Python函数

Python函数
一.函数介绍

我们目前为止,已经可以完成一些软件的基本功能了,现在我们自己来实现一个len,但是不能使用len
```
a = "alexdsb"
count = 0
for i in a:
    count += 1
print(count)
```
我们现在实现了一个求长度,我还想让你们求一下列表和元组的长度是不是就要将我们写的内容再次拿过来

我们在求一个字典的长度,也需要将我们写好的内容拿过来使用好像咱们这个程序中好多都是一样的啊,我们能不能把这些代码封装起来,用的时候拿过来就用啊

二.函数定义

def 是python中关键字主要用来定义函数的

len这个是函数的名字

()这个括号是个神奇的东西,咱们后边会详细盘它

冒号是表示咱们这个语句写完了

函数体就是有4个空格的缩进
```
def len():
  a = "alexdsb"
  count = 0
  for i in a:
      count += 1
  print(count)
```
我们来看一下函数的定义在内存空间发生了什么:

是的你没有看错,内存开辟了一个空间,但是里边存放是代码.

这样我就将咱们写的代码封装起来了,我们现在执行一下程序看看它会不会进行求长度,它并没有执行,我们来看看怎么能够执行上呢?

三.函数的调用

使用函数名加小括号就可以调用了写法:函数名() 这个时候函数的函数体会被执行
```
def len():
  a = "alexdsb"
  count = 0
  for i in a:
      count += 1
  print(count)

len()  # 函数的调用
```
当我们调用执行的时候,才会执行func这个空间里的代码,执行的时候在开辟空间,这次是在func里边开辟的空间

现在就实现了求一次长度,我想要多求几次我就只需要
```
len()
len()
len()
```
直接调用定义好的函数就可以了 大家都练习一下

当我们执行完函数后,函数里开辟的空间就销毁了,我们如果想用函数里的值就需要从函数中传递出来

四. 函数的返回值

我们现在换一下例子,都是男同胞大家都有哪方面的想法,就需要使用交友社交软件,我们现在来模拟一下使用社交软件的流程吧
```
 def yue():
    print("掏出手机")
    print("打开默默")
    print("约一个妹子")  
yue()
```
咱们约完之后的得有个结果吧, 比如约的是萝莉小姐姐,还是大妈啊总得有个结果,那么这个结果

怎么来描述和获得呢? 这就涉及到函数的返回值啦

执行完函数之后,我们可以使用return来返回结果
```
def yue():
    print("约你")
    print("约我")
    print("约他")
    return   
yue()
```
返回的是什么结果,返回的东西给谁了?? 返回值返回给了函数调用者 yue()就是函数的调用者那就是返回给它了,我们来看看返回的什么
```
def yue():
    print("约你")
    print("约我")
    print("约他")
    return   
ret = yue()
print(ret)
```
返回的结果是None,想想我们有的时候操作列表的方法打印的结果就是None,我们所有用的字符串,列表的方法都是函数.

函数中遇到return,此函数就立马结束了.不在继续执行
```
def yue():
    print("约你")
    print("约我")
    print("约他")
    return
      print("大家一起约")
yue()
```
我们现在给return后边写一个返回值,我们试试返回个东西
```
def yue():
    print("约你")
    print("约我")
    print("约他")
    return  "美女一枚"   
yue()
```
我们现在返回了一个字符串,我们来看一下
```
def yue():
    print("约你")
    print("约我")
    print("约他")
    return '美女一枚'
girl =  yue()
print(girl)

结果:
约你
约我
约他
美女一枚
```
肯定好多朋友还是不明白上边怎么就打印美女一枚了,莫慌看下图:
```
1.定义了一个函数yue
2.调用函数
3.执行函数里的约你
4.执行函数里的约我
5.执行函数里的约他
6.返回给调用者一个字符串,这个调用者就是yue()
7.将返回的字符串通过一个等号赋值给白变量girl
8.打印变量girl的值
```
函数的返回值可以有多个结果:
```
def yue():   
    print("约你")   
    print("约我")   
    print("约他")   
    return "美女一枚", "萝莉一枚"
girl = yue()
print(type(girl))   # tuple
```
当函数的返回值是多个的时候,返回的就是一个元组

