2.列表字符串字典元组集合

Posted 2021-03-14 huohu121

list:
增:list.append("str") 追加str到list最后
插入:list.insert(num,"str") 在list的num位置插入str
修改:list[num] = "str" 把list的第num位置改为str
把另一个列表元素添加进来: list.extend(list2) #list = [list[0],list[1],...list[-1],list2[0],list2[1]]

删:
(1)list.remove("str") 删除list列表中str的元素
(2)del list[num] 删除list列表中位置为num的元素
(3)list.pop() 弹出list的最后一个元素,并把最后一个元素返回,这时可以用一个变量接收,如:
str = list.pop() list弹出最后一个元素,并赋值给str
如果带下标,如list.pop(num) list弹出num位置的元素,并返回
(4)list.clear() 清空list中所有内容

查
num = list.index("str") list查找一个值为str的元素,并将下标返回,用于查找已知元素的位置
str = list[num] 把list中num位置的元素返回,查找用于已知位置的元素的值

统计
num = list.count("str") 统计list中值为str的元素个数

排序
list.reverse() 反转list中元素的顺序
list.sort() 排序

设定步长切片
list[0:-1:2]设定步长为2的list切片,前面下标可以省略,但是冒号不能省略list[::2]

浅复制
list2 = list.copy() list复制一份至list2,浅复制指的是list内部元素是列表或者可迭代对象不复制,list和list2的可迭代对象都指向同一元素,list修改这个可迭代对象,list2也修改
list2 = list[:] 这样也可以实现浅拷贝
深复制
import copy
list2 = copy.deepcopy(list) 完全复制一份list,两个列表完全独立
元组(tuple)
元组不可变,两个方法:count 和 index
for i in enumerate(list) #返回i是一个元组(下标,值)
for index, item in enumerate(list,start=0): #这句连同下标一块取得,enumerate取得下标,把下标赋给变量index,方便后续操作,start为起始计数下标,默认为0,可以省略
start=1时,index从1开始计数

字符串处理
str.capitalize() str首字母大写
str.count("char") 统计str中char出现的次数
str.endswith("char") 判断str是否以char结尾,返回一个布尔值
str.expandtabs(tabsize=30) str内有 转义字符,用后面的参数指定这个 代表的空格数,一般用于格式化字符串
★str = "my name is {name},i am {age} years old."
str.format(name="lili",age=12) 格式化字符串
str.format_map({"name":"lili","age":12}) 用字典格式化字符串
#上面这两个都输出为 my name is lili,i am 12 years old.
str.isalnum() str是否为字母数字,返回布尔值
str.isalpha() str是否为纯英文字符(包含大小写),返回布尔值
str.isdecimal() str是否为十进制数字
★str.isdigit() str是否为整数
str.isidentifier() str是否是一个合法的变量名
str.islower() str是否为小写
str.isnumeric() str是否为数字(包括罗马数字和汉字数字)
str.isspace() str是否为空格
str.istitle() str是否为title(每个单词首字母大写)
str.isupper() str是否为大写
★sep.join(seq) sep:分隔符 seq:要连接的元素序列字符串列表元组字典
以sep作为分隔符,将seq元素合并成一个字符串,并返回这个字符串
如:str = "=".join("asdf")
print(str) #输出为a=s=d=f
位置:
str.center(50,"-") 留出50个位置,"-"中把str的字符串放在中间
str.ljust(50,"*") 留出50个位置,"*"中把str的字符串放在左边
str.rjust(50,"*") 留出50个位置,"*"中把str的字符串放在右边
str.zfill(50) 留出50个位置,str之前用0填充
大小写:
str.lower() str大写变小写
str.upper() str小写变大写
str.swapcase() str大小写交换
str.title() str变为每个单词首字母大写
去空白:
str.strip() 去掉str两边的空白
str.lstrip() 去掉str左边的空白
str.rstrip() 去掉str右边的空白
替换
str.replace("old_char","new_char",num) 把str中的元素替换成另一个元素,num是一个数字,可省略,代表替换几个
查找:
str.find(char) 在str中查找最左边char出现的位置,返回一个index
str.rfind("char") 在str中查找最右边出现char的位置,返回一个index
分割:
str.split() 把str用空格分割,返回一个列表.无参数是默认用空格,有参数可以写成str.split("b"),注意,当"b"为分隔符的时候,返回的列表中不会再有"b"
str.splitlines() 按换行分割字符串,返回一个列表,一般windows和linux用不同的换行符,这个可以自动识别并分割

