🚀 优质资源分享 🚀

本章内容概要

列表内置方法

字典内置方法

元组内置方法

集合内置方法

可变类型与不可变类型

本章内容详细

1.列表内置方法 list

列表在调用内置方法之后不会产生新的值

1.1 统计列表中的数据值的个数

l1 = ['jason', 'kevin', 'oscar', 'tony', 'jerry']
l2 = [77, 22, 55, 33, 44, 99]
# 统计列表中数据的个数
print(len(l1))  # 5
print(len(l2))  # 6
1
2
3
4
5

2.增

2.1 尾部追加数据值append() 括号内无论写什么数据类型 都是当成一个数据值增加

# 2.1尾部追加数据值append() 括号内无论写什么数据类型 都是当成一个数据值追加
res = l1.append('owen')
print(res)  # None 空
print(l1)  # ['jason', 'kevin', 'oscar', 'tony', 'jerry', 'owen']
1
2
3
4

s1 = '$hello$'
res1 = s1.split('$')
print(res1)  # ['', 'hello', '']
print(s1)  # $hello$
l1.append([1, 2, 3, 4, 5])
print(l1)  # ['jason', 'kevin', 'oscar', 'tony', 'jerry', [1, 2, 3, 4, 5]]
1
2
3
4
5
6

2.2 任意位置插入数据值insert 括号内i而什么数据类型 都是当成一数据子方恒

# 意位置插入数据值insert() 括号内无论写什么数据类型 都是当成一个数据值插入
l1.insert(0, [1, 2, 3])
print(l1)  # [[1, 2, 3], 'jason', 'kevin', 'oscar', 'tony', 'jerry']
l2.insert(0, '插队')  # ['插队', [1, 2, 3], 'jason', 'kevin', 'oscar', 'tony', 'jerry']
print(l2)
1
2
3
4
5

2.3 扩展列表

方式1

# 2.3 扩展列表
new\_1 = [11, 22, 33, 44, 55]
new\_2 = [1, 2, 3]
# 方式1
for i in new\_1:
 new\_2.append(i)
print(new\_2)  # [1, 2, 3, 11, 22, 33, 44, 55
1
2
3
4
5
6
7

方式2

# 方式2
print(new\_1 + new\_2)  # [11, 22, 33, 44, 55, 1, 2, 3]
1
2

方式3(推荐使用)  extend

# 方式3(推荐使用)
new\_1.extend(new\_2) # 括号里面必须是支持for循环的数据类型 for循环+append()
print(new\_1)  # [11, 22, 33, 44, 55, 1, 2, 3]
1
2
3

3.查询数据与修改数据

# 3.查询数据与修改数据
print(l1)  # ['jason', 'kevin', 'oscar', 'tony', 'jerry']
print(l1[0])  # jason
print(l1[1:4])  # ['kevin', 'oscar', 'tony']
l1[0] = 'jasonNM'
print(l1)  # ['jasonNM', 'kevin', 'oscar', 'tony', 'jerry']
1
2
3
4
5
6

4.删除数据

4.1通用数据策略

# 4.1通用数据策略
del l1[0]  # 通过索引即可
print(l1)  # ['kevin', 'oscar', 'tony', 'jerry']
1
2
3

4.2指名道姓的删除 remove

# 4.2 指名道姓删除
res = l1.remove('jason')  # 括号内必须填写明确的数据值
print(l1, res)  # ['kevin', 'oscar', 'tony', 'jerry'] None
1
2
3

4.3 先取出数值 在删除  pop

# 4.3 先取出数据值 然后再删
res = l1.pop()  # 默认取出列表尾部数据值 然后再删
print(l1, res)  # ['jason', 'kevin', 'oscar', 'tony'] jerry
res = l1.pop(0)
print(res, l1)  # jason ['kevin', 'oscar', 'tony']
1
2
3
4
5

5.查看索引值 index

