列表、字典、元组、集合的内置方法

列表、字典、元组、集合的内置方法

• 列表内置方法
• 字典内置方法
• 元组内置方法
• 集合内置方法

一、列表的内置方法

​ 列表内一般都会存储相同的数据类型的数据

​ list关键字可以将支持for循环的数据类型转换成列表

1. 类型转换

   list关键字可以将支持for循环的数据类型转换成列表

# 数据类型关键字(需要转换的数据)
print(list(123))  # 报错
print(list(123.21))  # 报错
print(list('hello'))
print(list({'username': 'abc', 'pwd': 123}))
print(list((11, 22, 33)))
print(list({11, 22, 33}))

2. 列表修改、添加数据

   1)修改值

l1 = ['aaa', 'bbb', 456]
l1[0] = 123
print(l1)

​ 2)添加值

​ 方式1 尾部追加（将括号内的数据当成一个整体追加到列表末尾）

l1.append(789)
print(l1)
l1.append([111, 222, 333])
print(l1)

​ 方式2 插入元素（将括号内的数据当成一个整体插入到索引指定位置）

l1.insert(0, 'ccc')
print(l1)
l1.insert(2, 'ddd')
print(l1)
l1.insert(0, [11, 22, 33])
print(l1)

​ 方式3 扩展元素（相当于for循环+append操作）

l1.extend([111, 222, 333, 444, 555])
print(l1)
l2 = [111, 222, 333, 444, 555]
l3 = [1, 2, 3, 4, 5]
for i in l3:
    l1.append(i)  # 将l3中元素追加到l2末尾
print(l2)

3. 删除列表数据

   1)删除数据

   ​ 方式1 通用删除方式

del l1[1]  # 根据索引直接删除 del是关键字delete的缩写
print(l1)

​ 方式2 remove( ) 括号内指定需要移除的元素值

l1.remove('ccc')
print(l1)
print(l1.remove('ddd'))  # 结果为none

​ 方式3 pop( ) 括号内指定需要弹出的元素索引值，括号内如果不写参数则默认弹出列表尾部元素

print(l1)
l1.pop(1)
print(l1)
l1.pop()
print(l1)
print(l1.pop())  # 结果为弹出的值

4. 升序降序

l4 = [44, 22, 11, 33, 99, 77, 88, 66]
l4.sort()  # 默认是升序
l4.sort(reverse=True)  # 参数指定 降序
print(l4)

5. 顺序颠倒

l4.reverse()
print(l4)

6. 切片

print(l4)
print(l4[1:5])
print(l4[::-1])  # 冒号做优两边不写数字默认全都要
print(l4[:5])  # 左边不写默认从头开始
print(l4[1:])  # 右边不写默认到尾部

7. 列表比较运算

l5 = [999, 111]
l6 = [111, 222, 333, 444, 555, 666, 777, 888]
print(l5 > l6)  # True 列表比较运算采用相同索引元素比较，只要有一个比出了结果就直接得出结论
s1 = 'hello world'
s2 = 'abc'
print(s1 > s2)  # True 字符串比较大小也是按照索引位置内部转换成ASCII对应的数字比较

二、字典的内置方法

1. 按K取值 K不存在会直接报错

dic = {'name': 'abc', 
      'age': 20,
      'hobbies': ['play game', 'basketball']}
print(dit['nsme'])
print(dic['pwd'])

2. 按K修改值 新增键值对（使用频率最高）

dic = {'name': 'abc', 'age': 20, 'hobbies': ['play game', 'basketball']}
dic['name'] = 'aaa'  # 键存在为修改值
print(dic)
dic['hobbies'].append('read')
print(dic)
dic['pwd'] = 123
print(dic)

3. 统计字典内部键值对的个数

dic = {'name': 'abc', 'age': 20, 'hobbies': ['play game', 'basketball']}
print(len(dic))

4. 成员运算 默认只暴露K

dic = {'name': 'abc', 'age': 20, 'hobbies': ['play game', 'basketball']}
print('aaa' in dic)
print('name' in dic)

5. 删除元素

   方式1

dic = {'name': 'abc', 'age': 20, 'hobbies': ['play game', 'basketball']}
del dic['name']
print(dic)

​ 方式2 指定K弹出键值对 给出V

dic = {'name': 'abc', 'age': 20, 'hobbies': ['play game', 'basketball']}
print(dic.pop('age'))
print(dic)

​ 方式3 弹出键值对 组织成元组的形式 第一个元素是K，第二个元素是V（了解）

dic = {'name': 'abc', 'age': 20, 'hobbies': ['play game', 'basketball']}
print(dic.popitem())
print(dic)

6. 获取V值

   方式1

dic = {'name': 'abc', 'age': 20, 'hobbies': ['play game', 'basketball']}
print(dic['name'])  # 键不存在直接报错 按K取值不太推荐使用该方式
print(dic['xxx'])  # 报错

​ 方式2

dic = {'name': 'abc', 'age': 20, 'hobbies': ['play game', 'basketball']}
print(dic.get('pwd'))  # 123
print(dic.get('xxx'))  # None 键不存在 不会报错 返回None
print(dic.get('pwd', '啊啊啊'))  # 第二个参数可以在k不存在的时候自定义返回信息
print(dic.get('xxx', '啊啊啊'))  # 第二个参数可以在k不存在的时候自定义返回信息

7. keys() values() items() 在python2中是列表，在python3中是迭代器

