函数Day05

函数

一 什么是函数？

函数是实现一些特定的小方法 或者是 小程序

优点：

1. 增加了代码的重复使用率
2. 减少了了代码量
3. 提高了代码的维护

二 函数的定义

 def   函数名([参数1,[参数2]]):
    函数体

函数名 参照 你的 变量的命名方式

三 函数的调用

函数名([参数1,[参数2]])

实例：

#定义函数
def demo():
    print("我是demo函数")

#调用函数
demo()

注意：

1. 函数名区分大小写
2. 函数名可以重复 但是会被覆盖
3. 函数的调用不能放在该函数的上方调用

四 函数的参数问题

(一) 形参

​ 在函数定义的时候 写在函数括号里的变量名 称为 形参

#此刻的 x和y  称为 形参 且没有默认值  在调用的时候 必须传实参
def demo(x,y):
    print(x,y)
demo(10,20)  #10,20称为 实参 也就是真正起作用的参数  形参和实参的值 默认是 一一对应上的

#此刻的 x和y  称为 形参 且有默认值  在调用的时候 可以不传实参
def demo(x=1,y=2):
    print(x,y)
demo() 

注意：

1. 当我的函数在定义的时候 有形参 且没有默认值的情况下 必须有实参(实际的参数)

2. 实参 也就是真正起作用的参数 形参和实参的值 默认是 一一对应上的

3. 实参的个数不能够大于我形参的个数

4. 当函数有形参 且有默认值的情况下 可以不传实参

5. 函数有形参 且 有默认值 传实参和不传实参的情况

   • 不传实参
     
     • 形参的值为 默认值
   • 传实参
     
     • 形参的值为实参的值 一一对应

6. 形参的默认值 必须放在后面 否则会报语法错误

7. 实参的值 可以通过 形参名 来指定穿参 但是 所有实参传参的时候 都必须 有指定 形参名 否则为 语法错误

   def add(x,y,z=1):
      print('x的值为',x)
      print('y的值为',y)
      print('z的值为',z)
   
   #形参名 等于 实参的值
   
   add(y=10,x=20,z=100)  #通过形参的关键字 来传实参
   
   #add(y=10,x=20,100)    #错误的写法 语法错误
   

(二) Return 函数的返回值

(1) 没有return的函数

返回值为None

(2) return 会将返回值 返回给调用处 你可以将这个值 输出 可以在进行其它的操作

如:

def sum(n=1,m=100):
    mySum = 0
    for i in range(n,m+1):
        mySum+=i
    # print(mySum)  #直接输出
    return mySum   #将值返回给调用处
sum()  #此刻sum()的值为  函数内部的mySum的值 

(3) return 返回多个值

以列表 或者元组 或者字符串 或者字典 都可以返回多个值

def add():
    # return x+y
    x = 10
    y = 20
    z = 30
    # return [x,y,z]  #返回一个列表 多个值
    # return x+y+z  #返回一个表达式
    # return x,y,z  #返回一个元组  多个值
# print(add())

(4) 当函数体执行的时候 遇到了 return 就意味着 函数执行完毕 return 下面的代码 将不会再执行

(三) 不定长参数

说明：也就是传入的参数的个数 不确定

(1) *参数名 来接收实参的参数 接收的值为元组类型

语法格式：

​ def 函数名(*形参名):

def mySum(*args):
    # print(bool(args)) #如果为空元组 那么为bool的False  否则为真
    # print(args)
    #求 不定长实参的 参数和
    sum = 0
    for i in args:
        sum+=i
    print(sum)
mySum(10,20,2,3,4,4)

(2) 不定长参数 和普通形参的组合

def mySum(x,y,*args):
    print(x)    #'a'
    print(y)    #'b'
    print(args) #(2,3,4,5)
# mySum('a','b',2,3,4,5)

(3) **args 关键字的不定长参数

def demo(**args):
    print(type(args))  #dict
    print(args) #{'name': '张三', 'age': 18, 'sex': '男'}
demo(name='张三',age=18,sex='男')

(4) 和*参数的函数

def demo(*tup,**args):
    print(type(args))
    print(type(tup))
    print(args)
    print(tup)
demo(1,2,3,4,5,name='张三',age=18,sex='男')

五 变量的作用域

(1) 在函数外部所定义的变量 称为 全局变量 在函数的内外都可以获取到

name = "全局变量name"
def demo():
    print(name)  #可以获取到name的值
demo()

(2) 在函数内部声明的变量 为局部 变量 在函数外部获取不到

name = "全局变量name"
def demo():
    name = "新的值"
    print(name)  #"新的值"
demo()
print(name) #"全局变量name"

(3) 关键字 global 将函数外部的全局变量 声明内外使用同一个

name = "我是全局的变量name"

def demo():
    global name
    print("在函数内部修改之前的name",name)
    name = "张三"
    print("在函数内部修改以后的值为：",name)

print("在函数调用之前的name",name)
demo()
print("在函数调用之后的name",name)

(4) 关键字 nonlocal

说明： 当函数发生嵌套的时候 使用 nonlocal 会将函数外层的变量 声明内外都使用同一个

num = 30000
def func1():
    num = 10
    def func2():
        # global num  #30000
        nonlocal num  #此刻 函数func2 的num 和func1的num 为同一个 num
        num = 20
        print(num)
    func2()
    print(num)

func1()
print(num)

注意：

在函数的内部可以获取 函数外部的全局变量 但是不能进行修改 如果修改的话 那么就会在 函数的内部 创建一个 同名的局部变量

六 匿名函数

关键字 lambda

注意：

1. lambda只是一个表达式 函数体 比 def简单很多
2. 只能实现有限的功能

实例：

func = lambda a,b:a+b
func(10,20)

简写：

#简写
#print((lambda a,b:a+b)(10,20))

七 导入包的方式

import 包名 直接将整个包导入进来

使用： 包名.函数名()

from 库名 import 包名

从 一个库里面(文件夹) 导入一个装着函数的 包(文件)

from 库名.包名 import 函数名 只导入 一个函数

使用：函数名()

from 包名 import 函数名 从一个包里 导入 特定的某个函数

使用：函数名()

import 包名 as 新名 给当前可能名字 比较长的包 起一个 简短的别名

import func as f

f.函数名()