Python__17--字符串

时间：2022-12-29 17:06:50

字符串的定义

字符串类型是 Python里面最常见的类型。我们可以简单地通过在引号间包含字符的方式创建它。Python里面单引号和双引号的作用是相同的。字符串是一种直接量或者说是一种标量，这意味着 Python解释器在处理字符串时是把它作为单一值并且不会包含其他 Python类型的。字符串是不可变类型，就是说改变一个字符串的元素需要新建一个新的字符串。字符串是由独立的字符组成的，并且这些字符可以通过切片操作顺序地访问。

1 查询操作

  1. index：查找子串第一次出现，没有会报错

    s='hello,hello'
print(s.index('lo'))
#输出3

  2. rindex：查找子串最后一次出现，没有会报错

  3. find：查找子串第一次出现，没有会返回-1

  4. rfind：查找子串最后一次出现，没有会返回-1

测试代码：

s='hello,hello'
print(s.index('lo'))
print(s.find('lol'))
print(s.rfind('lo'))
print(s.rindex('lol'))

测试结果：

Python__17--字符串

2 大小写转换

  1. 全部转成大写，s.upper()

    a=s.upper()

  2. 全部转成小写，s.lower()

    s='Hello,Python'
b=s.lower()
#输出为hello,python

  3. 大小写交换，s.swapcase()

  4. 每个单词首字母大写，其余小写，s.title()

  5. 第一个字符大写，其余小写，s.capitalize()

测试代码：

s='hOllLKk'
a=s.upper()
print(s)
print(a)
s='Hello,Python'
b=s.lower()
print(b)
c=s.swapcase()
print(c)
d=s.title()
print(d)
e=s.capitalize()
print(e)

测试结果：

Python__17--字符串

3 字符串对齐

默认填充空格，指定参数小于原字符串个数，则原样输出

3.1 居中对齐，center()

s='hello,world'
print(s.center(20,'*'))
#输出
#****hello,world****

3.2 左对齐，ljust

print(s.ljust(20,'*'))
#输出
#hello,world********

3.3 右对齐，rjust、zfil()

  • s.rjust()

    print(s.rjust(20,'*'))
#输出
#********hello,world

  • s.zfill() 只有一个个数参数，用0填充

    print(s.zfill(20,'*'))
#输出
#00000000hello,world
print('-8000'.zfill(8))
#输出
#-00080000

测试代码：

s='hello,world'
print(s.center(20,'*'))
print(s.center(20))
print(s.ljust(20,'*') )
print(s.rjust(20,'*') )
print(s.zfill(20) )
print('-8000'.zfill(8))

测试结果：

Python__17--字符串

4 字符串劈分

4.1 s1.split()

左侧开始分割，默认用空格分隔

s1='hello world python'
print(s1.split())    #默认在空格处分割
#输出：['hello',world','python']

s2='hello|world|python'
print(s2.split(sep='|'))    #用竖线分割
#输出：['hello',world','python']

print(s2.split(sep='|',maxsplit=1))    #按照竖线，从左开始分割一个
#输出：['hello',world|python']

4.2 s1.rsplit

右侧开始分割，默认用空格分隔

s1='hello world python'
print(s1.rsplit())    #默认在空格处分割

s2='hello|world|python'
print(s2.rsplit(sep='|'))    #用竖线分割
#输出：['hello',world','python']

print(s2.split(sep='|',maxsplit=1))    #按照竖线，从右侧开始分割一个
#输出：['hello|world','python']

5 字符串判断

  1. 合法标识符：字母（汉字也是字母）、数字、下划线

  2. s.isdentifier()，是否是合法的标识符

    s='hello,python'
print(s.isdentifier())
#输出：False

  3. s.isspace，是否全部由空白字符组成（回车，换行，水平制表符）

    print('\t'.isdentifier())
#输出：True

  4. s.isalpha，是否全部又字母组成

  5. s.isdigit()，是否由除了汉字数字的数字组成

  6. s.isdecimal，是否全部由十进制阿拉伯数字组成

  7. s.isnumeric，是否全部由数字组成

  8. s.isalnum，是否全部由字母和数字组成

6 字符串的替换和合并

6.1 替换

s1='hello,python'
print(s1.replace('python','Java'))
#输出：hello,Java
s2='hello,python,python,python'
print(s2.replace('python','Java',2))
#输出：hello,Java,Java,python

