08. 列表、元组、字典及其操作

一、了解级字符串操作

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. 类型总结

可变
无序
可以存多个值