Python基础知识：类

初级篇

• 面向过程：根据业务逻辑从上到下写垒代码

• 函数式：将某功能代码封装到函数中，往后便无需重复编写，仅调用函数便可

• 面向对象：对函数进行分类和封装，让开发“更快更好更强...”

一、面向对象三大特性：封装、继承、多态。

• 封装：将内容封装到某处，从某处调用被封装的内容；

• 继承：子类能够继承父类的全部内容，分为单继承和多继承；

  • 当类是经典类（不继承object）时，多继承状况下，会按照深度优先方式查找，即左边一条道走到黑，一直到共同的父类，再去右边找；

  • 当类是新式类（默认继承object）时，多继承状况下，会按照广度优先方式查找，即左边到共同父类以前，再去右边找，直到共同父类；

• 多态：由不一样的类实例化获得的对象，调用同一个方法，执行的逻辑不一样。

二、建立类

• class ClassName()--建立类，类的命名规则为驼峰法，每一个单词的首字母必须大写；小写的名称指根据类建立的实例（对象）；
• Python2.7中建立类时，须要在括号内包含object，如class ClassName(object)
• 类中的函数称为方法，有关函数的一切都适用于方法，惟一的差异在于调用方法的方式；
• __init__()这是一个特殊的方法，称为构造方法，每当你根据类建立新的实例时，Python都会自动运行它；开头和末尾各有两个下划线，这是一种约定，旨在避免默认方法和普通方法发生名称冲突；

class Dog():
    '''一次模拟小狗的简单尝试'''
    def __init__(self,name,age):
        '''初始化属性name和age'''
        self.name = name
        self.age = age
    def sit(self):
        '''模拟小狗被命令时蹲下'''
        print(self.name.title() + ' is now sitting.')
    def roll_over(self):
        '''模拟小狗被命令时打滚'''
        print(self.name.title() + ' rolled over.')
my_dog = Dog('holiday',3)
print("My dog's name is " + my_dog.name.title() + '.')
print("My dog's age is " + str(my_dog.age) + '.')
#用句点法来调用Dog类中定义的任何方法
my_dog.sit()
my_dog.roll_over()

三、类中的每一个属性都要有初始值，哪怕这个值是0或空字符，在有些状况下，能够设置默认值，在__init__()内指定初始值，若是你对某个属性这么作了，就无需包含为它提供初始值的形参。

• 三种方法修改属性值：一、直接修改；二、经过方法修改；三、经过增量修改

#建立一个餐馆类，并修改属性值
class Restaurant():
    def __init__(self,restaurant_name,cuisine_type):
        self.restaurant_name = restaurant_name
        self.cuisine_type = cuisine_type
        self.number_served = 0    #设置属性默认值
    def describe_restaurant(self):
        print("The name of restaurant is %s."%self.restaurant_name)
        print("The cuisine type of restaurant is %s."%self.cuisine_type)
        print("[%s] people have dined in this restaurant."%self.number_served)
    def set_number_served(self,number):  # 2经过方法修改属性值
        self.number_served = number
    def increment_number_served(self,increment_num):  #3经过增量修改属性值
        self.number_served += increment_num
        '''这个增量就是餐馆天天的就餐人数'''
        print('I think the restaurant serves %s people a day.'%increment_num)
    def open(self):
        print("The restaurant is open!")
restaurant = Restaurant('KFC','fast food')
restaurant.number_served = 10 #1直接修改属性值
restaurant.describe_restaurant()
restaurant.set_number_served(200)
restaurant.describe_restaurant()
restaurant.increment_number_served(300)
restaurant.describe_restaurant()

View Code

四、单继承：一个类继承另外一个类时，它将自动获取另个一个类的全部属性和方法，原有的称为父类，也叫基类，新类称为子类，也叫派生类；同时子类还能够定义本身特有的属性和方法；若是父类和子类有相同的方法，子类优先执行本身的方法。

　　建立子类时，Python首先要完成的就是为父类的全部属性赋值；super是一个特殊的函数，帮助子类和父类关联起来，父类也叫superclass，名称所以而来。

　　Python2.7中函数super（）须要两个实参：子类名和对象self。

