Python-函数1

函数的定义：

    函数是指将一组语句的集合通过一个名字(函数名)封装起来

特性：

   1、减少重复代码

   2、使程序变得可扩展

   3、是程序变得易维护

函数的使用:

   只需调用函数名即可

语法：

    

def function():     #定义一个函数
    print("this is function")    #执行体
function()    #调用函数
输出:
C:Python35python.exe D:/linux/python/all_test/总练习.py
this is function

带参数的函数

def function(x,y):     #定义一个函数
   res = x * y
   return res #返回执行的结果
c = function(2,3)    #调用函数
print(c)
输出：
C:Python35python.exe D:/linux/python/all_test/总练习.py
6

函数的参数与局部变量

 形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量

 实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值

盗张图

来我们再抄一段alex的博客内容，当然不能全抄 我也得改改，哈哈

默认参数

def information(name,age,country,course): #定义一个信息函数
    print("----注册学生信息----")
    print("姓名：",name)
    print("年龄：",age)
    print("国籍：",country)
    print("课程：",course)
information("辉哥",23,"CN","Python")
information(18,"lisa","CN","HTML")      #这里我们注意一下我们年龄和姓名输错位置了，它们会找相应的位置吗？还是按顺序输入呢？
输出：
C:Python35python.exe D:/linux/python/all_test/总练习.py
----注册学生信息----
姓名： 辉哥
年龄： 23
国籍： CN
课程： Python
----注册学生信息----
姓名： 18                  #这里我们看到年龄和姓名输错位置了，这是为什么呢？看下面解释
年龄： lisa
国籍： CN
课程： HTML

解释：因为正常情况下，给函数传参数是按顺序的，所以会导致上面的错误，要想不按位置传参的话，我们应该怎么做呢？我们就可以用关键参数，看下面例子：

def information(name,age,country,course): #定义一个信息函数
    print("----注册学生信息----")
    print("姓名：",name)
    print("年龄：",age)
    print("国籍：",country)
    print("课程：",course)
information("辉哥",23,"CN","Python")
information(18,"lisa","CN","HTML")
information(age=18,country="CN",name="huige",course="python")  #指定关键参数，指定参数名

# 输出：
# C:Python35python.exe D:/linux/python/all_test/总练习.py
# ----注册学生信息----
# 姓名： 辉哥
# 年龄： 23
# 国籍： CN
# 课程： Python
# ----注册学生信息----
# 姓名： 18
# 年龄： lisa
# 国籍： CN
# 课程： HTML
#
#看下面输出即便顺序不对，我们只要指定了参数名，就会自己找自己的参数
#
# ----注册学生信息----
# 姓名： huige
# 年龄： 18
# 国籍： CN
# 课程： python

对了还要说一下默认的参数呢？看下面例子
默认参数就是，一个参数基本上就是这一个，我们就可以给其指定一个默认的参数，比如像国籍这种信息你不填写，就默认就是中国的，这就需要通过默认参数来实现，
例：
def information(name,age,course,country="CN"): #定义一个信息函数,并指定了country的默认参数为CN，备注：指定了默认参数一定要放到形参的末尾
    print("----注册学生信息----")
    print("姓名：",name)
    print("年龄：",age)
    print("国籍：",country)
    print("课程：",course)
information("辉哥",23,"CN","Python")          
information(18,"lisa","HTML")                               #这里我没有给给其指定参数，下面输出就会默认为CN
information(age=18,country="CN",name="huige",course="python")  #指定关键参数，指定参数名，关键参数，比默认参数优先

# 输出：
# C:Python35python.exe D:/linux/python/all_test/总练习.py
# ----注册学生信息----
# 姓名： 辉哥
# 年龄： 23
# 国籍： Python       #这里我们看到国籍变成Python了，可我们指定了默认参数了，原因是默认参数是你不给其传参数的情况下，
# 默认是那个指定的这里你给指定了参数，而又没有按照参数顺许来指定，当然就会位置错误了
# 课程： CN
# ----注册学生信息----
# 姓名： 18
# 年龄： lisa
# 国籍： CN
# 课程： HTML
# ----注册学生信息----
# 姓名： huige
# 年龄： 18
# 国籍： CN
# 课程： python

非固定参数  *args   **kwargs

 非固定参数是在若你的函数在定义时不确定用户想传入多少个参数，就可以使用非固定参数

def information(name,age,course,*args,country="CN"): #定义一个信息函数,并指定了country的默认参数为CN，
    # 备注：指定了默认参数一定要放到形参的末尾,非固定参数要放到指定默认参数的前面
    print("----注册学生信息----")
    print("姓名：",name)
    print("年龄：",age)
    print("国籍：",country)
    print("课程：",course)
    print("非固定参数:",args)

information(18,"lisa","HTML",12,"hah") 
#输出：
# C:Python35python.exe D:/linux/python/all_test/总练习.py
# ----注册学生信息----
# 姓名： 18
# 年龄： lisa
# 国籍： CN
# 课程： HTML
# 非固定参数: (12, 'hah')     #这里非固定参数以元组的形式输出

