MSG

# 6.str字符串数据类型

# 字符串 (str / string)

字符串使用格式：在python中字符串使用双引号，单引号，三引号，引起来的内容就称为字符串

# 字符串操作

# 字符串相加操作

格式：变量 + 变量 或 变量 = 变量 + 变量

wo1='你好！'
wo2=' 世界'
print(wo1+wo2)

执行结果：
你好！ 世界

# 字符串复制操作

格式：变量 * 次数 或 变量 = 变量 * 次数

wo = '你好！ 世界\n'
print(wo * 3)

执行结果：
你好！ 世界
你好！ 世界
你好！ 世界

​ 以上实例，我在字符串中加了换行符，如果没加，3遍字符串就会输出在同一行

# 切片跟索引

# 索引

索引也称为下标，在python中索引也是下标是从0开始

反向索引：python中反向索引是从-1开始

索引就是字符串的下标位置

通过索引获取到的内容，其内容还是字符串类型

格式：变量[下标值]

索引实例

a = "世界这么多，你不去走走？"
print(a[1])

执行结果：
界

​ 以上的实例，获取到了下标为1的字符

a = "世界这么多，你不去走走？"
print(a[20])

执行结果：
IndexError: string index out of range

​ 以上的实例，通过下标值获取字符的范围超过字符串的整体范围，所以报错了

反向索引实例

a = "世界这么多，你不去走走？"
print(a[-1])

执行结果：
？

​ 以上的实例：运用反向索引，下标值为-1，获取到了最后一位的字符

a = "世界这么多，你不去走走？"
print(a[-0])

执行结果：
世

​ 以上的实例：使用下标值为-0，-0这下标值在python中相等于0，-0=0

# 切片

切片可以对字符串进行截取取值，从0开始，反向切片从-1开始

反向切片，默认是从左向右切

特点：起始值可取，结束值不可取

格式：变量[起始位置 : 结束位置]

实例：

a = "世界这么多，你不去走走？"
print(a[0:2])

执行结果：
世界

a = "世界这么多，你不去走走？"
so = a[0:2] + a[7:9]
print(so)

执行结果：
世界不去

a = "世界这么多，你不去走走？"
so = a[6:]
print(so)

执行结果：
你不去走走？

​ 如果结束位置不填，默认到结尾

a = "世界这么多，你不去走走？"
so = a[:5]
print(so)

执行结果：
世界这么多

​ 如果起始位置不填，默认从开头开始

a = "世界这么多，你不去走走？"
so = a[:]
print(so)

执行结果：
世界这么多，你不去走走？

​ 如果起始跟结束位置都不填写，默认从头到尾执行

a = "世界这么多，你不去走走？"
so = a[-3:-1]
print(so)

执行结果：
走走

​ 反向切片

# 步长

步长，可以在指定范围内，每几个取一个值

反向步长，以右向左方向取值

格式：变量[起始位置 : 结束位置 : 步长]

实例：

a = "世界这么多，你不去走走？"
so = a[0:5:2]
print(so)

执行结果：
世这多

​ 每走二步，取一个值

a = "世界这么多，你不去走走？"
so = a[0::2]
print(so)

执行结果：
世这多你去走

从0位置到结尾位置，每二步为一组，每一组取第一位值

a = "世界这么多，你不去走走？"
so = a[8:1:-2]
print(so)

执行结果：
去你多这

反向步长，从8位置以反方向2位置开始，每二步为一组，每一组取第一位值

a = "世界这么多，你不去走走？"
so = a[-1:-7:-2]
print(so)

执行结果：
？走不

# 迭代

可以使用for循环来便利或获取 字符串中的每一个字符

语法：

for 变量量 in 可迭代对象:
     pass

​ 可迭代对象: 可以⼀一个⼀一个往外取值的对象

便利或获取字符串的字符，一般使用for循环，也有用while循环的

so = "there is only one line difference between genius and madman.是吗"
s = 0
while s <= len(so):
    print(so[s])
    s += 1
    
so = "there is only one line difference between genius and madman.是吗"
for i in so:
    print(i)

​ 以上的实例，就看得出 for 跟 while的区别

# 字符串的内置函数

字符串是不可变的对象，所有任何操作对原字符串是不会有任何的影响

# 英文互转函数

# 首字母变成大写-capitalize()

让字符串中第一位字母，如果是小写，就变成大写

格式：变量.capitalize() 或 变量 = 变量.capitalize()

