• 12.python 模块使用，面向对象介绍

    一.简介

    　　模块是一个保存了Python代码的文件。模块能定义函数，类和变量。模块里也能包含可执行的代码

    　　模块分为三种：

    • 自定义模块
    • 内置标准模块
    • 开源模块（第三方）

    自定义模块：

    　　

    模块导入

    import module
from module.xx.xx import xx
from module.xx.xx import xx as rename  
from module.xx.xx import *

    导入自定义模块时注意路径，查看库文件sys.path,sys.path.append('路径')添加自定义路径

    二.内置模块

    time模块

    time模块提供各种操作时间的函数

    说明：一般有两种表示时间的方式:
           1.时间戳的方式(相对于1970.1.1 00:00:00以秒计算的偏移量),时间戳是惟一的
           2.以数组的形式表示即(struct_time),共有九个元素，分别表示，同一个时间戳的struct_time会因为时区不同而不同

    

    The tuple items are:
      year (including century, e.g. 1998)
      month (1-12)
      day (1-31)
      hours (0-23)
      minutes (0-59)
      seconds (0-59)
      weekday (0-6, Monday is 0)
      Julian day (day in the year, 1-366)
      DST (Daylight Savings Time) flag (-1, 0 or 1)
    

     
    

      

    •  函数
      • 

    

    time() -- 返回时间戳
    sleep() -- 延迟运行单位为s
    gmtime() -- 转换时间戳为时间元组（时间对象）
    localtime() -- 转换时间戳为本地时间对象
    asctime() -- 将时间对象转换为字符串
    ctime() -- 将时间戳转换为字符串
    mktime() -- 将本地时间转换为时间戳
    strftime() -- 将时间对象转换为规范性字符串
    常用的格式代码：
    

    %Y Year with century as a decimal number.
    %m Month as a decimal number [01,12].
    %d Day of the month as a decimal number [01,31].
    %H Hour (24-hour clock) as a decimal number [00,23].
    %M Minute as a decimal number [00,59].
    %S Second as a decimal number [00,61].
    %z Time zone offset from UTC.
    %a Locale's abbreviated weekday name.
    %A Locale's full weekday name.
    %b Locale's abbreviated month name.
    %B Locale's full month name.
    %c Locale's appropriate date and time representation.
    %I Hour (12-hour clock) as a decimal number [01,12].
    %p Locale's equivalent of either AM or PM.
    


    strptime() -- 将时间字符串根据指定的格式化符转换成数组形式的时间
    常用格式代码：
       同strftime
    

      

    • 举例
      • 

    

     View Code
    

    2.datetime模块
    

    定义的类有：　
    datetime.date　　　　--表示日期的类。常用的属性有year, month, day
    datetime.time　　　　--表示时间的类。常用的属性有hour, minute, second, microsecond
    

    datetime.datetime　　--表示日期时间
    datetime.timedelta　  --表示时间间隔，即两个时间点之间的长度

    

      

    • date类
      • 



    

    date类表示日期，构造函数如下 ：
    

    datetime.date(year, month, day);
    

    year (1-9999)
    

    month (1-12)
    

    day (1-31)
    

    date.today()　　--返回一个表示当前本地日期的date对象
    

    date.fromtimestamp(timestamp) --根据给定的时间戮，返回一个date对象
    


     View Code
    


    　　　　date.year() 　　--取给定时间的年
    

    　　　　date.month()　　--取时间对象的月
    

    　　　　date.day()　　--取给定时间的日
    

    date.replace()　　--生成一个新的日期对象，用参数指定的年，月，日代替原有对象中的属性
    

    date.timetuple()　　--返回日期对应的time.struct_time对象
    

    date.weekday()　　--返回weekday,Monday == 0 ... Sunday == 6
    

    date.isoweekday() --返回weekday,Monday == 1 ... Sunday == 7
    

    date.ctime()　　　　--返回给定时间的字符串格式
    

    

    

    

    


    


    1
    

    2
    

    3
    

    4
    

    5
    

    6
    


    		


    

    import datetime
    

    from dateutil.relativedelta import relativedelta
    

    # 获取当前时间的前一个月
    

    datetime.datetime.now() - relativedelta(months=+1)
    

    # 获取当天的前一个月
    

    datetime.date.today() - relativedelta(months=+1) 
    



    


    		



    


    



    



    



    



    

     View Code
    

      

    • 

      time 类
      



      • 



    

    time类表示时间，由时、分、秒以及微秒组成
    

    time.min（)　　--最小表示时间
    

    time.max()　　--最大表示时间
    

    time.resolution()　　--微秒
    


     View Code
    


      

    • datetime类
      • 



    

    datetime是date与time的结合体，包括date与time的所有信息
    

    datetime.max()　　--最大值
    

    datetime.min()　　--最小值
    

    datetime.resolution() --datetime最小单位
    

    datetime.today()　　--返回一个表示当前本地时间
    

    datetime.fromtimestamp()　　--根据给定的时间戮，返回一个datetime对象
    

    datetime.year()　　--取年
    

    datetime.month()　　--取月
    

    datetime.day()　　--取日期
    

    datetime.replace()　　--替换时间
    

    datetime.strptime()　　--将字符串转换成日期格式
    

    datetime.time()　　--取给定日期时间的时间　　
    

     View Code
    


    3.sys模块
    

       用于提供对解释器相关的访问及维护，并有很强的交互功能
    

    常用函数：
    

    sys.argv --传参，第一个参数为脚本名称即argv[0]
    

    sys.path --模块搜索路径
    

    sys.moudule --加载模块字典
    

    sys.stdin　　--标准输入
    

    sys.stdout　　--标准输出
    

    sys.stderr　　--错误输出
    

    sys.platform --返回系统平台名称
    

    sys.version　　--查看python版本
    

    sys.maxsize　　--最大的Int值
    

    举例:
    

    

    复制代码
    

    #!/usr/bin/env python
