Python 入门基础

第一个Python程序之打印 Hello World!

print("Hello World!")
1

字符串定义的三种方式，type 用了检测数据类型

# 单引号定义法，使用单引号进行包围
name = '测试'
print(type(name))
# 双引号定义法
name = "测试"
print(type(name))
# 三引号定义法，写法和多行注释是一样的
name = """
我是
小白
"""
print(type(name))
1
2
3
4
5
6
7
8
9
10
11
12

# 在字符串内 包含双引号
name = '"包含双引号"'
print(name)
# 在字符串内 包含单引号
name = "'包含单引号'"
print(name)
# 使用转义字符 \ 解除引号的效用
name = "\"解除引号的效用\""
print(name)
name = '\'解除引号的效用\''
print(name)
1
2
3
4
5
6
7
8
9
10
11

Python 中的各类运算符

# 算术（数学）运算符
print(1 + 1) #加
print(2 - 1) #减
print(3 * 3) #乘
print(4 / 2) #除
print(11 // 2) #取整除
print(9 % 2) #取余
print(2 ** 2) #指数
1
2
3
4
5
6
7
8

# 赋值运算符
num = 1 + 2 * 3
1
2

# 复合赋值运算符
num = 1
num += 1 #加法赋值运算符 等效于 num = num + 1
num -= 1 #减法赋值运算符
num *= 4 #乘法赋值运算符
num /= 2 #除法赋值运算符
num %= 2 #取模赋值运算符
num **=2 #幂赋值运算符
num //= 2 #取整除赋值运算符
1
2
3
4
5
6
7
8
9

Python 中的 input 语句，获取键盘的输入信息

name = input("请告诉我你是谁？")
print("我知道了，你是:%s" % name)
1
2

字符串格式化的方式

#1、第一个 %s 占位，第二个% 后面跟变量。%s 将内容转换成字符串，放入占位位置。
print("1 * 1 的结果是：%s" % (1 * 1))

# 定义变量 %d 将内容转换成整数，放入占位位置。%f 将内容转换成浮点型，放入占位位置
stock_price_daily_growth_factor = 1.2
growth_days = 7.1
finally_stock_price = 71.63
print("每日增长系数: %.1f，经过%d天的增长后，股价达到了：%.2f" % (stock_price_daily_growth_factor, growth_days, finally_stock_price))
# 打印结果：每日增长系数: 1.2，经过7天的增长后，股价达到了：71.63

#2、f"{占位}"
print(f"1 * 2的结果是：{1 * 2}")
1
2
3
4
5
6
7
8
9
10
11
12

布尔类型和比较运算符

# 01_布尔类型和比较运算符
bool_1 = True
bool_2 = False
print(f"bool_1变量的内容是：{bool_1}, 类型是：{type(bool_1)}")
print(f"bool_2变量的内容是：{bool_2}, 类型是：{type(bool_2)}")
# 比较运算符的使用
# == , !=, >, <, >=, <=
# 演示进行内容的相等比较
num1 = 10
num2 = 10
print(f"10 == 10的结果是：{num1 == num2}")

num1 = 10
num2 = 15
print(f"10 != 15的结果是：{num1 != num2}")

name1 = "itcast"
name2 = "itheima"
print(f"itcast == itheima 结果是：{name1 == name2}")

# 演示大于小于，大于等于小于等于的比较运算
num1 = 10
num2 = 5
print(f"10 > 5结果是：{num1 > num2}")
print(f"10 < 5的结果是：{num1 < num2}")

num1 = 10
num2 = 11
print(f"10 >= 11的结果是：{num1 >= num2}")
print(f"10 <= 11的结果是：{num1 <= num2}")
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

if语句的基本格式应用

age = 10

if age >= 18:
    print("我已经成年了")

print("时间过的真快呀")
1
2
3
4
5
6

if else的组合判断语句

age = int(input("请输入你的年龄："))

if age >= 18:
    print("您已成年，需要买票10元。")
else:
    print("您未成年，可以免费游玩。")
1
2
3
4
5
6

if elif else 多条件判断语句的使用

# 多条件判断的语法
if int(input("请输入你的身高（cm）：")) < 120:
    print("身高小于120cm，可以免费。")
elif int(input("请输入你的VIP等级（1-5）：")) > 3:
    print("vip级别大于3，可以免费。")
elif int(input("请告诉我今天几号：")) == 1:
    print("今天是1号免费日，可以免费")
else:
    print("不好意思，条件都不满足，需要买票10元。")
1
2
3
4
5
6
7
8
9

while语句的基本格式应用

i = 0
while i < 100:
    print("小美，我喜欢你")
    i += 1
1
2
3
4

while循环的嵌套使用

# 外层：表白100天的控制
# 内层：每天的表白都送10只玫瑰花的控制
i = 1
while i <= 100:
    print(f"今天是第{i}天，准备表白.....")

    # 内层循环的控制变量
    j = 1
    while j <= 10:
        print(f"送给小美第{j}只玫瑰花")
        j += 1

    print("小美，我喜欢你")
    i += 1

print(f"坚持到第{i - 1}天，表白成功")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

while的嵌套循环打印输出九九乘法表

# 定义外层循环的控制变量
i = 1
while i <= 9:
    # 定义内层循环的控制变量
    j = 1
    while j <= i:
        # 内层循环的print语句，不要换行，通过\t制表符进行对齐
        print(f"{j} * {i} = {j * i}\t", end='')
        j += 1
    i += 1
    print()     # print空内容，就是输出一个换行
1
2
3
4
5
6
7
8
9
10
11

for循环的基础语法

name = "itheima"

for x in name:
    # 将name的内容，挨个取出赋予x临时变量
    # 就可以在循环体内对x进行处理
    print(x)
1
2
3
4
5
6

break 结束本循环

#计算1-10之和，但是如果和超过20以后，就不再循环了，直接打印和是多少，i循环到几了
i=1
s=0
while i<10:
    s+=i
    if s>20:
        break
    i+=1
print ('s=',s,'i=',i)   #结果是s=21，i=6

1
2
3
4
5
6
7
8
9
10

continue 结束本次循环，继续执行下一次循环

#计算1-100的偶数和
s=0
for i in range(1,101):
    if i%2==1:   #当i跟2取余是1时，表示这是个奇数，则不执行本次循环
        continue
    s+=i
print (s)   #2550

1
2
3
4
5
6
7
8

return 结束整个程序运行

# 1-100内的偶数和
def fun():
    s = 0
    for i in range(1, 101):
        if i % 2 == 1:
            return s  # 碰到奇数就返回s的值
        s += i
    print(s)


print(fun())  # 调用函数，并打印结果
1
2
3
4
5
6
7
8
9
10
11

Python中的range()语句的基本使用

# range是python中的一个内置函数，用于生成一系列连续的整数，创建一个整数列表，一般用在 for 循环中
# range()函数语法
range(start, stop[, step])
1
2
3

# range语法1 range(num)
# for x in range(10):
#     print(x)

# range 语法2 range(num1, num2)
# for x in range(5, 10):
#     # 从5开始，到10结束（不包含10本身）的一个数字序列，数字之间间隔是1
#     print(x)

# range 语法3 range(num1, num2, step)
# for x in range(5, 10, 2):
#     # 从5开始，到10结束（不包含10本身）的一个数字序列，数字之间的间隔是2
#     print(x)

for x in range(10):
    # 默认从0开始，不包含10
    print(f"{x}")
    
# 错误写法，不能直接写5
for x in 5:
    # 默认从0开始，不包含10
    print(f"{x}")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

Python for循环临时变量的作用域

i = 0
for i in range(5):
    print(i)

print(i)
1
2
3
4
5

for循环打印九九乘法表

# 通过外层循环控制行数
for i in range(1, 10):
    # 通过内层循环控制每一行的数据
    for j in range(1, i + 1):
        # 在内层循环中输出每一行的内容
        print(f"{j} * {i} = {j * i}\t", end='')

    # 外层循环可以通过print输出一个回车符
    print()
1
2
3
4
5
6
7
8
9

嵌套应用for循环

# 坚持表白100天，每天都送10朵花
# range
i = 0
for i in range(1, 101):
    print(f"今天是向小美表白的第{i}天，加油坚持。")

    # 写内层的循环了
    for j in range(1, 11):
        print(f"给小美送的第{j}朵玫瑰花")

    print("小美我喜欢你")

print(f"第{i}天，表白成功")
1
2
3
4
5
6
7
8
9
10
11
12
13

函数的定义语法

# 定义一个函数，输出相关信息
def say_hi():
    print("Hi 我是程序员，学Python")

# 调用函数，让定义的函数开始工作
say_hi()
1
2
3
4
5
6

函数使用参数

# 定义2数相加的函数，通过参数接收被计算的2个数字
def add(x, y, z):
    result = x + y + z
    print(f"{x} + {y} + {z}的计算结果是：{result}")

# 调用函数，传入被计算的2个数字
add(5, 6, 7)
1
2
3
4
5
6
7

定义函数返回值的语法格式

# 定义一个函数，完成2数相加功能
def add(a, b):
    result = a + b
    # 通过返回值，将相加的结果返回给调用者，return 后函数执行结束
    return result

# 函数的返回值，可以通过变量去接收
r = add(5, 6)
print(r)
1
2
3
4
5
6
7
8
9

def add(x, y):
    #add函数可以接收2个参数，进行2数相加的功能
    #:param x: 形参x表示相加的其中一个数字
    #:param y: 形参y表示相加的另一个数字
    #:return: 返回值是2数相加的结果
    result = x + y
    print(f"2数相加的结果是：{result}")
    return result

add(5, 6)
1
2
3
4
5
6
7
8
9
10

嵌套调用函数

# 定义函数func_b
def func_b():
    print("1")
# 定义函数func_a，并在内部调用func_b
def func_a():
    print("2")

    # 嵌套调用func_b
    func_b()

    print("3")
# 调用函数func_a
func_a()

# 调用结果：2 1 3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

函数使用的时候，定义的变量作用域

# 变量在函数体内成为了函数的局部变量
def test_a():
    num = 100
    print(num)
    
test_a()
#出了函数体，局部变量就无法使用了
print(num)
1
2
3
4
5
6
7
8

函数的多返回值示例

# 演示使用多个变量，接收多个返回值
def test_return():
    return 1, "hello", True
# 定义多个变量
x, y, z = test_return()
# 依次调用
print(x)
print(y)
print(z)
1
2
3
4
5
6
7
8
9

# 多种传参的形式
def user_info(name, age, gender):
    print(f"姓名是:{name}, 年龄是:{age}, 性别是:{gender}")
# 位置参数 - 默认使用形式
user_info('小明', 20, '男')

# 关键字参数
user_info(name='小王', age=11, gender='女')
user_info(age=10, gender='女', name='潇潇')    # 可以不按照参数的定义顺序传参
user_info('甜甜', gender='女', age=9)

# 缺省参数（默认值）
def user_info(name, age, gender):
    print(f"姓名是:{name}, 年龄是:{age}, 性别是:{gender}")

user_info('小天', 13, '男')

# 不定长 - 位置不定长, *号,打印结果为元祖
# 不定长定义的形式参数会作为元组存在，接收不定长数量的参数传入
def user_info(*args):
    print(f"args参数的类型是：{type(args)}，内容是:{args}")

user_info(1, 2, 3, '小明', '男孩')

# 不定长 - 关键字不定长, **号，打印结果为List
def user_info(**kwargs):
    print(f"args参数的类型是：{type(kwargs)}，内容是:{kwargs}")
user_info(name='小王', age=11, gender='男孩')

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

lambda匿名函数

# 定义一个函数，接受其它函数输入
def test_func(compute):
    result = compute(1, 2)
    print(f"结果是:{result}")
# 通过lambda匿名函数的形式，将匿名函数作为参数传入
def add(x, y):
    return x + y

# 函数作为参数传递
test_func(add)

# 使用 lambda 可以不定义 add 方法。x，y 代表形参，x+y 是运算
test_func(lambda x, y: x + y)
1
2
3
4
5
6
7
8
9
10
11
12
13

数据容器之list列表。语法：[元素，元素，…]

# 定义一个列表 list
my_list = ["itheima", "itcast", "python"]
print(my_list)
print(type(my_list))

my_list = ["itheima", 666, True]
print(my_list)
print(type(my_list))

# 定义一个嵌套的列表
my_list = [ [1, 2, 3], [4, 5, 6]]
print(my_list)
print(type(my_list))

# 通过下标索引取出对应位置的数据
my_list = ["Tom", "Lily", "Rose"]
# 列表[下标索引], 从前向后从0开始，每次+1，  从后向前从-1开始，每次-1
print(my_list[0])
print(my_list[1])
print(my_list[2])
# 错误示范；通过下标索引取数据，一定不要超出范围
# print(my_list[3])

# 通过下标索引取出数据（倒序取出）
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])


