20161016 Python 读书笔记之函数抽象 参数、作用域

Python读书笔记之函数抽象 参数、作用域

1.斐波那契数列

#ecoding=utf-8
fibs = [0,1]
for i in range(8):
    fibs.append(fibs[-2] + fibs[-1])
print fibs

2.抽象和结构

    #下载网页、计算频率、打印每个单词的频率
page = download_page()
freqs = compute_frequencies(page)
for word,freq in freqs:
    print wprd,freq

3.记录函数

#如果在函数的开头写下字符串，他就会作为函数的一部分进行存储，这称为文档字符串
def square(x):
    'Calculates the square of the number x.'
    return x*x
print square(10)
print square.__doc__  #__doc__是函数属性
#为什么我们想要修改参数  使用函数改变数据结构是将程序抽象化的好方法
storage = {}
storage['first'] = {}
storage['middle'] = {}
storage['last'] = {}
#storage这个数据结构的存储方式是带有三个键"first"、"middle"和"last"的字典
me = 'Magnus Lie Hetland'
storage['first']['Magnus'] = [me]
storage['middle']['Lie'] = [me]
storage['last']['Hetland'] = [me]
print storage

4.默认参数

def hello(name,greeting='Hello',punctuation='!'):
    print '%s. %s%s' % (greeting,name,punctuation)
hello('Mars')
hello('Mars','Howdy','...')
hello('Mars',punctuation='.')
hello('Mars',greeting='Top of the moring to ya')
#收集参数
def print_params(*params):  #这里我们只指定了一个参数，但是前面添加了*号。为什么
    print params
print_params('Testing') #我们可以看到，结果作为元祖打印出来了。
#联合普通参数
def print_params_2(title,*params):
    print title
    print params
print_params_2('params',1,2,3)
#处理关键字参数
def print_params_3(**params):
    print params
print_params_3(x=1,y=2,z=3) #最后结果以字典的格式输出

5.如何实现多个名字同时存储。

def store(data,*full_names):
    for full_name in full_names:
        names = full_name.split()
        if len(names) == 2 : names.insert(1,'')
        labels = 'first','middle','last'
        for label ,name in zip(labels,names):
            people = lookup(data,label,name)
            if people:
                people.append(full_name)
            else:
                data[label][name] = [full_name]
d = {}

print store(d,'luke Skywalker','Anakin Skywalker')

6.反转过程

#对于参数正常工作，只要扩展的部分是最新的就可以了。可以使用同样的技术来处理字典--使用双星运算符。
def hello_3(greeting='Hello',name='world'):
    print '%s, %s!' % (greeting,name)
params = {'name':'Sir Robin','greeting':'Well met'}
hello_3(**params)
#练习使用参数
def story(**kwds):
    return 'once upon a time.there was a ' \
           '%(job)s called %(name)s.' % kwds
def power(x,y,*others):
    if others:
        print 'Received redundant parameters:', others
    return pow(x,y)
def interval(start,stop=None,step=1):
    'Imitates range() for step > 0'
    if stop is None:            #如果没有为stop提供值。。。。。
        start,stop = 0,start    #指定参数
    result = []
    i = start                   #计算start索引
    while i < stop:             #直到计算到stop索引
        result.append(i)        #将索引添加到result内。。。。
        i += step               #用step(>0)增加索引。。。。
    return result
print story(job = 'king' , name = 'Gumby')
print story(name = 'Sir Robin' , job = 'brave knight')
params = {'job':'language','name':'Python'}
print story(**params)
del params['job']
print story(job = 'stroke of genius' , **params)
print power(2,3)
print power(3,2)
print power(y=3,x=2)
params1 = (5,) * 2
print power(*params1)
print power(3,3,'Hello,world')
print interval(10)
print interval(1,5)
print interval(3,12,4)
print power(*interval(3,7))

7.作用域

#变量可以把它看成值的名字
x = 1   #在执行x=1赋值语句后，名称x引用到值1.这就像用字典一样，键引用值
scope = vars()  #当然，变量和所对应的值是用个“不可见”的字典。
print scope['x']    #使用内建的vars函数可以返回这个字典
#这类“不可见的字典”叫做命名空间或者作用域
#除了全局作用域外，每个函数都会创建一个新的作用域
def combine(parameter):
    print parameter + ' ' + globals()['parameter']
parameter = 'berry'
combine('Shrub')
x = 1
def change_global():
    global x
    x = x + 1
change_global()
print x
#函数嵌套
def multiplier(factor):
    def mutiplyByFator(number):
        return number * factor
    return multiplier
double = multiplier(2)
print multiplier(2)(3)

8.递归

    #两个经典：阶乘和幂
def factorial(n):   #求阶乘
    if n == 1:
        return 1
    else:
        return n * factorial(n-1)
print factorial(4)
def power(x,n):     #求幂
    if n==0:
        return 1
    else:
        return x * power(x,n-1)
print power(3,2)
    #递归之二元查找
def search(sequence,number,lower=0,upper=None):
    if upper is None :
        upper = len(sequence) - 1

    if lower == upper:
        assert number == sequence[upper]
        return upper
    else:
        middle = (lower + upper) // 2
        if number > sequence[middle]:
            return search(sequence,number,middle+1,upper)
        else:
            return search(sequence,number,lower,middle)
seq = [34,67,8,123,4,100,95]
seq.sort()
print seq
print search(seq,34)
print search(seq,100)
print search(seq,132)
#函数式编程的一些函数： map、filter和reduce下面介绍一下map函数   将序列中的元素全部传给一个函数
print map(str,range(10)) # Equivalent to [str(i) for i in range(10)]
#上面这条语句与下面这条语句一个意思
print [str(x) for x in range(10)]
#filter函数可以基于一个返回布尔值的函数对元素进行过滤。
def func(x):
    return x.isalnum()
seq = ["foo","x41","?!","***"]
print filter(func,seq)
#本例中，使用列表推导式可以不专门定义一个函数
print [x for x in seq if x.isalnum()]
#事实上，还有一个叫做lambda表达式的特性，可以创建短小的函数。
print filter(lambda x : x.isalnum() , seq)
#使用reduce函数，他能够将序列的前两个元素与给定的函数联合使用，并且将它们的返回值和第三个元素继续联合使用，知道整个序列处理完毕，并且得到一个最终结果。
#例如，需要计算一个序列的数字和，可以使用reduce函数加上lambda x,y : x+y(继续使用相同的数字)
numbers = [72,101,108,108,111,44,32,119,111,114,108,100,33]
print reduce(lambda x,y : x+y, numbers)