Python核心编程---读书笔记：第7章~第13章

所读的内容来源《Python核心编程》一书，以下是自己读书一些笔记。如有侵权，还请指出，会删除该博文。

 

第7章映射和集合类型

字典是映射类型，实现采用哈希值和指向的对象。

字典对象可变。

处理过程：对键执行哈希操作，根据计算结果在某个地址中存储你的值。

哈希表无序

Keys()或者values()返回列表

删除字典： dict1.clear()

删除字典元素： del dict1[‘name’], dict1.pop(‘name’):删除并返回值

7.2映射类型操作符

标准类型操作符： < .

查找操作符: []

键成员关系操作: in , not in

 

7.3映射类型的内建函数和工厂函数

7.3.1 标准类型函数[type() , str()和cmp()]

type():工厂方法，会会

str():返回字典的自复查un表示

字典比较：cmp(dict1 , dict2):

1）比较字典长度，dict1比dict2长，cmp()返回正值

2）长度相同，就比较键，

3）长度和键相同，比较值

 

dict()：工厂函数，创建字典

字典复制：推荐用copy()比从原字典生成的快，这是一个浅拷贝，对当前

拷贝的字典进行操作时，会影响到原来的字典

dict2 = dict1.copy()

 

import copy

#字典拷贝用dict.copy()速度比较快
def dictCopy_test():
    dict1 = {'x':1, 'y':2}
    dict2 = dict1.copy()
    print(str(dict2))

 

 

len(dict1):返回键值对的数目

 

hash():返回对象的哈希值，键必须是可哈希的

 

def hashTest():
    result = hash('hello world')
    print(result)

 

dict1.keys():返回所有键组成的列表

dict1.values():返回值组成的列表

dict1.items():返回所有键值对组成的列表

dict.iter():返回迭代子而非列表

dict.update(dict1):将字典dict1的键值对添加到字典dict中,重复的会被新的键值对来取代

dict.get(key,default=None)

dict.has_key(key)

 

7.5字典的键

不允许一个键对应多个值

键必须可哈希，不可变类型都是可哈希的，例如数字和字符串

实现了__hash__)的类可以返回整数，所以可以哈希

如果键是恶变对象，值可以变化，键变化，无法找到

元组必须只含有数字和字符串才可以作为键

 

7.6集合类型

set,集合是无需排列的可哈哈希值组成

集合创建用set()

访问集合中的值用in,not in

set1.remove(‘z’)

删除集合：del set1

 

7.7集合类型操作符

in, not in

两个集合相等：另一个集合中每个成员是另一个集合成员

set1 == set2

set1 < set2 :表示set1是set2的子集

联合(1): set1 | set2，会进行或操作

交集(&):返回一个集合，包含两个集合都存在的元素

差补：s – t,只属于集合s，部署于集合t

对称差分：异或，不能同时属于两个集合

 

def setOperationTest():
    set1 = set([1,2])#集合需要用数组初始化
    set2 = set([2,3])
    orSet = set1 | set2
    andSet = set1 & set2
    print(orSet)
    print(andSet)

 

7.7.3 集合类型操作符

Update (|=)：在已存在集合中添加成员，和update()等价

&=和intersection_update()等价：保留与其他集合共有成员

-= 差更新，

^=

 

7.8内建函数

set()生成可变集合，可传入序列

frozenset()不可变集合

 

方法：

s.issubset(t)

s.issuperset(t)

s.union(t):并集

s.intersection(t):交集

s.difference(t):返回的集合是s的成员，不是t成员

s.symmetric_difference(t):返回新集合，是s或t成员

 

可变集合:

add(),remove(),discard(),pop(),clear()

s.discard(obj):从集合s中删除对象obj

s.pop():删除集合s任意对象并返回

 

 

第8章条件和循环

 8.1if语句

多重条件表达式,and , or , not

elif:

三元操作符：

smaller = x if x < y else y

符合条件，返回前面的；否则，返回后面的

 

def getMin(num1 , num2):
    smaller = num1 if num1 < num2else num2
    return smaller

 

