Python学习笔记

Python语言

• 是一种解释性、面向对象、动态数据类型的高级程序设计语言
• 创始人：吉多，荷兰人
• 时间：1989编写的，1991公开发行

Python语言特点

• 开源、免费
• 面向过程、面向对象、交互式编程

• 面向过程：以事情或解决问题的过程为中心，主要考虑解决问题的思路和步骤
• 面向对象：以事务为中心，主要考虑解决问题时涉及的事务的特征和行为

编写人生中第一个python程序

# 汇率转换器
# 在控制台中输入美元金额，打印出人民币金额
# 1美元为7.2914人民币

#获取数据--美元金额
usd = input("请输入美元金额：")
#数据出来
#TypeError: can't multiply sequence by non-int of type 'float'
#类型错误，因为input函数所获得都是字符串无法进行数学运算
rmb = float(usd) * 7.2914
#显示结果--人民币
print("人民币金额为"+str(rmb))

• 书写代码，从右往左，从上往下顺序编写
• 程序是改出来的，不是直接写出来的
• 快捷键
• 注释
• 函数

快捷键

• 移动到本行开头home健，笔记本fn+home
• 移动到本行末尾end健
• 注释代码：ctrl+/
• 复制当前行：ctrl+d
• 撤销：ctrl+z
• 选择列：shift+alt+鼠标左键
• 移动行：shift+alt+上下箭头
• 智能提示：ctrl+space

注释

• 是对程序或代码的解释性、说明性的文字
• Python在执行程序时，会自动跳过注释，不把注释当成命令对的
• 自己编写较大的程序或者公司中团队合作编程时，为了程序的易读性，通常要加注释
• 一般注释量占总代码的20%/25%
• 单行注释

• 以#号字符开始
• 一般单独写到一行，或者写道一行的末尾

• 多行注释

• 以三个单引号或者三个双引号开头和结尾

#print()函数是python中的输出语句，在终端输出666
print(666)

函数

• 表示一个功能，函数的定义者是提供功能的人，函数的调用者是使用功能的人

input()与print()函数

#变量 = input("提示信息")
# 在终端中获取用户输入的信息，将输入的信息赋值给变量
# = 赋值符号，将右边数据给左边

# print(数据)
# 在终端中显示信息

#使用print()函数在终端中输出个人介绍（姓名、年龄、爱好）
print("刘思园")  #打印 字符串
print('21')    打印字符串
print(21)    #打印 整数
print("睡觉")  #字符串

#在一行上输出个人介绍
print("刘思园",21,"睡觉")

Demo

标识符命名规则

• 第一个字符必须是字母或者下划线，其余的字符可以是字母、数字、下划线
• 标识符不能包含空格或者其他特殊字符
• 标识符中不能是python关键字
• 标识符区分大小写
• 通常以下划线开头和结束的名称，有特殊含义，一般不建议使用
• 变量名命名时，尽量达到见名知意，使用驼峰模式命名，中文可以作为标识符使用（不建议）
• 建议命名：字母小写，多个单词以下划线间隔

class_name = input("请输入班级名称")

常量

• 固定不变的量称为常量
• 通常使用全部大写字母表示（多个词之间使用下划线增加可阅读性）

#最大年龄
MAXAGE=100
MAX_AGE=100

变量

• 把程序中运行过程中需要处理的数据用变量存储起来，然后给这个变量一个可读性强的名字，将来一旦用到这些数据，可以通过变量名来获取数据
• 变量是可以变化的量，实际上是编程人员申请的内存空间，给这段空间起的名字叫做变量名
• 定义：关联一个对象的标识符
• 作用：在内存中，操作数据
• 语法格式

变量名 = 变量值
变量名1 = 变量名2 = 变量值
变量名1,变量名2 = 变量值1,变量值2

• = 表示赋值符号，将等于号右侧的值赋值给等号左侧变量

age = 20
print("age")
x = 10
y = 20
result = x + y
print(result)