# 取出嵌套列表的元素
my_list = [ [1, 2, 3], [4, 5, 6]]
print(my_list[1][1])

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

list 列表方法预览

list列表的常用方法演示

mylist = ["itcast", "itheima", "python"]

# 1.1 查找某元素在列表内的下标索引 index方法
index = mylist.index("itheima")
print(f"itheima在列表中的下标索引值是：{index}")
# 结果：itheima在列表中的下标索引值是：1

# 1.2如果被查找的元素不存在，会报错
# index = mylist.index("hello")
# print(f"hello在列表中的下标索引值是：{index}")

# 2. 修改特定下标索引的值
mylist[0] = "python"
print(f"列表被修改元素值后，结果是：{mylist}")
# 结果：列表被修改元素值后，结果是：['python', 'itheima', 'python']

# 3. 在指定下标位置插入新元素 insert 方法
mylist.insert(1, "best")
print(f"列表插入元素后，结果是：{mylist}")
# 结果：列表插入元素后，结果是：['python', 'best', 'itheima', 'python']

# 4. 在列表的尾部追加```单个```新元素 append 方法
mylist.append("程序员")
print(f"列表在追加了元素后，结果是：{mylist}")
# 结果：列表在追加了元素后，结果是：['python', 'best', 'itheima', 'python', '程序员']

