列表、元组、字典及其常用操作
一、了解级字符串操作
1.find、rfind、index、rindex、count
print("abcd".find("ab")) # 0 (查找一个子字符串在大字符串中出现的起始位置,如果查不到则返回-1)
print("aaabcdefg".find("ab", 2, 5)) # 2 (查找某段字符串的子字符串在大字符串中出现的起始位置)
print("abcdefgab".rfind("ab")) # 7 (查找在大字符串中右数第一次出现的子字符串的起始位置)
print("====".index("ab")) # 找不到则报错
print("abababab".rindex("ab")) # 6 (查找在大字符串中右数第一次出现的子字符串的起始位置,找不到会报错)
print("abababab".count("ab")) # 4 (查找一个子字符串在大字符串中出现的次数)
find()和rfind()查找不到会返回-1,index和rindex找不到则会报错,所以尽量优先使用find系列来提高程序的健壮性
2.center、ljust、rjust、zfill
作用:输出美观
print("cc".center(10, '*')) # ****cc**** (输出10个字符,cc置中,其他的填*号)
print("cc".ljust(10, '*')) # cc******** (输出10个字符,右边用*补充)
print("cc".rjust(10, '*')) # ********cc (输出10个字符,左边用*补充)
print("cc".zfill(10)) # 00000000cc (输出10个字符,左边用0补充)
3.extendtab
print("my name is cc".capitalize()) # My name is cc (字符串的首字母大写)
print("AbCd".swapcase()) # aBcD (每个字母对调大小写)
print("my name is cc".title()) # My Name Is Cc (每个首字母都大写)
print('hello\tworld\t'.expandtabs(tabsize =10)) # hello world (规定从第一个\t到第二个\t之间间隔10个字符)
4.is数字系列
# 在python3中
num1=b'4' # bytes
num2=u'4' # unicode,python3中无需加u就是unicode
num3='四' # 中文数字
num4='Ⅳ' # 罗马数字
isdigit():用于b和u格式,即num1和num2
isdecimal():用于u格式,即num2
isnumberic():用于u、中文数字、罗马数字,即num2、num3、num4
这三种都不可以判断浮点型数字
5.is其他
print('abc123'.isalpha()) # False (判断字符串是否由纯字母组成)
print('abc123'.isalnum()) # True (判断字符串是否只由字母和数字组成)
二、列表及其操作
1. 重点掌握的操作
1.1 按索引取、改值(正、反向存取)
可以改也可以取值,但是超出索引会报错(即不可以使用这种非操作来为列表增加值)
l = [111, 222]
l[0] = 123 # 可以对列表可以被素引到的值进行修改
print(l) # [123, 222]
1.2 切片
顾头不顾尾,有步长
l = [111, 222, 333, 444]
l1 = l[0:3]
print(l1) # [111, 222, 333]
l2 = l[::-1] # 反向存值,可以指定起始、终点位置
print(l2) # [444, 333, 222, 111]
1.3 长度
j即列表存的值的个数
l = [111, 222, 333, [444, 555]]
print(len(l)) # 4
1.4 成员运算in 、not in
l = [111, 222, 333]
print(111 in l) # True
print(111 not in l) # False
1.5 追加
append 可以在列表末尾加一个值
l = [111, 222, 333, 444, 555]
l.append(666)
l.append(777)
print(l) # [111, 222, 333, 444, 555, 666, 777]
insert 可以在指定位置前增加一个值
l = [111, 222, 333, 444, 555]
l.insert(0, 123) # (在索引0前增加一个值)
print(l) # [123, 111, 222, 333, 444, 555]
1.6 删除
(1)del是通用的、不是列表专属的删除方式
l=[111,"aaa",222,333,444,555]
del l[0]
print(l) # >>> ['aaa', 222, 333, 444, 555]
(2)列表专属的删除方式之指定元素删除
l=[111, "aaa", "aaa", 222, 333, 444, 555]
res=l.remove("aaa") # 指定元素删除,每次删除一个
print(l) # [111, "aaa", 222, 333, 444, 555]
print(res) # None
(3)列表专属的删除方式之指定索引删除
l = [111, "aaa", 222, 333, 444, 555]
res = l.pop() # 默认删除的是索引-1对应的值,有返回值 555
print(l) # [111, 'aaa', 222, 333, 444]
print(res) # 555
1.7 for循环
for i in [111, 222, 333]:
print(i)
2. 需要掌握的操作
2.1 count
统计某个值在列表中的个数
l=[11, 22, 11, 11]
print(l.count(11)) # 3
2.2 sort
排序,sort 只能在存有能比较大小的值的列表中使用
l = [10, -1, 3, 2, 11]
l.sort(reverse=True) # reverse = True表示从大到小排列
print(l) # [11, 10, 3, 2, -1]
2.3 clear
清空列表
l = [1,2,3]
l.clear()
print(l) # []
2.4 reverse
反向重排
l = ['benz', 'audi', 'bmw']
l.reverse()
print(l) # ['bmw', 'audi', 'benz']
2.5 extend
追加多个值
而append、insert都只能追加一个值
l = [11, 22, 33]
l.extend([44, 55, 66])
print(l) # >>>[11, 22, 33, 44, 55, 66]
2.6 深浅copy
(1)浅copy
拷贝的值如果有可变类型的,更改原列表的可变类型元素,copy的列表也会跟着变
与因为拷贝的是原来值的内存地址
l1 = [11, 22, [33, 44]]
l2 = l1.copy()
l1[-1][0] = 'hello'
print(l1) # [11, 22, ['hello', 44]]
print(l2) # [11, 22, ['hello', 44]]
(2)深copy
更改原列表的可变类型元素,copy的列表则不会跟着变
因为深copy会将拷贝来的可变类型重新绑定一个新的内存地址
from copy import deepcopy
l1 = [11, 22, [33, 44]]
l2 = deepcopy(l1)
l1[-1].append(555)
print(l1) # [11, 22, [33, 44, 555]]
print(l2) # [11, 22, [33, 44]] 不跟随l1改变
3. 类型总结
可以存多个值
有序
属于可变类型
三、元组及其操作
1.介绍
1.1 用途
按照索引存放多个任意类型的值,索引反映的是位置/顺序
本质上元组就是不可变的列表
1.2 定义
在小括号()内用逗号分隔开多个任意类型的值
t=(111,222,333) # t=tupe((111,222,333))
强调:(1)当元组内只有一个元素时,必须加逗号
t = ("aaa",)
(2)定义空:
t = ()
1.3 类型转换
tuple(所有可以被for循环遍历的类型)
2.常用操作及内置方向
2.1 按素引取值
只能取不能改
可以正、反向取
2.2 切片
顾头不顾尾,有步长
t = (11, 22, 33)
print(t[::-1]) # (33, 22 11)
2.3 len长度
t = (111, 222, 333)
print(len(t)) # 3
2.4 成员运算in 、not in
t = (111, 222, 333)
print(111 in t) # True
2.5 循环
for i in (11, 22, 33)
print(i)
3、需要掌握的操作
3.1 index、count
l1 = (111, 222, 333, 444, 111)
print(l1.index(333))
print(l1.count(123))
4、类型总结
可以存多个值
不可变
有序
四、字典及其操作
1. 介绍
(1)作用
按key:value的形式存放多个任意类型的value,key反映的是value的属性
存多个不同属性的值,用key对应value,key必须是不可变类型
(2)定义方式
在{ }内用逗号分隔开多个key:value元素,其中key必须是不可变类型,并且key不可以重复
而value可以是任意类型
d={"k1":1111,"k2":222} # d=dict({"k1":1111,"k2":222})
(3)类型转换
dict()可以将一组两两对应的值转化成字典
l=[("name","jason"),("age",18),["gender","male"]]
d1=dict(l)
print(d1)n # {'name': 'jason', 'age': 18, 'gender': 'male'}
d2=dict(x=11,y=22,z=33)
print(d2) # {'x': 11, 'y': 22, 'z': 33}
(4)空字典
dic = {}
2. 优先掌握的常用操作
2.1 按key存取值:可存可取
d = {'name': 'jason', 'age': 18}
print(d['age']) # >>>18
d['gender'] = 'male' # 可以通过不存在的key完成赋值操作来达到为字典添加值的效果,而列表不行
print(d) # >>>{'name': 'jason', 'age': 18, 'gender': 'male'}
2.2 长度len
d = {'name': 'jason', 'age': 18}
print(len(d)) # 2
2.3 成员运算in 、not in
只能判断key,不能判断value
d = {'name': 'jason', 'age': 18}
print('name' in d) # True
2.4 删除
(1)del 万能删除
没有返回值,单纯只是删除
d = {'name': 'jason', 'age': 18}
del d['name']
print(d) # {'age': 18}
(2)popitem 随机删除
有返回值,本质上是取走操作
d = {'name': 'jason', 'age': 18}
res = d.popitem() # 随机删除一组 key:value,并组织成元组的形式返回
print(res) # ('age', 18)
(3)pop 指定删除
有返回值,本质上是取走操作
d = {'name': 'jason', 'age': 18}
res = d.pop('name') # 将括号内指定的key对应的value弹出
print(res) # jason
2.5 键keys(),值values(),键值对items()
以python2中使用为例,keys()、values()、items()可以对字典取键、值、键值对,以列表形势返回
>>> d={"name":"jason",'age':18}
>>> d.keys()
['age', 'name']
>>> d.values()
[18, 'jason']
>>>
>>> d.items()
[('age', 18), ('name', 'jason')]
2.6 循环
字典可以用于for循环
d = {'name': 'egon', 'age': 18}
for k in d: # 同样的,d.keys()、d.values()、d.items()也可以用于for循环
print(k)
3. 内置的方法
3.1 clear 清空字典
d = {'name': 'egon', 'age': 18}
d.clear()
print(d) # {}
3.2 update 新增键值对
可以增加,可以修改(如果key存在,那么将值修改成后update传入的)
d = {'k1': 111, 'k2': 222 }
d.update(k2='aaa', k3=333) # 可增可改
print(d) # {'k1': 111, 'k2': 'aaa', 'k3': 333}
3.3 get 查找
优点:查找的key不存在不会报错,而是返回None
d = {'name': 'jason', 'age': 18}
print(d.get('name')) # key不存在不会报错,会返回None
print(d["name"]) # key不存在则会报错
get()也可以传自定义的参数,用作找不到后的返回值
d = {'name': 'jason', 'age': 18}
res = d.get('name1', '找不到') # key不存在不会报错,会返回右边的自定义返回值
print(res) # 找不到
3.4 了解即可
① {}fromkeys()
作用:快速初始化一个字典
d = {}.fromkeys(["name", "age", "gender"], None) # 不写None结果也一样
print(d) # {'name': None, 'age': None, 'gender': None}
注意点:(不常用,但是需要了解)
dic = {}.fromkeys(['k1', 'k2', 'k3'], [])
print(dic) # {'k1': [], 'k2': [], 'k3': []}
dic.get('k1').append('123')
print(dic) # {'k1': ['123'], 'k2': ['123'], 'k3': ['123']}
因为"k1"、“k2”、"k3"对应的是同一个列表
② setdefault()
作用:保证字典中肯定有一个key是指定的,(如果原来字典有这个key,那么原字典的值不变,返回的仍然是原value)
d = {'k1': 111, 'k2': 222, }
val = d.setdefault('k3', 333)
print(d) # {'k1': 111, 'k2': 222, 'k3': '333'}
print(val) # 333
res = d.setdefault('k2', 123)
print(d) # {'k1': 111, 'k2': 222, 'k3': '333'}
print(res) # 222 返回 k2 对应的原来的 222
4. 类型总结
可变
无序
可以存多个值