#子类冰淇淋店继承父类餐馆
class Restaurant():
    def __init__(self,restaurant_name,cuisine_type):
        self.restaurant_name = restaurant_name
        self.cuisine_type = cuisine_type
    def describe_restaurant(self):
        print("The name of restaurant is %s."%self.restaurant_name)
        print("The cuisine type of restaurant is %s."%self.cuisine_type)
class IceCreamStand(Restaurant):
    def __init__(self,restaurant_name,cuisine_type):
        super().__init__(restaurant_name,cuisine_type)
        self.flavors = []
    def show_flavors(self):
        print("The menu of icecreamstand is as follows:")
        for flavor in self.flavors:
            print('\t' + flavor)
icecreamstand = IceCreamStand('Ice And Snow','icecream')
icecreamstand.flavors = ['a','b','c','d']
icecreamstand.show_flavors()

五、多继承：class 类（类1，类2）；若是类1和类2有相同的方法，优先执行类1的方法；

• 若是类1和类2没有共同的父类：一条道走到黑

• 若是类1和类2有共同的父类：第一条路只走到共同父类以前，再去走第二条路，最后再去找共同的父类；
• Python2中的类默认不继承object类，这中状况会一条路走到黑，直到顶端，继承Object以后就不会走到黑；

• 复杂的继承关系：

 

六、将实例用做属性

#将Privileges实例用做Admin类的一个属性
class User():
    def __init__(self,first_name,last_name,age):
        self.first_name = first_name
        self.last_name = last_name
        self.age = age
        self.login_attempts = 0
    def describe_user(self):
        print("User's first name is %s."%self.first_name)
        print("User's last name is %s."%self.last_name)
        print("User's age is %d."%self.age)
        print("User logged in %d times."%self.login_attempts)
    def increment_login_attempts(self):
        self.login_attempts += 1
    def reset_login_attempts(self):
        self.login_attempts = 0
    def greet_user(self):
        print("Hello " + self.last_name + ' ' + self.first_name +
              ",long time no see,are you OK?")
class Admin(User):
    def __init__(self,first_name,last_name,age):
        super().__init__(first_name,last_name,age)
        self.privileges = Privileges()
class Privileges():
    def __init__(self):
        self.privileges = ['can add post','can delete post','can ban user']
    def show_privileges(self):
        print('Administrator have the following privileges:')
        for privilege in self.privileges:
            print('\t'+privilege)
user = User('james','lebran',34)
user.increment_login_attempts()
user.describe_user()
user.reset_login_attempts()
user.describe_user()
admin = Admin('james','lebran',34)
admin.privileges.show_privileges()

View Code

七、导入类

• 方法同调用模块中的函数同样，模块中能够存放单个类或者多个类，使用import或者from...import..，*表示调出模块中全部类；
• 在使用pickle模块将对象保存到文件时，若是想在另个一个py文件中load该文件的对象，须要先导入对应的类；
• 有时候，须要将类分散到多个模块中，以避免模块太大，或在同一模块中存储不相关的类；将类存储在多个模块时，你可能会发现一个模块中的类依赖于另外一个模块中的类，这种状况下，可在前一个模块中导入必要的类。

八、有序字典

• 第一种方法： 定义一个新类，继承字典类

class MyDict(dict):
    def __init__(self):
        self.li = []
        #执行字典的初始化方法
        super(MyDict,self).__init__()
    def __setitem__(self, key, value):
        #执行字典的设置方法，将k,v添加到字典
        self.li.append(key)
        super(MyDict,self).__setitem__(key, value)
    def __str__(self):
        temp_list = []
        for key in self.li:
            value = self.get(key)
            temp_list.append("'%s:'%s"%(key,value))
        temp_str = '{' + ','.join(temp_list) + '}'
        return temp_str
obj = MyDict()
obj['k1'] = 123
obj['k2'] = 356
print(obj)

• 第二种方法：collections模块中的一个类OrderedDict()，记录字典中键值对的添加顺序，少许数据看不出来效果；

from collections import OrderedDict
favor_lang = OrderedDict()
favor_lang['james'] = 'c'
favor_lang['paul'] = 'c++'
favor_lang['alice'] = 'python'
new_dic = {}
for k,v in favor_lang.items():
    new_dic[k] = v
