Python 入门

对于 Python 来说，程序、脚本或者软件都是指同一个东西。
获取帮助，
如 >>>help(str)
#“print”上使用了引号，Python 就可以理解希望获取关于“print”的帮助而不是想要它打印东西。
>>>help(‘print’)

在 Python 中有 4 种类型的数——整数、长整数、浮点数和复数。

在双引号中的字符串与单引号中的字符串的使用完全相同，例如"What's your name?"和’What's your name?’。
利用三引号，你可以指示一个多行的字符串。你可以在三引号中自由的使用单引号和双引号。例如：
'''This is a multi-line string. This is the first line.
This is the second line.
"What's your name?," I asked.
He said "Bond, James Bond."
'''

转义符
例如：\' 指示单引号
注意：
在一个字符串中，行末的单独一个反斜杠表示字符串在下一行继续，而不是开始一个新的行。例如：
"This is the first sentence.\
This is the second sentence."
等价于"This is the first sentence. This is the second sentence."

在 Python 中没有专门的 char 数据类型

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

一定要用自然字符串处理正则表达式。否则会需要使用很多的反斜杠。例如，后向引用符可以写成'\\1'或 r'\1'。

使用变量时只需要给它们赋一个值。不需要声明或定义数据类型。

建议坚持在每个物理行只写一句逻辑行，尽可能避免使用分号。
下面是一个在多个物理行中写一个逻辑行的例子。它被称为明确的行连接。
s = 'This is a string. \
This continues the string.'
print s
它的输出：
This is a string. This continues the string.
类似地，
print \
i
与如下写法效果相同：
print i

缩进
空白在 Python 中是重要的。事实上行首的空白是重要的。它称为缩进。在逻辑行首的空白（空格和制表符）用来决定逻辑行的缩进层次，从而用来决定语句的分组。
这意味着同一层次的语句必须有相同的缩进。每一组这样的语句称为一个块。

如何缩进
不要混合使用制表符和空格来缩进，因为这在跨越不同的平台的时候，无法正常工作。强烈建议：在每个缩进层次使用单个制表符或两个或四个空格。
选择这三种缩进风格之一。更加重要的是，选择一种风格，然后一贯地使用它，即只使用这一种风格。

运算符
+ 加，两个对象相加3 + 5得到8。'a' + 'b'得到'ab'。
* 乘 两个数相乘或是返回一个被重复若干次的字符串 2 * 3 得到 6。'la' * 3 得到'lalala'。
** 幂 返回 x 的 y 次幂 3 ** 4 得到 81（即 3 * 3 * 3 * 3）
/ 除 x除以y 4/3得到1（整数的除法得到整数结果）。4.0/3或4/3.0得到 1.3333333333333333
// 取整除 返回商的整数部分 4 // 3.0 得到 1.0
% 取模 返回除法的余数 8%3 得到 2。-25.5%2.25 得到 1.5

If语句
if 语句用来检验一个条件，如果条件为真，我们运行一块语句（称为 if-块），否则处理另
外一块语句（称为 else-块）。else从句是可选的。
注意 if 语句在结尾处包含一个冒号——我们通过它告诉 Python 下面跟着一个语句块。
elif 从句，事实上把两个相关联的 if else-if else 语句合并为一个 if-elif-else 语句。
例如
if 逻辑语句：
TODO...
elif 逻辑语句：
TODO...
else:
TODO...

在 Python 中没有 switch 语句。

while语句
只要在一个条件为真的情况下， while 语句允许你重复执行一块语句。while 语句是所谓循环语句的一个例子。while 语句有一个可选的 else 从句。while语句可选的else 块事实上是多余的，因为你可以把其中的语句放在同一块（与 while 相同）中，跟在 while 语句之
后，这样可以取得相同的效果。

for循环
for..in 循环对于任何序列都适用。可以使用一个由内建 range 函数生成的数的列表，广义说来可以使用任何种类的由任何对象组成的序列。
Python 的 for 循环从根本上不同于 C/C++的 for 循环。C#程序员会注意到 Python 的 for 循环与 C#中的foreach 循环十分类似。Java 程序员会注意到它与 Java 1.5 中的 for (int i : IntArray)相似。

