Python学习笔记（3-1）：内置数据结构之字符串

文章导读

 - 课程难度：★★☆☆☆
 - 预计学习时间：1小时
 - 简介：本节主要讲解了Python内置数据结构中字符串数据的相关基础知识及常用的函数，包括：（1）字符串的定义及一些基础的知识点，如数字转成字符串格式、字符串的拼接、复制、比较及ASCII码的访问等；
（2）如何访问字符串中的某个元素或片段（切片操作）；（3）字符串格式化输出的三种方式；（4）字符串常用的一些函数；
 - 重点涉及的函数和内容：（1）切片操作；（2）利用%格式化输出字符串；（3）str.format()、split()、strip(）、join()、index()、find()、count()、replace()、startswith()、endswith()、
lower()、upper()、capitalize()、title()、swapcase()等函数

一、字符串的定义及基础知识

1、定义

字符串就根本而言，是一连串的字符。例如，字符串’alpha’实际上是五个字符’a’、‘l’、‘p’、‘h’、'a’拼成的数组。字符串中可以包含汉字、英文字母、数字和标点等任意字符。Python中的字符串必须用引号括起来，以此作为定界符，可以使用单引号、双引号、三单引号或三双引号，其中三引号允许一个字符串跨多行，并且不同的定界符之间可以互相嵌套。

2、基础知识

（1）数据类型：str

字符串用单引号' '或者双引号" "进行定义，数据类型为str，这个名称是一个保留字。

print('string A')
print("string B")
print(type('STRING'))

输出结果如下：

string A
string B
str

（2）原生字符串

可以使用 \t,\n,\\这种转义字符，表示制表位、换行、单独输出单引号和双引号（还有很多其他的）；可以使用字母r修饰字符串，表示原生字符串（raw string），这可以将字符串变成纯文本。

print('str\ting A')
print(r'str\ting A')

输出结果如下：

str	ing A
str\ting A

（3）数字转换成字符串：str()

利用str()函数，可以将数字变成字符串形式：

print(str(1.2)) 	# 转换数字
print(str([1,2,3])) 	# 转换列表

输出结果如下：

1.2
[1, 2, 3]

（4）字符串的拼接：+

利用加号+ 进行字符串的拼接，（注：加号+可用于连接字符串与字符串、列表与列表、元组与元组）

str1 = 'alpha_'
str2 = 'beta_'
print(str1 + str2)

输出结果如下：

'alpha_beta_'

（5）字符串的复制：*

利用符号* 对字符串进行复制（只能乘整数），数字在后面在前面均可。

str1 = 'alpha_'
str2 = 'beta_'
print(str1 * 10)
print(5 * str2)

输出结果如下：

alpha_alpha_alpha_alpha_alpha_alpha_alpha_alpha_alpha_alpha_
beta_beta_beta_beta_beta_

（6）字符ASCII码的访问

ord()函数可以返回字符的ASCII码，chr()函数能返回数字（标准ACSII是0~127）所代表的字符：

print(ord('a'))		
print(ord('A'))
print(chr(98)) 	

输出结果如下：

97
65
b

（7）字符串的比较

字符串比较实际上就是一个一个char值的比较，规则是先比较两字符串第一个ASCII码，如果相同，再比较第二个ASCII码，逐步比较下去，直到返回第一个不相同的结果为止。如果比较到最后一个可比较的值仍然一样，但两个字符串长度不等，认为较长的大：

print('123' < '234') 		# 在第一个值时1的ACSII码小于2的

print('aazsee' > 'aazcss') 	# 比较到第四个值，s的ACSII码大于c的

print('aazsee' < 'aazseexx') 	# 比较到最后一个可比较的值仍然一样，
						# 但两个字符串长度不等，认为较长的大。

print('aazsee' == 'aazsee') 	# 如果两字符串等长，且每一个字符都相等，
						# 则认为两字符串相等
						

输出结果如下：

True
True
True
True

（8）字符串是不可变数据类型

字符串对象在定义后，不支持对字符串内的某个特定元素重新赋值：

string[0] = 3  # 会报错

二、 字符串的访问与切片

1、访问字符串中某个元素

刚刚提到，字符串实际上是一个字符的序列，我们可以像访问列表一样访问字符串。也即，字符串的下标也从0开始取，第n个元素的下标是n-1。因此对字符串’alpha’，其’a’,‘l’,‘p’,‘h’,'a’的下标值分别是 [0, 1, 2, 3, 4]。我们定义一个便于观察结果的字符串：

string='1234567890'

访问一个值，下标允许是负数，看作是反向去取。-1是最后一个值，-2是倒数第二个值，以此类推。字符串合法的下标值是 [ -len(string), len(string) ) ,这是一个左闭右开的区间，len(string)为字符串的长度。当它是负值时，可以看做系统自动加了一个len(string)。

print(string[0])
print(string[-2])

输出结果如下：

1
9

2、访问字符串中的一个片段：切片

使用冒号进行切片，语法格式为：string[start : end : step]，start为切片开始的位置（默认为0）,end为切片截止（但不包含）位置（默认为列表长度），step为切片的步数（默认为1），省略步长时可省略第二个冒号。step为负整数时，表示反向切片(从右往左访问)
（1）步长step为默认值1时（连续切片）

string = '1234567890'	
print(string[2:8]) 		# 给出开头和结尾
print(string[2:100])	# 尾部超界，返回最小值
print(string[:7])		# 只给出结尾
print(string[4:])		# 只给出开头
print(string[:])		# 访问整个字符串
print(string[-3:])	    # 以负值给出字符串的开头
print(string[::-1])     # 反向访问整个字符串

输出结果如下：

345678
34567890
1234567
567890
1234567890
890
09876543210987654321

（2）步长step不为1时（跳跃式切片 ）

string = '12345678901234567890'
print(string[::2])
print(string[::3]) 
print(string[4::2])
print(string[4::3])
print(string[::-2]) #反向跳跃式访问

输出结果如下：

12345678901234567890
1357813579
1470369
57913579
581470
0864208642

反向切片对于列表以及其他数据格式都有用，是一个有意思的小技巧，我们以一个简单的列表来举例：

a = ['alpha', 'beta', 'gamma', 'sigma']
print(a[::-1])

输出结果如下：

['sigma', 'gamma', 'beta', 'alpha']

最后，这里有一件事情需要强调，就是字符串可以基于下标访问一个指定元素，可以基于切片访问一个片段，但是不能基于下标或是切片对字符串内的一个元素或一个片段进行部分修改。例如这段代码会产生如下报错信息：

string = '1234567890'
string[2:4] = '***' 	# 报错1，字符串不能不能修改

报错1【TypeError: 'str' object does not support item assignment】

字符串为不可变类型，除非对字符串全部重新定义，否则不可直接修改其中的元素或片段，这一点对后续所讲的元组也适用，需要牢记。

三、 字符串的格式化输出

我们平时常将一些元素指定格式做成字符串，写入文件或是在控制台上输出出来，这就是字符串格式化（formatting）所做的事情。格式化的字符串和一般字符串一样，可用于赋值給变量。

1、直接应用字符串的拼接功能

此前讲过字符串的拼接用加号 + 即可，因此，我们把要做的元素直接转换成字符串，然后和想要的格式化的字符串拼接起来，打在一起输出即可（数字和字符串是不能相加的）：

a = 1.4
b = 2.2
print('alpha = ' + str(a) +', beta = ' + str(b) + ', alpha * beta = ' + str(a * b) )

输出结果如下：

alpha = 1.4, beta = 2.2, alpha * beta = 3.08

2、利用%格式化字符串

通过 format % values 的形式传值，其中format是包含%规则的字符串，values是要传入的值，传值可通过位置、字典等形式实现。

a = 1
b = 2
c = a + b
print('a + b = %d'%c)

这里，字符串内部的%指的是在%的位置插入值，%的后面的字母指示输出值的类型，主要应用的有d、f和s，分别代表输出整数、浮点数和字符串。常用的%格式如下表。在字符串的最后，立即接即将被格式化输出的值，也用%标识。

符号	功能
%s	格式化为字符串
%d	格式化为整数
%f	格式化为浮点数
%e	格式化为科学计数法来表示浮点数
%%	格式化为百分比

我们以如下代码输出intnum的部分为例，在字符串内，%d中的%指的是“格式化输出一个对象”，d表示的是“这个对象是一个整数”。而字符串之后的%intnum指示这里“要在字符串内插入的元素是intnum”。如下各举一例格式化输出整数、浮点数和字符串：

intnum = 3
floatnum = 4.5
string = 'alpha'
print('INTNUM: %d'%intnum)
print('FLOATNUM: %f'%floatnum)
print('STRING: %s'%string)

输出结果如下：

INTNUM: 3
FLOATNUM: 4.500000
STRING: alpha

（1）输出指定宽度的字符串

在刚刚输出单一元素的基础上，我们可以指定输出的宽度(占位符，最少占多少位而不是固定占多少位，如果位数多按多的来），也可以用0当数字的占位符。对于浮点数，我们还可以指定保留小数点位数。
具体例子及注释如下：

intnum = 35
floatnum = 24.3442
string = 'alpha'
print('1: INTNUM: %d'%intnum)				
print('2: INTNUM: %6d'%intnum)		# 输出整数，最少占6位
print('3: INTNUM: %06d'%intnum)		# 输出整数，最少占6位，空位用0补齐
print('4: FLOATNUM: %f'%floatnum)			
print('5: FLOATNUM: %20f'%floatnum)		# 输出浮点数，最少占20位
print('6: FLOATNUM: %8.2f'%floatnum)	# 输出浮点数，最少占8位，小数点后两位
print('7: FLOATNUM: %08.2f'%floatnum)	# 在6之上，空位用0补齐
print('8: FLOATNUM: %08.2e'%floatnum)	# 在6之上，输出以科学计数法表示
print('9: STRING: %8s'%string)			#输出字符串，最少占8位
print('10: STRING: %08s'%string)		# 输出字符串，最少占8位，此时0无效
print('11: \tSTRING: %08s'%string) 		# 带转义字符的字符串
print(r'12: \tSTRING: %08s'%string)   	# 用r将转义字符转成纯文本的字符串

输出结果如下：

1: INTNUM: 35
2: INTNUM:     35
3: INTNUM: 000035
4: FLOATNUM: 24.344200
5: FLOATNUM:            24.344200
6: FLOATNUM:    24.34
7: FLOATNUM: 00024.34
8: FLOATNUM: 2.43e+01
9: STRING:    alpha
10: STRING:    alpha
11: 	STRING:    alpha
12: \tSTRING:    alpha

（2）一次输出多值

上面格式化部分都是以一定的格式规则在特定位置上输出一个值，最后，我们如果希望一次输出多个值，可以在字符串中插入多个百分号，而在字符串结束后的百分号后面，将所有输出的结果按照插入字符串的顺序用括号括起来，例如如下的代码所示：

print('my name is %s,age %d,height %.2f,money %5.2e,satisfied %.2f%%' % ('Lucy',33,183.5,10000000000.0,90.365))

输出结果如下：

my name is Lucy,age 33,height 183.50,money 1.00e+10,satisfied 90.36%

3、str.format()格式化字符串

该方法通过str.format(values)形式格式化，其中str是带有{}规则的字符串，values是要传入的值。它可通过多种形式获取字符串对应的数值。

（1）通过位置索引获取结果

位置索引也就是通过{}中不同位置的索引获取对应的值，例如{0}代表values序列值的第一个元素。示例如下：

print('my name is {0},age {1},height {2:.2f},money {3:5.2e},satisfied {4:.2%}'.format('lucy',33,183.5,10000000.0,0.90365))

（2）通过默认位置索引获取结果

如果后续的有序列表已经按照{}出现的顺序排列好，则可以省略其中的索引值

print('my name is {},age {},height {:.2f},money {:5.2e},satisfied {:.2%}'.format('lucy',33,183.5,10000000.0,0.90365))

（3）通过关键字获取结果

{}支持通过关键字参数的形式获取结果，具体地，{key}可以获取参数key对应的value值。示例如下：

print('my name is {name},age {age},height {height:.2f},money {money:5.2e},satisfied {percent:.2%}'.format(name='lucy',age=33,height=183.5,money=10000000.0,percent=0.90365))

以上三种方式代码的结果都相同，输出结果如下：

my name is lucy,age 33,height 183.50,money 1.00e+07,satisfied 90.36%

四、字符串的常用函数

python里面的字符串函数，是字符串对象的成员函数。简单的说，我们拿到一个字符串string，调用这个字符串对象的成员函数，使用的语法是string.function()，这个.function()就是函数的名称。

1、len()函数

这个函数能够返回字符串的长度

STRING = ' alpha , beta , gamma , sigma '
LEN = len(STRING)
print(LEN)

输出结果如下：

30

2、split()函数

这个函数能将字符串拆分，传入的参数是分隔符，分隔符的默认值是空格

STRING = ' alpha , beta , gamma , sigma '
SPLIT = STRING.split(',')
print(SPLIT)

输出结果如下：

[' alpha ', ' beta ', ' gamma ', ' sigma ']

3、strip()函数

strip()函数能够删除字符串两侧的空白字符或指定字符。strip()、lstrip()、rstrip()方法分别用于删除字符串两侧、左侧和右侧的空白值或指定的字符

STRING = ' alpha , beta , gamma , sigma '
SPLIT = STRING.split(',')
for i in range(len(SPLIT)):
    SPLIT[i] = SPLIT[i].strip() #删除空白值
print(SPLIT)

输出结果如下：

['alpha', 'beta', 'gamma', 'sigma']

text = '       ===========test===========########'
print(text.strip('=# ')) #删除两侧的=、#和空格

输出结果如下：

test

4、join()函数

join()函数能将一个字符串列表用某个字符串连接起来，调用的是连接字符串的函数对象，及concatstr.join()

STRING = ' alpha , beta , gamma , sigma '
SPLIT = STRING.split(',')
JOIN = '-%-'.join(SPLIT) #使用 -%- 作为连接符
print(JOIN)

输出结果如下：

alpha -%- beta -%- gamma -%- sigma

5、index()、find()函数以及in关键字

index()、find()函数能够寻找一个子字符串的位置，并返回下标。in关键字能判断一个子字符串是否在本字符串中：

STRING = ' alpha , beta , gamma , sigma '
SPLIT = STRING.split(',')
for i in range(len(SPLIT)):
     SPLIT[i] = SPLIT[i].strip()
JOIN = '-%-'.join(SPLIT)

print(JOIN.find('-%-'))		# 利用find函数寻找一个子字符串的位置，返回下标
print(JOIN.index('-%-'))	# 利用index函数寻找一个子字符串的位置，返回下标
print('-%-' in JOIN)		# 利用in判断一个子字符串是否在原字符串中

输出结果如下：

5
5
True

如果一个子字符串会包含在原字符串中，find()和index()函数会返回找到第一个子字符串的所在下标，而in关键字的语句会返回True。如果不包含，find()函数会返回-1，index()函数会报错，而in关键字最后会返回False

print(JOIN.find('-@-'))		# 返回-1
print(JOIN.index('-@-'))		# 会报错
print('-@-' in JOIN)			# 返回False

6、count()函数

count()函数能返回一个子字符串在字符串中出现的次数：

STRING = ' alpha , beta , gamma , sigma '
SPLIT = STRING.split(',')
for i in range(len(SPLIT)):
     SPLIT[i] = SPLIT[i].strip()
JOIN = '-%-'.join(SPLIT)
print(JOIN.count('-%-'))

输出结果如下：

3

7、replace()函数

replace()函数能将一个子字符串替换为另一个。利用replace()函数，可以将替换功能中替换的对象改成空字符串，来删除某个固定片段。replace()函数并不会改变原来的对象。

STRING = ' alpha , beta , gamma , sigma '
SPLIT = STRING.split(',')
for i in range(len(SPLIT)):
     SPLIT[i] = SPLIT[i].strip()
JOIN = '-%-'.join(SPLIT)

JOIN.replace('-%-', '-@-')			# 单纯调用replace函数，不会改变原来的JOIN
print(JOIN)
JOIN = JOIN.replace('-%-', '-@-')	# 将JOIN中的'-%-'替换为'-@-'
print(JOIN)
JOIN = JOIN.replace('-@-', '') 		# 将JOIN中的'-@-'替换为空字符串，即删去该片段
print(JOIN)

输出结果如下：

alpha-%-beta-%-gamma-%-sigma
alpha-@-beta-@-gamma-@-sigma
alphabetagammasigma

8、startswith()、endswith()函数

这两个函数能测试字符串是否以指定的一个或多个字符（放在元组中）开始和结束：

text ='Simple is better than complex.'
print(text.startswith('Simple'))
print(text.startswith('simple'))
print(text.endswith(('.','!','?')))

输出结果如下：

True
False
True

9、lower()、upper()、capitalize()、title()、swapcase()等函数

这些函数用于改写字符串中字母的大小写：

text = 'Explicit is better than impicit.'
print(text.lower())      #把字符串中所有的英文字母都转换为小写字母
print(text.upper())      #把字符串中的所有字母都转换为大写字母
print(text.capitalize()) #把每个句子的首字母转换为大写字母
print(text.title())      #字符串中每个单词的首字母转换为大写字母
print(text.swapcase())   #把小写字母转换为大写字母，把大写字母转换为小写字母

输出结果如下：

explicit is better than impicit.
EXPLICIT IS BETTER THAN IMPICIT.
Explicit is better than impicit.
Explicit Is Better Than Impicit.
eXPLICIT IS BETTER THAN IMPICIT.

注：以上输出结果中的“is”是保留字的形式。

字符串处理还有许多的函数，但上述讲到的函数基本足以满足面向数据分析的各种需要，因此便不再补充。此外，因为正则表达式较为复杂，且面向数据分析应用场景较少，因此也在此略过。
在下两章介绍numpy和pandas的时候，还会再对相关字符串处理进行一次介绍，现在是对单独的一个字符串进行的处理，在未来将描述对一整个字符串数组或序列进行的处理。

---

对于缺乏Python基础的同仁，可以通过免费专栏🔥《Python学习笔记（基础）》从零开始学习Python

结语

请始终相信“Done is better than perfect” ，不要过分追求完美，即刻行动就是最好的开始， 一个模块一个模块地积累和练习，必将有所收获。
还有其他的问题欢迎在评论区留言📝！

---

[版权申明] 非商业目的注明出处可自由转载，转载请标明出处！！！
博客：butterfly_701c