Python对容器内数据的排序有两种,一种是容器自己的sort函数,一种是内建的sorted函数。
创新互联专注于企业全网营销推广、网站重做改版、天峻网站定制设计、自适应品牌网站建设、H5开发、商城开发、集团公司官网建设、成都外贸网站建设、高端网站制作、响应式网页设计等建站业务,价格优惠性价比高,为天峻等各大城市提供网站开发制作服务。
sort函数和sorted函数唯一的不同是,sort是在容器内排序,sorted生成一个新的排好序的容器。
对于一个简单的数组 L=[5,2,3,1,4].
sort: L.sort()
sorted(...)
sorted(iterable, cmp=None, key=None, reverse=False) -- new sorted list
iterable:待排序的可迭代类型的容器;
cmp:用于比较的函数,比较什么由key决定,有默认值,迭代集合中的一项;
key:用列表元素的某个已命名的属性或函数(只有一个参数并且返回一个用于排序的值)作为关键字,有默认值,迭代集合中的一项;
reverse:排序规则. reverse = True 或者 reverse = False,有默认值。
返回值:是一个经过排序的可迭代类型,与iterable一样。
如果是一个多维的列表 L=[(‘b’,2),(‘a’,1),(‘c’,3),(‘d’,4)].
有三种选择对这个多维列表进行排序
利用cmp函数
sorted(L, cmp=lambda x,y:cmp(x[1],y[1]))
L.sort(cmp=lambda x,y:cmp(x[1],y[1]))
利用key
sorted(L, key=lambda x:x[1]);
L.sort(key=lambda x:x[1]);
反序
以上几种排序均可加上参数reverse.
例如 sorted(reverse=True), L.sort(reverse=True). 或者改成False
OrderedDict是collections中的一个包,能够记录字典元素插入的顺序,常常和排序函数一起使用来生成一个排序的字典。
比如,比如一个无序的字典
d = {‘banana’:3,’apple’:4,’pear’:1,’orange’:2}
通过排序来生成一个有序的字典,有以下几种方式
collections.OrderedDict(sorted(d.items(),key = lambda t:t[0]))
或者
collections.OrderedDict(sorted(d.items(),key = lambda t:t[1]))
或者
collections.OrderedDict(sorted(d.items(),key = lambda t:len(t[0])))
Python 函数
函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。
函数能提高应用的模块性,和代码的重复利用率。你已经知道Python提供了许多内建函数,比如print()。但你也可以自己创建函数,这被叫做用户自定义函数。
定义一个函数
你可以定义一个由自己想要功能的函数,以下是简单的规则:
函数代码块以 def 关键词开头,后接函数标识符名称和圆括号()。
任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始,并且缩进。
return [表达式] 结束函数,选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
语法
def functionname( parameters ): "函数_文档字符串"
function_suite
return [expression]
默认情况下,参数值和参数名称是按函数声明中定义的顺序匹配起来的。
实例
以下为一个简单的Python函数,它将一个字符串作为传入参数,再打印到标准显示设备上。
实例(Python 2.0+)
def printme( str ): "打印传入的字符串到标准显示设备上"
print str
return
函数调用
定义一个函数只给了函数一个名称,指定了函数里包含的参数,和代码块结构。
这个函数的基本结构完成以后,你可以通过另一个函数调用执行,也可以直接从Python提示符执行。
如下实例调用了printme()函数:
实例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
# 定义函数def printme( str ): "打印任何传入的字符串"
print str
return
# 调用函数printme("我要调用用户自定义函数!")printme("再次调用同一函数")
以上实例输出结果:
我要调用用户自定义函数!再次调用同一函数
参数传递
在 python 中,类型属于对象,变量是没有类型的:
a=[1,2,3]
a="Runoob"
以上代码中,[1,2,3] 是 List 类型,"Runoob" 是 String 类型,而变量 a 是没有类型,她仅仅是一个对象的引用(一个指针),可以是 List 类型对象,也可以指向 String 类型对象。
可更改(mutable)与不可更改(immutable)对象
在 python 中,strings, tuples, 和 numbers 是不可更改的对象,而 list,dict 等则是可以修改的对象。
不可变类型:变量赋值 a=5 后再赋值 a=10,这里实际是新生成一个 int 值对象 10,再让 a 指向它,而 5 被丢弃,不是改变a的值,相当于新生成了a。
可变类型:变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改,本身la没有动,只是其内部的一部分值被修改了。
python 函数的参数传递:
不可变类型:类似 c++ 的值传递,如 整数、字符串、元组。如fun(a),传递的只是a的值,没有影响a对象本身。比如在 fun(a)内部修改 a 的值,只是修改另一个复制的对象,不会影响 a 本身。
可变类型:类似 c++ 的引用传递,如 列表,字典。如 fun(la),则是将 la 真正的传过去,修改后fun外部的la也会受影响
python 中一切都是对象,严格意义我们不能说值传递还是引用传递,我们应该说传不可变对象和传可变对象。
python 传不可变对象实例
实例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
def ChangeInt( a ): a = 10
b = 2ChangeInt(b)print b # 结果是 2
实例中有 int 对象 2,指向它的变量是 b,在传递给 ChangeInt 函数时,按传值的方式复制了变量 b,a 和 b 都指向了同一个 Int 对象,在 a=10 时,则新生成一个 int 值对象 10,并让 a 指向它。
传可变对象实例
实例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
# 可写函数说明def changeme( mylist ): "修改传入的列表"
mylist.append([1,2,3,4])
print "函数内取值: ", mylist
return
# 调用changeme函数mylist = [10,20,30]changeme( mylist )print "函数外取值: ", mylist
实例中传入函数的和在末尾添加新内容的对象用的是同一个引用,故输出结果如下:
函数内取值: [10, 20, 30, [1, 2, 3, 4]]函数外取值: [10, 20, 30, [1, 2, 3, 4]]
参数
以下是调用函数时可使用的正式参数类型:
必备参数
关键字参数
默认参数
不定长参数
必备参数
必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
调用printme()函数,你必须传入一个参数,不然会出现语法错误:
实例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
#可写函数说明def printme( str ): "打印任何传入的字符串"
print str
return
#调用printme函数printme()
以上实例输出结果:
Traceback (most recent call last):
File "test.py", line 11, in module
printme()TypeError: printme() takes exactly 1 argument (0 given)
关键字参数
关键字参数和函数调用关系紧密,函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致,因为 Python 解释器能够用参数名匹配参数值。
以下实例在函数 printme() 调用时使用参数名:
实例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
#可写函数说明def printme( str ): "打印任何传入的字符串"
print str
return
#调用printme函数printme( str = "My string")
以上实例输出结果:
My string
下例能将关键字参数顺序不重要展示得更清楚:
实例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
#可写函数说明def printinfo( name, age ): "打印任何传入的字符串"
print "Name: ", name
print "Age ", age
return
#调用printinfo函数printinfo( age=50, name="miki" )
以上实例输出结果:
Name: mikiAge 50
默认参数
调用函数时,默认参数的值如果没有传入,则被认为是默认值。下例会打印默认的age,如果age没有被传入:
实例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
#可写函数说明def printinfo( name, age = 35 ): "打印任何传入的字符串"
print "Name: ", name
print "Age ", age
return
#调用printinfo函数printinfo( age=50, name="miki" )printinfo( name="miki" )
以上实例输出结果:
Name: mikiAge 50Name: mikiAge 35
不定长参数
你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数,和上述2种参数不同,声明时不会命名。基本语法如下:
def functionname([formal_args,] *var_args_tuple ): "函数_文档字符串"
function_suite
return [expression]
加了星号(*)的变量名会存放所有未命名的变量参数。不定长参数实例如下:
实例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
# 可写函数说明def printinfo( arg1, *vartuple ): "打印任何传入的参数"
print "输出: "
print arg1
for var in vartuple: print var
return
# 调用printinfo 函数printinfo( 10 )printinfo( 70, 60, 50 )
以上实例输出结果:
输出:10输出:706050
匿名函数
python 使用 lambda 来创建匿名函数。
lambda只是一个表达式,函数体比def简单很多。
lambda的主体是一个表达式,而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda函数拥有自己的命名空间,且不能访问自有参数列表之外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行,却不等同于C或C++的内联函数,后者的目的是调用小函数时不占用栈内存从而增加运行效率。
语法
lambda函数的语法只包含一个语句,如下:
lambda [arg1 [,arg2,.....argn]]:expression
如下实例:
实例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
# 可写函数说明sum = lambda arg1, arg2: arg1 + arg2
# 调用sum函数print "相加后的值为 : ", sum( 10, 20 )print "相加后的值为 : ", sum( 20, 20 )
以上实例输出结果:
相加后的值为 : 30相加后的值为 : 40
return 语句
return语句[表达式]退出函数,选择性地向调用方返回一个表达式。不带参数值的return语句返回None。之前的例子都没有示范如何返回数值,下例便告诉你怎么做:
实例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
# 可写函数说明def sum( arg1, arg2 ): # 返回2个参数的和."
total = arg1 + arg2
print "函数内 : ", total
return total
# 调用sum函数total = sum( 10, 20 )
以上实例输出结果:
函数内 : 30
变量作用域
一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。
变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。两种最基本的变量作用域如下:
全局变量
局部变量
全局变量和局部变量
定义在函数内部的变量拥有一个局部作用域,定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问,而全局变量可以在整个程序范围内访问。调用函数时,所有在函数内声明的变量名称都将被加入到作用域中。如下实例:
实例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
total = 0 # 这是一个全局变量# 可写函数说明def sum( arg1, arg2 ): #返回2个参数的和."
total = arg1 + arg2 # total在这里是局部变量.
print "函数内是局部变量 : ", total
return total
#调用sum函数sum( 10, 20 )print "函数外是全局变量 : ", total
以上实例输出结果:
函数内是局部变量 : 30函数外是全局变量 : 0
sorted函数python介绍如下
sorted() 作为 Python 内置函数之一,其功能是对序列(列表、元组、字典、集合、还包括字符串)进行排序。
sorted() 函数的基本语法格式如下
list = sorted(iterable, key=None, reverse=False)
其中,iterable 表示指定的序列,key 参数可以自定义排序规则;reverse 参数指定以升序(False,默认)还是降序(True)进行排序。sorted() 函数会返回一个排好序的列表。
注意,key 参数和 reverse 参数是可选参数,即可以使用,也可以忽略。
演示sorted()函数的基本代码用法:
#对列表进行排序
a = [5,3,4,2,1]
print(sorted(a))
#对元组进行排序
a = (5,4,3,1,2)
print(sorted(a))
#字典默认按照key进行排序
a = {4:1,\
5:2,\
3:3,\
2:6,\
1:8}
print(sorted(a.items()))
#对集合进行排序
a = {1,5,3,2,4}
print(sorted(a))
#对字符串进行排序
a = "51423"
print(sorted(a))
1.1 例如:print(hex(2))案例
1.2 输出函数:print(hex(2))
1.3 输出结果:0x2
1.4 解析说明:返回16进制的数。
2.1 例如:print(chr(10))案例
2.2 输出函数:print(chr(10))
2.3 输出结果:0o12
2.4 解析说明:返回当前整数对应的ASCll码
3.1 例如:print(ord("b"))案例
3.2 输出函数:print(ord("b"))
3.3 输出结果:98
3.4 解析说明:返回当前ASCll码的10进制数
4.1 例如:print(chr(97))
4.2 输出函数:print(chr(97))
4.3 输出结果:b
4.4 解析说明:返回当前ASCll码的10进制数。
案例一:给你一个字符串,s = 'hello kitty'
1.1 输出函数:print(s.capitalize())
1.2 输出结果:0x2
1.3 解析说明:返回16进制的数。
2.1输出函数:print(s.replace('kitty','kuang'))
2.2 输出结果:hello kuang
2.3 解析说明:替换功能,将kitty换成kuang。
2.4 输出函数:print(s.replace('4','KK'))
2.5 输出结果:12KK12KK
2.6 解析说明:所有的4都替换成KK
2.7 输出函数:print(s.replace('4','KK'))
2.8 输出结果:12KK12KK124
2.9 解析说明:将前两个的4替换成go
案例一:给你一个字符串,ip = '192.168.1.1'
3.1 输出函数:print(ip.split(','))
3.2 输出结果:['192.168.1.1']
3.3 解析说明:将字符串分割成列表
案例一:给你一个字符串,ip = '192.168.1.1'
3.3 输出函数:print(ip.split(',',2))
3.4 输出结果:['192.168.1.1']
3.5 解析说明:从第二个开始分割成列表
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序号函数
网站网址:https://www.cdcxhl.com/article8/hshcip.html
成都网站建设公司_创新互联,为您提供Google、网站导航、移动网站建设、小程序开发、服务器托管、微信公众号
声明:本网站发布的内容(图片、视频和文字)以用户投稿、用户转载内容为主,如果涉及侵权请尽快告知,我们将会在第一时间删除。文章观点不代表本网站立场,如需处理请联系客服。电话:028-86922220;邮箱:631063699@qq.com。内容未经允许不得转载,或转载时需注明来源: 创新互联