Python数据类型之字符串类型

Python系列 评论

字符串类型(string)

字符串介绍

定义方式

在单引号、双引号、三引号内，由一串字符组成

1
2
3
4
5
6
7
8
9
10
11
#单引号
name='Elijah'

#双引号
title="Python developer"

#三引号，表示多行的字符串，可以在三引号中自由的使用单引号和双引号
message=
'''
立志成为一名"身体健康"的'开发者'
'''

★常用字符串方法

strip() / lstrip() / rstrip() 去除指定字符串(默认去除空格)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# strip() 去掉字符串前后的空格(默认情况下)
>>> s = "   Hello World   "
>>> s.strip()
"Hello World"

# lstrip() 去掉字符串左边(left)的空格(默认情况下)
>>> s = "   Hello World   "
>>> s.lstrip()
"Hello World   "

# rstrip() 去掉字符串右边(right)的空格(默认情况下)
>>> s = "   Hello World   "
>>> s.rstrip()
"   Hello World"

# strip("str_args") 去掉字符串前后的指定字符(传入指定字符参数情况下)
# lstrip("str_args")与rstrip("str_args")同理
>>> s = "***Hello World***"
>>> s.strip('*')
"Hello World"

startswith() / endswith() 判断字符串开头/结尾

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# startswith("str_args") 判断目标字符串是否以指定字符串开头
>>> s="Hello_World"
>>> s.startswith("Hello")
True

>>> s="Hello_World"
>>> s.startswith("ello")
False

# endswith("str_args") 判断目标字符串是否以指定字符串结尾
>>> s="Hello_World"
>>> s.endswith("World")
True

>>> s="Hello_World"
>>> s.endswith("Worl")
False

replace() 替换字符串

语法说明

str.replace(old, new[, max])

参数说明

  • old – 将被替换的子字符串。
  • new – 新字符串，用于替换old子字符串
  • max – 可选字符串, 替换不超过 max 次
1
2
3
4
5
6
7
8
# replace() 替换字符串，传入参数依次为旧字符串、新字符串、替换最大次数
>>> s="Hello World"
>>> s.replace("World","Python")
"Hello Python"

>>> s="In the apple case, there is a red apple beside the green apple."
>>> s.replace("apple","peach",2)
"In the peach case, there is a red peach beside the green apple."

format() 格式化字符串

语法说明

  • 格式化字符串的函数 str.format()，它增强了字符串格式化的功能
  • 基本语法是通过 {} 和 : 来代替以前的 %
  • format 函数可以接受不限个参数，位置可以不按顺序
1
2
3
4
5
6
7
8
9
10
11
# format() 格式化字符串，不设置指定位置，按默认顺序
>>>"{} {}".format("hello", "world")
'hello world'

# format() 格式化字符串，设置指定位置
>>> "{arg_2} {arg_1}".format(arg_2="hello", arg_1="world")
'hello world'

# format() 格式化字符串，设置指定位置
>>> "{1} {0} {1}".format("hello", "world")
'world hello world'
  • 2.4.1 数字格式化

    下表展示了 str.format() 格式化数字的多种方法：

1
2
>>> print("{:.2f}".format(3.1415926));
3.14

格式化符号说明

  • ‘^’、’<’、’>’ 分别是居中、左对齐、右对齐，后面带宽度， ‘:’ 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。
  • ‘+’ 表示在正数前显示 ‘+’，负数前显示 ‘-‘
  • ‘ ‘（空格）表示在正数前加空格
  • ‘b’、’d’、’o’、’x’ 分别是二进制、十进制、八进制、十六进制。
  • 此外我们可以使用大括号 ‘{}’ 来转义大括号，如下实例
