python 面向对象

前面我们讲到基本数据类型用来表示最常见的信息。但是信息有无穷多种，为了更好的表达信息，我们可以创建自定义数据类型。

1. 类

1.1 类的概念

一种数据类型就是类。例如整数，浮点数，字符串。

1.2 类的定义

python 中通过关键字 class 可以定义一个自定义数据类型，基本语法如下：

class 类名:
	属性
	方法

注意：python 中类名规则同变量，一般使用 大驼峰 来表示。

案例

例如：创建一个 Point 类用于表示平面坐标系中的一个点

class Point:
    """
    表示平面坐标系中的一个点
    """
print(Point)

2. 对象

2.1 对象的概念

某种数据类型的一个具体的数据称为这个类的一个对象或者实例。通过类创建对象叫做实例化。

所谓的面向对象，就是把一些数据抽象成类的思想。

python 是一门面向对象的编程语言，python 中一切皆对象。

前面学习的函数也是 python 中的一个类，定义的某个函数就是函数类的一个具体实例。

def func():
    pass
print(type(func))

2.2 实例化

除了基本数据类型实例化的过程中用到的特殊的语法规范外，所有自定义类型进行实例化都是通过调用类名来实现的，非常简单，语法如下：

类名(参数)

看起来和调用函数一样。

案例

给上面创建的 Point 类创建一个实例。

point = Point()
print(type(point))

3. 属性

类和对象的特征数据称为属性。

3.1 类属性

类的特征称为类属性。

3.1.1 类属性的定义

直接在类中定义的变量（与 class 语句只有一个缩进），就是类属性。

案例：

给 Point 类创建一个 name 属性用来表示名称。

class Point:
    """
    表示平面坐标系中的一个点
    """
    name = '点'

3.1.2 类属性的访问

类属性可以直接通过类名和对象以句点法访问，语法格式如下：

类名.类属性名
对象.类属性名

案例：

print(Point.name)  # 直接通过类名访问类属性
point=Point()  # 创建一个实例
print(point.name)     # 通过对象访问类属性

点
点
注意：如果不存在属性则抛出 AttributeError 的异常

print(Point.a)

AttributeError Traceback (most recent call last)

in
----> 1 print(Point.a)

AttributeError: type object ‘Point’ has no attribute ‘a’

3.2 对象属性

对象的特征数据称为对象属性。

3.2.1 对象属性的定义

对象属性一般定义在构造方法中，详见下面构造方法一节。

通过句点法 对象.对象属性 以赋值的方式可以直接定义对象属性。

案例：

平面坐标系中的每个点都有 x 坐标和 y 坐标，通过类 Point 创建一个对象表示点（x=1，y=2）

point = Point()
# 通过赋值直接定义对象属性
point.x = 1
point.y = 2

注意：在定义对象属性时如果和类属性同名，那么通过对象将无法访问到类属性。

3.2.2 对象属性的访问

通过句点法 对象.对象属性 可以访问对象属性。

案例：

访问上面案例中 point 的 x 坐标和 y 坐标

print(point.x)
print(point.y)

1
2
访问对象属性时，首先会检查对象是否拥有此属性，如果没有则去创建对象的类中查找有没有同名的类属性，如果有则返回，如果都找不到则抛出 AttributeError 的异常

4. 方法

定义在类中的函数称为方法。通过调用的方式的不同，分为对象方法，类方法，静态方法和魔术方法。

4.1 对象方法

定义在类中的普通方法，一般通过对象调用称为对象方法。

4.1.1 对象方法的定义

为了讲清楚对象方法的定义和调用，我们先看下面的案例。

案例：

定义函数 my_print，它接收一个 Point 对象，然后打印这个点的 x，y 坐标。

def my_print(point):
    print('({},{})'.format(point.x, point.y))
  
p = Point()
p.x = 1
p.y = 2
my_print(p)

(1,2)
定义函数 distance，它接收两个 Point 对象，然后返回这两个点的距离。

def distance(p1, p2):
    return ((p1.x-p2.x)**2 + (p1.y-p2.y)**2)**0.5

p1 = Point()
p2 = Point()
p1.x = 1
p1.y = 2
p2.x = 3
p2.y = 4
res = distance(p1,p2)
print(res)

