[转] Python快速入门

xuol001

本文是Python的快速入门，在本文中并不涉及Python的特殊规则和细节，目标是通过示例使你快速了解Python语言的特点。本文简要介绍了变量,表达式,控制流,函数以及输入/输出的基本概念,在本文中不涉及Python语言的高级特性。尽管如此，有经验的程序员还是能够通过阅读本章的材料创建高级程序。我们鼓励新手通过运行示例，亲身体验一把Python。

1.1. 运行Python

Python 程序通过解释器执行。如果你的机器已经装好了Python，简单的在命令行键入python即可运行Python解释器。在解释器运行的时，会有一个命令提示符 >>>，在提示符后键入你的程序语句，键入的语句将会立即执行。在下边的例子中，我们在>>>提示符后边键入最常见的显示"Hello World"的命令:

Python 2.4.2 (#67, Sep 28 2005, 12:41:11) [MSC v.1310 32 bit (Intel)] on win32

Type "copyright", "credits" or "license()" for more information.

>>> print "Hello World"

Hello World

>>>

程序也可以像下面一样放置在一个文件中

# helloworld.py

print "Hello World"

Python源代码文件使用.py后缀.'#'表示注释(到行末结束)

执行文件helloworld.py

% python helloworld.py

Hello World

%

在Windows 下，只需双击一个.py文件就能执行这个python程序。windows会自动调用python解释程序，然后启动一个终端窗口(类DOS窗口)来执行它。在这种情况下,终端窗口会在程序执行完毕后立即关闭(经常是在你看到它的输出之前)。为避免这个问题,你可以使用python集成开发环境,例如IDLE或Pythonwin。另一个可行的方法是建立一个 bat文件,在文件写入这样一行语句，如 python -i helloworld.py。运行这个批处理，程序在执行完成后会自动进入python解释器。

在解释器中,也可以通过函数execfile()来运行一个保存在磁盘上的程序,如下例:

>>> execfile("helloworld.py")

Hello World

在UNIX下,你可以在程序的首行写入 #! 魔法字符串 来自动调用python解释器执行你的脚本。

print "Hello World"

解释器会一直运行直到文件结束。如果在交互模式下,键入 EOF字符退出解释器。在UNIX下,EOF字符是Ctrl+ D;在Windows下,EOF字符是Ctrl+Z.也可以在程序中使用sys.exit()函数或者通过引发SystemExit异常来退出程序:

>>> import sys

>>> sys.exit()

或者

>>> raise SystemExit

1.2. 变量和表达式

通过Listing 1.1所示的程序示例变量和表达式的用法

Listing 1.1 复利计算器(Simple Compound-Interest Calculation)

   1 principal = 1000        # Initial amount (本金)

   2 rate = 0.05              # Interest rate (利率)

   3 numyears = 5             # Number of years (期数,年)

   4 year = 1

   5 while year = a and b  c):

   4         print "b is still between a and c"

用 elif 语句可以检验多重条件(用于代替其它语言中的switch语句):

   1 if a == '+':

   2         op = PLUS   

   3 elif a == '-':

   4         op = MINUS

   5 elif a == '*':

   6         op = MULTIPLY

   7 else:

   8         raise RuntimeError, "Unknown operator"

1.4. 文件输入/输出

下面的程序打开一个文件,然后一行行地读出并显示文件内容:

   1 f = open("foo.txt")  # Returns a file object

   2 line = f.readline()    # Invokes readline() method on file

   3 while line:

   4         print line,    # trailing ',' omits newline character

   5         line = f.readline()

   6 f.close()

open()函数返回一个新文件对象(file object)。通过调用此对象的不同方法可以对文件进行不同的操作。readline()方法读取文件的一行(包括换行符'\n')。如果读到文件末尾，就返回一个空字符串。要将程序的输出内容由屏幕重定向到文件中，可以使用'>>'运算符，如下例:

   1 f = open("out","w")     # Open file for writing

   2 while year >f,"%3d %0.2f" % (year,principal)  #将格式文本输出到文件对象 f

   5         year += 1

   6 f.close()

当然,文件对象也拥有write()方法，通过它可以向文件对象写入新的数据。例如上边例子中的print的语句也可以写成这样:

f.write("%3d   %0.2f\n" % (year,principal))  

1.5. 字符串

要创建一个字符串，你使用单引号,双引号或三引号将其引起来，如下例:

   1 a = 'Hello World'

   2 b = "Python is groovy"

   3 c = """What is footnote 5?"""

