《python学习手册》阅读笔记5.1-5.14

不知不觉这么久没写了，两周时间，看完了字符串，列表与字典，元组与文件，整个第二部分啃完了，第三部分是语句，再往后好像就是平时写的时候没接触过的比较深的东西了，到时候应该会写详细点。

2015-05-02

• 单引号和双引号字符串是一样的,之所以这两种形式都能够使用是因为你不使用反斜杠转义字符就可以实现在一个字符串中包含其余种类的引号。可以在一个双引号字符所包含的字符串中嵌入一个单引号字符，反之亦然:

  >>> 'spam eggs'  # single quotes
  'spam eggs'
  >> 'doesn\'t'  # use \' to escape the single quote...
  "doesn't"
  >> "doesn't"  # ...or use double quotes instead
  "doesn't"
  >> '"Yes," he said.'
  '"Yes," he said.'
  >> "\"Yes,\" he said."
  '"Yes," he said.'
  >> '"Isn\'t," she said.'
  '"Isn\'t," she said.'

• Python自动在任意的表达式中合并相邻的字符串常量，尽管可以简单地在它们之间增加+操作符来明确地表示这是一个合并操作（把这种形式放到圆括号中，就可以允许它跨越多行）：

  >> title = "Meaning " 'of' " Life"      # Implicit concatenation
  >> title
  'Meaning of Life'

  在这些字符串之间增加逗号会创建一个元组，而不是一个字符串。

• raw字符串抑制转义
  如果字母r（大写或小写）出现在字符串的第一引号的前面，它将会关闭转义机制。这个结果就是Python会将反斜杠作为常量来保持，就像输入的那样。

2015-05-04

• 一个raw字符串不能以奇数个反斜杠结束。如果需要用单个的反斜杠结束一个raw字符串，可以使用两个反斜杠并分片掉第二个反斜杠(r’1\nb\tc\’[:-1])、手动添加一个反斜杠(r’1\nb\tc’+’\’)，或者忽略raw字符串语法并在常规字符串中把反斜杠改为双反斜杠(‘1\nb\tc\’)。
• 三重引号编写多行字符串块
  这个形式以三重引号开始（单引号和双引号都可以），并紧跟任意行数的文本，并且以开始时的同样的三重引号结尾。嵌入在这个字符串文本中的单引号和双引号也会，但不是必须转义——直到Python看到和这个常量开始时同样的三重引号，这个字符串才会结束

print """\
Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to
"""

• 索引和分片
  
  • 一个负偏移与这个字符串的长度相加后得到这个字符串的正的偏移值。能够将负偏移看做是从结束处反向计数。
  • S[:]获取了从偏移0到末尾之间的元素，这有效地实现顶层S拷贝。一个有相同值，但是是不同内存片区的对象
• 为了去掉换行符常常推荐采用line.rstrip方法，因为这个调用将会留下没有换行字符那行的最后一个字符，而这在一些文本编辑器工具中是很常见的。

2015-05-05

内置的ord函数转换为其对应的ASCII码——这个函数实际上返回的是这个字符在内存中对应的字符的二进制值。而chr函数将会执行相反的操作，获取ASCII码并将其转化为对应的字符

>>> ord('s')
115
>>> chr(115)
's'

2015-05-09

• 修改字符串
  如果仅为了替换一个子字符串的话，那么可以使用字符串的replace方法来实现：

>>> S = 'spammy'
>>> S = S.replace('mm', 'xx')
>>> S
'spaxxy'

replace方法比这一段代码所表现的更具有普遍性。它的参数是原始子字符串（任意长度）和替换原始子字符串的字符串（任意长度），之后进行全局搜索并替换：

>>> S.replace('SPAM', 'EGGS', 1)  # Replace one
'xxxxEGGSxxxxSPAMxxxx'

2015-05-11

• 字符串格式化表达式
  在%操作符的左侧放置一个需要进行格式化的字符串，这个字符串带有一个或多个嵌入的转换目标，都以%开头（例如，%d）。
  在%操作符右侧放置一个（或多个，嵌入到元组中）对象，这些对象将会插入到左侧想让Python进行格式化字符串的一个（或多个）转换目标的位置上去。

>>> exclamation = "Ni"
>>> "The knights who say %s!" % exclamation
'The knights who say Ni!'
>>> "%d %s %d you" % (1, 'spam', 4)
'1 spam 4 you'
>>> "%s -- %s -- %s" % (42, 3.14159, [1, 2, 3])
'42 -- 3.14159 -- [1, 2, 3]'

