一、字符串

  • 字符串定义
  • 字符串下标
  • 字符串切片
  • 字符串常用方法查找方法
    替换方法
    判断方法

二、字符串实操



1、字符串定义

"""
字符串
1、字符串是python中最常用的数据类型，是不可变类型
2、一般用引号来创建字符串，可用单引号、双引号、三引号
  （三引号形式的字符串支持换行，即多行字符串）
"""

# 单引号
str1 = 'hello'
str2 = 'I\'m TOM'  # 字段串中间出现单引号，要用反斜杠转义
print(f'单引号：{str1}, {str2}')
print(type(str1), type(str2))

# 双引号
str1 = "hello wold"
str2 = "I'm Tina"
str3 = "I'm " \
       "Tina"  # 代码中换行，输出不换行
print(f'双引号：{str1}, {str2}, {str3}')
print(type(str1), type(str2), type(str3))

# 三引号(支持换行输出)
str1 = ''' I\'m Jack,
                     nice to meet you!
       '''
str2 = """ I'm Rose,
                     nice to meet you,too!
       """
print(f'三引号：{str1}, {str2}')
print(type(str1), type(str2))

out:

单引号：hello, I'm TOM
<class 'str'> <class 'str'>
双引号：hello wold, I'm Tina, I'm Tina
<class 'str'> <class 'str'> <class 'str'>
三引号： I'm Jack,
                     nice to meet you!
       ,  I'm Rose,
                     nice to meet you,too!



2、字符串下标

又称索引，通过下标能快速找到相应的存储空间（python中下标从0开始）

# 下标
# 语法： 字符串[下标]
str1 = "Hello,Tina"
print(str1[0])  # H
print(str1[6])  # T
print(str1[7])  # i



3、字符串切片

切片是指对操作的序列截取其中⼀部分的操作

'''
# 切片
1、语法：序列[开始位置下标:结束位置下标:步⻓]
2、注意: (1) 步长为选取间隔，正负整数均可，不填则默认步长为1
        (2) 左闭右开（不包含结束位置下标的数据），正负整数均可
'''
str1 = '0123456789'
print(str1[0: 4: 1])  # 0123
print(str1[0: 4: 2])  # 02  选取间隔为2
print(str1[-2: -6: -1])  # 8765 倒数第2个到倒数第6个（不含第6个数）
print(str1[-2: -6: 1])  # 无输出，选取方向与步长方向不一致，则无法输出相应数据（从-2到-6是从右往左，步长1代表从左往右选取，方向相反）



4、字符串常用操作方法

4.1、查找

查找方法

描述

语法

find():

检测某个子串是否包含在这个字符串中，如果在，返回子串开始位置下标，否则返回-1。

字符串序列.find(子串, 开始位置下标, 结束位置下标)

index():

检测某个子串是否包含在这个字符串中，如果在，返回子串开始位置下标，否则抛出异常。

字符串序列.index(子串, 开始位置下标, 结束位置下标)

rfind():

功能同find，但是查找方向是从右边开始。

字符串序列.rfind(子串, 开始位置下标, 结束位置下标)

rindex():

功能同index，但是查找方向是从右边开始。

字符串序列.rindex(子串, 开始位置下标, 结束位置下标)

count():

计算子串在字符串中出现的总次数。

字符串序列.count(⼦串, 开始位置下标, 结束位置下标)

（1）查找子串在字符串中的位置

find() 

# find()
# 语法：字符串序列.find(子串，开始位置下标，结束位置下标)
str1 = 'I like apple and orange and strawberry and banana.'

# 若字符串序列中有多个目标子串，返回第一个子串的开始下标
print(str1.find('and'))  # 13

# 若字符串序列中未查询到目标子串，返回-1
print(str1.find('and', 16, 20))  # -1 --范围内没找到

print(str1.find('and', 16, 30))  # 24
print(str1.find('and', 30))  # 39

# 下标不支持负整数
print(str1.find('and', -1, -30))  # -1

rfind() 

# rfind()
print(str1.rfind('and'))  # 39
#  从右边开始16位到24位
print(str1.rfind('and', 16, 30))  # 24

index() 

# index()
# 语法：字符串序列.index(子串，开始位置下标，结束位置下标)
str1 = 'I like apple and orange and strawberry and banana.'
print(str1.index('and'))  # 13
print(str1.index('and', 20, 30))  # 24

# 找不到数据抛出异常
print(str1.index('and', 16, 20))  # 异常

rindex() 

# rindex()
print(str1.rindex('and'))  # 39

（2）查找子串在字符串中的个数

count() 

# count()
# 字符串序列.count(子串,开始位置下标，结束位置下标)
str1 = 'I like apple and orange and strawberry and banana.'

print(str1.count('and'))  # 3
print(str1.count('ands'))  # 0
print(str1.count('and', 10, 30))  # 2

4.2、修改

修改字符串，指的就是通过函数的形式修改字符串中的数据。

(1) 替换、分割、合并

replace()：替换 

'''
replace()
语法：字符串序列.replace(旧子串,新子串，替换次数)
如果不填写替换次数，默认旧子串无论在字符串中出现几次，都全部替换
''' 