一个字符串用什么引号开头，就必须用什么引号结尾。单引号与双引号只能创建单行字符串，两个三引号之间的一切字符(包括换行)都是字符串的内容, 因此三引号能够创建多行字符串。如下例：

   1 print '''Content-type: text/html

   2

   3  Hello World

   4 Click here.

   5 '''

字符串是一个以0开始，整数索引的字符序列,要获得字符串 s 中的第 i+1 个字符(别忘了0是第一个),使用索引运算符 s:

   1 a = "Hello World"

   2 b = a[4]                # b = 'o'

要获得一个子串,使用切片运算符 s[i:j]。 它返回字符串 s 中从索引 i (包括i)到 j (不包括 j)之间的子串。若 i 被省略，python就认为 i=0，若 j 被省略，python就认为 j=len(s)-1:

   1 c = a[0:5]              # c = "Hello"

   2 d = a[6:]               # d = "World"

   3 e = a[3:8]              # e = "lo Wo"

可以用加(+)运算符来连结字符串:

g = a + " This is a test"

通过使用str()函数,repr()函数或向后的引号(`)可以将其他类型的数据转换为字符串:

   1 s = "The value of x is " + str(x)

   2 s = "The value of y is " + repr(y)

   3 s = "The value of y is " + `y`

repr()函数用来取得对象的规范字符串表示，向后的引号(`)是repr()函数的快捷版。

在大多情况下str()和repr()函数会返回同一个结果,但是它们之间有很微妙的差别,后边的章节对此将有详细描述。

1.6. 列表和元组(Lists & Tuples)

就如同字符串是字符的序列,列表和元组则是任意对象的序列。象下面这样就可以创建一个列表:

names = [ "Dave", "Mark", "Ann", "Phil" ]

列表和元组都是以整数0来开始索引的序列,你可以用索引操作符来读取或者修改列表中特定元素的值:

a = names[2]             # Returns the third item of the list, "Ann"

names[0] = "Jeff"        # Changes the first item to "Jeff"

用len()函数得到列表的长度:

print len(names)        # prints 4

append()方法可以把一个新元素插入列表的末尾:

names.append("Kate")

aList.insert(index,aMember)方法可以把新元素 aMember 插入到列表 aList[index] 元素之前:

names.insert(2, "Sydney")

用切片操作符可以取出一个子列表或者对子列表重新赋值:

b = names[0:2]                      # Returns [ "Jeff", "Mark" ]

c = names[2:]                       # Returns [ "Sydney", "Ann", "Phil", "Kate" ]

names[1] = 'Jeff'                   # Replace the 2nd item in names with "Jeff"

names[0:2] = ['Dave','Mark','Jeff'] # 用右边的 list 替换 names 列表中的前两个元素

   

加(+)运算符可以连结列表:

a = [1, 2, 3] + [4, 5]     # Result is [1,2,3,4,5]

列表元素可以是任意的 Python 对象,当然也包括列表:

a = [1,"Dave",3.14, ["Mark", 7, 9, [100,101]], 10]

子列表的元素用下面的方式调用:

a[1]            # Returns "Dave"

a[3][2]         # Returns 9

a[3][3][1]      # Returns 101

Listing 1.2中代码从一个文件中读取一系列数字，然后输出其中的最大值和最小值。通过这个示例我们可以了解到列表的一些高级特性：

Listing 1.2 列表的高级特性

   1 import sys                   # Load the sys module (导入sys模块)

   2 f = open(sys.argv[1])       # Filename on the command line (从命令行读取文件名)

   3 svalues = f.readlines()     # Read all lines into a list (读出所有行到一个列表)

   4 f.close()

   5

   6 # Convert all of the input values from strings to floats (把输入的值转换为浮点数)

   7 fvalues = [float(s) for s in svalues]

   8

   9 # Print min and max values (输出最大值和最小值)

  10 print "The minimum value is ", min(fvalues)

  11 print "The maximum value is ", max(fvalues)

程序第一行用import语句从Python library中导入sys模块。

你需要在命令行提供一个文件名给上面的程序，该文件名参数保存在sys.argv 列表中，open方法通过读取sys.argv[1]得到这个文件名参数。

readlines()方法读取文件中的所有的行到一个列表中。

表达式 [float(s) for s in svalues] 通过循环列表svalues中的所有字符串并对每个元素运行函数float()来建立一个新的列表,这种特殊的建立列表的方法叫做列表包含( list comprehension)。 在列表中所有的字符串都转换为浮点数之后,内建函数min()和max()计算出列表中的最大值及最小值。

