python学习五-使用字符串

痛定思痛。 2022-06-03 03:26 98阅读 0赞

字符串  
字符串都是不可变的。如：分片赋值都是不合法的。  
所有标准的序列操作（索引、分片、乘法、判断成员资格、求长度、取最小值和  
最大值）对字符串同样适用，前面已经讲述的这些操作。但是，请注意字符串都  
是不可变的。  
  
Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但  
最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。  
在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。  
================================================  
在%左侧放置一个字符串，而右侧则放置希望被格式化的值。  
>>> format = "Hello,%s,%s enough for ya?"  
>>> values = ('world','Hot')  
>>> print format % values  
Hello,world,Hot enough for ya?  
格式化字符串的%部分称为转换说明符，他们标记了需要插入转换值的位置。  
s表示值会被格式化为字符串---如果不是字符串，则会用str将其转换为字符串。  
  
  
如果要格式化实数（浮点数），可以使用f说明转换为说明符类型，同时提供所需  
的精度，一个句点再加上希望保留的小数位数。  
>>> format = "Pi with three decimals: %.3f"       
>>> from math import pi  
>>> print format % pi  
Pi with three decimals: 3.142  
  
\[root@node01 python\]\# vi zfc.py  
\#!/usr/bin/python  
print "My name is %s and weight is %d kg!" % ('Zara', 21)  
\[root@node01 python\]\# python zfc.py   
My name is Zara and weight is 21 kg!  
=================================================  
python字符串格式化符号:  
     符号   描述  
      %c    格式化字符及其ASCII码  
      %s    格式化字符串  
      %d i%   格式化整数  
      %u    格式化无符号整型  
      %o    格式化无符号八进制数  
      %x    格式化无符号十六进制数  
      %X    格式化无符号十六进制数（大写）  
      %f    格式化浮点数字，可指定小数点后的精度  
      %e    用科学计数法格式化浮点数  
      %E    作用同%e，用科学计数法格式化浮点数  
      %g    %f和%e的简写  
      %G    %f 和 %E 的简写  
      %p    用十六进制数格式化变量的地址  
==================================================  
格式化操作符辅助指令:  
      符号    功能  
      \*       定义宽度或者小数点精度  
      -       用做左对齐  
      +       在正数前面显示加号( + )  
      <sp>    在正数前面显示空格  
      \#       在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')  
      0       显示的数字前面填充'0'而不是默认的空格  
      %       '%%'输出一个单一的'%'  
      (var)   映射变量(字典参数)  
      m.n.    m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)  
==================================================  
简单转换  
>>> 'price of eggs: $%d' % 42        格式化整数  
'price of eggs: $42'  
>>> 'Hexadecimal price of eggs: %x' % 42    格式化无符号十六进制数  
'Hexadecimal price of eggs: 2a'  
>>> from math import pi  
>>> 'Pi: %f...' % pi                    格式化浮点数字，可指定小数点后的精度  
'Pi: 3.141593...'  
>>> 'Very inexact estimate of pi: %i' % pi  格式化整数  
'Very inexact estimate of pi: 3'  
>>> 'Using str: %s' % 42L                    格式化字符串  
'Using str: 42'  
>>> 'Using repr: %s' % 42L               格式化字符串  
'Using repr: 42'  
  
字符串宽度和精度  
转换字符串可以包括字段宽度和精度。  
>>> '%10f' % pi         字段宽10  
'  3.141593'  
>>> '%10.2f' % pi       字段宽10，精度2  
'      3.14'  
>>> '%.2f' % pi         精度2     
'3.14'   
>>> '%.5s' % 'Guido van Rossum'  
'Guido'  
>>> '%.\*s' % (5,'Guido van Rossum')  用\*作为字段宽度和精度，此时数值会从元组参数中读出：  
'Guido'  
  
符号、对齐和用0填充  
在字段宽度和精度值之前还可以放置一个“标志”，该标志可以是零、加号、减号或者空格。  
零表示数字将会用0进行填充。  
>>> '%010.2f' % pi  
'0000003.14'  
>>> 010  
8  
>>> '%-10.2f' % pi    用减号来左对齐数值  
'3.14      '          数字左侧多出了额外的空格  
>>> print ('% 5d' % 10) + '\\n' + ('% 5d' % -10)     空格（“”）意味着在正数前加上空格。这在需要对齐正负数时会很有用。  
   10  
  -10  
>>> print ('% +5d' % 10) + '\\n' + ('% +5d' % -10)   +，他表示不管是正数还是负数都标识出符号。  
  +10  
  -10  
