Python中字符串(str)的定义及详细操作

字符串

在python中字符串是基本数据类型，是一个不可变的字符序列，用于存储和表示基本的文本信息。

Python的字符串类型（str）

单引号 ,双引号 ,三引号包括起来的内容

1.单引号和双引号、三引号都可以包含字符串，内容是一样的

2.单引号中可以直接放双引号，不用转义;双引号中可以直接放单引号，不用转义

3.单引号中放单引号或者双引号中放双引号，需要用 \ 转义

4.三个单引号或者三个双引号，可以包含多行数据，并且里面随便包含双引号和单引号

例1：

a='python'
b="python"
c='''python'''
d="""python"""
print(a)
print(b)
print(c)
print(d)    #不管字符串用的是单、双、还是三引号，结果相同

python
python
python
python

例2：

a='hello"python"world'
b="hello'python'world"
print(a)
print(b)

hello"python"world
hello'python'world

例3：

a='hello\'python\'world'
b="hello\"python\"world"   #不加反斜线转义就会报错
print(a)
print(b) 

hello'python'world
hello"python"world

sql="""
select *
from table
where name like '%li%
order by id desc
"""
print(sql)

select *
from table
where name like '%li%
order by id desc

字符串驻留机制

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

驻留机制的几种情况

1.字符串的长度为0或1时

