Python基础-字符串

分类 Python 标签 Python 评论:
  1. 字符串
    1. 创建字符串的两种方式
    2. 转义字符
    3. 原样字符串
    4. 跨越多行的字符串
    5. 使用加法和乘法操作字符串
    6. 在字符串中查找子串索引
    7. 两个字符串进行比较
    8. 字符串反转
    9. 字符串的排序
  2. 格式化字符串
    1. 用百分号作为占位符
    2. 用花括号作为占位符
  3. 字符串大小写转换
  4. 字符串的对齐
  5. 字符串的子串替换
  6. 字符串的字符转换
  7. 字符串的拆分和合并
  8. 去除字符串的前导字符串或后续字符串
  9. 字符串中以is开头的方法
  10. 字符串其他方法

字符串

字符串是不可变类型，没有改、增、删操作
字符串也属于序列类型，可以将字符串看作是字符的列表，因此列表的操作对于字符串也是适用的

创建字符串的两种方式

1、 适用引号，既可以适用单引号，也可以适用双引号，通常适用单引号，不能在单引号中使用单引号，也不能在双引号中使用双引号

>>> s = 'abcd'
>>> s
'abcd'

>>> s = ''             ##空字符串
>>> s
''

2、适用内置函数str()

>>> s = str('abcd')
>>> s
'abcd'

>>> str(123)
'123'
>>> str(123.1)
'123.1'


>>> a = 123
>>> str(a)
'123'

转义字符

符号 说明
' 单引号
" 双引号
\a 发出系统响铃
\b 退格符
\n 换行符
\t 横向制表符（TAB）
\v 纵向制表符
\r 回车符
\f 换页符
\o 八进制数代表的字符
\x 十六进制代表的字符
\0 表示一个空字符
\ 反斜杠

原样字符串

原样字符串的最后一个字符不能是反斜杠（最后两个字符都是反斜杠除外）

>>> print(r'\t\n')
\t\n

