Python 课程学习笔记（8）字符串

最新推荐文章于 2023-02-12 10:25:34 发布

默默耕耘的lanjing

最新推荐文章于 2023-02-12 10:25:34 发布

阅读量250

点赞数 1

分类专栏： python 学习笔记小白的各种学习日记文章标签： python 字符串

本文链接：https://blog.csdn.net/Happy19981998/article/details/115973065

版权

python 学习笔记同时被 2 个专栏收录

16 篇文章 5 订阅

订阅专栏

小白的各种学习日记

12 篇文章 4 订阅

订阅专栏

第九章字符串

75. 字符串的创建于驻留机制

76. 字符串的常用操作-字符串查询操作

77. 字符串的常用操作-字符串大小写转换操作

78. 字符串的常用操作-字符串内容对齐操作

79. 字符串的常用操作-字符串的劈分

80. 字符串的常用操作-字符串判断的相关方法

75. 字符串的创建与驻留机制

（1）字符串

在Python 中字符串是基本数据类型，是一个不可变的字符序列（元组 & 字符串）

（2）什么叫字符串驻留机制呢？—— 在内存中只有一个副本 —— 节省了内存空间

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

（3）驻留机制的几种情况（交互模式（实时操作）—— win+r —— cmd —— python）

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

② 符合标识符的字符串含有字母、下划线的字符串

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

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

（4）sys 中的 intern 方法强制2个字符串指向同一个对象 —— 目的：节省空间

（5）PyCharm对字符串进行了优化处理

（4）字符串驻留机制的犹缺点

① 当需要值相同的字符串时，可以直接从字符串池里拿来使用，避免频繁的创建和销毁，提升效率和节约内存，因此拼接字符串和修改字符串是会比较影响性能的。

② 在需要进行字符串拼接时建议使用str类型的join()方法，而非 + ，因为间join()方法是先计算出所有字符中的长度，然后再拷贝，只new一次对象，效率要比"+"效率高。

print('--------------------75.字符串的创建与驻留机制------------------')
a='python'
b="python"
c='''python'''
print(a,id(a))
print(b,id(b))
print(c,id(c))   # a,b,c,标识相同，说明a,b,c在内存中只有一份

s1='abc%'
s2='abc%'
print(s1 is s2)

--------------------75.字符串的创建与驻留机制------------------
python 1945324197624
python 1945324197624
python 1945324197624
True

76. 字符串的常用操作-字符串查询操作

功能	方法名称	作用
查询方法	index0	查找子串substr第一次出现的位置，如果查找的子串不存在时，则抛出Va1ueError
	rindex()	查找子串substr最后一次出现的位置，如果查找的子串不存在时，则抛出VaIueError
	find()	查找子串substr第一次出现的位置，如果查找的子串不存在时，则返回-1
	rfind()	查找了串substr最后一次出现的位置，如果查找的子串不存在时，则返回-1

通常选用 .find() .rfind() 不会报错

print('--------------------76.字符串的常用操作-字符串查询操作------------------')
s='hello,hello'
print(s.index('lo'))      #3
print(s.find('lo'))       #3
print(s.rindex('lo'))     #9
print(s.rfind('lo'))      #9
#print(s.index('k'))       ValueError: substring not found
print(s.find('k'))
#print(s.rindex('k'))
print(s.rfind('k'))

--------------------76.字符串的常用操作-字符串查询操作------------------
3
3
9
9
-1
-1

77. 字符串的常用操作-字符串大小写转换操作

功能	方法名称	作用
大小写转换	upper()	把字符串中所有字符都转成大写字母
	lower()	把字符串中所有字符都转成小写字母
	swapcase()	把字符串中所有大写字母转成小与字母，把所有小写字母都转成大写字母
	capitalize()	把第一个字符转换为大写，把其余字符转换为小写
	title()	把每个单词的第一个字符转换为大与，把每个单词的剩余字符转换为小写

print('--------------------77.字符串的常用操作-字符串大小写转换操作------------------')
s='hello,python'
a=s.upper()                 #转成大写之后会产生一个新的字符串对象
print(a,id(a))
print(s,id(s))

