PYTHON 函数基础

函数

函数基础

一、认识函数

函数：函数是带名字的代码块，用于完成具体的工作。

二、分类

自定义函数：程序员自己写的函数，可以根据需求去创建函数。

内置函数：python系统自带的函数，程序员在开发过程中直接接调用就可以。

系统函数：系统自带，系统自己使用。

二 如何去定义函数

语法格式

函数的定义：将这些具有特定功能的代码块封装打包，需要使用的时候调用即可。
如何创建函数：
def 函数名(形参)：
	'''文档说明'''
	代码块
	return

函数名(实参)

函数的参数：形参--实参。
	位置参数：形参和实参的位置要一一对应，数量相同。一个萝卜一个坑。
	默认值参数：创建函数的时候，给参数写默认值
	关键字参数：调用函数的时候，参数 = 实参(位置顺序可以不等，数量还是要相等。)

return：根据自己的需求去返回结果给函数。
return后面的代码都不会再执行。
	一个函数里面只能有一个return
	一个return可以返回多个值。 return a,b,a+b
	return要写在循环外面，直接返回循环最终的结果。
如果函数里面没有return 调用的时候使用print打印结果会出现none

1.文档说明：用于函数功说明

2.函数命名遵循变量命名规则

3.函数要先创建再调用。

def max_1():
    ''' 这是一个求最大值的函数 '''
    ls = [12,3,1,45,21]
    a = ls[0]
    for i in ls:
        if i>a:
            a = i
    print(a)

max_1()

定义空函数

​ 使用pass占位

def min_1():
    pass
min_1()

(一) 函数参数

1什么是参数？

参数：参数—参变量—在一定程度上可以理解成变量

作用：传递数据/存储数据。

形参：创建（定义）函数的时候括号里面的参数就是形参，此时只是变量，用来接收外部的值。

实参：在调用函数的时候，函数名括号里面的参数，有实际的值。

歌手：形参

具体人物：实参

def func(形参)：
	函数体
	
#调用函数的时候
func(实参)

def concert(singer,day):
    print(f'{singer}的演唱会{day}，你去吗')

concert('A','8月20日')
concert('B','9月20日')
concert('C','10月20日')

1.1位置参数（必须参数）

1在使用多个参数进行传递的时候必须注意参数的数量和位置，形参和实参必须一个萝卜一个坑，一一对应。

def concert(singer,day):
    print(f'{singer}的演唱会{day}开，你去吗')

# concert('周杰伦','9月20号')
# concert('8月20号','林宥嘉')

1.2 默认参数

在函数定义的时候，就已经把参数的值定义好了。后期调用函数的时候，可以不用传参数，也会有值，如果传参数的话他就会把这个参数更新。

def info(name,age,like = '绘画'):
    print('''
    ---------------------
    姓名：{}
    年龄：{}
    爱好：{}
    '''.format(name,age,like))

info('luo',18)
#创建函数的时候就设置好了参数的值
info('luo',18,'听歌')
#给默认值参数传参之后，就会更新这个值，其他的参数要遵循位置参数的原则。

1.3 关键字参数

1在传递参数的时候，使用产生的关键字进行传递（参数名 = 参数值）

2关键字参数传递时可以不用位置对应，数量要对应

3当关键字产生与非关键字参数一起使用的时候，应该先写非关键字参数。先写的非关键字参数要遵循位置参数的原则。

def info(name,age,heigh,like):
    print('''
    ---------------------
    姓名：{}
    年龄：{}
    身高：{}
    爱好：{}
    '''.format(name,age,heigh,like))

info(name='luo',age=18,heigh=180,like='音乐')

# 使用 （关键字 = 值）
info(heigh=180,like='音乐',name='luo',age=18)
# 关键字参数传递时可以不用位置对应
info(heigh=180,like='音乐')
#数量要对应
info('luo',18,like='音乐',heigh=180)
#info(like='音乐',heigh=180,'luo',18,) 错误示范。
#当关键字产生与非关键字参数一起使用的时候，应该先写非关键字参数。先写的非关键字参数要遵循位置参数的原则。

1.4可变参数（不定长参数）

可变参数：一个形参可以接收多个参数值。

