Python基础——函数的基本使用

一、定义

1、语法
def 函数名（ ）：
函数体

二、属性

1、函数在内存中准备好的代码，不会自动执行，只有手动调用时才执行，调用方式：函数名+括号；
2、函数是语句的封装；
3、函数声明时，在括号内传递参数，我们称之为形式参数（形参），只起到占位的作用；
4、函数调用时，传入的参数，我们称之为实际参数（实参）

三、操作

1、函数的参数

• 1）参数

# 1、定义一个函数，传入两个数字，求两个数的最大值，并打印
def pr_max(a, b):
    x = a if a > b else b
    print(x)
      
pr_max(34, 2)

# 2、定义一个函数，传入两个数字，求两个数的和，并打印
def pr_sum(a, b):
    print(a + b)

pr_sum(2, 3)

# 3、定义一个函数，传入一个列表，执行完这个函数以后，列表就变成有序的了

def sort_list(L):
    L.sort()

nums = [8, 0, 1, 2, 9, 5, 4]  # 值的传递都是内存地址的传递
sort_list(nums)
print(nums)

• 2）可变参数
  参数的个数不固定，就可以称为可变参数；
  在python里有两种可变参数，*args、**kwargs；
  *args：可变参数，它是把参数以元组的形式保存；
  **kwargs：可变参数，它是把参数以字典的形式保存；

# 1、求任意长度个数的数字之和
def demo(a, b, *args):
    result = a + b
    for arg in args:
        result += arg
    return result

print(demo(1, 2))
print((demo(1, 2, 3)))

• 3）缺省参数
  在函数声明时，定义形参并给形参设置一个默认值，这种参数可以称之为缺省参数；
  如果有缺省参数，缺省参数要放在非缺省参数的后面；

def demo(a, b, x='hello'):
    print('a========>{}'.format(a))
    print('b========>{}'.format(b))
    print('x========>{}'.format(x))

demo('good', 12)
demo(100, 'yes', 'xxx')
demo(x='mmm', a=100, b='ssss')

• 4）可变参数和缺省参数同时出现
  位置参数必须要放在关键字参数的前面

def demo(a, b, *args, x='hello', y='nice',**kwargs):
    print('a========>{}'.format(a))
    print('b========>{}'.format(b))
    print('args========>{}'.format(args))
    print('x========>{}'.format(x))
    print('y========>{}'.format(y))
    print('kwargs========>{}'.format(kwargs))

# 位置参数必须要放在关键字参数的前面
demo(12, 23, 100, 50, 'yes', 'no', x='qqqq', y='wwww')

names = ('zhangsan', 'lisi', 'wangwu')
person = {'name': 'zhangsna', 'age': 18}

# args为：(('zhangsan', 'lisi', 'wangwu'),)是一个元组，该元组中有一个元素，该元素是一个元组
demo(12, 34, names, x='qqqq', y='wwww')
# args为：('zhangsan', 'lisi', 'wangwu')是一个元组，元组中有3个元素，*names将元组内元素展开
demo(12, 34, *names, x='qqqq', y='wwww', **person)

• 5）传可变对象
  可变对象在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了

def changeme(mylist):
    mylist.append([1, 2, 3, 4])
    print("函数内取值: ", mylist)
    print(id(mylist))
    return


mylist = [10, 20, 30]
print(id(mylist))
changeme(mylist)
print("函数外取值: ", mylist)
print(id(mylist))


"""
1987445536456
函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
1987445536456
函数外取值:  [10, 20, 30, [1, 2, 3, 4]]
1987445536456
"""

• 6)）传不可变对象

def change(a):
    print(id(a))  # 指向的是同一个对象
    a = 10
    print(id(a))  # 一个新对象


a = 1
print(id(a))
change(a)
print(id(a))

"""
1624992800
1624992800
1624993088
1624992800
"""

2、函数返回值

• 如果一个函数没有return语句，那么这个函数的返回值的None；
• return语句后面不能再有任何的语句，因为执行不到，return表示函数的结束

