Python复习笔记——字符串的使用

Python复习笔记——字符串的使用

• 最早的字符串编码是美国标准信息交换码ASCII，仅对10个数字、26个大写英文字母、26个小写英文字母及一些其他符号进行了编码。ASCII码采用1个字节来对字符进行编码，最多只能表示256个符号

• GB2312是我国制定的中文编码，使用1个字节表示英语，2个字节表示中文；GBK是GB2312的扩充，而CP936是微软在GBK基础上开发的编码方式。GB2312、GBK和CP936都是使用2个字节表示中文

• UTF-8对全世界所有国家需要用到的字符进行了编码，以1个字节表示英语字符(兼容ASCII)，以3个字节表示常见汉字，还有些语言的符号使用2个字节（例如俄语和希腊语符号）或者4个字节

• Python 3.x完全支持中文字符，默认使用UTF8编码格式，无论是一个数字、英文字母，还是一个汉字，在统计字符串长度时都按一个字符对待和处理

>>> s = '中国山东青岛'
>>> len(s)                   #字符串长度，或者包含的字符个数
6
>>> s = '中国山东青岛ABCDE'   #中文与英文字符同样对待，都算一个字符
>>> len(s)
11
>>> 姓名 = '张三'             #使用中文作为变量名
>>> print(姓名)               #输出变量的值
张三

字符串格式化

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mw9uarRX-1653795443122)(C:\Users\CrazyBin\AppData\Roaming\Typora\typora-user-images\image-20220528201728603.png)]

• 常用格式字符

格式字符	说明
%s	字符串 (采用str()的显示)
%r	字符串 (采用repr()的显示)
%c	单个字符
%d	十进制整数
%i	十进制整数
%o	八进制整数
%x	十六进制整数
%e	指数 (基底写为e)
%E	指数 (基底写为E)
%f、%F	浮点数
%g	指数(e)或浮点数 (根据显示长度)
%G	指数(E)或浮点数 (根据显示长度)
%%	一个字符%

>>> x = 1235
>>> "%o" % x
"2323"
>>> "%x" % x
"4d3"
>>> "%e" % x
"1.235000e+03"
>>> "%s" % 65
"65"
>>> "%d,%c" % (65,65)
"65,A"
>>> "%d" % "555"
TypeError: %d format: a number is required, not str
>>> '%s'%[1, 2, 3]        #直接把对象转换成字符串
'[1, 2, 3]'

• str.format() 方法通过字符串的花括号 {} 来识别替换字段，从而完成字符串的格式化

替换字段由字段名、转换字段以及格式说明符组成，即一般形式为：

{字段名!转换字段:格式说明符}

字段名有三种写法：省略不写、十进制非负整数、合法的Python标识符

转换字段的取值有三种：s, r, a, 分别表示传递参数之前先对参数调用str()，repr()以及ascii()函数

• 使用format方法进行格式化

>>> print("The number {0:,} in hex is: {0:#x}, the number {1} in oct is {1:#o}".format(5555,55))
The number 5,555 in hex is: 0x15b3, the number 55 in oct is 0o67
>>> print("The number {1:,} in hex is: {1:#x}, the number {0} in oct is {0:o}".format(5555,55))
The number 55 in hex is: 0x37, the number 5555 in oct is 12663
>>> print("my name is {name}, my age is {age}, and my QQ is {qq}".format(name="Zhang san",age=40,qq="30646****"))
my name is Zhang san, my age is 40, and my QQ is 30646****
>>> position = (5, 8, 13)
>>> print("X:{0[0]};Y:{0[1]};Z:{0[2]}".format(position))
X:5;Y:8;Z:13
>>> '{0:<8d},{0:^8d},{0:>8d}'.format(65) #设置对齐方式
'65      ,   65   ,      65
>>> '{0:+<8d},{0:-^8d},{0:=>8d}'.format(65)
'65++++++,---65---,======65'

weather = [("Monday","rainy"),("Tuesday","sunny"),
           ("Wednesday", "sunny"),("Thursday","rainy"),
           ("Friday","cloudy")]
formatter = "Weather of '{0[0]}' is '{0[1]}'".format
for item in map(formatter,weather):
    print(item)