# 5.查看数据值对于的索引值
print(l1.index('jason'))
1
2

6.统计某个数据值出现的数据 append

# 6.统计某个数据值出现的次数
l1.append('jason')
print(l1.count('jason'))  # 2
1
2
3

7.排序 sort 升序  sort(reverse=True)  降序    b.sort(key=a.index)  去重b按a的列表排序

l2.sort()  # 升序 [22, 33, 44, 55, 77, 99]
print(l2)
1
2

l2.sort(reverse=True)  # 降序
print(l2)  # [99, 77, 55, 44, 33, 22]
1
2

8.翻转 reverse

l1.reverse()  # 前后跌倒
print(l1)  # ['jerry', 'tony', 'oscar', 'kevin', 'jason']
1
2

9.比较运算

new\_1 = [99, 22]
new\_2 = [11, 22, 33, 44]
print(new\_1 > new\_2)  # True 是按照位置顺序一一比较
1
2
3

new\_1 = ['a', 11]
new\_2 = [11, 22, 33, 44]
print(new\_1 > new\_2)  # 不同数据类型之间默认无法直接做操作
1
2
3

new\_1 = ['a', 11]           # a 97
new\_2 = ['A', 22, 33, 44]   # A 65
print(new\_1 > new\_2)  # True
new\_1 = ['你', 11]           # a 97
new\_2 = ['我', 22, 33, 44]   # A 65 
print(new\_1 > new\_2)  # False
1
2
3
4
5
6

2.字典内置方法 dict

字典很少涉及到类型转换 都是直接定义使用

# 类型转换(了解即可) 字典很少涉及到类型转换 都是直接定义使用
print(dict([('name', 'jason'), ('pwd', 123)]))  # {'name': 'jason', 'pwd': 123}
print(dict(name='jason', pwd=123))  # {'name': 'jason', 'pwd': 123}
1
2
3

1.字典内k:v键值对是无序的

2.取值

# 2.取值操作
print(info['username'])  # 不推荐使用 键不存在会直接报错
print(info['xxx'])  # 不推荐使用 键不存在会直接报错
print(info.get('username'))  # jason
print(info.get('xxx'))  # None
print(info.get('username', '键不存在返回的值 默认返回None'))  # jason
print(info.get('xxx', '键不存在返回的值 默认返回None'))  # 键不存在返回的值 默认返回None
print(info.get('xxx', 123))  # 123
print(info.get('xxx'))  # None
1
2
3
4
5
6
7
8
9

3.统计字典中键值对的个数  len

print(len(info))  # 3
1

4.修改数据 info

info['username'] = 'jasonNB'  # 键存在则是修改
print(info) # {'username': 'jasonNB', 'pwd': 123, 'hobby': ['read', 'run']}
1
2

5.新增数据 info

# 5.新增数据
info['salary'] = 6  # 键不存在则是新增
print(info)  # {'username': 'jason', 'pwd': 123, 'hobby': ['read', 'run'], 'salary': 6}
1
2
3

6.删除数据

方式1

# 方式1
del info['username']
print(info)  # {'pwd': 123, 'hobby': ['read', 'run']}
1
2
3

方式2

res = info.pop('username')
print(info, res)  # {'pwd': 123, 'hobby': ['read', 'run']} jason
1
2

方式3

# 方式3
info.popitem()  # 随机删除
print(info)  # {'username': 'jason', 'pwd': 123}
1
2
3

7.快速获取键 值 键值对数据

print(info.keys())  # 获取字典所有的k值 结果当成是列表即可dict\_keys(['username', 'pwd', 'hobby'])
print(info.values())  # 获取字典所有的v值 结果当成是列表即可dict\_values(['jason', 123, ['read', 'run']])
print(info.items())  # 获取字典kv键值对数据 组织成列表套元组dict\_items([('username', 'jason'), ('pwd', 123), ('hobby', ['read', 'run'])])
1
2
3

