函数的定义和调用

一、函数的介绍

函数：可以用对重复使用的功能代码进行封装，提高代码的复用性，提高工作效率，降低代码的耦合性

二、函数的定义

定义函数关键字:def
语法：

def 函数名()：
	#函数内部代码

三、函数的命名规范

1、函数名只能使用数字、字母、下划线组成
2、函数名不能使用数字开头
3、不能使用python中的关键字（内置函数，官方库，第三方库的名字统统不要用）
4、命名风格：推荐使用下划线命名法

四、函数的调用

函数的调用：函数名()
定义好的函数，不会执行运行，需要调用才会执行函数内部代码

def print_func():
    for i in range(1, 10):
        for j in range(i):
            print("* ", end="")
        print()


print_func()

五、内置函数

函数的参数分类及使用

一、函数的参数

1.参数的定义：函数名后面的括号中定义参数
2.参数的传递：
参数传递的两种形式：
位置参数：位置参数（按位置进行传递）
关键字参数：通过关键字指定传给某个参数。
注意：关键参数写在位置参数之后。
定义的参数称为：形参
调用实际的传递的为：实参

二、函数的参数类型

形参：定义的参数称为形参

三种定义形式：
1、必须参数（必备参数）：定义了就一定（必须要传），不能多也不能少
def add(a, b):
print(“a:”, a)
print(“b:”, b)
print(a + b)
add(11, 22)
运行结果：a: 11
b: 22
33

2、默认参数（缺省参数）：定义的时候可以设置默认值，调用的时候可以传，也可以不传，不传使用默认值

def add(a, b, c=99):  
    print("a:", a)
    print("b:", b)
    print("c:", c)
    print(a + b)
add(11, 22) # 不传默认值

运行结果：a: 11
b: 22
c: 99
33

def add(a, b, c=99):
    print("a:", a)
    print("b:", b)
    print("c:", c)
    print(a + b)
add(11, 22, 121) # 传默认值

运行结果：a: 11
b: 22
c: 121
33
3、不定长参数（动态\可变参数）：可以接受0个或者多个参数
*args：只能接收位置参数，以元组的形式保存

def func(*args):
    print(args)
func()
func(11)
func("aaa", "abbb", 12345678, 11, 22, 33, 4, 4, 55, 323, 6, 777)

运行结果：()
(11,)
(‘aaa’, ‘abbb’, 12345678, 11, 22, 33, 4, 4, 55, 323, 6, 777)
**kwargs：只能接收关键字传参，以字典的形式保存

def func2(**kwargs):
    print(kwargs)
func2(a=11, b=22, c=33)

运行结果：{‘a’: 11, ‘b’: 22, ‘c’: 33}
***args和kwargs共同使用：先写位置参数，再写关键字参数

def func2(*args, **kwargs):
    print(args)
    print(kwargs)
func2(1111, 2222, 333, 4444, a=11, b=22, c=33)

运行结果：(1111, 2222, 333, 4444)
{‘a’: 11, ‘b’: 22, ‘c’: 33}

实参：调用时实际传递的为实参

两种形式：
1、位置传参（位置参数）：按照参数定义的位置进行传递

def add(a, b):
    print("a:", a)
    print("b:", b)
    print(a + b)
add(11, 22)

运行结果：a: 11
b: 22
33
2、关键字传参（关键字参数）：通过参数名字，指定传递

def add(a, b):
    print("a:", a)
    print("b:", b)
    print(a + b)
add(b=333, a=111)

运行结果：a: 111
b: 333
444
注意点：如果使用两种形式混合传递参数：先写位置参数，再写关键字参数（不然就会报错）

三、函数的参数拆包

*一个星号:

*加在形参前面（定义函数参数的时候使用），接收不定长的位置参数，转换为元祖

def func2(*aa):
    print(aa)
func2(11, 22, 33)

运行结果：(11, 22, 33)
ps:结果为元祖
*加在实参前面（调用函数参数的时候使用），可以将元祖(列表)拆包成多个位置参数

def func1(a, b, c, d):
    print(a, b, c, d)
