Python数据分析基础 PDF 中文高质量版

给大家带来的一篇关于Python数据相关的电子书资源，介绍了关于Python、数据分析方面的内容，本书是由人民邮电出版社出版，格式为PDF，资源大小11.3M，克林顿·布朗利编写，目前豆瓣、亚马逊、当当、京东等电子书综合评分为：7.2

Python数据分析基础电子书封面

读者评价

适合数据分析新手，但需要掌握一定的python语法基础才可以。不然因为作者很粗心，文中有很多小bug。比如，明明说是python3编程，但书中很多代码print没加括号。。。另外，明明是讲解pandas的，但是里面涉及的新函数，语法讲解不清，或者根本就不给介绍。读者要么就得囫囵吞枣，要么就得一遍读，一遍查阅资料才可以。。不然真会把你搞晕。。 唯一的好处就是书中代码都是一遍基础python编，一遍pandas编，让你能明显体会到pandas的好处。这三星是给思路的。 但是作者的责任心真是“呵呵哒。”

可以作为python数据分析入门的第一本书，书中主要讲了csv和excel文件的导入处理，基础内容

想深入应用手中的数据？还是想在上千份文件上重复同样的分析过程？没有编程经验的非程序员们如何能在最短的时间内学会用当今炙手可热的Python语言进行数据分析？

来自Facebook的数据专家Clinton Brownley可以帮您解决上述问题。在他的这本书里，读者将能掌握基本Python编程方法，学会编写出处理电子表格和数据库中的数据的脚本，并了解使用Python模块来解析文件、分组数据和生成统计量的方法。学习基础语法，创建并运行自己的Python脚本，读取和解析CSV文件，读取多个Excel工作表和工作簿，执行数据库操作，搜索特定记录、分组数据和解析文本文件，建立统计图并绘图，生成描述性统计量并估计回归模型和分类模型，在Windows和Mac环境下按计划自动运行脚本。

第一章说实话对于零基础的人来说容易被吓到，成功的从入门到放弃，可以跳过第一章，书内容不错，但是并没有一种循序渐进的感觉。

专业评价

“这本书对于那些使用数据的Python新手来说，是非常有用的学习资源。它的教学风格和附带的例子会帮助用户尽快熟悉Python语言、编程环境和Python生态系统中zui常用的几个软件包。” ——Wes McKinney，pandas库之父

想深入应用手中的数据？还是想在上千份文件上重复同样的分析过程？没有编程经验的非程序员们如何能在zui短的时间内学会用当今炙手可热的Python语言进行数据分析？ 

来自Facebook的数据专家Clinton Brownley可以帮您解决上述问题。在他的这本书里，读者将能掌握基本Python编程方法，学会编写出处理电子表格和数据库中的数据的脚本，并了解使用Python模块来解析文件、分组数据和生成统计量的方法。 

- 学习基础语法，创建并运行自己的Python脚本 

- 读取和解析CSV文件 

- 读取多个Excel工作表和工作簿 

- 执行数据库操作 

- 搜索特定记录、分组数据和解析文本文件 

- 建立统计图并绘图 

- 生成描述性统计量并估计回归模型和分类模型 

- 在Windows和Mac环境下按计划自动运行脚本

内容介绍

本书展示如何用Python程序将不同格式的数据处理和分析任务规模化和自动化。主要内容包括：Python基础知识介绍、CSV文件和Excel文件读写、数据库的操作、示例程序演示、图表的创建，等等。

内容精选

很多关于Python 的图书和在线教程都展示了如何在Python shell 中运行代码。要以这种形式运行Python 代码，需要先打开一个命令行窗口（Windows 系统）或终端窗口（macOS 系统），输入“python”，按回车键之后会看见Python 提示符（就是>>>）。然后，只需一个一个地输入命令，Python 就会依次执行。

>>> 4 + 5 9 
>>> print("I'm excited to learn Python.") I'm excited to learn Python.

