Python学习笔记（10）函数

函数作用：

　　1：减少重复代码

　　2：方便修改，更易扩展

　　3：保持代码的一致性

 

def define简写

　　函数命名规则 函数名必须以下划线或字母开头，可以包含在任意字母、数字或下划线的组合，不能使用标点符号。

　　函数名是区分大小写的

　　函数名不能是保留字

 

　　函数没有return默认返回None

　　如果return多个对象，python会将其封装成一个元组返回

　　函数在执行过成中只要遇到return语句，就会执行并返回结果，return代表着函数的结束

　　函数名可以进行赋值

　　函数名可以作为函数参数，还可以作为函数的返回值

 

函数参数：

 

　　位置参数，关键字参数，默认参数

 

　　def print_info(name, age, sex='男'):
    　　print('name=%s'% name)
   　　 print('age=%d'% age)
   　　 print('sex=%s'% sex)
　　print_info('wanghaining', 20)#必须参数
　　print_info(age=21, name='yb', sex='女')#关键字参数 #默认参数

　　不定长参数，无名参数

 

　　def add(*args): #不定长参数 无命名参数
  　　  sum = 0
   　　 for i in args:
        　　sum += i
 　　   return sum

　　print(add(1,2,3,4,5))


关键字参数：

　　def print_info(name, age, *args, sex='男', **kwargs):    # 不定长参数的位置 *args放在前面 **kwargs参数放在右面
   　　 print('name=%s, age=%d, sex=%s' % (name, age, sex))
  　　  for i in args:
       　　 print(i)
   　　 for i in kwargs:
       　　 print('%s:%s' % (i, kwargs[i]))


　　print_info('王海宁', 20, 20, 1, 2, 3, whn=1, whn2=2)  # 第一种传参数方式
　　list1 = [1, 2, 3]
　　dict2 = {'whn1': '1', 'whn2': '2'}
　　print_info('王海宁', 20, *list1, **dict2) //第二中传参数方式 *列表或元组  ××字典

命名关键字参数

　　def person(name, age, *, city, job):    
　　　　print(name, age, city,job)

　　person('whn', 18, city='昆明', job='程序员')
　　* 后的参数为命名关键字参数
　　如果已有可变长参数就不需要*
　　命名关键字参数必须传入参数名

作用域

内部作用域要修改外部作用域变量的值时，全局变量要用glbol关键字，嵌套作用域变量要使用nonllocal关键字。

 

　　x = 10

　　def outside():

　　　　y = 5

　　　　def inside():

　　　　　　global x

　　　　　　nonlocal y

　　　　　　print(x,y)

　　　　inside()

　　outside()

 

递归

 

　　1.调用自身函数

　　2.有一个结束条件

　　3.但凡递归可以写的程序，循环都可以解决

　　4.递归的效率在很多时候会很低

 

　　def x(n):

　　　　if n==1:

　　　　　　return 1

　　　　else:

　　　　　　return n+x(n-1)

 　　

　　　print(x(100))　　

 

　　尾递归

　　

　　

　　def x(n, s=1):

 

　　if n == 1:

　　　　return s

　　else:

　　return x(n-1, s+(n))

　　print(x(100))

 

　

 

内置函数 

　　官方文档http://docs.python.org/3/library/functions.html#abs

 

map

 

　　def f(x):

　　　　return x*x

　　r = map(f, [1,2,3,4])　　　　　＃第一个参数为函数，第二个为可迭代对象　字符串、列表，元组，字典，集合等　　　返回一个迭代器

 

reduce

 

　　from functools import reduce

　　def f(x,y):

　　　　return x+y

　　r = reduce(f, [1,2,3,4])　　# 结果为10　　

 

 

filter 用于过滤序列

filter把传入的函数依次作用与每个元素，然后根据返回值是True还是False决定元素的去留，返回一个迭代器。

　　

　　def foo(x):

 

　　　　if x > 5:

　　　　return x

　　print(list(filter(foo, [x for x in range(10)])))

 

sorted()

　　

　　>>> sorted([36,5,+9,8,2,-9])
　　[-9, 2, 5, 8, 9, 36]

　　>>> sorted([36,5,+9,8,2,-9],key=abs)
　　[2, 5, 8, 9, -9, 36]

　　>>> sorted([36,5,+9,8,2,-9],key=abs, reverse=True)
　　[36, 9, -9, 8, 5, 2]

　　>>> sorted(['Z','a'])
　　['Z', 'a']

　　>>> sorted(['Z','a'], key=str.lower)
　　['a', 'Z']

 

 

匿名函数 lambda

　　

　　>>> list(map(lambda x:x*x, [1,2,3,4,5]))
　　[1, 4, 9, 16, 25]

 

如果在一个内部函数里，对在外部作用域(但不是在全局作用域)的变量进行引用，那么内部函数就被认为值闭包。

　　闭包=函数块+定义函数时的环境