# 5. 在列表的尾部追加```一批```新元素 extend 方法
mylist2 = [1, 2, 3]
mylist.extend(mylist2)
print(f"列表在追加了一个新的列表后，结果是：{mylist}")
# 结果：列表在追加了一个新的列表后，结果是：['python', 'best', 'itheima', 'python', '程序员', 1, 2, 3]

# 6. 删除指定下标索引的元素（2种方式）
mylist = ["itcast", "itheima", "python"]

# 6.1 方式1：del 列表[下标] mylist 方法
del mylist[2]
print(f"列表删除元素后结果是：{mylist}")
# 结果：列表删除元素后结果是：['itcast', 'itheima']

# 6.2 方式2：列表.pop(下标)
mylist = ["itcast", "itheima", "python"]
element = mylist.pop(2)
print(f"通过pop方法取出元素后列表内容：{mylist}, 取出的元素是：{element}")
# 结果：通过pop方法取出元素后列表内容：['itcast', 'itheima'], 取出的元素是：python

# 7. 删除某元素在列表中的第一个匹配项 remove 方法
mylist = ["itcast", "itheima", "itcast", "itheima", "python"]
mylist.remove("itheima")
print(f"通过remove方法移除元素后，列表的结果是：{mylist}")
# 结果：通过remove方法移除元素后，列表的结果是：['itcast', 'itcast', 'itheima', 'python']