so = "there is only one line difference between genius and madman. 是吗"
print(so.capitalize())

执行结果：
There is only one line difference between genius and madman. 是吗

# 转成大写-upper()

将字符串中的全部小写字母变成大写

格式：变量.upper() 或 变量 = 变量.upper()

so = "there is only one line difference between genius and madman.是吗"
print(so.upper())

执行结果:
THERE IS ONLY ONE LINE DIFFERENCE BETWEEN GENIUS AND MADMAN.是吗

# 转成小写-lower()

将字符串中的全部大写字母变成小写

格式：变量.lower() 或 变量 = 变量.lower()

so = "There Is Only One Line Difference Between Genius And Madman.是吗"
print(so.lower())

执行结果:
there is only one line difference between genius and madman.是吗

# 实例：验证码登录

验证码登录，要求把验证码强制转成小写字母

so = "jxPT"
wo = input("请输入验证码%s："%(so,))
if so.lower() == wo.lower():
    print("登录成功")
else:
    print("验证码错误")

# 英文字母大小写互换-swapcase()

就是把字符串中的，大写字母转成小写字母，小写字母转成大写字母

格式：变量.swapcase() 或 变量 = 变量.swapcase()

so = "There Is Only One Line Difference Between Genius And Madman.是吗"
print(so.swapcase())

执行结果：
tHERE iS oNLY oNE lINE dIFFERENCE bETWEEN gENIUS aND mADMAN.是吗

# 转成小写(不常用)-casefold()

将字符串中的全部大写字母变成小写，跟上面的lower()函数功能差不多

lower() 跟 casefold() 区别

  1. lower() 对某些字符支持不够好
  2. casefold() 对所有字母都生效，如东欧的一些字母等

格式：变量.casefold() 或 变量 = 变量.casefold()

so = "There Is Only One Line Difference Between Genius And Madman.是吗"
print(so.casefold())

执行结果：
there is only one line difference between genius and madman.是吗

​ 以上实例，执行后的结果跟上面的 lower() 函数差不多，请看下面的实例

so = "БBß"  # 俄美德
print("没有加函数的结果：",so)
print("lower() 函数的结果：",so.lower())
print("casefold() 函数的结果：",so.casefold())

执行结果：
没有加函数的结果： БBß
lower() 函数的结果： бbß
casefold() 函数的结果： бbss

# 以特殊字符隔开的首字母大写(不常用)-title()

在字符串中，每个被特殊字符隔开的字母，首字母大写

注意：在title() 函数中，中文也是特殊字符

格式：变量.title() 或 变量 = 变量.title()

so = "there is only one line difference between genius and madman.是吗"
print(so.title())

执行结果：
There Is Only One Line Difference Between Genius And Madman.是吗

​ 以上实例，空格为特殊字母，所以每个空格后第一个字母变成大写

so = "there is only one line differ是吗ence between genius and madman."
print(so.title())

执行结果：
There Is Only One Line Differ是吗Ence Between Genius And Madman.

​ 以上实例：空格跟中文为特殊字母，所以每个空格或中文后第一个字母变成大写

# 切法函数

# 指定长度-居中-center()

字符串中，指定字符串长度，如果字符串长度没有那么长，原字符串数据居中后直接自动填充

如果不指定填充的字符，python默认是以空格填补

格式：变量.center(长度数,"填充字符") 或 变量 = 变量.center(长度数,"填充字符")

so = "博主最帅"
print(so.center(10))

执行结果：
   博主最帅

​ 以上实例，如果不指定填充字符，默认以空格填充

so = "博主最帅"
print(so.center(10,"*"))

执行结果：
***博主最帅***

​ 以上实例，指定了 * 字符为填充字符

# 指定长度-居左-ljust()

字符串中，指定字符串长度，如果字符串长度没有那么长，原字符串数据居左后直接自动填充

如果不指定填充的字符，python默认是以空格填补

格式：变量.ljust(长度数,"填充字符") 或 变量 = 变量.ljust(长度数,"填充字符")

so = "博主最帅"
print(so.ljust(10))

执行结果：
博主最帅

​ 以上实例，如果不指定填充字符，默认以空格填充

so = "博主最帅"
print(so.ljust(10,"*"))

执行结果：
博主最帅******

​ 以上实例，指定了 * 字符为填充字符

# 指定长度-居右-rjust()

字符串中，指定字符串长度，如果字符串长度没有那么长，原字符串数据居右后直接自动填充

