python函数应用

一、函数的作用

封装代码，代码重用

二、定义函数

def 函数名（参数）:

    代码1

    代码2

调用函数

函数名()

返回值

def add():
return '言'

sum = add()
print(sum)

返回值的应用

def sum1(a, b):
return a + b

rest = sum1(1, 2)
print(rest)

---

函数的说明文档

help()    #help函数的作用：查看函数的说明文档（函数的解释说明的信息）

案例：

help(len)

#运行结果
#Help on built-in function len in module builtins:
len(obj, /)
    Return the number of items in a container.

结果

快速体验

def sum1(a, b):
"""求和函数"""
return a + b

rest = sum1(1, 2)
print(rest)

help(sum1)

结果

---

函数嵌套调用

# B函数
def testB():
print('B函数开始----')
# 嵌套调用B
print("这是B函数")
print('B函数结束----')


#A函数
def testA():
print('A函数开始----')
#嵌套调用B
testB()
print('A函数结束----')
testA()

案例1：

# 打印五条条行线
def print_line():
print('_ ' * 20)

def print_lines(num):
i = 0
while i < num:
print_line() #调用上方函数
i += 1

print_lines(5)

案例2：

# 函数计算
# 1.求三个数之和
def sum_num(a,b,c):
return a + b + c

result = sum_num(1,2,3)
print(result)

# 2.求三个数平均值
def average_num(a,b,c):
sumResult = sum_num(a , b, c) #调用上方函数
return sumResult / 3

result_avg = average_num(1,2,3)
print(result_avg)

---

变量作用域

局部变量

所谓局部变量是定义在函数体内部的变量，即只在函数体内部生效。

#定义函数，声明一个变量：函数体内部访问、函数体外面访问
def testA():
a = 100
print(a) #函数体内部访问，能访问到a变量

testA()

注意a定义在testA()函数内部的变量，在函数外部访问则立即报错。

局部变量的作用：在函数体内部，临时保存数据， 即当函数调用完成后，则销毁局部变量。

全局变量

a = 100
print("我是全局变量a",a)

def testB():
b = a
print("这是test里的a变量",a)

testB()

修改变量的值

a = 100
print("我是全局变量a",a)

def testB():
a = 200 #局部变量
print("这是test里的a变量",a)

testB()
print("我也是全局变量a，没有被修改",a)

使用global修改全局变量

a = 100
print("我是全局变量a",a)

def testB():
global a #声明a为全局变量
a = 200 #
global b #声明全局变量
b = 500
print(b)
print("这是test里的a变量",a)

testB()
print("被修改后的全局变量a",a)

print(b)

---

多函数程序执行流程

glo_num = 0

def test1():
global glo_num
glo_num = 100

def test2():
print(glo_num)

print(glo_num) #修改的函数没有执行

test1()
test2()
print(glo_num)

结论：随着函数的推进，数据会发生变化

返回值作为参数传递

def test1():
return 50

def test2(num):
print(num)

#1.保存函数test1的返回值
result = test1()
# print(result)
#2.将函数返回值所在变量作为参数传递到test2函数
test2(result)    #50

一个函数多个返回值的写法

def return_num():
# return 1,2 #返回的是元组
#return 后面可以直接书写 元组 列表 字典，返回多个值
# return (10,20)
# return [100,200]
return {'name':'Python','age':30}


result = return_num()
print(result)

注意：

1.return a , b写法，返回多数据的时候，默认是元组类型。

2.return 后面可以直接书写 元组 列表 字典，返回多个值

函数的参数

位置参数：调用函数时根据函数定义的参数位置来传递参数。

def user_info(name,age,gender):
print(f"我叫{name}，今年{age}岁了，性别是{gender}")

user_info('Tom',18,'男')

注意：传递和定义参数的顺序及个数必须一致

关键字参数——不区分先后顺序

写法：键=值

def user_info(name,age,gender):
print(f"我叫{name}，今年{age}岁了，性别是{gender}")


user_info('Tom', gender='男', age=18)

注意：函数调用时，如果有位置参数，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序。

缺省参数

为参数提供默认值，调用函数时可不传入该默认参数的值：所有位置参数必须出现在默认参数前，包括函数定义和调用。

def user_info(name,age,gender='男'):
print(f"我叫{name}，今年{age}岁了，性别是{gender}")


user_info('Tom', age=18, gender='女') #我叫Tom，今年18岁了，性别是女

注意：函数调用时，如果为缺省参数传值则修改默认参数值；否则使用这个默认值。

---

不定长参数

不定长参数也叫可变参数，用于用于不确定调用的时候会传递多少个参数的场景。

这时可以用包裹（packing）位置参数，或者包裹关键字参数，来进行参数传递，会显得非常的方便。

包裹位置传递—返回的是元组

# 当不知道传递多少参数时可以使用包裹位置传递
def user_info(*args):
print(args)


user_info('gyq')
user_info('gyq','123')
user_info('gyq','123',00)#('gyq', '123', 0)

注意：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple)，args是元组类型， （这个单词可以换成其他任意单词），这就是包裹位置传递。

包裹关键字传递— 返回的是字典

def user_info(**kwargs):
print(kwargs)

user_info(name='TOM',age=18,id=1)#{'name': 'TOM', 'age': 18, 'id': 1}

结论：

1.无论是包裹位置传递还是包裹关键字传递，都是一个组包的过程。

2.收集零散数据组成一个整体叫组包。

拆包和交换变量值

拆包：元组

def return_num():
return 100, 200


return_num1,return_num2 = return_num()
print(return_num1)
print(return_num2)

拆包：字典

dict1 = {'name':'TOM','age':18}
a,b = dict1

# 取出来的是key
print(a) #name
print(b) #age

# 找到对应的key所对应的值
print(dict1[a]) #TOM
print(dict1[b]) #200

---

引用

可以先把引用当成一个变量名

id()函数可以显示内存id地址（十进制值）

aa=[10,20]
bb=aa

print(id(aa))
print(id(bb))

aa.append(30)
print(bb) #[10, 20, 30]

print(id(aa))
print(id(bb))

# 执行结果
# 1551394103944
# 1551394103944
# [10, 20, 30]
# 1551394103944
# 1551394103944

结论：即使修改列表后id地址值仍然不变，说明是引用传递。

可变和不可变类型

数据能够直接进行修改，如果能直接修改那么就是可变，否则是不可变。

• 可变类型
  • 列表
  • 字典
  • 集合
• 不可变类型
  • 整形
  • 浮点型
  • 字符串
  • 元组