python学习03： 基本数据类型之字符串类型_python 字符串 类型

一.序列类型

序列类型用来表示有序的元素集合

• 字符串(str) 字符串是用单引号/双引号/三引号包裹起来的字符的序列，用于表示文本信息
• 列表 (list) 列表是有序可变的元素集合，其元素可以是任意数据类型
• 元祖 (tuple) : 元组是有序不可变的元素的集合，其元素可以是任意数据类型，可以说元组就是不可变列表。

二.字符串

2.1 字符串的定义

定义：字符串是使用单引号/双引号/三引号包裹起来的字符的序列，用于表示文本信息。

a = 'a'
b = "bc"
c = """hello,world"""
d = '''hello,d'''
e = """
    hello,
    world!
    """
print('a的类型为：', type(a))    # a的类型为： <class 'str'>
print('b的类型为：', type(b))    # b的类型为： <class 'str'>
print('c的类型为：', type(c))    # c的类型为： <class 'str'>
print('d的类型为：', type(d))    # d的类型为： <class 'str'>
print('e的类型为：', type(e))    # e的类型为： <class 'str'>
1
2
3
4
5
6
7
8
9
10
11
12
13

python中字符串用str表示

注意：
①：使用单引号和双引号定义的字符串在本质上没有任何区别
②：字符串里面的字符是有顺序的
③：以下图片，记住可以这样去写就可以了，基本上用不到。

既然单引号和双引号定义的字符串没有区别，那为什么要同时存在呢？
当我们想把单引号或双引号当作字符输出的时候，
我们外面包裹的引号就要使用相反的引号(即外双内单，外单内双)不然就会报错。

举例：

print('我是'小明'')  #  SyntaxError  语法错误
print("我是'小明'")  #  我是'小明'
print('我是"小明"')  #  我是"小明"
1
2
3

注意：
单引号或双引号只能定义单行的字符串

print('床前明月光,'
       '疑是地上霜')
# 床前明月光，疑是地上霜   输出结果依然是单行
1
2
3

那么如果我们想输入多行字符串应该怎么做呢？
三引号可以定义多行的字符串

print('''床前明月光，
... 疑是地上霜''')
床前明月光，
...疑是地上霜
1
2
3
4

一般情况下，使用三双引号做多行注释，函数和类用三双引号进行注释(注释本身就是字符串)
如果要定义多行字符串做变量去使用的时候，一般情况下使用三单引号，因为要更快速一点不用按Shift，当然，使用三双引号也是可以的。

-定义空字符串-

e =''  #  两个引号合在一起代表空字符串，打印出来什么都没有。
1

总结：
①：单引号或双引号创建的字符串在本质上没有什么区别，区分的的作用就是用来把单引号或双引号当作字符输出。
②：单引号或双引号只能定义单行字符串，三引号可以定义多行字符串。
③：三双引号一般用来做多行注释，表示函数，类定义时的说明，三单引号可以定义多行字符串做变量。
④：可以定义空字符串。

2.2 字符串的索引

任何序列类型中的元素都有索引来表示它在序列中的位置
字符串是字符的序列表示，单个字符在字符串中的位置使用索引来表示，也叫做下标

---

索引使用整数表示

• 从左往右是正向索引，从0开始
• 从右往左是反向索引，从-1开始
• 索引的位置是始终固定的，序号都是不变的

为什么索引从0开始呢，引入偏移量的概念：是因为索引是所在位置距离序列头部的偏移个数。

---

索引的作用：可以通过索引获取字符串中的单个字符
语法： s[index] 代表从字符串s中，获取索引为index的字符

