python字符串的表示和处理函数_unsupported format string passed to list-优快云博客

本文链接：https://blog.youkuaiyun.com/pipisorry/article/details/23563441

http://blog.youkuaiyun.com/pipisorry/article/details/42085723

python字符串表示

Python除处理数字外还可以处理字符串，字符串用单撇号或双撇号包裹：

>>> 'spam eggs'
'spam eggs'
>>> 'doesn/'t'
"doesn't"
>>> "doesn't"
"doesn't"
>>> '"Yes," he said.'
'"Yes," he said.'
>>> "/"Yes,/" he said."
'"Yes," he said.'
>>> '"Isn/'t," she said.'
'"Isn/'t," she said.'

字符串输出格式与输入的样子相同，都是用撇号包裹，撇号和其它特殊字符用用反斜杠转义。如果字符串中有单撇号而没有双撇号则用双撇号包裹，否则应该用单撇号包裹。后面要介绍的print语句可以不带撇号或转义输出字符串。

多行的长字符串也可以用行尾反斜杠续行，续行的行首空白不被忽略，如

        hello = "This is a rather long string containing/n        several lines of text just as you would do in C./n            Note that whitespace at the beginning of the line is         significant./n"
        print hello

结果为　

        This is a rather long string containing
        several lines of text just as you would do in C.
            Note that whitespace at the beginning of the line is significant.

