python字符串知识点

kxm_lzu

于 2023-01-14 21:43:10 发布

阅读量111

点赞数

分类专栏： python知识点文章标签： python

本文链接：https://blog.csdn.net/kxm_lzu/article/details/128679333

版权

python知识点专栏收录该内容

2 篇文章 0 订阅

订阅专栏

文章目录

不可变的字符串

python中的数据类型分为可变和不可变两种。各有优缺点，可变类型的优点在于可以“就地”修改，而不可变类型不能“就地”修改，但是有助于进行内部优化。还有就是字典的键必须是不可变类型。字符串显然是不可变的类型。

数据类型转换

类型转换语法为：type(data_object),前提是变量支持类型转换，如果不支持，将会抛出"ValueError"的异常。一些常见转换如下：

将字符串转换为数值

s = "45"
n = int(s)
print(n) # 结果n为45

int转换接受第二个可选参数：int(data_object, radix=10),默认将字符串以10进制的形式转换为整数，当然也可以有2进制，8进制，16进制。可以使用str()方法将数字转换为字符串。

n = int("10001", 2)
print(n)  # 按照二进制转换为数字，结果为17

字符串运算符

比较运算符：> < python使用字符编码(ASCII或者Unicode)顺序比较字符串，大写字母均在小写字母前，也就是说大写字母小于小写字母，除此之外，字母按照字母表顺序比较。

print('a' > 'A')  # True

字符串连接符：+，用于将多个字符串连接成一个字符串
字符串乘法运算符：*,可以快速得到长字符串，这种方式创建长字符串很高效

print('_'*20) # ____________________

is 和 is not用来判断是否指向相同的内存空间(即是否是同一个对象)。而 == 则用来判断值是否相等。还有一个比较特殊的就是None，这实际上是一个特殊类型：NoneType类型，该类型只有一个值，就是None。它代表是否创建了对象，没有则为None,有则不为None。

str_1 = "cc"
str_2 = str_1

str_3 = "cc"
# is 是检查两个对象是否指向同一块内存空间，即比较的是内存地址，可以通过
# id函数来获取内存地址，而 == 是检查他们的值是否相等

print("str_1 id is " + str(id(str_1)))
print("str_3 id is " + str(id(str_3)))

print(str_1 == str_2)  # True
print(str_1 == str_3) # True

print(str_1 is str_2) # True

# 下面的语句结果也是True，这是因为python有一个字符串驻留机制，在一些情况下会驻留，另一些情况则不会
# 因此有时候会返回True，有时候返回False
print(str_1 is str_3) # True

按道理，str_1和str_3应该不是同一个对象，用is判断应该是False，但是仍然为True，这是由于字符串的一个驻留机制，会让相同的内容只有一个副本。驻留机制情况比较多，这里不过多介绍。

下面的代码可以看出，空字符串也是创建了对象的，无论使用==还是is，均为False。因此，None仅代表没有创建对象。

str_4 = ""
# None其实是一种特殊类型，NoneType类型，该类型只有一个值，就是None。
# 空(空格，空字符串，空列表等)不代表是None，但None代表空,即没有创建对象
# 只要创建了对象，则一定不为None,在判断是否为None时，最好使用is关键字，不要使用 ==
print(str_4 == None) # False
print( str_4 is None) # False

索引和切片

索引是用数字来引用单个字符。而切片则是引用子字符串。不可以使用索引或者切片“就地”更改字符串中的值，因为字符串是不可变类型。

索引字符串将产生一个单字符的字符串，虽然只有一个字符，但是其类型依然是字符串类型。也就是说，在python中，没有单独的字符类型。

print(type("wd"[1])) # <class 'str'>

切片：切片是Python字符串，元组，列表共享的一种特殊功能。
其语法为：string[beg: end: step]
前两个参数已经很熟了，主要说一下step这个参数。首先，它的符号表示方向，正为从前往后切，负则为从后往前切。beg为切片开始的位置，end为切片结束的位置。若省略这两个参数，则分别表示从端点开始，从端点结束。至于从左端点还是右端点，这就要看step的符号了。正则起始在左，终止在右，负则反之。step表示，走到第step步，取一个。
总的来说，前两个参数和step的符号确定范围和方向，step数值确定怎么取，如果前两个参数和方向构不成范围，则为空字符串

