一.序列和索引
1.1 用索引检索字符串中的元素
# 正向递增
s='helloworld'
for i in range (0,len(s)):# i是索引
print(i,s[i],end='\t\t')
print('\n--------------------------')
# 反向递减
for i in range (-10,0):
print(i,s[i],end='\t\t')
print('\n--------------------------')
print('\n',s[9],s[-1])
1.2通过切片操作可以获取一个新的序列（从0开始切到五不包含5，步长为2）
s='hello'
s2='world'
print(s+s2)#产生一个新的字符串序列
# 序列的相乘操作
print(s*5)
print('-'*40)
1.3序列的箱操作和函数的使用
s='helloworld'
print('e在helloworld中存在吗',('e'in s))
print('e在helloworld中存在吗',('v'in s))
#not in的使用
print('e在helloworld中存在吗',('e'not in s))# not in的使用
print('e在helloworld中存在吗',('v'not in s))
#内置函数的使用
print('len()',len(s))
print('min(s)',min(s))
print('max(s)',max(s))
# 序列对象的方法，使用序列的方法，打点调用
print('s.index():',s.index('o'))#o在s中第一次出现的索引位置4
print('s.count():',s.count('o'))#统计o在字符串之间的位置
二.列表的基本操作
列表名是自己取的变量名，列表与字符串一样，都是序列中的一种
lst=['hello','world',98,100.5]
print(lst)
# 可以使用内置的函数list()创建列表
lst2=list('helloworld')
lst3=list(range(1,10,2))#从1开始到10结束，步长为2,不包含10，1、3、5、7、9
print(lst2)
print(lst3)
#列表是序列中的一种,对列表的操作符，运算符，函数均可操作
print(lst+lst2+lst3)# 序列中的相加操作
print(lst*3)#序列的相乘操作
print(len(lst))
print(max(lst3))
print(min(lst3))
print(lst2.count('o'))#统计o的个数
print(lst2.index('o'))# o在列表lst2中第一次的位置
# 列表的删除操作
lst4=[10,20,30,40,50]
print(lst4)
# 删除列表
del lst4
#print(lst4)
列表的遍历操作
lst=['hello','world','python','php']
# 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):#直接写1，start不写也可以
print(index,item)
2.1列表特有操作
列表的相关操作
lst=['hello','world','python']
print('原列表',lst,id(lst))
#增加元素的操作
lst.append('sql')
print('增加元素之后',lst,id(lst))
#使用insert(index,x)在指定的index位置上插入元素x
lst.insert(1,100)
print(lst)
#列表元素的删除操作
lst.remove('python')
print('删除元素之后的列表',lst,id(lst))
#使用pop(index)根据索引将元素取出，然后再删除
print(lst.pop(1))
print(lst)
#清除列表中所有的元素clear()
# lst.clear()
# print(lst,id(lst))
#列表的反向
lst.reverse()#不会产生新的列表，在原列表的基础上进行的
print(lst)
# 列表的拷贝，将产生的一个新的列表对象
new_lst=lst.copy()
print(lst,id(lst))
print(new_lst,id(new_lst))
#列表元素的修改操作
#根据索引进行修改元素
lst[1]='mysql'
print(lst)
ctrl+?:注释
列表的排序操作
lst=[4,56,3,78,40,56,89]
print('原列表',lst)
#排序，默认是升序
lst.sort()#排序是在原列表的基础上进行的，不会产生新的列表
print(lst)
print('升序',lst)
#排序，降序
lst.sort(reverse=True)#大的在前小的在后
print('降序',lst)
print('------------------------------')
lst2=['banana','apple','Cat','Orange']
print('原列表',lst2)
#升序排序，先排大写，再排小写 大写A 65，小写a 97
lst2.sort()#默认升序
print('升序',lst2)
#降序，先排小写，后排大写
lst2.sort(reverse=True)
print('降序:',lst2)
# 忽略大小写进行比较
lst2.sort(key=str.lower)# 参数不加括号，调用加括号
print(lst2)
列表的排序sorted
lst=[4,56,3,78,40,56,89]
print('原列表',lst)
#排序
asc_lst=sorted(lst)
print('升序',asc_lst)
print('原列表',lst)
#降序
desc_lst=sorted(lst,reverse=True)
print('降序：',desc_lst)
print('原列表',lst)
lst2=['banana','apple','Cat','Orange']
print('原列表',lst2)
#忽略大小写进行排序
new_lst2=sorted(lst2,key=str.lower)
print('原列表：',lst2)
print('排序后的列表',new_lst2)#默认升序
2.2 列表的生成式及二维列表
2.2.1一维列表
列表生成式的使用
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(1,11)]
print(lst)
# 从列表中选择符合条件的元素组成新的列表
lst=[i for i in range(10) if i%2==0 ]
print(lst)
2.2.2 二维列表
二维列表的遍历及列表生成式
# 创建二维列表
lst=[
['城市','环比','同比'],
['北京',102,103],
['上海',100,504],
['深圳',100,39]
]
print(lst)
#遍历二维列表使用双层for循环
for row in lst:#行
for item in row:#列
print(item,end='\t')
print()#换行
#列行生成式生成一个4行5列的二维列表
lst2=[[j for j in range(5)]for i in range(4)]
print(lst2)
2.3元组的创建与删除
# 使用小括号创建元组
t=('hello',[10,20,30],'python','world')
print(t)
# 使用内置函数tuple()创建元组
t=tuple('helloworld')
print(t)
t=tuple([10,20,30,40,50])
print(t)
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=(10)
print(t,type(t))
#如果元组只有一个元素，逗号不能省略
y=(10,)
print(y,type(y))
#元组的删除
del t
#print(t)
2.4 元组元素的遍历和访问
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):
print(index,'----->',item)
for index,item in enumerate(t,start=11): #序号从11开始
print(index,'----->',item)
2.5 元组生成式
t=(i for i in range(1,4))
print(t)#t是生成器对象
# t=tuple(t)
# print(t)
#遍历
#for item in t:
# print(item)
print(t.__next__())
print(t.__next__())
print(t.__next__())
t=tuple(t)
print(t)# 使用__next__()方法已经把生成器中的元素取出来了，里面没有元素
2.6 字典类型
2.6.1 字典的创建与删除
# 1.创建字典
d={10:'cat',20:'dog',30:'pet',20:'zoo'}
print(d)# key相同时，value值进行覆盖
# 2.zip函数
lst1=[10,20,30,40]
lst2=['cat','dog','pet','zoo','car']
zipobj=zip(lst1,lst2)
print(zipobj)#<zip object at 0x0000020A30625500>(zip映射对象，看不到里面内容)
#print(list(zipobj))zipobj映射对象里面的内容已经转成列表类型，不能再转成字典了
d=dict(zipobj)
print(d)
#使用参数创建字典
d=dict(zip(lst1,lst2))# 左侧cat是key,右侧是value
print(d)
t=(10,20,30)
print({t:10})# t是key,10是value,元组是可以作为字典中的key
# lst=[10,20,30]#列表和元组目前的区别只是创建符号，元组使用小括号，列表使用方括号
# print(lst:10) SyntaxError: invalid syntax
#列表不可以去作为字典当中的键,列表是可变数据类型
#字典属于序列
print('max:',max(d))
print('min:',min(d))
print('len:',len(d))#长度计算式字典当中元素的个数
#字典的删除
del d
#print(d)删除之后就不能再使用了
字典中的key是无序的,解释器是帮忙处理了,所以有序
2.6.2 字典元素的访问和遍历
d={'hello':10,'world':20,'python':30}
# 访问字典中的元素
# 1.使用d[key]
print(d['hello'])
# 2. d.get(key)
print(d.get('hello'))
# 二者之间是有区别的，如果key不存在,d[key]报错。get(key)
#print(d.['java']) SyntaxError: invalid syntax
print(d.get('java'))#None
print(d.get('java','不存在'))
#字典的遍历
for item in d.items():
print(item) # key=value组成的一个元组类型
# 在使用for循环遍历时，分别获取key,value
for key,value in d.items():
print(key,'----->',value)
2.6.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)#映射的结果
d=dict(list)#转成字典类型
print(d)
#使用pop函数
print(d.pop(1001))
print(d)
print(d.pop(1008,'不存在'))
# 随机删除
print(d.popitem())
print(d)
# 清空字典中所有的元素
d.clear()
print(d)
# python中一切皆对象，每个对象都有一个布尔值
print(bool(d))#空字典的布尔值为False
2.6.4 字典生成式
import random
d={ item:random.randint(1,100) for item in range(1,4) }#item（0 1 2 3）做键
#item:random.randint(1,100) 1-100之间随机数做值
print(d)
#创建两个列表
lst=[1001,1002,1003]
lst2=['张三','王五','李四']#第一个列表元素做键，第二个元素列表做值
d={key:value for key,value in zip(lst,lst2)}
print(d)
2.7.1集合的创建与删除
#{}直接创建集合
s={10,20,30,40}
print(s)
#集合只能存储不可变数据类型
#s={[10,20],[30,40]} 列表不能进行hash的类型
print(s)
#使用set()创建集合
s=set()#创建一个空集合,空集合的布尔值是false
print(s)
s={} #创建的是集合还是字典呢？字典
print(s,type(s))#dict
s=set('helloworld')
print(s)
s2=set([10,20,30])
print(s2)
s3=set(range(1,10))
print(s3)
#集合属于序列的一种
print('max',max(s3))
print('min',min(s3))
print('len',len(s3))
print('9在集合中存在吗',(9 in s3))
print('9在集合中不存在吗',(9 not in s3))
# 集合的删除操作
del s3
#print(s3)#未定义
2.7.2集合类型
集合的操作符
A={10,20,30,40,50}
B={30,50,88,76,20}
# 交集操作
print(A&B)#两个集合中共有的部分
#并集
print(A|B)
#差集
print(A-B)
#补集操作：得到不相交的部分
print(A^B)
2.7.3 集合的操作方法及集合的遍历：集合的遍历可以使用for与enumerate函数来进行
s={10,20,30}
#向集合中添加元素
s.add(100)
print(s)
# 删除元素
s.remove(20)
print(s)
#清空集合中所有元素
#s.clear()
#print(s)
#集合的遍历操作
for item in s:
print(item)
# 使用enumerate()函数遍历
for index,item in enumerate(s):
print(index,'--->',item)#如果没有指定的话，默认从0开始的
#集合的生成式
s={i for i in range(1,10)}
print(s)
s={i for i in range(1,10) if i%2==1}
print(s)
列表是插入顺序。元组是唯一不可变数据类型，使用（）定义。字典是无序的，因为底层用到了hash表，定义符号用{}。
2.8 python3.11新特性
2.8.1 结构的模式匹配
data=eval(input('请输入要匹配的数据'))
match data:
case {'name':'yy','age':22}:
print('字典')
case [10,20,30]:
print('列表')
case (10,20,40):
print('元组')
case _:
print('相当于多重if中的else')
#如果是输入helloworld,helloworld未定义，“helloworld”当去掉一对引号，还带有一对引号
2.8.2 合并字典运算符
d1={'a':10,'b':20}
d2={'c':30,'d':40}
merged_dict=d1|d2
print(merged_dict)
2.8.3同步迭代
#fruits={'apple','orange','banana','mango'}#集合是无序的，改成列表
fruits=['apple','orange','banana','mango']
counts=[10,3,4,5]
for f,c in zip(fruits,counts):
match f,c:
case 'apple',10:
print('10个apple')
case 'orange',3:
print('3个橘子')
case 'banana',4:
print('4个香蕉')
case 'mango',5:
print('5个芒果')
本章总结
列表是无序序列。
在元组中只有一个函数的时候，逗号不能省略。创建字典的方式使用{}直接创建，使用内置函数创建，第一种得到zip对象，需要进行类型转换。第二种左边是键，右边是值。字典是可变数据类型，具有查询的方法
get（）获取单个值，keys()获取所有键，values获取所有的值，items获取所有的键值对
列表中有四个元素，向列表中添加一个元组‘hello,world’,将元组作为一个元素添加到列表当中
d是一个字典，d2和d指向同一个内存空间，把b的值修改为100，d2也是100
在字典中的键是不可变数据类型，1是整数，不可变数据类型。元组是不可变数据类型做键可以，字符串是不可变数据类型做键可以，列表是可变数据类型，不能做字典中的键
第四个元素是列表，是整体作为一个元素添加进来
在索引为2的位置添加20
reverse没有返回值
章节习题
lst=[88,89,90,98,00,99]#表示的员工的两位整数出生年份
print(lst)
#遍历列表的方式
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)
lst=[88,89,90,98,00,99]#表示的员工的两位整数出生年份
print(lst)
#1.遍历列表的方式
# 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(value) != '0':
lst[index] ='19'+ str(value)#拼接年份，再赋值
else:
lst[index] = '200'+ str(value)
print('修改后的年份列表',lst)
# 创建一个空列表：用于存储入库的商品信息
lst=[]
for i in range(5):#5次赋值
goods=input('请输入商品的编号和商品的名称进行商品入库，每次只能输入一次商品')
lst.append(goods)
#输入所有的商品信息
for item in lst:
print(item)
#创建一个空列表，用于存储购物车中的商品
cart=[]
while True:
flag=False#代表没有商品的情况
num=input('请输入要购买的商品编号：')
# 遍历商品列表，查询一下购买的商品是否存在
for item in lst:
if num==item[0:4]:#前四位是商品编号（切片操作，切到3不包含四）
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('-'*50)
print('您的购物车里已选择的商品为：')
cart.reverse()
for item in cart:
print(item)
模拟12306车票订票流程
# 创建字典用于存储车票信息，使用车次做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获取出来的值是一个列表
for item in dict_ticket.get(key):#根据键获取值
print(item,end='\t\t ')
# 换行
print()
# 输入用户的购票车次
train_no=input('请输入要购买的车次')
# 根据key获取值
info=dict_ticket.get(train_no,'车次不存在') # info是一个列表类型
#判断车次不存在
if info!='车次不存在':
person=input('请输入乘车人，如果多位乘车人使用逗号分隔：')
# 获取车次的出发站--到达站，还有出发时间
s=info[0]+' '+info[1]+'开'
print('您已购买了'+train_no+' '+s+person+'尽快换取纸制车式')
else:
print('对不起，选择的车次可能不存在')
# 创建一个空集合
s=set()
# 录入5位好友的姓名和手机号
for i in range(1,6):
info=input(f'请输入第{i}位好友的姓名和手机号：')
#添加到集合当中
s.add(info)
# 遍历集合
for item in s:
print(item)
三、字符串及正则表达式
3.1 字符串的常用方法1
# 大小写转换
s1='HelloWorld'
new_s2=s1.lower()
print(s1,new_s2)
new_s3=s1.upper()
print(new_s3)
#字符串的分隔
e_mail='hh@123.com'
lst=e_mail.split('@')
print('邮箱名：',lst[0],'邮件服务器域名：',lst[1])
print(s1.count('o'))#o在字符串s1中出现了两次
#检索操作
print(s1.find('o'))#o在字符串中首次出现的位置
print(s1.find('p')) #-1,没有找到
print(s1.index('o'))
#print(s1.index('p'))# print(s1.index('p')) 子串没有找到
#判断前缀和后缀
print(s1.startswith('H'))
print(s1.startswith('P'))
print('demo.py'.endswith('.py'))#True
print('text.txt'.endswith('.txt'))#True
3.2 字符串的常用方法2
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())# 只去掉字符串右侧的空格
#去掉指定的字符
s3='dl-Helloworld'
print(s3.strip('ld'))#与顺序无关
print(s3.lstrip('ld'))
print(s3.rstrip('ld'))#去掉指定的字符，但去与我们的顺序无关
3.3格式化字符串的方式
#1.占位符格式化
name='马冬梅'
age=18
score=98.5
print('姓名：%s,年龄：%d,成绩：%f'%(name,age,score))
print('姓名：%s,年龄：%d,成绩：%f'%(name,age,score))
# 2.f-string
print(f'姓名:{name},年龄:{age},成绩：:{score}')
#3.使用字符串format方法
print('姓名：{0}，年龄：{2}'.format(name,age,score))
print('姓名：{2}，年龄：{0}，成绩{1}'.format(age,score,name))
3.4 mat的格式控制
s='helloworld'
print('{0:*<20}'.format(s))#字符串的显示宽度为20，左对齐，空白部分使用*号填充
print('{0:*>20}'.format(s))
print('{0:*^20}'.format(s))
#居中对齐
print(s.center(20,'*'))
# 千位分隔符（只适用于整数和浮点数）
print('{0:,}'.format(987654321))
print('{0:,}'.format(987654321.7865))
#浮点数小数部分的精度
print('{0:.2f}'.format(3.1415))
# 字符串类型，显示的是最大的显示长度
print('{0:.5}'.format('helloworld')) # hello
#整数类型
a=425
print('二进制：{0:b},十进制：{0:o},十六进制：{0:x}'.format(a))
# 浮点数类型
b=3.1415926
print('{0:.2f},{0:.2E},{0:.2e},{0:.2%}'.format(b))
3.5 字符串的编码和解码
s='伟大的中国梦'
# 编码 str->bytes
scode=s.encode(errors='replace')# 默认utf-8,因为utf-8中文占3个字符
print(scode)
scode_gbk=s.encode('gbk',errors='replace')#gbk中文占2个字符
print(scode_gbk)
# 解码过程bytes->str
print(bytes.decode(scode_gbk,'gbk'))
print(bytes.decode(scode,'utf-8'))
3.6 数据验证的方法
from curses.ascii import isdigit
#isdigit()十进制的阿拉伯数字
print('123',isdigit())#True
print('一二三',isdigit()) #False
print('0b1010',isdigit()) #False
print('IIIIII',isdigit()) #False
print('-'*50)
# 所有字符都是数字
print('123'.isnumeric()) #True
print('一二三'.isnumeric()) #True
print('0b1010'.isnumeric()) #False
print('IIIIII'.isnumeric()) #True
print('壹贰叁'.isnumeric()) #True
print('-'*50)
#所有的字符都是字母（包含中文字符）
print('hello你好'.isalpha()) #True
print('hello你好123'.isalpha()) #False
print('hello你好一二三'.isalpha()) #True
print('hello你好IIIIII'.isalpha()) #False
print('-'*50)
# 所有字符都是数字或字母
print('hello你好'.isalnum()) #True
print('hello你好123'.isalnum()) #True
print('hello你好一二三'.isalnum()) #True
print('hello你好IIIIII'.isalnum()) #True
print('hello你好壹贰叁'.isalnum()) #True
print('-'*50)
#判断字符的大小写
print('HelloWorld'.islower())#False
print('helloworld'.islower())#True
print('hello你好'.islower())#True
# 所有字符都是首字母大写
print('Hello'.istitle())#True
print('HelloWorld'.istitle())#False
print('Helloworld'.istitle())#True
print('Hello World'.istitle())#True
print('Hello world'.istitle())#False
# 判断是否都是空白字符
print('-'*50)
print('\t'.isspace())#True
print(' '.isspace())#True
print('\n'.isspace())#True
3.7 字符串的拼接处理
s1='hello'
s2='world'
# 1.使用+进行拼接
print(s1,s2)
#2.使用字符串的join()方法
print(''.join([s1,s2])) # 使用的空字符串拼接
print('*'.join(['hello','world','python','java','php']))
print('你好'.join(['hello','world','python','java','php']))
#3.直接拼接
print('hello world')
#4.使用格式化字符串进行拼接
print('%s%s'%(s1,s2))
print(f'{s1}{s2}')
print('{0}{1}'.format(s1,s2))
字符串的去重操作
s='helloworldhelloworldacddfc'
# 1.字符串的拼接及not in
new_s=''
for item in s:#遍历
if item not in new_s: #不存在
new_s+=item #拼接
print(new_s)
# 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)
#3.通过集合去重+列表排序
new_s3=set(s)#集合去重打乱了顺序
lst=list(new_s3)
lst.sort(key=s.index)
print(''.join(lst))
3.8 正则表达式
3.9 re模块中的match函数的使用
import re # 导入
pattern='\d\.\d+'# +限定符， 0-9出现1次或多次
s='I study Python 3.11 every day'
match=re.match(pattern,s,re.I)#忽略大小写
print(match)#从头开始匹配，所以是None
s2='3.11Python I study Python 3.11 every day'
match2=re.match(pattern,s2,re.I)
print(match2)#\d是一个数字，没有写次数，就是1次,.作为普通字符，.后面还要0-9的数字，就是1-多次，找的是2次
print('匹配的起始位置：',match2.start())
print('匹配值的结束位置',match2.end())
print('匹配区间的位置元素',match2.span())# 元组
print('待匹配的字符串',match2.string)
print('匹配的数据',match2.group())
3.9re模块中的search函数和findall函数的使用
import re # 导入
pattern='\d\.\d+'# +限定符， 0-9出现1次或多次
s='I study Python 3.11 every day Python 2.7 I love you'
match=re.search(pattern,s)#用pattern这个规则在s中查找
print(match)
s2='4.10 Python I study every day'
s3='I study every day'
match2=re.search(pattern,s2)
match3=re.search(pattern,s3)
print(match2)
print(match3)
#输出内容用match.group
print(match.group())
print(match2.group())
import re # 导入
pattern='\d\.\d+'# +限定符， 0-9出现1次或多次
s='I study Python 3.11 every day Python 2.7 I love you'
s2='4.10 Python I study every day'
s3='I study every day'
lst=re.findall(pattern,s)
lst2=re.findall(pattern,s2)
lst3=re.findall(pattern,s3)#空列表
print(lst)
3.10 re模块的sub函数和spilt函数的使用
import re # 导入
pattern='黑客|破解|反爬'# +限定符， 0-9出现1次或多次
s='我想学习Python,想破解一些VIP视频，python可以实现反爬吗'
re.sub(pattern,'XXX',s)
print(s)
s2='https://cn.bing.com/search?q=csdn&form=ANNTH1'
pattern2='[?|&]'#模式字符串
lst=re.split(pattern2,s2)
print(lst)
本章总结：
lower和upper结果是一个新的字符串对象
spilt结果是一个列表类型
字符串判断的方法结果是一个bool类型
replace可以指定替换的次数，如果不指定默认会替换全部
match是从字符串的开头，search是查找到第一个，findall查找所有，subn替换，spilt分隔
章节习题
英文占一个字节，中文在utf-8占3个字节
如果不写编码格式就按utf-8编写
字符串第一个转成小写再连接剩余部分
spilt结果是列表，将ab去掉
index是起始索引，不是全部索引，find查不到是-1，index会报错
lower转小写，upper转大写，strip去掉左右空格或者特殊字符，spilt（）分隔不符合要求的
\d 0-9的数字出现8次
小写w是字母、数字、下划线，+是出现的一个次数一到多次，s是待匹配的字符串，re.search使用这个模式字符串到s中查找，只查找到符合条件的第一个
spilt结果是列表类型
章节习题
lst=['京A8888','津B6666','吉A777666']
for item in lst:
item[0:1]#归属地是车牌第一个字，使用切片操作0：切一个，0-1不包含索引为1
area=item[0:1]
print(item,'归属地：',area)
s='HelloPython,HelloJava,hellophp'
word=input('请输入要统计的字符')
print('{0}在{1}一共出现了{2}'.format(word,s,s.upper().count(word)))#字符串的格式化
lst=[
['01','电风扇','美的',500],
['02','洗衣机','TCL',1000],
['03','微波炉','老板',500]
]
print('编号\t\t名称\t\t\t品牌\t\t单价')
for item in lst:#item是元素，继续遍历
for i in item:
print(i,end='\t\t')
print()#换行
#格式化
for item in lst:
item[0]='0000'+item[0]
item[3]='Y{0:.2f}'.format(item[3])#0是索引位置，：是引导符，.2f保留两位小数
print()
print('编号\t\t\t名称\t\t\t品牌\t\t单价')
for item in lst:#item是元素，继续遍历
for i in item:
print(i,end='\t\t')
print()#换行
整数的正则表达式是\d,出现几次：{1}。*代表0或者多次
findall结果是列表
四、bug的由来和分类
正向递增索引：索引的范围是0—>N-1,append是列表的调用方法，打点调用
字符串的切片是整数
4.1 Python中异常处理机制
try:
num1 = int(input("输入一个整数:"))
num2 = int(input("输入另一个整数:"))
result = num1 / num2
print('结果', result)
except ZeroDivisionError:
print('除数为0')
4.2多个except结构
try:
num1 = int(input("输入一个整数:"))
num2 = int(input("输入另一个整数:"))
result = num1 / num2
print('结果', result)
except ZeroDivisionError:
print('除数为0')
except ValueError:
print('不能将字符串转成整数')
except BaseException:
print('未知异常')
finally无论程序是否异常都会执行的代码
try:
num1 = int(input("输入一个整数:"))
num2 = int(input("输入另一个整数:"))
result = num1 / num2
print('结果', result)
except ZeroDivisionError:
print('除数为0')
except ValueError:
print('不能将字符串转成整数')
except BaseException:
print('未知异常')
else:
print('结果：',result)
finally:
print('程序执行结束')
4.3 raise关键字的使用
try:
gender=input("Enter your gender: ")
if gender!="Male"and gender!="Female":
raise Exception('性别只能是男或者女')#第三行判断条件为True，会抛出异常对象
else:
print('您的性别是',gender)
except Exception as e:
print(e)
4.4 python中常用的异常类型
4.5 PyCharm的程序调试
本章总结
如果没有出现异常执行try-else结构，在最后一个结果中，没有异常执行try-else-finally,出现异常执行try-except-finally
设置断点：在变量定义，循环处
finally无论是否异常都会执行
章节习题
try:
score=eval(input("Enter your score: "))
if 0<=score<=100:
print("Your score is:",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 b+c>a:
print(f'三角形的边长：,{a},{b},{c}')
else:
raise Exception(f'{a},{b},{c},不能构成三角形')# 格式化处理
except Exception as e:
print(e)
五、函数及常用的内置函数
def get_sum(num):#num叫做形式参数（函数定义处）
s=0
for i in range(1,num+1):
s=s+i
print(f'1到{num}之间的累加和为:{s}')
#函数的调用处
get_sum(10)#1-10之间的累加和 10是实际参数值
get_sum(100)#1-100之间的累加和 100是实际参数值
get_sum(1000)#1-100之间的累加和 1000是实际参数值
函数的参数传递-位置参数和关键字参数
def happy_birthday(name,age):
print('祝'+name+'生日快乐')
print(str(age)+'生日快乐')
#调用
happy_birthday('张三',18)#调用时调用的参数个数和顺序必须与定义的参数的个数和顺序相同
关键字传参
def happy_birthday(name,age):
print('祝'+name+'生日快乐')
print(str(age)+'生日快乐')
#关键字传参
happy_birthday(age=18,name='张三')
#happy_birthday(age=18,name1='张三')
#定义形参为name,TypeError: happy_birthday() got an unexpected keyword argu
happy_birthday('陈梅梅',age=18)#正常执行，位置传参，也可以使用关键字传参
#happy_birthday(name='陈梅梅',18)#SyntaxError: positional argument follows keyword argument
#位置参数在前，关键字传参在后，不然会报错
5.1 函数的参数传递–默认值参数
def happy_birthday(name='张三',age=18):
print('祝'+name+'生日快乐')
print(str(age)+'生日快乐')
#调用
happy_birthday()#不用传参
happy_birthday('陈梅梅')#位置传参
happy_birthday(age=19)#关键字传参（函数调用处传参）,name采用默认值
#happy_birthday(19)# 19会赋值给哪个变量，如果使用位置传参的方式，19被传给了name
def fun(a,b=20):
pass
#def fun2(a=20,b):# 语法报错，当位置参数和默认参数（在函数定义时）同时存在的时候，位置参数在后会报错
# pass
# 当位置参数和关键字参数同时存在，应该遵循位置参数在前，默认参数在后
5.2 函数的参数传递–可变参数
# 个数可变的位置参数
def fun(*data):
print(type(data))
for item in data:
print(item)
#调用
fun(10,20,30,40)
fun(10)
fun(20,30)
fun([11,22,33,44])#实际传递的是一个参数
#在调用时，参数前加一颗星，分将列表进行解包
fun(*[11,22,33,44])
#个数可变的关键字参数
def fun2(**kwpara):#定义需要两颗星
print(type(kwpara))
for key,value in kwpara.items():
print(key,'-----',value)
#调用
fun2(name='hh',age=18,height=20)#关键字参数
d={'name':'hh','age':18,'height':20}
#fun2(d)#不可以将字典传入做参数， fun2() takes 0 positional arguments but 1 was given
fun2(**d)# 如果参数是字典，前面加上两颗星进行系列解包
5.3 函数的返回值
# 函数的返回值
def calc(a,b):
print(a+b)
calc(10,20)
print(calc(10,20))#None
def calc2(a,b):
s=a+b
return s #将s返回函数的调用处处理
print('-'*10)
get_s=calc2(10,20)#存储到变量当中
print(get_s)
get_s2=calc2(calc2(10,20),3)#先去执行calc2(10,20)，返回结果是30，再去执行calc2(30，30)
print(get_s2)
#返回值可以是多个
def get_sum(num):
s=0#累加和
for i in range(1,num+1):
s=s+i
odd_sum=0#奇数和
even_sum=0#偶数和
for i in range(1,num+1):
if i%2==0:
odd_sum=odd_sum+i
else:
even_sum=even_sum+i
s+=1
return odd_sum,even_sum,s#三个值
result=get_sum(10)
print(type(result))
print(result)
#系列解包赋值
a,b,c=get_sum(10)
print(a,b,c)
5.4 变量的作用域
def calc2(a,b):
s=a+b
return s #将s返回函数的调用处处理
result=calc2(10,20)
print(result)
#print(a,b,s)#a,b是函数的参数，参数是局部变量，s函数中定义的变量，局部变量，作用范围是函数
a=100#全局变量
def calc(x,y):
return a+x+y
print(a)
print(calc(10,20))
print('-'*30)
def calc2(x,y):
a=200#局部变量，局部变量的名称和全局变量的名称相同
return a+x+y# a是局部变量还是全局变量？局部变量，当全局变量和局部变量名称相同时，局部变量的优先级高
print(calc2(10,20))
print(a)
print('-'*30)
def calc3(x,y):
global s#s是在函数中定义的变量，但是使用了global关键字声明，这个变量s变成了全局变量
s=300# 声明和赋值，必须分开执行
return s+x+y
print(calc3(10,20))
print(s)
print('-'*30)
5.5 匿名函数的使用
from ctypes import HRESULT
def calc(a,b):
return a+b
print(calc(10,20))
#匿名函数
s=lambda a,b:a+b#s表示的是一个匿名函数
print(type(s))
#调用匿名函数
print(s(10,20))
print('*'*50)
#
lst=[10,20,30,40,50]
for i in range(len(lst)):# i表示索引
print(lst[i])
print()
for i in range(len(lst)):
result=lambda x:x[i]#根据索引取值，result的是函数（function）类型，x是形式参数
print(result(lst))# lst是实际参数
student_scores=[#列表，列表里面四个元素
{'name':'张三','score':98},
{'name':'李四','score':96},
{'name':'王五','score':98},
{'name':'赵六','score':65}
]
# 对列表进行排序，排序规则：字典中的成绩
student_scores.sort(key=lambda x:x.get('score'), reverse=True)#x是字典,降序、
print(student_scores)
5.6 函数的递归操作
def fac(n):#n的阶乘 N！=N*(N-1)!....1! N=5
if n == 1:
return 1
else:
return n * fac(n - 1)# 自己调用自己
print(fac(5))
5.7斐波那契数列
递归每调一次会开辟一个栈
def fac(n):
if n == 1 or n == 2:
return 1
else:
return (n - 1)+fac(n-2)
print(fac(9))
for i in range(1,9):
print(fac(i),end="\t")#不换行
print()
5.8常用的内置函数–类型转换函数
还有转成字典类型的dict
print('非空字符串的布尔值',bool('hello'))
print('空字符串布尔值',bool(''))# 空字符串不是空格字符串
print('空列表布尔值',bool([]))
print('空列表布尔值',bool(list()))
print('空元组布尔值',bool(()))
print('空元组布尔值',bool(tuple()))
print('空集合布尔值',bool(set()))
print('空字典布尔值',bool({}))
print('空字典布尔值',bool(dict()))
print('-'*30)
print('非0数值型布尔值',bool(123))
print('整数0的布尔值',bool(0))
print('浮点数0.0的布尔值',bool(0.0))
#将其他类型转成字符型
lst=[10,20,30]
print(type(lst),lst)
print()
s=str(lst)
print(type(s),s)
# float类型和str类型转成int类型
print('-'*30,'float类型和str类型转成int类型','-'*30)
print(int(98.7)+int('90'))
# 注意事项
#print(int('98.7'))#ValueError: invalid literal for int() with base 10: '98.7'
#字符串里面的浮点串不可以转
#print(int('a'))ValueError: invalid literal for int() with base 10: 'a'
print('-'*30,'int,str类型转成float类型','-'*30)
print(float(98.7)+float('3.14'))
s='hello'
print(list(s))
seq=range(1,10)#
print(tuple(seq))#创建元组
print(set(seq))#添加到集合中
print(list(seq))
print('-'*30)
常见的内置函数–数学函数
print('绝对值',abs(100),abs(-100),abs(0))
print('商和余数',divmod(13,4))
print('最大值',max('hello'))
print('最大值',max([10,4,56,78,4]))
print('最小值',min('hello'))
print('最小值',min([10,4,56,78,4]))
print('求和',sum([10,34,45]))
print('x的y次幂',pow(2,3))
#四舍五入
print(round(3.1415926))# round函数只有一个参数，保留整数
print(round(3.9415926))#4
print(round(3.1415926,2))# 2表示保留两位小数
print(round(314.15926,-1))# 314 ,-1位，个位进行四舍五入
print(round(314.15926,-2))# 300 ,-2位，十位进行四舍五入
5.9 迭代器操作函数
lst=[54,66,43,65,88]
#1.排序
asc_lst=sorted(lst)#升序
desc_lst=sorted(lst,reverse=True)#降序
print('原列表',lst)
print('升序',asc_lst)
print('降序',desc_lst)
# 2.reversed反向
new_lst=reversed(lst)
print(type(new_lst))#<class 'list_reverseiterator'> 迭代器对象，结果不是列表
print(list(new_lst))
# 3.zip
x=['a','b','c','d','e']
y=[10,20,30,40,50]
zipobj=zip(x,y)
print(type(zipobj))#<class 'zip'>
#print(list(zipobj))
# 4.enumerate
enum=enumerate(y,start=1)
print(type(enum))#<class 'enumerate'>
print(tuple(enum))#转成元组
#5.all
lst2=[10,20,'',30]
print(all(lst2))#空字符串布尔值是false
print(all(lst))
# 6.any
print(any(lst))#True
#7.
print(next(zipobj))
print(next(zipobj))
print(next(zipobj))
#filter和map第一个参数都是函数
def fun(num):
return num*2==1#可能是True,False
obj=filter(fun,range(10))#函数作为参数
# 将range(10),0-9的整数都执行一次fun操作
print(list(obj))# [1,3,5,7,9]
def upper(x):
return x.upper()
new_lst2=['hello','world','python']
obj=map(upper,new_lst2)
print(list(obj))#迭代器对象要转成列表或元组
5.10 其他内置函数的使用
#format()
print(format(3.14,'20'))#默认右对齐
print(format('hello','20'))#默认左对齐
print(format('hello','*<20'))#<左对齐，*表示的填充符，20表示的是显示的宽度
print(format('hello','*^20'))
print(format(3.1415926,'.2f'))#3.14
print(format(20,'b'))
print(format(20,'o'))
print(format(20,'x'))
print(format(20,'X'))
print('-'*40)
print(len('helloworld'))
print(len([10,20,30,40,50]))
print('-'*40)
print(id(10))#查看内存地址
print(id('helloworld'))#查看内存地址
print(type('hello'),type(10))#查看内存地址
print(eval('10+30'))
print(eval('10>30'))
本章总结
章节习题
列表用的是-1就是反向递减，8的索引是-1,2的索引是-2，现在有三个元素：2 8 10
函数的返回值可有可无
当全局和局部相同，局部更具有优先级
将第四个元素添加到列表
每递归一次规模缩小
3是作为参数传进来的
第一个最内部无返回值
没有返回值类型，结果就是没有
参数可有可无也可以多个
import random
def get_max(lst):
x=lst[0]# x存储是元素的最大值
#遍历
for x in range(1,len(lst)):
if lst[x] > x:
x=lst[x]# 对最大值进行赋值
return x
#调用
lst=[random.randint(1,100) for item in range(10)]
print(lst)
#计算列表元素的最大值
print(get_max(lst))
print(max)
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):# 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('请输入一个字符串')
new_s=lower_upper(s)# 函数的调用
print(new_s)
def get_find(s,lst):
for item in lst:
if s in item:
return True
return False
lst=['hello','world','python']
s=input('请输入您要判断的字符串')
result=get_find(s,lst)
print('存在'if result else '不存在')# if...else的简写，三元运算符 if result==True if result利用到对象的布尔值
六、面向过程和面向对象两大编程思想
6.1 自定义类和创建自定义类的对象
查看对象的数据类型
a=10
b=8.8
s='hello'
print(type(a))
print(type(b))
print(type(s))
类名大写，冒号可省略，类是抽象的模版，对象是具体的事例
自定义数据类型
#编写一个person
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
# 编写一个Student类
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
创建自定义类型的对象：
#编写一个person
class Person:
pass
# 编写一个Student类
class Student:
pass
#创建一个Person类型对象
per=Person()#per就是Person类型的对象
stu=Student()#stu就是Student类型的对象
print(type(per))
print(type(stu))
class Student:#类属性：定义在类中，方法外的变量
school='北京XXX教育'
# 初始方法方法，函数称为方法
def __init__(self,xm,age):#xm,age是方法的参数，是局部变量，xm,age的作用域是整个__init__方法
self.xm=xm#=左侧是实例属性，xm是局部变量，将局部变量的值xm赋值给实例属性self.name
self.age=age#实例的名称和局部变量的名称可以相同
#定义在类中的函数，称为方法，自带一个参数self
def show(self):
print(f'我叫：{self.name},今年:{self.age}岁了')
#静态方法
@staticmethod
def sm():
#print(self.name)
#self.show()
print('这是一个静态方法，不能调用实例属性，也不能调用实例方法')
@classmethod
def cm(cls):
print('这是一个类方法，不能调用实例属性，也不能调用实例方法')
#self.show()
#print(self.name)
类方法，类属性，静态方法都是使用类名调用，和实例有关都是使用对象进行打点调用
class Student:#类属性：定义在类中，方法外的变量
school='北京XXX教育'
# 初始方法方法，函数称为方法
def __init__(self,xm,age):#xm,age是方法的参数，是局部变量，xm,age的作用域是整个__init__方法
self.name=xm#=左侧是实例属性，xm是局部变量，将局部变量的值xm赋值给实例属性self.name
self.age=age#实例的名称和局部变量的名称可以相同
#定义在类中的函数，称为方法，自带一个参数self
def show(self):
print(f'我叫：{self.name},今年:{self.age}岁了')
#静态方法
@staticmethod
def sm():
#print(self.name)
#self.show()
print('这是一个静态方法，不能调用实例属性，也不能调用实例方法')
@classmethod
def cm(cls):
print('这是一个类方法，不能调用实例属性，也不能调用实例方法')
#self.show()
#print(self.name)
# 创建类的对象
stu=Student('hh',18)#传了两个参数，因为__init__方法中，有两个参数，self,是自带的参数，无需手动传入
#实例属性，使用对象名打点调用
print(stu.name,stu.age)
#类属性，直接使用类名，打点调用
print(Student.school)
#实例方法，使用对象名进行打点调用
stu.show()
#类方法，@classmethod进行修饰的方法，直接使用类名打点调用
Student.cm()
#静态方法 @staticmethod进行修饰的方法，直接使用类名打点调用
Student.sm()
6.2 使用类模版创建N多个对象
class Student:#类属性：定义在类中，方法外的变量
school='北京XXX教育'
# 初始方法方法，函数称为方法
def __init__(self,xm,age):#xm,age是方法的参数，是局部变量，xm,age的作用域是整个__init__方法
self.name=xm#=左侧是实例属性，xm是局部变量，将局部变量的值xm赋值给实例属性self.name
self.age=age#实例的名称和局部变量的名称可以相同
#定义在类中的函数，称为方法，自带一个参数self
def show(self):
print(f'我叫：{self.name},今年:{self.age}岁了')
#根据图纸创建多个对象
stu=Student('hh',18)
stu2=Student('张三',28)
stu3=Student('马丽',21)
stu4=Student('Marry',23)
print(type(stu))
print(type(stu2))
print(type(stu3))
print(type(stu4))
Student.school='派森教育'#给类属性赋值
#将学生对象存储到列表中
lst=[stu,stu2,stu3,stu4]#列表当中的元素是Student类型的对象
for item in lst:# item是列表中的元素，是Student类型的对象
item.show()# 对象名打点调用实例方法
6.3 动态绑定属性和方法
class Student:#类属性：定义在类中，方法外的变量
school='北京XXX教育'
# 初始方法方法，函数称为方法
def __init__(self,xm,age):#xm,age是方法的参数，是局部变量，xm,age的作用域是整个__init__方法
self.name=xm#=左侧是实例属性，xm是局部变量，将局部变量的值xm赋值给实例属性self.name
self.age=age#实例的名称和局部变量的名称可以相同
#定义在类中的函数，称为方法，自带一个参数self
def show(self):
print(f'我叫：{self.name},今年:{self.age}岁了')
# 创建两个Student类型对象
stu=Student('张三',18)
stu2=Student('王五',19)
print(stu.name,stu.age)
print(stu2.name,stu2.age)
#为stu2动态绑定一个实例属性
stu2.gender='男'
print(stu2.name,stu2.age,stu2.gender)
#print(stu.gender)#AttributeError: 'Student' object has no attribute 'gender',没有这个属性，没有给stu绑定
# 动态绑定方法
def introduce():
print('我是一个普通函数，我被动态绑定成了stu2对象方法')
stu2.fun=introduce#函数的赋值
# fun是stu2对象的方法
#调用（实例方法打点调用）
stu2.fun()
6.4 Python中的权限控制
特殊的：双下划线
class Student():
#首尾双下划线
def __init__(self, name,age, gender):
self._name = name # self._name受保护的，只能本类和子类访问
self.__age = age#self.__age表示私有,只能类本身去访问
self.gender=gender# 普通的实例属性，类的内部，外部，及子类都可以访问
def _fun1(self):# 受保护的
print('子类及本身可以访问')
def __fun2(self):# 私有的
print('只有定义的类可以访问')
def show(self):# 普通的实例方法
self._fun1() #类本身访问受保护的方法
self.__fun2() #类本身访问私有方法
print(self._name)#受保护的实例属性
print(self.__age)#私有的实例属性
# 创建一个学生类的对象
stu=Student('张三',18 ,'男')
#类的外部
print(stu._name)
#print(stu.__age)#AttributeError: 'Student' object has no attribute '__age'. Did you mean: '_name'?
#没有这个属性：出了class的定义范围，age不能用
#调用受保护的实例方法
stu._fun1() #子类及本身可以访问
# 私有方法
#stu.__fun2()#AttributeError: 'Student' object has no attribute '__fun2'. Did you mean: '_fun2'?
#超范围，访问不了
# 私有的实例和方法是真的不能访问吗？
print(stu._Student__age)# 为什么可以这样访问
stu._Student__fun2()
print(dir(stu))#
6.5 属性的设置
可以将方法转换成属性使用，访问的时候只能访问属性，不能修改属性的值，可以使用setter方法去修改
class Student():
def __init__(self, name,gender):
self.name = name#普通实例属性
self.__gender=gender#self.__gender是私有的实例属性
# 使用@property(属性) 修饰方法，将方法转成属性使用
@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('陈梅梅','女')
print(stu.name,'的性别是:',stu.gender)#stu.gender就会去执行syu.gender()
#尝试修改属性值
#stu.gender='男'AttributeError: property 'gender' of 'Student' object has no setter
stu.gender='其他'
print(stu.name,'性别是:',stu.gender)
6.6 继承的概念
class Person:# 默认继承了object
def __init__(self, name, age):
self.name = name
self.age = age
def show(self):
print(f'大家好，我叫:{self.name},我今年：:{self.age}岁')
# Student继承Person类
class Student(Person):# 编写初始化的方法
def __init__(self, name, age, stuno):
super().__init__(name, age) #调用父类的初始化方法
self.stuno = stuno
#Doctor继承Person类
class Doctor(Person):# 编写初始化方法
def __init__(self, name, age, department):
super().__init__(name, age)
self.department = department
#创建第一个子类对象
stu=Student('陈梅梅',20,'1001')
stu.show()
doctor=Doctor('张一一',32,'外科')
doctor.show()
6.7 Python中的多继承
from tkinter.font import names
class FatherA():
def __init__(self,name):
self.name=name
def showA(self):
print('父类A中的方法')
class FatherB():
def __init__(self,age):
self.age=age
def showB(self):
print('父类B中的方法')
class Son(FatherA,FatherB):
#编写初始化的方法
def __init__(self,name,age,gender): # 需要调用两个父类的初始化方法
FatherA.__init__(self,name)
FatherB.__init__(self,age)
self.gender=gender
son=Son('陈梅梅',20,'女')
son.showA()
son.showB()
6.8 方法重写
方法的名称必须和父类中相同
from contextlib import suppress
class Person:# 默认继承了object
def __init__(self, name, age):
self.name = name
self.age = age
def show(self):
print(f'大家好，我叫:{self.name},我今年：:{self.age}岁')
# Student继承Person类
class Student(Person):# 编写初始化的方法
def __init__(self, name, age, stuno):
super().__init__(name, age) #调用父类的初始化方法
self.stuno = stuno
def show(self):# 调用父类中的方法
super().show()
print(f'我来着XXX大学，我的学号是：{self.stuno}')
#Doctor继承Person类
class Doctor(Person):# 编写初始化方法
def __init__(self, name, age, department):
super().__init__(name, age)
self.department = department
def show(self):
print(f'大家好，我叫:{self.name},我今年：:{self.age}岁,我的工作科室是:{self.department}')
#super().show()#调用父类中show方法
#创建第一个子类对象
stu=Student('陈梅梅',20,'1001')
stu.show()#调用子类自己的show方法
doctor=Doctor('张一一',32,'外科')
doctor.show()#调用子类自己的show方法
6.9 Python中的多态：值关心对象的行为
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()# 通过变量obj(对象调用eat方法
# 创建三个类的对象
per= Person()
cat = Cat()
dog = Dog()
fun(per)#python中的多态，不关心对象的数据类型，只关心对象是否具有同名方法
fun(cat)
fun(dog)
6.10 object类
查看对象属性
class Person(object):
def __init__(self,name,age):
self.name = name
self.age = age
def show(self):
print(f'大家好，我叫:{self.name},我今年:{self.age}岁')
# 创建Person类的对象
per=Person('陈梅梅',20) #创建对象的时候会自动调用__init__方法()
print(dir(per))
per.show()
# 先new在inital调用
print(per)#自动调用了__str__方法
_str_方法重写之前
class Person(object):
def __init__(self,name,age):
self.name = name
self.age = age
# 创建person类的对象
per=Person('陈梅梅',20)
print(per)
_str_方法重写之后
class Person(object):
def __init__(self,name,age):
self.name = name
self.age = age
# 方法重写
def __str__(self):
return '这是一个人类，具有name和age两个实例属性'#返回值是字符串
# 创建person类的对象
per=Person('陈梅梅',20)
print(per)# 还是内存地址吗？不是__str__方法中的内容 直接输出对象名，实际上调用__str___方法
print(per.__str__())#手动调用
对象的特殊方法
a=10
b=20
print(dir(a))# python中一切皆对象
print(a+b)# 执行加法运算
print(a-b)
print(a.__add__(b))
print(a.__sub__(b)) #执行减法运算
print(f'{a}<{b}吗',a.__lt__(b))
print(f'{a}<={b}吗',a.__le__(b))
print(f'{a}=={b}吗',a.__eq__(b))
print('-'*40)
print(f'{a}>{b}吗',a.__gt__(b))
print(f'{a}>={b}吗',a.__ge__(b))
print(f'{a}!={b}吗',a.__ne__(b))
#
print('-'*40)
print(a.__mul__(b))#乘法
print(a.__truediv__(b))#除法
print(a.__mod__(b))# 取余
print(a.__floordiv__(b))#整除
print(a.__pow__(2))#幂运算
Python的特殊属性
class A:
pass
class B:
pass
class C(A,B):
def __init__(self,name,age):
self.name=name
self.age=age
# 创建类的对象
a=A()
b=B()
# 创建C类的对象
c=C('陈梅梅',20)
print('对象a的属性特点',a.__dict__)#对象的属性字典
print('对象b的属性字典',b.__dict__)
print('对象c的属性字典',c.__dict__)
print('对象a的属性特点',a.__class__)#对象的属性字典
print('对象b的属性字典',b.__class__)
print('对象c的属性字典',c.__class__)
print('A类的父类的元组',A.__bases__)
print('A类的父类的元组',B.__bases__)
print('A类的父类的元组',C.__bases__)#A类，如果继承了N多个父类，结果只显示一个父类
print('A类的层次结构：',A.__mro__)
print('B类的层次结构：',B.__mro__)
print('C类的层次结构：',C.__mro__)#C类继承了A类，B类，间接继承了object类
#子类的列表
print('A类的子类列表:',A.__subclasses__())#A的子类是C类
print('B类的子类列表:',B.__subclasses__())
print('C类的子类列表:',C.__subclasses__())
![57.[前端开发-前端工程化]Day04-webpack插件模式-搭建本地服务器](https://i-blog.csdnimg.cn/direct/65a5bbd2e84a449c810dba872b13e55a.png)
