5.24～6.4-Python-语言及其应用-笔记-代码结构

代码结构

使用\ 进行连接，python 仍然把它解释为同一行！

zip 进行并行迭代 并行迭代 并行迭代 并行迭代 并行迭代！

使用zip 可以对多个序列（元组，列表，字符串）进行迭代！

days = ['Mon','Tues','wens']
fruits = ['bana','orange','peach']
desserts =['tirma','ice_cream','pie']
for day,fruit,dessert in zip(days,fruit,desserts):
print (day,':drink',drink,'-eat',fruit,'-enjoy',dessert)

和dict,list 函数一起可以生成,对应的List 和dict

list(zip(days,fruits))
dict(zip(days,fruits))

推导式

分别实现List,dict ,set 推导式子！

list 推导式子~

num_list = [num for num in range(1,6)]
加入判断
num_list = [num for num in range(1,6) if num%2==1]
列表推导式生成元组的形式
col = range(1,7)
row = range(1,7)
cells = [(row,col) for row in rows for col in cols]
for i in cells:
print i
(1,1)(2,2) ....

dict 推导式子~**set(word)**

word
4000
= 'letter'
letter_counts = {letter:word.count(letter) for letter in set(word)}
letter_counts = {'l':1,'e':2,'t':3,'t':4,'e':5,'r':6}

Set 推导式子~

a_set = {num for num in range(1,6)if num %3 ==1}
a_set = {1,4}

!!元组是没有推导式子的，使用( )是生成器对象!!,生成器对象把数据传给迭代器的一种方式!,生成器只能运行一次，因为不保存在内存中，只能是使用一次

num_things = (num for num in range(1,6))

None值的解释！Ｎone作为布尔值和false 没有区别，区分false 需要使用is 的方式

thing = none
if thing  和　if False 是没有区别
if thing is none:

5.参数类型

位置参数，关键字参数，指定默认参数值　

def menu(wine,entree,open):
return {'a':wine,'b':entree,'c':open}
def menu(a=wine,b=entree,c=open):
def menu(wine,entree,c=open):

指定默认参数值在函数定义的时候一定被计算出来了，而不是在程序运行的时候,下面的程序解释了一下

def buggy(arg,result=[]):
result.append(arg)
print result
>>>bug('a')
>>>bug('b')#expect ['b']
['a','b']

６．＊收集位置参数，收集所有的或者是剩下的位置参数,常用的方式是＊args

def print_args(req1,req2,*args):
print ('a':req1)
print ('b':req2)
print ('more',args)
>>>print_args('cap','gloves',scarf','morecle','mysral-max')

7.** 收集关键字参数到一个字典里面,通常使用

def print_kwargs(**kwargs):
print ('key':kwargs)
print_kwargs(wine='a',entree='b',dessert='c')
>>> key:{'wine':'a','entree':'b','dessert':'c'}

８. 函数

8.1 参数func 是一个可以运行的函数的名称，把函数名称answer传过去，这里的answer仅仅是对象形式

#define func
def run_sth(func):
func()
def answer():
print 'happy'

>>>run_sth(answer)
>>> 42
def add_args(arg1,arg2):
print (arg1+arg2)
def run_sth_with_args(func,arg1,arg2):
func(arg1,arg2)
>>> run_sth_with_args(add_args,5,9)

８.2 内部函数,可以避免内部的循环和代码重迭,!!!!!!!!!　

def outer(a,b):
def inner(c,d):
return c+d
return inner(a,b)

def knight(saying):
def inner(quote):
return 'we are knight who say :'%s''%quote
return inner(saying)
>>>knight('Ni!')

8.3 闭包（inner2 是一个闭包），内部函数是一种闭包，闭包可以由另外一个函数动态生成的函数，并且可以存储／改变函数外创建的值的函数

inner2可以直接得到外部的saying参数，不需要通过一个参数获取，

外部函数返回的是inner2,是inner2的复制，并不是调用了inner的函数

def knight2(saying):
def inner2():
return 'we are the knight who say :'%s ''%saying
return inner2
a = knight2('Duck')
b = knight2('Hase')
#调用函数
>>>a()
>we are the knight who say :Duck
>>>b()
>we are the knight who say :Hase

８．４　lambda()函数，小函数定义和使用都是比较快的，captailze()函数是使得每一个单词的首字母变成大写

stairs= ['thud','meow','thus','hiss']
def edit_story(words,func):
for i in words:
print(func(i))
edit_story(stairs,lambda word:word.captailze()+'!')

9.生成器generator,创建一个列表但是不占用内存，生成器是为了迭代数据产生的，例如range()

生成器函数，区别普通函数的，它的返回值是yield语句声明，不是用return ,例：

def my_range(fir=0,last=10,step=1):
num = first
while num <last:
yield num
number += step
>>> range=my_range(1,5,1)

10.装饰器decoration ，以一个函数作为输入，另外一个函数作为输出

def document_it(func):
def new_function(*args,**kwargs):
print 'Running function:'
print 'Position argument:'
result = func(*args,**kwargs)
print 'end'
return result
return new_function

修饰器的使用方式＠,表示调用

@doucument_it
def add_init(a,b):
return a+b

一个函数调用多个修饰器,使用的顺序是越靠近def 的装饰器首先开始执行，有先后顺序

def square_it(func):
def new_function(*args,**kwargs):
result = func(*args,**kwargs)
return result*result
return new_function
@document_it
@square_it
def add_inits(a,b)
return a+b
>>> add_init(3,5)

11.global 变量，需要声明

函数中没有办法改变全局变量,报错的原因是函数里面有一个自己命名的局部变量，如果要得到全局变量，必须是利用global进行声明！！

def change_for_global():
global name = 'scc'
name = 'wjn'
print 'this is inner:',name
>>>change_for_global()

12 exception ，分开处理会是一个比较好的选择,下面的例子IndexError 是一个由于索引错误抛出的异常！，exception Execeprion as other:

这样的方式可以得到一个异常对象

shortlist= [0,1,2]
while True:
value = input('Postion[q to quit]?')
if value=='q':
break
try:
postion = int(value)
print shortlist[position]
except IndexError as error:
print ('Bad index',position)
exception Execeprion as other:
print 'Something else broke',other

自己定义一个异常类(class 对象),继承的是Exception的父类,引发异常使用的是raise 的方式,

except OopsException as Exc:这样的方式是获得整个异常对象

class UpperException(Exception):
pass
words = ['enneize','happy','Mo']
for i in words:
if i.isupper():
try:
raise UpperException(word)
except OopsException as Exc:
print(Exc)