python 函数

#coding=utf-8

#
#抽象
#

def func(a):
	if a == 1:
		print a
	elif a == 2:
		print '!=2'
	else: 
		print 'None'
		
func(3)

#特别数学
fids = [0,1]
for i in range(8):
	fids.append(fids[-2] + fids[-1])
print fids

#对上面进行封装
def InputFids(num):
	if num <= 2:
		assert False, 'num < 2'
		return
	num = num - 2
	fids = [0, 1]
	for i in range(num):
		fids.append(fids[-2] + fids[-1])
	print fids
InputFids(3)


#6-1创建函数
import math
x = 1
y = math.sqrt
print callable(x)                                      #内建函数 callable 判断这个函数是否可用
print callable(y)                                      # X是变量 @return False Y是函数 @return True
print y(x)

#6-1-1 文档化函数
def test(a = '', b = ''):                              # 函数 可提供默认参数
	'this is test func'                                # @必须写在函数开头
													   # @相当于 #调用；不过会作为函数的一部分进行存储
	pass
	print '1233'

print test.__doc__                                     #__doc__ 是函数属性

print help(test)                                       # 内建函数 help 用来查看函数定义和其说明__doc__

print test(1)                                          #无返回值，输出为None

#6-2 参数
# 形参： 函数括号中定义的变量称为 形参
# 实参:  调用函数时提供的值 是 实参
# 参数是有作用域的, 形参 只能在函数内部生效； 覆盖全局变量
test(b = 1, a = 2)                                     #可以打乱顺序 传值；但必须显示 赋值
test(a = 1, b = 2)
test()                                                # 有默认值时，可不填

# 字典 函数
def init(data):
	data['first'] = {}
	data['middle'] = {}
	data['last'] = {}

def lookup(data, label, name):
	return data[label].get(name)

def store(data, full_name):
	names = full_name.split()                           # 拆分成 列表
	print names
	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]             # 添加, 开辟新的并存储

MyName = {}
init(MyName)
store(MyName, 'Mrs LILY')
store(MyName, 'Mrs Jone')
print lookup(MyName, 'first','Mrs')

#引用，只能使用列表
#ep1:
def inc(x): return x + 1
foo = 10 
foo1 = inc(foo)                                           # 这个变量引用无效
print foo1,foo

#ep2:
def inc1(x): 
	x[0] = x[0] + 1                                       # 列表引用有效
foo= [10]
inc1(foo)
print foo


#回调函数使用
def func(x):
	print x, 'show'
def test1(func2):
	func2(1)

test1(func)

#6-3多个参数
def print_param(param1, *param):                                  # 可以看做多个参数存储到一个变量中
	print param

print_param(1, 2, '123', 'qqqqqq', u'卡哇伊')

#关键字参数
def print_param2(**param):                                        #直接转换为字典
	print param

print_param2(x = 1, y = 2) 

def print_param3(x, y ,  *parm, **keypar):
	print x, y
	print parm
	print keypar
print_param3(1, 2, '2','3', foo = 1, ffo= 2)

#6-4 参数收集逆向过程
def add(x, y) : return x + y
params = (1,2)
params2 = [2,3]
print add(*params)                                             #也支持拆包
print add(*params2)	


self_dir = {'x':'test', 'y':'test2' }                         # 键值不能随意定义， 必须与 下面的形参一致
def show_dir(x = '1', y = '2'):                               # 与上面一致
	print '%s,%s' % (x, y)
show_dir()
show_dir(**self_dir)                                         #想使用双*, 定义的 键值名， 必须与函数的 参数名一致，否则找不到

def with_stars(**kwds):
	print kwds['x']
	
def without(kwds):
	print kwds['name'], 'is', kwds['age'], 'years old'
with_stars(**self_dir)

#ep
def foo(x, y, z, m = '0', n = '0'):
	print x, y, z, m, n

def call_foo(*arg, **kwds):
	print "call foo",arg, kwds
	#foo(*arg, **kwds)
call_foo(12, 33, 35, x = '99', y = '234')

#6-5 练习示例
def story(**kwds):
	return "show %(job)s call %(name)s" % kwds

def power(x, y, *others):
	if others:
		print 'show others', others
	return pow(x, y)

def interval(start, stop = None, step = 1):
	'---------------------------'
	if stop is None:
		start, stop = 0, start
	result = []
	i = start
	while i < stop:
		result.append(i)
		i += step
	return result

print story(job = 'king', name = 'Hj')
params = {'job':'111', 'name':'222'}
print story(**params)

del params['job']
print story(job = 'shit', **params)
print interval(10)
print power(2,3, '1233333')
print power(*interval(3,6))

#作用域

g_test = 33                       #全局变量不能作为 函数 的 参数名
def test22():
	g_test = 3
	print g_test
	#global g_test        #将局部变量转换为全局变量, 将局部的值【 覆盖 】全局的值
	#print g_test
	#global g_test
	#print g_test
print 'glot'
print g_test
test22()
print 'glot'
print g_test

#嵌套作用域

def test11(te):
	def test55(num):                # 这个函数 成为闭包
		num += te                  # 函数返回出去后， te值还保存着
		print num
	return test55
local = test11(5)
num = 2
for i in range(5):
	local(num)
	
#6-5 递归

def addNum(num):
	if num == 100:
		print 'is over'
		return
	num += 1	
	return addNum(num)             # 反复调用自己
addNum(-20)	

#二分法处理
import random
num = random.uniform(1, 100)      #获得浮点型
num = int(num)
print int(num)

def getNum(min, max, num):
	falg = (max - min)/2 + min
	#global num
	if falg > num:
		max = falg
		getNum(min,max, num)
	elif falg < num:
		min = falg
		getNum(min,max, num)
	else:
		print falg
getNum(1, 100, num)