元组(tuple)类型和列表关系很密切,通过用圆括号中将一系列逗号分割的值括起来可以得到一个元组:

   1 a = (1,4,5,-9,10)

   2 b = (7,)       # 一个元素的元组 (注意一定要加一个额外的逗号！)

   3 person = (first_name, last_name, phone)

在某些时候，即使没有圆括号, Python仍然可以根据上下文认出这是一个元组，如: (为了写出更清晰可读的程序，建议你不要依赖 Python 的智能)

a = 1,4,5,-9,10

b = 7,

person = first_name, last_name, phone

元组支持大多数列表的操作,比如索引,切片和连结。一个关键的不同是你不能在一个tuple创建之后修改它的内容。也就是说,你不能修改其中的元素,也不能给tuple添加新的元素。

1.7. 循环

通过使用while语句，我们在前面已经简单介绍了 while 循环。在Python中另一种循环结构是 for 循环，它通过 迭代 一个序列(例如字符串,列表,或者tuple等)中的每个元素来建立循环。下边是一个例子:

for i in range(1,10):

        print "2 to the %d power is %d" % (i, 2**i)

range(i,j)函数建立一个整数序列,这个序列从第 i 数开始(包括 i )到第 j 数为止(不包括 j)。若第一个数被省略，它将被认为是0。该函数还可以有第三个参数，步进值，见下面的例子:

a = range(5)          # a = [0,1,2,3,4]

b = range(1,8)        # b = [1,2,3,4,5,6,7]

c = range(0,14,3)    # c = [0,3,6,9,12]

d = range(8,1,-1)    # d = [8,7,6,5,4,3,2]

for语句可以迭代任何类型的序列:

a = "Hello World"

# Print out the characters in a

for c in a:

        print c

b = ["Dave","Mark","Ann","Phil"]

# Print out the members of a list

for name in b:

        print name

range()函数根据起始值，终止值及步进值三个参数在内存中建立一个列表，当需要一个很大的列表时,这个既占内存又费时间。为了克服它的缺点,Python提供了xrange()函数:

for i in xrange(1,10):

        print "2 to the %d power is %d" % (i, 2**i)

a = xrange(100000000)       # a = [0,1,2, ..., 99999999]

b = xrange(0,100000000,5)   # b = [0,5,10, ...,99999995]

xrange()函数只有在需要值时才临时通过计算提供值，这大大节省了内存。

1.8. 字典

字典就是一个关联数组(或称为哈希表)。它是一个通过关键字索引的对象的集合。使用大括号{}来创建一个字典，如下 例:

a = {

       "username" : "beazley",

       "home" : "/home/beazley",

       "uid" : 500

     }

用关键字索引操作符可以访问字典的某个特定值:

u = a["username"]

d = a["home"]

用下面的方式插入或者修改对象:

a["username"] = "pxl"

a["home"] = "/home/pxl"

a["shell"] = "/usr/bin/tcsh"

尽管字符串是最常见的 关键字(key) 类型，你还是可以使用很多其它的 python 对象做为字典的关键字，比如数字 和 tuple，只要是不可修改对象，都可以用来做字典的key。有些对象,例如列表和字典,不可以用来做字典的key,因为他们的内容是允许更改的。

我们可以使用 has_key() 方法来检验一个键/值对是否存在(或者in操作符):

if a.has_key("username"):

     username = a["username"]

else:

     username = "unknown user"

上边的操作还可以用更简单的方法完成:

username = a.get("username", "unknown user")

字典的keys() 方法返回由所有关键字组成的列表:

k = a.keys()         # k = ["username","home","uid","shell"]

del语句可以删除字典中的特定元素:

del a["username"]

1.9. 函数

在Python中，使用def语句来创建函数，如下例:

def remainder(a, b):

        q = a/b

        r = a - q*b

        return r

要调用一个函数，只要使用函数名加上用括号括起来的参数就可以了。比如result = remainder(37,15),如果你打算让函数返回多个值，就让它返回一个元组好了。（当然，只要你愿意，让它返回一个列表我们也不会介意)

def divide(a, b):

        q = a/b        # If a and b are integers, q is an integer

        r = a - q*b

        return (q, r)

当返回一个 tuple 时，你会发现象下面这样调用函数会很有用:

quotient, remainder = divide(1456,33)

你也可以象下面这样给函数的参数指定一个默认值:

def connect(hostname, port, timeout = 300):

      # Function body

若在函数定义的时候提供了默认参数，那么在调用函数时就允许省略这个参数：

connect('www.python.org', 80)

你也可以使用关键字参数来调用函数,这样你的参数就可以使用任意顺序:

