夯实Python基础（2）

Python字符串

我们知道，字符串是Python的内置对象，用来存储和表现基于文本的信息。通过《Python入门》的学习，我们已经了解和掌握了字符串的如下特性：

1、字符串是一种常量

正如数字一样，字符串也是一种常量，它的值就是它自己，所以，它同样是一种字面常量。就是说，你看到它是什么，它就是什么，不能（原地）修改。

例如：

>>>‘abc’

‘abc’

2、字符串是一种序列类型的常量

字符串之所以名字上有个“串”字，我们可以通俗的理解为它一般不只包含一个字符，大多数时候，可能会是由多个、或者很多个字符构成的。但是，这些“多个字符”一旦“串”在了一起，它就构成了一个独立的字符串常量。在计算机的内存中，它表现为一小块存储空间，并且它存储的信息不能被原地修改。

也正因为不能被修改，它就拥有了固定的字符顺序，所以，它也成为了一种序列类型的数据。与其他序列类型的数据一样，它拥有这个序列的顺序（索引index）、索引值（指定位置的字符index[n]）、和序列的长度（len）。

例如：

>>> ‘abc’[0]

‘a’

>>> len(‘abc’)

3

3、字符串可以作为一个拥有值的常量赋值给一个变量

既然字符串是一个常量，它就可以赋值给一个变量，让一个变量拥有它的值。当某个字符串被赋值给某个变量时，在计算机的内存中，实际上是为这个变量添加了一个引用，这个引用指向了内存空间中那个字符串的存储区域。

例如：

>>> x = ‘abc’

>>> x

‘abc’

好了，

在回顾了这些有关字符串的常识以后，

今天我们要重点介绍一下字符串的操作。

Python为我们提供了大量的内置函数（方法），

方便我们在需要对字符串进行必要处理的时候，

能够轻松地一招搞定。

这也是我们在Python编程实际应用中，

会大量遇到和应该熟悉和掌握的基本知识和技能。

1、字符串的大小操作

（1）大小写转换

str.lower()# 返回str字符串的小写格式。

str.upper()# 返回str字符串的大写格式。

PS：请注意，这个新生成的字符串，不是对原有的内存地址添加引用，而是，重新生成了一个内存片段。

例如：

>>> 'aBcDeF'.lower()

'abcdef'

>>> 'aBcDeF'.upper()

'ABCDEF'

（2）驼峰式转换

str.title()# 返回字符串中所有单词首字母大写其他字母小写的新字符串

str.capitalize()# 返回首字母大写、其他字母全部小写的新字符串

例如：

>>> print('ab XY'.title())

Ab Xy

>>> print('abc DE'.capitalize())

Abc de

（3）大小写反转

str.swapcase()#所有字符串做大小写转换(大写-->小写，小写-->大写)

例如：

>>> print('abc XYZ'.swapcase())

ABC xyz

2、字符串的判断操作

（1）判断字符串是否是数字、字母、字母或数字

str.isnumeric() #判断字符串是否为数字（不含小数点）

str.isalpha() #判断字符串是否字母

str.isalnum() #判断字符串是否字母和数字混合（不含其它字符）

例如：

>>> print('34'.isnumeric())

True

>>> print('abc'.isalpha())

True

>>> print('a34'.isalnum())

True

（2）判断字符串或首字母是否大小写

str.islower() #字符串是否大写？

str.isupper() #字符串是否小写？

str.istitle() #字符串每个单词是否首字母大写，且其他字符小写？

PS:要求字符串str中至少要包含一个字符串字符（比如不能纯数字），否则返回False。

例如：

>>> print('a34'.islower())

True

>>> print('AB'.isupper())

True

>>> print('Aa'.isupper())

False

>>> print('Aa Bc'.istitle())

True

>>> print('Aa_Bc'.istitle())

True

>>> print('Aa bc'.istitle())

False

>>> print('Aa_bc'.istitle())

False

