常用循环：

When looping through a sequence, the position index and corresponding value can be retrieved at the same time

using the enumerate() function.

>>>

>>> for i, v in enumerate(['tic', 'tac', 'toe']):

... print(i, v)

...

0 tic

1 tac

2 toe

To loop over two or more sequences at the same time, the entries can be paired with the zip() function.

>>>

>>> questions = ['name', 'quest', 'favorite color']

>>> answers = ['lancelot', 'the holy grail', 'blue']

>>> for q, a in zip(questions, answers):

... print('What is your {0}? It is {1}.'.format(q, a))

...

What is your name? It is lancelot.

What is your quest? It is the holy grail.

What is your favorite color? It is blue.

To loop over a sequence in reverse, first specify the sequence in a forward direction and then call the reversed() function.

>>>

>>> for i in reversed(range(1, 10, 2)):

... print(i)

...

9

7

5

3

1

To loop over a sequence in sorted order, use the sorted() function which returns a new sorted list while leaving the source unaltered.

>>>

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']

>>> for f in sorted(set(basket)):

... print(f)

...

apple

banana

orange

pear

语法糖：

() 表达式，元组，生成器表达式

[] 列表 ， 列表解析

{} 字典，集合，集合和字典解析

生成器表达式，列表生成式：

Generator expressions and list comprehensions

Two common operations on an iterator’s output are 1) performing some operation for every element,

2) selecting a subset of elements that meet some condition. For example, given a list of strings,

you might want to strip off trailing whitespace from each line or extract all the strings containing a given substring.

List comprehensions and generator expressions (short form: “listcomps” and “genexps”) are a concise notation for such operations,