# 定义变量 申请内存，为内存空间命名
person_name = '张三'
class_name = 'test_2023'
# 修改变量:python中允许对同一个变量，先后存入不同类型的数据，之前的数据会被覆盖
person_name = '李四
#使用/调用/引用 变量：可以向申请的内存中存入数据、修改数据、取出数据进行运算、查看数据、收回
print(person_name)
#删除变量:del 用于删除变量，同时解除与对象的关联
#del 变量名1,变量名2
del person_name，class_name

变量的特点

• 变量在使用前必须先赋值，否则会报错
• 可在一行同时对多个变量赋值。变量值可相同，也可不同
• 变量赋值后，值随时可变，单值为最新一次所赋的值

数据类型

• 数据类型就是数据所属的种类

python中的数据类型

• 基本数据类型

• 整数类型int
• 浮点数类型float
• 布尔类型bool
• 只能存储一个数据，而且数据中能整体使用，不能只使用其中的一部分

a = 234
#234是一个整体，是一个数，不能拆分成2，3，4使用

• 序列数据类型--称为容器

• 字符串类型str
• 列表类型list
• 元组类型tuple
• 集合类型set
• 字典类型dict
• 可以存储多个元素/数据，既可以整体使用，也可以使用其中一部分
• 序列，数据成员（数据中的每一个）有序号/下标

• 注意变量没有类型，关联的对象才有类型

name = 'test'
age = 18
sal = 100.15

查看数据类型

• type()函数

name = 'test'
age = 18
sal = 100.15
print(type(name)type(age),type(sal))

占位

• 只希望有一个变量，但指向的对象还不能确定

#占位
skill = None
#绑定数据
skill = '乾坤大挪移'
print(skill)
#解除与对象的绑定关系
name = None
print(name)

整数类型--int

• 正整数、负整数、0

number01 = 1
number02 = -1
number03 = 0

浮点数类型--float

• 浮点数类型表示的是带小数点的数据，也成为实数
• 也称为小数，是由整数和小数组成，中间使用小数点

number04 = 3.14

布尔类型

• 表示逻辑值
• 用来表示真或假，是或否、成立或不成立、满足或不满足的类型
• 布尔类型的值

• True表示真
• False表示假

• 布尔类型的值本质是整数类型

• 0表示假，1表示真的情况

字符串

• 是一个有序的字符集合，主要用于存储和表示文本
• 字符串在Python中使用单引号，双引号，三个单引括起来的一串字符
• 是由一系列字符组成的不可变序列容器，存储的是字符编码值

• ord(字符串)返回改字符串的unicode码
• chr(整数)返回该整数对应的字符串

• 字符串只能被重新赋值，不能修改某个字符的值，字符串是不可变的
• 字符串中每个字符都有唯一一个编码（下标/序号）

• 下标从0开始

s = 'hello' #下标 0 1 2 3 4
print(s[1])
#定义字符串
name = 'sean'
address = "北京昌平区"
sex = '''男'''
email = """[email protected]"""

• 统计总字数len()函数

print(len("sean"))

数据类型转换

• 是一种数据类型转换成另一种数据类型
• 转换为整数类型：int(数据)
• 转换为浮点型：float(数据)
• 转换为字符串类型：str(数据)
• 混合类型的自动升级

• 1 + 2.14 返回的结果 3.14
• 1 + 3.0 返回结果4.0

• input()函数获取的任何内容都是字符串类型

数据的处理

• 使用运算符将两个或多个具体数据或变量连接起来的式子

a * 3
a + 4
a*2 / b/3

算是运算符

• 只能用于整数或浮点数，不能用于字符串
• 运算结果为数字

特殊运算符--复合赋值运算符

Demo

# 通过input()键盘输入给对方留言，获取留言总字数
txt = input("请输入您的留言：")
print("您留言的总字数为"+str(len(txt))+"个字")
print(f'你留言的总字数为：{len(txt)}')