如果不指定填充的字符，python默认是以空格填补

格式：变量.rjust(长度数,"填充字符") 或 变量 = 变量.rjust(长度数,"填充字符")

so = "博主最帅"
print(so.rjust(10))

执行结果：
      博主最帅

​ 以上实例，如果不指定填充字符，默认以空格填充

so = "博主最帅"
print(so.rjust(10,"*"))

执行结果：
******博主最帅

​ 以上实例，指定了 * 字符为填充字符

# 指定 \t 字符的长度-expandtabs()

可以指定\t的长度，默认长度是8

格式：变量.expandtabs(指定长度) 或 变量 = 变量.expandtabs(指定长度)

so = "博主最\t帅"
print(so.expandtabs(10))

执行结果：
博主最       帅

# 去除空格-左右-strip()

去除左右两端的空格，就是去除开头跟结尾的空格

strip() 函数还有去除字符的做作，默认是去除空格

想要去除指定的字符，注意：只能去除左右两端

格式：变量.strip(默认或指定字符) 或 变量 = 变量.strip(默认或指定字符)

so = " 博主 最帅 "
print(so.strip())

执行结果：
博主 最帅

​ 默认去除空格

so = "博主 最帅 博主"
print(so.strip("博主"))

执行结果：
 最帅

​ 指定字符去除

# 去除空格-左边-lstrip()

去除左右两端的空格，就是去除开头跟结尾的空格

strip() 函数还有去除字符的做作，默认是去除空格

想要去除指定的字符，注意：只能去除左边端

格式：变量.lstrip(默认或指定字符) 或 变量 = 变量.lstrip(默认或指定字符)

so = " 博主 最帅 "
print(so.lstrip())

执行结果：
博主 最帅

默认去除空格

so = "博主 最帅 博主"
print(so.lstrip("博主"))

执行结果：
 最帅 博主

​ 指定字符去除

# 去除空格-右边-rstrip()

去除左右两端的空格，就是去除开头跟结尾的空格

strip() 函数还有去除字符的做作，默认是去除空格

想要去除指定的字符，注意：只能去除右边两端

格式：变量.rstrip(默认或指定字符) 或 变量 = 变量.rstrip(默认或指定字符)

so = " 博主 最帅 "
print(so.rstrip())

执行结果：
 博主 最帅

默认去除空格

so = "博主 最帅 博主"
print(so.rstrip("博主"))

执行结果：
博主 最帅

​ 指定字符去除

# 实例：用户登录，忽略空格

要求：模拟用户登录，忽略用户输入的空格值

user = input("请输入用户名：")
pwd = input("请输入密码：")
if user.strip() == "博主" and pwd.strip() == "123456":
    print("登录成功")
else:
    print("账号或密码错误")
    
或

user = input("请输入用户名：").strip()
pwd = input("请输入密码：").strip()
if user == "博主" and pwd == "123456":
    print("登录成功")
else:
    print("账号或密码错误")

# 字符串替换-replace()

字符串替换，如果不指定替换数，默认是全替换

格式：

  1. 变量.replace("原字符串内存","要替换的内容",替换数)
  2. 变量 = 变量.replace("原字符串内存","要替换的内容",替换数)
so = "There Is Only One Line Difference Between Genius And Madman."
so = so.replace("There","也许")
print(so)

执行结果：
也许 Is Only One Line Difference Between Genius And Madman.

​ 以上实例：替换指定的字符，默认全替换

so = "There sssssss Is Only One Line Difference Between Genius And Madman."
so = so.replace("s","S",6)
print(so)

执行结果：
There SSSSSSs Is Only One Line Difference Between Genius And Madman.

​ 以上实例：指定替换数为6，超过6位后不替换

# 字符串切割-split()

字符串切割，根据指定的切割符进行切割，用什么字符切割，切割后字符就会消失

注意：如果切割是在开头或结尾，那就会出现空字符串

切割出来后的字符串，是以列表类型显示存放，字符还是字符串类型

格式：变量.split("切割符") 或 变量 = 变量.split("切割符")

so = "There Is Only One Line Difference Between Genius And Madman."
so = so.split(" ")
print(so)

执行结果：
['There', 'Is', 'Only', 'One', 'Line', 'Difference', 'Between', 'Genius', 'And', 'Madman.']

​ 以上实例，切割空格符，切割后空格就消失

so = "There Is Only One Line Difference Between Genius And Madman. There"
so = so.split("There")
print(so)