print(new_dic)

九、random模块包含以各类方式生成随机数的函数，randint()随机返回一个位于指定范围内的整数，范围两端的数字也会返回；

#摇骰子
from random import randint
class Die():
    def __init__(self,sides=6):
        self.sides = sides
    def roll_die(self):
        print(randint(1,self.sides))
die = Die(6)  
die.roll_die()　　

十、练习题

#汽车-电动汽车-电池,给电池类添加一个更新电池容量的方法
class Car():
    def __init__(self,make):
        self.make = make
        print('I have an %s.'%self.make)
class ElectricCar(Car):
    def __init__(self,make):
        super().__init__(make)
        self.battery = Battery()
class Battery():
    def __init__(self,battery_size=70):
        self.battery_size = battery_size
    def get_range(self):
        if self.battery_size == 70:
            range = 240
        elif self.battery_size == 85:
            range = 270
        print('This car can go approximately %d miles on a full charge.'%range)
    def upgrade_battery(self):
        if self.battery_size != 85:
            self.battery_size = 85
my_car = Car('audi')
electric_car = ElectricCar('tesla')
electric_car.battery.get_range()
electric_car.battery.upgrade_battery()
electric_car.battery.get_range()
my_battery = Battery(85)
my_battery.get_range()

View Code

 十一、面向对象初级知识的介绍，总结以下：

• 面向对象是一种编程方式，此编程方式的实现是基于对 类 和 对象 的使用
• 类 是一个模板，模板中包装了多个“函数”供使用
• 对象，根据模板建立的实例（即：对象），实例用于调用被包装在类中的函数
• 面向对象三大特性：封装、继承和多态

问答专区

问题一：什么样的代码才是面向对象？

答：从简单来讲，若是程序中的全部功能都是用 类 和 对象 来实现，那么就是面向对象编程了。

问题二：函数式编程 和 面向对象 如何选择？分别在什么状况下使用？

答：须知：对于 C# 和 Java 程序员来讲不存在这个问题，由于该两门语言只支持面向对象编程（不支持函数式编程）。而对于 Python 和 PHP 等语言却同时支持两种编程方式，且函数式编程能完成的操做，面向对象均可以实现；而面向对象的能完成的操做，函数式编程不行（函数式编程没法实现面向对象的封装功能）。

因此，通常在Python开发中，所有使用面向对象 或 面向对象和函数式混合使用

面向对象的应用场景:

1. 多函数需使用共同的值，如：数据库的增、删、改、查操做都须要链接数据库字符串、主机名、用户名和密码
2. 须要建立多个事物，每一个事物属性个数相同，可是值的需求
   如：张3、李4、杨五，他们都有姓名、年龄、血型，但其都是不相同。即：属性个数相同，但值不相同

问题三：类和对象在内存中是如何保存？

答：类以及类中的方法在内存中只有一份，而根据类建立的每个对象都在内存中须要存一份，大体以下图：

根据类建立对象时，对象中除了封装 name 和 age 的值以外，还会保存一个类对象指针，该值指向当前对象的类。

进阶篇

• 类的成员能够分为三大类：字段、方法和属性

注：全部成员中，只有普通字段的内容保存对象中，即：根据此类建立了多少对象，在内存中就有多少个普通字段。而其余的成员，则都是保存在类中，即：不管对象的多少，在内存中只建立一份。

一、字段：普通字段和静态字段，他们在定义和使用中有所区别，而最本质的区别是内存中保存的位置不一样

• 普通字段属于对象，普通字段在每一个对象中都要保存一份，只有类没有对象，内存中就没有普通字段；

• 静态字段属于类，静态字段在内存中只保存一份；
• 普通字段只能用对象访问，只有Python中静态字段能够用类和对象同时访问，最好不要用对象访问静态字段，以避免往后代码出错。
• 应用场景： 经过类建立对象时，若是每一个对象都具备相同的字段，那么就使用静态字段；

class Province:
    # 静态字段
    country ＝ '中国'
    def __init__(self, name):
        # 普通字段
        self.name = name
