A. ...与 Python 作为后端服务的编程语言各有什么优劣
Node.js相优于Python的地方：
快：这个快有两方面，第一是V8引擎快，第二是异步执行，Node.js
功能上是一个基于V8引擎的异步网络和IO Library，和Python的Twisted很像，不同的是Node.js的event
loop是很底层的深入在语言中的，可以想象成整个文件在执行的时候就在一个很大的event loop里；
npm：npm可以说是用起来最顺手的package management了，npm作为Node.js的官方package management，汇集了整个社区最集中的资源；不像Python经历过easy_install和pip，还有2to3的问题；
Windows支持：Node.js有微软的加持，Windows基本被视为一等公民来支持，libuv已经可以很好的做到统一跨平台的API；而Python虽然也对Windows有官方的支持，但是总感觉是二等公民，时不时出些问题。
Python优于Node.js的地方：
语
言：就单纯从语言的角度来说，Python写起来要比Javascript舒服很多；Javascript
设计本身有许多缺陷，毕竟当时设计的时候只是作为在浏览器中做一些简单任务的script，所以代码一旦庞大，维护还是有困难（不过Node.js的
mole很大的改善了这个问题），不过用Coffeescript可以很大的改善Javascript，几乎可以和Python等同；
成
熟：成熟包括语言本身已经成熟，还有Framework和ecosystem也很庞大。Node.js的绝大多数framework都很新，有的API一
直在变，有的感觉已经不在维护，总之没有一个像Django那种百足之虫感觉的framework。Python的主流ORM
sqlalchemy也很成熟。
Python 和 Node.js 很难分高下的地方：
异
步Style：Node.js的异步Style是CPS，也就是层层callback，基于event，和浏览器中的Javascript很像。CPS好
处是让熟悉浏览器Javascript的人能很快上手，学习难度也不大。缺点是逻辑一复杂，就变得很难维护，基本上需要通过async.js这种
library，或者用promise。Python的异步除了和Node.js很像的Twisted之外，也有基于coroutine的
gevent，coroutine让异步代码维护起来更容易，不过学习曲线陡；
应用场景：如果是一个CRUD的app，
那么想都不想直接是Python，Node.js本身不擅长CRUD的app（绝大多数Node.js都是直接裸在外面的，而不是有一个Nginx在前
面，否则websocket就不能用了，不过新版nginx开始支持websocket），代码又不好维护，而Python的WSGI很适合，成熟的
stack也有很多。如果更偏向于real-time，比如一个chat room，那么Node.js实现更容易。这两个应用场景还是有差别的。
来源于知乎：https://www.hu.com/question/20961574
B. SQLAlchemy 中的 Session、sessionmaker、scoped_session
目录
Session 其实 就是一个会话, 可以和数据库打交道的一个会话
在一般的意义上， 会话建立与数据库的所有对话，并为你在其生命周期中加载或关联的所有对象表示一个“等待区”。他提供了一个入口点获得查询对象， 向数据库发送查询，使用会话对象的当前数据库连接， 将结果行填充在对象中， 然后存储在会话中， 在这种结构中称为身份映射 – 这种数据结构维护了每一个副本的唯一， 这种唯一意味着一个对象只能有一个特殊的唯一主键。
会话以基本无状态的形式开始，一旦发出查询或其他对象被持久化，它就会从一个引擎申请连接资源，该引擎要么与会话本身相关联，要么与正在操作的映射对象相关联。此连接标识正在进行的事务， 在会话提交或回滚其挂起状态之前，该事务一直有效。
会话中维护的所有变化的对象都会被跟踪 - 在再次查询数据库或提交当前事务之前， 它将刷新对数据库的所有更改， 这被称为工作模式单元。
在使用会话时候，最重要的是要注意与它相关联的对象是会话所持有的事务的代理对象 - 为了保持同步，有各种各样的事件会导致对象重新访问数据库。可能从会话中分离对象并继续使用他们，尽管这种做法有其局限性。但是通常来说，当你希望再次使用分离的对象时候，你会将他们与另一个会话重新关联起来， 以便他们能够恢复表示数据库状态的正常任务。
可能会将这里的session与http中的session搞混，需要注意的是，它有点用作缓存，因为它实现了 身份映射 模式，并存储了键入其主键的对象。但是，它不执行任何类型的查询缓存。 此外，默认情况下，Session使用弱引用存储对象实例。这也违背了将Session用作缓存的目的。关于session强应用下次再讨论。
1. session创建和管理数据库连接的会话 2. model object 通过session对象访问数据库，并把访问到的数据以 Identity Map 的方式，映射到Model object 中
1. session在刚被创建的时候，还没有和任何model object 绑定，可认为是无状态的 2. session 接受到query查询语句, 执行的结果或保持或者关联到session中 3. 任意数量的model object被创建，并绑定到session中，session会管理这些对象 4. 一旦session 里面的objects 有变化，那可是要commit/rollback提交或者放弃changs
一般来说，session在需要访问数据库的时候创建，在session访问数据库的时候，准确来说，应该是“add/ update / delete ”数据库的时候，会开启 database transaction 。 假设没有修改autocommit的默认值( False ), 那么， database transaction 一直会保持，只有等到 session 发生rolled back、committed、或者closed的时候才结束，一般建议，当 database transaction 结束的时候，同时 close session ,以保证，每次发起请求，都会创建一个新的 session 特别是对web应用来说，发起一个请求，若请求使用到 Session 访问数据库，则创建 session ，处理完这个请求后，关闭 session
Session 是一个直接实例化的常规的Python 类。然而， 为了标准会会话的配置和获取方式， sessionmaker 类通常用于创建顶级会话配置， 然后可以在整个应用程序中使用它， 就不需要重复配置参数。
下面是sessionmaker 的使用方式
在上面，该 sessionmaker()创建了一个工厂类，在创建这个工厂类时我们配置了参数绑定了引擎。将其赋值给Session。每次实例化Session都会创建一个绑定了引擎的Session。 这样这个session在访问数据库时都会通过这个绑定好的引擎来获取连接资源当你编写应用程序时， 请将sessionmaker 工厂放在全局级别，视作应用程序配置的一部分。例如：应用程序包中有三个.py文件，您可以将该sessionmaker行放在__init__.py文件中; 在其他模块“from mypackage import Session”。这样，所有的Session()的配置都由该配置中心控制。
直接只用 create_engine 时，就会创建一个带连接池的引擎：
创建一个session，连接池会分配一个connection。当session在使用后显示地调用 session.close()，也不能把这个连接关闭，而是由由QueuePool连接池管理并复用连接。
确保 session 在使用完成后用 session.close、session.commit 或 session.rollback 把连接还回 pool，这是一个必须在意的习惯。
关于SQLAlchemy 数据库连接池：
session 和 connection 不是相同的东西， session 使用连接来操作数据库，一旦任务完成 session 会将数据库 connection 交还给 pool。 在使用 create_engine 创建引擎时，如果默认不指定连接池设置的话，一般情况下，SQLAlchemy 会使用一个 QueuePool 绑定在新创建的引擎上。并附上合适的连接池参数
create_engine() 函数和连接池相关的参数有：
SQLAlchemy不使用连接池：在创建引擎时指定参数 poolclass=NullPool 即禁用了SQLAlchemy提供的数据库连接池。SQLAlchemy 就会在执行 session.close() 后立刻断开数据库连接。当然，如果没有被调用 session.close()，则数据库连接不会被断开，直到程序终止。
关于 SQLAlchemy 的 engine ,这里有一篇文章写的很好： http://sunnyingit.github.io/book/section_python/SQLalchemy-engine.html
session不是线程安全的，在多线程的环境中，默认情况下，多个线程将会共享同一个session。试想一下，假设A线程正在使用session处理数据库，B线程已经执行完成，把session给close了，那么此时A在使用session就会报错，怎么避免这个问题？
1 . 可以考虑在这些线程之间共享Session及其对象。但是应用程序需要确保实现正确的锁定方案，以便多个线程不会同时访问Session或其状态。SQLAlchemy 中的 scoped_session 就可以证线程安全，下面会有讨论。 2 . 为每个并发线程维护一个会话，而不是将对象从一个Session复制到另一个Session，通常使用Session.merge()方法将对象的状态复制到一个不同Session的新的本地对象中。
上面简单介绍了sessionmaker的作用，下面开始探讨 scoped_session 对创建 Session 的影响。现在先探讨单线程情况。
结论：
通过 sessionmaker 工厂创建了两个 Session ，而且可以看到 s1 s2 是两个不同的 Session 。 在 s1 添加 person 后，继续使用 s2 添加 person 报错. 说 person 这个对象 已经和 另一个 Session 关联一起来了, 所以再次关联另一个 Session 就会报错。
即在上面代码的 s1.add(person) 之后， s1.commit() ,然后再 s2.add(persion)这里就没帖代码了。
结论：
即使在 s1 提交之后， s2 再去添加 person 也会发生错误,但 s1 的提交是成功了的，数据 person 已经存放在数据库了。 当 s1 添加 person 并提交，然后关闭 s1 , s2 再去添加并提交 person 数据库,这不会报错，但是数据库也不会出现两条 person 数据。
结论：
s1 关闭之后， s2 再去添加提交同一个对象，不会报错，但是数据库值有一条 person 数据。
结论：
当然， s1 , s2 添加提交不同的对象，不会出错。在数据库成功新增数据。
以上说明：
一个对象一旦被一个 Session 添加，除非关闭这个 Session ，不然其他的 Session 无法添加这个对象。 一个 Session 添加并提交一个对象，然后关闭该 Session ，其他的 Session 可以添加并提交这个对象，但是数据库并不会有这条数据。
结论：
可以看到，通过 scoped_session再去创建 Session ，返回的是同一个 Session 。 scoped_session类似单例模式，当我们调用使用的时候，会先在Registry里找找之前是否已经创建Session，未创建则创建 Session ，已创建则直接返回。
这里探讨在多线程下使用 scoped_session 与不使用 scoped_session 的情况
当不使用 scoped_session 时，也分两种情况，是否创建全局性 Session
结论：
每个线程下的 Session 都是不同的 Session 数据库成功新增了线程3提交的数据，其他的线程中的数据并没有提交到数据库中去。
结论：
全部线程下的 Session 都时同一个 Session 每个线程下的数据都被提交到了数据库
结论：
每个线程下的 Session 都不相同 只有线程3下的数据被提交到了数据库
结论：
每个线程下的 Session 是同一个 Session 每个线程下的数据都没提交到了数据库
以上说明：
在同一个线程中，有 scoped_session 的时候，返回的是同一个 Session 对象。 在多线程下，即使通过 scoped_session 创建Session，每个线程下的 Session 都是不一样的，每个线程都有一个属于自己的 Session 对象，这个对象只在本线程下共享。 scoped_session 只有在单线程下才能发挥其作用。在多线程下显得没有什么作用。
C. 如何在Ubuntu14.04的Docker容器中运行OpenVPN
本文将指导你如何搭建私有docker registry，并确保其安全性。在本教程的最后，你将亲身体验上传自制的docker镜像到私有registry，并在不同的机器上安全的将该其拉去下来。
本教程不包含如何容器化应用服务的内容，而是旨在引导你去创建registry来存储你要部署的服务资源。如果你想要docker的入门教程，也许这儿可以帮到你。
基于Ubuntu14.04系统的单registry和单客户机模式，本教程已经通过测试，也许在其他基于debian的发布上仍可以运行。
docker概念
如果在此之前你尚未接触过docker，这需要花费你几分钟的时间来熟悉docker的关键概念。如果你对docker已得心应手，只是想了解如何构建私有registry的话，那么，你可以直接进入下一小节。
对于一个新手该如何使用docker，不妨试试这里优秀的docker笔记。
docker的核心就是要对应用以及应用的依赖与操作系统分离。为了达到上述目的，docker采用容器与镜像机制。一个docker镜像基本上是一个文件系统的模板。当你通过docker run命令运行一个docker镜像时，该文件系统的一个实例即被激活，并且运行在系统内的docker容器之中。默认的，该容器无法触及原始镜像以及docker本身所运行在的主机的文件系统。这是一个独立的环境。
对容器所做的任何改动都将保存在容器本身之内，并不会影响原始的镜像。如果想保留这些改动，那么，可以通过docker commit命令将容器保存为镜像。这意味你可以通过原有的容器来衍生出新的容器，而不会对原始容器（或镜像）造成任何影响。如果你熟悉git，那么你会觉得该流程十分眼熟：从任意的容器上去创建新的分支（这里，分支的意思即为docker中的镜像）。运行镜像类似于执行git checkout操作。
更进一步形容，运行私有docker registry，就好比为docker镜像运行私有git仓库。
第一步——安装必要的软件
在docker registry服务器上，应当创建一个拥有sudo权限的用户（如果可以，在客户机上也如此）。
docker registry软件是一款python应用，因此为了使其能够运行起来，需要安装python开发环境以及必要的库：
sudo apt-get updatesudo apt-get -y install build-essential python-dev libevent-dev python-pip liblzma-dev
第二步——安装并配置docker registry
为了安装最新的稳定的docker registry发行版（作者撰文时为0.7.3，译者译时为0.9.1），我们将使用python包管理工具pip：
sudo pip install docker-registry
docker-registry需要配置文件。
默认地，pip将该配置文件放置在相当偏僻的地方，因系统中python的安装位置而异。因此，为了找到该路径，我们将尝试运行registry，以查看相关的输出：
gunicorn --access-logfile - --debug -k gevent -b 0.0.0.0:5000 -w 1 docker_registry.wsgi:application
由于配置文件不在正确的位置，上述尝试将会以失败而告终，并输出一条包含FileNotFoundError错误消息，如下所示[在某些版本中，无下述信息输出，译者注]：
FileNotFoundError: Heads-up! File is missing: /usr/local/lib/python2.7/dist-packages/docker_registry/lib/../../config/config.yml
registry在同样的路径上包含一个示例配置文件，该文件名为config_sample.yml，因此，我们可以通过上述给出的路径名来定位示例配置文件。
从错误消息中复制路径信息（此时为/usr/local/lib/python2.7/dist-packages/docker_registry/lib/../../config/config.yml），然后，将config.yml部分去除，这样我们可以切换到该路径下。
cd /usr/local/lib/python2.7/dist-packages/docker_registry/lib/../../config/
将config_sample.yml文件的内容复制到config.yml中：
sudo cp config_sample.yml config.yml
默认情况下，docker的数据文件存放在/tmp文件夹下，但是在许多的类Linux系统中，系统重启时该文件夹被清空，这并不是我们所希望的。那么，我们创建一个永久性的文件夹来存储数据：
sudo mkdir /var/docker-registry
好的，下面我们配置config.yml文件，将对文件夹/tmp的引用更改为/var/docker-registry。首先，首先找到以sqlalchemy_index_database为首的靠近文件首部的一行：
sqlalchemy_index_database:_env:SQLALCHEMY_INDEX_DATABASE:sqlite:////tmp/docker-registry.db
将其更改指向/var/docker-registry，如下所示：
sqlalchemy_index_database:_env:SQLALCHEMY_INDEX_DATABASE:sqlite:////var/docker-registry/docker-registry.db
向下一点，到local:部分，重复上述操作，更改如下内容：
local: &localstorage: localstorage_path: _env:STORAGE_PATH:/tmp/registry
为：
local: &localstorage: localstorage_path: _env:STORAGE_PATH:/var/docker-registry/registry
样例配置文件中的其他默认值均无需修改。一目十行即可。然而，如果你想要做一些复杂的配置，诸如采用扩展存储装置来存储docker数据，那么该文件正具有此功能。当然，这已超出本教程的范围，你可以查看docker-registry文档以获取更多的帮助。
既然配置文件已置于正确的位置，那么再一次尝试来测试docker registry服务器：
gunicorn --access-logfile - --debug -k gevent -b 0.0.0.0:5000 -w 1 docker_registry.wsgi:application
你会看到如下的输出：
2014-07-27 07:12:24 [29344] [INFO] Starting gunicorn 18.02014-07-27 07:12:24 [29344] [INFO] Listening at: http://0.0.0.0:5000 (29344)2014-07-27 07:12:24 [29344] [INFO] Using worker: gevent2014-07-27 07:12:24 [29349] [INFO] Booting worker with pid: 293492014-07-27 07:12:24,807 DEBUG: Will return docker-registry.drivers.file.Storage
棒极了！现在我们已经拥有一个运行着的docker registry。下面执行Ctrl+C终止该程序。
到目前为止，docker registry并不是那么有用。它并不会自行启动除非我们执行上述gunicorn命令。另外，docker registry不没有引入任何的内置的认证机制，因此，其当前状态下是不安全并且对外部完全开放的。
第三步——以服务的形式启动docker registry
通过创建Upstart脚本，设置docker registry在系统的启动程序中开始运行。
首先，创建日志文件目录：
sudo mkdir -p /var/log/docker-registry
然后，用一款你拿手的文本编辑器来创建Upstart脚本：
sudo nano /etc/init/docker-registry.conf
将如下内容写入上述脚本中：
description "Docker Registry"start on runlevel [2345]stop on runlevel [016]respawnrespawn limit 10 5script exec gunicorn --access-logfile /var/log/docker-registry/access.log --error-logfile /var/log/docker-registry/server.log -k gevent --max-requests 100 --graceful-timeout 3600 -t 3600 -b localhost:5000 -w 8 docker_registry.wsgi:applicationend script
更多关于Upstart脚本的内容，请阅读该教程。
此时，执行如下命令：
sudo service docker-registry start
将看到下面的输出：
docker-registry start/running, process 25303
当然，你也可以通过运行下面的命令查看server.log日志文件，验证docker-registry服务是否正在运行：
tail /var/log/docker-registry/server.log
如果一切正常的话，你会看到像之前执行gunicorn命令时输出的文本信息。
既然docker-registry服务器已在后台运行，那么下面我们来配置Nginx，以使registry更加安全。
D. 学会Python之后更适合做哪方面的工作
下面我们来说一下Python具体的工作岗位以及其岗位要求：
Python后台开发工程师：主要是负责搭建和改进平台产品的后台，并与前端开发工程师相互配合完成整体产品的开发工作。要求工程师具备至少一门Python Web开发框架（Tornado、Django、Flask等），了解并熟悉MySQL/Redis/MongoDB。还要熟悉分布式、微服务、高性能Web服务的开发。
Python爬虫开发工程师：爬虫开发工程师并非我们预想的那样，只是负责为公司爬取相对应的数据内容。爬虫开发工程师主要负责对传统网页、SNS及微博等各种网站信息高效采集与正确解析，然后对用户数据进行整理分析，参与建模的构建，总结分析不同网站、网页的结构特点及规律，负责爬虫架构设计和研发，参与爬虫核心算法和策略优化研究。需要开发工程师熟悉了解robot规则、selenium、mitmproxy、pymouse等内容。当然作为爬虫开发工程师一定要有一定的职业情况，所有工作都需要在合理合法的需求下进行。
Python全栈开发工程师：是指可以使用Python相关工具，独立完成网站开发，称之为全栈开发。全栈开发工程师需要掌握非常多的技能，包括：项目管理、前后端开发、界面设计、产品设计、数据库开发、多端产品等等。
自动化运维工程师：是在基本的运维工作的基础上，实现运维工作的自动化，并且对自动化程序进行优化提升。需要从业者在掌握基本的运营工作的前提下，掌握Python中的IPy、Ansible、Saltstack等常用模块。
自动化测试工程师：首要要完成测试的基本工作，包括测试计划、测试用例、黑盒测试、性能测试等等。其次要是完成产品的自动化测试的部署以及维护工作，并且不断尝试新的方法，新的工具，以提高测试的效率。需要掌握Python以及selenium相关的技能。
数据分析师：指的是不同行业中，专门从事行业数据搜集、整理、分析，并依据数据做出行业研究、评估和预测的专业人员。需要从业者了解行业相关业务知识、相关管理工作、掌握足够的数据分析方法、了解数据分析工具使用、能够完成数据分析建模等，工作内容偏重于分析，同样也要掌握一定的开发能力，例如R语言和Python语言。
数据分析开发工程师：根据数据分析师的建模完成数据相关的开发工作，搭建仓库、完成数据存储、数据处理、计算处理以及报表开发等工作。需要从业者熟练应用数据库、数据建模开发、Python相关数据科学知识等技能。
人工智能开发工程师：根据企业人工智能AI相关的开发需求，完成相应产品或者功能开发。需要从业者掌握充分的数据理论基础、Python开发基础、机器学习理论与实践、深度学习理论与实践、自然语言处理等一系列相关的开发技能。
Python游戏开发工程师：主要负责游戏服务端的逻辑开发。需要从业者掌握Python各种性能优化方法、soket网络编程知识、运维相关基础知识、以及Python相关的游戏开发库与框架。此外还可以将Python开发相关工作按照岗位晋升分为初级Python开发工程师、中级Python开发工程师、高级Python开发工程师、项目经理、架构师、CTO等。主要是根据从业者工作年限，在某个就业方向的工作经验以及解决问题的能力进行定位。
无论是哪个就业方向，扎实的学习好Python相关知识是重中之重，在互联网行业，无论是大厂还是创业创新的公司，招聘人才的最核心要求是技术能力，只有自己的能力和岗位匹配的时候，才能获得更多的工作机会。
E. 后端编程Python3-数据库编程
对大多数软件开发者而言，术语数据库通常是指RDBMS（关系数据库管理系统）, 这些系统使用表格（类似于电子表格的网格），其中行表示记录，列表示记录的字段。表格及其中存放的数据是使用SQL （结构化査询语言）编写的语句来创建并操纵的。Python提供了用于操纵SQL数据库的API（应用程序接口），通常与作为标准的SQLite 3数据库一起发布。
另一种数据库是DBM （数据库管理器），其中存放任意数量的键-值项。Python 的标准库提供了几种DBM的接口，包括某些特定于UNIX平台的。DBM的工作方式 与Python中的字典类似，区别在于DBM通常存放于磁盘上而不是内存中，并且其键与值总是bytes对象，并可能受到长度限制。本章第一节中讲解的shelve模块提供了方便的DBM接口，允许我们使用字符串作为键，使用任意（picklable）对象作为值。
如果可用的 DBM 与 SQLite 数据库不够充分，Python Package Index, pypi.python.org/pypi中提供了大量数据库相关的包，包括bsddb DBM ("Berkeley DB")，对象-关系映射器，比如SQLAlchemy （www.sqlalchemy.org）,以及流行的客户端/服务器数据的接口，比如 DB2、Informix、Ingres、MySQL、ODBC 以及 PostgreSQL。
本章中，我们将实现某程序的两个版本，该程序用于维护一个DVD列表，并追踪每个DVD的标题、发行年份、时间长度以及发行者。该程序的第一版使用DBM （通过shelve模块）存放其数据，第二版则使用SQLite数据库。两个程序都可以加载与保存简单的XML格式，这使得从某个程序导出DVD数据并将其导入到其他程序成为可能。与DBM版相比，基于SQL的程序提供了更多一些的功能，并且其数据设计也稍干净一些。
12.1 DBM数据库
shelve模块为DBM提供了一个wrapper,借助于此，我们在与DBM交互时，可以将其看做一个字典，这里是假定我们只使用字符串键与picklable值，实际处理时， shelve模块会将键与值转换为bytes对象(或者反过来)。
由于shelve模块使用的是底层的DBM,因此，如果其他计算机上没有同样的DBM,那么在某台计算机上保存的DBM文件在其他机器上无法读取是可能的。为解决这一问题，常见的解决方案是对那些必须在机器之间可传输的文件提供XML导入与导出功能，这也是我们在本节的DVD程序dvds-dbm.py中所做的。
对键，我们使用DVD的标题；对值，则使用元组，其中存放发行者、发行年份以及时间。借助于shelve模块，我们不需要进行任何数据转换，并可以把DBM对象当做一个字典进行处理。
程序在结构上类似于我们前面看到的那种菜单驱动型的程序，因此，这里主要展示的是与DBM程序设计相关的那部分。下面给出的是程序main()函数中的一部分， 忽略了其中菜单处理的部分代码。
db = None
try:
db = shelve.open(filename, protocol=pickle.HIGHEST_PROTOCOL)
finally:
if db is not None:
db.dose()
这里我们已打开(如果不存在就创建)指定的DBM文件，以便于对其进行读写操作。每一项的值使用指定的pickle协议保存为一个pickle,现有的项可以被读取， 即便是使用更底层的协议保存的，因为Python可以计算出用于读取pickle的正确协议。最后，DBM被关闭——其作用是清除DBM的内部缓存，并确保磁盘文件可以反映出已作的任何改变，此外，文件也需要关闭。
该程序提供了用于添加、编辑、列出、移除、导入、导出DVD数据的相应选项。除添加外，我们将忽略大部分用户接口代码，同样是因为已经在其他上下文中进行了展示。
def add_dvd(db):
title = Console.get_string("Title", "title")
if not title:
return
director = Console.get_string("Director", "director")
if not director:
return
year = Console.get_integer("Year", "year",minimum=1896,
maximum=datetime,date.today().year)
ration = Console.get_integer("Duration (minutes)", "minutes“, minimum=0, maximum=60*48)
db[title] = (director, year, ration)
db.sync()
像程序菜单调用的所有函数一样，这一函数也以DBM对象(db)作为其唯一参数。该函数的大部分工作都是获取DVD的详细资料，在倒数第二行，我们将键-值项存储在DBM文件中,DVD的标题作为键，发行者、年份以及时间(由shelve模块pickled在一起)作为值。
为与Python通常的一致性同步，DBM提供了与字典一样的API，因此，除了 shelve.open() 函数(前面已展示)与shelve.Shelf.sync()方法(该方法用于清除shelve的内部缓存，并对磁盘上文件的数据与所做的改变进行同步——这里就是添加一个新项)，我们不需要学习任何新语法。
def edit_dvd(db):
old_title = find_dvd(db, "edit")
if old_title is None:
return
title = Console.get.string("Title", "title", old_title)
if not title:
return
director, year, ration = db[old_title]
...
db[title]= (director, year, ration)
if title != old_title:
del db[old_title]
db.sync()
为对某个DVD进行编辑，用户必须首先选择要操作的DVD,也就是获取DVD 的标题，因为标题用作键，值则用于存放其他相关数据。由于必要的功能在其他场合 (比如移除DVD)也需要使用，因此我们将其实现在一个单独的find_dvd()函数中，稍后将査看该函数。如果找到了该DVD,我们就获取用户所做的改变，并使用现有值作为默认值，以便提高交互的速度。(对于这一函数，我们忽略了大部分用户接口代码， 因为其与添加DVD时几乎是相同的。)最后，我们保存数据，就像添加时所做的一样。如果标题未作改变，就重写相关联的值；如果标题已改变，就创建一个新的键-值对， 并且需要删除原始项。
def find_dvd(db, message):
message = "(Start of) title to " + message
while True:
matches =[]
start = Console.get_string(message, "title")
if not start:
return None
for title in db:
if title.lower().startswith(start.lower()):
matches.append(title)
if len(matches) == 0:
print("There are no dvds starting with", start)
continue
elif len(matches) == 1:
return matches[0]
elif len(matches) > DISPLAY_LIMIT:
print("Too many dvds start with {0}; try entering more of the title".format(start)
continue
else:
matches = sorted(matches, key=str.lower)
for i, match in enumerate(matches):
print("{0}: {1}".format(i+1, match))
which = Console.get_integer("Number (or 0 to cancel)",
"number", minimum=1, maximum=len(matches))
return matches[which - 1] if which != 0 else None
为尽可能快而容易地发现某个DVD,我们需要用户只输入其标题的一个或头几个字符。在具备了标题的起始字符后，我们在DBM中迭代并创建一个匹配列表。如果只有一个匹配项，就返回该项；如果有几个匹配项(但少于DISPLAY_LIMIT, 一个在程序中其他地方设置的整数)，就以大小写不敏感的顺序展示所有这些匹配项，并为每一项设置一个编号，以便用户可以只输入编号就可以选择某个标题。(Console.get_integer()函数可以接受0,即便最小值大于0,以便0可以用作一个删除值。通过使用参数allow_zero=False, 可以禁止这种行为。我们不能使用Enter键，也就是说，没有什么意味着取消，因为什么也不输入意味着接受默认值。)
def list_dvds(db):
start =”"
if len(db)> DISPLAY.LIMIT:
start = Console.get_string(“List those starting with [Enter=all]”， "start”)
print()
for title in sorted(db, key=str.lower):
if not start or title.Iower().startswith(start.lower()):
director, year, ration = db[title]
print("{title} ({year}) {ration} minute{0}, by "
"{director}".format(Util.s(ration),**locals()))
列出所有DVD (或者那些标题以某个子字符串引导)就是对DBM的所有项进行迭代。
Util.s()函数就是简单的s = lambda x: "" if x == 1 else "s",因此，如果时间长度不是1分钟，就返回"s"。
def remove_dvd(db):
title = find_dvd(db, "remove")
if title is None:
return
ans = Console.get_bool("Remove {0}?".format(title), "no")
if ans:
del db[title]
db.sync()
要移除一个DVD,首先需要找到用户要移除的DVD,并请求确认，获取后从DBM中删除该项即可。
到这里，我们展示了如何使用shelve模块打开(或创建)一个DBM文件，以及如何向其中添加项、编辑项、对其项进行迭代以及移除某个项。
遗憾的是，在我们的数据设计中存在一个瑕疵。发行者名称是重复的，这很容易导致不一致性，比如，发行者Danny DeVito可能被输入为"Danny De Vito",用于 一个电影；也可以输入为“Danny deVito",用于另一个。为解决这一问题，可以使用两个DBM文件，主DVD文件使用标题键与(年份，时间长度，发行者ID)值; 发行者文件使用发行者ID (整数)键与发行者名称值。下一节展示的SQL数据库 版程序将避免这一瑕疵，这是通过使用两个表格实现的，一个用于DVD,另一个用于发行者。
12.2 SQL数据库
大多数流行的SQL数据库的接口在第三方模块中是可用的，Python带有sqlite3 模块(以及SQLite 3数据库)，因此，在Python中，可以直接开始数据库程序设计。SQLite是一个轻量级的SQL数据库，缺少很多诸如PostgreSQL这种数据库的功能， 但非常便于构造原型系统，并且在很多情况下也是够用的。
为使后台数据库之间的切换尽可能容易，PEP 249 (Python Database API Specification v2.0)提供了称为DB-API 2.0的API规范。数据库接口应该遵循这一规范，比如sqlite3模块就遵循这一规范，但不是所有第三方模块都遵循。API规范中指定了两种主要的对象，即连接对象与游标对象。表12-1与表12-2中分别列出了这两种对象必须支持的API。在sqlite3模块中，除DB-API 2.0规范必需的之外，其连接对象与游标对象都提供了很多附加的属性与方法。
DVD程序的SQL版本为dvds.sql.py,该程序将发行者与DVD数据分开存储，以 避免重复，并提供一个新菜单，以供用户列出发行者。该程序使用的两个表格在图12-1
def connect(filename):
create= not os.path.exists(filename)
db = sqlite3.connect(filename)
if create:
cursor = db.cursor()
cursor.execute("CREATE TABLE directors ("
"id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE NOT NULL, "
"name TEXT UNIQUE NOT NULL)")
cursor.execute("CREATE TABLE dvds ("
"id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE NOT NULL, "
"title TEXT NOT NULL, "
"year INTEGER NOT NULL,"
"ration INTEGER NOT NULL, "
"director_id INTEGER NOT NULL, ”
"FOREIGN KEY (director_id) REFERENCES directors)")
db.commit()
return db
sqlite3.connect()函数会返回一个数据库对象，并打开其指定的数据库文件。如果该文件不存在，就创建一个空的数据库文件。鉴于此，在调用sqlite3.connect()之前，我们要注意数据库是否是准备从头开始创建，如果是，就必须创建该程序要使用的表格。所有査询都是通过一个数据库游标完成的，可以从数据库对象的cursor()方法获取。
注意，两个表格都是使用一个ID字段创建的，ID字段有一个AUTOINCREMENT 约束——这意味着SQLite会自动为ID字段赋予唯一性的数值，因此，在插入新记录时，我们可以将这些字段留给SQLite处理。
SQLite支持有限的数据类型——实际上就是布尔型、数值型与字符串——但使用数据'‘适配器”可以对其进行扩展，或者是扩展到预定义的数据类型(比如那些用于日期与datetimes的类型)，或者是用于表示任意数据类型的自定义类型。DVD程序并不需要这一功能，如果需要，sqlite3模块的文档提供了很多详细解释。我们使用的外部键语法可能与用于其他数据库的语法不同，并且在任何情况下，只是记录我们的意图，因为SQLite不像很多其他数据库那样需要强制关系完整性，sqlite3另一点与众不同的地方在于其默认行为是支持隐式的事务处理，因此，没有提供显式的“开始事务” 方法。
def add_dvd(db):
title = Console.get_string("Title", "title")
if not title:
return
director = Console.get_string("Director", "director")
if not director:
return
year = Console.get_integer("Year", "year”, minimum=1896,
maximum=datetime.date.today().year)
ration = Console.get_integer("Duration (minutes)", "minutes",
minimum=0,maximum=60*48)
director_id = get_and_set_director(db, director)
cursor = db.cursor()
cursor.execute("INSERT INTO dvds ”
"(title, year, ration, director_id)"
"VALUES (?, ?, ?, ?)",
(title, year, ration, director_id))
db.commit()
这一函数的开始代码与dvds-dbm.py程序中的对应函数一样，但在完成数据的收集后，与原来的函数有很大的差别。用户输入的发行者可能在也可能不在directors表格中，因此，我们有一个get_and_set_director()函数，在数据库中尚无某个发行者时， 该函数就将其插入到其中，无论哪种情况都返回就绪的发行者ID,以便在需要的时候插入到dvds表。在所有数据都可用后，我们执行一条SQL INSERT语句。我们不需要指定记录ID,因为SQLite会自动为我们提供。
在査询中，我们使用问号(？)作为占位符，每个?都由包含SQL语句的字符串后面的序列中的值替代。命名的占位符也可以使用，后面在编辑记录时我们将看到。尽管避免使用占位符(而只是简单地使用嵌入到其中的数据来格式化SQL字符串)也是可能的，我们建议总是使用占位符，并将数据项正确编码与转义的工作留给数据库模块来完成。使用占位符的另一个好处是可以提高安全性，因为这可以防止任意的SQL 被恶意地插入到一个査询中。
def get_and_set_director(db, director):
director_id = get_director_id(db, director)
if directorjd is not None:
return director_id
cursor = db.cursor()
cursor.execute("lNSERT INTO directors (name) VALUES (?)”,(director,))
db.commit()
return get_director_id(db, director)
这一函数返回给定发行者的ID,并在必要的时候插入新的发行者记录。如果某个记录被插入，我们首先尝试使用get_director_id()函数取回其ID。
def get_director_id(db, director):
cursor = db.cursor()
cursor.execute("SELECT id FROM directors WHERE name=?",(director,))
fields = cursor.fetchone()
return fields[0] if fields is not None else None
get_director_id()函数返回给定发行者的ID,如果数据库中没有指定的发行者，就返回None。我们使用fetchone()方法，因为或者有一个匹配的记录，或者没有。(我们知道，不会有重复的发行者，因为directors表格的名称字段有一个UNIQUE约束，在任何情况下，在添加一个新的发行者之前，我们总是先检査其是否存在。)这种取回方法总是返回一个字段序列(如果没有更多的记录，就返回None)。即便如此，这里我们只是请求返回一个单独的字段。
def edit_dvd(db):
title, identity = find_dvd(db, "edit")
if title is None:
return
title = Console.get_string("Title","title", title)
if not title:
return
cursor = db.cursor()
cursor.execute("SELECT dvds.year, dvds.ration, directors.name"
“FROM dvds, directors "
"WHERE dvds.director_id = directors.id AND "
"dvds.id=:id", dict(id=identity))
year, ration, director = cursor.fetchone()
director = Console.get_string("Director", "director", director)
if not director:
return
year = Console,get_integer("Year","year", year, 1896,datetime.date.today().year)
ration = Console.get_integer("Duration (minutes)", "minutes",
ration, minimum=0, maximum=60*48)
director_id = get_and_set_director(db, director)
cursor.execute("UPDATE dvds SET title=:title, year=:year,"
"ration=:ration, director_id=:directorjd "
"WHERE id=:identity", locals())
db.commit()
要编辑DVD记录，我们必须首先找到用户需要操纵的记录。如果找到了某个记录，我们就给用户修改其标题的机会，之后取回该记录的其他字段，以便将现有值作为默认值，将用户的输入工作最小化，用户只需要按Enter键就可以接受默认值。这里，我们使用了命名的占位符(形式为:name),并且必须使用映射来提供相应的值。对SELECT语句，我们使用一个新创建的字典；对UPDATE语句，我们使用的是由 locals()返回的字典。
我们可以同时为这两个语句都使用新字典，这种情况下，对UPDATE语句，我们可以传递 dict(title=title, year=year, ration=ration, director_id=director_id, id=identity))，而非 locals()。
在具备所有字段并且用户已经输入了需要做的改变之后，我们取回相应的发行者ID (如果必要就插入新的发行者记录)，之后使用新数据对数据库进行更新。我们采用了一种简化的方法，对记录的所有字段进行更新，而不仅仅是那些做了修改的字段。
在使用DBM文件时，DVD标题被用作键，因此，如果标题进行了修改，我们就需要创建一个新的键-值项，并删除原始项。不过，这里每个DVD记录都有一个唯一性的ID,该ID是记录初次插入时创建的，因此，我们只需要改变任何其他字段的值， 而不需要其他操作。
def find_dvd(db, message):
message = "(Start of) title to " + message
cursor = db.cursor()
while True: .
start = Console.get_stnng(message, "title")
if not start:
return (None, None)
cursor.execute("SELECT title, id FROM dvds "
"WHERE title LIKE ? ORDER BY title”，
(start +"%",))
records = cursor.fetchall()
if len(records) == 0:
print("There are no dvds starting with", start)
continue
elif len(records) == 1:
return records[0]
elif len(records) > DISPLAY_LIMIT:
print("Too many dvds ({0}) start with {1}; try entering "
"more of the title".format(len(records),start))
continue
else:
for i, record in enumerate(records):
print("{0}:{1}".format(i + 1, record[0]))
which = Console.get_integer("Number (or 0 to cancel)",
"number", minimum=1, maximum=len(records))
return records[which -1] if which != 0 else (None, None)
这一函数的功能与dvdsdbm.py程序中的find_dvd()函数相同，并返回一个二元组 (DVD标题，DVD ID)或(None, None),具体依赖于是否找到了某个记录。这里并不需要在所有数据上进行迭代，而是使用SQL通配符(%),因此只取回相关的记录。
由于我们希望匹配的记录数较小，因此我们一次性将其都取回到序列的序列中。如果有不止一个匹配的记录，但数量上又少到可以显示，我们就打印记录，并将每条记录附带一个数字编号，以便用户可以选择需要的记录，其方式与在dvds-dbm.py程序中所做的类似：
def list_dvds(db):
cursor = db.cursor()
sql = ("SELECT dvds.title, dvds.year, dvds.ration, "
"directors.name FROM dvds, directors "
"WHERE dvds.director_id = directors.id")
start = None
if dvd_count(db) > DISPLAY_LIMIT:
start = Console.get_string("List those starting with [Enter=all]", "start")
sql += " AND dvds.title LIKE ?"
sql += ” ORDER BY dvds.title"
print()
if start is None:
cursor.execute(sql)
else:
cursor.execute(sql, (start +"%",))
for record in cursor:
print("{0[0]} ({0[1]}) {0[2]} minutes, by {0[3]}".format(record))
要列出每个DVD的详细资料，我们执行一个SELECT査询。该査询连接两个表，如果记录(由dvd_count()函数返回)数量超过了显示限制值,就将第2个元素添加到WHERE 分支，之后执行该査询，并在结果上进行迭代。每个记录都是一个序列，其字段是与 SELECT査询相匹配的。
def dvd_count(db):
cursor = db.cursor()
cursor.execute("SELECT COUNT(*) FROM dvds")
return cursor.fetchone()[0]
我们将这几行代码放置在一个单独的函数中，因为我们在几个不同的函数中都需要使用这几行代码。
我们忽略了 list_directors()函数的代码，因为该函数在结构上与list_dvds()函数非常类似，只不过更简单一些，因为本函数只列出一个字段(name)。
def remove_dvd(db):
title, identity = find_dvd(db, "remove")
if title is None:
return
ans = Console.get_bool("Remove {0}?".format(title), "no")
if ans:
cursor = db.cursor()
cursor.execute("DELETE FROM dvds WHERE id=?", (identity,))
db.commit()
在用户需要删除一个记录时，将调用本函数，并且本函数与dvds-dbm.py程序中 相应的函数是非常类似的。
到此，我们完全查阅了 dvds-sql.py程序，并且了解了如何创建数据库表格、选取 记录、在选定的记录上进行迭代以及插入、更新与删除记录。使用execute()方法，我们可以执行底层数据库所支持的任意SQL语句。
SQLite提供了比我们这里使用的多得多的功能，包括自动提交模式（以及任意其他类型的事务控制），以及创建可以在SQL查询内执行的函数的能力。提供一个工厂函数并用于控制对每个取回的记录返回什么（比如，一个字典或自定义类型，而不是字段序列）也是可能的。此外，通过传递“:memory:”作为文件名，创建内存中的SQLite 数据库也是可能的。
以上内容部分摘自视频课程05后端编程Python22 数据库编程，更多实操示例请参照视频讲解。跟着张员外讲编程，学习更轻松，不花钱还能学习真本领。
F. Python课程内容都学习什么啊
贺圣军Python轻松入门到项目实战（经典完整版）（超清视频）网络网盘
链接: https://pan..com/s/1C9k1o65FuQKNe68L3xEx3w
若资源有问题欢迎追问~