当前位置:首页 > Python >
《Python机器学习算法》电子书封面

Python机器学习算法

  • 发布时间:2019年04月12日 13:52:06
  • 作者:赵志勇
  • 大小:30.1 MB
  • 类别:机器学习电子书
  • 格式:PDF
  • 版本:原书扫描版
  • 评分:9.3

    Python机器学习算法 PDF 原书扫描版

      给大家带来的一篇关于机器学习相关的电子书资源,介绍了关于Python、机器学习、算法方面的内容,本书是由电子工业出版社出版,格式为PDF,资源大小30.1 MB,赵志勇编写,目前豆瓣、亚马逊、当当、京东等电子书综合评分为:9.7分

      Tags:python 算法 机器学习 

      内容介绍

      书还可以,对机器学习的解释比较到位,速度也很快

      这本书采用python3对决策树、集成学习、SVM和神经网络做了一个i详细的讲解和编程的实现。我觉得这本书比较好的一点在于对每一种算法都有了一个比较详细的解释

      探索数据的内在价值,洞悉人工智能背后的技术!

      精彩书评

      在人工智能时代,机器学习已经成了互联网从业人员和在校学生的一门必修课。市场上不乏机器学习相关的书籍,但大都晦涩难懂而缺乏应用场景。本书是作者在新浪微博广告业务上一手的实践经验和心得体会,具有实用性,非常适合于对机器学习感兴趣但没有经验的开发人员,和渴望了解“理论知识如何在业务中应用”的在校学生,相信你们一定可以从中找到想要的答案。——新浪微博高级技术经理 姜贵彬

      本书没有使用高深复杂的数学逻辑来解释机器学习,而是从直观简洁的介绍入手,通俗易懂,再辅助于代码实现帮助读者理解算法细节,是机器学习入门一本不可多得的好书,推荐。——百度资深技术专家 毛钦

      本书从具体的代码开始去理解抽象的算法,给读者一种脚踏实地的感觉,推荐给所有工程出身有志于算法的工程师。——阿里妈妈算法工程技术专家 易慧民

      本书对常用的机器学习算法进行了深入和全面的介绍,书中大量的代码清单令人印象尤为深刻,确实是一本实用易懂、快速入门的好书。——美团·大众点评资深技术专家 潘文彬

      内容简介

      《Python机器学习算法》是一本机器学习入门读物,注重理论与实践的结合。全书主要包括6个部分,每个部分均以典型的机器学习算法为例,从算法原理出发,由浅入深,详细介绍算法的理论,并配合目前流行的Python语言,从零开始,实现每一个算法,以加强对机器学习算法理论的理解、增强实际的算法实践能力,最终达到熟练掌握每一个算法的目的。与其他机器学习类图书相比,《Python机器学习算法》同时包含算法理论的介绍和算法的实践,以理论支撑实践,同时,又将复杂、枯燥的理论用简单易懂的形式表达出来,促进对理论的理解。

      写作历程

      机器学习的黄金时间

      近年来,人工智能AI技术的快速发展,得益于越来越多的人工智能人才的涌入和计算机硬件以及软件技术的不断发展。机器学习是人工智能AI的中一个重要的方向,在机器学习的发展过程中,越来越多的人投身于机器学习的研究中,同时,越来越多的互联网公司加入到人工智能的行列,“人工智能”一词也成为妇孺皆知的名词,这正是人工智能发展的黄金时间,同样,机器学习算法作为人工智能中的核心方法,也是发展的一个黄金时间。

      机器学习中的常用算法

      在机器学习的发展过程中出现了很多优秀的机器学习算法,主要可以从监督学习,无监督学习以及半监督学习的角度对其进行划分。

      监督学习(Supervised Learning)是指利用训练样本,包括数据特征和数据标签,训练出一个模型,并利用训练好的模型,对未知数据进行预测。常用的监督学习问题包括分类和回归,其中,分类问题的标签是离散的值,而回归问题的标签是一系列连续的值。常见的监督学习有:Logistic Regression算法,支持向量机SVM算法,BP神经网络算法,线性回归,Lasso,GBDT,随机森林等。
      无监督学习(Unsupervised Learning)是指事先没有训练样本,我们需要直接对数据进行建模。常见的无监督问题包括聚类。常见的无监督学习有:KMeans算法,Mean Shift算法,DBSCAN算法等。
      在发展的过程中,人们不断提出一些新的算法和模型,深度学习(Deep Learning)的概念便是在这个过程中被提出,深度学习通过构建深层神经网络模型,学习到输入数据的更抽象的表示,以此达到特征学习的功能,更大程度上提高了模型的学习能力。深度学习的成功成为机器学习乃至人工智能发展史上光辉的一笔。常见的深度学习模型包括:自编码器Auto-encoder,深度信念网DBN,卷积神经网络CNN,递归神经网络RNN以及LSTM等。

      机器学习的常用框架

      现在是机器学习发展的一个黄金时间,越来越多的研究人员和越来越多的公司参与到机器学习的研究和算法的开发过程中,因此,出现了很多开源的机器学习算法实现以及机器学习的算法框架,下面我们罗列一些常见的框架以及开源实现:

      TensorFlow。TensorFlow当属现在最火的深度学习框架。TensorFlow最初由Google Brain小组(该小组隶属于Google’s Machine Intelligence研究机构)的研究员和工程师开发出来的,开发目的是用于进行机器学习和深度神经网络的研究。
      Scikit-Learn。Scikit-Learn是用于机器学习的Python 模块,它建立在SciPy之上。该项目由David Cournapeau 于2007年创立,当时项目名为Google Summer of Code,自此之后,众多志愿者都为此做出了贡献。
      Caffe。Caffe 是由神经网络中的表达式、速度、及模块化产生的深度学习框架,是一个基于C++/CUDA架构框架,开发者能够利用它自由的组织网络,目前支持卷积神经网络和全连接神经网络(人工神经网络)。
      Keras。Keras是极其精简并高度模块化的神经网络库,在TensorFlow 或 Theano 上都能够运行,是一个高度模块化的神经网络库,支持GPU和CPU运算。
      ConvNetJS。ConvNetJS是利用Javascript实现的神经网络,同时还具有非常不错的基于浏览器的Demo。它最重要的用途是帮助深度学习初学者更快、更直观的理解算法。
      Theano。Theano是一个Python库,它允许使用者有效地定义、优化和评估涉及多维数组的数学表达式,同时支持GPUs和高效符号分化操作。
      MXNet。MXNet是一个兼具效率和灵活性的深度学习框架。它允许使用者将符号编程和命令式编程相结合,以追求效率和生产力的最大化。
      Vowpal Wabbit。Vowpal Wabbit是一个机器学习系统,该系统推动了如在线、散列、Allreduce、Learning2search、等方面机器学习前沿技术的发展。
      XGBoot。XGBoot是设计为高效、灵活、可移植的优化分布式梯度 Boosting库。它实现了 Gradient Boosting 框架下的机器学习算法。XGBoost通过提供并行树Boosting(也被称为GBDT、GBM),以一种快速且准确的方式解决了许多数据科学问题。
      除了上述的各种框架,还有一些开源的代码,如libSVM,libFM等等。

      开始写博客

      互联网技术的发展为我们的学习和生活提供了很多的便利,我们可以在互联网获取到大量的学习材料,可以和技术达人,学术牛人探讨各种技术问题。

      在读研究生的时候,我有幸接触机器学习。刚开始接触机器学习时,抱着对各种机器学习算法的敬畏以及对知识的渴求,我努力去学习各种算法,包括聚类算法,分类算法等。在学习的过程中,我翻阅了机器学习领域的一些书,包括《pattern recognition and machine learning》(即PRML),《Machine Learning》,《集体智慧编程》,周志华老师的《机器学习》(即俗称的西瓜书),《机器学习实战》,李航老师的《统计机器学习》以及《推荐系统实战》等等。从这些书中,我学到了很多机器学习方面的知识,通过学习,我也渐渐对机器学习领域有了较为清晰的认识。

      计算机学科是一门实践性较强的学科,任何一门语言或者任何一个算法,通过对算法的实现,能够加深对算法的理解,同时,算法的设计是为了解决实际的问题,只有在实践的过程中,才能更好的解决实际的问题。

      因此,在学习的过程中,一方面学习机器学习的理论知识,另一方面通过具体的数据集,实践每一个算法。俗话说:独学而无友,则孤陋而寡闻。在掌握了部分算法后,我打算把我的学习过程分享出来,比较好的方式就是组织学习的小组,但是一些现实因素的限制,我决定通过写博客的方式将我的笔记写出来,一开始写博客,我打算能够记录出学习机器学习算法的具体过程,因此,我给自己的文章建了一个响亮的标题《简单易学的机器学习算法》(写着写着,发现想要说明白也不是那么简单)。

      在此过程中,微博上也出现了很多大牛在分享各种学习资料,我也不断转发这些材料,并在事后不断学习,还为此做了一个话题:

      开始写《Python机器学习算法》

      能够写出一本书是很多人的理想,我也不例外,在此,我得感谢博文视点的符隆美编辑,多次鼓励我写书,才有我开始动手写这本书。

      正如上面所说,我积累了大量的算法,以及自己对算法的实现,期间编辑与我联系,希望我能够将自己的稿子整理出来出一本书,刚开始的时候,我是拒绝的,我总觉得自己的能力还不足以将一个算法解释清楚,更别说出一本书,同时,市场上机器学习方面的书实在是多,如:1、《机器学习实战》。这真是一本好书,让很多初学者可以入门,同时提供了很多实践的机会,真是一本实战的好书。2、李航老师的《统计机器学习》。这是一本理论上很全的书。3、周志华老师的西瓜书《机器学习》。周老师是机器学习方面的专家,这本书得到了很多人的认可,无论是知识的全面性,还是对机器学习理论的解释,都体现出了周老师学识的渊博。4、还有一些经典的专注,如《PRML》等等还有很多。以上说的这些书是大家谈论比较多的,同时,还有一些其他的课程,如斯坦福的教程等等,无一不是学习的好材料。那究竟写些什么呢,在博客中的文章还是浅显,而且过于零散。

      (以上分割线表示经过了一段时间的思考)

      经过半个月时间的思考,决定写一些典型的算法,因为有些算法在我实际的工作中也经常被用到。在讲解算法的基本原理的同时,配上实验的代码,从聚类算法,分类算法,回归算法,推荐算法到深度学习,希望尽可能涉及到机器学习的大部分算法,同时,介绍了在实际中使用这其中某些算法的一个例子。

      最终决定写一本机器学习入门读物,注重理论与实践的结合。在最终定稿时,全书一共包括6个部分,每个部分均以典型的机器学习算法为例,从算法原理出发,由浅入深,详细介绍算法的理论,并配合目前流行的Python语言,从零开始,实现每一个算法,以加强对机器学习算法理论的理解、增强实际的算法实践能力。

      目录

      • 0绪论1
      • 0.1机器学习基础1
      • 0.1.1机器学习的概念1
      • 0.1.2机器学习算法的分类2
      • 0.2监督学习3
      • 0.2.1监督学习3
      • 0.2.2监督学习的流程3
      • 0.2.3监督学习算法4
      • 0.3无监督学习4
      • 0.3.1无监督学习4
      • 0.3.2无监督学习的流程4
      • 0.3.3无监督学习算法5
      • 0.4推荐系统和深度学习6
      • 0.4.1推荐系统6
      • 0.4.2深度学习6
      • 0.5Python和机器学习算法实践6
      • 参考文献7
      • 第一部分分类算法
      • 1Logistic Regression10
      • 1.1Logistic Regression模型10
      • 1.1.1线性可分VS线性不可分10
      • 1.1.2Logistic Regression模型11
      • 1.1.3损失函数13
      • 1.2梯度下降法14
      • 1.2.1梯度下降法的流程14
      • 1.2.2凸优化与非凸优化15
      • 1.2.3利用梯度下降法训练Logistic Regression模型17
      • 1.3梯度下降法的若干问题18
      • 1.3.1选择下降的方向18
      • 1.3.2步长的选择19
      • 1.4Logistic Regression算法实践20
      • 1.4.1利用训练样本训练Logistic Regression模型20
      • 1.4.2最终的训练效果22
      • 1.4.3对新数据进行预测23
      • 参考文献26
      • 2Softmax Regression27
      • 2.1多分类问题27
      • 2.2Softmax Regression算法模型28
      • 2.2.1Softmax Regression模型28
      • 2.2.2Softmax Regression算法的代价函数28
      • 2.3Softmax Regression算法的求解29
      • 2.4Softmax Regression与Logistic Regression的关系31
      • 2.4.1Softmax Regression中的参数特点31
      • 2.4.2由Softmax Regression到Logistic Regression31
      • 2.5Softmax Regression算法实践32
      • 2.5.1对Softmax Regression算法的模型进行训练33
      • 2.5.2最终的模型34
      • 2.5.3对新的数据的预测35
      • 参考文献39
      • 3Factorization Machine40
      • 3.1Logistic Regression算法的不足40
      • 3.2因子分解机FM的模型42
      • 3.2.1因子分解机FM模型42
      • 3.2.2因子分解机FM可以处理的问题43
      • 3.2.3二分类因子分解机FM算法的损失函数43
      • 3.3FM算法中交叉项的处理43
      • 3.3.1交叉项系数43
      • 3.3.2模型的求解44
      • 3.4FM算法的求解45
      • 3.4.1随机梯度下降(Stochastic Gradient Descent)45
      • 3.4.2基于随机梯度的方式求解45
      • 3.4.3FM算法流程46
      • 3.5因子分解机FM算法实践49
      • 3.5.1训练FM模型50
      • 3.5.2最终的训练效果53
      • 3.5.3对新的数据进行预测55
      • 参考文献57
      • 4支持向量机58
      • 4.1二分类问题58
      • 4.1.1二分类的分隔超平面58
      • 4.1.2感知机算法59
      • 4.1.3感知机算法存在的问题61
      • 4.2函数间隔和几何间隔61
      • 4.2.1函数间隔62
      • 4.2.2几何间隔62
      • 4.3支持向量机63
      • 4.3.1间隔最大化63
      • 4.3.2支持向量和间隔边界64
      • 4.3.3线性支持向量机65
      • 4.4支持向量机的训练66
      • 4.4.1学习的对偶算法66
      • 4.4.2由线性支持向量机到非线性支持向量机68
      • 4.4.3序列最小最优化算法SMO69
      • 4.5支持向量机SVM算法实践74
      • 4.5.1训练SVM模型74
      • 4.5.2利用训练样本训练SVM模型81
      • 4.5.3利用训练好的SVM模型对新数据进行预测85
      • 参考文献88
      • 5随机森林89
      • 5.1决策树分类器89
      • 5.1.1决策树的基本概念89
      • 5.1.2选择最佳划分的标准91
      • 5.1.3停止划分的标准94
      • 5.2CART分类树算法95
      • 5.2.1CART分类树算法的基本原理95
      • 5.2.2CART分类树的构建95
      • 5.2.3利用构建好的分类树进行预测98
      • 5.3集成学习(Ensemble Learning)99
      • 5.3.1集成学习的思想99
      • 5.3.2集成学习中的典型方法99
      • 5.4随机森林(Random Forests)101
      • 5.4.1随机森林算法模型101
      • 5.4.2随机森林算法流程102
      • 5.5随机森林RF算法实践104
      • 5.5.1训练随机森林模型105
      • 5.5.2最终的训练结果109
      • 5.5.3对新数据的预测110
      • 参考文献113
      • 6BP神经网络114
      • 6.1神经元概述114
      • 6.1.1神经元的基本结构114
      • 6.1.2激活函数115
      • 6.2神经网络模型116
      • 6.2.1神经网络的结构116
      • 6.2.2神经网络中的参数说明117
      • 6.2.3神经网络的计算117
      • 6.3神经网络中参数的求解118
      • 6.3.1神经网络损失函数118
      • 6.3.2损失函数的求解119
      • 6.3.3BP神经网络的学习过程120
      • 6.4BP神经网络中参数的设置126
      • 6.4.1非线性变换126
      • 6.4.2权重向量的初始化126
      • 6.4.3学习率127
      • 6.4.4隐含层节点的个数127
      • 6.5BP神经网络算法实践127
      • 6.5.1训练BP神经网络模型128
      • 6.5.2最终的训练效果132
      • 6.5.3对新数据的预测133
      • 参考文献136
      • 第二部分回归算法
      • 7线性回归138
      • 7.1基本线性回归138
      • 7.1.1线性回归的模型138
      • 7.1.2线性回归模型的损失函数139
      • 7.2线性回归的最小二乘解法140
      • 7.2.1线性回归的最小二乘解法140
      • 7.2.2广义逆的概念141
      • 7.3牛顿法141
      • 7.3.1基本牛顿法的原理141
      • 7.3.2基本牛顿法的流程142
      • 7.3.3全局牛顿法142
      • 7.3.4Armijo搜索144
      • 7.3.5利用全局牛顿法求解线性回归模型145
      • 7.4利用线性回归进行预测146
      • 7.4.1训练线性回归模型147
      • 7.4.2最终的训练结果149
      • 7.4.3对新数据的预测150
      • 7.5局部加权线性回归152
      • 7.5.1 局部加权线性回归模型152
      • 7.5.2局部加权线性回归的最终结果153
      • 参考文献154
      • 8岭回归和Lasso回归155
      • 8.1线性回归存在的问题155
      • 8.2岭回归模型156
      • 8.2.1岭回归模型156
      • 8.2.2岭回归模型的求解156
      • 8.3Lasso回归模型157
      • 8.4拟牛顿法158
      • 8.4.1拟牛顿法158
      • 8.4.2BFGS校正公式的推导158
      • 8.4.3BFGS校正的算法流程159
      • 8.5L-BFGS求解岭回归模型162
      • 8.5.1BGFS算法存在的问题162
      • 8.5.2L-BFGS算法思路162
      • 8.6岭回归对数据的预测165
      • 8.6.1训练岭回归模型166
      • 8.6.2最终的训练结果168
      • 8.6.3利用岭回归模型预测新的数据168
      • 参考文献171
      • 9CART树回归172
      • 9.1复杂的回归问题172
      • 9.1.1线性回归模型172
      • 9.1.2局部加权线性回归173
      • 9.1.3CART算法174
      • 9.2CART回归树生成175
      • 9.2.1CART回归树的划分175
      • 9.2.2CART回归树的构建177
      • 9.3CART回归树剪枝179
      • 9.3.1前剪枝179
      • 9.3.2后剪枝180
      • 9.4CART回归树对数据预测180
      • 9.4.1利用训练数据训练CART回归树模型180
      • 9.4.2最终的训练结果182
      • 9.4.3利用训练好的CART回归树模型对新的数据预测185
      • 参考文献187
      • 第三部分聚类算法
      • 10K-Means190
      • 10.1相似性的度量190
      • 10.1.1闵可夫斯基距离191
      • 10.1.2曼哈顿距离191
      • 10.1.3欧氏距离191
      • 10.2K-Means算法原理192
      • 10.2.1K-Means算法的基本原理192
      • 10.2.2K-Means算法步骤193
      • 10.2.3K-Means算法与矩阵分解193
      • 10.3K-Means算法实践195
      • 10.3.1导入数据196
      • 10.3.2初始化聚类中心197
      • 10.3.3聚类过程198
      • 10.3.4最终的聚类结果199
      • 10.4K-Means++算法200
      • 10.4.1K-Means算法存在的问题200
      • 10.4.2K-Means++算法的基本思路202
      • 10.4.3K-Means++算法的过程和最终效果204
      • 参考文献205
      • 11Mean Shift206
      • 11.1Mean Shift向量206
      • 11.2核函数207
      • 11.3Mean Shift算法原理209
      • 11.3.1引入核函数的Mean Shift向量209
      • 11.3.2Mean Shift算法的基本原理210
      • 11.4Mean Shift算法的解释212
      • 11.4.1概率密度梯度212
      • 11.4.2Mean Shift向量的修正213
      • 11.4.3Mean Shift算法流程213
      • 11.5Mean Shift算法实践217
      • 11.5.1Mean Shift的主过程218
      • 11.5.2Mean Shift的最终聚类结果219
      • 参考文献221
      • 12DBSCAN222
      • 12.1基于密度的聚类222
      • 12.1.1基于距离的聚类算法存在的问题222
      • 12.1.2基于密度的聚类算法225
      • 12.2DBSCAN算法原理225
      • 12.2.1DBSCAN算法的基本概念225
      • 12.2.2DBSCAN算法原理227
      • 12.2.3DBSCAN算法流程228
      • 12.3DBSCAN算法实践231
      • 12.3.1DBSCAN算法的主要过程232
      • 12.3.2Mean Shift的最终聚类结果234
      • 参考文献236
      • 13Label Propagation237
      • 13.1社区划分237
      • 13.1.1社区以及社区划分237
      • 13.1.2社区划分的算法238
      • 13.1.3社区划分的评价标准239
      • 13.2Label Propagation算法原理239
      • 13.2.1Label Propagation算法的基本原理239
      • 13.2.2标签传播240
      • 13.2.3迭代的终止条件242
      • 13.3Label Propagation算法过程244
      • 13.4Label Propagation算法实践244
      • 13.4.1导入数据245
      • 13.4.2社区的划分246
      • 13.4.3最终的结果247
      • 参考文献248
      • 第四部分推荐算法
      • 14协同过滤算法250
      • 14.1推荐系统的概述250
      • 14.1.1推荐系统250
      • 14.1.2推荐问题的描述251
      • 14.1.3推荐的常用方法251
      • 14.2基于协同过滤的推荐252
      • 14.2.1协同过滤算法概述252
      • 14.2.2协同过滤算法的分类252
      • 14.3相似度的度量方法253
      • 14.3.1欧氏距离254
      • 14.3.2皮尔逊相关系数(Pearson Correlation)254
      • 14.3.3余弦相似度254
      • 14.4基于协同过滤的推荐算法256
      • 14.4.1基于用户的协同过滤算法256
      • 14.4.2基于项的协同过滤算法258
      • 14.5利用协同过滤算法进行推荐260
      • 14.5.1导入用户-商品数据260
      • 14.5.2利用基于用户的协同过滤算法进行推荐261
      • 14.5.3利用基于项的协同过滤算法进行推荐262
      • 参考文献264
      • 15基于矩阵分解的推荐算法265
      • 15.1矩阵分解265
      • 15.2基于矩阵分解的推荐算法266
      • 15.2.1损失函数266
      • 15.2.2损失函数的求解266
      • 15.2.3加入正则项的损失函数即求解方法267
      • 15.2.4预测269
      • 15.3利用矩阵分解进行推荐270
      • 15.3.1利用梯度下降对用户商品矩阵分解和预测270
      • 15.3.2最终的结果272
      • 15.4非负矩阵分解273
      • 15.4.1非负矩阵分解的形式化定义274
      • 15.4.2损失函数274
      • 15.4.3优化问题的求解274
      • 15.5利用非负矩阵分解进行推荐277
      • 15.5.1利用乘法规则进行分解和预测277
      • 15.5.2最终的结果278
      • 参考文献279
      • 16基于图的推荐算法280
      • 16.1二部图与推荐算法280
      • 16.1.1二部图280
      • 16.1.2由用户商品矩阵到二部图281
      • 16.2PageRank算法282
      • 16.2.1PageRank算法的概念282
      • 16.2.2PageRank的两个假设283
      • 16.2.3PageRank的计算方法283
      • 16.3PersonalRank算法285
      • 16.3.1PersonalRank算法原理285
      • 16.3.2PersonalRank算法的流程286
      • 16.4利用PersonalRank算法进行推荐288
      • 16.4.1利用PersonalRank算法进行推荐288
      • 16.4.2最终的结果291
      • 参考文献291
      • 第五部分深度学习
      • 17AutoEncoder294
      • 17.1多层神经网络294
      • 17.1.1三层神经网络模型294
      • 17.1.2由三层神经网络到多层神经网络295
      • 17.2AutoEncoder模型296
      • 17.2.1AutoEncoder模型结构296
      • 17.2.2AutoEncoder的损失函数297
      • 17.3降噪自编码器Denoising AutoEncoder298
      • 17.3.1Denoising AutoEncoder原理298
      • 17.3.2Denoising AutoEncoder实现299
      • 17.4利用Denoising AutoEncoders构建深度网络302
      • 17.4.1无监督的逐层训练302
      • 17.4.2有监督的微调303
      • 17.5利用TensorFlow实现Stacked Denoising AutoEncoders306
      • 17.5.1训练Stacked Denoising AutoEncoders模型306
      • 17.5.2训练的过程307
      • 参考文献308
      • 18卷积神经网络309
      • 18.1传统神经网络模型存在的问题309
      • 18.2卷积神经网络311
      • 18.2.1卷积神经网络中的核心概念311
      • 18.2.2卷积神经网络模型312
      • 18.3卷积神经网络的求解313
      • 18.3.1卷积层(Convolution Layer)313
      • 18.3.2下采样层(Sub-Sampling Layer)316
      • 18.3.3全连接层(Fully-Connected Layer)316
      • 18.4利用TensorFlow实现CNN316
      • 18.4.1CNN的实现316
      • 18.4.2训练CNN模型320
      • 18.4.3训练的过程321
      • 参考文献321
      • 第六部分项目实践
      • 19微博精准推荐324
      • 19.1精准推荐324
      • 19.1.1精准推荐的项目背景324
      • 19.1.2精准推荐的技术架构325
      • 19.1.3离线数据挖掘326
      • 19.2基于用户行为的挖掘327
      • 19.2.1基于互动内容的兴趣挖掘327
      • 19.2.2基于与博主互动的兴趣挖掘328
      • 19.3基于相似用户的挖掘329
      • 19.3.1基于“@”人的相似用户挖掘329
      • 19.3.2基于社区的相似用户挖掘329
      • 19.3.3基于协同过滤的相似用户挖掘331
      • 19.4点击率预估332
      • 19.4.1点击率预估的概念332
      • 19.4.2点击率预估的方法332
      • 19.5各种数据技术的效果334
      • 参考文献335
      • 附录A336
      • 附录B341

      读书笔记

      详解Python函数any()和all()的用法和区别

      Python函数any()和all()的用法及区别介绍

      引子

      平常的文本处理工作中,我经常会遇到这么一种情况:用python判断一个string是否包含一个list里的元素。

      这时候使用python的内置函数any()会非常的简洁:

      fruits = ['apple', 'orange', 'peach']
      str = "I want some apples"
      if any(element in str for element in fruits):
        print "string contains some fruits."

      any()

      其实any函数非常简单:判断一个tuple或者list是否全为空,0,False。如果全为空,0,False,则返回False;如果不全为空,则返回True。

      all()

      all函数正好和any相反:判断一个tuple或者list是否全为不为空,0,False。如果全不为空,则返回True;否则返回False。

      这里需要注意的是,空tuple和空list的返回值是True

      python中内建函数all()和any()的区别

      all(x) 是针对x对象的元素而言,如果all(x)参数x对象的所有元素不为0、”、False或者x为空对象,则返回True,否则返回False
      如:

      In [25]: all(['a', 'b', 'c', 'd']) #列表list,元素都不为空或0
      Out[25]: True
      In [26]: all(['a', 'b', '', 'd']) #列表list,存在一个为空的元素
      Out[26]: False
      In [27]: all([0, 1,2, 3]) #列表list,存在一个为0的元素
      Out[27]: False
      In [28]: all(('a', 'b', 'c', 'd')) #元组tuple,元素都不为空或0
      Out[28]: True
      In [29]: all(('a', 'b', '', 'd')) #元组tuple,存在一个为空的元素
      Out[29]: False
      In [30]: all((0, 1,2, 3)) #元组tuple,存在一个为0的元素
      Out[30]: False
      In [31]: all([]) # 空列表
      Out[31]: True
      In [32]: all(()) # 空元组
      Out[32]: True

      any(x)是判断x对象是否为空对象,如果都为空、0、false,则返回false,如果不都为空、0、false,则返回true

      In [33]: any(['a', 'b', 'c', 'd']) #列表list,元素都不为空或0
      Out[33]: True
      In [34]: any(['a', 'b', '', 'd']) #列表list,存在一个为空的元素
      Out[34]: True
      In [35]: any((0,1)) #元组tuple,存在一个为空的元素
      Out[35]: True
      In [36]: any((0,'')) #元组tuple,元素都为空
      Out[36]: False
      In [37]: any(()) # 空元组
      Out[37]: False
      In [38]: any([]) # 空列表
      Out[38]: False

      python中any()和all()如何使用

      any(iterables)和all(iterables)对于检查两个对象相等时非常实用,但是要注意,any和all是python内置函数,同时numpy也有自己实现的any和all,功能与python内置的一样,只不过把numpy.ndarray类型加进去了。因为python内置的对高于1维的ndarray没法理解,所以numpy基于的计算最好用numpy自己实现的any和all。

      本质上讲,any()实现了或(OR)运算,而all()实现了与(AND)运算。

      对于any(iterables),如果可迭代对象iterables(至于什么是可迭代对象,可关注我的下篇文章)中任意存在每一个元素为True则返回True。特例:若可迭代对象为空,比如空列表[],则返回False。
      官方文档如是说:

      Return True if any element of the iterable is true. If the iterable is empty, return False.

      伪代码(其实是可以运行的python代码,但内置的any是由C写的)实现方式:

      def any(iterable):
          for element in iterable:
              if element:
                  return True
          return False

      对于all(iterables),如果可迭代对象iterables中所有元素都为True则返回True。特例:若可迭代对象为空,比如空列表[],则返回True。

      官方文档如是说:

      Return True if all elements of the iterable are true (or if the iterable is empty).

      伪代码(其实是可以运行的python代码,但内置的all是由C写的)实现方式:

      def all(iterable):
          for element in iterable:
              if not element:
                  return False
          return True

      python的模块由两类语言开发,一类为纯python,一类为编译型语言,比如C/C++/Fortran。绝大多数标准库由纯python开发,这是由于python语言具有简洁性及短的开发周期。这些模块的源码很容易获得,在ipython下可用module??打印到屏幕上查看,或者写一个脚本保存起来,比如下面这样:

      import os
      import inspect as inspect
      import pandas as pd
      
      path = r"D:\python3_dev\package_down"
      os.chdir(path)
      
      series = inspect.getsource(pd.Series)
      with open("pd_series_code.py", "w") as f:
          f.write(series)

      当然,也可以到python安装包下查找,但是效率很低。

      python inspect.getsource(object)只能查看用python写的module, class, method, function, traceback, frame, or code object。可以看看getsource的文档字符串,了解其基本功能。

      >>>inspect.getsource.__doc__
      'Return the text of the source code for an object.\n\n    
      The argument may be a module, class, method, function, traceback, frame,\n    
      or code object.  The source code is returned as a single string.  An\n    
      OSError is raised if the source code cannot be retrieved.'

      对于有些模块,通常是关乎运行性能的,一般都由编译型语言开发,比如os模块和for循环N多层的线性代数等模块。所以无法通过getsource方法获得源码,通常会抛出一个TypeError异常。要查看这些模块的源码,需要到GitHub上的python/cpython目录下找,比如在Objects目录下可找到listobject.c,这是list模块的C代码。

      那么怎么知道一个模块是内置的呢?可用type(object)或object.__module__。比如

      >>>type(all)
      builtin_function_or_method
      >>>all.__module__
      'builtins'

      一个2X3 ndarray 的例子。用numpy自己实现的all很容易判断两个array是否相等,但python内置的却抛出了异常。

      >>>x = np.ones((2,3))
      >>>x1 = np.ones((2,3))
      >>>np.all(x==x1)
      True
      >>>xe = x==x1
      >>>xe.all()
      True
      >>>all(xe)#这里调用了python内置模块all()
      ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()

      但是,还有更pythonic的写法,因为numpy有一个模块array_equal,可以直接判断两个array是否完全相等或某个轴相等,其实他也是用np.all实现的。

      >>>np.array_equal(x, x1)
      True

      其实也不要惊讶,这只是python的常规操作。轮子已经被匠人造好,拿来用就OK了!如果你觉得自己可以造出更金光闪闪的轮子,那就抡起你的斧头;如果觉得已经够完美,那就拿来主义,不要再造了。

       

      python线程锁相关技巧和操作示例

      Python线程下使用锁的技巧分享

      使用诸如Lock、RLock、Semphore之类的锁原语时,必须多加小心,锁的错误使用很容易导致死锁或相互竞争。依赖锁的代码应该保证当出现异常时可以正常的释放锁。

      典型代码如下:

      try:
        lock.acquire()
        #关键部分
        ...
      finally:
        lock.release()

      另外,所有种类的锁还支持上下文管理协议(写起来更简洁):

      with语句自动获取锁,并且在控制流离开上下文时自动释放锁。

      with lock:
        #关键部分
        ...

      此外,编写代码时一般应该避免同时获取多个锁,例如下面就应该尽量避免:

      这通知很统一导致应用程序神秘死锁,尽管与集中策略可以避免出现这种情况(如分层锁定),但是最好在编写代码时避免这种嵌套锁。

      with lock_A:
        #关键部分
        ...
        with lock_B:
          #B的关键部分
          ...

      尽管在Python中可以使用各种锁和同步原语的组合编写非常传统的多线程程序,但有一种首推的编程方式要优于其他所有编程方式:即将多线程程序组织为多个独立任务的集合,这些任务之间通过消息队列进行通信,例如下面要讲的queue模块。

      Python多线程编程之多线程加锁操作示例

      Python语言本身是支持多线程的,不像PHP语言。

      下面的例子是多个线程做同一批任务,任务总是有task_num个,每次线程做一个任务(print),做完后继续取任务,直到所有任务完成为止。

      # -*- coding:utf-8 -*-
      #! python2
      import threading
      start_task = 0
      task_num = 10000
      mu = threading.Lock()  ###通过工厂方法获取一个新的锁对象
      class MyThread(threading.Thread):  ###类MyThread继承基类threading.Thread
        def run(self): ##线程启动的入口函数,子类需重写
          global start_task
          global mu
          global start_task
          while start_task < task_num:  ##如果任务没有完成,则继续
            if mu.acquire():  ##加锁
              if start_task < task_num:
                print start_task
                start_task = start_task + 1
              mu.release()  ##释放锁
      def test():
        thread_all = []
        for i in range(6): ##for循环创建6个线程
          t = MyThread() ##创建线程
          thread_all.append(t)
          t.start()  ###启动线程
        for i in range(6):
          thread_all[i].join()  ##等待线程结束
      if __name__ == "__main__":
        test()
      
      

      运行上述代码,则输出1~9999

      测试加锁与不加锁效果:将任务数设置为1千万或者以上,在多核机器上将print输出分别保存,就能说明问题。

      python线程中同步锁详解

      在使用多线程的应用下,如何保证线程安全,以及线程之间的同步,或者访问共享变量等问题是十分棘手的问题,也是使用多线程下面临的问题,如果处理不好,会带来较严重的后果,使用python多线程中提供Lock Rlock Semaphore Event Condition 用来保证线程之间的同步,后者保证访问共享变量的互斥问题

      Lock & RLock:互斥锁 用来保证多线程访问共享变量的问题
      Semaphore对象:Lock互斥锁的加强版,可以被多个线程同时拥有,而Lock只能被某一个线程同时拥有。
      Event对象: 它是线程间通信的方式,相当于信号,一个线程可以给另外一个线程发送信号后让其执行操作。
      Condition对象:其可以在某些事件触发或者达到特定的条件后才处理数据

      1、Lock(互斥锁)

      请求锁定 — 进入锁定池等待 — 获取锁 — 已锁定 — 释放锁

      Lock(指令锁)是可用的最低级的同步指令。Lock处于锁定状态时,不被特定的线程拥有。Lock包含两种状态——锁定和非锁定,以及两个基本的方法。

      可以认为Lock有一个锁定池,当线程请求锁定时,将线程至于池中,直到获得锁定后出池。池中的线程处于状态图中的同步阻塞状态。

      构造方法:
      Lock()

      实例方法:
      acquire([timeout]): 使线程进入同步阻塞状态,尝试获得锁定。
      release(): 释放锁。使用前线程必须已获得锁定,否则将抛出异常。

      if mutex.acquire():
       counter += 1
       print "I am %s, set counter:%s" % (self.name, counter)
        mutex.release()

      2、RLock(可重入锁)

      RLock(可重入锁)是一个可以被同一个线程请求多次的同步指令。RLock使用了“拥有的线程”和“递归等级”的概念,处于锁定状态时,RLock被某个线程拥有。拥有RLock的线程可以再次调用acquire(),释放锁时需要调用release()相同次数。

      可以认为RLock包含一个锁定池和一个初始值为0的计数器,每次成功调用 acquire()/release(),计数器将+1/-1,为0时锁处于未锁定状态。

      构造方法:
      RLock()

      实例方法:
      acquire([timeout])/release(): 跟Lock差不多。

      3、Semaphore(共享对象访问)

      咱们再聊聊Semaphore ,说实话Semaphore是我最晚使用的同步锁,以前类似的实现,是我用Rlock实现的,相对来说有些绕,毕竟Rlock 是需要成对的锁定和开锁的》。。。

      Semaphore管理一个内置的计数器,
      每当调用acquire()时内置计数器-1;
      调用release() 时内置计数器+1;
      计数器不能小于0;当计数器为0时,acquire()将阻塞线程直到其他线程调用release()。

      直接上代码,我们把semaphore控制为3,也就是说,同时有3个线程可以用这个锁,剩下的线程也之只能是阻塞等待了…

      #coding:utf-8
      #blog xiaorui.cc
      import time
      import threading
      
      semaphore = threading.Semaphore(3)
      
      def func():
       if semaphore.acquire():
        for i in range(3):
         time.sleep(1)
         print (threading.currentThread().getName() + '获取锁')
        semaphore.release()
        print (threading.currentThread().getName() + ' 释放锁')
      
      
      for i in range(5):
       t1 = threading.Thread(target=func)
       t1.start()

      4、Event(线程间通信)

      Event内部包含了一个标志位,初始的时候为false。
      可以使用使用set()来将其设置为true;
      或者使用clear()将其从新设置为false;
      可以使用is_set()来检查标志位的状态;

      另一个最重要的函数就是wait(timeout=None),用来阻塞当前线程,直到event的内部标志位被设置为true或者timeout超时。如果内部标志位为true则wait()函数理解返回。

      import threading
      import time
      
      class MyThread(threading.Thread):
       def __init__(self, signal):
        threading.Thread.__init__(self)
        self.singal = signal
      
       def run(self):
        print "I am %s,I will sleep ..."%self.name
        self.singal.wait()
        print "I am %s, I awake..." %self.name
      
      if __name__ == "__main__":
       singal = threading.Event()
       for t in range(0, 3):
        thread = MyThread(singal)
        thread.start()
      
       print "main thread sleep 3 seconds... "
       time.sleep(3)
      
       singal.set()
      
      

      5、Condition(线程同步)

      可以把Condition理解为一把高级的琐,它提供了比Lock, RLock更高级的功能,允许我们能够控制复杂的线程同步问题。threadiong.Condition在内部维护一个琐对象(默认是RLock),可以在创建Condigtion对象的时候把琐对象作为参数传入。Condition也提供了acquire, release方法,其含义与琐的acquire, release方法一致,其实它只是简单的调用内部琐对象的对应的方法而已。Condition还提供了如下方法(特别要注意:这些方法只有在占用琐(acquire)之后才能调用,否则将会报RuntimeError异常。):

      Condition.wait([timeout]):

      wait方法释放内部所占用的琐,同时线程被挂起,直至接收到通知被唤醒或超时(如果提供了timeout参数的话)。当线程被唤醒并重新占有琐的时候,程序才会继续执行下去。

      Condition.notify():

      唤醒一个挂起的线程(如果存在挂起的线程)。注意:notify()方法不会释放所占用的琐。

      Condition.notify_all()
      Condition.notifyAll()

      唤醒所有挂起的线程(如果存在挂起的线程)。注意:这些方法不会释放所占用的琐。

      对于Condition有个例子,大家可以观摩下。

      from threading import Thread, Condition
      import time
      import random
      
      queue = []
      MAX_NUM = 10
      condition = Condition()
      
      class ProducerThread(Thread):
       def run(self):
        nums = range(5)
        global queue
        while True:
         condition.acquire()
         if len(queue) == MAX_NUM:
          print "Queue full, producer is waiting"
          condition.wait()
          print "Space in queue, Consumer notified the producer"
         num = random.choice(nums)
         queue.append(num)
         print "Produced", num
         condition.notify()
         condition.release()
         time.sleep(random.random())
      
      
      class ConsumerThread(Thread):
       def run(self):
        global queue
        while True:
         condition.acquire()
         if not queue:
          print "Nothing in queue, consumer is waiting"
          condition.wait()
          print "Producer added something to queue and notified the consumer"
         num = queue.pop(0)
         print "Consumed", num
         condition.notify()
         condition.release()
         time.sleep(random.random())
      
      
      ProducerThread().start()
      ConsumerThread().start()
      

      Python3.6及TensorFlow的安装和配置流程(图解)

      python3.6.3安装图文教程 TensorFlow安装配置方法

      一、Python官网下载自己电脑和系统对应的Python安装包。

       网址:下载地址

      一直往下拉到Files,这里我下载的是Windows x86-64 executable installer

      (注意:要装TensorFlow必须安装64位的Python,TensorFlow不支持32位)<

      二、下载python-3.6.3-amd64.exe应用程序

      下载完成后得到一个python-3.6.3-amd64.exe应用程序,右击以管理员身份运行该安装包;可以选择默认一路安装,也可以customize,自定义想要安装的路径;

       建议install for all users, 这里我安装的路径为D:\Python36;

       勾选 add to PATH ,可以省去后面的配置系统环境变量的步骤;一路next完成安装。

      三、测试是否安装成功

      打开cmd,输入Python;(如下图表明已安装成功)

      若显示python不是系统命令,说明系统环境变量未配置成功;下面介绍系统环境变量的配置。

      计算机(或我的电脑)-右键属性-环境变量-系统变量-path,双击打开path的编辑窗,加入Python的安装路径。如D:\Python36\Scripts\;D:\Python36\;(若在末尾不用加分号)

      确定之后重新cmd测试是否安装成功。

      四、安装后找到Python3.6文件夹

      安装完后可以在系统所有应用程序中找到Python3.6文件夹;

      为了方便可以把IDLE右键发送到桌面快捷方式。

      至此,Python3.6的安装就结束了。

      下面介绍TensorFlow的安装

      在上面的Python安装过程中,通常已经安装好了pip,下面就可以用pip来方便地安装各种开发需要的工具包。

      1.去下面的网址下载你需要的包。(TensorFlow,nltk,numpy 等等都可以找到)

      点击:下载地址

      2.这里以tensorflow为例,下载一个对应版本的TensorFlow

      3.把该文件放到Python安装路径下的Scripts文件夹下,如D:\Python36\Scripts

      4.打开cmd, 进入该路径,输入 pip install tensorflow-1.4.0-cp36-cp36m-win_amd64.whl

      按回车开始安装。

      安装成功的结果:

      其他工具包的安装都可以仿照此例,如自然语言处理NLTK的安装如下:

      下面就可以开始你的Python开发了。

      Win7 64位下python3.6.5安装配置图文教程

      一、安装python

      1、首先进入网站下载:点击打开链接(或自己输入网址),进入之后如下图,选择图中红色圈中区域进行下载。

      关注公众号:资料在线,干货满满。

      2、下载完成后如下图所示

      3、双击exe文件进行安装,如下图,并按照圈中区域进行设置,切记要勾选打钩的框,然后再点击Customize installation进入到下一步:

      4、对于上图中,可以通过Browse进行自定义安装路径,也可以直接点击Install进行安装,点击install后便可以完成安装了。

      5、为了检查我们的python是否安装成功,可以在命令窗口中输入python进行查询,如显示下图一的信息则表示成功了,如显示第二张图的信息则表示出错了。

      二、认识编程环境

      1、在开始运行处运行命令cmd,进行dos模式,输入python,即可进行python的交互式环境。

      2、进行到IDLE界面

      3、交互式界面可以用于简单的学习,编写较大程序时应到具体的python文件中,python文件默认的后缀为.py,我们可以新建文本文件,然后把后缀扩展名改为.py,然后

      最后选择菜单中的Run下的run module即可运行,快捷键为F5。

      第一次自己动手安装,还有许多问题要解决。

      安装过程小插曲,运行的时候提示:

      解决方法如下:

      (1)把C:\Windows\SysWOW64的api-ms-win-crt-runtime-l1-1-0.dll删除掉。

      (2)重新安装api-ms-win-crt-runtime-l1-1-0.dll(其实这个就是VC redit.exe里面的)

      安装VC redit.exe程序解决

      是VC的一个程序:VC redit.exe 下载链接

      下载安装完成两个目录下都会有了, 重启电脑,这时候就可以正常运行。

      python小白一枚,还有许多需要学习的地方,先记录一下。下一篇再整理一些pip安装教程。

      还有一个小补充:

      EOL while scanning string literal,提示这个异常的原因是:这个异常造成的原因是字符串,引号没有成对出现。

      win10下python3.5.2、tensorflow和matplotlib安装教程

      win10环境下搭建python3.5.2和tensorflow

      在win10环境下搭建python3.5.2和tensorflow平台,供大家参考,具体内容如下

      操作步骤如下:

      1、官网(https://www.python.org/ )下载python3.5.2 

      选择Downloads-Windows

      选择64位executable installer

      2、安装过程,双击.exe可执行文件

      一路默认下去!

        

      3、安装成功后打开cmd命令窗口

      print(“Hello World!”)回车后出现HelloWorld!即可

      4、python -m pip install -U pip 用来更新pip

      5、win10安装tensorflow (可参考 网址

      这里我安装tensorflow-cpu版本

      · 在命令行输入:pip install --upgrade --ignore-installed tensorflow

      6、安装库的方法

      下载库的网址:链接地址

       

       cp35代表适用python3.5版本,win64表示适用于64位电脑,下载版本如下红色字所示文件:

      以安装库matplotlib为例:

      至此环境搭建完成!

      注意事项:

      库报错

      解决:所有库必须统一来源、统一安装,下载网址

      win10下tensorflow和matplotlib安装教程

      本文介绍了一系列安装教程,具体如下

      1.安装Python

      版本选择是3.5.1,因为网上有些深度学习实例用的就是这个版本,跟他们一样的话可以避免版本带来的语句规范问题

      python的下载官网

      2.安装easy_install

      • 在Python的官网下载easy_install的安装包,下载地址
      • 下载完成后解压zip,解压后双击setup.py,会跳出一个黑框闪一下,这时python目录下的scripts文件夹中有了easy_install的应用程序文件。
      • 接下来配置环境变量:计算机→系统属性→高级系统设置→环境变量→双击path→添加Python和scripts的路径
      • win+R+cmd打开命令行,输入easy_install virtualenv,回车

      安装了easy_install之后安装Python库就方便了,直接在命令行中输入easy_install+libname就行了。但试验了几次后发现pip比较适合我这种小白,所以安装了pip。

      3.安装pip

      • 在命令行里输入easy_install pip,回车
      • 检查pip是否成功安装,直接在命令行里输入pip
      • pip版本升级,在命令行里输入:python -m pip install -U pip

      注意空格,比如python与-m之间就有个空格

      4.安装tensorflow

      确定计算机联网了,网速也要保证,有次我的网速太慢了,不得已一个组件一个组件的下,最后再输入以下那条命令,也成功了,但网速快的话是可以自动一次性下载完成的

      在命令行输入:pip install --upgrade --ignore-installed tensorflow

      安装完成后在Python中输入import tensorflow 可能会出现找不到模块的错误,这时需要安装MSVCP140.DLL,下载安装完成后重启电脑就可以了,下载地址

      5.安装matplotlib

      特别只出一个Python第三方组件库,内容很全:链接地址

      • 从刚才提到的第三方库中下载matplotlib,选择文件时注意cp35代表适用Python3.5版本,win64表示适用于64位电脑
      • 记住下载的matplotlib的路径,我一般会放在Python文件夹下
      • 打开命令行,输入cd 安装路径,回车。如果把所有下载的组件都放到这个安装路径的话,用cd转到这个路径再用pip安装就很方便
      • 在命令行继续输入pip install 文件名,文件名一定要写对写全。用这种法还可以安装很多组件,比如我文件夹下的那个pywin32。示例图如下:

      可以用一个简单的例子验证matplotlib是否安装正确,由于我还没有开始学matplotlib,这个例子用的是其他文章里的 (可以发现这篇文章里让安装的各种组件,在安装tensorflows的时候就已经自动安装好了,若是网速不够导致timeout,就要挨个下载安装这些组件)            

       例子:

      以上就是本文的全部内容,希望对大家的学习有所帮助

      Python高级编程技巧总结

      符合语言习惯的 Python 优雅编程技巧

      Python最大的优点之一就是语法简洁,好的代码就像伪代码一样,干净、整洁、一目了然。要写出 Pythonic(优雅的、地道的、整洁的)代码,需要多看多学大牛们写的代码,github 上有很多非常优秀的源代码值得阅读,比如:requests、flask、tornado,下面列举一些常见的Pythonic写法。
      0. 程序必须先让人读懂,然后才能让计算机执行。

      “Programs must be written for people to read, and only incidentally for machines to execute.”

      1. 交换赋值

      ##不推荐
      temp = a
      a = b
      b = a 
      ##推荐
      a, b = b, a # 先生成一个元组(tuple)对象,然后unpack

      2. Unpacking

      ##不推荐
      l = ['David', 'Pythonista', '+1-514-555-1234']
      first_name = l[0]
      last_name = l[1]
      phone_number = l[2] 
      ##推荐
      l = ['David', 'Pythonista', '+1-514-555-1234']
      first_name, last_name, phone_number = l
      # Python 3 Only
      first, *middle, last = another_list

      3. 使用操作符in

      ##不推荐
      if fruit == "apple" or fruit == "orange" or fruit == "berry":
        # 多次判断 
      ##推荐
      if fruit in ["apple", "orange", "berry"]:
        # 使用 in 更加简洁

      4. 字符串操作

      ##不推荐
      colors = ['red', 'blue', 'green', 'yellow']
      result = ''
      for s in colors:
        result += s # 每次赋值都丢弃以前的字符串对象, 生成一个新对象 
      ##推荐
      colors = ['red', 'blue', 'green', 'yellow']
      result = ''.join(colors) # 没有额外的内存分配

      5. 字典键值列表

      ##不推荐
      for key in my_dict.keys():
        # my_dict[key] ... 
      ##推荐
      for key in my_dict:
        # my_dict[key] ...
      # 只有当循环中需要更改key值的情况下,我们需要使用 my_dict.keys()
      # 生成静态的键值列表。

      6. 字典键值判断

      ##不推荐
      if my_dict.has_key(key):
        # ...do something with d[key] 
      ##推荐
      if key in my_dict:
        # ...do something with d[key]

      7. 字典 get 和 setdefault 方法

      ##不推荐
      navs = {}
      for (portfolio, equity, position) in data:
        if portfolio not in navs:
            navs[portfolio] = 0
        navs[portfolio] += position * prices[equity]
      ##推荐
      navs = {}
      for (portfolio, equity, position) in data:
        # 使用 get 方法
        navs[portfolio] = navs.get(portfolio, 0) + position * prices[equity]
        # 或者使用 setdefault 方法
        navs.setdefault(portfolio, 0)
        navs[portfolio] += position * prices[equity]

      8. 判断真伪

      ##不推荐
      if x == True:
        # ....
      if len(items) != 0:
        # ...
      if items != []:
        # ... 
      ##推荐
      if x:
        # ....
      if items:
        # ...

      9. 遍历列表以及索引

      ##不推荐
      items = 'zero one two three'.split()
      # method 1
      i = 0
      for item in items:
        print i, item
        i += 1
      # method 2
      for i in range(len(items)):
        print i, items[i]
      ##推荐
      items = 'zero one two three'.split()
      for i, item in enumerate(items):
        print i, item

      10. 列表推导

      ##不推荐
      new_list = []
      for item in a_list:
        if condition(item):
          new_list.append(fn(item)) 
      ##推荐
      new_list = [fn(item) for item in a_list if condition(item)]

      11. 列表推导-嵌套

      ##不推荐
      for sub_list in nested_list:
        if list_condition(sub_list):
          for item in sub_list:
            if item_condition(item):
              # do something... 
      ##推荐
      gen = (item for sl in nested_list if list_condition(sl) \
            for item in sl if item_condition(item))
      for item in gen:
        # do something...

      12. 循环嵌套

      ##不推荐
      for x in x_list:
        for y in y_list:
          for z in z_list:
            # do something for x &amp; y 
      ##推荐
      from itertools import product
      for x, y, z in product(x_list, y_list, z_list):
        # do something for x, y, z

      13. 尽量使用生成器代替列表

      ##不推荐
      def my_range(n):
        i = 0
        result = []
        while i &lt; n:
          result.append(fn(i))
          i += 1
        return result # 返回列表
      ##推荐
      def my_range(n):
        i = 0
        result = []
        while i &lt; n:
          yield fn(i) # 使用生成器代替列表
          i += 1
      *尽量用生成器代替列表,除非必须用到列表特有的函数。

      14. 中间结果尽量使用imap/ifilter代替map/filter

      ##不推荐
      reduce(rf, filter(ff, map(mf, a_list)))
      ##推荐
      from itertools import ifilter, imap
      reduce(rf, ifilter(ff, imap(mf, a_list)))
      *lazy evaluation 会带来更高的内存使用效率,特别是当处理大数据操作的时候。

      15. 使用any/all函数

      ##不推荐
      found = False
      for item in a_list:
        if condition(item):
          found = True
          break
      if found:
        # do something if found... 
      ##推荐
      if any(condition(item) for item in a_list):
        # do something if found...

      16. 属性(property)

      =
      ##不推荐
      class Clock(object):
        def __init__(self):
          self.__hour = 1
        def setHour(self, hour):
          if 25 &gt; hour &gt; 0: self.__hour = hour
          else: raise BadHourException
        def getHour(self):
          return self.__hour
      ##推荐
      class Clock(object):
        def __init__(self):
          self.__hour = 1
        def __setHour(self, hour):
          if 25 &gt; hour &gt; 0: self.__hour = hour
          else: raise BadHourException
        def __getHour(self):
          return self.__hour
        hour = property(__getHour, __setHour)

      17. 使用 with 处理文件打开

      ##不推荐
      f = open("some_file.txt")
      try:
        data = f.read()
        # 其他文件操作..
      finally:
        f.close()
      ##推荐
      with open("some_file.txt") as f:
        data = f.read()
        # 其他文件操作...

      18. 使用 with 忽视异常(仅限Python 3)

      ##不推荐
      try:
        os.remove("somefile.txt")
      except OSError:
        pass
      ##推荐
      from contextlib import ignored # Python 3 only
      with ignored(OSError):
        os.remove("somefile.txt")

      19. 使用 with 处理加锁

      ##不推荐
      import threading
      lock = threading.Lock()
      lock.acquire()
      try:
        # 互斥操作...
      finally:
        lock.release()
      ##推荐
      import threading
      lock = threading.Lock()
      with lock:
        # 互斥操作...

      20. 参考

      1) Idiomatic Python: http://python.net/~goodger/projects/pycon/2007/idiomatic/handout.html
      2) PEP 8: Style Guide for Python Code: http://www.python.org/dev/peps/pep-0008/

      有关Python的22个编程技巧

      1. 原地交换两个数字

      Python 提供了一个直观的在一行代码中赋值与交换(变量值)的方法,请参见下面的示例:

      x,y= 10,20
      print(x,y)
      x,y= y,x
      print(x,y)
      #1 (10, 20)
      #2 (20, 10)

      赋值的右侧形成了一个新的元组,左侧立即解析(unpack)那个(未被引用的)元组到变量 <a> 和 <b>。

      一旦赋值完成,新的元组变成了未被引用状态并且被标记为可被垃圾回收,最终也完成了变量的交换。

      2. 链状比较操作符

      比较操作符的聚合是另一个有时很方便的技巧:

      n= 10
      result= 1< n< 20
      print(result)
      # True
      result= 1> n<= 9
      print(result)
      # False

      3. 使用三元操作符来进行条件赋值

      三元操作符是 if-else 语句也就是条件操作符的一个快捷方式:

      [表达式为真的返回值] if [表达式] else [表达式为假的返回值]

      这里给出几个你可以用来使代码紧凑简洁的例子。下面的语句是说“如果 y 是 9,给 x 赋值 10,不然赋值为 20”。如果需要的话我们也可以延长这条操作链。

      x = 10 if (y == 9) else 20

      同样地,我们可以对类做这种操作:

      x = (classA if y == 1 else classB)(param1, param2)

      在上面的例子里 classA 与 classB 是两个类,其中一个类的构造函数会被调用。

      下面是另一个多个条件表达式链接起来用以计算最小值的例子:

      def small(a,b,c):
      returnaifa<= banda<= celse(bifb<= aandb<= celsec)
      print(small(1,0,1))
      print(small(1,2,2))
      print(small(2,2,3))
      print(small(5,4,3))
      #Output
      #0 #1 #2 #3

      我们甚至可以在列表推导中使用三元运算符:

      [m**2 if m > 10 else m**4 for m in range(50)]
      #=> [0, 1, 16, 81, 256, 625, 1296, 2401, 4096, 6561, 10000, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400, 441, 484, 529, 576, 625, 676, 729, 784, 841, 900, 961, 1024, 1089, 1156, 1225, 1296, 1369, 1444, 1521, 1600, 1681, 1764, 1849, 1936, 2025, 2116, 2209, 2304, 2401]

      4. 多行字符串

      基本的方式是使用源于 C 语言的反斜杠:

      multiStr= “select * from multi_row
      where row_id < 5”
      print(multiStr)
      # select * from multi_row where row_id < 5

      另一个技巧是使用三引号:

      multiStr= “””select * from multi_row
      where row_id < 5″””
      print(multiStr)
      #select * from multi_row
      #where row_id < 5

      上面方法共有的问题是缺少合适的缩进,如果我们尝试缩进会在字符串中插入空格。所以最后的解决方案是将字符串分为多行并且将整个字符串包含在括号中:

      multiStr= (“select * from multi_row ”
      “where row_id < 5 ”
      “order by age”)
      print(multiStr)
      #select * from multi_row where row_id < 5 order by age

      5. 存储列表元素到新的变量中

      我们可以使用列表来初始化多个变量,在解析列表时,变量的数目不应该超过列表中的元素个数:【译者注:元素个数与列表长度应该严格相同,不然会报错】

      testList= [1,2,3]
      x,y,z= testList
      print(x,y,z)
      #-> 1 2 3

      6. 打印引入模块的文件路径

      如果你想知道引用到代码中模块的绝对路径,可以使用下面的技巧:

      import threading
      import socket
      print(threading)
      print(socket)
      #1- <module ‘threading' from ‘/usr/lib/python2.7/threading.py'>
      #2- <module ‘socket' from ‘/usr/lib/python2.7/socket.py'>

      7. 交互环境下的 “_” 操作符

      这是一个我们大多数人不知道的有用特性,在 Python 控制台,不论何时我们测试一个表达式或者调用一个方法,结果都会分配给一个临时变量: _(一个下划线)。

      >>> 2+ 1
      3
      >>> _
      3
      >>> print_
      3
      “_” 是上一个执行的表达式的输出。

      8. 字典/集合推导

      与我们使用的列表推导相似,我们也可以使用字典/集合推导,它们使用起来简单且有效,下面是一个例子:

      testDict= {i: i *iforiinxrange(10)}
      testSet= {i *2foriinxrange(10)}
      print(testSet)
      print(testDict)
      #set([0, 2, 4, 6, 8, 10, 12, 14, 16, 18])
      #{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

      注:两个语句中只有一个 <:> 的不同,另,在 Python3 中运行上述代码时,将 <xrange> 改为 <range>。

      9. 调试脚本

      我们可以在 <pdb> 模块的帮助下在 Python 脚本中设置断点,下面是一个例子:

      import pdb
      pdb.set_trace()

      我们可以在脚本中任何位置指定 <pdb.set_trace()> 并且在那里设置一个断点,相当简便。

      10. 开启文件分享

      Python 允许运行一个 HTTP 服务器来从根路径共享文件,下面是开启服务器的命令:

      # Python 2
      python -m SimpleHTTPServer
      # Python 3
      python3 -m http.server

      上面的命令会在默认端口也就是 8000 开启一个服务器,你可以将一个自定义的端口号以最后一个参数的方式传递到上面的命令中。

      11. 检查 Python 中的对象

      我们可以通过调用 dir() 方法来检查 Python 中的对象,下面是一个简单的例子:

      test= [1,3,5,7]
      print(dir(test))
      [‘__add__', ‘__class__', ‘__contains__', ‘__delattr__', ‘__delitem__', ‘__delslice__', ‘__doc__', ‘__eq__', ‘__format__', ‘__ge__', ‘__getattribute__', ‘__getitem__', ‘__getslice__', ‘__gt__', ‘__hash__', ‘__iadd__', ‘__imul__', ‘__init__', ‘__iter__', ‘__le__', ‘__len__', ‘__lt__', ‘__mul__', ‘__ne__', ‘__new__', ‘__reduce__', ‘__reduce_ex__', ‘__repr__', ‘__reversed__', ‘__rmul__', ‘__setattr__', ‘__setitem__', ‘__setslice__', ‘__sizeof__', ‘__str__', ‘__subclasshook__', ‘append', ‘count', ‘extend', ‘index', ‘insert', ‘pop', ‘remove', ‘reverse', ‘sort']

      12. 简化 if 语句

      我们可以使用下面的方式来验证多个值:

      if m in [1,3,5,7]:

      而不是:

      if m==1 or m==3 or m==5 or m==7:

      或者,对于 in 操作符我们也可以使用 ‘{1,3,5,7}' 而不是 ‘[1,3,5,7]',因为 set 中取元素是 O(1) 操作。

      13. 一行代码计算任何数的阶乘

      Python 2.x.
      result= (lambdak: reduce(int.__mul__,range(1,k+1),1))(3)
      print(result)
      #-> 6
      Python 3.x.
      import functools
      result= (lambdak: functools.reduce(int.__mul__,range(1,k+1),1))(3)
      print(result)
      #-> 6

      14. 找到列表中出现最频繁的数

      test= [1,2,3,4,2,2,3,1,4,4,4]
      print(max(set(test),key=test.count))
      #-> 4

      15. 重置递归限制

      Python 限制递归次数到 1000,我们可以重置这个值:

      import sys
      x=1001
      print(sys.getrecursionlimit())
      sys.setrecursionlimit(x)
      print(sys.getrecursionlimit())
      #1-> 1000
      #2-> 1001

      请只在必要的时候采用上面的技巧。

      16. 检查一个对象的内存使用

      在 Python 2.7 中,一个 32 比特的整数占用 24 字节,在 Python 3.5 中利用 28 字节。为确定内存使用,我们可以调用 getsizeof 方法:

      在 Python 2.7 中

      import sys
      x=1
      print(sys.getsizeof(x))
      #-> 24
      在 Python 3.5 中
      import sys
      x=1
      print(sys.getsizeof(x))
      #-> 28

      17. 使用 __slots__ 来减少内存开支

      你是否注意到你的 Python 应用占用许多资源特别是内存?有一个技巧是使用 __slots__ 类变量来在一定程度上减少内存开支。

      import sys
      classFileSystem(object):
      def __init__(self,files,folders,devices):
      self.files= files
      self.folders= folders
      self.devices= devices
      print(sys.getsizeof(FileSystem))
      classFileSystem1(object):
      __slots__= [‘files','folders','devices']
      def __init__(self,files,folders,devices):
      self.files= files
      self.folders= folders
      self.devices= devices
      print(sys.getsizeof(FileSystem1))
      #In Python 3.5
      #1-> 1016
      #2-> 888

      很明显,你可以从结果中看到确实有内存使用上的节省,但是你只应该在一个类的内存开销不必要得大时才使用 __slots__。只在对应用进行性能分析后才使用它,不然地话,你只是使得代码难以改变而没有真正的益处。

      【译者注:在我的 win10 python2.7 中上面的结果是:

      #In Python 2.7 win10
      #1-> 896
      #2-> 1016

      所以,这种比较方式是不那么让人信服的,使用 __slots__ 主要是用以限定对象的属性信息,另外,当生成对象很多时花销可能会小一些,具体可以参见 python 官方文档:

      The slots declaration takes a sequence of instance variables and reserves just enough space in each instance to hold a value for each variable. Space is saved because dict is not created for each instance. 】

      18. 使用 lambda 来模仿输出方法

      import sys
      lprint=lambda *args:sys.stdout.write(” “.join(map(str,args)))
      lprint(“python”,”tips”,1000,1001)
      #-> python tips 1000 1001

      19.从两个相关的序列构建一个字典

      t1= (1,2,3)
      t2= (10,20,30)
      print(dict(zip(t1,t2)))
      #-> {1: 10, 2: 20, 3: 30}

      20. 一行代码搜索字符串的多个前后缀

      print(“http://www.google.com”.startswith((“http://”,”https://”)))
      print(“http://www.google.co.uk”.endswith((“.com”,”.co.uk”)))
      #1-> True
      #2-> True

      21. 不使用循环构造一个列表

      import itertools
      test= [[-1,-2],[30,40],[25,35]]
      print(list(itertools.chain.from_iterable(test)))
      #-> [-1, -2, 30, 40, 25, 35]

      22. 在 Python 中实现一个真正的 switch-case 语句

      下面的代码使用一个字典来模拟构造一个 switch-case。

      def xswitch(x):
      returnxswitch._system_dict.get(x,None)
      xswitch._system_dict= {‘files': 10,'folders': 5,'devices': 2}
      print(xswitch(‘default'))
      print(xswitch(‘devices'))
      #1-> None
      #2-> 2

       

      用Python实现2048小游戏操作步骤

      前言

      2048游戏规则:简单的移动方向键让数字叠加,并且获得这些数字每次叠加后的得分,当出现2048这个数字时游戏胜利。同时每次移动方向键时,都会在这个4*4的方格矩阵的空白区域随机产生一个数字2或者4,如果方格被数字填满了,那么就GameOver了。

      主逻辑图

      逻辑图解:黑色是逻辑层,蓝色是外部方法,红色是类内方法,稍后即可知道~

      下面容我逐行解释主逻辑main()函数,并且在其中穿叉外部定义的函数与类。

      主逻辑代码解读(完整代码见文末)

      主逻辑main如下,之后的是对主函数中的一些方法的解读:

      def main(stdscr):
       def init():
       #重置游戏棋盘
       game_field.reset()
       return 'Game'
      
       def not_game(state):
       #画出 GameOver 或者 Win 的界面
       game_field.draw(stdscr)
       #读取用户输入得到action,判断是重启游戏还是结束游戏
       action = get_user_action(stdscr)
       responses = defaultdict(lambda: state) #默认是当前状态,没有行为就会一直在当前界面循环
       responses['Restart'], responses['Exit'] = 'Init', 'Exit' #对应不同的行为转换到不同的状态
       return responses[action]
      
       def game():
       #画出当前棋盘状态
       game_field.draw(stdscr)
       #读取用户输入得到action
       action = get_user_action(stdscr)
      
       if action == 'Restart':
        return 'Init'
       if action == 'Exit':
        return 'Exit'
       if game_field.move(action): # move successful
        if game_field.is_win():
        return 'Win'
        if game_field.is_gameover():
        return 'Gameover'
       return 'Game'
      
      
       state_actions = {
        'Init': init,
        'Win': lambda: not_game('Win'),
        'Gameover': lambda: not_game('Gameover'),
        'Game': game
       }
      
       curses.use_default_colors()
       game_field = GameField(win=32)
      
       state = 'Init'
      
       #状态机开始循环
       while state != 'Exit':
       state = state_actions[state]()

      逐条解读(代码框内会标注是来自外部,无标注则是来自内部):定义主函数

      def main(stdscr):
       def init():
       #重置游戏棋盘
       game_field.reset()

      reset出自外部定义的类,game_field=GameField的一个方法reset:

        外部:

       def reset(self):
       if self.score > self.highscore:
        self.highscore = self.score
       self.score = 0
       self.field = [[0 for i in range(self.width)] for j in range(self.height)]
       self.spawn()
       self.spawn()
      #其中highscore为程序初始化过程中定义的一个变量。记录你win游戏的最高分数记录。
       return 'Game'

      返回一个游戏进行中的状态。game_field=GameField状态在后面有定义:

      主函数底部定义:

       state_actions = {
        'Init': init,
        'Win': lambda: not_game('Win'),
        'Gameover': lambda: not_game('Gameover'),
        'Game': game
       }
       def not_game(state):
       #画出 GameOver 或者 Win 的界面
       game_field.draw(stdscr)

      draw是导入的类game_field=GameField中的方法:

      #来自外部类
       def draw(self, screen):
       help_string1 = '(W)Up (S)Down (A)Left (D)Right'
       help_string2 = ' (R)Restart (Q)Exit'
       gameover_string = '  GAME OVER'
       win_string = '  YOU WIN!'
      #定义各个字符串
       def cast(string):
        screen.addstr(string + '\n')
      
       def draw_hor_separator():
        line = '+' + ('+------' * self.width + '+')[1:]
        separator = defaultdict(lambda: line)
        if not hasattr(draw_hor_separator, "counter"):
        draw_hor_separator.counter = 0
        cast(separator[draw_hor_separator.counter])
        draw_hor_separator.counter += 1
      
       def draw_row(row):
        cast(''.join('|{: ^5} '.format(num) if num > 0 else '| ' for num in row) + '|')
      
       screen.clear()
       cast('SCORE: ' + str(self.score))
       if 0 != self.highscore:
        cast('HGHSCORE: ' + str(self.highscore))
       for row in self.field:
        draw_hor_separator()
        draw_row(row)
       draw_hor_separator()
       if self.is_win():
        cast(win_string)
       else:
        if self.is_gameover():
        cast(gameover_string)
        else:
        cast(help_string1)
       cast(help_string2)
      #这里面的draw方法的字函数我就不做多的解释了,很简单的一些概念。
      #但是又运用到了很优秀的精简代码。
      #有的地方建议去查一下python的一些高级概念,我就不做多的介绍了。

      这里面的draw方法的字函数我就不做多的解释了,很简单的一些概念。

      但是又运用到了很优秀的精简代码。

      有的地方建议去查一下python的一些高级概念,我就不做多的介绍了。

       #读取用户输入得到action,判断是重启游戏还是结束游戏
       action = get_user_action(stdscr)

      读取用户行为,函数来自于代码初始的定义

      #来自外部定义的函数
      def get_user_action(keyboard): 
       char = "N"
       while char not in actions_dict: 
       char = keyboard.getch()
       return actions_dict[char]

      在结尾处,也即是主函数执行的第三步,定义了state = state_actions[state]()这一实例:

      #主函数底部:
       state = 'Init'
      
       #状态机开始循环
       while state != 'Exit':
       state = state_actions[state]()
       responses = defaultdict(lambda: state) #默认是当前状态,没有行为就会一直在当前界面循环
       responses['Restart'], responses['Exit'] = 'Init', 'Exit' #对应不同的行为转换到不同的状态
       return responses[action]
       def game():
       #画出当前棋盘状态
       game_field.draw(stdscr)
       #读取用户输入得到action
       action = get_user_action(stdscr)
      
       if action == 'Restart':
        return 'Init'
       if action == 'Exit':
        return 'Exit'
       if game_field.move(action): # move successful
        if game_field.is_win():
        return 'Win'
        if game_field.is_gameover():
        return 'Gameover'
       return 'Game'
      #game()函数的定义类似于上面已经讲过的not_game(),只是game()有了内部循环
      #即如果不是Restart/Exit或者对move之后的状态进行判断,如果不是结束游戏,就一直在game()内部循环。

      game()函数的定义类似于上面已经讲过的not_game() ,只是game()有了内部循环,即如果不是Restart/Exit或者对move之后的状态进行判断,如果不是结束游戏,就一直在game()内部循环。

       state_actions = {
        'Init': init,
        'Win': lambda: not_game('Win'),
        'Gameover': lambda: not_game('Gameover'),
        'Game': game
         }
      
       curses.use_default_colors()
       game_field = GameField(win=32)
      
      
       state = 'Init'
      
       #状态机开始循环
       while state != 'Exit':
       state = state_actions[state]()
      #此处的意思是:state=state_actions[state] 可以看做是:
      #state=init()或者state=not_game(‘Win')或者是另外的not_game(‘Gameover')/game()

      此处的意思是:state=state_actions[state] 可以看做是:state=init()或者state=not_game(‘Win')或者是另外的not_game(‘Gameover')/game()

      废话不多说,上一个我的成功的图,另外,可以通过设置最后几行中的win=32来决定你最终获胜的条件!

      完整代码

      #-*- coding:utf-8 -*-
      import curses
      from random import randrange, choice # generate and place new tile
      from collections import defaultdict
      letter_codes = [ord(ch) for ch in 'WASDRQwasdrq']
      actions = ['Up', 'Left', 'Down', 'Right', 'Restart', 'Exit']
      actions_dict = dict(zip(letter_codes, actions * 2))
      def transpose(field):
       return [list(row) for row in zip(*field)]
      
      def invert(field):
       return [row[::-1] for row in field]
      
      class GameField(object):
       def __init__(self, height=4, width=4, win=2048):
       self.height = height
       self.width = width
       self.win_value = win
       self.score = 0
       self.highscore = 0
       self.reset()
      
       def reset(self):
       if self.score > self.highscore:
        self.highscore = self.score
       self.score = 0
       self.field = [[0 for i in range(self.width)] for j in range(self.height)]
       self.spawn()
       self.spawn()
      
       def move(self, direction):
       def move_row_left(row):
        def tighten(row): # squeese non-zero elements together
        new_row = [i for i in row if i != 0]
        new_row += [0 for i in range(len(row) - len(new_row))]
        return new_row
      
        def merge(row):
        pair = False
        new_row = []
        for i in range(len(row)):
         if pair:
         new_row.append(2 * row[i])
         self.score += 2 * row[i]
         pair = False
         else:
         if i + 1 < len(row) and row[i] == row[i + 1]:
          pair = True
          new_row.append(0)
         else:
          new_row.append(row[i])
        assert len(new_row) == len(row)
        return new_row
        return tighten(merge(tighten(row)))
      
       moves = {}
       moves['Left'] = lambda field:    \
        [move_row_left(row) for row in field]
       moves['Right'] = lambda field:    \
        invert(moves['Left'](invert(field)))
       moves['Up'] = lambda field:    \
        transpose(moves['Left'](transpose(field)))
       moves['Down'] = lambda field:    \
        transpose(moves['Right'](transpose(field)))
      
       if direction in moves:
        if self.move_is_possible(direction):
        self.field = moves[direction](self.field)
        self.spawn()
        return True
        else:
        return False
      
       def is_win(self):
       return any(any(i >= self.win_value for i in row) for row in self.field)
      
       def is_gameover(self):
       return not any(self.move_is_possible(move) for move in actions)
      
       def draw(self, screen):
       help_string1 = '(W)Up (S)Down (A)Left (D)Right'
       help_string2 = ' (R)Restart (Q)Exit'
       gameover_string = '  GAME OVER'
       win_string = '  YOU WIN!'
       def cast(string):
        screen.addstr(string + '\n')
      
       def draw_hor_separator():
        line = '+' + ('+------' * self.width + '+')[1:]
        separator = defaultdict(lambda: line)
        if not hasattr(draw_hor_separator, "counter"):
        draw_hor_separator.counter = 0
        cast(separator[draw_hor_separator.counter])
        draw_hor_separator.counter += 1
      
       def draw_row(row):
        cast(''.join('|{: ^5} '.format(num) if num > 0 else '| ' for num in row) + '|')
      
       screen.clear()
       cast('SCORE: ' + str(self.score))
       if 0 != self.highscore:
        cast('HGHSCORE: ' + str(self.highscore))
       for row in self.field:
        draw_hor_separator()
        draw_row(row)
       draw_hor_separator()
       if self.is_win():
        cast(win_string)
       else:
        if self.is_gameover():
        cast(gameover_string)
        else:
        cast(help_string1)
       cast(help_string2)
      
       def spawn(self):
       new_element = 4 if randrange(100) > 89 else 2
       (i,j) = choice([(i,j) for i in range(self.width) for j in range(self.height) if self.field[i][j] == 0])
       self.field[i][j] = new_element
      
       def move_is_possible(self, direction):
       def row_is_left_movable(row): 
        def change(i): # true if there'll be change in i-th tile
        if row[i] == 0 and row[i + 1] != 0: # Move
         return True
        if row[i] != 0 and row[i + 1] == row[i]: # Merge
         return True
        return False
        return any(change(i) for i in range(len(row) - 1))
      
       check = {}
       check['Left'] = lambda field:    \
        any(row_is_left_movable(row) for row in field)
      
       check['Right'] = lambda field:    \
         check['Left'](invert(field))
      
       check['Up'] = lambda field:    \
        check['Left'](transpose(field))
      
       check['Down'] = lambda field:    \
        check['Right'](transpose(field))
      
       if direction in check:
        return check[direction](self.field)
       else:
        return False
      def main(stdscr):
       def init():
       #重置游戏棋盘
       game_field.reset()
       return 'Game'
       def not_game(state):
       #画出 GameOver 或者 Win 的界面
       game_field.draw(stdscr)
       #读取用户输入得到action,判断是重启游戏还是结束游戏
       action = get_user_action(stdscr)
       responses = defaultdict(lambda: state) #默认是当前状态,没有行为就会一直在当前界面循环
       responses['Restart'], responses['Exit'] = 'Init', 'Exit' #对应不同的行为转换到不同的状态
       return responses[action]
      
       def game():
       #画出当前棋盘状态
       game_field.draw(stdscr)
       #读取用户输入得到action
       action = get_user_action(stdscr)
      
       if action == 'Restart':
        return 'Init'
       if action == 'Exit':
        return 'Exit'
       if game_field.move(action): # move successful
        if game_field.is_win():
        return 'Win'
        if game_field.is_gameover():
        return 'Gameover'
       return 'Game'
      
      
       state_actions = {
        'Init': init,
        'Win': lambda: not_game('Win'),
        'Gameover': lambda: not_game('Gameover'),
        'Game': game
       }
       curses.use_default_colors()
       game_field = GameField(win=32)
       state = 'Init'
       #状态机开始循环
       while state != 'Exit':
       state = state_actions[state]()
      curses.wrapper(main)

       

      以上就是本次介绍的机器学习电子书的全部相关内容,希望我们整理的资源能够帮助到大家,感谢大家对码农之家的支持。

      上一篇:树莓派Python编程入门与实战 第2版

      下一篇:Python数据抓取技术与实战

      展开 +

      收起 -

      下载地址:百度网盘下载
      机器学习 相关电子书
      python机器学习 Scikit-learn使用手册
      python机器学习 Scikit-learn使用手册 PDF 原书扫描版

      scikit-learn是在Python中进行机器学习简单且高效的工具可用于数据挖掘和数据分析,这里提供Scikit-learn 使用手册,欢迎下载

      立即下载
      深入浅出Python机器学习
      深入浅出Python机器学习 PDF 完整超清版

      人工智能,火了!计算机是由程序驱动的,人工智能不过是一些特殊的算法。只要你有一些程序设计语言的基础,跟随本书,你也能进入人工智能的世界,成为一名人工智能应用的开发者。

      立即下载
      Python+TensorFlow机器学习实战
      Python+TensorFlow机器学习实战 .rar 课件源码版

      本资源为《Python+TensorFlow机器学习实战》的课件、源码等资源 很系统:讲解19种机器学习经典算法,依次击破重难点 很图示:书中包括113张图解说明,方便读者理解 很实用:囊括文本识别、语

      立即下载
      零起点Python足彩大数据与机器学习实盘分析
      零起点Python足彩大数据与机器学习实盘分析 PDF 全书影印版 立即下载
      Python+Spark2.0+Hadoop机器学习与大数据实战
      Python+Spark2.0+Hadoop机器学习与大数据实战 PDF 原书扫描版

      本书从浅显易懂的“大数据和机器学习”原理说明入手,讲述大数据和机器学习的基本概念,浅显易懂的原理介绍加上Step by Step 实机操作、范例程序详细解说,实现降低机器学习与大数据技术

      立即下载
      Python机器学习
      Python机器学习 PDF 中文影印版

      Python机器学习中文版(Sebastian Raschka著),一共13章,含机器学习算法、模型评估、集成学习、web应用、神经网络等,想要学习机器语言的可以下载学习

      立即下载
      NLTK基础教程:用NLTK和Python库构建机器学习应用
      NLTK基础教程:用NLTK和Python库构建机器学习应用 PDF 高清版

      本书主要介绍如何通过NLTK库与一些Python库的结合从而实现复杂的NLP任务和机器学习应用。全书共分为10章。第1章对NLP进行了简单介绍。第2章、第3章和第4章主要介绍一些通用的预处理技术、专

      立即下载
      读者心得
      163小时30分钟前回答

      python机器学习理论与实战(六)支持向量机

      上节基本完成了SVM的理论推倒,寻找最大化间隔的目标最终转换成求解拉格朗日乘子变量alpha的求解问题,求出了alpha即可求解出SVM的权重W,有了权重也就有了最大间隔距离,但是其实上节我们有个假设:就是训练集是线性可分的,这样求出的alpha在[0,infinite]。但是如果数据不是线性可分的呢?此时我们就要允许部分的样本可以越过分类器,这样优化的目标函数就可以不变,只要引入松弛变量 即可,它表示错分类样本点的代价,分类正确时它等于0,当分类错误时 ,其中Tn表示样本的真实标签-1或者1,回顾上节中,我们把支持向量到分类器的距离固定为1,因此两类的支持向量间的距离肯定大于1的,当分……

      码农之家

      焦富霞 提供上传

      资源
      18
      粉丝
      47
      喜欢
      1865
      评论
      17

      Copyright 2018-2021 www.xz577.com 码农之家

      版权投诉 / 书籍推广:520161757@qq.com