编程 - 后场思库

Python的发展趋势

空心菜发表了文章 0 个评论 2939 次浏览 2021-08-08 21:47 来自相关话题

一、Python发展历史Python是一种计算机程序设计语言。你可能在之前听说过很多编程语言，比如难学的C语言（语法和实现难度），非常流行的JAVA语言（尤其是现在分布式存储和服务），非常有争议的PHP（常见 WordPress 大多网 ...查看全部

一、Python发展历史

Python是一种计算机程序设计语言。你可能在之前听说过很多编程语言，比如难学的C语言（语法和实现难度），非常流行的JAVA语言（尤其是现在分布式存储和服务），非常有争议的PHP（常见 WordPress 大多网站），前端HTML、JavaScripts、Node.JS、还有最近随着容器风行的Golang等等。那Python是What？

1989年，Python的创始人为吉多·范罗苏姆（Guido van Rossum）。1989年的圣诞节期间，吉多·范罗苏姆为了在阿姆斯特丹打发时间，决心开发一个新的脚本解释程序，作为ABC语言的一种继承。
1991年，第一个Python编译器诞生。它是用C语言实现的，并能够调用C语言的库文件。从一出生，Python已经具有了：类，函数，异常处理，包含表和词典在内的核心数据类型，以及模块为基础的拓展系统。
1992年，Python之父发布了Python的web框架Zope1.
Python 1.0 - January 1994 增加了 lambda, map, filter and reduce.
Python 2.0 - October 16, 2000，加入了内存回收机制，构成了现在Python语言框架的基础
Python 2.4 - November 30, 2004, 同年目前最流行的WEB框架Django 诞生
Python 2.5 - September 19, 2006
Python 2.6 - October 1, 2008
Python 2.7 - July 3, 2010
In November 2014, it was announced that Python 2.7 would be supported until 2020, and reaffirmed that there would be no 2.8 release as users were expected to move to Python 3.4+ as soon as possible
Python 3.0 - December 3, 2008
Python 3.1 - June 27, 2009
Python 3.2 - February 20, 2011
Python 3.3 - September 29, 2012
Python 3.4 - March 16, 2014
Python 3.5 - September 13, 2015

二、Python的前景

最新的TIOBE（ https://www.tiobe.com/tiobe-index/ ）排行榜，Python赶超JAVA占据第二名了， Python崇尚优美、清晰、简单，是一个优秀并广泛使用的语言。

我们看看17年Python的排名:

由上图17年预测可见，Python整体呈上升趋势，反映出Python应用越来越广泛并且也逐渐得到大家的认知和认可，影响度也越来越大，在国内Python开发招聘的岗位也越来越多，我们来看看2017年100offer统计情况：

从上图我们可以看出Python的人均面邀数为6，整体年薪在34w左右，在职位招聘排行榜前十名，应该还算不错的表现哦。

三、Python的应用领域

Python可以应用于众多领域，如：数据分析、组件集成、网络服务、图像处理、数值计算和科学计算等众多领域。

目前业内几乎所有大中型互联网企业都在使用Python，如：Youtube、Dropbox、BT、Quora（中国知乎）、豆瓣、知乎、Google、Yahoo!、Facebook、NASA、阿里、百度、腾讯、汽车之家、美团等。

目前Python主要的应用领域

云计算: 在云计算领域Python可谓有一席之地，典型应用OpenStack这个大体量的开源云计算产品就是居于Python开发的。
WEB开发: 已有众多大型网站均为Python开发，Youtube, Dropbox, 豆瓣, 知乎等….， Python也有许多Web开发框架，典型WEB框架有Django、Pylons，还有Tornado、Bottle、Flask等。
系统运维: 从国内的趋势来看，掌握一门编程语言已经成为了必然的结果，Python在国内已经成为了首选，不管是做自动化运维还是业务运维现在Python在运维领域已经应用极广。
金融：量化交易，金融分析，在金融工程领域，Python不但在用，且用的最多，而且重要性逐年提高。原因：作为动态语言的Python，语言结构清晰简单，库丰富，成熟稳定，科学计算和统计分析都很牛逼，生产效率远远高于c,c++,java,尤其擅长策略回测
图形GUI: PyQT, WxPython, TkInter, PySide等在图形用户接口领域都有广泛被应用。

哪些公司在用Python

谷歌：Google App Engine 、code.google.com 、Google earth 、谷歌爬虫、Google广告等项目都在大量使用Python开发。
CIA: 美国中情局网站就是用Python开发的。
NASA: 美国航天局(NASA)大量使用Python进行数据分析和运算。
YouTube:世界上最大的视频网站YouTube就是用Python开发的。
Dropbox:美国最大的在线云存储网站，全部用Python实现，每天网站处理10亿个文件的上传和下载。
Instagram:美国最大的图片分享社交网站，每天超过3千万张照片被分享，全部用python开发。
Facebook:大量的基础库均通过Python实现的
Redhat: 世界上最流行的Linux发行版本中的yum包管理工具就是用python开发的
豆瓣: 公司几乎所有的业务均是通过Python开发完成的。
知乎: 国内最大的问答社区，通过Python开发(国外Quora)
春雨医生：国内知名的在线医疗网站是用Python开发的

除上面之外，还有搜狐、金山、腾讯、盛大、网易、百度、阿里、淘宝、土豆、新浪、果壳等公司都在使用Python完成各种各样的任务, 互联网公司广泛使用Python来做的事一般有：自动化运维、自动化测试、大数据分析、爬虫、Web 等。

为什么是Python而不是其他语言呢？

C 和 Python、Java、C#等

C语言: 代码编译得到机器码，机器码在处理器上直接执行，每一条指令控制CPU工作

其他语言：代码编译得到字节码，虚拟机执行字节码并转换成机器码再后在处理器上执行

Python和C Python这门语言是由C开发而来　

对于使用：Python的类库齐全并且使用简洁，如果要实现同样的功能，Python 10行代码可以解决，C可能就需要100行甚至更多.
对于速度：Python的运行速度相较与C，绝逼是慢了

Python 和 Java、C#等

对于使用：Linux原装Python，其他语言没有；以上几门语言都有非常丰富的类库支持

对于速度：Python在速度上可能稍显逊色

Python和PHP相比

Python提供了丰富的数据结构，非常容易和c集成。相比较而言，php集中专注在web上。 php大多只提供了系统api的简单封装，但是python标准包却直接提供了很多实用的工具。python的适用性更为广泛，php在web更加专业，php的简单数据类型，完全是为web量身定做。

所以，Python和其他语言没有什么本质区别，其他区别在于：擅长某领域、人才丰富、先入为主。语言是死的，每个语言的诞生都有它的道理，所以选择你喜欢的，开心的玩起来。

Go进阶笔记-微服务概览与治理

peanut 发表了文章 0 个评论 2506 次浏览 2020-11-25 10:15 来自相关话题

基本上在产品的最开始阶段，为了快速构建产品，都是单体架构，尽快我们也会按照业务划分模块，但是这个样子始终最终部署的时候还是单体式应用。如我们早期可以使用Python 的Django快速迭代一个web应用，我们会在Django中划分不同的模块， ...查看全部

基本上在产品的最开始阶段，为了快速构建产品，都是单体架构，尽快我们也会按照业务划分模块，但是这个样子始终最终部署的时候还是单体式应用。
如我们早期可以使用Python 的Django快速迭代一个web应用，我们会在Django中划分不同的模块，也就是Django中的app。
而随着业务的迭代发展，项目越来越复杂，可能就会导致应用的扩展，可靠性越来越低，最终导致敏捷开发和自动化部署变得无法完成。