8.5 while语句

 

8.6 for语句

通过序列想迭代

for name in names:

         …

 

通过索引迭代

for i in range(len(names)):

 

 

8.6.3用于迭代器类型

迭代器对象有next()方法，返回下一条目

迭代完成用StopIteration除法异常

 

range(end)

range(start ,end)

 

 

与序列相关的内建函数

sorted() , reversed() , enumerate() , zip()

 

8.9 pass语句

pass不做任何事情，用于标记以后将要完成的代码

 

8.11 迭代器和iter()函数

迭代器是数据结构，可以迭代至最后一个元素

迭代器作用：迭代醒呢个提升，可扩展

迭代方法：next()获取对象，全部获取会引发StopIteration异常

迭代器去诶an：不能回到开始，不能复制迭代器

 

#迭代器
def iterTest():
    nums = range(1,11)
    it = iter(nums)
    while True:
        try:
            value = it.__next__() #注意这里不是next()
            print(value)
        except StopIteration:
            break

 

文件的迭代：

调用readline()方法就是迭代

myfile = open(‘data.txt’)

for eachline in myFile:

         prnt(eachline)

 

8.11.5可变对象和迭代器

迭代时如果改变元素（删除），是不会执行的

创建迭代器

iter(obj)

iter(func , sentinel): sentinel:哨兵

实现了__iter__()和next()方法的类可以作为迭代器使用

传递两个参数，会重复调用func，直到下一个值为sentinel

 

8.12列表解析

列表解析：可以只使用一句话进行操作

语法: [expr  for iter_var initerable]

[x ** 2 for x in range(6)]

filter(func , seq):

 

def filterTest():
    nums = range(1,11)
    results = filter(lambdax : x % 2 , nums)
    print(results)

 

#三行5列矩阵，矩阵迭代，前面是元素(x,y)后面先是行循环，然后是列循环
def matrixIter():
    nums = [(x+1 , y+1)for x inrange(3)for y inrange(5)]
    print(nums)

 

8.13生成器表达式

生成器表达式是列表解析的扩展

生成器含义：是一个函数，允许返回值，暂停代码的执行，之后恢复

生成器实现原理：生成器每次计算出一个条目后，把条目通过yield产生出来，生成器采用延迟计算，省内存

 

列表解析缺点：需要生成所有数据，大数据性能不好

列表解析是方括号，生成器是圆括号

[expr for iter_val in iterable if cond_expr]

(expr for iter_val in iterable if cond_expr)

计算非空字符总和

sum(len(word) for line in data for word inline.split() )

寻找最长文件

max( len(x.strip()) for x in open(‘/etc/motd’))

 

第9章文件和输入输出

9.1文件对象

open(file_name ,access_mode=’r’ ,buffering=-1)

 

内建函数file()与open()相同

通用换行符支持UNS

read():读取字节到字符串

readline():读取文件一行

readlines():读取所有行作为字符串列表返回

 

write():字符串写入到文件

writelines():针对列表操作

 

文件内移动

seek():文件中移动文件指针到不同位置

offset:

 

文件迭代:

for eachline in f:

close():关闭文件

flush():把缓冲区数据写入文件

truncate(size):最多截取到size字节处，没有，就截取到文件位置

 

9.6命令行参数

sys.argv:参数列表

 

9.7文件系统

文件访问操作通过os模块实现

os.path模块中

basename():去掉目录路径，返回文件名

dirname():去掉文件名，返回目录路径

split():返回(dirname() ,basename())的元组

 

9.8文件执行

 

9.9永久存储模块

pickle和marshal将复杂对象转换为二进制数据集合，然后发送

称为：数据的序列化

pickle:可以处理递归对象

 

9.9.2DBM风格的模块

采用dbhash,dbm,anydbm选择对象，只能存储自复查un，不能对python对象进行序列化

 

9.9.3shelve模块

shelve:把书放在架子上

原理：使用anydbm寻找dbm模块，使用cPickle完成储存转换过程

