函数

1.  函数（functin），什么是函数，就是将一些语句通过一个名字去代替，通过调动函数名来实现其功能

对于我们以前写的那些三级菜单以及购物车程序，中间是有一部分比较重复的过程，看起来比较繁琐每次调用都需要去写那些，所以呢我们可以把这些重复的代码用一个东西来代表一下即函数，然后再去调用，这样就方便了很多，因此，这里我介绍一下基本的函数用法，

1.1  特性 ：一致性   可扩展性   代码重用  

1.2 格式，在python中用函数定义一般是def(define)       通过def来定义的，格式如下

　　def ( )  ()内是函数名

　　　　函数体          如下举个例子

def    f():
　　print("sang")
f()

sang

1.3   函数的命名规则和变量的命名规则差不多                       

函数名必须以下划线或字母开头，可以包含任意字母、数字或下划线的组合。不能使用任何的标点符号；
函数名是区分大小写的。
函数名不能是保留字。

1.4  参数

形参和实参，关键字参数，必须参数，默认参数，形参，不是实际存在的是虚拟的，在定义的时候使用形参，如f(),实参，是在调用的时候传递给函数的参数，我通过例子来说明

1.4.1

def f(n):           形参
    print(x)
f(33)   实参

def action1(n):
    print("start action1...")
def action2(n):
    print("start action2...")
def action3(n):
    print("start action3...")
action1(1)
action2(2)
action3(3)
结果：

start action1...
start action2...
start action3...

1.4.2一个日志记录

