python浓缩（2）Python起步

本章对Python 的主要特性做一个快速介绍。

在所有的交互示例中，你会看到Python 的主提示符( >>> )和次提示符( ... )。主提示符是解释器告诉你它在等待你输入下一个语句，次提示符告诉你解释器正在等待你输入当前语句的其它部分。

语句和表达式（函数、算术表达式等）：

语句使用关键字来组成命令，类似告诉解释器一个命令；
表达式没有关键字。它们可以是使用数学运算符构成的算术表达式，也可以是使用括号调用的函数；

2.1 程序输出，print 语句及“Hello World!”

在交互式解释器中，可以用 print 语句显示变量的字符串表示，或者仅使用变量名查看该变量的原始值。

2.2 程序输入和raw_input()内建函数

下划线(_)在解释器中有特别的含义，表示最后一个表达式的值。

Python 的print 语句，与字符串格式运算符( % )结合使用，可实现字符串替换功能。

%s 表示由一个字符串来替换；%d 表示由一个整数来替换；%f表示由一个浮点数来替换；

Print 语句也支持将输出重定向到文件。符号 >> 用来重定向输出，下面这个例子将输出重定向到标准错误输出：

import sys
print >> sys.stderr, 'Fatal error: invalid input!'
import sys
print >> sys.stderr, 'Fatal error: invalid input!'

下面是一个将输出重定向到日志文件的例子：

logfile = open('/tmp/mylog.txt', 'a')
print >> logfile, 'Fatal error: invalid input!'
logfile.close()

2.2 程序输入和内建函数raw_input()

得到数据输入的方法是使用raw_input()内建函数。它读取标准输入，并将读取到的数据赋值给指定的变量。

注：内建函数int()将数值字符串转换成整数值，这样才可以对它进行数学运算。

核心笔记：从交互式解释器中获得帮助

如果需要得到一个生疏函数的帮助，只需要对它调用内建函数help()：

eg:help(raw_input);

核心风格： 一直在函数外做用户交互操作

从用户那里得到需要的数据，然后调用函数处理，从函数得到返回值，然后显示结果给用户。

更重要的，将函数分为两大类，一类只做事，不需要返回值（比如与用户交互或设置变量的值），另一类则执行一些运算，最后返回结果。如果输出就是函数的目的，那么在函数体内使用 print 语句也是可以接受的选择.

2.3 注释

Python 也使用 # 符号标示注释;
文档字符串：你可以在模块、类或者函数的起始添加一个字符串，起到在线文档的功能；与普通注释不同，文档字符串可以在运行时访问，也可以用来自动生成文档

2.4 运算符

标准算术运算符：+ - * / // % **

Python 有两种除法运算符，单斜杠用作传统除法，双斜杠用作浮点除法（对结果进行四舍五入).

传统除法是指如果两个操作数都是整数的话，它将执行是地板除(取比商小的最大整数)；
而浮点除法是真正的除法，不管操作数是什么类型，浮点除法总是执行真正的除法【第五章详细介绍】；

标准比较运算符：< <= > >= == !=

逻辑运算符：and or not

eg:

3 < 4 < 5

该例子在其他语言中通常是不合法的，不过Python 支持这样的表达式。它实际上是下面表达式的缩写：

>>> 3 < 4 and 4 < 5

2.5 变量和赋值

Python 中变量名规则与其它大多数高级语言一样;
Python变量名是大小写敏感的;
Python 是动态类型语言，变量的类型和值在赋值那一刻被初始化;
Python 也支持增量赋值，也就是运算符和等号合并在一起;
Python 不支持C 语言中的自增1 和自减1 运算符,会将 --n 解释为-(-n) 从而得到 n;

2.6 数字

Python 支持五种基本数字类型，其中有三种是整数类型。

int (有符号整数)
long (长整数)
bool (布尔值)
float (浮点值)
complex (复数)

请不要将Python 的长整数与C 语言的长整数混淆。Python 的长整数所能表达的范围远远超过C 语言的长整数， Python 长整数仅受限于用户计算机的虚拟内存总数。如果你熟悉 Java, Python 的长整数类似于 Java 中的BigInteger 类型;整型与长整型正在逐步统一为一种整数类型,从Python2.3 开始，再也不会报整型溢出错误，结果会自动的被转换为长整数,在未来版本的Python 中，两种整数类型将会无缝结合，长整数后缀 “L”也会变得可有可无；

