一、list列表类型：

一种有序集合，里面有多个数据用逗号隔开，可以对数据进行追加、插入、删除和替换；使用[]标识，可以包含任意数据类型

# 字符串类型列表
names=['bill','may','jack']

#整数型列表
numbers = [1,2,34,4]

#混合类型列表
values=['Bill',23,23.45,True]
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.

列表的基本操作

创建列表
  • 方法1：list(iterable)函数

使用list(iterable)函数:可迭代对象(字符串、列表、元组、集合和字典等)

  • 方法2：[元素1，元素2，……]

python 数据类型----可变数据类型_元组

通过索引操作列表元素
names = ["Bill", "Mary", "Jack"]
print(names[0])# 运行结果：Bill
print(names[2])# 运行结果：Jack

s = "Hello World"
print(s[0])# 运行结果：H
print(s[3])# 运行结果：l
print("Apple"[2])# 运行结果：p
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
列表封包和列表解包

解包时，变量的数量必须与列表中的元素的个数相同，否则会抛出异常

可以使用通配符(*)部分元素解包

values=10,20,30
#运行结果 <class 'tuple'>
print(type(values))

x,y,z=values
#运行结果10 20 30
print(x,y,z)
#部分解包
a,b,*c =[1,2,3,4,5,6,6,7]
#运行结果 1 2 [3, 4, 5, 6, 6, 7]
print(a,b,c)
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
追加元素

列表是可变的序列对象，可以追加元素

  • 单个元素追加append(x)
  • 多个元素追加：(+)运算符或者列表的extend(t)方法

python 数据类型----可变数据类型_java_02

插入元素

list.insert(i,x)方法，i指定索引位置，x是要插入的元素

python 数据类型----可变数据类型_元组_03

替换元素

直接赋值符号(=)

python 数据类型----可变数据类型_python_04

删除元素
  • list.remove(x)

找到匹配的元素x，则删除该元素，如果多个匹配元素，只删除第一个匹配的元素

python 数据类型----可变数据类型_java_05

  • pop方法
a = [1,2,3,4]
a.pop(1)
print(a)
#>>>[1, 3, 4]
  • 1.
  • 2.
  • 3.
  • 4.
  • del方法
a = [1,2,3,4,'张三']
del a[4]
print(a)
# >>>[1, 2, 3, 4]
  • 1.
  • 2.
  • 3.
  • 4.
list内元素翻转
  • x.reverse()
b = ['李四', '张三', '王二', '赵一' ]
b.reverse()
print(b)
#>>>['赵一', '王二', '张三', '李四']
  • 1.
  • 2.
  • 3.
  • 4.
list内的元素排序

x.sort()升序排序；x.sort(reverse=True)降序排序

a = [4,2,1,3]
a.sort()
print(a)
#>>>[1, 2, 3, 4]
a.sort(reverse=True)
print(a)
#>>>[4, 3, 2, 1]
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
list的切片

列表的切片：分割一个列表，只提取其中某一个片段出来

  • list[start: end: step]
  • start: 从哪里开始，
  • end: 到哪里结束，
  • step: 步长，每几个元素获取一次值 – 默认为1，可以省略；左闭右开(取头不取尾)
lst3 = [100, 3.14, True, "python", [1, 2, 3, 4]]
print(lst3[0])

#切片：
print(lst3[0:2])
#>>>>>>>> [100, 3.14]
print(lst3[0:4])
#>>>>>>>> [100, 3.14, True, 'python']
print(lst3[2:4])
#>>>>>>>> [True, 'python']
print(lst3[0:])
#>>>>>>>> [100, 3.14, True, "python", [1, 2, 3, 4]] end可以省略，默认取到最后
print(lst3[:4]) 
#>>>>>>>> [100, 3.14, True, 'python'] start可以省略，默认从0开始
print(lst3[0::2])
#>>>>>>>> [100, True, [1, 2, 3, 4]] 从0开始，步长为2
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
list的元素统计

统计元素的个数：count() – 判断这个元素在列表中有几个

