06_Python初识函数_全栈开发学习笔记

1. 创建一个简易函数代替len()

范例：

s = "霸王丸地狱变"    # 第一步

print(len(s))

def own_len():    # 第二步：定义函数（声明函数）
    i = 0         # 第四步
    for k in s:   # 第五步
        i = i + 1
    return i    #1 第六步 #2 return()为返回值

length = own_len()    # 第三步：own_len()为函数调用
print(length)

执行结果

6
6

---

2. 返回值（默认返回None）

2.1 返回值的三种情况

1. 没有返回值
   范例1：不写return

def func():
    l = ["霸王丸","牙神幻十郎"]
    for i in l:
        print(i)

ret = func()
print(ret)

执行结果

霸王丸
牙神幻十郎
None

范例2.1：只写return：结束一个函数

def func():
    l = ["霸王丸","牙神幻十郎"]
    for i in l:
        print(i)
    return

ret = func()
print(ret)

执行结果：

霸王丸
牙神幻十郎
None

范例2.2：只写return：结束一个函数的继续

def func():
    l = ["霸王丸","牙神幻十郎"]
    for i in l:
        if i == "霸王丸":
            return

ret = func()
print(ret)

执行结果：

None

范例3：return None（不常用 ）

def func():
    l = ["霸王丸","牙神幻十郎"]
    for i in l:
        if i == "霸王丸":
            return None

ret = func()
print(ret)

执行结果

None

2. 返回一个值。
   可以返回任何数据类型；只要返回就可以接收到；如果在一个程序中有多个return，那么只执行第一个。
   范例1.1：返回一个列表

def func():
    return [1,2,3,4]

print(func())

执行结果

[1, 2, 3, 4]

范例1.2：返回一个字典

def func():
    return {"k1":"v1","k2":"v2"}

print(func())

执行结果

{'k2': 'v2', 'k1': 'v1'}

3. 返回多个值
   范例1：返回多个值用多个变量接收：有多少返回值就用多少变量接收

def func():
    return 1,2,3

r1,r2,r3 = func()
print(r1,r2,r3)

执行结果

1 2 3

范例2：用一个变量接收: 得到的是一个元组

def func():
    return 1,2,3

r = func()
print(r)

执行结果

(1, 2, 3)

---

3. 参数

3.1 没有参数

定义函数和调用函数时括号里都不写内容

3.2 一个参数

传什么就是什么
范例：

def my_len(s):    # #自定义函数只需要0个参数。接收参数,形式参数，形参
    i = 0
    for k in s:
        i = i + 1
    return i    #返回值

ret1 = my_len("红疯与白疯")    # 传递参数：传参，实际参数，实参
ret2 = my_len([1,2,3,4,5,6])      #传递参数：传参

print(ret1)
print(ret2)

执行结果

5
6

3.3 多个参数

3.3.1 站在实参的角度上

• 按照位置传参
• 按照关键字传参
• 混着用可以：但是 必须先按照位置传参，再按照关键字传参数，不能给同一个变量传多个值

1. 位置参数1：按照位置传参
   范例：

def my_sum(a,b):
    res = a + b
    return(res)

ret = my_sum(1,2)    # 位置传参
print(ret)

执行结果

3

2. 位置参数2：按照关键字传参
   范例：

def my_sum(a,b):
    print(a,b)
    res = a + b
    return(res)

ret = my_sum(b=1,a=2)    # 关键字传参
print(ret)

执行结果

2 1
3

3. 位置参数3：混用也可以
   范例：

def my_sum(a,b):
    print(a,b)
    res = a + b
    return(res)

ret = my_sum(2,b=2)    # 先位置，后关键字
print(ret)

执行结果：

2 2
4

3.3.2 站在形参的角度上

• 位置参数：必须传,且有几个参数就传几个值
• 默认参数: 可以不传，如果不传就是用默认的参数，如果传了就用传的

范例1：位置参数

def classmate(name,sex):
    print("%s : %s"%(name,sex))

classmate("刘备","男")
classmate("关羽","男")
classmate("张飞","男")

执行结果：

刘备 : 男
关羽 : 男
张飞 : 男

范例2：默认参数

def classmate(name,sex="男"):
    print("%s : %s"%(name,sex))

