014.Python函数

一 函数的概念

1.1 函数的含义

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

1.2 函数特点

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

1.3 函数的基本格式

# 语法格式
def 函数名():
    pass

简单示例

# 函数的定义
def func():
        print("函数简单示例")

# 函数的调用
func()

执行

[root@node10 python]# python3 test.py
函数简单示例

1.4 函数的命名规则

驼峰命名法

(1)大驼峰命名法: MyWorld 每个单词首字符都是大写
(2)小驼峰命名法: myWork  只有第一个单词首字符小写,剩下都大写
函数命名当中不做强制要求,但是对于类名来讲,建议使用大驼峰
函数命名: 一般如下: my_work ,  my_beatiful_girl

二 函数的参数

(1)形参:形式参数 (在函数的定义处)
(2)实参:实际参数 (在函数的调用处)
形式参数种类: 普通(位置)参数 默认参数 普通收集参数 命名关键字参数 关键字收集参数
实际参数种类: 普通(位置)实参 关键字实参
形参和实参数量要一一对应

2.1 普通形参

函数和定义处

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

        print()
        i+=1
# 函数的调用处 10,10 就是实际参数: 普通实参
star(10,10)

执行

[root@node10 python]# python3 test.py
**********
**********
**********
**********
**********
**********
**********
**********
**********
**********

2.2 默认形参

# hang 和 lie 就是形参: 默认形参 带有默认值
def star(hang=10,lie=10):
        i = 0
        while i<hang:
                j = 0
                while j<lie:
                        print("*",end="")
                        j+=1

                print()
                i+=1
star()

执行

[root@node10 python]# python3 test.py
**********
**********
**********
**********
**********
**********
**********
**********
**********
**********

给与实际参数时候,用自己的
没给与实际参数时,用默认形参的

# hang 和 lie 就是形参: 默认形参 带有默认值
def star(hang=10,lie=10):
        i = 0
        while i<hang:
                j = 0
                while j<lie:
                        print("*",end="")
                        j+=1

                print()
                i+=1
star(4,5)

执行

[root@node10 python]# python3 test.py
*****
*****
*****
*****

一个参数，hang=4，默认lie=10

# hang 和 lie 就是形参: 默认形参 带有默认值
def star(hang=10,lie=10):
        i = 0
        while i<hang:
                j = 0
                while j<lie:
                        print("*",end="")
                        j+=1

                print()
                i+=1
star(4)

执行

[root@node10 python]# python3 test.py
**********
**********
**********
**********

2.3 普通形参 + 默认形参

如果普通形参 + 默认形参都存在的情况下, 优先顺序,普通形参要跟在默认形参的前面;

# hang 和 lie 就是形参: 默认形参 带有默认值
def star(hang,lie=10):
        i = 0
        while i<hang:
                j = 0
                while j<lie:
                        print("*",end="")
                        j+=1

                print()
                i+=1
star()   #不写参数会报错

执行

# 写1个参数 hang = 4 lie  =10
# star(4)

# 写2个参数
# star(3,3)

2.4 关键字实参

[root@node10 python]# cat test.py
# 函数的定义处
def star(hang,lie=10):
        i = 0
        while i<hang:
                j = 0
                while j<lie:
                        print("*",end="")
                        j+=1

                print()
                i+=1

# 函数的调用处
# lie = 13 是关键字实参
star(3,lie=13)

执行

[root@node10 python]# python3 test.py
*************
*************
*************

其他用法

# hang = 3 ,lie = 5 是关键字实参
star(hang = 3,lie =5)
# 如果是关键字实参,顺序可以颠倒
star(lie = 2,hang=3)

如果定义时,是普通形参 ,调用时,是关键字实参调用,那么跟在这个普通形参后面的所有参数,都需要使用关键字实参

def star(hang,a1,a2,lie=10):
        i = 0
        while i<hang:
                j = 0
                while j<lie:
                        print("*",end="")
                        j+=1

                print()
                i+=1
# 函数的调用处
# star(1,a1= 1,a2 = 3,lie = 18)
star(1,lie=3,a1 = 4,a2=8)

执行

[root@node10 python]# python3 test.py
***

三 收集参数

3.1 普通收集参数

(任意长度都可以接收)

语法

def func(*args):
    pass

*args 就是普通收集参数 : * + 参数名字(名字自定义,一般约定俗成叫做args => arguments 参数的意思)

用途:专门用于收集多余的没人要的普通实参,都放到一个元组当中收集

[root@node10 python]# cat test.py
#函数的定义处 定义好收集参数args
def func(a,b,c,*args):
        print(a,b,c)
        print(args)

# 函数的调用处
func(1,2,3,4,5,56,6,7)

执行

[root@node10 python]# python3 test.py
1 2 3
(4, 5, 56, 6, 7)

计算任意长度的累加和

def mysum(*args):
        total = 0
        for i in args:
                total += i
        print(total)

mysum(1,2,3,4,4,5)

执行

[root@node10 python]# python3 test.py
19

3.2 关键字收集参数

语法

def func(**kwargs):
    pass

**kwargs 就是关键字收集参数 : ** + 参数名字 (名字自定义,一般约定俗成叫做kwargs => keyword arguments 参数的意思)

用途:专门用于收集多余的没人要的关键字实参,都放到一个字典当中收集

# 函数的定义处,定义关键字收集参数
def myfunc(a,b,c,**kwargs):
        print(a,b,c)
        print(kwargs)
# 函数的调用处
myfunc(a=1,b=3,c=5,d=10,e=21)

执行

