Python学习（七）——函数

函数简介 function

input()、print()、range()、len()都是python的内置函数，可以直接使用的。
函数可以用来保存代码，在需要的时候，可对这些语句进行重复调用。
优点：

1. 遇到重复功能的时候，直接调用即可，减少代码量。
2. 提升代码，项目的结构性，分工明确，提高代码可读性。
3. 遇到扩展功能的时候，修改比较方便。
   函数的本质就是一段有特定功能、可以重复使用的代码。

def my_len(str):
    lenght = 0
    for i in str:
        lenght += 1
    return lenght

lenght = my_len("https://www.csdn.net/")
print(lenght)
# 结果：21

函数的定义

语法：

def 函数名(形参1,形参2....形参n):
	代码块

# eg:
def fn():
    print("Num1")

函数的调用

语法：函数对象()

def fn():
    print("Num1")
 
fn()
fn()
 
# 结果：Num1
#		Num1

def fn():
    print("Num1")
    print("hi")
    print("Jim")
 
fn()
 
# 结果：Num1
#		hi
#		Jim

函数的参数

形参和实参

函数的参数：在定义函数时，在函数名后()中定义数量不等的形参，注意可以没有也可以有一个或多个，多个形参之间用逗号隔开。

形参(形式参数)：定义形参就相当于在函数内部声明了变量，但是并不赋值。

实参(实际参数)：在函数定义时指定了形参，在调用的时候也必须传递实参，实参会赋值给对应的形参。

# 定义函数时指定形参a,b
def fn(a,b):
    print("a=",a)
    print("b=",b)
# 调用函数时，来传递实参
fn(10,20)
# 结果：a= 10
#		b= 20

# 求两个数的和
def sum1(a,b):
    print(a,"+",b,"=",a+b)
 
sum1(11,22)
# 结果：11 + 22 = 33

def fn(a):
    print("a=",a)
a = 123
fn(a)  # 实参也可以传变量
# 结果：a= 123

实参可以传递任意类型的数据

def fn(a):
    print("a=",a)
b = fn
fn(b)
# 结果：a= <function fn at 0x000001B27BE2F040>

定义函数时叫形参，调用函数时叫实参。定义多少个形参就必须传递多少个实参。

参数的传递方式

默认值参数

def fn(a, b, c=10):
    print("a=", a)
    print("b=", b)
    print("c=", c)
fn(1,2,3)
# 结果：a= 1
#		b= 2
#		c= 3
  
def fn(a, b, c=10):
    print("a=", a)
    print("b=", b)
    print("c=", c)
fn(1,2)
# 结果：a= 1
#		b= 2
#		c= 10

位置参数和关键字参数

位置字参数：按照形参定义的顺序来传递。
关键字参数：可以不按照形参定义的顺序来传递，而是直接根据参数名来传递参数。

def fn(a, b, c):
    print("a=", a)
    print("b=", b)
    print("c=", c)
fn(b=1,c=3,a=2)
# 结果：a= 2
#		b= 1
#		c= 3
fn(1,2,c=30)  # 1,2是位置参数，c=30是关键字参数
# 结果：a= 1
#		b= 2
#		c= 30

注意：混合使用关键字和位置参数时，位置参数必须在关键字参数的前面。

可变参数

可变参数也可以叫做不定长参数

*args

*args是将所有的实参保存到一个元组中。
命名潜规则是**kwargs。

def fn(*a):
    print(a) 
    print(type(a)) 
fn()
# 结果：()
#		<class 'tuple'>
fn(1, 2, 3)  
# 结果：(1, 2, 3)
#		<class 'tuple'>

eg：任意个数的和

def sum(*a):
    result = 0
    for i in a:
        result+=i
    print(result)
sum(1)
sum(1,2)
sum(1,2,3,4,5)
# 结果：1
#		3
#		15

1. 带星号的形参只能有一个，只能接收位置参数。
2. 带星号的参数可以和其他的参数配合使用，但是要写在最后面。

def fn(a, b, *c):
    print("a=", a)
    print("b=", b)
    print("c=", c)
fn(1, 2, 3, 4, 5)
# 结果：a= 1
#		b= 2
#		c= (3, 4, 5)

def fn(*a, b, c):
    print("a=", a)
    print("b=", b)
    print("c=", c)
fn(1, 2, 3, 4, 5, b=4, c=3)
# 结果：a= (1, 2, 3, 4, 5)
#		b= 4
#		c= 3

**kwargs