4.1 总结

　　1.遇到return,此函数结束,return下面的代码将不会在执行

　　2.return 返回值

　　　　关于返回值:

　　　　　　如果return什么都不写或者干脆就没写return,返回的结果就是None

　　　　　　如果return后面写了一个值,返回给调用者这个值

　　　　　　如果return后面写了多个结果,返回给调用者一个tuple(元祖),调用者可以直接使用解构获取多个变量

OK,完美可以得到结果了但是我们约的方式是不是有点问题啊?陌陌现在还能约到吗?约不到了我们换探探那要是过几天探探也不行了

是不是会有一个新的替代品,那你们想有一个替代的,你就需要去改代码.是不是有点不合适了最好的方式是想用什么约就用什么约 ok 我们也是可以实现的 ,我们就要在函数后边的括号里搞点事情了.

五.函数的参数

参数,也就是函数括号里的内容函数在调用的时候指定一个具体的变量的值就是参数.写法如下:
```
def 函数名(参数):

    函数体
```
我们应该把代码改一下,能够实现我刚说的那种效果
```
def yue(chat):

    print("拿出⼿手机")

    print("打开"+chat)

    print("找个漂亮的妹⼦子")

    print("约不约")



yue("陌陌")
yue("微信")
yue("探探")

结果:
拿出手机
打开陌陌
找个漂亮的妹⼦
约不约


拿出⼿机
打开微信
找个漂亮的妹⼦
约不约


拿出手机
打开探探
找个漂亮的妹⼦
约不约　

搞定了. 我们在调用yue的时候给chat一个值. 然后再执行函数体.
```
如果我们再定函数的时候写了形参,在调用函数的时候没有传递值,调用的时候右边括号会发黄,所以我们必须要传递参数,参数要一一对应,不能多不能少.

1.1 参数

　　1.形参

　　　　写在函数声明的位置的变量叫形参,形式上的一个完整.表示这个函数需要xxx

　　2.实参

　　　　在函数调用的时候给函数传递的值.加实参,实际执行的时候给函数传递的信息.表示给函数xxx

　　3.传参

　　　　从调用函数的时候将值传递到定义函数的过程叫做传参
```
def yue(chat):    # chat  形参   

    print("拿出手机")   

    print("打开"+chat)   

    print("找个漂亮的妹子")   

    print("约不约")



yue("陌陌")     # "陌陌"在这里就是实参

len("字符串")    # "字符串"在这里就是实参

print("麻花藤")    # "麻花藤"就是实参
```
1.2 参数的分类

1.2.1 位置参数

　　约到现在,有没有想过这么一个问题,啥样的都约么? 哪里的都约么? 不一定吧.比如我现在在北京,我很寂寞,我喜欢小姐姐

　　alex 在泰国,很寂寞人妖就行了 .需求是不一样的而我们现在的函数没有这些功能那怎么办呢? 很简单多来几个参数就好了
```
def yue(chat,addr,age):    # chat  形参

    print("拿出手机")

    print("打开"+chat)

    print("找个" + addr +"附近漂亮的" + str(age) + "岁妹子")

    print("约不约")



yue("陌陌","北京",18)    # 实参

结果:

拿出手机

打开陌陌

找个北京附近漂亮的18岁妹子

约不约
```
上述代码分析: 在访问yue()的时候,我们按照位置的顺序分别把"陌陌","北京",18赋值给了chat,addr,age,在传参过程中.系统会按照位置把实参赋值到形参.

形参就是一个变量名,实参就是值传参就是在赋值
```
def func(addr,age):
    addr = "北京"
  age = 18      # 从实参到形参的过程中,函数体内部帮我做了变量的赋值
  print(addr)
  print(age)

func("北京",18)
```
练习

编写函数,给函数传递两个参数a,b a,b相加返回a参数和b参数相加的和
```
def f(a,b):
    c = a+b
    return c

num_sum = f(5,8)
print(num_sum)
结果: 13
```
编写函数,给函数传递两个参数a,b 比较a,b的大小返回a,b中最大的那个数
```
def f(a,b):

    if a>b:

        return a

    else:

        return b

num_sum = f(5,8)

print(num_sum)
结果:8
```
比较大小的这个写法有点麻烦,我们在这里学一个三元运算符
```
def f(a,b):

    c = a if a > b else b  #当a>b就把a赋值给c,否则就把b赋值给c

    return c

msg = f(5,7)

print(msg)

结果:

7
```
1.2.2 关键字参数

