本文共 36067 字，大约阅读时间需要 120 分钟。

  python十分钟入门

                            简明python教程

【简介】

Python（蟒蛇）是一种动态解释型的编程语言。Python可以在Windows、UNIX、MAC等多种操作系统上使用，也可以在Java、.NET开发平台上使用。

【特点】

1 Python使用C语言开发，但是Python不再有C语言中的指针等复杂的数据类型。

【版本】

python2与python3是目前主要的两个版本。

【HelloWorld】

1 创建hello.py

#!/usr/bin/python# Filename : helloworld.pyif __name__ == '__main__':    print 'Hello World'

python ./helloworld.py

【注释】

# -* - coding: UTF-8 -* -

3 如下注释用于指定解释器（它被称作 组织行 ——源文件的头两个字符是#!，后面跟着一个程序。这行告诉你的Linux/Unix系统当你 执行 你的程序的时候，它应该运行哪个解释器）。

#! /usr/bin/python

4 注意python中也有main函数：

#hello.pydef foo():    str="function"    print(str);if __name__=="__main__":    print("main")    foo()

C:\work\python\divepy>python hello.pymainfunction

>>> import hello>>> hello.foo()function>>> hello.__name__'hello'>>>

【文件类型】

import py_compilepy_compile.compile(‘hello.py’)

python -O -m py_complie hello.py

【变量】

x = 1print id(x)x = 2print id(x)

_a = 1_b = 2

import gldef fun():  print gl._a  print gl._bfun()

【常量】

class _const:  class ConstError(TypeError): pass    def __setattr__(self,name,vlaue):      if self.__dict__.has_key(name):        raise self.ConstError, “Can’t rebind const(%s)”%name        self.__dict__[name]=valueimport syssys.modules[__name__]=_const()

注意浮点数：

3.23和52.3E-4是浮点数的例子。E标记表示10的幂。在这里，52.3E-4表示52.3 * 10-4。

(-5+4j)和(2.3-4.6j)是复数的例子。

注意字符串：

使用单引号（'）你可以用单引号指示字符串，就如同'Quote me on this'这样。所有的空白，即空格和制表符都照原样保留。

注意字符串中的转义字符：

用\'来指示单引号——注意这个反斜杠。现在你可以把字符串表示为'What\'s your name?'。另一个表示这个特别的字符串的方法是"What's your name?"，即用双引号。另外，你可以用转义符\\来指示反斜杠本身。

自然字符串：

如果你想要指示某些不需要如转义符那样的特别处理的字符串，那么你需要指定一个自然字符串。自然字符串通过给字符串加上前缀r或R来指定。例如r"Newlines are indicated by \n"。

Unicode字符串：

Python允许你处理Unicode文本——你只需要在字符串前加上前缀u或U。例如，u"This is a Unicode string."。

【数据类型】

【类型转换】

 int(x [,base ])         将x转换为一个整数

【运算符和表达式】

6 exec和eval语句

>>> exec 'print "Hello World"'Hello World

>>> eval('2*3')6

【控制语句】

1 条件语句：

if (表达式) :#其实表达式可以没有括号    语句1else :    语句2

2 条件语句：

if (表达式) :  语句1elif (表达式) :  语句2…elif (表达式) :  语句nelse :  语句m

3 条件嵌套：

if (表达式1) :  if (表达式2) :    语句1  elif (表达式3) :    语句2  …  else:    语句3elif (表达式n) :   …else :   …

4 python本身没有switch语句。

5 循环语句：

while(表达式) :   …else :   …

6 循环语句：

for 变量 in 集合 :   …else :   …

7 range：

python不支持类似c的for(i=0;i<5;i++)这样的循环语句，但可以借助range模拟：

for x in range(0,5,2):    print x

range(1,5)给出序列[1, 2, 3, 4]

举例：

#!/usr/bin/python# Filename: while.pynumber = 23running = Truewhile running:    guess = int(raw_input('Enter an integer : '))    if guess == number:        print 'Congratulations, you guessed it.'         running = False # this causes the while loop to stop    elif guess < number:        print 'No, it is a little higher than that'     else:        print 'No, it is a little lower than that' else:    print 'The while loop is over.'     # Do anything else you want to do hereprint 'Done'

8 break和continue

#!/usr/bin/python# Filename: continue.pywhile True:    s = raw_input('Enter something : ')    if s == 'quit':        break    if len(s) < 3:        continue    print 'Input is of sufficient length'    # Do other kinds of processing here...