微服务定义

关于SOA

面向服务的架构（SOA）是一个组件模型，它将应用程序的不同功能单元（称为服务）进行拆分，并通过这些服务之间定义良好的接口和协议联系起来。接口是采用中立的方式进行定义的，它应该独立于实现服务的硬件平台、操作系统和编程语言。这使得构建在各种各样的系统中的服务可以以一种统一和通用的方式进行交互。

所以我们可以把微服务看做是SOA的一种实践：

小即是美：小的服务代码少，bug也少，易于测试，易于维护，也更容易不断迭代完善。
单一职责：一个服务只需要干好一件事情，专注才能做好。

什么是微服务？

围绕业务功能构建的，服务关注单一业务，服务间采用轻量级的通信机制，可以全自动独立部署，可以使用不同的编程语言和数据存储技术。微服务架构通过业务拆分实现服务组件化，通过组件组合快速开发系统，业务单一的服务组件又可以独立部署，使整个系统变得清晰灵活。

原子服务
独立进程
隔离部署
去中心化服务治理

注意：基础设施的建设，复杂度高。

自己的理解：

简单说就是微小的服务或应用，比如linux上的各种工具：ls,cat,awk等
微服务就是让每个小的服务专注的做好一件事
每个服务单独开发和部署，服务之间是完全隔离的

微服务的优缺点

微服务也不是万金油，并不是所有的情况都需要做成微服务，同时微服务也有自己的缺点或者说微服务也会带来一些问题：

微服务应用是分布式系统，因此系统必然会比单体应用的时候复杂：开发者不得不适用RPC或者消息传递来实现进程间通信；必须要写代码来处理消息传递中速度过慢或者服务不可用等局部失效问题。
分区的数据库架构，同时更新多个业务主体的事务很普遍。这种事务对单体式应用来说很容易，因为只有一个数据库。在微服务架构中，需要更新不同服务使用的不同的数据库，从而对开发者提供了更高的要求和挑战。
测试一个基于微服务的应用也变的很复杂。
服务模块的依赖，应用的升级可能会涉及多个服务模块的修改。

优点：

迭代周期短，极大的提升开发效率
独立部署，独立开发
可伸缩性好，能够针对指定的服务进行伸缩
故障隔离，不会相互影响

缺点：

复杂度增加，一个请求往往要经过多个服务，请求链路比较长
监控和定位问题困难
服务管理比较复杂

组件化服务

微服务的核心是组件化服务，通过将之前复杂的巨石机构，拆分成不同的服务，来实现组件化。即将应用拆散为一系列的服务运行在不同的进程中。单一的服务变化只需要重新部署对应的服务进程。

区中心化

数据去中心化
治理去中心化
技术去中心化

注：治理区中心化，可以理解为消除架构中的热点，例如，我们通常在架构中使用的Nginx，所有的流量都会先经过Nginx,虽然也可以扩容，但是相对来说收益就比较低。

每个服务独享自身的数据存储设施(缓存，数据库等)，而不是像传统应用共享一个缓存和数据库，这样有利于服务的独立性，隔离相关干扰。

基础设施自动化

无自动化不微服务。自动化包括测试和部署。
单一进程的传统应用被拆分为一系列的多进程服务后，意味着开发，调试，测试，监控和部署的复杂度会增加，必须要有合适的自动化基础设施来支持微服务架构，否则开发和运维的成本会大大增加。

CICD
Testing
K8s

落地微服务的关键因素

配套设施：

微服务框架研发和维护
打包，版本管理，上线平台支持
硬件层支持，比如容易和容器调度
服务治理平台支持，比如分布式链路追踪和监控
测试自动化支持，比如上线前自动化case

组织架构

微服务框架开发团队
私有云研发团队
测试平台研发团队

硬件层架构

可用性 & 兼容性设计

微服务架构采用粗力度的进程间通信。关于可用性和兼容性主要包含以下方面：

隔离
超时控制
负载保护
限流
降级
重试
负载均衡

注意：服务的提供者的变更可能引发服务消费者的兼容性破坏，时刻谨记服务契约的兼容性。
总结一句话：发送时要保守，接收时要开放。

微服务设计

API Gateway

常见的开源网关：Kong, APSix,

面向用户场景的API,而不是面向资源的API

BFF（Backend for Frontend）可以认为是一种适配服务，将后端的微服务进行适配（主要包括聚合裁剪和适配逻辑），向无线端设备暴露友好和统一的API，方便无线设备介入访问后端服务。

BFF 可以理解为主要进行数据的组装，业务场景的聚合API

网关在微服务架构中承担着非常重要的角色，它是解偶拆分和后续升级的利器。在网关的配合下，单块BFF 实现解偶拆分，各业务团队可以独立开发和交付各自的微服务。
把跨横切面逻辑从BFF 剥离到网关上，BFF的开发可以更加专注于业务逻辑交付。实现架构上的关注分离。

Mircoservice划分

相对来说有两种不同不同的划分服务边界：通过业务职能（Business Capability）划分和DDD的限界上下文(Bounded Context)

Business Capability: 由公司内部不同部门提供的只能
Bounded Context：这里的业务边界的含义是“解决不同业务问题”的问题域和对应的解决方案域，为了解决某种类型的业务问题，贴近领域知识，也就是业务。

DDD 通过领域对象之间的交互实现业务逻辑与流程，并通过分层的方式将业务逻辑剥离出来，单独进行维护，从而控制业务本身的复杂度。

注意：微服务与微服务之间不是通过数据耦合的，所以微服与微服务之间都是通过接口调用，一定不是通过数据，服务与服务之间数据是隔离的。

什么是CQRS

CQRS — Command Query Responsibility Segregation，故名思义是将 command 与 query 分离的一种模式。

CQRS 将系统中的操作分为两类，即「命令」(Command) 与「查询」(Query)。命令则是对会引起数据发生变化操作的总称，即我们常说的新增，更新，删除这些操作，都是命令。而查询则和字面意思一样，即不会对数据产生变化的操作，只是按照某些条件查找数据。

CQRS 的核心思想是将这两类不同的操作进行分离，然后在两个独立的「服务」中实现。这里的「服务」一般是指两个独立部署的应用。在某些特殊情况下，也可以部署在同一个应用内的不同接口上。

Command 与 Query 对应的数据源也应该是互相独立的，即更新操作在一个数据源，而查询操作在另一个数据源上。

Mircoservice安全

关于外网的请求，通常在API Gateway进行统一的认证拦截，认证成功后，使用JWT方式通过RPC元数据传递的方式带到BFF层，BFF校验Token完整性后把身份信息注入到应用的Context中，BFF到其他下层的微服务，建议是直接在RPC Request中带入用户身份信息（UserID）请求服务

对于服务内部，一般要区分身份认证和授权

对于身份认证：如果是gRPC，可以很容易进行身份认证，如：证书…
对于授权：通过配置中心做一个RBAC的服务，下发到服务，服务加载的时候就可以很容易构建一个RBAC的认证，从而判断这个请求是否有权限。

gRPC && 服务发现

