5 字符串

1 下标

"下标" 又叫 "索引" ，就是编号。比如火车座位号，座位号的作用: 按照编号快速找到对应的座位。同理，下标的作用即是通过下标快速找到对应的数据.

str1 = 'abcdefg'
print(str1)
# 数据在程序运行过程中存放在内存里面
# 现在我想得到数据 a 这个字符，和得到数据 b 这个字符就如下操作
# 在程序中字符数据会从 0 开始按照顺序分配一个编号，使用对应下标取出对应数据

# 取出字符串下标得到精确值
print(str1[0],str1[1])

[10:31:33 root@dev py-demo]#/bin/python3 /root/py-demo/day-1/test.py
abcdefg
a b

1.2 快速体验

需求: 字符串 name ="abcdef”，取到不同下标对应的数据。

如上图我们想取出 name[0] 的值就是 a

代码：

name ="abcdef"

print(name[0])
print(name[2])
print(name[3])

[10:31:33 root@dev py-demo]#/bin/python3 /root/py-demo/day-1/test.py
a
c
d

2 切片

切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。

注意在切片中我们都是取前不取后

如果取值方向(下标开始到结束的方向) 和 步长的方向冲突则不能取

2.1 语法

#  序列[开始位置下标:结束位置下标:步长]

注意：

1.不包含结束位置下标对应的数据， 正负整数均可。

2.步长是选取间隔，正负整数均可，默认步长为1。

2.2 体验

2.2.1 步长体验

范例 1

在下面范例中我想得到 str1 变量的 a、b、c 这三个数据，这时候就需要使用到切片功能

str1 ="abcdef"

# abc
# 从 0 下标取，一直取到 3 的索引，每次步长为 1，也就取出 str1[0,1,2] 
print(str1[0:3:1])

[10:56:11 root@dev py-demo]#/bin/python3 /root/py-demo/day-1/test.py
abc

范例 2

arr = '0123456789'

# 24
# 从下标 2 开始取，一直取到 5 ，每次步长为 2
print(arr[2:5:2])

[10:56:15 root@dev py-demo]#/bin/python3 /root/py-demo/day-1/test.py
24

2.2.2 默认取值体验

范例 3

# 这个示例中没有写步长的值，因为在切片中默认步长为 1

str1 ="abcdef"

# abc，如果不写开始下标，默认从 0 开始取值
print(str1[:3])

# cde
print(str1[2:5])

# ef，如果不写结束下标，默认取到最后一个下标
print(str1[4:])

# abcdef ，开始和结束都不写默认取出所有下标
print(str1[:])

[10:51:04 root@dev py-demo]#/bin/python3 /root/py-demo/day-1/test.py
abc
cde
ef
abcdef

2.2.3 负数体验

范例 4

arr = '0123456789'

# 步长为负数，会将数据倒序排序
print(arr[::-1])

# 以 2 为步进倒叙取值
# 97531
print(arr[::-2])

# 如果下标取负数，如负 1 ，则标识该数组的最后一个这里是 9 ，-2 是 8 以此向前类推
# 所以 -4 这里是倒数第四 6 ，取到倒数第 1 并不包含 -1 
# 678
print(arr[-4:-1])

[11:09:10 root@dev py-demo]#/bin/python3 /root/py-demo/day-1/test.py
9876543210
97531
678

2.2.4 复杂体验

arr = '0123456789'

# -1 步长为负数，会将数据倒序排序
# 不能取数数据，从 -4 到 -1 取值方向为从左到右，但是 -1 步长为从右向左取值
# 如果取值方向(下标开始到结束的方向) 和 步长的方向冲突则不能取
print(arr[-4:-1:-1])

可以看到打印出的内容为空

注意：

在反方向取值的时候需要方向一致才能取出

arr = '0123456789'

# 987
# 这里取出来是 987，因为步长为 -1 所以由后往前取值，并且取倒数第一个到倒数第4个并不包含倒数第4个的值
print(arr[-1:-4:-1])

[11:17:29 root@dev py-demo]#/bin/python3 /root/py-demo/day-1/test.py
987

3 常用操作方式

字符串的常用操作方法有查找、修改和判断三大类

