Python基础知识：类

初级篇

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

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

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

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

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

• 继承：子类可以继承父类的所有内容，分为单继承和多继承；

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

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

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

2、创建类

• 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()

3、类中的每个属性都要有初始值，哪怕这个值是0或空字符，在有些情况下，可以设置默认值，在__init__()内指定初始值，如果你对某个属性这么做了，就无需包含为它提供初始值的形参。

• 三种方法修改属性值：1、直接修改；2、通过方法修改；3、通过增量修改

#创建一个餐馆类，并修改属性值
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()

4、单继承：一个类继承另一个类时，它将自动获取另个一个类的所有属性和方法，原有的称为父类，也叫基类，新类称为子类，也叫派生类；同时子类还可以定义自己特有的属性和方法；如果父类和子类有相同的方法，子类优先执行自己的方法。

　　创建子类时，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()

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

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

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

• 复杂的继承关系：

 

6、将实例用作属性

#将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()

7、导入类

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

8、有序字典

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

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)

9、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()　　

10、练习题

#汽车-电动汽车-电池,给电池类添加一个更新电池容量的方法
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()

 11、面向对象初级知识的介绍，总结如下：

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

问答专区

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

答：从简单来说，如果程序中的所有功能都是用 类 和 对象 来实现，那么就是面向对象编程了。

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

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

所以，一般在Python开发中，全部使用面向对象 或 面向对象和函数式混合使用

面向对象的应用场景:

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

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

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

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

进阶篇

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

注：所有成员中，只有普通字段的内容保存对象中，即：根据此类创建了多少对象，在内存中就有多少个普通字段。而其他的成员，则都是保存在类中，即：无论对象的多少，在内存中只创建一份。

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

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

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

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

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

• 普通方法：由对象调用；至少一个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()

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

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

3、属性

• 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

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

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

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

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

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

 

#新式类，具有三种@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 方法

注：经典类中的属性只有一种访问方式，其对应被 @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     # 删除商品原价

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

class Foo:

    def get_bar(self):
        return 'wupeiqi'

    BAR = property(get_bar)

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

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...

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

 4、类成员的修饰符

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

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

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

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

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

静态字段

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

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），不建议强制访问私有成员。

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

5、类的特殊成员

• __方法名__，这种前后有双下划线的方法为构造方法，还有一种方法叫析构方法，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)

•  __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'>

•  __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()

 6、isinstance()判断对象是否是某个类的实例，这个类可以是创建实例的类型或类的父类；issubclass()判断一个类是否是另一个类的子类

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

7、主动执行父类的方法，第一种方法：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

8、设计模式之单例模式

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>