python之Character string

本文和大家分享的主要是python 中Character string相关内容，一起来看看吧，希望对大家 学习python 有所帮助。

　　1 、 python 字符串

　　字符串是 Python  中最常用的数据类型。我们可以使用引号 (' 或 ") 来创建字符串， l

Python 不支持单字符类型，单字符也在 Python 也是作为一个字符串使用。

　　>>> var1 = 'hello python'    # 定义字符串

　　>>> print(var1[0])     # 切片截取，从 0 开始，不包括截取尾数

　　h

　　>>> print(var1[0:5])

　　hello

　　>>> print(var1[-6:])

　　python

　　>>> var2 = var1[0:6]+'world'   # 截取字符并拼接赋值给新变量

　　>>> print(var2)

　　hello world

　　2 、 python 转义字符

　　\ : 在行尾时，为续行符

　　\\ : 反斜杠转义，输出 '\'

　　\' : 单引号转义

　　\" : 双引号转义

　　\b : 退格（ backspace ）

　　\n : 换行

　　\v : 纵向制表符

　　\t : 横向制表符

　　\r : 回车

　　\f : 换页

　　3 、 python 字符串运算符

(+) 拼接， (*) 重复， ([]) 索引， ([:]) 切片， (in) 成员判断， (not in) 非成员判断， (r/R) 元素输出字符串

　　>>> var1 = 'hello'

　　>>> var2 = 'python'

　　>>> print(var1+var2)   # 拼接字符串

　　hellopython

　　>>> print(var1*3)   # 重复输出字符串

　　hellohellohello

　　>>> print(var1[0])  # 索引字符串

　　h

　　>>> print(var1[3:])  # 索引切片

　　lo

　　>>> 'e' in var1   # 判断字符串是否在变量中

　　True

　　>>> 'p' not in var1  # 判断字符串是否不在变量中

　　True

　　>>> print("he\tllo \n")

　　he    llo

　　>>> print(r"he\tllo \n") # 原始输出字符串，也就是原始输出转义字符

　　he\tllo \n

　　4 、格式化字符串

　　Python  支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s  的字符串中。

　　在 Python  中，字符串格式化使用与  C  中  sprintf  函数一样的语法。

　　python 字符串格式化符号：

　　%c 格式化字符及其 ASCII 码

　　%s 格式化字符串

　　%d 格式化整数

　　%u 格式化无符号整型

　　%o 格式化无符号八进制数

　　%x 格式化无符号十六进制数

　　%X 格式化无符号十六进制数（大写）

　　%f 格式化浮点数字，可指定小数点后的精度

　　%e 用科学计数法格式化浮点数

　　%E 作用同 %e ，用科学计数法格式化浮点数

　　%g%f 和 %e 的简写

　　%G%f  和  %E  的简写

　　%p 用十六进制数格式化变量的地址

　　格式化操作符辅助指令：

　　* 定义宽度或者小数点精度

　　- 用做左对齐

　　+ 在正数前面显示加号 ( + )

　　在正数前面显示空格

　　# 在八进制数前面显示零 ('0') ，在十六进制前面显示 '0x' 或者 '0X'( 取决于用的是 'x' 还是 'X')

　　0 显示的数字前面填充 '0' 而不是默认的空格

　　%'%%' 输出一个单一的 '%'

　　(var) 映射变量 ( 字典参数 )

m.n.m  是显示的最小总宽度 ,n  是小数点后的位数 ( 如果可用的话 )

　　>>> print("ascii:%c"%'s')  # 格式化输出字符

　　ascii:s

　　>>> print("ascii:%c"%'1')  # 格式化输出数字

　　ascii:1

　　>>> print("str:%s"%'character string')  # 格式化字符串

　　str:character string

　　>>> print("str:%d"%888)   # 格式化整数

　　str:888

　　>>> print("str:%f"%888)   # 格式浮点数

　　str:888.000000

　　>>> print("str:%e"%888)  # 格式化科学计数浮点数

　　str:8.880000e+02

　　>>> print("str:%E"%888)  # 同上

　　str:8.880000E+02

　　>>> print("str:%G"%888)  #%f 和 %E 的简写

　　str:888

　　>>> print("str:%20f"%888.089)   # 定义 20 宽度输出

　　str:          888.089000

　　>>> print("str:%-20f"%888.089)  # 用左对齐

　　str:888.089000

　　>>> print("str:%+20f"%888.089)  # 在正数前显示加号

　　str:         +888.089000

　　>>> print("str:%+-20f"%888.089)   # 左对齐显示加号

　　str:+888.089000

　　>>> print("str:%020f"%888.089)   # 以 0 填充默认的空格

　　str:0000000000888.089000

　　>>> print("str:%%%20f"%888.089)  # 在数字前输入 % 号

　　str:%          888.089000

　　>>> print("str:%%%-20f"%888.089)  # 左对齐输出 % 号

　　str:%888.089000

　　>>> print("str:%20.3f"%888.089)   # 显示最小总宽度 20 ，小数点后位数为 3 位

　　str:             888.089

自python2.6 开始，增加格式化字符串函数 str.format():

　　用法：它通过{} 和 : 来代替 %

　　位置参数不受顺序约束，且可以为{} 空 , 只要 format 里有相对应的参数值即可 , 如参数值不够就会报错，参数索引从 0 开，传入位置参数列表可用 * 列表

　　In [27]: '{}+{}={}'.format(1,2,3)   # 格式化按顺序应用参数值

　　Out[27]: '1+2=3'

　　In [28]: '{2}-{1}={0}'.format(1,2,3)  # 指定顺序应用参数值

　　Out[28]: '3-2=1'

　　In [29]: '{0}+{0}={1}'.format(2,3)  # 指定参数可以重复使用

　　Out[29]: '2+2=3'

　　In [30]: '{}+{}={}'.format(2,3)   # 如不指定顺序， format 参数不够就会报错

　　---------------------------------------------------------------------------

　　IndexError                                Traceback (most recent call last)

　　 in < module>()

　　----> 1 '{}+{}={}'.format(2,3)IndexError: tuple index out of range

　　In [31]: l1 = [2,4,8]

　　In [32]: '{}*{}={}'.format(*l1)   # 使用列表引用参数值

　　Out[32]: '2*4=8'

　　In [33]: dct = {'name':'python','age':20}   # 定义字典

　　In [35]: 'welcom to {name},age is {age}'.format(name='qi',age=28) # 变量引用

　　Out[35]: 'welcom to qi,age is 28'

　　In [36]: 'welcom to {name},age is {age}'.format(**dct) # 使用 ** 引用字典参数必须填写 key 值

　　Out[36]: 'welcom to python,age is 20'

　　填充与格式化：

　　In [53]: "{0: >20}".format("string")   # 从 0 位开始已空格填充 20 宽度左对齐

　　Out[53]: '              string'

　　In [54]: "{0:&>20}".format("string")

　　Out[54]: '&&&&&&&&&&&&&&string'

　　In [55]: "{0:#>20}".format("string") # 使用 # 号会有个小 bug

　　....:

　　Out[55]: '##############string'

　　In [60]: '{0:+<20}'.format("string")  # 向右对齐填充 +

　　Out[60]: 'string++++++++++++++'

　　In [61]: '{0:+^20}'.format("string")  # 剧中对齐填充 +

　　Out[61]: '+++++++string+++++++'

　　精度与进制：

　　>>> '{0:.3f}'.format(10/3)    # 小数位进度格式化

　　'3.333'

　　>>> '{0:b}'.format(8)    # 格式化二进制

　　'1000'

　　>>> '{0 

}'.format(9)  # 格式化八进制