多语言：语言中立，支持多种语言
轻量级，高性能：序列化支持PB(Protocol Buffer) 和JSON, PB是一种语言无关的高性能序列化框架
可插拔
IDL：基于文件定义服务，通过proto3工具生成指定语言的数据结构/服务端接口以及客户端Stub
设计理念：如元数据的传递
移动端：基于标准的HTTP2设计，支持双向流，消息头压缩,单TCP的多路复用/服务端推送等特性。
服务而非对象，消息而非引用：促进微服务的系统间粗粒度消息交互设计理念
负载无关的：不同的服务需要使用不同的消息类型和编码
流：streaming API
阻塞式和非阻塞式：支持异步和同步处理在客户端和服务端交互的消息序列
元数据交换：常见的横切关注点，如认证或追踪，依赖数据交换。
标准化状态码：客户端通常以有限的方式响应API调用返回的错误

Health Check

gRPC 有一个标准的健康监测协议，在gRPC的所有语言实现中基本都提供了生成代码合用于设置运行状态的功能。

主动健康检查可以在服务提供者服务不稳定时，被消费者所感知，临时从负载均衡中摘除，减少错误请求。当服务提供这重新稳定后，health check 成功，重新假如到消费者的负载均衡中，回复请求，health check 同样也被用于外挂方式的容器健康检测，或者流量检测

healthCheck 可以做什么？

在我们的服务注册与发现中，假如服务的提供者Provider到Discoery 之间通信时正常的，但是我们的服务调用者Consumer到服务提供者Provider之间出现网络问题，这个时候如果没有健康检查，我们的服务调用这就会继续调用，但是这个时候其实是会调用失败的，而healthCheck 就可以避免这种情况的发生。它会对从Discoery中获取到的Provider进行健康检查，虽然Discoery中有这个Provider，但是如果健康检查有问题，那么就会把这个provider进行剔除。避免调用失败的问题。
平滑发布

服务发现

CAP原理

C: consistency, 一致性，每次总是能够读到最近写入的数据或者失败
A: available, 每次请求都能读到数据
P: partition tolerance 分区容忍,不管任意个消息由于网络原因失败,系统都能能够继续工作

CAP原理中，P是必须满足的，C 和A 可以根据业务需要选择，要么是CP系统，要么是AP系统

客户端发现

一个服务实例启动时，它的网络地址会被注册到注册中心，当服务实例终止时，再从注册中心删除。这个服务实例的注册表通过心跳机制动态刷新；客户端使用一个负载均衡算法，去选择一个可用的服务实例，来响应这个请求。

服务端发现

客户端通过负载均衡器向一个服务发送请求，这个负载均衡器会查询服务注册表，并将请求路由到可用的服务实例上。服务实例在服务注册表上被注册和注销

对比两种服务发现：

客户端发现：直连，比服务端服务发现少一次网络跳转，Consumer需要内置特定的服务发现客户端和发现逻辑。
服务端发现：Consumer无需关注服务发现具体细节，只需要知道服务的DNS域名即可，支持异构语言开发，需要基础设施支撑，多了一次网络跳转，可能有性能损失。

注意：微服务的和兴是去中心化，所以相对来说使用客户端服务发现模式比较好

推荐的服务发现：
https://nacos.io/zh-cn/docs/what-is-nacos.html
https://github.com/bilibili/discovery 学习一下代码

服务发现中的保护机制：

如果发现短时间内大量服务提供这下线，会开启自我保护模式。这个时候不会剔除服务。
如果服务消费者和服务注册中心通信故障，这个时候本身服务消费者会缓存配置，即使短时间内通信故障也不会有太大影响。

多集群 & 多租户

对于特别重要的服务通常是要考虑多级群。

从单一集群考虑，多个节点保证可用性，我们通常使用N+2的方式来冗余节点。
从单一集群故障带来的影响面角度考虑冗余多套集群。
单个机房内的机房故障导致的问题。

多套冗余的集群对应多套独占的缓存，带来更好的性能和冗余能力
尽量避免业务隔离使用或者sharding带来的cache hit影响（按照业务划分集群资源）

但是这里会有一个问题需要考虑：
根据不同的业务划分集群后，如果其中一个业务的进群挂了之后，将流量切到正常集群的时候，这个时候因为独占缓存，所以就会导致产生到两的cache miss 透传到DB，这个时候DB的压力会瞬间变大。

解决办法：可以和所有集群建立连接，通过负载均衡的方式，这样请求就会均摊的打到不同的集群中
上，从而防止缓存击穿的情况。

注意这里还有一个问题：
对于服务中的个别服务可能会存在有大量的其他服务都会依赖这个服务的情况，如帐号服务，那么这个时候health check 的检查可能会占用一定的资源，并且随着规模的增加，光health check 就会占用非常高的资源，如何解决这个问题呢？

是否可以从全集群中选取一批节点（子集），利于划分子集限制连接池大小？

通常20-100个后端，部分场景需要大子集，比如批量读写操作。
后端平均分给客户端。
客户端重启，保持重新均衡，同时对后端重启保持透明，同时连接的变动最小。

需要思考这个算法的实现。

多租户

在一个微服务架构中允许系统共存是利用微服务稳定性及模块化最有效的方式之一。这种方式一般被称为多租户。租户卡一是测试，金丝雀发布，影子系统，甚至服务层或产品线，使用租户能够保证代码的隔离性并且能够基于流量租户做路由决策。

多租户就是解决RPC的路由或者叫做RPC染色

并行测试需要一个和生产环境一样的过渡（staging）环境，并且知识用来处理测试流量。在并行测试中，工程师团队首先完成生产服务的一次变动，然后将变动的代码部署到测试栈，这种方法可以在不影响生产环境的情况下让开发者稳定的测试服务，同时能够在发布前更容易的识别和控制bug，尽管并行测试是一种非常有效的集成测试方法，但是它也带来了一些可能影响服务架构成功的挑战：

混用环境导致的不可靠测试
多套环境带来的硬件成本
难以做负载测试，仿真线上真实流量情况

使用这种方法(内部叫染色发布)，我们可以把待测试的服务 B 在一个隔离的沙盒环境中启动，并且在沙盒环境下可以访问集成环境(UAT) C 和D。我们把测试流量路由到服务 B，同时保持生产流量正常流入到集成服务。服务 B 仅仅处理测试流量而不处理生产流量。另外要确保集成流量不要被测试流量影响。生产中的测试提出了两个基本要求，它们也构成了多租户体系结构的基础：

流量路由：能够基于流入栈中的流量类型做路由。
隔离性：能够可靠的隔离测试和生产中的资源，这样可以保证对于关键业务微服务没有副作用。

这里可以理解为，对于不同的流量区别对待，对于测试的流量，也会在请求的时候带上对应的染色标记，这样到达系统的时候就会根据不同的染色标记走不同的路由，路由到具有相同染色的服务上。

小结

对于微服整体有一认识
对于公司现有系统架构的一些思考，可以跟着课程的深入学习，慢慢对公司现有架构整理出自己的意见和一些可行性的方案

需要关注的书籍与链接：

https://microservices.io/
https://nacos.io/zh-cn/docs/what-is-nacos.html
https://github.com/bilibili/discovery
https://hellosean1025.github.io/yapi/
《UNIX环境高级编程》
《Google SRE》

图解Python 集合

空心菜发表了文章 2 个评论 4580 次浏览 2016-08-10 23:41 来自相关话题

