Python 核心数据结构
列表（list）
列表是一种数据项构成的有限序列，即按照一定的线性顺序，排列而成的数据项的集合，在这种数据结构上进行的基本操作包括对元素的的查找，插入，和删除。
在Python中，使用方括号[ ]表示列表：[item,item,item,item,item,item,item]
python中的列表存储
列表常见的操作
| 操作 | 说明 |
| list.append(obj) | 在列表后面新增元素 |
| del list[i] | 删除元素 |
| len(list) | 求列表长度 |
| list[i] | 读取第i个元素 |
| list[-i] | 读取倒数第i个元素 |
| list[i,j] | 从第i个元素截取 |
| list.index(objc) | 从列表中找出某个值第一次出现的地方 |
| list.insert(i,obj) | 在第i个元素的位置插入元素 |
| list.pop(i) | 移除第i个元素，并返回其值 |
列表的特性
成员有序：放进去的顺序跟取出的顺序是一致的
L = [1, 2, 3, 4, 5] print(L)
[1, 2, 3, 4, 5]
Process finished with exit code 0
成员可重复出现
L = [1, 1, 1, 1, 1] print(L) [1, 1, 1, 1, 1] Process finished with exit code 0
集合（set）
在Python中，使用大括号{ }或set()函数创建集合：{item,item.......}
需要特别注意的点：当我们要创建一个空集合的时候，只能用set()进行创建，因为{ }表示的是空的字典
集合常见的操作
| 操作 | 说明 |
| set.add(item) | 往集合里添加一个元素 |
| set.update(item) | 往集合里添加元素，item是可迭代对象如：列表、元组、字典等 |
| set.remove(item) | 将元素 item 从集合 set 中移除，如果元素不存在，则会发生错误。 |
| set.discard(item) | 将元素 item 从集合 set 中移除，如果元素不存在，不会发生错误 |
| set.pop() | 随机取出并删除一个元素 |
| set.len() | 计算集合个数 |
| set.clear() | 清空集合 |
| union() | 取两个集合的并集 |
集合的特性:
成员无序
my_set = {'xdclass', 'python', 'wiggin'}
print(my_set)
{'python', 'xdclass', 'wiggin'}
Process finished with exit code 0
是不是真的无序？
my_set = {1, 2, 3}
print(my_set)
{1, 2, 3}
Process finished with exit code 0
有的人可能会有疑惑，为什么set里面存储数字的时候，就是有序的呢？
其实不然，元素往set里存储前，会计算hash值，这个hash值决定了其存储的位置，只是刚好，数字1,2,3的hash值对应也是从小到大
print(hash(1)) print(hash(2)) print(hash(3)) 0x1 0x2 0x3 Process finished with exit code 0
如果这个时候，存入的数字是{6,7,8}呢，输出的结果又如何，6,7,8对应的hash值也是6,7,8
my_set = {6, 7, 8}
print(my_set)
{8, 6, 7}
Process finished with exit code 0
事情变得越来越有趣，为什么hash值按顺序排列，但是输出的结果却不是按顺序的呢？
成员不可重复出现（多次放入同一个元素，只算一个）
my_set = {'xdclass', 'xdclass', 'xdclass'}
print(my_set)
{'xdclass'}
Process finished with exit code 0
元组(tuple)
Python 的元组与列表非常相似，不同之处在于元组的元素不能修改、整个元组也不能变动。
在Python中，元组使用小括号( )，创建元组的时候，只要在括号中添加相应的元素，并使用逗号分隔即可，如：tup = (1, 2, 3)
需要特别注意的点：当我们要创建一个只有一个元素的元组的时候，在元素后面要加一个逗号，如：tup = （1，）而不能使用(1)
为什么只有一个元素时，后面要有一个逗号呢？
(1+1)*2 = 4 (2)*2 = ? 4 or (2,2)?
在Python中，( ) 也可以作为运算时的符号，如果不将单一元素的元组跟数学运算加以区分，那么解析器会傻傻分不清
元组常见的操作
| 操作 | 说明 |
| 新增元素 | 不允许 |
| 修改元素 | 不允许 |
| 删除某个元素 | 不允许 |
| tup[i] | 获取第i个元素 |
| tup[-i] | 获取倒数第i个元素 |
| tup[i:j] | 从第i个元素起到第j个元素 |
字典(dict)
在Python中，字典类型可存储任意类型对象，它用于存放具有映射关系的数据。其映射关系通过key value的形式体现。在Python中使用，key，value通过key:value的形式存在，同样通过大括号{ }包裹，
每个键值对通过逗号分隔，形式如下：{key1 : value1, key2 : value2 }
字典的常见操作
| 操作 | 说明 |
| update({1:2}) | 新增元素 |
| dict['key'] | 通过key获取对应的值，如果没对应key，会报错 |
| dict['key']=123 | 修改key对应的值 |
| del dict['key'] | 删除一个key及其对应value |
| del dict | 清空整个字典 |
| len(dict) | 字典元素个数 |
字典的特性
- 在字典中，key不能重复，如果放入相同的key，后者的值会覆盖前者
- 在字典中，key必须是不可变的
range类型
range() 函数返回的是一个可迭代对象（类型是对象），而不是列表类型， 所以打印的时候不会打印列表。
print(range(6)) 输出结果： range(0, 6)
如果想把range对象变成列表，可以使用list()函数对range进行处理
print(list(range(6))) 输出结果： [0, 1, 2, 3, 4, 5]
range函数的基本语法
- range(stop)
- range(start, stop[, step])
- start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
- stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
- step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)
print(list(range(6))) 输出结果： [0, 1, 2, 3, 4, 5] print(list(range(1,6))) 输出结果： [ 1, 2, 3, 4, 5] print(list(range(1, 6, 2))) 输出结果： [ 1, 3, 5] print(list(range(-11, -6))) 输出结果： [-11, -10, -9, -8, -7] print(list(range(1, -6, -1))) 输出结果： [1, 0, -1, -2, -3, -4, -5]
深入理解可变与不可变对象
什么是可变？什么是不可变？
这里的可变与不可变是相对于内存里的那块地方是否可以改变，通俗点讲，就是内存中对应的地址在值发生变动的时候会不会变。地址不变时，为可变对象，变动时，为不可变对象
a = 1 print(id(a)) a = a + 1 print(id(a))
输出结果： 140734638482064 140734638482096
上面的例子，在a的值发生变动(a = a+1)的时候,a对应的地址也发生了改变，其本质原因在于数字类型不可变，如果值要变动，会在内存里重新开辟一个空间用于存储相应的值
a = [1, 2, 3] print(id(a)) a.append(4) print(id(a)) 输出结果： 2935304970888 2935304970888
可变类型：列表、字典
不可变类型：数字、字符串、元组
元组里的元素不能变，但是，如果元组里存的是一个列表，那么这个时候能不能修改列表里某个属性的值呢？
答案是可以的
tup = (1, 2, 3, ["111", "222", "333"]) tup[-1][0] = "444" print(tup)
我们回到list的存储方式，list的地址里存的都是实际内容的指针，此时元组的内容指向list地址，而无论list的内容如何变更，list的地址也不会变，所以并不违背set里存储的元素不能变这样一个原则。
