Excel 2013高效办公 生产管理
- 综合评级：
- ★★★★★
- 定价：
- ￥59.00
- 作者：
- Excel Home
- 出版社：
- 人民邮电出版社
- 出版日期：
- 2016年3月
- 页数：
- 342
- 字数：
- 580000
- ISBN：
- 9787115413314
书籍介绍
本书以Excel在企业生产管理中的具体应用为主线，按照生产管理人员的日常工作特点谋篇布局，通过介绍典型应用案例，在讲解具体工作方法的同时，介绍相关的Excel 2013常用功能。本书分为3篇，共10章，分别介绍了订单管理、物料配制、环境管理、现场管理、绩效管理及人员评估、工艺管理、缺陷管理、设备效率管理、仓储管理以及出入货管理等内容。
本书附带一张光盘，包含“视频导读”、“循序渐进学Excel 2013”和“示例文件”3个部分的内容。“视频导读”特邀具有娴熟培训技巧的Excel Home技术高手，通过演示本书中多个代表性的案例，提供阅读与实操有效结合的视听途径，帮助读者在学习过程中举一反三，更好地掌握其他内容；“循序渐进学Excel 2013”是由Excel专家录制的Excel 2013入门学习视频，帮助读者快速、全面了解Excel；“示例文件”包含了本书示例所涉及的源文件，供广大读者借鉴使用。
作者简介
潘湘阳： 网名Stanleypan，ExcelHome版主，本书技术作者。长期在外企从事生产工艺流程管控工作，有10多年的Excel使用经验。擅长依据先进生产管理理论，利用Excel对企业内部分流程进行程序定制化，解决工作流程优化与和效率提升难题。
张建军： 网名lfspecter，ExcelHome版主，本书技术作者。长期在外企从事现场管理工作。熟悉TPM、TQM、Lean Production、DOE、FMEA、8D和SPC等管理工具的运用，善于利用Excel进行有针对性的计算与分析。
丁昌萍： 网名Alieena，江苏大学计算机学院讲师，本书执笔作者。精通数据统计与分析、网络信息管理与网站建设开发，在Excel函数与公式的应用方面有着丰富的经验。
周庆麟： 本丛书技术总策划，网名Kevin，全球微软有价值专家（MVP）之一，ExcelHome站长，多年来从事企业信息化管理工作，对Microsoft Office在销售、财务、物流和公司管理方面的应用有深入的研究，曾参与策划和编写了数十本Office技术畅销图书。同时也是一名技术顾问和培训讲师，有丰富的授课经验。
林树珊： 本丛书总监制，网名Susan，ExcelHome总版主，管理顾问，多年来从事企业经营管理工作，从1998年开始钟情于企业信息化以及关注Microsoft Office的发展，在企业经营管理以及Office应用方面拥有丰富的实战经验。
目录
第1部分 用特殊方法实现Python风格的类 ............................................... 1
第1章 __init__()方法 .............................................................. 5
1.1 隐式的基类——object ......................................................... 5
1.2 基类中的__init__()方法 ..................................................................... 6
1.3 在基类中实现__init__()方法 ............................................................. 7
1.4 使用__init__()方法创建常量清单 ..................................................... 8
1.5 通过工厂函数调用__init__() ............................................................. 9
1.5.1 错误的工厂设计和模糊的else语句 ......................................... 10
1.5.2 使用elif简化设计来获得一致性 ............................................. 11
1.5.3 使用映射和类来简化设计 ......................................................... 11
1.6 在每个子类中实现__init__()方法 ................................................... 14
1.7 简单的组合对象 ...................................................................... 16
1.7.1 封装集合类 ...................................................................... 16
1.7.2 扩展集合类 ...................................................................... 17
1.7.3 可适应更多需求的另一种设计 ................................................. 17
1.8 复合的组合对象 ...................................................................... 18
1.9 不带__init__()方法的无状态对象 ................................................... 19
1.10 一些其他的类定义 .......................................................................... 20
1.11 多策略的__init__()方法.................................................................. 22
1.11.1 更复杂的初始化方式 ............................................................... 23
1.11.2 静态函数的初始化 ................................................................... 24
1.12 更多的__init__()技术 ..................................................................... 24
1.12.1 带有类型验证的初始化 ........................................................... 26
1.12.2 初始化、封装和私有化 ........................................................... 28
1.13 总结........................................................................................ 29
第2章 与Python无缝集成——基本特殊方法 .................................... 30
2.1 __repr__()和__str__()方法................................................................ 30
2.1.1 非集合对象的__str__()和__repr__() ......................................... 31
2.1.2 集合中的__str__()和__repr__() ................................................. 32
2.2 __format__()方法 ..................................................................... 33
2.2.1 内嵌格式规范................................................................... 34
2.2.2 集合和委托格式规范 ................................................................. 35
2.3 __hash__()方法 ........................................................................ 35
2.3.1 决定哈希的对象 ......................................................................... 36
2.3.2 有关不可变对象和继承的默认行为 ......................................... 37
2.3.3 重载不可变对象 ......................................................................... 39
2.3.4 重载可变对象................................................................... 40
2.3.5 从可变的Hand类中生成一个不可变的Hand类 .............................. 41
2.4 __bool__()方法 ........................................................................ 43
2.5 __bytes__()方法 ....................................................................... 44
2.6 比较运算符方法 ...................................................................... 45
2.6.1 设计比较运算................................................................... 47
2.6.2 实现同一个类的对象比较 ......................................................... 48
2.6.3 实现不同类的对象比较 ............................................................. 49
2.6.4 硬总和、软总和及多态 ............................................................. 50
2.6.5 不同类比较的例子 ..................................................................... 51
2.7 __del__()方法 ........................................................................... 53
2.7.1 引用计数和对象销毁 ................................................................. 54
2.7.2 循环引用和垃圾回收 ................................................................. 55
2.7.3 循环引用和weakref模块 .......................................................... 56
2.7.4 __del__()和close()方法 ............................................................. 58
2.8 __new__()方法和不可变对象 .......................................................... 58
2.9 __new__()方法和元类型 .................................................................. 59
2.9.1 元类型示例1——有序的属性 .................................................. 60
2.9.2 元类型示例2——自引用 ........................... 61
2.10 总结........................................................................................ 64
第3章 属性访问、特性和修饰符 ................................................................ 66
3.1 属性的基本操作 ...................................................................... 66
3.2 创建特性 .................................................................................. 68
3.2.1 主动计算特性................................................................... 70
3.2.2 setter和deleter特性 .................................................................. 71
33.3 使用特殊方法完成属性访问 ........................................................... 72
3.3.1 使用__slots__创建不可变对象 ................................................. 73
3.3.2 使用tuple子类创建不可变对象 ............................................... 74
3.3.3 主动计算的属性 ......................................................................... 75
3.4 __getattribute__()方法 ....................................................................... 77
3.5 创建修饰符 .............................................................................. 78
3.5.1 使用非数据修饰符 ..................................................................... 80
3.5.2 使用数据修饰符 ......................................................................... 81
3.6 总结、设计要素和折中方案 ........................................................... 83
3.6.1 特性与属性对比 ......................................................................... 83
3.6.2 修饰符的设计................................................................... 84
3.6.3 展望 .................................................................................. 84
第4章 抽象基类设计的一致性 ........................................................... 85
4.1 抽象基类 .................................................................................. 85
4.2 基类和多态 .............................................................................. 87
4.3 可调用对象 .............................................................................. 88
4.4 容器和集合 .............................................................................. 88
4.5 数值类型 .................................................................................. 89
4.6 其他的一些抽象基类 ........................................................................ 90
4.6.1 迭代器的抽象基类 ..................................................................... 90
4.6.2 上下文和上下文管理器 ............................................................. 91
4.7 abc模块 .................................................................................... 92
4.8 总结、设计要素和折中方案 ........................................................... 93
第5章 可调用对象和上下文的使用 ............................................................ 95
5.1 使用ABC可调用对象来进行设计 ................................................ 95
5.2 提高性能 .................................................................................. 97
5.3 使用functools完成记忆化 .............................................................. 99
5.4 可调用API和复杂性 ..................................................................... 100
5.5 管理上下文和with语句 ................................................................ 102
5.5.1 使用小数上下文 ....................................................................... 103
5.5.2 其他上下文 .................................................................... 104
5.6 定义__enter__()和__exit__()方法 ................................................. 104
5.7 上下文管理器工厂 .......................................................................... 105
5.8 总结........................................................................................ 107
5.8.1 可调用对象的设计要素和折中方案 ..................................................... 108
5.8.2 上下文管理器的设计要素和折中方案 ................................................. 108
5.8.3 展望 ................................................................................ 109
第6章 创建容器和集合 ..................................................................... 110
6.1 集合的抽象基类 .................................................................... 110
6.2 特殊方法示例 ........................................................................ 111
6.3 使用标准库的扩展 .......................................................................... 112
6.3.1 namedtuple()函数 ..................................................................... 112
6.3.2 deque类 .......................................................................... 114
6.3.3 使用ChainMap ......................................................................... 115
6.3.4 OrderedDict集合 ...................................................................... 116
6.3.5 defaultdict子类 ........................................................................ 118
6.3.6 counter集合.................................................................... 119
6.4 创建新集合 ............................................................................ 120
6.5 定义一种新的序列 .......................................................................... 121
6.5.1 一个用于统计的list ................................................................. 122
6.5.2 主动计算和延迟计算 ............................................................... 122
6.5.3 使用__getitem__()、__setitem__()、__delitem__()和slice操作 ......... 125
6.5.4 实现__getitem__()、__setitem__()和__delitem__() ....................... 126
6.5.5 封装list和委托 ........................................................................ 127
6.5.6 用__iter__()创建迭代器 ........................................................... 129
6.6 创建一种新的映射 .......................................................................... 129
6.7 创建一种新的集合 .......................................................................... 131
6.7.1 一些设计原则........................................................................... 132
6.7.2 定义Tree类 ................................................................... 132
6.7.3 定义TreeNode类 ..................................................................... 133
6.7.4 演示二叉树集合 ....................................................................... 136
6.8 总结........................................................................................ 136
6.8.1 设计要素和折中方案 ............................................................... 137
6.8.2 展望 ................................................................................ 138
第7章 创建数值类型 ......................................................................... 139
7.1 numbers的抽象基类 ....................................................................... 139
7.1.1 决定使用哪种类型 ................................................................... 141
7.1.2 方法解析和运算符映射 ........................................................... 141
7.2 算术运算符的特殊方法 ................................................................. 142
7.3 创建一个数字类 .................................................................... 144
7.3.1 FixedPoint的初始化 ................................................................ 144
7.3.2 定义固定小数点位数的二进制算术运算符 ......................................... 146
7.3.3 定义FixedPoint一元算术运算符 ........................................... 148
7.3.4 实现FixedPoint反向运算符 ................................................... 148
7.3.5 实现FixedPoint比较运算符 ................................................... 150
7.4 计算一个数字的哈希值 ................................................................. 152
7.5 实现其他的特殊方法 ...................................................................... 153
7.6 原地运算符的优化 .......................................................................... 154
7.7 总结........................................................................................ 155
7.7.1 设计要素和折中方案 ............................................................... 155
7.7.2 展望 ................................................................................ 155
第8章 装饰器和mixin——横切方面 ...................................... 156
8.1 类和描述 ................................................................................ 156
8.1.1 创建函数 ........................................................................ 157
8.1.2 创建类 ............................................................................ 158
8.1.3 一些类设计原则 ....................................................................... 159
8.1.4 面向方面编程........................................................................... 159
8.2 使用内置的装饰器 .......................................................................... 160
8.3 使用标准库中的mixin类 .............................................................. 161
8.3.1 使用上下文管理器的mixin类 ............................................... 162
8.3.2 禁用类的一个功能 ................................................................... 163
8.4 写一个简单的函数装饰器 ............................................................. 164
8.5 带参数的装饰器 .................................................................... 166
8.6 创建方法函数装饰器 ...................................................................... 167
8.7 创建类装饰器 ........................................................................ 169
8.8 向类中添加方法函数 .............................................................. 170
8.9 将装饰器用于安全性 .............................................................. 172
8.10 总结...................................................................................... 173
8.10.1 设计要素和折中方案 .......................................................... 173
8.10.2 展望 .............................................................................. 174
第2部分 持久化和序列化 ............................................................... 175
第9章 序列化和保存——JSON、YAML、Pickle、CSV和XML ........................................ 178
9.1 持久化、类、状态以及数据表示 ............................................... 179
9.2 文件系统和网络的考虑 ............................................................. 180
9.3 定义用于持久化的类 ................................................................ 181
9.4 使用JSON进行转储和加载........................................................ 184
9.4.1 在类中支持JSON ................................................................... 185
9.4.2 自定义JSON编码 ................................................................... 186
9.4.3 自定义JSON解码 ................................................................... 188
9.4.4 安全性和eval() ...................................................................... 189
9.4.5 重构编码函数......................................................................... 189
9.4.6 日期字符串的标准化 ............................................................. 190
9.4.7 将JSON写入文件 ................................................................... 191
9.5 使用YAML进行转储和加载 ........................................................ 192
9.5.1 YAML文件的格式化 .............................................................. 193
9.5.2 扩展YAML的表示 ................................................................. 194
9.5.3 安全性与安全加载 ................................................................. 196
9.6 使用pickle进行转储和加载..................................................... 196
9.6.1 针对可靠的pickle处理进行类设计 ........................................... 197
9.6.2 安全性和全局性问题 ............................................................... 199
9.7 转储和加载CSV ................................................................... 200
9.7.1 将简单的序列转储为CSV ...................................................... 200
9.7.2 从CSV文件中加载简单的序列 ............................................. 201
9.7.3 处理集合与复杂的类 ............................................................... 202
9.7.4 在一个CSV文件中转储并从多类型的行中加载数据 ....................... 203
9.7.5 使用迭代器筛选CSV中的行 ................................................. 204
9.7.6 从CSV文件中转储和加载连接的行 .............................................. 205
9.8 使用XML转储和加载 ................................................................... 207
9.8.1 使用字符串模板转储对象 ....................................................... 208
9.8.2 使用xml.etree.ElementTree转储对象 ............................................ 209
9.8.3 加载XML文档 ..................................................................... 210
9.9 总结..................................................................................... 211
9.9.1 设计要素和折中方案 ............................................................... 211
9.9.2 模式演化 ........................................................................ 212
9.9.3 展望 ................................................................................ 213
第10章 用Shelve保存和获取对象 .................................................... 214
10.1 分析持久化对象用例 .............................................................. 215
10.2 创建shelf.............................................................................. 216
10.3 设计适于存储的对象 ................................................................... 217
10.3.1 为我们的对象设计键 ............................................................. 217
10.3.2 为对象生成代理键 ................................................................. 218
10.3.3 设计一个带有简单键的类 ..................................................... 218
10.3.4 为容器和集合设计类 ............................................................. 220
10.3.5 用外键引用对象 ..................................................................... 220
10.3.6 为复杂对象设计CRUD操作 ................................................ 222
10.4 搜索、扫描和查询 ........................................................................ 223
10.5 为shelve设计数据访问层 ........................................................... 224
10.6 用索引提高性能 ............................................................................ 227
10.7 有关更多的索引维护工作 ........................................................... 230
10.8 用writeback代替更新索引 ......................................................... 232
10.9 总结...................................................................................... 233
10.9.1 设计要素和折中方案 ............................................................. 233
10.9.2 应用软件层................................................................... 234
10.9.3 展望 .............................................................................. 234
第11章 用SQLite保存和获取对象 ......................................................... 235
11.1 SQL数据库、持久化和对象 ....................................................... 2351
1.1.1 SQL数据模型—行和表 ................................................. 236
11.1.2 使用SQL的DML语句完成CRUD .............................................. 238
11.1.3 使用SQL中SELECT语句执行查询 ............................................ 240
11.1.4 SQL事务和ACID属性 ........................................................ 240
11.1.5 设计数据库中的主键和外键 ................................................. 242
11.2 使用SQL处理程序中的数据...................................................... 2431
1.3 从Python对象到SQLite BLOB列的映射 ........................................ 245
11.4 手动完成从Python对象到数据库中行的映射 ................................... 247
11.4.1 为SQLite设计一个访问层 ................................................... 248
11.4.2 实现容器的关系 ............................................................... 251
11.5 使用索引提高性能 ............................................................... 252
11.6 添加ORM层 ....................................................................... 252
11.6.1 设计ORM友好的类 .............................................................. 253
11.6.2 使用ORM层创建模型 .......................................................... 255
11.6.3 使用ORM层操作对象 .......................................................... 256
11.7 通过指定标签字符串查询文章对象 ......................................... 258
11.8 通过创建索引提高性能............................................................. 259
11.9 总结...................................................................................... 261
11.9.1 设计要素和折中方案 ............................................................. 261
11.9.2 映射的方法 ................................................................... 261
11.9.3 键和键的设计 ..................................................................... 262
11.9.4 应用软件层 ................................................................... 262
11.9.5 展望 ............................................................................... 262
第12章 传输和共享对象 ............................................................... 263
12.1 类、状态和表示 ..................................................................... 263
12.2 用HTTP和REST传输对象 ....................................................... 264
12.2.1 用REST实现CRUD操作 .................................................... 264
12.2.2 实现非CRUD操作 ............................................................... 265
12.2.3 REST协议和ACID ............................................................... 266
12.2.4 选择一种表示方法—JSON、XML或者YAML .................... 266
12.3 实现一个REST服务器——WSGI和mod_wsgi .................................................. 267
12.3.1 创建简单的REST应用程序和服务器 ............................................ 267
12.3.2 实现REST客户端 ................................................................. 270
12.3.3 演示RESTful服务并创建单元测试 ............................................... 271
12.4 使用可回调类创建WSGI应用程序 .......................................... 272
12.4.1 设计RESTful对象标识符 .................................................... 274
12.4.2 多层REST服务 ..................................................................... 275
12.4.3 创建roulette服务器 .............................................................. 279
12.4.4 创建roulette客户端 .............................................................. 280
12.5 创建安全的REST服务 ................................................................ 281
12.6 用web应用程序框架实现REST ............................................... 284
12.7 用消息队列传输对象 ................................................................ 285
......
最新图书
￥139.00
￥10.00
￥298.00
￥168.00
￥168.00