集合基本功能集合是一个无序的，不重复的数据组合，用{}表示，它的主要作用如下：去重，把一个列表变成集合，就会自动去重关系测试，测试两组数据之前的交集、差集、并集、子集等关系集合创建： >>> ...查看全部

集合基本功能

集合是一个无序的，不重复的数据组合，用{}表示，它的主要作用如下：

去重，把一个列表变成集合，就会自动去重
关系测试，测试两组数据之前的交集、差集、并集、子集等关系

集合创建：

>>> set_job = set(['DEV', 'OPS', 'DBA', 'QA', 'Sales'])

>>> set_man = set(('lucky', 'jack', 'andy', 'tom', 'andy', 'jim'))

>>> print(set_job, type(set_job))

{'DEV', 'OPS', 'Sales', 'QA', 'DBA'} 

>>> print(set_man, type(set_man))    # 天生去重，只有一个andy了

{'andy', 'jack', 'lucky', 'tom', 'jim'}

元素添加：

>>> set_job = set(['DEV', 'OPS', 'DBA', 'QA', 'Sales'])

>>> set_job.add('HR')       # add方法只能添加一个

>>> print(set_job)

{'QA', 'HR', 'Sales', 'DEV', 'OPS', 'DBA'}

>>> set_job.update(['FD', 'MD', 'MD'])

>>> print(set_job)

{'QA', 'HR', 'Sales', 'DEV', 'MD', 'OPS', 'FD', 'DBA'}

>>> set_job.update(('AD', 'PD'))  # update方法可以添加是列表或者元组，去重,如果添加的为一个单独字符串，则把字符串拆成字母添加到集合中

>>> print(set_job)

{'QA', 'HR', 'PD', 'Sales', 'DEV', 'MD', 'OPS', 'AD', 'FD', 'DBA'}

元素删除：

>>> set_job = {'QA', 'HR', 'PD', 'Sales', 'DEV', 'MD', 'OPS', 'AD', 'FD', 'DBA'}

>>> set_job.remove('PD')   # 删除指定元素

>>> set_job.remove('xx')   # 元素不存在则报错 KeyError

Traceback (most recent call last):

  File "", line 1, in 

KeyError: 'xx'

>>> print(set_job)

{'QA', 'HR', 'MD', 'DEV', 'Sales', 'OPS', 'AD', 'FD', 'DBA'}

>>> set_job.pop()  # 随机删除一个元素

'QA'

>>> print(set_job)

{'HR', 'MD', 'DEV', 'Sales', 'OPS', 'AD', 'FD', 'DBA'}

>>> set_job.discard('OPS')  # 指定删除

>>> set_job.discard('xxx')  # 不存在返回None，不会报KeyError

>>> print(set_job)

{'HR', 'MD', 'DEV', 'Sales', 'AD', 'FD', 'DBA'}

其他：

>>> set_job = {'QA', 'HR', 'PD', 'Sales', 'DEV', 'MD', 'OPS', 'AD', 'FD', 'DBA'}

>>> len(set_job)  # 集合长度

10

>>> 'QA' in set_job  # 判断是否在集合中

True

>>> 'XXX' not in set_job # 不在集合中

True

>>> for i in set_job:   # 循环

...     print(i)

集合关系测试

交集：

>>> set_a = {5, 6, 7, 8, 9, 10}

>>> set_b = {1, 2, 3, 4, 5, 6}

>>> print(set_a.intersection(set_b))   # 常规方式

{5, 6}

>>> print(set_a & set_b)   # 运算符（&）方式

{5, 6}

并集

>>> set_a = {5, 6, 7, 8, 9, 10}

>>> set_b = {1, 2, 3, 4, 5, 6}

>>> set_c = set_a.union(set_b)    # 关键字union做并集运算 先后顺序无关，谁并谁都可以

>>> print(set_c)

