函数名(位置参数，关键参数,params,*param)
* 调用时，位置参数写在最前面。
* *params收集其余的位置参数，返回tuple。
* **params收集其余的关键参数，返回字典。
裴波那契数列(任一个数都是前两个数之和）:
fibs=[0,1]
for i in range(8):
fibs.append(fibs[-2]+fibs[-1]
###############
fibs=[0,1]
num=input("How many Fibonacci numbers do you want?')
for i in range(num-2):
fibs.append(fibs[-2]+fibs[-1])
print fibs
########################
num=input("How many Fibonacci numbers do you want?')
pint fibs(num)
#先调用，后面再写独立的函数定义
创建函数
callable(函数名) 2.0版本, hasattr(func, _call) 3.0版本： 判断函数是否可调用
def 函数名(参数):
return 返回值
返回值可有可无，return只是标注函数的结束。
举例:
'create a fibonacci`是文档字符串，对函数进行解释，可以用函数名.doc调用查看
def fibs(num):
'create a fibonacci`
result=[0,1]
for i in range(num-2):
result.append(result[-2]+fibs[-1])
return result
练习：建立一个姓名数据库，可以通过中间名/姓/名查有谁，还可以通过输入全名添加记录。
#-*- coding:utf8 -*-
'''
#数据结构
storage={}
storage['first']={}
storage['middle']={}
storage['last']={}
'''
def init(data):
'初始化数据结构'
data['first']={}
data['middle']={}
data['last']={}
return
# storage={}
# init(storage)
# print storage
# me='Magnus Lie Hetland'
# storage['first']['Magnus']=[me]
# storage['middle']['Lie']=[me]
# storage['last']['Hetland']=[me]
# print storage
# print storage['middle'].get('Lie')
def lookup(data, label, name):
'查询名字'
return data[label].get(name)
#存储单个名字
def store(data, full_name):
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]
# mynames={}
# init(mynames)
# #print mynames
# store(mynames,'Magnus Lie Hetland')
# #print mynames
# store(mynames,'Robin Hood')
# store(mynames,'Robin Locksley')
# #print mynames
# lookup(mynames,'first','Robin')
# store(mynames,'Mr. Gumby')
# #print mynames
# print lookup(mynames,'middle','')
#批量存储名字
def store2(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]
疑问：
反转参数疑惑
函数练习:
#-*- coding:utf8 -*-
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 'Reveived redundant parameters: ', others
return pow(x,y)
def interval(start, stop=None, step=1):
'Imitates range() for setp >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) 增加索引i
return result
params=(5,) *2
power(*params)
# 结果：3125
power(3,3,'Hello, world')
# 结果：Received redundant parameters:('Hello, word') 27
interval(10)
# 结果:[0,1,2,3,4,5,6,7,8,9]
作用域
变量和所对应的值用的是个不可见的字典，这个字典就是命名空间或者作用域，内建函数vars可以返回这个字典
>>>x=1
>>>scope=vars()
>>>scope['x']
>>>1
>>>scope['x']+=1
>>>x
2
每个函数都会创造一个新的作用域，函数内的赋值语句只在内部作用域(局部命名空间)起作用，产生局部变量，它不影响外部(全局)作用域中相同名称的变量(全局变量)。
函数内访问全局变量
>>>def combine(parameter):
print parameter + globals()['parameter']
...
>>>parameter='berry'
>>>combine('shrub')
shrubbery
在函数内声明全局变量
>>>x=1
>>>def change_global():
global x
x=x+1
>>>change_global()
>>>x
2
嵌套函数:
函数存储子封闭作用域的行为称之为闭包
def multiplier(factor):
def multiplyByFactor(numer):
return number*factor
return multiplyByFacotor
>>>double=multiplier(2)
>>>double(5)
10
>>>multiplier(5)(4)
20
递归
有用的递归包含：
- 当函数直接返回值时有基本实例(最小可能性问题),如无，则会产生无穷递归
- 递归实例，包括一个或者多个问题最小部分的递归调用
阶乘(n(n-1)(n-2)...1)
def factorial(n):
result=n
for i in range(1,n)
result *= i
return result
########################
#1的阶乘是1
#大于1的数n的阶乘是n*(n-1)的阶乘
def factorial(n):
if n==1:
return 1
else:
return n*factorial(n-1)
幂:
0的幂都为0
1的幂都为1
任何数的0幂都为1
x的n次幂为x* x的n-1次幂
def pow(x,n):
if x = 0 and n =!0:
return 0
elif x=1 or n=0:
return 1
else:
return x*pow(x,n-1)
二元查找(binary serach)
两者中点，查找在左侧还是右侧，继续查找数字所在那部分。
下面的内容完全可以用index来找。。
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)
其他：1-3全部可以用列表推导式代替！而且更方便，或者更易读
- map: map格式:
map(str,range(10)) # 意思就是 [str(i) for i in range(10)] - filter:基于返回布尔值对元素过滤
isalnum是判断是否是数字或者字符
def func(x):
return x.isalnum()
seq=['foo','x41','?!','***']
filter(func,seq) #结果:['foo','x41']
# [x for x in seq if x.isalnum()]
- lambda匿名函数:
filter(lambda x: x.isalnum(), seq) - reduce: 将序列前两个元素与给定函数联合使用，并将返回值和第三个元素继续联合使用，直到序列处理完毕，得到最终结果。
reduce(lambda x,y:x+y, numbers)