【python 基础篇 四】python的常用数据类型操作-------字符串

1.字符串的基本概念

概念：由单个字符组成的一个集合

1.1 字符串的形式

1. 非原始字符串
   • 使用单引号包含 ‘abc’
   • 使用双引号包含"abc"
   • 使用3个单引号’‘’ abc ‘’’
   • 使用3个双引号"“” abc “”"
2. 原始字符串
   • 使用单引号包含 r’abc’
   • 使用双引号包含 r"abc"
   • 使用3个单引号 r’‘’ abc ‘’’
   • 使用3个双引号 r"“” abc “”"
3. 转义字符
   • 概念：通过转换某个指定字符，使它具备特殊的含义
   • 常见转义字符
     • \ 连行符
     • \ ’ 单引号
     • \ " 双引号
     • \ n 换行
     • \ t 横向制表

str = "abcsd"
print(str)# 输出abcsd

str = "ab\tcsd"
print(str)# 输出ab  csd

str = "ab\ncsd"
print(str)# 输出ab 换行csd

str = "ab\"csd"
print(str)# 输出ab"csd

str = r"ab\tcsd"
print(str)# 输出ab\tcsd

str = r"ab\t \ncsd"
print(str)# 输出ab\t \ncsd

注意：原始字符串中转义字符不能生效，只有在非原始字符串中才可以生效

1.2 各个形式的特点

1. 单/双引号
   • 混合使用可以避免使用引号转义字符
   • 一般内容需要写出一行，如果要跨行需要连行符
2. 三引号
   • 可以直接跨行书写
   • 可用于注释

#混合使用可以避免使用引号转义字符
#要输出 我是 "sz"
name = "我是\"sz\""  #方法一
print(name)#输出 我是 "sz"
name1 = '我是"sz"'   #方法二
print(name1)#输出 我是 "sz"

#一般内容需要写出一行，如果要跨行需要连行符
name = "我是 \   #方法一
		sz"
print(name)#输出 我是sz
name1 = ("我是"    #方法二
		"sz")
print(name1)#输出 我是sz

#三引号 直接跨行书写
name1 = """我是
123
sz"""
print(name1)
#三引号 用于注释
"""
输出:
我是
123
sz
"""

2.字符串一般操作

2.1 字符串拼接

1. str1+str2
2. “xxx” “xxx”
3. “xxx%s”% “xxx”
4. 字符串乘法 “abc” *3 = “abcabcabc”

str1 = "abc"
str2 = "vdf"
print(str1+str2)#输出 abcvdf
print("abc""vdf")#输出 abcvdf
print("abc%s"%"vdf")#输出 abcvdf
print("abc"*3)#输出 abcabcabc

2.2 字符串切片

1. 概念：获取一个字符串的某个片段
2. 获取某一个字符
   • str[下标] 如果下标为负则从尾部开始 最后一个字符为-1
   • 注意：要防止下标越界
3. 获取一个字符片段
   • str[起始：结束：步长]
   • 注意：
     • 获取范围 [起始，结束) 起始包含 结束不包含
     • 默认值 起始值默认为0 结束值默认字符串的长度 步长默认为1
     • 获取顺序 步长 > 0 从左边到右 步长 < 0 从右往左。注意：不能从头部跳到尾部或者从尾部调到头部

#获取某一个字符  
str1 = "abcoioennx"
print(str1[0])#输出 a
print(str1[5])#输出 o
print(str1[-1])#输出 x

#获取一个字符片段
str1 = "abcoioennx"
print(str1[::])#输出 abcoioennx
print(str1[0:2])#输出ab
print(str1[3:8])#输出oioen
print(str1[3:8:2])#输出oon
print(str1[::-1])#输出 xnneoiocba

3.字符串的函数操作

3.1 字符串的查找计算

• len() 内置函数
  • 作用：计算字符串的字符个数
  • 语法：len(str) 返回值：整型
