Python基础语法和模块

1、变量和简单类型

1.1、单选注释和多行注释

单行注释使用#号
多行注释使用三个单引号```或三个双引号"“”"

1.2、变量

1.2.1、python是弱类型

>>> a = 10
>>> print(type(a))  # 可以使用type查看变量的类型
<class 'int'>

可以使用print函数输出变量

# print函数的语法格式
# print(value , ..., sep=' ', end='\n', file=sys.stdout, flush=False)

1.2.2、变量的命名规则

必须以字母或下划线开头，后面跟任意数目的字母、数字和下划线。区分大小写
python2.x对中文支持差，如果要使用中文字符或变量，需要在python源文件的第一行增加"# coding:utf-8"，源文件必须保存为UTF-8编码。

1.3、数值类型

1.3.1、整型

支持小整数，也支持大整数

>>> a = 99999999999999
>>> print(type(a))
<class 'int'>

整型数值的4种形式

• 十进制形式：最普通的整数就是十进制形式的整数
• 二进制形式：以 0b或0B 开头的整数就是二进制形式的整数
• 八进制形式：以0o或0O 开头的整数就是八进制形式的整数（第二个字母是大写或小写的O)
• 十六进制形式：以0x或0X开头整数就是十六进制形式的整数，其中 10~15 分别以a_f(此处的af不区分大小写）来表示

1.3.2、浮点数

• 十进制形式：例如：6.1
• 科学计数形式：例如：6.1e2(即6.11010)

1.3.3、复数

复数的虚部用j或J表示，如

>>> a = 5 + 0.2j
>>> print(a)
(5+0.2j)
>>> print(type(a))
<class 'complex'>

1.4、字符串

字符串的内容几乎可以包含任何字符（英文字符、中文字符）。
Python3.X对中文字符支持较好，2.X则需要在源码文件中增加"# coding:utf-8"
python不允许直接拼接数值和字符串，可以使用str()或repr函数将数值转成字符串。

# 拼接字符串
>>> str = "Hello" + "World"
>>> 
>>> age = "年龄："
>>> num = 9
>>> print(age + str(9))
年龄：9
>>> print(age + repr(9))
年龄：9

使用input获取用户输入的内容

>>> msg = input("请输入：")
请输入：小明
>>> print(msg)
小明
>>> print(type(msg))
<class 'str'>

长字符串使用三个引号（单引号、双引号都可以）

str = ```你好，这是
python长字符串```
print(str)

特殊字符反斜线，需要反义；或者使用"r"开头，表示原始字符串

>>> s = r"D:\project\python"
>>> print(s)
D:\project\python

python3新增type类型，代表字节（二进制），可用于网络传输，也可以存储各种二进制文件，比如图片、音乐等文件。
字符串转成字节的方法有3种：

# 1、如果为ASCII字符，可以在字符串前用b开头表示
>>> b = b'hello'
>>> print(b)
b'hello'
>>> print(b[0])
104
# 2、调用bytes()函数转换,默认使用UTF-8编码
>>> b = bytes("你好！", encoding="UTF-8")
>>> print(b)
b'\xe4\xbd\xa0\xe5\xa5\xbd\xef\xbc\x81'
# 3、使用字符串的encode()方法转成bytes,默认使用UTF-8编码
>>> b = '你好！'.encode('UTF-8')
>>> print(b)
b'\xe4\xbd\xa0\xe5\xa5\xbd\xef\xbc\x81'

字节转成字符的方法，用bytes的decode()转换

>>> b = b'\xe4\xbd\xa0\xe5\xa5\xbd\xef\xbc\x81'
>>> print(b.decode('utf-8'))
你好！

1.4.1 格式化输出

python字符串格式化符号:

符 号	描述	例子
%c	格式化字符及其ASCII码
%s	格式化字符串	print(“%s” % str2)
%d或%i	格式化整数
%u	格式化无符号整型
%o	格式化无符号八进制数
%x或%X	格式化无符号十六进制数
%f	格式化浮点数字，可指定小数点后的精度
%e或%E	用科学计数法格式化浮点数（e小写/大写）
%g	%f和%e的简写
%G	%F 和 %E 的简写
%p	用十六进制数格式化变量的地址

格式化操作符辅助指令:

符号	功能	例子
*	定义宽度或者小数点精度
-	用做左对齐	#2个空间大小输出，不够的用0补齐，左对齐 print(“%-02d”%a)
+	在正数前面显示加号( + )
	在正数前面显示空格
#	在八进制数前面显示零(‘0’)，在十六进制前面显示’0x’或者’0X’(取决于用的是’x’还是’X’)
0	显示的数字前面填充’0’而不是默认的空格
%	‘%%‘输出一个单一的’%’
(var)	映射变量(字典参数)	print(“%(name)s，年龄%(age)4d岁” % {“name”: ‘test’, “age”: 20})
m.n.	m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)

1.4.2 字符串操作

可以通过[]使用索引获取字符，字符串第一个索引号是0，第二个为1，依次类推；最后一个索引为-1，倒数第二个索引为-2，依次类推；

>>> s = "你好！早上好"
>>> print(s[1])
好
# 打印索引号1至3（不包含3）的字符
>>> print(s[1:3]) 
好！
>>> print(s[1:])
好！早上好

len()获取字符串长度

>>> print(len(s))
6

min()获取最小字符和max获取最大字符

>>> s = "abcdefg"
>>> print(min(s))
a
>>> print(max(s))
g

dir()列出指定类或模块包含的全部内容（包含函数、方法、类、变量等）

>>> dir(str)
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

help()查看某个函数或方法的帮助文档

>>> help(str)
Help on class str in module builtins:

class str(object)
 |  str(object='') -> str
 |  str(bytes_or_buffer[, encoding[, errors]]) -> str
 |
......

str类中与大小写有关的常用方法：

>>> s = "hello WORLD"
# title将每个单词的首字母大写
>>> s.title()
'Hello World'
# 将整个字符串小写
>>> s.lower()
'hello world'
# 将整个字符串大写
>>> s.upper()
'HELLO WORLD'

删除空白

>>> s = "  hello  "
# 删除左边的空白
>>> print(s.lstrip())
hello
# 删除右边的空白
>>> print(s.rstrip())
  hello
# 删除两边的空白
>>> print(s.strip())
hello

查找、替换相关方法

>>> s = 'hello world!'
# startswith判断是否以指定的字符串开头
>>> print(s.startswith('hello'))
True
# endswith判断是否以指定的字符串结尾
>>> print(s.endswith('ld'))
False
>>> print(s.endswith('ld!'))
True
# find查找指定子串在字符串中出现的位置，如果没有找到指定子串 ，则返回-1
>>> print(s.find('ld!'))
9
# index查找指定子串在字符串中出现的位置，如果没有找到指定子串，则引发ValueError错误
>>> print(s.index('ld!'))
9
# replace字符串替换
>>> print(s.replace('hello', '你好'))
你好 world!
#　maketrans生成映射表，
>>> table = str.maketrans('he', '你好')
>>> print(table)
{104: 20320, 101: 22909}
# translate根据映射表对字符串进行替换
>>> print(s.translate(table))
你好llo world!

字符串分割、连接

>>> s = 'hello world!'
# split将字符串按指定分割符分割成多个短语
>>> print(s.split('o'))
['hell', ' w', 'rld!']
>>> sj = s.split()
>>> print(sj)
['hello', 'world!']
# join将多个短语连接成字符串
>>> print(','.join(sj))
hello,world!

1.5、运算符

1.5.1、==与is区别

==与 is 很相似，==只比较两个变量的值，但is要求两个变量引用同一个对象。

import time
a = time.gmtime()
b = time.gmtime()
# 时间相等，输出True
print(a==b)
# a和b不是同一对象，输出False
print(a is b)
# 可以通过id()函数打印对象引用的内存地址
print(id(a))
print(id(b))

1.5.2、三元运算符

# 如果 x 为 True，返回 a；否则返回 b
a if x else b

1.5.3、in成员运算符

in判断某个成员是否位于序列中，同样提供not in;

>>> a = "Hello"
>>> print("H" in a)
True
>>> print(3 in [1, 2, 3])
True

2、列表、元组、字典

2.1、创建列表和元组

列表和元组的创建语法有点相似，列表使用方括号，元组使用圆括号，元素之间以英文逗号隔。

# 创建列表
>>> mylist = ["hello","world"]
>>> print(mylist)
['hello', 'world']
# 创建元组
>>> mytuple = ("hello", "world")
>>> print(mytuple)
('hello', 'world')

2.2、列表和元组通用的操作

在不涉及元素改变的操作，列表和元组是通用的。

>>> mylist = ["hello","world","你好","世界"]
# 1、通过索引下标访问元素
>>> print(mylist[0])
hello
# 2、子序列，分片语法[start : end : step]
>>> print(mylist[0:2])
['hello', 'world']
# 3、加法运算，只能列表和列表相加，元组和元组相加
>>> mylist2 = ["python"]
>>> mylist3 = mylist + mylist2
>>> print(mylist3)
['hello', 'world', '你好', '世界', 'python']

2.1.1 长度、最大值、最小值

Python 提供了内置的len()、 max()、 min()全局函数来获取元组或列表的长度、最大值和最小值。

>>> t = (-1,0,1,2,3)
# 长度
>>> print(len(t))
5
# 最大值
>>> print(max(t))
3
# 最小值
>>> print(min(t))
-1
>>> l = ['ab','bb','cb']
>>> print(len(l))
3
# 字符串按ASCII值比较
>>> print(max(l))
cb
>>> print(min(l))
ab

2.1.2 序列封包与解包

• 序列封包：把多个值赋给一个变量时，python会转为元组。
• 序列解包：python允许将元组或列表赋值给多个变量。

>>> vars = 1,2,3
>>> print(vars)
(1, 2, 3)
>>> print(type(vars))
<class 'tuple'>
>>> a,b,c = vars
>>> print(a,b,c)
1 2 3
# 可以只解出部分变量，剩下的使用列表保存，变量之前添加“＊”，那么该变量就代表是个列表，可以保存多个集合元素
>>> first, second, *rest = range(10)
>>> print(first,second,rest)
0 1 [2, 3, 4, 5, 6, 7, 8, 9]

2.3 列表

元组不可变，列表可以变；元组支持的操作，列表都支持；列表支持对元素的修改，元组不支持

2.3.1 列表和区间转换

list()函数可将元组、区间对象转换为列表

>>> t = ('hello',1,2)
>>> l = list(l)
>>> print(l)
['hello', 1, 2]
>>> r = range(1,5)
>>> l2 = list(r)
>>> print(l2)
[1, 2, 3, 4]
# 指定步长的区间
>>> r2 = range(1,10,2)
>>> l3 = list(r2)
>>> print(l3)
[1, 3, 5, 7, 9]

tuple()函数可将列表、区间对象转换为元组

>>> l = ['hello', 1,2]
>>> print(tuple(l))
('hello', 1, 2)
>>> r = range(1,10,2)
>>> print(tuple(r))
(1, 3, 5, 7, 9)

2.3.2 增加列表元素

列表的append()方法可以把单个值、元组、列表添加到列表的后面，但是参数中的元组或列表都作为单个元素。
列表的extend()方法实现类似功能，但是可以元组、列表不会作为整体添加。
列表的insert()方法将元素插入到指定位置。
del()函数可以根据索引删除列表中的元素，也可以删除变量，支持列表分片删除。
列表的remove()方法可以根据值删除元素。
列表的clear()清空列表元素。
元素的修改可以通过索引下标操作，也可以通过slice语法操作
列表的count()：用 于统计列表中某个元素出现的次数。
列表的index()：用 于判断某个元素在列表中出现的位置，如果不存在，会引发ValueError，在使用index()方法时还可传入start和end参数，用于在列表的指定范围内搜索元素。
列表的pop()：用于将列表当成“技”使用 实现元素 出战功能
列表的reverse()：用 于将列表中的元素反向存放
列表的sort()： 用于对列表元素排序。

# append()
>>> list1 = ['hello', 1,2]
# 添加单个值
>>> list1.append('world')
>>> print(list1)
['hello', 1, 2, 'world']
# 添加元组，元组作为单个元素添加到后面
>>> list1.append((3,4))
>>> print(list1)
['hello', 1, 2, 'world', (3, 4)]
# 添加列表，列表作为单个元素添加到后面
>>> list1.append(["python", "java"])
>>> print(list1)
['hello', 1, 2, 'world', (3, 4), ['python', 'java']]

# extend()
>>> list1 = ['hello', 1,2]
# 添加字符串，会把每个字符单独作为一个元素添加
>>> list1.extend('world')
>>> print(list1)
['hello', 1, 2, 'w', 'o', 'r', 'l', 'd']
# 添加元组
>>> list1.extend((3,4))
>>> print(list1)
['hello', 1, 2, 'w', 'o', 'r', 'l', 'd', 3, 4]
# 添加列表
>>> list1.extend(['python','list'])
>>> print(list1)
['hello', 1, 2, 'w', 'o', 'r', 'l', 'd', 3, 4, 'python', 'list']

# insert
>>> list1 = ['hello', 1,2]
>>> list1.insert(1, 'world')
>>> print(list1)
['hello', 'world', 1, 2]
>>> list1.insert(2, ('python','java'))
>>> print(list1)
['hello', 'world', ('python', 'java'), 1, 2]
>>> list1.insert(5, ['python','java'])
>>> print(list1)
['hello', 'world', ('python', 'java'), 1, 2, ['python', 'java']]

# del()
>>> list1 = ['hello', 1,2]
>>> print(list1)
['hello', 1, 2]
>>> del list1[0]
>>> print(list1)
[1, 2]
>>> del list1[0:2]
>>> print(list1)
[]
# 删除变量，会引发NameError错误
>>> del list1
>>> print(list1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'list1' is not defined. Did you mean: 'list'?

# remove
>>> list1 = ['hello', 1,2]
>>> list1.remove('hello')
>>> print(list1)
[1, 2]

# clear
>>> list1.clear()
>>> print(list1)
[]

# 修改
>>> list1 = ['hello', 1,2]
>>> list1[1] = 'world'
>>> print(list1)
['hello', 'world', 2]
>>> list1[1:3] = [3,4]
>>> print(list1)
['hello', 3, 4]

>>> list1 = list(range(1,10))
>>> print(list1)
# count,查找5在列表中出现的次数
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> print(list1.count(5))
1
# index,查找9在列表中出现的位置
>>> print(list1.index(9))
8
# index,查找9在列表中0，5区间出现的位置
>>> print(list1.index(9,0,5))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 9 is not in list
# pop
>>> print(list1.pop())
9
>>> print(list1)
[1, 2, 3, 4, 5, 6, 7, 8]
# reverse
>>> list1.reverse()
>>> print(list1)
[8, 7, 6, 5, 4, 3, 2, 1]

# sort默认从小到大排序
>>> list1.sort()
>>> print(list1)
[1, 2, 3, 4, 5, 6, 7, 8]
# sort传入reverse=True参数，从大到小排序
>>> list1.sort(reverse=True)
>>> print(list1)
[8, 7, 6, 5, 4, 3, 2, 1]

2.4 字典

2.4.1 创建

可以使用花括号创建，也可以使用dict()创建字典

>>> m = {"user":"test", "age":10}
>>> print(m)
{'user': 'test', 'age': 10}
>>> print(type(m))
<class 'dict'>
# 使用dict()可以把成对key-value的列表转为字典
>>> l = [['user', 'test'],['age', 10]]
>>> m2 = dict(l)
>>> print(m2)
{'user': 'test', 'age': 10}
# 因为元组是不可变，可以使用元组作为key。
>>> m3 = {('user','test'):10}
>>> print(m3)
{('user', 'test'): 10}
# 通过参数创建字典
>>> m4 = dict(user = 'test', age = 10)
>>> print(m4)
{'user': 'test', 'age': 10}

2.4.2 基本用法

>>> m = {'user':'test'}
# 通过key访问
>>> print(m['user'])
test
# 通过key修改
>>> m['user']='test10'
# 通过key添加
>>> m['age']=10
>>> print(m)
# 使用in或not in判断是否存在
{'user': 'test10', 'age': 10}
>>> print('user' in m)
True

2.4.3 常用方法

clear()用于清空宇典中所有的key-value对。
get()方法其实就是根据key来获取value,方括号访问不存在的key，字典会引起KeyError错误；get访问不存在的key，会返回None。
update()方法根据key-value对来更新己有的字典，如果不存在，则会添加。
items()、keys()、values()分别用于获取字典中的所key-value、 所有的key、所有value，依次返回dict_items、dict-keys、dict-values对象，可通过list把它们转换成列表再操作。
pop()方法用于获取指定key对应的value，并删除这个key-value。
popitem()方法用于随机弹出字典中的一个key-value对。
setdefault()方法也用于根据key来获取对应value, 但key在字典中不存在时，该方法会先为这个不存在key设置默认的value，然后再返回value。
fromkeys()方法使用给定的多个key创建字典，这些key对应的value默认都是None；也可以额外传入一个参数作为默认的value。

>>> m = {'user':'test'}
>>> print(m.get('user'))
test
>>> m.update({'age':10,'score':90})
>>> print(m)
{'user': 'test', 'age': 10, 'score': 90}
>>> item = m.items()
>>> print(type(item))
<class 'dict_items'>
>>> print(item)
dict_items([('user', 'test'), ('age', 10), ('score', 90)])
>>> print(list(item))
[('user', 'test'), ('age', 10), ('score', 90)]
>>> keys = m.keys()
>>> print(keys)
dict_keys(['user', 'age', 'score'])
>>> values = m.values()
>>> print(values)
dict_values(['test', 10, 90])
m.pop('test')
# 随机弹出一个key-value，可通过序列解包接收key和value
k,v = m.popitem()
m.
>>> m.clear()
>>> print(m)
{}
>>> dict.fromkeys(['a','b'])
{'a': None, 'b': None}
# 带默认值
>>> dict.fromkeys(['a','b'],10)
{'a': 10, 'b': 10}
# 使用字典格式化字符串
>>> text = '姓名：%(user)s,年龄：%(age)s'
>>> m = {"user":"test", "age":10}
>>> print(text % m)
姓名：test,年龄：10

3、流程控制

3.1、if分支

支持三种形式

>>> age = 10
# 第一种
>>> if age == 10:
...     print('age=10')
...

# 第二种
>>> if age == 10:
...     print('age=10')
... else:
...     print('age!=10')
...

# 第三种
>>> if age == 10:
...     print('age=10')
... elif age < 10:
...     print('age<10')
... elif age > 0:
...     print('age>10')
... else:
...     # pass 作为空语句,占位
...     pass

3.2、断言

断言语句用于对bool表达式进行断言，如果该bool表达式为True, 该程序可以继续执行，否则程序会引发AssertionError错误。

>>> age = input('请输入年龄：')
请输入年龄：10
>>> age = int(age)
>>> assert age < 10
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError

3.3、循环结构

3.3.1、while循环

>>> count_i = 10
>>> while count_i > 0:
...     print('count_i=', count_i)
...     count_i = count_i -1
...
count_i= 10
count_i= 9
count_i= 8
count_i= 7
count_i= 6
count_i= 5
count_i= 4
count_i= 3
count_i= 2
count_i= 1
>>> print('end count_i=', count_i)
end count_i= 0

# 遍历元组和列表
>>> m = ['hello', 'world']
>>> i = 0
>>> while i < len(m):
...     print(m[i])
...     i +=1
>>> while len(m) > 0:
...     print(m.pop())

3.3.2、for in循环

# 遍历列表、元组
>>> m = [1,1.1,2,2.0]
>>> for i in range(0, len(m)):
...     print(m[i])
1
1.1
2
2.0
>>> for ele in m:
...     if isinstance(ele, int):
...             print('整数:', ele)
...     elif isinstance(ele, float):
...             print('浮点数:', ele)
...
整数: 1
浮点数: 1.1
整数: 2
浮点数: 2.0

# 遍历字典
>>> m = {'user':'test', 'age':10}
# 第一种方式
>>> for k,v in m.items():
...     print(k,v)
...
user test
age 10
# 第二种方式
>>> for k in m.keys():
...     print(k,m[k])
...
user test
age 10
# 第三种方式
>>> for v in m.values():
...     print(v)
...
test
10

3.3.3、循环使用else

# while中使用else
>>> age = 10
>>> while age > 0:
...     print('age=%d大于0' % age)
...     age -= 1
... else:
...     print('age=%d小于0' % age)

# for中使用else
>>> age = 10
>>> for a in range(0,age):
...     print('age=%d' % a)
... else:
...     print('end age=%d' % a)

3.3.4、for表达式

语法：[表达式 for 循环计数器 in 可迭代对象]

>>> a = range(1,5)
>>> v = [x * x for x in a]
>>> print(v)
[1, 4, 9, 16]

# 使用if，只迭代符合条件的元素
>>> a = range(1,5)
>>> v = [x * x for x in a if x % 2 == 0]
>>> print(type(v))
<class 'list'>
>>> print(v)
[4, 16]

# 中括号改为圆括号，for不再是表达式，而是一个生成器。
>>> a = range(1,5)
>>> v_gen = (x * x for x in a if x % 2 == 0)
>>> print(type(v_gen))
<class 'generator'>
>>> for v in v_gen:
...     print(v, end='\t')
...
4       16

3.3.5、常用工具函数

zip()函数可以把多个列表“压缩”zip对象(可迭代对象)，如果列表长度不相等, 那么zip将以长度更短的列表为准。
reversed()函数实现反向遍历。
sorted()函数，该函数接收一个可迭代对象作为参数，返回一个对元素排序的列表，可传入reverse参数，如果将该参数设置为True，则表示反向排序。

# zip
>>> a = ['user', 'age']
>>> b = ['test',10]
>>> for k,v in zip(a,b):
...     print(k,v)
...
user test
age 10

# reversed
>>> a = ['user', 'age']
>>> [x for x in reversed(a)]
['age', 'user']
# sorted
>>> sorted(a)
['age', 'user']
>>> sorted(a,reverse=True)
['user', 'age']

3.3.6、控制循环结构

break：跳出循环
continue：中断本次循环
return：结束方法

4、函数和lambda表达式

4.1、函数定义

函数可以不加->表示动态定义和加->表示静态定义。

def 函数名(形参列表):
    #可执行语句组成的函数
    [return [返回值]]

# 在def那一行后面会加一个->，表示期待的输入类型和输出类型。
def add(a:int, b:int) -> int:
    return a+b

4.1.1、函数文档

函数文档在函数声明之后，函数体之前的一段字符串，可通过help()查看函数文档

>>> def test(x,y):
...      '''
...      test(x,y)
...              返回两个数之间转大的数
...      '''
...      z = x if x > y else y
...      return z
...
>>> help(test)
Help on function test in module __main__:

test(x, y)
    test(x,y)
            返回两个数之间转大的数

>>> print(test.__doc__)

     test(x,y)
             返回两个数之间转大的数

4.1.2、多个返回值

如果函数有多个返回值，会自动将多个返回值封装成元组。

4.2、函数参数

4.2.1、函数

>>> def test(user, age):
...     return {'user':user,'age':age}
...
# 按位置顺序传入参数
>>> print(test('test',10))
{'user': 'test', 'age': 10}
# 按关键字名传入参数，可不按顺序传入，注意关键参数只能放在参数列表后边传入。
>>> print(test(age=10,user='test'))
{'user': 'test', 'age': 10}
# 参数默认值age=10，有默认值的参数必须在后面
>>> def test(user, age=10):
...     return {'user':user,'age':age}
# 加＊代表可变参数，可变参数当成元组传入；允许可变参数位于任何位置，但带可变参数的函数最后位置只能有一个普通参数
>>> def test(*parames):
...     print(parames)
...
>>> test('test',10)
('test', 10)
# 加**两个星可以收集关键字参数，会被当成字典收集
>>> def test(**parames):
...      print(parames)
...
# 把列表或元组拆开传给参数，需要在传入的变量前加*
>>> test(user = 'test', age = 10)
{'user': 'test', 'age': 10}
>>> def test(user, age):
...     return {'user':user,'age':age}
...
>>> list1 = ['test',10]
>>> test(*list1)
{'user': 'test', 'age': 10}
# 把字典拆开传给参数，需要在传入的变量前加**
>>> map1 = {'user': 'test1', 'age': 11}
>>> test(**map1)
{'user': 'test1', 'age': 11}

4.2.2、变量作用域

python提供三个工具获取指定范围的变量字典
globals()：该函数返回全局范围内所有变量组成的“变量字典”
locals()：该函数返回当前局部范围内所有变量组成的“变量字典”
vars(object)：获取在指定对象范围内所有变量组成的“变量字典”。如果不传入object参数， vars和locals的作用完全相同。

age = 100
def userinfo():
    # 内部的age
    age = 10
    print('local age:', age)
    print('local age:', locals()['age'])
    print('locals vars:', locals())
    # 调用全局的age
    print('globals age:', globals()['age'])

    locals()['age'] = 11 # 修改不生效
    print('1 update local age', age)
    print('1 update local age:', locals()['age'])

    age = 12 # 修改生效
    print('2 update local age', age)
    print('2 update local age:', locals()['age'])


user = 'test'
userinfo()
print('locals vars:', locals())
print('globals vars:', globals())

globals()['age'] = 55
print('update globals age', age)
print('update globals age:', locals()['age'])

## 运行结果
#local age: 10
#local age: 10
#locals vars: {'age': 10}
#globals age: 100
#1 update local age 10
#1 update local age: 10
#2 update local age 12
#2 update local age: 12
#locals vars: {'age': 100, 'user': 'test'}
#globals vars: {'age': 100, 'user': 'test'}
#update globals age 55
#update globals age: 55

4.3、局部函数

函数可以作为参数传入函数体，也可以作为返回值返回
函数体内定义的函数

# 全局函数
def outfunc(type,n):
    m = 10
    # 内部函数
    def square(n):
        # nonlocal声明使用所在函数中的变量
        nonlocal m
        return m*n*n
    if type == 'value':
        return square(n)
    if type == 'func':
        return square

# 返回值
print(outfunc('value', 2))
# 返回函数
print(outfunc('func', 2))
# 返回函数时，再调用函数
print(outfunc('func', 2)(2))

4.4、lambda表达式

语法:

lambda 参数列表: 表达式

lambda表达式的本质就是匿名的、单行函数体的函数。适合用于单选函数、省去函数定义更简洁；用完释放，提高性能。
lambda表达式可以写成函数的形式。

lambda x , y:x + y
# 可改写为如下函数形式
def add(x, y): 
  return x+ y

5、类和对象

5.1、类、对象、方法

class Person:
    # 执行语句

    # 定义0至多个变量，变量可动态添加和删除，删除del
    hair = ' black '
    # 定义__init__构造方法，所有方法第一个参数是self，被绑定到构造方法初始化的对象
    def __init__ (self, name ='test', age = 10):
        # 增加两个实例变量
        self.name = name
        self.age= age

    # 定义0至多个方法
    # 定义了一个 say 方法
    def say(self, content):
        print(self.name,":",content)



## 实例化
person = Person()
print(person.name,person.age)
person.say('你好！')
# 动态添加变量
person.score = 100
print('score:',person.score)
# 动态添加方法，调用时需要手动传入self参数变量
def info(self):
    print("info:",self.name,self.age)
person.info = info
person.info(person)

person.info2 = lambda self:print("lambda info:",self.name,self.age)
person.info2(person)

# 使用MethodType自动绑定第一个参数
def info3(self):
    print("MethodType info:",self.name,self.age)

person.info3 = MethodType(info3,person)
person.info3()

info4 = person.info3
info4()

# 通过类也能调用方法，第一个参数需要手动传入
Person.say(person,'你好！，类名调用')

################# 运行结果 ##############
test 10
test : 你好！
score: 100
info: test 10
lambda info: test 10
MethodType info: test 10
MethodType info: test 10
test : 你好！，类名调用

5.2、类方法和静态方法

class Bird:
    # 使用@classmethod修饰的方法是类方法,类自动绑定到第一个参数
    @classmethod
    def fly(f):
        print("类方法fly：", f)

    # 使用@staticmethod修饰的方法是静态方法，需要手动绑定参数
    @staticmethod
    def info(i):
        print("静态方法info：", i)

# 调用类方法
Bird.fly()
# 调用静态方法
Bird.info('test')

#######运行结果#######
类方法fly： <class '__main__.Bird'>
静态方法info： test
类方法fly： <class '__main__.Bird'>
静态方法info： test2

5.3、函数修饰器

def funA(fn):
    print('funA method')
    fn()
    return 'funA result'

@funA
def funB():
    print('funB method')

print(funB)

#########运行结果###########
funA method
funB method
funA result

@符号来修饰函数是非常实用的功能，可以在被修饰函数前/后添加一些额外的处理逻辑，并且不需要修改被修饰函数的代码，其实是类似其他编程语言的AOP(面向切面编程)

def auth(fn):
    def auth_fn(*args):
        print('===先进行权限检查===')
        fn(*args)
    return auth_fn

@auth
def login(user, psw):
    print('登录login，参数a:%s，参数b:%s' % (user, psw))
login('test','123456')

5.4、使用property函数定义属性

在使用property()函数时，可传入4个参数，分别代表getter方法、setter方法、del方法和doc方法，其中doc是文档字符串，用于说明该属性。
在使用property可传入0个（不能读写）、1个（只读属性）、2个（读写属性）、3个（读写属性，也可删除）和4个（读写属性，也可删除，包含文档说明〉参数
property()函数

#coding=utf-8
class Foo(object):
    def get_bar(self):
        print("getter...")
        return 'laowang'

    def set_bar(self, value): 
        """必须两个参数"""
        print("setter...")
        return 'set value' + value

    def del_bar(self):
        print("deleter...")
        return 'laowang'

    BAR = property(get_bar, set_bar, del_bar, "description...")

obj = Foo()

obj.BAR  # 自动调用第一个参数中定义的方法：get_bar
obj.BAR = "alex"  # 自动调用第二个参数中定义的方法：set_bar方法，并将“alex”当作参数传入
desc = Foo.BAR.__doc__  # 自动获取第四个参数中设置的值：description...
print(desc)
del obj.BAR  # 自动调用第三个参数中定义的方法：del_bar方法

#################
getter...
setter...
description...
deleter...

@property装饰器

class Goods:
    @property
    def price(self):
        print('@property')

    @price.setter
    def price(self, value):
        print('@price.setter')

    @price.deleter
    def price(self):
        print('@price.deleter')

obj = Goods()
obj.price          # 自动执行 @property 修饰的 price 方法，并获取方法的返回值
obj.price = 123    # 自动执行 @price.setter 修饰的 price 方法，并将  123 赋值给方法的参数
del obj.price      # 自动执行 @price.deleter 修饰的 price 方法

################运行结果##############
@property
@price.setter
@price.deleter

5.5、隐藏和封装

python没有提供private修饰符，通过使用双下划线开头处理。

class MyClass:
    def __init__(self):
        self.__private = 0  # 私有变量
    def __private_method(self):
        pass  # 私有方法

########运行########        
obj = MyClass()
print(obj.__private)  # 报错，无法直接访问私有变量
obj.__private_method()  # 报错，无法直接调用私有方法        
       
# Python并没有像其他编程语言一样严格限制私有成员的访问，通过一种名为“名称修饰”的机制，将双下划线开头的变量名进行了变换。
# 变量__private在类内部被重命名为_MyClass__private，方法__private_method在类内部被重命名为_MyClass__private_method。
obj = MyClass()
print(obj._MyClass__private)  # 访问重命名后的私有变量
obj._MyClass__private_method()  # 调用重命名后的私有方法  

5.6、继承

Python支持多继承，子类继承的语法是在定义子类时，将多个父类放在子类之后的圆括号里。
如果多个父类包含了同名的方法，排在前面的父类方法会遮蔽排在后面的父类同名方法。

class Fruit:
    def info(self):
        print("水果:%s" % self.name)

class Food:
    def taste(self):
        print("口感:%s" % self.tast)

# 定义Apple类，继承了Fruit和Foot类
class Apple(Fruit, Food):
    name = '苹果'
    tast = '甜'

a = Apple()
a.info()
a.taste()

5.6.1、重载

子类重写父类方法后，可以通过类名的方式调用，注意类名的方式调用不会自动绑定第一个self参数
使用super调用父类的构造方法，会自动绑定第一个参数。

class A:
    def __init__(self):
        print("打印属性 a")

class B(A):
    def __init__(self):
        print("打印属性 b")
        A.__init__(self)  # super() 等同于 super(B, self)

class C(A):
    def __init__(self):
        print("打印属性 c")
        A.__init__(self)  # super() 等同于 super(C, self)

class D(B, C):
    def __init__(self):
        print("打印属性 d")
        B.__init__(self)
        C.__init__(self)

d = D()

##############
打印属性 d
打印属性 b
打印属性 a
打印属性 c

5.6.2、动态性

Python是动态语言，类、对象的属性、方法都可以动态增加和修改，任何类的实例包含一个字典__dict__,
如果程序要限制某个类允许动态添加的属性和方法，可以通过__slots__属性指定，__slots__的作用是阻止在实例化类时为实例分配dict。

5.6.3、使用type函数创建类

当type（）只有一个参数时，其作用就是返回变量或对象的类型当type（）有三个参数时，其作用就是创建类对象：

• 第一个参数：name表示类名称，字符串类型
• 第二个参数：bases表示继承对象（父类），元组类型，单元素使用逗号
• 第三个参数：attr表示属性，这里可以填写类属性、类方式、静态方法，采用字典格式，key为属性名，value为属性值
  语法：type(类名, 父类的元组（针对继承的情况，可以为空），包含属性的字典（名称和值）)

def add(self, age):
    self.age += age

Myclass = type('Myclass', (), {'age': 10, 'add': add})
c = Myclass()
print('age:',c.age)
c.add(100)
print('add age:',c.age)

#############运行结果#############
age: 10
add age: 110

5.6.4、使用metaclass

metaclass可以控制类的创建过程，包括类的属性、方法和父类等。metaclass可以用于实现一些高级的编程技巧，例如自动注册子类、自动添加属性和方法等
在Python当中，call,new,init__三者之间的关系
在类实例化的过程当中，哪个对象加()就寻找产生这个对象的类的__call__方法，只要是__call__方法，一定会做三件事情：
1、调用__new__方法，构造新的对象，相当于Java当中的构造函数.（对象自己的__new）
2、调用__init__方法,去初始化这个对象（对象自己的__init__）
3、返回这个对象.

class Mymeta(type):  # 只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类
    def __init__(self, class_name, class_bases, class_dic):
        print('Mymeta self:', self)  # 现在是People
        print('Mymeta class_name:', class_name)
        print('Mymeta class_bases:', class_bases)
        print('Mymeta class_dic:', class_dic)
        super(Mymeta, self).__init__(class_name, class_bases,class_dic)  # 重用父类type的功能
class People(object, metaclass=Mymeta):  # People=Mymeta(类名,基类们,类的名称空间)
    country = 'China'

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def eat(self):
        print('People：%s is eating' % self.name)

p = People('test', 10)
p.eat()

##########运行######
Mymeta self: <class '__main__.People'>
Mymeta class_name: People
Mymeta class_bases: (<class 'object'>,)
Mymeta class_dic: {'__module__': '__main__', '__qualname__': 'People', 'country': 'China', '__init__': <function People.__init__ at 0x000001DB996FF5E0>, 'eat': <function People.eat at 0x000001DB996FF670>}
People：test is eating

5.7、检查类型

Python提供了两个函数来检查类型

• issubclass(cls,class_or_tuple):检查cls是否为后一个类或元组包含的多个类中任意类的子类。
• isinstance(obj,class_or_tuple):检查obj是否为后一个类或元组包含的多个类中任意类的对象。
  Python为所有类提供一个__bases__属性，查看该类的所的直接父类，返回父类组成的元组。
  Python为所有类提供一个__subclasses__()方法，查看该类的所有直接子类，返回该类的所有子类组成的列表。

5.8、枚举类

程序有两种方式来定义枚举类：

• 直接使用 Enum 列出多个枚举值来创建枚举类。
• 通过继承 Enum 基类来派生枚举类。
  直接使用 Enum 列出多个枚举值来创建枚举类：

import enum
#定义枚举类
Season = enum.Enum('Season', ('SPRING', 'SUMMER', 'FALL', 'WINTER'))
#直接访问指定枚举对象
print(Season.SPRING)
#访问枚举成员的变量名
print(Season.SPRING.name)
#访问枚举成员的值
print(Season.SPRING.value)
#根据枚举变量名访问枚举对象
print(Season['SUMMER'])    #输出Season.SUMMER
#根据枚举值访问枚举对象       #输出Season.FALL
print(Season(3))

####################
Season.SPRING
SPRING
1
Season.SUMMER
Season.FALL

如果要定义更复杂的枚举，则可通过继承 Enum 来派生枚举类

import enum
class Orientation(enum.Enum):
    #为序列指定值
    EAST = '东'
    SOUTH = '南'
    WEST = '西'
    NORTH = '北'
    def info(self):
        print('这是一个定义方向为【%s】的枚举'% self.value)
print(Orientation.SOUTH)
print(Orientation.SOUTH.value)
#通过枚举变量访问枚举
print(Orientation['WEST'])
#通过枚举值访问枚举
print(Orientation('北'))
#调用枚举的info()方法
Orientation.EAST.info()
#循环遍历Orientation枚举的所有成员
for name, member in Orientation.__members__.items():
    print(member, '--->', name, '--->', member.value)
    
###########运行###########
Orientation.SOUTH
南
Orientation.WEST
Orientation.NORTH
这是一个定义方向为【东】的枚举
Orientation.EAST ---> EAST ---> 东
Orientation.SOUTH ---> SOUTH ---> 南
Orientation.WEST ---> WEST ---> 西
Orientation.NORTH ---> NORTH ---> 北

6、异常处理

6.1、异常处理机制

try:
	pass # 尝试做
except ValueError as e:
	pass # 捕获一个错误
except (TypeError, SyntaxError) as e:
	pass # 捕获多个错误
except Exception as e:
	pass # 捕获其他错误
else:
	pass # 没有捕捉到错误
finally:
	pass # 最终都会执行

6.2、raise引发异常

python会自动引发异常，也可以通过raise显示地引发异常。

try:
     s = None
     if s is None:
         print "s 是None对象"
         raise NameError     #如果引发NameError异常，后面的代码将不能执行
     print len(s)  
except TypeError:
     print "空对象没有长度"
 
s = None
if s is None:
    raise NameError 
print 'is here?' 

7、特殊属性和方法

7.1、特殊属性

Class.__doc__ # 类型帮助信息 ‘Class1 Doc.’
Class.__name__ # 类型名称 ‘Class1’
Class.__module__ # 类型所在模块 ‘main’
Class.__bases__ # 类型所继承的基类 (<type ‘object’>,)
Class.__dict__ # 类型字典，存储所有类型成员信息。 <dictproxy object at 0x00D3AD70>
obj.__class__ # 类型 <class ‘__main__.Class1’>
obj.__module__ # 实例类型所在模块 ‘__main__’
obj.__dict__ # 对象字典，存储所有实例成员信息。 {‘i’: 1234}

7.2、对象创建和销毁

__new__(cls, ...): #创建对象时调用，返回一个新的实例。
__init__(self, ...): #对象初始化时调用，用于设置对象的初始状态。
__del__(self): #对象被销毁时调用，进行资源清理操作。

7.3、字符串表示和格式化

__str__(self): #将对象转换为字符串的方法，通过str(obj)或print(obj)调用。
__repr__(self): #将对象转换为供开发者阅读的字符串的方法，通过repr(obj)调用。
__format__(self, format_spec): #格式化对象的方法，通过format(obj, format_spec)调用。

7.4、属性访问和设置

__getattr__(self, name): #获取不存在的属性时调用。
__setattr__(self, name, value): #设置属性值时调用。
__delattr__(self, name): #删除属性时调用。
__getattribute__(self, name): #获取属性时调用，无论属性是否存在。

7.5、容器类型操作

__len__(self): #返回对象的长度，通过len(obj)调用。
__getitem__(self, key): #获取对象的索引值或键值对应的值，通过obj[key]调用。
__setitem__(self, key, value): #设置对象的索引值或键值对应的值，通过obj[key] = value调用。
__delitem__(self, key): #删除对象的索引值或键值对应的值，通过del obj[key]调用。
__iter__(self): #返回一个迭代器对象，通过iter(obj)调用。
__next__(self): #在迭代器中返回下一个元素，通过next(obj)调用。
__contains__(self, item): #检查对象是否包含某个元素，通过item in obj调用。

7.6、函数调用和可调用对象

__call__(self, ...): #将对象作为函数调用，通过obj()调用。

7.7、比较和排序

__eq__(self, other): #比较对象是否相等，通过obj == other调用。
__ne__(self, other): #比较对象是否不相等，通过obj != other调用。
__lt__(self, other): #比较对象是否小于，通过obj < other调用。
__gt__(self, other): #比较对象是否大于，通过obj > other调用。
__le__(self, other): #比较对象是否小于等于，通过obj <= other调用。
__ge__(self, other): #比较对象是否大于等于，通过obj >= other调用。

7.8、数值运算

__add__(self, other): #加法运算，通过obj + other调用。
__sub__(self, other): #减法运算，通过obj - other调用。
__mul__(self, other): #乘法运算，通过obj * other调用。
__truediv__(self, other): #真除法运算，通过obj / other调用。
__floordiv__(self, other): #整除法运算，通过obj // other调用。
__mod__(self, other): #取模运算，通过obj % other调用。
__pow__(self, other): #幂运算，通过obj ** other调用。

7.9、位运算

__and__(self, other): #位与运算，通过obj & other调用。
__or__(self, other): #位或运算，通过obj | other调用。
__xor__(self, other): #位由于回答的内容过长，无法完整列出所有的特殊方法。

8、模块和包

python3标准库

8.1、导入模块

import module1 # 导入一个模块
import package1.module1 # 导入一个包中的模块
import module1 as alias # 给模块起别名
from module1 import func1 # 从模块中导入一个函数
from module1 import * # 导入模块中的所有函数

# 导入 sys,os两个模块，并为sys指定别名s，为os指定别名o。
import sys as s,os as o
# 使用模块别名作为前缀来访问模块中的成员
print(s.argv[0])
print (o.sep)

##########运行结果######
test.py
\

8.2、包和模块

模块文件的文件名就是它的模块名，比如modulel.py的模块名就是modulel

模块：python的源码文件,模块的形式如“xxx.py”。
包：存放模块的文件夹，包的名字就是此文件夹的名字。每个包中都包含文件__init__.py，表明这个文件夹是python的包。

8.3、模块相关的方法

import string
# dir()函数可以返回模块或类的所有成员（变量、方法、类），包含双下划线成员
print(dir(string))
# 使用模块自带的变量查看所有，不包含双下划线成员
print(string.__all__)

# help查看文档信息
help(string.capwords)
# __doc__查看文档信息
print(string.capwords.__doc__)

# 查看模块的源码文件路径
print(string.__file__)

9、常见模块

• Python 教程
• Python 语言参考手册
• Python标准库
• Python 模块索引

9.1、基本模块

• 文本处理服务
  • string — 常见的字符串操作
  • re — 正则表达式操作
  • difflib — 计算差异的辅助工具
  • textwrap — 文本自动换行与填充
  • unicodedata — Unicode 数据库
  • stringprep — 因特网字符串预备
  • readline — GNU readline 接口
  • rlcompleter — GNU readline 的补全函数
• 二进制数据服务
  • struct — 将字节串解读为打包的二进制数据
  • codecs — 编解码器注册和相关基类
• 数据类型
  • datetime — 基本日期和时间类型
  • zoneinfo — IANA 时区支持
  • calendar — 日历相关函数
  • collections — 容器数据类型
  • collections.abc — 容器的抽象基类
  • heapq — 堆队列算法
  • bisect — 数组二分查找算法
  • array — 高效的数字数组
  • weakref — 弱引用
  • types — 动态类型创建和内置类型名称
  • copy — 浅层 (shallow) 和深层 (deep) 复制操作
  • pprint — 数据美化输出
  • reprlib — 另一种 repr() 实现
  • enum — 对枚举的支持
  • graphlib — 操作类似图的结构的功能
• 数字和数学模块
  • numbers — 数字的抽象基类
  • math — 数学函数
  • cmath — 关于复数的数学函数
  • decimal — 十进制定点和浮点运算
  • fractions — 分数
  • random — 生成伪随机数
  • statistics — 数学统计函数
• 函数式编程模块
  • itertools — 为高效循环而创建迭代器的函数
  • functools — 高阶函数和可调用对象上的操作
  • operator — 标准运算符替代函数
• 文件和目录访问
  • pathlib — 面向对象的文件系统路径
  • os.path — 常用路径操作
  • fileinput — 迭代来自多个输入流的行
  • stat — 解析 stat() 结果
  • filecmp — 文件及目录的比较
  • tempfile — 生成临时文件和目录
  • glob — Unix 风格路径名模式扩展
  • fnmatch — Unix 文件名模式匹配
  • linecache — 随机读写文本行
  • shutil — 高阶文件操作
• 数据持久化
  • pickle — Python 对象序列化
  • copyreg — 注册配合 pickle 模块使用的函数
  • shelve — Python 对象持久化
  • marshal — 内部 Python 对象序列化
  • dbm — Unix “数据库” 接口
  • sqlite3 — SQLite 数据库 DB-API 2.0 接口模块
• 数据压缩和存档
  • zlib — 与 gzip 兼容的压缩
  • gzip — 对 gzip 格式的支持
  • bz2 — 对 bzip2 压缩算法的支持
  • lzma — 用 LZMA 算法压缩
  • zipfile — 使用ZIP存档
  • tarfile — 读写tar归档文件
• 文件格式
  • csv — CSV 文件读写
  • configparser — 配置文件解析器
  • tomllib — 解析 TOML 文件
  • netrc — netrc 文件处理
  • plistlib — 生成与解析 Apple .plist 文件
• 加密服务
  • hashlib — 安全哈希与消息摘要
  • hmac — 基于密钥的消息验证
  • secrets — 生成管理密码的安全随机数
• 通用操作系统服务
  • os — 多种操作系统接口
  • io — 处理流的核心工具
  • time — 时间的访问和转换
  • argparse — 命令行选项、参数和子命令解析器
  • getopt — C 风格的命令行选项解析器
  • logging — Python 的日志记录工具
  • logging.config — 日志记录配置
  • logging.handlers — 日志处理程序
  • getpass — 便携式密码输入工具
  • curses — 终端字符单元显示的处理
  • curses.textpad — 用于 curses 程序的文本输入控件
  • curses.ascii — 用于 ASCII 字符的工具
  • curses.panel — curses 的面板栈扩展
  • platform — 获取底层平台的标识数据
  • errno — 标准 errno 系统符号
  • ctypes — Python 的外部函数库
• 并发执行
  • threading — 基于线程的并行
  • multiprocessing — 基于进程的并行
  • multiprocessing.shared_memory — 可跨进程直接访问的共享内存
  • The concurrent package
  • concurrent.futures — 启动并行任务
  • subprocess — 子进程管理
  • sched — 事件调度器
  • queue — 一个同步的队列类
  • contextvars — 上下文变量
  • _thread — 底层多线程 API
• 网络和进程间通信
  • asyncio — 异步 I/O
  • socket — 底层网络接口
  • ssl — 套接字对象的 TLS/SSL 包装器
  • select — 等待 I/O 完成
  • selectors — 高级 I/O 复用库
  • signal — 设置异步事件处理程序
  • mmap — 内存映射文件支持
• 互联网数据处理
  • email — 电子邮件与 MIME 处理包
  • json — JSON 编码和解码器
  • mailbox — 操作多种格式的邮箱
  • mimetypes — 映射文件名到 MIME 类型
  • base64 — Base16, Base32, Base64, Base85 数据编码
  • binascii — 二进制和 ASCII 码互转
  • quopri — 编码与解码经过 MIME 转码的可打印数据
• 结构化标记处理工具
  • html — 超文本标记语言支持
  • html.parser — 简单的 HTML 和 XHTML 解析器
  • html.entities — HTML 一般实体的定义
  • XML处理模块
  • xml.etree.ElementTree — ElementTree XML API
  • xml.dom — 文档对象模型 API
  • xml.dom.minidom — 最小化的 DOM 实现
  • xml.dom.pulldom — 支持构建部分 DOM 树
  • xml.sax — 支持 SAX2 解析器
  • xml.sax.handler — SAX 处理句柄的基类
  • xml.sax.saxutils — SAX 工具集
  • xml.sax.xmlreader — 用于 XML 解析器的接口
  • xml.parsers.expat — 使用 Expat 的快速 XML 解析
• 互联网协议和支持
  • webbrowser — 方便的 Web 浏览器控制工具
  • wsgiref — WSGI 工具和参考实现
  • urllib — URL 处理模块
  • urllib.request — 用于打开 URL 的可扩展库
  • urllib.response — urllib 使用的 Response 类
  • urllib.parse 用于解析 URL
  • urllib.error — urllib.request 引发的异常类
  • urllib.robotparser — robots.txt 语法分析程序
  • http — HTTP 模块
  • http.client — HTTP 协议客户端
  • ftplib — FTP 协议客户端
  • poplib — POP3 协议客户端
  • imaplib — IMAP4 协议客户端
  • smtplib — SMTP 协议客户端
  • uuid — RFC 4122 定义的UUID对象
  • socketserver — 用于网络服务器的框架
  • http.server — HTTP 服务器
  • http.cookies — HTTP状态管理
  • http.cookiejar —— HTTP 客户端的 Cookie 处理
  • xmlrpc — XMLRPC 服务端与客户端模块
  • xmlrpc.client — XML-RPC 客户端访问
  • xmlrpc.server — 基本 XML-RPC 服务器
  • ipaddress — IPv4/IPv6 操作库
• 多媒体服务
  • wave — 读写WAV格式文件
  • colorsys — 颜色系统间的转换
• 国际化
  • gettext — 多语种国际化服务
  • locale — 国际化服务
• 程序框架
  • turtle — 海龟绘图
  • cmd — 支持面向行的命令解释器
  • shlex —— 简单的词法分析
• Tk图形用户界面(GUI)
  • tkinter —— Tcl/Tk 的 Python 接口
  • tkinter.colorchooser — 颜色选择对话框
  • tkinter.font — Tkinter 字体封装
  • Tkinter 对话框
  • tkinter.messagebox — Tkinter 消息提示
  • tkinter.scrolledtext — 滚动文字控件
  • tkinter.dnd — 拖放操作支持
  • tkinter.ttk — Tk 风格的控件
  • tkinter.tix — TK扩展包
  • IDLE
• 开发工具
  • typing —— 对类型提示的支持
  • pydoc — 文档生成器和在线帮助系统
  • Python 开发模式
  • doctest — 测试交互式的 Python 示例
  • unittest — 单元测试框架
  • unittest.mock — 模拟对象库
  • unittest.mock — 上手指南
  • 2to3 — 自动化的 Python 2 到 3 代码转写
  • test — Python 回归测试包
  • test.support — 针对 Python 测试套件的工具
  • test.support.socket_helper — 用于套接字测试的工具
  • test.support.script_helper — 用于 Python 执行测试工具
  • test.support.bytecode_helper — 用于测试正确字节码生成的支持工具
  • test.support.threading_helper — 用于线程测试的工具
  • test.support.os_helper — 用于操作系统测试的工具
  • test.support.import_helper — 用于导入测试的工具
  • test.support.warnings_helper — 用于警告测试的工具
• 调试和分析
  • 审计事件表
  • bdb — 调试器框架
  • faulthandler —— 转储 Python 的跟踪信息
  • pdb — Python 的调试器
  • Python 性能分析器
  • timeit — 测量小代码片段的执行时间
  • trace —— 跟踪 Python 语句的执行
  • tracemalloc — 跟踪内存分配
• 软件打包和分发
  • ensurepip — 引导 pip 安装器
  • venv — 创建虚拟环境
  • zipapp —— 管理可执行的 Python zip 打包文件
• Python 运行时服务
  • sys — 系统相关的形参和函数
  • sys.monitoring — 执行事件监测
  • sysconfig —— 提供对 Python 配置信息的访问支持
  • builtins — 内建对象
  • main ——顶层代码环境
  • warnings ——控制警告信息
  • dataclasses — 数据类
  • contextlib — 为 with语句上下文提供的工具
  • abc — 抽象基类
  • atexit — 退出处理器
  • traceback —— 打印或读取栈回溯信息
  • future — Future 语句定义
  • gc — 垃圾回收器接口
  • inspect — 检查对象
  • site —— 指定域的配置钩子
• 自定义 Python 解释器
  • code — 解释器基类
  • codeop — 编译Python代码
• 导入模块
  • zipimport — 从 Zip 存档中导入模块
  • pkgutil — 包扩展工具
  • modulefinder — 查找脚本使用的模块
  • runpy ——查找并执行 Python 模块
  • importlib — import 的实现
  • importlib.resources – 包资源的读取、打开和访问
  • importlib.resources.abc – 针对资源的抽象基类
  • importlib.metadata – 访问软件包元数据
  • sys.path 模块搜索路径的初始化
• Python 语言服务
  • ast — 抽象语法树
  • symtable ——访问编译器的符号表
  • token — 与Python解析树一起使用的常量
  • keyword — 检验Python关键字
  • tokenize — 对 Python 代码使用的标记解析器
  • tabnanny — 模糊缩进检测
  • pyclbr — Python 模块浏览器支持
  • py_compile — 编译 Python 源文件
  • compileall — 字节编译 Python 库
  • dis — Python 字节码反汇编器
  • pickletools — pickle 开发者工具集
• Windows系统相关模块
  • msvcrt — 来自 MS VC++ 运行时的有用例程
  • winreg — 访问 Windows 注册表
  • winsound —— Windows 系统的音频播放接口
• Unix 专有服务
  • posix — 最常见的 POSIX 系统调用
  • pwd — 用户密码数据库
  • grp — 组数据库
  • termios — POSIX 风格的 tty 控制
  • tty — 终端控制功能
  • pty — 伪终端工具
  • fcntl —— 系统调用 fcntl 和 ioctl
  • resource — 资源使用信息
  • Unix syslog 库例程
• 模块命令行界面（CLI）
• 被取代的模块
  • aifc — 读写 AIFF 和 AIFC 文件
  • audioop — 处理原始音频数据
  • cgi — 通用网关接口支持
  • cgitb — 用于 CGI 脚本的回溯管理器
  • chunk — 读取 IFF 分块数据
  • crypt —— 验证 Unix 口令的函数
  • imghdr — 推测图像类型
  • mailcap — Mailcap 文件处理
  • msilib — 读写 Microsoft Installer 文件
  • nis — Sun 的 NIS (黄页) 接口
  • nntplib — NNTP 协议客户端
  • optparse — 命令行选项的解析器
  • ossaudiodev — 访问兼容OSS的音频设备
  • pipes — 终端管道接口
  • sndhdr — 推测声音文件的类型
  • spwd —— shadow 密码库
  • sunau — 读写 Sun AU 文件
  • telnetlib – Telnet 客户端
  • uu — 对 uuencode 文件进行编码与解码
  • xdrlib — 编码与解码 XDR 数据