当前位置:首页 > Python >
《Python机器学习经典实例》电子书封面

Python机器学习经典实例

  • 发布时间:2019年11月28日 14:42:07
  • 作者:普拉提克·乔西
  • 大小:27.3M
  • 类别:Python电子书
  • 格式:PDF
  • 版本:超清中文版
  • 评分:9.9

    Python机器学习经典实例 PDF 超清中文版

      给大家带来的一篇关于Python相关的电子书资源,介绍了关于Python、机器学习方面的内容,本书是由人民邮电出版社出版,格式为PDF,资源大小27.3M,普拉提克·乔西编写,目前豆瓣、亚马逊、当当、京东等电子书综合评分为:8.8分

      Tags:python 机器学习 

      内容介绍

      Python机器学习经典实例

      Python机器学习经典实例电子书封面

      读者评价

      很多代码,但是重复的太多了。比如用逻辑回归写了个代码,预处理部分写了函数,然后从sklearn调用Logistic_regression,然后fit,predict,然后到svm部分呢,预处理部分写了个代码,然后又调用sklearn svm.fit ,predict,问题是预处理部分的代码都很类似。没必要每个例子都重复一遍的。不够简洁,也许这就是cookbook的特点吧

      本书(《Python 机器学习经典实例》)的标题“经典实例”让我非常感兴趣。

      一直认为学习任何新事物,先上手实现简单的demo,再分析这个demo做了什么,怎么做,才能更快的学习。如果是在初始阶段就大量的学习理论,只会对要学习的东西感到痛苦,“这个有什么用啊?”或者“虽然每个字都能看懂,但放一起就不知道在说什么了”。幸运的是本书就同书名一样,上手就是实例,也穿插了必要的专有名词解释,总体来说还是能够跟得上进度。并且给出了所使用的数据,能够和书中得到相同的结果,这一反馈更能够增强学习的意愿与兴趣。但是另一方面,只给出“结果”,而没有“原因”,在一定程度上只是学会了“书里面的知识”,而无法从虚拟的例子映射到实际的现实问题。但鱼和熊掌不可得兼,专注做好一件事,对于“机器学习”的通俗解释,可以从另一本书中找到答案(还没找到这本书)。

      专业评价

      用火的Python语言、通过各种各样的机器学习算法来解决实际问题!书中介绍的主要问题如下。

      - 探索分类分析算法并将其应用于收入等级评估问题

      - 使用预测建模并将其应用到实际问题中

      - 了解如何使用无监督学习来执行市场细分

      - 探索数据可视化技术以多种方式与数据进行交互

      - 了解如何构建推荐引擎

      - 理解如何与文本数据交互并构建模型来分析它

      - 使用隐马尔科夫模型来研究语音数据并识别语音

      内容简介

      在如今这个处处以数据驱动的世界中,机器学习正变得越来越大众化。它已经被广泛地应用于不同领域,如搜索引擎、机器人、无人驾驶汽车等。本书首先通过实用的案例介绍机器学习的基础知识,然后介绍一些稍微复杂的机器学习算法,例如支持向量机、极端随机森林、隐马尔可夫模型、条件随机场、深度神经网络,等等。

      本书是为想用机器学习算法开发应用程序的Python 程序员准备的。它适合Python 初学者阅读,不过熟悉Python 编程方法对体验示例代码大有裨益。

      内容精选

      在真实世界中,经常需要处理大量的原始数据,这些原始数据是机器学习算法无法理解的。为了让机器学习算法理解原始数据,需要对数据进行预处理。

      1.2.1 准备工作

      来看看Python是如何对数据进行预处理的。首先,用你最喜欢的文本编辑器打开一个扩展名为.py的文件,例如preprocessor.py。然后在文件里加入下面两行代码:

      import numpy as np
      from sklearn import preprocessing

      我们只是加入了两个必要的程序包。接下来创建一些样本数据。向文件中添加下面这行代码:

      data = np.array([[3,  -1.5,    2,  -5.4], [0,    4,    -0.3,  2.1], [1,    3.3,  
      -1.9, -4.3]])

      现在就可以对数据进行预处理了。

      1.2.2 详细步骤

      数据可以通过许多技术进行预处理,接下来将介绍一些最常用的预处理技术。

      1. 均值移除(Mean removal)

      通常我们会把每个特征的平均值移除,以保证特征均值为0(即标准化处理)。这样做可以消除特征彼此间的偏差(bias)。将下面几行代码加入之前打开的Python文件中:

      data_standardized = preprocessing.scale(data) 
      print "\nMean =", data_standardized.mean(axis=0)
      print "Std deviation =", data_standardized.std(axis=0)

      现在来运行代码。打开命令行工具,然后输入以下命令:

      $ python preprocessor.py

      命令行工具中将显示以下结果:

      Mean = [  5.55111512e-17  -1.11022302e-16  -7.40148683e-17  -7.40148683e-17]
      Std deviation = [ 1.  1.  1.  1.]

      你会发现特征均值几乎是0,而且标准差为1。

      2. 范围缩放(Scaling)

      数据点中每个特征的数值范围可能变化很大,因此,有时将特征的数值范围缩放到合理的大小是非常重要的。在Python文件中加入下面几行代码,然后运行程序:

      data_scaler = preprocessing.MinMaxScaler(feature_range=(0, 1)) 
      data_scaled = data_scaler.fit_transform(data)
      print "\nMin max scaled data =", data_scaled

      范围缩放之后,所有数据点的特征数值都位于指定的数值范围内。输出结果如下所示:

      Min max scaled data:
      [[ 1.            0.            1.            0.        ]
       [ 0.            1.            0.41025641    1.        ]
       [ 0.33333333    0.87272727    0.            0.14666667]]

      3. 归一化(Normalization)

      数据归一化用于需要对特征向量的值进行调整时,以保证每个特征向量的值都缩放到相同的数值范围。机器学习中最常用的归一化形式就是将特征向量调整为L1范数,使特征向量的数值之和为1。增加下面两行代码到前面的Python文件中:

      data_normalized = preprocessing.normalize(data, norm='l1') 
      print "\nL1 normalized data =", data_normalized

      执行Python文件,就可以看到下面的结果:

      L1    normalized    data:    
      [[    0.25210084    -0.12605042    0.16806723    -0.45378151]
       [    0.             0.625        -0.046875       0.328125  ]
       [    0.0952381      0.31428571   -0.18095238    -0.40952381]]

      这个方法经常用于确保数据点没有因为特征的基本性质而产生较大差异,即确保数据处于同一数量级,提高不同特征数据的可比性。

      4. 二值化(Binarization)

      二值化用于将数值特征向量转换为布尔类型向量。增加下面两行代码到前面的Python文件中:

      data_binarized = preprocessing.Binarizer(threshold=1.4).transform(data)
      print "\nBinarized data =", data_binarized

      再次执行Python文件,就可以看到下面的结果:

      Binarized data:
      [[    1.    0.    1.    0.]
       [    0.    1.    0.    1.]
       [    0.    1.    0.    0.]]

      如果事先已经对数据有了一定的了解,就会发现使用这个技术的好处了。

      5. 独热编码

      通常,需要处理的数值都是稀疏地、散乱地分布在空间中,然而,我们并不需要存储这些大数值,这时就需要使用独热编码(One-Hot Encoding)。可以把独热编码看作是一种收紧(tighten)特征向量的工具。它把特征向量的每个特征与特征的非重复总数相对应,通过one-of-k的形式对每个值进行编码。特征向量的每个特征值都按照这种方式编码,这样可以更加有效地表示空间。例如,我们需要处理4维向量空间,当给一个特性向量的第n个特征进行编码时,编码器会遍历每个特征向量的第n个特征,然后进行非重复计数。如果非重复计数的值是K,那么就把这个特征转换为只有一个值是1其他值都是0的K维向量。增加下面几行代码到前面的Python文件中:

      encoder = preprocessing.OneHotEncoder()
      encoder.fit([[0, 2, 1, 12], [1, 3, 5, 3], [2, 3, 2, 12], [1, 2, 4, 3]])
      encoded_vector = encoder.transform([[2, 3, 5, 3]]).toarray() 
      print "\nEncoded vector =", encoded_vector

      结果如下所示:

      Encoded vector:
      [[ 0.  0.  1.  0.  1.  0.  0.  0.  1.  1.  0.]]

      在上面的示例中,观察一下每个特征向量的第三个特征,分别是1、5、2、4这4个不重复的值,也就是说独热编码向量的长度是4。如果你需要对5进行编码,那么向量就是[0, 1, 0, 0]。向量中只有一个值是1。第二个元素是1,对应的值是5。

      ……

      作者介绍

      Prateek Joshi

      人工智能专家,重点关注基于内容的分析和深度学习,曾在英伟达、微软研究院、高通公司以及硅谷的几家早期创业公司任职。

      译者简介:

      陶俊杰

      长期从事数据分析工作,酷爱Python,每天都和Python面对面,乐此不疲。本科毕业于北京交通大学机电学院,硕士毕业于北京交通大学经管学院。曾就职于中国移动设计院,目前在京东任职。

      陈小莉

      长期从事数据分析工作,喜欢Python。本科与硕士毕业于北京交通大学电信学院。目前在中科院从事科技文献与专利分析工作。

      目录

      • 第1章 监督学习  1
      • 1.1 简介  1
      • 1.2 数据预处理技术  2
      • 1.2.1 准备工作  2
      • 1.2.2 详细步骤  2
      • 1.3 标记编码方法  4
      • 1.4 创建线性回归器  6
      • 1.4.1 准备工作  6
      • 1.4.2 详细步骤  7
      • 1.5 计算回归准确性  9
      • 1.5.1 准备工作  9
      • 1.5.2 详细步骤  10
      • 1.6 保存模型数据  10
      • 1.7 创建岭回归器  11
      • 1.7.1 准备工作  11
      • 1.7.2 详细步骤  12
      • 1.8 创建多项式回归器  13
      • 1.8.1 准备工作  13
      • 1.8.2 详细步骤  14
      • 1.9 估算房屋价格  15
      • 1.9.1 准备工作  15
      • 1.9.2 详细步骤  16
      • 1.10 计算特征的相对重要性  17
      • 1.11 评估共享单车的需求分布  19
      • 1.11.1 准备工作  19
      • 1.11.2 详细步骤  19
      • 1.11.3 更多内容  21
      • 第2章 创建分类器  24
      • 2.1 简介  24
      • 2.2 建立简单分类器  25
      • 2.2.1 详细步骤  25
      • 2.2.2 更多内容  27
      • 2.3 建立逻辑回归分类器  27
      • 2.4 建立朴素贝叶斯分类器  31
      • 2.5 将数据集分割成训练集和测试集  32
      • 2.6 用交叉验证检验模型准确性  33
      • 2.6.1 准备工作  34
      • 2.6.2 详细步骤  34
      • 2.7 混淆矩阵可视化  35
      • 2.8 提取性能报告  37
      • 2.9 根据汽车特征评估质量  38
      • 2.9.1 准备工作  38
      • 2.9.2 详细步骤  38
      • 2.10 生成验证曲线  40
      • 2.11 生成学习曲线  43
      • 2.12 估算收入阶层  45
      • 第3章 预测建模  48
      • 3.1 简介  48
      • 3.2 用SVM建立线性分类器  49
      • 3.2.1 准备工作  49
      • 3.2.2 详细步骤  50
      • 3.3 用SVM建立非线性分类器  53
      • 3.4 解决类型数量不平衡问题  55
      • 3.5 提取置信度  58
      • 3.6 寻找最优超参数  60
      • 3.7 建立事件预测器  62
      • 3.7.1 准备工作  62
      • 3.7.2 详细步骤  62
      • 3.8 估算交通流量  64
      • 3.8.1 准备工作  64
      • 3.8.2 详细步骤  64
      • 第4章 无监督学习——聚类  67
      • 4.1 简介  67
      • 4.2 用k-means算法聚类数据  67
      • 4.3 用矢量量化压缩图片  70
      • 4.4 建立均值漂移聚类模型  74
      • 4.5 用凝聚层次聚类进行数据分组  76
      • 4.6 评价聚类算法的聚类效果  79
      • 4.7 用DBSCAN算法自动估算集群数量  82
      • 4.8 探索股票数据的模式  86
      • 4.9 建立客户细分模型  88
      • 第5章 构建推荐引擎  91
      • 5.1 简介  91
      • 5.2 为数据处理构建函数组合  92
      • 5.3 构建机器学习流水线  93
      • 5.3.1 详细步骤  93
      • 5.3.2 工作原理  95
      • 5.4 寻找最近邻  95
      • 5.5 构建一个KNN分类器  98
      • 5.5.1 详细步骤  98
      • 5.5.2 工作原理  102
      • 5.6 构建一个KNN回归器  102
      • 5.6.1 详细步骤  102
      • 5.6.2 工作原理  104
      • 5.7 计算欧氏距离分数  105
      • 5.8 计算皮尔逊相关系数  106
      • 5.9 寻找数据集中的相似用户  108
      • 5.10 生成电影推荐  109
      • 第6章 分析文本数据  112
      • 6.1 简介  112
      • 6.2 用标记解析的方法预处理数据  113
      • 6.3 提取文本数据的词干  114
      • 6.3.1 详细步骤  114
      • 6.3.2 工作原理  115
      • 6.4 用词形还原的方法还原文本的基本形式  116
      • 6.5 用分块的方法划分文本  117
      • 6.6 创建词袋模型  118
      • 6.6.1 详细步骤  118
      • 6.6.2 工作原理  120
      • 6.7 创建文本分类器  121
      • 6.7.1 详细步骤  121
      • 6.7.2 工作原理  123
      • 6.8 识别性别  124
      • 6.9 分析句子的情感  125
      • 6.9.1 详细步骤  126
      • 6.9.2 工作原理  128
      • 6.10 用主题建模识别文本的模式  128
      • 6.10.1 详细步骤  128
      • 6.10.2 工作原理  131
      • 第7章 语音识别  132
      • 7.1 简介  132
      • 7.2 读取和绘制音频数据  132
      • 7.3 将音频信号转换为频域  134
      • 7.4 自定义参数生成音频信号  136
      • 7.5 合成音乐  138
      • 7.6 提取频域特征  140
      • 7.7 创建隐马尔科夫模型  142
      • 7.8 创建一个语音识别器  143
      • 第8章 解剖时间序列和时序数据  147
      • 8.1 简介  147
      • 8.2 将数据转换为时间序列格式  148
      • 8.3 切分时间序列数据  150
      • 8.4 操作时间序列数据  152
      • 8.5 从时间序列数据中提取统计数字  154
      • 8.6 针对序列数据创建隐马尔科夫模型  157
      • 8.6.1 准备工作  158
      • 8.6.2 详细步骤  158
      • 8.7 针对序列文本数据创建条件随机场  161
      • 8.7.1 准备工作  161
      • 8.7.2 详细步骤  161
      • 8.8 用隐马尔科夫模型分析股票市场数据  164
      • 第9章 图像内容分析  166
      • 9.1 简介  166
      • 9.2 用OpenCV-Pyhon操作图像  167
      • 9.3 检测边  170
      • 9.4 直方图均衡化  174
      • 9.5 检测棱角  176
      • 9.6 检测SIFT特征点  178
      • 9.7 创建Star特征检测器  180
      • 9.8 利用视觉码本和向量量化创建特征  182
      • 9.9 用极端随机森林训练图像分类器  185
      • 9.10 创建一个对象识别器  187
      • 第10章 人脸识别  189
      • 10.1 简介  189
      • 10.2 从网络摄像头采集和处理视频信息  189
      • 10.3 用Haar级联创建一个人脸识别器  191
      • 10.4 创建一个眼睛和鼻子检测器  193
      • 10.5 做主成分分析  196
      • 10.6 做核主成分分析  197
      • 10.7 做盲源分离  201
      • 10.8 用局部二值模式直方图创建一个人脸识别器  205
      • 第11章 深度神经网络  210
      • 11.1 简介  210
      • 11.2 创建一个感知器  211
      • 11.3 创建一个单层神经网络  213
      • 11.4 创建一个深度神经网络  216
      • 11.5 创建一个向量量化器  219
      • 11.6 为序列数据分析创建一个递归神经网络  221
      • 11.7 在光学字符识别数据库中将字符可视化  225
      • 11.8 用神经网络创建一个光学字符识别器  226
      • 第12章 可视化数据  230
      • 12.1 简介  230
      • 12.2 画3D散点图  230
      • 12.3 画气泡图  232
      • 12.4 画动态气泡图  233
      • 12.5 画饼图  235
      • 12.6 画日期格式的时间序列数据  237
      • 12.7 画直方图  239
      • 12.8 可视化热力图  241
      • 12.9 动态信号的可视化模拟  242

      读书笔记

      详解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 Linux系统管理与自动化运维》Ansible详解(一)

      Ansible维护模式通常由控制机和被管理机组成。因为Ansible的特性不像其他运维工具那样需要在被监控的目标上安装agent,所以我们的侧重点只需要放在安装了Ansible的服务器上(当然用于实验环境的话可以是一台笔记本,台式机或者仅仅只需要一台虚拟机即可)。Ansible可以通过SSH进行远程链接到对端主机上,然后执行你想要执行的playbook或者指令。所有的远程主机都可以在inventory中被定义。

      1.:默认command

      ansible test -m ping  #测试ansible是否正常
      ansible test -a "whoami" 
      ansible test -a "hostname"

      2.实现拷贝文件:copy 

      ansible test -m copy -a "src=/tmp/data.txt dest=/tmp/data.txt" #实现将本地的/tmp/data.txt 拷贝到远程主机tmp/data.txt中

      3.修改文件权限:file

      file 将权限改为700 所有者和所属组改为anan 

      ansible test -m file -a"dest=/tmp/data.txt mode=700 owner=anan group=anan"

      4.远程服务器安装软件:

      ansible test -m yum -a "name=lrzsz state=present " -become #become类似于sudo 安装lrzsz

      5.ansible-playbook实现1-4操作

      ansbile-playbook test_playbook.yml
      ---
      - hosts: test
        tasks:
        - name: test ping 
          ping:
      
        - name: test copy file
          copy: src=/tmp/data.txt dest=/tmp/data2.txt
      
        - name: test change file mode
          file: dest=/tmp/data2.txt mode=700 owner=anan group=anan
      
        - name: test install software
          yum: name="lrzsz" state=latest #absent present removed latest

      6.列出生效的主机 (也可以通过-i指定hosts文件)\ 

      ansible test --list-hosts\
      ansible test -i hostsdir

       

      远程服务器匹配规则

      7.分组定义主机:

      hosts文件如下:

      [user:children]
      webserver
      db_server
      monitor_server
      docker_server
      master
      
      [webserver:children]
      http_server
      nginx_server
      
      [db_server:children]
      mysql_server
      redis_server
      
      [monitor_server:children]
      nagios_server
      zabbix_server
      
      [container_server:children]
      docker_server
      
      [master]
      10.1.11.34
      
      [http_server]
      10.1.11.35
      
      [http_server:vars]
      http_port=80
      maxRequestsPerChild=808
      
      [nginx_server]
      10.1.11.36
      
      [mysql_server]
      10.1.11.37
      
      [redis_server]
      [nagios_server]
      [zabbix_server]
      [docker_server]
      
      [test]
      10.1.11.36

      8.动态Inverntory获取

      hosts表:
      
      create table hosts(
          id int not null auto_increment,
          host varchar(15) default null,
          groupname varchar(15) default null,
          username varchar(15) default null,
          port int(11) default '22',
          primary key(id)
          )engine=InnoDB auto_increment=3 default charset=utf8mb4;
      
      
      insert into hosts 
      (host,groupname,username)
      values(('10.1.11.35','anan','anan'),('10.1.11.36','anan','anan'),('10.1.11.37','anan','anan'));

      动态获取服务器列表程序

      #!/usr/bin/env python
      # -*- coding: utf-8 -*-
      # @Time    : 2018/7/20 16:20
      # @Author  : anan
      # @Site    : 
      # @File    : hosts.py
      # @Software: PyCharm
      
      
      from __future__ import print_function
      import argparse
      import json
      from collections import defaultdict
      from contextlib import contextmanager
      
      import pymysql
      
      def to_json(in_dict):
          return json.dumps(in_dict,sort_keys=True,indent=2)
      
      @contextmanager
      def get_conn(**kwargs):
          conn=pymysql.connect(**kwargs)
          try:
              yield conn
          finally:
              conn.close()
      
      def parse_args():
          parser=argparse.ArgumentParser(description="Openstack Inventory Module")
          group=parser.add_mutually_exclusive_group(required=True)
          group.add_argument('--list',action='store_true',help='List active server')
          group.add_argument('--host',help="List details about the specific host")
          return parser.parse_args()
      
      def list_all_host(conn):
          hosts=defaultdict(list)
      
          with conn as cur:
              cur.execute('select * from hosts')
              rows=cur.fetchall()
              for row in rows:
                  no,host,group,user,port=row
                  hosts[group].append(host)
          return hosts
      
      
      def get_host_detail(conn,host):
          details={}
          with conn as cur:
              cur.execute("select * from hosts where host='{0}'".format(host))
              rows=cur.fetchall()
              if rows:
                  no,host,group,user,port=rows[0]
                  details.update(ansible_user=user,ansible_port=port)
      
          return details
      
      
      def main():
          parser=parse_args()
          with get_conn(host='10.1.11.37',user='root',passwd='passwd',db='test') as conn:
              if parser.list:
                  hosts=list_all_host(conn)
                  print(to_json(hosts))
              else:
                  details=get_host_detail(conn,parser.host)
                  print(to_json(details))
      
      if __name__ == '__main__':
          main()

      Inventory行为参数

      yaml文件编辑:

      yaml语法规则

      palybook2.yml

      ---
      #一个职工的记录
      name: examaple developer
      job: developer
      skill: elite
      employed: True
      foods:
        - Apple
        - Orange
        - Strawberry
        - Mango
      Language:
        ruby: elite
        Python: elite
        dotnet: Lame

      *ansible目前已经提供了超过950个模块:用户可以根据自己喜欢的编程语言编写第三方模块(学习和使用Ansible模块)*

      ansible-doc file

      ansible-doc -l file

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

      上一篇:Python数据分析基础

      下一篇:Python Linux系统管理与自动化运维

      展开 +

      收起 -

      下载地址:百度网盘下载
      Python 相关电子书
      Python+Spark2.0+Hadoop机器学习与大数据实战
      Python+Spark2.0+Hadoop机器学习与大数据实战 PDF 原书扫描版

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

      立即下载
      机器学习:使用OpenCV和Python进行智能图像处理
      机器学习:使用OpenCV和Python进行智能图像处理 PDF 完整英文版

      OpenCV是1个综合性了經典和优秀计算机视觉、机器学习算法的开源系统库。根据与PythonAnaconda版本号融合,我也能够 获得你所必须的全部开源系统测算库。 这书最先详细介绍归类和重归等统计分

      立即下载
      Python机器学习基础教程
      Python机器学习基础教程 PDF 超清完整版

      这是一本机器学习入门书,以Python语言介绍,包含机器学习的基本概念及其应用;实践中最常用的机器学习算法以及这些算法的优缺点;待处理数据的呈现方式的重要性等内容

      立即下载
      零起点Python机器学习快速入门
      零起点Python机器学习快速入门 PDF 原书超清版

      这本书采用独创的黑箱模式,MBA案例教学机制,结合一线实战案例,介绍Sklearn人工智能模块库和常用的机器学习算法,读完本书内容和配套的教学代码,就能够编写简单的机器学习函数

      立即下载
      Python机器学习:预测分析核心算法
      Python机器学习:预测分析核心算法 PDF 高清版

      在学习和研究机器学习的时候,面临令人眼花缭乱的算法,机器学习新手往往会不知所措。本书从算法和Python语言实现的角度,帮助读者认识机器学习。 本书专注于两类核心的算法族,即惩罚

      立即下载
      机器学习:Python实践
      机器学习:Python实践 PDF 原书完整版

      本书系统地讲解了机器学习的基本知识,以实践为导向,使用 scikit-learn 作为编程框架,强调简单、快速地建立模型,并利用机器学习解决实际问题

      立即下载
      读者心得
      87小时1分钟前回答

      Python3.5集合及其常见运算实例详解

      本文实例讲述了Python3.5集合及其常见运算。分享给大家供大家参考,具体如下: 1、集合的定义:集合是一个 无序的、无重复的数据 的数据组合。 2、集合的特征: (1) 去除重复元素 :将一个列表变成集合就可实现去重。 (2) 测试关系 :测试两组数据之间交集、并集、差集等关系。 3、集合常用的操作: (1) 去重复 :将列表变成集合,形式: 集合=set(列表) list_1 = [1,3,5,3,6,8,9,6,8,1]list_1 = set(list_1)print(list_1,type(list_1)) 运行结果: {1, 3, 5, 6, 8, 9} class 'set' (2)测试两个集合的 交集 ——形式为: print((集合1).intersection(集合2)) 或 print(集合1 list_2) #两个集合的交集 运行结果: {1, 2, 3, 4, 5, 6, 8, 9} {0, 2, 5……

      88小时44分钟前回答

      python字符串string的内置方法实例详解

      下面给大家分享python 字符串string的内置方法,具体内容详情如下所示: #__author: "Pizer Wang"#__date: 2018/1/28a = "Let's go"print(a)print("-------------------")a = 'Let\'s go'print(a)print("-------------------")print("hello" * 3)print("helloworld"[2:])print("-------------------")print("ell" in "helloworld")print("-------------------")print("Pizer is a good student")print("%s is a goog student" % "Pizer")print("-------------------")a = "1234"b = "abcd"c = "!@#$"d = a + b + cprint(d)d = "".join([a, b, c])print(d)d = ", ".join([a, b, c])print(d)d = "++".join([a, b, c])print(d)print("-------------------")print("string的内置方法")str = "helloworld"print(str.count("l")) #统计元个数print(str.capitalize()) #首字母大写print(str.center(25, "-")) #居中print(……

      网友NO.46355
      网友NO.46355

      无监督学习经典模型 无监督学习着重于发现数据本身的分布特点 无监督学习不需要对数据进行标记 节省大量人力 也让数据的规模 变得不可限量 1 发现数据群落 数据聚类 也可以寻找 离群样本 2 特征降维 保留数据具有区分性的低维特征 这些都是在海量数据处理中非常实用的技术 数据聚类 K均值算法(预设聚类的个数 不断更新聚类中心 迭代 ,是所有数据点到其所属聚类中心距离平方和趋于稳定) 过程 ①首先 随机布设K个特证空间内的点作为初始的聚类中心 ②然后 对于根据每个数据的特征向量 从K个聚类中心中 寻找距离最近的一个 并且把该数据标记为从属与这个聚类中心 ③接着 在所有数据都被标记了聚类中心之后 根据这些数据新分配的类簇 重新对K个聚类中心做计算 ④如果一轮下来 所有数据从属的聚类中心与上一次的分配的类簇没有变化 那么迭代可以 停止 否则回到②继续循环

      网友NO.36317
      网友NO.36317

      数据工作的基本流程 定义问题: 我们首先需要解决的是我们将面临一个什么问题,需要我们做什么,俗话说的磨刀不误砍柴工,首先看清对手是谁才能有的放矢。 收集数据: 根据确定的数据分析对象,抽象出在数据分析中所需要的特征信息,然后选择合适的信息收集方法,将收集到的信息存入数据库。对于海量数据,选择一个合适的数据存储和管理的数据仓库是至关重要的。 准备消费数据: 把不同来源、格式、特点性质的数据在逻辑上或物理上有机地集中,从而为企业提供全面的数据共享。如果执行多数的数据挖掘算法,即使是在少量数据上也需要很长的时间,而做商业运营数据挖掘时数据量往往非常大。数据规约技术可以用来得到数据集的规约表示,它小得多,但仍然接近于保持原数据的完整性,并且规约后执行数据挖掘结果与规约前执行结果相同或几乎相同。在数据库中的数据有一些是不完整的(有些感兴趣的属性缺少属性值)、含噪声的(包含错误的属性值),并且是不一致的(同样的信息不同的表示方式),因此需要进行数据清理,将完整、正确、一致的数据信息存入数据仓库中。不然,挖掘的结果会差强人意。通过平滑聚集、数据概化、规范化等方式将数据转换成适用于数据挖掘的形式。对于有些实数型数据,通过概念分层和数据的离散化来转换数据也是重要的一步。 探索性分析: 根据数据仓库中的数据信息,选择合适的分析工具,应用统计方法、事例推理、决策树、规则推理、模糊集,甚至神经网络、遗传算法的方法处理信息,得出有用的分析信息。 数据建模: 像描述性和推论性统计数据一样,数据建模可以总结数据或预测未来的结果。 您的数据集和预期结果将决定可供使用的算法。 重要的是要记住,算法是工具,而不是魔杖。 你仍然必须是知道如何为工作选择正确的工具的工匠。 一个比喻就是要求有人给你一把飞利浦剃须刀,他们给你一把螺丝刀或者一把锤子。 充其量,它显示完全缺乏了解。 最糟糕的是,这使得项目不可能完成。 数据建模也是如此。 错误的模型可能导致最差的表现,甚至会导致错误的结论。 模型验证和模型使用: 用训练数据对模型进行训练之后,就可以用于预测数据。

      网友NO.46008
      网友NO.46008

      深度学习无处不在。深度学习建立在几十年前的神经网络的基础上,但是最近的进步始于几年前,并极大地提高了深度神经网络的认知能力,引起了人们的广泛兴趣。如果你对神经网络还不熟悉,KDnuggets 有很多文章详细介绍了最近深度学习大量的创新、成就和赞许。

      码农之家

      江弘博 提供上传

      资源
      32
      粉丝
      8
      喜欢
      1320
      评论
      3

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

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