>>> print('Aa BC'.istitle())

False

（3）判断字符串是否为空、是否可打印、是否符合标识符定义规则

str.isspace()#字符串是否为空白（空格、制表符、换行符等）

str.isprintable()#字符串是否可打印

str.isidentifier()#字符串是否满足标识符定义规则

例如：

（1）判断是否为空白。没有任何字符是不算是空白。

>>> print(' '.isspace())

True

>>> print(' \t'.isspace())

True

>>> print('\n'.isspace())

True

>>> print(''.isspace())

False

>>> print('abc'.isspace())

False

（2）判断是否是可打印字符。

>>> print('\n'.isprintable())

False

>>> print('\t'.isprintable())

False

>>> print('acd'.isprintable())

True

>>> print(' '.isprintable())

True

>>> print(''.isprintable())

True

（3）判断是否满足标识符定义规则：只能是字母或下划线开头、不能包含除数字、字母和下划线以外的任意字符。

>>> print('abc'.isidentifier())

True

>>> print('2abc'.isidentifier())

False

>>> print('abc2'.isidentifier())

True

>>> print('_abc2'.isidentifier())

True

>>> print('_abc_2'.isidentifier())

True

>>> print('_Abc_2'.isidentifier())

True

>>> print('Abc_2'.isidentifier())

True

3、填充操作

（1）字符串居中（往两边）填充

str.center(width[, fillchar])

字符串居中，左右两边使用fillchar进行填充，使得整个字符串的长度达到width指定的大小。

fillchar默认为空格。

如果width小于字符串的长度，则无法填充直接返回字符串本身，也不会创建新字符串对象

例如：使用下划线填充并居中字符串

>>> print('abc'.center(5,'_'))

_ab_

>>> print('abc'.center(6,'_'))

__abc_

（2）字符串偏左/右，往另一边填充

str.ljust(width[, fchar])

#使用fchar填充在字符串的右边，使得整体长度为width。

str.rjust(width[, fchar])

#使用fchar填充在字符串的左边，使得整体长度为width。

PS：如果不指定fchar，则默认使用空格填充。如果width小于或等于字符串的长度，则无法填充，直接返回原字符串，且不会创建新的字符串对象。

例如：

>>> print('xyz'.ljust(5,'_'))

xyz__

>>> print('xyz'.rjust(5,'_'))

__xyz

（3）填充零

str.zfill(width)

• 用0填充在字符串的左边使其长度为width。
• 如果S前右正负号+/-，则0填充在这两个符号的后面，且符号也算入长度。
• 如果width小于或等于S的长度，则无法填充，直接返回原字符串，且不会创建新字符串对象。

例如：

>>> print('abc'.zfill(5))

00abc

>>> print('-abc'.zfill(5))

-0abc

>>> print('+abc'.zfill(5))

+0abc

>>> print('42'.zfill(5))

00042

4、字符串的子串搜索

（1）返回字符串中子串出现的次数

str.count(sub[, start[, end]])

PS：可以通过索引编号，指定从哪里开始计算(start)以及计算到哪里结束(end)，默认索引从0开始计算，不包括end边界。

例如：

>>> print('aaxyzaabbcaa'.count('aa'))

3

（2）判断字符串以什么字符开头或结尾

str.startswith(fix[, start[, end]])

# 判断字符串是否以fix开头

str.endswith(fix[, start[, end]])

# 判断字符串是否以fix结尾

• 返回布尔值：True和False。
• fix可以是一个元组(tuple)。
• 可以指定起始start和结尾end的搜索边界。

例如：fix是普通的字符串时

>>> print('abcxyz'.startswith('abc'))

True

# False，因为限定了搜索范围为从索引4开始

>>> print('abcxyz'.endswith('xyz',4))

False

# False，因为搜索范围为'abcxy'

>>> print('abcxyz'.endswith('xyz',0,5))

False

fix是元组(tuple)时，只要tuple中任意一个元素满足endswith的条件，就返回True。

