[Python] Python 之 __new__() 方法与实例化

__new__() 是在新式类中新出现的方法,它作用在构造方法建造实例之前,可以这么理解,在 Python 中存在于类里面的构造方法 __init__() 负责将类的实例化,而在 __init__() 启动之前,__new__() 决定是否要使用该 __init__() 方法,因为__new__() 可以调用其他类的构造方法或者直接返回别的对象来作为本类的实例。

 

如果将类比喻为工厂,那么__init__()方法则是该工厂的生产工人,__init__()方法接受的初始化参数则是生产所需原料,__init__()方法会按照方法中的语句负责将原料加工成实例以供工厂出货。而__new__()则是生产部经理,__new__()方法可以决定是否将原料提供给该生产部工人,同时它还决定着出货产品是否为该生产部的产品,因为这名经理可以借该工厂的名义向客户出售完全不是该工厂的产品。

 

__new__() 方法的特性:

  • __new__() 方法是在类准备将自身实例化时调用。
  • __new__() 方法始终都是类的静态方法,即使没有被加上静态方法装饰器。
  • 类的实例化和它的构造方法通常都是这个样子:
class MyClass(object):
    def __init__(self, *args, **kwargs):
        ...

# 实例化
myclass = MyClass(*args, **kwargs)

  

正如以上所示,一个类可以有多个位置参数和多个命名参数,而在实例化开始之后,在调用 __init__() 方法之前,Python 首先调用 __new__() 方法:

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

  

第一个参数cls是当前正在实例化的类。

  • 如果要得到当前类的实例,应当在当前类中的 __new__() 方法语句中调用当前类的父类的 __new__() 方法。

  例如,如果当前类是直接继承自 object,那当前类的 __new__() 方法返回的对象应该为:

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

  

注意:

  事实上如果(新式)类中没有重写__new__()方法,即在定义新式类时没有重新定义__new__()时,Python默认是调用该类的直接父类的__new__()方法来构造该类的实例,如果该类的父类也没有重写__new__(),那么将一直按此规矩追溯至object的__new__()方法,因为object是所有新式类的基类。

 

  而如果新式类中重写了__new__()方法,那么你可以自由选择任意一个的其他的新式类(必定要是新式类,只有新式类必定都有__new__(),因为所有新式类都是object的后代,而经典类则没有__new__()方法)的__new__()方法来制造实例,包括这个新式类的所有前代类和后代类,只要它们不会造成递归死循环。具体看以下代码解释:

 

class Foo(object):
    def __init__(self, *args, **kwargs):
        ...
    def __new__(cls, *args, **kwargs):
        return object.__new__(cls, *args, **kwargs)    

# 以上return等同于
# return object.__new__(Foo, *args, **kwargs)
# return Stranger.__new__(cls, *args, **kwargs)
# return Child.__new__(cls, *args, **kwargs)
class Child(Foo): def __new__(cls, *args, **kwargs): return object.__new__(cls, *args, **kwargs)
# 如果Child中没有定义__new__()方法,那么会自动调用其父类的__new__()方法来制造实例,即 Foo.__new__(cls, *args, **kwargs)。
# 在任何新式类的__new__()方法,不能调用自身的__new__()来制造实例,因为这会造成死循环。因此必须避免类似以下的写法:
# 在Foo中避免:return Foo.__new__(cls, *args, **kwargs)或return cls.__new__(cls, *args, **kwargs)。Child同理。
# 使用object或者没有血缘关系的新式类的__new__()是安全的,但是如果是在有继承关系的两个类之间,应避免互调造成死循环,例如:(Foo)return Child.__new__(cls), (Child)return Foo.__new__(cls)。
class Stranger(object):
    ...
# 在制造Stranger实例时,会自动调用 object.__new__(cls)

 

  •  通常来说,新式类开始实例化时,__new__()方法会返回cls(cls指代当前类)的实例,然后该类的__init__()方法作为构造方法会接收这个实例(即self)作为自己的第一个参数,然后依次传入__new__()方法中接收的位置参数和命名参数。

 

注意:如果__new__()没有返回cls(即当前类)的实例,那么当前类的__init__()方法是不会被调用的。如果__new__()返回其他类(新式类或经典类均可)的实例,那么只会调用被返回的那个类的构造方法。