• find()
  • 作用：查找子串索引(下标)位置
  • 语法：find(sub,start=0,end=len(str))
    • sub----需要检索的字符串
    • start----检索的开始位置 可以省略 默认值为0
    • end -----检索的结束位置 可以省略 默认值为len(str)
    • 返回值 找到返回下标 找不到返回-1
• rfind()
  • 作用和语法：与find相同
  • 区别：从右向左进行查找
• index()
  • 作用：获取子串索引位置
  • 语法：index(sub,start=0,end=len(str))
    • sub----需要检索的字符串
    • start----检索的开始位置 可以省略 默认值为0
    • end -----检索的结束位置 可以省略 默认值为len(str)
  • 它的作用和find作用大致相同 区别是在返回值不同
  • 返回值 找到返回下标 找不到报异常
  • 注意：从左到右进行查找，找到后立即停止
• rindex()
  • 作用和语法：与index相同
  • 区别：从右向左进行查找
• count()
  • 作用：计算某个字符串的出现个数
  • 语法：count(sub,start=0,end=len(str))
    • sub----需要检索的字符串
    • start----检索的开始位置 可以省略 默认值为0
    • end -----检索的结束位置 可以省略 默认值为len(str)
    • 返回值 字符串出现个数

#len()
str1 = "abcoioennx"
str2 = "我是MT\n"
print(len(str1))#输出为10
print(len(str2))#输出为5 转义字符也当做一个字符

#find
str1 = "abcoioennx"
print(str1.find("e"))#输出为6
print(str1.find("ennx"))#输出为6
print(str1.find("enox"))#输出为-1

#index
str1 = "abcoioennx"
print(str1.index("e"))#输出为6
print(str1.index("ennx"))#输出为6
print(str1.index("enox"))#输出 报错

#count
str1 = "abcoioennx"
print(str1.count("e"))#输出为1
print(str1.count("o"))#输出为2
print(str1.count("ennx"))#输出为1
print(str1.count("enox"))#输出为0

3.2 字符串的转换

• replace()
  • 作用：使用给定的新字符串，替换原字符串中的 旧字符串
  • 语法：replace(old,new,count)
    • old 需要被替换的旧字符串
    • new 替换后的新字符串
    • count 指定替换个数 可以省略 代表范围在全部
    • 返回值：替换后的字符串，并不会改变原来字符串本身
• capitalize()
  • 作用：将字符串首字母变为大写
  • 语法：capitalize()
    • 返回值：改变后的字符串，并不会改变原来字符串本身
• title()
  • 作用：将字符串每个单词的首字母变为大写
  • 语法：title()
    • 返回值：改变后的字符串，并不会改变原来字符串本身
• lower()
  • 作用：将字符串每个字符都变为小写
  • 语法：lower()
    • 返回值：改变后的字符串，并不会改变原来字符串本身
• upper()
  • 作用：将字符串每个字符都变为大写
  • 语法：upper()
    • 返回值：改变后的字符串，并不会改变原来字符串本身

#replace()
str1 = "abcoioennx"
print(str1.replace("o","s"))#输出为abcsisennx
print(str1.replace("o","s",1))#输出为abcsioennx  这个1代表只换一个字符
print(str1)#输出为abcoioennx  不会改变字原来的字符串

#capitalize
str1 = "abcoioennx"
print(str1.capitalize())#输出为Abcoioennx

#title
str1 = "abcoioennx"
str2 = "hello world"
print(str1.title())#输出为Abcoioennx
print(str2.title())#输出为Hello World

#lower
str1 = "ABCDRioennx"
str2 = "hello world"
print(str1.lower())#输出为abcdrioennx
print(str2.lower())#输出为hello world

#upper
str1 = "ABCDRioennx"
str2 = "hello world"
print(str1.upper())#输出为ABCDRIOENNX
print(str2.upper())#输出为HELLO WORLD

3.3 字符串的填充压缩