b=s.lower()                 #转成小写之后会产生一个新的字符串对象
print(b,id(b))
print(s,id(s))
#print(s.lower(),id(s.lower()))
print(b==s)             #True 内容相同
print(b is s)           #False 地址不同 没有驻留

s2='hello,Python'
c=s2.swapcase()
print(c,id(c))

d=s2.title()
print(d,id(d))

e=s2.capitalize()
print(e,id(e))

--------------------77.字符串的常用操作-字符串大小写转换操作------------------
HELLO,PYTHON 1945326004528
hello,python 1945325971504
hello,python 1945326004592
hello,python 1945325971504
True
False
HELLO,pYTHON 1945326004656
Hello,Python 1945326004720
Hello,python 1945326004784

78. 字符串的常用操作-字符串内容对齐操作

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

print('--------------------78.字符串的常用操作-字符串内容对齐操作------------------')
s='hello,Python'
print('居中')
print(s.center(20,"*"))
print(s.center(20))
print('左对齐')
print(s.ljust(20,'*'))
print(s.ljust(10))      #宽度小，返回原字符
print(s.ljust(20,))
print('右对齐')
print(s.rjust(20,'*'))
print(s.rjust(20))
print(s.rjust(10))     #宽度小，返回原字符
print('右对齐2')
print(s.zfill(20))      #左边用0补齐
print(s.zfill(10))
print('-8910'.zfill(8))    #-0008910,减号也算一位

--------------------78.字符串的常用操作-字符串内容对齐操作------------------
居中
****hello,Python****
hello,Python
左对齐
hello,Python********
hello,Python
hello,Python
右对齐
********hello,Python
hello,Python
hello,Python
右对齐2
00000000hello,Python
hello,Python
-0008910

79. 字符串的常用操作-字符串的劈分

功能	方法名称
字符串的劈分	split()	从字符串的左边开始劈分，默认的劈分字符是空格字符串，返回的值都是一个列表
		以通过参数sep指定劈分字符串是的劈分符
		通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大次劈分之后，剩余的子串会单独做为一部分
	rsplit()	从字符串的右边开始劈分，默认的劈分字符是空格字符串，返回的值都是一个列表
		以通过参数sep指定劈分字符串是的劈分符
		通过参数xsplit指定劈分字符串时的最大劈分次数，在经过最大次劈分之后，剩余的了串会单独做为一部分

print('--------------------79.字符串的常用操作-字符串的劈分------------------')
s='hello world Python'
print('---split 从左侧劈分---')
lst=s.split()
print(lst)
s1='hello|world|python'
print(s1.split())   #['hello|wprld|python']  没有空格
print(s1.split(sep='|'))
print(s1.split(sep='|',maxsplit=1))

print('---rsplit 从右侧劈分---')
print(s.rsplit())
print(s1.rsplit('|'))
print(s1.rsplit(sep="|",maxsplit=1))

--------------------79.字符串的常用操作-字符串的劈分------------------
---split 从左侧劈分---
['hello', 'world', 'Python']
['hello|world|python']
['hello', 'world', 'python']
['hello', 'world|python']
---rsplit 从右侧劈分---
['hello', 'world', 'Python']
['hello', 'world', 'python']
['hello|world', 'python']

80. 字符串的常用操作-字符串判断的相关方法

功能	方法名称	作用
判断字符串的方法	isidentifier()	判断指定的字符串是不是合法的标识符 à 字母、数字、下划线
	isspace()	判断指定的字符串是否全部由空白字符组成（回车、换行，水平制表符）
	isalpha()	判断指定的字符串是否全部由字母组成（数字不是字母，英文汉字都可）
	isdecimal()	判断指定字符串是否全部由十进制的数字组成
	isnumeric()	判断指定的字符串是否全部由数字组成（123，一二三四，ⅠⅡⅢⅣ）
	isalnum()	判断指定字符串是否全部由字母和数字组成（汉子，英文都可）

print('--------------------80.字符串的常用操作-字符串判断的相关方法------------------')
s='hello,python'
print('1.',s.isidentifier())  # False   --> 字母数字下划线
print('2.','hello'.isidentifier())
print('3.','张三_'.isidentifier())
print('4.','张三_123'.isidentifier())