borrowed from the functional programming language Haskell (https://www.haskell.org/). You can strip all the whitespace

from a stream of strings with the following code:

line_list = [' line 1\n', 'line 2 \n', ...]

# Generator expression -- returns iterator

stripped_iter = (line.strip() for line in line_list)

# List comprehension -- returns list

stripped_list = [line.strip() for line in line_list]

You can select only certain elements by adding an "if" condition:

stripped_list = [line.strip() for line in line_list

if line != ""]

The for...in clauses contain the sequences to be iterated over. The sequences do not have to be the same length,

because they are iterated over from left to right, not in parallel. For each element in sequence1, sequence2 is looped over

from the beginning. sequence3 is then looped over for each resulting pair of elements from sequence1 and sequence2.

example:

mapping = {

order_book_id: index_code for index_code in SHENWAN_INDUSTRY_MAP

for order_book_id in self.get_shenwan_industry(index_code, date)

}

闭包：

编码：

string is a sequence of characters, ie unicode codepoints; these are an abstract concept, and can't be directly stored on disk.

.encode() method of a string to get byte string

byte string is a sequence of, unsurprisingly, bytes - things that can be stored on disk

.decode() method of the byte string to get string

程序一般统一用unicode，而不同存储介质可以有自己的选择，比如gbk，utf8

一个重要的技巧，解铃还需系铃人，在你知道编码的最源头，就用相适配的编码进行编解码，一旦编解开，之后就可以一路编解了

协程：

协程就是用户态下的线程，是人们在有了进程、线程之后仍觉得效率不够，而追求的又一种高并发解决方案。

为什么说是用户态，是因为操作系统并不知道它的存在，它是由程序员自己控制、互相协作的让出控制权而不是像进程、

线程那样由操作系统调度决定是否让出控制权。

http://python.jobbole.com/85438/

Install Python 3.x in CentOS / RedHat 6.x from sources

http://www.sromero.org/wiki/linux/aplicaciones/python/python34_centos6

CentOS and RedHat 6.x ship with Python 2, so you cannot/shouldn't install Python 3

at the system level (with or without the package manager). But you can setup Python 3.x (3.4.3 in our example below)

in a separate "virtualenv" environment, not affecting the system packages and allowing you to develop Python 3.x programs.

You may already have Python installed on your server, you can verify using:

# which python

/usr/bin/python

# python --version

Python 2.6.6

For this install we want to leave existing Python packages and executables in place.

--------------------------------------------------

As we're going to compile python3, we need to install the required development packages:

# yum groupinstall "Development tools"

# yum install zlib-devel bzip2-devel openssl-devel ncurses-devel zx-devel \

sqlite-devel readline-devel tk-devel gdbm-devel db4-devel libpcap-devel

python-devel libffi-devel （libxml2-devel openssl-devel libxslt-devel gcc libgcc glibc）

mysql-devel.x86_64

以上这些必要的基础依赖，在以后其他组件的安装及使用过程中需要用到，所以要提前装好

对于基础依赖，要有个共识印象

Download Python 3.4 sources and compile / install them :

# cd /usr/local/src

# wget https://www.python.org/ftp/python/3.4.3/Python-3.4.3.tar.xz --no-check-certificate

#https://www.python.org/ftp/python/2.7.11/Python-2.7.11.tar.xz

# tar xf Python-3.4.3.tar.xz

# cd Python-3.4.3

# ./configure --prefix=/usr/local --enable-shared LDFLAGS="-Wl,-rpath /usr/local/lib"

# make && sudo make altinstall

(

if you don't want to overwrite the python executable (safer, at least on some distros yum needs python to be 2.x, such as for RHEL6)

- you can install python3.* as a concurrent instance to the system default with an altinstall:

)

Python3自带安装pip和setuptools

# /usr/local/bin/python3.4 --version

Finally, create a link to Python 3 executable for easy usage:

# ln -s /usr/local/bin/python3 /usr/bin/python3

And check:

# python3 --version

Python 3.3.2

#ln -s /usr/local/bin/pip3.4 /usr/bin/pip3 //将pip也链接好 方便使用

如果是Python2没有自带安装pip，需要再次安装pip

# wget https://bitbucket.org/pypa/setuptools/raw/bootstrap/ez_setup.py

# /usr/local/bin/python3.4 ez_setup.py (安装setuptools)

# /usr/local/bin/easy_install-3.4 pip （安装pip）

----------------------------------------------------------------

ez_setup.py python-setuptools easy_install pip egg文件 wheel （https://packaging.python.org/en/latest/projects）

python-devel

Python模块常用的几种安装方式（http://blog.163.com/yang_jianli/blog/static/161990006201162152724339/）

一、方法1： 单文件模块

直接把文件拷贝到 $python_dir/Lib

二、方法2： 多文件模块，带setup.py

下载模块包，进行解压，进入模块文件夹，执行：

python setup.py install

三、 方法3：easy_install 方式

先下载ez_setup.py,运行python ez_setup 进行easy_install工具的安装，之后就可以使用easy_install进行安装package了。

easy_install packageName

easy_install package.egg

四、 方法4：pip 方式

先进行pip工具的安裝：easy_install pip（pip 可以通过easy_install 安裝，而且也会装到 Scripts 文件夹下。）

安裝：pip install PackageName

更新：pip install -U PackageName

移除：pip uninstall PackageName

搜索：pip search PackageName

帮助：pip help

注：虽然Python的模块可以拷贝安装，但是一般情况下推荐制作一个安装包，即写一个setup.py文件来安装。

setup.py文件的使用如下:

% python setup.py build #编译

% python setup.py install #安装

% python setup.py sdist #制作分发包

% python setup.py bdist_wininst #制作windows下的分发包

% python setup.py bdist_rpm

setup.py文件的编写

setup.py中主要执行一个 setup函数，该函数中大部分是描述性东西，最主要的是packages参数，列出所有的package，

可以用自带的find_packages来动态获取package。所以setup.py文件的编写实际是很简单的。

简单的例子:

setup.py文件：

from setuptools import setup, find_packages

setup(

name = " mytest " ,

version = " 0.10 " ,

description = " My test module " ,

author = " Robin Hood " ,

url = " http://www.csdn.net " ,

license = " LGPL " ,

packages = find_packages(),

scripts = [ " scripts/test.py " ],

)

mytest.py

import sys

def get():

return sys.path

scripts/test.py

import os

print os.environ.keys()

setup中的scripts表示将该文件放到 Python的Scripts目录下，可以直接用。OK，简单的安装成功，可以运行所列举的命令生成安装包，

或者安装该python包。

ez_setup.py

The recommended way to bootstrap setuptools on any system is to download ez_setup.py and run it using the target Python environment

Most Linux distributions come with wget.

Download ez_setup.py and run it using the target Python version. The script will download the appropriate version and install it for you:

> wget https://bootstrap.pypa.io/ez_setup.py -O - | python

(

Note that on some older systems (noted on Debian 6 and CentOS 5 installations),wget may refuse to download ez_setup.py

> wget --no-check-certificate https://bootstrap.pypa.io/ez_setup.py

> python ez_setup.py --insecure

)

只需要一个大约 8K 作为的脚本ez_setup.py，就能自动为用户安装包括 setuptools 自身在内的许多 Python 包。

使用这种方式，用户只需要下载 ez_setup。py 并运行，就可以自动下载和安装适合用户当前 Python 版本的适当的

setuptools egg 文件。此外，这段脚本还会将可执行的 easy_install 脚本安装到用户所有的操作系统 Python 可执行脚本正常应该安装的位置

easy_install

easy_install was released in 2004, as part of setuptools.

It was notable at the time for installing packages from PyPI using requirement specifiers, and automatically installing dependencies.

pip

pip came later in 2008, as alternative to easy_install, although still largely built on top of setuptools components.

It was notable at the time for not installing packages as Eggs or from Eggs (but rather simply as ‘flat’ packages from sdists),

and introducing the idea of Requirements Files, which gave users the power to easily replicate environments.

操作系统源安装：pip setuptools wheel

https://packaging.python.org/en/latest/install_requirements_linux/#installing-pip-setuptools-wheel-with-linux-package-managers

CentOS and RHEL don’t offer pip or wheel in their core repositories, although setuptools is installed by default.

To install pip and wheel for the system Python, there are two options:

Enable the EPEL repository using these instructions. On EPEL 6 and EPEL7, you can install pip like so:

sudo yum install python-pip

On EPEL 7 (but not EPEL 6), you can install wheel like so:

sudo yum install python-wheel

Since EPEL only offers extra, non-conflicting packages, EPEL does not offer setuptools, since it’s in the core repository.

Enable the PyPA Copr Repo using these instructions [1]. You can install pip and wheel like so:

sudo yum install python-pip python-wheel

To additionally upgrade setuptools, run:

sudo yum upgrade python-setuptools

pip:

pip has a number of subcommands: “search”, “install”, “uninstall”, “freeze”, "list",etc

To use a package from this index either "pip install package" (get pip)

or download, unpack and "python setup.py install" it.

To install the latest version of “SomeProject”:

pip install 'SomeProject'

To install a specific version:

pip install 'SomeProject==1.4'

To install greater than or equal to one version and less than another:

pip install 'SomeProject>=1,<2'

To install a version that’s “compatible” with a certain version: [4]

pip install 'SomeProject~=1.4.2'

In this case, this means to install any version “==1.4.*” version that’s also “>=1.4.2”.

（https://packaging.python.org/en/latest/projects）

Installing with get-pip.py

To install pip, securely download get-pip.py（https://bootstrap.pypa.io/get-pip.py）

Then run the following:

python get-pip.py

get-pip.py will also intall setuptools （Beginning with pip v1.5.1, get-pip.py stopped requiring setuptools to be installed first.

） and wheel, if they're not already.

setuptools is required to install source distributions.

Both are required to be able to build a Wheel Cache (which improves installation speed),

although neither are required to install pre-built wheels.

//end pip

Python包列表：

https://pypi.python.org/pypi?%3Aaction=index

sql-to-graphite 0.0.6 A tool to send SQL results to Graphite

python的版本兼容问题

比如说graphite的setup.py脚本中第四行还是import ConfigParser

The ConfigParser module has been renamed to configparser in Python 3.

The 2to3 tool will automatically adapt imports when converting your sources to Python 3.

/usr/local/bin/2to3-3.4 setup.py //对比并打印出在Python2和Python3下 setup.py的代码不同之处

/usr/local/bin/2to3-3.4 -w setup.py //将Python2版本代码修改成Python版本代码，并将源文件备份

-----------------------------------------------------------------------------------------------------------------------

虽然linux系统上一般都有python环境，但是默认的python版本较低。而且yum等系统工具，都依赖于默认的python。

所以推荐的做法是再安装一个python，并使用virtualenv等工具，分项目进行环境管理，并与系统默认的python环境进行隔离。

virtualenv:

pip安装：

pip install virtualenv

which virtualenv

/usr/local/bin/virtualenv

创建虚拟环境

virtualenv cabot

Using base prefix '/usr/local'

New python executable in /data/server/alter/cabot/bin/python3.4

Also creating executable in /data/server/alter/cabot/bin/python

Installing setuptools, pip, wheel...done.

--------------------------------------------------------------------------------------------------------------------------

Python 解析sql：（下面的代码可直接 Python select_parser.py 运行

来自：http://pyparsing.wikispaces.com/file/view/select_parser.py/158651233/select_parser.py

支持语法 http://www.sqlite.org/lang_select.html 暂时还不支持 and or 等表达式

）

# select_parser.py

# Copyright 2010, Paul McGuire

#

# a simple SELECT statement parser, taken from SQLite's SELECT statement

# definition at http://www.sqlite.org/lang_select.html

#

from pyparsing import *

LPAR,RPAR,COMMA = map(Suppress,"(),")

select_stmt = Forward().setName("select statement")

# keywords

(UNION, ALL, AND, INTERSECT, EXCEPT, COLLATE, ASC, DESC, ON, USING, NATURAL, INNER,

CROSS, LEFT, OUTER, JOIN, AS, INDEXED, NOT, SELECT, DISTINCT, FROM, WHERE, GROUP, BY,

HAVING, ORDER, BY, LIMIT, OFFSET) = map(CaselessKeyword, """UNION, ALL, AND, INTERSECT,

EXCEPT, COLLATE, ASC, DESC, ON, USING, NATURAL, INNER, CROSS, LEFT, OUTER, JOIN, AS, INDEXED, NOT, SELECT,

DISTINCT, FROM, WHERE, GROUP, BY, HAVING, ORDER, BY, LIMIT, OFFSET""".replace(",","").split())

(CAST, ISNULL, NOTNULL, NULL, IS, BETWEEN, ELSE, END, CASE, WHEN, THEN, EXISTS,

COLLATE, IN, LIKE, GLOB, REGEXP, MATCH, ESCAPE, CURRENT_TIME, CURRENT_DATE,

CURRENT_TIMESTAMP) = map(CaselessKeyword, """CAST, ISNULL, NOTNULL, NULL, IS, BETWEEN, ELSE,

END, CASE, WHEN, THEN, EXISTS, COLLATE, IN, LIKE, GLOB, REGEXP, MATCH, ESCAPE,

CURRENT_TIME, CURRENT_DATE, CURRENT_TIMESTAMP""".replace(",","").split())

keyword = MatchFirst((UNION, ALL, INTERSECT, EXCEPT, COLLATE, ASC, DESC, ON, USING, NATURAL, INNER,

CROSS, LEFT, OUTER, JOIN, AS, INDEXED, NOT, SELECT, DISTINCT, FROM, WHERE, GROUP, BY,

HAVING, ORDER, BY, LIMIT, OFFSET, CAST, ISNULL, NOTNULL, NULL, IS, BETWEEN, ELSE, END, CASE, WHEN, THEN, EXISTS,

COLLATE, IN, LIKE, GLOB, REGEXP, MATCH, ESCAPE, CURRENT_TIME, CURRENT_DATE,

CURRENT_TIMESTAMP))

identifier = ~keyword + Word(alphas, alphanums+"_")

collation_name = identifier.copy()

column_name = identifier.copy()

column_alias = identifier.copy()

table_name = identifier.copy()

table_alias = identifier.copy()

index_name = identifier.copy()

function_name = identifier.copy()

parameter_name = identifier.copy()

database_name = identifier.copy()

# expression

expr = Forward().setName("expression")

integer = Regex(r"[+-]?\d+")

numeric_literal = Regex(r"\d+(\.\d*)?([eE][+-]?\d+)?")

string_literal = QuotedString("'")

blob_literal = Combine(oneOf("x X") + "'" + Word(hexnums) + "'")

literal_value = ( numeric_literal | string_literal | blob_literal |

NULL | CURRENT_TIME | CURRENT_DATE | CURRENT_TIMESTAMP )

bind_parameter = (

Word("?",nums) |

Combine(oneOf(": @ $") + parameter_name)

)

type_name = oneOf("TEXT REAL INTEGER BLOB NULL")

expr_term = (

CAST + LPAR + expr + AS + type_name + RPAR |

EXISTS + LPAR + select_stmt + RPAR |

function_name + LPAR + Optional(delimitedList(expr)) + RPAR |

literal_value |

bind_parameter |

identifier

)

UNARY,BINARY,TERNARY=1,2,3

expr << operatorPrecedence(expr_term,

[

(oneOf('- + ~') | NOT, UNARY, opAssoc.LEFT),

('||', BINARY, opAssoc.LEFT),

(oneOf('* / %'), BINARY, opAssoc.LEFT),

(oneOf('+ -'), BINARY, opAssoc.LEFT),

(oneOf('<< >> & |'), BINARY, opAssoc.LEFT),

(oneOf('< <= > >='), BINARY, opAssoc.LEFT),

(oneOf('= == != <>') | IS | IN | LIKE | GLOB | MATCH | REGEXP, BINARY, opAssoc.LEFT),

('||', BINARY, opAssoc.LEFT),

((BETWEEN,AND), TERNARY, opAssoc.LEFT),

])

compound_operator = (UNION + Optional(ALL) | INTERSECT | EXCEPT)

ordering_term = expr + Optional(COLLATE + collation_name) + Optional(ASC | DESC)

join_constraint = Optional(ON + expr | USING + LPAR + Group(delimitedList(column_name)) + RPAR)

join_op = COMMA | (Optional(NATURAL) + Optional(INNER | CROSS | LEFT + OUTER | LEFT | OUTER) + JOIN)

join_source = Forward()

single_source = ( (Group(database_name("database") + "." + table_name("table")) | table_name("table")) +

Optional(Optional(AS) + table_alias("table_alias")) +

Optional(INDEXED + BY + index_name("name") | NOT + INDEXED)("index") |

(LPAR + select_stmt + RPAR + Optional(Optional(AS) + table_alias)) |

(LPAR + join_source + RPAR) )

join_source << single_source + ZeroOrMore(join_op + single_source + join_constraint)

result_column = "*" | table_name + "." + "*" | (expr + Optional(Optional(AS) + column_alias))

select_core = (SELECT + Optional(DISTINCT | ALL) + Group(delimitedList(result_column))("columns") +

Optional(FROM + join_source) +

Optional(WHERE + expr("where_expr")) +

Optional(GROUP + BY + Group(delimitedList(ordering_term)("group_by_terms")) +

Optional(HAVING + expr("having_expr"))))

select_stmt << (select_core + ZeroOrMore(compound_operator + select_core) +

Optional(ORDER + BY + Group(delimitedList(ordering_term))("order_by_terms")) +

Optional(LIMIT + (integer + OFFSET + integer | integer + COMMA + integer)))

tests = """\

select * from xyzzy where z > 100

select * from xyzzy where z > 100 order by zz

select * from xyzzy""".splitlines()

for t in tests:

print t

try:

print select_stmt.parseString(t).dump()

except ParseException, pe:

print pe.msg

print

解析sql end

----------------------------------------------------------------------------------------------------------------

语音参考：

python函数参考：https://docs.python.org/2/library/functions.html

print type(age) 输出变量类型

age = int(age) 类型转换

字母转数字，数字转字母：

ord('A')

65

>>> chr(65)

'A'

>>> print u'中文'

中文

u'中'和u'\u4e2d'是一样的，\u后面是十六进制的Unicode码。因此，u'A'和u'\u0041'也是一样的。

字符串长度

len(a)

字符串里面的%是一个普通字符怎么办？这个时候就需要转义，用%%来表示一个%

list和tuple：

list常用操作：

list_a = ['b','c','d'] 初始化

list_a.append('e') b,c,d,e 追加

list_a.insert(0,'a') a,b,c,d,e 任一下标插入

list_a.pop() a,b,c,d 出队列

list_a.pop(2) a,d,d 任一下标删除

list_a[0] = 'c' c,b,d 任一位置赋值

print list_a

tuple_a = (1,2,3) 定义元组（元组定义用小括号，list定义用中括号，字典定义用大括号，set定义使用set()函数list做为参数）

tuple“指向不变”，要创建一个内容也不变的tuple怎么做？那就必须保证tuple的每一个元素本身也不能变。

多个变量可以同时接收一个tuple，按位置赋给对应的值，Python的函数返回多值其实就是返回一个tuple

range() 序列生产器 在循环时非常有用

dict（字典）：

dict_a = {"a":0,"b":1,"c":2}

dict_a['d'] = 3

print dict_a

value = dict_a.get('d',0)

print value 输出3

value = dict_a.get('e',0)

print value 输出0，因为e不存在，后面的参数又定义了不存在时输出0

dict_a.pop('b') 将b这个key=>value从字典中删除

for values in dict_a:

print alues

dict内部存放的顺序和key放入的顺序是没有关系的。

和list比，dict有以下几个特点：

dict查找和插入的速度极快，不会随着key的增加而增加；

需要占用大量的内存，内存浪费多。

而list相反：

查找和插入的时间随着元素的增加而增加；

占用空间小，浪费内存很少。

所以，dict是用空间来换取时间的一种方法。

对于不变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。

相反，这些方法会创建新的对象并返回，这样，就保证了不可变对象本身永远是不可变的。

例子如下：

a = "abc"

print a.replace('c','d') 输出 abd

b = a.replace('c','d')

print a 输出 abc

print b 输出 abd

------------------------------------------------------------------------

python自定函数：

def关键字

默认参数，可变参数

默认参数：

当不按顺序提供部分默认参数时，需要把参数名写上。比如调用enroll('Adam', 'M', city='Tianjin')，意思是，city参数用传进去的值，

其他默认参数继续使用默认值。

可变参数：

Python允许你在list或tuple前面加一个*号，把list或tuple的元素变成可变参数传进去：

>>> nums = [1, 2, 3]

>>> calc(*nums)

------------------------------------------------------------------------

python特性：

切片：

l = range(100)

print l[10:99:10]

[10, 20, 30, 40, 50, 60, 70, 80, 90]

>>> 'ABCDEFG'[:3]

'ABC'

>>> 'ABCDEFG'[::2]

'ACEG'

在很多编程语言中，针对字符串提供了很多各种截取函数，其实目的就是对字符串切片。

Python没有针对字符串的截取函数，只需要切片一个操作就可以完成

迭代：

d = {'a':1,'b':2,'c':3,'d':4}

for key in d.iterkeys():

print key 输出 a,b,c,d

for value in d.itervalues():

print value 输出 1,2,3,4

for k,v in d.iteritems():

print "key=",k,"value=",v 输出 key= a value= 1 等

isinstance([1,2,3], Iterable) 判断是否可迭代 输出True

转换成索引-元素迭代：

for i, value in enumerate(['a','b','c']):

print i, value 输出0,a 1,b 2,c

列表生成式：

print [k*k*k for k in range(1,5) if k % 2 != 0] 输出[1, 27]

print [m + n for m in 'ABC' for n in 'abc'] 输出：

['Aa', 'Ab', 'Ac', 'Ba', 'Bb', 'Bc', 'Ca', 'Cb', 'Cc']

生成器：

在Python中，一边循环一边计算的机制，称为生成器（Generator）

generator的工作原理，它是在for循环的过程中不断计算出下一个元素，并在适当的条件结束for循环。

对于函数改成的generator来说，遇到return语句或者执行到函数体最后一行语句，就是结束generator的指令，for循环随之结束。

---------------------------------------------------------------------------------

Python函数式编程：

----------------------------------------------------------------------------------

python模块：

在Python中，一个.py文件就称之为一个模块（Module）。

为了避免模块名冲突，Python又引入了按目录来组织模块的方法，称为包（Package）

每一个包目录下面都会有一个__init__.py的文件，这个文件是必须存在的，否则，Python就把这个目录当成普通目录，而不是一个包。

__init__.py可以是空文件，也可以有Python代码，因为__init__.py本身就是一个模块，而它的模块名就是包名。

例如：import sys

导入sys模块后，我们就有了变量sys指向该模块，利用sys这个变量，就可以访问sys模块的所有功能。

抽象与封装：

类似_xxx和__xxx这样的函数或变量就是非公开的（private），不应该被直接引用，比如_abc，__abc等；

外部不需要引用的函数全部定义成private，只有外部需要引用的函数才定义为public。

Python提供了__future__模块，把下一个新版本的特性导入到当前版本，于是我们就可以在当前版本中测试一些新版本的特性。

当模块被直接运行时，模块名为__main__,

__name__表示当前模块名

-------------------------------------------------------------------------------------------------------------

Anaconda

http://conda.pydata.org/docs/test-drive.html

python3安装：

wget https://repo.continuum.io/archive/Anaconda3-4.1.1-Linux-x86_64.sh

bash Anaconda3-4.1.1-Linux-x86_64.sh

安装验证：

conda --version

创建环境：

# 指定python版本为2.7，注意至少需要指定python版本或者要安装的包# 后一种情况下，自动安装最新python版本

conda create -n env_name python=2.7

# 同时安装必要的包

conda create -n env_name numpy matplotlib python=2.7

conda create --name stock pandas（安装最新python版本）

切换环境：

source activate env_name（例如：source activate stock）

#退出环境，也可以使用`activate root`切回root环境

deactivate env_name

移除环境

conda remove -n env_name --all

列出环境

conda info -e

which python（显示形如：/root/anaconda3/envs/stock/bin/python

ls /root/anaconda3/envs/stock/ 显示：

bin conda-meta include lib share ssl

）

包管理

查看环境下的包：

conda list

安装包：

conda install --name stock（环境名） lxml（包名）

指定查看某环境下安装的package

conda list -n env_name

查找包

conda search pyqtgraph

更新包

conda update numpy

conda update anaconda

卸载包

conda remove numpy

------------------------------------------------------------------------------------------------------

numpy