===============================================  
字符串基本操作  
字符串从string 模块中“继承”了很多方法，这里只介绍一些特别有用的  
1、find   
find 方法可以在一个较长的字符串中查找子字符串。它返回子串所在位置的最左端索引。如果没有找到则返回-1.  
>>> 'with a moo-moo here. and a moo-moo ther'.find('moo')   
7  
>>> title = "Monty Pyhon's Flying Circus"  
>>> title.find('Monty')  
0  
>>> title.find('Python')  
\-1  
字符串的find方法并不返回布尔值，如果返回的是0，则证明在索引0位置找到了子串。  
>>> subject = '$$$ Get rich now!!! $$$'  
>>> subject.find('$$$')                起始点  
0  
>>> subject.find('$$$', 1)             只提供起始点  
20  
>>> subject.find('!!!')                        
16  
>>> subject.find('!!!',0,16)           提供起始点和结束点  
\-1  
  
2、join  
join 方法是非常重要的字符串方法，它是split方法的逆方法，用来在队列中添加元素。  
>>> seq = \[1,2,3,4,5\]          这里说明连接的序列元素都必须是字符串  
>>> sep = '+'  
>>> sep.join(seq)  
Traceback (most recent call last):  
  File "<stdin>", line 1, in <module>  
TypeError: sequence item 0: expected string, int found  
  
>>> seq = \['1','2','3','4','5'\]  
>>> sep = '+'  
>>> sep.join(seq)  
'1+2+3+4+5'  
>>> dirs = '','usr','bin','env'  
>>> '/'.join(dirs)  
'/usr/bin/env'  
>>> print 'C:' + '\\\\'.join(dirs)  
C:\\usr\\bin\\env  
>>>   
  
3、lower  
lower 方法返回字符串的小写字母版。  
如果想要编写“不区分大小写”的代码的话，那么这个方法就派上用场了-----代码会忽略大小写状态。  
>>> 'Trondheim Hammer Dance'.lower()  
'trondheim hammer dance'  
  
>>> if 'Gumby' in \['gumby','smith','jones'\]: print 'Found it!'  
...   
>>> name = 'Gumby'  
>>> names = \['gumby', 'smith', 'jones'\]   
>>> if name.lower() in names:print 'Found it!'  
...   
Found it!  
  
title  
将字母大写  
>>> "that's all folks".title()  
"That'S All Folks"  
  
string模块的capwords  
>>> import string  
>>> string.capwords("that's all folks")  
"That's All Folks"  
  
4、replace   
replace 方法返回某字符串的所有匹配项均被替换之后得到字符串。  
>>> 'This is a test'.replace('is','eez')   
'Theez eez a test'  
  
5、split  
这是一个非常重要的方法，它是join的逆方法，用来将字符串分割成序列。  
>>> '1+2+3+4+5'.split('+')  
\['1', '2', '3', '4', '5'\]  
>>> '/usr/bin/env'.split('/')  
\['', 'usr', 'bin', 'env'\]  
>>> 'using the default'.split()   
\['using', 'the', 'default'\]  
如果不提供分隔符，程序会把所有空格作为分隔符。  
  
6、strip   
strip 方法返回去除两侧（不包含内部）空格的字符串。  
>>> '      internal white space is kept    '.strip()   
'internal white space is kept'  
>>> names = \['gumby', 'smith', 'jones'\]  
>>> name = 'gumby'  
>>> if name in names: print 'Found it!'  
...   
Found it!  
>>> if name.strip() in names: print 'Found it!'  
...   
Found it!  
也可以指定需要去除的字符。  
>>> '\*\*\* SPAM \* for \* everyone !!! \*\*\*' .strip('\*!')  
' SPAM \* for \* everyone !!! '  
这个方法只能去除两侧的字符，所有字符串中的型号没有被去掉。  
  
7、translate  
translate方法和replace方法一样，可以替换字符串中的一些部分。translate方法只处理单个字符。  
他的优势在于可以进行多个替换，有些时候比replace效率高的多。  
>>> from string import maketrans  
>>> table = maketrans('cs', 'kz')  
>>> len(table)   
256  
>>> table\[97:123\]  
'abkdefghijklmnopqrztuvwxyz'  
>>> maketrans('','')\[97:123\]  
'abcdefghijklmnopqrstuvwxyz'  
>>> 'this is an incredible test'.translate(table)  
'thiz iz an inkredible tezt'