python笔记

原创已于 2025-08-30 14:20:00 修改 · 303 阅读

7 ·

CC 4.0 BY-SA版权

文章标签：

#python

于 2025-08-28 20:46:08 首次发布

python学习笔记

预备知识
- Python特点
  - Python 是一种解释型语言：这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
    - Python语言写的程序不需要编译成二进制代码。你可以直接从源代码运行程序。
    - 在计算机内部，Python解释器把源代码转换成称为字节码的中间形式，然后再把它翻译成计算机使用的机器语言并运行。
  - Python 是交互式语言：这意味着，您可以在一个 Python 提示符 >>> 后直接执行代码。
    - 这里指的就是python的交互模式；
  - Python 是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。
  - 可扩展性、可扩充性：如果需要一段关键代码运行得更快或者希望某些算法不公开，可以部分程序用C或C++编写，然后在Python程序中使用它们。
    - Python作为一种“胶水语言”（glue language）使用。使用Python将其他语言编写的程序进行集成和封装。
- Python 面向对象
  - 面向过程&面向对象
    - 面向过程：做一件事情，从头到尾，每一个细节都要关注，重点在于过程
    - 面向对象：做一件事情，用对象去做，不关心细节和过程，万物皆对象
  - 类&对象
    - 类：描述一类事物，一个抽象的概念，比如：人、动物、水果
    - 对象：是类的具象化比如：张三、李四、猫、狗
  - python中面向对象的三大特征
    - 封装
      - 面向对象编程的第一步----->将“属性和方法”封装到一个抽象的“类”中
      - 外界使用类创建对象，然后让对象调用方法对象方法的细节都被封装在类的内部；
    - 继承
      - 子类可以拥有父类的属性和方法
      - 单继承
         子类中可以使用爷爷类型的方法
      - 多继承
         一个子类可以继承多个父类；子类拥有所有父类的属性和方法
      - 方法重写：概念：在子类中书写和父类同名的方法特点：在类中调用方法，如果在子类中找到，直接执行子类中的方法如果子类中没有找到这个方法，去父类中找，找到了就调用父类中的方法，如果父类中没有找到，则报错私有方法和属性：语法格式： def __函数名(self): def __init__(self): self.__money = "自己猜" 特点：不允许被外界访问，只能自己使用如果外界必须访问，那么可以提供一个公共的方法，访问私有属性
    - 多态
      - 一个对象的多种形态（一父多子）
- python的运行方式
  - 交互模式下执行 Python
    - Windows下：在开始菜单找到“命令提示符”，打开，就进入到命令行模式；在命令行模式输入： python 即可进入 Python 的交互模式
    - Linux 下：直接在终端输入 python，如果是按装了 python3 ，则根据自己建的软连接的名字进入对应版本的 Python 交互环境，例如建立软连接使用的 python3，这输入 python3。
    - 进入交互模式就是一个极其简单的编辑界面，可以实时的显示代码运行结果；不需要print()函数就可以；
    - 退出交互模式，直接输入 exit() 或者quit() 即可
  - 通过脚本输出
    - 编写.by文件，通过文件运行；
  - 在脚本文件中指定 python 程序所在路径，修改文件为可执行文件，然后直接运行文件
    - 在Linux下：
      - 添加解释器 #!/usr/bin/python3
- 运算符与表达式
  - **
    - 幂
      - x ** y
        返回x的y次幂
         3 ** 4得到81（即3 * 3 * 3 * 3）
  - //
    - 取整除
      - 返回商的整数部分
         4 // 3.0得到1.0
        相当于强制取整
  - 用and; or; not；表示与或非
  - 运算符优先级（从低到高）
    - Topic1

- 全局变量
  - 全局变量是指在函数外部定义的变量，可以在程序的任何地方被访问和修改。在函数内部，如果要修改全局变量的值，需要使用 `global` 关键字声明，可以一次声明多个
  - globals()
    - 它返回当前全局作用域中的所有变量和它们的值，以字典的形式呈现。这个字典包含了当前模块中定义的所有变量，包括函数、类、模块等。
- if __name__ == "__main__" ：
  - 判断当前模块是否是主程序入口
  - 当一个 Python 文件被直接运行时，其 `__name__` 属性的值为 `'__main__'`
  - 当它被作为模块导入时，`__name__` 的值为模块名
编程规范
- 缩进规则
  - Python 采用代码缩进和冒号（ : ）来区分代码块之间的层次
    - 行尾的冒号和下一行的缩进，表示下一个代码块的开始，而缩进的结束则表示此代码块的结束
  - 注：
    - 统一使用 4 个空格进行缩进，不要用tab（制表符）也不要tab和空格混用；不然再不同的平台可能出现错误；（IDE里用tab是因为提前进行了设置，但是也不要混用）
  - 逻辑行和物理行
    - 物理行是我们在编写程序时看到的，逻辑行则是python看到的
    - python中分号;标识一个逻辑行的结束，但是实际中一般每个物理行只写一个逻辑行，可以避免使用分号；python里不会写分号；
    - 使用
      - 使用";"号将两个或多个逻辑行合并成一个物理行。
      - 使用"\"号连接两个物理行。
        \的使用被称为‘明确的行连接’；告诉你，我俩是一行的，打死不分开；
      - 字典、列表等变量赋值语句，是可以直接书写为多个物理行的；
        Topic1

- 注释
  - Python中使用 # 进行注释，我们在使用# 的时候，# 号后面要空一格
  - 在行内注释的时候，中间应该至少加两个空格
  - 多行注释
    - ''' '''
- 空格
  - 在二元运算符两边各空一格
  - 不要在逗号、分号、冒号前面加空格，但应该在它们后面加（行尾不用加）
  - 函数的参数列表中，逗号之后要有空格
  - 函数的参数列表中，默认值等号两边不要添加空格
  - 通常情况下，在运算符两侧、函数参数之间以及逗号两侧，都建议使用空格进行分隔。
- 空行
  - 使用必要的空行可以增加代码的可读性，通常在顶级定义（如函数或类的定义）之间空两行，而方法定义之间空一行，另外在用于分隔某些功能的位置也可以空一行。
- 模块导入
  - 导入总应该放在文件顶部，位于模块注释和文档字符串之后，模块全局变量和常量之前。
  - 导入应该按照从最通用到最不通用的顺序分组，分组之间空一行：
    - 标准库导入；第三方库导入；应用程序指定导入；
- 命名规范
  - 模块
    - 模块尽量使用小写命名，首字母保持小写，尽量不要用下划线；
  - 类名
    - 类名使用驼峰(CamelCase)命名风格，首字母大写，私有类可用一个下划线开头；
  - 函数名
    - 函数名一律小写，如有多个单词，用下划线隔开；
  - 私有函数
    - 私有函数可用两个下划线开头；
      - 只是一个约定，实际类外还是可以访问
  - 变量名
    - 变量名尽量小写, 如有多个单词，用下划线隔开；
  - 常量
    - 常量采用全大写，如有多个单词，使用下划线隔开；
  - 注：
    - 除了常量和类大写以外，其他全部小写；除了类用大写分隔以外，其他全部用下划线；只有私有的用下划线开头；
- 引号用法
  - 自然语言使用双引号；
  - 机器标识使用单引号；
  - 正则表达式使用双引号；
  - 文档字符串 (docstring) 使用三个双引号；
输入输出
- 输出
  - printf
    - 打印abc并换行
      - print("abc")
    - 打印abcd
      - print("abc%s" % "d")
    - 打印abcdefg
      - print ("abc%sef%s" % "d", "g")
    - 打印不换行
      - print("a", end = " ")
- 输入
  - 读取键盘输入
    - input()
      - 整行输入，返回的是遇到换行符的之前整个的字符串，如果需要一个一个输入，可以利用split()函数拆分；
- 正无穷
  - float('inf')