# 直接访问普通字段
obj = Province('河北省')
print obj.name
# 直接访问静态字段
Province.country

 二、方法：普通方法、静态方法和类方法，三种方法在内存中都归属于类，区别在于调用方式不一样。

• 普通方法：由对象调用；至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self；
• 类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类名赋值给cls；
• 静态方法：由类调用；参数无关紧要；
• 类方法和静态方法Python中也能够用对象调用，可是尽可能不要用；

class Foo:
    def __init__(self, name):
        self.name = name
    def ord_func(self):
        """ 定义普通方法，至少有一个self参数 """
        # print(self.name)
        print('普通方法')
    @classmethod
    def class_func(cls):
        """ 定义类方法，至少有一个cls参数 """
        print('类方法')
    @staticmethod
    def static_func():
        """ 定义静态方法 ，无默认参数"""
        print('静态方法')
# 调用普通方法
f = Foo()
f.ord_func()
# 调用类方法
Foo.class_func()
# 调用静态方法
Foo.static_func()

相同点：对于全部的方法而言，均属于类（非对象）中，因此，在内存中也只保存一份。

不一样点：方法调用者不一样、调用方法时自动传入的参数不一样。

三、属性

• Python中的属性实际上是普通方法的变种，具备方法的写做形式，具备字段访问形式。对于属性，有如下两个知识点：

　　a、属性的基本使用

#属性的基本使用
# ############### 定义 ###############
class Foo:
    def func(self):
        pass
    # 定义属性
    @property
    def prop(self):
        pass
# ############### 调用 ###############
foo_obj = Foo()
foo_obj.func()
foo_obj.prop   #调用属性

由属性的定义和调用要注意一下几点：

• 定义时，在普通方法的基础上添加 @property 装饰器；
• 定义时，属性仅有一个self参数
• 调用时，无需括号
             方法：foo_obj.func()
             属性：foo_obj.prop

属性存在乎义是：访问属性时能够制造出和访问字段彻底相同的假象；属性由方法变种而来，若是Python中没有属性，方法彻底能够代替其功能。

实例：对于主机列表页面，每次请求不可能把数据库中的全部内容都显示到页面上，而是经过分页的功能局部显示，因此在向数据库中请求数据时就要显示的指定获取从第m条到第n条的全部数据（即：limit m,n），这个分页的功能包括：

• 根据用户请求的当前页和总数据条数计算出 m 和 n
• 根据m 和 n 去数据库中请求数据 

# ############### 定义 ###############
class Pager:   
    def __init__(self, current_page):
        # 用户当前请求的页码（第一页、第二页...）
        self.current_page = current_page
        # 每页默认显示10条数据
        self.per_items = 10 

    @property
    def start(self):
        val = (self.current_page - 1) * self.per_items
        return val

    @property
    def end(self):
        val = self.current_page * self.per_items
        return val
# ############### 调用 ###############
p = Pager(1)
p.start 就是起始值，即：m
p.end   就是结束值，即：n

View Code

从上述可见，Python的属性的功能是：属性内部进行一系列的逻辑计算，最终将计算结果返回。

　　b、属性的两种定义方式：

• 装饰器 即：在类的普通方法上应用装饰器；
• 静态字段 即：在类中定义值为property对象的静态字段；

 咱们知道Python中的类有经典类和新式类，新式类的属性比经典类的属性丰富。（ 若是类继object，那么该类是新式类 ）；

#经典类，具备一种@property装饰器（如上一步实例）
# ############### 定义 ###############    
class Goods:
    @property
    def price(self):
        return "wupeiqi"
# ############### 调用 ###############
obj = Goods()
result = obj.price  # 自动执行 @property 修饰的 price 方法，并获取方法的返回值

View Code

 

#新式类，具备三种@property装饰器
# ############### 定义 ###############
class Goods(object):
    @property
    def price(self):
        print '@property'
    @price.setter
    def price(self, value):
        print '@price.setter'
    @price.deleter
    def price(self):
        print '@price.deleter'