这种运行代码的方法简捷有趣，但是当代码的行数不断增加时，就不太合适了。当你的任务需要多行代码才能完成时，一种更简便的方式是将所有的代码写在一个称为Python 脚本的文本文件中，然后运行这个脚本。下面就说明创建Python 脚本的方法。

1.1 　创建Python脚本

要创建一个Python 脚本，需执行下列步骤。

(1) 打开Spyder IDE 或一个文本编辑器（例如：Windows 系统可以使用Notepad、Notepad++ 或Sublime Text；macOS 系统可以使用TextMate、TextWrangler 或Sublime Text）。

(2) 将下面两行代码写在文本文件中：

#!/usr/bin/env python3 print("Output #1: I'm excited to learn Python.")

第一行比较特殊，称为shebang 行，在Python 脚本中，你应该一直将它作为第一行。请注意行中的第一个字符是井号（#）。以# 开头的行为单行注释，所以安装了Windows 系统的计算机不读取也不执行这行代码。但是，安装了Unix 系统的计算机使用这一行来找到执行文件中代码的Python 版本。因为Windows 系统忽略这一行，像macOS 这样的基于Unix 的系统使用这一行，所以加入这一行可以使脚本在不同操作系统的计算机之间具有可移植性。

第二行是一个简单的打印语句。这一行会将双引号之间的文本打印在命令行窗口（Windows）或终端窗口（macOS）上。

(3) 打开Save As 对话框。

(4) 在location 栏中切换到桌面，使文件可以保存到桌面上。

(5) 在format 栏中，选择All Files，使对话框不自动选择文件类型。

(6) 在Save As 或File Name 栏中，输入“first_script.py”。以前，你可能会将这个文本文件保存为.txt 文件，但是在这个示例中，你应该把它保存为.py 文件，来创建一个Python 脚本。

(7) 点击Save。

作者简介

Clinton W. Brownley博士，Facebook数据科学家，负责大数据流水线、统计建模和数据可视化项目，并为大型基础设施建设提供数据驱动的决策建议。

目录

