1980 lines
57 KiB
Markdown
1980 lines
57 KiB
Markdown
# 07-Python数据类型
|
||
|
||
**Python有五个常用数据类型**
|
||
|
||
- Numbers 数字
|
||
|
||
- String 字符串
|
||
|
||
- List 列表
|
||
|
||
- Tuple 元组
|
||
|
||
- Dictionary 字典
|
||
|
||
- Set 集合 用来去重
|
||
|
||
|
||
**其他分类方式**
|
||
序列类型： 字符串、列表、元组、Unicode字符串，buffer对象，range对象
|
||
泛映射类型： 字典
|
||
集合： set()
|
||
|
||
## 一、数字
|
||
|
||
用于存储数值，是不变的数据类型，也就是说改变数字数据类型会分配一个新的对象。
|
||
当你指定一个值时，Number对象就会被创建
|
||
|
||
```python
|
||
var1 = 1
|
||
var1,var2=1,10
|
||
```
|
||
|
||
**使用del删除一些对象的引用**
|
||
|
||
```python
|
||
del var1[,var2[,var3[....,varN]]]]
|
||
```
|
||
|
||
例
|
||
|
||
```python
|
||
del var
|
||
del var_a, var_b
|
||
```
|
||
|
||
**Python常用数字类型**
|
||
|
||
- int 有符号整型
|
||
- float 浮点型
|
||
|
||
除了 [`int`](https://docs.python.org/zh-cn/3.12/library/functions.html#int) 和 [`float`](https://docs.python.org/zh-cn/3.12/library/functions.html#float)，Python 还支持其他数字类型，例如 [`Decimal`](https://docs.python.org/zh-cn/3.12/library/decimal.html#decimal.Decimal) 或 [`Fraction`](https://docs.python.org/zh-cn/3.12/library/fractions.html#fractions.Fraction)。Python 还内置支持 [复数](https://docs.python.org/zh-cn/3.12/library/stdtypes.html#typesnumeric)，后缀 `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
|
||
|
||
```python
|
||
>>> f=12
|
||
>>> type(f)
|
||
<type 'int'>
|
||
>>> f=12.0
|
||
>>> type(f)
|
||
<type 'float'>
|
||
```
|
||
|
||
复数类型：应用于系统分析、信号分析、量子力学、相对论、应用数学、流体力学、碎形
|
||
|
||
```python
|
||
>>> j=3.12
|
||
>>> type(j)
|
||
<type 'float'>
|
||
>>> j=3.12j //在原来数字基础上加j
|
||
>>> type(j)
|
||
<type 'complex'>
|
||
```
|
||
|
||
严格来讲，bool类型就是bool类型
|
||
bool(布尔型)
|
||
真 或 假
|
||
1 或 0
|
||
True 或 False
|
||
|
||
```python
|
||
>>> a=1==1
|
||
>>> a
|
||
True
|
||
>>> a=bool(1==1)
|
||
>>> a
|
||
True
|
||
>>> a=bool(1=="1")
|
||
>>> a
|
||
False
|
||
>>> type(a)
|
||
<type 'bool'>
|
||
```
|
||
|
||
## 二、字符串
|
||
|
||
表示文本
|
||
|
||
字符串是immutable的
|
||
|
||
**immutable -- 不可变对象**
|
||
|
||
具有固定值的对象。不可变对象包括 *数字、字符串和元组*。这样的对象不能被改变。如果必须存储一个不同的值，则必须创建新的对象。它们在需要常量哈希值的地方起着重要作用，例如作为字典中的键。
|
||
|
||
**创建字符串**
|
||
使用引号创建字符串
|
||
|
||
```python
|
||
var1 = 'Hello World!'
|
||
var2 = "Python fklinux"
|
||
var3 = '''Python fklinux'''
|
||
```
|
||
|
||
### 字符串切片
|
||
|
||
**字符串取值顺序**
|
||
1、从左到右索引默认0开始的，最大范围是字符串长度少1
|
||
2、从右到左索引默认-1开始的，最大范围是字符串开头
|
||
|
||
用`'变量[头下标:尾下标:步长]'`，就可截取相应的字符串，其中下标是从0开始算起，可以是正数或负数，下标可以为空表示取到头或尾。
|
||
|
||
```python
|
||
s = 'ilovepython'
|
||
s[1:5]的结果是love
|
||
```
|
||
|
||
当使用以冒号分隔的字符串，返回一个新对象，结果包含以这对偏移标识的连续内容，
|
||
|
||
左边的开始包含下边界，取到的最大范围不包括上边界。
|
||
|
||
```python
|
||
#!/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 | 其它的字符以普通格式输出 |
|
||
|
||
**原始字符串**
|
||
|
||
```python
|
||
# 如果不想让转义字符生效，只想显示字符串原来的意思，用r定义原始字符串, r和R效果相同
|
||
print(r'\t\r')
|
||
实际输出为："\t\r"
|
||
```
|
||
|
||
**字符串运算符**
|
||
下表实例变量a值为字符串"Hello"，b变量值为"Python"：
|
||
|
||
- \+ 字符串连接 a + b 输出结果： HelloPython
|
||
- \* 重复输出字符串 a*2 输出结果：HelloHello
|
||
- 支持成员运算符 in 和 not int
|
||
|
||
相邻的两个或多个 *字符串字面值* （引号标注的字符）会自动合并：
|
||
|
||
```python
|
||
>>> 'Py' 'thon'
|
||
'Python'
|
||
```
|
||
|
||
拼接分隔开的长字符串时，这个功能特别实用：
|
||
|
||
```python
|
||
>>> text = ('Put several strings within parentheses '
|
||
... 'to have them joined together.')
|
||
>>> text
|
||
'Put several strings within parentheses to have them joined together.'
|
||
```
|
||
|
||
这项功能只能用于两个字面值，不能用于变量或表达式：
|
||
|
||
```python
|
||
>>> 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
|
||
```
|
||
|
||
合并多个变量，或合并变量与字面值，要用 `+`：
|
||
|
||
```python
|
||
>>> prefix + 'thon'
|
||
'Python'
|
||
```
|
||
|
||
\+可以用于字符串更新
|
||
你可以对已存在的字符串进行修改，并赋值给另一个变量
|
||
|
||
```python
|
||
#!/usr/bin/python3.8
|
||
var1 = 'Hello World!'
|
||
print （"更新字符串 :- ", var1[:6] + 'wing!'）
|
||
|
||
结果：
|
||
更新字符串 :- Hello wing!
|
||
```
|
||
|
||
```python
|
||
#!/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格式化方法：使用%
|
||
|
||
```python
|
||
#!/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
|
||
|
||
```python
|
||
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附带参数
|
||
|
||
```python
|
||
>>> print("a",sep=':')
|
||
a:b
|
||
|
||
In [109]: print("abc","def",sep="|",end='')
|
||
abc|def
|
||
separater end
|
||
```
|
||
|
||
三引号（triple quotes） 可以将复杂的字符串进行复制,允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。
|
||
|
||
```python
|
||
>>> 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对象。 |
|
||
|
||
```python
|
||
# 把字符串的第一个字符大写
|
||
In [11]: a='hello world'
|
||
In [14]: a.capitalize()
|
||
Out[14]: 'Hello world'
|
||
```
|
||
|
||
```python
|
||
# 字符串的每个单词开头字符大写
|
||
In [7]: import string
|
||
In [8]: string.capwords("hello world")
|
||
Out[9]: 'Hello World'
|
||
```
|
||
|
||
```python
|
||
# 返回一个原字符串居中，并使用空格填充至长度为 width 的新字符串，这里的宽度为20
|
||
In [20]: a.center(20)
|
||
Out[20]: ' hello world '
|
||
```
|
||
|
||
```python
|
||
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
|
||
```
|
||
|
||
```python
|
||
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
|
||
```
|
||
|
||
```python
|
||
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'
|
||
```
|
||
|
||
使用方法举例：
|
||
|
||
```python
|
||
In [9]: hero = "i'm wing"
|
||
In [10]: hero.title()
|
||
Out[10]: "I'M Wing"
|
||
```
|
||
|
||
也可以直接使用模块实现各种字符串方法：
|
||
|
||
```python
|
||
In [13]: import string
|
||
|
||
In [14]: hero="i am wing"
|
||
|
||
In [15]: string.capwords(hero)
|
||
Out[15]: 'I Am Wing'
|
||
```
|
||
|
||
**大小写转化**
|
||
|
||
```python
|
||
#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
|
||
```
|
||
|
||
**去除空白**
|
||
|
||
```python
|
||
#!/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()用来按行分割字符串
|
||
|
||
```python
|
||
#!/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)) #还可以指定分割符的最大使用次数,这里是只使用两次
|
||
```
|
||
|
||
```python
|
||
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)
|
||
```
|
||
|
||
例如：
|
||
|
||
```python
|
||
>>> a='Beautiful, is; better*than\nugly'
|
||
>>> import re
|
||
>>> re.split('; |, |\*|\n',a)
|
||
['Beautiful', 'is', 'better', 'than', 'ugly']
|
||
```
|
||
|
||
**拼接字符串**
|
||
|
||
方法很多，其中join()方法性能最好，只是注意join处理的是列表
|
||
|
||
```python
|
||
#!/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个英文字母**
|
||
|
||
```python
|
||
In [9]: string.ascii_lowercase
|
||
Out[9]: 'abcdefghijklmnopqrstuvwxyz'
|
||
```
|
||
**中文内容处理**
|
||
|
||
注：python3不用处理即可使用
|
||
|
||
如果文件内容是中文：
|
||
read方法读出来之后是16进制方式，需要用print打印
|
||
|
||
如果使用readlines读文件，文件内容会被放到列表里，想显示中文必须使用for循环print列表元素才能显示中文
|
||
比如：
|
||
|
||
```python
|
||
[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)
|
||
....:
|
||
中文
|
||
```
|
||
|
||
替换字符
|
||
|
||
```python
|
||
str.maketrans 生成映射
|
||
str.translate 替换字符
|
||
>>> str="abcdefg"
|
||
>>> str.translate(str.maketrans("abcd","1234"))
|
||
'1234efg'
|
||
```
|
||
|
||
----------------------------
|
||
|
||
shell相关字符串处理
|
||
|
||
用sed作文本的大小写替换
|
||
|
||
```bash
|
||
# sed 's/[a-z]/\u&/g' /etc/passwd
|
||
# sed 's/[A-Z]/\l&/g' a
|
||
```
|
||
|
||
删除文件倒数第二行：
|
||
|
||
```bash
|
||
# sed '{N;$!P;D}' a.txt
|
||
```
|
||
|
||
翻转文本内容：
|
||
|
||
```bash
|
||
# tac a.txt
|
||
```
|
||
|
||
大小写替换
|
||
|
||
```bash
|
||
# echo HEllo Word | tr a-z A-Z
|
||
HELLO WORLD
|
||
```
|
||
|
||
使用shell命令翻转字符串
|
||
|
||
```bash
|
||
# a=abcdefg
|
||
# echo $a | rev
|
||
gfedcba
|
||
```
|
||
|
||
----------------------
|
||
|
||
## 三、列表
|
||
|
||
打印一个产品信息的界面
|
||
|
||
欢迎来到千锋饮料售卖机
|
||
|
||
产品列表
|
||
|
||
名字 剩余量 单价
|
||
|
||
购买
|
||
|
||
上货
|
||
|
||
[]()
|
||
**序列**
|
||
序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推,Python已经内置确定序列的长度以及确定最大和最小的元素的方法。Python有6个序列的内置类型，最常见的是列表和元组。
|
||
|
||
**序列操作包括**
|
||
索引，切片，加，乘，检查成员
|
||
|
||
**列表**
|
||
|
||
与 [immutable](https://docs.python.org/zh-cn/3.12/glossary.html#term-immutable) 字符串不同, 列表是 [mutable](https://docs.python.org/zh-cn/3.12/glossary.html#term-mutable) 类型，其内容可以改变
|
||
|
||
支持字符，数字，字符串甚至可以包含列表（嵌套），他的数据项不需要具有相同的类型
|
||
|
||
**创建列表**
|
||
以逗号分隔的不同的数据项使用方括号括起来即可。
|
||
例如：
|
||
|
||
```python
|
||
list1 = ['physics', 'chemistry', 1997, 2000]
|
||
list2 = [1, 2, 3, 4, 5 ]
|
||
list3 = ["a", "b", "c", "d"]
|
||
list4 = [] #创建空列表
|
||
list5 = list() #创建空列表
|
||
```
|
||
|
||
**列表截取**
|
||
语法：变量[头下标:尾下标]
|
||
从左到右索引默认0开始的，从右到左索引默认-1开始，下标可以为空，表示取到头或尾。
|
||
|
||
例1：
|
||
|
||
```python
|
||
#!/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：
|
||
|
||
```python
|
||
L = ['spam', 'Spam', 'SPAM!']
|
||
```
|
||
|
||
操作：
|
||
|
||
| Python 表达式 | 结果 | 描述 |
|
||
| ------------- | ----------------- | ------------------------ |
|
||
| L[2] | 'SPAM!' | 读取列表中第三个元素 |
|
||
| L[-2] | 'Spam' | 读取列表中倒数第二个元素 |
|
||
| L[1:] | ['Spam', 'SPAM!'] | 从第二个元素开始截取列表 |
|
||
|
||
**更新列表**
|
||
可以对列表的数据项进行修改或更新，也可以使用append()方法来添加列表项
|
||
例如：
|
||
|
||
```python
|
||
#!/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 语句来删除列表的的元素
|
||
例
|
||
|
||
```python
|
||
#!/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()`](https://docs.python.org/zh-cn/3.12/library/stdtypes.html#range) 和 [`len()`](https://docs.python.org/zh-cn/3.12/library/functions.html#len)：
|
||
|
||
```python
|
||
>>> 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
|
||
```
|
||
|
||
或者自定义计数器
|
||
|
||
```python
|
||
iterable=['a','b','c']
|
||
i = 0
|
||
for item in iterable:
|
||
print(i, item)
|
||
i += 1
|
||
```
|
||
|
||
不过大多数情况下 [`enumerate()`](https://docs.python.org/zh-cn/3.12/library/functions.html#enumerate) 函数很方便
|
||
|
||
**内置函数enumrate()**
|
||
为一个可迭代的对象添加序号，可迭代的对象你可以理解成能用for循环的就是可迭代的。
|
||
默认是编号是从0开始，可以设置从1开始
|
||
|
||
```python
|
||
iterable=['a','b','c']
|
||
for i, item in enumerate(iterable):
|
||
print(i, item)
|
||
```
|
||
|
||
```python
|
||
函数接收一个参数：默认是从0开始
|
||
>>> list(enumerate('abc'))
|
||
(0, 'a')
|
||
(1, 'b')
|
||
(2, 'c')
|
||
|
||
函数接收第二个参数指定开始的数字：
|
||
>>> enumerate('abc', 1)
|
||
(1, 'a')
|
||
(2, 'b')
|
||
(3, 'c')
|
||
```
|
||
|
||
实例：
|
||
|
||
```python
|
||
#cat test.py
|
||
li = ["手机", "电脑", '鼠标垫', '游艇']
|
||
for k, i in enumerate(li,1): # 这里的1表示序号从1开始
|
||
print(k,i)
|
||
|
||
执行结果如下：
|
||
1 手机
|
||
2 电脑
|
||
3 鼠标垫
|
||
4 游艇
|
||
```
|
||
|
||
**逆向循环**
|
||
|
||
为了逆向对序列进行循环，可以求出欲循环的正向序列，然后调用 [`reversed()`](https://docs.python.org/zh-cn/3.12/library/functions.html#reversed) 函数：
|
||
|
||
```python
|
||
>>> for i in reversed(range(1, 10, 2)):
|
||
... print(i)
|
||
9
|
||
7
|
||
5
|
||
3
|
||
1
|
||
```
|
||
|
||
**排序**
|
||
|
||
按顺序循环序列，可以用 [`sorted()`](https://docs.python.org/zh-cn/3.12/library/functions.html#sorted) 函数，在不改动原序列的基础上，返回一个新的序列：
|
||
|
||
```python
|
||
>>> 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
|
||
|
||
**给列表插入数据的其他方法**
|
||
把被切片出来的数据替换成后面的数据
|
||
|
||
```python
|
||
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']
|
||
```
|
||
|
||
批量替换
|
||
|
||
```python
|
||
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]
|
||
```
|
||
|
||
另类删除：
|
||
|
||
```python
|
||
In [7]: a=[12,3,4,3]
|
||
In [8]: a[2:]=[]
|
||
In [9]: a
|
||
Out[9]: [12, 3]
|
||
```
|
||
|
||
列表中嵌套列表：
|
||
|
||
```python
|
||
>>> 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)：
|
||
|
||
```python
|
||
>>> test=[1,2,3]
|
||
>>> isinstance(test,list)
|
||
True
|
||
```
|
||
|
||
变量解包：(可以用元组，列表，字典解包)
|
||
|
||
```python
|
||
>>> l1,l2 = [[1,'x','y'],[2,'z','r']]
|
||
>>> print(l1)
|
||
[1, 'x', 'y']
|
||
>>> print(l2)
|
||
[2, 'z', 'r']
|
||
```
|
||
|
||
**列表解包**
|
||
|
||
```python
|
||
In [59]: li=[1,2,3,4]
|
||
|
||
In [60]: print(*li)
|
||
1 2 3 4
|
||
```
|
||
|
||
如果不采用解包的方法：
|
||
|
||
```python
|
||
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 -- 间距
|
||
|
||
返回值
|
||
返回一个切片对象。
|
||
|
||
实例
|
||
|
||
```python
|
||
>>> 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]
|
||
```
|
||
|
||
**浅拷贝**
|
||
用等号将一个列表赋值给多个变量时，使用其中任意一个变量对列表的操作，结果都会同步到其他变量的值。
|
||
|
||
```python
|
||
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]
|
||
```
|
||
|
||
这种现象很像前面学的变量赋值，变量和列表本身之间的关系称作：变量对列表对象的引用并没有创建一个新的列表。
|
||
```python
|
||
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]]
|
||
```
|
||
|
||
**深拷贝**
|
||
|
||
```python
|
||
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测试
|
||
|
||
```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方法会更易读**
|
||
|
||
```python
|
||
>>> 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
|
||
|
||
```python
|
||
import sys
|
||
import pprint
|
||
|
||
str = pprint.pformat(sys.path)
|
||
print(str)
|
||
运行结果同上
|
||
```
|
||
|
||
|
||
|
||
## 四、元组
|
||
|
||
**导语**
|
||
元组介绍
|
||
访问元组
|
||
修改元组
|
||
删除元组
|
||
元组运算符
|
||
元组索引、截取
|
||
无关闭分隔符
|
||
元组内置函数
|
||
|
||
**元组介绍**
|
||
**使用元组的理由**
|
||
|
||
```ini
|
||
1. 占用内存空间小
|
||
2. 元组内的值不会被意外的修改
|
||
3. 可作为字典的键
|
||
4. 函数的参数是以元组形式传递的
|
||
5. 命名元组有时候可以代替类的对象(面向对象的时候讲)
|
||
```
|
||
|
||
与列表类似，不同之处在于元组的元素不能修改。
|
||
元组使用小括号，列表使用方括号。
|
||
元组的创建，只需要在括号中添加元素，并使用逗号隔开即可。
|
||
|
||
实例
|
||
|
||
```python
|
||
tup1 = ('physics', 'chemistry', 1997, 2000)
|
||
tup2 = (1, 2, 3, 4, 5 )
|
||
tup3 = "a", "b", "c", "d" # 任意无符号的对象，以逗号隔开，默认为元组
|
||
var1,var2,var3,var4=tup3 # 元组解包(unpack),把元组中的元素分别赋值给前面的变量
|
||
```
|
||
|
||
**创建空元组**
|
||
|
||
```python
|
||
tup1 = ()
|
||
|
||
元组中只包含一个元素时，需要在元素后面添加逗号，不加逗号会怎样，用type看一下类型
|
||
tup1 = (50,)
|
||
```
|
||
|
||
**访问元组**
|
||
元组与字符串类似，下标索引从0开始，可以进行截取，组合等
|
||
元组可以使用下标索引来访问元组中的值
|
||
实例:
|
||
|
||
```python
|
||
#!/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)
|
||
```
|
||
|
||
**修改元组**
|
||
元组中的元素值不允许修改，但可以对元组进行连接组合
|
||
实例:
|
||
|
||
```python
|
||
#!/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语句删除整个元组
|
||
实例:
|
||
|
||
```python
|
||
#!/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
|
||
```
|
||
|
||
**元组解包**
|
||
|
||
```python
|
||
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 }
|
||
|
||
```python
|
||
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
|
||
dict1 = { 'abc': 456 }
|
||
dict2 = { 'abc': 123, 98.6: 37 }
|
||
dict3 = {} # 空字典
|
||
```
|
||
|
||
**copy()创建字典**
|
||
|
||
```python
|
||
a={"a":"b","aa":"bb"}
|
||
b=a.copy()
|
||
a=
|
||
```
|
||
|
||
**fromkeys()创建字典**
|
||
语法
|
||
dict.fromkeys(seq[, value])
|
||
seq -- 字典键值列表
|
||
value -- 可选参数, 设置键序列（seq）的值
|
||
|
||
以**序列** seq 中元素做字典的键，序列可以是字符串、列表、元组。value 为字典所有键对应的初始值。
|
||
|
||
实例
|
||
|
||
```python
|
||
#!/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() 接收一个序列类型的参数，这个序列类型中的每个元素必须是成对出现
|
||
|
||
```python
|
||
>>>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() 函数**可以对具有相同数量的元素的序列进行配对**，返回的值不是元组，也不是列表，而是一个整合在一起的可迭代变量
|
||
|
||
```python
|
||
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
|
||
# python认为：True==1==1.0
|
||
d= {True:'yes',1:'no',1.0:'maybe'}
|
||
print(d)
|
||
```
|
||
|
||
|
||
Python字典中的键 是否相同（只有相同才会覆盖）取决于两个条件：
|
||
|
||
```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不可变数据类型：**
|
||
布尔型
|
||
整型
|
||
浮点型
|
||
元组
|
||
字符串
|
||
|
||
例如
|
||
|
||
```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()
|
||
|
||
```python
|
||
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
|
||
|
||
```python
|
||
#!/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()
|
||
|
||
**两种遍历字典方法：**
|
||
第一种：
|
||
|
||
```python
|
||
for k,v in dict.items():
|
||
print(k,v)
|
||
```
|
||
|
||
第二种：高效
|
||
|
||
```python
|
||
for key in dict:
|
||
print(key,dict[key])
|
||
```
|
||
|
||
**修改字典**
|
||
向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对
|
||
|
||
```python
|
||
#!/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
|
||
```
|
||
|
||
**删除字典元素**:
|
||
|
||
```python
|
||
del dict['Name'] # 删除键是'Name'的条目
|
||
dict.clear() # 清空字典所有条目
|
||
del dict # 删除字典
|
||
```
|
||
|
||
**pop()**
|
||
截取字典key的value，源字典key会被删除
|
||
|
||
```python
|
||
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
|
||
也是给字典添加元素的一种方式
|
||
|
||
```python
|
||
In [85]: f
|
||
Out[85]: {1: '农夫山泉', 2: '矿泉水', 3: '可乐'}
|
||
|
||
In [83]: f.setdefault(8,"雪碧")
|
||
Out[83]: '雪碧'
|
||
```
|
||
|
||
dict.update(dict2)
|
||
把字典dict2的键/值对更新到dict里
|
||
|
||
**字典变量解包**
|
||
|
||
```python
|
||
>>> d3,d4 = {'x':32,'y':80}
|
||
>>> print(d3)
|
||
x
|
||
>>> print(d4)
|
||
y
|
||
```
|
||
|
||
**应用场景**
|
||
|
||
```python
|
||
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函数转换成集合。
|
||
|
||
**有两个函数可创建集合类型对象**
|
||
|
||
```python
|
||
set() # 创建可变集合对象
|
||
frozenset() # 创建不可变集合对象
|
||
```
|
||
|
||
**可变集合创建**
|
||
|
||
```python
|
||
s = {"tom","cat","name","error"}
|
||
# 或
|
||
s = set({"tom","cat","name","error"})
|
||
```
|
||
|
||
**不可变集合创建**：
|
||
|
||
```python
|
||
>>> 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：去除海量列表里重复元素
|
||
|
||
```python
|
||
>>> a = [11,22,33,44,11,22]
|
||
>>> b = set(a)
|
||
>>> b
|
||
set([33, 11, 44, 22])
|
||
```
|
||
|
||
例2：去除重复元素后转换成列表
|
||
|
||
```python
|
||
l1 = ['b','c','d','b','c','a','a']
|
||
l2 = list(set(l1))
|
||
print(l2)
|
||
```
|
||
|
||
还有一种
|
||
|
||
```python
|
||
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方法
|
||
|
||
```python
|
||
l1 = ['b','c','d','b','c','a','a']
|
||
l2 = list(set(l1))
|
||
l2.sort(key=l1.index)
|
||
print(l2)
|
||
```
|
||
|
||
也可以这样写：
|
||
|
||
```python
|
||
l1 = ['b','c','d','b','c','a','a']
|
||
l2 = sorted(set(l1),key=l1.index)
|
||
print(l2)
|
||
```
|
||
|
||
也可以用遍历：
|
||
|
||
```python
|
||
l1 = ['b','c','d','b','c','a','a']
|
||
l2 = []
|
||
for i in l1:
|
||
if not i in l2:
|
||
l2.append(i)
|
||
print(l2)
|
||
```
|
||
|
||
上面的代码也可以这样写
|
||
|
||
```python
|
||
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类型**
|
||
|
||
```python
|
||
In [66]: a=None
|
||
In [67]: type(None)
|
||
NoneType
|
||
```
|
||
|
||
## 七、内建函数
|
||
|
||
查看系统内所有内置函数（BIF）：isinstance就在里面
|
||
|
||
```python
|
||
>>> dir(__builtins__)
|
||
```
|
||
|
||
**长度、最大最小值**
|
||
|
||
支持字符串、列表、元组、字典、集合，不支持数字
|
||
|
||
```python
|
||
len(str)
|
||
字符串长度
|
||
In [11]: a='hello world'
|
||
In [15]: len(a)
|
||
Out[15]: 11
|
||
```
|
||
|
||
```python
|
||
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对象
|
||
|
||
```python
|
||
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 -- 列表推导式，处理一个序列中的所有或部分元素并返回结果列表的一种紧凑写法。
|
||
|
||
```python
|
||
# 语法格式
|
||
[expression for item in iterable ]
|
||
expression # 表达式，比如 单独的变量名，变量名 - 1
|
||
item # 循环变量
|
||
iterable # 可迭代对象 其后面可以跟判断条件，如：
|
||
[expression for item in iterable if condition]
|
||
```
|
||
|
||
```python
|
||
# 传统方法
|
||
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]
|
||
```
|
||
|
||
```python
|
||
[i for i in 1,2,3,4] # 报错
|
||
[i for i in (1,2,3,4)] # 正确
|
||
```
|
||
|
||
```python
|
||
# 添加有表达式的列表推导式
|
||
In [5]: num_list = [n - 1 for n in range(1,7)]
|
||
|
||
In [6]: num_list
|
||
Out[6]: [0, 1, 2, 3, 4, 5]
|
||
```
|
||
|
||
```python
|
||
# 有条件判断的传统方法
|
||
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]
|
||
```
|
||
|
||
```python
|
||
# 含有嵌套循环的一般方法
|
||
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)
|
||
```
|
||
|
||
**字典推导式**
|
||
|
||
```python
|
||
{key_expression:value_expression for expression in iterable}
|
||
```
|
||
|
||
```python
|
||
# 一个简单的例子
|
||
words = 'letters'
|
||
w_counts = {w: words.count(w) for w in words}
|
||
print(w_counts)
|
||
```
|
||
|
||
```python
|
||
# 利用 set 集合去重，以减少 words.count(letter) 的次数，以节约资源和时间
|
||
w_counts = {w: words.count(w) for w in set(words)}
|
||
```
|
||
|
||
**集合推导式**
|
||
格式和列表、字典推导式的格式一样
|
||
|
||
```python
|
||
>>> a_set = {n for n in range(1,6) if n % 3 == 1}
|
||
>>> a_set
|
||
{1, 4}
|
||
```
|
||
|
||
**生成器推导式**
|
||
也许机智的你已经发现了以上的规律，如果将列表推导式的方括号变成圆括号就可以定义一个元组推导式；
|
||
不幸的是，元组没有推导式，其实它是一个生成器推导式，它返回的是一个生成器对象，可以直接对其进行迭代。
|
||
|
||
**特点：**
|
||
|
||
一个生成器只能运行一次。list/set/str/dict 都是存储在内存里的，但生成器仅在运行时产生值，不会被保存下来，当然也不能对其备份。
|
||
|
||
```python
|
||
>>> 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]
|
||
```
|
||
|
||
|