多测师拱墅校区肖sir

一、索引
（1）索引在公司中一般叫做下标或角标。
（2）索引分为：
正向索引 ：从0开始
负向索引：从-1开始

（3）我（3）通过索引位读取序列中的指定元素 ，索引的表达式：
格式：【开始索引，结束索引，步长】
str 【索引位】
str【x】
备注：切片的语法：包含开始，不包含结束，隔位不能为0,，可以为为1,1表示隔位，从2开始有效果。
s=‘abcdefghigjklmn’
print(s[3]) #d #正向索引
print(s[5]) #f #正向索引
print(s[-3]) # l #负向索引
print(s[1:4]) # bcd #1表示开始值，4表示结束值 ，不包含结束值
print(s[-4:-1]) #klm #-4开始值，-1结束值，不包含结束值
print(s[-1:-4:-1]) #nml #开始值是-1，结束值-4，步长-1
print(s[:]) #abcdefghigjklmn 显示所有,开始值为空代表所有，结束值为空也代表所有
print(s[3:])#defghigjklmn 显示3开始值，结束值是所有，
print(s[::-1]) #nmlkjgihgfedcba 反转
print(s[1:6:2]) #bdf 1表示开始值，6表示结束值，2 表示步长
print(s[-2:-6:-2]) #mk -2开始值是，结束值-6， 步长是-2
#abcdefghigjklmn 显示所有print(s[::1])
print(s[::2]) #acegijln

======================================
python字符串函数
字符串的定要用单引号或者双引号英文括起来
字符类型：
案例：
s=‘abcdefghigjklmn’
print(type(s))
（1）函数 capitalize() ：实现首个字母大写输出 (第一个字母大写，其他字母小写)
案例：
s=‘abcdefghigjklmn’
print(s.capitalize())

（2）title 表示 返回标题化字符串，也是表示首个字母大写
s=‘abcdefg higjklmn’
print(s.title())

