F.read([size]) #size为读取的长度，以byte为单位
F.readline([size])
#读一行，如果定义了size，有可能返回的只是一行的一部分
F.readlines([size])
#把文件每一行作为一个list的一个成员，并返回这个list。其实它的内部是通过循环调用readline()来实现的。如果提供size参数，size是表示读取内容的总长，也就是说可能只读到文件的一部分。
F.write(str)
#把str写到文件中，write()并不会在str后加上一个换行符
F.writelines(seq)
#把seq的内容全部写到文件中。这个函数也只是忠实地写入，不会在每行后面加上任何东西。
file的其他方法：
f=open('/tmp/workfile', 'w')
print f读文件实例二
myfile = open('myfile', 'r') # open for input
print myfile.readline() # read the line back
print myfile.readline() # empty string: end of file
myfile.close()
读文本文件
input = open('data', 'r')
#第二个参数默认为r
input = open('data')
读固定字节
file_object = open('abinfile', 'rb')
try:
while True:
chunk = file_object.read(100)
if not chunk:
break
do_something_with(chunk)
finally:
file_object.close( )
读每行
list_of_all_the_lines = file_object.readlines( )
如果文件是文本文件，还可以直接遍历文件对象获取每行：for line in file_object:
process line
向文件中保存内容
myfile = open('myfile', 'w') # open for output (creates)
myfile.write('hello text filen') # write a line of text
myfile.close()
其它
写文本文件
output = open('data', 'w')
写二进制文件
output = open('data', 'wb')
追加写文件
output = open('data', 'w+')
写数据
file_object = open('thefile.txt', 'w')
file_object.write(all_the_text)
file_object.close( )
写入多行
file_object.writelines(list_of_text_strings)
F.close()
#关闭文件。python会在一个文件不用后自动关闭文件，不过这一功能没有保证，最好还是养成自己关闭的习惯。如果一个文件在关闭后还对其进行操作会产生ValueError
F.flush()
#把缓冲区的内容写入硬盘
F.fileno()
#返回一个长整型的”文件标签“
F.isatty()
#文件是否是一个终端设备文件（unix系统中的）
F.tell()
#返回文件操作标记的当前位置，以文件的开头为原点
F.next()
#返回下一行，并将文件操作标记位移到下一行。把一个file用于for ... in file这样的语句时，就是调用next()函数来实现遍历的。
F.seek(offset[,whence])
#将文件打操作标记移到offset的位置。这个offset一般是相对于文件的开头来计算的，一般为正数。但如果提供了whence参数就不一定了，whence可以为0表示从头开始计算，1表示以当前位置为原点计算。2表示以文件末尾为原点进行计算。需要注意，如果文件以a或a+的模式打开，每次进行写操作时，文件操作标记会自动返回到文件末尾。
F.truncate([size])
Python中函数的参数传递方式
.普通的参数传递
>>> def add(a,b):
return a+b
>>> print add(1,2)
3
>>> print add('abc','123')
abc123 2.参数个数可选,参数有默认值的传递
>>> def myjoin(string,sep='_'):
return sep.join(string)
>>> myjoin('Test')
'T_e_s_t'
>>> myjoin('Test',';')
'T;e;s;t'>>> def myrange(start=0,stop,step=1):
print stop,start,step
SyntaxError: non-default argument follows default argument参数sep的缺省值是'_' 如果这个参数不给定值就会使用缺省值 如果给定 则使用给定的值
需要注意 如果一个参数是可选参数 那么它后面所有的参数都应该是可选的,另外 可选参数的顺序颠倒依然可以正确的给对应的参数赋值 但必须清楚的指明变量名和值
3.个数可变参数
>>> def printf(fmt,*arg):
print fmt%arg
>>> printf ('%d is larger than %d',2,1)
2 is larger than 1函数中的*arg必须是最后一个参数,*表示任意多个参数,*arg会把除了前面以外所有的参数放到一个tuple里面传递给函数,可以在函数中通过arg来访问
arg是一个tuple,可以通过访问tuple的方法在函数中访问arg
另一种方式传递任意个数参数是通过dictionary的方式来传递 同样也可以接受多个参数 但是每个参数需要指明名称对应关系比如a=1,b=2,c=3
>>> def printf(format,**keyword):
for k in keyword.keys():
print "keyword[%s] %s %s"%(k,format,keyword[k])
>>> printf('is',one=1,tow=2,three=3)
keyword[three] is 3
keyword[tow] is 2
keyword[one] is 1
在定义或调用这种函数时，要遵循以下规则：
1. arg=<value>必须在arg后
2. *arg必须在arg=<value>后
3. **arg必须在*arg后
在函数调用过程中，形参赋值的过程是这样的：
首先按顺序把“arg”这种形式的实参给对应的形参
第二，把“arg=<value>”这种形式的实参赋值给形式
第三，把多出来的“arg”这种形式的实参组成一个tuple给带一个星号的形参
第四，把多出来的“key=value”这种形式的实参转为一个dictionary给带两个星号的形参。
听起来好复杂，实际是是很简单的。很直观，来看例子：
1. def test(x,y=5,*a,**b):
2. print x,y,a,b
就这么一个简单函数，来看看下面对这个函数调用会产生什么结果：
test(1) ===> 1 5 () {}
test(1,2) ===> 1 2 () {}
test(1,2,3) ===> 1 2 (3,) {}
test(1,2,3,4) ===> 1 2 (3,4)
test(x=1) ===> 1 5 () {}
test(x=1,y=1) ===> 1 1 () {}
test(x=1,y=1,a=1) ===> 1 1 () {'a':1}
test(x=1,y=1,a=1,b=1) ===> 1 1 () {'a':1,'b':1}
test(1,y=1) ===> 1 1 () {}
test(1,2,y=1) ===> 出错，说y给赋了多个值
test(1,2,3,4,a=1) ===> 1 2 (3,4) {'a':1}
test(1,2,3,4,k=1,t=2,o=3) ===> 1 2 (3,4) {'k':1,'t':2,'o':3}
在python中函数参数的定义主要有四种方式：
1.F(arg1,arg2,...)
这是最常见的定义方式，一个函数可以定义任意个参数，每个参数间用逗号分割，用这种方式定义的函数在调用的的时候也必须在函数名后的小括号里提供个数相等的值（实际参数），而且顺序必须相同，也就是说在这种调用方式中，形参和实参的个数必须一致，而且必须一一对应，也就是说第一个形参对应这第一个实参。例如：
def a(x,y):
print x,y
调用该函数，a(1,2)则x取1，y取2，形参与实参相对应，如果a(1)或者a(1,2,3)则会报错。
2.F(arg1,arg2=value2,...)
这种方式就是第一种的改进版，提供了默认值
def a(x,y=3):
print x,y
调用该函数，a(1,2)同样还是x取1，y取2，但是如果a(1)，则不会报错了，这个时候x还是1，y则为默认的3。上面这俩种方式，还可以更换参数位置，比如a(y=8,x=3)用这种形式也是可以的。
3.F(*arg1)
上面俩个方式是有多少个形参，就传进去多少个实参，但有时候会不确定有多少个参数，则此时第三种方式就比较有用，它以一个*加上形参名的方式来表示这个函数的实参个数不定，可能为0个也可能为n个。注意一点是，不管有多少个，在函数内部都被存放在以形参名为标识符的tuple中。
>>> def a(*x):
if len(x)==0:
print 'None'
else:
print x
>>> a(1)
(1,) #存放在元组中
>>> a()
None
>>> a(1,2,3)
(1, 2, 3)
>>> a(m=1,y=2,z=3)
Traceback (most recent call last):
File "<pyshell#16>", line 1, in -toplevel-
a(m=1,y=2,z=3)
TypeError: a() got an unexpected keyword argument 'm'
4.F(**arg1)
形参名前加俩个*表示，参数在函数内部将被存放在以形式名为标识符的dictionary中，这时调用函数的方法则需要采用arg1=value1,arg2=value2这样的形式。
>>> def a(**x):
if len(x)==0:
print 'None'
else:
print x
>>> a()
None
>>> a(x=1,y=2)
{'y': 2, 'x': 1} #存放在字典中
>>> a(1,2) #这种调用则报错
Traceback (most recent call last):
File "<pyshell#25>", line 1, in -toplevel-
a(1,2)
TypeError: a() takes exactly 0 arguments (2 given)
Python 的强大特性之一是其对 list 的解析，它提供一种紧凑的方法，可以通过对 list 中的每个元素应用一个函数，从而将一个 list 映射为另一个 list。
实例
a = ['cat', 'window', 'defenestrate']
for x in a:
print x, len(x)for x in [1, 2, 3]: print x, # iteration
实例
Loop through a list: for in
a = ['cat', 'window', 'defenestrate']
for x in a[:]: # make a slice copy of the entire list
if len(x) > 6: a.insert(0, x)
print a
根据数组长度来操作
a = ['Mary', 'had', 'a', 'little', 'lamb']
for i in range(len(a)):
print i, a[i]
实例
words = ['A', 'B', 'C', 'D', 'E']
for word in words:
print word
3.24. List 解析介绍
>>> li = [1, 9, 8, 4]
>>> [elem*2 for elem in li]
[2, 18, 16, 8]
>>> li
[1, 9, 8, 4]
>>> li = [elem*2 for elem in li]
>>> li
[2, 18, 16, 8]
为了便于理解它，让我们从右向左看。li 是一个将要映射的 list。Python 循环遍历 li 中的每个元素。对每个元素均执行如下操作：首先临时将其值赋给变量 elem，然后 Python 应用函数 elem*2 进行计算，最后将计算结果追加到要返回的 list 中。
需要注意是，对 list 的解析并不改变原始的 list。
将一个 list 的解析结果赋值给对其映射的变量是安全的。不用担心存在竞争情况或任何古怪事情的发生。Python 会在内存中创建新的 list，当对 list 的解析完成时，Python 将结果赋给变量。
From <dive into python>
python 分支，循环，条件语句用法
我学习了两种数据类型，1种是数字，1种是字符串。数字可以做数学运算，字符串呢可以处
理文本信息。其中数字又分为，整数，浮点数。字符串当然就是字符串了。整数，浮点数就
是描述数字的数据类型。然后呢，要做一些有意义的事情的话，就需要把这些组合起来进行
一些处理了（就是表达式了）。还要注意，python解释器在做解释之前做了数据类型的检查
，比如数字和字符串是不能相加的，如果要相加必须用str()等函数转换为字符串才行哦。但
是为什么python解释器不默认把这样的运算默认把数字当字符串处理啊！原因是这样的话，
以后程序写大了万一出问题了不好调试！嘿嘿！调试，我今天用过，调试很好啊！就像丢了
东西去找东西一样，按照原路一步一步的看东西丢在哪里了（这个比方不知道合适不啊）。
但是这里有个问题啊，既然python会做类型检查，那么我写的如下代码肯定会执行错误的啊
！！！：
>>> "3" < 3
False
结果可以正确执行，郁闷。python怎么能这样呢！得到这个结果，python到底是怎么做的啊
。我查阅了相关资料后明白了，它是把"3"的阿斯卡码值和3做的比较，因为数字在字母的后
面，所以python输出了这个结果！崩溃！唉！现在想起来python这只小蟒蛇突然间没有那么
的可爱了！不管了！
还有啊，当一些复合表达式的时候，最好用括号，因为这样可以很容易的看出谁与谁想结合
。
关于变量的思考。我现在觉得，变量不应该想成一个箱子啊！因为：
>>> x = 1 + 2
>>> y = 2 + 3
>>> z = x
>>> z
3
>>> x
3
应该想成风筝更合适点啊！变量就相当于放风筝的人！通过这个人可以找到它放的那只“风
筝”！然后1值风筝可以有两根线。可以两个人一起放一只风筝。然后,放风筝的人也可以把
自己的线隔断再连接在别人的风筝上！嗯，我觉得这样的理解才对呢。还有风筝的类型决定
了变量的类型，只要风筝类型一变化，变量的类型就变化了！比如：
>>> x = 7
>>> x = "haha"
>>> x
'haha'
唉！变量这样就给变了！嗯！这样感觉不是很好啊！还是不要随便变来变去，变得自己都忘
记了就完啦！
二：分支，条件，循环
现在回想起学第一章节的时候，写的代码可真够呆的。就像玩CS游戏的时候，好多笨蛋就知
道一条直线的往前冲，都不知道选择敌人少的地方走，真的是笨脑袋！然后呢python还是很
聪明的，例如：
x = 3
y = raw_input("y:")
if x < y:
print 'haha'
else: print 'heihei'
‘’‘’‘’‘’‘’‘’‘’‘
y:5
haha
在讲分支、循环的时候，要特别注意python代码中的强制缩进。
我们先看看分支：
（1）简单的if-else
Python代码
1. a = '1'
2. if a == 1: #注意后面有一个冒号。其中“==”是相等判断
3. print 1 #注意print 函数之前有一个tab键，这就是python的强制缩进
4. else: #注意else后面的冒号
5. print 0 #注意缩进
6.
7.
8. if (a == 1): #可以添加园括号
9. print 1
10. else:
11. print 0
输出是：
1
1
（2）and 逻辑判断
Python代码
1. a = 1
2. b = 0
3. if a == 1 and b == 1: #and 是逻辑“与”运算，自然“or”就是逻辑“或”运算
4. print 1
5. else:
6. print 0
输出是：
0
（3）分支if -else if
更近一步看：
Python代码
1. #else if
2. a = 1
3. b = 0
4. if a < 1:
5. print 1
6. elif b < 1: #注意这里不是else if ，而是elif。
7. print 0
输出是：
0
以上三个就讲完了分支判断。下面讲循环。
（一）开始是for循环：
其for循环根本上是元素的遍历：
如：
python代码
1. for i in range(0, 5): #注意range是一个函数
2. print i
3.
4. 输出是：
5. 0
6. 1
7. 2
8. 3
9. 4
输出是：
0
1
2
3
4
其中range是一个函数，表示产生一个[0,5)的序列。这里用“[0,5)”这种数学 表达方式就
是为了说明是大于等于0，小于5。是一个半开半闭区间。注意在python中都是使用半开半闭
区间（我没有见过其他的形式，或许可以自己实现）。
而“for i in range(0, 5):”的含义就是从“0，1，2，3，4”这个序列中，每次取出一个
元素赋值个变量i，每次执行print函数，打印元素i的值。
在if和for语句结束的地方都有一个冒号，这是为了告诉编译器，当前行结束了，应该解释后
面一行了。
有了这个冒号，我们其实也可以不换行，直接执行print函数。
Python代码
1. for i in range(0, 5):print i
（二）while 循环
while循环，当while条件成立的时候，执行while内部的程序段。
Python代码
1. i = 10
2. while i > 0:
3. print i
4. i -= 1
#注意python不支持i--,i++,--i,++i之类的运算
Python 汉字转换拼音代码
# -*-coding:utf-8-*-
# 返回汉字的拼音
def Return_pinyin(word):
global reslist
for line in reslist:
if (word==line[0]+line[1]) or (word==line[2]+line[3]):
str = line
break
# 取①和②之间的内容
s = str.find(u'①')+4
e = str.find(u'②')+3
return str[s:e]
def GetPy(word):
#首先装载资源文件
i=0
allstr = ''
while i<len(word):
if ord(word[i])>127:
if allstr:
allstr += Return_pinyin(word[i]+word[i+1])
else:
allstr = Return_pinyin(word[i]+word[i+1])
i +=2
else:
if allstr:
allstr += word[i]
else:
allstr = word[i]
i +=1
return allstr
if __name__=='__main__':
f = open('wbtext1.txt','r')
reslist = f.readlines()
f.close()
word = raw_input(u'请输入汉字: ')
print GetPy(word).lower()