重复笔记
注:本笔记基于python2.6而编辑,尽可能的偏向3.x的语法html
Python的特点
1.简单
2.易学
3.免费、开源
4.高层语言: 封装内存管理等
5.可移植性: 程序若是避免使用依赖于系统的特性，那么无需修改就能够在任何平台上运行
6.解释性: 直接从源代码运行程序,再也不须要担忧如何编译程序,使得程序更加易于移植。
7.面向对象: 支持面向过程的编程也支持面向对象的编程。
8.可扩展性: 须要保密或者高效的代码，能够用C或C++编写，而后在Python程序中使用它们。
9.可嵌入性: 能够把Python嵌入C/C++程序，从而向你的程序用户提供脚本功能。
10.丰富的库: 包括正则表达式、文档生成、单元测试、线程、数据库、网页浏览器、CGI、FTP、
电子邮件、XML、XML-RPC、HTML、WAV文件、密码系统、GUI(图形用户界面)、Tk和其余与系统有关的操做。
除了标准库之外，还有许多其余高质量的库，如wxPython、Twisted和Python图像库等等。
11.归纳: Python确实是一种十分精彩又强大的语言。它合理地结合了高性能与使得编写程序简单有趣的特点。
12.规范的代码: Python采用强制缩进的方式使得代码具备极佳的可读性。java
Python 下载地址
http://www.python.org/download/python
Python 安装：
windows时，运行安装文件以后，还须要配置环境变量，在环境变量的“Path”后面加上英文的分号及python安装目录
如：“;C:\promg\python2.6”
不配置环境变量的话，无法在命令行直接使用pythonmysql
有两种使用Python运行你的程序的方式
1.使用交互式的带提示符的解释器
直接双击运行“python.exe”，在里面输入内容，如： print 'haha...'
2.使用源文件
在Python的安装目录下，建一个批处理(test.bat)，写入：
@echo off
python.exe test.py
pauselinux
而“test.py”里面的内容是须要执行的程序
Python命令行选项
选项 做用
-c cmd 在命令行直接执行python代码。如python -c 'print "hello world"'。
-d 脚本编译后从解释器产生调试信息。同PYTHONDEBUG=1。
-E 忽略环境变量。
-h 显示python命令行选项帮助信息。
-i 脚本执行后立刻进入交互命令行模式。同PYTHONINSPECT=1。
-O 在执行前对解释器产生的字节码进行优化。同 PYTHONOPTIMIZE=1。
-OO 在执行前对解释器产生的字节码进行优化，并删除优化代码中的嵌入式文档字符串。
-Q arg 除法规则选项，-Qold(default)，-Qwarn，-Qwarnall，-Qnew。
-S 解释器不自动导入site.py模块。
-t 当脚本的tab缩排格式不一致时产生警告。
-u 不缓冲stdin、stdout和stderr，默认是缓冲的。同PYTHONUNBUFFERED=1。
-v 产生每一个模块的信息。若是两个-v选项，则产生更详细的信息。同PYTHONVERBOSE=x。
-V 显示Python的版本信息。
-W arg 出错信息控制。(arg is action:message:category:module:lineno)
-x 忽略源文件的首行。要在多平台上执行脚本时有用。
file 执行file里的代码。
- 从stdin里读取执行代码。程序员
easy_install
这是个很经常使用的python安装工具
能够直接安装ez_setup.py脚本(下载网址： http://peak.telecommunity.com/dist/ez_setup.py):
python ez_setup.pyweb
windows 下的使用：
安装：
下载: http://peak.telecommunity.com/dist/ez_setup.py
执行: python ez_setup.py
使用：
easy_install.exe -U %modal% # %modal% 是模块名
linux 下：
安装：
sudo apt-get install python-setuptools
或者：
wget -q http://peak.telecommunity.com/dist/ez_setup.py
sudo python ez_setup.py
使用：
sudo easy_install 模块名
安装完后，最好确保easy_install所在目录已经被加到PATH环境变量里:
Windows: C:\Python25\Scripts
Linux: /usr/local/bin
不能使用easy_install的特殊状况：
a、安装默认版本的MySQL-python会报错，须要指定版本以下：easy_install "MySQL-python==1.2.2"
b、有些包直接easy_install会失败，须要自行下载安装：
wxpython，pil要下载exe安装程序
robotide由于在pypi上找不到，要下载后再easy_install
经过easy_install安装软件，相关安装信息会保存到easy-install.pth文件里，路径相似以下形式：
Windows：C:\Python25\Lib\site-packages\easy-install.pth
Linux：/usr/local/lib/python25/site-packages/easy-install.pth
若是想删除经过easy_install安装的软件包，好比说：MySQL-python，能够执行命令：
easy_install -m MySQL-python
此操做会从easy-install.pth文件里把MySQL-python的相关信息抹去，剩下的egg文件，你能够手动删除。
版本问题
python3.0版本较以前的有很大变更，并且不向下兼容。
Python 2.6做为一个过渡版本，基本使用了Python 2.x的语法和库，同时考虑了向Python 3.0的迁移。即2.6版本兼容2.x和3.0的语法
Python 2.6保持了对以前版本的全兼容，并且还包含了Python 3.0的新玩意(一些新特性须要经过“from future import”来启用)。
如，在Python2.6要使用3.0的打印,得写上“ from future import print_function”
基于早期Python版本而能正常运行于Python 2.6并没有警告的程序能够经过一个2 to 3的转换工具无缝迁移到Python 3.0。正则表达式
部分函数和语句的改变
最引人注意的改变是print语句没有了，取而代之的是print函数
一样的还有exec语句，已经改成exec()函数。去除了<>，所有改用!=。
在python2.x版本中
#!/usr/bin/env python
# 或者上句写: #!/usr/bin/python
print "Hello, world!"
或者：
import sys
sys.stdout.write("Hello, world\n")算法
在python3.x中
print('Hello world!')
用迭代器来替代列表
一些知名的API将再也不返回列表。
而字典的dict.iterkeys()、dict.itervalues()和dict.iteritems()方法将会移除，而你能够使用.keys()、.values()和.items()，它们会返回更轻量级的、相似于集合的容器对象，而不是返回一个列表来复制键值。
这样作的优势是，能够直接在键和条目上进行集合操做，而不须要再复制一次。
整型数
移除了含糊的除法符号('/')，而只返回浮点数。
在之前的版本中，若是参数是int或者是long的话，就会返回相除后结果的向下取整(floor)，而若是参数是float或者是complex的话，那么就会返回相除后结果的一个恰当的近似。
在2.6版本中能够经过from future import division来启用这项特性。spring
python2 to python3 问题
1.print 语句
2.x 3.x 说明
① print print() # 输出一个空白行
② print 1 print(1) # 输出一个单独的值
③ print 1, 2 print(1, 2) # 输出多个值，以空格分割
④ print 1, 2, print(1, 2, end=' ') # 输出时取消在末尾输出回车符。
⑤ print >>sys.stderr, 1, 2 print(1, 2, file=sys.stderr) # 把输出重定向到一个管道
2.被重命名或者从新组织的模块
1)http
在Python 3里，几个相关的HTTP模块被组合成一个单独的包，即http。
2.x 3.x
① import httplib import http.client # http.client 模块实现了一个底层的库，能够用来请求HTTP资源，解析HTTP响应。
② import Cookie import http.cookies # http.cookies 模块提供一个蟒样的(Pythonic)接口来获取经过HTTP头部(HTTP header)Set-Cookie发送的cookies
③ import cookielib import http.cookiejar # 经常使用的流行的浏览器会把cookies以文件形式存放在磁盘上，http.cookiejar 模块能够操做这些文件。
④ import BaseHTTPServer import http.server # http.server 模块实现了一个基本的HTTP服务器
import SimpleHTTPServer
import CGIHttpServer
2)urllib
Python 2有一些用来分析，编码和获取URL的模块，可是这些模块就像老鼠窝同样相互重叠。在Python 3里，这些模块被重构、组合成了一个单独的包，即urllib。
2.x 3.x
① import urllib import urllib.request, urllib.parse, urllib.error
② import urllib2 import urllib.request, urllib.error
③ import urlparse import urllib.parse
④ import robotparser import urllib.robotparser
⑤ from urllib import FancyURLopener from urllib.request import FancyURLopener
from urllib import urlencode from urllib.parse import urlencode
⑥ from urllib2 import Request from urllib.request import Request
from urllib2 import HTTPError from urllib.error import HTTPError
之前，Python 2里的 urllib 模块有各类各样的函数，包括用来获取数据的 urlopen()，还有用来将URL分割成其组成部分的 splittype(), splithost()和 splituser()函数。
在python3的 urllib 包里，这些函数被组织得更有逻辑性。2to3将会修改这些函数的调用以适应新的命名方案。
在Python 3里，之前的 urllib2 模块被并入了 urllib 包。同时，以 urllib2 里各类你最喜好的东西将会一个不缺地出如今Python 3的 urllib 模块里，好比 build_opener()方法, Request 对象， HTTPBasicAuthHandler 和 friends 。
Python 3里的 urllib.parse 模块包含了原来Python 2里 urlparse 模块全部的解析函数。
urllib.robotparse 模块解析 robots.txt 文件。
处理HTTP重定向和其余状态码的 FancyURLopener 类在Python 3里的 urllib.request 模块里依然有效。 urlencode()函数已经被转移到了 urllib.parse 里。
Request 对象在 urllib.request 里依然有效，可是像HTTPError这样的常量已经被转移到了 urllib.error 里。
3)dbm
全部的DBM克隆(DBM clone)如今在单独的一个包里，即dbm。若是你须要其中某个特定的变体，好比GNU DBM，你能够导入dbm包中合适的模块。
2.x 3.x
① import dbm import dbm.ndbm
② import gdbm import dbm.gnu
③ import dbhash import dbm.bsd
④ import dumbdbm import dbm.dumb
⑤ import anydbm import dbm
import whichdb
4)xmlrpc
XML-RPC是一个经过HTTP协议执行远程RPC调用的轻重级方法。一些XML-RPC客户端和XML-RPC服务端的实现库如今被组合到了独立的包，即xmlrpc。
2.x 3.x
① import xmlrpclib import xmlrpc.client
② import DocXMLRPCServer import xmlrpc.server
import SimpleXMLRPCServer
5)其余模块
2.x 3.x
① try: import io
import cStringIO as StringIO # 在Python 2里，你一般会这样作，首先尝试把cStringIO导入做为StringIO的替代，若是失败了，再导入StringIO。
except ImportError: # 不要在Python 3里这样作；io模块会帮你处理好这件事情。它会找出可用的最快实现方法，而后自动使用它。
import StringIO
② try: import pickle
import cPickle as pickle # 在Python 2里，导入最快的pickle实现也与上边 io 类似。在Python 3里，pickle模块会自动为你处理，因此不要再这样作。
except ImportError:
import pickle
③ import __builtin__ import builtins
④ import copy_reg import copyreg # copyreg模块为用C语言定义的用户自定义类型添加了pickle模块的支持。
⑤ import Queue import queue # queue模块实现一个生产者消费者队列(multi-producer, multi-consumer queue)。
⑥ import SocketServer import socketserver # socketserver模块为实现各类socket server提供了通用基础类。
⑦ import ConfigParser import configparser # configparser模块用来解析INI-style配置文件。
⑧ import repr import reprlib # reprlib 模块从新实现了内置函数 repr()，并添加了对字符串表示被截断前长度的控制。
⑨ import commands import subprocess # subprocess 模块容许你建立子进程，链接到他们的管道，而后获取他们的返回值。
builtins模块包含了在整个Python语言里都会使用的全局函数，类和常量。从新定义builtins模块里的某个函数意味着在每处都重定义了这个全局函数。这听起来很强大，可是同时也是很可怕的。
注释
“#”后面的内容
数据类型
共4种: 整数、长整数、浮点数和复数。
1.整数,如:2
2.长整数,如:22L # 长整数不过是大一些的整数。Python 3已经取消这种类型,被int取代了。
3.浮点数,如:3.23 和 52.3E-4 # E标记表示10的幂。在这里，52.3E-4表示52.3 * 10-4。
4.复数,如:(-5+4j) 和 (2.3-4.6j)
在Python 2和Python 3的变化:
1.八进制(octal)数:
Python 2: x = 0755 # 0开头
Python 3: x = 0o755 # 0o开头
2.long 类型
Python 2有为非浮点数准备的 int 和 long 类型。 int 类型的最大值不能超过 sys.maxint,并且这个最大值是平台相关的。
整数能够经过在数字的末尾附上一个L来定义长整型，显然，它比 int 类型表示的数字范围更大。
Python 3里，只有一种整数类型 int,大多数状况下，它很像Python 2里的长整型。
因为已经不存在两种类型的整数，因此就没有必要使用特殊的语法去区别他们。
因为 long 类型在Python 3的取消,引发如下改变
Python 2 Python 3 说明
① x = 1000000000000L x = 1000000000000 # 十进制的普通整数
② x = 0xFFFFFFFFFFFFL x = 0xFFFFFFFFFFFF # 十六进制的普通整数
③ long(x) int(x) # long()函数没有了。能够使用int()函数强制转换一个变量到整型。
④ type(x) is long type(x) is int # 检查一个变量是不是整型
⑤ isinstance(x, long) isinstance(x, int) # 也能够使用 isinstance()函数来检查数据类型
3.sys.maxint(sys.maxsize)
因为长整型和整型被整合在一块儿了, sys.maxint常量再也不精确。
由于这个值对于检测特定平台的能力仍是有用处的，因此它被Python 3保留，而且重命名为 sys.maxsize。
Python 2 Python 3
① from sys import maxint from sys import maxsize # maxint变成了maxsize。
② a_function(sys.maxint) a_function(sys.maxsize) # 全部的sys.maxint都变成了sys.maxsize。
int 是 types.IntType 的代名词
print(id(int)) # 打印如：505210872
import types;print(id(types.IntType)) # 打印如：505210872
标识符的命名
变量是标识符的例子。 标识符 是用来标识 某样东西 的名字。在命名标识符的时候，你要遵循这些规则：
1.标识符的第一个字符必须是字母表中的字母(大写或小写)或者一个下划线(‘’)。
2.标识符名称的其余部分能够由字母(大写或小写)、下划线(‘’)或数字(0-9)组成。
3.标识符名称是对大小写敏感的。例如，myname和myName不是一个标识符。
有效 标识符名称的例子有i、__my_name、name_23和a1b2_c3。
无效 标识符名称的例子有2things、this is spaced out和my-name。
逻辑行与物理行
物理行是在编写程序时文本的一行。逻辑行是程序的一个语句。
Python假定每一个 物理行 对应一个 逻辑行 。 他但愿每行都只使用一个语句，这样使得代码更加易读。
- 若是你想要在一个物理行中使用多于一个逻辑行，那么你须要使用分号(;)来特别地标明这种用法。
分号表示一个逻辑行/语句的结束。
如: i = 5; print i; # 强烈建议你坚持在每一个物理行只写一句逻辑行。 让程序见不到分号，而更容易阅读。 - 明确的行链接
在多个物理行中写一个逻辑行,行结尾用反斜杠标明
如: s = 'This is a string. This continues the string.'
# 上面这两行是一个逻辑行,打印是: This is a string. This continues the string.
print i
# 上面这两行也是一个逻辑行, 等同于: print i - 暗示的行链接
在多个物理行中写一个逻辑行,行结尾不须要使用反斜杠标明。
这种状况出如今逻辑行中使用了圆括号、方括号或波形括号的时候。 - 缩进
行首的空白是重要的。在逻辑行首的空白(空格和tab符)用来决定逻辑行的缩进层次，从而用来决定语句的分组。
同一层次的语句必须有相同的缩进。每一组这样的语句称为一个块。
不要混合使用tab符和空格来缩进，由于这在跨越不一样的平台的时候，没法正常工做。强烈建议只使用一种风格来缩进。
语法规则
1.缩进规则
一个模块的界限，彻底是由每行的首字符在这一行的位置来决定的(而不是花括号{})。这一点曾经引发过争议。
不过不能否认的是，经过强制程序员们缩进，Python确实使得程序更加清晰和美观。
在逻辑行首的空白(空格和tab)用来决定逻辑行的缩进层次，从而用来决定语句的分组。错误的缩进会引起错误。
注意: 强制缩进的问题,最多见的状况是tab符和空格的混用会致使错误，而这是用肉眼没法分别的。
2.变量没有类型
使用变量时只须要给它们赋值。 不须要声明或定义数据类型。
3.单语句块
若是你的语句块只包含一句语句，那么你能够在条件语句或循环语句的同一行指明它。如: if 1!=2: print('Yes')
强烈建议不要使用这种缩略方法。这会破坏Python清晰美观的代码风格,违背设计者的初衷。
若是是在Python解释器输入,它的把提示符会改变为...以表示语句尚未结束。这时按回车键用来确认语句已经完整了。而后，Python完成整个语句的执行，而且返回原来的提示符来等待下一句输入。
运算符与表达式:
运算符
运算符 名称 说明
+ 加 两个对象相加,也能够字符串拼接
- 减 获得负数或是一个数减去另外一个数
* 乘 两个数相乘 或是返回一个被重复若干次的字符串
** 幂 返回x的y次幂
/ 除 x除以y
// 取整除 返回商的整数部分
% 取模 返回除法的余数 # 8%3获得2。 -25.5%2.25获得1.5
<< 左移 把一个数的二进制向左移必定数目 # 2 << 2获得8
>> 右移 把一个数的二进制向右移必定数目 # 11 >> 1获得5
& 按位与 数的按位与 # 5 & 3获得1。
| 按位或 数的按位或 # 5 | 3获得7。
^ 按位异或 数的按位异或 # 5 ^ 3获得6
~ 按位翻转 x的按位翻转是-(x+1) # ~5获得6。
< 小于 返回x是否小于y
> 大于 返回x是否大于y
<= 小于等于 返回x是否小于等于y
>= 大于等于 返回x是否大于等于y
== 等于 比较对象是否相等
!= 不等于 比较两个对象是否不相等(python3删除了“<>”符号)
not 布尔“非” 若是x为True，返回False。若是x为False，它返回True。 # x = True; not x返回False。
and 布尔“与” 若是x为False，x and y返回False，不然它返回y的计算值。 # x=False; y=True; x and y返回False。
or 布尔“或” 若是x是True，它返回True，不然它返回y的计算值。# x = True; y = False; x or y返回True。
in, not in 成员测试 (由类里面的 contains 函数指定返回值)
is, is not 同性测试 (两值的 is 运算是判断引用,与“==”的比较有所不一样)
说明:
1.加号“+”:有数学相加，也有字符串拼接做用,注意:不能字符串和数字相加。如: 3 + 5获得8; 'a' + 'b'获得'ab'。
2.乘号“”:两个数相乘，也能够把字符串重复拼接若干次,如: 2 3获得6; 'la' * 3获得'lalala'。
3.幂“” :这种写法,其余语言好像没见到过,如: 3 4获得81(即3 * 3 * 3 * 3)
4.除号“/”:整数的除法获得整数结果,浮点数的获得浮点数,如:4/3获得1(返回相除后结果的向下取整(floor)); 4.0/3或4/3.0获得1.333...
注意:Python 3.0开始,移除了含糊的除法符号('/')，而只返回浮点数。如:4/3获得1.333...
5.取整除“//”:将两数相除,而后对结果取整,如: 7 // 3获得2; 4 // 3.0获得1.0
6.比较运算符:全部比较运算符返回1表示真，返回0表示假。这分别与特殊的变量 True 和 False 等价。注意大小写。
若是两个操做数都是数字，它们首先被转换为一个共同的类型(如double)。不然，它老是返回 False 。
< 3返回0(即False); 而3 < 5返回1(即True)。比较能够被任意链接: 3 < 5 < 7返回True。
大于、小于、小于等于、大于等于时:数字跟数字能够比较，字符串跟字符串能够比较，但数字不能跟字符串比较。
等于、不等于时: 数字跟数字能够比较，字符串跟字符串能够比较，数字跟字符串比较返回 False (表示不相等)
等于: Python 使用“==”来作比较，用“=”来赋值。但不容许内嵌的赋值，因此不会出现你本觉得在作比较而意外的写成赋值的状况。
7.布尔运算: and 和 or 都是短路运算,没有非短路运算的运算符。
短路运算:当前面一个表达式能够决定结果时，后面的语句不用再判断。非短路运算时，还照样判断后面的。
注意：在 and or 运算中，空字符串'',数字0,空列表[],空字典{},空元组(), None,在逻辑运算中都被看成假来处理。
8.and 和 or 的特殊用法:
因为语言的松散性,用 and 和 or 在赋值语句时有判断做用。
1) or 用在赋值语句里，返回第一个逻辑为真的值, 没有逻辑为真的返回最后一个。(以下这写法比较经常使用)
如:ss = False or None or 0 or '' or -1 or 'sss'; print(ss) # 打印:-1 (-1做if判断时返回 True)
设定预设值的写法: edittype = edittype or "text"; # 若是 edittype 以前有值,则取以前的值; 以前为空,则取默认值
2) and 用在赋值语句里，与 or 恰好相反，返回第一个逻辑为假的值, 没有逻辑为假的返回最后一个。
如: a = 0 and 1; print(a) # 打印: 0
a = 2 and 1; print(a) # 打印: 1
应用： valid = True; valid = valid and checkLength(name, 16); valid = valid and checkLength(name, 16); # 若是前面的验证不经过，则后面的再也不验证
简便的记忆是: and 偏 False, or 偏 True
要理解 and 和 or 的这种写法，得考虑到它的短路运算特性。它是在作逻辑判断，但返回的是前或后一个的值，而不是返回 True 或 False 。
9.三目运算符：
Python 没有三目运算符“cond ? a : b”,但能够使用 and 和 or 来代替(需理解前面的 and 和 or 的特殊用法)，以下：
1) c = cond and a or b # 这多数状况下是正确的，但当 a 是空字符串''、数字0等逻辑运算为假的状况下会出错。
2) c = (cond and [a] or [b])[0] # 即便 a或者b为一个逻辑假的值，将他放入集合中后，就为真了，也就是[False] [None]都不为假。
3) c = (b, a)[cond and 1 or 0] # 注意 a和b的位置是颠倒的,将表达式结果转成1和0来做为元组下标而选择结果。
4) c = a if cond else b # 使用 if else 写条件(python特有的写法,建议使用,前3种写法难理解也容易出错)
10.自增,自减:
Python 没有“++”和“--”两个语法,自增自减时只能写: i = i + 1 或者 i += 1, 不能用 i++
这在必定程度上避免出错，由于新手常常搞错“++”放前面仍是放后面; 但这也致使 for 循环的写法与其它语言很不一样
11.switch/case 语句
Python如今不支持这语句，但能够用 range(N) 生成一个 列表
12.一次性的多比较
“ if (0 < n < 4000) ”这种写法在python是容许的，它等价于“ if ((0 < n) and (n < 4000)) ”但前者更适合阅读。
运算符优先级
下面这个表给出Python的运算符优先级，从最低的优先级(最松散地结合)到最高的优先级(最紧密地结合)。
在一个表达式中，Python会首先计算下表中较下面的运算符，而后在计算列在下表上部的运算符。
在下表中列在同一行的运算符具备 相同优先级 。例如，+和-有相同的优先级。
建议使用圆括号来分组运算符和操做数，以便可以明确地指出运算的前后顺序，使程序尽量地易读。例如，2 + (3 * 4)显然比2 + 3 * 4清晰。
运算符 描述
lambda Lambda表达式
or 布尔“或”
and 布尔“与”
not x 布尔“非”
in，not in 成员测试
is，is not 同一性测试
<，<=，>，>=，!=，== 比较
| 按位或
^ 按位异或
& 按位与
<<，>> 移位
+，- 加法与减法
*，/，% 乘法、除法与取余
+x，-x 正负号
~x 按位翻转
** 指数
x.attribute 属性参考
x[index] 下标
x[index:index] 寻址段
f(arguments...) 函数调用
(experession,...) 绑定或元组显示
[expression,...] 列表显示
{key:datum,...} 字典显示
'expression,...' 字符串转换
计算顺序
默认地，运算符优先级表决定了哪一个运算符在别的运算符以前计算。然而，若是要改变它们的计算顺序，得使用圆括号。
例如，你想要在一个表达式中让加法在乘法以前计算，那么你就得写成相似(2 + 3) * 4的样子。
结合规律
运算符一般由左向右结合，即具备相同优先级的运算符按照从左向右的顺序计算。例如，2 + 3 + 4被计算成(2 + 3) + 4。
一些如赋值运算符那样的运算符是由右向左结合的，即a = b + c被处理为a = (b + c)。
对象
Python 将 "一切皆对象" 贯彻得很是完全，不区分什么 "值类型" 和 "引用类型"。所谓变量，实质就是一个通用类型指针 (PyObject*)，它仅仅负责指路，至于目标是谁，一律无论。
Python Object 对象的自身结构了。任何对象，就算一个最简单的整数，它的头部都会拥有 2 个特殊的附加信息，分别是："引用计数" 和 "类型 (type) 指针" 。前者指示 GC 什么时候回收，然后者标明了对象的身份，如此咱们就能够在运行期动态执行对象成员调用。
连同附加头，一个 "普通" 的整数起码得 12 字节： a = 8; import sys; print(sys.getsizeof(a)) # 打印： 12 (python3.2中，打印的是14) print(sys.getsizeof(None)) # 打印： 8
字符串
1.使用单引号“'”引发来: 'Quote me on this'
2.使用双引号“"”引发来: "What's your name?"
3.使用三引号('''或"""): 能够指示一个多行的字符串。你能够在三引号中自由的使用单引号和双引号。 /'''
如:
"""This is a multi-line string. This is the first line.
"What's your name?," I asked.
He said "Bond, James Bond."
"""
4.转义符“”
\ 指示反斜杠自己
' 指示单引号
" 指示双引号
注意: 行末的单独一个反斜杠表示字符串在下一行继续，而不是开始一个新的行。
5.天然字符串
天然字符串经过给字符串加上前缀r或R来指定，取消转义符的功能。例如: r"Newlines are indicated by \n"。
三引号的字符串也能够一样用法，如：R'''Newlines are indicated by \n'''
6.Unicode字符串
Python容许你处理Unicode文本(超过拉丁文字范围的)——只须要在字符串前加上前缀u或U。
例如，u"This is a Unicode string.哈哈.."。(Python3.x以后不须要这样了,能够直接写中文;而这样写会报错)
Python 3.0开始对unicode全面支持，全部的文本(str)都是Unicode的；并引入了一个叫作bytes的新类型来处理字节序列。而编码过的Unicode会以二进制的数据来表示。
由于在2.x的世界里，大量的bug都是由于已编码的文本和未编码的文本混杂在一块儿而产生的。
7.按字面意义级连字符串
若是你把两个字符串按字面意义相邻放着，他们会被Python自动级连。
例如，"What's" ' your name?'会被自动转为"What's your name?"。
便是说，两个字符串放在一块儿，会有字符拼接的效果。加号“+”也有字符拼接的效果。
8.字符串拼接
能够使用“str1.__add__(str2)”或者“str1 + str2”或者直接两个字符串放一块儿,来拼接字符串
但字符串与其它类型拼接时，得先把其它类型转成字符串类型，不然会出错。如“str1 + 2”就会出错，须要“str1 + str(2)”
9.格式化
使用“%控制符”能够格式化字符串,很是方便。如: str1 = "Swaroop's age is %d, weight is %f" % (5, 65.5)
“%(name)控制符”可按名称传参数(不写名称是按位置传参数)，如: str = "%(row)d Rows is %(value)s" % { 'value': 'kkkk', 'row': 22 }
格式化的符号用法参考下面的“字符串格式化控制表”
另外，string.format()函数也能够格式化字符串
例如：'subtracting {0}, adding {1}'.format(1, 'haha') # 参数讲对应到“{number}”的位置上
10.字符串序列(索引和切片)
字符串能够使用下标来获取字符串中某个项目，以及截取字符串。详情参考“序列”
用法如: name = 'swaroop'; name[1]; name[1:3]; name[1:-1]
11.str(anything)函数和 unicode(anything)函数
Python 2有两个全局函数能够把对象强制转换成字符串:unicode()把对象转换成Unicode字符串，还有 str()把对象转换为非Unicode字符串。
Python 3只有一种字符串类型，Unicode字符串，因此 str()函数便可完成全部的功能。(unicode()函数在Python 3里再也不存在了。)
另外:
没有专门的char数据类型，确实没有须要有这个类型。
单引号和双引号字符串是彻底相同的——它们没有在任何方面有不一样。
正则表达式: 必定要用天然字符串处理正则表达式。不然会须要使用不少的反斜杠。
使用 help(str) 可查看字符串对象定义的全部方法及属性。
因为百分号有特殊做用，因此字符串里面要用百分号的话须要使用“%%”，如："select * from my_table where name like '%%测试%%'"
字符串格式化控制：(未参考帮助文档，只是我的猜想)
转义符 (Escape Sequence)：
\ddd 1到3位8进制数指定Unicode字符输出(如：“\127”显示“W”)
\uxxxx 1到4位16进制数指定Unicode字符输出(Python3.x开始支持此写法,如: \u54C8 显示“哈”字)
\xhh 16进制数指定Unicode字符输出(如：“\xe5\x93\x88”显示“哈”)
\ (单独的一个斜杠也显示斜杠,即不后接有转移做用的字符时，做为斜杠使用)
' '
" "
\a 字符：0x07 响铃(ASCII控制字符)
\b 字符：0x08 退格(光标向左走一格)(ASCII控制字符)
\f 字符：0x0c Formfeed(FF)(走纸转页,换页)(ASCII控制字符)
\n 字符：0x0a 换行(ASCII控制字符)
\N{name} Unicode字符 只能针对Unicode
\r 字符：0x0d 回车
\t 字符：0x09 跳格(tab符号),水平制表符
\v 字符：0x0b 垂直制表符
%% %
%d 输出10进制整数，只能是数字类型，输出字符串类型会出错；浮点类型的数字将被取整(直接删除小数部分)。
%f,%F 以10进制输出浮点数，只能是数字类型，输出字符串类型会出错。
%e,%E 以科学计数法输出10进制的浮点数，大小写的“e”反应在显示时科学计数法的“e/E”上，只能是数字类型。
%a Python3.0开始支持此写法，原样输出结果，字符串类型会加上单引号引发来。
%o (字母o)以8进制整数方式输出，只能是数字类型；浮点类型的数字将被取整(直接删除小数部分)。
%x,%X 将数字以16进制方式输出，只能是数字类型；浮点类型的数字将被取整(直接删除小数部分)。
%s 将字符串格式化输出(可输出任何类型)
%c 以字符方式输出，提供的类型必须是 char 或 int 。
注：布尔类型的 True 或 False,用数字类型输出是 1或0,字符串输出是 True 或 False。
字符串转换成数字
float(str) 转换成浮点数,如, float("1e-1") 结果：0.1
int(str) 转换成整数,如, int("12") 结果：12
int(str,base) 转换成base进制的整数,如, int("11",2) 转换成2进制的整数,结果：3
long(str) 转换成长整数,Python3取消此语法,如, long("12L") 结果：12L
long(str,base) 转换成base进制的长整数,Python3取消此语法,如, long("11L",2) 结果：3L
字符串用例
name = 'Swaroop' # This is a string object
# 检查字符串的开头部分
if name.startswith('Swa'): # 相似函数如 endswith()
print('Yes, the string starts with "Swa"')
# 检查是否包含有此内容
if 'a' in name:
print('Yes, it contains the string "a"')
# 找出给定字符串的位置,找不到则返回-1
if name.find('war') != -1:
print('Yes, it contains the string "war"', 's')
# join()函数把列表拼接起来
delimiter = '; '
mylist = ['Brazil', 'Russia', 'India', 'China']
print(delimiter.join(mylist)) # 打印: Brazil; Russia; India; China
# 大小写转换
print("THIS IS TEST".lower()) # 转换成小写,打印：this is test
print("this is test".upper()) # 转换成大写,打印：THIS IS TEST
print("This Is Test".swapcase()) # 大小写互换,打印：tHIS iS tEST
print(" This Is Test ".strip()) # 去掉先后空格,打印：This Is Test
# 经常使用 string 函数
replace(string,old,new[,maxsplit])
字符串的替换函数，把字符串中的old替换成new。默认是把string中全部的old值替换成new值，若是给出maxsplit值，还可控制替换的个数，若是maxsplit为1，则只替换第一个old值。
如： a="11223344";print(string.replace(a,"1","one")) # 打印： oneone2223344
print(string.replace(a,"1","one",1)) # 打印： one12223344
b = "dfsdf dfsdfsd dfsdf ";print(a.replace(' ', '')) # 打印: dfsdfdfsdfsddfsdf
capitalize(string)
该函数可把字符串的首个字符替换成大字。
如： import string; print(string.capitalize("python")) # 打印： Python
split(string,sep=None,maxsplit=-1)
从string字符串中返回一个列表，以sep的值为分界符。
如： import string; ip="192.168.3.3"; print(string.split(ip,'.')) # 打印： ['192', '168', '3', '3']
控制台输入
使用 raw_input()函数 或者 input()函数 可以很方便的控从制台读入数据，获得的是字符串。
Python2.x时,raw_input()和 input()的区别:
当输入为纯数字时:input()返回的是数值类型，如:int,float; raw_input()返回的是字符串类型
input()会计算在字符串中的数字表达式，而 raw_input()不会。如输入“57+3”: input()获得整数60,raw_input()获得字符串'57+3'
注:Python3.0将 raw_input()函数去除了,而用 input() 取代它的功能。另外,input()获取的字符串会包括结尾的换行符。
例:(此处是Python2.6的写法，3.x时应该把 raw_input() 改为 input())
1.输入字符串
nID = raw_input("Input your id plz:\n"); print('your id is %s' % (nID))
2.输入整数
nAge = int(raw_input("input your age plz:\n")); print('your age is %d\n' % nAge)
3.输入浮点型
fWeight = float(raw_input("input your weight:\n")); print('your weight is %f' % fWeight)
4.输入16进制数据
nHex = int(raw_input('input hex value(like 0x20):\n'),16); print('nHex = %x,nOct = %d\n' %(nHex,nHex))
5.输入8进制数据
nOct = int(raw_input('input oct value(like 020):\n'),8); print('nOct = %o,nDec = %d\n' % (nOct,nOct))
注:打印字符串时，“%”做为特殊符号，两个百分号才能打印出一个百分号
Python 2 与 Python 3 的比较
Python 2 Python 3
① raw_input() input() # 最简单的形式，raw_input()被替换成input()。
② raw_input('prompt') input('prompt') # 能够指定一个提示符做为参数
③ input() eval(input()) # 若是想要请求用户输入一个Python表达式，计算结果
控制流:
if 语句
写法: if ... elif ... else ... # if后面不用圆括号
注:在Python中没有switch语句。你能够使用 if..elif..else 语句来完成一样的工做(在某些场合，使用字典会更加快捷。)
在C/C++里面能够使用 else if ,但这里不行，得写成: else :\n\t if,故此增长关键字 elif
例:
number = 23
# int是一个类，不过这里它只是把一个字符串转换为一个整数(假设这个字符串含有一个有效的整数文本信息)。
guess = int(raw_input('Enter an integer : '))
if guess == number:
print('Congratulations, you guessed it.')
elif guess < number:
print('No, it is a little higher than that') # Another block
else:
print('No, it is a little lower than that')
while 语句
只要条件为真，while语句容许你重复执行一块语句。
注:while语句有一个可选的else从句。else块事实上是多余的，由于能够把其中的语句跟在while语句里面。
例:
number = 23
running = True
while running:
guess = int(raw_input('Enter an integer : '))
if guess == number:
print('Congratulations, you guessed it.')
running = False # this causes the while loop to stop
elif guess < number:
print('No, it is a little higher than that')
else:
print('No, it is a little lower than that')
else:
# Do anything else you want to do here
print('The while loop is over.')
for 循环
for..in 是另一个循环语句，它在一序列的对象上 递归 即逐一使用队列中的每一个项目。
else 部分是可选的。若是包含 else,它老是在 for 循环结束后执行一次，除非遇到 break 语句。
例:
for i in range(1, 5):
print(i)
else:
print('The for loop is over')
# 打印结果: 1 至 4 以及 else 的内容
# range(1,5)给出序列[1, 2, 3, 4]。range默认步长为1,第三个参数是步长。如，range(1,5,2)给出[1,3]。
# 记住，range包含第一个数,但不包含第二个数。
注:
Python的 for 循环从根本上不一样于C/C++的 for 循环。相似 foreach 循环。
在C/C++中，若是你想要写 for (int i = 0; i < 5; i++)，那么用Python，你写成 for i in range(0,5)。
# 范例：九九乘法表
# 因为Python2 与Python3的 print 语法不相同，改用string来打印，保证两个版本的输出结果相同。
str = ''
for i in range(1,10):
for j in range(1, i+1):
str += ('%d * %d = %d \t' % (j, i, i*j))
str += '\n'
print(str)
break 语句
break 语句是用来 终止 循环语句的，即哪怕循环条件没有称为 False 或序列尚未被彻底递归，也中止执行循环语句。
一个重要的注释是，若是你从 for 或 while 循环中 终止 ，任何对应的循环 else 块将不执行。
continue 语句
continue 语句被用来告诉Python跳过当前循环块中的剩余语句，而后 继续 进行下一轮循环。
break 语句 和 continue 语句 对于 while 循环 和 for 循环 都有效。
例(2.x写法):
while True:
s = raw_input('Enter something : ')
if s == 'quit':
break
if len(s) < 3:
print 'Input is not of sufficient length'
continue
# Do other kinds of processing here...
print 'Length of the string is', len(s)
例(3.x写法):
while True:
s = input('Enter something : ') # 3.x用input()代替raw_input(),且会获取结尾输入的换行符
s = s[:-1] # 去掉结尾的换行符
if s == 'quit':
break
if len(s) < 3:
print('Input is not of sufficient length')
continue
# Do other kinds of processing here...
print('Length of the string is', len(s))
函数:
定义函数
函数经过def关键字定义。
def关键字后跟一个函数的 标识符 名称，而后跟一对圆括号。圆括号之中能够包括一些变量名，该行以冒号结尾。
接下来是一块语句，它们是函数体。
例:
def sayHello():
print('Hello World!') # block belonging to the function
sayHello() # call the function
函数形参
函数中的参数名称为 形参 而你提供给函数调用的值称为 实参 。
局部变量
当你在函数定义内声明变量的时候，它们与函数外具备相同名称的其余变量没有任何关系，即变量名称对于函数来讲是 局部 的。
这称为变量的 做用域 。全部变量的做用域是它们被定义的块，从它们的名称被定义的那点开始。
例:
x = 50
def func(x):
print('x is', x)
x = 2
print('Changed local x to', x) # 打印: 2
func(x)
print('x is still', x) # 打印: 50, 值没有变
global 语句
若是要为一个定义在函数外的变量赋值，那么你就得告诉Python这个变量名不是局部的，而是 全局 的。使用global语句完成这一功能。
没有global语句，是不可能为定义在函数外的变量赋值的。
你能够使用定义在函数外的变量的值(假设在函数内没有同名的变量)。然而，应避免这样作，由于这下降程序的可读性,不清楚变量在哪里定义的。
使用global语句能够清楚地代表变量是在外面的块定义的。
注:能够使用同一个global语句指定多个全局变量。例如 global x, y, z。
例:
def func():
global x
print('x is', x)
x = 2
print('Changed local x to', x) # 打印: 2
x = 50
func()
print('Value of x is', x) # 打印: 2, 值被改变了
默认参数值
若是但愿一些参数是 可选 的，这些参数可以使用默认值。
能够在函数定义的形参名后加上赋值运算符(=)和默认值，从而给形参指定默认参数值。
注意，默认参数值应该是一个参数。
例:
def say(message, times = 2):
print(message * times)
say('Hello ') # 打印:Hello Hello
say('World ', 5) # 打印:World World World World World
重要:
只有在形参表末尾的那些参数能够有默认参数值，即不能在声明函数形参的时候，先声明有默认值的形参然后声明没有默认值的形参。
这是由于赋给形参的值是根据位置而赋值的。例如，def func(a, b=5)是有效的，可是def func(a=5, b)是 无效 的。
关键参数
若是某个函数有许多参数，而你只想指定其中的一部分，那么能够经过命名来为这些参数赋值
——这被称做 关键参数 ——使用名字(关键字)而不是位置来给函数指定实参。
这样作有两个优点:
1、因为咱们没必要担忧参数的顺序，使用函数变得更加简单了。
2、假设其余参数都有默认值，咱们能够只给咱们想要的那些参数赋值。
例:
def func(a, b=5, c=10):
print('a is', a, 'and b is', b, 'and c is', c)
func(3, 7) # 参数a获得值3，参数b获得值7，而参数c使用默认值10。
func(25, c=24) # 根据实参的位置,变量a获得值25。根据命名，即关键参数，参数c获得值24。变量b根据默认值，为5。
func(c=50, a=100) # 使用关键参数来彻底指定参数值。a获得值100,c获得值50。变量b根据默认值，为5。
return 语句
return语句用来从一个函数 返回 即跳出函数。咱们也可选从函数 返回一个值 。
例:
def maximum(x, y):
if x > y:
return x
else:
return y
print(maximum(2, 3)) # 打印 3
None
None 是Python中表示没有任何东西的特殊类型(至关于java的 null)。例如，若是一个变量的值为None，能够表示它没有值。
注意:函数没有返回值的,等价于最后返回return None。经过运行print someFunction()，你能够明白这一点。
例:
def someFunction():
# pass语句在Python中表示一个空的语句块。它后面的代码会照常运行。
pass
print(someFunction())
DocStrings
DocStrings:文档字符串。它是一个重要的工具，帮助你的程序文档更加简单易懂，应该尽可能使用它。甚至能够在程序运行的时候，从函数恢复文档字符串！
在函数的第一个逻辑行的字符串是这个函数的 文档字符串 。注意，DocStrings也适用于模块和类。
文档字符串的惯例是一个多行字符串，它的首行以大写字母开始，句号结尾。第二行是空行，从第三行开始是详细的描述。 强烈建议遵循这个惯例。
例:
def printMax(x, y):
'''Prints the maximum of two numbers.
The two values must be integers.'''
x = int(x) # convert to integers, if possible
y = int(y)
if x > y:
print(x, 'is maximum')
else:
print(y, 'is maximum')
printMax(3, 5) # 打印: 5 is maximum
print(printMax.__doc__) # 打印: Prints the maximum ... must be integers.
注:
使用__doc__(注意是两个下划线)调用printMax函数的文档字符串属性。请记住Python把 每同样东西 都做为对象，包括这个函数。
Python中help()函数便是使用DocStings的了,它只是抓取函数的__doc__属性，而后整洁地展现给你。能够对上面的函数尝试一下: help(printMax)。记住按q退出help。
自动化工具也能够以一样的方式从你的程序中提取文档。所以强烈建议你对你所写的任何正式函数编写文档字符串。
函数属性 func_*
在Python 2里，函数的里的代码能够访问到函数自己的特殊属性。在Python 3里，为了一致性，这些特殊属性被从新命名了。
Python 2 与 Python 3 的比较
Python 2 Python 3 说明
① a_function.func_name a_function.__name__ # 包含了函数的名字。
② a_function.func_doc a_function.__doc__ # 包含了在函数源代码里定义的文档字符串(docstring)。
③ a_function.func_defaults a_function.__defaults__ # 是一个保存参数默认值的元组。
④ a_function.func_dict a_function.__dict__ # 一个支持任意函数属性的名字空间。
⑤ a_function.func_closure a_function.__closure__ # 一个由cell对象组成的元组，包含了函数对自由变量(free variable)的绑定。
⑥ a_function.func_globals a_function.__globals__ # 一个对模块全局名字空间的引用，函数自己在这个名字空间里被定义。
⑦ a_function.func_code a_function.__code__ # 一个代码对象，表示编译后的函数体。
模块:
若是要在其余程序中重用不少函数，那么你该使用模块。
模块基本上就是一个包含了全部你定义的函数和变量的文件。
为了在其余程序中重用模块，模块的文件名必须以.py为扩展名。
sys模块(标准库模块)
sys模块包含了与Python解释器和它的环境有关的函数。
例:
import sys # 输入 sys模块。基本上，这句语句告诉Python，咱们想要使用这个模块。
print('The command line arguments are:')
# 打印调用文件的命令行参数
for i in sys.argv:
print(i)
print('\nThe PYTHONPATH is', sys.path)
输出:
$ python using_sys.py we are arguments
The command line arguments are:
using_sys.py
we
are
arguments
The PYTHONPATH is ['/home/swaroop/byte/code', '/usr/lib/python23.zip',
'/usr/lib/python2.3', '/usr/lib/python2.3/plat-linux2',
'/usr/lib/python2.3/lib-tk', '/usr/lib/python2.3/lib-dynload',
'/usr/lib/python2.3/site-packages', '/usr/lib/python2.3/site-packages/gtk-2.0']
注:
执行 import sys 语句的时候，它在 sys.path 变量中所列目录中寻找 sys.py 模块。
若是找到了这个文件，这个模块的主块中的语句将被运行，而后这个模块将可以被你使用。
注意，初始化过程仅在咱们 第一次 输入模块的时候进行。另外，“sys”是“system”的缩写。
脚本的名称老是sys.argv列表的第一个参数。因此，在这里，'using_sys.py'是sys.argv[0]、'we'是sys.argv[1]。
sys.path包含输入模块的目录名列表。
能够观察到sys.path的第一个字符串是空的——这个空的字符串表示当前目录也是sys.path的一部分，这与PYTHONPATH环境变量是相同的。
这意味着你能够直接输入位于当前目录的模块。不然，你得把你的模块放在sys.path所列的目录之一。
另外:
sys.exit() # 程序结束
sys.stdin、 sys.stdout 和 sys.stderr 分别对应你的程序的标准输入、标准输出和标准错误流。
字节编译的.pyc文件
输入一个模块相对来讲是一个比较费时的事情，因此Python作了一些技巧，以便使输入模块更加快一些。
一种方法是建立 字节编译的文件，这些文件以.pyc做为扩展名。另外，这些字节编译的文件也是与平台无关的。
当你在下次从别的程序输入这个模块的时候，.pyc文件是十分有用的——它会快得多，由于一部分输入模块所需的处理已经完成了。
from ... import 语句
若是你想要直接输入 argv 变量到你的程序中(避免在每次使用它时打sys.)，那么你能够使用 from sys import argv 语句。
若是你想要输入全部 sys 模块使用的名字，那么你能够使用 from sys import *语句。
这对于全部模块都适用。
注意:
1.使用 from package import item 方式导入包时，这个子项(item)既能够是包中的一个子模块(或一个子包)，也能够是包中定义的其它命名，像函数、类或变量。
import 语句首先核对是否包中有这个子项，若是没有，它假定这是一个模块，并尝试加载它。若是没有找到它，会引起一个 ImportError 异常。
2.使用像 import item.subitem.subsubitem 这样的语句时，这些子项必须是包，最后的子项能够是包或模块，但不能是前面子项中定义的类、函数或变量。
3.应该避免使用 from...import 而使用 import 语句，由于这样能够使你的程序更加易读，也能够避免名称的冲突。
import ... as
为 import 的模块起一个简称。如: import cPickle as p
起简称后,下面的语句便可使用简称,如本来的 cPickle.dump() 可写成 p.dump()
模块的 name
每一个模块都有一个名称，在模块中能够经过语句来找出模块的名称。
这在一个场合特别有用——就如前面所提到的，当一个模块被第一次输入的时候，这个模块的主块将被运行。
假如咱们只想在程序自己被使用的时候运行主块，而在它被别的模块输入的时候不运行主块，咱们该怎么作呢？这能够经过模块的__name__属性完成。
每一个Python模块都有它的__name__，若是它是'main'，这说明这个模块被用户单独运行，咱们能够进行相应的恰当操做。
例:
# Filename: using_name.py
if __name__ == '__main__':
print('This program is being run by itself')
else:
print('I am being imported from another module')
输出:
$ python using_name.py
This program is being run by itself
$ python
>>> import using_name
I am being imported from another module
自定义模块
每一个Python程序也是一个模块。
模块,例:
# Filename: mymodule.py
def sayhi():
print('Hi, this is mymodule speaking.')
version = '0.1'
# End of mymodule.py
上面是一个 模块 的例子。你已经看到，它与咱们普通的Python程序相比并无什么特别之处。
记住这个模块应该被放置在咱们输入它的程序的同一个目录中，或者在 sys.path 所列目录之一。
用例1:
import mymodule
mymodule.sayhi()
print('Version', mymodule.version)
注:函数和成员都以点号来使用。
用例2: 使用from..import语法的版本。
from mymodule import sayhi, version # 或者写: from mymodule import *
sayhi()
print('Version', version)
包(Packages)
包一般是使用用“圆点模块名”的结构化模块命名空间。例如， A.B 表示名为"A" 的包中含有名为"B"的子模块。
使用圆点模块名保存不一样类库的包能够避免模块之间的命名冲突。(如同用模块来保存不一样的模块架构能够避免变量之间的命名冲突)
包目录必需要有一个 init.py 文件的存在；这是为了防止命名冲突而无心中在随后的模块搜索路径中覆盖了正确的模块。
最简单的状况下， init.py 能够只是一个空文件，不过它也可能包含了包的初始化代码，或者设置了 all 变量。
dir()函数
使用内建的dir函数来列出模块定义的标识符。标识符有函数、类和变量。
当你为 dir()提供一个模块名的时候，它返回模块定义的名称列表。若是不提供参数，它返回当前模块中定义的名称列表。
$ python >>> import sys >>> dir(sys) # get list of attributes for sys module ['__displayhook__', '__doc__', '__excepthook__', '__name__', '__stderr__', '__stdin__', '__stdout__', '_getframe', 'api_version', 'argv', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats', 'copyright', 'displayhook', 'exc_clear', 'exc_info', 'exc_type', 'excepthook', 'exec_prefix', 'executable', 'exit', 'getcheckinterval', 'getdefaultencoding', 'getdlopenflags', 'getfilesystemencoding', 'getrecursionlimit', 'getrefcount', 'hexversion', 'maxint', 'maxunicode', 'meta_path','modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix', 'ps1', 'ps2', 'setcheckinterval', 'setdlopenflags', 'setprofile', 'setrecursionlimit', 'settrace', 'stderr', 'stdin', 'stdout', 'version', 'version_info', 'warnoptions'] >>> dir() # get list of attributes for current module ['__builtins__', '__doc__', '__name__', 'sys'] >>> >>> a = 5 # create a new variable 'a' >>> dir() ['__builtins__', '__doc__', '__name__', 'a', 'sys'] >>> >>> del a # delete/remove a name; 这个得留意 >>> >>> dir() ['__builtins__', '__doc__', '__name__', 'sys'] >>>
数据结构
能够处理一些 数据 的 结构 。或者说，它们是用来存储一组相关数据的。
在Python中有三种内建的数据结构——列表、元组和字典。
列表(list, 有的语言称为:数组)
是处理一组有序项目的数据结构，即你能够在一个列表中存储一个 序列 的项目。
列表中的项目应该包括在方括号中，每一个项目之间用逗号分割。
能够添加、删除或是搜索列表中的项目。列表是 可变的 数据类型。
列表对象定义的全部方法能够经过 help(list) 得到完整的知识。我比较习惯称它为“数组”。
例:
shoplist = ['apple', 'mango', 'carrot', 'banana']
#查看长度
print('I have', len(shoplist),'items to purchase.')
#遍历
print('These items are:', end=' ') # 注意这行的结尾,打印时能够不换行,python 2.x应该用逗号结尾
for item in shoplist:
print(item, end=' ') # python 2.x 此行应该写：“print item,”
#添加
print('\nI also have to buy rice.')
shoplist.append('rice')
print('My shopping list is now:', shoplist)
#排序
print('I will sort my list now')
shoplist.sort()
print('Sorted shopping list is:', shoplist)
#删除,以及使用下标
print('The first item I will buy is:', shoplist[0])
olditem = shoplist[0]
del shoplist[0]
print('I bought the', olditem)
print('My shopping list is now:', shoplist)
#多维列表时,保存的对象只是引用
newlist = ['waa','dd']
shoplist.append(newlist)
print('My shopping list is now:', shoplist)
del newlist[0]
print('My shopping list is now', shoplist)
# 删除重复, 用 set (对元组也能够这样写)
L = [1,1,1,2,2]
print(list(set(L))) # 打印：[1, 2]
l = [(1, 2), (1, 2), 3, 5, 4, 3, 4, (1, 2), 0, 5]
l = list(set(l))
print(l) # 打印: [(1, 2), 0, 3, 4, 5]
# 复制列表(浅拷贝)
c = shoplist[:]
# 复制(深拷贝)
import copy
c = copy.deepcopy(shoplist)
元组(tuple)
元组和列表十分相似，只不过元组和字符串同样是 不可变的 即你不能修改元组。
元组经过圆括号中用逗号分割的项目定义。
元组一般用在使语句或用户定义的函数可以安全地采用一组值的时候，即被使用的元组的值不会改变。
若是你想要知道元组对象定义的全部方法，能够经过 help(tuple) 得到完整的知识。
例:
#一维元组
zoo = ('wolf', 'elephant', 'penguin')
print('Number of animals in the zoo is %s' % len(zoo)) # 打印: 3
newlist = ['waa','dd']
#多维元组
new_zoo = ('monkey', 'dolphin', zoo, newlist)
print('Number of animals in the new zoo is %s' % len(new_zoo)) # 打印: 3
print('All animals in new zoo are %s' % str(new_zoo)) # 打印: ('monkey','dolphin',('wolf','elephant','penguin'),['waa','dd'])
print('Animals brought from old zoo are %s' % str(new_zoo[2])) # 打印: ('wolf', 'elephant', 'penguin')
print('Last animal brought from old zoo is %s' % new_zoo[2][2]) # 打印: penguin
#多维元组时,保存的对象只是引用
del newlist[0]
print('new_zoo is now:' + str(new_zoo) ) # 打印: ('monkey','dolphin',('wolf','elephant','penguin'),['dd'])
注意:含有0个或1个项目的元组
一个空的元组(含有0个项目)由一对空的圆括号组成，如myempty = ()。
含有单个元素的元组必须在第一个(惟一一个)项目后跟一个逗号。如: singleton = (2 , )。
若是小括号里面只有惟一一个项目,而这个项目后面又没有跟一个逗号的话,Python会认为它是一个表达式。
字典(dict, 有的语言称为:json)
字典把键(名字)和值(详细状况)联系在一块儿。
注意，键必须是惟一的，且只能使用不可变的对象(好比字符串)来做为字典的键，但字典的值没有此限制。应该说只能使用简单的对象做为键。
键值对在字典中以这样的方式标记：d = {key1 : value1, key2 : value2 }。
键值对用冒号分割，而各个对用逗号分割，全部这些都包括在花括号中。
记住字典中的键/值对是没有顺序的。若是要一个特定的顺序，那么应该在使用前本身对它们排序。
字典是dict类的实例/对象，能够用 help(dict) 来查看其属性和函数。
例:
ab = { 'Swaroop': 'swar',
'Larry' : 'larry',
'Spammer': 'spammer'
}
print(ab) # 打印: {'Swaroop':'swar', 'Larry':'larry', 'Spammer':'spammer'}
print("Swaroop's address is %s" % ab['Swaroop']) # 打印: swar
# 添加值,或者设值
ab['Guido'] = 'guido'
# 删除值
del ab['Spammer']
# ab.pop('Spammer') # 也能够用 pop 来删除，但建议后面的这种写法，避免没有这个键时会报错： ab.pop('Spammer', None)
print('\nThere are %d contacts in the address-book\n' % len(ab)) # 打印: 3
# 遍历(这写法得留意)
for name, address in ab.items():
print('Contact %s at %s' % (name, address))
# 包含key
if 'Guido' in ab: # 或者写： if ab.has_key('Guido'):
print("\nGuido's address is %s" % ab['Guido'])
# 原字典上建立新字典
print(ab) # 打印: {'Swaroop':'swar', 'Larry':'larry', 'Guido':'guido'}
dd = dict(ab, slug_field='slug', test=5) # 建立新字典,字典做为参数的只能放第一个，其他不能再是字典；字典参数可省略
print(dd) # 打印: {'Swaroop':'swar', 'test':5, 'slug_field':'slug', 'Larry':'larry', 'Guido':'guido'}
# 建议的取值方法
print( ab['test'] ) # 这样取值，当字典里面没有对应的key时会报错:“KeyError”
print( ab.get('test', 'default_value') ) # get取值，当字典里面没有对应的key时可取后面的预设值,预设值是可选的(默认是 None)
# 全部的键和值
print(ab.keys()) # 全部的键
print(ab.values()) # 全部的值
# 复制(浅拷贝)
print(ab.copy())
# 复制(深拷贝)
import copy
c = copy.deepcopy(ab)
序列
列表、元组和字符串都是序列，序列的两个主要特色是“索引”操做符和“切片”操做符。
索引操做符让咱们能够从序列中抓取一个特定项目。(即便用下标)
切片操做符让咱们可以获取序列的一个切片，即一部分序列。(即在下标的中括号里面使用冒号)
例:
shoplist = ['apple', 'mango', 'carrot', 'banana']
# Indexing or 'Subscription' operation
print('Item 0 is %s' % shoplist[0])
print('Item 3 is %s' % shoplist[3])
print('Item -1 is %s' % shoplist[-1]) # 打印:banana 即倒数第一个
print('Item -2 is %s' % shoplist[-2]) # 打印:carrot 即倒数第二个
# Slicing on a list
print('Item 1 to 3 is %s' % shoplist[1:3]) # 打印:['mango', 'carrot'] 即下标[1]到[3],包括开始但不包括结束
print('Item 2 to end is %s' % shoplist[2:]) # 打印:['carrot', 'banana'] 即下标[2]到结束,包括最后一个
print('Item 1 to -1 is %s' % shoplist[1:-1]) # 打印:['mango', 'carrot'] 即下标[1]到[-1],包括开始但不包括结束
print('Item start to end is %s' % shoplist[:]) # 打印整个列表,跟直接写“shoplist”效果同样
# Slicing on a string (string与列表有一样的操做,)
name = 'swaroop'
print('characters 1 to 3 is %s' % name[1:3]) # 打印:wa
print('characters 2 to end is %s' % name[2:]) # 打印:aroop
print('characters 1 to -1 is %s' % name[1:-1]) # 打印:waroo
print('characters start to end is %s' % name[:]) # 打印:swaroop 跟直接写这个字符串同样
参考(引用)
当你建立一个对象并给它赋一个变量的时候，这个变量仅仅 参考 那个对象，而不是表示这个对象自己！
也就是说，变量名指向你计算机中存储那个对象的内存。
这被称做名称到对象的绑定。
例:
shoplist = ['apple', 'mango', 'carrot', 'banana']
mylist = shoplist # mylist 只是对象的另外一个名称,他们指向相同的内存空间
del shoplist[0]
# 他们此时打印相同的内容,都少了'apple'
print('shoplist is', shoplist)
print('mylist is', mylist)
# 深拷贝,复制成另外一个对象(得记住用切片操做符来取得拷贝)
mylist = shoplist[:] # make a copy by doing a full slice
del mylist[0] # remove first item
# 注意，如今他们打印出不一样的内容
print('shoplist is', shoplist)
print('mylist is', mylist)
列表综合
经过列表综合，能够从一个已有的列表导出一个新的列表。
[返回值 for 元素 in 列表 if 条件] 好比 [num for num in xrange(100) if num%2==0] 返回0～99之间的偶数列表
# 例如，你有一个数的列表，而你想要获得一个对应的列表，使其中全部大于2的数都是原来的2倍。对于这种应用，列表综合是最理想的方法。
listone = [2, 3, 4]
listtwo = [2*i for i in listone if i > 2] # 为知足条件(if i > 2)的数指定了一个操做(2*i)，从而导出一个新的列表。
print(listtwo) # 打印: [6, 8]
ls=[1,3,5,7] # reduce 在python3去掉了
print(reduce(lambda x,y:x+y,ls)) # 计算过程就是 1+3=4 而后4+5获得结果9，再加7，以此类推，最后返回最终计算的结果(总和)；打印：16
# 将字典的key，value倒过来的写法：
a_dict = {'a': 1, 'b': 2, 'c': 3}
# python3 的写法:
b_dict = {value:key for key, value in a_dict.items()}
# python2 时的写法：
b_dict = {}
for key, value in a_dict.iteritems():
b_dict[value] = key
print(b_dict) # key与value翻转，打印: {1:'a', 2:'b', 3:'c'}
说明:
注意原来的列表并无发生变化。
在不少时候，咱们都是使用循环来处理列表中的每个元素，而使用列表综合能够用一种更加精确、简洁、清楚的方法完成相同的工做。
当心 list 的 += 操做(python2时能够用，python3不能够再这样用)
集合
Python3 开始有这写法,跟以前的差很少,只是用大括号括起来,如： a = {1, 'aa', 3, 5, 6}
集合一样能够使用综合计算，如： a = {x for x in range(10) if x % 2 == 0}
成员测试 in, not in
检查是否包含有此内容,返回 True 或者 False, 例如：
# 1.对字符串
if 'a' in 'Swaroop':
print('Yes, it contains the string "a"')
# 2.对集合(列表、元组和字典)
if 'genre' in ('genre', 'jazz'):
print('Yes, it contains the genre')
print('genre' in ('genre', 'jazz')) # 元组,打印： True
print('genre' in ['genre', 'jazz']) # 列表,打印： True
print('genre' in {'genre':'sss', 'jazz':'dddd'}) # 字典,检查key，打印： True
print('sss' in {'genre':'sss', 'jazz':'dddd'}) # 字典,打印： False
排序
1.sort方法
Python语言内置了sort方法，能够很方便地对某个List进行排序
例如：
L = [6, 5, 1, 3, 4, 2]
L.sort()
print(L) # 打印：[1, 2, 3, 4, 5, 6]
li=[(2,'a'),(4,'b'),(1,'d')]
li.sort() # 元组列表排序
print(li) # 打印： [(1, 'd'), (2, 'a'), (4, 'b')]
2.自定义排序(例如，按关键词的权重排序，按人的年龄排序，等等)
若List中每一个元素都是2-tuple，tuple中第一个元素为String类型的keyword，第二个元素为该字符串对应的权重(int类型)，但愿按照权重排序(从高到低)，则能够这样：
L = [('b', 1), ('a', 0), ('c', 2), ('d', 3)]
# L.sort(lambda E1, E2: -cmp(E1[1], E2[1])) # cmp函数里面是需比较的两个值，负号表示倒序。(python2 的写法)
L.sort(key=lambda d:-d[1]) # Python3的写法，因为去掉了cmp()函数,得传入key参数； python2也能够这样用；负号表示倒序
print(L) # 打印：[('d', 3), ('c', 2), ('b', 1), ('a', 0)]
3.dict排序
对字典的排序，由于每个项包括一个键值对，因此要选择可比较的键或值进行排序
sorted(iterable[, cmp[, key[, reverse]]])
# cmp 和 key 通常使用 lambda
如：
d={"ok":1,"no":2}
# 对字典按键排序，用元组列表的形式返回
print(sorted(d.items(), key=lambda a:a[0])) # 打印： [('no', 2), ('ok', 1)]
print(sorted(d)) # 打印：['no', 'ok']
print(d) # 原字典并未改变，打印：{'ok':1, 'no':2}
# 对字典按值排序，用元组列表的形式返回
print(sorted(d.items(), key=lambda d:d[1])) # 打印：[('ok', 1), ('no', 2)]
# 排序后再转成字典，就没法再保证排序了
b = sorted(d.items(), key=lambda v:v[0])
print(b) # 打印： [('no', 2), ('ok', 1)]
print(dict(b)) # (排序又乱了)打印： {'ok': 1, 'no': 2}
4.类的排序
class test:
def __init__(self,a,b):
self.a = a
self.b = b
test1 = test(5,25)
test2 = test(50,35)
test3 = test(10,15)
tests = [test1, test2, test3]
# 以 cmp 来指定排序方式, python3不能够这样写(没有cmp参数及cmp函数)
result = sorted(tests,cmp = lambda x,y: cmp(x.a, y.a))
# 遍历排序结果，结果是已排序的： a:5 a:10 a:50
for item in result:
print("a:%s" % item.a)
# 以 key 来排序，结果也是能够的
result2 = sorted(tests,key = lambda d:d.a)
for item in result2:
print("a:%s" % item.a)
# 遍历原资料，原资料的顺序没有改变
for item in tests:
print("a:%s" % item.a)
5.注意：
python3 因为去掉了 cmp() 函数，能够用“(a > b) - (a < b)”代替“ cmp(a, b) ”
6.冒泡算法，以下：
num = [23,2,3,6,18,9,33,13,24,19]
for i in range(len(num)-1):
for j in range(len(num)-i-1):
if (num[j] > num[j+1]):
num[j], num[j+1] = num[j+1], num[j] # 置换，这样写比较简便，不需再用临时变量
print(num)
综合实例：
在Python中对列表，元组，字典等内置的数据结构的处理是很方便的事情，python借鉴了Lisp中的不少函数式计算的方法来处理列表，能够极大的简化咱们的代码。
1. set(): 将元组，列表 转化成没有重复项的集合
2. list(): 将集合，元组转化成列表
3. tuple(): 将集合，列表转化成元组
4. map(func,list):将list的每个元素传递给func的函数，这个函数有一个参数，且返回一个值，map将每一次调用函数返回的值组成一个新列表返回
5. filter(func,list):将list的每个元素传递给func的函数，这个函数有一个参数，返回bool类型的值，filter将返回True的元素组成新列表返回
6. reduce(func,list):将list的元素，挨个取出来和下一个元素经过func计算后将结果和再下一个元素继续计算
1、列表去重
ls = [1,3,2,5,2,1,3,4,6]
ls = list(set(ls)) # 最简单的列表去除重复
L = [1, 8, 3, 4, 6, 2, 3, 4, 5]
kk = [x for x in L if x not in locals()['_[1]']] # 保留原顺序的去除重复,只有 2.6 上能够, 2.7 以上版本不能这样写
# '_[1]' 是个内部临时变量，可查看: [x for x, y in locals().items()]
2、假若有列表：
books = [
{"name":"C#从入门到精通", "price":23.7, "store":"卓越"},
{"name":"ASP.NET高级编程", "price":44.5, "store":"卓越"},
{"name":"C#从入门到精通", "price":24.7, "store":"当当"},
{"name":"ASP.NET高级编程", "price":45.7, "store":"当当"},
{"name":"C#从入门到精通", "price":26.7, "store":"新华书店"},
{"name":"ASP.NET高级编程", "price":55.7, "store":"新华书店"},
]
2.1 求《ASP.NET高级编程》价格最便宜的店：
storename=min([b for b in books if b['name']=="ASP.NET高级编程"],key=lambda b:b['price'])["store"]
过程：先用列表解析取出《ASP.NET高级编程》的列表，经过min函数，比较字典的price键获取price最小的项
2.2 求在新华书店购买两本书同样一本要花的钱：
price=sum([b['price'] for b in books if b['store']=="新华书店"])
2.3 求列表中有那几本书：
booknames=list(set([b['name'] for b in books]))
2.4 列表里的书都打5折：
books=map(lambda b:dict(name=b['name'],price=b['price']*0.5,store=b['store']),books)
2.5 《C#从入门到精通》的平均价格：
avg=(lambda ls:sum(ls)/len(ls))([b['price'] for b in books if b['name']=="C#从入门到精通"])
2.6 求每本书的平均价格：
book_avg=map(lambda bookname:dict(name=bookname,avg=(lambda ls:sum(ls)/len(ls))([b['price'] for b in books if b['name']==bookname])),list(set([b['name'] for b in books])))
这段代码放在一行比较难看懂，可是格式化一下就很好懂了，构建的过程以下：
step1: 要求每本书的平均价格，首先要获得共有几本书，方法见2.3，获得去重的书名列表
list(set([b['name'] for b in books])) #去重后的书名列表
step2: 要求每一本书的均价，须要将计算均价的函数映射到每一本书上，因而
map(
#计算均价的函数，
list(set([b['name'] for b in books])) #去重后的书名列表
)
step3: 加入计算单本书均价的函数，参考2.5的方法，因为只用一行，因此用lambda来搞定：
func=lambda bookname:(lambda ls:sum(ls)/len(ls))([b.price for b in books if b['name']==bookname])
step4: 将计算单本均价的lambda函数加入map中，获得最终结果：
通过格式化后的结果，前面的单行代码能够格式化为下面容易阅读的形式
book_avg=map(
lambda bookname:
dict(
name = bookname,
# 计算单本书均价的函数
avg = (lambda ls:sum(ls)/len(ls)) ([b['price'] for b in books if b['name']==bookname])
),
#去重后的书名列表
list(
set(
[b['name'] for b in books]
)
)
)
在函数中接收元组和列表(函数的参数数量能够变更,便可变长参数)
当要使函数接收元组或字典形式的参数的时候，有一种特殊的方法，它分别使用*和**前缀。
这种方法在函数须要获取可变数量的参数的时候特别有用。
并且，使用*和**前缀的参数还能够传递给其它函数。
例:
# 因为在args变量前有*前缀，全部多余的函数参数都会做为一个元组存储在args中
def sum(message, *args):
'''Return the sum of each argument.'''
total = 0
# 除了用循环,也能够用下标来读取参数,如: args[0]
for i in args:
total += i
print (str(type(args)) + ' ' + message + ":" + str(total))
sum2(args) # 这样传过去的 args 是一个元组；打印如： ((3, 5.5),)
sum2(*args) # 这样传过去的 *args 表示多个参数；打印如：(3, 5.5)
def sum2(*args):
print(args)
sum('hight', 3, 5.5) # 打印: <type 'tuple'> hight:8.5
sum('weight', 10) # 打印: <type 'tuple'> weight:10
# 函数参数接收字典用法。使用的是**前缀，多余的参数则会被认为是一个字典的键/值对。
def printDict(message, **args):
print(str(type(args)) + ' ' + message + ':' + str(args))
printDict2(args = args) # 可这样，把 args 当作一个值(里面是字典)，传过去；打印如: {'args': {'a': 3, 'b': 'dd'}}
printDict2(**args) # 也可这样，把 **args 看作传过来的多个键/值对，传过去；打印如：{'a': 3, 'b': 'dd'}
def printDict2(**args):
print(args)
# 注意:参数为字典时,参数里面必须使用等号,不然运行出错
printDict('hight', a=3, b='dd') # 打印: <type 'dict'> hight:{'a': 3, 'b': 'dd'}
# 能够混合使用*和**前缀的参数, 可是必须 *args 在前, **args 在后,不然编译不经过
def printMul(message, *args1, **args2):
print(message + ' args1:' + str(args1) + ' args2:' + str(args2))
printMul('hello', 5, 4, a=2, b=3) # 打印： hello args1:(5, 4) args2:{'a': 2, 'b': 3}
面向对象的编程
面向过程的编程:根据操做数据的函数或语句块来设计程序的。
面向对象的编程:把数据和功能结合起来，用称为对象的东西包裹起来组织程序的方法。
类和对象是面向对象编程的两个主要方面。“类”建立一个新类型，而“对象”是这个类的实例。
域:属于一个对象或类的变量。
方法:属于类的函数，被称为类的方法。
域和方法能够合称为类的属性。
域有两种类型——属于每一个实例/类的对象或属于类自己。它们分别被称为实例变量和类变量。
类使用class关键字建立。类的域和方法被列在一个缩进块中。
self 参数
类的方法与普通的函数只有一个特别的区别——它们“必须”有一个额外的第一个参数名称，可是在调用这个方法的时候你不为这个参数赋值，Python会提供这个值。这个特别的变量指对象自己，按照惯例它的名称是self。
虽然你能够给这个参数任何名称，可是“强烈建议”使用self这个名称——其余名称都是不同意使用的。
使用一个标准的名称有不少优势——1.方便别人阅读；2.有些IDE(集成开发环境)也能够帮助你。
Python中的self等价于C++中的self指针和Java、C#中的this参考。
例:
class Person:
def sayHi(self): # self参数必须写
print('Hello, how are you?')
p = Person()
p.sayHi() # self参数不需赋值
print(p) # 打印: <__main__.Person instance at 0xf6fcb18c> (已经在__main__模块中有了一个Person类的实例)
类的变量和对象的变量
类的变量: 由一个类的全部对象(实例)共享使用。当某个对象对类的变量作了改动的时候，这个改动会反映到全部其余的实例上。
对象的变量: 由类的每一个对象/实例拥有。它们不是共享的，在同一个类的不一样实例中，虽然对象的变量有相同的名称，可是是互不相关的。
使用的数据成员名称以“双下划线前缀”且不是双下划线后缀,好比__privatevar，Python的名称管理体系会有效地把它做为私有变量。
惯例: 若是某个变量只想在类或对象中使用，就应该以单下划线前缀。而其余的名称都将做为公共的，能够被其余类/对象使用。
例:
class Person:
'''Represents a person.'''
population = 0 # 类的变量
def __init__(self, name):
'''Initializes the person's data.'''
# 每建立一个对象都增长1
Person.population += 1 # 调用类的变量,必须用 类名.变量名,若是写 self.变量名 则是对象的变量了
self.name = name # 对象的变量,每一个对象独立的
print('(Initializing %s) We have %d persons here.' % (self.name, Person.population))
def __del__(self):
'''I am dying.'''
print('%s says bye.' % self.name)
Person.population -= 1
def sayHi(self):
self.__sayHi2() # 调用私有方法,外部不能调用的
# 以双下划线开头(但没有双下划线结尾),则变成私有,仅供内部调用
def __sayHi2(self): # 使用 self.population 也能够读取类的变量,只是改变的时候却只改变对象的变量
print('Hi, my name is %s. We have %d persons here.' % (self.name, self.population))
swaroop = Person('Swaroop')
swaroop.sayHi() # 打印: Swaroop, 1
kalam = Person('Abdul Kalam')
kalam.sayHi() # 打印: Abdul Kalam, 2
swaroop.sayHi() # 打印: Swaroop, 2
print(Person.population) # 打印: 2
del swaroop # 调用对象的 __del__ 方法
print(Person.population) # 打印: 1
print(Person.__doc__) # 打印类的docstring
print(Person.__init__.__doc__) # 打印类的方法的docstring
继承
多态现象:一个子类型在任何须要父类型的场合能够被替换成父类型，即对象能够被视做是父类的实例。
被继承的类被称为“基本类”或“超类”、“父类”。继承的类被称为“导出类”或“子类”。
例:
# 父类
class Member:
def __init__(self, name, age):
self.name = name
self.age = age
print('(Initialized Member: %s)' % self.name)
def tell(self):
print('Member Name:"%s" Age:"%s"' % (self.name, self.age))
def tell2(self):
print('Member haha...')
# 子类
class Student(Member): # 继承的父类写括号里面;多继承则写多个,这括号的称为继承元组
def __init__(self, name, age, marks):
Member.__init__(self, name, age) # 父类的初始化,需手动写；Python不会自动调用父类的constructor
self.marks = marks
print('(Initialized Student: %s)' % self.name)
def tell(self):
Member.tell(self) # 调用父类的方法,注意:方法调用以前要加上父类名称前缀，而后把self变量及其余参数传递给它。
print('Marks: "%d"' % self.marks)
s = Student('Swaroop', 22, 75)
s.tell() # 会调用子类的方法
s.tell2() # 子类没有的，则使用父类的；若是多继承,且父类都有这个方法,则使用继承元组中排前面的
特殊的方法
init 方法
init 方法在类的一个对象被创建时，立刻运行。用来对你的对象作初始化。
注意，这个名称的开始和结尾都是双下划线。( init 方法相似于C++、C#和Java中的 constructor )
例:
class Person:
def __init__(self, name):
self.test_name = name
def sayHi(self):
print('Hello, my name is ' + self.test_name)
self.test = 'sss' # 属性能够随处定义,不需事先定义
print('the test is ' + self.test)
p = Person('Swaroop')
p.sayHi() # 打印: Swaroop , sss
print('the Person test is ' + p.test) # 打印: sss
p.test2 = 'haha...'
print('the Person test2 is ' + p.test2) # 打印: haha...
名称 说明
__init__(self,...) 这个方法在新建对象刚好要被返回使用以前被调用。
__del__(self) 在对象要被删除以前调用。如使用 del 删除时。
__str__(self) 在咱们对对象使用 print 语句或是使用 str() 的时候调用。
__lt__(self,other) 当使用 小于 运算符 (<) 的时候调用。
__gt__(self,other) 当使用 大于 运算符 (>) 的时候调用。
__eq__(self,other) 当使用 等于 运算符 (==) 的时候调用。
__ne__(self,other) 当使用 不等于 运算符 (!=) 的时候调用。
__le__(self,other) 当使用 小于等于 运算符 (<=) 的时候调用。
__ge__(self,other) 当使用 大于等于 运算符 (>=) 的时候调用。
__add__(self,other)当使用 加 运算符 (+) 的时候调用。
__getitem__(self,key) 使用x[key]索引操做符的时候调用。
__len__(self) 对序列对象使用内建的 len() 函数的时候调用。
try ... except (处理异常)
使用 try ... except 语句来处理异常。
except 从句能够专门处理单一的错误或异常，或者一组包括在圆括号内的错误/异常。没有给出错误或异常的名称，则处理全部的错误和异常。
若是某个错误或异常没有被处理，默认的Python处理器就会被调用。它会终止程序的运行，而且打印一个消息。
还能够关联上一个 else 从句,当没有异常发生的时候执行。
常见异常(可避免的):
使用不存在的字典关键字 将引起 KeyError 异常。
搜索列表中不存在的值 将引起 ValueError 异常。
调用不存在的方法 将引起 AttributeError 异常。
引用不存在的变量 将引起 NameError 异常。
未强制转换就混用数据类型 将引起 TypeError 异常。
导入一个并不存在的模块将引起一个 ImportError 异常。
try ... finally
假如但愿在不管异常发生与否的状况下都执行一段代码,能够使用 finally 块来完成。
注意，在一个 try 块下，你能够同时使用 except 从句和 finally 块。
若是在 finally 前面的 try 或者 except, else 等里面有 return 语句,会先跳去执行 finally 再执行 return
raise 语句
能够使用 raise 语句引起异常(抛出异常)。你还得指明错误/异常的名称和伴随异常触发的异常对象。
能够引起 Error 或 Exception 类的直接或间接导出类。
在Python 3里，抛出自定义异常的语法有细微的变化。
Python 2 Python 3
① raise MyException MyException
② raise MyException, 'error message' raise MyException('error message')
③ raise MyException, 'error message', a_traceback raise MyException('error message').with_traceback(a_traceback)
④ raise 'error message' unsupported(不支持)
说明:
① 抛出不带自定义错误信息的异常，这种最简单的形式下，语法没有改变。
② 抛出带自定义错误信息的异常时:Python 2用一个逗号来分隔异常类和错误信息；Python 3把错误信息做为参数传递给异常类。
③ 抛出一个带用户自定义回溯(stack trace,堆栈追踪)的异常。在Python 2和3里这语法彻底不一样。
④ 在Python 2里，能够仅仅抛出一个异常信息。在Python 3里，这种形式再也不被支持。2to3将会警告你它不能自动修复这种语法。
例：
raise RuntimeError("有异常发生")
生成器的 throw 方法
在Python 2里，生成器有一个 throw()方法。
调用 a_generator.throw()会在生成器被暂停的时候抛出一个异常，而后返回由生成器函数获取的下一个值。
Python 2 Python 3
① a_generator.throw(MyException) a_generator.throw(MyException) # 没有变化
② a_generator.throw(MyException, 'error message') a_generator.throw(MyException('error message'))
③ a_generator.throw('error message') unsupported(不支持)
说明:
① 最简单的形式下，生成器抛出不带用户自定义错误信息的异常。这种状况下，从Python 2到Python 3语法上没有变化 。
② 若是生成器抛出一个带用户自定义错误信息的异常，你须要将这个错误信息字符串(error string)传递给异常类来以实例化它。
③ Python 2还支持抛出只有异常信息的异常。Python 3不支持这种语法，而且2to3会显示一个警告信息，告诉你须要手动地来修复这处代码。
例(3.x)语法:
# 定义一个异常类,继承 Exception
class ShortInputException(Exception):
'''A user-defined exception class.'''
def __init__(self, length, atleast):
Exception.__init__(self)
self.length = length
self.atleast = atleast
try:
s = input('Enter something --> ') # Python 2 的输入是 raw_input()
if len(s) < 3:
raise ShortInputException(len(s), 3) # 引起异常;Python 2能够写：raise ShortInputException,(len(s), 3)
# 捕获 EOFError 异常
except EOFError:
print('\nWhy did you do an EOF on me?')
# 捕获一组错误/异常,Python 2 时应该写: “except (RuntimeError, ImportError), e:”
except (RuntimeError, ImportError) as e:
pass
# Python 2 时应该写: “except ShortInputException, x:”
except ShortInputException as x:
print('ShortInputException: The input was of length %d,\
was expecting at least %d' % (x.length, x.atleast))
# 捕获全部异常
except:
print('\nWhy did you do an Exception on me?')
# 没有任何异常时执行
else:
print('No exception was raised.')
# 无论是否有异常,都会执行
finally:
print('finally .....')
lambda 形式
lambda 语句被用来建立新的函数对象，而且在运行时返回它们。
注意, lambda 形式中，只能使用表达式。
例:
def make_repeater(n):
return lambda s: s*n # 注意: lambda 返回的是函数,而不是表达式的值
# 注意, twice 接收的是函数, 而不是表达式的值, 因此 twice 是一个函数,而不是值
twice = make_repeater(2)
print(twice('word ')) # 由于 twice 是一个函数,这里是调用这个函数,打印结果: word word
print(make_repeater(3)(5)) # 这里的“make_repeater(3)”能够认为是匿名函数,打印结果: 15
# 上面例子貌似太过复杂,下面是简单点的写法
# 记住, twice2 是一个函数
twice2 = lambda s: s*2
print(twice2('word ')) # 打印: word word
print(twice2(5)) # 打印: 10
# 上面的 twice2 至关于正常的函数这样写(lambda 后面的是参数，而结果是返回冒号后面的表达式)：
def twice3(s):
return s*2
print(twice3('word ')) # 打印: word word
print(twice3(5)) # 打印: 10
# 可认为 lambda 是一个匿名函数
print((lambda s: s*2)('word ')) # 打印: word word
# 而 def 是不能申明匿名函数的
print((def (s): return s*2)(10)) # 这写法将会报错
print((def twice3(s): return s*2)(10)) # 这写法也一样会报错
# lambda 能够有多个参数
twice4 = lambda x,y: x*y
print(twice4('word ', 3)) # 打印: word word word
print(twice4(5, 3)) # 打印: 15
exec 和 eval
exec 用来执行储存在字符串或文件中的Python语句。
eval 用来计算存储在字符串中的有效Python表达式。
exec 跟 eval 是类似的，可是 exec 更增强大并更具备技巧性。
eval 只能执行单独一条表达式；可是 exec 可以执行多条语句，导入(import)，函数声明
实际上 exec 能执行整个Python程序的字符串。
Python 2 与 Python 3 的比较
Python 2 Python 3
① exec codeString exec(codeString)
② exec codeString in global_namespace exec(codeString, global_namespace)
③ exec codeString in global_namespace, local_namespace exec(codeString, global_namespace, local_namespace)
说明:
① 就像 print 语句在Python 3里变成了一个函数同样, exec 语句在Python 3里也变成一个函数。
② exec 能够指定名字空间，代码将在这个由全局对象组成的私有空间里执行。
③ exec 还能够指定一个本地名字空间(好比一个函数里声明的变量)。
例：
exec('print("Hello World")') # 执行打印语句
print(eval('2*3')) # 打印：6
execfile 语句
Python 2里的 execfile 语句也能够像执行Python代码那样使用字符串。不一样的是 exec 使用字符串，而 execfile 则使用文件。
在Python 3里,execfile 语句已经被去掉了。若是你真的想要执行一个文件里的Python代码(可是你不想导入它)，你能够经过打开这个文件，读取它的内容，而后调用 compile()全局函数强制Python解释器编译代码，而后调用 exec() 函数。
Python 2 写的： execfile('a_filename')
Python 3 写的： exec(compile(open('a_filename', 'rb').read(), 'a_filename', 'exec'))
assert 语句
assert 语句用来声明某个条件是真的。
当 assert 语句失败的时候，会引起一个 AssertionError 错误。
比较经常使用于检验错误。
例: assert 2 >= 1 # 正常运行 assert 0 >= 1 # 出现错误
repr 函数
repr 函数用来取得对象的规范字符串表示。反引号(也称转换符)能够完成相同的功能。
注意，在大多数时候有 eval(repr(object)) == object。
基本上, repr 函数和反引号用来获取对象的可打印的表示形式。
你能够经过定义类的 repr 方法来控制你的对象在被repr函数调用的时候返回的内容。
例： i = ["item"] print(repr(i)) # 打印：['item']
yield 用法
1) 包含 yield 的函数是一个 Generator, 与日常的函数不一样
例：
def gen():
print 'enter'
yield 1
print 'next'
yield 2
print 'next end'
print('begin...')
gen() # 直接调用,发现打印没有执行(与日常的函数不一样)
# 从容器里拿到 iterator 的时候它还什么也不是，处在容器入口处，对于数组来讲就是下标为-1的地方，对于函数来讲就是函数入口嘛事没干，可是万事俱备就欠 next 。
print('end...')
print
for i in gen():
print('...%d...' % i)
# 开始 for in , next 让 itreator 爬行到 yield 语句存在的地方并返回值,
# 再次 next 就再爬到下一个 yield 语句存在的地方并返回值,依次这样直到函数返回(容器尽头)。
上面代码的输出是：
begin...
end...
enter
...1...
next
...2...
next end
2) Generator 里面的 send(msg) 与 next()
调用 for in 时，至关因而使用 next() 语句或是 send(None)
若是没有接收值则使用 send 发送的值必须是 None ，不然会出错的，由于 yield 语句没有接收这个值，但 send 又必须传参数的。
例，用上例的 gen() 函数
c = gen()
print(c.next()) # 调用第一个 yield
print(c.send(None)) # 调用第二个 yield, 这里 next() 与 send(None) 是一样效果的
print(c.next()) # 第三次调用则出错了，由于数组下标越界, 抛出 StopIteration 的异常； 但会把最后的“next end”打印出来，前两个是无法把它打印出来的
# send(msg) 貌似无法把 msg 传到参数中
def gen2(m):
for i in range(10):
print(m)
yield i + 101
d = gen2('***')
print(c.next())
print(c.send(5555)) # 打印的依然是 ***, 而不是 5555
3) throw() 与 close() 中断 Generator
中断 Generator 是一个很是灵活的技巧，能够经过 throw 抛出一个 GeneratorExit 异常来终止 Generator 。 Close() 方法做用是同样的，其实内部它是调用了 throw(GeneratorExit) 的。咱们看：
def close(self):
try:
self.throw(GeneratorExit)
except (GeneratorExit, StopIteration):
pass
else:
raise RuntimeError("generator ignored GeneratorExit") # Other exceptions are not caught
所以，当咱们调用了 close() 方法后，再调用 next() 或是 send(msg) 的话会抛出一个异常
例，继续用前面例的 gen() 函数
c = gen()
print(c.next()) # 调用第一个 yield
c.close()
print(c.next()) # 调用第二个 yield 出错了，抛出 StopIteration 的异常, 由于前面的 close 已经关闭它了
正则表达式
正则表达式有强大而且标准化的方法来处理字符串查找、替换以及用复杂模式来解析文本。
正则表达式的语法比程序代码更紧凑，格式更严格，比用组合调用字符串处理函数的方法更具备可读性。
还能够在正则表达式中嵌入注释信息，这样就能够使它有自文档化的功能。
匹配符：
^ 匹配字符串开始位置。在多行字符串模式匹配每一行的开头。
$ 匹配字符串结束位置。在多行字符串模式匹配每一行的结尾。
. 匹配除了换行符外的任何字符，在 alternate 模式(re.DOTALL)下它甚至能够匹配换行。
\A 匹配字符串开头
\Z 匹配字符串结尾
\b 匹配一个单词边界。即 \w 与 \W 之间。
\B 匹配一个非单词边界；至关于类 [^\b]。
\d 匹配一个数字。
\D 匹配一个任意的非数字字符。
\s 匹配任何空白字符；它至关于类 [ \t\n\r\f\v]。
\S 匹配任何非空白字符；它至关于类 [^ \t\n\r\f\v]。
\w 匹配任何字母数字字符；它至关于类 [a-zA-Z0-9_]。
\W 匹配任何非字母数字字符；它至关于类 [^a-zA-Z0-9_]。
x? 匹配可选的x字符。便是0个或者1个x字符。
x* 匹配0个或更多的x。
x+ 匹配1个或者更多x。
x{n,m} 匹配n到m个x，至少n个，不能超过m个。
(a|b|c) 匹配单独的任意一个a或者b或者c。
(x) 捕获组，小括号括起来便可，它会记忆它匹配到的字符串。
能够用 re.search() 返回的匹配对象的 groups()函数来获取到匹配的值。
\1 记忆组，它表示记住的第一个分组；若是有超过一个的记忆分组，能够使用 \2 和 \3 等等。
记忆组的内容也要小括号括起来。
(?iLmsux) iLmsux的每一个字符表明一种匹配模式
re.I(re.IGNORECASE): 忽略大小写(括号内是完整写法，下同)
re.M(re.MULTILINE): 多行模式，改变'^'和'$'的行为(参见上图)
re.S(re.DOTALL): 点任意匹配模式，改变'.'的行为
re.L(re.LOCALE): 使预约字符类 \w \W \b \B \s \S 取决于当前区域设定
re.U(re.UNICODE): 使预约字符类 \w \W \b \B \s \S \d \D 取决于unicode定义的字符属性
re.X(re.VERBOSE): 松散正则表达式模式。这个模式下正则表达式能够是多行，忽略空白字符，并能够加入注释。
(?:表达式) 无捕获组。与捕获组表现同样，只是没有内容。
(?P<name>表达式) 命名组。与记忆组同样，只是多了个名称。
(?P=name) 命名组的逆向引用。
(?#...) “#”后面的将会做为注释而忽略掉。例如：“ab(?#comment)cd”匹配“abcd”
(?=...) 以后的字符串须要匹配表达式才能成功匹配。不消耗字符串内容。 例：“a(?=\d)”匹配“a12”中的“a”
(?!...) 以后的字符串须要不匹配表达式才能成功匹配。不消耗字符串内容。 例：“a(?!\d)”匹配“abc”中的“a”
(?<=...) 以前的字符串须要匹配表达式才能成功匹配。不消耗字符串内容。 例：“(?<=\d)a”匹配“2a”中的“a”
(?<!...) 以前的字符串须要不匹配表达式才能成功匹配。不消耗字符串内容。 例：“(?<!\d)a”匹配“sa”中的“a”
注：上面4个表达式的里面匹配的内容只能是一个字符，多个则报错。
(?(id/name)yes-pattern|no-pattern) 若是编号为 id 或者别名为 name 的组匹配到字符串，则须要匹配yes-pattern，不然须要匹配no-pattern。 “|no-pattern”能够省略。如：“(\d)ab(?(1)\d|c)”匹配到“1ab2”和“abc”
元字符:
"[" 和 "]"
它们经常使用来匹配一个字符集。字符能够单个列出，也能够用“-”号分隔的两个给定字符来表示一个字符区间。
例如，[abc] 将匹配"a", "b", 或 "c"中的任意一个字符；也能够用区间[a-c]来表示同一字符集，和前者效果一致。
元字符在类别里并不起做用。例如，[a$]将匹配字符"a" 或 "$" 中的任意一个；"$" 在这里恢复成普通字符。
也能够用补集来匹配不在区间范围内的字符。其作法是把"^"做为类别的首个字符；其它地方的"^"只会简单匹配 "^"字符自己。
例如，[^5] 将匹配除 "5" 以外的任意字符。
特殊字符均可以包含在一个字符类中。如，[\s,.]字符类将匹配任何空白字符或","或"."。
反斜杠 "\"。
作为 Python 中的字符串字母，反斜杠后面能够加不一样的字符以表示不一样特殊意义。
它也能够用于取消全部的元字符，这样你就能够在模式中匹配它们了。
例如，须要匹配字符 "[" 或 "\"，能够在它们以前用反斜杠来取消它们的特殊意义： \[ 或 \\。
建议使用原始字符串:
建议在处理正则表达式的时候老是使用原始字符串。如： r'\bROAD$', 而不要写成 '\\bROAD$'
不然，会由于理解正则表达式而消耗大量时间(正则表达式自己就已经够让人困惑的了)。
无捕获组:
有时你想用一个组去收集正则表达式的一部分，但又对组的内容不感兴趣。你能够用一个无捕获组“(?:...)”来实现这项功能。
除了捕获匹配组的内容以外，无捕获组与捕获组表现彻底同样；能够在其中放置任何字符、匹配符，能够在其余组(无捕获组与捕获组)中嵌套它。
无捕获组对于修改已有组尤为有用，由于能够不用改变全部其余组号的状况下添加一个新组。
捕获组和无捕获组在搜索效率方面也同样。
命名组:
与用数字指定组不一样的是，它能够用名字来指定。除了该组有个名字以外，命名组也同捕获组是相同的。
(?P<name>...) 定义一个命名组，(?P=name) 则是对命名组的逆向引用。
MatchObject 的方法处理捕获组时接受的要么是表示组号的整数，要么是包含组名的字符串。因此命名组能够经过数字或者名称两种方式来获得一个组的信息。
松散正则表达式:
为了方便阅读和维护，能够使用松散正则表达式，它与普通紧凑的正则表达式有两点不一样：
1, 空白符被忽略。空格、制表符(tab)和回车会被忽略。若是须要匹配他们，能够在前面加一个“\”来转义。
2, 注释被忽略。注释以“#”开头直到行尾，与python代码中的同样。
使用松散正则表达式，须要传递一个叫 re.VERBOSE的 参数。详细见下面例子。
例如:
# 必须引入 re 标准库
import re
# 字符串替换: sub() 与 subn()
s = '100 NORTH MAIN ROAD'
# 将字符串结尾的单词“ROAD”替换成“RD.”；该 re.sub() 函数执行基于正则表达式的字符串替换。
print(re.sub(r'\bROAD$', 'RD.', s)) # 打印： 100 NORTH MAIN RD.
## subn() 与 sub() 做用同样，但返回的是包含新字符串和替换执行次数的两元组。
print(re.subn(r'\bROAD$', 'RD.', s)) # 打印： ('100 NORTH MAIN RD.', 1)
# 字符串分割, split()
# 在正则表达式匹配的地方将字符串分片，将返回列表。只支持空白符和固定字符串。可指定最大分割次数，不指定将所有分割。
print(re.split(r'\s+', 'this is a test')) # 打印： ['this', 'is', 'a', 'test']
print(re.split(r'\W+', 'This is a test.', 2)) # 指定分割次数,打印：['this', 'is', 'a test']
# 若是你不只对定界符之间的文本感兴趣，也须要知道定界符是什么。在 RE 中使用捕获括号，就会同时传回他们的值。
print(re.split(r'(\W+)', 'This is a test.', 2)) # 捕获定界符,打印：['this', ' ', 'is', ' ', 'a test']
## `MatchObject` 实例的几个方法
r = re.search(r'\bR(OA)(D)\b', s)
print(r.groups()) # 返回一个包含字符串的元组,可用下标取元组的内容，打印： ('OA', 'D')
print(r.group()) # 返回正则表达式匹配的字符串，打印： ROAD
print(r.group(2)) # 返回捕获组对应的内容(用数字指明第几个捕获组)，打印： D
print(r.start()) # 返回匹配字符串开始的索引, 打印： 15
print(r.end()) # 返回匹配字符串结束的索引，打印： 19
print(r.span()) # 返回一个元组包含匹配字符串 (开始,结束) 的索引，打印： (15, 19)
# 匹配多个内容, findall() 返回一个匹配字符串行表
p = re.compile('\d+')
s0 = '12 drummers drumming, 11 pipers piping, 10 lords a-leaping'
print(p.findall(s0)) # 打印： [12, 11, 10]
print(re.findall(r'\d+', s0)) # 也可这样写，打印： [12, 11, 10]
# 匹配多个内容, finditer() 以迭代器返回
iterator = p.finditer(s0)
# iterator = re.finditer(r'\d+', s0) # 上句也能够这样写
for match in iterator:
print(match.group()) # 三次分别打印：十二、 十一、 10
# 记忆组
print(re.sub('([^aeiou])y$', 'ies', 'vacancy')) # 将匹配的最后两个字母替换掉，打印： vacanies
print(re.sub('([^aeiou])y$', r'\1ies', 'vacancy')) # 将匹配的最后一个字母替换掉，记忆住前一个(小括号那部分)，打印： vacancies
print(re.search('([^aeiou])y$', 'vacancy').group(1)) # 使用 group() 函数获取对应的记忆组内容，打印： c
# 记忆组(匹配重复字符串)
p = re.compile(r'(?P<word>\b\w+)\s+\1') # 注意, re.match() 函数不能这样用，会返回 None
p = p.search('Paris in the the spring')
# p = re.search(r'(?P<word>\b\w+)\s+\1', 'Paris in the the spring') # 这一句能够替换上面两句
print(p.group()) # 返回正则表达式匹配的全部内容，打印： the the
print(p.groups()) # 返回一个包含字符串的元组，打印： ('the',)
# 捕获组
r = re.search(r'\bR(OA)(D)\b', s) # 如过能匹配到，返回一个 SRE_Match 类(正则表达式匹配对象)；匹配不到则返回“None”
# `MatchObject` 实例的几个方法
if r: # 若是匹配不到，则 r 为 None,直接执行下面语句则会报错；这里先判断一下，避免这错误
print(r.groups()) # 返回一个包含字符串的元组,可用下标取元组的内容，打印： ('OA', 'D')
print(r.group()) # 返回正则表达式匹配的字符串，打印： ROAD
print(r.group(2)) # 返回捕获组对应的内容(用数字指明第几个捕获组)，打印： D
# 无捕获组
print(re.match("([abc])+", "abcdefab").groups()) # 正常捕获的结果： ('c',)
print(re.match("(?:[abc])+", "abcdefab").groups()) # 无捕获组的结果： ()
# 命名组
m = re.match(r'(?P<word>\b\w+\b) *(?P<word2>\b\w+\b)', 'Lots of punctuation')
print(m.groups()) # 返回正则表达式匹配的全部内容，打印：('Lots', 'of')
print(m.group(1)) # 经过数字获得对应组的信息，打印： Lots
print(m.group('word2')) # 经过名称获得对应组的信息，打印： of
# 命名组 逆向引用
p = re.compile(r'(?P<word>\b\w+)\s+(?P=word)') # 与记忆组同样用法, re.match() 函数一样不能这样用，会返回 None
p = p.search('Paris in the the spring') # r'(?P<word>\b\w+)\s+(?P=word)' 与 r'(?P<word>\b\w+)\s+\1' 效果同样
print(p.group()) # 返回正则表达式匹配的全部内容，打印： the the
print(p.groups()) # 返回一个包含字符串的元组，打印： ('the',)
# 使用松散正则表达式,以判断罗马数字为例
pattern = '''
^ # beginning of string
(M{0,3}) # thousands - 0 to 3 Ms
(CM|CD|D?C{0,3}) # hundreds - 900 (CM), 400 (CD), 0-300 (0 to 3 Cs),
# or 500-800 (D, followed by 0 to 3 Cs)
(XC|XL|L?X{0,3}) # tens - 90 (XC), 40 (XL), 0-30 (0 to 3 Xs),
# or 50-80 (L, followed by 0 to 3 Xs)
(IX|IV|V?I{0,3}) # ones - 9 (IX), 4 (IV), 0-3 (0 to 3 Is),
# or 5-8 (V, followed by 0 to 3 Is)
$ # end of string
'''
print(re.search(pattern, 'M')) # 这个没有申明为松散正则表达式，按普通的来处理了，打印： None
print(re.search(pattern, 'M', re.VERBOSE).groups()) # 打印： ('M', '', '', '')
# (?iLmsux) 用法
# 如下这三句的写法都是同样的效果，表示忽略大小写，打印： ['aa', 'AA']
print(re.findall(r'(?i)(aa)', 'aa kkAAK s'))
print(re.findall(r'(aa)', 'aa kkAAK s', re.I))
print(re.findall(r'(aa)', 'aa kkAAK s', re.IGNORECASE))
# 能够多种模式同时生效
print(re.findall(r'(?im)(aa)', 'aa kkAAK s')) # 直接在正则表达式里面写
print(re.findall(r'(aa)', 'aa kkAAK s', re.I | re.M)) # 在参数里面写
print(re.findall(r'(aa)', 'aa kkAAK s', re.I or re.M))
# 预编译正则表达式解析的写法
# romPattern = re.compile(pattern) # 若是不是松散正则表达式,则这样写,即少写 re.VERBOSE 参数
romPattern = re.compile(pattern, re.VERBOSE)
print(romPattern.search('MCMLXXXIX').groups()) # 打印： ('M', 'CM', 'LXXX', 'IX')
print(romPattern.search('MMMDCCCLXXXVIII').groups()) # 打印： ('MMM', 'DCCC', 'LXXX', 'VIII')
# match()、search()、sub()、findall() 等等均可以这样用
match() vs search()
match() 函数只检查 RE 是否在字符串开始处匹配，而 search() 则是扫描整个字符串。记住这一区别是重要的。
match() 只报告一次成功的匹配，它将从 0 处开始；若是匹配不是从 0 开始的， match() 将不会报告它。
search() 将扫描整个字符串，并报告它找到的第一个匹配。
例：
print(re.match('super', 'superstition').span()) # 打印： (0, 5)
print(re.match('super', 'insuperable')) # 打印： None
print(re.search('super', 'superstition').span()) # 打印： (0, 5)
print(re.search('super', 'insuperable').span()) # 打印： (2, 7)
Python标准库:
os 模块
这个模块包含广泛的操做系统功能。若是你但愿你的程序可以与平台无关的话，这个模块是尤其重要的。
os.sep 获取操做系统特定的路径分割符。好比在Linux、Unix下它是'/'，在Windows下它是'\'，而在Mac OS下它是':'。
os.name 字符串指示你正在使用的平台。好比对于Windows，它是'nt'，而对于Linux/Unix用户，它是'posix'。
os.getcwd() 函数获得当前工做目录，即当前Python脚本工做的目录路径。
os.getenv(key) 函数用来读取环境变量。
os.putenv(key, value) 函数用来设置环境变量。
os.listdir(path) 返回指定目录下的全部文件和目录名。
os.remove(filePath) 函数用来删除一个文件。
os.system(shellStr) 函数用来运行shell命令，windows平台则是运行批处理命令。
os.linesep 字符串给出当前平台使用的行终止符。例如，Windows使用'\r\n'，Linux使用'\n'而Mac使用'\r'。
os.path.split(pathname) 函数返回一个路径的目录名和文件名。
os.path.isfile(path) 函数检验给出的路径是否一个文件。
os.path.isdir(path) 函数分别检验给出的路径是否目录。
os.path.existe(path) 函数用来检验给出的路径是否真地存在。
unittest 模块(单元测试)
单元测试的好处：
在编写代码以前，经过编写单元测试来强迫你使用有用的方式细化你的需求。
在编写代码时，单元测试能够使你避免过分编码。当全部测试用例经过时，实现的方法就完成了。
重构代码时，单元测试用例有助于证实新版本的代码跟老版本功能是一致的。
在维护代码期间，可验证代码是否破坏原有代码的状态。
在团队编码中，缜密的测试套件能够下降你的代码影响别人代码的机率，提早发现代码与其余人的不能够良好工做。
单元测试的原则：
彻底自动运行，而不须要人工干预。单元测试几乎是全自动的。
自主判断被测试的方法是经过仍是失败，而不须要人工解释结果。
独立运行，而不依赖其它测试用例(即便测试的是一样的方法)。即，每个测试用例都是一个孤岛。
例：
#### roman1.py 文件的内容 ####
# 定义异常类型(这里仅作范例，不执行什么)
class OutOfRangeError(ValueError): pass
class NotIntegerError(ValueError): pass
roman_numeral_map = (('M', 1000),
('CM', 900), ('D', 500), ('CD', 400), ('C', 100),
('XC', 90), ('L', 50), ('XL', 40), ('X', 10),
('IX', 9), ('V', 5), ('IV', 4), ('I', 1))
# 被测试函数
def to_roman(n):
'''convert integer to Roman numeral'''
# 数值范围判断
if not ( 0 < n < 4000 ):
raise OutOfRangeError('number out of range (must be less than 4000)')
# 类型判断, 内建的 isinstance() 方法能够检查变量的类型
# isinstance(n, int) 与 type(n) is int 等效
if not isinstance(n, int):
raise NotIntegerError('non-integers can not be converted')
result = ''
for numeral, integer in roman_numeral_map:
while n >= integer:
result += numeral
n -= integer
return result
#### 测试文件的内容 ####
import roman1 # 导入被测试的类
import unittest
# 需继承 unittest 模块的TestCase 类。TestCase 提供了不少能够用于测试特定条件的有用的方法。
class KnownValues(unittest.TestCase):
def setUp(self):
"""初始化"""
#执行数据库链接，数据初始化等,此函数可不写
pass
# setUp 和 tearDown 在执行每一个测试函数的先后都会执行
def tearDown(self):
"""销毁"""
pass
# 每个独立的测试都有它本身的不含参数及没有返回值的方法。若是方法不抛出异常而正常退出则认为测试经过;不然，测试失败。
# 测试自己是类一个方法，而且该方法以 test 开头命名。若是不是 test 开头，则不会执行。
def test_to_roman_known_values(self):
# 对于每个测试用例， unittest 模块会打印出测试方法的 docstring ，而且说明该测试失败仍是成功。
# 失败时必然打印docstring, 成功时需使用“-v”命令行参数来查看。
'''to_roman 方法传回的值与用例的数据不相等时,则测试不经过'''
# 测试的用例，通常是全部明显的边界用例。
known_values = ( (1, 'I'), (2, 'II'), (3, 'III'), (4, 'IV'),
(5, 'V'), (6, 'VI'), (7, 'VII'), (8, 'VIII'),
(9, 'IX'), (10, 'X'), (50, 'L'), (100, 'C'),
(500, 'D'), (1000, 'M'), (31, 'XXXI'), (148, 'CXLVIII'),
(3888, 'MMMDCCCLXXXVIII'), (3940, 'MMMCMXL'), (3999, 'MMMCMXCIX') )
for integer, numeral in known_values:
result = roman1.to_roman(integer) # 这里调用真实的方法。若是该方法抛出了异常，则测试被视为失败。
self.assertEqual(numeral, result) # 检查两个值是否相等。若是两个值不一致，则抛出异常，而且测试失败。
self.assertNotEqual(0, result, '这两个值不该该相等') # 检查两个值是否不相等。
self.assertTrue(5 > 0, '5 > 0 都出错，不是吧')
self.assertFalse(5 < 0)
# 对于每个失败的测试用例， unittest 模块会打印出详细的跟踪信息。
# 若是全部返回值均与已知的指望值一致，则 self.assertEqual 不会抛出任何异常，因而这次测试最终会正常退出，这就意味着 to_roman() 经过这次测试。
assert 5 > 0 # 为了更灵活的判断，可以使用 assert
# 测试异常,让被测试的方法抛出异常，这里来验证异常类型。若是预期的异常没有抛出，则测试失败。
def test_over_value(self):
'''参数过大或者太小时, to_roman 方法应该抛出异常信息'''
# assertRaises 方法须要如下参数：你指望的异常、你要测试的方法及传入给方法的参数。
#(若是被测试的方法须要多个参数的话，则把全部参数依次传入 assertRaises， 它会正确地把参数传递给被测方法的。)
self.assertRaises(roman1.OutOfRangeError, roman1.to_roman, 4000)
# 注意是把 to_roman() 方法做为参数传递;没有调用被测方法，也不是把被测方法做为一个字符串名字传递进去
self.assertRaises(roman1.OutOfRangeError, roman1.to_roman, 0)
self.assertRaises(roman1.OutOfRangeError, roman1.to_roman, -1)
# 验证参数类型
def test_non_integer(self):
'''若是参数不是 int 类型时， to_roman 方法应该抛出异常'''
self.assertRaises(roman1.NotIntegerError, roman1.to_roman, 0.5)
self.assertRaises(roman1.NotIntegerError, roman1.to_roman, 6.0)
# 在说明每一个用例的详细执行结果以后， unittest 打印出一个简述来讲明“多少用例被执行了”和“测试执行了多长时间”。
if __name__ == '__main__':
# main 方法会执行每一个测试用例
unittest.main()
with 关键字
从Python 2.5开始有，须要 from future import with_statement。自python 2.6开始，成为默认关键字。
with 是一个控制流语句, 跟 if/for/while/try 之类的是一类的，with 能够用来简化 try finally 代码，看起来能够比 try finally 更清晰。
with obj 语句在控制流程进入和离开其后的相关代码中，容许对象obj管理所发生的事情。
执行 with obj 语句时，它执行 obj.__enter__() 方法来指示正在进入一个新的上下文。当控制流离开该上下文的时候，它就会执行 obj.__exit__(type, value, traceback)。
"上下文管理协议"context management protocol: 实现方法是为一个类定义 __enter__ 和 __exit__ 两个函数。
with expresion as variable的执行过程是，首先执行 __enter__ 函数，它的返回值会赋给 as 后面的 variable, 想让它返回什么就返回什么，若是不写 as variable，返回值会被忽略。
而后，开始执行 with-block 中的语句，不论成功失败(好比发生异常、错误，设置sys.exit())，在with-block执行完成后，会执行__exit__函数。
这样的过程其实等价于：
try:
执行 __enter__()
执行 with_block.
finally:
执行 __exit__()
只不过，如今把一部分代码封装成了__enter__函数，清理代码封装成__exit__函数。
例：
import sys
class test:
def __enter__(self):
print("enter...")
return 1
def __exit__(self,*args):
print("exit...")
return True
with test() as t:
print("t is not the result of test(), it is __enter__ returned")
print("t is 1, yes, it is {0}".format(t))
raise NameError("Hi there")
sys.exit()
print("Never here")
注意:
1) t不是test()的值，test()返回的是"context manager object"，是给with用的。t得到的是__enter__函数的返回值，这是with拿到test()的对象执行以后的结果。t的值是1.
2) __exit__函数的返回值用来指示with-block部分发生的异常是否要 re-raise ，若是返回 False,则会抛出 with-block 的异常，若是返回 True,则就像什么都没发生。
在Python2.5中, file objec t拥有 __enter__ 和 __exit__ 方法，__enter__ 返回 object 本身，而 __exit__ 则关闭这个文件：
要打开一个文件，处理它的内容，而且保证关闭它，你就能够简简单单地这样作：
with open("x.txt") as f:
data = f.read()
do something with data
补充：
数据库的链接好像也能够和with一块儿使用，我在一本书上看到如下内容：
conn = sqlite.connect("somedb")
with conn:
conn.execute("insert into sometable values (?,?)",("foo","bar"))
在这个例子中，commit()是在全部with数据块中的语句执行完毕而且没有错误以后自动执行的，若是出现任何的异常，将执行rollback()
操做，再次提示异常
范例:
1.运行系统命令行
import os
os_command = 'echo haha...'
# 运行命令行,返回运行结果(成功时返回0,失败返回1或以上的出错数字)
result = os.system(os_command)
if result == 0:
print('run Successful')
else:
print('run FAILED')
# 注:os.system()函数不推荐使用,它容易引起严重的错误。(多是由于不具有可移植性)
#os.system(os_command) # 这命令会弹出一个黑乎乎的cmd运行窗口,并且没法得到输出 p = os.popen(os_command) # 捕获运行的屏幕输出，以文件类型接收，再也不另外弹出窗口 print(p.read()) # p 是个文件类型，可按文件的操做
2.获取系统时间
import time,datetime
time.sleep(2) # 时间暂停两秒
print(time.strftime('%Y-%m-%d %H:%M:%S')) # 打印如: 2011-04-13 18:30:10
print(time.strftime('%Y-%m-%d %A %X', time.localtime(time.time()))) # 显示当前日期； 打印如: 2011-04-13 Wednesday 18:30:10
print(time.strftime("%Y-%m-%d %A %X", time.localtime())) # 显示当前日期； 打印如: 2011-04-13 Wednesday 18:30:10
print(time.time()) # 以浮点数形式返回自Linux新世纪以来通过的秒数； 打印如: 1302687844.7
print(time.ctime(1150269086.6630149)) #time.ctime([sec]) 把秒数转换成日期格式，若是不带参数，则显示当前的时间。打印如: Wed Apr 13 21:13:11 2011
# 获得今天的日期
print(datetime.date.today()) # 打印如: 2011-04-13
# 获得前一天的日期
print(datetime.date.today() + datetime.timedelta(days=-1)) # 打印如: 2011-04-12
print(datetime.date.today() - datetime.timedelta(days=1)) # 打印如: 2011-04-14
# 获得10天后的时间
print(datetime.date.today() + datetime.timedelta(days=10)) # 打印如: 2011-04-23
# 获得10小时后的时间，上面的 days 换成 hours
print(datetime.datetime.now() + datetime.timedelta(hours=10)) # 打印如: 2011-04-14 04:30:10.189000
#两日期相减(也能够大于、小于来比较):
d1 = datetime.datetime(2005, 2, 16)
d2 = datetime.datetime(2004, 12, 31)
print((d1 - d2).days) # 打印： 47
#运行时间：
starttime = datetime.datetime.now()
time.sleep(1) # 暂停1秒
endtime = datetime.datetime.now()
print((endtime - starttime).seconds) # 秒, 打印： 1
print((endtime - starttime).microseconds) # 微秒； 打印： 14000
日期格式化符号:
%%: %号自己
%A: 本地星期(全称),如:Tuesday %a: 本地星期(简称),如:Tue
%B: 本地月份(全称),如:February %b: 本地月份(简称),如:Feb
%c: 本地相应的日期表示和时间表示,如:02/15/11 16:50:57
%d: 月内中的一天(0-31),如:15
%H: 24进制小时数(0-23)
%I: 12进制小时数(01-12)
%j: 年内的一天(001-366),如:046
%M: 分钟(00-59),如:50 %m: 月份(01-12),如:02
%p: 上下午(本地A.M.或P.M.的等价符),如:PM
%S: 秒钟(00-59),如:57
%X: 本地的时间,如:16:50:57 %x: 本地的日期,如:02/15/11
%Y: 四位的年(000-9999) %y: 两位数的年份表示(00-99)
%U: 年里的星期数(00-53)从星期天开始,如:07
%W: 年里的星期数(00-53)从星期一开始,如:07
%w: 星期(0-6),星期天为星期的开始,如:2 (星期天为0)
%Z: 当前时区的名称,如:中国标准时间
%z: 当前时区的名称,如:中国标准时间
3.建立目录
import os
pathDir = r'D:\Work' # 不一样系统的目录写法有所不一样
if not os.path.exists(pathDir):
os.mkdir(pathDir) # 建立目录, os.makedirs(pathDir) 建立多个不存在的目录
target = pathDir + os.sep + 'test.txt'
print(target)
# 注意os.sep变量的用法, os.sep 是目录分隔符,这样写方便移植。即在Linux、Unix下它是'/'，在Windows下它是'\'，而在Mac OS下它是':'。
4.文件操做(读写txt文件)
filePath = 'poem.txt'
f = open(filePath, 'w') # 以写的模式打开文件,Python 2.x 需将 open() / io.open() 改为 file()
for a in range( 0, 10 ):
s = "%5d %5d\n" % (a, a*a)
f.write( s ) # 把文本写入文件
f.close() # 关闭io流
f2 = open(filePath) # 没有提供模式，则默认是读取,即 'r'
while True:
line = f2.readline()
if len(line) == 0: # 读取结束
break
print(line, end=' ') # 避免print自动换行, 此行Python2.x应该写：“print line,”
f2.close() # close the file
# 删除文件
import os
os.remove(filePath)
说明:
1、在pythony 3.0 已经废弃了 file 类。
2、pythony 3.0 内置 open() 函数的构造函数是:
open(file, mode="r", buffering=None, encoding=None, errors=None, newline=None, closefd=True)
1.mode(模式):
r: 读，只能读文件，若是文件不存在，会发生异常
w: 写，只能写文件，若是文件不存在，建立该文件；若是文件已存在，先清空，再打开文件
a: 打开供追加
b: 二进制模式；通常是组合写法,如: rb 以二进制读方式打开；wb 以二进制写方式打开
t: 文本模式
+: 打开一个磁盘文件供更新,通常是组合使用,如:
rb+: 以二进制读方式打开，能够读、写文件，若是文件不存在，会发生异常
wb+: 以二进制写方式打开，能够读、写文件，若是文件不存在，建立该文件；若是文件已存在，先清空，再打开文件
u: 通用换行模式
默认的模式是 rt，即打开供读取的文本模式。
2.buffering 关键字参数的指望值是如下三个整数中的一个以决定缓冲策略：
0: 关闭缓冲
1: 行缓冲
> 1: 所填的 int 数=缓冲区大小
默认: 彻底缓冲
3.encoding 默认的编码方式独立于平台。
4.关闭文件描述符 closefd 能够是 True 或 False 。
若是是 False,此文件描述符会在文件关闭后保留。若文件名没法奏效的话，那么必须设为 True 。
3、清空文件内容
f.truncate()
注意：当以 "r+","rb+","w","wb","wb+"等模式时能够执行该功能，即具备可写模式时才能够。
4、文件的指针定位与查询
(1)文件指针：
文件被打开后，其对象保存在 f 中， 它会记住文件的当前位置,以便于执行读、写操做，
这个位置称为文件的指针( 一个从文件头部开始计算的字节数 long 类型 )。
(2)文件打开时的位置:
以"r","r+","rb+" 读方式, "w","w+","wb+"写方式 打开的文件，
一开始，文件指针均指向文件的头部。
(3)获取文件指针的值:
L = f.tell()
(4)移动文件的指针
f.seek(偏移量, 选项) # 偏移量 是 long 或者 int 类型，计算偏移量时注意换行符是2,汉字多是2或3
选项 =0 时， 表示将文件指针指向从文件头部到 "偏移量"字节处。
选项 =1 时， 表示将文件指针指向从文件的当前位置，向后移动 "偏移量"字节。
选项 =2 时， 表示将文件指针指向从文件的尾部，，向前移动 "偏移量"字节。
5、从文件读取指内容
1.文本文件(以"rt"方式打开的文件)的读取
s = f.readline()
返回值： s 是字符串，从文件中读取的一行，含行结束符。
说明: (1)若是 len(s) = 0 表示已到文件尾(换行符也是有长度的,长度为2)
(2)若是是文件的最后一行，有可能没有行结束符
2.二进制文件(以"rb"、"rb+"、"wb+" 方式打开的文件)的读取
s = f.read(n)
说明: (1)若是 len( s ) =0 表示已到文件尾
(2)文件读取后，文件的指针向后移动 len(s) 字节。
(3)若是磁道已坏，会发生异常。
6、向文件写入一个字符串
f.write( s )
参数: s 要写入的字符串
说明: (1)文件写入后，文件的指针向后移动 len(s) 字节。
(2)若是磁道已坏，或磁盘已满会发生异常。
7、经常使用文件操做参考
[1.os]
1.重命名：os.rename(old, new)
2.删除：os.remove(file)
3.列出目录下的文件：os.listdir(path)
4.获取当前工做目录：os.getcwd()
5.改变工做目录：os.chdir(newdir)
6.建立多级目录：os.makedirs(r"c:\python\test")
7.建立单个目录：os.mkdir("test")
8.删除多个目录：os.removedirs(r"c:\python") #删除所给路径最后一个目录下全部空目录。
9.删除单个目录：os.rmdir("test")
10.获取文件属性：os.stat(file)
11.修改文件权限与时间戳：os.chmod(file)
12.执行操做系统命令：os.system("dir")
13.启动新进程：os.exec(), os.execvp()
14.在后台执行程序：osspawnv()
15.终止当前进程：os.exit(), os._exit()
16.分离文件名：os.path.split(r"c:\python\hello.py") --> ("c:\\python", "hello.py")
17.分离扩展名：os.path.splitext(r"c:\python\hello.py") --> ("c:\\python\\hello", ".py")
18.获取路径名：os.path.dirname(r"c:\python\hello.py") --> "c:\\python"
19.获取文件名：os.path.basename(r"r:\python\hello.py") --> "hello.py"
20.判断文件是否存在：os.path.exists(r"c:\python\hello.py") --> True
21.判断是不是绝对路径：os.path.isabs(r".\python\") --> False
22.判断是不是目录：os.path.isdir(r"c:\python") --> True
23.判断是不是文件：os.path.isfile(r"c:\python\hello.py") --> True
24.判断是不是连接文件：os.path.islink(r"c:\python\hello.py") --> False
25.获取文件大小：os.path.getsize(filename)
26.*******：os.ismount("c:\\") --> True
27.搜索目录下的全部文件：os.path.walk()
28.文件的访问时间 : os.path.getatime(myfile) # 这里的时间以秒为单位，而且从1970年1月1日开始算起
29.文件的修改时间: os.path.getmtime(myfile)
[2.shutil]
1.复制单个文件：shultil.copy(oldfile, newfle)
2.复制整个目录树：shultil.copytree(r".\setup", r".\backup")
3.删除整个目录树：shultil.rmtree(r".\backup")
[3.tempfile]
1.建立一个惟一的临时文件：tempfile.mktemp() --> filename
2.打开临时文件：tempfile.TemporaryFile()
[4.StringIO] #cStringIO是StringIO模块的快速实现模块
1.建立内存文件并写入初始数据：f = StringIO.StringIO("Hello world!")
2.读入内存文件数据： print f.read() #或print f.getvalue() --> Hello world!
3.想内存文件写入数据：f.write("Good day!")
4.关闭内存文件：f.close()
[5.glob]
1.匹配文件：glob.glob(r"c:\python\*.py")
5.文件操做(遍历目录和文件名)
import os
import os.path
rootdir = r"D:\Holemar\1.notes\28.Python\test"
# os.walk 返回一个三元组，其中parent表示所在目录, dirnames是全部目录名字的列表, filenames是全部文件名字的列表
for parent,dirnames,filenames in os.walk(rootdir):
# 所在目录
print("parent is:" + parent)
# 遍历此目录下的全部目录(不包含子目录)
for dirname in dirnames:
print(" dirname is:" + dirname)
# 遍历此目录下的全部文件
for filename in filenames:
print(" filename with full path:" + os.path.join(parent, filename))
# 列表显示出某目录下的全部文件及目录(不包括子目录的内容) ls = os.listdir(rootdir)
6.文件操做(分割路径和文件名)
import os.path
#经常使用函数有三种：分隔路径，找出文件名，找出盘符(window系统)，找出文件的扩展名。
spath = "d:/test/test.7z"
# 下面三个分割都返回二元组
# 分隔目录和文件名
p,f = os.path.split(spath) # 注意二元组的接收
print("dir is:" + p) # 打印: d:/test
print(" file is:" + f) # 打印: test.7z
# 分隔盘符和文件名
drv,left = os.path.splitdrive(spath)
print(" driver is:" + drv) # 打印: d:
print(" left is:" + left) # 打印: /test/test.7z
# 分隔文件和扩展名
f,ext = os.path.splitext(spath)
print(" f is: " + f) # 打印: d:/test/test
print(" ext is:" + ext) # 打印: 7z
7.储存器
pickle标准模块。它能够在一个文件中储存任何Python对象，以后又能够把它完好无损地取出来。这被称为 持久地 储存对象。
在pythony 3.0 已经移除了 cPickle 模块，能够使用 pickle 模块代替。
import pickle as p # 这里使用 as 简称,方便更改模块时只需改一行代码 # import cPickle as p # Python 2.x 有这个模块(比pickle快1000倍) # 将会把资料保存在这个文件里面 shoplistfile = 'shoplist.data' # 须要保存的资料 shoplist = ['apple', 'mango', 'carrot', 2, 5] # 写入文件 f = open(shoplistfile, "wb") # 以二进制写入,Python2.x时可不用二进制,但3.x必须 p.dump(shoplist, f) # dump the object to a file f.close() # 取出资料 f = open(shoplistfile, "rb") # 以二进制读取 storedlist2 = p.load(f) print(storedlist2) f.close() # 删除文件 import os os.remove(shoplistfile)
8.url编码操做
import urllib,sys
s = '杭州'
print(urllib.quote(s)) # url 转码,打印如: %E6%9D%AD%E5%B7%9E
print(urllib.unquote('%E6%9D%AD%E5%B7%9E')) # url 解码,打印如: 杭州
# 按所用的编码来转码
print(urllib.quote(s.decode(sys.stdin.encoding).encode('utf8'))) # 打印如: %E6%9D%AD%E5%B7%9E
print(urllib.quote(s.decode(sys.stdin.encoding).encode('gbk'))) # 打印如: %BA%BC%D6%DD
print(urllib.quote(s.decode('gbk').encode('utf8'))) # 指定编码来转码
print(urllib.quote(u'中国'.encode('utf8'))) # unicode编码的，需encode一下；不然中文会出错
# decode就是把其余编码转换为unicode，等同于unicode函数；encode就是把unicode编码的字符串转换为特定编码。
# 一些不但愿被编码的url
print urllib.quote("http://localhost/index.html?id=1") # 打印: http%3A//localhost/index.html%3Fid%3D1
print urllib.quote("http://localhost/index.html?id=1",":?=/") # 打印: http://localhost/index.html?id=1
# 查看
print(u'中国'.__class__) # 打印: <type 'unicode'>
print('中国'.__class__) # 打印: <type 'str'>
9.数据库链接
cx_Oracle : 是一个用来链接并操做 Oracle 数据库的 Python 扩展模块， 支持包括 Oracle 9.2 10.2 以及 11.1 等版本。
安装：
需先oracle安装客户端，并配置环境变量：
ORACLE_HOME＝D:\Oracle\Ora81
PATH=D:\Oracle\Ora81\bin;(其余path的地址)
下载 cx_Oracle 安装包： http://www.python.net/crew/atuining/cx_Oracle/
Oracle 示例：
import cx_Oracle
print(cx_Oracle.version) # 打印出版本信息
# 创建链接, 3种不一样写法
conn = cx_Oracle.connect('username/pwssword@localhost:1521/db_name') # 参数连写
conn = cx_Oracle.connect('username', 'pwssword', 'ip_address:1521/db_name') # 分开3个参数写
dsn_tns = cx_Oracle.makedsn('localhost', 1521, 'db_name')
conn = cx_Oracle.connect('username', 'pwssword', dsn_tns) # 分开5个参数写
MySQLdb : MySQL 数据库的 Python 扩展模块
import MySQLdb
下载地址(tar安装包)： http://sourceforge.net/projects/mysql-python
(exe安装文件) http://www.lfd.uci.edu/~gohlke/pythonlibs/
mongodb:
下载数据库安装文件： http://www.mongodb.org/downloads
import pymongo
其余数据库：
postgresql PostgreSQL psycopg version 1.x, http://initd.org/projects/psycopg1
postgresql_psycopg2 PostgreSQL psycopg version 2.x, http://initd.org/projects/psycopg2
sqlite3 SQLite No adapter needed if using Python 2.5+ Otherwise, pysqlite, http://initd.org/tracker/pysqlite
ado_mssql Microsoft SQL Server adodbapi version 2.0.1+, http://adodbapi.sourceforge.net/
MySQL 示例：
# 0. 导入模块(若是导入出错，说明安装驱动不成功)
import MySQLdb
# 1. 数据库联结，默认host为本机, port为3306(各数据库的链接写法有所不一样)
conn = MySQLdb.connect(host="localhost", port=3306, user="root", passwd="root", db="testdb")
# conn = MySQLdb.Connection(host="localhost", port=3306, user="root", passwd="root", db="testdb") # 与上句同样
# 2. 选择数据库(若是前面尚未选择数据库的话)
conn.select_db('database name')
# 3. 得到cursor
cursor = conn.cursor()
# 4.1 执行SQL，查询和增删改都这样写； 查询返回查询结果的行数，增删改返回影响的行数
cursor.execute("SELECT * FROM tb_member")
# 4.1.1. cursor位置设定及读取结果(仅查询时可这样用)
# cursor.scroll(int, mode) # mode可为相对位置或者绝对位置，分别为relative和absolute。
cursor.scroll(0)
# 4.1.2. Fetch 及 获取结果(每次Fetch,结果集都会下移,下次获取的是剩下的结果集，除非再 cursor.scroll() 移动结果集)
print(cursor.fetchone()) # 获取对应位置的资料,返回一个一维元组,打印如：(1L, 'stu1', 'm')
print(cursor.fetchall()) # 返回结果是个二维元组(全部结果) 打印如：((1L, 'stu1', 'm'), (2L, 'stu2', 'f'))
# 4.2 execute SQL, 返回影响的行数
rows = cursor.execute("delete from tb_member where memid=2")
print(rows) # 返回影响的行数(整数类型), 打印如：1
# 5. 关闭链接
cursor.close()
conn.close()
10.需注意的默认参数
# 默认参数： 若是调用的时候没指定，那它会是函数定义时的引用；
# 所以，默认参数建议使用基本类型；若是不是基本类型，建议写 None,而后在函数里面设默认值
##### 范例1，默认参数若是是 []、{} ，将会影响全局 ########
def t1(a, b = []):
b.append(a)
print('%s %s' % (id(b), b))
t1(1) # 打印： 12523400 [1]
t1(2) # 打印： 12523400 [1, 2]
t1(3, b=[]) # 打印： 12545000 [3]
def t2(a, b = {}):
b[len(b)] = a
print('%s %s' % (id(b), b))
t2(1) # 打印： 12540928 {0: 1}
t2(2) # 打印： 12540928 {0: 1, 1: 2}
t2(3, b={}) # 打印： 11547392 {0: 3}
##### 范例2，若是默认的是其它的函数调用，一样原理，默认值只是函数定义时的引用，后面再也不改变 ########
import time
def cc(a,b = time.time()):print('%s %s' % (a,b))
cc(1) # 打印： 1 1306501851.48
cc(1,b=2) # 打印： 1 2
cc(2) # 打印： 2 1306501851.48
##### 范例3，只是为了更好的理解上述所讲 ########
def aa():
print('aa...')
return []
# 只在函数定义时，执行被调用的 aa(), 后面再也不执行
def bb(a,b = aa()):
b.append(1)
print('%s %s' % (id(b), b))
bb(1) # 打印： 12542840 [1]
bb(2) # 打印： 12542840 [1, 1]
################################################
# 范例4， 为避免上面的出错，正确的写法是这样的：
def t1(a, b = None):
b = b or []
b.append(a)
print('%s %s' % (id(b), b))
def t2(a, b = None):
b = b or {}
b[len(b)] = a
print('%s %s' % (id(b), b))
import time
def cc(a, b = None):
b = b or time.time()
print('%s %s' % (a,b))
随机数
from random import randint # 产生随机整数
for i in xrange(100):
print( randint(10, 90) ) # 产生 10~90 的随机整数- 条件参数列表
在实际开发中，咱们会遇到以下一种需求：- 默认条件有 (a, b, c, d ...)，总之不少。
- 调用者能够传递 (b = False, c = False) 来提供 "非" 条件，其余默认为 True。
- 或者传递 (b = True, c = True)，其余默认为 False。
- 还能够用 (all = True, ...) 来明确指定默认值。
def test(**on):
# 所有条件列表
accept_args = ("a", "b", "c", "d", "e")# 默认条件 default = on.pop("all", None) # 若是没有显式指明默认条件，则检查参数列： # 1. 若是有任何一个 True 条件则默认值为 False。 # 2. 若是所有为 False，则默认值为 True。 if default is None: default = not(True in on.values()) # 使用 setdefault 补全参数字典 for k in accept_args: on.setdefault(k, default) return onprint test(b = False, e = False) # 显示：{'a': True, 'c': True, 'b': False, 'e': False, 'd': True}
print test(c = True) # 显示：{'a': False, 'c': True, 'b': False, 'e': False, 'd': False}
print test(a = True, e = False) # 显示：{'a': True, 'c': False, 'b': False, 'e': False, 'd': False}
print test(all = True, c = False, e = True) # 显示：{'a': True, 'c': False, 'b': True, 'e': True, 'd': True}
print test(all = True, c = False, e = False) # 显示：{'a': True, 'c': False, 'b': True, 'e': False, 'd': True}
print test(all = False, c = True, e = True) # 显示：{'a': False, 'c': True, 'b': False, 'e': True, 'd': False} 断点调试
import pdb; pdb.set_trace() # 运行到这语句，会出现断点输入命令：
命令的详细帮助: h
查看代码上下文, l(小写L)
监视变量: p 变量名
单步执行: n
加入断点: b 行号
跳出断点: c
执行到函数返回前: r修改注册表(使用 _winreg, python3.x是 winreg 模块, 内置模块)
官方的参考文档：
http://docs.python.org/library/_winreg.html
http://www.python.org/doc/2.6.2/library/_winreg.html读取
读取用的方法是OpenKey方法：打开特定的key
hkey = _winreg.OpenKey(key,sub_key,res=0,sam=KEY_READ)
_winreg.CloseKey(hkey) # 关闭以前打开的,若是不关闭则在对象被销毁时关闭例子：
import _winreg
key = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, r"SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\Interfaces{0E184877-D910-4877-B 4C2-04F487B6DBB7}")获取该键的全部键值，遍历枚举
try:
i=0
while 1:
# EnumValue方法用来枚举键值，EnumKey用来枚举子键
print _winreg.EnumValue(key,i) # 打印： (name,value,type)
i+=1
except WindowsError:
print假如知道键名，也能够直接取值
print _winreg.QueryValueEx(key,"ExplorerStartupTraceRecorded") # 打印： (value,type)
建立 修改注册表
建立key：_winreg.CreateKey(key,sub_key)
建立key：_winreg.CreateKeyEx(key, sub_key[, res[, sam]])
删除key: _winreg.DeleteKey(key,sub_key)
删除键值： _winreg.DeleteValue(key,value)
给新建的key赋值： _winreg.SetValue(key,sub_key,type,value)例子：
import _winregkey=_winreg.OpenKey(_winreg.HKEY_CURRENT_USER,r"Software\Microsoft\Windows\CurrentVersion\Explorer")
删除键(没有时会报错)
_winreg.DeleteKey(key, "Advanced")
删除键值(没有时会报错)
_winreg.DeleteValue(key, "IconUnderline")
建立新的项
newKey = _winreg.CreateKey(key,"MyNewkey")
给新建立的项，添加键值(会多一个项:ValueName, 默认的值是ValueContent)
_winreg.SetValue(newKey,"ValueName", _winreg.REG_SZ, "ValueContent")
访问远程注册表
第二参数必须是HKEY_CURRENT_USER、HKEY_LOCAL_MACHINE等预先定义好的值，拿到返回的key后就能够进行操做了
key = _winreg.ConnectRegisty("IP地址或者机器名", _winreg.HKEY_CURRENT_USER)
实例： 修改IE代理服务器
import _winreg # python3 则写 winreg
import ctypes#proxy = "127.0.0.1:8000" proxy = "http=127.0.0.1:8580;https=127.0.0.1:8580;ftp=127.0.0.1:8580" # 代理服务器地址 ProxyOverride = '<local>;192.168.*;127.*' # 不使用代理服务器的IP段，或者域名段，能够用*表明任意长字符串,如: 192.168.* root = _winreg.HKEY_CURRENT_USER proxy_path = r"Software\Microsoft\Windows\CurrentVersion\Internet Settings" hKey = _winreg.OpenKey(root, proxy_path) # value 是代理是否开启的标志，0表示不使用代理，1表示使用 value, type = _winreg.QueryValueEx(hKey, "ProxyEnable") if value: # value 为 0 时 print("本来已使用代理") else: print("本来还没使用代理") # 修改代理设置 hKey = _winreg.CreateKey(root, proxy_path) _winreg.SetValueEx(hKey, "ProxyEnable", 0, _winreg.REG_DWORD, 0) # 最后的参数是代理的开关，0为关闭代理，1为开启 _winreg.SetValueEx(hKey, "ProxyServer", 0, _winreg.REG_SZ, proxy) # 不使用代理服务器的IP段，或者域名段，能够用*表明任意长字符串 _winreg.SetValueEx(hKey, "ProxyOverride", 0, _winreg.REG_SZ, ProxyOverride) _winreg.SetValueEx(hKey, "MigrateProxy", 0, _winreg.REG_DWORD, 1) # 是否全部协议使用相同代理服务器: 0为否，1为是 # 最后，关闭注册表链接 _winreg.CloseKey(hKey) # IE Reload注册表的信息, 由于修改注册表以后, ie不会立刻生效, 须要这一段； 但在win7系统彷佛有点问题 INTERNET_OPTION_REFRESH = 37 INTERNET_OPTION_SETTINGS_CHANGED = 39 internet_set_option = ctypes.windll.Wininet.InternetSetOptionW internet_set_option(0, INTERNET_OPTION_REFRESH, 0, 0) internet_set_option(0, INTERNET_OPTION_SETTINGS_CHANGED, 0, 0)- 修改注册表(使用 win32api, win32con 模块，需安装)
下载和安装模块： http://starship.python.net/crew/mhammond/downloads/
下载像“pywin32-212.6.win32-py2.6.exe”来安装注册表基本项
项名 描述
HKEY_CLASSES_ROOT 是HKEY_LOCAL_MACHINE\Software 的子项，保存打开文件所对应的应用程序信息
HKEY_CURRENT_USER 是HKEY_USERS的子项，保存当前用户的配置信息
HKEY_LOCAL_MACHINE 保存计算机的配置信息，针对全部用户
HKEY_USERS 保存计算机上的全部以活动方式加载的用户配置文件
HKEY_CURRENT_CONFIG 保存计算机的硬件配置文件信息打开注册表
win32api.RegOpenKey(key, subkey, reserved, sam)
win32api.RegOpenKeyEx(key, subkey, reserved, sam)
两个函数的参数用法同样。参数含义以下：
Key：必须为表1中列出的项。
SubKey：要打开的子项。
Reserved：必须为0。
Sam：对打开的子项进行的操做，包括 win32con.KEY_ALL_ACCESS、 win32con.KEY_READ、 win32con.KEY_WRITE 等关闭注册表
win32api.RegCloseKey(key)
其参数只有一个，其含义以下：
Key：已经打开的注册表项的句柄。如：
key = win32api.RegOpenKey(win32con.HKEY_CURRENT_USER, 'Software', 0, win32con.KEY_READ)
print key # 显示： <PyHKEY at 7670448 (220)>
win32api.RegCloseKey(key)
print key # 显示： <PyHKEY at 7670448 (0)>读取项值
win32api.RegQueryValue(key，subKey) # 读取项的默认值；其参数含义以下：
Key：已打开的注册表项的句柄。
subKey：要操做的子项。win32api.RegQueryValueEx(key，valueName) # 读取某一项值；其参数含义以下：
Key：已经打开的注册表项的句柄。
valueName：要读取的项值名称。win32api.RegQueryInfoKey(key) # RegQueryInfoKey函数查询项的基本信息； 返回项的子项数目、项值数目，以及最后一次修改时间
如：
import win32api
import win32con# 打开“HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Internet Explorer”项 key = win32api.RegOpenKey(win32con.HKEY_LOCAL_MACHINE,'SOFTWARE\\Microsoft\\Internet Explorer',0, win32con.KEY_ALL_ACCESS) # 读取项的默认值'' # 输出为空，表示其默认值未设置 print win32api.RegQueryValue(key,'') #读取项值名称为Version的项值数据，也就是Internet Explorer的版本 print win32api.RegQueryValueEx(key,'Version') # 显示如：('6.0.2900.2180', 1) print win32api.RegQueryInfoKey(key) # 查询项的基本信息,显示如：(26, 7, 128178812229687500L)设置项值
win32api.RegSetValue(key，subKey，type，value) # 设置项的默认值
Key：已经打开的项的句柄。
subKey：所要设置的子项。
Type：项值的类型，必须为 win32con.REG_SZ。
Value：项值数据，为字符串。win32api.RegSetValueEx(key，valueName，reserved，type，value) # 要修改或从新设置注册表某一项的项值。若是项值存在，则修改该项值，若是不存在，则添加该项值。
Key：要设置的项的句柄。
valueName：要设置的项值名称。
Reserved：保留，能够设为0。
Type：项值的类型。
Value：所要设置的值。
如：
# 将“HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Internet Explorer”的默认值设为python
win32api.RegSetValue(key,'',win32con.REG_SZ,'python')
# 修改“Version”的值
win32api.RegSetValueEx(key,'Version',0,win32con.REG_SZ,'7.0.2900.2180')- 添加、删除项
win32api.RegCreateKey(key，subKey) # 向注册表中添加项
win32api.RegDeleteKey(key，subKey) # 删除注册表中的项
两个函数的参数用法同样。参数含义以下：
Key：已经打开的注册表项的句柄。
subKey：所要操做（添加或删除）的子项。
如：
# 向“HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Internet Explorer”添加子项“Python”
win32api.RegCreateKey(key,'Python') # 此时会多一个“HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Internet Explorer\Python”
# 删除刚才建立的子项“Python”
win32api.RegDeleteKey(key,'Python') # 没有此项时，会抛出错误实例： 修改IE代理服务器
# 注意，新设置好的代理服务器，不会对以前已经开启的IE起效，只对以后开启的IE有效。
import win32api
import win32con
# 打开“HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Internet Settings”项；代理设置在注册表中的位置
key = win32api.RegOpenKey(win32con.HKEY_CURRENT_USER, r'Software\Microsoft\Windows\CurrentVersion\Internet Settings', 0, win32con.KEY_ALL_ACCESS)
# "ProxyEnable"=dword:00000001 ;是否启用代理服务器，dword:00000001表示开启，dword:00000000表示失效
win32api.RegSetValueEx(key, 'ProxyEnable', 0, win32con.REG_DWORD, 1)
# "ProxyServer"="192.168.0.1:8088" ;代理服务器的地址和端口
win32api.RegSetValueEx(key, 'ProxyServer', 0, win32con.REG_SZ, '127.0.0.1:8000')
# "ProxyOverride"="192.168." ;不使用代理服务器的IP段，或者域名段，能够用表明任意长字符串
win32api.RegSetValueEx(key, 'ProxyOverride', 0, win32con.REG_SZ, '192.168.*')# 想把IE代理去掉，如： win32api.RegSetValueEx(key, 'ProxyEnable', 0, win32con.REG_DWORD, 0) # 最后，关闭注册表链接 win32api.RegCloseKey(key)
多线程
一、函数式：调用thread模块中的start_new_thread()函数来产生新线程。如：
import time
import threaddef timer(no, interval):
cnt = 0
while cnt<10:
print 'Thread:(%d) Time:%s\n'%(no, time.ctime())
#time.sleep(interval)
cnt += 1
# 线程的结束能够等待线程天然结束，也能够在线程函数中调用 thread.exit() 或 thread.exit_thread() 方法。
thread.exit_thread()def test():
# 用 thread.start_new_thread() 来建立两个线程
# thread.start_new_thread(function, args[, kwargs]) 的第一个参数是线程函数；第二个参数是传递给线程函数的参数，它必须是tuple类型；kwargs是可选参数
thread1 = thread.start_new_thread(timer, (1,1))
thread2 = thread.start_new_thread(timer, (2,2))
print '开始运行\n'
time.sleep(1) # 此处若是不睡的话会报错,由于主进程结束而子线程没结束
print '运行结束'if name=='main':
test()
二、建立 threading.Thread 的子类来包装一个线程对象，以下例：
import threading
import time
class timer(threading.Thread): #The timer class is derived from the class threading.Thread
def __init__(self, num, interval):
threading.Thread.__init__(self)
self.thread_num = num
self.interval = interval
self.thread_stop = False
def run(self): #Overwrite run() method, put what you want the thread do here
while not self.thread_stop:
print 'Thread Object(%d), Time:%s\n' %(self.thread_num, time.time())
time.sleep(self.interval)
def stop(self):
self.thread_stop = True
def test():
thread1 = timer(1, 1)
thread2 = timer(2, 2)
thread1.start()
thread2.start()
time.sleep(10)
thread1.stop()
thread2.stop()
return
if __name__ == '__main__':
test()
threading.Thread类的使用：
1，在本身的线程类的__init__里调用threading.Thread.__init__(self, name = threadname) # threadname 为线程的名字
2， run()，一般须要重写，编写代码实现作须要的功能。
3，getName()，得到线程对象名称
4，setName()，设置线程对象名称
5，start()，启动线程
6，jion(timeout=None)，等待另外一线程结束后再运行。若是给出timeout，则最多阻塞timeout秒
7，setDaemon(bool)，设置子线程是否随主线程一块儿结束，必须在start()以前调用。默认为False。
8，isDaemon()，判断线程是否随主线程一块儿结束。
9，isAlive()，检查线程是否在运行中。
此外threading模块自己也提供了不少方法和其余的类，能够帮助咱们更好的使用和管理线程。能够参看http://www.python.org/doc/2.5.2/lib/module-threading.html。
http://www.cnblogs.com/tqsummer/archive/2011/01/25/1944771.html
http://blog.sina.com.cn/s/blog_4b5039210100esc1.html
http://sm4llb0y.blog.163.com/blog/static/18912397200981594357140/
多进程 (从 2.6 起增长了子进程级别的并行开发支持 —— multiprocessing)
!/usr/bin/env python
-- coding:utf-8 --
import os, time
from multiprocessing import *def test(x):
print current_process().pid, x
#time.sleep(1)if name == "main":
print "main:", os.getpid()
p = Pool(5)
p.map(test, range(13)) # 启动13个子进程
time.sleep(1)Process
咱们先从最根本的 Process 入手，看看是如何启动子进程完成并行计算的。上面的 Pool 不过是建立多个 Process，而后将数据(args)提交给多个子进程完成而已。
import os, time
from multiprocessing import *
def test(x):
print current_process().pid, x
time.sleep(1)
if __name__ == "__main__":
print "main:", os.getpid()
p = Process(target = test, args = [100])
p.start()
p.join()
进程监视(windows)
按期监视某进程是否存在，不存在则执行
import os,time
def __Is_Process_Running(imagename):
'''
功能：检查进程是否存在
返回：返回有多少个这进程名的程序在运行，返回0则程序不在运行
'''
p = os.popen('tasklist /FI "IMAGENAME eq %s"' % imagename) # 利用 windows 批处理的 tasklist 命令
return p.read().count(imagename) # p 是个文件类型，可按文件的操做def test():
'''
功能：按期地监视测进程是否还在运行，再也不运行时执行指定代码
'''
while True:
time.sleep(10)
pid = __Is_Process_Running('barfoo.exe')
if pid <= 0:
# code .....
breakif name == "main":
test()程序退出时执行
注册 atexit 函数来解决
若是中途关闭运行窗口，没法调用结束事件
import threading
import time
import atexitdef clean():
print "clean temp data..."def test():
for i in range(10):
name = threading.currentThread().name
print name, i
# time.sleep(1)if name == "main":
atexit.register(clean) # 注册程序结束时执行的函数
threading.Thread(target = test).start()
time.sleep(1)exit(4) # quit() 和 exit() 会等待全部前台线程退出，同时会调用退出函数。 import sys; sys.exit(4) # 和 exit / quit 做用基本相同。等待前台线程退出，调用退出函数。 import os; os._exit(4) # os._exit() 经过系统调用来终止进程的，全部线程和退出函数通通滚蛋。 time.sleep(1) print "Ho ..."
import subprocess
程序退出时执行
经过 subprocess.Popen 函数来解决；但会发生问题，不知道内部是什么缘由
import subprocess
proc = subprocess.Popen("python test.py")
proc.wait()前面的程序结束后，才继续执行下面的代码
test_file = open('test.txt', 'wb')
test_file.write('hello') # 这里的写入偶尔会出问题，不知道缘由
test_file.close()程序退出时执行
import os运行另一个进程
proxy_server = os.popen('cmd.exe /c start "" barfoo_proxy.exe')
等待这个进程结束(实际上是读取程序的输出，但程序若是一直不中止的话，就一直阻塞)，再往下执行
proxy_server.read()
前面的程序结束后，才继续执行下面的代码
test_file = open('test.txt', 'wb')
test_file.write('hello')
test_file.close()杀掉进程(windows)
def kill(pid):
""" kill process by pid for windows """
kill_command = "taskkill /F /T /pid %s" % pid
os.system(kill_command)反射(自省)
dir([obj]): 调用这个方法将返回包含obj大多数属性名的列表（会有一些特殊的属性不包含在内）。obj的默认值是当前的模块对象。
hasattr(obj, attr): 这个方法用于检查obj是否有一个名为attr的值的属性，返回一个布尔值。
getattr(obj, attr): 调用这个方法将返回obj中名为attr的属性对象，或者名为attr的函数, 例如若是attr为'bar'，则返回obj.bar。
setattr(obj, attr, val): 调用这个方法将给obj的名为attr的值的属性赋值为val。例如若是attr为'bar'，则至关于obj.bar = val。
callable(obj): 若是传入的参数是能够调用的对象或函数，则返回 True, 不然返回 False 。例：
# 测试类
class Cat(object):
def init(self, name='kitty'):
self.name = name
def sayHi(self): # 实例方法，sayHi指向这个方法对象，使用类或实例.sayHi访问
print(self.name + 'says Hi!') # 访问名为name的字段，使用实例.name访问cat = Cat('kitty2') print(dir(cat)) # 获取实例的属性名，以列表形式返回 if hasattr(cat, 'name'): # 检查实例是否有这个属性 setattr(cat, 'name', 'tiger') # 至关于: cat.name = 'tiger' print(getattr(cat, 'name')) # 至关于: print(cat.name) getattr(cat, 'sayHi')() # 至关于: cat.sayHi() # 下面这段代码列出对象的全部函数或可调用的对象： methodList = [method for method in dir(cat) if callable(getattr(cat, method))] # globals() 返回一个map，这个map的key是全局范围内对象的名字，value是该对象的实例。 globals().get('Cat')() # 至关于执行: Cat(); 注意，这用法须要导入相应的类，若是不导入，则会抛出异常。 # 解决不能直接导入的问题，使用动态导入 module = __import__('test_lib') # 导入模组, 多重的导入照样使用点运算符, 如: module = __import__('test_lib.test') parser = getattr(module, 'test_fun') # 获取模组里面的对象,能够是函数或者属性或者类 test_attr = getattr(module, 'test_attr') parser() # 获取模组里面的对象若是是函数或者类，可直接调用 print(test_attr) # 调用模组里面的属性 print(dir(module)) # 列表模组里面的全部内容http://www.cnblogs.com/huxi/archive/2011/01/02/1924317.html
http://blog.csdn.net/lokibalder/article/details/3459722@符号修饰函数(有的语言称为:注释)
python 2.4之后，增长了 @符号修饰函数 对函数进行修饰, python3.0/2.6又增长了对类的修饰。
修饰符必须出如今函数定义前一行，不容许和函数定义在同一行。也就是说 @A def f(): 是非法的。class Person: def sayHi(self): # self参数必须写，正常函数的写法 print('Hello, how are you?') @staticmethod # 申明此方法是一个静态方法，外部能够直接调用 def tt(a): # 静态方法，第一个参数不须要用 self print(a) def ff(self): self.sayHi() # 正常方法的调用 self.tt('dd') # 静态方法的调用 p = Person() p.ff() # 正常方法的调用: self参数不需赋值, 必须先 new 出一个类才能够用 Person.tt('a', 'b') # 能够直接调用下面的效果相似于: dec1(dec2(test(arg)))
@dec1
@dec2
def test1(arg):
print(arg)修饰函数还能够带参数, 效果相似于: dec1(arg1,arg2)(test(arg))
@dec1(arg1,arg2)
def test2(arg):
pass范例：
def accepts(types):
def check_accepts(f):
assert len(types) == f.func_code.co_argcount
def new_f(args, **kwds):
for (a, t) in zip(args, types):
assert isinstance(a, t), "arg %r does not match %s" % (a,t)
return f(*args, **kwds)
new_f.func_name = f.func_name
return new_f
return check_acceptsdef returns(rtype):
def check_returns(f):
def new_f(*args, **kwds):
result = f(*args, **kwds)
assert isinstance(result, rtype), "return value %r does not match %s" % (result,rtype)
return result
new_f.func_name = f.func_name
return new_f
return check_returns@accepts(int, (int,float))
@returns((int,float))
def func(arg1, arg2):
return arg1 * arg2
http://www.python.org/dev/peps/pep-0318/
http://blog.csdn.net/pythoner/article/details/2823260
垃圾回收
import gc
gc.collect() # 显示调用垃圾回收gc.disable() # 关闭垃圾回收,当程序须要大量内存时可调用这语句,避免频繁的垃圾回收而影响效率
gc.enable() # 开启垃圾回收- 利用 Python 搭建一个简单的 Web 服务器,快速实现局域网内文件共享。
- cd 到准备作服务器根目录的路径下(这目录下的文件将会被共享)
运行命令：
python -m Web服务器模块[端口号，默认8000]
这里的“Web服务器模块”有以下三种：
BaseHTTPServer: 提供基本的Web服务和处理器类，分别是HTTPServer和BaseHTTPRequestHandler。
SimpleHTTPServer: 包含执行GET和HEAD请求的SimpleHTTPRequestHandler类。
CGIHTTPServer: 包含处理POST请求和执行CGIHTTPRequestHandler类。运行如: python -m SimpleHTTPServer 8080
能够在浏览器中访问:
http://$HOSTNAME:端口号/路径
内置变量
all
这是一个字符串列表,定义在一个模块出口时使用 from
没有定义此语句，则 import * 默认的行为是导入全部的符号不如下划线开始的对象。
例如： a1.py 的内容以下: __all__=['b','c'] a='aaa' b='bbb' c='ccc' b1.py 的内容以下: import a1 from a1 import * print a1.a # 正常打印 print b # 正常打印 print a # 报错了,变量未定义
call
类的调用
只要定义类的时候，实现 call 函数，这个类型就成为可调用的。
换句话说，咱们能够把这个类型的对象看成函数来使用，至关于 重载了括号运算符。
del
del 类名 # 调用对象的 del 方法
doc
docstring
例： print(Person.__doc__) # 打印类的docstring print(Person.func_name.__doc__) # 打印类的方法的docstring
file
当前代码所在的Python模块的文件名。
例： import os, sys print( os.path.dirname(os.path.realpath(__file__)) ) # 获取当前目录 print( os.path.dirname(os.path.dirname(os.path.realpath(__file__))) ) # 获取上一层目录 print( os.path.dirname(os.path.abspath(sys.argv[0])) ) # 获取当前目录, sys.argv[0] 与 __file__ 同样显示当前文件名 print( os.getcwd() ) # 获取当前目录 print( os.path.abspath(os.curdir) ) # 获取当前目录 print( os.path.abspath( '. ') ) # 获取当前目录, 打印会加上点号，如： /home/holemar/project/ppf_web/.
init
类的构造方法
例：
class Human(object):
def __init__(self, name):
print(name)
class Person(Human): # Person 类继承 Human 类
def __init__(self, name):
self.name = name # 对象的变量,每一个对象独立的
super(Person, self).__init__(name) # 调用父类的 __init__ 方法,但这样的调用要求父类必须继承 object 类,或者继承其它的类
Human.__init__(self, "province") # 这样调用父类的 __init__ 方法也能够
name
每一个Python模块都有它的__name__，若是它是'main'，这说明这个模块被用户单独运行，咱们能够进行相应的恰当操做。
例:
if __name__ == '__main__':
print('This program is being run by itself')
else:
print('I am being imported from another module')
version
版本信息
例如:
__version__ = '2.6.26'
print( tuple(int(i) for i in __version__.split('.')) ) # 打印: (2, 6, 26)
print( float(__version__) ) # 报错
运算符,如大于、小于、等于、加减乘除, 等等
class Field(object):
def init(self, value):
self.value = value
# 小于: x < y, y > x
def __lt__(self, value):
print('__lt__ 被调用啦...')
return self.value < value
# 小于等于: x <= y, y >= x
def __le__(self, value):
return self.value <= value
# x > y, y < x
def __gt__(self, value):
return self.value > value
# x >= y, y <= x
def __ge__(self, value):
return self.value >= value
# 等于: x == y
def __eq__(self, value):
return self.value == value
# 不等于: x != y, x <> y
def __ne__(self, value):
return self.value != value
# 加: x + y
def __add__(self, value):
return str(self.value) + ' + ' + str(value)
# y + x
def __radd__(self, value):
return str(value) + ' + ' + str(self.value)
# 减: x - y
def __sub__(self, value):
return str(self.value) + ' - ' + str(value)
# y - x
def __rsub__(self, value):
return str(value) + ' - ' + str(self.value)
# 乘: x * y
def __mul__(self, value):
return str(self.value) + ' × ' + str(value)
# y * x
def __rmul__(self, value):
return str(value) + ' × ' + str(self.value)
# 除: x / y
def __div__(self, value):
return str(self.value) + ' ÷ ' + str(value)
# y / x
def __rdiv__(self, value):
return str(value) + ' ÷ ' + str(self.value)
# 整除: x // y
def __floordiv__(self, value):
return str(self.value) + ' // ' + str(value)
# y // x
def __rfloordiv__(self, value):
return str(value) + ' // ' + str(self.value)
# python2里面不知道怎么调用这个函数,但python3没有了 __div__,除的时候直接调用此函数
def __truediv__(self, value):
return str(self.value) + ' / ' + str(value)
def __rtruediv__(self, value):
return str(value) + ' / ' + str(self.value)
# 单元运算符
# ~x
def __invert__(self):
return '~' + str(self.value)
# -x
def __neg__(self):
return '-' + str(self.value)
# +x
def __pos__(self):
return '+' + str(self.value)
# x[y]
def __getitem__(self, value):
return 'this[' + str(value) + ']'
# x[y] = z
def __setitem__(self, key, value)
self[key] = value
# del x[y]
def __delitem__(self, value):
del self[value]
# x[y:z]
def __index__(self, y, z):
return self[y:z]
# 遍历
def __iter__(self):
pass
# y in x
def __contains__(self, value): # in 判断,只能返回 True / False
return False
# x.name
#def __getattribute__(self, value): # 覆盖此方法后,调用 self.value 会引发死循环
# return 'this.' + str(value)
# 被特定函数调用时
# len(x) ,返回值必须大于或等于0
def __len__(self):
return 1
# str(x) ,返回值必须是字符串
def __str__(self):
return str(self.value)
# unicode(x)
def __unicode__(self):
return unicode(self.value)
# abs(x)
def __abs__(self):
return abs(self.value)
# hash(x)
def __hash__(self):
return hash(self.value)
# hex(x)
def __hex__(self):
return hex(self.value)
# int(x)
def __int__(self):
return int(self.value)
# long(x)
def __long__(self):
return long(self.value)
# float(x)
def __float__(self):
return float(self.value)
# oct(x)
def __oct__(self):
return oct(self.value)
# cmp(x, y)
def __cmp__(self, value):
return cmp(self.value, value)
# coerce(x, y)
def __coerce__(self, value):
return coerce(self.value, value)
# divmod(x, y)
def __divmod__(self, value):
return divmod(self.value, value)
# divmod(y, x)
def __rdivmod__(self, value):
return divmod(self.value, value)
# pow(x, y[, z])
def __pow__(self, value):
return pow(self.value, value[, z])
# pow(y, x[, z])
def __rpow__(self, value):
return pow(self.value, value[, z])
# repr(x])
def __repr__(self, value):
return repr(self.value)
# size of S in memory, in bytes
def __sizeof__(self, value):
return 1
a = Field(32)
print(a < 12) # 调用 a 的 __lt__
print(12 > a) # 调用 a 的 __lt__
print(a >= 17)
print(a != 15)
print(a == 32)
print(a + 8) # 调用 a 的 __add__
print(8 + a) # 调用 a 的 __radd__
print(a * 8) # 调用 a 的 __mul__
print(8 * a) # 调用 a 的 __rmul__
print(a / 8) # python2时, 调用 a 的 __div__； python3时调用 __truediv__
print(~a)
print(-a)
print(+a)
#print(a.name2)
print(a['name3'])
print('name' in a)
print(len(a)) # 调用 a 的 __len__
print(str(a)) # 调用 a 的 __str__
运算符表：
二元运算符 特殊方法
+ __add__,__radd__
- __sub__,__rsub__
* __mul__,__rmul__
/ __div__,__rdiv__,__truediv__,__rtruediv__
// __floordiv__,__rfloordiv__
% __mod__,__rmod__
** __pow__,__rpow__
<< _lshift__,__rlshift__
>> __rshift__,__rrshift__
& __and__,__rand__
^ __xor__,__rxor__
| __or__,__ror__
+= __iaddr__
-= __isub__
*= __imul__
/= __idiv__,__itruediv__
//= __ifloordiv__
%= __imod__
**= __ipow__
<<= __ilshift__
>>= __irshift__
&= __iand__
^= __ixor__
|= __ior__
== __eq__
!=,<> __ne__
> __gt__
< __lt__
>= __ge__
<= __le__
内置变量 end
内置函数
import(name[, globals[, locals[, fromlist[, level]]]])
被 import 语句调用的函数。它的存在主要是为了你能够用另一个有兼容接口的函数 来改变 import 语句的语义.
abs(x)
返回一个数的绝对值。参数也许是一个普通或长整型，或者一个浮点数。若是参数是一个复数，返回它的模。
all(iterable)
若是迭代的全部元素都是真就返回真。版本2.5中新增.
any(iterable)
若是迭代中有一个元素为真就返回真。版本2.5中新增.
basestring()
这个抽象类型是str和unicode的父类。它不能被调用或初始化，可是它能够使用来测试一个对象是不是str或unicode的实例。 isinstance(obj, basestring)等价于 isinstance(obj, (str, unicode)) 版本2.3中新增.
bool([x])
将一个值转换为 Boolean,使用标准的真测试程序。若是x是假或忽略了，将返回 False;不然将返回 True.bool也是一个 class，它是 int 的一个子类，bool类不能进一步子类化。它仅有 False 和 True 两个实例。
callable(object)
若是 object 参数是能够调用的函数或者类就返回 True,不然返回 False 。返回 True,仍可能调用失败，但返回 False,就不可能调用成功。
可调用对象包括函数、方法、代码对象、类和已经定义了“ call()”方法的类实例。
如： a="123"; callable(a) 返回0; callable(chr) 返回1
chr(i)
返回一个ascii码是整数i的字符的字符串。例如: chr(97)返回'a'.这和 ord()恰好相反。这参数在[0..255]之间,所有包含。若是超出这个范围，就抛出 ValueError
classmethod(function)
返回函数的一个类方法。一个类方法接收类做为它的第一个潜在参数，就像一个实例方法接收一个实例。
类方法不一样于C++或Java的静态方法。若是你想这样作，使用 staticmethod()。
cmp(x, y)
根据比较两介对象x和y的结果，返回一个整数。若是x<y,返回-1,若是x==y,返回0，若是 x > y,根据比较结果返回一个正数.
coerce(number1, number2)
(能够当作一个数值类型转换函数)有两个参数，都是数字，返回这两个数字的一个列表，将这两个数字的数据类型统一。python3去掉这函数。
如: coerce(1,2j)，返回(1+0j,2j)
compile(string, filename, kind[, flags[, dont_inherit]])
编译 string 为一个代码对象。代码对象可以经过 exec 语句执行或者经过调用 eval()计算。
这filename参数指定代码从哪一个文件读取。若是不从文件中读取，就须传递一些可识别的值(一般使用'
kind参数指定哪一种代码被编译;若是是包含一系列语句组成的子符串能够‘exec’,若是是由一个表达式组成，就'eval',若是由一个交互语句组成就‘singlw’(在后面的例子，表达式语句计算的结果不是 None 将打印出来)。
当编译一个多行语句时，应用两个警告：必须以' '做为行结束符，同时输入必须至少以一个' '做为结束。若是是以' '做为行结束，使用 string 的 repalce() 方法将其改成‘ ’.
可先的参数flags和dont_inherit控制影响 string 编译的 future 语句。更详细的请参考英文文档。
complex([real[, imag]])
可把字符串或数字转换为复数。
建立一个复数real + imag*j或者将一个 string 或者 number 转化为一个复数.
若是第一个参数是一个字符串,它将做为复数解释，函数将被调用，而忽略第二个参数。第二个参数不多是一个字符串。每个参数均可能是一个数字类型包括复数.若是imag省略了, 它默认为0，函数将看成一个数字转换函数像 int(), long() and float().若是参数都省略了，将返回0j.
delattr(object, name)
与 setattr()相对的，参数是一个对象和一个 string. string 必须是对象的一个属性。函数删除object这个名为 string 的属性。例如: delattr(x, 'foobar')等价于 del x.foobar
dict([arg])
返回一个字典。
例如，下面全部返回都等价于{"one": 2, "two": 3}:
dict({'one': 2, 'two': 3})
dict({'one': 2, 'two': 3}.items())
dict({'one': 2, 'two': 3}.iteritems())
dict(zip(('one', 'two'), (2, 3)))
dict([['two', 3], ['one', 2]])
dict(one=2, two=3)
版本2.2中新增.
dir([object])
列出模块定义的标识符。标识符有函数、类和变量。
当参数为一个模块名的时候，它返回模块定义的名称列表。若是不提供参数，它返回当前模块中定义的名称列表。
注:由于 dir()主要在交互提示下方便使用，它尝试提供一给有意思的名字而不是尝试提供严格的或与定义同样的名字,在relrase中它的细节行为也许会改变。
divmod(a, b)
函数完成除法运算，返回商和余数。
如： divmod(10,3) 返回(3, 1); divmod(9,3) 返回(3, 0)
enumerate(iterable)
返回 enumerate 对象. iterable 必须是一个序列, 一个迭代, 或者其它对象它支持迭代.
enumerate()返回的 iterator 的 next()方法 返回一个元组包含必定的数目(从0开始)和从迭代中获取的对应的值。
enumerate() 对于获取一个索引系列颇有用: (0, seq[0]), (1, seq[1]), (2, seq[2]), .... 版本2.3中新增.
eval(expression[, globals[, locals]])
该参数是一个字符串和可选的 globals 和 locals 。若是提供 globals,globals 必须是一个字典。若是提供 locals,locals 能够是任何映射对象。2.4版本修改：之前 locals 被要求是一个字典。
expression参数是做为一个Python表达式被分析和评价(技术上来讲，一个条件列表)使用 globals 以及 locals 字典做为 global 和 local 名字空间。
若是提供了 globals 字典但没有'builtins'，当前 globals 在表达式被分析前被复制到 globals 中。这意味着表达式能够彻底访问标准 builtin 模块和受限的环境。若是 locals 字典省略则默认为 globals 字典。若是两个字典都被省略，表达式在调用 eval 的环境中执行。返回值是计算表达式的结果。语法错误报告为 exceptions 。
此函数也能够用来执行任意代码的对象(如 compile()建立的)。在这种状况下，传入一个代码对象，而不是一个字符串。该代码对象必须已编译传给'eval'做为这种参数。
提示： exec 语句支持是动态执行语句。 execfile()函数支持从一个文件中执行语句。 globals()和 locals()函数分别返回当前的 global 和 local 字典，这对使用 eval()或 execfile()颇有帮助。
execfile(filename[, globals[, locals]])
这个功能相似于 exec 语句，但分析一个文件，而不是一个字符串。这是不一样之处在于它的 import 语句不使用模块管理 - 它无条件读取文件，并不会建立一个新的 module 。
该参数是一个文件名和两个可选字典。该文件被做为Python语句序列(相似于一个模块)使用 globals 和 locals 做为 global and local 命名空间来分析和计算。若是提供 locals,locals 能够是任何映射对象。2.4版本修改：之前 locals 被要求是一个字典。若是 locals 字典省略则默认为全局字典。若是两个字典都被省略，表达式 execfile()被调用的环境中执行。返回值为 None 。
警告：默认的locals为下面的locals()：不要尝试修改默认的本地词典。若是你须要看到在函数execfile()返回后locals代码的的影响，传递一个明确的locals字典。 execfile()不能用于依赖修改函数的locals。
file(filename[, mode[, bufsize]])
文件类型的构造函数，文件对象。构造函数的参数与下面的内建的 open() 函数是同样的。
当打开一个文件，它是最好使用的 open()，而不是直接调用此构造函数。文件更适合检验类型(例如，isinstance(f, file))。
filter(function, iterable)
把一个函数应用于序列中的每一个项，并返回该函数返回真值时的全部项，从而过滤掉返回假值的全部项。
function 返回 True 时从iterable的元素中构造一个列表。迭代能够是一个序列，一个支持迭代的容器，或一个迭代器，若是Iterable的是一个字符串或一个元组，其结果也有这种类型的，不然它始终是一个列表。若是 function 是 None, 假定它是恒等函数，即，迭代是 False 其全部元素都被删除。
请注意， filter(function,iterable)，若是函数不为 None 等价于[item for item in iterable if function(item)]，若是函数为 None 等价于[item for item in iterable if item]。
float( [x])
将字符串或数字转换或一个浮点数。若是参数是一个字符串，它必须包含一个可能带符号的十进制或浮点数，可能嵌入空格。不然，参数能够是一个普通或长整数或浮点数，返回一个与之相同值的浮点数(在Python的浮点精度内)。若是没有给出参数，返回0.0。
注意：当传递一个字符串，可能会返回 NaN 和 Infinity，这取决于底层C库。
float(x)
把一个数字或字符串转换成浮点数。
frozenset([iterable])
返回一个frozenset对象，其元素来自于Iterable。 Frozensets组没有更新的方法，但能够哈希和其余组成员或做为字典键使用。一个frozenset的元素必须是不可改变。内部sets也应是frozenset对象。若是迭代没有指定，返回一个新的空集，frozenset ([])。 版本2.4中新增
getattr(object, name[, default])
返回object名为name属性的值。名称必须是一个字符串。若是该字符串是对象的其中属性名字，结果是该属性的值。例如，getattr(x, 'foobar')至关于x.foobar。若是指定的属性不存在，则返回默认提供的，不然抛出AttributeError。
globals()
返回表明当前 global 符号表字典的字典。这始终是当前模块字典(在一个函数或方法内，是在它被定义的模块，而不是被调用的模块)。
hasattr(object, name)
该参数是一个对象和一个字符串。若是字符串是对象的其中一个属性，结果为 True,若是没有返回 False 。 (这是经过调用的 getattr(对象名称)，看是否引起异常与否。)
hash(object)
返回对象(若是有的话)的哈希值。哈希值是整数。它们被用来在词典查找时，做为一个快速比较字典keys键。具备相同的哈希值，数值相等(即便它们属于不一样的类型，由于是1和1.0的状况)。
help([object])
调用内置的帮助系统。(此功能是为交互使用。)若是没有给出参数，交互式帮助系统启动解释控制台。若是参数是一个字符串，而后是字符串被做为一个module，function，class，method，keyword或文档主题名称和帮助页面名字进行查找后在控制台上打印出来。若是参数是任何其余类型的对象，将产生该对象的一个帮助页面。 版本2.2中新增.
hex(x)
转换一个(任意大小)整数为十六进制字符串。其结果是一个有效的Python表达式。在2.4版本变动：原只产生一个无符号的文字。
id(object)
返回对象的内存地址。
这是一个整数(或长整型)，这是保证是惟一的，与对象的生命周期同样长。两个非重叠的生命周期的对象可能有相同的 ID 值。
input([prompt])
警告：此函数是不安全的，由于用户错误的输入！它期待一个有效的Python表达式做为输入，若是输入语法上是无效的，将抛出SyntaxError。若是地计算过程当中有一个的错误，将抛出其余exceptions。 (另外一方面，有时这是你为特殊使用须要写一个快速脚本。)
若是readline模块被加载，input()将使用它来提供详细行编辑和历史特性。
考虑使用 raw_input() 函数做为从用户进行通常输入。
python3.x 开始有所变化
int([x[, radix]])
转换为字符串或数字为纯整数。若是参数是一个字符串，它必须包含一个可能有符号的十进制数做为一个Python整数，可能嵌入空格。
以radix参数给出的基数为基础进行转换(这是默认10)，能够是任何在[2，36]范围内的整数，或零。若是基数为零，根据字符串的内容猜想正确的基数。若是指定的基数x是否是一个字符串，引起TypeError异常。不然，参数能够是一个普通或长整数或浮点数。转换浮点数截断为整数(直到零)。若是参数是整数范围以外的，将返回一个long object。若是没有给出参数，返回0
isinstance(object, classinfo)
测试对象类型。返回 True 若是该object参数是classinfo的一个实例，或其(直接或间接)子类的实例。也返回 True 若是classinfo是一种type对象(new-style class)和是该类型或其(直接或间接)子类的对象。若是object不是class一个的实例或者给定类型的对象，函数返回 False 。若是 classinfo 既不是一个类的对象也不是一个 type 的对象，它多是一个包含类或类型的对象的 tuple, 也可能包含其余的递归元组(序列类型不接受)。若是 classinfo 不是一个类，类型或元组类，类型，或者这种元组，将抛出一个 TypeError 异常。
自: type(obj) is classinfo 等效于 isinstance(object, classinfo)
type(obj) in (int, long, float) 等效于 isinstance(object, (int, long, float)) # 多种类型的判断
issubclass(class, classinfo)
返回true若是class是classinfo(直接或间接)的子类。一个类被认为是本身的子类。 classinfo多是类对象元组，在这种状况下元组中的每一个classinfo项将被进行测试。在其余任何状况下，抛出一个TypeError异常。
iter(o[, sentinel])
返回一个迭代器对象。第一个参数有不一样的解释，视第二个参数的存在与否而定。若是没有第二个参数，o必须是一个对象的集合，支持迭代协议(iter()方法)，或者它必须支持序列协议(以整数0开始的参数__getitem__()方法)。若是它不支持这些协议，将抛出TypeError异常。若是第二个参数，sentinel，给出，而后o必须是可调用的对象。在这种状况下创造的每个迭代器无参调用o它的 next()方法，若是返回值等于sentinel，将抛出StopIteration，不然将返回其它的值。
len(s)
返回一个对象的长度。参数能够是一个序列(字符串，元组或列表)或映射(词典)。
list([iterable])
返回一个列表的items与可迭代的项目相同的顺序且相同的items。
iterable 能够是一个序列，一个容器，支持迭代，或一个迭代器对象。若是 iterable 已是一个列表，将返回一个副本，相似的于iterable[:]。
例如，list('abc')返回['a', 'b', 'c']和list( (1, 2, 3) ) 返回[1，2，3]。若是没有给出参数，返回一个新的空列表，[]。
locals()
更新并返回一个表明当前local符号表的字典。警告：本词典的内容不该该被修改，更改可能不会影响由interpreter用做局部变量的值。
long([x[, radix]])
转换字符串或数字为一个长整数。若是参数是一个字符串，它必须包含一个任意大小的可能有符号的数字，并有可能嵌入空格。radix参数解释和int()同样，并且只能当x是一个字符串时才须要它。不然，参数能够是一个普通或长整数或浮点数，返回与其相同值的长整数。转换浮点数到截断的整数(直到零)。若是没有给出参数，返回0L。
map(function, iterable, ...)
应用function在iterable的每个项上并返回一个列表。若是有其余可迭代的参数，函数必须采起许多参数应用于来自全部iterables项。若是一个迭代比另外一个短，将以None进行扩展。若是function是None，将假设为identity function，若是有多个参数，map()返回一个列表包含全部iterables相应的项目的元组组成。可迭代的参数多是一个序列或任何可迭代的对象，结果老是一个列表。
max(iterable[, args...][key])
一个Iterable参数，返回其中一个最大的非空可迭代项，(如一个字符串，元组或列表)。若有多个参数，返回最大的参数。
可选的key参数指定带一个参数的排序函数，用于list.sort()。key参数，若是有，必须在以keyword的形式(例如，"max(a,b,c,key=func)")。
min(iterable[, args...][key])
一个Iterable参数，返回其中一个最小的非空可迭代项，(如一个字符串，元组或列表)。若有多个参数，返回最小的参数。
可选的key参数指定带一个参数的排序函数，用于list.sort()。key参数，若是有，必须在以keyword的形式(例如，"max(a,b,c,key=func)")。
object()
返回一个新特征的对象。object是全部new style class的基类。它的方法是新样式类的全部实例共有的。
oct(x)
转换一(任意大小)整数到一个八进制字符串。其结果是一个有效的Python表达式。
open(filename[, mode[, bufsize]])
打开一个文件，返回一个在3.9节中描述的文件类型的对象，`File Objects'。若是文件没法打开，IOError异常引起。当打开一个文件，最好调用open()，而不是直接用file构造。
前两个参数与stdio的 fopen()函数同样：filename是要打开的文件名，mode是一个字符串，表示该文件是如何被打开。
mode，最经常使用的值是'r'读，'w'写(文件若是已存在就截断)，和'a'追加(在一些Unix系统意味着全部写入追加到文件尾部，不管其如今的seek位置)。若是模式被省略，默认为'r'等。当打开一个二进制文件，你应该模式值加上'b'，打开二进制模式，从而提升可行性。 (在某些不区分二进制文件和文本文件的系统追加‘b’，，它将做为文档)。下面是mode的可能值：
可选bufsize参数指定文件的所需缓冲区大小：0表示无缓冲，1表示行缓冲，任何其余的正数使用其大小(在约)的一个缓冲区。负数bufsize，使用系统默认，这tty设备一般使用行缓冲和其余文件的彻底缓冲。若是省略，使用系统默认。
模式'r+', 'w+'和'a+'打开文件进行更新(请注意，'w+'截断该文件)。附加'b'的模式在区分二进制和文本文件的系统上以二进制方式打开文件，系统上没有这个区别，加入了'b'没有效果。
ord(c)
返回一个字符串参数的ASCII码或Unicode值。给定一个长度为1的字符串，返回一个整数，当参数是一个Unicode对象，表明字符的 Unicode 代码，或参数是一个8位字符串，表明其字节值。
例如，ord('a')返回整数97，ord(u'\u2020')返回8224。这是8位串chr()和用于Unicode对象的unichr()的逆函数。若是给出Unicode参数和Python是UCS2 Unicode的，字符的代码点必须在范围[0 .. 65535]内，不然字符串的长度是2，抛出一个 TypeErro 。
pow(x, y[, z])
返回x的Y次方，若是给出z，返回x的y次方，模Z(比pow(x, y) % z更有效)的。这两个参数的形式pow(x, y)，至关于：x ** y
property([fget[, fset[, fdel[, doc]]]])
返回一个new-style类(从object派生的类)的属性。
fget是一个获取属性值的function，一样fset是设置属性值的function，fdel为删除属性的函数。典型的用途是定义一个托管属性x：
range([start,] stop[, step])
函数可按参数生成连续的有序整数列表。
这是一个通用函数来建立包含算术级数的列表，这是常用于循环。该参数必须是普通整数。若是step参数被省略，默认为1。若是省略start参数，默认为0。完整形式是返回一个普通整数列表[start, start + step, start + 2 * step, ...]。step不能为零(不然引起ValueError)。
raw_input([prompt])
若是prompt参数存在，它被写入到标准输出，结尾没有换行。而后函数从输入行读取，将其转换为一个字符串(去掉换行)，后返回。当为EOF，抛出EOFError。例如：
若是的ReadLine模块被加载，而后raw_input()将使用它来提供详细行编辑和历史特性。
reduce(function, iterable[, initializer])
使用带两参数的函数从左到右计算iterable的项，reduce这iterable获得一个数字。(累计计算结果，直到计算完全部项)
例如: reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) 就是计算 ((((1+2)+3)+4)+5)。
左参数x，是累加值和右边的参数，y，是iterable中更新的值。若是可选的initializer存在，在计算中摆在可迭代的项的前面，当iterable为空时，做为默认。若是没有给出initializer，则只包含一项，返回第一项。
reload(module)
从新导入先前导入的模块。该参数必须是一个模块对象，所以它以前必须已成功导入。若是您使用外部编辑器编辑源文件的模块，并想不离开Python解释器尝试新版本,这是有用的。返回值是模块对象(与module参数相同的值)。
repr(object)
返回一个字符串，其中包含一个对象的可打印形式。有时是对可以访问一个普通的函数的操做颇有用。对于许多类型，该函数使得试图返回一个字符串，会产生一个对象与传递给 eval() 相同的值产生的对象同样。
reversed(seq)
返回一个反向迭代器。seq必须是一个支持序列协议的对象(len()方法和__getitem__()以0开始的整数参数的方法) 版本2.4中新增
round(x[, n])
返回浮点值x四舍五入到小数点后n位后数字。若是n被省略，默认为零。结果是一个浮点数。
set([iterable])
返回其元素都是从iterable获得的set。元素必须是不可改变的。若是iterable没有指定，返回一个新的空集，设置([]). 版本2.4中新增
setattr(object, name, value)
与getattr()相对应。该参数是一个对象，一个字符串和一个任意值。该字符串能够是现有属性名称或一个新的属性。函数分配给该属性值，只要该对象容许的话。例如，setattr(x, 'foobar', 123)，至关于x.foobar = 123。
slice([start,] stop[, step])
返回一个切片对象，它表示的是range(start, stop, step)指定的范围。start和step参数默认为None。切片对象有只读数据属性start，stop和step，它只是返回参数值(或默认)。没有其余明确的功能，但它们的做为数值Python和其余第三方扩展使用。当使用扩展索引语法时也产生切片对象。例如：“a[start:stop:step]”或“a[start:stop, i]”。
sorted( iterable[, cmp[, key[, reverse]]])
返回一个新的排序的列表，包含Iterable的项。
可选参数cmp，key，reverse与list.sort()具相同涵义(详见第3.6.4)。
cmp指定带两个参数(Iterable的元素)，返回自一个负数，零或正数的函数“cmp=lambda x,y: cmp(x.lower(), y.lower())“。
key指定带一个参数的函数，用来从列表每一个元素中提取一个比较key：“key=str.lower”
reverse是一个布尔值。若是设置为True，则对列表中的元素进行排序，同时每一次比较都是逆向的。
通常而言，key和reverse转换过程是远远快于指定一个至关于cmp的功能。这是由于cmp是为每一个列表元素调用不少次，而key和reverse接触每一个元素只有一次。
版本2.4中新增
staticmethod( function)
函数返回一个静态方法。静态方法没有接收一个隐含的第一个参数。要声明一个静态方法，以下：
class C:
@staticmethod
def f(arg1, arg2, ...): ...
@staticmethod 形式 是一个function decorator 它便可以在类上如C.f()进行调用，也能够在实例上，如：C().f()。实例被忽略，除了类。 在Python静态方法相似于Java或C++的。对于更先进的概念，见classmethod()。
str([object])
返回对象的可打印字符串。对于字符串，这将返回字符串自己。
与 repr(object)不一样的是， str(object)并不老是试图返回一个 eval()能够接受的字符串，其目标是返回一个可打印字符串。若是没有给出参数，返回空字符串''。
sum(iterable[, start])
求start和可迭代的从左至右的项和并返回总和。start默认为0。在可迭代的项，一般是数字，不能是字符串。快速，正确的链接的字符串序列的方法是经过调用''.join(sequence)。注意sum(range(n), m)至关于reduce(operator.add, range(n), m)。 版本2.3中新增.
super(type[, object-or-type])
返回类型的超类。若是第二个参数被省略，返回的超级对象是未绑定。若是第二个参数是一个对象，isinstance(obj, type)必须是true。若是第二个参数是一个类型，issubclass(type2, type)必须是true。super() 只能用于新型类。
请注意，super是做为显式的点属性绑定过程查找的一部分，例如“super(C, self).__getitem__(name)”。所以，super是未定义对于使用语句或操做进行隐式的查找，如“super(C, self)[name]”。 版本2.2中新增.
tuple([iterable])
把序列对象转换成 tuple 。返回一个元组的items与可迭代的iterable是相同的且有相同的顺序。iterable多是一个序列，容器支持迭代，或迭代器对象。若是iterable是元组，直接返回。
例如，tuple('abc')返回('a', 'b', 'c') 和tuple([1, 2, 3])返回(1, 2, 3)。若是没有给出参数，返回一个新的空元组，()。
type(object)
返回对象的类型。返回值是一个类型对象。
type(name, bases, dict)
返回一个新的类型的对象。这基本上是类声明的动态形式。该name字符串是类名，成为__name__的属性;bases元组详细列明了基类，并成为__bases__的属性，以及dict字典是命名空间定义为类体，成为 dict 属性。
版本2.2中新增.
unichr(i)
返回一个Unicode码为整数i的字符的Unicode字符串。例如，unichr(97)返回字符串u'a'。这是Unicode字符串的 ord()的逆函数。参数的有效范围取决于Python如何被配置 - 它能够是UCS2 [0 .. 0xFFFF的]或UCS4 [0 .. 0x10FFFF]。不然引起ValueError。 版本2.0中新增
unicode([object[, encoding [, errors]]])
返回object的Unicode版本字符串，使用下列方式之一：
若是给出encoding和/或errors，Unicode()将解码能够是一个8位字符串或使用encoding解码器字符缓冲区的对象。编encoding参数是一个编码名称的字符串;若是encoding不知道，抛出LookupError。错误处理是根据errors，errors指定字符是在输入编码无效时的处理方案。若是错误是'strict'(默认)，引起ValueError，而'ignore'将忽略错误，以及'replace'值的致使官方Unicode替换字符，U+FFFD，用来取代输入的不能解码的字符。另见编解码器模块。
若是没有可选参数，Unicode()将模仿 str()，但它返回Unicode字符串，而不是8位字符串。更确切地说，若是对象是一个Unicode字符串或其子类将返回不带任何附加解码的Unicode字符串。
对于对象提供 unicode()方法，它将不带参数调用这种方法来建立一个Unicode字符串。对于其余全部对象，8位字符串版本或请求representation，使用编码'strict'模式的默认编解码器转换为Unicode字符串。
vars([object])
若是没有参数，根据如今的local符号表返回一个字典。若是是一个模块，类或类的实例对象做为参数(或其它任何有__dict__属性)，根据对象的符号表返回一个字典。返回的字典不该被被修改：在相应符号表上的影响是未定义的。
xrange([start,] stop[, step])
与 range()相似，但 xrnage()并不建立列表，而是返回一个xrange对象，它的行为与列表类似，可是只在须要时才计算列表值，当列表很大时，这个特性能为咱们节省内存。
这个功能很是相似于range()，但返回一个'xrange object'而不是一个列表。这是一个不透明的序列类型，包含相应的列表相同的值而实际上没有储存这些值。xrange的优点()比range()是很小的(xrange()仍是要创造请求的值)，除非使用一个很是大的范围内存的机器或全部元素历来没有使用过(例如循环一般是被打破终止的)。
注：xrange()是为了简单和快速而设计的。施加了必定的限制，以实现这一目标。 Python的C语言实现限制全部参数的为native C longs(“short”Python整数)，并要求在这些elements都与native C long兼容。
zip([iterable, ...]) 把两个或多个序列中的相应项合并在一块儿，并以元组的格式返回它们，在处理完最短序列中的全部项后就中止。 例如： zip([1,2,3],[4,5],[7,8,9]) 返回： [(1, 4, 7), (2, 5, 8)] 若是参数是一个序列，则zip()会以一元组的格式返回每一个项，如： zip([1,2,3,4,5]) 返回： [(1,), (2,), (3,), (4,), (5,)] 不带参数，它返回一个空列表。
- 1. kafka 笔记九 kafka 消息重复
- 2. 复习笔记
- 3. 汇编语言-复习笔记记录(重难点)
- 4. 【笔记】MySQL删除重复记录保留一条
- 5. Struts2复习笔记
- 6. Sturts2复习笔记
- 7. Windows复习笔记
- 8. Java复习笔记
- 9. mysql 复习笔记
- 10. Redis复习笔记
- 更多相关文章...
- • MySQL DISTINCT：去重（过滤重复数据） - MySQL教程
- • ASP.NET Razor - 标记 - ASP.NET 教程
- • Tomcat学习笔记（史上最全tomcat学习笔记）
- • Docker容器实战(六) - 容器的隔离与限制
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. No provider available from registry 127.0.0.1:2181 for service com.ddbuy.ser 解决方法
- 2. Qt5.7以上调用虚拟键盘(支持中文)，以及源码修改(可拖动，水平缩放)
- 3. 软件测试面试- 购物车功能测试用例设计
- 4. ElasticSearch（概念篇）：你知道的, 为了搜索…
- 5. redux理解
- 6. gitee创建第一个项目
- 7. 支持向量机之硬间隔（一步步推导，通俗易懂）
- 8. Mysql 异步复制延迟的原因及解决方案
- 9. 如何在运行SEPM配置向导时将不可认的复杂数据库密码改为简单密码
- 10. windows系统下tftp服务器使用
- 1. kafka 笔记九 kafka 消息重复
- 2. 复习笔记
- 3. 汇编语言-复习笔记记录(重难点)
- 4. 【笔记】MySQL删除重复记录保留一条
- 5. Struts2复习笔记
- 6. Sturts2复习笔记
- 7. Windows复习笔记
- 8. Java复习笔记
- 9. mysql 复习笔记
- 10. Redis复习笔记