函数

一.什么是函数

　　函数:对功能或动作的封装

二.函数的定义与函数的调用

　　函数的定义:

　　　　　　def　　函数名():

　　　　　　　　函数体

　　随便写一个:

1  def yue():     
2     print("拿出手机")         
3     print("打开陌陌")     
4     print("找个漂亮的妹子")
5     print("问她, 约不?!!")
6     print("ok,走")

View Code

　　函数的调用:

　　　　函数名()

 1 def yue():
 2     print("拿出手机")
 3     print("打开陌陌")
 4     print("找个漂亮的妹子")
 5     print("问她, 约不?!!")
 6     print("ok,走")
 7 
 8 
 9 
10 yue()      #调用

View Code

三.函数的返回值

当函数执行完的时候,可以给调用者一个返回值(return)

1.函数中遇到return,函数本次调用停止,不会继续执行

1 def yue():
2  print("约你")
3  print("约我")
4  print("约他")
5  return
6  print("约谁呀") # 这句话不会被执⾏
7 yue()

View Code

2.给函数调用者一个返回值

1 def yue():
2      print("约你")
3      print("约我")
4      print("约他")
5      return "美⼥⼀枚"
6 
7 girl = yue()
8 print(girl) # 美⼥⼀枚

View Code

给函数调用者多个返回值

1 def yue():
2      print("约你")
3      print("约我")
4      print("约他")
5      return "美⼥⼀枚", "萝莉⼀枚"
6 
7 
8 girl = yue()
9 print(type(girl)) # tuple

View Code

总结:

　　1.return在哪里出现,函数本次调用停止

　　2.return 返回值,这个函数调用之后会得到一个结果

　　　　当函数有返回值的时候,我们可以不接受返回值

　　　　在函数中如果写return,但是return后面不跟值,表示函数没有返回值,接收到的是None

　　　　在函数中如果不写return表示函数没有返回值,调用方接收到的是None

　　　　在函数中写return,return后面跟一个值

　　　　在函数中写return,return后面可以跟多个值,表示返回多个值,接收到的是元组(为了是不可变)

 1 当函数执行之后。可以给调用者一个返回值
 2 def yue(): # 参数
 3     print("拿出手机")
 4     print("打开陌陌")
 5     print("找一找心怡的对方.")
 6     print("出来吃吃饭")
 7     print("唱唱歌")
 8     print("跳跳广场舞")
 9     return "小姐姐", "小护士", "广场舞大妈"
10     # return "小姐姐"  # return表示返回。 这个函数在调用之后会得到一个结果
11 ret = yue() # 当函数有返回值的时候。 我们可以不接受返回值
12 print(ret)

View Code

四.参数位置

参数:

　　函数在调用的时候,给函数传递的信息

形参:

　　在函数声明的位置的变量

实参:

　　在函数调用的地方给出具体的值的参数叫实参,实际参数

传参:

　　把实参赋值给形参的过程叫传参

1 # 形参
2 def yue(tools): # 在函数声明的位置。 给出来的参数叫形参。 形式上的一个参数. 用一个变量来表是
3     print("拿出手机")
4     print("打开%s" % tools)
5     print("找一找心怡的对方.")
6     print("出来吃吃饭")
7     print("唱唱歌")
8     print("跳跳广场舞")

View Code

1 # 实参
2 # 在函数调用的时候。把实参的值赋值给形参的过程叫传参
3 # yue("微信") # 在函数调用的地方给出的具体的值。 参数叫实参. 实际参数
4 # yue("陌陌")
5 # yue("探探")

View Code

1 def chi(good_food, no_good_food, drink):
2     print("我要吃", good_food, no_good_food, drink)
3 
4 
5 chi("大米饭", "冰峰", "炸鸡")
6 chi(drink="哇哈哈", no_good_food="薯条", good_food="盖浇饭")
7 chi("小米饭", "辣条", drink="可乐")
8 chi(drink="可乐", "小米饭", "辣条")

View Code

1 def regist(name, age=18,sex="男"):
2     print(name, age, sex)
3 
4 regist("刘伟", 22)
5 regist("李铁帅", 27)
6 regist("高晓燕", 18, "女")

View Code

实参的分类:

　　1.位置参数　　按照位置给形参传递信息

　　2.关键字参数　　按照形参的名字给参数赋值

　　3.混合参数　　按照先位置参数,后关键字参数

形参的分类:

　　1.位置参数　　按照位置来声明形参

　　2.默认值参数　　　当给参数传递值的时候,默认值不起作用,不给值.默认值起作用,保证你至少有个值能用

　　3.动态传参　　

　　　　　　*args 　　动态接收位置参数(接收到的是元组)

　　　　　　**kwargs　　动态接受关键字参数(接收到是字典)

4.顺序:　　位置参数==>*args==>默认值参数==>**kwargs

# def chi(*food):  # * 表示的是不定参数. 可以传递任意个信息 参数名是food, 接受到的是元组
#     print("我要吃", food)
#
# chi("一锅大米饭", "一箱辣条", "一桶方便面", "4L可乐")
# chi("方便面")
# chi("一大锅米饭", "一小锅小米饭", "一箱辣条", "一桶方便面", "4L可乐")

View Code

 1 # def func(**kwargs):  # key word arguments
 2 #     print(kwargs)
 3 #
 4 #
 5 # func(a=10, b=20, jay="周杰伦", jj="林俊杰")
 6 #
 7 # 无敌模式.所有的参数都能接收
 8 # def func(*args, **kwargs):
 9 #     print(args)