执行结果：
['', ' Is Only One Line Difference Between Genius And Madman. ', '']

​ 以上实例，提醒你：如果切割是在开头或结尾，那就会出现空字符串

# 字符串指定字符插入-join()

将容器数据中的字符串使用制定的字符进行链接成一个字符串

join函数 可以把列表转成字符串

格式：'链接字符'.join(变量) 或 变量 = '链接字符'.join(变量)

wo = ['业务：你好，大家好','老板：我好,全都好','医生：他好，我也好']
so = '___'.join(wo)
print(so)

执行结果:
业务：你好，大家好___老板：我好,全都好___医生：他好，我也好

# 实例：切割函数跟字符插入函数的应用

使用split() 函数跟 join() 函数

so = "There Is Only One Line Difference Between Genius And Madman. There"
so = so.split("There")
print('_'.join(so))

执行结果：
_ Is Only One Line Difference Between Genius And Madman. _

# 格式化输出-format()

虽然python有站位符格式化输出，但是字符串类型也有个函数也是做格式化输出，功能差不多

三种格式：

  1. 变量 = {}{}{}.format("值0","值1","值2") ## 按左向右顺序输出

    so = "我为{}，心情好就写{}，主要写{}文章".format("博主","文章","技术类")
print(so)

执行结果：
我为博主，心情好就写文章，主要写技术类文章

  2. 变量 = {1}{2}{0}.format("值1","值2","值0") ## 按指定的顺序输出

    so = "我为{1}，心情好就写{2}，主要写{0}文章".format("博主","文章","技术类")
print(so)

执行结果：
我为文章，心情好就写技术类，主要写博主文章

  3. 变量 = {名称}{名称}{名称}.format(名称="值",名称="值",名称="值") ## 按指定的名称来输出

    so = "我为{wo}，心情好就写{so}，主要写{xo}文章".format(wo="博主",xo="文章",so="技术类")
print(so)

执行结果：
我为博主，心情好就写技术类，主要写文章文章

# 查找函数

# 开头查找-startswith()

判断是否以指定的字符开头

返回值：如果是：True ， 如果不是：False

格式：变量.startswith("字符") 或 变量 = 变量.startswith("字符")

so = "There Is Only One Line Difference Between Genius And Madman."
print(so.startswith("There"))

执行结果：
True

# 结尾查找-endswith()

判断是否以指定的字符结尾

返回值：如果是：True ， 如果不是：False

格式：变量.endswith("字符") 或 变量 = 变量.endswith("字符")

so = "There Is Only One Line Difference Between Genius And Madman."
print(so.endswith("Madman."))

执行结果：
True

# 查找字符出现次数-count()

查找指定的字符出现的次数

返回值，如果有：输出次数 ， 如果没有：输出0

格式：变量.count("字符") 或 变量 = 变量.count("字符")

so = "There Is Only One Line Difference Between Genius And Madman."
print(so.count("s"))

结果：
2

​ 以上的实例，查找 s 字符在字符串出现过几次，出现了2次

# 查找字符出现的位置-find

查找指定的字符的位置，也能指定范围找指定的字符位置

返回值：如果找得到：返回位置 ， 如果找不到：返回 -1

格式：变量.find("字符",开始位置,结尾位置) 或 变量 = 变量.find("字符",开始位置,结尾位置)

so = "There Is Only One Line Difference Between Genius And Madman."
print(so.find("s"))

执行结果：
7

​ 以上实例，查找到 s 字符在7位中

​ 注意：只要查找到，就会马上返回，不会查找后面的 s 字符

so = "There Is Only One Line Difference Between Genius And Madman."
print(so.find("s",8))

执行结果：
47

​ 以上实例，指定了查找的开始位置，没有指定结尾位置，默认是直接查找到结尾

# 查找字符出现的位置(报错)-index()

查找指定的字符的位置，也能指定范围找指定的字符位置

功能跟find() 函数一样，唯一不一样的就是，fin() 没结果是返回 -1 ，index() 没结果是直接报错

返回值：如果找得到：返回位置 ， 如果找不到：直接程序报错

格式：变量.index("字符",开始位置,结尾位置) 或 变量 = 变量.index("字符",开始位置,结尾位置)

so = "There Is Only One Line Difference Between Genius And Madman."
print(so.index("s"))

执行结果：
7

​ 以上实例，查找到 s 字符在7位中

​ 注意：只要查找到，就会马上返回，不会查找后面的 s 字符

