Python核心编程第二版第六章学习笔记

一.序列
它们的成员有序排列的,并且可以通过下标 偏移量访问到它的一个或者几个成员,这类Python 类型统称为序列,包括下面这些: 字符串 (普 通字符串和unicode 字符串), 列表 ,和 元组 类型。
1.序列类型操作符

序列操作符                    作用
seq[ind]                      获得下标为ind 的元素
seq[ind1:ind2]                获得下标从ind1 到ind2 间的元素集合
seq * expr                    序列重复expr 次
seq1 + seq2                   连接序列seq1 和seq2
obj in seq                    判断obj 元素是否包含在seq 中,返回bool类型值
obj not in seq                判断obj 元素是否不包含在seq 中, 返回bool类型值
特殊举例:
>>> s = 'abcdefgh'
>>> s[::-1] # 可以视作"翻转"操作
'hgfedcba'
>>> s[::2] # 隔一个取一个的操作
'aceg'
有一个字符串,我们想通过一个循环按照这样的形式显示它:每次都把 位于最后的一个字符砍掉,下面是实现这个要求的一种方法:
>>> s = 'abcde'
>>> i = -1
>>> for i in range(-1, -len(s), -1)             #range(-1,-5,-1)=[-1,-2,-3,-4]
... print s[:i]
abcd
abc
ab
a
如果要遍历序列中的每个元素:用None 作为索引值,这样一来就可以满足你的需要,比 如说,在你想用一个变量作为索引来从第一个到遍历最后一个元素的时候:

>>> s = 'abcde'
>>> for i in [None] + range(-1, -len(s), -1):   #[None]+range(-1,-len(s),-1)=[None,-1,-2,-3,-4]
... print s[:i]                                 #s[:None]=abcde
...
abcde
abcd
abc
ab
a

2.序列内建类型转换工厂函数
函数                        含义
list(iter)                  把可迭代对象转换为列表
str(obj)                    把obj 对象转换成字符串(对象的字符串表示法)
unicode(obj)                把对象转换成Unicode 字符串(使用默认编码)
basestring()                抽象工厂函数,其作用仅仅是为str 和unicode 函数提供父类,所以不能被 实例化,也不能被用
tuple(iter)                 把一个可迭代对象转换成一个元组对象
这些转换实际上是工厂函数 ,将对象作为参数,并将其内容(浅)拷贝到新生成的对象中
浅拷贝
所谓浅拷贝就是只拷贝了对象的索引,而不是重新建立了一个对象!
3.序列功能性函数
函数名                                           功能
enumerate(iter) a                                                                  接受一个可迭代对象作为参数,返回一个enumerate 对象(同 时也是一         个迭代器),该对象生成由iter 每个元素的index 值 和item 值组成的元组。

len(seq)                                         返回seq 的长度

max(iter,key=None) or max(arg0,arg1...,key=None) b    返回iter 或(arg0,arg1,...)中的最大值,如果指定了key, 这个key 必   须是一个可以传给sort()方法的,用于比较的回 调函数.

min(iter, key=None) or min(arg0, arg1.... key=None) 返回iter 里面的最小值;或者返回(arg0,arg2,...)里面 的最小值;如  果指定了key,这个key 必须是一个可以传给 sort()方法的,用于比较的回调函数.
reversed(seq) c                                                                           接受一个序列作为参数,返回一个以逆序访问的迭代器

sorted(iter, func=None, key=None, reverse=False) c            接受一个可迭代对象作为参数,返回一个有序的列表;可选参数
func,key 和reverse 的含义跟list.sort()内建函数的参数含义一 样.

sum(seq, init=0) a                                                                       返回seq 和可选参数init 的总和, 其效果等同   reduce(operator.add,seq,init)
zip([it0, it1,... itN]) d                                                        返回一个列表,其第一个元素是it0,it1,...这些元素的第 一个元素
                                                     组成的一个元组,第二个...,类推.
二.字符串、列表、元组
1.字符串
编译时字符串连接


>>> foo = "Hello" 'world!'
>>> foo
'Helloworld!'

通过这种方法,你可以把长的字符串分成几部分来写,而不用加反斜杠。如上所示, 你可以在一行里面混用两种分号。这种写法的好处是你可以把注释也加进来,如下:

