1. 构造方法__init__
# ### __init__ 构造方法
'''
触发时机：实例化对象,初始化的时候触发
功能：为对象添加成员
参数：参数不固定,至少一个self参数
返回值：无
'''
# (1) 基本语法
class MyClass():
def __init__(self):
print("构造方法被触发 ... ")
self.color = "屎黄色"
# 实例化对象
obj = MyClass()
print(obj.__dict__)
print(obj.color)
# (2) 带有多个参数的构造方法
class MyClass():
def __init__(self,color):
self.color = color
# 实例化对象
obj1 = MyClass("狗屎绿")
print(obj1.color)
obj2 = MyClass("粉嫩红")
print(obj2.color)
# (3)类可以是一个,对象可以是多个,创造的对象彼此是独立的;
class Children():
def __init__(self,name,skin):
self.name = name
self.skin = skin
def cry(self):
print("小孩一下生久哇哇哇的哭")
def la(self):
print("小孩一下生久拉粑粑")
def __eat(self):
print("小孩一下生就要吃奶奶..")
def info(self):
print("小孩的名字:{},小孩的肤色{}".format(self.name,self.skin))
def info2(self,name,skin):
print("小孩的名字:{},小孩的肤色{}".format(name,skin))
# 实例化对象
afanda = Children("阿凡达","深蓝色")
afanda.cry()
afanda.info()
haoke = Children("绿巨人","绿色的")
haoke.la()
haoke.info()
wangbaoqiang = Children("王宝强","亮绿色")
wangbaoqiang.info()
# wangbaoqiang.__eat() error
wangbaoqiang.info2("张保张","黄色")
2. 单继承_多继承
2.1 单继承
# ### 继承
"""
一个类除了自身所拥有的属性方法之外,还获取了另外一个类的成员属性和方法 是一种继承关系
被继承的类叫做父类(基类,超类),继承的类叫做子类(衍生类)
在python中所有类都继承object这个父类
继承: (1) 单继承 (2) 多继承
"""
# ### 单继承
class Human(object):
eye = "黑色的"
def jump(self):
print("古代人类都能上树")
def beat_animal(self):
print("古代人类都会打猎")
def __makefire(self):
print("古代人类会生火")
# (1) 子父继承之后,子类可以调用父类的公有成员
class Man(Human):
pass
obj = Man()
obj.jump()
# (2) 子父继承之后,子类不能调用父类的私有成员
class Woman(Human):
def pub_func(self):
self.__makefire()
obj2 = Woman()
# obj2.__makefire() 不行
# obj2.pub_func() 不行
# (3) 子父继承之后,子类可以重写父类的同名公有方法
class Children(Human):
def beat_animal(self):
print("小孩天生只会打豆豆,不会打猎")
obj3 = Children()
obj3.beat_animal()
2.2 多继承
# ### 多继承
# (1) 基本语法
class Father():
property = "风流倜傥,才华横溢,玉树临风,才高八斗,学富五车,英姿洒窗"
def f_hobby(self):
print("吃喝嫖赌抽,坑蒙拐骗偷,抽烟喝酒烫头")
class Mother():
property = "倾国倾城,貌美如花,沉鱼落雁,闭月羞花,婀娜多姿,前凸后翘"
def m_hobby(self):
print("蹦野迪,社会摇,打麻将,网红勾引小鲜肉")
class Daughter(Father,Mother):
pass
obj = Daughter()
print(obj.property)
obj.m_hobby()
# (2) 多继承的成员调用
print("<=================>")
class Father():
property = "风流倜傥,才华横溢,玉树临风,才高八斗,学富五车,英姿洒窗"
def f_hobby():
print("吃喝嫖赌抽,坑蒙拐骗偷,抽烟喝酒烫头")
class Mother():
property = "倾国倾城,貌美如花,沉鱼落雁,闭月羞花,婀娜多姿,前凸后翘"
def m_hobby(self):
print(self.property)
print("蹦野迪,社会摇,打麻将,网红勾引小鲜肉")
"""
(1)super本身是一个类 super()是一个对象 用于调用父类的绑定方法
(2)super() 只应用在绑定方法中,默认自动传递self对象 (前提:super所在作用域存在self)
(3)super用途: 解决复杂的多继承调用顺序
"""
class Son(Father,Mother):
property = "打游戏,吃小零食"
def m_hobby(self):
print("son中m_hobby方法")
# 用类调用成员
def skill1(self):
Father.f_hobby()
print(Mother.property)
# 用对象调用成员
"""self按照顺序找: 对象本身 => 类 => 父类 对应的成员 """
def skill2(self):
print(self.property)
self.m_hobby()
# 用super调用成员
"""super()只调用父类的相关成员,顺带传递对象参数"""
def skill3(self):
print(super())
print(super().property)
super().m_hobby()
obj2 = Son()
# obj2.skill1()
obj2.property = "喜欢看lol,dnf,wow,跑跑卡丁车,ddo,霸王大陆,澄海3c"
# obj2.skill2()
obj2.skill3()
3. super的深度理解
# ### 菱形继承 (钻石继承)
"""
Human
Man Woman
Children
"""
class MyClass():
pass
class Human():
pty = 1
def feelT(self):
print("古代人类,天热了,光腚1")
print(self.pty)
print("古代人类,天冷了,穿寿衣2")
class Man(Human):
# pty = 2
def feelT(self):
print("男人,天热了,光膀子3")
print(super(),"<==2==>")
super().feelT()
print("男人,天冷了,光腚4")
class Woman(Human):
# pty = 3
def feelT(self):
print("女人,天热了,脱毛5")
print(super(),"<==3==>")
super().feelT()
print("女人,天冷了,穿貂6")
class Children(Man,Woman):
# pty = 4
def feelT(self):
print("小孩,天热了,光腚7")
print(super(),"<==1==>")
super().feelT()
print("小孩,天冷了,多喝热水8")
# ### super的深层理解
obj = Children()
obj.feelT()
# 73512648
"""
# mro: 方法解析顺序 (c3算法计算的)
# 语法: 类.mro() => 列表
m :method
r :resolution
o :order
super 会自动根据mro列表返回出来的顺序关系,依次调用
super作用:专门用于解决复杂的多继承调用顺序关系;依照mro返回的列表顺序,依次调用;
super调用的顺序:会按照c3算法的广度优先原则进行调用
super传参:会默认在调用方法时,传递该对象参数;
"""
lst = Children.mro()
print(lst)
"""
[
<class '__main__.Children'>,
<class '__main__.Man'>,
<class '__main__.Woman'>,
<class '__main__.Human'>,
<class 'object'>
]
"""
# ### issubclass与isinstance
# issubclass 判断类的子父关系(应用在类与类之间)
"""只要在一条继承链上满足关系即可"""
res = issubclass(Children,Man)
res = issubclass(Children,Human)
res = issubclass(Children,MyClass)
# 如果元组当中有一个父类满足,即返回真
res = issubclass(Children, (Man,Human,MyClass) )
print(res)
# isinstance 判断对象的类型 (应用在类与对象之间)
"""只要在一条继承链上满足关系即可"""
res = isinstance(obj,Children)
res = isinstance(obj,Human)
res = isinstance(obj,MyClass)
# 如果元组当中有一个类满足,即返回真
res = isinstance(obj, (Man,Human,MyClass) )
print(res)
小提示：
self参数要放在第一位，调用的时候，不用自己传参数，系统自动传的（传的是对象）
如果对象里面没有这种这种方法，那么就会去类里面去调用（先找对象，再找类）
如果本类中没有这种方法，那么就回去父类中去调用方法（先找类，后找父类）
对象有没有-->创建这个对象的类有没有-->这个类的父类有没有
如果继承多个父类，那么调用方法是，从左到右依次去找父类
super只调用父类，顺便把对象参数也传到父类里面
self先看自己有没有，super只看父类有没有
4. 注册_登录
# ### 注册
# (1)检测两次密码如果相同,确认注册成功
# (2)检测两次密码如果不同,提示两次密码不一致
# (3)用户名不能重复
# ### 登录小程序
# 账户密码会预先记录在文件中
# 输入账号密码:如果都正确,登录成功
# 如果用户登录时进行三次校验,都不对,记录黑名单文件中
# 如果是黑名单的用户,禁止下次再次登录
4.1 注册
# ### 注册
# (1)检测两次密码如果相同,确认注册成功
# (2)检测两次密码如果不同,提示两次密码不一致
# (3)用户名不能重复
# 存放账户的列表
accountlist = []
fp = open("user.txt",mode="r+",encoding="utf-8")
for i in fp:
# 获取账户名
account = i.split(":")[0]
# 添加到账户列表
accountlist.append(account)
sign = True
while sign:
name = input("请输入您要注册的用户名：")
if name == "" or " " in name:
print("抱歉,该名字中含有非法字符")
else:
# 判断改名字是否被注册过了
if name in accountlist:
print("抱歉~ 您的用户名已被注册~")
else:
# 这个名字允许使用
# 确认用户的密码 输入第一次
pwd1 = input("请输入您的密码:")
while True:
# 确认用户的密码 输入第二次
pwd2 = input("请确认您的密码:")
if pwd1 == pwd2:
# 可以存储该账户密码到文件中
strvar = name + ":" + pwd2 + "\n"
fp.write(strvar)
fp.close()
sign = False
print("恭喜你~ 注册成功~")
break
# 退出当前的注册状态
elif pwd2.upper() == "Q":
print("欢迎下次再来~")
break
# 密码不一致
else:
print("两次密码不一致~")
用户名单user.txt
wangwen:111
lisi:222
zhangsan:333
zhaoliu:666
4.2 登录
# ### 登录小程序
# 账户密码会预先记录在文件中
# 输入账号密码:如果都正确,登录成功
# 如果用户登录时进行三次校验,都不对,记录黑名单文件中
# 如果是黑名单的用户,禁止下次再次登录
# 账户列表
accountlist = []
# 密码列表
pwdlist = []
# 黑名单列表
blacklist = []
with open("user.txt",mode="a+",encoding="utf-8") as fp:
fp.seek(0)
lst = fp.readlines()
# print(lst)
for i in lst:
user,pwd = i.strip().split(":")
# print(user,pwd)
accountlist.append(user)
pwdlist.append(pwd)
# 账户列表和密码列表,按照相同的索引下标一一对应
# print(accountlist) # ['wangwen', 'lisi', 'zhangsan', 'zhaoliu']
# print(pwdlist) # ['111', '222', '333', '666']
sign = True
while sign:
name = input("请输入您的用户名")
if name in accountlist:
# 打开黑名单,
with open("black.txt",mode="a+",encoding="utf-8") as fp:
fp.seek(0)
lst = fp.readlines()
for i in lst:
blacklist.append(i.strip())
# print(blacklist)
# 检测是否是拉黑的用户
if name in blacklist:
print("抱歉~ 该账户已经被冻结,请联系客户人员~")
else:
# 走到这个分支,说明是合法用户,可以让用户输入密码
index_num = accountlist.index(name)
# print(index_num)
# 通过索引号获取密码
pwd_true = pwdlist[index_num]
# print(pwd_true)
# 控制密码输错次数不超过3次
times = 1
while times <= 3:
ask_pwd = input("请输入您的登录密码:")
if ask_pwd == pwd_true:
print("恭喜您~ 登录成功~")
sign = False
break
else:
# 剩下次数 = 总次数-使用过的次数
print("抱歉您的密码输入错误,还剩下{}机会".format(3-times))
if times == 3:
print("抱歉~,输错三次,您的账号被冻结~")
# 把当前用户拉黑,记录到黑名单中
with open("black.txt",mode="a+",encoding="utf-8") as fp:
strvar = name + "\n"
fp.write(strvar)
times +=1
else:
print("抱歉,该用户名不存在")
黑用户名单black.txt
lisi
5. 小练习
# ### 1.完成下列功能:
# 1.1创建一个人类Person,再类中创建3个成员属性
# animal = '高级动物'
# soul = '有灵魂'
# language = '语言'
# 1.2在类中定义三个方法,吃饭,睡觉,工作.
# 1.3在此类中的__init__方法中,给对象封装5个属性: 国家 , 姓名 , 性别 , 年龄 , 身高.
# 1.4实例化四个人类对象:
# 第一个人类对象p1属性为:中国,alex,未知,42,175.
# 第二个人类对象p2属性为:美国,武大,男,35,160.
# 第三个人类对象p3属性为:你自己定义.
# 第四个人类对象p4属性为:p1的国籍,p2的名字,p3的性别,p2的年龄,p3的身高.
# 1.5 通过p1对象执行吃饭方法,方法里面打印:alex在吃饭.
# 1.6 通过p2对象执行吃饭方法,方法里面打印:武大在吃饭.
# 1.7 通过p3对象执行吃饭方法,方法里面打印:(p3对象自己的名字)在吃饭.
# 1.8 通过p1对象找到类中成员属性animal
# 1.9 通过p2对象找到类中成员属性soul
# 2.0 通过p3对象找到类中成员属性language
# ### 2.通过自己创建类,实例化对象
#通过调用对象当中的方法,在终端输出如下信息
#小明，10岁，男，上山去砍柴
#小明，10岁，男，开车去东北
#小明，10岁，男，最爱大保健
#老李，90岁，男，上山去砍柴
#老李，90岁，男，开车去东北
#老李，90岁，男，最爱大保健
# ### 3.模拟英雄联盟写一个游戏人物的类
#要求:
#(1) 创建一个 Game_role 的类.
#(2) 构造方法中给对象封装 name,ad(攻击力),hp(血量).三个属性.
#(3) 创建一个attack方法,此方法是实例化两个对象,互相攻击的功能:
#例: 实例化一个对象 盖伦,ad为10, hp为100
#实例化另个一个对象 剑豪 ad为20, hp为80
#盖伦通过attack方法攻击剑豪,此方法要完成 '谁攻击谁,谁掉了多少血, 还剩多少血'的提示功能.
# ### 4.请定义一个圆形类,有计算周长和面积的两个方法 (圆的半径通过参数传递给初始化方法)
# ### 5创建AB两个类，A类中有属性abc=5把A类的对象存储在B类对象的成员属性pty中,用B类对象调用出abc这个值.
# ### 简答题
# 1.类或对象是否能做字典的key
# 2.简述python的私有成员是如何实现的 _
# 3.私有成员能在类的外部使用么?能在子类中使用么?
# ### 读代码,写答案
# 1.读程序写结果.(不执行)
class StarkConfig(object):
def __init__(self,num):
self.num = num
def changelist(self,request):
print(self.num,request)
class RoleConfig(StarkConfig):
def changelist(self,request):
print('666')
# 创建了一个列表,列表中有三个对象(实例)
config_obj_list = [StarkConfig(1),StarkConfig(2),RoleConfig(3)]
for item in config_obj_list:
print(item.num)
# 2.读程序写结果.(不执行)
class StarkConfig(object):
def __init__(self,num):
self.num = num
def changelist(self,request):
print(self.num,request)
class RoleConfig(StarkConfig):
pass
# 创建了一个列表,列表中有三个对象(实例)
config_obj_list = [StarkConfig(1),StarkConfig(2),RoleConfig(3)]
for item in config_obj_list:
item.changelist(168)
print(config_obj_list[0].num)
# 3.读程序写结果.(不执行)
class StarkConfig(object):
def __init__(self,num):
self.num = num
def changelist(self,request):
print(self.num,request)
class RoleConfig(StarkConfig):
def changelist(self,request):
print(666,self.num)
config_obj_list = [StarkConfig(1),StarkConfig(2),RoleConfig(3)]
for item in config_obj_list:
item.changelist(168)
# 4.读程序写结果.(不执行)
class StarkConfig(object):
def __init__(self,num):
self.num = num
def changelist(self,request):
print(self.num,request)
def run(self):
self.changelist(999)
class RoleConfig(StarkConfig):
def changelist(self,request):
print(666,self.num)
config_obj_list = [StarkConfig(1),StarkConfig(2),RoleConfig(3)]
config_obj_list[1].run()
config_obj_list[2].run()
# 5.读程序写结果.(不执行)
class StarkConfig(object):
def __init__(self,num):
self.num = num
def changelist(self,request):
print(self.num,request)
def run(self):
self.changelist(999)
class RoleConfig(StarkConfig):
def changelist(self,request):
print(666,self.num)
class AdminSite(object):
def __init__(self):
self._registry = {}
def register(self,k,v):
self._registry[k] = v
site = AdminSite()
print(len(site._registry))
site.register('range',666)
site.register('shilei',438)
print(len(site._registry))
site.register('lyd',StarkConfig(19))
site.register('yjl',StarkConfig(20))
site.register('fgz',RoleConfig(33))
print(len(site._registry))
print(site._registry)
# 6.读程序写结果.(不执行)
class StarkConfig():
def __init__(self,num):
self.num = num
def changelist(self,request):
print(self.num,request)
def run(self):
self.changelist(999)
class RoleConfig(StarkConfig):
def changelist(self,request):
print(666,self.num)
class AdminSite():
def __init__(self):
self._registry = {}
def register(self,k,v):
self._registry[k] = v
site = AdminSite()
site.register('lyd',StarkConfig(19))
site.register('yjl',StarkConfig(20))
site.register('fgz',RoleConfig(33))
for k,row in site._registry.items():
row.changelist(5)
for k,row in site._registry.items():
row.run()
# 7.读程序写结果.(不执行)
class JustCounter:
__secretCount = 0
def count(self):
print(self.__secretCount) # 获取
self.__secretCount += 1
def count3():
print(JustCounter.__secretCount)
JustCounter.__secretCount += 1
print(JustCounter.__secretCount)
class Bars(JustCounter):
def count2(self):
print(self.__secretCount)
# 情况一
counter1 = JustCounter()
counter1.count()
counter1.count()
JustCounter.count3()
# 情况二
counter2 = Bars()
counter2.count()
counter2.count()
# 情况三
JustCounter.count3()
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
