python 学习（未完结）

1. 数据类型

1. Number-数字

   ​ int

   ​ float

   ​ bool

   ​ 1 or 0

   ​ complex-复数 a+bj

2. String-字符串

   变量[头下标:尾下标]

   ​ 1、反斜杠可以用来转义，使用r可以让反斜杠不发生转义。

   ​ 2、字符串可以用+运算符连接在一起，用*运算符重复。

   ​ 3、Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。

   ​ 4、Python中的字符串不能改变。

3. bool-布尔类型

4. List-列表

   截取语法：变量[头下表:尾下标]

   +：链接符 *重复操作

5. Tuple-元组

   tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2 )

   tinytuple = (123, 'runoob')

6. Set-集合

   创建：parame = {value01,value02,...}

   或者

   set(value)

7. Dictionary-字典=Map

8. isinstace和type区别：

   • type()不会认为子类是一种父类类型。
   • isinstance()会认为子类是一种父类类型。

   >>> isinstance(A(), A)

   True

   >>> type(A()) == A

   True

   >>> isinstance(B(), A)

   True

   >>> type(B()) == A

   False

2. 运算符

与java中的一样，需要注意海象运算符

# 传统写法
n = 10
if n > 5:
    print(n)

# 使用海象运算符
if (n := 10) > 5:
    print(n)

3. 生成器

yield:生成器函数是一种特殊的函数，它允许你在函数运行过程中暂停和继续执行，并且每次暂停时返回一个值。与普通函数不同，生成器函数使用 yield 关键字而不是 return 关键字。

eg:

def countdown(n):
    while n > 0:
        yield n //在此行暂停先返回
        n -= 1


if __name__ == '__main__':
    generator = countdown(10)

    print(next(generator)) //打印10
    print(next(generator)) //打印9
    print(next(generator)) ////打印8

    for value in generator:
        print(value)  //打印7，6，5，4，3，2，1

斐波那契数列：

def fibonacci(n):
    a, b, cont = 0, 1, 0
    while True:
        if (cont > n):
            return
        yield a
        a, b = b, a + b
        cont += 1

if __name__ == '__main__':
    f=fibonacci(10)
    while True:
        try:
            print(next(f), end=' ')
        except StopIteration:
            break

4. 函数

表达式：

   def 函数名（参数列表）:
    	函数体

2. 默认参数：

   def 函数名(参数1，参数2=3)：
   	函数体
   

3. 不定长参数

   ​ (加了星号 ***** 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数)

   def 函数名(参数1，*参数2)

   ​ (加了两个星号 ** 的参数会以字典的形式导入。)

   ​ (单独出现星号 *****，则星号 ***** 后的参数必须用关键字传入):

   >>> def f(a,b,*,c):
   ...     return a+b+c
   ... 
   >>> f(1,2,3)   # 报错
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   TypeError: f() takes 2 positional arguments but 3 were given
   >>> f(1,2,c=3) # 正常
   6
   >>>

5. lambda函数

Python 使用 lambda 来创建匿名函数。

lambda arguments: expression

• lambda:python的关键字，定义lambda函数
• arguments：参数列表，包含>=0个参数，但是必须在冒号前指定
• expression：用于计算并返回函数的结果

x = lambda a : a + 10
print(x(5))

6. 模块

import module1[,module2...]或者from modname import ...(可以是* 代表所有):指从一个包中导入

eg:引入其他文件中的方法

__name__属性：仅在该模块自身运行时执行

7. 输入输出

输入输出方式：

1. 表达式语句

2. print()函数

3. 文件对象的write()方法

   • 标准输出文件：sys.stdout

   • 格式化输出：str.format()

     >>>print('{}网址："{}!"'.format('Python', 'www.python.org'))
     Python网址："www.python.org!"
     或
     >>>print('{0} 和 {1}'.format('Google', 'Runoob'))
     Google 和 Runoob
     >>>print('{1} 和 {0}'.format('Google', 'Runoob'))
     Runoob 和 Google
     
     或
     >>> print('{name}网址： {site}'.format(name='菜鸟教程', site='www.runoob.com'))
     菜鸟教程网址： www.runoob.com

   • 将输出的值转换为字符串：

     • str()：函数返回一个用户易读的表达形式

     • repr()：产生一个解释器易读的表达形式

       >>>s="喜羊羊与灰太狼"
       >>>str(s)
       '喜羊羊与灰太狼'
       >>>x=2*7
       >>>repr(x)
       '14'

• 键盘读取：input()内置函数

str=input("请输入：")
print("内容是："，str)

• 读写文件open() 返回一个file对象

  open(filename,mode)

  -filename：路径

  -mode：打开文件的模式：只读(默认r)、写入、追加。

8. file文件

方法：

1. open(文件路径file,模式mode) 完整格式：open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

   buffering：设置缓冲

   encoding：一般使用utf8

   errors：报错级别

   newline：区分换行符

   closefd：传入的file参数类型

   opener：设置自定义开启器，开启其的返回值必须是一个打开的文件描述符

2. file.close() 关闭文件

3. file.flush() 将缓冲区的数据立即写入文件

4. file.fileno() 返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上

5. file.isatty() 文件连接到一个终端设备返回True，否则返回False

6. file.read([size]) 从文件读指定的字节数，如果没有或为负则读取所有

