目录
01-多继承
'''
01-多继承
知识点:
*可以有很多爸爸，但是第一个才是亲爸
python中支持多继承父类
多继承中子类默认调用第一父类的init函数、属性以及函数
'''
# 1.师父类
class Master(object):
def __init__(self):
print("Master--->init")
self.kongfu='独门秘籍'
def make_kongfu(self):
print(f"使用{self.kongfu}")
# 2.学校类
class School(object):
def __init__(self):
print("School--->init")
self.kongfu='公共功夫'
def make_kongfu(self):
print(f"使用{self.kongfu}")
# 3.徒弟类
#*****这里父类有两个才是重点其他都简单
class Prentice(Master,School):
pass
'''4.创建对象'''
tudi= Prentice()
# 4.1 调用父类的属性以及函数
print(tudi.kongfu)
tudi.make_kongfu()
02-子类重写父类属性和方法
'''
02-子类重写父类属性和方法
知识点:
1.子类若重写init函数创建对象时则会调用子类的init函数
2.子类init函数调用第一父类的初始化函数使用
super().__init__()#superman--超人，父亲--超人
3.子类init函数调用其他父类的初始化函数使用
父类名.__init__(self)#马云是我干爹--马爸爸
4.子类的对象,self,父类的self的地址值一模一样
5.子类init函数中调用其他父类的init函数则使用时就会使用其他父类的属性以及函数
6.子类可以对父类属性重新赋值,子类可以对父类函数重写,调用时用的子类的重写函数
7.子类可以多次调用子类的init函数(不建议使用)
self.__init__()
8.super().__init__()中没有self是python的规定
Master().__init__(self)就必须要加self
9.内存区域只会创建一个对象tudi
亲爹 money ===>调用亲爹money
干爹 car ===>调用干爹car
'''
# 1.师父类
class Master(object):
def __init__(self):
print("师傅类>>>init函数>>>",id(self))
self.kongfu = '[古法煎饼果子配方]'
def make_cake(self):
print(f"使用{self.kongfu}制作煎饼果子")
# 2.学校类
class School(object):
def __init__(self):
print("学校类>>>init函数>>>",id(self))
self.kongfu = '[学校煎饼果子配方]'
def make_cake(self):
print(f"使用{self.kongfu}制作煎饼果子")
# 3.徒弟类
class Prentice(Master,School):
# 3.1 子类初始化函数
def __init__(self):
# 默认调用第一父类的初始化函数
# super().__init__()
# 调用其他父类的初始化函数(内存中创建School对象)
School.__init__(self)
# Master.__init__(self)
print("徒弟类>>>init函数>>>",id(self))
# 修改父类的kongfu属性值
self.kongfu = '[黑暗系煎饼果子配方]'
# 3.2 重写父类的函数
def make_cake(self):
'''
先调用自己的初始化函数
每调用一次制作方法都会初始化一次
每调用一次init函数,kongfu都会重新赋值
:return:
'''
self.__init__()
print(f"使用{self.kongfu}制作煎饼果子-徒弟")
# 3.3 调用师傅类
def make_Master_cake(self):
# 调用师傅类的初始化函数 kongfu=古法
Master.__init__(self)
# 调用师父类的函数 制作=古法煎饼果子
Master.make_cake(self)
# 3.4 调用学校类
def make_School_cake(self):
School.__init__(self)
School.make_cake(self)
'''
4.创建对象
'''
# 4.1 创建对象
tudi = Prentice()
# print("徒弟对象的id值:",id(tudi))
# 调用第二父类的init函数
# print("第二父类:",tudi.kongfu)
# print("第二父类:",tudi.make_cake())
# 4.2 重写父类的属性和函数
# 调用子类的函数===>黑暗系
# tudi.make_cake()
# 4.3 调用师傅类的函数
# tudi.make_Master_cake()
# 4.4 调用学校类的函数
tudi.make_School_cake()03-多层继承
'''
03-多层继承
'''
# 1.师父类
class Master(object):
def __init__(self):
print("师傅类>>>init函数>>>",id(self))
self.kongfu = '[古法煎饼果子配方]'
def make_cake(self):
print(f"使用{self.kongfu}制作煎饼果子")
# 2.学校类
class School(object):
def __init__(self):
print("学校类>>>init函数>>>",id(self))
self.kongfu = '[学校煎饼果子配方]'
def make_cake(self):
print(f"使用{self.kongfu}制作煎饼果子")
# 3.徒弟类
class Prentice(Master,School):
# 3.1 子类初始化函数
def __init__(self):
# 默认调用第一父类的初始化函数
# super().__init__()
# 调用其他父类的初始化函数(内存中创建School对象)
School.__init__(self)
# Master.__init__(self)
print("徒弟类>>>init函数>>>",id(self))
# 修改父类的kongfu属性值
self.kongfu = '[黑暗系煎饼果子配方]'
# 3.2 重写父类的函数
def make_cake(self):
'''
先调用自己的初始化函数
每调用一次制作方法都会初始化一次
每调用一次init函数,kongfu都会重新赋值
:return:
'''
self.__init__()
print(f"使用{self.kongfu}制作煎饼果子-徒弟")
# 3.3 调用师傅类
def make_Master_cake(self):
# 调用师傅类的初始化函数 kongfu=古法
Master.__init__(self)
# 调用师父类的函数 制作=古法煎饼果子
Master.make_cake(self)
# 3.4 调用学校类
def make_School_cake(self):
School.__init__(self)
School.make_cake(self)
# 4.徒孙类
class tusun(Prentice):
pass
'''
5.创建徒孙对象
'''
ts = tusun()
# 5.1 调用徒弟的制作方法
ts.make_cake()
# 5.2 调用师祖-师父
ts.make_Master_cake()
# 5.3 调用师祖-学校
ts.make_School_cake()04-super的使用
'''
04-super的使用
知识点:
1.super()指向的是父类的对象 默认第一父类
2.默认添加super()函数
创建子类对象时候
若有父类则自动将子类对象id值传递给父类
若无父类则不需要创建(默认继承object)
3.子类创建对象时,父类的地址会和子类相同
4.父类创建对象时,父类和子类没有任何关系
5.__mro__获取继承父类顺序
'''
# 1.师父类
class Master(object):
def __init__(self):
print("师傅类>>>init函数>>>",id(self))
self.kongfu = '[古法煎饼果子配方]'
def make_cake(self):
print(f"使用{self.kongfu}制作煎饼果子")
# 2.学校类
class School(object):
def __init__(self):
print("学校类>>>init函数>>>",id(self))
self.kongfu = '[学校煎饼果子配方]'
def make_cake(self):
print(f"使用{self.kongfu}制作煎饼果子")
# 3.徒弟类
class Prentice(Master,School):
# 3.1 init函数
# 3.2 重写父类的函数
def make_cake(self):
self.__init__()
print(f"使用{self.kongfu}制作煎饼果子")
# 3.3 调用师父类
def make_Master_cake(self):
Master.__init__(self)
Master.make_cake(self)
# 3.4 调用学校类
def make_School_cake(self):
School.__init__(self)
School.make_cake(self)
# 3.5 super调用父类的函数
def make_old_cake(self):
# 第一种:直接调用父类的初始化函数以及制作方法
# Master.__init__(self)
# Master.make_cake(self)
# School.__init__(self)
# School.make_cake(self)
# 第二种:super()默认第一父类
# super(Prentice,self).__init__()
# super(Prentice, self).make_cake()
# 第三种:super()函数
super().__init__()
super().make_cake()
'''
4.创建对象
'''
tudi = Prentice()
# 调用徒弟的函数
tudi.make_old_cake()
# 输出徒弟类的id
print("徒弟的id:",id(tudi))
mst = Master()
print("师父的id:",id(mst))
# __mro__魔法方法 获取到该类有哪些继承的父类
print(Prentice.__mro__)
print(list.__mro__)
05-私有权限
'''
05-私有权限
私有属性和私有函数
私有权限的设置为 __设置
1.私有属性
1.1 子类不能够直接调用父类的私有属性
1.2 私有属性只能够在本类中使用(类里面)
1.3 私有属性不可以使用对象调用(类外面)
1.4 私有属性保证数据的安全性
1.5 私有属性值可以在类里面修改和访问
2.私有函数
2.1 子类不可以调用父类的私有函数
2.2 私有函数只能够在本类中使用(类里面)
2.3 私有函数不可以使用对象调用(类外面)
2.4 私有函数可以保证数据的安全性
2.5 python中的定义函数名一般 get_XX获取私有属性值 定义set_XX修改私有属性值
'''
# 1.师傅类
class Master():
# 1.1 初始化函数
def __init__(self):
# 公共属性 可以被子类所调用的
self.kongfu = "[古法煎饼果子配方]"
# 私有属性
self.__money = 20000
def make_cake(self):
print(f"使用{self.kongfu}制作煎饼果子")
# 公共函数调用类中私有属性
def getMasterMoney(self):
# 调用类的私有函数
self.__huaMoney()
print(f"我需要使用自己的私房钱{self.__money}")
# 私有函数
def __huaMoney(self):
print(f"我要花自己的私房钱{self.__money}")
# 2.徒弟类
class Prentice(Master):
# 2.1 初始化函数
def __init__(self):
super().__init__()
# 2.2 制作方法
def make_cake(self):
print(f"使用{self.kongfu}制作煎饼果子")
# 2.3 获取钱
def getMoney(self):
#self.__huaMoney()
print(f"需要钱{self.__money}")
# 2.4 私有函数 花钱
# def __huaMoney(self):
# print(f"花自己的私房钱{self.__money}")
'''
3.创建对象
'''
tudi = Prentice()
tudi.make_cake()
# 不可以使用
# tudi.getMoney()
# 调用父类的公共函数使用父类的私有属性值
tudi.getMasterMoney()
# 调用父类的私有方法
# tudi.__huaMoney()
# 创建师父类
mst = Master()
# 对象调用私有函数 不可以被调用
# mst.__huaMoney()
# 对象调用私有属性 不可以被使用
# print("钱:",mst.__money)
mst.getMasterMoney()
06-多态
'''
06-多态
面向对象的编程的四大特征
1.多态--一个事物具有多种形态
多态定义:
多态是一种使用对象的方式,子类重写父类的方法,调用不同的子类对象和相同的父类方法,得到不同的结果
*个人理解：一千个人有一千个哈姆雷特，同一个哈姆雷特不同人有不同理解
同一个方法，不同人有不同标准，处理的方法也不同，结果也就不同了
多态好处:
更加的灵活,更容易编写出通用代码,可以使用不同的需求进行变化
*个人理解：灵活，满足个性化需求
多态的步骤:
1.定义父类 提供公共方法
2.定义子类 重写父类的方法
3.将子类对象传递给父类,可以查看不同的子类对象的结果
*父类先有这个行为，子类可以有不同的见解
就像康熙、雍正、乾隆虽然是祖孙三代，都喜欢瓷器，但是代代审美不同，保留下的各代瓷器种类就不一样
多态例子（老师的）：
class 王健林(object):
def money(self):
房地产、电影、商业
class 王思聪(王健林):
def money(self):
直播、游戏、电竞
class 王思思(王健林):
def money(self):
电信、软件、学校
2.封装--将事物的多种属性多种函数封装到类中(将所有工具放置(封装)工具箱 )
3.继承--将类进行扩展提高效率(减少重复性的使用)
4.抽象--将事物数据化成一个class出来
'''
# 1.师傅类
class Master():
age = 18
sex = '女'
height = 165
weight = 110
# 1.1 赚钱
def makeMoney(self):
print("师父靠手艺赚钱 5000块")
# 1.2 是否美女
def MeiNv(self):
if 18<=self.age<30 and self.sex == "女" \
and 165<=self.height<175 \
and 80<=self.weight<120:
print("师父>>>>美女")
# 1.3 将子类对象传递给父类可以查看子类不同的结果
def getMeiNv(self,obj):
print("="*30)
# 调用子类函数
obj.MeiNv()
# 2.徒弟类
class Prentice(Master):
# 2.1 徒弟赚钱函数 重写父类的函数
def makeMoney(self):
print("我上班赚钱每个月3000块")
# 2.2 是否是美女
def MeiNv(self):
if self.age == 18 and self.sex =='女' \
and self.height == 165 and \
self.weight == 110:
print("徒弟>>>美女")
# 3.徒孙类
class TuSun(Master):
# 3.1 徒孙赚钱的函数
def makeMoney(self):
print("我坑蒙拐骗去拿钱 10000块")
# 3.2 是否是美女
def MeiNv(self):
if self.sex == '女':
print("徒孙>>>美女")
'''
4.创建对象
'''
# 4.1 徒弟赚钱
tudi = Prentice()
tudi.makeMoney()
tudi.MeiNv()
# 4.2 徒孙赚钱
ts = TuSun()
ts.makeMoney()
ts.MeiNv()
# 4.3 师父
mst = Master()
mst.makeMoney()
mst.MeiNv()
# 4.4 将子类对象传递给父类查看子类的不同结果
# tudi子类对象
mst.getMeiNv(tudi)
# tusun子类对象
mst.getMeiNv(ts)
07-类属性和实例属性
'''
07-类属性和实例属性
实例属性:
实例化的属性的定义：
在init函数中定义的变量叫做实例化属性
只有在创建对象之后才可以使用
实例化的属性的访问:
1.类名访问实例化属性-不可用
2.对象访问实例化属性
实例化属性的修改:
1.类名修改实例化属性
2.对象修改实例化属性和其他实例化对象不相干
类属性:
类属性的定义：
类里面,函数外面定义的变量叫做类属性
类属性就是类对象所拥有的属性,是所有实例化对象所拥有的
类属性的访问:
1.类名访问
2.实例化对象访问
类属性的修改
1.类名设置类属性值(类的值以及对象值都改变)
2.对象设置类属性值(类的值不变,单个对象值改变)
注意事项:
1.对象修改类属性是创建了一个实例化属性
2.类属性定义需要保持一致的记录 占用的内存小
3.实例化属性是需要实例化对象开辟一片内存空间进行存储的
实例属性就是需要经常更改的记录
'''
class Dog():
# 类属性
age=0
tooth = 10
def __init__(self):
# 实例化属性
self.age = 5
'''1.访问类属性'''
# 创建对象
wangcai = Dog()
xiaohei = Dog()
# 类名调用类属性值
print("狗的牙齿:",Dog.tooth)
# 对象调用类属性值
print("旺财的牙齿:",wangcai.tooth)
print("小黑的牙齿：",xiaohei.tooth)
print("="*30)
'''2.修改类属性'''
Dog.tooth = 20
print("狗的牙齿:",Dog.tooth)
print("旺财的牙齿：",wangcai.tooth)
print("小黑的牙齿：",xiaohei.tooth)
print("="*30)
'''3.访问实例化属性'''
# 类访问实例化属性-不可用
# print("实例化狗的年龄:",Dog.age)
# 对象访问实例化属性
print("实例化旺财的年龄:",wangcai.age)
print("实例化小黑的年龄:",xiaohei.age)
print("="*30)
'''4.修改实例化属性'''
# **跟我想的有差别，什么set和get的问题，老师意识到问题却没解决
# 个人理解：实例化对象先用实例化的属性，先这么理解，不知道对不对，但不这样我也记不住
wangcai.age = 10
xiaohei.age = 15
Dog.age = 30
print("实例化狗的年龄:",Dog.age)
print("实例化旺财的年龄:",wangcai.age)
print("实例化小黑的年龄:",xiaohei.age)
08-类方法和静态方法
'''
08-类方法和静态方法
知识点:
类方法(cls)：需要使用类属性等数据可以使用类方法(类方面的数据调用)
类属性、类方法 需要使用cls
实例方法(self)：需要使用实例对象、实例属性、实例方法等(复杂的数据处理、代码处理)
实例化属性、实例化方法 需要使用self
静态方法()：始终在内存中,任何时候都可以调用(简单的代码)
什么都不需要,只需要自己搞
类方法:
1.使用装饰器@classmethod设置类方法#class--类，method--方法
2.默认第一个参数cls cls===>类对象===>Dog
3.使用场景:
当需要调用类对象以及类属性(私有属性等)
需要设置类方法
4.类方法一般和类属性配合使用
注意事项:
self ===>指的实例化对象的id值
cls ===>指的是类(Dog)的id值
cls.tooth
Dog.tooth
cls在当前类中代表的是Dog类
静态方法--（换言之：固定方法，静固如石）
*个人理解：定义简单，谁都能用
1.使用装饰器@staticmethod设置静态方法#static--静态的，method--方法
2.静态方法不需要传递类对象或者实例化对象
以及不需要设置类属性和实例化属性等
因此参数列表为空
3.静态方法既可以使用类对象的访问也可以使用实例化对象访问
4.使用场景:当既不需要类想以及实例化对象等
就可以使用静态方法
5.取消不必要的参数传递,可以减少内存的性能消耗
6.静态方法取消了不需要的参数传递,有利于减少不必要的内存占用和性能消耗
实例方法（都叫实例方法了，就是实例可以用且只能实例使用的方法）
1.实例方法只可以用实例化对象访问
'''
'''
1.类方法
'''
class Dog(object):
# 设置类属性 私有的
__tooth = 10
# 设置为类方法
@classmethod
def get_tooth(cls):
# cls 是什么 类的id值
print("cls:",cls)
print("cls的id值:",id(cls))
# 返回当前的类属性,调用当前类私有属性
return cls.__tooth
# 创建对象
wangcai = Dog()
print("旺财的id:",id(wangcai))
# 调用实例化对象的类方法
result = wangcai.get_tooth()
print("输出结果:",result)
print("="*20)
'''
2.静态方法
'''
class TaiDi():
# 设置静态方法
@staticmethod
def get_tooth():
print("泰迪的牙齿很厉害的")
# 设置实例方法
def getFace(self):
print("泰迪的脸很可爱")
#实例化方法可以调用静态方法
self.get_tooth()
# 类属性
students = [1,2,3,4,5]
# 设置静态方法
@staticmethod
def getMsg():
print("欢迎来到江苏师范大学,智慧教育学院")
# 设置类方法
@classmethod
def getClassMsg(cls):
for i in range(0,len(cls.students)):
print("类方法中：",i)
print("我的姓名是:",cls.getClassName())
@classmethod
def getClassName(cls):
return "张无忌"
# 创建对象
tai = TaiDi()
# 实例化对象调用静态方法
tai.get_tooth()
# 类调用静态方法
TaiDi.get_tooth()
# 实例化对象调用实例方法
tai.getFace()
# 类调用实例方法 -不可用
# TaiDi.getFace()
# 调用类方法
TaiDi.getClassMsg()
# 调用静态方法
TaiDi.getMsg()
09-异常
'''
09-异常
知识点:
*个人理解：
形式：
try[解释为测试，测试内容为:后面]:
肯发生错误的代码
except[1.啥也不写2.写猜测可能发生的异常]【as result[作为结果，结果内容为:后面内容]】:
错误发生执行的代码，result
【else:
非错误代码
finally:
无论如何执行代码】
【】内写的是可加可不加的内容
异常种类：NameError,ZeroDivisionError,FileNotFoundError。确定这些就写。
捕获所有的异常--->Exception，但我肯定写这个，偷懒。
1.异常定义:当解释器无法处理的时候,提出错误信息就是异常
2.异常的语法
try:
可能发生的错误代码(断网)
except:
错误发生执行的代码(断网无法上课 后面补)
3.捕获指定的异常--单个异常
try:
可能发生的错误代码
except(FileNotFoundError):
错误发生执行的代码
注意事项:
* 如果说指定的异常和捕获异常不一致,则无法处理
* 一般try下方必须有一行代码
4.捕获指定的异常--多种异常
当捕获多种异常的时候,可以将各种异常except()
后面是元组的形式书写
try:
可能出错的代码
except(异常名称1,异常名称2) as result:
print(result) 打印异常的错误信息
当已经捕获到异常1时，1后面的异常都不会捕获了
5.捕获所有的异常
Exception
6.异常的else
如果没有异常执行代码就会执行else代码
7.异常的finally
try:
可能出错的代码
except Exception as result:
异常的处理代码
else:
没有异常的代码块
finally:
无论如何都会执行的代码
'''
# 1.异常体验 FileNotFoundError
# file = open("test.txt",'r')
# file.close()
# 2.异常的写法
# try:
# open("test.txt",'r')
# except:
# print("文件找不到异常")
# file = open("test.txt",'w')
# file.close()
# 3.捕获异常--指定的异常
# try:
# open("taidi.txt",'r')
# except(FileNotFoundError):
# print("变量名没有定义,无此变量名")
# 4.捕获异常--多种指定异常
# try:
# print(1/0)
# except(NameError,ZeroDivisionError,FileNotFoundError) as result:
# print("捕获的异常时:",result)
# 5.捕获所有的异常
# try:
# print(num)
# open("zpp.txt",'r')
# print(1 / 0)
# except Exception as result:
# print("捕获的所有异常信息:",result)
# 6.异常的else 没有异常则不会执行else
# try:
# print(1)
# except Exception as result:
# print("else异常:",result)
# else:
# print("此代码块,没有异常信息")
# 7.异常的finally
try:
file = open("江苏师范.txt",'r')
except Exception as result:
print("异常finally模式:",result)
file = open("江苏师范.txt",'w')
else:
print("没有任何异常的情况")
finally:
print("最终执行的代码块")
10-异常的传递
'''
10-异常的传递
'''
import time
# 1.设置异常结构
try:
file = open("test.txt")
# 2.二层异常
try:
# 3.循环读取
while True:
# 4.读取一行的内容
content = file.readline()
# 5.如果读取的内从长度不够
if len(content) == 0:
break
# 6.睡眠2毫秒
time.sleep(2)
# 7.输出打印
print(content)
except:
print("产生意外,读取文件出错")
finally:
print("最终关闭文件")
file.close()
except :#FileNotFoundError
print("文件不存在,请重新查找")11-自定义异常
'''
11-自定义异常
知识点:
1.自定义异常的父类必须是Exception
2.自定义异常的触发函数 raise
'''
'''
1.自定义异常类
'''
class ShortInputError(Exception):
# 设置初始化值
def __init__(self,length,min_length):
# 设置实例属性
self.length = length
self.min_length = min_length
# 魔法方法
def __str__(self):
return f'您输入的信息是{self.length},'\
f'最小长度是{self.min_length}'
def main():
# 1.用户输入密码
pwd = input("请输入您的密码")
# 2.异常处理
try:
if len(pwd) < 10:
raise ShortInputError(len(pwd),10)
except ShortInputError as result:
print("自定义异常:",result)
else:
print("输入完成,密码长度合适")
if __name__ == '__main__':
main()12-异常的练习
'''
12-异常的练习
课后作业:模拟注册功能
账号,密码,电话号码,邮编
1.用户输入账号、密码、电话号码、邮编等信息
2.自定义异常处理
账号:nameError字母、数字、下划线的使用(1.字母+数字 2.字母+下划线 3.字母+下划线+数字)
密码:passwordError密码长度不够10个、密码不一致、密码需要有(大小写字母、数字等)
电话号码:phoneError 必须全是数字以及长度是11个
邮编:postError长度是6个且必须全是数字
3.对以上的信息进行异常的处理
4.使用类的方式写
'''
import sys,re
class nameError(Exception):
def __init__(self,name):
self.username=name
def __str__(self):
username = re.findall(r'[^0-9a-zA-Z_]', self.username)
return f'输入的账户{self.username}中有非法字符{username}'
class passwordError1(Exception):
def __init__(self,userpassword):
self.userpassword=userpassword
def __str__(self):
userpassword = re.findall(r'[^0-9a-zA-Z]', self.userpassword)
return f'输入的密码{self.userpassword}中有非法字符{userpassword}'
class passwordError2(Exception):
def __init__(self,userpasswordlen):
self.userpasswordlen=userpasswordlen
def __str__(self):
return f'输入的账户长度不足10'
class phoneError1(Exception):
def __init__(self,userphone):
self.userphone=userphone
def __str__(self):
userphone = re.findall(r'[^0-9]', self.userphone)
return f'输入的电话号码{self.userphone}中有非法字符{userphone}'
class phoneError2(Exception):
def __init__(self,userphonelen):
self.userphone=userphonelen
def __str__(self):
return f'输入的电话号码长度不为11'
class postError1(Exception):
def __init__(self,userpost):
self.userpost=userpost
def __str__(self):
userpost = re.findall(r'[^0-9]', self.userpost)
return f'输入的邮政编码{self.userpost}中有非法字符{userpost}'
class postError2(Exception):
def __init__(self,userpostlen):
self.userpostlen = userpostlen
def __str__(self):
return f'输入的邮政编码长度不为6'
def main():
while True:
#账号
name=input("请输入账号（由字母、数字、下划线组成）：")
username = re.findall(r'[^0-9a-zA-Z_]', name)
try :
if username!=[]:
raise nameError(name)
except Exception as result:
print("账号异常，",result)
else:
print("账号正常。")
break
while True:
#密码
password=input("请输入密码（由大小写字母、数字组成）：")
userpassword = re.findall(r'[^0-9a-zA-Z]', password)
try:
if userpassword != []:
raise passwordError1(password)
elif len(password)<10:
raise passwordError2(len(password))
except Exception as result:
print("密码异常，", result)
else:
print("密码正常。")
break
while True:
#电话号码
phone=input("请输入电话号码（数字）：")
userphone = re.findall(r'[^0-9]', phone)
try:
if userphone != []:
raise phoneError1(phone)
elif len(phone) < 10:
raise phoneError2(len(phone))
except Exception as result:
print("电话号码异常，", result)
else:
print("电话号码正常。")
break
while True:
#邮编
post=input("请输入邮政编码（数字）：")
userpost = re.findall(r'[^0-9]', post)
try:
if userpost != []:
raise postError1(post)
elif len(post) != 6:
raise postError2(len(post))
except Exception as result:
print("邮编异常，", result)
else:
print("邮编正常。")
break
print(f'注册成功！\n账号：{name}\n密码：{password}\n电话号码：{phone}\n邮编：{post}')
if __name__ == '__main__':
main()
'''
re函数
'''
# import re
# def main():
# inp=input("shuru:")
# #re.findall查询inp中是否满足r'[]'内的条件
# #0-9==>数字 a-z==>字母 A-Z==>大写字母 _==>下划线 ^==>非
# #userinp为列表类型 当inp中所有字符都不满足条件，则返回空列表；否则，返回满足条件的字符
# userinp=re.findall(r'[^0-9a-zA-Z_]',inp)
# print(userinp)
# if __name__ == '__main__':
# main()版权声明：本文为xingyunzizai原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接和本声明。