函数
- 定义函数
  - 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
  - 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
  - 函数内容以冒号起始，并且缩进。
  - return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
  - 语法
    - def functionname( parameters ): '''函数_文档字符串''' function_suite return [expression]
- 调用函数
  - 按值传递参数和按引用传递参数
    - 所有参数（自变量）在Python里都是按引用传递。
      - 如果你在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了。
      - 注：
        引用传递现在暂时理解为C里面的指针作为形参的传递；
        ruby也是一样的；
    - 按值传递参数
      - 常量的传递
  - 参数
    - 关键字参数
      - 如果某个函数有很多参数，而现在只想指定其中的部分，那么可以通过命名为这些参数赋值；
      - 注
         特定赋值的就是给定的值，其余的参数按照位置递增；一旦使用关键字复制参数，则后面的参数都得使用关键字赋值；
    - 缺省参数（默认参数）
      - 定义函数的时候，对一些参数设置默认值，如果调用的时候没有赋值，那就使用默认值；
      - 注：
        只有在形参表末尾的那些参数可以有默认参数值；默认参数只能从后往前；
    - 不定长参数
      - 需要一个函数能处理比当初声明时更多的参数
      - 语法
         def functionname([formal_args,] *var_args_tuple ): "函数_文档字符串" function_suite return [expression]
        注：
        加了星号（*）的变量名会存放所有未命名的变量参数；所有未命名的参数实际需要一个功能代码处理；
      - 实例
         # 不定长参数的例子 def printinfo( arg1, *vartuple ): "打印任何传入的参数" print("输出: ") print( arg1 ) for var in vartuple: #var竟然都不需要定义，直接用 print( var ) return # 调用printinfo 函数 printinfo( 10 ) printinfo( 70, 60, 50 )
        输出: 10 输出: 70 60 50
- 匿名函数
  - lambda的主体是一个表达式，而不是一个代码块
  - 语法
    - lambda [arg1 [,arg2,.....argn]]:expression
  - 实例
    - # 可写函数说明 sum = lambda arg1, arg2: arg1 + arg2 # 调用sum函数 print "相加后的值为 : ", sum( 10, 20 ) print "相加后的值为 : ", sum( 20, 20 )
- global语句
  - 定义变量时使用，使函数内的变量变为全局变量；
- 函数多态
  - 在不同的数据类型下，同一个函数可以有不同的表现形式
  - def add(x, y): return x + y
类&继承
- 面向对象术语简介
  - 类(Class):
    - 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。
  - 对象：
    - 通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法
    - Python中一切皆对象。不管是我们自己定义的类、6种基本数据类型还是内置的类(第三方类)等都称作为对象
  - 方法：
    - 类中定义的函数
  - 方法重写：
    - 如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写
  - 多态：
    - 对不同类的对象使用同样的操作
      - 相同的程序(代码)，可以处理不同的数据类型
  - 封装：
    - 对外部世界隐藏对象的工作细节
  - 实例变量：
    - 定义在__init__方法中的变量，只作用于当前实例的类
- Python类的定义
  - python中定义类使用class关键字，class后面紧接类名，类名通常是大写开头的单词
  - 语法
    - class ClassName: 语句1 ... 语句n
  - 注：
    - 类定义与函数定义(def语句)一样：只有在被执行才会起作用；即在定义阶段只是语法检查；
    - 类是属性和方法的组合
      - 一个对象的特征称为"属性"，比如：i=50；i就是一个属性；
      - 一个对象的行为称为"方法"，其实就是函数；
      - 属性在代码层面上来看就是变量，方法实际就是函数
    - 进入类定义时，就会创建一个新的命名空间，并把它用作局部作用域；
    - 正常离开(从结尾出)类定义时，就会创建一个类对象；可以理解为这个类可以正常使用了；
- 类对象
  - 类只是一个抽象的概念，只有经过实例化后(获得实例对象)，才会有意义，才能正常使用这个类中的属性和方法；只有实例化之后，这个实例对象才是一个完整的对象；
  - 注：
    - 类的实例化，可以理解为一种赋值（和C里的结构体很相似）；
- 实例对象
  - 格式：实例对象名 = 类名()
    - 一个类可以实例化出无数个实例对象：这些实例对象之间的属性和方法都是独立的；
  - 实例对象仅支持一个操作：属性引用
    - 实例对象名.属性名
    - 实例对象名.方法名()
- self参数
  - self代表的当前的实例对象本身
    - 一个抽象类实例化后，实例对象为a，那么此时self就代表实例对象a
    - 一个抽象类实例化后，实例对象为b，那么此时self就代表实例对象b
  - 注：
    - 现在的理解这个self是实例对象名，给起了个专有的名字；
- 类变量与实例变量
  - 类变量
    - 类变量是所有实例公用的属性
    - 在类中任意地方(所有方法中)都可以使用"类名.类属性名"来调用类属性
    - 在类外任意地方都可以使用"类名.类属性名"或"实例名.类属性名"来调用类属性（但是都用实例名）
  - 实例变量
    - 实例变量：是每个实例都独有的数据(也可以叫"实例属性")，(其实，类实例化之后还是每个实例都可以用；)
    - 实例变量是定义在__init__方法中的
      - _init__()方法也是类中的一个方法，因此其第一个参数也必须是self
    - 类中的self参数就相当于一个形参，当类实例化后，实例对象就相当于self参数的实参
    - 实例
      - class People(): #类属性 country = "china" face_value = 100 def __init__(self,name): #实例属性 self.name = name def speak(self, age): # 类中调用类属性：类名.属性名 # 类中调用实例属性：self.属性名 print("我的名字是：%s,来自：%s，年龄是：%s, 颜值是：%d" % (self.name,People.country,age,People.face_value)) #print里面，country，face_value的使用必须是类名.变量名 a = People("zhoubing") a.speak(27) print("****************************************************************************") b = People("guochao") b.face_value = 80 b.speak(26) print("****************************************************************************") c = People("shanyi") c.speak(21)
      - 解决
         因为speak里使用的还是类的people.value，你个小傻子，想要这里的修改有用的话，value这个变量就得用实例变量；
  - 注：
    - 通过"实例对象名.属性名"来覆盖类属性，只会影响到当前实例对象，不会影响到其他实例对象中的类属性，因为他只是改了他的属性值，并没有改类里的属性值；
    - 通过"类名.属性名"来覆盖类属性，会影响到所有实例的类属性
    - 类变量是所有对象共有，其中一个对象将它值改变，其他对象得到的就是改变后的结果；而实例变量则属对象私有，某一个对象将其值改变，不影响其他对象；（这里的类变量的改变指的是用类名.变量名去改变）
    - 类属性就是类的变量，实例属性就是__init__中的变量；
- 类的使用
  - 调用类属性：
    - 类中访问类变量：类名. 类变量名
    - 类外访问类变量：类名.类变量名或实例名.类变量名
  - 调用实例属性：
    - 类中访问实例变量：self.实例变量名
    - 类外访问实例变量：实例名.实例变量名
  - 调用实例方法：
    - 类中访问实例方法：self.方法名(参数)或类名.方法名(self,参数)
    - 类外访问实例方法：实例名.方法名(参数)
  - 类中定义方法的要求
    - 在类中定义方法时，第一个参数必须是self，除第一个参数外，类的方法和普通的函数没什么区别；
    - 虽然在定义方法时会定义一个self参数，但是不管是在类中或是在类外调用方法都不用传递self，其他参数正常传入；（定义的时候必须用它，实际使用的时候，不会有这个参数的传递）；
  - 注
    - 创建一个对象也叫做类的实例化，即x = MyClass()；（注意是有小括号的）
