夯实Python基础（2）

爱高渡，
学编程，
号外有话说

Python是目前编程领域最受欢迎的语言。从本期开始，经高渡网站授权，我们将抢先在高渡号外连载《夯实Python基础》的微课精简版。

本课程是《Python入门》课程的加强版，建议有Python入门课程基础的同学，用于巩固学习成果，拓宽和加深知识含量，同时，也对接下来的应用开发（如Web开发等）的学习会有良好的帮助。

更多课程请访问高渡网站
https://www.igaodu.cn

今日热门关键词
Python入门、Web开发、数据挖掘
数据分析、机器学习、人工智能

遇上好资源，赶紧：加关注 点收藏

夯实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'] # 不会压缩连续的分隔符
>>> ''.split('', '>', 'world>']
>>> ''.split('')
['', '']
>>> '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

更多课程请访问高渡网站
网址：https://www.igaodu.cn
相关课程资源还有：
《Python轻松入门》视频课程（18节）
《Python入门》同步微课（18节）
《Python Web开发》视频课程（26节）
《Java基础教程》视频课程（25节）

课程资源，建议PC端观看

喜欢就点在看

遇上好资源，转发给好友

专注提供优质的编程学习资源

爱高渡，学编程，手把手教你

长按二维码关注公众号