字符串特征

一对引号字符串

  1. name1 = 'Tom'
  2. a = 'I\'m Tom'    # 需加入转义字符
  3. name2 = "Rose"

三引号字符串

  1. name3 = ''' Tom '''
  2. name4 = """ Rose """
  3. a = """ I am    
  4. Tom"""        # 支持回车换行
  • 三引号字符串支持回车换行输出；
  • 若使用单引号进行输出时，遇到字符中包含单引号**'**，需要对其进行转义**\'**。

    字符串输出print()

    ```c

    输出方式1——直接输出

    print(“hello world”)

name = “Tom”

输出方式2——%s格式化输出

print(“我的名字是%s” % name)

输出方式3——f-字符串格式化输出

print(f”我的名字是{name}”)

  1. <a name="rPcGR"></a>
  2. # 字符串输入`input()`
  3. ```c
  4. name = input("请输入你的名字：")    # 返回键盘输入的字符串

下标（索引）

每次只能截取其中的一个数据。

  1. name = "abcdef"
  2. print(name[0])    # a
  3. print(name[3])    # d

切片

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

  1. 序列[开始位置下标:结束位置下标:步长]
  3. 其中：
  4. 1. 切片数据不包含结束位置下标对应的数据，正负整数均可；
  5. 2. 步长是选取间隔，正负整数均可，默认步长是1，语法上为可选项。

切片举例

  1. # 切片语法：序列[开始位置下标:结束位置下标:步长]
  2. str1 = "0123456789"
  4. # 正值测试
  5. print(str1[2:6:1])  # 2345
  6. print(str1[2:6:2])  # 24
  7. print(str1[2:6])    # 2345     不写步长，默认为1
  8. print(str1[:6])     # 012345    不写开始，默认从0开始
  9. print(str1[2:])     # 23456789  不写结束，默认选取到最后
  10. print(str1[:])      # 0123456789 不写开始和结束，默认全部选取，等价于常规print(str)
  12. # 负值测试
  13. print(str1[::-1])        # 9876543210    步长为负，表示倒序（从右向左）选取
  14. print(str1[-2:-1])     # 8            下标为负，表示倒序倒序选取位置
  15. print(str1[:-1])        # 012345678      不写开始，结束为负，表示从0开始向右选取到结束的倒数位置
  16. print(str1[-3:])        # 789            不写结束，开始为负，表示从开始位置往后选取所有数据
  17. # 负下标，正步长
  18. print(str1[-5:-3:1])   # 56         负下标，正步长，表示以倒序的方式找出下标位置后，按从左到右的正方向选取数据
  19. # 负下标，负步长
  20. print(str1[-5:-3:-1])  #         负下标，负步长，由于选取方向和步长方向相反，将无法选取数据

字符串的常用操作方法

查找

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

find()

  1. 字符串序列.find(子串,开始位置下标,结束位置下标)
  3. 其中，开始和结束位置下标可以省略，表示在整个字符串序列中查找。

rfind()

检测某个子串是否包含在这个字符串中。

  • 如果在，返回这个子串开始的位置下标；
  • 否则，返回**-1**。 ```python fo = open(“test.txt”, “r”) fo.seek(2, 0) # 文件指针指向开头偏移2个字节 tempFile1 = fo.readlines() # 按行读取

print(tempFile1) # [‘aaa\n’, ‘bbbbb\n’, ‘ccccc\n’, ‘ddddd’]

fo.close()

  1. <a name="Ijb2X"></a>
  2. ### �`index()`
  3. ```python
  4. 字符串序列.index(子串,开始位置下标,结束位置下标)
  6. 其中，开始和结束位置下标可以省略，表示在整个字符串序列中查找。

检测某个子串是否包含在这个字符串中。

  • 如果在，返回这个子串开始的位置下标；

  • 否则，编译报错。

    rindex()

    和index()功能相同，但查找方向为右侧开始。

  • 如果在，返回这个子串开始的位置下标（从左往右开始计算的下标）；

  • 否则，编译报错。

    count()

    返回某个子串在字符串出现的次数。 ```python 字符串序列.count(子串,开始位置下标,结束位置下标)

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

  1. <a name="zU6pT"></a>
  2. ## 修改
  3. 所谓修改字符串，就是通过**函数的形式修改字符串中的数据**。
  4. <a name="c1Nh0"></a>
  5. ### 替换/分割/合并
  6. <a name="M1PCh"></a>
  7. #### `replace()`
  8. ```python
  9. 字符串序列.replace(旧子串,新子串,替换次数)
  11. 其中：
  12. 1. 替换次数可以省略，表示替换所有的子串；
  13. 2. 如果替换次数超出了子串出现的次数，表示替换所有的子串；
  14. 3. 返回替换后的字符串，不修改原字符串。

数据按照是否能修改分为可变类型和不可变类型。修改字符串类型时，不能改变原有字符串，属于不可变类型。

split()