# -*- coding:utf-8 -*-
#传参
import sys

print(sys.argv[0])
print(sys.argv[1])
print(sys.argv[2])


##运行
python argv.py argv0 argv1
argv.py
argv0
argv1
    

    复制代码
    

    


     View Code
    

    

    复制代码
    

    #sys.exit()系统返回值 

>>> import sys
>>> sys.exit(0)

C:>echo %ERRORLEVEL%
0

#windows查看系统返回值命令
echo %ERRORLEVEL%
#linux查看系统返回值命令
echo $?
    

    复制代码
    

    

     View Code
    

     View Code
    

    4.pickle模块
    

    　　pickle，用于python特有的类型 和 python的数据类型间进行转换
    

     pickle模块提供了四个功能：dumps、dump、loads、load
    

    Functions:

        dump(object, file)
        dumps(object) -> string
        load(file) -> object
        loads(string) -> object

    pickle.dumps(obj)--把任意对象序列化成一个str，然后，把这个str写入文件
    pickle.loads(string)　　--反序列化出对象
    pickle.dump(obj,file)　　--直接把对象序列化后写入文件
    pickle.load(file)　　--从文件中反序列化出对象
    

    

    复制代码
    

    #!/usr/bin/env python
# -*- coding:utf-8 -*-
import pickle
accounts = {
    1000: {
        'name':'USERA',
        'email': 'lijie3721@126.com',
        'passwd': 'abc123',
        'balance': 15000,
        'phone': 13651054608,
        'bank_acc':{
            'ICBC':14324234,
            'CBC' : 235234,
            'ABC' : 35235423
        }
    },
    1001: {
        'name': 'USERB',
        'email': 'caixin@126.com',
        'passwd': 'abc145323',
        'balance': -15000,
        'phone': 1345635345,
        'bank_acc': {
            'ICBC': 4334343,
        }
    },
}
#把字典类型写入到文件中
f = open('accounts.db','wb')
f.write(pickle.dumps(accounts))
f.close()

#2，反序列出对象并修改其内容，并将修改内容重新写入文件
file_name = "accounts.db"
f = open(file_name,'rb')
account_dic = pickle.loads(f.read())
f.close()

account_dic[1000]['balance'] -= 500
f = open(file_name,'wb')
f.write(pickle.dumps(account_dic))
f.close()


#3,反序列化对象并查看其内容