# ############### 调用 ###############
obj = Goods()
obj.price    # 自动执行 @property 修饰的 price 方法，并获取方法的返回值
obj.price = 123    # 自动执行 @price.setter 修饰的 price 方法，并将  123 赋值给方法的参数
del obj.price    # 自动执行 @price.deleter 修饰的 price 方法

View Code

注：经典类中的属性只有一种访问方式，其对应被 @property 修饰的方法；新式类中的属性有三种访问方式，并分别对应了三个被@property、@方法名.setter、@方法名.deleter修饰的方法；因为新式类中具备三种访问方式，咱们能够根据他们几个属性的访问特色，分别将三个方法定义为对同一个属性：获取、修改、删除；

class Goods(object):

    def __init__(self):
        # 原价
        self.original_price = 100
        # 折扣
        self.discount = 0.8

    @property
    def price(self):
        # 实际价格 = 原价 * 折扣
        new_price = self.original_price * self.discount
        return new_price

    @price.setter
    def price(self, value):
        self.original_price = value

    @price.deltter
    def price(self, value):
        del self.original_price

obj = Goods()
obj.price         # 获取商品价格
obj.price = 200   # 修改商品原价
del obj.price     # 删除商品原价

View Code

• 当使用静态字段的方式建立属性时，经典类和新式类无区别

class Foo:

    def get_bar(self):
        return 'wupeiqi'

    BAR = property(get_bar)

obj = Foo()
reuslt = obj.BAR        # 自动调用get_bar方法，并获取方法的返回值
print reuslt

View Code

property的构造方法中有个四个参数：

• 第一个参数是方法名，调用 对象.属性 时自动触发执行方法
• 第二个参数是方法名，调用 对象.属性 ＝ XXX 时自动触发执行方法
• 第三个参数是方法名，调用 del 对象.属性 时自动触发执行方法
• 第四个参数是字符串，调用 对象.属性.__doc__ ，此参数是该属性的描述信息

class Foo：

    def get_bar(self):
        return 'wupeiqi'

    # *必须两个参数
    def set_bar(self, value): 
        return return 'set value' + value

    def del_bar(self):
        return 'wupeiqi'

    BAR ＝ property(get_bar, set_bar, del_bar, 'description...')

obj = Foo()

obj.BAR              # 自动调用第一个参数中定义的方法：get_bar
obj.BAR = "alex"     # 自动调用第二个参数中定义的方法：set_bar方法，并将“alex”看成参数传入
del Foo.BAR          # 自动调用第三个参数中定义的方法：del_bar方法
obj.BAE.__doc__      # 自动获取第四个参数中设置的值：description...

View Code

 注意：Python WEB框架 Django 的视图中 request.POST 就是使用的静态字段的方式建立的属性；因此，定义属性共有两种方式，分别是【装饰器】和【静态字段】，而【装饰器】方式针对经典类和新式类又有所不一样。

 四、类成员的修饰符

类的全部成员在上一步骤中已经作了详细的介绍，对于每个类的成员而言都有两种形式：

• 公有成员，在任何地方都能访问
• 私有成员，只有在类的内部才能方法

 私有成员和公有成员的定义不一样：私有成员命名时，前两个字符是下划线。（特殊成员除外，例如：__init__、__call__、__dict__等）

class C:
 
    def __init__(self):
        self.name = '公有字段'
        self.__foo = "私有字段"

View Code

私有成员和公有成员的访问限制不一样：

静态字段

• 公有静态字段：类能够访问；类内部能够访问；派生类中能够访问
• 私有静态字段：仅类内部能够访问；

class C:

    name = "公有静态字段"

    def func(self):
        print C.name

class D(C):

    def show(self):
        print C.name


C.name         # 类访问

obj = C()
obj.func()     # 类内部能够访问

obj_son = D()
obj_son.show() # 派生类中能够访问

公有静态字段

class C:

    __name = "公有静态字段"

    def func(self):
        print C.__name

class D(C):

    def show(self):
        print C.__name


C.__name       # 类访问            ==> 错误

obj = C()
obj.func()     # 类内部能够访问     ==> 正确

obj_son = D()
obj_son.show() # 派生类中能够访问   ==> 错误

私有静态字段

普通字段