• 更高级的字符串格式化表达式
  %[(name)][flags][width][.precision]typecode
  字符码出现在目标字符串的尾部，在%和字符码之间，你可以进行以下的任何操作：放置一个字典的键；罗列出左对齐（-）、正负号（+）和补零（0）的标志位；给出数字的整体长度和小数点后的位数等。width和percision都可以编码为一个*，以指定它们应该从输入值的下一项中取值。

>>> template = '{0}, {1} and {2}'                       # By position
>>> template.format('spam', 'ham', 'eggs')
'spam, ham and eggs'

>>> template = '{motto}, {pork} and {food}'             # By keyword
>>> template.format(motto='spam', pork='ham', food='eggs')
'spam, ham and eggs'

>>> template = '{motto}, {0} and {food}'                  # By both
>>> template.format('ham', motto='spam', food='eggs')
'spam, ham and eggs'

• 添加具体格式化
  下面的{0:10}意味着一个10字符宽的字段中的第一个位置参数，{1:<10}意味着第2个位置参数在一个10字符宽度字段中左对齐，{0.platform:>10}意味着第一个参数的platform属性在10字符宽度的字段中右对齐

>>> '{0:e}, {1:.3e}, {2:g}'.format(3.14159, 3.14159, 3.14159)
 2015-05-11
'3.141590e+00, 3.142e+00, 3.14159'
>>> '{0:f}, {1:.2f}, {2:06.2f}'.format(3.14159, 3.14159, 3.14159)
'3.141590, 3.14, 003.14'
 2015-05-11
>>> '{0:X}, {1:o}, {2:b}'.format(255, 255, 255)   # Hex, octal, binary
'FF, 377, 11111111'
>>> bin(255), int('11111111', 2), 0b11111111     # Other to/from binary
('0b11111111', 255, 255)
>>> hex(255), int('FF', 16), 0xFF                 # Other to/from hex
('0xff', 255, 255)

• 列表迭代和解析,内置函数map做类似的工作，但它对序列中的各项应用一个函数并把结果收集到一个新的列表中：

>>> list(map(abs, [-1, -2, 0, 1, 2]))       # map function across sequence
[1, 2, 0, 1, 2]

2015-05-12

原处修改列表

• 索引和分片的赋值都是原地修改，它们对列表进行直接修改，而不是生成一个新的列表作
• 分片赋值能够用来替换（覆盖）、增长（插入）、缩短（删除）主列表。
• L.append(X)与L+[X]的结果类似，不同的是，前者会原地修改L，而后者会生成新的列表
• 要当心append和sort原处修改相关的列表对象，而结果并没有返回列表（从技术上来讲，两者返回的值皆为None）。
• 如果编辑类似L=L.append(X)的语句，将不会得到L修改后的值（实际上，会失去整个列表的引用）；当使用append和sort之类的属性时，对象的修改有点像副作用，所以没有理由再重新赋值。
• 将空列表赋值给一个索引只会在指定的位置存储空列表的引用，而不是删除

字典

• 字典有时又叫做关联数组（associative array）或者是散列表（hash）。它们通过键将一系列值联系起来，这样就可以使用键从字典中取出一项。就像列表那样，同样可以使用索引操作从字典中获取内容。但是索引采取键的形式，而不是相对偏移。
• 保存在字典中的项并没有特定的顺序。实际上，Python将各项从左到右随机排序，以便快速查找。键提供了字典中项的象征性（而非物理性的）位置。
• 与列表相似，字典可以在原处增长或是缩短（无需生成一份拷贝）。它们可以包含任何类型的对象，而且它们支持任意深度的嵌套（可以包含列表和其他的字典等）。
• 通过给索引赋值，字典可以在原处修改（可变），但不支持用于字符串和列表中的序列操作
• 字典存储的是对象引用（不是拷贝）。

字典的基本操作

• keys方法则能够返回字典中所有的键，将它们收集在一个列表中。后者对于按顺序处理字典是非常有用的，但是你不应该依赖keys列表的次序。然而，因为keys结果是一个普通列表，如果次序要紧，随时都可以进行排序
• in成员关系测试同样适用于字典。它能够检查某个键是否储存在字典内，如同上一行的has_key方法调用。从技术上来讲，这样做能行得通是因为字典定义了单步遍历keys列表的迭代器。

其他字典方法

