1、类的定义（class）
在Python中，定义类是通过class关键字，类名通常是大写开头的单词。语法格式如下：
class ClassName: <statement-1> . . . <statement-N>
类实例化后，可以使用其属性，实际上，创建一个类之后，可以通过类名访问其属性。
1.1、构造方法（__init__(self)）
类有一个名为 __init__() 的特殊方法（构造方法），该方法在类实例化时会自动调用，像下面这样：
def __init__(self): self.data = []
如下实例化类 MyClass，对应的 __init__() 方法就会被调用：
x = MyClass()
注意，__init__方法的第一个参数永远是self，表示创建的实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。当然， __init__() 方法也可以有其他参数，参数通过 __init__() 传递到类的实例化操作上。在构造实例时，self参数不需要传，Python解释器自己会把实例变量传进去。
示例：
#!/usr/bin/python3 class Complex: def __init__(self, realpart, imagpart): self.r = realpart self.i = imagpart
x = Complex(3.0, -4.5) print(x.r, x.i) # 输出结果：3.0 -4.5
类的方法与普通的函数只有一个特别的区别：它们必须有一个额外的第一个参数名称（我们习惯将它命名为 self，但不是必须叫这个名字），除此之外，类的方法和普通函数没有什么区别。self代表的是类的实例，而非类。
1.2、创建一个类实例
类对象支持两种操作：属性引用和实例化。属性引用使用和 Python 中所有的属性引用一样的标准语法：obj.name。
类对象创建后，类命名空间中所有的命名都是有效属性名。所以如果类定义是这样：
#!/usr/bin/python3 class MyClass: """一个简单的类实例""" i = 12345 def f(self): return 'hello world' # 实例化类 x = MyClass() # 访问类的属性和方法 print("MyClass 类的属性 i 为：", x.i) print("MyClass 类的方法 f 输出为：", x.f())
可以自由地给一个实例变量绑定属性，比如，给实例 x 随便绑定一个name属性：
x.name = 'Bart Simpson' print(bart.name) #'Bart Simpson'
和静态语言不同，Python允许对实例变量绑定任何数据，也就是说，对于两个实例变量，虽然它们都是同一个类的不同实例，但拥有的变量名称都可能不同。
1.3、实例属性和类属性
Python是动态语言，可以给类的实例绑定任意的属性。给实例绑定属性我们可以通过self变量，或者直接给类实例绑定也行：
class Student(object): def __init__(self, name): self.name = name s = Student('Bob') s.score = 90 #直接绑定一个属性
在一个类中定义的属性，这种属性是类属性，归类本身所有：
class Student(object): name = 'Student' #类属性
类属性可以直接通过类来访问，也可以通过类实例来访问：
class Student(object): ... name = 'Student' ... s = Student() # 创建实例s print(s.name) #Student 打印出name属性，因为实例并没有name属性，所以会继续查找class的name属性 print(Student.name) #Student 打印类的name属性 s.name = 'Michael' # 给实例绑定name属性 print(s.name) #Michael 由于实例属性优先级比类属性高，因此，它会屏蔽掉类的name属性 print(Student.name) #Student 但是类属性并未消失，用Student.name仍然可以访问 del s.name # 如果删除实例的name属性 print(s.name) #Student 再次调用s.name，由于实例的name属性没有找到，类的name属性就显示出来了
在给一个类实例绑定属性时，建议不要使用和类属性相同的名字。
实例属性属于各个实例所有，互不干扰。类属性属于类所有，所有实例共享一个属性。建议不要对实例属性和类属性使用相同的名字，否则将产生难以发现的错误。
1.4、类的方法
在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。
#!/usr/bin/python3 #类定义 class people: #定义基本属性 name = '' age = 0 #定义私有属性,私有属性在类外部无法直接进行访问 __weight = 0 #定义构造方法 def __init__(self,n,a,w): self.name = n self.age = a self.__weight = w def speak(self): print("%s 说: 我 %d 岁。" %(self.name,self.age)) # 实例化类 p = people('runoob',10,30) p.speak() #输出 runoob 说: 我 10 岁。
1.5、私有属性和私有方法（以__开头的属性和方法）
在Python中，实例的变量名如果以__开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问。如果外部直接通过实例来访问私有属性和方法的话，代码将直接报错。
私有属性：以两个下划线开头（比如：__private_attrs）的属性为类的私有属性，该属性不能在类的外部被使用或直接访问，在类内部的方法中使用 self.__private_attrs 进行访问。
私有方法：以两个下划线开头（比如：__private_method）的属性为类的私有方法，该方法不能在类的外部被使用或直接访问，在类内部的方法中使用 self.__private_method 进行访问。
私有属性代码示例：
#!/usr/bin/python3 class JustCounter: __secretCount = 0 # 私有变量 publicCount = 0 # 公开变量 def count(self): self.__secretCount += 1 self.publicCount += 1 print (self.__secretCount) counter = JustCounter() counter.count() print (counter.publicCount) print (counter.__secretCount) # 这里将报错，实例不能访问私有变量
私有方法代码示例：
#!/usr/bin/python3 class Site: def __init__(self, name, url): self.name = name # public self.__url = url # private def who(self): print('name : ', self.name) print('url : ', self.__url) def __foo(self): # 私有方法 print('这是私有方法') def foo(self): # 公共方法 print('这是公共方法') self.__foo() # 可以通过类内部的方法来访问私有方法 x = Site('菜鸟教程', 'www.runoob.com') x.who() # 正常输出 x.foo() # 正常输出 x.__foo() # 访问私有方法这里将报错
1.5.1、通过实例直接访问私有变量
一般来说，私有变量是不能直接访问的，比如 __name，这是因为Python解释器对外把__name变量改成了_Student__name。但是实际上我们仍然可以通过_Student__name来访问__name变量：obj.__Student_name。
但是非常不建议这么做，因为不同版本的Python解释器可能会把__name改成不同的变量名。
2、继承
Python 同样支持类的继承。基类必须与派生类定义在一个作用域内。
派生类的定义如下所示：则此时基类 BaseClassName 必须和类 DerivedClassName 定义在同一个作用域内。
class DerivedClassName(BaseClassName1): <statement-1> . . . <statement-N>
除了直接使用类，还可以用表达式，基类定义在另一个模块中时这一点非常有用:
class DerivedClassName(modname.BaseClassName):
继承代码示例：
#!/usr/bin/python3 #类定义 class people: #定义基本属性 name = '' age = 0 #定义私有属性,私有属性在类外部无法直接进行访问 __weight = 0 #定义构造方法 def __init__(self,n,a,w): self.name = n self.age = a self.__weight = w def speak(self): print("%s 说: 我 %d 岁。" %(self.name,self.age)) #单继承示例 class student(people): grade = '' def __init__(self,n,a,w,g): #调用父类的构函 people.__init__(self,n,a,w) self.grade = g #覆写父类的方法 def speak(self): print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade)) s = student('ken',10,60,3) s.speak() #输出 ken 说: 我 10 岁了，我在读 3 年级
2.1、多继承
Python同样有限的支持多继承形式。继承了多个类的类定义形如下例：
class DerivedClassName(Base1, Base2, Base3): <statement-1> . . . <statement-N>
需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索 即方法在子类中未找到时，从左到右查找父类中是否包含方法。
代码实例：
#!/usr/bin/python3 #类定义 class people: #定义基本属性 name = '' age = 0 #定义私有属性,私有属性在类外部无法直接进行访问 __weight = 0 #定义构造方法 def __init__(self,n,a,w): self.name = n self.age = a self.__weight = w def speak(self): print("%s 说: 我 %d 岁。" %(self.name,self.age)) #单继承示例 class student(people): grade = '' def __init__(self,n,a,w,g): #调用父类的构函 people.__init__(self,n,a,w) self.grade = g #覆写父类的方法 def speak(self): print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade)) #另一个类，多重继承之前的准备 class speaker(): topic = '' name = '' def __init__(self,n,t): self.name = n self.topic = t def speak(self): print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic)) #多重继承 class sample(speaker,student): a ='' def __init__(self,n,a,w,g,t): student.__init__(self,n,a,w,g) speaker.__init__(self,n,t) test = sample("Tim",25,80,4,"Python") test.speak() #方法名同，默认调用的是在括号中排前地父类的方法 输出：我叫 Tim，我是一个演说家，我演讲的主题是 Python
2.2、super() 函数
super() 函数是用于调用父类(超类)的一个方法。
class A: def add(self, x): y = x+1 print(y) class B(A): def add(self, x): super().add(x) b = B() b.add(2) # 3
3、判断对象类型的方法
3.1、type()
判断对象类型可以使用type()函数，基本类型都可以用type()判断：
type(123) #<class 'int'> type('str') #<class 'str'> type(None) #<type(None) 'NoneType'> #函数和类也可以用type()判断： type(abs) #<class 'builtin_function_or_method'> type(a) #<class '__main__.Animal'>
type()函数返回的返回对应的Class类型。我们可以直接比较两个变量的type类型是否相同：
type(123)==type(456) #True # 判断基本数据类型可以直接写int，str等 type(123)==int #True type('abc')==str #True #如果要判断一个对象是否是函数可以使用types模块中定义的常量： import types def fn(): ... pass ...
type(fn)==types.FunctionType #True type(abs)==types.BuiltinFunctionType #True type(lambda x: x)==types.LambdaType #True type((x for x in range(10)))==types.GeneratorType #True
3.2、使用 isinstance(实例, 类)
对于class的继承关系来说，使用type()就很不方便。我们要判断class的类型，可以使用isinstance()函数：
#假设继承关系：object -> Animal -> Dog -> Husky a = Animal() d = Dog() h = Husky() isinstance(h, Dog) #true isinstance(h, Animal) #true isinstance(d, Dog) and isinstance(d, Animal) #true isinstance(d, Husky) #false isinstance('a', str) #True isinstance(123, int) #True isinstance(b'a', bytes) #True
使用 isinstance() 还可以判断一个变量是否是多个类型中的其中一种。比如下面的代码就可以判断是否是list或者tuple：
isinstance([1, 2, 3], (list, tuple)) #True isinstance((1, 2, 3), (list, tuple)) #True