9 三元操作符

V1 if X else V2

如果你来自 C/C++ 或者是 Java 世界, 那么你很难忽略的一个事实就是 Python 在很长的一段时间里没有条件表达式(C ? X : Y), 或称三元运算符. ( C 是条件表达式; X 是 C 为 True 时的结果, Y 是 C 为 False 时的结果) 

贵铎·范·罗萨姆一直拒绝加入这样的功能, 因为他认为应该保持代码简单, 让程序员不轻易出错. 不过在十年多后, 他放弃了, 主要是因为人们试着用and 和 or 来模拟它, 但大多都是错误的. 根据 FAQ , 正确的方法(并不唯一)是(C and [X] or [Y])[0] .

唯一的问题是社区不同意这样的语法. (你可以看一看 PEP 308, 其中有不同的方案.) 对于Python 的这一问题，人们表达了极大的诉求.贵铎·范·罗萨姆最终选择了一个最被看好(也是他最喜欢)的方案, 然后把它运用于标准库中的一些模块. 根据 PEP , "这个评审通过考察大量现实世界的案例, 包含不同的应用, 以及由不同程序员完成的代码." 最后 Python 2.5 集成的语法确定为: X if C else Y .

【数据结构】

1 元组（tuple）

tuple_name=("apple",5,tuple,"orange")

python中一种内置的数据结构。元组由不同的元素组成，每个元素可以存储不同类型的数据，如字符串、数字甚至元素。元组是写保护的，即元组创建之后不能再修改。元组往往代表一行数据，而元组中的元素代表不同的数据项。可以把元组看做不可修改的数组。创建元组示例如下：

tuple_name=("apple",5,tuple,"orange")

我们可以通过一对方括号来指明某个项目的位置从而来访问元组中的项目，就像我们对列表的用法一样。这被称作 索引 运算符。我们使用new_zoo[2]来访问new_zoo中的第三个项目。我们使用new_zoo[2][2]来访问new_zoo元组的第三个项目的第三个项目。

含有0个或1个项目的元组：

一个空的元组由一对空的圆括号组成，如myempty = ()。然而，含有单个元素的元组就不那么简单了。你必须在第一个（唯一一个）项目后跟一个逗号，这样Python才能区分元组和表达式中一个带圆括号的对象。即如果你想要的是一个包含项目2的元组的时候，你应该指明singleton = (2 , )。

元组基本上同列表，但不同的是元组用圆括号表示，元组中的值不可以改变，相当于一个常量。

2 列表（list）

list=["apple","banana","grage","orange"]

列表和元组相似，也由一组元素组成，列表可以实现添加、删除和查找操作，元素的值可以被修改。列表是传统意义上的数组。列表创建示例如下：

list=["apple","banana","grage","orange"]

使用：

可以使用append方法来在尾部追加元素，使用remove来删除元素。

# -* - coding: UTF-8 -* -#!/usr/bin/python# Filename: using_list.pylist = ['apple', 'mango', 'carrot', 'banana']#列表长度len(list)#遍历列表# 注意末尾的逗号，我们在print语句的结尾使用了一个 逗号 来消除每个print语句自动打印的换行符。这样做有点难看，不过确实简单有效。print 'These items are:',for item in list:    print item,#增加列表项list.append('rice')#列表排序#注意sort()函数改变原来的列表，函数返回值是空值即Nonelist.sort()#获得排序列表副本1list2 = list[:]list2.sort()#获得排序列表副本2list3 = sorted(list)#删除列表项del list[0]

帮助：

3 字典（dictionary）

dict={"a":"apple", "b":"banana", "g":"grage", "o":"orange"}

由键-值对组成的集合，字典中的值通过键来引用。键和值之间用冒号隔开，键-值对之间用逗号隔开，并且被包含在一对花括号中。注意，键必须是唯一的。记住字典中的键/值对是没有顺序的。字典是dict类的实例/对象。创建示例如下：

dict={"a":"apple", "b":"banana", "g":"grage", "o":"orange"}

使用：dict[key]