class Foo(object):
    def __init__(self, *args, **kwargs):
        ...
    def __new__(cls, *args, **kwargs):
        return object.__new__(Stranger, *args, **kwargs)  

class Stranger(object):
    ...

foo = Foo()
print type(foo)    

# 打印的结果显示foo其实是Stranger类的实例。

# 因此可以这么描述__new__()和__ini__()的区别,在新式类中__new__()才是真正的实例化方法,为类提供外壳制造出实例框架,然后调用该框架内的构造方法__init__()使其丰满。
# 如果以建房子做比喻,__new__()方法负责开发地皮,打下地基,并将原料存放在工地。而__init__()方法负责从工地取材料建造出地皮开发招标书中规定的大楼,__init__()负责大楼的细节设计,建造,装修使其可交付给客户。

 

Python补充06 Python之道

作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明。谢谢!

 

Python有一个彩蛋,用下面语句调出:

import this

该彩蛋的文档记录于。

语句执行之后,终端将显示一首”The Zen of Python”的诗,即“Python之道”。这首诗总结了Python的风格,可以指导Python程序员的编程。Python程序员会自豪宣称自己”Pythonic”。Pythonic的一个基本标准,是写出合乎“Python之道”的代码

 

下面是“Python之道”的全文,以及我附加的翻译。

The Zen of Python, by Tim Peters

Python之道

Beautiful is better than ugly.

美观胜于丑陋。

Explicit is better than implicit.

显示胜于隐式。

Simple is better than complex.

简单胜于复杂。

Complex is better than complicated.

复杂胜于过度复杂。

Flat is better than nested.

平面胜于嵌套。

Sparse is better than dense.

稀少胜于稠密。

Readability counts.

可读性需要考虑。

Special cases aren’t special enough to break the rules.

即使情况特殊,也不应打破原则,

Although practicality beats purity.

尽管实用胜于纯净。

Errors should never pass silently.

错误不应悄无声息的通过,

Unless explicitly silenced.

除非特意这么做。

In the face of ambiguity, refuse the temptation to guess.

当有混淆时,拒绝猜测(深入的搞明白问题)。

There should be one– and preferably only one –obvious way to do it.

总有一个,且(理想情况下)只有一个,明显的方法来处理问题。

Although that way may not be obvious at first unless you’re Dutch.

尽管那个方法可能并不明显,除非你是荷兰人。(Python的作者Guido是荷兰人,这是在致敬)

Now is better than never.

现在开始胜过永远不开始,

Although never is often better than *right* now.

尽管永远不开始经常比仓促立即开始好。

If the implementation is hard to explain, it’s a bad idea.

如果程序实现很难解释,那么它是个坏主意。

If the implementation is easy to explain, it may be a good idea.

如果程序实现很容易解释,那么它可能是个好主意。

Namespaces are one honking great idea — let’s do more of those!

命名空间是个绝好的主意,让我们多利用它。

 

“Python之道”强调美观、简单、可读和实用,拒绝复杂或模糊。

 

历史

Tim Peters于的Python邮件列表,以”The Python Way”为标题,发表了“Python之道”,得到许多Python程序员的认同。另一方面,2001年的International Python Conference #10 (IPC10, IPC是PyCon的前身)会议,主办方希望在文化衫上印标语,而这一标语要能代表Python文化。到会的Python程序员们创作了500多条。组织者选了”import this”。后来,Python的作者Guido增加了this.py模块,让这个语句可以在解释器中执行,打印“Python之道”。

Python社区很幽默。

 

此外,是Python爱好者的集会,可以去给别人展示自己的Python项目,或者听讲座。2012年的PyCon是在北京和上海同时举行。

 

 

python学习1:先找个大纲,呵呵

来源:

第一篇Python语言基础知识
第1章Python概述
1.1Python简介
1.2Python的特征
1.3第一个Python程序
1.4搭建开发环境
1.4.1Python的下载和安装
1.4.2交互式命令行的使用方法
1.5Python的开发工具
1.5.1PythonWin的使用方法
1.5.2Eclipse IDE集成开发环境
1.5.3EditPlus编辑器环境的配置
1.6不同平台下的Python
1.7小结

