1. 创建 Python 类
python 3 最简单的类就像这样
class MyFirstClass:
pass
类定义以class关键字开始，接着是用于识别类的名字，最后以冒号结尾
2. 添加属性
不需要改动类的定义，可以直接通过点标记法为实例对象设定任意属性
class Point:
pass
# 创建对象实例
p1 = Point()
p2 = Point()
p1.x = 5
p1.y = 4
p1.x = 3
p1.y = 6
print(p1.x,p1.y)
print(p2.x,p2.y)
输出结果如下：
3. 让它做点什么
模拟 Point 类的一些动作，设置一个 reset 方法让对象回到原点
class Point:
def reset(self):
self.x = 0
self.y = 0
p = Point()
p.reset()
print(p.x,p.y)
输出结果如下：
Python 中的方法在格式上与函数完全一致。以 def 开头，然后是空格和方法名。可以这样理解，方法就是定义在类里面的函数，并且必须具有 self 参数，self 就是对方法所调用对象的引用
4. 更多参数
import math
class Point:
def move(self,x,y):
self.x=x
self.y=y
def reset(self):
self.move(0,0)
def calculate_distance(self,other_point):
return math.sqrt(
(self.x - other_point.x)**2+
(self.y - other_point.y)**2)
# 如何使用
point1 = Point()
point2 = Point()
point1.reset()
point2.move(5,0)
print(point2.calculate_distance(point1))
assert (point2.calculate_distance(point1)==
point1.calculate_distance(point2))
point1.move(3,4)
print(point1.calculate_distance(point2))
print(point1.calculate_distance(point1))
输出结果如下：
现在的类有3个方法。move 方法接收两个参数 x 和 y ，并将它们的值赋予 self 对象。reset 方法调用 move，calculate_distance 方法采用了毕达哥拉斯定理计算两个点之间的距离。注意，由于没有初始化对象，因此当
point3 = Point()
point3.x=5
print(point3.y)
时，会报如下错：
Point 对象没有属性 y
5. 初始化对象
python 3 初始化对象用到 __ init __函数
class Point:
def __init__(self,x,y):
self.move(x,y)
def move(self,x,y):
self.x=x
self.y=y
def reset(self):
self.move(0,0)
# 构造一个Point
point=Point(3,5)
print(point.x,point.y)
输出结果如下：
在初始化对象过程中，用到了__ init __函数，并定义了两个必须的参数 x 和 y，因此在创建对象实例时，必须传入对应参数，否则将会报错，如下：
point=Point(3,5)
当然，如果不想每次初始化时都传入参数，可以设置默认参数，如下：
class Point:
def __init__(self,x=1,y=2):
self.move(x,y)
def move(self,x,y):
self.x=x
self.y=y
def reset(self):
self.move(0,0)
# 构造一个Point
point=Point()
print(point.x,point.y)
输出结果如下：
6. 自我解释
在面向对象编程中，编写能清晰地总结每个对象和方法的API文档是非常重要的。但保持文档的更新是很难的，最好的方式是直接写进代码里。python 通过字符串文档来支持文档注释
class Point:
def __init__(self,x=1,y=2):
'''
description:
该函数用于初始化对象实例
param x: 坐标x
param y: 坐标y
'''
self.move(x,y)
def move(self,x,y):
self.x=x
self.y=y
def reset(self):
self.move(0,0)
# 构造一个Point
point = Point()
print(point.x,point.y)
输入 help(Point) 可得到类的相关帮助信息，如下：
7. 模块和包
模块就是一个 python 文件，import 语句用于从模块中导入模块或特定的类、函数。假设我们有一个 database.py 模块，其中包含一个 Database 类，则有以下几种变式可以用来访问模块中的类
import database
db = database.Database()
# 对 db 进行查询
from database import Database
db = Database()
# 对 db 进行查询
from database import Database as DB
db = DB()
# 对 db 进行查询
一次导入多个类
from database import Database, Query
一次导入所有类和函数（不推荐使用）
from database import *
8. 组织模块
当项目中模块越来越多时，可用包（package）来组织模块。一个包是一个目录下模块的集合，只需在目录下添加一个名为 __ init __.py 的文件（通常是空文件）就可以告诉 Python 这个目录是一个包
9. 绝对导入
绝对导入是指定我们想要导入的模块、函数或路径的完整路径。导入方法如下：
import Package.Model
class = Package.Model.Class()
或者
from Package.Model import Class
class = Class()
或者
from Package import Model
class = Model.Class()
import 语句用点句号操作符来区分包和模块
10. 相对导入
相对导入基本上是一种寻找与当前模块在位置上有相对关系的类、函数或模块的方式
from .Model import Class
Model 前面的点号的意思是“使用当前包内的 Model 模块”
from ..Model import Class
也可以这样用更多点号来访问更高的层级
11. 组织模块内容
在导入一个模块时，有时候不需要立即实例化对象，避免占用不必要的资源。因此，可以先导入，在需要的时候再进行实例化。如下例子，在真正需要的时候通过调用 initialize_database 函数来创建模块层的变量
class Database:
# 数据库的实现
pass
database = None
def initialize_database():
global database
database = Database()
global 关键字告诉 Python initialize_database 内部的变量 database 是刚刚在模块层定义的全局变量。另外，所有模块层的代码都会在导入的时候立即执行，而实际上我们有时只想访问其中的几个函数，为了解决这一问题，我们通过将启动代码放到一个函数中（根据惯例，一般叫做 main ），只有在将模块作为脚本运行时才会执行这一函数，在被其他脚本导入时则不会执行
class UsefulClass:
pass
def main():
useful = UsefulClass()
print(useful)
if __name__ == "__main__":
main()
其中，__ name __ 是一个特殊变量，在被其他模块导入时，值为 .py 文件的名字，本身作为运行脚本时，值为“--main--”，即是它本身的意思