# tuple中的'xyz'满足条件

>>> print('abcxyz'.endswith(('ab','xyz')))

True

# tuple中'ab'和'xy'都不满足条件

>>> print('abcxyz'.endswith(('ab','xy')))

False

（3）搜索字符串中是否包含某子串

str.find(sub[, start[, end]])

str.rfind(sub[, start[, end]])

str.index(sub[, start[, end]])

str.rindex(sub[, start[, end]])

find()搜索字符串中是否包含子串sub，如果包含，则返回sub的索引位置，否则返回"-1"。可以指定起始start和结束end的搜索位置。

rfind()则是返回搜索到的最右边子串的位置，如果只搜索到一个或没有搜索到子串，则和find()是等价的。

index()和find()一样，唯一不同点在于当找不到子串时，抛出ValueError错误。

例如：

>>> 'abcxyzXY'.find('xy')

3

>>> 'abcxyzXY'.find('xy',4)

-1

>>> 'xyzabcabc'.rfind('bc')

7

可以使用in操作符来判断字符串是否包含子串sub，它返回的不是索引位置，而是布尔值。

>>> 'xy' in 'abxycd'

True

>>> 'xyz' in 'abxycd'

False

5、替换操作

（1）将字符串中的子串old替换为new字符串

str.replace(old, new[, count])

PS：如果给定count，则表示只替换前count个old子串。如果str中搜索不到子串old，则无法替换，直接返回原字符串，且不创建新字符串对象。

>>> 'abcxyzoxy'.replace('xy','XY')

‘abcXYzoXY’

>>> 'abcxyzoxy'.replace('xy','XY',1)

‘abcXYzoxy’

>>> 'abcxyzoxy'.replace('mn','XY',1)

‘abcxyzoxy’

（2）字符串映射转换（可以理解为一种简单的加密方法）

str.translate(table)

static str.maketrans(x[, y[, z]])

str.maketrans()生成一个字符一 一映射的table，然后使用translate(table)对字符串中的每个字符进行映射。

例如，现在想要对"I love you"做一个简单的加密，将里面部分字符都替换为数字，这样别人就不知道转换后的这句话是什么意思。

第一步：创建映射表

# maketrans()生成映射表

>>> in_str='abcxyzlij'

>>> out_str='123456789'

>>> map_table=str.maketrans(in_str,out_str)

第二步：使用映射表实现映射（加密）

# 使用translate()进行映射

>>> mylove = 'I love you'

>>> result = mylove.translate(map_table)

>>> print(result)

I 7ove 5ou

PS：maketrans(x[, y[, z]])中的x和y都是字符串，且长度必须相等。如果maketrans(x[, y[, z]])给定了第三个参数z，则这这个参数字符串中的每个字符都会被映射为None。

例如:

>>> in_str='abcxyz'

>>> out_str='123456'

>>> map_table=str.maketrans(in_str,out_str,'ar')

>>> mylove='How are you'

>>> result=mylove.translate(map_table)

>>> print(result)

How e 5ou

6、字符串分割操作

（1）分割为三元组

str.partition(sep)

str.rpartition(sep)

搜索字符串中的子串sep，并从sep处对字符串进行分割，最后返回一个包含3元素的元组：sep左边的部分是元组的第一个元素，sep自身是元组的二个元素，sep右边是元组的第三个元素。

partition(sep)从左边第一个sep进行分割，rpartition(sep)从右边第一个sep进行分割。

如果搜索不到sep，则返回的3元素元组中，有两个元素为空。partition()是后两个元素为空，rpartition()是前两个元素为空。

例如：

>>> print('abcxyzxyzopq'.partition('xy'))

('abc', 'xy', 'zxyzopq')

>>> print('abcxyzxyzopq'.rpartition('xy'))

('abcxyz', 'xy', 'zopq')

（2）分割字符串，并生成一个列表

