Python基础语法- 6-2

(补 6-1)
方法没有重载

Python中没有方法的重载！！

定义一个方法即可有多种调用方式，
相当于其他语言中的方法的重载。

在类体中定义了多个重名的方法，只有最后一个方法有效。

建议：不要使用重名的方法！

方法的动态性

可以动态的为类添加新的方法，

或者动态的修改类的已有的方法。

    class Person:
        def work(self):
            print("work hard!")
    
    def play_game(self):
        print("{0}paly game".format(self))
    
    def work2(s):
        print("work hard!play game!")
        
    Person.play = play_game     # 新增方法
    Person.work = work2     # 修改已有方法
    
    p = Person()
    p.play()
    p.work
    
    #   结果：
    #   Person 动态的新增了 play_game 方法，work2 替换了 work方法。

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

Python对于类的成员 没有 严格的访问控制限制。

私有属性和私有方法：

  1. 两个下划线开头的属性是私有的(private)。其他为公共的(public)
  
  2. 类内部可以访问私有属性(方法)，类外部不能直接访问私有属性(方法)

  3. 类外部可以通过“_类名 私有属性(方法)名”访问私有属性(方法)

  4. 方法本质上也是属性！只不过是可以通过()执行。所以，此处也是私有方法和公有方法的用法。

@property 装饰器

@property可以将一个方法的调用方式变成“属性调用”。

    class Employee:
        @property
        def salary(self):
            return 30000   
    
    emp1 = Employee()
    print(emp1.salary)  # 将方法像属性一样调用了
    
    # print(type(emp1.salary))

几个实例比较 体会一下

    # 一个普普通通的脑子 想到的普普通通的类的调用
    # 犯了一堆普普通通的错误
    class Employee:
        def __init__(self,name,salary):
            self.name = name
            self.salary = salary
    
    empl = Employee('hhh',1000)
    print(empl.name)
    print(empl.salary)
    
    empl.salary = -2000     # 这样搞：属性都没有私有，那用户都随便改你的内容了 
    print (empl.salary)

    # 高级了一点，知道封装起来了
    class Employee:
        def __init__(self,name,salary):
            self.name = name
            self.__salary = salary
    
        def get_salary(self):
            return self.__salary    # 此时，__salary为私有属性
    
        def set_salary(self,salary):
        if 1000<salary<20000:  # 写顺手了 别忘了python里 if等没有括号
            self.__salary = salary
        else:
            print("工资范围输入错误！应该在1000~20000内")
    
    empl = Employee('hhh',1000)
    print(empl.get_salary())
    empl.set_salary(5000)
    print(empl.get_salary())

    # 用@property 实现 对方法像属性一样调用
    class Employee:
        def __init__(self,name,salary):
            self.name = name
            self.__salary = salary
    
        @property
        def salary(self):
            return self.__salary
    
        @salary.setter
        def salary(self,salary):   # 这里参数还有一个输入变量salary呢 别忘了！！
            if 1000 < salary < 20000:
                self.__salary = salary
            else:
                print("工资范围输入错误！应该在1000~20000内")
    
    empl = Employee('hhh', 1000)
    print(empl.salary)
    empl.salary = 5000
    print(empl.salary)
    

6-2 面向对象（进阶）

6-2.1 面向对象三大特征介绍

继承、封装（隐藏）、多态。

• 封装（隐藏）

只对外暴露“相关调用方法”。

Python追求简洁的语法，没有严格的语法级别的“访问控制符”，更多的是依靠程序员自觉实现。

• 继承

  继承可以让子类具有父类的特性，提高了代码的重用性。

• 多态

多态是指同一个方法调用由于对象不同会产生不同的行为。

6-2.1.1 继承

实现“代码复用”。

已有的类，我们称为“父类或者基类”，新的类，我们称为“子类或者派生类”（直接具备了已有类的特征）。

• Python 支持多重继承，一个子类可以继承多个父类。

    如果在类定义中没有指定父类，则默认父类是object类。
    也就是说，object是所有类的父类。
    
    object里面定义了一些所有类共有的默认实现，比如：_new_()。
  