tu = ("xiaoyao", 18, 11, "男")
func1(*tu)

运行结果：xiaoyao 18 11 男
PS:拆的是“元组”，结果为元组中所有元素

def func1(a, b, c, d):
    print(a, b, c, d)
li = ["xiaoyao", 18, 11, "男"]
func1(*li)

运行结果：xiaoyao 18 11 男
PS：拆的是“列表”，结果为列表中所有元素

** 两个星号:

** 加在形参前面（定义函数参数的时候使用），接收不定长的关键字参数，转换为字典

def func2(**bb):
    print(bb)
func2(a=111, b=222)

运行结果：{‘a’: 111, ‘b’: 222}
ps：结果为“字典”
** 加在实参前面（调用函数参数的时候使用），可以将字典拆包成多个关键字参数

def func2(a, b, c, d):
    print(a, b, c, d)
dic = {"a": 11, "b": 22, "c": 33, "d": 44}
func2(**dic)

运行结果：11 22 33 44
ps：拆的是“字典”，结果为字典中所有值

函数的返回值

一、函数有没有返回值的区别

1、append方法没有定义返回值，所以运行结果是空

li = [11, 22, 33]
st1= "12345"
res = li.append(11)
print(res)

运行结果：None
2、copy方法有定义返回值，所以运行结果有值

li = [11, 22, 33]
st1= "12345"
res2 = li.copy()
print(res2)

运行结果：[11, 22, 33]

3、如何查看函数有没有返回值：crtl+鼠标悬停方法上
1）None为没有定义返回值
2）不是None为有定义返回值，并展示数据类型

二、返回值的定义

1、函数的返回值：通过关键字return来定义
2、不写return，返回None

def add(a, b):
    c = a + b
result = add(11, 22)
print("函数调用之后的返回结果：", result)

运行结果：函数调用之后的返回结果： None
3、return后面不写内容，返回None

def add(a, b):
    c = a + b
    return
result = add(11, 22)
print("函数调用之后的返回结果：", result)

运行结果：函数调用之后的返回结果： None
4、return后面就返回一个值，返回就是该数据

def add(a, b):
    c = a + b
    return c
result = add(11, 22)
print("函数调用之后的返回结果：", result)

运行结果：函数调用之后的返回结果： 33
ps:但无法识别数据类型，展示“所有”

5、ruturn后面返回1个以上值（用逗号隔开），返回的是一个元组

def func(a, b):
    c = a + b
    d = a - b
    return c, d
result = func(11, 22)
print("函数调用之后的返回结果：", result)

运行结果：函数调用之后的返回结果： (33, -11)
6、使用元组拆包，用两个变量接收两个返回值

def func(a, b):
    c = a + b
    d = a - b
    return c, d
res1, res2 = func(11, 22)
print(res1,res2)

运行结果：33 -11
7、注意点：函数执行到return就会结束函数的运行，并返回结果
1）执行到return c，d，已经返回了结果，后边的return 111不会执行

def demo1(a, b):
    c = a + b
    d = a - b
    if c == d:
        return c, d
    return 111
res = demo1(0, 0)
print(res)

运行结果：(0, 0)
2）未执行return c，d，后边的return 111会执行

def demo1(a, b):
    c = a + b
    d = a - b
    if c == d:
        return c, d
    return 111
res = demo1(11, 2)
print(res)

运行结果：111
8、什么时候需要返回值，什么时候不需要返回值？根据需求决定。
1）需要ruturn：老板让你去买瓶酱油给我
ps：你去买完酱油之后，需要把酱油给到我（把结果给到我，这就需要返回值）
2）不需要return：老板让你去关窗户
ps：你关完窗户就直接完事了，不需要给我什么（不需要返回值）

函数的作用域

一、全局变量

1、定义：python中直接定义在模块（py文件中的变量），叫做全局变量，在该文件中任何地方都可以使用
2、全局变量在函数中可以使用

a = 100
def demo2():
    b = 200
    print('函数中打印a：',a)
demo2()

运行结果：函数中打印a： 100

二、局部变量

