python
1.print
print是python中提供的打印输出功能 是将python程序中的数据输出到控制台
print('hello wold')
2.注释
“”"
三对引号【英文格式下】单引号可以，双引号也可以
“”"
注释掉含义：
对代码进行解释和说明，目的就是让别人和自己能够清晰的看懂代码
注释是不会被计算机识别的
一般写注释的时候 写在代码的后方或者上方
注释还有另外一个作用;修改代码的时候，可能代码需要进行调试
单行注释的快捷键ctrl+/
去处键也是ctrl+/
3.编程语言
编程语言：有多条语句 按照相应的逻辑实现代码
编写相应的程序语句都有相应的结束标记
一般编程语言的结束标记是分号
在python中建议语句 的予以结束不需要分号 也可以写分号【但是荟被警告】
建议一行一句【如果一行有多种语句，语句结束必须加分号】不建议
print("hello word");print("hello python")
print("hello python")
print("hello 千锋")
缩进：在代码前面不要随便添加空格或tob键
print("hello everyone")
print("nice to meet you")
4.标识符
标识符:标识某个实体的符号，使用这个符号可以代替实体参与相应的运算
在编程语言中，标识符一般就是给变量、项目名称、文件名称、函数名、类名等等自定义名称，建立起名称和使用的数据之间的关系
自定义名称是要遵守一定的规则的;
1.标识符是由数字、字母、下划线组成的
2. 标识符名称不能以数字开头
3. 不能使用关键字与保留字
关键字：编程语言中具有特殊含义的单词
保留字: 编程语言中已经使用的名称 不建议再使用 【因为再使用的话 会覆盖掉原本的含义】
# 我想打印一个数据10
print(10)
# 定义一个标识符 给它赋值为10
num = 10
print(num)
# 我想打印 10+20的和
print(10 + 20)
print(num + 20)
定义的时候包含了其他的符号 就会报错
# num@ = 10
# SyntaxError: invalid syntax
不能以数字开头
# 1_num = 10
# SyntaxError: invalid decimal literal
python中的关键字有哪些
Python环境中自带了很多工具包，每个工具包都有对应的作用
比如 time — 包含时间相关的操作
要想使用工具包 需要导包
语法：import 工具包名
使用工具包下面的内容 工具包名.内容名
import time
# 打印当前时间 获取time工具包 当前时间的操作
print(time.localtime())
# python中的关键字 被放在 keyword的工具包
import keyword
# 获取所有的关键字的操作
print(keyword.kwlist)
"""
'False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class',
'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from',
'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or',
'pass', 'raise', 'return', 'try', 'while', 'with', 'yield'
"""
# 使用关键字定义名称
# False = 10
# SyntaxError: cannot assign to False
# 不允许给False再次赋值
# 不建议使用保留字
# print 在Python中被使用了 具有输出的含义
# print = 10
# print这个标识符 代表只是10 原本的输出的含义就被覆盖了
# print(10)
# TypeError: 'int' object is not callable
怎么辨别是不是保留字： 写单词的时候被提示出来的都是Python中已经使用的了 就不再使用即可
5.变量与数据类型
变量：变化的数据 这种变化的数据在程序中来使用 一般会给数据做个标记 方便获取相关的数据信息
这个标记就成为变量名
例如
在程序中使用气温的时候，具体使用那个数据就不确定了
一般会给这个数据值 设置一个变量名 随着时间的推移 设置不同的数据值
当使用的时候直接使用的时候直接使用这个标记名代替数据参与运算即可
# 早晨温度
air_temp = 24
# 中午温度
air_temp = 30
print(air_temp)
数据类型：把相同特征的数据进行归类，形成一类数据，这个称为数据类型
Python中的数据类型
整数类型(整型int) 10 20 30 45
小数类型(浮点型float) 4.15 6.78
文本数据(字符串str) 字符串数据是需要使用引号包含的[不 区分单双引号]]
‘hello’ ‘千锋’ “Nice” ‘’ [空字符串]
逻辑结果(布尔类型bool) 逻辑结果只有两种 成立与不成立，布尔值只有两个 True 和 False
空类型(NoneType) 空值(None) 代表什么都没有 空字符串和None不是一个东西 【空字符串理解成是空箱子 None连箱子都没有】
获取数据的类型 type(变量名)
类和对象
类： 对具有相同属性和特征的数据的一个抽象描述 比如整数类型
对象: 该类下实际存在的实体 比如 10
生活中举例:
电脑 --- 类[泛泛的称呼]
联想小新 — 类
某人的电脑 — 对象
学生 – 类
某人-- 对象
# 定义一个 变量 记录人的名称 [起名字尽量见名知意]
name = '小千'
print(name)
# 定义一个变量 记录一个人的年龄
age = 10
print(age)
print(type(age)) # <class 'int'> class代表的就是类型
# 定义一个变量 记录性别
gender = '女'
print(gender)
print(type(gender)) # <class 'str'>
# 记录一个状态值
flag = True
print(flag)
print(type(flag)) # <class 'bool'>
# 空值
result = None
print(type(result)) # <class 'NoneType'>
6.输入
输出 按住ctrl键 点击要查看信息的名称 就可以进入到Python定义的源码文件
print(value, …, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)
value, …, 代表print可以一次性输出多个数据，书写的时候 数据之间使用逗号分隔
sep=’ ’ 一次性输出多个数据时 展示的结果中数据之间的分隔符 默认是空格
end=‘\n’ 输出内容结束符，print输出内容时 会在内容末尾追加一个结束符 默认是换行
字符串中特殊的符号 \ [转义符]
可以将某些符号的含义 转变成其他的意思
n — \n换行符
r — \r 回车 在windows系统下 存储数据的时候 \n 本质上存储的是\r\n
t — \t 制表符 就是tab键
u —\u 这个识别成unicode编码符号
file=sys.stdout
print数据输出的目的地，默认就是控制台
flush=False
是否快速的将通道中的数据输出到文件中
print(10, 20, 30, 40)
# 自己设置多个数据之间的分隔符
# 如果直接使用逗号分隔 代表的输出的多个数据 为了区分是数据还是分隔符，给分隔符赋值的时候 sep=指定的分隔符
print(10, 20, 30, 40, sep='+')
# 演示转义符
print('and') # and
print('a\nd')
"""
a
d
"""
# 输出内容的时候 此时不需要换行 可以修改end的值
print('hello', end='\t')
print('world')
把内容输出到文件中
- 需要建立程序和文件之间的联系通道
有一个操作 open(文件路径, 操作文件的模式, 文件的编码形式)
以指定模式将文件与程序建立联系
操作文件的模式
r–read 只读 在程序中要读取文件的数据
w – write 只写 要将信息从程序中写入到文件
文件如果不存在 会自动创建文件
文件存在 会清空文件内容 再把数据写入
a — append 只写 要将信息从程序中写入到文件中
文件不存在 会创建文件
文件存在 进行的是追加写的操作
文件的编码形式 【不同的编码形式决定了文件中语言的类型】
编码：人为规定一种编译规则
在计算机存储数据的时候，存储格式是 二进制形式的
十进制数据 逢十进一 数字符号集 0 1 2 3 4 5 6 7 8 9
二进制数据 逢二进一 数字符号集 0 1
但是数据存储的时候 并不是只有数字，还有汉字 英文字母等等
十进制转化成二进制怎么转换的？？？
存储10 在计算机中的是什么样子？？？
除以2取余数 直到商为0 将所有的余数倒序拼接起来
10/2 = 5 ---- 0
5/2 = 2 ----- 1
2/2 = 1 ----- 0
1/2 = 0 ----- 1
10 ====> 1010
汉字、英文字母等等不能直接转化为二进制，因此就出现了编码
计算机人为制造的，运算规则也是人为制造的
汉字或者英文字母在存储的时候 指定了什么规则？？？ 这个映射规则称为编码
将汉字或者英文字母 每一个字对应着一个数字
例如
a ===> 97
一 ===> 27361
常见的编码规则有：
ASCII码 --- 只设置128个符号对应的数字 包括英文字母
GB2312 --- 国家编码标准 2312序列号
GBK --- 国标扩展
Unicode --- 国际编码标准 【收录是世界语言在内的】
Python的编码就是unicode下UTF-8
- 通过通道把数据传递到文件中
handle = open('C:\WorkContent\各班代课\Python2304\day02_变量及其运算符\代码\静夜思.txt', 'w', encoding='utf-8')
print('床前明月光，疑是地上霜。', file=handle, flush=True)
# \u 每一个unicode编码值 都对应着一个文字
print('\u4e00') # 一
路径中 C:\users…
怎么解决转义的问题？ 有些情况下 不需要转义符进行转义，保持转义符的本意
方式1： 对转义符再次转义 \ 保持\本身的含义
print('\\n') # \n
方式2: 使用r修饰字符串 字符串中每个符号都保持数据本身的含义
print(r'\n') # \n
open(文件路径, 操作文件的模式, 文件的编码形式)
文件路径有两种格式:
1. 绝对路径
windows系统 从盘符开始 到 具体的文件的路径 就是绝对路径
C:\WorkContent\各班代课\Python2304\day02_变量及其运算符\代码\静夜思.txt
Mac系统 从根路径 /开始到具体文件结束
/Users/各班代课/Python2304/day02_变量及其运算符/代码/静夜思.txt
2. 相对路径[建议]
需要文件配置在项目路径下
相对路径是有参照物的：当前正在编辑的文件
相对路径中有两个特殊的符号：
. — 当前操作的文件所在的文件夹 cat
… — 当前操作的文件所在的文件夹上一级 E
handle1 = open('./静夜思.txt', 'w', encoding='utf-8')
print('床前明月光， 疑是地上霜', file=handle1)
# handle1 = open('../李白.txt', 'w', encoding='utf-8')
7.输出
print 把数据输出到控制台
input 让用户在控制台输入数据 传递到程序中
格式：input（提示语）—会让程序暂停
如何让程序继续：在控制台输如数据 ，结束输入的标记是回车
输如数据回车之后 就把控制台输入的数据传递到程序中 想要获取这个数据 需要接收
注意：输入的数据是变化的【也就是变量】想要获取变量的数据需要给变量的值一个标记名【变量名】
#将用户在控制台输入的数据 赋值给name之歌变量名
name=input('请输入你的姓名：')
print('打印name的值',name)
#不管录入的数据格式是什么样的 在程序中变量的值永远都是字符串类型的
value=input('请输入内容：')
print(type(value))
8.类型转换
让用户输入两个数，求两个数的和
num1 = input('请输入第一个数：')
num2 = input('请输入第二个数：')
print('两个数据的和', num1 + num2) # 两个数据的和 1728
为什么是这个结果？？？
input 不管用户输入的是什么格式的数据 在程序中拿到的都是字符串类型的
字符串数据之间进行相加 完成的是拼接的动作
print('a' + 'b') # ab
目的是求和，不是拼接
想要完成这个目的，num1和num2接受到数据类型得是整数类型的才可以，但是现在是字符串类型的
想让字符串格式的数值变成整数类型，就需要进行类型转换
操作语法【这个格式是固定的】
int(数据/变量名)
value = '1673'
print(type(value)) # <class 'str'>
num = int(value)
print(type(num)) # <class 'int'>
注意事项： 把字符串格式的数值转化为整型时 数值的格式必须满足整数形态
int('3.14')
ValueError: invalid literal for int() with base 10: '3.14'
# 不合法的数据
int('17a')
# ValueError: invalid literal for int() with base 10: '17a'
# 改进：才能达到需求
# 输入一个数值 将转换为整型 并赋值给num1
num1 = int(input('请输入第一个数：'))
num2 = int(input('请输入第二个数：'))
print('两个数据的和', num1 + num2) # 两个数据的和 45
把字符串数据转化成浮点型
float(数据/变量名)
注意：转换的时候要满足数字的形态 【可以是整数 也可以小数】
data = '3.14'
res = float(data)
print(type(res)) # <class 'float'>
data = '10009'
res = float(data)
print(type(res)) # <class 'float'>
9.算数运算符
一元运算符： 正负号 +17 -89
二元运算符
加法 +
减法 -
乘法 *
除法 / 和 //
取余 %
幂数 **
a = 17
b = 6
print('加法', a + b)
print('减法', a - b)
print('乘法', a * b)
print('除法', a / b) # 结果是浮点型的
print('向下整除', a // b) # 有一个向下取整的操作： 结果是<=商 且最接近于商的整数
print('取余', a % b) # 两数相除 获取余数
print('幂数x的y次方', a ** b)
"""
加法 23
减法 11
乘法 102
除法 2.8333333333333335
向下整除 2
取余 5
幂数x的y次方 24137569
"""
#print(2 ** 3)
# 开方
# 对8开3次方 === 8的三分之一次方
#print(8 ** (1/3))
"""
算数运算符的优先级：**幂数>负号>乘，除，余>加减
提高运算符的优先级别 使用()包含 不管多少层都是（）
10.复合赋值运算符
简单的赋值运算符
=
a=10[将等号右边数据赋值给左边的变量名]
复合赋值运算符
在进行赋值的时候 先进行了算术运算
+=
-=
*=
/=
//=
%=
**=
num = 125
# num -= 15 # ===>num-15=125-15=110
# print(num)
# num %= 4 # ===>num%4=110%4=2
# print(num)
# num **= 5 # ===>num**5=2**5=32
# print(num)
a = 17
b = 9
res = a + b > b * 2
print(res) # True
res = a - b <= a % b
print(res) # True
# 判断一个数据是否是偶数 偶数：能被2整除【除以2余数为0】
num = 17
res = num % 2 == 0
print(res) # False
# 判断一个数的个位数是否为7
# 获取数据的个位数？？？？ 除以10 取余数 比如 17除以10 商1 余7 16除以10商1余6
res = num % 10 == 7
print(res) # True
# 如何获取十位上的数据？？？？
"""
1.可以将十位上的数 处理成个位上的数 ===== 整除10 245//10 = 24
2.将处理后的结果对10取余 24 % 10=4
"""
# 判断一个数据是否是奇数 除以2余1
res = num % 2 == 1
print(res)
res = num % 2 != 0
print(res)
11.比较运算符
比较两个数据，判断大小
> 判断前者是否大于后者
>=判断前者是否大于等于后者
<判断前者是否小于后者
<=判断前者是否小于等于后者
== 判断前者是否等于后者
!= 判断前者是否不等于后者
比较运算符运行结果是布尔类型的，结果只有两个值True和False
算术运算符优先级别高于比较运算符
a = 17
b = 9
res = a + b > b * 2
print(res) # True
res = a - b <= a % b
print(res) # True
# 判断一个数据是否是偶数 偶数：能被2整除【除以2余数为0】
num = 17
res = num % 2 == 0
print(res) # False
# 判断一个数的个位数是否为7
# 获取数据的个位数？？？？ 除以10 取余数 比如 17除以10 商1 余7 16除以10商1余6
res = num % 10 == 7
print(res) # True
如何获取十位上的数据？？？？
1.可以将十位上的数 处理成个位上的数 ===== 整除10 245//10 = 24
2.将处理后的结果对10取余 24 % 10=4
# 判断一个数据是否是奇数 除以2余1
res = num % 2 == 1
print(res)
res = num % 2 != 0
print(res)
12.逻辑运算符
逻辑运算符是来操作逻辑关系的
逻辑与 and
连接的条件必须同时成立【也就是条件之间是并且的关系】，结果才是成立的
逻辑或 or
连接的条件成立其中一个即可【也就是条件之间的关系是或者关系】
逻辑非 not
对条件结果进行取反操作，真变假，假变真
比较运算符的优先级高于逻辑运算符
逻辑运算符中 not > and > or
# 大学中评奖学金 平均成绩和绩点
# 平均成绩在90以上 并且 绩点在4.5以上
# 定义两个变量 表示成绩和绩点
# score = float(input('请输入平均成绩：'))
# gpa = float(input('请输入绩点：'))
# res = score > 90 and gpa > 4.5
# print(res)
练习:
1. 输入一个数 判断这个数是否是3的倍数 并且也是7的倍数
2. 输入一个数 判断这个数的十位是否为2的倍数 并且 个位是否是3的倍数
# 1. 输入一个数 判断这个数是否是3的倍数 并且也是7的倍数 倍数：整除【余数为0】
# num = int(input('请输入一个整数：'))
# res = num % 3 == 0 and num % 7 == 0
# print(res)
#
# # 因为找的是既是3的倍数 也是7的倍数 可以找两个最小公倍数 21
# res = num % 21 == 0
# print(res)
# 2. 输入一个数 判断这个数的十位是否为2的倍数 并且 个位是否是3的倍数
# num = int(input('请输入一个整数：'))
# decade = num // 10 % 10
# unit = num % 10 # 个位上的数据是不足10 除以10会被余下的
# # 加这个不等于0 考虑的是0不是任何数的倍数
# res = (decade % 2 == 0 and decade != 0) and (unit % 3 == 0 and unit != 0)
# print(res)
逻辑或 or
条件1 or 条件2
其中一个条件成立即可
# 判断一个年是否为闰年
"""
闰年：分为普通闰年和世纪闰年
普通闰年： 能被4整除但是不能被100整除 2020年
世纪闰年： 能被400整除 2000年
普通闰年和世纪闰年满足其中一个要求 就是闰年
"""
# year = int(input('请输入年份：'))
# # common = year % 4 == 0 and year % 100 != 0
# # century = year % 400 == 0
# # res = common or century
# res = (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)
# print(res)
# 判断输入的月份是否是第三季度的 7月8月9月
# month = int(input('月份：'))
# res = month == 7 or month == 8 or month == 9
# print('输入的月份是否是第三季度的结果：', res)
"""
1. 判断输入的数据是否是3或者5的倍数
2. 判断输入的月份的天数是否是30天
"""
# num = int(input('请输入整数：'))
# res = num % 3 == 0 or num % 5 == 0
# print(res)
# 判断输入的月份的天数是否是30天
# 4 6 9 11
# month = int(input('输入月份：'))
# res = month == 4 or month == 6 or month == 9 or month == 11
# print(res)
逻辑非 not
对逻辑结果取反: not 条件
如果条件是成立的 not之后 结果就为False
如果条件是不成立的 not之后 结果就是True
# 判断一个数是否为奇数
# num = int(input('请输入整数:'))
# # num % 2 == 1
# # num % 2 != 0 # 不等于0 就是对等于0进行取反
# res = not(num % 2 == 0)
# print(res)
# 判断一个数是否能被3或者7整除 但是不能同时被3和7整除
# num = int(input('请输入整数:'))
# res = (num % 3 == 0 or num % 7 == 0) and not(num % 3 == 0 and num % 7 == 0)
# print(res)
练习：
1. 判断一个数是否不为正数
2. 输入一个月份 判断其是否在 1-12之间
# num = int(input('请输入整数:'))
# res = not(num > 0)
# print(res)
# 输入一个月份 判断其是否在 1-12之间
month = int(input('月份：'))
# month >= 1 and month <= 12
res = not(month < 1 or month > 12)
print(res)
# 区间形式的范围判断 month >= 1 and month <= 12
# python可以对其进行简写
res = 1 <= month <= 12
print(res)
13.成员运算符
成员： 众多中的一个
这个运算符是应用在容器型数据的元素判断的
判断数据是否在某个容器型数据中
整数、小数、布尔值、空值 每个数据都是独立的个体，这些都不是容器型数据
10
3.14
True
None
字符串是一个容器型类型，元素是字符【长度为1的字符串称为字符， 比如’a’, ‘0’, ’ '】
字符串就是由0个或者多个字符拼接起来的
0个字符的情况下 称为空字符串 ‘’ [是个空箱子]
成员运算符 in
格式: 数据 in 容器型数据
逻辑： 把数据当做一个整体，判断数据是否包含在容器中
格式： 数据 not in 容器型数据
判断数据是否不在容器中
'hello'
res = 'h' in s
print(res)
res = 'hl' in s
print(res)
res = 'hl' not in s
print(res)
14.流程控制语句
流程控制语句： 通过代码逻辑控制程序的执行流程
程序的流程有3种情况
1. 顺序结构语句， 特点：代码会从第一行到最后一行逐行运行【每条语句都会执行到】
2. 分支结构语句， 特点：按照逻辑条件满足与否，决定逻辑操作是否运行 【比如游戏星星数达到3颗才能进入下一关】
3. 循环结构语句， 特点：没有满足某个条件，就需要一直执行相应的逻辑操作
15.分支结构语句
分支结构语句有三种形态：
1. 单分支结构
在顺序流程过程中 检测数据是否达到某个状态点 如果达到这个状态点按照状态点的流程进行操作
如果没有达到的话 按照原流程进行操作
例如：
学校 — 回家
如果时间比较早 在6点之前到家 先去洗车 —再回家
语法：
if 条件:
满足条件执行的操作
解读： 如果条件满足 就执行相应的操作
注意： 相应的操作的执行 要看条件是否满足 体现这种关系使用的是代码块包含的结构
Python中如何体现代码块包含： 使用冒号+四个空格的缩进 【一般编辑器会默认一个tab键 就是四个空格】
#print('从学校出发')
# 需要记录当前的时间点
#hour = 17
# 要求 时间在18点之前 进行洗车的操作
#if hour < 18:
# print('洗车店洗车')
#print('回到家中')
-
双分支结构
相当于十字路口，是向左还是向右
语法：
if 条件:
满足条件执行的操作
else:
不满足条件执行的操作
解读：如果条件满足 做事情A 否则做事情B
# 做一个成绩判定器： 判断输入的成绩是及格还是不及格
# score = float(input('成绩：'))
# if score >= 60:
# print('及格')
# else:
# print('不及格')
- 多分支结构
出现了3种及其以上的选择
语法：
if 条件1:
操作1
elif 条件2:
操作2
…
elif 条件n:
操作n
else:
以上条件都不满足 执行的操作
这个else语句可以省略
elif ==== else if
如果与否则是对立面， 执行了如果 就不会执行否则
# # 给成绩分等级
# """
# >=90 A
# >=80 B
# >=70 C
# >=60 D
# <60 E
# """
# score = float(input('请输入成绩：'))
# if score >= 90:
# print('A')
# elif score >= 80: # score 肯定是小于90
# print('B')
# elif score >= 70: # score < 80
# print('C')
# elif score >= 60:
# print('D')
# else:
#print('E')
练习
1.超市活动，购买金额不足180，支付原金额，在180以上，打8折，金额在300以上打6折，录入购买金额，计算出支付金额
rmb = float(input('请输入购买金额：'))
if rmb > 300:
print(rmb * 0.6)
elif rmb > 180:
print(rmb * 0.8)
else:
print(rmb)
2.做一个数据比较器：根据输入的两个数 获取其中的最大值
a = float(input('请输入第一个数：'))
b = float(input('请输入第二个数：'))
if a > b:
print('第一个数大',a)
else:
print('第二个数大',b)
3.录入身高（单位是m）、体重（单位是kg），计算一个人的bmi值，判定身材情况
bmi小于18.5偏瘦
bmi在18.5到24.9之间正常
bmi大于24.9偏胖
height = float(input('请输入您的身高：(m)'))
weight = float(input('请输入您的体重：(kg)'))
bmi = weight / (height ** 2)
if bmi > 24.9:
print('身材偏胖')
elif bmi > 18.5:
print('身材正常')
else:
print('身材偏瘦')
4.模拟用户登录：录入用户名和密码，如果用户名为admin，密码为123456abc，则提示登录成功，否则提示登录失败
y = input('请输入你的用户名：')
m = float(input('请输入你的密码：'))
if y == 'admin' and m == '123456abc':
print("登录成功")
else:
print('登陆失败')
需求：
计算加油的金额
因为油号不同 价格不同 优惠也是不一样
92 单价8元/L 添加30L及其以上 打8折 否则按照原价处理
95 单价8.8元/L 添加25L及其以上 打8折 否则按照原价处理
98 单价9.5元/L 添加20L及其以上 打9折 25L及其以上8.5折 30L及其以上8折 否则按照原价处理
oil_num = int(input('请输入油号：'))
litre = float(input('加油的升数(L): '))
# 判断油号
if oil_num == 92:
if litre >= 30:
payment = 8 * litre * 0.8
else:
payment = 8 * litre
elif oil_num == 95:
# pass # 代码块必须有内容 当前没有写逻辑可以使用pass占位
if litre >= 25:
payment = 8.8 * litre * 0.8
else:
payment = 8.8 * litre
else:
# pass # 空白代码块的占位符
# if litre >= 30:
# payment = 9.5 * litre * 0.8
# elif litre >= 25:
# payment = 9.5 * litre * 0.85
# elif litre >= 20:
# payment = 9.5 * litre * 0.9
# else:
# payment = 9.5 * litre
if litre < 20:
payment = 9.5 * litre
elif litre < 25:
payment = 9.5 * litre * 0.9
elif litre < 30:
payment = 9.5 * litre * 0.85
else:
payment = 9.5 * litre * 0.8
print(oil_num, '号油添加', litre, '升的油价是', payment)
循环结构语句
循环：周而复始 重复做同一件事
一直重复操作，没有终止，在编程里称为死循环 【在程序中是要避免的 — 程序卡死】
常见的循环结束状态：
-
循环满N次 比如：体育测试：围着操场跑满5圈
-
循环达到某个条件 比如： 体育测试：跑满1000米
Python提供的循环操作，有两个结构：
-
for-in循环，适合于循环满N次的情景
本质上是在遍历[逐个获取]容器型数据，在遍历获取元素的过程中进行相应的逻辑判断
容器中有几个元素，这个循环就执行几次
语法：
for 变量名 in 容器型数据:
循环体
解读：
in 可以理解成进入容器中拿元素数据
变量名 in进入拿到数据之后 赋值给变量名
循环结束点： in到容器中 没有数据可拿的时候 循环结束
s = 'hello' # 逐个将字符串s中的元素取出来 for ch in s: print(ch) # print('跑了一圈')
# 获取字符串中小于l的字符
# 逻辑 获取到元素之后 要对其进行判断 判断是否是小于l的
for ch1 in s:
if ch1 < 'l':
print(ch1)
假如跑100圈 使用循环的时候 可以使用range快速生成一个等差数列
range(stop)
设定一个结束值， 等差数列是从0开始 步长为1 到stop[不包含]结束
range(10) ====> 0 1 2 3 4 5 6 7 8 9
range(start, stop)
设定了起始值和结束值 等差数列是从start[包含]开始 步长为1 到stop[不包含]结束
range(1, 11) ====> 1 2 3 4 5 6 7 8 9 10
range(start, stop, step)
step步长
正数 --- 生成的是递增的等差数列 要求 起始值<结束值
负数 --- 生成的是递减的等差数列 要求 起始值>结束值
stop结束位置[不包含]
start开始位置[包含]
range(1, 10, 2) ====> 1 3 5 7 9
range(10, 0, -2) ====> 10 8 6 4 2
range(100) ===> 0-99
for ele in range(1, 101):
print('跑第', ele, '圈')
for ele1 in range(0, 100, 5):
print(ele1)
- while循环
语法：
while 条件判断:
循环体代码块
解读：
只要条件成立，程序就一直在此循环，直到循环条件不成立
输出1-10之间的数据
for循环的思想： 需要一个容器，容器中存放在1-10
for i in range(1, 11): # 容器的起始值是1 步长是1 结束位置是11[不包含]
print(i)
print('================')
while循环 思想:
-
重复做的操作是什么 ==== 打印数据 每次打印的都是1个
-
做这件事情的条件 ===== 只要打印的数据没有到10 就得一直打印
根据这两件事情，需要哪些数据支持
打印数据 每打印1次 数据要在原来的基础上+1
也就是说要打印的数据是变化的 就得设置标记名给其进行标记 【定义一个变量 记录打印的数据值】
num = 1
# 循环的操作
while num <= 10:
print(num)
# 数据还在原来的基础上+1
num += 1
print('循环结束时 num的值', num)
# 1-10中的偶数 使用while打印1-10中的偶数
# 定义一个数据的起始值
m = 1
# 循环 数据进行递增
while m <= 10:
if m % 2 == 0:
print(m)
m += 1
"""
1. 使用while循环 完成 1+2+3+...+100
"""
# 使用for来完成的时候
total = 0 # 记录和的
for i in range(1, 101):
total += i
print(total)
m = 1
total1 = 0
while m < 101:
total1 += m
m += 1
print(total1)
1.求 1-2+3-4+5-6+…-98+99-100
2.求1-100中能被3整除且个位数为5的数据的个数
# range(1, 101)
k = 1
total2 = 0 # 接受和
while k < 101:
if k % 2 == 0:
total2 -= k
else:
total2 += k
k += 1
print(total2)
# range(1, 101)
p = 1
count = 0 # 计数器
while p < 101:
# 判断这个数据是否满足要求
if p % 3 == 0 and p % 10 == 5:
count += 1
p += 1
print(count)
循环结束的场景：
-
明确循环次数 — for-in循环 遍历容器，容器中有几个数据 循环就执行几次
-
明确结束状态的 — while循环
while 循环条件:
满足条件就执行
经过上面代码的演示 while也可以适用于明确循环次数的，只不过使用while书写起来麻烦了一些， 所以建议使用for-in循环
案例: 有1023个桃子， 猴子每天吃桃子剩余个数的一半多1个，问多少天能吃完
来操作的时候 循环次数不明确 就使用while循环
1. 重复做的事情是什么 桃子个数/2 + 1
2. 结束做这件事情的状态[只要没有达到这个状态就不会结束] 桃子个数为0 就不用吃 【只要桃子个数不为0 就得一直吃】
需要准备的数据：
1. 需要一个变量名 接受桃子的个数 起始值是1023
2. 计数器 记录吃的天数
peach_count = 1023 # 桃子的个数
day = 0 # 计数器【天数】
# 开启循环
while peach_count > 0:
# 吃完 记录的剩余的桃子的个数
peach_count = peach_count - (peach_count//2 + 1)
# 计数器+1
day += 1
# 循环结束的时候 桃子被吃完
print('1023个桃子猴子需要', day, '天吃完')
1. 录入一个大于1的整数
如果这个数值是偶数 将数据整除2后-1
如果这个数是奇数 将这个数据-1 再整除2
重复操作 问多少次之后才能将数据设置为0
num = int(input('请输入一个大于1整数：'))
# num1 = num # 记录原始的数据
# count1 = 0
# while num > 0:
# # 判断奇偶性
# if num % 2 == 0:
# num = num // 2 - 1
# else:
# num = (num - 1) // 2
# # 计数器+1
# count1 += 1
# print(num1, '经过运算', count1, '次之后置为0')
一张纸的厚度是0.8mm，假设纸足够长，问对折多少次可以将纸的高度达到1000米
重复的事情 对折 厚度*2
做这件事情的目的 达到1000000mm
"""
"""
准备数据
1. 记录纸的高度 起始高度是0.8mm
2. 计数器 记录次数
paper_height = 0.8
count2 = 0
while paper_height < 1000 * 1000:
# 重复的操作
paper_height *= 2
# 计数器+1
count2 += 1
print('0.8mm的纸经过', count2, '次对折后达到千米')
简单的思路
初学while循环的
可以while True的思想 【死循环】
分析出来结束点 判断是否达到结束点 到了的话 结束循环break
paper_height1 = 0.8
count3 = 0
while True:
# 对折
paper_height1 *= 2
# 计数
count3 += 1
# 判断 纸的高度达到千米
if paper_height1 >= 1000 * 1000:
break
数字炸弹：
规则： 有一个出题人 随便在1-100之间设定一个数据，然后其他人猜
猜小了、猜大了 出题人提示新的范围
猜中了 就一顿暴揍
69
你： 85 出题人 1-85
他： 70 出题人 1-70
她： 55 出题人 55-70
我: 69 挨揍了
"""
Python提供了一个工具包 random 就是来提供随机操作
import random
print(random.randint(1, 101)) # 在给定的a,b之间随机选择一个整数
"""
完成这个游戏 是需要循环的
循环次数是不明确的，使用while循环
循环结束状态： 猜中了
"""
"""
数据准备
1. 准备一个1-100中的随机数
2. 猜数的范围的起始值和结束值
"""
random_num = random.randint(1, 100) # 唯一一个包含结束位置的
# 猜数的范围
start = 1
stop = 100
# 开始猜
while True:
# 猜的动作是重复的 所以放在循环中
# 字符串数据可以使用+将数据拼接在一起 【只能是字符串与字符串拼接】
# 把数据转化成字符串的操作 str(数据) int() float()
guess = int(input('请输入' + str(start) + '-' + str(stop) + '之间的数据，进行竞猜：'))
# 将输入的数据与随机的数据进行对比
if guess > random_num:
# pass
print('猜大了')
stop = guess
elif guess < random_num:
print('猜小了')
start = guess
else:
print('猜中了 暴揍中.....')
break
print('游戏结束')
关键词break和continue
搜索关键字
import keyword
print(keyword.kwlist)
关键字
['False', 'None', 'True', 'and', 'as', 'assert', 'async',
'await', 'break', 'class', 'continue', 'def', 'del',
'elif', 'else', 'except', 'finally', 'for', 'from', 'global',
'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or',
'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
break和continue
都是应用在循环结构语句中，只能对循环起作用
break的作用是中断它所在的循环 【退出循环】
continue的作用[循环一次一次执行的]是， 结束当前次[循环体中后面的代码不再执行]，
跳到循环判断的位置，再决定是否开启下一次 [判断成立的时候 开启下一次]
演示continue的作用
# 打印1-10中的偶数
for i in range(1, 11):
# 判断这个数据是否是偶数 是的话 执行打印操作
if i % 2 == 0:
print(i)
# 换一种思路： 判断是否为奇数 如果是奇数 跳过这一次循环 继续拿下一个数
for j in range(1, 11):
if j % 2 == 1:
continue
print(j)
# 利用continue写 数7游戏
# 1-100中 遇到7 或者 7的倍数 跳过 否则是输出
"""
1. 使用range 生成1-100的数列
2. 遍历逐个获取数据
3. 判断 获取的数据 是否是7的倍数 或者 带7
带有7 有两种情况
个位 %10 == 7
十位 //10%10 == 7
7的倍数
%7 == 0
"""
for m in range(1, 101):
if m % 10 == 7 or m // 10 % 10 == 7 or m % 7 == 0:
continue
print(m)
break 是结束所在的循环
一般循环结束是 循环条件不成立或者容器中没有数据可拿时 结束循环
for n in range(1, 11):
print(n)
if n == 5:
break
需求：
# 获取 1-100中 3的倍数且个位数为5 当获取到第二个的时候 结束获取
"""
思路：
获取的时候还需要计数 当计数器为2的时候 结束循环
count = 0 # 计数器
for k in range(1, 101):
if k % 3 == 0 and k % 10 == 5:
count += 1 # 计算器+1
print(k)
# 判断计算器是否为2 结束
if count == 2:
break
扫一扫
13万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