def information(name,age,course,*args,country="CN",**kwargs): #定义一个信息函数,并指定了country的默认参数为CN，
    # 备注：指定了默认参数一定要放到形参的末尾,非固定参数要放到指定默认参数的前面,**kwargs要放到最后面、并且所有以字典的形式出现的，都传给他
    print("----注册学生信息----")
    print("姓名：",name)
    print("年龄：",age)
    print("国籍：",country)
    print("课程：",course)
    print("非固定参数args:",args)
    print("非固定参数kwargs:", kwargs)

information(18,"lisa","HTML",12,"hah",13,"dddd","[1,2]",na1="huige",)        #这里我没有给给其指定参数，下面输出就会默认为CN
# 输出：
# C:Python35python.exe D:/linux/python/all_test/总练习.py
# ----注册学生信息----
# 姓名： 18
# 年龄： lisa
# 国籍： CN
# 课程： HTML
# 非固定参数args: (12, 'hah', 13, 'dddd', '[1,2]')
# 非固定参数kwargs: {'na1': 'huige'}

全局与局部变量

在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。

全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。

当全局变量与局部变量同名时：

在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。

我要抄代码了：

实例：

name = "Alex Li"     #定义一个全局变量
def change_name(name):
    print("before change:", name)     #在函数内未改变变量之前
    name = "金角大王,一个有Tesla的男人"   #重新定义变量
    print("after change", name)             #重新定义后
change_name(name)
print("在外面看看name改了么?", name)   #在函数体外
# 
# 输出：
# C:Python35python.exe D:/linux/python/all_test/总练习.py
# before change: Alex Li
# after change 金角大王,一个有Tesla的男人
# 在外面看看name改了么? Alex Li

嵌套函数

意思就是函数调函数，多了不说，看例子：

name = "huige"
def change_name():
    name = "huige1"
    def change_name2():
        name = "huige11"
        print("第3层打印", name)
    change_name2()  # 调用内层函数
    print("第2层打印", name)
change_name()
print("最外层打印", name)

# 输出：
# C:Python35python.exe D:/linux/python/all_test/总练习.py
# 第3层打印 huige11
# 第2层打印 huige1
# 最外层打印 huige

函数的递归

递归的内涵：

  一个函数在内部调本身，这个函数就是递归

递归特性:

1. 必须有一个明确的结束条件
2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，
每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，
所以，递归调用的次数过多，会导致栈溢出）；最高998层、

例子：通过递归进行二分查找

data = [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32,33, 35,66]
def binary_search(dataset, find_num):
    print(dataset)
    if len(dataset) > 1:
        mid = int(len(dataset) / 2)
        if dataset[mid] == find_num:  # find it
            print("找到数字", dataset[mid])
        elif dataset[mid] > find_num:  # 找的数在mid左面
            print("33[31;1m找的数在mid[%s]左面33[0m" % dataset[mid])
            return binary_search(dataset[0:mid], find_num)
        else:  # 找的数在mid右面
            print("33[32;1m找的数在mid[%s]右面33[0m" % dataset[mid])
            return binary_search(dataset[mid + 1:], find_num)
    else:
        if dataset[0] == find_num:  # find it
            print("找到数字啦", dataset[0])
        else:
            print("没的分了,要找的数字[%s]不在列表里" % find_num)
binary_search(data, 66)

# 输出:
# C:Python35python.exe D:/linux/python/all_test/总练习.py
# [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35, 66]
# 找的数在mid[18]右面
# [20, 21, 22, 23, 30, 32, 33, 35, 66]
# 找的数在mid[30]右面
# [32, 33, 35, 66]
# 找的数在mid[35]右面
# [66]
# 找到数字啦 66

匿名函数

匿名函数就是不需要显式的指定函数；匿名函数使用lambda

#这段代码
def calc(n):
    return n**n
print(calc(10))
 
#换成匿名函数
calc = lambda n:n**n
print(calc(10))
你也许会说，用上这个东西没感觉有毛方便呀， 。。。。呵呵，如果是这么用，确实没毛线改进，不过匿名函数主要是和其它函数搭配使用的呢，如下

1
2
3
res = map(lambda x:x**2,[1,5,7,4,8])  #把列表的元素一一传给x
for i in res:
    print(i)
输出

1
25
49
16
64

 高价函数

 定义:把函数作为参数传入，一个函数就可以接收另一个函数作为参数，这样的函数称为高价函数，函数是的编程就是指这种高度抽象的编程范式

简单的高阶函数

def add(x,y,f):         #这个我们传入了 -10   6  abs
    return f(x) + f(y)  #使用f=abs 这里f(x)和f(y) 等于 abs(x)和abs(y)
c = add(-10,6,abs)      #备注:abs本身就是个内置函数，是输出数值的绝对值
print(c)
#输出：
# C:Python35python.exe D:/linux/python/all_test/总练习.py
# 16
# 

 map函数的高阶

def f(x):
    return x * x
r = map(f,[1,2,3,4,5,6,7,8,9])    #map就是把列表里的1,2,3,4,5,6,7,8,9依次传给f()函数作为参数，然后赋值给r变量
print(list(r))
#输出:

# C:Python35python.exe D:/linux/python/all_test/总练习.py
# [1, 4, 9, 16, 25, 36, 49, 64, 81]

好，函数的就先说到这里。