1、定义：定义在函数中的变量，叫做局部变量，只能在该函数内部使用

def demo2():
    b = 200

2、局部变量在函数外不可以使用，会报错

def demo2():
    b = 200
demo2()
print('函数外面打印b：',b)

运行结果：NameError: name ‘b’ is not defined（b没有定义）
3、局部变量在函数内可以使用

def demo2():
    b = 200
    print('函数内部打印b：',b)
demo2()

运行结果：函数内部打印b： 200
4、局部变量在其他函数内不可以使用

def demo2():
    b = 200
demo2()
def demo1():
    c = 999
    print('函数内部打印b：',b) # 无法使用
demo1()

运行结果：NameError: name ‘b’ is not defined（b没有定义）

三、关键字global（全局），在函数内部申明全局变量

1、在函数内部，将aa声明成全局变量，后边不准直接赋值，需要换行后赋值

def demo3():
    global aa
    aa = 100
demo3()
print(aa)

运行结果：100
2、就近原则：当函数外部和内部都有变量，则取最近的变量值

num = 100
def func():
    num = 200
    print("函数中打印num:", num)
func()

运行结果：200
3、定义局部变量的时候尽量不要和全局变量重名
1）重名，可能会报错

num = 100
def func():
    print("函数中打印num:", num)
    num = 200
func()

运行结果：UnboundLocalError: local variable ‘num’ referenced before assignment（赋值前引用的局部变量‘num’）
ps:解释器会先检测函数内部的变量，检测到则优先使用，但变量在函数后方，所以报错
2）不重名，不报错

num1 = 100
def func():
    print("函数中打印num:", num1)
    num = 200
func()

运行结果：函数中打印num: 100
4、函数内部使用global，也会遵循就近原则

num = 100
def func():
    global num
    print("函数中111打印num:", num)
    num = 200
    print("函数中222打印num:", num)
func()
print("函数外面：", num)

运行结果：函数中111打印num: 100
函数中222打印num: 200
函数外面： 200

内置函数的使用

一、len()：获取数据长度

str1 = '1234444'
li = [11, 22, 33, 44, 55]
print(len(str1))
print(len(li))

运行结果：7
5
二、sum()：求和

li = [11, 22, 33, 44, 55]
tu = (11, 22, 33, 44, 55, 66)
dic = {"a": 11, "b": 22, "c": 33}
res = sum(tu) + sum(li) + sum(dic.values())
print(res)

运行结果：462
三、max()：最大值

li = [11, 22, 33, 44, 55]
res = max(li)
print(res)

运行结果：55
四、min()：最小值

li = [11, 22, 33, 44, 55]
res2 = min(li)
print(res2)

运行结果：11
五、Python数据类型（类，可作为函数使用）：int、float、bool、str、list、tuple、dict、set
1、可以转换数据类型

s = "100"
print(int(s))
num = str(10000)
print(type(num))

运行结果：100
<class ‘str’>
2、bool：获取数据的布尔值
1）Python所有的数据都有布尔值
2）非0为True：数据值等于0，或者数据值为None，或者数据的长度为0

a = '0'
print(bool(a))
a = 0
print(bool(a))
a = {}
print(bool(a))
a = [0]
print(bool(a))

运行结果：True
False
False
True

Python中高级内置函数

一、enumerate：利用它可以同时获得序列类型数据的下标和值

li = ["aa", "bb", "cc", "dd"]
res = enumerate(li)
print(list(res))

运行结果：[(0, ‘aa’), (1, ‘bb’), (2, ‘cc’), (3, ‘dd’)]

li = ["aa", "bb", "cc", "dd"]
for i, v in enumerate(li):
    print(f"下标{i},值{v}")

运行结果：下标0,值aa
下标1,值bb
下标2,值cc
下标3,值dd

二、eval：可以识别字符串中有效的python表达式（去除字符串的引号）

a = "[11,22,33,44]"
res = eval(a)  # [11,22,33,44]
print(res, type(res))

运行结果：[11, 22, 33, 44] <class ‘list’>

b = "{'a':11,'b':22}"
res2 = eval(b)  # {'a':11,'b':22}
print(res2, type(res2))