break 语句
break 语句是用来终止循环语句的，即哪怕循环条件没有称为 False 或序列还没有被完全递归，也停止执行循环语句。
一个重要的注释是，如果你从 for 或 while 循环中终止 ，任何对应的循环 else 块将不执行。
例如
while True:
s = raw_input('Enter something : ')
if s == 'quit':
break
print 'Length of the string is', len(s)
print 'Done'
在这个程序中，我们反复地取得用户地输入，然后打印每次输入地长度。我们提供了一个特别的条件来停止程序，即检验用户的输入是否是'quit'。通过终止循环到达程序结尾来停止程序。
输入字符串的长度通过内建的 len() 函数取得。
记住，break 语句也可以在 for 循环中使用。

continue 语句
continue 语句被用来告诉 Python 跳过当前循环块中的剩余语句，然后 继续 进行下一轮循环。
例如
while True:
s = raw_input('Enter something : ')
if s == 'quit':
break
if len(s) < 3:
continue
print 'Input is of sufficient length'
在这个程序中，我们从用户处取得输入，但是我们仅仅当它们有至少 3 个字符长的时候才处理它们。所以，我们使用内建的 len 函数来取得长度。如果长度小于 3，我们将使用 continue 语句忽略块中的剩余的语句。否则，这个循环中的剩余语句将被执行，我们可以在这里做我们希望的任何处理。
注意， continue 语句对于 for 循环也有效。

函数的定义
函数通过 def 关键字定义。def 关键字后跟一个函数的 标识符 名称，然后跟一对圆括号。圆括号之中可以包括一些变量名，该行以冒号结尾。接下来是一块语句，它们是函数体。
例如
def sayHello():
print 'Hello World!' # block belonging to the function
sayHello() # call the function

局部变量
当你在函数定义内声明变量的时候，它们与函数外具有相同名称的其他变量没有任何关系，即变量名称对于函数来说是 局部 的。这称为变量的 作用域 。所有变量的作用域是它们被定义的块，从它们的名称被定义的那点开始。
例如
def func(x):
print 'x is', x
x = 2
print 'Changed local x to', x
x = 50
func(x)
print 'x is still', x
它如何工作
在函数中，我们第一次使用 x 的 值 的时候，Python 使用函数声明的形参的值。
接下来，我们把值 2 赋给 x。x 是函数的局部变量。所以，当我们在函数内改变 x 的值的时候，在主块中定义的 x 不受影响。

使用 global 语句
如果你想要为一个定义在函数外的变量赋值， 那么你就得告诉 Python 这个变量名不是局部的，而是 全局 的。我们使用 global 语句完成这一功能。没有 global 语句，是不可能为定义在函数外的变量赋值的。
注意：应该尽量避免这样做，因为这使得程序的读者会不清楚这个变量是在哪里定义的。
def func():
global x
print 'x is', x
x = 2
print 'Changed local x to', x
x = 50
func()
print 'Value of x is', x
你可以使用同一个 global 语句指定多个全局变量。例如 global x, y, z。


默认参数值
对于一些函数，你可能希望它的一些参数是 可选 的，如果用户不想要为这些参数提供值的话，这些参数就使用默认值。这个功能借助于默认参数值完成。你可以在函数定义的形参名后加上赋值运算符（=）和默认值，从而给形参指定默认参数值。
注意，默认参数值应该是一个参数。更加准确的说，默认参数值应该是不可变的。
例如
def say(message, times = 1):
print message * times
say('Hello')
say('World', 5)
名为 say 的函数用来打印一个字符串任意所需的次数。如果我们不提供一个值，那么默认地，字符串将只被打印一遍。我们通过给形参 times 指定默认参数值 1 来实现这一功能。
在第一次使用 say 的时候，我们只提供一个字符串，函数只打印一次字符串。在第二次使用 say 的时候，我们提供了字符串和参数 5，表明我们想要 说 这个字符串消息 5 遍。
重要
只有在形参表末尾的那些参数可以有默认参数值，即你不能在声明函数形参的时候，先声明有默认值的形参而后声明没有默认值的形参。
这是因为赋给形参的值是根据位置而赋值的。例如， def func(a, b=5)是有效的，但是 def func(a=5, b)是 无效 的。