lst3 = [100, 3.14, True, "python", [1, 2, 3, 4, "python", "python"]]
print(lst3.count("python"))
#>>>>>>>>> 1 count将列表内元素作为参数，返回列表内该元素出现的次数
print(lst3[4].count("python"))
#>>>>>>>>> 2
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
常见方法
  • append：在列表最后插入新的值
  • clear：清除列表内容
  • copy：复制列表
  • count：统计某个元素在列表中出现的次数
  • extend：在列表结尾插入另一个列表，用新列表扩展原有的列表。列表相加产生一个新列表，extend改变被扩展的列表
  • index：从列表中找出某个值第一次出现的索引位置
  • insert：将值插入列表的指定位置
  • pop：移除列表中的元素，默认是最后一个元素，并返回该元素的值
  • remove：移除列表中某个值的第一次匹配项
  • reverse：将列表中的元素反向存放
  • sort：对列表进行排序，改变原来的列表
print("----测试append方法-----")
numbers = [1, 2, 3, 4]
numbers.append(5)  # 将5添加到numbers列表的最后
print(numbers)  # 运行结果：[1, 2, 3, 4, 5]
numbers.append([6, 7])  # 将列表[6,7]作为一个值添加到numbers列表后面
print(numbers)  # [1, 2, 3, 4, 5, [6, 7]]

print("----测试clear方法-----")
names = ["Bill", "Mary", "Jack"]
print(names)
names.clear();  # 清空names列表
print(names)  # 运行结果：[]

print("----测试copy方法-----")
a = [1, 2, 3]
b = a  # a和b指向了同一个列表
b[1] = 30  # 修改列表b的元素值，a列表中对应的元素值也会改变
print(a)  # 运行结果：[1, 30, 3]

aa = [1, 2, 3]
bb = aa.copy()  # bb是aa的副本
bb[1] = 30  # 修改bb中的元素值，aa中的元素值不会有任何变化
print(aa)  # 运行结果：[1, 2, 3]

print("----测试count方法-----")
search = ["he", "new", "he", "he", "world", "peter", [1, 2, 3], "ok", [1, 2, 3]]
#  搜索“he”在search出现的次数，运行结果：3
print(search.count("he"))
#  搜索[1,2,3]在search出现的次数，运行结果：2
print(search.count([1, 2, 3]))

print("----测试extend方法-----")
a = [1, 2, 3]
b = [4, 5, 6]
a.extend(b)  # 将b列表接在a列表的后面，extend方法并不返回值
print(a)  # 运行结果：[1, 2, 3, 4, 5, 6]

# 如果使用列表连接操作，效率会更低，并不建议使用
a = [1, 2, 3]
b = [4, 5, 6]
print(a + b)  # 运行结果：[1, 2, 3, 4, 5, 6]

# 可以使用分片赋值的方法实现同样的效果
a = [1, 2, 3]
b = [4, 5, 6]
a[len(a):] = b
print(a)  # 运行结果：[1, 2, 3, 4, 5, 6]

print("----测试index方法-----")
s = ["I", "love", "python"];
print(s.index("python"))  # 查询”python”的索引位置，运行结果：2
print("xyz在列表中不存在，所以搜索是会抛出异常.")
# str.index("xyz")   # 会抛出异常，因为”xyz”在s列表中不存在

print("----测试insert方法-----")
numbers = [1, 2, 3, 4, 5]
numbers.insert(3, "four")  # 在numbers列表的第4个元素的位置插入一个”four”
print(numbers)  # 运行结果：[1, 2, 3, 'four', 4, 5]
#  可以使用分片赋值实现同样的效果
numbers = [1, 2, 3, 4, 5]
numbers[3:3] = ['four']  # 使用分片赋值在列表中插入另一个列表
print(numbers)  # 运行结果：[1, 2, 3, 'four', 4, 5]

print("----测试pop方法-----")
numbers = [1, 2, 3]
#  pop方法返回删除的元素值
print(numbers.pop())  # 删除numbers列表中的最后一个元素值，运行结果：3
print(numbers.pop(0))  # 删除numbers列表中的第1个元素值，运行结果：1
print(numbers)  # 运行结果：[2]

print("----测试remove方法-----")
words = ["he", "new", "he", "yes", "bike"]
words.remove("he")  # 删除words列表中的第1个”he”
print(words)  # 运行结果：['new', 'he', 'yes', 'bike']
# words.remove("ok")    #  删除不存在的列表元素，会抛出异常

print("----测试reverse方法-----")
numbers = [1, 2, 3, 4, 5, 6]
numbers.reverse()  # 将numbers列表中的元素值倒序摆放
print(numbers)  # 运行结果：[6, 5, 4, 3, 2, 1]

print("----测试sort方法-----")
numbers = [5, 4, 1, 7, 4, 2]
numbers.sort()  # 对numbers列表中的元素值按升序排序(默认)
print(numbers)  # 运行结果：[1, 2, 4, 4, 5, 7]

