python 基础学习八——函数

函数

函数简介

• 函数也是一个对象
• 函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
• 函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

定义一个函数

def 函数名([形参1,形参2,形参3....]):
    代码块

你可以定义一个由自己想要功能的函数，以下是简单的规则：
函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
注意：
函数名必须符合标识符的规范(可以包含字母、数字、下划线但是不能以数字开头)
print是函数对象  print()是调用函数

函数的参数

形参和实参

• 形参(形式参数) 定义形参就相当于在函数内部声明了变量，但是并不是赋值
• 实参(实际参数)指定了形参，那么在调用函数时必须传递实参，实参将会赋值给对应的形参，简单来说有几个形参就要有几个实参

参数的传递方式

• 定义形参时,可以为形参指定默认值。指定了默认值以后，如果用户传递了参数则默认值不会生效。如果用户没有传递，则默认值就会生效
• 位置参数：位置参数就是将对应位置的实参赋值给对应位置的形参
• 关键字参数 : 关键字参数可以不按照形参定义的顺序去传递，而根据参数名进行传递
• 混合使用位置参数和关键字参数的时候必须将位置参数写到关键字参数前面去

不定长参数

• 定义函数时，可以在形参前面加一个*,这样这个形参可以获取到所有的实参，它会将所有的实参保存到一个元组中
def func(*arg):
    print(arg)

func(1,2,3,4,5)
>>> (1,2,3,4,5)

*arg会把多出来的位置参数转化为tuple
**kwarg会把关键字参数转化为dict

• 带*号的形参只能有一个，可以和其他参数配合使用
• *形参只能接受位置参数，不能接受关键字参数
• **形参可以接收其他的关键字参数,它会将这些参数统一保存到字典当中。字典的key就是参数的名字,字典的value就是参数的值

• **形参只有一个，并且必须写在所有参数的后面
def func(**kwarg):
    print(kwarg)

func(a=1,b=2)

参数的解包

• 传递实参时，也可以在序列类型的参数前添加星号，这样它会自动的将序列中元素依次作为参数传递
def func(a,b,c,d):
    print(a,b,c,d)

list1=[1,2,3,4]
func(*list1)
>>> 1 2 3 4

• 要求序列中的元素的个数必须和形参的个数一致

函数的返回值

• 返回值就是函数执行以后返回的结果，默认返回None
• 通过return来指定函数的返回值,可以有多个返回值
• return后面可以跟任意对象，返回值甚至可以是一个函数

文档字符串

• help()是Python中内置函数，通过help()函数可以查询Python中函数的用法

• 在定义函数时，可以在函数内部编写文档字符串，文档字符串就是对函数的说明

变量的作用域

一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。

• 作用域指的是变量生效的区域
• 在Python中一共有两种作用域
• 全局作用域(全局变量)
• 全局作用域在程序执行时创建，在程序执行结束时销毁
• 所有函数以外的区域都是全局作用域
• 在全局作用域中定义的变量，都是全局变量，全局变量可以在程序的任意位置进行访问

• 函数作用域（局部变量）
• 函数作用域在函数调用时创建，在调用结束时销毁
• 函数每调用一次就会产生一个新的函数作用域
• 在函数作用域中定义的变量，都是局部变量，它只能在函数内部被访问

命名空间

• 命名空间实际上就是一个字典，是一个专门用来存储变量的字典
• locals()用来获取当前作用域的命名空间
• 如果在全局作用域中调用locals()则获取全局命名空间，如果在函数作用域中调用locals()则获取函数命名空间
• 返回值是一个字典

递归函数

• 递归是解决问题的一种方式，它的整体思想，是将一个大问题分解为一个个的小问题，直到问题无法分解时，在去解决问题
• 递归式函数有2个条件
• 1. 基线条件 问题可以被分解为最小问题，当满足基线条件时，递归就不执行了
• 2. 递归条件 可以将问题继续分解的条件

可更改(mutable)与不可更改(immutable)对象

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。

可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python 函数的参数传递：

不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。

可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

高阶函数

接收函数作为参数，或者将函数作为返回值返回的函数就是高阶函数

闭包

• 将函数作为返回值也是高阶函数,我们也称为闭包

• 闭包的好处
• 通过闭包可以创建一些只有当前函数能访问的变量
• 可以将一些私有数据藏到闭包中

• 行成闭包的条件
• 函数嵌套
• 将内部函数作为返回值返回
• 内部函数必须要使用到外部函数的变量

装饰器的引入