str.split(sep=None, maxsplit=-1)

str.rsplit(sep=None, maxsplit=-1)

str.splitlines([keepends=True])

split()根据sep对字符串进行分割，maxsplit用于指定分割次数，如果不指定maxsplit或者给定值为"-1"，则会从左向右搜索并且每遇到sep一次就分割直到搜索完字符串。

如果不指定sep或者指定为None，则改变分割算法：以空格为分隔符，且将连续的空白压缩为一个空格。

rsplit()和split()是一样的，只不过是从右边向左边搜索。

splitlines()专门用来分割换行符。虽然它有点像split('\n')或split('\r\n')，但它们是有区别的。

>>> '1,2,3'.split(',')

['1', '2', '3']

>>> '1,2,3'.split(',',1)

['1', '2,3'] # 只分割了一次

>>> '1,2,,3'.split(',')

['1', '2', '', '3'] # 不会压缩连续的分隔符

>>> '<hello><><world>'.split('<')

['', 'hello>', '>', 'world>']

>>> '<hello><><world>'.split('<>')

['<hello>', '<world>']

>>> '1 2 3'.split()# 不指定sep时

['1', '2', '3']

>>> '1 2 3'.split(maxsplit=1)

['1', '2 3']

>>> ' 1 2 3 '.split()

['1', '2', '3']

>>> ' 1 2 3 \n'.split()

['1', '2', '3']

# 显式指定sep为空格、制表符、换行符时

>>> ' 1 2 3 \n'.split(' ')

['', '1', '', '2', '', '3', '', '\n']

>>> ' 1 2 3 \n'.split('\t')

[' 1 2 3 \n']

>>> ' 1 2\n3 \n'.split('\n')

[' 1 2', '3 ', ''] # 注意列表的最后一项''

>>> ''.split('\n')

['']

>>> 'ab c\n\nde fg\rkl\r\n'.splitlines()

['ab c', '', 'de fg', 'kl']

>>> 'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True)

['ab c\n', '\n', 'de fg\r', 'kl\r\n']

将split()和splitlines()相比较一下：

#### split()

>>> ''.split('\n')

[''] # 因为没换行符可分割

>>> 'One line\n'.split('\n')

['One line', '']

#### splitlines()

>>> "".splitlines()

[] # 因为没有换行符可分割

>>> 'Two lines\n'.splitlines()

['Two lines']

7、join操作

str.join(iterable)

将可迭代对象(iterable)中的字符串使用str字符串连接起来。

注意，iterable中必须全部是字符串类型，否则报错。

如果你还是python的初学者，还不知道iterable是什么，却想来看看join的具体语法，那么你可以暂时将它理解为：字符串string、列表list、元组tuple、字典dict、集合set。

例如：

字符串

>>> X1='python'

>>> '_'.join(X1)

'p_y_t_h_o_n'

元组

>>> X2=('1','2','3')

>>> '_'.join(X2)

'1_2_3'

集合。注意，集合无序。

>>> X3={'p','y','t','h','o','n'}

>>> '_'.join(X3)

'n_o_p_h_y_t'

列表

>>> X4=['py','th','o','n']

>>> '_'.join(X4)

'py_th_o_n'

字典

>>> X5={'name':"malongshuai",'gender':'male','from':'China','age':18}

>>> '_'.join(X5)

'name_gender_from_age'

iterable参与迭代的部分必须是字符串类型，不能包含数字或其他类型。

8、修剪操作

移除左右两边、左边、右边的字符char。如果不指定chars或者指定为None，则默认移除空白(空格、制表符、换行符)。

str.strip([chars])

str.lstrip([chars])

str.rstrip([chars])

唯一需要注意的是，chars可以是多个字符序列。在移除时，只要是这个序列中的字符，都会被移除。

例如：移除单个字符或空白。

>>> ' abcde '.strip()

'abcde'

>>> print('www.example.com'.lstrip('cmowz.'))

example.com