# 编程实现两个数的四则运算
#获取数据
num1 = int(input("请输入第1个数:"))
num2 = int(input("请输入第2个数:"))
result_jia = num1 + num2
result_jian = num1 - num2
result_cheng = num1 * num2
result_chu = num1 / num2
print(f'两数相加得{result_jia}\n两数相减得{result_jian}\n两数相乘得{result_cheng}\n两数相除得{result_chu}')

"""
在终端中分别录入3个数据(分钟数、小时数、天数)
输出总秒数
"""
#获取分钟数
minute = float(input("请输入分钟数："))
#获取小时数
hour = float(input("请输入小时数："))
#获取天数
day = float(input("请输入天数："))
count = (minute*60)+(hour*3600)+(day*86400)
print("总秒数：",count)

"""
在终端中录入距离,时间,初速度,计算加速度.
匀变速直线运动的位移与时间公式:
	距离=初速度 * 时间 + 加速度 * 时间平方的一半
输入:
	距离:100
	初速度:2
	时间:5
输出:加速度7.2
公式:
	距离=初速度 * 时间 + 加速度 * 时间平方的一半
"""
#test10 计算匀变速直线运动
#获取距离
d= float(input("请输入距离:"))
#获取初速度
v = float(input("请输入初速度:"))
#获取时间
t= float(input("请输入时间:"))
#计算加速度
a = (d - v * t)*2 / t**2
print(f'加速度{a}')