{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

>>> 

>>> set_c = set_a | set_b     # 运算符关键符 | 做并集运算  先后顺序无关，谁并谁都可以

>>> print(set_c)

{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

差集

>>> set_a = {5, 6, 7, 8, 9, 10}

>>> set_b = {1, 2, 3, 4, 5, 6}

>>> set_c = set_a - set_b   # a集合跟b集合做差集 关键符 -

>>> print(set_c)

{8, 9, 10, 7}

>>> set_d = set_b - set_a   # b集合跟a集合做差集 关键符 -

>>> print(set_d)

{1, 2, 3, 4}

>>> set_c = set_a.difference(set_b) # a集合跟b集合做差集 关键字difference

>>> print(set_c)

{8, 9, 10, 7}

>>> set_d = set_b.difference(set_a) # b集合跟a集合做差集 关键字difference

>>> print(set_d)

{1, 2, 3, 4}

子集父集

拿苹果来打比方就是，把苹果掰开，然后掰开的一小部分就是子集，然后整个苹果就是父集

>>> set_a = {5, 6, 7, 8, 9, 10}

>>> set_b = {1, 2, 3, 4, 5, 6}

>>> set_c = {7, 8, 9, 10}

>>> set_d = {1, 2, 3, 4}

>>> set_e = {5, 6}

>>> set_f = {11, 12, 13, 14, 15, 16}

>>> set_c.issubset(set_a)   # 测试集合c是否是集合a的子集 放回布尔值  关键字issubset

True

>>> set_d.issubset(set_b)   # 测试集合d是否是集合b的子集 返回布尔值  issubset

True

>>> set_e.issubset(set_a)

True

>>> set_e.issubset(set_b)

True

>>> set_e <= set_a         # 测试集合e是否是集合a的子集 关键符 <=

True

>>> set_e <= set_b

True

>>> set_f.issuperset(set_a)  # 测试f集合是否是a集合的父集

False

>>> set_a.issuperset(set_e)  # 测试a集合是否是集合e的父集 关键字issuperset

True

>>> set_b >= set_e  # 测试集合b是否是集合e的父集 关键符 >=

True

>>> set_b >= set_d

True

对称差集
对称差集就是两个集合去掉相同的部分，然后剩下的所有元素组成的集合

>>> set_a = {5, 6, 7, 8, 9, 10}

>>> set_b = {1, 2, 3, 4, 5, 6}

>>> set_c = set_a.symmetric_difference(set_b)  # 集合a和集合b做对称差集 关键字symmetric_difference 

>>> print(set_c)

{1, 2, 3, 4, 7, 8, 9, 10}

>>> set_c = set_a ^ set_b  # 集合a和集合b做对称差集 关键符 ^

>>> print(set_c)

{1, 2, 3, 4, 7, 8, 9, 10}

>>> set_c = set_b ^ set_a

>>> print(set_c)

{1, 2, 3, 4, 7, 8, 9, 10}

所有方法：

class set(object):

    """

    set() -> new empty set object

    set(iterable) -> new set object

    

    Build an unordered collection of unique elements.

    """

    def add(self, *args, **kwargs): # real signature unknown

        """

        Add an element to a set.

        

        This has no effect if the element is already present.

        """

        pass



    def clear(self, *args, **kwargs): # real signature unknown

        """ Remove all elements from this set. """

        pass



    def copy(self, *args, **kwargs): # real signature unknown

        """ Return a shallow copy of a set. """

        pass



    def difference(self, *args, **kwargs): # real signature unknown

        """

        Return the difference of two or more sets as a new set.

        

        (i.e. all elements that are in this set but not the others.)

        """

        pass



    def difference_update(self, *args, **kwargs): # real signature unknown

        """ Remove all elements of another set from this set. """

        pass



    def discard(self, *args, **kwargs): # real signature unknown

        """

        Remove an element from a set if it is a member.

        

        If the element is not a member, do nothing.

        """

        pass



    def intersection(self, *args, **kwargs): # real signature unknown

        """

        Return the intersection of two sets as a new set.

        

        (i.e. all elements that are in both sets.)

        """

        pass



    def intersection_update(self, *args, **kwargs): # real signature unknown

        """ Update a set with the intersection of itself and another. """

        pass



    def isdisjoint(self, *args, **kwargs): # real signature unknown

        """ Return True if two sets have a null intersection. """

        pass



    def issubset(self, *args, **kwargs): # real signature unknown

        """ Report whether another set contains this set. """

        pass



    def issuperset(self, *args, **kwargs): # real signature unknown

        """ Report whether this set contains another set. """

        pass



    def pop(self, *args, **kwargs): # real signature unknown

        """

        Remove and return an arbitrary set element.

        Raises KeyError if the set is empty.

        """

        pass



    def remove(self, *args, **kwargs): # real signature unknown

        """

        Remove an element from a set; it must be a member.

        

        If the element is not a member, raise a KeyError.

        """

        pass



    def symmetric_difference(self, *args, **kwargs): # real signature unknown

        """

        Return the symmetric difference of two sets as a new set.

        

        (i.e. all elements that are in exactly one of the sets.)

        """

        pass



    def symmetric_difference_update(self, *args, **kwargs): # real signature unknown

        """ Update a set with the symmetric difference of itself and another. """

        pass



    def union(self, *args, **kwargs): # real signature unknown

        """

        Return the union of sets as a new set.

        

        (i.e. all elements that are in either set.)

        """

        pass



    def update(self, *args, **kwargs): # real signature unknown

        """ Update a set with the union of itself and others. """

        pass

Python菜鸟之路基础篇(一)

空心菜发表了文章 3 个评论 4984 次浏览 2016-07-26 00:55 来自相关话题

Hello World 学习任何一门语言，我想大家写的以一句就是hello world吧，下面我们来看看Python的hello world 创建一个hello.py的文件：print ("Hello World")然后执 ...查看全部

Hello World

学习任何一门语言，我想大家写的以一句就是hello world吧，下面我们来看看Python的hello world
创建一个hello.py的文件：

print ("Hello World")

然后执行命令:python hello.py ,输出

crh:Python crh$ python3 hello.py 

Hello World

Python执行过程为：把代码读到内存 ---->词法语法分析 ---->放到编译器 ----> 生成字节码 ---->执行字节码 ---->生成机器码---->CPU执行,图示如下：

指定解释器
在上面情况，我们指定Python3 来执行hello.py
如果想要类似于执行shell脚本一样执行python脚本，例： ./hello.py ，那么就需要在 hello.py 文件的头部指定解释器，如下：

crh:Python crh$ cat hello.py 

#!/usr/bin/env python3



print ("Hello World")

像上面这样，然后给hello.py文件添加执行权限(chmod +x hello.py)就可以像执行shell脚本一样./hello.py 即可。
***像上面是利用Linux env命令通过环境变量去找到你想用的Python命令，如果你指定用某个Python版本的话一可以写绝对路径，比如：/usr/bin/python or /usr/local/bin/python3

在交互器中执行
除了把程序写在文件里，还可以直接调用python自带的交互器运行代码，进行调试和测试

crh:Python crh$ python3

Python 3.5.1 (default, Dec 26 2015, 18:08:53) 

[GCC 4.2.1 Compatible Apple LLVM 7.0.2 (clang-700.1.81)] on darwin

Type "help", "copyright", "credits" or "license" for more information.

[quote]>> print ("Hello World")

Hello World

>>>

变量

在一个计算机程序中引用变量是用来存储信息和操作的。他们还提供一种标签数据与一个描述性的名称,所以我们的程序可以被读者和我们自己更清楚地理解。它有助于认为变量保存信息的容器。他们的唯一目的是标签和数据存储在内存中。这些数据可以通过使用程序引用。

声明变量

#_[i]_coding:utf-8_[/i]_

 

name = "Lucky chen"

如上面所示声明了一个变量name，他的值是"Lucky chen"

我们再来看一组连续赋值的过程：

>>> name = "crh"

>>> name1 = name

>>> print (name,name1)

crh crh

>>> name = "Lucky"

>>> print (name1,name)

crh Lucky

如上所示，为什么name1 = name 当后续把name变量的值改变了，为什么name1的值没有随着改变呢，如下看看你就明白了：

>>> name = "crh"     #首先在内存中打开一块内存空间存储name变量值

>>> id(name)         #查看变量name的内存地址

4412833952

>>> name1 = name     #把我们把name赋值给name1变量

>>> id(name1)        #然后查看name1变量的内存地址 （跟name变量的内存地址一样）

4412833952

>>> name = "lucky"   #重新打开一个内存空间存储name的变量值

>>> id(name)         #查看新的name变量值的内存地址

4412834176

>>> id(name1)        #查看name1变量内存地址

4412833952

如上所示，我们可以看出，nama1其实就是借助name变量做一个变量的赋值，通过name变量得到值所在内存中的内存地址后，从而变成了一个正常的赋值过程。而不换随着name变量的内存空间地址的改变而改变。示意图如下：

交互输入

用户输入就是程序和用户的交互，程序等待用户输入一个参数然后重新继续进行：

#!/usr/bin/env python3

#Authe: Lucky.chen

#_[i]_coding:utf-8_[/i]_

 

name = input("Please enter your name:")

print ("[size=16]#",name,"[/size]#")

如上图所示，默认Python3下的input函数用户输入的所有东西都当做字符串处理，所以你输入的年龄希望它是整数类型，还需要int()一下。

在python2中input这个函数，用户默认输入的是什么格式的参数，Python就当作是什么类型处理，Python2中获取用户输入参数的函数还有一个叫做raw_input（），这个函数默认也是字符串处理。可以看出Python3为了简洁统一，在Python3中已经不存在了raw_input()函数，input()一个函数完全可以做到所有使用。

平常如果我们用针对密码、密码串之类的交互的话，一般用户的输入时隐藏或者*****的，输入密码时，在Python下如果你需要你输入的东西不可见，可以利用getpass 模块中的 getpass方法来处理：

#!/usr/bin/env python3

#Authe: Lucky.chen

#_[i]_coding:utf-8_[/i]_[/quote]



#导入getpass模块

import getpass



# 将用户输入的内容赋值给 name 变量

pwd = getpass.getpass("请输入密码：")

  

# 打印输入的内容

print("Password is [size=16]",pwd,"***print end")[/size]



#比如我输入110119，执行过程和结果如下：

请输入密码：

Password is [size=16] 110119 ***print end

[/size]

注释和拼接

注释：
单行注释：# 开头就好，跟shell一样
多行注释：成对的三个单引号 ''' 注释内容 ''' 或者成对的三个双引号 """ 注释内容 """

>>> ''' My name is lucky ''' 

' My name is lucky '

[quote]>> """ My age is 23 """

' My age is 23 '

>>> # Good Idea

... 

>>> msg = """ My info is :

... age: 23

... name: lucky

... job: IT"""

>>> print (msg)

 My info is :

age: 23

name: lucky

job: IT

>>>

拼接：
1、难受的 "+"

>>> name = "lucky"

>>> age = 23

>>> job = "IT"

>>> 

>>> msg = """ Info of """ +name + """

... Name:""" +name + """

... Age:""" +age + """

... Job:""" +job

Traceback (most recent call last):

  File "", line 4, in 

TypeError: Can't convert 'int' object to str implicitly

>>> 

>>> name = "lucky"

>>> age = "23"

>>> job = "IT"

>>> msg = """ Info of """ +name + """

... Name:""" +name + """

... Age:""" +age + """

... Job:""" +job

>>> print (msg)

 Info of lucky

Name:lucky

Age:23

Job:IT

>>>

如上所示 "+"拼接只能是字符串，如果是整型、或者是浮点都会报错。

2、百分号（%）
Code:

#!/usr/bin/env python3.5

#auther: lucky.chen[/quote]



name = input("Please input your name: ")

age = input("Please input your age:")

job = input("Please input your job:")

salary = input("Please input your salary:")



msg = """------------ info of %s

Name: %s

Age: %s

Job: %s

Salary: %s

""" % (name,name,age,job,salary)



print (msg)

Result:

Please input your name: lucky

Please input your age:23

Please input your job:IT

Please input your salary:40000

------------ info of lucky

Name: lucky

Age: 23

Job: IT

Salary: 40000

3、使用format函数
情况一：使用变量格式化
Code:

#!/usr/bin/env python3.5

#auther: lucky.chen



name = input("Please input your name: ")

age = input("Please input your age:")

job = input("Please input your job:")

salary = input("Please input your salary:")



msg = """------------ info of {_Name}

Name: {_Name}

Age: {_Age}

Job: {_Job}

Salary: {_Salary}

""".format(_Name=name,_Age=age,_Job=job,_Salary=salary)



print (msg)

Result:

Please input your name: crh

Please input your age:23

Please input your job:IT

Please input your salary:45000

------------ info of crh

Name: crh

Age: 23

Job: IT

Salary: 45000

情况二：使用下脚标

#!/usr/bin/env python3.5

#auther: lucky.chen



name = input('please input your name:')

age = input('please input your age:')

job = input('please input your job:')

salary = input('please input your salary:')

msg = '''

------------info of {0}-----------

Name: {0}

Age: {1}

Job: {2}

Salary: {3}

'''.format(name,age,job,salary)

print (msg)

Result:

please input your name:chenronghua

please input your age:23

please input your job:OPS

please input your salary:50000



------------info of chenronghua-----------

Name: chenronghua

Age: 23

Job: OPS

Salary: 50000

format是比较好的方式，有时候我们必须使用format方法，所以掌握了format就好。

流程控制

一、流程控制这里先介绍 if ...... else and if ...... elif ..... else

1、if ..... else（用户认证登录）
Code：

#!/usr/bin/env python3.5

#auther: lucky.chen



name = input("Please input your name:")

passwd = input("Please input your password:")



if name == "crh" and passwd == "123456":

    print (" \033[32mWelcome login OPS Management platform\033[0m ")

else:

    print ("\033[31mYour UserName or Password Error\033[0m")

Result:

Please input your name:crh

Please input your password:34

Your UserName or Password Error

2、if ..... elfi ...... else
Code:

#!/usr/bin/env python3.5

#auther: lucky.chen



age = int(input("Pleast input your age:"))



if age < 18:

    print (" \033[32m You're too young \033[0m ")

elif age > 18 and age < 30:

    print ("\033[31m You still have many chance comes at a time when youth waiting for you \033[0m")

else:

    print ("\033[33m Before you is too old to do \033[0m")

Result:

Pleast input your age:23

 You still have many chance comes at a time when youth waiting for you

二、for 循环遍历

#!/usr/bin/env python3.5

#auther: lucky.chen



for num in range(5):

    print ("loop is:",num)

    

# Result is:

loop is: 0

loop is: 1

loop is: 2

loop is: 3

loop is: 4

range函数也可以设置步长值，比如我们要打印出1-10中的所有偶数（默认步长为1）

#!/usr/bin/env python3.5

#auther: lucky.chen



for num in range(0,11,2):

    print ("loop is:",num)

    

# Result

loop is: 0

loop is: 2

loop is: 4

loop is: 6

loop is: 8

loop is: 10

除掉range函数我们还可以使用xrange函数，为什么要这里要介绍xrange呢，因为xrange相对于range来说性能比较优越，因为xrange不需要一上来就开辟一块很大的内存空间，具体可以参考我之前发布的文章：Python中xrange和range的异同 ,但是好像Python3.*中没有了xrange函数。

for...else...循环介绍，不止if中有else，在for循环中也是可以用else的，在for循环中的else就是当前面的循环正常执行完后，没有跳出，后面的else代码将被执行。

crh:Python crh$ cat for.py 

#!/usr/bin/env python3

#Auther: lucky.chen



for num in range(4):

    print ("Loop is:",num)

else:

    print ("normal")

crh:Python crh$ ./for.py 

Loop is: 0

Loop is: 1

Loop is: 2

Loop is: 3

normal

crh:Python crh$

crh:Python crh$ cat for.py 

#!/usr/bin/env python3

#Auther: lucky.chen



for num in range(4):

    if num > 2:

        break

    print ("Loop is:",num)

else:

    print ("normal")

crh:Python crh$ ./for.py 

Loop is: 0

Loop is: 1

Loop is: 2

crh:Python crh$

三、while循环遍历

while 循环它的原理是：当条件为真的时候运行，当条件为假的时候停止！没有一个规定次数，不设置条件就永远循环下去。

#!/usr/bin/env python3.5

#auther: lucky.chen



import time

count = 0

while True:

    count +=1

    print ("loop",count)

    time.sleep(3)

#这个循环3秒钟自+1后,无线循环只要这个条件为”真“，就无限循环下去

#!/usr/bin/env python3.5

#auther: lucky.chen



import time

num = 0



while num < 3:

    num +=1

    print ("Num is:",num)

    time.sleep(3)



#这个循环每3秒循环一次，当条件num < 3的时候为真（自己设置的条件），当num不小于3的时候为假(false)循环停止.

While ...... else

#!/usr/bin/env python3.5

#auther: lucky.chen



while 1:

    if num == 4:

        print ("I think stop")

        break

    print (num)

    num += 1

else:

    print ("stop")

四、break和continue介绍

break在循环中的作用是跳出所在的循环体，不在进行循环，而continue是跳出所在循环体中的本次循环，后续没有完的循环继续。

Code：

#!/usr/bin/env python3.5

#auther: lucky.chen



num = 1



print ("test break for loop start")

for n in range(5):

    if n == num:

        break

    print (n)



print ("\n")



print ("test continue for loop start")

for n in range(5):

    if n == num:

        continue

    print (n)

Result：

test break for loop start

0





test continue for loop start

0

2

3

4

猜数字游戏：

#!/usr/bin/env python3.5

#auther: lucky.chen



#load module (random)

import random



TryNum = 0

RandNum = random.randrange(10)

print (RandNum)





while TryNum < 3:

    GuessNum = int(input("请猜测从0到9之间的一个中奖数字:"))



    if GuessNum >= 10:

        print ("你输入的数字不在中奖号码范围内,请重新输入!")

        continue



    if GuessNum == RandNum:

        print ("恭喜你猜对了,你将获得小米电视一台!")

        break



    elif GuessNum > RandNum:

        print ("你猜的数字太大了可以再往小了猜")



    else:

        print ("你猜的数字太小了可以往大了猜")



    TryNum += 1



else:

    print ("不好意思你三次机会用完了,Game over!")



#先随机到0-9中筛选出以为数字,然后用户三次机会猜测一个中奖号码,如果用户输入的数字不在范围内,则让用户再次输入.

Result：

4

请猜测从0到9之间的一个中奖数字:11

你输入的数字不在中奖号码范围内,请重新输入!

请猜测从0到9之间的一个中奖数字:11

你输入的数字不在中奖号码范围内,请重新输入!

请猜测从0到9之间的一个中奖数字:11

你输入的数字不在中奖号码范围内,请重新输入!

请猜测从0到9之间的一个中奖数字:11

你输入的数字不在中奖号码范围内,请重新输入!

请猜测从0到9之间的一个中奖数字:2

你猜的数字太小了可以往大了猜

请猜测从0到9之间的一个中奖数字:5

你猜的数字太大了可以再往小了猜

请猜测从0到9之间的一个中奖数字:4

恭喜你猜对了,你将获得小米电视一台!

五、嵌套循环
While for:

#!/usr/bin/env python3.5

#auther: lucky.chen



count = 1



while count < 4:

    print("count var lt 4")



    print ("#########################[size=16]#")[/size]



    for n in range(3):

        print ("for num is:",n)



    print ("****************************")

    count += 1

Result:

count var lt 4

#########################[size=16]#[/size]

for num is: 0

for num is: 1

for num is: 2

****************************

count var lt 4

#########################[size=16]#[/size]

for num is: 0

for num is: 1

for num is: 2

****************************

count var lt 4

#########################[size=16]#[/size]

for num is: 0

for num is: 1

for num is: 2

****************************

死循环：

#!/usr/bin/env python3.5

#auther: lucky.chen

import time



while True:

    print ("One Loop")

    time.sleep(1)

    

    while True:

        print ("Two Loop")

        time.sleep(1)

        

        while True:

            print ("Three Loop")

            time.sleep(1)

#这是一个死循环,第一次执行这段code的时候,依次往下执行,单到了第三个while的时候,就一直是true,所以一直在执行第三个while下的code.



#结果如下:

One Loop

Two Loop

Three Loop

Three Loop

Three Loop

Three Loop

..........

..........

如上我们给出了一个死循环的例子，但是如果如果我们需要跳出循环应该怎么做，如果用break可以做到吗？
1、第一个while后加break分析

2、第二个while后加break分析

3、第三个while后加break分析

既然存在这种死循环的那我们有什么办法可以跳出呢？那就是打标志，标志位
Code：

#!/usr/bin/env python3.5

#auther: lucky.chen



count = 0

while True:

    print ("我是第一层")

    jump_1_flag = False



    while True:

        print ("我是第二层")

        jump_2_flag = False



        while True:

            count += 1

            print ("我是第三层")



            if count > 3:

                jump_2_flag = True

                break



        if jump_2_flag:

            print ("第三层跳到我这里来了，我也要跳到第一层")

            jump_1_flag = True

            break



    if jump_1_flag:

        print ("第二层和第三层跳到第一层了，我也要跳")

        break

分析和结果：

Python input和raw_input的区别

空心菜发表了文章 1 个评论 4321 次浏览 2015-12-14 23:18 来自相关话题

使用input和raw_input都可以读取控制台的输入，但是input和raw_input在处理数字时是有区别的纯数字输入当输入为纯数字时 []input返回的是数值类型，如int,floa ...查看全部

使用input和raw_input都可以读取控制台的输入，但是input和raw_input在处理数字时是有区别的

纯数字输入

当输入为纯数字时

]input返回的是数值类型，如int,float[/

]raw_inpout返回的是字符串类型，string类型[/

输入字符串为表达式

input会计算在字符串中的数字表达式，而raw_input不会。
如输入 "57 + 3":
input会得到整数60
raw_input会得到字符串"57 + 3"

输入字符串结果如下：

通过上面的实验我们知道input它会根据用户输入变换相应的类型,而且如果要输入字符和字符串的时候必须要用引号包起来,而raw_input则是不管用户输入什么类型的都会转变成字符型.

python input的实现

看python input的文档，你可以发现input其实是通过raw_input来实现的，原理很简单，就下面一行代码：

def input(prompt):

    return (eval(raw_input(prompt)))

Python在生产环境都可以用来做什么？

贡献

koyo 回复了问题 2 人关注 3 个回复 7184 次浏览 2015-12-14 14:45 来自相关话题

为什么越来越多人喜欢全栈式开发语言 – Python

push 发表了文章 1 个评论 6000 次浏览 2015-11-29 20:12 来自相关话题

前段时间，ThoughtWorks在深圳举办一次社区活动上，有一个演讲主题叫做“Fullstack JavaScript”，是关于用JavaScript进行前端、服务器端，甚至数据库（MongoDB）开发，一个Web应用开发人员，只需要学会一门语言，就可以实现 ...查看全部

前段时间，ThoughtWorks在深圳举办一次社区活动上，有一个演讲主题叫做“Fullstack JavaScript”，是关于用JavaScript进行前端、服务器端，甚至数据库（MongoDB）开发，一个Web应用开发人员，只需要学会一门语言，就可以实现整个应用。

受此启发，我发现Python可以称为大数据全栈式开发语言。因为Python在云基础设施，DevOps，大数据处理等领域都是炙手可热的语言。

就像只要会JavaScript就可以写出完整的Web应用，只要会Python，就可以实现一个完整的大数据处理平台。

云基础设施

这年头，不支持云平台，不支持海量数据，不支持动态伸缩，根本不敢说自己是做大数据的，顶多也就敢跟人说是做商业智能（BI）。

云平台分为私有云和公有云。私有云平台如日中天的OpenStack，就是Python写的。曾经的追赶者CloudStack，在刚推出时大肆强调自己是Java写的，比Python有优势。结果，搬石砸脚，2015年初，CloudStack的发起人Citrix宣布加入OpenStack基金会，CloudStack眼看着就要寿终正寝。

如果嫌麻烦不想自己搭建私有云，用公有云，不论是AWS，GCE，Azure，还是阿里云，青云，在都提供了Python SDK，其中GCE只提供Python和JavaScript的SDK，而青云只提供Python SDK。可见各家云平台对Python的重视。

提到基础设施搭建，不得不提Hadoop，在今天，Hadoop因为其MapReduce数据处理速度不够快，已经不再作为大数据处理的首选，但是HDFS和Yarn——Hadoop的两个组件——倒是越来越受欢迎。Hadoop的开发语言是Java，没有官方提供Python支持，不过有很多第三方库封装了Hadoop的API接口（pydoop，hadoopy等等）。

Hadoop MapReduce的替代者，是号称快上100倍的Spark，其开发语言是Scala，但是提供了Scala，Java，Python的开发接口，想要讨好那么多用Python开发的数据科学家，不支持Python，真是说不过去。HDFS的替代品，比如GlusterFS，Ceph等，都是直接提供Python支持。Yarn的替代者，Mesos是C++实现，除C++外，提供了Java和Python的支持包。

DevOps

DevOps有个中文名字，叫做开发自运维。互联网时代，只有能够快速试验新想法，并在第一时间，安全、可靠的交付业务价值，才能保持竞争力。DevOps推崇的自动化构建/测试/部署，以及系统度量等技术实践，是互联网时代必不可少的。

自动化构建是因应用而易的，如果是Python应用，因为有setuptools, pip, virtualenv, tox, flake8等工具的存在，自动化构建非常简单。而且，因为几乎所有Linux系统都内置Python解释器，所以用Python做自动化，不需要系统预安装什么软件。

自动化测试方面，基于Python的Robot Framework企业级应用最喜欢的自动化测试框架，而且和语言无关。Cucumber也有很多支持者，Python对应的Lettuce可以做到完全一样的事情。Locust在自动化性能测试方面也开始受到越来越多的关注。

自动化配置管理工具，老牌的如Chef和Puppet，是Ruby开发，目前仍保持着强劲的势头。不过，新生代Ansible和SaltStack——均为Python开发——因为较前两者设计更为轻量化，受到越来越多开发这的欢迎，已经开始给前辈们制造了不少的压力。

在系统监控与度量方面，传统的Nagios逐渐没落，新贵如Sensu大受好评，云服务形式的New Relic已经成为创业公司的标配，这些都不是直接通过Python实现的，不过Python要接入这些工具，并不困难。

除了上述这些工具，基于Python，提供完整DevOps功能的PaaS平台，如Cloudify和Deis，虽未成气候，但已经得到大量关注。

网络爬虫

大数据的数据从哪里来？除了部分企业有能力自己产生大量的数据，大部分时候，是需要靠爬虫来抓取互联网数据来做分析。

网络爬虫是Python的传统强势领域，最流行的爬虫框架Scrapy，HTTP工具包urlib2，HTML解析工具beautifulsoup，XML解析器lxml，等等，都是能够独当一面的类库。

不过，网络爬虫并不仅仅是打开网页，解析HTML这么简单。高效的爬虫要能够支持大量灵活的并发操作，常常要能够同时几千甚至上万个网页同时抓取，传统的线程池方式资源浪费比较大，线程数上千之后系统资源基本上就全浪费在线程调度上了。Python由于能够很好的支持协程（Coroutine）操作，基于此发展起来很多并发库，如Gevent，Eventlet，还有Celery之类的分布式任务框架。被认为是比AMQP更高效的ZeroMQ也是最早就提供了Python版本。有了对高并发的支持，网络爬虫才真正可以达到大数据规模。

抓取下来的数据，需要做分词处理，Python在这方面也不逊色，著名的自然语言处理程序包NLTK，还有专门做中文分词的Jieba，都是做分词的利器。

数据处理

万事俱备，只欠东风。这东风，就是数据处理算法。从统计理论，到数据挖掘，机器学习，再到最近几年提出来的深度学习理论，数据科学正处于百花齐放的时代。数据科学家们都用什么编程？

如果是在理论研究领域，R语言也许是最受数据科学家欢迎的，但是R语言的问题也很明显，因为是统计学家们创建了R语言，所以其语法略显怪异。而且R语言要想实现大规模分布式系统，还需要很长一段时间的工程之路要走。所以很多公司使用R语言做原型试验，算法确定之后，再翻译成工程语言。

Python也是数据科学家最喜欢的语言之一。和R语言不同，Python本身就是一门工程性语言，数据科学家用Python实现的算法，可以直接用在产品中，这对于大数据初创公司节省成本是非常有帮助的。正式因为数据科学家对Python和R的热爱，Spark为了讨好数据科学家，对这两种语言提供了非常好的支持。

Python的数据处理相关类库非常多。高性能的科学计算类库NumPy和SciPy，给其他高级算法打了非常好的基础，matploglib让Python画图变得像Matlab一样简单。Scikit-learn和Milk实现了很多机器学习算法，基于这两个库实现的Pylearn2，是深度学习领域的重要成员。Theano利用GPU加速，实现了高性能数学符号计算和多维矩阵计算。当然，还有Pandas，一个在工程领域已经广泛使用的大数据处理类库，其DataFrame的设计借鉴自R语言，后来又启发了Spark项目实现了类似机制。

对了，还有iPython，这个工具如此有用，以至于我差点把他当成标准库而忘了介绍。iPython是一个交互式Python运行环境，能够实时看到每一段Python代码的结果。默认情况下，iPython运行在命令行，可以执行ipython notebook在网页中运行。用matplotlib绘制的图可以直接嵌入式的显示在iPython Notebook中。
iPython Notebook的笔记本文件可以共享给其他人，这样其他人就可以在自己的环境中重现你的工作成果；如果对方没有运行环境，还可以直接转换成HTML或者PDF。

为什么是Python

正是因为应用开发工程师、运维工程师、数据科学家都喜欢Python，才使得Python成为大数据系统的全栈式开发语言。

对于开发工程师而言，Python的优雅和简洁无疑是最大的吸引力，在Python交互式环境中，执行import this，读一读Python之禅，你就明白Python为什么如此吸引人。Python社区一直非常有活力，和NodeJS社区软件包爆炸式增长不同，Python的软件包增长速度一直比较稳定，同时软件包的质量也相对较高。有很多人诟病Python对于空格的要求过于苛刻，但正是因为这个要求，才使得Python在做大型项目时比其他语言有优势。OpenStack项目总共超过200万行代码，证明了这一点。

对于运维工程师而言，Python的最大优势在于，几乎所有Linux发行版都内置了Python解释器。Shell虽然功能强大，但毕竟语法不够优雅，写比较复杂的任务会很痛苦。用Python替代Shell，做一些复杂的任务，对运维人员来说，是一次解放。

对于数据科学家而言，Python简单又不失强大。和C/C++相比，不用做很多的底层工作，可以快速进行模型验证；和Java相比，Python语法简洁，表达能力强，同样的工作只需要1/3代码；和Matlab，Octave相比，Python的工程成熟度更高。不止一个编程大牛表达过，Python是最适合作为大学计算机科学编程课程使用的语言——MIT的计算机入门课程就是使用的Python——因为Python能够让人学到编程最重要的东西——如何解决问题。

顺便提一句，微软参加2015年PyCon，高调宣布提高Python在Windows上的编程体验，包括Visual Studio支持Python，优化Python的C扩展在Windows上的编译等等。脑补下未来Python作为Windows默认组件的场景。

内容来源：ThoughtWorks洞见
分享阅读：http://insights.thoughtworkers.org/full-stack-python/

通知设置 新通知

编程

Python的发展趋势

一、Python发展历史

二、Python的前景

三、Python的应用领域

目前Python主要的应用领域

哪些公司在用Python

为什么是Python而不是其他语言呢？

C 和 Python、Java、C#等

Python和C Python这门语言是由C开发而来

Python 和 Java、C#等

Python和PHP相比

Go进阶笔记-微服务概览与治理

微服务定义

什么是微服务？

微服务的优缺点

组件化服务

区中心化

基础设施自动化

硬件层架构

可用性 & 兼容性设计

微服务设计

API Gateway

Mircoservice划分

什么是CQRS

Mircoservice安全

gRPC && 服务发现

Health Check

服务发现

多集群 & 多租户

多租户

小结

图解Python 集合

Python菜鸟之路基础篇(一)

Python input和raw_input的区别

Python在生产环境都可以用来做什么？

为什么越来越多人喜欢全栈式开发语言 – Python

热门话题

热门用户

OpenSkill 专业的开源技术学习问答平台

通知设置新通知

Python和C Python这门语言是由C开发而来　