【Python基础入门技能树笔记】数据类型-复合数据类型

文章目录

3. 复合数据类型
- List列表
- - 创建
  - 增
  - - 列表加法
    - 列表乘法
  - 查
  - - 索引
    - 切片
  - 删、改
  - 列表推导式
  - 常用函数
- Tuple元组
- - 创建
  - 推导式
  - 常用函数
- Dict字典
- - 创建
  - 增
  - 删
  - 改
  - 查
  - 常用函数
  - 字典的遍历
  - 字典推导式
- Set集合
- - 创建
  - 增
  - 删
  - 集合的运算方法
  - 集合推导式
  - 不可变集合

3. 复合数据类型

List列表

创建

变量名 = [元素1,元素2,…,元素n]

list类型中区分元素的顺序，且允许包含重复的元素。

增

列表加法

多个列表可以通过加法进行拼接，如下

lst1 = [1,2,3,4]
lst2 = ['a','b','c',666]
print(lst1)
print(lst1 + lst2)

结果：

[1, 2, 3, 4]
[1, 2, 3, 4, 'a', 'b', 'c', 666]

列表相加并非列表元素两两相加，而是将两个列表拼接在一起，并返回新的列表。

列表乘法

列表乘法是指列表与一个整数N相乘，这会将列表中的元素重复N次，并返回到一个新的列表，如下

lst2 = ['a','b','c',666]
print(lst2 * 3)

结果

['a', 'b', 'c', 666, 'a', 'b', 'c', 666, 'a', 'b', 'c', 666]

查

索引

列表每一个元素都对应一个整数型的索引值，可以通过索引值来得到相应的元素值。同时支持列表元素的正向索引和反向索引。

正向索引即索引值为正，从0开始；
反向索引即索引值为负，从-1开始。若是反向索引，则-1为末尾元素对应的索引编号。

lst2 = ['a','b','c',666]
print(lst2[1],lst2[-1])

结果：

b 666

切片

切片操作可以截取列表变量中的部分元素，并返回一个子列表变量。

切片操作中，生成子列表的元素包含起始索引对应的元素，但是不包含终止索引对应的元素。

lst2 = ['a','b','c',666]
print(lst2[1:3])

结果：

['b', 'c']

切片这里截取的是原片段，而不是副本，对切片修改，原列表也会修改

删、改

通过索引值或切片对相应元素进行修改或删除。

lst2 = ['a','b','c',666]
lst2[2] = 'jntm'
print(lst2)
lst2[1] = 'kbqn'
print(lst2)
lst2[1:3] = [1,2]
print(lst2)

结果：

['a', 'b', 'jntm', 666]
['a', 'kbqn', 'jntm', 666]
['a', 1, 2, 666]

删除整个列表或列表中的部分元素，使用del命令。删除整个列表后，不可再次引用。

列表推导式

列表推导式会遍历后面的可迭代对象,然后按照for前的表达式进行运算,生成最终的列表.
如果有if条件语句,for遍历后紧跟着进行条件判断.
如果有多个for循环,则最终的数据数量为多个for循环的笛卡尔积.
可以进行嵌套的列表推导,与嵌套for循环的原理相同.

lst = [e for e in range(3)]
print(lst)lst2 = [e for e in range(3) for f in range(e+1,e+3)]
print(lst2)
lst22 = []
for e in range(3):for f in range(e+1,e+3):lst22.append(e)print(lst22)lst3 = [e for e in range(10) if (e != 5) & (e % 2 == 1)]# 多个条件，请带括号
print(lst3)
lst33 = []
for e in range(10):if (e != 5) & (e % 2 == 1):lst33.append(e)print(lst33)lst4 = [e for e in "python" if e != "o"]
print(lst4)lst5 = [[e for e in range(g) if e !=1] for g in range(2,5) if g != 3]
print(lst5)
lst55 = []
for g in range(2,5):if g != 3:temp = []for e in range(g):if e != 1:temp.append(e)lst55.append(temp)print(lst55)

结果：

