目录
1.list和tuple的区别
1.1 list:
1、是一种有序的集合,可以随时添加和删除其中元素;
2、访问list中的元素,索引从0开始,0为第一个元素,当索引超出范围会报错,索引不能越界,最后一个元素的索引是len(num)-1;
3、如果要取最后一个元素,除了计算索引位置之外,还可以用-1做索引直接取到最后一个元素;
4、使用append()可以在list的尾部添加元素;
5、使用insert()可以将元素插入添加到指定位置;
6、使用pop()可以删除list最后一个元素,使用pop(i)其中i是索引号,可以删除指定位置的元素。
1.2 Tuple
1、tuple是一种有序列表,它和list非常相似;
2、Tuple一旦初始化就无法修改,而且没有append()、insert()这些方法,可以获取元素但不能赋值变成另外的元素。
1.3 区别:
list是可变数据类型;tuple是不可变数据类型。
列表不能做字典的关键字,而元素可以;
元组和列表都是可嵌套的,并且元组中嵌套的列表是可变的。
2.学到的序列有哪几种
1.字符串(str):把文本放入单引号、双引号或三引号中。字符串不可以改变;
2.字节(bytes)和str 除操作的数据单元不同之外,它们支持的所有方法都基本相同,bytes是不可变序列。
字符串(str) 由多个字符组成,以字符为单位进行操作;
字节串(bytes) 由多个字节组成,以字节为单位进行操作。
3.列表(list):容器类型,任意对象有序集合,表达式符号:[],通过索引访问其中的元素,可变对象,长度可变,修改指定的索引元素,删除语句。
4.元组(tuple):容器类型,任意对象有序集合,表达式符号:(),通过索引访问其中的元素,不可变对象,长度固定。
3.list中所有方法的使用
3.1创建空列表
直接使用一对空的方括号就可以创建空列表,或者使用 list()
list_var = []
list_var1 = list()
3.2索引,切片
切片可以正着来也可以反着来,正着来的索引就是 [0, len-1] ,反过来的索引是 [-len, -1]。
list_var = [1, 2, 3]
list_var1 = [1, 1.1, 1 + 1j, 'aaa', True, None, b'', (1, 2, 3), list_var, []] # 可以存储不同类型的数据
print(list_var1[3]) # 正向索引
print(list_var1[-3]) # 逆向索引 -1开始
print(list_var1[3:5]) # 选取一片,左闭右开
'''
aaa
(1, 2, 3)
['aaa', True]
'''
3.3加入
添加元素到列表尾部: append()
在指定索引位置插入数据: insert()
list_var = [1, 2, 3]
list_var1 = [1, 1.1, 1 + 1j, 'aaa', True, None, b'', (1, 2, 3), list_var, []] # 可以存储不同类型的数据
list_var1.append("lele")
print(list_var1)
list_var1.insert(0, "lll")
print(list_var1)
'''
[1, 1.1, (1+1j), 'aaa', True, None, b'', (1, 2, 3), [1, 2, 3], [], 'lele']
['lll', 1, 1.1, (1+1j), 'aaa', True, None, b'', (1, 2, 3), [1, 2, 3], [], 'lele']
'''
3.4删除,清空
删除一个元素并返回删除的元素:pop()
清空列表: clear()
删除给定的值第一次出现的元素:remove()
list_var = [1, 2, 3]
list_var1 = [1, 1.1, 1 + 1j, 'aaa', True, None, b'', (1, 2, 3), list_var, []] # 可以存储不同类型的数据
list_var1.remove(1) # 删除第一次出现的元素
print(list_var1)
list_data = list_var1.pop(1) # 可以通过索引删除,默认删除最后一个。返回被删除的元素
print(list_data)
list_var1.clear() # 清空所有元素
print(list_var1)
'''
[1.1, (1+1j), 'aaa', True, None, b'', (1, 2, 3), [1, 2, 3], []]
(1+1j)
[]
'''
3.5运算
使用 + 拼接列表,使用 * 重复
list_var = [1, 2, 3]
list_var1 = list_var + [4, 5]
print(list_var1)
list_var2 = list_var * 2
print(list_var2)
'''
[1, 2, 3, 4, 5]
[1, 2, 3, 1, 2, 3]
'''
3.6反转,排序,计数
reverse() 实现列表反转,sort() 默认实现列表递增排序,设置 reverse 参数可实现降序排序。两者都是原位操作,无返回值
sort() 有两个参数 key 和 reverse:
key 可以是一个 lambda 函数,如果给出了 key 函数,则对每个列表元素应用一次,并根据它们的函数值对它们进行升序或降序排序。
reverse 是一个布尔值,不设置的话默认升序排序,设置为 True 时按照降序排序。
list_var = [1, 9, 6, 45, 12, 8, 9]
print(list_var.count(9)) # 统计9出现的次数
list_var.sort() # 默认升序
print(list_var)
list_var.sort(reverse=True) # 倒序
print(list_var)
list_var.reverse() # 实现列表元素的反转
print(list_var)
'''
2
[1, 6, 8, 9, 9, 12, 45]
[45, 12, 9, 9, 8, 6, 1]
[1, 6, 8, 9, 9, 12, 45]
'''
4.将元组和列表转换成字典
list_var = ['name', 'lele']
list_var1 = ['age', '22']
list_var2 = [list_var, list_var1]
print(dict(list_var2))
tuple_var = (("class", "1903"), ("phone", "15555556"))
print(dict(tuple_var))
'''
{'name': 'lele', 'age': '22'}
{'class': '1903', 'phone': '15555556'}
'''
5.dict中所有方法的使用
5.1clear()
用于清空字典中所有元素(键-值对),对一个字典执行 clear() 方法之后,该字典就会变成一个空字典。
dic1 = {'name': 'lele', 'age': 22, 'sex': '男'}
print(dic1, type(dic1))
dic1.clear()
print(dic1)
'''
{'name': 'lele', 'age': 22, 'sex': '男'} <class 'dict'>
{}
'''
5.2 copy()
用于返回一个字典的浅拷贝。
dic1 = {'name': 'lele', 'age': 22, 'sex': '男'}
dic2 = dic1.copy()
print(dic2)
'''
{'name': 'lele', 'age': 22, 'sex': '男'}
'''
5.3 fromkeys()
使用给定的多个键创建一个新字典,值默认都是 None,也可以传入一个参数作为默认的值。
tuple_var = ("name", "age", "class")
dic2 = dict.fromkeys(tuple_var)
print(dic2)
'''
{'name': None, 'age': None, 'class': None}
'''
dic3 = dict.fromkeys(tuple_var, 'lele')
print(dic3)
'''
{'name': 'lele', 'age': 'lele', 'class': 'lele'}
'''
5.4 get()
用于返回指定键的值,也就是根据键来获取值,在键不存在的情况下,返回 None,也可以指定返回值。
dict_var = {"name": "lele", "age": 22, "class": 1903}
print(dict_var.get("name"))
'''
lele
'''
5.5 items()
获取字典中的所有键-值对,一般情况下可以将结果转化为列表再进行后续处理。
dict_var = {"name": "lele", "age": 22, "class": 1903}
print(dict_var.items())
'''
dict_items([('name', 'lele'), ('age', 22), ('class', 1903)])
'''
5.6 keys()
返回一个字典所有的键。
dict_var = {"name": "lele", "age": 22, "class": 1903}
print(dict_var.keys())
'''
dict_keys(['name', 'age', 'class'])
'''
5.7 pop()
返回指定键对应的值,并在原字典中删除这个键-值对。
dict_var = {"name": "lele", "age": 22, "class": 1903}
print(dict_var.pop("name")) # 返回键所对应的值
print(dict_var) # 删除键值对
'''
lele
{'age': 22, 'class': 1903}
'''
5.8 popitem()
删除字典中的最后一对键和值。
dict_var = {"name": "lele", "age": 22, "class": 1903}
print(dict_var.popitem()) # 返回最后一对键值对,并删除
print(dict_var)
'''
('class', 1903)
{'name': 'lele', 'age': 22}
'''
5.9 setdefault()
和 get() 类似, 但如果键不存在于字典中,将会添加键并将值设为default
dict_var = {"name": "lele", "age": 22, "class": 1903}
print(dict_var.setdefault("age"))
print(dict_var.setdefault("sex"))
print(dict_var)
'''
22
None
{'name': 'lele', 'age': 22, 'class': 1903, 'sex': None}
'''
5.10 update()
字典更新,将字典dict1的键-值对更新到dict里,如果被更新的字典中己包含对应的键-值对,那么原键-值对会被覆盖,如果被更新的字典中不包含对应的键-值对,则添加该键-值对
dict_var = {"name": "lele", "age": 22, "class": 1903}
dict_var1 = {"name": "xilele"}
print(dict_var)
dict_var.update(dict_var1)
print(dict_var)
dict_var2 = {"sex": 'nan'}
dict_var.update(dict_var2)
print(dict_var)
'''
{'name': 'lele', 'age': 22, 'class': 1903}
{'name': 'xilele', 'age': 22, 'class': 1903}
{'name': 'xilele', 'age': 22, 'class': 1903, 'sex': 'nan'}
'''
5.11 values()
返回一个字典所有的值。
dict_var = {"name": "lele", "age": 22, "class": 1903}
print(dict_var.values())
'''
dict_values(['lele', 22, 1903])
'''
6.list或dict浅拷贝画图加代码解释
list_var = ["Will", 28, ["Python", "C#", "JavaScript"]]
list_var1 = list_var.copy()
print(id(list_var))
print(list_var)
for ele in list_var:
print(id(ele))
print("----------------------------")
print(id(list_var1))
print(list_var1)
for ele in list_var1:
print(id(ele))
print("----------------------------")
list_var[0] = "Wilber"
list_var[2].append("CSS")
print(id(list_var))
print(list_var)
for ele in list_var:
print(id(ele))
print("----------------------------")
print(id(list_var1))
print(list_var1, type(list_var1))
for ele in list_var1:
print(id(ele))
分析一下这段代码:
- 首先,使用一个will变量,指向一个list类型的对象
-
然后,通过浅拷贝函数copy(),对will指向的对象进行浅拷贝,然后浅拷贝生成的新对象赋值给wilber变量
- 浅拷贝会创建一个新的对象,这个例子中"wilber is not will"
- 但是,对于对象中的元素,浅拷贝就只会使用原始元素的引用(内存地址),也就是说"wilber[i] is will[i]"
-
当对will进行修改的时候
- 由于list的第一个元素是不可变类型,所以will对应的list的第一个元素会使用一个新的对象2548518188784
- 但是list的第三个元素是一个可不类型,修改操作不会产生新的对象,所以will的修改结果会相应的反应到wilber上