7. file.readline([size]) 读取整行，包括"\n"字符

8. file.readlines([sizeint]) 读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区

9. file.seek(offset[,whence]) 移动文件读取指针到指定位置

10. file.tell() 返回文件当前位置

11. file.truncate([size]) 从文件的首行首字符开始截断，截断文件为 size 个字符，无 size 表示从当前位置截断；截断之后后面的所有字符被删除，其中 windows 系统下的换行代表2个字符大小。

12. file.write(str) 将字符串写入文件，返回写入的字符串长度

13. file.writelines(sequence) 向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符

9. OS 文件/目录方法

os模块：处理文件和目录

1. os.access(path,mode) 检查权限模式
2. os.chdir(path) 改变当前工作目录
3. os.chflags(path,flags) 设置路径的标记为数字标记
4. os.chmod(path,mode) 更改权限
5. os.chown(path,uid,gid) 更改文件所有者
6. os.chroot(path) 改变当前进程的跟目录
7. os.close(fd) 关闭文件描述符fd
8. os.closerange(fd_low,fd_high) 关闭所有文件描述符，从fd_low(包含)到fd_high(不包含)，错误会忽略
9. os.dup(fd) 复制文件描述符
10. os.dup2(fd,fd2) 将一个文件描述符fd复制到另一个fd2
11. os.fchdir(fd) 通过文件描述符改变当前工作目录
12. ...

10. 错误和异常

1. 异常处理:

   • try except

   

   if __name__ == '__main__':
       while True:
           try:
               a = int(input("请输入一个数字："))
               break
           except ValueError:
               print("输入的不是数字，请重新输入！")

   • try except...else：

     

     if __name__ == '__main__':
         for i in sys.argv[1:]:
             try:
                 f = open(i, 'r')
             except IOError:
                 print("文件不存在！")
             else:
                 print('hhahh')
                 print(i, 'has', len(f.readlines()), 'lines')
                 f.close()

   • try-finally：

     

     def method3():
         try:
             a = 1 / 0
         except ZeroDivisionError:
             print("除数不能为0！")
         else:
             print("没有异常发生！")
         finally:
             print("都运行")
             
             
             
     result:
     除数不能为0！
     都运行

2. 抛出异常 ：raise

   语法：raise [Exception [, args [,traceback]]]

   def throw_error():
       if (x := 10) > 5:
           raise Exception("x should be less than 5")

3. 自定义异常：通常创建一个异常类继承或间接继承自Exception类

   class MyError(Exception):
       def __init__(self, message):   //Exception类默认的__init__()方法被覆盖
           self.message = message
       def __str__(self):
           return repr(self.message)
   
   def throw_my_error():
       if (x := 10) > 5:
           raise MyError("x should be less than 5")

11. 面向对象

Python：面向对象的语言

1. 类=属性(私有属性__name，类外部无法直接访问【双下划线开头】)+方法(第一个参数必须是self，必须有)+构造方法(__init__() 在实例化时会被调用)

   python中self表示实例，代表当前对象的地址，而 self.class 则指向类。

   类的专有方法：

   __init__	构造函数，在生成对象时调用
   __del__	析构函数，释放对象时使用
   __repr__	打印，转换
   __setitem__	按照索引赋值
   __getitem__	按照索引获取值
   __len__	获得长度
   __cmp__	比较运算
   __call__	函数调用
   __add__	加运算
   __sub__	减运算
   __mul__	乘运算
   __truediv__	除运算
   __mod__	求余运算
   __pow__	乘方

   class Person:
       def __init__(self, name, age):
           self.name = name
           self.age = age
       def say_hello(self):
           print("Hello, my name is {} and I am {} years old.".format(self.name, self.age))
           
   
   p1 = Person("Alice", 25)
   p1.say_hello()
   
   result:Hello, my name is Alice and I am 25 years old.

2. 继承

   单继承：class childClassName(parentClassName):

   ​ ...

   多继承：class childClassName(parentClassName1,parentClassName2):

   ​ ...

   class person():
       age = 0
       name = ""
   
       def __init__(self, age, name):
           self.age = age
           self.name = name
   
       def sayHello(self):
           print("Hello, my name is " + self.name + " and I am " + str(self.age) + " years old.")
   
   
   class student(person):
       grade = ''
   
       def __init__(self, age, name, grade):
           super().__init__(age, name)  # 调用父类的构造函数
           self.grade = grade
   
       def sayHello(self):  # 重写
           print("Hello, 我叫 " + self.name + " ， " + str(
               self.age) + " 岁了，是  " + self.grade + "年级.")
   
   
   s = student(18, "Tom", "3")
   s.sayHello()
   super(student, s).sayHello()  # 调用父类的方法
   
   
   result：Hello, 我叫 Tom ， 18 岁了，是  3年级.
              Hello, my name is Tom and I am 18 years old.

3. 运算符重载

   class Vector:
       def __init__(self, x, y):
           self.x = x
           self.y = y
       def __add__(self, other):
           return Vector(self.x + other.x, self.y + other.y)
       def __str__(self):
           return 'Vector (%d, %d)' % (self.x, self.y)
   
   Vector1 = Vector(2, 3)
   Vector2 = Vector(4, 5)
   print(Vector1 + Vector2)
    
   result：Vector (6, 8)