[0, 1, 2]
[0, 0, 1, 1, 2, 2]
[0, 0, 1, 1, 2, 2]
[1, 3, 7, 9]
[1, 3, 7, 9]
['p', 'y', 't', 'h', 'n']
[[0], [0, 2, 3]]
[[0], [0, 2, 3]]

常用函数

append函数用于向列表末尾添加元素。该函数没有返回值，它只是修改了当前列表
extend函数用于在列表的末尾添加另一个列表，与append函数相比，extend函数可以一次性添加多个元素

insert函数用于依据索引位置，向列表中插入元素。该函数，没有返回值，而是直接将元素插入当前列表。insert函数的第一个参数是插入的位置，第二个参数是要插入的对象

lst = [4,4,2,3]
lst.insert(1,0)
print(lst)

结果：

[4, 0, 4, 2, 3]

remove函数用于依据元素本身，从列表移除元素。该函数没有返回值，直接操作原列表
若列表中有重复元素，remove函数只会移除匹配到的第一个。

lst = [4,4,6,3]
lst.remove(6)
print(lst)

结果

print(lst)

pop函数用于移除列表中指定位置的元素，并返回要移除的元素。在默认情况下，移出列表中最后一个元素

lst = [4,4,6,7]
print(lst.pop(3))
print(lst)

结果：

7
[4, 4, 6]

reverse函数用于将列表反向排列

copy函数用于创建列表的副本。
删除a列表元素不会对其副本b造成影响

index函数用于返回所匹配的元素的索引。该函数的第一个参数是待查找的对象，第二个参数是查找的起始范围，第三个参数是查找的结束范围
count函数用于统计某个元素在列表中出现的次数

lst = [1,1,0,1,0,1,1,0,1,1,1,0]
num = lst.count(0)
e = 1
for i in range(num):e = lst.index(0,e+1,len(lst))print(e)

结果：

Tuple元组

创建

变量名 = (元素1,元素2,…,元素n)

注意：
当元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用。

由于元组中的元素值是不允许修改的，因此元组的元素没有增、删、改
元组的查和列表一样

推导式

不知道算不算

tup = (e for e in range(6))
print(tuple(tup))

结果：

(0, 1, 2, 3, 4, 5)

常用函数

index、count和列表相同

operator.eq比较两个传入的值是否一致，常用于元组

import operatorlst = [1,2]
lst1 = lst.copy()
lst2 = lst
print(operator.eq(lst,lst1))
print(operator.eq(lst,lst2))

结果：

True
True

Dict字典

字典是无序的所以不支持索引和切片

key不可以重复，否则只会保留第一个，value值可以重复;
key可以是任意的数据类型，但不能出现可变的数据类型（list列表、dict字典、set集合），保证key唯一;

创建

dic = {"name": "张三", "age": 18, "sex": "男"}
dic1 = {}

增

dic = {"name": "张三", "age": 18}
dic["sex"] = "男"
print(dic)

结果：

{'name': '张三', 'age': 18, 'sex': '男'}

删

就是用del删除key

dic = {"name": "张三", "age": 18}
del dic["age"]
print(dic)

结果：

{'nane': '张三'}

改

就是用旧的key搭配新的value，覆盖旧的value，即强制更新，没有key增加key、value，就算有key也更新为新的value，可以用键值对的方式

dic = {"name": "张三", "age": 18}
dic["age"] = 100
print(dic)

结果：

{'nane': '张三', 'age': 100}

dict.setdefault(k,value)
如果key值存在，那么返回对应字典的value，不会用到自己设置的value
如果key值不存在。返回None，并且把新设置的key和value保存在字典中
如果key值不存在，但设置了value，则返回设置的value

dic = {"name": "张三", "age": 18}print(dic.setdefault("name"))
print(dic.setdefault("name",666))
print(dic)print(dic.setdefault("sex"))
print(dic)del dic["sex"]print(dic.setdefault("sex","男"))
print(dic)

结果：

张三
张三
{'name': '张三', 'age': 18}
None
{'name': '张三', 'age': 18, 'sex': None}
男
{'name': '张三', 'age': 18, 'sex': '男'}

查

就是把key当索引，看value

dic = {"name": "张三", "age": 18}
print(dic["name"])

结果：