- 属性绑定
  - 这里现在我理解为动态的添加和删除
  - objname.attr = attr_value
    - 若属性attr已经存在，绑定操作会将属性名指向新的对象
    - 若不存在，则为该对象添加新的属性，后面就可以引用新增属性
  - Python类实例有两个特殊之处：
    - __init__在实例化时执行
      - 是创建实例化变量的一个函数
    - Python实例对象调用方法时，会将实例对象作为第一个参数传递因此，__init__方法中的self就是实例对象本身；
  - 注：
    - 绑定（添加和删除）必须用的是类名
- 实例属性引用规则
  - 总是先到实例对象中查找属性，再到类属性中查找属性；即有相同的，先用实例属性，后用类属性；
  - 属性绑定语句总是为实例对象创建新属性，属性存在时，更新属性指向的对象
- 可变类属性引用
  - 为类里定义了一个列表（字典也可以），可以用列表函数进行动态的操作；
- 类中的方法
  - 实例方法
    - 在类编程中，一般情况下在类中定义的方法、函数默认都是实例方法
    - 绑定到对象实例上的方法，实例方法的第一个参数通常是self，表示该方法是绑定到对象实例上的。
  - 类方法
    - 类方法通常用于实现与类相关的操作，例如创建类的实例对象或者修改类的属性。
    - Python中的类方法和实例方法类似，但类方法需要满足以下要求：
      - 类方法至少需要包含一个参数，与实例方法不同的是该参数并非self，而是python程序员约定俗成的参数：cls(cls表示当前类对象)
      - Python会自动将类本身绑定到cls参数(非实例对象)，故在调用类方法时，无需显式为cls参数传递参数
      - 类方法需要使用修饰语句：＠classmethod
    - 调用类方法
      - 类方法推荐使用类名直接调用，当然也可以使用实例对象来调用(不推荐)
      - 类方法中是不能调用实例变量的，但是可以调用类变量：因为类方法是指向类的，而不是实例对象的
  - 静态方法
    - 类中的静态方法，实际上就是众所周知的普通函数，存在的唯一区别是：
      - 类静态方法在类命名空间中定义，而函数则在程序的全局命名空间中定义
    - 要求
      - 类静态方法没有self、cls这样的特殊参数，故Python解释器不会对其包含的参数做任何类或对象的绑定
      - 类静态方法中无法调用任何类和对象的属性和方法，类静态方法与类的关系不大
      - 静态方法需要使用＠staticmethod修饰
    - 静态方法的调用
      - 既可以使用类名，也可以使用类对象
- 与类相关的方法
  - __init__方法
    - 作用就是在实例话的时候需要强制输入必要的参数，否则会报错；
    - class Student(object): def __init__(self, name_1, score_1): self.name = name_1 self.score = score_2
    - 注
      - 参数只是用来传递数据的，不是实际的变量；
  - __new__()方法
    - 作用也是在实例话的时候强制输入必要的参数，不过__new__()方法的第一个参数就是这个类（cls），
    - __new__方法的第一个参数是这个类，而其余的参数会在调用成功后全部传递给__init__方法初始化；即实例话传递的参数，必须得先在_new_（）里运行，运行之后的返回值，传递到_init_()方法，用于其自身的初始化；如果_new()_的返回值是错误的，那_init_都不会执行；
    - 例
      - class B(): def __new__(cls): print("__new__方法被执行") return super().__new__(cls) def __init__(self): print("__init__方法被执行") b = B()
  - super()方法
    - （目的是用来解决多重继承时父类的查找问题），实际用的时候只要在子方法里调用父方法就会用，也就是在方法里调用该方法；
    - 在_init_里调用_init_
      - 明确指定
         class C(P): def __init__(self): P.__init__(self) print 'calling Cs construtor'
      - 使用super()方法
         class C(P): def __init__(self): super(C,self).__init__() print 'calling Cs construtor' c=C()
    - 多重继承
      - class A: def m(self): print('A') class B: def m(self): print('B') class C(A): def m(self): print('C') super().m() C().m()
      - 注：
        这里最后的super().m()是在调用父类的方法；
- 继承
  - 新建的类可以继承一个或多个父类；子类可以直接访问(调用)父类的静态属性和方法；
    - 继承多个类，之间用逗号隔开；
  - 方法重写
    - 父类的方法，在子类中不完全适用，可以在子类中进行重写（修改）；
  - 子类中调用父类的方法
    - 明确指定
      - 类名.方法
    - 使用super()方法
      - super()方法的第一个参数要指定调用的父类名，默认是cls;
- python类和c++类的区别
  - 1. 语法：Python的类定义比C++简单，不需要显式地声明构造函数和析构函数，也不需要使用关键字public、private和protected来控制成员变量和成员函数的访问权限。
  - 2. 继承：Python支持多重继承，而C++只支持单一继承。Python的继承关系是通过类的基类列表来实现的，而C++则是通过类的继承方式来实现的。
  - 3. 动态性：Python的类是动态的，可以在运行时添加、删除或修改类的属性和方法，而C++的类是静态的，一旦定义就不能再修改。
  - 4. 内存管理：Python的类使用垃圾回收机制来管理内存，而C++的类需要手动管理内存。
  - 5. 多态性：Python的类支持运行时多态，而C++的类支持编译时多态。Python的多态性是通过方法重写和方法重载来实现的，而C++的多态性是通过虚函数和纯虚函数来实现的。
程序结构
- 分支
  - 分支结构
    - if
      - if 条件表达式：语句一语句二 ......
  - 双向分支
    - if…else…
      - if条件表达式: 语句一语句二 ... else: 语句一语句二 ...
  - 多路分支
    - if...elif...elif...else:
      - if 条件表达式：语句1 … elif 条件表达式：语句1 … elif 条件表达式：语句1 … else: 语句1
  - 三目运算
    - a = b if 条件表达式 else c
  - 注
    - 注意语句最后的冒号
    - python没有switch语句
- 循环
  - for循环
    - for 变量 in 序列：语句1 语句2 ...
  - for-else语句
    - for循环结束的时候，有时候需要执行一些收尾工作，此时需要使用else语句;
  - other
    - pass
      - 只是占位符号，代表这句话啥也不干，没有跳过功能
    - range函数（生成有序数列）
      - range(1,101)：生成一个从1到100的数字序列
  - while循环
    - while 条件表达式：语句块
    - while 条件表达式：语句块1 else：语句块2
数据结构
- Number（数字）
  - int（整型）
    - Py3.x 去除了 long 类型，现在只有一种整型 - int，表示为长整型
    - 整数可以是任何长度，只受到可用内存的限制
  - float（浮点型）
    - 浮点数精确到 15 位小数（截断的时候，>=3就进位）
  - complex（复数）
    - 复数以 x + yj 的形式写成，其中 x 是实部，y 是虚部
    - c = 5+6j
  - type() 函数
    - 获取变量或值的类型
    - type(i)
  - isinstance() 函数
    - 检查一个对象是否属于一个特定的类（数据类型）
    - isinstance(c, int)
      - 返回值是布尔值
- String（字符串）
  - 字符串是 Unicode （统一码）字符的序列
  - 字符串可以被索引和截取
    - 变量[头下标:尾下标]
      - 索引值以 0 开始，-1 为从末尾的开始位置
  - 加号 +：是字符串的连接符
  - 星号 * ：表示复制当前字符串，紧跟的数字为复制的次数
- List（列表）
  - 列表用 [] 标识，内部元素用逗号分隔；而且同一个list可以是不同的类型；
  - 可以被索引和截取（和字符串一样）
  - 使用函数len()查看长度
  - 使用del()可以删除列表中的项
- 二维数组
  - 创建一个3*4的二维数组
    - a = [[0] * 3 for i in range(4)]