1
2
>>> print ("{} 对应的位置是 {{0}}".format("yang"))
yang 对应的位置是 {0}
数字 格式 输出 描述
3.1415926 {:.2f} 3.14 保留小数点后两位
3.1415926 {:+.2f} +3.14 带符号保留小数点后两位
-1 {:+.2f} -1.00 带符号保留小数点后两位
2.71828 {:.0f} 3 不带小数
5 {:0>2d} 05 数字补零 (填充左边, 宽度为2)
5 {:x<4d} 5xxx 数字补x (填充右边, 宽度为4)
10 {:x<4d} 10xx 数字补x (填充右边, 宽度为4)
1000000 {:,} 1,000,000 以逗号分隔的数字格式
0.25 {:.2%} 25.00% 百分比格式
1000000000 {:.2e} 1.00e+09 指数记法
13 {:10d} 13 右对齐 (默认, 宽度为10)
13 {:<10d} 13 左对齐 (宽度为10)
13 {:^10d} 13 中间对齐 (宽度为10)
11 ‘{:b}’.format(11) 1011 进制
‘{:d}’.format(11) 11
‘{:o}’.format(11) 13
‘{:x}’.format(11) b
‘{:#x}’.format(11) 0xb
‘{:#X}’.format(11) 0xB

find() / rfind() 查找字符串位置、index() / rindex() 查找字符串位置、count() 查找字符串出现次数

语法说明
find()

str.find(str, beg=0, end=len(string))

index()

str.index(str, beg=0, end=len(string))

count()

str.count(str, beg= 0,end=len(string))

参数说明

  • str – 指定检索的字符串
  • beg – 开始索引，默认为0
  • end – 结束索引，默认为字符串的长度

返回值
find()

如果包含子字符串返回开始的索引值，否则返回-1。
rfind() 返回字符串最后一次出现的位置，其他属性与find()相同

index()

如果包含子字符串返回开始的索引值，否则报异常。
rindex() 返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常，可以指定可选参数[beg:end]设置查找的区间。

count()

该方法返回子字符串在字符串中出现的次数,顾头不顾尾,如果不指定范围则查找所有

  • find() / rfind() 查找字符串位置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# find() 查找字符串位置/ rfind()返回字符串最后一次出现的位置，其他属性与find()相同

# 从下标0开始，查找在字符串里第一个出现的子串，返回结果：0
>>> s='abca'
>>> s.find('a')
0

# 从下标1开始，查找在字符串里第一个出现的子串：返回结果3
>>> s='abca'
>>> s.find('a',1)
3

# 查找不到返回-1
>>> s='abca'
>>> s.find('3')
-1
>>>
  • index() / rindex() 查找字符串位置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# index() 查找字符串位置/ rindex()返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常，可以指定可选参数[beg:end]设置查找的区间。

# 从下标0开始，查找在字符串里第一个出现的子串，返回结果：0
>>> s='abca'
>>> s.index('a')
0
# 从下标1开始，查找在字符串里第一个出现的子串：返回结果3
>>> s='abca'
>>> s.index('a',1)
3
# 查找不到报异常
>>> s='abca'
>>> s.find('3')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found
  • count() 查找字符串出现次数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# count() 该方法返回子字符串在字符串中出现的次数,顾头不顾尾,如果不指定范围则查找所有。

# 查找a出现的次数，没有指定范围默认查找所有
>>> s='abca'
>>> s.count('a')
2

# 查找a出现的次数，指定范围从1到4,返回1次
>>> s='abca'
>>> s.count('a',1,4)
1

# 查找z出现的次数，没有则返回0次
>>> s='abca'
>>> s.count('z')
0

split() / rsplit() 切分字符串

语法说明

str.split(str=””, num=string.count(str))

参数说明

  • str – 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
  • num – 分割次数。

返回值

返回分割后的字符串列表。返回分割后的字符串列表。
rsplit()表示从右向左开始切分

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# split() 通过指定分隔符对字符串进行切片，如果参数num 有指定值，则仅分隔 num 个子字符串 / rsplit() 表示从右向左开始进行切分，其他同split()

# 默认以空格进行分割，也就是下例中的\n
>>> s="Line1-abcdef \nLine2-abc \nLine4-abcd";
>>> s.split( )
['Line1-abcdef', 'Line2-abc', 'Line4-abcd']

# 指定的切片次数为1次，所以后面的两个\n保留
>>> s.split(' ', 1 )
['Line1-abcdef', '\nLine2-abc \nLine4-abcd']

# rsplit() 从右向左以'|'字符进行切分，切分次数为1次
>>> s='a|b|c'
>>> s.rsplit('|',1)
['a|b', 'c']

join() 连接字符串

语法说明

str.join(sequence)

参数说明

  • sequence – 要连接的元素序列。

返回值

返回通过指定字符连接序列中元素后生成的新字符串。

1
2
3
4
5
6
7
# join() 连接字符串

# 将序列seq中的元素'a','b','c'以指定的字符'-'连接生成一个新的字符串。
>>> s="-"
>>> seq=("a", "b", "c")
>>> s.join(seq)
"a-b-c"

center() / ljust() / rjust() / zfill() 填充字符串

语法说明
center()

str.center(width[, fillchar])

ljust()

str.ljust(width[, fillchar])

rjust()

str.rjust(width[, fillchar])

zfill()

str.zfill(width)

参数说明

  • width – 指定字符串长度。
  • fillchar – 填充字符，默认为空格。

返回值
center()

返回一个指定的宽度 width 居中的字符串，如果 width 小于字符串宽度直接返回字符串，否则使用 fillchar 去填充。

ljust()

返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。

rjust()

返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串。

zfill()

返回指定长度的字符串。

  • center() 填充字符串
1
2
3
4
5
6
# center() 返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。

# 指定字符串长度为40，用'*'来填充
>>> s="[www.elijahyang.com]"
>>> s.center(40, '*')
"**********[www.elijahyang.com]**********"
  • ljust() 填充字符串(左对齐)
1
2
3
4
5
6
# ljust() 返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。

# 指定字符串长度为40，左对齐，用'*'来填充
>>> s="[www.elijahyang.com]"
>>> s.ljust(40, '*')
"[www.elijahyang.com]********************"
  • rjust() 填充字符串(右对齐)
1
2
3
4
5
6
# rjust() 返回一个原字符串右对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。

# 指定字符串长度为40，右对齐，用'*'来填充
>>> s="[www.elijahyang.com]"
>>> s.rjust(40, '*')
"********************[www.elijahyang.com]"
  • zfill() 填充字符串(右对齐,填充0)
1
2
3
4
5
6
# zfill() 返回指定长度的字符串，原字符串右对齐，前面填充0。

# 指定字符串长度为40，右对齐，用0来填充
>>> s="[www.elijahyang.com]"
>>> s.zfill(40)
"00000000000000000000[www.elijahyang.com]"

expandtabs() 把tab转换成空格

语法说明

str.join(sequence)

参数说明

  • tabsize – 指定转换字符串中的 tab 符号(‘\t’)转为空格的字符数。

返回值

该方法返回字符串中的 tab 符号(‘\t’)转为空格后生成的新字符串。

1
2
3
4
5
6
7
8
9
10
11
12
# expandtabs() 指定转换字符串中的 tab 符号('\t')转为空格的字符数。

# 将s字符串中\t转换为空格(默认\t空格数为8)
# 实际操作中\t的默认转换为空格数为1
>>> s="this is\tstring example"
>>> s.expandtabs()
"this is string example"

# 将s字符串中\t转换为空格(指定\t空格数为16)
>>> s="this is\tstring example"
>>> s.expandtabs(16)
"this is         string example"

lower() / upper() 字符串英文大小写转换

语法说明

str.lower()
str.upper()

返回值

返回将字符串中所有大写字符转换为小写后生成的字符串。
返回将字符串中所有大写字符转换为大写后生成的字符串。

  • lower() 字符转换为小写
1
2
3
4
5
# lower() 将字符串中所有字符转换为小写

>>> s="HELLO WORLD"
>>> s.lower()
"hello world"
  • upper() 字符转换为大写
1
2
3
4
5
# upper() 将字符串中所有字符转换为大写

>>> s="hello world"
>>> s.upper()
"HELLO WORLD"

capitalize() 首字母大写 / swapcase() 大小写翻转 / title() 每个单词的首字母大写

语法说明

str.capitalize()
str.swapcase()
str.title()

返回值
capitalize()

该方法返回一个首字母大写的字符串。

swapcase()

返回大小写字母转换后生成的新字符串。

title()

返回”标题化”的字符串,就是说所有单词都是以大写开始。

  • capitalize() 首字母大写
1
2
3
4
5
# capitalize() 首字母大写

>>> s="this is string example from yang"
>>> s.capitalize()
"This is string example from yang"
  • swapcase() 大小写字母互换
1
2
3
4
5
# swapcase() 大小写字母互换

>>> s="tHiS Is sTrINg eXaMPle FRoM YaNg"
>>> s.swapcase()
"ThIs iS StRinG ExAmpLE frOm yAnG"
  • title() 每个单词的首字母大写
    1
    2
    3
    4
    5
    # title() 每个单词的首字母大写

    >>> s="this is string example from yang"
    >>> s.title()
    "This Is String Example From Yang"

maketrans() 字符串对照表翻译

语法说明

str.maketrans(intab, outtab)

参数说明

  • intab – 字符串中要替代的字符组成的字符串。
  • outtab – 相应的映射字符的字符串。

返回值

返回字符串转换后生成的新字符串。

1
2
3
4
5
6
7
8
9
# maketrans() 用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。两个字符串的长度必须相同，为一一对应的关系。

# 用12345来代替原本字符串那种的aeiou字符
>>> intab = "aeiou"
>>> outtab = "12345"
>>> trantab = str.maketrans(intab, outtab)
>>> str = "this is string example"
>>> str.translate(trantab)
"th3s 3s str3ng 2x1mpl2"

len() 字符串长度

语法说明

len( s )

参数说明

  • s – 对象。

回值

返回对象长度。

1
2
3
4
5
#  字符串长度

>>> s="yang"
>>> len(s)
4

str[::-1] 字符串翻转*

1
2
3
4
5
6
# [::-1]通过步进反转

>>> s = 'abcd'
>>> new_s = s[::-1]
>>> new_s
'dcba'

其他字符串方法

is数字系列(在python3中)

  • isdigt() 判断是否是数字(bytes、unicode)

    对于bytes、unicode使用isdigt()方法，返回True，其他返回False

1
2
3
4
5
6
7
8
9
10
11
12
13
num1=b'4' # bytes
num2=u'4' # unicode,python3中无需加u就是unicode
num3='四' # 中文数字
num4='Ⅳ' # 罗马数字

num1.isdigit()
True
num2.isdigit()
True
num3.isdigit()
False
num4.isdigit()
False
  • isdecimal() 判断是否只包含十进制字符(unicode)

    对于unicode使用isdecimal()方法，返回True，其他返回False
    bytes类型无isdecimal()方法

1
2
3
4
5
6
7
8
9
10
11
num1=b'4' # bytes
num2=u'4' # unicode,python3中无需加u就是unicode
num3='四' # 中文数字
num4='Ⅳ' # 罗马数字

num2.isdecimal()
True
num3.isdecimal()
False
num4.isdecimal()
False
  • isnumeric() 判断是否是否只由数字组成(unicode)

    对于unicode使用isnumeric()方法，返回True，其他返回False
    bytes类型无isnumeric()方法

1
2
3
4
5
6
7
8
9
10
11
num1=b'4' # bytes
num2=u'4' # unicode,python3中无需加u就是unicode
num3='四' # 中文数字
num4='Ⅳ' # 罗马数字

num2.isnumeric()
True
num3.isnumeric()
True
num4.isnumeric()
True
  • Tips

    以上isdigit() 、 isdecimal() 、 isnumeric() 均不能判断浮点数

is其他系列(在python3中)

  • isalnum() 判断是否由字母和数字组成

    字符串至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False

1
2
3
4
5
6
7
>>> str = "yang0827"
>>> str.isalnum()
True

>>> str = "www.baidu.com"
>>> str.isalnum()
False
  • isalpha() 判断是否只由字母组成

    如果字符串至少有一个字符并且所有字符都是字母则返回 True,否则返回 False

1
2
3
4
5
6
7
>>> s="yang"
>>> s.isalpha()
True

>>> s="yang example....!!!"
>>> s.isalpha()
False
  • isidentifier() 判断是否是合法的标识符

    如果字符串是合法的标识符则返回 True,否则返回 False

1
2
3
4
5
6
7
8
9
10
11
>>> s="_a"
>>> s.isidentifier()
True

>>> s="中国"
>>> s.isidentifier()
True

>>> s="3a"
>>> s.isidentifier()
False
  • islower() 判断是否由小写字母组成

    如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False

1
2
3
4
5
6
7
>>> s="this is a example"
>>> s.islower()
True

>>> s="This is a example"
>>> s.islower()
False
  • isupper() 判断是否由大写字母组成

    如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False

1
2
3
4
5
6
7
>>> s="THIS IS A EXAMPLE"
>>> s.isupper()
True

>>> s="This Is A Example"
>>> s.isupper()
False
  • isspace() 判断是否只由空白字符组成

    如果字符串中只包含空格，则返回 True，否则返回 False

1
2
3
4
5
6
7
>>> s="      "
>>> s.isspace()
True

>>> s="this is a example"
>>> s.isspace()
False

-istitle() 判断是否字符串中所有的单词拼写首字母是否为大写，且其他字母为小写

如果字符串中所有的单词拼写首字母是否为大写，且其他字母为小写则返回 True，否则返回 False

1
2
3
4
5
6
7
>>> s="This is a example"
>>> s.istitle()
True

>>> s="This Is A Example"
>>> s.istitle()
False