python学习手册附录_python学习手册附录a在哪 - CSDN
  • Python学习手册(第4版)的第8部分(高级话题部分)和 附录,pdf格式
  • Python学习手册(第4版)-补充文章(8,9部分)-PDF高清电子版本 书本缺少的章节的电子资源:第八部分(高级话题)内容,第九部分(附录)内容
  • 人们为何使用Python19 软件质量20 开发效率21 Python是“脚本语言”吗21 好吧,Python的缺点是什么呢23 如今谁在使用Python23 使用Python可以做些什么24 系统编程25 用户图形接口25 Internet脚本25 组件...

    目录
    前言1
    第一部分 使用入门
    第1章 问答环节19
    人们为何使用Python19
    软件质量20
    开发效率21
    Python是“脚本语言”吗21
    好吧,Python的缺点是什么呢23
    如今谁在使用Python23
    使用Python可以做些什么24
    系统编程25
    用户图形接口25
    Internet脚本25
    组件集成26
    数据库编程26
    快速原型27
    数值计算和科学计算编程27
    游戏、图像、人工智能、XML、机器人等27
    Python如何获得支持28
    Python有哪些技术上的优点28
    面向对象28
    免费29
    可移植29
    功能强大30
    可混合31
    简单易用31
    简单易学32
    Python和其他语言比较起来怎么样32
    本章小结33
    本章习题33
    习题解答34
    Python是工程,不是艺术34

    第2章 Python如何运行程序36
    Python解释器简介36
    程序执行37
    程序员的视角37
    Python的视角39
    执行模块的变体41
    Python实现的替代者42
    执行优化工具43
    冻结二进制文件44
    其他执行选项45
    未来的可能性46
    本章小结46
    本章习题47
    习题解答47

    第3章 如何运行程序48
    交互提示模式下编写代码48
    交互地运行代码49
    为什么使用交互提示模式51
    使用交互提示模式52
    系统命令行和文件54
    第一段脚本55
    使用命令行运行文件56
    使用命令行和文件57
    UNIX可执行脚本(#!)58
    UNIX env查找技巧59
    点击文件图标60
    在Windows中点击图标60
    input的技巧61
    图标点击的其他限制63
    模块导入和重载63
    模块的显要特性:属性65
    import和reload的使用注意事项68
    使用exec运行模块文件69
    IDLE用户界面70
    IDLE基础71
    使用IDLE72
    高级IDLE工具74
    其他的IDE74
    其他启动选项76
    嵌入式调用76
    冻结二进制的可执行性77
    文本编辑器启动的选择77
    其他的启动选择77
    未来的可能77
    我应该选用哪种78
    调试Python代码78
    本章小结80
    本章习题80
    习题解答80
    第一部分 练习题81

    第二部分 类型和运算
    第4章 介绍Python对象类型87
    为什么使用内置类型88
    Python的核心数据类型88
    数字90
    字符串92
    序列的操作92
    不可变性94
    类型特定的方法94
    寻求帮助96
    编写字符串的其他方法97
    模式匹配98
    列表98
    序列操作98
    类型特定的操作99
    边界检查100
    嵌套100
    列表解析101
    字典103
    映射操作103
    重访嵌套104
    键的排序:for 循环105
    迭代和优化107
    不存在的键:if 测试107
    元组109
    为什么要用元组109
    文件110
    其他文件类工具111
    其他核心类型111
    如何破坏代码的灵活性113
    用户定义的类114
    剩余的内容115
    本章小结115
    本章习题116
    习题解答116

    第5章 数字117
    Python的数字类型117
    数字常量118
    内置数学工具和扩展119
    Python表达式操作符120
    在实际应用中的数字125
    变量和基本的表达式125
    数字显示的格式126
    比较:一般的和连续的127
    str和repr显示格式128
    除法: 传统除法、Floor除法和真除法129
    整数精度133
    复数133
    十六进制、八进制和二进制记数134
    位操作136
    其他的内置数学工具137
    其他数字类型139
    小数数字139
    分数类型141
    集合145
    布尔型151
    数字扩展152
    本章小结153
    本章习题153
    习题解答153

    第6章 动态类型简介155
    缺少类型声明语句的情况155
    变量、对象和引用156
    类型属于对象,而不是变量157
    对象的垃圾收集158
    共享引用159
    共享引用和在原处修改161
    共享引用和相等163
    动态类型随处可见164
    本章小结165
    本章习题165
    习题解答165

    第7章 字符串167
    字符串常量169
    单双引号字符串是一样的170
    用转义序列代表特殊字节171
    raw字符串抑制转义173
    三重引号编写多行字符串块175
    实际应用中的字符串176
    基本操作176
    索引和分片177
    为什么要在意:分片181
    字符串转换工具181
    修改字符串184
    字符串方法185
    字符串方法实例:修改字符串187
    字符串方法实例:文本解析189
    实际应用中的其他常见字符串方法190
    最初的字符串模块(在Python 3.0中删除)191
    字符串格式化表达式192
    更高级的字符串格式化表达式194
    基于字典的字符串格式化196
    字符串格式化调用方法196
    基础知识197
    添加键、属性和偏移量198
    添加具体格式化198
    与%格式化表达式比较200
    为什么用新的格式化方法203
    通常意义下的类型分类206
    同样分类的类型共享其操作集合206
    可变类型能够在原处修改207
    本章小结208
    本章习题208
    习题解答208

    第8章 列表与字典210
    列表210
    实际应用中的列表213
    基本列表操作213
    列表迭代和解析213
    索引、分片和矩阵214
    原处修改列表215
    字典220
    实际应用中的字典222
    字典的基本操作222
    原处修改字典223
    其他字典方法224
    语言表225
    字典用法注意事项226
    为什么要在意字典接口229
    创建字典的其他方法230
    Python 3.0中的字典变化231
    本章小结237
    本章习题237
    习题解答237

    第9章 元组、文件及其他239
    元组239
    实际应用中的元组241
    为什么有了列表还要元组243
    文件243
    打开文件244
    使用文件245
    实际应用中的文件246
    其他文件工具252
    重访类型分类254
    为什么要在意操作符重载255
    对象灵活性255
    引用 VS 拷贝256
    比较、相等性和真值258
    Python 3.0的字典比较260
    Python中真和假的含义261
    Python的类型层次263
    Type对象263
    Python中的其他类型265
    内置类型陷阱265
    赋值生成引用,而不是拷贝265
    重复能够增加层次深度266
    留意循环数据结构266
    不可变类型不可以在原处改变267
    本章小结267
    本章习题268
    习题解答268
    第二部分练习题269

    第三部分 语句和语法
    第10章 Python语句简介275
    重访Python程序结构275
    Python的语句276
    两个if的故事278
    Python增加了什么279
    Python删除了什么279
    为什么使用缩进语法281
    几个特殊实例283
    简短实例:交互循环285
    一个简单的交互式循环285
    对用户输入数据做数学运算287
    用测试输入数据来处理错误288
    用try语句处理错误289
    嵌套代码三层290
    本章小结290
    本章习题291
    习题解答291

    第11章 赋值、表达式和打印292
    赋值语句292
    赋值语句的形式293
    序列赋值294
    Python 3.0中的扩展序列解包297
    多目标赋值语句301
    增强赋值语句302
    变量命名规则305
    Python的废弃协议306
    表达式语句308
    表达式语句和在原处的修改309
    打印操作310
    Python 3.0的print函数311
    Python 2.6 print语句313
    打印流重定向315
    版本独立的打印318
    为什么要注意print和stdout319
    本章小结320
    本章习题321
    习题解答321

    第12章 if测试和语法规则322
    if语句322
    通用格式322
    基本例子323
    多路分支323
    Python语法规则325
    代码块分隔符326
    语句的分隔符328
    一些特殊情况329
    真值测试330
    if/else三元表达式332
    为什么要在意布尔值334
    本章小结335
    本章习题335
    习题解答335

    第13章 while和for循环336
    while循环336
    一般格式336
    例子337
    break、continue、pass和循环else338
    一般循环格式338
    pass338
    continue340
    break340
    循环else341
    为什么要在意“模拟C 语言的while循环”342
    for循环343
    一般格式343
    例子344
    为什么要在意“文件扫描”349
    编写循环的技巧350
    循环计数器:while和range351
    非完备遍历:range和分片352
    修改列表:range353
    并行遍历:zip和map354
    产生偏移和元素:enumerate357
    本章小结358
    本章习题358
    习题解答359

    第14章 迭代器和解析,第一部分360
    迭代器:初探360
    文件迭代器361
    手动迭代:iter和next363
    其他内置类型迭代器365
    列表解析:初探367
    列表解析基础知识368
    在文件上使用列表解析369
    扩展的列表解析语法370
    其他迭代环境371
    Python 3.0中的新的可迭代对象375
    range迭代器376
    map、zip和filter迭代器377
    多个迭代器 VS单个迭代器378
    字典视图迭代器379
    其他迭代器主题381
    本章小结381
    本章习题381
    习题解答382

    第15章 文档383
    Python文档资源383

    注释384

    dir函数384
    文档字符串:__doc__385
    PyDoc:help函数388
    PyDoc:HTML报表390
    标准手册集393
    网络资源394
    已出版的书籍394
    常见编写代码的陷阱395
    本章小结397
    本章习题397
    习题解答397
    第三部分练习题398

    第四部分 函数
    第16章 函数基础403
    为何使用函数404
    编写函数405
    def语句406
    def语句是实时执行的407
    第一个例子:定义和调用408
    定义408
    调用408
    Python中的多态409
    第二个例子:寻找序列的交集410
    定义410
    调用411
    重访多态411
    本地变量412
    本章小结413
    本章习题413
    习题解答413

    第17章 作用域415
    Python作用域基础415
    作用域法则416
    变量名解析:LEGB原则418
    作用域实例419
    内置作用域420
    在Python 2.6中违反通用性422
    global语句422
    最小化全局变量423
    最小化文件间的修改424
    其他访问全局变量的方法426
    作用域和嵌套函数427
    嵌套作用域的细节427
    嵌套作用域举例427
    nonlocal语句433
    nonlocal基础433
    nonlocal应用435
    为什么使用nonlocal437
    本章小结440
    本章习题441
    习题解答442

    第18章 参数444
    传递参数444
    参数和共享引用445
    避免可变参数的修改447
    对参数输出进行模拟448
    特定的参数匹配模型449
    基础知识449
    匹配语法450
    细节452
    关键字参数和默认参数的实例452
    任意参数的实例455
    Python 3.0 Keyword-Only参数459
    min调用462
    满分463
    加分点464
    结论465
    一个更有用的例子:通用set函数465
    模拟Python 3.0 print函数466
    使用Keyword-Only参数467
    为什么要在意:关键字参数469
    本章小结469
    本章习题470
    习题解答470

    第19章 函数的高级话题472
    函数设计概念472
    递归函数474
    用递归求和474
    编码替代方案475
    循环语句VS递归476
    处理任意结构477
    函数对象:属性和注解478
    间接函数调用478
    函数内省479
    函数属性480
    Python 3.0中的函数注解481
    匿名函数: lambda483
    lambda表达式483
    为什么使用lambda484
    如何(不要)让Python代码变得晦涩难懂486
    嵌套lambda和作用域487
    为什么要在意:回调488
    在序列中映射函数:map489
    函数式编程工具:filter和reduce490
    本章小结492
    本章习题492
    习题解答492

    第20章 迭代和解析,第二部分494
    回顾列表解析:函数式编程工具494
    列表解析与map495
    增加测试和嵌套循环496
    列表解析和矩阵498
    理解列表解析499
    为什么要在意:列表解析和map500
    重访迭代器:生成器501
    生成器函数:yield VS return502
    生成器表达式:迭代器遇到列表解析506
    生成器函数 VS 生成器表达式507
    生成器是单迭代器对象508
    用迭代工具模拟zip和map510
    为什么你会留意:单次迭代514
    内置类型和类中的值生成515
    Python 3.0解析语法概括516
    解析集合和字典解析517
    针对集合和字典的扩展的解析语法517
    对迭代的各种方法进行计时518
    对模块计时519
    计时脚本519
    计时结果520
    计时模块替代方案523
    其他建议527
    函数陷阱528
    本地变量是静态检测的528
    默认和可变对象529
    没有return语句的函数531
    嵌套作用域的循环变量532
    本章小结532
    本章习题532
    习题解答533
    第四部分练习题533
    第五部分 模块

    第21章 模块:宏伟蓝图539
    为什么使用模块540
    Python程序架构540
    如何组织一个程序541
    导入和属性541
    标准库模块543
    import如何工作543
    1.搜索544
    2.编译(可选)544
    3.运行545
    模块搜索路径545
    配置搜索路径547
    搜索路径的变动548
    sys.path列表548
    模块文件选择549
    高级的模块选择概念550
    第三方工具:distutils550
    本章小结551
    本章习题551
    习题解答551

    第22章 模块代码编写基础553
    模块的创建553
    模块的使用554
    import语句554
    from语句555
    from *语句555
    导入只发生一次555
    import和from是赋值语句556
    文件间变量名的改变557
    import和from的对等性557
    from语句潜在的陷阱558
    模块命名空间560
    文件生成命名空间560
    属性名的点号运算562
    导入和作用域562
    命名空间的嵌套563
    重载模块564
    reload基础565
    reload实例566
    为什么要在意:模块重载567
    本章小结568
    本章习题568
    习题解答568
    第23章 模块包570
    包导入基础570
    包和搜索路径设置571
    init.py包文件572
    包导入实例573
    包对应的from语句和import语句574
    为什么要使用包导入575
    三个系统的传说576
    包相对导入578
    Python 3.0中的变化578
    相对导入基础知识579
    为什么使用相对导入581
    相对导入的作用域583
    模块查找规则总结583
    相对导入的应用584
    为什么要在意:模块包589
    本章小结590
    本章习题590
    习题解答590

    第24章 高级模块话题592
    在模块中隐藏数据592
    最小化from *的破坏:_X和__all__593
    启用以后的语言特性593
    混合用法模式:name和__main__594
    name进行单元测试595
    使用带有name的命令行参数596
    修改模块搜索路径599
    Import语句和from语句的as扩展599
    模块是对象:元程序600
    用名称字符串导入模块603
    过渡性模块重载604
    模块设计理念607
    模块陷阱607
    顶层代码的语句次序的重要性608
    from复制变量名,而不是连接609
    from *会让变量语义模糊610
    reload不会影响from导入610
    reload、from以及交互模式测试611
    递归形式的from导入无法工作612
    本章小结613
    本章习题613
    习题解答613
    第五部分练习题614
    第六部分 类和OOP

    第25章 OOP:宏伟蓝图619
    为何使用类620
    概览OOP621
    属性继承搜索621
    类和实例623
    类方法调用624
    编写类树624
    OOP是为了代码重用627
    本章小结629
    本章习题629
    习题解答630

    第26章 类代码编写基础631
    类产生多个实例对象631
    类对象提供默认行为632
    实例对象是具体的元素632
    第一个例子632
    类通过继承进行定制635
    第二个例子635
    类是模块内的属性637
    类可以截获Python运算符638
    第三个例子639
    为什么要使用运算符重载641
    世界上最简单的Python类641
    类与字典的关系644
    本章小结646
    本章习题646
    习题解答646

    第27章 更多实例649
    步骤1:创建实例650
    编写构造函数650
    在进行中测试651
    以两种方式使用代码652
    版本差异提示654
    步骤2:添加行为方法654
    编写方法656
    步骤3:运算符重载658
    提供打印显示658
    步骤4:通过子类定制行为659
    编写子类660
    扩展方法:不好的方式660
    扩展方法:好的方式661
    多态的作用663
    继承、定制和扩展664
    OOP:大思路664
    步骤5:定制构造函数665
    OOP比我们认为的要简单666
    组合类的其他方式667
    在Python 3.0中捕获内置属性669
    步骤6:使用内省工具670
    特殊类属性670
    一种通用显示工具671
    实例与类属性的关系672
    工具类的命名考虑673
    类的最终形式674
    步骤7(最后一步):把对象存储到数据库中676
    Pickle和Shelve676
    在shelve数据库中存储对象677
    交互地探索shelve678
    更新shelve中的对象680
    未来方向681
    本章小结683
    本章习题684
    习题解答684

    第28章 类代码编写细节686
    class语句686
    一般形式686
    例子687
    方法689
    例子690
    调用超类构造函数691
    其他方法调用的可能性691
    继承692
    属性树的构造692
    继承方法的专有化693
    类接口技术694
    抽象超类695
    Python 2.6和Python 3.0的抽象超类696
    命名空间:完整的内容698
    简单变量名:如果赋值就不是全局变量698
    属性名称:对象命名空间698
    Python命名空间的“禅”:赋值将变量名分类699
    命名空间字典701
    命名空间链接704
    回顾文档字符串706
    类与模块的关系707
    本章小结708
    本章习题708
    习题解答708

    第29章 运算符重载710
    基础知识710
    构造函数和表达式:init和__sub__711
    常见的运算符重载方法711
    索引和分片:getitem和__setitem__713
    拦截分片713
    Python 2.6中的分片和索引715
    索引迭代:__getitem__716
    迭代器对象:iter和__next__717
    用户定义的迭代器717
    有多个迭代器的对象719
    成员关系:containsiter和__getitem__721
    属性引用:getattr和__setattr__723
    其他属性管理工具725
    模拟实例属性的私有性:第一部分725
    reprstr会返回字符串表达形式726
    右侧加法和原处加法:radd和__iadd__729
    原处加法730
    Call表达式:__call__731
    函数接口和回调代码732
    比较:ltgt和其他方法734
    Python 2.6的cmp方法(已经从Python 3.0中移除了)734
    布尔测试:bool和__len__735
    Python 2.6中的布尔736
    对象析构函数:__del__738
    本章小结739
    本章习题739
    习题解答739

    第30章 类的设计741
    Python和OOP741
    通过调用标记进行重载(或不要)742
    OOP和继承:“是一个”关系743
    OOP和组合:“有一个”关系744
    重访流处理器746
    为什么要在意:类和持续性748
    OOP和委托:“包装”对象749
    类的伪私有属性751
    变量名压缩概览751
    为什么使用伪私有属性752
    方法是对象:绑定或无绑定754
    在Python 3.0中,无绑定方法是函数756
    绑定方法和其他可调用对象757
    为什么要在意:绑定方法和回调函数760
    多重继承:“混合”类760
    编写混合显示类761
    类是对象:通用对象的工厂771
    为什么有工厂772
    与设计相关的其他话题773
    本章小结773
    本章习题774
    习题解答774

    第31章 类的高级主题775
    扩展内置类型775
    通过嵌入扩展类型776
    通过子类扩展类型777
    新式类779
    新式类变化780
    类型模式变化781
    钻石继承变动785
    新式类的扩展789
    slots实例789
    类特性793
    getattribute和描述符795
    元类795
    静态方法和类方法796
    为什么使用特殊方法796
    Python 2.6和Python 3.0中的静态方法797
    静态方法替代方案799
    使用静态和类方法800
    使用静态方法统计实例801
    用类方法统计实例802
    装饰器和元类:第一部分805
    函数装饰器基础805
    装饰器例子806
    类装饰器和元类807
    更多详细信息808
    类陷阱809
    修改类属性的副作用809
    修改可变的类属性也可能产生副作用810
    多重继承:顺序很重要811
    类、方法以及嵌套作用域812
    Python中基于委托的类:getattr和内置函数814
    “过度包装”814
    本章小结815
    本章习题815
    习题解答815

    第六部分 练习题816
    为什么要在意:大师眼中的OOP821
    第七部分 异常和工具
    第32章 异常基础825
    为什么使用异常826
    异常的角色826
    异常处理:简明扼要827
    默认异常处理器827
    捕获异常828
    引发异常829
    用户定义的异常830
    终止行为830
    为什么要在意:错误检查832
    本章小结833
    本章习题833
    习题解答834

    第33章 异常编码细节835
    try/except/else语句835
    try语句分句836
    try/else分句839
    例子:默认行为840
    例子:捕捉内置异常841
    try/finally语句841
    例子:利用try/finally编写终止行为842
    统一try/except/finally语句843
    统一try语句语法845
    通过嵌套合并finally和except845
    合并try的例子846
    raise语句847
    利用raise传递异常849
    Python 3.0异常链:raise from849
    assert语句850
    例子:收集约束条件(但不是错误)850
    with/as环境管理器851
    基本使用852
    环境管理协议853
    本章小结855
    本章习题855
    习题解答856

    第34章 异常对象857
    异常:回到未来858
    字符串异常很简单858
    基于类的异常858
    类异常例子859
    为什么使用类异常861
    内置Exception类864
    内置异常分类865
    默认打印和状态866
    定制打印显示867
    定制数据和行为868
    提供异常细节868
    提供异常方法869
    本章小结870
    本章习题870
    习题解答870

    第35章 异常的设计872
    嵌套异常处理器872
    例子:控制流程嵌套873
    例子:语法嵌套化874
    异常的习惯用法876
    异常不总是错误876
    函数信号条件和raise876
    关闭文件和服务器连接877
    在try外进行调试878
    运行进程中的测试879
    关于sys.exc_info879
    与异常有关的技巧880
    应该包装什么881
    捕捉太多:避免空except语句881
    捕捉过少:使用基于类的分类883
    核心语言总结884
    Python工具集884
    大型项目的开发工具885
    本章小结888
    第七部分练习题889
    第八部分 高级话题注1

    第36章 Unicode和字节字符串893
    Python 3.0中的字符串修改894
    字符串基础知识895
    字符编码方法895
    Python的字符串类型897
    文本和二进制文件899
    Python 3.0中的字符串应用900
    常量和基本属性900
    转换901
    编码Unicode字符串903
    编码ASCII文本903
    编码非ASCII文本904
    编码和解码非ASCII文本904
    其他Unicode编码技术905
    转换编码907
    在Python 2.6中编码Unicode字符串908
    源文件字符集编码声明910
    使用Python 3.0 Bytes对象911
    方法调用912
    序列操作913
    创建bytes对象的其他方式913
    混合字符串类型914
    使用Python 3.0(和Python 2.6)bytearray对象915
    使用文本文件和二进制文件918
    文本文件基础919
    Python 3.0中的文本和二进制模式919
    类型和内容错误匹配921
    使用Unicode文件922
    在Python 3.0中读取和写入Unicode922
    在Python 3.0中处理BOM924
    Python 2.6中的Unicode文件927
    Python 3.0中其他字符串工具的变化927
    re模式匹配模块927
    Struct二进制数据模块928
    pickle对象序列化模块931
    XML解析工具932
    本章小结935
    本章习题935
    习题解答936

    第37章 管理属性938
    为什么管理属性938
    插入在属性访问时运行的代码939
    特性940
    基础知识940
    第一个例子941
    计算的属性942
    使用装饰器编写特性943
    描述符944
    基础知识945
    第一个示例947
    计算的属性949
    在描述符中使用状态信息950
    特性和描述符是如何相关的952
    getattr和__getattribute__953
    基础知识954
    第一个示例956
    计算属性958
    getattrgetattribute比较959
    管理技术比较960
    拦截内置操作属性963
    重访基于委托的Manager967
    示例:属性验证970
    使用特性来验证971
    使用描述符验证973
    使用getattr来验证974
    使用getattribute验证976
    本章小结977
    本章习题977
    习题解答977

    第38章 装饰器979
    什么是装饰器979
    管理调用和实例980
    管理函数和类980
    使用和定义装饰器981
    为什么使用装饰器981
    基础知识982
    函数装饰器982
    类装饰器986
    装饰器嵌套988
    装饰器参数990
    装饰器管理函数和类991
    编写函数装饰器991
    跟踪调用992
    状态信息保持选项993
    类错误之一:装饰类方法997
    计时调用1002
    添加装饰器参数1004
    编写类装饰器1007
    单体类1007
    跟踪对象接口1009
    类错误之二:保持多个实例1012
    装饰器与管理器函数的关系1013
    为什么使用装饰器(重访)1015
    直接管理函数和类1016
    示例:“私有”和“公有”属性1018
    实现私有属性1019
    实现细节之一1021
    公有声明的泛化1022
    实现细节之二1024
    开放问题1025
    Python不是关于控制1029
    示例:验证函数参数1030
    目标1030
    针对位置参数的一个基本范围测试装饰器1031
    针对关键字和默认泛化1033
    实现细节1036
    开放问题1038
    装饰器参数 VS 函数注解1039
    其他应用程序:类型测试1041
    本章小结1042
    本章习题1042
    习题解答1043

    第39章 元类1046
    要么是元类,要么不是元类1046
    提高魔力层次1047
    “辅助”函数的缺点1049
    元类与类装饰器的关系:第一回合1051
    元类模型1053
    类是类型的实例1053
    元类是Type的子类1055
    Class语句协议1056
    声明元类1057
    编写元类1058
    基本元类1058
    定制构建和初始化1059
    其他元类编程技巧1060
    实例与继承的关系1063
    示例:向类添加方法1064
    手动扩展1064
    基于元类的扩展1065
    元类与类装饰器的关系:第二回合1067
    示例:对方法应用装饰器1070
    用装饰器手动跟踪1070
    用元类和装饰器跟踪1071
    把任何装饰器应用于方法1073
    元类与类装饰器的关系:第三回合1074
    “可选的”语言功能1076
    本章小结1078
    本章习题1078
    习题解答1078
    第九部分 附录注2
    附录A 安装和配置1083
    附录B 各部分练习题的解答 1093

    展开全文
  • 掌握了Python语言的核心,想再深入了解它的面向对象特性和编程技巧,可以看其他的Python大部头,或者最直接也是最有效的方式,下载并安装Python,在它的“Shell”里边用边学,这样可以事半功倍;如果你英语够好,...
        

    如果你是一名有经验的程序员,迅速阅读此书可以大体了解Python语言的核心。掌握了Python语言的核心,想再深入了解它的面向对象特性和编程技巧,可以看其他的Python大部头,或者最直接也是最有效的方式,下载并安装Python,在它的“Shell”里边用边学,这样可以事半功倍;如果你英语够好,python.org网站将是你挖宝的必经之地。此书也讲到了Python的这一易学特性,只要你仔细认真,定会从学习中得到乐趣。
    《Python语言入门》曾是我大学时期读过的专业类好书之一,现在在我的同学中传阅。译者翻译得比较准确、通顺。在Python的入门级图书中,《Python语言入门》不失为一部经典之作

    获取方式

    1. 点击 https://51dr.cn/Book/Detail/11725 访问
    2. 公众号回复 “11725” 获取下载地址,
      关注公众号资源分享,视频教程应有尽有!欢迎关注一起学习!


      4624570-d5e95760e6ff2b9d.png
      扫码关注公众号

      4624570-e53cc52cee89a2a3
      image

    内容简介 · · · · · ·

    Google和YouTube由于Python的高可适应性、易于维护以及适合于快速开发而采用它。如果你想要编写高质量、高效的并且易于与其他语言和工具集成的代码,《Python学习手册:第4 版》将帮助你使用Python快速实现这一点,不管你是编程新手还是Python初学者。本书是易于掌握和自学的教程,根据作者Python专家Mark Lutz的著名培训课程编写而成。

    《Python学习手册:第4版》每一章都包含关于Python语言的关键内容的独立的一课,并且包含了一个独特的“练习题”部分,其中带有实际的练习和测试,以便你可以练习新的技能并随着学习而测试自己的理解。你会发现众多带有注释的示例以及图表,它们将帮助你开始学习Python 3.0。

    《Python学习手册:第4版》包括以下内容:

    学习Python的主要内建对象类型:数字、列表和字典。

    使用Python语句创建和处理对象,并且学习Python的通用语法模型。

    使用函数构造和重用代码,函数是Python的基本过程工具。

    学习Python模块:封装语句、函数以及其他工具,从而可以组织成较大的组件。

    Python的面向对象编程工具,用于组织程序代码。

    学习异常处理模型,以及用于编写较大程序的开发工具。

    了解包括装饰器、描述器、元类和Unicode处理等高级Python工具。

    作者简介 · · · · · ·

    作为全球Python培训界的领军人物,《Python学习手册:第4版》作者Mark Lutz是Python最畅销书籍的作者,也是Python社区的先驱。

    Mark 是O'Reilly出版的《Programming Python》和《Python Pocket Reference》的作者,这两本书于2009年都已经出版了第3版。Mark自1992年开始接触Python,1995年开始撰写有关Python的书籍,从1997年开始教授Python课程。截止到2009年,他已经开办了225个Python短期培训课程,教授了大约3500名学习者,销售了大约25万册有关Python的书籍。许多书被翻译成十多种语言。

    此外,Mark拥有威斯康星大学计算机科学学士和硕士学位,在过去的25年中,他主要从事编译器、编程工具、脚本程序以及各种客户端/服务器系统方面的工作。你也可以通过访问http://www.rmi.net/~lutz与他取得联系。

    目录 · · · · · ·

    前言 1
    第一部分 使用入门
    第1章 问答环节 19
    人们为何使用Python 19
    软件质量 20
    开发效率 21
    Python是“脚本语言”吗 21
    好吧,Python的缺点是什么呢 23
    如今谁在使用Python 23
    使用Python可以做些什么 24
    系统编程 25
    用户图形接口 25
    Internet脚本 25
    组件集成 26
    数据库编程 26
    快速原型 27
    数值计算和科学计算编程 27
    游戏、图像、人工智能、XML、机器人等 27
    Python如何获得支持 28
    Python有哪些技术上的优点 28
    面向对象 28
    免费 29
    可移植 29
    功能强大 30
    可混合 31
    简单易用 31
    简单易学 32
    Python和其他语言比较起来怎么样 32
    本章小结 33
    本章习题 33
    习题解答 34
    Python是工程,不是艺术 34
    第2章 Python如何运行程序 36
    Python解释器简介 36
    程序执行 37
    程序员的视角 37
    Python的视角 39
    执行模块的变体 41
    Python实现的替代者 42
    执行优化工具 43
    冻结二进制文件 44
    其他执行选项 45
    未来的可能性 46
    本章小结 46
    本章习题 47
    习题解答 47
    第3章 如何运行程序 48
    交互提示模式下编写代码 48
    交互地运行代码 49
    为什么使用交互提示模式 51
    使用交互提示模式 52
    系统命令行和文件 54
    第一段脚本 55
    使用命令行运行文件 56
    使用命令行和文件 57
    UNIX可执行脚本(#!) 58
    UNIX env查找技巧 59
    点击文件图标 60
    在Windows中点击图标 60
    input的技巧 61
    图标点击的其他限制 63
    模块导入和重载 63
    模块的显要特性:属性 65
    import和reload的使用注意事项 68
    使用exec运行模块文件 69
    IDLE用户界面 70
    IDLE基础 71
    使用IDLE 72
    高级IDLE工具 74
    其他的IDE 74
    其他启动选项 76
    嵌入式调用 76
    冻结二进制的可执行性 77
    文本编辑器启动的选择 77
    其他的启动选择 77
    未来的可能 77
    我应该选用哪种 78
    调试Python代码 78
    本章小结 80
    本章习题 80
    习题解答 80
    第一部分 练习题 81
    第二部分 类型和运算
    第4章 介绍Python对象类型 87
    为什么使用内置类型 88
    Python的核心数据类型 88
    数字 90
    字符串 92
    序列的操作 92
    不可变性 94
    类型特定的方法 94
    寻求帮助 96
    编写字符串的其他方法 97
    模式匹配 98
    列表 98
    序列操作 98
    类型特定的操作 99
    边界检查 100
    嵌套 100
    列表解析 101
    字典 103
    映射操作 103
    重访嵌套 104
    键的排序:for 循环 105
    迭代和优化 107
    不存在的键:if 测试 107
    元组 109
    为什么要用元组 109
    文件 110
    其他文件类工具 111
    其他核心类型 111
    如何破坏代码的灵活性 113
    用户定义的类 114
    剩余的内容 115
    本章小结 115
    本章习题 116
    习题解答 116
    第5章 数字 117
    Python的数字类型 117
    数字常量 118
    内置数学工具和扩展 119
    Python表达式操作符 120
    在实际应用中的数字 125
    变量和基本的表达式 125
    数字显示的格式 126
    比较:一般的和连续的 127
    str和repr显示格式 128
    除法: 传统除法、Floor除法和真除法 129
    整数精度 133
    复数 133
    十六进制、八进制和二进制记数 134
    位操作 136
    其他的内置数学工具 137
    其他数字类型 139
    小数数字 139
    分数类型 141
    集合 145
    布尔型 151
    数字扩展 152
    本章小结 153
    本章习题 153
    习题解答 153
    第6章 动态类型简介 155
    缺少类型声明语句的情况 155
    变量、对象和引用 156
    类型属于对象,而不是变量 157
    对象的垃圾收集 158
    共享引用 159
    共享引用和在原处修改 161
    共享引用和相等 163
    动态类型随处可见 164
    本章小结 165
    本章习题 165
    习题解答 165
    第7章 字符串 167
    字符串常量 169
    单双引号字符串是一样的 170
    用转义序列代表特殊字节 171
    raw字符串抑制转义 173
    三重引号编写多行字符串块 175
    实际应用中的字符串 176
    基本操作 176
    索引和分片 177
    为什么要在意:分片 181
    字符串转换工具 181
    修改字符串 184
    字符串方法 185
    字符串方法实例:修改字符串 187
    字符串方法实例:文本解析 189
    实际应用中的其他常见字符串方法 190
    最初的字符串模块(在Python 3.0中删除) 191
    字符串格式化表达式 192
    更高级的字符串格式化表达式 194
    基于字典的字符串格式化 196
    字符串格式化调用方法 196
    基础知识 197
    添加键、属性和偏移量 198
    添加具体格式化 198
    与%格式化表达式比较 200
    为什么用新的格式化方法 203
    通常意义下的类型分类 206
    同样分类的类型共享其操作集合 206
    可变类型能够在原处修改 207
    本章小结 208
    本章习题 208
    习题解答 208
    第8章 列表与字典 210
    列表 210
    实际应用中的列表 213
    基本列表操作 213
    列表迭代和解析 213
    索引、分片和矩阵 214
    原处修改列表 215
    字典 220
    实际应用中的字典 222
    字典的基本操作 222
    原处修改字典 223
    其他字典方法 224
    语言表 225
    字典用法注意事项 226
    为什么要在意字典接口 229
    创建字典的其他方法 230
    Python 3.0中的字典变化 231
    本章小结 237
    本章习题 237
    习题解答 237
    第9章 元组、文件及其他 239
    元组 239
    实际应用中的元组 241
    为什么有了列表还要元组 243
    文件 243
    打开文件 244
    使用文件 245
    实际应用中的文件 246
    其他文件工具 252
    重访类型分类 254
    为什么要在意操作符重载 255
    对象灵活性 255
    引用 VS 拷贝 256
    比较、相等性和真值 258
    Python 3.0的字典比较 260
    Python中真和假的含义 261
    Python的类型层次 263
    Type对象 263
    Python中的其他类型 265
    内置类型陷阱 265
    赋值生成引用,而不是拷贝 265
    重复能够增加层次深度 266
    留意循环数据结构 266
    不可变类型不可以在原处改变 267
    本章小结 267
    本章习题 268
    习题解答 268
    第二部分练习题 269
    第三部分 语句和语法
    第10章 Python语句简介 275
    重访Python程序结构 275
    Python的语句 276
    两个if的故事 278
    Python增加了什么 279
    Python删除了什么 279
    为什么使用缩进语法 281
    几个特殊实例 283
    简短实例:交互循环 285
    一个简单的交互式循环 285
    对用户输入数据做数学运算 287
    用测试输入数据来处理错误 288
    用try语句处理错误 289
    嵌套代码三层 290
    本章小结 290
    本章习题 291
    习题解答 291
    第11章 赋值、表达式和打印 292
    赋值语句 292
    赋值语句的形式 293
    序列赋值 294
    Python 3.0中的扩展序列解包 297
    多目标赋值语句 301
    增强赋值语句 302
    变量命名规则 305
    Python的废弃协议 306
    表达式语句 308
    表达式语句和在原处的修改 309
    打印操作 310
    Python 3.0的print函数 311
    Python 2.6 print语句 313
    打印流重定向 315
    版本独立的打印 318
    为什么要注意print和stdout 319
    本章小结 320
    本章习题 321
    习题解答 321
    第12章 if测试和语法规则 322
    if语句 322
    通用格式 322
    基本例子 323
    多路分支 323
    Python语法规则 325
    代码块分隔符 326
    语句的分隔符 328
    一些特殊情况 329
    真值测试 330
    if/else三元表达式 332
    为什么要在意布尔值 334
    本章小结 335
    本章习题 335
    习题解答 335
    第13章 while和for循环 336
    while循环 336
    一般格式 336
    例子 337
    break、continue、pass和循环else 338
    一般循环格式 338
    pass 338
    continue 340
    break 340
    循环else 341
    为什么要在意“模拟C 语言的while循环” 342
    for循环 343
    一般格式 343
    例子 344
    为什么要在意“文件扫描” 349
    编写循环的技巧 350
    循环计数器:while和range 351
    非完备遍历:range和分片 352
    修改列表:range 353
    并行遍历:zip和map 354
    产生偏移和元素:enumerate 357
    本章小结 358
    本章习题 358
    习题解答 359
    第14章 迭代器和解析,第一部分 360
    迭代器:初探 360
    文件迭代器 361
    手动迭代:iter和next 363
    其他内置类型迭代器 365
    列表解析:初探 367
    列表解析基础知识 368
    在文件上使用列表解析 369
    扩展的列表解析语法 370
    其他迭代环境 371
    Python 3.0中的新的可迭代对象 375
    range迭代器 376
    map、zip和filter迭代器 377
    多个迭代器 VS单个迭代器 378
    字典视图迭代器 379
    其他迭代器主题 381
    本章小结 381
    本章习题 381
    习题解答 382
    第15章 文档 383
    Python文档资源 383

    注释 384

    dir函数 384
    文档字符串:doc 385
    PyDoc:help函数 388
    PyDoc:HTML报表 390
    标准手册集 393
    网络资源 394
    已出版的书籍 394
    常见编写代码的陷阱 395
    本章小结 397
    本章习题 397
    习题解答 397
    第三部分练习题 398
    第四部分 函数
    第16章 函数基础 403
    为何使用函数 404
    编写函数 405
    def语句 406
    def语句是实时执行的 407
    第一个例子:定义和调用 408
    定义 408
    调用 408
    Python中的多态 409
    第二个例子:寻找序列的交集 410
    定义 410
    调用 411
    重访多态 411
    本地变量 412
    本章小结 413
    本章习题 413
    习题解答 413
    第17章 作用域 415
    Python作用域基础 415
    作用域法则 416
    变量名解析:LEGB原则 418
    作用域实例 419
    内置作用域 420
    在Python 2.6中违反通用性 422
    global语句 422
    最小化全局变量 423
    最小化文件间的修改 424
    其他访问全局变量的方法 426
    作用域和嵌套函数 427
    嵌套作用域的细节 427
    嵌套作用域举例 427
    nonlocal语句 433
    nonlocal基础 433
    nonlocal应用 435
    为什么使用nonlocal 437
    本章小结 440
    本章习题 441
    习题解答 442
    第18章 参数 444
    传递参数 444
    参数和共享引用 445
    避免可变参数的修改 447
    对参数输出进行模拟 448
    特定的参数匹配模型 449
    基础知识 449
    匹配语法 450
    细节 452
    关键字参数和默认参数的实例 452
    任意参数的实例 455
    Python 3.0 Keyword-Only参数 459
    min调用 462
    满分 463
    加分点 464
    结论 465
    一个更有用的例子:通用set函数 465
    模拟Python 3.0 print函数 466
    使用Keyword-Only参数 467
    为什么要在意:关键字参数 469
    本章小结 469
    本章习题 470
    习题解答 470
    第19章 函数的高级话题 472
    函数设计概念 472
    递归函数 474
    用递归求和 474
    编码替代方案 475
    循环语句VS递归 476
    处理任意结构 477
    函数对象:属性和注解 478
    间接函数调用 478
    函数内省 479
    函数属性 480
    Python 3.0中的函数注解 481
    匿名函数: lambda 483
    lambda表达式 483
    为什么使用lambda 484
    如何(不要)让Python代码变得晦涩难懂 486
    嵌套lambda和作用域 487
    为什么要在意:回调 488
    在序列中映射函数:map 489
    函数式编程工具:filter和reduce 490
    本章小结 492
    本章习题 492
    习题解答 492
    第20章 迭代和解析,第二部分 494
    回顾列表解析:函数式编程工具 494
    列表解析与map 495
    增加测试和嵌套循环 496
    列表解析和矩阵 498
    理解列表解析 499
    为什么要在意:列表解析和map 500
    重访迭代器:生成器 501
    生成器函数:yield VS return 502
    生成器表达式:迭代器遇到列表解析 506
    生成器函数 VS 生成器表达式 507
    生成器是单迭代器对象 508
    用迭代工具模拟zip和map 510
    为什么你会留意:单次迭代 514
    内置类型和类中的值生成 515
    Python 3.0解析语法概括 516
    解析集合和字典解析 517
    针对集合和字典的扩展的解析语法 517
    对迭代的各种方法进行计时 518
    对模块计时 519
    计时脚本 519
    计时结果 520
    计时模块替代方案 523
    其他建议 527
    函数陷阱 528
    本地变量是静态检测的 528
    默认和可变对象 529
    没有return语句的函数 531
    嵌套作用域的循环变量 532
    本章小结 532
    本章习题 532
    习题解答 533
    第四部分练习题 533
    第五部分 模块
    第21章 模块:宏伟蓝图 539
    为什么使用模块 540
    Python程序架构 540
    如何组织一个程序 541
    导入和属性 541
    标准库模块 543
    import如何工作 543
    1.搜索 544
    2.编译(可选) 544
    3.运行 545
    模块搜索路径 545
    配置搜索路径 547
    搜索路径的变动 548
    sys.path列表 548
    模块文件选择 549
    高级的模块选择概念 550
    第三方工具:distutils 550
    本章小结 551
    本章习题 551
    习题解答 551
    第22章 模块代码编写基础 553
    模块的创建 553
    模块的使用 554
    import语句 554
    from语句 555
    from *语句 555
    导入只发生一次 555
    import和from是赋值语句 556
    文件间变量名的改变 557
    import和from的对等性 557
    from语句潜在的陷阱 558
    模块命名空间 560
    文件生成命名空间 560
    属性名的点号运算 562
    导入和作用域 562
    命名空间的嵌套 563
    重载模块 564
    reload基础 565
    reload实例 566
    为什么要在意:模块重载 567
    本章小结 568
    本章习题 568
    习题解答 568
    第23章 模块包 570
    包导入基础 570
    包和搜索路径设置 571
    init.py包文件 572
    包导入实例 573
    包对应的from语句和import语句 574
    为什么要使用包导入 575
    三个系统的传说 576
    包相对导入 578
    Python 3.0中的变化 578
    相对导入基础知识 579
    为什么使用相对导入 581
    相对导入的作用域 583
    模块查找规则总结 583
    相对导入的应用 584
    为什么要在意:模块包 589
    本章小结 590
    本章习题 590
    习题解答 590
    第24章 高级模块话题 592
    在模块中隐藏数据 592
    最小化from *的破坏:_X和all 593
    启用以后的语言特性 593
    混合用法模式:namemain 594
    name进行单元测试 595
    使用带有name的命令行参数 596
    修改模块搜索路径 599
    Import语句和from语句的as扩展 599
    模块是对象:元程序 600
    用名称字符串导入模块 603
    过渡性模块重载 604
    模块设计理念 607
    模块陷阱 607
    顶层代码的语句次序的重要性 608
    from复制变量名,而不是连接 609
    from *会让变量语义模糊 610
    reload不会影响from导入 610
    reload、from以及交互模式测试 611
    递归形式的from导入无法工作 612
    本章小结 613
    本章习题 613
    习题解答 613
    第五部分练习题 614
    第六部分 类和OOP
    第25章 OOP:宏伟蓝图 619
    为何使用类 620
    概览OOP 621
    属性继承搜索 621
    类和实例 623
    类方法调用 624
    编写类树 624
    OOP是为了代码重用 627
    本章小结 629
    本章习题 629
    习题解答 630
    第26章 类代码编写基础 631
    类产生多个实例对象 631
    类对象提供默认行为 632
    实例对象是具体的元素 632
    第一个例子 632
    类通过继承进行定制 635
    第二个例子 635
    类是模块内的属性 637
    类可以截获Python运算符 638
    第三个例子 639
    为什么要使用运算符重载 641
    世界上最简单的Python类 641
    类与字典的关系 644
    本章小结 646
    本章习题 646
    习题解答 646
    第27章 更多实例 649
    步骤1:创建实例 650
    编写构造函数 650
    在进行中测试 651
    以两种方式使用代码 652
    版本差异提示 654
    步骤2:添加行为方法 654
    编写方法 656
    步骤3:运算符重载 658
    提供打印显示 658
    步骤4:通过子类定制行为 659
    编写子类 660
    扩展方法:不好的方式 660
    扩展方法:好的方式 661
    多态的作用 663
    继承、定制和扩展 664
    OOP:大思路 664
    步骤5:定制构造函数 665
    OOP比我们认为的要简单 666
    组合类的其他方式 667
    在Python 3.0中捕获内置属性 669
    步骤6:使用内省工具 670
    特殊类属性 670
    一种通用显示工具 671
    实例与类属性的关系 672
    工具类的命名考虑 673
    类的最终形式 674
    步骤7(最后一步):把对象存储到数据库中 676
    Pickle和Shelve 676
    在shelve数据库中存储对象 677
    交互地探索shelve 678
    更新shelve中的对象 680
    未来方向 681
    本章小结 683
    本章习题 684
    习题解答 684
    第28章 类代码编写细节 686
    class语句 686
    一般形式 686
    例子 687
    方法 689
    例子 690
    调用超类构造函数 691
    其他方法调用的可能性 691
    继承 692
    属性树的构造 692
    继承方法的专有化 693
    类接口技术 694
    抽象超类 695
    Python 2.6和Python 3.0的抽象超类 696
    命名空间:完整的内容 698
    简单变量名:如果赋值就不是全局变量 698
    属性名称:对象命名空间 698
    Python命名空间的“禅”:赋值将变量名分类 699
    命名空间字典 701
    命名空间链接 704
    回顾文档字符串 706
    类与模块的关系 707
    本章小结 708
    本章习题 708
    习题解答 708
    第29章 运算符重载 710
    基础知识 710
    构造函数和表达式:initsub 711
    常见的运算符重载方法 711
    索引和分片:getitemsetitem 713
    拦截分片 713
    Python 2.6中的分片和索引 715
    索引迭代:getitem 716
    迭代器对象:iternext 717
    用户定义的迭代器 717
    有多个迭代器的对象 719
    成员关系:containsitergetitem 721
    属性引用:getattrsetattr 723
    其他属性管理工具 725
    模拟实例属性的私有性:第一部分 725
    reprstr会返回字符串表达形式 726
    右侧加法和原处加法:raddiadd 729
    原处加法 730
    Call表达式:call 731
    函数接口和回调代码 732
    比较:ltgt和其他方法 734
    Python 2.6的cmp方法(已经从Python 3.0中移除了) 734
    布尔测试:boollen 735
    Python 2.6中的布尔 736
    对象析构函数:del 738
    本章小结 739
    本章习题 739
    习题解答 739
    第30章 类的设计 741
    Python和OOP 741
    通过调用标记进行重载(或不要) 742
    OOP和继承:“是一个”关系 743
    OOP和组合:“有一个”关系 744
    重访流处理器 746
    为什么要在意:类和持续性 748
    OOP和委托:“包装”对象 749
    类的伪私有属性 751
    变量名压缩概览 751
    为什么使用伪私有属性 752
    方法是对象:绑定或无绑定 754
    在Python 3.0中,无绑定方法是函数 756
    绑定方法和其他可调用对象 757
    为什么要在意:绑定方法和回调函数 760
    多重继承:“混合”类 760
    编写混合显示类 761
    类是对象:通用对象的工厂 771
    为什么有工厂 772
    与设计相关的其他话题 773
    本章小结 773
    本章习题 774
    习题解答 774
    第31章 类的高级主题 775
    扩展内置类型 775
    通过嵌入扩展类型 776
    通过子类扩展类型 777
    新式类 779
    新式类变化 780
    类型模式变化 781
    钻石继承变动 785
    新式类的扩展 789
    slots实例 789
    类特性 793
    getattribute和描述符 795
    元类 795
    静态方法和类方法 796
    为什么使用特殊方法 796
    Python 2.6和Python 3.0中的静态方法 797
    静态方法替代方案 799
    使用静态和类方法 800
    使用静态方法统计实例 801
    用类方法统计实例 802
    装饰器和元类:第一部分 805
    函数装饰器基础 805
    装饰器例子 806
    类装饰器和元类 807
    更多详细信息 808
    类陷阱 809
    修改类属性的副作用 809
    修改可变的类属性也可能产生副作用 810
    多重继承:顺序很重要 811
    类、方法以及嵌套作用域 812
    Python中基于委托的类:getattr和内置函数 814
    “过度包装” 814
    本章小结 815
    本章习题 815
    习题解答 815
    第六部分练习题 816
    为什么要在意:大师眼中的OOP 821
    第七部分 异常和工具
    第32章 异常基础 825
    为什么使用异常 826
    异常的角色 826
    异常处理:简明扼要 827
    默认异常处理器 827
    捕获异常 828
    引发异常 829
    用户定义的异常 830
    终止行为 830
    为什么要在意:错误检查 832
    本章小结 833
    本章习题 833
    习题解答 834
    第33章 异常编码细节 835
    try/except/else语句 835
    try语句分句 836
    try/else分句 839
    例子:默认行为 840
    例子:捕捉内置异常 841
    try/finally语句 841
    例子:利用try/finally编写终止行为 842
    统一try/except/finally语句 843
    统一try语句语法 845
    通过嵌套合并finally和except 845
    合并try的例子 846
    raise语句 847
    利用raise传递异常 849
    Python 3.0异常链:raise from 849
    assert语句 850
    例子:收集约束条件(但不是错误) 850
    with/as环境管理器 851
    基本使用 852
    环境管理协议 853
    本章小结 855
    本章习题 855
    习题解答 856
    第34章 异常对象 857
    异常:回到未来 858
    字符串异常很简单 858
    基于类的异常 858
    类异常例子 859
    为什么使用类异常 861
    内置Exception类 864
    内置异常分类 865
    默认打印和状态 866
    定制打印显示 867
    定制数据和行为 868
    提供异常细节 868
    提供异常方法 869
    本章小结 870
    本章习题 870
    习题解答 870
    第35章 异常的设计 872
    嵌套异常处理器 872
    例子:控制流程嵌套 873
    例子:语法嵌套化 874
    异常的习惯用法 876
    异常不总是错误 876
    函数信号条件和raise 876
    关闭文件和服务器连接 877
    在try外进行调试 878
    运行进程中的测试 879
    关于sys.exc_info 879
    与异常有关的技巧 880
    应该包装什么 881
    捕捉太多:避免空except语句 881
    捕捉过少:使用基于类的分类 883
    核心语言总结 884
    Python工具集 884
    大型项目的开发工具 885
    本章小结 888
    第七部分练习题 889
    第八部分 高级话题注1
    第36章 Unicode和字节字符串 893
    Python 3.0中的字符串修改 894
    字符串基础知识 895
    字符编码方法 895
    Python的字符串类型 897
    文本和二进制文件 899
    Python 3.0中的字符串应用 900
    常量和基本属性 900
    转换 901
    编码Unicode字符串 903
    编码ASCII文本 903
    编码非ASCII文本 904
    编码和解码非ASCII文本 904
    其他Unicode编码技术 905
    转换编码 907
    在Python 2.6中编码Unicode字符串 908
    源文件字符集编码声明 910
    使用Python 3.0 Bytes对象 911
    方法调用 912
    序列操作 913
    创建bytes对象的其他方式 913
    混合字符串类型 914
    使用Python 3.0(和Python 2.6)bytearray对象 915
    使用文本文件和二进制文件 918
    文本文件基础 919
    Python 3.0中的文本和二进制模式 919
    类型和内容错误匹配 921
    使用Unicode文件 922
    在Python 3.0中读取和写入Unicode 922
    在Python 3.0中处理BOM 924
    Python 2.6中的Unicode文件 927
    Python 3.0中其他字符串工具的变化 927
    re模式匹配模块 927
    Struct二进制数据模块 928
    pickle对象序列化模块 931
    XML解析工具 932
    本章小结 935
    本章习题 935
    习题解答 936
    第37章 管理属性 938
    为什么管理属性 938
    插入在属性访问时运行的代码 939
    特性 940
    基础知识 940
    第一个例子 941
    计算的属性 942
    使用装饰器编写特性 943
    描述符 944
    基础知识 945
    第一个示例 947
    计算的属性 949
    在描述符中使用状态信息 950
    特性和描述符是如何相关的 952
    getattrgetattribute 953
    基础知识 954
    第一个示例 956
    计算属性 958
    getattrgetattribute比较 959
    管理技术比较 960
    拦截内置操作属性 963
    重访基于委托的Manager 967
    示例:属性验证 970
    使用特性来验证 971
    使用描述符验证 973
    使用getattr来验证 974
    使用getattribute验证 976
    本章小结 977
    本章习题 977
    习题解答 977
    第38章 装饰器 979
    什么是装饰器 979
    管理调用和实例 980
    管理函数和类 980
    使用和定义装饰器 981
    为什么使用装饰器 981
    基础知识 982
    函数装饰器 982
    类装饰器 986
    装饰器嵌套 988
    装饰器参数 990
    装饰器管理函数和类 991
    编写函数装饰器 991
    跟踪调用 992
    状态信息保持选项 993
    类错误之一:装饰类方法 997
    计时调用 1002
    添加装饰器参数 1004
    编写类装饰器 1007
    单体类 1007
    跟踪对象接口 1009
    类错误之二:保持多个实例 1012
    装饰器与管理器函数的关系 1013
    为什么使用装饰器(重访) 1015
    直接管理函数和类 1016
    示例:“私有”和“公有”属性 1018
    实现私有属性 1019
    实现细节之一 1021
    公有声明的泛化 1022
    实现细节之二 1024
    开放问题 1025
    Python不是关于控制 1029
    示例:验证函数参数 1030
    目标 1030
    针对位置参数的一个基本范围测试装饰器 1031
    针对关键字和默认泛化 1033
    实现细节 1036
    开放问题 1038
    装饰器参数 VS 函数注解 1039
    其他应用程序:类型测试 1041
    本章小结 1042
    本章习题 1042
    习题解答 1043
    第39章 元类 1046
    要么是元类,要么不是元类 1046
    提高魔力层次 1047
    “辅助”函数的缺点 1049
    元类与类装饰器的关系:第一回合 1051
    元类模型 1053
    类是类型的实例 1053
    元类是Type的子类 1055
    Class语句协议 1056
    声明元类 1057
    编写元类 1058
    基本元类 1058
    定制构建和初始化 1059
    其他元类编程技巧 1060
    实例与继承的关系 1063
    示例:向类添加方法 1064
    手动扩展 1064
    基于元类的扩展 1065
    元类与类装饰器的关系:第二回合 1067
    示例:对方法应用装饰器 1070
    用装饰器手动跟踪 1070
    用元类和装饰器跟踪 1071
    把任何装饰器应用于方法 1073
    元类与类装饰器的关系:第三回合 1074
    “可选的”语言功能 1076
    本章小结 1078
    本章习题 1078
    习题解答 1078
    第九部分 附录注2
    附录A 安装和配置 1083
    附录B 各部分练习题的解答 1093

    展开全文
  • 如果你想要编写高质量、高效的并且易于与其他语言和工具集成的代码,《Python学习手册:第4 版》将帮助你使用Python快速实现这一点,不管你是编程新手还是Python初学者。本书是易于掌握和自学的教程,根据作者Py...

    下载地址:网盘下载

     

    内容简介  · · · · · ·

    作者简介  · · · · · ·

    作为全球Python培训界的领军人物,《Python学习手册:第4版》作者Mark Lutz是Python最畅销书籍的作者,也是Python社区的先驱。

    Mark 是O'Reilly出版的《Programming Python》和《Python Pocket Reference》的作者,这两本书于2009年都已经出版了第3版。Mark自1992年开始接触Python,1995年开始撰写有关Python的书籍,从1997年开始教授Python课程。截止到2009年,他已经开办了225个Python短期培训课程,教授了大约3500名学习者,销售了大约25万册有关Python的书籍。许多书被翻译成十多种语言。

    此外,Mark拥有威斯康星大学计算机科学学士和硕士学位,在过去的25年中,他主要从事编译器、编程工具、脚本程序以及各种客户端/服务器系统方面的工作。你也可以通过访问http://www.rmi.net/~lutz与他取得联系。

    目录  · · · · · ·

    前言 1
    第一部分 使用入门
    第1章 问答环节 19
    人们为何使用Python 19
    软件质量 20
    开发效率 21
    Python是“脚本语言”吗 21
    好吧,Python的缺点是什么呢 23
    如今谁在使用Python 23
    使用Python可以做些什么 24
    系统编程 25
    用户图形接口 25
    Internet脚本 25
    组件集成 26
    数据库编程 26
    快速原型 27
    数值计算和科学计算编程 27
    游戏、图像、人工智能、XML、机器人等 27
    Python如何获得支持 28
    Python有哪些技术上的优点 28
    面向对象 28
    免费 29
    可移植 29
    功能强大 30
    可混合 31
    简单易用 31
    简单易学 32
    Python和其他语言比较起来怎么样 32
    本章小结 33
    本章习题 33
    习题解答 34
    Python是工程,不是艺术 34
    第2章 Python如何运行程序 36
    Python解释器简介 36
    程序执行 37
    程序员的视角 37
    Python的视角 39
    执行模块的变体 41
    Python实现的替代者 42
    执行优化工具 43
    冻结二进制文件 44
    其他执行选项 45
    未来的可能性 46
    本章小结 46
    本章习题 47
    习题解答 47
    第3章 如何运行程序 48
    交互提示模式下编写代码 48
    交互地运行代码 49
    为什么使用交互提示模式 51
    使用交互提示模式 52
    系统命令行和文件 54
    第一段脚本 55
    使用命令行运行文件 56
    使用命令行和文件 57
    UNIX可执行脚本(#!) 58
    UNIX env查找技巧 59
    点击文件图标 60
    在Windows中点击图标 60
    input的技巧 61
    图标点击的其他限制 63
    模块导入和重载 63
    模块的显要特性:属性 65
    import和reload的使用注意事项 68
    使用exec运行模块文件 69
    IDLE用户界面 70
    IDLE基础 71
    使用IDLE 72
    高级IDLE工具 74
    其他的IDE 74
    其他启动选项 76
    嵌入式调用 76
    冻结二进制的可执行性 77
    文本编辑器启动的选择 77
    其他的启动选择 77
    未来的可能 77
    我应该选用哪种 78
    调试Python代码 78
    本章小结 80
    本章习题 80
    习题解答 80
    第一部分 练习题 81
    第二部分 类型和运算
    第4章 介绍Python对象类型 87
    为什么使用内置类型 88
    Python的核心数据类型 88
    数字 90
    字符串 92
    序列的操作 92
    不可变性 94
    类型特定的方法 94
    寻求帮助 96
    编写字符串的其他方法 97
    模式匹配 98
    列表 98
    序列操作 98
    类型特定的操作 99
    边界检查 100
    嵌套 100
    列表解析 101
    字典 103
    映射操作 103
    重访嵌套 104
    键的排序:for 循环 105
    迭代和优化 107
    不存在的键:if 测试 107
    元组 109
    为什么要用元组 109
    文件 110
    其他文件类工具 111
    其他核心类型 111
    如何破坏代码的灵活性 113
    用户定义的类 114
    剩余的内容 115
    本章小结 115
    本章习题 116
    习题解答 116
    第5章 数字 117
    Python的数字类型 117
    数字常量 118
    内置数学工具和扩展 119
    Python表达式操作符 120
    在实际应用中的数字 125
    变量和基本的表达式 125
    数字显示的格式 126
    比较:一般的和连续的 127
    str和repr显示格式 128
    除法: 传统除法、Floor除法和真除法 129
    整数精度 133
    复数 133
    十六进制、八进制和二进制记数 134
    位操作 136
    其他的内置数学工具 137
    其他数字类型 139
    小数数字 139
    分数类型 141
    集合 145
    布尔型 151
    数字扩展 152
    本章小结 153
    本章习题 153
    习题解答 153
    第6章 动态类型简介 155
    缺少类型声明语句的情况 155
    变量、对象和引用 156
    类型属于对象,而不是变量 157
    对象的垃圾收集 158
    共享引用 159
    共享引用和在原处修改 161
    共享引用和相等 163
    动态类型随处可见 164
    本章小结 165
    本章习题 165
    习题解答 165
    第7章 字符串 167
    字符串常量 169
    单双引号字符串是一样的 170
    用转义序列代表特殊字节 171
    raw字符串抑制转义 173
    三重引号编写多行字符串块 175
    实际应用中的字符串 176
    基本操作 176
    索引和分片 177
    为什么要在意:分片 181
    字符串转换工具 181
    修改字符串 184
    字符串方法 185
    字符串方法实例:修改字符串 187
    字符串方法实例:文本解析 189
    实际应用中的其他常见字符串方法 190
    最初的字符串模块(在Python 3.0中删除) 191
    字符串格式化表达式 192
    更高级的字符串格式化表达式 194
    基于字典的字符串格式化 196
    字符串格式化调用方法 196
    基础知识 197
    添加键、属性和偏移量 198
    添加具体格式化 198
    与%格式化表达式比较 200
    为什么用新的格式化方法 203
    通常意义下的类型分类 206
    同样分类的类型共享其操作集合 206
    可变类型能够在原处修改 207
    本章小结 208
    本章习题 208
    习题解答 208
    第8章 列表与字典 210
    列表 210
    实际应用中的列表 213
    基本列表操作 213
    列表迭代和解析 213
    索引、分片和矩阵 214
    原处修改列表 215
    字典 220
    实际应用中的字典 222
    字典的基本操作 222
    原处修改字典 223
    其他字典方法 224
    语言表 225
    字典用法注意事项 226
    为什么要在意字典接口 229
    创建字典的其他方法 230
    Python 3.0中的字典变化 231
    本章小结 237
    本章习题 237
    习题解答 237
    第9章 元组、文件及其他 239
    元组 239
    实际应用中的元组 241
    为什么有了列表还要元组 243
    文件 243
    打开文件 244
    使用文件 245
    实际应用中的文件 246
    其他文件工具 252
    重访类型分类 254
    为什么要在意操作符重载 255
    对象灵活性 255
    引用 VS 拷贝 256
    比较、相等性和真值 258
    Python 3.0的字典比较 260
    Python中真和假的含义 261
    Python的类型层次 263
    Type对象 263
    Python中的其他类型 265
    内置类型陷阱 265
    赋值生成引用,而不是拷贝 265
    重复能够增加层次深度 266
    留意循环数据结构 266
    不可变类型不可以在原处改变 267
    本章小结 267
    本章习题 268
    习题解答 268
    第二部分练习题 269
    第三部分 语句和语法
    第10章 Python语句简介 275
    重访Python程序结构 275
    Python的语句 276
    两个if的故事 278
    Python增加了什么 279
    Python删除了什么 279
    为什么使用缩进语法 281
    几个特殊实例 283
    简短实例:交互循环 285
    一个简单的交互式循环 285
    对用户输入数据做数学运算 287
    用测试输入数据来处理错误 288
    用try语句处理错误 289
    嵌套代码三层 290
    本章小结 290
    本章习题 291
    习题解答 291
    第11章 赋值、表达式和打印 292
    赋值语句 292
    赋值语句的形式 293
    序列赋值 294
    Python 3.0中的扩展序列解包 297
    多目标赋值语句 301
    增强赋值语句 302
    变量命名规则 305
    Python的废弃协议 306
    表达式语句 308
    表达式语句和在原处的修改 309
    打印操作 310
    Python 3.0的print函数 311
    Python 2.6 print语句 313
    打印流重定向 315
    版本独立的打印 318
    为什么要注意print和stdout 319
    本章小结 320
    本章习题 321
    习题解答 321
    第12章 if测试和语法规则 322
    if语句 322
    通用格式 322
    基本例子 323
    多路分支 323
    Python语法规则 325
    代码块分隔符 326
    语句的分隔符 328
    一些特殊情况 329
    真值测试 330
    if/else三元表达式 332
    为什么要在意布尔值 334
    本章小结 335
    本章习题 335
    习题解答 335
    第13章 while和for循环 336
    while循环 336
    一般格式 336
    例子 337
    break、continue、pass和循环else 338
    一般循环格式 338
    pass 338
    continue 340
    break 340
    循环else 341
    为什么要在意“模拟C 语言的while循环” 342
    for循环 343
    一般格式 343
    例子 344
    为什么要在意“文件扫描” 349
    编写循环的技巧 350
    循环计数器:while和range 351
    非完备遍历:range和分片 352
    修改列表:range 353
    并行遍历:zip和map 354
    产生偏移和元素:enumerate 357
    本章小结 358
    本章习题 358
    习题解答 359
    第14章 迭代器和解析,第一部分 360
    迭代器:初探 360
    文件迭代器 361
    手动迭代:iter和next 363
    其他内置类型迭代器 365
    列表解析:初探 367
    列表解析基础知识 368
    在文件上使用列表解析 369
    扩展的列表解析语法 370
    其他迭代环境 371
    Python 3.0中的新的可迭代对象 375
    range迭代器 376
    map、zip和filter迭代器 377
    多个迭代器 VS单个迭代器 378
    字典视图迭代器 379
    其他迭代器主题 381
    本章小结 381
    本章习题 381
    习题解答 382
    第15章 文档 383
    Python文档资源 383
    #注释 384
    dir函数 384
    文档字符串:__doc__ 385
    PyDoc:help函数 388
    PyDoc:HTML报表 390
    标准手册集 393
    网络资源 394
    已出版的书籍 394
    常见编写代码的陷阱 395
    本章小结 397
    本章习题 397
    习题解答 397
    第三部分练习题 398
    第四部分 函数
    第16章 函数基础 403
    为何使用函数 404
    编写函数 405
    def语句 406
    def语句是实时执行的 407
    第一个例子:定义和调用 408
    定义 408
    调用 408
    Python中的多态 409
    第二个例子:寻找序列的交集 410
    定义 410
    调用 411
    重访多态 411
    本地变量 412
    本章小结 413
    本章习题 413
    习题解答 413
    第17章 作用域 415
    Python作用域基础 415
    作用域法则 416
    变量名解析:LEGB原则 418
    作用域实例 419
    内置作用域 420
    在Python 2.6中违反通用性 422
    global语句 422
    最小化全局变量 423
    最小化文件间的修改 424
    其他访问全局变量的方法 426
    作用域和嵌套函数 427
    嵌套作用域的细节 427
    嵌套作用域举例 427
    nonlocal语句 433
    nonlocal基础 433
    nonlocal应用 435
    为什么使用nonlocal 437
    本章小结 440
    本章习题 441
    习题解答 442
    第18章 参数 444
    传递参数 444
    参数和共享引用 445
    避免可变参数的修改 447
    对参数输出进行模拟 448
    特定的参数匹配模型 449
    基础知识 449
    匹配语法 450
    细节 452
    关键字参数和默认参数的实例 452
    任意参数的实例 455
    Python 3.0 Keyword-Only参数 459
    min调用 462
    满分 463
    加分点 464
    结论 465
    一个更有用的例子:通用set函数 465
    模拟Python 3.0 print函数 466
    使用Keyword-Only参数 467
    为什么要在意:关键字参数 469
    本章小结 469
    本章习题 470
    习题解答 470
    第19章 函数的高级话题 472
    函数设计概念 472
    递归函数 474
    用递归求和 474
    编码替代方案 475
    循环语句VS递归 476
    处理任意结构 477
    函数对象:属性和注解 478
    间接函数调用 478
    函数内省 479
    函数属性 480
    Python 3.0中的函数注解 481
    匿名函数: lambda 483
    lambda表达式 483
    为什么使用lambda 484
    如何(不要)让Python代码变得晦涩难懂 486
    嵌套lambda和作用域 487
    为什么要在意:回调 488
    在序列中映射函数:map 489
    函数式编程工具:filter和reduce 490
    本章小结 492
    本章习题 492
    习题解答 492
    第20章 迭代和解析,第二部分 494
    回顾列表解析:函数式编程工具 494
    列表解析与map 495
    增加测试和嵌套循环 496
    列表解析和矩阵 498
    理解列表解析 499
    为什么要在意:列表解析和map 500
    重访迭代器:生成器 501
    生成器函数:yield VS return 502
    生成器表达式:迭代器遇到列表解析 506
    生成器函数 VS 生成器表达式 507
    生成器是单迭代器对象 508
    用迭代工具模拟zip和map 510
    为什么你会留意:单次迭代 514
    内置类型和类中的值生成 515
    Python 3.0解析语法概括 516
    解析集合和字典解析 517
    针对集合和字典的扩展的解析语法 517
    对迭代的各种方法进行计时 518
    对模块计时 519
    计时脚本 519
    计时结果 520
    计时模块替代方案 523
    其他建议 527
    函数陷阱 528
    本地变量是静态检测的 528
    默认和可变对象 529
    没有return语句的函数 531
    嵌套作用域的循环变量 532
    本章小结 532
    本章习题 532
    习题解答 533
    第四部分练习题 533
    第五部分 模块
    第21章 模块:宏伟蓝图 539
    为什么使用模块 540
    Python程序架构 540
    如何组织一个程序 541
    导入和属性 541
    标准库模块 543
    import如何工作 543
    1.搜索 544
    2.编译(可选) 544
    3.运行 545
    模块搜索路径 545
    配置搜索路径 547
    搜索路径的变动 548
    sys.path列表 548
    模块文件选择 549
    高级的模块选择概念 550
    第三方工具:distutils 550
    本章小结 551
    本章习题 551
    习题解答 551
    第22章 模块代码编写基础 553
    模块的创建 553
    模块的使用 554
    import语句 554
    from语句 555
    from *语句 555
    导入只发生一次 555
    import和from是赋值语句 556
    文件间变量名的改变 557
    import和from的对等性 557
    from语句潜在的陷阱 558
    模块命名空间 560
    文件生成命名空间 560
    属性名的点号运算 562
    导入和作用域 562
    命名空间的嵌套 563
    重载模块 564
    reload基础 565
    reload实例 566
    为什么要在意:模块重载 567
    本章小结 568
    本章习题 568
    习题解答 568
    第23章 模块包 570
    包导入基础 570
    包和搜索路径设置 571
    __init__.py包文件 572
    包导入实例 573
    包对应的from语句和import语句 574
    为什么要使用包导入 575
    三个系统的传说 576
    包相对导入 578
    Python 3.0中的变化 578
    相对导入基础知识 579
    为什么使用相对导入 581
    相对导入的作用域 583
    模块查找规则总结 583
    相对导入的应用 584
    为什么要在意:模块包 589
    本章小结 590
    本章习题 590
    习题解答 590
    第24章 高级模块话题 592
    在模块中隐藏数据 592
    最小化from *的破坏:_X和__all__ 593
    启用以后的语言特性 593
    混合用法模式:__name__和__main__ 594
    以__name__进行单元测试 595
    使用带有__name__的命令行参数 596
    修改模块搜索路径 599
    Import语句和from语句的as扩展 599
    模块是对象:元程序 600
    用名称字符串导入模块 603
    过渡性模块重载 604
    模块设计理念 607
    模块陷阱 607
    顶层代码的语句次序的重要性 608
    from复制变量名,而不是连接 609
    from *会让变量语义模糊 610
    reload不会影响from导入 610
    reload、from以及交互模式测试 611
    递归形式的from导入无法工作 612
    本章小结 613
    本章习题 613
    习题解答 613
    第五部分练习题 614
    第六部分 类和OOP
    第25章 OOP:宏伟蓝图 619
    为何使用类 620
    概览OOP 621
    属性继承搜索 621
    类和实例 623
    类方法调用 624
    编写类树 624
    OOP是为了代码重用 627
    本章小结 629
    本章习题 629
    习题解答 630
    第26章 类代码编写基础 631
    类产生多个实例对象 631
    类对象提供默认行为 632
    实例对象是具体的元素 632
    第一个例子 632
    类通过继承进行定制 635
    第二个例子 635
    类是模块内的属性 637
    类可以截获Python运算符 638
    第三个例子 639
    为什么要使用运算符重载 641
    世界上最简单的Python类 641
    类与字典的关系 644
    本章小结 646
    本章习题 646
    习题解答 646
    第27章 更多实例 649
    步骤1:创建实例 650
    编写构造函数 650
    在进行中测试 651
    以两种方式使用代码 652
    版本差异提示 654
    步骤2:添加行为方法 654
    编写方法 656
    步骤3:运算符重载 658
    提供打印显示 658
    步骤4:通过子类定制行为 659
    编写子类 660
    扩展方法:不好的方式 660
    扩展方法:好的方式 661
    多态的作用 663
    继承、定制和扩展 664
    OOP:大思路 664
    步骤5:定制构造函数 665
    OOP比我们认为的要简单 666
    组合类的其他方式 667
    在Python 3.0中捕获内置属性 669
    步骤6:使用内省工具 670
    特殊类属性 670
    一种通用显示工具 671
    实例与类属性的关系 672
    工具类的命名考虑 673
    类的最终形式 674
    步骤7(最后一步):把对象存储到数据库中 676
    Pickle和Shelve 676
    在shelve数据库中存储对象 677
    交互地探索shelve 678
    更新shelve中的对象 680
    未来方向 681
    本章小结 683
    本章习题 684
    习题解答 684
    第28章 类代码编写细节 686
    class语句 686
    一般形式 686
    例子 687
    方法 689
    例子 690
    调用超类构造函数 691
    其他方法调用的可能性 691
    继承 692
    属性树的构造 692
    继承方法的专有化 693
    类接口技术 694
    抽象超类 695
    Python 2.6和Python 3.0的抽象超类 696
    命名空间:完整的内容 698
    简单变量名:如果赋值就不是全局变量 698
    属性名称:对象命名空间 698
    Python命名空间的“禅”:赋值将变量名分类 699
    命名空间字典 701
    命名空间链接 704
    回顾文档字符串 706
    类与模块的关系 707
    本章小结 708
    本章习题 708
    习题解答 708
    第29章 运算符重载 710
    基础知识 710
    构造函数和表达式:__init__和__sub__ 711
    常见的运算符重载方法 711
    索引和分片:__getitem__和__setitem__ 713
    拦截分片 713
    Python 2.6中的分片和索引 715
    索引迭代:__getitem__ 716
    迭代器对象:__iter__和__next__ 717
    用户定义的迭代器 717
    有多个迭代器的对象 719
    成员关系:__contains__、__iter__和__getitem__ 721
    属性引用:__getattr__和__setattr__ 723
    其他属性管理工具 725
    模拟实例属性的私有性:第一部分 725
    __repr__和__str__会返回字符串表达形式 726
    右侧加法和原处加法:__radd__和__iadd__ 729
    原处加法 730
    Call表达式:__call__ 731
    函数接口和回调代码 732
    比较:__lt__、__gt__和其他方法 734
    Python 2.6的__cmp__方法(已经从Python 3.0中移除了) 734
    布尔测试:__bool__和__len__ 735
    Python 2.6中的布尔 736
    对象析构函数:__del__ 738
    本章小结 739
    本章习题 739
    习题解答 739
    第30章 类的设计 741
    Python和OOP 741
    通过调用标记进行重载(或不要) 742
    OOP和继承:“是一个”关系 743
    OOP和组合:“有一个”关系 744
    重访流处理器 746
    为什么要在意:类和持续性 748
    OOP和委托:“包装”对象 749
    类的伪私有属性 751
    变量名压缩概览 751
    为什么使用伪私有属性 752
    方法是对象:绑定或无绑定 754
    在Python 3.0中,无绑定方法是函数 756
    绑定方法和其他可调用对象 757
    为什么要在意:绑定方法和回调函数 760
    多重继承:“混合”类 760
    编写混合显示类 761
    类是对象:通用对象的工厂 771
    为什么有工厂 772
    与设计相关的其他话题 773
    本章小结 773
    本章习题 774
    习题解答 774
    第31章 类的高级主题 775
    扩展内置类型 775
    通过嵌入扩展类型 776
    通过子类扩展类型 777
    新式类 779
    新式类变化 780
    类型模式变化 781
    钻石继承变动 785
    新式类的扩展 789
    slots实例 789
    类特性 793
    __getattribute__和描述符 795
    元类 795
    静态方法和类方法 796
    为什么使用特殊方法 796
    Python 2.6和Python 3.0中的静态方法 797
    静态方法替代方案 799
    使用静态和类方法 800
    使用静态方法统计实例 801
    用类方法统计实例 802
    装饰器和元类:第一部分 805
    函数装饰器基础 805
    装饰器例子 806
    类装饰器和元类 807
    更多详细信息 808
    类陷阱 809
    修改类属性的副作用 809
    修改可变的类属性也可能产生副作用 810
    多重继承:顺序很重要 811
    类、方法以及嵌套作用域 812
    Python中基于委托的类:__getattr__和内置函数 814
    “过度包装” 814
    本章小结 815
    本章习题 815
    习题解答 815
    第六部分练习题 816
    为什么要在意:大师眼中的OOP 821
    第七部分 异常和工具
    第32章 异常基础 825
    为什么使用异常 826
    异常的角色 826
    异常处理:简明扼要 827
    默认异常处理器 827
    捕获异常 828
    引发异常 829
    用户定义的异常 830
    终止行为 830
    为什么要在意:错误检查 832
    本章小结 833
    本章习题 833
    习题解答 834
    第33章 异常编码细节 835
    try/except/else语句 835
    try语句分句 836
    try/else分句 839
    例子:默认行为 840
    例子:捕捉内置异常 841
    try/finally语句 841
    例子:利用try/finally编写终止行为 842
    统一try/except/finally语句 843
    统一try语句语法 845
    通过嵌套合并finally和except 845
    合并try的例子 846
    raise语句 847
    利用raise传递异常 849
    Python 3.0异常链:raise from 849
    assert语句 850
    例子:收集约束条件(但不是错误) 850
    with/as环境管理器 851
    基本使用 852
    环境管理协议 853
    本章小结 855
    本章习题 855
    习题解答 856
    第34章 异常对象 857
    异常:回到未来 858
    字符串异常很简单 858
    基于类的异常 858
    类异常例子 859
    为什么使用类异常 861
    内置Exception类 864
    内置异常分类 865
    默认打印和状态 866
    定制打印显示 867
    定制数据和行为 868
    提供异常细节 868
    提供异常方法 869
    本章小结 870
    本章习题 870
    习题解答 870
    第35章 异常的设计 872
    嵌套异常处理器 872
    例子:控制流程嵌套 873
    例子:语法嵌套化 874
    异常的习惯用法 876
    异常不总是错误 876
    函数信号条件和raise 876
    关闭文件和服务器连接 877
    在try外进行调试 878
    运行进程中的测试 879
    关于sys.exc_info 879
    与异常有关的技巧 880
    应该包装什么 881
    捕捉太多:避免空except语句 881
    捕捉过少:使用基于类的分类 883
    核心语言总结 884
    Python工具集 884
    大型项目的开发工具 885
    本章小结 888
    第七部分练习题 889
    第八部分 高级话题注1
    第36章 Unicode和字节字符串 893
    Python 3.0中的字符串修改 894
    字符串基础知识 895
    字符编码方法 895
    Python的字符串类型 897
    文本和二进制文件 899
    Python 3.0中的字符串应用 900
    常量和基本属性 900
    转换 901
    编码Unicode字符串 903
    编码ASCII文本 903
    编码非ASCII文本 904
    编码和解码非ASCII文本 904
    其他Unicode编码技术 905
    转换编码 907
    在Python 2.6中编码Unicode字符串 908
    源文件字符集编码声明 910
    使用Python 3.0 Bytes对象 911
    方法调用 912
    序列操作 913
    创建bytes对象的其他方式 913
    混合字符串类型 914
    使用Python 3.0(和Python 2.6)bytearray对象 915
    使用文本文件和二进制文件 918
    文本文件基础 919
    Python 3.0中的文本和二进制模式 919
    类型和内容错误匹配 921
    使用Unicode文件 922
    在Python 3.0中读取和写入Unicode 922
    在Python 3.0中处理BOM 924
    Python 2.6中的Unicode文件 927
    Python 3.0中其他字符串工具的变化 927
    re模式匹配模块 927
    Struct二进制数据模块 928
    pickle对象序列化模块 931
    XML解析工具 932
    本章小结 935
    本章习题 935
    习题解答 936
    第37章 管理属性 938
    为什么管理属性 938
    插入在属性访问时运行的代码 939
    特性 940
    基础知识 940
    第一个例子 941
    计算的属性 942
    使用装饰器编写特性 943
    描述符 944
    基础知识 945
    第一个示例 947
    计算的属性 949
    在描述符中使用状态信息 950
    特性和描述符是如何相关的 952
    __getattr__和__getattribute__ 953
    基础知识 954
    第一个示例 956
    计算属性 958
    __getattr__和__getattribute__比较 959
    管理技术比较 960
    拦截内置操作属性 963
    重访基于委托的Manager 967
    示例:属性验证 970
    使用特性来验证 971
    使用描述符验证 973
    使用__getattr__来验证 974
    使用__getattribute__验证 976
    本章小结 977
    本章习题 977
    习题解答 977
    第38章 装饰器 979
    什么是装饰器 979
    管理调用和实例 980
    管理函数和类 980
    使用和定义装饰器 981
    为什么使用装饰器 981
    基础知识 982
    函数装饰器 982
    类装饰器 986
    装饰器嵌套 988
    装饰器参数 990
    装饰器管理函数和类 991
    编写函数装饰器 991
    跟踪调用 992
    状态信息保持选项 993
    类错误之一:装饰类方法 997
    计时调用 1002
    添加装饰器参数 1004
    编写类装饰器 1007
    单体类 1007
    跟踪对象接口 1009
    类错误之二:保持多个实例 1012
    装饰器与管理器函数的关系 1013
    为什么使用装饰器(重访) 1015
    直接管理函数和类 1016
    示例:“私有”和“公有”属性 1018
    实现私有属性 1019
    实现细节之一 1021
    公有声明的泛化 1022
    实现细节之二 1024
    开放问题 1025
    Python不是关于控制 1029
    示例:验证函数参数 1030
    目标 1030
    针对位置参数的一个基本范围测试装饰器 1031
    针对关键字和默认泛化 1033
    实现细节 1036
    开放问题 1038
    装饰器参数 VS 函数注解 1039
    其他应用程序:类型测试 1041
    本章小结 1042
    本章习题 1042
    习题解答 1043
    第39章 元类 1046
    要么是元类,要么不是元类 1046
    提高魔力层次 1047
    “辅助”函数的缺点 1049
    元类与类装饰器的关系:第一回合 1051
    元类模型 1053
    类是类型的实例 1053
    元类是Type的子类 1055
    Class语句协议 1056
    声明元类 1057
    编写元类 1058
    基本元类 1058
    定制构建和初始化 1059
    其他元类编程技巧 1060
    实例与继承的关系 1063
    示例:向类添加方法 1064
    手动扩展 1064
    基于元类的扩展 1065
    元类与类装饰器的关系:第二回合 1067
    示例:对方法应用装饰器 1070
    用装饰器手动跟踪 1070
    用元类和装饰器跟踪 1071
    把任何装饰器应用于方法 1073
    元类与类装饰器的关系:第三回合 1074
    “可选的”语言功能 1076
    本章小结 1078
    本章习题 1078
    习题解答 1078
    第九部分 附录注2
    附录A 安装和配置 1083
    附录B 各部分练习题的解答 1093

     

     

    下载地址:网盘下载

     

    转载于:https://www.cnblogs.com/long12365/p/9730310.html

    展开全文
  • 之前为了编写一个svm分词的程序而简单学了下Python,觉得Python很好用,想深入并系统学习一下,了解一些机制,因此开始阅读《Python学习手册(第三版)》。如果只是想快速入门,我在这里推
    原文地址为:《Python学习手册》读书笔记

      之前为了编写一个svm分词的程序而简单学了下Python,觉得Python很好用,想深入并系统学习一下,了解一些机制,因此开始阅读《Python学习手册(第三版)》。如果只是想快速入门,我在这里推荐了几篇文章,有其他语言编程经验的人简单看一看就可以很快地开始编写Python程序了。

      黑体表示章节下划线表示可以直接在原文对应位置查到的专有技术名词。

      原书配套答案请到http://www.hzbook.com/Books/4572.html下载,简单注册即可。

    第三章 如何运行程序

      import进行模块导入只能运行一次,多次运行需使用reload。

      模块往往是变量名的封装,被认为是命名空间。例如:

    #myfile.py
    title = "test"

    >>>import myfile
    >>>print myfile.title
    test

      替代方案是from,下面有同样的效果:

    >>>from myfile import title
    >>>print tittle
    test
    from myfile import * 则可以把myfile所有变量全部导入(第19章内容)。

    第四章 介绍Python对象类型

      虽然字符串支持多种操作,但是它具有不可变性,即原字符串不能改变,只能用新字符串作为结果赋予一个变量。下面是一个试图改变原字符串的操作及报错信息:

    >>> s="spam"
    >>> s[0] = 'z'
    Traceback (most recent call last):
    File
    "<stdin>", line 1, in <module>
    TypeError:
    'str' object does not support item assignment

     第五章 数字

       str和repr显示格式

    >>>num = 1/3.0
    >>>num
    0.33333333333333331
    >>>print num
    333333333333

    >>>repr(num)
    '0.33333333333333331' #交互模式回显
    >>>str(num)
    '333333333333' #打印语句

     

      浮点数运算在精确方面有缺陷。这和硬件有关,打印结果也不能完全解决。

    >>> 0.1+0.1+0.1-0.3
    5.551115123125783e-17
    >>> print 0.1+0.1+0.1-0.3
    5.55111512313e-17

      使用小数对象可以进行修正

    >>> from decimal import Decimal
    >>> Decimal('0.1') + Decimal('0.1') + Decimal('0.1') - Decimal('0.3')
    Decimal(
    '0.0')

     第六章 动态类型简介

      a = 3这个语句实际上执行了三个步骤:创建一个对象代表值3;如果还未创建,创建一个变量a;将变量与新的对象3连接。这时,变量a成为了对象3的一个引用,也可以看做是指针。

      类型属于对象,而不是变量,这就很好理解为什么Python中同一个变量名可以作为不同类型的对象的引用了。

      在这种机制下,每个对象都有一个引用计数器,当计数器为0时就被系统回收,这便是Python中对象的垃圾收集的方法了。

      不同变量引用同一个数字或字符串时,对变量操作(eg.a=3 a=a+2)只是创建了一个新的对象并使它引用新对象,这也是上一章提到的字符串不能改动的原因。而对于一些类型来说,有的操作确实能改变对象,如下所示:

    #situation 1
    >>>L1=[2,3,4]
    >>>L2=L1
    >>>L1=24
    >>>L2
    [
    2,3,4]

    #situation 2
    >>L1=[2,3,4]
    >>>L2=L1
    >>>L2[0]=24
    >>>L1
    [
    24,3,4]

      为了让两个变量使用不同的对象,可以拷贝对象,使用L2=L1[:]来代替L2=L1即可。对于字典则使用D.copy()方法。标准库的copy模块提供了一个对任意对象的调用方法,下面两种方式的区别暂不讨论:

    import copy
    X
    = copy.copy(Y) #表层拷贝
    X = copy.deepcopy(Y) #深拷贝

      这里就出现了个问题,两个引用是否是同一对象?可以用下面的方式判断:

    >>>L=[1,2,3]
    >>>M=L
    >>>L== M
    True
    >>>L is M
    True

      负值索引相当于从末尾倒数。-1就是最后一个元素的索引。对于s="spam",-5是个非法的索引值。分号:前的空值表示从第一个开始,后的空值表示直到最后一个。

     第七章 字符串

      单双引号是一样的,这样允许用户不使用转移字符来实现带有单或双引号的字符串。个人认为避免了按shift才能使用双引号“的麻烦。

    >>>'knight"s ',"knight's"
    (
    'knight"s ',"knight's")

      此外,合并相邻的字符串常量,如'knight"s ' "knight's"(中间有空格)会显示为'knight"s knight\'s'。可见,最外层是单引号,为了保持原内容,Python把单引号里的单引号改写成了转义字符,这个例子和书上的不同,更有助于理解。转义字符和C很类似,多了几种;但是Python里没有空字符串,Python为每个字符串保存了内容和长度。同时,如果一个字符串中没有合法的转义编码出现在"\"后,那么它将在字符串中保留反斜线。抑制转义的方法是在字符串前加r,如r"C:\new\text.dat",此时的\n和\t就不会被当做是转义字符,同时,这样做也不必把\改写成\\。

      三重引号适用于多行的字符串的直接输入而不使用转义字符。利用三重引号也可以实现类似C中/* */注释掉代码的目的。

      Unicode字符串通过在前面加u获得。

      扩展分片是第三个索引,用作步进。这时完整的分片形式为X[I:J:K],其中步进为K。当步进取-1时,可以把字符串反转,很神奇的方法。

      利用分片,可以对字符串进行修改,即把新字符串加到原字符串上,再把原字符串切掉。

      字符串格式化的用法与C的printf很像,不同之处在于所有参数外需要加一个(),形成%(arg1,arg2,arg3)的形式。格式化代码请参考原书表格,通用结构:%[(name)][flags][width][.precision]code,其中name可以是字典名,这时在参数表里提供这个字典的键即可。

      既然字符串是对象,那么它就有对应的方法。书上介绍了修改字符串的replace()、查找find()、把每个元素取出创建列表的list()、把列表合并成字符串的join()(可以作为list()的反操作)、提取组件的split()。

     

    第八章 列表

      用中括号表示列表,列表的组成对象是有序的,组成列表的各个对象允许不同。

      用大括号表示字典,字典的组成对象是无序的,字典键的搜索方式是哈希搜索,速度很快。

      可以用字典来模拟列表:使用序数作为字典的索引即可。类似地,字典可以用来表示一些稀疏矩阵。

      字典的get方法用于避免不存在的键,如果键不存在,返回值是0。

      字典接口是使用方式类似字典并且实际工作都和字典一样的一些Python扩展程序的接口。

     

    第9章 元组、文件及其他 

      用小括号表示元组,元组不能原处修改。

      为了避免只含一个元素的元组被当做表达式,使用一个逗号,写为(40,)。逗号可以帮助识别元组,下面的也是元组的表示方式:

    t = 0,'Ni',1.2,3

      从文件中读取的是字符串,需要作为其他类型来操作时必须转换。

      eval()用来把字符串作为对象,因此也可以达到执行Python的任何表达式。

      pickle模块可以直接在文件中存储几乎任何Python对象。

      struct模块提供了二进制数据的打包。打包+存入文件,读取文件+解包。

      在“赋值VS引用”这一节,对于复合方式的赋值,修改其成员会导致所有使用该成员的对象的改变。直观来看就是下面:

    >>>X = [1,2,3]
    >>>L = ['a', X, 'b']
    >>>D = {'x':X, 'y':2}
    >>>X[1] = 'surprise'
    >>>L
    [
    'a', [1,'surprise',3], 'b']
    >>>D
    {
    'x':[1,'surprise',3], 'y':2}

      这是一个陷阱,为了避免这种情况,根据具体类型使用拷贝(比如分片、copy方法)而不是引用。

      Python内部暂时存储并重复使用短字符串,因此对同样内容的字符串,is判定可能根据其长度为True(字符串较短时)或False(字符串较长时)。不同类型的比较(用==进行)的判定方式不一样。

      还有其他内置类型陷阱,如重复能增加层次深度,循环数据结构L=L.append(L)

     

    第二部分练习题

      2.(摘自附录B)分片运算超出边界(例如,L[-1000:100])可工作,因为Python会缩放超出边界的分片(必要时,限制值可设为零和序列长度)。以翻转的方式提取序列是行不通的(较低边界值比较高边界值更大,例如,L[3:1])。你会得到空分片([ ]),因为Python会缩放分片限制值,以确定较低边界永远比较高边界小或相等(例如,L[3:1]会缩放成L[3:3],空的插入点是在偏移值3处)。Python分片一定是从左至右抽取,即使你用负号索引值也是这样(会先加上序列长度转换成正值)。注意到,Python 2.3的第三限制值分片会稍微修改此行为:L[3:1:-1]的确是从右至左抽取。

      3.索引运算、分片运算以及del:对于L=[1,2,3,4], L[2] = []只能把3变为[],而L[2:3] = []却能删掉第三项。

      4.X,Y = Y,X,左边视为两个对象,右边视为一个元组,这个表达式交换了两个引用。

     

    第10章 Python语句简介 

      绝大多数的Python程序每行一个语句,不需要分号。Python的风格就是完全不要分号,虽然在语句末加上分号也能通过。唯一需要分号的情况是一行中多个语句的分隔符。相反地,括号可以使一个语句分隔成很多行,比如用列表直观地定义一个矩阵时。反斜线\也可以达到这个目的。

      嵌套代码只需要保持缩进一致即可。Python是WYSIWYG语言(what you see is what you get,所见即所得)

     

    第11章 赋值、表达式和打印

      形如X+=Y的赋值语句称为增强赋值语句,它有三个优点:程序员输入减少,左侧只需要计算一次(X=X+Y中X计算两次),优化技术会自动选择(支持原处修改的类型可以直接原处修改)。

      单一下划线开头的变量名不会被from module import *这样的语句导入。前后都有双下划线的变量名是系统定义的变量名,对解释器有特殊意义。双下划线开头但结尾没有双下划线的变量是类的本地变量(参考第19章)。

      表达式语句通常用于执行可原处修改列表的列表方法,即对于列表L,L.append(3)是正确的,而L=L.append(4)是错误的,第二个式子右边返回的是None。

      标准输出的重定向方法:

    import sys
    sys.stdout
    = open('log.txt','a')
    ...
    print x,y,x #写入log.txt

     为了避免忘记恢复sys.stdout,写入log.txt也可以用:

    log = open('log.txt','a')
    print >>log, x, y, x

     

    第12章 if测试

       类似于C,Python的布尔运算or是短路运算,而它返回第一个为真的操作对象,或者是第二个为假的对象。[ ] or { } 将返回{ }。

      if选择分支有以下几种等价形式:

    #最常见的分支形式
    if X:
    A
    = Y
    else:
    A
    = Z

    #Python2.5以后引入
    A = Y if X else Z

    #Python2.5以前(以后也兼容)
    #
    需要理解and和or的运算和返回值规则
    A = ((X and Y) or Z)

    #列表形式
    A = [Z,Y][bool(X)]

     

    第13章  while和for循环

      pass语句是无运算的占位符,为了表示语法需要语句并且还没有任何实用的语句可写时就可以使用它。

      while和for循环都有一个可选的else语句,在循环条件不满足时且没有用break结束循环时使用。

      C语言形式的 while((x = next()) != NULL) { ...process x...}在Python里行不通:C语言赋值语句会返回赋值后的值,而Python赋值语句只是语句,不是表达式。

      Python的迭代协议:有next方法的对象会前进到下一个结果,而在末尾时引发StopIteration。所有的迭代工具内部工作都调用next,并捕捉StopIteration异常来确定何时离开。

      用for修改列表时,for x in L:x+=1是无法修改的,因为它修改的是循环变量x而不是列表L。应该使用L[i]  +=1的索引来控制修改。

      zip()可以用于for并行修改多个对象时的情况(按最短的截断)。它也可以用来再循环中建立列表:for (k,v) in zip(keys, vals):D[k]=v。

      enumerate()用于产生偏移和元素:for (offset,item) in enumerate(S): print offset,item

      基本的列表解析:L=[x+10 for x in L]

      扩展的列表解析,删除文件中的换行符:

    lines = [line.rstrip() for line in open('script1.py') if line[0] =='p']

      从文件中逐行读取文本行的最佳方法是不要刻意去读:

    for line in open('script1.py'):
    print line.upper()

     

    第十四章 文档

      __doc__属性封装了对象上的文档,通过它可以查看(比如函数的)注释。

      文档字符串被认为最是用于较大、功能性的文档,而#最好只限于关于费解的表达式或语句的微型文档。PyDoc系统能够将前者取出并显示。

     

    第十五章 函数基础

      def是可执行代码,直到运行了def时其定义的函数才开始存在。

      由于函数的参数没有类型规定,因此可以很方便地实现多态:

    >>>def times(x,y):
    ...
    return x*y
    ...

    >>>times(2,4)
    8
    >>>times('Ni',4)
    'NiNiNiNi'

     

    第十六章 作用域与参数

      变量名解析的LEGB原则:变量名引用分为三个作用域进行查找,本地作用域(L,每次调用函数时创建)、上一级调用的本地作用域(E)、全局作用域(G,模块作用域)、内置作用域(B,预定义的变量名如open)。仅对简单变量生效,对于特定对象的变量如object.spam,查找规则规则完全不同。

      内置作用域是一个名为__builtin__的内置模块,import后才可以使用,这时可以用dir(__buildin__)查看预定义的变量名。根据LEGB原则,在本地作用域定义一个新的open = 'spam'会导致open()函数不能被调用。

      global用于全局变量声明。

      作者认为在模块导入时,导入其他模块的模块拥有了对其他模块变量的修改权,这使得被导入模块的维护变得复杂:维护者不知道第二个模块什么情况下会修改变量。因此最好的解决办法是不这样做,在文件间进行通信的最好办法就是通过调用函数,传递参数,然后获得返回值(用函数提供修改变量的接口,并且告诉维护者这个变量可以被其他模块改变)。

      工厂函数(又称闭合),是能记住嵌套作用域的变量值的函数。示例:

    >>> def maker(N):
    ...
    def action(X):
    ...
    return X ** N
    ...
    return action
    ...
    >>> f = maker(2)
    >>> f #显示f的引用
    <function action at 0xb7738294>
    >>> f(3)
    9
    >>> f(4)
    16
    >>> g = maker(3)
    >>> g(3)
    27
    >>> f(3)
    9

      对于函数参数,不可变参数是通过传值来传递,可变对象(列表、字典等)是通过传引用进行传递的。

      多个返回值的常用return方式是使用元组。

      函数参数的四种匹配方式:位置匹配、关键字参数、所有对象、所有关键字/值:

    >>>def f(a,b,c):print a,b,c #常规匹配
    >>>f(1,2,3)
    1 2 3

    >>>f(c=3,b=2,a=1) #关键字匹配
    1 2 3

    >>>f(1,c=3,b=2) #位置+关键字匹配
    1 2 3

    >>>def f(a,b=2,c=3):print a,b,c #默认参数
    >>>f(1)
    1 2 3
    >>>f(a=1)
    1 2 3

    >>>def f(*args):print args # 任意参数*
    >>>f()
    ()
    >>>f(1)
    (
    1,)
    >>>f(1,2,3,4)

    >>>def f(**args):print args # 任意参数**,把参数组装成为字典
    >>>f()
    {}
    >>>f(a=1,b=2)
    {
    'a'=1,'b'=2}

    相反地,调用函数在参数变量前面加*可以分解参数。

      参数匹配顺序:调用和定义中先是非关键字参数(name)、然后是关键字参数(name=value)、*name最后是**name。

     

    第17章 函数的高级话题

      def f(x,y,z):return x+y+z和f= lambda x,y,z:x+y+z会达到同样的效果。lambda是一个表达式,而不是语句,允许出现在def不能出现的地方。正是因为这个特点,lambda比def的使用更加灵活,比如编写跳转表(也即行为的列表或字典):L=[(lambda x:x**2),[(lambda x:x**3),[(lambda x:x**4)]。出于代码易读性的考虑,应尽量避免嵌套的lambda。

      apply的介绍略过,它可以用*和**型参数代替。(似乎在Python3.0以上版本已废弃,待确认)

      map(func,arg)可以很方便的用函数func处理列表类型的数据,而自己编写类似的功能需要使用for来完成。

      filter和reduce这两个函数工具分别用于列表过滤和列表全元素的逐个运算。

      关于列表解析,带if条件的之前已提过,不再重复。for的应用示例:

    >>> res = [x+y for x in [0,1,2] for y in [100,200,300]]
    >>> res
    [
    100, 200, 300, 101, 201, 301, 102, 202, 302]

    更进一步的嵌套:

    >>>[(x,y) for x in range(5) if x%2 ==0 for y in range(5) if y%2==0]

    作者在这里开了个小玩笑:“而map和filter的等效形式往往更复杂也会有深层的嵌套,这里不进行说明,将这部分代码留给禅师、前LISP程序员以及犯罪神经病作为练习”。

      生成器函数与一般函数不同之处在于,它yield而不是return一个值,并把自己挂起,现场保存在下一次调用。为与列表解析相区分,可以使用圆括号作为生成器表达式:

    >>> for num in (x **2 for x in range(4)):
    ...
    print '%s,%s' %(num,num/2.0)
    ...
    0,
    0.0
    1,0.5
    4,2.0
    9,4.5

      一个测试不同的迭代方法的小程序。当然,对于不同的操作,不同方法的相对速度可能不一样,不存在所有情况下都最快的“最优方法”:

    #file timerseqs.py
    import time,sys
    reps
    = 1000
    size
    = 10000

    def tester(func, *args):
    startTime
    = time.time()
    for i in range(reps):
    func(
    *args)
    elapsed
    = time.time() - startTime
    return elapsed

    def forStatement():
    res
    = []
    for x in range(size):
    res.append(abs(x))

    def listComprehension():
    res
    = [abs(x) for x in range(size)]

    def mapFunction():
    res
    = map(abs, range(size))

    def generatorExpression():
    res
    = list(abs(x) for x in range(size))

    print sys.version
    tests
    = (forStatement, listComprehension, mapFunction,generatorExpression)
    for testfunc in tests:
    print testfunc.__name__.ljust(20), '=>',tester(testfunc)

      陷阱:本地变量是静态检测的。这意味着如果在模块里定义了X=99,def一个函数print X后又在函数里X=88,那么就会报错。

      陷阱:默认对象在def时赋值,而不是调用函数时赋值。

     

    第18章 模块:宏伟蓝图

      Python进行import时搜索目录的顺序:主目录、PYTHONPATH环境变量目录、标准库目录、.pth目录。

     

    第19章 模块代码编写基础 

      将会被用于导入的模块文件命名需要以.py做结尾。

      当两个不同模块使用了相同的变量名时,不能用from,只能用import。

      (本章大部分内容都在第三章介绍过)

     

    第20章 模块包

      import时列出路径名称,以点号相隔:import dir1.dir2.mod。这与平台无关,import不能使用平台特定的路径表达方式。同时,这也表明文件名省略了.py的原因。另外,dir1和dir2中必须包含一个__init__.py文件(可以为空,Python首次进入其所在目录时会执行它的内容)。每次使用路径必须完整输入,使用import dir1.dir2.mod as mod中定义的mod代替前面过长的路径名可以解决这个问题。

      个人认为,模块包是为了方便同名模块的使用不发生混淆的方式,这是软件开发时所需要的。

     

    第21章 高级模块话题

      _X的命名方式可以防止from *导入这个变量,然而这种方法不能阻止其他导入方式的导入,并不是一些面向对象语言中的私有声明。

      __all__会列出from *复制的变量名,与_X正相反。同样只对from *有效,不是私有声明。

      from __feature__ import featurename还不是很理解,好象是用选用扩展功能的方式开启特殊的代码编译。

      模块可以通过检测自己的__name__是否为"__main__"确定它是在执行还是被导入。这样可以让模块在扮演两种不同角色时发挥不同功能。

      相对导入:路径以一个点开始,定位同一个包的模块。可以开启__feature__中强迫导入的绝对性。很类似于Linux,两个点表示上一级路径。

      陷阱一:顶层代码的语句次序。被import时模块的顶层代码会立即执行,此时它所引用后文定义的变量将无效。

      陷阱二:字符串变量是不能直接用于import语句的。可以使用exec "import" + modname来使用字符串modname。这样做仍然有个缺点,每次执行时必须编译import语句。更好的代替方案是string = __import__(modname),然后把string单列一行执行即可。

      陷阱三:from复制变量名而不是拷贝。

    #nested1.py
    X = 99
    def printer():print X

    #nested2.py
    from nested1 import X,printer
    X
    = 88
    printer()

    %python nested2.py
    99

      陷阱四:reload不影响from导入。为了更新变量,使用.运算符来导入和修改其他模块的变量。

      陷阱五:reload、from及交互模式测试。这部分比较有启发性,建议在原书仔细阅读,简要概括就还是:导入后(模块)要重载(模块),重载后还要重新执行import(变量)。reload和from的合作并不完美,最佳原则是使用reload和import来启动程序。

      陷阱六:重载没有传递性。重载A不会重载A中import的B和C。需要这种功能时可以自己编写一个通用工具。

    reload_all
    import types
    def status(module):
    print 'reloading',module.__name__

    def transitive_reload(module,visited):
    if not visited.has_key(module):
    status(module)
    reload(module)
    visited[module]
    = None
    for attrobj in module.__dict__.values(): #For all attrs
    if type(sttrobj) == types.ModuleType:
    transitive_reload(attrobj,visited)

    def reload_all(*args):
    visited
    = {}
    for arg in args:
    if type(arg) == types.Module Type:
    transitive_reload(arg,visited)

    if __name__ == '__main__':
    import reloadall
    reload_all(reloadall)

      陷阱七:递归导入。

     

    第22章 OOP:宏伟蓝图

      属性通常是在class语句中通过赋值语句添加在类中,而不是在定义类时嵌入。因此对没有赋值的对象属性的访问会出错。

      类方法函数第一个参数通常为self(调用时不指明),但不一定叫self,位置是关键(来自习题5)。作为类方法直接调用时,需指明实例的名称(24章)。

      Python的OOP模型其实就是在对象树中搜索属性。

      (笔者有部分OOP基础,因此本章具体理论和理解略去)

     

    第23章 类代码编写基础

      类其实也是一种对象。

      在类定义外创建的函数也可以成为方法:

     

    >>>def upperName(self):
    ...
    return self.name.upper()

    >>>rec.method = upperName

     

     

    第24章 类代码编写细节

      和def一样,class也是可执行代码,运行时才会产生类对象。

      调用超类的构造器是可以的,在子类的构造方法中使用Super.__init__()即可。

      抽象超类有的方法没有提供实现,而是由子类提供。

      类的运算符重载通过修改诸如__add__(对应于+)等方法来实现。具体细节请参考原书。下面是一个修改__iter__获得用户定义的迭代器的例子:

    View Code
    class Squares:
    def __init__(self,start,stop):
    self.value
    = start - 1
    self.stop
    = stop
    def __iter__(self):
    return self
    def next(self):
    if self.value == self.stop:
    raise StopIteration
    self.value
    += 1
    return self.value ** 2

    %python
    >>>from iters import Squares
    >>>for i in Squares(1,5):
    ...
    print i,
    ...
    1 4 9 16 25

       __setattr__的修改可以模拟实现成员变量私有性,这里不贴书中的源码了。

      右侧方法如__radd__中,self在右侧,和__add__相反。

      __call__可以拦截调用,用使用函数的方法使用类。对改写了__call__的类prod,实例化x = prod(2),x(3)可以直接使用。

      __del__是析构器,但在Python中很少使用析构方法。

      命名空间其实是普通的字典。

      

    第25章 类的设计

      无绑定类方法对象无self必须明确提供实例对象做第一个参数,绑定实例方法对象用self+函数对,不用传递实例。

      委托是指把对象包装在代理类中。

    #trace.py
    class wrapper:
    def __init__(self,object):
    self.wrapped
    = object
    def __getattr__(self,attrname):
    print 'Trace:',attrname
    return getattr(self.wrapped,attrname)

    >>>from trace import wrapper
    >>>x = wrapper([1,2,3])
    >>>x.append(4)
    Trace:append
    >>>x.wrapped
    [
    1,2,3,4]

      组合是一种技术,让控制器类嵌入和引导一群对象,并自行提供接口。

      (这一章主要内容是帮助读者从面向过程向面向对象过渡,而且比较浅显,在这方面作者推荐继续去读设计模式的书效果会更好,这里就不详细介绍了)

     

     第26章 类的高级主题

      伪私有属性:将开头两个下划线的变量名前再加上_类名。仍然不是真正的私有。

      新式类从内置类型创建子类,或者直接用object作为超类。3.0以后所有类自动成为新式类。钻石继承在新式类里从括号最右开始搜索,这与经典类正相反。为了解决继承不同类同名变量冲突,可以进行强制规定,如attr = B.attr。

      __slots__用来限制类的实例能有的合法属性集。

      内容属性使用拦截的方式来提供属性,但是它本身不是成员变量。类似于改写__getattr__,使用property()进行。

      静态方法类方法分别需要调用staticmethod和classmethod两个函数,前者调用不需要实例(实例调用时),后者把类传入类方法第一个参数。

      函数装饰器在def上一行用@标明,有点像包裹函数,@A @B @C后def f()相当于f=A(B(C(f)))。

     

    第27章 异常基础

      try/except可以用于捕捉异常并从异常中恢复,而try/final可以保证无论是否发生异常,终止行为都一定会进行。二者也可以合并使用(2.5版以后)。else在不发生异常时执行。except有几种分句形式(请参考原书)。

      rasie、assert用于触发异常。raise后不带参数表示重新引发当前异常(第28章)。

      with/as可以用作try/final的替代方案。as后面是with后表达式的赋值对象。

     

    第28章 异常对象

      字符串异常(myexc = "My exception string";raise myexc)已经在3.0以后消失,现在常用的是基于类的异常。类异常比字符串异常方便之处在于,可以在原始版本中用超类定义异常,在后续版本中使用子类来描述新的异常,这为版本维护提供了极大的方便。字符串异常的判断方式是is而不是==(常见陷阱,29章)。

     

    第29章 异常的设计

      嵌套的try,引发异常时except会回到先前进入但未离开的try,而finally不会停止传递。

      用try进行调试的方式,在错误发生时程序仍处于激活状态,可以进行其他的测试而不是重新开始:

    try:
    ...run program...
    except:
    import sys
    print 'uncaught!', sys.exc_info()[0], sys.exc_info()[1]
      #sys.exc_info有专门一小节讲解,无异常返回3个None
      #反之返回type value tracebck

     


    转载请注明本文地址:《Python学习手册》读书笔记
    展开全文
  • Python学习手册笔记

    2014-06-06 16:03:30
    之前为了编写一个svm分词的程序而简单学了下Python,觉得Python很好用,想深入并系统学习一下,了解一些机制,因此开始阅读《Python学习手册(第三版)》。如果只是想快速入门,我在这里推荐了几篇文章,有其他语言...
  • python附录

    2012-07-16 16:16:31
    运算符优先级:  运算符 运算  求值顺序   ( )  圆括号  最先求值。如果存在嵌套,则最内层先求值。如果几个圆括号相同优先(无嵌套),则按从左到右顺序求值 ... +或-
  • 关于Python语言本身的讲解全面详尽而又循序渐进不断重复,同时详述语言现象背后的机制和原理;除语言本身,还包含编程实践和设计以及高级主题。边看边写代码。不然看了会忘,也不会发现细节问题。边看边梳理总结。先...
  • 如果你想要编写高质量、高效的并且易于与其他语言和工具集成的代码,《Python学习手册:第4 版》将帮助你使用Python快速实现这一点,不管你是编程新手还是Python初学者。本书是易于掌握和自学的教程,根据作者P...
  • 为什么80%的码农都做不了架构师?>>> ...
  • Python 是一门简单易学且功能强大的编程语言。它拥有高效的高级数据结构,并且能够用简单而又高效的方式进行面向对象编程。Python 优雅的语法和动态类型,再结合它的解释性,使其在大多数平台的许多领域成为编写脚本...
  • 下载地址:网盘下载内容简介······本书是权威的Python语言参考指南,内容涉及核心Python语言和Python库的最重要部分。本书内容简洁扼要、可读性强,书中还包括了一些没有在Python官方文档或其他资料中出现过的...
  • 教育部考试中心近日发布了“关于全国计算机等级(NCRE)体系调整”的通知,决定自2018年3月起,在全国计算机二级考试中加入了“Python语言程序设计”科目。 9个月前,浙江省信息技术课程改革方案已经出台,Python...
  •  之前为了编写一个svm分词的程序而简单学了下Python,觉得Python很好用,想深入并系统学习一下,了解一些机制,因此开始阅读《Python学习手册(第三版)》。如果只是想快速入门,我在这里推荐了几篇文章,有其他语言...
1 2 3 4 5 ... 20
收藏数 1,649
精华内容 659
关键字:

python学习手册附录