前言

此篇文章是我在B站学习时所做的笔记，部分为亲自动手演示过的，方便复习用。此篇文章仅供学习参考。

---

提示：以下是本篇文章正文内容，下面案例可供参考

循环

for 循环

for循环也可以让指定的代码重复执行 (循环)
for循环可以遍历容器中的数据( 
    遍历: 从容器中把数据一个一个取出
    容器: 可以简单理解为盒子, 盒子中可以存放很多的数据 (字符串 str, 列表 list, 元组 tuple, 字典 dict)
)
for 循环 也可以称为 for 遍历
1
2
3
4
5
6

• 基本的 for 循环语法:

for 变量名 in 容器:
    重复执行的代码
    
# 1. for 和 in  都是关键字
# 2. 容器中有多少个数据,循环会执行多少次(0 个数据,执行 0 次, ...)
# 3. 每次循环,会将容器中数据取出一个保存到 in 关键字前边的变量中
1
2
3
4
5
6

• for 做指定次数的循环

for 变量 in range(n):
    重复执行的代码
    
# 1, range() 是 Python 中的函数, 作用使用可以生成 [0, n) 之间的整数, 不包含 n 的 , 一个有 n 个数字, 所以这个循环循环 n 次
# 2, 想让 for 循环循环多少次,n 就写几
# 3, 变量的值 也是每次循环从 [0, n) 取出一个值, 第一次取得是 0 ,最后一次取得是 n-1
1
2
3
4
5
6

• range() 变形

# 需求: 使用 for 循环获取 5 到 10 之间的数字
for 变量 in  range(a, b):
    重复的代码
    
#  range(a, b)  作用是生成 [a, b) 之间的整数数字, 不包含 b
1
2
3
4
5

for i in range(5):  # [0 1 2 3 4 ]
    print(i)
​
print('-' * 30)
# 需求: 使用 for 循环获取 5 到 10(包含) 之间的数字
for m in range(5, 11):
    print(m)
1
2
3
4
5
6
7

​break 和 continue

break 和 continue 是 Python 中的两个关键字, 只能在循环中使用
​
break: 终止循环, 即代码执行遇到 break, 循环不再执行,立即结束
​
continue: 跳过本次循环. 即代码执行遇到 continue,本次循环剩下的代码不再执行, 继续下一次循环
1
2
3
4
5

# 1. 获取你输入的字符串
result = input('请输入一个字符串:')
# 2. 遍历打印这个字符串
for i in result:
    # 3. 在遍历的时候,如果这个字符是 e, 不打印(即后续的代码不执行)
    if i == 'e':
        continue  # 本次循环后续的代码不执行,执行下一次循环
    print(i)
​
print('-' * 30)
​
for i in result:
    # 3. 在遍历的时候,如果这个字符是 e, 不打印(即后续的代码不执行)
    # 如果这个字符不是 e, 打印
    if i != 'e':
        print(i)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

容器

容器: 也可以称为是数据序列, 或者高级数据类型, 也是 Python 中的数据类型
容器中可以存放多个数据.
1
2

字符串

字符串是容器, 因为字符串中可以包含多个字符
1

定义

定义: 使用引号(单引号, 双引号, 三引号)引起来的内容就是字符串
1

# 1. 使用单引号定义
my_str1 = 'hello'
print(my_str1, type(my_str1))
# 2, 使用双引号定义
my_str2 = "hello"
print(my_str2, type(my_str2))
​
# 3. 使用三引号定义
my_str3 = """hello"""
print(my_str3, type(my_str3))
my_str4 = '''hello'''
print(my_str4, type(my_str4))
​
# 4. 字符串本身包含引号 I'm 小明
# 4.1 字符串本身包含单引号, 则在定义的时候不能使用单引号
# 4.2 字符串本身包含双引号, 则在定义的时候不能使用双引号
my_str5 = "I'm 小明"
print(my_str5)
​
# 5. 字符串本身包含单引号,在定义的时候,我就是想使用单引号
# 5.1 使用 \ 转义字符,将字符串本身的引号进行转义 \' --> '  \" --> "
my_str6 = 'I\'m 小明'
print(my_str6)
# 5.2 字符串  I\'m 小明  \\ --> \
my_str7 = 'I\\\'m 小明'
print(my_str7)
​
# 5.3 字字符串前边加上 r""  原生字符串, 字符串中 的\不会作为转义字符, 文件操作会用一下
my_str8 = r'I\'m 小明'
print(my_str8)
my_str9 = r'I\\\'m 小明'
print(my_str9)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

