python路--函数

函数

概念

　　1.重复代码变得简洁

　　2.方便功能的修改

　　3.代码一处修改，处处修改

创建

  def add(x,y):
      print('x+y=%s'%(x+y))

  add(3,4) #调用
  #==========================

　  import time

  time_format = '%Y-%m-%d %X'
  time_current = time.strftime(time_format)
  print(time_current)

参数

 def add( name, age ):
     print(name ,age)
 #==========================
 add( name = 'xiaohu' ,age = 12)

　　默认参数--放最后

1 def add( name, age ,sex='male'):
2     print(name ,age,sex)
3 #==========================
4 add( name = 'xiaohu' ,age = 12)

　　不定长参数I

 def add(*args):     #放到元组
     print(args)   #(1, 2, [5, 3],)
     sum = 0
     for i in args:
         sum+=i
     print(sum)  #11#==========================
 add(1,2,[5,3], )

　　不定长参数II

 def print_info(**kwargs):   #放到字典
    print(kwargs)   #{'name': 'alex', 'age': 15}
    print(kwargs['name'])   #alex
    print(kwargs['age'])    #15
    for i in kwargs:
         print(i,kwargs[i])
 #==========================
 print_info( name='alex',age=15)

　　#简单认为：无键放到*args的元组中，有键放到**keargs的字典中

　　无键和有键的不能掺和的输入

　　形参跟实参，先无键，后有键

　　def add( name, age ,sex='male'):

　　def print_info(sex='male',*args,**kwargs):

　　print_info('asd')#不管写什么参数，第一个都给sex

return

　　如果返回多个值，会将值封装在一个元组中

定义域

  count= 10  #全局变量
  def f():
      print(count)  #True
      count+=1  #False    全局作用域的值，在函数中能读(打印/赋值)不能修改

  count= 10
  def f():
      count = 5  #True  新建个变量
      print(count)
  f()
  print(count)
  # 5
  # 10
  
 最直接的考虑就是，内部定义的count看做count'，与外部的count无关

 如果想在局部改数据，global count添上。出现的效果为自己想要的
 
  count= 10
  def f():
      global count  #定义count是全局的，就能修改count的值
      print(count)
      count = 5 
  f() 
  print(count)
  #10
  #5

 变量位置不同，加的标识符也不同
  
  def outer():
      count =10  
      def inner():
          nonlocal count
          count = 20
          print(count)
     inner()
     print(count)
  outer()

补充：                                                                                     

传参

  def f(*args):
  
  　　print(args)
  
  f(*[1,2,3,])  #(1, 2, 3)
  ------------------------------
  def f(args):
 
  print(args)
 
  f([1,2,3,])  #[1, 2, 3]

高阶函数

  def fm(a,b,fm):
      return fm(a)+fm(b)
  def f(n):
     return n+1
  print(fm(3,4,f))

　　函数名代表地址，函数()表示内容

递归函数

 阶乘
 def f(n):
     if n == 0:return 1
     return n*f(n-1)
 print( f(5))

 斐波那契
 def f(n):
     if n==1:return 0
     if n==2:return 1
     return f(n-1)+f(n-2)
 print(f(7))

　　1.但凡是递归可以解决的，循环都可以解决。

　　2.递归效率低，能不用就不用。

 

内置函数

 filter(function, sequence)
 
 str = ['a', 'b', 'c', 'd']
 def fun1(s):
     if s != 'a':
         return s

 ret = filter(fun1, str)
 print(list(ret))  # ret是一个迭代器对象

 #结果['b', 'c', 'd']

map(function, sequence) 
 
 str = ['a', 'b']
 def fun2(s):
     return s + "alvin"
 ret = map(fun2, str)
 print(list(ret))  #  map object的迭代器

 #结果['aalvin', 'balvin']

 reduce(function, sequence, starting_value)
 from functools import reduce
 def add1(x, y):
     return x + y
 print(reduce(add1, range(1, 101)))  ## 4950 （注：1+2+...+99）
 print(reduce(add1, range(1, 101), 20))  ## 4970 （注：1+2+...+99+20）

普通函数与匿名函数的对比

 # 普通函数
 def add(a, b):
     return a + b
 print(add(2, 3))
 
 # 匿名函数
 add = lambda a, b: a + b
 print(add(2, 3))
 # ========输出===========
  5
  5