# 8. 清空列表 clear 方法
mylist.clear()
print(f"列表被清空了，结果是：{mylist}")
# 结果：列表被清空了，结果是：[]

# 9. 统计列表内某元素的数量 count方法
mylist = ["itcast", "itheima", "itcast", "itheima", "python"]
count = mylist.count("itheima")
print(f"列表中itheima的数量是：{count}")
# 结果：列表中itheima的数量是：2

# 10. 统计列表中全部的元素数量 len
mylist = ["itcast", "itheima", "itcast", "itheima", "python"]
count = len(mylist)
print(f"列表的元素数量总共有：{count}个")
# 结果：列表的元素数量总共有：5个

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
57
58
59
60
61
62
63
64
65
66
67
68
69

使用while和for循环遍历列表

def list_while_func():
    """
    使用while循环遍历列表的演示函数
    :return: None
    """
    mylist = ["学习", "程序员", "Python"]
    # 循环控制变量：通过下标索引来控制，默认是0
    # 每一次循环，将下标索引变量+1
    # 循环条件：下标索引变量 < 列表的元素数量

    # 定义一个变量，用来标记列表的下标
    index = 0       # 初始下标为0
    while index < len(mylist):
        # 通过index变量取出对应下标的元素
        element = mylist[index]
        print(f"列表的元素：{element}")

        # 至关重要：将循环变量（index）每一次循环都+1
        index += 1