import time
def logger(n):
    time_format = "%Y-%m-%d %X"
    time_current = time.strftime(time_format)
    with open("日志记录","a")as f:
        f.write("%s end action%s
"%(time_current,n))
def action1(n):
    print("start action1...")
    logger(n)
def action2(n):
    print("start action2...")
    logger(n)
def action3(n):
    print("start action3...")
    logger(n)
action1(1)
action2(2)
action3(3)
结果：

start action1...
start action2...
start action3...
还有在新建的文件里面我们会发现时间

2016-09-06 11:25:46 end action1
2016-09-06 11:25:46 end action2
2016-09-06 11:25:46 end action3

 1.4.3必须和关键字参数

def print_info(name,age):
    print("Name:%s"%name)
    print("Age:%d"%age)
print_info("sang",22)    #必需参数  就是顺序得一致，调用和声明的顺序得一样
print_info(name="sang",age = 22)  #关键字参数  如果是print_info(22,"sang")就会报错了
结果：

Name:sang
Age:22
Name:sang
Age:22

 1.4.4 默认参数

#默认参数
def print_info(name,age,sex = "male"):
    print("Name:%s"%name)
    print("Age:%d"%age)
    print("Sex:%s"%sex)
print_info(name = "sang",age = 22)
print_info("jinxin",25)
print_info("wuchao",26)
print_info("lili",27,"female")
结果：

Name:sang
Age:22
Sex:male
Name:jinxin
Age:25
Sex:male
Name:wuchao
Age:26
Sex:male
Name:lili
Age:27
Sex:female

1.4.5不定长参数  ：

def add(x,y):
    print(x+y)
add(5,9)

def add(x,y,z):          # 这种方法有点LOW
    print(x+y+z)
add(1,2,3)

我们计算几个数的加法运算，但是如果好多数呢，显然这种方法就不行了，所以呢就引入了不定长参数*args  **kwargs

def add(*args):
    print(args)
    sum = 0
    for i in args:
        sum +=i
    print(sum)
add(1,2,3,4,5,6,7,8,9)
结果是

(1, 2, 3, 4, 5, 6, 7, 8, 9)
45

这样就实现个多个数的运算,*args表示没有命名的变量参数，**kwargs表示已经命名的变量参数

def f(**kargs):
    print(kargs)
 
f(**{'name':'sang'})

{'name': 'sang'}

def print_info(*args,**kwargs):
    print(args)
    print(kwargs)
    for i in kwargs:
        print("%s:%s"%(i,kwargs[i]))
print_info()
print_info("aaa",2,name = "hello")
结果是：

()
{}
('aaa', 2)
{'name': 'hello'}
name:hello

1.46  高阶函数            一个或者多个函数可以作为输入，输出一个函数

def foo3():
    def inner():
        return 8
    return inner
ret = foo3()
print(ret)
print(ret())
结果是：

<function foo3.<locals>.inner at 0x0000006435B6C598>
8

#1 函数名可以进行赋值
#2 函数名可以作为函数参数，还可以作为函数的返回值

def f(n):
    return n*n
def foo(a,b,func):
    ret=func(a)+func(b)
    return ret
print(foo(1,2,f))
结果：
5

2.  函数的返回值 return

#-author:"sangshijia"
#date: 2016/9/5
def f():
    print("OK")     一般情况下是默认返回一个None的，也可以写出来
    return 10       # 结束函数返回某个对象
a=f()
print(a) #print(f())

 3.函数的作用域  

我们可以通过下面的代码来 弄清它们之间的位置和关系

#作用域它们之间的关系如下：作用域局部local>外层作用域enclosing>当前模块中的全局global>python内置作用域built_in，也就是LEGB。
a = int(3.2)          #built-in        系统固定的模块里变量  如 int等
count = 10            #     全局变量global
def outer():
    o_count = 1      #  嵌套的局部变量 enclosing
    print(o_count)
    #count = 5
    def inner():
        i_count = 3   #  local  局部变量
        print(o_count)
        print(i_count)
    inner()
outer()

4.递归函数（ recursion）   我的理解：在一个函数内部可以调用其他函数，但是如果调用(return)其函数本身，那么就是递归函数

#递归的特性： 1.调用自身函数，  2.有一个结束条件
#递归的效率有时候会很低

4.1 以   斐波那契数列   （0,1,1,2,3,5,8,13,21,34........）为例子

import time                     #还可以通过时间来 测出时间差
t1 = time.time()
def fibo(n):
    before = 0
    after = 1
    if n == 0 or n ==1:
        return n                 #
    if n <= 3:
        return 1
    return fibo(n-1)+fibo(n-2)    #递归
n = int(input(":")) 
print(fibo(n))
t2 = time.time()
print(t2 - t1)
结果是：

:3
1
5.416621446609497

# def fibo_new(n):
#     if n <= 1:
#         return 1
#     return (fibo_new(n - 1) + fibo_new(n - 2))
#
# print(fibo_new(6))
结果是：
13

4.2

def fibo_new(n):
    if n <= 1:
        return 1
    return fibo_new(n-1)+fibo_new(n-2)
print(fibo_new(3))

阶乘的例子：以5位例

def f(jiecheng):
    for i in range(1, jiecheng):
        jiecheng *= i
    return jiecheng
print(f(5))

def fat(n):
    ret=1
    for i in range(2,n+1):
        ret=ret*i
    return ret
print(fat(5))

def fact(n):
    if n==1:
        return 1
    return n*fact(n-1)
print(fact(5))

4.3         all 和eval函数

print(all("123456"))        #all函数返回true,其他情况都是返回false
print(eval("1+3*5"))   #而Python中的eval函数可以计算Python表达式，并返回结果
结果是：

True
16

4.4

str = ["a","b","c","d"]
def funl(s):
    if s != "a":
        return s
ret = filter(funl,str )
print(ret)
print(list(ret))           #ret是一个迭代器对象
结果：

<filter object at 0x0000006CADCAB6D8>
['b', 'c', 'd']

重要内置函数：

def fun1(s):
    if s != 'a':
        return s
ret = filter(fun1, str)# ('b','c','d',)
print(ret) #<filter object at 0x0000000000A3A6A0>
print(list(ret))  # ret是一个迭代器对象
结果：

<filter object at 0x000000DF55C0B6D8>
['b', 'c', 'd']

4.5其他几个函数的延伸

4.51 map

str = ["a","b","c","d"]
def fun2(s):
    return s + "hello"
ret = map(fun2,str)  #
注意filter与map的区别

print(ret)    # map object的迭代器

print(list(ret))
结果：

<map object at 0x0000003A8780B6D8>
['ahello', 'bhello', 'chello', 'dhello']

from functools import reduce
def add1(x, y):
    return x + y

print(reduce(add1,range(1,101)))#reduce 的结果就是一个值

5050

4.52  

from functools import reduce
def add1(x,y):
    return x + y
print(reduce(add1,range(1,101)))
结果为
5050

4.53  lambda   匿名函数      

     匿名函数的命名规则，用lamdba 关键字标识，冒号（：）左侧表示函数接收的参数（a,b） ,冒号（：）右侧表示函数的返回值（a+b）。

　　因为lamdba在创建时不需要命名，所以，叫匿名函数　　

def add(a,b):
    return a + b
lambda a,b:a+b

匿名函数与正常函数的区别

   def add(a,b):

　　return a+b

print(add(2,3))