Python

这是一篇关于Python的思维导图，作为一门叫做ABC语言的替代品。Python提供了高效的高级数据结构，还能简单有效地面向对象编程。

Python

基础语法

标识符

第一个字符必须是字母表中字母或下划线 _

标识符的其他的部分由字母、数字和下划线组成

标识符对大小写敏感

Python 3 中，可以用中文作为变量名，非 ASCII 标识符也是允许的了

python保留字

保留字即关键字，我们不能把它们用作任何标识符名称

注释

Python中单行注释以 # 开头

多行注释可以用多个 # 号，还有 ''' 和 """

行与缩进

python最具特色的就是使用缩进来表示代码块，不需要使用大括号 {}

缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数

多行语句

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

在 [], {}, 或 () 中的多行语句，不需要使用反斜杠 \

空行

函数之间或类的方法之间用空行分隔，表示一段新的代码的开始

类和函数入口之间也用一行空行分隔，以突出函数入口的开始

空行与代码缩进不同，空行并不是Python语法的一部分

书写时不插入空行，Python解释器运行也不会出错

空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构

空行也是程序代码的一部分

同一行显示多条语句

Python 可以在同一行中使用多条语句，语句之间使用分号 ; 分割

多个语句构成代码组

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

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

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

print 输出

print 默认输出是换行的

如果要实现不换行需要在变量末尾加上 end=""

import

在 python 用 import 或者 from...import 来导入相应的模块

将整个模块(somemodule)导入，格式为： import somemodule

从某个模块中导入某个函数,格式为： from somemodule import somefunction

从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc

运算符

算术运算符

+ 加 - 两个对象相加

- 减 - 得到负数或是一个数减去另一个数

* 乘 - 两个数相乘或是返回一个被重复若干次的字符串

/ 除 - x 除以 y

% 取模 - 返回除法的余数

** 幂 - 返回x的y次幂

// 取整除 - 向下取接近商的整数

比较运算符

== 等于 - 比较对象是否相等 (a == b) 返回 False。

!= 不等于 - 比较两个对象是否不相等 (a != b) 返回 True。

> 大于 - 返回x是否大于y (a > b) 返回 False。

< 小于 - 返回x是否小于y。(a < b) 返回 True。

>= 大于等于 - 返回x是否大于等于y。 (a >= b) 返回 False。

<= 小于等于 - 返回x是否小于等于y。 (a <= b) 返回 True。

赋值运算符

= 简单的赋值运算符 c = a + b 将 a + b 的运算结果赋值为 c

+= 加法赋值运算符 c += a 等效于 c = c + a

-= 减法赋值运算符 c -= a 等效于 c = c - a

*= 乘法赋值运算符 c *= a 等效于 c = c * a

/= 除法赋值运算符 c /= a 等效于 c = c / a

%= 取模赋值运算符 c %= a 等效于 c = c % a

**= 幂赋值运算符 c **= a 等效于 c = c ** a

//= 取整除赋值运算符 c //= a 等效于 c = c // a

:= 海象运算符，可在表达式内部为变量赋值。Python3.8 版本新增运算符。

位运算符

& 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0

| 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1

^ 按位异或运算符：当两对应的二进位相异时，结果为1

~ 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1

<< 左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0

>> 右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数

逻辑运算符

and x and y 布尔"与" - 如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。

or x or y 布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值

not not x 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True

成员运算符

in 如果在指定的序列中找到值返回 True，否则返回 False。 x 在 y 序列中 , 如果 x 在 y 序列中返回 True

not in 如果在指定的序列中没有找到值返回 True，否则返回 False。 x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True

身份运算符

is 是判断两个标识符是不是引用自一个对象 x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False

is not 是判断两个标识符是不是引用自不同对象 x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

基本数据类型

Python 中的变量

Python 中的变量不需要声明

每个变量在使用前都必须赋值

变量赋值以后该变量才会被创建

在 Python 中，变量就是变量，它没有类型

我们所说的"类型"是变量所指的内存中对象的类型

多个变量赋值

Python允许你同时为多个变量赋值

例：a = b = c = 1

您也可以为多个对象指定多个变量

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

标准数据类型

Number（数字）

一般规定

数据类型是不允许改变的,这就意味着如果改变数字数据类型的值，将重新分配内存空间

Python 数字数据类型用于存储数值

三种不同的数字类型