def list_for_func():
    """
    使用for循环遍历列表的演示函数
    :return:
    """
    mylist = [1, 2, 3, 4, 5]
    # for 临时变量 in 数据容器:
    for element in mylist:
        print(f"列表的元素有：{element}")


if __name__ == '__main__':
    # list_while_func()
    list_for_func()
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

tuple元组的定义和操作。

# 定义元组
t1 = (1, "Hello", True)
t2 = ()
t3 = tuple()
print(f"t1的类型是：{type(t1)}, 内容是：{t1}")
print(f"t2的类型是：{type(t2)}, 内容是：{t2}")
print(f"t3的类型是：{type(t3)}, 内容是：{t3}")

# 定义单个元素的元素
t4 = ("hello", )
print(f"t4的类型是：{type(t4)}, t4的内容是：{t4}")

# 元组的嵌套
t5 = ( (1, 2, 3), (4, 5, 6) )
print(f"t5的类型是：{type(t5)}, 内容是：{t5}")

# 下标索引去取出内容
num = t5[1][2]
print(f"从嵌套元组中取出的数据是：{num}")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

tuple 元祖常用方法预览。元组不可修改，所以其操作方法非常少。

tuple 元祖的常用方法演示

# 元组的操作：index查找方法
t6 = ("java", "测试", "Python")
index = t6.index("Python")
print(f"在元组t6中查找python，的下标是：{index}")
# 结果：在元组t6中查找python，的下标是：2

# 元组的操作：count统计方法
t7 = ("java", "vue", "vue", "vue", "Python")
num = t7.count("vue")
print(f"在元组t7中统计vue的数量有：{num}个")
# 结果：在元组t7中统计vue的数量有：3个

# 元组的操作：len函数统计元组元素数量
t8 = ("java", "vue", "vue", "vue", "Python")
num = len(t8)
print(f"t8元组中的元素有：{num}个")
# 结果：t8元组中的元素有：5个
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

元组的遍历

# 元组的遍历：while
index = 0
while index < len(t8):
    print(f"元组的元素有：{t8[index]}")
    # 至关重要
    index += 1

# 元组的遍历：for
for element in t8:
    print(f"2元组的元素有：{element}")

1
2
3
4
5
6
7
8
9
10
11

字符串常用方法汇总

字符串常用方法演示

# 定义集合
my_set = {"java", "vue", "itheima", "java", "vue", "itheima", "java", "vue", "itheima"}
my_set_empty = set()        # 定义空集合
print(f"my_set的内容是：{my_set}, 类型是：{type(my_set)}")
#结果：my_set的内容是：{'java', 'itheima', 'vue'}, 类型是：
print(f"my_set_empty的内容是：{my_set_empty}, 类型是：{type(my_set_empty)}")
#结果：my_set_empty的内容是：set(), 类型是：

# 添加新元素
my_set.add("Python")
my_set.add("java")      #
print(f"my_set添加元素后结果是：{my_set}")
#结果：my_set添加元素后结果是：{'Python', 'java', 'itheima', 'vue'}

# 移除元素
my_set.remove("vue")
print(f"my_set移除vue后，结果是：{my_set}")
#结果：my_set移除vue后，结果是：{'Python', 'java', 'itheima'}

