第一个python程序：
新建目录—>新建python文件
😸了解IPO编程方法
print基本的输出函数
语法结构：
print（内容）
print()函数完整的语法格式：
print(value,...,sep='',end='\n',file=None)
sep叫分隔符
- 1.输出字符串
print('北京欢迎你！')#支持单引号，双引号，三引号
print("北京欢迎你！")
print('''北京欢迎你!''')
print("""北京欢迎你!""")
- 2.不换行输出直接加逗号即可
print(a,b,"可乐加汉堡")
- 3.python还可以通过ASCII码值去显示字符串，用到的是python中的内置函数chr（）
它会将98转成所对应的字符（通过chr函数）
chr（）括号里是ASCII值
- 4.使用print输出中文Unicode码（内置函数是ord）
（中文编码的范围是u4e00~u9fa5）
- 5.使用print函数将内容输出到文件（需要使用内置函数open）
fp=open('note.txt','w')#w,write 打开文件
print("北京欢迎你",file=fp)#把这段文字放到文件里
fp.close()#关闭文件
#程序目的：将"北京欢迎你"写入（输出）文件note.txt中
- 6.多条print函数输出，结果一行输出
这个操作的原因是因为print函数的完整语法结构中包含换行符
第一个print的结束由-->替换，而第二个print未作处理，所以下面默认还是有换行符的
- 7.使用连接符来连接两个字符串（就是加号+）
print('北京'+'欢迎你')
#必须是加号两者中间才没有空格，逗号的话默认是空格
#连接只能是字符串和字符串相连
文件
input基本的输入函数
语法结构：
x=input('提示文字')
无论你输入的数据是什么，x的数据类型都是字符串类型
- 所以如果想输入整数类型的话，就需要用内置函数int，将字符串类型转为整数类型
解决方法就是把+加号，改成逗号，意思是在同一行输出
num=input('请输入你的幸运数字：')
print('我的幸运数字是：'+num)#这里的num正常输入，是字符串类型
num=int(num)
print('你的幸运数字是',num)
😸Python中的注释
#中文文档声明（必须写在第一行）
# coding=utf-8
#单行注释
'''
三引号为多行注释
蒽
'''
"""
三个双引号也可以，颜色不同但效果一样
"""
😸数据类型
保留字
import keyword
print(keyword.kwlist)#关键字严格区分大小写
print(len(keyword.kwlist))#计算个数
标识符
————————
变量与常量
- 如果想修改变量的数据类型和值，直接赋值不同类型即可，因为python动态修改变量的数据类型
- 如果想检查是什么数据类型，只需print里写
type（变量名） - python中支持，多个变量指向同一个值，例如
no=num=100，两个等式 - 查看对象的内存地址用内置函数id，例如
print(id(no))
数值类型
整数类型
浮点数类型
round（0.1+0.2，1），可以保留一位小数（逗号后写几，就保留几位）
字符串类型
- 在转义字符之前加上大写或小写的r，转义字符会失效
- 利用索引切片（中间是冒号，包前不包后，用中括号）
x='2022年'
y='北京冬奥会'
print(x+y)
print(x*10)
print(10*x)
print('北京'in y)
print('扬州'in y)
结果是
2022年北京冬奥会
2022年2022年2022年2022年2022年2022年2022年2022年2022年2022年
2022年2022年2022年2022年2022年2022年2022年2022年2022年2022年
True
False
布尔类型
数据类型之间的转换
类型转换包括隐式转换和显式转换
下列是显式转换
| 函数 | 描述说明 |
|---|---|
| int（x） | 将x转换为整数类型 |
| float（x） | 将x转换为浮点类型 |
| str（x） | 将x转成字符串 |
| chr（x） | 将整数x转换为一个字符 |
| ord（x） | 将一个字符x转换为其对应的整数值 |
| hex（x） | 将一个整数x转换为一个十六进制的字符串 |
| oct（x） | 将一个整数x转换为一个八进制字符串 |
| bin（x） | 将一个整数x转换为一个二进制字符串 |
eval函数（Python内置函数）
- 用于去掉字符串最外侧的引号，并按照python语句方式去掉引号后的字符串
- 经常和input（）函数一起使用
- 也是一种类型转换函数
语法格式：
变量=eval（字符串）
应用
s='3.14+3'
print(s,type(s))
x=eval(s)#使用eval函数去掉s这个字符串中左右的引号
#去掉引号也就是说执行了加法运算
print(x,type(x))
结果是
3.14+3 <class 'str'>
6.140000000000001 <class 'float'>
- 常与input（）连用，用于获取用户输入的数值
age=eval(input('请输入您的年龄'))#将字符串类型转成了int类型
#相当于int（age）
print(age,type(age))
结果是：
请输入您的年龄18
18 <class 'int'>
字符串也可以用eval
hello='邯郸欢迎你'
print(hello)
print(eval('hello'))
#两个print结果一样
#但是下面这种写法不可以
#因为用了eval后去了引号就变成了变量，而你程序中并没有这个变量
print(eval(邯郸欢迎你))
😸运算符（算术、赋值、比较、逻辑）
算术运算符
print('加法',1+1)
print('减法',1-1)
print('乘法',2*3)
print('除法',10/2)
print('整除',10//3)
print('取余',10%3)
print('幂运算',2**4)#2的四次方
#直接会算出来
优先级：
- 第一级：**
- 第二级：*、/、%、//
- 第三级：+、-
赋值运算符
Python支持链式赋值
a=b=c=100
Python还支持系列解包赋值
a,b=10 20
系列解包赋值还可以交换两数值
a,b=b,a
逻辑运算符
and 逻辑与 从左到右
or 逻辑或 从左到右
not 逻辑非 从右到左
位运算符（转二进制）
把数字看作二进制数来进行计算的
分为 按位与 、 按位或 、 按位异或 、按位取反
按位与&
使二进制一一对齐后，只有两位都是1结果才是1
按位或|
只要有一个是1，那就是1
按位异或^
两个位置上的数相同，就是0
有一个是1，那就是1
按位取反~（只有一个操作数）
1、0变换
print('按位与运算',12&8) #结果是8
print('按位或运算',4|8) #结果是12
print('按位异或',31^32) #结果是63
print('位取返',~123) #结果是-124
左移位<<
就是将一个二进制数向左移动指定的位数，左边（高位端）溢出的位被舍弃。右边（低位端）的空位用0补充
右移位>>
是将一个二进制数向右移动指定的位数，右边溢出的位被舍弃，左边的空位端
- 如果最高位是0（正数）则左侧空位补0；
- 如果最高位是1（负数），左侧空位补1
print('左移位：',2<<2)#8 2*2*2
print('左移位：',2<<3)#16 2* 2*2*2
print('右移位',8>>2) #2 8/2/2
print('右移位',-8>>2)#-2 -8/2/2
总结就是左乘右除
运算符的优先级
| ** | 幂运算 |
| ~、+、- | 取反、正负号 |
| 乘、/、%、// | 算术运算符 |
| +、- | |
| <<、>> | 位运算符 |
| & | |
| 尖角号^ | |
| I | |
| <、<=、>、>=、！=、== | 比较运算符 |
| = | 赋值运算符 |
🫠程序的流程控制
1.程序的描述方式（三种）
- 自然语言（用人类语言 直接描述）
- 流程图
- 伪代码（介于自然语言和编程语言之间的一种算法描述语言）
2.程序的组织结构：顺序、选择（分支）、循环
选择（分支）结构
1. 单分支结构
if 表达式：
语句块
- （表达式后面是冒号）
- Tip：使用if语句时，如果语句块中只有一句代码，可以将语句块直接写在冒号后
2. 双分支结构
number=eval(input('请输入您的号码'))
if number==12345:
print('恭喜您中奖')
else:
print('很遗憾')
但是这里可以再简化一下
意思是：把这句话直接赋值给result
又或者：直接print打印
number=eval(input('请输入您的号码'))
result='恭喜中奖'if number==12345 else'很遗憾'
print(result)
print('恭喜中奖'if number==12345 else'很遗憾')
3. 多分支结构
if...elif...else
当表达式结果都为false时，会执行else语句，所以else语句并不是必须的
4. match...case
python中代替switch的是模式匹配 match...case
score=input('请输入你的成绩')
match score:
case 'A':
print('优秀')
case 'B':
print('良好')
case 'C':
print('合格')
循环结构
在Python中循环结构分两类
- 1.遍历循环结构for，
for 循环变量 in 遍历对象:
- 还有一个是for...else
- 它这里面的else只有在for循环正常进行完之后才会执行。但是如果for没有正常执行完比如遇到break，那么就不会执行else语句
range()函数，产生一个（n，m）的整数序列，包前不包后
- 2.无限循环结构while
四个步骤：
- 初始化变量、条件判断、语句块、改变变量
- 同时也有while...else结构
s=0
i=1 # 1.初始化变量
while i<=100:# 2.条件判断
s+=i # 3.语句块
i+=1 # 4.改变变量
else:
print('累加和为：',s)
案例
1. 使用while循环模拟用户登录，且只有三次机会
i=0
while i<3:#执行三次0、1、2
user_name=input('请输入你的用户名：')
pwd=input('请输入你的密码')
if user_name=='phy' and pwd=='11111':
print('系统正在登录中...')
i=8 # 用户名正确时的改变变量
else:
if i<2:
print('输入错误，您还有',2-i,'次机会')
i+=1 # 用户名不正确的时候的改变变量
if i==3:
print('三次都错误')
2. 嵌套循环打印星号图形
# 长方形
for i in range(1,4):
for j in range(1,5):
print('*',end='')
print()
————————————————————————————
# 三角
for i in range(1,6):
for j in range(1,i+1):
print('*',end='')
print()
————————————————————————————
#倒三角
for i in range(1,6):
for j in range(1,7-i):
print('*',end='')
print()
————————————————————————————
#等腰三角形
for i in range(1,6):
for j in range(1,6-i):
print(' ',end='')
for k in range(1,i*2):
print('*',end='')
print()
————————————————————————————
#菱形(只有奇数行才能打印出菱形)
row=eval(input('请输入菱形的行数'))
if row%2==0:
print('重新输入')
row=eval(input('请输入菱形的行数'))#现在假设为7
#------上半部分
top_row=(row+1)//2 #(7+1)/2
for i in range(1,top_row+1):
for j in range(1,top_row+1-i):
print(' ',end='')
for k in range(1,i*2):
print('*',end='')
print()
#------下半部分
bottom_row=row//2
for i in range(1,bottom_row+1):
for j in range(1,i+1):
print(' ',end='')
for k in range(1,2*bottom_row-2*i+2):
print('*',end='')
print()
————————————————————————————
#空心菱形（只需加一个判断：只有在第一个和最后一个时才打印星号，不然就打印空格）
row=eval(input('请输入菱形的行数'))
if row%2==0:
print('重新输入')
row=eval(input('请输入菱形的行数'))#现在假设为7
#------上半部分
top_row=(row+1)//2 #(7+1)/2
for i in range(1,top_row+1):
for j in range(1,top_row+1-i):
print(' ',end='')
for k in range(1,i*2):
if k==1 or k==i*2-1:
print('*',end='')
else:
print(' ',end='')#空格而不是空字符串
print()
#------下半部分
bottom_row=row//2
for i in range(1,bottom_row+1):
for j in range(1,i+1):
print(' ',end='')
for k in range(1,2*bottom_row-2*i+2):
if k==1 or k==2*bottom_row-2*i+2-1:
print('*',end='')
else:
print(' ',end='')
print()
3.程序的跳转语句：break或者continue
- break 用于跳出（退出）循环，通常与if一起搭配
s=0
i=1
while i<11:
s+=i
if s>20:
print('累加和大于20的数是：',i)
break
i+=1
- 用break来代替上用户名案例中通过改变变量的方式
i=0
while i<3:#执行三次0、1、2
user_name=input('请输入你的用户名：')
pwd=input('请输入你的密码')
if user_name=='phy' and pwd=='11111':
print('系统正在登录中...')
break
else:
if i<2:
print('输入错误，您还有',2-i,'次机会')
i+=1 # 用户名不正确的时候的改变变量
else:
print('三次都错误')
- continue 用于跳过本次循环的后续代码，而继续执行下一次循环的操作
s=0
i=1
while i<=100:
if i%2==1:
i+=1
continue
s+=i
i+=1
print('1-100之间的偶数和为：',s)
4.空语句 pass
python的保留字，在语法结构中只起到占位符的作用，使语法结构完善，不报错
猜数例子
产生随机数的random内置函数
#产生随机数
import random
rand=random.randint(1,100)#包含1也包含100
#产生随机数
import random
rand=random.randint(1,100)#包含1也包含100
#——————————————循环步骤```````
count=1 #记录猜数次数，循环初始化
while count<=10:
number=eval(input('有一个数，在1~100，请你猜一猜：'))
if number==rand:
print('猜对了')
break
elif number>rand:
print('大了')
elif number<rand:
print('小了')
count+=1
if count<=3:
print('恭喜，你一共猜了',count,'次')
elif count<=6:
print('还可以，你一共猜了',count,'次')
else:
print('继续努力，你一共猜了',count,'次')
🫠组合数据类型
- 序列和索引
- 列表（有序序列）（可变数据类型）
- 元组（有序序列）（不可变）
- 字典（无序）（可变）
- 集合(无序)（可变）
序列：
一个用于存储多个值的连续空间，每个值都对应一个整数的编号，称为索引
操作1：切片
- 省略开始位置的话，默认是从0开始
- 步长不写默认是1、
- 省略结束位置，默认是最后
- 省略开头和结尾，只写步长，就是默认就是在全部里切，且步长为2
操作2：相加、相乘
tip：字符串属于序列的一种
s='hello'
s2='world'
print(s+s2)
print(s*5)
print('-'*40)
操作n
这里面min和max的判断是按照ASCII码值来计算的
1.列表：
是序列的一种，所以对序列的操作符、运算符、函数均可以使用
列表的创建方式
用法：
enumerate函数，枚举
- 可以的得到序号和元素
- 可用于列表的遍历操作
列表遍历操作的三种方式:
lst=['hello','world',111,222]
# 使用for循环
for item in lst:
print(item)
# for循环+函数
for i in range(0,len(lst)):
print(i,lst[i])
# 使用enumerate（）函数
for index,item in enumerate(lst):
print(index,item)
#index在这里表示序号，而不是索引，并且可以手动设置序号起始值
#start也可以省略，直接写1
for index, item in enumerate(lst,start=1):
print(index, item)
列表的相关操作（增删改查）
列表的增删改查并不改变原列表的地址
tip：如果需要查元素的地址，只需 id（元素名） 即可
列表排序的两种方法
排序是在原列表的基础上排序的，并不会产生新的列表
- 列表对象的sort方法
lst.sort(key=None,reverse=False)
其中key代表排序的规则，reverse代表排序方式（默认为升序）
- 内置函数sorted（）
sorted（iterable。key=None，reverse=False）
内置函数的方式不会改变原列表，因为会产生新的列表
其中iterable代表的是排序的对象
- 字符串升降序比的是ASCII值
- 当然也可以自己指定排序规则，比如：忽略大小写进行比较（str.lower就是都转成小写）
lst=[4,56,3,78,20,56,89]
print('原列表',lst)
#排序，默认是升序
lst.sort()
print('升序',lst)
#降序
lst.sort(reverse=True)
print('降序',lst)
#————————————————————————————
# 内置函数的方式
asc_lst=sorted(lst)
print('升序',asc_lst)
print('原列表',lst)# 原列表没有任何改变
列表的生成式
即（expression即你列表中每个元素形式）
一维列表、二维列表
#——————————————————一维列表
import random\
#
lst=[random.randint(1,100) for _ in range(10)]
print(lst)
#从列表中选择符合条件的元素组成新的列表
# 下面这个可以筛选出偶数
lst=[i for i in range(10) if i%2==0]
print(lst)
#——————————————————二维列表（表格数据）
lst=[
['汉堡','可乐','沙拉酱'],
['草莓','西瓜','哈密瓜'],
['茄子','包子','烤冷面']
]
print(lst)
for row in lst:
for item in row:
print(item,end='\t')
print()
2.元组类型：
- 不可变序列，没有增删改查的操作
- 只能用索引获取元素或者用for遍历元素
- 可以使用判断操作
- 如果元组中只有一个数，逗号也不可省略，要写成比如t=（10，）
操作n
元组的遍历与访问
- 元组的遍历与列表相同，用for循环
- 根据索引访问元素
- 元组也可以执行切片操作
t=(1,2,3)
#
for item in t:
print(item)
#
for i in range(len(t)):#在len这里我们省略了起始start
print(i,t[i])
# 使用enumerate
for index,item in enumerate(t):
print(index,'--->',item)
元组的生成式
元组也有生成式，不过它的结果是一个生成器对象，它需要转成一个元组或者列表我们才可以看到内容
#生成式
t=(i for i in range(1,4))
print(t)
t=tuple(t)# 关键一步转元组，没有这一步得到的只是一个生成器对象
print(t)
#把生成式遍历
for item in t:
print(item)
--next-- 方法
元组和列表的区别
3.字典类型：
是根据一个信息查找另一个信息的方式构成了“键值对”，它表示索引用的键和对应的值构成的成对关系
- 可变数据类型，具有增删改等的操作
- 与列表不同的是，字典中的元素是无序的，所以你第一个添加到字典中的元素并不一定就是在第一位的
- 并且字典中的键要求必须唯一，不能重复；但是值是可以重复的
- 但是如果你写的时候键重复了，那么后面的会覆盖代替前面的
- 要求字典中的键是不可变序列，所以哪些可以作为键呢？整型、字符型、浮点型、元组...都可以，
字典类型的创建方式
映射的结果是一个对象，你看不到实际内容
所以你如果想看到内容，你可以把它转成列表或者字典（一般都是字典）（并且只能选一个，不能都写）
lst1=[10,20,30,40]
lst2=['cat','dog','pet','zoo','car']
zipobj=zip(lst1,lst2)
print(zipobj) # 这时候打印是个对象，看不到内容
#转成列表
#print(list(zipobj))
#转成字典
d=dict(zipobj)
print(d)
第三种创建字典的方式（用参数）
d=dict(cat=10,dog=20)
print(d)
字典的取值（访问）和遍历
- 在取值上两种方式也有区别，如果你访问的这个key不存在，那么d[key]会报错，但是d.get[key]不会报错，而是得到一个None
字典的相关操作方法
添加就是直接d.[]=''
字典的生成式
4.集合类型：
集合的创建方式
- 如果你直接使用花括号创建
s={}，那么创建的就是字典而不是集合 - 如果你想创建集合：
s=set（）用内置函数
集合类型的操作符
集合的相关操作方法
集合的遍历和生成式
#普通遍历
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)
几种数据类型区别
🫠Python 3.11新特性
- 结构模型匹配（match...case）
- 字典合并运算符 |
- 同步迭代
最后这个case_相当于else，就是别的都不匹配那就走这个
# 同步迭代
fruits=['apple','orange','pear','grape']
counts=[10,3,4,5]
for f,c in zip(fruits,counts):
match f,c:
case 'apple',10:
print('10个苹果')
case 'orange',3:
print('3个橘子')
case 'pear',4:
print('4个梨')
case 'grape',5:
print('5串葡萄')
结果是：
10个苹果
3个橘子
4个梨
5串葡萄
🤖易错
🤖实战
千年虫是什么虫
lst=[88,89,90,98,0,99]
print('原列表：',lst)
# 1.for
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)
# 2.enumerate
for index,value in enumerate(lst):
if str(lst[index])!='0':
lst[index]='19'+str(value)
else:
lst[index] = '200' + str(value)
print(lst)
模拟京东的购物流程
#首先创建一个空列表，用来存储入库的商品信息
#1.入库
lst=[]
for i in range(5):
goods=input('请输入商品的编号和名称进行商品入库：')
lst.append(goods)
#2.展示商品（遍历）
for item in lst:
print(item)
#3.创建一个空列表，用来存储购物车里面的商品
#当我输入q时结束,不然一直循环，所以选用无限循环while
cart=[]
while True:#意思就是一直去执行
flag=False #代表没有商品的情况
num=input('请输入你要购买的商品编号：')
#4.遍历商品列表用来查询商品是否存在
for item in lst:
if num==item[0:4]:# 从商品中切出序号，进行比较
flag=True #代表商品已找到
cart.append(item)
print('商品已成功添加入购物车')
break #退出的是这个for循环
if not flag and num!='q':#not flag也可以写成flag==False
print('商品不存在')
if num=='q':
break #退出的是while
print('-'*56)
print('购物车里已选择的商品为：')
cart.reverse()
for item in cart:
print(item)
模拟12306火车票订票流程
#创建字典用于存储车票信息，使用车次作为key，使用其他信息作为value
dict_ticket={
'G1111':['北京南-天津南','18:06','18:39','00:33'],
'G2222':['北京南-天津南','18:15','18:49','00:34'],
'G3333':['北京南-天津西','18:20','18:53','00:36'],
'G4444':['北京南-天津东','18:40','19:30','00:54']
}
print('车次 出发地-到达站 出发时间 到达时间 历时时长')
#遍历字典中的元素
for key in dict_ticket.keys():
print(key,end='\t')#为什么不换行，因为车次和车次的详情信息在一行显示
for item in dict_ticket.get(key): #根据key获取值
print(item,end='\t\t')
print()
train_number=input('请输入要购买的车次：')
#根据key获取值
info=dict_ticket.get(train_number,'车次不存在')#info是一个列表类型
# 判断车次是否存在
if info!='车次不存在':
person=input('请输入乘车人，如果是多位请用逗号分割：')
s=info[0]+' '+info[1]+' '+'开'
print('您已购买了'+train_number+' '+s+'请'+person+'尽快换取纸质车票，【铁路客服】')
else:
print('对不起，车次不存在')
模拟手机通讯录
s=set()
i=1
for i in range(1,6):
#关键f
info=input(f'请输入第{i}位好友的姓名和手机号码:')
s.add(info)
for item in s:
print(item)
🐥字符串
常用操作
- replace第三个参数为替换次数，默认为全部替换
- strip（）括号里不写，默认就是左右全部空格都去掉，但是如果括号里写了字符串，那就是是只去掉指定字符串
格式化字符串的三种方法
# 使用占位符进行格式化
name='马里奥'
age=18
score=98.5
print('姓名：%s，年龄：%d,成绩：%.1f' %(name,age,score))
#f-string
print(f'姓名：{name},年龄：{age},成绩{score}')
#使用字符串format方法
print('姓名：{0}，年龄：{1}，成绩：{2}'.format(name,age,score))
format详解
s='helloworld'
print('{0:*<20}'.format(s))#字符串的显示宽度为20，左对齐，空白部分使用*填充
#千位分隔符（也就是三位一个逗号）
print('{0:,}'.format(987654321))
#精度
print('{0:.2f}'.format(3.1415926))
#最大显示长度(与上面精度相比，没有写f)
print('{0:.5}'.format('helloword'))
#整数类型
a=425
print('二进制：{0:b},十进制{0:d}，八进制{0:o}，十六进制{0:X}'.format(a))
#浮点数类型
b=3.1415926
print('{0:.2f},{0:.2E},{0:.2e},{0:.2%}'.format(b))
#3.14,3.14E+00,3.14e+00,314.16
字符串的编码与解码
- str转成bytes，叫做编码
- bytes类型转成str类型去显示，叫做解码
- 默认是utf-8，中文占3个字节；gbk中文占2个字节
数据的验证
字符串的拼接（数据的处理）
- 使用str.join()方法进行拼接字符串
- 直接拼接
- 使用格式化字符串进行拼接
s1='hello'
s2='world'
# 1.使用加号+拼接
print(s1+s2)
# 2.使用字符串的join（）方法
#指定空字符串进行拼接
print(''.join([s1,s2]))#把s1和s2放到列表，那么它就会对列表里的元素进行拼接
# 3.直接拼接
print('hello' 'world')
# 4.使用格式化字符串进行拼接
print('%s%s' % (s1,s2))
print(f'{s1}{s2}')
print('{0}{1}'.format(s1,s2))
字符串的去重操作
s='hellohelloworld'
#字符串
new_s=''
for item in s:
if item not in new_s:
new_s+=item
print(new_s)
#索引
new_s2=''
for i in range(len(s)):
if s[i] not in new_s2:
new_s2+=s[i]
print(new_s2)
#通过集合去重（无序）+列表排序
#用集合去重是因为，集合有要求，其中元素不能重复
new_s3=set(s)
lst=list(new_s)#转成列表类型
lst.sort(key=s.index)
print(''.join(lst))
🐥正则表达式（特殊的字符串）
字符
元字符
限定符
其他字符
re模块
内置模块，用来实现正则表达式
写之前先要导入reimport re
match
import re
pattern='\d.\d+'
s='I study Python 3.12 everyday'
match=re.match(pattern,s,re.I)
print(match)#None
s2='3.12 I study Python everyday'
match2=re.match(pattern,s2)
print(match2)#<re.Match object; span=(0, 4), match='3.12'>
print('匹配的起始位置：',match2.start()) #0
print('匹配的结束位置：',match2.end()) #4
print('匹配区间的位置元素：',match2.span())#(0,4)
print('待匹配的字符串：',match2.string)#3.12 I study Python everyday
print('匹配的数据：',match2.group())#3.12
🤖实战
# 1. 要求根据车牌号，通过切片操作找到其归属地
lst=['京A1111','津B6666','冀C8888']
for i in lst:
area=i[0:1]
print(i,'归属于地',area)
# 2.忽略大小写，查找字符出现次数
word=input('请输入你要统计的字符：')
s='HelloPython,HelloJave,hellophy'
print('{0}在{1}一共出现了{2}次'.format(word,s,s.upper().count(word)))
# 3.格式化输出商品的名称和单价
lst=[
['01','电风扇','美的','500'],
['02', '洗衣机','海尔', '1000'],
['03','微波炉','老板','1500']
]
print('编号\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:.2f}'.format(eval(item[3]))
print('编号\t\t\t名称\t\t品牌\t\t单价')
for item in lst:
for i in item:
print(i,end='\t\t')
print()
🦥异常处理
语法结构
异常关键字：raise
抛出一个异常，从而提醒程序出现了异常情况，程序能够正确地处理这些异常情况
try:
gender=input('请输入你的性别：')
if gender!='男' and gender!='女':
raise Exception('性别只能是男或者女')
else:
print('你的性别是：',gender)
except Exception as e:
print(e)
Python中常见的异常类型
PyCharm的程序调试
1.设置断点——>2.进入调试视图(三种方式)——>3.开始调试
🤖实战
#输入成绩，如果不正确手动抛出异常
# 手动抛出异常用raise
try:
score=eval(input('请输入你的成绩:'))
if 0<score<100:
print('分数为：',score)
else:
raise Exception('分数不正确')
except Exception as e:
print(e)
# 勾股判断三边是否构成三角形（不能的话抛出异常）
try:
a=int(input('请输入第一条边长：'))
b = int(input('请输入第二条边长：'))
c = int(input('请输入第三条边长：'))
if a+b>c and a+c>b and b+c>a:
print(f'三边长为:{a},{b},{c}')
else:
raise Exception(f'{a},{b},{c},不可以构成三角形')
except Exception as e:
print(e)
🐧函数及常用的内置函数
函数的定义及调用
自定义函数格式
def 函数名称（参数列表）：
函数体
[return返回值列表，非必须]
传参方式：
- 位置对应传参
- 关键字传参
在一个调用里，可以既使用位置传参又使用关键字传参
但是要注意，如果这样写的话，必须位置参数在前，关键字参数或者默认值参数在后
比如：
birthday（‘猪猪侠’,age=18）
- 默认值参数
是指在函数定义时，直接对形参进行赋值，在调用时如果该参数不传值，将使用默认值，如果该参数传值，则使用传递的值
- 可变参数
在调用时，前加星号会进行系列解包操作
匿名函数lambda
是指没有名字的函数，这种函数只能使用一次，一般是在函数的函数体只有一句代码且只有一个返回值时，可以使用匿名函数来简化
result=lambda 参数列表：表达式
#只有一句的函数
def calc(a,b):
return a+b
print(calc(10,20))
#匿名函数
s=lambda a,b:a+b
print(type(s))
print(s(10,20))
还可以用于成绩排序：
student_scores=[
{'name':'john','score':87},
{'name':'irene','score':95},
{'name':'lily','score':80},
{'name':'winter','score':100}
]
student_scores.sort(key=lambda x:x.get('score'),reverse=True)
print(student_scores)
递归函数
- 一个完整的递归由两部分组成：递归调用和递归终止条件
- 一般可使用if--else结构来判断递归的调用和递归的终止
斐波那契数列
def fac(n):
if n==1 or n==2:
return 1
else:
return fac(n-1)+fac(n-2)
print(fac(9)) #34
常用的内置函数
数据类型转换函数
int（'3.14'）这种写法在转整型里是不合法的（在字符串中写浮点数）
常用的数学函数
常用的迭代器函数
常用的其他内置函数
format，数值默认右对齐，字符串默认左对齐
print(format(3.14,'20')) #数值默认右对齐
print(format('hello','20')) #字符串默认左对齐
print(format('hello','*<20'))#<左对齐，*表示填充符，20表示显示的宽度
print(format('hello','*^20'))
print(format(3.1415926,'.2f'))#保留两位小数
🤖实战
import random
def get_max(lst):
max=lst[0]
for i in range(1,len(lst)):
if max<lst[i]:
max=lst[i]
return max
lst=[random.randint(1,100) for i in range(10)]#列表生成式
print(lst)
print(get_max(lst))
def get_digit(x):
s=0
lst=[]
for item in x:
if item.isdigit():
lst.append(int(item))
s=sum(lst)
return lst,s
s=input('请输入一个字符串：')
lst,x=get_digit(s) #系列解包赋值
print('提取的数字列表为：',lst)
print('累加和为：',x)
def lower_upper(x):
lst=[]
for item in x:
if 'A'<=item<='Z':
lst.append(chr(ord(item)+32))#ord()将字母转为Unicode值，加上32，chr（）整数转成字符
elif 'a'<=item<='z':
lst.append(chr(ord(item)-32))
else:
lst.append(item)
return ''.join(lst)
s=input('请输入一个字符串：')
print(lower_upper(s))
def get_find(s,lst):
for item in lst:
if s==item:
return True
return False
lst=['hello','world','python']
s=input('请输入你要判断的字符串：')
result=get_find(s,lst)
print('存在' if result else '不存在') # if--else的简写，三目条件运算符
🐇面向对象程序设计
面向过程和面向对象思想的异同
类和对象
类： 是由n多个对象中抽取像的属性和行为从而归纳出来的
在Python中一切皆对象
- 自定义数据类型的语法结构：
class 类名（）：
pass
但是你自定义完之后，目前还是不可以使用，它相当于你绘制了一个图纸，只有你创建对象之后才可以使用，对象是具体的实例
- 创建对象的语法结构
对象名=类名（）
对象名也就是一个变量名
类的组成
创建和调用👇
class Student:
#类属性：直接定义在类中，方法外的变量
school='扬州教育中心'
# 初始化方法，实例属性需要定义在_init_方法中，使用self打点的变量
def __init__(self,xm,age):
self.name=xm #左侧是实例属性，xm是局部变量，将局部变量的值xm赋值给实例属性self.name
self.age=age #实例的名称和局部变量的名称可以相同
#定义在类中的函数，称为方法，且自带参数self
def show(self):
print(f'我叫:{self.name},今年{self.age}岁了')
#静态方法
@staticmethod
def sm():
#self.name()
#self.show()
print('这是一个静态方法，不能调用实例属性，也不能调用实例方法')
#类方法
@classmethod
def cm(cls):
print('这是一个静态方法，不能调用实例属性，也不能调用实例方法')
#创建类对象
stu=Student('phy',18)
#类属性（直接使用类名去打点调用）
print(Student.school)
#实例属性（它使用对象名进行打点调用，而并不是用self）
print(stu.name,stu.age)
#实例方法（使用对象名进行打点调用）
stu.show()
#静态方法（直接使用类名打点调用）
Student.sm()
#类方法（直接使用类名打点调用）
Student.cm()
动态绑定属性和方法
- 每个对象的属性名称相同，但属性值不同
- 可以为某个对象绑定独有的属性或方法
动态绑定属性
动态绑定方法
面向对象的三大特征（封装，继承，多态）
1.封装
python中的权限控制
如果非要访问双下划线的私有属性或方法的话
对象的名字._类的名字_ _属性名
对象的名字._类的名字_ _方法名（）
关于属性设置问题：（私有属性）
class Student:
def __init__(self,name,gender):
self.name=name
self.__gender=gender#私有
#让@property修饰方法，来把方法修改（转）为一个属性去使用
#虽然这样私有属性就可以显示了，但是它只可读不可写
#如果非要写，就需要setter
@property
def gender(self):
return self.__gender
#将我们gender这个属性设置为可写属性
@gender.setter
def gender(self,value):
if value!='男' and value!='女':
print('性别有误，已将性别默认值为男')
self.__gender='男'#设置默认值
else:
self.__gender=value
stu=Student('zyx','女')
print(stu.name,'的性别是',stu.gender)
#改
stu.gender='其它'
print(stu.name,'的性别是',stu.gender)
2.继承
1. 一个父类可以有多个子类
2. 一个子类可以继承多个父类（多继承）
方法重写
即：在子类里再写一个方法，方法名要跟你要重写的这个父类的方法名相同
- 当然你也可以完全重写，不使用super调用父类内容
比如：
3.多态
class Person():
def eat(self):
print('汉堡')
class Cat():
def eat(self):
print('鱼')
class Dog():
def eat(self):
print('骨头')
#这三个类函数都有一个同名的方法，eat
def fun(obj):#obj是函数的形参，因为此时并不知道参数的数据类型
obj.eat()
per=Person()
cat=Cat()
dog=Dog()
#python中的多态，不关心对象的数据类型，只关心对象是否具有同名方法
fun(per)#这就已经构成多态了
fun(cat)
fun(dog)
🦙object类（对象）
对象的特殊方法（首尾双下划线）
dir（）内置函数，可以查看你的类的对象，它所具有的属性或方法
使用即：
对象的特殊属性（首尾双下划线）