位置参数好不好呢? 如果是少量的参数还算OK, 没有问题. 但是如果函数在定义的时候参数非常多怎么办? 程序员必须记住, 我有哪些参数, 而且还有记住每个参数的位置, 否则函数就不能正常调用了. 那则么办呢? python提出了一种叫做关键字参数. 我们不需要记住每个参数的位置. 只要记住每个参数的名字就可以了
```
def yue(chat, address, age):

    print("拿出手机")

    print("打开"+chat)

    print("找个"+address+"附近漂亮的"+str(age)+"岁妹子")

    print("约不约")



yue(chat="微信", age=18, address="北京")       # 关键字参数.

结果:

拿出手机

打开微信

找个北京附近漂亮的18岁妹子

约不约
```
搞定, 这样就不需要记住繁琐的参数位置了.

1.2.3 混合参数

可以把上面两种参数混合着使用. 也就是说在调用函数的时候即可以给出位置参数, 也可以指定关键字参数.
```
# 混合参数 
yue("微信", age=18, address="上海")    # 正确.第一个位置赋值给chat, 后面的参数开始指定关键字.

yue(age="18", "微信", address="广州")  # 错误, 最开始使用了关键字参数, 那么后面的 微信的位置就串了, 容易出现混乱
```
注意: 在使用混合参数的时候, 关键字参数必须在位置参数后面

1.2.4 总结

综上: 在实参的⾓角度来看. 分为三种:
1. 位置参数
2. 关键字参数
3. 混合参数, 位置参数必须在关键字参数前面
位置参数:

　　位置参数,按照位置来赋值,到目前为止,我们编写的函数都是这种
```
def yue(chat, address, age):   

    print("拿出手机")   

    print("打开"+chat)   

    print("找个"+address+"附近漂亮的"+str(age)+"岁妹子")   

    print("约不约")
```
默认值参数:

　　在函数声明的时候, 就可以给出函数参数的默认值. 在调用的时候可以给出具体的值, 也可以不给值, 使⽤用默认值. 比如, 我们录入咱们班学生的基本信息. 通过调查发现. 我们班大部分学生都是男生. 这个时候就可以给出⼀一个sex='男'的默认值.
```
def stu_info(name, age, sex='男'):   

    print("录入学生信息")

    print(name, age, sex)   

    print("录入完毕")



stu_info("张强", 18)
```
注意:必须先声明在位置参数,才能声明关键字参数