布尔值是特殊的整数;

复数（包括-1 的平方根, 即所谓的虚数）在其它语言中通常不被直接支持（一般通过类来实现)；

decimal，用于十进制浮点数。举例来说，由于在二进制表示中有一个无限循环片段，数字1.1 无法用二进制浮点数精确表示。因此，数字1.1 实际上会被表示成：

>>> 1.1
1.1000000000000001
>>> print decimal.Decimal('1.1')
1.1

第五章详细将介绍所有的数字类型。

2.7 字符串

Python 支持使用成对的单引号或双引号，三引号（三个连续的单引号或者双引号）可以用来包含特殊字符。

使用索引运算符( [ ] )和切片运算符( [ : ] )可以得到子字符串；
字符串有其特有的索引规则：第一个字符的索引是 0，最后一个字符的索引是－1；
加号( + )用于字符串连接运算，星号( * )则用于字符串重复；

你可以在第六章学到更多有关字符串的知识。

2.8 列表和元组

能保存任意数量任意类型的Python 对象。和数组一样，通过从0 开始的数字索引访问元素，但是列表和元组可以存储不同类型的对象。

列表和元组有几处重要的区别。列表元素用中括号( [ ])包裹，元素的个数及元素的值可以改变。
元组元素用小括号(( ))包裹，不可以更改（尽管他们的内容可以）。元组可以看成是只读的列表。

通过切片运算( [ ] 和 [ : ] )可以得到子集，这一点与字符串的使用方法一样。

你可以在第六章学到更多有关列表、元组以及字符串的知识。

2.9 字典

字典是Python 中的映射数据类型，由键-值(key-value)对构成。几乎所有类型的Python 对象都可以用作键，不过一般还是以数字或者字符串最为常用。

值可以是任意类型的Python 对象，字典元素用大括号({ })包裹。

在第七章中会详细讲解字典。

2.10 代码块及缩进对齐

代码块通过缩进对齐表达代码逻辑而不是使用大括号。

2.11 if 语句

标准if 条件语句的语法如下：

if expression:
    if_suite

Python 还支持 else、elif （意指 “else-if ”）语句。

在第8 章你可以学到更多有关 if, elif, else 条件语句的知识。

2.12 while 循环

while expression:
    while_suite

第8 章的循环一节进行详细讲解。

2.13 for 循环和range()内建函数

Python 中的for 循环与传统的for 循环（计数器循环）不太一样，它更象shell 脚本里的foreach 迭代。Python 中的for 接受可迭代对象（例如序列或迭代器）作为其参数，每次迭代其中一个元素.

print 语句默认会给每一行添加一个换行符。只要在print 语句的最后添加一个逗号(,)，就可以改变它这种行为,带逗号的print 语句输出的元素之间会自动添加一个空格.

另外，通过指定输出格式，程序员可以最大程度的控制输出布局。它也可以将所有数据放到一处输出－－只需要将数据放在格式化运算符右侧的元组或字典中。

因为我们不能改变 for 循环的行为（迭代一个序列），我们可以生成一个数字序列。range()内建函数接受一个数值范围，生成一个列表.

range()函数经常和len()函数一起用于字符串索引.

>>> foo = 'abc'
>>> for i in range(len(foo)):
... print foo[i], '(%d)' % i

不过，这些循环有一个约束，你要么循环索引，要么循环元素。这导致了enumerate()函数的推出。它同时做到了这两点：

>>> for i, ch in enumerate(foo):
... print ch, '(%d)' % i

2.13 列表解析

你可以在一行中使用一个for 循环将所有值放到一个列表当中：

>>> squared = [x ** 2 for x in range(4)]
>>> for i in squared:
... print i

列表解析甚至能做更复杂的事情，比如挑选出符合要求的值放入列表：

>>> sqdEvens = [x ** 2 for x in range(8) if not x % 2]
>>>
>>> for i in sqdEvens:
... print i

