1. 列表
   1. 使用deepcopy()复制所有内容
      1. deepcopy()能够处理深度嵌套列表、字典以及其他对象
   2. 使用zip()迭代多个序列
      1. 整体打包
   3. 使用推导式创建列表
      1. 简单形式：[expression for item in iterable]
         1. >>> number_list = [number for number in range(1,6)
         2. >>> number_list
         3. [1,2,3,4,5]
      2. 包含条件表达式：[expression for item in iterable if condition]
         1. >>> a_list = [number for number in range(1,6) if number % 2 == 1
         2. >>> a_list
         3. [1,3,5]
2. 字典：dict
   1. 创建字典
      1. {Key:value)
      2. dict()
         1. acme = dict(first='wile',middle='e',last='coy')
         2. 限制：参数名不能有空格与保留字
         3. dict()函数可以将双值序列转换为字典
   2. 修改字典：字典键必须是唯一
      1. [key]添加或修改字典项
      2. {**a,**b} 合并字典
      3. update() 合并字典：将一个字典的键和值复制到另一个字典
         1. a.update(b)
            1. 将b字典中的键-值复制增加到字典a中
      4. del语句删除字典项
         1. del a['b']
            1. 删除字典a中b键及值
      5. pop()：返回字典项后将其删除
         1. a.pop('b')
            1. 返回字典a中b键对应的值后将其删除，若该键不存在则产生异常
      6. clear()：删除所有字典
         1. a.clear()
      7. copy()：浅复制,适用于字典值不可变的情况
         1. a.copy()
      8. deepcopy()：深复制，复制所有内容
         1. import copy
         2. b = copy.deepcopy(a)
   3. 获取字典
      1. [key]
      2. get()
         1. 键存在，得到可选值
            1. a.get('ba')
         2. 键不存在，得到可选值，并提前指定
            1. a.get('ba':'cv')
         3. 键不存在，提前未指定，返回None
      3. keys()：获取所有键
         1. a.keys()
      4. values()：获取所有值
         1. a.values()
      5. items()：获取所有‘键-值’对
         1. a.items()
      6. len()：获取‘键-值’个数
         1. len(a)
   4. 迭代字典
      1. 迭代字典会返回键
         1. for sth in a:
         2. for sth in a.keys():
      2. 迭代字典返回值
         1. for sth in a.values():
      3. 迭代字典以元组形式返回键-值
         1. for key,value in a.items():
         2. 返回元组：(key,value)
   5. 字典推导式
      1. {key:value for exp in ite}
      2. {key:value for exp in ite if con}
3. 集合
   1. 创建集合（集合是无序的）
      1. {} 创建集合
         1. {1,2,3}
      2. set():创建集合
         1. empty_set = set()
      3. set():可将列表、字符串、元组、字典转换为字符串，重复的值会丢弃，当字典转换为集合时，只有键保留
      4. frozenset():创建不可变集合
         1. frozenset(列表、元组、集合)
   2. 修改集合
      1. len():获取集合元素个数
         1. len(a)
      2. add():向集合后添加元素
         1. add('a')
      3. remove():删除集合中的元素
         1. remove('a')
   3. 读取集合
      1. 迭代集合
         1. for a in b:
   4. 集合运算
      1. 交集运算：多个集合共有的元素
         1. 交集运算符：&
            1. a & b
         2. a.intersection(b)
            1. 交集函数
      2. 并集运算：存在于任何一个集合中的元素
         1. 并集运算符：|
            1. a|b
         2. a.union(b)
            1. 并集函数
      3. 差集运算：存在于第一个集合但不在第二个集合中的元素
         1. 差集运算符：-
            1. a-b
         2. a.difference(b)
            1. 差集函数
      4. 异或集：元素仅在两个集合中出现一次
         1. 异或运算符：^
            1. a^b
         2. a.symmetric_difference(b)
            1. 异或函数
      5. 检查一个集合是否为另一个集合的子集：第一个集合中的所有成员也出现在第二个集合中
         1. 子集运算符：<=
            1. a<=b
         2. a.issbset(b)
            1. 子集函数
         3. 真子集判断：<
      6. 超集：
         1. 超集运算符：>=
            1. a>=b
         2. a.issuperset(b)
            1. 超集函数
            2. 真超集判断：>
   5. 集合推导式
      1. {expression for expression in iterable}
      2. 带有条件测试：
         1. {expression for expression in iterable if condition}
4. 函数
   1. 实参与形参
      1. 位置实参
         1. 实参值按顺序被依次复制到对应的形参。
      2. 关键字实参
         1. 按照其对应的形参名称指定实参，定义的顺序可以与定义函数时的顺序不同
         2. 同时也可以混用位置实参与关键字实参，但位置实参要放到最前面
      3. 指定默认形参值
         1. def fun(a,b,c='d'):
         2. 默认形参值是在定义函数时而不是在运行函数时计算的，不可使用可变数据类型指定，如列表或字典
      4. 使用*拆分/汇集位置实参
         1. 当在带有参数的函数内部使用*时，星号会将可变数量的位置实参汇集成单个形参元组
         2. 在函数之外，*args会将元组args拆分由逗号分隔的位置形参
         3. 在函数之内，*args会将所有的位置实参汇集成单个args元组
            1. *args在函数外部是膨胀效果，在函数内部是吸入效果，值要么被拆分，要么被汇集
      5. 使用**拆分/汇集关键字实参
         1. 将关键字实参汇集成一个字典，实参名是键，实参值是对应的值
         2. 在函数外部，**kwards会将字典kwards拆分为若干个形如name=value的实参
         3. 在函数内部，**kwards会将若干个name=value实参汇集成单个字典形参kwards
      6. 仅关键字形参
         1. 可以传入与位置形参同名的关键字实参，形参必须以name=value的形式提供，不能只按照位置提供值
   2. 文档字符串
      1. 通过在函数体起始部分添加字符串来为函数定义附加上文档
      2. 调用help(定义的函数名),打印函数的文档字符串
   3. 匿名函数：lambda
      1. lambda函数是一个可以表达为单语句形式的匿名函数，可以用它来代替普通的微型函数
      2. lambda函数可以有0个或多个逗号分隔的参数，然后是冒号：，接着是函数定义
   4. 生成器
      1. 通过写一个生成器函数来生成自定义序列
      2. 注意其中获取返回值语句需要用yield而非renturn，同时，生成器只能运行一次
      3. 生成器推导式
   5. 装饰器：在原函数基础上，通过不修改原函数代码，增加相关功能
      1. 一个函数可以有多个装饰器，最接近函数的装饰器先运行
   6. 命名空间
      1. 主程序部分定义了全局命名空间，在其中定义的变量就是全局变量
         1. 可以在函数内部获取全局变量的值
         2. 不可以在函数内获取全局变量的值后并进行修改
         3. 不获取，只修改，也只是修改函数内部的变量值
      2. 要想在函数中访问全局变量而非局部变量，需要明确使用global关键字
      3. 访问命名空间中的内容
         1. locals()函数：会返回局部名称空间的内容目录
         2. globals()函数：会返回全局名称空间的内容目录
   7. 变量名称中的__和__用法
      1. 以双下划线起止的名称是保留给python内部使用的，不要将自己的变量名称也带有双下划线__，相当于系统变量名称
         1. 系统变量 function.__name__ 保留函数名称
         2. 系统变量 function.__doc__ 保留文档字符串
   8. 递归：函数调用自身
      1. yield from表达式，让一个生成器把部分工作交给另一个生成器
   9. 异常
      1. 使用try和except代码块处理错误
      2. 可以编写不在标准库中定义好的自定义的异常
5. 对象，类
   1. class 定义类
   2. 初始化 python对象初始化方法：__init__():
      1. __init__()是python特殊的方法名称，该方法用于在类定义中初始化对象
      2. self参数指定了引用的是此对象本身
   3. 继承：从现有类创建新类
      1. 从父类继承
      2. 覆盖方法
      3. 添加方法：子类添加父类没有的方法
      4. super（） 获取父类属性：子类能够获得父类的属性，不用再次定义
      5. 多重继承：子类可以继承多个父类
      6. 辅助父类：mixin：不与其他父类共享任何方法，仅执行一些“辅助”任务，如日志记录等
   4. 特性（属性）访问
      1. 计算值属性
      2. 使用名称重整保护内部隐私
      3. 类和对象特性
         1. 可以为类设置各种特性，类的特性会被子对象继承
         2. 改变子对象特性并不会影响到类的特性
         3. 改变类的特性不会影响到已有子对象特性，但会影响新对象
   5. 方法的类型
      1. 实例方法：在类定义的方法中看到第一个参数是self，实例方法的第一个参数是self，当调用该方法时，python会将对象传入该方法。
      2. 类方法：影响整个类，第一个参数是cls。
         1. 用前置装饰器@classmethod指明接下来的函数是类方法，方法的第一个参数是类本身，python传统做法是将该参数命名为cls
      3. 静态方法：既不影响类，也不影响对象，使用@staticmethod作为前置装饰器，不需要self,cls等参数
   6. 鸭子方法：多态，根据方法的名称和参数将相同的操作用于不同的对象
   7. 魔术方法
   8. 聚合与组合
   9. 具名元组
   10. 数据类
       1. 使用数据类注意事项：
          1. 需要@dataclass装饰器
          2. 定义类特性要使用形如name:type或name:type = val的变量注解，type可以是包括类在内的任意python对象类型
          3. 创建数据类型时，要按照类中指定的顺序提供参数，或是使用具名参数
6. 当创建复杂的数据结构时，由于字典的键必须是不可变的，因此列表、字典、集合都不能作为键，但元组可以。
   1. site = {(44.79,93.14,285):'my house',(38.79,-77.03,13):'the position'}
7. 对于列表和元组，利用方括号[]访问单个元素，方括号内的值是整数偏移。对于字典，则是键。列表、元组、字典利用[]访问得到的都是值。对于集合，要么存在，要么不存在，不存在索引或键。