• ljust()
  • 作用：根据指定字符(1个),，将原来字符串填充够指定长度，原字符串靠左，填充靠右
  • 语法：ljust(width,fillchar)
    • width 指定最后字符串长度
    • fillchar 如果原字符串 < 指定字符串 填充的字符
    • 返回值：填充完毕的字符串，不会修改原来的值，填充字符的长度为1，只有原字符串<指定结果长度时才会填充。
• rjust()
  • 作用：与 ljust一模一样
  • 区别：原字符串靠左，填充靠右
• center()
  • 作用：根据指定字符(1个),，将原来字符串填充够指定长度，原字符串居中
  • 语法：center(width,fillchar)
    • width 指定最后字符串长度
    • fillchar 如果原字符串 < 指定字符串 填充的字符
    • 返回值：填充完毕的字符串，不会修改原来的值，填充字符的长度为1，只有原字符串<指定结果长度时才会填充。
• lstrip()
  • 作用：移除所有原字符串指定字符（默认为空白字符），从左侧开始删除
  • 语法：lstrip(chars)
    • chars 需要移除的字符集，表现形式为字符串 “ abc ” = " a | b | c "
    • 返回值：填充完毕的字符串，不会修改原来的值。
    • 注意：最开始没有找到就不会删除
• rstrip()
  • 作用：同上
  • 区别 ，从左侧开始删除

#ljust()
str1 = "abcox"
print(str1.ljust(10,"s"))#输出为abcoxsssss
str2 = "abcofx"
print(str2.ljust(4,"s"))#输出为abcofx 没有填充

#rjust()
str1 = "abcox"
print(str1.rjust(10,"s"))#输出为 sssssabcox
str2 = "abcofx"
print(str2.rjust(4,"s"))#输出为 abcofx

#center()
str1 = "abcox"
print(str1.center(10,"s"))#输出为ssabcoxsss
str2 = "abcofx"
print(str2.center(4,"s"))#输出为abcofx

#lstrip()
str1 = "abcox"
print(str1.lstrip("x"))#输出为abcox 因为从左侧最开始没有找到就停止了
str2 = "abcofx"
print(str2.lstrip("abc"))#输出为ofx
str3 = "aaabcofx"
print(str3.lstrip("abo"))#输出为cofx 可以连续删除相同的，但是不能隔一个删除


#rstrip()
str1 = "abcox"
print(str1.lstrip("x"))#输出为abco
str2 = "abcofx"
print(str2.lstrip("xo"))#输出为abcof
str3 = "aaabcofxxx"
print(str3.lstrip("xfo"))#输出为aaabc

3.4 字符串的分割拼接

• split()
  • 作用：根据分隔符将一个大的字符串分割成几个小字符串
  • 语法：split(sep,maxsplit)
    • sep 分割符
    • maxsplit 最大分割次数 可以省略(有多少分割多少)
    • 返回值：分割后的字符串，组成的列表 list列表 类型 ，不会修改原来的值。
• partition()
  • 作用：根据分隔符将一个大的字符串分割成两个小字符串[分隔符左侧，分隔符，分隔符右侧]
  • 语法：partition(sep)
    • sep 分割符
    • 返回值：如果查找到分隔符返回 (分隔符左侧，分隔符，分隔符右侧)tuole类型，如果没有找到分隔符返回（分隔符，“”，“”）tuole类型
• rpartition()
  • 作用：同上
  • 区别：从右向左
• splitlines()
  • 作用：把换行符(/r /n)当做分隔符，把字符串拆开 \r是空格 \n是换行
  • 语法：splitlines(keepends)
    • keepends 是否保留换行符 bool类型
    • 返回值：被换行符分割的多个字符串，作为元素组成的列表 list类型 不会改变原类型
• join()
  • 作用：根据指定字符串，将给定的可迭代对象，进行拼接，得到拼接后的字符串
  • 语法：join(iterable)
    • iterable 可迭代参数 字符串 元组 列表等可遍历的
    • 返回值：拼接好的字符串

