python容器类型数据
str
序列操作
字符串属于序列类型，所谓序列，指的是一块可存放多个值的连续内存空间，这些值按一定顺序排列，可通过每个值所在位置的编号（称为索引、下标）访问它们。
s= "hello moluo"
Python 还支持索引值是负数，此类索引是从右向左计数，换句话说，从最后一个元素开始计数，从索引值 -1 开始，如图 所示。
索引取值
格式：序列类型数据[下标]
s = "hello moluo"
print(s[6]) # m
print(s[-10]) # e
切片操作
格式：序列类型数据[start : end : step]
s = "hello moluo"
print(s[1:4]) # ell => 取索引1到索引3（左闭又开）
print(s[:4]) # hell => start缺省，默认从0取
print(s[1:]) # ello moluo => end缺省，默认取到最后
print(s[1:-1]) # ello molu
print(s[6:9]) # mol
print(s[-4:-1]) # olu
print(s[-1:-4]) # 空
print(s[-1:-4:-1]) #oul step为1：从左向右一个一个取。为-1 ，从右向左一个取
判断成员是否存在
判断存在：Python 中，可以使用 in 关键字检查某元素是否为序列的成员。
s = "hello moluo"
print("moluo" in s) # True
相加拼接与乘法叠加
支持两种类型相同的序列使用“+”运算符做相加操作，它会将两个序列进行连接，但不会去除重复的元素。
使用数字 n 乘以一个序列会生成新的序列，其内容为原来序列被重复 n 次的结果
s = "hello"+" moluo"
print(s) # hello moluo
s= "*"*10
print(s) # **********
解包
a,b = "wb"
print(a) # w
print(b) # b
list
list，列表，在实际开发中，经常需要将一组（不只一个）数据存储起来，以便后边的代码使用。列表就是这样的一个数据结构。
列表会将所有元素都放在一对中括号[ ]里面，相邻元素之间用逗号,分隔，如下所示：
[element1, element2, element3, ..., elementn]
注意：不同于C，java等语言的数组，python的列表可以存放不同的，任意的数据类型对象。
列表声明
data = []
print(data, type(data))
data = [123,"moluo",True]
print(data,type(data))
序列操作
列表是 Python 序列的一种，我们可以使用索引（Index）访问列表中的某个元素（得到的是一个元素的值），也可以使用切片访问列表中的一组元素（得到的是一个新的子列表）。
索引取值
l = [10,11,12,13,14]
print(l[2]) # 12
print(l[-1]) # 14
切片操作
l = [10,11,12,13,14]
print(l[2:5])
print(l[-3:-1])
print(l[:3])
print(l[1:])
print(l[:])
print(l[2:4])
print(l[-3:-1])
print(l[-1:-3])
print(l[-1:-3:-1])
print(l[::2])
说明：
1、取出的元素数量为：结束位置 - 开始位置；
2、取出元素不包含结束位置对应的索引，列表最后一个元素使用
list[len(slice)]获取；3、当缺省开始位置时，表示从连续区域开头到结束位置；
4、当缺省结束位置时，表示从开始位置到整个连续区域末尾；
5、两者同时缺省时，与列表本身等效；
6、step为正，从左向右切，为负从右向左切。
判断成员是否存在
in 关键字检查某元素是否为序列的成员
l = [10,11,12,13,14]
print(20 in l) # False
print(12 in l) # True
相加拼接与乘法叠加
l1 = [1,2,3]
l2 = [4,5,6]
print(l1+l2) # [1, 2, 3, 4, 5, 6]
print(l2*3) # [4, 5, 6, 4, 5, 6, 4, 5, 6]
解包
a,b = [1,2]
print(a) # 1
print(b) # 2
tuple
tuple，元组
元组声明
Python的元组与列表类似，不同之处在于元组的元素只能读，不能修改。通常情况下，元组用于保存无需修改的内容。
元组使用小括号表示，声明一个元组：
(element1, element2, element3, ..., elementn)
注意：当创建的元组中只有一个字符串类型的元素时，该元素后面必须要加一个逗号（,）。否则 Python 解释器会将它视为字符串。
data = (1,2,3)
print(data,type(data)) # (1, 2, 3) <class 'tuple'>
# 当元组声明时，可以省略小括号
data = 1,
print(data, type(data)) # (1,) <class 'tuple'>
data = 1, 2
print(data, type(data)) # (1, 2) <class 'tuple'>
常用操作
和列表一样，元组也是一种序列类型，因此也支持索引取值和切片操作、判断成员是否存在，解包。
l = (1,2,3,4,5)
# 索引取值
print(l[2]) # 3
print(l[-2]) # 4
# 切片操作
print(l[2:4]) # (3, 4)
print(l[:4]) # (1, 2, 3, 4)
# 判断成员是否存在
print(2 in l) # True
# 加法拼接
a = (1,2)
b = (4,5)
print(a+b) # (1, 2, 4, 5)
# 乘法叠加
print(b*3) # (4, 5, 4, 5, 4, 5)
# 解包
x, y = (10, 20)
print(x) # 10
print(y) # 20
# 组包
x = 1
y = 2
data = x,y
print(data) # (1, 2)
# 交换2个变量的值
x = 10
y = 20
x,y = y,x
print(x,y) # 20 10
set
Python 中的集合(set)，和数学中的集合概念一样。由不同的可hash的不重复的元素组成的集合。
声明集合
Python 集合会将所有元素放在一对大括号 {} 中，相邻元素之间用“,”分隔，如下所示：
{element1,element2,...}
其中，elementn 表示集合中的元素，个数没有限制。
从内容上看，同一集合中，只能存储不可变的数据类型，包括整形、浮点型、字符串、元组，无法存储列表、字典、集合这些可变的数据类型，否则 Python 解释器会抛出 TypeError 错误。
由于集合中的元素是无序的，因此无法向列表那样使用下标访问元素。Python 中，访问集合元素最常用的方法是使用循环结构，将集合中的数据逐一读取出来。
dict
dictionary，字典
声明字典
python使用 { } 创建字典，由于字典中每个元素都包含键（key）和值（value）两部分，因此在创建字典时，键和值之间使用冒号:分隔，相邻元素之间使用逗号,分隔，所有元素放在大括号{ }中。
使用{ }创建字典的语法格式如下：
dictname = {'key':'value1', 'key2':'value2', ...}
1、同一字典中的各个键必须唯一，不能重复。
2、低版本中，字典的键值对是无序的，但在3.6版本后字典的键值对默认有序的了，这是新的版本特征。
常用操作
book = {
"price": 9.9,
"title": "西游记后传",
"publish": "人民出版社",
"authors": ["吴承恩", "小明"]
}
# (1) 查键值
print(book["title"]) # 返回字符串 西游记后传
print(book["authors"]) # 返回列表 ["吴承恩", "小明"]
# (2) 添加或修改键值对，注意：如果键存在，则是修改，否则是添加
book["price"] = 299 # 修改键的值
book["publish"] = "北京商务出版社" # 添加键值对
# (3) 删除键值对 del 删除命令
print(book)
del book["publish"]
print(book)
del book
print(book)
# (4) 判断键是否存在某字典中
print("price" in book)
变量缓存机制[重要]
在计算机的硬件当中，内存是最重要的配置之一，直接关系到程序的运行速度和流畅度。而python代码的运行，肯定也是放在内存中运行的，所以官方实现了一套变量缓存机制，以达到节省内存的目的。在这个变量缓存机制中，python把一些相同值的变量在内存中指向同一块内存空间，而不再重新开辟一个空间。当然，变量缓存机制，也叫内存驻留机制。
python中使用id()函数查看数据的内存地址。
a = 10
b = 10
print(id(a)) # 140724467271616
print(id(b)) # 140724467271616
# 数值类型(int, float, bool)
1.对于整型而言，-5~正无穷范围内的相同值 id一致
2.对于浮点数而言，正数范围内的相同值 id一致
3.布尔值而言,值相同情况下，id一致
# 容器类型(str, list, set, dict, tuple)
5.字符串 和 空元组 相同的情况下，地址相同
6.列表，元组，字典，集合无论什么情况 id标识都不同 [空元组例外]
小数据池
不同的python文件（模块）中的代码里面的相同数据的本应该是不在同一个内存地址当中的， 而是应该全新的开辟一个新空间，但是这样也会占用了更多的内存，所以python定义了小数据池的概念，默认允许小部分数据即使在不同的文件当中，只要数据相同就可以使用同一个内存空间，以达到节省内存的目的。
小数据池只针对：int、bool、None关键字 ，这些数据类型有效。
is运算符
# 在python中如果要比较两个变量是否同一个值，一般是使用 == 判断。
# 但是，如果在判断的基础上，还要判断两个变量的内存地址是否一样的话，则需要使用is来判断
print(10 == 10.0)
print(id(10) == id(10.0))
数据类型转换
类型自动转换
# data = bool + int
data = True + 2
print(data)
# data = bool + float
data = True + 3.14
print(data)
# data = int + float
data = 3 + 3.5
print(data)
类型强制转换
i = int("3")
print(i,type(i)) # 3 <class 'int'>
s = str(3.14)
print(s,type(s)) # 3.14 <class 'str'>
x = int(True)
print(x, type(x)) # 1 <class 'int'>
y = bool(0)
print(y, type(y)) # False <class 'bool'>
a = float(True)
print(a, type(a)) # 1.0 <class 'float'>
a = float("3.15")
print(a, type(a)) # 3.15 <class 'float'>
# # 以下错误示例：
# a = float("3.15元")
# print(a, type(a)) # ValueError: could not convert string to float: '3.15元'
容器类型数据强制类型转换
# 列表可以通过转换数据类型为集合，可以去除重复的成员
data = [1,3,4, 5, 3, 2, 1]
print(data, type(data)) # [1, 3, 4, 5, 3, 2, 1] <class 'list'>
ret = set(data)
print(ret, type(ret)) # {1, 2, 3, 4, 5} <class 'set'>
data = list(ret)
print(data, type(data)) # [1, 2, 3, 4, 5] <class 'list'>
# 字典转列表，可以直接提取字典的所有key出来
data = {"A":1, "B":2}
ret = list(data)
print(ret) # ['A', 'B']
# 元组可以通过转换数据成列表，修改成员的排列位置
old_data = (1, 2, 3, 4)
data = list(old_data)
data[1], data[2] = data[2], data[1]
new_data = tuple(data)
print(new_data) # (1, 3, 2, 4)