笔记参考了菜鸟教程
Python 中的变量不需要声明，赋值才创建。赋值给变量的是什么类型变量就是什么类型
多个变量赋值
1 a, b, c = 1, 2, "runoob"
标准数据类型
Python3 中有六个标准的数据类型：
不可变数据：Number(数字)、String（字符串）、Tuple(元组)
可变数据： List（列表）、Set(集合)、Dictionary(字典)
Python 字符串不能被改变。向一个索引位置赋值，比如word[0] = 'm'会导致错误。
Number(数字)
Python3数字不支持Double型
内置的 type() 函数可以用来查询变量所指的对象类型。
此外还可以用 isinstance 来判断：isinstance(变量，类型)
isinstance 和 type 的区别在于：type()不会认为子类是一种父类类型，isinstance()会认为子类是一种父类类型。
1 >>> class A: 2 ... pass 3 ... 4 >>> class B(A): 5 ... pass 6 ... 7 >>> isinstance(A(), A) 8 True 9 >>> type(A()) == A 10 True 11 >>> isinstance(B(), A) 12 True 13 >>> type(B()) == A 14 False
到 Python3 中，把 True 和 False 定义成关键字了，但它们的值还是 1 和 0，它们可以和数字相加。
数值运算
数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。
1 >>>2 ** 5 # 乘方 2 32
List(列表)
列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。
和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。
1 #!/usr/bin/python3 2 3 list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ] 4 tinylist = [123, 'runoob'] 5 6 print (list) # 输出完整列表 7 print (list[0]) # 输出列表第一个元素 8 print (list[1:3]) # 从第二个开始输出到第三个元素 9 print (list[2:]) # 输出从第三个元素开始的所有元素 10 print (tinylist * 2) # 输出两次列表 11 print (list + tinylist) # 连接列表
输出结果:
['abcd', 786, 2.23, 'runoob', 70.2]
abcd
[786, 2.23]
[2.23, 'runoob', 70.2]
[123, 'runoob', 123, 'runoob']
['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']
与Python字符串不一样的是，列表中的元素是可以改变的
Python 列表截取可以接收第三个参数，参数作用是截取的步长
>>>A=['a','b','c','d','e'] >>>A[1:4:2]
输出结果：['b','d']
将列表当做堆栈使用
列表方法使得列表可以很方便的作为一个堆栈来使用，堆栈作为特定的数据结构，最先进入的元素最后一个被释放（后进先出）。用 append() 方法可以把一个元素添加到堆栈顶。用不指定索引的 pop() 方法可以把一个元素从堆栈顶释放出来。
>>> stack = [3, 4, 5] >>> stack.append(6) >>> stack.append(7) >>> stack [3, 4, 5, 6, 7] >>> stack.pop() 7 >>> stack [3, 4, 5, 6] >>> stack.pop() 6 >>> stack.pop() 5 >>> stack [3, 4]
将列表当作队列使用
也可以把列表当做队列用，只是在队列里第一加入的元素，第一个取出来；但是拿列表用作这样的目的效率不高。在列表的最后添加或者弹出元素速度快，然而在列表里插入或者从头部弹出速度却不快（因为所有其他的元素都得一个一个地移动）。
>>> from collections import deque >>> queue = deque(["Eric", "John", "Michael"]) >>> queue.append("Terry") # Terry arrives >>> queue.append("Graham") # Graham arrives >>> queue.popleft() # The first to arrive now leaves 'Eric' >>> queue.popleft() # The second to arrive now leaves 'John' >>> queue # Remaining queue in order of arrival deque(['Michael', 'Terry', 'Graham'])
列表推导式
怕你看不懂，先上栗子，再上锤子！
这里我们将列表中每个数值乘三，获得一个新的列表：
>>> vec = [2, 4, 6] >>> [3*x for x in vec] [6, 12, 18]
再看这个好玩的：
>>> vec = [2, 4, 6]
>>> [[x, x**2] for x in vec] [[2, 4], [4, 16], [6, 36]]
这里我们对序列里每一个元素逐个调用某方法：
>>> freshfruit = [' banana', ' loganberry ', 'passion fruit '] >>> [weapon.strip() for weapon in freshfruit] ['banana', 'loganberry', 'passion fruit']
我们可以用 if 子句作为过滤器：
>>> vec = [2, 4, 6] >>> [3*x for x in vec if x > 3] [12, 18] >>> [3*x for x in vec if x < 2] []
以下是一些关于循环和其它技巧的演示：
>>> vec1 = [2, 4, 6] >>> vec2 = [4, 3, -9] >>> [x*y for x in vec1 for y in vec2] [8, 6, -18, 16, 12, -36, 24, 18, -54] >>> [x+y for x in vec1 for y in vec2] [6, 5, -7, 8, 7, -5, 10, 9, -3] >>> [vec1[i]*vec2[i] for i in range(len(vec1))] [8, 12, -54]
列表推导式可以使用复杂表达式或嵌套函数：
>>> [str(round(355/113, i)) for i in range(1, 6)] ['3.1', '3.14', '3.142', '3.1416', '3.14159']
好啦，现在再看如下的是个人都不知道说了什么的锤子：
列表推导式提供了从序列创建列表的简单途径。通常应用程序将一些操作应用于某个序列的每个元素，用其获得的结果作为生成新列表的元素，或者根据确定的判定条件创建子序列。
每个列表推导式都在 for 之后跟一个表达式，然后有零到多个 for 或 if 子句。返回结果是一个根据表达从其后的 for 和 if 上下文环境中生成出来的列表。如果希望表达式推导出一个元组，就必须使用括号。
嵌套列表解析
Python的列表还可以嵌套。
以下栗子展示了3X4的矩阵列表：
>>> matrix = [[1, 2, 3, 4],[5, 6, 7, 8],[9, 10, 11, 12],]
将3X4的矩阵列表转换为4X3列表：
>>> [[row[i] for row in matrix] for i in range(4)] [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
也可以使用以下方法来实现：
>>> transposed = [] >>> for i in range(4): ... transposed.append([row[i] for row in matrix]) ... >>> transposed [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
另外一种实现方法：
>>> transposed = [] >>> for i in range(4): ... # the following 3 lines implement the nested listcomp ... transposed_row = [] ... for row in matrix: ... transposed_row.append(row[i]) ... transposed.append(transposed_row) ... >>> transposed [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
元组由若干逗号分隔的值组成，栗子：
>>> t = 12345, 54321, 'hello!' >>> t[0] 12345 >>> t (12345, 54321, 'hello!') >>> # Tuples may be nested: ... u = t, (1, 2, 3, 4, 5) >>> u ((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
如你所见，元组在输出时总是有括号的，以便于正确表达嵌套结构。在输入时可能有或没有括号， 不过括号通常是必须的（如果元组是更大的表达式的一部分）。
Tuple（元组）
元组（tuple）与列表类似，不同之处在于元组的元素不能修改，只能进行连接组合。元组写在小括号 () 里，元素之间用逗号隔开。
#!/usr/bin/python3 tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2 ) tinytuple = (123, 'runoob') print (tuple) # 输出完整元组 print (tuple[0]) # 输出元组的第一个元素 print (tuple[1:3]) # 输出从第二个元素开始到第三个元素 print (tuple[2:]) # 输出从第三个元素开始的所有元素 print (tinytuple * 2) # 输出两次元组 prin
显示结果：
('abcd', 786, 2.23, 'runoob', 70.2)
abcd
(786, 2.23)
(2.23, 'runoob', 70.2)
(123, 'runoob', 123, 'runoob')
('abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob')
Set（集合）
集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。集合是无序的不重复序列。
基本功能是进行成员关系测试和删除重复元素。列表可存在重复元素，集合不能存在重复元素。
Dictionary（字典）
字典（dictionary）是Python中的内置数据类型。字典以关键字为索引。
列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。
键(key)必须使用不可变类型,如字符串，元组和数字。
在同一个字典中，键(key)必须是唯一的。
1 #!/usr/bin/python3 2 dict = {} 3 dict['one'] = "1 - 菜鸟教程" 4 dict[2] = "2 - 菜鸟工具" 5 tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'} 6 7 print (dict['one']) # 输出键为 'one' 的值 8 print (dict[2]) # 输出键为 2 的值 9 print (tinydict) # 输出完整的字典 10 print (tinydict.keys()) # 输出所有键 11 print (tinydict.values()) # 输出所有值
输出结果：
1 - 菜鸟教程
2 - 菜鸟工具
{'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
dict_keys(['name', 'code', 'site'])
dict_values(['runoob', 1, 'www.runoob.com'])
字典推导可以用来创建任意键和值的表达式词典：
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
在序列中遍历时，索引位置和对应值可以使用 enumerate() 函数同时得到：
>>> for i, v in enumerate(['tic', 'tac', 'toe']): ... print(i, v) ... 0 tic 1 tac 2 toe
同时遍历两个或更多的序列，可以使用 zip() 组合：
#!usr/bin/python3
questions = ['name', 'quest', 'favorite color']
answers = ['lancelot', 'the holy grail', 'blue']
for q, a in zip(questions, answers):
print('{0} {1}'.format(q, a))
执行结果：
name lancelot
quest the holy grail
favorite color blue
要反向遍历一个序列，首先指定这个序列，然后调用 reversed() 函数：
#!usr/bin/python3 for i in reversed(range(1, 10, 2)): print(i,end=" ")
执行结果：
9 7 5 3 1
1、字典是一种映射类型，它的元素是键值对。
2、字典的关键字必须为不可变类型，且不能重复。
3、创建空字典使用 { }。
字典键的特性：
1.不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住；
2.键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行