[root@node10 python]# python3 test.py
1 3 5
{'d': 10, 'e': 21}

拼接任意长度的字符串

def myfunc2(**kwargs):
        dictvar = {"weiguo":"皇帝","shuguo":"皇叔"}
        str1 = ''
        str2 = ''
        # print(kwargs)  # kwargs 是字典 {'weiguo': '曹操', 'shuguo': '刘备', 'wuguo': '孙权'}
        for k,v in kwargs.items():
                if k in dictvar:
                        # print(k) # monitor clasflower
                        str1 += dictvar[k] + ':' + v  + '\n'
                        # str1 += "曹操" + ":" + 刘备 + '\n'
                else:
                        # 如果不符合条件,将是乱世奸雄名字拼接在一起
                        str2 += v + ' '

        print(str1,"乱世奸雄")
        print(str2,"吴国皇帝")
myfunc2(weiguo="曹操",shuguo="刘备",wuguo="孙权")

执行

[root@node10 python]# python3 test.py
皇帝:曹操
皇叔:刘备
 乱世奸雄
孙权  吴国皇帝

3.3 命名关键字参数

语法

(1)在函数的定义处,跟在*号后面的参数是命名关键字参数
def func(参数1,参数2,*,参数3,参数4):
    pass

(2)夹在普通收集参数和关键字收集参数之间的参数是命名关键字参数
def func(*args,参数1,参数2,**kwargs):
    pass

这两种是命名关键字参数;
命名关键字参数在函数调用时,必须用关键字实参的形式调用(除非指定了默认值)

第一种写法

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

# 函数的调用处 , 命名关键字必须指定关键字实参进行调用,否则报错
func(1,2,3,d=4)

执行

[root@node10 python]# python3 test.py
1 2 3
4

第二种写法

# 函数的定义处
def func(*args,b,c,**kwargs):
        print(args)
        print(kwargs)
        print(b,c)

# 函数的调用处
func(1,2,3,4,a=1,b=2,c=3,d=4,f=5)

执行

[root@node10 python]# python3 test.py
(1, 2, 3, 4)
{'a': 1, 'd': 4, 'f': 5}
2 3

命名关键字可以指定默认值

def func(a,b,*,c=1,d=2):
    print(a,b)
    print(c,d)
# 命名关键字必须在调用时,用关键字实参,要么调用时使用它的默认值,一旦写了一定指定关键字实参;
func(5,6)

执行

[root@node10 python]# python3 test.py
5 6
1 2

3.4 *和**的用法

在函数定义处: * 和 ** 作用:打包   (比如普通收集参数和关键字收集参数)
在函数调用处: * 和 ** 作用:解包

好处: 可以控制参数的长度(优点) 动态产生不定长参数调用时需要用到
* 可以对应str list tuple
** 可以对应dict

示例

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

lst = [1,2,3]
# *lst 在列表的前面加* 代表解包操作,把列表当中的元素,一个一个拿出来,当成参数给func调用 相当于func(1,2,3,d=90)
func(*lst,d=90)

执行

[root@node10 python]# python3 test.py
1 2 3
90

示例2

def func(a,b,c,*,d,e,f):
        print(a,b,c)
        print(d,e,f)
# *dictvar 在字典的前面加** 代表解包操作,把字典当中的元素,一个一个拿出来,当成d=1,e=12,f=13参数给func调用 ,相当于func(1,2,3,d=11,e=12,f=13) 一模一样
dictvar = {"d":11,"e":12,"f":13}
func(1,2,3,**dictvar)

执行

[root@node10 python]# python3 test.py
1 2 3
11 12 13

具体用法示例

#定义处: * 和 ** 是收集参数 ,负责打包 ,一颗星打包成元组,二颗星打包成字典
def func(*args,**kwargs):
        pass
# 调用处 * 和 ** 是魔术用法, 负责解包,一个星是将列表元素拆解成普通实参,二个星是将字典元组拆解成关键字实参
func(*lst,**dictvar)

3.5 return返回值

1. return + 数据类型 :    将这个数据弹到函数的调用处,后面除了可以接六大标准数据类型之外,还可以返回类 对象 函数 等;默认返回None
2. 函数当中,执行完return 之后,函数立刻终止,意味着函数里 , 跟在return后面的代码不执行

把数据返回到函数的调用处

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

# 这个地方是调用处 函数名()
res = func()  # 相当于 res = 1
print(res)

函数的返回值不是必须的,按照需求来,如果不写return 返回值,默认返回None

def func():
        print(1234566)

res = func()
print(res)

# 打印1234567 和 自定义的return 之间没有半毛钱关系,返回值是自定义的;
res  = print(1234567)
print(res)

执行

[root@node10 python]# python3 test.py
1234566
None
1234567
None

(3) 写一个计算器

def calc(sign,num1,num2):
        if sign == "+":
                res = num1 + num2
        elif sign == "-":
                res = num1 - num2
        elif sign == "*":
                res = num1 * num2
        elif sign == "/":
                if num2 == 0:
                        return "我不认识"
                res = num1 / num2
        else:
                return "请正常一点"
        return res
res = calc("+",5,1)
print(res)

(1)在函数的定义处,跟在*号后面的参数是命名关键字参数def func(参数1,参数2,*,参数3,参数4):pass
(2)夹在普通收集参数和关键字收集参数之间的参数是命名关键字参数def func(*args,参数1,参数2,**kwargs):pass这两种是命名关键字参数;命名关键字参数在函数调用时,必须用关键字实参的形式调用(除非指定了默认值)