values = [6, 5, 2, 7, "aa", "bb", "cc"]
# 待排序列表的元素类型必须是可比较的，字符串和数值类型不能直接比较，否则会抛出异常
# values.sort()  #  抛出异常

# 使用sort方法排序，会直接修改原列表，如果要想对列表的副本进行排序，可以使用下面的代码
# 方法1：使用分片操作
x = [5, 4, 1, 8, 6]
y = x[:]
y.sort();  # 对列表的副本进行排序
print(x)  # 运行结果：[5, 4, 1, 8, 6]
print(y)  # 运行结果：[1, 4, 5, 6, 8]

# 方法2：使用sorted函数
x = [7, 6, 4, 8, 5]
y = sorted(x)  # 对x的副本进行排序
print(x)  # 运行结果：[7, 6, 4, 8, 5]
print(y)  # 运行结果：[4, 5, 6, 7, 8]

# sorted函数可以对任何序列进行排序，例如对字符串进行排序
print(sorted("geekori"))  # 运行结果：['e', 'e', 'g', 'i', 'k', 'o', 'r']

x = [5, 4, 1, 7, 5]
x.sort(reverse=True)  # 对列表x中的元素值降序排列
print(x)  # 运行结果：[7, 5, 5, 4, 1]
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.
  • 35.
  • 36.
  • 37.
  • 38.
  • 39.
  • 40.
  • 41.
  • 42.
  • 43.
  • 44.
  • 45.
  • 46.
  • 47.
  • 48.
  • 49.
  • 50.
  • 51.
  • 52.
  • 53.
  • 54.
  • 55.
  • 56.
  • 57.
  • 58.
  • 59.
  • 60.
  • 61.
  • 62.
  • 63.
  • 64.
  • 65.
  • 66.
  • 67.
  • 68.
  • 69.
  • 70.
  • 71.
  • 72.
  • 73.
  • 74.
  • 75.
  • 76.
  • 77.
  • 78.
  • 79.
  • 80.
  • 81.
  • 82.
  • 83.
  • 84.
  • 85.
  • 86.
  • 87.
  • 88.
  • 89.
  • 90.
  • 91.
  • 92.
  • 93.
  • 94.
  • 95.
  • 96.
  • 97.
  • 98.
  • 99.
  • 100.
  • 101.
  • 102.
  • 103.
  • 104.
  • 105.
  • 106.
  • 107.
  • 108.
  • 109.
  • 110.
  • 111.
需要注意的点

由于列表是可变类型，因此如果使用浅拷贝会改变原始值、目标值。

b=[3,2] #原始值
print(b)  #  输出结果 [3, 2]
c=b #浅拷贝 C为目标值

c[0]=1 
print(b) #目标值改变导致原始值改变 输出结果 [1, 2]
print("//")
print(c)  # 输出结果 [1, 2]
b[0]=4 
print(c) #原始值改变导致目标值改变 输出结果 [1, 2]
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.

若不想改变可用深拷贝

##深拷贝互不影响
import copy
b=[3,2] #原始值
print(b)  # 输出结果 [3, 2]
c=copy.deepcopy(b) #深拷贝 C为目标值

c[0]=1 
print(b) #目标值改变，不影响原始值  输出结果 [3, 2]
print("//")
print(c) # 输出结果[1, 2]
b[0]=4 
print(c) #原始值改变，不影响目标值 # 输出结果[1, 2]
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.

二、dict字典类型：

用于存储关联关系的数据，标识{键:值, key:value}键值对之间用逗号隔开， 字典中key值具有唯一性，不能重复

a = {'x': 10, 'y': 20}
print(a, type(a))
#>>>{'x': 10, 'y': 20} <class 'dict'>
  • 1.
  • 2.
  • 3.

创建字典

  • dict()函数,通过列表(元组)或命名参数建立字典
  • {key1:value1,key2:value2,……key_n:value_n}
items =[["bill","1234"],("Mike",'423'),["mary",'34234']]
d = dict(items)
print(d)
# 使用命名参数
dict_items = dict(name='Bill',number=2542,grade='A')
print(dict_items)
dict_item={'color': 'red', 'size': '20', 'type': 'bold'}
print(dict_item)

