下载安卓APP箭头
箭头给我发消息

客服QQ:3315713922
读书 > Office >Excel > Excel 2013高效办公 生产管理

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;“示例文件”包含了本书示例所涉及的源文件,供广大读者借鉴使用。

相关课程
目录

第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

......

热门图书
推荐新闻
技术文库
论坛推荐