connect(port = 80, hostname = "www.python.org")

函数内部定义的变量为局部变量，要想在一个函数内部改变一个全局变量的值，在函数中使用global语句:

   1 a = 4.5

   2 ...

   3 def foo():

   4         global a

   5         a = 8.8             # 改变全局变量 a

1.10. 类

Python支持面向对象编程，在面向对象编程中，class语句用于定义新类型的对象。例如，下面这个类定义了一个简单的堆栈：

   1 class Stack(object):

   2         def __init__(self):              # 初始化栈

   3                 self.stack = [ ]

   4         def push(self,object):

   5                 self.stack.append(object)

   6         def pop(self):

   7                 return self.stack.pop()

   8         def length(self):

   9                 return len(self.stack)

在类定义中,方法用 def 语句定义。类中每个方法的第一个参数总是引用类实例对象本身，大家习惯上使用 self 这个名字代表这个参数。不过这仅仅是个习惯而已，如果你愿意也可以用任意的别的名字。不过为了别人容易看懂你的程序，最好还是跟随大家的习惯。类的方法中若需要调用实例对象的属性则必须显式使用self变量(如上所示)。方法名中若前后均有两个下划线，则表示这是一个特殊方法，比如init方法被用来初始化一个对象(实例)。

象下面这样来使用一个类:

   1 s = Stack()           # Create a stack (创建)

   2 s.push("Dave")       # Push some things onto it (写入)

   3 s.push(42)

   4 s.push([3,4,5])

   5 x = s.pop()           # x gets [3,4,5] (读取)

   6 y = s.pop()           # y gets 42

   7 del s                  # Destroy s (删除)

1.11. 异常

如果在你的程序发生了一个错误，就会引发异常(exception),你会看到类似下面的错误信息:

Traceback (most recent call last):

File "", line 42, in foo.py

NameError: a

错误信息指出了发生的错误类型及出错位置，通常情况下，错误会导致程序终止。不过你可以使用 try 和 except 语句来捕获并处理异常:

try:

    f = open("file.txt","r")

except IOError, e:

    print e

上面的语句表示：如果有 IOError 发生，造成错误的详细原因将会被放置在对象 e 中，然后运行 except 代码块。 若发生其他类型的异常，系统就会将控制权转到处理该异常的 except 代码块，如果没有找到该代码块，程序将运行终止。若没有异常发生，except代码块就被忽略掉。

raise语句用来有意引发异常，,你可以使用内建异常来引发异常，如下例:

raise RuntimeError, "Unrecoverable error"

当然，你也可以建立你自己的异常，这将在 第五章--控制流中的定义新的异常中详细讲述。

1.12. 模块

当你的程序变得越来越大，为了便于修改和维护，你可能需要把它们分割成多个相关文件。 Python允许你把函数定义或公共部分放入一个文件，然后在其他程序或者脚本中将该文件作为一个模块导入。要创建一个模块，把相应的语句和定义放入一个文件，这个文件名就是模块名。(注意:该文件必须有.py后缀)：

   1 # file : div.py

   2 def divide(a,b):

   3     q = a/b        # If a and b are integers, q is an integer

   4     r = a - q*b

   5     return (q,r)

要在其它的程序中使用这个模块，使用import语句:

import div

a, b = div.divide(2305, 29)

import语句创建一个新的名字空间，该空间包含模块中所有定义对象的名称。要访问这个名字空间，把模块名作为一个前缀来使用这个模块内的对象，就像上边例子中那样:div.divide()

如果你希望使用一个不同的模块名字访问这个模块，给import语句加上一个 as 模块名 部分就可以了:

import div as foo

a,b = foo.divide(2305,29)

如果你只想导入指定的对象到当前的名称空间,使用 from 语句:

from div import divide

a,b = divide(2305,29)       # No longer need the div prefix (不再需要div前缀)

导入一个模块中的所有内容到当前的名称空间:

from div import *

最后，内建函数dir()可以列出一个模块中的所有可访问内容。当你在python交互环境中测试一个模块的功能时，这会是一个很有用的工具，因为它可以提供一个包含可用函数及变量的列表:

>>> import string

>>> dir(string)

['_ _builtins_ _', '_ _doc_ _', '_ _file_ _', '_ _name_ _', '_idmap',

'_idmapL', '_lower', '_swapcase', '_upper', 'atof', 'atof_error',

'atoi', 'atoi_error', 'atol', 'atol_error', 'capitalize',

'capwords', 'center', 'count', 'digits', 'expandtabs', 'find',

...

>>>