• 我们可以直接通过修改函数中的代码来完成需求，但是会产生以下一些问题
• 如果修改的函数多，修改起来会比较麻烦
• 不方便后期的维护
• 这样做会违反开闭原则(ocp)
• 程序的设计，要求开放对程序的扩展，要关闭对程序的修改。在程序需要进行拓展的时候，不能去修改原有的代码

装饰器的使用

• 通过装饰器，可以在不修改原来函数的情况下来对函数进行扩展
• 在开发中，我们都是通过装饰器来扩展函数的功能的

函数装饰器

链接:https://blog.csdn.net/Huangqingmeng/article/details/110760665

练习

1、 打印名片程序:输入姓名，电话号码，性别，最后打印出来名片
• 控制姓名长度为6-20
• 电话号码长度11
• 性别只能允许输入男或女
• 每一样信息不允许为空

##### 三个循环分开写
def func1():
    while True:
        name=input('请输入姓名，长度6-20')
        if len(name)>=6 and len(name)<=20 and ' ' not in name:
            break
    while True:
        phone=input('请输入11位电话号码')
        if len(phone)==11 and ' ' not in phone:
            break
    while True:
        gender=input('请输入性别（男或女）')
        if  gender=='男' or gender=='女':
            print('姓名：{}\n电话号码：{}\n性别：{}'.format(name,phone,gender))
            break
                
func1()

##### 循环嵌套结构
def func1():
    num=1   
    while num:
        name=input('请输入姓名，长度6-20')
        if len(name)>=6 and len(name)<=20 and ' ' not in name:
            while num:
                phone=input('请输入11位电话号码')
                if len(phone)==11 and ' ' not in phone:
                    while num:
                        gender=input('请输入性别（男或女）')
                        if  gender=='男' or gender=='女':
                            print('姓名：{}\n电话号码：{}\n性别：{}'.format(name,phone,gender))
                            num=0
    else:
        print('程序结束')
    
func1()

##### 当时写嵌套的时候觉得会出错，结果没有出错
def func1():

    while True:
        name=input('请输入姓名，长度6-20')
        if len(name)>=6 and len(name)<=20 and ' ' not in name:
        
            while True:
                phone=input('请输入11位电话号码')
                if len(phone)==11 and ' ' not in phone:
                
                    while True:
                        gender=input('请输入性别（男或女）')
                        if  gender=='男' or gender=='女':
                            print('姓名：{}\n电话号码：{}\n性别：{}'.format(name,phone,gender))
                            break
                    break
            break   
    else:
        print('程序结束')
               
func1()

2、使用函数根据用户输入求斐波那契数列斐波那契数列：1,1,2,3,5,8,13,21…即: 起始两项均为1，此后的项分别为前两项之和

# 不需要传参，方便用户使用
def func1():
    num=int(input('请输入你要获取的项数'))   
    a=b=1
   
    if num<=2:
        [print(a,end='  ')  for i in range(num)]
    else:
        [print(a,end='  ')  for i in range(2)]
    
    for i in range(num-2):
        print(a+b,end='  ')
        a,b=b,a+b
   
func1()

3、 编写一段代码，定义一个函数求1-100之间所有整数的和，并调用该函数打印出结果

##### for循环
def func1():
    sum=0
    for i in range(1,101):
        sum+=i
    print(sum)

func1()

##### while循环
def func1():
    sum=0
    i =1
    while i <= 100:
        sum+=i
        i+=1
    print(sum)

func1()

4、用函数实现一个判断用户输入的年份是否是闰年的程序
1.能被400整除的年份
2.能被4整除，但是不能被100整除的年份
以上2种方法满足一种即为闰年

def fun1():
    year = int(input('请输入年份：'))
    if year%400==0 or year%4==0 and year%100!=0:
        print('%s是闰年'%year)
    else:
        print('%d不是闰年'%year)

fun1()

5、 猴子吃桃问题（递归）：
猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个。第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩的一半零一个。到第10天早上想再吃时，见只剩下一个桃子了，求第一天共摘了多少桃子？

def fun1(day):
    if day==10:
        return 1
    elif day>10:
        print('超出时间限制了')
    else:
        return (fun1(day+1)+1)*2

res=fun1(1)
print(res)

6、请使用装饰器实现已存在的函数的执行所花费的时间。

import time

def ti(fn):
    def me():
        a=time.clock()
        fn()
        b=time.clock()
        print(b-a)
        return b-a
    return me

# 一个简单的循环打印函数
@ti
def fun1():
    for i in range(50):
        print ('hello world!')
fun1()