13518219792
1.常用内置函数：(不用import就可以直接使用)
让客户满意是我们工作的目标，不断超越客户的期望值来自于我们对这个行业的热爱。我们立志把好的技术通过有效、简单的方式提供给客户，将通过不懈努力成为客户在信息化领域值得信任、有价值的长期合作伙伴，公司提供的服务项目有：空间域名、虚拟空间、营销软件、网站建设、北票网站维护、网站推广。
help(obj) 在线帮助, obj可是任何类型
callable(obj) 查看一个obj是不是可以像函数一样调用
repr(obj) 得到obj的表示字符串，可以利用这个字符串eval重建该对象的一个拷贝
eval_r(str) 表示合法的python表达式，返回这个表达式
dir(obj) 查看obj的name space中可见的name
hasattr(obj,name) 查看一个obj的name space中是否有name
getattr(obj,name) 得到一个obj的name space中的一个name
setattr(obj,name,value) 为一个obj的name space中的一个name指向vale这个object
delattr(obj,name) 从obj的name space中删除一个name
vars(obj) 返回一个object的name space。用dictionary表示
locals() 返回一个局部name space,用dictionary表示
globals() 返回一个全局name space,用dictionary表示
type(obj) 查看一个obj的类型
isinstance(obj,cls) 查看obj是不是cls的instance
issubclass(subcls,supcls) 查看subcls是不是supcls的子类
类型转换函数
chr(i) 把一个ASCII数值,变成字符
ord(i) 把一个字符或者unicode字符,变成ASCII数值
oct(x) 把整数x变成八进制表示的字符串
hex(x) 把整数x变成十六进制表示的字符串
str(obj) 得到obj的字符串描述
list(seq) 把一个sequence转换成一个list
tuple(seq) 把一个sequence转换成一个tuple
dict(),dict(list) 转换成一个dictionary
int(x) 转换成一个integer
long(x) 转换成一个long interger
float(x) 转换成一个浮点数
complex(x) 转换成复数
max(...) 求最大值
min(...) 求最小值
用于执行程序的内置函数
complie 如果一段代码经常要使用,那么先编译,再运行会更快。
2.和操作系统相关的调用
系统相关的信息模块 import sys
sys.argv是一个list,包含所有的命令行参数.
sys.stdout sys.stdin sys.stderr 分别表示标准输入输出,错误输出的文件对象.
sys.stdin.readline() 从标准输入读一行 sys.stdout.write("a") 屏幕输出a
sys.exit(exit_code) 退出程序
sys.modules 是一个dictionary，表示系统中所有可用的module
sys.platform 得到运行的操作系统环境
sys.path 是一个list,指明所有查找module，package的路径.
操作系统相关的调用和操作 import os
os.environ 一个dictionary 包含环境变量的映射关系 os.environ["HOME"] 可以得到环境变量HOME的值
os.chdir(dir) 改变当前目录 os.chdir('d:\\outlook') 注意windows下用到转义
os.getcwd() 得到当前目录
os.getegid() 得到有效组id os.getgid() 得到组id
os.getuid() 得到用户id os.geteuid() 得到有效用户id
os.setegid os.setegid() os.seteuid() os.setuid()
os.getgruops() 得到用户组名称列表
os.getlogin() 得到用户登录名称
os.getenv 得到环境变量
os.putenv 设置环境变量
os.umask 设置umask
os.system(cmd) 利用系统调用，运行cmd命令
操作举例：
os.mkdir('/tmp/xx') os.system("echo 'hello' /tmp/xx/a.txt") os.listdir('/tmp/xx')
os.rename('/tmp/xx/a.txt','/tmp/xx/b.txt') os.remove('/tmp/xx/b.txt') os.rmdir('/tmp/xx')
用python编写一个简单的shell
#!/usr/bin/python
import os, sys
cmd = sys.stdin.readline()
while cmd:
os.system(cmd)
cmd = sys.stdin.readline()
用os.path编写平台无关的程序
os.path.abspath("1.txt") == os.path.join(os.getcwd(), "1.txt")
os.path.split(os.getcwd()) 用于分开一个目录名称中的目录部分和文件名称部分。
os.path.join(os.getcwd(), os.pardir, 'a', 'a.doc') 全成路径名称.
os.pardir 表示当前平台下上一级目录的字符 ..
os.path.getctime("/root/1.txt") 返回1.txt的ctime(创建时间)时间戳
os.path.exists(os.getcwd()) 判断文件是否存在
os.path.expanduser('~/dir') 把~扩展成用户根目录
os.path.expandvars('$PATH') 扩展环境变量PATH
os.path.isfile(os.getcwd()) 判断是否是文件名，1是0否
os.path.isdir('c:\Python26\temp') 判断是否是目录,1是0否
os.path.islink('/home/huaying/111.sql') 是否是符号连接 windows下不可用
os.path.ismout(os.getcwd()) 是否是文件系统安装点 windows下不可用
os.path.samefile(os.getcwd(), '/home/huaying') 看看两个文件名是不是指的是同一个文件
os.path.walk('/home/huaying', test_fun, "a.c")
遍历/home/huaying下所有子目录包括本目录,对于每个目录都会调用函数test_fun.
例：在某个目录中，和他所有的子目录中查找名称是a.c的文件或目录。
def test_fun(filename, dirname, names): //filename即是walk中的a.c dirname是访问的目录名称
if filename in names: //names是一个list,包含dirname目录下的所有内容
print os.path.join(dirname, filename)
os.path.walk('/home/huaying', test_fun, "a.c")
文件操作
打开文件
f = open("filename", "r") r只读 w写 rw读写 rb读二进制 wb写二进制 w+写追加
读写文件
f.write("a") f.write(str) 写一字符串 f.writeline() f.readlines() 与下read类同
f.read() 全读出来 f.read(size) 表示从文件中读取size个字符
f.readline() 读一行,到文件结尾,返回空串. f.readlines() 读取全部，返回一个list. list每个元素表示一行，包含"\n"\
f.tell() 返回当前文件读取位置
f.seek(off, where) 定位文件读写位置. off表示偏移量，正数向文件尾移动，负数表示向开头移动。
where为0表示从开始算起,1表示从当前位置算,2表示从结尾算.
f.flush() 刷新缓存
关闭文件
f.close()
regular expression 正则表达式 import re
简单的regexp
p = re.compile("abc") if p.match("abc") : print "match"
上例中首先生成一个pattern(模式),如果和某个字符串匹配，就返回一个match object
除某些特殊字符metacharacter元字符，大多数字符都和自身匹配。
这些特殊字符是 。^ $ * + ? { [ ] \ | ( )
字符集合(用[]表示)
列出字符,如[abc]表示匹配a或b或c,大多数metacharacter在[]中只表示和本身匹配。例：
a = ".^$*+?{\\|()" 大多数metachar在[]中都和本身匹配，但"^[]\"不同
p = re.compile("["+a+"]")
for i in a:
if p.match(i):
print "[%s] is match" %i
else:
print "[%s] is not match" %i
在[]中包含[]本身，表示"["或者"]"匹配.用
和
表示.
^出现在[]的开头,表示取反.[^abc]表示除了a,b,c之外的所有字符。^没有出现在开头，即于身身匹配。
-可表示范围.[a-zA-Z]匹配任何一个英文字母。[0-9]匹配任何数字。
\在[]中的妙用。
\d [0-9]
\D [^0-9]
\s [ \t\n\r\f\v]
\S [^ \t\n\r\f\v]
\w [a-zA-Z0-9_]
\W [^a-zA-Z0-9_]
\t 表示和tab匹配, 其他的都和字符串的表示法一致
\x20 表示和十六进制ascii 0x20匹配
有了\，可以在[]中表示任何字符。注：单独的一个"."如果没有出现[]中，表示出了换行\n以外的匹配任何字符,类似[^\n].
regexp的重复
{m,n}表示出现m个以上(含m个),n个以下(含n个). 如ab{1,3}c和abc,abbc,abbbc匹配，不会与ac,abbbc匹配。
m是下界，n是上界。m省略表下界是0,n省略，表上界无限大。
*表示{,} +表示{1,} ?表示{0,1}
最大匹配和最小匹配 python都是最大匹配，如果要最小匹配，在*,+,?,{m,n}后面加一个?.
match object的end可以得到匹配的最后一个字符的位置。
re.compile("a*").match('aaaa').end() 4 最大匹配
re.compile("a*?").match('aaaa').end() 0 最小匹配
使用原始字符串
字符串表示方法中用\\表示字符\.大量使用影响可读性。
解决方法：在字符串前面加一个r表示raw格式。
a = r"\a" print a 结果是\a
a = r"\"a" print a 结果是\"a
使用re模块
先用re.compile得到一个RegexObject 表示一个regexp
后用pattern的match,search的方法,得到MatchObject
再用match object得到匹配的位置,匹配的字符串等信息
RegxObject常用函数:
re.compile("a").match("abab") 如果abab的开头和re.compile("a")匹配，得到MatchObject
_sre.SRE_Match object at 0x81d43c8
print re.compile("a").match("bbab")
None 注：从str的开头开始匹配
re.compile("a").search("abab") 在abab中搜索第一个和re_obj匹配的部分
_sre.SRE_Match object at 0x81d43c8
print re.compile("a").search("bbab")
_sre.SRE_Match object at 0x8184e18 和match()不同,不必从开头匹配
re_obj.findall(str) 返回str中搜索所有和re_obj匹配的部分.
返回一个tuple,其中元素是匹配的字符串.
MatchObject的常用函数
m.start() 返回起始位置,m.end()返回结束位置(不包含该位置的字符).
m.span() 返回一个tuple表示(m.start(), m.end())
m.pos(), m.endpos(), m.re(), m.string()
m.re().search(m.string(), m.pos(), m.endpos()) 会得到m本身
m.finditer()可以返回一个iterator,用来遍历所有找到的MatchObject.
for m in re.compile("[ab]").finditer("tatbxaxb"):
print m.span()
高级regexp
| 表示联合多个regexp. A B两个regexp，A|B表示和A匹配或者跟B匹配.
^ 表示只匹配一行的开始行首,^只有在开头才有此特殊意义。
$ 表示只匹配一行的结尾
\A 表示只匹配第一行字符串的开头 ^匹配每一行的行首
\Z 表示只匹配行一行字符串的结尾 $匹配第一行的行尾
\b 只匹配词的边界 例：\binfo\b 只会匹配"info" 不会匹配information
\B 表示匹配非单词边界
示例如下：
print re.compile(r"\binfo\b").match("info ") #使用raw格式 \b表示单词边界
_sre.SRE_Match object at 0x817aa98
print re.compile("\binfo\b").match("info ") #没有使用raw \b表示退格符号
None
print re.compile("\binfo\b").match("\binfo\b ")
_sre.SRE_Match object at 0x8174948
分组(Group) 示例：re.compile("(a(b)c)d").match("abcd").groups() ('abc', 'b')
#!/usr/local/bin/python
import re
x = """
name: Charles
Address: BUPT
name: Ann
Address: BUPT
"""
#p = re.compile(r"^name:(.*)\n^Address:(.*)\n", re.M)
p = re.compile(r"^name:(?P.*)\n^Address:(?P.*)\n", re.M)
for m in p.finditer(x):
print m.span()
print "here is your friends list"
print "%s, %s"%m.groups()
Compile Flag
用re.compile得到RegxObject时，可以有一些flag用来调整RegxObject的详细特征.
DOTALL, S 让.匹配任意字符,包括换行符\n
IGNORECASE, I 忽略大小写
LOCALES, L 让\w \W \b \B和当前的locale一致
MULTILINE, M 多行模式，只影响^和$(参见上例)
VERBOSE, X verbose模式
Python 支持四种不同的数值类型：
整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。
长整型(long integers) - 无限大小的整数，整数最后是一个大写或小写的L。
浮点型(floating point real values) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102= 250）
复数(complex numbers) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。
在Phton中常见的运算加、减、乘、除、求余、幂指数等，同现实生活中的遵循一样的优先级。即，乘除运算高于加减运算。例：
Python内置复数的计算支持所有常见复数的计算，对复数处理的数学函数在模块cmath中：
字符串或串(String)是由数字、字母、下划线组成的一串字符。Python字符串最大的特点是 不可修改， 只能生成新的字符串，用 双引号或单引号 都可以表示字符串，多行字符串用三个连续单引号表示，特殊字符用转义符 “\" 表示如： 制表符"\t",换行符"\n"
str='Hello World!'
print str*2 # 输出字符串两次
Hello World!Hello World!
print str+"TEST" # 输出连接的字符串
Hello World!TEST
len('str') #输出字符串的长度
12
python的 字串列表 有2种取值顺序:
从左到右索引默认0开始的，最大范围是字符串长度少1
从右到左索引默认-1开始的，最大范围是字符串开头
如果你要实现从字符串中获取一段子字符串的话，可以使用变量 [头下标:尾下标] ，就可以截取相应的字符串，其中下标是从 0 开始算起，可以是正数或负数，下标可以为空表示取到头或尾。比如:
s = 'ilovepython'
s[1:5] 的结果是 love。
当使用以冒号分隔的字符串，python返回一个新的对象，结果包含了以这对偏移标识的连续的内容，左边的开始是包含了下边界。
上面的结果包含了s[1]的值l，而取到的最大范围不包括上边界，就是s[5]的值p。
'abcd'[3:1:-1] #从右到左
'dc'
一些高级操作：
s='You are my sunshine'
s.split(' ')
['You' ,'are', 'my' ,'sunshine']
t=['one','for','two']
' '.join(t)
'one for two'
t='Mike and Tom'
t.replace('Tom','jane')
'Mike and jane'
python变量的概念和初中代数的方程变量一致，变量就像贴在东西上的标签，命名规则：大小写英文、数字和下划线，且不能用数字开头，变量可以反复赋值，而且可以是不同类型的变量
序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。
Python有6个序列的内置类型，但最常见的是列表和元组。
序列都可以进行的操作包括索引，切片，加，乘，检查成员。
此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。
列表 是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。
列表的数据项不需要具有相同的类型
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。
[] #创建空的列表
[]
list() #创建空的列表
[]
alist=['physics','chemistry',1997,2000]
['physics','chemistry',1997,2000]
List（列表） 是 Python 中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（即嵌套）。
列表用[ ]标识，是 python 最通用的复合数据类型。
列表中值的切割也可以用到变量[头下标:尾下标]，就可以截取相应的列表，从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标可以为空表示取到头或尾。
list=['runoob', 786, 2.23, 'john', 70.2]
tinylist=[123, 'john']
print list # 输出完整列表
['runoob', 786, 2.23, 'john', 70.2]
'runoob' in alist #某个元素是否存在
True
print list[0] # 输出列表的第一个元素
runoob
print list[1:3] # 输出第二个至第三个元素
[786,2.23]
print list[2:] # 输出从第三个开始至列表末尾的所有元素
[2.23,'john',70.2]
print tinylist*2 # 输出列表两次
[123,'john',123,'john']
print list+tinylist # 打印组合的列表
['runoob',786,2.23,'john',70.2,123,'john']
Python的元组 与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
() #创建空的元组
()
tuple() #创建空的元组
()
元组中只包含一个元素时，需要在元素后面添加逗号如：tup1=(50,);
tup=(1,True,0.234,"holle")
同列表相似 元组 适用：
+ ：链接两个元组
* ：复制n次，生成新的元组
in ：某个元素是否存在
[start:end:step] ：切片
值得注意的是元组是不可以更新的（ 不可变） 序列，但我们可以对元组进行连接组合生成新的元组如：
tup1=(12,34.56)
tup2=('abc','xyz')
tup3= tup1+tup2
print tup3
(12,34.56,'abc','xyz')
任意无符号的对象，以逗号隔开，默认为元组。
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值(key=value)对用冒号( : )分割，每个对之间用逗号( , )分割，整个字典包括在花括号( {}) 中 ,格式如下所示：
d= {key1:value1,key2:value2}
键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
字典是可变类型，可以添加，删除，替换
偏函数是将所要承载的函数作为partial()函数的第一个参数，原函数的各个参数依次作为partial()函数后续的参数，除非使用关键字参数。
通过语言描述可能无法理解偏函数是怎么使用的，那么就举一个常见的例子来说明。在这个例子里，我们实现了一个取余函数，对于整数100，取得对于不同数m的100%m的余数。
参数offset--开始的偏移量，也就是代表需要移动偏移的字节数whence：可选，默认值为0。
给offset参数一个定义，表示要从哪个位置开始偏移；0代表从文件开头开始算起，1代表从当前位置开始算起，2代表从文件末尾算起。
file.seek(off,whence=0)：从文件中移动off个操作标记（文件指针），正往结束方向移动，负往开始方向移动。
如果设定了whence参数，就以whence设定的起始位为准，0代表从头开始，1代表当前位置，2代表文件最末尾位置。
1、Python类型操作符和内建函数总结
表4.5列出了所有操作符和内建函数，其中操作符顺序是按优先级从高到低排列的。同一种灰度的操作符拥有同样的优先级。注意在operator模块中有这些（和绝大多数Python)操作符相应的同功能的函数可供使用。
表4.5 标准类型操作符和内建函数
操作符/函数
描 述
结 果a
字符串表示
``
对象的字符串表示
str
内建函数
cmp(obj1, obj2)
比较两个对象
int
repr(obj)
对象的字符串表示
str
str(obj)
对象的字符串表示
str
type(obj)
检测对象的类型
type
值比较
小于
bool
大于
bool
=
小于或等于
bool
=
大于或等于
bool
==
等于
bool
!=
不等于
bool
不等于
bool
对象比较
is
是
bool
is not
不是
bool
布尔操作符
not
逻辑反
bool
and
逻辑与
bool
or
逻辑或
bool
2、Python数值类型操作符和内建函数
一、工厂函数
数值工厂函数总结类（工厂函数） 操作
bool(obj) b 返回obj对象的布尔值，也就是 obj.__nonzero__()方法的返回值。
int(obj, base=10) 返回一个字符串或数值对象的整数表 示， 类似string.atoi();
从Python 1.6起， 引入了可选的进制参数。
long(obj, base=10) 返回一个字符或数据对象的长整数表 示，类似string.atol(),
从Python1.6起， 引入了可选的进制参数 float(obj) ，
返回一个字符串或数据对象的浮点数 表示，类似string.atof()。
complex(str) or返回一个字符串的复数表示，或 者根据给定的实数，
complex(real, imag=0.0) （及一个可选 的虚数部分）生成一个复数对象。
二、内建函数
1、分类
Python 有五个运算内建函数用于数值运算：
abs(num), coerce(num1,num2), divmod(num1,num2), pow(num1,num2,mod=1)和 round(flt,ndig=0)
其中abs()返回给定参数的绝对值。如果参数是一个复数， 那么就返回math.sqrt(num.real2 + num.imag2).
coerce()是一个数据类型转换函数，不过它的行为更像一个运算符.数coerce（）为程序员提供了不依赖Python 解释器，而是自定义两个数值类型转换的方法。对一种新创建的数值类型来说， 这个特性非常有用.函数coerce()仅返回一个包含类型转换完毕的两个数值元素的元组.
divmod()内建函数把除法和取余运算结合起来, 返回一个包含商和余数的元组.对整数来说，它的返回值就是地板除和取余操作的结果.对浮点数来说，返回的商部分是math.floor(num1/num2)，对复数来说，商部分是ath.floor((num1/num2).real).
pow()它和双星号 （**）运算符都可以进行指数运算.不过二者的区别并不仅仅在于一个是运算符，一个是内建函数.在Python 1.5 之前，并没有 ** 运算符,内建函数pow()还接受第三个可选的参数，一个余数参数.如果有这个参数的， pow() 先进行指数运算，然后将运算结果和第三个参数进行取余运算.这个特性主要用于密码运算，并且比 pow(x,y) % z 性能更好， 这是因为这个函数的实现类似于C 函数pow(x,y,z).
round()用于对浮点数进行四舍五入运算。它有一个可选的小数位数参数.如果不提供小数位参数， 它返回与第一个参数最接近的整数（但仍然是浮点类型）.第二个参数告诉round 函数将结果精确到小数点后指定位数.
2、函数int()/round()/math.floor()它们之间的不同之处：
函数 int()直接截去小数部分.（返回值为整数）
函数 floor() 得到最接近原数但小于原数的整数.（返回值为浮点数）
函数 round() 得到最接近原数的整数.（返回值为浮点数）
3、进制转换函数:
返回字符串表示的8 进制和16 进制整数,它们分别是内建函数：
oct()和 hex(). oct(255)='0377'/hex(255)='0xff'
函数chr()接受一个单字节整数值(0到255)，返回一个字符串(ASCII)，其值为对应的字符.chr(97)='a'
函数ord()则相反，它接受一个字符(ASCII 或 Unicode)，返回其对应的整数值.ord('A')=65
3、Python字符串函数
(一)标准类型操作符和标准内建函数
1)、标准类型操作符
,,=,=,==,!=,对象值得比较
注：做比较时字符串是按ASCII值的大小来比较的
is 对象身份比较
and,or,not 布尔类型
2）标准内建函数
type(obj)
cmp(obj1,obj2)
str(obj)和repr(obj) 或反引号运算符(``) 可以方便的以字符串的方式获取对象的
内容、类型、数值属性等信息。str()函数得到的字符串可读性好， 而repr()函数得到的字符
串通常可以用来重新获得该对象, 通常情况下 obj == eval(repr(obj)) 这个等式是成立的
isinstance(obj,type) 判断对象的类型
(二)序列操作
1、序列操作
字符串属于序列对象，可以使用所有序列的操作和函数
切片 [] [:] [::]
简单总结：
*索引（S[i])获取特定偏移的元素。
——第一个元素偏移为0
——（S[0])获取第一个元素。
——负偏移索引意味着从最后或右边反向进行计数
——（S[-2])获取倒数第二个元素（就像S[len(s)-2]一样
*分片[S[i:j]提取对应的部分作为一个序列
——右边界不包含在内
——分片的边界默认为0和序列的长度，如果没有给出的话S[:]
——（S[1:3])获取了从偏移为1，直到但不包括偏移为3的元素
——（S[1:])获取从偏移为1到末尾之间的元素
——（S[:3])获取从偏移为0直到但不包括偏移为3的元素
——（S[:-1])获取从偏移为0直到但不包括最后一个元素之间的元素
——（S[:])获取从偏移为0到末尾之间的元素,这有效地实现了顶层S拷贝
拷贝了一个相同值，但是是不同内存区域的对象。对象字符串这样不可变的对象不是很有用，但是对于可以实地修改的对象来说很有用。
比如列表。
扩展分片：第三个限制值 【步进】
完整形式：X[I:J:K]:这标识索引X对象的元素，从偏移为I直到J-1，每隔K元素索引一次。第三个限制值，K，默认为1
实例
Python Code
1
2
3
4
5
S='abcdefghijk'
S[1:10]
'bcdefghij'
S[1:10:2]
'bdfhj
也可以使用负数作为步进。
分片表达式
Python Code
1
2
"hello"[::-1]
'olleh'
通过负数步进，两个边界的意义实际上进行了反转。
3、成员操作符 in ，not in
返回布尔值True 或False
可以使用string模块来判断输入字符的合法性，可见成品中的idcheck.py
4、字符串连接
+ 连接字符串 ‘name’+' '+'jin'
字符串格式化 '%s %s' % ('name','jin')
join()方法 ' '.join(('name','jin')) ' '.join(['name','jin'])
5、删除清空字符串
del aString
aString=''
(三)、序列函数
序列类型函数
len(str) 返回字串的长度
enumerate(iter):接受一个可迭代对象作为参数，返回一个enumerate
max(str)/min(str):max()和min()函数对其他的序列类型可能更有用,但对于string类型它们能很好地运行,返回最大或者最小的字符(按照ASCII 码值排列),
zip([it0, it1,... itN]) 返回一个列表，其第一个元素是it0,it1,...这些元素的第一个元素组成的一个元组，第二个...,类推.
reversed(seq)c 接受一个序列作为参数,返回一个以逆序访问的迭代器(PEP 322)
sorted(iter,func=None,key=None,reverse=False) 接受一个可迭代对象作为参数，返回一个有序的列表;可选参数func,key 和reverse 的含义跟list.sort()内建函数的参数含义一样.
注意：
sorted等需要在原处修改的函数无法用在字符串对象，但可以产生新的对象
sum处理的对象是数字，不能用在字符串
sorted(s)
['a', 'e', 'e', 'g', 'g', 'g', 'o']
(四)只适合于字符串类型的函数
1)raw_input()函数
内建的raw_input()函数使用给定字符串提示用户输入并将这个输入返回，下面是一个使
用raw_input()的例子:
user_input = raw_input("Enter your name: ")
prin user_input
2)str() and unicode()
str()和unicode()函数都是工厂函数，就是说产生所对应的类型的对象.它们接受一个任
意类型的对象，然后创建该对象的可打印的或者Unicode 的字符串表示. 它们和basestring 都
可以作为参数传给isinstance()函数来判断一个对象的类型
3)chr(), unichr(), and ord()
chr()函数用一个范围在range(256)内的(就是0 到255)整数做参数,返回一个对应的字符.unichr()跟它一样，只不过返回的是Unicode 字符
ord()函数是chr()函数(对于8 位的ASCII 字符串)或unichr()函数(对于Unicode 对象)
的配对函数,它以一个字符(长度为1 的字符串)作为参数,返回对应的ASCII 数值，或者Unicode
数值，如果所给的Unicode 字符超出了你的Python 定义范围,则会引发一个TypeError 的异常
(五)、只适用于字符串的操作符
1、格式化操作符 %
字符串格式化符号
格式化字符 转换方式
%c 转换成字符(ASCII 码值，或者长度为一的字符串)
%ra 优先用repr()函数进行字符串转换
%s 优先用str()函数进行字符串转换
%d / %i 转成有符号十进制数
%ub 转成无符号十进制数
%ob 转成无符号八进制数
%xb/%Xb (Unsigned)转成无符号十六进制数(x/X 代表转换后的十六进制字符的大
小写)
%e/%E 转成科学计数法(e/E 控制输出e/E)
%f/%F 转成浮点数(小数部分自然截断)
%g/%G %e 和%f/%E 和%F 的简写
%% 输出%
格式化操作符辅助指令
符号 作用
* 定义宽度或者小数点精度
- 用做左对齐
+ 在正数前面显示加号( + )
sp 在正数前面显示空格
# 在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于
用的是'x'还是'X')
0 显示的数字前面填充‘0’而不是默认的空格
% '%%'输出一个单一的'%'
(var) 映射变量(字典参数)
m.n m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)
2、字符串模板: 更简单的替代品
由于新式的字符串Template 对象的引进使得string 模块又重新活了过来，Template 对象
有两个方法,substitute()和safe_substitute().前者更为严谨,在key 缺少的情况下它会报一
个KeyError 的异常出来，而后者在缺少key 时，直接原封不动的把字符串显示出
3、原始字符串操作符( r/R )
字符串抑制转义r'带特殊符号的字串'
myfile=open(r'C:\new\text.data','w')
4、Unicode 字符串操作符( u/U )
u'abc' U+0061 U+0062 U+0063
u'\u1234' U+1234
u'abc\u1234\n' U+0061 U+0062 U+0063 U+1234 U+0012
(六)字符串对象的方法：
1、删减
T2.lstrip() 移除字符串前面字符（默认空格），返回字符串
T2.rstrip() 移除字符串后面字符（默认空格），返回字符串
T2.strip() 移除字符串前后面空格，返回字符串 默认空格，可以其他字符 S.strip('"')
2、切割
partition(sep),
rpartition(sep),
splitlines([keepends]),#把S按照行分割符分为一个list，keepends是一个bool值，如果为真每行后而会保留行分割符
split([sep [,maxsplit]]),#以sep为分隔符，把S分成一个list。maxsplit表示分割的次数。默认的分割符为空白字符
rsplit([sep[,maxsplit]]) #从右到左切割
备注：
partition()函数族是2.5版本新增的方法。它接受一个字符串参数，并返回一个3个元素的 tuple 对象。
如果sep没出现在母串中，返回值是 (sep, ‘’, ‘’)；
否则，返回值的第一个元素是 sep 左端的部分，第二个元素是 sep 自身，第三个元素是 sep 右端的部分。
S.partition(';')
('', ';', ' generated by /sbin/dhclient-script\nnameserver 172.16.10.171\nnameserver 8.8.8.8\nnameserver 172.16.0.2\nnameserver 178.79.131.110\nnameserver 202.96.199.133\n')
参数 maxsplit 是分切的次数，即最大的分切次数，所以返回值最多有 maxsplit+1 个元素。
s.split() 和 s.split(‘ ‘)的返回值不尽相同
' hello world!'.split()
['hello', 'world!']
' hello world!'.split(' ')
['', '', 'hello', '', '', 'world!']
S.split('\n',3)
['; generated by /sbin/dhclient-script', 'nameserver 172.16.10.171', 'nameserver 8.8.8.8', 'nameserver 172.16.0.2\nnameserver 178.79.131.110\nnameserver 202.96.199.133\n']
超过最大切割个数后面的全部为一个元素
按行切割
S
'; generated by /sbin/dhclient-script\nnameserver 172.16.10.171\nnameserver 8.8.8.8\nnameserver 172.16.0.2\nnameserver 178.79.131.110\nnameserver 202.96.199.133\n'
S.splitlines()
['; generated by /sbin/dhclient-script', 'nameserver 172.16.10.171', 'nameserver 8.8.8.8', 'nameserver 172.16.0.2', 'nameserver 178.79.131.110', 'nameserver 202.96.199.133']
产生差异的原因在于当忽略 sep 参数或sep参数为 None 时与明确给 sep 赋予字符串值时 split() 采用两种不同的算法。
对于前者，split() 先去除字符串两端的空白符，然后以任意长度的空白符串作为界定符分切字符串
即连续的空白符串被当作单一的空白符看待；
对于后者则认为两个连续的 sep 之间存在一个空字符串。因此对于空字符串（或空白符串），它们的返回值也是不同的：
''.split()
[]
''.split(' ')
['']
3、变形
lower(),#全部小写
upper(),#全部小写
capitalize(),#首字母大写
swapcase(),#大小写交换
title()#每个单词第一个大写,其他小写
备注
因为title() 函数并不去除字符串两端的空白符也不会把连续的空白符替换为一个空格，
所以建议使用string 模块中的capwords(s)函数，它能够去除两端的空白符，再将连续的空白符用一个空格代替。
Python Code
1
2
3
4
' hello world!'.title()
' Hello World!'
string.capwords(' hello world!')
'Hello World!'
4、连接
join(seq)
join() 函数的高效率（相对于循环相加而言），使它成为最值得关注的字符串方法之一。
它的功用是将可迭代的字符串序列连接成一条长字符串，如：
conf = {'host':'127.0.0.1',
... 'db':'spam',
... 'user':'sa',
... 'passwd':'eggs'}
';'.join("%s=%s"%(k, v) for k, v in conf.iteritems())
'passswd=eggs;db=spam;user=sa;host=127.0.0.1'
S=''.join(T) #使用空字符串分割把字符列表转换为字符串
5、查找
count( sub[, start[, end]]),#计算substr在S中出现的次数
find( sub[, start[, end]]),#返回S中出现sub的第一个字母的标号，如果S中没有sub则返回-1。start和end作用就相当于在S[start:end]中搜索
index( substr[, start[, end]]),#与find()相同，只是在S中没有substr时，会返回一个运行时错误
rfind( sub[, start[,end]]),#返回S中最后出现的substr的第一个字母的标号，如果S中没有substr则返回-1，也就是说从右边算起的第一次出现的substr的首字母标号
rindex( sub[, start[, end]])
T2.find('ie') 字符串方法调用：搜索
find()----找到的第一个符合字符的index
rfind()-----找到最后一个符合的字符的index
备注：
find()函数族找不到时返回-1，index()函数族则抛出ValueError异常。
另，也可以用 in 和 not in 操作符来判断字符串中是否存在某个模板
6、替换
replace(old, new[,count]),#把S中的oldstar替换为newstr，count为替换次数。这是替换的通用形式，还有一些函数进行特殊字符的替换
translate(table[,deletechars]) #使用上面的函数产后的翻译表，把S进行翻译，并把deletechars中有的字符删掉
备注：
replace()函数的 count 参数用以指定最大替换次数
translate() 的参数 table 可以由 string.maketrans(frm, to) 生成
translate() 对 unicode 对象的支持并不完备，建议不要使用
7、判定
isalnum(),#是否全是字母和数字，并至少有一个字符
isalpha(),是否全是字母，并至少有一个字符
isdigit(),是否全是数字，并至少有一个字符 ，如果是全数字返回True,否则返回False
islower(),#S中的字母是否全是小写
isupper(),#S中的字母是否是大写
isspace(),#是否全是空白字符，并至少有一个字符
istitle(),S是否是首字母大写的
startswith(prefix[, start[, end]]), #是否以prefix开头
endswith(suffix[,start[, end]]),#以suffix结尾
备注：
这些函数都比较简单，顾名知义。需要注意的是*with()函数族可以接受可选的 start, end 参数，善加利用，可以优化性能。
另，自 Py2.5 版本起，*with() 函数族的 prefix 参数可以接受 tuple 类型的实参，当实参中的某人元素能够匹配，即返回 True。
8、填充
字符串在输出时的对齐：
center(width[, fillchar]), 字符串中间对齐
ljust(width[, fillchar]), 字符串左对齐，不足部分用fillchar填充，默认的为空格
rjust(width[, fillchar]), 字符串右对齐，不足部分用fillchar填充，默认的为空格
zfill(width), 把字符串变成width长，并在右对齐，不足部分用0补足
expandtabs([tabsize])把字符串中的制表符（tab）转换为适当数量的空格。
fillchar 参数指定了用以填充的字符，默认为空格
zfill的z为zero的缩写,顾名思义,是以字符0进行填充，用于数值输出
expandtabs()的tabsize 参数默认为8。它的功能是把字符串中的制表符（tab）转换为适当数量的空格。
9、编码
encode([encoding[,errors]]),
decode([encoding[,errors]])
这是一对互逆操作的方法，用以编码和解码字符串。因为str是平台相关的，它使用的内码依赖于操作系统环境，
而unicode是平台无关的，是Python内部的字符串存储
move函数是Python中的运动函数，move（num,a,b,c） 是一个典型的挪动盘子的例子中使用的函数。num为盘子数量，abc代表三根柱子。
