c语言中常数表示的ox6a6l,Python，day1，基础之字符串和字典

常数表示的ox6a6l,Python，day1，基础之字符串和字典"/>

c语言中常数表示的ox6a6l,Python，day1，基础之字符串和字典

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 Filesfnordfoobarbazfrozzbozz')

C:Program Filesfnordfoobarbazfrozzbozz

>>>

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码点和名称，可在网上使用有关该字符的描述进行搜索，也可参阅特定的网站，如。

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'xffxfeHx00ex00lx00lx00ox00,x00 x00wx00ox00rx00lx00dx00!x00'

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

b'xffxfex00x00Hx00x00x00ex00x00x00lx00x00x00lx00x00x00ox00x00x00,x00x00x00 x00x00x00wx00x00x00ox00x00x00rx00x00x00lx00x00x00dx00x00x00!x00x00x00'

>>>

>>> 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'Hxc3xa6llxc3xa5, wxc3xb8rld!'

>>> b'Hxc3xa6llxc3xa5, wxc3xb8rld!'.decode()'Hællå, wørld!'

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

b'Hxc3xa6llxc3xa5, wxc3xb8rld!'

>>> str(b'Hxc3xa6llxc3xa5, wxc3xb8rld!', encoding="utf-8")'Hællå, wørld!'

>>>

View Code

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

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

b'xe6x88x91xe7x88xb1xe5x8cx97xe4xbaxacxe5xa4xa9xe5xaex89xe9x97xa8xefxbcx81'

>>> 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")) #判断一个字符串以什么结尾(判断邮件地址是否以结尾)#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'xffxfemx00yx00 x00nx00ax00mx00ex00 x00ix00sx00 x00ax00lx00ex00xx00'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("DJFn".rstrip()) #去右边的空格和回车