8.修改字典数据 键存在则是修改 键不存在则是新增

# 8.修改字典数据 键存在则是修改 键不存在则是新增
info.update({'username':'jason123'})
print(info)  # {'username': 'jason123', 'pwd': 123, 'hobby': ['read', 'run']}
info.update({'xxx':'jason123'})
print(info)  # {'username': 'jason123', 'pwd': 123, 'hobby': ['read', 'run'], 'xxx': 'jason123'}
1
2
3
4
5

9.快速构造字典 给的值默认情况下所有的键都用一个

# 9.快速构造字典 给的值默认情况下所有的键都用一个
res = dict.fromkeys([1, 2, 3], None)
print(res)  # {1: None, 2: None, 3: None}
new\_dict = dict.fromkeys(['name', 'pwd', 'hobby'], [])  # {'name': [], 'pwd': [], 'hobby': []}
new\_dict['name'] = []
new\_dict['name'].append(123)
new\_dict['pwd'].append(123)
new\_dict['hobby'].append('read')
print(new\_dict)  # {'name': [123], 'pwd': [123, 'read'], 'hobby': [123, 'read']}
1
2
3
4
5
6
7
8
9

res = dict.fromkeys([1, 2, 3], 234234234234234234234)
print(id(res[1]))  # 2340954113104
print(id(res[2]))  # 2340954113104
print(id(res[3]))  # 2340954113104
1
2
3
4

10.键存在则获取键对应的值 键不存在则设置 并返回设置的新值

3.元组内置方法 tuple

# 关键字 tuple
# 类型转换 支持for循环的数据类型都可以转元组
print(tuple(123))  # 不可以
print(tuple(123.11))  # 不可以
print(tuple('zhang'))  # 可以
1
2
3
4
5

t1 = ()  # tuple
print(type(t1))
t2 = (1)  # int
print(type(t2))
t3 = (11.11)  # float
print(type(t3))
t4 = ('jason')  # str
print(type(t4))
1
2
3
4
5
6
7
8

当元组内只有一个数据值的时候 逗号不能省略,如果省略了 那么括号里面是什么数据类型就是什么数据类型建议:编写元组 逗号加上 哪怕只有一个数据(111, ) (‘jason’, )ps:以后遇到可以存储多个数据值的数据类型 如果里面只有一个数据 逗号也趁机加上

t2 = (1,)  # tuple
print(type(t2))
t3 = (11.11,)  # tuple
print(type(t3))
t4 = ('jason',)  # tuple
print(type(t4))
1
2
3
4
5
6

1.统计元组内个数

t1 = (11, 22, 33, 44, 55, 66)
# 1.统计元组内数据值的个数
print(len(t1))  # 6
1
2
3

2.查与改

# 2.查与改
print(t1[0])  # 可以查 11
t1[0] = 222  # 不可以改
"""元组的索引不能改变绑定的地址"""
1
2
3
4

t1 = (11, 22, 33, [11, 22])
t1[-1].append(33)
print(t1)  # (11, 22, 33, [11, 22, 33])
1
2
3

4.集合内置方法 set

set() 类型转换 支持for循环的 并且数据必须是不可变类型1.定义空集合需要使用关键字才可以2.集合内数据必须是不可变类型(整型 浮点型 字符串 元组 布尔值)

3.去重

# 去重
s1 = {1, 2, 12, 3, 2, 3, 2, 3, 2, 3, 4, 3, 4, 5, 4, 5, 4, 5, 4, 5, 4}
print(s1)  # {1, 2, 3, 4, 5, 12}
l1 = ['jason', 'jason', 'tony', 'oscar', 'tony', 'oscar', 'jason']
s2 = set(l1)
l1 = list(s2)
print(l1)  # ['jason', 'tony', 'oscar']
1
2
3
4
5
6
7

4.模拟两个人的好友集合

1.求f1和f2的共同好友