for item in weather:
    print(formatter(item))
运行结果：
Weather of 'Monday' is 'rainy'
Weather of 'Tuesday' is 'sunny'
Weather of 'Wednesday' is 'sunny'
Weather of 'Thursday' is 'rainy'
Weather of 'Friday' is 'cloudy'

• Python 3.6.x开始支持一种新的字符串格式化方式，官方叫做Formatted String Literals，在字符串前加字母f，含义与字符串对象format()方法类似

>>> width = 8
>>> height = 6
>>> print(f'Rectangle of {width}*{height}\nArea:{width*height}')
Rectangle of 8*6
Area:48

字符串常用方法

find()、rfind()、index()、rindex()、count()

• find()和rfind方法分别用来查找一个字符串在另一个字符串指定范围（默认是整个字符串）中首次和最后一次出现的位置，如果不存在则返回-1

• index()和rindex()方法用来返回一个字符串在另一个字符串指定范围中首次和最后一次出现的位置，如果不存在则抛出异常

• count()方法用来返回一个字符串在当前字符串中出现的次数

>>> s="apple,peach,banana,peach,pear"
>>> s.find("peach")
6
>>> s.find("peach",7)
19
>>> s.find("peach",7,20)
-1
>>> s.rfind('p')
25
>>> s.index('p')
1
>>> s.index('pe')
6
>>> s.index('pear')
25
>>> s.index('ppp')
Traceback (most recent call last):
  File "<pyshell#11>", line 1, in <module>
    s.index('ppp')
ValueError: substring not found
>>> s.count('p')
5
>>> s.count('pp')
1
>>> s.count('ppp')
0

split()、rsplit()、partition()、rpartition()

• split()和rsplit()方法分别用来以指定字符为分隔符，把当前字符串从左往右或从右往左分隔成多个字符串，并返回包含分隔结果的列表
• partition()和rpartition()用来以指定字符串为分隔符将原字符串分隔为3部分，即分隔符前的字符串、分隔符字符串、分隔符后的字符串，如果指定的分隔符不在原字符串中，则返回原字符串和两个空字符串

>>> s = "apple,peach,banana,pear"
>>> s.split(",")
["apple", "peach", "banana", "pear"]
>>> s.partition(',')
('apple', ',', 'peach,banana,pear')
>>> s.rpartition(',')
('apple,peach,banana', ',', 'pear')
>>> s.rpartition('banana')
('apple,peach,', 'banana', ',pear')
>>> s = "2017-10-31"
>>> t = s.split("-")
>>> print(t)
['2017', '10', '31']
>>> print(list(map(int, t)))
[2017, 10, 31]

• 对于split()和rsplit()方法，如果不指定分隔符，则字符串中的任何空白符号（空格、换行符、制表符等）都将被认为是分隔符，并删除切分结果中的空字符串

>>> s = 'hello world \n\n My name is Dong   '
>>> s.split()
['hello', 'world', 'My', 'name', 'is', 'Dong']
>>> s = '\n\nhello world \n\n\n My name is Dong   '
>>> s.split()
['hello', 'world', 'My', 'name', 'is', 'Dong']
>>> s = '\n\nhello\t\t world \n\n\n My name\t is Dong   '
>>> s.split()
['hello', 'world', 'My', 'name', 'is', 'Dong']

• 然而，明确传递参数指定split()使用的分隔符时，情况是不一样的，会保留切分得到的空字符串

>>> 'a,,,bb,,ccc'.split(',')       #每个逗号都被作为独立的分隔符
['a', '', '', 'bb', '', 'ccc']
>>> 'a\t\t\tbb\t\tccc'.split('\t') #每个制表符都被作为独立的分隔符
['a', '', '', 'bb', '', 'ccc']
>>> 'a\t\t\tbb\t\tccc'.split()     #连续多个制表符被作为一个分隔符
['a', 'bb', 'ccc']

• split()和rsplit()方法还允许指定最大分割次数