- 元组（tuple）
  - 元组与列表相同，也是有序序列，唯一的区别是元组是不可变的
  - 元组用 () 标识，内部元素用逗号分隔
  - tuple比list速度快；对不需要修改的数据进行‘写保护’，可以使代码更安全
  - 空元组&包含一个元素的元组
    - tup1 = () # 空元组
    - tup2 = (5, ) # 一个元素，需要在元素后添加逗号
  - tuple与list相互转换
    - 使用内置的函数list()和tuple()
    - 实例
      - l = [1, 2, 3] print l # [1, 2, 3] t = tuple(l) print t # (1, 2, 3) l1 = list(t) print l1 #[1, 2, 3]
  - 元组函数（元组名.函数名）
    - count(value)
      - 返回元组中值为value的元素的个数
    - index(value, [start, [stop]])
      - 返回列表中第一个出现的值为value的索引，如果没有，则异常 ValueError
  - 注
    - 虽然元组中的元素不可变，但它可以包含可变的对象，例如：List（列表）；并且这个列表里的元素是可以更改的，只是不能更改这个列表的名字而已；
    - 嵌套之后的使用和C里面的二维数组很相似，可以索引和截取；
- Set（集合）
  - 集合是一个无序不重复元素集
    - 无序的，那么索引就没有任何意义
    - 不重复，是指集合中相同的元素会被自动过滤掉，只保留一份
  - 集合用 {} 标识，内部元素用逗号分隔
  - 创建集合
    - 可以使用大括号 {} 或者 set() 函数创建集合，但是创建一个空集合，必须使用 set() 而不是 {}，因为 {} 用于创建一个空字典；
    - s = {1, 2, 3}
    - s = set('123') #默认就是迭代形式，一个字符一个元素；
    - s = set() #空集合
  - 集合之间的运算
    - a | b # 并集
    - a - b # 差集
    - a & b # 交集
    - a ^ b # 对称差 - 不同时在a和b中的元素
- Dictionary（字典）
  - 定义
    - 字典是键值对的无序集合
    - 字典用 {} 标识，其中的每个元素都以 key:value 对的形式出现，key 和 value 可以是任何类型；
    - 字典中的 key 必须是唯一的
    - 可以用 key 来检索相应的 value，但相反则不行
    - 每个键与值必须用冒号隔开(:)，每对用逗号分割，整体放在花括号中({})；值可以取任何数据类型，但必须是不可变的，如字符串，数或元组；
  - 常规操作
    - d = {} # 创建空字典
    - d[key] = value
      - 如果字典中已有key，则为其赋值为value，否则添加新的键值对key/value；
      - d['name'] = 'Python' # 增加新的键/值对
    - 判断字典中是否有某键，可以使用in 或 not in；
    - del d[key]
      - 删除键值对
  - 内置函数（字典名.函数名）
    - d.keys() # 所有键
    - d.values() # 所有值
    - d.clear() # 清空字典
- 序列
  - 序列类型是指容器内的元素从0开始的索引顺序访问，一次可以访问一个或者多个元素；列表、元组和字符串都是序列；集合也是序列，不过不支持索引；
  - 序列的两个主要特点是索引操作符和切片操作符
    - 索引可以得到特定元素
    - 切片可以得到部分序列
      - 切片操作符中的第一个数（冒号之前）表示切片开始的位置，第二个数（冒号之后）表示切片到哪里结束；即第一个包含，第二个不包含；
      - 如果不指定第一个数，Python就从序列首开始
      - 如果没有指定第二个数，则Python会停止在序列尾
      - 可以用负数做切片，负数用在从序列尾开始计算的位置；
- 数据类型之间的转换
  - 可以使用不同的类型转换函数来转换不同的数据类型，例如：int()、float()、str() 等
  - 从 int 转换为 float
  - 从 float 到 int 的转换，值将会被截断（使其接近零），即直接抛弃小数位；
  - 字符串的转换必须包含兼容的值
    - 字符串转int或者float你必须得是个数，字母a不行；
  - 可以将一个序列转换为另一个序列
    - set(); tuple(); list()
    - 要转换为字典，每个元素必须是一对；原本的数据必须是字典这样的形式的；
- 队列
  - list实现
    - 入队
      - list.append()
    - 出队
      - list.pop(0)
- 栈
  - list实现
    - 入栈
      - list.append()
    - 出栈
      - list.pop()
- 堆
  - heapq模块
    - 实现的是小顶堆，对插入的值去负数就可以实现大顶堆，所有的操作都得是取负数
    - 导入
      - import heapq
    - 创建一个空堆
      - heap = []
    - 将列表转化为堆
      - heapq.heapfiy(heap)
    - 插入
      - heapq.heappush(heap, 3)
    - 弹出最小元素
      - heapq.heappop(heap)
    - 查看最小元素，但是不弹出
      - heap[0]：就是列表下标访问
数据结构内置的函数
- 列表（list）
  - 遍历整个列表
    - for a in num: print a
    - for i in range(len(num)): print num[i]
  - 列表操作符+
    - 列表对+和的操作符与字符串相似。+号用于组合列表，*号用于重复列表
    - c=a+b
    - c=a*4
  - 列表函数（列表名.函数名）
    - help(list)
      - 相关的函数可以使用help命令获得
    - 增加
      - append（value）
        向列表尾添加项value
        l = [1, 2, 2] l.append(3) #[1, 2, 2, 3]
      - insert(i, value)
        向列表i位置插入项vlaue，如果没有i，则添加到列表尾部
      - extend(list2)
        向列表尾添加列表list2
        实例
         l = [1, 2, 2] l1 = [10, 20] l.extend(l1) print l #[1, 2, 2, 10, 20]
    - 删除
      - pop([i])
        返回i位置项，并从列表中删除；如果不提供参数，则删除最后一个项；如果提供，但是i超出索引范围，则异常IndexError
        实例
         l = [0, 1, 2, 3, 4, 5] print l.pop() # 5 print l #[0, 1, 2, 3, 4] print l.pop(1) #1 print l #[0, 2, 3, 4]
      - remove(value)
        删除列表中第一次出现的value，如果列表中没有vlaue，则异常ValueError
      - clear()
    - 查找
      - index(value, [start, [stop]])
        返回列表中第一个出现的值为value的索引，如果没有，则异常 ValueError
      - count(value)
        返回列表中值为value的项的个数
         l = [1, 2, 2] print l.count(2) # 2
    - 修改
      - sort(cmp=None, key=None, reverse=False)
        列表排序，仅支持int型；
        cmp: 比较函数
         key: 主要用来比较的元素
         reverse: 排序方式：True:降序排列；False:升序排列
         默认为升序排列
      - reverse()
        列表反转
         l = [1, 2, 3] l.reverse() print l #[3, 2, 1]
    - 其他
      - copy()
        返回一个副本(浅复制)
- 元组（tuple）
  - help(tuple)查看，有的函数和list一样；
  - 命名元组
    - Python有一个类似tuple的容器namedtuples（命名元组），位于collection模块中。namedtuple是继承自tuple的子类，可创建一个和tuple类似的对象，而且对象拥有可访问的属性。在c/c++中，对应的数据类型是结构体struct。
