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

1. 类

1.1 类的概念

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

1.2 类的定义

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

class 类名:
	属性
	方法

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

案例

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

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

<class ‘main.Point’>

2. 对象

2.1 对象的概念

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

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

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

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

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

<class ‘function’>

2.2 实例化

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

类名(参数)

看起来和调用函数一样。

案例

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

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

<class ‘main.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 类实例化后,需要手动创建对象属性 xy,这显然容易出错和不规范,正确的做法应该是在构造方法中定义属性 xy

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)

3

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

7

静态方法

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

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

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

总结:

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

  1. 对象方法:方法内部需要访问对象属性、对象方法就定义为对象方法;既需要访问对象属性、方法,也需要访问类属性、方法,那必须定义为对象方法

  2. 类方法:方法内部只需要访问类属性、类方法就定义为类方法

  3. 静态方法:方法内部既不需要访问对象属性、对象方法,也不需要访问类属性、类方法就定义为静态方法

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()  # 调用类方法

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()

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

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

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'>)
  1. 在搜索方法时,是按照 mro 的输出结果从左往右的顺序查找的
  2. 如果在当前类(Class C)中找到方法,就直接执行,不再搜索
  3. 如果没有找到,就查找下一个类中(Class B)是否有对应的方法,如果找到,就直接执行,不再搜素
  4. 如果找到最后一个类(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 反射

反射就是动态的操作对象。

简单的讲就是根据字符串形式的属性名方法名操作对应的对象。

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

1

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’
自省和反射机制的理解需要大量的阅读源码。

上一篇 下一篇

评论 | 0条评论