str_5 = "adhdakj"
print(str_5[1::-2]) # a
print(str_5[::-2]) # jaha
print(str_5[2::-2]) # ha
print(str_5[3::-2]) # dd
print(str_5[4::-2]) # aha
print(str_5[-1:-2:-2]) # j
print(str_5[-1:-3:-2]) # j
print(str_5[-1:-4:-2]) # ja
# 下面的切片构不成范围，则为空，其他情况类似
print(str_5[1:3:-2] == "") # True
print(str_5[-1:-3] == "") # True
print(str_5[1:-3]) # dhd
print(str_5[1:-3:-1] == "") # True
print(str_5[-3:1] == "") # True

在python中，切片不会因为索引越界而抛出异常。它会尽可能多地获取输入，在某些情况下，还会得到空字符串。

print("xcajksbn"[2:20]) # 'ajksbn'
print("xcajksbn"[10:20]) # 空字符串

单字符函数

python中有两个函数是为长度为1的字符串设计的，称为单字符函数，但其操作对象依然是字符串。

ord(str):返回字符的数字编码
chr(n):将ASCII/Unicode编码转换为字符

print(ord("A")) # 输出65
print(chr(65)) # 输出A

用join函数构造字符串

使用+可以创建字符串，连接字符串，但是每次都会新建字符串对象，效率不是很高。使用join()方法可以快速，高效的构建字符串。
用法为：separator_string.join(list)
可以接受空字符串为分隔符，那样会将列表里的字符串全部连接到一起。list里面的元素也必须是字符串，不然会报错。

重要的字符串函数

函数与方法不同，方法是字符串对象所拥有的，而函数是内置的函数。

input():提示用户输入字符串
len(str): 得到字符串长度
max(str): 返回字符串中编码最大的字符
min(str)：返回字符串中编码最小的字符
reversed(str): 返回一个字符串逆序的迭代器
sorted(str): 返回按字符编码排序的列表
重点演示最后两个函数的用法

a = reversed("jncxasjk")   #生成逆序的迭代器
print(type(a)) # 是一个迭代器
a1 = "".join(a) # join函数的参数也可以是迭代器
print(a1)  # kjsaxcnj
print(type(a1)) # 字符串类型

b = sorted("csdvsdzvdzf") #返回按字符编码排序的列表
print(type(b)) # 列表类型
print(b) # ['c', 'd', 'd', 'd', 'f', 's', 's', 'v', 'v', 'z', 'z']
b1 = "".join(b)  #使用join方法将列表转为字符串
print(b1) # cdddfssvvzz
print(type(b1)) # 字符串类型

进制转换函数(将数字转为指定进制的字符串)

bin(n):转换为二进制字符串
hex(n):转换为16进制字符串
oct(n):转换为8进制字符串

print(bin(3)) # '0b11'
print(hex(3)) # '0x3'
print(oct(3)) # '0o3'

布尔方法与大小写转换方法

#判断是不是所有字符都是字母或者数字
print("sxaxs12@".isalnum())
print("sxaxs12".isalnum())

# 判断是否是字母
print("3".isalpha())
print("a".isalpha())

# 判断是否是10进制数，decimal一般用于unicode编码字符
print("12".isdigit())
print("12s".isdigit())
print("12".isdecimal())
print("12s".isdecimal())

#判断是否是有效的python标识符
print("2sd".isidentifier())
print("sdsd".isidentifier())

#判断是否为空白
print("csd".isspace())

#判断是否是标题，即每个单词首字母大写
print("Tcb Us".istitle())
print("acb Us".istitle())

#判断是否全是大小写
print("scsA".isupper())
print("SACA".isupper())
print("scsA".islower())
print("csdcs".islower())


# 大小写转换方法，这个大小写转换只适用于字母，其他字母的大小写就不对了。可以用str.casefold()将所有字符(包括iunicode中的字符)均转为小写
# upper(),lower(),title(),swapcase():变换大小写，小变大，大变小
print("cvzsd".upper())
print("SCDS".lower())
print("SCDScd".lower())
print("SJCKAcnsjc".swapcase())

字符串的搜索和替换

首先介绍两个基本函数：