- 字典（dict）
  - 字典函数（字典名.函数名）
    - 增加/修改
      - 下标操作
         d[key] = value,update
      - update(dict2)
        把dict2的元素加入到dict中去，键字重复时会覆盖dict中的键值
         实例
         d = {1:"one", 2:"two", 3:"three"} d2 = {1:"first", 4:"forth"} d.update(d2) print d #{1: 'first', 2: 'two', 3: 'three', 4: 'forth'}
      - copy()
        返回字典的一个副本(浅复制)
        实例
         d1 = {"1":"one", "2":"two"} d2 = d1.copy() print d2 #{'1': 'one', '2': 'two'}
    - 删除
      - pop(key, [default])
        若字典中key键存在，删除并返回dict[key]（告诉你删除了哪一个），若不存在，且未给出default值，引发KeyError异常
         实例
         d9 = {1:"one", 2:"two", 3:"three"} print d9.pop(1) #one print d9 #{2: 'two', 3: 'three'} print d9.pop(5, None) #None try: d9.pop(5) # raise KeyError except KeyError, ke: print "KeyError:", ke #KeyError:5
      - popitem()
        随机删除：删除任意键值对，并返回该键值对，如果字典为空，则产生异常KeyError
        实例
         d10 = {1:"one", 2:"two", 3:"three"} print d10.popitem() #(1, 'one') print d10 #{2: 'two', 3: 'three'}
      - clear()
      - del语句
    - 访问
      - 单个元素
         下标
         get(key,[default])
        返回字典dict中键key对应值，如果字典中不存在此键，则返回default 的值(default默认值为None)
        实例
         d5 = {1:"one", 2:"two", 3:"three"} print d5.get(1) #one print d5.get(5) #None print d5.get(5, "test") #test
        
        setdefault(key,[default])
        若字典中有key，则返回vlaue值，若没有key，则加上该key，值为default，默认None；default可以是字符串，列表，字典；
        实例
         d = {1:"one", 2:"two", 3:"three"} print d.setdefault(1) #one print d.setdefault(5) #None print d #{1: 'one', 2: 'two', 3: 'three', 5: None} print d.setdefault(6, "six") #six print d #{1: 'one', 2: 'two', 3: 'three', 5: None, 6: 'six'}
      - 遍历
         keys()
        返回一个包含字典中所有键的列表
        
         values()
        返回一个包含字典中所有值的列表
        
         items()
        返回一个包含字典中(键, 值)对元组的列表
         实例
         d7 = {1:"one", 2:"two", 3:"three"} for item in d7.items(): print item #(1, 'one') #(2, 'two') #(3, 'three') for key, value in d7.items(): print "%s -- %s" % (key, value) #1 -- one #2 -- two #3 -- three
  - 字典遍历
    - 直接for in遍历
      - for x in d: print(x)
      - 直接用for in 遍历字典，遍历的是字典的key
    - keys函数遍历
      - for x in d.keys(): print(x)
    - values函数遍历
      - for x in d.values(): print(x)
    - items函数遍历
      - for x in d.items(): print(x)
      - for k, v in d.items(): print(k, v)
  - 默认字典
    - 默认字典是defaultdict
  - 有序字典
    - 有序字典是OrderedDict（第一个字母大写）
    - 有序字典会保持插入的顺序
- 集合（set）
  - 集合函数（集合名.函数名）
    - 详细操作：
      - https://blog.youkuaiyun.com/business122/article/details/7541486（Google的python书签里有）
- 成员运算符
  - 用于判断一个元素是否在容器中
  - in/not in
- 字符串
  - 全转换为小写
    - str.lower()
  - 全转换为大写
    - str.upper()
  - 字符串格式
    - "%s"%("str")
      - %s相当于一个占位符，将会被%符号后（）里的东东取代
    - "%5s%-7s"%("str1", "str2")
      - 表示取代第一个字符至少是5个字符，不够再左面补空格，-表示在右面补空格，多了和5个一样；
    - ohters
      - %f浮点占位符
         %%
      - %E
      - %d
      - %X
      - %n
      - %o
      - %.2f
        小数点后保留两位
常用内置函数
- 数学相关
  - abs(x)
    - 返回一个数的绝对值。参数可以是普通的整数，长整数或者浮点数。如果参数是个复数，返回它的模。
  - divmod(x,y)
    - 结合除法和余数运算，返回包含商和余数的元组
    - divmod(5,2)
      - (2, 1)
  - pow(x, y[, z])
    - pow(x,y)返回x的y次方，如果z存在即pow(x,y,z)，其结果等于pow(x,y)%z
    - pow(2,3)
      - 8
    - pow(2,3,3)
      - 2^3%2(取余)
    - round(x[, n])
      - 返回浮点数x的四舍五入的值，其中n值，表示小数点后的位数，（默认是1位）
  - min(x[,y,z…])
    - 返回给定参数和最小值
  - max(x[,y,z…])
    - 返回给定参数和最大值
    - 注
      - 参数可以为序列，但是得是相同的数据类型（int 和序列也不行，int 和 float可以，str 和int float不行），相同的序列值比较第一值的大小；
  - sum(iterable[,start])
    - sum()函数对序列进行求和运算
    - sum([1,2,3,4])
    - sum(range(101))
  - range()
    - range(start, stop, step)
    - 逆序
      - range(start, stop, -1)
    - 注：
      - `range()` 返回的是一个可迭代对象，而不是一个列表。如果需要将其转换为列表，可以使用 `list()` 函数。
      - 区间是左闭右开的
- 进制转换
  - oct(x)
    - 用于将一个整数转换为八进制
  - hex(x)
    - 用于将10进制数转换为16进制数
  - chr(i)
    - 整数转字符，数字的范围为range(0,256)
  - bin(x)
    - 返回一个整数的二进制表示
- 类型转换
  - bool([x])
    - bool()函数将参数转换为bool类型，如果没有给参数则返回False
  - int(x,base=10)
    - int()函数用于将一个数字型的字符串转换为整型。参数base表示进制数，默认为十进制；
  - float([x])
    - float()函数用于将整数和字符串转换成浮点数
  - str(object)
    - str()函数将对象转换为可阅读的样式
  - list([iterable])
    - list()函数根据输入的可迭代的参数，创建一个新的列表
  - tuple([iterable])
    - tuple()函数根据输入的可迭代的参数，创建一个新的元组
  - dict([iterable])
    - dict()函数根据传入的参数，创建一个新的字典
  - set([iterable])
    - set()函数根据参数创建一个新的集合
  - ord(char)
    - 字符转int
  - frozenset([iterable])
    - frozenset()函数返回一个冻结的set集合，其不能添加和删除元素
- 序列相关
  - len(object)
    - 返回字符串或者序列的长度
  - range([start,]stop[,step])
    - 创建一个整数列表
    - start : 生成的整数从start开始，可省略，默认为0
    - end : 生成的整数以end结束，但不包含end
    - step : 步长，默认为1
    - 注
      - start不能小于end
      - range(0) # range(0,0)为空
  - zip([iterable,…])
    - zip()函数聚合传入的一个到多个迭代器相同位置的元素生成一个新的元组类型的迭代器
    - 实例
      - x = [1,2,3] y = ['a','b','c'] z = [4,5,6] xy = zip(x,y) xy = set(xy) print(xy) xyz = zip(x,y,z) xyz = set(xyz) print(xyz) dxy = dict(xy) print(dxy)
    - 注：
      - 可以使用这个把两个序列生成字典的形式，然后再转化为字典；
      - zip返回的值没发直接输出（是个地址），需要再进行类型转化（vscode是这样的），不过可以正常的进行对元组操作，因为结合之后的就是个元组；
  - sorted()
    - sorted()函数对所有可迭代的对象进行排序操作
    - sorted(iterable, cmp=None, key=None, reverse=False)
      - iterable：= 需要排序的东东，比如数组，字典
      - cmp: 比较函数
      - key: 主要用来比较的元素
      - reverse: 排序方式：True:降序排列；False:升序排列
         默认为升序排列
    - 是稳定排序
    - 实例
      - >>> sorted([1,2,3,4], reverse=False) #升序排列 [1, 2, 3, 4]
      - 字典按照key或者value排序，返回的是一个排序后的元组列表。
        sorted_dict = sorted(my_dict.items(), key=lambda x: x[0])
        sorted_dict = sorted(my_dict.items(), key=lambda x: x[1])
  - reversed(seq)
    - reversed()反转序列，生成一个新的序列
  - enumerate(iterable[, start])
    - enumerate()函数用于将一个可遍历的数据对象，组合为一个索引序列，同时包含索引和数据。其中参数start表示参数下标（索引）的起始位置；
    - 实例
      - >>> a = [1,2,3,4] >>> list(enumerate(a)) [(0, 1), (1, 2), (2, 3), (3, 4)] >>> list(enumerate(a,2)) [(2, 1), (3, 2), (4, 3), (5, 4)]
    - 注：
      - 就是把一个序列变为一组一组的集合，每组的第一个值你还可以自己指定；感觉这个在构造字典的时候超级好用哈；
  - iter()
    - iter()函数用于创建一个迭代器
    - next()
      - next()函数返回迭代器的下一个元素
    - 实例
      - >>> a = iter(range(10)) >>> next(a) 0 >>> next(a) 1 >>> next(a) 2
  - all(iterable)
    - all()函数用于判断给定的可迭代参数中是否含有元素为0、’’、False，如果含有这样的元素返回False否则返回True，如果是空的迭代器则返回True。
  - any(iterable)
    - any()函数用于判断给定的迭代器是否全部为空的元素0、’’、False, 如果全部为空则返回False，否则返回True。空的元组或者列表返回False.
  - cmp(x,y)
    - cmp()函数用于比较两个对象的大小，如果x<y返回-1，如果相等则返回0，如果x>y则返回1
  - filter(function or None, sequence)
    - filter()函数用于过滤序列，过滤不符合的数据，返回有符合元素组成的序列
    - filter(条件, 序列)
      - 条件可以是表达式，函数等；应该是啥都行，只要是你能想到的；
  - map
    - map()函数将传入的函数应用到序列中的所有的项，可以应用多个序列；
    - 当传入的为None而不是函数的时候，map()函数将序列中的元素合并起来，返回一个新的元祖；（注意这里，不论原本是啥，输出都是元组）
    - 实例
      - def add(a,b): return a+b new1 = map(add, [1,2],[3,4]) new1 = tuple(new1) print(new1)
      - 注
         map和zip有同样的问题