#split()
str1 = "sz-18-186-0588-22545"
print(str1.split("-"))#输出为['sz', '18', '186', '0588', '22545']
str2 = "lz-28-186-0588-22545"
print(str2.split("-",3))#输出为['lz', '28', '186', '0588-22545']

#partition()
str1 = "sz-18-186-0588-22545"
print(str1.partition("-"))#输出为('sz', '-', '18-186-0588-22545')
str2 = "lz28186"
print(str2.partition("-"))#输出为('lz28186', '', '')

#rpartition()
str1 = "sz-18-186-0588-22545"
print(str1.rpartition("-"))#输出为('sz-18-186-0588', '-', '22545')
str2 = "lz28186"
print(str2.rpartition("-"))#输出为('', '', 'lz28186')

#splitlines()
str1 = "sz 18\n186-058"
print(str1.splitlines(1))#输出为['sz 18\n', '186-058']
str2 = "lz\n28 186"
print(str2.splitlines(0))#输出为['lz', '28 186']

#join()
items = ["sz","18","shanghai"]
str1 = "-"
print(str1.join(items))#输出为sz-18-shanghai
str2 = "lz28186"
print(str1.join(str2))#输出为l-z-2-8-1-8-6

3.5 字符串的判定

• isalpha()
  • 作用：判断当前字符串是否所有字符都是字母 就是不包含数字，特殊符号，标点符号等
  • 语法 ：isalpha()
• isdigit()
  • 作用：判断当前字符串是否所有字符都是数字 就是不包含字母，特殊符号，标点符号等
  • 语法 ：isdigit()
• isalnum()
  • 作用：判断当前字符串是否所有字符都是数字或字符 就是不包含特殊符号，标点符号等
  • 语法 ：isdigit()
• isspace()
  • 作用：判断当前字符串是否所有字符都是空白符 就是包含空格，缩进，换行等不可见的转义字符等
  • 语法 ：isdigit()
• startswith()
  • 作用：判断当前字符串是否以某个前缀开头
  • 语法 ：startswith(prefix，start=0，end=len(str))
    • prefix 需要判定的前缀字符
    • start：判断的开始位置
    • end：判断的结束位置
• endswith()
  • 作用：和上面相反
• in
  • 作用：判断一个字符串，是否被另一个字符串包含
  • 用法：print(“xxx” in “xxx”)
• not in
  • 作用：判断一个字符串，是否不被另一个字符串包含
  • 用法：print(“xxx” not in “xxx”)

#isalpha()
str1 = "lz28186"
str2 = " "
str3 = "lszx"
print(str1.isalpha())#输出为False
print(str2.isalpha())#输出为False
print(str3.isalpha())#输出为True

#isdigit()
str1 = "lz28186"
str2 = " \n"
str3 = "4552"
print(str1.isdigit())#输出为False
print(str2.isdigit())#输出为False
print(str3.isdigit())#输出为True

#isalnum()
str1 = "lz28186"
str2 = " \n"
str3 = "4552"
print(str1.isalnum())#输出为True
print(str2.isalnum())#输出为False
print(str3.isalnum())#输出为True

#isspace()
str1 = "lz28186"
str2 = " \n"
str3 = "4552\t"
print(str1.isspace())#输出为False
print(str2.isspace())#输出为True
print(str3.isspace())#输出为False

#startswith()
str1 = "lz28186"
str2 = " \n"
str3 = "4552\t"
print(str1.startswith("lz"))#输出为True
print(str1.startswith("2",2,))#输出为True
print(str2.startswith(" "))#输出为True
print(str3.startswith("s"))#输出为False

#in   not in
print("az" in "azfs sn ivm")#输出为True
print("a z" in "azfs sn ivm")#输出为False
print(" " in "ahsi alx nf")#输出为True
print("az" not in "a x sf ")#输出为True
print("az" not in "az sfc w ")#输出为False