• 然而键不存在时通过get方法能够返回默认值（None或者用户定义的默认值）。这是在当键不存在时为了避免missing-key错误而填入默认值的一个简单方法
• update方法把一个字典的键和值合并到另一个字典中，盲目地覆盖相同键的值：

语言表

• 就任何字典D而言，写成for key in D:和写成完整的key in D.keys():效果是一样的。这其实只是先前所提到的迭代器能够允许in成员关系操作符用于字典的另一个实例

创建字典的其他方法

{'name': 'mel', 'age': 45}            # Traditional literal expression

D = {}                                # Assign by keys dynamically
D['name'] = 'mel'
D['age'] = 45

dict(name='mel', age=45)              # dict keyword argument form

dict([('name', 'mel'), ('age', 45)])  # dict key/value tuples form

如果你可以事先拼出整个字典，那么第一种是很方便的。
如果你需要一次动态地建立字典的一个字段，第二种比较合适。
第三种关键字形式所需的代码比常量少，但是键必须都是字符串才行。
如果你需要在程序运行时把键和值逐步建成序列，那么最后一种形式比较有

>>> D = {k: v for (k, v) in zip(['a', 'b', 'c'], [1, 2, 3])}
>>> D
{'a': 1, 'c': 3, 'b': 2}

2015-05-13

append和extend方法可在原处增长列表，sort和reverse方法可以对列表进行排序或者翻转，insert方法可以在一个偏移值处插入一个元素，remove和pop方法会按照值和位置从列表中删除元素，del语句会删除一个元素或分片，而索引以及分片赋值语句则会取代一个元素或整个片段。本题可任意挑选其中的四个。

元组

• 元组与列表非常类似，只不过元组不能在原处修改（它们是不可变的），并且通常写成圆括号（而不是方括号）中的一系列项。虽然元组不支持任何方法调用，但元组具有列表的大多数属性。
• 如果圆括号里的单一对象是元组对象而不是一个简单的表达式，需要对Python进行特别说明。如果确实想得到一个元组，只要在这一单个元素之后、关闭圆括号之前加一个逗号就可以了。
• 列表解析是名副其实的序列操作——它们总会创建新的列表，但也可以用于遍历包括元组、字符串以及其他列表在内的任何序列对象。我们将会看到，列表解析甚至可以用在某些并非实际储存的序列之上——任何可遍历的对象都可以，包括可自动逐行读取的文件。
• 注意元组的不可变性只适用于元组本身顶层而并非其内容。例如，元组内部的列表是可以像往常那样修改的。

为什么有了列表还要元组

最佳答案似乎是元组的不可变性提供了某种完整性。这样你可以确保元组在程序中不会被另一个引用修改，而列表就没有这样的保证了。因此，元组的角色类似于其他语言中的“常数”声明，

文件

内置open函数会创建一个Python文件对象，可以作为计算机上的一个文件链接。在调用open之后，你可以通过调用返回文件对象的方法来读写相关外部文件。

使用文件

• 虽然表中的读写方法都是常用的，但是要记住，现在从文本文件读取文字行的最佳方式是根本不要读取该文件,而是用迭代语句逐行读取。

• 注意从文件读取的数据回到脚本时是一个字符串。所以如果字符串不是你所需的，就得将其转换成其他类型的Python对象。同样，与print语句不同的是，当你把数据写入文件时，Python不会自动把对象转换为字符串——你必须传递一个已经格式化的字符串.

• 在Python中，一旦对象不再被引用，则这个对象的内存空间就会自动被收回。当文件对象被收回的时候，如果需要的话，Python也会自动关闭该文件。这就意味着你不需要总是手动去关闭文件，尤其是对于不会运行很长时间的简单脚本。另一方面，手动关闭调用没有任何坏处，而且在大型程序中通常是个很不错的习惯。
• 前面一段关于关闭文件的提示很重要，因为关闭既释放了操作系统资源也清空了缓冲区。默认情况下，输出文件总是缓冲的，这意味着写入的文本可能不会立即自动从内存转换到硬盘——关闭一个文件，或者运行其flush方法，迫使缓存的数据进入硬盘。

实际应用中的文件

• 使用eval可以把字符串转换成对象，它是一个功能强大的工具
• pickle模块是能够让我们直接在文件中存储几乎任何Python对象的高级工具，也并不要求我们把字符串转换来转换去。它就像是超级通用的数据格式化和解析工具

pickle.dump(D, F) 
 2015-05-13
 E = pickle.load(F) 

• struct模块能够构造并解析打包的二进制数据。从某种意义上说，它是另一个数据转换工具，它能够把文件中的字符串解读为二进制数据。