print("DJFn".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+2n+3+4'.splitlines()) #换行

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

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

View Code

3. 字典

字典是Python中唯一的内置映射类型，其中的值不按顺序排列，而是存储在键下。键可能是数(整数索引)、字符串或元组。字典(日常生活中的字典和Python字典)旨在让你能够轻松地找到特定的单词(键)，以获悉其定义(值)。

字典用{}括起开。

在很多情况下，使用字典都比使用列表更合适。下面是Python字典的一些用途：

表示棋盘的状态，其中每个键都是由坐标组成的元组；

存储文件修改时间，其中的键为文件名；

数字电话/地址簿。

3.1 函数 dict

可使用函数dict从其他映射(如其他字典)或键-值对序列创建字典。函数dict实际上是一个类，也是一个工厂函数，目前，这种差别不重要。

这可能是函数dict最常见的用法，但也可使用一个映射实参来调用它，这将创建一个字典，其中包含指定映射中的所有项。像函数list、 tuple和str一样，如果调用这个函数时没有提供任何实参，将返回一个空字典。从映射创建字典时，如果该映射也是字典(毕竟字典是Python中唯一的内置映射类型)，可不使用函数dict，而是使用字典方法copy。

>>> items = [('name', 'Alex'), ('age', 22)]

>>> d = dict(items)

>>> d

{'name': 'Alex', 'age': 22}

>>> d['name']

'Alex'

>>>

还可使用关键字实参来调用这个函数，如下所示：

>>> d = dict(name='alex', age=22)

>>> d

{'name': 'alex', 'age': 22}

>>>

3.2 创建和使用字典

字典以类似于下面的方式表示：

phonebook

= {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}

字典由键及其相应的值组成，这种键-值对称为项(item)。在前面的示例中，键为名字，而值为电话号码。每个键与其值之间都用冒号(:)分隔，项之间用逗号分隔，而整个字典放在花括号内。空字典(没有任何项)用两个花括号表示，类似于下面这样： {}。

注意：在字典(以及其他映射类型)中，键必须是独一无二的，而字典中的值无需如此。

基本的字典操作

a. 字典的基本行为在很多方面都类似于序列。

i.  len(d)返回字典d包含的项(键-值对)数。

ii.  d[k]返回与键k相关联的值。

iii.  d[k] = v将值v关联到键k。

iv.  del d[k]删除键为k的项。

v.   k in d检查字典d是否包含键为k的项。

b. 字典和列表一些重要的不同之处

i. 键的类型：字典中的键可以是整数，但并非必须是整数。字典中的键可以是任何不可变的类型，如浮点数(实数)、字符串或元组。

ii. 自动添加：即便是字典中原本没有的键，也可以给它赋值，这将在字典中创建一个新项。然而，如果不使用append或其他类似的方法，就不能给列表中没有的元素赋值。

iii. 成员资格：表达式k in d(其中d是一个字典)查找的是键而不是值，而表达式v in l(其中l是一个列表)查找的是值而不是索引。这看似不太一致，但你习惯后就会觉得相当自然。毕竟如果字典包含指定的键，检查相应的值就很容易。

提示：相比于检查列表是否包含指定的值，检查字典是否包含指定的键的效率更高。数据结构越大，效率差距就越大。

3.3 字典的常用操作

info ={'stu101': "TengLan Wu",'stu102': "longZe Luola",'stu103': "XiaoZe Maliya"}#print(info["stu101"])

#add

print(info)

info["stu101"] = "武藤兰" #修改

info["stu104"] = "Cangjingkong" #不存在，创建

print(info)

——>{'stu101': 'TengLan Wu', 'stu102': 'longZe Luola', 'stu103': 'XiaoZe Maliya'}

{'stu101': '武藤兰', 'stu102': 'longZe Luola', 'stu103': 'XiaoZe Maliya', 'stu104': 'Cangjingkong'}#del

print(info)

info.pop("stu101") #如果不指定，随机删#del info["stu101"]#info.popitem() # 随机删

print(info)

——>{'stu101': 'TengLan Wu', 'stu102': 'longZe Luola', 'stu103': 'XiaoZe Maliya'}

{'stu102': 'longZe Luola', 'stu103': 'XiaoZe Maliya'}#find

print(info)print(info.get("stu104"))#Determine whether the dictionary has data

print('stu104' in info) #info.has_key("103") in py2.x

——>{'stu101': 'TengLan Wu', 'stu102': 'longZe Luola', 'stu103': 'XiaoZe Maliya'}

None

False#分别打印values keys

print(info)print(info.values())print(info.keys())

——>{'stu101': 'TengLan Wu', 'stu102': 'longZe Luola', 'stu103': 'XiaoZe Maliya'}

dict_values(['TengLan Wu', 'longZe Luola', 'XiaoZe Maliya'])

dict_keys(['stu101', 'stu102', 'stu103'])#setdefault 在字典中取值，取到，将stu103返回，取不到stu106，创建

print(info)print(info.setdefault("stu103", "Alex"))print(info)print(info.setdefault("stu106", "Alex"))print(info)

——>{'stu101': 'TengLan Wu', 'stu102': 'longZe Luola', 'stu103': 'XiaoZe Maliya'}

XiaoZe Maliya

{'stu101': 'TengLan Wu', 'stu102': 'longZe Luola', 'stu103': 'XiaoZe Maliya'}

Alex

{'stu101': 'TengLan Wu', 'stu102': 'longZe Luola', 'stu103': 'XiaoZe Maliya', 'stu106': 'Alex'}#update 字典合并，原有且更改的，更新；原没有的，增加

print(info)print(info)

b={"stu101": "Daqiao",1: 3,2: 4}

info.update(b)print(info)

——>{'stu101': 'TengLan Wu', 'stu102': 'longZe Luola', 'stu103': 'XiaoZe Maliya'}

{'stu101': 'Daqiao', 'stu102': 'longZe Luola', 'stu103': 'XiaoZe Maliya', 1: 3, 2: 4}#items 将字典转化成列表

print(info)print(info.items())

——>{'stu101': 'TengLan Wu', 'stu102': 'longZe Luola', 'stu103': 'XiaoZe Maliya'}

dict_items([('stu101', 'TengLan Wu'), ('stu102', 'longZe Luola'), ('stu103', 'XiaoZe Maliya')])#高效 通过索引，直接取出info

print(info)for i ininfo:print(i, info[i])print("----------")#低效 将字典转成列表(数据量很大时，转很长时间，机器奔溃) 列表中每一个元素都是一个小元组

for k, v ininfo.items():print(k, v)#fromkeys [1, {"name": "alex"}, 444] 共用一个地址空间，类似浅copy

c = dict.fromkeys([6, 7, 8], "test")

c2= dict.fromkeys([6, 7, 8], [1, {"name": "alex"}, 444])print(c)print(c2)

c2[7][1]['name'] = "jack"

print(c2)

——>{6: 'test', 7: 'test', 8: 'test'}

{6: [1, {'name': 'alex'}, 444], 7: [1, {'name': 'alex'}, 444], 8: [1, {'name': 'alex'}, 444]}

{6: [1, {'name': 'jack'}, 444], 7: [1, {'name': 'jack'}, 444], 8: [1, {'name': 'jack'}, 444]}#copy

返回一个新字典，其包含的键值对与原来的字典相同(这个方法执行的是浅复制，因为值本身是原件，而非副本)。>>> x = {'username': 'admin', 'machines': ['foo', 'bar', 'baz']}>>> y =x.copy()>>> y['username'] = 'mlh'

>>> y['machines'].remove('bar')>>>y

{'username': 'mlh', 'machines': ['foo', 'baz']}>>>x

{'username': 'admin', 'machines': ['foo', 'baz']}

当替换副本中的值时，原件不受影响。然而，如果修改副本中的值(就地修改而不是替换) ，原件也将发生变化，因为原件指向的也是被修改的值(如这个示例中的'machines'列表所示)。#deepcopy

为避免这种问题，一种办法是执行深复制，即同时复制值及其包含的所有值，等等。为此，可使用模块copy中的函数deepcopy。>>> from copy importdeepcopy>>> d ={}>>> d['names'] = ['Alfred', 'Bertrand']>>> c =d.copy()>>> dc =deepcopy(d)>>> d['names'].append('Clive')>>>c

{'names': ['Alfred', 'Bertrand', 'Clive']}>>>dc

{'names': ['Alfred', 'Bertrand']}

View Code

字典方法示例

#一个使用get()的简单数据库#一个将人名用作键的字典。每个人都用一个字典表示，#字典包含键'phone'和'addr'，它们分别与电话号码和地址相关联

people ={'Alice': {'phone': '2341','addr': 'Foo drive 23'},'Beth': {'phone': '9102','addr': 'Bar street 42'},'Cecil': {'phone': '3158','addr': 'Baz avenue 90'}

}#电话号码和地址的描述性标签，供打印输出时使用

labels ={'phone': 'phone number','addr': 'address'}

name= input('Name:')#要查找电话号码还是地址？

request = input('Phone number (p) or address (a)?')#使用正确的键：

key = request #如果request既不是'p'也不是'a'

if request == 'p': key = 'phone'

if request == 'a': key = 'addr'

#使用get提供默认值

person =people.get(name, {})

label=labels.get(key, key)

result= person.get(key, 'not available')print("{}'s {} is {}.".format(name, label, result))

执行结果：

Name: jj

Phone number (p)oraddress (a)? a

jj's address is not available.

View Code

内容来源于网络如有侵权请私信删除