Python入门笔记（十）—— 函数

今天我们来讲讲函数。

函数和方法不一样，对应的英语应该是function, method

########## function(函数)
def add(a, b):
    return a + b

print(add(4, 5))


########## method(方法)
class oop:
    def __init__(self, a, b):
        self.a = a
        self.b = b

    def add(self):
        return self.a + self.b

a = oop(4, 5)
print(a.add())

函数是一个独立的功能，和对象无关，显示的传递数据。

方法与对象和类有关，依赖对象而调用，可以直接处理对象上的数据（例子中init传入的a，b）也就是隐式传递数据。

---

函数的主要作用就是为了提高代码重用率。

函数可以在带参数、不带参数、带返回值、不带返回值中自由组合

def function(arg1, arg2):
  return arg1 + arg2

function(2, 7)

• 函数名称必须遵守标识符规则，可以使用数字、字母、下划线，但是不用使用数字开头，不能使用关键字。
• 函数先定义后调用。
• 函数不调用是不执行的。
• 函数可以调用多次。

---

函数调用的本质，对于不可变类型来说，是传值调用。

a = 4
b = 5

def add(a, b):
    a = a + b
    b = a - b
    a = a - b
    print("inner", a)
    print("inner", b)

add(a, b)

print(a)
print(b)

###
inner 5
inner 4
4
5
###

##########

a = (3, 4, 5)

def func(a):
    a = (6, 7, 8)
    print("innner", a)

func(a)

print(a)

###
innner (6, 7, 8)
(3, 4, 5)
###

函数传入一个不可变参数时，会在函数内部新建一个副本，来进行运算，不会对原值进行改变。

在传入一个可变类型的参数时，则是进行了传引用调用。

a = [3, 4, 5]

def func(a):
    a.append(7)
    print("inner", a)

func(a)

print(a)

###
inner [3, 4, 5, 7]
[3, 4, 5, 7]
###

传入一个可变类型时，实际传入了参数的引用，函数可以根据这个引用对他实际的值进行改变，导致函数外面的值也进行了改变。

函数可以返回多个值，也可以不返回值。不返回值默认返回None

def area(r):
  s = 3.14 * r ** 2
  c = 2 * 3.14 * r
  return s, c

s1, c1 = area(5)
print(s1)
print(c1)

###
78.5
31.400000000000002
小数点不精准的原因我会放在下一篇来讲。小数点不精准是普遍的，要尽量避免。
###

return可以用来返回值，也可以用来结束此方法。

---

函数参数的定义方式有四种：

• 位置参数
• 关键词参数
• 默认参数
• 可变参数(*args, **kwargs) # 写到这，我想写一篇md语法转义字符😑 为了这俩* 我还专门去百度了一下😑

位置参数

在传参的时候，实参传递的顺序按照形参定义的顺序进行传递的传参方式。

关键词参数

在传参的时候，以形参等于实参的形式忽略形参定义的顺序进行传参的传参方式。

关键词参数和位置参数同时使用时，关键词参数必须在位置参数后面定义。

默认参数

在定义参数的时候，给形参一个默认值，在调用函数的时候，如果不给有默认值的形参传参，会自动采用默认值。

当某个值变化小的时候，我们就可以使用默认参数。

def add(num1, num2 = 10):
    total = num1 + num2
    return total

print(add(20))
print(add(20, 20))

###
30
40
###

可变参数

如果函数中的参数过多，定义起来非常麻烦，调用起来也非常麻烦，因此Python提供了可变参数类型。能处理比当初声明时更多的参数，会将传入的参数变成元组( *args )或者字典( **kwargs )

元组参数(*args)

通过给形参前面添加* 使参数变成一个元组，所有传递的参数变成元组的元素。

args参数名称可以任意命名，但是一般叫args。

def func(*args):
    print(args)
    print(args[0], args[1])

func(1, 2, 3, 4)

###
(1, 2, 3, 4)
1 2
###

* 具有打散序列的功能

def func(a, b, c):
    print(a, b, c)

a = (1, 2, 3)
func(*a)

# 1 2 3


a = (1, 2, 3)
print(*a)
b = [4, 5, 6]
print(*b)
c = "hello"
print(*c)

###
1 2 3
4 5 6
h e l l o
###

字典参数(**kwargs)

通过给形参前面添加** 使参数变成一个字典，所有传递的参数变成字典的键值对，这里传参要求以键等于值的形式。

def func(**kwargs):
    print(kwargs)
    print(kwargs["name"], kwargs["age"])

func(name="hanhan", age=10)

###
{'name': 'hanhan', 'age': 10}
hanhan 10
###

** 具有打散字典的功能

def func(name, age):
    print(name, age)

a = {"name": "hanhan", "age": 10}
func(**a)

# hanhan 10

**kwargs必须跟在*args后面。

函数参数总结：
定义函数时参数的顺序：位置参数，元组参数，默认参数，字典参数

---

函数嵌套及调用

函数内部嵌套函数

def outter():
    print("aaa")

    def inner():
        print("bbb")

    inner()

outter()

###
aaa
bbb
###

函数之间调用

def func1():
    print("func1")

def func2():
    func1()
    print("func2")

func2()

###
func1
func2
###

今天的内容真的是超级充实了，大家能看到这里希望给我一个赞💕

递归函数下篇博客再讲，886