6.2 合并join()

6.2.1 列表

lst=['hello','python','Java']
print('|'.join(lst))
#输出：hello|python|Java
print(''.join(lst))
#输出：hellopythonJava

6.2.2 元组

t=('hello','python','Java')
print(''.join(t))
#输出：hellopythonJava

6.2.3 字符串

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

7 字符串的比较

  1. ==与is

    • ==比较的value
    • is比较的是内存地址id

  2. ,>=,<,<=,==,!=

    依次比较每一个字符的原始值

    ord('a')   #为97
chr(97)    #为a

8 字符串的切片操作

产生新的对象

s1=s[start:end:step]

  • 步长为正

    s='hello,python'
s1=s[0:5]
s2=s[6:]
s3='!'
newstr=s1+s3+s2
print(s1)                  #hello
print(s2)                  #python
print(s3)                  #!
print(newstr)              #hello!python
s2=s[-6::1]                #从序号-6开始

  • 步长为负

    s1=s[::-1]    #倒序输出

9 格式化字符串

9.1 %占位符

  1. %s：字符串
  2. %d、%i：整数
  3. %f ：浮点数
name='张三'
age=20
print('我叫%s，今年%d岁了'%(name,age))
#输出：我叫张三，今年20岁了

9.2 {}占位符

print('我叫{0}，今年{1}岁了'.format(name,age))
print(f'我叫{name}，今年{age}岁了')
#输出：我叫张三，今年20岁了
#输出：我叫张三，今年20岁了

9.3 单位精度

9.3.1 使用%

print('%d'%99)
print('%10d'%99)    #10代表输出宽度
print('%.3f'%3.1415926)    #.3f代表三位小数
print('%10.3f'%3.1415926)

9.3.2 使用{}

print('{0:.3f}'.format(3.1415926))    #0代表第一个占位符3.1415926,.3表示小数点后三位，f表示浮点型
print('{0:10.3f}'.format(3.1415926))    #10代表输出宽度

#输出：3.142
#输出：     3.142

9.4 对齐

# 左对齐
'{:*<10}'.format('分割线')
#输出：分割线*******
# 居中
'{:*^10}'.format('分割线')
#输出：***分割线****
# 右对齐
'{:*>10}'.format('分割线')
#输出：*******分割线

10 字符串的编码、解码转换

  • 编码：将字符串转换为二进制数据（bytes）
  • 解码：将bytes类型的数据转换成字符串类型
  • byte=s.encode(encoding='GBK') 编码
  • print(byte.decode(encoding='GBK')) 解码
  • byte=s.encode(encoding='UTF-8') 编码
  • print(byte.decode(encoding='UTF-8')) 解码

测试代码：

s="天涯共此时"
byte=s.encode(encoding='GBK')
print(byte)
print(byte.decode(encoding='GBK'))

byte=s.encode(encoding='UTF-8')
print(byte)
print(byte.decode(encoding='UTF-8'))

测试结果：

b'\xcc\xec\xd1\xc4\xb9\xb2\xb4\xcb\xca\xb1'
天涯共此时
b'\xe5\xa4\xa9\xe6\xb6\xaf\xe5\x85\xb1\xe6\xad\xa4\xe6\x97\xb6'
天涯共此时

进程已结束，退出代码为 0

11 字符串的驻留机制

测试代码：

a=257
b=257
c=257
print(a,id(a))
print(b,id(b))
print(c,id(c))

测试结果：

257 2494013466448
257 2494013466448
257 2494013466448

进程已结束，退出代码为 0

内存示意图：

Python__17--字符串

字符串驻留：

字符串驻留：是一种在内存中保存一份且不可变字符串的方法。（相同的字符串只保留一份）不同的值被存放在字符串的驻留池当中,Python的驻留机制对相同的字符串只保留一份拷贝,后续创建相同的字符串时，不会开辟新的空间，而是把字符串的地址赋给新的创建变量。

Python__17--字符串

import sys
a =sys.intern(b) #强制驻留

测试代码：

import sys
a='Python'
b='world'
c='Pythonworld'
d=a#+b
print(d,id(d))
print(c,id(c))
d=sys.intern(c)
print(d,id(d))
print(c,id(c))

测试结果：

Python 1828817256816
Pythonworld 1828817241584
Pythonworld 1828817241584
Pythonworld 1828817241584

进程已结束，退出代码为 0
标签：

相关文章