python字典和列表中具体方法的使用及其列表与元组的区别，和浅拷贝

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上

咸鱼乐

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
python字典和列表中具体方法的使用及其列表与元组的区别，和浅拷贝

目录1.list和tuple的区别1.1 list：1.2 Tuple1.3 区别：2.学到的序列有哪几种3.list中所有方法的使用3.1创建空列表3.2索引，切片3.3加入3.4删除，清空3.5运算3.6反转，排序，计数4.将元组和列表转换成字典5.dict中所有方法的使用6.浅拷贝...
复制链接

扫一扫

专栏目录