>>> f = urllib.urlopen(' http://'  # protocol
... 'localhost' # hostname
... ':8000' # port
... '/cgi-bin/friends2.py') # file
如你所想,下面就是urlopen()方法所得到的真实输入:
>>> ' http://'  'localhost' ':8000' '/cgi-bin/friends2.py'

普通字符串转化为Unicode 字符串
如果把一个普通字符串和一个Unicode 字符串做连接处理,Python 会在连接操作前先把普 通字符串转化为Unicode 字符串:
>>> 'Hello' + u' ' + 'World' + u'!'
u'Hello World!'
只适用于字符串的操作符
(1) 格式化操作符( % )
格式化字符                       转换方式
%c                               转换成字符(ASCII 码值,或者长度为一的字符串)
%r a                                                             优先用repr()函数进行字符串转换
%s                               优先用str()函数进行字符串转换
%d / %i                          转成有符号十进制数
%u b                                                             转成无符号十进制数
%o b                                                              转成无符号八进制数
%x b /%X b (Unsigned)                 转成无符号十六进制数(x/X 代表转换后的十六进制字符的大 小写)
%e/%E                            转成科学计数法(e/E 控制输出e/E)
%f/%F                            转成浮点数(小数部分自然截断)
%g/%G                            %e 和%f/%E 和%F 的简写
%%                               输出%
格式化操作符辅助指令
符号                作用
  •                定义宽度或者小数点精度
-                   用做左对齐
+                   在正数前面显示加号( + )
<sp>                在正数前面显示空格
#                   在八进制数前面显示零('0'),在十六进制前面显示'0x'或者'0X'(取决于 用的是'x'还是'X')
0                   显示的数字前面填充‘0’而不是默认的空格
% '%%'              输出一个单一的'%'
(var)               映射变量(字典参数)
m.n                 m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)
原始字符串操作符( r/R )
为了对付那些在字符串中出现 的特殊字符(下面的小节会介绍这些特殊字符)。在原始字符串里,所有的字符都是直接按照字
面的意思来使用,没有转义特殊或不能打印的字符。
2.列表
(1)如何删除列表中的元素或者列表(本身)
要删除列表中的元素,如果你确切的知道要删除元素的素引可以用del 语句,否则可以用 remove()方法.

>>> aList
[123, 'abc', 'float replacer', ['inner', 'list'], (7-9j)]
>>> del aList[1]
>>> aList
[123, 'float replacer', ['inner', 'list'], (7-9j)]
>>> aList.remove(123)
>>> aList
['float replacer', ['inner', 'list'], (7-9j)]

(2)连接接操作符( + )
连接操作符允许我们把多个列表对象合并在一起.注意, 列表类型的连接操作也只能在同类 型之间进行 ,换句话说, 你不能把两个不同类型的对象连接在一起,即便他们都是序列类型也不 .
3)列表的比较方法
1. 对两个列表的元素进行比较.
2. 如果比较的元素是同类型的,则比较其值,返回结果.
3. 如果两个元素不是同一种类型,则检查它们是否是数字.
    a. 如果是数字,执行必要的数字强制类型转换,然后比较.
    b. 如果有一方的元素是数字,则另一方的元素"大"(数字是"最小的")
    c. 否则,通过类型名字的字母顺序进行比较.
4. 如果有一个列表首先到达末尾,则另一个长一点的列表"大".
5. 如果我们用尽了两个列表的元素而且所有元素都是相等的,那么结果就是个平局,就 是说返回一个0.
(4) sorted() and reversed()
>>> s = ['They', 'stamp', 'them', 'when', "they're", 'small']
>>> for t in reversed(s):
... print t,
...
small they're when them stamp They
>>> sorted(s)
['They', 'small', 'stamp', 'them', "they're", 'when']
(5)list() and tuple()
list()函数和tuple()函数接受可迭代对象(比如另一个序列)作为参数,并通过浅拷贝数据 来创建一个新的列表或者元组.

>>> aList = ['tao', 93, 99, 'time']
>>> aTuple = tuple(aList)
>>> aList, aTuple
(['tao', 93, 99, 'time'], ('tao', 93, 99, 'time'))
>>> aList == aTuple
False
>>> anotherList = list(aTuple)
>>> aList == anotherList
True
>>> aList is anotherList
False
>>> [id(x) for x in aList, aTuple, anotherList]
[10903800, 11794448, 11721544]