（3）count ：统计指定的字符在当前字符串中出现的次数
s=‘abcdefgaaahigjklmn’
print(s.count(“a”)) 结果：4
（4）join 拼接函数, 自动定义分割，来分割当前的字符串（自定义符号）
s=‘abcdefgaaahigjklmn’
print(''.join(s)) #结果：abcdefgaaahigjklmn
（5）split 分割函数，指定当前字符串的一个字符作为分割符，且结果返回一个列表
s=‘abcdefgaaahigjklmn’
print(s.split(“c”)) #[‘ab’, ‘defgaaahigjklmn’]
案例：
s=‘abcdef:gaaahigjklmn’
print(s.split(“:”))
（6）strip 删除字符串开头和结尾的字符
s=‘abcdef:gaaahigjklmn’
print(s.strip(“n”))
结果：abcdef:gaaahigjklm
（7）lstrip 删除字符以‘xx’开头的内容
s=‘abcdef:gaaahigjklmn’
print(s.lstrip(“a”)
（8）rsttip 删除字符以‘xx’ 结尾的内容
s=‘abcdef:gaaahigjklmn’
print(s.rstrip(“n”))
（9）startswith 判断字符串中以“xx”字符串开头，如果条件成立返回True，False
正确的案例
s=‘abcdef:gaaahigjklmn’
print(s.startswith(“a”)) #True
错误的案例：
s=‘abcdef:gaaahigjklmn’
print(s.startswith(“b”)) #False
（10）endtswith 判断字符串中以“xx”字符串结尾，如果条件成立返回True，False
正确案例：
s=‘abcdef:gaaahigjklmn’
print(s.endswith(“n”))
错误案例：
s=‘abcdef:gaaahigjklmn’
print(s.endswith(“m”)) #False

（11）find
从字符串左边开始查找指定的字符串，且返回的是当前字符的索引位，一旦找到第一个将停止查找，如果查找的对象不存在，则返回-1
案例：
s=‘abcdef:gaaahigjklmn’
print(s.find(“c”)) #结果：2

（12）rfind 从字符串的右边开始查找指定的字符串，且返回的是当前字符的索引位，一旦找到第一个将停止查找，如果查找的对象不存再则返回-1
s=‘abcdef:gaaachigjklmn’
print(s.rfind(“c”)) #11

（13）replace 替换
a、替换所有的数据
s=‘abcdef:gaaachigjklmn’
print(s.replace(“c”,“q”))

b、替换指定的次数
格式：（原值，替换新值，次数）
s=‘acbcdcef:gaacachigjklmn’
print(s.replace(“c”,“q”,3))

（14）
lower 将字符串中的所有字母改成小写
案例：
s1=‘AABCD’
print(s1.lower())

（15）upper 将字符串中的所有字母小写改为大写
案例：
s=‘acbcdcef:gaacachigjklmn’
s1=‘AABCD’
print(s.upper())

（16）isalnum 判断字符串是否字母或数字，或字母和数字组合
正确的案例1：
s=‘acbcd1111cefgaacachigjklmn’
print(s.isalnum()) #True

（17）isdigit 判断字符是否是全数字
错误案例：
s=‘acbcd1111cefgaacachigjklmn’
print(s.isdigit())

争取案例：
s1=“123243”
print(s1.isdigit())

（18）islower

a.判断字符是否全部小写
错误案例：
s1=“SDSFAS aaa”
print(s1.islower()) #结果：False
（19）
b、判断字符是否全部大写
s1=“SDSFAS”
print(s1.isupper()) #结果:True

(20)istitle
判断字符串中首个字母改为大写，其他为字母改成小写
s1=“Sa”
print(s1.istitle())

=========================================

列表：
单词：list
括号：[ ] 英文的中括号
类型：
定义列表的方式：
第一种：直接通过[] 中括号定义
案例：list=[1,2,3,4,5]
第二种：通过list装换
a=‘hzdcs’ #字符类型
b=list(a) list转换成列表
print(b)

============================
列表的 *** 作：
（1）通过索引索引
案例：通过索引赋值（内容是覆盖原有数据）
li=[1,2,3,4,5]
li[2]=6
print(li) 结果：[1, 2, 6, 4, 5]

（2）替换部分值
li=[1,2,3,4,5]
li[2:]=“7845546”
print(li)

（3）append 添加元素 （一般默认添加在最后一位）
li=[1,2,3,4,5]
li.append(“hz”)
print(li) 结果：[1, 2, 3, 4, 5, ‘hz’]

（4）extend 列表的拼接 （将两个列表中的值通过extend 函数来形成一个表）
li=[1,2,3,4,5]
st=[5,6,7,8,9,10]
li.extend(st)
print(li) #结果：[1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 10]
print(st) #结果：[5, 6, 7, 8, 9, 10]

（5）insrt 插入一个具体的值 （根据索引插入值，原来索引位的 往后推）
案例1：
li=[1,2,3,4,5]
st=[5,6,7,8,9,10]
li.insert(2,“z”)
print(li)
案例2：
li=[1,2,3,4,5]
st=[5,6,7,8,9,10]
li.insert(-2,“z”)
print(li)
（6）remove 删除列表中的元素 （删除具体的元素）
案例1：只有一个值
li=[1,2,3,4,5]
st=[5,6,7,8,9,10]
li.remove(2)
print(li)
案例2：有两个相同的值，只删除第一个，从左边开始删除
li=[1,2,3,4,2,5]
st=[5,6,7,8,9,10]
li.remove(2)
print(li) #[1, 3, 4, 2, 5]
案例3：删除不存在的数据报错、
li=[1,2,3,4,2,5]
st=[5,6,7,8,9,10]
li.remove(9)
print(li) #list.remove(x): x not in list
（7）del 删除
案例1：通过索引 删除列表中对应的元素 （通过索引删除）
li=[1,2,3,4,2,5]
st=[5,6,7,8,9,10]
del li[4]
print(li)
案例2：删除不存在的索引，报错
li=[1,2,3,4,2,5]
st=[5,6,7,8,9,10]
del li[9]
print(li)

（8）sort 升序排序
案例1：纯数据和纯字符排序
li=[1,8,2,6,3,4,7,5]
li.sort()
print(li) #结果[1, 2, 3, 4, 5, 6, 7, 8]

案例2：数字和字符不能同时排序
li=[1,8,2,6,3,4,7,5,‘q’,‘r’]
li.sort()
print(li) #TypeError: ‘<’ not supported between instances of ‘str’ and ‘int’
案例3; 列表中有多个相同的数值排序
li=[1,8,2,6,3,4,7,5,1,8]
li.sort() #[1, 1, 2, 3, 4, 5, 6, 7, 8, 8]

（9）aorted 排序
a、reverse=True降序
b、reverse=False #升序
li=[1,8,2,6,3,4,7,5,1,8]
print(sorted(li,reverse=True)) #降序
print(sorted(li,reverse=False)) #升序

（10）reverse 反转输出
li=[1,8,2,6,3,4,7,5,1,8]
li.reverse()
print(li) #[8, 1, 5, 7, 4, 3, 6, 2, 8, 1]
（11）pop 删除：（默认删除末尾的值，）
案例1:删除默认值
li=[1,8,2,6,3,4,7,5,1,8]
li.pop()
print(li) #[1, 8, 2, 6, 3, 4, 7, 5, 1]

案例2:根据索引删除
li=[1,8,2,6,3,4,7,5,1,8]
li.pop(1)
print(li) #[1, 2, 6, 3, 4, 7, 5, 1, 8]

（12）index 根据列表中具体的值得出索引值
li=[1,8,2,6,3,4,7,5]
print(li.index(6)) #3 ，3表示索引位

==================================
四、元组
类型：
元组：（）
元组的单词：tuple
元组是有序，不可变
当元组中是一个字符或一个数值时，要加上逗号（，）
定义：元组是python汇总常用的一种数据结构。元组由不同的元素组成，每个元素可以存储不同的类型的数据，如字符串，数字，甚至元组。元组是写‘保护’的，即元组中元素作为一个整体，创建后不能再做任何修改 *** 作。

元组的函数：
（1）index 查看元组中元素的索引
案例：
yz=(1,2,3,4)
print(yz.index(3))

（2）元组要进行修改：（将元组=list列表==tuple元组）
案例：
yz=(1,2,3,4)
print(type(yz))
d=list(yz) #通过list将元组转换成列表
print(type(d))
d.insert(2,“a”) #[1, 2, ‘a’, 3, 4] 表示的是列表
print(d)
c=tuple(d) #通过tuple 转换成元组
print(type©)

面试题：元组和列表的异同？
相同：
1、都有序
2、都可以存放任何数据
3、支持切片和迭代等 *** 作
不同：
1、list 是可变的对象，元组tuple是不可变对象，索引tuple 可以使用代码更安全；
2、括号 ：列表【】 ，元组是（）
3、字符类型不一样：list tuple

==================================
字典：
1、字典（dict）是另一种可变容器模型，且可存储任意类型对象。
2、字典同时是无序，字典都是以键值对的形式存在，先键后值，键是唯一 的，值且不唯一
3、字典表达符：{}
4、字典单词：dict
5. 字符类型：
6、定义字典的方式：
方式一：通过{} 定义字典
d={“name”:“zs” ,“age”:18}
方式二：通过dict 来转换字段
li=[(‘a’,1),(‘b’,2),(‘c’,3)]
print(type(li))
d=dict(li) #通dict转换成字典
print(d)
print(type(d))

===============================
字典函数：
1、添加键值对
(1)第一种情况：添加不存在的键值
d={“name”:“zs” ,“age”:18}
d[‘sex’]=‘女’
print(d)

（2）添加键值，已经存在的键，键不变，值变
案例：
d={“name”:“zs” ,“age”:18}
d[“age”]=16
print(d)

2、keys 取出字典中所有的键
d={“name”:“zs” ,“age”:18}
print(d.keys()) #结果：dict_keys([‘name’, ‘age’])

3、valuse 取出键返回的值
d={“name”:“zs” ,“age”:18}
print(d.values()) #dict_values([‘zs’, 18])

4、根据键取出对应的值
d={“name”:“zs” ,“age”:18}
print(d[“age”]) #18

5、字典中添元素，setdefault 默认值
（1）已经存在的键值
d={“name”:“zs” ,“age”:18}
d.setdefault(“age”,16) #setdefault值优先级要低于字典本身
print(d) #{‘name’: ‘zs’, ‘age’: 18}
（2）添加不存在键值，
d={“name”:“zs” ,“age”:18}
d.setdefault(“fs”,16)
print(d) # {‘name’: ‘zs’, ‘age’: 18, ‘fs’: 16}

6、清空字典 clear
d={“name”:“zs” ,“age”:18}
d.clear()
print(d)

7.del 删除指定的键和值
d={“name”:“zs” ,“age”:18}
del d[“age”]
print(d)

8、字典遍历
for in 循环
（1）遍历所有键：
d={“name”:“zs” ,“age”:18}
for i in d:
print(i)
（2）遍历所有的键和值
d={“name”:“zs” ,“age”:18}
for i in d:
print(i,d[i])
（3）items 遍历键值
d={“name”:“zs” ,“age”:18}
for k,v in d.items():
print(k,v)

9、pop （键）
（1）删除指定的键
d={“name”:“zs” ,“age”:18}
d.pop(“name”)
print(d)
（2）打印删除键对应的值
d={“name”:“zs” ,“age”:18}
print(d.pop(“name”)) #zs

10.get(key)方法，通过key获取值，当键不存在，返回none
d={“name”:“zs” ,“age”:18}
print(d.get(“age”)) #18

11、popitem 函数删除字典中的键值对
（1）先删除在显示删除后的结果
d={“name”:“zs” ,“age”:18}
d.popitem()
print(d)
（2）打印删除的值
d={“name”:“zs” ,“age”:18}
print(d.popitem()) #(‘age’, 18)

12、update 函数中利用一个字典更新另一个字典
d={“name”:“zs” ,“age”:18}
c={“sex”:“女”}
d.update©
print(d) #{‘name’: ‘zs’, ‘age’: 18, ‘sex’: ‘女’}

13、copy 复制字典
d={“name”:“zs” ,“age”:18}
e=d.copy()
print(e) #{‘name’: ‘zs’, ‘age’: 18}
print(d) # {‘name’: ‘zs’, ‘age’: 18}

14、forkeys 函数快速生成字典
print({}.fromkeys([“name”,“age”]))
print({}.fromkeys([“name”,“age”],“18”))

=====================================
集合：
（1）功能：去重
（2）集合类型：
A.可变集合 set
B.不可变集合 frozenset
（3）
A.可变集合字符类型：
B.不可变集合字符类型

======================
1、可变集合：
案例：
print(type(li))
j=set(li) #
print(j) #{1, 2, 3, 5}
print(type(j)) #
2、不可变集合
li=[1,2,3,5]
print(type(li))
j=frozenset(li) #
print(j) #{1, 2, 3, 5}
print(type(j)) #

======================
1、对列表去重
li=[1,2,3,5,3,3,5,8]
q=set(li)
print(q) #{1, 2, 3, 5, 8}

2、对字符去重
e=‘hellowd’
print(set(e))
3、add对集合添加参数
li=[1,2,3,5,3,3,5,8]
d=set(li)
d.add(“ww”)
print(d)

4、remove 删除具体的参数
li=[1,2,3,5,3,3,5,8]
d=set(li)
d.remove(5)
print(d)

5、pop 删除数据

li=[1,2,3,5,3,3,5,8]
d=set(li)
d.pop()
print(d)

6、copy复制数据
li=[1,2,3,5,3,3,5,8]
d=set(li)
p=d.copy()
print(d) #{1, 2, 3, 5, 8}
print§ #{1, 2, 3, 5, 8}

7、clear 清除数据
li=[1,2,3,5,3,3,5,8]
p=set(li)
print(p.clear())

========================
frozenset 不可变集合

1、copy复制函数
li=[1,2,3,5,3,3,5,8]
d=frozenset(li)
p=d.copy()
print(d)
print§

作业：
列表，元组，字典，集合，字符，联系和区别？