Python语法
1.print
print在Python中提供打印输出的功能,是将Python中的数据输出到控制台。
print()
2.注释
含义:对代码进行解释和说明,目的就是让别人和自己能够清晰的看懂代码的含义,提高代码的可读性。
注释是不会被计算机识别的 一般写注释的时候写在代码的上方或者右方。
注释另外的作用:修改代码的时候,可能代码需要调试,有部分代码用不到,没有必要删除,可以给注释掉。
单行注释 : #空格
快捷键 ctrl+/
去掉注释也一样ctrl+/
多行注释 : 三对引号[英文格式下] 单引号也可以双引号也可以。
'''
多行注释
'''
3.行和缩进
编程语言:由多条语句按照相应的逻辑实现代码,编写相应的程序的。
语句都有相应的结束标记,一般编程语言语句的结束标记是分号;。
在Python中,建议语句的结束不写分号,也可以写【但是会报警告】。
建议:一行一条语句【如果一行中有多条语句,语句结束必须加分号—这种方式不建议】
print('hello');print('world')
缩进:在代码前面不要随意加空格或者tab键。
4.标识符与关键字
标识某个实体的符号,使用这个符号可以代替实体进行相应的运算
在编程语言中,标识符一般就是给变量、项目名称、文件名称、函数名、类名等等自定义名称,建立起名称和使用的数据之间的关系。
自定义名称要遵循一定的规则:
-
标识符是由数字、字母、下划线组成。
-
标识符名称不能以数字开头。
-
不能使用关键字与保留字。
-
关键字:编程语言中具有特殊含义的单词
Python环境中自带了很多工具包,每个工具包都有对应的作用。比如:time–包含时间相关的操作。
要想使用工具包,需要导包。
语法:
import 工具包名
使用工具包下面的内容:
工具包名.内容名
# 打印当前时间,需要获取time工具包 import time # 当前时间的操作 print(time.localtime())
-
保留字:编程语言中已经使用的名称,不建议再使用【因为再使用的话,会覆盖掉原本的含义】
-
# 1.标识符是由数字、字母、下划线组成。
# 打印一个数据10
print(10) # 10
# 定义一个标识符,给它赋值为10
num = 10
print(num) # 10
# 打印10+20的和
print(10+20) # 30
print(num+20) # 30
# 定义的时候不能包含其他符号,否则会报错
num@ = 10 # SyntaxError: invalid syntax
# 2.标识符名称不能以数字开头。
1_num = 10 # SyntaxError: invalid decimal literal
# 3.不能使用关键字与保留字。
# 3.1 不能使用关键字
"""
# 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再次赋值
"""
# 3.2 不建议使用保留字
"""
# 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) # 30
数据类型:把相同特征的数据进行归类,形成一类数据,这个称为数据类型
Python中的数据类型
整数类型(整型int) 10 20 30 40
小数类型(浮点型float) 3.14 5.17
文本数据(字符串str)字符串数据是需要使用引号包含的[不区分单双引号] ‘hello’ “Nice” ‘’ [空字符串]
逻辑结果(布尔类型bool) 逻辑结果只有两种 成立与不成立,布尔值只有两个 True 和 False
空类型(NoneType) 空值(None) 代表什么都没有
空字符串和None不是一个东西 【空字符串理解成是空箱子 None连箱子都没有】
获取数据的类型
type变量名
类和对象
类:对具有相同属性和特征的数据的一个抽象描述【泛泛的称呼】
比如:整数类型
对象;该类下实际存在的实体
比如:10
# 定义一个 变量,记录人的名称,[起名字尽量见名知意]
name = '喜唐'
print(name) # 喜唐
print(type(name)) # <class 'str'> class代表的就是类型
# 定义一个变量 记录一个人的年龄
age = 30
print(age) # 30
print(type(age)) # <class 'int'> # 30
# 定义一个变量 记录性别
gender = '女'
print(gender) # 女
print(type(gender)) # <class 'str'>
# 记录一个状态值
flag = True
print(flag) # True
print(type(flag)) # <class 'bool'>
# 空值
result = None
print(result) # None
print(type(result)) # <class 'NoneType'>
6.Python的输出
按住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(要写\r\n,\r\n会自动解读为\n,但\r不会)
t—\t 制表符 就是tab键
u— 这个识别成unicode编码符号
file=sys.stdout
:print数据输出的目的地,默认就是控制台下# 更新内容的输出目的地 把内容输出到文件中 1. 需要建立程序和文件之间的联系通道 有一个操作 open(文件路径, 操作文件的模式, 文件的编码形式):以指定模式将文件与程序建立联系 文件路径有两种格式: a. 绝对路径 windows系统 从盘符开始 到 具体的文件的路径 就是绝对路径 例如:D:\pythonproject1\静夜思.txt Mac系统 从根路径 /开始到具体文件结束 例如:/Users/各班代课/Python2304/day02_变量及其运算符/代码/静夜 思.txt b. 相对路径[建议] 需要文件配置在项目路径下 相对路径是有参照物的:当前正在编辑的文件 相对路径中有两个特殊的符号: . --- 当前操作的文件所在的文件夹 pythonproject1 .. --- 当前操作的文件所在的文件夹上一级 D 操作文件的模式 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 2. 通过通道把数据传递到文件中 """ # 绝对路径示例: handle=open('D:\喜唐的笔记\静夜思.txt','w',encoding='UTF-8') print('床前明月光,疑是地上霜。',file=handle,flush=True) # 相对路径示例: handle1=open('.\静夜思.txt','w',encoding='UTF-8') print('窗前明月光,疑是地上霜。',file=handle1) handle2=open('..\李白.txt','w',encoding='UFT-8') print('静夜思',file=handle2)
flush=False
:是否快速的将通道中的数据输出到文件中
print(1,2,3,4) # 1 2 3 4
# 自己设置多个数据之间的分隔符
# 如果直接使用逗号分隔 代表的输出的多个数据 为了区分是数据还是分隔符,给分隔符赋值的时候 sep=指定的分隔符
print(1,2,3,4,sep='+') # 1+2+3+4
# 演示转义符
print('and') # and
print('a\nd')
'''
a
d
'''
print('1\r\n2')
'''
1
2
'''
# 输出内容的时候 此时不需要换行 可以修改end的值
print('hello',end='\t')
print('world') # hello world
# \u 每一个unicode编码值 都对应着一个文字
print('\u4e00') # 一
# 有些情况下,不需要转义符进行转义,保持转义符的本意.比如:路径中 C:\users\...
# 方式1: 对转义符再次转义 \\ 保持\本身的含义
print('\\u') # \u
# 方式2: 使用r修饰字符串 字符串中每个符号都保持数据本身的含义
print(r'\u') # \u
7.Python中的输入
input
让用户在控制台输入数据,传递到程序中。
格式:input(提示语)
----会让程序暂停
如何让程序继续:在控制台上输入数据,结束输入的标记是回车,输入数据回车之后,就把控制台输入的数据传递到程序中,想要获取这个数据,需要接收。
注意:输入的数据是变化的【也就是变量】,想要获取变量的数据,需要给变量的值一个标记名【变量名】。
# 将用户在控制台输入的数据 赋值给name这个变量名
name = input('请输入你的姓名:')
print('打印name的值',name)
# 不管录入的数据格式是什么样的,在程序中变量的值永远都是字符串类型的。
value = input('请输入一个内容:')
print(type(value)) # <class 'str'>
8.类型转换
# 用户输入两个数,求和
num1 = input('请输入一个数字:') # 11
num2 = input('请输入另一个数字;') # 12
print('这两个数字的和',num1+num2) # 这两个数字的和 1112
# 这个结果的原因是:input 不管用户输入的是什么格式的数据 在程序中拿到的都是字符串类型的
字符串数据之间进行相加 完成的是拼接的动作
print('a'+'b') # ab
# 想要完成这个求和这个目的,num1和num2接收到数据类型得是整数类型的才可以,但是现在是字符串类型的,想让字符串格式的数值变成整数类型,就需要进行类型转换
操作语法【这个格式是固定的】
int(数据/变量名)
# 类型转换示例:
value = '1990'
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('11a') # ValueError: invalid literal for int() with base 10: '11a' 不合法的数据
# 改进:转换为整型,并赋值给num1和num2
num1 = int(input('请输入一个数字:')) # 11
num2 = int(input('请输入另一个数字;')) # 12
print('这两个数字的和',num1+num2) # 这两个数字的和 23
# 把字符串数据转化成浮点型
float(数据/变量名)
注意:转换的时候要满足数字的形态 【可以是整数 也可以小数】
data = '3.14'
res = float(data)
print(type(res)) # <class 'float'>
data = '11'
res = float(data)
print(type(res)) # <class 'float'>
9.运算符
算术运算符
一元运算符:正负号 +11 -11
二元运算符
加法+
减法-
乘法*
除法/ 和 //
取余%
幂数**
优先级别:幂数** > 负号 > 乘、除、取整、取余 > 加、减
提高运算符的优先级别 使用()包含 不管多少层都是()
复合赋值运算符
简单的赋值运算符
=
:a=10
[将等号右边的数据赋值给左边的变量名]复合赋值运算符:在进行赋值的时候,先操作了算术运算
+=
、-=
、*=
、/=
、//=
、%=
、**=
比较运算符: 比较两个数据,判断大小
>
判断前者是否大于后者
>=
判断前者是否大于或者等于后者
<
判断前者是否小于后者
<=
判断前者是否小于或者等于后者
==
判断前者是否等于后者
!=
判断前者是否不等于后者比较运算符运行结果是布尔类型的,结果只有两个值True和False
算数运算符优先级别高于比较运算符
逻辑运算符: 是来操作逻辑关系的
逻辑与
and
连接的条件必须同时成立【也就是条件之间是并且的关系】,结果才是成立的
逻辑或
or
连接的条件成立其中一个即可【也就是条件之间的关系是或者关系】
逻辑非
not
对条件结果进行取反操作【真变假,假变真】
比较运算符的优先级高于逻辑运算符
逻辑运算符中优先级别: not > and > or
成员运算符
in
成员: 众多中的一个,这个运算符是应用在容器型数据的元素判断的,判断数据是否在某个容器型数据中。
整数、小数、布尔值、空值 每个数据都是独立的个体,这些都不是容器型数据
字符串是一个容器型类型,元素是字符【长度为1的字符串称为字符, 比如’a’, ‘0’, ’ '】
字符串就是由0个或者多个字符拼接起来的
0个字符的情况下 称为空字符串 ‘’ [是个空箱子]格式: 数据 in 容器型数据
逻辑:把数据当做一个整体,判断数据是否包含在容器中格式: 数据 not in 容器型数据
判断数据是否不在容器中
# 算术运算符
a=9
b=2
print('加法',a+b)
print('减法',a-b)
print('乘法',a*b)
print('除法',a/b) # 结果是浮点型的
print('向下整除',a//b) # 有一个向下取整的操作: 结果是<=商 且最接近于商的整数
print('取余',a%b) # 两数相除 获取余数
print('幂数',a**b)
'''
加法 11
减法 7
乘法 18
除法 4.5
向下整除 4
取余 1
幂数 81
'''
# 开方
# 对8开3次方,就是8的三分之一次方
print(8**(1/3)) # 2.0
# 复合赋值运算符
num = 125
num += 5 # num = num + 5 = 130
print(num) # 130
num //= 6 # num = num // 6 = 21
print(num) # 21
num %= 10 # num = num % 10 = 1
print(num) # 1
# 比较运算符
a = 17
b = 9
res = a + b > b * 2
print(res) # True
res = a - b <= a % b
print(res) # True
# 判断一个数的个位数是否为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)
# 逻辑运算符
# 逻辑与 and
'''
大学中评奖学金 平均成绩和绩点
平均成绩在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
print(res)
# 判断输入的月份是否是第三季度的 7月8月9月
'''
month = int(input('月份:'))
res = month == 7 or month == 8 or month == 9
print('输入的月份是否是第三季度的结果:', res)
'''
"""
练习:
1. 判断输入的数据是否是3或者5的倍数
2. 判断输入的月份的天数是否是30天
"""
# 1. 判断输入的数据是否是3或者5的倍数
num = int(input('请输入整数:'))
res = num % 3 == 0 or num % 5 == 0
print(res)
# 2.判断输入的月份的天数是否是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 !=0 不等于0就是对等于0进行取反
# num % 2 ==1
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之间
"""
# 1. 判断一个数是否不为正数
num = int(input('请输入整数:'))
res = not(num > 0)
print(res)
# 2.输入一个月份 判断其是否在 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)
# 成员运算符
s = 'hello'
res = 'h' in s
print(res)
res = 'hl' in s
print(res)
res = 'hl' not in s
print(res)
10.分支结构语句
分支结构语句有三种形态:
1.单分支结构
在顺序流程过程中,检测数据是否达到某个状态点,如果达到这个状态点按照状态点的流程进行操作。如果没有达到的话,按照原流程进行操作。
例如:
学校 — 回家
如果时间比较早 在6点之前到家 先去洗车 —再回家
语法:
if 条件:
满足条件执行的操作
解读: 如果条件满足 就执行相应的操作
注意: 相应的操作的执行 要看条件是否满足 体现这种关系使用的是代码块包含的结构
Python中如何体现代码块包含: 使用冒号+四个空格的缩进 【一般编辑器会默认一个tab键 就是四个空格】
print('从学校出发')
# 需要记录当前的时间点
hour = 17
# 要求时间在18点之前,进行洗车的操作
if hour < 18:
print('洗车店')
print('回家')
2.双分支结构
相当于十字路口,是向左还是向右
语法:
if 条件:
满足条件执行的操作
else:
不满足条件执行的操作
解读:
如果条件满足,做事情A ,否则做事情B
# 做一个成绩判定器: 判断输入的成绩是及格还是不及格
score = float(input('成绩:'))
if score >= 60:
print('合格')
else:
print('不合格')
3.多分支结构
出现了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:
print('B')
elif score >= 70:
print('C')
elif score >= 60:
print('D')
else:
print('E')
"""
练习:
1. 超市活动,购买金额不足180,支付原金额,在180以上 打8折, 金额在300以上打6折
录入购买金额,计算出支付金额
2. 做一个数据比较器:根据输入的两个数 获取其中的最大值
3. 录入身高(单位是m)、体重(单位是kg),计算一个人的BMI值,判定身材状况
BMI小于 18.5 偏瘦
BMI在18.5到24.9之间正常
BMI大于24.9 偏胖
4. 模拟用户登录:录入用户名与密码,如果用户名为admin 密码为123456abc 则提示登录成功 否则提示登录失败
"""
# 1. 超市活动,购买金额不足180,支付原金额,在180以上 打8折, 金额在300以上打6折
# 录入购买金额,计算出支付金额
money = float(input('请输入购买金额:'))
if money > 300:
payment = money * 0.6
elif money > 180:
payment = money * 0.8
else:
payment = money
print('支付金额为', payment)
# 2. 做一个数据比较器:根据输入的两个数 获取其中的最大值
num1 = float(input("a:"))
num2 = float(input('b:'))
if num1 > num2:
print('a比较大,a的值为', num1)
else:
print('b比较大,b的值为', num2)
# 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 < 18.5:
print('偏瘦')
elif bmi <= 24.9:
print('正常')
else:
print('偏胖')
# 4. 模拟用户登录:录入用户名与密码,如果用户名为admin 密码为123456abc 则提示登录成功 否则提示登录失败
username = input('用户名:')
password = input('密码:')
if username == 'admin' and password == '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('加油的升数:'))
# 判断油号
if oil_num == 92:
# pass
if litre >= 30:
payment = 8 * litre * 0.8
else:
payment = 8 * litre
elif oil_num == 95:
# pass
if litre >= 25:
payment = 8.8 * litre * 0.8
else:
payment = 8.8 * litre
else:
# 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('加油的金额为:',payment)
11.循环结构语句
循环:周而复始 重复做同一件事
一直重复操作,没有终止,在编程里称为死循环 【在程序中是要避免的 — 程序卡死】
常见的循环结束状态:
- 循环满N次 比如:体育测试:围着操场跑满5圈
- 循环达到某个条件 比如: 体育测试:跑满1000米
Python提供的循环操作,有两个结构:
-
for-in循环,适合于循环满N次的情景
本质上是在遍历[逐个获取]容器型数据,在遍历获取元素的过程中进行相应的逻辑判断,容器中有几个元素,这个循环就执行几次。
语法:
for 变量名 in 容器型数据:
循环体
解读:
in 可以理解成进入容器中拿元素数据
变量名 in进入拿到数据之后 赋值给变量名
循环结束点: in到容器中 没有数据可拿的时候 循环结束# for-in循环 s = "hello" # 逐个将字符串s中的元素取出来 for c in s: print(c) # print('跑了一圈') # 获取字符串中小于l的字符 # 逻辑 获取到元素之后 要对其进行判断 判断是否是小于l的 for d in s: if d < 'l': print(d) # 假如跑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 x in range(1,101): print('跑第',x,'圈') for y in range(0,100,4): print(y)
for循环和range结合例题
# 1. 求1+2+3+...+99+100 """ 产生一个容器 容器放着1-100的数据 遍历容器取值 ,取出来一个累加起来 注意: 和随着取值 会发生变化的 【定义一个变量 用来接受累加和的值】 """ total = 0 # 放在循环的外面 避免每次循环重置 for i in range(1,101): total += i # total = total + i """ 第一次 in 的时候 i = 1 total += i ===> total = total + i = 1 第二次 in 的时候 i = 2 total += i ===> total = total + i = 1 + 2 = 3 第三次 in 的时候 i = 3 total += i ===> total = total + i = 3 + 3 = 6 """ print(total) # 求 1-2+3-4+5-6+...-98+99-100 """ 观察: 发现奇数是相加的 偶数是相减的 获取数据的是加还是减 需要判断拿到的数据是奇数还是偶数 """ total = 0 # 定义一个变量 记录累加和 for i in range(1,101): if i % 2 == 1: total += i else: total -= i # 当循环结束的时候 把所有的数据都参与运算了 # 写的代码与for对齐 代表已经出了循环 如果还是缩进的操作 代表还在循环之中 print(total) # 另一种求幂数的方法 total2 = 0 # 定义一个变量 记录累加和 for k in range(1, 101): # 不想使用分支判断 可以利用对-1求幂数 (-1)的奇数次幂结果是-1 (-1)的偶数次幂结果是1 value = (-1) ** (k - 1) * k total2 += value print(total2) # 求1**2 + 2**2 + 3**2 +......+ 10**2 的结果 total = 0 for a in range(1,11): value = a ** 2 total += value print(total) # 求1-100中能被3整除且个位数为5的数据的个数 # 需要一个变量作为计数器 count = 0 for b in range(1,101): if b % 3 == 0 and b % 10 == 5: count += 1 print(count)
关键字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的作用【循环一次一次执行的】是,结束当前次【循环体中后面的代码不再执行】,跳到循环判断的位置,再决定是否开启下一次【判断成立的时候开启下一次】
# 演示continue的作用 # 打印1-10中的偶数 ''' for i in range(1,11): # 判断这个数据是否是偶数 if i % 2 == 0: print(i) ''' # 换一种思路,判断这个数据是否是奇数,是奇数,跳过这次循环,继续下一次 ''' for i in range(1,11): if i % 2 == 1: continue print(i) ''' # 练习:利用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的作用 """ 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
-
while循环
语法:
while 条件判断:
循环体代码块
解读:
只要条件成立,程序就一直在此循环,直到循环条件不成立# 输出1-10之间的数据 # for循环的思想: 需要一个容器,容器中存放在1-10 for i in range(1, 11): # 容器的起始值是1 步长是1 结束位置是11[不包含] print(i) print('================') # while循环 思想: """ 1. 重复做的操作是什么 ==== 打印数据 每次打印的都是1个 2. 做这件事情的条件 ===== 只要打印的数据没有到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 # 使用while循环 完成 1+2+3+...+100 # 1.使用for来完成的时候 total = 0 # 记录和的 for i in range(1, 101): total += i print(total) # 2.使用while来完成的时候 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的数据的个数 ''' # 练习1:求 1-2+3-4+5-6+...-98+99-100 k = 1 total2 = 0 # 接受和 while k < 101: if k % 2 == 0: total2 -= k else: total2 += k k += 1 print(total2) # 2.求1-100中能被3整除且个位数为5的数据的个数 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
2. 一张纸的厚度是0.8mm,假设纸足够长,问对折多少次可以将纸的高度达到1000米
"""
# 练习1
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')
# 练习2
'''
1m = 1000mm
重复的事情 对折 厚度*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 True
思想【死循环】
分析出来结束点 判断是否达到结束点 到了的话 结束循环break
# 一张纸的厚度是0.8mm,假设纸足够长,问对折多少次可以将纸的高度达到1000米
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('游戏结束')
12.列表
可变的有序型容器。
可变:数据的值可以发生变化,可以修改/增加/删除
有序: 容器存储放数据的时候,容器中有多少个数据,会给数据设置编号,编号是从0开始[左边视为开始],可以通过编号定位获取这个位置的数据,也可以修改。这个编号被称为下标/索引
数据在进行定义的时候,数据标识是[], 在[]中定义多个数据,数据之间使用逗号分隔
例如:比如[19, 24, 26, 22],数据中的编号0 1 2 3
1.获取列表中元素的个数
len(数据/变量名)
print(len(airtemp_list)) # 7
2.下标(索引)
数据的一个编号,可以通过这个编号获取数据,也可以修改这个位置的数据,一般的编程语言中 编号就是从左向右 ,从0开始 加1递增。
Python对于下标有两种表达形式:
获取数据的时候可以使用正向索引 也可以使用负向索引
正向索引 — 从左向右
0,1,2,3,4,5,6,…, len(数据)-1负向索引 — 从右向左
-1,-2,-3,-4,-5, … -len(数据)
格式:
列表数据[下标] ====> 代表的是获取这个位置的数据
列表数据[下标] = 数据值 ====> 修改这个位置的数据
注意:下标不能超过编号的界限,否则报错
'''
7点 9点 11点 1点 2点 4点 6点
0 1 2 3 4 5 6 正向索引
-7 -6 -5 -4 -3 -2 -1 负向索引
'''
airtemp_list = [17, 19, 22, 26, 30, 28, 26]
# 获取9点 【第二个位置的数据】
print(airtemp_list[1]) # 正向索引获取的
# 使用负向索引
print(airtemp_list[-len(airtemp_list) + 1])
# 获取左边的使用正向 获取右边的使用负向
# airtemp_list.pop() # 把最后一个删除了 [17, 19, 22, 26, 30, 28]
# airtemp_list[6] # IndexError: list index out of range
# 获取倒数第一个位置
print(airtemp_list[len(airtemp_list) - 1]) # 正向索引
print(airtemp_list[-1]) # 负向索引
# 修改这个位置的数据
airtemp_list[-3] = 33
print(airtemp_list) # [17, 19, 22, 26, 33, 28, 26]
# 列表是可变的,所有的操作都影响的数据列表本身
# 操作完查看数据变化 直接打印列表本身即可
3.切片(slice):提取子序列
本质上根据下标定位到容器相应的位置, 从指定的起始位置按照步长取数据元素去
格式:列表数据[起始下标:结束下标:步长]
步长为正数:代表的是正向切片 【根据位置从左向右按照步长取值】
注意:起始下标定位的位置 要在 结束下标定位的位置 的左边步长为负数,代表的是负向切片 【根据位置从右向左按照步长取值】
注意:起始下标定位的位置 要在 结束下标定位的位置 的右边解读:
:步长可以省略, 步长默认为1
列表数据[起始下标:结束下标]
代表从起始下标对应的元素开始 逐个取值 到结束下标对应的位置[结束下标不包含]起始下标可以省略
看步长为正还是为负
步长为正 代表从最左边开始
步长为负 代表从最右边开始结束下标也可以省略
看步长为正还是为负
步长为正 代表到最右边结束
步长为负 代表到最左边结束
scores = [76, 28, 39, 45, 57, 82, 91, 68] # 8个数据
# 0 1 2 3 4 5 6 7
sub_scores = scores[1:7:1]
print(sub_scores)
# 等价于
sub_scores = scores[1:7]
print(sub_scores)
# 等价于 只是按照下标定位到列表相应的位置范围
sub_scores = scores[1:-1]
print(sub_scores)
# 前3个
sub_scores = scores[:3]
print(sub_scores)
# 后三个
sub_scores = scores[-3:]
print(sub_scores)
# 反转
sub_scores = scores[::-1]
print(sub_scores)
sub_scores = scores[::2]
print(sub_scores)
4.增加数据的操作
列表数据.append(数据) 把数据追加在列表的末尾
列表数据.insert(指定位置, 数据) 在指定位置添加数据, 原位置及其之后的数据都向后移一个
course_list = ['语文', '数学', '英语', '体育']
# 增加一门Python课程
course_list.append('Python')
print(course_list)
# 在1的位置添加政治
course_list.insert(1, '政治')
print(course_list)
5.删除数据的操作
列表数据.remove(数据) 将数据在列表中移除 如果数据有多个的话 只会移除出现的第一个
列表数据.pop() 将列表中最后一个元素移除
列表数据.pop(位置) 将列表中指定位置的元素移除
列表数据.clear() 清空列表
course_list.remove('英语')
print(course_list)
course_list.pop()
print(course_list)
course_list.pop(0)
print(course_list)
course_list.clear()
print(course_list)
6.关于列表遍历的操作
- 获取下标序列 ,根据下标提取数据值
- 遍历列表,获取列表中的元素
nums = [18, 29, 33, 56, 71, 28, 42, 56, 37]
for pos in range(len(nums)): # 0 1 2 3 4 5 6 ... 长度-1
print(nums[pos])
# 等同输出
for ele in nums:
print(ele)
# 获取列表中所有的偶数
for even in nums:
if even % 2 == 0:
print(even)
# 定义一个新的列表 用来存储所有的偶数
even_list = []
for n in nums:
if n % 2 == 0:
even_list.append(n)
print(even_list)
# 获取所有偶数所在的位置
pos_list = []
for i in range(len(nums)):
if nums[i] % 2 == 0:
pos_list.append(i)
print(pos_list)
# 获取所有的偶数及其对应的位置
# 遍历位置
for j in range(len(nums)):
if nums[j] % 2 == 0:
print(j, nums[j])
# enumerate(有序容器数据) ====》产生一个新的容器 [[位置, 元素], [位置, 元素]]
# 二维结构
for item in enumerate(nums):
print(item)
# 拆包: 把容器中的数据赋值给N个变量, 把容器拆解 这个过程叫做拆包
a, b = [11, 23]
print(a, b)
# 利用拆包的原理
for p, e in enumerate(nums):
# p接受的位置 e接受的元素
if e % 2 == 0:
print(p, e)
7.列表推导式
产生新列表 – 遍历简化的格式
[变量 for 变量 in 容器型数据 if判断条件]
"""
even_list = []
for n in nums:
if n % 2 == 0:
even_list.append(n)
print(even_list)
"""
#列表推导式
result = [n for n in nums if n % 2 == 0]
print(result)
# 有些需求不一定是有判断的 if判断条件的存在是按照需求来决定有或者没有的
values = [1, 2, 3, 4, 5]
# ====> [1, 4, 9, 16, 25]
pow_list = []
for d in values:
pow_list.append(d ** 2)
print(pow_list)
# 列表推导式
print([d ** 2 for d in values])
"""
练习:
1. scores = [82, 79, 65, 47, 58, 91, 66]
利用列表推导式获取 60及其以上的成绩
2. 利用列表推导式 获取 1-100中个位数是1 且是3的倍数的数据
"""
# 练习1
scores = [82, 79, 65, 47, 58, 91, 66]
pass_score = [s for s in scores if s >= 60]
print(pass_score)
# 练习2
res = [g for g in range(1, 101) if g % 10 == 1 and g % 3 == 0]
print(res)
8.其他容器型数据
max(容器型数据) 获取数据中的最大值
min(容器型数据) 获取数据中的最小值
sum(容器型数据) 对容器中数据求和