"""
在终端中获取一个四位整数,计算每位相加和.
输入:1234
输出:10
"""
#test12
#获取四位整数
num = int(input("请随机输入四位整数："))
#num//1000  得千位数
#num % 1000 // 100 得百位数
#num % 1000 % 100 //10 得十位数
#num % 1000 % 100 %10 得个位数
result = (num//1000)+(num % 1000 // 100)+(num % 1000 % 100 //10)+(num % 1000 % 100 %10)
print(f'每位相加和为：{result}')

关系运算符

• 也称为比较运算符

<,>,<=,>=,==, !=

• 关系运算符运算的结果是布尔类型的值 True，False

Demo

"""
准备一个数，判断这个数是否是偶数
"""
num = int(input("请随意输入一个数"))
result = num %2 == 0
print(f'您输入的数:{num},它是否是偶数：{result}')

逻辑运算符

• 逻辑运算符通常和关系运算符一起使用
• 通过逻辑运算符连接多个关系运算符
• 参与的数据主要是布尔类型的数据
• 比较厚的结果是布尔类型

Demo

"""
在终端中录入年份，判断年份是否为闰年
条件1：年份能被4整除，但是不能被100整除
条件2：年份能被400整除
输入2019
输出False
输入2000
输出True
"""

year = int(input("请输入年份："))
result = (year % 4 ==0 and year % 100 != 0) or (year % 400 ==0)
print(f'判断的年份是：{year}')
print(f'判断闰年的结果是：{result}')

短路运算

• 一旦结果确定，后面的表达式将不再执行

#False and  ?
result1 = 1>1 and input("请输入一个数")==0
print(result1)
# True or ?
result2 = 2>1 or input("请输入一个数")
print(result2)

• 逻辑运算时尽量将复杂的判断放在后面

• and 当第一个式子为false时，将不会判断后面的式子，结果一定为false
• or 当第一个操作数为True是，将不会再判断第二个操作数，因此不论第二个操作数为何，结果一定为True

三目运算符

• 也成为 三元运算符 或 条件运算符

第一处内容 if 条件 else 第二处内容

• 条件： 布尔值、布尔类型的变量、布尔表达式
• 条件满足时，运行第一处内容，否则执行第二处内容

# 如果10大于等于10，则打印1，否则打印-1
print(1) if 10>=10  else print(-1)

# 如果今天天气好，输入天气真好，否则输出天气很不好
#定义变量获取天气情况，晴朗、阴天、雨天、刮风
str = input("请输入今天的天气，晴朗、阴天、雨天、刮风：")
print("天气真好！") if str == '晴朗' else print("天气真不好")

#准备一个数字
#判断是否为奇数或者偶数
#如果是奇数输出奇数，否则输出偶数
num = int(input("请输入一个整数："))
print("您输入的数为偶数") if num % 2 ==0 else print("您输入的数为奇数")

运算符优先级

• 小括号()
• 幂运算（指数）**
• 正负号 +-
• 算数运算符

• *，/，//，%
• +，-

• 比较运算符

• < <=,>,>=,==,!=

• 逻辑运算符

• 先not,后and,最后or

字符串

字符串运算

• 加法运算

• \+:用于拼接两个容器
• +=：用于原容器与右侧拼接，并重新绑定变量

• 乘法运算

• *：重复生成容器元素
• *=：用原容器生成重复元素，并重新绑定变量

• 比较运算

• 依次比较两个容器中元素，一旦不同则返回比较结果

• 成员运算

• in
• not in

s1 ="你好"
s2 ="同学"
s3 = s1+s2
print(s3,type(s3))
s3 += "a"  # s3 = s3+'a'
print(s3,type(s3))
#乘法
print("--------乘法--------")
s4 ='python'
s5 =s4*3
print(s5)
#比较
print("--------比较--------")
print(s4 != s5)
print(s4 > s5)
#成员运算
print("--------成员运算--------")
print('大圣'in'我是齐天大圣')
print('大圣' not in'我是齐天大圣')

• 索引（正向索引，反向索引）

• 索引也成为下标，就是元素编号
• 作用：定位单个元素
• 语法：容器[整数]
• 正向索引从0开始，第二个索引为1，最后一个索引为容器名[len(容器名)-1]

• 语法格式

容器名[下标]
容器名[len(容器名)-1]

• 反向索引从-1开始，-1代表最后一个，-2代表倒数第二个，第一个-len(容器)

• 切片

• 作用：定位多个元素
• 语法：容器[开始索引:结束索引:间隔]
• 结束索引不包含该位置元素
• 开始索引默认为0，间隔默认为1

• 倒叙打印
  容器名[::-1]

• 间隔 是整数时表示自左向右
• 间隔 是负数时表示自右向左

字符串常见的函数

• 获取字符串长度

• len() 统计字符串长度

s1 ="123456"
print(len(s1))

• 查找一个字符串在另一字符串中首次出现的位置

• find(str,start,end)
• str表示要查找的字符串
• start 表示查找的开始位置
• end表示查找的终止位置
• 返回范围是第一个字符首次出现的对应下标

• 统计一个字符串在另一个字符串中出现的次数,如果不存在返回0

• count(str)

• 指定某个字符为分隔符，从字符串的左边开始将其分割成多个字符串，并将结果以列表形式返回

• split(分隔符，分割数量)

• 大小写转换

• upper()英文字母全变为大写
• lower()英文字母全变成小写

• 字符串替换

• replace(旧字符串,新字符串,个数)

• 删除字符串两端，右端、左端空白字符

• strip()
• rstrip()
• lstrip()

• 判断是否全为字母

• isalpha()

• 判断是否全为数字

• isdigit()

• 判断字符串以什么开头

• startswith()

• 判断字符串以什么结尾

• endswith()

列表

• 属于序列数据类型
• 以[]定界，多个数据之间用英文逗号间隔
• 列表是有序、
• 可变的序列之一
• 列表中各个元素的数据类型可以不同

#创建列表
列表名 = []
列表名 = list(可迭代对象)
# 添加元素
列表名.append(元素) #追加
列表名.insert(索引,元素) #根据索引插入元素
# 定位元素
索引、切片
创建列表
# list1 = []  #定义空列表
# print(list1,type(list1))
# list2 = list(range(10)) #list括号中放入可迭代对象
# print(list2,type(list2))
# list3 = ['a','b','c']
# print(list2,type(list3))
# list4 = ['a','b','c',1,2,3,5.6,6]
# print(list4,type(list4))
# list5 = [['a','b','c',1,2,3,5.6,6],['a','b','c']]
# print(list5,type(list5))
# 遍历列表
    -正向方法
    for 变量 in 列表名:
        print(变量)
    -反向方法
    for 索引名 in range(len(列表名)-1，-1，-1)：
        print(列表名[索引])
# 拆包/解包
*[1,2,3]
list5 = [['a','b','c',1,2,3,5.6,6],['a','b','c']]
print(list5,type(list5))
print(*list5)
print(*[1,2,3])
a,b,c =[1,2,3]
print(a,b,c)

#定义列表，列表中存入测试用例
#用例编号、测试标题、用户名、密码、预测结果
cases = [
    [101,'测试用户登录01','admin','123456','登录成功'],
    [102, '测试用户登录02', 'admin', '123', '密码错误'],
    [103, '测试用户登录03', 'adm', '123456', '用户名错误'],
    [104, '测试用户登录04', 'admin', '', '密码为空'],
]
#获取第二条测试用例
#将第二条用例的用户名、密码、预期结果获取出来并存入变量中
print(cases[1])
username = cases[1][2]
password = cases[1][3]
expect = cases[1][4]

列表运算

• 加法运算 -- 拼接
• 乘法运算 -- 复制

list01 = [1,2,3,4]
list02 = list01 * 3
print(list02)

修改列表中的某个元素

list01 = [1,2,3,4]
#更新或修改元素
list01[1] = 1
print(list01)
# 列表名[下标] = 新数据

#删除某个元素   
del list01[2]
print(list01)

#del 列表名[下标]
#列表名.pop(下标/索引号)


list01 = ["高程","周景阳","赵平岩","张文博"]
# print(list01.count("高程"))
# print(list01.clear()) #清空列表中的内容
print(list01.remove("高程")) #返回None
print(list01)

"""
创建列表，存储水金地木土天王星
向列表中追加海王星
在地球后插入火星
打印地球里太阳最近的行星（最后一个行星）
打印地球之前的所有行星（前两个行星）
删除金星
删除地球后面的所有行星
倒叙打印所有行星
"""

ball = ["水星","金星","地球","木球","土星","天王星"]
ball.append('海王星')
print(f"追加海王星{ball}")
ball.insert(3,'火星')
print(f"插入火星{ball}")
print(f'打印地球里太阳最近的行星:{ball[-1]}')
print(f'打印地球之前的所有行星:{ball[:2]}')
#删除金星
# print(f"删除金星{ball.pop(1)}")
# print(f'删除金星后的数据：{ball}')
# del ball[2:]
# print(f"删除地球后面的所有行星:{ball}")
print(f'倒叙打印所有行星:{ball[::-1]}')

元组

• 是有序，不可变的序列类型，一旦创建，不可改变
• 元组也称为常量列表
• 使用元组，访问速度快，代码安全性更高

元组名 = (数据1，数据2，....数据n)
元组名 = tuple(可迭代对象)

#整体访问
print(元组名)
#索引/切片访问单个或多个元素
#也可以通过拆包解包访问
#元组可以进行加法运算、乘法运算
#元组不能单独删除某个元素

"""
在控制台录入日期（月日），计算是这一年的第几天
例如：
   3月15日 -->31+28+15
   5月20日 -->31+28+31+30+20
"""

#获取月份
date1 = int(input("请输入月份："))
#获取日期
date2 = int(input("请输入日期："))
# 定义 每月天数的元组
day = (31,28,31,30,31,30,31,31,30,31,30,31)
#      1  2  3   4 5  6  7  8  9  10 11 12  对应的月份
#      0  1  2   3 4  5  6  7  8  9  10 11  对应的天数的下标
result = sum(day[:date1-1]) + date2
print(f"你输入的日期是{date1}月{date2}日，这是这一年的第{result}天")

字典

• 字典属于无序、可变的数据类型
• 以键:值 的方式存储，通过键来访问字典的值 键不可重复，只可以重复

#创建字典
字典名 = {键1:值1,键2:值2} #常用
字典名 = dict(键1:值1,键2:值2)

student = {"username":"张三","age":18,"sal":23.23}
#使用整个字典
print(student)
#获取字典中的姓名，年龄
print(student["username"])
print(student["age"])
#删除字典元素
del student["age"]
#删除字典
del 字典

不可拼接不可复制

• 常用字典函数

• 复制字典copy() 和赋值一样

student01 = {"username":"张三","age":18,"sal":23.23}
student02 = student01.copy()

• clear() 清空字典
• **pop()**删除字典中指定元素
• **get()**获取键所对应的值
• update() 更新将一个字典元素更新到另一个字典中（存在则覆盖）
• 获取字典中所有的键 keys()
• 获取字典中所有的值 values()
• 以键与值形式返回字典元素 items()

集合

• 集合是无序的、可变的序列
• 同一个集合内的每个元素都是唯一的，不允许存在重复元素
• 不支持修改、复制

• 创建集合
• 解包
• 删除集合 del 集合名

#创建集合
集合名 = {数据1，数据2，...}
集合名 = set(可迭代对象)

#创建集合
set01 = {1,2,3,4,5,6}
set02 = {'a','b',2,'c',3,4}
set03 = set(range(10))
#使用集合
print(set01)
#解包
a,b,c,d,e,f = set01
#删除集合
del 集合名

• 常见运算

• 并集 | 去重且合并

set06 = {1,2,3,4,5}
set07 = {1,6,3,4,7}
result = set06 | set07

• 交集 & 打印共同含有的元素
• 差集 - 一集合比另一个集合多的元素

• 集合常用的函数

• add() 添加元素如果元素已存在则忽略该操作
• update() 将一个集合中的元素更行到另外一个集合中
• pop() 删除集合中的一个元素，并返回该值

number = set.pop()
print(number)

• remove() 移除集合中的某个元素
• clear() 清空集合

流程控制语句

• 顺序结构：按照顺序一行一行的写代码，程序执行时按照书写代码的顺序执行
• 选择结构：编写过程中会写不同的程序，只执行其中的一个程序
• 循环结构：写一份程序，会反复执行多次

选择结构

• 根据条件是否成立，决定执行那段代码
• 选择结构分为单分支、双分支、多分支、嵌套分支
• 单分支

if 条件:
     语句段（代码）

• 双分支

if  条件:
     语句段1
else:
     语句段2

• 多分支

if 条件:
     语句段1
elif 条件:
     语句段2
elif 条件:
     语句段3
else:
     语句段4

# 题目1：输入两个整数，使用if语句，判断大小，把比较大的值输出
print("判断输入整数的大小")
num1 = int(input("请输入第一个整数："))
num2 = int(input("请输入第二个整数："))
max_number =num1
if max_number <num2:
    max_number =num2
print(f"最大的数是：{max_number}")

# 题目2：从键盘输入性别，当输入正确时，输出“你的性别是...”，输出错误时，什么也不做
sex = input("请输入性别：")
if sex == '男' or sex == '女':
    print(f'你的性别是{sex}')
else:
print("性别未知")

#题目3：当两个整数都是正数时，计算和，否则什么也不错
num1 = int(input("请输入第一个正数："))
num2 = int(input("请输入第二个正数："))
if num1 >0 and num2 >0 :
    print(f"两数之和为{num1}+{num2}={num1+num2}")


#题目4：获取键盘输入的一个整数值，求该数的绝对值
num1 = int(input("请输入第一个整数："))
if num1 < 0 :
    num1 = -num1
print(f'该数的绝对值为{num1}')

#题目5：键盘输入2个整数，比较大小（双分支）
num1 = int(input("请输入第一个整数："))
num2 = int(input("请输入第二个整数："))
if num1 > num2:
    print(f"您输入的{num1}比{num2}大")
else:
    print(f"您输入的{num2}比{num1}大")

#题目6：获取键盘输入的整数，判断时整数还是负数
num = int(input("请输入第一个整数："))
if num > 0:
    print(f"您输入的整数{num}是正数")
else:
    print(f"您输入的整数{num}是负数")

#题目7：获取键盘输入的分数，判断分数所属的等级（优秀、良好、中等、及格、不及格）
score = float(input("请输入您的分数："))
if score >= 90:
    print(f"您的成绩为优秀")
elif 80 <= score < 90:
    print(f"您的成绩为良好")
elif 70 <= score < 80:
    print(f"您的成绩为中等")
elif 60 <= score <70:
    print(f"您的成绩为及格")
elif score>=0 and score <60:
    print(f"您的成绩为不及格")
else:
    print(f"分数只能输入0~100之间的数”)

#题目8：在控制台获取一个季度，打印相应的月份
#      输入与输出
#      春 1~3月
#      夏 4~5月
#      秋 7~8月
#      冬 10~12月

season = input("请输入季度：")
if season == '春':
    print(f"您输入的季度{season}有1月2月3月")
elif season == '夏':
    print(f"您输入的季度{season}有4月5月6月")
elif season == '秋':
    print(f"您输入的季度{season}有7月8月9月")
elif season == '冬':
    print(f"您输入的季度{season}有10月11月12月")
else:
    print(f"请重新输入”)

# 题目9
"""
	先在终端中录入一个数字
	再录入一个运算符
	最后录入一个数字
	打印计算的结果
	要求:如果运算符不是+ - * / 提示"运算符输入有误"
"""
num1 =float( input("请输入第一个数字："))
char = input("请输入运算符：")
num2 =float( input("请输入第二个数字"))
if char == '+':
    print(f"{num1}+{num2}={num1+num2}")
elif char == '-':
    print(f"{num1}-{num2}={num1-num2}")
elif char == '*':
    print(f"{num1}*{num2}={num1 * num2}")
elif char == '/':
    print(f"{num1}/{num2}={num1 / num2}")
else:
    print(f"运算符输入错误")

# 题目 10
"""
在终端中依次录入4个同学体重,打印最重的值.
	思路:假设第一个就是最大的
	使用假设的依次与后几个变量进行比较,如果发现更大的,则替换假设的
输入:52 ,40,37,60
输出:60
"""

print("请依次输入四位同学的体重(kg)")
weight1 = float(input("请输入第一个同学的重量:"))
weight2 = float(input("请输入第二个同学的重量:"))
weight3 = float(input("请输入第三个同学的重量:"))
weight4 = float(input("请输入第四个同学的重量:"))
if weight1 > weight2 >weight3 >weight4 :
    print(f"体重最重的是第一位同学：{weight1}")
elif weight2 > weight3 >weight4 >weight1:
    print(f"体重最重的是第二位同学{weight2}")
elif weight3 > weight4 >weight1 >weight2:
    print(f"体重最重的是第三位同学{weight3}")
else:
    print(f"体重最重的是第四位同学{weight4}")

# 题目 11
"""
	在终端中录入一个成绩,判断等级
	输入:成绩
	输出:优秀,良好,及格,不及格,成绩有误
"""
print("请输入你的成绩")
score = float(input("请输入您的分数："))
if score >= 90:
    print(f"您的成绩为优秀")
elif 80 <= score < 90:
    print(f"您的成绩为良好")
elif 70 <= score < 80:
    print(f"您的成绩为中等")
elif 60 <= score <70:
    print(f"您的成绩为及格")
elif score <60:
    print(f"您的成绩为不及格")
else:
    print(f"成绩有误”)
# 题目12
"""
在终端中录入月份,然后打印天数.
输入:2 输出:28天
输入:1 3 5 7 8 10 12 输出:31天
输入:4 6 9 11 输出:30天
"""
          
month = int(input("请输入月份："))
if month == 2:
    print(f"{month}月有28天")
elif {month} & {1, 3, 5, 7, 8, 10, 12}:
    print(f"{month}月有31天")
elif {month} & {4,6,,9,11}:
    print(f"{month}月有30天")
else:
    print(f"请重新输入”)
# 题目13
'''
获取键盘输入的节日名称,输入相应的礼物
春节---饺子 情人节---玫瑰花 
端午节---粽子 中秋节---月饼
'''
          
#获取节日名称
print("输入节日名称（春节、情人节、端午节、中秋节），将会打印出对应的节日礼物")
festival = input("请输入节日名称：")
if festival == '春节':
    print(f"{festival}的礼物是饺子")
elif festival == '情人节':
    print(f"{festival}的礼物是玫瑰花")
elif festival == '端午节':
    print(f"{festival}的礼物是粽子")
elif festival == '中秋节':
    print(f"{festival}的礼物是月饼")
else:
    print(f"请重新输入”)

          
# 题目14
"""
在终端中获取一个整数,如果是偶数为变量state赋值"偶数",否则赋值"奇数"
在终端中获取一个年份,如果是闰年为变量day赋值29,否则赋值28
"""
num = int(input("请输入一个整数："))
state = "奇数" if num % 2 else "偶数"
          
year= int(input("请输入一个年份："))
day = 29 if (year % 4 ==0 and year % 100 != 0) or (year % 400 ==0) else 28          

# 题目15
'''
获取键盘输入的三角形3条边,判断是否可以组成三角
形,如果能组成三角形,进一步判断是什么三角形(等边、等
腰、直角、普通)
'''
          
a = float(input("请输入三角形第一条边："))
b = float(input("请输入三角形第二条边："))
c = float(input("请输入三角形第三条边："))
if a>b>c and b+c > a :
    print("可以组成三角形")
elif b>c>a and c+a >b:
    print("可以组成三角形")
elif c>a>b and a+b >c:
    print("可以组成三角形")
else:
    print("不可以组成三角形")
if a==b==c:
    print("改三角形为等边三角形")
elif a**2 == b**2+c**2 or b**2 == a**2+c**2 or c**2 == b**2+a**2:
    print("该三角形为直角三角形")
elif a==b or a==c or b==c:
    print("该三角形为等腰三角形")
else:
    print("该三角形为普通三角形")
# 题目16
'''
键盘输入1000---5000年之间的年份,如果在范围里
判断是平年还是闰年,如果不在范围里给出错误信息提示
'''
          
year= int(input("请输入1000~5000年份："))
if year<=1000 or year>=5000:
    print("请输入范围内的年份")
elif(year % 4 ==0 and year % 100 != 0) or (year % 400 ==0):
    print(f"{year}为闰年")
else:
    print(f"{year}是平年")

#嵌套语句方法
# year= int(input("请输入1000~5000年份："))
# if 1000<= year<=5000:
#     if (year % 4 ==0 and year % 100 != 0) or (year % 400 ==0):
#         print(f"{year}为闰年")
#     else:
#         print(f"{year}是平年")
# else:
#     print("请输入范围内的年份")


# 根据键盘输入的身高(sg)和体重(tz),计算bmi值,判断身体状况
# sg = float(input("请输入身高（m）："))
# tz = float(input("请输入体重（kg）："))
# bmi = tz /sg**2
# if bmi <= 18:
#     print(f"您的身体状况偏瘦")
# elif 18<bmi<24:
#     print(f"您的身体状况正常")
# elif 24 <= bmi <= 28 :
#     print(f"您的身体状况超重，请注意健康饮食")
# else:
#     print(f"您的身体状况是肥胖，请注意减肥")


"""
编写一个计算器,实现,加、减、乘、除功能,要求:
(1)根据计算符号(fh),选择相应的功能
(2)使用嵌套解决除数是0的问题
"""
# num1 = float(input("请输入第一个数"))
# fh = input("请输入运算符")
# num2 = float(input("请输入第二个数"))
# if fh == '+':
#     print(f"{num1}+{num2}={num1+num2}")
# elif fh == '-':
#     print(f"{num1}-{num2}={num1 - num2}")
# elif fh == '*':
#     print(f"{num1}*{num2}={num1 * num2}")
# elif fh == '/':
#     if num2 != 0:
#         print(f"{num1}/{num2}={num1 / num2}")
#     elif num2 == 0:
#         print("除数为零不做计算")
# else:
#     print("请重新输入")

注：文章中的练习题是从网上复制其他博主的，但是是自己做的，笔记是老师上课讲的，可能或许打给会与其他博主有相似之处，是我自己整理的哦！