2.8284271247461903
观察上面的两个函数，发现它们都接收一个或多个 Point 的对象作为参数。为了显式的加强这样的联系，我们可以将它们定义在 Point 的类中。

class Point:
    """
    表示平面坐标系中的一个点
    """
    name = '点'

    def my_print(point):
        print('({},{})'.format(point.x, point.y))

    def distance(p1, p2):
        return ((p1.x-p2.x)**2 + (p1.y-p2.y)**2)**0.5

4.1.2 对象方法的调用

对象方法向属性一样，可以通过句点法进行调用。

类名.方法名(参数)
对象.方法名(参数)

通过类名调用方法时，和普通函数没有区别

# 更新了类，再次实例化对象
point = Point()
point.x = 1
point.y = 2
p1 = Point()
p2 = Point()
p1.x = 1
p1.y = 2
p2.x = 3
p2.y = 4

Point.my_print(point)
res = Point.distance(p1, p2)
print(res)

(1,2)
2.8284271247461903
通过对象调用方法时，对象本身会被隐式的传给方法的第一个参数

point.my_print()
# 通过对象调用方法时，对象本身会被隐式的传给方法的第一个参数，那么第一个参数已经传了就不需要再传了。
res = p1.distance(p2)
# p1 隐式传了，只需要传p2了
print(res)

(1,2)
2.8284271247461903
因此，定义对象方法会习惯性的把第一个形参定义为 self，表示调用对象本身

class Point:
    """
    表示平面坐标系中的一个点
    """
    name = '点'

    def my_print(self):
        print('({},{})'.format(self.x, self.y))

    def distance(self, p2):
        return ((self.x-p2.x)**2 + (self.y-p2.y)**2)**0.5

4.2 类方法

在类中通过装饰器 classmethod 可以把一个方法变成类方法。

一个类方法把类自己作为第一个实参，就像一个实例方法把实例自己作为第一个实参。
cls 代表的是同一个对象，类对象
定义一个类方法 base_point 用来返回坐标原点。

class Point:
    """
    表示平面坐标系中的一个点
    """
    name = '点'

    def my_print(self):
        print('({},{})'.format(self.x, self.y))

    def distance(self, p2):
        return ((self.x-p2.x)**2 + (self.y-p2.y)**2)**0.5
    @classmethod
    def base_point(cls):
        bp = cls()
        bp.x = 0
        bp.y = 0
        return bp

通过类本身或者是该类的实例都可以调用类方法。

p = Point()
bp1 = p.base_point()
bp1.my_print()
bp2 = Point.base_point()
bp2.my_print()

(0,0)
(0,0)
类方法一般都用来生成特殊对象。
类方法和对象方法很相似，又很不相似
相似点
也至少要包含一个参数，不过通常命名为 cls
在调用类方法时，无需显式为 cls 参数传参，但传递的并不是实例对象，而是类对象本身

不同点
最大的不同在于需要使用 @classmethod 装饰器才能称为类方法

4.3 特殊方法（魔术方法）

在类中可以定义一些特殊的方法用来实现特殊的功能，也称为魔术方法。这些方法一般都以双下划线 __ 开头

`init`

__init__ 又叫构造方法，初始化方法，在调用类名实例化对象时，构造方法会被调用，类名括号 () 后的参数会传递给构造方法，对象属性一般在这个方法中定义。

案例：

上面案例中的 Point 类实例化后，需要手动创建对象属性 x 和 y，这显然容易出错和不规范，正确的做法应该是在构造方法中定义属性 x 和 y

class Point:
    """
    表示平面坐标系中的一个点
    """
    name = '点'
  
    def __init__(self, x, y):
        self.x = x
        self.y = y
  
    def my_print(self):
        print('({},{})'.format(self.x, self.y))

    def distance(self, p2):
        return ((self.x-p2.x)**2 + (self.y-p2.y)**2)**0.5
  
    @classmethod
    def base_point(cls):
        return cls(0,0)

# 实例化
p1 = Point(1, 2)
p2 = Point(x=3, y=4)
p1.my_print()
p2.my_print()

