python_初识函数

1.函数的含义:

功能 (包裹一部分代码 实现某一个功能 达成某一个目的)

2.函数特点:

可以反复调用,提高代码的复用性,提高开发效率,便于维护管理

3.函数基本格式

3.1)函数的定义

在Python中可以使用def关键字来定义函数,在函数名后面的圆括号中可以放置传递给函数的参数

　　def  函数名（参数1，参数2）

3.1.1) 函数的命名: 

函数的命名与变量的命名要求一致

　　　　　函数的命名
字母数字下划线,首字符不能位数字
严格区分大小且,且不能使用关键字
函数命名有意义,且不能使用中文哦

3.2) 函数的调用

返回值=函数名（参数1，参数2）#记得函数名后面加括号

只有解释器读到函数名() 时，才会执行此函数.而且是这个指令你写几次，函数里面的代码就运行几次，

3.2.1)函数的返回值

return 自定义返回值,如果没有写return ,默认返回None
功能:把值返回到函数的调用处;
(1)return 后面可以返回值 是自定义的. 除了6大标准数据类型之外,还有类 对象 函数
(2)如果执行了return 语句,意味着函数终止,后面的代码不执行

下面的例子充分说明了函数内如果出现return,函数立刻终止,跳出函数

# 1.return
def func():
    l = ["金老板","二哥"]
    for i in l:
        print(i)
        if i =="金老板":
            return
    print("="*10)

res = func()
print(res)

# 2.break
def func():
    l = ["金老板","二哥"]
    for i in l:
        print(i)
        if i =="金老板":
            break
    print("="*10)

res = func()
print(res)

 

1.
def func():
    for i in range(5):
        if i == 3:
            return i
        print(i)
res = func()

2.
def func():
    print("这句话执行了1")
    print("这句话执行了2")
    return 1
    print("这句话执行了3")
    print("这句话执行了4")
res = func()
print(res)

返回值的3种情况:　

没有返回值 —— 返回None

　　　　a)不写return　　
　　　　b)只写return:结束一个函数的继续==break
　　　　c)return None —— 不常用

def func(): # 定义函数
    l=["金老板","二哥"]
    # 遍历列表
    for i in l:
    # 打印列表内容-金老板,二哥
        print(i)
    #这里注释return返回值,函数不会有返回值
        #return i  

# 调用函数,用一个变量去接收函数的返回值,这里用res去接收,然后打印res  
res = func()
print(res)        

def  func():
    a=111
    b=[1,2,3]
    return

ret=func()
print(ret)

def  func():
    a=111
    b=[1,2,3]
    return  None

ret=func()
print(ret)

 返回1个值
　　　　a)可以返回任何数据类型
　　　　b)只要返回就可以接收到
　　　　c)如果在一个程序中有多个return，那么只执行第一个

返回多个值
　　　　a)用多个变量接收：有多少返回值就用多少变量接收
　　　　b)用一个变量接收: 得到的是一个元组

# 1.返回一个值
def  func():
        a=111
        b=[1,2,3]
        c={'a':15,'b':6}
        return a 

print(func())

# 2.返回多个值
def  func():
        a=111
        b=[1,2,3]
        c={'a':15,'b':6}
        #返回多个值，变量之间按逗号隔开，以元组的形式返回
       #return a,b,c

print(func())

def func():
    return 1,2,3

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

## ValueError: too many values to unpack (expected 2)

4.函数的参数

4.1)实参与形参的定义

1.形参: 形式参数 (在函数的定义处)

   形参:(普通[位置]形参 , 默认形参 , 普通收集参数 , 命名关键字参数, 关键字收集参数)

2.实参: 实际参数 (在函数的调用处)

   实参:(普通实参.关键字实参)

3.注意:形参 和 实参 要一一对应

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

s = "金老板小护士"
res = my_len(s) # 传递参数:传参,实际参数(实参)
res = my_len([1,2,3,4,5])
print(res)

4.2)形参

4.2.1)位置形参