按照指定字符分割字符串。

  1. 字符串序列.split(分割字符,num)
  3. 其中：
  4. 1. num 表示分隔字符出现的次数，即将来返回数据个数为num + 1个；
  5. 2. 如果分割字符是原有字符串的子串，分割后将丢失分割字符；
  6. 3. 返回数据列表。
  8. 示例：
  9. mystr = "1 and 2 and 3 and 4"
  11. print(mystr.split("and"))   # 返回['1 ', ' 2 ', ' 3 ', ' 4']

join()

用一个字符或子串合并字符串，即：将多个字符串合并为一个新的字符串。

  1. 字符或子串.join(多字符串组成的序列)
  3. 示例：
  4. list = ['1 ', ' 2 ', ' 3 ', ' 4']
  5. tempJoin = "and"
  6. print(tempJoin.join(list))

转换字符大小写

capitalize()

将字符串第一个字符转换成大写。

  1. str1 = "abc def"
  2. print(str1.capitalize())     # Abc def    仅字符串的首字母大写

title()

将字符串每个单词首字母转换成大写。

  1. str1 = "abc def"
  2. print(str1.title())     # Abc Def

lower()

将字符串中所有的大写字符转成小写。

  1. str1 = "ABC DEf"
  2. print(str1.lower())     # abc def

upper()

将字符串中所有的小写字符转成大写。

  1. str1 = "abc deF"
  2. print(str1.upper())     # ABC DEF

删除空白符

lstrip()

删除字符串左侧空白符。

  1. str1 = "   abc def   "
  2. print(str1)           # "   abc def   "
  3. print(str1.lstrip())  # "abc def   "

rstrip()

删除字符串右侧空白符。

  1. str1 = "   abc def   "
  2. print(str1)           # "   abc def   "
  3. print(str1.rstrip())  # "   abc def"

strip()

删除字符串两侧空白符。

  1. str1 = "   abc def   "
  2. print(str1)           # "   abc def   "
  3. print(str1.strip())  # "abc def"

字符串对齐

ljust()

返回一个左对齐，并使用指定字符（默认空格）填充到对应长度的新字符串。

  1. 字符串序列.ljust(长度,填充字符)
  3. 举例：
  4. str1 = "hello"
  5. print(str1)
  6. print(str1.ljust(10, "."))  # "hello....."
  7. print(str1.ljust(10))   # "hello     "

rjust()

返回一个右对齐，并使用指定字符（默认空格）填充到对应长度的新字符串（与**ljust()**类似）。

  1. 字符串序列.rjust(长度,填充字符)
  3. 举例：
  4. str1 = "hello"
  5. print(str1)
  6. print(str1.rjust(10, "."))  # ".....hello"
  7. print(str1.rjust(10))   # "     hello"

center()

返回一个右对齐，并使用指定字符（默认空格）填充到对应长度的新字符串（与**ljust()**类似）。

  1. 字符串序列.center(长度,填充字符)
  3. 举例：
  4. str1 = "hello"
  5. print(str1)
  6. print(str1.center(10, "."))  # "..hello..."
  7. print(str1.center(10))   # "  hello   "

判断

所谓判断，就是判断真假，返回的结果是布尔类型。

判断开头和结尾

startswitch()

检查字符串是否以指定子串开头。是返回True，否则返回False。如果设置开始和结束位置下标，则在指定范围内检查，否则在整个字符串内检查。

  1. 字符串序列.startswitch(子串,开始位置下标,结束位置下标)
  3. 举例：
  4. str1 = "hello world a"
  5. print(str1.startswith("hello"))  # True
  6. print(str1.startswith("he"))  # True
  7. print(str1.startswith("hi"))  # False

endswitch()

检查字符串是否以指定子串结尾。是返回True，否则返回False。如果设置开始和结束位置下标，则在指定范围内检查，否则在整个字符串内检查。

  1. 字符串序列.endswitch(子串,开始位置下标,结束位置下标)
  3. 举例：
  4. str1 = "hello world a"
  5. print(str1.endswith(" a"))  # True
  6. print(str1.endswith("aa"))  # False

isalpha()

检查字符串是否至少有一个字符，且所有字符都是字母，是返回True，否则返回False。

  1. str1 = "woshishui"
  2. str2 = "woshishui?"
  3. str3 = "hahahah2333"
  4. print(str1.isalpha())    # True
  5. print(str2.isalpha())    # False
  6. print(str3.isalpha())    # False

isdigit()

检查字符串是否只包含数字，是返回True，否则返回False。

  1. str1 = "woshishui"
  2. str2 = "2333"
  3. print(str1.isdigit())   # False
  4. print(str2.isdigit())   # True

isalnum()

检查字符串是否至少有一个字符，且所有字符都是字母或数字，是返回True，否则返回False。

  1. str1 = "woshishui"
  2. str2 = "2333a"
  3. str3 = "2333a-"
  4. print(str1.isalnum())   # True
  5. print(str2.isalnum())   # True
  6. print(str3.isalnum())   # False

isspace()

检查字符串是否只包含空格符，是返回True，否则返回False。

  1. str1 = "     "
  2. str2 = "a b c"
  3. print(str1.isspace())   # True
  4. print(str2.isspace())   # False