1.4.1单星号可变参数

1. *args，可以接收多个参数值，也可以没有参数值。

2. 接收的参数值，保存到了元组中。

 def num(*args):
     s = args
     print(s)
     print(type(args))
 
 num(1,2,4)
 num(1,2,4,3)
 num()
 --------------------------
 def max_auto(*args):
     data = [*args]
     max_val =data[0]
     for val in data:
         if val > max_val:
             max_val =val
     return max_val
 print(max_auto(1,2,3,4,5))
 print(max(1,2,3,4,5))
 
 def singer(sex,*args):
     print(f'你认识{sex}歌手有{args}')
 
 singer('男',500,'五月天')
 # 当出现可变与不可变参数同时出现时，先一一对应，再保存到元组
 
 def singer(*args,sex):
     print(f'你认识的歌手有{args}那些是{sex}的')
 
 singer('男',500,'五月天')
 #先写不可变再写可变。
 
 def singer(sex,*args):
     print(f'你认识{sex}歌手有{args}')
 
 singer(sex='nan','500')
 #报错

1.4.2双星号可变

1**kwargs,可以接收多个参数值，也可以不接受

2,双星号参数，把值保存到字典里面。

3，传参数的时候，使用 key = value 键对值的形式进行传参

def code(who,**kwargs):
    print(f"各城市的邮政编码如下：{kwargs}，填表人{who}")
    print(type(kwargs))

code('luo')
code('luo',cs=410000,bj=100000,sh=200000,gz=510000)

(二) 函数返回值

在定义函数的时候，根据自己的需求把数据作为返回值返回给函数。

根据客户需求生产产品

def func(形参)：
	'''文档说明'''
	代码块
	return 返回值

#调用
func(实参)
def num():
    return 123
print(num())


def num(a,b):
    return a+b,a-b,a,b

print(num(1,2))
#一次可以返回多个值


def num(a,b):
    return a+b
    print(123)

print(num(1,2))
# 函数里面 只能有一个return
# return后面的代码不会再运行

def num(a,b):
    a+=b

print(num(1,2))
#如果函数里没有return使用print就会出现none

def num(n):
    s = 0
    for i in range(n+1):
        s+=i
        # print(s) # 得到的是循环的过程
    # print(s)# 得到的是循环的结果
    #     return s # 的到的是0，因为return后面的代码将不会再执行
    return s
#return 只管结果，拿到最终的结果返回给函数。
print(num(100))

(三) 函数对象

把函数当成变量使用

3.1.函数被引用，把函数赋值给变量，通过变量来执行函数。

def func():
    print('hello word')

# func()
a = func()
print(a)
def func():
    print('hello word')

# func()
a = func  #把函数的功能保存起来了。
print(a)#直接打印函数名是是内存地址。
a() #调用函数。

def func(name):
    print(f'{name}是你的朋友吗')
a = func
a('luo')

3.2把函数作为元素，放到列表，元组，集合，字典中使用。

def func():
    a = input('请输入一个歌手名')
    return a

# ls = ['A','B','C',func()]
# print(ls)
ls1 = ['A','B','C',func]
print(ls1)
print(ls1[3]())
def func():
    a = input('请输入一个歌手名')
    return a

# ls = ['A','B','C',func()]
# print(ls)
ls1 = ['A','B','C']
print(ls1)
ls1.append(func())
print(ls1)
#可以把函数当成元素进行列表的操作
----------------------------------------------

def func():
    a = input('歌手名')
    return a

dic1 = {1:'A',2:'B',3:func()}
print(dic1)
#输出字典的时候得到的是函数的值
dic2 = {1:'A',2:'B',3:func}
print(dic2) # 得到的时候函数的内存地址
print(dic2[3]()) #通过字典的键取值加括号进行函数的调用。

3.3 把函数作为参数传递给另外的函数。

def func():
    a = input('请输入一个歌手名')
    return a

def hello(name):
    print(f'大家好我是{name}')

hello(func())
#把func函数掉用的结果传递给了 hello函数


def func():
    a = input('请输入一个歌手名')
    return a
def hello(name):
    print(f'大家好我是{name()}')