- 对象操作
  - help([object])
    - help()函数用于查看函数或模块用途的详细说明
  - dir([object])
    - dir()函数主要是收集对象的信息。如果其不带参数，就返回当前范围的变量、方法和定义的类型列表；带参数的时候，返回参数的属性，方法列表。
  - id([object])
    - id()函数用于获取对象的内存地址。
  - hash([object])
    - hash()用于获取一个对象的哈希值
  - type(name,bases,dict)
    - type()函数，如果只有一个参数则返回对象的类型，如果有三个参数则返回新的类对象；（即，三个参数是用来创建新的类对象的）
- exec/eval
  - exec语句
    - 用来执行储存在字符串或文件中的Python语句；
  - eval语句
    - 用来计算存储在字符串中的有效Python表达式；
  - 实例
    - cmd = "print 'hello world'" exec cmd #hello world expression = "10 * 2 + 5" print eval(expression) #25
- 时间日期
  - time
    - time()
      - 返回当前时间的时间戳（1970纪元后经过的浮点秒数）
    - localtime([secs])
      - 将一个时间戳转换为当前时区的struct_time。如果参数未提供，则以当前时间为准。
    - sleep(secs): 线程推迟指定的时间运行。单位为秒。
  - datatime
    - datetime(year, month, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]])
      - 返回一个表示日期和时间的datetime对象。
    - today()
      - 返回当前本地日期
- 文件
  - shutil
    - shutil.move("filename", "othername")
      - 重命名
    - shutil.move("filnename", "path")
      - 移动目录
    - shutil.copy("filename", "path")
      - 复制文件到指定路径
    - shutil.rmtree()
      - 删除目录及其文件
  - glob
    - 查找文件
    - glob.glob()
      - 匹配目录匹配符
         ？
- 字符串
  - split()
    - 拆分
  - strip()
    - 慎用！！！！
    - 删除前导和末尾指定字符，实际上是删除指定字符的所有组合
    - "www.example.com".strip("cmowz.") -> example
  - lstrip()
    - 删除前导，其余同上
  - rstrip()
    - 删除末尾，其余同上
  - removeprefix()
    - 删除字符串指定前缀
      - python3.9
  - removesuffix()
    - 删除字符串指定后缀
      - python3.9
  - repleace()
    - 删除字符串中所有的指定字符
- 正则表达式
  - re
    - Topic1

- - - - ?
文件
- 文件对象
  - 用open()可以创建一个文件对象
  - open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
  - 参数说明
    - file
      - 必需，文件路径（相对或者绝对路径）
    - mode
      - 可选，文件打开模式（常用）
    - encoding
      - 一般使用utf8 （常用）
    - 不常用
      - buffering: 设置缓冲
      - errors: 报错级别
      - newline: 区分换行符（一般不用）
      - closefd: 传入的文件参数类型（一般不用）
      - opener
        设置自定义开启器，开启器的返回值必须是一个打开的文件描述符
  - 一般的使用形式
    - f = open('1.txt','r')
    - f现在是一个文件对象
    - 1.txt是文件路径（打开的文件在这个py文件的同目录下，不是同目录需要写相对路径）
- 打开模式
  - 单独打开模式
    - t
      - 文本模式 (默认)
    - b
      - 二进制模式（用于打开音频、视频、图片等的模式）
    - +
      - 打开一个文件进行更新(可读可写，这个一般不单独使用)
    - r
      - （默认）以只读方式打开文件，文件的指针将会放在文件的开头；不存在报错；
    - w
      - 只写，覆盖；不存在新建；
    - a
      - 只写，追加；不存在新建；
  - 组合打开模式
    - 就是字面意思的没记录
    - r+
      - 打开一个文件用于读写；不存在报错；不覆盖，在文件最前面写入；
    - w+
      - 打开一个文件用于读写；不存在新建；覆盖；
- 读写
  - 读
    - file.read([size])
      - 从文件读取指定的字节数，如果未给定或为负则读取所有
    - file.readline([size])
      - 读取整行，包括 “\n” 字符；注意这里还是字节数；默认是取一行，也就是取完'\n'姐就结束；
    - file.readlines([sizeint])
      - 读取所有行并返回列表，若给定sizeint>0，则是设置一次读多少字节；
  - 写
    - file.write(str)
      - 将字符串写入文件，返回的是写入的字符长度
    - file.writelines(sequence)
      - 向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符；即在字符串里加入\n是实现换行；
- 关闭
  - file.close()
    - 每一个文件的操作，都以.close()函数结束；
- 遍历目录下的所有子目录和文件
  - os.walk(path)
    - for root, dirs, files in os.walk(path)
模块
- 模块
  - 模块就是一个包含了所有你定义的函数和变量的文件，模块必须以.py为扩展名。模块可以从其他程序中‘输入’(import)以便利用它的功能。
  - 在python程序中导入其他模块使用'import', 所导入的模块必须在sys.path所列的目录中，因为sys.path第一个字符串是空串''即当前目录，所以程序中可导入当前目录的模块。
  - 模块我自己觉得可以理解为一个库，里面都很多定义的功能；
    - 一个.py文件就称之为一个模块（Module）
- 包
  - 包是保存模块的一个文件夹
  - 按目录来组织模块的方法，称为包（Package）
  - 每一个包目录下面都会有一个__init__.py的文件，这个文件是必须存在的，否则，Python就把这个目录当成普通目录，而不是一个包；即包就是一个特殊的目录；
  - 类似的，可以有多级目录，组成多级层次的包结构
- 导入模块
  - import
    - 所有的模块import都从“根节点”开始。根节点的位置由sys.path中的路径决定，项目的根目录一般自动在sys.path中。如果希望程序能处处执行，需手动修改sys.path。
  - import sys
    - 导入sys模块后，我们就有了变量sys，指向该模块，利用sys这个变量，就可以访问sys模块的所有功能；
  - from .. import
    - 如果想直接使用其他模块的变量或其他，而不加'模块名+.'前缀，可以使用from .. import。
  - 区别
    - import 导入模块，每次使用模块中的函数都要是定是哪个模块；
    - from…import * 导入模块，每次使用模块中的函数，直接使用函数就可以了，不用使用.;
    - 这是因为使用from...import跟在import之后的方法或者文件是绝对路径；
  - 注：
    - 单独import某个包名称时，不会导入该包中所包含的所有子模块。
    - 对于不在sys.path中，一定要避免用import导入自定义包（package）的子模块（module），而要用from…import… 的绝对导入或相对导入，且包（package）的相对导入只能用from形式。