(1,2)
(3,4)

`str`

__str__ 方法在对象被 print 函数打印时被调用，print 输出 __str__ 方法返回的字符串。

案例：

上面案例中 Point 类里的 my_print 方法可以去掉，定义一个 __str__ 方法

class Point:
    """
    表示平面坐标系中的一个点
    """
    name = '点'
  
    def __init__(self, x, y):
        self.x = x
        self.y = y
  
    def __str__(self):
        return '({},{})'.format(self.x, self.y)

    def distance(self, p2):
        return ((self.x-p2.x)**2 + (self.y-p2.y)**2)**0.5
  
    @classmethod
    def base_point(cls):
        return cls(0,0)

p = Point(2,2)
print(p)

(2,2)
更多的特殊方法详见官方文档

4.4 静态方法

在类中通过装饰器 staticmethod 可以把一个方法变静态方法。

静态方法不会接收隐式的第一个参数，它和普通的函数一样，只是被封装到类中。

通过类和对象都可以调用。

在 Point 类中定义一个静态方法，用来计算两个数的和。

class Point:
    """
    表示平面坐标系中的一个点
    """
    name = '点'
  
    def __init__(self, x, y):
        self.x = x
        self.y = y
  
    def __str__(self):
        return '({},{})'.format(self.x, self.y)

    def distance(self, p2):
        return ((self.x-p2.x)**2 + (self.y-p2.y)**2)**0.5
  
    @classmethod
    def base_point(cls):
        return cls(0,0)
  
    @staticmethod
    def sum(x,y):
        return x+y

Point.sum(1,2)

p = Point(1,2)
p.sum(3,4)

静态方法

静态方法是一个不需要访问实例或类属性的方法。它与类和实例无关，因此不会接收隐含的 self 或 cls 参数。静态方法通常用于执行与类相关但不依赖于类状态或实例状态的操作。

和之前学过的函数一毛一样，唯一区别是：静态方法需要定义在类体中，且需要添加 @staticmethod 装饰器
静态方法没有 self、cls 参数，也不需要至少传一个参数，和普通函数一样
Python 解释器不会对它包含的参数做任何类或对象的绑定，所以静态方法无法调用任何类属性、类方法、实例属性、实例方法，除非通过类名和实例对象

什么时候会用静态方法
类里面封装的方法

既不需要访问实例属性、实例方法
也不需要访问类属性、类方法
就可以考虑将这个方法封装成一个静态方法

总结：

关于对象方法、 classmethod 和 staticmethod 的实际应用场景
简单来说

对象方法：方法内部需要访问对象属性、对象方法就定义为对象方法；既需要访问对象属性、方法，也需要访问类属性、方法，那必须定义为对象方法
类方法：方法内部只需要访问类属性、类方法就定义为类方法
静态方法：方法内部既不需要访问对象属性、对象方法，也不需要访问类属性、类方法就定义为静态方法

class GirlFriend:
    """
    女朋友特征
    """
    sex = "girl"

    def __init__(self, height, weight, education, location, skill):
        self.height = height
        self.weight = weight
        self.education = education
        self.location = location
        self.skill = skill

    def __str__(self):
        return 'I want have a GirlFriend for  height>{},weight<{}),education is {} and location in {}' 
            .format(self.height, self.weight, self.education, self.location)

    def method(self):
        print('she is good at {}！！'.format(self.skill))

    @classmethod
    def gender(cls):
        print("she is {}".format(cls.sex))

    @staticmethod
    def hobby(sport, song):
        print("she is favorite sport is {},and favorite listen song is {}"
              .format(sport, song))


p = GirlFriend(150, 100, "undergrad", "杭州", "cooking")  # 调用类名实例化对象--传参自动执行构造方法
print(p)
p.method() # 对象调用对象方法
p.hobby("dance", "GQ")  # 对象调用静态方法
GirlFriend.gender()  # 调用类方法，不需要创建实例
GirlFriend.hobby("dance", "GQ")  # 对象调用静态方法，不需要创建实例

