python的字符串

Python字符串的三种表示方式

通过单引号，双引号、三引号都可以。

a = 'hello'
b = "hello"
c = '''hello'''
# 打印如下
hello
hello
hello

需要显示hello就是带有单引号，怎么表示呢？
需要输出单引号，那么两边可以使用双引号，三引号。
需要输出双引号，那么两边可以使用单引号，三引号。
需要输出三引号，那么两边可以使用单引号，双引号。

a = "hello,'world'"
b = 'hello,"world"'
c = "hello,'''world'''"
print(a)
print(b)
print(c)
# 打印如下
hello,'world'
hello,"world"
hello,'''world'''

字符串与数字相乘

字符串与数字相乘，是一种拼接的效果

d = 'hello'
d = d * 2
print(d)
# 打印如下：
hellohello

字符串的输入和输出

# 输入 input()
 input函数得到的内容就是字符串
 
# 输出 print() 函数
  格式化使用 %s 或者 f-string
  
name = "张三"
print("姓名: %s" % name)
# 使用%s占位，使用%引用变量
print(f"姓名: {name}")
# 使用f-string的形式，通过大括号占位引用变量

# 打印如下：
姓名: 张三
姓名: 张三

下标

下标其实就是索引，是一个整型数字，可以是正数，也可以是负数
正数下标是从0开始，表示第一个字符，-1 表示最后一个字符

my_str = “hello”
下标的使用语法是，变量[下标]

print(my_str[1]) # e
print(my_str[-4]) # e
#最后一个字符o的取值方法
print(my_str[4])  # o
print(my_str[-1])  # o
# 还可以结合len()函数实现
#len() 表示获取字符串的长度
print(my_str[len(my_str) - 1 ]) # o

切片(字符串截取一部分子串)

切片语法： 变量[start: end :step]，会得到一个新的字符串

start 开始位置的下标
end 结束位置的下标，不包含end对应的值
step 步长，下标之前的间隔，默认是1，当是1的时候，可以不写

my_str = 'hello'
# start索引为2，end索引为4，步长为1
my_str1 = my_str[2:4:1] # ll 
# start索引为2，end索引为4，步长为1可以省略不写
my_str2 = my_str[2:4] # ll
# end 位置不写，表示的是截取到最后一个元素，也可以理解为end的值为len()长度的值
my_str3 = my_str[2:] # llo
# start 省略不写，表示从索引0开始
my_str4 = my_str[:3] # hel
# start 和 end 都不写，表示重新获取一次数据hello
my_str5 = mystr[:] # hello
# 负数索引，也是可以的
my_str6 = my_str[-4:-1] # ell
 # 不会报错，只是取不到数据，因为开始索引比结束索引大了
my_str7 = my_str[3:1] # 没有数据
 # 步长是负数的时候，是可以的，倒着取值
my_str8 = my_str[3:1:-1] # ll
# 字符串的反转 
my_str9 = my_str[::-1] # olleh
# 开始索引，结束索引，省略，步长为2，取的是索引0,2,4的值 
my_str10 = my_str[::2] # hlo 相当与my_str[0:5:2]

字符串常见操作

find

检测str是否包含在my_str中，如果是返回开始的索引值，否则返回-1
my_str.find(str, start=0, end=len(my_str))
str：要在字符串中查找的内容，类型str
start:开始位置，从哪里开始查找，默认是0
end：结束的位置，查找到哪里结束，默认是len()
返回值：如果找到了str,返回str在my_str中的位置正数下标，如果没有找到，返回-1

# 从一个字符串中，查找是否存在某个字符串
my_str = "hello,world,aaa hello,world"
# 从my_str中查找hello,得到索引0
index = my_str.find('hello') # 0
# 从my_str中查找ello,得到索引1
index = my_str.find('ello') # 1
# 从my_str中查找hello,开始索引设置为3，将返回-1，因为从my_str的索引3到最后，没有hello子串了
index = my_str.find("hello", 3) # -1 
# 查找到第二个hello的位置索引
inde = my_str.find("hello",15) # 16
# rfind() right find() 从右边（后边）开始查找，但是返回的位置索引还是从左边开始算起，
#拿my_str = "hello,world,aaa hello,world"来讲，它会从最有一个world开始找起，但是返回的索引位置仍然是从左边算起的
index = my_str.rfind("hello") # 16 

index()

在字符串中查找是否存在某个字符串
使用方式和find一样，只是index()方法，在找不到子串的时候，会报错。
rindex() 和 rfind()使用也是一样的。

count()

count(sub_str, start, end)
统计子串出现的次数

my_str = "hello,world,aaa hello,world"
# 统计hello出现的次数
print(my_str.count("hello")) # 2

replace 字符串的替换

my_str.replace(old_str, new_str, count) 将my_str中的old_str替换成new_str
old_str: 将要被替换的字符串
new_str: 新的字符串，替换成的字符串
count: 替换的次数，默认是全部替换
返回值：得到一个新的字符串，不会改变原来的字符串

split 字符串的切割

my_str.split(sub_str, count)
将my_str字符串按照sub_str进行切割
sub_str：按照什么内容切割字符串，默认是按空白字符全部切割（空格，tab健）
count: 切割几次，默认是全部切割
返回值：列表 []

# 按照空白字符，全部切割
my_str.split()

join 字符串的连接

my_str.join(可迭代对象)
可迭代对象，字符串，列表（需要列表中的每一个数据都是字符串类型）
将my_str这个字符串添加到可迭代对象的两个元素之间
返回值：一个新的字符串，不会改变原字符串的值

my_str = "hello"
print(";".join(my_str)) # h;e;l;l;o

my_list = ['a', 'b', 'c']
print(";".join(my_list)) #  a;b;c

一些其他的方法

my_str = "hello world"
# 第一个单词首字母大写
print(my_str.capitalize())  # Hello world
# 每一个单词的首字符都大写
print(my_str.title())  # Hello World
# 转成大写
print(my_str.upper())  # HELLO WORLD
# 转成小写
print(my_str.lower())  # hello world
# 以什么开头
print(my_str.startswith("h"))  # True
# 以什么结尾
print(my_str.endswith("e"))  # False
# 居中
print(my_str.center(30))  # '         hello world          '
# 左对齐
print(my_str.ljust(30))  # 'hello world                   '
# 右对齐
print(my_str.rjust(30))  # '                   hello world'
# 去除两端空格
print(my_str.strip())
# 以sub_str切割，输出结果包含sub_str和sub_str前后三部分
print(my_str.partition(" "))  # ('hello', ' ', 'world')
# 按行分隔
print(my_str.splitlines())
# 判断字符串是否都是字母，包含空格也会判断为False
print(my_str.isalpha())  # False
# 判断字符串是否都是数字
print(my_str.isdigit())  # False
# 如果字符串都是字母或者都是数字，则返回true,否则返回false
print(my_str.isalnum())  # False
# 如果字符串只包含空格，则返回True，否则返回False
print(my_str.isspace())  # False