关键参数
如果你的某个函数有许多参数，而你只想指定其中的一部分，那么你可以通过命名来为这些参数赋值——这被称作 关键参数 ——我们使用名字（关键字）而不是位置（我们前面所一直使用的方法）来给函数指定实参。
这样做有两个 优势：一、由于我们不必担心参数的顺序，使用函数变得更加简单了。二、假设其他参数都有默认值，我们可以只给我们想要的那些参数赋值。
例如
def func(a, b=5, c=10):
print 'a is', a, 'and b is', b, 'and c is', c
func(3, 7)
func(25, c=24)
func(c=50, a=100)

return 语句
return 语句用来从一个函数 返回 即跳出函数。我们也可选从函数 返回 一个值 。
例如
def maximum(x, y):
if x > y:
return x
else:
return y
print maximum(2, 3)


DocStrings
Python 有一个很奇妙的特性，称为 文档字符串 ，它通常被简称为 docstrings 。DocStrings 是一个重要的工具，由于它帮助你的程序文档更加简单易懂，你应该尽量使用它。你甚至可以在程序运行的时候，从函数恢复文档字符串！
def printMax(x, y):
'''Prints the maximum of two numbers.
The two values must be integers.'''
x = int(x) # convert to integers, if possible
y = int(y)
if x > y:
print x, 'is maximum'
else:
print y, 'is maximum'
printMax(3, 5)
print printMax._ _doc_ _#注意双下划线

输出
5 is maximum
Prints the maximum of two numbers.
The two values must be integers.

可以使用help(printMax)和dir(printMax)查看效果。

dir()函数
你可以使用内建的 dir 函数来列出模块定义的标识符。标识符有函数、类和变量。
当你为 dir()提供一个模块名的时候，它返回模块定义的名称列表。如果不提供参数，它返回当前模块中定义的名称列表。

 del 语句删除当前模块中的变量/属性
例如 del a #将变量a删除

列表
列表中的项目应该包括在方括号中，这样 Python 就知道你是在指明一个列表。一旦你创建了一个列表，你可以添加、删除或是搜索列表中的项目。由于你可以增加或删除项目，我们说列表是 可变的 数据类型，即这种类型是可以被改变的。
如果想要知道列表对象定义的所有方法，可以通过 help(list)获得完整的知识。
# This is my shopping list
shoplist = ['apple', 'mango', 'carrot', 'banana']
print 'I have', len(shoplist),'items to purchase.'
print 'These items are:', # Notice the comma at end of the line
for item in shoplist:
print item,#这里的逗号用来消除每个 print 语句自动打印的换行符
print '\nI also have to buy rice.'
shoplist.append('rice')#利用append()函数添加一个项目
print 'My shopping list is now', shoplist
print 'I will sort my list now'
shoplist.sort()#sort()方法对列表排序
print 'Sorted shopping list is', shoplist
print 'The first item I will buy is', shoplist[0]
olditem = shoplist[0]
del shoplist[0]
print 'I bought the', olditem
print 'My shopping list is now', shoplist

元组
元组和列表十分类似，只不过元组和字符串一样是 不可变的 即你不能修改元组。元组通过圆括号中用逗号分割的项目定义。元组通常用在使语句或用户定义的函数能够安全地采用一组值的时候，即被使用的元组的值不会改变。
zoo = ('wolf', 'elephant', 'penguin')
print 'Number of animals in the zoo is', len(zoo)
new_zoo = ('monkey', 'dolphin', zoo)#注意元组之内的元组不会失去它的身份。
print 'Number of animals in the new zoo is', len(new_zoo)
print 'All animals in new zoo are', new_zoo
print 'Animals brought from old zoo are', new_zoo[2]
print 'Last animal brought from old zoo is', new_zoo[2][2]
我们可以通过一对方括号来指明某个项目的位置从而来访问元组中的项目，就像我们对列表的用法一样。这被称作 索引 运算符。 我们使用 new_zoo[2]来访问 new_zoo 中的第三个项目。 我们使用 new_zoo[2][2]来访问 new_zoo 元组的第三个项目的第三个项目。
含有 0 个或 1 个项目的元组。一个空的元组由一对空的圆括号组成，如 myempty = ()。然而，含有单个元素的元组就不那么简单了。你必须在第一个（唯一一个）项目后跟一个逗号，这样 Python 才能区分元组和表达式中一个带圆括号的对象。即如果你想要的是一个包含项目 2 的元组的时候，你应该指明 singleton = (2 , )。