对于类方法，可以使用类名来调用，如 ClassName.method()。在类方法的定义中，通常会使用 cls 参数来引用类本身，以便在方法内部访问类属性和调用其他类方法。
对于静态方法，可以使用类名或实例对象来调用，如 ClassName.method() 或 instance.method()。静态方法的定义中不需要使用特殊的参数，因为它们不能访问类属性或调用其他类方法。
总结起来，调用类方法和静态方法不需要创建类的实例，可以直接通过类名来调用。

4.5 python的@property

@property 是一个装饰器，可以将一个类方法转换为属性，使其在访问时更像是直接访问属性而不是方法。通过使用 @property 装饰器，你可以定义一个方法，然后像访问属性一样使用它。

下面是一个使用 @property 装饰器的示例：

class Person:
    def __init__(self, name):
        self._name = name
    
    @property
    def name(self):
        return self._name

在上述示例中，@property 装饰器将 name 方法转化为只读属性。这意味着，如果要获取 Person 实例的 name 属性，只需使用实例对象的 name 属性访问即可，如下所示：

person = Person('Alice')
print(person.name)

这将输出 Alice，即 person 实例的 name 属性的值。注意，这里不需要显式调用 name() 方法来获取值。

需要注意的是，@property 装饰器只能用于只读属性，如果需要设置属性的值，则需要使用类似于 name.setter 的装饰器来定义一个 setter 方法。

示例2

class MyClass:
    def __init__(self, value):
        self._value = value

    @property
    def value(self):
        return self._value

    @value.setter
    def value(self, new_value):
        self._value = new_value

obj = MyClass(10)
print(obj.value)  # 直接访问属性，而不是方法
obj.value = 20  # 修改属性值
print(obj.value)

@value.setter 是 @property 装饰器的一个补充，它用于定义属性的 setter 方法。

在使用 @property 装饰器时，我们可以将一个方法转换为一个属性。但默认情况下，这个属性是只读的，即我们可以通过 obj.value 来访问它，但无法直接修改它。

如果我们想要给属性添加设置方法（setter），允许修改属性的值，就需要使用 @value.setter 装饰器

5. 类的继承

类还有一个重要的特性是继承。

5.1 继承

当定义一个类时，可以从现有的类继承，新的类称为子类(Subclass)，被继承的类称为基类，父类或超类(Base class,Super class).

子类可以继承父类的属性和方法。

案例：

创建一个类用来表示三维的点。

class Point:
    """
    表示平面坐标系中的一个点
    """
    name = '点'
  
    def __init__(self, x, y):
        self.x = x
        self.y = y
  
    def __str__(self):
        return '({},{})'.format(self.x, self.y)

    def distance(self, p2):
        return ((self.x-p2.x)**2 + (self.y-p2.y)**2)**0.5
  
    @classmethod
    def base_point(cls):
        return cls(0,0)
  
    @staticmethod
    def sum(x,y):
        return x+y
  
class TdPoint(Point):
    """
    表示三维的点
    """

在上面的案例中 TdPoint 类继承了 Point 类。对于 TdPoint 来说 Point 是它的父类，对于 Point 类来说 TdPoint 是他的子类。

print(dir(TdPoint))

[‘class’, ‘delattr’, ‘dict’, ‘dir’, ‘doc’, ‘eq’, ‘format’, ‘ge’, ‘getattribute’, ‘gt’, ‘hash’, ‘init’, ‘init_subclass’, ‘le’, ‘lt’, ‘module’, ‘ne’, ‘new’, ‘reduce’, ‘reduce_ex’, ‘repr’, ‘setattr’, ‘sizeof’, ‘str’, ‘subclasshook’, ‘weakref’, ‘base_point’, ‘distance’, ‘name’, ‘sum’]
虽然在 TdPoint 类中没有定义任何的属性和方法，但它自动继承了父类 Point 的属性和方法。

5.2 重写

在上面的案例中，虽然 TdPoint 类继承了 Point 的属性和方法，但是三维的点比二维的点多了一个纬度，所以大部分方法和属性不合适，需要重写。

在子类中定义同名的方法和属性会覆盖父类的方法和属性。

