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

最新推荐文章于 2024-05-06 21:49:48 发布

原创最新推荐文章于 2024-05-06 21:49:48 发布 · 435 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#python

python语法专栏收录该内容

13 篇文章

订阅专栏

代码结构

使用\ 进行连接，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 = '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)