str1 = 'I like apple and orange and strawberry and banana.'
str2 = str1.replace('and', 'he')
print(str2)  

# 指定替换次数
str2 = str1.replace('and', 'he', 1)
print(str2)

注意：
数据按照是否能直接修改分为可变类型和不可变类型两种。字符串类型的数据修改的时候，不能改变原有字符串，属于不能直接修改数据的类型即是不可变类型。

split()：按照指定字符分割字符串 

''''
split()
语法：字符串序列.split(分割字符,num)
num表分割字符出现的次数
'''
str1 = 'I like apple and orange and strawberry and banana.'
print(str1.split('and'))
print(str1.split('and', 2))

注意：如果分割字符是原有字符串中的⼦串，分割后则丢失该⼦串。

join()：字符串合并 

'''
# join()
# 语法：字符或⼦串.join(多字符串组成的序列)

# 字符或⼦串会插入到序列当中每个元素的后面，组成一个新的字符串
'''
str1 = '..?'
str2 = 'abcde'
str3 = str1.join(str2)
print(str3)  # a..?b..?c..?d..?e

（2）大小写转换

capitalize()：仅字符串首字母大写 

# capitalize()
str1 = 'i like apple and orange and strawberry and banana.'
print(str1.capitalize())

out:

I like apple and orange and strawberry and banana.

title()：字符串中每个单词首字母大写 

# title()
print(str1.title())

out:

I Like Apple And Orange And Strawberry And Banana.

upper()：字符串中小写字母全部转换成大写 

# upper()
print(str1.upper())

out:

I LIKE APPLE AND ORANGE AND STRAWBERRY AND BANANA.

lower()：字符串中大写字母全部转换成小写 

# lower()
str1 = 'ABCD'
print(str1.lower())

out:

abcd

(3) 去除空白符

方法

描述

lstrip()

删除字符串左侧空白

rstrip()

删除字符串右侧空白

stripe()

删除字符串两侧空白

str1 = '   hello   '
# lstripe()
print(str1.lstrip())

# rstripe()
print(str1.rstrip())

# stripe()
print(str1.strip())

out:

hello   
   hello
hello

(4) 对齐

方法

描述

ljust()

字符串左对齐

rjust()

字符串右对齐

center()

居中(但并非绝对居中)

数据按指定方向对齐，使用指定字符(默认空格)填充至对应长度的新字符串。

str1 = 'hello'

# ljust()
# 语法：字符串序列.ljust(长度，填充字符)
# 填充字符：不填写则默认空格
print(str1.ljust(10, '.'))

# rjust()
# 语法：字符串序列.rjust(长度，填充字符)
# 填充字符：不填写则默认空格
print(str1.rjust(10, '.'))  # .....hello

# center()
# 语法：字符串序列.center(长度，填充字符)
# 填充字符：不填写则默认空格
print(str1.center(10, '.'))  # ..hello...  --可以看出只是相对居中

out:

hello.....
.....hello
..hello...

4.3、判断

方法

描述

startswith

判断字符串是否是以子串开头，是则返回true,否则返回false;如果设置开始和结束位置下标，则在指定范围内检查

endswith

判断字符串是否是以子串结尾，是则返回true,否则返回false;如果设置开始和结束位置下标，则在指定范围内检查

isalpha

判断非空字符串是否全部都是由–字母–组成，是则返回true,否则返回false

isdight

判断非空字符串是否全部都是由–数字–组成，是则返回true,否则返回false

isalnum

判断非空字符串是否仅由字母、数字其中一种或两种组合组成，是则返回true,否则返回false

ispace

判断非空字符串是否仅由空白字符组成，是则返回true,否则返回false

startswith()：字符串是否以指定子串开头 

# 字符串.startswith(子串，开始位置下标，结束位置下标)
str1 = 'Hello,world'
print(str1.startswith('He'))  # True
print(str1.startswith('l', 2))  # True

endswith()：字符串是否以指定子串结尾 

# 字符串.endswith(子串，开始位置下标，结束位置下标)
str1 = 'Hello,world'
print(str1.endswith('rld'))  # True

isalpha()：字符串是否全部由字母或者中文汉字组成 

# isalpha()
print(str1.isalpha())  # False,有逗号
str2 = 'abcd'
print(str2.isalpha())  # True

# 中文亦可
my_str = '我们'
print(my_str.isalpha())  # True

isdight()：字符串是否全部由数字组成 

# isdight()
str1 = '12 345'
str2 = '12345'
print(str1.isdigit())  # False,有空白符
print(str2.isdigit())  # True

isalnum()：字符串是否仅由字母、数字其中一种或两种组合组成 

# isalnum()
str1 = 'abcd'
str2 = '12345'
str3 = 'a1'
print(str1.isalnum())  # True
print(str2.isalnum())  # True
print(str3.isalnum())  # True

isspace()：字符串是否仅由空白字符组成 

# isspace()
str1 = '12 345'
str2 = '     '
print(str1.isspace())  # False,有数字
print(str2.isspace())  # True