第一章 变量、常用循环体、代码结构、代码练习
第二章 列表、元组等数据结构、字符串驻留机制及字符串格式化操作
第三章 函数、面向对象、文件操作、深浅拷贝、模块、异常及捕获
第四章 项目打包、类和对象高级、序列、迭代器、生成器、装饰器
第五章 正则表达式、json、logging日志配置、数据库操作、枚举、闭包、匿名函数和高阶函数、time、datetime
第六章 Socket编程、多线程(创建方式、线程通信、线程锁、线程池)
项目打包
先安装第三方模块
pip install PyInstaller执行打包操作：
-F ：指定文件
pyinstaller -F E:....\stusystem.pywindows系统时，打包后，会获得一个exe可执行文件，打包完成
执行即可
知识点
- 随机数
import random
random.randint(1000,1500) # 获取1000-1500之间的随机数- 展示列表中 索引和值
year = [88, 82, 89, 29, 30]
for index, value in enumerate(year):
print(index, value)
# 输出
0 88
1 82
2 89
3 29
4 30- lambda表达式
stu_list = [{'english':90},{'python':80}]
stu_list.sort(key=lambda x: int(x['english'])) # lambda表达式- 手动抛出异常抛出的异常，由except捕获
try:
raise Exception('程序错误')
except Exception as e:
print(e)- 时间格式化
import time
ls = time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time()))
print(ls)Python类和对象高级
python中一切皆对象
- python(动态语言)的面向对象比Java(静态语言)面向对象更加地彻底。
- python中的类和函数，都属于对象，都是python的一等公民
- 可赋值给一个变量
- 可以添加到集合对象中
- 可以作为参数传递给函数
- 可以当做函数的返回值
def ask(name='bobby'):
print(name)
class Person:
def __init__(self):
print('bobbyPerson')
def print_type(item):
print(type(item))
my_func = ask # 函数赋值给变量
my_func('java')
my_class = Person # 类对象赋值给变量
my_class()
obj_list = []
obj_list.append(ask) # 添加到列表
obj_list.append(Person) # 添加到列表
for i in obj_list:
print(i())
print_type(ask) # 作为参数传递
print_type(Person) # 作为参数传递
def decorator_func():
print('dec start')
return ask # 作为返回值传递
my_ask = decorator_func()
my_ask('tom')type、object和class的关系
type —> class(类) —> object(实例对象)
type生成类对象，类对象可实例化为实例对象
object是最顶层的基类，所有对象的类型最后都会推导出object是最顶层父类
print(type(1)) # <class 'int'>
print(type(int)) # <class 'type'>
lst = [1, 2]
print(type(lst)) # <class 'list'>
print(type(list)) # <class 'type'>
print(type.__bases__) # <class 'object'> type类的基类(父类)
print(object.__bases__) # () object类的基类(父类)object是type的实例(所有对象都是type的实例)，而type又继承了object
同时type也是type自身的实例
如下str是类，同时也是type的实例(实例对象)，也叫对象
设计理念：：为了动态修改类属性，类方法…（像java中修改类信息时，会用到java的反射之类的知识点较为复杂，而Python是不需要的，直接修改即可，这就是python设计一切皆对象的好处）
python中常见内置类型
- 变量的组成或者叫对象的三个特征(id,type,value)
- None(全局只有一个)
- 迭代类型
- 序列类型
- list
- range
- str…
- 映射类型(dict)
- 集合
- set
- frozenset
- 上下文管理类型(with)
魔法函数
什么是魔法函数？
双下划线开头，双下划线结束
一定要使用python定义好的魔法函数，不然是没有用处的
class Company(object):
def __init__(self, employee_list):
self.employee = employee_list
def __getitem__(self, item):
return self.employee[item]
company = Company(['tom', 'job', 'jane'])
for em in company: # 会去调用 __getitem__()函数，并依次将索引传入参数
print(em) # 实际上会先去找 __iter__() 函数，找不到则去找 __getitem__()函数
company1 = company[:2] # 还可以进行切片操作(序列类型)如果以上不创建 __getitem__()函数，下面遍历时会报错，该对象不是一个可迭代类型
也就是说，我们在Company类对象中创建了一个魔法函数__getitem__()，使Company的实例对象变成了一个可迭代的对象，并且每次迭代都会去调用__getitem__()方法
定义魔法函数：将会直接影响到python语法，而且魔法函数不需要手动调用，python解释器会去帮我们调用
鸭子类型和多态
鸭子类型
当看到一只鸟走起来像鸭子，叫起来像鸭子，那么这只鸟就可以被称之为鸭子。
表现为，我们可以通过使用魔法函数，使某一些对象具备一些类型
比如，一个类对象添加了一个魔法函数__getitem__()，那么它就成为了一个可迭代对象。
多态(纯天然，不必像静态语言一样需要满足某些条件)
直接调用方法即可，只要方法名相同，传入任何类型都可以
class Cat:
def say(self):
print('i am a cat')
class Dog:
def say(self):
print('i am a dog')
animal_list = [Cat, Dog]
for i in animal_list:
i().say() # i am a cat i am a dog抽象基类(abc模块) 类似java接口
抽象基类：
- 不能实例化
- 单继承
- 子类需要实现父类的方法
判断对象是否是某种类型(包括基类)
isinstance(obj, type) # 判断对象是否是某种类型(包括基类)模拟一个抽象基类·
不经常使用0.0，了解一下
import abc
class CacheBase(metaclass=abc.ABCMeta):
@abc.abstractmethod
def get(self, key):
pass
@abc.abstractmethod
def set(self, key, value):
pass
class RedisCache(CacheBase): # 继承自CacheBase类后，未重写父类抽象方法
pass
class RedisCache(CacheBase): # 继承后，重写所有抽象方法
def get(self, key):
pass
def set(self, key, value):
pass
redis_cache = RedisCache() # 如果RedisCache没有重写CacheBase中所有抽象方法
# 那么会程序报错，抛出异常类和实例属性的查找顺序
class A:
name = 'A'
def __init__(self, age):
self.age = age
a = A(20)
print(a.name) # 先找 实例对象中有没有 name属性，发现没有再去A类中找类属性当存在复杂继承关系时，可使用__mro__查看查找顺序
print(A.__mro__)类方法和静态方法
class Date:
def __init__(self, year, month, day):
self.year = year
self.month = month
self.day = day
@staticmethod
def parse_from_str(date_str):
year, month ,day = date_str.split('-')
return Date(int(year),int(month),int(day)) # 采取硬编码Date类对象
@classmethod
def parse_str(cls, date_str):
year, month, day = date_str.split('-')
return cls(int(year), int(month), int(day)) # 可直接返回 cls本身上下文管理器高级
import contextlib
# 使之成为一个上下文管理器 利用了生成器的作用
@contextlib.contextmanager
def file_open():
print('file_open...')
yield {} # yield之前的相当于是 __enter__()函数的内容 yield之后的代码块 相当于__exit__()函数的内容
print('file_end...')
with file_open() as fi:
print('file processing') # 此代码块执行时，位置是 上面 yield{} 中的代码块
# 执行结果
file_open...
file processing
file_end...isinstance() 和 type()区别
- isinstance(obj,type) 判断时，会去找继承链，如果obj的类型是继承自type(某一种类型，不是指type类)，那么返回结果为True
- type(): 返回当前对象的类型
序列
序列分类
- 容器序列(可放入多个元素)：list、tuple、deque
- 扁平序列：str、bytes、bytearray、array.array
- 可变序列：list、deque、bytearray、array
- 不可变序列：str、tuple、bytes
序列类型的abc继承关系
# abc模块，进入abc模块可查看
from collections import abclist的extend方法
# +
a = [1,2]
c = a + [3, 4] # [1,2,3,4]
c = a + (3, 4) # 直接报错。。
# +=
a = [1,2]
a += (3,4) #[1,2,3,4]
a += [3,4] #[1,2,3,4]
# += 实际是调用了 __iadd__()魔法函数，是调用了extend方法
a = [1,2]
a.extend(range(3)) # [1,2,0,1,2]实现可切片的对象
import numbers
class Group:
def __init__(self, group_name, company_name, staffs):
self.group_name = group_name
self.company_name = company_name
self.staffs = staffs
def __getitem__(self, item): # 实现切片的关键是，定义__getitem__()魔法函数
cls = type(self)
if isinstance(item, slice): # 如果item是 slice类型(切片类型)
return cls(self.group_name, self.company_name, self.staffs[item])
elif isinstance(item, numbers.Integral): # item是 数字类型
return cls(self.group_name, self.company_name, [self.staffs[item]])
def __contains__(self, item): # 判断对象是否在Group实例对象的staffs列表中
if item in self.staffs:
return True
else:
return False
staffs = ['bobby1', 'bobby2', 'bobby3']
group = Group('user', 'immoc', staffs)
sub_group = group[:2]
sub_group = group[0]
'bobby1' in group # True 解释器去找__contains__()魔法函数bisect维持已排序的序列
简介：
bisect是python内置模块，用于有序序列的插入和查找。
- 查找： bisect(array, item) 查找该数值将会插入的位置并返回，而不会插入
- 插入： insort(array,item) 会自动维持顺序
特点：
- 二分查找效率高
- 维持顺序
import bisect
inter_list = []
bisect.insort(inter_list, 3) # 插入元素
bisect.insort(inter_list, 2)
bisect.insort(inter_list, 1)
bisect.insort(inter_list, 5)
print(inter_list) #[1, 2, 3, 5]
print(bisect.bisect_left(inter_list, 0)) # 获取元素0的插入位置，遇到相同元素时，返回相同元素左边的位置array
array和list的区别：
- array只能存放指定类型的数据
import array
my_array = array.array('i') # 只接受int类型数据
my_array.append(1)
my_array.append('abc') # 报错列表生成式
列表生成式性能高于列表操作，建议多用，但是逻辑过于复杂的话不建议使用(增强代码的可读性)
# 列出 1-20之间的奇数
# 当i是奇数时，返回给 for 前面的 i
o_list = [i for i in range(1,21) if i % 2 ==1]
# 复杂逻辑 奇数平方
def handle_item(item):
return item**2
o_list = [handle_item(i) for i in range(1,21) if i % 2 ==1]生成器表达式
o_list = (i for i in range(1,21) if i % 2 ==1) # 是一个生成器对象，可以遍历，也可以转换为list列表字典生成式
# 将字典中 key和value互换
my_dict = {'bobby1':22, 'bobby2':23,'wlh':21}
reversed_dict = {value:key for key,value in my_dict.items()}集合生成式
# 把所有的key放入my_set中
my_dict = {'bobby1':22, 'bobby2':23,'wlh':21}
my_set = {key for key,value in my_dict.items()} # 方式一：可加入逻辑判断 集合生成式
my_set2 = set(my_dict.keys()) # 方式二：单一，不能判断set和dict
dict
- dict属于Mapping类型
a = {}
# dict类型实现了一些MutableMapping的魔法函数，满足MutableMapping协议
# 所以它被判断为是MutableMapping类型(鸭子类型)
isinstance(a, MutableMapping)dict类型的方法
- fromkeys (生成一个dict)
- setdefault(key,value) 添加一对k-v，并且返回value值(效率高)
- update() 添加至少一个k-v
lst = ['joke','python']
new_dict = dict.fromkeys(lst, 1) # 生成一个dict，key是 joke、python，value都是1
default_value = new_dict.setdefault('java',2) # 新增元素，并且返回value
print(default_value) # 2
print(new_dict) # {'joke': 1, 'python': 1, 'java': 2}
# 方式一
new_dict.update(a = '1', b = '2')
# 方式二
new_dict.update([('a','1'),('b','2')]) # {'joke': 1, 'python': 1, 'java': 2, 'a': '1', 'b': '2'}UserDict
一般情况下，不建议去继承list和dict
可以去继承c语言模拟的类UserDict
from collections import UserDict
class MyDict(UserDict):
def __setitem__(self, key, value):
super().__setitem__(key, value*2)
my_dict = MyDict(a = 1)
print(my_dict) # {'a': 2}defaultdict类
此类实现了__missing__()魔法函数，可处理当[key]找不到key时，自动设置一个默认值
可以去继承它，也可以直接使用
from collections import defaultdict
my_dict = defaultdict(dict)
my_value = my_dict['a']
print(my_value) # 默认值是一个空字典 {}set和frozenset(不可变集合)
s = set('abcde') # 接收可迭代对象
a.add('c') # 可新增
s = forzenset('abcde') # 定义好后，就不能更改了(不可变的集合)，一般可作为dict的keyset性能很高，要记住set集合关系运算的几种操作，很方便
a,b = {1,2},{1,3}
a & b # 取交集
a | b # 取并集
a ^ b # 取对称差集
a - b # 取差集dict和set实现原理
dict和list性能
- dict的查找性能远远大于listdict采用k-v存储方式，直接根据k可找到value值，时间复杂度是o(1)的存在
- 在list中，随着list数据量增大，查找时间成正比
- 在dict中，不会随着dict数据量增大而查找时间增大
- 根据key的hash值计算元素的存储位置
set
- set其实也是根据key的hash值计算元素的存储位置，不同的是set只有key没有value
- 元素必须是一个可hash的元素(实现了__hash__()魔法函数)
对象引用和垃圾回收
对象引用
python中一切皆对象，一个变量的组成由id标识、type类型和value值组成
id标识就是对象的引用地址
is比较id标识
class Person:
pass
p = Person()
print(type(p) is Person) # True垃圾回收
算法是采用引用计数
当一块内存地址被标识(变量)指向时，引用计数+1，当一块内存地址被标识(变量)取消指向后，引用计数-1，当引用计数变成0时，python会进行垃圾回收，清理内存。
a = 1
b = a
del a,b # 此时1这个值的计数器-2 然后1 这个值在内存中会被删除__del__()魔法函数，当元素被 del的时候会去调用，我们可以按照自己的逻辑定义
常见参数错误
类中定义的列表默认值
class Company:
def __init__(self, name, staffs=[]):
self.name = name
self.staffs = staffs
def add(self, staff_name):
self.staffs.append(staff_name)
def remove(self, staff_name):
self.staffs.remove(staff_name)
com1 = Company("com1")
com1.add("jane1")
com2 = Company("com2")
com2.add("jane2")
# 而com3不使用默认值
com3 = Company("com3",["jane3"])
print(com1.staffs) # ['jane1', 'jane2']
print(com2.staffs) # ['jane1', 'jane2']
print(com3.staffs) # ['jane3']
# 由于com1和com2都是使用的[]默认值，也就是Company.__init__.__defaults__的值，所以两个对象中的staffs列表都指向了一个内存
# 但是com3的staffs列表传入了参数，没有使用默认值，那么staffs就不会指向Company.__init__.__defaults__元类编程
property动态属性
from datetime import date, datetime
class User:
def __init__(self, name, birthday):
self.name = name
self.birthday = birthday
self._age = 0
@property # 类似java的get方法
def age(self):
# 2022-1999
return datetime.now().year - self.birthday.year
@age.setter # set方法
def age(self,value):
self._age = value
if __name__ == '__main__':
user = User('bobby', date(year=1999,month=1,day=1))
user.age = 19 # 赋值后，调用了 @age.setter下的age(self,value)方法
print(user._age) # 19
print(user.age) # 23 # 调用的 age(self)方法魔法函数(getattr、getattribute)
- __getattr__(): 查找不到属性
# __getattr__() 在查找不到属性的时候调用此魔法函数
from datetime import date, datetime
class User:
def __init__(self, name, birthday):
self.name = name
self.birthday = birthday
def __getattr__(self, item):
return "not find attr"
if __name__ == '__main__':
user = User('bobby', date(year=1999,month=1,day=1))
print(user.age) # 一般查找不到属性，直接报错了，但是写了 __getattr__()，返回了字符串
# 所以打印 not find attr
----------------------------------------------------------------------
# 练习二
class User:
def __init__(self, info={}):
self.info = info
def __getattr__(self, item):
return self.info[item]
if __name__ == '__main__':
user = User(info={'company_name':'immoc', 'name':'jane'})
print(user.name) # jane
# user.name，由于找不到属性，调用getattr魔法函数，然后返回 info[item]的值- __getattribute__(): 无条件调用，只要调用实例属性，就走__getattribute__函数
优先级比 __getattr__()高
class User:
def __init__(self, info={}):
self.info = info
def __getattr__(self, item):
return self.info[item]
def __getattribute__(self, item):
return "boss"
if __name__ == '__main__':
user = User(info={'company_name':'immoc', 'name':'jane'})
print(user.name) # boss
# 只要写了 __getattribute__()魔法函数，只要调用实例属性，就会走getattribute函数属性描述符
只要实现了__get__()、__set__()、__delete_()任何一个魔法函数，那么这个类就被称为是属性描述符
可对值进行校验抛出异常
import numbers
class IntField:
def __set__(self, instance, value):
if not isinstance(value, numbers.Integral):
raise ValueError('int value need')
self.value = value
def __get__(self, instance, owner):
return self.value
class User:
age = IntField() # 指向IntField对象
if __name__ == '__main__':
user = User()
user.age = 30 # 给age赋值时，会去调用IntField的 set方法魔法函数
print(user.age) # 获取时，调用IntField的 get方法魔法函数属性查找顺序
如果user是某个类的实例，那么user.age(以及等价的getattr(user,‘age’))，会去首先调用 __getattribute__()。
如果类中定义了，__getattr__()，那么在 __getattribute__()抛出异常的时候会去调用__getattr__()，
而对于属性描述符(__get__())的调用，是发生在__getattribute__()内部的
user = User()
user.age # 的调用顺序 1-5
1. 如果'age'出现在User或者基类的__dict__中，并且 age是 data descriptor(数据属性描述符)，那么就会调用__get__() 方法
2. 'age'如果出现在 user的__dict__中，那么直接返回 user.__dict__['age']，否则
3. 如果'age'出现在User或者基类的__dict__中，并且 age是 non-data descriptor(非数据属性描述符)，那么调用 __get__()方法，否则直接返回 __dict__['age']
4. 如果User有 __getattr__方法，调用__getattr__()
5.抛异常顺序：
- 数据属性描述符 __get__()
- 直接调用对象属性
- 非数据属性描述符 __get__()
- 类属性
- __getattr__
- 抛异常
new和init
- __new__()：用来控制对象的创建的
- __init__()：给对象中的属性进行初始化赋值，如果__new__()中没有返回创建的对象，那么__init__()魔法函数将不会执行的
自定义元类
动态返回类对象
type：创建类的类，可使用type(obj)查询对象类型，同时也可以使用type()创建一个类对象
方式一：
def create_class(name):
if name == "user":
class User:
def __str__(self):
return 'user'
return User
elif name == "company":
class Company:
def __str__(self):
return 'company'
return Company
if __name__ == '__main__':
user = create_class('user')() # 创建User实例对象
print(user) # user方式二: type()创建类
type(name,bases,attrs)
- name:类名 str类型
- param2:继承自 tuple类型
- param3:属性 dict字典类型
def say(self):
return f'i am {self.name}'
if __name__ == '__main__':
# 方式一 ：位置传参
User = type('User',(), {'name':'wlh','say':say}) #创建了一个User类对象,name属性,say实例方法
# 方式二：关键字传参
User = type(name ='User',bases = (),attrs = {'name':'wlh','say':say})
obj = User()
print(obj) # <__main__.User object at 0x0000019F1172FFD0>
print(obj.name) # wlh
print(obj.say()) # i am wlh什么是元类
元类是创建类的类，比如type就是元类，控制类的创建。
python中类的实例化过程，会先去寻找metaclass，通过metaclass去创建类
找不到metaclass的话，就使用type()创建对象
class MetaClass(type):
def __new__(cls, *args, **kwargs):
return super().__new__(cls, *args, **kwargs)
class User(metaclass=MetaClass):
def __init__(self, name):
self.name = name
def __str__(self):
return 'user'
if __name__ == '__main__':
my_obj = User('jane')
print(my_obj)获取对象属性方法
- getattr(obj,key,None) : 获取对象属性值
# 取的对象的某个属性值，后面可以设置默认值None
getattr(obj, 'db_column', None)- setattr(obj,key,value) : 设置对象属性值
setattr(obj, 'a', 1)python3 迭代器和生成器、装饰器
迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
迭代器有两个基本的方法：iter() 和 next()。
迭代器的定义：
- 类中定义了__iter__和__next__两个方法
- __iter__方法需要返回对象本身，即:self
- __next__方法，返回下一个数据，如果没有数据了就要抛出StopIteration的异常
迭代器的使用
可迭代的类型：list、tuple、string、set、dict
其中list,tuple,string都是有序的迭代类型，我们可以按照顺序迭代，而set和dict是无序的，我们不知道next下一个元素是谁
- 字符串，列表或元组对象都可用于创建迭代器：
lst = [1,2,3,4]
it = iter(lst) # 创建迭代器对象
print(next(it)) # 1
print(next(it)) # 2- 迭代器对象，可使用for进行遍历
lst=[1,2,3,4]
it = iter(lst) # 创建迭代器对象
for x in it:
print (x, end=" ") # 1 2 3 4自定义迭代器(不常用)理解
把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__() 。
__iter__() 方法返回一个特殊的迭代器对象， 这个迭代器对象实现了 next() 方法并通过 StopIteration 异常标识迭代的完成。
__next__() 方法会返回下一个迭代器对象。
创建一个返回数字的迭代器，初始值为 1，逐步递增 1：
class MyNumbers:
def __iter__(self): # iter(obj)执行时，会执行这里，并且返回自己(由于实现了 __iter__() __next__()，所以就是返回了迭代器对象)
self.a = 1
return self
def __next__(self):
x = self.a
self.a += 1
return x
myc = MyNumbers()
myiter = iter(myc) # 获取迭代器对象
print(next(myiter)) # 1
print(next(myiter)) # 2
print(next(myiter)) # 3StopIteration
StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况，在 __next__() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。
class MyNumbers:
def __iter__(self): # iter(obj)执行时，会执行这里，并且返回自己(由于实现了 __iter__() __next__()，所以就是返回了迭代器对象)
self.a = 1
return self
def __next__(self):
if self.a <= 5:
x = self.a
self.a += 1
return x
else:
raise StopIteration
myc = MyNumbers()
myiter = iter(myc) # 获取迭代器对象
print(next(myiter)) # 1
print(next(myiter)) # 2
print(next(myiter)) # 3
print(next(myiter)) # 4
print(next(myiter)) # 5
print(next(myiter)) # 抛异常生成器(边迭代边输出)
- ()作为推导式，就会得到一个生成器。目的：边迭代边输出，只有用到了元素才会去生成(资源较大)
from collections.abc import Iterable
gen = (i for i in range(1,4000000000)) # 使用推导式创建 生成器
print(isinstance(gen, Iterable)) # True 是一个可迭代对象
print(next(gen)) # 1
print(next(gen)) # 2- 自定义生成器
使用yield关键字实现斐波那契数列
每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。
def fibonacci(n):
a, b = 0, 1
count = 0
while True:
if count > n:
break
yield a
a, b = b, a + b
count += 1
gen = fibonacci(100000000000) # 并不会进行卡顿，因为生成器是需要的时候才生成
for i in gen:
if i > 1000:
break
print(i, end="\t") # 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987装饰器Decorator
装饰模式(设计模式相关)
在不改变目标函数代码的情况下，对目标函数进行业务增强
无参装饰器
例如：要对目标方法进行登录验证
def login_check(func):
def wrapper():
print('login check ..')
func()
return wrapper
@login_check
def f1():
print('this is fun1')
def f2():
print('this is fun2')
f1() # login check .. this is fun1
f2() # this is fun2当有多个装饰器使用在一个函数上时，优先级会按照顺序执行
@login_check # login_check先执行
@time_check # time_check后执行
def f1():
print('this is fun1')有参装饰器
def login_check(func):
def wrapper(*args, **kwargs):
print('login check ..')
func(*args, **kwargs)
return wrapper
@login_check
def f1(x):
print('this is fun1', x)
@login_check
def f2(x, y, **kwargs):
print('this is fun2', x, y)
print(kwargs)
f1('abc') # login check .. this is fun1
f2('hello', 'python',a=1,b=2) # login check .. this is fun2 hello python {'a': 1, 'b': 2}第一章 变量、常用循环体、代码结构、代码练习
第二章 列表、元组等数据结构、字符串驻留机制及字符串格式化操作
第三章 函数、面向对象、文件操作、深浅拷贝、模块、异常及捕获
第四章 项目打包、类和对象高级、序列、迭代器、生成器、装饰器
第五章 正则表达式、json、logging日志配置、数据库操作、枚举、闭包、匿名函数和高阶函数、time、datetime
第六章 Socket编程、多线程(创建方式、线程通信、线程锁、线程池)
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
