列表(list)是包含0个或多个数据的有序序列，其中的每个数据称为元素。列表的元素个数和元素内容都是可以改变的。列表的所有元素放在一对方括号中，相邻元素之间使用逗号分隔。在Python中，同一个列表中元素的数据类型可以各不相同，可以同时包含整数、实数、复数、字符串等基本类型的元素，也可以包含列表、元组、字典、集合、函数或其他任意对象。一对空的方括号表示空列表。

（1）创建列表

☞使用[]直接创建列表

在列表当中他的元素可以是任意类型

lst=[2,3,4,35.3,'asd',[2,3]]
print(lst)

(2)使用list()函数创建列表

lst=list((2,3,4))
print(lst)

(3)将字符串转换成列表

lst=list('hello word')    #将字符串转换成列表
print(lst)

(4)range函数转换成列表

例如：range(10)end表示范围（0-9）,(start)初始值默认0，(step)默认步长为1

range(start, end, step)

lst=list(range(10)) #range(10)表示范围（0-9）初始值默认0，默认步长为1
print(lst)

lst1=list(range(2,10,3)) #range(2,10,3)表示范围（2-9）初始值默认2，默认步长为3
print(lst1)

(5) list() map()函数

如下函数参数是str表示转换成字符串类型再用list转换成列表

lst=list(map(str,range(10)))
print(lst)

(6)list() zip()函数

将可迭代的对象作为参数，将对相中对应的的元素打包成一个个元组

lst=list(zip('abc','123'))
print(lst)

(7)使用下标访问列表中的元素

列表、元组和字符串属于有序序列，其中的元素有严格的先后顺序，用户可以使用整数作为下标来访问其中任意位置上的元素。
列表、元组和字符串都支持双向索引，有效索引范围为[-L,L-1]，其中L表示列表、元组或字符串的长度。正向索引时，0表示第1个元素，1表示第2个元素，2表示第3个元素，以此类推；反向索引时，-1表示最后1个元素，-2表示倒数第2个元素，-3表示倒数第3个元素，以此类推。如果指定的下标不在有效范围内，代码会抛出异常。

data = list(range(10))
print(data)
print(data[0])    #第一个元素的下标为8
print(data[3])    #第四个元素的下标为3
print(data[-1])    #-1表示最后一个元素的下标
print(data[15])    # 15不是有效下标，代码抛出异常

3. 列表常用方法

3.1 append()，insert()，extend()

append()用于向列表尾部追加一个元素；

insert()用于向列表任意指定位置插入一个元素，该位置之后的所有元素自动向后移动，下标加1；

extend()用于将另一个列表中的所有元素追加至当前列表的尾部。

data = [1,2,3,4,5]
data.append(6)      #data调用append方法后 在列表的尾部加上一个6
print(data)

data.insert(0,9)    #在指定列表上插入指定元素
print(data)    

data.extend([7,8])  #将另一个列表中的所有元素追加至当前列表的尾部
print(data)

3.2 pop()，remove()

pop()用于删除并返回列表中指定位置上的元素，不指定位置时默认是列表中最后一个元素，如果列表为空或指定位置不存在会抛出异常；

remove()用于删除列表中第一个与指定值相等的元素，如果列表中不存在该指定值则抛出异常。

data = [1,2,3,4,5,6,7,8]
print(data.pop())    #删除并返回最后一个元素
print(data)

print(data.pop(2))   #删除并返回下标为2的元素，后面的元素向前移动
print(data)

data =[1, 2, 3, 3, 5, 3]
data.remove(3)       #删除第一个3，该方法没有返回值
print(data)

3.3 count()，index()

count()用于返回列表中指定元素出现的次数；
index()用于返回指定元素在列表中首次出现的位置，如果列表中不存在该指定元素，则抛出异常。

data = [2,1,4,3,2,3,4,1,5,7,3]
print(data.count(3))    #列表中指定元素出现的次数
print(data.count(1))    #列表中指定元素出现的次数
print(data.index(2))    #返回指定元素在列表中首次出现的位置，如果列表中不存在该指定元素，则抛                
                        #出异常