s =('hello, world!)
print(s[0])    #  h  获取字符串s中下标为0的字符
print(s[5])    #  ，  获取字符串s中下标为5的字符 
print(s[-1])   #  !  获取字符串s中下标为-1的字符
1
2
3
4

2.3字符串的切片

索引是取字符串中的单个元素
获取序列中的子序列叫切片
字符串的切片就是获取字符串的子串
序列切片的语法 s[ start : end : step ]

• start 表示起始索引
• end 表示结束索引
• step 表示步长，默认等于1，可以不写

str[ m : n : t ] 表示从字符串索引为m到索引为n之间不包含索引n每隔t个字符进行切片

---

[ start : end ] 切片包头不包尾，左闭右开。

案例：

s =('hello,world!')  
1

要取到 ‘hello,word’应该怎么做呢？
按照我们正常数，很可能会误以为s[0:10] 可以取到 ‘hello, world’ 但是打印之后的结果却是hello,worl ，是因为我们忽略了：“切片包头不包尾”

为什么切片包头不包尾呢？我们要回顾前面学到的知识：索引是所在位置距离序列开头的偏移的个数
为了能更好的理解，我们画一个图

①：0点是序列开头，0点在’H’上面，所以字符’H’距离序列开头的偏移量为0，下标为0。
②：切开始索引的时候，直接从它的下标切可以把它切出，但切结束索引的时候，直接从它的下标切就会把它漏掉，因为它的下标在它的左边。上图，’d‘的下标为10，但很明显结束索引为10只能切到字符’L‘。要想切到’d‘要切到右边。即d的下标+1 s[0:11]
③：反向切片也是一样的道理只是方向反过来了，它是从右边开始切，所以反向切片的的下标在它的右边。

练习1：左闭右开

s1 ='0123456789'
print(s1[1:5])  # '1234'  包头不包尾
# [1:5]的意思是获取字符串s1从下标1到下标5但不取下标5的子串，获取子序列 '1234'.
print(s1[0:4])  # '0123'   也可以写成 s1[:4] 如果从头开始切,那么start可以省略
print(s1[5:])  # '56789'  如果切到结尾，那么end也可以省略
print(s1[:])  # 取全部
1
2
3
4
5
6

总结：
①：如果从头开始切，那么start可以省略
②：如果切到结尾，那么end也可以省略
③：[::] 表示取全部

练习2：正步长

s2 = '0123456789'
print(s2[::2])  # '02468'
print(s2[1::2])  #  '13579'
print(s2[1::3])  # '147'
print(s2[2::2])  #  '2468'
print(s2[:6:3])  #  '03'   #  注意6是结束索引，切到索引6，切出5，切不出6.
print(s2[:5:3])  #  '03'
print(s2[:4:3])  #  '03'   # 每一段三个 每段切第一个，第一段为'012' 切出0 第二段为'3' 切出3，有一个也要切。
1
2
3
4
5
6
7
8

练习3：负步长

s3 ='0123456789'
print(s3[::-2])   # 也可以写成[-1::-2]  '97531'  因为步长为负数,所以切片方向是从右往左，开始索引为9或-1
print(s3[:5:-2])  #   '97' 步长为负表示从右往左切，开始索引为-1，顾头不顾腚，取到索引为6，切片范围为9876，2表示每两个切一个，然后确定范围：是'97'

print(s3[1::-2]  # 1  切片范围为'10'，只能切出1

如果要从1切到8应该怎么切
print(s3[1:9]) # 12345678  因为1的索引为1，8的索引为 8 左闭右开，要取到8，应该切到9的索引位置
print(s3[1:9:2]) # 1357 首先[1:9]会界定范围，表示只会取1到8这部分，然后步长为2表示每隔两步切一个，每一小段里面只会取第一个，然后开始跳步长
print(s3[::3]) #  0369
print(s3[1:9:-1])  # 切出空字符串，因为根本就没有这个范围
#  step为负数，代表切片方向从右往左切，那么我们的开始索引为1结束索引为8，但是切片为负，是从右往左切，找不到这个范围，切出空。
print(s3[::-3]) #  9630 表示取全部，步长为-3,步长为负，切片方向从右往左。
print(s3[2:-1:-2]) #  切不出来，当步长为负数的时候，开始索引必须要在结束索引的右边，否则切出空。
print(s3[-1:2:-2])  # 9753

s4 ='hello,world!'
print(s4[-11::-2])  # e
print(s4[:5:-2])  # !lo
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

为了更好理解负步长，我们画个图。 content = ’Hello,world! print(content[1::-2] 会取到什么？ e

总结：
①：当step为负数的时候，代表切片方向从右往左切(开始索引在右边，结束索引在左边)
②：不论是正向索引还是反向索引，都是顾头不顾腚，千万不要把反向索引给忽略了。
③：当步长为负数的时候，开始索引一定要在结束索引的右边，否则切出空。
④：当看到花式切片的时候，要先根据步长确定切片方向，再根据start和end找出范围。

例：

易混淆：反向索引的时候也是顾头不顾腚，所以：
①：步长为负，切片方向从右往左
②：切片范围为下标为7开始到下标为3但不取下标3的范围。.

思考：如何获取一个字符串的逆串？
将’abc ’ - ‘cba’
分析:本质就是字符串的倒序，反向切片，步长为1

'abc'
x = 'abc'  
print(x[::-1])  #  'cba'  [::]表示取值范围为全部，step为负数，表示反向切片，步长为1
1
2
3

2.4 字符串的拼接

①python中使用+运算符可以把字符串首尾拼接在一起

s1 ='hello'
s2 =' '
s3 ='world!'
print(s1)  # hello
print(s2)  # 
print(s3)  # world!
print(s1+s2+s3)  # helo world!
1
2
3
4
5
6
7

按照＋的顺序 首尾相连
②字符串和整数进行乘法运算表示重复拼接这个字符串

如何把 100个*拼接在一起
s = '*'
print(s*100)  # 把s打印100次，得出结果为100个*，首尾相连。
1
2
3

2.5 字符串的常用方法

字符串是一个类，具体的字符串是它的一个个体。
内建函数dir dir()
接收任何数据作为参数，返回这个数据对象的所有的方法名的列表

print(dir(str)) 
print(dir('abc')  #  下面的方法是字符串通用的方法，即类属性，通过类和对象都可以访问。
# ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
1
2
3

方法其实就是函数，是定义在数据类型里面的

---

方法怎么用在哪看

• 通过内建函数help可以返回函数的帮助信息

s = 'hello'
s.capitalize()
print(s)  #  'Hello'
print(help(s.capitalize))  # 输出 capitalize的帮助文档 
1
2
3
4

几乎所有的字符串方法 都是返回一个新的字符串

s = 'hello'
new_s = s.capitalize()
print(new_s)      # Hello  把第一个字符变为大写，其他的变为小写
1
2
3

• 在: 官方文档.进行查询
• 
  

2.6 字符串和数值的相互转换

1和‘1’不同，1.2和’1.2’也不相同，但是它们却可以相互转化。

• 数值 - 字符串 str（）

①、整数-字符串（十进制的整数字符串）

int - str
age = 18
res = str(18)
print(res, type(res))  #  18 <class 'str'>


print(int('0b11',base=0))  # 3  二进制的整数字符串(拓展)

str - int
int_str = '18'
age2 = int(int_str)
print(age2,type(age))  # 18 <class 'int'>
注意：一定要是整数字符串才能转整数，浮点数字符串不能转整数
1
2
3
4
5
6
7
8
9
10
11
12
13

注意：整数字符串转整数，如果字符串中有非数字符号，会报错

int('1.8')  # 报错 不能这样写
1

②、浮点数-字符串
float - str

a = 1.2       
a = str(a)    
print(type(a))  #  <class 'str'>
1
2
3

str - float 一定要是合法的浮点数字符串才能转化为浮点数

print(float('1.5'))    # 1.5
print(float('18'))     # 18.0
print(float(a))       # 报错 因为不是合法的字符串
print(float('1.8.8'))   # 报错
float('1.2')  # 1.2
float('.2')  # 0.2
float('1.')  # 1.0
float('3.4e-3')  # 0.0034
# 只要是合法的浮点数字符串都可以转化为浮点数
1
2
3
4
5
6
7
8
9

只要浮点数字符串去掉引号它还是浮点数那么它就可以转化为浮点数

2.7 转义符

python中使用反斜杠 \ 转义字符, \和某些字符组合，表示特殊含义的字符。
以下列举常用的转义字符

• \\ 输出反斜杠本身

print('b\\a')   #  b\a
1

• \’ 输出单引号本身

print('a\'b\'c')   # a'b'c
1

• \" 输出双引号本身

print("a\"b\"c")  # a"b"c
1

• \a 响铃
• \n 换行

linux系统 换行 \n

windows \r\n

print('床前明月光,\n疑是地上霜’）
# 床前明月光，
# 疑是地上霜
1
2
3

• \r 回车
• \t 制表符 隔一个Tab键

print('a\tb')   #  a	b
1

• 在定义字符串的时候，有时候需要强制不转义，在字符串的前面加上 r 这个引导符 字符串会原样输出（raw原始的原生的）。

print(r'床前明月光,\n疑是地上霜') 
#  床前明月光,\n疑是地上霜
1
2

如何快速区分正斜杠和反斜杠？
撇正捺反

2.8 字符串的格式化

以上文件是政府办公厅文件，红字部分是模板是固定不变的，而画x的部分是需要根据实际情况动态调整的内容。我们在编程的时候想输出字符串，这个字符串有一些内容可能会动态地改变，那我们是不是也可以先写一个模板，然后在输出的时候我们动态地去填充空白的地方？，为了实现这样的一个功能，我们引入字符串的格式化概念。

在实际工作过程中经常需要动态输出字符串
例如，我们通过程序计算计算机的内存利用率，然后输出
（10：15）计算机的内存利用率为（30%）
其中括号中的内容会动态调整，需要根据程序执行结果进行填充，最终形成上述格式的字符串输出
python支持三种形式的字符串格式化。

2.8.1 % 字符串格式化

语法格式：
%[(name)][flags][width][.precision]typecode
括号里是可选项，typecode是必选项。

简单用法：例1：

time = '11:15'
percent = 75
format_str = '%s计算机的内存使用率为%s%%'  # 模版字符串
# %是槽位的标志会被替换，‘%s'作为槽位和 % 后提供的值按顺序一一对应
# s 等价于，先把值 str 一下 然后替换到模版字符串中
# 因为 % 是槽位(需要被替换的地方)标志,所以在模板字符串中想要单独输出  %，不能只使用一个%。
# 模版字符串中想要单独输出 % 就需要 %%，表示输出百分号本身 (可以当作是转义).

res = format_str % (time, percent)  # 如果只有一个值直接写值就行了，不用加括号。
print(res)  # 11:15 计算机的内存利用率为75%
# 注意：time 和 percent的位置是不能换的，因为它是按照位置一一对应的。
#  如果你的槽位和你的值的数量不匹配，它会报错。

写成一条语句
res = '%s计算机的内存使用率为%s%%' % ('11:15', 75)
print(res)   #  11:15计算机的内存使用率为75%
# 还可以写成这样
res = '%(time)s计算机的内存利用率为%(percent)s%%' % {'time':'11:15', 'percent': 75}
# % 后是字典时，可以通过name指定key对应的值
print(res)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

注意：
①、typecode 是必须要写的
②、s 等价于先把值str一下，然后再替换到模板字符串中

高级用法：例2：
需求：输出两位数的月份，例如01，02

month = '%02d' % 6  # 右对齐，内容向右靠。
print(month)  # 06
1
2

需求：生成 ‘0001’ ‘9999’

res = '%04d' % 1
print(res)  # 0001
1
2

需求，保留小数点

res = '%s计算机的内存利用率为%f%%' % ('11:15',75.999)
print(res)   #  11:15计算机的内存利用率为75.999000%
1
2

优化 [.precision]保留几位小数会自动四舍五入

res = '%s计算机的内存利用率为%.2f%%' % ('11:15',75.599)
print(res)  # 11:15计算机的内存利用率为75.60%,保留两位小数。
1
2

把一个数转换成不同的数据类型。

print('字符串%s,十进制%d,科学计数%e,八进制%o,16进制%x,unicode字符%c' % (100, 100, 100, 100, 100, 100))  
# 字符串100,十进制100,科学计数1.000000e+02,八进制144,16进制64,unicode字符d  把后面的值转换成不同的类型然后再格式化到我们的模版字符串里面
print('字符串%(key)s,十进制%(key)d,科学计数%(key)e,八进制%(key)o,16进制%(key)x,unicode字符%(key)c' % {'key': 65})
#  字符串65,十进制65,科学计数6.500000e+01,八进制101,16进制41,unicode字符A
1
2
3
4

2.8.2 format()方法格式化字符串

% 的字符串格式化继承自 C 语言，python 中给字符串对象提供了一个 format 函数进行字符串格式化，且功能更强大，并且大力推荐，所以我们要首选使用。format本身也是字符串中的一个方法。

格式 ：<模板字符串>.format(<逗号分隔的参数>)
在模板字符串中使用{}代替了以前的 % 作为槽位
简单使用
①、：

print('{}计算机的内存利用率为{}%'.format('11:15',75)) # 在模版字符串中调用format把后面的参数传入槽位。
 #  11:15计算机的内存利用率为75.999%
1
2

②、当format中的参数使用位置参数提供时，{}中可以填写参数的整数索引和参数一一对应。

print('{0}计算机的内存利用率为{1}%'.format('11:15',75)) 
#  0 和 1 调换位置也是可以的 两个0或两个1也是可以的
 #  11:15计算机的内存利用率为75.999%
1
2
3

③、当format中的参数使用关键字参数提供时，{}中可以填写参数名与参数一一对应。
在传参数的时候可以指明这个数据叫什么，

print('{time}计算机的内存利用率为{percent}%'.format(time='11:15', percent=75))
#  这样写的时候括号里面必须要写对应的参数名
#  右边的参数可以通过参数名放在左边的任一槽位
 #  11:15计算机的内存利用率为75.999%
1
2
3
4

复杂用法
{} 中除了可以写参数索引外，还可以填写控制信息来实现更多的格式化功能，语法如下
{[参数序号][:格式控制标记]}

其中 格式控制标记格式如下
[fill][align][sign][#][0][width][,][.precision][type]

注意：冒号是格式控制标记符，是固定的 ，必须要有的，是为了把前面的time，0等和后面的分隔开来。

例1：输出两位数的月份 例如：01 02

res = '{:0>2}'.format(8)
# 宽度为2 右对齐，空白处填充0，超过了就远样输出不会截取字符
print(res)   # 08  fill 空白部分填充，写任何的单个字符都可以，相对于百分号更有优势。
1
2
3

例2 : 左对齐

print('{:*<5}'.format(9))
# '9****'
print('{:=^20}'.format('登录功能开始测试'))
1
2
3

例3： 保留两位小数

res = '{time}计算机的内存利用率为{percent:.2%}'.format(time='11:15', percent=0.75123)
# 11:15计算机的内存利用率为75.12%
1
2

例4 ，为数字添加分隔符

print('{:,}'.format(10000000))
#  10,000,000 # 每三个0加一个逗号
1
2

例5：

print('字符串{key},十进制{key:d},科学计数{key:e},八进制{key:#o},16进制{key:x},unicode字符{key:c}'.format(key=65))
#  字符串65,十进制65,科学计数6.500000e+01,八进制0o101,16进制41,unicode字符A
1
2

2.8.3 格式字符串字面值

3.6 新版功能
格式字符串字面值或称为 f-string 是标注了 ‘f’ 或 ‘F’ 前缀的字符串字面值。
这种字符串可包含替换槽位，即以 {} 标注的表达式。

基本语法
literal_char{expression[:format_spec]}
literal——char：普通的字符
expressional： 表达式，变量，函数
format_spex:格式字符串 规则和 format 里面的控制字符一模一样

例1

iten = '11:15'
percent = 75
f_str = f'{iten}计算机的内存利用率为{percent:.2f}%' 
#  冒号后面和format一模一样
# %写在外面和写在里面是不一样的，如果写在里面表示要把percent格式化成百分比(是一个控制字符)，写在外面表示模版字符串里面的一个普通的字符。
print(f_str)  
# 11:15计算机的内存利用率为7500%   %写在里面
# 11:15计算机的内存利用率为75.00%   %写作外面
1
2
3
4
5
6
7
8

例2：
用f字符串输出两位数的月份 例如01 02…

month = 8
res = f'{month:0>2}'  
print(res)  # 08  month必须是前面定义了的，不然就会报错。后面部分和format格式化一模一样。
1
2
3

例3:

num = 10
res = f'十进制{num:d},八进制{num:#0}'
print(res)   # 十进制10,八进制10
1
2
3

例4 包含运算和函数的f字符串

num = -10
print(f'{num+1}')  # 11

s = '*'
print(f'{s * 10})

print(f'{abs(num)}')

1
2
3
4
5
6
7
8

例5：

s = 'abcd'
print(f'{s[::-1]}')

s = '心蓝'
ss ='心蓝最帅'
print(f'{s:>3}')
print(f'(ss:>3}')
# dcba
#  心蓝   右对齐宽度为3，多余部分用空格填充
# 心蓝最帅  右对齐，宽度为3，超出了3就原样输出
1
2
3
4
5
6
7
8
9
10

例题：

解析：
①：对于百分号字符串格式化的来说，百分号是槽位的标志，如果你的槽位和你的值的数量不匹配会报错，所以A错误
②：当format中的参数使用关键字参数提供时，{}中必须填写参数名与后面的参数对应，所以D错误
③：C答案不报错，但是不规范，format字符串格式化，槽位的数量尽量和后面的值的数量相匹配，如果不匹配的话不会报错，但是不规范。c答案后面的2没有意义