- dir()函数
  - dir(sys)返回sys模块的名称列表
  - 如果不提供参数，即dir()，则返回当前模块中定义名称列表
  - del -> 删除一个变量/名称，del之后，该变量就不能再使用
- 跨.py文件调用自定义函数
  - 两个py文件在同一个文件夹下
    - import 导入另一个文件的名字
      - import 文件名
      - 也可以：from 文件名 import *，然后直接使用函数名调用，这样方便但是有多个文件可能会有函数名冲突；
    - 函数调用
      - 文件名.函数名
    - 如果只调用py文件中的一个函数
      - from 文件名 import 函数名
      - 函数调用直接写函数名
  - 两个py文件在不同文件夹下
    - import sys sys.path.append(路径)
    - sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
    - 把这个文件的上级目录添加到sys.path
- 安装模块
容错处理
- 异常
  - 异常的作用
    - 为了防止一些报错影响你的程序继续运行，就用try语句把它们抓出来(捕获)，然后通过程序自动的去处理这个异常；
  - 常见异常的类型
    - FloatingPointError
      - 浮点计算错误
    - OverflowError
      - 数值运算超出最大限制
    - ZeroDivisionError
      - 除(或取模)零 (所有数据类型)
    - AttributeError
      - 对象没有这个属性
    - IOError
      - 输入/输出操作失败
    - ImportError
      - 导入模块/对象失败
    - IndexError
      - 序列中没有此索引(index)
    - KeyError
      - 映射中没有这个键
    - MemoryError
      - 内存溢出错误(对于Python 解释器不是致命的)
    - ValueError
      - 传入无效的参数
    - FileExistsError
      - 文件不存在
    - 注：
      - 异常类型都是定义好的，使用的时候是会进行匹配的；
  - python中使用try ... except 处理
    - except
      - 发生异常，执行这块代码
    - else
      - 如果没有发生上面所有的except异常就执行这块代码
    - finally
      - 无论是否发生异常都将执行最后的代码
    - 例
      - try: execution block ##正常执行模块 except A: exc A block ##发生A错误时执行 except B: exc B block ##发生B错误时执行 except: other block ##发生除了A,B错误以外的其他错误时执行 else: if no exception, jump to here ##没有错误时执行 finally: final block ##总是执行
      - try: a = 1 / 2 print(a) print(m) # 此处抛出python标准异常 b = 1 / 0 # 此后的语句不执行 print(b) c = 2 / 1 print(c) except NameError: print("Ops!!") except ZeroDivisionError: print("Wrong math!!") except: print("Error")
    - 注：
      - 一旦跳入了某条except语句，就会执行相应的异常处理方法(block)，执行完毕就会结束。不会再返回try的normal block继续执行了。也就是异常发生之后的语句不会被执行；
      - 如果用else就必须有except，否则会有语法错误
  - with…as语句
    - with as 语句的结构如下
      - with expression [as variable]: with-block
    - 这样的过程等价于：
      - try: 执行 __enter__的内容执行 __exit__内容 finally: 执行 with_block
      - _enter_&_exit_都是expression里的；
    - 简单粗暴的理解：不论执行expression出现什么情况，代码块with-block的值照样执行；
    - 例
      - with open() as f:
        with open('number1.txt','r') as f: with-block
        以只读形式打开文件，并且一行为单位形成一个序列保存在f内（f：<class '_io.TextIOWrapper'>）
  - raise语句（唤起）
    - 用来触发异常
    - 单独raise，不加其他参数
      - 已经捕捉到了异常，异常已经发生了，不处理，重新引发它；
        ？
    - raise 异常类名称
      - raise后面带一个异常类名称，表示引发执行类型的异常，即程序运行到我这，就会触发我指定的异常；
    - raise 异常类名称("描述信息")
      - 在引发指定类型的异常，同时附带异常的描述信息
- assert语句(断言)
  - 在没完善一个程序之前，我们不知道程序在哪里会出错，与其让它在运行时崩溃，不如在出现错误条件时就崩溃；
  - assert可以理解为：我断言他是这样的，如果是，那我说的对，你继续执行，如果不是，我是不可能错的，所以你给我崩溃。
  - def zero(s): a = int(s) assert a > 0,"a超出范围" #这句的意思：如果a确实大于0，程序正常往下运行 return a zero("-2") #但是如果a是小于0的，程序会抛出AssertionError错误，报错为参数内容“a超出范围”
正则表达式
并发编程
- 多线程
  - threading
    - import threading
    - 创建多个线程
      - threads = [] for i in range(5): t = threading.Thread(target=worker) threads.append(t)
    - 启动线程
      - for t in threads: t.start()
    - 等待线程结束
      - for t in threads: t.join()
  - ThreadPoolExecutor
    - from concurrent.futures import ThreadPoolExecutor
    - 创建进程池，定义最大进程数
      - tasks = [] executor = ThreadPoolExecutor(max_workers=最大线程数)
    - 添加线程进线程池
      - task = executor.submit(函数名, 函数参数) tasks.append(task)
    - 启动
      - for it in tasks: it.result()
    - 注：
      - ThreadPoolExecutor不保证线程的同步（主线程和子线程的同步），可能会在有些情况下出错。可以用with as语句来实现创建线程池，保证线程同步。
      - 实例：
        with ThreadPoolExecutor(max_workers=最大线程数) as executor:
- 多进程
  - multiprocessing
    - import multiprocessing
    - 创建进程池，定义最大进程数
      - pool = multiprocessing.Pool(processes=max_num)
    - 启动子进程
      - for i in range(5): pool.apply_async(worker, (i))
    - 闭进程池，不再接受新的任务
      - pool.close()
    - 等待所有子进程执行完毕
      - pool.join()
数据库
- 数据库通用流程
  - 引入API模块
  - 连接数据库
  - 执行SQL语句和存储过程
  - 关闭连接
- mysql
- pymysql
  - 主要方法
    - connect()
      - 连接数据库
    - cursor()
      - 获取游标对象，操作数据库
    - commit()
      - 提交事务
    - rollback()
      - 回滚事务
    - close()
      - 关闭数据库连接
  - 导入包
    - import pymysql
  - 连接数据库
    - db = pymysql.connect(host="数据库地址", user="用户名", password="密码", database="数据库名", port = 3306, charset='utf8')
  - 创建游标
    - cursor = db.cursor()
  - 操作数据库
    - 创建
      - # 如果数据表已经存在使用execute()方法删除表。 cursor.execute("DROP TABLE IF EXISTS EMPLOYEE") # 创建数据表SQL语句 sql = """CREATE TABLE EMPLOYEE ( FIRST_NAME CHAR(20) NOT NULL, LAST_NAME CHAR(20), AGE INT, SEX CHAR(1), INCOME FLOAT )""" cursor.execute(sql)
    - 查询数据
      - # SQL 插入语句 sql = """INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES ('Mac', 'Mohan', 20, 'M', 2000)""" try: cursor.execute(sql) # 提交到数据库执行 db.commit() except: # 发生错误时回滚 db.rollback()
    - 添加数据
      - # SQL 插入语句 sql = """INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES ('Mac', 'Mohan', 20, 'M', 2000)""" try: cursor.execute(sql) # 提交到数据库执行 db.commit() except: # 发生错误时回滚 db.rollback()
    - 修改数据
      - # SQL 更新语句 sql = "UPDATE EMPLOYEE SET AGE = AGE + 1 WHERE SEX = '{}'".format('M') try: cursor.execute(sql) # 提交到数据库执行 db.commit() except: # 发生错误时回滚 db.rollback()
    - 删除数据
      - # SQL 刪除语句 sql = "DELETE FROM EMPLOYEE WHERE AGE > {}".format(20) try: cursor.execute(sql) # 提交到数据库执行 db.commit() except: # 发生错误时回滚 db.rollback()
  - 关闭游标，数据库连接
    - cursor.close() db.close()
