2021-01-30

python方法不能重载：定义多个同名方法，只有最后一个有效

class Person:
    def say_hi(self,name):
        print("{0},hello".format(name))
    def say_hi(self):
        print("hello")
p1 = Person()
p1.say_hi()

方法的动态性：动态的为类添加新的方法，或者动态的修改类的已有的方法。

class Person:
    def work(self):
        print("努力上班")

def play_game(s):
    print("玩游戏：{0}".format(id(s)))
    print(id(s))

def work2(s):
    print("好好工作")

print(play_game("xioxixi"))
p = Person()
c = Person()
Person.hhh = play_game
p.hhh()
c.hhh()
Person.work = work2
p.work()

私有属性和私有方法(实现封装)

1. 通常我们约定，两个下划线开头的属性是私有的(private)。其他为公共的(public)。
2. 类内部可以访问私有属性(方法)
3. 类外部不能直接访问私有属性(方法)
4. 类外部可以通过“_类名__私有属性(方法)名”访问私有属性(方法)

class Employee:
    __company = "百战程序员" #私有类属性. 通过dir 可以查到_Employee__company
    def __init__(self,name,age):
        self.name = name
        self.__age = age #私有实例属性
    def say_company(self):
        print("我的公司是：",Employee.__company) #类内部可以直接访问私有属性
        print(self.name,"的年龄是：",self.__age)
        self.__work()
    def __work(self): #私有实例方法通过dir 可以查到_Employee__work
        print("工作！好好工作，好好赚钱，娶个媳妇！")

p1 = Employee("高淇",32)
print(p1.name)
print(dir(p1))
p1.say_company()
print(p1._Employee__age) #通过这种方式可以直接访问到私有属性。通过dir 可以查到属性：_Employee__age
#print(p1.__age) #直接访问私有属性，报错
#p1.__sleep() #直接访问私有方法，报错
一宁
@property 装饰器
class Employee:
    def __init__(self, name, salary, age):
        self.name = name
        self.__age = age
        self.__salary = salary

    @property  # 相当于salary 属性的getter 方法
    def sal(self):
        print("月薪为{0},年薪为{1}".format(self.__salary, (12 * self.__salary)))
        return self.__salary;

    @property  # 相当于salary 属性的getter 方法
    def ag(self):
        print("年龄为{0}".format(self.__age))
        return self.__salary;

    @sal.setter  # 如果涉及两个属性（增加一个age）的更改这个位置应该怎么写？
    def sss(self, salary):
        if (0 < salary < 1000000):
            self.__salary = salary

    @ag.setter
    def aaa(self, age):
        self.__age = age

emp1 = Employee("高淇", 100, "xxx")
print(emp1.sal)
emp1.sss = (-200)
emp1.aaa = ("hahaha")

如果父类中有相同名字的方法，在子类没有指定父类名时，解释器将
“从左向右”按顺序搜索。

class A:
    def aa(self):
        print("aa")
    def say(self):
        print("say AAA!")
class B:
    def bb(self):
        print("bb")
    def say(self):
        print("say BBB!")
class C(A,B):
    def cc(self):
        print("cc")
c = C()
print(C.mro()) #打印类的层次结构
c.say() #解释器寻找方法是“从左到右”的方式寻找，此时会执行B类中的say()

super()获得父类定义

#super()
class A:
    def say(self):
        print("A: ",self)
        print("say AAA")
class B(A):
    def say(self):
        A.say(self) 调用父类的say 方法
        super().say() #通过super()调用父类的方法
        print("say BBB")
b = B()
b.say()

一宁
多态: 1. 多态是方法的多态，属性没有多态。
2. 多态的存在有2 个必要条件：继承、方法重写。

class Animal:
    def __init__(self, name,age):
        self.name = name
        self.__age = age
    def shout(self):
        print("动物叫了一声")
class Dog(Animal):
    def shout(self):
        print("小狗，汪汪汪")
class Cat(Animal):
    def __init__(self, name,age,weight):
        self.weight = weight
        Animal.__init__(self, name,age)
    def shout(self):
        print("小猫，喵喵喵")
class Pig:
    pass

def animalShout(a):
    if isinstance(a,Animal):
        a.shout() #传入的对象不同，shout 方法对应的实际行为也不同。
    else:
        print("不会叫")

animalShout(Dog("dog",2))
animalShout(Cat("cat",3,60))
animalShout(Pig)
a=Cat("meiduan",15,80)
print(a.name)
#print(a.age)        私有实例不能这样调用
print(a._Animal__age)
print(a.weight)

特殊方法重载

class Person:
    def __init__(self,name):
        self.name = name
    def __add__(self, other):
        if isinstance(other,Person):
            return self.name+other.name
        else:
            return "不是同类对象，不能相加"
    def __mul__(self, other):
        if isinstance(other,int):
            return self.name*other
        else:
            return "不是同类对象，不能相乘"
p1 = Person("高淇")
p2 = Person("高希希")
x = p1 + p2
print(x)
print(p1*3)