07python基础字符串

最新推荐文章于 2024-10-02 10:53:34 发布

Gggghc

最新推荐文章于 2024-10-02 10:53:34 发布

阅读量74

点赞数

分类专栏：记录自学python 文章标签： python

本文链接：https://blog.csdn.net/weixin_51421734/article/details/119858442

版权

记录自学python 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

本文详细介绍了Python中的字符串驻留机制，解释了何时字符串会被驻留，并展示了不同情况下内存地址的比较。此外，还涵盖了字符串的常用操作，如查询、大小写转换、对齐、劈分、判断、替换、合并、比较、切片和格式化。同时，讨论了字符串的编码转换过程，以及在信息技术领域的应用。

摘要由CSDN通过智能技术生成

字符串

1. 字符串驻留机制

字符串是python中的基本数据类型，是一个不可变序列
驻留机制：
- 仅保留一份相同且不可变字符串的方法，不同的值被存放在字符串的驻留池中，python的驻留机制对相同的字符串只保留一份拷贝，后续创建相同字符串时，不会开辟新空间，而是把该字符串的地址赋给新创建的变量
可以用 ’ ’ , " " ,’’’ ‘’’ 创建

a = 'python'
b = "python"
c = '''python'''
print(id(a),'/',id(b),'/',id(c))
# 2032043442096 / 2032043442096 / 2032043442096
# a,b,c的内存地址相同

驻留机制的几种情况（交互模式）

字符串的长度为0或1时

s1 = ''
s2 = ''
print(s1 is s2) #true
s3 = '%'
s4 = '%'
print(s3 is s4) # true

符合标识符的字符串（字母，数字，下划线）

s1 = 'abc%'
s2 = 'abc%'
print(s1 == s2) # true
print(s1 is s2) # false

s3 = 'abcx'
s4 = 'sbcx'
print(s3 is s4) # true

字符串只在编译时进行驻留，而非运行时

a = 'abc'
b = 'ab' + 'c'
c = ''.join(['ab','c'])
print(a,type(a)) # abc <class 'str'>
print(b,type(b)) # abc <class 'str'>
print(c,type(c)) # abc <class 'str'>

print(a is b) # true
print(a is c) # False
# b的值在运行之前已经连接完成，c的值程序运行时通过join方法连接

[-5,256]之间的整数数字

a = -5
b = -5
print(a is b) # true
c = -6
d = -5
print(c is d) # false

sys中的intern方法墙纸2个字符串指向同一个对象

s1 = 'abc%'
s2 = 'abc%'
print(s1 is s2) # false
s1 = sys.intren(s2)
print(s1 is s2) # true

PyCharm对字符串进行了优化
优缺点：
- 当需要值相同的字符串时，可以直接从字符串池中拿来使用，避免频繁的创建和销毁，提升效率和借阅内存，因此拼接字符串和修改字符串比较影响性能
- 需要进行字符串拼接时建议使用str类型的join方法，而非+，因为join（）是先计算出所有字符中的长度，然后再拷贝，只new一次对象，效率要比+更高。

2. 字符串常用操作

2.1 查询

index() - 查找子串substr第一次出现的位置，如果查找的子串不存在，抛ValueError
rindex() - 查找子串substr最后一次出现的位置，如果查找的子串不存在，抛ValueError
find() - 查找子串substr第一次出现的位置，如果查找的子串不存在，返回-1
rfind() - 查找子串substr最后一次出现的位置，如果查找的子串不存在，返回-1

s = 'hello,hello'
print(s.index('lo')) # 3
print(s.find('lo')) # 3
print(s.rindex('lo')) # 9
print(s.rfind('lo')) # 9

2.2 大小写转换

upper() - 字符转大写
lower() - 字符转小写
swapcase() - 大写转小写，小写转大写
capitalize() - 第一个字符转大写，其余转小写
title() - 每个单词的第一个字符转大写，每个单词的剩余字符转小写

s = 'hElLo,PytHon'
a = s.upper()
c = s.lower()
e = s.title()
d = s.swapcase()
print(s,id(s)) # hElLo,PytHon 1438698717104
print(a,id(a)) # HELLO,PYTHON 1438703621872
print(c,id(c)) # hello,python 1438703960112
print(d,id(d)) # HeLlO,pYThON 1438703960240
print(e,id(e)) # Hello,Python 1438703960176

2.3 对齐操作

center() - 居中第一个参数指定宽度，第二个参数指定填充符，第二个参数可选，默认空格，如果设置宽度小于实际宽度则返回原字符串
ljust() - 左对齐同上
rjust() - 右对齐同上
zfill() - 右对齐左边用0填充，该方法只接收一个参数，用于指定字符串的宽度，如果指定的宽度小于等于字符串长度，返回字符串本身

s = 'hello,Python'
# s长度12  设置为20

#居中
print(s.center(20,'*'))
# ****hello,Python****
#左对齐
print(s.ljust(20,"*"))
print(s.ljust(10,"*"))
print(s.ljust(20))
'''
hello,Python********
hello,Python
hello,Python 
'''
#右对齐
print(s.rjust(20,'*'))
print(s.rjust(20))
print(s.rjust(10))
'''
********hello,Python
        hello,Python
hello,Python
'''
#zfill()
print(s.zfill(20))
print(s.zfill(10))
print('-8910'.zfill(8))
'''
00000000hello,Python
hello,Python
-0008910
'''

2.4 字符串的劈分

split()
- 字符串左边开始劈分，默认的劈分字符是空字符，返回值是一个列表
- 通过参数sep指定劈分字符串
- 通过参数maxsplit指定最大劈分次数，经过最大劈分次数后，剩余字符串会单独作为一部分
rsplit()
- 字符串右边开始劈分，默认的劈分字符是空字符，返回值是一个列表
- 通过参数sep指定劈分字符串
- 通过参数maxsplit指定最大劈分次数，经过最大劈分次数后，剩余字符串会单独作为一部分