下标

下标(索引): 就是指字符在字符串中的位置编号, 这个编号就是下标
​
这个编号一般来说都是从左到右进行编号的, 从 0 开始的(Python 中支持负数下标,从右到左进行编号的, 从-1 开始)
​
下标作用: 可以使用下标获取字符串中某个位置的字符
​
语法: 
字符串[下标]  # 获取指定位置的字符
1
2
3
4
5
6
7
8

str1 = 'abcdefg'
​
# 1. 打印字符串中最开始位置的字符
print(str1[0])  # a
​
# 2. 打印最后一个位置的数据
print(str1[-1])  # g
​
# 3. 打印倒数第二个位置的字符
print(str1[-2])  # f
​
# 打印下标为 2 的数据
print(str1[2])  # c
​
# 获取字符串中字符的个数(获取字符串的长度)
# len(字符串)   # length(长度)
num = len(str1)
print(num)
# 长度-1 的下标位置是最后一个字符
print(str1[num-1])  # g 最后一个字符,倒数第一个
​
print(str1[len(str1)-1])  # g 最后一个字符,倒数第一个
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

切片

切片: 可以获取字符串中多个字符(多个字符的下标是有规律的, 等差数列)
​
语法:
字符串[start:end :step]
start 是开始位置的下标, end 是结束位置的下标(注意,不能取到这个位置的字符) step 步长,等差数列的差值, 所取的相邻字符下标之间的差值,默认是 1, 可以不写
例: [1:5:1]  # 1 2 3 4 
[1:5:2]  # 1 3 
[1:5:3]  # 1 4
[1:5:4]  # 1 
1
2
3
4
5
6
7
8
9

# 切片会得到一个字符串, 即可以获取字符串中的多个字符
​
str1 = 'abcdefg'
​
# 1. 获取 abc 字符
print(str1[0:3:1])   # abc
# 1.1 如果步长是 1 可以不写, 最后一个冒号也不写
print(str1[0:3])  # abc
# 1.2 如果开始位置为 0 ,可以不写, 但是冒号必须有
print(str1[:3])  # abc
​
# 2. 获取 efg 字符
print(str1[4:7])  # efg
print(str1[-3:7])  # efg    
# 2.1 如果最后一个字符也要取, 可以不写, 但是冒号必须有
print(str1[4:])  # efg
# 2.2 如果开始和结束都不写, 获取全部内容, 但是冒号必须有
print(str1[:])  # abcdefg
​
# 3. 获取 aceg  # 0 2 4 6, 所以步长为 2
print(str1[0:7:2])  # aceg
print(str1[::2])  # aceg
​
​
# 4. 特殊应用, 步长为负数, 开始和结束不写,意思全变, 一般不用管,只有一种使用场景
# 反转(逆置) 字符串  字符串[::-1]
print(str1[::-1])  # gfedcba
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

字符串的查找方法 find

字符串.find(sub_str, start, end)  
    作用: 在字符串中查找是否存在 sub_str 这样的字符串
    sub_str: 要查找的小的字符串
    start: 开始位置, 从哪个下标位置开始查找, 一般不写,默认是 0 
    end: 结束位置, 查找到哪个下标结束, 一般不写,默认是 len()
    返回(代码执行之后会得到什么, 如果有返回,就可以使用变量保存): 
        1. 如果在字符串中找到了 sub_str , 返回 sub_str 第一次出现的正数下标(sub_str 中第一个字符在大字符串中的下标)
        2. 如果没有找到,返回 -1 
str1 = "and itcast and itheima and Python"
1
2
3
4
5
6
7
8
9

​
# 在字符串中查找 and
num = str1.find('and')
print(num)  # 0
​
# 在字符串中查找 第二个 and 出现的下标, 从第一次出现的后一位开始找
num1 = str1.find('and', num+1)
print(num1)  # 11
​
# 在字符串中查找 第三个 and 出现的下标, 从第二次出现的后一位开始找
num2 = str1.find('and', num1+1)
print(num2)  # 23
​
# 在字符串中查找 第四个 and 出现的下标, 从第三次出现的后一位开始找
num3 = str1.find('and', num2+1)
print(num3)  # -1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