其实所谓的操作方法，无非就是学习操作函数，而在学习操作函数的时候需要很多大量的函数需要我们记忆

3.1 查找

所谓字符串查找方法即是查找子串在字符串中的位置(index)或出现的次数。

3.1.1 find()

find()： 检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则返回-1。

1.语法

字符串序列.find(子串，开始位置下标，结束位置下标)

注意: 开始和结束位置下标可以省略，表示在整个字符串序列中查找。

2.快速体验

mysrt = 'hello world and itcast and it an python'
print(mysrt.find('and'))    # 输出 12 ，默认会把第一个查找到的进行输出
print(mysrt.find('and',15,30))  # 输出 23 ，查找 and 并且开始下标为 15，结束下标为 30
print(mysrt.find('ands'))   # 输出 -1 ，因为在 mysrt 字符串中并没有 ands 这个子串

[15:35:32 root@dev py-demo]#/bin/python3 /root/py-demo/day-1/test.py
12
23
-1

3.1.2 index()

index()：检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则报异常。

1.语法

字符串序列.index(子串，开始位置下标，结束位置下标)

注意: 开始和结束位置下标可以省略，表示在整个字符串序列中查找。

2.快速体验

mysrt = 'hello world and itcast and it an python'

# 输出 12
print(mysrt.index('and'))

# 输出 23
print(mysrt.index('and',15,30))

# 直接报错
print(mysrt.index('ands'))

[15:39:30 root@dev py-demo]#/bin/python3 /root/py-demo/day-1/test.py
12
23
Traceback (most recent call last):
  File "/root/py-demo/day-1/test.py", line 5, in <module>
    print(mysrt.index('ands'))
ValueError: substring not found

# 报错为提示子字符串没有找到

3.1.3 count()

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

1. 语法

   字符串序列.count(子串，开始位置下标，结束位置下标)

2.快速体验

mysrt = 'hello world and itcast and it an python'

print(mysrt.count('and'))       # 输出 2 ，因为在上面的 mysrt 中拥有两个 and
print(mysrt.count('and',15,30)) # 输出 1 ，因为在上面的 mysrt 15 到 30 下标中拥有1个 and
print(mysrt.count('ands'))        # 输出 0 ，因为在上面的 mysrt 中拥有 0 个

[15:50:19 root@dev py-demo]#/bin/python3 /root/py-demo/day-1/test.py
2
1
0

3.1.4 rfind

用法和 find 一样，只不过 rfind 是通过字符串右侧开始查找

mysrt = 'hello world and itcast and it an python'

print(mysrt.rfind('and'))   # 输出 23 ，默认会将最后一个输出
print(mysrt.rfind('and',0,15))   # 输出 12 ，指定了寻找下标 0-15
print(mysrt.rfind('ands'))  # 输出 -1

[15:58:23 root@dev py-demo]#/bin/python3 /root/py-demo/day-1/test.py
23
12
-1

3.1.5 rindex

用法和 index 一样，只不过 rindex 是通过字符串右侧开始查找

mysrt = 'hello world and itcast and it an python'

print(mysrt.rindex('and'))   # 输出 23 ，默认会将最后一个输出
print(mysrt.rindex('and',0,15))   # 输出 12 ，指定了寻找下标 0-15
print(mysrt.rindex('ands'))  # 输出 -1

[16:01:24 root@dev py-demo]#/bin/python3 /root/py-demo/day-1/test.py
23
12
Traceback (most recent call last):
  File "/root/py-demo/day-1/test.py", line 5, in <module>
    print(mysrt.rindex('ands'))  # 输出 -1
ValueError: substring not found

3.2 修改

所谓修改字符串，指的就是通过调用函数的形式修改字符串中的数据做一个调整

3.2.1 replace()

replace 替换:

1.语法

字符串序列.replace(旧子串，新子串，替换次数)

注意: 替换次数如果查出子串出现次数，则替换次数为该子串出现次数

2.快速体验

mysrt = 'hello world and itcast and it and python'

# 将 mysrt 中所有 and 替换为 & ，这里并没有写替换次数
# 输出结果：hello world & itcast & it & python
print(mysrt.replace('and','&'))