　　'11'

　　>>> '{0:x}'.format(26) # 格式化十六进制

　　'1a'

　　>>> '{0:,}'.format(123456789)  # 千分位格式化

　　'123,456,789'

　　使用索引：

　　>>> l2 = ['AA',{'bb':'cc'},('d','e')]   # 列表索引引用

　　>>> 'outing:{0[0]}'.format(l2)

　　'outing:AA'

　　>>> 'outing:{0[0]},{0[1]}'.format(l2)  # 将列表当成一个元素，在其中索引值

　　"outing:AA,{'bb': 'cc'}"

　　5 、 python 的字符串方法

　　1 >>> s = 'i mi to'     # 将字符串的第一个字符改为大写

　　2 >>> s.capitalize()

　　3 'I mi to'

　　4

　　5 >>> s = 'I MI TO'  # 将字符串所有字符改为小写

　　6 >>> s.casefold()

　　7 'i mi to'

　　8

　　9 >>> s.center(15)  # 将字符串剧中，并用空格将字符串填充长度，如指定长度小于实际长度则没有效果

　　10 '    I MI TO    '

　　11

　　12 >>> s = 'abcabcabcabc' # 返回 sub 在字符串里出现的次数， start ， end 为可选参数，决定范围

　　13 >>> s.count('a',0,12)