# -* - coding: UTF-8 -* -#!/usr/bin/python# Filename: using_dict.pyaddressBook = {             'Swaroop'   : 'swaroopch@byteofpython.info',             'Larry'     : 'larry@wall.org',             'Matsumoto' : 'matz@ruby-lang.org',             'Spammer'   : 'spammer@hotmail.com'     }# 使用字典：dict[key]print "Swaroop's address is %s" % addressBook['Swaroop']# 增加字典项：dict[newKey]=newValueaddressBook['Guido'] = 'guido@python.org'# 删除字典项：del dict[key]del addressBook['Spammer']# 字典长度：len(dict)print '\nThere are %d contacts in the address-book\n' % len(addressBook)# 遍历字典：for name, address in addressBook.items():    print 'Contact %s at %s' % (name, address)# 查找字典值：if 'Guido' in addressBook: # 或 addressBook.has_key('Guido')    print "\nGuido's address is %s" % addressBook['Guido']#对字典按键排序，元组列表的形式返回d={"ok":1,"no":2}sorted(d.items, key=lambda d:d[0])#[('no', 2), ('ok', 1)]对字典按值排序，元组列表的形式返回d={"ok":1,"no":2}sorted(d.items, key=lambda d:d[1])#[('ok', 1), ('no', 2)]

帮助：

可以通过help(dict)获得完整的知识。

4 序列：

解释：

1，列表、元组和字符串都是序列。

2，序列的两个主要特点是索引操作符和切片操作符。

索引操作符让我们可以从序列中抓取一个特定项目。

切片操作符让我们能够获取序列的一个切片，即一部分序列。

使用：

#!/usr/bin/python# Filename: seq.pyshoplist = ['apple', 'mango', 'carrot', 'banana']# Indexing or 'Subscription' operationprint 'Item 0 is', shoplist[0]print 'Item 1 is', shoplist[1]print 'Item 2 is', shoplist[2]print 'Item 3 is', shoplist[3]print 'Item -1 is', shoplist[-1]print 'Item -2 is', shoplist[-2]# Slicing on a listprint 'Item 1 to 3 is', shoplist[1:3]print 'Item 2 to end is', shoplist[2:]print 'Item 1 to -1 is', shoplist[1:-1]print 'Item start to end is', shoplist[:]# Slicing on a stringname = 'swaroop'print 'characters 1 to 3 is', name[1:3]print 'characters 2 to end is', name[2:]print 'characters 1 to -1 is', name[1:-1]print 'characters start to end is', name[:]

5 列表综合

解释：

通过列表综合，可以从一个已有的列表导出一个新的列表。例如，你有一个数的列表，而你想要得到一个对应的列表，使其中所有大于2的数都是原来的2倍。对于这种应用，列表综合是最理想的方法。

# -* - coding: UTF-8 -* -#!/usr/bin/python# Filename: list_comprehension.pylistone = [2, 3, 4]listtwo = [2*i for i in listone if i > 2]print listtwo  # 结果是[6,8]

【函数相关】

1，解释

python程序由包（package）、模块（module）和函数组成。包是由一系列模块组成的集合。模块是处理某一类问题的函数和类的集合。包就是一个完成特定任务的工具箱。包必须含有一个__init__.py文件，它用于标识当前文件夹是一个包。python的程序是由一个个模块组成的。模块把一组相关的函数或代码组织到一个文件中，一个文件即是一个模块。模块由代码、函数和类组成。导入模块使用import语句。包的作用是实现程序的重用。函数是一段可以重复多次调用的代码。

通常把内建函数成为BIF（built-in functions）

2，定义

函数定义示例如下：

#!/usr/bin/python# Filename: seq.pydef arithmetic(x,y,operator):   result={      "+":x+y,      "-":x-y,      "*":x*y,      "/":x/y   }   return result[operator]print arithmetic(1,2,"+")

3，变量

函数内部的全局变量

#!/usr/bin/python# Filename: func_global.pydef func():    global x #这里声明使用外部定义的全局的x。    print 'x is', x  #将输出外部值50    x = 2    print 'Changed local x to', x #这里外部值x真正的被改变了x = 50func()print 'Value of x is', x

4， DocStrings

文档字符串的惯例是一个多行字符串，它的首行以大写字母开始，句号结尾。第二行是空行，从第三行开始是详细的描述。 强烈建议 你在你的函数中使用文档字符串时遵循这个惯例。

  pass语句在Python中表示一个空的语句块。

# -* - coding: UTF-8 -* -#!/usr/bin/python# Filename: func_doc.py#这里的y=1是默认参数def func(x, y=1):    '''This is the DocStrings       func(x,y=1) '''    pass #这句表示空语句print func(3)       #由于函数没有return的话默认有一句 return None，所以这里输出Noneprint func.__doc__  #这里调用直接输出DocStrings