运行结果：{‘a’: 11, ‘b’: 22} <class ‘dict’>

c = "77>99"
res3 = eval(c)  # 77>99
print(res3)

运行结果：False

d = "print('hello python')"
eval(d)  # print('hello python')

运行结果：hello python

三、filter：过滤器函数

需求：获取字典中值大于30的键值对，放到一个新的字典中
1、常规做法

dic = {"aa": 11, "bb": 22, "cc": 33, "dd": 44}
new_dict = {}
for k, v in dic.items():
    if v > 30:
        new_dict[k] = v
print(new_dict)

运行结果：{‘cc’: 33, ‘dd’: 44}
2、使用filter过滤函数

dic = {"aa": 11, "bb": 22, "cc": 33, "dd": 44}
def func(x):
    return x[1] > 30
res = filter(func, dic.items())
print(dict(list(res)))

运行结果：{‘cc’: 33, ‘dd’: 44}
ps：语法filter(函数，列表):
遍历“列表”，将列表所有元素作为参数传入“函数”；
列表元素为元组，返回每个“元组”中下标为“1”且大于30的元素；
将返回的元素转化成“字典”输出
需求：过滤列表中大于30小于60的数据，生成列表

li = [11, 22, 33, 44, 55, 66, 77, 88, 99]
def func(x):
    return 60 > x > 30
res = filter(func, li)
print(list(res))

运行结果：[33, 44, 55]

四、匿名函数：lambda表达式（适用函数中只有一行代码的简单函数）

1、语法：lambda 参数：返回值
2、经常和filter过滤器函数一起使用

li = [11, 22, 33, 44, 55, 66, 77, 88, 99]
res = filter(lambda x: 80 > x > 40, li)
print(list(res))

运行结果：[44, 55, 66, 77]

五、zip()：聚合打包

需求：将上述数据转换为以下格式
1、使用for循环来实现

# users = [{'name': '小明', 'age': 18, 'gender': '男'},
#          {'name': '小李', 'age': 19, 'gender': '男'},
#          {'name': '小美', 'age': 17, 'gender': '女'}]

users_title = ["name", "age", "gender"]
users_info = [['小明', 18, '男'], ["小李", 19, '男'], ["小美", 17, '女']]
list1 = []
for item in users_info:  # 循环遍历列表users_info中的每个列表赋值给item
    dic ={}
    for i in range(len(users_title)):   
# 取列表users_title的长度3，循环赋值给i
        dic[users_title[i]] = item[i]   
# 使用字典键值对赋值方法，将列表users_title的每个元素作为key，将列表item的每个元素作为value，按照下标生成字典dic中的元素
    list1.append(dic)            
# 将生成的dic字段，添加到列表list1的尾部
print(list1)                    # 打印列表

运行结果：[{‘name’: ‘小明’, ‘age’: 18, ‘gender’: ‘男’},
{‘name’: ‘小李’, ‘age’: 19, ‘gender’: ‘男’},
{‘name’: ‘小美’, ‘age’: 17, ‘gender’: ‘女’}]
2、zip()的使用

a = ["name", "age", "gender","url","123"]
b = ['小明', 18, '男']
res = dict(zip(a,b))
print(res)

运行结果：{‘name’: ‘小明’, ‘age’: 18, ‘gender’: ‘男’}
3、使用zip()来实现需求

users_title = ["name", "age", "gender"]
users_info = [['小明', 18, '男'], ["小李", 19, '男'], ["小美", 17, '女']]
list1 = []
for item in users_info: # 取出列表中的列表
    dic = dict(zip(users_title,item)) 
# 使用第一个列表和取出的每个列表聚合，并转化成字典
    list1.append(dic) # 将聚合后的字典加入列表
print(list1)

运行结果：[{‘name’: ‘小明’, ‘age’: 18, ‘gender’: ‘男’},
{‘name’: ‘小李’, ‘age’: 19, ‘gender’: ‘男’},
{‘name’: ‘小美’, ‘age’: 17, ‘gender’: ‘女’}]