print('5.','\t'.isspace())           #True

print('6.','acb'.isalpha())          #True
print('7.','张三'.isalpha())          #True
print('8.','张三33'.isalpha())        #False

print('9.','123'.isdecimal())         #True
print('10.','123四'.isdecimal())      #False
print('11.','ⅠⅡⅢ'.isdecimal())     #False

print('12.','123'.isnumeric())         #True
print('13.','123四'.isnumeric())       #True
print('14.','ⅠⅡⅢ'.isnumeric())       #True
print('15.','一二三四九'.isnumeric())     #True

print('16.','abc1'.isalnum())            #True
print('17.','张三123'.isalnum())        #True
print('18.','abc!'.isalnum())        #False
print('19.','abc张三666'.isalnum())       #True

--------------------80.字符串的常用操作-字符串判断的相关方法------------------
1. False
2. True
3. True
4. True
5. True
6. True
7. True
8. False
9. True
10. False
11. False
12. True
13. True
14. True
15. True
16. True
17. True
18. False
19. True

81. 字符串的常用操作-替换与合并

功能	方法名称	作用
字符串替换	replace()	第1个参数指定被替换的子串，第2个参数指定替换子串的字符串，该方法返回替换后得到的字符串，替换前的字符串不发生变化，调用该方法时可以通过第3个参数指定最大替换次数
字符串的合并	join()	将列表或元组中的字符串合并成一个字符串

print('--------------------81.字符串的常用操作-替换与合并------------------')
print('----替换---')
s='hello,Python'
print(s.replace('Python','Java'))
print(s.replace('python','Java'))  #未找到替换对象，原样输出
s1='hello,Python,Python'
print(s1.replace('Python','Java',1))
print(s1.replace('Python','Java',2))
print(s1.replace('Python','Java',3))

s1='hello,Python,Python,Python'
print(s1.replace('Python','Java',3))

lst=['hello','java','Python']
print('|'.join(lst))
print(''.join(lst))

t=('hello','java','Python')
print(''.join(t))

print('*'.join('python'))     #连接字符串，将其作为字符串序列

--------------------81.字符串的常用操作-替换与合并------------------
----替换---
hello,Java
hello,Python
hello,Java,Python
hello,Java,Java
hello,Java,Java
hello,Java,Java,Java
hello|java|Python
hellojavaPython
hellojavaPython
p*y*t*h*o*n

82. 字符串的比较操作

（1）运算符：>,>=,<,<=,==,!=

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

（3）比较原理：两上字符进行比较时，比较的是其ordinal value（原始值），调用内置函数ord可以得到指定字符的ordinal value。

与内置函数ord对应的是内置函数chr，调用内置函数chr时指定ordinal value可以得到其对应的字符

print('--------------------82.字符串的比较操作------------------')
print('apple'>'app')       #True
print('apple'>'banana')   #False

print(ord('a'),ord('b'))   #获取原始值
print(ord('王'))

print(chr(97),chr(98))
print(chr(29579))

print('''== 与 is 的区别
== 比较的是 value
is 比较的是 id ''')

a=b='python'
c='python'
print(a==b)        #True
print(a==c)       #True

print(a is b)      #True
print(a is c)      #True

print(id(a))
print(id(b))
print(id(c))

--------------------82.字符串的比较操作------------------
True
False
97 98
29579
a b
王
== 与 is 的区别
== 比较的是 value
is 比较的是 id
True
True
True
True
1945324197624
1945324197624
1945324197624

83. 字符串的切片操作

（1）字符串是不可变类型

① 不具备增、删、改等操作

② 切片操作将产生新的对象

print('--------------------83.字符串的切片操作------------------')
s='hello,Python'
s1=s[:5]      #由于没有指定起始位置，所以从0号为开始
s2=s[6:]     #由于没有指定结束位置，所以切到字符串的最后一个位置
s3='!'
newstr=s1+s3+s2

print(s1)
print(s2)
print(newstr)