第2章Python的基本语法
2.1Python的文件类型
2.2Python的编码规则
2.2.1命名规则
2.2.2代码缩进与冒号
2.2.3模块导入的规范
2.2.4使用空行分隔代码
2.2.5正确的注释
2.2.6语句的分隔
2.3变量和常量
2.3.1变量的命名
2.3.2变量的赋值
2.3.3局部变量
2.3.4全局变量
2.3.5常量
2.4数据类型
2.4.1数字类型
2.4.2字符串类型
2.5运算符与表达式
2.5.1算术运算符和算术表达式
2.5.2关系运算符和关系表达式
2.5.3逻辑运算符和逻辑表达式
2.5.4运算符的优先级
2.6小结

第3章Python的控制语句
3.1结构化程序设计
3.2条件语句
3.2.1if语句
3.2.2if…elif…else语句
3.2.3if语句的嵌套
3.2.4实现switch语句的功能
3.3循环语句
3.3.1while循环
3.3.2for循环
3.3.3break和continue语句
3.4结构化程序示例
3.5小结
第4章内置数据结构
4.1元组
4.1.1元组的创建
4.1.2元组的访问
4.1.3元组的遍历
4.2列表
4.2.1列表的创建
4.2.2列表的使用方法
4.2.3列表的查找、排序与反转
4.2.4用列表实现堆栈和队列
4.3字典
4.3.1字典的创建
4.3.2字典的访问
4.3.3字典的方法
4.3.4字典的排序与复制
4.3.5全局字典——sys.modules模块
4.4序列
4.5小结
第5章模块与函数
5.1Python程序的结构
5.2模块
5.2.1模块的创建
5.2.2模块的导入
5.2.3模块的属性
5.2.4模块的内置函数
2.5自定义包
5.3函数
5.3.1函数的定义
5.3.2函数的参数
5.3.3函数的返回值
5.3.4函数的嵌套
5.3.5递归函数
5.3.6lambda函数
5.3.7Generator函数
5.4小结
第6章字符串与正则表达式
6.1字符串的操作
6.1.1字符串的格式化
6.1.2字符串的转义符
6.1.3字符串的合并
6.1.4字符串的截取
6.1.5字符串的比较
6.1.6字符串的反转
6.1.7字符串的查找和替换
6.1.8字符串与日期的转换
6.2正则表达式
6.2.1正则表达式简介
6.2.2使用sys.re模块处理正则表达式
6.3小结
第7章文件的处理
7.1文件的基本操作
7.1.1文件的打开或创建
7.1.2文件的读取
7.1.3文件的写入
7.1.4文件的删除
7.1.5文件的复制
7.1.6文件的重命名
7.1.7文件内容的查找和替换
7.1.8文件的比较
7.1.9配置文件的访问
7.2目录的基本操作
7.2.1目录的创建与删除
7.2.2目录的遍历
7.3文件和流
7.3.1Python的流对象
7.3.2模拟Java的输入、输出流
7.4文件处理示例——文件属性浏览程序
7.5小结
第8章面向对象编程
8.1面向对象编程概述
8.2类和对象
8.2.1类和对象的区别
8.2.2类的定义
8.2.3对象的创建
8.2.4Python对象的体系结构
8.3属性和方法
8.3.1类的属性
8.3.2类的方法
8.3.3内部类的使用
8.3.4__init__方法
8.3.5__del__方法
8.3.6垃圾回收机制
8.3.7类的内置方法
8.3.8方法的动态特性
8.4继承
8.4.1使用继承
8.4.2抽象类的模拟
8.4.3多态性
8.4.4多重继承
8.4.5更好的继承方式
8.5运算符的重载
8.6Python与设计模式
8.6.1设计模式简介
8.6.2设计模式示例——Python实现工厂方法
8.7小结
第9章异常处理与程序调试
9.1异常的处理
9.1.1Python中的异常
9.1.2try…except的使用方法
9.1.3try…finally的使用方法
9.1.4使用raise抛出异常
9.1.5自定义异常
9.1.6assert语句的使用方法
9.1.7异常信息
9.2使用PythonWin调试程序
9.3使用Eclipse for Python调试程序
9.3.1新建工程
9.3.2配置调试
9.3.3设置断点
9.4小结
第10章Python 的数据库编程
10.1Python环境下的数据库编程
10.1.1通过ODBC访问数据库
10.1.2使用DAO对象访问数据库
10.1.3使用ActiveX Data Object访问数据库
10.1.4Python连接数据库的专用模块
10.2Python的持久化模块
10.2.1用dbhash模块读写数据
10.2.2shelve模块读写数据
10.3嵌入式数据库SQLite
10.3.1sqlite的命令行工具
10.3.2使用sqlite3模块访问sqlite数据库
10.4小结
第二篇Python的GUI程序设计