元组最通常的用法是用在打印语句中
age = 22
name = 'Swaroop'
print '%s is %d years old' % (name, age)
print 'Why is %s playing with that python?' % name

print 语句可以使用跟着%符号的项目元组的字符串。这些字符串具备定制的功能。定制让输出满足某种特定的格式。定制可以是%s 表示字符串或%d 表示整数。元组必须按照相同的顺序来对应这些定制。print 的这个用法使得编写输出变得极其简单，它避免了许多字符串操作。它也避免了我们一直以来使用的逗号。
在第二个 print 语句中，我们使用了一个定制，后面跟着%符号后的单个项目——没有圆括号。这只在字符串中只有一个定制的时候有效。

字典
键必须是唯一的，就像如果有两个人恰巧同名的话，你无法找到正确的信息。
只能使用不可变的对象（比如字符串）来作为字典的键。
键值对在字典中以这样的方式标记： d = {key1 : value1, key2 : value2 }。注意它们的键/值对用冒号分割，而各个对用逗号分割，所有这些都包括在花括号中。
记住字典中的键/值对是没有顺序的。如果你想要一个特定的顺序，那么你应该在使用前自己对它们排序。
例如
ab = { 'Swaroop' : 'swaroopch@byteofpython.info',
'Larry' : 'larry@wall.org',
'Matsumoto' : 'matz@ruby-lang.org',
'Spammer' : 'spammer@hotmail.com'
}
print "Swaroop's address is %s" % ab['Swaroop']
# Adding a key/value pair
ab['Guido'] = 'guido@python.org'
# Deleting a key/value pair
del ab['Spammer']
print '\nThere are %d contacts in the address-book\n' % len(ab)
for name, address in ab.items():
print 'Contact %s at %s' % (name, address)
if 'Guido' in ab: # OR ab.has_key('Guido')
print "\nGuido's address is %s" % ab['Guido']
使用字典的 items 方法，来使用字典中的每个键/值对。这会返回一个元组的列表，其中
每个元组都包含一对项目——键与对应的值。我们抓取这个对，然后分别赋给 for..in 循环中的变量 name 和address 然后在 for－块中打印这些值。
使用 in 操作符来检验一个键/值对是否存在，或者使用 dict 类的 has_key 方法。你可以使用help(dict)来查看 dict 类的完整方法列表。

序列
列表、元组和字符串都是序列，但是序列是什么，它们为什么如此特别呢？序列的两个主要特点是索引操作符和切片操作符。索引操作符让我们可以从序列中抓取一个特定项目。切片操作符让我们能够获取序列的一个切片，即一部分序列。
shoplist = ['apple', 'mango', 'carrot', 'banana']
# Indexing or 'Subscription' operation
print '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 list
print '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 string
name = '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[:]
使用索引来取得序列中的单个项目，即下标操作。每当你用方括号中的一个数来指定一个序列的时候， Python 会为你抓取序列中对应位置的项目。Python 从 0 开始计数。因此，shoplist[0]抓取第一个项目，shoplist[3]抓取 shoplist 序列中的第四个元素。
索引同样可以是负数，在那样的情况下，位置是从序列尾开始计算的。因此， shoplist[-1]表示序列的最后一个元素而 shoplist[-2]抓取序列的倒数第二个项目。
切片操作符是序列名后跟一个方括号，方括号中有一对可选的数字，并用冒号分割。注意这与你使用的索引操作符十分相似。记住数是可选的，而冒号是必须的。
切片操作符中的第一个数（冒号之前）表示切片开始的位置，第二个数（冒号之后）表示切片到哪里结束。如果不指定第一个数，Python 就从序列首开始。如果没有指定第二个数，则 Python 会停止在序列尾。
注意，返回的序列从开始位置 开始 ，刚好在 结束 位置之前结束。即开始位置是包含在序列切片中的，而结束位置被排斥在切片外。
这样， shoplist[1:3]返回从位置 1 开始，包括位置 2，但是停止在位置 3 的一个序列切片，因此返回一个含有两个项目的切片。类似地，shoplist[:]返回整个序列的拷贝。
你可以用负数做切片。负数用在从序列尾开始计算的位置。例如， shoplist[:-1]会返回除了最后一个项目外包含所有项目的序列切片。