pickle:会把python对象保存到文件(二进制)。

dump():接受文件句柄和数据对象作为参数，把数据保存到给定文件【序列化】

load():从文件中取出已经保存的对象【解析】

gzip,zlib:压缩

tempfile:生成临时文件

 

 

第10章错误和异常

try-except和tr-finally:互斥

except Exception[,reason]

捕获所有异常:Exception是在最底层

try:

except Exception , ex:

reason:将会包含异常信息诊断的实例

 

10.4 上下文管理

10.4.1 with语句

with作用：简化代码，with用于线程资源，文件，数据库；连接

with open(‘data.txt’ , ‘r’) as f:

         forline in f:

 

10.6触发异常

raise语句: raise[SomeException[,args , [, traceback ]]]

 

10.7断言

断言含义：是一个等于布尔真的判定，发生异常表示表达式为假

 

assert expression[ , arguments]

assert 2 + 2 == 2 * 2

 

10.9 *创建异常

 

10.12 异常和sys模块

获取异常方法:sys.exec_info()

得到异常类，实例，追踪对象

 

 

第11章函数和函数式编程

11.1 什么是函数？

函数：逻辑结构化的编程方法

如果没有返回元素，python返回None

元组关键字: *tuple_args

字典关键字: **dict_args

 

 

python不允许函数未声明前对其引用或调用

 

函数属性：

内嵌函数：函数体内创建另一个函数是合法的。

 

11.3.6函数装饰器

装饰器：以@开头，包含名字和可选参数

@decorator(args)

def func2(funcArgs)

 

静态方法装饰器

class MyClass(object):

@staticmethod

def staticFunc():

 

 

class MyClass(object):
    def __init__(self, name):
        self.name= name

    @staticmethod
    def show():
        print("static method")

if __name__ == "__main__":
    myClass = MyClass('dong')
    MyClass.show()

 

 

装饰器堆叠：

@deco2

@deco1

def func()

…

 

func = deco2(deco1(func))

 

 

有参数和无参数的装饰器

装饰器的本质：是函数，接受函数作为参数，返回另一个函数    

                   作用：日志，检测性能，加入事务

 

11.6.1非关键字可变长参数(元组)

可变长的参数元组必须在位置和默认参数之后，带元组或非关键字可变长参数）

def func_time(formal_args , *vargs_tuple):

添加可变参数列表变量，处理超出数目的参数

 

def tupleArgs(arg1 , arg2='2', *otherArgs):
    print(arg1)
    print(arg2)
    print(*otherArgs)

 

 

11.6.2关键字变量参数

def func(formal_args , *tuple_args ,**dict_args )

 

 

11.7函数式编程

lambda关键字创造匿名函数，匿名是因为不需要以标准的方式声明

lambda本质是一个表达式，定义和声明在同一行

lambda[arg1 , arg2 , …,argn] : expression

参数可选，

lambda表达式中前面是参数，后面是表达式，返回可调用的函数

def true() : return True

a = lambda x , y = 2 : x + y

 

11.7内建函数apply(),filter(),map(),reduce()

apply(func , nkw , kw):用可选参数调用func,nkw:非关键字参数,

kw关键字参数

map(func , seq1 , seq2…):将函数func作用于给定序列(s)每个元素，并返回列表，相当于对列表中每个元素进行处理

reduce(func , seq [, init]):将二元函数作用于seq序列元素，每次携带一堆

先前结果和下一个序列元素，若init设定，第一个是init和第一个序列元素

 

# map(func , seq): map对序列中每个元素value调用func(seq)，并返回处理后的序列
def mapTest():
    nums = [i for i inrange(1,6)]
    results = map(lambdax : x + 2 , nums)
    for i inresults:
        print(i)

 

map(lambda x , y : x + y , [1,3,5],[2,4,6])

 

reduce():进行折叠，等于每次从序列中取出两个元素进行运算，

有点类似于。典型的一个应用：求序列元素累加和

reduce(func , seq [, init]):

 

