目录
1.1.set可以理解为一个只有key的字典，所有里面的元素都是唯一的，天生去重
一、list列表
1.列表的定义
#方式一
lst1 = []
print("method1:", type(lst1))
#方式二
lst2 = list()
print("method2:", type(lst2))
#list()为工厂函数，可以把其他数据类型转换为list
#若在list()中传递的是可迭代对象时，可挨个存入列表
lst3 = list("123abc")
print("lst3 is", lst3)
2.list特点
2.1.list为有序项目集合
lst = ["a", "b", "c", "d", "e"]
#输出列表第2个元素
print(lst[1])
#lst[-1:2:-2] 其中-1为起始位置，2为结束位置(不包括)，-2位步长
#正数表示从前往后 负数表示从后往前
print(lst[-1:2:-2])
2.2.list为可变数据类型
可变数据类型就是在原内存地址空间上，可以修改
lst = ["abc", "123"]
#id()内置函数返回对象的内存地址
print("the id before modifing is", id(lst))
#尝试直接修改原list，查看内存地址是否改变
lst[1] = "xxyy"
print("the id after modifing is", id(lst))
#如果直接修改不可变数据类型，会报错
#string为不可变数据类型
str1 = "abc"
try:
#尝试修改str1的第1个元素
str1[0] = "x"
print("modify successful!")
except TypeError as err:
print(err)
2.3.list可以存放任何数据类型
#print表示存放内置函数
lst = ["a", 3.4, 4, [1], print]3.list的增删改查
3.1.list的新增
| 函数 | 具体作用 |
| appen() | 往列表末尾追加元素 |
| insert() | 在指定位置插入元素 |
| extend() | 传入的元素为可迭代对象，依次向末尾插入每个元素 |
lst = ["aa", "12", "bb"]
lst.append("xxx")
print("after append:", lst)
lst.insert(2, "***")
print("after insert:", lst)
lst.extend("123")
print("after extend:", lst)
3.2.list的运算
lst1 = [1, 2]
lst2 = [3, 4]
print("lst1 + lst2 =", lst1 + lst2)
print("lst1 * 3 =", lst1 * 3)
3.3.list的删除
| 函数 | 具体作用 |
| pop() | 默认删除末尾元素，也可以指定下标删除 可以返回删除的值 |
| remove() | 指定元素删除，元素不存在会报错 |
| del语句 | 删除切片 |
| clear() | 删除全部元素 |
lst = ["a", "b", 1, 2, "c", "d"]
value = lst.pop()
print("delete the end of list:", lst)
print("the value of deleting:", value)
lst.pop(0)
print("delete the first of list:", lst)
try:
lst.remove("d")
print("delete success!")
except:
print("delete fail!")
del lst[2:]
print("delect the a slice of list:", lst)
lst.clear()
print("delete all elements:", lst)
3.4.list的修改
lst = ["a", "b", "c", "e", "f"]
#通过下标修改
lst[2] = "***"
print("after modifying by index:", lst)
#通过切片修改，赋值对象是一个可迭代对象
lst[3:] = "123"
print("after modifying by slice:", lst)
4.统计
| 函数 | 具体作用 |
| len() | 统计列表的长度 |
| count() | 统计指定元素在列表中出现的次数 |
| index() | 返回指定元素在列表中出现的下标位置，若有指定元素有多个，返回第一个元素的下标 |
lst = ["a", "a", "d", "d", "e"]
print("the length of list:", len(lst))
print("the count of a:", lst.count("a"))
try:
print("the index of d:", lst.index("d"))
except ValueError as err:
print(err)
5.list的拷贝
若直接使用"lst2 = lst1"进行复制，lst1与lst2指向的就是同一个对象，若改变lst2中的值也会对lst1中的值产生影响，可以使用copy()进行浅拷贝--仅拷贝类型的值
lst1 = ["a", "b", "c", "d", "e", "f"]
lst2 = lst1.copy()
#修改lst2的值 不会对lst1产生影响
lst2[2] = "***"
print("lst1 is", lst1)
print("lst2 is", lst2)
#以切片的方式也可以实现浅拷贝
lst3 = lst1[:]
lst3[3] = "***"
print("lst1 is", lst1)
print("lst3 is", lst3)
6.list的反转--reverse
lst = ['a', 'b', 'c', 'd', 'e', 'f']
lst.reverse()
print("reverse list:", lst)
7.list的排序--sort
sort方法默认对列表进行升序排序，若列表内元素是数字，则按照数字从小到大进行排序；若列表内元素为字符串，则按照字符串所有字符的Unicode码之和进行排序
lst = ['f', 'e', 'd', 'c', 'b', 'a']
lst.sort()
print("asc:", lst)
#降序排序
lst.sort(reverse=True)
print("desc:", lst)
8.list的遍历
lst = ["abc", "aa", "xx", "xyz"]
# 依次取列表中的元素
for i in lst:
print(i)
# enumerate返回下标和值
print("key --> value")
for k, v in enumerate(lst):
print(f"{k} --> {v}")
二、tuple元组
1.tuple的定义
t1 = ()
print(type(t1))
t2 = (1, ) #初始元组只有一个元素时，后面要打逗号，没有逗号为int类型
t3 = (1)
print(f"type of t2 is {type(t2)}, type of t3 is {type(t3)}")
2.tuple的特点
2.1.有序项目集合
2.2.可以存放任何数据类型
2.3.不可变数据类型
不可以更改元组中的数据，但如何想要修改的数据为可变类型时，那么这个元素又是可以修改的，如：list等
t1 = ("abc", 3, 4.5, [1, 2])
try:
t1[0] = "a"
print("modify success!", t1)
except TypeError as err:
print(err)
# 修改tuple中存放的list类型的数据(可变数据类型)
try:
t1[3][0] = 2
print("modify success!", t1)
except TypeError as err:
print(err)
三、dict字典
1.dict的特点
1.1.键值映射的数据结构 key--value
字典的key，天生去重，且key必须是可hash对象(不可变数据类型)
字典的value可以是任何值
1.2.无序项目集合，没有直接的index索引
1.3.可变数据类型
2.dict的取值
2.1.使用key直接取值
d1 = {"name": "sumeng", "age": 18}
print(d1["name"])
# 没有想要获取的key值时会报错
try:
print(d1["xxx"])
except:
print("get error")
2.2.使用get取值
get属性获取值时如果找不到指定的key，不会报错会直接返回None，get还可以设置默认值
d1 = {"a": 1, "b": 2}
print("the value of a is", d1.get("a"))
# 若字典key没有c，则返回0
print("the value of c is", d1.get("c", 0))
3.字典的遍历
d1 = {"a": 1, "b": 3}
# 直接进行循环遍历取值，取到的为key值
for i in d1:
print(f"key is {i}")
# 使用items方法返回key和value
for i in d1.items():
print(f"(key, value) is {i}")
for k, v in d1.items():
print(f"{k} --> {v}")
4.dict的成员关系判断
d1 = {"a": 1, "b": 3, "c": 5}
# 使用in关键字判断指定值是否在字典中--默认情况下判断的是key值
print("if a in d1:", "a" in d1)
# 使用values返回字典的所有value值
print(f"the values of dict is", d1.values())
# 使用keys返回字典中所有的key值
print(f"the keys of dict is", d1.keys())
5.dict的删除
d1 = {"a": 1, "b": 2, "c": 3}
# pop删除指定元素，返回指定删除key的values值
value1 = d1.pop("a")
print("deleted value is", value1)
# popitem删除存储的最后一个，返回被删除的(key, vlaue)元组
value2 = d1.popitem()
print("deleted (key, value) is", value2)
6.dict的合并
d1 = {"a": 1, "b": 2}
d2 = {"c": 3, "d": 4}
# 直接改变的d1的内容，将d2合并到d1中去
d1.update(d2)
print(f"method1: {d1}")
# 合并生成新字典
d3 = dict(d1, **d2)
print(f"method2: {d3}")
7.dict与str格式的转换
使用JSON库
import json
d1 = {"zhangsan": {"age": 18, "hobby": "basketball"},
"lisi": {"age": 18, "hobby": "music"}}
# dict --> str
d1_str = json.dumps(d1)
print(f"the type of d1_str is {type(d1_str)}")
# str --> dict
d2 = json.loads(d1_str)
print(f"the type of d2 is {type(d2)}")
四、set集合
1.set的特点
1.1.set可以理解为一个只有key的字典，所有里面的元素都是唯一的，天生去重
该特点可以用于类型的转换，实现去重
1.2.无序项目集合
1.3.可变数据类型，但集合中的元素必须是不可变数据类型
2.set的新增
s1 = {1, 2, 3}
# 新增1个元素
s1.add(4)
print(f"after add:", s1)
# 一次性新增多个元素update--传递可迭代对象
s1.update("abc")
print(f"after update:", s1)
3.set的删除
s1 = {1, 2, 3, 4, 'a', 'c', 'b'}
# 使用remove删除元素，若要删除的元素set中没有会报错
s1.remove(4)
print("after remove:", s1)
# 使用discard删除元素，要删除的元素不在set中也不会报错
s1.discard("x")
print("after discard:", s1)
4.集合运算
s1 = {1, 2, 3, 4}
s2 = {2, 4, 5, 6}
# 交集
print("s1 & s2 =", s1 & s2)
# 并集
print("s1 | s2 =", s1 | s2)
# 差集
print("s1 - s2 =", s1 - s2)
print("s2 - s1 =", s2 - s1)
# 对称差集--在s1、s2中，但不同时在两个里面
print("s1 ^ s2 =", s1 ^ s2)
五、面试相关问题
列表与元组的区别
1.列表为可变数据类型，支持增删改操作，元组为不可变数据类型，无法进行增删改操作，只能整体替换
2.由于列表为可变数据类型，所以不能作为字典的key值，但元组可以
3.存储时，空列表比空元组多占用16个字节
4.列表定义时使用中括号[]，而元组定义时使用圆括号()
字典与集合的区别
字典是一系列无序的组合，其中的元素是一堆key(键)和value(值)的配对
集合是一系列无序、唯一的元素组合，但没有键和值的配对
3768
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