f1 = {'jason', 'tony', 'oscar', 'jerry'}
f2 = {'kevin', 'jerry', 'jason', 'lili'}
# 1.求f1和f2的共同好友
print(f1 & f2)  # {'jason', 'jerry'}
1
2
3
4

2.求f1/f2独有好友

print(f1 - f2)  # {'oscar', 'tony'}
print(f2 - f1)  # {'lili', 'kevin'}
1
2

3.求f1和f2所有的好友

print(f1 | f2)  # {'jason', 'kevin', 'lili', 'oscar', 'jerry', 'tony'}
1

4.求f1和f2各自独有的好友(排除共同好友)

print(f1 ^ f2)  # {'kevin', 'lili', 'tony', 'oscar'}
1

5.父集 子集

# 5.父集 子集
s1 = {1, 2, 3, 4, 5, 6, 7}
s2 = {3, 2, 1}
print(s1 > s2)  # s1是否是s2的父集 s2是不是s1的子集
print(s1 < s2)
1
2
3
4
5

5.可变类型与不可变类型

为什么字符串调用内置方法是产生新的值 列表调用内置方法是改变自身

1.可变类型  list  值改变(内置方法) 内存地址可以不变

# 为什么字符串调用内置方法是产生新的值 列表调用内置方法是改变自身
# 1.可变类型 list 值改变(内置方法) 内存地址可以不变
l1 = [11, 22, 33]
print(id(l1))  # 1359453669056
l1.append(44)  # [11, 22, 33, 44]
print(id(l1))  # 1359453669056
1
2
3
4
5
6

2.不可变类型 str int float 值改变(内置方法)，内存地址肯定变

# 2.不可变类型 str int float 值改变(内置方法)，内存地址肯定变
s1 = '$hello$'
print(id(s1))  # 2807369626992#
s1 = s1.strip('$')
print(id(s1))  # 2807369039344
ccc = 666
print(id(ccc))  # 2807369267664
ccc = 990
print(id(ccc))  # 2807374985904
1
2
3
4
5
6
7
8
9

作业

1.# 利用列表编写一个员工姓名管理系统# 输入1执行添加用户名功能# 输入2执行查看所有用户名功能# 输入3执行删除指定用户名功能# ps: 思考如何让程序循环起来并且可以根据不同指令执行不同操作# 提示: 循环结构 + 分支结构# 拔高: 是否可以换成字典或者数据的嵌套使用完成更加完善的员工管理而不是简简单单的一个用户名(能写就写不会没有关系)

2.去重下列列表并保留数据值原来的顺序# eg: [1, 2, 3, 2, 1]# 去重之后[1, 2, 3]

l1 = [2, 3, 2, 1, 2, 3, 2, 3, 4, 3, 4, 3, 2, 3, 5, 6, 5]
l2 = list(set(l1))  # 把列表装换为集合去重之后在装换为列表
l2.sort(key=l1.index)  # 对去重后的列表按原始列表排序
print(l2)
1
2
3
4

3.有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合pythons = {‘jason’, ‘oscar’, ‘kevin’, ‘ricky’, ‘gangdan’, ‘biubiu’}linuxs = {‘kermit’, ‘tony’, ‘gangdan’}

1.求出即报名python又报名linux课程的学员名字集合

print(pythons & linuxs)
1

2.求出所有报名的学生名字集合

print(pythons | linuxs)  # {'kevin', 'gangdan', 'jason', 'biubiu', 'kermit', 'tony', 'ricky', 'oscar'}
1

3.求出只报名python课程的学员名字

print(pythons - linuxs)  # {'kevin', 'oscar', 'ricky', 'jason', 'biubiu'}
1

4.求出没有同时这两门课程的学员名字集合

print(pythons ^ linuxs)  # {'biubiu', 'tony', 'kermit', 'jason', 'ricky', 'oscar', 'kevin'}
1