整型(int) - 通常被称为是整型或整数，是正或负整数，不带小数点

浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示

复数( (complex)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型

数字类型转换

int(x)

将x转换为一个整数。

float(x)

将x转换到一个浮点数。

complex(x)

将x转换到一个复数，实数部分为 x，虚数部分为 0。

complex(x, y)

将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式

数字相关函数

数学函数

abs(x) 返回数字的绝对值，如abs(-10) 返回 10

ceil(x) 返回数字的上入整数，如math.ceil(4.1) 返回 5

exp(x) 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045

fabs(x) 返回数字的绝对值，如math.fabs(-10) 返回10.0

floor(x) 返回数字的下舍整数，如math.floor(4.9)返回 4

log(x) 如math.log(math.e)返回1.0,math.log(100,10)返回2.0

log10(x) 返回以10为基数的x的对数，如math.log10(100)返回 2.0

max(x1, x2,...) 返回给定参数的最大值，参数可以为序列

min(x1, x2,...) 返回给定参数的最小值，参数可以为序列

modf(x) 返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示

pow(x, y) x**y 运算后的值

round(x [,n]) 返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。其实准确的说是保留值将保留到离上一位更近的一端

sqrt(x) 返回数字x的平方根

随机数函数

choice(seq) 从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数

randrange ([start,] stop [,step]) 从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1

random() 随机生成下一个实数，它在[0,1)范围内

seed([x]) 改变随机数生成器的种子seed

shuffle(lst) 将序列的所有元素随机排序

uniform(x, y) 随机生成下一个实数，它在[x,y]范围内

三角函数

acos(x) 返回x的反余弦弧度值

asin(x) 返回x的反正弦弧度值

atan(x) 返回x的反正切弧度值

atan2(y, x) 返回给定的 X 及 Y 坐标值的反正切值。

cos(x) 返回x的弧度的余弦值

hypot(x, y) 返回欧几里德范数 sqrt(x*x + y*y)

sin(x) 返回的x弧度的正弦值

tan(x) 返回x弧度的正切值

degrees(x) 将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0

radians(x) 将角度转换为弧度

数学常量

pi 数学常量 pi（圆周率，一般以π来表示）

e 数学常量 e，e即自然常数（自然常数）

String（字符串）

一般规定

字符串是 Python 中最常用的数据类型。我们可以使用引号( ' 或 " )来创建字符串

Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用

Python 访问子字符串，可以使用方括号 [] 来截取字符串，字符串的截取的语法格式：变量[头下标:尾下标]

字符串索引值从左以 0 为开始值，从右以-1 为开始值

字符串运算符

+ 字符串连接 a + b 输出结果： HelloPython

* 重复输出字符串 a*2 输出结果：HelloHello

[] 通过索引获取字符串中字符

[ : ] 截取字符串中的一部分，遵循左闭右开原则，str[0:2] 是不包含第 3 个字符的。

in 成员运算符 - 如果字符串中包含给定的字符返回 True

not in 成员运算符 - 如果字符串中不包含给定的字符返回 True

r/R 原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。

% 格式字符串

格式化符号

%c 格式化字符及其ASCII码

%s 格式化字符串

%d 格式化整数

%u 格式化无符号整型

%o 格式化无符号八进制数

%x 格式化无符号十六进制数

%X 格式化无符号十六进制数（大写）

%f 格式化浮点数字，可指定小数点后的精度

%e 用科学计数法格式化浮点数

%E 作用同%e，用科学计数法格式化浮点数

%g %f和%e的简写

%G %f 和 %E 的简写

%p 用十六进制数格式化变量的地址

格式化操作符辅助指令

* 定义宽度或者小数点精度

- 用做左对齐

+ 在正数前面显示加号( + )

<sp> 在正数前面显示空格

# 在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')

0 显示的数字前面填充'0'而不是默认的空格

% '%%'输出一个单一的'%'

(var) 映射变量(字典参数)

m.n. m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)

字符串相关函数

capitalize()

将字符串的第一个字符转换为大写

center(width, fillchar)

返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。

count(str, beg= 0,end=len(string))

返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数

expandtabs(tabsize=8)

把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。

find(str, beg=0, end=len(string))

检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1

index(str, beg=0, end=len(string))

跟find()方法一样，只不过如果str不在字符串中会报一个异常。

isalnum()

如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True，否则返回 False

isalpha()

如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False

isdigit()

如果字符串只包含数字则返回 True 否则返回 False..

islower()

如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False

isnumeric()

如果字符串中只包含数字字符，则返回 True，否则返回 False

isspace()

如果字符串中只包含空白，则返回 True，否则返回 False.

istitle()

如果字符串是标题化的(见 title())则返回 True，否则返回 False

isupper()

如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False

join(seq)

以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串

len(string)

返回字符串长度

ljust(width[, fillchar])

返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。

lower()

转换字符串中所有大写字符为小写.

lstrip()

截掉字符串左边的空格或指定字符。

maketrans()

创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标

max(str)

返回字符串 str 中最大的字母。

min(str)

返回字符串 str 中最小的字母。

replace(old, new [, max])

把 将字符串中的 old 替换成 new,如果 max 指定，则替换不超过 max 次。

rfind(str, beg=0,end=len(string))

类似于 find()函数，不过是从右边开始查找.

rindex( str, beg=0, end=len(string))

类似于 index()，不过是从右边开始.

rjust(width,[, fillchar])

返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串

rstrip()

删除字符串末尾的空格或指定字符。

split(str="", num=string.count(str))

以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串

splitlines([keepends])

按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。

startswith(substr, beg=0,end=len(string))

检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。

strip([chars])

在字符串上执行 lstrip()和 rstrip()

swapcase()

将字符串中大写转换为小写，小写转换为大写

title()

返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())