>>> s = '\n\nhello\t\t world \n\n\n My name is Dong   '
>>> s.split(None, 1)        #不指定分隔符，使用空白字符作为分隔符
['hello', 'world \n\n\n My name is Dong   ']
>>> s.rsplit(None, 1)
['\n\nhello\t\t world \n\n\n My name is', 'Dong']
>>> s.split(None, 2)
['hello', 'world', 'My name is Dong   ']
>>> s.rsplit(None, 2)
['\n\nhello\t\t world \n\n\n My name', 'is', 'Dong']
>>> s.split(maxsplit=6)
['hello', 'world', 'My', 'name', 'is', 'Dong']
>>> s.split(maxsplit=100)   #最大分隔次数大于可分隔次数时无效
['hello', 'world', 'My', 'name', 'is', 'Dong']

字符串连接join()

>>> li = ["apple", "peach", "banana", "pear"]
>>> ','.join(li)
'apple,peach,banana,pear'
>>> '.'.join(li)
'apple.peach.banana.pear'
>>> '::'.join(li)
'apple::peach::banana::pear'

• 将字符串重复指定次数，并使用指定的分隔符进行连接，结果字符串最后不带分隔符。例如，concat(‘good’, 5, ‘,’)的返回结果为’good,good,good,good,good’

def concat(s, n, separator):
    return separator.join([s]*n)

print(concat('good', 5, ','))

lower()、upper()、capitalize()、title()、swapcase()

>>> s = "What is Your Name?"
>>> s.lower()                   #返回小写字符串
'what is your name?'
>>> s.upper()                   #返回大写字符串
'WHAT IS YOUR NAME?'
>>> s.capitalize()              #字符串首字符大写
'What is your name?'
>>> s.title()                   #每个单词的首字母大写
'What Is Your Name?'
>>> s.swapcase()                #大小写互换
'wHAT IS yOUR nAME?'

replace()

>>> words = ('测试', '非法', '暴力', '话')
>>> text = '这句话里含有非法内容'
>>> for word in words:
    if word in text:
        text = text.replace(word, '***')		
>>> text
'这句***里含有***内容'

makestrans() translate()

• 字符串对象的maketrans()方法用来生成字符映射表，而translate()方法用来根据映射表中定义的对应关系转换字符串并替换其中的字符，使用这两个方法的组合可以同时处理多个字符

#创建映射表，将字符"abcdef123"一一对应地转换为"uvwxyz@#$"
>>> table = ''.maketrans('abcdef123', 'uvwxyz@#$')
>>> s = "Python is a great programming language. I like it!"
>>> s.translate(table)          #按映射表进行替换
'Python is u gryut progrumming lunguugy. I liky it!'
>>> table = ''.maketrans('0123456789', '零一二三四伍陆柒捌玖')
>>> '2018年12月31日'.translate(table)
'二零一捌年一二月三一日'

strip()、rstrip()、lstrip()

>>> s = " abc  "
>>> s.strip()                             #删除空白字符
'abc'
>>> '\n\nhello world   \n\n'.strip()      #删除空白字符
'hello world'
>>> "aaaassddf".strip("a")                #删除指定字符
'ssddf'
>>> "aaaassddf".strip("af")
'ssdd'
>>> "aaaassddfaaa".rstrip("a")            #删除字符串右端指定字符
'aaaassddf'
>>> "aaaassddfaaa".lstrip("a")            #删除字符串左端指定字符
'ssddfaaa'

• 这三个方法的参数指定的字符串并不作为一个整体对待，而是在原字符串的两侧、右侧、左侧删除参数字符串中包含的所有字符，一层一层地从外往里扒

>>> 'aabbccddeeeffg'.strip('af')  #字母f不在字符串两侧，所以不删除
'bbccddeeeffg'
>>> 'aabbccddeeeffg'.strip('gaf')
'bbccddeee'
>>> 'aabbccddeeeffg'.strip('gaef')
'bbccdd'
>>> 'aabbccddeeeffg'.strip('gbaef')
'ccdd'
>>> 'aabbccddeeeffg'.strip('gbaefcd')

eval()

>>> eval("3+4")                             #计算表达式的值
7
>>> a = 3
>>> b = 5
>>> eval('a+b')                             #要求变量a和b已存在
8
>>> import math
>>> eval('math.sqrt(3)')
1.7320508075688772
>>> eval('aa')                              #当前上下文中不存在对象aa
NameError: name 'aa' is not defined
>>> eval('*'.join(map(str, range(1, 6))))   #5的阶乘
120

