python数据类型之【字符串】、常用方法、拆分字符串split( )、删除首尾指定字符strip( )、对字符串（还有列表、元组）求逆、判断是否为回文字符串、字符串的切片。

注意：

1、字符串一旦定义就不能修改，但是可以用replace去替换，相当于变相的进行了修改。

一、字符串——str

所谓字符串，其实就是一串字符，在编程语言中用来表示文本的一种数据类型。

在Python中定义一个字符串可以使用一对单引号或一对双引号。

需要注意的是，如果字符串里面的字符本身就带引号（单引号/双引号），那么我们在定义的时候需要特别注意下，该用什么引号。

比如：

字符串中如果不包含引号，那么字符串用单引号、双引号都可以。

字符串中如果包含单引号，那么字符串就用双引号引起来。

字符串中如果包含双引号，那么字符串就用单引号引起来。

如果字符串同时包含单引号、双引号，那就只能用转义字符来实现。

例如：分别定义两个字符串，字符串内容分别为：甲'乙'丙 、甲"乙"丙

# 法1 既然里面是单引号，那么外面就用双引号，反之亦然
str1 = "甲'乙'丙"   # 内单，外双
str2 = '甲"乙"丙'  # 内双，外单
print(str1)
print(str2)      # ————推荐
结果：
甲'乙'丙
甲"乙"丙


# 法2使用转义字符
str1 = '甲\'乙\'丙'    # 使用转义字符 \'  结果输出单引号
str2 = "甲\"乙\"丙"     # 使用转义字符 \"  结果输出双引号
print(str1)
print(str2)
结果：
甲'乙'丙
甲"乙"丙

例如：同时包含两种引号，甲"乙'丙，那就只能用\来进行转义了。

str1 = "甲\"乙'丙"     #  或写成str1 = "甲\"乙\'丙"也可以
print(str1)             #因为外面双引号，里面单引号不影响
结果：
甲"乙'丙

str1 = "甲\"乙'丙"     # \" 通过反斜杠来进行转义
print(str1)
结果：
甲"乙'丙

二、字符串的常用方法

字符串所有方法：