无论list()还是tuple()都不可能做完全的转换 .也就是说,你传给tuple()的一个列表对象不可能变成一个元组,而你传给list()的 对象也不可能真正的变成一个列表.虽然前后两个对象(原来的和新的对象)有着相同的数据集 合(所以相等 == ),但是变量指向的却不是同一个对象了(所以执行 is 操作会返回false).还 要注意,即使它们的所有的值都相同,一个列表也不可能"等于"一个元组.
(6) 列表类型内建函数
List Method                           Operation
list.append(obj)                      向列表中添加一个对象obj
list.count(obj)                       返回一个对象obj 在列表中出现的次数
list.extend(seq)                        把序列seq 的内容添加到列表中
list.index(obj, i=0, j=len(list))      返回list[k] == obj 的k 值,并且k 的范围在 i<=k<j;否则 引发ValueError 异常.
list.insert(index, obj)               在索引量为index 的位置插入对象obj.
list.pop(index=-1) a                   删除并返回指定位置的对象,默认是最后一个对象
list.remove(obj)                      从列表中删除对象obj
list.reverse()                        原地翻转列表
list.sort(func=None,key=None, reverse=False) b 以指定的方式排序列表中的成员,如果func 和key 参数指定, 则按照指定的方式比较各个元素,如     果reverse 标志被置为 True,则列表以反序排列.
(6) 核心笔记:那些可以改变对象值的可变对象的方法是没有返回值的!
Python 初学者经常会陷入一个误区:调用一个方法就返回一个值.最明显的例子就是 sort():
>>> music_media.sort()# 没有输出?
>>
在使用可变对象的方法如sort(),extend()和reverse()的时候要注意,这些操作会在列表 中原地执行操作,也就是说现有的列表内容会被改变,但是没有返回值!是的,与之相反,字符串 方法确实有返回值:


>>> 'leanna, silly girl!'.upper()
'LEANNA, SILLY GIRL!'

温习一下,字符串是不可变的 -- 不可变对象的方法是不能改变它们的值的,所以它们必须 返回一个新的对象.如果你确实需要返回一个对象。
3 元组
(1)创建一个元组并给它赋值

>>> aTuple = (123, 'abc', 4.56, ['inner', 'tuple'], 7-9j)
>>> anotherTuple = (None, 'something to see here')
>>> print aTuple
(123, 'abc', 4.56, ['inner', 'tuple'], (7-9j))
>>> print anotherTuple
(None, 'something to see here')
>>> emptiestPossibleTuple = (None,)
>>> print emptiestPossibleTuple
(None,)
>>> tuple('bar')
('b', 'a', 'r')
(2) 元组也不是那么“不可变”
你可以“修改”特定的元组元素,哇!这意味着什么?
虽然元组对象本身是不可变的,但这并不意味着元组包含的可变对象也不可变了。
>>> t = (['xyz', 123], 23, -103.4)
>>> t
(['xyz', 123], 23, -103.4)
>>> t[0][1]
123
>>> t[0][1] = ['abc', 'def']
>>> t
(['xyz', ['abc', 'def']], 23, -103.4)
3) 默认集合类型
所有的多对象的,逗号分隔的,没有明确用符号定义的,比如说像用方括号表示列表和用 圆括号表示元组一样,等等这些集合默认的类型都是元组,下面是一个简单的示例:


>>> 'abc', -4.24e93, 18+6.6j, 'xyz'
('abc', -4.24e+093, (18+6.6j), 'xyz')
>>>
>>> x, y = 1, 2
>>> x, y
(1, 2)
(4) 单元素元组
曾经试过创建一个只有一个元素的元组?你在列表上试过,它可以完成,但是无论你怎么 在元组上试验,你都不能得到想要的结果。
>>> ['abc']
['abc']
>>> type(['abc']) # a list
<type 'list'>
>>>
>>> ('xyz')
'xyz'
>>> type(('xyz')) # a string, not a tuple
<type 'str'>

或许你忘记了圆括号被重载了,它也被用作分组操作符。由圆括号包裹的一个单一元素首 先被作为分组操作,而不是作为元组的分界符。一个变通的方法是在第一个元素后面添一个逗 号(,)来表明这是一个元组而不是在做分组操作.