class Point:
    """
    表示平面坐标系中的一个点
    """
    name = '点'
  
    def __init__(self, x, y):
        self.x = x
        self.y = y
  
    def __str__(self):
        return '({},{})'.format(self.x, self.y)

    def distance(self, p2):
        return ((self.x-p2.x)**2 + (self.y-p2.y)**2)**0.5
  
    @classmethod
    def base_point(cls):
        return cls(0,0)
  
    @staticmethod
    def sum(x,y):
        return x+y
  
class TdPoint(Point):
    """
    表示三维的点
    """
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z
      
    def __str__(self):
        return '({},{},{})'.format(self.x, self.y, self.z)
  
    def distance(self, p2):
        return ((self.x-p2.x)**2 + (self.y-p2.y)**2 + (self.z-p2.z)**2)**0.5
  
    @classmethod
    def base_point(cls):
        return cls(0,0,0)

上面的代码中 TdPoint 类重写了父类中的__init__,str,distance,base_point 三个方法

p1 = TdPoint(1,2,3)
p2 = TdPoint(2,3,4)
print(p1)

(1,2,3)

p1.distance(p2)

1.7320508075688772

print(TdPoint.base_point())

(0,0,0)

5.3 super 方法

重写了父类方法后如果又要调用父类的方法怎么解决呢？
当子类重写了父类方法时，又想调用父类的同名方法时，就需要用到 super()

在 Python 中，super 是一个特殊的类
super() 就是使用 super 类创建出来的对象
实际应用的场景：子类在重写父类方法时，调用父类方法

例如，三维点在计算点与点的距离时，要求同时返回投射到二维平面的点的距离。

class TdPoint(Point):
    """
    表示三维的点
    """
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z
      
    def __str__(self):
        return '({},{},{})'.format(self.x, self.y, self.z)
  
    def distance(self, p2):
        d2 = Point.distance(self, p2)
        d3 = ((self.x-p2.x)**2 + (self.y-p2.y)**2 + (self.z-p2.z)**2)**0.5
        return d2, d3
  
    @classmethod
    def base_point(cls):
        return cls(0,0,0)

p1 = TdPoint(1,2,3)
p2 = TdPoint(2,3,4)
p1.distance(p2)

(1.4142135623730951, 1.7320508075688772)
可以直接通过类名的方式调用对应的方法。但是这种方法的耦合性太大，官方推荐使用 super 函数。

class TdPoint(Point):
    """
    表示三维的点
    """
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z
      
    def __str__(self):
        return '({},{},{})'.format(self.x, self.y, self.z)
  
    def distance(self, p2):
        d2 = super().distance(p2)
        d3 = ((self.x-p2.x)**2 + (self.y-p2.y)**2 + (self.z-p2.z)**2)**0.5
        return d2, d3
  
    @classmethod
    def base_point(cls):
        return cls(0,0,0)

p1 = TdPoint(1,2,3)
p2 = TdPoint(2,3,4)
p1.distance(p2)

<super: <class ‘TdPoint’>, >

(1.4142135623730951, 1.7320508075688772)
在具有单继承的类层级结构中，super 可用来引用父类而不必显式地指定它们的名称，从而令代码更易维护。

super()会返回一个代理对象，它会将方法调用委托给父类，这对于访问已在类中被重载的父类方法很有用。

Python 多继承

大部分面向对象的编程语言，都只支持单继承，即子类有且只能有一个父类
而 Python 却支持多继承（C++也支持多继承）
和单继承相比，多继承容易让代码逻辑复杂、思路换了一直备受争议，中小型项目中较少使用，后来的 Java、C#、PHP 取消了多继承
多继承带来的问题：多个父类中包含同名的类方法
Python 的解决方案：根据子类继承多个父类时这些父类的前后次序决定，即排在前面父类中的类方法会覆盖排在后面父类中的同名类方法【后面文章详解】

什么是多继承

子类可以拥有多个父亲，并且具有所有父类的属性和方法
儿子可以拥有多个爸爸…爸爸也可以有多个儿子…

语法格式

class 子类(父类1, 父类2, ...):
    pass

实际代码

class A:
    def test(self):
        print("test")


class B:
    def demo(self):
        print("demo")


class C(A, B):
    ...


c = C()
c.test()
c.demo()


# 输出结果
test
demo

C 继承了 A、B，拥有了他们的所有属性和方法