>>> print(r'hello world\')
  File "<stdin>", line 1
    print(r'hello world\')
                         ^
SyntaxError: EOL while scanning string literal
>>>
>>> print(r'hello world\\')
hello world\\

跨越多行的字符串

>>> print('''asdfa
... sadfasd
... asdfasdf
... ''')
asdfa
sadfasd
asdfasdf

使用加法和乘法操作字符串

>>> print('Hello, ' + 'World!')
Hello, World!

>>> print('haha, ' * 3)
haha, haha, haha,

在字符串中查找子串索引

当获得字符串中指定子串的索引时，除了调用方法index，还可以调用方法find、rfind、rindex，其中，子串的索引指的是子串中第一个字符的索引
index和find从左边开始查找，返回的是第一个子串的索引，rindex和rfind从右边开始查找，返回的是最后一个子串的索引

>>> s = '123456678966789'
>>> s.index('66')
5
>>> s.find('66')
5
>>> s.rindex('66')
10
>>> s.rfind('66')
10

index和rindex在找不到子串时抛出异常，而find和rfind找不到子串时返回-1

>>> s.index('62')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found
>>>
>>> s.rindex('62')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found
>>> s.rfind('62')
-1
>>>
>>> s.find('62')
-1
>>>

该四种查找方法还可以指定查找范围，例如：

>>> s.find('66', 7, 13)
10
>>> s.rfind('66', 7, 13)
10
>>> s.index('66', 7, 13)
10
>>> s.rindex('66', 7, 13)
10

两个字符串进行比较

和列表比较类似，首先比较两个字符串中的第一个字符，如果相等，则继续比较下一个字符，依次比较下去，直到两个字符串中的字符不相等时其比较结果就是两个字符串的比较结果，两个字符串中的所有后续字符，将不再被比较。

两个字符比较时，比较的是其ordinal value（序数），即ASCII码。调用内置函数ord()可以得到指定字符的ASCII码（十进制）。相反，调用chr()函数可以从ASCII码得到字符

>>> ord('a')
97
>>> chr(97)
'a'

>>> ord('a')
97
>>> ord('{')
123
>>>
>>> '{' > 'a'
True

字符串常量会被缓存和重用，和整型不同的是，整型只有较小的整型才会被重用，大的整型并不会被重用

>>> a = b = 'hello'
>>> c = 'hello'
>>> id(a)
139932323278384
>>> id(b)
139932323278384
>>> id(c)
139932323278384

字符串反转

与列表不同的是，字符串是不可变类型，因此我们如果想对字符串所有字符进行反转，不存在方法reverse()，只能调用内置函数reversed()。

>>> s = 'abcde'
>>> s1 = reversed(s)
>>> s1
<reversed object at 0x7f44886bee80>

>>> print(list(s1))
['e', 'd', 'c', 'b', 'a']

字符串的排序

与列表不同的是，字符串是不可变类型，因此我们如果想对字符串所有字符进行排序，不存在方法sort()，只能调用内置函数sorted()。

>>> s = 'aEdFcfRjK'

>>> sorted(s)
['E', 'F', 'K', 'R', 'a', 'c', 'd', 'f', 'j']

>>> sorted(s, reverse = True)                       ##反向排序
['j', 'f', 'd', 'c', 'a', 'R', 'K', 'F', 'E']

>>> s
'aEdFcfRjK'

调用内置函数sorted()时，还可以指定参数key = 函数名，或者key = 类名.方法名，这样会对字符串中的所有字符分别调用指定的函数或方法，然后按照函数或方法的返回值进行排序，从而自定义排序规则

>>> sorted(s, key = str.lower)
['a', 'c', 'd', 'E', 'F', 'f', 'j', 'K', 'R']
>>>
>>> sorted(s, key = str.upper)
['a', 'c', 'd', 'E', 'F', 'f', 'j', 'K', 'R']

格式化字符串

用百分号作为占位符

常见的占位符有：

占位符 说明
%nd 整数，n表示宽度
%.nf 浮点数，.n表示保留几位小数
%s 字符串
%o 八进制整数
%x 十六进制整数
%X 大写十六进制整数
%% %转义

不确定使用哪种占位符，那么%s永远起作用，他会把任何数据类型转换为字符串

>>> print('%s先生，你%d月的实时话费%.2f元，可用余额%.2f元。' %('jerry', 5, 20, 50))
jerry先生，你5月的实时话费20.00元，可用余额50.00元。

如果定义的格式化字符串中的%是一个普通字符，需要使用%%对其进行转义，注意，这里并不是通过\来进行转义

>>> print('我的工作已经完成了%d%%' %(80))
我的工作已经完成了80%

占位符%中可以指定宽度，数字和字符串都是右对齐

>>> print('%10d' %(10))
        10

>>> print('%10s' %('ab'))
        ab

占位符%中可以指定精度

>>> print('%.3f' %(3.1415926))
3.142

>>> print('%.3s' %('hello'))
hel

用花括号作为占位符

使用format方法并使用花括号作为占位符，来进行格式化输出

位置化参数，例如：

>>> '{0} love {1}!'.format('I', 'you')
'I love you!'

>>> '{0} love {1}! {0} love python'.format('I', 'you')
'I love you! I love python'

关键字参数，例如：

>>> '{a} love {b}!'.format(a='I',b='you')
'I love you!'

{}中不指定参数，方法format的参数会按顺序依次匹配所有占位符{}，但是format()的参数不能少于占位符，否则不够匹配，抛出异常

>>> '{} love {}! {} love python'.format('I', 'you')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: tuple index out of range


>>> '{} love {}! love python'.format('I', 'you')
'I love you! love python'

>>> '{} love {}! love python'.format('I', 'you', 'yes')
'I love you! love python'

占位符{}中可以使用冒号指定整数的表示形式，其中，位置参数或关键字参数的名称放在冒号前面

##转换为二进制数
>>> '{:b}'.format(118)                     
'1110110'

##指定十六进制a-f是小写
>>> '{:x}'.format(111)                     
'6f'

##指定十六进制A-F是大写
>>> '{:X}'.format(111)                     
'6F'

##指定浮点数保留1位小数
>>> '{0:.1f}{1}'.format(35.56,'GB')
'35.6GB'

##包括整数位总共3位
>>> '{0:.3}{1}'.format(35.56,'GB')
'35.6GB'

##使用逗号作为千位分隔符
>>> '{:,}'.format(123456789)
'123,456,789'

##位置参数或关键字参数的名称放在冒号前面
>>> '{0:b}'.format(118)
'1110110'
>>> '{a:b}'.format(a = 118)
'1110110'

占位符{}中还可以使用冒号指定宽度，其中，数字是右对齐，字符串是左对齐

>>> '{a:10}'.format(a = 118)
'       118'
>>> '{a:10}'.format(a = '118')
'118       '

##同时指定宽度和精度
>>> '{0:8.2f}{1}'.format(35.5666,'GB')
'   35.57GB'

':m'.format(n) 等价于format(n, 'm')

>>> '{:.1f}'.format(35.56)
'35.6'

>>> format(35.6, '.1f')
'35.6'

使用美元符作为占位符，导入string模块，使用其Template方法

>>> import string

>>> a = 'I'
>>> b = 'you'

>>> tmpl = string.Template('$x love $y')
   
>>> tmpl.substitute(x = a, y = b)
'I love you'

##使用字典
>>> tmpl.substitute({'x':a, 'y':b})
'I love you'

safe_substitute()，占位符没有匹配的实际值时，不会抛出异常，而是使用占位符本身作为其实际值

>>> tmpl.substitute(x = a)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/local/python3/lib/python3.7/string.py", line 132, in substitute
    return self.pattern.sub(convert, self.template)
  File "/usr/local/python3/lib/python3.7/string.py", line 125, in convert
    return str(mapping[named])
KeyError: 'y'
>>>

>>> tmpl.safe_substitute(x = a)
'I love $y'

字符串大小写转换

可以调用字符串的以下方法：

  1. upper()：把所有字符转化为大写
  2. lower()：把所有字符转化为小写
  3. swapcase()：把所有小写转化为大写，大写转化为小写
  4. capitalize()：把第一个字符转换为大写，把其余字符转化为小写
  5. title()：把每个单词的第一个字符转化为大写，把每个单词的剩余字符转化为小写
>>> s = 'I love Python'

>>> s.upper()
'I LOVE PYTHON'

>>> s.lower()
'i love python'

>>> s.swapcase()
'i LOVE pYTHON'

>>> s.capitalize()
'I love python'

>>> s.title()
'I Love Python'

判断字符串中某些字符的大小写，可以调用字符串的以下方法：

  1. isupper()：是否所有字符全为大写
  2. islower()：是否所有字符全为小写
  3. istitle()：是否每个单词的第一个字符为大写，并且每个单词的剩余字符为小写
>>> s
'I love Python'

>>> s.isupper()
False

>>> s.islower()
False

>>> s.istitle()
False

字符串的对齐

如果想要设置字符串的对齐方式，可以调用字符串的以下方法：

  1. center()：中心对齐
  2. ljust()：左对齐
  3. rjust()：右对齐

这三个方法都可以接收两个参数，其中
第一个参数指定字符串的宽度，如果指定的宽度小于等于字符串的长度，则返回字符串本身
第二个参数指定填充字符，且第二个参数时可选的，默认值是空值

>>> s = 'Hello,world!'

##center()
>>> s.center(21, '-')
'-----Hello,world!----'

>>> s.center(21)
'     Hello,world!    '

>>> s.center(10)
'Hello,world!'

##ljust()
>>> s.ljust(21, '-')
'Hello,world!---------'

>>> s.ljust(21)
'Hello,world!         '

>>> s.ljust(10)
'Hello,world!'

##rjust
>>> s.rjust(21, '-')
'---------Hello,world!'

>>> s.rjust(21)
'         Hello,world!'

>>> s.rjust(10)
'Hello,world!'
  1. zfill()：右对齐，左边用0填充
    该方法只接收一个参数，用于指定字符串的宽度，如果指定的宽度小于等于字符串的长度，则返回字符串本身
>>> s.zfill(21)
'000000000Hello,world!'

>>> s = '-Hello,world!'             
>>> s.zfill(21)
'-00000000Hello,world!'          ##注意，这里的负号是在填充的首部，可用于数字的表示

>>> s.zfill(10)
'-Hello,world!'

字符串的子串替换

如果想讲字符串中的子串替换为指定的字符串，可以调用方法replace()，该方法的第一个参数指定被替换的子串，第二个参数指定替换子串的字符串。
该方法返回替换后得到的字符串，替换前的字符串不发生变化。

>>> s = 'abc-abc-abc'
>>> s.replace('abc', 'haha')
'haha-haha-haha'
>>> s
'abc-abc-abc'

还可以指定第三个参数来指定最大替换个数

>>> s.replace('abc', 'haha', 2)
'haha-haha-abc'

字符串的字符转换

如果想对字符串中的某些字符进行转换，可以调用方法maketrans和translate，两者结合使用。会将所有字符全都转换。
首先调用方法maketrans创建一个转换表，然后把创建的转换表作为参数传给方法translate。

>>> s = 'abcdefg'

##创建转换表
>>> table = str.maketrans('abc', '123')
>>> print(table)
{97: 49, 98: 50, 99: 51}                  ##{ a :  1,  b : 2,  c: 3}，就是个映射关系，其显示的是ascii码

##进行转换
>>> s.translate(table)                    ##将转换表作为参数传递，相当于把转换表进行翻译，得出结果
'123defg'

转换表还可以给定第三个参数，用于指定想要删除的字符

>>> s = 'abcdefg'
>>>
>>> table = str.maketrans('abc', '123', 'fg')
>>> print(table)
{97: 49, 98: 50, 99: 51, 102: None, 103: None}              ##f和g映射到None，相当于删除

>>> s.translate(table)
'123de'

不转换，只指定要删除的字符

>>> s = 'abcdefg'

>>> table = str.maketrans('', '', 'cde')

>>> print(table)
{99: None, 100: None, 101: None}

>>> s.translate(table)
'abfg'

字符串的拆分和合并

1、调用方法split或rsplit拆分字符串，方法split从字符串左边开始拆分，rsplit从字符串右边开始拆分，默认拆分符是空格，这两个方法的返回值都是一个列表。

>>> s = 'I love python'

>>> s.split()
['I', 'love', 'python']

>>> s.rsplit()
['I', 'love', 'python']

可以通过参数sep指定拆分字符串时的拆分符

>>> s = 'I love python!'

>>> s.split(sep = 'e')
['I lov', ' python!']

>>> s.rsplit(sep = 'e')
['I lov', ' python!']

可以通过参数maxsplit指定拆分字符串时的最大拆分次数，在经过最大次拆分后，剩余的子串会单独作为一部分，此时，方法split和rsplit就有区别了

>>> s = 'python java php js'

>>> s.split(maxsplit = 2)
['python', 'java', 'php js']

>>> s.rsplit(maxsplit = 2)
['python java', 'php', 'js']

2、调用方法partition或rpartition拆分字符串，方法partition从字符串左边开始拆分，rpartition从字符串右边开始拆分，与split不同的是，调用partition和rpartition两个方法时，都必须指定拆分符
，方法partition在指定的拆分符第一次出现的地方（rpartition在指定拆分符最后一次出现的地方），将字符串拆分为三部分：

  1. 拆分符前面的部分
  2. 拆分符
  3. 拆分符后面的部分

这两个方法的返回值都是一个元组；

>>> s = 'python-java-php-js'

>>> s.partition('-')
('python', '-', 'java-php-js')

>>> s.rpartition('-')
('python-java-php', '-', 'js')


##字符串中不存在拆分符
>>> s.partition('=')
('python-java-php-js', '', '')

>>> s.rpartition('=')
('', '', 'python-java-php-js')

3、调用方法join合并多个字符串

>>> a = ['a', 'b', 'c']
>>> '-'.join(a)
'a-b-c'

>>> b = ('1', '2', '3')
>>> '+'.join(b)
'1+2+3'

>>> '-'.join('python')
'p-y-t-h-o-n'

去除字符串的前导字符串或后续字符串

1、lstrip()方法去除前导字符串
2、rstrip()方法去除后续字符串
3、strip()方法去除前导和后续字符串
其中，默认的前导字符串和后续字符串都是空格字符串

>>> s = '       python        '

>>> s
'       python        '

>>> s.lstrip()
'python        '

>>> s.rstrip()
'       python'

>>> s.strip()
'python'

调用以上三个方法时，可以指定一个字符串，这样的话，
前导字符串指的是：从左边第一个字符开始依次往后，直到某个字符不在指定的字符串中
后续字符串指的是：从右边最后一个字符开始依次往前，直到某个字符不在指定的字符串中

>>> s = 'www.example.com'

>>> s.lstrip('cmowz.')
'example.com'

>>> s.rstrip('cmowz.')
'www.example'

>>> s.strip('cmowz.')
'example'

字符串中以is开头的方法

方法 说明
salnum()： 如果字符串至少有一个字符，且所有字符都是字母或者数字，则为True，否则为Fals
sdigit()： 如果字符串只包含数字（阿拉伯数字），则为True，否则为False
slower()： 如果字符串中至少包含一个区分大小写的字符，并且这些字符都是小写，则为True，否则为False
stitle()： 如果字符串是标题化（所有单词首字母大写，其余小写）的，则为True，否则为False
salpha()： 如果字符串至少有一个字符，且这些字符全部由字母组成，则为True，否则为False
sdecimal()： 如果字符串只包含十进制数，则为True，否则为False
sidentifier()： 判断指定的字符串是否是合法的标识符
snumeric()： 如果字符串中只包含数字（阿拉伯数字、汉语数字、罗马数字），则为True，否则为False
sspace()： 如果字符串中只由空白字符（空格、回车、TAB等）组成，则为True，否则为False
supper()： 如果字符串中至少包含一个区分大小写的字符，并且这些字符都是大写，则为True，否则为False

字符串其他方法

33975c71-2fa0-4941-98c4-c73b67f70fd6-字符串方法.jpg

转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论，也可以邮件至 289211569@qq.com

©2016-2023 Daryl