Python知识点分集03

1. 元组(tuple)：注意：元组不可修改

① 创建元组：元组名 = ( 元素 , )

注意：若元组内只有一个元素则元素后带个逗号。

访问： 访问一个元素：元组名[下标] ； 访问多个元素：元组名[start: stop]

t = ('tony', )   # 一个元素后要记得带逗号，否则为字符串类型
t1 = ('张三', '李四', '王五')
print(t1[0])    # 张三
print(t1[0:2])     # ('张三', '李四')

t2 = (10, [1, 2, 3], 30)
t2[1][0] = 100  # 元组里面的元素不可以修改指的是不能直接修改元组的直系子元素
print(t2)     # (10, [100, 2, 3], 30)

② 常用函数：

元组名.index(元素)：从元组中找出该元素第一个匹配项的下标位置。不存在则报错。

元组名.count(元素)：统计该元素在元组中出现的次数。

len(元组名)：计算元组元素的个数，并返回个数值。

max(元组名)：返回元组中元素的最大值（列表也同样适用）。

min(元组名)：返回元组中元素的最小值（列表也同样适用）。

t3 = [1, 5, 43, 6, 88, 6]
print(t3.index(6))   # 3
print(t3.count(6))   # 2
print(len(t3))       # 6
print(max(t3))      # 88
print(min(t3))      # 1

2. 字典：键值对的形式

① 创建字典：dict1 = { } ; dict2 = dict( ) ; dict3 = {键1 : 值1, 键2 : 值2,······}

访问： 字典名[键名]

② 增：字典名[键名] = 值

字典名.update()：添加键值对或字典

dict1 = {}
dict2 = dict()
dict3 = {'name': 'tony', 'age': 18}
dict3['gender'] = '男'
print(dict3)    # {'name': 'tony', 'age': 18, 'gender': '男'}
dict3.update({'hobby': 'sleep'})      # {'name': 'tony', 'age': 18, 'gender': '男', 'hobby': 'sleep'}
print(dict3)

③ 删：字典名.pop() ：根据键来删除并返回，键不存在则报错，也可以写上参数使键不存在时返回指定的参数。

字典名.poptiem()：删除最后一个并返回。

字典名.clear()： 清空字典

del 字典名[键名]：删除对应得键值对。

dict_ = {'name': '张三', 'gender': '男', 'age': 18, 'hobby': 'sleep'}
dict_.pop('age')    # {'name': '张三', 'gender': '男', 'hobby': 'sleep'}
print(dict_)
print(dict_.popitem())  # ('hobby', 'sleep')
print(dict_)        # {'name': '张三', 'gender': '男'}
dict_.clear()      # {}
print(dict_)
del dict_

④ 改：字典名[键名] = 值

字典名.update()：以键值对形式存在的可迭代对象可以进行转换——字典名.update([('one',1),('two',2)]) ; 用关键字参数创建——字典名.update(one=1, two=2)

dict_ = {'name': '张三', 'gender': '男', 'age': 18, 'hobby': 'sleep'}
dict_['name'] = '李四'
dict_.update(age=20)
dict_.update([('hobby', 'eat')])  #{'name': '李四', 'gender': '男', 'age': 20, 'hobby': 'eat'}
print(dict_)

⑤ 查：字典名[键名]

字典名.get()：通过键找到对应的值，键不存在返回None，可以加上参数使键不存在时返回指定参数。

字典名.keys()：返回字典所有的键的列表视图，通过for 循环遍历出来。

字典名.values()：返回字典所有的值的列表视图，通过for 循环遍历出来。

字典名.items()：返回字典所有的键值对形式的列表视图，通过for 循环遍历出来。

dict3 = {'name': '张三', 'age': 18}
print(dict3['name'])         # 张三
print(dict3.get('age'))      # 18
print(dict3.items())         # dict_items([('name', '张三'), ('age', 18)])
print(dict3.keys())          # dict_keys(['name', 'age'])
print(dict3.values())        # dict_values(['张三', 18])
for i in dict3:
    print(i)         # name    age
for i in dict3.values():   
    print(i)         # 张三    18 
for i in dict3.items():
    print(i)        # ('name', '张三')    ('age', 18)

3. 枚举：enumerate() 函数用于将一个可遍历的数字对象组合成一个索引序列的元组，同时列出数据下标和数据。一般用于for 循环中。

格式： enumerate(序列, start=开始的数) 注意：start不写默认从0开始。

names = ['张三', '李四', '王五', '赵六']
data = enumerate(names, start=1)
for i in data:
    print(i)      # (1, '张三')   (2, '李四')  (3, '王五')    (4, '赵六')
for i, j in data:
    print(i, j)   # 1 张三  2 李四  3 王五  4 赵六

4. 集合：集合是一个无序的不重复的元素序列，所以无下标指引；且其中的元素是唯一的，因此可以用来去重。

集合内可存放数值、字符串、元组，但不能存放列表和字典。

① 创建：集合名 = set( ) ; 集合名 = {1, 2, 3···}

s = set('张三')    # {'张', '三'}
print(s)
s_ = {'张三', '李四', '王五'}  # {'张三', '王五', '李四'}
print(s_)  

② 增：集合名.add(值)：指定值进行添加。

集合名.update(可迭代对象) ：添加可迭代对象中的每一个元素。

j1 = {'tony', 32, 32, 56, 'ab'}
j1.add('happy')    # {32, 'ab', 'happy', 56, 'tony'}
print(j1)
j1.update('abc')   # {32, 'ab', 'b', 'happy', 'a', 56, 'tony', 'c'}
print(j1)

③ 删：集合名.pop()：随机删除，返回删除的元素。

集合名.remove(值)：删除指定的值，不存在则会报错。

集合名.discard(值)：删除指定的值，不存在不会报错。

集合名.clear()：清空集合。

j1 = {'tony', 32, 32, 56, 'ab'}
j1.remove(32)      # {'tony', 56, 'ab'}
print(j1)
j1.pop()           # {56, 'ab'}
print(j1)
j1.discard('ab')   # {56}
print(j1)
j1.clear()         # set()
print(j1)