hello(func)
#如果想要得到函数值，就在参数后面加括号，最终也可以调用函数的结果。

#当函数都有参数时
----------------------------------
def add_1(a,b):
    return a+b

def hello(age):
    print(f'大家好，我今年{age}岁')

hello(add_1(10,8))
# 得到函数的值，并把结果传递给hello函数
def add_1(a,b):
    return a+b

#当函数有多个参数时
------------------------------------
def hello(name,age):
    print(f'大家好我是{name}，我今年{age}岁')

hello('luo',add_1(10,8))

3.4把函数作为另一个函数的返回值[嵌套函数]

#没有参数的情况
def func():
    def hello():
        print('你好')
    return hello()
func()
# 把内层函数的结果返回给外层函数
def func():
    def hello():
        print('你好')
    return hello
# 此时 func() = hello
a = func()
a()
----------------------------------
#有参数的情况

def f(x,y):
    def s(a,b):
        print(a+b)
    return s(x,y)

f(1,2)
# 把内层函数当成返回值的时候，参数写外层函数的参数，把外层函数的参数传到了内层函数。

(四) 函数的作用域

4.1 匿名函数

匿名函数：不用def对函数进行定义，没有函数名，通过关键字 lambda

表达的函数。

lambda 参数 ：表达式（返回值）

def add_1(a,b):
    return a+b
print(add_1(1,2))

print((lambda a,b:a+b)(1,2))

res = lambda a,b:a+b

print(res(2,3))

匿名函数的意义：

不用取名，直接作为表达式使用。

4.2 函数作用域

作用域：作用的范围。可以使用的范围。变量的有效范围。有些变量可以在整段代码任意地方使用，有些变量只能在函数内部使用。变量的作用域有变量的定义的位置决定。在不同的位置定义的变量作用域不同

全局：（顶个对齐）整篇代码里面都可以调用，基础数据类型（int，str，float，bool）的变量不能在局部修改

局部：（有缩进）不能在全局内使用和修改。
在访问变量的时候，先查找本地变量，局部变量，--全局变量，最后是内置变量。

4.21 global关键字

举例子：

​ 全局变量：（公家的）私人只能使用，不能修改。

​ 局部变量：（私人的）只有自己能用。不能公有。

1 全局变量在局部只能调用不能修改
num = 10 #全局变量
def func():
    print(num)#此时可以调用
    num+=1 #此时不能修改
func()

#使用global获取全局变量的修改权
----------------------------------
num = 10 #全局变量
def func():
    global num
    print(num)#此时可以调用
    num+=1 #此时不能修改
    print(num)
func()

#全局不能修改局部变量
-------------------------------------------
def func():
    num = 10 #局部变量
    print(num)
func()

num+=1 #此时 全局不能修改局部变量
print(num)


---------------------------------
#使用global上交修改权，写在函数里面
def func():
    global num
    num = 10 #局部变量
    print(num)
func()

# global num #错误写法
num+=1 #此时 全局不能修改局部变量
print(num)

4.2.2 nonlocal关键

# 局部变量可以在再局部调用，但是不能修改
def func():
    a = 10 #局部变量
    def hello():
        print(a)
        a+=1
        print(a)
    return hello()
func()

# 使用nonlocal让局部变量再局部化
def func():
    a = 10 #局部变量
    def hello():
        nonlocal a
        a+=1
        print(a)
    return hello()
func()
# 局部变量可以在再局部调用，但是不能修改

(五) 命名空间

python中使用命名空间记录变量的轨迹，命名空间相当于是一个字典，键–变量名，值–变量值

命名空间：存放变量/函数名的地方

python中命名空间分三种：

1.内置命名空间：启动python解释器，就会自动产生对应的命名空间，里面存放的就是python自带的关键字、内置函数，内置模块。关闭python解释器，内置命名空间随之消失。

2.全局命名空间：最外层函数名，变量名的保存空间。当python文件执行的时候产生，执行完之后就关闭。

3.局部命名空间：函数内部变量，内层函数函数名，保存空间，调用函数的时候就会产生，函数执行完毕就会销毁。

加载顺序：解释器–文件–运行函数

查询顺序：先看函数里面–再找全局—再看内置。