python特殊函数大全,python常用函数

Python|range函数用法完全解读

迭代器是 23 种设计模式中最常用的一种（之一），在 Python 中随处可见它的身影，我们经常用到它，但是却不一定意识到它的存在。在关于迭代器的系列文章中（链接见文末），我至少提到了 23 种生成迭代器的方法。有些方法是专门用于生成迭代器的，还有一些方法则是为了解决别的问题而“暗中”使用到迭代器。

成都创新互联公司2013年至今，是专业互联网技术服务公司，拥有项目成都做网站、成都网站建设网站策划，项目实施与项目整合能力。我们以让每一个梦想脱颖而出为使命，1280元腾冲做网站,已为上家服务,为腾冲各地企业和个人服务,联系电话:18980820575

在系统学习迭代器之前，我一直以为 range() 方法也是用于生成迭代器的，现在却突然发现，它生成的只是可迭代对象，而并不是迭代器！ （PS：Python2 中 range() 生成的是列表，本文基于Python3，生成的是可迭代对象）

于是，我有了这样的疑问：为什么 range() 不生成迭代器呢？在查找答案的过程中，我发现自己对 range 类型的认识存在一些误区。因此，本文将和大家全面地认识一下 range ，期待与你共同学习进步。

1、range() 是什么？

它的语法：range(start, stop [,step]) ；start 指的是计数起始值，默认是 0；stop 指的是计数结束值，但不包括 stop ；step 是步长，默认为 1，不可以为 0 。range() 方法生成一段左闭右开的整数范围。

对于 range() 函数，有几个注意点：（1）它表示的是左闭右开区间；（2）它接收的参数必须是整数，可以是负数，但不能是浮点数等其它类型；（3）它是不可变的序列类型，可以进行判断元素、查找元素、切片等操作，但不能修改元素；（4）它是可迭代对象，却不是迭代器。

2、 为什么range()不生产迭代器？

可以获得迭代器的内置方法很多，例如 zip() 、enumerate()、map()、filter() 和 reversed() 等等，但是像 range() 这样仅仅得到的是可迭代对象的方法就绝无仅有了（若有反例，欢迎告知）。这就是我存在知识误区的地方。

在 for-循环 遍历时，可迭代对象与迭代器的性能是一样的，即它们都是惰性求值的，在空间复杂度与时间复杂度上并无差异。我曾概括过两者的差别是“一同两不同”：相同的是都可惰性迭代，不同的是可迭代对象不支持自遍历（即next()方法），而迭代器本身不支持切片（即 getitem () 方法）。

虽然有这些差别，但很难得出结论说它们哪个更优。现在微妙之处就在于，为什么给 5 种内置方法都设计了迭代器，偏偏给 range() 方法设计的就是可迭代对象呢？把它们都统一起来，不是更好么？

事实上，Pyhton 为了规范性就干过不少这种事，例如，Python2 中有 range() 和 xrange() 两种方法，而 Python3 就干掉了其中一种，还用了“李代桃僵”法。为什么不更规范点，令 range() 生成的是迭代器呢？

关于这个问题，我没找到官方解释，以下纯属个人观点 。

zip() 等方法都需要接收确定的可迭代对象的参数，是对它们的一种再加工的过程，因此也希望马上产出确定的结果来，所以 Python 开发者就设计了这个结果是迭代器。这样还有一个好处，即当作为参数的可迭代对象发生变化的时候，作为结果的迭代器因为是消耗型的，不会被错误地使用。

而 range() 方法就不同了，它接收的参数不是可迭代对象，本身是一种初次加工的过程，所以设计它为可迭代对象，既可以直接使用，也可以用于其它再加工用途。例如，zip() 等方法就完全可以接收 range 类型的参数。

也就是说，range() 方法作为一种初级生产者，它生产的原料本身就有很大用途，早早把它变为迭代器的话，无疑是一种画蛇添足的行为。

对于这种解读，你是否觉得有道理呢？欢迎就这个话题与我探讨。

3、range 类型是什么？

以上是我对“为什么range()不产生迭代器”的一种解答。顺着这个思路，我研究了一下它产生的 range 对象，一研究就发现，这个 range 对象也并不简单。

首先奇怪的一点就是，它竟然是不可变序列！我从未注意过这一点。虽然说，我从未想过修改 range() 的值，但这一不可修改的特性还是令我惊讶。

翻看文档，官方是这样明确划分的——有三种基本的序列类型：列表、元组和范围（range）对象。（There are three basic sequence types: lists, tuples, and range objects.）

这我倒一直没注意，原来 range 类型居然跟列表和元组是一样地位的基础序列！我一直记挂着字符串是不可变的序列类型，不曾想，这里还有一位不可变的序列类型呢。

那 range 序列跟其它序列类型有什么差异呢？

普通序列都支持的操作有 12 种。range 序列只支持其中的 10 种，不支持进行加法拼接与乘法重复。

那么问题来了：同样是不可变序列，为什么字符串和元组就支持上述两种操作，而偏偏 range 序列不支持呢？虽然不能直接修改不可变序列，但我们可以将它们拷贝到新的序列上进行操作啊，为何 range 对象连这都不支持呢？