如果要打印本文件而不是其他模块的docString，我想出来了这么一个办法：

A.py

'''Created on 2012-10-10@author: xing.gexing'''import Aif __name__=="__main__":    print A.__doc__

5，导入模块

如果你想要直接输入argv变量到你的程序中（避免在每次使用它时打sys.），那么你可以使用from sys import argv语句。如果你想要输入所有sys模块使用的名字，那么你可以使用from sys import *语句。这对于所有模块都适用。一般说来，应该避免使用from..import而使用import语句，因为这样可以使你的程序更加易读，也可以避免名称的冲突。也可以直接import sys

6， 创建模块

创建如下模块：mymodule.py

#!/usr/bin/python# Filename: mymodule.pydef sayhi():    print 'Hi, this is mymodule speaking.'version = '0.1'# End of mymodule.py

#!/usr/bin/python# Filename: mymodule_demo.pyimport mymodulemymodule.sayhi()print 'Version', mymodule.version

#!/usr/bin/python# Filename: mymodule_demo2.pyfrom mymodule import sayhi, version# Alternative:# from mymodule import *sayhi()print 'Version', version

7，函数中传入元组、列表、字典

元组、列表： 当要使函数接收元组或字典形式的参数的时候，有一种特殊的方法，它分别使用*和**前缀。这种方法在函数需要获取可变数量的参数的时候特别有用。

# -* - coding: UTF-8 -* -#!/usr/bin/python# 1,函数的参数是元组/列表#   后续参数1,2作为元组(1,2)传入def a1(*args):    if len(args)==0:        print 'None'    else:        print argsa1()         # 输出Nonea1(1,2)      # 输出(1, 2)# 2,函数的参数是字典#   后续参数作为字典{x:1,y:2}传入def a2(**args):    if len(args)==0:        print 'None'    else:        print argsa2()         # 输出Nonea2(x=1,y=2)  # 输出{'y': 2, 'x': 1}注意遍历返回的顺序与形参位置顺序相反

另外特别地，对于传递字典，有这样一些结论：

#dict1={x:1,y:2} # NameError: name 'x' is not defined，除非这个x变量事先已经被定义了。dict2={'x':1,'y':2}#dict3={1:x,2:y} # NameError: name 'x' is not defined，同理。dict4={1:'x',2:'y'}# 定义函数参数为字典def a(**args):    print argsa(x=1,y=2)      # 我的理解是，这里估计先要通过函数的语法检查，所以=左边必须是变量，然后才被识别为字符串'x'，所以这种传递字典很局限，只能传递key为字符串的字典。#a('x'=1,'y'=2)#a(1=x,2=y)#a(1='x',2='y')

如果要传递任意的字典，不如这样：

def a(dict)dict={1:'x',2='y'}a(dict)

【字符串相关】

format="%s%d" % (str1,num)print format

str1="hello"str2="world"result=str1+str2

word="world"print word[0:3]

# -* - coding: UTF-8 -* -#!/usr/bin/python# Filename: str_methods.py# 字符串namename = 'Swaroop' # name.startswith("") startwith方法是用来测试字符串是否以给定字符串开始if name.startswith('Swa'):    print 'Yes, the string starts with "Swa"'# in                  in操作符用来检验一个给定字符串是否为另一个字符串的一部分if 'a' in name:    print 'Yes, it contains the string "a"'# name.find("")       find方法用来找出给定字符串在另一个字符串中的位置，或者返回-1以表示找不到子字符串if name.find('war') != -1:    print 'Yes, it contains the string "war"'#                     str类也有以一个作为分隔符的字符串join序列的项目的整洁的方法，它返回一个生成的大字符串delimiter = '_*_'mylist = ['Brazil', 'Russia', 'India', 'China']print delimiter.join(mylist)

【文件处理】

1，读写文件

 读取文件可以使用readline()函数、readlines()函数和read函数。

    写入文件可以使用write()、writelines()函数

# -* - coding: UTF-8 -* -#!/usr/bin/python# Filename: using_file.pypoem = '''\Programming is funWhen the work is doneif you wanna make your work also fun:        use Python!'''# 以写模式打开文件,模式可以为读模式（'r'）、写模式（'w'）或追加模式（'a'）f = file('poem.txt', 'w')# 写入内容f.write(poem) # 关闭文件 f.close() # 以读模式打开文件，不指定mode默认为读f = file('poem.txt')# 逐行读取内容while True:    line = f.readline()    if len(line) == 0: # 长度为0表示读到EOF        break    print line,    # 注意逗号表示避免换行# 关闭文件f.close()