translate(table, deletechars="")

根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中

upper()

转换字符串中的小写字母为大写

zfill (width)

返回长度为 width 的字符串，原字符串右对齐，前面填充0

isdecimal()

检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。

Tuple（元组）

一般规定

Python 的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号( ) ，列表使用方括号 [ ]

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可

元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用

元组与字符串类似，下标索引从 0 开始，可以进行截取，组合

修改元组

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合

所谓元组的不可变指的是元组所指向的内存中的内容不可变

删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组

元组运算符

与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组

元组内置函数

len(tuple)

计算元组元素个数。

max(tuple)

返回元组中元素最大值。

min(tuple)

返回元组中元素最小值。

tuple(iterable)

将可迭代系列转换为元组。

List（列表）

一般规定

列表是最常用的 Python 数据类型，它可以作为一个方括号内的逗号分隔值出现

列表的数据项不需要具有相同的类型

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可

列表函数

len(list)

列表元素个数

max(list)

返回列表元素最大值

min(list)

返回列表元素最小值

list(seq)

将元组转换为列表

列表方法

list.append(obj)

在列表末尾添加新的对象

list.count(obj)

统计某个元素在列表中出现的次数

list.extend(seq)

在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

list.index(obj)

从列表中找出某个值第一个匹配项的索引位置

list.insert(index, obj)

将对象插入列表

list.pop([index=-1])

移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

list.remove(obj)

移除列表中某个值的第一个匹配项

list.reverse()

反向列表中元素

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

对原列表进行排序

list.clear()

清空列表

list.copy()

复制列表

Set（集合）

一般规定

集合（set）是一个无序的不重复元素序列

可以使用大括号 { } 或者 set() 函数创建集合

创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典

集合内置方法

add() 为集合添加元素

clear() 移除集合中的所有元素

copy() 拷贝一个集合

difference() 返回多个集合的差集

difference_update() 移除集合中的元素，该元素在指定的集合也存在。

discard() 删除集合中指定的元素

intersection() 返回集合的交集

intersection_update() 返回集合的交集。

isdisjoint() 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。

issubset() 判断指定集合是否为该方法参数集合的子集。

issuperset() 判断该方法的参数集合是否为指定集合的子集

pop() 随机移除元素

remove() 移除指定元素

symmetric_difference() 返回两个集合中不重复的元素集合。

symmetric_difference_update() 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。

union() 返回两个集合的并集

update() 给集合添加元素

Dictionary（字典）

一般规定

字典是另一种可变容器模型，且可存储任意类型对象

字典的每个键值 key=>value 对用冒号 : 分割

每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中

字典格式：d = {key1 : value1, key2 : value2, key3 : value3 }

键必须是唯一的，但值则不必

值可以取任何数据类型，但键必须是不可变的，如字符串，数字

不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住

键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行

字典内置函数&方法

len(dict)

计算字典元素个数，即键的总数。

str(dict)

输出字典，可以打印的字符串表示。

type(variable)

