python3–函数(函数,全局变量和局部变量,递归函数)

python基础

浏览数:395

2019-4-20

1.1函数

1.1.1什么是函数

函数就是程序实现模块化的基本单元,一般实现某一功能的集合。
函数名:就相当于是程序代码集合的名称
参数:就是函数运算时需要参与运算的值被称作为参数
函数体:程序的某个功能,进行一系列的逻辑运算
return 返回值:函数的返回值能表示函数的运行结果或运行状态。

1.1.2函数的作用

  1.  函数是组织好的,可重复使用的,用来实现单一,或者相关功能的代码。
  2.  函数能够提高应用的模块性,和代码的重复利用率

我们已近知道python提供了许多内置函数,比如print(),我们自已创建的函数称为内置函数

1.1.3定义函数的语法

def 函数名(参数):
    函数体
    return  返回值内容

 1.1.4函数定义规则

  1. 函数代码以def关键词开头,后接定义函数的名称和圆括号,冒号():
  2. 函数内容以冒号”:”开始,并且缩进
  3. 函数内容的第一行内容可选择性使用文档字符串—用来定义该函数的说明
  4. 函数的返回值: return  [返回值内容]  用于结束函数,返回一个值,表示程序执行的结果。
  5. 函数不带return 默认返回None   返回值可以是任何类型的数据(数字,字符串,函数,列表,元祖,字典等),也可以是一个表达式
  6. 函数参数:任何传入参数和自变量必须放在圆括号中间,圆括号之间用于定义参数。

1.1.5函数调用

定义函数语法

def printinfo():
    print("hello world")
    return

调用函数

printinfo()
#函数执行结果
hello world

查看函数返回值

print(printinfo())
#结果
hello world
None             #默认函数值返回类容

其他返回值示例

def printinfo():
    print("hello world")
    return  [111+222]
print(printinfo())

#结果
hello world
[333]        #返回值内容

1.1.5函数参数

注:形参和实参(定义函数时,圆括号(参数)中的所有参数都是形式参数也称为形参,调用函数中,圆括号(参数)中的参数称为实际参数,也叫实参)

1)必须参数::

2)关键字参数:

3)默认参数:

4)可变参数(*args,**kwargs):

 1.必须参数:

从字面理解:必须要传入参数

传入的参数:与定义的形参顺序一一对应

def stuinfo(name,age):
    print(name,age)
    return

#在不传入参数
stuinfo()  #调用函数

#函数执行结果
TypeError: stuinfo() missing 2 required positional arguments: 'name' and 'age'
#报错,提示类型错误,该函数,缺少两个位置参数

不传入参数

def stuinfo(name,age):
    print(name,age)
    return
stuinfo("zhangsan",18) 
#函数执行结果
zhangsan 18

传入参数

 2.关键字参数

def stuinfo(name,age,hobby):
    print(name,age,hobby)
    return

#参数位置匹配,关键字参数,与形参的位置顺序无关,
stuinfo(age=19,name="lisi",hobby="run")  
#name=   age=  hobby=就是关键字参数

#函数执行结果
lisi 19 run

关键字参数

3.默认参数

默认参数必须指向不变的对象

当函数有多个参数,把变化大的参数反正前面,变化小的参数放在后面。变化小的参数就作为默认参数。

默认参数好处:降低调用函数的难度

#默认参数,可以直接使用用,也可以修改默认参数值
def grade(name,age,city="BeiJing"):  #city="BeiJing"  就是默认参数
    print(name,age,city)
# grade("yangjian",age=18)
grade("lala",age=18,city="shanghai")

#grade函数执行结果
lala 18 shanghai

默认参数

4.可变参数

*args  **args

用途:在定义函数需要,每个定义函数功能的都可以继续优化,所以我们需要用动态参数

如果把参数写死了,后期继续修改完善的功能的,修改该函数功能则会相当麻烦

*args  结果类型是元祖,传递值是任意类型

def test(*args):
    print(args)
test(123456,[12,45,88],{"name":"qw","age":15}) #可以传递任意参数的类型
#函数执行结果
(123456, [12, 45, 88], {'name': 'qw', 'age': 15})