字符串的替换方法 replace

字符串.replace(old_str, new_str, count)  # 将字符串中 old_str 替换为 new_str
- old_str: 被替换的内容
- new_str: 替换为的内容
- count: 替换的次数, 一般不写,默认是全部替换
- 返回: 替换之后的完整的字符串, 注意: 原来的字符串没有发生改变
str1 = 'good good study'
1
2
3
4
5
6

​

# 1, 将 str1 中 所有的 g 改为 G
str2 = str1.replace('g', 'G')
print('str1:', str1)   # str1: good good study
print('str2:', str2)   # str2: Good Good study
​
# 2. 将 str1 中第一个 good 改为 GOOD
str3 = str1.replace('good', 'GOOD', 1)
print('str3:', str3)   # str3: GOOD good study
​
# 3. 将 str1 中第二个 good 改为 GOOD
# 3.1 先将全部的 good  --> GOOD
str4 = str1.replace('good', "GOOD")
# 3.2 再将第一个 GOOD --> good
str4 = str4.replace('GOOD', 'good', 1)
print('str4:', str4)  # str4: good GOOD study
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

字符串的拆分 split

字符串.split(sep, maxsplit)  # 将字符串按照 sep 进行分割(拆分)
​
- sep, 字符串按照什么进行拆分, 默认是空白字符(空格, 换行\n, tab键\t)
- max_split, 分割次数,一般不写, 全部分割
- 返回: 将一个字符串拆分为多个,存到列表中
- 注意: 如果 sep 不写, 想要指定分割次数 则需要按照如下方式使用
字符串.split(maxsplit=n)   # n 是次数
1
2
3
4
5
6
7

str1 = "hello world and itcast and itheima and Python"
​
# 1. 将 str1 按照 and 字符进行拆分
result1 = str1.split('and')
print(result1)  # ['hello world ', ' itcast ', ' itheima ', ' Python']
​
# 2, 将 str1 按照 and 字符进行拆分, 拆分一次
result2 = str1.split('and', 1)
print(result2)  # ['hello world ', ' itcast and itheima and Python']
​
# 3. 按照空白字符进行切割
result3 = str1.split()
print(result3)  # ['hello', 'world', 'and', 'itcast', 'and', 'itheima', 'and', 'Python']
​
# 4. 按照空白字符进行切割, 拆分一次
result4 = str1.split(maxsplit=1)
print(result4)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

​

字符串的链接 join

字符串.join(列表)   # 括号中的内容主要是列表,可以是其他容器
​
# 作用: 将字符串插入到列表中每相邻的两个数据之间, 组成一个新的字符串
- 列表中的数据使用使用 逗号隔开的
- 注意点: 列表中的数据必须都是字符串, 否则会报错
1
2
3
4
5

list1 = ['good', 'good', 'study']
​
# 1. 将 列表中的字符串使用空格连起来
str1 = ' '.join(list1)
print(str1)  # good good study
​
# 2. 将 列表中的字符串使用 and 连起来
str2 = ' and '.join(list1)
print(str2)  # good and good and study
​
1
2
3
4
5
6
7
8
9
10

列表

列表 list, 是使用最多的一种容器(数据类型)
列表中可以存储多个数据, 每个数据之间使用逗号隔开
列表中可以存放任意类型的数据

定义

# 1. 类实例化的方式(不常用)
# 1.1 定义空列表(没有任何数据的列表)
# 变量 = list()
list1 = list()
print(type(list1), list1)  # <class 'list'> []
​
# 1.2 类型转换 list(容器)  将其他的容器转换为列表
# 转换字符串会将字符串中的每个字符作为一个数据存入到列表中
list2 = list('hello')
print(type(list2), list2)  # <class 'list'> ['h', 'e', 'l', 'l', 'o']
​
# 2, 直接使用 [] 进行定义(常用)
# 2.1 定义空列表
my_list = []
print(my_list)  # []
​
# 2.2 定义非空列表
my_list1 = [1, '小明', 3.14, False]
print(my_list1)  # [1, '小明', 3.14, False]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

​

列表支持下标和切片, 长度