2.15 文件和内建函数open() 、file()

如何打开文件：handle = open(file_name, access_mode = 'r')

file_name 变量包含我们希望打开的文件的字符串名字；
access_mode 中 'r' 表示读取，'w' 表示写入， 'a' 表示添加。其它可能用到的标声还有 '+' 表示读写， 'b'表示二进制访问. 默认值为 'r'。如果 open() 成功，一个文件对象句柄会被返回。所有后续的文件操作都必须通过此文件句柄进行。当一个文件对象返回之后，我们就可以访问它的一些方法，比如 readlines() 和close().

核心笔记：什么是属性？

属性可以是简单的数据值，也可以是可执行对象，比如函数和方法。哪些对象拥有属性呢？很多。 类，模块，文件还有复数等等对象都拥有属性。

filename = raw_input('Enter file name: ')
fobj = open(filename, 'r')
for eachLine in fobj:
    print eachLine,
fobj.close()

一次读入文件的所有行，然后关闭文件，再迭代每一行输出。这样写代码的好处是能够快速完整的访问文件。内容输出和文件访问不必交替进行。

上面的代码适用于文件大小适中的文件。对于很大的文件来说，会占用太多的内存，这时你最好一次读一行。（下一节有一个好例子）

file()内建函数是最近才添加到Python 当中的。它的功能等同于 open()，不过file()这个名字可以更确切的表明它是一个工厂函数。（生成文件对象）类似int()生成整数对象，dict()生成字典对象。

在第9 章，我们详细介绍文件对象，及它们的内建方法属性，以及如何访问本地文件系统。

2.16 错误和异常

编译时会检查语法错误，不过 Python 也允许在程序运行时检测错误。当检测到一个错误，Python 解释器就引发一个异常，并显示异常的详细信息。程序员可以根据这些信息迅速定位问题并进行调试，并找出处理错误的办法。

要给你的代码添加错误检测及异常处理，只要将它们封装在 try-except 语句当中。 try之后的代码组，就是你打算管理的代码。 except 之后的代码组，则是你处理错误的代码。

try:
    filename = raw_input('Enter file name: ')
    fobj = open(filename, 'r')
    for eachLine in fobj:
        print eachLine, fobj.close()
except IOError, e:
    print 'file open error:', e

程序员也可以通过使用 raise 语句故意引发一个异常。

在第10 章你可以学到更多有关Python 异常的知识。

2.17 函数

如果函数中没有 return 语句， 就会自动返回 None 对象。

Python 是通过引用调用的。这意味着函数内对参数的改变会影响到原始对象。不过事实上只有可变对象会受此影响，对不可变对象来说，它的行为类似按值调用。

如何定义函数

def function_name([arguments]):
    "optional documentation string"
    function_suite

定义一个函数的语法由 def 关键字及紧随其后的函数名再加上该函数需要的几个参数组成。这个语句由一个冒号(:)结束，之后是代表函数体的代码组， eg：

def addMe2Me(x):
    'apply + operation to argument'
    return (x + x)

加号运算符几乎与所有数据类型工作，不管是数值相加还是序列合并。

如何调用函数

>>> addMe2Me(4.25)
8.5
>>> addMe2Me('Python')
'PythonPython'
>>> addMe2Me([-1, 'abc'])
[-1, 'abc', -1, 'abc']

注意一下， + 运算符在非数值类型中如何工作。

默认参数

>>> def foo(debug=True):
... 'determine if in debug mode with default argument'
... if debug:
...     print 'in debug mode'
...     print 'done'
>>> foo()
in debug mode
done
>>> foo(False)
done

请阅读第11 章以了解更详细的函数的信息。

2.18 类

类是面向对象编程的核心，它扮演相关数据及逻辑的容器角色。它们提供了创建“真实”对象(也就是实例)的蓝图。

如何定义类

class ClassName(base_class[es]):
    "optional documentation string"
    static_member_declarations
    method_declarations

可以提供一个可选的父类或者说基类; 如果没有合适的基类，那就使用 object 作为基类。class 行之后是可选的文档字符串，静态成员定义，及方法定义。