# 随机取出一个元素
my_set = {"java", "vue", "itheima"}
element = my_set.pop()
print(f"集合被取出元素是：{element}, 取出元素后：{my_set}")
#结果：集合被取出元素是：java, 取出元素后：{'itheima', 'vue'}

# 清空集合, clear
my_set.clear()
print(f"集合被清空啦，结果是：{my_set}")
#结果：集合被清空啦，结果是：set()

# 取2个集合的差集
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.difference(set2)
print(f"取出差集后的结果是：{set3}")
#结果：取出差集后的结果是：{2, 3}
print(f"取差集后，原有set1的内容：{set1}")
#结果：取差集后，原有set1的内容：{1, 2, 3}
print(f"取差集后，原有set2的内容：{set2}")
#结果：取差集后，原有set2的内容：{1, 5, 6}


# 消除2个集合的差集
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set1.difference_update(set2)
print(f"消除差集后，集合1结果：{set1}")
#结果：消除差集后，集合1结果：{2, 3}
print(f"消除差集后，集合2结果：{set2}")
#结果：消除差集后，集合2结果：{1, 5, 6}

# 2个集合合并为1个
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.union(set2)
print(f"2集合合并结果：{set3}")
#结果：2集合合并结果：{1, 2, 3, 5, 6}
print(f"合并后集合1：{set1}")
#结果：合并后集合1：{1, 2, 3}
print(f"合并后集合2：{set2}")
#结果：合并后集合2：{1, 5, 6}

# 统计集合元素数量len()
set1 = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5}
num = len(set1)
print(f"集合内的元素数量有：{num}个")
#结果：集合内的元素数量有：5个
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
57
58
59
60
61
62
63
64
65
66
67

集合的遍历

# 集合不支持下标索引，不能用while循环
# 可以用for循环
set1 = {1, 2, 3, 4, 5}
for element in set1:
    print(f"集合的元素有：{element}")
#结果：集合的元素有：1
#结果：集合的元素有：2
#结果：集合的元素有：3
#结果：集合的元素有：4
#结果：集合的元素有：5
1
2
3
4
5
6
7
8
9
10

数据容器字典的定义

# 定义字典
my_dict1 = {"王力鸿": 99, "周杰轮": 88, "林俊节": 77}
# 定义空字典
my_dict2 = {}
my_dict3 = dict()
print(f"字典1的内容是：{my_dict1}, 类型：{type(my_dict1)}")
print(f"字典2的内容是：{my_dict2}, 类型：{type(my_dict2)}")
print(f"字典3的内容是：{my_dict3}, 类型：{type(my_dict3)}")

# 定义重复Key的字典
my_dict1 = {"王力鸿": 99, "王力鸿": 88, "林俊节": 77}
print(f"重复key的字典的内容是：{my_dict1}")

# 从字典中基于Key获取Value
my_dict1 = {"王力鸿": 99, "周杰轮": 88, "林俊节": 77}
score = my_dict1["王力鸿"]
print(f"王力鸿的考试分数是：{score}")
score = my_dict1["周杰轮"]
print(f"周杰轮的考试分数是：{score}")
# 定义嵌套字典
stu_score_dict = {
    "王力鸿": {
        "语文": 77,
        "数学": 66,
        "英语": 33
    }, "周杰轮": {
        "语文": 88,
        "数学": 86,
        "英语": 55
    }, "林俊节": {
        "语文": 99,
        "数学": 96,
        "英语": 66
    }
}
print(f"学生的考试信息是：{stu_score_dict}")

# 从嵌套字典中获取数据
# 看一下周杰轮的语文信息
score = stu_score_dict["周杰轮"]["语文"]
print(f"周杰轮的语文分数是：{score}")
score = stu_score_dict["林俊节"]["英语"]
print(f"林俊节的英语分数是：{score}")
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

字典常用方法汇总

字典常用方法演示

my_dict = {"周杰轮": 99, "林俊节": 88, "张学油": 77}
# 新增元素
my_dict["张信哲"] = 66
print(f"字典经过新增元素后，结果：{my_dict}")
#结果：字典经过新增元素后，结果：{'周杰轮': 99, '林俊节': 88, '张学油': 77, '张信哲': 66}