多继承带来的顺序问题

如果不同的父类中存在同名的方法，子类对象在调用该方法时，会调用哪一个父类的方法呢？

重点注意

正式开发中，如果需要用到多继承，那么多个父类应该避免使用同名的属性、方法
如果父类存在同名的属性、方法，应该尽量避免使用多继承

实际代码

class A:
    def test(self):
        print("AAA-test")

    def demo(self):
        print("AAA-demo")

class B:
    def test(self):
        print("BBB-test")

    def demo(self):
        print("BBB-demo")


class C(A, B):
    ...


c = C()
c.test()
c.demo()


# 输出结果
AAA-test
AAA-demo

调用的是父类 A 的方法

如果 C 继承父类的顺序改变一下呢

# 刚刚是 A, B ； 现在是 B, A
class C(B, A):
    ...


c = C()
c.test()
c.demo()


# 输出结果
BBB-test
BBB-demo

现在变成调用父类 B 的方法了
这又是为什么呢？答案就是 Python 的 MRO 方法搜索顺序

什么是 MRO

MRO，method resolution order，方法搜索顺序
对于单继承来说，MRO 很简单，从当前类开始，逐个搜索它的父类有没有对应的属性、方法
所以 MRO 更多用在多继承时判断方法、属性的调用路径
Python 中针对类提供了一个内置属性 mro 可以查看方法搜索顺序

实际代码

class A:
    def test(self):
        print("AAA-test")


class B:
    def test(self):
        print("BBB-test")

# 继承了三个类，B、A、还有默认继承的 object
class C(B, A):
    ...


# 通过类对象调用，不是实例对象！
print(C.__mro__)


# 输出结果
(<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>)

在搜索方法时，是按照 mro 的输出结果从左往右的顺序查找的
如果在当前类（Class C）中找到方法，就直接执行，不再搜索
如果没有找到，就查找下一个类中（Class B）是否有对应的方法，如果找到，就直接执行，不再搜素
如果找到最后一个类（Class object）都没有找到方法，程序报错

5.4 多态

python 是一门动态语言，严格的来说 python 不存在多态。

def bark(animal):
    animal.bark()

上面的函数 bark 接收一个对象，并调用了对象的 bark 方法。对于 python 来说只要传入的对象有 bark 方法这个函数就可以执行，而不必去检查这个对象的类型。

class Animal:
    def bark(self):
        print('嗷嗷叫！')

class Dog(Animal):
    def bark(self):
        print('汪汪叫！')

class Cat(Animal):
    def bark(self):
        print('喵喵叫！')

class Duck(Animal):
    def bark(self):
        print('嘎嘎叫！')

dog = Dog()
cat = Cat()
duck = Duck()

bark(dog)
bark(cat)
bark(duck)

汪汪叫！
喵喵叫！
嘎嘎叫！
上面的案例中 dog 是 Dog 类型的一个实例，同时它也是 Animal 的一个实例。但是反过来不成立。

对于静态语言来说函数 bark 如果需要传入 Animal 类型，则传入的对象必须是 Animal 类型或者它的子类，否则，不能调用 bark。

dog，cat，duck 都是 Animal 类型，但是它们执行 bark 后的输出又各不相同。一个类型多种形态，这就是多态。

对于 python 这样的动态语言来说，则不需要传入的一定是 Animal 类型，只要它具有一个 bark 方法就可以了。

class SomeClass:
    def bark(self):
        print('随便叫！')

sc = SomeClass()
bark(sc)

随便叫！

5.5 私有化

python 中不存在那种只能在仅限从一个对象内部访问的私有变量。

但是，大多数 Python 代码都遵循这样一个约定：以一个下划线开头的名称 (例如 _spam) 应该被当作是 API 的非公有部分 (无论它是函数、方法或是数据成员)。这应当被视为一个实现细节，可能不经通知即加以改变。

class A:
    _arg1 = 'A'
  
    def _method1(self):
        print('我是私有方法')

a = A()
a._arg1

‘A’

a._method1()

我是私有方法
这种以一个下划线开头的属性可以被类和实例调用。

只是在 from xxx import * 时不会被导入。

