Day 11 函数进阶

Day 11 函数进阶

1.返回值

1.什么是返回值

从函数内部传递到函数外部的数据就是返回值

2.什么时候函数需要返回值（新手）

如果实现函数的功能产生了新的数据，那么函数就需要通过返回值把新产生的数据返回

3.怎么将数据返回

1）怎么确定返回值

return后面的值就是返回值（如果没有return，默认返回None）

2）怎么获取函数返回值

函数调用表达式的值就是函数返回值

def sum1(a,b):
    return a+b    # a+b的结果就是返回的数据


s = sum1(10, 20)  # sum1(10,20)也是函数反回值就是30
print(s)

如果函数中没遇到return,返回值就是None

def print_star():
    print('*************')

s1 = print_star()
print(s1)

4.怎么使用函数返回值

返回值能做的，函数表达式都能做

def func1():
    return 'abc'


print('abc')
print(func1())

a = 'abc'
print(a)
b = func1()
print(b)

print('abc'[-1])
print(func1()[-1])   # print('abc'[-1])

list1 = ['abc', 100]
list2 = [func1(), 100]
print(list2)    # ['abc', 100]

print(func1().join('123'))   # print('abc'.join('123'))

dic1 = {func1(): 123}
print(dic1)    # {'abc': 123}


def func2(string: str):
    return list(string)


print(func2('abc'))

re = func2('abc')
re.append(100)
print(re)   # ['a', 'b', 'c', 100]

5. return的使用(只能在函数体里使用)

1.需要将函数中产生的数据返回时候使用return: return 需要返回的数据

2.提前结束函数（执行函数体的时候如果遇到return，函数直接结束）

def func3():
    print('=====')
    print('-----')
    print('******')
    return 100


result = func3()
print(result)

# 练习：写一个函数，给一个整数，如果这个数是偶数就计算这个数的阶乘，否则计算这个数的立方值。
def operation(num: int):
    if num & 1:
        return num ** 3
    else:
        s3 = 1
        for x in range(1, num+1):
            s3 *= x
        return s3

result = operation(3)
print(result)

2.全局变量和局部变量

根据变量的作用域（能使用的范围）的不同分为全局变量和局部变量

1.全局变量

没有定义在函数里面或者类里面的变量都是全局变量。全局变量的作用域是从定义开始到程序结束。

a = 10    # a是全局变量
if True:
    print(f'if语句中:{a}')
for _ in range(3):
    print(f'循环中：{a}')


def func1():
    print(f'函数中:{a}')


func1()


# b和x都是全局变量
for x in range(3):
    b = 100

print(f'函数外面b:{b},{x}')


def func2():
    print(f'函数里面b:{b},{x}')


func2()

2.局部变量

定义在函数中的变量就是局部变量（形参也是局部变量）。局部变量的作用域是从定义开始到函数结束。

def func3(m, n):
    # m = 10, n = 20
    s = m + n
    d = 100
    print(m, n, d)


func3(10, 20)
# print(m, n)
# print(d)

3. global

global 和return都是只能在函数体中使用的关键字

不能直接在函数内部修改全局变量的值，他会在函数内部创建一个对应的局部变量，导致修改失败。

1）global可以在函数内部修改全局变量的值

2）在函数内部定义一个全局变量

age = 18


def func4():

    global age
    age = 20     # 修改变量age
    print(f'函数内部的年龄:{age}')

    global name
    name = '小明' # 定义全局变量

func4()
print(f'函数外部的年龄:{age}, {name}')

3.匿名函数

1.什么是匿名函数

匿名函数还是函数，匿名函数可以看成是函数体只有一条语句的函数的简写方式

定义匿名函数的语法：（不支持参数种类）

函数名 = lambda 参数列表：返回值

相当于：
def 函数名(参数列表):
    return 返回值

func1 = lambda x: x*2
# def func1(x):
#     return x*2
print(func1(10))
print(func1(x=100))


func2 = lambda x, y=10: x+y
# def func2(x, y=10):
#     return x+y
print(func2(2))
print(func2(100, 200))


# 练习：写一个匿名函数判断指定的年是否是闰年
is_leap_year = lambda year: year % 4 == 0 and year % 100 != 0 or year % 400 == 0
print(is_leap_year(2001))

4. 函数就是变量

1.函数就是变量

1. python中定义函数其实就是定义一个类型是function的变量，函数名就是变量名。

a = 10
b = 'abc'
c = [10, 20]
d = {'a': 10, 'b': 20}
# e = lambda x: x*2
def e(x):
    return x*2

2. 普通变量能做的函数都可以做

x = [10, 20, 30]
def func1():
    print('函数1')

# 打印变量
print(x)
print(func1)

# 查看变量类型
print(type(x))    # <class 'list'>
print(type(func1))    # <class 'function'>

# 查看变量的id
print(id(x))        # 4302411904
print(id(func1))    # 4302849360

# 用一个变量给另外一个变量赋值
y = x
y.append(100)

z = func1
z()
# x = 'abc'
# func1 = 200

2.高阶函数

1）.实参高阶函数