对于特别长的字符串（比如包含说明的几段文字），如果用上面的方式每行都用/n/结尾是很麻烦的，特别是这样无法用象Emacs这样的功能强大的编辑器重新编排。对这种情况，可以使用三重撇号，例如

        hello = """
　
            This string is bounded by triple double quotes (3 times ").
        Unescaped newlines in the string are retained, though         it is still possible/nto use all normal escape sequences.
　
            Whitespace at the beginning of a line is
        significant.  If you need to include three opening quotes
        you have to escape at least one of them, e.g. /""".
　
            This string ends in a newline.
        """

三重撇号字符串也可以用三个单撇号，没有任何语义差别。

多行的字符串常量可以直接连接起来，字符串常量之间用空格分隔则在编译时可以自动连接起来，这样可以把一个长字符串连接起来而不需要牺牲缩进对齐或性能，不象用加号连接需要运算，也不象字符串串内的换行其行首空格需要保持。

字符串长度

内置函数len()返回字符串的长度：len(s)

repr(反引号)操作

在Python 2里，为了得到一个任意对象的字符串表示，有一种把对象包装在反引号里(比如`x`)的特殊语法。在Python 3里，这种能力仍然存在，但是你不能再使用反引号获得这种字符串表示了。你需要使用全局函数repr()。

Notes	Python 2	Python 3
①	`x`	repr(x)
②	`'PapayaWhip' + `2``	repr('PapayaWhip'+ repr(2))

记住，x可以是任何东西 — 一个类，函数，模块，基本数据类型，等等。repr()函数可以使用任何类型的参数。
在Python 2里，反引号可以嵌套，导致了这种令人费解的(但是有效的)表达式。2to3足够智能以将这种嵌套调用转换到repr()函数。

皮皮Blog

字符串处理

字符串的索引和分片

定义一个字符串以后，我们可以截取其中的任意部分形成新串，这种操作被称作字符串的分片(slice)。字符串分片跟列表的分片(slicing lists)原理是一样的，从直观上也说得通，因为字符串本身就是一些字符序列。

子串：python没有substring函数，因为直接使用str[start:end]就可以啦。

 +---+---+---+---+---+ 
 | H | e | l | p | A |
 +---+---+---+---+---+ 
   0   1   2   3   4   5 
  -5  -4  -3  -2  -1
第一行数字给出字符串中下标0到5的位置，第二行给出相应的负下标。从i到j的片段由在边界i和j之间的字符组成。

>>> a_string = "My alphabet starts where your alphabet ends."
>>> a_string[3:11]
"alphabet"
>>> a_string[3:-3]
"alphabet starts where your alphabet en"
>>> a_string[0:2]
"My"
>>> a_string[:18]
"My alphabet starts"
>>> a_string[18:]
" where your alphabet ends."

我们可以通过指定两个索引值来获得原字符串的一个slice。该操作的返回值是一个新串，依次包含了从原串中第一个索引位置开始，直到但是不包含第二个索引位置之间的所有字符。
就像给列表做分片一样，我们也可以使用负的索引值来分片字符串。
字符串的下标索引是从0开始的，所以a_string[0:2]会返回原字符串的前两个元素，从a_string[0]开始，直到但不包括a_string[2]。
如果省略了第一个索引值，Python会默认它的值为0。所以a_string[:18]跟a_string[0:18]的效果是一样的，因为从0开始是被Python默认的。
同样地，如果第2个索引值是原字符串的长度，那么我们也可以省略它。所以，在此处a_string[18:]跟a_string[18:44]的结果是一样的，因为这个串的刚好有44个字符。这种规则存在某种有趣的对称性。在这个由44个字符组成的串中，a_string[:18]会返回前18个字符，而a_string[18:]则会返回除了前18个字符以外字符串的剩余部分。事实上a_string[:n]总是会返回串的前n个字符，而a_string[n:]则会返回其余的部分，这与串的长度无关。

不合理的片段下标可以很好地得到解释：过大的下标被换成字符串长度，上界小于下界时返回空串。

word = 'HelpA'
>>> word[1:100]
'elpA'
>>> word[10:]
''
>>> word[2:1]
''

下标允许为负数，这时从右向左数。例如：

>>> word[-1]     # 最后一个字符
'A'
>>> word[-2]     # 倒数第二个字符
'p'
>>> word[-2:]    # 最后两个字符
'pA'
>>> word[:-2]    # 除最后两个字符外的部分
'Hel'
但要注意的是 -0 实际还是 0，所以它不会从右向左数！

超出范围的片段下标被截断，但在非片段的情况下不要这样：

>>> word[-100:]
'HelpA'
>>> word[-10]    # 错误
Traceback (innermost last):
  File "<stdin>", line 1
IndexError: string index out of range

示例：Python字符串逐字符或逐词反转方法

字符串逐字符反转
1. revchars=astring[::-1]
x='abcd'
In [66]: x[::-1]
Out[66]: 'dcba'

2. 采用reversed()，注意它返回的是一个迭代器，可以用于循环或传递给其它的“累加器”，不是一个已完成的字符串。
revchars=''.join(reversed(astring))
逐词反转
1. 创建一个列表，将列表反转，用join方法合并

s='Today is really a good day'

rev=' '.join(s.split()[::-1])

2. 可以不改变原先的空格，采用正则式来做revwords=' '.join(reversed(s.split()))
revwords=''.join(reversed(re.split(r'(\s+)',s)))

字符串条件判断

是否以start开头：str.startswith('start')
是否以end结尾：str.endswith('end')
是否全为字母（包括中文）或数字：str.isalnum()
是否全字母（包括中文）：str.isalpha()
是否全数字：str.isdigit()
是否全小写：str.islower()
是否全大写：str.isupper()

Note：中文的islower和isupper都返回False。

python判断字符串是否包含子串的方法

1. if 'abcde'.__contains__("abc")

2. if "abc" in 'abcde'

3.'abcde'.find('bcd') >= 0

4.'abcde'.count('bcd') > 0

5.try:
    string.index(ls,ss)
    print 'find it'
except(ValueError):
    print 'fail'

[http://blog.youkuaiyun.com/elvis_kwok/article/details/7405083]

python判断字符串是否是数字

# coding=utf-8
import re

# s.isdigit() # 只能判断字符串是不是都是纯数字,不能有+-.号

def IsFloatStr(s):
    '''
    浮点数判断
    '''
    # 正则表达式实现
    # return True if re.match(r'[-+]*\d+?\.{0,1}\d*$', s) else False
    try:
        float(s)
        return True
    except:
        return False


def IsIntStr(s):
    '''
    整数判断
    '''
    # 正则表达式实现
    # return True if re.match(r'[-+]*\d+$', s) else False
    try:
        int(s)
        return True
    except:
        return False


print('IsFloatStr')
for s in ['123', '-123', '+123', '-12.3', '-1.2.3', '123hello']:
    print(s, IsFloatStr(s))
print('\nIsIntStr')
for s in ['123', '-123', '+123', '-12.3', '-1.2.3', '123hello']:
    print(s, IsIntStr(s))

字符串格式化

字符串大小写处理

全部大写：str.upper()
全部小写：str.lower()

或者 str.casefold() 此方法与 Lower() 方法相似，但是 casefold() 方法更强大，更具攻击性，这意味着它将更多字符转换为小写字母，并且在比较两个用 casefold() 方法转换的字符串时会找到更多匹配项。
大小写互换：str.swapcase()
首字母大写，其余小写：str.capitalize()
首字母大写：str.title()

字符串补齐

获取固定长度，右对齐，左边不够用空格补齐：str.rjust(width)
获取固定长度，左对齐，右边不够用空格补齐：str.ljust(width)
获取固定长度，中间对齐，两边不够用空格补齐：str.center(width)
获取固定长度，右对齐，左边不足用0补齐：str.zfill(width) 或者 str.rjust(width, '0')

str.expandtabs(tabsize=8)

字符串搜索定位与替换

字符串搜索

搜索指定字符串，没有返回-1：str.find('t')

python字符串查找指定多个子字符串的所有位置：

a = "dhvka,feovj.dlfida?dfka.dlviaj,dlvjaoid,vjaoj?"
b = [i for i, j in enumerate(a) if j in [',', '.', '?']]
print(b)

[5, 11, 18, 23, 30, 39, 45]

指定起始位置搜索：str.find('t',start)
指定起始及结束位置搜索：str.find('t',start,end)
从右边开始查找：str.rfind('t')

上面所有方法都可用index代替，不同的是使用index查找不到会抛异常，而find返回-1

计数
搜索到多少个指定字符串：str.count('t')

字符串替换

替换old为new：str.replace('old','new')
替换指定次数的old为new：str.replace('old','new',maxReplaceTimes)
print '%s replace t to *=%s' % (str,str.replace('t', '*'))

print '%s replace t to *=%s' % (str,str.replace('t', '*',1))

字符串一次替换多个不同字符

将字符串中的[ ] '替换成空格

methon1: tags = re.sub("\[|\]|'", "", str(music_tag[music_name]))

methon3: [一次完成多个字符串的替换]

字符串去除空格及去除指定字符

去两边空格：str.strip()
去左空格：str.lstrip()
去右空格：str.rstrip() Python 字符分割时，只分割最后一个 str.rsplit("/",1)

去两边字符串（支持正则）：s.strip('{|}')

python删除字符串中空白字符：换行、空格、制表符

print(' '.join("Please \n don't \t hurt me.".split()))
输出：
Please don't hurt me.

字符串联合与分割

字符串连接str.join(iterable)

用指定的字符串，连接元素为字符串的可迭代对象。

'-'.join(['2012', '3', '12'])
# '2012-3-12'

'-'.join([2012, 3, 12])
# TypeError: sequence item 0: expected str instance, int found

字符串连接concat

字符串连接的几种不同方式

def concat1(): 
    z = x + y 
    return z 

 def concat2(): 
    z = "%s%s" % (x, y) 
    # z = "{}{}".format(x, y) 
    # z = "{0}{1}".format(x, y) 
    return z

字符串重复*号

用*号重复

'abc'*2

# 'abcabc'

字符串分割

不会出错的字符串分割符

句子分隔符，例如："\004"
词与词的分隔符，例如："\001"
词与词性的分隔符，例如："\002"

[Python中实现快速字符串连接]

string对象的 split() 方法只适应于非常简单的字符串分割情形，它并不允许有多个分隔符或者是分隔符周围不确定的空格，不支持正则。

当你需要更加灵活的切割字符串的时候，最好使用re.split() 方法。

分割字符串为数组：str.split()。
指定分隔符：str,str.split('-')。默认按\s类的分割符（空格|\t等）进行分隔。

字符串右分割

str.rsplit("/",1)

示例中是最大分割一次

str.rsplit(None,1)[-1]

默认分割符进行分割，并只分割一次，取最右边的数据。eg. "ad daf adfa"，这时返回"adfa"

使用正则表达式分割

[re.findall(pattern, string, flags=0)]

按字符分割，但数字连在一起
split_result = re.findall(r'\d+|\D', input_string)
或者split_result = re.findall(r'\d+|.', input_string)

或者

def split_string(input_string):
result = []
current_number = ''

for char in input_string:
if char.isdigit():
current_number += char
else:
if current_number:
result.append(current_number)
current_number = ''
result.append(char)

if current_number:
result.append(current_number)

return result
# 示例用法
input_string = '燃油1457434310专供TED腾家ab123cd456ef'
split_result = split_string(input_string)

['燃', '油', '1457434310', '专', '供', 'T', 'E', 'D', '腾', '家', 'a', 'b', '123', 'c', 'd', '456', 'e', 'f']

按字符分割，但多个数字或多个英文字母连在一起（数字和英文要分开）
split_result = re.findall(r'\d+|[a-zA-Z]+|\D', input_string)
或者split_result = re.findall(r'\d+|[a-zA-Z]+|.', input_string)

['燃', '油', '1457434310', '专', '供', 'TED', '腾', '家', 'ab', '123', 'cd', '456', 'ef']

splitlines()方法

splitlines()方法以多行字符串作为输入，返回一个由字符串组成的列表，列表的元素即原来的单行字符串。请注意，每行行末的回车符没有被包括进去。

>>> s = """Finished files are the re-
... sult of years of scientif-
... ic study combined with the
... experience of years."""
>>> s.splitlines()
["Finished files are the re-", "sult of years of scientif-", "ic study combined with the", "experience of years."]

格式化字符串

自python2.6开始，新增了一种格式化字符串的函数str.format()，可谓威力十足。跟之前的%型格式化字符串相比是优越的存在。

一个等价的方式是：f"Process total {cnt} rows !"

语法

它通过{}和:来代替%。
'{},{}'.format('kzc',18)
'kzc,18'

“映射”

位置“映射”

In [1]: '{0},{1}'.format('kzc',18)  
Out[1]: 'kzc,18'  
In [3]: '{1},{0},{1}'.format('kzc',18)  
Out[3]: '18,kzc,18'

字符串的format函数可以接受不限个参数，位置可以不按顺序，可以不用或者用多次，不过2.6不能为空{}，2.7才可以。
关键字“映射”

In [5]: '{name},{age}'.format(age=18,name='kzc')  
Out[5]: 'kzc,18'

对象属性“映射”

class Person:  
    def __init__(self,name,age):  
        self.name,self.age = name,age  
        def __str__(self):  
            return 'This guy is {self.name},is {self.age} old'.format(self=self)

In [2]: str(Person('kzc',18))  
Out[2]: 'This guy is kzc,is 18 old'

下标“映射”

In [7]: p=['kzc',18]
In [8]: '{0[0]},{0[1]}'.format(p)
Out[8]: 'kzc,18'

有了这些便捷的“映射”方式，我们就有了偷懒利器。基本的python知识告诉我们，list和tuple可以通过“打散”成普通参数给函数，而dict可以打散成关键字参数给函数（通过和*）。所以可以轻松的传个list/tuple/dict给format函数。非常灵活。

格式限定符

它有着丰富的的“格式限定符”（语法是{}中带:号），比如：

填充与对齐
填充常跟对齐一起使用
^、<、>分别是居中、左对齐、右对齐，后面带宽度；:号后面带填充的字符，只能是一个字符，不指定的话默认是用空格填充。
比如

In [15]: '{:>8}'.format('189')
Out[15]: '     189'
In [16]: '{:0>8}'.format('189')
Out[16]: '00000189'
In [17]: '{:a>8}'.format('189')
Out[17]: 'aaaaa189'
print('{:*^60}'.format(' 每个TERMINALNO 数据记录数 ')) 
******************** 每个TERMINALNO 数据记录数 ********************
 （中文字符居然只算1个字符，所以有中文字符时候输出不同行还是对不齐）

Note: 如果是使用{：>20}格式化列表，要先将列表转化成str()，否则报错TypeError: unsupported format string passed to list.__format__．

精度与类型f
精度常跟类型f一起使用

In [44]: '{:.2f}'.format(321.33345)
Out[44]: '321.33'

其中.2表示长度为2的精度，f表示float类型。

其他类型
主要就是进制了，b、d、o、x分别是二进制、十进制、八进制、十六进制。

In [54]: '{:b}'.format(17)
Out[54]: '10001'
In [55]: '{:d}'.format(17)
Out[55]: '17'
In [56]: '{:o}'.format(17)
Out[56]: '21'
In [57]: '{:x}'.format(17)
Out[57]: '11'

设置二进制输出位宽：32位输出，前面不足的补0。

print('{:032b}'.format(i)) # bin(i)

用，号还能用来做金额的千位分隔符

In [47]: '{:,}'.format(1234567890)
Out[47]: '1,234,567,890'

python 2.x和3.x中的字符串编码区别String vs. Bytes

[python字符串编码及区别]

from:http://blog.youkuaiyun.com/pipisorry/article/details/42085723

ref: Python 的内置字符串方法（收藏专用）