　　14 4

　　15 >>> s.encode(encoding='utf-8',errors='strict') # 以 encoding 指定的编码格式对字符串进行编码

　　16 b'abcabcabcabc'

　　17 >>> s.endswith('abc',1,12)  # 检查字符串是否以 sub 结尾，是返回 True, 否返回 False ， start ， end为可选参数，决定范围

　　18 True

　　19

　　20 >>> s = 'a\tb\tc'

　　21 >>> s.expandtabs(4)   # 把字符串的 tab 字符（ \t ）转化为空格，如不指定 tabsize, 默认为 8 个空格

　　22 'a   b   c'

　　23

　　24 >>> s.find('b')  # 检测字符串是否在字符串中，如在则返回索引，否则返回 -1 ，可指定起始值。

　　25 2

　　26

　　27 >>> s='hello python'

　　28 >>> s.index('hello')   #  类似 find() ，不同在于如果 sub 不在字符串中，返回异常

　　29 0

　　30

　　31 >>> s.isalnum()    # 有空格返回 false

　　32 False

　　33 >>> s='hellopython'

　　34 >>> s.isalnum()   # 如果字符串至少有一个字符，并且所有字符都是字母或数字则返回 True, 否则False

　　35 True

　　36 >>> s.isalpha()  # 如果字符串至少有一个字符，并且所有字符都是字母则返回 True, 否则 False

　　37 True

　　38

　　39 >>> s = '123'

　　40 >>> s.isdigit()  # 如果字符串只包含数字则返回 True, 否则返回 False

　　41 True

　　42

　　43 >>> s = '123'

　　44 >>> s.isdecimal()  # 如果字符串只包含十进制数字则返回 True ，否则返回 False

　　45 True

　　46 >>> s= 'ox123'

　　47 >>> s.isdecimal()

　　48 False

　　49 >>> s = '0.33'

　　50 >>> s.isdecimal()

　　51 False

　　52

　　53 >>> s = 'abc'

　　54 >>> s.islower()  # 如果字符中至少包含一个能区分大小写的字符，并且这些字符都是小写则返回True, 否则返回 Flase

　　55 True

　　56 >>> s = 'Abc'

　　57 >>> s.islower()

　　58 False

　　59

　　60 >>> s = 'ABC'

　　61 >>> s.isupper()  # 果字符中至少包含一个能区分大小写的字符，并且这些字符都是大写则返回 True,否则返回 Flase

　　62 True

　　63 >>> s = 'ABc'

　　64 >>> s.isupper()

　　65 False

　　66 >>>

　　67

　　68 >>> s = '123'

　　69 >>> s.isnumeric()  # 如果字符串只包含数字字符，则返回 True, 否则返回 False

　　70 True

　　71 >>> s = '123a'

　　72 >>> s.isnumeric()

　　73 False

　　74

　　75 >>> 'def'.isidentifier()  # 判断字符串是否包含该语言的保留字

　　76 True

　　77

　　78 >>> 'aaa'.isprintable() # 判断是否可以打印

　　79 True

　　80

　　81 >>> ''.isspace()

　　82 False

　　83 >>> ' '.isspace()  # 判断字符串中至少有一个字符且所有都是空格，否则返回 false

　　84 True

　　85 >>> ' a'.isspace()

　　86 False

　　87

　　88 >>> 'Abc'.istitle()  # 判断是否是标题 格式，可以理解为首字母大写。

　　89 True

　　90 >>> 'aBC'.istitle()

　　91 False

　　92

　　93 >>> s = '123'

　　94 >>> '_'.join(s)  # 返回一个用指定字符串分隔的字，或者是将指定字符加入到另一个字符中。

　　95 '1_2_3'

　　96 >>> s.join('abc')

　　97 'a123b123c'

　　98

　　99 >>> s = 'ABC'

　　100 >>> s.lower()  # 返回的是指定字符串的拷贝，并转化成小写

