python中复杂数据类型的操作方法

目录

一.list和tuple的区别

二.序列

1.字节

2.字符串

3.元组

4.列表

三.list中所有方法的使用

四.将元组和列表转化为字典

五.dict中所有方法的使用

六.list或dict浅拷贝画图加代码解释

---

一.list和tuple的区别

list和tuple都属于序列，可以储存不同种类的数据类型，元素之间用“，”隔开。

list属于可变的数据类型，对列表可实现元素修改的操作方法。tuple属于不可变的数据类型，如果在tuple中嵌套了list的数据类型，此时的tuple也可以修改。

例：

tuple_var = (1, 5, "hello", ["python", 256])
tuple_var[3][0] = "hello"
print(tuple_var)


#执行结果
(1, 5, 'hello', ['hello', 256])

进程已结束,退出代码0

二.序列

在python中的序列主要包含四种数据类型：字节，字符串，元组，列表

1.字节

字节（bytes）

python中，bytes是以字节为单位来处理的

通过将b' ' 赋值给一个变量来创建bytes

bytes_var = b'101010'
print(bytes_var)

2.字符串

字符串（str）

字符串是python中最常见的数据类型，一般使用（'或"）来创建字符串，多行字符串可以使用（'''或"""）来表示。

创建字符串只需要为变量分配一个值即可，

str_var1 = "hello world!!"
str_var2 = 'python'
print(str_var1, str_var2)

3.元组

元组（tuple）

元组是一种有序且不可更改的序列，允许重复成员出现

元组用（）定义，元素之间使用  ，   分隔。

tuple_var = (1, b'', "python", 2.1, (), [])
print(tuple_var)

4.列表

列表（list）

列表是一种有序可变的序列，允许重复成员的出现

列表用[ ]定义，元素之间使用“，”隔开

list_var = [3.14, 26, "python", b'', (), [], 1+2j]
print(list_var)

三.list中所有方法的使用

list.append(元素）   将某个元素添加在列表的末尾

list_var = [1, 2, 5, 8]
list_var.append("hello")
print(list_var)

list.extend(元素)      将列表或者元组等其它数据类型拼接在list后面

list_var1 = [1, 3, 8, 25]
tuple_var1 = (9, 'hello', b'')
list_var1.extend(tuple_var1)
print(list_var1)

list.insert(元素)        在指定位置插入指定元素

list_var2 = ['helle', 'nihao', 3.14]
list_var2.insert(1, 666)
print(list_var2)

list.pop(元素)           删除并返回指定位置的元素,未指定位置时默认删除最后一项

list_var3 = ['nihao', 'book', 'phone', 66]
list_data = list_var3.pop(1)
print(list_data,list_var3)

list.remove(元素)        删除序列中第一个出现的指定元素使用remove之前要先判断在序列中有没有对应的元素

list_var4 = ['nihao', 'python', 25, 3.14, 'nihao', 25]
print(list_var4.count('nihao'))         #返回'nihao'在列表中出现的次数
list_var4.remove('nihao') 
print(list_var4)

list.count(元素)          返回列表中指定元素出现的次数

list_var5 = ['nihao', 'apple', 'python', 3.14, 3.14]
list_data = list_var5.count(3.14)
print(list_data)

list.index(元素)          返回指定元素在列表中第一次出现的索引位置

list_var6 = ['nihao', 5, 5, 3.14]
list_data = list_var6.index(3.14)
print(list_data)

list.reverse()             反转列表（倒置）

list_var7 = [1, 2, 3, 4]
list_var7.reverse()
print(list_var7)

list.clear()                        清空列表

list_var8 = [1, 3, 5, 5]
list_var8.clear()
print(list_var8)

list.sort()                          给列表中的元素排序，默认从小到大，（）中传入reverse=True,则从大到小排序

list_var9 = [1, 5, 6, 21, 18, 25, 6, 5]
list_var9.sort()
print(list_var9)
list_var9.sort(reverse=True)
print(list_var9)

list.copy()                     返回一个浅拷贝的列表

list_var9 = [1, 5, 6, 21, 18, 25, 6, 5]
list_data = list_var9.copy()
print(list_var9, list_data)
print(id(list_var9))
print(id(list_data))

四.将元组和列表转化为字典

字典是一种无序，可变的集合。没有重复元素

映射关系：拥有键和对应的值，称为键值对。值可以使用任何数据类型，但是键只能是不可变的数据类型，比如：字符串，数字或者元组。

1.将元组转化为字典

tuple_var = ((1, 'python'), (5, 'apple'), ('nihao', 666))
dict_data = dict(tuple_var) 
print(dict_data)

2.将列表转化为字典

list_var = [(1, 99), ('nihao', 666)]
dict_data = dict(list_var)
print(dict_data)

五.dict中所有方法的使用

dict.clear()                  清空字典

dict_var = {1: 2, 6: 9}
dict_var.clear() 
print(dict_var) 

dict.copy()              浅拷贝

dict_var = {5: 6, 9:12}
dict_data = dict_var.copy()
print(dict_var, dict_data)
print(id(dict_var), id(dict_data))

dict.formkeys()        使用可迭代对象中的键和值设置为value的值创建一个新字典

list_var = ['nihao', 'hello']
dict_var = {5: 6, 9: 12}
dict_data = dict_var.fromkeys(list_var, 25)
print(dict_var, dict_data)

dict.get(键)                    通过键获取值，键不存在返回默认值

dict_var = {5: 6, 9: 12}
dict_data = dict_var.get(5)
print(dict_data)

dict.items()                     返回字典中所有的键值对组成的列表

dict_var = {5: 6, 9: 12, 'hello': 18}
dict_data = dict_var.items()
print(dict_data)

dict.keys()                       返回字典中所有的键组成的列表

dict_var = {'hello': 666, 'nihao': 25, 12: 25}
dict_data = dict_var.keys()
print(dict_data)

dict.values()                       返回字典中所有的值组成的列表

dict_var = {'hello': 666, 'nihao': 25, 12: 5}
dict_data = dict_var.values()
print(dict_var, dict_data)

dict.pop(键)                    删除并返回指定键的键值对

dict_var = {'hello': 666, 'nihao': 25, 12: 5}
dict_data = dict_var.pop(12)
print(dict_var, dict_data)

dict1.updata(dict2)           字典1合并字典2，对于在字典1中存在的键，使用字典2的值进行数据覆盖            

dict_var1 = {'hello': 666, 'nihao': 25, 12: 5}
dict_var2 = {'hello': 88, 15: 25 }
dict_var1.update(dict_var2)
print(dict_var1)

   dict.popitem()                           按照先进后出的原则，删除字典的元素并以（key,value)元组返回。如果字典为空，则引发KeyError

dict_var = {'hello': 666, 'nihao': 25, 12: 5}
dict_data = dict_var.popitem()
print(dict_var, dict_data)



#执行结果
{'hello': 666, 'nihao': 25} (12, 5)

进程已结束,退出代码0

dict.setdefault()             如果键不存在于字典中，将会添加键并将值设为默认值

dict_var = {'hello': 666, 'nihao': 25, 12: 5}
dict_var.setdefault('abc')
print(dict_var)



#执行结果
{'hello': 666, 'nihao': 25, 12: 5, 'abc': None}

进程已结束,退出代码0

六.list或dict浅拷贝画图加代码解释

赋值运算（a=b）,相当于给列表对象挂上a和b的标签，使用的是同一个内存地址

a=[2,5,6,8,[5,4,3,[1,2]]]
b=a
print(id(a))
print(id(b))


#执行结果
2130390972736
2130390972736

进程已结束,退出代码0

浅拷贝：list中的copy方法是浅拷贝，我们定义了一个a变量并创建了一个列表对象，接着又把对象拷贝给c，我们可以使用id方法查看内存地址，当然浅拷贝只能拷贝对象第一层，不会拷贝子对象，所以内存地址必然会不同。

a = [2, 5, 6, 8, [5, 4, 3, [1, 2]]]
c = a.copy()
print(id(a))
print(id(c))


#执行结果
2507561793856
2507562036992

进程已结束,退出代码0

  

如果只改变c中第一层的数据的话，a不会发生变化

a = [2, 5, 6, 8, [5, 4, 3, [1, 2]]]
c = a.copy()
c[1] = 25
print(a)
print(c)



#执行结果
[2, 5, 6, 8, [5, 4, 3, [1, 2]]]
[2, 25, 6, 8, [5, 4, 3, [1, 2]]]

进程已结束,退出代码0

如果改变c中第二层数据的话，那么a,c都会发生变化

a = [2, 5, 6, 8, [5, 4, 3, [1, 2]]]
c = a.copy()
c[4][1] = 15
print(a)
print(c)

#执行结果
[2, 5, 6, 8, [5, 15, 3, [1, 2]]]
[2, 5, 6, 8, [5, 15, 3, [1, 2]]]

进程已结束,退出代码0