print(data.index(8))    #元素8不存在 代码抛出异常，并提示8 is not in list

3.4 sort()，reverse()

sort()用于按照指定的规则对列表中所有元素进行排序，支持key参数和reverse参数。

reverse()用于翻转列表中的所有元素，首尾交换。如果将其值指定为True，则表示降序排序。如果为Fase，则表示升序排序。默认为升序排列。

from random import sample    #在range(10000)中任选16个不重复的随机数
data = sample(range(10000), 10)
print("1:",data)

data.reverse()               #翻转，首尾交换，该方法没有返回值
print("2:",data)

data_re = sorted(data,reverse=True)    #降序排序
print("3:",data_re)

data.sort()                  #按元素大小进行排序，该方法没有返回值
print("4:",data)

data.sort(key=str)           #按所有元素转换为字符串后的大小进行排序
print("5:",data)

二.元组

(1)元组

元组是一种固定长度，不可变的Python对象序列。可以通过把若干元素放在一对圆括号中创建元组，如果只有一个元素的话则需要多加一个逗号，例如(3,)。也可以使用tuple()函数把列表、字典、集合、字符串以及range对象、map对象、zip对象或其他类似对象转换为元组。很多内置函数、标准库函数和扩展库函数也会返回元组或者包含元组的对象。

(2)元组与列表的区别

元组是不可改变的，元组创建后不能进行更改，既不能修改各元素的值，也不能增加或删除元素；列表是可变的，列表创建后，既可以修改已有元素的值，也可以增加新元素或删除现存元素。
由于Python对元组进行了一系列优化工作，使用元组数据处理,效率比较高。

(3)元组推导式

元组推导式可以利用range区间、列表、字典和集合等数据类型，快速生成一个满足指定需求的元组。
元组推导式的语法格式如下：
(表达式 for 迭代变量 in 可迭代对象[if 条件表达式])

列表推导式和元组推导式不同的是如下输出的是一个生成器对象，生成器对象具有惰性求值的特点，只有在需要的时候才能生成新的元素。

a = (x for x in range(1,11))
print(a)

可以使用tuple()函数：可以直接将生成器对象转换成元组。

a = (x for x in range(1,11))
print(tuple(a))

直接使用for循环遍历生成器对象，也是可以获得个个元素的。

注意：如下代码当使用在生成器遍历对象的时候只能访问一次，访问过得元素就不能再次访问，所以tuple（）函数为空

a = (x for x in range(1,11))
for i in a:
    print(i,' ',end='')

print(tuple(a))  # 访问过得元素就不能再次访问，所以tuple（）函数为空

使用next()函数遍历生成器对象，获得个个元素。

a = (x for x in range(1,11))

print(next(a))
print(next(a))
print(next(a))
print(next(a))
print(next(a))

print(tuple(a))

(4)序列解包

序列解包的本质是对多个变量同时进行赋值，也就是把一个序列或可迭代对象中的多个元素的值同时赋值给多个变量，要求赋值符号左侧变量的数量和赋值符号右侧值的数量必须一致。

a,b,c = 1,2,3   #赋值符号‘=’左侧变量的数量必须和右侧值的数量相同

print('1:',a,b,c)
a,b,c = (12,1.6,'asd')
print('2:',a,b,c)
a,b,c = [1,2,3]
print('3:',a,b,c)
a,b,c = map(int,'123')
print('4:',a,b,c)

三.字典

字典

字典是Python提供的一种常用的数据结构，用于存放具有映射关系的数据。字典使用大括号({})将元素列出。元素由键值(key)与数值(value)组成，中间以冒号(:)隔开。键值必须是字符串、数字或元组等不可变类型；数值则可以是任何数据类型。字典的元素排列没有一定的顺序，可以使用键值来访问元素。

（1）创建字典

可使用大括号语法来创建字典，也可使用dict()函数来创建字典。
使用大括号：

