57 KiB
07-Python数据类型
Python有五个常用数据类型
-
Numbers 数字
-
String 字符串
-
List 列表
-
Tuple 元组
-
Dictionary 字典
-
Set 集合 用来去重
其他分类方式 序列类型： 字符串、列表、元组、Unicode字符串，buffer对象，range对象 泛映射类型： 字典 集合： set()
一、数字
用于存储数值，是不变的数据类型，也就是说改变数字数据类型会分配一个新的对象。 当你指定一个值时，Number对象就会被创建
var1 = 1
var1,var2=1,10
使用del删除一些对象的引用
del var1[,var2[,var3[....,varN]]]]
例
del var
del var_a, var_b
Python常用数字类型
- int 有符号整型
- float 浮点型
除了 int 和 float，Python 还支持其他数字类型，例如 Decimal 或 Fraction。Python 还内置支持 复数，后缀 j 或 J 用于表示虚数（例如 3+5j ）。
数值类型实例
| int | float | complex |
|---|---|---|
| 10 | 0.0 | 3.14j |
| 100 | 15.20 | 45.j |
| -786 | -21.9 | 9.322e-36j |
| 080 | 32.3+e18 | .876j |
| -0490 | -90. | -.6545+0J |
| -0x260 | -32.54e100 | 3e+26J |
| 0x69 | 70.2-E12 | 4.53e-7j |
注：复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示，复数的实部a和虚部b都是浮点型
浮点型float
>>> f=12
>>> type(f)
<type 'int'>
>>> f=12.0
>>> type(f)
<type 'float'>
复数类型：应用于系统分析、信号分析、量子力学、相对论、应用数学、流体力学、碎形
>>> j=3.12
>>> type(j)
<type 'float'>
>>> j=3.12j //在原来数字基础上加j
>>> type(j)
<type 'complex'>
严格来讲，bool类型就是bool类型 bool(布尔型) 真 或 假 1 或 0 True 或 False
>>> a=1==1
>>> a
True
>>> a=bool(1==1)
>>> a
True
>>> a=bool(1=="1")
>>> a
False
>>> type(a)
<type 'bool'>
二、字符串
表示文本
字符串是immutable的
immutable -- 不可变对象
具有固定值的对象。不可变对象包括 数字、字符串和元组。这样的对象不能被改变。如果必须存储一个不同的值，则必须创建新的对象。它们在需要常量哈希值的地方起着重要作用，例如作为字典中的键。
创建字符串 使用引号创建字符串
var1 = 'Hello World!'
var2 = "Python fklinux"
var3 = '''Python fklinux'''
字符串切片
字符串取值顺序 1、从左到右索引默认0开始的，最大范围是字符串长度少1 2、从右到左索引默认-1开始的，最大范围是字符串开头
用'变量[头下标:尾下标:步长]'，就可截取相应的字符串，其中下标是从0开始算起，可以是正数或负数，下标可以为空表示取到头或尾。
s = 'ilovepython'
s[1:5]的结果是love
当使用以冒号分隔的字符串，返回一个新对象，结果包含以这对偏移标识的连续内容，
左边的开始包含下边界，取到的最大范围不包括上边界。
#!/usr/bin/python3.8
str = 'Hello World!'
print (str)
print (str[:])
print (str[::]) # 以上3种都是输出完整字符串
print (str[::1]) # 最后面的数字是步长，步长为1
print (str[::2]) # 步长为2
print (str[0]) # 输出字符串中的第一个字符
print (str[-1]) # 输出倒数第1个字符
print (str[-2]) # 输出倒数第2个字符
print (str[-3:-1]) # 输出倒数第3和第2个字符
print (str[-1:-3]) # 这样会有问题，因为默认是从做往右取值，可以在最后指定负值的步长表示从右往左取值
print (str[-1:-3:-1])
print (str[2:5]) # 输出字符串中第三个至第五个之间的字符串
print (str[2:]) # 输出从第三个字符开始的字符串
print (str * 2) # 输出字符串两次
print (str + "TEST") # 输出连接的字符串
转义字符
需要在字符中使用特殊字符时，用反斜杠\转义字符。
| 转义字符 | 描述 |
|---|---|
| \在行尾时 | 续行符 |
| \\ | 反斜杠符号 |
| \a | 响铃 |
| \b | 退格(Backspace) |
| \n | 换行 |
| \v | 纵向制表符 |
| \t | 横向制表符 |
| \r | 回车 |
| \f | 换页 |
| \oyy | 八进制数，yy代表的字符，例如：\o12代表换行 |
| \xyy | 十六进制数，yy代表的字符，例如：\x0a代表换行 |
| \other | 其它的字符以普通格式输出 |
原始字符串
# 如果不想让转义字符生效，只想显示字符串原来的意思，用r定义原始字符串, r和R效果相同
print(r'\t\r')
实际输出为："\t\r"
字符串运算符 下表实例变量a值为字符串"Hello"，b变量值为"Python"：
- + 字符串连接 a + b 输出结果： HelloPython
- * 重复输出字符串 a*2 输出结果：HelloHello
- 支持成员运算符 in 和 not int
相邻的两个或多个 字符串字面值 （引号标注的字符）会自动合并：
>>> 'Py' 'thon'
'Python'
拼接分隔开的长字符串时，这个功能特别实用：
>>> text = ('Put several strings within parentheses '
... 'to have them joined together.')
>>> text
'Put several strings within parentheses to have them joined together.'
这项功能只能用于两个字面值，不能用于变量或表达式：
>>> prefix = 'Py'
>>> prefix 'thon' # can't concatenate a variable and a string literal
File "<stdin>", line 1
prefix 'thon'
^^^^^^
SyntaxError: invalid syntax
>>> ('un' * 3) 'ium'
File "<stdin>", line 1
('un' * 3) 'ium'
^^^^^
SyntaxError: invalid syntax
合并多个变量，或合并变量与字面值，要用 +：
>>> prefix + 'thon'
'Python'
+可以用于字符串更新 你可以对已存在的字符串进行修改，并赋值给另一个变量
#!/usr/bin/python3.8
var1 = 'Hello World!'
print （"更新字符串 :- ", var1[:6] + 'wing!'）
结果：
更新字符串 :- Hello wing!
#!/usr/bin/python3.8
a = "Hello"
b = "Python"
print ("a + b 输出结果：", a + b)
print ("a * 2 输出结果：", a * 2 )
print ("a[1] 输出结果：", a[1] )
print ( "a[1:4] 输出结果：", a[1:4] )
if( "H" in a) :
print ("H 在变量 a 中" )
else :
print("H 不在变量 a 中" )
if( "M" not in a) :
print("M 不在变量 a 中" )
else :
print("M 在变量 a 中")
print(r'\n')
print(R'\n')
结果：
a + b 输出结果： HelloPython
a * 2 输出结果： HelloHello
a[1] 输出结果： e
a[1:4] 输出结果： ell
H 在变量 a 中
M 不在变量 a 中
\n
\n
格式化打印
python2格式化方法：使用%
#!/usr/bin/python
print("My name is %s and ===========weight\t\n is %d kg!" % ('Zara', 21))
%s 字符串
%d 整数
%f 浮点数
结果：
My name is Zara and weight is 21 kg!
注：Bash格式化打印语法
# printf "...%d %f %s" 5 6.3 "hello"
python3格式化方法：主打format
In [4]: print( '{0},{1}'.format('hello',2) )
hello,2
In [88]: print('{1}----{0}'.format('hello',2))
2----hello
In [5]: print('{},{},{}'.format('hello',2,3))
hello,2,3
In [6]: print ( '{name},{gender},{age}' . format (age = 32 ,gender = 'male' ,name = 'liying' ))
liying,male,32
# 格式限定符
# 它有着丰富的的"格式限定符"（语法是{}中带:号），比如：
# 填充与对齐，填充常跟对齐一起使用
# ^、<、>分别是居中、左对齐、右对齐，后面带宽度
# :号后面带填充的字符，只能是一个字符，不指定默认是用空格填充
# 8是字符串宽度
In [9]: print ( '{:>8}' . format ( 'liying' )) # 没有指定填充字符，默认用空格填充
liying
In [9]: print ( '{1:>8}' . format ( 'liying' )) # 没有指定填充字符，默认用空格填充
liying
# 1代表的是索引位置
In [10]: print ( '{:0>8}' . format ( 'liying' )) # 用0填充
00liying
In [11]: print ( '{:a>8}' . format ( 'liying' )) # 用字符a填充
aaliying
# 精度与类型f，精度常跟类型f一起使用
In [13]: print ( '{:.2f}' . format ( 31.31412 )) # 指定小数点位数为2位
31.31
In [101]: print('{:>10.3f}'.format(3.1415926)) # >10 指定宽度为10且右对齐
3.142
# 进制，b、d、o、x分别是二进制、十进制、八进制、十六进制
In [15]: print ( '{:b}' . format ( 15 ))
1111
In [16]: print ( '{:d}' . format ( 15 ))
15
In [17]: print ( '{:o}' . format ( 15 ))
17
In [18]: print ( '{:x}' . format ( 15 ))
f
# 用逗号做金额的千位分隔符
In [22]: print ( '{:,}' . format ( 123456789 ))
123,456,789
python3.0 print函数新语法，可以让print附带参数
>>> print("a",sep=':')
a:b
In [109]: print("abc","def",sep="|",end='')
abc|def
separater end
三引号（triple quotes） 可以将复杂的字符串进行复制,允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。
>>> hi ='''hi there'''
>>> hi ='''hi\nthere'''
字符串方法
| 方法 | 描述 |
|---|---|
| *string.find(str, beg=0, end=len(string)) | 检测 str 是否包含在 string 中，如果是 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是则返回开始的索引值，否则返回-1 |
| *string.index(str,beg=0,end=len(string)) | 跟find()方法一样，只不过如果str不在 string中会报一个异常. |
| *string.isalnum() | 如果 string 至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False |
| *string.isalpha() | 如果 string 至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False |
| *string.isdigit() | 如果 string 只包含数字则返回 True 否则返回 False. |
| *string.islower() | 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False |
| *string.isnumeric() | 如果 string 中只包含数字字符，则返回 True，否则返回 False |
| *string.isspace() | 如果 string 中只包含空格，则返回 True，否则返回 False. |
| *string.istitle() | 如果 string 是标题化的(见 title())则返回 True，否则返回 False |
| *string.isupper() | 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False |
| *string.join(seq) | 以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 |
| *string.ljust(width) | 返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串 |
| *string.lower() | 转换 string 中所有大写字符为小写. |
| *string.lstrip() | 截掉 string 左边的空格 |
| *string.maketrans(intab, outtab]) | maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。 |
| *string.partition(str) | 有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把字符串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string. |
| *string.replace(str1,str2,num=string.count(str1)) | 把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次. |
| *string.rfind(str, beg=0,end=len(string) ) | 类似于 find()函数，不过是从右边开始查找. |
| *string.rindex( str, beg=0,end=len(string)) | 类似于 index()，不过是从右边开始. |
| *string.rjust(width) | 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串 |
| *string.rpartition(str) | 类似于 partition()函数,不过是从右边开始查找. |
| *string.rstrip() | 删除 string 字符串末尾的空格. |
| *string.split(str="", num=string.count(str)) | 以 str 为分隔符切片 string，如果 num有指定值，则仅分隔 num 个子字符串 |
| *string.splitlines(num=string.count('\n')) | 按照行分隔，返回一个包含各行作为元素的列表，如果 num 指定则仅切片 num 个行. |
| *string.startswith(obj, beg=0,end=len(string)) | 检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查. |
| *string.strip([obj]) | 在 string 上执行 lstrip()和 rstrip() |
| *string.swapcase() | 翻转 string 中的大小写 |
| *string.title() | 返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle()) |
| *string.translate(str, del="") | 根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 del 参数中 |
| *string.upper() | 转换 string 中的小写字母为大写 |
| *string.zfill(width) | 返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0 |
| string.isdecimal() | isdecimal()方法检查字符串是否只包含十进制字符。这种方法只存在于unicode对象。 |
# 把字符串的第一个字符大写
In [11]: a='hello world'
In [14]: a.capitalize()
Out[14]: 'Hello world'
# 字符串的每个单词开头字符大写
In [7]: import string
In [8]: string.capwords("hello world")
Out[9]: 'Hello World'
# 返回一个原字符串居中，并使用空格填充至长度为 width 的新字符串，这里的宽度为20
In [20]: a.center(20)
Out[20]: ' hello world '
string.count(str, beg=0, end=len(string))
返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
beg开始的位置
end结束的位置 ，不包括结束位置
In [21]: a.count('l')
Out[21]: 3
In [22]: a.count('l',3)
Out[22]: 2
In [23]: a.count('l',3,9)
Out[23]: 1
In [24]: a.count('l',3,10)
Out[24]: 2
string.endswith(obj, beg=0, end=len(string))
检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
beg开始的位置
end结束的位置
In [25]: a.endswith('ld')
Out[25]: True
In [28]: a.endswith('o',2,5)
Out[28]: True
In [29]: a.endswith('o',2,4)
Out[29]: False
string.expandtabs(tabsize=8)
把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。
注意：这里的8最后转换后会是7个空格，如果指定成3会是2个空格
In [34]: a='hello\tworld'
In [35]: print(a)
hello world
In [36]: a.expandtabs()
Out[36]: 'hello world'
使用方法举例：
In [9]: hero = "i'm wing"
In [10]: hero.title()
Out[10]: "I'M Wing"
也可以直接使用模块实现各种字符串方法：
In [13]: import string
In [14]: hero="i am wing"
In [15]: string.capwords(hero)
Out[15]: 'I Am Wing'
大小写转化
#vim upper_lower_string.py
#!/usr/bin/python3.8
string = "Hello Wing"
print(string.lower())
print(string.upper())
结果如下
# python upper_lower_string.py
hello wing
HELLO WING
去除空白
#!/usr/bin/python3.8
string = "\nhello,this is a strip test\n"
string_1 = "<hello,this is a strip test>"
a="-"
for i in range(4):
print (a*40)
if i == 0:
print ("'string'变量所存储字符串的原始打印格式为:")
print (string)
elif i == 1:
print ("'string'使用字符串方法'lstrip'后去掉了字符串前面的空白，打印格式为:")
print (string.lstrip())
elif i == 2:
print ("'string'使用字符串方法'rstrip'后去掉了字符串后面的空白，打印格式为:")
print (string.rstrip())
else:
print ("'string'使用字符串方法'strip'后去掉了字符串前面和后面的空白，打印格式为:")
print (string.strip())
else:
print (a*40)
print ('注:在lstrip()、rstrip()、strip()没有参数的情况下会删除空白,"tab、空格、换行、回车"都属于"空白"')
for i in range(4):
print (a*40)
if i == 0:
print ("'string_1'变量所存储字符串的原始打印格式为:")
print (string_1)
elif i == 1:
print ('''"string_1"使用字符串方法lstrip("<")后去掉了字符串前面的"<"，打印格式为:''')
print (string_1.lstrip("<"))
elif i == 2:
print ( '''"string_1"使用字符串方法rstrip(">")后去掉了字符串后面的">"，打印格式为:''')
print (string_1.rstrip(">"))
else:
print ('''"string_1"使用字符串方法strip("<").strip(">")后去掉了字符串前面和后面的空白，打印格式为:''')
print ( string_1.strip("<").strip(">"))
else:
print ( a*40)
print ('注:也可以添加参数作为被删除的字符串，也就是说可以利用这3中方法删除原始字符串前后的任意指定字符串')
分割字符串
split()用来分割字符串
splitlines()用来按行分割字符串
#!/usr/bin/env python3.8
string = "a-b-c"
string1 = "a---b---c"
string2 = "hello,this is my first using of split,are you ok?yes,I am ok"
print(string.split("-")) #可以指定单个分割符
print( string1.split("---")) #也可以指定多个字符当作分割符
print(string1.split("--"))
print(string2.split(",",2)) #还可以指定分割符的最大使用次数,这里是只使用两次
string3 = "This is a multiline text"
print (string3.split()) #不加参数，默认将空格当作分割符
string4 = '''This is
a multiline piece of
text'''
print (string4.split()) #如果是多行文本，默认也是按空格分割
print (string4.splitlines()) #如果想按行分割，可以使用splitlines()方法
Python的str类有split方法，但是这个split方法只能根据指定的某个字符分隔字符串，如果要同时指定多个字符来分隔字符串，该怎么办呢？幸运的是python的re模块中提供的split方法可以用来做这件事情
import re
re.split('; |, ',str)
例如：
>>> a='Beautiful, is; better*than\nugly'
>>> import re
>>> re.split('; |, |\*|\n',a)
['Beautiful', 'is', 'better', 'than', 'ugly']
拼接字符串
方法很多，其中join()方法性能最好，只是注意join处理的是列表
#!/usr/bin/env python3.8
somelist = ['one','two','three','four']
print (','.join(somelist) ) #使用方法前面指定的分割符连接列表元素
print (', '.join(somelist))
print ('\t'.join(somelist))
print (''.join(somelist) )
# 注意:join()是字符串方法，如果你给他的参数是一串数字会报错！
numlist = [1,2,3,4,5]
# print ','.join(numlist) //这种方式直接会报错
# 可以使用下面的方式转换数字为字符串
print (','.join([str(i) for i in numlist])) # 列表表达式
print (','.join(str(i) for i in numlist))
取26个英文字母
In [9]: string.ascii_lowercase
Out[9]: 'abcdefghijklmnopqrstuvwxyz'
中文内容处理
注：python3不用处理即可使用
如果文件内容是中文： read方法读出来之后是16进制方式，需要用print打印
如果使用readlines读文件，文件内容会被放到列表里，想显示中文必须使用for循环print列表元素才能显示中文 比如：
[root@wing python]# cat a.txt
中文
la
In [62]: f=open('a.txt','r')
In [63]: content=f.readlines()
In [64]: content
Out[64]: ['中文\n']
In [65]: for i in content:
....: print (i)
....:
中文
替换字符
str.maketrans 生成映射
str.translate 替换字符
>>> str="abcdefg"
>>> str.translate(str.maketrans("abcd","1234"))
'1234efg'
shell相关字符串处理
用sed作文本的大小写替换
# sed 's/[a-z]/\u&/g' /etc/passwd
# sed 's/[A-Z]/\l&/g' a
删除文件倒数第二行：
# sed '{N;$!P;D}' a.txt
翻转文本内容：
# tac a.txt
大小写替换
# echo HEllo Word | tr a-z A-Z
HELLO WORLD
使用shell命令翻转字符串
# a=abcdefg
# echo $a | rev
gfedcba
三、列表
打印一个产品信息的界面
欢迎来到千锋饮料售卖机
产品列表
名字 剩余量 单价
购买
上货
序列
序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推,Python已经内置确定序列的长度以及确定最大和最小的元素的方法。Python有6个序列的内置类型，最常见的是列表和元组。
序列操作包括 索引，切片，加，乘，检查成员
列表
与 immutable 字符串不同, 列表是 mutable 类型，其内容可以改变
支持字符，数字，字符串甚至可以包含列表（嵌套），他的数据项不需要具有相同的类型
创建列表 以逗号分隔的不同的数据项使用方括号括起来即可。 例如：
list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]
list4 = [] #创建空列表
list5 = list() #创建空列表
列表截取 语法：变量[头下标:尾下标] 从左到右索引默认0开始的，从右到左索引默认-1开始，下标可以为空，表示取到头或尾。
例1：
#!/usr/bin/python3.8
list1 = ['physics', 'chemistry', 1997, 2000];
list2 = [1, 2, 3, 4, 5, 6, 7 ];
print("list1[0]: ", list1[0])
print("list2[1:5]: ", list2[1:5])
以上实例输出结果：
list1[0]: physics
list2[1:5]: [2, 3, 4, 5]
例2：
L = ['spam', 'Spam', 'SPAM!']
操作：
| Python 表达式 | 结果 | 描述 |
|---|---|---|
| L[2] | 'SPAM!' | 读取列表中第三个元素 |
| L[-2] | 'Spam' | 读取列表中倒数第二个元素 |
| L[1:] | ['Spam', 'SPAM!'] | 从第二个元素开始截取列表 |
更新列表 可以对列表的数据项进行修改或更新，也可以使用append()方法来添加列表项 例如：
#!/usr/bin/python
list = ['physics', 'chemistry', 1997, 2000];
print ("Value available at index 2 : ")
print (list[2])
list[2] = 2001 #更新列表元素
print ("New value available at index 2 : ")
print (list[2])
以上实例输出结果：
Value available at index 2 :
1997
New value available at index 2 :
2001
删除列表元素 使用 del 语句来删除列表的的元素 例
#!/usr/bin/python3.8
list1 = ['physics', 'chemistry', 1997, 2000]
print (list1)
del list1[2]
print ("After deleting value at index 2 : ")
print (list1)
以上实例输出结果：
['physics', 'chemistry', 1997, 2000]
After deleting value at index 2 :
['physics', 'chemistry', 2000]
列表操作符 + 号用于组合列表 * 号用于重复列表 in 判断元素是否在列表中 not in 例：
| Python 表达式 | 结果 | 描述 |
|---|---|---|
| [1, 2, 3] + [4, 5, 6] | [1, 2, 3, 4, 5, 6] | 组合 |
| ['Hi!'] * 4 | ['Hi!', 'Hi!', 'Hi!', 'Hi!'] | 重复 |
| 3 in [1, 2, 3] | True | 元素是否存在于列表中 |
| for x in [1, 2, 3]: print x, | 1 2 3 | 迭代 |
成员运算符可以使用for完成对列表的迭代，要按索引迭代序列，可以组合使用 range() 和 len()：
>>> a = ['Mary', 'had', 'a', 'little', 'lamb']
>>> for i in range(len(a)):
... print(i, a[i])
0 Mary
1 had
2 a
3 little
4 lamb
或者自定义计数器
iterable=['a','b','c']
i = 0
for item in iterable:
print(i, item)
i += 1
不过大多数情况下 enumerate() 函数很方便
内置函数enumrate() 为一个可迭代的对象添加序号，可迭代的对象你可以理解成能用for循环的就是可迭代的。 默认是编号是从0开始，可以设置从1开始
iterable=['a','b','c']
for i, item in enumerate(iterable):
print(i, item)
函数接收一个参数：默认是从0开始
>>> list(enumerate('abc'))
(0, 'a')
(1, 'b')
(2, 'c')
函数接收第二个参数指定开始的数字：
>>> enumerate('abc', 1)
(1, 'a')
(2, 'b')
(3, 'c')
实例：
#cat test.py
li = ["手机", "电脑", '鼠标垫', '游艇']
for k, i in enumerate(li,1): # 这里的1表示序号从1开始
print(k,i)
执行结果如下：
1 手机
2 电脑
3 鼠标垫
4 游艇
逆向循环
为了逆向对序列进行循环，可以求出欲循环的正向序列，然后调用 reversed() 函数：
>>> for i in reversed(range(1, 10, 2)):
... print(i)
9
7
5
3
1
排序
按顺序循环序列，可以用 sorted() 函数，在不改动原序列的基础上，返回一个新的序列：
>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for i in sorted(basket):
... print(i)
apple
apple
banana
orange
orange
pear
列表方法
| 方法 |
|---|
| list.append(obj) 在列表末尾添加新的对象 |
| list.count(obj) 统计某个元素在列表中出现的次数 |
| list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） |
| list.index(obj) 从列表中找出某个值第一个匹配项的索引位置 |
| list.insert(index, obj) 将对象插入列表 |
| list.pop(obj=list[-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值 |
| list.remove(obj) 移除列表中某个值的第一个匹配项 |
| list.reverse() 反向列表中元素 |
| list.sort([func]) 对原列表进行排序 |
operator.eq(a,b) 判断两个对象是否相等 ,使用之前import operator
给列表插入数据的其他方法 把被切片出来的数据替换成后面的数据
In [216]: a=['a', 'b', 'c', 'd', 'e']
In [215]: a[1:4]
Out[215]: ['b', 'c', 'd']
In [217]: a[1:4]=[1]
In [218]: a
Out[218]: ['a', 1, 'e']
在索引为1的数据之前添加后面的数据
In [224]: a[1:1]=[5]
In [225]: a
Out[225]: ['a', 5, 'b', 'c', 'd', 'e']
批量替换
In [4]: a=[12, 3, 8, 8, 4, 3]
In [5]: a[2:]=[1,1,1,]
In [6]: a
Out[6]: [12, 3, 1, 1, 1]
另类删除：
In [7]: a=[12,3,4,3]
In [8]: a[2:]=[]
In [9]: a
Out[9]: [12, 3]
列表中嵌套列表：
>>> a=[1,2,['a','b']]
>>> a
[1, 2, ['a', 'b']]
>>> a[2]
['a', 'b']
>>> a[2][0]
'a'
>>> a[2][1]
'b'
判断一个对象是否是一个列表(tuple,str,dict)：
>>> test=[1,2,3]
>>> isinstance(test,list)
True
变量解包：(可以用元组，列表，字典解包)
>>> l1,l2 = [[1,'x','y'],[2,'z','r']]
>>> print(l1)
[1, 'x', 'y']
>>> print(l2)
[2, 'z', 'r']
列表解包
In [59]: li=[1,2,3,4]
In [60]: print(*li)
1 2 3 4
如果不采用解包的方法：
In [18]: a=[1, 2, 3, 4]
In [19]: for i in a:
...: print(i,end=" ")
...:
1 2 3 4
slice() 函数 实现切片对象，主要用在切片操作函数里的参数传递
语法： class slice(stop) class slice(start, stop[, step])
参数说明： start -- 起始位置 stop -- 结束位置 step -- 间距
返回值 返回一个切片对象。
实例
>>> myslice = slice(5) # 设置截取5个元素的切片
>>> myslice
slice(None, 5, None)
>>> arr = range(10)
>>> arr
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> arr[myslice] # 截取 5 个元素
[0, 1, 2, 3, 4]
浅拷贝 用等号将一个列表赋值给多个变量时，使用其中任意一个变量对列表的操作，结果都会同步到其他变量的值。
In [335]: a=b=[1,2,3]
In [336]: a
Out[336]: [1, 2, 3]
In [337]: b
Out[337]: [1, 2, 3]
In [338]: a[1]=8
In [339]: a
Out[339]: [1, 8, 3]
In [340]: b
Out[340]: [1, 8, 3]
这种现象很像前面学的变量赋值，变量和列表本身之间的关系称作：变量对列表对象的引用并没有创建一个新的列表。
In [110]: base_count = ['name',['money',100.00]]
In [111]: xmen = list(base_count)
In [112]: xpan = base_count.copy() # 浅复制
In [113]: xmen[1][1] = 20.00
In [114]: xpan
Out[114]: ['name', ['money', 20.0]]
深拷贝
In [115]: import copy
In [116]: xmen_new = copy.deepcopy(base_count) # 深复制
In [117]: xpan_new = copy.deepcopy(base_count)
In [118]: xpan_new[1][1] = 50.00
In [119]: xmen_new
Out[119]: ['name', ['money', 20.0]]
In [120]: xpan_new
Out[120]: ['name', ['money', 50.0]]
pprint和pformat pprint模块中使用的格式化可以按照一种格式正确的显示数据, 这种格式即可被解析器解析, 又很易读.
比如下面sys.path默认输出为： 注意：ipython内自带优化看不出效果，需用自带python测试
>>> import sys,pprint
>>> sys.path
['', '/usr/lib/python2.7/site-packages/TimeConvert-1.4.0-py2.7.egg', '/usr/lib/
python2.7/site-packages/tzlocal-1.3-py2.7.egg', '/usr/lib64/python27.zip', '/usr/
lib64/python2.7', '/usr/lib64/python2.7/plat-linux2', '/usr/lib64/python2.7/lib-tk', '/
usr/lib64/python2.7/lib-old', '/usr/lib64/python2.7/lib-dynload', '/usr/lib64/
python2.7/site-packages', '/usr/lib64/python2.7/site-packages/gtk-2.0', '/usr/lib/
python2.7/site-packages']
用pprint方法会更易读
>>> pprint.pprint(sys.path)
['',
'/usr/lib/python2.7/site-packages/TimeConvert-1.4.0-py2.7.egg',
'/usr/lib/python2.7/site-packages/tzlocal-1.3-py2.7.egg',
'/usr/lib64/python27.zip',
'/usr/lib64/python2.7',
'/usr/lib64/python2.7/plat-linux2',
'/usr/lib64/python2.7/lib-tk',
'/usr/lib64/python2.7/lib-old',
'/usr/lib64/python2.7/lib-dynload',
'/usr/lib64/python2.7/site-packages',
'/usr/lib64/python2.7/site-packages/gtk-2.0',
'/usr/lib/python2.7/site-packages']
如果仅仅想获得数据而不是输出数据也可以用pformat
import sys
import pprint
str = pprint.pformat(sys.path)
print(str)
运行结果同上
四、元组
导语 元组介绍 访问元组 修改元组 删除元组 元组运算符 元组索引、截取 无关闭分隔符 元组内置函数
元组介绍 使用元组的理由
1. 占用内存空间小
2. 元组内的值不会被意外的修改
3. 可作为字典的键
4. 函数的参数是以元组形式传递的
5. 命名元组有时候可以代替类的对象(面向对象的时候讲)
与列表类似，不同之处在于元组的元素不能修改。 元组使用小括号，列表使用方括号。 元组的创建，只需要在括号中添加元素，并使用逗号隔开即可。
实例
tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d" # 任意无符号的对象，以逗号隔开，默认为元组
var1,var2,var3,var4=tup3 # 元组解包(unpack),把元组中的元素分别赋值给前面的变量
创建空元组
tup1 = ()
元组中只包含一个元素时，需要在元素后面添加逗号，不加逗号会怎样，用type看一下类型
tup1 = (50,)
访问元组 元组与字符串类似，下标索引从0开始，可以进行截取，组合等 元组可以使用下标索引来访问元组中的值 实例:
#!/usr/bin/python3.8
tup1 = ('physics', 'chemistry', 1997, 2000);
tup2 = (1, 2, 3, 4, 5, 6, 7 );
print("tup1[0]: ", tup1[0])
print("tup2[1:5]: ", tup2[1:5])
输出结果：
tup1[0]: physics
tup2[1:5]: (2, 3, 4, 5)
修改元组 元组中的元素值不允许修改，但可以对元组进行连接组合 实例:
#!/usr/bin/python3.8
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
# 以下修改元组元素操作是非法的。
# tup1[0] = 100;
# 创建一个新的元组
tup3 = tup1 + tup2
print(tup3)
输出结果：
(12, 34.56, 'abc', 'xyz')
删除元组 元组中的元素值是不允许删除的，但可使用del语句删除整个元组 实例:
#!/usr/bin/python3.8
tup = ('physics', 'chemistry', 1997, 2000)
print (tup)
del tup
print ("After deleting tup : ")
print (tup)
# 以上实例元组被删除后，输出变量会有异常信息
输出结果：
('physics', 'chemistry', 1997, 2000)
After deleting tup :
Traceback (most recent call last):
File "test.py", line 9, in <module>
print tup;
NameError: name 'tup' is not defined
元组解包
In [199]: one,two = 1,2
In [200]: one,two = two,one
In [201]: one
Out[201]: 2
In [202]: two
Out[202]: 1
五、字典
字典是映射类型数据结构，且可存储任意类型对象，是除列表以外python之中最灵活的内置数据结构类型。查找速度非常快，一个元素和10W个元素没有什么区别
• 在字典存放的每个元素都是以一对儿键值对。 • 在 Python 中字典通常被称为dict，键称为 key，值称为 value • 字典中不可以存在相同的 key，但是 value 可以。
字典创建 字典当中的元素是通过键来存取的，每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中。 格式：d = {key1 : value1, key2 : value2 }
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
dict1 = { 'abc': 456 }
dict2 = { 'abc': 123, 98.6: 37 }
dict3 = {} # 空字典
copy()创建字典
a={"a":"b","aa":"bb"}
b=a.copy()
a=
fromkeys()创建字典 语法 dict.fromkeys(seq[, value]) seq -- 字典键值列表 value -- 可选参数, 设置键序列（seq）的值
以序列 seq 中元素做字典的键，序列可以是字符串、列表、元组。value 为字典所有键对应的初始值。
实例
#!/usr/bin/python3.8
seq = ('Google', 'Runoob', 'Taobao')
dict = dict.fromkeys(seq)
# dict = {}.fromkeys(seq) 也可以把dict写成{}
print ("新字典为 : %s" % str(dict))
dict = dict.fromkeys(seq, 10)
print ("新字典为 : %s" % str(dict))
输出结果：
新字典为 : {'Google': None, 'Taobao': None, 'Runoob': None}
新字典为 : {'Google': 10, 'Taobao': 10, 'Runoob': 10}
dict()创建字典 dict() 接收一个序列类型的参数，这个序列类型中的每个元素必须是成对出现
>>>dict() # 创建空字典
{}
>>> dict(a='a', b='b', t='t') # 传入关键字
{'a': 'a', 'b': 'b', 't': 't'}
>>> dict([('one', 1), ('two', 2), ('three', 3)]) # 可迭代对象方式来构造字典
{'three': 3, 'two': 2, 'one': 1} # 字典的无序特性:列表是有序的对象结合，字典是无序的对象集合
zip()创建字典 利用 zip() 函数可以对具有相同数量的元素的序列进行配对，返回的值不是元组，也不是列表，而是一个整合在一起的可迭代变量
In [36]: english = 'Monday','Tuesday','Thursday',
In [37]: chineses = '星期一','星期二','星期三'
In [38]: zip(english,chineses)
Out[38]: <zip at 0x1052c7f08>
In [39]: type(zip(english,chineses))
Out[39]: zip
In [27]: for key,value in zip(english,chineses):
...: print(key,value)
Monday 星期一
Tuesday 星期二
Thursday 星期三
In [41]: list((english,chineses)) #转换成列表,这个的结果不能直接用dict转换
Out[41]: [('Monday', 'Tuesday', 'Thursday'), ('星期一', '星期二', '星期三')]
In [40]: dict(zip(english,chineses)) # 映射函数方式来构造字典
Out[40]: {'Monday': '星期一', 'Thursday': '星期三', 'Tuesday': '星期二'}
>>> dict(zip(['one', 'two', 'three'], [1, 2, 3])) # 映射函数方式来构造字典
{'three': 3, 'two': 2, 'one': 1}
==注意：zip() 函数会在最短序列迭代（循环）完毕时停止==
key的唯一性和不可变性 键 必须是唯一且不可变的，如果同一个键被赋值两次，后一个值会被记住,值 则可以取任何数据类型
下面的字典最后长什么样子？
# python认为：True==1==1.0
d= {True:'yes',1:'no',1.0:'maybe'}
print(d)
Python字典中的键 是否相同（只有相同才会覆盖）取决于两个条件：
1、两者的值是否相等（比较__eq__()方法)
2、比较两者的哈希值是否相同（比较___hash__()hash方法）
In [69]: (hash(True), hash(1), hash(1.0))
(1, 1, 1)
Python 内部用一个哈希表来维护字典中的 key 到 value 的映射关系 所以 key 必须是可哈希的： 判断一个对象是否可哈希用hash()函数，返回一个整数，就是可哈希，反之会抛出 TypeError 异常
python中可变数据类型有： list dict set
python不可变数据类型： 布尔型 整型 浮点型 元组 字符串
例如
In [10]: li = [1,2,3,4] # 列表为可变类型
In [11]: dic = {'name':'wing','age':28,li:8}
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-11-adb0f90c4fca> in <module>()
----> 1 dic = {'name':'wing','age':28,li:gender}
TypeError: unhashable type: 'list'
获取字典所有的 key dict_obj.keys()
dic01={'a':1,'b':2}
print(dic01.keys())
访问字典里的值有三种方式： dict_obj['key'] # key 必须存在，不存在，抛出异常
dict_obj.get('key') # key 存在获取到 value，不存在，返回 None
dict_obj.get('key', 'value') # key 不存在，返回指定的 value
#!/usr/bin/python3.8
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
print ("dict['Name']: ", dict['Name'])
print ("dict['Age']: ", dict['Age'])
输出结果：
dict['Name']: Zara
dict['Age']: 7
获取字典所有的 value dict_obj.values()
一次性获取字典的 key 和 value dict_obj.items()
两种遍历字典方法： 第一种：
for k,v in dict.items():
print(k,v)
第二种：高效
for key in dict:
print(key,dict[key])
修改字典 向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对
#!/usr/bin/python3.8
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
dict['Age'] = 8 # update existing entry
dict['School'] = "DPS School" # Add new entry
print ("dict['Age']: ", dict['Age'])
print("dict['School']: ", dict['School'])
输出结果：
dict['Age']: 8
dict['School']: DPS School
删除字典元素:
del dict['Name'] # 删除键是'Name'的条目
dict.clear() # 清空字典所有条目
del dict # 删除字典
pop() 截取字典key的value，源字典key会被删除
In [361]: dic6 = {'b': 2, 'c': '3', 'd': 'new key', 'li': [1, 3, 5]}
In [362]: dic6
Out[362]: {'b': 2, 'c': '3', 'd': 'new key', 'li': [1, 3, 5]}
In [363]: li = dic6.pop('li')
In [364]: li # 劫取出来的value
Out[364]: [1, 3, 5]
In [365]: dic6
Out[365]: {'b': 2, 'c': '3', 'd': 'new key'}
字典相关内置函数 dict.setdefault(key, default=None) 和get()类似, 但如果key在字典中不存在，将会添加键并将值设为default，不管添加成功与否，都返回该key对应的value 也是给字典添加元素的一种方式
In [85]: f
Out[85]: {1: '农夫山泉', 2: '矿泉水', 3: '可乐'}
In [83]: f.setdefault(8,"雪碧")
Out[83]: '雪碧'
dict.update(dict2) 把字典dict2的键/值对更新到dict里
字典变量解包
>>> d3,d4 = {'x':32,'y':80}
>>> print(d3)
x
>>> print(d4)
y
应用场景
host_info = []
host_info.append(
{'192.168.1.11':
{'cpu':['Intel(R) Core(TM) i5-5350U CPU @ 1.80GHz',4,1],
'memory':['16','4','2'],
'disk':['1T','2T']
}
}
)
jso
host_info.append({'192.168.1.12':
{'cpu':['Intel(R) Core(TM) i5-5350U CPU @ 1.80GHz',4,1],'memory':['16','4','2'],'disk':['1T','2T']}})
host_info[0]["192.168.1.11"]['disk'][0]
六、集合
集合就是数学里的集合，没有什么特殊的定义。集合最好的应用是去重。 表示方法是通过一个{}创建或者通过set和frozenset函数转换成集合。
有两个函数可创建集合类型对象
set() # 创建可变集合对象
frozenset() # 创建不可变集合对象
可变集合创建
s = {"tom","cat","name","error"}
# 或
s = set({"tom","cat","name","error"})
不可变集合创建：
>>> s = [23，3，4，32]
>>> d = frozenset(s) # 创建不可变集合d
>>> print(d)
frozenset({23,3,4,32})
集合特性
集合是一组无序可哈希(hash)的值，所有元素不会重复 支持成员关系测试：in , not in 支持迭代，集合中的元素必须是可迭代对象 不支持：索引、元素获取、切片 没有特定语法格式，只能通过工厂函数set或者frozenset创建，字符串则直接创建即可
注：可哈希是什么意思 hash是一种函数映射，称为hash函数，y=hash_func(x)，可hash就是指对于一个对象x有其对应的y。在python内部是通过字典key的hash值来对应内存中的value地址的，所以两个相同hash的key就表示同一个了，而不可hash的对象自然也不能作为字典的key。
集合运算符： s | t s和t的并集 s & t s和t的交集 s - t 求差集 s ^ t 求对称差集
适用于set可变集合常用方法： s.add(item) 将item添加到s中。如果item已经在s中，则无任何效果 s.remove(item) 从s中删除item。如果item不是s的成员，则引发KeyError异常 s.discard(item) 从s中删除item。如果item不是s的成员，则无任何效果 s.pop() 随机删除一个s中任意的集合元素，如果有变量接收则会接收到删除到的那个元素 s.clear() 删除s中的所有元素 s.copy() 浅复制 s.update(t) 将t中的所有元素添加到s中。t可以是另一个集合、一个序列或者支持迭代的任意对象 s.union(t) 并集。返回所有在s和t中的元素 s.intersection(t) 交集。返回所有同时在s和t中的都有的元素 s.intersection_update(t) 算s与t的交集，并将结果赋值给s s.difference(t) 差集。返回所有在set中，但不在t中的元素 s.difference_update(t) 从s中删除同时也在t中的所有元素 s.symmetric_difference(t) 求对称差集。返回所有s中没有t中的元素和t中没有s中的元素组成的集合 s.sysmmetric_difference_update(t) 计算s与t的对称差集，并将结果放入s s.isdisjoint(t) 如果s和t没有相同项，则返回True s.issubset(t) 如果s是t的一个子集，则返回True s.issuperset(t) 如果s是t的一个超集，则返回True
集合实例：祛除列表中重复的元素 例1：去除海量列表里重复元素
>>> a = [11,22,33,44,11,22]
>>> b = set(a)
>>> b
set([33, 11, 44, 22])
例2：去除重复元素后转换成列表
l1 = ['b','c','d','b','c','a','a']
l2 = list(set(l1))
print(l2)
还有一种
l1 = ['b','c','d','b','c','a','a']
l2 = {}.fromkeys(l1).keys()
l3=[]
for i in l2:
l3.append(i)
print(l3)
这两种都有个缺点，祛除重复元素后排序变了： ['a', 'c', 'b', 'd']
如果想要保持他们原来的排序：用list类的sort方法
l1 = ['b','c','d','b','c','a','a']
l2 = list(set(l1))
l2.sort(key=l1.index)
print(l2)
也可以这样写：
l1 = ['b','c','d','b','c','a','a']
l2 = sorted(set(l1),key=l1.index)
print(l2)
也可以用遍历：
l1 = ['b','c','d','b','c','a','a']
l2 = []
for i in l1:
if not i in l2:
l2.append(i)
print(l2)
上面的代码也可以这样写
l1 = ['b','c','d','b','c','a','a']
l2 = []
[l2.append(i) for i in l1 if not i in l2] # 列表推导式
print l2
这样就可以保证排序不变了 ['b', 'c', 'd', 'a']
None类型
In [66]: a=None
In [67]: type(None)
NoneType
七、内建函数
查看系统内所有内置函数（BIF）：isinstance就在里面
>>> dir(__builtins__)
长度、最大最小值
支持字符串、列表、元组、字典、集合，不支持数字
len(str)
字符串长度
In [11]: a='hello world'
In [15]: len(a)
Out[15]: 11
max(str)
返回字符串 str 中最大的字母。
In [42]: max(a)
Out[42]: 'w'
min(str)
返回字符串 str 中最小的字母。
In [45]: min(a)
Out[45]: ' '
类型转换
数据类型的转换，你只需要将数据类型作为函数名即可。 以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。
| 函数 | 意义 |
|---|---|
| float(x) | print(float('10')) 将x转换到一个浮点数 |
| str(x) | print(str(10)) 将x转换为字符串 |
| repr(x) | print(type(repr(10))) 将对象 x 转换为表达式字符串 |
| eval(str) | print(eval('5+8')) 用来计算在字符串中的有效Python表达式,并返回一个对象 |
| tuple(s) | 将序列 s 转换为一个元组 |
| list(s) | 将序列 s 转换为一个列表 |
| set(s) | 转换为可变集合 |
| dict(d) | 创建一个字典。d 必须是一个序列 (key,value)元组。成对出现的数据，比如a=8,b=9 |
| frozenset(s) | 转换为不可变集合 |
| int(d) | 转换为整型 |
| chr(x) | asc=chr(97);print(asc) 将一个整数转换为一个字符，ascii与字符的转换函数 |
| ord(x) | asc=ord('a');print(asc) 将一个字符转换为它的整数值，与chr()相反 |
| hex(x) | asc=hex(10);print(asc) 将一个整数转换为一个十六进制字符串 |
| oct(x) | asc=oct(10);print(asc) 将一个整数转换为一个八进制字符串 |
常用的几个 int list tuple str dict
str与repr的区别
str()一般是将数值转成字符串(返回一个字符串，包含对象的友好的可打印表示形式。对于字符串，它返回字符串本身)。
'' 输出本身内容
repr()是将一个对象转成字符串显示。
实质上''与repr()意义是相同的。
eval函数类型转换
功能：将字符串str当成有效的表达式来求值并返回计算结果。
语法： eval(source[, globals[, locals]]) -> value
参数：
source：一个Python表达式或函数compile()返回的代码对象
globals：可选。必须是dictionary
locals：可选。任意map对象
1 可以把list,tuple,dict和string相互转化。
2 #################################################
3 字符串转换成列表
4 >>>a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]"
5 >>>type(a)
6 <type 'str'>
7 >>> b = eval(a)
8 >>> print b
9 [[1, 2], [3, 4], [5, 6], [7, 8], [9, 0]]
10 >>> type(b)
11 <type 'list'>
12 #################################################
13 字符串转换成字典
14 >>> a = "{1: 'a', 2: 'b'}"
15 >>> type(a)
16 <type 'str'>
17 >>> b = eval(a)
18 >>> print b
19 {1: 'a', 2: 'b'}
20 >>> type(b)
21 <type 'dict'>
22 #################################################
23 字符串转换成元组
24 >>> a = "([1,2], [3,4], [5,6], [7,8], (9,0))"
25 >>> type(a)
26 <type 'str'>
27 >>> b = eval(a)
28 >>> print b
29 ([1, 2], [3, 4], [5, 6], [7, 8], (9, 0))
30 >>> type(b)
31 <type 'tuple'>
八、推导式
推导式是 Python 语言中独有的特性，它是从一个或者多个迭代器快速简洁地创建数据结构的一种方法，可以将循环和条件判断相结合，从而避免语法冗长的代码
列表推导式
list comprehension -- 列表推导式，处理一个序列中的所有或部分元素并返回结果列表的一种紧凑写法。
# 语法格式
[expression for item in iterable ]
expression # 表达式，比如 单独的变量名，变量名 - 1
item # 循环变量
iterable # 可迭代对象 其后面可以跟判断条件，如：
[expression for item in iterable if condition]
# 传统方法
In [1]: number_list = list(range(1,5))
In [2]: number_list
Out[2]: [1, 2, 3, 4]
# 列表推导式
In [3]: num_list = [n for n in range(1,7)]
In [4]: num_list
Out[4]: [1, 2, 3, 4, 5, 6]
[i for i in 1,2,3,4] # 报错
[i for i in (1,2,3,4)] # 正确
# 添加有表达式的列表推导式
In [5]: num_list = [n - 1 for n in range(1,7)]
In [6]: num_list
Out[6]: [0, 1, 2, 3, 4, 5]
# 有条件判断的传统方法
In [7]: a_list = []
In [8]: for n in range(1,6):
...: if n % 2 == 1:
...: a_list.append(n)
...:
In [9]: a_list
Out[9]: [1, 3, 5]
# 有条件判断的列表推导式
In [10]: a_list = [n for n in range(1,6) if n % 2 == 1]
In [11]: a_list
Out[11]: [1, 3, 5]
# 含有嵌套循环的一般方法
In [12]: rows = range(1,4)
In [13]: cols = range(1,3)
In [14]: for row in rows:
...: for col in cols:
...: print(row,col)
...:
1 1
1 2
2 1
2 2
3 1
3 2
# 含有嵌套循环的列表推导式
In [15]: rows = range(1,4)
In [16]: cols = range(1,3)
In [17]: cells = [(row,col) for row in rows for col in cols]
In [18]: for cell in cells:
...: print(cell)
...:
(1, 1)
(1, 2)
(2, 1)
(2, 2)
(3, 1)
(3, 2)
字典推导式
{key_expression:value_expression for expression in iterable}
# 一个简单的例子
words = 'letters'
w_counts = {w: words.count(w) for w in words}
print(w_counts)
# 利用 set 集合去重，以减少 words.count(letter) 的次数，以节约资源和时间
w_counts = {w: words.count(w) for w in set(words)}
集合推导式 格式和列表、字典推导式的格式一样
>>> a_set = {n for n in range(1,6) if n % 3 == 1}
>>> a_set
{1, 4}
生成器推导式 也许机智的你已经发现了以上的规律，如果将列表推导式的方括号变成圆括号就可以定义一个元组推导式； 不幸的是，元组没有推导式，其实它是一个生成器推导式，它返回的是一个生成器对象，可以直接对其进行迭代。
特点：
一个生成器只能运行一次。list/set/str/dict 都是存储在内存里的，但生成器仅在运行时产生值，不会被保存下来，当然也不能对其备份。
>>> number_thing = (number for number in range(1,6) if number % 2 == 1)
>>> number_thing
<generator object <genexpr> at 0x7f25d59f1820>
>>> type(number_thing)
<type 'generator'>
# 可以直接对生成器对象进行迭代
>>> for number in number_thing:
... print(number)
...
1
3
5
# 可以对其调用 list()函数，但是由于上面已经迭代一次了，由于其是无法保存的，所以再次进行迭代，发现它已经不存在了
>>> list(number_thing)
[]
# 再次生成
>>> number_thing = (number for number in range(1,6) if number % 2 == 1)
>>> list(number_thing)
[1, 3, 5]