str.startwith(substr)：匹配到前缀则返回true
str.endwith(substr)：匹配到后缀则返回true

print("csa".startswith("cs")) # True
print("csa".endswith("a")) # True

字符串搜索方法

str.count(substr, beg, end) : 记录子字符串出现的次数，后面的参数指定起始和终止位置

print("doo be doo be doo...".count("doo")) # 3
print("doo be doo be doo...".count("doo", 1)) # 2
print("doo be doo be doo...".count("doo", 1, 10)) # 1
print("doo be doo be doo...".count("doo", 1, 9)) # 0

str.find(substr, beg, end): 得到子字串第一次出现的索引，没找到则返回-1，后面参数的和count方法一样

print("doo be doo be doo...".find("doo")) # 0
print("doo be doo be doo...".find("doo",1)) # 7
print("doo be doo be doo...".find("doob")) # -1

若想要找到所有子字符串出现的位置，可按以下程序来实现：

frank_str = "doo be doo be doo..."
n = -1

while True:
    n = frank_str.find("doo", n+1)
    if n == -1:
        break
    print(n)  # 0，7，14

str.index(substr, beg, end)
str.rfind(substr, beg, end)

这两个方法与find基本一致，知识index在找不到的时候会抛出异常，而rfind()是从逆序寻找子字符串，依然是搜索正常顺序的子字符串

print(frank_str.rfind("doo")) # 14
print(frank_str.index("doob")) # 抛出valuerror

字符串替换方法(replace()方法)

str.replace(old, new, count): 前面为原来得字串，后面的为想要替换得字串，count指替换数量，默认替换全部得旧字串。替换之后将生成新的字符串，因为字符串为不可变类型，不可以被原地修改。

print(frank_str.replace("doo", "doi")) # doi be doi be doi...
print(frank_str.replace("doo", "doi", 2))  #指定count后，只替换了前两个子字符串!，doi be doi be doo...

使用split()方法拆分字符串

input_str.split(“分割字符串”)：该函数有一个参数，表示用什么字符串分割原始字符串，如果省略则按照空格分割。生成列表，列表中的元素是字符串。


print("Moe Larry Curly Shemp".split()) # ['Moe', 'Larry', 'Curly', 'Shemp']

print("Moe, Larry, Curly, Shemp".split(", ")) # ['Moe', 'Larry', 'Curly', 'Shemp']

print("Moe  Larry Curly Shemp".split(" ")) # 分割的时候会将空白字符识别为空字符串， ['Moe', '', 'Larry', 'Curly', 'Shemp']
                                           # 中间有n个空格，则会切出来n-1个空字符串

print("Moe    Larry Curly Shemp".split(" ")) # ['Moe', '', '', '', 'Larry', 'Curly', 'Shemp']

print("Moe    Larry Curly Shemp".split()) # ['Moe', 'Larry', 'Curly', 'Shemp']

print("  vcwsvds vs".split()) # ['vcwsvds', 'vs']

从字符串剥离字符(strip()方法)

从字符串剥离字符
strip(extra_chars) 去除开头和结尾的字符
lstrip(extra_chars) 去除开头的字符
rstrip(extra_chars) 去除结尾的字符
会去除extra_chars中所有的字符,如不指定，将去除前后所有的空白
这些函数都将生成新的字符串，而原字符串不会被改变

print("    csdc scds  ".strip()) # 'csdc scds'
print("    csdc scds  ".lstrip()) # 'csdc scds '
print("    csdc scds  ".rstrip()) # '    csdc scds'
print("asdcacafa".strip('a')) # 'sdcacaf'

字符串对齐

字符串对齐
ljust(width, fillchar) 左对齐
rjust(width, fillchar) 右对齐
center(width, fillchar) 居中
width表示把字符串放在这么宽的区域中，其余用填充字符(fillchar)填充
zfill(width) 用0填充,是右对齐的一种简洁方式

print("help!".center(10, "$")) # '$$help!$$$'

print("help!".zfill(10)) # '00000help!'

#注意一种特殊情况，填充的0将称为数字字符串的一部分，如下
print("12".zfill(10)) # '0000000012'

print("-12".rjust(10, "0")) # 注意与以下的区别 '0000000-12'

print("-12".zfill(10)) # 因此0会填充在数字和符号之间 '-000000012'