列表支持下标和切片操作, 使用方法和字符串中的使用方法一致
区别: 列表的切片得到的是列表

list1 = ['小明', 18, 1.71, True]
​
# 获取第一个数据,名字
print(list1[0])
​
# 获取最后一个数据
print(list1[-1])
​
# 第一第二个数据
print(list1[0:2])  # ['小明', 18]
​
# 列表页支持 len() 求长度的, 求数据元素个数
print(len(list1))  # 4 
1
2
3
4
5
6
7
8
9
10
11
12
13

查找 - 查找列表中数据下标的方法

在字符串中使用的 find 方法查找下标的,找到了返回的是下标，不存在返回的是 -1.
在列表中没有 find 方法, 想要查找数据的下标,使用的 index() 方法
​
列表.index(数据, start, end)  使用和 find 方法一样, 同时在字符串中也有 index 方法
区别: 返回, index() 方法,找到返回第一次出现的下标, 没有找到代码直接报错
1
2
3
4
5

查找 - 判断是否存在

判断容器中某个数据是否存在可以使用 in 关键字
​
数据 in 容器   # 如果存在返回 True ,如果不存在,返回 False
1
2
3

查找 - 统计出现的次数

统计出现的次数,使用的是 count() 方法
列表.count(数据)   # 返回 数据出现的次数
1
2

my_list = [1, 3, 5, 7, 2, 3]
​
# 找 数据 3 出现的下标
num = my_list.index(3)
print(num)  # 1
​
# 找 数据 4 出现的下标
# num1 = my_list.index(4)  #  代码会报错
if 4 in my_list:
    num1 = my_list.index(4)
    print(num1)
else:
    print('不存在数据 4')
​
# my_list.count(4) 统计 数据 4 出现的次数
if my_list.count(4) > 0:
    num1 = my_list.index(4)
    print(num1)
else:
    print('不存在数据 4')
​
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

添加数据的方法

• 尾部添加(最常用)

列表.append(数据)   # 将数据添加到列表的尾部
​
返回: 返回的 None(关键字,空), 一般就不再使用 变量 来保存返回的内容
想要查看添加后的列表,需要打印的是列表
1
2
3
4

• 指定下标位置添加

列表.insert(下标, 数据)  # 在指定的下标位置添加数据, 如果指定的下标位置本来有数据, 原数据会后移
​
返回: 返回的 None(关键字,空), 一般就不再使用 变量 来保存返回的内容
想要查看添加后的列表,需要打印的是列表
1
2
3
4

• 列表合并

列表1.extend(列表2)  #  将列表 2 中的所有数据逐个添加的列表1 的尾部 返回: 返回的 None(关键字,空), 一般就不再使用 变量 来保存返回的内容 想要查看添加后的列表,需要打印的是列表 
1

my_list = [] 
print(my_list)  # [] ​
# 1. 想列表中添加数据  郭德纲
my_list.append('郭德纲')
print(my_list)  # ['郭德纲']
​
# 2. 向列表的尾部添加 郭麒麟
my_list.append('郭麒麟')
print(my_list)  # ['郭德纲', '郭麒麟']
​
# 3. 在下标位置为 1 的位置添加数据 '岳岳
my_list.insert(1, '岳岳')
print(my_list)  # ['郭德纲', '岳岳', '郭麒麟']
​
# 4. 在下标位置为 1 的位置添加数据 于谦
my_list.insert(1, '于谦')
print(my_list)  # ['郭德纲', '于谦', '岳岳', '郭麒麟']
​
# 5. 定义新的列表 list1
list1 = ['孙越', '烧饼']
# 将 list1 中数据逐个添加到 my_list 中
my_list.extend(list1)
print(my_list)  # ['郭德纲', '于谦', '岳岳', '郭麒麟', '孙越', '烧饼']
​
# 将 list1 作为一个整体添加到 my_list
my_list.append(list1)
print(my_list)  # ['郭德纲', '于谦', '岳岳', '郭麒麟', '孙越', '烧饼', ['孙越', '烧饼']]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

修改操作

想要修改列中的指定下标位置的数据, 使用的语法是:
​
列表[下标] = 数据
​
# 字符串中字符不能使用下标修改
1
2
3
4
5