classmate("刘备")
classmate("关羽")
classmate("张飞")
classmate("孙尚香","女")

执行结果

刘备 : 男
关羽 : 男
张飞 : 男
孙尚香 : 女

3.3.2.1 默认参数的陷阱

如果默认参数的值是一个可变数据类型（列表、字典），那么每一次调用函数的时候，如果不传值就共用这个数据类型的资源。
范例1：

def qqxing(l = []):
    l.append(1)
    print(l)

qqxing()     #[1]
qqxing([])   #[1] 
qqxing()     #[1,1]
qqxing()     #[1,1,1]

执行结果

[1]
[1]
[1, 1]
[1, 1, 1]

范例2：

def qqxing(l = {}):
    l['k'] = 'v'
    print(l)

qqxing()
qqxing()
qqxing()

执行结果

{'k': 'v'}
{'k': 'v'}
{'k': 'v'}

范例3：

def qqxing(k,l = {}):
    l[k] = 'v'
    print(l)

qqxing(1)
qqxing(2)
qqxing(3)

执行结果

{1: 'v'}
{1: 'v', 2: 'v'}
{1: 'v', 2: 'v', 3: 'v'}

3.3.2 只有调用函数的时候

按照位置传：直接写参数的值
按照关键字：关键字 = 值

3.3.3 定义函数的时候

• 位置参数：直接定义参数
• 默认参数，关键字参数：参数名 = "默认的值"
  顺序：必须先定义位置参数，后定义默认参数
• 动态参数 : 可以接受任意多个参数。
  参数名之前加，习惯参数名args，
  参数名之前加*，习惯参数名kwargs
• 顺序：位置参数，args，默认参数，*kwargs

3.3.4 动态参数

• 动态参数有两种：可以接受任意个参数
• *args：接收的是按照位置传参的值，组织成一个元组
• **kwargs：接受的是按照关键字传参的值，组织成一个字典
• args必须在kwargs之前

范例1.1：动态参数 *args（按位置传参）

def sum(*args):
    n = 0
    for i in args:
        n = n + i
    return n

print(sum(1,2))
print(sum(1,2,3))
print(sum(1,2,3,4))

执行结果

3
6
10

范例1.2：动态参数 *args（演示无法包括位置参数）

def func(*args,l=[]):
    print(args,l)

func(1,2,'str')
func(1,2,'str',l = ['1st',1])

执行结果

(1, 2, 'str') []
(1, 2, 'str') ['1st', 1]

范例2：动态参数 **kwargs

def func(**kwargs):
    print(kwargs)

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

执行结果：

{'b': 2, 'c': 3, 'a': 1}
{'b': 2, 'a': 1}
{'a': 1}

范例3：args与*kwargs结合

def func(*args,**kwargs):
    print(args,kwargs)

func(1,2,3,4,5,a="aaa",b="bbb")

执行结果：

(1, 2, 3, 4, 5) {'b': 'bbb', 'a': 'aaa'}

3.3.5 动态参数的另一种传参方式

范例1：*args

def func(*args):    # 站在形参的角度上，给变量加上*，就是组合所有传来的值。
    print(args)

l = [1,2,3,4,5]
func(*l)    # 站在实参的角度上，给一个序列（列表与元组）加上*，就是将这个序列按照顺序打散

执行结果：

(1, 2, 3, 4, 5)

范例2：**kwargs

def func(**kwargs):
    print(kwargs)

func(a=1,b=2)
d = {"a":1,"b":2,"c":3}    # 定义一个字典d
func(**d)

执行结果：

{'a': 1, 'b': 2}
{'b': 2, 'c': 3, 'a': 1}

---

4. 参数的嵌套

#-*- encoding:utf-8 -*-

def f1(l1):
    for i in l1:
        print(i)

def f2(l1):
    f1(l1)
    for i in l1:
        print(i)

f2([1,2,3,4])

执行结果：

1
2
3
4

1
2
3
4

---

5. 函数的注释

范例：

def func():
    '''
    这个函数实现了什么功能
    参数1：
    参数2：
    :return: 是字符串或者列表的长度
    '''
    pass

---

6. 函数参数的思维导图

图片:

函数参数

链接:

上图源自老男孩中心的老师Eva Jing的博客