diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..81758f7 --- /dev/null +++ b/.gitignore @@ -0,0 +1,10 @@ +# 忽略所有 MP4 文件 +*.mp4 + +# 忽略特定目录下的 MP4 文件 +videos/*.mp4 +media/*.mp4 + +# 忽略特定名称的 MP4 文件 +video.mp4 +movie.mp4 \ No newline at end of file diff --git a/Python学习笔记.md b/Python学习笔记.md new file mode 100644 index 0000000..439c8cb --- /dev/null +++ b/Python学习笔记.md @@ -0,0 +1,3172 @@ +# Python学习笔记 + +## Day 1: Python基础入门 + +### 1.1 开发环境配置 +- 安装VSCode编辑器 +- 安装Python插件 +- 创建第一个.py文件 + +### 1.2 第一个Python程序 +```python +print('hello world') +print(1+2+3) +``` + +### 1.3 print函数详解 +- print函数用于输出内容到终端 +- 默认情况下，print函数输出的内容会自动换行 +- 使用end参数可以控制输出格式： + ```python + # 默认换行输出 + print(1) + print(2) + print(3) + + # 使用end参数自定义分隔符 + print(1, end='---') + print(2, end='---') + print(3, end='---') + + # 使用逗号分隔输出 + print('你好', end=',') + print('世界') + ``` + +### 1.4 字面量和常量 +- **字面量**：程序中直接使用的固定值 + - 数字字面量：如 `3.14` + - 字符串字面量：如 `'hello'` +- **常量**： + - 给特定值取一个名字 + - 命名约定使用大写字母 + - 值不应该被修改 + ```python + PI = 3.14 + print(PI) + ``` +- **变量**： + - 给特定值取一个名字 + - 值可以随时修改 + ```python + name = 'zhangsan' + name = '张三' + print(name) + ``` + +### 1.5 注释 +- **注释的作用**：对代码进行解释说明，供程序员阅读 +- **注释的类型**： + 1. 单行注释：以 `#` 开头 + ```python + # 这里是一个常量 + COUNT = 100 + ``` + 2. 多行注释：使用三引号 `"""` 或 `'''` + ```python + """ + a变量的值是1 + b变量的值是2 + c变量的值是3 + """ + a = 1 + b = 2 + c = 3 + ``` + +### 1. if语句的梳理 +```python +# 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') +``` + +## Day 2: 字符串与输入输出 + +### 2.1 字符串操作 +- 字符串拼接：`+` 号 +- 字符串重复：`*` 号 +- 成员运算：`in` / `not in` +- 索引取值：`str[i]` +- 负数索引：`str[-1]` 表示最后一个字符 + +示例代码： +```python +s1 = '我的名字是' +s2 = '佳佳' +print(s1 + s2) + +name = '张三' +print('我的名字是' + name) + +str1 = '我要成功' +print(str1 * 5) + +str2 = 'my name is zhangsan' +print('y' in str2) +print('yy' in str2) +print('name' in str2) + +str3 = 'zhangsan' +print('san' not in str3) +print('lisi' not in str3) + +str4 = '你好世界' +print(str4[0], str4[1], str4[2], str4[3]) +print(str4[0] + str4[2] + str4[-1]) +``` + +### 2.2 输入与输出 +- `input()` 用于获取用户输入，返回字符串类型 +- `print()` 用于输出内容 + +示例代码： +```python +name = input('请输入你的名字') +print('你输入的内容是' + name) + +n1 = input('请输入第一个数字') +n2 = input('请输入第二个数字') +print(n1 + n2) # 字符串拼接 + +# 转换为整数再相加 +n1 = int(input('请输入第一个数字')) +n2 = int(input('请输入第二个数字')) +print(n1 + n2) +``` + +### 2.3 数据类型检测与转换 +- `type()` 检测数据类型 +- `int()`、`float()`、`str()` 类型转换 + +示例代码： +```python +n1 = input('请输入一个数字') +print(type(n1)) # str +print(type(int(n1))) # int + +n1 = input('请输入第一个数字') +n2 = input('请输入第二个数字') +n1 = int(n1) +n2 = int(n2) +print(n1 + n2) +print(n1 - n2) +print(n1 * n2) +print(n1 / n2) +``` + +### 2.4 变量与数据类型基础 +- Python变量无需声明类型，类型由赋值自动推导 +- 常见类型：int、float、str、bool + +### 2.5 列表的基本操作 +- 创建、添加、访问、获取长度 + +示例代码： +```python +fruits = ["apple", "banana", "cherry"] +fruits.append("orange") +first_fruit = fruits[0] +num_fruits = len(fruits) +``` + +## Day 3: 运算符与变量 + +### 3.1 数据类型转换函数 +- `int(x)`：将x转为整数 +- `float(x)`：将x转为浮点数 +- `str(x)`：将x转为字符串 +- 布尔值、浮点数、字符串之间的转换 + +示例代码： +```python +print(int('100')) # 100 +print(int(True)) # 1 +print(int(3.14)) # 3 +print(float(100)) # 100.0 +print(str(True)) # 'True' +``` + +### 3.2 算术运算符 +- `+` 加法 +- `-` 减法 +- `*` 乘法 +- `/` 除法 +- `//` 取整除 +- `%` 取余 +- `**` 幂运算 + +示例代码： +```python +print(1 + 2) # 3 +print(7 - 9) # -2 +print(2 * 3) # 6 +print(8 / 3) # 2.666... +print(9 // 2) # 4 +print(9 % 2) # 1 +print(2 ** 3) # 8 + +# 布尔值参与运算 +print(True + True) # 2 +print(True - True) # 0 +print(True * True) # 1 +print(True / True) # 1.0 +``` + +### 3.3 赋值运算符 +- `=` 赋值，将右边的值赋给左边变量 + +示例代码： +```python +a = 100 +a = a + 2 +print(a) # 102 +num = 10 +num = num + num + num + 100 +print(num) # 130 +``` + +### 3.4 复合赋值运算符 +- `+=`、`-=`、`*=`、`/=`、`//=`、`%=`、`**=` + +示例代码： +```python +a = 1 +a += 1 +print(a) # 2 + +a = 1 +b = 2 +c = 3 +a += b +a -= c +b += c +c += b +print(a, b, c) # 0 5 8 +``` + +### 3.5 内置的数字运算函数 +- `abs(x)`：绝对值 +- `divmod(x, y)`：返回(x//y, x%y) +- `pow(x, y, z=None)`：幂运算，可取模 +- `round(x, n=0)`：四舍五入，保留n位小数 +- `max(x1, x2, ...)`：最大值 +- `min(x1, x2, ...)`：最小值 + +示例代码： +```python +print(abs(-100)) # 100 +print(divmod(9, 2)) # (4, 1) +print(pow(2, 3)) # 8 +print(round(3.6678, 3)) # 3.668 +print(max(23, 45, 67, 89)) # 89 +print(min(23, 45, 67, 89)) # 23 +``` + +### 3.6 变量 +- 变量就像盒子，可以存放内容 +- 变量声明格式：变量名 = 值 +- 变量的值可以改变 +- 变量名要有语义 + +示例代码： +```python +name = 'zhangsan' +age = 18 +sex = '男' +grade = 'IT231' +print(name, age, sex, grade) +``` + +## Day 4: 变量命名与字符串格式化 + +### 4.1 变量命名规则与标识符 +- 变量名只能包含字母、数字和下划线，不能以数字开头 +- 不能使用Python关键字和函数名 +- 变量名应简短且有描述性 +- 标识符区分大小写，不能是关键字或保留字 + +### 4.2 字符串的定义与嵌套 +- 单引号、双引号、三引号均可定义字符串 +- 三引号支持多行字符串 +- 引号可嵌套使用 + +### 4.3 字符串拼接与格式化 +- `+` 号拼接字符串 +- `%` 占位符格式化字符串（%s, %d, %f） +- `f"{}"` 格式化字符串（推荐） + +示例代码： +```python +name = '张三' +age = 18 +gender = '男' +print('我的名字是' + name + ',我今年' + str(age) + '岁,我是' + gender + '的') +print('我的名字是%s,我今年%s岁,我是%s的' % (name, age, gender)) +print(f'我的名字是{name},我今年{age}岁,我是{gender}的') +``` + +### 4.4 字符串格式化表达式 +```python +print("1 * 1的结果是:%d" % (1 * 1)) +print(f"1 * 2的结果是:{1 * 2}") +print("字符串在Python中的类型名是:", type("字符串")) +``` + +### 4.5 变量交换与小数处理 +- 不用第三变量交换两个数 +- 保留小数位（不四舍五入） + +示例代码： +```python +# 保留两位小数（不四舍五入） +origin = 123.456789 +print(int(origin * 100) / 100) # 123.45 + +# 交换变量 +a = 5 +b = 8 +a = a + b +b = a - b +a = a - b +print(a, b) # 8 5 +``` + +### 4.6 综合练习 +- 计算小时转天和小时 +- 输入两个数字，输出和、差、积、商、余数 + +示例代码： +```python +# 小时转天和小时 +hours = 89 +day = int(hours / 24) +h = hours % 24 +print('为抵抗洪水，战士连续作战89小时，编程计算共' + str(day) + '天零' + str(h) + '小时') + +# 输入两个数字，输出运算结果 +x = float(input("请输入第一个数字 x: ")) +y = float(input("请输入第二个数字 y: ")) +print(f"{x} + {y} = {x + y}") +print(f"{x} - {y} = {x - y}") +print(f"{x} * {y} = {x * y}") +print(f"{x} / {y} = {x / y}") +print(f"{x} % {y} = {x % y}") +``` + +## Day 5: 条件判断与分支结构 + +### 5.1 条件测试与比较运算符 +- `==` 等于 +- `!=` 不等于 +- `>` 大于 +- `<` 小于 +- `>=` 大于等于 +- `<=` 小于等于 +- `and` 多条件同时满足 +- `or` 多条件有一个满足 +- `in` 检查成员 +- `not in` 检查非成员 + +示例代码： +```python +n1 = 10 +n2 = 10 +n3 = 20 +print(n1 == n2) # True +print(n1 != n3) # True + +str1 = 'hello' +str2 = 'Hello' +print(str1 == str2.lower()) # True + +print(5 == 5 and 10 != 5) # True +print(5 != 10 or 10 == 15) # True + +print('e' in 'hello') # True +print('he' not in 'hello') # False +``` + +### 5.2 程序的三大结构 +- 顺序结构 +- 选择结构（分支） +- 循环结构 + +### 5.3 if语句 +- 单分支 +- 双分支 +- 多分支（elif） + +示例代码： +```python +# 单分支 +n1 = -10 +if n1 > 0: + print('这个是正数') + +# 双分支 +age = 10 +if age >= 18: + print('成年了') +else: + print('没有成年') + +# 多分支 +num = int(input("请输入一个整数: ")) +if num > 0: + print("这个数是正数") +elif num < 0: + print("这个数是负数") +else: + print("这个数是零") +``` + +### 5.4 综合练习与应用 +- 判断闰年 +- 补零输出 +- 判断奇偶数 +- 判断字符类型 +- 判断水仙花数 +- 密码判断 + +示例代码： +```python +# 判断闰年 +year = int(input('请输入一个年份:')) +if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0): + print(f"{year} 是闰年") +else: + print(f"{year} 不是闰年") + +# 补零输出 +num = int(input('请输入一个数字:')) +if num < 10: + print(f"0{num}") +else: + print(num) + +# 判断奇偶数 +num = int(input("请输入一个整数: ")) +if num % 2 == 0: + print("这个数是偶数") +else: + print("这个数是奇数") + +# 判断水仙花数 +num = int(input('请输入一个三位的数字：')) +a = num % 10 +b = num % 100 // 10 +c = num // 100 +if a**3 + b**3 + c**3 == num: + print(f'你输入的三位数{num}是水仙花数') +else: + print(f'你输入的三位数{num}不是水仙花数') + +# 密码判断 +correct_password = "python123" +password = input("请输入密码: ") +if password == correct_password: + print("密码正确，欢迎进入系统！") +else: + print("密码错误，请重试。") +``` + +## Day 6: 多分支与综合练习 + +### 6.1 多分支结构（elif） +- 结构： + ```python + if 条件1: + # 条件1成立时执行 + elif 条件2: + # 条件2成立时执行 + elif 条件3: + # 条件3成立时执行 + else: + # 所有条件都不成立时执行 + ``` +- 应用：数字正负零判断、成绩评级等 + +示例代码： +```python +num = int(input('请输入一个数字')) +if num > 0: + print(f'你输入的数字{num}是一个大于0的数字') +elif num < 0: + print(f'你输入的数字{num}是一个小于0的数字') +else: + print(f'你输入的数字{num}是一个等于0的数字') + +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 之间的整数") +``` + +### 6.2 综合练习 +- 判断奇偶 +- 判断正负零 +- 绝对值计算 +- 比较两个数大小 +- 能否被3和5同时整除 +- 判断闰年 +- 简单计算器 +- 判断三角形类型 +- 字母大小写转换 +- 生肖计算 +- ATM取款机 +- 简单彩票系统 + +示例代码（部分）： +```python +# 判断奇偶 +num = int(input("请输入一个整数：")) +if num % 2 == 0: + print(f"{num} 是偶数") +else: + print(f"{num} 是奇数") + +# 绝对值 +num = int(input("请输入一个整数：")) +if num < 0: + num = -num +print(f"绝对值是 {num}") + +# 简单计算器 +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("无效的运算符") + +# 判断三角形类型 +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("无法构成三角形") + +# 生肖计算 +zodiac = ["猴", "鸡", "狗", "猪", "鼠", "牛", "虎", "兔", "龙", "蛇", "马", "羊"] +year = int(input("请输入年份：")) +print(f"{year} 属 {zodiac[year % 12]}") +``` + +## Day 7: 条件语句进阶 + +### 7.1 if语句基础 +```python +# 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') +``` + +### 7.2 if语句嵌套 +- 在if语句内部可以嵌套其他if语句 +- 外层条件满足时才会执行内层条件判断 +- 语法结构： +```python +if 外层条件: + # 外层条件为真时执行的代码 + if 内层条件: + # 内层条件为真时执行的代码 + else: + # 内层条件为假时执行的代码 +else: + # 外层条件为假时执行的代码 +``` + +示例代码： +```python +# 判断是否有火车票和刀具长度 +ticket = True +knife = 34 +if ticket==True: + print('恭喜你 有票') + if knife<10: + print('可以携带') + else: + print('不可以携带') +else: + print('很遗憾 没有票') + +# 猜拳游戏 +import random +my_num = int(input('请输入数字0-2:')) # 0:石头 1:剪刀 2:布 +if my_num <= 2: + computer_num = 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('你输入的数字不合法') +``` + +### 7.3 综合练习 +1. 比较两个数的大小 +```python +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. 判断三角形类型 +```python +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. 体重标准判断 +```python +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('你是标准身材,请继续保持!') +``` + +## Day 8: 循环结构基础 + +### 8.1 高级练习 +1. 复杂身份验证系统 +```python +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取款机（加强版） +```python +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. 复杂成绩评级 +```python +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 之间的成绩") +``` + +### 8.2 循环的意义 +- 循环是程序中广泛存在的基础功能 +- 用于重复执行某些操作 +- Python中的循环语句： + 1. while循环 + 2. for...in循环 +- 循环的组成： + 1. 定义循环的关键字（while/for/in） + 2. 限制条件（终止条件） + 3. 循环体（满足条件执行的代码） +- 死循环：无法靠自身条件终止的循环 + +### 8.3 while循环 +- 语法结构： +```python +while 判断条件: + 满足条件执行语句 + ... +``` + +- 注意事项： + 1. 初始值 + 2. while + 限制条件 + 3. 满足条件执行的循环体 + 4. 初始值的迭代（累加/累减） + +示例代码： +```python +# 打印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 # 累加 初始值的迭代 +``` + +## Day 9: 循环控制语句 + +### 9.1 正向和反向循环 +```python +# 正向循环：输出数字1-10 +num = 1 +while num <= 10: + print(num) + num += 1 + +# 反向循环：输出数字10-1 +num = 10 +while num >= 1: + print(num) + num -= 1 +``` + +### 9.2 break和continue关键字 +- break：直接结束整个循环 +- continue：中断本次循环，继续下一次循环 + +示例代码： +```python +# break示例 +num = 1 +while num <= 10: + if num == 5: + break # 当num等于5时结束循环 + print(f'这是第{num}次循环') + num += 1 + +# continue示例 +num = 0 +while num < 10: + num += 1 + if num == 5: + continue # 当num等于5时跳过本次循环 + print(f'这是第{num}次循环') +``` + +### 9.3 循环练习 +1. 打印1-100之间的偶数 +```python +num = 1 +while num <= 100: + if num % 2 == 0: + print(num) + num += 1 +``` + +2. 计算1-100的和 +```python +sum = 0 +num = 1 +while num <= 100: + sum += num + num += 1 +print(f'1到100的和是：{sum}') +``` + +3. 打印九九乘法表 +```python +i = 1 +while i <= 9: + j = 1 + while j <= i: + print(f'{j}×{i}={i*j}', end='\t') + j += 1 + print() # 换行 + i += 1 +``` + +4. 猜数字游戏 +```python +import random +target = random.randint(1, 100) +count = 0 + +while True: + guess = int(input('请猜一个1-100之间的数字：')) + count += 1 + + if guess > target: + print('太大了') + elif guess < target: + print('太小了') + else: + print(f'恭喜你猜对了！答案就是{target}') + print(f'你总共猜了{count}次') + break +``` + +## Day 10: for循环与三目运算符 + +### 10.1 三目运算符 +- 语法：`结果1 if 条件 else 结果2` +- 作用：根据条件判断，选择不同的结果 + +示例代码： +```python +a = 100 +b = 20 +max = a if a > b else b +print(max) + +# 等价于： +if a > b: + max = a +else: + max = b +print(max) +``` + +### 10.2 for循环 +- for循环用于对序列类型（如字符串、列表、元组等）进行逐个处理 +- 语法结构： +```python +for 临时变量 in 待处理的数据集: + 循环体 +``` +- 临时变量：每次循环时取到的数据项 +- 循环体：对每个数据项要执行的操作 + +示例代码： +```python +str = 'hello' +for s in str: + print(s) +``` + +### 10.3 range函数 +- 用于生成一系列数字，常与for循环配合使用 +- 用法： + - `range(num)`：从0到num-1 + - `range(start, end)`：从start到end-1 + - `range(start, end, step)`：从start到end-1，步长为step + +示例代码： +```python +for n in range(10): + print(n) + +for n in range(1, 10): + print(n) + +for n in range(1, 10, 2): + print(n) +``` + +## Day 11: 循环案例精讲 + +### 11.1 求100-999之间的水仙花数 +- 水仙花数：一个n位数，其每个位上的数字的n次幂之和等于它本身。 +- 三位数水仙花数示例：153（1^3 + 5^3 + 3^3 = 153） + +示例代码： +```python +for num in range(100, 1000): + a = num % 10 # 个位 + b = num % 100 // 10 # 十位 + c = num // 100 # 百位 + if a**3 + b**3 + c**3 == num: + print(num, end=',') +``` + +### 11.2 打印100以内不带7且不是7的倍数的数 +- 条件：不是7的倍数，个位和十位都不能是7 + +示例代码： +```python +for num in range(1, 101): + if (num % 7 != 0) and (num % 10 != 7) and (num // 10 != 7): + print(num, end=',') +``` + +### 11.3 判断素数 +- 素数：只能被1和自身整除的数，最小的素数是2 + +示例代码： +```python +num = int(input('请输入一个数字:')) +flag = True +if num < 2: + flag = False +else: + for i in range(2, num): + if num % i == 0: + flag = False + break +if flag: + print(f'{num}是素数') +else: + print(f'{num}不是素数') +``` + +## Day 12: 数据容器入门与列表 + +### 12.1 数据容器入门 +- 数据容器是一种可以容纳多个数据的数据类型，每个数据被称为元素。 +- 数据容器的特点： + 1. 可以容纳多份数据。 + 2. 是否支持重复数据。 + 3. 是否可以修改。 + 4. 是否有序。 +- 数据容器的类型： + - 列表(list) + - 元组(tuple) + - 字符串(str) + - 集合(set) + - 字典(dict) + +### 12.2 列表的创建与索引 +- 列表由一系列按照特定顺序排列的元素组成。 +- 定义方式：使用方括号`[]`，用逗号分隔元素。 +- 示例代码： +```python +list_names = ['李一', '张三', '李四'] +list_nums = [100, 200, 300, 400] +print(list_names, list_nums) +``` + +- 输出列表的值和类型： +```python +print(list_names) +print(type(list_names)) # +``` + +- 下标索引：列表的每个元素都有一个编号，从左到右，默认从0开始。 +- 示例代码： +```python +list_names = ['李一', '张三', '李四', '老王', 'wangwu'] +print(list_names[0]) # 李一 +print(list_names[1]) # 张三 +print(list_names[2]) # 李四 +print(list_names[3]) # 老王 +print(list_names[4]) # wangwu +``` + +- 修改元素的值： +```python +list_names[1] = '尼古拉斯' +print(list_names) # ['李一', '尼古拉斯', '李四', '老王', 'wangwu'] +``` + +- 反向索引：从后到前，从-1开始。 +- 示例代码： +```python +print(list_names[-1]) # wangwu +print(list_names[-2]) # 老王 +print(list_names[-3]) # 李四 +print(list_names[-4]) # 张三 +print(list_names[-5]) # 李一 +``` + +- 列表可以存储多个数据，并且可以存储不同的数据类型，同时支持嵌套。 +- 示例代码： +```python +list_nums = [[4, 5, 6], [6, 7, 8], [10, 11]] +print(list_nums[0]) # [4, 5, 6] +print(list_nums[0][0]) # 4 +``` + +- 多维列表示例： +```python +list = [1, [2, 3, [4, [5, 6, [7, 8, [9, 10]]]]]] +print(list[1][2][1][2][2][0]) # 9 +``` + +## Day 13: 列表的操作与常用方法 + +### 13.1 列表的操作 +- 修改列表中的元素值： +```python +list = [100, 200, 300, 400, 500] +list[2] = 3 +print(list) # [100, 200, 3, 400, 500] +``` + +- 修改区间值： +```python +list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] +list[1:5] = [100, 200, 300, 400] # 替换索引1到4的元素 +print(list) # [0, 100, 200, 300, 400, 5, 6, 7, 8, 9] +``` + +- 添加步长： +```python +list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] +list[1:9:2] = ['奇数', '奇数', '奇数', '奇数'] # 步长为2，从索引1开始替换 +print(list) # [0, '奇数', 2, '奇数', 4, '奇数', 6, '奇数', 8, 9] +``` + +- 重复列表： +```python +list = [1, 2, 3] +print(list * 3) # [1, 2, 3, 1, 2, 3, 1, 2, 3] +``` + +- 列表拼接： +```python +list = [12, 13, 14] +print(list + [4, 5, 6]) # [12, 13, 14, 4, 5, 6] +print(list + [4, 5, 6] + [20, 30, 40, 50]) # [12, 13, 14, 4, 5, 6, 20, 30, 40, 50] +``` + +### 13.2 列表的常用方法 +- 在Python中，一切皆对象，列表也是一个对象，由属性和方法组成。 +- 常用方法： + 1. `list.index(元素)`：查找指定元素在列表中的索引，如果找不到则报错。 + 2. `list.append(x)`：将x作为一个元素添加到列表list中（x可以是列表或元素）。 + +示例代码： +```python +list = ['zhangsan', 'lisi', 'wangwu'] +print(list.index('lisi')) # 1 + +list = ['a', 'b'] +list.append('c') +list.append('d') +list.append(['e', 'f', 'g']) +print(list) # ['a', 'b', 'c', 'd', ['e', 'f', 'g']] +``` + +- 案例：创建一个列表，里面是0开始的偶数，一直到100。 +```python +list = [] # 创建一个空列表 +for num in range(0, 101): # 循环1-100 + if num % 2 == 0: # 选择1-100的偶数 + list.append(num) # 将偶数追加到列表中 +print(list) # [0, 2, 4, ..., 100] +``` + +## Day 14: 列表的方法总结与应用 + +### 14.1 列表的方法总结 +- `list.extend()`：将列表中的元素增加到列表中去。 +- `list.pop(x)`：如果括号里没有参数，默认删除最后一项；如果写了参数，将列表中的第x个元素取出并删除。 +- `list.remove(x)`：将列表中出现的第一个元素x删除。 +- `list.clear()`：删除所有的元素。 +- `list.insert(i, x)`：在列表的第i个位置插入字符x。 +- `list.reverse()`：将列表list里面的元素反转原地保存。 +- `list.sort()`：将列表list里面的元素排序。 + +示例代码： +```python +list = ['a', 'b'] +list.extend('c') +list.extend(['d', 'e']) +print(list) # ['a', 'b', 'c', 'd', 'e'] + +list = ['a', 'b', 'c', 'd'] +print(list.pop()) # 'd' +print(list) # ['a', 'b', 'c'] + +list = ['a', 'b', 'c', 'd', 'e', 'f', 'g'] +list.remove('c') # 删除第一个c字符 +print(list) # ['a', 'b', 'd', 'e', 'f', 'g'] + +list = ['a', 'b', 'c', 'd', 'e'] +list.clear() +print(list) # [] + +list = ['a', 'b', 'c', 'd'] +list.insert(1, 'x') # 在下标为1的位置插入字符x +print(list) # ['a', 'x', 'b', 'c', 'd'] + +list = ['a', 'b', 'c'] +list.insert(1, ['x', 'y', 'z']) # 在下标为1的位置插入多个字符 +print(list) # ['a', ['x', 'y', 'z'], 'b', 'c'] + +list = ['a', 'b', 'c', 'd'] +list.reverse() +print(list) # ['d', 'c', 'b', 'a'] + +list = [12, 3, 1, 78, 88, 90, 34, 56] +list.sort(reverse=False) # 默认升序 +print(list) # [1, 3, 12, 34, 56, 78, 88, 90] + +list = [1, 2, 36, 7, 89, 100, 34, 78] +list.sort(reverse=True) # 降序排序 +print(list) # [100, 89, 78, 36, 34, 7, 2, 1] +``` + +## Day 15: 列表遍历与元组 + +### 15.1 列表的遍历 +列表遍历是指按照需求依次取出列表中的元素进行操作。Python提供了两种遍历方式： + +1. while循环遍历： +```python +list = ['apple', 'banana', 'orange', 'grape'] +index = 0 +while index < len(list): + print(list[index]) + index += 1 +``` + +2. for循环遍历： +```python +list = ['apple', 'banana', 'orange', 'grape'] +for v in list: + print(v) +``` + +while循环和for循环的对比： +1. 循环条件控制： + - while循环可以自定义循环条件，并自行控制 + - for循环不可以自定义循环条件，只能一个个从容器内取出数据 +2. 无限循环： + - while循环可以通过条件控制做到无限循环 + - for循环理论上不可以，因为被遍历的容器容量不是无限的 +3. 使用场景： + - while循环适用于任何想要循环的场景 + - for循环适用于遍历数据容器的场景或简单的固定次数循环场景 + +### 15.2 列表遍历的应用 +示例：创建一个列表，包含1-100的偶数，每5个数求平均数，并将平均值放入新列表 +```python +# 第一步：生成1-100的偶数列表 +list = [] +for i in range(1, 101): + if i % 2 == 0: + list.append(i) +print(list) # [2, 4, 6, ..., 100] + +# 第二步：每5个数求平均数 +result = 0 +new_list = [] +for index in range(len(list)): + result += list[index] + if (index + 1) % 5 == 0: + new_list.append(result / 5) + result = 0 +print(new_list) # [6.0, 16.0, 26.0, 36.0, 46.0, 56.0, 66.0, 76.0, 86.0, 96.0] +``` + +### 15.3 元组 +元组（tuple）是一种不可变的数据容器，可以封装多个不同类型的元素。 + +1. 定义元组： +```python +t1 = ('zhangsan', 'lisi', 'wangwu') +t2 = ('apple',) # 如果只有一个值，也要添加逗号，否则不是元组 +print(type(t1)) # +``` + +2. 元组的读写： +```python +# 读取元组的值 +print(t1[0]) # 'zhangsan' +print(t1[1]) # 'lisi' +print(t1[2]) # 'wangwu' + +# 修改元组的值（会报错） +# t1[0] = '张三' # TypeError: 'tuple' object does not support item assignment +``` + +3. 元组的嵌套： +```python +t1 = (('zhangsan', 'lisi', 'wangwu'), ('apple', 'orange'), ('jack', 'tom')) +print(t1[0]) # ('zhangsan', 'lisi', 'wangwu') +print(t1[0][1]) # 'lisi' +``` + +元组的特点： +- 有序：可以通过索引访问元素 +- 不可变：一旦定义后不能修改 +- 可以包含重复值 +- 可以包含不同类型的元素 +- 支持嵌套使用 + +## Day 16: 元组的进阶操作 + +### 16.1 元组的操作符 +1. 拼接和重复： +```python +t1 = (1, 2, 3) +t2 = (4, 5, 6) +print(t1 + t2) # (1, 2, 3, 4, 5, 6) 拼接 +print(t1 + (7, 8, 9)) # (1, 2, 3, 7, 8, 9) 拼接 +print(t1 * 4) # (1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3) 重复 +``` + +2. in操作符： +```python +t1 = ('apple', 'orange', 'mango') +print('orange' in t1) # True +print('pear' in t1) # False +``` + +### 16.2 元组和列表的混合使用 +元组中可以包含列表，且列表中的元素可以修改： +```python +t1 = ('zhangsan', ['a', 'b', 'c']) +print(t1[1]) # ['a', 'b', 'c'] +print(t1[1][1]) # 'b' +t1[1][1] = 'B' # 修改列表中的元素 +print(t1) # ('zhangsan', ['a', 'B', 'c']) +``` + +### 16.3 元组的遍历 +```python +nums = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) +for v in nums: + print(v * 100, end=',') # 将值扩大100倍 +``` + +### 16.4 元组和列表的转换 +1. list()函数：将可遍历对象转换为列表 +```python +print(list('hello')) # ['h', 'e', 'l', 'l', 'o'] 字符串转列表 +print(list((1, 2, 3, 4, 5))) # [1, 2, 3, 4, 5] 元组转列表 +``` + +2. tuple()函数：将可遍历对象转换为元组 +```python +print(tuple('hello')) # ('h', 'e', 'l', 'l', 'o') 字符串转元组 +print(tuple([1, 2, 3, 4, 5])) # (1, 2, 3, 4, 5) 列表转元组 +``` + +### 16.5 元组的方法和函数 +1. 元组的方法： + - index()：查找元素，返回下标（不存在则报错） + ```python + t1 = ('banana', 'apple', 'mango', 'pear', 'orange') + print(t1.index('orange')) # 4 + ``` + + - count()：统计元素出现次数 + ```python + t1 = ('apple', 'apple', 'apple', 'orange', 'pear') + print(t1.count('apple')) # 3 + print(t1.count('hehe')) # 0 + ``` + +2. 元组的函数： + - len()：统计元素个数 + ```python + t1 = ('apple', 'apple', 'apple', 'orange', 'pear', 'orange') + print(len(t1)) # 6 + ``` + + - sorted()：排序（返回列表） + ```python + t2 = (12, 4, 67, 8, 10, 1) + print(sorted(t2)) # [1, 4, 8, 10, 12, 67] 升序 + print(sorted(t2, reverse=True)) # [67, 12, 10, 8, 4, 1] 降序 + ``` + +## Day 17: 集合 + +### 17.1 集合的基本概念 +集合（set）是一种无序的数据容器，具有以下特点： +- 通过{}存储多个元素 +- 无序的，随机顺序输出 +- 不可以通过索引下标读写元素 +- 不可以设置重复的值（自动去重） + +1. 定义集合： +```python +s1 = {'zhangsan', 'lisi', 'zhangsan', 'lisi'} # 自动去重 +print(s1) # {'zhangsan', 'lisi'} +``` + +2. 获取集合元素： +```python +s1 = {'shangsan', 'lisi', 'wangwu'} +for item in s1: + print(item) +``` + +3. 判断元素是否存在： +```python +s1 = {'zhangsan', 'lisi', 'wangwu', 'haha'} +print('zhangsan' in s1) # True +print('张三' in s1) # False +``` + +### 17.2 集合的方法和函数 +1. 集合的方法： + - add()：添加元素 + ```python + s1 = {'a', 'b', 'c'} + s1.add('d') # 添加单个元素 + s1.add(('e', 'f')) # 添加元组 + print(s1) # {('e', 'f'), 'b', 'c', 'a', 'd'} + ``` + + - remove()：移除指定元素 + ```python + s1 = {'apple', 'orange', 'banana'} + s1.remove('orange') + print(s1) # {'apple', 'banana'} + ``` + + - pop()：随机取出一个元素 + ```python + s1 = {'apple', 'orange', 'banana'} + print(s1.pop()) # 返回随机元素并从集合中删除 + ``` + + - clear()：清空集合 + ```python + s1 = {'apple', 'orange', 'banana'} + s1.clear() + print(s1) # set() + ``` + +2. 集合的运算： + - 并集（union 或 |）：获取所有元素 + ```python + s1 = {1, 2, 3} + s2 = {3, 4, 5} + print(s1.union(s2)) # {1, 2, 3, 4, 5} + print(s1 | s2) # {1, 2, 3, 4, 5} + ``` + + - 交集（intersection 或 &）：获取共有元素 + ```python + s1 = {1, 2, 3, 4} + s2 = {1, 2, 3, 4, 5, 6} + print(s1.intersection(s2)) # {1, 2, 3, 4} + print(s1 & s2) # {1, 2, 3, 4} + ``` + + - 差集（difference 或 -）：获取独有元素 + ```python + s1 = {1, 2, 3, 4, 5} + s2 = {3, 4, 5, 6, 7, 8, 9} + print(s1 - s2) # {1, 2} + print(s1.difference(s2)) # {1, 2} + ``` + + - 非对称差集（^）：获取非公共元素 + ```python + s1 = {1, 2, 3, 4, 5} + s2 = {3, 4, 5, 6, 7, 8, 9} + print(s1 ^ s2) # {1, 2, 6, 7, 8, 9} + ``` + +### 17.3 集合的转换 +```python +list_nums = [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] 集合转列表 +``` + +## Day 18: 数据容器梳理与字典 + +### 18.1 数据容器梳理 +Python中的5种数据容器： +1. 列表（list）： + - 存储多个元素 + - 有序 + - 可以重复 + - 可以通过索引下标进行读写 + +2. 元组（tuple）： + - 存储多个元素 + - 有序 + - 可以重复 + - 可以通过索引下标进行获取，不能修改 + +3. 集合（set）： + - 存储多个元素 + - 无序 + - 不能重复 + - 没有索引下标 + +4. 字典（dict）：键值对形式存储数据 +5. 字符串（str）：字符序列 + +创建符号： +- 列表：[1, 2, 3, 4, 5] +- 元组：(1, 2, 3, 4, 5) +- 集合：{1, 2, 3, 4, 5} +- 字典：{'key': 'value'} + +通用函数： +- len()：统计元素个数 +- sorted()：对元素进行排序 + +### 18.2 字典的基本概念 +字典是一种键值对形式的数据容器，具有以下特点： +- 使用{}存储数据 +- 每条数据包含键（key）和值（value） +- 键值对之间用逗号分隔 +- 键必须是唯一的，值可以重复 + +1. 字典的创建： +```python +student = { + 'name': 'lisi', + 'gender': '男', + 'age': 20 +} +print(type(student)) # +``` + +2. 字典的读写： +```python +# 读取值 +print(student['name']) # 'lisi' + +# 修改值 +student['name'] = 'zhangsan' +print(student) # {'name': 'zhangsan', 'gender': '男', 'age': 20} +``` + +3. 字典的嵌套： +```python +my_dict = { + 'k1': {'语文': 77, '数学': 66, '英语': 88}, + 'k2': {'语文': 71, '数学': 61, '英语': 81} +} +print(my_dict['k1']) # {'语文': 77, '数学': 66, '英语': 88} +print(my_dict['k1']['数学']) # 66 +``` + +### 18.3 字典的方法 +1. pop(key)：删除指定键值对并返回值 +```python +result = {'语文': 77, '数学': 66, '英语': 33} +print(result.pop('数学')) # 66 +print(result) # {'语文': 77, '英语': 33} +``` + +2. popitem()：删除并返回最后一对键值对 +```python +result = {'语文': 77, '数学': 66, '英语': 33} +print(result.popitem()) # ('英语', 33) +print(result) # {'语文': 77, '数学': 66} +``` + +3. clear()：清空字典 +```python +result = {'语文': 77, '数学': 66, '英语': 33} +result.clear() +print(result) # {} +``` + +4. keys()：获取所有键 +```python +person = { + 'name': 'zhangsan', + 'sex': '男', + 'age': 19, + 'class': 'IT231' +} +print(person.keys()) # dict_keys(['name', 'sex', 'age', 'class']) + +# 遍历键 +for key in person.keys(): + print(key) +``` + +5. values()：获取所有值 +```python +print(person.values()) # dict_values(['zhangsan', '男', 19, 'IT231']) +``` + +## Day 19: 数据容器梳理与算法题 + +### 19.1 数据容器梳理 +数据容器是一种可以容纳多个数据的数据类型，每个数据被称为元素，可以是任意数据类型。 + +1. 列表（list）： + - 使用中括号[]定义 + - 特点： + - 可以重复 + - 有序（有索引） + - 可以修改 + - 操作：定义、遍历、方法和函数 + +2. 元组（tuple）： + - 使用小括号()定义 + - 特点： + - 可以重复 + - 有序（有索引） + - 不可修改 + - 操作：定义、遍历、方法和函数 + +3. 集合（set）： + - 使用大括号{}定义 + - 特点： + - 不可重复 + - 无序 + - 不可修改 + - 操作：定义、遍历、方法和函数 + +4. 字典（dict）： + - 使用大括号{}定义，存储键值对 + - 特点： + - key不可重复（重复会覆盖） + - 无序（无索引） + - 可以修改值 + - key和value可以是任意类型 + - 操作：定义、遍历、方法和函数 + +5. 字符串（str）： + - 使用引号定义 + - 操作：遍历、方法和函数 + +### 19.2 数据容器的算法题 +1. 列表反转： +```python +lst = [1, 2, 3, 4, 5] +reversed_lst = lst[::-1] +print(f"反转后的列表是 {reversed_lst}") +``` + +2. 查找列表中的最大值和最小值： +```python +lst = [3, 1, 7, 5, 2] +max_value = max(lst) +min_value = min(lst) +print(f"最大值是 {max_value}") +print(f"最小值是 {min_value}") +``` + +3. 字典的键值交换： +```python +d = {'a': 1, 'b': 2, 'c': 3} +reversed_dict = {v: k for k, v in d.items()} +print(f"反转后的字典是 {reversed_dict}") +``` + +4. 集合的运算： +```python +set1 = {1, 2, 3} +set2 = {3, 4, 5} + +union = set1 | set2 +intersection = set1 & set2 +difference = set1 - set2 + +print(f"并集是 {union}") +print(f"交集是 {intersection}") +print(f"差集是 {difference}") +``` + +5. 元组拆包： +```python +t = (1, 2, 3, 4) +a, b, c, d = t +print(f"拆包后的元素是 {a} {b} {c} {d}") +``` + +6. 列表去重： +```python +lst = [1, 2, 2, 3, 3, 4] +unique_lst = list(set(lst)) +print(f"去重后的列表是 {unique_lst}") +``` + +7. 查找出现次数最多的元素： +```python +from collections import Counter + +lst = [1, 2, 3, 1, 1, 2, 4] +counter = Counter(lst) +most_common_element = counter.most_common(1)[0][0] +print(f"出现次数最多的元素是 {most_common_element}") +``` + +8. 计算字典值的总和： +```python +d = {'Alice': 20, 'Bob': 25, 'Charlie': 30} +total = sum(d.values()) +print(f"字典中所有值的总和是 {total}") +``` + +9. 字典合并： +```python +dict1 = {'a': 1, 'b': 2} +dict2 = {'c': 3, 'd': 4} +merged_dict = {**dict1, **dict2} +print(f"合并后的字典是 {merged_dict}") +``` + +10. 从列表中删除指定元素： +```python +lst = [1, 2, 3, 1, 4, 1, 5] +remove_element = 1 +new_lst = [x for x in lst if x != remove_element] +print(f"删除后的列表是 {new_lst}") +``` + +11. 列表中的嵌套字典： +```python +lst = [{'name': 'Alice', 'age': 20}, {'name': 'Bob', 'age': 25}] +key = 'name' +values = [d[key] for d in lst if key in d] +print(f"所有的 '{key}' 值是 {values}") +``` + +12. 找出列表中的最大和最小元素的差值： +```python +lst = [10, 2, 8, 6, 4] +max_val = max(lst) +min_val = min(lst) +diff = max_val - min_val +print(f"最大值和最小值之间的差是 {diff}") +``` + +## Day 20: 字符串的操作与方法 + +### 20.1 数据容器的区别 +- 列表（list）：有序、可重复、可修改 +- 元组（tuple）：有序、可重复、不可修改 +- 集合（set）：无序、不可重复、不可修改 +- 字典（dict）：无序、key重复会覆盖，通过key访问 +- 字符串（str）：字符序列，可遍历、不可修改 + +常用转换函数： +- list()、tuple()、set()、dict()、str() + +### 20.2 字符串的基本操作 +- 字符串是字符的容器，可以通过索引下标访问每个字符： +```python +str = 'hello' +print(str[0]) # h +print(str[-1]) # o +``` +- 字符串不可修改（不可变类型）。 + +### 20.3 字符串的遍历 +- while循环： +```python +str = 'abcdefgh' +i = 0 +while i < len(str): + print(str[i]) + i += 1 +``` +- for循环： +```python +str = 'ABCDEFGH' +for v in str: + print(v) +``` +- 也可用for+range遍历索引。 + +### 20.4 字符串的常用方法 +- lower() / upper()：转小写/大写 +- islower() / isnumeric()：判断是否全小写/是否全为数字 +- startswith()/endswith()：判断是否以指定内容开头/结尾，可指定区间 +- split()：分割字符串为列表 +- count()：统计子串出现次数 +- replace(old, new, count)：替换子串 +- center(width, fillchar)：居中显示并填充 +- strip(chars)：去除两侧指定字符 +- zfill(width)：左侧补0到指定宽度 +- join(iterator)：用指定分隔符拼接序列 +- format()：格式化字符串 + +#### 示例代码： +```python +s = 'ABCdef' +print(s.lower()) # abcdef +print(s.upper()) # ABCDEF +print('hello'.startswith('h')) # True +print('hello'.endswith('o')) # True +print('a b c'.split()) # ['a', 'b', 'c'] +print('hello,hello'.count('hello')) # 2 +print('hello world'.replace('hello', 'hi')) # hi world +print('hello'.center(10, '*')) # **hello*** +print(' abcd '.strip()) # abcd +print('zhangsan'.zfill(10)) # 000zhangsan +print('-'.join(['a', 'b', 'c'])) # a-b-c +print('我的名字是{0},我今年{1}岁'.format('zhangsan', 18)) +``` + +## Day 21: 切片与字符串练习 + +### 21.1 切片的概念与语法 +- 切片是从一个序列中截取出一个子序列的操作。 +- 适用于列表、元组、字符串等序列类型。 +- 语法：`序列[起始下标:结束下标:步长]` + - 起始下标：截取的起始位置，留空表示从头开始。 + - 结束下标：截取的结束位置，不包含该位置，留空表示到结尾。 + - 步长：每次取值的间隔，默认为1，负数表示反向取值。 + +#### 示例： +```python +lst = [0,1,2,3,4,5,6,7,8,9] +print(lst[2:6]) # [2, 3, 4, 5] +print(lst[::2]) # [0, 2, 4, 6, 8] +print(lst[::-1]) # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0] +print(lst[-2:-5:-1]) # [8, 7, 6] + +s = '0123456789' +print(s[2:5]) # 234 +print(s[::-1]) # 9876543210 + +t = (0,1,2,3,4,5,6,7,8,9) +print(t[::-2]) # (9, 7, 5, 3, 1) +``` + +### 21.2 切片与字符串常见练习 +1. 反转列表/字符串： +```python +lst = [1, 2, 3, 4, 5] +print(lst[::-1]) # [5, 4, 3, 2, 1] +s = "hello" +print(s[::-1]) # "olleh" +``` +2. 获取子列表： +```python +lst = [10, 20, 30, 40, 50, 60] +print(lst[2:5]) # [30, 40, 50] +``` +3. 隔一个取一个： +```python +s = "abcdefghij" +print(s[::2]) # "acegik" +``` +4. 删除前三个元素： +```python +lst = [1,2,3,4,5,6,7,8,9] +lst = lst[3:] +print(lst) # [4, 5, 6, 7, 8, 9] +``` +5. 替换中间元素： +```python +lst = [1,2,3,4,5] +lst[len(lst)//2:len(lst)//2+1] = [10] +print(lst) # [1, 2, 10, 4, 5] +``` +6. 检查回文： +```python +def is_palindrome(s): + return s == s[::-1] +print(is_palindrome("radar")) # True +``` +7. 合并切片： +```python +a = [1,2,3] +b = [4,5,6] +print(a[:2] + b[-2:]) # [1, 2, 5, 6] +``` +8. 矩阵转置： +```python +matrix = [[1,2],[3,4],[5,6]] +transposed = [list(row) for row in zip(*matrix)] +print(transposed) # [[1, 3, 5], [2, 4, 6]] +``` +9. 字符串重组： +```python +s = "HelloWorld" +idx = s.index("World") +print(s[idx:] + s[:idx]) # "WorldHello" +``` +10. 列表深拷贝与浅拷贝： +```python +import copy +original = [1, 2, [3, 4]] +shallow_copy = original[:] +deep_copy = copy.deepcopy(original) +shallow_copy[2][0] = 99 +print(original) # [1, 2, [99, 4]] +deep_copy[2][0] = 100 +print(original) # [1, 2, [99, 4]] +``` + +### 21.3 字符串常见练习 +1. 判断是否是回文： +```python +s = "racecar" +print(s == s[::-1]) # True +``` +2. 统计某个字符出现次数： +```python +s = "hello" +print(s.count("l")) # 2 +``` +3. 删除字符串中的元音： +```python +s = "beautiful" +vowels = "aeiouAEIOU" +new_s = ''.join(c for c in s if c not in vowels) +print(new_s) # "btfl" +``` +4. 计算字符串中的单词数量： +```python +s = "I love Python" +print(len(s.split())) # 3 +``` +5. 检查字符串是否只包含字母： +```python +s = "Python123" +print(s.isalpha()) # False +``` +6. 字符串大小写转换： +```python +s = "Hello World" +print(s.swapcase()) # "hELLO wORLD" +``` +7. 删除字符串中的重复字符（保留首次顺序）： +```python +s = "banana" +seen = set() +new_s = ''.join(seen.add(c) or c for c in s if c not in seen) +print(new_s) # "ban" +``` +8. 获取第一个不重复的字符： +```python +s = "swiss" +for c in s: + if s.count(c) == 1: + print(c) # "w" + break +``` +9. 反转字符串中的单词： +```python +s = "I love Python" +print(' '.join(s.split()[::-1])) # "Python love I" +``` + +## Day 22: 推导式与相关函数 + +### 22.1 推导式的概念与语法 +- 推导式是一种简洁的for循环写法，用于生成新的容器（列表、集合、字典）。 +- 基本语法： + - 列表推导式：[表达式 for 变量 in 可迭代对象] + - 带条件的列表推导式：[表达式 for 变量 in 可迭代对象 if 条件] + - 双分支：[表达式1 if 条件 else 表达式2 for 变量 in 可迭代对象] + +#### 示例： +```python +# 普通for循环 +lst = [1,2,3,4,5,6,7,8,9] +newlst = [] +for item in lst: + newlst.append(item * 100) +print(newlst) # [100, 200, ..., 900] + +# 列表推导式 +print([item * 100 for item in lst]) + +# 带条件的列表推导式 +print([val for val in lst if val % 2 == 0]) # [2, 4, 6, 8] + +# 双分支 +print([True if val > 5 else False for val in lst]) # [False, False, ..., True] +``` + +### 22.2 集合推导式与字典推导式 +- 集合推导式：用大括号包裹，生成集合 +```python +set1 = {1,2,3,4,5,6,7,8,9} +newset = {val * 100 for val in set1} +print(newset) +``` +- 字典推导式：用大括号包裹，生成键值对 +```python +d = {'zhangsan':70, 'lisi':69, 'wangwu':60} +newdict = {key: value + 10 for key, value in d.items()} +print(newdict) # {'zhangsan': 80, 'lisi': 79, 'wangwu': 70} +``` + +### 22.3 推导式常见练习 +1. 字典转为特定格式字符串列表： +```python +d = {'x': 'A', 'y': 'B', 'z': 'C'} +print([f'{key} = {val}' for key, val in d.items()]) +``` +2. 列表元素大小写转换： +```python +lst = ["ADDD","dddDD","DDaa","sss"] +print([item.lower() for item in lst]) +print([item.upper() for item in lst]) +``` +3. 组合元组： +```python +print([(x, y) for x in range(0,6) if x%2==0 for y in range(0,6) if y%2!=0]) +``` +4. 99乘法表： +```python +print([f'{i}x{j}={i*j}' for i in range(1,10) for j in range(1,10)]) +``` +5. 矩阵元素乘积： +```python +M = [[1,2,3], [4,5,6], [7,8,9]] +N = [[2,2,2], [3,3,3], [4,4,4]] +print([M[i][j]*N[i][j] for i in range(3) for j in range(3)]) +print([[M[i][j]*N[i][j] for i in range(3)] for j in range(3)]) +``` + +### 22.4 enumerate和zip函数 +- enumerate：为可迭代对象生成索引号和元素的元组 +```python +lst = ['apple','banana','cherry'] +print([val for val in enumerate(lst)]) # [(0, 'apple'), (1, 'banana'), (2, 'cherry')] +``` +- zip：将多个可迭代对象按顺序配对成元组 +```python +list1 = [1,2,3,4,5] +list2 = ['a','b','c','d'] +list3 = ['A','B','C'] +print([val for val in zip(list1, list2, list3)]) # [(1, 'a', 'A'), (2, 'b', 'B'), (3, 'c', 'C')] +``` + +## Day 23: 函数基础 + +### 23.1 函数的概念与定义 +- 函数是一段可重复使用的代码块，用于执行特定任务 +- 函数定义语法： +```python +def 函数名(参数1, 参数2, ...): + 函数体 + return 返回值 +``` + +示例代码： +```python +# 无参数无返回值的函数 +def say_hello(): + print("Hello, World!") + +# 有参数有返回值的函数 +def add(a, b): + return a + b + +# 调用函数 +say_hello() # 输出：Hello, World! +result = add(3, 5) +print(result) # 输出：8 +``` + +### 23.2 函数的参数 +1. 位置参数： +```python +def greet(name, age): + print(f"你好，{name}，你今年{age}岁了") + +greet("张三", 18) # 参数按顺序传递 +``` + +2. 默认参数： +```python +def greet(name, age=18): + print(f"你好，{name}，你今年{age}岁了") + +greet("张三") # 使用默认年龄 +greet("李四", 20) # 覆盖默认年龄 +``` + +3. 关键字参数： +```python +def greet(name, age): + print(f"你好，{name}，你今年{age}岁了") + +greet(age=20, name="王五") # 使用参数名指定值 +``` + +4. 可变参数： +```python +# *args：接收任意数量的位置参数 +def sum_numbers(*args): + return sum(args) + +print(sum_numbers(1, 2, 3, 4)) # 输出：10 + +# **kwargs：接收任意数量的关键字参数 +def print_info(**kwargs): + for key, value in kwargs.items(): + print(f"{key}: {value}") + +print_info(name="张三", age=18, city="北京") +``` + +### 23.3 函数的返回值 +1. 单个返回值： +```python +def square(x): + return x * x + +result = square(5) +print(result) # 输出：25 +``` + +2. 多个返回值： +```python +def get_circle_info(radius): + area = 3.14 * radius * radius + perimeter = 2 * 3.14 * radius + return area, perimeter + +area, perimeter = get_circle_info(5) +print(f"面积：{area}, 周长：{perimeter}") +``` + +3. 无返回值： +```python +def print_message(): + print("这是一个消息") + # 没有return语句，默认返回None +``` + +### 23.4 函数的作用域 +1. 局部变量： +```python +def test(): + x = 10 # 局部变量 + print(x) + +test() +# print(x) # 错误：x未定义 +``` + +2. 全局变量： +```python +x = 100 # 全局变量 + +def test(): + print(x) # 可以访问全局变量 + +test() +print(x) # 可以访问全局变量 +``` + +3. global关键字： +```python +x = 100 + +def test(): + global x # 声明使用全局变量 + x = 200 # 修改全局变量 + print(x) + +test() +print(x) # 输出：200 +``` + +### 23.5 函数的高级特性 +1. 函数作为参数： +```python +def apply_operation(x, y, operation): + return operation(x, y) + +def add(a, b): + return a + b + +def multiply(a, b): + return a * b + +print(apply_operation(5, 3, add)) # 输出：8 +print(apply_operation(5, 3, multiply)) # 输出：15 +``` + +2. lambda表达式： +```python +# 使用lambda定义匿名函数 +square = lambda x: x * x +print(square(5)) # 输出：25 + +# 在函数中使用lambda +numbers = [1, 2, 3, 4, 5] +squared = list(map(lambda x: x * x, numbers)) +print(squared) # 输出：[1, 4, 9, 16, 25] +``` + +3. 函数装饰器： +```python +def log_function_call(func): + def wrapper(*args, **kwargs): + print(f"调用函数：{func.__name__}") + return func(*args, **kwargs) + return wrapper + +@log_function_call +def add(a, b): + return a + b + +print(add(3, 5)) # 输出：调用函数：add 8 +``` + +## Day 24: 函数进阶应用 + +### 24.1 递归函数 +- 递归是函数调用自身的过程 +- 递归函数必须包含基本情况（终止条件）和递归情况 + +示例代码： +```python +# 计算阶乘 +def factorial(n): + if n == 0 or n == 1: # 基本情况 + return 1 + else: # 递归情况 + return n * factorial(n - 1) + +print(factorial(5)) # 输出：120 + +# 斐波那契数列 +def fibonacci(n): + if n <= 1: # 基本情况 + return n + else: # 递归情况 + return fibonacci(n-1) + fibonacci(n-2) + +print(fibonacci(10)) # 输出：55 +``` + +### 24.2 闭包 +- 闭包是一个函数，它记住了创建时的环境变量 +- 闭包可以访问外部函数的变量 + +示例代码： +```python +def create_counter(): + count = 0 # 外部函数的变量 + + def counter(): + nonlocal count # 声明使用外部变量 + count += 1 + return count + + return counter + +# 创建计数器 +counter = create_counter() +print(counter()) # 输出：1 +print(counter()) # 输出：2 +print(counter()) # 输出：3 +``` + +### 24.3 生成器函数 +- 使用yield关键字创建生成器 +- 生成器可以逐个产生值，而不是一次性生成所有值 + +示例代码： +```python +def number_generator(n): + for i in range(n): + yield i + +# 使用生成器 +gen = number_generator(5) +for num in gen: + print(num) # 输出：0 1 2 3 4 + +# 生成器表达式 +squares = (x*x for x in range(5)) +print(list(squares)) # 输出：[0, 1, 4, 9, 16] +``` + +### 24.4 函数式编程 +1. map函数： +```python +# 将函数应用于可迭代对象的每个元素 +numbers = [1, 2, 3, 4, 5] +squared = list(map(lambda x: x**2, numbers)) +print(squared) # 输出：[1, 4, 9, 16, 25] +``` + +2. filter函数： +```python +# 过滤可迭代对象中的元素 +numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] +even_numbers = list(filter(lambda x: x % 2 == 0, numbers)) +print(even_numbers) # 输出：[2, 4, 6, 8, 10] +``` + +3. reduce函数： +```python +from functools import reduce + +# 将函数应用于可迭代对象的所有元素，返回单个值 +numbers = [1, 2, 3, 4, 5] +product = reduce(lambda x, y: x * y, numbers) +print(product) # 输出：120 +``` + +### 24.5 函数的高级应用 +1. 函数缓存： +```python +from functools import lru_cache + +@lru_cache(maxsize=128) +def fibonacci(n): + if n <= 1: + return n + return fibonacci(n-1) + fibonacci(n-2) + +print(fibonacci(10)) # 输出：55 +``` + +2. 函数参数检查： +```python +def validate_input(func): + def wrapper(*args, **kwargs): + for arg in args: + if not isinstance(arg, (int, float)): + raise TypeError("参数必须是数字") + return func(*args, **kwargs) + return wrapper + +@validate_input +def add(a, b): + return a + b + +print(add(1, 2)) # 输出：3 +# print(add("1", 2)) # 引发TypeError +``` + +3. 函数计时器： +```python +import time + +def timer(func): + def wrapper(*args, **kwargs): + start_time = time.time() + result = func(*args, **kwargs) + end_time = time.time() + print(f"函数 {func.__name__} 执行时间：{end_time - start_time:.4f} 秒") + return result + return wrapper + +@timer +def slow_function(): + time.sleep(1) + return "完成" + +print(slow_function()) # 输出：函数 slow_function 执行时间：1.0000 秒 +``` + +### 24.6 函数的最佳实践 +1. 函数命名规范： +```python +# 使用小写字母和下划线 +def calculate_average(): + pass + +# 动词开头 +def get_user_info(): + pass + +# 描述性名称 +def convert_temperature(): + pass +``` + +2. 函数文档字符串： +```python +def calculate_circle_area(radius): + """ + 计算圆的面积 + + 参数: + radius (float): 圆的半径 + + 返回: + float: 圆的面积 + """ + return 3.14 * radius * radius +``` + +3. 函数参数默认值： +```python +def create_user(name, age=18, city="北京"): + """ + 创建用户信息 + + 参数: + name (str): 用户名 + age (int, optional): 年龄，默认为18 + city (str, optional): 城市，默认为北京 + """ + return {"name": name, "age": age, "city": city} +``` + +## Day 25: 模块和包 + +### 25.1 模块的概念 +- 模块是一个包含Python代码的文件 +- 模块可以包含函数、类和变量 +- 使用模块可以组织代码，提高代码的复用性 + +示例代码： +```python +# math_operations.py +def add(a, b): + return a + b + +def subtract(a, b): + return a - b + +def multiply(a, b): + return a * b + +def divide(a, b): + if b == 0: + raise ValueError("除数不能为0") + return a / b +``` + +### 25.2 导入模块 +1. 导入整个模块： +```python +import math_operations + +result = math_operations.add(5, 3) +print(result) # 输出：8 +``` + +2. 导入特定函数： +```python +from math_operations import add, subtract + +result = add(5, 3) +print(result) # 输出：8 +``` + +3. 使用别名： +```python +import math_operations as mo +from math_operations import add as addition + +result = mo.multiply(5, 3) +print(result) # 输出：15 + +sum_result = addition(5, 3) +print(sum_result) # 输出：8 +``` + +### 25.3 内置模块 +1. math模块： +```python +import math + +print(math.pi) # 输出：3.141592653589793 +print(math.sqrt(16)) # 输出：4.0 +print(math.pow(2, 3)) # 输出：8.0 +``` + +2. random模块： +```python +import random + +print(random.random()) # 输出：0到1之间的随机数 +print(random.randint(1, 10)) # 输出：1到10之间的随机整数 +print(random.choice(['apple', 'banana', 'orange'])) # 随机选择一个元素 +``` + +3. datetime模块： +```python +from datetime import datetime, timedelta + +now = datetime.now() +print(now) # 输出当前时间 + +future = now + timedelta(days=7) +print(future) # 输出7天后的时间 +``` + +### 25.4 包的概念 +- 包是一个包含多个模块的目录 +- 包必须包含一个`__init__.py`文件 +- 包可以组织相关的模块 + +示例结构： +``` +my_package/ + __init__.py + math_operations.py + string_operations.py + utils.py +``` + +### 25.5 创建和使用包 +1. 创建包： +```python +# my_package/__init__.py +from .math_operations import add, subtract +from .string_operations import reverse_string + +# my_package/math_operations.py +def add(a, b): + return a + b + +def subtract(a, b): + return a - b + +# my_package/string_operations.py +def reverse_string(text): + return text[::-1] +``` + +2. 使用包： +```python +from my_package import add, reverse_string + +print(add(5, 3)) # 输出：8 +print(reverse_string("Hello")) # 输出：olleH +``` + +### 25.6 模块和包的最佳实践 +1. 模块命名规范： +```python +# 使用小写字母和下划线 +math_operations.py +string_utils.py +data_processing.py +``` + +2. 包的结构： +``` +project/ + package1/ + __init__.py + module1.py + module2.py + package2/ + __init__.py + module3.py + module4.py + main.py +``` + +3. 相对导入： +```python +# 在包内使用相对导入 +from .module1 import function1 +from ..package2.module3 import function3 +``` + +4. 模块文档： +```python +""" +这是一个数学运算模块 + +这个模块提供了基本的数学运算功能，包括： +- 加法 +- 减法 +- 乘法 +- 除法 +""" + +def add(a, b): + """ + 计算两个数的和 + + 参数: + a (int/float): 第一个数 + b (int/float): 第二个数 + + 返回: + int/float: 两个数的和 + """ + return a + b +``` + +### 25.7 常用第三方包 +1. requests：HTTP请求 +```python +import requests + +response = requests.get('https://api.example.com/data') +print(response.json()) +``` + +2. pandas：数据处理 +```python +import pandas as pd + +df = pd.DataFrame({ + 'name': ['张三', '李四', '王五'], + 'age': [20, 25, 30] +}) +print(df) +``` + +3. numpy：科学计算 +```python +import numpy as np + +arr = np.array([1, 2, 3, 4, 5]) +print(arr.mean()) # 计算平均值 +print(arr.std()) # 计算标准差 +``` + +## Day 26: 面向对象编程基础 + +### 26.1 类和对象的概念 +- 类是一个模板，用于创建对象 +- 对象是类的实例，具有属性和方法 +- 属性是对象的特征 +- 方法是对象的行为 + +示例代码： +```python +class Person: + # 类属性 + species = "人类" + + # 初始化方法 + def __init__(self, name, age): + # 实例属性 + self.name = name + self.age = age + + # 实例方法 + def introduce(self): + return f"我叫{self.name}，今年{self.age}岁" + +# 创建对象 +person1 = Person("张三", 20) +person2 = Person("李四", 25) + +# 访问属性和方法 +print(person1.name) # 输出：张三 +print(person1.introduce()) # 输出：我叫张三，今年20岁 +print(Person.species) # 输出：人类 +``` + +### 26.2 类的属性 +1. 类属性： +```python +class Student: + # 类属性 + school = "第一中学" + total_students = 0 + + def __init__(self, name): + self.name = name + Student.total_students += 1 + +# 访问类属性 +print(Student.school) # 输出：第一中学 + +# 创建对象 +student1 = Student("张三") +student2 = Student("李四") +print(Student.total_students) # 输出：2 +``` + +2. 实例属性： +```python +class Car: + def __init__(self, brand, model, year): + self.brand = brand + self.model = model + self.year = year + self.speed = 0 # 初始速度 + + def accelerate(self): + self.speed += 10 + + def brake(self): + self.speed -= 5 + +# 创建对象 +car = Car("丰田", "卡罗拉", 2020) +print(car.brand) # 输出：丰田 +car.accelerate() +print(car.speed) # 输出：10 +``` + +### 26.3 类的方法 +1. 实例方法： +```python +class Rectangle: + def __init__(self, width, height): + self.width = width + self.height = height + + def area(self): + return self.width * self.height + + def perimeter(self): + return 2 * (self.width + self.height) + +rect = Rectangle(5, 3) +print(rect.area()) # 输出：15 +print(rect.perimeter()) # 输出：16 +``` + +2. 类方法： +```python +class MathUtils: + pi = 3.14159 + + @classmethod + def circle_area(cls, radius): + return cls.pi * radius * radius + + @classmethod + def circle_perimeter(cls, radius): + return 2 * cls.pi * radius + +print(MathUtils.circle_area(5)) # 输出：78.53975 +``` + +3. 静态方法： +```python +class StringUtils: + @staticmethod + def is_palindrome(text): + return text == text[::-1] + + @staticmethod + def count_words(text): + return len(text.split()) + +print(StringUtils.is_palindrome("level")) # 输出：True +print(StringUtils.count_words("Hello World")) # 输出：2 +``` + +### 26.4 封装 +1. 私有属性和方法： +```python +class BankAccount: + def __init__(self, account_number, balance): + self.__account_number = account_number # 私有属性 + self.__balance = balance + + def __validate_amount(self, amount): # 私有方法 + return amount > 0 + + def deposit(self, amount): + if self.__validate_amount(amount): + self.__balance += amount + return True + return False + + def get_balance(self): + return self.__balance + +account = BankAccount("12345", 1000) +account.deposit(500) +print(account.get_balance()) # 输出：1500 +``` + +2. 属性装饰器： +```python +class Person: + def __init__(self, name, age): + self.__name = name + self.__age = age + + @property + def name(self): + return self.__name + + @name.setter + def name(self, value): + if not isinstance(value, str): + raise ValueError("名字必须是字符串") + self.__name = value + + @property + def age(self): + return self.__age + + @age.setter + def age(self, value): + if not isinstance(value, int) or value < 0: + raise ValueError("年龄必须是正整数") + self.__age = value + +person = Person("张三", 20) +print(person.name) # 输出：张三 +person.name = "李四" +print(person.name) # 输出：李四 +``` + +### 26.5 继承 +1. 单继承： +```python +class Animal: + def __init__(self, name): + self.name = name + + def speak(self): + pass + +class Dog(Animal): + def speak(self): + return f"{self.name}说：汪汪！" + +class Cat(Animal): + def speak(self): + return f"{self.name}说：喵喵！" + +dog = Dog("旺财") +cat = Cat("咪咪") +print(dog.speak()) # 输出：旺财说：汪汪！ +print(cat.speak()) # 输出：咪咪说：喵喵！ +``` + +2. 多继承： +```python +class Flyable: + def fly(self): + return "我能飞" + +class Swimmable: + def swim(self): + return "我能游泳" + +class Duck(Flyable, Swimmable): + def __init__(self, name): + self.name = name + + def speak(self): + return f"{self.name}说：嘎嘎！" + +duck = Duck("唐老鸭") +print(duck.speak()) # 输出：唐老鸭说：嘎嘎！ +print(duck.fly()) # 输出：我能飞 +print(duck.swim()) # 输出：我能游泳 +``` + +### 26.6 多态 +```python +class Shape: + def area(self): + pass + +class Circle(Shape): + def __init__(self, radius): + self.radius = radius + + def area(self): + return 3.14 * self.radius * self.radius + +class Rectangle(Shape): + def __init__(self, width, height): + self.width = width + self.height = height + + def area(self): + return self.width * self.height + +def print_area(shape): + print(f"面积是：{shape.area()}") + +# 多态示例 +circle = Circle(5) +rectangle = Rectangle(4, 6) + +print_area(circle) # 输出：面积是：78.5 +print_area(rectangle) # 输出：面积是：24 +``` + +## Day 27: 面向对象编程进阶 + +### 27.1 抽象类和接口 +1. 抽象类： +```python +from abc import ABC, abstractmethod + +class Shape(ABC): + @abstractmethod + def area(self): + pass + + @abstractmethod + def perimeter(self): + pass + +class Circle(Shape): + def __init__(self, radius): + self.radius = radius + + def area(self): + return 3.14 * self.radius * self.radius + + def perimeter(self): + return 2 * 3.14 * self.radius + +# 不能直接实例化抽象类 +# shape = Shape() # 会报错 + +circle = Circle(5) +print(circle.area()) # 输出：78.5 +``` + +2. 接口（通过抽象类实现）： +```python +from abc import ABC, abstractmethod + +class PaymentMethod(ABC): + @abstractmethod + def pay(self, amount): + pass + +class CreditCard(PaymentMethod): + def pay(self, amount): + return f"使用信用卡支付{amount}元" + +class Alipay(PaymentMethod): + def pay(self, amount): + return f"使用支付宝支付{amount}元" + +# 使用接口 +def process_payment(payment_method, amount): + return payment_method.pay(amount) + +card = CreditCard() +alipay = Alipay() + +print(process_payment(card, 100)) # 输出：使用信用卡支付100元 +print(process_payment(alipay, 200)) # 输出：使用支付宝支付200元 +``` + +### 27.2 魔术方法 +1. 基本魔术方法： +```python +class Person: + def __init__(self, name, age): + self.name = name + self.age = age + + def __str__(self): + return f"Person(name={self.name}, age={self.age})" + + def __repr__(self): + return f"Person('{self.name}', {self.age})" + + def __len__(self): + return len(self.name) + + def __bool__(self): + return self.age >= 18 + +person = Person("张三", 20) +print(str(person)) # 输出：Person(name=张三, age=20) +print(repr(person)) # 输出：Person('张三', 20) +print(len(person)) # 输出：2 +print(bool(person)) # 输出：True +``` + +2. 运算符魔术方法： +```python +class Vector: + def __init__(self, x, y): + self.x = x + self.y = y + + def __add__(self, other): + return Vector(self.x + other.x, self.y + other.y) + + def __sub__(self, other): + return Vector(self.x - other.x, self.y - other.y) + + def __mul__(self, scalar): + return Vector(self.x * scalar, self.y * scalar) + + def __str__(self): + return f"Vector({self.x}, {self.y})" + +v1 = Vector(1, 2) +v2 = Vector(3, 4) + +print(v1 + v2) # 输出：Vector(4, 6) +print(v2 - v1) # 输出：Vector(2, 2) +print(v1 * 2) # 输出：Vector(2, 4) +``` + +### 27.3 描述符 +1. 属性描述符： +```python +class ValidString: + def __init__(self, minlen=0, maxlen=None): + self.minlen = minlen + self.maxlen = maxlen + + def __get__(self, instance, owner): + return instance.__dict__.get(self.name) + + def __set__(self, instance, value): + if not isinstance(value, str): + raise TypeError("值必须是字符串") + if len(value) < self.minlen: + raise ValueError(f"字符串长度不能小于{self.minlen}") + if self.maxlen and len(value) > self.maxlen: + raise ValueError(f"字符串长度不能大于{self.maxlen}") + instance.__dict__[self.name] = value + + def __set_name__(self, owner, name): + self.name = name + +class User: + name = ValidString(minlen=2, maxlen=20) + email = ValidString(minlen=5, maxlen=50) + + def __init__(self, name, email): + self.name = name + self.email = email + +user = User("张三", "zhangsan@example.com") +print(user.name) # 输出：张三 +print(user.email) # 输出：zhangsan@example.com +``` + +### 27.4 元类 +1. 基本元类： +```python +class MetaLogger(type): + def __new__(cls, name, bases, attrs): + print(f"创建类：{name}") + return super().__new__(cls, name, bases, attrs) + + def __init__(cls, name, bases, attrs): + print(f"初始化类：{name}") + super().__init__(name, bases, attrs) + +class MyClass(metaclass=MetaLogger): + def __init__(self): + print("初始化实例") + +# 创建类时会打印日志 +obj = MyClass() +``` + +2. 单例模式： +```python +class Singleton(type): + _instances = {} + + def __call__(cls, *args, **kwargs): + if cls not in cls._instances: + cls._instances[cls] = super().__call__(*args, **kwargs) + return cls._instances[cls] + +class Database(metaclass=Singleton): + def __init__(self): + print("初始化数据库连接") + + def query(self, sql): + return f"执行SQL：{sql}" + +# 创建多个实例，但只会初始化一次 +db1 = Database() +db2 = Database() +print(db1 is db2) # 输出：True +``` + +### 27.5 设计模式 +1. 工厂模式： +```python +class Animal: + def speak(self): + pass + +class Dog(Animal): + def speak(self): + return "汪汪！" + +class Cat(Animal): + def speak(self): + return "喵喵！" + +class AnimalFactory: + @staticmethod + def create_animal(animal_type): + if animal_type == "dog": + return Dog() + elif animal_type == "cat": + return Cat() + else: + raise ValueError("未知的动物类型") + +# 使用工厂创建对象 +factory = AnimalFactory() +dog = factory.create_animal("dog") +cat = factory.create_animal("cat") + +print(dog.speak()) # 输出：汪汪！ +print(cat.speak()) # 输出：喵喵！ +``` + +2. 观察者模式： +```python +class Subject: + def __init__(self): + self._observers = [] + + def attach(self, observer): + self._observers.append(observer) + + def detach(self, observer): + self._observers.remove(observer) + + def notify(self, message): + for observer in self._observers: + observer.update(message) + +class Observer: + def update(self, message): + pass + +class NewsAgency(Subject): + def publish_news(self, news): + self.notify(news) + +class NewsChannel(Observer): + def __init__(self, name): + self.name = name + + def update(self, message): + print(f"{self.name}收到新闻：{message}") + +# 使用观察者模式 +agency = NewsAgency() +channel1 = NewsChannel("CCTV") +channel2 = NewsChannel("BBC") + +agency.attach(channel1) +agency.attach(channel2) + +agency.publish_news("重大新闻！") +``` + +### 27.6 最佳实践 +1. 组合优于继承： +```python +class Engine: + def start(self): + return "引擎启动" + +class Wheel: + def rotate(self): + return "轮子转动" + +class Car: + def __init__(self): + self.engine = Engine() + self.wheels = [Wheel() for _ in range(4)] + + def start(self): + return self.engine.start() + + def drive(self): + return [wheel.rotate() for wheel in self.wheels] + +car = Car() +print(car.start()) # 输出：引擎启动 +print(car.drive()) # 输出：['轮子转动', '轮子转动', '轮子转动', '轮子转动'] +``` + +2. 依赖注入： +```python +class Database: + def query(self, sql): + return f"执行SQL：{sql}" + +class UserService: + def __init__(self, database): + self.database = database + + def get_user(self, user_id): + return self.database.query(f"SELECT * FROM users WHERE id = {user_id}") + +# 使用依赖注入 +db = Database() +user_service = UserService(db) +print(user_service.get_user(1)) +``` \ No newline at end of file diff --git a/day01/code/01-认识编辑器.py b/day01/code/01-认识编辑器.py new file mode 100644 index 0000000..ed48c62 --- /dev/null +++ b/day01/code/01-认识编辑器.py @@ -0,0 +1,7 @@ +print('hello world') +print(1+2+3) + +# 下载安装设置好vscode 启动vscode +# 下载插件 +# 新建第一个py文件 .py + diff --git a/day01/code/02-第一个py文件.py b/day01/code/02-第一个py文件.py new file mode 100644 index 0000000..768677f --- /dev/null +++ b/day01/code/02-第一个py文件.py @@ -0,0 +1,4 @@ +# print函数 输出的意思 +print('你好 世界') +print(10*10) + diff --git a/day01/code/03-print函数的介绍.py b/day01/code/03-print函数的介绍.py new file mode 100644 index 0000000..3a8a575 --- /dev/null +++ b/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('世界') + diff --git a/day01/code/04-字面量和常量.py b/day01/code/04-字面量和常量.py new file mode 100644 index 0000000..c3716d7 --- /dev/null +++ b/day01/code/04-字面量和常量.py @@ -0,0 +1,14 @@ +# 字面量 是一个固定的值 它在程序中可以直接使用 +# 数字字面量 3.14 +# 字符串字面量 'hello' + +# 常量 变量 都是可以存值 +# 常量 给特定的值存一个名字 约定这个名字是大写 同时不要修改值 +PI=3.14 +print(PI) + +# 变量 给特定的值存一个名字 值是可以修改的 +name='zhangsan' +name='张三' +print(name) + diff --git a/day01/code/05-注释.py b/day01/code/05-注释.py new file mode 100644 index 0000000..2df0147 --- /dev/null +++ b/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) + diff --git a/day01/code/06-常用的值类型.py b/day01/code/06-常用的值类型.py new file mode 100644 index 0000000..ac902d7 --- /dev/null +++ b/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.掌握数字和字符串的声明定义和输出 \ No newline at end of file diff --git a/day02/code/01-字符串的操作.py b/day02/code/01-字符串的操作.py new file mode 100644 index 0000000..b4f447d --- /dev/null +++ b/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就是最后一个字符 \ No newline at end of file diff --git a/day02/code/02-输入函数input.py b/day02/code/02-输入函数input.py new file mode 100644 index 0000000..a4a9695 --- /dev/null +++ b/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)) + + + + + + diff --git a/day02/code/03-数据类型的检测.py b/day02/code/03-数据类型的检测.py new file mode 100644 index 0000000..39dbdc0 --- /dev/null +++ b/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) + + + diff --git a/day02/code/04-作业.py b/day02/code/04-作业.py new file mode 100644 index 0000000..2e1ef47 --- /dev/null +++ b/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) \ No newline at end of file diff --git a/day03/01-转换数据类型的函数.py b/day03/01-转换数据类型的函数.py new file mode 100644 index 0000000..e6416b3 --- /dev/null +++ b/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) + + + diff --git a/day03/02-算术运算符.py b/day03/02-算术运算符.py new file mode 100644 index 0000000..e8535cf --- /dev/null +++ b/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 \ No newline at end of file diff --git a/day03/03-赋值运算符.py b/day03/03-赋值运算符.py new file mode 100644 index 0000000..9a7cc00 --- /dev/null +++ b/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 \ No newline at end of file diff --git a/day03/04-复合赋值运算符.py b/day03/04-复合赋值运算符.py new file mode 100644 index 0000000..f9e6341 --- /dev/null +++ b/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 \ No newline at end of file diff --git a/day03/05-内置的数字运算函数.py b/day03/05-内置的数字运算函数.py new file mode 100644 index 0000000..88e3557 --- /dev/null +++ b/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)) \ No newline at end of file diff --git a/day03/06-变量.py b/day03/06-变量.py new file mode 100644 index 0000000..397e2ab --- /dev/null +++ b/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 diff --git a/day04/01-作业.py b/day04/01-作业.py new file mode 100644 index 0000000..83d4f87 --- /dev/null +++ b/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)+'小时') + + + + diff --git a/day04/02-作业.py b/day04/02-作业.py new file mode 100644 index 0000000..704c569 --- /dev/null +++ b/day04/02-作业.py @@ -0,0 +1,13 @@ +# 编写一个程序，输入矩形的长和宽，输出矩形的面积和周长 + +# 输入矩形的长和宽 +length = float(input("请输入矩形的长: ")) +width = float(input("请输入矩形的宽: ")) + +# 计算面积和周长 +area = length * width +perimeter = 2 * (length + width) + +# 输出结果 +print("矩形的面积为: ", area) +print("矩形的周长为: ", perimeter) \ No newline at end of file diff --git a/day04/03-作业.py b/day04/03-作业.py new file mode 100644 index 0000000..c74bca1 --- /dev/null +++ b/day04/03-作业.py @@ -0,0 +1,11 @@ +# 编写一个程序，输入一个数字，输出该数字的平方和立方 +# 输入数字 +num = float(input("请输入一个数字: ")) + +# 计算平方和立方 +square = num ** 2 +cube = num ** 3 + +# 输出结果 +print(f"{num} 的平方是 {square}") +print(f"{num} 的立方是 {cube}") \ No newline at end of file diff --git a/day04/04-作业.py b/day04/04-作业.py new file mode 100644 index 0000000..04f421a --- /dev/null +++ b/day04/04-作业.py @@ -0,0 +1,15 @@ +# 扩展class(类) - 非常重要 +# 1.类： +# 表示一类事物(和生活中的类一致的)，是抽象(不具体)的， +# 比如：人类，动物类，植物类 + +# 2.对象：对象是类下面的具体事物，对象是真实存在的，一般对象都拥有属性和方法 +# 比如：刘德华，尼古拉斯赵四，华南虎 + +# 3.属性：属性是用来描述对象的，属性是对象的特点，属性是私有的(不同) +# 比如：刘德华的身高，体重，肤色... + +# 4.方法：方法是对象具有的功能，方法是对象公有的特点(相同) +# 比如：刘德华会走，会跑，会吃饭... + +# 程序来源于生活，解决生活中一些复杂的问题 \ No newline at end of file diff --git a/day04/05-变量的命名规则与标识符.py b/day04/05-变量的命名规则与标识符.py new file mode 100644 index 0000000..170af2a --- /dev/null +++ b/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...) + +# 保留字：未来的关键字，将来会变成关键字 + +# 标识符的规则就是变量的命名规则，因为变量属于标识符的一种 \ No newline at end of file diff --git a/day04/06-字符串的扩展.py b/day04/06-字符串的扩展.py new file mode 100644 index 0000000..5f98e39 --- /dev/null +++ b/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)) +# 注意多个变量占位,变量要用括号括起来,并按照占位的顺序填入 \ No newline at end of file diff --git a/day04/08-作业.py b/day04/08-作业.py new file mode 100644 index 0000000..6b2d8dd --- /dev/null +++ b/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+'岁') + diff --git a/day04/09-作业.py b/day04/09-作业.py new file mode 100644 index 0000000..ab0c50c --- /dev/null +++ b/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) \ No newline at end of file diff --git a/day04/10-作业.py b/day04/10-作业.py new file mode 100644 index 0000000..41c9dba --- /dev/null +++ b/day04/10-作业.py @@ -0,0 +1,10 @@ +# 编写一个程序，输入两个数，计算并输出它们的平均值。 +# 输入两个数字 +num1 = float(input("请输入第一个数字: ")) +num2 = float(input("请输入第二个数字: ")) + +# 计算平均值 +average = (num1 + num2) / 2 + +# 输出结果 +print(f"{num1} 和 {num2} 的平均值是: {average}") \ No newline at end of file diff --git a/day04/11-作业.py b/day04/11-作业.py new file mode 100644 index 0000000..d2c5de8 --- /dev/null +++ b/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}") diff --git a/day04/12-作业.py b/day04/12-作业.py new file mode 100644 index 0000000..6e0136d --- /dev/null +++ b/day04/12-作业.py @@ -0,0 +1,10 @@ +# 编写一个程序，输入三角形的底和高，计算并输出其面积。 +# 输入底和高 +base = float(input("请输入三角形的底: ")) +height = float(input("请输入三角形的高: ")) + +# 计算面积 +area = 0.5 * base * height + +# 输出结果 +print(f"三角形的面积是: {area}") diff --git a/day04/13-字符串的扩展.py b/day04/13-字符串的扩展.py new file mode 100644 index 0000000..150b229 --- /dev/null +++ b/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("字符串")) # 逗号分隔打印多个值 \ No newline at end of file diff --git a/day05/01-条件测试.py b/day05/01-条件测试.py new file mode 100644 index 0000000..3b12735 --- /dev/null +++ b/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(不包含某个字符和子串) +""" \ No newline at end of file diff --git a/day05/02-比较运算符.py b/day05/02-比较运算符.py new file mode 100644 index 0000000..29e94fb --- /dev/null +++ b/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 + diff --git a/day05/03-程序的三大结构.py b/day05/03-程序的三大结构.py new file mode 100644 index 0000000..de67988 --- /dev/null +++ b/day05/03-程序的三大结构.py @@ -0,0 +1,13 @@ +# 程序的三大结构 +# 1.顺序结构：程序从上往下执行，遇到错误终止 +print(1) +print(2) +print(a) # 报错，因为a不存在，一旦报错，整个程序就结束了 +print('你好世界') + +# 2.选择结构 +# 程序在执行过程中，遇到了分支(人生走到岔路口，面临选择) +# 选择分为：单选择(单分支)、双选择(双分支)、多选择(多分支) + +# 3.循环结构 +# 重复 + 有规律 + 迭代 \ No newline at end of file diff --git a/day05/04-if语句.py b/day05/04-if语句.py new file mode 100644 index 0000000..52f3b46 --- /dev/null +++ b/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('回家看动画片') \ No newline at end of file diff --git a/day05/05-作业.py b/day05/05-作业.py new file mode 100644 index 0000000..1dfbe82 --- /dev/null +++ b/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},它是平年") # 不满足条件 + + + \ No newline at end of file diff --git a/day05/06-作业.py b/day05/06-作业.py new file mode 100644 index 0000000..b0e910b --- /dev/null +++ b/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}不是水仙花数') +""" \ No newline at end of file diff --git a/day05/07-作业.py b/day05/07-作业.py new file mode 100644 index 0000000..1dbe86d --- /dev/null +++ b/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} 不是闰年") diff --git a/day06/01-elif应用.py b/day06/01-elif应用.py new file mode 100644 index 0000000..11ed0e8 --- /dev/null +++ b/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 之间的整数") + + + + + + diff --git a/day06/02-练习.py b/day06/02-练习.py new file mode 100644 index 0000000..436f979 --- /dev/null +++ b/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("很遗憾，没有中奖！") diff --git a/day07/01-if语句的梳理.py b/day07/01-if语句的梳理.py new file mode 100644 index 0000000..9a8cdc6 --- /dev/null +++ b/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') + diff --git a/day07/02-if语句大练习.py b/day07/02-if语句大练习.py new file mode 100644 index 0000000..7627a10 --- /dev/null +++ b/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天') \ No newline at end of file diff --git a/day07/03-if语句大练习.py b/day07/03-if语句大练习.py new file mode 100644 index 0000000..43b312b --- /dev/null +++ b/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('你是标准身材,请继续保持!') \ No newline at end of file diff --git a/day07/04-判断语句的嵌套.py b/day07/04-判断语句的嵌套.py new file mode 100644 index 0000000..f197b58 --- /dev/null +++ b/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('你输入的数字不合法') \ No newline at end of file diff --git a/day07/05-作业.py b/day07/05-作业.py new file mode 100644 index 0000000..92510dc --- /dev/null +++ b/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}') # 淡季经济舱打三折 \ No newline at end of file diff --git a/day07/06-综合作业.py b/day07/06-综合作业.py new file mode 100644 index 0000000..e02369e --- /dev/null +++ b/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("输入错误") \ No newline at end of file diff --git a/day08/01-高级练习.py b/day08/01-高级练习.py new file mode 100644 index 0000000..5289ece --- /dev/null +++ b/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("输入错误，请输入数字") + diff --git a/day08/02-循环的意义.py b/day08/02-循环的意义.py new file mode 100644 index 0000000..260c229 --- /dev/null +++ b/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、循环体(满足条件执行的代码) + +# 四.死循环 +# 无法靠自身条件终止的代码的循环 diff --git a/day08/03-while循环.py b/day08/03-while循环.py new file mode 100644 index 0000000..4bebeea --- /dev/null +++ b/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 # 累加 初始值的迭代 + \ No newline at end of file diff --git a/day08/04-while循环练习.py b/day08/04-while循环练习.py new file mode 100644 index 0000000..c10116c --- /dev/null +++ b/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 \ No newline at end of file diff --git a/day08/05-while循环的高级练习.py b/day08/05-while循环的高级练习.py new file mode 100644 index 0000000..f534e66 --- /dev/null +++ b/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}。") + + + + + + + + + + + diff --git a/day09/01-正向和反向循环.py b/day09/01-正向和反向循环.py new file mode 100644 index 0000000..e66353b --- /dev/null +++ b/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 + + + \ No newline at end of file diff --git a/day09/02-break和continue.py b/day09/02-break和continue.py new file mode 100644 index 0000000..f41e205 --- /dev/null +++ b/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}次循环') + + + + diff --git a/day09/03-练习1.py b/day09/03-练习1.py new file mode 100644 index 0000000..4cce67f --- /dev/null +++ b/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}') + diff --git a/day09/04-练习2.py b/day09/04-练习2.py new file mode 100644 index 0000000..f578e45 --- /dev/null +++ b/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 # 结束循环 diff --git a/day09/05-综合练习.py b/day09/05-综合练习.py new file mode 100644 index 0000000..eabdeda --- /dev/null +++ b/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 \ No newline at end of file diff --git a/day10/01-三目运算符.py b/day10/01-三目运算符.py new file mode 100644 index 0000000..0cea4b9 --- /dev/null +++ b/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) + diff --git a/day10/02-练习.py b/day10/02-练习.py new file mode 100644 index 0000000..45c6832 --- /dev/null +++ b/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('不满足任何一个要求，不嫁') \ No newline at end of file diff --git a/day10/03-作业.py b/day10/03-作业.py new file mode 100644 index 0000000..a218026 --- /dev/null +++ b/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}") + + + + + + + diff --git a/day10/04-for循环.py b/day10/04-for循环.py new file mode 100644 index 0000000..76fd4f8 --- /dev/null +++ b/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) \ No newline at end of file diff --git a/day10/05-range函数.py b/day10/05-range函数.py new file mode 100644 index 0000000..30ac7f0 --- /dev/null +++ b/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) + + + \ No newline at end of file diff --git a/day10/06-作业.py b/day10/06-作业.py new file mode 100644 index 0000000..e027a50 --- /dev/null +++ b/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)) \ No newline at end of file diff --git a/day10/07-作业.py b/day10/07-作业.py new file mode 100644 index 0000000..7d676ad --- /dev/null +++ b/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)}") + + + + + + \ No newline at end of file diff --git a/day11/01-练习.py b/day11/01-练习.py new file mode 100644 index 0000000..2571991 --- /dev/null +++ b/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) diff --git a/day11/02-经典练习.py b/day11/02-经典练习.py new file mode 100644 index 0000000..591c506 --- /dev/null +++ b/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 + diff --git a/day11/03-循环的案例.py b/day11/03-循环的案例.py new file mode 100644 index 0000000..b2eedbe --- /dev/null +++ b/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}不是素数') \ No newline at end of file diff --git a/day11/04-作业.py b/day11/04-作业.py new file mode 100644 index 0000000..bcbb99f --- /dev/null +++ b/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}天') \ No newline at end of file diff --git a/day11/05-作业.py b/day11/05-作业.py new file mode 100644 index 0000000..adae09c --- /dev/null +++ b/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只小鸡 +""" \ No newline at end of file diff --git a/day12/01-作业.py b/day12/01-作业.py new file mode 100644 index 0000000..126b904 --- /dev/null +++ b/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}只') + + + + + + diff --git a/day12/02-作业.py b/day12/02-作业.py new file mode 100644 index 0000000..9960554 --- /dev/null +++ b/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) diff --git a/day12/03-总结.py b/day12/03-总结.py new file mode 100644 index 0000000..6be887d --- /dev/null +++ b/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) # 循环体 \ No newline at end of file diff --git a/day12/04-数据容器的入门.py b/day12/04-数据容器的入门.py new file mode 100644 index 0000000..bed8a9a --- /dev/null +++ b/day12/04-数据容器的入门.py @@ -0,0 +1,29 @@ +# 一、数据容器 +# 数据容器就是一种可以容纳多种数据的数据类型 容纳的每一个数据被称为元素 +# 每一个数据 可以是任意数据类型 如字符串 数字 布尔值等等 + +# 二、数据容器的部分特点 +# 1、所有的数据容器可以容纳多份数据 +num=100 # 一个数据 +names=['zhangsan','lisi','wangsan'] #多份数据 容器 + +# 2、是否支持重复数据 +# 有些容器里面不支持重复数据 有些支持 注意区别 + +# 3、是否可以修改 +# 有些容器里面可以支持修改数据 有些不支持 注意区别 + +# 4、是否有序 +# 有些容器里面的数据是有顺序的 有些没有顺序 注意区别 + +# 总结:注意区别是否支持重复 是否能够修改 是否有序 + +# 三、数据容器有5类 +# 列表(list) +# 元祖(tuple) +# 字符串(str) +# 集合(set) +# 字典(dict) + + + diff --git a/day12/05-列表的创建索引.py b/day12/05-列表的创建索引.py new file mode 100644 index 0000000..0b88a9f --- /dev/null +++ b/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)) # + +# 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]) #一层一层的扒开 通过下标找到对应的数字 diff --git a/day12/06-综合练习10.py b/day12/06-综合练习10.py new file mode 100644 index 0000000..df3dda1 --- /dev/null +++ b/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. 找出嵌套列表中所有偶数的和 +# 给定一个嵌套列表，找出其中所有偶数的和。 + + + diff --git a/day13/00-列表的创建和索引.py b/day13/00-列表的创建和索引.py new file mode 100644 index 0000000..06cdd43 --- /dev/null +++ b/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)) # + +# 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]) # 一层一层的扒开，通过下标找到对应的数字 \ No newline at end of file diff --git a/day13/01-列表的操作.py b/day13/01-列表的操作.py new file mode 100644 index 0000000..346c008 --- /dev/null +++ b/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]) + + + + + + + + diff --git a/day13/02-列表的常用方法.py b/day13/02-列表的常用方法.py new file mode 100644 index 0000000..4138770 --- /dev/null +++ b/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) + + + + + + + + + + + + + + + + diff --git a/day13/03-练习.py b/day13/03-练习.py new file mode 100644 index 0000000..9382514 --- /dev/null +++ b/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}") + + + + + + + + + + + + + + + + + diff --git a/day14/01-列表的方法.py b/day14/01-列表的方法.py new file mode 100644 index 0000000..dee53f3 --- /dev/null +++ b/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) \ No newline at end of file diff --git a/day14/02-列表的方法.py b/day14/02-列表的方法.py new file mode 100644 index 0000000..dc075e9 --- /dev/null +++ b/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)) + + + + + diff --git a/day14/03-列表方法的总结.py b/day14/03-列表方法的总结.py new file mode 100644 index 0000000..21a5d7f --- /dev/null +++ b/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不改变原列表 + + + + + + + + + + + + + + + + diff --git a/day14/04-列表的应用.py b/day14/04-列表的应用.py new file mode 100644 index 0000000..f54927a --- /dev/null +++ b/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表示开始的索引位置，负数表示从后往前) + + + diff --git a/day15/01-作业.py b/day15/01-作业.py new file mode 100644 index 0000000..768229c --- /dev/null +++ b/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}") + + + + + + + + + + + + + + + + + + + + + diff --git a/day15/02-列表的遍历.py b/day15/02-列表的遍历.py new file mode 100644 index 0000000..ff08a41 --- /dev/null +++ b/day15/02-列表的遍历.py @@ -0,0 +1,31 @@ +# 一、列表的遍历 +# 列表是一个容器 可以存储多个数据 如果需要按照需求依次取出元素进行操作 那么就需要遍历 + +list=['apple','banana','orange','grape'] +# 下标是有序的并且有规律的 使用循环进行操作 +# len函数 获取列表的元素个数 通过len函数设置循环遍历的条件 + +# while循环 +index=0 +while index len(list2): + merged_list.extend(list1[min_len:]) +else: + merged_list.extend(list2[min_len:]) + +print(merged_list) \ No newline at end of file diff --git a/day15/05-元祖.py b/day15/05-元祖.py new file mode 100644 index 0000000..3ef00e3 --- /dev/null +++ b/day15/05-元祖.py @@ -0,0 +1,28 @@ +# 容器的三大特征 是否有序 是否可以读写 是否可以有重复值 + +# 数据容器 - 元祖 +# 元祖同列表一样 可以封装多个不同类型的元素 但是最大的不同点在于元祖一但定义之后不能修改 + +# 1、定义元祖 +# 定义元祖的时候用小括号 用逗号隔开 数据可以是不同类型的 +t1=('zhangsan','lisi','wangwu') +t2=('apple',) #如果只有一个值 也要添加逗号 否则不是元祖(列表没有关系) +print(t1) +print(t2) +print(type(t1)) # + +# 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]) \ No newline at end of file diff --git a/day16/01-元祖的操作.py b/day16/01-元祖的操作.py new file mode 100644 index 0000000..9db52c9 --- /dev/null +++ b/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倍 + + + + + diff --git a/day16/02-元祖和列表的转换.py b/day16/02-元祖和列表的转换.py new file mode 100644 index 0000000..4973e12 --- /dev/null +++ b/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) + + diff --git a/day16/03-元祖的方法和函数.py b/day16/03-元祖的方法和函数.py new file mode 100644 index 0000000..61728b7 --- /dev/null +++ b/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)) #降序 + + diff --git a/day16/04-元祖的应用.py b/day16/04-元祖的应用.py new file mode 100644 index 0000000..f0236c7 --- /dev/null +++ b/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'] \ No newline at end of file diff --git a/day16/05-元祖的练习.py b/day16/05-元祖的练习.py new file mode 100644 index 0000000..42834de --- /dev/null +++ b/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]) + + diff --git a/day17/01-集合.py b/day17/01-集合.py new file mode 100644 index 0000000..9b716a0 --- /dev/null +++ b/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) + + + + diff --git a/day17/02-集合的方法和函数.py b/day17/02-集合的方法和函数.py new file mode 100644 index 0000000..ff6189f --- /dev/null +++ b/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} + + + + + diff --git a/day17/03-转换.py b/day17/03-转换.py new file mode 100644 index 0000000..fd0ad9a --- /dev/null +++ b/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] 将列表转为集合 通过列表函数将集合转为列表 + + + diff --git a/day17/03-集合的应用.py b/day17/03-集合的应用.py new file mode 100644 index 0000000..7649910 --- /dev/null +++ b/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)) # {'陈二', '刘一'} + + + + + + + + + \ No newline at end of file diff --git a/day17/05-集合的作业.py b/day17/05-集合的作业.py new file mode 100644 index 0000000..8555285 --- /dev/null +++ b/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("第一个集合不是第二个集合的超集") + + + + + diff --git a/day18/01-练习.py b/day18/01-练习.py new file mode 100644 index 0000000..cd7bc06 --- /dev/null +++ b/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}") + + + diff --git a/day18/02-梳理数据容器.py b/day18/02-梳理数据容器.py new file mode 100644 index 0000000..7d33947 --- /dev/null +++ b/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): 差集 diff --git a/day18/03-字典.py b/day18/03-字典.py new file mode 100644 index 0000000..59a3104 --- /dev/null +++ b/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)) # + +# 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) \ No newline at end of file diff --git a/day18/04-字典的应用.py b/day18/04-字典的应用.py new file mode 100644 index 0000000..711682c --- /dev/null +++ b/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])) \ No newline at end of file diff --git a/day18/05-字典的方法.py b/day18/05-字典的方法.py new file mode 100644 index 0000000..4149e33 --- /dev/null +++ b/day18/05-字典的方法.py @@ -0,0 +1,33 @@ +# 字典的方法 +# 1、dict.pop(key) 取出key对应的vlaue并在字典中删除此key的键值对 +result={'语文':77,'数学':66,'英语':33} +print(result.pop('数学')) #66 必须添加key +print(result) + +# 2、dict.popitem() 删除并返回字典的最后一堆键值对 如果字典未空抛出keyError +result={'语文':77,'数学':66,'英语':33} +print(result.popitem()) #('英语', 33) 返回的是元祖 +print(result) + +# 3、dict.clear() 清空字典 +result={'语文':77,'数学':66,'英语':33} +result.clear() +print(result) #{} + +# 4、dict.keys() 获取字典中的全部key 可用于for循环来遍历字典 +person={ + 'name':'zhangsan', + 'sex':'男', + 'age':19, + 'class':'IT231' +} +print(person.keys()) + +for key in person.keys(): + print(key) + +# dict.values() 获取字典中的全部value +print(person.values()) + + + diff --git a/day18/06-字典的作业.py b/day18/06-字典的作业.py new file mode 100644 index 0000000..7936ae1 --- /dev/null +++ b/day18/06-字典的作业.py @@ -0,0 +1,100 @@ +# 字典中的作业 字典方法案例总结 + +# 1. 创建字典并访问元素 +students = {'Alice': 20, 'Bob': 22, 'Charlie': 23} +key = 'Bob' +if key in students: + print(f"'{key}' 的年龄是 {students[key]}") +else: + print(f"'{key}' 不在字典中") + + +# 2. 向字典添加新键值对 +students = {'Alice': 20, 'Bob': 22} +students['Charlie'] = 23 +print(f"更新后的字典是 {students}") + + +# 3. 删除字典中的键值对 +students = {'Alice': 20, 'Bob': 22, 'Charlie': 23} +del_key = 'Bob' +if del_key in students: + del students[del_key] + print(f"删除后的字典是 {students}") +else: + print(f"'{del_key}' 不在字典中") + + + +# 4. 查找字典中是否存在某个键 +students = {'Alice': 20, 'Bob': 22, 'Charlie': 23} +key = 'Charlie' +if key in students: + print(f"'{key}' 存在于字典中") +else: + print(f"'{key}' 不存在于字典中") + + +# 5. 获取字典的所有键和值 +students = {'Alice': 20, 'Bob': 22, 'Charlie': 23} +keys = list(students.keys()) +values = list(students.values()) +print(f"字典中的所有键是 {keys}") +print(f"字典中的所有值是 {values}") + + +# 6. 获取字典中所有键值对（项） +students = {'Alice': 20, 'Bob': 22, 'Charlie': 23} +items = list(students.items()) +print(f"字典中的所有项是 {items}") + + +# 7. 使用 get() 方法访问字典中的值 +students = {'Alice': 20, 'Bob': 22, 'Charlie': 23} +key = 'David' +value = students.get(key, None) # 默认值为 None +if value is None: + print(f"'{key}' 不存在于字典中，返回默认值 {value}") +else: + print(f"'{key}' 的值是 {value}") + + +# 8. 字典中值的最大值和最小值 +students = {'Alice': 20, 'Bob': 22, 'Charlie': 23} +max_value = max(students.values()) +min_value = min(students.values()) +print(f"字典中值的最大值是 {max_value}") +print(f"字典中值的最小值是 {min_value}") + + +# 9. 字典的键值对反转 +students = {'Alice': 20, 'Bob': 22, 'Charlie': 23} +reversed_dict = {v: k for k, v in students.items()} +print(f"反转后的字典是 {reversed_dict}") + + +# 10. 合并两个字典 +dict1 = {'Alice': 20, 'Bob': 22} +dict2 = {'Charlie': 23, 'David': 24} +merged_dict = {**dict1, **dict2} # Python 3.5+ 支持 +print(f"合并后的字典是 {merged_dict}") + + +# 11. 计算字典中所有值的总和 +students = {'Alice': 20, 'Bob': 22, 'Charlie': 23} +total = sum(students.values()) +print(f"字典中所有值的总和是 {total}") + + +# 12. 字典的条件筛选 +set1 = {1, 2, 3} +set2 = {1, 2, 3, 4, 5} +if set1.issubset(set2): + print("第一个集合是第二个集合的子集") +else: + print("第一个集合不是第二个集合的子集") + + + + + diff --git a/day18/06-字典的方法.py b/day18/06-字典的方法.py new file mode 100644 index 0000000..37ba68c --- /dev/null +++ b/day18/06-字典的方法.py @@ -0,0 +1,16 @@ +# dict.update(other)将另一个字典的键-值对合并到当前字典中(|) +person_1 = { + 'name':'zhangsan', + 'age':18 +} + +person_2 = { + '中文姓名':'张三', + '年龄':18 +} +# 第一种方式： +person_1.update(person_2) # 类似于集合的并集 +print(person_1) + +# 第二种方式： +print(person_1 | person_2) diff --git a/day19/01-梳理.py b/day19/01-梳理.py new file mode 100644 index 0000000..8f06b3c --- /dev/null +++ b/day19/01-梳理.py @@ -0,0 +1,49 @@ +# 第一章 Python的基础语法 +# 1、编译器和环境(临时的) +# vscode软件 + python插件 + +# 2、注释 代码的解释或者程序的说明 +# 编译器不会执行 +# 单行注释(#) 多行注释(""" """) + +# 3、字面量 常量 变量 +# 字面量 就是固定的值 比如100 'zhangsan' +# 常量 存储特定的值 但是这个值不能改变 同时约定常量的名称全部大写 比如COUNT=100 PI=3.14 +# 变量 存储特定的值 但是这个值可以改变 比如num=100 num=200(修改变量num的值) + +# 4、数据类型 +# 你定义的一些数据都有一个类型 而且必须知道这个类型才能操作这个数据 +# 数据类型一共有6种 +# 数字类型(整数int 浮点数float 复数comflex 布尔值bool) +# 字符串类型 str +# 列表类型 list +# 元祖类型 tuple +# 集合类型 set +# 字典类型 dict + +# 5、重要的内置函数 +# 内置函数 python语言的作者提前封装好的 具有特定的功能 函数后面有括号 括号里面放一些参数、 +# print() 输出函数 方便调试 +# input() 输入函数 +# type() 检测括号里面的值的类型 +# int() 将括号里面的值转为整数 +# float() 将括号里面的值转为浮点数 +# str() 将括号里面的值转为字符串 + +# 6、运算符 +# 数学运算符 + - * / % ** // +# 赋值运算符 =(将符号右边的值赋值给左边的变量) +# 复合赋值运算符 += -= *= /= %= **= //= 是一种符号的合并 优化简化代码的 +# 比较运算符 > < >= <= == != + + +# 第二章 分支语句 +# if的三种结构 +# if 单分支 只有一种情况 +# if else 双分支 有两种情况 +# if elif elif elif else 多分支 有多种情况 + +# 第三章 循环语句 +# 循环的意义 有规律 重复 +# while循环 初始值+限制条件+循环体+累加累减 +# for循环 for-in (遍历:获取一个容器里面的每一项值) \ No newline at end of file diff --git a/day19/02-梳理数据容器.py b/day19/02-梳理数据容器.py new file mode 100644 index 0000000..bc5e0fc --- /dev/null +++ b/day19/02-梳理数据容器.py @@ -0,0 +1,60 @@ +# 第四章 数据容器 +# 数据容器就是一种可以容纳多个数据的数据类型 容纳的每一个数据被称为元素 +# 每一个元素 可以是任意的数据类型 如字符串 数字 布尔值等 + +# 数据容器分为5类 +# 分别是列表 元祖 字符串 集合 字典 + +# 1、列表 +# 多个数据放在中括号里面([]) 每一个数据都可以是任意的数据类型 +# 特点 +# 可以重复 元素可以相同的值 list=['a','a','b','c'] +# 有序 每一个元素都有一个默认的从0开始的整数编号 比如上面的第一个a的编号是0 第二个a的编号是1 +# 是否修改 列表里面的每一个元素都可以修改 +# 定义 +# 遍历 +# 方法和函数 + + +# 2、元祖 +# 元祖同列表一样 可以封装不同类型的元素在里面 但最大的不同在于元祖一旦定义就不可以修改 +# 定义元祖使用小括号 使用逗号隔开 数据可以是任意的数据类型 +# 特点 +# 可以重复 元素可以相同的值 +# 有序 每一个元素都有一个默认的从0开始的整数编号 +# 是否可以修改 不可以修改 +# 定义 +# 遍历 +# 方法和函数 + +# 3、集合 +# 定义集合使用大括号({}) 使用逗号隔开 数据可以是不同的数据类型 +# 特点 +# 元素不可以重复 +# 无序 +# 是否可以修改 不可以修改 +# 定义 +# 遍历 +# 方法和函数 + +# 4、字典 +# 使用大括号({}) 不过存储的元素是一个一个的键值对(一组值) +# 特点 +# 当key重复 第二个会把第一个覆盖掉 +# key不能重复 覆盖关系 +# 无序的 没有索引下标 +# 可以修改对应的值 +# 字典的key和value值 可以是任意的数据类型 +# 通过key获取对应的值 +# 定义 +# 遍历 +# 方法和函数 + +# 5、字符串 +# 定义 使用引号包裹的数据都是字符串 +# 遍历 +# 方法和函数 + + + + diff --git a/day19/03-数据容器的算法题.py b/day19/03-数据容器的算法题.py new file mode 100644 index 0000000..ef3a4f9 --- /dev/null +++ b/day19/03-数据容器的算法题.py @@ -0,0 +1,76 @@ +# 1. 列表反转 +lst = [1, 2, 3, 4, 5] +reversed_lst = lst[::-1] +print(f"反转后的列表是 {reversed_lst}") + +# 2. 查找列表中的最大值和最小值 +lst = [3, 1, 7, 5, 2] +max_value = max(lst) +min_value = min(lst) +print(f"最大值是 {max_value}") +print(f"最小值是 {min_value}") + +# 3. 字典的键值交换 +d = {'a': 1, 'b': 2, 'c': 3} +reversed_dict = {v: k for k, v in d.items()} +print(f"反转后的字典是 {reversed_dict}") + +# 4. 集合的并集、交集、差集运算 +set1 = {1, 2, 3} +set2 = {3, 4, 5} + +union = set1 | set2 +intersection = set1 & set2 +difference = set1 - set2 + +print(f"并集是 {union}") +print(f"交集是 {intersection}") +print(f"差集是 {difference}") + +# 5. 元组拆包 +t = (1, 2, 3, 4) +a, b, c, d = t +print(f"拆包后的元素是 {a} {b} {c} {d}") + +# 6. 列表去重 +lst = [1, 2, 2, 3, 3, 4] +unique_lst = list(set(lst)) +print(f"去重后的列表是 {unique_lst}") + +# 7. 列表中查找出现次数最多的元素 +from collections import Counter + +lst = [1, 2, 3, 1, 1, 2, 4] +counter = Counter(lst) +most_common_element = counter.most_common(1)[0][0] +print(f"出现次数最多的元素是 {most_common_element}") + +# 8. 计算字典中所有值的总和 +d = {'Alice': 20, 'Bob': 25, 'Charlie': 30} +total = sum(d.values()) +print(f"字典中所有值的总和是 {total}") + +# 9. 字典合并 +dict1 = {'a': 1, 'b': 2} +dict2 = {'c': 3, 'd': 4} +merged_dict = {**dict1, **dict2} +print(f"合并后的字典是 {merged_dict}") + +# 10. 从列表中删除指定元素 +lst = [1, 2, 3, 1, 4, 1, 5] +remove_element = 1 +new_lst = [x for x in lst if x != remove_element] +print(f"删除后的列表是 {new_lst}") + +# 11. 列表中的嵌套字典 +lst = [{'name': 'Alice', 'age': 20}, {'name': 'Bob', 'age': 25}] +key = 'name' +values = [d[key] for d in lst if key in d] +print(f"所有的 '{key}' 值是 {values}") + +# 12. 找出列表中的最大和最小元素的差值 +lst = [10, 2, 8, 6, 4] +max_val = max(lst) +min_val = min(lst) +diff = max_val - min_val +print(f"最大值和最小值之间的差是 {diff}") diff --git a/day20/01-数据容器的区别.py b/day20/01-数据容器的区别.py new file mode 100644 index 0000000..c9f7a8b --- /dev/null +++ b/day20/01-数据容器的区别.py @@ -0,0 +1,21 @@ +# 1、数据容器的五大类 +# 列表list +# 元组tuple +# 集合set +# 字典dict +# 字符串str + +# 2、存在5个函数进行相应的转换 +# list() 将括号里面的值转为列表 +# tuple() 将括号里面的值转为元祖 +# set() 将括号里面的值转为集合 +# dict() 将括号里面的值转为字典 +# str() 将括号里面的值转为字符串 + +# 3、数据容器的区别 +# 列表 有序 可以重复 可以修改 +# 元祖 有序 可以重复 不可以修改 +# 集合 无序 不可以重复 不可以修改 +# 字典 无序 重复会覆盖 通过key来覆盖相应的值 + + diff --git a/day20/02-数据容器之字符串.py b/day20/02-数据容器之字符串.py new file mode 100644 index 0000000..d29ecb9 --- /dev/null +++ b/day20/02-数据容器之字符串.py @@ -0,0 +1,30 @@ +# 一、数据容器-字符串 +# 尽管字符串看起来不像列表元祖那样可以存储多个元素 +# 但是不可以否认 字符串同样是数据容器的一员 +# 字符串是字符的容器 一个字符串可以放任意数量的字符 +str='hello' +# 通过索引下标来获取对应的值 +print(str[0]) +print(str[1]) +print(str[2]) +print(str[3]) +print(str[4]) + +# 和其他的数据容器一样 字符串也可以通过下标来获取 但是字符串无法修改 +# str[0]="H" + +# 从前往后 下标从0开始 从后往前 下标从-1开始 +print(str[-5]) +print(str[-4]) +print(str[-3]) +print(str[-2]) +print(str[-1]) + + + + + + + + + diff --git a/day20/03-字符串遍历.py b/day20/03-字符串遍历.py new file mode 100644 index 0000000..dabbd17 --- /dev/null +++ b/day20/03-字符串遍历.py @@ -0,0 +1,23 @@ +# 字符串的遍历 +# 将容器里面的数据依次取出进行处理的行为 遍历 +# 推荐使用for循环 +# 一旦拥有索引下标 while循环也可以 + +# while循环遍历 +str='abcdefgh' +i=0 +while inew 替换count次数 count可以省略 +str='hello,zhangsan,lisi,wangwu,lisi,hello,zhangsan' +print(str.replace('hello','嗨')) +print(str.replace('hello','嗨',1)) +print(str.replace('hello',' ')) + +# 2、str.center(width,fillchar) 字符串居中函数 第二个参数为宽度不足填充符号可以省略 +str='hello' +print(str.center(10,'*')) +print(str.center(21,'#')) +# 三角形 +str='' +for i in range(1,10,2): + print(str.center(i,'*')) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/day20/08-字符串的方法.py b/day20/08-字符串的方法.py new file mode 100644 index 0000000..8671c13 --- /dev/null +++ b/day20/08-字符串的方法.py @@ -0,0 +1,23 @@ +# 1、str.strip(chars) 返回str副本 在其左右两侧去掉chars中列出的字符 +str='abcdcba' +print(str.strip()) #abcdcba +print(str.strip('a')) #bcdcb +print(str.strip('ab')) #cdc + +# 2、str.zfill(width) 返回str副本 长度为width 不足左侧添加0 +str='zhangsan' +print(str.zfill(20)) +print(str.zfill(5)) #长度不够 保留原字符串 + +# 3、拼接字符串.join(iterator) 拼接字符串数组 +# 将字符串 元祖 列表中是元素以指定的字符或者分隔符连接成一个新的字符串 +str='abcdefgh' +list=['a','b','c','d'] +print('#'.join(str)) + +# 4、str.format() 返回字符串的一种排列格式 +print('我的名字是{0},我今年{1}岁'.format('zhangsan',18)) + + + + diff --git a/day20/09-练习.py b/day20/09-练习.py new file mode 100644 index 0000000..a079067 --- /dev/null +++ b/day20/09-练习.py @@ -0,0 +1,58 @@ +# 1. 字符串大小写转换 +text = "Hello, World!" +# 将字符串转换为全大写 +upper_text = text.upper() +print(upper_text) +# 将字符串转换为全小写 +lower_text = text.lower() +print(lower_text) +# 将字符串首字母大写 +capitalized_text = text.capitalize() +print(capitalized_text) + +# 2. 字符串查找和替换 +text = "Hello, World! Hello, Python!" +# 查找子字符串的位置 +index = text.find("World") +print(index) +# 替换子字符串 +new_text = text.replace("Hello", "Hi") +print(new_text) + +# 3. 字符串分割和连接 +text = "apple,banana,orange" +# 分割字符串 +fruits = text.split(",") +print(fruits) +# 连接字符串 +joined_text = "-".join(fruits) +print(joined_text) + +# 4. 字符串去除空白字符 +text = " Hello, World! " +# 去除字符串左侧的空白字符 +left_stripped = text.lstrip() +print(left_stripped) +# 去除字符串右侧的空白字符 +right_stripped = text.rstrip() +print(right_stripped) +# 去除字符串两侧的空白字符 +stripped = text.strip() +print(stripped) + +# 5. 字符串判断 +text = "12345" +# 判断字符串是否由数字组成 +is_digit = text.isdigit() +print(is_digit) +text = "Hello" +# 判断字符串是否由字母组成 +is_alpha = text.isalpha() +print(is_alpha) + + + + + + + diff --git a/day21/01-切片.py b/day21/01-切片.py new file mode 100644 index 0000000..bab8558 --- /dev/null +++ b/day21/01-切片.py @@ -0,0 +1,55 @@ +# 一、切片的概念 +# 从一个序列中截取出一个子序列 +# 序列 序列是指内容连续有序 可以使用下标索引的一类数据容器 列表 元祖 字符串 均可以被视为序列 + +list=[0,1,2,3,4,5,6,7,8,9] +t1=(0,1,2,3,4,5,6,7,8,9) +str='0123456789' + +# 二、切片的语法 +# 语法 序列[起始下标:结束下标:步长] +# 起始下标 截取序列的起始位置 留空表示从头开始 +# 结束下标 截取序列的结束位置 不包括这个位置 留空表示截取到结尾 +# 步长 依次截取数据的间隔 +# -步长1 一个个取元素 默认值为1 +# -步长2 每次跳过1个元素取值 +# -步长n 每次跳过n个元素取值 +# -步长为负数表示 反向取值 起始下标和结束下标要反向标记 + +# 三、列表的切片 +list=[0,1,2,3,4,5,6,7,8,9] #列表(序列) 元素值和索引值一样的 +# 正向切片 +print(list[2:6:1]) #[2, 3, 4, 5] +print(list[2:6]) #[2, 3, 4, 5] +print(list[3:]) #[3, 4, 5, 6, 7, 8, 9] +print(list[:6]) #[0, 1, 2, 3, 4, 5] +print(list[::2]) #[0, 2, 4, 6, 8] + +#反向切片 步长为负数 +list=[0,1,2,3,4,5,6,7,8,9] #列表(序列) 元素值和索引值一样的 +print(list[::1]) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] +print(list[::-1]) #[9, 8, 7, 6, 5, 4, 3, 2, 1, 0] +print(list[-2:-5:-1]) #[8, 7, 6] +print(list[-5:-9:-1]) #[5, 4, 3, 2] + +# 四、字符串切片 +str='0123456789' #字符串(序列) 元素值和索引值一样的 +print(str[::-1]) #9876543210 +print(str[2:5]) #234 + +# 五、元祖的切片 +t1=(0,1,2,3,4,5,6,7,8,9) #元祖(序列) 元素值和索引值一样的 +print(t1[::-1]) #(9, 8, 7, 6, 5, 4, 3, 2, 1, 0) +print(t1[::]) #(0, 1, 2, 3, 4, 5, 6, 7, 8, 9) +print(t1[::-2]) #(9, 7, 5, 3, 1) +print(t1[-3:-7:-2]) #(7, 5) + + + + + + + + + + diff --git a/day21/02-切片的练习.py b/day21/02-切片的练习.py new file mode 100644 index 0000000..955ebd6 --- /dev/null +++ b/day21/02-切片的练习.py @@ -0,0 +1,82 @@ +# 1、反转列表 +# 编写代码将列表 [1, 2, 3, 4, 5] 反转。 +lst = [1, 2, 3, 4, 5] +reversed_lst = lst[::-1] +print(reversed_lst) # 输出: [5, 4, 3, 2, 1] + +# 2、获取子列表 +# 从列表 [10, 20, 30, 40, 50, 60] 中获取索引 2 到 4（包含 4）的元素。 +lst = [10, 20, 30, 40, 50, 60] +sub_lst = lst[2:5] # 注意：结束索引 5 对应的元素不包含在切片内 +print(sub_lst) # 输出: [30, 40, 50, 60] + +# 3、隔一个取一个 +# 从字符串 "abcdefghij" 中每隔一个字符取一个，得到 "acegij"。 +s = "abcdefghij" +result = s[::2] +print(result) # 输出: "acegik" + +# 4、删除前三个元素 +# 对列表 [1, 2, 3, 4, 5, 6, 7, 8, 9] 删除前三个元素。 +lst = [1, 2, 3, 4, 5, 6, 7, 8, 9] +lst = lst[3:] # 直接赋值新列表 +print(lst) # 输出: [4, 5, 6, 7, 8, 9] +# 或者使用原地修改 +lst = [1, 2, 3, 4, 5, 6, 7, 8, 9] +lst[:3] = [] +print(lst) # 输出: [4, 5, 6, 7, 8, 9] + +# 5、替换中间元素 +# 将列表 [1, 2, 3, 4, 5] 的中间元素（索引 2）替换为 10。 +lst = [1, 2, 3, 4, 5] +mid_idx = len(lst) // 2 +lst[mid_idx:mid_idx+1] = [10] # 用 [10] 替换中间元素 +print(lst) # 输出: [1, 2, 10, 4, 5] + +# 6、检查回文 +# 编写函数 is_palindrome(s)，使用切片判断字符串是否为回文（如 "radar" 是回文）。 +def is_palindrome(s): + return s == s[::-1] +print(is_palindrome("radar")) # 输出: True +print(is_palindrome("hello")) # 输出: False + +# 7、合并切片 +# 合并两个列表的切片：将列表 a = [1, 2, 3] 的前两个元素和列表 b = [4, 5, 6] 的后两个元素合并为 [1, 2, 5, 6]。 +a = [1, 2, 3] +b = [4, 5, 6] +merged = a[:2] + b[-2:] +print(merged) # 输出: [1, 2, 5, 6] + +# 8、矩阵转置 +# 对二维列表 matrix = [[1, 2], [3, 4], [5, 6]] 使用切片转置为 [[1, 3, 5], [2, 4, 6]]。 +matrix = [[1, 2], [3, 4], [5, 6]] +transposed = [list(row) for row in zip(*matrix)] +print(transposed) # 输出: [[1, 3, 5], [2, 4, 6]] + +# 9、字符串重组 +# 给定字符串 "HelloWorld"，通过切片重组为 "WorldHello"。 +s = "HelloWorld" +idx = s.index("World") +result = s[idx:] + s[:idx] +print(result) # 输出: "WorldHello" + +# 10、列表复制 +# 使用切片创建列表 original = [1, 2, [3, 4]] 的深拷贝（修改拷贝不影响原列表）。 +import copy +original = [1, 2, [3, 4]] +shallow_copy = original[:] # 浅拷贝，嵌套列表仍共享引用 +deep_copy = copy.deepcopy(original) # 深拷贝 +# 修改浅拷贝的嵌套列表会影响原列表 +shallow_copy[2][0] = 99 +print(original) # 输出: [1, 2, [99, 4]] +# 修改深拷贝的嵌套列表不会影响原列表 +deep_copy[2][0] = 100 +print(original) # 输出: [1, 2, [99, 4]] + + + + + + + + diff --git a/day21/03-字符串的练习.py b/day21/03-字符串的练习.py new file mode 100644 index 0000000..782ce3b --- /dev/null +++ b/day21/03-字符串的练习.py @@ -0,0 +1,53 @@ +# 1. 反转字符串 +s = "hello" +reversed_s = s[::-1] +print(reversed_s) # 输出: "olleh" + +# 2. 判断是否是回文 +s = "racecar" +is_palindrome = s == s[::-1] +print(is_palindrome) # 输出: True + +# 3. 统计某个字符的出现次数 +s = "hello" +char_count = s.count("l") +print(char_count) # 输出: 2 + +# 4. 删除字符串中的元音 +s = "beautiful" +vowels = "aeiouAEIOU" +new_s = ''.join(c for c in s if c not in vowels) +print(new_s) # 输出: "btfl" + +# 5. 计算字符串中的单词数量 +s = "I love Python" +word_count = len(s.split()) +print(word_count) # 输出: 3 + +# 6. 检查字符串是否只包含字母 +s = "Python123" +only_alpha = s.isalpha() +print(only_alpha) # 输出: False + +# 7. 字符串大小写转换 +s = "Hello World" +swapped_s = s.swapcase() +print(swapped_s) # 输出: "hELLO wORLD" + +# 8. 删除字符串中的重复字符（保留首次出现的顺序） +s = "banana" +seen = set() +new_s = ''.join(seen.add(c) or c for c in s if c not in seen) +print(new_s) # 输出: "ban" + +# 9. 获取字符串中第一个不重复的字符 +s = "swiss" +for c in s: + if s.count(c) == 1: + print(c) # 输出: "w" + break + +# 10. 反转字符串中的单词 +s = "I love Python" +reversed_words = ' '.join(s.split()[::-1]) +print(reversed_words) # 输出: "Python love I" \ No newline at end of file diff --git a/day22/01-列表推导式.py b/day22/01-列表推导式.py new file mode 100644 index 0000000..28d32bc --- /dev/null +++ b/day22/01-列表推导式.py @@ -0,0 +1,43 @@ +# 一、推导式 +# 推导式就是 for 循环的一种使用方法 将一个可迭代对象中的数据遍历到某一个容器中 +# 简单来说就是一种for循环语句 遍历可迭代对象中的所有数据 然后将遍历出来的数据进行处理放入对应的容器中 + +# 案例对比 +# 将一个列表中的每一个元素扩大100倍 放到新的列表中 +# 1、正常的遍历操作 +list=[1,2,3,4,5,6,7,8,9] +newlist=[] +for item in list: + newlist.append(item*100) +print(newlist) #[100, 200, 300, 400, 500, 600, 700, 800, 900] + +# 2、推导式 +list=[1,2,3,4,5,6,7,8,9] +print([item * 100 for item in list]) #[100, 200, 300, 400, 500, 600, 700, 800, 900] + +# 二、推导式的基本语法 +# val for val in iterable val:容器 iterable:容器(列表 元祖 集合 字符串) + +# 三、列表推导式 +# 1、普通的列表推导式 +# [val for val in iterable] 第一个val是数据容器 就可以直接进行操作 继续生成一个列表 +# 案例 +list=[1,2,3,4,5,6,7,8,9] +print([item * 100 for item in list]) #[100, 200, 300, 400, 500, 600, 700, 800, 900] + +# 2、带条件的列表推导式 +# 推导式使用单分支 只能在for语句结束之后使用 +# 案例 +# 获取列表中的偶数 +list=list=[1,2,3,4,5,6,7,8,9] +newlist=[val for val in list if val %2 ==0] #单分支 条件要写在for语句的后面 +print(newlist) #[2, 4, 6, 8] + + + + + + + + + diff --git a/day22/02-列表推导式.py b/day22/02-列表推导式.py new file mode 100644 index 0000000..9921550 --- /dev/null +++ b/day22/02-列表推导式.py @@ -0,0 +1,18 @@ +# 2、带条件的列表推导式 +# 推导式使用单分支 只能在for语句结束之后使用 +# 案例 +# 获取列表中的偶数 +list=list=[1,2,3,4,5,6,7,8,9] +newlist=[val for val in list if val %2 ==0] #单分支 条件要写在for语句的后面 +print(newlist) #[2, 4, 6, 8] + +# 推导式使用双分支 只能写在for循环的前面 +# 结构 +# val1 if condtion else val2 for val in list +list=[1,2,3,4,5,6,7,8,9] +newlist=[True if val > 5 else False for val in list] +print(newlist) #[False, False, False, False, False, True, True, True, True] + + + + diff --git a/day22/03-其他推导式.py b/day22/03-其他推导式.py new file mode 100644 index 0000000..f5b1486 --- /dev/null +++ b/day22/03-其他推导式.py @@ -0,0 +1,71 @@ +# 1、集合推导式 +# 集合推导式和列表推导式用法基本一样 但是外面使用大括号包括 得到的数据是一个集合 +set={1,2,3,4,5,6,7,8,9} +newset={val * 100 for val in set} +print(newset) + +# 2、字典推导式 +# 字典推导式和列表推导式用法基本一样 但是字典的数据是以键值对的形式存在 所以返回的数据或者要返回的数据变成两个 以对应键值对 +dict={ + 'zhangsan':70, + 'lisi':69, + 'wangwu':60 +} +# 推荐使用items方法 将字典转换成对应的列表(列表里面包含元祖的形式) +print(dict.items()) +newdict={key:value + 10 for key,value in dict.items()} +print(newdict) #{'zhangsan': 80, 'lisi': 79, 'wangwu': 70} + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/day22/04-和字典配合的函数.py b/day22/04-和字典配合的函数.py new file mode 100644 index 0000000..61f1773 --- /dev/null +++ b/day22/04-和字典配合的函数.py @@ -0,0 +1,20 @@ +# 1、enumerate +# 枚举，根据索引号 和 容器 中的值，一个一个拿出来配对组成元组，放入迭代器中，然后返回迭代器。 +# 参数 +# iterable：可迭代数据 +# start：可以选择开始的索引号（默认从0开始索引） +list=['apple','banana','cherry'] +newlist=[val for val in enumerate(list)] +print(newlist) #[(0, 'apple'), (1, 'banana'), (2, 'cherry')] + + +# 2、zip +# 将多个中的值，一个个拿出来配对组成元组放入迭代器中，如果某个元素多出，没有匹配项就会被舍弃。 +# 参数 +# iterable：可迭代数据 +list1=[1,2,3,4,5] +list2=['a','b','c','d'] +list3=['A','B','C'] +print([val for val in zip(list1,list2,list3)]) + + diff --git a/day22/05-列表推导式练习.py b/day22/05-列表推导式练习.py new file mode 100644 index 0000000..e274241 --- /dev/null +++ b/day22/05-列表推导式练习.py @@ -0,0 +1,52 @@ +# 1、将字典中的数据变成['x=A', 'y=B', 'z=c']的样式 +dict = {'x': 'A', 'y': 'B', 'z': 'C' } +# print(dict.items()) # 将字典转换成列表格式 [('x', 'A'), ('y', 'B'), ('z', 'C')] +list = [f'{key} = {val}' for key,val in dict.items()] # 元组解构两个之key,val +print(list) # 'x = A', 'y = B', 'z = C'] + +# 2、将所用元素变成纯小写 +list = ["ADDD","dddDD","DDaa","sss"] +print([item.lower() for item in list]) # item列表的每一项 ['addd', 'ddddd', 'ddaa', 'sss'] +print([item.upper() for item in list]) # item列表的每一项 ['ADDD', 'DDDDD', 'DDAA', 'SSS'] + +# 3、x是0-5之间的偶数,y是0-5之间的奇数 把x,y组成一起变成元组,放到列表当中 +# print([(x,y) for x in range(0,6) if x%2==0 for y in range(0,6) if y%2!=0]) +# [(0, 1), (0, 3), (0, 5), (2, 1), (2, 3), (2, 5), (4, 1), (4, 3), (4, 5)] + +# list = [(0,1),(2,3),(4,5)] +# print([(x,y) for x,y in list]) + + +# 4、使用列表推导式 制作所有99乘法表中的运算 +# list = [f'{i}x{j}={i*j}' for i in range(0,10) for j in range(0,10)] +# print(list) + +# 5、求M,N中矩阵和元素的乘积 +M = [[1,2,3], [4,5,6], [7,8,9]] +N = [[2,2,2], [3,3,3], [4,4,4]] + +# =>实现效果1 [2, 4, 6, 12, 15, 18, 28, 32, 36] +# =>实现效果2 [[2, 4, 6], [12, 15, 18], [28, 32, 36]] + +list = [M[i][j]*N[i][j] for i in range(0,3) for j in range(0,3)] +print(list) # [2, 4, 6, 12, 15, 18, 28, 32, 36] + +list1 = [[M[i][j]*N[i][j] for i in range(0,3)] for j in range(0,3)] +print(list1) # [[2, 12, 28], [4, 15, 32], [6, 18, 36]] + +# print(M[0][0]) +# print(N[0][0]) +# print(M[0][1]) +# print(N[0][1]) +# print(M[0][2]) +# print(N[0][2]) + + + + + + + + + + diff --git a/day22/06-练习.py b/day22/06-练习.py new file mode 100644 index 0000000..cbb2b6a --- /dev/null +++ b/day22/06-练习.py @@ -0,0 +1,48 @@ +# 题目 1：列表推导式（字符串操作） +# 要求：将字符串 "Hello World" 中的每个字符转换为 ASCII 码值，并生成列表。 +# 示例输出：[72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100] +ascii_values = [ord(c) for c in "Hello World"] + +# 题目 2：字典推导式（反转键值对） +# 要求：将字典 {'a': 1, 'b': 2, 'c': 3} 的键值对反转，生成新字典。 +# 示例输出：{1: 'a', 2: 'b', 3: 'c'} +original_dict = {'a': 1, 'b': 2, 'c': 3} +reversed_dict = {v: k for k, v in original_dict.items()} + +# 题目 3：集合推导式（筛选唯一元素） +# 要求：从列表 ['apple', 'banana', 'apple', 'cherry', 'banana'] 中提取所有唯一的水果名称（忽略大小写），并生成集合。 +# 示例输出：{'apple', 'banana', 'cherry'} +fruits = ['apple', 'banana', 'apple', 'cherry', 'banana'] +unique_fruits = {f.lower() for f in fruits} + +# 题目 4：嵌套推导式（矩阵转置） +# 要求：使用列表推导式将矩阵 [[1, 2, 3], [4, 5, 6]] 转置。 +matrix = [[1, 2, 3], [4, 5, 6]] +transposed = [[row[i] for row in matrix] for i in range(len(matrix[0]))] + +# 题目 5：条件推导式（筛选和转换） +# 要求：从列表 [1, -2, 3, -4, 5, -6] 中筛选出正数，并将每个正数平方后生成新列表。 +# 示例输出：[1, 9, 25] +numbers = [1, -2, 3, -4, 5, -6] +squared_positives = [x**2 for x in numbers if x > 0] + +# 题目 6：字典推导式（统计字符频率） +# 要求：统计字符串 "hello" 中每个字符的出现次数，生成字符到频率的映射。 +# 示例输出：{'h': 1, 'e': 1, 'l': 2, 'o': 1} +s = "hello" +char_freq = {c: s.count(c) for c in s} + + + + + + + + + + + + + + + diff --git a/day23/00-列表推导式的案例.py b/day23/00-列表推导式的案例.py new file mode 100644 index 0000000..1d1bc35 --- /dev/null +++ b/day23/00-列表推导式的案例.py @@ -0,0 +1,53 @@ +# 1、将字典中的数据变成['x=A', 'y=B', 'z=c']的样式 +dict = {'x': 'A', 'y': 'B', 'z': 'C' } +# print(dict.items()) # 将字典转换成列表格式 [('x', 'A'), ('y', 'B'), ('z', 'C')] +list = [f'{key} = {val}' for key,val in dict.items()] # 元组解构两个之key,val +print(list) # 'x = A', 'y = B', 'z = C'] + +# 2、将所用元素变成纯小写 +list = ["ADDD","dddDD","DDaa","sss"] +print([item.lower() for item in list]) # item列表的每一项 ['addd', 'ddddd', 'ddaa', 'sss'] +print([item.upper() for item in list]) # item列表的每一项 ['ADDD', 'DDDDD', 'DDAA', 'SSS'] + +# 3、x是0-5之间的偶数,y是0-5之间的奇数 把x,y组成一起变成元组,放到列表当中 +# print([(x,y) for x in range(0,6) if x%2==0 for y in range(0,6) if y%2!=0]) +# [(0, 1), (0, 3), (0, 5), (2, 1), (2, 3), (2, 5), (4, 1), (4, 3), (4, 5)] + +# list = [(0,1),(2,3),(4,5)] +# print([(x,y) for x,y in list]) + + +# 4、使用列表推导式 制作所有99乘法表中的运算 +# list = [f'{i}x{j}={i*j}' for i in range(0,10) for j in range(0,10)] +# print(list) + +# 5、求M,N中矩阵和元素的乘积 +M = [[1,2,3], [4,5,6], [7,8,9]] +N = [[2,2,2], [3,3,3], [4,4,4]] + +# =>实现效果1 [2, 4, 6, 12, 15, 18, 28, 32, 36] +# =>实现效果2 [[2, 4, 6], [12, 15, 18], [28, 32, 36]] + +list = [M[i][j]*N[i][j] for i in range(0,3) for j in range(0,3)] +print(list) # [2, 4, 6, 12, 15, 18, 28, 32, 36] + +list1 = [[M[i][j]*N[i][j] for i in range(0,3)] for j in range(0,3)] +print(list1) # [[2, 12, 28], [4, 15, 32], [6, 18, 36]] + +# print(M[0][0]) +# print(N[0][0]) +# print(M[0][1]) +# print(N[0][1]) +# print(M[0][2]) +# print(N[0][2]) + + + + + + + + + + + diff --git a/day23/01-集合推导式的案例.py b/day23/01-集合推导式的案例.py new file mode 100644 index 0000000..b6a5335 --- /dev/null +++ b/day23/01-集合推导式的案例.py @@ -0,0 +1,32 @@ +''' +案例： + 满足年龄在18到21,存款大于等于5000,小于等于5500的人 + 开卡格式为:尊贵VIP卡老X(姓氏), + 否则开卡格式为:抠脚大汉老X(姓氏) + 把开卡的种类统计出来 +''' +list = [ + {"name": "刘鑫炜", "age": 18, "money": 10000}, + {"name": "刘聪", "age": 19, "money": 5100}, + {"name": "刘子豪", "age": 20, "money": 4800}, + {"name": "孔祥群", "age": 21, "money": 2000}, + {"name": "宋云杰", "age": 18, "money": 20} +] + +# s1 = set() # 创建一个空的集合 +# for item in list: +# if 18<=item['age']<=21 and 5000<=item['money']<=5500: +# s1.add('尊贵VIP卡老'+item['name'][0]) +# else: +# s1.add('抠脚大汉老'+item['name'][0]) +# print(s1) # {'抠脚大汉老孔', '尊贵VIP卡老刘', '抠脚大汉老宋', '抠脚大汉老刘'} + +# 推导式实现 +print({'尊贵VIP卡老'+item['name'][0] if 18<=item['age']<=21 and 5000<=item['money']<=5500 else '抠脚大汉老'+item['name'][0] for item in list}) + + + + + + + diff --git a/day23/02-字典推导式的案例.py b/day23/02-字典推导式的案例.py new file mode 100644 index 0000000..2993a2c --- /dev/null +++ b/day23/02-字典推导式的案例.py @@ -0,0 +1,129 @@ +# 案例一 +# dictionary = {'a': '1234', 'B': 'FFFF', 'c': ' 23432', 'D': '124fgr', 'e': 'eeeee', 'F': 'QQQQQ'} +# 1：获取字典中key值是小写字母的键值对 +# print(dictionary.items()) +#[('a', '1234'), ('B', 'FFFF'), ('c', ' 23432'), ('D', '124fgr'), ('e', 'eeeee'), ('F', 'QQQQQ')] + +# newdict = {key:value for key,value in dictionary.items() if key.islower()} # key:字典中的每一个键 value:每一个值 +# print(newdict) # {'a': '1234', 'c': ' 23432', 'e': 'eeeee'} + +# 2：将字典中的所有key设置为小写 +# newdict = {key.lower():value for key,value in dictionary.items()} +# print(newdict) +# {'a': '1234', 'b': 'FFFF', 'c': ' 23432', 'd': '124fgr', 'e': 'eeeee', 'f': 'QQQQQ'} + +# 3：将字典中所有key是小写字母的value统一赋值为'error' +# 思路： +# 正常输出的是key为大写字母的 +# not:取反 +# not key.islower()：不是小写字母 +# newdict = {key:value if not key.islower() else 'error' for key,value in dictionary.items()} +# print(newdict) +# {'a': 'error', 'B': 'FFFF', 'c': 'error', 'D': '124fgr', 'e': 'error', 'F': 'QQQQQ'} + + +# 案例二 +# 将下面的字符串转换成字典 +# 思路： +# cookie字符串有规律的，每一组值后面都有= 然后通过; 连接起来 +# cookies = "anonymid=jy0ui55o-u6f6zd; depovince=GW; _r01_=1; JSESSIONID=abcMktGLRGjLtdhBk7OVw; ick_login=a9b557b8-8138-4e9d-8601-de7b2a633f80" + +# print(cookies.split('; ')) # 利用规律将字符串拆分成列表 +# ['anonymid=jy0ui55o-u6f6zd', 'depovince=GW', '_r01_=1', 'JSESSIONID=abcMktGLRGjLtdhBk7OVw', 'ick_login=a9b557b8-8138-4e9d-8601-de7b2a633f80'] + +# 将上面的拆分的列表继续变成元组，然后解构成字典的键值对 + +# str = 'anonymid=jy0ui55o-u6f6zd' +# print(str.split('=')) # ['anonymid', 'jy0ui55o-u6f6zd'] +# print((str.split('='),)) # (['anonymid', 'jy0ui55o-u6f6zd'],) 注意逗号，如果元组只有一项值，必须添加逗号 + + +# dict = {key:value for item in cookies.split('; ') for key,value in (item.split('='),)} +# print(dict) + +""" +{ + 'anonymid': 'jy0ui55o-u6f6zd', + 'depovince': 'GW', + '_r01_': '1', + 'JSESSIONID': 'abcMktGLRGjLtdhBk7OVw', + 'ick_login': 'a9b557b8-8138-4e9d-8601-de7b2a633f80' +} +""" +# 案例二(换一种写法) +# cookies = "anonymid=jy0ui55o-u6f6zd; depovince=GW; _r01_=1; JSESSIONID=abcMktGLRGjLtdhBk7OVw; ick_login=a9b557b8-8138-4e9d-8601-de7b2a633f80" +# dict = {} +# list = cookies.split('; ') +# for item in list: +# dict[item.split('=')[0]] = item.split('=')[1] +# print(dict) + +# 推导式实现 +# print({item.split('=')[0]:item.split('=')[1] for item in cookies.split('; ')}) + +# 案例三 +# 将字符串转换成字典 +# str = "k:1|k1:2|k2:3|k3:4" +# 将字符串转换成字典需要两步 +# 第一步：将字符串拆分成列表['k:1','k1:2','k2:3','k3:4'] +# 第二步：将列表的每一项继续通过冒号拆分成两项，第一项就是键，第二项就是值 +# print({item.split(':')[0] : item.split(':')[1] for item in str.split('|')}) +# {'k': '1', 'k1': '2', 'k2': '3', 'k3': '4'} + +# print({key:value for item in str.split('|') for key,value in (item.split(':'),)}) +# 注意后面的for循环转换成元组 +# {'k': '1', 'k1': '2', 'k2': '3', 'k3': '4'} + + +# 案例四 +# 生成一个包含5个随机数的字典 +# import random # 导入内置的模块 +# print(random.randint(1,100)) # 生成随机数 + +# print({i : random.randint(1,100) for i in range(1,6)}) +# {1: 66, 2: 16, 3: 56, 4: 16, 5: 79} + +# 案例五 +# 将两个长度相同的列表合并成字典 +# name = ['zhangsan', 'lisi', 'wangwu', 'maliu'] +# sign = ['双鱼座', '天蝎座', '水瓶座', '巨蟹座'] +# 思路：利用元组解构字典的键值对，需要将上面的两个列表变成元组 +# print(tuple(zip(name,sign))) +# (('zhangsan', '双鱼座'), ('lisi', '天蝎座'), ('wangwu', '水瓶座'), ('maliu', '巨蟹座')) +# print(list(zip(name,sign))) +# [('zhangsan', '双鱼座'), ('lisi', '天蝎座'), ('wangwu', '水瓶座'), ('maliu', '巨蟹座')] +# print({name:value for name,value in tuple(zip(name,sign)) }) +# {'zhangsan': '双鱼座', 'lisi': '天蝎座', 'wangwu': '水瓶座', 'maliu': '巨蟹座'} +# print({name:value for name,value in list(zip(name,sign)) }) +# {'zhangsan': '双鱼座', 'lisi': '天蝎座', 'wangwu': '水瓶座', 'maliu': '巨蟹座'} + +# 案例六 +# 将key中大小写相同的字母的value值求和 +# dict = {'a': 2, 'B': 5, 'A': 7, 'C': 10,'b':10} +# lower() upper() +# in +# print({key.lower():dict.get(key.lower(),0) + dict.get(key.upper(),0) for key in dict.keys() if key.lower() in ['a','b','c']}) +# {'a': 9, 'b': 5, 'c': 10} + +# # 案例七 +# 将字典中key、value互换位置 +# 将字典转换成能够被解构的元组 +d = {1: 'a', 2: 'b', 3: 'c'} +print({value:key for key,value in d.items()}) + + + + + + + + + + + + + + + + + diff --git a/day23/03-推导式的练习.py b/day23/03-推导式的练习.py new file mode 100644 index 0000000..647a621 --- /dev/null +++ b/day23/03-推导式的练习.py @@ -0,0 +1,47 @@ +# 题目 1：列表推导式（字符串操作） +# 要求：将字符串 "Hello World" 中的每个字符转换为 ASCII 码值，并生成列表。 +# 示例输出：[72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100] +ascii_values = [ord(c) for c in "Hello World"] + +# 题目 2：字典推导式（反转键值对） +# 要求：将字典 {'a': 1, 'b': 2, 'c': 3} 的键值对反转，生成新字典。 +# 示例输出：{1: 'a', 2: 'b', 3: 'c'} +original_dict = {'a': 1, 'b': 2, 'c': 3} +reversed_dict = {v: k for k, v in original_dict.items()} + +# 题目 3：集合推导式（筛选唯一元素） +# 要求：从列表 ['apple', 'banana', 'apple', 'cherry', 'banana'] 中提取所有唯一的水果名称（忽略大小写），并生成集合。 +# 示例输出：{'apple', 'banana', 'cherry'} +fruits = ['apple', 'banana', 'apple', 'cherry', 'banana'] +unique_fruits = {f.lower() for f in fruits} + +# 题目 4：嵌套推导式（矩阵转置） +# 要求：使用列表推导式将矩阵 [[1, 2, 3], [4, 5, 6]] 转置。 +matrix = [[1, 2, 3], [4, 5, 6]] +transposed = [[row[i] for row in matrix] for i in range(len(matrix[0]))] + +# 题目 5：条件推导式（筛选和转换） +# 要求：从列表 [1, -2, 3, -4, 5, -6] 中筛选出正数，并将每个正数平方后生成新列表。 +# 示例输出：[1, 9, 25] +numbers = [1, -2, 3, -4, 5, -6] +squared_positives = [x**2 for x in numbers if x > 0] + +# 题目 6：字典推导式（统计字符频率） +# 要求：统计字符串 "hello" 中每个字符的出现次数，生成字符到频率的映射。 +# 示例输出：{'h': 1, 'e': 1, 'l': 2, 'o': 1} +s = "hello" +char_freq = {c: s.count(c) for c in s} + + + + + + + + + + + + + + diff --git a/day24/01-函数的概述.py b/day24/01-函数的概述.py new file mode 100644 index 0000000..0bc9587 --- /dev/null +++ b/day24/01-函数的概述.py @@ -0,0 +1,51 @@ +# 一、函数的概述 +# 函数是组织好的 可以重复使用的 用来实现特定功能的代码段 +# 关键词 封装 重复使用 特定功能 + +# 内置函数 也可以自定义函数 +# python默认提供的 具有特定功能的 可以重复使用的 +# 例如 len()/str()/type()... + +list=[1,2,3,4,5,6] +print(len(list)) + +# 二、函数的特点 +# 函数是指将一组语句的集合 通过一个名字封装起来 要想执行这个函数 只需要调用函数名称即可 +# 它接收一些输入的值(参数) 并且可以输出一些结果(返回值) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/day24/02-函数的声明和调用.py b/day24/02-函数的声明和调用.py new file mode 100644 index 0000000..8113490 --- /dev/null +++ b/day24/02-函数的声明和调用.py @@ -0,0 +1,29 @@ +# 一、函数的声明/定义 +# 声明函数的语法格式 +""" +def 函数名称(): + 函数体 + +函数名称:可以自定义 最好是语义化 +函数体:使用函数就会执行代码块 +函数名称后面的括号:参数列表 扩展函数 使的函数更加的灵活 +""" + +# 二、函数的调用/使用 +# 函数名称() +# 调用上面的函数 函数体的代码就会被执行 + +# 三、案例 编写函数 统计字符串的长度 +def str_len(): + str='aaaaa' + count=0 + for i in str: + count +=1 + print(count) + +str_len() +str_len() +str_len() + + + diff --git a/day24/03-函数的参数.py b/day24/03-函数的参数.py new file mode 100644 index 0000000..584b1e4 --- /dev/null +++ b/day24/03-函数的参数.py @@ -0,0 +1,32 @@ +# 一、函数的参数 +# 函数的参数可有可无 但是一个带有参数的函数一定更加的灵活 +# 无参数的函数基本没有意义 +# 参数分为形参和实参 + +# 1、形参 +# 形参是形式上的参数 是虚拟变量 +# 在定义函数和函数体的时候使用 目的是为了函数在调用的时候接收实参 + +# def test(a): 这里的a代表的是形参 目的是为了函数在调用的时候接收实参 +# print('这里是一些代码') + +# 2、实参 +# 实参是实际上的参数 调用函数的时候传给函数的参数 +# 实参可以是常量 变量 表达式 函数 实参会传值给形参 + +# 二、案例 可以声明一个函数 打任意字符串的长度 +def str_len(str): + count=0 + for i in str: + count +=1 + print(count) + +str_len('hello') +str_len('aaaaaa') + + + + + + + diff --git a/day24/04-函数的返回值.py b/day24/04-函数的返回值.py new file mode 100644 index 0000000..ee10208 --- /dev/null +++ b/day24/04-函数的返回值.py @@ -0,0 +1,33 @@ +# 一、函数的返回值 +# 函数是组织代码的一种方式 可以将代码封装起来 并在需要的时候调用它 +# 1、return也是可选的 如果函数没有返回值 它会默认返回none +# 利用return实现 return后面的代码的结果是函数的返回值 + +# 例如 求两个数字的和 +def sum(a,b): + print(a+b) #打印a+b的值 + +def sum(a,b): + return a+b #将a+b的和给整个函数作为返回值 + +n=sum(5,6) +print(n) + +n=sum(10,11) +print(n) + +# 2、return后面的代码不再执行 函数结束了 +def say_hello(): + print('hello') + return + print('嗨') + +say_hello() + + + + + + + + diff --git a/day24/05-函数的案例.py b/day24/05-函数的案例.py new file mode 100644 index 0000000..715f13e --- /dev/null +++ b/day24/05-函数的案例.py @@ -0,0 +1,63 @@ +# 练习： +# 1.利用函数实现传入一个年份，判断是否是闰年 +def is_run(year): # year:形参，占位 + if year % 4 == 0 and year % 100 !=0 or year % 400 == 0: + return '闰年' + else: + return '非闰年' + +# 调用三次函数 +# print(is_run(2000)) +# print(is_run(2001)) +# print(is_run(2002)) + +# 2.利用函数实现两个数字的加减乘除 +# 分析：参数 +# def calc(n1,n2,op): # n1,n2都是数字，op是操作符 +# if op == '+': +# return n1 + n2 +# elif op == '-': +# return n1 - n2 +# elif op == '*': +# return n1 * n2 +# elif op == '/': +# return n1 / n2 +# else: +# return '输入有误!' +# print(calc(1,2,'+')) +# print(calc(1,2,'-')) +# print(calc(1,2,'*')) +# print(calc(1,2,'/')) + +# 3.函数实现：请输入一个km数值，计算打车费用，已知出租车起步价10块钱3km以内，超出的部分2元/km +# def car_money(km): +# if km > 3: +# return 10 + (km-3)*2 +# else: +# return 10 + +# print(car_money(5)) +# print(car_money(2)) +# print(car_money(10)) + +# 4.函数实现：根据公式(身高-108)*2 = 体重，可以有10斤左右的浮动，来观察测试者体重是否标准(身高：cm) +def calc(height,weight): + max = (height - 108)*2 + 10 # 最大限度 + min = (height - 108)*2 - 10 # 最小限度 + if weight > max: + return '偏胖' + elif weight < min: + return '偏瘦' + elif min<=weight<=max: + return '标准身材' + else: + return '输入有误' + +print(calc(170,180)) +print(calc(170,110)) +print(calc(170,130)) + + + + + diff --git a/day24/06-函数的作业.py b/day24/06-函数的作业.py new file mode 100644 index 0000000..6c2e04b --- /dev/null +++ b/day24/06-函数的作业.py @@ -0,0 +1,46 @@ +# 练习题 1：计算平均值 +# 编写一个函数 calculate_average，接受一个数字列表作为参数，返回这些数字的平均值。 +def calculate_average(numbers): + if not numbers: + return 0 + return sum(numbers) / len(numbers) + +a=calculate_average([1,2,3,4]) +print(a) + +# 练习题 2：检查素数 +# 编写一个函数 is_prime，接受一个整数作为参数，判断它是否为素数（质数），如果是返回 True，否则返回 False。 +def is_prime(n): + if n <= 1: + return False + for i in range(2, int(n ** 0.5) + 1): + if n % i == 0: + return False + return True + +# 练习题 3：字符串反转 +# 编写一个函数 reverse_string，接受一个字符串作为参数，返回该字符串的反转结果。 +def reverse_string(s): + return s[::-1] # 使用切片反转字符串 + + + + + + +# 练习题 4：统计字符频率 +# 编写一个函数 count_characters，接受一个字符串作为参数，返回一个字典，其中键为字符，值为该字符在字符串中出现的次数。 +def count_characters(s): + frequency = {} + for char in s: + frequency[char] = frequency.get(char, 0) + 1 + return frequency + +# 练习题 5：筛选偶数 +# 编写一个函数 filter_even_numbers，接受一个数字列表作为参数，返回一个新列表，其中只包含原列表中的偶数。 +def filter_even_numbers(numbers): + return [num for num in numbers if num % 2 == 0] + + + + \ No newline at end of file diff --git a/day24/07-函数的作业.py b/day24/07-函数的作业.py new file mode 100644 index 0000000..fdb3a37 --- /dev/null +++ b/day24/07-函数的作业.py @@ -0,0 +1,68 @@ +# 1. 计算平方 +def square(n): + return n * n + +print(square(5)) # 输出 25 + +# 2. 计算两数之和 +def add(a, b): + return a + b + +print(add(3, 7)) # 输出 10 + +# 3. 判断偶数 +def is_even(n): + return n % 2 == 0 + +print(is_even(4)) # 输出 True +print(is_even(7)) # 输出 False + +# 4. 计算列表中的最大值 +def find_max(lst): + return max(lst) + +print(find_max([3, 5, 1, 9, 2])) # 输出 9 + +# 5. 计算字符串长度 +def string_length(s): + return len(s) + +print(string_length("hello")) # 输出 5 + +# 6. 计算列表中所有元素的和 +def list_sum(lst): + return sum(lst) +print(list_sum([1, 2, 3, 4, 5])) # 输出 15 + +# 7. 计算阶乘 +# 编写一个函数 factorial(n)，返回 n!（n 的阶乘）。 +def factorial(n): + result = 1 + for i in range(1, n + 1): + result *= i + return result +print(factorial(5)) # 输出 120 + +# 8. 反转字符串 +def reverse_string(s): + return s[::-1] +print(reverse_string("hello")) # 输出 "olleh" + +# 9. 统计列表中某个元素的出现次数 +def count_occurrences(lst, target): + return lst.count(target) +print(count_occurrences([1, 2, 3, 4, 2, 2, 5], 2)) # 输出 3 + +# 10. 交换两个变量 +def swap(a, b): + return b, a +x, y = swap(3, 7) +print(x, y) # 输出 7 3 + + + + + + + + diff --git a/day24/08-函数的总结.py b/day24/08-函数的总结.py new file mode 100644 index 0000000..845dbfb --- /dev/null +++ b/day24/08-函数的总结.py @@ -0,0 +1,75 @@ +# 一、基础函数定义与调用 +# 题目 1：计算圆的面积 +# 定义一个函数 calculate_area(radius)，接收半径作为参数，返回圆的面积（使用公式：面积 = π * r²，π 取 3.14）。 +# 示例输入：radius = 5 +# 预期输出：78.5 +def calculate_area(radius): + pi = 3.14 + return pi * radius ** 2 + +# 调用示例 +result = calculate_area(5) +print(result) # 输出：78.5 + +# 二、参数传递（位置参数、默认参数） +# 题目 2：拼接姓名 +# 定义函数 full_name(first, last, middle='')，接收名、姓和中间名（可选），返回完整姓名（格式：first middle last，中间名不存在时省略空格）。 +# 示例输入 1：first='John', last='Doe' → 输出：'John Doe' +# 示例输入 2：first='Alice', last='Smith', middle='Mary' → 输出：'Alice Mary Smith' +def full_name(first, last, middle=''): + if middle: # 若middle不为空字符串 + return f"{first} {middle} {last}" + else: + return f"{first} {last}" + +# 调用示例 +print(full_name('John', 'Doe')) # 输出：John Doe +print(full_name('Alice', 'Smith', 'Mary')) # 输出：Alice Mary Smith + +# 三、返回值与多返回值 +# 题目 3：计算矩形的周长和面积 +# 定义函数 rectangle_metrics(length, width)，返回矩形的周长和面积。 +# 示例输入：length=4, width=3 → 输出：周长 14，面积 12 +def rectangle_metrics(length, width): + perimeter = 2 * (length + width) + area = length * width + return perimeter, area # 返回元组 + +# 调用示例 +perimeter, area = rectangle_metrics(4, 3) +print(f"周长{perimeter}，面积{area}") # 输出：周长14，面积12 + +# 四、可变参数（*args 和 kwargs） +# 题目 4：计算任意个数的平均值 +# 定义函数 average(*nums)，接收任意个数字参数，返回它们的平均值。若没有参数，返回 0。 +# 示例输入 1：average (1, 2, 3, 4) → 输出：2.5 +# 示例输入 2：average (5, 10) → 输出：7.5 +# 示例输入 3：average () → 输出：0 +def average(*nums): + if not nums: # 处理无参数情况 + return 0 + total = sum(nums) + return total / len(nums) + +# 调用示例 +print(average(1, 2, 3, 4)) # 输出：2.5 +print(average(5, 10)) # 输出：7.5 +print(average()) # 输出：0 + + + + + + + + + + + + + + + + + + diff --git a/day24/09-函数和数据容器的练习.py b/day24/09-函数和数据容器的练习.py new file mode 100644 index 0000000..d0b2b5b --- /dev/null +++ b/day24/09-函数和数据容器的练习.py @@ -0,0 +1,97 @@ +# 1. 列表筛选与转换 +# 定义函数 filter_and_square(lst)，筛选出列表中的偶数，返回每个数的平方。 +# 示例输入：[1, 2, 3, 4, 5, 6] → 输出：[4, 16, 36] +def filter_and_square(lst): + return [x ** 2 for x in lst if x % 2 == 0] + +# 示例调用 +print(filter_and_square([1, 2, 3, 4, 5, 6])) # 输出: [4, 16, 36] + +# 2. 字典值求和 +# 定义函数 sum_dict_values(dicts)，计算多个字典中所有值的总和。 +def sum_dict_values(dicts): + total = 0 + for dictionary in dicts: + for value in dictionary.values(): + total += value + return total + +# 3. 嵌套列表扁平化 +# 定义函数 flatten(lst)，将任意深度的嵌套列表展开为一维列表。 +# 示例输入：[1, [2, [3, 4], 5], 6] → 输出：[1, 2, 3, 4, 5, 6] +def flatten(lst): + result = [] + for item in lst: + if isinstance(item, list): + result.extend(flatten(item)) # 递归展开子列表 + else: + result.append(item) + return result + +# 示例调用 +print(flatten([1, [2, [3, 4], 5], 6])) # 输出: [1, 2, 3, 4, 5, 6] + +# 4. 统计单词频率 +# 定义函数 word_count(text)，统计字符串中每个单词的出现次数（忽略大小写）。 +# 示例输入："Hello world! Hello Python." → 输出：{'hello': 2, 'world': 1, 'python': 1} +from collections import Counter +import re + +def word_count(text): + # 提取单词（忽略大小写，按非字母分割） + words = re.findall(r'\b\w+\b', text.lower()) + return dict(Counter(words)) # 转换为字典 + +# 示例调用 +text = "Hello world! Hello Python." +print(word_count(text)) # 输出: {'hello': 2, 'world': 1, 'python': 1} + +# 5. 集合交集与并集 +# 定义函数 process_sets(sets)，返回所有集合的交集和并集。 +# 示例输入：[{1, 2, 3}, {2, 3, 4}, {3, 4, 5}] → 输出：({3}, {1, 2, 3, 4, 5}) +def process_sets(sets): + if not sets: + return (set(), set()) + intersection = set.intersection(*sets) # 交集 + union = set.union(*sets) # 并集 + return (intersection, union) + +# 示例调用 +sets = [{1, 2, 3}, {2, 3, 4}, {3, 4, 5}] +print(process_sets(sets)) # 输出: ({3}, {1, 2, 3, 4, 5}) + + +# 6. 字典按值排序 +# 定义函数 sort_dict_by_value(d)，返回按值升序排序的键值对列表。 +# 示例输入：{'a': 3, 'b': 1, 'c': 2} → 输出：[('b', 1), ('c', 2), ('a', 3)] +def sort_dict_by_value(d): + return sorted(d.items(), key=lambda item: item[1]) # 按值升序排序 + +# 示例调用 +d = {'a': 3, 'b': 1, 'c': 2} +print(sort_dict_by_value(d)) # 输出: [('b', 1), ('c', 2), ('a', 3)] + +# 7. 列表分组 +# 定义函数 group_by(lst, key_func)，根据指定函数的返回值对列表元素进行分组。 +from collections import defaultdict + +def group_by(lst, key_func): + groups = defaultdict(list) + for item in lst: + key = key_func(item) + groups[key].append(item) + return dict(groups) # 转换为普通字典 + +# 示例调用 +lst = [1, 2, 3, 4, 5] +key_func = lambda x: 'even' if x % 2 == 0 else 'odd' +print(group_by(lst, key_func)) # 输出: {'odd': [1, 3, 5], 'even': [2, 4]} + + + + + + + + +