张三

dict.get(k,default)

如果key在字典中存在，则返回字典中的值
如果key在字典中不存在，则返回default值，如果没设定default，则返回None

dic = {"name": "张三", "age": 18}print(dic.get("age",666))
print(dic.get("sex",888))
print(dic.get("sex"))

结果：

18
888
None

常用函数

len(dict) 测量字典中键值对个数
dict.keys() 返回字典中所有的key
dict.values() 返回包含value的列表

dict.items() 返回包含(键值,实值)元组的列表
in \ not in 判断key是否存在字典中

dic = {"name": "张三", "age": 18}
print(dic.items())
print(18 in dic)
print("age" in dic)

结果：

dict_items([('name', '张三'), ('age', 18)])
False
True

字典的遍历

dic = {"name": "张三", "age": 18}for i in dic.items():print(i)for i in dic.keys():print(i,dic[i],dic.get(i))for i in dic.values():print(i)for i in enumerate(dic):print(i,dic[i[1]],dic.get(i[1]))

结果：

('name', '张三')
('age', 18)
name 张三 张三
age 18 18
张三
18
(0, 'name') 张三 张三
(1, 'age') 18 18

字典推导式

类似列表推导式，甚至for的执行顺序都是类似的

dic = {k:v for k in "python" for v in range(6)}
print(dic)dic1 = {}
for k in "python":for v in range(6):dic1[k]=vprint(dic1)dic2 = {k:v for k,v in zip("python",range(6))}
print(dic2)dic3 = {k:v for k,v in [[i,j]for i,j in zip("python",range(6))]}
print(dic3)

结果：

{'p': 5, 'y': 5, 't': 5, 'h': 5, 'o': 5, 'n': 5}
{'p': 5, 'y': 5, 't': 5, 'h': 5, 'o': 5, 'n': 5}
{'p': 0, 'y': 1, 't': 2, 'h': 3, 'o': 4, 'n': 5}
{'p': 0, 'y': 1, 't': 2, 'h': 3, 'o': 4, 'n': 5}

Set集合

集合中的每一个元素不能出现多次，并且是无序存储的

由于集合中的元素不能出现多次，这使得集合在很大程度上能够高效地从列表或元组中删除重复值，并执行取并集、交集等常见的的数学操作。

集合本身就可以被迭代（字符串，列表，元组也是）

创建

se = set()
se1 = set([3,1,2,1])
print(se)
print(se1)

结果：

set()
{1, 2, 3}

增

add方法

se1 = set([3,1,2,1])
se1.add("Python")
print(se1)

结果：

{1, 2, 3, 'Python'}

就像字典的键一样，不能把可变数据类型放到集合里

删

remove方法从集合中删除一个指定值，如果指定值不存在，会报错
discard方法，从集合中删除一个指定值，类似字典的get

se1 = set([3,1,2,1])
se1.discard("Python")
print(se1)
se1.discard(2)
print(se1)

结果：

{1, 2, 3}
{1, 3}

pop方法从集合中删除并且返回一个任意的值，需要注意的是，如果集合是空的，会报错

集合的运算方法

并：union
交：intersection
差：difference
对称：symmetric_difference

se1 = set([3,1,2,1])
se2 = set([2,3,4])
print(se1.union(se2))
print(se1.intersection(se2))
print(se1.difference(se2))
print(se1.symmetric_difference(se2))

结果

{1, 2, 3, 4}
{2, 3}
{1}
{1, 4}

这些方法后面都可以加上_upgrade，将返回值赋予se1，返回None

集合推导式

集合也有推导式，和列表类似，不再说明

不可变集合

主要用于构造嵌套集合

不可变集的一个主要的缺点是：由于它们是不可变的，这意味着你不能向其中添加元素或者删除其中的元素。除了值不可以改变，不可变集和可变集是很相似的。

lst = [(1,2),(3,4),(5,6)]se1 = set(lst)
print(se1)se2 = set(frozenset(lst[i])for i in range(len(lst)))
print(se2)fse1 = frozenset([1,2,3])
fse2 = frozenset([3,4,5])
print(fse1.union(fse2))

结果：

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