【python基础】——数据类型（列表、字典、集合）

骏马金龙——python语法基础

python基础

变量与运算

符号	//	%	**
意义	整除	整除取余	幂次方

---

数据种类

---

0. 序列

参考：python序列操作

序列（str、list、tuple)可以进行的操作：
通过索引取元素、切片操作、找出第一个元素的位置index()

可变序列（list)可以进行的操作：
**1) 删除相关操作有del、remove()、pop()、clear()。
2）添加相关操作有append()、extend()、insert()、s *= n
3）拷贝序列copy()、反转序列reverse()。
4) 注意：列表复制有三种

l0 = [1, 2, 3]
print("l0_:",l0)
l1 = l0
l2 = l0[:]
l4 = l0*4
print("l4_:",l4)
l3 = l0.copy()
l0.append(1000)
l1.append(0)
print("l0:",l0)
print("l1:",l1)
print("l2:",l2)
print("l3:",l3)
print("l4:",l4)

l0_: [1, 2, 3]
l4_: [[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]]
l0: [1, 2, 3, 1000, 0]
l1: [1, 2, 3, 1000, 0]
l2: [1, 2, 3]
l3: [1, 2, 3]
l4: [[1, 2, 3, 1000, 0], [1, 2, 3, 1000, 0], [1, 2, 3, 1000, 0], [1, 2, 3, 1000, 0]]
可见：因为可变序列引用的是地址，直接通过赋值的方式进行复制，只是将地址复制了，没有真正地重新分配另一块新的地址进行存放，所有当l0和l1任何一方进行改变的时候，都会导致地址的内容发生改变，因此l0和l1会发生改变，而l2,l3是通过copy等方式进行的深层复制，直接分配了一个新的地址进行存储，因此不会随l0改变而改变
l4是对列表进行复制，这样引用的是地址吗，导致后面也会出现随动现象

不可变序列（tuple、str)可以进行的操作：
**hash(哈希映射操作)：就是根据一定的规则将不可变的序列映射成另一个形式，可以简单地理解为y = f(x)的形式，最常见的是将不可变序列hash成十进制的数字，一般映射关系是一一对应的

>>> hash("asd")
-2014632507

>>> hash((1,23))
1320437575

>>> hash([1,23])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

能够hash的不可变序列，意味着能作为dict的key，能保存到set或frozenset中

---

1. 列表

# ----------------------列表的创建------------------
l1 = list()
l2 = []
print("l1:",l1)
print("l2:",l2)

1). 添加元素：append()、extend()、insert()

append()、extend()——前者是将整个添加的对象作为一个整体添加而后者则是将可迭代对象的内层每一个元素单个添加

# ----------------------列表元素的添加---------------------
## 直接在列表最后面进行元素的添加,append,extend
for i in range(10):
	l1.append(i)
	l2.append(i+2)
print("l1:",l1)
print("l2:",l2)
l1.extend(l2)
print(l1)

## 根据索引将元素插入到指定的位置，列表自动延长，该位置及以后的原来元素向后挪位置
l1 = [1,2,3]
print("插入前：",l1)
l1.insert(1,["插入的元素"])
print("插入后：",l1)

2). 删除元素：remove()、pop()、del

# -----------------删除元素------------#
# 直接在列表末尾删除元素,
popl1 = [1,2,3]
l1.pop()
print(l1)
## 直接移除指定的元素,remove,若要移除的元素不存在报错
l1 = [1,2,3
l1.remove(2)
print(l1)
del l1[1]

3). 其他操作：reverse()、index()、count()等

# ----------------其他-----------------
## 合并
print(l1 + l2)
## 查找第一个元素的索引
print(l1.index(1))
## 反转
print(l1.reverse())
## 计数
print(l1.count(1))

注意：

---

2、字典——{key:value}形式的非序列容器无序数据结构

字典是无序的，和集合一样，根据索引得到的元素和添加元素的顺序是没有关系的
> 如上图所示，字典是一个通过键值对进行元素的存放的一个数据结构，key代表元素的唯一标签。对于字典的操作都是先对key进行hash,然后根据hash值（可以理解为地址）去得到key和value的指针，如：
1）存放字典元素：根据key得到hash值，若hash值对应的指向value的指针不存在，则新创建key-value键值对，若存在，则将value值覆盖为最新的值

1)创建字典

dict1 = {"1":"1","2":2,"3":3}
dict2 = dict(one=1,two=2,three=3)
dict3 = dict([('one',1),("two",2)])
dict4 = dict(zip(("one","two","three"),(1,2,3)))

{‘1’: ‘1’, ‘2’: 2, ‘3’: 3}
{‘one’: 1, ‘two’: 2, ‘three’: 3}
{‘one’: 1, ‘two’: 2}
{‘one’: 1, ‘two’: 2, ‘three’: 3}

