- 类的概念
- 如何创建一个类
- 方法和特殊方法
- 静态数据、静态方法和装饰器
- 继承和多态
- 继承
- 多态
- 模块调用和多文件应用程序
- Python标准库
python完全支持过程化编程和面向对象编程。面对对象编程是一种设计思想，意味着我们把对象作为程序的基本单元，而每个对象包含了自己的属性和方法。面向对象编程主要有以下特点：
- 封装（Encapsulation）：对外部世界隐藏对象的工作细节。
- 继承（Inheritance）：继承使子类具有父类的各种属性和方法，而不需要编写相同的代码。
- 多态（Polymorphism）：为不同的数据类型的实体提供统一的接口。
类的创建的语法：
class className(base_classes):
suite
对象的创建有两个步骤：
- 构造对象
- 初始化对象
class Chair(object):
def __init__(self, name, legs=4):
self.name = name
self.legs = legs
__init__ 是 Python 中的特殊方法（special method），它用于初始化对象。它是一个实例被创建时最先被调用的函数，并且每次创建实例，它的__init__都会被调用，而且它的第一个参数永远是 self，指向创建的实例本身。（init是initial的简写，顾名思义就是用来初始化的）
chair1 = Chair('Barcelona')
chair2 = Chair('Bar',1)
print(chair2.name)
chair1.legs = 2
print(chair1.legs)
输出： Bar 2
由于这些属性是public，可以通过’ . '运算符进行读取和赋值。
方法和特殊方法class Rectangle(object):
def __init__(self, width, height):
self.width = width
self.height = height
def area(self):
return self.width * self.height
rect = Rectangle(5, 4)
print(rect.width, rect.height, rect.area())
输出： 5 4 20
python 方法的机理，包括特殊方法，与函数的机理是完全一样的，不过会外加第一参数self，以及对self的属性进行访问的能力和调用self的方法。
静态数据、静态方法和装饰器在某些情况下，拥有一些能够和类而不是类的实例一起使用的数据会非常有用。
class Balloon(object):
unique_colors = set()
def __init__(self,color):
self.color = color
Balloon.unique_colors.add(color)
@staticmethod
def uniqueColorCount():
return len(Balloon.unique_colors)
@staticmethod
def uniqueColors():
return Balloon.unique_colors.copy()
静态数据是在class块内创建的，但却是在任何def语句之外。为了访问静态数据，必须给定其名字，最简单的方法就是使用类名，就像在Balloon类的静态方法中所做的那样。
@staticmethod是一个装饰器。所谓的装饰器就是一个函数，它带一个作为参数的函数，用一定的方式封装函数，然后再将封装后的函数赋值回初始函数的名字。因此它和下列代码有着相同的效果；
def uniqueColors():
return Balloon.unique_colors.copy()
uniqueColors = staticmethod(uniqueColors)
符号@用于表明这是一个装饰器。staticmethod( )函数是一个python的内置函数。
继承和多态 继承在面向对象编程中，当我们已经创建了一个类，而又想再创建一个与之相似的类，比如添加几个方法，或者修改原来的方法，这时我们不必从头开始，可以从原来的类派生出一个新的类，我们把原来的类称为父类或基类，而派生出的类称为子类，子类继承了父类的所有数据和方法。
先从一个简单的类开始；
class Person:
def __init__(self, name, job=None, pay=0):
self.name = name
self.job = job
self.pay = pay
def lastName(self):
return self.name.split()[-1]
def giveRaise(self,percent):
self.pay = int(self.pay * (1+percent))
def __repr__(self):
return '[Person: %s, %s]' %(self.name, self.pay)
class Manger(Person):
def giveRaise(self, percent, bonus=.10):
Person.giveRaise(self, percent + bonus)
def side_remark(self):
print(self.job, '千里之行,始于足下。')
if __name__ == '__main__':
bob = Person('Bob Smitch')
sue = Person('Sue Jones', job='dev', pay=100000)
print(bob)
print(sue)
print(bob.lastName(),sue.lastName())
sue.giveRaise(.10)
print(sue)
print('--------分隔-------')
tom = Manger('Tom Jones','mgr',50000)
tom.giveRaise(.10)
tom.side_remark()
print(tom.lastName())
print(tom)
输出： [Person: Bob Smitch, 0] [Person: Sue Jones, 100000] Smitch Jones [Person: Sue Jones, 110000] --------分隔------- mgr 千里之行,始于足下。 Jones [Person: Tom Jones, 60000]多态
if __name__ == '__main__':
...
print('----three all----')
for obj in (bob, sue, tom):
obj.giveRaise(.10)
print(obj)
输出： ----three all---- [Person: Bob Smitch, 0] [Person: Sue Jones, 121000] [Person: Tom Jones, 72000]
这里obj可能是一个Person或Manger，这就是python的多态概念，giveRaise的具体行为取决于你将它用到哪一个对象。
多态的概念其实不难理解，它是指对不同类型的参数进行相同的操作，根据对象（或类）类型的不同而表现出不同的行为。继承可以拿到父类的所有数据和方法，子类可以重写父类的方法，也可以新增自己特有的方法。有了继承，才有了多态，这样才能实现为不同的数据类型的实体提供统一的接口。
模块调用和多文件应用程序面向对象编程允许把功能（例如，封装方法和数据属性）进行封装，如封装到类中。python模块允许在更高层次上封装哪些导入的功能—例如，整个类集，或者全部实例变量。所谓的模块可以认为是一个‘ .py ’后缀的文件。模块可能会含有导入时要执行的代码，但更为常见的是，它们通常只是在导入时，提供一些函数和实例化的类。
from person import Person
bob = Person('Bob Smitch')
sue = Person('Sue Jones', job='dev', pay=100000)
print(bob)
print(sue)
print(bob.lastName(),sue.lastName())
sue.giveRaise(.10)
print(sue)
person.py文件保存定义好的两个类；
from person import Manger
tom = Manger('Tom Jones','mgr',50000)
tom.giveRaise(.10)
tom.side_remark()
print(tom.lastName())
print(tom)
Python标准库
Python有自己的标准库，我们下载Python的时候，它们已经被默认安装了，其中有很多现成的模块供我们调用（关于标准库大家可以自行查阅）。