s = 'hello,world python'
lst1 = s.split()
print(lst1)  # ['hello,world', 'python']
s1 = 'hello|world|python'
print(s1.split())
print(s1.split(sep='|'))
print(s1.split(sep='|', maxsplit=1))
'''
['hello|world|python']
['hello', 'world', 'python']
['hello', 'world|python']
'''
print('------------------------------')
print(s.rsplit())
print(s1.rsplit('|'))
print(s1.rsplit('|', maxsplit=1))
'''
['hello,world', 'python']
['hello', 'world', 'python']
['hello|world', 'python']
'''

2.5 字符串的判断

isidentifier() - 判断字符串是不是合法的标识符

s = 'hello,python'
print('1.',s.isidentifier())
print('2.','hello'.isidentifier())
print('3.','张三'.isidentifier())
print('4.','张三_123'.isidentifier())
'''
1. False
2. True
3. True
4. True
'''

isspase() - 判断字符串是否全部由空白字符组成（回车，换行，水平制表符）

s = 'hello,python'
print(\t'.isspace()) # true

isalpha() - 判断字符串是否全部由字母组成

print('abc'.isalpha()) # true
print('张三'.isalpha()) # true
print('张三1'.isspace()) # false

isdecimal() - 判断字符串是否全部由十进制的数字组成

print('123'.isdecimal()) # True
print('123四'.isdecimal()) # False

isnumeric() - 判断字符串是否全部由数字组成

print('123'.isnumeric()) # True
print('123四'.isnumeric()) # True

isalnum() - 判断指定字符串是否全部由字母和数字组成

print('abc1'.isalnum()) # True
print('张三123'.isalnum()) # True
print('abc!'.isalnum()) # False

2.6 字符串替换、合并

replace() - 第一个参数为被替换子串，第二个为替换子串，第三个为最大替换次数

s = 'hello,python'
print(s.replace('python','java')) # hello,java
s1 = 'hello,python,python,python'
print(s1.replace('python','java',2)) # hello,java,java,python

join()

lst = ['hello','java','python']
print('|'.join(lst)) # hello|java|python
print(''.join(lst)) # hellojavapython

t = ('hello','java','python')
print('|'.join(t)) # hello|java|python
print(''.join(t)) # hellojavapython

print('*'.join('python')) # p*y*t*h*o*n

2.7 字符串比较

运算符：>,>=,<,<=,==,!=
比较规则：先比较第一个字符，如果相等以此比较下面的
比较原理：两个字符比较时，比较的是其ordinal value（原始值），调动内置函数ord可以得到指定字符的ordinal value。与内置函数ord对应的是内置函数chr，调用chr时指定ordinal value可以得到其对应的字符

print('abc'>'abb') # True
print('abc'>'bcd') # False

print(ord('a'),ord('b')) # 97 98
print(chr(97),chr(98)) # a b

== 比较的是value is 比较的是id

2.8 字符串切片操作

字符串是不可变类型
不具备增删改操作
切片操作将产生新的对象

[start : end : step]

s = 'hello,Python'
s1 = s[:5]  # 没有指定起始位置 默认从0开始
s2 = s[6:]  # 没有指定结束为止 默认切到最后一个元素
s3 = '!'
print(s1)  # hello
print(s2)  # Python
newStr = s1 + s2 + s3
print(newStr)  # helloPython!

print(s[1:5:1])  # ello
print(s[::2])  # hloPto
print(s[::-1])  # nohtyP,olleh

2.9格式化字符串

%占位符
- %s：字符串
- %i或%d：整数
- %f：浮点数

name = '张三'
age = 20
print('我叫%s,今年%d岁了' % (name, age)) # 我叫张三,今年20岁了

{}

name = '张三'
age = 20
print('我叫{0},今年{1}岁'.format(name,age)) # 我叫张三,今年20岁

f-string

name = '张三'
age = 20
print(f'我叫{name},今年{age}岁') # 我叫张三,今年20岁

精度

print('%d' % 99)
print('%10d' % 99) # 宽度10
print('999999999')
print('%.3f' %3.1415926) # .3 表示小数点后三位
print('%10.3f' %3.1415926) # 宽度为10，取小数点后三位
'''
99
        99
999999999
3.142
     3.142
'''

# {}
print('{0}'.format(3.1415926))
print('{0:.3}'.format(3.1415926)) # .3 表示一共3位数
print('{0:.3f}'.format(3.1415926)) # .3f 表示小数点后三位
print('{0:10.3}'.format(3.1415926))
'''
3.1415926
3.14
3.142
      3.14
'''

2.10 字符串编码转换

编码：将字符串转换为二进制数据（bytes）
解码：将bytes类型的数据转换成字符串类型

s = '床前明月光'
# 编码
print(s.encode(encoding='GBK'))  # GBK一个中文占两个字符，b表示二进制
# b'\xb4\xb2\xc7\xb0\xc3\xf7\xd4\xc2\xb9\xe2'
print(s.encode(encoding='UTF-8'))  # UTF-8一个中文占三个字符
# b'\xe5\xba\x8a\xe5\x89\x8d\xe6\x98\x8e\xe6\x9c\x88\xe5\x85\x89'

# 解码
# byte代表就是一个二进制数据(字节类型数据)
byte = s.encode(encoding='GBK')
print(byte.decode(encoding="GBK")) # 床前明月光
byte1 = s.encode(encoding='UTF-8')
print(byte1.decode(encoding="UTF-8")) # 床前明月光