• 公有普通字段：对象能够访问；类内部能够访问；派生类中能够访问
• 私有普通字段：仅类内部能够访问；

ps：若是想要强制访问私有字段，能够经过 【对象._类名__私有字段明 】访问（如：obj._C__foo），不建议强制访问私有成员。

方法、属性的访问于上述方式类似，即：私有成员只能在类内部使用

五、类的特殊成员

• __方法名__，这种先后有双下划线的方法为构造方法，还有一种方法叫析构方法，Python内部回收机制会在没有调用类的任何成员的时候，把内存清掉，在清除以前会执行一个析构方法__del__( )
•   __doc__

　　表示类的描述信息

•  __module__ 和  __class__ 

　　__module__ 表示当前操做的对象在那个模块

　　__class__     表示当前操做的对象的类是什么

•  __init__

　　构造方法，经过类建立对象时，自动触发执行。

•  __del__

　　析构方法，当对象在内存中被释放时，自动触发执行。

注：此方法通常无须定义，由于Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，由于此工做都是交给Python解释器来执行，因此，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。

•  __call__

　　对象后面加括号，触发执行。

注：构造方法的执行是由建立对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()

class Foo:

    def __init__(self):
        pass
    
    def __call__(self, *args, **kwargs):

        print('__call__')


obj = Foo() # 执行 __init__
obj()       # 执行 __call__

•  __dict__

　　类或对象中的全部成员

class Province:

    country = 'China'

    def __init__(self, name, count):
        self.name = name
        self.count = count

    def func(self, *args, **kwargs):
        print('func')

# 获取类的成员，即：静态字段、方法、
print Province.__dict__
# 输出：{'country': 'China', '__module__': '__main__', 'func': <function func at 0x10be30f50>, '__init__': <function __init__ at 0x10be30ed8>, '__doc__': None}

obj1 = Province('HeBei',10000)
print obj1.__dict__
# 获取 对象obj1 的成员
# 输出：{'count': 10000, 'name': 'HeBei'}

•  __str__

　　若是一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。

class Foo:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __str__(self):
        return '%s - %s' % (self.name,self.age)
#直接打印
obj = Foo('alex',23)
print(obj)
#执行str()函数，就会自动执行类中的__str__函数，并获取返回值
ret = str(obj)
print(ret)

View Code

•  __repr__

　　对于一个object来讲，__str__和__repr__都是返回对object的描述，只是，前一个的描述简短而友好，后一个的描述，更细节复杂一些。__str__()用于显示给用户，而__repr__()用于显示给开发人员，在终端不用print也会显示repr的返回值，而str函数的返回值必须print才能看见。

　　print(对象)时，若是找不到str方法，会执行repr方法代替输出，若是两个方法共存，仍是执行str方法。

• __getitem__、__setitem__、__delitem__

用于索引操做，如字典。有两种方法触发以上函数，分别是字符串形式和切片形式；以上分别表示获取、设置、删除数据；

class Foo():
    def __getitem__(self, key):
        print(key)
    def __setitem__(self, key, value):
        print(key, value)
    def __delitem__(self, key):
        print(key)
#字符串方式
obj = Foo()
result = obj['k1']  # 自动触发执行 __getitem__
obj['k2'] = 'charlie'  # 自动触发执行 __setitem__
del obj['k1']  # 自动触发执行 __delitem__
#输出
# k1
# k2 charlie
# k1
#切片方式
class Foo1():
    def __getitem__(self, item):
        #item.start,item.stop,item.step
        print(type(item))
    def __setitem__(self, key, value):
        print(type(key), type(value))
    def __delitem__(self, key):
        print(type(key))
obj = Foo1()
ret = obj[1:4:2] # 自动触发执行 __getitem__
obj[1:4] = [1,2] # 自动触发执行 __setitem__
del obj[1:4]  # 自动触发执行 __delitem__
#输出
# <class 'slice'>
# <class 'slice'> <class 'list'>
# <class 'slice'>

View Code

•  __iter__ 

用于迭代器，之因此列表、字典、元组能够进行for循环，是由于类型内部定义了 __iter__

class Foo:
    def __init__(self, sq):
        self.sq = sq
    def __iter__(self):
        return iter(self.sq)