print(dir(str))
结果：
['__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、查看和查找

总的来说，查看就是通过下标去获取值，而查找就是通过值去获取位置下标。

查看：通过字符串[索引]的方式访问（得到）字符串中指定位置的字符。也就是说，只能得到指定位置上的字符，但不能修改指定位置上的字符。即：字符串不能通过下标去修改，但是可以读取。

str1 = "我爱你中国！"
print(str1[0])  # 获取第一个字符，即：下标为0
print(str1[-1])   # 获取最后一个字符，下标为-1
结果：
我
！

查找：——find( )、index( )

find( )和index( )都是查找字符的下标，区别是，如果没找到这个字符，find就返回-1，而index就会报错。

（1）find(要查找的字符，开始查找的位置)——查找指定字符，找到就返回该字符的索引值，找不到就返回-1 。

str1 = "我爱你中国！"
print(str1.find("你"))  # 查找 你
结果：
2   # 返回找到后的索引


str1 = "我爱你中国！"
print(str1.find("hello"))   # 查找hello
结果：
-1       # 没找到就返回-1

（2）index(要查找的字符，开始查找的位置)——查找指定字符，找到就返回该字符的索引值，找不到就报错。

#查找 你，找到了返回你这个字符所在下标
str1 = "我爱你中国！"
print(str1.index("你"))
结果：
2


#查找hello这个字符串，没找到就报错
str1 = "我爱你中国！"
print(str1.index("hello"))
结果：
    print(str1.index("hello"))
ValueError: substring not found

for遍历字符串

str1 = "我爱你中国！"
for i in str1:
    print(i)
结果：
我
爱
你
中
国
！



str1 = "我爱你中国！"
for i in str1:
    print(i, end="")
结果：
我爱你中国！

2、判断类相关操作

详见：字符串判断类操作

isalpha( )——是纯字母或汉字吗？是返回True，不是返回False

isdigit( )——是纯数字吗？

islower( )——所有字母都是小写吗？

isupper( )——所有字母都是大写吗？

str1 = "你好word"  # 汉字+字母
str2 = "你好word123"   # 汉字+字母+数字
str3 = "a?,._"   # 字母+特殊字符
print(str1.isalpha())  # 判断字符串是纯字母（或汉字）吗？
print(str2.isalpha())
print(str3.isalpha())
结果：
True
False
False

3、替换——replace( )

格式：字符串名.replace("换谁"，"换成什么"，替换几个)

str1 = "你好word 你好word123 你好word"
print(str1.replace("你好", "hello"))   # 不写替换几个，那就默认全部替换掉
结果：
helloword helloword123 helloword

str1 = "你好word 你好word123 你好word"
print(str1.replace("你好", "hello", 2))  # 指定替换两个
结果：
helloword helloword123 你好word

4、count( )——统计字符串出现的次数

str1 = "你好word 你好word123 你好word"
print(str1.count("123"))
结果：
1

5、去除首尾处指定字符、去除左右两端指定字符——strip( )、lstrip( )、rstrip()

情景1：strip( )、lstrip( )、rstrip()里面啥都不写，那就默认去除空白符，比如\n、\r、\t

str1 = "  asd   "  
print("'%s'" % str1)  # 为了更明显的看到效果，用格式化输出结果，
str2 = str1.strip()     # 即：在结果的外面加上一对引号，更能看到字符长短情况
print("'%s'" % str2)
结果：
'  asd   '  #可以明显的看到左右两边空格都么了
'asd'

str1 = "  asd   "
print("'%s'" % str1)
str3 = str1.lstrip()  # 去掉左边空格
str4 = str1.rstrip()   # 去掉右边空格
print("'%s'" % str3)
print("'%s'" % str4)
结果：
'  asd   '
'asd   '
'  asd'


str1 = " \t \r asd \n  "
str2 = str1.strip()
print("'%s'" % str2)
结果：
'asd'

情景2：strip( )、lstrip( )、rstrip( )里面写上字符，那就代表删除左右两边指定的字符。

str1 = "a niceday"
print("'%s'" % str1) 
str2 = str1.strip("ay")  # 去掉两边的a字符和y字符
print("'%s'" % str2)
结果：
'a niceday'
' niced'    # 左边么了a，右边么了ay



str1 = "a niceday"
print("'%s'" % str1) 
str3 = str1.lstrip("ay")   # 去左边的a字符和y字符
print("'%s'" % str3)
结果：
'a niceday'
' niceday'   # 左边只要a没y，所有就把有的去了

str1 = "a niceday"
print("'%s'" % str1) 
str4 = str1.rstrip("ay")   # 去掉右边的字符ay
print("'%s'" % str4)
结果：
'a niceday'
'a niced'     # 右边的ay都没了

6、拆分字符串——split( )

根据指定字符，对字符串进行切割，还可以指定切割次数，默认全部切割。切割后的结果放到一个列表里。

格式：

字符串名.split( )——啥都不写，表示按空格去拆分

字符串名.split(值)——按这个值去拆分，全部拆分

字符串名.split(值，n)——按这个值去拆分，拆分n个（次）

str1 = "hello word !"
print(str1.split())   # 根据空格去拆分
结果：
['hello', 'word', '!']

str1 = "hello word ! haha"
print(str1.split("h"))   # 根据字符h来进行切割，默认全部切割
结果：                 # 根据谁切割，就对着那个字符切下去，那个字符就么了
['', 'ello word ! ', 'a', 'a']


str1 = "hello word ! haha"

print(str1.split("h", 1))  # 根据字符h来进行切割，切割一次
结果：
['', 'ello word ! haha']    # 可以看到，后面的h都还在

练习1：计算字符串中每个字符相加的和。

#法1——推荐
str1 = "123ab 45abcd"
sum = 0
for i in str1:
    if i.isdigit():   
        sum += int(i)
print(sum)
结果：
15


#法2
str1 = "123 45"
sum = 0
for i in str1:
    if i != str(" "):   # 求1+2+3+4+5的和
        sum += int(i)
print(sum)
结果：
15

str1 = "123 45"
list1 = str1.split()
sum = 0
for i in list1:  
    sum += int(i)   # 求123+45的和
print(sum)
结果：
168

！！！前方高能~~

练习：输入一个字符串，在这个字符串中，如果是数字就相加，如果是字母或汉字就拼接，如果是其它类型的字符就存到列表里。

str1 = input("请输入字符串：")
s = ""  # 定义一个空字符串用来存放字母和汉字
list1 = []  # 定义一个空列表用来存放，其它符号
sum = 0
for i in str1:    
    if i.isdigit():    # 这里不用写成if i.isdigit()==True
        sum += int(i) # 如果是数字就相加
    elif i.isalpha():  # 如果是字母和文字就拼接
        s += i
    else:  # 如果是其它符号的话就添加到列表里
        list1.append(i)
print("该字符串中,所有数字相加的和是：%d" % sum)
print("该字符串中,所有字母和汉字拼接的结果是：%s" % s)
print("该字符串中,非数字非字母的有：%s" % list1)
结果：
请输入字符串：￥1a2b* 中国&.5
该字符串中,所有数字相加的和是：8
该字符串中,所有字母和汉字拼接的结果是：ab中国
该字符串中,非数字非字母的有：['￥', '*', ' ', '&', '.']

注意：

在上面代码中，有一行需要注意下：

if i.isdigit():  这里不用写成if i.isdigit()==True：
因为能够执行if语句，说明if后面的条件是满足了，所以才能执行，而条件满足也就是说条件为True。所以如果这里写成，if i.isdigit()==True：的话没问题，不报错，但会显得代码很冗余。

即：当一个函数或者方法，如果返回值就是True或者False，那么它在if后面作为条件时，只写方法名就好了，不用再写方法名==True。

例如：说明if后面条件为True的例子。

a = 2
b = 1
if a > b:
    print(a)
else:
    print(b)
结果：
2

上述代码就是说，如果a>b，那就打印a，否则打印b。结果打印的是2说明输出的是a，也就是说执行的是if a>b，也就是说a>b，结果为True，所以可以得到这样一个结论：如果要执行if语句，那么if后面的条件必须为真（True）。

练习2：去掉字符串里的空格。————replace( )的使用

str1 = "    day     day up   "
print(str1.replace(" ", ""))  # 把"空格"  替换成""
结果：
daydayup

7、格式化字符串

格式化字符，我们平时见的最多的就是把它放到print函数里面去，然后打印出来。但其实，我们也可以把格式化字符串的结果放到一个变量里面去，让它去作为这个变量的值。

例如：把这个格式化字符串的结果放到str1这个变量里面去，此时，str1的值就是这个格式化后的结果。

str1 = "今天是%d年%d月%d号" % (2022, 11, 25)
print(str1)
结果:
今天是2022年11月25号

常用的详见：格式化字符

再补充点：

%——被称为格式化操作符，专门用来处理字符串中的格式。

格式化字符串——就是说，包含%的字符串就叫格式化字符串。

%s——字符串

%d——十进制整数，比如，%03d表示输出3位整数，不足左边用0补全

%x——十六进制整数，把一个十进制的数按照十六进制方式显示。这里是小写的x，表示abcdef用小写。%03x表示输出3位整数，不足左边用0补全

%X——这里是大写的X，表示ABCDEF用大写。

print("%x" % 10)
print("%X" % 10)
结果：
a
A

十六进制： 0 1 2 3 4 5 6 7 8 9  a   b   c   d  e    f  10 11...

表示十进制0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 ....

print("%x" % 14)   # 十进制的14就是十六进制的e
print("%x" % 15)
print("%x" % 16)
print("%x" % 17)   # 十进制的17就是十六进制的11
结果：
e
f
10
11

8、字符串的切片

只要可以使用索引访问成员，那么这种数据类型的数据就可以使用切片。比如：字符串、元组、列表。

切片使用开始索引和结束索引来限定范围，目的是从一个大是字符串中切出来小的字符串。

语法：

字符串[开始索引：结束索引：步长]——左闭右开，即开始索引的值能取到，结束索引的值取不到。

需要注意的是：

（1）如果从头开始取，那么开始索引的数字可以不写，但冒号得写。——省略开始索引，意味着默认从0开始。

（2）如果取到末尾（或叫到末尾结束），那么结束索引可以不写，但冒号得写。——省略结束索引，默认取到最后。

（3）默认步长为1，可以不写。

（4）索引不仅支持正序的索引，还支持倒序的，所谓倒序索引就是从右向左进行编号，最右边的索引值是-1，依次递减。具体如下：以字符串str1 = "hello word"为例进行说明。

 练习：切片举例。

str1 = "hello word"
print(str1[-1])
结果：
d

#取整个字符串
str1 = "hello word"
print(str1[:])
结果：
hello word


#截取2~6位置上的字符串
str1 = "hello word"
print(str1[2:7])
结果：
llo w

#截取1~末尾的字符串
str1 = "hello word"
print(str1[1:])
结果：
ello word

# 截取从开始到2位置上的字符串
str1 = "hello word"
print(str1[:3])
结果:
hel

 例如：获取所有奇数位、偶数位上的字符。

# 从开始位置一直到最后，每隔一个字符截取字符串。
str1 = "hello word"   
print(str1[::2])    # 换句话说，获取所有偶数位上的字符
结果：
hlowr



#获取所有奇数位上的字符
str1 = "hello word"
print(str1[1::2])
结果：
el od

str1 = "hello word"
print(str1[1：：2])
结果：
el od

注意奇数、偶数开始的索引是多少，奇数是1，3，5，7....索引，开始索引是1，而偶数是0，2，4，6....所以开始索引是从0开始，而0又可以不写。

练习：截取从1到-3的字符串。

str1 = "hello word"
print(str1[1:-2])
结果：
ello wo

练习：截取字符串末尾三个字符。

str1 = "hello word"
print(str1[-3:])
结果：
ord

9、字符串的逆序——字符串求逆

str1 = "abcde"
print(str1[::-1])
结果：
edcba

练习：判断字符串是否是回文字符串。

str1 = input("请输入一个字符串：")
if str1 == str1[::-1]:
    print("字符串%s是回文" % str1)
else:
    print("字符串%s不是回文" % str1)
结果：
请输入一个字符串：abcba
字符串abcba是回文


请输入一个字符串：abcd
字符串abcd不是回文

请输入一个字符串：你好你
字符串你好你是回文

请输入一个字符串：123六321
字符串123六321是回文

练习：把列表逆序，列表中的每个成员也逆序。

#法1：把最终的求逆结果放到一个新列表里。
list1 = ["张三", "李四", "王五"]
list2 = list1[::-1]   # 列表求逆
print(list2)
list3 = []
for i in list2:  #遍历求逆后的列表，并把每次遍历出来的成员求逆，追加到list3里
    list3.append(i[::-1])   # i[::-1] 就是把成员中的字符逆序
print(list3)
结果：
['王五', '李四', '张三']
['五王', '四李', '三张']


#法2：把结果放到list1里。
list1 = ["张三", "李四", "王五"]
list1 = list1[::-1]  # 把列表逆置
index = 0   # 定义一个索引变量
for n in list1:
    str1 = n[::-1]  # 对每次遍历的成员求逆
    list1[index] = str1   # 通过index变量的变化
    index += 1            #  来修改list1列表中该索引位置上的值   列表名[索引]=值，意思是修改该位置上的值
print(list1)
结果：
['五王', '四李', '三张']

小结：由上题可知，索引既可以是一个数字，也可以是一个变量。

10、多维列表

所谓多维列表就是说，列表的成员，又是一个列表。

例如：

list1 = [12, ["水果", "蔬菜"]]
print(list1[1][1])
结果：
蔬菜


print(list1[1][0])
结果：
水果


print(list1[0])
结果：
12

解析：list1是一个二维列表，有两个成员。

第一个成员是：12

第二个成员是一个列表["水果", "蔬菜"] 。

列表索引默认从0开始，所以list1[1]就是取索引为1的元素，也就是["水果", "蔬菜"]，而后面的[1]就是再从["水果", "蔬菜"]这个列表中取索引为1的元素，最终得到了蔬菜。