10 #     print(kwargs)
11 #
12 #
13 # func(1, 2, 5, jj="陶喆", jay="zhoujielun", soup="胡辣汤")
14 #
15 #
16 # def func(*args):  # 在这里. 其实相当于把传进来的参数做了一次聚合, 聚合成一个元组
17 #     print(args)
18 #
19 #
20 # lst = "娃哈哈"
21 # func(*lst)  # 在实参位置 * 表示打散, 打散的是可迭代对象
22 #
23 #
24 # def func(**kwargs):  # ** 把接收到的关键字参数打包(聚合)成字典
25 #     print(kwargs)  # 一定是字典
26 #
27 #
28 # dic = {"张无忌": "明教教主", "谢逊": "金毛狮王", "范瑶": "光明右使"}
29 #
30 # # func(张无忌=dic['张无忌'], 谢逊=dic['谢逊'], 范瑶=dic['范瑶'])
31 # func(**dic)  # 这里的** 是把字典打散. 字典的key作为参数的名字, 字典的值作为参数的值传递给形参

View Code

# def func(a, b, *args, c=5):  # arguments参数
#     print(a, b, c, args)
#
#
# func(1, 2, 3, 4, 5, 6, 8, c=10)

View Code

无敌模式:

　　def func(*arge,**kwarge):

　　　　pass　　

　　func(位置==>关键字)

*的表示

　　在实参上,* **,表示打散.

　　在形参上,* **,表示聚合

五.命名空间

1 # 最开始会开辟一个自己的命名空间- 内置名称空间
2 # a = 10
3 # print(a)
4 # # 直接在py文件一个层面上是全局名称空间
5 # def func():
6 #     hasakey = 10
7 # # 在函数内部属于局部名称空间
8 # func()

View Code

加载顺序:内置名称空间==>全局名称空间==>局部名称空间

取值顺序:局部名称空间==>全局名称空间==>内置名称空间

1 # a = 10 # 全局
2 # def func():
3 #     # a = 20
4 #     print(a)
5 #
6 # func()

View Code

作用域:变量或者函数的声明周期

全局作用域:全局名称空间 + 内置名称空间

局部作用域:余部名称空间

globals() 查看全局作用域中的内容

locals() 查看当前作用域中的内容

 1 # a = 10 # 全局
 2 # def func():
 3 #     liuwei = "刘伟"
 4 
 5 # 1. globals() 查看全局作用域中的所有内容
 6 # qiao = "乔峰"
 7 # def 抗收音机():
 8 #     bgm = "难念的经"
 9 #     print("娃哈哈")f
10 #     print(locals())
11 # 抗收音机()
12 
13 # # print(globals()) # 查看全局作用域中的内容
14 # # print(locals()) # locals()查看的是当前作用域中的内容

View Code

global: 在局部引入全局变量

nonlocal: 在局部, 引入离他最近的那一层的变量

六.函数的嵌套

  1 # def func1():
  2 #     print("我是func1")
  3 # 
  4 # 
  5 # def func2():
  6 #     print("我是func2")
  7 #     func1()
  8 # 
  9 # 
 10 # def func3():
 11 #     func2()
 12 #     print("我是func3")
 13 # 
 14 # 
 15 # func3()
 16 # 这样的代码不是嵌套.互相调用
 17 # 
 18 # 函数可以互相嵌套
 19 # 
 20 # 
 21 # def outer():
 22 #     def inner():
 23 #         print("我是内部")
 24 # 
 25 #     print("我是外部")
 26 #     inner()
 27 # 
 28 # 
 29 # outer()
 30 # 
 31 # 
 32 # def outer():
 33 #     print("我是外面的")
 34 # 
 35 #     def inner_1():
 36 #         def inner_2():
 37 #             print("我是里面的2")
 38 # 
 39 #         inner_2()
 40 #         print("我是里面的1")
 41 # 
 42 #     inner_1()
 43 #     print("我是外面的收尾")
 44 # 
 45 # 
 46 # outer()
 47 # 
 48 # a = 10
 49 # 
 50 # 
 51 # def func():
 52 #     global a  # 表示在当前作用域中的使用的a是全局中的变量
 53 #     a = 20  # 所有的a都是外面的了
 54 #     print(a)  # 现在只有看的权利
 55 # 
 56 # 
 57 # print(a)  # 10
 58 # func()  # 20
 59 # print(a)  # 20
 60 # 
 61 # 
 62 # def outer():
 63 #     a = 10
 64 # 
 65 #     def inner():
 66 #         nonlocal a  # 找的是局部当中, 离他最近的上层的那个变量
 67 #         a = 20
 68 #         print(a)
 69 # 
 70 #     print(a)  # 10
 71 #     inner()  # 20
 72 #     print(a)  # 20
 73 # 
 74 # 
 75 # outer()
 76 # 
 77 # a = 1
 78 # 
 79 # 
 80 # def fun_1():
 81 #     a = 2
 82 # 
 83 #     def fun_2():
 84 #         nonlocal a
 85 #         a = 3
 86 # 
 87 #         def fun_3():
 88 #             a = 4
 89 #             print(a)
 90 # 
 91 #         print(a)
 92 #         fun_3()
 93 #         print(a)
 94 # 
 95 #     print(a)
 96 #     fun_2()
 97 #     print(a)
 98 # 
 99 # 
100 # print(a)
101 # fun_1()
102 # print(a)
103 # 
104 # global 引入全局变量, 可以定义全局变量
105 # nonlocal 引入局部中离他最近的外层变量
106 # 
107 # 
108 # def func():
109 #     global a  # 没有也得有. 自动帮你创建
110 #     a = 20
111 # 
112 # 
113 # func()
114 # print(a)

View Code

这样的程序如果能分析明白,那么作用域,global,nanlocal就没问题了