so = "There Is Only One Line Difference Between Genius And Madman."
print(so.index("s",8))

执行结果：
47

​ 以上实例，指定了查找的开始位置，没有指定结尾位置，默认是直接查找到结尾

## index()函数
so = "There Is Only One Line Difference Between Genius And Madman."
print(so.index('世界'))

结果：
ValueError: substring not found
    
## find()函数
so = "There Is Only One Line Difference Between Genius And Madman."
print(so.find('世界'))

结果：
-1

​ 以上实例，很明显的表达出 find()函数跟 index()函数的区别

# 条件判断函数

# 计算字符串长度 -len()

用于计算字符串串的⻓，长度，从 1 开始算

len() 函数运行实际是调用python内部的 len()函数

格式：len(变量) 或 变量 = len(变量)

so = "一二三"
print(len(so))

执行结果：
3

# 判断是否由大写字母组成-isupper()

检测一个字符串中的数据是否都是大写字母组成，符号不算

返回值：是：True ， 否：False

格式：变量.isupper() 或 变量 = 变量.isupper()

so = "HELLO！WORLD"
print(so.isupper())

执行结果：
True

# 判断是否由小写字母组成-islower()

检测一个字符串中的数据是否都是小写字母组成，符号不算

返回值：是：True ， 否：False

格式：变量.islower() 或 变量 = 变量.islower()

so = "hello！world"
print(so.islower())

执行结果：
True

# 判断是否由字母、数字、文字组成-isalnum()

检测一个字符串中的数据是否都是字母、数字、文字组成，符号不算

返回值：是：True ， 否：False

格式：变量.isalnum() 或 变量 = 变量.isalnum()

so = "ThereIsOnlyOneLineDifferenceBetweenGeniusAndMadman人1"
print(so.isalnum())

执行结果：
True

# 判断是否由字母、文字组成-isalpha()

检测一个字符串中的数据是否都是字母、文字组成6，符号不算

返回值：是：True ， 否：False

格式：变量.isalpha() 或 变量 = 变量.isalpha()

so = "ThereIsOnlyOneLineDifferenceBetweenGeniusAndMadman是吗"
print(so.isalpha())

执行结果：
True

# 判断是不是数字组成 - isdigit()

检测一个字符串中的数据是否由纯数字组成，十进制，符号不算

返回值：是：True ， 否：False

格式：变量.isdigit() 或 变量 = 变量.isdigit()

so = "121345"
print(so.isdigit())

执行结果：
True

# 判断是不是数字组成 - isdecimal()

检测一个字符串中的数据是否由纯数字组成，数字整数，符号不算

返回值：是：True ， 否：False

格式：变量.isdecimal() 或 变量 = 变量.isdecimal()

so = "121345"
print(so.isdecimal())

执行结果：
True

# 判断是不是数字组成 - isnumeric()

检测一个字符串中的数据是否由纯数字组成，可以识别中文数字，符号不算

返回值：是：True ， 否：False

格式：变量.isnumeric() 或 变量 = 变量.isnumeric()

so = "一二三"
print(so.isnumeric())

执行结果：
True

# 实例：模拟10086电话

需要判断输入的值是不是数字

so = input("请输入指定的数字：")
wo = so.isdigit()
print(wo)

print('''
    欢迎致电10086客服专线：
    1. 话费查询
    2. 业务办理
    3. 宽带办理
    4. 站点查询
    5. 人工服务
''')

so = input("请选择服务：")
wo = so.isdigit()
if wo == True:
    so = int(so)
    print("请稍等")
elif wo == False:
    print("请输入数字")

# 实例：for循环

要求：便利一遍字符串，如果有数字，输出出来

so = "the1re is on2ly one li3ne dif4feren5ce b6etwee7n geniu8s and mad9man.是吗"
for i in so:
    if i.isdigit():
        print(i)
        
执行结果：
1
2
3
4
5
6
7
8
9

# 过滤函数

# 制作字典-maketrans()

制作用于字符串替换的映射表（制作字典）

# 替换操作-translate()

进行字符串替换操作（替换操作）

# 实例：敏感字过滤

wo = '心态很重要，如果心态没把握好，很容易爆粗话，比如：草泥马'
so = ''.maketrans('草泥马','***')
do = wo.translate(so)
print(do)

结果：
心态很重要，如果心态没把握好，很容易爆粗话，比如：***

​ 在以上实例，在maketrans函数中替换的值，是一对一的

← 7.list 列表数据类型 →