还有一种定义私有属性的方法是以两个下划线开头的名称（例如__spam)，这种方式定义的私有变量只能在类的内部访问。

class A:
    __arg1 = 'A'
  
    def __method1(self):
        print('我是私有方法')

a = A()
a.__arg1

AttributeError Traceback (most recent call last)

in
1 a = A()
----> 2 a.__arg1

AttributeError: ‘A’ object has no attribute ‘__arg1’
这种限制访问的原理是，以双下划线开头的属性名(至少带有两个前缀下划线，至多一个后缀下划线)会被改写成 _classname__spam，所以在类外部通过原名称反问不到，但在类的内部使用原名称可以访问。

a._A__arg1

‘A’

补充说明：
Python 默认的成员函数都是公开的，在 Python 中定义私有方法只需要在方法名前加上 “__” 两个下划线，那么这个方法就会成为私有的了，私有的方法只能在类内部访问，不能在类的外部调用。
Python 私有方法定义语法：

class Person(object):
    def __funcname(self, params):
        pass

class Person(object):
    def __init__(self, name, age, score):
        self.name = name
        self.age = age
        self.__score = score
    def __getscore(self):
        return self.__score
person = Person("haicoder", 18, 100)
print(person.__getscore())
# 会报错

修改为：

class Person(object):
    def __init__(self, name, age, score):
        self.name = name
        self.age = age
        self.__score = score
    def __getscore(self):
        return self.__score
    def info(self):
        print("Name =", self.name, "Age =", self.age, "Score =", self.__getscore())
person = Person("haicoder", 18, 100)
person.info()
# 正常不报错

6.自省与反射机制

6.1 自省

在日常生活中，自省（introspection）是一种自我检查行为。

在计算机编程中，自省是指这种能力：检查对象以确定它是什么类型、它有哪些属性和哪些方法。自省向程序员提供了极大的灵活性和控制力。

type

type 函数可以返回一个对象的类型

type(1)

int

isinstance

检查一个对象是否是某个或某些类型的实例

isinstance(1,int)

True

issubclass

检查一个类是否是某个或某些类的子类

issubclass(bool, int)

True

dir

返回一个传入对象的属性名和方法名的字符串列表

print(dir(1))

[‘abs’, ‘add’, ‘and’, ‘bool’, ‘ceil’, ‘class’, ‘delattr’, ‘dir’, ‘divmod’, ‘doc’, ‘eq’, ‘float’, ‘floor’, ‘floordiv’, ‘format’, ‘ge’, ‘getattribute’, ‘getnewargs’, ‘gt’, ‘hash’, ‘index’, ‘init’, ‘init_subclass’, ‘int’, ‘invert’, ‘le’, ‘lshift’, ‘lt’, ‘mod’, ‘mul’, ‘ne’, ‘neg’, ‘new’, ‘or’, ‘pos’, ‘pow’, ‘radd’, ‘rand’, ‘rdivmod’, ‘reduce’, ‘reduce_ex’, ‘repr’, ‘rfloordiv’, ‘rlshift’, ‘rmod’, ‘rmul’, ‘ror’, ‘round’, ‘rpow’, ‘rrshift’, ‘rshift’, ‘rsub’, ‘rtruediv’, ‘rxor’, ‘setattr’, ‘sizeof’, ‘str’, ‘sub’, ‘subclasshook’, ‘truediv’, ‘trunc’, ‘xor’, ‘as_integer_ratio’, ‘bit_length’, ‘conjugate’, ‘denominator’, ‘from_bytes’, ‘imag’, ‘numerator’, ‘real’, ‘to_bytes’]
python 中的自省函数有很多，凡是可以检查对象状态的函数都可以称为自省函数。

6.2 反射

反射的定义

通过字符串映射object对象的方法或者属性。
简单的讲就是根据字符串形式的属性名方法名操作对应的对象。

python有四个重要内置函数：getattr、hasattr、delattr和setattr较为全面的实现了基于字符串的反射机制。他们都是对内存内的模块进行操作，并不会对源文件进行修改

反射的四个基本方法

