第一章
1.1 自带的集成开发环境
写少量代码时可使用
写大量代码时可使用
1.2 第一个Python程序
- 在项目中创建文件夹 char2
- 在 char2 下创建Python File demo1
- 输入
hello,Python - 点击运行
1.3 IPO程序编写方法
IPO (Input，Process，Output)
输入-处理-输出
1.4 print 函数的使用
语法：print(输出内容)
完整语法：print(value,...,sep='',end='\n',file=None)
1.4.1 基础
a=100 # 变量a，值为100
b=50 # 变量b，值为50
print(90)
print(a) # 输出的是变量的值，a的值为100
print(a*b) # 输出的是a*b的运算结果，运算结果为5000
print('48小时')
print("48小时")
print('''48小时''')
print("""48小时""") # 只要是引号即可
1.4.2 不换行 一次性输出多个数据
希望：
一次输出多个内容 并且不换行（输出多个在一行当中）
用英文逗号将输出内容隔开
a=100
b=50
print(a,b,'48小时')
1.4.3 输出ASCII所对应的字符
语法：chr()
print('b') # 直接输出了b
print(chr(98)) # 也输出了b，使用chr()将98转换成ASCII表中的字母
print('C')
print(chr(67))
print(8)
print(chr(56))
print('[')
print(chr(91))
# 中文编码的范围是从[u4e00~u9fa5]
1.4.4 使用print函数输出中文Unicode码
1.4.4.1 查询中文Unicode码
语法：ord()
print(ord('小'))
print(ord('时'))
1.4.4.2 输出中文Unicode码
print(chr(23567))
print(chr(26102))
1.4.5 使用print函数将内容输出到文件
不仅可以将数据输出到控制台上，还可以把数据输出到文件中
fp=open('note.txt','w') # 自定义变量fp，命名文件note.txt，w-->write
print('48小时',file=fp) # 将“48小时”输出（写入）到文件note.txt中
fp.close() # 关闭文件
文件 note.txt 会和 demo1 产生在同一路径下
点击 Reload in 'GBK'
1.4.6 多条print函数输出结果一行显示
因为print(value,...,sep='',end='\n',file=None)
- 其中
sep=''代表的是分隔符为空格 end='\n'代表结束符为换行
修改结束符
print(48,end='-->') # 修改了这句的结束符
print('小时') # 没有修改这句结束符，所以print之后会有一个空行
1.4.7 使用连接符连接多个字符串
print('48'+'小时')
注意：只能字符串之间连接
1.5 input 函数的使用
1.5.1 基础
语法：x=input('提示文字')
注意：无论输入的数据是什么，x的数据类型都是字符串型
name=input('请输入您的姓名：') # 变量name
print('我的姓名是：'+name)
1.5.2 输入整数类型的数据
num=input('请输入您的幸运数字：')
print('我的幸运数字是：'+num) # 连接成功，说明num是字符串类型
num=int(num) # 使用内置函数int将num转成整数类型
print('我的幸运数字是：',num) # 注意此时使用的是,而不是+
1.6 Python中的注释
1.6.1 单行多行注释
# 这是单行注释
'''
这是多行注释
'''
"""
这也是多行注释
"""
1.6.2 中文声明注释
注意：中文声明注释需写在第一行
# coding=utf-8
# 中文声明注释
1.7 Python中的缩进
代码缩进：
- 是指每行语句开始前的空白区域
- 用来表示Python程序间的包含和层次关系
- 类定义、函数定义、流程控制语句以及异常处理语句等行尾的冒号和下一行的缩进表示一个代码块的卡死hi，而缩进结束，则表示一个代码块的结束
- 通常情况下采用4个空格作为一个缩进
# 一般代码，不需要缩进
print('hello')
# 类的定义
class Student:
pass
# 函数的定义
def fun():
pass
章节习题
习题1：输出“人生苦短，我用Python”
需求：使用print()函数将“人生苦短，我用Python”输出到文本文件text.txt中
fp=open('note.txt','w') # 打开文件
print('人生苦短，我用Python',file=fp) # 输出内容到文件
fp.close() # 关闭文件
习题2：输出个人自我介绍
需求：使用input()函数从键盘输入姓名、年龄、座右铭，并使用print()函数输出到控制台
name=input('请输入您的姓名：')
age=input('请输入您的年龄：')
motto=input('请输入您的座右铭：')
print('-----------自我介绍------------')
print('姓名：',name)
print('年龄：',age)
print('座右铭：',motto)
第二章 数据类型和运算符
2.1 保留字和标识符
2.1.1 保留字
保留字：指在Python中被赋予特定意义的一些单词，在开发程序时，不可以把这些保留字作为变量、函数、类、模块和其他对象的名称来使用
注意：保留字严格区分大小写
true='真' # 可行
True='真' # 不可行，True为保留字
2.1.1.1 查询Python中的保留字
import keyword # 导入
print(keyword.kwlist) # 打印保留字列表
print(len(keyword.kwlist)) # 计算保留字的个数
2.1.2 标识符
Python标识符的命名规则：
- 可以是字符（英文、中文）、下划线 “_” 和数字，并且第一个字符不能是数字
- 不能使用保留字
- 标识符严格区分大小写
- 以下划线开头的标识符有特殊意义，一般应避免使用相似的标识符
- 允许使用中文作为标识符，但不建议
Python标识符的命名规范：
- 模块名尽量短小，并且全部使用小写字母，可以使用下划线分隔多个字母
例如：grame_main - 包名尽量短小，并且全部使用小写字母，不推荐使用下划线
例如：com.ioppython ，不推荐使用com_ioppython - 类名采用单词首字母大写形式（Pascal风格）
例如:MyClass - 模块内部的类采用 “_”+Pascal风格的类名组成
例如:在MyClass中的内部类_InnerMyClass - 函数、类的属性和方法的命名，全部使用小写字母，多个字母之间使用下划线分隔
- 常量命名时采用全部大写字母，可以使用下划线
- 使用单下划线“_”开头的模块变量或函数是受保护的，在使用“from xxx import *”语句从模块中导入时，这些模块变量或函数不能被导入
- 使用双下划线“_”开头的实例变量或方法是类私有的
- 以双下划线开头和结尾的是Python的专用标识
例如_init_()表示初始化函数
2.2 常量与变量
2.2.1 变量
语法：变量名=value
举例：luck_number=8
首先在堆内存中开了一个空间，放入8，栈内存中的luck_number指向堆当中的这个内存空间
luck_number=8 # 创建一个整型变量luck_number并为其赋值为8
my_name='iop99' # 字符串类型的变量
print('luck_number的数据类型是：',type(luck_number)) # 利用type函数输出luck_number的数据类型
print(my_name,'的幸运数字是：',luck_number)
# Python动态修改变量的数据类型，通过赋不同类型的值就可以直接修改
luck_number='48小时'
print('luck_number的数据类型是：',type(luck_number))
# Python中允许多个变量指向同一个值
no=number=728 # no与number都指向了728这个整数值
print(id(no)) # id()查看对象的储存地址
print(id(number)) # 储存地址相同
变量命名应遵循以下几条规则：
- 变量名必须是一个有效的标识符
- 变量名不能使用Python中的保留字
- 慎用小写字母 i 和大写字母 O
- 应选择有意义的单词作为变量名
2.2.2 常量
- 常量就是在程序运行过程中值不允许改变的量
- 全部使用大写字母和下划线命名
pi=3.1415926 # 定义了一个变量
PI=3.1415926 # 定义了一个常量
2.3 数值类型
2.3.1 整数类型 int
整数类型表示的数值是没有小数部分的数值，包含正整数、负整数和0
num=957 # 默认是十进制，表示整数
num2=0b10101 # 使用二进制表示整数
num3=0o257 # 使用八进制表示整数
num4=0x89ABF # 使用十二进制表示整数
print(num)
print(num2)
print(num3)
print(num4)
2.3.2 浮点数类型 float
浮点数类型表示带有小数点的数值，由整数部分和小数部分组成
height=183.6
print(height)
print(type(height))
还可以用科学计数法表示
x=1.99E1413
print('科学计数法：',x,'x的数据类型：',type(x))
注意：两个浮点数类型的数在计算时，有一定概率运算结果后增加一些 “不确定的” 尾数
print(0.1+0.2) # 不确定的尾数问题
print(round(0.1+0.2,1)) # 解决方法：使用round()函数保留1位小数
2.3.3 复数类型
Python中的复数与数学中的复数形式完全一致，由实部和虚部组成
实部部分使用.real表示，虚部部分使用.imag表示
x=123+456j
print('实数部分：',x.real) # 实数部分
print('虚数部分：',x.imag) # 虚数部分
2.4 字符串类型
2.4.1 字符串
字符串类型连续的字符序列，可以表示计算机能识别的一切字符
字符串的界定符：单引号、双引号、三引号
info='''地址：江苏省南京市
收件人：iop99
手机号：17700000000
''' # 三引号常用于定义多行字符串
info2="""地址：江苏省南京市
收件人：iop99
手机号：17700000000
"""
2.4.2 转义字符
原字符：使转义字符失效的字符，r或R
print('48小时')
print('48\n小时')
print('48\t小时')
print('小饼说：\'48小时\'')
print('小饼说：\"48小时\"')
# 原字符
print(r'48\n小时')
print(R'48\n小时')
2.4.3 字符串的索引和切片
字符串又被称为有序的字符序列，对字符串中某个字符的检索称为索引
对字符串中某个子串或区间的检索称为切片
切片的语法结构：字符串或字符串变量[N:M]
从2开始到7结束，不包含7；从-8开始到-3结束，不包含-3
s='helloworld'
print(s[0],s[-10]) # 获取字符串中索引为0和-10的，实际上表示的是同一个字符
print(s[2:7]) # 从2开始到7结束，不包含7（正向递增）
print(s[-8:-3]) # 从-8开始到-3结束，不包含-3（反向递减）
print(s[:5]) # 默认N从0开始
print(s[4:]) # M默认切到字符串结尾
print('48小时'[2]) # 获取字符串中索引为2的
print('48小时'[-1]) # 获取字符串中索引为-1的
2.4.4 常用的字符串操作
x='2022年'
y='北京冬奥会'
print(x+y) # 连接两个字符
print(x*10) # 对x这个字符串复制10次
print('北京'in y) # True
print('上海'in y) # False
2.5 布尔类型
用来表示“真”值或“假”值的数据类型
True表示1，False表示0
x=True
print(x)
print(type(x)) # bool
print(x+10) # 1+10=11
print(False+10) # 0+10=10
print(bool(18)) # 测试一下整数18的布尔值 True
print(bool(0),bool(0.0)) # False
# 总结：非0的整数的布尔值都为True
print(bool('48小时')) # True
print(bool('')) # False
# 总结：所有非空字符串的布尔值都为True
print(bool(False)) # False
print(bool(None)) # False
布尔值为False的情况：
- False或是None
- 数值中的0，包含0，0.0，虚数0
- 空序列，包含空字符串、空元组、空列表、空字典、空集合
- 自定义对象的实例，该对象的
_bool_()方法返回False或_len_()方法返回0
2.6 数据类型之间的转换
2.6.1 隐式转换
x=10
y=3
z=x/y # 在执行除法运算的时候，将运算的结果赋值给z
print(z,type(z)) # 隐式转换，通过运算隐式转换了结果的类型
2.6.2 int()与float()
# float类型转换成int类型，只保留整数部分
print('float类型转成int类型：',int(3.14))
print('float类型转成int类型：',int(3.9))
print('float类型转成int类型：',int(-3.14))
print('float类型转成int类型：',int(-3.9))
# int类型转换成float类型
print('int类型转成float类型：',float(10))
# 将str转成int类型
print(int('100')+int('200')) # 结果是进行了加法计算 100+200=300
# 将字符串转成int或float时报错的情况
print(int('18a')) # 不可行，因为a不是一个数
print(int('3.14')) # 不可行，因为3.14不是一个整数，只能转换为浮点数
print(float('3.14')) # 可行
print(float('45a.987')) # 不可行，因为a不是一个数
2.6.3 chr()与ord()
print(ord('杨')) # “杨”在unicode表中对应的整数值
print(chr(26472)) # 26472整数在unicode表中对应的字符
2.6.4 进制之间的转换操作
十进制与其它进制之间的转换
print('十进制转换成十六进制：',hex(5642))
print('十进制转换成八进制：',oct(5642))
print('十进制转换成二进制：',bin(5642))
2.7 eval 函数
用于去掉字符串最外侧的引号，并按照python语言方式执行去掉引号后的字符串
eval的语法格式：变量=eval(字符串)
s='3.14+3'
print(s,type(s))
x=eval(s) # 使用eval函数去掉s这个字符串中左右的引号，执行加法运算
print(x,type(x))
eval()函数经常和input()函数一起使用
# `eval()`函数经常和`input()`函数一起使用，用来获取用户输入的数值
age=eval(input('请输入您的年龄：')) # 将字符串类型转换成int类型，相当于int(age)
print(age,type(age))
hello='南京欢迎你'
print(hello)
print(eval('hello')) # eval将hello两边的引号去掉，hello代表变量hello，即南京欢迎你
print(eval('南京欢迎你')) # 不可行，去掉引号后是没有引号的字符串，南京欢迎你应该表示的是一个变量，但此时这个变量没有被定义
2.8 运算符
2.8.1 算术运算符
算数运算符的优先级由高到低：
- 第一级：**
- 第二级：*、/、%、//
- 第三级：+、-
print('加法：',1+1)
print('减法：',1-1)
print('乘法：',2*3)
print('除法：',10/2)
print('整除：',10//3)
print('取余：',10%3)
print('幂运算：',2**3)
2.8.2 赋值运算符
x=20 # 直接赋值，直接将20赋值给变量x
y=10
x=x+y # 将x+y的和赋值给x，x的值为30
print(x) # x的值为30
x+=y # 40，相当于x=x+y
print(x)
x-=y # 30，相当于x=x-y
print(x)
x*=y
print(x) # 300
x/=y
print(x) # 30.0，发生了类型转换，此时x的数据类型为float
print(type(x))
x%=2
print(x) # 0.0，因为30.0除以2没有余数
z=3
y//=z # y整除z，y=y//z
print(y) # 3
y**=2 # 相当于y=y**2
print(y) # 3的2次方，9
其它赋值方法
# python支持链式赋值
a=b=c=100 # a=100 b=100 c=100
# python支持解包赋值
a,b=10,20 # a=10 b=20
# 使用解包法交换两个变量的值
a,b=b,a # 把b的值赋值给a，把a的值赋值给b，a=20 b=10
2.8.3 比较运算符
print('98大于90吗？',98>90) # True
2.8.4 逻辑运算符
print(8>7 and 98>90) # True
print(8<7 and 10/0) # False，当第一个表达式为False直接得结果，不会再运算10/0
print(8>7 or 10/0) # True，当第一个表达式为True直接得结果，不会再运算10/0
2.8.5 位运算符
位运算符 把数字看作二进制数来计算
2.8.5.1 位与运算符
将需要操作的数转换成二进制并对齐，当同一个位置的数都为1时，结果为1
print('按位与运算',12&8) # 8
2.8.5.2 位或运算符
当同一个位置的数都为0时，结果为0
print('按位或运算',4|8) # 12
2.8.5.3 位异或运算符
当同一个位置的数相同时为0，不同为1
print('按位异或运算',34^28)
2.8.5.4 位取反运算符
取反，原来是0就是1，原来是1就是0
print('按位取反运算',~123)
2.8.5.5 “左移位”运算符
“左移位”运算（<<） 是将一个二进制数向左移动指定的位数，左边（高位端）溢出的位被丢弃，右边（低位端）的空位用0补充
print('左移位：',2<<2) # 8，表示的是2向左移动2位，2*2*2（2乘以2个2）
print('左移位：',2<<3) # 16，表示的是2向左移动3位，2*2*2*2（2乘以3个2）
print('左移位：',4<<2) # 4*2*2
2.8.5.6 “右移位”运算符
“右移位”运算（>>） 是将一个二进制数向右移动指定的位数，右边（低位端）溢出的位被丢弃，左边（高位端）的空位端，如果最高位是0则用0补充，如果最高位是1则用1补充
print('右移位：',8>>2) # 2，表示的是8向右移动2位，8//2 4//2（8除以2个2）
print('右移位：',8>>3) # 1，8除以3个2
print('右移位：',-8>>2) # -2
2.8.6 运算符的优先级
章节习题
习题1：获取数字并输出
从键盘上获取一个4位整数，分别输出个位、十位、百位、千位上的数字
需求：可以使用
eval()函数或int()函数将从键盘获取的数字串转成int类型，通过整除和取余操作分别获取数字
# 方法一：eval()
num=eval(input('请输入一个任意四位数字：'))
print('这个数字的个位是：',num%10)
print('这个数字的十位是：',num%100//10)
print('这个数字的百位是：',num//100%10)
print('这个数字的千位是：',num//1000)
# 方法二：int()
num1=(input('请输入一个任意四位数字：'))
num1=int(num1)
print('这个数字的个位是：',num1%10)
print('这个数字的十位是：',num1%100//10)
print('这个数字的百位是：',num1//100%10)
print('这个数字的千位是：',num1//1000)
# 方法三：索引
num2=(input('请输入一个任意四位数字：'))
print('这个数字的个位是：',num2[3])
print('这个数字的十位是：',num2[2])
print('这个数字的百位是：',num2[1])
print('这个数字的千位是：',num2[0])
习题2：根据父母身高预测儿子身高
需求：从键盘输入父母身高，并使用
eval()或float()转换输入的数据类型。
计算公式：儿子身高=（父亲身高+母亲身高）*0.54
# 方法一：eval()
hight1=eval(input('请输入爸爸的身高：'))
hight2=eval(input('请输入妈妈的身高：'))
print('预测儿子的身高为：',(hight1+hight2)*0.54)
# 方法二：float()
hight1=(input('请输入爸爸的身高：'))
hight2=(input('请输入妈妈的身高：'))
hight1=float(hight1)
hight2=float(hight2)
print('预测儿子的身高为：',(hight1+hight2)*0.54)
第三章 程序的流程控制
3.1 程序的组织结构
3.2 顺序结构
按照程序语句的自然顺序，从上到下，依次执行每条语句的程序
3.3 选择/分支结构
也叫“分支结构”，是按照条件选择执行不同的代码段
3.3.1 单分支结构 if
执行流程：如果表达式为True，就执行语句块；如果表达式为False，就跳过语句块，继续执行后面的代码
num=eval(input('请输入你的获奖号码：'))
# 使用if语句
if num==12345: # 等值判断
print('恭喜你！中奖了')
if num!=12345:
print('很遗憾，未中奖')
# 以上if判断的表达式是通过比较运算符计算出来的，结果是布尔类型
n=20
if n%2: # 20%2的余数是0，即False；若余数非0，则布尔值为True
print(n,'是奇数') # 由于20%2的余数是0，该行代码不会执行
if not n%2:
print(n,'是偶数')
# 判断一个字符串是否是空字符串
x=input('请输入一个字符串')
if x: # 在python中一切皆对象，每个对象都有一个布尔值，非空字符串的布尔值为True，空字符串的布尔值为False
print(x,'是一个非空字符串')
注意：当使用if语句时，如果语句块只有一句代码，可以不换行直接写在冒号后
if a>b:max=a
3.3.2 双分支结构 if-else
执行流程：如果表达式为True，就执行语句1；否则就执行语句2
num=eval(input('请输入你的获奖号码：'))
# 使用if-else语句
if num==12345: # 等值判断
print('恭喜你！中奖了')
else:
print('很遗憾，未中奖')
# 以上代码可以使用条件表达式进行简化
result='恭喜你！中奖了' if num==12345 else '很遗憾，未中奖'
print(result)
3.3.3 多分枝结构 if-elif-else
score=eval(input('请输入你的成绩：'))
# 使用if-elif-else语句
if score<0 or score>100:
print('成绩有误！')
elif 0<=score<60:
print('D')
elif 60<=score<80:
print('C')
elif 80<=score<90:
print('B')
else:
print('A')
3.3.4 嵌套if的使用
单分支结构、双分支结构和多分支结构在实际开发中是可以互相嵌套使用的，内层的分支结构将作为外层分支结构的语句块使用
answer=input('请问，您喝酒了吗')
if answer=='y':
proof=eval(input('请输入酒精含量：'))
if proof<20:
print('不构成酒驾')
elif proof<80:
print('已构成酒驾')
else:
print('已达醉驾标准')
else:
print('你走吧，没你啥事儿')
3.3.5 多个条件的连接 and与or
3.3.5.1 and
在使用and连接多个条件判断时，只有同时满足多个条件，才能执行if后面的语句块
user_name=input('请输入用户名：')
user_password=input('请输入密码：')
if user_name=='iop' and user_password=='888888':
print('登录成功')
else:
print('用户名或密码错误')
3.3.5.2 or
使用or连接多个条件判断时，只要满足一个条件，就能执行if后面的语句块
score=eval(input('请输入你的成绩：'))
if score<0 or score>100:
print('成绩有误！')
else:
print('你的成绩为',score)
3.3.6 模式匹配 match-case
score=input('请输入你的成绩等级：')
match score:
case 'A':
print('优秀')
case 'B':
print('良好')
case 'C':
print('合格')
case 'D':
print('不合格')
3.4 循环结构
3.8.1 遍历循环 for
for i in 'hello': # 每次从hello中取一个赋值给i
print(i)
range()函数，用于生成一个 [n,m) 的整数序列，包含n但不包含m
for i in range(1,11): # 包含1但是不包含11
print(i)
计算1-10中的偶数
for i in range(1,11): # 包含1但是不包含11
if i%2==0:
print(i,'是偶数')
计算1-10的累加和
s=0 # 用于存储累加和
for i in range(1,11): # 包含1但是不包含11
s+=i # 相当于s=s+i
print('1-10的累加和为',s)
计算100-999的水仙花数
# 水仙花数：个位的立方+十位的立方+百位的立方=这个数
for i in range(100,1000):
sd=i%10 # 获取个位上的数字
tens=i//10%10 # 十位
hundred=i//100 # 百位
# 判断
if sd**3+tens**3+hundred**3==i:
print(i,'是水仙花数')
3.8.2 无限循环 while
3.8.2.1 while的四个步骤
# (1)初始化变量
answer=input('今天要上课吗？y/n')
while answer=='y': # (2)条件判断
print('好好学习，天天向上') # (3)语句块
# (4)改变变量
answer=input('今天要上课吗？y/n') # 会回到第3行进行循环
1-100的累加和
s=0 # 存储累加和
i=1 # (1)初始化变量
while i<=100: # (2)条件判断
s+=i # (3)语句块
# (4)改变变量
i+=1
print('1-100的累加和为',s)
3.8.2.2 while-else
s=0 # 存储累加和
i=1 # (1)初始化变量
while i<=100: # (2)条件判断
s+=i # (3)语句块
# (4)改变变量
i+=1
else:
print('1-100的累加和为',s)
3.8.2.3 使用while循环模拟用户登陆
# (1)初始化变量
i=0
while i<3: # (2)条件判断
# (3)语句块
user_name=input('请输入用户名：')
user_password=input('请输入密码：')
# 登录操作，if-else
if user_name=='iop' and user_password=='888888':
print('登录成功')
# (4)改变变量，目的：退出循环
i=9 # 随便设置一个值，只要不是0-2即可在第3行判断i<3是为False，退出循环
else:
if i<2:
print('用户名或密码错误，你还有',2-i,'次机会')
i+=1 # (4)改变变量
if i==3:
print('对不起，三次均错误')
3.3 程序跳转语句
3.3.1 break
3.3.1.1 break在if中使用
程序跳转语句break用于跳（退）出循环结构，通常与if一起搭配使用
从1开始累加，累加和大于20
s=0 # 存储累加和
i=1 # (1)初始化变量
while i<=11: # (2)条件判断
s+=i # (3)语句块
if s>20:
print('累加和大于20的当前数是：',i)
break
# (4)改变变量
i+=1
登录
# (1)初始化变量
i=0 # 统计登录的次数
while i<3: # (2)条件判断
# (3)语句块
user_name=input('请输入用户名：')
user_password=input('请输入密码：')
# 登录操作，if-else
if user_name=='iop' and user_password=='888888':
print('登录成功')
break # 退出循环
else:
if i<2:
print('用户名或密码错误，你还有',2-i,'次机会')
i+=1 # (4)改变变量
if i==3:
print('对不起，三次均错误')
3.3.1.2 break在for中使用
for i in 'hello':
if i=='e':
break
print(i)
登录
for i in range(3):
user_name=input('请输入用户名：')
user_password=input('请输入密码：')
if user_name=='iop' and user_password=='888888':
print('登录成功')
break
else:
if i<2:
print('用户名或密码错误，你还有',2-i,'次机会')
else:
print('对不起，三次均错误')
3.3.2 continue
3.3.2.1 continue在if中使用
1-100之间的偶数和
s=0 # 存储累加和
i=1 # (1)初始化变量
while i<=100: # (2)条件判断
# (3)语句块
if i%2==1: # 奇数
i+=1
continue # 不再执行后面的代码了，进入下一次循环
# 累加求和的代码
s+=i
i+=1
print('1-100之间的偶数和：',s)
3.3.2.2 continue在for中使用
1-100之间的偶数和
s=0 # 存储累加和
for i in range(1,101):
if i%2==1: # 奇数
continue
s+=i
print('1-100之间的偶数和：',s)
3.4 空语句 pass
- pass是python中的保留字
- 在语法结构中只起到占位符作用，使语法结构完整，不报错
- 一般可用在if、for、while、函数的定义、类的定义中
if True: # 没有语句块，语法结构不完整，会报错
if True:
pass # pass占位，语法结构完整，不会报错
for i in range(10):
pass
章节习题
习题1：输入年份判断是否是闰年
需求：从键盘获取一个四位的整数年份，判断其是否是闰年。
闰年的判断条件：能被4整除但不能被100整除，或者能被400整除
year=eval(input('请输入一个四位的年份：'))
if (year%4==0 and year%100!=0) or year%400==0:
print(year,'年是闰年')
else:
print(year,'年是平年')
习题2：模拟10086查询功能
需求：输入1，显示当前余额；输入2，显示当前剩余流量，单位为G；输入3，显示当前剩余通话，单位为分钟；输入0，退出自助查询系统
answer='y'
while answer=='y':
print('----------欢迎使用10086查询系统----------')
print('1. 查询当前余额')
print('2. 查询剩余流量')
print('3. 查询剩余通话')
print('0. 退出自助查询系统')
choice=input('请输入您要执行的操作：')
if choice=='1':
print('当前余额为：546.2元')
elif choice=='2':
print('当前剩余流量为：49G')
elif choice=='3':
print('当前剩余通话为：362分钟')
elif choice=='0':
print('系统退出中...')
break
else:
print('输入有误，请重新输入')
# 改变变量，返回前面循环
answer=input('还继续操作吗？y/n')
else:
print('系统退出中...')
第四章
4.1 序列
4.1.1 序列的索引
序列是一个用于存储多个值的连续空间，每个值都对应一个整数的编号，称为索引
# 正向递增
s='helloworld'
for i in range(0,len(s)):
print(i,s[i],end=' ')
print('/n')
# 逆向递减
s='helloworld'
for i in range(-len(s),0):
print(i,s[i],end=' ')
4.1.2 序列的切片
s='HelloWorld'
# 切片操作
s1=s[0:5:2] # 索引从0开始到5结束，不包含5，步长为2
print(s1) # Hlo 因为步长为2，每次迈2步
# 省略了开始位置，start默认从0开始
print(s[:5:2])
# 省略了开始位置，省略步长，步长默认为1
print(s[:5:])
# 省略了结束位置，默认结束为最末
print(s[0::1])
print(s[5::])
print(s[5:]) # 第15、16相同，都是省略了结束和步长
# 只写步长
print(s[::2]) # 获取索引为0、2、4、6、8的元素
s='HelloWorld'
# 步长为负数
print(s[::-1])
print(s[-1:-len(s)-1:-1]) # 第3、4行相同
4.1.3 序列的相关操作
# 序列的相加
s='Hello'
s2='World'
print(s+s2) # 产生一个新的字符串序列
s='HelloWorld'
# x in s
print('e在HelloWorld中存在吗？',('e' in s)) # True
print('v在HelloWorld中存在吗？',('v' in s)) # False
# x not in s
print('e在HelloWorld中不存在吗？',('e' not in s)) # False
print('v在HelloWorld中不存在吗？',('v' not in s)) # True
# 内置函数的使用
print('len()：',len(s))
print('max()：',max(s)) # 注意，不是按序列数字大小
print('min()：',min(s))
# 序列对象的方法：使用序列名称，打点调用
print('s.index()：',s.index('o')) # 4，o在s中第一次出现的索引
print('s.index()：',s.index('v')) # 报错，v在s中根本不存在
print('s.count()：',s.count('o')) # 2，o在s中总共出现的次数
4.2 列表
- 是指一系列的按特定顺序排列的元素组成的
- 是python中内置的可变序列
- 在python中使用 [ ] 定义列表，元素与元素之间使用英文的逗号分隔
- 列表中的元素可以是任意的数据类型
4.2.1 列表的基本操作
列表的创建方式：
- 使用 [ ] 直接创建列表
语法结构：列表名=[element,element2,...,elementN] - 使用内置函数
list()创建列表
语法结构：列表名=list(序列)
# 直接使用 [ ] 创建列表
lst=['hello','iop',99,100.2]
print(lst)
# 使用内置函数list()创建列表
lst2=list('helloworld')
print(lst2)
lst3=list(range(1,10,2)) # 步长为2
print(lst3)
# 列表是序列的一种，对序列的操作符、运算符、函数均可使用
print(lst+lst2+lst3)
print(lst*3)
print(len(lst2))
print(max(lst2))
print(lst2.count('o'))
列表的删除：del列表名
lst=[10,20,30]
print(lst)
# 删除列表
del lst
4.2.2 列表的遍历操作 enumerate
enumerate函数的使用语法结构：
for index,item in enumerate(lst):
输出index（序号）和item（元素）
lst=['hello','world','python','iop']
# 使用遍历循环for遍历列表元素
for item in lst:
print(item)
# 使用for循环，range()函数，len()函数
for i in range(0,len(lst)):
print(i,'--->',lst[i])
# 使用enumerate函数
for index,item in enumerate(lst):
print(index,item)
注意：index是序号，不是索引，我们可以手动修改序号的起始值
for index,item in enumerate(lst,start=1):
4.2.3 列表的特有操作
lst=['hello','world','python']
print('原列表',lst,id(lst))
# 增加元素的操作
lst.append('sql')
print('增加元素之后：',lst,id(lst))
# 插入元素
lst.insert(1,100)
print('插入元素之后：',lst,id(lst))
# 删除操作
lst.remove('sql')
print('删除元素之后：',lst,id(lst))
print(lst.pop(1))
print(lst,id(lst)) # pop会先把100取出，再删除
# 清除列表中所有元素
lst.clear()
print(lst)
# 列表的反向
lst.reverse() # 不会产生新列表，在原列表的基础上进行的
print(lst)
# 列表的拷贝，将产生一个新的列表对象
new_lst=lst.copy()
print(lst,id(lst))
print(new_lst,id(new_lst))
# 列表元素的修改
lst[1]='mysql'
print(lst)
4.2.4 列表排序的两种方式
- 列表对象的
sort方法：lst.sort(key=None,reverse=False)key：表示排序的规则；reverse：表示排序方式（默认升序） - 内置函数
sorted()：sorted(iterable,key=None,reverse=False)iterable：表示排序的对象
4.2.4.1 sort
lst=[4,56,3,85,42,11]
print('原列表：',lst)
# 排序，默认升序
lst.sort() # 在原列表上进行
print('升序：',lst)
# 排序，降序
lst.sort(reverse=True) # 在原列表上进行
print('降序：',lst)
# 英文单词是按照ASCII码排序
lst=['apple','banana','Cat','cat']
print('原列表：',lst)
# 升序排序，先排大写，再排小写
lst.sort() # 在原列表上进行
print('升序：',lst)
# 降序排序，先排小写，再排大写
lst.sort(reverse=True) # 在原列表上进行
print('降序：',lst)
# 自定排序规则：忽略大小写进行比较
lst.sort(key=str.lower)
print('忽略大小写进行比较：',lst)
4.2.4.2 sorted()
用内置的sorted()函数将产生一个新的列表对象
lst=[4,56,3,85,42,11]
print('原列表：',lst)
# 排序
asc_lst=sorted(lst) # 因为使用该内置函数会产生一个新的列表对象
print('升序：',asc_lst)
print('原列表：',lst) # 原列表不会发生改变
desc_lst=sorted(lst,reverse=True)
print('降序：',desc_lst)
print('原列表：',lst)
lst=['banana','cat','apple','Cat']
print('原列表：',lst)
# 自定排序规则：忽略大小写进行比较
new_lst=sorted(lst,key=str.lower)
print('忽略大小写进行比较：',new_lst)
print('原列表：',lst)
4.2.5 列表生成式
列表生成式的语法结构：
lst=[expression for item in range]
lst=[expression for item in range if condition]
import random
lst=[item for item in range(1,11)]
print(lst)
lst=[item*item for item in range(1,11)]
print(lst)
lst=[random.randint(1,100) for _ in range(10)] # 产生1-100之间的随机数
print(lst)
# 从列表中选择符合条件的元素组成新的列表
lst=[i for i in range(10) if i%2==0]
print(lst)
4.2.6 二维列表
# 创建二维列表
lst=[
['城市','环比','同比'],
['北京',102,103],
['上海',104,105],
['广州',100,140],
]
print(lst)
# 遍历二维列表使用双层for循环
for row in lst: # 行
for item in row: # 列
print(item,end=' ')
print() # 换行
# 列表生成式生成一个4行5列的二维列表
lst2=[[j for j in range(5)] for i in range(4)]
print(lst2)
4.3 元组 tuple
- 是python中内置的不可变序列，没有增删改查一系列操作
- 在python中使用
()定义元组，元素与元素之间使用英文的逗号分割 - 元组中只有一个元素的时候，逗号也不能省略
4.3.1 元组的创建与删除
# 使用小括号创建元组
t=('hello',[10,20,30],'python','woeld')
print(t)
# 使用内置函数tuple()创建元组
t=tuple('helloworld') # 把字符串中的每一个元素都当作元组中的每一个元素了
print(t)
t=tuple([10,20,30])
print(t)
关于序列的一些操作在元组中也可以实现
t=tuple([10,20,30])
print('10在元组中是否存在：',(10 in t))
print('10在元组中是否不存在：',(10 not in t))
print('最大值：',max(t))
print('最小值：',min(t))
print('len：',len(t))
print('t.index：',t.index(10))
print('t.count：',t.count(10))
元组中只有一个元素的时候，逗号也不能省略
t=tuple([10,20,30])
print(type(t))
# 如果元组中只有一个元素
t=(10)
print(type(t))
# 如果元组中只有一个元素，逗号不能省略
t=(10,)
print(type(t))
t=tuple([10,20,30])
# 元组的删除
del t
print(t) # 报错，已被删除，t没有被定义
4.3.2 元组的访问及遍历
t=('python','hello','world')
# 根据索引访问元组
print(t[0])
t2=t[0:3:2]
print(t2)
# 元组的遍历
for item in t:
print(item)
# for + range() + len()
for i in range(len(t)):
print(i,t[i])
# 使用enumerate()
for index,item in enumerate(t,start=1):
print(index,'--->',item)
4.3.3 元组生成式
t=(i for i in range(1,4))
print(t) # 根本看不到元素，看到的是一个生成器对象
t=tuple(t)
print(t)
# 想要看到它的元素，方法一：遍历
for item in t:
print(item)
t=(i for i in range(1,4))
print(t) # 根本看不到元素，看到的是一个生成器对象
# 方法二：__next__()
print(t.__next__()) # 只能取出第一个元素
print(t.__next__()) # 继续取出第二个元素
print(t.__next__()) # 继续取出第三个元素
t=tuple(t)
print(t) # 使用__next__()后再打印该元组发现为空
4.3.4 元组和列表的区别
4.4 字典
字典类型是根据一个信息查找另一个信息的方式构成了“键值对”，它表示索引用的键和对应的值构成的成对关系
4.4.1 字典的创建与删除
字典的创建方式：
- 使用
{ }直接创建字典d={key1:value1,key2:value2,...} - 使用内置函数
dict()创建字典dict(key1=value1,key2=value2,...) - 通过映射函数
zip创建字典zip(lst1,lst2)
# (1)创建字典
d={10:'cat',20:'dog',30:'zoo'}
print(d) # key相同时，value值进行了覆盖
# (2)zip函数
lst=[10,20,30,40]
lst2=['cat','dog','car']
zipobj=zip(lst,lst2)
print(zipobj) # 映射结果是一个zip对象，看不到里面的内容
# 如何转成字典呢？
d=dict(zipobj)
print(d)
# 使用参数创建字典
d=dict(cat=10,dog=20) # cat是key，10是value
print(d)
# 元组作为键
t=(10,20,30)
print({t:10}) # t是key，10是value，元组可以作为字典里的key
# 列表作为键
lst=[10,20,30]
print({lst:10}) # 报错，列表不可以作为字典里的key
# 字典属于序列，序列的基本操作字典同样适用
d={10:'cat',20:'dog',30:'zoo'}
print('max：',max(d))
print('min：',min(d))
print('len：',len(d))
# 字典的删除
del d
print(d)
注意：字典中的key是无序的，因为新版本解释器更新，所以看起来像是有序的
4.4.2 字典元素的访问及遍历
字典元素的取值：d[key] 或 d.get(key)
d={'hello':10,'world':20,'python':30}
# 访问字典中的元素
# (1)使用d[key]
print(d['hello']) # 10
# (2)使用d.get(key)
print(d.get('hello')) # 10
# 注意：两者是有区别的，如果key不存在，d[key]会报错，d.get(key)可以指定默认值
print(d['sql']) # 报错
print(d.get('sql')) # None
print(d.get('sql','不存在')) # 不存在（自定义的默认值）
字典的遍历
d={'hello':10,'world':20,'python':30}
for item in d.items():
print(item) # 得到的是key=value组成的一个元组
# 在使用for循环遍历时，分别遍历key，value
for key,value in d.items():
print(key,'--->',value)
4.4.3 字典操作的相关方法
d={1001:'李梅',1002:'王华',1003:'陈明'}
print(d)
# 向字典中添加元素
d[1004]='张丽丽' # 直接使用赋值的方式向字典中添加元素
print(d)
# 获取字典中所有的key
keys=d.keys()
print(keys) # dict_keys([1001, 1002, 1003, 1004])
print(list(keys)) # 转成列表
print(tuple(keys)) # 转成元组
# 获取字典中所有的value
values=d.values()
print(values) # dict_values(['李梅', '王华', '陈明', '张丽丽'])
print(list(values)) # 转成列表
print(tuple(values)) # 转成元组
# 将字典中的数据转成key-value的形式，以元组的方式进行展现
lst=list(d.items())
print(lst) # 转成了列表，列表中的每一组都是key-value的形式
d=dict(lst) # 转成字典
print(d)
d={1001:'李梅',1002:'王华',1003:'陈明'}
# 使用pop函数
print(d.pop(1001)) # 李梅 先把值取出来，然后再把整个key-value对删除
print(d) # {1002: '王华', 1003: '陈明'} 已经没有1001了
# 删除一个不存在的
print(d.pop(1008,'不存在')) # 不存在 为设置的默认值
# 随机删除
print(d.popitem())
print(d) # 已经随机删除一个key-value对了
# 清空字典中所有的元素
d.clear()
print(d) # {} 空字典
4.4.4 字典生成式
d={key:value for item in range}
d={key:value for key,value in zip(lst1,lst2)}
import random
d={item:random.randint(1,100) for item in range(4)}
print(d)
# 创建两个列表
lst={1001,1002,1003}
lst2={'陈梅','李华','张明'}
d={key:value for key,value in zip(lst,lst2)}
print(d)
4.5 集合
- python中的集合与数学集合概念一致
- python中的集合是一个无序的不重复元素序列
- 集合中只能存储不可变数据类型（不能存储字典、列表）
- 在python中集合使用
{}定义 - 与列表、字典一样，都是python中的可变数据类型
4.5.1 集合的创建与删除
集合的创建方式：
- 使用
{}直接创建集合
语法结构：s={element1,element2,...elementN} - 使用内置函数
set()创建集合
语法结构：s=set(可迭代对象)
# {}直接创建集合
s={10,20,30,40}
print(s)
# 使用set()创建集合
s=set() # 创建了一个空集合，空集合的bool值是False
print(s) # set()
# 直接使用{}创建的是集合还是字典呢？
s={}
print(s,type(s)) # 字典
s=set('helloworld')
print(s) # 证明了集合是无序且不重复的
s2=set([10,20,30])
print(s2)
s3=set(range(1,10))
print(s3)
# 集合属于序列，序列的基本操作集合同样适用
s={10,20,30,40}
print('max：',max(s))
print('min：',min(s))
print('len：',len(s))
print('9在集合当中存在吗?',(9 in s))
print('9在集合当中不存在吗?',(9 not in s))
# 集合的删除
del s
print(s) # 报错
集合的删除：del 集合名
4.5.2 集合的操作符
A={10,20,30,40,50}
B={30,50,88,75,20}
# 交集操作
print(A&B)
# 并集操作
print(A|B) # 合并且会去掉重复的元素
# 差集操作
print(A-B)
# 补集操作
print(A^B)
4.5.3 集合的操作方法
s={10,20,30}
# 向集合中添加元素
s.add(100)
print(s)
# 删除元素
s.remove(20)
print(s)
# 清空集合中所有元素
s.clear()
print(s)
4.5.4 集合的遍历
s={10,20,30}
# 集合的遍历操作
for item in s:
print(item)
# 使用enumerate()函数
for index,item in enumerate(s):
print(index,'--->',item)
# 集合的生成式
s={i for i in range(1,10)}
print(s)
s={i for i in range(1,10) if i%2==1}
print(s)
4.6 列表、元组、字典、集合的区别
4.7 python新特性
4.7.1结构模式匹配
data=eval(input('请输入要匹配的数据：'))
match data:
case {'name':'iop','age':20}:
print('字典')
case [10,20,30]:
print('列表')
case (10,20,30):
print('元组')
case _:
print('相当于多重if中的else')
4.7.2 字典合并运算符 |
d1={'a':10,'b':20}
d2={'c':30,'d':40}
merger_dict=d1|d2
print(merger_dict) # {'a': 10, 'b': 20, 'c': 30, 'd': 40}
4.7.3 同步迭代
fruits={'apple','orange','pear','banana'}
counts={10,2,3,5}
for f,c in zip(fruits,counts):
match f,c:
case 'apple',10:
print('10个苹果')
case 'orange',2:
print('2个橘子')
case 'pear',3:
print('3个梨子')
case 'banana',5:
print('5个香蕉')
# 因为使用的是集合，集合是无序的，所以每次输出是随机的
print('-'*40)
# 如果改成列表，就可以全部按顺序输出
fruits1=['apple','orange','pear','banana']
counts1=[10,2,3,5]
for f1,c1 in zip(fruits1,counts1):
match f1,c1:
case 'apple',10:
print('10个苹果')
case 'orange',2:
print('2个橘子')
case 'pear',3:
print('3个梨子')
case 'banana',5:
print('5个香蕉')
章节习题
习题1：千年虫是什么虫
需求：已知一个列表中存储的是员工的出生年份[88,89,90,98,00,99]由于时间比较久，出生的年份均为2位整数，现需要2位年份前加19如果年份是00，将需要加上200.
lst=[88,89,90,98,00,99]
print(lst) # 00会变成0，这就是为什么要在前面加上200
# 遍历列表的方式
for index in range(len(lst)):
if str(lst[index])!=0:
lst[index]='19'+str(lst[index])
else:
lst[index]='200'+str(lst[index])
print('修改后的年份列表：',lst)
lst1=[88,89,90,98,00,99]
# 使用enumerate()
for index,value in enumerate(lst1):
if str(lst1[index]) != 0:
lst1[index] = '19' + str(value)
else:
lst1[index] = '200' + str(value)
print('修改后的年份列表：', lst1)
习题2：模拟京东的购物流程
需求：从键盘录入5个商品信息（1001手机）添加到商品列表中，展示商品信息，提示用户选择商品，用户选中的商品添加到购物车中（购物车中的商品要逆序），用户选中的商品不存在需要有相应提示，当用户输入“q”时循环结束，显示购物车中的商品
# 创建一个空列表，用于存储入库的商品信息
lst=[]
for i in range(5):
goods=input('请输入商品编号和商品名称进行入库，每次只能输入一件商品：')
lst.append(goods) # 把input输入的商品编号和商品名称添加到lst列表中
# 输出所有的商品信息
for item in lst:
print(item)
# 创建一个空列表，用于存储购物车中的信息
cart=[]
while True: # 无限循环，一直执行
flag=False # 初始定义，代表没有商品的情况
num=input('请输入要购买的商品编号：')
# 遍历商品列表，查询一下要购买的商品是否存在
for item in lst:
if num==item[0:4]: # 切片操作，切出item前4位为商品编号
flag=True # 变False为True，代表商品已找到
cart.append(item) # 添加到购物车中
print('商品已成功添加到购物车')
break # 已找到，退出for循环
if not flag and num!='q': # not flag等价于flag==False
print('商品不存在！')
if num=='q':
break # 退出while循环
print('-'*40)
# 展示购物车商品
print('你的购物车已选择的商品为：')
cart.reverse() # reverse将购物车中最新添加的放在最上面优先展示输出，即按最新的时间顺序
for item in cart:
print(item)
习题3：模拟12306订票流程
需求：假设北京到天津有以下4个车次可供选择，用户选择所要购买的车次，进行购票进站
# 创建一个字典，用于存储车票信息，使用车次作为key，其他信息作为value
dict_ticket={
'G1569':['北京南-天津南','18:06','18:39','00:33'],
'G1567':['北京南-天津南','18:15','18:49','00:34'],
'G8917':['北京南-天津西','18:20','18:19','00:59'],
'G203':[' 北京南-天津南','18:35','19:09','00:34']
}
print('车次 出发站-到达站 出发时间 到达时间 历时时长')
# 遍历字典中的元素
for key in dict_ticket.keys():
print(key,end=' ') # 为什么不换行？需要将车次和车次信息在同一行显示
# 根据key获取出来的value是一个列表
for item in dict_ticket.get(key): # 根据key获取值（车次信息）
print(item,end=' ')
# 换行
print()
# 输入用户的购票车次
train_no=input('请输入要购买的车次：')
# 根据key获取值
info=dict_ticket.get(train_no,'车次不存在！') # 根据输入的车次获取info，info是列表类型
# 判断车次是否存在
if info!='车次不存在！': # 车次存在的情况下
person=input('请输入乘车人，如果是多位乘车人请用逗号分割：')
# 获取车次的信息
s=info[0]+' '+info[1]+'开，'
print('您已购买了'+train_no+' '+s+'请'+person+'尽快换取纸质车票。【铁路客服】')
else:
print('对不起，选择的车次可能不存在')
习题4：模拟手机通讯录
需求：从键盘录入5位好友的姓名和电话，由于通讯录是无序的，所以可以使用集合来实现
# 创建一个空集合
s=set()
# 录入5位好友的姓名和手机号
for i in range(1,6):
info=input('请输入第{i}位好友的姓名和手机号：')
# 添加到集合
s.add(info)
# 遍历集合
for item in s:
print(item)
第五章 字符串及正则表达式
5.1 字符串
字符串是python中的不可变数据类型
5.1.1 字符串的常用方法
# 大小写转换
s1='HelloWorld'
new_s2=s1.lower()
print(new_s2)
new_s3=s1.upper()
print(new_s3)
# 字符串的分割
e_mail='iop99yeside@163.com'
lst=e_mail.split('@')
print('邮箱名：',lst[0],'邮件服务器域名：',lst[1])
print(s1.count('o')) # o在字符串s1中出现了2次
# 检索操作
print(s1.find('o')) # o在字符串s1中首次出现的位置
print(s1.find('p')) # -1 没有找到
print(s1.index('o'))
print(s1.index('p')) # 报错，没有找到
# 判断前后缀
print(s1.startswith('H'))
print(s1.startswith('P'))
print(s1.endswith('d'))
print('demo.py',endswith('.py')) # True
s='HelloWorld'
# 字符串的替换
new_s=s.replace('o','你好',1) # 最后一个参数是替换次数，默认是全部替换
print(new_s)
# 字符串在指定位置的宽度范围内居中
print(s.center(20))
print(s.center(20,'-')) # 指定的填充
# 去掉字符串左右的空格
s=' Hello World '
print(s.strip()) # 直接去掉左右的空格
print(s.lstrip()) # 只去掉左侧的空格
print(s.rstrip()) # 只去掉右侧的空格
# 去掉指定的字符
s='dl-HelloWorld'
print(s.strip('ld')) # -HelloWor 去除字符的时候与顺序无关
print(s.lstrip('ld')) # -HelloWorld
5.1.2 格式化字符串
5.1.2.1 占位符%、f-string、format()
# (1)使用占位符进行格式化
name='林夏'
age=18
score=99.3
print('姓名：%s，年龄：%d，成绩：%f' % (name,age,score)) #注意使用方式，%+元组
print('姓名：%s，年龄：%d，成绩：%.1f' % (name,age,score)) #对小数进行简化
# (2)f-string
print(f'姓名：{name}，年龄：{age}，成绩：{score}')
# (3)使用字符串的format方法
print('姓名：{0}，年龄：{1}，成绩：{2}'.format(name,age,score)) # 花括号里是format索引位置
print('姓名：{2}，年龄：{0}，成绩：{1}'.format(age,score,name))
5.1.2.2 格式化字符串的详细格式
s='helloworld'
print('{0:*<20}'.format(s)) # 字符串显示的宽度为20，左对齐，空白部分用*填充
print('{0:*^20}'.format(s)) # 字符串显示的宽度为20，居中对齐，空白部分用*填充
# 居中对齐
print(s.center(20,'*'))
# 千位分隔符（只适用于整数和浮点数）
print('{0:,}'.format(41653156))
print('{0:,}'.format(4165956.3156))
# 浮点数小数部分的精度
print('{0:.2f}'.format(3.1415926))
# 字符串类型，表示的是最大显示长度
print('{0:.5}'.format(s))
# 整数类型
a=425
print('二进制：{0:b}，十进制：{0:d}，八进制:{0:o}，十六进制：{0:x}，十六进制：{0:X}'.format(a))
# 1a9，1A9 十六进制用大写X转换后就是大写，用小写x转换后就是小写
# 浮点数类型
b=3.1415926
print('{0:.2f}，{0:.2E}，{0:.2e}，{0:.2%}'.format(b)) # 保留两位小数，科学计数法，百分数
5.1.3 字符串的编码和解码
- str转换成bytes：编码
- bytes转换成str：解码
errors：出错方式
s='暑假来了'
# 编码 str->bytes
scode=s.encode(errors='replace') # 默认是utf-8，1个中文占3个字节
print(scode)
scode_gbk=s.encode('gbk',errors='replace') # gbk 1个中文占2个字节
print(scode_gbk)
# 编码中的出错问题
s2='☎☏'
scode=s2.encode('gbk',errors='ignore') # 忽略
print(scode) # b'' 无意义码
scode=s2.encode('gbk',errors='replace') # 严格
print(scode) # b'??' 出现问号？
# scode=s2.encode('gbk',errors='strict') # 严格
# print(scode) # 报错
# 解码 bytes->str
print(bytes.decode(scode_gbk,'gbk'))
5.1.4 数据验证的方法
数据的验证是指程序对用户输入的数据进行“合法”性验证
| 方法名 | 描述说明 |
|---|---|
| str.isdigit() | 所有字符都是数字（阿拉伯数字） |
| str.isnumeric() | 所有字符都是数字 |
| str.isalpha() | 所有字符都是字母（包括中文字符） |
| str.isalnum() | 所有字符都是数字或字母（包括中文字符） |
| str.islower() | 所有字符都是小写 |
| str.isupper() | 所有字符都是大写 |
| str.istitle() | 所有字符都是首字母大写 |
| str.isspace() | 所有字符都是空白字符（\n、\t等） |
# isdigit()只识别十进制的阿拉伯数字
print('123'.isdigit()) # True
print('一二三'.isdigit()) # False
print('0b1010'.isdigit()) # False
print('Ⅷ'.isdigit()) # False
print('-'*40)
# isnumeric()所有字符都是数字
print('123'.isnumeric()) # True
print('一二三'.isnumeric()) # True
print('0b1010'.isnumeric()) # False
print('Ⅷ'.isnumeric()) # True
print('壹贰叄肆'.isnumeric()) # True
print('-'*40)
# isalpha()所有字符都是字母（包括中文字符）
print('hello你好'.isalpha()) # True
print('hello你好123'.isalpha()) # False
print('hello你好一二三'.isalpha()) # True
print('hello你好Ⅷ'.isalpha()) # False
print('hello你好壹贰叄'.isalpha()) # True
print('-'*40)
# isalnum()所有字符都是数字或字母
print('hello你好'.isalnum()) # True
print('hello你好123'.isalnum()) # True
print('hello你好一二三'.isalnum()) # True
print('hello你好Ⅷ'.isalnum()) # True
print('hello你好壹贰叄'.isalnum()) # True
print('-'*40)
# 判断字符的大小写
print('HelloWorld'.islower()) # False
print('helloworld'.islower()) # True
print('hello你好'.islower()) # True
print('HelloWorld'.isupper()) # False
print('HELLOWORLD'.isupper()) # True
print('HELLO你好'.isupper()) # True
print('-'*40)
# istitle()首字母大写
print('Hello'.istitle()) # True
print('HelloWorld'.istitle()) # False W不该大写
print('Helloworld'.istitle()) # True
print('Hello World'.istitle()) # True
print('Hello world'.istitle()) # False w该大写
print('-'*40)
# isspace()判断是否都是空白字符
print('\t'.isspace()) # True
print(' '.isspace()) # True
print('\n'.isspace()) # True
5.1.5 字符串的处理
5.1.5.1 拼接
- 使用
str.join()方法进行拼接字符串 - 直接拼接
- 使用格式化字符串进行拼接
s1='hello'
s2='world'
# (1)使用+进行拼接
print(s1+s2)
# (2)使用字符串的join()方法
print(''.join([s1,s2])) # 使用空字符串进行拼接
print('*'.join([s1,s2])) # 将每个值中间用*连接
print('你好'.join([s1,s2])) # 将每个值中间用 你好 连接
# (3)直接拼接
print('hello''world') #直接写在一起
# (4)使用格式化字符串进行拼接
print('%s%s' % (s1,s2))
print(f'{s1}{s2}')
print('{0}{1}'.format(s1,s2))
5.1.5.2 去重
s='helloworldheloaqaqaq'
# (1)字符串拼接not in
new_s=''
for item in s:
if item not in new_s:
new_s+=item # 拼接操作
print(new_s) # helowrdaq
# (2)索引+not in
new_s2=''
for i in range(len(s)):
if s[i] not in new_s2:
new_s2+=s[i] # 拼接操作
print(new_s2) # helowrdaq
# (3)通过集合去重+列表的排序操作
new_s3=set(s)
lst=list(new_s3)
print(lst) # ['w', 'e', 'o', 'd', 'q', 'h', 'a', 'r', 'l']
lst.sort(key=s.index)
print(''.join(lst)) # helowrdaq
5.2 正则表达式
元字符：
- 具有特殊意义的字符
- 例如：“^”和“$”分别表示匹配的开始和结束
| 元字符 | 描述说明 | 举例 | 结果 |
|---|---|---|---|
| . | 匹配任意字符（除\n） | p\nytho\tn | p、y、t、h、o、\t、n |
| \w | 匹配字母、数字、下划线 | python\n123 | p、y、t、h、o、n、1、2、3 |
| \W | 匹配非字母、数字、下划线 | python\n123 | \n |
| \s | 匹配任意空白字符 | python\t123 | \t |
| \S | 匹配任意非空白字符 | python\t123 | p、y、t、h、o、n、1、2、3 |
| \d | 匹配任意十进制数 | python\t123 | 1、2、3 |
限定符：
- 用于限定匹配的次数
| 限定符 | 描述说明 | 举例 | 结果 |
|---|---|---|---|
| ? | 匹配前面的字符0次或1次 | colou?r | 可以匹配color或colour |
| + | 匹配前面的字符1次或多次 | colou+r | 可以匹配colour或colouu...r |
| * | 匹配前面的字符0次或多次 | colou*r | 可以匹配color或colouu...r |
| {n} | 匹配前面的字符n次 | colou{2}r | 可以匹配colouur |
| {n,} | 匹配前面的字符最少n次 | colou{2,}r | 可以匹配colouur或colouuu...r |
| {n,m} | 匹配前面的字符最小n次，最多m次 | colou{2,4}r | 可以匹配colouur或colouuur或colouuuur |
| 区间字符[] | 匹配[]中所指定的字符 | [.?!] [0-9] | 匹配标点符号点、问号、感叹号 匹配0、1、2、3、4、5、6、7、8、9 |
| 排除字符^ | 匹配不在[]中指定的字符 | [^0-9] | 匹配除0、1、2、3、4、5、6、7、8、9的字符 |
| 选择字符 I (竖线) | 用于匹配 I 左右的任意字符 | \d{18}I\d{15} | 匹配15位身份证或18位身份证 |
| 转义字符 | 同python中的转义字符 | \ . | 将.作为普通字符使用 |
| [\u4e00-\u9fa5] | 匹配任意一个汉字 | ||
| 分组 ( ) | 改变限定符的作用 | sixIfourth (sixIfour)th | 匹配six或foueth 匹配sixth或fourth |
5.3 re模块
- python中的内置模块
- 用于实现python中的正则表达式操作
| 函数 | 功能描述 |
|---|---|
| re.match(pattern,string,flags=0) | 用于从字符串的开始位置进行匹配，如果起始位置匹配成功，结果为Match对象，否则结果为None |
| re.search(pattern,string,flags=0) | 用于在整个字符串中搜索第一个匹配值，如果匹配成功，结果为Match对象，否则结果为None |
| re.findall(pattern,string,flags=0) | 用于在整个字符串搜索所有符合正则表达式的值，结果是一个列表类型 |
| re.sub(pattern,string,flags=0) | 用于实现字符串中对指定子串的替换 |
| re.split(pattern,string,flags=0) | 字符串中的split()方法功能相同，都是分隔字符串 |
5.3.1 re模块中的match函数
import re # 导入
pattern='\d.\d+' # 模式字符串 +限定符，\d 0-9数字出现1次或多次 含义是：数字.数字...
s='I study python 3.11 every day' # 待匹配字符串
match=re.match(pattern,s,re.I) # 用pattern规则在s中查找 re.I意思是忽略大小写
print(match) # None
s2='3.11python I study every day'
match2=re.match(pattern,s2)
print(match2) # <re.Match object; span=(0, 4), match='3.11'>
print('匹配值的起始位置：',match2.start())
print('匹配值的结束位置：',match2.end())
print('匹配区间的位置元素：',match2.span())
print('待匹配的字符串：',match2.string)
print('匹配的数据：',match2.group())
5.3.2 re模块中的search函数
import re # 导入
pattern='\d.\d+'
s='I study python 3.11 every day python2.7 i love u'
match=re.search(pattern,s)
print(match) # <re.Match object; span=(15, 19), match='3.11'> 3.11找到了，2.7没找
s2='4.10python I study every day'
match2=re.search(pattern,s2)
print(match2) # <re.Match object; span=(0, 4), match='4.10'>
s3='python I study every day'
match3=re.search(pattern,s3)
print(match3) # None
print(match.group()) # 3.11
print(match2.group()) # 4.10
# findall()在整个字符串中查找所有
lst=re.findall(pattern,s)
lst2=re.findall(pattern,s2)
lst3=re.findall(pattern,s3)
print(lst) # ['3.11', '2.7']
print(lst2) # ['4.10']
print(lst3) # []
5.3.4 re模块中的sub函数和split函数
import re # 导入
pattern='黑客|破解|反爬'
s='我学python是为了破解一些vip视频，py可以无底线反爬吗'
new_s=re.sub(pattern,'XXX',s)
print(new_s) # 我学python是为了XXX一些vip视频，py可以无底线XXX吗
s2='https://cn.bing.com/search?q=iop&qs=n&fo'
pattern2='[?|&]'
lst=re.split(pattern2,s2) # 用pattern2的规则去到s2进行拆分
print(lst) # ['https://cn.bing.com/search', 'q=iop', 'qs=n', 'fo']
章节习题
习题1：车牌归属地
需求：使用列表存储N个车牌号码，通过遍历列表及字符串的切片操作判断车牌的归属地
lst=['京A8888','京A1111','沪A6666']
for item in lst:
area=item[0:1]
print(item,'归属地为',area)
习题2：统计指定字符出现的次数
需求：声明一个字符串，内容为“HelloPython,HelloJava,hellophp”用户从键盘录入要查询的字符（部分大小写），要求统计出要查找的字符在字符串中出现的次数
s='HelloPython,HelloJava,hellophp'
word=input('请输入要统计的字符的大写形式：')
print('{0}在{1}一共出现了{2}次'.format(word,s,s.upper().count(word))) # upper()都转成大写
习题3：格式化输出商品信息
需求：使用列表存储一些商品数据，使用循环遍历输出商品信息，要求对商品的编号进行格式化为6位，单价保留2位小数，并在前面添加人民币符号输出
lst = [
['01', '电风扇', '美的', '100'],
['02', '洗衣机', 'TCL', '1000'],
['03', '微波炉', '小熊', '400']
]
print('编号\t\t名称\t\t\t品牌\t\t单价')
for item in lst:
for i in item:
print(i,end='\t\t')
print() # 换行
# 格式化
for item in lst:
item[0] = '0000' + item[0]
item[3] = '￥{0:.2}'.format(item[3]) # 连接上索引为3的字符且保留两位小数
# 遍历输出
print('编号\t\t\t名称\t\t\t品牌\t\t单价')
for item in lst:
for i in item:
print(i,end='\t\t')
print() # 换行
习题4：使用正则表达式提取图片网址
需求：从给定的文本中使用正则表达式提取出所有的图片链接地址
运行效果：
import re
s='"queryEnc":"%c3%C0%C5%AE","queryExt":"美女”,"listNum":1726,"displayNum":1102160,"gsm":"3c","bdFmtDispNum" :"丝1,100,000","bdsearchTime":"","isNeedAsyncRequest":8,"bdIsclustered":"1","data":[{ "adType" :"g""hasAspData":"0","thumbuRl":"https:/img1,baidu.com/it/u=272155668,1962283813&fm=26&fmt=auto","commoditvInfo":null"iscommodity":0,"middleURL":"https://img1,baidu.com/it/u=272155668,1962283813&fm=26&fmt=auto"shituToken":"aadb3a","largeTnImageUrl":"，"hasLarge":0,"hoverURL":"https://img1.baidu.com/it/u=272155668,1962283813&fm=26&fmt=auto", "pageNum":30, "objURL":"ipprf z2C$qAzdH3FAzdH3F2t42d z&e3Bkwt17z&e3Bv54AzdH3Ft4w2j fjw6viAzdH3Ff6v=ippr%nA%dF%dFetn z&e3Bxt78dn z&e3Bvg%dfstei%dFda81%dFam%dFd1%dF88%df8ande8cm80banenllalnba80 z&e3B3r2&6jui6=ippr%nA%dF%dFetn z&e3Bxt78dn z&e3Bvg&wrr=daad&ftzj=u1111,8aaaa&g=wba&g=a82=ag&u4p=3rj2?fjv=8m9abc98cd&p=an8vwcw9v9jl1nm88jdllww8dmuwnvvn""fromURL":"ippr z2C"fromJumpUrl":"ippr z2C$GAzdH3FAzdH3Fe z&e3Bm z&e3BvgAzdH3Fr65utsiAzdH3FowpviMtgt z&e3Brir?et1=m8adm8"$qAzdH3FAzdH3Fe z&e3Bm z&e3BvgAzdH3Fr65utsjAzdH3FowpviMtgt z&e3Brir?et1=m8adm8","fromURLHost":"v.6.cn","width":800，"height":600,"type":"jpg""currentIndex"."""is gif":0,"iscopyright":0,"resourceInfo":null,"is":"@ 日""strategyAssessment":"3141544242 1243 0 0""filesize":"""bdSrcType":"@"."di":"157630"，"pi":“""imgcollectionword":"","hasThumbData" :"""bdSetImgNum":0,"partnerId":0,"spn":0,"bdImgnewsDate":"2020-06-0302:31","fromPageTitle":"美女</strong>热舞"，"fromPageTitleEnc":"美女热舞","bdSourceName":"""bdFromPageTitlePrefix":"""isAspDianiing":0，null,"face info":null,"xiangshi info":null,"adpicId":"0","source type":""},{ "adType":"0", "hasAspData":"0","thumbuRL":"https://img0.baidu.com/it/u=1934854801,2871685401&fm=253&fmt=auto&app=138&f=JPEG?W=508&h=313","commodityInfo":nul1,"iscommodity":0,"middleURl":"httos://img8.baidu.com/it/u=1934854801,2871685401&fm=253&fmt=auto&app=138&f=JPEG?W=500&h=313","shituToken":"9bb791","largeTnImageurl"."""hasLarge" :0, "hoverURl":"https://img,baidu,com/it/u=1934854801,28716854018fm=253&fmt=uto&apD=138&f=JPEG?W=50B&h=313", "pageNum":31,"obiURL":"ipprf z2C$9AZdH3FAzdH3F2t42d z&e3Bkwt17 2&e3Bv54AzdH3Ft4w2i fiw6viAzdH3Ff6v=ippr%nA%dF%dFt42 2&e3B33da z&e3Bv54%df7r%dfwsst42%dF8889%dfac8dd8as1n1%dFd8ac8dasIn1-d-8daa z&e3B3r2&6juj6=ippr%nA%dF%dft42 &e3833da &e3Bv54&wrr=daad&ftzi=ul111,8aaaa&g=wba&g=a&2=ag&u4p=3ri2?fiv='
pattern='https://img\d{1}.baidu.com/it/u=\d*,\d*&fm=\d*&fmt=auto' # 模式字符串
lst = re.findall(pattern,s) # 使用pattern模式到s中查找，赋值给lst列表
for item in lst:
print(item) # 输出