位置参数其实与实参角度的位置参数是一样的，就是按照位置从左至右，一一对应

位置形参是必须传的,且有几个就传几个值

# 函数的定义处 hang,lie 普通(位置)形参
def my_star(hang,lie):
    i = 0
    while i < hang:
        j = 0
        while j < lie:
            # 打印星星
            print("*",end="")
            j +=1
        print()
        i +=1

# 函数的调用处  3,8 普通实参    
my_star(3,8)

4.2.2)默认形参

如果给与实参,那么就使用实际参数

如果没给实参,那么就使用参数的默认值

1.默认形参
# hang,lie 在函数定义处给与默认值
def my_star( hang = 4,lie=10):
    i = 0
    while i <hang:
        j =0
        while j < lie:
            print("*",end="")
            j+=1
        print()
        i+=1

res = my_star()
print(res)
print("<=============>")
res = my_star(10,3)
print(res)

4.2.3)普通形参 + 默认形参 

默认形参必须写在普通形参的后面,语法上有要求

def my_star(lie,hang=3):
    i=0
    while i<hang:
        j=0
        while j<lie:
            print("*",end="")
            j+=1
        print()
        i+=1

my_star(3)
my_stat(4,8)

# 形参实参要一一匹配,error报错
# my_star() 

4.3)关键字实参

1).如果使用关键字实参进行函数调用,实参的顺序无所谓

2).如果定义时是普通形参,调用时是关键字实参,那么这个参数后面的所有调用方式都需要关键字实参进行调用

def small_start(hang,a,b,c,lie=10):
# def small_start(hang,lie=10):
    i = 0
    while i<hang:
        j = 0
        while j<lie:
            # 打印星星
            print("*",end="")
            j+=1
        # 打印换行
        print()
        i+=1
# 关键字实参 hang  和 lie 
small_start(lie = 12,hang = 12)

# small_start(3,4,5,6,7)
# small_start(3,c=90,b=7,a=5,lie =14)

 4.3.1)位置实参+关键字实参

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

4.3.3)注意

1).只有调用函数的时候

　　按照位置传:直接写参数的值

　　按照关键字:关键字=值

2).定义函数的时候

　　位置参数:直接定义参数

　　默认参数:关键字参数:参数名 = "默认的值"

3).定义参数的时候:必须先定义位置参数,再定义默认参数

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

classmate("二哥","男")
classmate(sex="男",name="二哥")


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

classmate("二哥")
classmate("狼哥","男")
classmate("狼哥",sex="男")

 

4.4)动态参数(收集参数)*/ **

*/ **后面加任意的参数名都可以

动态参数有两种：可以接受任意个参数

*args ： 接收的是按照位置传参的值，组织成一个元组

**kwargs： 接受的是按照关键字传参的值，组织成一个字典

args必须在kwargs之前

(1) 普通收集参数 * 在函数的定义处
专门用来收集那些多余的,没人要的普通实参,形成一个元组

语法:
def func(*args) : args => arguments
def func(*args):
print(args) => 返回的数据类型是元组 

(2) 关键字收集参数 ** 在函数的定义处
专门用来收集那些多余的,没人要的关键字实参,形成一个字典

语法:
def func(**kwargs) : kwargs => keyword arguments
def func(**kwargs):
print(kwargs) => 返回的数据类型是字典

4.4.1)动态参数的另一种传参方式

在函数的定义处:* ** 相当于打包操作 (一个是元组,一个是字典)
在函数的调用处:* ** 相当于解包操作 (把里面的元素一个一个拿出来,当成实参调用赋值了)

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

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

def func(**kwargs)
    print(kwargs)

func(a=1,b=2)
d={"a":1,"b":2}
func(**d)

4.5)注意

参数顺序:普通参数 > 默认参数 > *args >关键字参数 > **kwargs 

5.函数的注释

函数注释的格式

def func():

　　'''

　　这个函数实现了什么功能

　　参数1:

　　参数2:

　　return:是字符串或者列表的长度

　　'''

　　pass