2015-05-14

重访类型分类

• 对象根据分类来共享操作；例如，字符串、列表和元组都共享诸如合并、长度和索引等序列操作。
• 只有可变对象（列表、字典和集合）可以原处修改；我们不能原处修改数字、字符串或元组。
• 文件导出唯一的方法，因此可变性并不真的适用于它们——当处理文件的时候，它们的状态可能会修改，但是，这与Python的核心类型可变性限制不完全相同。
• 表9-3中的“数字”包含了所有数字类型：整数（与Python 2.6的整数有区别）、浮点数、复数、小数和分数。
• 表9-3中的字符串包括str，以及Python 3.0中的bytes和Python 2.6中的unicode；Python 3.0中的bytearray字符串类型是可变的。
• 集合类似于一个无值的字典的键，但是，它们不能映射为值，并且没有顺序；因此，集合不是一个映射类型或者一个序列类型，frozenset是集合的一个不可变的版本。
• 除了类型分类操作，表9-3中的Python 2.6和Python 3.0的所有类型都有可调用的方法，这些方法通常特定于它们的类型。

对象类型	分类	是否可变
数字	数值	否
字符串	序列	否
列表	序列	是
字典	对应	是
元组	序列	否
文件	扩展	N/A
Sets	集合	是
frozenset	集合	否
bytearray(3.0)	序列	是

对象灵活性

列表、字典和元组可以包含任何种类的对象。
列表、字典和元组可以任意嵌套。
列表和字典可以动态地扩大和缩小。

引用VS拷贝

• 你可以在程序范围内任何地方传递大型对象而不必在途中产生拷贝。然而，如果你的确需要拷贝，那么可以明确要求。
• 没有限制条件的分片表达式（L[:]）能够复制序列。
• 字典copy方法（X.copy()）能够复制字典。
• 有些内置函数（例如，list）能够生成拷贝（list(L)）。
• copy标准库模块能够生成完整拷贝。
• 无条件值的分片以及字典copy方法只能做顶层复制。也就是说，不能够复制嵌套的数据结构（如果有的话）。如果你需要一个深层嵌套的数据结构的完整的、完全独立的拷贝，那么就要使用标准的copy模块——包括import copy语句，并编辑X=copy.deepcopy(Y)对任意嵌套对象Y做完整的复制。这一调用语句能够递归地遍历对象来复制它们所有的组成部分。

比较、相等性和真值

有两种方法可以测试相等性:

• “==”操作符测试值的相等性。Python运行相等测试，递归地比较所有内嵌对象。
• “is”表达式测试对象的一致性。Python测试二者是否是同一个对象（也就是说，在同一个内存地址中）。

>>> S1 = 'spam'
>>> S2 = 'spam'
>>> S1 == S2, S1 is S2
(True, True)

• 因为在Python内部暂时储存并重复使用短字符串作为最佳化，事实上内存里只有一个字符串’spam’供S1和S2分享。因此，”is”一致性测试结果为真。

• 数字通过相对大小进行比较。

• 字符串是按照字典顺序，一个字符接一个字符地对比进行比较（”abc”<”ac”）。
• 列表和元组从左到右对每部分的内容进行比较。
• 字典通过排序之后的（键、值）列表进行比较。字典的相对大小比较在Python 3.0中不支持，但是，它们在Python 2.6及更早的版本中有效，就像是比较排序的（键、值）列表一样。
• 数字混合类型比较（例如，1<’spam’）在Python 3.0中是错误的。Python 2.6中允许这样的比较，但是使用一种固定但任意的排序规则。通过代理，这也适用于排序，它在内部使用比较：非数字的混合类型集合不能在Python 3.0中排序。

Python中真和假的含义

数字如果非零，则为真。
其他对象如果非空，则为真。

None

None不是意味着“未定义”。也就是说，None是某些内容，而不是没有内容（尽管起名字是没有内容）——它是一个真正的对象，并且有一块内存，由Python给定一个内置的名称。

留意循环数据结构

如果遇到一个复合对象包含指向自身的引用，就称之为循环对象。无论何时Python在对象中检测到循环，都会打印成[…]，而不会陷入无限循环。

>>> L = ['grail']      # Append reference to same object
>>> L.append(L)        # Generates cycle in object: [...]
>>> L
['grail', [...]]

啊笔记比较乱，标题也是乱七八糟的，不知道是按时间还是按章节来，到现在才看到快四分之一(:з」∠)跪。