索引、切片、字符、列表、元组、字典、集合
一、Python中的索引
定义：我们可以直接使用索引来访问序列中的元素，同时索引可分为 正向和负向两种，而切片也会用到索引，有助于大 家理解正、负向索引的区别，如图所示：
（1）正向索引从0开始：
（2）负向索引从-1开始：
（3）python存在索引： 字符串（string）、列表（list）、元组（tuple）
二、切片
（1）定义：切片是指对操作的对象截取其中一部分的操作，字符串、列表、元组都支持 切片操作。
（2）切片的语法：[start_index : end_index : step]
解释说明：
start_index表示起始索引
end_index表示结束索引
step表示步长，步长不能为0，且默认值为1，2开始有变化
（3）切片时不包含结束索引位
（4）案例：
s=“abcdefghijk”
print(s[3]) #d 从索引0开始
print(s[1:3]) #bc 从索引1开始b，c 索引3结束d，不包含结束值
print(s[0:3]) #abc 从索引0开始a,b，c 索引3结束d，不包含结束值
print(s[:]) #abcdefghijk 从开始索引为空，结束索引位空，空表示所有
print(s[2:]) #abcdefghijk 从索引2开始c，结束索引位空，空表示所有
print(s[::-1]) #kjihgfedcba 反转
print(s[::-2]) #kigeca
print(s[1:6:2]) #bdf
print(s[1:6:3]) #be
print(s[:-1]) #abcdefghij
print(s[::3]) #adgj
print(s[-1:-6:-2]) #kig
print(s[-6👎2]) #fhj
print(s[2:-1]) #cdefghij
三、Python中的字符串
（1）字符串是Python中最常用的数据类型。
（2）单引号’‘或者双引号"“来创建字 符串都可以
（3）字符类型：<class ‘str’>
（4）详解：
1、capitalize()：首字符大写
案例：
a=‘abcdefjhijk’
print(a.capitalize()) #Abcde fjh ijk
备注：titie 标题化首个字母大写
a=‘abcde fjh ijk’
print(a.title()) #Abcde Fjh Ijk
2、count()：统计具体字符出现的次数
案例：
a=‘abcdeafjhaijk’
print(a.count(“a”))
3、join()：把集合中的字符按自定义的分隔符连接在一起
案例：
a=‘abcdeafjhaijk’
print(”%".join(a)) #a%b%c%d%e%a%f%j%h%a%i%j%k
4、split()：把字符串通过指定标识符进行分割
案例：
a=‘abcd eafjhaijk’
print(a.split(“d”)) #结果：[‘abc’, ’ eafjhaijk’]
5、strip(字符)：删除字符串开头和结尾有a的字符
案例：
a=‘abcd eafjhaijka’
print(a.strip(“a”)) 结果：bcd eafjhaijk
6、lstrip(ab)：删除字符串开头有a序列字符
案例：
a=‘abcd eafjhaijka’
print(a.lstrip(“a”)) 结果：bcd eafjhaijka
7、rstrip(ab)：删除字符串结尾有ab序列字符
案例：
a=‘abcd eafjhaijka’
print(a.rstrip(“a”)) 结果：abcd eafjhaijk
8、startswith()：判断字符串是否以什么开始
正确案例：
a=‘abcd eafjhaijka’
print(a.startswith(“a”)) 结果：True
错误案例：
a=‘abcd eafjhaijka’
print(a.startswith(“k”)) 结果：False
9、endswith()：判断字符串是否以什么结束
正确案例：
a=‘abcd eafjhaijkab’
print(a.endswith(“b”)) 结果：True
错误案例：
a=‘abcd eafjhaijkab’
print(a.endswith(“a”)) #False
10、find()/rfind()：字符串查询find()是左边开始查，rfind()从右边开始查，结果 显示下标
（1）find：
案例：从左往右找，找到了第一个就停止查找
情况一：查找存在字符，显示索引位
a=‘abcdeafjchaijkab’
print(a.find(“c”)) 结果：2
情况2：查找不存在的字符,结果是：-1
a=‘abcdeafjchaijkab’
print(a.find(“z”)) 结果：-1
（2）rfind 从右往左查找，找到了就显示第一个的索引位
情况1：存在的字符
a=‘abcdeafjchaijkab’
print(a.rfind(“c”)) #显示索引位8
情况2：不存在的字符 ，结果显示-1
a=‘abcdeafjchaijkab’
print(a.rfind(“p”)) #结果显示-1
11、replace()：replace(substring,newstring,max) substring表示被替换的字 符串,newstring要替换字符串,max表示替换的次数
案例：
a=‘abcdeafjchaicjkab’
print(a.replace(“c”,“8”,2))
12、lower()：方法转换字符串中所有大写字符为小写
案例：
b=“ABCD”
print(b.lower()) 结果：abcd
13、upper()：将字符串中的所有小写字符转换为大写字母输出
案例：
c=“abc”
print(c.upper()) 结果：ABC
14、isdigit()：判断字符串中是否全为数字
情况1：全为数字
a=‘123’
print(a.isdigit()) 结果：True
情况2：不是全为数字：
a=‘abcdeaf1jchai3cjkab’
print(a.isdigit()) #False
15、isalpha()：判断字符串中是否全为字母
情况1：全为字母
a=‘abc’
print(a.isalpha()) 结果：True
情况2：不是全为字母
a=‘abc11’
print(a.isalpha()) 结果：False
16、isalnum()：判断字符串当中是否全都为数字，全为字母，或者数字字母组合 返回布尔值：True和False 如果有特殊符号就是否
情况1：数字和字母存在
a=‘abc11’
print(a.isalnum()) #结果：True
情况2：纯字母也正确
a=‘abc’
print(a.isalnum()) 结果： #True
情况3：纯数字也是正确
a=‘123’
print(a.isalnum())结果: #True
17、istitle()：判断字符串中首字母是否为大写，其他是否为小写，其他不为小写则为否
情况1：a=‘Abcd’
print(a.istitle()) 结果：True
情况2：全是大写也报错：
a=‘ADVB’
print(a.istitle()) #False
18、isupper()/islower():is开头的就是判断一个字符串是否展示为都是大写或者都是小写
情况1：isupper() 判断全为大写
a=‘ABCD’
print(a.isupper()) #结果：True
情况2：islower()判断全为小写
a=‘abcd’
print(a.islower()) #True
==============================
四、Python中的列表
（1）定义：列表（list）是一组有序存储的数据，也是python常见的序列之一，序列 中的每个元素都分配一个索引，第一个元素索引是0，第二个元素索引是1，依此 类推。
（2）列表表达符为：[ ]
（3）字符类型：<class ‘list’>
（4）定义列表的两种方法：
方法一：list1 = [1,2,3,4] #直接通过[ ]进行定义
案例：# list=[1,2,3,4,5,6,7,8]
print(type(list))
print（s）
方法二：list2 = list(‘1234’) #使用list()方法进行定义
案例：通过list将字符串转换成列表
list1=“abcd”
print(type(list1)) #<class ‘str’>
s=list(list1)
print(type(s)) #<class ‘list’>
print(s) #[‘a’, ‘b’, ‘c’, ‘d’]
（5）列表中对应的函数详解：
1、索引和切片赋值
案例1：通过索引替换列表中的值
li=[1,2,3,4,5,6,7,8]
li [1]=“a”
print(li)
案例2：
li=[1,2,3,4,5,6,7,8]
li [3:]=“西安多测师”
print(li)结果：[1, 2, 3, ‘西’, ‘安’, ‘多’, ‘测’, ‘师’]
2、append函数：添加一个元素
案例：默认添加在最后一位
li=[1,2,3,4,5,6,7,8]
li.append(“dcs”)
print(li)
3、extend函数：连接两个列表
案例：
li=[1,2,3,4,5,6,7,8]
li1=[9,10,11]
li.extend(li1)
print(li) 结果：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]、
4、insert(index,value)函数：在指定位置插入一条数据
情况1：索引在范围内：插入的值在索引位上，之前索引位上的数+1
li=[1,2,3,4,5,6,7,8]
li.insert(3,“a”)
print(li) #[1, 2, 3, ‘a’, 4, 5, 6, 7, 8]
情况2：超出索引位，直接默认在最后一位插入
li=[1,2,3,4,5,6,7,8]
li.insert(20,“a”)
print(li) #[1, 2, 3, 4, 5, 6, 7, 8, ‘a’]
5、remove函数：移除元素
li=[1,2,3,4,5,6,7,8]
li.remove(4)
print(li) 结果：[1, 2, 3, 5, 6, 7, 8]
6、del 删除值
案例：
li=[1,2,3,4,5,6,7,8]
del li[3]
print(li) 结果：[1, 2, 3, 5, 6, 7, 8]
7、index函数：在列表中查找元素所对应的索引值
案例：
li=[1,2,3,4,5,6,7,8]
print(li.index(4)) # 索引位：3 #结果：3
8、sort函数：实现列表的升序排列
案例：
i=[1,2,9,11,5,6,7,8]
li.sort()
print(li) #[1, 2, 5, 6, 7, 8, 9, 11]
9、sorted函数：实现降序排列
案例：
li=[1,2,9,11,5,6,7,8]
print(sorted(li,reverse=True)) #降序
print(sorted(li,reverse=False)) #升序
10、reverse函数：列表元素反转
案例：
li=[1,2,9,11,5,6,7,8]
li.reverse()
print(li) 结果：[8, 7, 6, 5, 11, 9, 2, 1]
11、pop函数：默认删除左后一位
情况1：
li=[1,2,9,11,5,6,7,8]
li.pop()
print(li) #结果：[1, 2, 9, 11, 5, 6, 7]
情况2：根据索引位删除列表中的值
li=[1,2,9,11,5,6,7,8]
li.pop(2)
print(li) #[1, 2, 11, 5, 6, 7, 8]
=========================
五、Python中的元组
（1）定义：元组（tuple）是Python中常用的一种数据结构。元组由不同的元素组成， 每个元素可以存储不同类型的数据，如字符串、数字、甚至元组。
（2）元组是’写保护’ 的，即元组中元素作为一个整体，创建后不能再做任何修改操作
（3）元组表达符为：()
（4）元组字符类型：<class ‘tuple’>
（5）元组的定义：s=(1,2,3)
备注：注意：当元组只有一个元素时,后面要加逗号，
案例：
s1=(1,)
print(type(s1))#<class ‘tuple’>
（6）元组常见操作：
1、元组转换为列表
案例：
s=(1,2,3)
print(type(s)) #<class ‘tuple’>
print(s) #(1, 2, 3)
list1=list(s) #通过list将元组转换成列表
print(list1) #[1, 2, 3]
print(type(list1)) #<class ‘list’>
2、列表转换为元组
案例：
list1=[1, 2, 3]
print(type(list1)) #<class ‘list’>
print(list1) #[1, 2, 3]
t=tuple(list1) #将列表通过tuple转换成元组
print(t)#(1, 2, 3)
print(type(t)) #<class ‘tuple’>
3、元组中的值是可以间接来改变
案例：
s=(1,2,3)
list1=list(s) #通过list将元组转换成列表
print(list1)
list1.append(4) #通过函数对转换的列表进行修改
print(list1)
t=tuple(list1) #将修改好的列表转换成元组
print(t)
4、元组和列表的区别
（1）符号不同： 列表 [ ] ,元组（）
（2）字符类型不同： list 、tuple
（3） 元组有序、列表有序
（4）列表可变，元组不可变
5、元组通有序，可以通过索引或切片取值
案例：
s=(1,2,3)
print(s[1]) #2
=========================
六、Python中的字典
（1）定义： 字典（dict）是另一种可变容器模型，且可存储任意类型对象。
（2）字典的 每个键值key：value对用冒号 : 分割，每个键值对之间用逗号分割，
（3）字典表达符：{}
（4）字典字符类型：<class ‘dict’>
（5）字典同时是无序，字典都是以键值对的形式存在，先键后值，键是唯一 的，值且不唯一
（6）字典的定义方式： 方式
方式一：通过{}直接定义字典
zd={‘name’:“wm”,‘age’:18}
print(type(zd)) #<class ‘dict’>
print(zd)
方式二：将列表转换成字典
案例：
list1=[(“name”,“wm”),(“age”,18)]
print(type(list1) )#<class ‘list’>
zd=dict(list1)
print(type(zd)) #<class ‘dict’>
print(zd) #{‘name’: ‘wm’, ‘age’: 18}
（7）字典中常见的函数
1、添加一个键值对
情况1：添加键值对，不存在的情况下
zd={‘name’:“wm”,‘age’:18}
zd[“sex”]=“女”
print(zd) #{‘name’: ‘wm’, ‘age’: 18, ‘sex’: ‘女’}
情况2：添加键值对，存在的情况下，替换值，键不变
zd={‘name’:“wm”,‘age’:18}
zd[“age”]=20
print(zd) #{‘name’: ‘wm’, ‘age’: 20}
2、keys取出键返回列表
案例：zd={‘name’:“wm”,‘age’:18}
print(zd.keys()) #dict_keys([‘name’, ‘age’])
3、values取出值返回列表
案例：
zd={‘name’:“wm”,‘age’:18}
print(zd.values()) #dict_values([‘wm’, 18])
4、根据具体键取值
案例：
zd={‘name’:“wm”,‘age’:18}
print(zd[‘name’]) #wm
5、字典添加元素setdefault（）
情况1：不存在键值的情况下
zd={‘name’:“wm”,‘age’:18}
zd.setdefault(“sex”,“男”)
print(zd)
情况2：存在键值的情况下，默认值的优先级小于字典本身值
zd={‘name’:“wm”,‘age’:18}
zd.setdefault(“age”,“20”)
print(zd) #{‘name’: ‘wm’, ‘age’: 18}
6、del删除字典
案例：
zd={‘name’:“wm”,‘age’:18}
del(zd)
print(zd) #报错：NameError: name ‘zd’ is not defined
7、删除指定的键，连同值也删除
案例：
zd={‘name’:“wm”,‘age’:18}
del zd[“name”]
print(zd) #{‘age’: 18}
8、字典的遍历：for…in…遍历字典
情况1：for循环遍历键key
zd={‘name’:“wm”,‘age’:18}
for i in zd:
print(i)
备注：end=" " 横向输出
情况2：for循环遍历键key和值 values
zd={‘name’:“wm”,‘age’:18}
for i in zd:
print(i,zd[i])
结果： name wm
age 18
9、使用items()完成遍历
案例：
zd={‘name’:“wm”,‘age’:18}
for k,v in zd.items():
print(k,v)
10、pop(key)函数，删除指定键并返回删除的值
情况1：
zd={‘name’:“wm”,‘age’:18}
print(zd.pop(“name”)) #wm
情况2：通过pop删除字典后的结果
zd={‘name’:“wm”,‘age’:18}
zd.pop(“name”)
print(zd)
11、clear()清空字典所有项
案例：
zd={‘name’:“wm”,‘age’:18}
zd.clear()
print(zd) 结果： {}
12、get(key)方法,通过key获取值,当键不存在,返回None
情况1:get获取键存在，则显示值
zd={‘name’:“wm”,‘age’:18}
print(zd.get(“name”)) #wm
情况2：get获取键不存在，则显示none
zd={‘name’:“wm”,‘age’:18}
print(zd.get(“sex”)) #None
13、fromkeys函数可以给具体的键指定值
（1）快速创建一个字典：
print({}.fromkeys([“name”,“age”]))
（2）快速创建一个字典的键和值
print({}.fromkeys([“name”,“age”],“a”))
14、update函数利用一个字典更新另外一个字典
案例：
zd={‘name’:“wm”,‘age’:18}
zd1={“sex”:" 男"}
zd.update(zd1)
print(zd) #{‘name’: ‘wm’, ‘age’: 18, ‘sex’: ’ 男’}
print(zd1) # print(zd1)
15、popitem函数随机返回并删除字典中的键值对(一般删除末尾对) 如果字典已经为空，却调用了此方法，就报出KeyError异常
情况1：默认删除最后一组
zd={‘name’:“wm”,‘age’:18}
zd.popitem()
print(zd) #{‘name’: ‘wm’
情况2：删除一个空字典，报错
zd={}
zd.popitem()
print(zd) 结果：KeyError: ‘popitem(): dictionary is empty’
16、copy 复制字典
案例：
zd={‘name’:“wm”,‘age’:18}
s=zd.copy()
print(zd) 结果：{‘name’: ‘wm’, ‘age’: 18}
print(s) 结果：{‘name’: ‘wm’, ‘age’: 18}
===================================
七、Python中的集合
1、定义：集合是不同元素的无序集合，与序列类型不同，集合没有切片成操作
2、语法：set
3、集合：最重要的功能就是去重
4、字符类型：可变集合：#<class ‘set’> 不可变集合：<class ‘frozenset’>
5、集合类型分类：
（1）可变集合：set 集合里面的元素可以发生改变，集合中可以动态增加和删除
（2）不可变集合：frozenset 集合里面的元素是不可变化
3、可变集合函数
（1）数据重复，进行去重
案例1：对列表数据重复，进行去重
list1=[1,2,1,3,4,1,2]
print(type(list1)) #<class ‘list’>
c=set(list1)
print? #{1, 2, 3, 4}
print(type?) #<class ‘set’>
案例2：对字符重复，进行去重
str1=“abcamnc”
c=set(str1)
print?
（1）add函数
案例：
str1=“abcamnc”
c=set(str1)
c.add(“h”)
print?
（2）remove函数
案例：
list1=[1,2,1,3,4,1,2]
c=set(list1)
c.remove(1)
print? 结果：{2, 3, 4}
（3）clear函数
案例：
list1=[1,2,1,3,4,1,2]
c=set(list1)
c.clear()
print? 结果：set()
（4）pop函数 ##把最前面这个给删除了
list1=[1,2,1,3,4,1,2]
案例：
c=set(list1)
c.pop()
print? 结果：{2, 3, 4}
4、不可变集合函数
类型：<class ‘frozenset’>
案例：
list1=[1,2,1,3,4,1,2]
c=frozenset(list1)
print?#frozenset({1, 2, 3, 4})
（1）只有copy函数可以使用
案例：
list1=[1,2,1,3,4,1,2]
c=frozenset(list1)
s=c.copy()
print?
print(s)