class FooClass(object):
    """my very first class: FooClass"""
    version = 0.1 # class (data) attribute  // 定义了一个静态变量 version
    def __init__(self, nm='John Doe'):
        """constructor"""
        self.name = nm # class instance (data) attribute
        print 'Created a class instance for', nm
    def showname(self):
        """display instance attribute and class name"""
        print 'Your name is', self.name
        print 'My name is', self.__class__.__name__
    def showver(self):
        """display class(static) attribute"""
        print self.version # references FooClass.version
    def addMe2Me(self, x): # does not use 'self'
        """apply + operation to argument"""
        return x + x

__init__() 方法有一个特殊名字，所有名字开始和结束都有两个下划线的方法都是特殊方法。

当一个类实例被创建时， __init__() 方法会自动执行，在类实例创建完毕后执行，类似构建函数。它的目的是执行一些该对象的必要的初始化工作。通过创建自己的 __init__() 方法，你可以覆盖默认的 __init__()方法（默认的方法什么也不做），从而能够修饰刚刚创建的对象。在这个例子里，我们初始化了一个名为 name的类实例属性（或者说成员）。这个变量仅在类实例中存在，它并不是实际类本身的一部分。__init__()需要一个默认的参数，前一节中曾经介绍过。毫无疑问，你也注意到每个方法都有的一个参数， self.什么是 self ? 它是类实例自身的引用。其他语言通常使用一个名为 this 的标识符。

如何创建类实例

>>> foo1 = FooClass()
Created a class instance for John Doe

类实例使用同样的函数运算符调用一个函数或方法:

>>> foo1.showname() Your name is John Doe
My name is __main__.FooClass
>>> foo1.showver()
0.1
>>> print foo1.addMe2Me(5)
10
>>> print foo1.addMe2Me('xyz')
xyzxyz

比较有趣的数据是类名字。在showname()方法中，我们显示 self.__class__.__name__ 变量的值。对一个实例来说，这个变量表示实例化它的类的名字。（self.__class__引用实际的类）。在我们的例子里，创建类实例时我们并未传递名字参数，因此默认参数 'John Doe' 就被自动使用。不使用默认值的示例如下：

>>> foo2 = FooClass('Jane Smith') 
Created a class instance for Jane Smith
>>> foo2.showname()
Your name is Jane Smith
My name is FooClass

第十三章将详细介绍Python 类和类实例。

2.19 模块

模块是一种组织形式，它将彼此有关系的Python 代码组织到一个个独立文件当中。模块可以包含可执行代码，函数和类或者这些东西的组合。

当你创建了一个 Python 源文件，模块的名字就是不带 .py 后缀的文件名。一个模块创建之后，你可以从另一个模块中使用 import 语句导入这个模块来使用。

如何导入模块

import module_name

如何访问一个模块函数或访问一个模块变量？一旦导入完成，一个模块的属性（函数和变量）可以通过熟悉的 .句点属性标识法访问。

module.function()
module.variable

现在我们再次提供 Hello World! 例子，不过这次使用 sys 模块中的输出函数。

>>> import sys
>>> sys.stdout.write('Hello World!\n')
Hello World!
>>> sys.platform
'win32'
>>> sys.version
'2.4.2 (#67, Sep 28 2005, 10:51:12) [MSC v.1310 32 bit(Intel)]'

与print的唯一的区别在于这次调用了标准输出的 write()方法，不同于print 语句， write()不会自动在字符串后面添加换行符号，需要显示指出。

核心笔记：什么是“PEP”？

一个 PEP 就是一个 Python 增强提案，这也是在新版Python 中增加新特性的方式。它们不但提供了新特性的完整描述，还有添加这些新特性的理由，如果需要的话，还会提供新的语法、技术实现细节、向后兼容信息等等。在一个新特性被整合进Python 之前，必须通过Python 开发社区， PEP 作者及实现者，还有Python 的创始人， Guidovan Rossum(Python 终身的仁慈的独裁者）的一致同意。PEP1 阐述了PEP 的目标及书写指南。在PEP0 中可以找到所有的PEP。 PEP 索引的网址是： http://python.org/dev/peps.

关于模块和导入，你可以在第12 章中得到更多有用的信息。