**kwargs是将所有的形参保存到一个字典中，字典的键就是参数的名字，字典的值就是参数的值。
形参，也只能有一个，并且必须写在所有参数的最后，命名潜规则是**kwargs。

def fn(**kwargs):
    print("kwargs=", kwargs)
    print(type(kwargs))
fn(a=1, b=2, c=3) 
# 结果：kwargs= {'a': 1, 'b': 2, 'c': 3}
#		<class 'dict'>

*args和**kwargs是可以同时使用的，*args必须要写在**kwargs前面。

def fn(aa, *args, **kwargs):
    print(aa)
    print("args=", args)
    print("kwargs=", kwargs)
    print(type(aa))
    print(type(args))
    print(type(kwargs))
fn(1, 2, 3, 4, 5, 6, a=1, b=2, c=3)
# 结果：1
#		args= (2, 3, 4, 5, 6)
#		kwargs= {'a': 1, 'b': 2, 'c': 3}
#		<class 'int'>
#		<class 'tuple'>
#		<class 'dict'>

参数装包和解包

装包：不定长参数，即把多个参数保存到一个元组或字典中。

传递实参时，可以在序列类型的参数前添加星号，它会自动将序列中的元素依次作为参数传递。
序列中元素的个数必须和我们函数中的形参个数一致。

def fn(a,b,c):
    print("a=",a)
    print("b=",b)
    print("c=",c)
 
t = (1,2,3)
fn(*t)
# 或 fn(*[1,2,3])
# 结果：a= 1
#		b= 2
#		c= 3
d = {"a":1,"b":2,"c":3}  # 字典的key的名字要和形参的名字对上
fn(**d)
# 结果：a= 1
#		b= 2
#		c= 3

*args：接收位置参数；元组类型；把元组中的数据进行拆包，也就是把元组中的数据拆成单个的数据。
**kwagrs：接收关键字参数；字典类型；把字典中的数据进行拆包，也就是把字典中的数据拆成单个的键值对。

函数的返回值

返回值：函数执行后，返回的结果。
获取返回值的方法：把函数调用当做一个值来输出。

def fn():
    return 1
x = fn()
print(x)
# 或 print(fn())
# 结果：1

无论定义的是返回什么类型，return只能返回单值，但是值可以有多个元素；看似返回很多个值，其实会被python隐式的分装成一个元组返回出来。

def fn():
    return 1,2,3
print(fn())
# 结果：(1, 2, 3)

函数的嵌套

def fn():
    def fn2():
        print("hello")
    print("f")
fn()

返回值也可以是返回函数

def fn():
    def fn1():
        print("hello")
    return fn1
r = fn()
r()
# 或 fn()()
# 结果：hello

return

def fn():
    pass
print(fn()) 
print(type(None)) 
# 结果：None
#		<class 'NoneType'>  

None代表空值，不可以理解为0，若不给一个return，那么这个函数的返回值为空。
None是NoneType数据类型的唯一值。
函数体中没有return语句时，与return、return None等效，都是返回None。

def fn():
    return
print(fn())  
# 结果：None

return语句在同一函数中可以出现多次，但是只要有一个得到执行，其后面的代码不会再执行。

def fn():
    print("one")
    print("two")
    print("three")
    return
    print("four")
 
fn()
# 结果：one
#		two
#		three

• break：退出当前循环
• continue：跳过本次循环
• return：用来结束函数

def fn():
    for i in range(1,11):
        if i ==4:
            print("提前结束")
            break
        print(f"第{i}遍")
fn()
# 结果：第1遍
#		第2遍
#		第3遍
#		提前结束 

print(fn) # 输出函数对象，即内存地址
print(fn()) # 输出fn()的返回值

print与return的区别：
print仅仅是打印在控制台，而return则是将return后面的部分作为返回值，作为函数的输出，可以赋值给一个变量，继续使用该返回值做其他事

函数高级用法

函数可以被引用(可以赋值)。

def fn():
    print("I'm fn")
a = fn
a()
# 结果：I'm fn

函数可以作为参数传入到另外一个函数。

def fn1():
    print("I'm fn")
def fn2(x):
    x()  # 调用x()
fn2(fn1)
# 结果：I'm fn

可以将函数作为返回值。

def fn1():
    print("I'm fn")
def fn2(x):
    return x
y=fn2(fn1)
y()
# 结果：I'm fn

函数可以作为容器元素

def fn():
    print("I'm fn")
li = [1, 2, 3, fn]
x = li[3]  # x相当于是fn
x()
# 结果：I'm fn