Python 字符串
字符串的驻留机制
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
| s1=''
s2=''
s1 is s2
s1='%'
s2='%'
s1 is s2
s1='abc%'
s2='abc%'
s1 == s2
s1 is s2
s1='abcd'
s2='abcd'
s1 == s2
s1='abc'
s2='ab'+'c'
s3=''.join(['ab','c'])
s1 is s2
s1 is s3
a=-5
b=-5
a is b
|
- 字符串驻留机制的优缺点
- 当需要值相同的字符串时。可以直接从字符串池里拿来使用，避免频繁的创建和销毁，提升效率和节约内存，因此拼接字符串和修改字符串是会比较影响性能的。、
- 在需要进行字符串拼接时建议使用str类型的join方法，而非+,因为join()方法是先计算出所有字符中的长度，然后再拷贝，只new一次对象，效率要比"+"效率高
字符串的常用操作
字符串的查询操作的方法
| 查询方法 | index() | 查找子串substr第一次出现的位置，如果查找的子串不存在，则抛出ValueError |
| rindex() | 查找子串substr最后一次出现的位置，如果查找的子串不存在，则抛出ValueError |
| find() | 查找子串substr第一次出现的位置,如果查找的子串不存在时，则返回-1 |
| rfind() | 查找子串substr最后一次出现的位置，如果查找的子串不存在时，则返回-1 |
1
2
3
4
5
6
7
8
9
10
| s='hello.hello'
print(s.index('lo'))
print(s.find('lo'))
print(s.rindex('lo'))
print(s.rfind('lo'))
print(s.find('k'))
print(s.rfind('k'))
|
字符串的大小写转换操作的方法
| 大小写转化 | upper() | 把字符串中所有字符都转成大写字母 |
| lower() | 把字符串中所有字符都转成小写字母 |
| swapace() | 把字符串中所有大写字母转成小写字母,把所有小写字母都转成大写字母 |
| capitalize() | 把第一个字符转换成大写,把其余字符转换成小写 |
| title() | 把每个单词的第一个字符转换成大写，把每个单词的剩余单词转换成小写 |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
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(b==s)
print(b is s)
s2='hello,Python'
print(s2.swapcase())
print(s2.title())
|
字符串内容对齐操作的方法
| 字符串对齐 | center() | 居中对齐,第1个参数指定宽度,第2个参数指定填充符,第2个参数是可选的,默认是空格,如果设置宽度小于实际宽度则返回原字符串 |
| ljust() | 左对齐,第1个参数指定宽度,第2个参数指定填充符,第2个参数是可选的,默认是空格,如果设置宽度小于实际宽度则返回原字符串 |
| rjust() | 右对齐,第1个参数指定宽度,第2个参数指定填充符,第2个参数是可选的,默认是空格如果设置宽度小于实际宽度,则返回原字符串 |
| zfill() | 右对齐,左边用0填充,该方法只接收一个参数,用于指定字符串的宽度,如果指定的宽度小于等于字符串的长度,返回字符串本身 |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| s='hello,Python'
'''居中对齐'''
print(s.center(20,'*'))
'''左对齐'''
print(s.ljust(20,'*'))
print(s.ljust(10))
print(s.ljust(20))
'''右对齐'''
print(s.rjust(20,'*'))
print(s.rjust(20))
print(s.rjust(10))
'''右对齐,使用0键填充'''
print(s.zfill(20))
print(s.zfill(10))
print('-8910'.zfill(8))
|
字符串劈分操作的方法
| 字符串的劈分 | split() | 从字符串的左边开始劈分,默认的劈分字符是空格字符串,返回的值都是一个列表 |
| | 以通过参数sep指定劈分字符串是的劈分符 |
| | 通过参数maxsplit指定劈分字符串时的最大劈分次数,在经过最大次劈分之后,剩余的子串会单独做一部分 |
| rsplit() | 从字符串的右边开始劈分,默认的劈分字符是空格字符串,返回的值都是一个列表 |
| | 以通过参数sep指定劈分字符串是劈分符 |
| | 通过参数maxsplit指定劈分字符串时的最大劈分次数,在经过最大次劈分之后,剩余的子串对单独作为一部分 |
1
2
3
4
5
6
7
8
9
10
11
12
| s='hello world Python'
lst=s.split()
print(lst)
s1='hello|world|Python'
print(s1.split(sep='|'))
print(s1.split(sep='|',maxsplit=1))
print('----------------------------------')
'''rsplit()从右侧开始劈分'''
print(s.rsplit())
print(s1.rsplit(sep='|'))
print(s1.rsplit(sep='|',maxsplit=1))
|
判断字符串操作的方法
| 判断字符串的方法 | isidentifier() | 判断指定的字符串是不是合法的标识符 |
| isspqce() | 判断指定的字符串是否全部有空白字符组成(回车、换行、水平制表符) |
| isalpha() | 判断指定的字符串是否全部有字母组成 |
| isdecimal() | 判断指定的字符串是否全部有十进制的数字组成 |
| isnumeric() | 判断指定的字符串是否全部由数字组成 |
| isalnum() | 判断指定字符串是否全部由字母和数字组成 |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| s='hello,python'
print('1.',s.isidentifier())
print('2.','hello'.isidentifier())
print('3.','张三_'.isidentifier())
print('4.','张三_123'.isidentifier())
print('5.','\t'.isspace())
print('6.','abc'.isalpha())
print('7.','张三'.isalpha())
print('8.','张三1'.isalpha())
print('9.','123'.isdecimal())
print('10.','123四'.isdecimal())
print('11.','ⅠⅡⅢ'.isdecimal())
print('12.','123'.isnumeric())
print('13.','123四'.isnumeric())
print('14.','ⅠⅡⅢ'.isnumeric())
print('15.','abc1'.isalnum())
print('16.','张三123'.isalnum())
print('17.','abc~'.isalnum())
|
字符串操作的其他方法
| 字符串替换 | replace() | 第1个参数指定被替换的子串,第2个参数指定替换子串的字符串,该方法返回替换后得到的字符串,替换前的字符串不发生变化,调用该方法时可以通过第3个参数指定最大替换次数 |
| 字符串的合并 | join() | 将列表或元组的字符串合并成一个字符串 |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| s='hello,Python'
print(s.replace('Python','Java'))
s1='hello,Python,Python,Python'
print(s1.replace('Python','Java',2))
lst=['hello','java','Python']
print('|'.join(lst))
print(''.join(lst))
t=('hello','java','Python')
print(''.join(t))
print('*'.join('Python'))
|
字符串的比较操作
字符串的比较操作
- 运算符:>,>=,<,<=,==,!=
- 比较规则:首先比较两个字符串中的第一个字符，如果相等则继续比较下一个字符，依次比较下去，直到两个字符串中的字符不相等时，其比较结果就是两个字符串的比较结果，两个字符串中的所有后续字符将不再被比较
- 比较原理:两上字符进行比较时，比较的是其ordinal value(原始值)调用内置函数ord可以得到指定字符的ordinal value。与内置函数ord对应的是内置函数chr,调用内置函数chr时指定ordinal value可以得到其对应的字符
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| print('apple'>'app')
print('apple'>'banana')
print(ord('a'),ord('b'))
print(ord('冯'))
print(chr(97),chr(98))
print(chr(20911))
'''==与is的区别'''
'''==比较的是值
is 比较的是地址
'''
a=b='Python'
c='Python'
print(a==b)
print(a==c)
print(a is b)
print(a is c)
print(id(a))
print(id(b))
print(id(c))
|
字符串的切片操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| s='hello,Python'
s1=s[:5]
s2=s[6:]
s3='!'
newstr=s1+s3+s2
print(s1)
print(s2)
print('--------------')
print(newstr)
print(id(s))
print(id(s1))
print(id(s2))
print(id(s3))
print(id(newstr))
print('-------------切片[start:stop:step]--------------')
print(s[1:5:1])
print(s[::2])
print(s[::-1])
print(s[-6::])
|
格式化字符串
为什么需要格式化字符串
在python中我们会遇到一个问题，问题是如何输出格式化的字符串。我们经常会输出类似'亲爱的xxx你好！你xx月的话费是xx，余额是xx'之类的字符串，而xxx的内容都是根据变量变化的，所以，需要一种简便的格式化字符串的方式。
格式化字符串的两种方式
031
2
3
4
5
6
7
8
9
10
11
|
name='张三'
age=20
print('我叫%s,今年%d岁'%(name,age))
print('我叫{0},今年{1}岁'.format(name,age))
print(f'我叫{name},今年{age}岁')
|
1
2
3
4
5
6
7
| print('%10d'% 99)
print('hellohello')
print('%.3f' % 3.1415926)
print('%10.3f'%3.1415926)
print('hellohello')
|
1
2
3
4
5
6
7
8
| print('{0:.3}'.format(3.1415926))
print('{0:.3f}'.format(3.1415926))
print('{0:10.3f}'.format(3.1415926))
print('hellohello')
|
字符串的编码转换
- 编码与解码的方式
- 编码:将字符串转换为二进制数据(bytes)
- 解码:将bytes类型的数据转换成字符串类型
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| s='天涯共此时'
print(s.encode(encoding='GBK'))
print(s.encode(encoding='UTF-8'))
byte=s.encode(encoding='GBK')
print(byte.decode(encoding='GBK'))
byte=s.encode(encoding='UTF-8')
print(byte.decode(encoding='UTF-8'))
|
