提交代码，笔记

.gitignore

@@ -0,0 +1,10 @@
+# 忽略所有 MP4 文件
+*.mp4
+
+# 忽略特定目录下的 MP4 文件
+videos/*.mp4
+media/*.mp4
+
+# 忽略特定名称的 MP4 文件
+video.mp4
+movie.mp4

day01/code/01-认识编辑器.py

@@ -0,0 +1,7 @@
+print('hello world')
+print(1+2+3)
+
+# 下载安装设置好vscode 启动vscode
+# 下载插件
+# 新建第一个py文件 .py
+

day01/code/02-第一个py文件.py

@@ -0,0 +1,4 @@
+# print函数 输出的意思
+print('你好 世界')
+print(10*10)
+

day01/code/03-print函数的介绍.py

@@ -0,0 +1,22 @@
+# 警号是注释的含义 编辑器不会执行 只给开发者阅读的
+# print函数是用于输出内容到终端的函数
+# 默认情况下 print函数输出的内容会自动换行
+print(1)
+print(2)
+print(3)
+
+# print函数的end参数 可以实现灵活的输出控制 满足不同场景下的特殊需求
+# end的值就是输出函数的内容的链接符号 自由设定
+print(1,end='---')
+print(2,end='---')
+print(3,end='---')
+print(4,end='---')
+print(5,end=',')
+print(6,end=',')
+print(7,end=',')
+print(8,end=',')
+
+# 需求 将下面的'你好世界'在一行输出 中间用逗号隔开
+print('你好',end=',')
+print('世界')
+

day01/code/04-字面量和常量.py

@@ -0,0 +1,14 @@
+# 字面量 是一个固定的值 它在程序中可以直接使用
+# 数字字面量 3.14
+# 字符串字面量 'hello'
+
+# 常量 变量 都是可以存值
+# 常量 给特定的值存一个名字 约定这个名字是大写 同时不要修改值
+PI=3.14
+print(PI)
+
+# 变量 给特定的值存一个名字 值是可以修改的
+name='zhangsan'
+name='张三'
+print(name)
+ 

day01/code/05-注释.py

@@ -0,0 +1,17 @@
+# 注释 对代码进行解释说明 程序员自己看的
+# 推荐使用中文
+COUNT=100 # 这里是一个常量
+print(COUNT)
+
+# 单行注释 以#开头的文字说明
+# 多行注释 以一对三个引号引起来的文字说明
+"""
+a变量的值是1
+b变量的值是2
+c变量的值是3
+"""
+a=1
+b=2
+c=3
+print(a,b,c)
+

day01/code/06-常用的值类型.py

@@ -0,0 +1,40 @@
+# 一.常用的值类型(介绍6种) - 必须记住
+# 1.数字(number)
+# 整数int：100，200，1，-1
+# 浮点数float：数学当中的小数，比如：3.14，1.678，0.678
+# 复数comflex: 以j结尾，4j, 123j    例如：4 + 3j   4表示复数的实部，3表示虚部   了解
+# 布尔bool：布尔值只有两个值(真和假),True表示真，False表示假
+
+# 2.字符串(string)
+# 字符串必须包裹在引号中，单引号和双引号都可以
+# 引号里面可以放中文，数字，字母，一些特殊符号，但都是字符串
+# str = 'hello'
+# str_name = "张三"
+# str_num = '100'  # 注意：这里的100不是数字，是字符串
+
+# print(张三)  # 这里会报错，没有添加引号
+# print('张三') # 张三
+
+# 3.了解其他的四种
+# 列表：其实就是其他语言中的数组，里面可以存放一堆数据，中括号包裹
+list = ['zhangsan','lisi','wangwu','赵六','李雷']
+print(list)
+
+# 元组：存放多个值，圆括号包裹
+t = ('zhangsan','lisi','wangwu','赵六','李雷')
+print(t)
+
+# 集合：存放多个值，大括号包裹
+s = {'zhangsan','lisi','wangwu','赵六','李雷','zhangsan','zhangsan','zhangsan'}
+print(s)
+
+# 字典：存放多个值，大括号包裹，每一组有两个值组成(键:值)
+dict = {'name':'zhangsan','age':18,'sex':'男'}
+print(dict)
+
+
+# 需求
+# 1.必须记住这六个类型的中文名称(数字，字符串，列表，元组，集合，字典)
+# 2.数字number   字符串string
+# 3.数字包括整数(int)，小数(float)，复数，布尔(bool),记住后面的单词
+# 4.掌握数字和字符串的声明定义和输出

day02/code/01-字符串的操作.py

@@ -0,0 +1,42 @@
+# 1.x+y链接两个字符串 
+# 1-1.两个变量的拼接
+s1='我的名字是'
+s2='佳佳'
+print(s1+s2)
+
+# 1-2.字符串和变量的拼接
+name='张三'  
+print('我的名字是'+name)
+
+# 2.x*n 将字符串x复制n次
+str='我要成功'
+print(str*5)
+
+# 3.x in s(x not in s) 判断x是否是s的字符串 返回布尔值
+# in操作符 判断存在
+str='my name is zhangsan'
+print('y' in str)
+print('yy' in str)
+print('name' in str)
+
+# not in操作符 判断不存在
+str='zhangsan'
+print('san' not in str)
+print('lisi' not in str)
+
+# 4.str[i]索引 返回第i个字符
+# 一个字符串里面的字符都对应一个整数数字编号 编号从0开始 依次累加
+# 可以通过中括号+编号进行取值
+# 编号可以被称为索引或下标
+str='你好世界'
+print(str)
+print(str[0])
+print(str[1])
+print(str[2])
+print(str[3])
+# print(str[4]) #报错
+
+# 例子 
+str='我们是共产主义接班人'
+print(str[0]+str[2]+str[9]) # 我是人
+print(str[0]+str[2]+str[-1]) #负数从后往前数 -1开始 -1就是最后一个字符

day02/code/02-输入函数input.py

@@ -0,0 +1,30 @@
+# 输出函数print() 可以完成将内容(字面量、变量等)输出
+print('你好世界')
+# 输入函数input() 可以从键盘获取输入 并填写提示文字
+input('请输入你的名字')
+
+# 使用一个变量接收input语句获取的键盘数据
+name=input('请输入你的名字')
+print('你输入的内容是'+name)
+
+# 例如 请输入两个数字 将两个数字的结果输出
+# input输入的内容是字符串格式
+n1=input('请输入第一个数字')
+n2=input('请输入第二个数字')
+print(n1+n2)
+
+# 利用int函数进行转换
+n1=int(input('请输入第一个数字'))
+n2=int(input('请输入第二个数字'))
+print(n1+n2)
+
+# 换一种写法
+n1=input('请输入第一个数字')
+n2=input('请输入第二个数字')
+print(int(n1)+int(n2))
+
+
+
+
+
+

day02/code/03-数据类型的检测.py

@@ -0,0 +1,21 @@
+# 获取值的数据类型
+# type()函数 用于获取一个值的数据类型
+n1=input('请输入一个数字')
+print(type(n1))
+
+# 数据类型的转换
+# int(x) 将x转为一个整数
+print(type(int(n1)))
+
+# 例如 请输入两个数字 将两个数字的结果输出
+n1=input('请输入第一个数字')
+n2=input('请输入第二个数字')
+n1=int(n1)
+n2=int(n2)
+print(n1+n2)
+print(n1-n2)
+print(n1*n2)
+print(n1/n2)
+
+
+

day02/code/04-作业.py

@@ -0,0 +1,72 @@
+# 1. 变量和数据类型基础
+# 在Python中，变量不需要声明类型，类型是根据赋给它的值自动推导的。以下是几种常见的数据类型：
+# 整数（int）
+# 浮动小数（float）
+# 字符串（str）
+# 布尔值（bool）
+# 练习 1: 定义不同类型的变量
+# 定义一个整数变量
+x = 10
+
+# 定义一个浮动小数变量
+y = 3.14
+
+# 定义一个字符串变量
+name = "Alice"
+
+# 定义一个布尔值变量
+is_active = True
+
+# 2. 类型转换
+# 你可以使用Python内置的int()，float()，str()等函数进行类型转换。
+# 练习 2: 类型转换
+# 将一个浮动小数转换成整数
+x = 3.7
+x_int = int(x)  # 转换为整数
+
+# 将一个整数转换成浮动小数
+y = 5
+y_float = float(y)  # 转换为浮动小数
+
+# 将一个整数转换成字符串
+z = 100
+z_str = str(z)  # 转换为字符串
+
+# 3. 操作符
+# 你可以使用算术操作符（如+，-，*，/）进行数字运算，使用字符串连接操作符（+）拼接字符串。
+# 练习 3: 使用操作符
+# 数字运算
+a = 10
+b = 5
+result_add = a + b  # 加法
+result_divide = a / b  # 除法
+
+# 字符串操作
+greeting = "Hello"
+name = "Bob"
+message = greeting + ", " + name  # 字符串拼接
+
+# 4. 输入与输出
+# 你可以使用input()函数获取用户输入，并使用print()输出结果。
+# 练习 4: 用户输入和输出
+# 获取用户输入
+name = input("请输入你的名字: ")
+age = input("请输入你的年龄: ")
+
+# 输出结果
+print(f"你好，{name}！你今年{age}岁。")
+
+# 5. 常见的内置数据类型
+# Python还有很多其他数据类型，如列表、元组、字典等。你可以进行一些练习来熟悉它们的使用。
+# 练习 5: 使用列表
+# 创建一个列表
+fruits = ["apple", "banana", "cherry"]
+
+# 添加元素
+fruits.append("orange")
+
+# 访问列表元素
+first_fruit = fruits[0]
+
+# 获取列表的长度
+num_fruits = len(fruits)

day03/01-转换数据类型的函数.py

@@ -0,0 +1,28 @@
+# 一、int(x) 将x转为一个整数
+print(int('100'))
+print(type(int('100')))
+
+# print(int('hello')) #报错
+
+# 重点1 布尔值转数字
+print(int(True))
+print(type(int(True)))
+
+# 重点2 浮点型转数字
+print(int(3.14))
+print(type(int(3.14)))
+
+# 二、float(x) 将x转为一个浮点数
+print(float(100))
+print(type(float(100)))
+
+# 三、str(x) 将x转为字符串
+print(str(True))
+print(type(str(True)))
+
+print(str(100))
+print(type(str(100)))
+print(15764-16000)
+
+
+

day03/02-算术运算符.py

@@ -0,0 +1,46 @@
+# 算术(数学)运算符
+# 1.+
+# print(1 + 2) # 3
+# print(1 + 2 + 3) # 6
+# 注意字符串,拼接
+# print('hello' + 'world') # helloworld
+
+# 2.-
+# 数字相减
+# print(7 - 9) # -2
+# print('zhang' - 'li') # 报错
+
+# 3.*
+# print(2 * 3) # 6
+# 数字相乘
+# print('zhang' * 'li') # 报错
+
+# 4./
+# print(8/3)  # 2.6666666666666665
+# 数字相除
+# print(8/0) # 报错，除数不能为0
+
+# 5.// 取整除，商的整数部分，数字参与运算
+# print(9 // 2)  # 4
+# print(9 // 3)  # 3
+
+# 6.% 取余数，求模
+# print(9 % 2) # 1
+# print(10 % 2) # 0
+# 余数的意义：求奇数偶数，求是否可以整除......
+
+# 7.**  求幂(指数)
+# print(2 ** 3)  # 2的3次方，2是底数，3是指数  结果:8
+# print(12 ** 2) # 144
+
+
+# 特殊情况
+# 两个布尔值的运算，True=1  False=0
+print(True + True)  # 1 + 1 = 2
+print(True - True)  # 1 - 1 = 0
+print(True * True)  # 1 * 1 = 1
+print(True / True)  # 1 / 1 = 1.0
+print(True // True) # 1 // 1 = 1
+print(True % True)  # 1 % 1 = 0
+print(True ** True) # 1 ** 1 = 1
+print(True + False) # 1 + 0 = 1

day03/03-赋值运算符.py

@@ -0,0 +1,19 @@
+# 赋值运算符 --> =
+# 注意：
+# 和数学当中的等号写法和读都一样，但是意义不一样
+# 右 --> 左 需要先计算右边，再赋值给左边
+
+
+# 例如1：
+a = 100  # 含义：将右边100这个数字赋值给左边的变量a
+
+# 例如2：
+a = 1  # 将右边1这个数字赋值给左边的变量a
+a = a + 2 # 将右边的a的值加上2，再次赋值给左边的a   相当于：a = 1 + 2
+print(a) # 3
+
+
+# 例如3：
+num = 10
+num = num + num + num + 100 # num = 10 + 10 + 10 + 100
+print(num) # 130

day03/04-复合赋值运算符.py

@@ -0,0 +1,36 @@
+# 复合的赋值运算符：+= -= *= /= //= %= **=
+# 提升性能，优化代码
+
+# 例子
+a = 1
+a += 1 # a = a + 1
+print(a) # 2
+
+# b = 10
+# b -= 3 # b = b - 3
+# print(b) # 7
+
+# c = 5
+# c *= 100 # c = c * 100
+# print(c) # 500
+
+# d = 100
+# d /= 10 # d = d / 10
+# print(d) # 10.0
+
+# e = 9
+# e %= 2 # e = e % 2
+# print(e) # 1
+
+
+
+
+# 例子：
+a = 1
+b = 2
+c = 3
+a += b # a = a + b  ==>  a = 1 + 2 = 3
+a -= c # a = a - c  ==>  a = 3 - 3 = 0
+b += c # b = b + c ==> b = 2 + 3 = 5
+c += b # c = c + b ==> c = 3 + 5 = 8
+print(a,b,c) # 输出三个数字0，5，8

day03/05-内置的数字运算函数.py

@@ -0,0 +1,28 @@
+# 内置函数：python语言设定好，具有特定的功能
+# 一.前面学过的内置函数
+# 1.print函数：打印
+# 2.input函数：输入
+# 3.type函数：检测类型
+# 4.int/float/str ：类型转换
+
+# 二.内置的数值运算函数
+# 1.abs() 取括号里面数字的绝对值
+num=-100
+print(abs(num))
+
+# 2.divmod(整数商,余数)
+print(divmod(9,2)) #(4,1) 4是9和2的商的整数部分 1是9和2的余数
+
+# 3.pow(x,y,z) (x**y)%z 参数z可以忽略
+# 求幂
+print(2**3)
+print(pow(2,3))
+
+# 4.round(x,n)对x求四舍五入 保留n位小数
+print(round(3.6678))
+print(round(3.6678,3))
+
+# 5.max(x1,x2,x3...xn) 返回一个最大值
+# min(x1,x2,x3...xn) 返回一个最小值
+print(max(23,45,67,89))
+print(min(23,45,67,89))

day03/06-变量.py

@@ -0,0 +1,31 @@
+# 变量
+# 变量就像盒子，可以存放内容
+
+# 1.变量声明的格式
+# 变量的自定义名称 = 值
+# 在整个的python文档中，通过名称得到值
+
+# 2.变量的意义：
+# 解决重复值(多次使用)的问题
+# 变量的值是可以改变的
+# 约定：程序中使用的值，先声明变量再使用
+# a = 200 # 定义变量
+# a = 1 # 修改上面变量a的值
+# a = 10 # 修改变量的值
+# print(a + 1)
+# print(a + 2)
+# print(a + 3)
+# print(a + 4)
+# print(a + 5)
+
+# 3.变量声明的组成
+# 3.1.约定一个变量的名称(语义化)，存储对应的值
+name = 'zhangsan'
+age = 18
+sex = '男'
+
+# 3.2.中间的等号(赋值符号)
+grade = 'IT231'  # 将右边的结果赋值给左边
+
+# 3.3.变量的值，变量的值存在于6大数据类型中，通过变量名来访问变量对应的值
+print(name,age,sex,grade) # zhangsan 18 男 IT221

day04/01-作业.py

@@ -0,0 +1,21 @@
+# 一.为抵抗洪水，战士连续作战89小时，编程计算共多少天零多少小时？
+
+hours = 89 # 定义变量hours存储时间
+day = int(hours / 24) # int将括号里面的值转换成整数
+h = hours % 24  # 求不足一天的小时数
+# 打印结果：涉及到字符串和变量的拼接
+# 利用+号
+# 值必须是字符串才能使用+号进行拼接,使用str函数进行转换
+print('为抵抗洪水，战士连续作战89小时，编程计算共'+ str(day) +'天零' + str(h) +'小时')
+
+# 将上面的题目变得更加灵活
+# 为抵抗洪水，战士连续作战89小时，编程计算共多少天零多少小时？
+# 将89变成由用户来输入
+xiaoshi = int(input('请输入战士连续作战的小时数：')) # 注意这里输入的数字是字符串,利用转换函数进行字符串转数字
+day = int(xiaoshi / 24) # 天,必须是整数
+hour = xiaoshi % 24 # 取余获取不足一天的小时数
+print('为抵抗洪水，战士连续作战'+str(xiaoshi)+'小时，编程计算共'+str(day)+'天零'+str(hour)+'小时')
+
+
+
+

day04/02-作业.py

@@ -0,0 +1,13 @@
+# 编写一个程序，输入矩形的长和宽，输出矩形的面积和周长
+
+# 输入矩形的长和宽
+length = float(input("请输入矩形的长: "))
+width = float(input("请输入矩形的宽: "))
+
+# 计算面积和周长
+area = length * width
+perimeter = 2 * (length + width)
+
+# 输出结果
+print("矩形的面积为: ", area)
+print("矩形的周长为: ", perimeter)

day04/03-作业.py

@@ -0,0 +1,11 @@
+# 编写一个程序，输入一个数字，输出该数字的平方和立方
+# 输入数字
+num = float(input("请输入一个数字: "))
+
+# 计算平方和立方
+square = num ** 2
+cube = num ** 3
+
+# 输出结果
+print(f"{num} 的平方是 {square}")
+print(f"{num} 的立方是 {cube}")

day04/04-作业.py

@@ -0,0 +1,15 @@
+# 扩展class(类) - 非常重要
+# 1.类：
+# 表示一类事物(和生活中的类一致的)，是抽象(不具体)的，
+# 比如：人类，动物类，植物类
+
+# 2.对象：对象是类下面的具体事物，对象是真实存在的，一般对象都拥有属性和方法
+# 比如：刘德华，尼古拉斯赵四，华南虎
+
+# 3.属性：属性是用来描述对象的，属性是对象的特点，属性是私有的(不同)
+# 比如：刘德华的身高，体重，肤色...
+
+# 4.方法：方法是对象具有的功能，方法是对象公有的特点(相同)
+# 比如：刘德华会走，会跑，会吃饭...
+
+# 程序来源于生活，解决生活中一些复杂的问题

day04/05-变量的命名规则与标识符.py

@@ -0,0 +1,26 @@
+# 一.变量的命名和使用(合理的给变量取名称)
+# 变量名只能包含字母、数字和下划线，不能数字开头
+# 变量名不能包含空格，但能使用下划线来分隔其中的单词
+# 不要将 Python 关键字和函数名用作变量名。
+# 变量名应既简短又具有描述性。例如，name 比 n 好，student_name 比 s_n 好
+
+# 注意：
+# 关键字:Python里面已经使用了，具有特定的功能，比如：def if while for
+
+name = '张三'
+user_name = '尼古拉斯赵四'
+
+
+# 二.标识符
+# 标识符是编程时使用的自定义名字，用于给常量、变量、函数、方法、类等命名。
+
+# 三.标识符的规则
+# 标识符只能包含字母（A-Z，a-z）、数字（0-9）、中文(不推荐使用)和下划线（_）。
+# 标识符不能以数字开头。
+# 标识符区分大小写（如variable和Variable是不同的标识符）。
+# 标识符不能是Python的关键字或保留字。
+# 标识符具有语义化的特点(name,age,gender,user_name...)
+
+# 保留字：未来的关键字，将来会变成关键字
+
+# 标识符的规则就是变量的命名规则，因为变量属于标识符的一种

day04/06-字符串的扩展.py

@@ -0,0 +1,49 @@
+# 一.字符串的三种定义方式
+# 1.单引号
+str_one = 'hello'
+print(str_one)
+
+# 2.双引号
+str_two = "你好"
+print(str_two)
+
+# 3.三引号
+# 注意1：三引号定义法，和多行注释的写法一样，同样支持换行操作
+# 使用变量接收，就是字符串
+# 不使用变量接收，就是多行注释
+# """你好,世界"""
+# str_three = """你好,
+# 世
+# 界
+# """
+# print(str_three) # 同样支持换行操作
+
+# 二.字符串的引号嵌套规则是单引号可以内含双引号,反之一样
+# str = "what's your name"
+# print(str) # what's your name
+
+# str1 = '你好世界"欢迎"您'
+# print(str1) # 你好世界"欢迎"您
+
+# 三.字符串的拼接
+# 1.利用+号
+name = '张三'
+age = 18
+gender = '男'
+print('我的名字是' + name + ',我今年' + str(age) + '岁,我是' + gender + '的' )
+
+# 问题：上面的字符串拼接方式如果变量过多，拼接起来比较麻烦，同时无法和数字等其他类型进行拼接
+
+# 2.字符串格式化，利用%占位实现
+# 其中的%S
+# % 表示:我要占位
+# s 表示:%s将变量变成字符串放入占位的地方
+# d 表示:%d代表整数占位符，
+# f 表示:%f代表浮点数占位符(默认保留6位小数)
+# 所以，综合起来的意思就是:我先占个位置，等一会有个变量过来，我把它变成字符串放到占位的位置
+
+name = '张三'
+age = 18
+gender = '男'
+print('我的名字是%s,我今年%s岁,我是%s的' %(name,age,gender))
+# 注意多个变量占位,变量要用括号括起来,并按照占位的顺序填入

day04/08-作业.py

@@ -0,0 +1,7 @@
+# 编写代码，使用 input() 函数获取用户输入的名字和年龄，并输出欢迎信息。
+user_name = input('请输入你的名字：') # 接收用户输入的姓名
+user_age = input('请输入你的年龄：') # 接收用户输入的年龄
+print(f"欢迎姓名是{user_name}的同学,他今年{user_age}岁")
+print('欢迎姓名是%s的同学,他今年%s岁' %(user_name,user_age))
+print('欢迎姓名是' + user_name + '的同学,他今年' + user_age+'岁')
+

day04/09-作业.py

@@ -0,0 +1,27 @@
+# 一.在不考虑四舍五入的情况下对一个数字进行保留两位小数 origin = 123.456789 结果：123.45
+# origin = 123.456789
+# print(int(origin*100)) # 12345
+# print(int(origin*100)/100) # 123.45
+
+
+# print(0.1 + 0.2)
+# 0.30000000000000004  IEEE745标准
+# print((0.1*10 + 0.2*10)/10)
+# 0.3 将小数扩大一定的倍数变成整数，然后结果再缩小对应的倍数
+
+
+# 二.给定两个变量 a = 5,b = 8 思考：如何在不声明第三个变量的情况下 交换变量a和b的值
+# a = 5
+# b = 8
+# c = a # 利用第三个变量接收a
+# a = b # a得到了b的值
+# b = c # b得到了c的值，c的值就是a
+# print(a,b) # 8 5
+
+# 如果交换的变量值是数字，通过计算进行交换
+# a = 5
+# b = 8
+# a = a + b  # a = 13
+# b = a - b  # b = 13 - 8 = 5
+# a = a - b  # a = 13 - 5 = 8
+# print(a,b)

day04/10-作业.py

@@ -0,0 +1,10 @@
+# 编写一个程序，输入两个数，计算并输出它们的平均值。
+# 输入两个数字
+num1 = float(input("请输入第一个数字: "))
+num2 = float(input("请输入第二个数字: "))
+
+# 计算平均值
+average = (num1 + num2) / 2
+
+# 输出结果
+print(f"{num1} 和 {num2} 的平均值是: {average}")

day04/11-作业.py

@@ -0,0 +1,18 @@
+# 编写一个程序，输入两个数字 x 和 y，计算并输出它们的和、差、积、商、余数。
+# 输入两个数字
+x = float(input("请输入第一个数字 x: "))
+y = float(input("请输入第二个数字 y: "))
+
+# 计算并输出结果
+sum_result = x + y
+difference = x - y
+product = x * y
+quotient = x / y
+remainder = x % y
+
+# 输出结果
+print(f"{x} + {y} = {sum_result}")
+print(f"{x} - {y} = {difference}")
+print(f"{x} * {y} = {product}")
+print(f"{x} / {y} = {quotient}")
+print(f"{x} % {y} = {remainder}")

day04/12-作业.py

@@ -0,0 +1,10 @@
+# 编写一个程序，输入三角形的底和高，计算并输出其面积。
+# 输入底和高
+base = float(input("请输入三角形的底: "))
+height = float(input("请输入三角形的高: "))
+
+# 计算面积
+area = 0.5 * base * height
+
+# 输出结果
+print(f"三角形的面积是: {area}")

day04/13-字符串的扩展.py

@@ -0,0 +1,28 @@
+# 一.更优雅快速的字符串格式化写法：
+# 第一种字符串的写法：
+# name = '张三'
+# age = 18
+# gender = '男'
+# print('我的名字是' + name + ',我今年' + str(age) + '岁,我是' + gender + '的' )
+
+
+# 第二种字符串的写法：
+# name = '张三'
+# age = 18
+# gender = '男'
+# print('我的名字是%s,我今年%s岁,我是%s的' %(name,age,gender))
+
+# 第三种字符串的写法：使用最多的
+# 格式：f"内容{变量}" 的格式来快速格式化
+# 注意：上面的写法不关注类型和精度
+
+# name = '张三'
+# age = 18
+# gender = '男'
+# print(f'我的名字是{name},我今年{age}岁,我是{gender}的')
+# print(f"我的名字是{name},我今年{age}岁,我是{gender}的")
+
+# 对表达式进行格式化
+print("1 * 1的结果是:%d" %(1 * 1))
+print(f"1 * 2的结果是:{1 * 2}")
+print("字符串在Python中的类型名是:",type("字符串"))  # 逗号分隔打印多个值

day05/01-条件测试.py

@@ -0,0 +1,60 @@
+# 一、条件测试
+# 1、检查是否相等（==）
+n1=10
+n2=10
+n3=20
+# print(n1=n2) #报错 赋值关系
+print(n1==n2) #True
+print(n1==n3) #False
+
+# 2、如何在检查是否相等的时候忽略大写
+str1='hello'
+str2='Hello'
+print(str1==str2) #False
+print(str1==str2.lower()) #True
+
+# 3、检查是否不等（!=）
+n1=10
+n2=10
+n3=20
+print(n1!=n2) #False
+print(n1!=n3) #True
+
+# 4、使用and（或者&）检查多个条件同时满足 否则输出False
+n1=5
+n2=10
+n3=15
+n4=5
+print(n1==n2 and n3!=n4) #False
+print(n1==n4 and n1!=n2) #True
+
+# 5、使用or（或者|）检查多个条件 有一个满足则输出True
+n1=5
+n2=10
+n3=15
+n4=5
+print(n1!=n2 or n2==n3) #True
+print(n1==n2 or n2==n3) #False
+
+# 6、检查特定的值是否在列表中（in）
+str='hello'
+print('e' in str)
+print('he' in str)
+print('ho' in str) #False 连续的字符
+
+# 7、检查特定的值是否不在列表中（not in）
+str='hello'
+print('hehe' not in str)
+print('he' not in str)
+
+# 8、布尔表达式 True / False
+
+# 9、总结
+"""
+总结：
+== 相当于数学中的等号， = 赋值符号    != 不等号
+and(和) 多条件同时每个条件都要满足True,结果才满足True
+or(或)  多条件有一个条件满足True,结果满足True
+in(包含某个字符和子串)
+not in(不包含某个字符和子串)
+"""

day05/02-比较运算符.py

@@ -0,0 +1,21 @@
+# 比较运算符
+# == 等于
+# != 不等于
+# > 大于
+# < 小于
+# >= 大于或等于(小于也满足,等于也满足)
+# <= 小于或等于
+
+n1 = 1
+n2 = 3
+n3 = 5
+n4 = 1
+print(n1 == n4) # True
+print(n1 != n2) # True
+
+print(n1 >= n4) # True
+print(n1 <= n4) # True
+
+print(n1 > n3) # False
+print(n1 < n3) # True
+

day05/03-程序的三大结构.py

@@ -0,0 +1,13 @@
+# 程序的三大结构
+# 1.顺序结构：程序从上往下执行，遇到错误终止
+print(1)
+print(2)
+print(a)  # 报错，因为a不存在，一旦报错，整个程序就结束了
+print('你好世界')
+
+# 2.选择结构
+# 程序在执行过程中，遇到了分支(人生走到岔路口，面临选择)
+# 选择分为：单选择(单分支)、双选择(双分支)、多选择(多分支)
+
+# 3.循环结构
+# 重复 + 有规律 + 迭代

day05/04-if语句.py

@@ -0,0 +1,36 @@
+# if语句
+# 单分支 仅仅考虑True的情况
+"""
+if 要判断的条件:
+  条件成立时,要做的事情1
+  条件成立时,要做的事情2
+  条件成立时,要做的事情3
+"""
+# 案例 判断当前的数字是否是正数
+n1 = -10
+print('if语句开始')
+if n1>0:
+  print('这个是正数')
+  print('这个是一个正数')
+print('if语句结束')
+
+
+# 双分支 需要考虑True和False的情况
+"""
+if 要判断的条件:
+  条件成立时,要做的事情1
+  条件成立时,要做的事情2
+  条件成立时,要做的事情3
+else:
+  条件不成立时,要做的事情1
+  条件不成立时,要做的事情2
+  条件不成立时,要做的事情3
+"""
+# 案例 判断是否成年
+age = 10
+if age>=18:
+  print('成年了')
+  print('可以去网吧了')
+else:
+  print('没有成年')
+  print('回家看动画片')

day05/05-作业.py

@@ -0,0 +1,17 @@
+# 用户输入一个年份，判断该年份是否为闰年
+# 闰年的条件：
+# 输入4位数的年份，如果年份能被4整除且(and)不能被100整除，或(or)者能被400整除
+
+# 条件
+# 能被4整除：year % 4 == 0 当前的年份和4取余数等于0,表示能够整除
+# 不能被100整除：year % 100 != 0  表示不能整除
+# 能被400整除 year % 400 == 0
+
+year = int(input('请输入一个4位的年份:'))  # 接收用户输入一个年份(转整数)
+if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:  # 闰年的条件
+    print(f"你输入的年份是{year},它是闰年") # 满足条件
+else:
+    print(f"你输入的年份{year},它是平年") # 不满足条件
+    
+    
+    

day05/06-作业.py

@@ -0,0 +1,62 @@
+# 1.用户输入一个数字，如果数字小于10，补0，如果数字大于10，不需要补
+# 理由：如果涉及到时间 12:13:04  09:05:07
+"""
+num = int(input('请输入一个数字:')) # 使用变量接收数据,转换成整数
+if num < 10:
+    # print('0' + str(num)) # 方式1.这里的num将其转换成字符串才可以进行拼接
+    print(f"0{num}") # 方式2
+    # print('0%s' %num) # 方式3
+else:
+    print(num) # 走到这里说明数字大于或等于10，直接输出
+"""
+
+# 2.用户输入一个整数，判断该整数是奇数还是偶数，并输出结果
+# 问题：如何判断偶数和奇数
+# 一个数如果和2取余等于0,是偶数
+# 一个数如果和2取余不等于0,是奇数
+"""
+num = int(input('请输入一个整数：')) # 将输入的字符串整数转换成整数
+if num % 2 == 0:
+    print(f"你输入的{num}是偶数")
+else:
+    print(f'你输入的{num}是奇数')
+"""
+
+# 3.用户输入一个字符，判断该字符是字母还是数字
+# 思路：
+# 字母：a-z  A-Z  
+# 数字：0-9
+
+# 数字
+# print(2 <= 8 <= 9) # True
+# print(2 <= 18 <=9) # False
+
+# 大小写字母
+# print('a'<='f'<='z') # True  任意一个小写字母都属于这个范围
+# print('a'<='e'<='z') # True
+# print('a'<='A'<='z') # False
+# print('A'<='D'<='E') # True  D在A至E之间
+"""
+char = input('请输入一个字符：')
+if 'a'<=char<='z' or 'A'<=char<='Z':  # 这里的条件用来检测小写字母 + 大写字母
+    print(f'你输入的是字母{char}')
+else: # 在没有多分支的情况下，默认其他的字符当做数字
+    print(f'你输入的是数字{char}') # 有问题的，需要多分支，没有考虑特殊的一些符号
+"""
+
+# 4.输入一个三位数字判断是否是水仙花数
+# 水仙花数条件：当一个数字，每一位数字的立方和刚好等于这个数字
+# 三位数：153、370、371、407
+# print(1**3 + 5**3 + 3**3) # 153
+"""
+num = int(input('请输入一个三位的数字：')) # 转整数
+# 求三位数的每一位
+a = num % 10 # 个位
+b = num % 100 // 10 # 十位
+c = num // 100 # 百位
+# 写if语句
+if a**3 + b**3 + c**3 == num :
+    print(f'你输入的三位数{num}是水仙花数')
+else:
+    print(f'你输入的三位数{num}不是水仙花数')
+"""

day05/07-作业.py

@@ -0,0 +1,37 @@
+# 1. 判断一个数是正数、负数还是零
+num = int(input("请输入一个整数: "))
+
+if num > 0:
+    print("这个数是正数")
+elif num < 0:
+    print("这个数是负数")
+else:
+    print("这个数是零")
+
+
+# 2. 判断一个数是奇数还是偶数
+num = int(input("请输入一个整数: "))
+
+if num % 2 == 0:
+    print("这个数是偶数")
+else:
+    print("这个数是奇数")
+
+
+# 3. 检查用户输入的密码是否正确
+correct_password = "python123"
+password = input("请输入密码: ")
+
+if password == correct_password:
+    print("密码正确，欢迎进入系统！")
+else:
+    print("密码错误，请重试。")
+
+
+# 4. 判断一个年份是否是闰年
+year = int(input("请输入一个年份: "))
+
+if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
+    print(f"{year} 是闰年")
+else:
+    print(f"{year} 不是闰年")

day06/01-elif应用.py

@@ -0,0 +1,56 @@
+# 单分支 if
+# 双分支 if else
+
+# 多分支 elif 判断子句
+# 基本结构
+"""
+if 条件1:
+  满足条件时要做的事情1
+  ...
+elif 条件2:
+  满足条件时要做的事情2
+  ...
+elif 条件3:
+  满足条件时要做的事情3
+  ...
+else:
+  不满足条件时要做的事情
+"""
+
+# 案例 要判断一个数字是大于0 小于0 等于0
+num = int(input('请输入一个数字'))
+if num>0:
+  print(f'你输入的数字{num}是一个大于0的数字')
+elif num<0:
+  print(f'你输入的数字{num}是一个小于0的数字')
+else:
+  print(f'你输入的数字{num}是一个等于0的数字')
+
+
+# 作业 用户输入一个成绩(0-100) 判断成绩的评级(A,B,C,D,E)
+# 自由定义评级的等级
+# >=90 A
+# >=80 B
+# >=70 C
+# >=60 D
+# 其他分数 E
+score = int(input("请输入分数："))
+
+if 90 <= score <= 100:
+    print("你的成绩等级是 A")
+elif 80 <= score < 90:
+    print("你的成绩等级是 B")
+elif 70 <= score < 80:
+    print("你的成绩等级是 C")
+elif 60 <= score < 70:
+    print("你的成绩等级是 D")
+elif 0 <= score < 60:
+    print("你的成绩等级是 F")
+else:
+    print("分数输入错误，请输入 0-100 之间的整数")
+
+
+
+
+
+

day06/02-练习.py

@@ -0,0 +1,154 @@
+# 1. 判断奇偶
+num = int(input("请输入一个整数："))
+if num % 2 == 0:
+    print(f"{num} 是偶数")
+else:
+    print(f"{num} 是奇数")
+
+
+# 2. 判断正数、负数还是零
+num = float(input("请输入一个数："))
+if num > 0:
+    print(f"{num} 是正数")
+elif num < 0:
+    print(f"{num} 是负数")
+else:
+    print("输入的数是 0")
+
+
+# 3. 计算绝对值
+num = int(input("请输入一个整数："))
+if num < 0:
+    num = -num
+print(f"绝对值是 {num}")
+
+
+# 4. 比较两个数的大小
+a = int(input("请输入第一个整数："))
+b = int(input("请输入第二个整数："))
+
+if a > b:
+    print(f"较大的数是 {a}")
+elif a < b:
+    print(f"较大的数是 {b}")
+else:
+    print("两个数相等")
+
+
+# 5. 判断是否能被 3 和 5 同时整除
+num = int(input("请输入一个整数："))
+if num % 3 == 0 and num % 5 == 0:
+    print(f"{num} 可以被 3 和 5 同时整除")
+else:
+    print(f"{num} 不能被 3 和 5 同时整除")
+
+# 6. 成绩评级
+score = int(input("请输入分数："))
+
+if 90 <= score <= 100:
+    print("你的成绩等级是 A")
+elif 80 <= score < 90:
+    print("你的成绩等级是 B")
+elif 70 <= score < 80:
+    print("你的成绩等级是 C")
+elif 60 <= score < 70:
+    print("你的成绩等级是 D")
+elif 0 <= score < 60:
+    print("你的成绩等级是 F")
+else:
+    print("分数输入错误，请输入 0-100 之间的整数")
+
+
+# 7. 判断闰年
+year = int(input("请输入年份："))
+if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
+    print(f"{year} 是闰年")
+else:
+    print(f"{year} 不是闰年")
+
+
+# 8. 简单计算器
+num1 = float(input("请输入第一个数："))
+operator = input("请输入运算符（+、-、*、/）：")
+num2 = float(input("请输入第二个数："))
+
+if operator == "+":
+    print(f"结果是 {num1 + num2}")
+elif operator == "-":
+    print(f"结果是 {num1 - num2}")
+elif operator == "*":
+    print(f"结果是 {num1 * num2}")
+elif operator == "/":
+    if num2 == 0:
+        print("除数不能为 0！")
+    else:
+        print(f"结果是 {num1 / num2}")
+else:
+    print("无效的运算符")
+
+
+# 9. 判断三角形类型
+a, b, c = map(int, input("请输入三条边长（用空格分隔）：").split())
+
+if a + b > c and a + c > b and b + c > a:
+    if a == b == c:
+        print("等边三角形")
+    elif a == b or b == c or a == c:
+        print("等腰三角形")
+    elif a ** 2 + b ** 2 == c ** 2 or a ** 2 + c ** 2 == b ** 2 or b ** 2 + c ** 2 == a ** 2:
+        print("直角三角形")
+    else:
+        print("普通三角形")
+else:
+    print("无法构成三角形")
+
+
+# 10. 字母大小写转换
+char = input("请输入一个字母：")
+
+if 'a' <= char <= 'z':
+    print(f"转换后的字母是 {char.upper()}")
+elif 'A' <= char <= 'Z':
+    print(f"转换后的字母是 {char.lower()}")
+else:
+    print("输入的不是字母")
+
+
+# 11. 生肖计算
+zodiac = ["猴", "鸡", "狗", "猪", "鼠", "牛", "虎", "兔", "龙", "蛇", "马", "羊"]
+year = int(input("请输入年份："))
+print(f"{year} 属 {zodiac[year % 12]}")
+
+
+# 12. ATM 取款机
+balance = 5000
+amount = int(input("请输入取款金额："))
+
+if amount % 100 != 0:
+    print("取款金额必须是 100 的倍数！")
+elif amount > balance:
+    print("余额不足！")
+else:
+    balance -= amount
+    print(f"取款成功！剩余余额：{balance} 元")
+
+
+# 13. 简单彩票系统
+import random
+
+lottery = random.randint(0, 99)  # 随机生成两位数
+guess = int(input("请输入你的彩票号码（0-99）："))
+
+lottery_digits = [lottery // 10, lottery % 10]
+guess_digits = [guess // 10, guess % 10]
+
+print(f"中奖号码是 {lottery}")
+
+if guess == lottery:
+    print("恭喜！你中了 10000 元！")
+elif sorted(guess_digits) == sorted(lottery_digits):
+    print("恭喜！你中了 3000 元！")
+elif guess_digits[0] in lottery_digits or guess_digits[1] in lottery_digits:
+    print("恭喜！你中了 1000 元！")
+else:
+    print("很遗憾，没有中奖！")

day07/01-if语句的梳理.py

@@ -0,0 +1,21 @@
+# if语句 单分支
+num = -10
+if num > 0:
+  print('num是正数')
+  
+# if else语句 双分支
+age = int(input('请输入你的年龄'))
+if age>=18:
+  print('成年人')
+else:
+  print('没有成年')
+
+# elif语句 多分支
+num = int(input('请输入一个数字'))
+if num>0:
+  print('正数')
+elif num<0:
+  print('负数')
+else:
+  print('等于0')
+  

day07/02-if语句大练习.py

@@ -0,0 +1,46 @@
+# 1.用户输入用户名:zhangsan、密码:123456，则提示登入成功，否则提示失败
+# 过程
+# 当我们通过表单输入用户名和密码，点击提交或者登录
+# 用户名和密码传递给后端(服务器端)
+# 服务器端拿到用户名和密码
+# 将用户名和密码和你注册时的用户名和密码进行匹配
+
+
+# 双分支实现
+# user_name = input('请输入用户名：')
+# user_password = input('请输入密码：')
+# if user_name == 'zhangsan' and user_password == '123456':  # 必须两个条件同时满足
+#     print('登录成功')
+# else:
+#     print('登录失败,请重新输入用户名和密码')
+
+
+# 2.使用input 函数 接收一个四位年份 和 月份 判断这个月有多少天将结果输出到控制台(if的嵌套)
+# 四位年份：非闰年和闰年
+# 月份：
+# 1,3,5,7,8,10,12 大月  31天
+# 4,6,9,11 小月  30天
+# 2 平月 (闰年：29，非闰年：28)
+
+# 第一步：输入年份和月份
+year = int(input('请输入一个四位的年份：'))
+month = int(input('请输入月份1-12：'))
+
+# 第二步：计算大月(不需要考虑闰年和非闰年)
+if month == 1 or month == 3 or month == 5 or month == 7 or month == 8 or month == 10 or month == 12:
+    print(f'{month}月是大月有31天')
+
+# 第三步：计算小月(不需要考虑闰年和非闰年)  
+elif month == 4 or month == 6 or month == 9 or month == 11:
+    print(f'{month}月是小月有30天')
+
+# 第四步：计算2月(要考虑闰年和非闰年)(闰年：29天，非闰年：28天)
+# 除了上面的以外的情况(如果你输入的是1-12，只剩下2月)
+else: # 相当于你输入的是2月
+   
+    # 第五步：嵌套一个if语句来判断是否是闰年
+    # 闰年的判断条件：能被4整除且不能被100整除，或能被400整除
+    if (year % 4 == 0 and year % 100 != 0) or (year % 400 ==0):
+        print('你输入的月份是2月，同时是闰年，这个月有29天')
+    else:
+        print('你输入的月份是2月，但不是闰年，这个月有28天')

day07/03-if语句大练习.py

@@ -0,0 +1,70 @@
+# 1.用户输入两个整数，比较这两个数的大小，并输出较大的数。
+# 比较整数：int函数转换
+# 比较小数：float函数转换
+
+# n1 = int(input('请输入第一个整数：'))
+# n2 = int(input('请输入第二个整数：'))
+
+# 三种情况(第一个大,第二个大,相等)
+# if n1 > n2 :
+#     print(f'最大的数字是：{n1}')
+# elif n1 < n2 :
+#     print(f'最大的数字是：{n2}')
+# else :
+#     print(f'n1:{n1}和n2:{n2}是相等的')
+
+# 2.用户输入三角形的三边长，判断它是否为等边、等腰或普通三角形
+# 三个条件：if多分支
+# 如果三条边都相等，必须是等边三角形
+# 如果三边有任意的两边相等，必须是等腰三角形
+# 如果不满足上面的两点，就是普通三角形
+
+
+# 代码实现
+# 第一步：输入三个数字
+# n1 = int(input('请输入第一个边的长度：'))
+# n2 = int(input('请输入第二个边的长度：'))
+# n3 = int(input('请输入第三个边的长度：'))
+
+# 第二步，设置条件
+# if n1 == n2 == n3 : # 三边相同
+#     print(f'你输入的n1={n1},n2={n2},n3={n3}相同是等边三角形')
+   
+# elif n1 == n2 or n2 == n3 or n1 == n3 : # 任意两边相同
+#     print(f'你输入的n1={n1},n2={n2},n3={n3}任意两边相同是等腰三角形')
+   
+# else: # 其他情形
+#     print('你输入的三个数字不相等,是一个普通三角形')  
+
+
+# 3.根据公式(身高-108)* 2 = 体重，可以有10斤左右的浮动，来观察测试者体重是否标准(身高：cm)
+# 分析结果：身材是标准的，身材是偏胖的，身材是偏瘦的
+# 根据结果得到需要三个条件：if的多分支
+
+# 前提
+# 输入身高和体重
+# 通过公式计算最大体重的分界点和最小体重的分界点
+
+# 条件1：体重超过最大体重分界点，身材是偏胖的
+# 条件2：体重比最小体重分界点小，身材是偏瘦的
+# 条件3：体重在最大分界点和最小分界点区间内，身材是标准的
+
+# 代码实现
+# 输入身高(cm)和体重(斤)
+height = int(input('请输入你的身高cm：')) # 你的身高
+weight = int(input('请输入你的体重斤：')) # 你的体重
+
+# 通过公式计算最大体重的分界点和最小体重的分界点
+
+max_weight = (height-108)* 2 + 10   # 最大体重的分界点
+min_weight = (height-108)* 2 - 10   # 最小体重的分界点
+
+# 条件
+if weight > max_weight : # 偏胖
+    print('你太胖了,需要减减肥!')
+
+elif weight < min_weight : # 偏瘦
+    print('你太瘦了,需要多多加强营养!')
+   
+else : # 基于最大和最小之间的,标准身材
+    print('你是标准身材,请继续保持!')

day07/04-判断语句的嵌套.py

@@ -0,0 +1,47 @@
+# 判断语句的嵌套
+# 在使用if语句的时候 可以在if语句里面使用if语句
+# 规则
+# 如果存在分支语句嵌套 外层条件满足 进而执行内层的条件 一层一层向内执行
+
+# 语法
+"""
+if 条件:
+   外层if条件为真的代码块
+   if 条件:
+     内层if条件为真执行的代码
+   else:
+     内层if条件为真执行的代码
+else:
+   外层if条件为假的代码块
+"""
+
+# 案例 判断是否有火车票 判断携带的刀具是否可以(刀具<10cm可以被携带)
+ticket = True
+knife = 34
+if ticket==True:
+  print('恭喜你 有票')
+  #内层判断携带的刀具是否可以
+  if knife<10:
+    print('可以携带')
+  else:
+    print('不可以携带')
+else:
+  print('很遗憾 没有票')
+  
+  
+  
+# 作业
+# 猜拳游戏
+# 约定：石头(0)剪刀(1)布(2)
+import random  # 导入random模块
+my_num = int(input('请输入数字0-2:')) # 我们输入的整数
+if my_num <= 2: #输入的整数必须<=2
+    # 计算机随机产生的数字
+    computer_num = random.randint(0,2) # 利用random模块下面的randint方法随机产生0-2三个数字
+    # 列出我们赢的情况，其他的都是计算机赢
+    if (my_num == 0 and computer_num==1) or (my_num == 1 and computer_num == 2) or (my_num == 2 and computer_num == 0):
+        print(f'我们赢了，计算机是{computer_num}，恭喜！')
+    else: # 其他情况
+        print(f'我们输了，计算机是{computer_num}，计算机赢了')
+else:
+    print('你输入的数字不合法')

day07/05-作业.py

@@ -0,0 +1,41 @@
+# 一.请输入一个km数值，计算打车费用，已知出租车起步价10块钱3km以内，超出的部分2元/km
+# 分析
+# 判断你输入的km数字是否>3
+
+# num = int(input('请输入一个公里数km:'))  # 输入的公里数
+# if num > 3:  # 起步价 + 超出的公里数 * 2 (2元/km)
+#     print(f'你输入的公里数是{num},打车费用是{10 + ( num - 3 ) * 2}')
+# elif num == 0:
+#     print(f'你输入的公里数是{num},没有打车费用')
+# else:
+#     print(f'你输入的公里数是{num},打车费用是起步价10元')
+
+
+# 二.程序题
+"""
+东方航空从北京飞往马尔代夫的机票原价为4000元,4到10月份为旺季, 其他月份为淡季,
+- 旺季时候头等舱打9折,经济舱打7.5折；
+- 淡季头等舱打6折, 经济舱打3折。
+- 从页面输入出行的月份和选择的舱型计算出机票价格
+"""
+# 分析条件
+# 条件：4-10月旺季.  其他的是淡季
+# 条件：头等舱  经济舱
+# 代码演示
+# 输入月份和选择的舱型
+month = int(input('请输入出行的月份(1 - 12):'))  # 输入的月份
+level = input('请输入你选择的舱型(头等舱/经济舱):')  # 输入的舱型
+price = 4000 # 机票的价格
+# 通过条件判断是旺季还是淡季
+if month >= 4 and month <= 10 : # 旺季
+    # 继续判断是头等舱还是经济舱
+    if level == '头等舱':
+        print(f'旺季头等舱的价格是{price * 0.9}')  # 旺季头等舱打九折
+    else :
+        print(f'旺季经济舱的价格是{price * 0.75}')  # 旺季经济舱打七五折
+else: # 淡季
+    # 淡季头等舱打6折, 经济舱打3折
+    if level == '头等舱':
+        print(f'淡季头等舱的价格是{price * 0.6}')  # 淡季头等舱打六折
+    else :
+        print(f'淡季经济舱的价格是{price * 0.3}')  # 淡季经济舱打三折

day07/06-综合作业.py

@@ -0,0 +1,187 @@
+# 基础练习
+# 判断奇偶数
+num = int(input("请输入一个整数: "))
+if num % 2 == 0:
+    print("这是一个偶数")
+else:
+    print("这是一个奇数")
+    
+# 判断正数、负数或零
+num = float(input("请输入一个数字: "))
+if num > 0:
+    print("正数")
+elif num < 0:
+    print("负数")
+else:
+    print("零")
+    
+# 比较两个数的大小
+a = int(input("输入第一个数: "))
+b = int(input("输入第二个数: "))
+if a > b:
+    print("第一个数较大")
+elif a < b:
+    print("第二个数较大")
+else:
+    print("两个数相等")
+    
+# 判断闰年
+year = int(input("请输入年份: "))
+if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
+    print("闰年")
+else:
+    print("平年")
+    
+# 判断字符是否是元音字母
+char = input("请输入一个字符: ").lower()
+if char in "aeiou":
+    print("是元音字母")
+else:
+    print("不是元音字母")
+    
+# 进阶练习
+# 计算折扣
+price = float(input("请输入商品价格: "))
+if price > 100:
+    discount = 0.2
+elif price > 50:
+    discount = 0.1
+else:
+    discount = 0.05
+final_price = price * (1 - discount)
+print(f"折扣后价格: {final_price:.2f}")
+
+# 判断三角形类型
+a, b, c = map(int, input("输入三条边的长度: ").split())
+if a + b > c and a + c > b and b + c > a:
+    if a == b == c:
+        print("等边三角形")
+    elif a == b or a == c or b == c:
+        print("等腰三角形")
+    else:
+        print("普通三角形")
+else:
+    print("不能构成三角形")
+    
+# 计算BMI指数
+weight = float(input("请输入体重(kg): "))
+height = float(input("请输入身高(m): "))
+bmi = weight / (height ** 2)
+if bmi < 18.5:
+    print("偏瘦")
+elif bmi < 24:
+    print("正常")
+elif bmi < 28:
+    print("偏胖")
+else:
+    print("肥胖")
+    
+# 判断学生成绩等级
+score = int(input("请输入成绩: "))
+if score >= 90:
+    print("优秀")
+elif score >= 80:
+    print("良好")
+elif score >= 70:
+    print("中等")
+elif score >= 60:
+    print("及格")
+else:
+    print("不及格")
+    
+# 判断是否能领取驾照
+age = int(input("请输入你的年龄: "))
+if age >= 18:
+    print("可以申请驾照")
+else:
+    print("未满18岁，无法申请驾照")
+    
+# 高级练习
+# 判断用户输入的用户名和密码是否正确
+username = input("请输入用户名: ")
+password = input("请输入密码: ")
+if username == "admin" and password == "123456":
+    print("登录成功")
+else:
+    print("用户名或密码错误")
+    
+# 模拟简单计算器
+num1 = float(input("输入第一个数: "))
+num2 = float(input("输入第二个数: "))
+op = input("输入运算符 (+, -, *, /): ")
+if op == "+":
+    print(f"结果: {num1 + num2}")
+elif op == "-":
+    print(f"结果: {num1 - num2}")
+elif op == "*":
+    print(f"结果: {num1 * num2}")
+elif op == "/":
+    if num2 != 0:
+        print(f"结果: {num1 / num2}")
+    else:
+        print("错误：除数不能为零")
+else:
+    print("无效运算符")
+    
+# 判断一个数是否是素数
+num = int(input("请输入一个大于1的整数: "))
+is_prime = True
+if num > 1:
+    for i in range(2, int(num ** 0.5) + 1):
+        if num % i == 0:
+            is_prime = False
+            break
+else:
+    is_prime = False
+print("是素数" if is_prime else "不是素数")
+
+# 判断用户输入的年份是否为世纪年
+year = int(input("请输入年份: "))
+if year % 100 == 0:
+    print(f"{year} 是世纪年")
+else:
+    print(f"{year} 不是世纪年")
+    
+# 判断一个数是否为回文数
+num = input("请输入一个数字: ")
+if num == num[::-1]:
+    print("是回文数")
+else:
+    print("不是回文数")
+    
+# 判断用户名是否合法（长度大于等于6）
+username = input("请输入用户名: ")
+if len(username) >= 6:
+    print("用户名有效")
+else:
+    print("用户名长度必须至少6个字符")
+    
+# 判断一个年份是否属于 21 世纪
+year = int(input("请输入年份: "))
+if 2001 <= year <= 2100:
+    print(f"{year} 属于 21 世纪")
+else:
+    print(f"{year} 不属于 21 世纪")
+    
+# 判断数字是否在区间 [10, 50] 内
+num = int(input("请输入一个数字: "))
+if 10 <= num <= 50:
+    print(f"{num} 在区间 [10, 50] 内")
+else:
+    print(f"{num} 不在区间 [10, 50] 内")
+    
+# 判断密码强度
+password = input("请输入密码: ")
+if len(password) >= 8 and any(c.isdigit() for c in password) and any(c.isalpha() for c in password):
+    print("密码强度较高")
+else:
+    print("密码强度较低，请包含字母和数字，并且至少8位")
+    
+# 判断是否是工作日还是周末
+day = int(input("请输入星期几 (1-7, 1代表星期一): "))
+if 1 <= day <= 5:
+    print("工作日")
+elif day == 6 or day == 7:
+    print("周末")
+else:
+    print("输入错误")

day08/01-高级练习.py

@@ -0,0 +1,145 @@
+# 1. 复杂身份验证系统
+# 题目：
+# 模拟一个简单的身份验证系统，用户需要输入 用户名 和 密码，并根据以下规则进行验证：
+# 用户名必须是 admin 或 user
+# 如果是 admin，密码必须是 "admin123"
+# 如果是 user，密码必须是 "user456"
+# 如果用户名或密码错误，提示 "用户名或密码错误"
+# 如果输入的用户名不在系统内，提示 "用户不存在"
+
+username = input("请输入用户名: ")
+password = input("请输入密码: ")
+
+if username == "admin":
+    if password == "admin123":
+        print("欢迎管理员登录！")
+    else:
+        print("用户名或密码错误")
+elif username == "user":
+    if password == "user456":
+        print("欢迎用户登录！")
+    else:
+        print("用户名或密码错误")
+else:
+    print("用户不存在")
+
+
+
+
+
+# 2. ATM 取款机（加强版）
+# 题目：
+# 用户输入取款金额，必须满足以下条件：
+# 取款金额必须是 100 的倍数
+# 余额不足时，提示 "余额不足"
+# 取款限额：单次取款金额不得超过 3000
+# 每日限额：每日取款不得超过 10000
+# 取款成功时，显示 "取款成功，余额为 X 元"
+
+balance = 10000
+daily_limit = 10000  # 每日可取款额度
+
+amount = int(input("请输入取款金额（100 的倍数）: "))
+
+if amount % 100 != 0:
+    print("错误：取款金额必须是 100 的倍数")
+elif amount > balance:
+    print("错误：余额不足")
+elif amount > 3000:
+    print("错误：单次取款金额不得超过 3000 元")
+elif amount > daily_limit:
+    print("错误：超过每日取款限额")
+else:
+    balance -= amount
+    daily_limit -= amount
+    print(f"取款成功，余额为 {balance} 元，今日还可取 {daily_limit} 元")
+
+# 3. 复杂成绩评级
+# 题目：
+# 输入成绩（0-100），根据以下规则进行评级：
+# 95-100：A+
+# 90-94：A
+# 85-89：B+
+# 80-84：B
+# 70-79：C
+# 60-69：D
+# <60：F
+# 额外要求：
+# 如果成绩大于 100 或小于 0，提示 "输入错误"
+# 如果成绩是 满分 100，提示 "满分！你太棒了！"
+
+score = int(input("请输入成绩 (0-100): "))
+
+if 95 <= score <= 100:
+    print("评级: A+")
+    if score == 100:
+        print("满分！你太棒了！")
+elif 90 <= score < 95:
+    print("评级: A")
+elif 85 <= score < 90:
+    print("评级: B+")
+elif 80 <= score < 85:
+    print("评级: B")
+elif 70 <= score < 80:
+    print("评级: C")
+elif 60 <= score < 70:
+    print("评级: D")
+elif 0 <= score < 60:
+    print("评级: F")
+else:
+    print("输入错误，请输入 0-100 之间的成绩")
+
+# 4. 复杂闰年判断
+# 题目：
+# 编写程序，输入年份 year，判断它是否是闰年：
+# 能被 4 整除但不能被 100 整除，或
+# 能被 400 整除
+# 额外要求：
+# 如果年份小于 0，提示 "输入错误"
+# 让用户输入 起始年份和结束年份，打印出该范围内所有的闰年。
+
+start_year = int(input("请输入起始年份: "))
+end_year = int(input("请输入结束年份: "))
+
+if start_year < 0 or end_year < 0:
+    print("输入错误，年份必须是正数")
+elif start_year > end_year:
+    print("起始年份不能大于结束年份")
+else:
+    print(f"{start_year} 到 {end_year} 之间的闰年有：")
+    for year in range(start_year, end_year + 1):
+        if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
+            print(year, end=" ")
+
+# 5. 进阶计算器
+# 题目：
+# 用户输入 两个数字 和 运算符（+、-、*、/、%），计算结果并显示：
+# 除法 / 不能除以 0，否则提示 "错误：除数不能为 0"
+# 允许输入 **（指数运算），比如 2 ** 3 = 8
+# 增加异常处理，如果输入非数字，提示 "输入错误"
+
+try:
+    num1 = float(input("请输入第一个数字: "))
+    num2 = float(input("请输入第二个数字: "))
+    operator = input("请输入运算符 (+, -, *, /, %, **): ")
+
+    if operator == "+":
+        print("结果:", num1 + num2)
+    elif operator == "-":
+        print("结果:", num1 - num2)
+    elif operator == "*":
+        print("结果:", num1 * num2)
+    elif operator == "/":
+        if num2 == 0:
+            print("错误：除数不能为 0")
+        else:
+            print("结果:", num1 / num2)
+    elif operator == "%":
+        print("结果:", num1 % num2)
+    elif operator == "**":
+        print("结果:", num1 ** num2)
+    else:
+        print("错误：无效的运算符")
+except ValueError:
+    print("输入错误，请输入数字")
+

day08/02-循环的意义.py

@@ -0,0 +1,26 @@
+# 一.循环的意义
+# 循环在程序中同判断一样，也是广泛存在的，是非常多功能实现的基础
+# 例如：输出100次内容
+print('你好,世界1')
+print('你好,世界2')
+print('你好,世界3')
+print('你好,世界4')
+print('你好,世界5')
+print('你好,世界6')
+print('你好,世界7')
+print('你好,世界8')
+print('你好,世界9')
+print('你好,世界10')
+# 上面的写法如果是100次，非常不方便，可以通过循环进行优化
+
+# 二.python里面的循环语句
+# 1、while循环
+# 2、for...in 循环
+
+# 三.循环的组成
+# 1、定义循环的关键字(while  for   in)
+# 2、限制条件(终止条件)
+# 3、循环体(满足条件执行的代码) 
+
+# 四.死循环
+# 无法靠自身条件终止的代码的循环 

day08/03-while循环.py

@@ -0,0 +1,23 @@
+# 一、while循环
+# 语法
+"""
+while 判断条件:
+  满足条件执行语句
+  ...
+"""
+
+# 注意
+# 初始值
+# while + 限制条件
+# 满足条件执行的循环体
+# 初始值的迭代(累加累减)
+
+# 案例
+# 打印100-200之间是有能被3和7整除的数
+num = 100 # 初始值
+while num <= 200: # 条件1：100-200
+    # 条件2：能被3和7整除
+    if(num % 3 == 0 and num % 7 == 0):
+        print(num) # 打印结果
+    num += 1 # 累加 初始值的迭代
+    

day08/04-while循环练习.py

@@ -0,0 +1,51 @@
+# 1. 输出 1 到 100 的整数
+i = 1
+while i <= 100:
+    print(i, end=" ")
+    i += 1
+
+# 2. 计算 1 到 n 的和
+n = int(input("请输入一个整数："))
+sum = 0
+i = 1
+while i <= n:
+    sum += i
+    i += 1
+print(f"1到{n}的和是 {sum}")
+
+
+# 3.用户输入一个整数，计算这个数字的各位数字的和。例如：输入 123，输出 1 + 2 + 3 = 6。
+num = int(input("请输入一个整数："))
+sum_digits = 0
+while num > 0:
+    sum_digits += num % 10  # 提取最后一位数字
+    num //= 10  # 去掉最后一位
+print(f"各位数字的和是 {sum_digits}")
+
+# 4.找出从 1 到 n 之间的所有偶数，n 是用户输入的整数。
+n = int(input("请输入一个整数："))
+i = 2
+while i <= n:
+    print(i, end=" ")
+    i += 2
+
+# 5.用户输入密码，最多重试 3 次，如果密码正确则输出“登录成功”，如果密码错误则输出“密码错误”，并提示用户剩余尝试次数。
+password = "1234"
+tries = 3
+while tries > 0:
+    entered_password = input("请输入密码：")
+    if entered_password == password:
+        print("登录成功")
+        break
+    else:
+        tries -= 1
+        print(f"密码错误，剩余尝试次数：{tries}")
+else:
+    print("尝试次数超过限制，账户已锁定")
+
+# 6.使用 while 循环打印一个倒三角形。假设倒三角形的高度为 n，n 是用户输入的整数。
+n = int(input("请输入倒三角形的高度："))
+i = 0
+while i < n:
+    print(" " * i + "*" * (n - i))
+    i += 1

day08/05-while循环的高级练习.py

@@ -0,0 +1,67 @@
+# 练习 1：模拟银行账户操作
+# 编写一个程序来模拟银行账户的操作，用户可以选择存款、取款、查看余额或退出。
+balance = 0
+while True:
+    print("\n银行账户操作")
+    print("1. 存款")
+    print("2. 取款")
+    print("3. 查看余额")
+    print("4. 退出")
+    choice = input("请输入你的选择: ")
+
+    if choice == '1':
+        amount = float(input("请输入存款金额: "))
+        if amount > 0:
+            balance += amount
+            print(f"存款成功，当前余额: {balance}")
+        else:
+            print("存款金额必须为正数。")
+    elif choice == '2':
+        amount = float(input("请输入取款金额: "))
+        if amount > 0 and amount <= balance:
+            balance -= amount
+            print(f"取款成功，当前余额: {balance}")
+        else:
+            print("取款金额无效或余额不足。")
+    elif choice == '3':
+        print(f"当前余额: {balance}")
+    elif choice == '4':
+        print("感谢使用，再见！")
+        break
+    else:
+        print("无效的选择，请重新输入。")
+
+
+# 练习 2：猜数字游戏（限定次数）
+# 编写一个猜数字游戏，计算机随机选择一个 1 到 100 之间的数字，用户有 10 次机会猜出这个数字。
+import random
+
+number = random.randint(1, 100)
+attempts = 0
+max_attempts = 10
+
+while attempts < max_attempts:
+    guess = int(input("猜一个 1 到 100 之间的数字: "))
+    attempts += 1
+
+    if guess < number:
+        print("猜的数字太小了，再试一次。")
+    elif guess > number:
+        print("猜的数字太大了，再试一次。")
+    else:
+        print(f"恭喜你，猜对了！你用了 {attempts} 次尝试。")
+        break
+
+if attempts == max_attempts:
+    print(f"很遗憾，你已经用完了 {max_attempts} 次尝试。正确的数字是 {number}。")
+
+
+
+
+
+
+
+
+
+
+

day09/01-正向和反向循环.py

@@ -0,0 +1,16 @@
+# 正向循环
+# 例如 输出数字1-10
+num=1
+while num<=10:
+  print(num)
+  num +=1
+  
+# 反向循环
+# 例如 输出数字10-1
+num=10
+while num>=1:
+  print(num)
+  num -=1
+  
+  
+  

day09/02-break和continue.py

@@ -0,0 +1,27 @@
+# continue和break关键字
+# 关键字：python内部约定的，具有特殊用途的单词
+# 程序的循环速度非常快，利用continue和break关键字结束循环
+
+# 1.break关键字(打断的意思)
+# break关键字,可以直接结束循环,循环体内碰到break，循环就结束
+# 案例
+num=1
+while num<=10:
+  if num==5:
+    break # 只要num==5 break就执行 整个循环结束
+  print(f'这是第{num}次循环')
+  num +=1
+
+# 2.continue关键字(继续的意思)
+# continue关键字用于中断本次循环，可以进入下一次循环
+# 案例
+num=0
+while num<10:
+  num +=1
+  if num==5:
+    continue # 只要num==5 continue就执行 跳过本次循环 继续下一个循环
+  print(f'这是第{num}次循环')
+  
+  
+  
+

day09/03-练习1.py

@@ -0,0 +1,30 @@
+ # 1.使用循环不断要求用户输入数字，计算所有输入数字的和，直到用户输入 0 时结束。
+# 分析
+# 题目中出现中断循环或者结束循环(break)
+
+# 第一步：不断用户输入数字(依靠无限循环不断输入)
+# while True:  #这里的条件一直满足，无限循环
+#     input('请输入你要相加的数字：')
+
+
+# 第二步：计算所有输入数字的和(迭代：上一次的结果 + 下一次的值)
+# sum = 0
+# i = 1
+# while i <= 10:# i的值从1-10
+#     sum += i # sum = sum + i  
+#     # 上面代码的第一次执行：sum =  0 + 1 = 1
+#     # 上面代码的第二次执行：sum =  sum + i = 1 + 2 后面的sum就是上一次的结果1 + i的下一次的值2
+#     i += 1
+# print(sum) # 55
+
+
+# 第三步：直到用户输入 0 时结束(if判断用户输入的数字如果是0,结束循环break)
+
+sum = 0 # 求和的初始值(第一次赋值,存储所有输入数字的和)
+while True:
+    value = int(input('请输入你要相加的数字：')) # 每次输入的值给value
+    sum += value # 累加(迭代)
+    if value == 0: # 如果用户输入的数字是0,结束循环
+        break
+print(f'你输入的所有数字的和是{sum}')
+

day09/04-练习2.py

@@ -0,0 +1,26 @@
+# 2.猜年龄游戏
+# 前面讲过一个random模块(内置模块，先导入，再使用)，利用random对象下面的方法随机产生一个整数
+# 2.1.准备随机数(randint)
+
+# 2.2.通过无限循环去判断用户输入的是否是随机的年龄
+# 用户输入的数字大了
+# 用户输入的数字小了
+# 用户输入的数字对了，结束循环(break)
+
+# 2.3.需要设置变量统计猜测的次数，定输赢(迭代+= / -=)
+
+import random
+age = random.randint(1,200)  # 生成1-200之间的数据，包括1和200
+
+count = 0 # 统计你猜测的次数的初始值
+
+while True: # 无限循环来猜测，正确了就结束
+    my_age = int(input('请输入你猜测的数字：')) # 用户猜测的数字
+    count += 1 # 统计你猜测的次数
+    if my_age > age :
+        print('你输入的数字 大 了')
+    elif my_age < age :
+        print('你输入的数字 小 了')
+    else: # 注意：如果猜对了，结束循环
+        print(f'恭喜你,你猜对了！随机的年龄是{age},你总共猜测了{count}次')
+        break # 结束循环

day09/05-综合练习.py

@@ -0,0 +1,146 @@
+# 练习 1：猜数字游戏（使用 break）
+# 要求： 让用户猜一个数字（1-10 之间），如果猜对了，就使用 break 结束循环。
+import random
+
+secret_number = random.randint(1, 10)
+
+while True:
+    guess = int(input("猜一个 1 到 10 之间的数字: "))
+   
+    if guess == secret_number:
+        print("恭喜，你猜对了!")
+        break  # 终止循环
+    else:
+        print("猜错了，继续猜!")
+
+# 练习 2：跳过偶数（使用 continue）
+# 要求： 只打印 1 到 10 之间的奇数，跳过偶数。
+num = 0
+
+while num < 10:
+    num += 1
+    if num % 2 == 0:  # 如果是偶数
+        continue  # 跳过本次循环，进入下一次
+    print(num)
+
+# 练习 3：限制输入次数（使用 break 和 continue）
+# 要求： 用户最多有 3 次机会输入密码，输入正确后结束，否则继续输入。如果输入为空，则提示“密码不能为空”并跳过本次输入。
+correct_password = "123456"
+attempts = 3
+
+while attempts > 0:
+    password = input("请输入密码: ")
+   
+    if password == "":
+        print("密码不能为空!")
+        continue  # 直接跳到下一次循环
+   
+    if password == correct_password:
+        print("密码正确，欢迎进入系统!")
+        break  # 终止循环
+    else:
+        attempts -= 1
+        print(f"密码错误，你还有 {attempts} 次机会")
+
+if attempts == 0:
+    print("你的账号已被锁定!")
+
+# 练习 4：寻找第一个能被 7 整除的数字
+# 要求： 从 1 开始计数，找到第一个能被 7 整除的数字后停止。
+num = 1
+
+while True:
+    if num % 7 == 0:
+        print(f"找到第一个能被 7 整除的数字：{num}")
+        break  # 找到后直接退出循环
+    num += 1
+
+# 练习 5：用户登录（使用 break 和 continue）
+# 要求： 用户最多可以输入 3 次密码，正确则退出，输入为空则提示“密码不能为空”并跳过本次输入。
+correct_password = "admin123"
+attempts = 3
+
+while attempts > 0:
+    password = input("请输入密码: ")
+   
+    if password == "":
+        print("⚠️ 密码不能为空!")
+        continue
+   
+    if password == correct_password:
+        print("✅ 密码正确，登录成功!")
+        break
+    else:
+        attempts -= 1
+        print(f"❌ 密码错误，你还有 {attempts} 次机会")
+
+if attempts == 0:
+    print("🔒 账号已被锁定!")
+
+# 练习 6：打印 1-50 内第一个能被 7 和 9 同时整除的数
+# 要求： 找到第一个能同时被 7 和 9 整除的数，找到后 break 退出。
+num = 1
+
+while num <= 50:
+    if num % 7 == 0 and num % 9 == 0:
+        print(f"🎯 找到：{num}")
+        break
+    num += 1
+
+# 练习 7：跳过数字 5（使用 continue）
+# 要求： 1 到 10 之间的数字，但 跳过 5。
+num = 0
+
+while num < 10:
+    num += 1
+    if num == 5:
+        continue  # 跳过 5
+    print(num)
+
+# 练习 8：计算 1-100 之间的奇数和（使用 continue）
+# 要求： 计算 1 到 100 之间所有奇数的总和。
+num = 0
+total = 0
+
+while num <= 100:
+    num += 1
+    if num % 2 == 0:
+        continue  # 跳过偶数
+    total += num
+
+print(f"所有奇数的和是: {total}")
+
+# 练习 9：找出 1-100 内所有能被 3 整除的数
+# 要求： 1-100 之间，找到所有能被 3 整除的数字，并打印。
+num = 1
+
+while num <= 100:
+    if num % 3 != 0:
+        num += 1
+        continue  # 跳过不能被 3 整除的数
+    print(num)
+    num += 1
+
+# 练习 10：银行取款系统
+# 要求： 余额为 5000 元，用户可以不断输入取款金额，直到余额不足或用户输入 0 退出。
+balance = 5000
+while balance > 0:
+    amount = int(input(f"💰 你当前余额为 {balance}，请输入取款金额（输入 0 退出）："))
+    if amount == 0:
+        print("👋 交易结束!")
+        break
+    if amount > balance:
+        print("⚠️ 余额不足!")
+        continue  # 重新输入金额
+    balance -= amount
+    print(f"✅ 取款成功，剩余余额: {balance}")
+
+# 练习 11：倒计时（使用 break）
+# 要求： 倒计时 10 秒，当计数到 3 时，立即结束。
+num = 10
+while num > 0:
+    print(f"倒计时: {num} 秒")
+    num -= 1
+    if num == 3:
+        print("🚀 倒计时提前终止!")
+        break

day10/01-三目运算符.py

@@ -0,0 +1,20 @@
+# 三目运算符
+# 语法
+# 条件为真时候的结果 if 判断条件 else 条件为假时候的结果
+
+# 案例
+# 将a b 里面的最大值给max
+a=100
+b=20
+max=a if  a>b else b
+print(max)
+
+# if语句 对比
+a=100
+b=20
+if a>b:
+  max=a
+else:
+  max=b
+print(max)
+

day10/02-练习.py

@@ -0,0 +1,25 @@
+# 大家都知道，男大当婚，女大当嫁。那么女方家长要嫁女儿，当然要提出一定的条件：
+# - 高:180cm以上; 富:1000万以上; 帅:60以上(0~100);
+# - 如果这三个条件同时满足，则:'我一定要嫁给他’
+# - 如果三个条件有为真的情况(满足一个即可)，则:'嫁吧，比上不足，比下有余'。
+# - 如果三个条件都不满足，则:‘不嫁！’
+
+# 分析：
+# 条件：高:180cm以上; 富:1000万以上; 帅:60以上(0~100);
+
+# 代码：
+# 1.用户输入三个数据(高富帅)
+height = int(input('请输入你的身高(cm):'))  # 身高
+money = int(input('请输入你的财富(万):'))  # 财富
+face = int(input('请输入你的颜值分数(0~100):'))  # 颜值
+
+# 2.三种不同的情况，采用多分支
+# 如果这三个条件同时满足，则:'我一定要嫁给他’ -- and
+if height > 180 and money > 1000 and face > 60:
+    print(f'他的身高{height}cm,财富是{money}万,颜值是{face}分,我一定要嫁给他')
+# 如果三个条件有为真的情况，则:'嫁吧，比上不足，比下有余' -- or
+elif height > 180 or money > 1000 or face > 60:
+     print(f'他的身高{height}cm,财富是{money}万,颜值是{face}分,嫁吧，比上不足，比下有余')
+# 其他情况(如果三个条件都不满足，则:‘不嫁！’)
+else:
+    print('不满足任何一个要求，不嫁')

day10/03-作业.py

@@ -0,0 +1,37 @@
+# 练习 1：判断正负数
+# 输入一个数字，判断它是正数还是负数
+num = -3
+
+result = "正数" if num > 0 else "负数"
+print(result)
+
+# 练习 2：找两个数中的较大者
+a = 10
+b = 20
+
+max_value = a if a > b else b
+print(f"较大值是: {max_value}")
+
+# 练习 3：判断是否为偶数
+n = 7
+
+result = "偶数" if n % 2 == 0 else "奇数"
+print(f"{n} 是 {result}")
+
+# 练习 4：嵌套三目运算符（判断分数等级）
+score = 85
+
+grade = "优秀" if score >= 90 else ("良好" if score >= 75 else "及格")
+print(f"成绩等级: {grade}")
+
+# 练习 5：用户输入进行判断
+num = int(input("请输入一个整数："))
+result = "正数" if num > 0 else ("零" if num == 0 else "负数")
+print(f"{num} 是 {result}")
+
+
+
+
+
+
+

day10/04-for循环.py

@@ -0,0 +1,24 @@
+# 一.for循环
+# 1.for循环和while循环的区别
+# 除了while循环语句外，Python同样提供了for循环语句，两者能完成的功能基本差不多，但仍有一些区别:
+# while循环的循环条件是自定义的，自行控制循环条件
+# for循环是一种"轮询"机制，是对一批内容进行"逐个处理"
+
+# 2.for循环的基础语法
+"""
+for 临时变量 in 待处理的数据集：
+  循环体
+"""
+# 临时变量:用户可以自定义名称，不推荐在循环外使用，故命名临时变量
+# 循环体：拿到 "待处理的数据集" 进行逐个处理或者操作
+# 待处理数据集：严格来说称之为序列类型
+# 序列类型指其内容可以一个个依次取出的一种类型，包括:字符串、列表、元组...
+
+# 案例
+str='hello'
+for s in str:
+  print(s)
+  
+# 注意 不能直接对某个数字进行处理
+# for i in 10:
+#   print(i)

day10/05-range函数.py

@@ -0,0 +1,21 @@
+# for循环和range函数
+# 1、forin操作字符串
+str='hello'
+for s in str:
+  print(s)
+  
+# 2、forin操作数字 需要range函数
+# 2-1、range函数里面只有一个参数 从0开始获取 到num结束的数字序列(num不包含)
+for n in range(10):
+  print(n)
+  
+# 2-2、range函数里面有两个参数 从num1开始获取 到num2结束的数字序列(num2不包含)
+for n in range(1,10):
+  print(n)
+  
+# 2-2、range函数里面有三个参数 从num1开始获取 到num2结束的数字序列(num2不包含) num3是步长
+for n in range(1,10,2):
+  print(n)
+  
+  
+  

day10/06-作业.py

@@ -0,0 +1,59 @@
+# 一.求出1/1 - 1/2 + 1/3 - 1/4 + 1/5 - 1/6... + 1/100的和
+# 重复 + 规律
+# 1.第一种方式
+# fz = 1 # 分子
+# fm = 1 # 分母的初始值1 需要循环(1~100)
+# sum = 0 # 存放结果
+# while fm <= 100:
+#     sum += fz/fm  # 1次：sum += 1/1  (2次 -)  (3次 +) (4次 -)...
+#     fz = -fz # 一正一负(负负得正)
+#     fm +=1
+# print(sum) # 0.688172179310195
+
+# 2.第二种方式
+# sum = 0 # 存放结果
+# for fm in range(1,101):  # fm = 1~100
+#     if fm % 2 == 0: # 偶数，相减
+#        sum -= 1/fm   # 第二次：sum = 1 - 1/2
+#     else: # 奇数，相加
+#        sum += 1/fm  # 第一次：sum = 0 + 1
+# print(sum) # 0.688172179310195
+
+# 总结：循环的算法，推算前面几步，剩下的交给循环实现
+
+# 二.打印出1000-2000年中所有的闰年，并以每行四个数的形式输出
+# 循环1000-2000年中所有的闰年
+# 设置一个计数器
+# 并以每行四个数的形式输出，利用计数器和4进行取余来输出换行
+# count = 0
+# for year in range(1000,2001): # 循环1000~2000年里面的年份
+#     if (year % 4 == 0 and year % 100 !=0) or (year % 400 == 0): # 闰年的条件
+#         count += 1 # 满足闰年，计数器+1，统计闰年的个数
+#         print(year,end='  ') # 不换行输出所有的闰年
+#         if count % 4 == 0: # 利用计数器和4进行取余来输出换行
+#             print() # 输出换行
+
+# 三.利用星型字符（*）输出如下图形：三角形 , 菱形
+# 1.等腰三角形 - 通过循环输出5行，每一行计算对应的空格和星号
+# 第一行：4个空格 + 1颗星
+# 第二行：3个空格 + 3颗星
+# 第三行：2个空格 + 5颗星
+# 第四行：1个空格 + 7颗星
+# 第五行：0个空格 + 9颗星
+
+# rows = 5 # 初始值
+# for i in range(1,rows+1): # i = 1,2,3,4,5
+#     print(' ' * (rows - i) + '*' * (2 * i - 1))
+
+# 直角
+# rows = 10 # 初始值
+# for i in range(1,rows + 1): # i = 1,2,3,4,5,6,7,8,9,10
+#     print('*' * i)
+
+# 菱形
+# rows = 5 # 初始值
+# for i in range(1, rows+1): # i = 1,2,3,4,5
+#     print(' ' * (rows - i) + '*' * (2 * i - 1))
+   
+# for i in range(rows-1, 0, -1): # i = 1,2,3,4,5
+#     print(' ' * (rows - i) + '*' * (2 * i - 1))

day10/07-作业.py

@@ -0,0 +1,60 @@
+# 1. 输出 1 到 100 的整数
+for i in range(1, 101):
+    print(i, end=" ")
+
+# 2. 计算 1 到 n 的和
+n = int(input("请输入一个整数："))
+sum = 0
+for i in range(1, n + 1):
+    sum += i
+print(f"1到{n}的和是 {sum}")
+
+# 4. 判断质数
+# 用户输入一个整数 n，使用 for 循环判断 n 是否为质数。质数是指大于 1 且只有 1 和自身两个约数的数。
+n = int(input("请输入一个整数："))
+is_prime = True
+for i in range(2, int(n ** 0.5) + 1):
+    if n % i == 0:
+        is_prime = False
+        break
+if is_prime and n > 1:
+    print(f"{n} 是质数")
+else:
+    print(f"{n} 不是质数")
+
+# 5. 输出列表中的所有元素
+lst = [1, 2, 3, 4, 5]
+for item in lst:
+    print(item, end=" ")
+
+# 6.反转一个字符串
+s = input("请输入一个字符串：")
+reversed_str = ""
+for char in s:
+    reversed_str = char + reversed_str  # 每次将当前字符添加到结果前面
+print(f"反转后的字符串是 {reversed_str}")
+
+# 7.找出列表中的最大值
+lst = [3, 1, 4, 1, 5, 9, 2]
+max_val = lst[0]
+for num in lst:
+    if num > max_val:
+        max_val = num
+print(f"列表中的最大值是 {max_val}")
+
+# 8.求列表中所有数字的平方
+lst = [1, 2, 3, 4]
+for num in lst:
+    print(num ** 2, end=" ")
+
+# 9.字符串中每个字符的ASCII值
+# 用户输入一个字符串，使用 for循环 输出字符串中每个字符的 ASCII 值。
+s = input("请输入一个字符串：")
+for char in s:
+    print(f"{char}的ASCII值是{ord(char)}")
+    
+    
+    
+    
+    
+    

day11/01-练习.py

@@ -0,0 +1,38 @@
+# 输出所有 1~100 中的偶数
+for i in range(1, 101):
+    if i % 2 == 0:
+        print(i)
+
+
+# 判断 100 以内有多少个质数（素数）
+for num in range(2, 101):
+    is_prime = True
+    for i in range(2, int(num ** 0.5) + 1):
+        if num % i == 0:
+            is_prime = False
+            break
+    if is_prime:
+        print(num)
+
+
+# 打印斐波那契数列前 20 个数
+a, b = 0, 1
+for _ in range(20):
+    print(a, end=' ')
+    a, b = b, a + b
+
+
+# 九九乘法表横着显示
+for i in range(1, 10):
+    for j in range(1, 10):
+        print(f"{i}*{j}={i*j:2}", end="  ")
+    print()
+
+
+# 用户输入一个字符串，统计每个字母出现的次数（用 for + 字典）
+s = input("请输入一段文字：")
+count = {}
+for ch in s:
+    if ch.isalpha():
+        count[ch] = count.get(ch, 0) + 1
+print(count)

day11/02-经典练习.py

@@ -0,0 +1,44 @@
+# 练习 1：九九乘法表（经典嵌套循环）
+# 题目： 打印标准的九九乘法表。
+for i in range(1, 10):
+    for j in range(1, i + 1):
+        print(f"{j}*{i}={i*j}", end='\t')
+    print()
+
+# 练习 2：计算列表中的素数个数
+# 题目： 给定一个整数列表，找出其中的素数个数。
+def is_prime(n):
+    if n < 2: return False
+    for i in range(2, int(n**0.5) + 1):
+        if n % i == 0:
+            return False
+    return True
+
+def count_primes(lst):
+    count = 0
+    for num in lst:
+        if is_prime(num):
+            count += 1
+    return count
+
+# 练习 3：找出字符串中出现次数最多的字符
+# 题目： 给定字符串 "aabbbccccdd", 输出出现次数最多的字符和次数（如：'c', 4）
+def most_common_char(s):
+    max_count = 0
+    result = ''
+    for char in set(s):
+        count = s.count(char)
+        if count > max_count:
+            max_count = count
+            result = char
+    return result, max_count
+
+# 练习 4：列表去重但保持原顺序
+# 题目： 输入 [1, 2, 2, 3, 1, 4]，输出 [1, 2, 3, 4]
+def dedupe_keep_order(lst):
+    result = []
+    for item in lst:
+        if item not in result:
+            result.append(item)
+    return result
+

day11/03-循环的案例.py

@@ -0,0 +1,81 @@
+# 一.求100-999之间的水仙花数
+# 水仙花数：
+# 是指一个n位数（n≥3），其每个位上的数字的n次幂之和等于它本身。
+# 例如，三位数153就是一个水仙花数，因为1^3 + 5^3 + 3^3 = 153。
+
+# 思路：
+# 1.如何获取一个三位数的个位,十位,百位
+# 2.如何设定条件：个位*个位*个位 + 十位*十位*十位 + 百位*百位*百位 = 百十个
+
+# 代码
+"""
+i = 100
+while i <= 999:
+    a = i % 10   # 个位
+    b = i % 100 // 10 # 十位(//符号获取商的整数部分)
+    c = i // 100 # 百位
+    if a*a*a + b*b*b + c*c*c == i: #设定条件
+       print(i,end=',') # 一行输出，逗号分隔  153,370,371,407
+    i += 1
+"""
+   
+"""
+for num in range(100,1000): # 循环产生100-999
+   # 获取一个三位数的个位,十位,百位
+   a = num % 10   # 个位
+   b = num % 100 // 10 # 十位(//符号获取商的整数部分)
+   c = num // 100 # 百位
+   if a*a*a + b*b*b + c*c*c == num: #设定条件
+       print(num,end=',') # 一行输出，逗号分隔  153,370,371,407
+"""
+
+# 二.打印输出100以内的不带7且不是7的倍数
+# 分析：
+# 1.循环1-100个数
+# 2.不是7的倍数：无法和7整除，采用取余的方式进行判断
+# 3.不带7(个位不能是7，十位不能是7)
+
+# for num in range(1,101): # 循环1-100个数
+#     if (num % 7 != 0) and (num % 10 != 7) and (num // 10 != 7) :
+#         # 不是7的倍数(num % 7 != 0)  
+#         # 个位不能是7(num % 10 != 7)
+#         # 十位不能是7(num // 10 != 7)
+#         print(num,end=',')
+
+
+num = 1
+while num <= 100:
+    if (num % 7 != 0) and (num % 10 != 7) and (num // 10 != 7) :
+        # 不是7的倍数(num % 7 != 0)  
+        # 个位不能是7(num % 10 != 7)
+        # 十位不能是7(num // 10 != 7)
+        print(num,end=',')
+    num += 1
+
+# 三.判断输入的数字是否是素数(素数就是能够被1和自身整除的数)
+# 分析：
+# 如果判断这个数字是否是素数，可以通过取余实现(取余针对整除进行运算)
+# 根据概念一个数字除了1和自身，其他的数字都不能和它进行整除
+# 例如：19  除了1和自身都不能和它整除(剩下的2-18都不能整除)
+# 例如：23  除了1和自身都不能和它整除(剩下的2-22都不能整除)
+# 例如：29  除了1和自身都不能和它整除(剩下的2-28都不能整除)
+# 得到规律，想证明一个数字是否是素数，和除了1和自身之外的中间数字进行整除
+
+# 代码
+# num = int(input('请输入一个数字:'))  # 输入的数字
+# flag = True  # 是否素数的标记(True素数，False不是素数)
+# if num < 2: # 最小的素数是 2
+#     flag = False # 不是素数
+# else: # 输出的数字肯定>=2
+#     # 判断是否是素数，用输出的数字和和除了1和自身之外的中间数字进行整除
+#     # 假设输入的是19   和2-18整除
+#     for i in range(2, num):
+#         if num % i == 0: # 能整除，不是素数
+#             flag = False
+#             break # 结束循环，有一个能整除，就说明不是素数，可以结束循环
+
+# 根据flag进行判断
+# if flag:
+#     print(f'{num}是素数')
+# else:
+#     print(f'{num}不是素数')

day11/04-作业.py

@@ -0,0 +1,36 @@
+# 一.输入一个日期，判断这个日期是这一年的第几天  例如： 2016/02/11，计算后结果为42
+# 2016/02/11  31(1月) + 11(2月) = 42
+# 2000/05/01  31(1月) + 29(2月) + 31(3月) + 30(4月) + 1(5月) = 122
+
+# 分析
+# 1.分别输出年月日
+# 2.区分大月：1,3,5,7,8,10,12 大月(31)
+# 3.区分小月：4,6,9,11 小月(2)
+# 4.区分闰年2月：(闰年29)  (平年28)
+
+# 代码
+# 分别输出年月日
+# year = int(input('请输入四位的年份：'))
+# month = int(input('请输入月份：'))
+# day = int(input('请输入今天是几号：'))
+
+# result = 0 # 存储结果
+# result += day # 先统计day
+
+# 通过条件统计大月，满足条件+31天
+# for m in range(1,month): # 这里不包括month本身
+#     if m == 1 or m == 3 or m == 5 or m == 7 or m == 8 or m == 10: # 满足大月的条件
+#         result += 31
+#     else: # 视为小月(2月也被视为小月)
+#         result += 30
+
+# 根据上面的代码描述，将2月也纳入小月，这样结果就扩大了1或者2(1月要么28要么29)
+# 根据闰年的条件进行减法运算，闰年-1，非闰年-2(前面将2月变成30天)
+# 主要前提：月份一定要大于2
+# if month > 2:
+#     if (year % 4 == 0 and year % 100 !=0) or (year % 400 ==0): # 闰年的条件
+#         result -= 1
+#     else :
+#         result -= 2
+   
+# print(f'你输入的年月日是{year}-{month}-{day} , 他是这一年的{result}天')

day11/05-作业.py

@@ -0,0 +1,47 @@
+# 一.1,2,3,4四个数字,能组合成多少种互不相同且没有重复的三位数.
+# 通过循环去不断的进行组合
+# 抓住限制条件
+# 核心就是循环的嵌套：外层循环一次，内层循环要全部完成一轮，依次类推...
+# 根据下面的案例：外层1次，内层10次，外层10次，内层100次，外层循环一次，内层全部完成一轮
+# for i in range(1,11): # 外层循环一次
+#     for j in range(1,11):# 内层循环十次，如果外层循环10次，内层循环100次
+#         print(end='')
+
+# 代码
+# 主要：组合成三位数
+# for i in range(1,5): # i=1,2,3,4
+#     for j in range(1,5): # j=1,2,3,4
+#         for k in range(1,5): # k = 1,2,3,4
+#             # num = i + j + k # 不能直接将数字进行相加,而是拼接成一个数字
+#             # num  = 100 * i + 10 * j + k  # 组合成三位数
+#             if i != j and j != k and i != k:# 互不相同
+#                 num = int(str(i) + str(j) + str(k))  # 转换成字符串进行拼接，最终变成字符串，可以继续转换
+#                 print(num,end=',')
+
+
+# 百钱白鸡，问：公鸡5元每只，母鸡3元每只，小鸡1元3只，100元买一百只鸡多少种办法？
+# 通过循环去不断的进行组合(循环组合抓住起点和终点)
+# 抓住限制条件
+
+# 比如：
+# 通过循环组合买公鸡，起点是买0只，终点是买20只(100/5=20)
+# 通过循环组合买母鸡，起点是买0只，终点是买33只(100/3)
+# 通过循环组合买小鸡，起点是买0只，终点是买100只(最多100只)
+
+# 最终死死的抓住条件
+# 假设公鸡：i只  母鸡：j只   小鸡：k只
+# 条件: i + j + k == 100     i*5 + j*3 + k*1/3 == 100
+
+# 代码
+for i in range(0,21): # 公鸡
+    for j in range(0,33): # 母鸡
+        for k in range(0,101): # 小鸡
+            if (i + j + k == 100) and (i*5 + j*3 + k*1/3 == 100):
+                print(f'你买了{i}只公鸡,{j}只母鸡,{k}只小鸡')
+
+"""
+你买了0只公鸡,25只母鸡,75只小鸡
+你买了4只公鸡,18只母鸡,78只小鸡
+你买了8只公鸡,11只母鸡,81只小鸡
+你买了12只公鸡,4只母鸡,84只小鸡
+"""

day12/01-作业.py

@@ -0,0 +1,14 @@
+# 鸡兔同笼，问：鸡兔同笼35个头94只脚用 鸡有多少只兔有多少只?
+# 通过循环去不断的进行组合(鸡和兔子区间范围0--35)
+# 抓住限制条件(35个头94只脚用)
+
+for i in range(0,36): # 通过循环去不断的进行组合   鸡
+    for j in range(0,36): # 通过循环去不断的进行组合  兔
+        if (i + j == 35) and (i * 2 + j * 4 == 94):
+            print(f'鸡有{i}只，兔子有{j}只')
+            
+            
+            
+            
+            
+            

day12/02-作业.py

@@ -0,0 +1,49 @@
+# 1. 计算数列的和
+numbers = [2, 4, 6, 8, 10]
+total = 0
+for num in numbers:
+    total += num
+print(f"数列的和是 {total}")
+
+# 2. 统计字符串中字符出现的次数
+s = input("请输入字符串：")
+char_count = {}
+for char in s:
+    char_count[char] = char_count.get(char, 0) + 1
+
+for char, count in char_count.items():
+    print(f"{char}: {count}")
+
+# 3. 找出列表中的所有偶数
+lst = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+even_numbers = []
+for num in lst:
+    if num % 2 == 0:
+        even_numbers.append(num)
+
+print("偶数有：", *even_numbers)
+
+# 4.计算列表中所有数字的平方
+lst = [1, 2, 3, 4, 5]
+squared_list = []
+for num in lst:
+    squared_list.append(num ** 2)
+
+print(f"平方后的列表是：{squared_list}")
+
+# 5.计算字符串的反向
+s = input("请输入一个字符串：")
+reversed_str = ""
+for char in s:
+    reversed_str = char + reversed_str
+
+print(f"反转后的字符串是：{reversed_str}")
+
+# 6.找出数组中的重复元素
+arr = [1, 2, 3, 4, 2, 5, 3]
+duplicates = []
+for i in range(len(arr)):
+    if arr[i] in arr[:i] and arr[i] not in duplicates:
+        duplicates.append(arr[i])
+
+print("重复的元素有：", *duplicates)

day12/03-总结.py

@@ -0,0 +1,84 @@
+# 梳理前面的核心内容
+# 1.电脑必须安装编译器 + python插件，保证电脑能够执行python程序
+
+# 2.变量和常量的概念
+# num = 100 # 变量(值可以改变)
+# COUNT = 200 # 常量(值约定不能改变)，约定常量的名称全部大写
+
+# 3.常用的值的六种类型
+# 数字类型：包括整数,小数,布尔值...
+num = 100 # 整数
+fnum = 3.14 # 小数
+b = True # 布尔值，只有两个值True/false表示真/假
+
+# 字符串类型：引号包裹的，里面可以是数字，字母，一些特殊符号，中文...
+str = 'hello'
+name = '张三'
+
+# 列表类型(后面讲)
+# 元组类型(后面讲)
+# 集合类型(后面讲)
+# 字典类型(后面讲)
+
+# 4.python自带的内置函数
+# print() 控制面板输出
+print('你好世界')
+# input() 控制面板输入
+username = input('请输入你的名称：')
+# int() 将括号里面的值转换成整数，主要字符串不能进行转换
+# float()  将括号里面的值转换成小数，主要字符串不能进行转换
+# str() 将括号里面的值转换成字符串
+# type() 输出括号里面值的类型
+
+
+# 5.运算符
+# 算术运算符：
+# +：加
+# -：减
+# *：乘
+# /：除
+# %：取余
+# //：取除法商的整数部分
+# **：求幂(次方)
+
+# 赋值运算符
+# =
+
+# 复合的赋值运算符(简化的写法)
+# +=    num = num + 1  ==>   num += 1
+# -=    num = num - 1  ==>   num -= 1
+# *=    num = num * 1  ==>   num *= 1
+# /=
+# %=
+# //=
+# **=
+
+# 比较运算符
+# == ：等于，相当于数学里面的(=)
+# != : 不等于
+# >
+# <
+# >=
+# <=
+
+# 6.注释
+# 代码或者文字前面添加一个#，表示单行注释
+# 代码或者文字前后添加三个引号(""")，表示多行注释
+
+# 7.分支语句
+# if语句的三种结构
+# if                           单分支(一个条件)
+# if...else...                 双分支(两个条件)
+# if...elif...elif...else      多分支(多个条件)
+
+# 8.循环语句
+# 循环的意义：重复 + 有规律
+# while循环的基本结构和组成
+# num = 1 # 1.初始值
+# while num <= 10: # 2.限制条件
+#     print(num) # 循环体
+#     num += 1   # 循环体(迭代/累加/累减)
+   
+# for循环的基本结构和组成
+# for num in range(1,11):  # num:临时变量  range(1,11):循环数据集的序列(生成1-10这10个数)
+#     print(num) # 循环体

day12/04-数据容器的入门.py

@@ -0,0 +1,29 @@
+# 一、数据容器
+# 数据容器就是一种可以容纳多种数据的数据类型 容纳的每一个数据被称为元素
+# 每一个数据 可以是任意数据类型 如字符串 数字 布尔值等等
+
+# 二、数据容器的部分特点
+# 1、所有的数据容器可以容纳多份数据
+num=100 # 一个数据
+names=['zhangsan','lisi','wangsan'] #多份数据 容器
+
+# 2、是否支持重复数据
+# 有些容器里面不支持重复数据 有些支持 注意区别
+
+# 3、是否可以修改
+# 有些容器里面可以支持修改数据 有些不支持 注意区别
+
+# 4、是否有序
+# 有些容器里面的数据是有顺序的 有些没有顺序 注意区别
+
+# 总结:注意区别是否支持重复 是否能够修改 是否有序
+
+# 三、数据容器有5类
+# 列表(list)
+# 元祖(tuple)
+# 字符串(str)
+# 集合(set)
+# 字典(dict)
+
+
+

day12/05-列表的创建索引.py

@@ -0,0 +1,51 @@
+# 数据容器-列表
+# 1、列表的描述
+# 列表(list) 由一系列按照特定的顺序排列的元素组成的
+# 列表通常包含多个元素的 因此给列表指定一个表示复数的名称是一个不错的主意
+# 建议 可以使用复数的名称来表示 也可以采用'List'拼接指定的名称
+# 比如 letters / names / list_name
+
+# 2、列表的定义方式
+# 在Python中 用方括号[]来表示列表 用逗号分割其中的元素
+list_names=['李一','张三','李四']
+list_nums=[100,200,300,400]
+print(list_names,list_nums)
+# 注意 列表里面的每一个数据被称为元素
+
+# 3、输出列表的值和类型
+print(list_names)
+print(type(list_names)) #<class 'list'>
+
+# 4、下标索引(读取以及修改元素的值)
+# 也就是是 列表的每一个元素都有一个编号 而且编号是有顺序的 从左到右 默认从0开始 依次累加
+list_names=['李一','张三','李四','老王','wangwu']
+print(list_names[0])
+print(list_names[1])
+print(list_names[2])
+print(list_names[3])
+print(list_names[4])
+# print(list_names[5]) # 报错 列表索引超出了范围
+
+# 修改元素的值
+list_names=['李一','张三','李四','老王','wangwu']
+list_names[1]='尼古拉斯'
+print(list_names)
+
+# 5、反向索引
+# 也就是从后到前 从-1开始 依次累加 -2 -3 -4...
+list_names=['李一','张三','李四','老王','wangwu']
+print(list_names[-1])
+print(list_names[-2])
+print(list_names[-3])
+print(list_names[-4])
+print(list_names[-5])
+
+# 6、列表可以存储多个数据 并且可以存储不同的数据类型 同时支持嵌套
+# 支持嵌套 列表里面可以支持列表
+list_nums=[[4,5,6],[6,7,8],[10,11]]
+print(list_nums[0])
+print(list_nums[0][0])
+
+# 案例 多维列表 通过索引获取数字9
+list = [1, [2,3, [4, [5,6, [7,8, [9,10]]]]]]
+print(list[1][2][1][2][2][0]) #一层一层的扒开 通过下标找到对应的数字

day12/06-综合练习10.py

@@ -0,0 +1,32 @@
+# 1. 计算 1 到 100 中所有奇数的平方和
+# 编写一个程序，计算 1 到 100 之间所有奇数的平方和。
+
+# 2. 找出列表中的最大值和最小值
+# 给定一个包含整数的列表，编写程序找出列表中的最大值和最小值。
+
+# 3. 统计句子中单词的长度
+# 给定一个句子，统计每个单词的长度，并输出长度大于 3 的单词及其长度。
+
+# 4. 打印 1 到 100 之间的所有素数
+# 编写一个程序，打印出 1 到 100 之间的所有素数。
+
+# 5. 计算列表中所有正数的平均值
+# 给定一个包含整数的列表，计算列表中所有正数的平均值。
+
+# 6. 找出字符串中出现次数最多的字符
+# 给定一个字符串，找出其中出现次数最多的字符。
+
+# 7. 生成一个乘法表（指定范围）
+# 编写一个程序，生成一个指定范围（例如 3 到 7）的乘法表。
+
+# 8. 检查列表是否为升序排列
+# 给定一个列表，检查列表是否按升序排列。
+
+# 9. 计算两个列表对应元素的和
+# 给定两个列表，计算它们对应元素的和，并将结果存储在一个新的列表中。
+
+# 10. 找出嵌套列表中所有偶数的和
+# 给定一个嵌套列表，找出其中所有偶数的和。
+
+
+

day13/00-列表的创建和索引.py

@@ -0,0 +1,55 @@
+# 数据容器 - 列表
+# 1.列表的描述
+# 列表(list)由一系列按特定顺序排列的元素(字母数字中文...)组成。
+# 列表通常包含多个元素，因此给列表指定一个表示复数的名称(如letters/names)是个不错的主意
+# 建议：可以使用复数的名称表示，也可以采用"list_"拼接特定的名称
+# 比如：letters / names / list_name
+
+# 2.列表的定义方式
+# 在 Python 中，用方括号([])表示列表，用逗号分隔其中的元素
+list_nums = [100,200,300,400,500]
+list_names = ['刘一','陈二','张三','李四','wangwu',123]
+# 注意：列表内的每一个数据，称之为元素
+
+# 3.输出列表的值和类型
+print(list_nums) # [100, 200, 300, 400, 500]
+print(type(list_nums))  # <class 'list'>
+
+# 4.下标索引(读取以及修改元素的值) 
+# 也就是说，列表中的每一个值都有一个编号，而且编号是有序的，从左往右，默认从0开始，依次递增
+list_names = ['刘一','陈二','张三','李四','wangwu']
+
+# 可以通过索引编号获取(修改)列表里面的某一个值
+print(list_names[0]) # 刘一    获取列表下标索引为0的哪一项值
+print(list_names[1]) # 陈二
+print(list_names[2]) # 张三
+print(list_names[3]) # 李四
+print(list_names[4]) # wangwu
+# print(list_names[5]) # 报错，列表索引超出了范围
+
+# 可以通过索引编号修改列表里面的某一个值
+list_names = ['刘一','陈二','张三','李四']
+list_names[1] = '尼古拉斯陈二'  # 修改索引下标为1的元素的值
+print(list_names) # ['刘一', '尼古拉斯陈二', '张三', '李四']
+
+# 5.反向索引
+# 也就是从后向前，从-1开始，依次类推-2,-3,-4...
+list_names = ['刘一','陈二','张三','李四','王五']
+print(list_names[-1]) # 王五
+print(list_names[-2]) # 李四
+print(list_names[-3]) # 张三
+print(list_names[-4]) # 陈二
+print(list_names[-5]) # 刘一
+
+# 6.列表可以一次存储多个数据，且可以为不同的数据类型，同时支持嵌套
+# 列表的嵌套：列表里面存在列表
+list_nums = [[4,5,6],[7,8],[10,11]] # 列表中存在三个元素，但是每个元素依然是列表
+# 获取嵌套列表的值，依然是通过索引下标完成
+print(list_nums[0]) # [4, 5 ,6] 通过第一个索引下标获取对应的值，对应的值依然是一个列表，继续通过索引获取
+print(list_nums[0][0]) #4 一旦看到出现两个或以上索引下标，说明列表里面一定嵌套有列表
+print(list_nums[0][1]) #5
+print(list_nums[0][2]) #6
+
+# 例如：多维列表，通过索引获取数字9
+list = [1, [2,3, [4, [5,6, [7,8, [9,10]]]]]]
+print(list[1][2][1][2][2][0]) # 一层一层的扒开，通过下标找到对应的数字

day13/01-列表的操作.py

@@ -0,0 +1,35 @@
+# 1、修改列表里面某个元素的值
+list=[100,200,300,400,500]
+list[2]=3
+print(list)
+
+# 2、上面的方式是修改一个值 下面的方式是修改一堆(区间)值
+list=[0,1,2,3,4,5,6,7,8,9]
+list[1:5]=[100,200,300,400] #一一替换(不包含5的位置)
+print(list)
+
+# 3、在上面的基础上 添加步长
+list=[0,1,2,3,4,5,6,7,8,9]
+list[1:9:2]=['奇数','奇数','奇数','奇数'] #步长为2 从1开始 隔一个替换一个
+print(list)
+list[0:10:4]=['零','零','零']
+print(list)
+
+# 4、重复(字符串也可以)
+list=[1,2,3]
+print(list*3) #将list里面的元素重复了三次 放到新的列表中
+print(list)
+
+# 5、列表拼接(字符串也可以)
+list=[12,13,14]
+# print(list+4) #报错 列表拼接 不能是具体的某个整数
+print(list+[4,5,6])
+print(list+[4,5,6]+[20,30,40,50])
+
+
+
+
+
+
+
+

day13/02-列表的常用方法.py

@@ -0,0 +1,42 @@
+# 一.什么是方法
+# 在python里面一切皆对象，列表(list)也是一个对象
+# 对象一般由属性 + 方法 组成
+# 属性是用来描述对象的外观,特点,可以通过点符号来访问(python提供的很少)
+# 方法是用来描述对象的功能,方法和函数一样,后面有一个放参数的括号,方法也是函数实现的
+# 访问方法也是通过点符号实现  例如：list.index()   list是对象，index就是方法
+
+# 二.列表中的常用方法
+# 1、list.index(元素) 查找指定元素在列表下的索引 如果找不到那么就报错
+list=['zhangsan','lisi','wangwu']
+print(list.index('lisi'))
+# print(list.index('jack')) #报错
+
+# 2、list.append(x) 将x作为一个元素添加到列表list里面(x可以是列表或者元素)
+list=['a','b']
+list.append('c')
+list.append('d')
+list.append(['e','f','g'])
+print(list)
+
+# 案例 创建一个列表 里面是0开始的偶数 一直到100
+list=[] #创建一个空列表
+for num in range(0,101): # 循环1-100
+  if num % 2==0: # 选择1-100的偶数
+    list.append(num) # 将偶数追加到列表中
+print(list)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

day13/03-练习.py

@@ -0,0 +1,33 @@
+# 题目 1：添加元素并查找索引
+# 有一个列表 fruits = ['apple', 'banana', 'cherry']，需要添加 'date' 和 'elderberry' 到列表末尾，然后找出 'cherry' 在列表中的索引。
+fruits = ['apple', 'banana', 'cherry']
+fruits.append('date')
+fruits.append('elderberry')
+index = fruits.index('cherry')
+print(index)
+
+# 题目 2：添加元素并处理重复元素索引
+# 有一个列表 numbers = [1, 2, 3, 2, 4, 2]，添加数字 5 到列表末尾。然后找出数字 2 在列表中第一次出现的索引和最后一次出现的索引。
+numbers = [1, 2, 3, 2, 4, 2]
+numbers.append(5)
+first_index = numbers.index(2)
+last_index = len(numbers) - numbers[::-1].index(2) - 1
+print(f"数字 2 第一次出现的索引是: {first_index}")
+print(f"数字 2 最后一次出现的索引是: {last_index}")
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

day14/01-列表的方法.py

@@ -0,0 +1,54 @@
+# 1、list.extend() 将列表中的元素增加到列表中去
+list=['a','b']
+list.append('c')
+list.append(['d','e'])
+print(list)
+
+list=['a','b']
+list.extend('c')
+list.extend(['d','e'])
+print(list)
+
+# 2、删除相关的方法
+# list.pop(x)
+# 如果括号里面没有写参数 默认删除最后一项
+# 如果括号里面写了参数 将列表中的第x个元素取除并且删除该元素
+list=['a','b','c','d']
+print(list.pop())
+print(list)
+print(list.pop(2))
+print(list)
+
+# list.remove(x) 将列表中出现的第一个元素x删除
+list=['a','b','c','d','e','f','g']
+list.remove('c') #删除第一个c字符 整个方法没有返回值 注意pop()有返回值
+print(list)
+
+# list.clear() 删除所有的元素
+list=['a','b','c','d','e']
+list.clear()
+print(list)
+
+# 3、插入元素
+# list.insert(i,x) 在列表的第i个位置插入字符x
+list=['a','b','c','d']
+list.insert(1,'x') #在下标为1的位置插入字符x
+print(list)
+
+list=['a','b','c']
+list.insert(1,['x','y','z']) #在下标为1的位置插入多个字符x y z
+print(list)
+
+# 4、list.reverse() 将列表list里面的元素反转原地保存
+list=['a','b','c','d']
+list.reverse()
+print(list)
+
+# 5、list.sort() 将列表list里面的元素排序
+list=[12,3,1,78,88,90,34,56]
+list.sort(reverse=False) #默认升序 参数可以省略
+print(list)
+
+list=[1,2,36,7,89,100,34,78]
+list.sort(reverse=True) #降序排序
+print(list)

day14/02-列表的方法.py

@@ -0,0 +1,18 @@
+# 1、统计某元素在列表中的数量
+# list.count(元素)
+list=[1,2,3,34,5,6,7,888,99,1,1,1,1,4,5,7]
+print(list.count(1))
+
+# 2、和列表相关的函数
+# len() 统计长度
+list=['a','b','c','d']
+print(len(list))
+
+# sorted 是sort()函数的扩展 可以对列表的元素排序 同时不会修改原列表
+list=[12,2,3,4,46,78,7,8,9,20,35]
+print(sorted(list))
+
+
+
+
+

day14/03-列表方法的总结.py

@@ -0,0 +1,33 @@
+# 总结列表的常用方法：
+
+# 1.list.index(元素) : 找对应元素的索引,如果没有找到就报错
+# 2.list.append(元素或者列表) : 将对应的元素或者列表放到列表的后面
+# 3.list.extend(元素或者列表) : 功能和上面的append一样
+# 4.list.pop(索引) : 删除索引位置的元素，如果没有设置索引，默认删除最后一个元素
+# 5.list.remove(元素) : 删除列表中第一个和括号里面值相同的元素
+# 6.list.clear() : 删除列表中的所有元素
+# 7.list.insert(索引,插入的元素或列表) : 在对应的索引位置插入元素或者列表
+# 8.list.reverse() : 反转列表里面的所有元素
+# 9.list.sort(reverse=True) : 排序,默认是升序无需参数，如果是降序，就要设置参数reverse=True
+# 10.list.count(元素) : 统计列表中某个元素出现的次数
+
+
+# 函数
+# len(列表) : 统计列表中元素的个数
+# sorted(列表) : 排序列表，和list.sort类型，但是sorted不改变原列表
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

day14/04-列表的应用.py

@@ -0,0 +1,70 @@
+# 1.定义一个包含 5 个整数的列表。计算列表中所有元素的和与平均值，并输出结果。
+# sum()函数：将列表里面所有元素的和求出
+# len()函数：列表中所有元素的个数
+# numbers = [10, 20, 30, 40, 50]
+# print(sum(numbers)) # 列表所有元素的和 150
+# print(sum(numbers) / len(numbers)) # 列表所有元素的平均值 30.0
+
+
+# 2.创建一个包含水果名称的列表，输入一个水果名称，判断该水果是否在列表中，并输出该水果在列表中的位置
+# fruits = ["apple", "banana", "orange", "grape", "mango"] # 水果列表
+# f = input("请输入要查找的水果: ") # 输入的水果
+
+# in 操作符：判断当前的输入的元素是否存在当前的列表中，如果存在获取对应的位置，否则提示不存在
+# print('apple' in fruits)  # True
+# print('pear' in fruits) # False
+
+# if f in fruits: # 满足条件，说明当前输入的水果存在水果列表中
+#     i = fruits.index(f) # 求输入的水果在水果列表的位置
+#     print(f'你输入的水果存在{fruits}列表中,它的位置是{i}')
+# else: # 当前输入的水果不存在水果列表中
+#     print(f'你输入的{f},不存在水果列表{fruits}中')
+   
+
+# 3.定义一个包含若干整数的列表，对其进行升序和降序排序
+# 注意：sort方法没有返回值,改变原列表
+# numbers = [42, 15, 23, 4, 16, 8]
+# numbers.sort() # 默认升序排列
+# print(numbers) # [4, 8, 15, 16, 23, 42]
+# numbers.sort(reverse=True) # 降序排列
+# print(numbers) # [42, 23, 16, 15, 8, 4]
+
+# 4.创建一个包含从1到100的所有偶数的列表，并将每个偶数乘以3
+# 追加：append
+# 创建1-100的所有偶数的列表
+# list = [] # 自定义的空列表
+# for num in range(1,101): # 循环1-100
+#     if num % 2 == 0: # 偶数
+#         list.append(num * 3) # 将1-100里面的偶数先乘以3，再加入新列表中
+# print(list)
+
+
+# 5.创建一个3x3的嵌套数字列表，并计算所有元素的总和
+# sum():将列表里面的所有元素求和
+# len():求列表中元素的个数
+# nums = [[1,2,3],[4,5,6],[7,8,9],[10,10,10],[1,2,3,4,5,6,7,8,9,10]] # 定义的列表
+# print(sum(nums[0]))
+# print(sum(nums[1]))
+# print(sum(nums[2]))
+# 根据上面的分析，里面的索引是有规律(循环)
+# result = 0
+# for i in range(0,len(nums)): # 根据列表的长度进行循环
+#     result += sum(nums[i]) # 累加
+
+# print(result)
+
+
+# 6.创建一个包含20个整数的列表，输出列表的前5个元素和后5个元素
+# 通过循环创建20各整数的列表
+list = [] # 定义一个空列表，存放下面循环生成的20个整数
+for i in range(1,21):
+    list.append(i)
+
+print(list) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
+# 利用列表操作中的冒号(:)进行区间的获取
+# print(list[0:5]) # 左闭右开(包括左闭的0，不包括右边的5) [1, 2, 3, 4, 5]
+print(list[   : 5]) # 如果冒号左边是到开始位置，可以省略(其实索引位置可以省略)
+print(list[-5 :  ]) # 如果冒号右边是到结束位置，可以省略(-5表示开始的索引位置，负数表示从后往前)
+
+
+

day15/01-作业.py

@@ -0,0 +1,91 @@
+# 1. 列表求和
+lst = [1, 2, 3, 4, 5]
+total = sum(lst)
+print(f"列表的和是 {total}")
+
+# 2. 找出列表中的最大值
+lst = [1, 2, 3, 4, 5]
+max_value = max(lst)
+print(f"列表中的最大值是 {max_value}")
+
+# 3. 找出列表中的最小值
+lst = [3, 1, 4, 1, 5]
+min_value = min(lst)
+print(f"列表中的最小值是 {min_value}")
+
+# 4. 列表元素去重
+lst = [1, 2, 2, 3, 4, 4, 5]
+unique_lst = list(set(lst))
+print(f"去重后的列表是 {unique_lst}")
+
+# 5. 计算列表中的元素个数
+lst = [1, 2, 3, 4, 5]
+count = len(lst)
+print(f"列表中元素的个数是 {count}")
+
+# 6. 反转列表
+lst = [1, 2, 3, 4, 5]
+reversed_lst = lst[::-1]
+print(f"反转后的列表是 {reversed_lst}")
+
+# 7. 合并两个列表
+lst1 = [1, 2, 3]
+lst2 = [4, 5, 6]
+merged_lst = lst1 + lst2
+print(f"合并后的列表是 {merged_lst}")
+
+# 8. 计算列表中元素的平均值
+lst = [1, 2, 3, 4, 5]
+average = sum(lst) / len(lst)
+print(f"列表的平均值是 {average}")
+
+# 9. 查找列表中指定元素的索引
+lst = [10, 20, 30, 40, 50]
+element = 30
+if element in lst:
+    index = lst.index(element)
+    print(f"元素 {element} 的索引是 {index}")
+else:
+    print(f"元素 {element} 不在列表中")
+
+# 10. 列表中的元素求积
+lst = [1, 2, 3, 4]
+product = 1
+for num in lst:
+    product *= num
+print(f"列表元素的积是 {product}")
+
+# 11.判断列表是否为空
+lst = []
+if not lst:
+    print("列表为空：True")
+else:
+    print("列表为空：False")
+
+# 12. 删除列表中的指定元素
+lst = [1, 2, 3, 2, 4]
+element_to_remove = 2
+while element_to_remove in lst:
+    lst.remove(element_to_remove)
+print(f"删除后的列表是 {lst}")
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

day15/02-列表的遍历.py

@@ -0,0 +1,31 @@
+# 一、列表的遍历
+# 列表是一个容器 可以存储多个数据 如果需要按照需求依次取出元素进行操作 那么就需要遍历
+
+list=['apple','banana','orange','grape']
+# 下标是有序的并且有规律的 使用循环进行操作
+# len函数 获取列表的元素个数 通过len函数设置循环遍历的条件
+
+# while循环
+index=0
+while index<len(list):
+  print(list[index])
+  index +=1
+  
+# for循环
+for v in list:
+  print(v)
+  
+# 二、对比while循环和for循环
+# while循环和for循环，都是循环语句，但细节不同
+
+# 1.在循环条件控制上:
+# while循环可以自定循环条件，并自行控制
+# for循环不可以自定循环条件,只可以一个个从容器内取出数据
+
+# 2.在无限循环上:
+# while循环可以通过条件控制做到无限循环
+# for循环理论上不可以，因为被遍历的容器容量不是无限的
+
+# 3.在使用场景上:
+# while循环适用于任何想要循环的场景
+# for循环适用于遍历数据容器的场景 或 简单的固定次数循环场景

day15/03-列表遍历的应用.py

@@ -0,0 +1,30 @@
+# 列表遍历的应用
+
+# 1.创建一个列表，里面包含1-100里面的偶数，每5个数求平均数，且把求的平均值放到一个新列表中.
+# 分析
+# 第一步：生成一个列表里面是1-100的偶数
+list = [] # 存放1-100的偶数
+for i in range(1,101): # 循环产生1-100
+    if i % 2 == 0: # i是偶数
+        list.append(i) # 将偶数逐个追加到list列表中
+print(list)
+# [2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100]
+
+# 第二步：列表里面每5个数求平均数，追加给一个新的列表
+# 分析列表，通过索引下标找到计算平均值的结束点
+# 必须对列表进行遍历
+result = 0 # 累加初始值
+new_list = [] # 存放平均数的新列表
+for index in range(len(list)): # 遍历列表，同时需要列表的索引 (index 每一个元素的索引)
+    result += list[index] # 累加所有列表的值
+    if (index + 1) % 5 == 0: # 求平均数的结束点
+        new_list.append(result / 5) # 求平均值，放到新的列表中
+        result = 0 # 一旦求得平均值，重置result，下次重新开始计算
+       
+print(new_list) # [6.0, 16.0, 26.0, 36.0, 46.0, 56.0, 66.0, 76.0, 86.0, 96.0]
+
+
+
+
+
+

day15/04-列表的遍历练习.py

@@ -0,0 +1,59 @@
+# 1. 打印列表中的偶数
+# 给定一个整数列表，遍历该列表并打印出其中所有的偶数。
+numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+for num in numbers:
+    if num % 2 == 0:
+        print(num)
+        
+# 1. 打印列表中的偶数
+# 给定一个整数列表，遍历该列表并打印出其中所有的偶数。
+numbers = [10, 20, 30, 40, 50]
+total = 0
+for num in numbers:
+    total = total + num
+print(total)
+
+# 3. 找出列表中的最小元素
+# 给定一个整数列表，遍历该列表找出其中最小的元素并打印出来。
+numbers = [23, 12, 45, 6, 34]
+min_num = numbers[0]
+for num in numbers:
+    if num < min_num:
+        min_num = num
+print(min_num)
+
+# 4. 生成新列表，包含原列表元素的平方
+# 有一个整数列表，遍历该列表，将每个元素进行平方运算，然后将结果存储到一个新列表中，最后打印新列表。
+numbers = [1, 2, 3, 4, 5]
+squared_numbers = []
+for num in numbers:
+    squared_numbers.append(num ** 2)
+print(squared_numbers)
+
+# 5. 统计列表中每个元素出现的次数
+# 给定一个包含重复元素的列表，遍历该列表统计每个元素出现的次数，并将结果以字典的形式打印出来，字典的键为列表中的元素，值为该元素出现的次数。
+fruits = ['apple', 'banana', 'apple', 'cherry', 'banana', 'apple']
+fruit_count = {}
+for fruit in fruits:
+    if fruit in fruit_count:
+        fruit_count[fruit] = fruit_count[fruit] + 1
+    else:
+        fruit_count[fruit] = 1
+print(fruit_count)
+
+# 6. 合并两个列表中的元素，按顺序交替插入
+# 有两个列表 list1 和 list2，遍历这两个列表，将它们的元素按顺序交替插入到一个新列表中。如果其中一个列表较长，将其剩余元素直接添加到新列表的末尾，最后打印新列表。
+list1 = [1, 3, 5]
+list2 = [2, 4, 6, 8]
+merged_list = []
+min_len = min(len(list1), len(list2))
+for i in range(min_len):
+    merged_list.append(list1[i])
+    merged_list.append(list2[i])
+
+if len(list1) > len(list2):
+    merged_list.extend(list1[min_len:])
+else:
+    merged_list.extend(list2[min_len:])
+
+print(merged_list)

day15/05-元祖.py

@@ -0,0 +1,28 @@
+# 容器的三大特征 是否有序 是否可以读写 是否可以有重复值
+
+# 数据容器 - 元祖
+# 元祖同列表一样 可以封装多个不同类型的元素 但是最大的不同点在于元祖一但定义之后不能修改
+
+# 1、定义元祖
+# 定义元祖的时候用小括号 用逗号隔开 数据可以是不同类型的
+t1=('zhangsan','lisi','wangwu')
+t2=('apple',) #如果只有一个值 也要添加逗号 否则不是元祖(列表没有关系)
+print(t1)
+print(t2)
+print(type(t1)) #<class 'tuple'>
+
+# 2、读写元祖的值
+# 读 获取 可以通过下标来获取对应的值
+print(t1[0])
+print(t1[1])
+print(t1[2])
+# print(t1[3]) #报错 没有对应的值
+
+# 写 修改
+# t1[0]='张三'
+# print(t1) #报错 元祖里面的元素不能被修改
+
+# 3、可以封装多个不同类型的元素 元祖的嵌套使用
+t1=(('zhangsan','lisi','wangwu'),('apple','orange'),('jack','tom'))
+print(t1[0])
+print(t1[0][1])

day16/01-元祖的操作.py

@@ -0,0 +1,31 @@
+# 一、元祖的操作符
+# 1、+ 和 *
+t1=(1,2,3)
+t2=(4,5,6)
+print(t1+t2) #拼接
+print(t1+(7,8,9)) #拼接
+print(t1*4) #重复
+
+# 2、in操作符(列表也可以) 检测当前的元素是否在元祖或者列表中
+t1=('apple','orange','mango')
+print('orange' in t1) #True
+print('pear' in t1) #False
+
+# 二、元祖和列表的混合使用
+t1=('zhangsan',['a','b','c'])
+# 修改b字符
+print(t1[1])
+print(t1[1][1])
+t1[1][1]='B'
+print(t1) #这里修改的不是元祖 而是元祖里面列表的值
+
+# 三、元祖的遍历
+# 遍历 逐步获取元祖的每一个元素进行操作
+nums=(1,2,3,4,5,6,7,8,9,10)
+for v in nums:
+  print(v * 100,end=',') #定义一个元祖 将值扩大100倍
+  
+  
+  
+  
+  

day16/02-元祖和列表的转换.py

@@ -0,0 +1,17 @@
+# 元祖和列表的转换
+# 1、list() list函数 将括号里面的值(可遍历的)转为列表
+print(list('hello')) #['h', 'e', 'l', 'l', 'o'] 将字符串转为列表
+# print(list(100)) #报错 不能是数字
+print(list((1,2,3,4,5,6,7))) #[1, 2, 3, 4, 5, 6, 7] 将元祖转为列表
+
+# 2、tuple() tuple函数 将括号里面的值(可遍历的)转为元祖
+print(tuple('hello')) #('h', 'e', 'l', 'l', 'o') 将字符串转为元祖
+print(tuple([1,2,3,4,5,6,7])) #(1, 2, 3, 4, 5, 6, 7) 将列表转为元祖
+
+# 3、复习
+# int() 将括号里面的值转为整数 值一般是字符串格式的数字或者小数
+# float() 将括号里面的值转为小数 值一般是字符串格式的数字或者真正的数字
+# str() 将括号里面的值转为字符串
+# bool() 将括号里面的值转为布尔值(True / False)
+
+

day16/03-元祖的方法和函数.py

@@ -0,0 +1,22 @@
+# 元祖的常用方法
+# 1、index() 查找某个元素 如果数据存在返回对应的下标 否则报错
+t1=('banana','apple','mango','pear','orange')
+print(t1.index('orange')) # 4 输出对应元素的下标
+# print(t1.index('hehe')) # 报错 
+
+# 2、count() 统计某个数据在当前元祖中出现的次数
+t1=('apple','apple','apple','orange','pear')
+print(t1.count('apple')) #3
+print(t1.count('hehe')) #0
+
+# 元祖的常用函数
+# 1、len() 统计元祖中元素的个数 / 统计元祖的长度
+t1=('apple','apple','apple','orange','pear','orange')
+print(len(t1))
+
+# 2、sorted() 排序 排序元祖返回的是列表
+t2=(12,4,67,8,10,1)
+print(sorted(t2)) #升序
+print(sorted(t2,reverse=True)) #降序
+
+

day16/04-元祖的应用.py

@@ -0,0 +1,42 @@
+# 1.创建两个元组，分别包含城市名和对应的国家名，将它们组合成一个列表，格式为"城市 - 国家"。
+# 第一步：创建两个元组(国家名，城市名)
+country = ('中国','日本','韩国')
+city = ('北京','东京','首尔')
+
+# 第二步：进行组合
+# 两个元组相互对应的，使用相同的索引进行遍历(0,1,2)
+# 将它们组合成一个列表
+list = []
+for index in range(0,len(country)): # 通过索引遍历对应的值
+    # 格式为"城市 - 国家"
+    # city[index]:城市   country[index]:国家
+    list.append(city[index] + '-' + country[index])  #将拼接好的格式追加到列表中
+   
+# print(list) # ['北京-中国', '东京-日本', '首尔-韩国']
+   
+
+# 2.创建一个包含3个元组的列表，每个元组包含一个人的姓名和年龄。将所有人的姓名提取到一个新的列表中。
+# 第一步：创建一个包含3个元组的列表，姓名和年龄
+list = [('zhangsan',20),('lisi',18),('wangwu',30)]
+
+# 第二步：将所有人的姓名提取到一个新的列表中
+
+# 直接循环这个列表
+# 遍历列表，列表的每一个元素都是元组，可以对元组用逗号进行直接获取
+# a,b,c = (1,2,3)  # 将1给a，2给b，3给c ,逗号进行多个变量的赋值
+# print(a,b,c)# 1 2 3
+
+# a,b,c = [4,5,6]
+# print(a,b,c) # 4,5,6  逗号进行多个变量的赋值
+
+new_list = []
+for name,age in list:
+    new_list.append(name)
+print(new_list) # ['zhangsan', 'lisi', 'wangwu']
+
+# 准备的列表
+list = [('zhangsan',20),('lisi',18),('wangwu',30)]
+new_list = [] # 准备的新列表，接收列表中的姓名
+for item in list : # item:列表中的每一个元素，list:列表对象
+    new_list.append(item[0])
+print(new_list) # ['zhangsan', 'lisi', 'wangwu']

day16/05-元祖的练习.py

@@ -0,0 +1,62 @@
+# 练习1 创建元组并打印元素
+# 创建一个包含 5 个整数的元组，然后打印出该元组的第 3 个元素。
+numbers = (1, 2, 3, 4, 5)
+print(numbers[2])
+
+# 练习2 元组的拼接
+# 创建两个元组，将它们拼接成一个新的元组并打印。
+tuple1 = (1, 2, 3)
+tuple2 = (4, 5, 6)
+combined_tuple = tuple1 + tuple2
+print(combined_tuple)
+
+# 练习3 元组的重复
+# 创建一个元组，将其重复 3 次并打印结果。
+original_tuple = ('a', 'b')
+repeated_tuple = original_tuple * 3
+print(repeated_tuple)
+
+# 练习4 元组的切片操作
+# 创建一个包含 10 个元素的元组，使用切片操作提取出第 3 到第 7 个元素组成新的元组并打印。
+long_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+sliced_tuple = long_tuple[2:7]
+print(sliced_tuple)
+
+# 练习5 检查元素是否在元组中
+# 创建一个元组，检查某个特定元素是否存在于该元组中，并打印相应的结果信息。
+animals = ('dog', 'cat', 'bird', 'fish')
+target = 'cat'
+if target in animals:
+    print(f"{target} 在元组中。")
+else:
+    print(f"{target} 不在元组中。")
+   
+# 练习6 计算元组长度
+# 创建一个元组，计算它的长度并打印结果。
+mixed_tuple = (1, 'hello', True, 3.14)
+length = len(mixed_tuple)
+print(f"元组的长度是 {length}。")
+
+# 练习7 查找元素的索引
+# 创建一个元组，查找某个元素第一次出现的索引位置并打印。若元素不存在，打印提示信息。
+letters = ('a', 'b', 'c', 'b')
+search = 'b'
+if search in letters:
+    index = letters.index(search)
+    print(f"{search} 第一次出现的索引是 {index}。")
+else:
+    print(f"{search} 不在元组中。")
+   
+# 练习8 统计元素出现次数
+# 创建一个元组，统计某个元素在元组中出现的次数并打印。
+numbers = (1, 2, 2, 3, 2, 4)
+count_element = 2
+count = numbers.count(count_element)
+print(f"{count_element} 在元组中出现了 {count} 次。")
+
+# 练习9 元组的嵌套访问
+# 创建一个嵌套元组，访问内层元组的某个元素并打印。
+nested_tuple = ((1, 2), (3, 4), (5, 6))
+print(nested_tuple[1][0])
+
+

day17/01-集合.py

@@ -0,0 +1,37 @@
+# 一、数据容器 列表 元祖 集合 字典 字符串
+# 1、列表 通过[]存储多个元素
+# 有序的 按照顺序输出
+# 可以通过索引下标读写元素
+# 可以设置重复的值
+
+# 2、元祖 通过()存储多个元素
+# 有序的 按照顺序输出
+# 可以通过索引下标获取元素 不可以修改元素
+# 可以设置重复的值
+
+# 3、集合set 通过{}存储多个元素
+# 无序的 随机顺序
+# 不可以通过索引下标读写元素
+# 不可以设置重复的值
+
+# 二、集合 set
+# 1、定义集合
+# 去重 + 内容无序
+s1={'zhangsan','lisi','zhangsan','lisi','zhangsan','lisi','zhangsan','lisi','zhangsan','lisi'}
+print(s1)
+# print(s1[0]) #报错 不可以通过索引下标读写元素
+
+# 2、获取集合的元素
+# 可以通过遍历实现
+s1={'shangsan','lisi','wangwu'}
+for item in s1:
+  print(item)
+  
+# 3、通过in操作符判断某个元素是否在集合中
+s1={'zhangsan','lisi','wangwu','haha'}
+print('zhangsan' in s1)
+print('张三' in s1)
+
+
+
+

day17/02-集合的方法和函数.py

@@ -0,0 +1,57 @@
+# 一、集合的方法
+# 1、set.add(元素) 集合内部添加一个元素
+s1={'a','b','c'}
+s1.add('d') #给集合内部添加一个元素
+s1.add(('e','f')) #给集合内部添加一个元祖
+print(s1) #{('e', 'f'), 'b', 'c', 'a', 'd'} 随机顺序
+
+# 2、set.remove() 移除集合内部指定的元素
+s1={'apple','orange','banana'}
+s1.remove('orange')
+print(s1) #{'apple', 'banana'} 随机顺序
+
+# 3、set.pop() 从集合中随机抽出一个元素
+s1={'apple','orange','banana'}
+print(s1.pop()) #返回抽出的值 并且从集合中删除
+print(s1)
+
+# 4、set.clear() 将集合清空
+s1={'apple','orange','banana'}
+s1.clear() #清空集合
+print(s1) 
+
+
+# 二、集合的并集 交集 差集 非对称差集
+# 并集 union() 和 | 获取两个及其以上集合的所有元素
+s1={1,2,3} 
+s2={3,4,5}
+s3={4,5,6,7,8}
+print(s1.union(s2)) #{1, 2, 3, 4, 5} #默认去重
+print(s1 | s2 ) #{1, 2, 3, 4, 5} 等同于上面的写法 #默认去重
+print(s1 | s2 | s3) #{1, 2, 3, 4, 5, 6, 7, 8} 所有元素 默认去重
+
+# 交集 intersection() 和 & 获取两个及其以上集合的共有元素
+s1={1,2,3,4}
+s2={1,2,3,4,5,6}
+s3={1,2,3,4,5,6,7,8,9}
+print(s1.intersection(s2)) #{1, 2, 3, 4}
+print(s1 & s2) #{1, 2, 3, 4}
+print(s1 & s2 & s3) #{1, 2, 3, 4}
+
+# 差集 difference() 和 - 获取一个集合中其他集合没有的元素
+s1={1,2,3,4,5}
+s2={3,4,5,6,7,8,9}
+print(s1 - s2) #{1, 2} 输出s1剩下的 s2没有的元素
+print(s1.difference(s2)) #{1, 2}
+
+# 非对称差集 ^ 获取两个及其以上集合的非公共元素
+s1={1,2,3,4,5}
+s2={3,4,5,6,7,8,9}
+s3={1,3,5,8,0}
+print(s1 ^ s2) #{1, 2, 6, 7, 8, 9}
+print(s1 ^ s2 ^ s3) #{0, 2, 3, 5, 6, 7, 9}
+
+
+
+
+

day17/03-转换.py

@@ -0,0 +1,11 @@
+# 数据类型的转换
+# list() 将括号里面的内容转换为列表
+# tuple() 将括号里面的内容转换为元祖
+# set() 将括号里面的内容转换为集合 
+
+list_nums=[12,34,56,78,12,34,56,78,12,34,56,78]
+print(set(list_nums)) #{56, 34, 12, 78} 将一个包含重复元素的列表转为集合 并且去除重复的值
+print(list(set(list_nums))) #[56, 34, 12, 78] 将列表转为集合 通过列表函数将集合转为列表
+
+
+

day17/03-集合的应用.py

@@ -0,0 +1,24 @@
+# 创建两个集合，分别表示两个班的学生名字。输出两个班学生的并集、交集和差集。
+# 创建两个集合，分别表示两个班的学生名字
+grade_name_1 = {'张三','李四','王五'}
+grade_name_2 = {'刘一','陈二','张三','王五'}
+# 两个班学生的并集(union 和 |)
+print(grade_name_1 | grade_name_2) # {'陈二', '张三', '王五', '刘一', '李四'}
+print(grade_name_1.union(grade_name_2)) # {'陈二', '张三', '王五', '刘一', '李四'}
+
+# 两个班学生的交集(intersection 和 &)
+print(grade_name_1 & grade_name_2) # {'张三', '王五'}
+print(grade_name_1.intersection(grade_name_2)) # {'张三', '王五'}
+
+# 两个班学生的差集
+print(grade_name_2 - grade_name_1) # {'陈二', '刘一'}
+print(grade_name_2.difference(grade_name_1)) # {'陈二', '刘一'}
+
+
+
+
+
+
+
+
+ 

day17/05-集合的作业.py

@@ -0,0 +1,84 @@
+# 1. 集合的并集
+set1 = {1, 2, 3}
+set2 = {3, 4, 5}
+union_set = set1 | set2  # 或者 use set1.union(set2)
+print(f"并集是 {union_set}")
+
+# 2. 集合的交集
+set1 = {1, 2, 3, 4}
+set2 = {3, 4, 5, 6}
+intersection_set = set1 & set2  # 或者 use set1.intersection(set2)
+print(f"交集是 {intersection_set}")
+
+# 3. 集合的差集
+set1 = {1, 2, 3, 4}
+set2 = {3, 4, 5, 6}
+difference_set = set1 - set2  # 或者 use set1.difference(set2)
+print(f"差集是 {difference_set}")
+
+# 4. 判断元素是否在集合中
+set1 = {1, 2, 3, 4, 5}
+element = 3
+if element in set1:
+    print(f"元素 {element} 存在于集合中")
+else:
+    print(f"元素 {element} 不存在于集合中")
+
+# 5. 集合的对称差集
+set1 = {1, 2, 3}
+set2 = {2, 3, 4}
+symmetric_difference_set = set1 ^ set2  # 或者 use set1.symmetric_difference(set2)
+print(f"对称差集是 {symmetric_difference_set}")
+
+# 6. 集合的添加元素
+set1 = {1, 2, 3}
+element = 4
+set1.add(element)
+print(f"更新后的集合是 {set1}")
+
+# 7. 集合的删除元素
+set1 = {1, 2, 3, 4, 5}
+element = 3
+set1.remove(element)  # 如果元素不存在会抛出 KeyError 异常
+print(f"删除后的集合是 {set1}")
+
+# 8. 集合的集合运算
+set1 = {1, 2, 3}
+set2 = {3, 2, 1}
+if set1 == set2:
+    print("两个集合相等")
+else:
+    print("两个集合不相等")
+
+# 9. 从集合中随机删除元素
+import random
+
+set1 = {1, 2, 3, 4, 5}
+removed_element = set1.pop()  # 随机删除一个元素
+print(f"随机删除后的集合是 {set1}")
+
+# 10. 集合的清空
+set1 = {1, 2, 3, 4}
+set1.clear()
+print(f"清空后的集合是 {set1}")
+
+# 11. 集合的子集检查
+set1 = {1, 2, 3}
+set2 = {1, 2, 3, 4, 5}
+if set1.issubset(set2):
+    print("第一个集合是第二个集合的子集")
+else:
+    print("第一个集合不是第二个集合的子集")
+
+# 12. 集合的超集检查
+set1 = {1, 2, 3, 4, 5}
+set2 = {1, 2, 3}
+if set1.issuperset(set2):
+    print("第一个集合是第二个集合的超集")
+else:
+    print("第一个集合不是第二个集合的超集")
+
+
+
+
+

day18/01-练习.py

@@ -0,0 +1,71 @@
+# 1. 元组的长度
+t = (1, 2, 3, 4, 5)
+length = len(t)
+print(f"元组的长度是 {length}")
+
+# 2. 访问元组中的元素
+t = (10, 20, 30, 40, 50)
+index = int(input("请输入索引："))
+print(f"元组中索引 {index} 的元素是 {t[index]}")
+
+# 3. 元组元素求和
+t = (1, 2, 3, 4, 5)
+total = sum(t)
+print(f"元组中元素的和是 {total}")
+
+# 4. 查找元组中的最大值
+t = (10, 20, 30, 40, 50)
+max_value = max(t)
+print(f"元组中的最大值是 {max_value}")
+
+# 5. 查找元组中的最小值
+t = (10, 5, 30, 2, 50)
+min_value = min(t)
+print(f"元组中的最小值是 {min_value}")
+
+# 6. 元组的切片操作
+t = (1, 2, 3, 4, 5, 6, 7, 8, 9)
+start, end = map(int, input("请输入切片的起始和结束索引：").split(","))
+sliced_tuple = t[start:end]
+print(f"切片后的元组是 {sliced_tuple}")
+
+# 7. 元组的元素计数
+t = (1, 2, 2, 3, 2, 4, 5)
+element = int(input("请输入要查找的元素："))
+count = t.count(element)
+print(f"元素 {element} 出现了 {count} 次")
+
+# 8. 元组与列表互换
+t = (1, 2, 3, 4, 5)
+lst = list(t)
+lst[1] = 20  # 修改列表中的元素
+t_modified = tuple(lst)
+print(f"修改后的元组是 {t_modified}")
+
+# 9. 元组的连接
+t1 = (1, 2, 3)
+t2 = (4, 5, 6)
+merged_tuple = t1 + t2
+print(f"连接后的元组是 {merged_tuple}")
+
+# 10. 判断元素是否在元组中
+t = (1, 2, 3, 4, 5)
+element = int(input("请输入要查找的元素："))
+if element in t:
+    print(f"元素 {element} 存在于元组中")
+else:
+    print(f"元素 {element} 不存在于元组中")
+
+# 11. 计算元组的平均值
+t = (1, 2, 3, 4, 5)
+average = sum(t) / len(t)
+print(f"元组中元素的平均值是 {average}")
+
+# 12. 元组的嵌套
+t = ((1, 2), (3, 4), (5, 6))
+index = int(input("请输入要提取的内层元组索引："))
+inner_tuple = t[index]
+print(f"内层元组索引 {index} 的元素是 {inner_tuple}")
+
+
+

day18/02-梳理数据容器.py

@@ -0,0 +1,46 @@
+# 一.数据容器总共有5个
+# 1.列表：存储多个元素,有序,可以重复,可以通过索引下标进行读写(获取和设置)
+# 2.元组：存储多个元素,有序,可以重复,可以通过索引下标进行获取，不能设置(修改)
+# 3.集合：存储多个元素,无序,不能重复,没有索引下标
+# 4.字典：接下来学习的
+# 5.字符串：接下来学习的
+
+
+# 二.创建符号
+# 1.列表创建：[1,2,3,4,5]
+# 2.元组创建：(1,2,3,4,5)
+# 3.集合创建：{1,2,3,4,5}
+
+
+# 三.数据容器下面的函数
+# len()：统计数据容器里面元素的个数
+# sorted()：对数据容器里面的元素进行排序
+
+
+# 四.数据容器下面的方法
+# 1.列表方法：
+# list.index()  : 获取元素的索引位置
+# list.append() : 追加元素
+# list.extend() : 追加元素
+# list.pop()    : 删除对应位置的元素，返回删除的元素
+# list.remove() : 删除特定的元素
+# list.clear()  : 清空列表
+# list.count()  : 统计某个元素的个数
+# list.reverse(): 反转列表
+# list.sort()   : 排序
+# list.insert() : 插入元素
+
+
+# 2.元组方法
+# tuple.count() : 统计某个元素的个数
+# list.index()  : 获取元素的索引位置
+
+
+# 3.集合方法
+# set.add()     : 添加元素
+# list.pop()    : 从集合中随机取出一个元素(删除对应位置的元素，返回删除的元素)
+# list.remove() : 删除特定的元素
+# list.clear()  : 清空列表
+# list.union()  : 并集
+# list.intersection(): 交集
+# list.difference(y): 差集

day18/03-字典.py

@@ -0,0 +1,57 @@
+# 字典
+# 字典的含义 同样使用{} 不过存储的数据是一个键值对(key:value)
+
+# 1、字典的组成
+# 1.大括号：大括号包裹数据
+# 2.键值对：每一条数据有两个值(前面的叫做"键" , 后面的叫做"值")
+# 3.逗号：每条数据结尾都由逗号进行分隔
+# 4.引号：字符串需要添加引号
+dict={
+  'name':'zhangsan',
+  'sex':'男',
+  'age':18
+  }
+print(dict)
+  
+# 2、字典的值和类型
+# 创建一个名为student的字典 包含三条数据
+student={
+  'name':'lisi',
+  'gender':'男',
+  'age':20
+}
+print(student) #{'name': 'lisi', 'gender': '男', 'age': 20}
+print(type(student)) #<class 'dict'>
+
+# 3、字典的读写操作
+student={
+  'name':'lisi',
+  'gender':'男',
+  'age':20
+}
+print(student['name']) #lisi 通过键值名称访问对应的值
+print(student)
+student['name']='zhangsan' #设置
+print(student)
+
+# 4、字典是可以嵌套的
+# 字典中的key和value可以是任意的数据类型 key不可以是字典
+my_dict={
+  'k1':{'语文':77,'数学':66,'英语':88},
+  'k2':{'语文':71,'数学':61,'英语':81},
+  'k3':{'语文':72,'数学':62,'英语':82},
+  'k4':{'语文':73,'数学':63,'英语':83}
+}
+print(my_dict['k1']) #{'语文': 77, '数学': 66, '英语': 88}
+print(my_dict['k1']['数学']) #66
+
+# 5、字典中的key重复的时候 第二个会把第一个覆盖掉
+person={
+  'name':'lisi',
+  'gender':'男',
+  'age':20,
+  'name':'zhangsan',
+  'gender':'女',
+  'age':26
+}
+print(person)

day18/04-字典的应用.py

@@ -0,0 +1,32 @@
+# 1.创建一个字典，包含5个学生的姓名和他们的成绩。找出成绩最高的学生及其成绩
+# 创建包括5个学生姓名和成绩的字典
+students = {
+    '张三':78,
+    '李四':80,
+    '王五':66,
+    '赵六':77,
+    '孙七':58
+}
+# max函数：输出括号里面的最大数字
+# min函数：输出括号里面的最小数字
+print(max(234,45,3456,23)) # 3456
+print(min(234,45,3456,23)) # 23
+
+# 2.字典的遍历
+max = 0
+for item in students:
+    if students[item] > max:
+        max = students[item] 
+print(max)
+
+# 练习:创建一个字典，包含一些国家及其人口。根据人口从大到小排序，并输出前3个国家
+dict_sort = {
+    '中国':14,
+    '美国':3,
+    '印度':13,
+    '日本':1,
+    '墨西哥':2
+}
+print(list(dict_sort.items())) 
+list = list(dict_sort.items())
+print(sorted(list,key=lambda x:x[1]))