# reduce(func , seq ,init): 将序列中前一次运算结果和当前元素进行某种操作，直到最后只有一个元素
def reduceTest():
    nums = [i for i inrange(1,11)]
    sum = reduce( (lambda x, y : x + y) , nums)
    print(sum)
    nums = [i for i inrange(1,11)]
    sum = reduce( (lambda x, y : x + y) , nums ,45)
    print(sum)

 

 

11.8变量作用域

搜索标识符：先从局部作用域开始，，然后寻找全局域

全局变量名字会被局部变量覆盖掉

global

 

 

11.8.4闭包

闭包：将内部函数代码，作用域，外部函数的作用结合起来

 

 

11.8.5作用域和lambda

 

11.9递归

def fac(n):

  ifn == 0 or n == 1:

         return1

 else:

         returnn * fac(n-1)

 

11.10生成器

协同程序:运行独立函数调用，可以暂停或挂起

生成器含义：带有yield语句的函数，能暂停执行并返回中间结果

yield功能:返回一个值给调用者并暂停执行

适用：迭代大的数据集，可节省内存，自动推算下一个结果

next():获得下个生成的值

将值送给生成器send()，yield语句是表达式

close()结束

 

第12章模块

模块：允许调入模块，导入import

名称空间：名称到对象的关系映射

解释器启动后，访问搜索路径，保存在sys模块的sys,path变量

 

 

12.3名称空间

名称空间：名称到对象的映射

名称空间种类：局部名称空间，全局名称空间，内建名称空间

加载顺序：先加载内建名称空间，然后是全局，最后是活动名称空间

__builtins__:模块中名字构成

__builtin__:

 

导入模块顺序：

Python标准库模块，python第三方模块，自定义模块

 

多行导入

from Tkinter import Tk , Frame , Button,Entry, \

 Text

 

12.4.4扩展import 语句(as)

导入模块名字太长或者名称已经被使用用as

import numpy as np

 

12.5模块导入的特性

载入时执行模块：

一个模块只被加载一次，无论被导入多少次，防止多次执行

导入名称: from module import var

 

12.5.5 关于__future__

从zip文件中导入模块

 

globals():返回调用者全局名称空间

locals():

 

12.6.3 reload()

reload(module):重新导入已经导入的模块，模块是全部导入

 

12.7 包

包：由模块和子包组成。包含__init__.py

from package.module import *

 

绝对导入

from Analog import dial

相对导入

from Phone.Mobile.Analog import dial

from .Analog import dial

 

12.8模块其他特性

组织属性导入，不想导入属性名称加下划线_

 

导入循环：解决办法，移除其中一个导入语句

把import语句一道到函数内部，确保用到的时候才被导入

def test():

         importTest

         Test.func()

 

12.8.5模块执行

 

 

第13章  面向对象编程

13.1介绍

经典类：没有父类的类

类中参数self等同于this

__init__() 类似于类的构造器，python创建对象时就会执行该方法

 

子类的初始化时，先调用父类的构造函数初始化，子类需要定义自己构造器，否则基类构造器会被调用，若子类重写构造器，父类的不会被调用

def __init__(self , name , phone , id):

         ParentClass.__init__(self, name , phone)

         self.id= id

 

 

多态：一个操作，多个响应

反射：对象在运行期获取自身信息

静态成员：跟踪与类相关的值

class Test(object):

         name= ‘dong’ #静态成员

dir(对象)：返回对象的属性名字列表

 

 

13.4.3特殊的类属性

C.__name__ :类的名字

C.__doc__ : 类C的文档字符串

C.__bases__: 类C的所有父类构成的元组

C.__dict__ ：属性

C.__module__: 类C所在模块

C.__class__ ：实例C对应的类

 

__new__():调用类的__new__()方法，是静态方法，会调用父类的__new__()来创建对象

__del__():解构器方法，只能被调用一次

总结：

1先调用父类的__del__()

尽量不要实现__del__()

 

13.6.1实例化实例属性

在运行时创建实例属性，python是动态语言，允许对象属性动态创建

修改静态成员变量危险