# 注意：replace 函数有返回值，返回值是修改后得字符串
# 而元数据并没有修改，说明数据可以分为两类：1、可变类型 2、不可变类型
# replace 函数可以将值返回给变量如下操作：
# 输出：hello world @ itcast @ it @ python
new_srt = mysrt.replace('and','@')
print(new_srt)

# 替换次数，这里将第一个 and 替换为 $ ，因为我们得替换次数为 1
# 输出：hello world $ itcast and it and python
print(mysrt.replace('and','$',1))

# 替换次数这里改为 10
# 可以看到在 mysrt 变量中 and 一共有 3 个，但是我们需要替换为 10，所以会将其全部替换
# 替换次数如果超出子串出现次数，表示替换所有子串
print(mysrt.replace('and','*',10))

[10:35:49 root@dev py-demo]#/bin/python3 /root/py-demo/day-1/test.py
hello world & itcast & it & python
hello world @ itcast @ it @ python
hello world $ itcast and it and python
hello world * itcast * it * python

3.2.2 split()

split(): 按照指定字符分割字符串

1.语法

字符串序列.split(分割字符，num)

注意: num 表示的是分割字符出现的次数，即将来返回数据个数为num+1个

2.快速体验

mysrt = 'hello world and itcast and it and python'

# split 分割，返回一个列表
# 输出： ['hello world ', ' itcast ', ' it ', ' python']
# 将 mysrt 中 and 分割，可以看到上面输出了 4 个数据
list1 = mysrt.split('and')
print(list1)

# 分割字符次数为 2
# 输出：['hello world ', ' itcast ', ' it and python']
# 通过上面输出可以看到数据为 3 个，并且最后一个 and 并没有进行分割
list1 = mysrt.split('and',2)
print(list1)

输出：

[10:41:04 root@dev py-demo]#/bin/python3 /root/py-demo/day-1/test.py
['hello world ', ' itcast ', ' it ', ' python']
['hello world ', ' itcast ', ' it and python']

注意: 如果分割字符是原有字符串中的子串，分割后则丢失该子串

3.2.3 join()

join(): 用一个字符或子串合并字符串，即是将多个字符串合并为一个新的字符串

1.语法

字符或子串.join(多字符串组成的序列)

2.快速体验

# join() 合并列表里面的字符串数据为一个大字符串
mylist = ['aa','bb','cc']

# 这里我想实现以后得数据为：aa...bb...cc
# 可以看到链接字符需要放到 join 前面
new_str =  '...'.join(mylist)
print(new_str)

# 可以看到当前所有字符已经实现通过 ... 拼接
[10:42:56 root@dev py-demo]#/bin/python3 /root/py-demo/day-1/test.py
aa...bb...cc

3.2.4 capitalize()

capitalize(): 将字符串第一个字符转换成大写

mysrt = 'hello world and itcast and it and python'
print(mysrt.capitalize())

# 可以看到在该字符串中只有 hello 的 H 转为了大写
[10:51:44 root@dev py-demo]#/bin/python3 /root/py-demo/day-1/test.py
Hello world and itcast and it and python

注意: capitalize()函数转换后，只字符串第一个字符大写，其他的字符全都小写

3.2.5 title()

title(): 将字符串每个单词首字母转换成大写

mysrt = 'hello world and itcast and it and python'
print(mysrt.title())

# 可以看到每个字符串的首字母都转为了大写
[10:51:51 root@dev py-demo]#/bin/python3 /root/py-demo/day-1/test.py
Hello World And Itcast And It And Python

3.2.6 upper()

upper()：将全部小写转为大写

mysrt = 'hello world and itcast and it and python'
print(mysrt.upper())

[10:52:49 root@dev py-demo]#/bin/python3 /root/py-demo/day-1/test.py
HELLO WORLD AND ITCAST AND IT AND PYTHON

3.2.7 lower()

lower()：将全部大写转为小写

mysrt = 'Hello World and itcast and it and python'
print(mysrt.lower())

[10:57:37 root@dev py-demo]#/bin/python3 /root/py-demo/day-1/test.py
hello world and itcast and it and python