dic = {'name': 'abc', 'age': 20, 'hobbies': ['play game', 'basketball']}
print(dic.keys())  # 获取字典所有的键,输出看成列表即可
print(dic.values())  # 取字典所有的值，输出看成列表即可
print(dic.items())  # 获取字典里面所有的键值对，组织成列表套元组的形式，元组内有两个元素 第一个是K第二个是V

三、字典需要了解的方法

1. 更新字典 键存在则修改 不存在则创建

dic = {'name': 'abc', 'age': 20, 'hobbies': ['play game', 'basketball']}
dic.update({'name': 'bbb', 'pwd': '987'})
print(dic)

2. 初始化字典

dic = {'name': 'abc', 'age': 20, 'hobbies': ['play game', 'basketball']}
print(dict.fromkeys(['k1', 'k2', 'k3'],[]))

​ 笔试题

res = dict.fromkeys(['k1', 'k2', 'k3'],[])
res['k1'].append(111)
res['k2'].append(222)
res['k3'].append(333)
print(res)  # 结果k1、k2、k3都为111 222 333
# 因为k1、k2、k3都指向同一地址
res['k1'] = [111,222,333]  # 这样k1就指向了新地址
res['k1'].append(444)
print(res)

3. 当键存在的情况下，不修改而是获取该键对应的值

print(dic.setdefault('age', 22))
print(dic)
# 当键不存在的情况下 新增一组键值对 并且该方法的结果是新增的值
print(dic.setdefault('pwd', '123'))
print(dic)

四、元组的内置方法

​ 元组概念：

​ 小括号括起来，内部存放多个元素，元素与元素逗号隔开，元素可以是任意数据，但是元组内元，素不支持‘修改’(索引指向的元素的内存地址不能改变)，也可以简单的认为它是一个不可变的列表。

1. 类型转换 能够支持for循环的数据都可以转换成元组

print(tuple(111))  # 报错
print(tuple(11.11))  # 报错
print(tuple('hello'))  # ('h', 'e', 'l', 'l', 'o')
print(tuple([11,22,33]))  # (11, 22, 33)
print(tuple({'name':'jason','pwd':123}))  # ('name', 'pwd')

​ 元组笔试题

t1 = (111)  # 整型
t2 = (11.11)  # 浮点型
t3 = ('hello')  # 字符串
'''元组哪怕内部只有一个元素 也需要加上逗号'''
print(type((111,)))
'''
	容器类型:内部可以存放多个值的数据类型都可以称之为容器类型
	建议:所有的容器类型在存储数据的时候 如果内部只有一个元素 
	那么也推荐你加上逗号
'''

2. 索引取值

t = (111, 222, 333, 444, 555)
print(t[2])
print(t[-1])

3. 切片操作

t = (111, 222, 333, 444, 555)
print(t[1:5])
print(t[1:])
print(t[:])

4. 步长

t = (111, 222, 333, 444, 555)
print(t[1:5:2])

5. 统计元组内元素的个数

t = (111, 222, 333, 444, 555)
print(len(t))  # 5

6. for循环

t = (111, 222, 333, 444, 555)
for i in t:
    print(i)

7. count计数

print(t.count(111))  # 1

​ 笔试题

t1 = (111, 222, [11, 22, 33])
t1[2].append(44)
print(t1)

五、集合去重操作

1. 定义空集合需要使用关键字set

s1 = set()

2. 类型转换 能够支持for循环的数据类型都可以转成集合(元素要是不可变类型)

'''集合内元素是无序的'''
# 去重
s1 = {1, 2, 2, 2, 3, 4, 3, 4, 3, 1, 2, 3, 2, 1, 2, 3, 2, 1, 2, 3}
print(s1)  # {1, 2, 3, 4}
name_list = ['kevin', 'jason', 'jason', 'jason', 'kevin', 'kevin']
# 1.先将列表转换成集合
s1 = set(name_list)
# 2.再将去重之后的集合转换成列表
l1 = list(s1)
print(l1)

​ 小练习

"""课堂练习题"""
ll = [33, 22, 11, 22, 11, 44, 33, 22, 55, 66, 77, 77, 66, 55, 44]
# 基本要求:去重即可
s1 = set(ll)
ll1 = list(s1)
print(ll1)

# 拔高要求:去重并保留原来的顺序
# 1.先定义一个新列表
new_list = []
# 2.for循环ll列表
for i in ll:
    # 3.判断当前元素是否在新列表中
    if i not in new_list:
        # 3.1 如果不在 则添加到新列表
        new_list.append(i)
    # 3.2 如果在 则不管
print(new_list)

六、集合关系运算

1. 关系运算

"""两个群体之间做差异比较    共同好友 共同关注..."""
friends1 = {"zero", "kevin", "jason", "eg"}  # 用户1的好友们
friends2 = {"Jy", "ricky", "jason", "eg"}  # 用户2的好友们

2. 求两个用户的共同好友

print(friends1 & friends2)  # {'jason', 'eg'}

3. 求两个用户所有的好友

print(friends1 | friends2)  # {'kevin', 'ricky', 'jason', 'zero', 'Jy', 'eg'}

4. 求用户1独有的好友

print(friends1 - friends2)  # {'zero', 'kevin'}

5. 求用户2独有的好友

print(friends2 - friends1)  # {'ricky', 'Jy'}

6. 求用户1和用户2各自的好友

print(friends1 ^ friends2)  # {'Jy', 'zero', 'kevin', 'ricky'}

7. 父集与子集

s1 = {11, 22, 33, 44}
s2 = {11, 33}
print(s1 > s2)  # 判断s1是否是s2的父集   True
print(s2 < s1)  # 判断s2是否是s1的子集   True