# 继承的简单例子
    class Person:
        def __init__(self,name,age):  # 别又忘了添加变量！！
            self.name = name
            # self.age = age
            # 如果把 age 改成私有属性
            self.__age =  age
    
        def say_age(self):
            # print (self.name,"的年龄是：",self.age)
            print ("{0}的年龄是：{1}".format(self.name,self.age))
    
    class Student(Person):
        def __init__(self,name,age,score):
            self.score = score  # 子类的私有属性
            Person.__init__(self,name,age)  # 调用父类的初始化构造器
            # 想要继承 必须显式的调用父类的初始化方法，不然解释器不会去调用
    
    s1 = Student("xxx",16,100)
    # s1.say_age() # 注意这里也因为私有的原因不能用了！
    
    # print (s1.age) # 会报错 因为age 为私有属性 不能这么调用了!
    # 怎么用呢？用dir()看s1现在的属性 然后复制粘贴显示！
    
    print (dir(s1)) # 显示s1有哪些属性
    
    print (s1._Person__age)

类成员的继承和重写

1. 成员继承：子类继承了父类除构造方法之外的所有成员。

2. 方法重写：子类可以重新定义父类中的方法，这样就会覆盖父类的方法，也称为“重写”

查看类的继承层次结构

通过类的方法mro()或者类的属性 mro 可以输出这个类的继承层次结构。

object 根类

dir()查看对象属性

重写 str ()方法

object 有一个 str()方法，用于返回一个对于“对象的描述”

print()方法，帮助我们查看对象的信息。
str()可以重写。

多重继承

Python支持多重继承，一个子类可以有多个“直接父类”。

异常复杂，尽量避免使用。

MRO()

Python支持多继承，如果父类中有相同名字的方法，在子类没有指定父类名时

print(C.mro())

解释器将
==“从左向右”==按顺序搜索。

MRO（Method Resolution Order）：方法解析顺序。

通过mro()方法获得“类的层次结构”
方法解析顺序也是按照这个“类的层次结构”寻找的。

super()获得父类定义

在子类中获得父类的方法

super()代表父类的定义，不是父类对象。

（即：子类和父类找到的是一个东西，没有新建对象）

    # 子类中：
    # 这两种都可
    A.say(self)
    super().say()

6-2.1.2 多态

不同实现。

注：

1. 多态是方法的多态，属性没有多态。

2. 多态的存在有 2 个必要条件：继承、方法重写。

6-2.1.3 特殊方法和运算符重载

• Python 的运算符实际上是通过调用对象的特殊方法实现的。

我们可以重写上面的特殊方法，即实现了“运算符的重载”。

class Person:
    def init (self,name):     
        self.name = name

    def add (self, other):
        if isinstance(other,Person):
            return "{0}--{1}".format(self.name,other.name) 
        else:
            return "不是同类对象，不能相加"
    
    def mul (self, other):
        if isinstance(other,int): 
            return	self.name*other
        else:
            return "不是同类对象，不能相乘"

p1 = Person("baba") 
p2 = Person("son")

x = p1 + p2 print(x)

print(p1*3)

# 结果
# baba--son
# sonsonson

特殊属性

对象的浅拷贝和深拷贝

• 变量的赋值操作

  只是形成两个变量，实际还是指向同一个对象。

• 浅拷贝

Python拷贝一般都是浅拷贝。
拷贝时，对象包含的子对象内容不拷贝。

因此，源对象和拷贝对象会引用同一个子对象。

• 深拷贝

  使用 copy 模块的 deepcopy 函数，递归拷贝对象中包含的子对象。

  源对象和拷贝对象所有的子对象也不同。

组合

• “is-a”关系，使用“继承”。

    dog is animal。
    狗类就应该继承动物类。
  

• “has-a”关系，使用“组合”。

    MobilePhone has a CPU.
    手机拥有 CPU。 
  

6-2.1.4 设计模式_工厂模式实现

设计模式是面向对象语言特有的内容，是我们在面临某一类问题时候固定的做法。

设计模式有很多种，比较流行的是：GOF（Goup Of Four）23种设计模式

对于初学者，我们学习两个最常用的模式：工厂模式和单例模式。

• 工厂模式

    实现了创建者和调用者的分离，
    使用专门的工厂类将选择实现类、创建对象进行统一的管理和控制。
  

• 单例模式

    核心作用是确保一个类只有一个实例，
    并且提供一个访问该实例的全局访问点。
  

单例模式只生成一个实例对象.

单例模式有多种实现的方式，
推荐重写 new ()的方法。

设计模式称之为“模式”，就是一些固定的套路。