>>> ('xyz',)
('xyz',)
(5) 核心笔记:列表 VS 元组
一个经常会被问到的问题是,"为什么我们要区分元组和列表变量?"这个问题也可以被表
述为“我们真的需要两个相似的序列类型吗?”, 一个原因是在有些情况下 ,使用其中的一种类 型要优于使用另一种类型。 最好使用不可变类型变量的一个情况是,如果你在维护一些敏感的数据,并且需要把这些 数据传递给一个并不了解的函数(或许是一个根本不是你写的API),作为一个只负责一个软件 某一部分的工程师,如果你确信你的数据不会被调用的函数篡改,你会觉得安全了许多。
一个需要可变类型参数的例子是,如果你在管理动态数据集合时。你需要先把它们创建出 来,逐渐地或者不定期的添加它们,或者有时还要移除一些单个的元素。这是一个必须使用可 变类型对象的典型例子。幸运的是,通过内建的list()和tuple()转换函数,你可以非常轻松 的在两者之间进行转换.
list()和tuple()函数允许你用一个列表来创建一个元组,反之亦然.如果你有一个元组变 量,但你需要一个列表变量因为你要更新一下它的对象,这时list()函数就是你最好的帮手.如 果你有一个列表变量,并且想把它传递给一个函数,或许一个API,而你又不想让任何人弄乱你 的数据,这时tuple()函数就非常有用。
(6) 拷贝Python 对象
浅拷贝和深拷贝
三. 把Unicode 应用到实际应用中
�� 程序中出现字符串时一定要加个前缀 u.
�� 不要用 str()函数,用unicode()代替.
�� 不要用过时的 string 模块 -- 如果传给它的是非ASCII 字符,它会把一切搞砸。
�� 不到必须时不要在你的程序里面编解码 Unicod 字符.只在你要写入文件或数据库或者
     网络时,才调用encode()函数;相应地,只在你需要把数据读回来的时候才调用decode() 函数.
Python 标准库里面的绝大部分模块都是兼容Unicode 的.除了pickle 模块!pickle 模块只 支持ASCII 字符串.
四.Python 的Unicode 支持
1.内建的unicode()函数
Unicode 的工厂方法,同Unicode 字符串操作符(u / U)的工作方式很类似,它接受一个 string 做参数,返回一个Unicode 字符串.
2.内建的decode()/encode()方法
decode()和encode()内建函数接受一个字符串做参数返回该字符串对应的解码后/编码后 的字符串.decode()和encode()都可以应用于常规字符串和Unicode 字符串.
3.Unicode 类型
Unicode 字符串对象是basestring 的子类、用Unicode()工厂方法或直接在字符串前面加 一个u 或者U 来创建实例.支持Unicode 原始字符串,只要在你的字符串前面加一个ur 或者UR 就可以了.
4.Unicode 序数
标准内建函数ord()工作方式相同,最近已经升级到可以支持Unicode 对象了。内建的 unichr()函数返回一个对应的Unicode 字符(需要一个32 位的值);否则就产生一个ValueError 异常.
5.强制类型转换
混合类型字符串操作需要把普通字符串转换成Unicode 对象.
6.异常
UnicodeError 异常是在exceptions 模块中定义的,ValueError 的子类.所有关于Unicode 编解码的异常都要继承自UnicodeError.详见encode()函数.
7.RE 引擎对Unicode 的支持
编码                   描述
utf-8                  变量长度为8 的编码(默认编码)
utf-16                 变量长度为16 的编码(大/小端)
utf-16-le              小端UTF-16 编码
utf-16-be              大端UTF-16 编码
ascii 7-bit            7 位ASCII 码表
iso-8859-1             ISO 8859-1 (Latin-1) 码表
unicode-escape         (定义见Python Unicode 构造函数)
raw-unicode-escape     (定义见Python Unicode 构造函数)
native                 Python 用的内部格式
8.字符串格式化操作符
对于Python 的格式化字符串的操作符,%s 把Python 字符串中的Unicode 对象执行了 str(u)操作,所以,输出的应该是u.encode(默认编码).如果格式化字符串是Unicode 对象,所 有的参数都将首先强制转换成Unicode 然后根据对应的格式串一起进行格式转换.数字首先被 转换成普通字符串, 然后在转换成Unicode.Python 字符串通过默认编码格式转化成
Unicode.Unicode 对象不变,所有其他格式字符串都需要像上面这样转化,下面是例子:
u"%s %s" % (u"abc", "abc")   u"abc abc"








©️2020 CSDN 皮肤主题: 编程工作室 设计师:CSDN官方博客 返回首页