f = open('accounts.db','rb')
acountdb = pickle.loads(f.read())
print(acountdb)
    

    复制代码
    

    

    

    复制代码
    

    dic = {
    'k1': [1,2],
    'k2': [3,4]
}
#1.将对象写入文件
f = open('test','wb')
pickle.dump(dic,f)
f.close()
#2.将文件中内容反序列化，并读出
f = open('test','rb')
dic2 = pickle.load(f)
print(dic2)
f.close()
    

    复制代码
    

    


    5.os模块
    

    作用：
    

    　　用于提供系统级别的操作
    

    函数：　
    

    

    复制代码
    

     1 os.getcwd()                 获取当前工作目录，即当前python脚本工作的目录路径
 2 os.chdir("dirname")         改变当前脚本工作目录；相当于shell下cd
 3 os.curdir                   返回当前目录: ('.')
 4 os.pardir                   获取当前目录的父目录字符串名：('..')
 5 os.makedirs('dir1/dir2')    可生成多层递归目录
 6 os.removedirs('dirname1')   若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
 7 os.mkdir('dirname')         生成单级目录；相当于shell中mkdir dirname
 8 os.rmdir('dirname')         删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
 9 os.listdir('dirname')       列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
10 os.remove()                 删除一个文件
11 os.rename("oldname","new")  重命名文件/目录
12 os.stat('path/filename')    获取文件/目录信息
13 os.sep                      操作系统特定的路径分隔符，win下为"\",Linux下为"/"
14 os.linesep                  当前平台使用的行终止符，win下为"	
",Linux下为"
"
15 os.pathsep                  用于分割文件路径的字符串
16 os.name                     字符串指示当前使用平台。win->'nt'; Linux->'posix'
17 os.system("bash command")   运行shell命令，直接显示
18 os.environ                  获取系统环境变量
19 os.path.abspath(path)       返回path规范化的绝对路径
20 os.path.split(path)         将path分割成目录和文件名二元组返回
21 os.path.dirname(path)       返回path的目录。其实就是os.path.split(path)的第一个元素
22 os.path.basename(path)      返回path最后的文件名。如何path以／或结尾，那么就会返回空值。即os.path.split(path)的第二个元素
23 os.path.exists(path)        如果path存在，返回True；如果path不存在，返回False
24 os.path.isabs(path)         如果path是绝对路径，返回True
25 os.path.isfile(path)        如果path是一个存在的文件，返回True。否则返回False
26 os.path.isdir(path)         如果path是一个存在的目录，则返回True。否则返回False
27 os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
28 os.path.getatime(path)      返回path所指向的文件或者目录的最后存取时间
29 os.path.getmtime(path)      返回path所指向的文件或者目录的最后修改时间
    

    复制代码
    

    

    6.hashlib模块
    

    　　作用：
    

    　　用于加密相关的操作，代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法　
    

     View Code
    

    　　加密算法缺陷，即：通过撞库可以反解。所以，有必要对加密算法中添加自定义key再来做加密
    

     View Code
    

    　　7.random
    

    　　作用：
    

    　　生成随机变量
    

    

    import random
 
print(random.random())
print(random.randint(1, 2))
print(random.randrange(1, 10))
    

    

    

    复制代码
    

    import random
checkcode = ''
for i in range(4):
    current = random.randrange(0,4)
    if current != i:
        temp = chr(random.randint(65,90))
    else:
        temp = random.randint(0,9)
    checkcode += str(temp)