# 更新元素
my_dict["周杰轮"] = 33
print(f"字典经过更新后，结果：{my_dict}")
#结果：字典经过更新后，结果：{'周杰轮': 33, '林俊节': 88, '张学油': 77, '张信哲': 66}

# 删除元素
score = my_dict.pop("周杰轮")
print(f"字典中被移除了一个元素，结果：{my_dict}, 周杰轮的考试分数是：{score}")
#结果：字典中被移除了一个元素，结果：{'林俊节': 88, '张学油': 77, '张信哲': 66}, 周杰轮的考试分数是：33

# 清空元素, clear
my_dict.clear()
print(f"字典被清空了，内容是：{my_dict}")
#结果：字典被清空了，内容是：{}

# 获取全部的key
my_dict = {"周杰轮": 99, "林俊节": 88, "张学油": 77}
keys = my_dict.keys()
print(f"字典的全部keys是：{keys}")
#结果：字典的全部keys是：dict_keys(['周杰轮', '林俊节', '张学油'])

# 统计字典内的元素数量, len()函数
num = len(my_dict)
print(f"字典中的元素数量有：{num}个")
#结果：字典中的元素数量有：3个
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

遍历字典

# 方式1：通过获取到全部的key来完成遍历
for key in keys:
    print(f"字典的key是:{key}")
    print(f"字典的value是：{my_dict[key]}")

# 方式2：直接对字典进行for循环，每一次循环都是直接得到key
for key in my_dict:
    print(f"2字典的key是:{key}")
    print(f"2字典的value是：{my_dict[key]}")
1
2
3
4
5
6
7
8
9

数据容器的通用功能

my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = "abcdefg"
my_set = {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}

# len元素个数
print(f"列表 元素个数有：{len(my_list)}")
print(f"元组 元素个数有：{len(my_tuple)}")
print(f"字符串元素个数有：{len(my_str)}")
print(f"集合 元素个数有：{len(my_set)}")
print(f"字典 元素个数有：{len(my_dict)}")

# max最大元素
print(f"列表 最大的元素是：{max(my_list)}")
print(f"元组 最大的元素是：{max(my_tuple)}")
print(f"字符串最大的元素是：{max(my_str)}")
print(f"集合 最大的元素是：{max(my_set)}")
print(f"字典 最大的元素是：{max(my_dict)}")

# min最小元素
print(f"列表 最小的元素是：{min(my_list)}")
print(f"元组 最小的元素是：{min(my_tuple)}")
print(f"字符串最小的元素是：{min(my_str)}")
print(f"集合 最小的元素是：{min(my_set)}")
print(f"字典 最小的元素是：{min(my_dict)}")

# 类型转换: 容器转列表
print(f"列表转列表的结果是：{list(my_list)}")
print(f"元组转列表的结果是：{list(my_tuple)}")
print(f"字符串转列表结果是：{list(my_str)}")
print(f"集合转列表的结果是：{list(my_set)}")
print(f"字典转列表的结果是：{list(my_dict)}")

# 类型转换: 容器转元组
print(f"列表转元组的结果是：{tuple(my_list)}")
print(f"元组转元组的结果是：{tuple(my_tuple)}")
print(f"字符串转元组结果是：{tuple(my_str)}")
print(f"集合转元组的结果是：{tuple(my_set)}")
print(f"字典转元组的结果是：{tuple(my_dict)}")

# 类型转换: 容器转字符串
print(f"列表转字符串的结果是：{str(my_list)}")
print(f"元组转字符串的结果是：{str(my_tuple)}")
print(f"字符串转字符串结果是：{str(my_str)}")
print(f"集合转字符串的结果是：{str(my_set)}")
print(f"字典转字符串的结果是：{str(my_dict)}")

# 类型转换: 容器转集合
print(f"列表转集合的结果是：{set(my_list)}")
print(f"元组转集合的结果是：{set(my_tuple)}")
print(f"字符串转集合结果是：{set(my_str)}")
print(f"集合转集合的结果是：{set(my_set)}")
print(f"字典转集合的结果是：{set(my_dict)}")

