python 内置方法赋值_Python内置数据结构之字符串str

1. 数据结构回顾

所有标准序列操作(索引、切片、乘法、成员资格检查、长度、最小值和最大值)都适用于字符串，但是字符串是不可变序列，因此所有的元素赋值和切片赋值都是非法的。

>>> website = ''

>>> website[-3:] = 'com'Traceback (most recent call last):

File"", line 1, in?

website[-3:] = 'com'TypeError: object doesn't support slice assignment

View Code

通过名称来访问其各个值的数据结构。这种数据结构称为映射(mapping) 。字典是Python中唯一的内置映射类型，其中的值不按顺序排列，而是(值)存储在键下。键可能是数、字符串或元组。

2. 字符串

print ( "hello,world!") "hello,world!" 是字符串，字符串在几乎所有真实可用的Python程序中都会存在，并且有多种用法，其中最主要的用法就是表示一些文本。字符串是值，就像数字一样。str，repr和反引号是将Python值转换成 字符串的3种方法。

2.1 字符串基础

a.单引号字符串和转义引号

>>> 'let's go'# 后面的黑色字体部分Python无法识别

SyntaxError: invalid syntax

>>> 'let\'s go'# 在常规字符串中，反斜杠扮演着特殊角色：它对字符进行转义，让你能够在字符串中包含原本无法包含的字符。 反斜线(\)，可以换行。

"let's go"

>>> "let's go!" # 用""对'加以区分

"let's go!"

b.拼接字符串

>>> "let's say:" '"hello,world!"'

'let\'s say:"hello,world!"'

>>> 'hello,' + 'world!'

'hello,world!'

可以使用 + 操作符来连接 (粘在一起)； 使用 * 操作符重复

>>> word = 'help ' + 'me! '

>>> word

'help me! '

>>> ''

''

>>>

注意：

两个靠着一起的字符串会自动的连接; 上面例子的第一行也可以写成 word = 'Help' 'A'; 这只能用于两个字符串常量, 而不能用于任意字符串表达式。

c.字符串表示，str和repr

Python打印值的时候会保持值在代码中的状态，而不是你希望用户看到的状态，通过使用print，结果将不同。

>>> "Hello, world!"

'Hello, world!'

>>> print("Hello, world!")

Hello, world!

如果再加上表示换行符的编码\n，差别将更明显。

>>> 'hello,\nworld!'

'hello,\nworld!'

>>> print('hello,\nworld!')

hello,

world!

>>>

str，repr和反引号是将Python值转换成 字符串的3种方法。

通常会获得值的合法Python表达式表示。则意味着产生一个解释器易读的表达形式 (或者如果没有这样的语法会给出SyntaxError).

str()函数 ，(实际是类，工厂函数；str和int、long一样，是一种类型。repr仅仅是函数)

使用str能以合理的方式将值转换为用户能够看懂的字符串。例如，尽可能将特殊字符编码转换为相应的字符。

对于那些没有特殊表达的对象,str()将会与repr()返回相同的值. 很多的值, 如数字或一些如列表和字典那样的结构, 使用这两个函数的结果完全一致. 字符串与浮点型则有两种不同的表达。

repr和反引号则把结果字符串转换为合法的Python表达式。

d.长字符串，原始字符串和Unicode

有一些独特而有用的字符串表示方式。例如，有一种独特的语法可用于表示包含换行符或反斜杠的字符串(长字符串和原始字符串)。对于包含特殊符号的字符串，

Python 2还提供了一种专用的表示语法，结果为Unicode字符串。这种语法现在依然管用，但是多余，因为在Python 3中，所有的字符串都是Unicode字符串。 Python 3还引入了一种新语法，用于表示大致相当于老式字符串的字节对象。在处理Unicode编码方面，这种对象依然扮演着重要的角色。

请注意，指定原始字符串时，可使用单引号或双引号将其括起，还可使用三引号将其括起。

i. 长字符串