Python标准库
- 常用标准库
  - os
    - 操作系统管理
    - 文件和目录相关的操作都在这
    - os.path.join()
    - os.path.splitext()
      - 分解出扩展名
    - os.path.exists()
    - os.path.isfile()
    - os.path.isdir()
    - os.path.getsize()
      - 返回文件的字节数，等于0说明文件是空
    - os.getcwd()
    - os.walk()
      - for root, dirs, files in os.walk(path)：root是正在遍历的路径，dirs是当前目录下的文件夹，files是当前目录下的文件；
    - os.listdir()
      - 列出路径下的所有文件和文件夹
    - os.remove()
    - os.mkdir()
      - 创建目录，但是父目录要存在
    - os.makedirs()
      - 创建目录，不要求父目录存在
    - os.rmdir()
      - 删除目录，要求目录是空
    - os.remove()
    - os.stat()
      - 获取文件属性信息
  - sys
    - 解释器交互
  - platform
    - 操作系统信息
  - glob
    - 查找文件
  - shutil
    - 文件管理
    - shutil.rmtree()
  - random
    - 随机数
  - subprocess
    - 执行shell命令
  - pickle
    - 对象数据持久化
  - json
    - JSON编码和解码
  - time
    - 时间访问和转换
  - datetime
    - 日期和时间
  - urllib
    - HTTP访问
- os模块
  - os.getenv()和os.putenv()
    - 分别用来读取和设置环境变量
  - os.system()
    - 用来运行shell命令
  - os.linesep
    - 字符串给出当前平台使用的行终止符。例如，Windows使用'\r\n'，Linux使用'\n'而Mac使用'\r'
  - os.sep
    - 操作系统特定的路径分割符
- sys模块
  - sys模块包含系统对应的功能
  - sys.argv
    - 包含命令行参数，第一个参数是py的文件名
    - sys模块有一个argv变量，用list存储了命令行的所有参数
    - argv至少有一个元素，因为第一个参数永远是该.py文件的名称；指运行的时候命令行执行的.py文件；
      - 运行python3 hello.py获得的sys.argv就是['hello.py']，注意这里python3不算是参数；
      - 运行python3 hello.py Michael获得的sys.argv就是['hello.py', 'Michael]；
  - sys.platform
    - 返回平台类型
  - sys.exit([status])
    - 退出程序，可选的status(范围：0-127)：0表示正常退出，其他表示不正常，可抛异常事件供捕获
  - sys.path
    - 程序中导入模块对应的文件必须放在sys.path包含的目录中，使用sys.path.append添加自己的模块路径
  - sys.modules
    - This is a dictionary that maps module names to modules which have already been loaded
    - 这是一个将模块名称映射到已加载的模块的字典
  - sys.stdin,sys.stdout,sys.stderr
    - 包含与标准I/O 流对应的流对象
    - s = sys.stdin.readline() sys.stdout.write(s)
pdb
- 启动
  - 一般的python程序直接用pdb启动程序就可以；
  - 调试se.py
    - ./build/ARM/gem5.debug --pdb ./configs/example/se.py -c /remote/lms04/zwx1144326/Gem5/PM_Cases/aarch64/SimPoints/GKB5/101-AES_XTS/101_sp001
- 断点
  - b(reak)
    - [([filename:]lineno | function) [, condition]]
    - 使用lineno参数，在当前文件中设置一个中断；
    - 使用函数参数，在该函数内的第一个可执行语句处设置中断；
    - 不带参数，列出所有中断；
  - tbreak
    - 临时断点，第一次命中时自动删除
  - cl(ear)
    - 使用filename:lineno参数，清除此行的所有断点
    - 没有参数，清除所有中断（但首先要求确认）
- 运行
  - n(ext)
  - s(tep)
    - 执行当前行，在第一个可能的情况下停止（在被调用的函数中或在当前函数的下一行）
    - 注：
      - 可以使用next运行到当前函数，使用step进入函数的内部进行调试；
  - r(eturn)
    - 继续执行直到当前函数返回
  - c(ont(inue))
    - 继续执行，仅在遇到断点时停止
  - j(ump) lineno
    - 设置将要执行的下一行。仅在最底部的框架中可用
    - 应该注意的是，并非所有的跳转都是允许的——例如，不可能跳到for循环的中间或跳出 finally子句；
  - run
  - restart
    - 重新启动调试的 Python 程序
- 查看
  - l(ist)
  - ll
    - 列出当前函数或框架的所有源代码
  - a(rgs)
    - 打印当前函数的参数列表
  - p expression
    - 评估当前上下文中的表达式并打印其值
    - print()也可以使用，但不是调试器命令——它执行 Pythonprint()函数
  - pp expression
    - 像p命令一样，除了表达式的值是使用pprint模块打印出来的
  - whatis expression
    - 打印表达式的类型
  - retval
    - 打印函数最后一次返回的返回值
- 其他
  - ;;
    - 可以在一行中输入多个命令，以 . 分隔;;
  - h(elp) [command]
    - 不带参数，打印可用命令列表
    - 使用命令作为参数，打印关于该命令的帮助
常用代码
- 参数输入
  - import argparse
  - if __name__ == '__main__': argParser = argparse.ArgumentParser(description="tsvc test") argParser.add_argument("-tsvc", type=str, help="tsvc dir path, case: /xx/tsvc") argParser.add_argument("-m", type=str, default="cmp", help="test model: cmp or run, default cmp") args = argParser.parse_args()
- 遍历查找文件
  - for root, dirs, files in os.walk(dir_path): for file_name in files:
- 多进程
  - from concurrent.futures import ThreadPoolExecutor
  - tasks = [] with ThreadPoolExecutor(max_workers=g_max_threads) as executor: for sub_name, c_file in subName_cFiles.items(): 。。。。 task = executor.submit(self.run, shell) tasks.append(task) for it in tasks: it.result()
Q&A
- join()的用法
  - 将一个可迭代对象（如列表、元组等）中的元素用指定的分隔符连接起来，返回一个新的字符串。默认分隔符是空格。
  - 实例
    - parts = ["hello", "world", "this", "is", "Python"] sentence = " ".join(parts) print(sentence)
- 列表推导式
  - 一种简洁、高效地创建新列表的方式。可以快速的过滤，转换，生成列表。
  - 范式
    - [表达式 for 变量 in 可迭代对象 if 条件]
    - 可以没有if 条件，表达式可以是变量。
  - 实例：
    - my_list = [1, 2, 3, 4, 5, 2, 6] # 删除所有等于 2 的元素 my_list = [x for x in my_list if x != 2] print(my_list) # 输出: [1, 3, 4, 5, 6]
- 生成器
  - 是什么
    - 是一种特殊的迭代器，按需生成值（只生成当前值），而不是一次性把所有数据加载到内存中。对内存友好。
  - 什么时候用
    - 处理大量数据或无限序列（实际是很大的序列）。
  - 怎么用
    - # 列表：占内存 squares_list = [x**2 for x in range(1000000)]
    - # 生成器：只生成当前值 squares_gen = (x**2 for x in range(1000000))
    - 解释
      - 列表会把所有的数据生成，然后存到内存里。生成器只生成当前值。
  - 注
    - 生成器只能遍历一次，再次遍历时为空。
    - 不能使用索引访问元素（如 gen[0] 会报错）。
    - 可以用 list(gen) 把生成器转为列表（但会失去内存优势）。