一、类的私有属性和方法
_x 单前置下划线,表示私有属性或方法,但是类对象和子类可以访问
__x 双前置下划线,私有属性或方法,只有类对象自己能访问,子类不能访问
__x__ 魔法方法或属性
class Classmate:
name = 'lucy'
_age = 20 # 伪私有属性
__sex = 'F' # 私有属性
c = Classmate()
print(c._age) # 对象可以在外部访问伪私有属性
输出：20
# # print(c.__sex) # 私有属性,在外部不能直接访问
输出：报错
# # 强行获取私有属性 对象._类名私有属性名
print(c._Classmate__sex)
输出：F
print(c.name)
输出：lucy
怎么通过合理地手段获取私有属性或方法?
---解决方案:定义公有方法,在公有方法里去访问这个私有属性或调用私有方法即可
class Classmate:
def __init__(self):
self.__name = 'rose'
def __func(self): # 私有方法
print('这是私有方法')
def funa(self): # 公有方法
print('嘿嘿')
print(self.__name)
self.__func()
c = Classmate()
# c.__func() # 直接调用--报错
c.funa()
输出：嘿嘿
rose
这是私有方法
二、继承
继承的语法
class 类名(父类名):
pass
1.不使用继承
class Person:
def sing(self):
print('唱歌')
def dance(self):
print('跳舞')
p = Person()
p.sing()
p.dance()
输出：唱歌
跳舞
2、使用继承
class Mother:
def sing(self):
print('唱歌')
def dance(self):
print('跳舞')
class Rose(Mother):
pass
r = Rose()
r.sing()
r.dance()
输出：唱歌
跳舞
例：
class Father:
def init(self, name, age, property1):
self.name = name
self.age = age
self.property1 = property1
def diao_cha(self):
print(f'{self.name}是个富翁,年龄是{self.age}岁,有财产{self.property1}万')
class Child(Father):
pass
p = Child('follow heart', 20, 100)
p.diao_cha()
输出：follow heart是个富翁,年龄是20岁,有财产100万
三、继承的传递和重写、扩展
1.继承的传递 ---- 接力赛
class Animal: # 爷爷
def __init__(self, name):
self.name = name
def eat(self):
print("吃--")
def drink(self):
print("喝--")
class Dog(Animal): # 爸爸辈
def bark(self):
print(f'{self.name}会汪汪叫')
class Black(Dog): # 儿子
def sa_jiao(self):
print(f"{self.name}会撒娇")
# # 创建一个对象
black = Black('小黑')
black.sa_jiao()
输出：小黑会撒娇
2.重写 ---- 覆盖写
例1：
class Father:
def myMethod(self):
print('老爸的学习方法')
class Child(Father):
def myMethod(self):
print('儿子的学习方法')
c = Child()
c.myMethod()
例2：
class ZuBei():
def mi_fang(self):
print('祖传火锅秘方')
class You(ZuBei):
def mi_fang(self):
print('研发出全新的火锅秘方')
you = You()
you.mi_fang()
3.扩展 --- 保留原来的，在原来的基础上拓展
扩展父类 ---本质是调用父类的方法
- 法1：父类名.方法名(self)
- 法2：super().父类方法
class ZuBei():
def mi_fang(self):
print('祖传火锅秘方')
class You(ZuBei):
def mi_fang(self):
# 法一
# ZuBei.mi_fang(self)
# 法二
super().mi_fang()
print('研发出升级火锅秘方')
you = You()
you.mi_fang()
四、多继承
子类可以拥有多个父类，并且具有所有父类的属性和方法
多继承的语法： class 类名(父类1,父类2...)
class Dad:
def work(self):
print('积累了很多的工作经验')
class Mom:
def housework(self):
print('拥有超多的家务经验')
class Child(Dad,Mom):
pass
c = Child()
c.work()
c.housework()
两个父类有同名方法，继承调用时怎么办？
class Dad(object):
def play(self):
print('爸爸休闲时喜欢钓鱼')
class Mom:
def play(self):
print('妈妈休闲时喜欢打牌')
class Child(Mom,Dad): # 继承：就近原则
pass
c = Child()
c.play()
print(Child.__mro__) # 确定Child类对象调用方法的顺序
class Dad(object):
def play(self):
print('爸爸休闲时喜欢钓鱼')
class Mom:
def play(self):
print('妈妈休闲时喜欢打牌')
class Child(Mom,Dad): # 继承：就近原则
def play(self):
父类的扩展
Dad.play(self)
super().play() # 用super()调用时，调用依据继承顺序来
print('孩子休闲时喜欢玩游戏')
c = Child()
c.play()
五、多态
多态：多种形态
print(1 + 1) # + 表示加法
print('hello' + 'python') # 字符串的拼接
多态性：一种调用方式，不同的执行结果
----可以定义一个统一的接口，传入不同类型的值，但是调用逻辑一样，执行结果不一样
class Duck(object):
def fly(self):
print('鸭子在水里飞起来了')
class Swan(object):
def fly(self):
print('天鹅在空中翱翔')
class Plan(object):
def fly(self):
print('飞机在机场隆隆地起飞了')
# duck = Duck()
# duck.fly()
# swan = Swan()
# swan.fly()
# plan = Plan()
# plan.fly()
# 定义一个统一的接口
def func(obj):
obj.fly()
duck = Duck()
swan = Swan()
plan = Plan()
func(duck)
func(swan)
func(plan)
六、__new__
实例化一个对象
对象名 = 类名() 到底怎么创建出来的？
__new__()有两个作用：
1.在内存中为对象分配空间
2. 返回对象的引用，返回值引发__init__()的调用
实例化一个对象，真正第一个调用的是__new__()方法
class Person(object):
def __init__(self):
print('这是init方法')
def __new__(cls, *args, **kwargs): # cls作为第一个参数 class
print('这是new方法中的cls',cls)
print('这是new方法')
# return object.__new__(cls) # 创建对象
# return super().__new__(cls)
p = Person()
class Iphone(object):
def __new__(cls, *args, **kwargs):
print('这是new中cls',cls)
print('创建对象,分配空间')
ins = super().__new__(cls)
print('这是new中的ins',ins)
return ins
def __init__(self):
print('这是init中的self',self)
print('手机初始化')
print('这是类',Iphone)
pho = Iphone()
print('这是实例化对象',pho)
class A:
pass
a = A()
print(a)
eval（) 去掉引号