**kwargs结果类型是字典,传递值是以key=value方式传入

def test1(**kwargs):
    print(kwargs)
test1(name="xiha",age="12")

#执行结果
{'age': '12', 'name': 'xiha'}

函数* 和 ** 解包

#*
def test(*args):
    print(args)
test(*[1,2,3,4,5,6,7,8,9])  #*参数解包,把【元素】 循环出来,添加到元祖中
#结果
(1, 2, 3, 4, 5, 6, 7, 8, 9)

*

def test1(**kwargs):
    print(kwargs)
test1(**{"hobby":456,"number":789}) #**参数解包,把key:value 循环出来,添加到字典中
#结果
{'number': 789, 'hobby': 456}

**

函数参数组合

def f2(a, b, c=0,*args,**kwargs):
    print('a =', a, 'b =', b, 'c =', c, args,kwargs)
f2(12,b=12,c=89,aa="as",bb="xxx")
#结果
a = 12 b = 12 c = 89 () {'bb': 'xxx', 'aa': 'as'}

函数参数总结:

1.形参的位置顺序,必须与实参的顺序一一对应,缺一不行,多一不行

2.关键字参数,无须一一对应,缺一不行,多一不行

3.位置参数必须在关键字参数左边

4.默认参数一定要用不可变对象,如果是可变对象,程序运行时会有逻辑错误

1.2全局变量和局部变量

在子程序中定义的变量称为局部变量,只在子程序内部生效,

在程序一开始定义的变量称为全局变量

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

当全局变量与局部变量同名时:在定义局部变量的子程序内,局部变量起作用,在其他地方全局变量起作用

name = "xixi"   #全局变量
def change_name():
    name = "haha"  #局部变量只在函数局部作用域内生效
    print("我的名字",name)
    return
change_name()
print(name)

def me():
    global name #声明name是全局变量  global
    name = "yj"  #修改name全局变量的值
    print(name)
    return
me()

如果全局变量是可变的数据类型,函数可以对全局变量内部直接进行修改

eng = ["merry","jack","petter"]
def chang():
    eng.append("mali")
    print(eng)
    return
chang()

总结:

一般写程序变量的命名规则

###全局变量变量名大写

###局部变量变量名小写

  1. 函数优先读取局部变量,能读全局变量,无法对全局变量重新赋值操作,#全局变量是不可变的类型
  2. 全局变量是可变类型,函数可以对全局变量进行操作
  3. 函数中有global关键字,变量本质就是全局变量,可读取全局变量,也可操作全局变量

1.3函数之间嵌套

name = "YangJIan"  #最外层

def change_name(): #第二层
    name = "YangJIan2"

    def change_name2(): #第三层
        name = "YangJIan3"
        print("第3层打印", name)
        
    change_name2()  # 调用内层函数
    print("第2层打印", name)
change_name()  #先执行局部函数的打印,
print("最外层打印", name)

# 第3层打印 YangJIan3
# 第2层打印 YangJIan2
# 最外层打印 YangJIan

注:多层函数嵌套,子级函数,只在子级函数内部生效。父级函数能调用子级函数的功能

1.4递归函数

1.在函数内部,可以调用其他函数,如果一个函数在内部调用自身本身,这个函数就是递归函数。

2.在使用递归策越是,必须有一个明确的敌对结束条件,称为递归出口

函数调用的时候,每次调用时要做地址保存,参数传递等。

如果函数包含了对其自身函数的调用,该函数就是递归。如下

def foo(n):
    #实现阶乘
    if  n == 1:
        return n  # 当满种条件n==1才执行return 操作
    res = n*foo(n-1) #调用自已本身的函数的结果(再判断条件是否满足条件)给res ,
    return res
print(foo(5))
#120

 递归算法所所体现的重复一般有的要求:

1.每次调用在上次规模上都有有所减小:

2.每次递归调用都是有明确条件的。

3.相领两次的重复之间有紧密的联系,前一次要为后一次做准备(通常前一次的输出(返回值结果))就作为后一次的输入;

4.在问题的规模得到满足条件时,而不再进行递归调用。