如果一个函数的某个参数是函数，那么这样的函数就是实参高阶函数

2）返回值高阶函数

如果一个函数的返回值是函数，那么这个函数就是返回值高阶函数

def func3(x):
    print(x() + 10)


def f1(a=10, b=20):
    return 12.4


func3(f1)
func3(lambda a=10, b=20: 12.4)

3.系统实参高阶函数

1）max、min

参数key要求传一个函数，可以通过这个函数来确定比较大小的时候的比较标准。

key的要求：

a.是一个函数

b.这个函数必须有且只有一个参数（这个参数就相当于序列中的每个元素）

c.这个函数需要一个返回值（返回值就是比较标准）

nums = [78, 67, 55, 18, 29]
# 求元素值最大的元素
result = max(nums, key=lambda item:item)
print(result)
# 求nums中个位数最大的元素
result = max(nums, key=lambda item:item % 10)
print(result)
# 求各个位上上的数字和最大的元素（普通函数给函数名就可以了）
def f(item):
    s = 0
    for x in str(item):
        s += int(x)
    print(f'item:{item}')
    return s


result = max(nums, key=f)
print(result)   # 88


nums = [123, '78', 89, '345']
# 获取nums数值最大的元素
result = max(nums, key=lambda item: int(item))
print(result)

2)sorted

nums = [78, 67, 55, 18, 29]
# 对nums按照个位数的大小从到大排序：[55, 67, 78, 18, 29] / [55, 67, 18, 78, 29]
new_nums = sorted(nums, key=lambda item: item % 10)
print(new_nums)   # [55, 67, 78, 18, 29]


students = [
    {'name': 'stu1', 'age': 23, 'score': 89},
    {'name': 'stu2', 'age': 18, 'score': 98},
    {'name': 'stu3', 'age': 24, 'score': 100},
    {'name': 'stu4', 'age': 30, 'score': 27},
    {'name': 'stu5', 'age': 10, 'score': 78}
]
# 1）获取students年龄最小的学生(用min)
result = min(students, key=lambda item: item['age'])
print(result)
# 2）按照分数对students从大到小排序
students.sort(key=lambda item: item['score'], reverse=True)
print(students)

3)map——对序列中的元素进行变换或者合并

用法一：map(函数，序列)——将原序列中的元素，按照函数给定的标准转换成新的序列。

函数的要求：a.是一个函数

​ b.有一个参数（指向后面这个序列中的元素）

​ c.需要一个返回值（返回值就是新序列中的元素）

练习：获取 nums 中所有元素的个位数

nums = [19,89,78,56,47,34,74]
result = map(lambda item:item % 10,nums)
print(list(result))

用法二 ：map(函数，序列1，序列二)

用之前需要写from functools import reduce

函数的要求：a.是一个函数

​ b.有两个参数（分别指向后面序列中的元素）

​ c.返回值（返回值就是新序列中的元素）

# 产生一个新的序列，序列中的每个元素是math和chinese的分数和:  socres = [29, 43, 64, 96, 84]
math = [19, 23, 34, 56, 34]
chinese = [10, 20, 30, 40, 50]
result = map(lambda item1, item2: item1 + item2, math, chinese)
print(list(result))   # [29, 43, 64, 96, 84]

# 练习：将以下两个列表按照下面的要求转换字典： {'苹果': 1823, '小爱同学':22221, '耳机': 891, '天猫精灵': 78}
names = ['苹果', '小爱同学', '耳机', '天猫精灵']
nums = [1823, 22221, 891, 78]

result = map(lambda item1, item2:(item1, item2), names, nums)
print(list(result))

nums1 = [19, 78, 778, 90]
nums2 = [1, 89, 9, 2]
nums3 = [20, 23, 1, 119]
# [19120, 788923, 77891, 902119]
result = map(lambda x, y, z: int(f'{x}{y}{z}'), nums1, nums2, nums3)
print(list(result))

4)reduce——按照制定规则对序列中的元素进行合并操作

用法一：

语法：reduce(函数，序列，初始值)

函数的要求：a.函数

​ b.有且只有两个参数（第一个参数第一次指向初始值，从第二次开始指向上一次的计算结果；

​ 第二个参数只想序列中的每个元素）

​ c.有一个返回值（返回值决定合并规则）

# 求所有元素的和
nums = [23,34,45,67,78,96]
result = reduce(lambda x, y:x+y,nums,0)
# x=0
# 练习1：求所有的数的个位的和
nums = [23, 34, 56, 67, 8]
result = reduce(lambda x, y: x + y % 10, nums, 0)
print(result)
# 练习2：求所有的元素的数值和
nums = [23, '78.9', 9, '10']
result = reduce(lambda x, y: x+float(y), nums, 0)
print(result)
# 练习3：求所有数字的乘积
nums = [23, 8.9, 'abc', True, '2']
result = reduce(lambda x, y: x*(y if type(y) == int or type(y) == float else 1), nums, 1)
result = reduce(lambda x, y: x*(y if type(y) in [int, float]else 1), nums, 1)
print(result)