# 进行容器的排序 sorted
my_list = [3, 1, 2, 5, 4]
my_tuple = (3, 1, 2, 5, 4)
my_str = "bdcefga"
my_set = {3, 1, 2, 5, 4}
my_dict = {"key3": 1, "key1": 2, "key2": 3, "key5": 4, "key4": 5}

print(f"列表对象的排序结果：{sorted(my_list)}")
print(f"元组对象的排序结果：{sorted(my_tuple)}")
print(f"字符串对象的排序结果：{sorted(my_str)}")
print(f"集合对象的排序结果：{sorted(my_set)}")
print(f"字典对象的排序结果：{sorted(my_dict)}")

print(f"列表对象的反向排序结果：{sorted(my_list, reverse=True)}")
print(f"元组对象的反向排序结果：{sorted(my_tuple, reverse=True)}")
print(f"字符串对象反向的排序结果：{sorted(my_str, reverse=True)}")
print(f"集合对象的反向排序结果：{sorted(my_set, reverse=True)}")
print(f"字典对象的反向排序结果：{sorted(my_dict, reverse=True)}")
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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

字符串大小比较

# abc 比较 abd
print(f"abd大于abc，结果：{'abd' > 'abc'}")
# a 比较 ab
print(f"ab大于a，结果：{'ab' > 'a'}")
# a 比较 A
print(f"a 大于 A，结果：{'a' > 'A'}")
# key1 比较 key2
print(f"key2 > key1，结果：{'key2' > 'key1'}")
1
2
3
4
5
6
7
8

文件操作功能汇总

打开文件中 mode参数 常用三种访问形式

文件打开 open

# 打开文件
import time

f = open("D:/测试.txt", "r", encoding="UTF-8")
print(type(f))
# 读取文件 - read()
# print(f"读取10个字节的结果：{f.read(10)}")
# print(f"read方法读取全部内容的结果是：{f.read()}")
print("-----------------------------------------------")
# 读取文件 - readLines()
# lines = f.readlines()   # 读取文件的全部行，封装到列表中
# print(f"lines对象的类型：{type(lines)}")
# print(f"lines对象的内容是：{lines}")

# 读取文件 - readline()
# line1 = f.readline()
# line2 = f.readline()
# line3 = f.readline()
# print(f"第一行数据是：{line1}")
# print(f"第二行数据是：{line2}")
# print(f"第三行数据是：{line3}")

# for循环读取文件行
# for line in f:
#     print(f"每一行数据是:{line}")
# # 文件的关闭
# f.close()
# time.sleep(500000)
# with open 语法操作文件
with open("D:/测试.txt", "r", encoding="UTF-8") as f:
    for line in f:
        print(f"每一行数据是：{line}")

time.sleep(500000)
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

文件写入 write

# 打开文件，不存在的文件, r, w, a
import time

# f = open("D:/test.txt", "w", encoding="UTF-8")
# # write写入
# f.write("Hello World!!!")       # 内容写入到内存中
# # flush刷新
# # f.flush()                       # 将内存中积攒的内容，写入到硬盘的文件中
# # close关闭
# f.close()                       # close方法，内置了flush的功能的
# 打开一个存在的文件
f = open("D:/test.txt", "w", encoding="UTF-8")
# write写入、flush刷新
f.write("python")
# close关闭
f.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

文件的追加写入

# 打开文件，不存在的文件
# f = open("D:/test.txt", "a", encoding="UTF-8")
# # write写入
# f.write("python")
# # flush刷新
# f.flush()
# # close关闭
# f.close()
# 打开一个存在的文件
f = open("D:/test.txt", "a", encoding="UTF-8")
# write写入、flush刷新
f.write("\n月薪过万")
# close关闭
f.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14

捕获异常 语法 try excepet finally

# 捕获所有异常
try:
    f = open("D:/123.txt", "r", encoding="UTF-8")
except Exception as e:
    print("出现异常了")
    f = open("D:/123.txt", "w", encoding="UTF-8")
else:
    print("好高兴，没有异常。")
finally:
    print("我是finally，有没有异常我都要执行")
    f.close()
1
2
3
4
5
6
7
8
9
10
11