文章目录
序
第一篇写了python这个高中有哪些科目，这篇就说说各科都是学啥，怎么用的。
各种数据类型的定义等基础请参考：数据类型浅谈
这里就直接进入操作和用法
字符串
操作
+操作
就是拼接：‘521’+“1314”==》‘5211314’
*操作
就是重复：‘521’*2==》‘521’‘521’.爱你两辈子
[]切片操作
字符串的索引操作，字符串中只能使用[]下标 访问，不能修改
vars = ’ 君不见，黄河之水天上来，奔流到海不复回’
正序从0开始，for example：vars[0]=君；vars[1]=不
逆序从-1开始，for example：vars[-1]=回；vars[-2]=复
字符串的切片操作
str[开始值：结束值：步进值]
开始值：默认为0，结束值默认是最后一个下标，步进值默认为1
‘’’
print(vars[5]) # 写一个值就是获取指定下标的元素
print(vars[2:5]) # 从2下标开始取值，一直到下标5之前，能取到2，取不到5
print(vars[4:8:2]) # 黄河之水 ==> 黄之
print(vars[::]) # 从头取到尾
print(vars[::2]) # 从头取到尾，每隔一个取一个
print(vars[::-1]) # 字符串倒转过来
print(vars[::-2]) # 字符串倒转过来，每隔一个取一个
print(vars[1::]) # 不见，黄河之水天上来，奔流到海不复回
print(vars[1::2]) # 不，河水上，流海复
格式化方法
format
{}乘舟将欲行，互闻岸上{} ==> 李白乘舟将欲行，互闻岸上踏歌声
1 format 普通方式
a = ‘李白’，b = ‘踏歌声’
vars = ‘{}乘舟将欲行，互闻岸上{}’.format(a,b)
vars = ‘{}乘舟将欲行，互闻岸上{}’.format(a,‘踏歌声’)
2 format 通过索引传参
vars = ‘{2}乘舟将欲行，互闻岸上{1}’.format(‘a’,‘踏歌声’,‘李白’)
format里同样从正序从0开始
3 format 关键字传参
vars = ‘{a}乘舟将欲行，互闻岸上{b}’.format(a=‘李白’,b=‘踏歌声’)
4 format 容器类型数据传参
data = {‘a’:‘辛弃疾’,‘b’:‘踏歌声’}
vars = ‘{a}乘舟将欲行，互闻岸上{b}’.format(**data)
5 新增的 格式化方法 f方法
data = {‘a’:‘辛弃疾’,‘b’:‘踏歌声’}
vars = f’{data[“a”]}乘舟将欲行，互闻岸上{data[“b”]}’
函数
(一) 英文字符与字符检测相关函数
vars = ‘iloveyou’
-
返回字符串的副本，该字符串的首个字符大写，其余小写。
str.capitalize()
res = vars.capitalize() -
把字符串中的一个单词的首字母大写
res = vars.title() -
把字符串全部改为 大写
res = vars.upper() -
把字符串全部改为 小写
res = vars.lower() -
字符串中的大小写字符转换，大写转小写，小写转大写
res = vars.swapcase() -
检测字符串是否为全部大写字母组成
res = vars.isupper() -
检测字符串是否为全部小写字母组成
res = vars.islower() -
检测字符串是否符合标题title的要求
res = vars.istitle() -
检测字符串是否由数字和字母组成，如果字符串中包含来了数字字母的其它字符，则返回False
res = vars.isalnum() -
检测字符串是否全部由字符(包含英文字符和中文)组成
res = vars.isalpha() -
检测字符串是否由纯数字字符组成
res = vars.isdigit() -
检测当前字符串是否为 空格 字符组成 ’ ’
res = vars.isspace() -
检测字符串是否以指定的字符开始的，也可以指定开始和结束的位置
res = vars.startswith(‘y’)
res = vars.startswith(‘y’,1,5) -
检测字符串是否以 指定的字符 结束的，也可以指定开始和结束的位置
res = vars.endswith(‘y’)
res = vars.endswith(‘e’,1,5)
（二）字符串 查找与操作相关函数 重点重点重点
-
** find() 方法 ，找到则返回字符中符合条件的第一个字符出现的索引位置。未找到返回 -1
res = vars.find(‘you’) -
index() 方法#,找到则返回索引位置，未找到则报错
res = vars.index(‘youe’) -
** split() 方法 可以按照指定的分隔符，把字符串分隔成列表
vars = ‘user_admin_id_123’
res = vars.split(’’) # [‘user’, ‘admin’, ‘id’, ‘123’]
res = vars.split(’’,2) # [‘user’, ‘admin’, ‘id_123’] -
rsplit() 方法是从右向左进行，从后向前
res = vars.rsplit(’’) # [‘user’, ‘admin’, ‘id’, ‘123’]
res = vars.rsplit(’’,2) # [‘user_admin’, ‘id’, ‘123’] -
** join() 方法 ，使用指定的字符串，把一个容器中的元素链接成一个字符串
varlist = [‘user’, ‘admin’, ‘id’, ‘123’]
res = ‘_’.join(varlist) ⇒ ‘user_admin_id_123’ -
** strip() 去除字符串左右两侧的指定字符
vars = ‘@admin’
res = vars.strip(’@’) ==>‘admin’ -
rstrip() 去除字符串右侧的指定字符，
-
lstrip() 去除字符串左侧的指定字符
-
** len() 函数可以获取当前字符串的长度
print(len(vars)) -
** replace() 替换函数
- vars = ‘i love you’,找到 love 替换为 live
res = vars.replace(‘love’,‘live’),==> ‘i live you’ - vars = ‘aabbccddeeabcdef’
res = vars.replace(‘b’,‘B’,2)可以限制替换的次数
==>‘aaBBccddeeabcdef’
- vars = ‘i love you’,找到 love 替换为 live
列表
切片
语法==> 列表[开始索引:结束索引:步进值]
varlist = [‘刘德华’,‘张学友’,‘张国荣’,‘黎明’,‘郭富城’,‘小沈阳’,‘刘能’,‘宋小宝’,‘赵四’]
-
从开始索引到列表的最后
res = varlist[2:] # [‘张国荣’,‘黎明’,‘郭富城’,‘小沈阳’,‘刘能’,‘宋小宝’,‘赵四’] -
从开始到指定的结束索引之前
res = varlist[:2] # [‘刘德华’,‘张学友’] -
从开始索引到指定结束索引之前
res = varlist[2:6] # [‘张国荣’, ‘黎明’, ‘郭富城’, ‘小沈阳’] -
从指定索引开始到指定索引前结束，按照指定步进进行取值切片
res = varlist[2:6:2] # [‘张国荣’, ‘郭富城’] -
所有列表元素的切片
res = varlist[:]
res = varlist[::] -
倒着输出列表的元素
res = varlist[::-1] -
从指定下标开始，到指定下标前结束，并替换为对应的数据(容器类型数据，会拆分成每个元素进行赋值)
varlist[2:6] = [‘a’,‘b’,‘c’,1,2,3]
varlist[2:6:2] = [‘a’,‘b’] # 需要与要更新的元素个数对应 -
切片删除
del varlist[2:6]
del varlist[2:6:2]
相关函数
varlist = [‘刘德华’,‘张学友’,‘张国荣’,‘张学友’,‘黎明’,‘郭富城’,‘小沈阳’,‘刘能’,‘宋小宝’,‘赵四’]
-
len() 检测当前列表的长度，列表中元素的个数
res = len(varlist) -
count() 检测当前列表中指定元素出现的次数
res = varlist.count(‘张学友’) -
append() 向列表的尾部追加新的元素，
varlist.append(‘川哥’) -
insert() 可以向列表中指定的索引位置添加新的元素，
varlist.insert(20,‘aa’) -
pop() 可以对指定索引位置上的元素做 出栈 操作，返回出栈的元素
res = varlist.pop() # 默认会把列表中的最后一个元素 出栈
res = varlist.pop(2) # 会在列表中把指定索引的元素进行 出栈 -
remove() 可以指定列表中的元素 进行 删除,只删除第一个。如果没有找到，则报错
res = varlist.remove(1) -
index() 可以查找指定元素在列表中第一次出现的索引位置
res = varlist.index(1)
res = varlist.index(1,5,20) # 可以在指定索引范围内查找元素的索引位置 -
extend() 接收一个容器类型的数据，把容器中的元素追加到原列表中
varlist.extend(‘123’) -
s.clear() # 清空列表内容
varlist.clear() -
reverse() 列表翻转
varlist.reverse() -
sort() 对列表进行排序
res = varlist.sort() # 默认对元素进行从小到大的排序
res = varlist.sort(reverse=True) # 对元素进行从大到小的排序
res = varlist.sort(key=abs) # 可以传递一个函数，按照函数的处理结果进行排序
列表推到式
一，基本的列表推到式使用方式
1 假设我们想创建一个平方列表
- 使用 map函数和list完成
varlist = list(map(lambda x: x**2, range(10)))
print(varlist) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]- 还可以这样
varlist = [i**2 for i in range(10)]
print(varlist) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]- 普通方法怎么写呢？
至少三行吧
2 这个呢 ‘1234’ ==> [2,4,6,8]
varstr = ‘1234’
newlist = [int(i)*2 for i in varstr]
这里简化不够明显的话接着看
二，带有判断条件的列表推到式
- 0-9 求所有的偶数，==> [0, 2, 4, 6, 8]
- newlist = [i for i in range(10) if i % 2 == 0]
- 常规方法完成
newlist = []
for i in range(10):
if i % 2 == 0:
newlist.append(i)- 四行到一行
元组
元组中的元素一但定义不可以修改，因此元组称为 不可变数据类型.所以只能使用索引进行访问
切片方法和列表一样
vart = (1,2,3,4,5,5,4,3,2,1)
res = vart[:] # 获取全部
res = vart[::] # 获取全部
res = vart[1:] # 从索引1开始获取到最后
res = vart[1:3] # 从索引1开始到索引3之前
res = vart[:3] # 从索引 0 开始 到 索引 3之前
res = vart[1:5:2] # 从索引1开始到索引5之前，步进值为2
res = vart[::2] # 从索引 0 开始 到 最后 ，步进值为2
res = vart[5:1:-1] # 从索引5开始 到索引 1，步进值为-1 倒着输出
元组推导式 生成器
列表推导式结果返回了一个列表，元组推导式返回的是生成器
语法：
列表推导式 ==> [变量运算 for i in 容器] ==> 结果 是一个 列表
元组推导式 ==> (变量运算 for i in 容器) ==> 结果 是一个 生成器
- 列表推导式
varlist = [1,2,3,4,5,6,7,8,9]
newlist = [i**2 for i in varlist]
print(newlist) # [1, 4, 9, 16, 25, 36, 49, 64, 81]
- 元组推导式 生成器 generator
newt = (i**2 for i in varlist)
print(newt) # <generator object at 0x1104cd4d0>
- 使用next函数去调用
print(next(newt))
print(next(newt))- 使用list或tuple函数进行操作
print(list(newt))
print(tuple(newt))- 使用 for 进行遍历
for i in newt:
字典
字典的操作:获取、修改、删除、添加
var1 = {‘a’: 1, ‘b’: 2, ‘c’: 3}
var2 = {1: ‘a’, 2: ‘b’, 3: ‘c’, 4: ‘d’}
- res = var1 + var2 # XXXX TypeError，没有+操作
- res = var1 * 3 # xxxx TypeError ，没有*操作
- 获取元素
res = var1[‘a’]
-> 修改元素
res = var1[‘a’] = 111- 删除元素
del var1[‘a’]- 添加元素
var1[‘aa’] = ‘AA’- 如果字典中的key重复了，会被覆盖
var1[‘aa’] = ‘aa’
成员检测和获取
- 只能检测key，不能检测value
res = ‘AA’ in var1
res = ‘AA’ not in var1- 获取当前字典的长度 只能检测当前又多少个键值对
res = len(var1)- 获取当前字典中的所有 key 键
res = var1.keys()- 获取字典中所有的 value 值
res = var1.values()- 获取当前字典中所有 键值对
res = var1.items()
字典的遍历
- 在遍历当前的字典时，只能获取当前的key
for i in var1:
print(i) # 只能获取 key- 遍历字典时，使用 items() 函数，可以在遍历中获取key和value
for k,v in var1.items():
print(k) # 遍历时的 key
print(v) # 遍历时的 value- 遍历字典的所有key
for k in var1.keys():- 遍历字典的所有 value
for v in var1.values():
字典的相关函数
-
len(字典) #获取字典的键值对个数
-
dict.keys() # 获取当前字典的所有key 键，组成的列表
-
dict.values() # 获取当前字典的所有 value 值，组成的列表
-
dict.items() # 返回由字典项 ((键, 值) 对) 组成的一个新视图
-
iter(d) 返回以字典的键为元素的迭代器。
-
vardict = {‘a’:1,‘b’:2,‘c’:3}
- dict.pop(key) # 通过 key 从当前字典中弹出键值对 删除
res = vardict.pop(‘a’)
- dict.pop(key) # 通过 key 从当前字典中弹出键值对 删除
-
dict.popitem()
- res = vardict.popitem() # 把最后加入到字典中的键值对删除并返回一个元组
-
使用key获取字典中不存在元素，会报错
print(vardict[‘aa’]) -
可以使用get获取一个元素，存在则返回，不存在默认返回None
res = vardict.get(‘aa’)
res = vardict.get(‘aa’,‘abc’) -
dict.update(),更新字典,如果key存在，则更新，对应的key不存在则添加
vardict.update(a=11,b=22)
vardict.update({‘c’:33,‘d’:44}) -
dict.setdefault(key[,default])
如果字典存在键 key ，返回它的值。
如果不存在，插入值为 default 的键 key ，并返回 default .default 默认为 None。
res = vardict.setdefault(‘aa’,‘123’)
字典推导式
把字典中的键值对位置进行交换
newdict = {v:k for k,v in vardict.items()}
- 普通方法
newdict = {}
for k,v in vardict.items():
newdict[v] = k
同样可以简化很多
集合
定义集合
vars = {123,‘abc’,False,‘love’,True,(1,2,3),0,3.1415,‘123’}
- 1.无序。
- 2.布尔类型 True 表示为 1，False 表示为 0，布尔和数字只存在一个
- 3.元素的值不能重复
检测集合中的值
res = ‘123’ in vars
res = ‘123’ not in vars
-
获取集合中元素的个数 len()
res = len(vars) -
集合的遍历
for i in vars:
print(i,type(i)) -
向集合中追加元素 add()
res = vars.add(‘def’) -
删除集合中的元素 随机删除一个元素并返回 abc False True 3.1415
r1 = vars.pop() -
指定删除集合中的元素 remove() 返回None，不存在则报错
res = vars.remove(‘aaa’) -
discard 指定删除集合中的元素，不存在也不会报错
res = vars.discard(‘aaa’) -
clear() 清空集合
res = vars.clear() -
update(others) 更新集合，添加来自 others 中的所有元素。
res = vars.update({1,2,3,4,5}) -
当前集合中的浅拷贝并不存在 深拷贝的问题
res = vars.copy()
集合推导式
varset = {1,2,3,4}
-
(1) 普通推导式
newset = {i<<1 for i in varset } -
(2) 带有条件表达式的推导式
newset = {i<<1 for i in varset if i%2==0} -
(3) 带条件表达式的多循环的集合推导式
vars1 = {1,2,3}
vars2 = {4,5,6}
newset = {i+j for i in vars1 for j in vars2 if i%2 == 0 and j%2==0}
集合的主要运算
- 交集 & set.intersection() set.intersection_update()
- 并集 | union() update()
- 差集 - difference(),difference_update()
- 对称差集 ^ symmetric_difference() symmetric_difference_update()
vars1 = {'郭富城','刘德华','张学友','黎明','都敏俊',1}
vars2 = {'尼古拉斯赵四','刘能','小沈阳','宋小宝','都敏俊',1}
# & 求两个集合相交的部分
res = vars1 & vars2
# | 求两个集合的并集，就是把集合中所有元素全部集中起来，（去除重复）
res = vars1 | vars2
# - 差集运算
res = vars1 - vars2 # vars1有，而，vars2 没有的
res = vars2 - vars1 # vars2有，而，vars1 没有的
# ^ 对称差集
res = vars1 ^ vars2
# 交集运算函数 intersection intersection_update
# set.intersection() # 返回交集的结果 新的集合
# res = vars1.intersection(vars2)
# set.intersection_update() # 没有返回值
# 计算两个集合的相交部分，把计算结果重新赋值给第一个集合
# res = vars1.intersection_update(vars2)
# 并集运算函数 | union() update()
# res = vars1.union(vars2) # 返回并集结果，新的集合
# 求并集运算，并且把结果赋值给第一个集合
# res = vars1.update(vars2) # 没有返回值
# print(vars1)
# 差集运算 函数 difference(),difference_update()
# res = vars1.difference(vars2) # 返回差集结果 新的集合
# 把差集的结果，重新赋值给第一个集合
# res = vars1.difference_update(vars2) # 没有返回值
# 求对称差集
# res = vars1.symmetric_difference(vars2) # 返回对称差集的结果 新的集合
# 把对称差集的运算结果，重新赋值给第一个集合
res = vars1.symmetric_difference_update(vars2)# 没有返回值
集合检测
- issuperset() 检测是否为超集
- issubset() 检测是否为子集
- isdisjoint() 检测是否不相交
# 检测 超集 子集
vars1 = {1,2,3,4,5,6,7,8,9}
vars2 = {1,2,3}
# issuperset() 检测是否为超集
res = vars1.issuperset(vars2) # True vars1是vars2的超集
res = vars2.issuperset(vars1) # False
# issubset() 检测是否为子集
res = vars1.issubset(vars2) # False
res = vars2.issubset(vars1) # True vars2是vars1的子集
# 检测两个集合是否相交
vars1 = {1,2,3}
vars2 = {5,6,3}
# isdisjoint 检测是否不相交， 不相交返回True，相交则返回False
res = vars1.isdisjoint(vars2)
print(res)
507
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