# 定义列表
my_list = [1, 3, 5, 7]
​
# 1. 想要将下标为 1 的数据修改为 22
my_list[1] = 22
print(my_list)  # [1, 22, 5, 7]
​
# 修改最后一个位置的数据, 改为 'hello'
my_list[-1] = 'hello'
print(my_list)  # [1, 22, 5, 'hello']
​
# 2. 如果指定的下标不存在, 会报错的
# my_list[10] = 10  # 代码会报错
1
2
3
4
5
6
7
8
9
10
11
12
13

删除操作

在列表中删除中间的数据, 那么后面的数据会向前移动

• 根据下标删除

列表.pop(下标)  # 删除指定下标位置对应的数据
1. 下标不写,默认删除最后一个数据(常用)
2. 书写存在的下标, 删除对应下标位置的数据
​
返回: 返回的删除的数据
1
2
3
4
5

• 根据数据值删除

列表.remove(数据值)  # 根据数据值删除
​
返回: None
注意: 如果要删除的数据不存在, 会报错
1
2
3
4

• 清空数据(一般不用)

列表.clear()
1

my_list = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
​
# 1. 删除最后一个位置的数据
num = my_list.pop()
print('删除的数据为:', num)
print(my_list)  # [1, 3, 5, 7, 9, 2, 4, 6, 8]
​
# 2. 删除下标为 1 的数据 3
my_list.pop(1)
print(my_list)  # [1, 5, 7, 9, 2, 4, 6, 8]
​
# 3. 删除数据为 7 的数据
my_list.remove(7)  # 注意, 如果列表中有多个 7, 只能删除第一个, 如果数据不存在,会报错的
print(my_list)  # [1, 5, 9, 2, 4, 6, 8]
​
# my_list.remove(7)  # 会报错的
​
# 清空
my_list.clear()
print(my_list)  # []
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

列表的反转(倒置)

字符串中 反转倒置:  字符串[::-1]
​
列表中 反转和倒置:  
1. 列表[::-1]  # 使用切片的方法,会得到一个新列表, 原列表不会发生改变
2. 列表.reverse()   # 直接修改原列表, 返回 None
1
2
3
4
5

my_list = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
​
# 使用切片的方法反转, 会得到一个新列表
​
list1 = my_list[::-1]
print('my_list:', my_list)
print('list1  :', list1)
​
# 使用 reverse 方法, 直接修改原列表
my_list.reverse()
print('my_list:', my_list)
1
2
3
4
5
6
7
8
9
10
11

​

列表的复制

将列表中的数据复制一份,给到一个新的列表
# 使用场景: 有一个列表, 需要修改操作列表中的数据, 修改之后, 需要和原数据进行对比,即原数据不能改
​
1. 使用切片
变量 = 列表[:]
​
2. 使用 copy 方法
变量 = 列表.copy()
1
2
3
4
5
6
7
8

my_list = [1, 2, 3]
​
my_list1 = my_list[:]
print('my_list :', my_list)
print('my_list1:', my_list1)
my_list1[1] = 22
print('my_list :', my_list)
print('my_list1:', my_list1)
print('-' * 30)
​
my_list2 = my_list.copy()
print('my_list :', my_list)
print('my_list2:', my_list2)
my_list2[2] = 33
print('my_list :', my_list)
print('my_list2:', my_list2)
​
print('=' * 30)
my_list3 = my_list  # 这是同一个列表,多了一个名字, 引用
print('my_list :', my_list)
print('my_list3:', my_list3)
my_list3[0] = 11
print('my_list :', my_list)
print('my_list3:', my_list3)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

列表的排序

列表的排序, 一般来说都是对数字进行排序的
​
列表.sort()  # 按照升序排序, 从小到大
​
列表.sort(reverse=True)   # 降序排序, 从大到小
1
2
3
4
5

my_list = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
​
# 升序排序
my_list.sort()
print(my_list)
​
# 降序排序
my_list.sort(reverse=True)
​
print(my_list)
1
2
3
4
5
6
7
8
9
10

列表嵌套

列表嵌套, 列表中的内容还是列表
使用下标来确定获取的是什么类型的数据,然后确定可以继续进行什么操作