eval()函数是非常危险的

>>> a = input("Please input:")
Please input:__import__('os').startfile(r'C:\Windows\notepad.exe')
>>> eval(a)
>>> eval("__import__('os').system('md testtest')")

成员判断in

>>> "a" in "abcde"     #测试一个字符中是否存在于另一个字符串中
True
>>> 'ab' in 'abcde'
True
>>> 'ac' in 'abcde'    #关键字in左边的字符串作为一个整体对待
False
>>> "j" in "abcde"
False

s.startswith(t)、s.endswith(t)

• s.startswith(t)、s.endswith(t)，判断字符串是否以指定字符串开始或结束

>>> s = 'Beautiful is better than ugly.'
>>> s.startswith('Be')           #检测整个字符串
True
>>> s.startswith('Be', 5)        #指定检测范围起始位置
False
>>> s.startswith('Be', 0, 5)     #指定检测范围起始和结束位置
True
>>> import os
>>> [filename for filename in os.listdir(r‘D:\\')
     if filename.endswith(('.bmp','.jpg','.gif'))]

center()、ljust()、rjust()

• center()、ljust()、rjust()，返回指定宽度的新字符串，原字符串居中、左对齐或右对齐出现在新字符串中，如果指定宽度大于字符串长度，则使用指定的字符（默认为空格）进行填充

>>> 'Hello world!'.center(20)        #居中对齐，以空格进行填充
'    Hello world!    '
>>> 'Hello world!'.center(20, '=')   #居中对齐，以字符=进行填充
'====Hello world!===='
>>> 'Hello world!'.ljust(20, '=')    #左对齐
'Hello world!========'
>>> 'Hello world!'.rjust(20, '=')    #右对齐
'========Hello world!'

isalnum()、isalpha()、isdigit()、isdecimal()、isnumeric()、isspace()、isupper()、islower()

• isalnum()、isalpha()、isdigit()、isdecimal()、isnumeric()、isspace()、isupper()、islower()，用来测试字符串是否为数字或字母、是否为字母、是否为数字字符、是否为空白字符、是否为大写字母以及是否为小写字母

>>> '1234abcd'.isalnum()
True
>>> '1234abcd'.isalpha()         #全部为英文字母时返回True
False
>>> '1234abcd'.isdigit()         #全部为数字时返回True
False
>>> 'abcd'.isalpha()
True
>>> '1235.0'.isdigit()
False
>>> '1234'.isdigit()
True
>>> '九'.isnumeric()             #isnumeric()方法支持汉字数字
True
>>> '九'.isdigit()
False
>>> '九'.isdecimal()
False
>>> 'ⅣⅢⅩ'.isdecimal()
False
>>> 'ⅣⅢⅩ'.isdigit()
False
>>> 'ⅣⅢⅩ'.isnumeric()         #支持罗马数字
True

内置函数

• 除了字符串对象提供的方法以外，很多Python内置函数也可以对字符串进行操作，例如：

>>> x = 'Hello world.'
>>> max(x), min(x), len(x)
('w', ' ', 12)
>>> max(['abc', 'ABD'], key=str.upper) #忽略大小写
'ABD'
>>> sorted(x)
[' ', '.', 'H', 'd', 'e', 'l', 'l', 'l', 'o', 'o', 'r', 'w']
>>> list(zip(x,x))                     #zip()也可以作用于字符串
[('H', 'H'), ('e', 'e'), ('l', 'l'), ('l', 'l'), ('o', 'o'), (' ', ' '), ('w', 'w'), ('o', 'o'), ('r', 'r'), ('l', 'l'), ('d', 'd'), ('.', '.')]
>>> eval('[1, 2, 3, 4]')		        #字符串求值
[1, 2, 3, 4]

• 切片也适用于字符串，但仅限于读取其中的元素，不支持字符串修改

>>> 'Explicit is better than implicit.'[:8]
'Explicit'
>>> 'Explicit is better than implicit.'[9:23]
'is better than'