# 1、计算两个数字的最大值
def get_max(a, b):
    x = a if a > b else b
    return x  # 把函数运行的结果返回给调用者

# 获取两个数字的最大数
result = get_max(12, 3)
# 拿到最大数后，乘以2
print(result * 2)

3、函数多个返回值

• 可以使用列表、元组、set设置字典等让一个函数有多个返回值结果
• 推荐使用元组（元组不可变）

# 1、求最大数以及它的坐标
def get_max_and_index(nums):
    x = max(nums)
    x_index = nums.index(x)
    print(x, x_index)

get_max_and_index([9, 4, 1, 0, 8, 5, 12, 7, 6])

# 2、求最大数以及它的坐标（用遍历）
def get_max_and_index(nums):
    x = nums[0]  # 假设第0个数最大数
    x_index = 0  # 假设最大数的下标是0
    for i, num in enumerate(nums):  # 带下标的遍历数据
        if num > x:
            x = num
            x_index = i
    # 可以使用列表、元组、set设置字典等让一个函数有多个返回值结果
    # 推荐使用元组（元组不可变）
    return x, x_index  # 当元组作为函数的返回值的时候，建议不加小括号

result = get_max_and_index([9, 4, 1, 0, 8, 5, 12, 7, 6])
print('列表里的最大数是{}，它的下标是{}'.format(result[0], result[1]))

# 用两个变量来接收函数返回值（拆包的操作）
my_max, max_index = get_max_and_index([9, 4, 1, 0, 8, 5, 12, 7, 6])
print('列表里的最大数是{}，它的下标是{}'.format(my_max, max_index))

4、多个return语句

• 一般情况下，一个函数只会执行一个return语句；
• 在某种特殊情况（finally语句）下，有可能执行多个return语句

def get_max(a, b):
    if a > b:
        return a
    else:
        return b

result = get_max(23, 5)
print(result)

5、函数调用函数

def test1():
    print('test1开始了')
    print('test1结束了')

def test2():
    print('test2开始了')
    test1()
    print('test2结束了')

test2()

6、函数的联系及注释

注释有两种格式：单行注释：#；多行注释：‘’’ 注释 ‘’’ “”“注释 “””

# 1、定义一个函数，求1~n的和
def get_sum(n):
    x = 0;
    for i in range(1, n + 1):
        x += i
    return x
    
print(get_sum(100))
# 2、定义一个函数，传递参数n，求5==>1 + 1+2 + 1+2+3 + 1+2+3+4 + 1+2+3+4+5
def get_total(n):
    x = 0
    for i in range(1, n + 1):
        x += get_sum(i)
    return x

print(get_total(5))

7、局部变量和全局变量

a = 100  # 全局变量：在整个py文件里都能够被访问

def test():
    b = 45  # 在函数内部声明的变量，称之为局部变量：只能在函数内部访问
    print('a的结果是====>{}'.format(a))
    print('b的结果是====>{}'.format(b))

test()
print('函数外a是===>{}'.format(a))

8、数据的传递

• 在python里，任何的值传递都是内存地址的传递
• 如果修改了数据，内存地址没有发生变化，认为它是可变类型
• 如果修改了数据，内存地址发生了变化，认为它是不可变类型

def test(x):
    x = 10
    
a = 20
test(a)
print(a)  # a=20，数字是不可变类型

def demo(x):
    x[0] = 100

nums = [1, 2, 3]
demo(nums)
print(nums)  # nums=[100,2,3]

9、lambda表达式

• 匿名函数：用lambda关键词能创建小型匿名函数，这种函数得名于省略了用def声明函数的标准步骤；
• lambda函数的语法只包含一个语句： lambda 参数列表：运算表达式；
• 用处：lambda表达式，即匿名函数，一般用于把一个函数当做参数使用
• 1、栗子

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