2，我的常用格式

read_file = open("new_tablelist.txt").read()write_file = open("a.txt","w")for words in read_file.split("\n"):    if words != "":        write_file.write(words.split(":")[1]+"\n")write_file.close()

3 读写对象【存储器】

Python提供一个标准的模块，称为pickle。使用它你可以在一个文件中储存任何Python对象，之后你又可以把它完整无缺地取出来。这被称为 持久地 储存对象。

# -* - coding: UTF-8 -* -#!/usr/bin/python# Filename: pickling.pyimport cPickle as p#import pickle as p# 建立两个对象shoplistfile = 'shoplist.data'shoplist = ['apple', 'mango', 'carrot']# 将对象写入文件f = file(shoplistfile, 'w')p.dump(shoplist, f) f.close()# 删除对象del shoplist# 从文件中读取对象f = file(shoplistfile)storedlist = p.load(f)print storedlist

【对象和类】

class Fruit:    def grow(self):       print "Fruit grow"

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称，但是在调用这个方法的时候你不为这个参数赋值，Python会提供这个值。这个特别的变量指对象本身，按照惯例它的名称是self。

2 当一个对象被创建后，包含了三方面的特性，即对象的句柄、属性和方法。创建对象的方法：

fruit = Fruit()fruit.grow()

3 python没有保护类型的修饰符

6 python的构造函数名为__init__，析构函数名为__del__

# -* - coding: UTF-8 -* -#!/usr/bin/python# Filename: objvar.pyclass Person:    '''Represents a person.'''    # 这是类的变量    population = 0    # 构造函数    def __init__(self, name):        '''Initializes the person's data.'''  #类的文档字符串        # 这里是self.name，所以这个name是对象的变量        self.name = name        print '(Initializing %s)' % self.name        # 构造函数使得类的变量population+1        Person.population += 1    # 析构函数    def __del__(self):        '''I am dying.'''  #方法的文档字符串        print '%s says bye.' % self.name        Person.population -= 1        if Person.population == 0:            print 'I am the last one.'        else:            print 'There are still %d people left.' % Person.population    def sayHi(self):        '''Greeting by the person.        Really, that's all it does.'''        print 'Hi, my name is %s.' % self.name    def howMany(self):#如果这个函数要调用本类的sayHi(self),需要操作self.sayHi()        '''Prints the current population.'''        if Person.population == 1:            print 'I am the only person here.'        else:            print 'We have %d persons here.' % Person.population# 我们可以在运行时使用Person.__doc__和Person.sayHi.__doc__来分别访问类与方法的文档字符串。swaroop = Person('Swaroop')swaroop.sayHi()swaroop.howMany()kalam = Person('Abdul Kalam')kalam.sayHi()kalam.howMany()swaroop.sayHi()swaroop.howMany()

class Apple(Fruit):   def …

# -* - coding: UTF-8 -* -#!/usr/bin/python# Filename: inherit.pyclass SchoolMember:    '''Represents any school member.'''    def __init__(self, name, age):        self.name = name        self.age = age        print '(Initialized SchoolMember: %s)' % self.name    def tell(self):        '''Tell my details.'''        print 'Name:"%s" Age:"%s"' % (self.name, self.age),class Teacher(SchoolMember):    '''Represents a teacher.'''    def __init__(self, name, age, salary):        SchoolMember.__init__(self, name, age)        self.salary = salary        print '(Initialized Teacher: %s)' % self.name    def tell(self):        SchoolMember.tell(self)        print 'Salary: "%d"' % self.salaryclass Student(SchoolMember):    '''Represents a student.'''    def __init__(self, name, age, marks):        SchoolMember.__init__(self, name, age)        self.marks = marks        print '(Initialized Student: %s)' % self.name    def tell(self):        SchoolMember.tell(self)        print 'Marks: "%d"' % self.markst = Teacher('Mrs. Shrividya', 40, 30000)s = Student('Swaroop', 22, 75)print # prints a blank linemembers = [t, s]for member in members:    member.tell() # works for both Teachers and Students

8 对象的深度拷贝

要想取得深层拷贝，必须使用切片操作符来获取整个拷贝。