且看官方文档的解释：

…due to the fact that range objects can only represent sequences that follow a strict pattern and repetition and concatenation will usually violate that pattern.

原因是 range 对象仅仅表示一个遵循着严格模式的序列，而重复与拼接通常会破坏这种模式…

问题的关键就在于 range 序列的 pattern，仔细想想，其实它表示的就是一个等差数列啊（喵，高中数学知识没忘…），拼接两个等差数列，或者重复拼接一个等差数列，想想确实不妥，这就是为啥 range 类型不支持这两个操作的原因了。由此推论，其它修改动作也会破坏等差数列结构，所以统统不给修改就是了。

4、小结

回顾全文，我得到了两个偏冷门的结论：range 是可迭代对象而不是迭代器；range 对象是不可变的等差序列。

若单纯看结论的话，你也许没有感触，或许还会说这没啥了不得啊。但如果我追问，为什么 range 不是迭代器呢，为什么 range 是不可变序列呢？对这俩问题，你是否还能答出个自圆其说的设计思想呢？（PS：我决定了，若有机会面试别人，我必要问这两个问题的嘿~）

由于 range 对象这细微而有意思的特性，我觉得这篇文章写得值了。本文是作为迭代器系列文章的一篇来写的，所以对于迭代器的基础知识介绍不多，另外，还有一种特殊的迭代器也值得单独成文，那就是生成器了。

Python中的几种特殊数据类型小结

下面介绍了Python中的6种特殊数据类型：

1.list:列表

是一种有序的数据集合，在列表数据结构中的类型并不唯一

定义形式：L=['Micha',100,True]

输出整个列表的时候显示为['Micha',100,True]

输出单个的数值则为：Micha

a.访问，直接使用L[0]表示第一个元素或者使用L[-1]表示最后一个数据，以此类推，但是注意访问不能越界（访问的序号不能超过元素的总数）。

b.添加新元素：使用L.append(100)直接将100加入列表末尾，或者使用L.insert(0,'paul')将paul插入任意位置。

c.删除元素：L.pop（）删除最后一个元素，或者L.pop(2)删除第2个位置的元素。

d.替换元素：直接赋值就可以了L[2]=100

2.tuple:元组

是一种有序的列表，但是其一旦创立完毕就不能够更改，即不能插入，删除里面的元素，访问的方式跟List结构一致。

a.t=（）其打印后输出的形式是（）

若t中的数据为一个数字则需要在后面加逗号，以区分普通数字，如t=(1,)，打印出（1，）而非1，多元素的话则没有这个要求。

b.可以在不变的tuple中加入可变的List如t=（‘a’,'b',['A','B']）

3.dict:字典

d = {

'Adam': 95,

'Lisa': 85,

'Bart': 59

}

len()函数可以计算任意集合的大小

其中可以简单地使用d[key]的形式来查找对应的 value，这和 list很像，不同之处是，list必须使用索引返回对应的元素，而dict使用key,当key不存在的时候，使用该key可能出现错误，因此：要避免 KeyError 发生，有两个办法：

一是先判断一下 key 是否存在，用 in 操作符：

if'Paul' in d:

print d['Paul']

如果 'Paul' 不存在，if语句判断为False，自然不会执行print d['Paul']，从而避免了错误。

二是使用dict本身提供的一个 get方法，在Key不存在的时候，返回None：

print d.get('Bart')

59

a.dict中的key不能重复，且dict中的存储的对应值没有顺序，打印出的东西可能是无序的