返回输入的变量类型，如果变量是字典就返回字典类型。

radiansdict.clear()

删除字典内所有元素

radiansdict.copy()

返回一个字典的浅复制

radiansdict.fromkeys()

创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值

radiansdict.get(key, default=None)

返回指定键的值，如果键不在字典中返回 default 设置的默认值

key in dict

如果键在字典dict里返回true，否则返回false

radiansdict.items()

以列表返回一个视图对象

radiansdict.keys()

返回一个视图对象

radiansdict.setdefault(key, default=None)

和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default

radiansdict.update(dict2)

把字典dict2的键/值对更新到dict里

radiansdict.values()

返回一个视图对象

pop(key[,default])

删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。

popitem()

随机返回并删除字典中的最后一对键和值。

条件与循环

条件控制

if 语句

Python 中用 elif 代替了 else if，所以if语句的关键字为：if – elif – else

if – elif – else语句中，elif和else均可缺失

if – elif – else语句可以嵌套使用

每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块

使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块

在Python中没有switch – case语句

循环语句

while 循环

while循环语句的关键字为：while – else

while循环语句中的else可以缺失

需要注意冒号和缩进。另外，在 Python 中没有 do..while 循环

CTRL+C 来退出当前的无限循环

如果while循环体中只有一条语句，可以将该语句与while写在同一行中

for 循环

for循环语句的关键字为：for – else

for循环语句中的else可以缺失

需要注意冒号和缩进

CTRL+C 来退出当前的无限循环

如果for循环体中只有一条语句，可以将该语句与for写在同一行中

break 语句

跳出 for 和 while 的循环体

如果从 for 或 while 循环中终止，任何对应的循环 else 块将不执行

continue 语句

跳过当前循环块中的剩余语句，然后继续进行下一轮循环

pass 语句

Python pass是空语句，是为了保持程序结构的完整性

pass 不做任何事情，一般用做占位语句

迭代器与生成器

迭代器

迭代器是一个可以记住遍历的位置的对象

字符串，列表或元组对象都可用于创建迭代器

迭代器有两个基本的方法：iter() 和 next()

生成器

使用了 yield 的函数被称为生成器（generator）

跟普通函数不同的是，生成器是一个返回迭代器的函数

在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行

调用一个生成器函数，返回的是一个迭代器对象

函数

定义一个函数

函数代码块以def 关键词开头，后接函数标识符名称和圆括号 ()

任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。

函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。

函数内容以冒号起始，并且缩进。

return [表达式]结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None

函数调用的参数

必需参数

必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样

关键字参数

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值

使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值

默认参数

调用函数时，如果没有传递参数，则会使用默认参数

不定长参数

可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数

加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数

参数带两个星号 **，参数会以字典的形式导入

其他参数

声明函数时，参数中星号 * 可以单独出现，单独出现星号 * 后的参数必须用关键字传入

Python3.8 新增了一个函数形参语法 / ，/之前的函数形参必须使用指定位置参数，不能使用关键字参数的形式

匿名函数

python 使用 lambda 来创建匿名函数

lambda 只是一个表达式，函数体比 def 简单很多。

lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。

lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。

虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率

return语句

return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式

不带参数值的return语句返回None

数据结构

列表

一般规定

列表是可变的，这是它区别于字符串和元组的最重要的特点

列表可以修改，而字符串和元组不能

列表的方法

list.append(x) 把一个元素添加到列表的结尾，相当于 a[len(a):] = [x]。

list.extend(L) 通过添加指定列表的所有元素来扩充列表，相当于 a[len(a):] = L。

list.insert(i, x) 在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引

list.remove(x) 删除列表中值为 x 的第一个元素。如果没有这样的元素，就会返回一个错误。

list.pop([i]) 从列表的指定位置移除元素，并将其返回。如果没有指定索引，a.pop()返回最后一个元素。元素随即从列表中被移除。

list.clear() 移除列表中的所有项，等于del a[:]

list.index(x) 返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误。

list.count(x) 返回 x 在列表中出现的次数。

list.sort() 对列表中的元素进行排序。

list.reverse() 倒排列表中的元素。

list.copy() 返回列表的浅复制，等于a[:]

将列表当做堆栈使用

列表方法使得列表可以很方便的作为一个堆栈来使用，堆栈作为特定的数据结构，最先进入的元素最后一个被释放（后进先出）