obj = Foo([11,22,33,44])
for i in obj:
    print(i)
#输出11,22,33,44
#若是iter方法是一个生成器
class Foo:
    def __init__(self, sq):
        self.sq = sq
    def __iter__(self):
        yield 1
        yield 2
        yield 3
obj = Foo([11,22,33,44])
for i in obj:
    print(i)
#输出1，2，3

•  __new__ 和 __metaclass__

阅读如下代码：

class Foo:
    def __init__(self):
        pass
obj = Foo()   # obj是经过Foo类实例化的对象

上述代码中，obj 是经过 Foo 类实例化的对象，其实，不只 obj 是一个对象，Foo类自己也是一个对象，由于在Python中一切事物都是对象。若是按照一切事物都是对象的理论：obj对象是经过执行Foo类的构造方法建立，那么Foo类对象应该也是经过执行某个类的 构造方法 建立。

print type(obj) # 输出：<class '__main__.Foo'>     表示，obj 对象由Foo类建立
print type(Foo) # 输出：<type 'type'>              表示，Foo类对象由 type 类建立

因此，obj对象是Foo类的一个实例，Foo类对象是 type 类的一个实例，即：Foo类对象 是经过type类的构造方法建立。那么，建立类就能够有两种方式：

a). 普通方式

class Foo:
 
    def func(self):
        print('hello wupeiqi')

b).特殊方式（type类的构造函数）

def func(self):
    print('hello wupeiqi')
Foo = type('Foo',(object,), {'func': func})
#type第一个参数：类名
#type第二个参数：当前类的基类
#type第三个参数：类的成员

问题：类是由 type 类实例化产生，那么问题来了，类默认是由 type 类实例化产生，type类中如何实现的建立类？类又是如何建立对象？

答：类中有一个属性 __metaclass__，其用来表示该类由 谁 来实例化建立，因此，咱们能够为 __metaclass__ 设置一个type类的派生类，从而查看 类 建立的过程。

class MyType(type):

    def __init__(self, what, bases=None, dict=None):
        super(MyType, self).__init__(what, bases, dict)

    def __call__(self, *args, **kwargs):
        obj = self.__new__(self, *args, **kwargs)

        self.__init__(obj)

class Foo:

    __metaclass__ = MyType

    def __init__(self, name):
        self.name = name

    def __new__(cls, *args, **kwargs):
        return object.__new__(cls, *args, **kwargs)

# 第一阶段：解释器从上到下执行代码建立Foo类
# 第二阶段：经过Foo类建立obj对象
obj = Foo()

 六、isinstance()判断对象是不是某个类的实例，这个类能够是建立实例的类型或类的父类；issubclass()判断一个类是不是另外一个类的子类

#判断对象是不是某个类的实例
r = "abc"
print(isinstance(r,str))#True

七、主动执行父类的方法，第一种方法：super(子类,self).f1()；第二种方法：F1.f1(self)，不建议使用，了解就行；

class F1:
    def f1(self):
        print('f1.f1')
class F2(F1):
    def f1(self):
        #主动执行父类的fi
        super(F2,self).f1()
        #另外一种方法：F1.f1(self)
        print('f2.f1')
obj = F2()
obj.f1()
# f1.f1
# f2.f1

八、设计模式之单例模式

class Foo:
    #单例模式
    instance = None
    def __init__(self,name):
        self.name = name
    @classmethod
    def get_instance(cls):
        if cls.instance:
            return cls.instance
        else:
            obj = cls('alex')
            cls.instance = obj
            return obj
obj1 = Foo.get_instance()
print(obj1)
obj2 = Foo.get_instance()
print(obj2)
#两个对象如出一辙
# <__main__.Foo object at 0x000000B059AC92E8>
# <__main__.Foo object at 0x000000B059AC92E8>
class F1:
    #普通模式
    def __init__(self,name):
        self.name = name
f1 = F1('alex')
print(f1)
f2 = F1('alex')
print(f2)
#普通模式，参数同样时两个对象也不同
# <__main__.F1 object at 0x0000003E04762400>
# <__main__.F1 object at 0x0000003E04762550>