1. 类
前面学习的基本数据类型用来表示最常见的信息。但是信息有无穷多种，为了更好的表达信息，我们可以创建自定义数据类型，每一个数据类型就是一个类。
1.1 类的概念
一种数据类型就是一个类。例如整数（int），浮点数（float），字符串（str）等等。
1.2 类的定义
为了方便使用，python内置已经定义好了一些常见的类（如：int、float、str），但是在实际编程中，也会遇到很多类似的情况，所以为了方便编程，可以自行创建自己所需要的数据类型（如：动物类、植物类等等）。
python 中通过关键字 class 可以定义一个自定义数据类型，基本语法如下：
class 类名:
属性
方法
注意：python 中类名规则同变量，一般使用 大驼峰（首个英文字母大写） 来表示。
案例
例如：创建一个 Point 类用于表示平面坐标系中的一个点
class Point:
"""
创建一个 Point 类
"""
print(Point) # 打印这个创建的类，输出
print(int) # 对比整数类，打印出输出
2. 对象
2.1 对象的概念
某种数据类型的一个具体的数据称为这个类的一个对象或者实例。通过类创建对象叫做实例化。如：任意一个整数（如：10）是int的一个对象或者叫实例，任意一个字符串是str的一个对象，任意一个浮点数就是float的一个对象，任意一个动物（如：老虎）就是动物类的一个对象或者叫实例。
所谓的面向对象，就是把一些数据抽象成类的思想。
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:
"""
创建一个 Point 类
"""
name = '点 '
3.1.2 类属性的访问
类属性可以直接通过类名和对象以句点法访问，语法格式如下：
类名.类属性名
对象.类属性名
案例：
print(Point.name) # 直接通过类名访问类属性
point=Point() # 创建一个实例
print(point.name) # 通过对象访问类属性
输出：
点
点
注意：如果不存在属性则抛出 AttributeError 的异常
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 坐标。
class Point:
"""
"""
name = '点 '
def my_print(Point):
print('({},{})'.format(Point.x, Point.y))
point = Point()
point.x = 1
point.y = 2
my_print(point)
定义函数 distance，它接收两个 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
point1 = Point()
point1.x = 0
point1.y = 0
point2 = Point()
point2.x = 3
point2.y = 4
res = distance(point1, point2)
print(res)
观察上面的两个函数，发现它们都接收一个或多个 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 对象方法的调用
对象方法向属性一样，可以通过句点法进行调用。
方法1：类名.方法名(参数)
方法2：对象.方法名(参数)，一般使用此方法
类名.方法名(参数)
对象.方法名(参数)
通过类名调用方法时，和普通函数没有区别，参数放在后面的括号中
point1 = Point()
point1.x = 0
point1.y = 0
point2 = Point()
point2.x = 3
point2.y = 4
Point.my_print(point1) # 类名.方法名(参数) (0,0)
res = Point.distances(point1, point2) # 类名.方法名(参数)
print(res)
通过对象调用方法时，对象本身会被隐式的传给方法的第一个参数
point.my_print()
res = p1.distance(p2)
print(res)
因此，定义对象方法会习惯性的把第一个形参定义为 self，表示调用对象本身
class Point:
"""
"""
name = '点 '
def my_print(self):
print('({},{})'.format(self.x, self.y))
def distances(self,p2):
return ((self.x-p2.x)**2+(self.y-p2.y)**2)**0.5
point1 = Point()
point1.x = 0
point1.y = 0
point2 = Point()
point2.x = 3
point2.y = 4
# 调用方法
point1.my_print() # 对象.方法名(参数) (0,0)
Point.my_print(point1) # 类名.方法名(参数) (0,0)
res = Point.distances(point1, point2) # 类名.方法名(参数)
print(res)
res1 = point1.distances(point2) # 对象.方法名(参数)
print(res1)
4.2 类方法
在类中通过装饰器 classmethod 可以把一个方法变成类方法。
一个类方法把类自己作为第一个实参，就像一个实例方法把实例自己作为第一个实参。
案例
给Point类定义一个类方法，用来返回坐标原点。
通过类本身或者是该类的实例都可以调用类方法。
class Point:
"""
Point表示平面坐标系中的一个点
"""
name = '点'
def my_print(self):
print('({},{})'.format(self.x, self.y))
def distance(self, pp):
return ((self.x - pp.x) ** 2 + (self.y - pp.y) ** 2) ** 0.5
@classmethod
def base_point(cls):
bp = cls()
bp.x = 0
bp.y = 0
return bp
# 通过类本身或者是该类的实例都可以调用类方法。
res = Point.base_point()
res.my_print()
b = Point
b.base_point().my_print()
调用方法
类名.类方法(参数)
对象.类方法(参数)
两个调用方式都会隐式的把类本身传递给类方法的第一个参数，所以这个参数默认定义为cls表示类本身
类方法一般都用来生成特殊对象。
4.3 特殊方法（魔术方法）
在类中可以定义一些特殊的方法用来实现特殊的功能，也称为魔术方法。这些方法一般都以双下划线 __ 开头，下面介绍两种魔术方法
4.3.1 第一种常用魔术方法__init__
__init__ 又叫构造方法，初始化方法，在调用类名实例化对象时，构造方法会被调用，类名括号 () 后的参数会传递给构造方法，对象属性一般在这个方法中定义。
当创建对象的时候它会被自动调用，创建的对象会被传递个第一个参数，会接受类名括号里传入的参数（从第二个参数开始传）
案例：
上面案例中的 Point 类实例化后，需要手动创建对象属性 x 和 y，这显然容易出错和不规范，正确的做法应该是在构造方法中定义属性 x 和 y。
class Point:
"""
创建一个类
"""
name = '点' # 类的属性
def __init__(self, x, y):
self.x = x
self.y = y
print('我执行了初始化方法')
def my_print(self): # 对象方法
print('({},{})'.format(self.x, self.y))
def distance(self, pp):
return ((self.x - pp.x) ** 2 + (self.y - pp.y) ** 2) ** 0.5
# 实例化
p1 = Point(0, 0)
p2 = Point(x=3, y=4)
p1.my_print()
p3 = Point(6, 8)
res0 = p1.distance(p2)
res1 = p1.distance(p3)
print(res0, res1)
实例化创建对象时，会把对象传递给__init__中的self，比如：p3 = Point(6, 8)，会把实例化的对象Point传递给__init__中的self，把6传递给x，把8传递给y
4.3.2 第二种常用魔术方法__str__
__str__ 方法在对象被 print 函数打印时被调用，print 输出__str__方法返回的字符串。
print一个对象的时候，实际上会调用这个对象的str方法，打印这个方法的返回值
案例：
直接使用print函数打印实例化的对象，会输出类及创建对象的内存地址，如;
p1 = Point(0, 0)
print(p1) #输出<__main__.Point object at 0x000001C34CC0BB00>
上面案例中 Point 类里的 my_print 方法可以去掉，定义一个__str__方法，就可以实现打印对象是打印一个点的形式，见如下代码：
class Point:
"""
创建一个类
"""
name = '点' # 类的属性
def __init__(self, x, y):
self.x = x
self.y = y
print('我执行了初始化方法')
def __str__(self):
return '({},{})'.format(self.x, self.y)
def distance(self, pp):
return ((self.x - pp.x) ** 2 + (self.y - pp.y) ** 2) ** 0.5
# 实例化
p1 = Point(0, 0)
print(p1) # 输出(0, 0)
其实我们之前所学的基本数据类型的方法也都是有__str__方法的，否则也无法输出对应的格式，比如，以字符串和列表为例
# 字符串：打印的时候为了方便，隐藏了.__str__()
print('123') #等价于print('123'.__str__())，隐藏了.__str__()
print('123'.__str__())
# 列表：打印的时候为了方便，隐藏了.__str__()
print([1, 2, 3]) # 等价于print([1, 2, 3].__str__())，隐藏了.__str__()
print([1, 2, 3].__str__())
print(dir(str)) # 可以查看到字符串这个类也是有__str__方法的
print(dir(list)) # 可以查看到l列表这个类也是有__str__方法的
通过上面的例子可以了解到，其实所有的类（包括基本数据类型：字符串、列表、字典等等）中都是有__str__方法的，不同的类（数据类型）要区别打印出来的形式，比如：元组是小括号，列表是中括号。
都可以发现，print的时候，都省略了.__str__()，看起来就像是没有调用的样子。这就是魔术方法与众不同的地方，不用显式调用就是魔术
创建一个类的时候，如果需要打印出这个类，就需要在类中创建一个__str__方法来定义这个类的表现形式（如：元组是小括号，列表是中括号等等）
更多的魔术（特殊）方法详见官方文档
4.4 静态方法
在类中通过装饰器 staticmethod 可以把一个方法变静态方法。
静态方法不会接收隐式的第一个参数，它和普通的函数一样，只是被封装到类中。
通过类和对象都可以调用。
案例：
在 Point 类中定义一个静态方法，用来计算两个数的和。
class Point:
"""
创建一个类
"""
name = '点' # 类的属性
def __init__(self, x, y):
self.x = x
self.y = y
print('我执行了初始化方法')
def __str__(self):
return '({},{})'.format(self.x, self.y)
# def my_print(self): # 对象方法
# print('({},{})'.format(self.x, self.y))
def distance(self, pp):
return ((self.x - pp.x) ** 2 + (self.y - pp.y) ** 2) ** 0.5
@classmethod
def base_point(cls):
bp = cls()
bp.x = 0
bp.y = 0
return bp
@staticmethod
def my_sum(x, y):
return x+y
res = Point.my_sum(1, 2)
print(res)
p = Point(2, 3)
res1 = p.my_sum(4, 5)
print(res1)
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, pp):
return ((self.x - pp.x) ** 2 + (self.y - pp.y) ** 2) ** 0.5
@classmethod
def base_point(cls):
bp = cls(0, 0)
return bp
@staticmethod
def my_sum(x, y):
return x+y
class ThPoint(Point): # 继承Point类
"""
创建一个类用来表示三维的点
"""
print(ThPoint.name) # 可以调用父类中的属性
print(ThPoint.base_point()) # 可以调用父类中的类方法
print(ThPoint.my_sum(1, 2)) # 可以调用父类中的静态方法
在上面的案例中 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 的属性和方法，但是三维的点比二维的点多了一个纬度，所以大部分方法和属性不合适，需要重写。
在子类中定义同名的方法和属性会覆盖父类的方法和属性。
案例：
因为三维的点比二维的点多了一个纬度，而在__init__初始化时父类是只定义了x,y，没有z，所以，子类ThPoint中需要重写__init__方法
class Point:
"""
创建一个类
"""
name = '点' # 类的属性
def __init__(self, x, y):
self.x = x
self.y = y
print('我执行了初始化方法')
def __str__(self):
return '({},{})'.format(self.x, self.y)
# def my_print(self): # 对象方法
# print('({},{})'.format(self.x, self.y))
def distance(self, pp):
return ((self.x - pp.x) ** 2 + (self.y - pp.y) ** 2) ** 0.5
@classmethod
def base_point(cls):
bp = cls()
bp.x = 0
bp.y = 0
return bp
@staticmethod
def my_sum(x, y):
return x+y
class ThPoint(Point):
def __init__(self, x, y, z):
self.x = x
self.y = y
self.z = z
实例化并打印一个三维的点
p1 = ThPoint(1, 2, 3)
print(p1)
上面的print(p1)打印的结果是（1，2）这是为什么呢？p1实例化ThPoint(1, 2, 3)已经传了z=3，而实际结果只输出了二位的（1，2）？
原因是执行print(p1)时，先从子类ThPoint中寻找__str__方法，但是ThPoint中并没有此方法，所以到父类中寻找__str__方法，而父类中的__str__方法中只return了x坐标和y坐标，并没有z坐标，所以必须要更改__str__方法，让其返回z坐标。但是不能直接在父类Point中更改__str__方法，因为如果改了，就无法满足输出二维的点了，要同时满足既可以输入二维的点，又可以输出三维的点。解决的方法就是重写：在子类ThPoint中写一个__str__方法，打印三维点的数据格式，这样要打印三维点的时候，实例化T和Point后，遵循就近原则，先从当前的子类中寻找__str__方法，对上面代码进行修改，在子类中添加__str__方法：
class Point:
"""
创建一个类
"""
name = '点' # 类的属性
def __init__(self, x, y):
self.x = x
self.y = y
print('我执行了初始化方法')
def __str__(self):
return '({},{})'.format(self.x, self.y)
# def my_print(self): # 对象方法
# print('({},{})'.format(self.x, self.y))
def distance(self, pp):
return ((self.x - pp.x) ** 2 + (self.y - pp.y) ** 2) ** 0.5
@classmethod
def base_point(cls):
bp = cls()
bp.x = 0
bp.y = 0
return bp
@staticmethod
def my_sum(x, y):
return x+y
class ThPoint(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(0,0,0)
p2 = TdPoint(2,3,4)
print(p1)
(0,0,0)
print(p1.distance(p2))
5.385164807134504
5.3 super 方法
重写了父类方法后如果又要调用父类的方法怎么解决呢？
例如，三维点在计算点与点的距离时，要求同时返回投射到二维平面的点的距离。
super() 函数是用于调用父类(超类)的一个方法。
super() 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。
MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。
方法一：直接通过类名的方式调用对应的方法（不推荐，因为不知道调用的方法的父类是哪层的，可能是父类，也可能是父类的父类）
class Point:
"""
创建一个类
"""
name = '点' # 类的属性
def __init__(self, x, y):
self.x = x
self.y = y
print('我执行了初始化方法')
def __str__(self):
return '({},{})'.format(self.x, self.y)
# def my_print(self): # 对象方法
# print('({},{})'.format(self.x, self.y))
def distance(self, pp):
return ((self.x - pp.x) ** 2 + (self.y - pp.y) ** 2) ** 0.5
@classmethod
def base_point(cls):
bp = cls()
bp.x = 0
bp.y = 0
return bp
@staticmethod
def my_sum(x, y):
return x+y
class ThPoint(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):
ds2 = Point.distance(self, p2) #直接通过类名的方式调用对应的方法
ds3 = ((self.x - p2.x) ** 2 + (self.y - p2.y) ** 2 + (self.z - p2.z) ** 2) ** 0.5
return ds2,ds3
@classmethod
def base_point(cls):
return cls(0, 0, 0)
p1 = ThPoint(0, 0, 0)
p2 = ThPoint(3, 4, 0)
print(p1.distance(p2))
方法二：使用super调用父类中的方法
class Point:
"""
创建一个类
"""
name = '点' # 类的属性
def __init__(self, x, y):
self.x = x
self.y = y
print('我执行了初始化方法')
def __str__(self):
return '({},{})'.format(self.x, self.y)
# def my_print(self): # 对象方法
# print('({},{})'.format(self.x, self.y))
def distance(self, pp):
return ((self.x - pp.x) ** 2 + (self.y - pp.y) ** 2) ** 0.5
@classmethod
def base_point(cls):
bp = cls()
bp.x = 0
bp.y = 0
return bp
@staticmethod
def my_sum(x, y):
return x+y
class ThPoint(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):
ds2 = super().distance(p2) #使用super调用父类中的方法
ds3 = ((self.x - p2.x) ** 2 + (self.y - p2.y) ** 2 + (self.z - p2.z) ** 2) ** 0.5
return ds2,ds3
@classmethod
def base_point(cls):
return cls(0, 0, 0)
p1 = ThPoint(0, 0, 0)
p2 = ThPoint(3, 4, 0)
print(p1.distance(p2))
使用super调用父类方法的好处：
在具有单继承的类层级结构中，super 可用来引用父类而不必显式地指定它们的名称，从而令代码更易维护。
super()会返回一个代理对象，它会将方法调用委托给父类，这对于访问已在类中被重载的父类方法很有用。
5.4 多态
python 是一门动态语言，严格的来说 python 不存在多态。
Java中多态性的表现： 多态性，可以理解为一个事物的多种形态。同样python中也支持多态，但是是有限的的支持多态性，主要是因为python中变量的使用不用声明，所以不存在父类引用指向子类对象的多态体现，同时python不支持重载。在python中 多态的使用不如Java中那么明显，所以python中刻意谈到多态的意义不是特别大。
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()
print(a._arg1)
a._method1()
这种以一个下划线开头的属性可以被类和实例调用。只是在 from xxx import * 时不会被导入。
还有一种定义私有属性的方法是以两个下划线开头的名称（例如__spam)，这种方式定义的私有变量只能在类的内部访问。
class A:
__arg1 = 'A'
def __method1(self):
print('我是私有方法')
a = A()
# res = a.__arg1
a.__method1()
AttributeError: 'A' object has no attribute '__method1'
原因：
这种限制访问的原理是，以双下划线开头的属性名(至少带有两个前缀下划线，至多一个后缀下划线)会被改写成 _classname__spam，所以在类外部通过原名称反问不到，但在类的内部使用原名称可以访问。
在方法或者属性前面加上_类名，就可以访问了
a = A()
res = a._A__arg1
print(res)
a._A__method1()