person_info = [["张三", "18", "功能测试"], ["李四", "20", "自动化测试"]]
​
print(len(person_info))  # 2
print(person_info[0])  # ['张三', '18', '功能测试']
​
print(person_info[0][0])  # '张三'
​
print(person_info[0][0][0])  # 张
​
# 将 18 改为 19
person_info[0][1] = '19'
print(person_info)  # [['张三', '19', '功能测试'], ['李四', '20', '自动化测试']]
​
# 给 李四 所在的列表添加一个性别 信息
person_info[1].append('男')
print(person_info)  # [['张三', '19', '功能测试'], ['李四', '20', '自动化测试', '男']]
​
# 将张三的年龄信息删除
# person_info[0].pop(1)
person_info[0].remove('19')
print(person_info)  # [['张三', '功能测试'], ['李四', '20', '自动化测试', '男']]
​
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

列表去重

列表去重:列表中存在多个数据, 需求, 去除列表中重复的数据.
方式1.  思路
遍历原列表中的数据判断在新列表中是否存在, 如果存在,不管, 如果不存在放入新的列表中
遍历: for 循环实现
判断是否存在: 可以 使用 in 
存入数据: append()
​
方法 2: 
在 Python 中还有一种数据类型(容器) ,称为是 集合(set)
特点: 集合中不能有重复的数据(如果有重复的数据会自动去重)
可以使用集合的特点对列表去重
1. 使用 set() 类型转换将列表转换为 集合类型
2. 再使用 list() 类型转换将集合 转换为列表
​
缺点: 不能保证数据在原列表中出现的顺序(一般来说,也不考虑这件事)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

my_list = [3, 2, 4, 1, 2, 3, 3, 2, 1, 2, 3, 1]
# print(list(set(my_list)))
#
# new_list = list(set(my_list))
# print(new_list)
​
new_list = []
# for i in my_list:
#     # 判断新列表中是否存在 i
#     if i in new_list:
#         # 存在
#         pass  # continue
#     else:
#         new_list.append(i)
​
for i in my_list:
    if i not in new_list:
        new_list.append(i)
​
print(new_list)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

元组

元组: tuple, 元组的特点和列表非常相似
​
1. 元组中可以存放任意类型的数据
2. 元组中可以存放任意多个数据
​
区别:
1. 元组中的数据内容不能改变, 列表中的可以改变的
2. 元组使用 (), 列表 使用 [] 
​
应用: 在函数的传参或者返回值中使用, 保证数据不会被修改
1
2
3
4
5
6
7
8
9
10

定义

1. 使用 类实例化的方式
2. 直接使用 () 方式

常用方法

由于元组中的数据不能修改,所以只有查看的方法
​
3. 在元组中也可以使用 下标和切片获取数据
4. 在元组中存在 index 方法, 查找下标, 如果不存在,会报错
5. 在元组中存在 count 方法, 统计数据出现的次数
6. 在元组中可以使用 in 操作, 判断数据是否存在
7. len() 统计个数
以上方法的使用 和列表中一样的
1
2
3
4
5
6
7
8

# 1, 类实例化的方式
# 1.1 定义空元祖(不会使用的)
my_tuple1 = tuple()
print(type(my_tuple1), my_tuple1)  # <class 'tuple'> ()
# 1.2 类型转换
# 可以将列表转换为元组, 只需要将 [], 变为 (), 同时 可以将元组转换列表 , 将() 变为 []
my_tuple2 = tuple([1, 2, 3])
print(my_tuple2)  # (1, 2, 3)
# 转换字符串, 和列表中一样,只是将列表的[] 变为()
my_tuple3 = tuple('hello')
print(my_tuple3)  # ('h', 'e', 'l', 'l', 'o')
​
# 2. 直接使用 () 定义
my_tuple4 = (1, "小王", 3.14, False)
print(my_tuple4)
​
# 3. 特殊点, 定义只有一个数据的元组时, 数据后边必须有一个逗号
my_tuple5 = (1,)
print(my_tuple5)  # (1,)
​
print(my_tuple4[1])  # 小王
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

​
​

字典

1. 字典 dict, 字典中的数据是由键(key)值(value)对组成的(键表示数据的名字, 值就是具体的数据)
2. 在字典中一组键值对是一个数据, 多个键值对之间使用 逗号隔开
变量 = {key: value, key:value, ...}
3. 一个字典中的键是唯一的,不能重复的, 值可以是任意数据
4. 字典中的键 一般都是 字符串,可以是数字, 不能是列表
1
2
3
4
5