综上:在形参的角度来看
1. 位置参数
2. 默认值参数(大多数传进来的参数都是一样的, 一般用默认参数
六. 函数参数-动态参数

之前我们说过传参,如果我们在传参数的时候不很清楚有哪些的时候,或者说给一个函数传了很多参数,我们就要写很多,很麻烦怎么办呢,我们可以考虑使用动态参数

形参的第三种:动态参数

首先我们来回顾下位置参数
```
def eat(a,b,c):

    print('我想吃%s%s%s'%(a,b,c))

eat('大米饭','中米饭','小米饭')
```
现在有个问题,你们看我这体型也知道吃的不止这些,数量也没有写,这时我们就要用到动态参数　　

1.1 动态接收位置参数

在参数位置用*表示接受任意参数
```
def eat(*args):

    print('我想吃',args)

eat('大米饭','中米饭','小米饭')  # 收到的结果是一个tuple元祖
```
动态接收参数的时候要注意: 动态参数必须在位置参数后面
```
def eat(*args,a,b):

    print('我想吃',args,a,b)

eat('大米饭','中米饭','小米饭')

结果:

TypeError: eat() missing 2 required keyword-only arguments: 'a' and 'b'
# eat函数在调用的时候发现缺少俩个位置参数没有进行传递
```
通过上述代码发现一个问题就是,我们明明给了多个参数,为什么还会提示参数未传递呢?

原因就是因为这个在搞鬼 *把所有的位置参数都给接受了,所有会报错.我们尝试着把a,b放在的前面试试
```
def eat(a,b,*args):

    print('我想吃',args,a,b)

eat('大米饭','中米饭','小米饭')

结果:

我想吃 ('小米饭',) 大米饭 中米饭
```
动态接收参数的时候要注意:动态参数必须在位置参数后面

那默认值参数呢?
```
def eat(a,b,c='白菜',*args):

    print('我想吃',a,b,c,args)

eat('豆腐','粉条','猪肉','大葱')

结果:

我想吃 豆腐 粉条 猪肉 ('大葱',)  # 我们定义好的白菜没有生效,被猪肉给覆盖了
```
我们发现默认值参数写在动态参数前面,默认值的参数是不会生效的
```
def eat(a,b,*args,c='白菜'):

    print('我想吃',a,b,args,c)

eat('猪肉','粉条','豆腐','大葱')

结果:

我想吃 猪肉 粉条 ('豆腐', '大葱') 白菜  # 这样默认参数就生效了
```
这个时候如果你不给出关键字传参,那么你的默认值是永远都生效的　　

注意: 形参的顺序: 位置参数 , 动态参数 , 默认参数

1.2 动态接收关键字参数

在python中可以动态的位置参数,但是*这种情况只能接收位置参数无法接收关键字参数,在python中使用**来接收动态关键字参数
```
def func(**kwargs):

    print(kwargs)     

func(a=1, b=2, c=3)

结果:

{'a': 1, 'b': 2, 'c': 3}
```
动态关键字参数最后获取的是一个dict字典形式　　

顺序的问题, 在函数调用的时候, 如果先给出关键字参数, 则整个参数列表会报错.
```
def func(a,b,c,d):

    print(a,b,c,d)

func(1,2,c=3,4)

结果:

  File "D:/python_object/path2/test.py", line 806

    func(1,2,c=3,4)              ^

SyntaxError: positional argument follows keyword argument
```
关键参数必须要放在位置参数后边,由于实参是这个顺序,所以形参接收的时候也是这个顺序.也就是说位置参数必须在关键字参数前面.动态接收关键字参数也要在后面

最终顺序:

　　位置参数 > *args(动态位置参数) > 默认值参数 > **kwargs(动态默认参数)

　　这四种参数可以任意的使用

如果想接收所有的参数:
```
def func(*args,**kwargs):

    print(args,kwargs)

func(1,23,5,a=1,b=6)
```
动态参数还可以这样传参:
```
lst = [1,4,7]

# 方法一

def func(*args):

    print(args)

func(lst[0],lst[1],lst[2])



# 方法二

def func(*args):

    print(args)

func(*lst)  
# 在实参的位置上用*将lst(可迭代对象)按照顺序打散

# 在形参的位置上用*把收到的参数组合成一个元祖
```
字典也可以进行打散,不过需要**
```
dic = {'a':1,'b':2}

def func(**kwargs):

    print(kwargs)

func(**dic)
```
七.名称空间

在python解释器开始执行之后, 就会在内存中开辟一个空间, 每当遇到一个变量的时候, 就把变量名和值之间的关系记录下来, 但是当遇到函数定义的时候, 解释器只是把函数名读入内存, 表示这个函数存在了, 至于函数内部的变量和逻辑, 解释器是不关心的. 也就是说一开始的时候函数只是加载进来, 仅此而已, 只有当函数被调用和访问的时候, 解释器才会根据函数内部声明的变量来进行开辟变量的内部空间. 随着函数执行完毕, 这些函数内部变量占用的空间也会随着函数执行完毕而被清空.
```
def fun():   
    a = 10   
    print(a)
fun()
print(a)    # a不存在了已经..
```
我们给存放名字和值的关系的空间起一个名字叫: 命名空间. 我们的变量在存储的时候就是存储在这片空间中的.

命名空间分类:

1. 全局命名空间--> 我们直接在py文件中, 函数外声明的变量都属于全局命名空间

2. 局部命名空间--> 在函数中声明的变量会放在局部命名空间

3. 内置命名空间--> 存放python解释器为我们提供的名字, list, tuple, str, int这些都是内置命名空间　　

加载顺序:
1. 内置命名空间
2. 全局命名空间
3. 局部命名空间(函数被执行的时候)

取值顺序:

1. 局部命名空间

2. 全局命名空间

3. 内置命名空间
```
a = 10
def func():  
    a = 20   
    print(a)

func()  # 20
```
作用域: 作用域就是作用范围, 按照生效范围来看分为全局作用域和局部作用域

　　全局作用域: 包含内置命名空间和全局命名空间. 在整个文件的任何位置都可以使用(遵循从上到下逐⾏执行).

　　局部作用域: 在函数内部可以使用.

作⽤域命名空间:
1. 全局作用域: 全局命名空间 + 内置命名空间
2. 局部作用域: 局部命名空间
我们可以通过globals()函数来查看全局作⽤用域中的内容,也可以通过locals()来查看局部作⽤用域中的变量量和函数信息
```
a = 10
def func():   
    a = 40   
    b = 20   
    print("哈哈")   
    print(a, b)        
    print(globals())    # 打印全局作用域中的内容   
    print(locals())     # 打印当前作用域中的内容
func()
```
八. 函数的嵌套
1. 只要遇见了()就是函数的调用. 如果没有()就不是函数的调用
2. 函数的执行顺序
```
def fun1():   
    print(111)  
def fun2():   
    print(222)   
    fun1()   
fun2()
print(111)
```
```
def fun2():   
    print(222)   
    def fun3():       
        print(666)   
    print(444)   
    fun3()   
    print(888)
print(33)
fun2()
print(555)
```
九 .gloabal、nonlocal

首先我们写这样一个代码, 首先在全局声明一个变量, 然后再局部调用这个变量, 并改变这个变量的值
```
a = 100
def func():   
    global a    # 加了个global表示不再局部创建这个变量了. 而是直接使用全局的a   
    a = 28   
print(a)
func()
print(a)
```
global表示. 不再使用局部作用域中的内容了. 而改用全局作用域中的变量

2.1global 宗旨

在函数内部修改全局的变量,如果全局中不存在就创建一个变量
```
lst = ["麻花藤", "刘嘉玲", "詹姆斯"]
def func():   
    lst.append("⻢云")   
    # 对于可变数据类型可以直接进⾏访问
　　 print(lst)
func()
print(lst)
```
2.2 nonlocal宗旨

nonlocal 只修改上一层变量,如果上一层中没有变量就往上找一层,只会找到函数的最外层,不会找到全局进行修改
```
a = 10
def func1():   
    a = 20   
    def func2():
        nonlocal a       
        a = 30       
        print(a)  
    func2()   
    print(a)
func1()


结果:
加了nonlocal
30
30

不加nonlocal
30
20
```
再看, 如果嵌套了很多层, 会是一种什么效果:
```
a = 1
def fun_1():   
    a = 2   
    def fun_2():       
        nonlocal a       
        a = 3       
        def fun_3():           
            a = 4           
            print(a)       
        print(a)       
        fun_3()       
        print(a)   
    print(a)   
    fun_2()   
    print(a)
print(a)
fun_1()
print(a)
```
这样的程序如果能分析明白. 那么作用域, global, nonlocal就没问题了

十. 函数名的运用

函数名是一个变量, 但它是一个特殊的变量, 与括号配合可以执行函数的变量

1.1.函数名的内存地址
```
def func():   
    print("呵呵")
print(func)

结果: <function func at 0x1101e4ea0>
```
1.2 函数名可以赋值给其他变量
```
def func():   
    print("呵呵")
    print(func)
a = func    # 把函数当成一个值赋值给另一个变量

a()     # 函数调用 func()
```
1.3. 函数名可以当做容器类的元素
```
def func1():   
    print("呵呵")
def func2():   
    print("呵呵")
def func3():   
    print("呵呵")
def func4():  
     print("呵呵")

lst = [func1, func2, func3]
for i in lst:  
     i()
```
1.4.函数名可以当做函数的参数
```
def func():   
    print("吃了么")
def func2(fn):   
    print("我是func2")   
    fn()    # 执行传递过来的fn   
    print("我是func2")
func2(func)     # 把函数func当成参数传递给func2的参数fn.
```
1.5. 函数名可以作为函数的返回值
```
def func_1():   
    print("这里是函数1")   
    def func_2():       
        print("这里是函数2")   
    print("这里是函数1")   
    return func_2
fn = func_1()  
# 执行函数1.  函数1返回的是函数2, 这时fn指向的就是上面函数2
fn()    # 执行func_2函数
```
十一.f-strings字符串格式化

f-strings 是python3.6开始加入标准库的格式化输出新的写法，这个格式化输出比之前的%s 或者 format 效率高并且更加简化，非常的好用，相信我，你们学完这个之后，以后再用格式化输出这就是你们唯一的选择。

2.1 简单举例

他的结构就是F(f)+ str的形式，在字符串中想替换的位置用{}展位，与format类似，但是用在字符串后面写入替换的内容，而他可以直接识别。碉堡了。
```
name = '宝元'
age = 18
sex = '男'
msg = F'姓名：{name},性别：{age}，年龄：{sex}'  # 大写字母也可以
msg = f'姓名：{name},性别：{age}，年龄：{sex}'  
print(msg)
'''
输出结果：
姓名：宝元,性别：18，年龄：男
'''
```
2.2 任意表达式

他可以加任意的表达式，非常方便：
```
print(f'{3*21}')  # 63

name = 'barry'
print(f"全部大写：{name.upper()}")  # 全部大写：BARRY

# 字典也可以
teacher = {'name': '宝元', 'age': 18}
msg = f"The teacher is {teacher['name']}, aged {teacher['age']}"
print(msg)  # The comedian is 宝元, aged 18

# 列表也行
l1 = ['宝元', 18]
msg = f'姓名：{l1[0]},年龄：{l1[1]}.'
print(msg)  # 姓名：宝元,年龄：18.
```
2.3 也可以插入表达式

可以用函数完成相应的功能，然后将返回值返回到字符串相应的位置
```
def sum_a_b(a,b):
    return a + b
a = 1
b = 2
print('求和的结果为' + f'{sum_a_b(a,b)}')
```
2.4 多行f
```
xname = 'barry'
age = 18
ajd = 'handsome'

# speaker = f'''Hi {name}.
# You are {age} years old.
# You are a {ajd} guy!'''

speaker = f'Hi {name}.'
          f'You are {age} years old.'
          f'You are a {ajd} guy!'
print(speaker)
```
2.5 其他细节
```
print(f"{{73}}")  # {73}
print(f"{{{73}}}")  # {73}
print(f"{{{{73}}}}")  # {{73}}
m = 21
# ! , : { } ;这些标点不能出现在{} 这里面。
# print(f'{;12}')  # 报错
# 所以使用lambda 表达式会出现一些问题。
# 解决方式：可将lambda嵌套在圆括号里面解决此问题。
x = 5
print(f'{(lambda x: x*2) (x)}')  # 10
```
相关阅读:
kafka学习默认端口号9092
kafka搜索介绍
 进程线程区别
 linux下的mysql修改默认编码
 [LeetCode] #19 Remove Nth Node From End of List
[LeetCode] #18 4Sum
[LeetCode] #17 Letter Combinations of a Phone Number
[LeetCode] #16 3Sum Closest
编程之美2015 #1 2月29日
 编程之美2015 #2 回文字符序列
原文地址：https://www.cnblogs.com/lyoko1996/p/11005040.html

一.函数介绍

二.函数定义

三.函数的调用

四. 函数的返回值

4.1 总结

五.函数的参数

1.1 参数

1.2 参数的分类

1.2.1 位置参数

1.2.2 关键字参数

1.2.3 混合参数

1.2.4 总结

六. 函数参数-动态参数

1.1 动态接收位置参数

1.2 动态接收关键字参数

七.名称空间

八. 函数的嵌套

九 .gloabal、nonlocal

2.1global 宗旨

2.2 nonlocal宗旨

十. 函数名的运用

1.1.函数名的内存地址

1.2 函数名可以赋值给其他变量

1.3. 函数名可以当做容器类的元素

1.4.函数名可以当做函数的参数

1.5. 函数名可以作为函数的返回值

十一.f-strings字符串格式化

2.1 简单举例

2.2 任意表达式

2.3 也可以插入表达式

2.4 多行f

2.5 其他细节