Python3基础数据类型（数字、字符串、元组、列表、集合、字典）

笔记参考了菜鸟教程

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.键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行