字典(dict)
dict = {key:value, key1:value}
特性:1.无序 2.key唯一
查找
dict[key] 查找dict中键为key的元素,返回key对应的值(有key就查找,没有key就报错,所以得确定有这个key,不能确定就不用这个方法)
dict.get(key) 查找dict中键为key的元素,返回key对应的值(有key就查找,没有key就返回none,一般用这个方法)
修改
dict[key] = new_value 把dict中key对应的值修改为new_value
添加
dict[new_key] = new_value #dict中添加了一条键值对(修改和添加格式一样,dict中本来有key就是修改,没有就是添加)
删除
del dict 删除整个dict
del dict[key] 删除dict的键为key元素
dict.pop(key) 弹出dict的键为key的元素并返回key对应的值
判断
key in dict 判断dict中是否有key这个元素,返回一个布尔值
字典嵌套操作
dict[key][key][index] 字典查找用key,list用index
其他
dict.values() 返回dict中所有值得列表,不过有dict_values前缀,不能直接使用,可以使用list(dict.values())转换成列表
dict.keys() 同上,不过返回的是key的列表,前缀是dict_keys
dict.items() 同上,不过返回的是(key:value)元组组成的列表,前缀是dict_items
dict.setdefault(key,value) 在dict中查找key,dict有这个key,就返回这个key对应的值,如果没有这个key,就添加这个这个键值对,并返回这个value
dict.update(dict2) 把dict2合并进dict(dict本来有的key的值会被dict2内相同的key的值替代
d = dict.fromkeys([6,7,8], value) 用dict.fromkeys初始化一个键为参数[6,7,8],值为参数value的字典,并用变量名d接收
遍历字典典型用法
for i in dict:
print(i,dict[i]) 这个效率高

for k,v in dict.items():
print(k,v)
============================================================
集合(set)
创建集合可以使用{}或set(),但是如果创建空集合只能用set(),因为{}用来创建空字典
s1 = {10,20,30}
s2 = set("abcdefg")
s3 = set() 空集合
集合特性 1.去重 2.无序
集合里不能放可变对象,即不能放列表,字典,可以放元组
增加
s1.add("a") 把a添加到集合s1里,add只能增加单一数据.因为集合不能重复,如果原集合有这个数据,那么追加后集合该数据还是1个
s1.update([1,2,3]) 把数据序列添加到s1中去,update只能添加数据序列
删除
s1.remove(10) 从s1中删除10这个数据,如果数据不存在则报错
s1.dicard(10) 从s1中删除10这个数据,如果数据不存在也不报错
s1.pop() 随机删除s1中一个数据,并将这个数据返回
集合的运算:
运算符:(&)交集 (|)并集 (-)补集 (^)对称补集 (>)超集 (<)子集 (==)相同 (!=)不同 (in) (not in)
s1 = {1,2,3}
s2 = {2,3,4}
交集(&):生成两个集合的交集
s3 = s1 & s2 # s3 = {2,3}
并集(|):生成两个集合的并集
s3 = s1 | s2 # s3 = {1,2,3,4}
补集(-):生成两个集合的补集,把s1中两个集合相同的元素去掉
s3 = s1 - s2 # s3 = {1}
对称补集(^):生成两个集合的对称补集:(s1-s2)|(s2-s1),等于说两个集合中对方没有的元素的并集
s3 = s1 ^ s2 # s3 = {1,4}
子集(<)判断一个集合是否为另一个集合的子集
{1,2} < {1,2,3} #True
超集(>)判断一个集合是否为另一个集合的超集
{1,2,3} > {1,2} # True
判断是否有交集:s1.isdisjoint(s2)

可用于序列(list,tuple,str)的内置函数:
len(x) 返回元素个数
max(x) 返回最大值
min(x) 返回最小值
sum(x) 返回总和
any(x) 对所有元素进行真值测试,有一个True,结果为True
all(x) 对所有元素进行真值测试,所有为True,结果才为True
以上字典也能用
reversed, sorted
==============================================
容器类型转换
1.tuple():可以把列表和集合转换元组
2.list():可以把元组和集合转换成列表
3.set():可以把元组和列表转换成集合,注意set不可重复,原元组和列表转换后将去重
================================================
推导式:
1.列表推导式:用表达式创建一个有规律的列表或控制一个有规律的列表,有助于减少代码
list1 = [i for i in range(0,10,2)]
list2 = [i for i in range(10) if i % 2 == 0]
list3 = [多for循环列表推导式,感觉不利于阅读,强制忘记-_-!]
2.字典推导式:快速合并列表为字典或提取字典中目标数据
dict1 = {i: i**2 for i in range(1,5)}
dict2 = {list1[i]: list2[i] for i in range(len(list1))} 合并两个列表组成字典
注意:1.如果两个列表数据个数相同,len统计任意一个.2.如果数据个数不同,len统计多的会报错,统计少的不报错
dict3 = {key: value for key, value in dict.items() if value >=200} 提取字典中value>=200的元素组成字典
3.集合推导式:用的少