python基础

编程风格

\#!/usr/bin/env python   #在文件头部 ( 第一行 ) 加上  设置 Python 解释器 

 

\# -*- coding: utf-8 -*- #在文件头部 ( 第二行 ) 加上  在编辑器中设置以 UTF-8 默认编码保存文件 

 

\# Copyright (c) ***  #版权信息放在文件头部,文件编码之后  

 

\# docstring 是Python特有的注释风格,它是模块、类或函数的第一个语句,可以通过__doc__方法访问  

 

\# 用英语撰写注释,短注释可以忽略末尾的句号 (.) 

 

\# docstring 为每个模块、类或函数撰写 

 

docstring 推荐使用三个双引号(”””) 来定义

 

docsting , 不推荐使用三个单引号 (''') # 模块的 docsting 放在文件头部,版权信息之后  

 

”””This is a one line docstring.””” 

 

”””The title of a multiline docstring: After title is the content.You can write it as long 

 

as needed. ”””  

 \# 把 import 语句放在文件头部,在模块 docstring 之后,在模块全局变量或全局常量之前 

 

\# 按照从一般到特殊的原则分组 

 

import 语句,

先 import 标准库,

然后 import 第三方库,

最后 import 程序中的自定义库 

 

\# 在不同分组的 import 语句之间加空行  # 每个 import 语句只导入一个模块  

 

import sys  

 

import time  

 

from PyQt.QtCore import SIGNAL, QTimer  # 在终端中使用中文字符 在文件头部加上 

 

\# import sys  

 

\# reload(sys)  

 

\# sys.setdefaultencoding('utf-8')

 

 

设置自动生成代码头

 $ {PROJECT_NAME} # 当前项目名

 

 $ {NAME} #当前文件名

 

 ${PRODUCT_NAME}    #当前集成开发环境

 

 $ {USER}#当前用户的登录名

 

 $ {DATE}#当前系统日期

 

 $ {TIME}#当前系统时间

 

 $ {YEAR} #当年

 

 $ {MONTH}#当月

 

 $ {DAY} #当天

 

 $ {HOUR} #当前小时

 

 $ {MINUTE} #当前分钟

 

 ${SECOND} #当前秒

 

 ${MONTH_NAME_SHORT}#月份名称的前三个字母

 

 ${MONTH_NAME_FULL}# 一个月的全名

python基础语法部分：

环境变量：

环境变量是指搞告诉电脑，我的python在我设置的目录的那个地方。

电脑机制：

当前目录下查找支持文件没有，就到环境变量中去找，还没有就软件报错，

多行语句

Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠 ** 来实现多行语句，

数据类型：

1. int (整数), 如 1, 只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
2. bool (布尔), 如 True。
3. float (浮点数), 如 1.23、3E-2
4. complex (复数), 如 1 + 2j、 1.1 + 2.2j

空行

1. 函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。
2. 空行与代码缩进不同，空行并不是Python语法的一部分。书写时不插入空行，Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。

记住：空行也是程序代码的一部分。

print()

1、print语法格式

print()``函数具有丰富的功能，详细语法格式如下：
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
默认情况下，将值打印到流或``sys.stdout``。

可选关键字参数：

file``：类文件对象（``stream``）``; ``默认为当前的``sys.stdout``。
sep``：在值之间插入的字符串，默认为空格。
end``：在最后一个值后附加的字符串，默认为换行符。
flush``：是否强制刷新流。

2、sep可选关键字参数

sep``参数可以在值之间插入字符串，默认值为空格。
例：
print('1','2','3','4',sep = "``插入``")
输出结果：
1``插入``2``插入``3``插入``4

3、file可选关键字参数

file``参数默认值为``sys.stdout``，代表系统标准输出，即屏幕。我们可以通过改变该参数使``print()``函数输出到特定的文件中。
例：
f = open(r"F:\text.txt","w")  # ``打开文件，以便写入
print('test',file = f) # ``输出到文件
f.close()  # ``关闭文件
 
运行后，可以看到``test``输出到``text.txt``文件中。

4、end可选关键字参数

end``参数默认为``"\n"``（换行符），如果想在``print()``函数输出之后输出别的字符串，可以重设``end``参数。
例：
print('1','2',end = "``最后``")
print('\r1 2',end = ""):``可以强制一行，每次刷新都在行首，这个也可以用``flush``强制刷新
输出结果：
1 2``最后``>>>
运行后，我们可以看到，``print()``函数输出之后不会换行，且在最后一个值后面附加了``“``最后``”``。

5、flush可选关键字参数

而``print``的输出是否被缓存通常决定于``file``，但如果``flush``参数值为``True``，流会被强制刷新``(flush``默认为``false)``。这里需要先看下缓冲是怎么回事

类型	说明	输出情况
满缓冲	I/O``操作只有在缓冲区被填满之后才会进行	1.``缓冲区满 2.``刷出数据``flush 3.``关闭文件
行缓冲	通常只有遇到换行符时，才会执行实际的``I/O``操作；但缓冲区满也会强制执行	1.``遇到换行符 2.``缓冲区满 3.``刷出数据``flush 4.``关闭文件
无缓冲	不缓存，直接进行``I/O``操作	直接输出

多个语句构成代码组

缩进相同的一组语句构成一个代码块，我们称之代码组。

像if、while、def和class这样的复合语句，首行以关键字开始，以冒号( : )结束，该行之后的一行或多行代码构成代码组。

我们将首行及后面的代码组称为一个子句(clause)。

如下实例：

if expression : `
 `  suite`
 `elif expression : `
 `  suite `
 `else : `
 `  suite

三元表达式

条件成立时要返回的值 if 条件 else 条件不成立返回的值

def num(x,y):
ifx>y:
returnx
else:
returny
 
 
a=num(1,2)
#``用三元表达式运行上面的函数
#``三元表达式语法：
#``条件成立时要返回的值``if``条件``else``条件不成立返回的值
x=1
y=2
res=11 if x>y else 22
 
print(res)

import 与 from...import

1. 在 python 用 import 或者 from...import 来导入相应的模块。
2. 将整个模块(somemodule)导入，格式为： import somemodule
3. 从某个模块中导入某个函数,格式为： from somemodule import somefunction
4. 从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc
5. 将某个模块中的全部函数导入，格式为： from somemodule import *

Python3 基本数据类型 | 菜鸟教程 (runoob.com)

pythonm数据类型

多个变量赋值

1. Python允许你同时为多个变量赋值。例如：

a = b = c = 1

创建一个整型对象，值为 1，从后向前赋值，三个变量被赋予相同的数值。

1. 您也可以为多个对象指定多个变量。例如：

a, b, c = 1, 2, "runoob"

两个整型对象 1 和 2 的分配给变量 a 和 b，字符串对象 "runoob" 分配给变量 c。

标准数据类型

• Python3 中有Python的七种数据类型
• Number（数字）
• 布尔(Booleans)： True和False
• String（字符串）
• List（列表）
• Tuple（元组）
• Set（集合）
• Dictionary（字典）

Python3 的六个标准数据类型中：

不可变数据（**3 个）：

Number（数字）、String（字符串）、Tuple（元组）；

可变数据（**3 个）：

List（列表）、Dictionary（字典）、Set（集合）。

Python3 基本数据类型 | 菜鸟教程 (runoob.com)

Number（数字）

Python3 支持 int****、float、bool、complex（复数）。

在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。

像大多数语言一样，数值类型的赋值和计算都是很直观的。

内置的 type() 函数可以用来查询变量所指的对象类型。

isinstance 和 type 的区别在于：

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

注意：

Python3 中，bool 是 int 的子类，True 和 False 可以和数字相加 True==1*，False==0* 是会返回 *Ture*，但可以通过 *is* 来判断类型。

数值运算

实例

>>> 5 + 4 # 加法

9

>>> 4.3 - 2 # 减法

2.3

>>> 3 * 7 # 乘法

21

>>> 2 / 4 # 除法，得到一个浮点数

0.5

>>> 2 // 4 # 除法，得到一个整数

0

>>> 17 % 3 # 取余

2

>>> 2 ** 5 # 乘方

32

注意：

• 1、Python可以同时为多个变量赋值，如a, b = 1, 2。
• 2、一个变量可以通过赋值指向不同类型的对象。
• 3、数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。
• 4、在混合计算时，Python会把整型转换成为浮点数。

String（字符串）

Python中的字符串用单引号 ' 或双引号 " 括起来，同时使用反斜杠 ** 转义特殊字符。

字符串的截取的语法格式如下：

变量[头下标:尾下标]

索引值以 0 为开始值，-1 为从末尾的开始位置。

加号 + 是字符串的连接符， 星号 ***** 表示复制当前字符串，与之结合的数字为复制的次数。

注意：

• 1、反斜杠可以用来转义，使用r可以让反斜杠不发生转义。
• 2、字符串可以用+运算符连接在一起，用*运算符重复。
• 3、Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
• 4、Python中的字符串不能改变。

List（列表）

List（列表） 是 Python 中使用最频繁的数据类型。

列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

列表是写在方括号 [] 之间、用逗号分隔开的元素列表。

和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

列表截取的语法格式如下：

变量[头下标:尾下标]

索引值以 0 为开始值，-1 为从末尾的开始位置。

注意：

• 1、List写在方括号之间，元素用逗号隔开。
• 2、和字符串一样，list可以被索引和切片。
• 3、List可以使用+操作符进行拼接。
• 4、List中的元素是可以改变的。

Tuple（元组）

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。

注意：

• 1、与字符串一样，元组的元素不能修改。
• 2、元组也可以被索引和切片，方法一样。
• 3、注意构造包含 0 或 1 个元素的元组的特殊语法规则。
• 4、元组也可以使用+操作符进行拼接。

Set（集合）

集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。

基本功能是进行成员关系测试和删除重复元素。

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

Dictionary（字典）

字典（dictionary）是Python中另一个非常有用的内置数据类型。

列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典是一种映射类型，字典用 { } 标识，它是一个无序的

键(key) : 值(value) 的集合。

键(key)必须使用不可变类型。

在同一个字典中，键(key)必须是唯一的。

注意：

• 1、字典是一种映射类型，它的元素是键值对。
• 2、字典的关键字必须为不可变类型，且不能重复。
• 3、创建空字典使用 { }。

字符串

格式化字符串:

"[%-50s]"%'#':-50设置五十的宽度，填充s传进来的值，不够长度用空格补充

手写进度条：

\#=========知识储备==========

\#进度条的效果

[#       ]

[##      ]

[###      ]

[####     ]

 

\#指定宽度

print('[%-15s]' %'#')

print('[%-15s]' %'##')

print('[%-15s]' %'###')

print('[%-15s]' %'####')

 

\#打印%

print('%s%%' %(100)) #第二个%号代表取消第一个%的特殊意义

 

\#可传参来控制宽度

print('[%%-%ds]' %50) #[%-50s]

print(('[%%-%ds]' %50) %'#')

print(('[%%-%ds]' %50) %'##')

print(('[%%-%ds]' %50) %'###')

 

 

\#=========实现打印进度条函数==========

import sys

import time

 

def progress(percent,width=50):

  if percent >= 1:

​    percent=1

  show_str=('[%%-%ds]' %width) %(int(width*percent)*'#')

  print('\r%s %d%%' %(show_str,int(100*percent)),file=sys.stdout,flush=True,end='')

 

 

\#=========应用==========

data_size=1025

recv_size=0

while recv_size < data_size:

  time.sleep(0.1) #模拟数据的传输延迟

  recv_size+=1024 #每次收1024

 

  percent=recv_size/data_size #接收的比例

  progress(percent,width=70) #进度条的宽度70

字符串函数

print(str.upper())     # 把所有字符中的小写字母转换成大写字母  print(str.lower())     # 把所有字符中的大写字母转换成小写字母  print(str.capitalize())   # 把第一个字母转化为大写字母，其余小写  print(str.title())     # 把每个单词的第一个字母转化为大写，其余小写

# 2格式化相关

.ljust(width)   # 获取固定长度，左对齐，右边不够用空格补齐

.rjust(width)   # 获取固定长度，右对齐，左边不够用空格补齐

.center(width) # 获取固定长度，中间对齐，两边不够用空格补齐

.zfill(width)   # 获取固定长度，右对齐，左边不足用0补

# 3 字符串搜索相关

.find()  # 搜索指定字符串，没有返回-1

.index()  # 同上，但是找不到会报错

.rfind()  # 从右边开始查找

.count()  # 统计指定的字符串出现的次数

替换

.replace('old','new')  # 替换old为new

.replace('old','new',次数)  # 替换指定次数的old为new

# 5字符串去空格及去指定字符

.strip()  # 去两边空格

.lstrip()  # 去左边空格；；；括号中可以指定以什么分割

.rstrip()  # 去右边空格  .split()  # 默认按空格分隔

.split('指定字符')  # 按指定字符分割字符串为数组

# 6字符串判断相关

.startswith('start')  # 是否以start开头

.endswith('end')  # 是否以end结尾

.isalnum()  # 是否全为字母或数字

.isalpha()  # 是否全字母

.isdigit()  # 是否全数字

.islower()  # 是否全小写

.isupper()  # 是否全大写

.istitle()  # 判断首字母是否为大写

.isspace()  # 判断字符是否为空格

# 补充

bin()  # 十进制数转八进制

hex()  # 十进制数转十六进制

range()  # 函数：可以生成一个整数序列

type()  # 查看数据类型

len()  # 计算字符串长度

format()  # 格式化字符串，类似%s，传递值能多不能少

python魔法方法

什么是魔术方法？

在Python中，所有以双下划线__包起来的方法，统称为Magic Method****（魔术方法），它是一种的特殊方法，普通方法需要调用，而魔术方法不需要调用就可以自动执行。

魔术方法在类或对象的某些事件出发后会自动执行，让类具有神奇的“魔力”。如果希望根据自己的程序定制自己特殊功能的类，那么就需要对这些方法进行重写。

Python中常用的运算符、for循环、以及类操作等都是运行在魔术方法之上的。

魔术方法init、new、del的应用

class People(object):

  \# 创建对象

  def __new__(cls, *args, **kwargs):

​     print("触发了构造方法")

​     ret = super().__new__(cls) # 调用父类的__new__()方法创建对象

​     return ret ## 将对象返

  \# 实例化对象

  def __init__(self, name, age):

​     self.name = name

​     self.age = age

​     print("初始化方法")

  \# 删除对象

  \#  del 对象名或者程序执行结束之后

  def __del__(self):

​     print("析构方法，删除对象")





if __name__ == '__main__':

  p1 = People('xiaoming', 16)

输出：

触发了构造方法

初始化方法

析构方法，删除对象

使用call方法实现斐波那契数列

\# 斐波那契数列指的是这样一个数列 0, 1, 1, 2, 3, 5, 8, 13

\# 特别指出：第0项是0，第1项是第一个1。从第三项开始，每一项都等于前两项之和。

class Fib(object):

  def __init__(self):

​     pass

  def __call__(self,num):

​     a,b = 0,1;

​     self.l=[]



​     for i in range (num):

​       self.l.append(a)

​       a,b= b,a+b

​     return self.l

  def __str__(self):

​     return str(self.l)

  __rept__=__str__



f = Fib()

print(f(10))

输出：

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

常用的魔术方法

1.初始化方法init

触发机制：实例化对象之后立即触发

参数：至少有一个self，接收当前对象，其他参数根据需要进行定义

返回值：无

作用：初始化对象的成员

2.构造方法new

触发时机： 实例化对象时自动触发（在__init__之前触发）

参数：至少一个cls 接收当前类，其他参数根据初始化方法参数决定

返回值：必须返回一个对象实例，没有返回值，则实例化对象的结果为None

作用：实例化对象

注意：实例化对象是Object类底层实现，其他类继承了Object的__new__才能够实现实例化对象。

3.析构方法del

触发时机：当该类对象被销毁时，自动触发

参数：一个self，接受当前对象

返回值：无

作用：关闭或释放对象创建时资源

注意：del不一定会触发当前方法，只有当前对象没有任何变量引用时才会触发

4.****call

调用对象的魔术方法

触发时机:将对象当作函数调用时触发,方式： 对象()

参数:至少一个self接收对象，其余根据调用时参数决定

返回值：根据情况而定

作用：可以将复杂的步骤进行合并操作，减少调用的步骤，方便使用

注意：无

5.****len

触发时机：使用len(对象) 的时候触发

参数：一个参数self

返回值：必须是一个整型

作用：可以设置为检测对象成员个数，但是也可以进行其他任意操作

注意：返回值必须必须是整数，否则语法报错，另外该要求是格式要求。

6.****str

触发时机:使用print(对象)或者str(对象)的时候触发

参数：一个self接收对象

返回值：必须是字符串类型

作用：print（对象时）进行操作，得到字符串，通常用于快捷操作

注意：无

7.****repr

触发时机:在使用repr(对象)的时候触发

参数：一个self接收对象

返回值：必须是字符串

作用：将对象转使用repr化为字符串时使用，也可以用于快捷操作

8.****bool

触发时机: 使用bool(对象)的时候触发

参数：一个self接收对象

返回值：必须是布尔值

作用：根据实际情况决定，可以作为快捷方式使用

注意:仅适合于返回布尔值的操作

9.****format

触发时机：使用字符串.format(对象)时候触发

参数：一个self接收对象，一个参数接收format的{}中的格式，例如:>5

返回值:必须是字符串

作用：设置对象可以作为format的参数，并且自定义对象格式化的规则

注意：无

与属性操作相关的魔术方法

1.****getattr

触发时机：获取不存在的对象成员时触发

参数：一个是接收当前对象的self，一个是获取成员名称的字符串

返回值：必须有值

作用:为访问不存在的属性设置值

注意：getattribute无论何时都会在getattr之前触发，触发了getattribute就不会在触发getattr了

2.****setattr

触发时机:设置对象成员值的时候触发

参数:1个当前对象的self,一个是要设置的成员名称字符串,一个是要设置的值

返回值:无 过程操作

作用:接管设置操作,可以在设置前之前进行判断验证等行为

注意:在当前方法中无法使用成员=值的方式直接设置成员，否则会无限递归，必须借助object的设置方法来完成

object.setattr（参数1，参数2，参数3）

3.****delattr

触发时机：删除对象成员时触发

参数：一个当前对象的self

返回值：无

作用:可以在删除成员时进行验证。

4.****getattribute

触发时机：使用对象成员时触发，无论成员是否存在

参数：1个接收当前对象self，一个是获取的成员的名称字符串

返回值：必须有

作用：在具有封装操作（私有化时），为程序开部分访问权限使用

5.****dir

触发时机：dir（对象）的时候触发

参数:1个接收当前对象self

返回值：必须为序列类型（列表，元组，集合等，）

作用：可以自定义成员列表的返回值

比较运算相关魔术方法

__ lt__(self, other)：

定义小于号的行为：x < y 调用 x.lt(y)

__ le__(self, other)：

定义小于等于号的行为：x <= y 调用 x.le(y)

__ eq__(self, other) ：

定义等于号的行为：x == y 调用 x.eq(y)

__ ne__(self, other)：

定义不等号的行为：x != y 调用 x.ne(y)

__ gt__(self, other)：

定义大于号的行为：x > y 调用 x.**gt(y)

__ ge__(self, other) ：

定义大于等于号的行为：x >= y 调用 x.ge(y)

算术运算相关魔术方法

add(self, other) 定义加法的行为：+

sub(self, other) 定义减法的行为：-

mul(self, other) 定义乘法的行为：*

truediv(self, other) 定义真除法的行为：/

floordiv(self, other) 定义整数除法的行为：//

mod(self, other) 定义取模算法的行为：%

divmod(self, other) 定义当被 divmod() 调用时的行为

pow(self, other[, modulo]) 定义当被 power() 调用或 ** 运算时的行为

lshift(self, other) 定义按位左移位的行为：<<

rshift(self, other) 定义按位右移位的行为：>>

and(self, other) 定义按位与操作的行为：&

xor(self, other) 定义按位异或操作的行为：^

or(self, other) 定义按位或操作的行为：|

赋值运算相关魔术方法

iadd(self, other) 定义赋值加法的行为：+=

isub(self, other) 定义赋值减法的行为：-=

imul(self, other) 定义赋值乘法的行为：=

itruediv(self, other) 定义赋值真除法的行为：/=

ifloordiv(self, other) 定义赋值整数除法的行为：//=

imod(self, other) 定义赋值取模算法的行为：%=

ipow(self, other[, modulo]) 定义赋值幂运算的行为：**=

ilshift(self, other) 定义赋值按位左移位的行为：<<=

irshift(self, other) 定义赋值按位右移位的行为：>>=

iand(self, other) 定义赋值按位与操作的行为：&=

ixor(self, other) 定义赋值按位异或操作的行为：^=

ior(self, other) 定义赋值按位或操作的行为：|=

一元运算相关魔术方法

pos(self) 定义正号的行为：+x

neg(self) 定义负号的行为：-x

abs(self) 定义当被 abs() 调用时的行为

invert(self) 定义按位求反的行为：~x

类型转换相关魔术方法

complex(self) 定义当被 complex() 调用时的行为（需要返回恰当的值）

int(self) 定义当被 int() 调用时的行为（需要返回恰当的值）

float(self) 定义当被 float() 调用时的行为（需要返回恰当的值）

round(self[, n]) 定义当被 round() 调用时的行为（需要返回恰当的值）

index(self) 1. 当对象是被应用在切片表达式中时，实现整形强制转换

​ \2. 如果你定义了一个可能在切片时用到的定制的数值型,你应该定义 index

​ \3. 如果 index 被定义，则 int 也需要被定义，且返回相同的值

上下文管理相关魔术方法****(with)

enter和exit

enter(self)

\1. 定义当使用 with 语句时的初始化行为

\2. enter 的返回值被 with 语句的目标或者 as 后的名字绑定

exit(self, exctype, excvalue, traceback)

\1. 定义当一个代码块被执行或者终止后上下文管理器应该做什么

\2. 一般被用来处理异常，清除工作或者做一些代码块执行完毕之后的日常工作

容器类型相关魔术方法

len(self) 定义当被 len() 调用时的行为（返回容器中元素的个数）

getitem(self, key) 定义获取容器中指定元素的行为，相当于 self[key]

setitem(self, key, value) 定义设置容器中指定元素的行为，相当于 self[key] = value

delitem(self, key) 定义删除容器中指定元素的行为，相当于 del self[key]

iter(self) 定义当迭代容器中的元素的行为

reversed(self) 定义当被 reversed() 调用时的行为

contains(self, item) 定义当使用成员测试运算符（in 或 not in）时的行为

关于python魔术方法的知识掌握这么多基本就够用了，这里给大家推荐一个评价不错的python课程，希望对大家有所

for/if

break和 continue的区别与应用

break用于跳出一个循环或完全结束一个循环，且不仅可以结束其所在的循环，还可以结束其外层的循环；

continue的作用则是用于跳过本次循环体中剩余的语句，但是只要满足循环条件的话，还是会接着下一次循环。

高级程序语言一般有三种结构，比如顺序结构，选择结构，还有循环结构。

而Python中也有这三种结构，本文主要介绍Python中的选择结构和循环结构。

一、条件语句

Python中的选择结构主要表现为条件语句。

条件语句主要是通过条件语句的执行结果来决定执行的代码块。

Python中的条件语句主要是由if语句来编写。

下图将展示条件语句的执行过程。

Python语言中代表True的元素有任何非0和非空（null）的值，而0或null将为false

if语句形式

if ``判断条件``1:
语句``1...
elif ``判断条件``2:
语句``2...
else:
语句``3…
 

当判断条件1为真时，执行语句1

当判断条件2为假时，将判断判断条件2

当判断条件2为真时，将执行语句2

当判断条件2为假时，将执行语句3

注意：

Python``中的``elif``替换了``else if``，所以语句的关键字为``if - elif - else``。
每个条件语句后面都要加上冒号 ：，表示后面的语句是条件满足时的执行语句
缩进划分语句块
没有``switch-case``语句

条件语句实例

age = int(input("``请输入你的年龄``"))
if age <= 0:
print("``你在开玩笑``")
elif age < 18 and age > 0:
print("``你还未成年哦``")
else:        
print("``你已经是个成年人了``")

操作运算符

操作符	描述
<	小于
<=	小于或等于
>	大于
>=	大于或等于
!=	不等于
==	等于，比较两个值是否相等

f嵌套

在if语句中可以将一个if-elif-else结构放在另外一个if-elif-else结构中。

if语句嵌套形式

if ``条件``1:
语句
if ``条件``2:
语句
elif ``条件``3:
语句
else:
语句
elif ``条件``4:
语句
else:
语句
 

二、循环语句

Python中的循环结构主要表现为循环语句。

循环语句主要是通过对条件的控制来实现对某段程序反复执行的代码块。

在Python中，循环语句主要是有for和while语句来编写。

while语句

while语句形式

 
while ``条件``:
执行语句
Python``中的``while``语句有个特点，就是可以使用``else``代码块。
在``while``…``else``语句当条件为``false``时，将执行``else``的代码块。

while-else语法形式

while ``条件一``:
语句``1
else:
语句``2    

for语句

Python中的for语句几乎可以遍历任何序列的项目，比如列表，比如字符串。

for语句形式

for ``变量`` in ``序列``:
语句``1
else:
语句``2

循环语句中的break和continue

break和countinue的执行过程

break用于跳出for和while的循环体，如果你从循环中跳出，任何对应的操作都不执行了。而continue主要用于跳出当次循环，进入下一个循环。

list列表

列表操作

列表的取值

功能：访问list列表中元素值

语法：列表名[索引]

list1[index]

index取值范围[0,len(list1))

len（list）表示列表的长度

列表组合运算

语法： 列表3 = 列表1 + 列表2

将列表1和列表2中的元素取出，组成一个新的列表并返回。

列表重复

语法： 列表2 = 列表1 * n

判断元素是否在列表中

语法：元素 in 列表

若存在则返回True，否则返回False

列表截取

语法：list1[start:stop:step]

参数一：表示截取的开始下标值，默认为0

参数二：表示截取的结束下标值，默认为列表末尾

参数三：表示截取的步长，默认为1，可指定

注意：1.截取区间[start, end)，左闭右开

2.list1[::-1]可以获得倒叙的列表

二维列表

语法：列表 =[列表1，列表2，列表3，… ,列表n]

列表中元素可以是Python的基本数据类型，也可以是自定义的数据类型。

当列表中存放的元素刚好又是列表的时候，我们可以称这个列表为二维列表

二维列表取值（访问）

语法：列表名【下标1][下标2]

注意：下标1代表第n个列表（下标从0开始），下标2代表第n个列表中的第n个元素

列表的方法

list.append(元素/列表)

功能：在列表中末尾添加新的元素【在原本的列表中追加元素】

注意：append()中的值可以是列表也可以是普通元素

list.extend(列表)

功能：在列表的末尾一次性追加另外一个列表中的多个值

注意：extend()中的值只能是列表/元组[一个可迭代对象(可加在for循环之后的)]，打碎可迭代对象之后的元素再加入列表中，不能是元素

list.insert(下标值, 元素/列表)

功能：在下标处插入元素，不覆盖原本的数据，原数据向后顺延

注意：插入的数据可以是元素也可以为列表

list.pop(下标值)

功能：移除列表中指定下标处的元素(默认移除最后一个元素)，并返回移除的数据

注意此处会返回删除数据

list.remove(元素)

功能：移除列表中的某个元素第一个匹配结果

list.clear()

功能：清除列表中所有的数据

list.index(object[, start】[, stop])

功能：从指定的范围的列表中找出某个值(object)第一匹配的索引值

查询范围[start,stop),若不指定范围，则默认是整个列表。

注意：若在列表中找不到这个元素，则会报错。

list.count(元素)

功能：查看元素在列表中出现的次数

len(list)

功能： 获取元素列表个数（长度）

max(list)

功能：获取列表中的最大值

min(list)

功能：获取列表中的最小值

比较的是ASCII值

list.reverse()

功能： 将列表中的元素倒叙，在原列表进行操作，不返回新的列表。

list.sort()

list1.sort(reverse=False)

功能：将list1中的元素进行升序排列【默认reverse=False】当reverse为True的时候，降序排列。

在原列表进行排序

赋值拷贝

语法：list1 = [1, 2, 3]

list2 = list1

特点：共用同一块内存空间，更改其中任意一个变量，其他变量都会受到影响。

注意：赋值拷贝为引用拷贝，类似于快捷方式

浅拷贝

语法：``list1 = [1, 2, 3]
 
  list2 = list1.copy()
注意：只适用于一维列表；浅拷贝为一维内存拷贝，开辟了新的内存空间

不完全内存拷贝，对于一维列表重新开辟了一块内存空间，但若出现二维列表的情况下，因为二维列表存放在一维列表中存放的是列表的地址，因此，若出现二维列表相当于间接的引用了同一块内存区域（即二维列表还是共

用内存）。

深拷贝

impo copy
list2 = copy.deepcopy(list1)

完全内存拷贝，相当于将list1中的所有列表元素重新复制了一份，对于多维的也重新开辟了新的内存空间

list(元组)

功能：将元组转为列表

排序函数

1.sort()函数：

list.sort(cmp=None, key=None, reverse=False)

其中参数的含义是：

1. cmp -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。
2. key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
3. reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。

2.sorted()函数：

sorted(iterable, cmp=None, key=None, reverse=False)

其中：

1. iterable -- 可迭代对象。
2. cmp -- 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
3. key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
4. reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

sort ()与sorted()区别：

sort() 是应用在 list 上的方法，sorted() 可以对所有可迭代的对象进行排序操作。

list 的 sort() 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted() 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

list列表排序算法

1.冒泡排序

冒泡排序是最常见到的排序算法，也是很基础的一种排序算法。它的实现思想是：相邻的两个元素进行比较，然后把较大的元素放到后面（正向排序），在一轮比较完后最大的元素就放在了最后一个位置，像鱼儿在水中吐的气泡在上升的过程中不断变大，

2.选择排序

选择排序的思路是：第一轮的时候，所有的元素都和第一个元素进行比较，如果比第一个元素大，就和第一个元素进行交换，在这轮比较完后，就找到了最小的元素；第二轮的时候所有的元素都和第二个元素进行比较找出第二个位置的元素，以此类推

3.插入排序

插入排序的思想是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。 是稳定的排序方法。插入算法把要排序的数组分成两部分：第一部分包含了这个数组的所有元素，但将最后一个元素除外（让数组多一个空间才有插入的位置）， 而第二部分就只包含这一个元素（即待插入元素）。在第一部分排序完成后，再将这个最后元素插入到已排好序的第一部分中

4.快速排序

快速排序的思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小， 然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

5.希尔排序

希尔排序是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。 该方法因DL．Shell于1959年提出而得名。 希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少， 每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

Python列表函数&****方法

Python包含以下函数:

序号	函数
1	cmp(list1, list2) 比较两个列表的元素
2	len(list) 列表元素个数
3	max(list) 返回列表元素最大值
4	min(list) 返回列表元素最小值
5	list(seq) 将元组转换为列表

Python包含以下方法:

序号	方法
1	list.append(obj) 在列表末尾添加新的对象
2	list.count(obj) 统计某个元素在列表中出现的次数
3	list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4	list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
5	list.insert(index, obj) 将对象插入列表
6	[list.pop(index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7	list.remove(obj) 移除列表中某个值的第一个匹配项
8	list.reverse() 反向列表中元素
9	list.sort(cmp=None, key=None, reverse=False) 对原列表进行排序

set集合

集合是一个无序的不重复的序列。一般使用{}或者set()函数来创建。

Tips:创建一个空的集合只能使用set(),因为{}是创建空字典用的

set 访问

想要访问 set 集合，用不了 index 或 key ，但可以通过 for 循环来迭代 set 集合，或者用 in 判断某一个值是否在集合中，如下代码所示：

thisset = {"apple", "banana", "cherry"}
 
for x in thisset:
 print(x)
 
PS E:\dream\markdown\python> & "C:/Program Files (x86)/Python/python.exe" e:/dream/markdown/python/app/app.py
apple
banana
cherry

修改 item

集合一旦创建好之后，不能修改 set 中的项，只能新增。

新增 item

要想往 set 集合中新增，可以使用 add() 方法, 比如下面的例子。

 
 
thisset = {"apple", "banana", "cherry"}
 
thisset.add("orange")
 
print(thisset)
 
PS E:\dream\markdown\python> & "C:/Program Files (x86)/Python/python.exe" e:/dream/markdown/python/app/app.py
{'cherry', 'banana', 'orange', 'apple'}

新增 set 大集合

将一个set 整体加入到另一个 set 中，可以使用 update() 方法。

thisset = {"apple", "banana", "cherry"}
tropical = {"pineapple", "mango", "papaya"}
 
thisset.update(tropical)
 
print(thisset)
 
PS E:\dream\markdown\python> & "C:/Program Files (x86)/Python/python.exe" e:/dream/markdown/python/app/app.py
{'banana', 'pineapple', 'papaya', 'mango', 'apple', 'cherry'}

set 的 update 方法除了可以单纯的添加 set 集合，还可以是任何可迭代的集合，比如：tuple,list,dict 等等。

thisset = {"apple", "banana", "cherry"}
mylist = ["kiwi", "orange"]
 
thisset.update(mylist)
 
print(thisset)
 
PS E:\dream\markdown\python> & "C:/Program Files (x86)/Python/python.exe" e:/dream/markdown/python/app/app.py
{'cherry', 'orange', 'kiwi', 'apple', 'banana'}

移除 item

要想从 set 集合中移除某一个item，可以使用 remove() 或者 discard() 方法，如下代码所示：

remove 和 discard 有什么区别？前者表示如果item不在集合中就会抛异常，后者则不会。

 

thisset = {"apple", "banana", "cherry"}

 

thisset.remove("banana")

 

print(thisset)

 

PS E:\dream\markdown\python> & "C:/Program Files (x86)/Python/python.exe" e:/dream/markdown/python/app/app.py

{'cherry', 'apple'}

set 清空和删除

如何想把 set 集合中的所有元素都抹掉，可以使用 clear() 方法。

如果想把 set 集合释放掉，可以使用 del。

thisset = {"apple", "banana", "cherry"}
 
thisset.clear()
 
print(thisset)
 
PS E:\dream\markdown\python> & "C:/Program Files (x86)/Python/python.exe" e:/dream/markdown/python/app/app.py
set()
ps://blog.csdn.net/huangxinchen520/article/details/112394237

set 合并

有几种方式可以实现`` set ``集合合并，要么使用`` union ``，要么使用`` update``，前者是非破坏性操作，后者就是一种破坏性了，可以细评如下代码：
 
 
set1 = {"a", "b" , "c"}
set2 = {1, 2, 3}
 
set3 = set1.union(set2)
print(set3)
 
set1 = {"a", "b" , "c"}
set2 = {1, 2, 3}
 
set1.update(set2)
print(set1)

set 交集

set ``之间除了`` union ``操作，还可以`` intersection ``求交集，如下代码所示：
 
x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}
 
z = x.intersection(y)
 
print(z)
 
PS E:\dream\markdown\python> & "C:/Program Files (x86)/Python/python.exe" e:/dream/markdown/python/app/app.py
{'apple'}
 
 

set 更多方法

除了上面介绍的方法，set 集合中还有非常多的内建方法，如下经供参考。

装饰器和递归

无参装饰器

没有修改详细信息只修改了参数，返回值，

Def outter(func):
Def wrapper(*args,**kwargs):
功能增加
res=func(*args,**kwargs)
功能增加
Return res
Return wrapper
 
 
@outter#aa=outter(aa)``这个语法可以快速实训名字对应的内存地址
Def aa():
"""gnenn"""
print('asdfasdf')
 
 
aa()

完整替换装饰原函数

from functools import wraps # ``方法二
#``闭包函数
def outter(func):
  # ``方法二
  @wraps(func)
  def wrapper(*args, **kwargs):
    res = func(*args, **kwargs)
    return res
  # ``方法一
  wrapper.__name__ = func.__name__ # ``设置内存名字改变
  wrapper.__doc__ = func.__doc__ # ``设置详细名字改变
  #``方法二
  # @wraps(func)
  return wrapper
 
 
@outter # aa = outter(aa) ``这个语法可以快速实训名字对应的内存地址
def aa():
  """``详细描述``"""
  print('``功能``')
 
 
aa()
print(aa.__name__)
print(aa.__doc__)

有参装饰器

由于@语法的限制，他只能传递一个参数，就是下一行函数的内存地址

对于想要在装饰器中实现多种方法就可以使用

# 有参装饰器

def shix(fanfa): ``这里的参数可变
  def uotter(func): ``这里不可变
    def wrapper(*args, **kwargs): ``这里必须是这几个，
      if fanfa == 'one':
        """``增加代码功能地点``"""
        res = func(*args, **kwargs)
        print('``增加显示``one')
        return res
      elif fanfa == 'tow':
        """``增加代码功能地点``"""
        print('``增加显示``tow')
        res = func(*args, **kwargs)
        return res
      else:
        print('sss')
 
    return wrapper
 
  return uotter
 
 
# ``实现方法一
@shix(fanfa='one') # ``这里获得了``uotter(``传入了``one)``到``wrapper``里面实现增加功能和调用原函数
def one():
  print('``实现方法一``')
 
 
# ``实现方法二
@shix('tow')
def tow():
  print('``实现方法二``')

多个装饰器叠加解释:

# ``多层装饰器解释运行
# import time
#
#
# def doce1(func1): # func1 ==>wrapper2``的内存地址
#   def wrapper1(*args, **kwargs):
#     print('doce1.wrapper1')
#     time.sleep(1)
#     res1 = func1(*args, **kwargs)
#     return res1
#
#   return wrapper1
#
#
# def doce2(func2): # func2 ==>wrapper3``的内存地址
#   def wrapper2(*args, **kwargs):
#     print('doce2.wrapper2')
#     time.sleep(1)
#     res2 = func2(*args, **kwargs)
#     return res2
#
#   return wrapper2
#
#
# def doce3(x):
#   def outter3(func3): # func3 ==>index``的内存地址
#     def wrapper3(*args, **kwargs):
#       print('doce3.wrapper3')
#       time.sleep(1)
#       res3 = func3(*args, **kwargs)
#       return res3
#
#     return wrapper3
#
#   return outter3
#
#
# # ``加载顺序至下而上
# @doce1 # ==> index = doce2(wrapper2``的内存地址``) ==> index=wrapper1``的内存地址
# @doce2 # ==> index = doce2(wrapper3``的内存地址``) ==> index=wrapper2``的内存地址
# @doce3('123') # ==> index=outter3(index``的内存地址``) ==> index==wrapper3``的内存地址
# def index(x, y):
#   print(x, y)
#
#
# # ``运行顺序是自上而下
# print(index)
# index(1, 2)

递归

递归的两个阶段：

回溯：一层一层的调用下去

递推：瞒着某种结束条件，结束递归调用，然后一层一层的返回

案例：

一

  def age(n):
    if n ==1:
      return 18
    return age(n-1)-10
  
  res = age(5)
  print(res)
 
二
def cc(lists):
  if len(lists)==0:
    print('``不存在``')
    return
  num_cent = lists[len(lists) // 2] # ``获取中间值
  if num > num_cent: # ``要是大于中间值，在右边
    lists = lists[len(lists) // 2:] # ``将右边的切片出来
    cc(lists)
  elif num < num_cent: # ``小于在左边
    lists = lists[0:len(lists) // 2] # ``将左边的切片出来
    cc(lists) # ``递归
  else: # ``等于输出
    print('ok')
 
 
cc(aa)
 

运用：

展开一个嵌套的类型等

生成式

列表生成式

aa = [num``（条件为真）`` for num in ``可迭代对象`` if ``条件``]
aa = [num for num in ``可迭代对象``] == [num for num in ``可迭代对象`` if true]

字典生成式

aa = {key: value for key in ``可迭代对象`` if ``条件``}
aa = {key: value for key in ``可迭代对象``} == {key:value for key in ``可迭代对象`` if true}

集合生成式

aa = {key  for key in ``可迭代对象`` if ``条件``}
aa = {key for key in ``可迭代对象``} == {keyfor key in ``可迭代对象`` if true}

生成器表达式：可以简写去除括号

aa = ``（``num``（条件为真）`` for num in ``可迭代对象`` if ``条件）
aa = ``（``num for num in ``可迭代对象）`` == ``（``num for num in ``可迭代对象`` if true``）

在生成器中，迭代对象都有，当然没有调用next方法时在表达式或者生成器表达式中，是不存在一个值的，因为迭代对象机制是一次只产生一个值，不会保留下一次和上一次的值，只有当前值

使用：在读取大文件时可以使用或者有大量数据，这个时候就可以通过生成器来生成一个自定义的可迭代对象来节约内存

open() 函数

函数语法

open(name[, mode[, buffering]])

参数说明：

• name : 一个包含了你要访问的文件名称的字符串值。
• mode : mode 决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。
• buffering : 如果 buffering 的值被设为 0，就不会有寄存。如果 buffering 的值取 1，访问文件时会寄存行。如果将 buffering 的值设为大于 1 的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。

不同模式打开文件的完全列表：

模式	描述
t	文本模式 (默认)。
x	写模式，新建一个文件，如果该文件已存在则会报错。
b	二进制模式。
+	打开一个文件进行更新(可读可写)。
U	通用换行模式（不推荐）。
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
w	打开一个文件只用该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

file 对象方法

• file.read([size])：size 未指定则返回整个文件，如果文件大小 >2 倍内存则有问题，f.read()读到文件尾时返回""(空字串)。
• file.readline()：返回一行。
• file.readlines([size]) ：返回包含size行的列表, size 未指定则返回全部行。
• for line in f: print line ：通过迭代器访问。
• f.write("hello\n")：如果要写入字符串以外的数据,先将他转换为字符串。
• f.tell()：返回一个整数,表示当前文件指针的位置(就是到文件头的字节数)。
• f.seek(偏移量,[起始位置])：用来移动文件指针。
• 偏移量: 单位为字节，可正可负
• 起始位置: 0 - 文件头, 默认值; 1 - 当前位置; 2 - 文件尾
• f.close() 关闭文件

jaon写入

import json
# ``写入``json
all_res = {}
write_path = "E:/test_feature.json"
all_res["``明天``"] = "``天气好``"
 
with open(write_path, "w", encoding='utf-8') as f:
  json.dump(all_res, f, ensure_ascii=False)

异常处理

一 什么是异常

异常是程序发生错误的信号。程序一旦出现错误，便会产生一个异常，若程序中没有处理它，就会抛出该异常，程序的运行也随之终止。在Python中,错误触发的异常如下

错误分成两种：

一种是语法上的错误SyntaxError，

解决：错误应该在程序运行前就修改正确

另一类就是逻辑错误

一：错误发生的条件可以预知

二：错误发生的条件不可预知

为何处理异常：

为了增加程序的健壮性，基本是程序运行过程中出错了，也不要终止程序，而是捕捉异常并处理：将异常写入日志，或者其他

语法：

try:
被检测的代码块
Except ``异常`` as ``别名``:
检测到异常，就执行这个位置的逻辑
except``异常二 ``as ``别名``:
pass
else:
没有异常就会执行
finally:
无论有没有异常都会执行

如何处理

针对不同类型的异常：

如果我们想分别用不同的逻辑处理，需要用到多分支的except（类似于多分支的elif，从上到下依次匹配，匹配成功一次便不再匹配其他）

try:
被检测的代码块
except NameError:
触发``NameError``时对应的处理逻辑
except IndexError:
触发``IndexError``时对应的处理逻辑
except KeyError:
触发``KeyError``时对应的处理逻辑

迭代器\for和生成器

迭代器含义

迭代器：指的是迭代取值的工具，迭代指的是一个重复的过程，每一次重复都是基于上一次结果而继续的，单纯的重复不是迭代

为什么要有：为了解决取值只能是索引迭代器取值的局限性，必须增加一种不依赖索引取值的方式，就是迭代器

可迭代对象，但凡含有__iter__方法的都是可迭代对象，调用inter方法就可以转换成可迭代对象，调用__next__（）可以去值，并移动指针

迭代器对象：内置有__next__的方法和__iter__的方法对象

调用__next__()：可以获得下一个迭代器的值

调用__iter__():获得他本身

意义: 统一for循环的循环规则

for循环的工作原理:又叫迭代器循环

1.调用__iter__()获得一个迭代器对象

2.迭代器对象.next()拿到一个返回值赋值

3.循环往复步骤二.直到抛出StopIteration异常for会捕捉停止

List('hello')原理同for

迭代器优缺点

好处:

1. 节省内存，迭代器在内存中相当于只占一个数据的空间。

因为每次取值都上一条数据会在内存释放，加载当前的此条数据。

惰性机制。

next一次，取一个值，绝不过多取值。

有一个迭代器模式可以很好的解释上面这两条：迭代是数据处理的基石。扫描内存中放不下的数据集时，我们要找到一种惰性获取数据项的方式，即按需一次获取一个数据项。这就是迭代器模式。

缺点

不能直观的查看里面的数据。

取值时不走回头路，只能一直向下取

生成器

定义在方法中的返回语法

使用他的函数就是自定义的一个可迭代对象

使用 :

Def aa():
yield1
yield2
yield3
yield4
 
a=aa()
print(a.__next__())
print(a.__next__())
print(a.__next__())
print(a.__next__())
print(a.__next__())

生成器表达式形式

变量 = yiled 返回值(可以没有)

def aa():
print('``调用了``aa')
while True:
x=yieldNone
print(x)
 
 
a=aa()
a.send(None)
cc=a.send(['``传入了``yiled','asdf'])
 
print(cc)
cc=a.send('``传入了``yiled')
print(cc)
cc=a.send('asdf')
print(cc)

a.close() #关闭 关闭以后无法传值

结果：

调用了aa

['传入了yiled', 'asdf']

[['传入了yiled', 'asdf']]

传入了yiled

[['传入了yiled', 'asdf'], '传入了yiled']

asdf

[['传入了yiled', 'asdf'], '传入了yiled', 'asdf']

序列化和反序列化

序列化

序列化是指：把内存的数据类型转换成一个特定的格式的内容

该格式的内容可以用于存储或者传输给其他平台

为什么要序列化

1：持久保存状态用于存储

需知一个软件``/``程序的执行就在处理一系列状态的变化，在编程语言中，``'``状态``'``会以各种各样有结构的数据类型``(``也可简单的理解为变量``)``的形式被保存在内存中。
内存是无法永久保存数据的，当程序运行了一段时间，我们断电或者重启程序，内存中关于这个程序的之前一段时间的数据（有结构）都被清空了。
在断电或重启程序之前将程序当前内存中所有的数据都保存下来（保存到文件中），以便于下次程序执行能够从文件中载入之前的数据，然后继续执行，这就是序列化。
具体的来说，你玩使命召唤闯到了第``13``关，你保存游戏状态，关机走人，下次再玩，还能从上次的位置开始继续闯关。或如，虚拟机状态的挂起等。

2：跨平台数据交互

序列化之后，不仅可以把序列化后的内容写入磁盘，还可以通过网络传输到别的机器上，如果收发的双方约定好实用一种序列化的格式，那么便打破了平台``/``语言差异化带来的限制，实现了跨平台数据交互。
反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即``unpickling``。

进程和线程以协程

进程

进程的特点

动态性：进程是程序的一次执行过程，动态产生，动态消亡。
独立性：进程是一个能独立运行的基本单元。是系统分配资源与调度的基本单元。
并发性：任何进程都可以与其他进程并发执行。
结构性：进程由程序、数据和进程控制块三部分组成。

缺点

无法即时完成的任务带来大量的上下文切换代价与时间代价。
进程的上下文：当一个进程在执行时，``CPU``的所有寄存器中的值、进程的状态以及堆栈中的内容被称为该进程的上下文。
上下文切换：当内核需要切换到另一个进程时，它需要保存当前进程的所有状态，即保存当前进程的上下文，以便在再次执行该进程时，能够得到切换时的状态并执行下去。

进程适合用于cpu密集型的计算

Python``要充分利用多核``CPU``，就用多进程。
原因是：每个进程有各自独立的``GIL``，互不干扰，这样就可以真正意义上的并行执行，所以在``Python``中，多进程的执行效率优于多线程``(``仅仅针对多核``CPU``而言``)``。

进程模块

导入模块`` ``：`` multiprocessing
From multiprocessing import Process,Lock
 

简单使用、

初始化一个进程

p=Process(target=``传入方法名不要括号``(``相当于吧内存地址传过去了``),args=(``参数元组类型``(1``，``)))
p.start() ``# ``启动这个进程
p.join() ``# ``设置阻塞这个进程 不让主方法继续执行

设置锁来保证i/o安全

  lock=Lock()

方法一： 在with中加锁

with lock:`
 `  # do something...

相当于以下代码：

lock.acquire() ``# ``加锁
try:`
 `  # do something...`
 `finally:`
 `  temp_lock.release() ``# ``释放锁

进程池

ProcessPoolExecutor`` ``类是 ``Executor`` ``的子类，它使用进程池来异步地执行调用。
*max_workers* ``*可以设置最大进程*
方法一
  with concurrent.futures.ProcessPoolExecutor() as executor:
    for number, prime in zip(PRIMES, executor.map(is_prime, PRIMES)):
      print('%d is prime: %s' % (number, prime)
方法二：
aa =``concurrent.futures.ProcessPoolExecutor()
返回值列表`` = aa.map(``方法，参数``)
 

方法介绍

map

# 这个是有序调用，会依次拿取参数中的值

返回一个返回值列表future = map（fanc =传入方法的地址，要传入的参数列表）

future.result() # ``获取返回结果

Submit

‎将可调用‎‎**对象 fn‎‎ 调度为执行，并返回一个表示可调用对象执行的 ‎[‎Future‎](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/concurrent.futures.html#concurrent.futures.Future)‎ 对象。‎fn(*args, **kwargs)

future=executor.submit(``*fn =*``传入方法的地址参数，用逗号隔开``)
future.result() # ``获取返回结果

result(timeout=None)

返回调用返回的值。如果调用还没完成那么这个方法将等待`` ``timeout`` ``秒。如果在`` ``timeout`` ``秒内没有执行完成，`[concurrent.futures.TimeoutError](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/concurrent.futures.html#concurrent.futures.TimeoutError)` ``将会被触发。``timeout`` ``可以是整数或浮点数。如果`` ``timeout`` ``没有指定或为`` ``None``，那么等待时间就没有限制。

pipeline框架

我们现在有一个事情由输入数据得到输出数据，中间会经过很多的模块，而这些模块之间会通过中间数据进行交互。我们称这些处理模块为处理器也叫Processor，而把事情分为很多模块进行处理的架构称为Pipeline架构。

多线程数据通信的queue.Queue

我们上文提到多线程的生产者和消费者之间需要数据交互进行完成爬虫。同时也遗留了一个问题，那就是多线程之间如何进行数据交互。于是，便有了``queue.Queue``。
queue.Queue``可以用于多线程之间的、线程安全的数据通信
class`` ``queue.Queue(maxsize=0)
‎``FIFO``‎‎ ``队列的构造函数。``‎‎``maxsize``‎‎ ``是一个整数，用于设置队列中可放置的项目数的上限。一旦达到此大小，插入将阻塞，直到队列项目被消耗。如果`` ‎‎``maxsize``‎‎ ``小于或等于零，则队列大小是无限的。``‎
class`` ``queue.LifoQueue(maxsize=0)
LIFO`` ``队列构造函数。`` ``maxsize`` ``是个整数，用于设置可以放入队列中的项目数的上限。当达到这个大小的时候，插入操作将阻塞至队列中的项目被消费掉。如果`` ``maxsize`` ``小于等于零，队列尺寸为无限大。
class`` ``queue.PriorityQueue(maxsize=0)
优先级队列构造函数。`` ``maxsize`` ``是个整数，用于设置可以放入队列中的项目数的上限。当达到这个大小的时候，插入操作将阻塞至队列中的项目被消费掉。如果`` ``maxsize`` ``小于等于零，队列尺寸为无限大。

# 1.``导入类库
import queue
 
# 2.``创建``Queue maxsize``‎``‎ ``是一个整数，用于设置队列中可放置的项目数的上限。一旦达到此大小，插入将阻塞，直到队列项目被消耗。如果 ``‎``‎``maxsize``‎``‎ ``小于或等于零，则队列大小是无限的
q = queue.Queue(maxsize=0)
 
# 3.``添加元素``(``如果队列已满，则进行阻塞，等待队列不满时添加``)
q.put(item)
 
# 4.``获取元素（如果队列为空，则进行阻塞，等待队列不空时获取）
item = q.get()
 
# 5.``查询状态
# ``查看元素的多少
q.qsize()
# ``判断是否为空
q.empty()
# ``判断是否已满
q.full()
 

线程

Python多线程下，每个线程的执行方式如下：

获取GIL

执行代码直到sleep或者是python虚拟机将其挂起。

释放GIL

可见，某个线程想要执行，必须先拿到GIL，我们可以把GIL看作是“通行证”，并且在一个python进程中，GIL只有一个。拿不到通行证的线程，就不允许进入CPU执行。

因此，同一时刻，只有一个线程在运行，其它线程只能等待，即使是多核CPU，也没办法让多个线程「并行」地同时执行代码，只能是交替执行，因为多线程涉及到上线文切换、锁机制处理（获取锁，释放锁等），所以，在CPU密集型应用中多线程执行不快反慢。

补充说明：GIL

在 CPython 解释器（Python语言的主流解释器）中，有一把全局解释锁GIL（Global Interpreter Lock），某个线程须先拿到GIL才允许进入CPU执行。

什么时候 GIL 被释放呢？

当一个线程遇到 I/O 任务时，将释放GIL。

计算密集型（CPU-bound）线程执行 100 次解释器的计步（ticks）时（计步可粗略看作 Python 虚拟机的指令），也会释放 GIL。在Python3.x中，GIL不使用ticks计数，改为使用计时器（执行时间达到阈值后，当前线程释放GIL）。

特别提示：GIL只在CPython中才有，因为CPython调用的是c语言的原生线程，所以他不能直接操作cpu，只能利用GIL保证同一时间只能有一个线程拿到数据。而在PyPy和Jython中是没有GIL的。

线程模块

导入模块`` ``：`` multiprocessing
From threading import ``Thread``,Lock
 

简单使用、

初始化一个进程

t``=thread(target=``传入方法名不要括号``(``相当于吧内存地址传过去了``),args=(``参数元组类型``(1``，``)))
t.start() ``# ``启动这个线程
t.join() ``# ``设置阻塞这个线程不让主方法继续执行

设置锁来保证i/o安全

  lock=Lock()

方法一： 在with中加锁

with lock:`
 `  # do something...

相当于以下代码：

lock.acquire() ``# ``加锁
try:`
 `  # do something...`
 `finally:`
 `  temp_lock.release() ``# ``释放锁

获取名字

threading.current_thread().getName()

线程池

ThreadPoolExecutor`` ``类是 ``Executor`` ``的子类，它使用进程池来异步地执行调用。
*max_workers* ``*可以设置最大线程*
方法一
  with concurrent.futures.ThreadPoolExecutor`` ``() as executor:
    for number, prime in zip(PRIMES, executor.map(is_prime, PRIMES)):
      print('%d is prime: %s' % (number, prime)
方法二：
aa =``concurrent.futures.ThreadPoolExecutor`` ``()
返回值列表`` = aa.map(``方法，参数``)
 

方法介绍

map

# 这个是有序调用，会依次拿取参数中的值

返回一个返回值列表future = map（fanc =传入方法的地址，要传入的参数列表）

future.result() # ``获取返回结果

Submit

‎将可调用‎‎**对象 fn‎‎ 调度为执行，并返回一个表示可调用对象执行的 ‎[‎Future‎](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/concurrent.futures.html#concurrent.futures.Future)‎ 对象。‎fn(*args, **kwargs)

future=executor.submit(``*fn =*``传入方法的地址参数，用逗号隔开``)
future.result() # ``获取返回结果

result(timeout=None)

返回调用返回的值。如果调用还没完成那么这个方法将等待`` ``timeout`` ``秒。如果在`` ``timeout`` ``秒内没有执行完成，`[concurrent.futures.TimeoutError](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/concurrent.futures.html#concurrent.futures.TimeoutError)` ``将会被触发。``timeout`` ``可以是整数或浮点数。如果`` ``timeout`` ``没有指定或为`` ``None``，那么等待时间就没有限制。
 
 
 
 

协程 asyncio

Python协程

运行效率极高，协程的切换完全由程序控制，不像线程切换需要花费操作系统的开销,线程数量越多，协程的优势就越明显。

同时，在Python中，协程不需要多线程的锁机制，因为只有一个线程，也不存在变量冲突。

协程对于IO密集型任务非常适用，如果是CPU密集型任务，推荐多进程+协程的方式。对于多核CPU，利用多进程+协程的方式，能充分利用CPU，获得极高的性能。

Python协程的发展时间较长：

• • Python2.5 为生成器引用.send()、.throw()、.close()方法
  • Python3.3 为引入yield from，可以接收返回值，可以使用yield from定义协程
  • Python3.4 加入了asyncio模块
  • Python3.5 增加async、await关键字，在语法层面的提供支持
  • Python3.7 使用async def + await的方式定义协程
  • 此后asyncio模块更加完善和稳定，对底层的API进行的封装和扩展
  • Python将于3.10版本中移除以yield from的方式定义协程

注意：

使用``async def``的形式定义
在协程中可以使用``await``关键字，注意，其后跟的是``"``可等待对象``"(``协程``, ``任务`` ``和`` Future)
协程不能直接执行，需要在``asyncio.run()``中执行，也可以跟在``await``后面
async``和``await``这两个关键字只能在协程中使用
其中，``asyncio.run(main, *, debug=False)``方法就是对``run_until_complete``进行了封装：
loop = events.new_event_loop()
return loop.run_until_complete(main)

Lock

class`` ``asyncio.Lock
实现一个用于`` asyncio ``任务的互斥锁。`` ``非线程安全。
asyncio ``锁可被用来保证对共享资源的独占访问。
使用`` Lock ``的推荐方式是通过`` `[async with](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/compound_stmts.html#async-with)` ``语句``:
lock=asyncio.Lock()
# ... Later 
async with lock:
# access shared state
这等价于``:
lock=asyncio.Lock()
# ... Later
Await lock.acquire() 
try:
# access shared state
finally:
lock.release()
在`` 3.10 ``版更改``:`` ``Removed the`` ``loop`` ``parameter.
coroutine`` ``acquire()
获取锁。
此方法会等待直至锁为`` ``unlocked``，将其设为`` ``locked`` ``并返回`` ``True``。
当有一个以上的协程在`` `[acquire()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/asyncio-sync.html#asyncio.Lock.acquire)` ``中被阻塞则会等待解锁，最终只有一个协程会被执行。
锁的获取是`` ``公平的``: ``被执行的协程将是第一个开始等待锁的协程。
release()
释放锁。
当锁为`` ``locked`` ``时，将其设为`` ``unlocked`` ``并返回。
如果锁为`` ``unlocked``，则会引发`` `[RuntimeError](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/exceptions.html#RuntimeError)`。
locked()
如果锁为`` ``locked`` ``则返回`` ``True``。
 
异步协程爬取框架
未设置并发度：
import asyncio
# ``获取事件循环
loop = asyncio.get_event_loop()
# ``根据协程语法定义一个协程方法
async def main(url):
  await get_url(url) ``# ``其他方法
# ``await ``不会等待直接进入下一个
创建``task``列表
tasks = [loop.create_task(main(url)) for url in urls]
# ``执行爬虫事件列表
loop.run_until_complete(asyncio.wait(tasks))
设置并发度
import asyncio
# ``获取事件循环
 
asem = asyncio.Semaphore(10) ``# ``设置10的最大并发 
loop = asyncio.get_event_loop()
# ``根据协程语法定义一个协程方法
async def main(url):
async with asem:
    await get_url(url) # ``其他方法
# await ``不会等待直接进入下一个
 
创建``task``列表
tasks = [loop.create_task(main(url)) for url in urls]
# ``执行爬虫事件列表
loop.run_until_complete(asyncio.wait(tasks))
 
 

并发度第二种方法：

i``mport asyncio
 
async def foo(char:str, count: int):`
 `  for i in range(count):`
 `    print(f"{char}-{i}")`
 `    await asyncio.sleep(1)
 
async def main():`
 `  task1 = asyncio.create_task(foo("A", 2))`
 `  task2 = asyncio.create_task(foo("B", 3))`
 `  task3 = asyncio.create_task(foo("C", 2))
await task1`
 `await task2`
 `await task3
 
if __name__ == '__main__':`
 `  asyncio.run(main())

创建一个任务或者说并发任务

asyncio.create_task(coro,`` ``*,`` ``name=None)
将`` ``coro`` ``协程`` ``封装为一个`` ``Task`` ``并调度其执行。返回`` Task ``对象。``一个异步方法``\``协程方法
name`` ``不为`` ``None``，它将使用`` ``Task.set_name()`` ``来设为任务的名称

第三种方法设置并发度：

 
Import asyncio
Async def foo(char:str, count: int):
For i in range(count):
print(f"{char}-{i}")
awaitasyncio.sleep(.5)
Async def main():
Await asyncio.gather(foo("A", 2), foo("B", 3), foo("C", 2))
if__name__ == '__main__':
asyncio.run(main())

运行 asyncio 程序

asyncio.run(coro, ***, debug=False)

执行 [coroutine](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-coroutine) coro 并返回结果。

此函数会运行传入的协程，负责管理 asyncio 事件循环，终结异步生成器，并关闭线程池。

当有其他 asyncio 事件循环在同一线程中运行时，此函数不能被调用。

如果 debug 为 True，事件循环将以调试模式运行。

此函数总是会创建一个新的事件循环并在结束时关闭之。它应当被用作 asyncio 程序的主入口点，理想情况下应当只被调用一次。

总结：

• • 线程和协程推荐在IO密集型的任务(比如网络调用)中使用，而在CPU密集型的任务中，表现较差。
  • 对于CPU密集型的任务，则需要多个进程，绕开GIL的限制，利用所有可用的CPU核心，提高效率。
  • 在高并发下的最佳实践就是多进程+协程，既充分利用多核，又充分发挥协程的高效率，可获得极高的性能。

内置函数

round() 方法

返回浮点数``x``的四舍五入值
 

内省函数

reduce()

函数会对参数序列中元素进行累积。

函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。

注意：Python3.x reduce() 已经被移到 functools 模块里，如果我们要使用，需要引入 functools 模块来调用 reduce() 函数：

from functools import reduce

语法

reduce() 函数语法：

reduce(function, iterable[, initializer])

参数

• function -- 函数，有两个参数
• iterable -- 可迭代对象
• initializer -- 可选，初始参数
• 实例：

def add(x, y) : # 两数相加

return x + y

sum1 = reduce(add, [1,2,3,4,5]) # 计算列表和：1+2+3+4+5

sum2 = reduce(lambda x, y: x+y, [1,2,3,4,5]) # 使用 lambda 匿名函数

print(sum1)

print(sum2)

map()

map``（方法，``iterabl``e``）
会依次从``iterable``中取值到方法中运行，返回一个map类型的可迭代对象
案例：
aa = [i for i in range(100)]
 
res = map(lambda x:f'aa{x}',aa)
print(res) ``==``》``<map object at 0x000001ED3F1E5D30>
 

filter()

函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。

该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

注意: Python2.7 返回列表，Python3.x 返回迭代器对象，具体内容可以查看：Python3 filter() 函数

语法

以下是 filter() 方法的语法:

filter(function, iterable)

参数

• function -- 判断函数。
• iterable -- 可迭代对象。

返回值

返回列表。

实例

def is_odd(n):

return n % 2 == 1

newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

print(newlist)

all()

函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。

元素除了是 0、空、None、False 外都算 True。

函数等价于：

def`` ``all(iterable):
  ``for`` ``element`` ``in`` ``iterable:
    ``if`` ``not`` ``element:
      ``return`` ``False
  ``return`` ``True

Python 2.5 以上版本可用。

语法

以下是 all() 方法的语法:

all(iterable)

参数

• iterable -- 元组或列表。

返回值

如果iterable的所有元素不为0、''、False或者iterable为空，all(iterable)返回True，否则返回False；

注意：空元组、空列表返回值为True，这里要特别注意。

lambda匿名函数

语法:(定义)

Lambda 参数: 代码块

案例 : lambda x,y:x+y # 返回的是内存地址

调用:

方法一:

Res = (lambda x,y:x+y)(1,2)
Print(res)

方法二

Func=lambda x,y:x+y
Res = func(1,2)
方法三
结合map,reduce,filter
匿名函数只调用一次的函数，一般都是结合其它函数
 

enumerate(iterable, start=0)

返回一个枚举对象。``iterable`` ``必须是一个序列，或`` `[iterator](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-iterator)`，或其他支持迭代的对象。`` `[enumerate()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/functions.html?highlight=enumerate#enumerate)` ``返回的迭代器的`` `[__next__()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#iterator.__next__)` ``方法返回一个元组，里面包含一个计数值（从`` ``start`` ``开始，默认为`` 0``）和通过迭代`` ``iterable`` ``获得的值。
>>>
>>> seasons=['Spring','Summer','Fall','Winter']
>>> list(enumerate(seasons))[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons,start=1))[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
等价于``:
defenumerate(sequence,start=0):n=startforeleminsequence:yieldn,elemn+=1
 
 

max(iterable, *[, key, default])

max(arg1, arg2, *args[, key])

返回可迭代对象中最大的元素，或者返回两个及以上实参中最大的。

如果只提供了一个位置参数，它必须是非空 [iterable](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-iterable)，返回可迭代对象中最大的元素；如果提供了两个及以上的位置参数，则返回最大的位置参数。

有两个可选只能用关键字的实参。key 实参指定排序函数用的参数，如传

key ：

key可以指定一个方法，他会依次传入iterable中的值，到方法里，然后根据返回值进行比较

给 [list.sort()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#list.sort) 的。default 实参是当可迭代对象为空时返回的值。如果可迭代对象为空，并且没有给 default ，则会触发 [ValueError](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/exceptions.html#ValueError)。

如果有多个最大元素，则此函数将返回第一个找到的。这和其他稳定排序工具如 sorted(iterable, key=keyfunc, reverse=True)[0] 和 heapq.nlargest(1, iterable, key=keyfunc) 保持一致。

min(iterable, *[, key, default])

min(arg1, arg2, *args[, key])

返回可迭代对象中最小的元素，或者返回两个及以上实参中最小的。

如果只提供了一个位置参数，它必须是 [iterable](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-iterable)，返回可迭代对象中最小的元素；如果提供了两个及以上的位置参数，则返回最小的位置参数。

有两个可选只能用关键字的实参。key 实参指定排序函数用的参数，如传给 [list.sort()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#list.sort) 的。default 实参是当可迭代对象为空时返回的值。如果可迭代对象为空，并且没有给 default ，则会触发 [ValueError](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/exceptions.html#ValueError)。

如果有多个最小元素，则此函数将返回第一个找到的。这和其他稳定排序工具如 sorted(iterable, key=keyfunc)[0] 和 heapq.nsmallest(1, iterable, key=keyfunc) 保持一致。

key ：

key可以指定一个方法，他会依次传入iterable中的值，到方法里，然后根据返回值进行比较

sorted(iterable, /, *, key=None, reverse=False)

根据`` ``iterable`` ``中的项返回一个新的已排序列表。
key`` ``指定带有单个参数的函数，用于从`` ``iterable`` ``的每个元素中提取用于比较的键`` (``例如`` ``key=str.lower)``。`` ``默认值为`` ``None`` ``(``直接比较元素``)``。``key``可以指定一个方法，他会依次传入``iterable``中的值，到方法里，然后根据返回值进行比较
reverse`` ``为一个布尔值。`` ``如果设为`` ``True``，则每个列表元素将按反向顺序比较进行排序。

警告

出现了一些需要让用户知道的问题，但又不想停止程序，这时候我们可以使用警告：

首先导入警告模块：

import warnings
 

在需要的地方，我们使用 warnings 中的 warn 函数：

warn(msg, WarningType = UserWarning)

有时候我们想要忽略特定类型的警告，可以使用 warnings 的 filterwarnings 函数：

filterwarnings(action, category)
将`` ``action`` ``设置为`` ``'ignore'`` ``便可以忽略特定类型的警告：
warnings.filterwarnings('ignore')
 

warnings.filterwarnings(action = 'ignore', category = RuntimeWarning)

month_warning(13)

断言assert

一、``python assert ``断言句语格式及用法很简单。在没完善一个程序之前，我们不知道程序在哪里会出错，与其让它在运行最崩溃，不如在出现错误条件时就崩溃，这时候就需要``assert``断言的帮助。
 
二、基本的断言方法提供了测试结果是``True``还是``False``。所有的断言方法都有一个``msg``参数，如果指定``msg``参数的值，则将该信息作为失败的错误信息返回。

快速参考

三、unittest常用的断言方法

1.assertEqual(self, first, second, msg=None)
 
--``判断两个参数相等：``first == second
 
2.assertNotEqual(self, first, second, msg=None)
 
--``判断两个参数不相等：``first ``！``= second
 
3.assertIn(self, member, container, msg=None)
 
--``判断是字符串是否包含：``member in container
 
4.assertNotIn(self, member, container, msg=None)
 
--``判断是字符串是否不包含：``member not in container
 
5.assertTrue(self, expr, msg=None)
 
--``判断是否为真：``expr is True
 
6.assertFalse(self, expr, msg=None)
 
--``判断是否为假：``expr is False
 
7.assertIsNone(self, obj, msg=None)
 
--``判断是否为``None``：``obj is None
 
8.assertIsNotNone(self, obj, msg=None)
--``判断是否不为``None``：``obj is not None

算法

二分法

当在一个有序列表中找数据是可以使用，（默认小——》大）

原理：用指定值判断和列表中间值的大小，大这又去判断右半部分的中间值，直到最后找到指定值

案例：

def cc(lists):
  if len(lists)==0:
    print('``不存在``')
    return
  num_cent = lists[len(lists) // 2] # ``获取中间值
  if num > num_cent: # ``要是大于中间值，在右边
    lists = lists[len(lists) // 2:] # ``将右边的切片出来
    cc(lists)
  elif num < num_cent: # ``小于在左边
    lists = lists[0:len(lists) // 2] # ``将左边的切片出来
    cc(lists) # ``递归
  else: # ``等于输出
    print('ok')
 
 
cc(aa)

re正则

数量词的贪婪模式与非贪婪模式

正则表达式通常用于在文本中查找匹配的字符串。Python里数量词默认是贪婪的（在少数语言里也可能是默认非贪婪），总是尝试匹配尽可能多的字符；非贪婪的则相反，总是尝试匹配尽可能少的字符。

compile 函数

compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用。

语法格式为：

re.compile(pattern[, flags])

参数：

• pattern : 一个字符串形式的正则表达式
• flags 可选，表示匹配模式，比如忽略大小写，多行模式等

re.match函数

re.match ``尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，``match()``就返回``none``。
函数语法：

re.match(pattern, string, flags=0)

函数参数说明：

参数	描述
pattern	匹配的正则表达式
string	要匹配的字符串。
flags	标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见：正则表达式修饰符 - 可选标志

匹配成功re.match方法返回一个匹配的对象，否则返回None。

我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。

匹配对象方法	描述
group(num=0)	匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。
groups()	返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。

匹配对象

group（id） 获取给定子模式（组的匹配项）

start（id） 返回给定组的匹配项的起始位置

end（id） 返回给定组的匹配项的结束位置

span（id） 返回一个组的起始和结束位置

 

import re

 

m = re.match(r'(http://www|WWW)\.(.*)\..{3}', 'http://www.python.org')

print('输出匹配到的字符串')

print(m.group())

print('匹配第一个圆括号中的内容')

print(m.group(1))

print('匹配第二个圆括号中的内容')

print(m.group(2))

print('输出第一组字符串的起始位置')

print(m.start(1))

print('输出第二组字符串的起始位置')

print(m.start(2))

print('输出字符串的结束位置')

print(m.end(0))

print('输出第一个的起始和结束位置')

print(m.span(1))

 

re.search方法

re.search 扫描整个字符串并返回第一个成功的匹配。

函数语法：

re.search(pattern, string, flags=0)

检索和替换

Python 的re模块提供了re.sub用于替换字符串中的匹配项。

语法：

re.sub(pattern, repl, string, count=0, flags=0)

参数：

• pattern : 正则中的模式字符串。
• repl : 替换的字符串，也可为一个函数。
• string : 要被查找替换的原始字符串。
• count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。
• flags : 编译时用的匹配模式，数字形式。

re.subn(pattern, repl, string, count=0, flags=0)

返回替换后的值，和替换了几次

findall

在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果有多个匹配模式，则返回元组列表，如果没有找到匹配的，则返回空列表。

注意： match 和 search 是匹配一次 findall 匹配所有。

语法格式为：

re.findall(pattern, string, flags=0)

或

pattern.findall(string[, pos[, endpos]])

参数：

• pattern 匹配模式。
• string 待匹配的字符串。
• pos 可选参数，指定字符串的起始位置，默认为 0。
• endpos 可选参数，指定字符串的结束位置，默认为字符串的长度。

re.finditer

和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。

re.finditer(pattern, string, flags=0)

re.split

split 方法按照能够匹配的子串将字符串分割后返回列表，它的使用形式如下：

re.split(pattern, string[, maxsplit=0, flags=0])

参数：

参数	描述
pattern	匹配的正则表达式
string	要匹配的字符串。
maxsplit	分割次数，maxsplit=1 分割一次，默认为 0，不限制次数。
flags	标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见：正则表达式修饰符 - 可选标志

正则表达式对象

re.RegexObject

re.compile() 返回 RegexObject 对象。

re.MatchObject

特殊字符

所谓特殊字符，就是一些有特殊含义的字符，如上面说的 runoo*b 中的 ***，简单的说就是表示任何字符串的意思。如果要查找字符串中的 ***** 符号，则需要对 ***** 进行转义，即在其前加一个 **，runo*ob 匹配字符串 runo*ob。

许多元字符要求在试图匹配它们时特别对待。若要匹配这些特殊字符，必须首先使字符"转义"，即，将反斜杠字符**** 放在它们前面。下表列出了正则表达式中的特殊字符：

特别字符	描述
$	匹配输入字符串的结尾位置。如果设置了 RegExp 对象的 Multiline 属性，则 $ 也匹配 '\n' 或 '\r'。要匹配 $ 字符本身，请使用 $。
( )	标记一个子表达式的开始和结束位置。子表达式可以获取供以后使用。要匹配这些字符，请使用 ( 和 )。
*	匹配前面的子表达式零次或多次。要匹配 * 字符，请使用 *。
+	匹配前面的子表达式一次或多次。要匹配 + 字符，请使用 +。
.	匹配除换行符 \n 之外的任何单字符。要匹配 . ，请使用 . 。
[	标记一个中括号表达式的开始。要匹配 [，请使用 [。
?	匹配前面的子表达式零次或一次，或指明一个非贪婪限定符。要匹配 ? 字符，请使用 ?。
\	将下一个字符标记为或特殊字符、或原义字符、或向后引用、或八进制转义符。例如， 'n' 匹配字符 'n'。'\n' 匹配换行符。序列 '\' 匹配 ""，而 '(' 则匹配 "("。
^	匹配输入字符串的开始位置，除非在方括号表达式中使用，当该符号在方括号表达式中使用时，表示不接受该方括号表达式中的字符集合。要匹配 ^ 字符本身，请使用 ^。
{	标记限定符表达式的开始。要匹配 {，请使用 {。
|	指明两项之间的一个选择。要匹配 |，请使用 |。

正则表达式修饰符 - 可选标志

正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位`` OR(|) ``它们来指定。如`` re.I | re.M ``被设置成`` I ``和`` M ``标志：

修饰符	描述
re.I	使匹配对大小写不敏感
re.L	做本地化识别（``locale-aware``）匹配
re.M	多行匹配，影响`` ^ ``和`` $
re.S	使`` . ``匹配包括换行在内的所有字符
re.U	根据``Unicode``字符集解析字符。这个标志影响`` \w, \W, \b, \B.
re.X	该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。

正则表达式模式

模式字符串使用特殊的语法来表示一个正则表达式：

字母和数字表示他们自身。一个正则表达式模式中的字母和数字匹配同样的字符串。

多数字母和数字前加一个反斜杠时会拥有不同的含义。

标点符号只有被转义时才匹配自身，否则它们表示特殊的含义。

反斜杠本身需要使用反斜杠转义。

模式	描述
^	匹配字符串的开头
$	匹配字符串的末尾。
.	匹配任意字符，除了换行符，当``re.DOTALL``标记被指定时，则可以匹配包括换行符的任意字符。
[...]	用来表示一组字符``,``单独列出：``[amk] ``匹配`` 'a'``，``'m'``或``'k'
[^...]	不在``[]``中的字符：``[^abc] ``匹配除了``a,b,c``之外的字符。
re*	匹配``0``个或多个的表达式。
re+	匹配``1``个或多个的表达式。
re?	匹配``0``个或``1``个由前面的正则表达式定义的片段，非贪婪方式
re{ n}	精确匹配`` n ``个前面表达式。例如，`` ``o{2}`` ``不能匹配`` "Bob" ``中的`` "o"``，但是能匹配`` "food" ``中的两个`` o``。
re{ n,}	匹配`` n ``个前面表达式。例如，`` o{2,} ``不能匹配``"Bob"``中的``"o"``，但能匹配`` "foooood"``中的所有`` o``。``"o{1,}" ``等价于`` "o+"``。``"o{0,}" ``则等价于`` "o*"``。
re{ n, m}	匹配`` n ``到`` m ``次由前面的正则表达式定义的片段，贪婪方式
`a	b`
(re)	对正则表达式分组并记住匹配的文本
(?imx)	正则表达式包含三种可选标志：``i, m, ``或`` x ``。只影响括号中的区域。
(?-imx)	正则表达式关闭`` i, m, ``或`` x ``可选标志。只影响括号中的区域。
(?: re)	类似`` (...), ``但是不表示一个组
(?imx: re)	在括号中使用``i, m, ``或`` x ``可选标志
(?-imx: re)	在括号中不使用``i, m, ``或`` x ``可选标志
(?#...)	注释``.
(?= re)	前向肯定界定符。如果所含正则表达式，以`` ... ``表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。
(?! re)	前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功
(?> re)	匹配的独立模式，省去回溯。
\w	匹配字母数字及下划线
\W	匹配非字母数字及下划线
\s	匹配任意空白字符，等价于`` ``[ \t\n\r\f]``。
\S	匹配任意非空字符
\d	匹配任意数字，等价于`` [0-9].
\D	匹配任意非数字
\A	匹配字符串开始
\Z	匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。
\z	匹配字符串结束
\G	匹配最后匹配完成的位置。
\b	匹配一个单词边界，也就是指单词和空格间的位置。例如，`` 'er\b' ``可以匹配``"never" ``中的`` 'er'``，但不能匹配`` "verb" ``中的`` 'er'``。
\B	匹配非单词边界。``'er\B' ``能匹配`` "verb" ``中的`` 'er'``，但不能匹配`` "never" ``中的`` 'er'``。
\n, \t, ``等``.	匹配一个换行符。匹配一个制表符。等
\1...\9	匹配第``n``个分组的内容。
\10	匹配第``n``个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。

正则表达式实例

实例	描述
[Pp]ython	匹配`` "Python" ``或`` "python"
rub[ye]	匹配`` "ruby" ``或`` "rube"
[aeiou]	匹配中括号内的任意一个字母
[0-9]	匹配任何数字。类似于`` [0123456789]
[a-z]	匹配任何小写字母
[A-Z]	匹配任何大写字母
[a-zA-Z0-9]	匹配任何字母及数字
[^aeiou]	除了``aeiou``字母以外的所有字符
[^0-9]	匹配除了数字外的字符

特殊字符类

实例	描述
.	匹配除`` "\n" ``之外的任何单个字符。要匹配包括`` '\n' ``在内的任何字符，请使用象`` '[.\n]' ``的模式。
\d	匹配一个数字字符。等价于`` [0-9]``。
\D	匹配一个非数字字符。等价于`` [^0-9]``。
\s	匹配任何空白字符，包括空格、制表符、换页符等等。等价于`` [ \f\n\r\t\v]``。
\S	匹配任何非空白字符。等价于`` [^ \f\n\r\t\v]``。
\w	匹配包括下划线的任何单词字符。等价于``'[A-Za-z0-9_]'``。
\W	匹配任何非单词字符。等价于`` '[^A-Za-z0-9_]'``。

案例

特殊符号替换：``re.sub(`` r'[-,$()#+&*]'``," ooo ",str)

表达式

一、校验数字的表达式

 
1. ``数字：``^[0-9]*$
2. n``位的数字：``^\d{n}$
3. ``至少``n``位的数字：``^\d{n,}$
4. m-n``位的数字：``^\d{m,n}$
5. ``零和非零开头的数字：``^(0|[1-9][0-9]*)$
6. ``非零开头的最多带两位小数的数字：``^([1-9][0-9]*)+(.[0-9]{1,2})?$
7. ``带``1-2``位小数的正数或负数：``^(\-)?\d+(\.\d{1,2})?$
8. ``正数、负数、和小数：``^(\-|\+)?\d+(\.\d+)?$
9. ``有两位小数的正实数：``^[0-9]+(.[0-9]{2})?$
10. ``有``1~3``位小数的正实数：``^[0-9]+(.[0-9]{1,3})?$
11. ``非零的正整数：``^[1-9]\d*$ ``或`` ^([1-9][0-9]*){1,3}$ ``或`` ^\+?[1-9][0-9]*$
12. ``非零的负整数：``^\-[1-9][]0-9"*$ ``或`` ^-[1-9]\d*$
13. ``非负整数：``^\d+$ ``或`` ^[1-9]\d*|0$
14. ``非正整数：``^-[1-9]\d*|0$ ``或`` ^((-\d+)|(0+))$
15. ``非负浮点数：``^\d+(\.\d+)?$ ``或`` ^[1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0$
16. ``非正浮点数：``^((-\d+(\.\d+)?)|(0+(\.0+)?))$ ``或`` 
^(-([1-9]\d*\.\d*|0\.\d*[1-9]\d*))|0?\.0+|0$
17. ``正浮点数：``^[1-9]\d*\.\d*|0\.\d*[1-9]\d*$ ``或`` ^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$
18. ``负浮点数：``^-([1-9]\d*\.\d*|0\.\d*[1-9]\d*)$ ``或`` ^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$
19. ``浮点数：``^(-?\d+)(\.\d+)?$ ``或`` ^-?([1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0)$
 
 
二、校验字符的表达式
 
1. ``汉字：``^[\u4e00-\u9fa5]{0,}$
2. ``英文和数字：``^[A-Za-z0-9]+$ ``或`` ^[A-Za-z0-9]{4,40}$
3. ``长度为``3-20``的所有字符：``^.{3,20}$
4. ``由``26``个英文字母组成的字符串：``^[A-Za-z]+$
5. ``由``26``个大写英文字母组成的字符串：``^[A-Z]+$
6. ``由``26``个小写英文字母组成的字符串：``^[a-z]+$
7. ``由数字和``26``个英文字母组成的字符串：``^[A-Za-z0-9]+$
8. ``由数字、``26``个英文字母或者下划线组成的字符串：``^\w+$ ``或`` ^\w{3,20}$
9. ``中文、英文、数字包括下划线：``^[\u4E00-\u9FA5A-Za-z0-9_]+$
 
10. ``中文、英文、数字但不包括下划线等符号：``^[\u4E00-\u9FA5A-Za-z0-9]+$ 
       ``或`` ^[\u4E00-\u9FA5A-Za-z0-9]{2,20}$
 
11. ``可以输入含有``^%&',;=?$\"``等字符：``[^%&',;=?$\x22]+ 12 
         ``禁止输入含有``~``的字符：``[^~\x22]+
 

 
三、特殊需求表达式
 
1. Email``地址：
^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$
2. ``域名：
[a-zA-Z0-9][-a-zA-Z0-9]{0,62}(/.[a-zA-Z0-9][-a-zA-Z0-9]{0,62})+/.?
3. InternetURL``：
[a-zA-z]+://[^\s]* ``或`` ^http://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?$
4. ``手机号码：
^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\d{8}$
5. ``电话号码
("XXX-XXXXXXX"``、``"XXXX-XXXXXXXX"``、``"XXX-XXXXXXX"``、
"XXX-XXXXXXXX"``、``"XXXXXXX"``和``"XXXXXXXX)``：
^(\(\d{3,4}-)|\d{3.4}-)?\d{7,8}$
6. ``国内电话号码``(0511-4405222``、``021-87888822)``：
\d{3}-\d{8}|\d{4}-\d{7}
7. ``身份证号``(15``位、``18``位数字``)``：
^\d{15}|\d{18}$
 
8. ``短身份证号码``(``数字、字母``x``结尾``)``：
^([0-9]){7,18}(x|X)?$ 
或`` ^\d{8,18}|[0-9x]{8,18}|[0-9X]{8,18}?$
 
9. ``帐号是否合法``(``字母开头，允许``5-16``字节，允许字母数字下划线``)``：
^[a-zA-Z][a-zA-Z0-9_]{4,15}$
 
10. ``密码``(``以字母开头，长度在``6~18``之间，只能包含字母、数字和下划线``)``：
^[a-zA-Z]\w{5,17}$
11. ``强密码``(``必须包含大小写字母和数字的组合，不能使用特殊字符，长度在``8-10``之间``)``：
^(?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{8,10}$
 
12. ``日期格式：
^\d{4}-\d{1,2}-\d{1,2}
13. ``一年的``12``个月``(01``～``09``和``1``～``12)``：
^(0?[1-9]|1[0-2])$
14. ``一个月的``31``天``(01``～``09``和``1``～``31)``：
^((0?[1-9])|((1|2)[0-9])|30|31)$
15. ``钱的输入格式：

1. ​ 1.有四种钱的表示形式我们可以接受:"10000.00" 和 "10,000.00", 和没有 "分" 的 "10000" 和 "10,000"：

^[1-9][0-9]*$

1. \17. 2.这表示任意一个不以0开头的数字,但是,这也意味着一个字符"0"不通过,所以我们采用下面的形式：

^(0|[1-9][0-9]*)$

1. 一个0或者一个不以0开头的数字.我们还可以允许开头有一个负号：

^(0|-?[1-9][0-9]*)$

1. 这表示一个0或者一个可能为负的开头不为0的数字.让用户以0开头好了.把负号的也去掉,因为钱总不能是负的吧.下面我们要加的是说明可能的小数部分：

^[0-9]+(.[0-9]+)?$

1. .必须说明的是,小数点后面至少应该有1位数,所以"10."是不通过的,但是 "10" 和 "10.2" 是通过的：

^[0-9]+(.[0-9]{2})?$

1. .这样我们规定小数点后面必须有两位,如果你认为太苛刻了,可以这样：

^[0-9]+(.[0-9]{1,2})?$

1. 这样就允许用户只写一位小数.下面我们该考虑数字中的逗号了,我们可以这样：

^[0-9]{1,3}(,[0-9]{3})*(.[0-9]{1,2})?$

1. 1到3个数字,后面跟着任意个 逗号+3个数字,逗号成为可选,而不是必须：

^([0-9]+|[0-9]{1,3}(,[0-9]{3})*)(.[0-9]{1,2})?$
 
 ``备注：这就是最终结果了``,``别忘了``"+"``可以用``"*"``替代如果你觉得空字符串也可以接受的话``(``奇怪``,``为什么``?)``最后``,``别忘了在用函数时去掉去掉那个反斜杠``,``一般的错误都在这里
 
25. xml``文件：
^([a-zA-Z]+-?)+[a-zA-Z0-9]+\\.[x|X][m|M][l|L]$
26. ``中文字符的正则表达式：
[\u4e00-\u9fa5]
 
27. ``双字节字符：
[^\x00-\xff] 
(``包括汉字在内，可以用来计算字符串的长度``(``一个双字节字符长度计``2``，``ASCII``字符计``1))
 
28. ``空白行的正则表达式：
\n\s*\r (``可以用来删除空白行``)
 
29. HTML``标记的正则表达式：
<(\S*?)[^>]*>.*?</\1>|<.*? /> 
(``网上流传的版本太糟糕，上面这个也仅仅能部分，对于复杂的嵌套标记依旧无能为力``)
 
30. ``首尾空白字符的正则表达式：
^\s*|\s*$``或``(^\s*)|(\s*$) 
(``可以用来删除行首行尾的空白字符``(``包括空格、制表符、换页符等等``)``，非常有用的表达式``)
 
31. ``腾讯``QQ``号：
[1-9][0-9]{4,} 
(``腾讯``QQ``号从``10000``开始``)
32. ``中国邮政编码：
[1-9]\d{5}(?!\d) (``中国邮政编码为``6``位数字``)
33.`` ``IP``地址：
\d+\.\d+\.\d+\.\d+ (``提取``IP``地址时有用``)
34. IP``地址：
((?:(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d))

=

复制文件

• 1. 以下是演示“如何在Python中复制文件”的九种方法。
• 1. 1. shutil copyfile****（）方法
     2. shutil copy****（）方法
     3. shutil copyfileobj****（）方法
     4. shutil copy2****（）方法
     5. os popen****方法
     6. os****系统（）方法
     7. Thread****（）方法
     8. 子进程调用（）方法
     9. 子进程check_output（）方法

1. Shutil Copyfile****（）方法

该方法只有在目标可写时才将源的内容复制到目的地。如果您没有写入权限，则会引发IOError。

它通过打开输入文件进行阅读，忽略其文件类型。接下来，它不会对特殊文件进行任何不同的处理，也不会将它们复制为新的特殊文件。

所述的CopyFile（）方法利用较低级别的功能的copyfileobj（）的下方。它将文件名称作为参数，打开它们并将文件句柄传递给copyfileobj（）。该方法中有一个可选的第三个参数，您可以使用它来指定缓冲区长度。然后它将打开文件以读取指定缓冲区大小的

块。但是，默认行为是一次性读取整个文件。

以下是有关copyfile（）方法的要点。

• 1. 它将源的内容复制到名为目标的文件。
  2. 如果目的地不可写，则复制操作将导致IOError异常。
  3. 如果源文件和目标文件都相同，它将返回SameFileError。
  4. 但是，如果目的地以不同的名称预先存在，则副本将覆盖其内容。
  5. 如果目的地是目录，则意味着此方法将不会复制到目录，将会发生错误13。
  6. 它不支持复制文件，如字符或块设备和管道。

2. Shutil Copy****（）方法

copy****（）方法的功能类似于“CP”在Unix命令。这意味着如果目标是一个文件夹，那么它将在其中创建一个与源文件相同的名称（basename）的新文件。此外，该方法将复制其内容后将目标文件的权限与源进行同步。 如果要复制相同的文件，它也会抛出SameFileError。

3. Shutil Copyfileobj****（）方法

此方法将文件复制到目标路径或文件对象。如果目标是文件对象，则需要在调用copyfileobj（）之后明确关闭它。它假设一个可选参数（缓冲区大小），您可以使用它来提供缓冲区长度。这是在复制过程中保存在内存中的字节数。系统使用的默认大小为16KB。

4. Shutil Copy2****（）方法

但是，copy2（）方法的功能类似于copy（）。但是，在复制数据的同时，也可以在元数据中添加访问和修改时间。复制同一个文件会导致SameFileError。

对于好奇 – Copymode（）与Copystat（）之间的区别。

5. Os Popen****（）方法

该方法创建一个指向或来自该命令的管道。它返回一个连接到管道的打开的文件对象。您可以根据文件打开模式（即’r’（默认）或’w’）使用它进行读取或写入。

• 1. 模式 –它可以是’r’（默认）或’w’。
  2. bufsize –如果其值为0，则不会发生缓冲。如果设置为1，则在访问文件时将进行行缓冲。如果您提供的值大于1，则缓冲将以指定的缓冲区大小进行。但是，对于负值，系统将采用默认缓冲区大小。

对于Windows操作系统。

对于Linux操作系统。

6. Os System****（）方法

它是运行任何系统命令的最常见方式。使用system（）方法，可以在subshell中调用任何命令。在内部，这种方法会调用标准的C库函数。

此方法返回命令的退出状态。

对于Windows操作系统。

对于Linux操作系统。

7.****以Async方式使用线程库的Python文件复制

如果要以异步方式复制文件，请使用以下方法。在这里，我们使用Python的线程模块在后台运行复制操作。

使用此方法时，请确保采用锁定以避免死锁。如果您的应用程序正在使用多个线程读取/写入文件，您可能会面对它。

8.****使用子进程的Call（）方法在Python中复制一个文件

子进程模块提供了一个简单的界面来处理子进程。它使我们能够启动子进程，附加到其输入/输出/错误管道，并检索返回值。

子流程模块旨在替代传统模块和功能，如os.system，os.spawn ，os.popen ，popen2。*。

它公开一个call（）方法来调用系统命令来执行用户任务。

9.****使用子进程的Check_output（）方法在Python中复制文件

使用子进程的check_output（）方法，可以运行外部命令或程序并捕获其输出。它还支持管道。

常见编码

ASCII

ISO88591

GB2312

GBK

UTF-8

术语对照表

术语对照表

>>>

交互式终端中默认的 Python 提示符。往往会显示于能以交互方式在解释器里执行的样例代码之前。

...

具有以下含义：

• 交互式终端中输入特殊代码行时默认的 Python 提示符，包括：缩进的代码块，成对的分隔符之内（圆括号、方括号、花括号或三重引号），或是指定一个装饰器之后。

• [Ellipsis](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/constants.html#Ellipsis) 内置常量。

2to3

把 Python 2.x 代码转换为 Python 3.x 代码的工具，通过解析源码，遍历解析树，处理绝大多数检测到的不兼容问题。

2to3 包含在标准库中，模块名为 [lib2to3](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/2to3.html#module-lib2to3)；提供了独立入口点 Tools/scripts/2to3。详见 [2to3 - 自动将 Python 2 代码转为 Python 3 代码](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/2to3.html#to3-reference)。

abstract base class -- 抽象基类

抽象基类简称 ABC，是对 [duck-typing](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-duck-typing) 的补充，它提供了一种定义接口的新方式，相比之下其他技巧例如 [hasattr()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/functions.html#hasattr) 显得过于笨拙或有微妙错误（例如使用 [魔术方法](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/datamodel.html#special-lookup)）。ABC 引入了虚拟子类，这种类并非继承自其他类，但却仍能被 [isinstance()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/functions.html#isinstance) 和 [issubclass()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/functions.html#issubclass) 所认可；详见 [abc](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/abc.html#module-abc) 模块文档。Python 自带许多内置的 ABC 用于实现数据结构（在 [collections.abc](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/collections.abc.html#module-collections.abc) 模块中）、数字（在 [numbers](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/numbers.html#module-numbers) 模块中）、流（在 [io](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/io.html#module-io) 模块中）、导入查找器和加载器（在 [importlib.abc](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/importlib.html#module-importlib.abc) 模块中）。你可以使用 [abc](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/abc.html#module-abc) 模块来创建自己的 ABC。

annotation -- 标注

关联到某个变量、类属性、函数形参或返回值的标签，被约定作为 [type hint](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-type-hint) 来使用。

局部变量的标注在运行时不可访问，但全局变量、类属性和函数的标注会分别存放模块、类和函数的 annotations 特殊属性中。

参见 [variable annotation](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-variable-annotation), [function annotation](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-function-annotation), PEP 484 和 PEP 526，对此功能均有介绍。 另请参见 [对象注解属性的最佳实践](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/howto/annotations.html#annotations-howto) 了解使用标注的最佳实践。

argument -- 参数

在调用函数时传给 [function](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-function) （或 [method](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-method) ）的值。参数分为两种：

• 关键字参数: 在函数调用中前面带有标识符（例如 name=）或者作为包含在前面带有 ** 的字典里的值传入。举例来说，3 和 5 在以下对 [complex()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/functions.html#complex) 的调用中均属于关键字参数:
  complex(real=3,imag=5)complex(**{'real':3,'imag':5})
• 位置参数: 不属于关键字参数的参数。位置参数可出现于参数列表的开头以及/或者作为前面带有 * 的 [iterable](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-iterable) 里的元素被传入。举例来说，3 和 5 在以下调用中均属于位置参数:
  complex(3,5)complex(*(3,5))

参数会被赋值给函数体中对应的局部变量。有关赋值规则参见 [调用](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/expressions.html#calls) 一节。根据语法，任何表达式都可用来表示一个参数；最终算出的值会被赋给对应的局部变量。

另参见 [parameter](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-parameter) 术语表条目，常见问题中 [参数与形参的区别](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/faq/programming.html#faq-argument-vs-parameter) 以及 PEP 362。

asynchronous context manager -- 异步上下文管理器

此种对象通过定义 aenter() 和 aexit() 方法来对 [async with](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/compound_stmts.html#async-with) 语句中的环境进行控制。由 PEP 492 引入。

asynchronous generator -- 异步生成器

返回值为 [asynchronous generator iterator](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-asynchronous-generator-iterator) 的函数。它与使用 [async def](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/compound_stmts.html#async-def) 定义的协程函数很相似，不同之处在于它包含 [yield](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/simple_stmts.html#yield) 表达式以产生一系列可在 [async for](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/compound_stmts.html#async-for) 循环中使用的值。

此术语通常是指异步生成器函数，但在某些情况下则可能是指 异步生成器迭代器。如果需要清楚表达具体含义，请使用全称以避免歧义。

一个异步生成器函数可能包含 [await](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/expressions.html#await) 表达式或者 [async for](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/compound_stmts.html#async-for) 以及 [async with](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/compound_stmts.html#async-with) 语句。

asynchronous generator iterator -- 异步生成器迭代器

[asynchronous generator](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-asynchronous-generator) 函数所创建的对象。

此对象属于 [asynchronous iterator](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-asynchronous-iterator)，当使用 anext() 方法调用时会返回一个可等待对象来执行异步生成器函数的代码直到下一个 [yield](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/simple_stmts.html#yield) 表达式。

每个 [yield](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/simple_stmts.html#yield) 会临时暂停处理，记住当前位置执行状态 (包括局部变量和挂起的 try 语句)。当该 异步生成器迭代器 与其他 anext() 返回的可等待对象有效恢复时，它会从离开位置继续执行。参见 PEP 492 和 PEP 525。

asynchronous iterable -- 异步可迭代对象

可在 [async for](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/compound_stmts.html#async-for) 语句中被使用的对象。必须通过它的 aiter() 方法返回一个 [asynchronous iterator](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-asynchronous-iterator)。由 PEP 492 引入。

asynchronous iterator -- 异步迭代器

实现了 aiter() 和 anext() 方法的对象。anext 必须返回一个 [awaitable](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-awaitable) 对象。[async for](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/compound_stmts.html#async-for) 会处理异步迭代器的 anext() 方法所返回的可等待对象，直到其引发一个 [StopAsyncIteration](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/exceptions.html#StopAsyncIteration) 异常。由 PEP 492 引入。

attribute -- 属性

关联到一个对象的值，可以使用点号表达式通过其名称来引用。例如，如果一个对象 o 具有一个属性 a，就可以用 o.a 来引用它。

awaitable -- 可等待对象

能在 [await](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/expressions.html#await) 表达式中使用的对象。可以是 [coroutine](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-coroutine) 或是具有 await() 方法的对象。参见 PEP 492。

BDFL

“终身仁慈独裁者”的英文缩写，即 Guido van Rossum，Python 的创造者。

binary file -- 二进制文件

[file object](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-file-object) 能够读写 [字节类对象](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-bytes-like-object)。二进制文件的例子包括以二进制模式（'rb', 'wb' or 'rb+'）打开的文件、sys.stdin.buffer、sys.stdout.buffer 以及 [io.BytesIO](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/io.html#io.BytesIO) 和 [gzip.GzipFile](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/gzip.html#gzip.GzipFile) 的实例。

另请参见 [text file](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-text-file) 了解能够读写 [str](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#str) 对象的文件对象。

borrowed reference -- 借入引用

在 Python 的 C API 中，借入引用是指一种对象引用。 它不会修改对象引用计数。 如果对象被销毁则它会成为一个无目标指针。 例如，垃圾回收器可以移除对象的最后一个 [strong reference](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-strong-reference) 来销毁它。

推荐在 [borrowed reference](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-borrowed-reference) 上调用 [Py_INCREF()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/c-api/refcounting.html#c.Py_INCREF) 以将其原地转换为 [strong reference](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-strong-reference)，除非是当该对象无法在借入引用的最后一次使用之前被销毁。 [Py_NewRef()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/c-api/refcounting.html#c.Py_NewRef) 函数可以被用来创建一个新的 [strong reference](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-strong-reference)。

bytes-like object -- 字节类对象

支持 [缓冲协议](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/c-api/buffer.html#bufferobjects) 并且能导出 C-[contiguous](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-contiguous) 缓冲的对象。这包括所有 [bytes](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#bytes)、[bytearray](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#bytearray) 和 [array.array](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/array.html#array.array) 对象，以及许多普通 [memoryview](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#memoryview) 对象。字节类对象可在多种二进制数据操作中使用；这些操作包括压缩、保存为二进制文件以及通过套接字发送等。

某些操作需要可变的二进制数据。这种对象在文档中常被称为“可读写字节类对象”。可变缓冲对象的例子包括 [bytearray](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#bytearray) 以及 [bytearray](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#bytearray) 的 [memoryview](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#memoryview)。其他操作要求二进制数据存放于不可变对象 ("只读字节类对象")；这种对象的例子包括 [bytes](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#bytes) 以及 [bytes](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#bytes) 对象的 [memoryview](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#memoryview)。

bytecode -- 字节码

Python 源代码会被编译为字节码，即 CPython 解释器中表示 Python 程序的内部代码。字节码还会缓存在 .pyc 文件中，这样第二次执行同一文件时速度更快（可以免去将源码重新编译为字节码）。这种 "中间语言" 运行在根据字节码执行相应机器码的 [virtual machine](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-virtual-machine) 之上。请注意不同 Python 虚拟机上的字节码不一定通用，也不一定能在不同 Python 版本上兼容。

字节码指令列表可以在 [dis 模块](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/dis.html#bytecodes) 的文档中查看。

callback -- 回调

一个作为参数被传入以用以在未来的某个时刻被调用的子例程函数。

class -- 类

用来创建用户定义对象的模板。类定义通常包含对该类的实例进行操作的方法定义。

class variable -- 类变量

在类中定义的变量，并且仅限在类的层级上修改 (而不是在类的实例中修改)。

coercion -- 强制类型转换

在包含两个相同类型参数的操作中，一种类型的实例隐式地转换为另一种类型。例如，int(3.15) 是将原浮点数转换为整型数 3，但在 3+4.5 中，参数的类型不一致（一个是 int, 一个是 float），两者必须转换为相同类型才能相加，否则将引发 [TypeError](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/exceptions.html#TypeError)。如果没有强制类型转换机制，程序员必须将所有可兼容参数归一化为相同类型，例如要写成 float(3)+4.5 而不是 3+4.5。

complex number -- 复数

对普通实数系统的扩展，其中所有数字都被表示为一个实部和一个虚部的和。虚数是虚数单位（-1 的平方根）的实倍数，通常在数学中写为 i，在工程学中写为 j。Python 内置了对复数的支持，采用工程学标记方式；虚部带有一个 j 后缀，例如 3+1j。如果需要 [math](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/math.html#module-math) 模块内对象的对应复数版本，请使用 [cmath](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/cmath.html#module-cmath)，复数的使用是一个比较高级的数学特性。如果你感觉没有必要，忽略它们也几乎不会有任何问题。

context manager -- 上下文管理器

在 [with](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/compound_stmts.html#with) 语句中使用，通过定义 enter() 和 exit() 方法来控制环境状态的对象。参见 PEP 343。

context variable -- 上下文变量

一种根据其所属的上下文可以具有不同的值的变量。 这类似于在线程局部存储中每个执行线程可以具有不同的变量值。 不过，对于上下文变量来说，一个执行线程中可能会有多个上下文，而上下文变量的主要用途是对并发异步任务中变量进行追踪。 参见 [contextvars](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/contextvars.html#module-contextvars)。

contiguous -- 连续

一个缓冲如果是 C 连续 或 Fortran 连续 就会被认为是连续的。零维缓冲是 C 和 Fortran 连续的。在一维数组中，所有条目必须在内存中彼此相邻地排列，采用从零开始的递增索引顺序。在多维 C-连续数组中，当按内存地址排列时用最后一个索引访问条目时速度最快。但是在 Fortran 连续数组中则是用第一个索引最快。

coroutine -- 协程

协程是子例程的更一般形式。 子例程可以在某一点进入并在另一点退出。 协程则可以在许多不同的点上进入、退出和恢复。 它们可通过 [async def](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/compound_stmts.html#async-def) 语句来实现。 参见 PEP 492。

coroutine function -- 协程函数

返回一个 [coroutine](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-coroutine) 对象的函数。协程函数可通过 [async def](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/compound_stmts.html#async-def) 语句来定义，并可能包含 [await](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/expressions.html#await)、[async for](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/compound_stmts.html#async-for) 和 [async with](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/compound_stmts.html#async-with) 关键字。这些特性是由 PEP 492 引入的。

CPython

Python 编程语言的规范实现，在 python.org 上发布。"CPython" 一词用于在必要时将此实现与其他实现例如 Jython 或 IronPython 相区别。

decorator -- 装饰器

返回值为另一个函数的函数，通常使用 @wrapper 语法形式来进行函数变换。 装饰器的常见例子包括 [classmethod()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/functions.html#classmethod) 和 [staticmethod()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/functions.html#staticmethod)。

装饰器语法只是一种语法糖，以下两个函数定义在语义上完全等价:

deff(arg):...f=staticmethod(f)@staticmethoddeff(arg):...

同样的概念也适用于类，但通常较少这样使用。有关装饰器的详情可参见 [函数定义](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/compound_stmts.html#function) 和 [类定义](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/compound_stmts.html#class) 的文档。

descriptor -- 描述器

任何定义了 get(), set() 或 delete() 方法的对象。当一个类属性为描述器时，它的特殊绑定行为就会在属性查找时被触发。通常情况下，使用 a.b 来获取、设置或删除一个属性时会在 a 的类字典中查找名称为 b 的对象，但如果 b 是一个描述器，则会调用对应的描述器方法。理解描述器的概念是更深层次理解 Python 的关键，因为这是许多重要特性的基础，包括函数、方法、属性、类方法、静态方法以及对超类的引用等等。

有关描述器的方法的更多信息，请参阅 [实现描述器](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/datamodel.html#descriptors) 或 [描述器使用指南](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/howto/descriptor.html#descriptorhowto)。

dictionary -- 字典

一个关联数组，其中的任意键都映射到相应的值。键可以是任何具有 hash() 和 eq() 方法的对象。在 Perl 语言中称为 hash。

dictionary comprehension -- 字典推导式

处理一个可迭代对象中的所有或部分元素并返回结果字典的一种紧凑写法。 results = {n: n ** 2 for n in range(10)} 将生成一个由键 n 到值 n ** 2 的映射构成的字典。 参见 [列表、集合与字典的显示](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/expressions.html#comprehensions)。

dictionary view -- 字典视图

从 [dict.keys()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#dict.keys), [dict.values()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#dict.values) 和 [dict.items()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#dict.items) 返回的对象被称为字典视图。它们提供了字典条目的一个动态视图，这意味着当字典改变时，视图也会相应改变。要将字典视图强制转换为真正的列表，可使用 list(dictview)。参见 [字典视图对象](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#dict-views)。

docstring -- 文档字符串

作为类、函数或模块之内的第一个表达式出现的字符串字面值。它在代码执行时会被忽略，但会被解释器识别并放入所在类、函数或模块的 doc 属性中。由于它可用于代码内省，因此是对象存放文档的规范位置。

duck-typing -- 鸭子类型

指一种编程风格，它并不依靠查找对象类型来确定其是否具有正确的接口，而是直接调用或使用其方法或属性（“看起来像鸭子，叫起来也像鸭子，那么肯定就是鸭子。”）由于强调接口而非特定类型，设计良好的代码可通过允许多态替代来提升灵活性。鸭子类型避免使用 [type()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/functions.html#type) 或 [isinstance()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/functions.html#isinstance) 检测。(但要注意鸭子类型可以使用 [抽象基类](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-abstract-base-class) 作为补充。) 而往往会采用 [hasattr()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/functions.html#hasattr) 检测或是 [EAFP](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-EAFP) 编程。

EAFP

“求原谅比求许可更容易”的英文缩写。这种 Python 常用代码编写风格会假定所需的键或属性存在，并在假定错误时捕获异常。这种简洁快速风格的特点就是大量运用 [try](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/compound_stmts.html#try) 和 [except](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/compound_stmts.html#except) 语句。于其相对的则是所谓 [LBYL](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-LBYL) 风格，常见于 C 等许多其他语言。

expression -- 表达式

可以求出某个值的语法单元。 换句话说，一个表达式就是表达元素例如字面值、名称、属性访问、运算符或函数调用的汇总，它们最终都会返回一个值。 与许多其他语言不同，并非所有语言构件都是表达式。 还存在不能被用作表达式的 [statement](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-statement)，例如 [while](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/compound_stmts.html#while)。 赋值也是属于语句而非表达式。

extension module -- 扩展模块

以 C 或 C++ 编写的模块，使用 Python 的 C API 来与语言核心以及用户代码进行交互。

f-string -- f-****字符串

带有 'f' 或 'F' 前缀的字符串字面值通常被称为“f-字符串”即 [格式化字符串字面值](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/lexical_analysis.html#f-strings) 的简写。参见 PEP 498。

file object -- 文件对象

对外提供面向文件 API 以使用下层资源的对象（带有 read() 或 write() 这样的方法）。根据其创建方式的不同，文件对象可以处理对真实磁盘文件，对其他类型存储，或是对通讯设备的访问（例如标准输入/输出、内存缓冲区、套接字、管道等等）。文件对象也被称为 文件类对象 或 流。

实际上共有三种类别的文件对象: 原始 [二进制文件](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-binary-file), 缓冲 [二进制文件](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-binary-file) 以及 [文本文件](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-text-file)。它们的接口定义均在 [io](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/io.html#module-io) 模块中。创建文件对象的规范方式是使用 [open()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/functions.html#open) 函数。

file-like object -- 文件类对象

[file object](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-file-object) 的同义词。

filesystem encoding and error handler -- 文件系统编码格式与错误处理句柄

Python 用来从操作系统解码字节串和向操作系统编码 Unicode 的编码格式与错误处理句柄。

文件系统编码格式必须保证能成功解码长度在 128 以下的所有字节串。 如果文件系统编码格式无法提供此保证，则 API 函数可能会引发 [UnicodeError](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/exceptions.html#UnicodeError)。

[sys.getfilesystemencoding()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/sys.html#sys.getfilesystemencoding) 和 [sys.getfilesystemencodeerrors()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/sys.html#sys.getfilesystemencodeerrors) 函数可被用来获取文件系统编码格式与错误处理句柄。

[filesystem encoding and error handler](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-filesystem-encoding-and-error-handler) 是在 Python 启动时通过 PyConfig_Read() 函数来配置的：请参阅 [PyConfig](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/c-api/init_config.html#c.PyConfig) 的 [filesystem_encoding](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/c-api/init_config.html#c.PyConfig.filesystem_encoding) 和 [filesystem_errors](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/c-api/init_config.html#c.PyConfig.filesystem_errors) 等成员。

另请参见 [locale encoding](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-locale-encoding)。

finder -- 查找器

一种会尝试查找被导入模块的 [loader](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-loader) 的对象。

从 Python 3.3 起存在两种类型的查找器: [元路径查找器](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-meta-path-finder) 配合 [sys.meta_path](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/sys.html#sys.meta_path) 使用，以及 [path entry finders](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-path-entry-finder) 配合 [sys.path_hooks](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/sys.html#sys.path_hooks) 使用。

更多详情可参见 PEP 302, PEP 420 和 PEP 451。

floor division -- 向下取整除法

向下舍入到最接近的整数的数学除法。向下取整除法的运算符是 // 。例如，表达式 11 // 4 的计算结果是 2 ，而与之相反的是浮点数的真正除法返回 2.75 。注意 (-11) // 4 会返回 -3 因为这是 -2.75 向下 舍入得到的结果。见 PEP 238 。

function -- 函数

可以向调用者返回某个值的一组语句。还可以向其传入零个或多个 [参数](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-argument) 并在函数体执行中被使用。另见 [parameter](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-parameter), [method](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-method) 和 [函数定义](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/compound_stmts.html#function) 等节。

function annotation -- 函数标注

即针对函数形参或返回值的 [annotation](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-annotation) 。

函数标注通常用于 [类型提示](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-type-hint)：例如以下函数预期接受两个 [int](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/functions.html#int) 参数并预期返回一个 [int](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/functions.html#int) 值:

defsum_two_numbers(a:int,b:int)->int:returna+b

函数标注语法的详解见 [函数定义](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/compound_stmts.html#function) 一节。

参见 [variable annotation](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-variable-annotation) 和 PEP 484，其中描述了此功能。 另请参阅 [对象注解属性的最佳实践](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/howto/annotations.html#annotations-howto) 以了解使用标的最佳实践。

future

[future 语句](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/simple_stmts.html#future), from future import 指示编译器使用将在未来的 Python 发布版中成为标准的语法和语义来编译当前模块。 [future](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/future.html#module-future) 模块文档记录了可能 的 feature 取值。 通过导入此模块并对其变量求值，你可以看到每项新特性在何时被首次加入到该语言中以及它将（或已）在何时成为默认:

>>>

>>> importfuture>>> future.division_Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)

garbage collection -- 垃圾回收

释放不再被使用的内存空间的过程。Python 是通过引用计数和一个能够检测和打破循环引用的循环垃圾回收器来执行垃圾回收的。可以使用 [gc](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/gc.html#module-gc) 模块来控制垃圾回收器。

generator -- 生成器

返回一个 [generator iterator](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-generator-iterator) 的函数。它看起来很像普通函数，不同点在于其包含 [yield](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/simple_stmts.html#yield) 表达式以便产生一系列值供给 for-循环使用或是通过 [next()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/functions.html#next) 函数逐一获取。

通常是指生成器函数，但在某些情况下也可能是指 生成器迭代器。如果需要清楚表达具体含义，请使用全称以避免歧义。

generator iterator -- 生成器迭代器

[generator](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-generator) 函数所创建的对象。

每个 [yield](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/simple_stmts.html#yield) 会临时暂停处理，记住当前位置执行状态（包括局部变量和挂起的 try 语句）。当该 生成器迭代器 恢复时，它会从离开位置继续执行（这与每次调用都从新开始的普通函数差别很大）。

generator expression -- 生成器表达式

返回一个迭代器的表达式。 它看起来很像普通表达式后面带有定义了一个循环变量、范围的 for 子句，以及一个可选的 if 子句。 以下复合表达式会为外层函数生成一系列值:

>>>

>>> sum(iiforiinrange(10))# sum of squares 0, 1, 4, ... 81*285

generic function -- 泛型函数

为不同的类型实现相同操作的多个函数所组成的函数。在调用时会由调度算法来确定应该使用哪个实现。

另请参见 [single dispatch](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-single-dispatch) 术语表条目、[functools.singledispatch()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/functools.html#functools.singledispatch) 装饰器以及 PEP 443。

generic type -- 泛型类型

A [type](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-type) that can be parameterized; typically a [container class](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/datamodel.html#sequence-types) such as [list](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#list) or [dict](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#dict). Used for [type hints](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-type-hint) and [annotations](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-annotation).

For more details, see [generic alias types](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#types-genericalias), PEP 483, PEP 484, PEP 585, and the [typing](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/typing.html#module-typing) module.

GIL

参见 [global interpreter lock](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-global-interpreter-lock)。

global interpreter lock -- 全局解释器锁

[CPython](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-CPython) 解释器所采用的一种机制，它确保同一时刻只有一个线程在执行 Python [bytecode](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-bytecode)。此机制通过设置对象模型（包括 [dict](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#dict) 等重要内置类型）针对并发访问的隐式安全简化了 CPython 实现。给整个解释器加锁使得解释器多线程运行更方便，其代价则是牺牲了在多处理器上的并行性。

不过，某些标准库或第三方库的扩展模块被设计为在执行计算密集型任务如压缩或哈希时释放 GIL。此外，在执行 I/O 操作时也总是会释放 GIL。

创建一个（以更精细粒度来锁定共享数据的）“自由线程”解释器的努力从未获得成功，因为这会牺牲在普通单处理器情况下的性能。据信克服这种性能问题的措施将导致实现变得更复杂，从而更难以维护。

hash-based pyc -- 基于哈希的 pyc

使用对应源文件的哈希值而非最后修改时间来确定其有效性的字节码缓存文件。 参见 [已缓存字节码的失效](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/import.html#pyc-invalidation)。

hashable -- 可哈希

一个对象的哈希值如果在其生命周期内绝不改变，就被称为 可哈希 （它需要具有 hash() 方法），并可以同其他对象进行比较（它需要具有 eq() 方法）。可哈希对象必须具有相同的哈希值比较结果才会相同。

可哈希性使得对象能够作为字典键或集合成员使用，因为这些数据结构要在内部使用哈希值。

大多数 Python 中的不可变内置对象都是可哈希的；可变容器（例如列表或字典）都不可哈希；不可变容器（例如元组和 frozenset）仅当它们的元素均为可哈希时才是可哈希的。 用户定义类的实例对象默认是可哈希的。 它们在比较时一定不相同（除非是与自己比较），它们的哈希值的生成是基于它们的 [id()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/functions.html#id)。

IDLE

Python 的 IDE，“集成开发与学习环境”的英文缩写。是 Python 标准发行版附带的基本编辑器和解释器环境。

immutable -- 不可变对象

具有固定值的对象。不可变对象包括数字、字符串和元组。这样的对象不能被改变。如果必须存储一个不同的值，则必须创建新的对象。它们在需要常量哈希值的地方起着重要作用，例如作为字典中的键。

import path -- 导入路径

由多个位置（或 [路径条目](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-path-entry)）组成的列表，会被模块的 [path based finder](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-path-based-finder) 用来查找导入目标。在导入时，此位置列表通常来自 [sys.path](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/sys.html#sys.path)，但对次级包来说也可能来自上级包的 path 属性。

importing -- 导入

令一个模块中的 Python 代码能为另一个模块中的 Python 代码所使用的过程。

importer -- 导入器

查找并加载模块的对象；此对象既属于 [finder](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-finder) 又属于 [loader](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-loader)。

interactive -- 交互

Python 带有一个交互式解释器，即你可以在解释器提示符后输入语句和表达式，立即执行并查看其结果。只需不带参数地启动 python 命令（也可以在你的计算机开始菜单中选择相应菜单项）。在测试新想法或检验模块和包的时候用这种方式会非常方便（请记得使用 help(x)）。

interpreted -- 解释型

Python 一是种解释型语言，与之相对的是编译型语言，虽然两者的区别由于字节码编译器的存在而会有所模糊。这意味着源文件可以直接运行而不必显式地创建可执行文件再运行。解释型语言通常具有比编译型语言更短的开发/调试周期，但是其程序往往运行得更慢。参见 [interactive](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-interactive)。

interpreter shutdown -- 解释器关闭

当被要求关闭时，Python 解释器将进入一个特殊运行阶段并逐步释放所有已分配资源，例如模块和各种关键内部结构等。它还会多次调用 [垃圾回收器](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-garbage-collection)。这会触发用户定义析构器或弱引用回调中的代码执行。在关闭阶段执行的代码可能会遇到各种异常，因为其所依赖的资源已不再有效（常见的例子有库模块或警告机制等）。

解释器需要关闭的主要原因有 main 模块或所运行的脚本已完成执行。

iterable -- 可迭代对象

能够逐一返回其成员项的对象。 可迭代对象的例子包括所有序列类型 (例如 [list](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#list), [str](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#str) 和 [tuple](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#tuple)) 以及某些非序列类型例如 [dict](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#dict), [文件对象](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-file-object) 以及定义了 iter() 方法或是实现了 [序列](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-sequence) 语义的 getitem() 方法的任意自定义类对象。

可迭代对象被可用于 [for](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/compound_stmts.html#for) 循环以及许多其他需要一个序列的地方（[zip()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/functions.html#zip)、[map()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/functions.html#map) ...）。当一个可迭代对象作为参数传给内置函数 [iter()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/functions.html#iter) 时，它会返回该对象的迭代器。这种迭代器适用于对值集合的一次性遍历。在使用可迭代对象时，你通常不需要调用 [iter()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/functions.html#iter) 或者自己处理迭代器对象。for 语句会为你自动处理那些操作，创建一个临时的未命名变量用来在循环期间保存迭代器。参见 [iterator](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-iterator)、[sequence](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-sequence) 以及 [generator](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-generator)。

iterator -- 迭代器

用来表示一连串数据流的对象。重复调用迭代器的 [next()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#iterator.next) 方法（或将其传给内置函数 [next()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/functions.html#next)）将逐个返回流中的项。当没有数据可用时则将引发 [StopIteration](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/exceptions.html#StopIteration) 异常。到这时迭代器对象中的数据项已耗尽，继续调用其 next() 方法只会再次引发 [StopIteration](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/exceptions.html#StopIteration) 异常。迭代器必须具有 iter() 方法用来返回该迭代器对象自身，因此迭代器必定也是可迭代对象，可被用于其他可迭代对象适用的大部分场合。一个显著的例外是那些会多次重复访问迭代项的代码。容器对象（例如 [list](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#list)）在你每次向其传入 [iter()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/functions.html#iter) 函数或是在 [for](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/compound_stmts.html#for) 循环中使用它时都会产生一个新的迭代器。如果在此情况下你尝试用迭代器则会返回在之前迭代过程中被耗尽的同一迭代器对象，使其看起来就像是一个空容器。

更多信息可查看 [迭代器类型](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#typeiter)。

CPython implementation detail: CPython does not consistently apply the requirement that an iterator define iter().

key function -- 键函数

键函数或称整理函数，是能够返回用于排序或排位的值的可调用对象。例如，[locale.strxfrm()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/locale.html#locale.strxfrm) 可用于生成一个符合特定区域排序约定的排序键。

Python 中有许多工具都允许用键函数来控制元素的排位或分组方式。其中包括 [min()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/functions.html#min), [max()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/functions.html#max), [sorted()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/functions.html#sorted), [list.sort()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#list.sort), [heapq.merge()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/heapq.html#heapq.merge), [heapq.nsmallest()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/heapq.html#heapq.nsmallest), [heapq.nlargest()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/heapq.html#heapq.nlargest) 以及 [itertools.groupby()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/itertools.html#itertools.groupby)。

要创建一个键函数有多种方式。例如，[str.lower()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#str.lower) 方法可以用作忽略大小写排序的键函数。另外，键函数也可通过 [lambda](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/expressions.html#lambda) 表达式来创建，例如 lambda r: (r[0], r[2])。还有 [operator](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/operator.html#module-operator) 模块提供了三个键函数构造器：[attrgetter()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/operator.html#operator.attrgetter)、[itemgetter()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/operator.html#operator.itemgetter) 和 [methodcaller()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/operator.html#operator.methodcaller)。请查看 [如何排序](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/howto/sorting.html#sortinghowto) 一节以获取创建和使用键函数的示例。

keyword argument -- 关键字参数

参见 [argument](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-argument)。

lambda

由一个单独 [expression](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-expression) 构成的匿名内联函数，表达式会在调用时被求值。创建 lambda 函数的句法为 lambda [parameters]: expression

LBYL

“先查看后跳跃”的英文缩写。这种代码编写风格会在进行调用或查找之前显式地检查前提条件。此风格与 [EAFP](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-EAFP) 方式恰成对比，其特点是大量使用 [if](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/compound_stmts.html#if) 语句。

在多线程环境中，LBYL 方式会导致“查看”和“跳跃”之间发生条件竞争风险。例如，以下代码 if key in mapping: return mapping[key] 可能由于在检查操作之后其他线程从 mapping 中移除了 key 而出错。这种问题可通过加锁或使用 EAFP 方式来解决。

locale encoding -- 语言区域编码格式

在 Unix 上，它是 LC_CTYPE 语言区域的编码格式。 它可以通过 locale.setlocale(locale.LC_CTYPE, new_locale) 来设置。

在 Windows 上，它是 ANSI 代码页 (例如: cp1252)。

locale.getpreferredencoding(False) 可被用来获取语言区域编码格式。

Python 使用 [filesystem encoding and error handler](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-filesystem-encoding-and-error-handler) 在 Unicode 文件名和字节串文件名之间进行转换。

list -- 列表

Python 内置的一种 [sequence](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-sequence)。虽然名为列表，但更类似于其他语言中的数组而非链接列表，因为访问元素的时间复杂度为 O(1)。

list comprehension -- 列表推导式

处理一个序列中的所有或部分元素并返回结果列表的一种紧凑写法。result = ['{:#04x}'.format(x) for x in range(256) if x % 2 == 0] 将生成一个 0 到 255 范围内的十六进制偶数对应字符串（0x..）的列表。其中 [if](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/compound_stmts.html#if) 子句是可选的，如果省略则 range(256) 中的所有元素都会被处理。

loader -- 加载器

负责加载模块的对象。它必须定义名为 load_module() 的方法。加载器通常由一个 [finder](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-finder) 返回。详情参见 PEP 302，对于 [abstract base class](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-abstract-base-class) 可参见 [importlib.abc.Loader](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/importlib.html#importlib.abc.Loader)。

magic method -- 魔术方法

[special method](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-special-method) 的非正式同义词 。

mapping -- 映射

一种支持任意键查找并实现了 [Mapping](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/collections.abc.html#collections.abc.Mapping) 或 [MutableMapping](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/collections.abc.html#collections.abc.MutableMapping) [抽象基类](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/collections.abc.html#collections-abstract-base-classes) 中所规定方法的容器对象。 此类对象的例子包括 [dict](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#dict), [collections.defaultdict](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/collections.html#collections.defaultdict), [collections.OrderedDict](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/collections.html#collections.OrderedDict) 以及 [collections.Counter](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/collections.html#collections.Counter)。

meta path finder -- 元路径查找器

[sys.meta_path](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/sys.html#sys.meta_path) 的搜索所返回的 [finder](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-finder)。元路径查找器与 [path entry finders](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-path-entry-finder) 存在关联但并不相同。

请查看 [importlib.abc.MetaPathFinder](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/importlib.html#importlib.abc.MetaPathFinder) 了解元路径查找器所实现的方法。

metaclass -- 元类

一种用于创建类的类。类定义包含类名、类字典和基类列表。元类负责接受上述三个参数并创建相应的类。大部分面向对象的编程语言都会提供一个默认实现。Python 的特别之处在于可以创建自定义元类。大部分用户永远不需要这个工具，但当需要出现时，元类可提供强大而优雅的解决方案。它们已被用于记录属性访问日志、添加线程安全性、跟踪对象创建、实现单例，以及其他许多任务。

更多详情参见 [元类](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/datamodel.html#metaclasses)。

method -- 方法

在类内部定义的函数。如果作为该类的实例的一个属性来调用，方法将会获取实例对象作为其第一个 [argument](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-argument) (通常命名为 self)。参见 [function](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-function) 和 [nested scope](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-nested-scope)。

method resolution order -- 方法解析顺序

方法解析顺序就是在查找成员时搜索全部基类所用的先后顺序。请查看 Python 2.3 方法解析顺序 了解自 2.3 版起 Python 解析器所用相关算法的详情。

module -- 模块

此对象是 Python 代码的一种组织单位。各模块具有独立的命名空间，可包含任意 Python 对象。模块可通过 [importing](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-importing) 操作被加载到 Python 中。

另见 [package](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-package)。

module spec -- 模块规格

一个命名空间，其中包含用于加载模块的相关导入信息。是 [importlib.machinery.ModuleSpec](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/importlib.html#importlib.machinery.ModuleSpec) 的实例。

MRO

参见 [method resolution order](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-method-resolution-order)。

mutable -- 可变对象

可变对象可以在其 [id()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/functions.html#id) 保持固定的情况下改变其取值。另请参见 [immutable](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-immutable)。

named tuple -- 具名元组

术语“具名元组”可用于任何继承自元组，并且其中的可索引元素还能使用名称属性来访问的类型或类。 这样的类型或类还可能拥有其他特性。

有些内置类型属于具名元组，包括 [time.localtime()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/time.html#time.localtime) 和 [os.stat()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/os.html#os.stat) 的返回值。 另一个例子是 [sys.float_info](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/sys.html#sys.float_info):

>>>

>>> sys.float_info[1]# indexed access1024>>> sys.float_info.max_exp# named field access1024>>> isinstance(sys.float_info,tuple)# kind of tupleTrue

有些具名元组是内置类型（例如上面的例子）。 此外，具名元组还可通过常规类定义从 [tuple](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#tuple) 继承并定义名称字段的方式来创建。 这样的类可以手工编写，或者使用工厂函数 [collections.namedtuple()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/collections.html#collections.namedtuple) 创建。 后一种方式还会添加一些手工编写或内置具名元组所没有的额外方法。

namespace -- 命名空间

命名空间是存放变量的场所。命名空间有局部、全局和内置的，还有对象中的嵌套命名空间（在方法之内）。命名空间通过防止命名冲突来支持模块化。例如，函数 [builtins.open](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/functions.html#open) 与 [os.open()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/os.html#os.open) 可通过各自的命名空间来区分。命名空间还通过明确哪个模块实现那个函数来帮助提高可读性和可维护性。例如，[random.seed()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/random.html#random.seed) 或 [itertools.islice()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/itertools.html#itertools.islice) 这种写法明确了这些函数是由 [random](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/random.html#module-random) 与 [itertools](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/itertools.html#module-itertools) 模块分别实现的。

namespace package -- 命名空间包

PEP 420 所引入的一种仅被用作子包的容器的 [package](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-package)，命名空间包可以没有实体表示物，其描述方式与 [regular package](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-regular-package) 不同，因为它们没有 init.py 文件。

另可参见 [module](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-module)。

nested scope -- 嵌套作用域

在一个定义范围内引用变量的能力。例如，在另一函数之内定义的函数可以引用前者的变量。请注意嵌套作用域默认只对引用有效而对赋值无效。局部变量的读写都受限于最内层作用域。类似的，全局变量的读写则作用于全局命名空间。通过 [nonlocal](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/simple_stmts.html#nonlocal) 关键字可允许写入外层作用域。

new-style class -- 新式类

对于目前已被应于所有类对象的类形式的旧称谓。在早先的 Python 版本中，只有新式类能够使用 Python 新增的更灵活特性，例如 [slots](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/datamodel.html#object.slots)、描述符、特征属性、getattribute()、类方法和静态方法等。

object -- 对象

任何具有状态（属性或值）以及预定义行为（方法）的数据。object 也是任何 [new-style class](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-new-style-class) 的最顶层基类名。

package -- 包

一种可包含子模块或递归地包含子包的 Python [module](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-module)。从技术上说，包是带有 path 属性的 Python 模块。

另参见 [regular package](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-regular-package) 和 [namespace package](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-namespace-package)。

parameter -- 形参

[function](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-function) （或方法）定义中的命名实体，它指定函数可以接受的一个 [argument](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-argument) （或在某些情况下，多个实参）。有五种形参：

• positional-or-keyword：位置或关键字，指定一个可以作为 [位置参数](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-argument) 传入也可以作为 [关键字参数](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-argument) 传入的实参。这是默认的形参类型，例如下面的 foo 和 bar:
  deffunc(foo,bar=None):...
• positional-only：仅限位置，指定一个只能通过位置传入的参数。 仅限位置形参可通过在函数定义的形参列表中它们之后包含一个 / 字符来定义，例如下面的 posonly1 和 posonly2:
  deffunc(posonly1,posonly2,/,positional_or_keyword):...
• keyword-only：仅限关键字，指定一个只能通过关键字传入的参数。仅限关键字形参可通过在函数定义的形参列表中包含单个可变位置形参或者在多个可变位置形参之前放一个 * 来定义，例如下面的 kw_only1 和 kw_only2:
  deffunc(arg,*,kw_only1,kw_only2):...
• var-positional：可变位置，指定可以提供由一个任意数量的位置参数构成的序列（附加在其他形参已接受的位置参数之后）。这种形参可通过在形参名称前加缀 * 来定义，例如下面的 args:
  deffunc(*args,**kwargs):...
• var-keyword：可变关键字，指定可以提供任意数量的关键字参数（附加在其他形参已接受的关键字参数之后）。这种形参可通过在形参名称前加缀 ** 来定义，例如上面的 kwargs。

形参可以同时指定可选和必选参数，也可以为某些可选参数指定默认值。

另参见 [argument](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-argument) 术语表条目、[参数与形参的区别](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/faq/programming.html#faq-argument-vs-parameter) 中的常见问题、[inspect.Parameter](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/inspect.html#inspect.Parameter) 类、[函数定义](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/compound_stmts.html#function) 一节以及 PEP 362。

path entry -- 路径入口

[import path](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-import-path) 中的一个单独位置，会被 [path based finder](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-path-based-finder) 用来查找要导入的模块。

path entry finder -- 路径入口查找器

任一可调用对象使用 [sys.path_hooks](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/sys.html#sys.path_hooks) (即 [path entry hook](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-path-entry-hook)) 返回的 [finder](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-finder)，此种对象能通过 [path entry](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-path-entry) 来定位模块。

请参看 [importlib.abc.PathEntryFinder](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/importlib.html#importlib.abc.PathEntryFinder) 以了解路径入口查找器所实现的各个方法。

path entry hook -- 路径入口钩子

一种可调用对象，在知道如何查找特定 [path entry](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-path-entry) 中的模块的情况下能够使用 sys.path_hook 列表返回一个 [path entry finder](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-path-entry-finder)。

path based finder -- 基于路径的查找器

默认的一种 [元路径查找器](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-meta-path-finder)，可在一个 [import path](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-import-path) 中查找模块。

path-like object -- 路径类对象

代表一个文件系统路径的对象。类路径对象可以是一个表示路径的 [str](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#str) 或者 [bytes](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#bytes) 对象，还可以是一个实现了 [os.PathLike](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/os.html#os.PathLike) 协议的对象。一个支持 [os.PathLike](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/os.html#os.PathLike) 协议的对象可通过调用 [os.fspath()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/os.html#os.fspath) 函数转换为 [str](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#str) 或者 [bytes](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#bytes) 类型的文件系统路径；[os.fsdecode()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/os.html#os.fsdecode) 和 [os.fsencode()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/os.html#os.fsencode) 可被分别用来确保获得 [str](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#str) 或 [bytes](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#bytes) 类型的结果。此对象是由 PEP 519 引入的。

PEP

“Python 增强提议”的英文缩写。一个 PEP 就是一份设计文档，用来向 Python 社区提供信息，或描述一个 Python 的新增特性及其进度或环境。PEP 应当提供精确的技术规格和所提议特性的原理说明。

PEP 应被作为提出主要新特性建议、收集社区对特定问题反馈以及为必须加入 Python 的设计决策编写文档的首选机制。PEP 的作者有责任在社区内部建立共识，并应将不同意见也记入文档。

参见 PEP 1。

portion -- 部分

构成一个命名空间包的单个目录内文件集合（也可能存放于一个 zip 文件内），具体定义见 PEP 420。

positional argument -- 位置参数

参见 [argument](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-argument)。

provisional API -- 暂定 API

暂定 API 是指被有意排除在标准库的向后兼容性保证之外的应用编程接口。虽然此类接口通常不会再有重大改变，但只要其被标记为暂定，就可能在核心开发者确定有必要的情况下进行向后不兼容的更改（甚至包括移除该接口）。此种更改并不会随意进行 -- 仅在 API 被加入之前未考虑到的严重基础性缺陷被发现时才可能会这样做。

即便是对暂定 API 来说，向后不兼容的更改也会被视为“最后的解决方案” —— 任何问题被确认时都会尽可能先尝试找到一种向后兼容的解决方案。

这种处理过程允许标准库持续不断地演进，不至于被有问题的长期性设计缺陷所困。详情见 PEP 411。

provisional package -- 暂定包

参见 [provisional API](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-provisional-API)。

Python 3000

Python 3.x 发布路线的昵称（这个名字在版本 3 的发布还遥遥无期的时候就已出现了）。有时也被缩写为“Py3k”。

Pythonic

指一个思路或一段代码紧密遵循了 Python 语言最常用的风格和理念，而不是使用其他语言中通用的概念来实现代码。例如，Python 的常用风格是使用 [for](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/compound_stmts.html#for) 语句循环来遍历一个可迭代对象中的所有元素。许多其他语言没有这样的结构，因此不熟悉 Python 的人有时会选择使用一个数字计数器:

foriinrange(len(food)):print(food[i])

而相应的更简洁更 Pythonic 的方法是这样的:

forpieceinfood:print(piece)

qualified name -- 限定名称

一个以点号分隔的名称，显示从模块的全局作用域到该模块中定义的某个类、函数或方法的“路径”，相关定义见 PEP 3155。对于最高层级的函数和类，限定名称与对象名称一致:

>>>

>>> class****C:... class****D:... defmeth(self):... pass****...>>> C.qualname'C'>>> C.D.qualname'C.D'>>> C.D.meth.qualname'C.D.meth'

当被用于引用模块时，完整限定名称 意为标示该模块的以点号分隔的整个路径，其中包含其所有的父包，例如 email.mime.text:

>>>

>>> importemail.mime.text>>> email.mime.text.name'email.mime.text'

reference count -- 引用计数

对特定对象的引用的数量。当一个对象的引用计数降为零时，所分配资源将被释放。引用计数对 Python 代码来说通常是不可见的，但它是 [CPython](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-CPython) 实现的一个关键元素。[sys](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/sys.html#module-sys) 模块定义了一个 [getrefcount()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/sys.html#sys.getrefcount) 函数，程序员可调用它来返回特定对象的引用计数。

regular package -- 常规包

传统型的 [package](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-package)，例如包含有一个 init.py 文件的目录。

另参见 [namespace package](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-namespace-package)。

slots

一种写在类内部的声明，通过预先声明实例属性等对象并移除实例字典来节省内存。虽然这种技巧很流行，但想要用好却并不容易，最好是只保留在少数情况下采用，例如极耗内存的应用程序，并且其中包含大量实例。

sequence -- 序列

一种 [iterable](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-iterable)，它支持通过 getitem() 特殊方法来使用整数索引进行高效的元素访问，并定义了一个返回序列长度的 len() 方法。内置的序列类型有 [list](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#list)、[str](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#str)、[tuple](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#tuple) 和 [bytes](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#bytes)。注意虽然 [dict](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#dict) 也支持 getitem() 和 len()，但它被认为属于映射而非序列，因为它查找时使用任意的 [immutable](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-immutable) 键而非整数。

[collections.abc.Sequence](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/collections.abc.html#collections.abc.Sequence) 抽象基类定义了一个更丰富的接口，它在 getitem() 和 len() 之外又添加了 count(), index(), contains() 和 reversed()。 实现此扩展接口的类型可以使用 [register()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/abc.html#abc.ABCMeta.register) 来显式地注册。

set comprehension -- 集合推导式

处理一个可迭代对象中的所有或部分元素并返回结果集合的一种紧凑写法。 results = {c for c in 'abracadabra' if c not in 'abc'} 将生成字符串集合 {'r', 'd'}。 参见 [列表、集合与字典的显示](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/expressions.html#comprehensions)。

single dispatch -- 单分派

一种 [generic function](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-generic-function) 分派形式，其实现是基于单个参数的类型来选择的。

slice -- 切片

通常只包含了特定 [sequence](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-sequence) 的一部分的对象。切片是通过使用下标标记来创建的，在 [] 中给出几个以冒号分隔的数字，例如 variable_name[1:3:5]。方括号（下标）标记在内部使用 [slice](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/functions.html#slice) 对象。

special method -- 特殊方法

一种由 Python 隐式调用的方法，用来对某个类型执行特定操作例如相加等等。这种方法的名称的首尾都为双下划线。特殊方法的文档参见 [特殊方法名称](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/datamodel.html#specialnames)。

statement -- 语句

语句是程序段（一个代码“块”）的组成单位。一条语句可以是一个 [expression](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-expression) 或某个带有关键字的结构，例如 [if](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/compound_stmts.html#if)、[while](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/compound_stmts.html#while) 或 [for](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/compound_stmts.html#for)。

strong reference -- 强引用

在 Python 的 C API 中，强引用是对象引用的一种，当它被创建时将会增加对象引用计数而当它被删除时则会减少对象引用计数。

[Py_NewRef()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/c-api/refcounting.html#c.Py_NewRef) 函数可被用于创建一个对象的强引用。 通常，必须在退出某个强引用的作用域时在该强引用上调用 [Py_DECREF()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/c-api/refcounting.html#c.Py_DECREF) 函数，以避免引用的泄漏。

另请参阅 [borrowed reference](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-borrowed-reference)。

text encoding -- 文本编码

A string in Python is a sequence of Unicode code points (in range U+0000--U+10FFFF). To store or transfer a string, it needs to be serialized as a sequence of bytes.

Serializing a string into a sequence of bytes is known as "encoding", and recreating the string from the sequence of bytes is known as "decoding".

There are a variety of different text serialization [codecs](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/codecs.html#standard-encodings), which are collectively referred to as "text encodings".

text file -- 文本文件

一种能够读写 [str](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#str) 对象的 [file object](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-file-object)。通常一个文本文件实际是访问一个面向字节的数据流并自动处理 [text encoding](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-text-encoding)。文本文件的例子包括以文本模式（'r' 或 'w'）打开的文件、[sys.stdin](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/sys.html#sys.stdin)、[sys.stdout](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/sys.html#sys.stdout) 以及 [io.StringIO](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/io.html#io.StringIO) 的实例。

另请参看 [binary file](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-binary-file) 了解能够读写 [字节类对象](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-bytes-like-object) 的文件对象。

triple-quoted string -- 三引号字符串

首尾各带三个连续双引号（"）或者单引号（'）的字符串。它们在功能上与首尾各用一个引号标注的字符串没有什么不同，但是有多种用处。它们允许你在字符串内包含未经转义的单引号和双引号，并且可以跨越多行而无需使用连接符，在编写文档字符串时特别好用。

type -- 类型

类型决定一个 Python 对象属于什么种类；每个对象都具有一种类型。要知道对象的类型，可以访问它的 [class](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#instance.class) 属性，或是通过 type(obj) 来获取。

type alias -- 类型别名

一个类型的同义词，创建方式是把类型赋值给特定的标识符。

类型别名的作用是简化 [类型提示](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-type-hint)。例如:

defremove_gray_shades(colors:list[tuple[int,int,int]])->list[tuple[int,int,int]]:pass

可以这样提高可读性:

Color=tuple[int,int,int]defremove_gray_shades(colors:list[Color])->list[Color]:pass

参见 [typing](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/typing.html#module-typing) 和 PEP 484，其中有对此功能的详细描述。

type hint -- 类型提示

[annotation](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-annotation) 为变量、类属性、函数的形参或返回值指定预期的类型。

类型提示属于可选项，Python 不要求提供，但其可对静态类型分析工具起作用，并可协助 IDE 实现代码补全与重构。

全局变量、类属性和函数的类型提示可以使用 [typing.get_type_hints()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/typing.html#typing.get_type_hints) 来访问，但局部变量则不可以。

参见 [typing](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/typing.html#module-typing) 和 PEP 484，其中有对此功能的详细描述。

universal newlines -- 通用换行

一种解读文本流的方式，将以下所有符号都识别为行结束标志：Unix 的行结束约定 '\n'、Windows 的约定 '\r\n' 以及旧版 Macintosh 的约定 '\r'。参见 PEP 278 和 PEP 3116 和 [bytes.splitlines()](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/stdtypes.html#bytes.splitlines) 了解更多用法说明。

variable annotation -- 变量标注

对变量或类属性的 [annotation](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-annotation)。

在标注变量或类属性时，还可选择为其赋值:

class****C:field:'annotation'

变量标注通常被用作 [类型提示](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-type-hint)：例如以下变量预期接受 [int](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/functions.html#int) 类型的值:

count:int=0

变量标注语法的详细解释见 [带标注的赋值语句](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/reference/simple_stmts.html#annassign) 一节。

参见 [function annotation](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-function-annotation), PEP 484 和 PEP 526，其中描述了此功能。 另请参阅 [对象注解属性的最佳实践](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/howto/annotations.html#annotations-howto) 以了解使用标注的最佳实践。

virtual environment -- 虚拟环境

一种采用协作式隔离的运行时环境，允许 Python 用户和应用程序在安装和升级 Python 分发包时不会干扰到同一系统上运行的其他 Python 应用程序的行为。

另参见 [venv](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/library/venv.html#module-venv)。

virtual machine -- 虚拟机

一台完全通过软件定义的计算机。Python 虚拟机可执行字节码编译器所生成的 [bytecode](file:///C:/Users/FQCj/Desktop/python-3.10.5-docs-html/glossary.html#term-bytecode)。

Zen of Python -- Python 之禅

列出 Python 设计的原则与哲学，有助于理解与使用这种语言。查看其具体内容可在交互模式提示符中输入 "import this"。

pip命令

pip使用

安装包

pip install package_name

查看某个已安装包

pip show --files package_name

检查哪些包需要更新

pip list --outdated

升级包

pip install --upgrade package_name

卸载包

pip uninstall package_name

八 安装包或者模块

可以通过pip或者easy_install安装。pip是现代化的一种安装包的方式，以下讲解pip的常用命令:

1.安装包

pip install requests

2. 安装指定版本的包

pip install django == 1.10.6

3.卸载包

pip uninstall django

4.升级包

pip install -U requests

列出可升级的包：

pip list --outdate

一行命令升级所有pip安装的Python包

pip freeze --local | grep -v ‘^-e‘ | cut -d = -f 1 | xargs pip install -U

建议在执行前先执行：

pip install -U distribute

5.升级pip

pip install -U pip

6.查看当前pip是哪个版本

pip --version

7.显示某个已安装的包的信息

pip show -f <包名>

8.列出当前环境下安装了哪些包

pip list

9. 将当前环境安装的包全部列出来放在文件中

pip freeze > requirements.txt

10.从某个文件中安装包

pip install -r requirements.txt

11.临时更改安装源，以豆瓣源为例

pip install <包名> -i https://pypi.douban.com/simple

12.永久更改安装源

windows操作系统：在当前用户目录下新建pip/pip.ini，然后在文件中添加以下代码：

[global]

index-url = https://pypi.douban.com/simple

Linux/Mac：在用户目录下新建.pip/pip.conf，然后在文件中添加以下代码：

[global]

index-url = https://pypi.douban.com/simple

python pip 删除所有包

1) 导出所有包

pip freeze > requirements.txt

2）删除所有包

pip uninstall -r requirements.txt

or

pip uninstall -r requirements.txt -y

 
 
# pip --help
 
Usage:

pip [options]

conda 环境Pip报错Script file ‘D:\Anaconda3\Scripts\pip-script.py’ is not present.

解决方法

1、进入创建的环境：activate env_name

2、输入：python -m ensurepip

3、输入：python -m pip install --upgrade pip

 
 
Commands:
 install           Install packages. ``安装包
 download          Download packages. ``下载包
 uninstall          Uninstall packages. ``卸载包
 freeze           Output installed packages in requirements format. ``按着一定格式输出已安装包列表
 list            List installed packages. ``列出已安装包
 show            Show information about installed packages. ``显示包详细信息
 check            Verify installed packages have compatible dependencies.``检查包的依赖关系是否完整
 config           Manage local and global configuration.``管理配置
 search           Search PyPI for packages.``搜索包
 wheel            Build wheels from your requirements.
 hash            Compute hashes of package archives.``计算包的hash值 
 completion         A helper command used for command completion.
 help            Show help for commands.
 
General Options:
 -h, --help         Show help.
 --isolated         Run pip in an isolated mode, ignoring environment variables and user configuration.
 -v, --verbose        Give more output. Option is additive, and can be used up to 3 times.
 -V, --version        Show version and exit.
 -q, --quiet         Give less output. Option is additive, and can be used up to 3 times (corresponding to WARNING, ERROR, and CRITICAL logging levels).
 --log <path>        Path to a verbose appending log.
 --proxy <proxy>       Specify a proxy in the form [user:passwd@]proxy.server:port.
 --retries <retries>     Maximum number of retries each connection should attempt (default 5 times).
 --timeout <sec>       Set the socket timeout (default 15 seconds).
 --exists-action <action>  Default action when a path already exists: (s)witch, (i)gnore, (w)ipe, (b)ackup, (a)bort).
 --trusted-host <hostname>  Mark this host as trusted, even though it does not have valid or any HTTPS.
 --cert <path>        Path to alternate CA bundle.
 --client-cert <path>    Path to SSL client certificate, a single file containing the private key and the certificate in PEM format.
 --cache-dir <dir>      Store the cache data in <dir>.
 --no-cache-dir       Disable the cache.
 --disable-pip-version-check
               Don't periodically check PyPI to determine whether a new version of pip is available for download. Implied with --no-index.
 --no-color         Suppress colored output

模块介绍

模块首次导入三步

1.执行模块导入

2.产生对应的名称空间，将导入的模块运行时产生的名字都放入指定的名称空间

3.会把模块产生的名称空间指向导入方的同名名称空间中

模块导入规范：

1.导入内置模块

2.导入第三方模块

3.导入自定义模块

as 取别名

import---- as aa

From ----- import --- as aa

自定义模块的命名：

小写加下划线的风格

py文件的两种用途：1.做程序，2.做模块

name：当他作为程序是它的值是__main__,做模块时就是模块名

import和from import的区别

import：

1.执行模块导入

2.产生对应的名称空间，将导入的模块运行时产生的名字都放入指定的名称空间

3.会把模块产生的名称空间指向导入方的同名名称空间中

好处：不会与当前命名产生冲突

缺点，麻烦，当引用模块具体是，要加前缀

From import

1.产生了一个模块命名空间

2.将模块运行时产生的名字放到模块的名称空间

3.在当前名称空间拿到一个名字，这个名字的内存地址与模块名称空间的内存地址相同

好处：代码节俭

坏处：容易产生命名混淆

all：可以控制*导入那些名字

Import *

From 模块包 import *

模块查找优先级

1.找内存（内置模块）

2.按照sys。path打印出来的路径去查找

pprint.pprint(sys.path) #``查看解释器模块路径
pprint.pprint(sys.modules)``#``查看运行时加载的模块

导包规范：

1.无论是哪一种方式导包，在使用待点（.）的时候点的左边必须是包

2.不同包的同名模块，他是不同的，位于不同的命名空间

3、import导入，名称空间产生于文件，form import 导入时来源于包下的__init__。py

绝对导入和相对导入

绝对导入：

以包为起点进行导入

相对导入：

仅限于包内使用，不能挎包，包内模块之间导入

.``代表当前
..``代表上一级

软件开发规范目录：

Foo/
|-- core/
|  |-- core.py
|
|-- api/
|  |-- api.py
|
|-- db/
|  |-- db_handle.py
|
|-- lib/
|  |-- common.py
|
|-- conf/
|  |-- settings.py
|
|-- run.py
|-- setup.py
|-- requirements.txt
|-- README
 • core/: ``存放业务逻辑相关代码
 • api/: ``存放接口文件，接口主要用于为业务逻辑提供数据操作。
 • db/: ``存放操作数据库相关文件，主要用于与数据库交互
 • lib/: ``存放程序中常用的自定义模块
 • conf/: ``存放配置文件
 • run.py: ``程序的启动文件，一般放在项目的根目录下，因为在运行时会默认将运行文件所在的文件夹作为``sys.path``的第一个路径，这样就省去了处理环境变量的步骤
 • setup.py: ``安装、部署、打包的脚本。
 • requirements.txt: ``存放软件依赖的外部``Python``包列表。
 • README: ``项目说明文件。

除此之外，有一些方案给出了更加多的内容，比如LICENSE.txt,ChangeLog.txt文件等，主要是在项目需要开源时才会用到

README

关于README的内容，这个应该是每个项目都应该有的一个文件，目的是能简要描述该项目的信息，让读者快速了解这个项目。它需要说明以下几个事项:

1、软件定位，软件的基本功能；

2、运行代码的方法: 安装环境、启动命令等；

3、简要的使用说明；

4、代码目录结构说明，更详细点可以说明软件的基本原理；

5、常见问题说明。

setup.py

setup.py``来管理代码的打包、安装、部署问题。业界标准的写法是用``Python``流行的打包工具``setuptools``来管理这些事情，这种方式普遍应用于开源项目中。不过这里的核心思想不是用标准化的工具来解决这些问题，而是说，一个项目一定要有一个安装部署工具，能快速便捷的在一台新机器上将环境装好、代码部署好和将程序运行起来。

requirements.txt

requirements.txt``文件的存在是为了方便开发者维护软件的依赖库。我们需要将开发过程中依赖库的信息添加进该文件中，避免在`` setup.py``安装依赖时漏掉软件包，同时也方便了使用者明确项目引用了哪些``Python``包。

conda基础知识

基础

下载地址： https://www.anaconda.com/download/

Conda是一个开源的包、环境管理器，可以用于在同一个机器上安装不同版本的软件包及其依赖，并能够在不同的环境之间切换

Anaconda包括Conda、Python以及一大堆安装好的工具包，比如：numpy、pandas等

Miniconda包括Conda、Python

创建环境

conda create -n 环境名字 python=版本号

/

conda create --name 环境名字 python=版本号

切换环境

activate 环境名字

查看已经存在的环境

conda env list

卸载环境

conda remove --name 环境名字 --all

查看版本

Python 
python`` ``--version

Conda

Conda --version

这几步都需要切换到对应的环境中去

安装第三方包

输入
conda install requests
或者
pip install requests

卸载第三方包

那么怎么卸载一个包呢

conda remove requests

或者

pip uninstall requests

查看环境包信息

要查看当前环境中所有安装了的包可以用

conda list

导入导出环境

如果想要导出当前环境的包信息可以用
 
conda env export > environment.yaml
 
将包信息存入``yaml``文件中``.
 
当需要重新创建一个相同的虚拟环境时可以用
 
conda env create -f environment.yaml

常用命令

activate // ``切换到``base``环境
 
activate learn // ``切换到``learn``环境
 
conda create -n learn python=3 // ``创建一个名为``learn``的环境并指定``python``版本为``3(``的最新版本``)
 
conda env list // ``列出``conda``管理的所有环境
 
conda list // ``列出当前环境的所有包
 
conda install requests ``安装``requests``包
 
conda remove requests ``卸载``requets``包
 
conda remove -n learn --all // ``删除``learn``环境及下属所有包
 
conda update requests ``更新``requests``包
 
conda env export > environment.yaml // ``导出当前环境的包信息
 
conda env create -f environment.yaml // ``用配置文件创建新的虚拟环境

注意：

Jupyter

jupyter使用

jupyter 设置中文

\1. 下载中文包

pip install jupyterlab-language-pack-zh-CN

选择上面的用户变量，是用户变量！！！

选择新建，弹出的选项卡中，变量名为：LANG 变量值：zh_CN.UTF8

配置代码提示

默认``Jupyter Notebook``没有安装代码提示功能，极度影响编程效率，但是我们可以可通过如下命令安装和配置使得``Jupyter Notebook``具备代码提供功能。
1``、开始菜单运行``Anaconda Prompt (Anaconda3)``，逐条输入命令
pip install jupyter_contrib_nbextensions
jupyter contrib nbextension install
pip install jupyter_nbextensions_configurator
jupyter nbextensions_configurator enable

报错

AttributeError: type object 'IOLoop' has no attribute 'initialized'

\1. 降低tornado版本

看了很多博客，大多数都是说tornado版本与jupyter不匹配，安装指定版本的tornado就行

conda install tornado=4.5

1

\2. 升级pyzmq版本

我安装成功之后，jupyter还是打不开，还是报同样的错误。在github上看到了同样的问题，大多数人执行如下命令即可。

conda install -c anaconda pyzmq

1

问题原因：

有人说问题原因是tornado包是新版本的，而pyzmq或/和jupyter notebook是旧版本。

所以以上两种方法都是统一现有的版本，第一种是统一为旧版本，第二种是统一到新版本。