　　101 'abc'

　　102

　　103 >>> s.ljust(10,'+')  # 可以指定宽度，以及填充字符串，返回的是按宽度，填充字符串格式化后的左对齐的字符串。

　　104 'ABC+++++++'

　　105

　　106 >>> 'aaabccc'.partition('b')  # 在字符串中查找指定的字符，如找到则返回字符前部分，字符本身和后部分，如没找到则返回字符串和两个空字符串。

　　107 ('aaa', 'b', 'ccc')

　　108 >>> 'aaabccc'.partition('e')

　　109 ('aaabccc', '', '')

　　110

　　111 >>> 'aaabccc'.rpartition('b')  # 与 partition 一样，但是是从右边开始

　　112 ('aaa', 'b', 'ccc')

　　113 >>> 'aaabccc'.rpartition('c')

　　114 ('aaabcc', 'c', '')

　　115

　　116

　　117 >>> 'aaaaabbcc'.replace('a','A')  # 用指定字符串替换指定字符串，如果不指定替换次数，则替换所有

　　118 'AAAAAbbcc'

　　119 >>> 'aaaaabbcc'.replace('a','A',2)

　　120 'AAaaabbcc'

　　121

　　122 >>> 'aabbcc'.rfind('a')  # 返回指定子串的最高索引，如果没找到则返回 -1 ，可以指定要开始替换的起始，结束位置。

　　123 1

　　124 >>> 'aabbcc'.rfind('e')

　　125 -1

　　126 >>> 'aabbcc'.rindex('a')  # 与上面的 rfind 一样，只是如果没找到不是返回 -1 ，而是触发错误

　　127 1

　　128 >>> 'aabbcc'.rindex('e')

　　129 Traceback (most recent call last):

　　130   File "", line 1, in

　　131 ValueError: substring not found

　　132

　　133 >>> 'aa'.rjust(10,'+')  # 与 ljust() 相对应，右对齐

　　134 '++++++++aa'

　　135 >>> 'aa'.ljust(10,'+')

　　136 'aa++++++++'

　　137

　　138 >>> 'aabccbddbee'.split('b')  ## 按指定字符串对目标字符串进行切割，可以指定切割次数

　　139 ['aa', 'cc', 'dd', 'ee']

　　140 >>> 'aabccbddbee'.split('b',2)

　　141 ['aa', 'cc', 'ddbee']

　　142

　　143 >>> 'aabccbddbee'.rsplit('b',2) # 与 split 作用相同，但是从右侧开始

　　144 ['aabcc', 'dd', 'ee']

　　145

　　146 >>> '  aabb  '.strip()  # 移除字符串两侧的指定字符串，默认移除空格，需要注意的是可以指定多个字符

　　147 'aabb'

　　148 >>> '  aabb'.strip('b')

　　149 '  aa'

　　150 >>> '  aabb'.strip('ab')

　　151 '  '

　　152 >>> 'beaacebb'.rstrip('eb')  # 与 strip 一样，从右侧删除指定字符，可以为多个

　　153 'beaac'

　　154

　　155 >>> 'aa\nbb\ncc\ndd'.splitlines()  # 按换行符切割显示，如没指定 keepends=True 则将换行符移除。

　　156 ['aa', 'bb', 'cc', 'dd']

　　157 >>> 'aa\nbb\ncc\ndd'.splitlines(keepends=True)

　　158 ['aa\n', 'bb\n', 'cc\n', 'dd']

　　159

　　160 >>> 'aabbc'.startswith('a') # 判断字符串是否以某个字符开头，可以是多字符

　　161 True

　　162 >>> 'aabbc'.startswith('b')

　　163 False

　　164 >>> 'aabbc'.startswith('aab')

　　165 True

　　166

　　167 >>> 'aaBBcc'.swapcase()  # 转换大小写

　　168 'AAbbCC'

　　169

　　170 >>> 'wend is ok'.title()   # 标题格式，首字母大写，其它字符小写

　　171 'Wend Is Ok'

　　172

　　173 >>> 'wend is ok'.upper()  # 将字符全部转换成大写

　　174 'WEND IS OK'

　　175

　　176 >>> 'wend is ok'.zfill(20)  # 这里的 z 指 zero ，用 0 将字符填充到指定长度

　　177 '0000000000wend is ok'

来源：博客园