Python中常用的序列类型有字符串、列表和元组。
Python集合具备确定性、互异性和无序性三个特性.
Python要求放入集合中的元素必须是不可变类型。
Python中的整型、浮点型、字符串类型和元组属于不可变类型
列表、字典及集合本身都属于可变的数据类型。
给定一个集合，那么任何一个元素是否在集合中就确定了.
# 列表 是python中的一种数据类型，可以存放多个数据，列表中的数据可以是任意类型的 # 列表 list，定义使用[]进行定义 # 定义空列表 my_list = [] print(my_list,type(my_list)) my_list1 = list() #空列表 print(my_list1,type(my_list1)) #定义带数据的列表，数据元素之间使用逗号隔开 my_list2 = [1,1.23,True,'isaac'] print(my_list2,type(my_list2)) #求列表数据元素的个数，即列表长度 num = len(my_list2) print(num) #列表支持下标和切片 print(my_list2[1]) print(my_list2[-1]) print(my_list2[1:3]) #下标 *** 作和字符串不同的是，字符串不能使用下标修改数据 #但是列表可以 my_list2[0]=19 my_list2[-1]="hello word"(2）遍历
my_list = ['嘉然'，'向晚','贝拉'，'珈乐'，'乃琳']
for i in my_list:
print(i)
print('*' * 30)
j = 0
while j
（3）添加数据
#向列表中添加数据是在原列表中添加，不会返回新的表格。
my_list = ['嘉然'，'向晚','贝拉'，'珈乐'，'乃琳']
print(my_list)
#列表。append（数据）向列表尾追加数据
my_list.append('泠鸢')
print(my_list)
#列表。insert（下标，数据）在指定的下标位置进行添加数据
my_list.insert(0,'hanser')
print(my_list)
#列表。exten（可迭代对象）会将可迭代对象中的数据逐个添加到原列表的末尾
my_list.extend('love')
print(my_list)
my_list.extend([1,'python'3])
print(my_list)
（4）查询 *** 作
my_list = ['嘉然'，'向晚','贝拉'，'珈乐'，'乃琳']
#index() 根据数据值，查找元素所在的下标，找到返回元素的下标 没有找到，程序报错。
#列表没有find方法，只有index（）方法
#查找嘉然在列表的下标
num = my_list.index(嘉然)
print(num)
#count()统计出现的次数
num3 = my_list.count(1)
print(num3)
#in/not in 判断是否存在，存在是true，不存在false，一般和if配合使用
num4 = 嘉然 in my_list
print(num4)
num4 = 向晚 not in my_list
print(num4)
（5）删除 *** 作
my_list = ['嘉然'，'向晚','贝拉'，'珈乐'，'乃琳']
#1.根据元素的数据值删除remove（数据值），源列表中的数据
my_list.remove(贝拉)
print(my_list)
#2.根据下标删除
#2.1pop（下标）默认删除最后一个数据，返回删除的内容
num = my_list.pop() #删除最后一个数据
print(num)
print(my_list)
num = my_list.pop(2) #删除下标为2的数据
print(num)
print(my_list)
#2.2 del 列表[下标]
del my_list[1] #删除下标为1的数据2
print(my_list)
#del my_list[10] #删除不存在的下标会报错。
(6) 列表排序和逆置
#想要对列表的数据进行排序，前提是列表中的数据类型一样
my_list = [1,3,32,534,5467,341]
#列表。sort（）直接在原列表中进行排序
#my_list.sort 默认是从小到大排序，即升序
#my_list,sort(reverse=true) 通过reverse=true，从小到大排序
print(my_list)
#sorted（列表） 排序，不会在原列表中进行排序，会得到一个新的列表
my_list1 = sorted(my_list)
my_list2 = sorted(my_list,reverse=True)
print(my_list)
print(my_list1)
print(my_list2)
print("=" *30)
my_list3 = ['a', 'b','c','d','e']
#逆置，
my_list4 = my_list3[::-1]#得到一个新列表
print(my_list3)
print(my_list4)
#在原列表直接逆置 列表。reverse()
my_list3.reverse()
（7）列表嵌套
ouxiang_names = [['泠鸢'，'hanser']]，
['七海nana7mi','鹿乃'，'阿梓']
['向晚'，'嘉然']]
print(ouxiang_names[1]) #['七海nana7mi','鹿乃'，'阿梓']
print(ouxiang_names[1][1]) #七海nana7mi
print(ouxiang_names[1][1][1]) #乃
#向晚
print(ouxiang_names[2][0])
for ouxinag in ouxiang_names:
#print(ouxiang) #列表
for name in ouxinag
print(name)
3 元组
# 元组和列表非常相似，都可以存放多个数据，可以存放不同数据类型的数据
# 不同点：列表使用[] 定义，元组使用（）定义
# 列表中的数据可以修改，元组中的数据不能修改
my_list = ['泠鸢','hanser','鹿乃','七海nana7mi','阿梓'] #列表
my_tuple = ('泠鸢','hanser','鹿乃','七海nana7mi','阿梓') #元组
print(my_tuple,type(my_tuple))
# 元组支持下标和切片 *** 作
print(my_tuple[1]) #hanser
#定义空元组，没有意义
my_tuple1=()
print(my_tuple1,type(my_tuple1))
my_tuple2=tuple()
# 定义一个数据元素的元组，数据元素后边，必须有一个逗号
my_tuple3=(3) #3
my_tuple4=(3,)
print(my_tuple3,type(my_tuple3))
print(my_tuple4,type(my_tuple4))
4 字典
（1）定义与访问
# 字典dict 定义使用{}定义，是由键值对组成（key-value）
# 变量 = {key1：value1，key2：value，....} 一个key：value键值对是一个元素
# 字典的key 可以是 字符窜类型和数字类型（int float）不能是 列表
# value值可以是任何类型
# 1.定义空字典
my_dict = {}
my_dict1 = dict()
print(my_dict,type(my_dict))
print(my_dict1,type(my_dict1))
# 2.定义带数据的字典
my_dict2 = {'name':"泠鸢",'age':50,'like':['hanser','做词'],1:[1,4,8]}
print(my_dict2)
#3.访问value 值，在字典中没有下标的概念，使用key值访问对应的value值
#18
print(my_dict2['age'])
#hanser
print(my_dict2['like'][1])
#如果key值不存在
#print（my_dict2['gender']） #代码报错，key值不存在
#字典。get（key） 如果key值不存在，不会报错，返回的是none
print(my_dict2.get('gender'))
#my_dict2.get(key,数据值) 如果key存在，返回key对应的value值，如果key不存在，返回书写的数据值值
print(my_dict2.get('gender','男'))
print(my_dict2.get('age',1))
print(len(my_dict2))
（2）添加和修改数据
my_dict={'name':'isaac'}
print(my_dict)
#字典中添加和修改数据，使用key值进行添加和修改
#字典[ key] =数据值; 如果key值存在,就是修改,如果key值不存在,就是添加
my_dict[ 'age'] = 18 # key 值不存在,添加print(my_dict)
print(my_dict)
my_dict[ 'age'] =19# key值已经存在,就是修改数据
print(my_dict)
#注意点key值int的1和fLoat的1.0代表一个key值
my_dict[1] =‘int'
print(my_dict)
my_dict[1.0]='f1oat'
print(my_dict)
（3）删除数据
my_dict = { 'name ' : 'isaac ', 'age ': 19，1: 'float'， 2: 'aa'}
#根据key 值删除数据del字典名[key]
del my_dict[1]
print(my_dict)
#|字典.pop( key)根据key值删除，返回值是删除的Rey对应的value值
result = my_dict.pop( ' age ' )
print(my_dict)
print(result)
#字典.clear()清空字典，删除所有的键值对
my_dict.clear()
print(my_dict)
# del字典名直接将这个字典删除了，不能使用这个字典了
del my_dict#后边的代码不能再直接使用这个变量了,除非再次定义
# print(my_dict)代码报错，变量为定义
（4）字典中遍历数据
1. for 循环直接遍历字典, 遍历的是字典的 key 值
my_dict = { ' name ' : 'isaac', 'age' : 18， 'gender ' : '男'}
#for循环体直接遍历字典，遍历的字典的key值
for key in my_dict:
print(key, my_dict[key])
2. 字典.keys()
#字典.keys()获取字典中所有的Rkey值，得到的类型是 dict_keys，该类型具有的特点是
#1．可以使用list()进行类型转换，即将其转换为列表类型
#2.可以使用for循环进行遍历
result = my_dict.keys()
print(result, type(result))
for key in result:
print(key)
3. 字典.values()
#字典.values()获取所有的vaLue值，类型是dict_values
#1．可以使用List()进行类型转换,即将其转换为列表类型
#2.可以使用for循环进行遍历
result = my_dict.values()
print(result, type( result))
for value_in my_dict.values( ):
print(value)
4.字典.items()
#字典.items()获取所有的键值对，类型是 dict_items， key , value 组成元组类型
#1．可以使用List()进行类型转换,即将其转换为列表类型
#2.可以使用for循环进行遍历
result = my_dict.items()
print(result， type(result))
foritem in my_dict.items():
print( item[o], item[1])
print( '='* 30)
for k，v in my_dict.items(:# k 是元组中的第一个数据，v是元组中的第二个数据
print(k， v)
5 enumerate 函数
my_list = [ 'a', 'b', 'c', 'd', 'e']
# for i in my_List:
# print(i)
for i in my_list:
print(my_list.index(i)，i)#下标，数据值
# enemerate将可迭代序列中元素所在的下标和具体元素数据组合在一块,变成元组for j in enumerate(my_list) :
print(j)
在字典中可以包含列表，列表中能包含字典.
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）