用 append() 方法可以把一个元素添加到堆栈顶。用不指定索引的 pop() 方法可以把一个元素从堆栈顶释放出来

将列表当作队列使用

也可以把列表当做队列用，只是在队列里第一加入的元素，第一个取出来

拿列表用作这样的目的效率不高。在列表的最后添加或者弹出元素速度快，然而在列表里插入或者从头部弹出速度却不快

列表推导式

列表推导式提供了从序列创建列表的简单途径

通常应用程序将一些操作应用于某个序列的每个元素，用其获得的结果作为生成新列表的元素，或者根据确定的判定条件创建子序列

每个列表推导式都在 for 之后跟一个表达式，然后有零到多个 for 或 if 子句。返回结果是一个根据表达从其后的 for 和 if 上下文环境中生成出来的列表

del语句

使用 del 语句可以从一个列表中依索引而不是值来删除一个元素

这与使用 pop() 返回一个值不同。可以用 del 语句从列表中删除一个切割，或清空整个列表

模块

Python3 模块

从 Python 解释器退出再进入，那么定义的所有的方法和变量就都消失了

Python 提供了一个办法，把这些定义存放在文件中，为一些脚本或者交互式的解释器实例使用，这个文件被称为模块

模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py

模块可以被别的程序引入，以使用该模块中的函数等功能。这也是使用 python 标准库的方法

import 语句

想使用 Python 源文件，只需在另一个源文件里执行 import 语句

当解释器遇到 import 语句，如果模块在当前的搜索路径就会被导入

搜索路径是一个解释器会先进行搜索的所有目录的列表，搜索路径被存储在sys模块中的path变量

一个模块只会被导入一次，不管你执行了多少次import

你打算经常使用一个函数，你可以把模块import之后把它赋给一个本地的名称

from … import 语句

Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中

from … import * 语句

把一个模块的所有内容全都导入到当前的命名空间

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

如果没有给定参数，那么 dir() 函数会罗列出当前定义的所有名称

标准模块

Python 本身带着一些标准的模块库

有些模块直接被构建在解析器里，这些虽然不是一些语言内置的功能，但是他却能很高效的使用，甚至是系统级调用也没问题

这些组件会根据不同的操作系统进行不同形式的配置，比如 winreg 这个模块就只会提供给 Windows 系统

有一个特别的模块 sys ，它内置在每一个 Python 解析器中

包

包是一种管理 Python 模块命名空间的形式，采用"点模块名称"

比如一个模块的名称是 A.B， 那么他表示一个包 A中的子模块 B

就好像使用模块的时候，你不用担心不同模块之间的全局变量相互影响一样，采用点模块名称这种形式也不用担心不同库之间的模块重名的情况

这样不同的作者都可以提供 NumPy 模块，或者是 Python 图形库

在导入一个包的时候，Python 会根据 sys.path 中的目录来寻找这个包中包含的子目录

目录只有包含一个叫做 __init__.py 的文件才会被认作是一个包，主要是为了避免一些滥俗的名字（比如叫做 string）不小心的影响搜索路径中的有效模块

用户可以每次只导入一个包里面的特定模块

当使用 from package import item 这种形式的时候，对应的 item 既可以是包里面的子模块（子包），或者包里面定义的其他名称，比如函数，类或者变量

如果使用形如 import item.subitem.subsubitem 这种导入形式，除了最后一项，都必须是包，而最后一项则可以是模块或者是包，但是不可以是类，函数或者变量的名字

从一个包中导入*

如果我们使用 from sound.effects import *，Python 会进入文件系统，找到这个包里面所有的子模块，然后一个一个的把它们都导入进来

这个方法在 Windows 平台上工作的就不是非常好，因为 Windows 是一个不区分大小写的系统

Windows 平台平台上，我们无法确定一个叫做 ECHO.py 的文件导入为模块是 echo 还是 Echo，或者是 ECHO

为了解决这个问题，我们只需要提供一个精确包的索引

导入语句遵循如下规则：如果包定义文件 __init__.py 存在一个叫做 __all__ 的列表变量，那么在使用 from package import * 的时候就把这个列表中的所有名字作为包内容导入

作为包的作者，可别忘了在更新包之后保证 __all__ 也更新了啊

如果 __all__ 真的没有定义，那么使用from sound.effects import *这种语法的时候，就不会导入包 sound.effects 里的任何子模块2，只是把包sound.effects和它里面定义的所有内容导入进来