2.符合标识符的字符串 (含有字母、数字、下划线的字符串）

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

4.[-5，256]之间的整数数字

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

Pycharm对字符串进行了优化处理

例：

a='python'      #单引号类型
b="python"      #双引号类型
c='''python'''  #三引号类型
print(a,id(a))  
print(b,id(b))  
print(c,id(c))  #id相同，字符串驻留机制，相同的字符串只保留一份拷贝

例1：长度为0或1时

s1=''       
s2=''
s1 is s2    #字符串长度为0时,驻留
s3='1'
s4='1'
s3 is s4   #字符串长度为1时，驻留

例2：含有字母、数字、下划线的字符串

s1='abc_123'
s2='abc_123'
s1 is s2

例3：字符串编制时驻留，运行时不驻留

a='abc'
b='ab'+'c'
c=''.join(['ab','c'])
s1=a is b
s2=a is c
print(s1)     #a和b是运行前就是abc ，驻留
print(s2)    #c是运行后是abc ,所以不驻留
print(id(a),id(b),id(c))

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

a= -5
b= -5   
a is b #  -5到256之间的整数数字都会驻留

a=-6
b=-6
c=a is b
print(c)  #-6不在 -5到256之间的整数数字不驻留

为了节省空间，可以用sys强制驻留指向一个空间

import sys
a='abc%'
b='abc%'
a=sys.intern(b)
c=a is b
print(c)
print(id(a),id(b))

字符串的常用操作

1.字符串的查询操作

1.index():查找子串substr第一次出现的位置，如果查找的子串不存在时，则抛出ValueError

2.rindex():查找子串substr最后一次出现的位置，如果查找的子串不存在时，则抛出ValueError

3.find():查找子串substr第一次出现的位置，如果查找的子串不存在时，则返回-1

4.rfind():查找子串substr最后一次出现的位置，如果查找的子串不存在时，则返回-1

例：

a='lucky,lucky'
print(a.index('ky'))   #查找ky第一次出现的位置
print(a.find('ky'))    #查找ky第一次出现的位置
print(a.rindex('ky'))  #查找ky最后一次出现的位置
print(a.rfind('ky'))   #查找ky最后一次出现的位置 

2.字符串的大小写转换的操作方法

1.upper() 把字符串中所有字符都转成大写字母

2.lower() 把字符串中所有字符都转成小写字母

3.swapcase() 把字符串中所有大写字母转成小写字母，把所有小写字母都转成大写字母

3.capitalize() 把第一个字符转换为大写，把其余字符转换为小写

4.title() 把每个单词的第一个字符转换为大写，把每个单词的剩余字符转换为小写

例：

a='hello,python'      #把字符串中所有的字符都转成大写
b=a.upper()          
print(b)
c=a.swapcase()       #把字符转小写字母准换成大写字母，如果有大写字母会转换成小写
print(c)
d=a.capitalize()     #把字符串中第一字符转换成大写，把其余字符转换成小写
print(d)
e=a.title()         #把每个单词的第一个字符转换成大写，其余字符转换成小写
print(e)
s='BABY'
s1=s.lower()        #所有字符串转成小写
print(s1)

3.字符串的替换

1.replace() 第1个参数指定被替换的子串，第2个参数指定替换子串的字符串，该方法返回替换后得到的字符串，替换前的字符串不发生变化，调用该方法时可以通过第3个参数指定最大替换次数。

2.join()将列表或元组中的字符串合并成一个字符串

例1：replace

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

例2：join()

lst=['hello','python','world']
print('|'.join(lst))
print(''.join(lst))
print('*'.join(lst))  #列表的字符串合并

lst=('hello','python','world')
print('|'.join(lst))
print(''.join(lst))
print('+'.join(lst))  #元组的字符串合并

4.字符串内容对齐操作的方法

1.center() 居中对齐，第一个参数指定宽度，第二个参数指定填充符，第二个参数是可选的，默认是空格，如果设置宽度小于实际宽度则返回原字符串

2.ljust() 左对齐，第一个参数指定宽度，第二个参数指定填充符，第二个参数是可选的，默认是空格，如果设置宽度小于实际宽度则返回原字符串

3.rjust() 右对齐，第一个参数指定宽度，第二个参数指定填充符，第二个参数是可选的，默认是空格，如果设置宽度小于实际宽度则返回原字符串

4.zfill() 右对齐，左边用0填充，该方法只接受一个参数，用于指定字符串的宽度，如果指定的宽度小于等于字符串的长度，则返回原字符串

例：

a='hello ,python'
print(s.center(20,'*'))  #居中对齐，指定宽度20，用*号填充
print(s.center(20))      #居中对齐，指定宽度20，默认空格填充
print(s.ljust(20,'*'))   #左对齐，指定宽度20，用*号填充
print(s.ljust(20))       #左对齐，指定宽度20，默认空格填充
print(s.rjust(20))       #右对齐，指定宽度20，默认空格填充
print(s.rjust(20,'*'))   #右对齐，指定宽度20，用*好填充
print(s.zfill(20))       #右对齐，指定宽度20，左边默认0填充，只接受宽度参数哦

5.字符串劈分操作的方法

1.split(): 从字符串的左边开始劈分，默认的劈分字符是空格字符串，返回的值都是一个列表

    通过设置参数sep指定劈分字符串的劈分符
    
    通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大次劈分之后，剩余的子串会单独为一部分，从左边开始劈分

2.rsplit(): 从字符串的右边开始劈分，默认的劈分字符是空格字符串，返回的值都是一个列表

    通过参数sep指定劈分字符串的劈分符
    
    通过参数maxsplit()指定劈分字符串时的最大劈分次数，从右边开始劈分

例：

s='hello world python'
print(s.split())     #默认劈分字符串为空格

['hello', 'world', 'python']

s='hello| python| world'
print(s.split(sep='|'))    #设置参数sep指定劈分符是| ，竖线
print(s.split(sep='|',maxsplit=1))   #指定最大劈分次数为1，剩余的子串为单独一部分，从左侧开始劈分

['hello', ' python', ' world']
['hello', ' python| world']

s='hello world python'
print(s.rsplit())    #默认劈分字符串为空格

['hello', 'world', 'python']

s='hello| python| world' 
print(s.rsplit(sep='|'))              #设置参数sep指定劈分符是| ，竖线
print(s.rsplit(sep='|',maxsplit=1))   #指定最大劈分次数为1，剩余的子串为单独一部分，从左侧开始劈分

['hello', ' python', ' world']
['hello| python', ' world']

6.判断字符串操作的方法

1.isidentifier() 判断指定的字符串是不是合法的标识符

2.isspace() 判断指定的字符串是否全部由空白字符组成（回车、换行、水平制表符）

3.isalpha() 判断指定的字符串是否全部有字母组成

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

5.isnumeric() 判断指定的字符串是否全部由数字组成

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

例：

print(s.isidentifier())
print('s'.isidentifier())
print('2'.isidentifier())
print('小明'.isidentifier())
print('小明_98'.isidentifier())     #判断字符串是不是合法的标识符

False
True
False
True
True

print('\t'.isspace())        #判断字符串是够全部由空白字符组成（回车、换行、水平制表符）

True

print('Baby'.isalpha())
print('小明'.isalpha())      #判断字符串是够全部由字母组成

True
True

print('123'.isdecimal())     #判断字符串是否是十进制

True

print('12345'.isnumeric())
print('1234五'.isnumeric())   #判断字符串是够全部由数字组成

True
True

print('abc123'.isalnum())
print('小明123'.isalnum())    #判断字符串是够全部由字母和数字组成

True
True

7.字符串的比较操作

1.运算符：>, >=, <, <=, ==, !=

2.比较规则：首先比较两个字符串中的第一个字符，如果相等则继续比较下一个字符，依次比较下去，直到两个字符串中的字符不相等时，其比较结果就是两个字符串的比较结果，两个字符串中的所有后续字符将不再被比较

3.比较原理：两个字符比较时，比较的是其ordinal value(原始值），调用内置函数ord可以得到指定字符的原始值。与内置函数ord对应的是内置函数chr,调用内置函数chr时指定原始值可以得到其对应的字符

例：

print('apple'>'app')
print('apple'>'banana')
print(ord('a'),ord('b'))   #调动a和b的原始值
print(chr(97),chr(98))     #通过原始值可以调用对应的字符

True
False
97 98
a b

== 与 is 的区别

== 比较的是值

is比较的是id

a=b='python'
c='python'
print(a==b)      #比较的是值相等
print(b==c)
print(a is b)
print(b is c)    #比较的是id相同
print(id(a),id(b),id(c))   #a、b、c三个id 相同,字符串驻留

True
True
True
True
2965461198064 2965461198064 2965461198064

8.字符串的切片操作

字符串是不可变序列，不具备增、删、改等操作，切片操作将产生新的对象

s='hello python'
s1=s[2:]          #从索引为2开始切片，默认到最后
print(s1)
s2=s[:6]          #从索引为0开始切片，到索引为6结束
print(s2)
print(s[1:5:1])   #从索引为1开始到5（不包括5），步长为1
print(s[::2])     #默认从0开始，默认到最后，步长为2，两个元素之间的索引间隔为2
print(s[::-1])    #默认从字符串最后开始，到字符串的第一个开始，因为步长为-1
print(s[-6::1])   #从索引为-6开始，到字符串最后一个元素结束，步长为1

llo python
hello 
ello
hlopto
nohtyp olleh
python

9.格式化字符串

1.%作占位符: '我的名字叫%s,今年%d岁了 ’ % (name,age)

2.｛｝作占位符:‘我的名字叫｛0｝，今年｛1｝岁了，我真的叫:｛0｝’.format(name,age)

3.f-string:‘我叫｛name｝,今年｛age｝岁’

为什么需要字符串的编码转换

不同的计算机之间的内容数据传输，需要把字符串str转换成二进制字节传输，然后再把二进制字节转换成str显示

编码与解码的方式

1.编码：将字符串转换为二进制数据（bytes）

2.解码：将bytes类型的数据转换成字符串类型

例：格式化字符串

name='小明'
age=20
print('我叫%s,今年%d岁'%(name,age))
print('我叫｛Baby｝，今年｛20｝岁'.format(name,age))
print(f'我叫｛name｝,今年｛age｝岁')

我叫小明,今年20岁
我叫｛Baby｝，今年｛20｝岁
我叫｛name｝,今年｛age｝岁

宽度、和精度表示

print('%10d' % 99)                     #10d表示宽度
print('hellohello')
print('%f' % 3.1415926)               #f代表精度
print('%0.3f' % 3.1415926)            #0.3f带边保留小数点后3位
print('%10.3f' % 3.1415926)           #同时表示宽度10和精度小数点后3位
print('{0:.3}'.format(3.1415926))     #这里的.3表示的是一共三位数，0是代表的占位符的顺序，可以省略
print('{:.3f}'.format(3.1415926))     #0.3f表示的是小数点后三位
print('{:10.3f}'.format(3.1415926))   #同时设置宽度是10，精度是小数点后三位小数

        99
hellohello
3.141593
3.142
     3.142
3.14
3.142
     3.142

例：编码、解码

s='快过年见了'
print(s.encode(encoding='GBK'))       #在GBK这种编码中，一个中文占两个字节
print(s.encode(encoding='UTF-8'))     #在UTF-8这种编码中，一个中文占三个字节  
byte=s.encode(encoding='GBK')         #byte代表的是二进制数据，或者字节类型数据
print(byte.decode(encoding='GBK'))    #注意用什么编码，用什么解码

b'\xbf\xec\xb9\xfd\xc4\xea\xbc\xfb\xc1\xcb'
b'\xe5\xbf\xab\xe8\xbf\x87\xe5\xb9\xb4\xe8\xa7\x81\xe4\xba\x86'
快过年见了

小白学python的学习笔记，后续持续更新，敬请关注！共同学习进步，有问题的地方欢迎评论区留言讨论！点赞是我更新的动力，哈哈~~
下期见伙计们