第11章WxPython的开发环境
11.1Python所支持的GUI开发库
11.1.1Tkinter
11.1.2PyGTK
11.1.3PyQT
11.2WxPython介绍
11.2.1下载和安装WxPython
11.2.2第一个WxPython程序
11.2.3WxPython的封装:Pythoncard
11.3WxPython的开发工具
11.3.1使用wxGlade开发WxPython程序
11.3.2使用wxFormBuilder开发WxPython程序
11.3.3使用Boaconstructor开发WxPython程序
11.4小结
第12章WxPython框架初步
12.1WxPython的程序结构
12.1.1WxPython应用程序的组成
12.1.2WxPython窗口的组成
12.1.3WxPython应用程序的运行过程
12.2WxPython中的事件驱动编程
12.2.1事件驱动的编程模型
12.2.2事件的触发
12.2.3事件的绑定和处理
12.3WxPython的常用组件
12.3.1对话框
12.3.2工具栏
12.3.3状态栏
12.4小结
第13章WxPython库中的基本组件
13.1静态文本框
13.2文本框
13.2.1单行文本框
13.2.2多行文本框
13.3按钮控件
13.3.1普通按钮
13.3.2位图按钮
13.4单选框
13.4.1单选框的选择
13.4.2单选框的分组
13.5多选框
13.5.1多选框
13.5.2多选框事件
13.6列表控件
13.6.1列表框
13.6.2下拉列表
13.6.3可编辑的下拉列表
13.7使用Sizers布局组件
13.7.1Sizers布局管理器
13.7.2Grid Sizer布局
13.7.3Flex Grid Sizer布局
13.7.4Grid Bag sizer布局
13.7.5Box Sizer布局
13.8小结
第14章WxPython库中的菜单、窗口与对话框控件
14.1菜单
14.1.1创建菜单
14.1.2菜单的事件
14.1.3多级菜单
14.1.4菜单的快捷键
14.1.5位图菜单
14.1.6上下文菜单
14.2窗口
14.2.1Frame窗口
14.2.2带工具栏和状态栏的Frame窗口
14.2.3MDI窗口
14.2.4MiniFrame窗口
14.3对话框
14.3.1对话框的创建
14.3.2提示对话框
14.3.3文本输入对话框
14.3.4特殊对话框
14.3.5窗口与对话框的交互
14.4小结
第15章WxPython库中的高级控件
15.1表格控件
15.1.1表格控件的创建
15.1.2通过PyGridTable创建表格
15.1.3表格控件的单元格
15.1.4处理单元格的事件
15.2高级列表控件
15.2.1列表控件的创建
15.2.2列表控件的排序
15.2.3带位图的列表控件
15.3树型控件
15.3.1树型控件的创建
15.3.2树型控件的事件
15.3.3树表控件
15.4定时器控件
15.5小结
第16章WxPython库中的高级功能
16.1WxPython下的HTML显示
16.1.1HTML的显示
16.1.2基于HtmlWindow的简单浏览器
16.2WxPython中的XRC
16.2.1使用XRC
16.2.2XRC文件
16.3剪贴板的操作
16.3.1WxPython中的剪贴板对象
16.3.2处理剪贴板对象
16.3.3剪贴板操作实例
16.4小结
第三篇Python的Web开发
第17章Python的HTML应用
17.1HTML介绍
17.1.1HTML的历史
17.1.2SGML、HTML和XHTML三者的关系
17.1.3HTML的标签
17.1.4HTML的框架组成
17.2URL的处理
17.2.1统一资源定位符URL
17.2.2URL的解析
17.2.3URL的拼合
17.2.4URL的分解
17.2.5URL的编码与解码
17.2.6中文的编码与解码
17.2.7查询参数的编码
17.3CGI的使用
17.3.1CGI介绍
17.3.2获取CGI环境信息
17.3.3解析用户的输入
17.4获取HTML资源
17.4.1使用urlopen和urlretrieve获取HTTP资源
17.4.2分析返回资源的相关信息
17.4.3自定义获取资源方式
17.4.4使用urllib2模块获取资源
17.4.5使用httplib模块获取资源
17.5HTML文档的解析
17.5.1使用HTMLParser模块
17.5.2sgmllib的HTML文档处理
17.5.3HTML文档元素的处理
17.5.4使用htmllib处理HTML文档
17.6小结
第18章Python和XML
18.1XML介绍
18.1.1XML的演进历史
18.1.2XML的优点和限制
18.1.3XML技术的Python支持
18.2XML文档概览和验证
18.2.1XML文档的基本概念
18.2.2XML文档的结构良好性验证
18.2.3XML文档的有效性验证
18.3XML文档的结构
18.3.1XML的元素和标签
18.3.2元素的属性
18.3.3XML的文字
18.3.4字符实体
18.3.5CDATA段
18.3.6注释
18.3.7处理指令
18.3.8XML定义
18.4使用SAX处理XML文档
18.4.1SAX介绍
18.4.2SAX处理的组成部分
18.5使用DOM处理XML文档
18.5.1DOM介绍
18.5.2xml.dom模块中的接口操作
18.5.3对XML文档的操作
18.6小结
第19章Python的Web开发——Django框架的应用
19.1常见的Web开发框架
19.1.1Zope
19.1.2TurboGears
19.1.3Django
19.1.4其他的Web开发框架
19.1.5各种开发框架的选择
19.2MVC模式
19.2.1MVC模式介绍
19.2.2MVC模式的优点和缺点
19.2.3Django框架中的MVC
19.3Django开发环境的搭建
19.3.1Django框架的安装
19.3.2数据库的配置
19.4Django框架的应用
19.4.1Web应用的创建
19.4.2Django中的开发服务器
19.4.3创建数据库
19.4.4生成Django应用
19.4.5创建数据模型
19.4.6URL设计
19.4.7创建视图
19.4.8模板系统
19.4.9发布Django项目
19.5Django框架的高级应用
19.5.1管理界面
19.5.2生成数据库数据
19.5.3Session功能
19.5.4国际化
19.6小结
第20章敏捷方法学在Python中的应用——测试驱动开发
20.1测试驱动开发
20.1.1测试驱动开发模式(TDD)
20.1.2TDD的优势
20.1.3TDD的使用步骤
20.2unittest测试框架
20.2.1unittest模块介绍
20.2.2构建测试用例
20.2.3构建测试固件
20.2.4组织多个测试用例
20.2.5构建测试套件
20.2.6重构代码
20.2.7执行测试
20.3使用doctest模块进行测试
20.3.1doctest模块介绍
20.3.2构建可执行文档
20.3.3执行doctest测试
20.4小结
第四篇Python的其他应用
第21章Python中的进程和线程
21.1进程和线程
21.1.1进程和线程的概念
21.1.2Python中对于进程和线程处理的支持
21.2Python下的进程编程
21.2.1进程的运行环境
21.2.2创建进程
21.2.3终止进程
21.3使用subprocess模块管理进程
21.3.1使用Popen类管理进程
21.3.2调用外部系统命令
21.3.3替代其他进程创建函数
21.4进程间的信号机制
21.4.1信号的处理
21.4.2信号的使用规则
21.5多线程概述
21.5.1什么是多线程
21.5.2线程的状态
21.5.3Python中的线程支持
21.6生成和终止线程
21.6.1使用thread模块
21.6.2使用threading.Thread类
21.7管理线程
21.7.1线程状态转移
21.7.2主线程对子线程的控制
21.7.3线程中的局部变量
·ⅩⅦ·
1.8线程之间的同步
21.8.1临界资源和临界区
21.8.2锁机制
21.8.3条件变量
21.8.4信号量
21.8.5同步队列
21.8.6线程同步小结
21.9小结
第22章基于Python的系统管理
22.1增强的交互式环境IPython
22.1.1IPython介绍
22.1.2IPython的安装
22.1.3IPython的启动
22.1.4IPython的环境配置
22.1.5IPython的退出
22.2和IPython的简单交互
22.2.1IPython中的输入与输出
22.2.2输出提示符的区别
22.2.3输出提示符不同的原因
22.2.4IPython中的In和Out
22.3IPython中的magic函数
22.3.1Magic函数的使用和构造
22.3.2目录管理
22.3.3对象信息的收集
22.4IPython适合于系统管理的特点
22.4.1Tab补全
22.4.2历史记录功能
22.4.3执行外部的系统命令和运行脚本文件
22.4.4对象的查看和自省
22.4.5直接编辑代码
22.4.6设置别名和宏
22.5使用Python进行文件管理
22.5.1文件的比较
22.5.2文件的归档
22.5.3文件的压缩
22.6使用Python定时执行任务
22.6.1使用休眠功能
22.6.2使用sched来定时执行任务
22.7小结
·ⅩⅧ·
23章Python和网络编程
23.1网络模型介绍
23.1.1OSI简介
23.1.2TCP/IP简介
23.2Socket应用
23.2.1Socket基础知识
23.2.2Socket的工作方式
23.3服务器端和客户端通信
23.3.1服务器端的构建
23.3.2客户端的构建
23.4异步通信方式
23.4.1使用Fork方式
23.4.2使用线程方式
23.4.3异步IO方式
23.4.4使用asyncore模块
23.5Twisted网络框架
23.5.1认识Twisted框架
23.5.2Twisted框架下服务器端的实现
23.5.3Twisted框架下服务器端的其他处理
23.6小结