对象与参考
例如
print 'Simple Assignment'
shoplist = ['apple', 'mango', 'carrot', 'banana']
mylist = shoplist # mylist is just another name pointing to the same object!
del shoplist[0]
print 'shoplist is', shoplist
print 'mylist is', mylist
# notice that both shoplist and mylist both print the same list without
# the 'apple' confirming that they point to the same object
print 'Copy by making a full slice'
mylist = shoplist[:] # make a copy by doing a full slice
del mylist[0] # remove first item
print 'shoplist is', shoplist
print 'mylist is', mylist
# notice that now the two lists are different
重要 如果要复制一个列表或者类似的序列或者其他复杂的对象（不是如整数那样的简单 对象 ），那么必须使用切片操作符来取得拷贝。如果只是想要使用另一个变量名，两个名称都 参考 同一个对象。

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

类
class Person:
def sayHi(self):
print 'Hello, how are you?'
p = Person()#实例化类
p.sayHi()
# This short example can also be written as Person().sayHi()
类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称，但是在调用这个方法的时候你不为这个参数赋值，Python 会提供这个值。这个特别的变量指对象本身，按照惯例它的名称是 self。
虽然你可以给这个参数任何名称，但是 强烈建议 你使用 self 这个名称——其他名称都是不赞成你使用的。使用一个标准的名称有很多优点——你的程序读者可以迅速识别它，如果使用 self 的话，还有些 IDE（集成开发环境）也可以帮助你。
Python 中的 self 等价于 C++中的 self 指针和 Java、C#中的 this 参考。
你一定很奇怪 Python 如何给 self 赋值以及为何你不需要给它赋值。举一个例子会使此变得清晰。假如你有一个类称为 MyClass 和这个类的一个实例 MyObject。当你调用这个对象的方法 MyObject.method(arg1,arg2)的时候，这会由 Python 自动转为 MyClass.method(MyObject, arg1, arg2)——这就是 self 的原理了。
这也意味着如果你有一个不需要参数的方法，你还是得给这个方法定义一个 self 参数。

_ _init_ _方法
__init__方法在类的一个对象被建立时，马上运行。这个方法可以用来对你的对象做一些你希望的 初始化 。
例如
class Person:
    def __init__(self, name):
        self.name = name
    def sayHi(self):
        print 'Hello, my name is', self.name
p = Person('Swaroop')
p.sayHi()
# This short example can also be written as Person('Swaroop').sayHi()
__init__方法类似于 C++、C#和 Java 中的 constructor 。

class Person:
    '''Represents a person.'''
    population = 0
    def __init__(self, name):
        '''Initializes the person's data.'''
        self.name = name
        print '(Initializing %s)' % self.name
        # When this person is created, he/she
        # adds to the population
        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):
        '''Prints the current population.'''
        if Person.population == 1:
            print 'I am the only person here.'
        else:
            print 'We have %d persons here.' % Person.population