• 前言 xi
• 第 1 章 Python 基础 1
• 1.1 创建 Python 脚本 1
• 1.2 运行 Python 脚本 3
• 1.3 与命令行进行交互的几项技巧 6
• 1.4 Python 语言基础要素 10
• 1.4.1 数值 10
• 1.4.2 字符串 12
• 1.4.3 正则表达式与模式匹配 16
• 1.4.4 日期 19
• 1.4.5 列表 21
• 1.4.6 元组 26
• 1.4.7 字典 27
• 1.4.8 控制流 30
• 1.5 读取文本文件 35
• 1.5.1 创建文本文件 36
• 1.5.2 脚本和输入文件在同一位置 38
• 1.5.3 读取文件的新型语法 38
• 1.6 使用 glob 读取多个文本文件 39
• 1.7 写入文本文件 42
• 1.7.1 向 first_script.py 添加代码 42
• 1.7.2 写入 CSV 文件 45
• 1.8 print 语句 46
• 1.9 本章练习 47
• 第 2 章 CSV文件 48
• 2.1 基础 Python 与 pandas 50
• 2.1.1 读写 CSV 文件（第 1 部分）50
• 2.1.2 基本字符串分析是如何失败的 56
• 2.1.3 读写 CSV 文件（第 2 部分）57
• 2.2 筛选特定的行 58
• 2.2.1 行中的值满足某个条件 59
• 2.2.2 行中的值属于某个集合 60
• 2.2.3 行中的值匹配于某个模式 正则表达式 62
• 2.3 选取特定的列 64
• 2.3.1 列索引值 64
• 2.3.2 列标题 65
• 2.4 选取连续的行 67
• 2.5 添加标题行 69
• 2.6 读取多个 CSV 文件 71
• 2.7 从多个文件中连接数据 75
• 2.8 计算每个文件中值的总和与均值 78
• 2.9 本章练习 81
• 第 3 章 Excel 文件 82
• 3.1 内省 Excel 工作簿 84
• 3.2 处理单个工作表 88
• 3.2.1 读写 Excel 文件 88
• 3.2.2 筛选特定行 92
• 3.2.3 选取特定列 98
• 3.3 读取工作簿中的所有工作表 101
• 3.3.1 在所有工作表中筛选特定行 102
• 3.3.2 在所有工作表中选取特定列 104
• 3.4 在 Excel 工作簿中读取一组工作表 106
• 3.5 处理多个工作簿 108
• 3.5.1 工作表计数以及每个工作表中的行列计数 110
• 3.5.2 从多个工作簿中连接数据 111
• 3.5.3 为每个工作簿和工作表计算总数和均值 113
• 3.6 本章练习 117
• 第 4 章 数据库 118
• 4.1 Python 内置的 sqlite3 模块 119
• 4.1.1 向表中插入新记录 124
• 4.1.2 更新表中记录 128
• 4.2 MySQL 数据库 131
• 4.2.1 向表中插入新记录 135
• 4.2.2 查询一个表并将输出写入 CSV 文件 140
• 4.2.3 更新表中记录 142
• 4.3 本章练习 146
• 第 5 章 应用程序 147
• 5.1 在一个大文件集合中查找一组项目 147
• 5.2 为 CSV 文件中数据的任意数目分类计算统计量 158
• 5.3 为文本文件中数据的任意数目分类计算统计量 167
• 5.4 本章练习 174
• 第 6 章 图与图表 175
• 6.1 matplotlib 175
• 6.1.1 条形图 175
• 6.1.2 直方图 177
• 6.1.3 折线图 178
• 6.1.4 散点图 180
• 6.1.5 箱线图 181
• 6.2 pandas 183
• 6.3 ggplot 184
• 6.4 seaborn 186
• 第 7 章 描述性统计与建模 192
• 7.1 数据集 192
• 7.1.1 葡萄酒质量 192
• 7.1.2 客户流失 193
• 7.2 葡萄酒质量 194
• 7.2.1 描述性统计 194
• 7.2.2 分组、直方图与 t 检验 195
• 7.2.3 成对变量之间的关系和相关性 196
• 7.2.4 使用最小二乘估计进行线性回归 198
• 7.2.5 系数解释 200
• 7.2.6 自变量标准化 200
• 7.2.7 预测 202
• 7.3 客户流失 203
• 7.3.1 逻辑斯蒂回归 205
• 7.3.2 系数解释 207
• 7.3.3 预测 208
• 第 8 章 按计划自动运行脚本 209
• 8.1 任务计划程序（Windows 系统）209
• 8.2 cron 工具（macOS 系统和 Unix 系统）215
• 8.2.1 cron 表文件：一次性设置 216
• 8.2.2 向 cron 表文件中添加 cron 任务 216
• 第 9 章 从这里启航 220
• 9.1 更多的标准库模块和内置函数 221
• 9.1.1 Python 标准库（PSL）：更多的标准模块 221
• 9.1.2 内置函数 222
• 9.2 Python 包索引（PyPI）：更多的扩展模块 222
• 9.2.1 NumPy 223
• 9.2.2 SciPy 227
• 9.2.3 Scikit-Learn 230
• 9.2.4 更多的扩展包 232
• 9.3 更多的数据结构 232
• 9.3.1 栈 233
• 9.3.2 队列 233
• 9.3.3 图 233
• 9.3.4 树 234
• 9.4 从这里启航 234
• 附录A 下载指南 236
• 附录B 练习答案 245
• 作者介绍 247
• 封面介绍 247

读书笔记

详解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 & 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 < n:
    result.append(fn(i))
    i += 1
  return result # 返回列表
##推荐
def my_range(n):
  i = 0
  result = []
  while i < 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 > hour > 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 > hour > 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 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

上一篇：Java编程的逻辑 　下一篇：Python机器学习经典实例