python学习1——类与对象

鸭子类型和多态

鸭子类型
百科定义：当我看到一只鸟像鸭子一样走，像鸭子一样游，像鸭子一样呱呱叫，我就叫它鸭子
它不关注对象的类型，而是关注对象具有的行为。
在python中，有一个 extend 方法，它接收可迭代对象，它不关注对象的类型，只关注对象具有的方法行为。

a = [22,33]
list1 = [2,3,4,5]
tuple1 = (8,9,0)
set1 = {7,6,5}

a.extend(set1)
print(a)

多态
根据 a 指向的对象不同，它呈现出不同的行为，这就是多态。

class Dog(object):
    def eat(self):
        print("吃狗粮")


class Cat(object):
    def eat(self):
        print("吃猫粮")


class Goldfish(object):
    def eat(self):
        print("吃鱼粮")


animal_list = [Dog, Cat, Goldfish]

for a in animal_list:
    a().eat()

抽象基类(abc模块)

定义各种方法而不做具体实现，不能被实例化，通常提供给子类继承，子类必须重写方法。
应用场景

• 判断某个对象的类型
• 需要强制某个子类实现某些方法

 from collections.abc import Sized,Iterable
 print(isinstance(d,Iterable)) # 判断有没有iter方法

import abc
class father(metaclass=abc.ABCMeta):
    @abc.abstractmethod  #强制子类重写，不重写报错
    def get(self, key):
        pass

    @abc.abstractmethod
    def set(self, key, value):
        pass


class son(father):
    def get(self, key):
        pass

    def set(self, key, value):
        pass


s = son()
s.set('abcd', 'uuu')
# 如果子类不实现 set方法，就会报错
# TypeError: Can't instantiate abstract class son with abstract methods set

isinstance 和type 的区别

isinstance 判断某个对象的类型,若不存在 返回false。isinstance 会考虑类的继承关系
type is会判断内存地址 ，而不会判断继承关系

class A(object):
    pass


class B(A):
    pass


b = B()
print(isinstance(b, A)) # True

A = B = [1, 2]
c = [1, 2]
print(type(A) == type(c)) # True
print(A is c) # False

类变量和对象变量

类属性不能向下查找，实例属性可以向上查找。

class A:
   #类属性
    aa = 1
    
    def __init__(self,x,y):
      #实例属性
        self.x = x
        self.y = y
        
a = A(1, 2)
print(A.x) # 报错
print(A(1,2).x) # 可以得到 1
A.aa = 11
a.aa = 22
print(a.aa) # 22 相当于添加实例属性 self.aa=22
print(A.aa) # 11

b = A(2, 3)
print(b.aa) # 11

类属性和实例属性的查询顺序

mro 算法
类.__mro__

• python 2.2之前的算法：DFS(deep first search)：深度优先
  
  A>B>D>C>E

• Python2.2版本之后,引入了BFS(Breadth First Search)：广度优先
  
  A>B>C>D

• 在Python2.3之后,Python采用了C3算法
  Python新式类继承的C3算法

对象的自省机制

程序运行过程中用于判断某个对象的类型

• dir() 返回一个列表，当前对象的属性以及父类的属性，相当于包含dict
• type() 判断对象的类型
• hasattr(a,b) 判断a对象是否包含b方法
• isinstance(a, b) 判断a是否为b的子类 ，返回布尔值，第二个参数可以是元组(元组内是或运算)

super函数

调用父类方法，调用super为了避免重复

class Father(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def speak(self):
        print("%s 说: 我已经 %s岁了" % (self.name, self.age))


class Son(Father):
    def __init__(self, name, age, grade):
        super().__init__(name, age)
        self.grade = grade


s = Son('son', 8, 4)
s.speak()