python语句和函数

一、python基本文件操作

内建函数：open（filename，‘w/r/a’）打开文件,w 覆盖写，r 读取文件，a 保留已有内容增加添加写

　　　　    read（）读取/输入

　　　　　readline（）读取一行  readlines（） 逐行读取

　　　　　seek（x，y）文件移动  第一个参数表示偏移量，第二参数 0表示从文件开头偏移，1表示从当前位置偏移，2表示从文件结尾偏移

　　　　　 print（file.tell（））  显示文件指针的位置

　　　　　write（）输出

　　　　　close（）关闭文件

二、异常的检查和处理

异常是出现在错误时采用的正常的控制流以外的动作   检测到错误，引发异常，对异常进行捕获

try：

　　检测异常

except Exceptio【，reason】

　　异常处理代码

finally：

　　发现异常是否继续执行等操作

 常见错误类型：

变量没有被定义：NameError  ‘X’ is not defined 

语法错误：SyntaxError：invalid syntax

索引异常：IndexError：string index out of rang   比如检索超过索引下标的值时

字典索引错误：KeyError：查找字典中没有的key

输入类型错误：ValueError：输入整数的位置被输入 了字符串等其他类型

属性错误：AttritubeError：‘int’ object has no attritube ‘append’ 列如整数类型不支持append

  try：

　　year = int（input（‘请输入年份’））

  except （ValueError，xxxError） as  e：#检查测到非整数会执行下列代码，并把错误异常重写成e

  else

  继续执行

  finaly

  不管什么情况都会执行下面的函数

except  exceptinon  as  e  #不管是什么错误类型都会被catch

　　print（‘请输入整数 %s’ %e）

 

三、函数

book.txt   name.txt   weapon.txt

f= open('name.txt')

data = f.read()

print (data.split('|'))  根据分隔符来拆分字符串

f2 = open(weapon.txt)

i=1

for line in f2.readlines():

　　if i % 2 == 1:

　　　　print(line.strip(' ')) 去掉每行中的换行符

　　i++

f3 = open(book.txt)

print(f3.read().replace(' ',''))  将读取内容中的换行符换成空值，读取内容变成一整行，容易匹配

def  find_item(hero)

　　with open('book.txt',encoding = GBK18030) as f:

　　data = f.read().replace(' ','')

   　name_num =re.findall(hero,data)   返回的是data中出现的所有hero

return len(name_num)

name_dict = {}

with open ('name.txt') as f:

　　for line in f:

　　　　names = line.spilt('|')

　　　　for n in names:

　　　　　　name_num = find_item(n)  返回任务出现的次数

　　　　　　name_dict[n] = name_num  将人物和出现的次数组合成字典

默认参数

def student(name,sex,age=6):  默认参数只能放在最后  传参时可以不传默认参数 

可变长参数 *：

var1 = 1

def  func(first,*other):  first是必填参数，other可填可不填  必须放在最后  *other表示一个元组, 也可以不用*  直接定义一个元组,传参时直接传元组

def student(profile,*tuple):
    out_put=" "
    print(tuple)
    for parameter in tuple:
        if not out_put:
            out_put = out_put + parameter
        else:
            out_put = out_put + ',' + parameter
    return profile+': '+out_put

print(student(u'zhangsan',u'87kg',u'man',u'19'))#  *tuple可以传一组数据

def student(profile,**kwargs):
    out_put=" "
    for name,age in kwargs.items(): #遍历字典中的内容
        if not out_put:
            out_put = out_put + name+age
        else:
            out_put = out_put + ',' + name+age
    return profile+': '+out_put

print(student(u'student',zhagnsan='12',lisi='18'))#  **kwags是一个字典，也可以直接传一个字典

　　global var1  将var1作用域修改为全局

　　var1 = 2

　　return = print(len(first)+len(other))

func(1,2,3)

 

# 经典参数实例 

def fo(x,*args,y=2,**kwargs):
    print(x)
    print(y)
    print(args)
    print(kwargs)

fo(1,(1,2,3,),{'a':1,'b':'string'})

fo(1,*(1,2,3,),**{'a':1,'b':'string'},y=5)

1
2
((1, 2, 3), {'a': 1, 'b': 'string'})
{}
1
5
(1, 2, 3)
{'a': 1, 'b': 'string'}

