说明：本篇文章为作者复习阶段观看网课所写笔记，如有侵权，请联系作者删除。
创建列表
1.创建列表的第一种方式，使用[]
lst1 = ['hello','world',98,789]
print(lst1)
#列表元素按顺序有序排列
print(lst1[0])
#索引对应唯一的元素：索引可以是正数（从0开始）；也可以是负数（从-1开始）
print(lst1[-1],lst1[-4])2.创建列表的第二种方式，使用内置函数list()
lst2 = list(['china','home',123])
print(lst2)
#列表元素按顺序有序排列
print(lst2[1])
#负数从最后一个开始往前递减（即最后一个是-1，倒数第二个是-2，以此类推）
print(lst2[-3])
#列表任意的数据类型可以混存
#根据需要动态分配和回收内存（即使用前不需要定义内存大小，使用后不需要释放内存）列表的查询操作：（单个元素）
1.获取列表中指定元素的索引
如果列表中存在N个相同元素，只返回相同元素中第一个元素的索引
如果查询的元素在列表中不存在，则会抛出ValueError
还可以在指定的start和top之间进行查找
2.获取列表中的单个元素
正向索引从0到N-1
逆向索引从-N到-1
指定索引不存在，抛出indexError
#创建一个列表(其中有相同元素）
#lst = ['hello','world',98,'hello']
#print(lst.index('hello')) #输出0
#index()函数获取括号内元素的索引（即元素在列表中的序号）
#print(lst.index('Python'))
#查找的元素不在列表中，ValueError
#print(lst.index('hello',1,3)) #从列表中索引为1的元素开始查找，直到索引为3的元素为止（不包括3）
#输出ValueError错误，1-3（不包括3）中的元素没有hello
#创建一个列表
lst2 = ['hello','world',98,'world',234]
#获取索引为2的元素
print(lst2[2])
#获取索引为-3的元素
print(lst2[-3])
#获取索引为10的元素
print(lst2[10]) #输出IndexError错误列表的查询操作：（多个元素）
1.获取列表中的多个元素：切片
2.语法格式：列表名[start：stop：step]
3.切片操作：
#切片的结果：原列表片段的拷贝
#切片的范围:[start,stop) 左闭右开
#step默认为1，简写为[start,stop]
#step为正数，从start开始往后计算切片
#step为负数，从start开始往后计算切片
lst=[10,20,30,40,50,60,70,80]
#start=1.stop=6,step=1
#print(lst[1:6:1]) #输出结果为[20,30,40,50,60]
print('原列表',id(lst))
lst2=lst[1:6:1]
print('切的片段',id(lst2))
print(lst[1:6]) #默认步长为1
#start=1;stop=6;step=2
print(lst[1:6:2])
#stop=6;step=2;start采用默认
print(lst[:6:2]) #start默认为0
#start=1;step=2;stop采用默认
print(lst[1::2]) #stop默认到最后
print('----------------------------step为负数的情况----------------------------------------')
print('原列表:',lst)
print(lst[::-1]) #逆序输出原列表
#start=7；stop省略；step=-1
print(lst[7::-1])
#strat=6;stop=0;step=-2
print(lst[6:0:-2])列表元素的判断及遍历
1.判断指定元素在列表中是否存在
print('p' in 'python') #判断p在python中，输出结果为True
print('k' not in 'python') #判断k不在python中，输出结果为True
lst=[10,20,'python','hello']
print(10 in lst) #True
print(100 in lst) #False
print(10 not in lst) #False
print(100 not in lst) #True2.列表元素的遍历
for item in lst:
print(item)列表元素的增加操作
#append()在列表的末尾添加一个元素,在原列表末尾添加，并不创建新的列表
lst1=[10,20,30]
print('添加元素之前：',lst1,id(lst1))
lst1.append(100)
print('添加元素之后：',lst1,id(lst1))#extend()在列表的末尾至少添加一个元素
lst2=['hello','world']
#lst1.append(lst2) #将lst2整体作为一个元素添加到lst1的末尾
lst1.extend(lst2) #向lst1的末尾一次性添加多个元素
print(lst1)#insert()在列表的任意位置添加一个元素
lst1.insert(1,90) #在lst1索引为1的位置之后添加元素90
print(lst1)#切片:在列表的任意一个位置添加至少一个元素,把原来的元素切掉，换上新的元素
lst3=[True,False,'hello']
lst1[1:]=lst3
print(lst1)列表元素的删除操作
#remove():一次删除一个元素；重复元素删除第一个；元素不存在抛出ValueError
lst=[10,20,30,40,50,60,30]
lst.remove(30) #删除重复元素的第一个
print(lst)
#lst.remove(100) #删除不存在的元素，抛出ValueError
print(lst)#pop():删除一个指定索引位置上的元素；指定索引不存在抛出IndexError;不指定索引删除列表中最后一个元素
lst.pop(1) #删除索引为1的元素
print(lst)
lst.pop() #不指定索引删除列表中最后一个元素
print(lst)
#lst.pop(5) #指定索引不存在，抛出IndexError
print(lst)#切片:一次至少删除一个元素
#产生新的列表 #不产生新的列表，删除原列表中的元素
new_list=lst[1:3] lst[1:3]=[]
print('原列表：',lst) print(lst)
print('切片后：',new_list)#clear():清空列表中的所有元素 #del:将列表删除
lst.clear() del lst
print(lst) print(lst)列表的修改操作
#为指定索引的元素赋予一个新值 #为指定的切片赋予一个新值
lst=[10,20,30,40] lst[1:3]=[300,400,500]
#一次修改一个值 print(lst)
lst[2]=100
print(lst)列表的排序操作
sort()和sorted()的区别在于：sort()是在原列表的基础上排序，sorted()是创建新列表进行排序
#sort()：默认将列中的所有元素从小到大排序，也可以指定reverse=True进行降序排序
lst=[20,40,10,98,54]
print('排序前的列表：',lst,id(lst))
#调用sort()，默认升序,没有产生新的列表
lst.sort()
print('排序后的列表：',lst,id(lst))
#通过指定关键字参数reverse=True,将列表中的元素进行降序排序
lst.sort(reverse= True) #reverse=True 表示升序排序
print(lst)
lst.sort(reverse= False) #reverse=False 表示降序排序
print(lst)#sorted():指定reverse=True，进行降序排序，原列表不发生改变，产生新的列表
lst=[20,40,10,98,54]
print('原列表：',lst)
#开始排序
new_list=sorted(lst)
print(lst)
print(new_list )
#指定关键字参数，实现降序排序
desc_list=sorted(lst,reverse=True)
print(desc_list )列表生成式
1.列表中的元素是1,2,3,4,5,6,7,8,9
lst=[i for i in range(1, 10)]
print(lst)2.列表中的元素是 1,4,9,16,25,49,64,81 3.列表中的元素是2,4,6,8,10
lst=[i*i for i in range(1, 10)] lst2=[i*2 for i in range(1,6)]
print(lst) print(lst2)1.列表 [] 有序序列，第一个放入列表的元素索引就是1
2.字典 {} 无序序列，第一个放入字典的元素索引不一定就是1，可利用hash()
3.列表和字典都是可变序列，即都可进行增删改
4.字典是以键值对的方式存储数据的
5.字典名={'键':值，'键':值,'键':值}
6.scores={'张三':100,'李四':99,'王五':98}
创建字典 字典的创建方式：使用花括号{}；使用内置函数dict()
1.使用{}创建字典 3.创建空字典
scores={'张三':100,'李四':98,'王五':45} d={}
print(scores) print(d) #输出{}
print(type(scores)) #类型是dict2.使用内置函数dict()创建字典 4.使用字典生成式创建
student=dict(name='jack',age=20)
print(student)
print(type(student)) #类型是dict获取字典中的元素
字典中元素的获取：通过键获取与其对应的值 1.scores['张三'] 2.scores.get('张三')
scores={'张三':100,'李四':98,'王五':45}
#第一种方式：使用[] print(scores['张三']) #输出100
#第二种方式：使用get()
print(scores.get('李四')) #输出98
print(scores.get('陈六')) #输出None
print(scores.get('麻七',99)) #输出99；99是在查找‘麻七’所对的value不存在时，提供的一个默认值字典的增删查改操作
scores={'张三':100,'李四':98,'王五':45}
#键(key)的判断
print('张三' in scores ) #张三在scores中，输出True
print('张三' not in scores ) #张三不在scores中，输出False
#字典元素的删除
#通过删除指定的键(key)，从而删除整个键值对(key-value)
del scores['张三'] #删除指定键值对
print(scores) #输出{'李四': 98, '王五': 45}
#scores.clear() #将字典中的所有元素都删除
#print(scores) #输出{}
#字典元素的新增
scores['陈六']=98
print(scores) #输出{'李四': 98, '王五': 45, '陈六': 98}
#字典元素的修改
scores['陈六']=100 #对指定键值对进行修改
print(scores) #输出{'李四': 98, '王五': 45, '陈六': 100}
获取字典视图
1.keys() 获取字典中所有key（键）
2. values() 获取字典中所有value（值）
3. items() 获取字典中所有key-value对（键值对）
scores={'张三':100,'李四':98,'王五':45}
#获取字典中所有key
keys=scores.keys()
print(keys) #输出dict_keys(['张三', '李四', '王五'])
print(type(keys)) #输出<class 'dict_keys'>
print(list(keys)) #将所有的key组成的视图转换成列表
#获取字典中所有value
values=scores.values() #输出dict_values([100, 98, 45])
print(values) #输出<class 'dict_values'>
print(type(values)) #将所有的value组成的视图转换成列表
#获取字典中所有key-value对
items=scores.items()
print(items) #输出dict_items([('张三', 100), ('李四', 98), ('王五', 45)])
print(type(items)) #输出<class 'dict_items'>
print(list(items)) #输出[('张三', 100), ('李四', 98), ('王五', 45)]；转换之后的列表元素是由元组组成的字典元素的遍历 依次获取字典中的元素
scores={'张三':100,'李四':98,'王五':45}
for item in scores:
print(item) #item代表键
#根据键获取字典中的值
print(scores[item])
print(scores.get(item))字典的特点
1.字典中的所有元素都是一个key-value对，key不允许重复，value可以重复
a={'name':'张三','name':'李四'}
print(a) #输出{'name': '李四'}；key不允许重复
b={'name':'张三','firstname':'张三'}
print(b) #输出{'name': '张三', 'firstname': '张三'}；value可以重复2.字典中的元素是无序的，即无法指定某个位置插入元素
3.字典当中的key必须是不可变对象
4.字典可以根据需要，动态地伸缩
5.字典会浪费较大的内存，是一种使用空间换时间的数据结构
字典生成式
items1=['Fruits','Books','Others'] #列表1
prices1=[96,78,85] #列表2
#upper()将字母全部转换为大写
d1={item.upper():price for item,price in zip(items1,prices1)}
print(d1) #输出{'FRUITS': 96, 'BOOKS': 78, 'OTHERS': 85}
#当两个列表数据个数不匹配时，以少的为依据
items2=['Fruits','Books','Others'] #列表1
prices2=[96,78,85,100,500] #列表2
d2={item.upper():price for item,price in zip(items2,prices2)}
print(d2) #输出{'FRUITS': 96, 'BOOKS': 78, 'OTHERS': 85}元组
1.元组：Python内置的数据结构之一，是不可变序列
2.元组() 列表[] 字典{}
3.不可变序列：字符串、元组；没有增删改的操作
4.可变序列：列表、字典；可以对序列执行增删改操作，对象地址不发生改变
#列表
lst=[10,20,45]
print(id(lst))
lst.append(300) #在原列表中增加元素300
print(id(lst)) #增加元素前后列表的地址没有改变
#字符串
s='hello'
print(id(s))
s=s+' world'
print(id(s)) #增加元素前后字符串的地址发生改变
print(s)创建元组
1.第一种，直接使用小括号
t=('Python','world',98)
print(t)
print(type(t)) #输出<class 'tuple'>
#第一种方式可以省略小括号
n='Python','world',98
print(n)
print(type(n)) #输出<class 'tuple'>
#只包含一个元组的元素需要使用逗号和小括号
l=(10,)
print(l) #一定要加逗号
print(type(l)) #输出<class 'tuple'>
2.第二种，使用内置函数tuple()
m=tuple(('Python','world',98))
print(m)
print(type(m)) #输出<class 'tuple'>
#创建空列表
lst1=[]
lst2=list()
print('空列表',lst1 ,lst2 )
#创建空字典
d1={}
d2=dict()
print('空字典',d1 ,d2 )
#创建空元组
t1=()
t2=tuple()
print('空元组',t1 ,t2 )
#为什么要将元组设计成不可变序列
#在多任务环境下，同时操作对象时不需要加锁
#因此，在程序中尽量使用不可变序列
#注意事项：元组中存储的是对象的引用
#如果元组中的对象是不可变对象，则不能再引用其它对象
#如果元组中的对象是可变对象，则可变对象的引用不允许改变，但数据可以改变
t=(10,[20,30],9)
print(t)
print(type(t))
print(t[0],type(t[0]),id(t[0])) #输出10 <class 'int'>
print(t[1],type(t[1]),id(t[1])) #输出[20, 30] <class 'list'>
print(t[2],type(t[2]),id(t[2])) #输出9 <class 'int'>
#将t[1]修改为100
print(id(100))
#t[1]=100 #元组不允许修改元素
#由于t[1](即[20,30])是列表，而列表是可变序列，所以可以向该列表中添加元素，而列表的内存地址不变
t[1].append(100) #在列表的末尾添加元素
print(t) #输出(10, [20, 30, 100], 9)
print(id(t)) #添加后与最初的地址相同遍历元组 元组是可迭代对象，所有可以使用for...in进行遍历
t=('Python','world',98)1.第一种获取元组元素的方式:使用索引
print(t[0])
print(t[1])
print(t[2])
#print(t[3]) #IndexError: tuple index out of range2.第二种获取元组元素的方式:遍历元组
for item in t:
print(item)集合创建
1.python中的内置数据结构：列表、字典、元组、集合
2.列表、字典、集合都是可变序列
3.集合是没有value的字典
4.元素放入集合的顺序并不是其索引顺序，需要使用dash()计算元素的位置
#集合的创建方式
#第一种，使用{}
s={2,3,4,5,5,6,7,7}
print(s) #输出{2, 3, 4, 5, 6, 7}；因为集合中的元素不可以重复
#第二种，使用set()
s1=set(range(6)) #range(6)产生0-5的序列
print(s1) #输出{0, 1, 2, 3, 4, 5}
print(type(s1)) #输出<class 'set'>
s2=set([1,2,3,3]) #通过set()将列表转换为集合
print(s2) #输出{1, 2, 3}；因为集合中的元素不可以重复
print(type(s2)) #输出<class 'set'>
s3=set((1,4,4,65)) #通过set()将字典转换为集合
print(s3) #输出{65, 1, 4}；因为集合中的元素是无序的
print(type(s3)) #输出<class 'set'>
s4=set('python') #通过set()将字符串转换为集合
print(s4) #输出{'t', 'n', 'y', 'o', 'h', 'p'};因为集合中的元素的无序的
print(type(s4)) #输出<class 'set'>
s5=set({56,45,99}) #通过set()将集合转换为集合，也可直接当作集合
print(s5) #输出{56, 99, 45}；因为集合中的元素是无序的
print(type(s5)) #输出<class 'set'>
#定义空集合
s6={}
print(type(s6)) #输出<class 'dict'>；没有定义成功，不可以直接使用{}定义空集合
s7=set()
print(type(s7)) #输出<class 'set'>；定义成功集合的数据操作
s1={10,20,30,40}
s2={20,30,40,50,60}
#交集：集合A和集合B共有的元素组成的集合
print(s1.intersection(s2) )
print(s1 & s2) # & 与 intersection() 等价，都可以求两个集合的交集
#并集：集合A+集合B
print(s1.union(s2) )
print(s1 | s2) # | 与 union() 等价，都可以求两个集合的并集
#差集：集合A-集合B
print(s1.difference(s2) ) #集合A-集合B
print(s1-s2) # - 与 difference() 等价，都可以求两个集合的差集
#对称差集:并集-交集
print(s1.symmetric_difference(s2) )
print(s1 ^ s2)集合的运算
#随机生成 [0,10]范围的整数，分别组成集合A和集合B
#输出A和B的内容、长度、最大值、最小值以及它们的并集、交集和差集。
import random
def fun():
List = []
for j in range(5):
x = random.randint(0,10)
List.append(x)
return set(List)
A = fun()
B = fun()
print(str.format("集合的内容,长度,最大值,最小值分别为：\n{0} {1} {2} {3}",A,len(A),max(A),min(A)))
print(str.format("{0} {1} {2} {3}",B,len(B),max(B),min(B)))
print(str.format("A和B的并集,交集和差集分别为：\n{0} {1} {2} ",A|B,A&B,A-B))
集合间的关系
#两个集合是否相等：可以使用==或！=进行判断；元素相同就相等
s1={10,20,30,40}
s2={30,40,20,10}
print(s1==s2) #True
print(s1!=s2) #False
s3={10,20,30,40,50,60}
s4={10,20,30,40}
s5={10,20,90}
#一个集合是否为另一个集合的子集：可以调用issubest进行判断
print(s4.issubset(s3) ) #判断s4是不是s3的子集；输出True
print(s5.issubset(s3) ) #判断s5是不是s3的子集；输出False
#一个集合是否为另一个集合的超集：可以调用issuperset进行判断
#若A是B的子集，那么B就是A的超集
print(s3.issuperset(s4) ) #判断s3是不是s4的超集；输出True
print(s3.issuperset(s5) ) #判断s3是不是s5的超集；输出True
#两个集合是否没有交集：可以使用isdisjiont进行判断
print(s3.isdisjoint(s5) ) #判断s3和s5没有交集；输出False
print(s5.isdisjoint(s3) ) #与其上作用相同
s6={500,900}
print(s3.isdisjoint(s6) ) #判断s3和s6没有交集；输出True列表生成式 集合生成式
lst=[i*i for i in range(6)] s={i*i for i in range(6)}
print(lst) print(s)列表、元组、字典、集合总结
#列表 可变 可重复 有序 []
#元组 不可变 可重复 有序 ()
#字典 可变 key不可重复；value可以重复 无序 {key:value}
#集合 可变 不可重复 无序 {}
#元组创建：使用()创建；使用内置函数tuple()
#元组遍历：for...in
#元组是不可变序列，无法进行增删改操作
#集合创建：使用{}创建；使用内置函数set();使用集合生成式 s={i*i for i in range(6)}
#集合遍历：for...in
#集合新增：add()一次只删除一个元素;update()一次至少删除一个元素
#集合删除：remove()若删除元素不存在抛出错误;discard()若删除元素不存在不抛出错误;pop()随机删除任意一个元素;clear()清空列表
#集合是可变序列，可以进行增删改操作
1869
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