print checkcode
    

    复制代码
    

     
    

     
    

    参考链接
    

    https://i.cnblogs.com/EditPosts.aspx?opt=1
    

     
    

    

    python 面向对象（进阶篇）
    


    成员
    

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

    

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

    一、字段
    

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

      

    • 普通字段属于对象
      • 

    • 静态字段属于类
      • 

    

     字段的定义和使用
    

    由上述代码可以看出【普通字段需要通过对象来访问】【静态字段通过类访问】，在使用上可以看出普通字段和静态字段的归属是不同的。其在内容的存储方式类似如下图：
    

    

    由上图可是：
    

      

    • 静态字段在内存中只保存一份
      • 

    • 普通字段在每个对象中都要保存一份
      • 

    

    应用场景： 通过类创建对象时，如果每个对象都具有相同的字段，那么就使用静态字段
    

    二、方法
    

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

      

    • 普通方法：由对象调用；至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self；
      • 

    • 类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls；
      • 

    • 静态方法：由类调用；无默认参数；
      • 

    

     方法的定义和使用
    

    

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

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

    三、属性　　
    

    如果你已经了解Python类中的方法，那么属性就非常简单了，因为Python中的属性其实是普通方法的变种。
    

    对于属性，有以下三个知识点：
    

      

    • 属性的基本使用
      • 

    • 属性的两种定义方式
      • 

    

    1、属性的基本使用
    

     属性的定义和使用
    

    

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

      

    • 定义时，在普通方法的基础上添加 @property 装饰器；
      • 

    • 定义时，属性仅有一个self参数
      • 

    • 调用时，无需括号
                 方法：foo_obj.func()
                 属性：foo_obj.prop
      • 



    

    注意：属性存在意义是：访问属性时可以制造出和访问字段完全相同的假象
    

            属性由方法变种而来，如果Python中没有属性，方法完全可以代替其功能。
    

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

      

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

    • 根据m 和 n 去数据库中请求数据 
      • 



    

     View Code
    

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

    2、属性的两种定义方式
    

    属性的定义有两种方式：
    

      

    • 装饰器 即：在方法上应用装饰器
      • 

    • 静态字段 即：在类中定义值为property对象的静态字段
      • 



    

    装饰器方式：在类的普通方法上应用@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     # 删除商品原价
    

    复制代码
    

    

    

    

    静态字段方式，创建值为property对象的静态字段
    

    

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

    

    

    复制代码
    

    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__ ，此参数是该属性的描述信息
      • 

    

     View Code
    

     由于静态字段方式创建属性具有三种访问方式，我们可以根据他们几个属性的访问特点，分别将三个方法定义为对同一个属性：获取、修改、删除
    

     实例
    

     注意：Python WEB框架 Django 的视图中 request.POST 就是使用的静态字段的方式创建的属性
    

     Django源码
    

    

    所以，定义属性共有两种方式，分别是【装饰器】和【静态字段】，而【装饰器】方式针对经典类和新式类又有所不同。
    

    类成员的修饰符
    

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

      

    • 公有成员，在任何地方都能访问
      • 

    • 私有成员，只有在类的内部才能方法
      • 

    

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

    

    

    

    


    


    1
    

    2
    

    3
    

    4
    

    5
    
    		


    

    class C:
    

     
    

        def __init__(self):
    

            self.name = '公有字段'
    

            self.__foo = "私有字段"
    

    
    		

    
    

    

    

    

    

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

    静态字段
    

      

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

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

    

     公有静态字段
    

     私有静态字段
    

    普通字段
    

      

    • 公有普通字段：对象可以访问；类内部可以访问；派生类中可以访问
      • 

    • 私有普通字段：仅类内部可以访问；
      • 

    

    ps：如果想要强制访问私有字段，可以通过 【对象._类名__私有字段明 】访问（如：obj._C__foo），不建议强制访问私有成员。
    

     公有字段
    

     私有字段
    

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

    ps：非要访问私有属性的话，可以通过 对象._类__属性名
    

    类的特殊成员
    

    上文介绍了Python的类成员以及成员修饰符，从而了解到类中有字段、方法和属性三大类成员，并且成员名前如果有两个下划线，则表示该成员是私有成员，私有成员只能由类内部调用。无论人或事物往往都有不按套路出牌的情况，Python的类成员也是如此，存在着一些具有特殊含义的成员，详情如下：
    

    1. __doc__
    

    　　表示类的描述信息
    

     View Code
    

    2. __module__ 和  __class__ 
    

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

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

     lib/aa.py
    

     index.py
    

    3. __init__
    

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

     View Code
    

    4. __del__
    

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

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

     View Code
    

    5. __call__
    

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

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

     View Code
    

    6. __dict__
    

    　　类或对象中的所有成员
    

    上文中我们知道：类的普通字段属于对象；类中的静态字段和方法等属于类，即：
    

    

     View Code
    

     7. __str__
    

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

     View Code
    

    8、__getitem__、__setitem__、__delitem__
    

    用于索引操作，如字典。以上分别表示获取、设置、删除数据
    

    

    

    

    


    


    1
    

    2
    

    3
    

    4
    

    5
    

    6
    

    7
    

    8
    

    9
    

    10
    

    11
    

    12
    

    13
    

    14
    

    15
    

    16
    

    17
    

    18
    

    19
    

    20
    
    		


    

    #!/usr/bin/env python
    

    # -*- coding:utf-8 -*-
    

     
    

    class Foo(object):
    

     
    

        def __getitem__(self, key):
    

            print '__getitem__',key
    

     
    

        def __setitem__(self, key, value):
    

            print '__setitem__',key,value
    

     
    

        def __delitem__(self, key):
    

            print '__delitem__',key
    

     
    

     
    

    obj = Foo()
    

     
    

    result = obj['k1']      # 自动触发执行 __getitem__
    

    obj['k2'] = 'wupeiqi'   # 自动触发执行 __setitem__
    

    del obj['k1']           # 自动触发执行 __delitem__
    

    
    		

    
    

    

    

    

    

    9、__getslice__、__setslice__、__delslice__
    

     该三个方法用于分片操作，如：列表
    

    

    

    

    


    


    1
    

    2
    

    3
    

    4
    

    5
    

    6
    

    7
    

    8
    

    9
    

    10
    

    11
    

    12
    

    13
    

    14
    

    15
    

    16
    

    17
    

    18
    

    19
    
    		


    

    #!/usr/bin/env python
    

    # -*- coding:utf-8 -*-
    

     
    

    class Foo(object):
    

     
    

        def __getslice__(self, i, j):
    

            print '__getslice__',i,j
    

     
    

        def __setslice__(self, i, j, sequence):
    

            print '__setslice__',i,j
    

     
    

        def __delslice__(self, i, j):
    

            print '__delslice__',i,j
    

     
    

    obj = Foo()
    

     
    

    obj[-1:1]                   # 自动触发执行 __getslice__
    

    obj[0:1] = [11,22,33,44]    # 自动触发执行 __setslice__
    

    del obj[0:2]                # 自动触发执行 __delslice__
    

    
    		

    
    

    

    

    

    

    10. __iter__ 
    

    用于迭代器，之所以列表、字典、元组可以进行for循环，是因为类型内部定义了 __iter__ 
    

     第一步
    

     第二步
    

     第三步
    

    以上步骤可以看出，for循环迭代的其实是  iter([11,22,33,44]) ，所以执行流程可以变更为：
    

    

    

    

    


    


    1
    

    2
    

    3
    

    4
    

    5
    

    6
    

    7
    
    		


    

    #!/usr/bin/env python
    

    # -*- coding:utf-8 -*-
    

     
    

    obj = iter([11,22,33,44])
    

     
    

    for i in obj:
    

        print i
    

    
    		

    
    

    

    

    

    

     For循环语法内部
    

    11. __new__ 和 __metaclass__
    

    阅读以下代码：
    

    

    

    

    


    


    1
    

    2
    

    3
    

    4
    

    5
    

    6
    
    		


    

    class Foo(object):
    

     
    

        def __init__(self):
    

            pass
    

     
    

    obj = Foo()   # obj是通过Foo类实例化的对象
    

    
    		

    
    

    

    

    

    

    上述代码中，obj 是通过 Foo 类实例化的对象，其实，不仅 obj 是一个对象，Foo类本身也是一个对象，因为在Python中一切事物都是对象。
    

    如果按照一切事物都是对象的理论：obj对象是通过执行Foo类的构造方法创建，那么Foo类对象应该也是通过执行某个类的 构造方法 创建。
    

    

    

    

    


    


    1
    

    2
    
    		


    

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

    print type(Foo) # 输出：<type 'type'>              表示，Foo类对象由 type 类创建
    

    
    		

    
    

    

    

    

    

    所以，obj对象是Foo类的一个实例，Foo类对象是 type 类的一个实例，即：Foo类对象 是通过type类的构造方法创建。
    

    那么，创建类就可以有两种方式：
    

    a). 普通方式
    

    

    

    

    


    


    1
    

    2
    

    3
    

    4
    
    		


    

    class Foo(object):
    

     
    

        def func(self):
    

            print 'hello wupeiqi'
    

    
    		

    
    

    

    

    

    

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

    

    

    

    


    


    1
    

    2
    

    3
    

    4
    

    5
    

    6
    

    7
    
    		


    

    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(object):

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

    复制代码
    

    

    




    参考链接 
    

    https://www.cnblogs.com/wupeiqi/p/4766801.html
    

    

    

    
    
          
    • 

          
  • 

            相关阅读:
    
            
              【Golang基础总结】数组和切片的比较
                
    如何转载别人的文章
                
    C语言字节对齐问题详解
                
    幷查集拓展
                
    贪心
                
    dfs
                
    Trie
                
    哈夫曼树
                
    bfs
                
    并查集
                
                    
          
    • 
          
  • 
            原文地址：https://www.cnblogs.com/wolfboy55-163-com/p/8254382.html
          
    • 

        

      



      
      

        

        

      

    

  


  

  
Copyright © 2020-2023 
  润新知