标签：包含 重复 双引号 操作 代码 split cap xtend 直接
一、索引
索引在公司中一般叫做下标或角标
1、我们可以通过索引位读取序列中的指定元素，索引可以分为正向索引和负向索引
2、索引的表达方式：str[x]其中x是需要我们自己填写的一个数据。
如，str[1]、str[0]
3、索引中，正向索引从0开始，负向索引从-1开始
4、表示不隔位
[起始索引位：结束索引位：步长值]
切片语法中：(1)包含起始不包含结束
(2)隔位不能为0，可以为1，从2开始有效果
5、range(遍历函数)
（起始位：结束位：隔位）
print（list（range（1，10，3）））
打印结果为[1，4，7]
遍历函数中：包含起始不包含结束，隔位不能为0，可以为1
print（list（range（10）））
打印结果为：[0，1，2，3，4，5，6，7，8，9]
print（list（range（2,10）））
打印结果为：[2，3，4，5，6，7，8，9]
print（list（range（2,10,3）））
二、切片
1、切片表达式：str：[start_index:end_index:step]
开始索引：结束索引：步长值
2、解释：start_index:开始索引（可以取值）
end_index :结束索引（不能取值）
step：步长值（脚跨几个楼梯）
3、注意
(1)切片中，如果步长不写默认为1
(2)切片取值从索引开始到索引结束，结果不包括索引结束位置的值（取到索引结束前一位）
(3)步长从开始索引走起，步长分正负
三、常见的字符串函数
字符串的定义：要用单引号或双引号（英文）括起来表示
str=‘abc123‘
print(type(str))
打印类型：<class ‘str‘>
str1="admin:123456"
print(type(str1))
打印类型：<class ‘str‘>
1、str.capitalize():实现首字母大写,其它字母小写输出
str="dasfagfg"
print(str.capitalize())
输出结果：Dasfagfg
tr="dasAagfg"
print(str.capitalize())
输出结果：Dasaagfg
2、str.count(‘xx‘):统计xx字符在str中的数量
str="dasAagfg"
print(str.count(‘a‘))
输出结果：2
str="dasAagfg1111"
print(str.count("1"))
输出结果：4
总结：在count函数中，统计字符时，如果是数字，必须加引号
3、"".join(‘xx‘):拼接函数，自动定义分割，来分割当前的字符串（自定义符号）
str="123456"
print("_".join(str))
输出结果：1_2_3_4_5_6
4、str.split("xx"):分割函数，指定当前字符串作为一个字符串，且返回一个列表
str=“abc123”
num=str.split("b")
print(num)
输出结果：“a”，“c123”
5、str.strip("x"):删除字符串开头和结尾的字符
str="abc123"
print(str.strip("ab"))
输出结果：c123
6、str.lstrip("x"):删除字符串开头的字符
str="abc123"
print(str.lstrip("ab"))
输出结果：c123
7、str.rstrip("x"):删除字符串结尾的字符
str="abc123"
print(str.rstrip("23"))
输出结果：abc1
8、str.startswith("x"):判断字符串是否以x开头，若是：返回True；否则，返回False
str="abc123"
str.startswith("abc")
输出结果：True
9、str.endswith("x"):判断字符串是否以x结尾，若是：返回True；否则，返回False
str="abc123"
str.endswith("123")
输出结果：True
10、find、rfind通过具体的值来找到对应值的索引位
从左往右查找，找到第一个返回当前字符的索引位，如果找不到，返回-1
str="abcad123"
print(str.find("a"))
输出结果：0
从右往左查找，找到第一个返回当前字符的索引位，如果找不到，返回-1
str=“abc123”
print（str.rfind("1")）
输出结果：3
11、str.replace( "x","y" ,5 ):替换指定字符串，且可以指定替换次数
str="abc1231"
print(str.replace("1","ycy",3))
输出结果：abcycy23ycy
12、str.lower()：将字符串中的所有大写字母改为小写字母
str="ABC12ed"
print(str.lower(str))
输出结果：abc12ed
13、str.upper:将字符串中的所有小写字母改为大写字母
str="ABC12ed"
print(str.upper())
输出结果：ABC12ED
四、字符串的判断方法
以下都是字符串的判断，返回结果只有true or false
1、isalnum:判断字符串是否是字母、数字或数字字母组合
str="abc"
print(str.isalnum())
输出结果：True
特殊情况：
str=“中国”
print(str.isalnum())
print（str.encode(utf-8).isalnum()）
输出结果：True
Faluse
str=“123”
print(str.isalnum())
输出结果：True
2、str.isdigit():判断字符串是否全为数字
str="123"
print(str.isdigit())
输出结果：True
s
3、str.islower():判断字母是否都为小写
str=“abc1”
print(str.lower())
输出结果：True
4、str.isupper():判断字母是否为大写
str="ABC1"
print（str.issupper()）
输出结果：True
5、str.istitle():判断首字母是否为大写，其它字母是否为小写
str="Avv1"
print(str.istitle())
输出结果：true
五、python中的列表
字符串：str""
列表：list=[]
元组：tuple（）
字典：dict{}
集合：可变集合，不可变集合
1、list列表
定义列表的两种方法：
(1)通过 [ ] 来直接定义
list=[1,2,3,4,5,‘test‘ ]
print(type(list))
输出结果：<class,‘list‘>列表类型
(2)通过list来转换
a=‘hello‘
print(type(a))
输出结果：<class,‘str‘>
b=list(a)
print(type(b))
输出结果：<class,‘list‘>
print(b)
输出结果：[‘h‘,‘e‘,‘l‘,‘l‘,‘o‘]
(3)对列表进行操作
通过索引赋值：格式 列表名[索引]=“新值”
通过切片赋值：格式 列表名[索引：]=“新值”
append：添加函数
exend：添加函数，两个表拼接
insert：插入
remove：删除
del：删除
sort：升序
sorted：降序
reverse：反转
pop：删除
index：索引位
2、根据索引来对列表赋值
(1)索引方式赋值
list=[1,2,3,4,5,"rest"]
list[4]="yy"
print(list)
打印结果：[1,2,3,4,"yy","rest"]
(2)从索引位开始赋值
list=[1,2,3,4,5]
list[3:]="老王吃屁"
print(list)
输出结果：[1, 2, 3, ‘老‘, ‘王‘, ‘吃‘, ‘屁‘]
3、列表添加元素：append
a=[1,2,3,4,5]
print（a.append（“hello”））
输出结果：返回结果none
a=[1,2,3,4,5]
print(a.append("hello"))
输出结果：[1,2,3,4,5，“hello”]
4、列表拼接：extend
a=[1,2,3]
b=[4,5,6]
a.extend(b)
print(a)
输出结果：[1,2,3,4,5,6]
a=[1,2,3]
b=[4,5,6]
print(a.extend(b))
输出结果：none
5、列表中插入一个值：insert
(1)超出的索引值
a=[1,2,3,4,5]
a.insert(10,"helllo")
print(a)
输出结果：[1,2,3,4,5,"hello"]
(2)存在的索引值（插入到索引位前面）
a=[1,2,3,4,5]
a.insert(0,"helllo")
print(a)
输出结果：[“hello”，1,2,3,4,5]
(3)负向索引（插入到索引位前面）
a=[1,2,3,4,5]
a.insert(-1,"helllo")
print(a)
输出结果：[1,2,3,4,“hello”，5]
6、删除列表中的元素：remove，del
(1)remove删除具体的值
a=[“a”,1,2,3,"a",4,5,"b"]
a.remove("helllo")
print(a)
输出结果：[1,2,3,"a",4,5,"b"]
备注：多个同样的值，只能删除一个；可以删除数字、字母、字符
(2)del通过索引位删除
a=[1,2,3,4,5]
del a[1]
print(a)
输出结果：[1,3,4,5]
备注：超出索引位报错
7、升序：sort
a=[1,5,4,3,2]
a.sort()
print(a)
输出结果：[1,2,3,4,5]
备注：字母、字符不能进行排序，会报错
a=[1,5,4,3,2]
print(sorted（a,reverse=False）)
输出结果：[1,2,3,4,5]
8、降序：sorted
a=[1,5,4,3,2]
print(sorted（a,reverse=True）)
输出结果：[5,4,3,2,1]
备注：ture和false 中的首个字母大写
9、反转输出：reverse
a=[1,2,5,4,5]
a.reverse()
print(a)
输出结果：[5,4,5,2,1]
10、删除函数：pop
a=[1,2,3,4,5]
a.pop()
print(a)
输出结果：[1，2，3，4]
备注：默认删除末尾值
a=[1,2,3,4,5]
print(a.pop())
输出结果：[5]
备注：输出被删除的值
a=[1,2,3,4,5]
a.pop(1)
print(a)
输出结果：[1，3，4，5]
备注：删除索引位为1的值
a=[1,2,3,4,5]
print(a.pop(1))
输出结果：[2]
备注：删除索引位为1的值并输出删除值
11、删除具体的值：remove
a=[1,2,‘a‘,‘b‘,3,‘a‘]
a.remove(‘a‘)
print(a)
输出结果：[1,2,‘b‘,3,‘a‘]
备注：默认删除一个值
12、根据索引位输出具体值：index
a=[1,2,3,4,5]
print(a.index(2))
输出结果：3
六、python中的元组
元组的类型为：tuple ()
字符串的类型为：str =“”
列表的类型为：list =[]
元组定义后由于不可直接修改则相对于代码来说要更加安全
注意：当元组中只有一个值时，需要在值的后面加上逗号（，）
列表和元组的区别：列表可变，原则不可变
注意：1、当（）中只有一个值的情况下，输入什么值，这个值就是什么类型
2、如果要让一个值的输出为元组，值后面要加逗号
1、元组转列表，通过list的方法
a=(1,2,3,4,5)
print(type(a))
输出结果：<class,‘tuple‘>
b=list(a)
print(a)
输出结果：<class,‘list‘>
2、转换成列表再进行修改、增加、删除
a=(1,2,3,4,5)
b=list(a)
b.append("yy")
print(b)
输出结果：[1,2,3,4,5,"yy"]
3、将列表转换成元组，使用tuple
a=[1,2,3,4,5]
print(type（a）)
输出结果：<class,"list">
b=type（a）
print（type（b））
输出结果：<class,"tyope">
4、元组可以通过切片操作
a=（1，2，3，4，5，6，7，8，9）
print（a[1:]）
输出结果：（2，3，4，5，6，7，8，9）
备注：a[1:]的意思是，从索引位1开始到末尾，步长值为1
print（a[::-1]）
输出结果：(9,8,7,6,5,4,3,2,1)
5、元组可以通过索引位取值
a=（1,2,3,4,5）
print(a[2])
输出结果：3
七、python中的字典：dict类型
字典是由键值对组成，键是唯一，值可以不唯一。
{}英文的大括号，也叫花括号
字典中，键值是一个整体，多个键值时需要用逗号隔开。
整数类型不需要加单双引号，其他的都需要加单双引号
键和值中间用英文的：冒号，比如，name：张三 定义一个字典
1、定义一个字典
d={"name":"张三","age":18}
print(type(d))
print(d)
输出结果：{"name":"张三","age":18}
2、列表转化成字典步骤（重点）
a=[(‘name‘,‘张三‘),(‘age‘,18)]
b=dict(a)
print(type(b))
输出结果：<class,‘dict‘>
print(b)
输出结果：{"name":"张三","age":18}
3、字典中添加键值对的格式：变量名[键]=值
a={"name":"张三","age":18}
a[‘sex‘]="男"
print(a)
输出结果：{‘name‘: ‘张三‘, ‘age‘: 18, ‘sex‘: ‘男‘}
4、替换字典中的值
a={"name":"张三","age":18}
a[‘name‘]="李四"
print(a)
输出结果：{‘name‘: ‘李四‘, ‘age‘: 18}
5、通过keys取出相应的键
a={"name":"张三","age":18}
print(a.keys())
输出结果：dict_keys([‘name‘, ‘age‘])
6、通过values取出相应的值
a={"name":"张三","age":18}
print(a.values())
输出结果：dict_values([‘张三‘, 18])
7、通过键来获取相应的值
a={"name":"张三","age":18}
print(a["name"])
输出结果：张三
8、添加设置默认键值
a={"name":"张三","age":18}
a.setdefault(‘sex‘,‘男‘)
print(a)
输出结果：{‘name‘: ‘张三‘, ‘age‘: 18, ‘sex‘: ‘男‘}
备注：字典的默认值优先级特别低
9、修改字典键值
a={"name":"张三","age":18}
a["name"]="李四"
print(a)
输出结果：{‘name‘: ‘李四‘, ‘age‘: 18}
10、删除键
a={"name":"张三","age":18}
del a["name"]
print(a)
输出结果：{‘age‘: 18}
11、使用for循环获取key
a={"name":"张三","age":18}
for k in a:
print(k)
12、使用for循环获取key，values
a={"name":"张三","age":18}
for k in a:
print(k，a[k])
输出结果：name 张三 age 18
13、通过iteams（）方法获取对应键值对
a={"name":"张三","age":18}
for k，v in a.items():
print(k，v)
输出结果：name 张三 age 18
14、通过pop函数删除指定的键，打印返回对应键的值
a={"name":"张三","age":18}
print(a.pop("name"))
输出结果：张三
print（a）
输出结果：{‘age‘: 18}
15、打印删除后字典的内容（默认删除最后）
a={"name":"张三","age":18}
print（a.popitem()）
输出结果：(‘age‘, 18)
16、清空当前字典的内容：clear
a={"name":"张三","age":18}
a.clear()
print(a)
输出结果：{}
17、通过键获取对应的值
a={"name":"张三","age":18}
print（a）
print（a.get(name)）
输出结果：张三
备注：如果是一个不存在的键，返回的值时none
18、快速生成一个字典的方法fromkeys
print{}.fromkeys([‘name‘,‘age‘])
输出结果：{‘name‘: None, ‘age‘: None}
a={}.fromkeys([‘name‘,‘age‘])
print（a）
输出结果：{‘name‘: None, ‘age‘: None}
19、生成一个字典和值
print（{}.fromkeys(["name","age"],"a")）
输出结果：{‘name‘: ‘a‘, ‘age‘: ‘a‘}
20、已生成字典，通过fromkeys赋值
a={"name":"张三","age":18}
print（{}.fromkeys(["name","age"],"a")）
输出结果：{‘name‘: ‘a‘, ‘age‘: ‘a‘}
21、将多个字典合并：update
a={"name":"张三","age":18}
c={"sex":"男"}
a.update(c)
print(c)
输出结果：{‘name‘: ‘张三‘, ‘age‘: 18, ‘sex‘: ‘男‘}
22、复制字典：copy
a={"name":"张三","age":18}
b=a.copy()
print(b)
输出结果：{‘name‘: ‘张三‘, ‘age‘: 18}
23、删除字典字段
a={"name":"张三","age":18}
del a["name"]
print(a)
输出结果：{‘age‘: 18}
八、集合
集合是不同元素的无序集合，与序列不同，集合没有切片操作。set集合最重要的功能就是去重，
集合可分为：可变集合、不可变集合。
（1）可变集合（set）：集合里面的元素是可以发生动态变化的，集合中可以动态的增加和删除。
（2）不可变集合（frozenset）：集合里面的元素不可以发生变换。
备注：集合中的元素是无序的，且集合后元素不重复。
1、可变集合
1、对列表数据重复的进行去重
2、对一个字符串进行去重
2、对列表数据重复的进行去重
new=[1,2,3,44,3,2,1,55,44]
print(type(new))
输出结果：<class ‘list‘>
print(new)
输出结果：[1, 2, 3, 44, 3, 2, 1, 55, 44]
yy=set(new)
print(type(yy))
输出结果：<class ‘set‘>
print(yy)
输出结果：{1, 2, 3, 44, 55}
3、对一个字符串进行去重：set
向集合里添加元素：update、add
str="hello"
yy=set(str)
print(yy)
输出结果：{‘l‘, ‘h‘, ‘e‘, ‘o‘}
yy.update("8")
print(yy)
输出结果：{‘o‘, ‘e‘, ‘8‘, ‘l‘, ‘h‘}
yy.add("9")
print(yy)
输出结果：{‘8‘, ‘h‘, ‘o‘, ‘e‘, ‘9‘, ‘l‘}
备注：集合是无序的
4、清除集合中的内容：clear
xx="hello"
yy=set（xx）
yy.clear()
print(yy)
输出结果：set()
5、随机删除集合里的内容：pop
xx="hello"
yy=set（xx）
yy.pop()
print(yy)
输出结果：{‘h‘, ‘o‘, ‘l‘}
6、删除指定内容：remove
xx="hello"
yy=set（xx）
yy.remove("l")
print(yy)
输出结果：{‘h‘, ‘o‘, ‘e‘}
7、复制集合：copy
xx="hello"
yy=set（xx）
a=yy.copy()
print(a)
输出结果：{‘e‘, ‘l‘, ‘h‘, ‘o‘}
8、不可变集合：frozenset
不可变集合只能使用copy，进行添加或删除都会报错
xx="hello"
yy=forzenset（xx）
a=yy.copy()
print(a)
输出结果：frozenset({‘h‘, ‘l‘, ‘e‘, ‘o‘})
标签：包含 重复 双引号 操作 代码 split cap xtend 直接
原文地址：https://www.cnblogs.com/yuecaoyu/p/14256622.html