函数迭代器和生成器

 list【1,2,3】

it = iter(list)   iter迭代  迭代器有next方法，每次只返回元组中的一个值

print (next(it))

def  frange(start,end,step):  制作一个生成器（有迭代功能的函数,支持浮点数的range），每次只返回一个数值，next范围超过end会报错，

　　x=start

　　while x<end:

　　　　yield x

　　　　x += step

for i in frange(10,20,0.5) 

　　print(i)

匿名函数:lambda 表达式

参考文章:https://www.zhihu.com/question/20125256

def add（a，b）：

　　return a+b

add(1,2)

等同于 add  =  lambda a,b : b+a

print(add(1,2))

扩展:使用不定长参数  add = lambda *args: sum(args)

map函数:

map(Fun,Seq)   返回的是一个序列,   seq是一个元组或列表,作为fun的一个参数传入

def number(x):
return x**2
a = [2,3,4]

print(number(a[0]),number(a[1]),number(a[2]))
print(list(map(number,a)))  #这里需要注意,python2中返回的是一个列表  python3中返回的是一个迭代器
 

python 内建函数

filter（function or none，iter）将满足func的iter值取出来返回；用来筛选迭代器中的值

a = 【1,2,3,4，5】   print（list(filter（lambda x:x>2,a）)）   python3中需要用list转化  不然不会被执行，会返回一个filter对象

map（func，*iter） 可变的iter

b = 【2,3,4,5,6】  print（list（lambda x,y:x+y，a，b）） 返回的是【3,5,9,11】

from functools import reduce

reduce(func,sequence[,initial]) 初始值可以省略  把序列中的初始值按照func计算后输出

print (reduce(lambda x,y:x+y,[1,2,3],1))  返回7  （（1+1）+2）+3

zip(iter1[,iter2[...]])  返回zip object

for i in zip（（1,2,3），（1,2,3））

　　print i     返回（1,1）  （2,2）  （3,3）

可以用zip对字典中的key和value进行对调

dict = {'a':'aa','b':'bb'}

new_dict = zip(dict.values(),dict.keys())

print(dict(new_dict))    返回{aa":'a','bb':'b'}

闭包 函数嵌套 外部函数的参数被内部函数引用叫闭包

def sun (a):

　　def add(b):

　　　　retunrn a+b

　　return add

sum2 = sum(2)  传入外面的参数值2  返回的是里面的函数

print (sum2(4))  返回6   （2+4）给 里面的函数传值  返回的是里面的函数返回a+b

用闭包实现计数器功能：

def conter():

　　cnt =[0]

　　def add():             return  lambda cnt[0] : cnt[0]+1

　　　　cnt[0]+=1

　　　　return cnt[0]

　　return add

print(conter())

备注：关于为什么要是用list定义变量解释如下

python在使用变量的时候遵循一个原则：LEGB，分别是局部 local，闭包enclosing ，全局globle ，模块builtin

你使用一个函数内的变量做运算，python就会从函数中找这个变量的定义，如果找不到就会报错，避免了误使用全局变量的情况；

如果要引用的变量在闭包中，没有定义在函数内，就可以用nonlocal声明一下，python就会从外层函数中寻找这个变量；如果使用了global关键字修饰内部函数的变量，函数运算时就会在全局中寻找这个变量；如果函数内只引用全局变量而不对它进行修改，可以不加globle关键字直接引用，如果要修改全局变量则不需要在函数中声明globle关键字。

以上例子中使用list就达到了使用nonlocal变量的功能，因为对列表的操作就是直接操作了内存的位置，对变量的操作时重新分配了一块新的内存，所以在内部函数操作列表也是相当于在操作外部函数的list

 

装饰器  也是闭包的一种用法

def new_tips(argv):

　　def tips(func):

　　　　def nei(a,b):

　　　　　　print('%s  %s' %(argv,func__name__))

　　　　　　func(a,b)

　　　　return nei

　　return tips

@new_tips('test')       new_tips是装饰函数，用来装饰传进来的函数式，可以简化函数的书写，使其更加优雅。

def  test(a,b)

　　print(a+b)

print(test(1,2))

上下文自定义管理器

with open ('book.txt') as f:    等价于： try   finally：  当出现异常的时候  with会自动关闭，

　　for line  in f

　　　　print line