swaroop = Person('Swaroop')
swaroop.sayHi()
swaroop.howMany()
kalam = Person('Abdul Kalam')
kalam.sayHi()
kalam.howMany()
swaroop.sayHi()
swaroop.howMany()
population 属于 Person 类，
因此是一个类的变量。name 变量属于对象（它使用 self 赋值）因此是对象的变量。观察可以发现__init__方法用一个名字来初始化 Person 实例。在这个方法中，我们让 population 增加 1，这是因为我们增加了一个人。同样可以发现，self.name 的值根据每个对象指定，这表明了它作为对象的变量的本质。
记住，你只能使用 self 变量来参考同一个对象的变量和方法。这被称为 属性参考 。
在这个程序中，我们还看到 docstring 对于类和方法同样有用。我们可以在运行时使用 Person.__doc__和 Person.sayHi.__doc__来分别访问类与方法的文档字符串。
就如同__init__方法一样，还有一个特殊的方法__del__，它在对象消逝的时候被调用。对象消逝即对象不再被使用，它所占用的内存将返回给系统作它用。在这个方法里面，我们只是简单地把 Person.population减 1。
当对象不再被使用时， __del__方法运行，但是很难保证这个方法究竟在 什么时候 运行。如果你想要指明它的运行，你就得使用 del 语句，就如同我们在以前的例子中使用的那样。
Python 中所有的类成员（包括数据成员）都是 公共的 ，所有的方法都是 有效的 。
只有一个例外：如果你使用的数据成员名称以 双下划线前缀 比如__privatevar，Python 的名称管理体系会有效地把它作为私有变量。
这样就有一个惯例，如果某个变量只想在类或对象中使用，就应该以单下划线前缀。而其他的名称都将作为公共的，可以被其他类/对象使用。

类的继承
class 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.salary
class 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.marks
t = Teacher('Mrs. Shrividya', 40, 30000)
s = Student('Swaroop', 22, 75)
print # prints a blank line
members = [t, s]
for member in members:
member.tell() # works for both Teachers and Students

文件
poem = '''\
Programming is fun
When the work is done
if you wanna make your work also fun:
use Python!
'''
f = file('poem.txt', 'w') # open for 'w'riting
f.write(poem) # write text to file
f.close() # close the file
f = file('poem.txt')
# if no mode is specified, 'r'ead mode is assumed by default
while True:
    line = f.readline()
    if len(line) == 0: # Zero length indicates EOF
        break
    print line,
# Notice comma to avoid automatic newline added by Python
f.close() # close the file
首先，我们通过指明我们希望打开的文件和模式来创建一个 file 类的实例。模式可以为读模式（'r'）、写模式（'w'）或追加模式（'a'）。事实上还有多得多的模式可以使用，你可以使用 help(file)来了解它们的详情。
我们首先用写模式打开文件，然后使用 file 类的 write 方法来写文件，最后我们用 close 关闭这个文件。接下来，我们再一次打开同一个文件来读文件。如果我们没有指定模式，读模式会作为默认的模式。
在一个循环中，我们使用 readline 方法读文件的每一行。 这个方法返回包括行末换行符的一个完整行。 所以，当一个 空的 字符串被返回的时候，即表示文件末已经到达了，于是我们停止循环。
注意，因为从文件读到的内容已经以换行符结尾，所以我们在 print 语句上使用逗号来消除自动换行。最后，我们用 close 关闭这个文件。

储存器
 cPickle，它的功能和 pickle 模块完全相同，只不过它是用 C 语言编写的，因此要快得多（比 pickle 快 1000 倍）。你可以使用它们中的任一个，而我们在这里将使用 cPickle 模块。记住，我们把这两个模块都简称为 pickle 模块。

import cPickle as p
#import pickle as p
shoplistfile = 'shoplist.data'
# the name of the file where we will store the object
shoplist = ['apple', 'mango', 'carrot']
# Write to the file
f = file(shoplistfile, 'w')
p.dump(shoplist, f) # dump the object to a file
f.close()
del shoplist # remove the shoplist
# Read back from the storage
f = file(shoplistfile)
storedlist = p.load(f)
print storedlist

import..as 语法以便于我们可以使用更短的模块名称。
在这个例子中，它还让我们能够通过简单地改变一行就切换到另一个模块（cPickle 或者 pickle）！在程序的其余部分的时候，我们简单地把这个模块称为 p。
为了在文件里储存一个对象，首先以写模式打开一个 file 对象，然后调用储存器模块的 dump 函数，把对象储存到打开的文件中。这个过程称为 储存 。
接下来，我们使用 pickle 模块的 load 函数的返回来取回对象。这个过程称为 取储存 。