定义

# 1. 使用 类实例化的方法
my_dict = dict()
print(type(my_dict), my_dict)  # <class 'dict'> {}
​
# dict() 不能转列表和元组,字符串
​
# 2. 直接使用{} 定义
# 2.1 空字典
my_dict1 = {}
print(type(my_dict1), my_dict1)  # <class 'dict'> {}
​
# 2.2 非空字典, 小明('name') 18('age') 1.71('height') True(is_men)  抽烟 喝酒 烫头('like')
my_dict2 = {"name": "小明", "age": 18, "height": 1.71, "is_men": True, "like": ["抽烟", "喝酒", "烫头"]}
​
print(my_dict2)
print(len(my_dict2))  # 5
​
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

增加和修改操作

语法: 
字典[键] = 数据值
1. 如果键已经存在,就是修改数据值
2. 如果键不存在,就是添加数据(即添加键值对)
1
2
3
4

# 定义字典  小明 18 爱好
​
my_dict = {"name": "小明", "age": 18, "like": ['抽烟', '喝酒', '烫头']}
​
print(my_dict)  # {'name': '小明', 'age': 18, 'like': ['抽烟', '喝酒', '烫头']}
# 1. 添加性别信息 sex
my_dict['sex'] = '男'
print(my_dict)  # {'name': '小明', 'age': 18, 'like': ['抽烟', '喝酒', '烫头'], 'sex': '男'}
​
# 2. 修改年龄为 19
my_dict['age'] = 19
print(my_dict)  # {'name': '小明', 'age': 19, 'like': ['抽烟', '喝酒', '烫头'], 'sex': '男'}
​
# 3. 添加一个爱好, 学习--> 本质是向列表中添加一个数据
my_dict['like'].append('学习')
print(my_dict)  # {'name': '小明', 'age': 19, 'like': ['抽烟', '喝酒', '烫头', '学习'], 'sex': '男'}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

​

删除

• 删除指定键值对

del 字典[键]
or
字典.pop(键)  # 键必须书写
1
2
3

• 清空

字典.clear()
1

my_dict = {'name': '小明', 'age': 19, 'like': ['抽烟', '喝酒', '烫头', '学习'], 'sex': '男'}
​
# 删除  sex 键值对
del my_dict['sex']
print(my_dict)  # {'name': '小明', 'age': 19, 'like': ['抽烟', '喝酒', '烫头', '学习']}
​
# 字典.pop('键')
my_dict.pop('age')
print(my_dict)  # {'name': '小明', 'like': ['抽烟', '喝酒', '烫头', '学习']}
​
# 删除抽烟的爱好 ---> 本质操作是在列表中删除 数据值
# my_dict['like'].pop(0)
my_dict['like'].remove('抽烟')
print(my_dict)  # {'name': '小明', 'like': ['喝酒', '烫头', '学习']}
​
​
# 清空键值对
my_dict.clear()
print(my_dict)  # {}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

查询- 根据键获取对应的值

字典中没有下标的概念,想要获取数据值,要使用 key(键)来获取

• 使用 字典[键]

字典[键] 
1. 如果键存在 返回键对应的数据值, 
2. 如果键不存在, 会报错
1
2
3

• 使用 字典.get(键)

字典.get(键, 数据值)   
1. 数据值一般不写, 默认是 None
返回: 
1. 如果键存在 返回键对应的数据值
2. 如果键不存在, 返回的是 括号中书写的数据值(None)
​
一般建议使用 get 方法
1
2
3
4
5
6
7

my_dict = {'name': '小明', 'age': 19, 'like': ['抽烟', '喝酒', '烫头', '学习']}
​
# 1. 获取 名字
print(my_dict['name'])  # 小明
print(my_dict.get('name'))  # 小明
print(my_dict.get('name', 'zzz'))  # 小明
​
# 2. 获取 sex 性别
# print(my_dict['sex'])   # 代码会报错, 原因 key 不存在
​
print(my_dict.get('sex'))  # None
print(my_dict.get('sex', '保密'))  # 保密
​
# 3. 获取 第二个爱好
print(my_dict['like'][1])  # 喝酒
print(my_dict.get('like')[1])  # 喝酒
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

​

字典的遍历

对 字典的键 进行遍历