字符串可以使用一对匹配的三引号对包围: """ 或 '''。当使用三引号时, 回车不需要被舍弃, 他们会包含在字符串里。

>>> print('''This is a very long string. It continues here.

And it's not over yet. "Hello, world!"

Still here.''')

This is a very long string. It continues here.

And it's not over yet. "Hello, world!"

Still here.

>>>

ii. 原始字符串

原始字符串不以特殊方式处理反斜线。

>>> path = 'C:\nowhere'

>>> path

'C:\nowhere'

>>> print(path)# 打印出问题

C:

owhere

>>> print('C:\\nowhere') #对反斜杠本身进行转义。

C:\nowhere

>>>

对于很长的路径，将需要使用大量的反斜杠。

在这样的情况下，原始字符串可派上用场，因为它们根本不会对反斜杠做特殊处理，而是让字符串包含的每个字符都保持原样。

>>> print(r'C:\nowhere')

C:\nowhere

>>> print(r'C:\Program Files\fnord\foo\bar\baz\frozz\bozz')

C:\Program Files\fnord\foo\bar\baz\frozz\bozz

>>>

iii. Unicode、 bytes和bytearray

Python字符串与二进制的关系

python 3中最重要的新特性可能就是将文本(text)和二进制数据做了更清晰的区分。文本总是用unicode进行编码，以str类型表示；而二进制数据以bytes类型表示。

在python3中，不能以任何隐式方式将str和bytes类型二者混合使用。不可以将str和bytes类型进行拼接，不能在str中搜索bytes数据(反之亦然)，也不能将str作为参数传入需要bytes类型参数的函数(反之亦然)。

Unicode

大致而言，每个Unicode字符都用一个码点(code point)表示，而码点是Unicode标准给每个字符指定的数字。这让你能够以任何现代软件都能识别的方式表示129个文字系统中的12万个以上的字符。当然，鉴于计算机键盘不可能包含几十万个键，因此有一种指定Unicode字符的通用机制：使用16或32位的十六进制字面量(分别加上前缀\u或\U)或者使用字符的Unicode名称(\N{name})。

>>> "\u00C6"

'Æ'

要获悉字符的Unicode码点和名称，可在网上使用有关该字符的描述进行搜索，也可参阅特定的网站，如http://unicode-。

Bytes

Unicode的理念很简单，却带来了一些挑战，其中之一是编码问题。在内存和磁盘中，所有对象都是以二进制数字(0和1)表示的(这些数字每8个为一组，即1字节)，字符串也不例外。在诸如C等编程语言中，这些字节完全暴露，而字符串不过是字节序列而已。为与C语言互操作以及将文本写入文件或通过网络套接字发送出去，Python提供了两种类似的bytes类型：不可变的bytes和可变的bytearray。如果需要，可直接创建bytes对象(而不是字符串)，方法是使用前缀b：

>>> b'Hello, world!'

b'Hello, world!

然而， 1字节只能表示256个不同的值，离Unicode标准的要求差很远。 Python bytes字面量只支持ASCII标准中的128个字符，而余下的128个值必须用转义序列表示，如\xf0表示十六进制值0xf0(即240)。 8位一个字节，一位是一个bite，8位最多表示255个符号。

唯一的差别好像在于可用的字母表规模，但实际上并非完全如此。乍一看，好像ASCII和Unicode定义的都是非负整数和字符之间的映射，但存在细微的差别： Unicode码点是使用整数定义的，而ASCII字符是使用对应的数及其二进制编码定义的。

这一点好像无关紧要，原因之一是整数0～255和8位二进制数之间的映射是固定的，几乎没有任何机动空间。问题是超过1字节后，情况就不那么简单了：直接将每个码点表示为相应的二进制数可能不再可行。这是因为不仅存在字节顺序的问题(即便对整数值进行编码，也会遇到这样的问题)，而且还可能浪费空间：如果对于每个码点都使用相同数量的字节进行编码，就必须考虑到文本可能包含安那托利亚象形文字或皇家亚兰字母。有一种Unicode编码标准是基于这种考虑的，它就是UTF-32(32位统一编码转换格式， Unicode Transformation Format 32 bits)，但如果你主要处理的是使用互联网上常见语言书写的文本，那么使用这种编码标准将很浪费空间。然而，有一种非常巧妙的替代方式：不使用全部32位，而是使用变长编码，即对于不同的字符，使用不同数量的字节进行编码。这种编码方式主要出自计算机先锋Kenneth Thompson之手。通过使用这种编码，可节省占用的空间，就像摩尔斯码使用较少的点和短线表示常见的字母，从而减少工作量一样。具体地说，进行单字节编码时，依然使用ASCII编码，以便与较旧的系统兼容；但对于不在这个范围内的字符，使用多个字节(最多为6个)进行编码。

下面来使用ASCII、UTF-8、UTF-16和UTF-32编码将字符串转换为bytes。

>>> "Hello, world!".encode("ASCII")

b'Hello, world!'

>>> "Hello, world!".encode("UTF-8")

b'Hello, world!'

>>> "Hello, world!".encode("UTF-16")

b'\xff\xfeH\x00e\x00l\x00l\x00o\x00,\x00 \x00w\x00o\x00r\x00l\x00d\x00!\x00'

>>> "Hello, world!".encode("UTF-32")

b'\xff\xfe\x00\x00H\x00\x00\x00e\x00\x00\x00l\x00\x00\x00l\x00\x00\x00o\x00\x00\x00,\x00\x00\x00 \x00\x00\x00w\x00\x00\x00o\x00\x00\x00r\x00\x00\x00l\x00\x00\x00d\x00\x00\x00!\x00\x00\x00'

>>>

>>> len("How long is this?".encode("UTF-8"))17

>>> len("How long is this?".encode("UTF-16"))36

>>> len("How long is this?".encode("UTF-32"))72

>>>说明： 在所有情况下，都最好使用UTF-8。事实上，它也是默认使用的编码。

View Code

几乎在所有情况下，都最好使用UTF-8。它是默认使用的编码。

.encode()可将字符串编码为bytes，.decode()可将bytes解码为字符串。

可不使用方法encode和decode，而直接创建bytes和str(即字符串)对象，这种方法更通用一些，在你不知道类似于字符串或bytes的对象属于哪个类时，使用这种方法也更管用。一个通用规则是，不要做过于严格的假设。

>>> "Hællå, wørld!".encode()

b'H\xc3\xa6ll\xc3\xa5, w\xc3\xb8rld!'

>>> b'H\xc3\xa6ll\xc3\xa5, w\xc3\xb8rld!'.decode()'Hællå, wørld!'

>>> bytes("Hællå, wørld!", encoding="utf-8")

b'H\xc3\xa6ll\xc3\xa5, w\xc3\xb8rld!'

>>> str(b'H\xc3\xa6ll\xc3\xa5, w\xc3\xb8rld!', encoding="utf-8")'Hællå, wørld!'

>>>

View Code

>>> msg = "我爱北京天安门！"

>>> print(msg.encode(encoding = "utf-8"))

b'\xe6\x88\x91\xe7\x88\xb1\xe5\x8c\x97\xe4\xba\xac\xe5\xa4\xa9\xe5\xae\x89\xe9\x97\xa8\xef\xbc\x81'

>>> print(msg.encode(encoding = "utf-8").decode(encoding = "utf-8"))

我爱北京天安门！>>>

View Code

编码和解码的最重要用途之一是，将文本存储到磁盘文件中。然而， Python提供的文件读写机制通常会替你完成这方面的工作！只要文件使用的是UTF-8编码，就无需操心编码和解码的问题。但如果原本正常的文本变成了乱码，就说明文件使用的可能是其他编码。

最后， Python还提供了bytearray，它是bytes的可变版。从某种意义上说，它就像是可修改的字符串——常规字符串是不能修改的。然而， bytearray其实是为在幕后使用而设计的，因此作为类字符串使用时对用户并不友好。例如，要替换其中的字符，必须将其指定为0～255的值。

因此，要插入字符，必须使用ord获取其序数值(ordinal value)。

>>> x = bytearray(b"Hello!")

>>> x[1] = ord(b"u")

>>> x

bytearray(b'Hullo!')

>>>

2.2 字符串格式

字符串格式设置涉及的内容很多，基本思想是对字符串调用方法format，并提供要设置其格式的值。字符串包含有关如何设置格式的信息，而这些信息是使用一种微型格式指定语言(mini-language)指定的。每个值都被插入字符串中，以替换用花括号括起的替换字段。要在最终结果中包含花括号，可在格式字符串中使用两个花括号(即{{或}})来指定。

Python提供了多种字符串格式设置方法。以前，主要的解决方案是使用字符串格式设置运算符——百分号。这个运算符的行为类似于C语言中的经典函数printf：在%左边指定一个字符串(格式字符串)，并在右边指定要设置其格式的值。指定要设置其格式的值时，可使用单个值(如字符串或数字)，可使用元组(如果要设置多个值的格式)，还可使用字典，其中最常见的是元组。

%s称为转换说明符 ，指出了要将值插入什么地方。 s意味着将值视为字符串进行格式设置。如果指定的值不是字符串，将使用str将其转换为字符串。其他说明符将导致其他形式的转换。例如， %.3f将值的格式设置为包含3位小数的浮点数。

>>> a = "hello, %s. %s said!"

>>> b = ('world', 'he')

>>> a % b

'hello, world. he said!'

>>>

2.2.1 替换字段名

向format提供要设置其格式的未命名参数或参数指定名称 ；

>>> "{i} {} {sleep} {}".format(1, 2, sleep=4, i=3)

'3 1 4 2'

通过索引来指定要在哪个字段中使用相应的未命名参数 ，可以不按顺序使用未命名参数。

>>> "{i} {1} {sleep} {0}".format(1, 2, sleep=4, i=3)

'3 2 4 1'

访问提供的值的组成部分

>>> fullname = ["alex", "Li"]

>>> 'Mr {name[0]}'.format(name=fullname)

'Mr alex'

>>>

使用索引，还可使用句点表示法来访问导入的模块中的方法、属性、变量和函数(看起来很怪异的变量__name__包含指定模块的名称)。

>>> import math

>>> tmpl = "The {mod.__name__} module defines the value {mod.pi:f} for π"

>>> tmpl.format(mod = math)

'The math module defines the value 3.141593 for π'

>>>

2.2.2 转化

(s、 r和a)指定分别使用str、 repr和ascii进行转换。函数str通常创建外观普通的字符串版本(这里没有对输入字符串做任何处理) 。函数repr尝试创建给定值的Python表示(这里是一个字符串字面量)。函数ascii创建只包含ASCII字符的表示，类似于Python 2中的repr。

>>> print("{pi!s} {pi!r} {pi!a}".format(pi="π"))

π 'π' '\u03c0'

>>>

>>> "The number is {num:f}".format(num=42)

'The number is 42.000000'

字符串格式设置中的类型说明符

类型 含 义

b 将整数表示为二进制数

c 将整数解读为Unicode码点

d 将整数视为十进制数进行处理，这是整数默认使用的说明符

e 使用科学表示法来表示小数(用e来表示指数)

E 与e相同，但使用E来表示指数

f 将小数表示为定点数

F 与f相同，但对于特殊值(nan和inf)，使用大写表示

g 自动在定点表示法和科学表示法之间做出选择。这是默认用于小数的说明符，但在默认情况下至少有1位小数

G 与g相同，但使用大写来表示指数和特殊值

n 与g相同，但插入随区域而异的数字分隔符

o 将整数表示为八进制数

s 保持字符串的格式不变，这是默认用于字符串的说明符

x 将整数表示为十六进制数并使用小写字母

X 与x相同，但使用大写字母

% 将数表示为百分比值(乘以100，按说明符f设置格式，再在后面加上%)

2.2.3 宽度，精度，分隔符，对齐

宽度是使用整数指定的，如下所示：

>>> "{num:10}".format(num=3)

' 3'

>>> "{name:10}".format(name="Bob")

'Bob '

精度使用整数指定的，需要在它前面加上一个表示小数点的句点。

>>> "Pi day is {pi:.2f}".format(pi=pi)

'Pi day is 3.14'

使用逗号来指出你要添加千位分隔符。

>>> 'One googol is {:,}'.format(10**100)

'One googol is 10,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000'

在指定宽度和精度的数前面，可添加一个标志。这个标志可以是零、加号、减号或空格，其中零表示使用0来填充数字。

>>> '{:010.2f}'.format(pi)

'0000003.14'

要指定左对齐、右对齐和居中，可分别使用和^。

>>> from math importpi>>> print('{0:<10.2f}\n{0:^10.2f}\n{0:>10.2f}'.format(pi))3.14

3.14

3.14

>>>

View Code

可以使用填充字符来扩充对齐说明符，这样将使用指定的字符而不是默认的空格来填充。

>>> "{:$^15}".format(" WIN BIG ")

'$$$ WIN BIG $$$'

还有更具体的说明符=，它指定将填充字符放在符号和数字之间。

>>> print('{0:10.2f}\n{1:10.2f}'.format(pi, -pi))3.14

-3.14

>>> print('{0:10.2f}\n{1:=10.2f}'.format(pi, -pi))3.14

- 3.14

>>>

View Code

字符串格式设置示例

width = int(input('Please enter width:'))

price_width= 7

#指定price符的字段宽度，默认以空格填充

item_width = width -price_width

header_fmt= '{{:^{}}}{{:>{}}}'.format(item_width, price_width)#要指定左对齐、右对齐和居中，可分别使用< >和^ 。

fmt = '{{:{}.2f}}'.format(item_width, price_width)#可以使用填充字符来扩充对齐说明符，这样将使用指定的字符而不是默认的空格来填充。#"{:$^15}".format(" WIN BIG ") ——>$$$ WIN BIG $$$#.2f 将值(价格)的格式设置为包含2位小数的浮点数。

print('=' *width)print(header_fmt.format('Item', 'Price'))print('-' *width)print(fmt.format('Apples', 0.4))print(fmt.format('Pears', 0.5))print(fmt.format('Cantaloupes', 1.92))print(fmt.format('Dried Apricots (16 oz.)', 8))print(fmt.format('Prunes (4 lbs.)', 12))print('=' *width)

执行结果：

View Code

2.3 字符串基本操作

name = "my name is alex"

print(name.capitalize()) #首字母大写

print(name.count("a")) #统计a的个数

print(name.center(50, "-")) #美观打印，打印50个字符，不够用-补上

print(name.encode(encoding="utf-16")) #使用utf-16将字符串转化为bytes

print(name.endswith("ex")) #判断一个字符串以什么结尾(判断邮件地址是否以.com结尾)#name = "my \tname is alex"

print(name.expandtabs(tabsize=30)) #将 Tab键转换成多少个空格

print(name.find("n")) #查找,字符串的索引

print(name[name.find("name"):]) #字符串可以切片，从name开始截断

执行结果：

My nameisalex2

-----------------my name is alex------------------b'\xff\xfem\x00y\x00 \x00n\x00a\x00m\x00e\x00 \x00i\x00s\x00 \x00a\x00l\x00e\x00x\x00'True

my nameisalex3nameis alex

View Code

name = "my name is {name} and i am {years} old."

print(name.format(name='alex', years=23)) #格式化

——>my name is alex and i am 23old.print(name.format_map({'name': 'alex', 'years': 12})) #字典，格式化

——>my name is alex and i am 12old.#print(name.isalnum())

print('123Abc123'.isalnum()) #判断是否为数字和字母

——>Trueprint('ABCas'.isalpha()) #判断是否为字母

print('1237'.isdecimal()) #判断是否为十进制

print('123'.isdigit()) #判断是否为整数

print('As3adf'.isidentifier()) #判断是否为一个合法的标识符(变量名)

print('13414'.isnumeric()) #判断是否为一个数字

print('My Name is'.istitle()) #判断是每个字符的首字母是否为大写

——>Falseprint('MY NAME IS'.isupper()) #判断是每个字符是否为大写

——>Trueprint('+'.join(['1', '2', '3'])) #将列表转化成字符串

——>1+2+3

print(name.ljust(50, '*')) #满足长50，不够在句尾用*补足

——>my name is {name} and i am {years} old.***********

print(name.rjust(50, '*')) #满足长50，不够在句首用*补足

——>***********my name is {name} andi am {years} old.

执行结果：(——>后为执行结果，没有标注的全部为True)

my nameis alex and i am 23old.

my nameis alex and i am 12old.

True

True

True

True

True

True

False

True1+2+3my nameis {name} and i am {years} old.***********

***********my name is {name} and i am {years} old.

View Code

print("Djf".lower()) #将大写字母变小写

print("djf".upper()) #将小写字母变大写

print('------')print("\ndjf".lstrip()) #去左边的空格和回车

print("DJF\n".rstrip()) #去右边的空格和回车

print("DJF\n".strip()) #去两边的空格和回车

print('------')

p= str.maketrans("abcdef",'123456')print("alex li".translate(p)) #对应字母替换,密钥

print('------')print("alex li".replace('l', 'L')) #对应字母替换

print("alex li".replace('l', 'L', 1)) #对应字母替换

print('------')print("alex li".rfind('l')) #从左向右,最后一个l的下标

print("al exli li".split('l')) #按照分隔符，将字符串分成列表

print('1+2+3+4'.split('+'))print('1+2\n+3+4'.splitlines()) #换行

print("Alex Li".swapcase()) #大小写变换

print("alex li".title()) #首字母变大写

View Code