# -* - coding: UTF-8 -* -#!/usr/bin/python# Filename: reference.py# mylist和shoplist都只想同一个内存对象。shoplist = ['apple', 'mango', 'carrot', 'banana']mylist = shoplist # mylist和shoplist都少了appledel shoplist[0]# 这才是深层复制，mylist和shoplist对应两个不同的对象了。mylist = shoplist[:] # 这里只删除了mylist的第一个单词del mylist[0]

【异常处理】

1，使用try except语句

直接在python cmd里这样测试，尝试读取用户的一段输入。按Ctrl-d，看一下会发生什么：

>>> s = raw_input('Enter something --> ')Enter something --> Traceback (most recent call last):  File "
   
    ", line 1, in 
    
         s = raw_input('Enter something --> ')EOFError: EOF when reading a line
    
   

# -* - coding: UTF-8 -* -#!/usr/bin/python# Filename: try_except.pyimport systry:    s = raw_input('Enter something --> ')except EOFError as err:    print '\nWhy did you do an EOF on me?'+str(err)    sys.exit # 直接退出except:    print '\nSome error/exception occurred.'print 'Done'

2，自己构造异常类

# -* - coding: UTF-8 -* -#!/usr/bin/python# Filename: raising.py# 定义一个异常类ShortInputException，该类继承自Exceptionclass ShortInputException(Exception):    '''A user-defined exception class.'''    def __init__(self, length, atleast):#self是必须的，length表示当前输入长度，atleast表示应输入长度        Exception.__init__(self)        self.length = length    # 对象的私有变量        self.atleast = atleast  # 对象的私有变量 try:    s = raw_input('Enter something --> ')    if len(s) < 3:        raise ShortInputException(len(s), 3) # 主动抛出异常except EOFError:    print '\nWhy did you do an EOF on me?'except ShortInputException, x:    print 'ShortInputException: The input was of length %d, was expecting at least %d' % (x.length, x.atleast)else:    print 'No exception was raised.'

>>> ================================ RESTART ================================>>> Enter something --> Why did you do an EOF on me?>>> ================================ RESTART ================================>>> Enter something --> abShortInputException: The input was of length 2, was expecting at least 3>>> ================================ RESTART ================================>>> Enter something --> abcNo exception was raised.>>>

3，使用try finally

# -* - coding: UTF-8 -* -#!/usr/bin/python# Filename: finally.pyimport timetry:    f = file('poem.txt')    while True:        line = f.readline()        if len(line) == 0:# len(line)==0表示读到文件EOF            break        time.sleep(2)        print line,finally:    f.close()    print 'Cleaning up...closed the file'

4，使用with来避免finally

例如打开文件操作：

try:	f = open('a.txt')	print f.readlines() finally:	f.close()

如果使用with，则明显提高友好度:

with open('a.txt') as f:      print f.readlines()

>>> class A:	def __enter__(self):		print 'in enter'	def __exit__(self, e_t, e_v, t_b):		print 'in exit'>>> with A() as a:	print 'in with'in enterin within exit

【连接mysql】

import os, sysimport MySQLdbtry:    conn MySQLdb.connect(host=’localhost’,user=’root’,passwd=’’,db=’address’except Exception,e:    print e    sys.exit()cursor=conn.cursor()sql=’insert into address(name, address) values(%s, %s)’value=((“zhangsan”,”haidian”),(“lisi”,”haidian”))try    cursor.executemany(sql,values)except Exception, e:    print esql=”select * from address”cursor.execute(sql)data=cursor.fetchall()if data    for x in data:        print x[0],x[1]cursor.close()conn.close()

【多线程】

python[cpython] 的GIL规定每个时刻只能有一个线程访问python虚拟机，所以你要用python的多线程来做计算是很不合算的，但是对于IO密集型的应用，例如网络交互来说，python的多线程还是非常给力的。如果你是一个计算密集型的任务，非要用python来并行执行的话，有以下几个方法：

【easy_install工具】

Python中的easy_install工具很爽，它的作用类似于Php中的pear，或者Ruby中的gem，或者Perl中的cpan。

wget -q http://peak.telecommunity.com/dist/ez_setup.pypython ez_setup.py

有时候可能需要再安装python-dev

sudo yum install python-devel

例如安装python的代码覆盖率工具：

sudo easy_install coverage

转载地址：https://blog.csdn.net/u013494310/article/details/20617959 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！