scores ={'语文'：89，'数学'：92，'英语'：93}
print(scores)
empty_dict ={}
print(empty_dict)
data ={(20, 50):'good', 20:'bad'}
print(data)

使用dict()函数：

vege =[('ere', 1.58),('tro', 1.29),('lend', 2.19)]
data = dict(vege)
print(data)
data = dict()   #如果不添加键值则创建空字典
print('空字典',data)
data = dict(name ='李恒', age = 24)
print(data)

（2）字典推导式

字典推导式可以借助列表、元组、字典、集合以及 range区间,
快速生成符合需求的字典。字典推导式的语法格式如下：
{表达式 for 迭代变量 in 可迭代对象[if 条件表达式]}

data={ch:ord(ch) for ch in 'abcd'}
print(data)    #将字符串中的每一个字符作为字典元素的键，字符对应的ASCLL码作为元素的值

将字符串中的每一个字符作为字典元素的键，字符对应的ASCLL码作为元素的值

（3）字典元素的访问

通过键（key）访问值（value）访问值和修改值：

scores={'语文':88,'数学':96,'英语':95}
print(scores['语文'])   #通过键访问值
scores['语文']=99       #通过键修改值
print(scores)

get()方法：

根据键来获取值。使用get()方法访问不存在的键时，该方法会返回None或替换数据，不会导致错误。

scores ={'语文':89,'数学':92,'英语':93}
print(scores.get('语文'))
print(scores.get('Python'))
print(scores.get('Python','无'))

update()方法：

使用一个字典所包含的键值对来更新己有的字典。在执行update()方法时，如果被更新的字典中己包含对应的键值对，那么原值(value)会被覆盖；如果被更新的字典中不包含对应的键值对，则该键值对被添加进去。

scores = {'语文':89,'数学':92,'英语':93}
scores.update({'语文':95,'Python':90})
print(scores)

items()方法：

可以获取字典的“键值对”列表，该方法返回值为可遍历的键值对元组列表，想要获取到具体的“键值对”，可通过for循环遍历该元组列表。

键值
keys()方法：

可以获取字典的“键”列表。

键值
Values()方法：

可以获取字典的“值”列表。

scores ={'语文':89,'数学':92,'英语':93}
print(scores.pop('语文'))
print(scores)

pop()方法：

用于获取指定键对应的值，并删除这个键值对.

scores ={'语文':89,'数学':92,'英语':93}
print(scores.items())
for item in scores.items():
    print(item)
for key,value in scores.items():
    print(key,value)

四.集合

集合是无序、可变的容器对象，所有元素放在一对大括号中，元素之间使用逗号分隔，同一个集合内的每个元素都是唯一的，不允许重复。集合中只能包含数字、字符串、元组等不可变类型的数据，而不能包含列表、字典、集合等可变类型的数据，包含列表等可变类型数据的元组也不能作为集合的元素。集合中的元素是无序的，元素存储顺序和添加顺序并不一致。集合不支持使用下标直接访问特定位置上的元素。

(1)创建集合

可使用大括号语法来创建集合，也可使用set()函数来创建集合。

data = {'111',2,3,4}
print(data)
data = set(range(10))
print(data)

(2)集合的常用方法

add()

方法用来增加新元素，如果该元素已存在则忽略该操作，不会抛出异常；

update()

方法用于合并另外一个集合中的元素到当前集合中，并自动去除重复元素。

data ={30,40,50}
data.add(20)
data.add(50)
data.update({40,60})
print(data)

pop()、remove()、discard()：

集合对象的pop()方法用来随机删除并返回集合中的一个元素，如果集合为空则抛出异常；remove(）方法用于删除集合中的指定元素，如果指定元素不存在则抛出异常;
discard()用于从集合中删除一个指定元素，若指定的元素不在集合
中则直接忽略该操作。

data ={30,40,58}
data.remove(30)
print(data)
data.discard(30)
print(data)
print(data.pop())
print(data)

原文链接：https://blog.csdn.net/m0_60246190/article/details/120263098

列表、元组、字典与集合

一.列表