声明：
（1）该学习笔记是根据B站“Python_子木”分享的杨淑娟老师授课的“马士兵Python入门基础版”所整理的。该系列笔记适合初学Python的同学，仅供学习交流。
（2）博主是零基础的Python初学者，撰写笔记是为了更好复盘所学内容。如有错误还望大佬们多多指点，不胜感激！
目录
一、列表
1. 为什么需要列表
变量可以存储一个元素，而列表是一个“大容器”，可以存储N多个元素、存储多个不同数据类型，程序可方便地对这些数据进行整体操作。
列表相当于其他语言中的数组。
| 索引 | -7 | -6 | -5 | -4 | -3 | -2 | -1 |
| 数据 | ‘’hello‘’ | ‘’world‘’ | 123 | 98.6 | ‘’world‘’ | 125 | ‘’world‘’ |
| 索引 | 0 | 1 | 2 | 3 | 4 | 5 | 6 |
2. 列表的创建
列表的创建方式有两种：使用中括号[]或调用内置函数list()。使用中括号时，元素之间使用英文的都好进行分隔。
#列表的创建,用[]
lst=['hello','world',98]
print(lst)
print(lst[0],lst[-3])
#用内置函数list（）
lst2=list(['hello','world',98])
print(lst2)3. 列表的特点
（1）列表元素按顺序有序排列；
（2）索引映射唯一数据；
（3）列表可以存储重复数据；
（4）任意数据类型混存；
（5）根据需要动态分配和回收内存。
4. 列表的查询操作
（1）获取列表只能够指定元素的索引
使用index()函数：
如果列表中存在N个相同元素，值返回相同元素的第一个索引；
如果查询的元素在列表中不存在，则会跑出Value Error；
还可以在指定的start和stop之间进行查找。
#获取列表中指定元素的索引
lst=['hello','world',98,'hello']
print(lst.index('hello')) #只返回相同元素的第一个索引
#print(lst.index('python')) #报错
#在指定的start与stop之间进行查找
#print(lst.index('hello',1,3)),在【1，3）之间找不到hello，所以报错
print(lst.index('hello',1,4))（2）获取列表中的单个元素
（1）正向索引从0到N-1，举例：lst[0]；
（2）逆向索引从- N到-1，举例：lst[-N]；
（3）指定索引不存在，抛出indexError。
#获取列表中的单个元素
#正向
print(lst[0])
print(lst[3])#从0到N-1
#逆向
print(lst[-1])
print(lst[-2])
print(lst[-4])#从-N到-1
#print(lsr[-5])#索引不存在报错（3）获取列表中的多个元素
语法格式：列表名[start:stop:step]
切片操作
切片的结果：原列表片段的拷贝；
切片的范围：[start:stop]
step默认为1——简写为[start:stop]；
step为正数，从start开始往后计算切片：[:stop:step]——start默认，切片的第一个元素是列表的第一个元素；[strat::step]——stop默认，切片的最后一个元素是列表的最后一个元素；
step为负数，从start开始往前计算切片：[:stop:step]——start默认，切片的第一个元素默认是列表的最后一个元素；[strat::step]——stop默认，切片的最后一个元素是列表的第一个元素。
#获取列表中多个元素——切片操作，语法格式：列表名【start：stop：step】
lst3=[10,20,30,40,50,60,70,80]
#start=1,stop=6,step=1
print(lst3[1:6:1])
print(lst3[1:6])
print(lst3[1:6:])
#start=1,stop=6,step=2
print(lst3[1:6:2])
#stop=6,step=2,start默认
print(lst3[:6:2])
#start=1,step=2,stop采用默认
print(lst3[1::2])
#step为负数
print(lst3[::-1])
#start=7,stop省略,step=-1
print(lst3[7::-1])
#start=6,stop=0,step=-2
print(lst3[6:0:-2])#[6,0),不包括05. 判断指定元素在列表中是否存在
元素 in 列表名；元素 not in 列表名
6. 列表元素的遍历
for 迭代变量 in 列表名
【操作】
7. 列表元素的增加操作
| 方法/其他 | 操作描述 |
| append() |
在列表末尾添加一个元素 |
| extend() | 在列表末尾至少添加一个元素 |
| insert() | 在列表任意位置添加一个元素 |
| 切片 | 在列表任意位置至少添加一个元素 |
#列表元素的增加操作
#向列表的末尾增加一个元素append（）
lst=[10,20,30]
lst.append(100)
print(lst)
lst2=['hello','world']
'''
lst.append(lst2)
print(lst)
这里是将lst2作为一个元素添加到lst里面的，所以输出是lst2的内容带方括号
'''
#向列表的末尾一次添加多个元素extend（）
lst.extend(lst2)
print(lst)
#在任意位置添加一个元素insert（）
lst.insert(1,90)#在索引为1的位置上添加一个90
print(lst)
#在任意位置上添加多个元素
lst2=[True,False,'hello']
lst[1:]=lst2 #把切掉的部分用新列表替换
print(lst)8. 列表元素的删除操作
| remove() | 一次删除一个元素，重复元素只删除一个，元素不存在抛出Value Error |
| pop() | 删除一个指定索引位置上的元素，指定索引不存在抛出Index Error，不指定索引，删除列表最后一个元素 |
| 切片 | 一次至少删除一个元素 |
| clear() | 清空列表 |
| del | 删除列表 |
#列表元素的删除操作
#删除一个元素，remove（）
lst=[10,20,30,40,50,60,30]
lst.remove(30)
print(lst)
#根据索引移除元素pop（）
lst.pop(1)
print(lst)
lst.pop() #不指定索引，默认删除列表最后一个元素
print(lst)
#切片，至少删除一个元素，将产生一个新的元素列表
new_list=lst[1:3]
print('原列表',lst,id(lst))
print('新列表',new_list,id(new_list))
#不产生新的列表，而是删除列表中的内容
lst[1:3]=[] #用空列表进行替代
print(lst,id(lst))9. 列表元素的修改操作
列表元素的修改：为指定索引的元素赋予一个新值；为指定的切片赋予一个新值。
#列表元素的修改操作
#一次修改一个值
lst=[10,20,30,40]
lst[2]=100
print(lst)
#修改列表中的多个值
lst[1:3]=[300,400,500,600]
print(lst)10. 列表元素的排序操作
列表元素的拍摄操作常见的两种方式：
（1）调用sort方法，列有中的所有元素默认按照从小到大的顺序进行排序，可以指定reverse=True，进行降序排序；
（2）调用内置函数sorted()，可以指定reverse=True，进行降序排序，原列表不发生改变。
#列表元素的排序操作
lst2=[20,40,10,98,54]
print('原列表',lst2,id(lst2))
lst2.sort()
print('新列表',lst2,id(lst2)) #id未发生改变
#通过指定关键字参数，将列表中的元素进行降序排序
lst2.sort(reverse=True)
print(lst2)
lst2.sort(reverse=False)
print(lst2)
#使用内置函数sorted（）对列表进行排序，将产生一个新的列表
lst3=[10,67,29,11,19]
new_list=sorted(lst3)
print(lst3,id(lst3))
print(new_list,id(new_list))
#指定关键字参数，实现元素降序排序
desc_list=sorted(lst3,reverse=True)
print(desc_list)11. 列表生产式
列表生产式：简称“生成列表的公式”；
语法格式：[i*i for i in range(1,10)]；
i*i：表示列表元素的表达式；i：自定义变量；range(1,10)：迭代变量。
注意事项：表示列表元素的表达式中通常包含自定义变量。
lst=[i for i in range(1,10)]
print(lst)
lst2=[i*i for i in range(1,10)]
print(lst2)
#列表中的元素值为2，4，6，8，10
lst3=[i*2 for i in range(1,6)]
print(lst3)二、字典
1. 什么是字典
字典：Python内置的数据结构之一，与列表一样是一个可变序列（可执行增删改操作）；以键值对的方式存储数据，字典是一个无序的序列。
scores={'张三':100,'李四':98,'王五':45}
其中‘张三’是键，100是值
字典实现原理与查字典类似，查字典是根据部首或拼音查找对应的野马，Python中的字典是根据key查找value所在的位置。
2. 字典的创建
使用花括号： scores={'张三':100,'李四':98,'王五':45}；
使用内置函数：dict(name='jack',age='20')
#字典的创建
#使用花括号
scores={'张三':100,'李四':98,'王五':45}
print(scores)
#使用内置函数
student=dict(name='jack',age=20)
print(student)3. 字典中元素的获取
获取字典中的元素：
（1）[]——举例：print(scores['张三'])；
（2）get()方法——举例：print(scores.get('张三'))
[]取值与get()取值的区别：
[]:如果字典中不存在指定的key，抛出Key Error异常；
get()方法取值，如果字典中不存在指定的key，并不会抛出Key Error而是返回None，可以通过参数设置默认的value，一边指定的key不存在时返回。
#字典中元素的获取
print(scores['张三'])
print(scores.get('李四'))
print(scores.get('麻九',99)) #99是在查找其对应value不存在时，提供的一个默认值
4. key的判断
in 指定的key在字典中存在返回True——‘张三’ in scores；
not in 指定的key在字典中不存在返回False——‘Marry’ not in scores。
#key的判断
print('张三' in scores)
print('张三' not in scores)5. 字典元素的删除
#字典元素的删除
del scores['张三']
print(scores)
#清空字典元素
scores.clear()
print(scores)6. 字典元素的新增
#字典的新增
#新增健值对
scores={'lily':30,'abby':90}
scores['lily']=90
scores['jack']=98
print(scores)
7. 获取字典视图的三个方法
（1）keys()——获取字典中所有的key；
（2）values()——获取字典中所有的value；
（3）items()——获取字典中所有的key，value对。
#获取所有key
scores={'张三':100,'李四':98,'王五':45}
key=scores.keys()
print(key)
print(type(key))
#转成列表
print(list(key))
#获取所有的value
value=scores.values()
print(value)
print(type(value),list(value))
#获取所有的key-value 对
item=scores.items()
print(item)
print(list(item))8. 字典元素的遍历
字典元素的遍历时依次获取字典中的元素，item是指字典中的键，也将会输出字典中所有的键。
scores={'张三':100,'李四':98,'王五':45}
for item in scores:
print(item,scores[item],scores.get(item))9. 字典的特点
（1）字典中的所有元素都是一个key-value对，key不允许重复，value可以重复；
（2）字典中的元素是无序的；
（3）字典中也可以根据需要动态的伸缩；
（4）字典会浪费较大的内存，是一种使用空间换空间的数据。
#字典的特点
#key不能重复，value可以重复
d={'name':'张三','name':'李四'}
print(d) #key重复，value被覆盖掉
#value可以重复
a={'name':'lily','othername':'lily'}
print(a)10. 字典生成式
已知：
item=['fruits','books','others']
prices=[96,78,85]
如何生成{'FRUITS':96,'BOOKS':78,'OTHERS':85}？
使用内置函数zip()：将可迭代的对象作为参数，将对象中对应的元素打包成一个元组，然后返回由这些元组组成的列表。
items=['Fruits','Books','others']
prices=[96,78,85]
lst=zip(items,prices)
print(lst)
print(list(lst))#将对应的元素打包成元组
d={item:price for item,price in zip(items,prices) }
print(d)
a={item.upper():price for item,price in zip(items,prices)}
print(a)三、元组
1. 什么是元组
元组是Python内置的数据结构之一，是一个不可变序列。
t=('Python','hello',90)
不可变序列：字符串、元组，没有增删改操作
可变序列：列表、字典，可以对序列执行增删改操作，对象地址不发生改变
2. 元组的创建方式
#直接小括号
t=('python','hello',90)
print(t,type(t))
#使用内置函数
t=tuple(('python','hello',90))
print(t)
#只包含一个元素的元组要加逗号
t1=(10) #int类型
print(t1,type(t1))
t2=(10,) #tuple类型
print(t2,type(t2))空元组、空列表、空字典的创建
#空列表的创建方式
lst=[]
lst1=list()
print(lst)
print(lst1)
#空字典的创建方式
d={}
d2=dict()
print(d)
print(d2)
#空元组的创建方式
t3=()
t4=tuple()
print(t3)
print(t4)为什么要将元组设计成不可变序列
在多任务环境下，同时操作对象时不需要加锁。因此，在程序中尽量使用不可变对象。
注意事项：元组中存储的是对象的引用。如果元组中对象本身是不可变对象，则不能再引起其他对象；如果元组中的对象本身是可变对象，则可变对象的引用不允许改变，但数据可以改变。例如t=(10,[20,30],9)中，由于[20,30]是列表（可变序列）所以可以向列表中添加元素，而列表的内存地址不变。
#元组是不可变序列
t=(10,[20,30],90)
t[1].append(100)
print(t)3. 元组的遍历
元组是可迭代对象，可以使用for...in循环。
#元组的遍历
t=tuple(('python','hello',90))
for item in t:
print(item)
print(t[0])
print(t[1])
print(t[2])四、集合
1. 什么是集合
集合：Python语言提供的内置数据结构；与列表、字典一样都属于可变类型序列；集合是没有value的字典。
2. 集合的创建方式
#直接使用{}
s={'python','hello',90}
print(s)
#使用内置函数
s1=set(range(6))
print(s1,type(s1))
print(set([3,4,53,56])) #无序
print(set((3,4,43,435)))
print(set('python'))
print(set({124,3,4,4,5}))
#定义一个空集合
s2=set()
print(s2,type(s2))3. 集合的相关操作
（1）集合元素的判断操作
in 或not in
（2）集合元素的新增操作
1.调用add()方法，一次添加一个元素；
2.调用update()方法，至少添加一个元素。
（3）集合元素的删除操作
1.调用remove()方法，一次删除一个指定元素，如果指定的元素不存在抛出KeyError；
2.调用discard()方法，一次删除一个指定元素，如果指定元素不存在不抛出异常；
3.调用pop()方法，一次只删除一个任意元素；
4.调用clear()方法，清空集合。
#判断
s={10,20,30,40,50,60}
print(10 in s)
print(100 in s)
print(100 not in s)
#新增，add()一次新增一个元素，update()至少添加一个元素
s.add(70)
print(s)
s.update({80,90}) #update可放列表，元组，集合
print(s)
s.update([100,110])
print(s)
s.update((120,130))
print(s)
#删除，remove，discard，pop，clear
s.remove(130)
print(s)
'''s.remove(140)
print(s)会报错'''
s.discard(120)
print(s)
s.discard(140) #不会报错
print(s)
s.pop() #任意删除一个
print(s)
s.clear() #清空
print(s)
4. 集合间的关系
（1）两个集合是否相等：可以使用运算符==或!=进行判断；
（2）两个集合是否是另一个集合的子集：可以调用方法issubset进行判断；
（3）一个集合是否是另一个集合的超集：可以调用方法issuperset进行判断；
（4）两个集合是否没有交集：可以调用方法isdisjoint进行判断。
#两个集合是否相等==,!=
s={10,20,30,40}
s1={30,40,20,10}
print(s==s1)
print(s!=s1)
#一个集合是否是另一个的子集
s2={10,20,30,40,50,60}
s3={10,20,30,40}
s4={10,20,40,90}
s5={70,80,90}
print(s3.issubset(s2))
print(s4.issubset(s2))
#一个集合是否是另一个集合的超集
print(s2.issuperset(s3))
print(s2.issuperset(s4))
#两个集合是否没有交集
print(s2.isdisjoint(s3))
print(s2.isdisjoint(s4))
print(s5.isdisjoint(s2))5. 集合的数学操作
#交集操作
s1={10,20,30,40}
s2={20,30,40,50,60}
print(s1.intersection(s2))
print(s1&s2)
#并集操作
print(s1.union(s2))
print(s1|s2)
#差集操作
print(s1.difference(s2))
print(s1-s2)
#对称差集操作
print(s1.symmetric_difference(s2))
print(s1^s2)6. 集合生产式
用于生成集合的公式{i*i for i in range(1,10)}
#集合生成式
s={i*i for i in range(1,10)}
print(s)