hasattr(obj,func1): 判断objec是否有func1这个方法或者属性
getattr(obj,func1): 获取object对象中与func1同名的方法或者函数
setattr(obj,key,func1): 为object对象设置一个以key为名的func1方法或者属性
delattr(obj,func1): 删除object对象中的func1方法或者属性

hasattr

检查一个对象是否有给定名称的属性

hasattr([1,2,3],'append')

True

getattr

返回一个对象给定名称的属性

getattr(x,‘y’) 等价于 x.y

class Point:
  name = '点'
getattr(Point,'name')

‘点’

setattr

给一个对象添加一个给定名称的属性

setattr(x, ‘y’, v) 等价于 x.y = v

setattr(Point,'x',1)
Point.x

delattr

删除对象的一个给定名称的属性

delattr(x, ‘y’) 等价与 del x.y

  delattr(Point, 'x')
  Point.x

AttributeError Traceback (most recent call last)

in
----> 1 Point.x

AttributeError: type object ‘Point’ has no attribute ‘x’
自省和反射机制的理解需要大量的阅读源码。

接口自动化的应用

封装数据库的操作行为


    def __execute(self, sql, action, res_type='t', *args):
        """
        执行sql
        :param sql:
        :param action: 字符串，指定执行cursor对应的方法
        :param res_type:
        :param args: 其他参数，比如当执行fetchmany传入的size
        :return:
        """
        if res_type == 't':
            cursor = self.conn.cursor()
        else:
            cursor = self.conn.cursor(DictCursor)
        try:
            cursor.execute(sql)
            return getattr(cursor, action)(*args)
        except Exception as e:
            raise e
        finally:
            cursor.close()
  def get_one(self, sql, res_type='t'):
        """
        获取一条数据
        :param sql:
        :param res_type: 返回数据的类型，默认为t表示以元组返回，'d'表示以字典的形式返回
        :return: 元组/字典
        """
        # 数据库若断开即重连
        self.reConnect()
        return self.__execute(sql, 'fetchone', res_type)

    def get_many(self, sql, size, res_type='t'):
        # 数据库若断开即重连
        self.reConnect()
        return self.__execute(sql, 'fetchmany', res_type, size)

    def get_all(self, sql, res_type='t'):
        # 数据库若断开即重连
        self.reConnect()
        return self.__execute(sql, 'fetchall', res_type)

类属性的绑定

def extract_data_from_json(self):
        """
        从json数据中提取数据并绑定到类属性中
        :return:
        """
        try:
            rules = json.loads(self._case.get('extract'))
        except Exception as e:
            raise ValueError('用例【{}】的extract字段数据：{}格式不正确'.format(self._case['title'], self._case['extract']))
        for rule in rules:
            # 类属性名
            name = rule[0]
            # 提取表达式
            exp = rule[1]
            # 根据jsonpath去响应中提取值
            value = jsonpath(self._response.json(), exp)
            # 如果能提取到值
            if value:
                # 把值绑定到对应的类属性上
                setattr(self.__class__, name, value[0])  # 注意value是个列表
            else:
                # 提取不到值，说明jsonpath写错了，或者是响应又问题
                raise ValueError('用例【{}】的提取表达式{}提取不到数据'.format(self._case['title'], self._case['extract']))

1. 类

1.1 类的概念

1.2 类的定义

案例

2. 对象

2.1 对象的概念

2.2 实例化

案例

3. 属性

3.1 类属性

3.1.1 类属性的定义

案例：

3.1.2 类属性的访问

案例：

3.2 对象属性

3.2.1 对象属性的定义

案例：

3.2.2 对象属性的访问

案例：

4. 方法

4.1 对象方法

4.1.1 对象方法的定义

案例：

4.1.2 对象方法的调用

4.2 类方法

4.3 特殊方法（魔术方法）

__init__

案例：

__str__

案例：

4.4 静态方法

总结：

4.5 python的@property

5. 类的继承

5.1 继承

案例：

5.2 重写

5.3 super 方法

Python 多继承

什么是 MRO

5.4 多态

5.5 私有化

6.自省与反射机制

6.1 自省

type

isinstance

issubclass

dir

6.2 反射

反射的定义

hasattr

getattr

setattr

delattr

接口自动化的应用

评论

`init`

`str`