在python中，能hashable的数据类型都必须是不可变类型的，所以列表、集合、字典不能作为dict的key，字符串、数值、元组都可以作为dict的key(类的对象实例也可以，因为自定义类的对象默认是不可变的)。

2)初始化字典

dict.fromkeys（序列，默认的字典值）

dict5 = dict.fromkeys("abcd,",2)

3）字典的拷贝

# ------------字典的拷贝--------------------
dict6 = dict1.copy() # 浅拷贝，只是将每一个key的地址给到了新字典
print(dict1)
print(dict6)
print(id(dict1["1"]))
print(id(dict6["1"]))

dict6["1"] = 4 # 但是在一个拷贝的字典中发生值的改变值，会为这个键新开辟一个地址用于存储新的值
print(dict1)
print(dict6)
print(id(dict1["1"]))
print(id(dict6["1"]))
print(id(dict1["2"]))
print(id(dict6["2"]))

{‘1’: ‘1’, ‘2’: 2, ‘3’: 3}
{‘1’: ‘1’, ‘2’: 2, ‘3’: 3}
1508279661712
1508279661712
{‘1’: ‘1’, ‘2’: 2, ‘3’: 3}
{‘1’: 4, ‘2’: 2, ‘3’: 3}
1508279661712
140712196691072
140712196691008
140712196691008

4）增删改查

# --------------------字典的增删改查-------------------------
## 查询,根据key查找，不存在时会报错，可以通过重写字典类的__missing__方法来实现返回None
dict7 = {"1":"1","2":2,"3":3}
value = dict7["1"]
## 更新
dict7.update({"1":2,"4":5})
dict7["5"] = 6
## pop类
print(dict7.pop("1"))
print(dict7.popitem()) #按照 LIFO（Last In First Out 后进先出法
## 删除
dict7.update({"1":2,"4":5})
dict7["5"] = 6
del dict7["5"]
dict7.clear()

5）获得key,value和键值对

#--------------------获得字典key，value，键值对,若想对其进行迭代取值，需要利用list进行解析

dict8 = {"1":"1","2":2,"3":3}
print(dict8.keys())
print(list(dict8.keys()))
print(dict8.values())
print(dict8.items())
print(iter(dict8))

dict_keys([‘1’, ‘2’, ‘3’])
[‘1’, ‘2’, ‘3’]
dict_values([‘1’, 2, 3])
dict_items([(‘1’, ‘1’), (‘2’, 2), (‘3’, 3)])
<dict_keyiterator object at 0x0000015F2C7BD908>

3、集合set——无value版本的字典

无序、元素不重复、元素可变

1）创建

#创建
set1 = set()
set2 = {1,2,3}

2）集合运算

# 集合运算
set3 = {1,2,3}
set4 = {3,4,5,6}
## 交集
interset = set3&set4
interset2 = set3.intersection(set4)
print(interset)
print(interset2)
## 并集
union1  =set3|set4
union2 = set3.union(set4)
print(union1)
print(union2)
## 差集
diff1 = set3-set4
diff2 = set3.difference(set4)
print(diff1)
print(diff2)
diff3 = set4-set3
diff4 = set4.difference(set3)
print(diff3)
print(diff4)
## XOR集合，非相交部分
xor1 = set3^set4
xor2 = set3.symmetric_difference(set4)
print(xor1)
print(xor2)

{3}
{3}
{1, 2, 3, 4, 5, 6}
{1, 2, 3, 4, 5, 6}
{1, 2}
{1, 2}
{4, 5, 6}
{4, 5, 6}
{1, 2, 4, 5, 6}
{1, 2, 4, 5, 6}

3）其他操作

set5 = {1,2,3,4,5}
print(set5)
set5.add(6)
print(set5)
set5.remove(6)
print(set5)
set5.pop()
print(set5)
set5.clear()
print(set5)

{1, 2, 3, 4, 5}
{1, 2, 3, 4, 5, 6}
{1, 2, 3, 4, 5}
{2, 3, 4, 5}
set()

数据类型总结

数据类型	元素支持类型	元素可变性	元素有序性	查找元素的方法
字符串	字符	不可变	有序	根据下标索引
列表	所有数据类型	可变	有序	根据下标索引
字典	键(key)：不可变数据类型(tuple、str、字符、数值类型等)、可hash的数据类型；值(value):所有数据类型即可	可变	无序	根据键key查找
集合	所有数据类型（元素不重复）	可变	无序	/
元组	所有数据类型	不可变	有序	根据下标索引

参考文献

https://www.cnblogs.com/f-ck-need-u/p/9832640.html