# 通过zip()函数将两个可迭代对象打包成元组，第一个参数是字典的键，第二个参数为字典值
dict_ = dict(zip([102,103,104],['路人甲','路人乙','路人丙'])
print(dict_)
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.

字典的基本操作

1、dict内访问键值对

print(a[‘key’])    通过字典内的key可直接获取value

a = {'x': 10, 'y': 20}
print(a['x'])
#>>>10
  • 1.
  • 2.
  • 3.
2、dict内修改键值对：

x[‘key’]=‘zz’   通过获取value的方式，将新的值赋值给value

a = {'x': 10, 'y': 20}
a['x'] = 15
print(a)
#>>>{'x': 15, 'y': 20}
  • 1.
  • 2.
  • 3.
  • 4.
3、dict内增加键值对：

x[‘key’]=‘yy’   通过修改不存在的键值对方式，直接将不存在的键值对添加至字典内

a = {'x': 10, 'y': 20}
a['z'] = '张三'
print(a)
#>>>{'x': 10, 'y': 20, 'z': '张三'}
  • 1.
  • 2.
  • 3.
  • 4.
4、dict内删除键值对：

del x[‘key’]，.pop (‘key’)

a = {'x': 10, 'y': 20}
del a['x']
print(a)
#>>>{'y': 20} 

a = {'x': 10, 'y': 20}
a.pop('x')
print(a)
# >>>{'y': 20} 


a = {'x': 10, 'y': 20}
b = a.pop('x')
print(b)
# >>>10
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
5、list内的元素作为dict的key：

x.fromkeys(y,“none”)

fromkey方法，用于将列表内的元素作为字典的key来使用，注：需要先创建空字典，然后再将列表内的元素作为字典内的key

x = {}
y = ['name', 'age', 'sex']
dict1 = x.fromkeys(y, 'none')
print(dict1)
# >>>{'name': 'none', 'age': 'none', 'sex': 'none'}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
6、dict内多个键值对进行更新：

a.update(b)   注：此函数没有返回值

将b的键-值对更新到字典a 中，b可以是字典、列表等；此函数亦可作修改字典使用(相同的key，不同的value)

dict_ = {}  # 创建空字典
dict_.update({'x': 10, 'y': 20})  # 传字典
print(dict_)
#>>>{'x': 10, 'y': 20}
dict_.update([('j', 30), ('k', 40)])  # 传列表
print(dict_)
#>>>{'x': 10, 'y': 20, 'j': 30, 'k': 40}
dict_.update(e=50, f=60)  # 传关键字
print(dict_)
#>>>{'x': 10, 'y': 20, 'j': 30, 'k': 40, 'e': 50, 'f': 60}
dict_.update(x='张三', y='李四')  # 修改字典内容
print(dict_)
#>>>{'x': '张三', 'y': '李四', 'j': 30, 'k': 40, 'e': 50, 'f': 60}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
7、dict遍历：

items()、keys()、values()

  • items() 方法把字典中每对 key 和 value 组成一个元组，并把这些元组放在列表中返回。
  • keys()方法把字典的key视图
  • values返回字典的值试图
dict_sample = {102: '张三', 105: '李四', 109: '王五'}
print("---遍历键---")
for sample_id in dict_sample.keys():
    print("学号：" + str(sample_id))

print("---遍历值---")
for sample_name in dict_sample.values():
    print("学生：" + str(sample_name))

print("---遍历键：值---")
for s_id,s_name in dict_sample.items():
    print("学号：{0} - 学生：{1}".format(s_id, s_name))
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.

三、set集合类型：

是一种可迭代的、无序的、不能包含重复元素的容器类型数据

set的操作

创建集合

可以使用大括号 { } 或者 set() 函数创建集合。

注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。创建非空集合只能使用{ }

x = {'张三', '李四', '王二'}
y = set()
print(x, type(x), y, type(y))
# >>>{'张三', '王二', '李四'} <class 'set'> set() <class 'set'>
  • 1.
  • 2.
  • 3.
  • 4.

set内不能有重复的值

x = {'张三', '李四', '王二', '张三'}
print(x)
# >>>{'张三', '王二', '李四'}
  • 1.
  • 2.
  • 3.
添加元素

.add()，将需要添加的元素当做一个整体，添加到集合中去。如果元素已经存在，则不能添加，不会抛出错误

x = {1,2}
x.add(‘python’) 
print(x)# 添加字符串 
#>>>{1, 2, 'python'} 

x = {1, 2}
y = ('python', 'java')
x.add(y)# 添加元组
print(x)
#>>>{1, 2, ('python', 'java')}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.

.update()是把要传入的元素拆分，做为个体传入到集合中(如传入列表、集合、元组等，拆分后作为个体传入)

x = {1, 2}
y = ('python')
x.update(y)    # 添加字符串
print(x)
#>>>{'t', 1, 2, 'p', 'n', 'y', 'o', 'h'}  x = {1, 2}
y = ['python', 'java']
x.update(y)    # 添加元组
print(x)
#>>>{1, 2, 'python', 'java'}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
删除元素
remove(elem)

如果元素不存在，则抛出错误

x = {‘python’, ‘java’, ‘php’} x.remove(‘php’) 
print(x) 
#>>>{'python', 'java'}
  • 1.
  • 2.
  • 3.
discard 方法

如果元素不存在集合中，那么程序不会报错

x = {‘python’, ‘java’, ‘php’} 
x.discard(‘php’) 
print(x) 
#>>>{'python', 'java'}
  • 1.
  • 2.
  • 3.
  • 4.
pop 方法

随机删除集合中的一个元素，并返回被删除的元素，如果集合为空，程序报错

x = {'python', 'java', 'php'}
y = x.pop()
print(x,y)
z = set()
d=z.pop() # KeyError: 'pop from an empty set'
print(d,z)
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
difference_update方法

删除集合x与序列y的重复元素

x = {1, 2, 3}
y = [3, 4, 5]
x.difference_update(y)
print(x)
#>>>{1, 2}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
intersection_update方法

删除集合A中与序列B不重复的元素

x = {1, 2, 3}
y = [3, 4, 5]
x.intersection_update(y)
print(x)
#>>>{3}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
clear()清除集合
x = {'python', 'java', 'php'}
print(x)  #输出结果{'php', 'python', 'java'} 
x.clear()
print(x)  #输出结果set()
  • 1.
  • 2.
  • 3.
  • 4.
set集合运算

x&y交集，x|y并集， x-y差集， x^y非交集

x = {'python', 'java'}
y = {'python', 'sql'}
print(x & y, x | y, x - y, x ^ y)
#>>> {'python'} {'sql', 'python', 'java'} {'java'} {'sql', 'java'}
  • 1.
  • 2.
  • 3.
  • 4.
set内是否有重复：

.isdisjoint()

使用isdisjoint方法，用于判断两个集合是否不含相同的元素，如果不含返回 True，如果含有返回 False

x = {'python', 'java'}
y = {'python', 'sql'}
z = x.isdisjoint(y)
print(z)
#>>>False  x = {'python', 'java'}
y = {'php', 'sql'}
z = x.isdisjoint(y)
print(z)
#>>>True
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.

总结：

  • 序列元素是有序的，其中列表是可变的，元组是不可变
  • 集合元素是无序的，且不能重复
  • 字典通过键来访问元素，由键视图和值视图构成，键视图不能包含重复的元素

列表(List)

优点:
  • 有序性：列表中的元素按照插入的顺序排列，支持索引访问。
  • 灵活性：可以动态添加、修改或删除元素，适合用于需要频繁变更的数据集合。
  • 异构性：可以容纳不同类型的元素，如整数、字符串、对象等。
区别：
  • 与其他三种相比，列表的主要区别在于其可变性和异构性，但这也使得它在某些情况下不如集合或字典高效。

集合(Set)

优点:
  • 唯一性：自动去除重复元素，适合用于需要确保元素唯一性的场景。
  • 高效查找：基于哈希表实现，提供了快速的成员测试和交、并、差等集合运算。
  • 无序性：不保证元素的顺序，适合于对顺序不敏感的数据处理。
区别：
  • 集合的独特之处在于其唯一性和无序性，适用于需要快速查找和处理无序数据集合的情况。

字典(Dict)

优点:
  • 键值对：通过键(必须唯一)快速访问值，提供高效的映射关系存储。
  • 灵活性：键可以是几乎任何不可变类型，支持动态添加、修改键值对。
  • 无序性：虽然Python 3.7+中字典保持了插入顺序，但本质上字典是无序的。
区别

字典的核心优势在于键值映射，适合构建复杂的数据结构，如缓存、配置等。

元组(Tuple)

优点:
  • 不可变性：一旦创建，元素便不可更改，这有助于保护数据免受意外修改。
  • 轻量级：相比于列表，元组在内存占用上更小，因为它是静态数据结构。
  • 可作为字典键：由于其不可变性，元组可以直接作为字典的键使用。
区别：
  • 元组的主要特征是不可变性和轻量级，适用于不需要修改的固定数据集合，如函数返回多个值的场景。