24章常见的Python网络应用
24.1使用FTP传输文件
24.1.1FTP的工作原理和Python库的支持
24.1.2FTP的登录和退出
24.1.3FTP的数据传输
24.2使用POP3获取邮件
24.2.1POP3协议介绍
24.2.2poplib模块的使用方法
24.3使用SMTP发送邮件
24.3.1SMTP协议介绍
24.3.2smtplib模块的使用
24.4使用Telnet协议远程登录
24.4.1Telnet协议介绍和Python库的支持
24.4.2telnetlib模块的使用方法
24.5使用SNMP管理网络
24.5.1SNMP协议的组成
24.5.2PySNMP框架介绍及其使用方法
24.6网络分析
24.6.1网络分析概述
24.6.2使用Scapy在网络中抓包分析
24.7小结
第25章图像处理和游戏开发
25.1图像处理的基本概念
25.1.1Python下的图像处理包
25.1.2PIL支持的图像文件格式
25.1.3图像处理中的其他概念
25.2图像的基本处理
25.2.1图像的读写操作
25.2.2获取图像信息
25.2.3图像文件格式的转换
25.2.4图像的裁剪和合成
25.2.5图像的变换
·ⅩⅨ·
25.3图像处理的高级应用
25.3.1图像的通道操作
25.3.2图像的增强处理
25.3.3PIL中的内置滤镜
25.4使用PyGame进行游戏开发
25.4.1Python游戏开发包:PyGame
25.4.2创建基本的Pygame窗口
25.4.3事件系统
25.5小结

26章Python语言的扩展与嵌入
26.1Python语言的扩展
26.1.1Python扩展简介
26.1.2一个C扩展的例子
26.1.3模块方法表和初始化函数
26.1.4编译和测试
26.2Python语言的嵌入
26.2.1Python嵌入简介
26.2.2一个Python嵌入的例子
26.2.3更好的嵌入
26.3小结
第27章Windows下的Python
27.1组件对象模型
·ⅩⅩ·
27.1.1组件对象模型介绍
27.1.2COM结构
27.1.3COM对象的交互
27.2Python对COM技术的支持
27.2.1Python中的Windows扩展:PyWin32
27.2.2客户端COM组件
27.2.3实现COM组件
27.3Windows下的常见Python应用
27.3.1对Word的自动访问
27.3.2对Excel的自动访问
27.3.3对Powerpoint的自动访问
27.3.4对Outlook的自动访问
27.4小结