print('--------')
print(id(s))
print(id(s1))
print(id(s2))
print(id(s3))
print(id(newstr))

print('---切片 [start:end:step]---')
print(s[1:5:1])    # [1,5)，步长为1
print(s[::2])       #[0开始，结束），步长2，及两个元素之间的索引间隔为2
print(s[::-1])       #[字符串最后一个开始，字符串第一个],因为步长为负数

print(s[-6:-1:1])
print(s[-6::1])

--------------------83.字符串的切片操作------------------
hello
Python
hello!Python
--------
1945325971568
1945324196168
1945323352168
1945326494864
1945326004656
---切片 [start:end:step]---
ello
hloPto
nohtyP,olleh
Pytho
Python

84. 格式化字符串的两种方式

（1）为什么要格式化字符串

格式化字符串——以一定格式输出的字符串

（2）格式化字符串的两种方式

① % 做占位符

%s —— 字符串

%i或%d —— 整数

%f —— 浮点数

② { } 做占位符

其中，0,1，表示索引

③ f-string

print('--------------------84.格式化字符串------------------')
name='A'
age=18
weight=108
print('--① % 做占位符--')
print('我叫%s,今年%d岁' % (name,age))

print('--② {} 做占位符--')
print('我叫{0},现在{1}斤，我真的只有{1}斤'.format(name,weight))

print('--③f-string--')
print(f'我叫{name}，体重{weight}斤')

print('--精度与纬度（宽度）--')
print('%d' % 99)
print('%10d' % 99)             #10表示宽度
print('1234567890')

print('%f' % 3.1415926)
print('%.3f' % 3.1415926)      # .3 保留小数点后三位

print('%10.3f' % 3.14159)       #总宽度为10，小数点后3位

print('--另一种方法--')
print('{0}'.format(3.1415926))
print('{0:.3}'.format(3.14159))     #.3 表示一共3位数
print('{0:.3f}'.format(3.14159))    #.3f 表示3位小数
print('{0:10.3f}'.format(3.14159))   #10.3f 同时设置精度和纬度，一共十位，保留3位小数

--------------------84.格式化字符串------------------
--① % 做占位符--
我叫A,今年18岁
--② {} 做占位符--
我叫A,现在108斤，我真的只有108斤
--③f-string--
我叫A，体重108斤
--精度与纬度（宽度）--
99
99
1234567890
3.141593
3.142
3.142
--另一种方法--
3.1415926
3.14
3.142
3.142

85. 字符串的编码与解码（查重）

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

（2）编码与解码的方式

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

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


print('--------------------85.字符串的编码与解码------------------')
s='天涯共此时'
print('---编码---')
print(s.encode(encoding='GBK'))     # GBK --> 这种编码格式中，一个中文占两个字节  b`表示byte类型
print(s.encode(encoding='UTF-8'))   # UTF-8 --> 这种编码格式中，一个中文占3个字节  b`表示byte类型

print('---解码---')
#byte 代表的就是一个二进制数据（字节类型数据）
byte=s.encode(encoding='GBK')
print(byte.decode(encoding='GBK'))
#print(byte.decode(encoding='utf-8')) UnicodeDecodeError: 'utf-8' codec can't decode byte 0xcc in position 0: invalid continuation byte

byte=s.encode(encoding='UTF-8')
print(byte.decode(encoding='utf-8'))   #编码与解码格式一定要相同

--------------------85.字符串的编码与解码------------------
---编码---
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'
---解码---
天涯共此时
天涯共此时

默默耕耘的lanjing

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Python 课程学习笔记（8）字符串

第九章字符串75. 字符串的创建于驻留机制76. 字符串的常用操作-字符串查询操作77. 字符串的常用操作-字符串大小写转换操作78. 字符串的常用操作-字符串内容对齐操作79. 字符串的常用操作-字符串的劈分80. 字符串的常用操作-字符串判断的相关方法81. 字符串的常用操作-替换与合并82. 字符串的比较操作83. 字符串的切片操作84. 格式化字符串的两种方式85. 字符串的编码与解码（查重）75. 字符串的创建与驻留机制（1）字符串..
复制链接

扫一扫