for 变量 in 字典:
    print(变量)  # 变量就是字典的 key, 键
    
    
for 变量 in 字典.keys():  # 字典.keys() 可以获取字典中所有的键
    print(变量)
1
2
3
4
5
6

对 字典的值 进行遍历

for 变量 in 字典.values():   # 字典.values() 可以获取字典中所有的值
    print(变量)
1
2

对 字典的键值对 进行遍历

# 变量1 就是 键, 变量2 就是键对应的值
for 变量1, 变量2 in 字典.items():  # 字典.items() 获取键值对
    print(变量1, 变量2)
1
2
3

# 定义字典
my_dict = {'name': '小明', 'age': 18, 'sex': '男'}
​
# 1. 遍历字典的键
for k in my_dict:
    print(k)
​
for k in my_dict.keys():
    print(k)
​
print('-' * 30)
​
# 2. 遍历字典的值
for v in my_dict.values():
    print(v)
​
print('*' * 30)
​
# 3. 遍历键值
for k, v in my_dict.items():
    print(k, v)
​
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

作业

# 通过 input输入3个人信息，每个人有姓名和年龄，将信息存入字典中，并将将字典存入列表。
​
# 遍历列表，打印每个人的信息，打印格式如下：
#  张三 20
#  李四 22
#  王五 23
​
1. 输入三个人的信息 (输入 input('提示信息') 可以考虑使用 循环)
2. 每个人有姓名和年龄, (都需要使用 input 输入, 一次循环两个 input) 
3. 将姓名和年龄信息存入字典中 {"name": xxx, "age": xxx}/ {输入的姓名: 年龄}
4. 并将将字典存入列表。  列表.append(数据) 
1
2
3
4
5
6
7
8
9
10
11

# my_list = []
#
# for i in range(3):
#     my_dict = {}  # 每循环一次创建一个字典
#     name = input('请输入姓名:')
#     age = input('请输入年龄:')
#     my_dict['name'] = name
#     my_dict['age'] = age
#     my_list.append(my_dict)
#
# # 遍历列表, 列表中存的都是字典, 所以 item 是字典
# for item in my_list:   # item  是字典
#     print(item['name'], item['age'])  # 根据字典的 key 获取 value
​
#
# my_list = [{'id': 1,'money': 10}, {'id': 2, 'money': 20},
#            {'id': 3, 'money': 30}, {'id': 4, 'money': 40}]
#
# def func():
#     for i in my_list:  # i 变量, 字典类型
#         # 1. 如果字典中 ID 的值为奇数,则对 money 的值加 20
#         if i.get('id') % 2 == 1:
#             i['money'] = i.get('money') + 20
#         #     2. 如果字典中 ID 的值为偶数, 则对 money 的值加 10
#         else:
#             i['money'] = i.get('money') + 10
#
#     #     3. 打印输出列表,查看最终的结果
#     print(my_list)
#
# func()
​
​
my_dict = {'登录': [{'desc': '正确的用户名密码', 'username': 'admin', 'password': '123456', 'expect': '登录成功'}, {'desc': '错误的用户名', 'username': 'root', 'password': '123456', 'expect': '登录失败'}, {'desc': '错误的密码', 'username': 'admin', 'password': '123123', 'expect': '登录失败'}, {'desc': '错误的用户名和密码', 'username': 'aaaa', 'password': '123123', 'expect': '登录失败'}],
           '注册': [{'desc': '注册1', 'username': 'abcd', 'password': '123456'}, {'desc': '注册1', 'username': 'xyz', 'password': '123456'}]}
​
# 1. 自定义以程序, 实现如下要求
# 2. 能够获取测试人员输入的信息(登录/测试)
opt = input('请输入要获取的数据(登录/注册) :')
info_list = []
if opt == '登录':
    print('获取登录数据')
    for d in my_dict.get('登录'):  # d 字典类型
        # 需要将数据组成元组类型(定义元组)
        my_tuple = (d.get('username'), d.get('password'), d.get('expect'))
        # 需要将元组添加到列表中  append()
        info_list.append(my_tuple)
elif opt == '注册':
    print('获取注册数据')
    for d in my_dict.get('注册'):
        my_tuple = (d.get('username'), d.get('password'))
        info_list.append(my_tuple)
else:
    print('输入错误')
​
print(info_list)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56