# 函数也是一种数据类型
a = 12
b = 'hello'
x = add  # 给函数起了个别名
add(1, 2)
print(x(1, 2))
fn = lambda a, b: a + b
print(fn(2, 3))

• 2、栗子，求两数最大值

# def get_max(m, n):
#     return m if m > n else n

def test(a, x, y):
    result = a(x, y)
    print(result)

# test(a=get_max, x=4, y=5)
test(lambda m, n: m if m > n else n, 4, 30)

• 3、栗子，匿名函数的使用——sort、sorted

# 1）简单排序
# nums = [5,9,1,3,7,8,6,2,4]
# nums.sort()
# print(nums)

# 2）列表中为字典，需要告诉按照哪个条件进行排序
persons = [
    {'name': 'zhangsan', 'age': 19},
    {'name': 'lisi', 'age': 20},
    {'name': 'jerry', 'age': 17},
    {'name': 'herry', 'age': 22},
    {'name': 'merry', 'age': 14},
    {'name': 'tony', 'age': 23},
]

def demo(element):
    # print(element)
    return element['age']

persons.sort(key=demo)

# 若是降序排序
persons.sort(key=demo, reverse=True)

# 若使用lambda表达式，注释掉def demo( )函数
persons.sort(key=lambda element: element['age'])

# sorted( )按特定顺序显示列表元素，但不影响它们在列表中的元素排列顺序,只是函数的返回值变了
print(sorted(persons, key=lambda element: element['age']))
print(persons)

• 4、栗子，匿名函数的使用——filter
  filter(function or None, iterable) --> filter object

# 求列表中偶数
# 1）使用循环
nums = [5, 9, 1, 3, 7, 8, 6, 2, 4]
x = []
for num in nums:
    # if num % 2 == 0:
    # 如果num % 2 结果为 0 说明能被2整除；在Python中 数值是可以被当作真/假值处理的，默认情况下；非空非0时为true；0或空时为false
    if not num % 2:
        x.append(num)
print(x)

# 2）用filter过滤
nums = [5, 9, 1, 3, 7, 8, 6, 2, 4]
def test(element):
    return element % 2 == 0

# list((1,2,3))===>1,2,3
result = list(filter(test, nums))
print(result)

# 3）用lambda表达式，注释掉test（）函数
nums = [5, 9, 1, 3, 7, 8, 6, 2, 4]
result = list(filter(lambda element: not element % 2, nums))
print(result)

• 5、map
  可迭代对象操作函数的区别：
  1）map和filter在python2里是内置函数，返回值结果就是一个列表；在python3里，map和filter变成了内置类，结果时map和filter对象，而不再是list列表；

# 5、求列表中数字的平方
nums = [1, 2, 3, 4, 5, 6]

# 1）使用循环
# a = []
# for num in nums:
#     a.append(num ** 2)
# print(a)

# 2）用map
def fn(element):
    return element ** 2

result = list(map(fn, nums))
print(result)

# 3）用lambda表达式
result = list(map(lambda element: element ** 2, nums))
print(result)

• 6、reduce
  1）reduce在python2里是内置函数，不需要额外的导入模块；在python3 里需要额外导入functiontools模块
  For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates ((((1+2)+3)+4)+5)

# 1、
from functools import reduce
# 1）
# nums = [1, 2, 3, 4, 5, 6]

def foo(a, b):
    print('a===={},b===={}'.format(a, b))
    return a + b

print(reduce(foo, nums))

# 2）用lambda表达式
print(reduce(lambda x, y: x + y, [1, 2, 3, 4, 5, 6]))

# 2、
from functools import reduce

persons = [
    {'name': 'zhangsan', 'age': 19},
    {'name': 'lisi', 'age': 20},
    {'name': 'jerry', 'age': 17},
    {'name': 'herry', 'age': 22},
    {'name': 'merry', 'age': 14},
    {'name': 'tony', 'age': 23},
]

def bar(x, y):
    if isinstance(x, dict):
        return x['age'] + y['age']
    return x + y['age']

print(reduce(bar, persons))