切片，字符，列表，元组，字典，集合
===============================
一、python的索引
（1）定义：我们可以直接使用索引来访问序列中的元素，
（2）索引可分为：正向索引和负向索引
正向索引：从0开始
负向索引：从-1开始
（3）Python中的序列，包括字符串(String)、列表(List)、元组(Tuple)
二、切片
（1）
定义：切片是指对操作的对象截取其中一部分的操作，字符串、列表、元组都支持
切片操作。
（2）
切片的语法：[ 开始索引: 结束索引值 : 步长]
步长不能为0，且默认值为1
（3）切片中包含开始值，不包含结束值
（4）range 函数
案例：
print(list(range(10)))
print(list(range(3,10)))
print(list(range(1,11,2)))
print(list(range(0,11,2)))
（5）案例：
s='abcdefghijk'
print(s[1])#根据正向索引取值 1就是表示b #索正引从0开始
print(s[-2]) #根据负向索引取值 -2就是表示j #负索引从-1开始
print( s[1:4]) #bcd 根据正向索引取值 ，包含索引1，2,3
print(s[:]) # 显示所有abcdefghijk
print(s[2:] ) #cdefghijk 从索引2开始取空值表示所有
print(s[::-1] ) #反转 #kjihgfedcba
print(s[2:6:2] ) #ce 2 是步长
print(s[-2:-7:-2] ) #jhf 负向索引取值
print( s[:5]) #abcde
==================================
字符：
（1）字符串的定义：用单引号或双引号括起来，（英文）
（2）类型：<class 'str'>
案例： s='abcdefghijk'
c="abcdefghijk"
print(type(s))#<class 'str'>
print(type(c)) #<class 'str'>
（3）str 转换成字符类型
m=1
print(type(m)) #<class 'int'>
print(type(str(1))) #<class 'str'>
（4）常见的函数：
n='Abc'
x='xyz'
y="1234"
z="123abc"
#1、capitalize()：首字符大写
# print(s.capitalize()) #Abcdefghijk
# #2.标题化首个字母大写
# print(s.title())#标题化首个字母大 #Abcdefg Hi Jk
# 3.count()：统计具体字符出现的次数
# print(s.count("a")) #3
# # 4.join()：把集合中的字符按自定义的分隔符连接在一起
# print(', '.join(s))
# # 5.split()：把字符串通过指定标识符进行分割
# print(s.split("e"))
# 6.strip()：删除字符串开头和结尾有a或b的字符
# print(s.strip("a"))
# 7.lstrip(ab)：删除字符串开头有a序列字符
# print(s.lstrip("a")) #bacdefaghijka
# # 8.删除字符串结尾有a序列字符
# print(s.rstrip("a")) #abacdefaghijk
# # 9.endswith()：判断字符串是否以什么结束
# print(s.endswith("a")) #True 对
# print(s.endswith("b")) #False 错
# 10、startswith()：判断字符串是否以什么开始
# print(s.startswith("ab")) #True
# 11.find()/rfind()：字符串查询find()是开始查，rfind()从右边开始查，结果 显示下标左边
# print(s.find("c")) #3 从左边开始找，找到第一个就结束，显示索引位
# print(s.rfind("c")) #8 从右边开始找，找到第一个就结束，显示索引位
# print(s.rfind("*")) #-1 查找不存在的数据
# print(s.find("*")) #-1 查找不存在的数据
#11、replace()：replace(substring,newstring,max) substring表示被替换的字
# print(s.replace('a','v')) #vbvcdefvcghijkv 替换了所有的数据
# print(s.replace('a','v',2)) #vbvcdefacghijka 2表示替换次数从左往右替换
# 12、lower()：方法转换字符串中所有大写字符为小写
# print(c.lower()) #abcd
#13upper()：将字符串中的所有小写字符转换为大写字母输出
# print(x.upper()) #XYZ
# #isdigit()：判断字符串中是否全为数字
# print(y.isdigit()) #True
# print(z.isdigit()) #False
# # isalpha()：判断字符串中是否全为字母
# print(c.isalpha()) #True
# print(z.isalpha()) #False
#isalnum()：判断字符串当中是否全都为数字，全为字母，或者数字字母组合 返回布尔值：True和False 如果有特殊符号就是否
# print(x.isalnum()) #True
# print(y.isalnum()) #True
# print(z.isalnum()) #True
#istitle()：判断字符串中首字母是否为大写，其他是否为小写，其他不为小写则为否
# print(c.istitle()) #False
# print(n.istitle()) #True
# isupper()/islower():is开头的就是判断一个字符串是否展示为都是大写或者都是小写
print(c.isupper()) #True
print(x.islower()) #True
print(n.islower()) #False
print(n.isupper()) #False
========================================
列表：
（1）定义：列表（list）是一组有序存储的数据，也是python常见的序列之一，
（2）单词：list
（3）符号：[]
（4）字符类型：<class 'list'>
（5）定义列表的两种方法：
方法一：list1 = [1,2,3,4] #直接通过[]进行定义
案例：
a=[1,2,3,4]
print(type(a)) #<class 'list'>
方法二：list2 = list('1234') #使用list()方法进行定义
案例：
b='1234'
print(type(b)) #<class 'str'>
print(list(b)) #['1', '2', '3']
print(type(list(b))) #<class 'list'>
(6)列表操作
1、通过索引赋值：格式 列表名[索引]='新值'
2、append函数：添加一个元素
3、extend函数：连接两个列表
4、insert(index,value)函数：在指定位置插入一条数据
5、remove函数：移除元素
6、del 索引删除值
7、index函数：在列表中查找元素所对应的索引值
8、sort函数：实现列表的升序排列
9、sorted函数：实现降序排列
10、reverse函数：列表元素反转
11、pop函数：
=======================
案例：
1、通过索引赋值：格式 列表名[索引]='新值'
案例1：
a=[1,2,3,4，5]
a[2]='v'
print(a) #[1, 2, 'v', 4, 5]
案例2：
a=[1,2,3,4,5]
a[2:]='v'
print(a) #[1, 2, 'v']
2、append函数：添加一个元素
默认添加在最后一位
案例：
a=[1,2,3,4,5]
a.append("v")
print(a)
3、extend函数：连接两个列表
案例：
a=[1,2,3,4,5]
b=[7,8,9,10]
a.extend(b)
print(a) #[1, 2, 3, 4, 5, 7, 8, 9, 10]
print(b) #[7, 8, 9, 10]
4、insert(index,value)函数：在指定位置插入一条数据
插入的数据的原来的数据，往后移动一位，在插入
案例1：在索引范围
a=[1,2,3,4,5]
a.insert(2,'v')
print(a)
案例2：超出索引位，添加在末尾
a=[1,2,3,4,5]
a.insert(10,'v')
print(a) #[1, 2, 3, 4, 5, 'v']
案例3：插入负向索引
a=[1,2,3,4,5]
a.insert(-2,'v')
print(a ) #[1, 2, 3, 'v', 4, 5]
5、remove函数：移除元素
案例1：删除存在的值
a=[1,2,3,4,5]
a.remove(4)
print(a)
案例2：删除不存在的值，直接报错
a=[1,2,3,4,5]
a.remove(6)
print(a)
案例3：删除多个值的情况，从左往右删除
a=[1,2,5,3,4,5]
a.remove(5)
print(a)
6、del 索引删除值
案例:
a=[1,2,5,3,4,5]
del a[2]
print(a) #[1, 2, 3, 4, 5]
7、index函数：在列表中查找元素所对应的索引值
案例：
a=[1,2,5,3,4,5]
print(a.index(3)) #3
8、sort函数：实现列表的升序排列
案例1：
a=[1,8,2,6,3,4,5]
a.sort()
print(a)
案例2：
a=[1,8,2,6,3,4,5,"a"]
a.sort()
print(a)报错：字母和数字不能同时进行排序
9、sorted函数：实现降序排列
案例：
a=[1,8,2,6,3,4,5]
print(sorted(a,reverse=True)) #降序
print(sorted(a,reverse= False))#升序
10、reverse函数：列表元素反转
案例:
a=[1,8,2,6,3,4,5]
a.reverse()
print(a)
11、pop函数：
案例1：默认删除
a=[1,8,2,6,3,4,5]
a.pop()
print(a)
案例2：根据索引删除
a=[1,8,2,6,3,4,5]
a.pop(1)
print(a) #[1, 2, 6, 3, 4, 5]
=======================
元组：
定义：
1、定义：元组（tuple）是Python中常用的一种数据结构。元组由不同的元素组成，
每个元素可以存储不同类型的数据，如字符串、数字、甚至元组。元组是'写保护'
的，即元组中元素作为一个整体，创建后不能再做任何修改操作。
2、符号：（）
3、类型：<class 'tuple'>
4、 单词：tuple
5、特殊情况：当出现一位数据时，加上一个逗号
a=(1)
print(type(a)) #<class 'int'>
6、元组是不可变，有序
7、元组的实战
（1）通过索引取值
案例：
a=(1,2,3)
print(a[1])
（2）要修改元组，就要将元组通过list改成列表，在修改，修改好在通过转回元组
a=(1,2,3,4,5,6)
print(type(a))#<class 'tuple'>
b=list(a) #通过list将元组转换成列表
print(type(b)) #<class 'list'>
print(b)
b.append(8) #通过列表中函数操作
print(b)
c=tuple(b)#通过tuple将列表转换成元组
print(type(c)) #<class 'tuple'>
print(c)
（3）元组和列表的区别？
相同：
a、都是序列类型的容器对象，可以存放任何类型的数据
b、支持切片、迭代等操作
不同：
a、list 是可变的对象，元组tuple是不可变的对象
b、tuple不可变，所以使用tuple可以使代码更安全
==========================================
Python中的字典
1、定义：
字典（dict）是另一种可变容器模型，且可存储任意类型对象
2.键值对的形式存在
字典的每个键值key：value对用冒号 : 分割
3、符号：{ }
4、字符类型：<class 'dict'>
5、定义字典：
（1）直接定义{}
案例：
d={'name':"wd",'age':'18'}
（2）通过dict 转换成字典
案例
a=[('name',"wd"),('age','18')]
print(type(a)) #<class 'list'>
zd=dict(a)
print(type(zd)) #<class 'dict'>
print(zd) #{'name': 'wd', 'age': '18'}
6、字典的实战
（1）添加一个键值对
案例一：添加新的键值，默认添加在最后
d={'name':"wd",'age':'18'}
d ['sex']=' 女'
print(d)
案例二：已存在的键值 #键不变修改值
d={'name':"wd",'age':'18'}
d ['age']=' 20'
print(d)
（2）取出键返回列表
d={'name':"wd",'age':'18'}
print(d.keys())
（3）取出值返回列表
d={'name':"wd",'age':'18'}
print(d.values()) #dict_values(['wd', '18'])
（4）取出具体键的值
d={'name':"wd",'age':'18'}
print(d['age']) #18
（5）字典添加元素setdefault（）
案例1:不存在的数据，直接添加
d={'name':"wd",'age':'18'}
d.setdefault("sex","女")
print(d)
案例2:存在的数据，默认值的优先级小于字典本身
d={'name':"wd",'age':'18'}
d.setdefault("age",'20')
print(d)
（6）del 删除字典
d={'name':"wd",'age':'18'}
del (d) 字典不存在
7、删除指定的键，连同值也删除
d={'name':"wd",'age':'18'}
del d['name']
print(d)
8、字典的遍历：for...in...遍历字典
案例：
d={'name':"wd",'age':'18'}
for k in d:
print(k,d[k])
9、通过for循环获取所有键
d={'name':"wd",'age':'18'}
for k in d:
print(k)
10、使用items()完成遍历
d={'name':"wd",'age':'18'}
for k,v in d.items():
print(k,v)
11、pop(key)函数，删除指定键并返回删除的值
案例1：删除后的内容
d={'name':"wd",'age':'18'}
d.pop("name")
print(d)
案例2：打印出删除内容
d={'name':"wd",'age':'18'}
print(d.pop("name")) #wd
12、clear()清空字典所有项
d={'name':"wd",'age':'18'}
d.clear()
print(d) #返回一个{}空
13、get(key)方法,通过key获取值,当键不存在,返回None
案例1：get获取存在的值
d={'name':"wd",'age':'18'}
print(d.get('age'))#18
案例2：get获取不存在的值 ，结果是none值
d={'name':"wd",'age':'18'}
print(d.get('a'))
14、fromkeys函数可以给具体的键指定值
（1）快速生成字典，键
print({}.fromkeys(['name','age']))
（2）快速生成字典键和值
print({}.fromkeys(['name','age'],"s"))
（3）已经存在的字典，通过fromkeys重新赋值
d={'name':"wd",'age':'18'}
print(d.fromkeys(['name','age'],"s"))
15、popitem函数随机返回并删除字典中的键值对(一般删除末尾对)
案例：
d={'name':"wd",'age':'18'}
print(d.popitem())
16、update函数利用一个字典更新另外一个字典
案例1：
d={'name':"wd",'age':'18'}
c={"sex":'男'}
d.update(c)
print(d)
print(c)
17、copy复制字典
d={'name':"wd",'age':'18'}
s=d.copy()
print(s)
print(d)
==========================================
集合
（1）集合是不同元素的无序集合，与序列类型不同，集合是没有切片操作
（2）单词：set 可变集合 ，frozenset 不可变集合
a .可变集合：集合里面的元素是可以发生改变，集合中的数据可以修改
b.不可变集合：集合汇总的元素是不可以发生变化
（3）集合：最重要的功能就是去重
(4)集合是无序，集合的元素是不重复的
（5）字符类型：可变集合：<class 'set'>
一、可变集合
（1）对重复的数据，进行去重
案例1：对列表进行去重
a=[1,2,5,2,6,2,8]
b=set(a)
print(b) #{1, 2, 5, 6, 8}
print(type(b))
案例1：对字符进行去重
a='abcdssakm'
b=set(a)
print(b) #{'b', 's', 'm', 'c', 'k', 'a', 'd'}
print(type(b))
二、可变集合操作
（1）add添加元素 ，位置随机添加
a=[1,2,5,2,6,2,8]
b=set(a)
b.add("dd")
print(b)
（2）remove 删除元素
a=[1,2,5,2,6,2,8]
b=set(a)
b.remove(8)
print(b)
（3）pop 删除 #
#把最前面这个给删除了
a=[1,2,5,2,6,2,8]
b=set(a)
b.pop()
print(b)
（4）clear（） 清除，返回set空集合
a=[1,2,5,2,6,2,8]
b=set(a)
b.clear()
print(b)
5、update 添加元素到集合中
a=[1,2,5,2,6,2,8]
b=set(a)
b.update("r")
print(b)
6、copy 复制集合
a=[1,2,5,2,6,2,8]
b=set(a)
c=b.copy()
print(b)
print(c)
======================================
不可变集合frozenset
1、不能添加，修改，只能复制
2、类型：<class 'frozenset'>
2、类型：<class 'frozenset'>
3,单词:frozenset
4、copy 不可编辑和
案例：
a=[1,2,5,2,6,2,8]
b=frozenset(a)
c=b.copy()
print(b)
print(c)
======================================
面试题：
1、字典和元组的区别？
2、如何对列表排序？
3、如何使一个字符反转？
4、字典，元组，列表，集合区别？
5、如何对一组数据去重？
6、如何统计一个元素重现次数？
