# -*- coding: utf-8 -*-import math
defadd_end(L=None):#add_end(L=[]):
L.append('END')
return L
a = add_end([1, 2, 3])
print a
'''
1、对于任意函数,都可以通过类似func(*args, **kw)的形式调用它,
无论它的参数是如何定义的。
2、对于函数的使用,参数顺序有:必选参数、默认参数、可变参数和关键字参数。
3、例子
>>> func(1, 2)
a = 1 b = 2 c = 0 args = () kw = {}
>>> func(1, 2, c=3)
a = 1 b = 2 c = 3 args = () kw = {}
>>> func(1, 2, 3, 'a', 'b')
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}
>>> func(1, 2, 3, 'a', 'b', x=99)
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}
4、深化
默认参数一定要用不可变对象,如果是可变对象,运行会有逻辑错误!
要注意定义可变参数和关键字参数的语法:
*args是可变参数,args接收的是一个tuple;
**kw是关键字参数,kw接收的是一个dict。
以及调用函数时如何传入可变参数和关键字参数的语法:
可变参数既可以直接传入:func(1, 2, 3),又可以先组装list或tuple,再通过*args传入:func(*(1, 2, 3));
关键字参数既可以直接传入:func(a=1, b=2),又可以先组装dict,再通过**kw传入:func(**{'a': 1, 'b': 2})。
使用*args和**kw是Python的习惯写法,当然也可以用其他参数名,但最好使用习惯用法。
使用递归函数的优点是逻辑简单清晰,缺点是过深的调用会导致栈溢出。
针对尾递归优化的语言可以通过尾递归防止栈溢出。尾递归事实上和循环是等价的,
没有循环语句的编程语言只能通过尾递归实现循环。
Python标准的解释器没有针对尾递归做优化,任何递归函数都存在栈溢出的问题。
''''''
def power(x, n=2):
s = 1
while n > 0:
n = n - 1
s = s * x
return s
def enroll(name,gender,age = 6,city = 'BeiJing'):
print 'name:',name
print 'gender:',gender
print 'age:',age
print 'city:',city
print power(5)
enroll('ChenYu','M')
def move(x, y, step, angle=0):
nx = x + step * math.cos(angle)
ny = y - step * math.sin(angle)
return nx, ny
r = move(100, 100, 60, math.pi / 6)
print r
print u"输入名字:"
name = raw_input()
print 'hello,',name
a = int(raw_input(u'请输入一个整数'))
print 'This is used for %s %d' % ('test',a)
print u"循环的使用for和while:"
sum = 0
for x in [1,2,3,4,5,6,7,8,9,10]:
sum = sum + x
print sum
print range(5)
sum = 0
n = 99
while n > 0:
sum = sum + n
n = n -2
print sum
print u'字典的使用:'
d = {'Michael':95,'Bob':75,'Y=Tracy':69}
print d['Michael']
''''''
定义函数时,需要确定函数名和参数个数;
如果有必要,可以先对参数的数据类型做检查;
函数体内部可以用return随时返回函数结果;
函数执行完毕也没有return语句时,自动return None。
函数可以同时返回多个值,但其实就是一个tuple。
'''defmy_cmp(x,y):ifnot isinstance(x,(int, float)):
raise TypeError('bad operand type')
ifnot isinstance(y,(int, float)):
raise TypeError('bad operand type')
if x > y:
returnTrueelif x < y:
returnFalseelse:
return0defnop():pass
a = my_cmp(1,2.0)
print a
匿名函数等高级方法
# -*- coding: utf-8 -*-import functools
defcalc_sum(*args):
ax = 0for n in args:
ax = ax + n
return ax
deflazy_sum(*args):defsum():
ax = 0for n in args:
ax = ax + n
return ax
return sum
f = lazy_sum(1,3,4,5)
print f
print f()
# 闭包# 函数lazy_sum中又定义了函数sum,并且,内部函数sum可以引用外部函数lazy_sum的参数和局部变量,# 当lazy_sum返回函数sum时,相关参数和变量都保存在返回的函数中,# 这种称为“闭包(Closure)”的程序结构拥有极大的威力。# 请再注意一点,当我们调用lazy_sum()时,每次调用都会返回一个新的函数,即使传入相同的参数:# 返回函数不要引用任何循环变量,或者后续会发生变化的变量。defcount():
fs = []
for i in range(1, 4):
deff():return i*i
fs.append(f)
return fs
f1, f2, f3 = count()
defcount():
fs = []
for i in range(1, 4):
deff(j):defg():return j*j
return g
fs.append(f(i))
return fs
# 对于匿名函数的使用如下:# 关键字lambda表示匿名函数,冒号前面的x表示函数参数。# 匿名函数有个限制,就是只能有一个表达式,不用写return,返回值就是该表达式的结果。# 用匿名函数有个好处,因为函数没有名字,不必担心函数名冲突。# 此外,匿名函数也是一个函数对象,也可以把匿名函数赋值给一个变量,再利用变量来调用该函数:
f = lambda x: x * x
print f
print f(5)
defbuild(x,y):returnlambda:x*x + y*y
#print build#print build(2,3)# 由于函数也是一个对象,而且函数对象可以被赋值给变量,所以,通过变量也能调用该函数。defnow():print'2015-5-30'
f = now
f()
#print now.__name__#print f.__name__deflog(func):defwrapper(*args,**kw):print'call %s()' % func.__name__
return func(*args,**kw)
return wrapper
# 观察上面的log,因为它是一个decorator,所以接受一个函数作为参数,并返回一个函数。# 我们要借助Python的@语法,把decorator置于函数的定义处# 装饰器:假设我们要增强now()函数的功能,比如,在函数调用前后自动打印日志,# 但又不希望修改now()函数的定义,这种是代码运行期间动态增加功能的方式@log defnow_2():print'2015'
now_2()
# print now_2()# 偏函数的使用# 自定义int2()# functools.partial就是帮助我们创建一个偏函数的,不需要我们自己定义int2(),# 可以直接使用下面的代码创建一个新的函数int2defint2(x,base = 2):return int(x,base)
# 把一个函数的某些参数给固定住(也就是设置默认值),返回一个新的函数,调用这个新函数会更简单。# 注意到上面的新的int2函数,仅仅是把base参数重新设定默认值为2,但也可以在函数调用时传入其他值# functools.partial()是进行函数封装的一种方法print int2('10000')
int2_2 = functools.partial(int,base = 2)
print int2_2('10000')