b.dict的更新：使用d[‘paul']=72求解

c.dict遍历：

d = {'Adam': 95, 'Lisa': 85, 'Bart': 59 }

for key in d:

...     print key

遍历只能获得key的值，需要通过key值获得对应的value

4.set：集合

无序但是所有元素唯一，不重复

a.定义：s = set(['A', 'B', 'C']),查看 set的内容：

print s

set(['A','C', 'B'])

可以用in来判断是否存在于集合中

b.遍历

s =set([('Adam', 95), ('Lisa', 85), ('Bart', 59)])

for xin s:

print x[0]+':',x[1]

c.添加元素到集合中

s.add(4)

d.删除元素

s.remove(4)若该元素不在集合中将会报错

5.Unicode编码

Python在后来添加了对Unicode的支持，以Unicode表示的字符串用u'...'表示，比如：

printu'中文'

注意: 不加 u，中文就不能正常显示中文。

a.转义形式： u'中文\n日文\n韩文'

b.输出多行：

u'''第一行

第二行'''

c.raw+多行的形式：

ur'''Python的Unicode字符串支持"中文",

"日文",

"韩文"等多种语言'''

如果中文字符串在Python环境下遇到 UnicodeDecodeError，这是因为.py文件保存的格式有问题。可以在第一行添加注释

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

目的是告诉Python解释器，用UTF-8编码读取源代码。然后用Notepad++另存为， 并选择UTF-8格式保存。

6.raw的作用

如果一个字符串包含很多需要转义的字符，对每一个字符都进行转义会很麻烦。为了避免这种情况，我们可以在字符串前面加个前缀 r，表示这是一个“raw”字符串，里面的字符就不需要转义了。例如：

r'\(~_~)//'

但是r'...'表示法不能表示多行字符串，也不能表示包含'和 "的字符串，如果要表示多行字符串。

python中quote函数是什么意思，怎么用

quote函数一般用于处理URL链接里的特殊字符，比如一些非ASCII列表中的字母。

位置：该函数在Python27中位于urllib模块下，在Python3中应该是向下移动一级目录，位于urllib.parse模块中。

功能：替换字符串string中的一些特殊字符，并使用%xx的方式替换该特殊字符（xx为该字符的（uft-8）十六进制数值）。正常字符ascii字母a-z，数字，还有符号'_.-'是不会被替换的。当然使用函数的第二个参数（默认值为/）可以指定哪些字符也不需要替换。

例子：

urllib.quote('/test')

'/test'

urllib.quote('/test', safe='')

'%2Ftest' # 2F 为/的uft-8的hex值。

其他：函数的第一个参数为需要转换的字符串，格式应该为str或者bytes。

函数的第三个字符为编码方式。

Python内置函数range

range 类型表示不可变的数字序列，通常用于在 for 循环中循环指定的次数。

range 构造器的参数必须为整数（可以是内置的 int 或任何实现了 __index__ 特殊方法的对象）。 如果省略 step 参数，其默认值为 1 。 如果省略 start 参数，其默认值为 0 ，如果 step 为零则会引发 ValueError。

如果 step 为正值，确定 range r 内容的公式为 r[i] = start + step*i 其中 i = 0 且 r[i] stop 。

如果 step 为负值，确定 range 内容的公式仍然为 r[i] = start + step*i ，但限制条件改为 i = 0 且 r[i] stop .

如果 r[0] 不符合值的限制条件，则该 range 对象为空。 range 对象确实支持负索引，但是会将其解读为从正索引所确定的序列的末尾开始索引。

元素绝对值大于 sys.maxsize 的 range 对象是被允许的，但某些特性 (例如 len()) 可能引发 OverflowError。

一些 range 对象的例子:

range 对象实现了 一般 序列的所有操作，但拼接和重复除外（这是由于 range 对象只能表示符合严格模式的序列，而重复和拼接通常都会违反这样的模式）。

start

start 形参的值 (如果该形参未提供则为 0 )

stop

stop 形参的值

step

step 形参的值 (如果该形参未提供则为 1 )

range 类型相比常规 list 或 tuple 的优势在于一个 range 对象总是占用固定数量的（较小）内存，不论其所表示的范围有多大（因为它只保存了 start , stop 和 step 值，并会根据需要计算具体单项或子范围的值）。

range 对象实现了 collections.abc.Sequence ABC，提供如包含检测、元素索引查找、切片等特性，并支持负索引

使用 == 和 != 检测 range 对象是否相等是将其作为序列来比较。 也就是说，如果两个 range 对象表示相同的值序列就认为它们是相等的。 （请注意比较结果相等的两个 range 对象可能会具有不同的 start, stop 和 step 属性，例如 range(0) == range(2, 1, 3) 而 range(0, 3, 2) == range(0, 4, 2) 。）

在 3.2 版更改: 实现 Sequence ABC。 支持切片和负数索引。 使用 int 对象在固定时间内进行成员检测，而不是逐一迭代所有项。

在 3.3 版更改: 定义 '==' 和 '!=' 以根据 range 对象所定义的值序列来进行比较（而不是根据对象的标识）。

3.3 新版功能: start, stop 和 step 属性。

享学课堂浅谈Python序列内建函数都有哪些

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内部的字符串存储

Python魔法函数（特殊函数）

Python中如何实现运算符的重载，即实现例如a+b这样的运算符操作呢？

在C++中可以使用 operator 关键字实现运算符的重载。但是在Python中没有类似这样的关键字，所以要实现运算符的重载，就要用到Python的魔法函数。Python魔法函数是以双下划线开头，双下划线结尾的一组函数。我们在类定义中最常用到的 __init__ 函数就是这样一个魔法函数，它在创建类对象时被自动调用。

下面我们来看个简单的例子。

上述代码示例了几个魔法函数的用法。 __add__ 函数对应了二元运算符+，当执行a+b语句时，python就会自动调用a. add (b)。 对于上述例子中的v1+v2+v3，则相当于调用了(v1. add(v2)). add(v3)。

代码中还有一个在Python类定义经常使用的 __str__ 函数，当使用 str() 时会被调用。print函数对传入的参数都调用了str()将其转换成易读的字符串形式，便于打印输出，因而会调用类定义的__str__函数打出自定义的字符串。

代码中还有一个特殊的 __call__ 函数，该函数在将对象采用函数调用方式使用时被调用, 例如v1()相当于v1. call ()。

以上就是魔法函数的基本使用方法。常见的魔法函数我们可以使用 dir() 函数来查看。

输出结果为：

上述结果中形式为‘__函数名__’的函数为魔法函数，注意有些对象也是这种形式，例如__class__, __module__等, 这些不是魔法函数。具体的魔法函数说明可以参考Python官方说明文档。

以上代码在Python3.6运行通过.