目录
写这篇文章，是对于平常开发不是以
Python为主，以便能快速复习Python基础知识而记录，以下文章都是基于python 3+
1 列表
1.1 定义
序列是Python 中最基本的数据结构
序列中的每个值都有对应的位置值，称之为索引，第一个索引是 0，第二个索引是 1，依此类推。
Python 有 6 个序列的内置类型，但最常见的是列表和元组
列表都可以进行的操作包括索引，切片，加，乘，检查成员。
此外，Python 已经内置确定序列的长度以及确定最大和最小的元素的方法。
列表是最常用的 Python 数据类型，它可以作为一个方括号内的逗号分隔值出现。列表的数据项 不需要具有相同的类型
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：
list1 = ['Google', 'Test', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]
list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']
1.2 访问列表中的值
列表索引从 0开始，第二个索引是 1，依此类推。
通过索引列表可以进行截取、组合等操作。
#!/usr/bin/python3
list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[0] )
print( list[1] )
print( list[2] )
结果：
red
green
blue
索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，以此类推
#!/usr/bin/python3
list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[-1] )
print( list[-2] )
print( list[-3] )
结果：
black
white
yellow
使用下标索引来访问列表中的值，同样也可以使用方括号 [] 的形式截取字符，如下所示：
#!/usr/bin/python3
nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
print(nums[0:4])
结果：
[10, 20, 30, 40]
使用负数索引值截取：
#!/usr/bin/python3
list = ['Google', 'Test', "Zhihu", "Taobao", "Wiki"]
# 读取第二位
print ("list[1]: ", list[1])
# 从第二位开始（包含）截取到倒数第二位（不包含）
print ("list[1:-2]: ", list[1:-2])
结果：
list[1]: Test
list[1:-2]: ['Test', 'Zhihu']
1.3 更新列表
可以对列表的数据项进行修改或更新，也可以使用 append() 方法来添加列表项，如下所示：
#!/usr/bin/python3
list = ['Google', 'Test', 1997, 2000]
print ("第三个元素为 : ", list[2])
list[2] = 2001
print ("更新后的第三个元素为 : ", list[2])
list1 = ['Google', 'Test', 'Taobao']
list1.append('Baidu')
print ("更新后的列表 : ", list1)
结果：
第三个元素为 : 1997
更新后的第三个元素为 : 2001
更新后的列表 : ['Google', 'Test', 'Taobao', 'Baidu']
1.4 删除列表元素
可以使用 del 语句来删除列表的的元素，如下实例：
#!/usr/bin/python3
list = ['Google', 'Test', 1997, 2000]
print ("原始列表 : ", list)
del list[2]
print ("删除第三个元素 : ", list)
结果：
原始列表 : ['Google', 'Test', 1997, 2000]
删除第三个元素 : ['Google', 'Test', 2000]
1.5 Python列表脚本操作符
列表对+ 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表
| Python 表达式 | 结果 | 描述 |
|---|---|---|
| len([1, 2, 3]) | 3 | 长度 |
| [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, end=" ") | 1 2 3 | 迭代 |
1.6 Python列表截取与拼接
Python的列表截取与字符串操作类型，如下所示：
L=['Google', 'Test', 'Taobao']
操作：
| Python 表达式 | 结果 | 描述 |
|---|---|---|
| L[2] | 'Taobao' | 读取第三个元素 |
| L[-2] | 'Test' | 从右侧开始读取倒数第二个元素: count from the right |
| L[1:] | ['Test', 'Taobao'] | 输出从第二个元素开始后的所有元素 |
>>>L=['Google', 'Test', 'Taobao']
>>> L[2]
'Taobao'
>>> L[-2]
'Test'
>>> L[1:]
['Test', 'Taobao']
>>>
列表还支持拼接操作：
>>>squares = [1, 4, 9, 16, 25]
>>> squares += [36, 49, 64, 81, 100]
>>> squares
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>>
1.7 嵌套列表
使用嵌套列表即在列表里创建其它列表，例如：
>>>a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'
1.8 列表比较
列表比较需要引入 operator 模块的 eq 方法
# 导入 operator 模块
import operator
a = [1, 2]
b = [2, 3]
c = [2, 3]
print("operator.eq(a,b): ", operator.eq(a,b))
print("operator.eq(c,b): ", operator.eq(c,b))
结果
operator.eq(a,b): False
operator.eq(c,b): True
2 元组
2.1 定义
Python 的元组与列表类似，不同之处在于 元组的元素不能修改
注意：元组使用小括号 ( )，列表使用方括号 [ ]
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可
>>> tup1 = ('Google', 'Test', 1997, 2000)
>>> tup2 = (1, 2, 3, 4, 5 )
>>> tup3 = "a", "b", "c", "d" # 不需要括号也可以
>>> type(tup3)
<class 'tuple'>
2.2 创建空元组
创建空元组
tup1 = ()
元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用：
>>> tup1 = (50)
>>> type(tup1) # 不加逗号，类型为整型
<class 'int'>
>>> tup1 = (50,)
>>> type(tup1) # 加上逗号，类型为元组
<class 'tuple'>
元组与字符串类似，下标索引从 0 开始，可以进行截取，组合等。
2.3 访问元组
元组可以使用下标索引来访问元组中的值，如下实例:
#!/usr/bin/python3
tup1 = ('Google', 'Test', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])
结果：
tup1[0]: Google
tup2[1:5]: (2, 3, 4, 5)
2.4 修改元组
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:
#!/usr/bin/python3
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)
结果：
(12, 34.56, 'abc', 'xyz')
2.5 删除元组
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:
#!/usr/bin/python3
tup = ('Google', 'Test', 1997, 2000)
print (tup)
del tup
print ("删除后的元组 tup : ")
print (tup)
以上实例元组被删除后，输出变量会有异常信息，输出如下所示：
删除后的元组 tup :
Traceback (most recent call last):
File "test.py", line 8, in <module>
print (tup)
NameError: name 'tup' is not defined
2.6 元组运算符
与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。
| Python 表达式 | 结果 | 描述 |
|---|---|---|
| len((1, 2, 3)) | 3 | 计算元素个数 |
| (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, end=" ") | 1 2 3 | 迭代 |
3 字典
3.1 定义
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示：
d = {key1 : value1, key2 : value2, key3 : value3 }
注意：dict 作为 Python 的关键字和内置函数，变量名不建议命名为 dict
键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字。
3.2 创建空字典
使用大括号 { } 创建空字典：
# 使用大括号 {} 来创建空字典
emptyDict = {}
# 打印字典
print(emptyDict)
# 查看字典的数量
print("Length:", len(emptyDict))
# 查看类型
print(type(emptyDict))
结果：
{}
Length: 0
<class 'dict'>
使用内建函数 dict() 创建字典：
emptyDict = dict()
# 打印字典
print(emptyDict)
# 查看字典的数量
print("Length:",len(emptyDict))
# 查看类型
print(type(emptyDict))
结果：
{}
Length: 0
<class 'dict'>
3.3 访问字典里的值
把相应的键放入到方括号中，如下实例:
#!/usr/bin/python3
tinydict = {'Name': 'Test', 'Age': 7, 'Class': 'First'}
print ("tinydict['Name']: ", tinydict['Name'])
print ("tinydict['Age']: ", tinydict['Age'])
结果：
tinydict['Name']: Test
tinydict['Age']: 7
如果用字典里没有的键访问数据，会输出错误如下：
#!/usr/bin/python3
tinydict = {'Name': 'Test', 'Age': 7, 'Class': 'First'}
print ("tinydict['Alice']: ", tinydict['Alice'])
结果：
Traceback (most recent call last):
File "test.py", line 5, in <module>
print ("tinydict['Alice']: ", tinydict['Alice'])
KeyError: 'Alice'
3.4 修改字典
向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:
#!/usr/bin/python3
tinydict = {'Name': 'Test', 'Age': 7, 'Class': 'First'}
tinydict['Age'] = 8 # 更新 Age
tinydict['School'] = "菜鸟教程" # 添加信息
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])
结果：
tinydict['Age']: 8
tinydict['School']: 菜鸟教程
3.5 删除字典元素
能删单一的元素也能清空字典，清空只需一项操作。
显式删除一个字典用del命令，如下实例：
#!/usr/bin/python3
tinydict = {'Name': 'Test', 'Age': 7, 'Class': 'First'}
del tinydict['Name'] # 删除键 'Name'
tinydict.clear() # 清空字典
del tinydict # 删除字典
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])
但这会引发一个异常，因为用执行 del 操作后字典不再存在：
Traceback (most recent call last):
File "/test-test/test.py", line 9, in <module>
print ("tinydict['Age']: ", tinydict['Age'])
NameError: name 'tinydict' is not defined
3.6 字典键的特性
字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行
- 不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
- 键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行
#!/usr/bin/python3
tinydict = {'Name': 'Test', 'Age': 7, 'Name': '小菜鸟'}
print ("tinydict['Name']: ", tinydict['Name'])
结果：
tinydict['Name']: 小菜鸟
#!/usr/bin/python3
tinydict = {['Name']: 'Test', 'Age': 7}
print ("tinydict['Name']: ", tinydict['Name'])
以上实例输出结果：
Traceback (most recent call last):
File "test.py", line 3, in <module>
tinydict = {['Name']: 'Test', 'Age': 7}
TypeError: unhashable type: 'list'
3.7 字典内置函数&方法
Python字典包含了以下内置函数：
len(dict)：计算字典元素个数，即键的总数。str(dict)：输出字典，可以打印的字符串表示。type(variable)：返回输入的变量类型，如果变量是字典就返回字典类型
4 集合
4.1 定义
集合（set）是一个无序的不重复元素序列。
可以使用 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为{ }是用来创建一个空字典。
创建格式：
parame = {value01,value02,...}
或者
set(value)
集合大致操作如下:
>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket) # 这里演示的是去重功能
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket # 快速判断元素是否在集合内
True
>>> 'crabgrass' in basket
False
>>> # 下面展示两个集合间的运算.
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a
{'a', 'r', 'b', 'c', 'd'}
>>> a - b # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b # 不同时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}
遍历元素：
>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}
4.2 操作集合
4.2.1 添加元素
语法格式如下：
s.add( x )
将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。
>>> thisset = set(("Google", "Test", "Taobao"))
>>> thisset.add("Facebook")
>>> print(thisset)
{'Taobao', 'Facebook', 'Google', 'Test'}
还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式如下：
s.update( x )
x 可以有多个，用逗号分开。
>>> thisset = set(("Google", "Test", "Taobao"))
>>> thisset.update({1,3})
>>> print(thisset)
{1, 3, 'Google', 'Taobao', 'Test'}
>>> thisset.update([1,4],[5,6])
>>> print(thisset)
{1, 3, 4, 5, 6, 'Google', 'Taobao', 'Test'}
>>>
4.2.2 移除元素
语法格式如下：
s.remove( x )
将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。
>>> thisset = set(("Google", "Test", "Taobao"))
>>> thisset.remove("Taobao")
>>> print(thisset)
{'Google', 'Test'}
>>> thisset.remove("Facebook") # 不存在会发生错误
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'Facebook'
>>>
此外还有一个方法也是移除集合中的元素，且 如果元素不存在，不会发生错误
格式如下所示：
s.discard( x )
>>> thisset = set(("Google", "Test", "Taobao"))
>>> thisset.discard("Facebook") # 不存在不会发生错误
>>> print(thisset)
{'Taobao', 'Google', 'Test'}
我们也可以设置随机删除集合中的一个元素，语法格式如下：
s.pop()
thisset = set(("Google", "Test", "Taobao", "Facebook"))
x = thisset.pop()
print(x)
结果：
$ python3 test.py
Test
多次执行测试结果都不一样。
set 集合的 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。
4.2.3 计算集合元素个数
语法格式如下：
len(s)
计算集合 s 元素个数。
>>> thisset = set(("Google", "Test", "Taobao"))
>>> len(thisset)
3
4.2.4 清空集合
语法格式如下：
s.clear()
清空集合 s
>>> thisset = set(("Google", "Test", "Taobao"))
>>> thisset.clear()
>>> print(thisset)
set()
4.2.5 判断元素是否在集合中存在
语法格式如下：
x in s
判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。
>>> thisset = set(("Google", "Test", "Taobao"))
>>> "Test" in thisset
True
>>> "Facebook" in thisset
False
>>>
5 推导式
Python 推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体
Python支持各种数据结构的推导式：
- 列表(list)推导式
- 字典(dict)推导式
- 集合(set)推导式
- 元组(tuple)推导式
5.1 列表推导式
列表推导式格式为：
[表达式 for 变量 in 列表]
[out_exp_res for out_exp in input_list]
或者
[表达式 for 变量 in 列表 if 条件]
[out_exp_res for out_exp in input_list if condition]
各个元素说明：
out_exp_res：列表生成元素表达式，可以是有返回值的函数。for out_exp in input_list：迭代input_list将out_exp传入到out_exp_res表达式中。if condition：条件语句，可以过滤列表中不符合条件的值。
过滤掉长度小于或等于3的字符串列表，并将剩下的转换成大写字母：
>>> names = ['Bob','Tom','alice','Jerry','Wendy','Smith']
>>> new_names = [name.upper()for name in names if len(name)>3]
>>> print(new_names)
['ALICE', 'JERRY', 'WENDY', 'SMITH']
计算 30 以内可以被 3 整除的整数：
>>> multiples = [i for i in range(30) if i % 3 == 0]
>>> print(multiples)
[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]
5.2 字典推导式
字典推导基本格式：
{ key_expr: value_expr for value in collection }
或
{ key_expr: value_expr for value in collection if condition }
使用字符串及其长度创建字典：
listdemo = ['Google','Test', 'Taobao']
# 将列表中各字符串值为键，各字符串的长度为值，组成键值对
>>> newdict = {key:len(key) for key in listdemo}
>>> newdict
{'Google': 6, 'Test': 4, 'Taobao': 6}
提供三个数字，以三个数字为键，三个数字的平方为值来创建字典：
>>> dic = {x: x**2 for x in (2, 4, 6)}
>>> dic
{2: 4, 4: 16, 6: 36}
>>> type(dic)
<class 'dict'>
5.3 集合推导式
集合推导式基本格式：
{ expression for item in Sequence }
或
{ expression for item in Sequence if conditional }
计算数字 1,2,3 的平方数：
>>> setnew = {i**2 for i in (1,2,3)}
>>> setnew
{1, 4, 9}
判断不是 abc 的字母并输出：
>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'d', 'r'}
>>> type(a)
<class 'set'>
5.4 元组推导式(生成器表达式)
元组推导式可以利用 range 区间、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的元组。
元组推导式基本格式：
(expression for item in Sequence )
或
(expression for item in Sequence if conditional )
元组推导式和列表推导式的用法也完全相同，只是元组推导式是用 () 圆括号将各部分括起来，而列表推导式用的是中括号 []，另外元组推导式返回的结果是一个生成器对象。
例如，我们可以使用下面的代码生成一个包含数字 1~9 的元组：
>>> a = (x for x in range(1,10))
>>> a
<generator object <genexpr> at 0x7faf6ee20a50> # 返回的是生成器对象
>>> tuple(a) # 使用 tuple() 函数，可以直接将生成器对象转换成元组
(1, 2, 3, 4, 5, 6, 7, 8, 9)
6 迭代器与生成器
6.1 迭代器定义
迭代是Python最强大的功能之一，是访问集合元素的一种方式，特点：
- 迭代器是一个可以记住遍历的位置的对象。
- 迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。
- 迭代器只能往前不会后退。
- 迭代器有两个基本的方法：
iter()和next()
字符串，列表或元组对象都可用于创建迭代器：
>>> list=[1,2,3,4]
>>> it = iter(list) # 创建迭代器对象
>>> print (next(it)) # 输出迭代器的下一个元素
1
>>> print (next(it))
2
>>>
迭代器对象可以使用常规for语句进行遍历：
#!/usr/bin/python3
list=[1,2,3,4]
it = iter(list) # 创建迭代器对象
for x in it:
print (x, end=" ")
结果：
1 2 3 4
也可以使用 next() 函数：
#!/usr/bin/python3
import sys # 引入 sys 模块
list=[1,2,3,4]
it = iter(list) # 创建迭代器对象
while True:
try:
print (next(it))
except StopIteration:
sys.exit()
结果如下：
1
2
3
4
6.2 创建一个迭代器
把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__()
类都有一个构造函数，Python 的构造函数为 __init__(), 它会在对象初始化的时候执行
__iter__()方法返回一个特殊的迭代器对象， 这个迭代器对象实现了__next__()方法并通过StopIteration异常标识迭代的完成。__next__()方法（Python 2 里是 next()）会返回下一个迭代器对象。
创建一个返回数字的迭代器，初始值为 1，逐步递增 1：
class MyNumbers:
def __iter__(self):
self.a = 1
return self
def __next__(self):
x = self.a
self.a += 1
return x
myclass = MyNumbers()
myiter = iter(myclass)
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
结果：
1
2
3
4
5
6.3 StopIteration
StopIteration异常用于标识迭代的完成，防止出现无限循环的情况，在 __next__() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。
例如在 20 次迭代后停止执行：
class MyNumbers:
def __iter__(self):
self.a = 1
return self
def __next__(self):
if self.a <= 20:
x = self.a
self.a += 1
return x
else:
raise StopIteration
myclass = MyNumbers()
myiter = iter(myclass)
for x in myiter:
print(x)
6.4 生成器
在 Python 中，使用了 yield函数被称为生成器(generator)
跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器
在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行
调用一个生成器函数，返回的是一个迭代器对象。
#!/usr/bin/python3
import sys
def fibonacci(n): # 生成器函数 - 斐波那契
a, b, counter = 0, 1, 0
while True:
if (counter > n):
return
yield a
a, b = b, a + b
counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成
while True:
try:
print (next(f), end=" ")
except StopIteration:
sys.exit()
结果：
0 1 1 2 3 5 8 13 21 34 55