一、recode

---------# import random
from random import randint

3. 编写一个函数，实现摇骰子的功能，打印n个骰子的点数和。

def play_dice(n):
sum1 = 0
for _ in range(n):
num = randint(1, 6)
print(num)
sum1 += num

return sum1

print(play_dice(2))

4. 编写一个函数，交换指定字典的key和value。

-----# 如:{'a':1, 'b':2, 'c':3} ---> {1:'a', 2:'b', 3:'c'}

def change_key_value(dict1:dict):

for key in dict1.copy():
    # 通过key拿到值
    value = dict1[key]
    # 删除原来的键值对
    del dict1[key]
    # 将值作为key,键作为value，添加键值对
    dict1[value] = key

"""
copy: {'a': 1, 'b': 2, 'c': 3, 'd': 4}
原：{ 1:'a', 2:'b', 3:'c', 4:'d' }
key = 'a'  value=1  dict1[1]='a'
key = 'b'  value=2  dict1[2]='b'
....

"""

dict11 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
change_key_value(dict11)
print(dict11)

5. 编写一个函数，提取指定字符串中的所有的字母，然后拼接在一起后打印出来。

------# 如:'12a&bc12d--' ---> 打印'abcd'
def connect(str1:str):
mstr = ''
for char in str1:
if char.isalpha():
mstr += char

return mstr

print(connect('12a&bchu23juj12d--'))

9.写一个函数，求指定列表中，指定的元素的个数 。

def yt_count(list1:list, item):
count = 0
for x in list1:
if x == item:
count += 1
return count

print(yt_count([1, 34, 56, 7, 1, 3, 1], 17))

10.写一个函数，获取指定列表中指定元素对应的下标(如果有多个，一起返回)

def yt_index(list1, item):
indexs = []
for index in range(len(list1)):
x = list1[index]
if x == item:
indexs.append(index)
return indexs

print(yt_index([1, 34, 56, 7, 1, 3, 1], 1))

二、匿名函数

1.普通函数:

def 函数名(参数列表):
函数体

2.匿名函数:

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

说明：
函数名 -> 变量名
lambda -> 关键字
参数列表 -> 参数名1, 参数名2...
: -> 固定的
返回值 -> 相当于只有一个return语句的函数体

匿名函数的调用和普通函数一样：函数名(实参列表),也支持位置参数、关键字参数、参数设置默认值、不定长参数
"""
------# 写一个匿名函数，功能是求两个数的和
sum1 = lambda num1=10, num2=3: num1+num2

print(sum1(10, 20))
print(sum1(num1=100, num2=200))
print(sum1())

sum11 = lambda *nums: sum(nums)
print(sum11(1, 2, 3))

----# 相当于上面的匿名函数
---# def sum1(num1, num2):
---# return num1+num2

----# 练习：求1+2+3+...+n的和

sum2 = lambda n: sum(range(n+1))
print(sum2(100))

-----# 练习：读程序
funcs = []
for item in range(1, 5):
funcs.append(lambda x: x*item)
print(item)

"""
item = 1 ~ 4
item = 1 [lambda x: xitem]
item = 2 [lambda x: xitem, lambda x: xitem]
item = 3 [lambda x: xitem, lambda x: xitem, lambda x: xitem]
item = 4 [lambda x: xitem, lambda x: xitem, lambda x: xitem, lambda x: xitem]
"""
print(funcs0) # 24 8
print(funcs1) # 24 8

三、变量的作用域

1.变量的作用域

变量的作用域指的是变量能够使用的范围

2.全局变量

全局变量:声明在函数和类的外面的变量都是全局变量；作用域是从声明开始，到整个py文件结束（任何地方都可以使用）
"""
-----# a 是全局变量
a = 10

-----# x和b都是全局变量
for x in range(5):
b = 10
print(x)

---# c是全局变量
for x in range(5):
for y in range(4):
c = 100

print(c)

"""

3.局部变量

声明在函数和类中的变量都是局部变量。声明在函数的局部变量，作用域是从声明开始到整个函数结束
"""
---# 全局变量
a1 = 100

def fun1():
# 局部变量
aa = 100
print(aa, a1)
for xx in range(5):
print(aa+xx)

fun1()
----# print(aa) # NameError: name 'aa' is not defined

"""

4.global关键字

在函数中说明一个变量是全局变量

注意：只能在函数中使用
"""
---# 全局变量
name = 'abc'

def func2():
global age
age = 18

global name    # 说明当前函数中使用的name是全局变量name
name = 'aaa'
print(name)

func2()
print(name)
print(age)

"""

5.nonlocal关键字

想要在局部的局部中修改局部变量的值
"""
def func3():
abc = 100
def func4():
nonlocal abc
abc = 200
print('f4:', abc)
func4()
print('f3:', abc)

func3()

四、函数作为变量

声明函数就是声明一个类型是function的变量, 函数名实质就是变量名。
"""

def func1():
print('====')

print(type(func1))

"""

1.变量可以给其他变量赋值

"""
a = 10
b = a
print(b*10)

list1 = [1, 2]
list2 = list1
list2.append(100)
print(list2)

func1 = lambda x: print(x)
func2 = func1
func2(10)

---# 声明一个变量func11，类型是function
def func11():
print('我是函数')
---# 用一个函数给变量a赋值，a也是一个函数
a = func11
a()
print(a)

---# 将函数func11的返回值给b，b的值是None
b = func11()
print(b)

"""

2.函数作为列表的元素

"""
a = 10
list1 = [1, a]
print(list1, list1[1]+100)

def func22():
print('我又是函数')
return 10

list2 = [1, func22, func22()]
print(list2)

---# list2[1]取到一个函数, 通过后面加()调用函数
print(list21)

---# list2[2]取到的是整数10
print(list2[2]+100)

"""

3.将函数作为参数

"""
a = 10
def func1(n):
print(n)

func1(a)

def func11(n):
# n = func12
n() # func12()

def func12():
print('hello world')

re = func11(func12)

---# 应用：sort的使用
"""
列表.sort(key=None, reverse=False)
使用sort的时候,可以通过给key赋一个函数变量，来规定列表中的元素按照什么标准来排序。
这儿的函数变量要求要有一个参数和一个返回值。参数代表列表中的元素，返回值代表按照那个标准排序
"""

list1 = [1, 45, 8, 89]
list1.sort()
print(list1)

list2 = [
{'name': '张三', 'age': 20, 'score': 90},
{'name': '李四', 'age': 28, 'score': 70},
{'name': '王五', 'age': 18, 'score': 89}
]
---# 根据成绩排序
---# def get_age(item):
---# return item['score']
---# list2.sort(key=get_age)
list2.sort(key=lambda item: item['score'])
print(list2)

list3 = [
('a', 20),
(10, 3),
('b', 90)
]
---# def second(item):
---# return item[1]
---# list3.sort(key=second, reverse=True)
---# print(list3)

list3.sort(key=lambda item: item[1])
print(list3)

"""

4.将函数作为返回值

"""

----# 根据运算符号，返回对应的功能
def operation(operator: str):
if operator == '+':
def add(*args, **kwargs):
"""求和"""
"""
args=(10, 20)
kwargs = {'a':2, 'b':3}
"""
sum1 = 0
for item in args:
sum1 += item
for key in kwargs:
sum1 += kwargs[key]
return sum1
return add

elif operator == '*':
    def func2(*args, **kwargs):
        """求乘积"""
        sum1 = 1
        for item in args:
            sum1 *= item
        for key in kwargs:
            sum1 *= kwargs[key]
        return sum1
    return func2

f1 = operation('+') # f1就是有两个不定长参数，功能是求和的函数
re = f1(10, 20, a=2, b=3)
print(re)

print(operation('+')(10, 20, a=2, b=3))
print(operation('*')(1, 2, 3, 4))

五、函数的调用

1.补充：python中的函数可以有多个返回值

"""

求多个数的和以及平均值

def yt_sum(*nums):
sum1 = sum(nums)
average = sum1 / len(nums)
return sum1, average # 同时返回和、平均值

a, b = yt_sum(2, 45, 67, 90, 0)
num = yt_sum(34, 56, 67, 34, 56)
print(a, b)
print(num[0], num[1])

"""

2.函数的调用过程是一个压栈的过程

每次调用函数的时候，系统都会在内存中(栈)开辟空间来存储函数执行过程中产生数据(函数中声明的变量)。
当函数调用完成后，这块内存会自动销毁。
"""

六、递归函数

1.什么是递归函数

递归函数：函数中调用函数本身，这样的函数就是递归函数(自己调自己)

循环能做的事情递归都可以做，但是实际上循环能解决的问题绝对不选递归
"""

def func1():
print('==')
func1()

"""

2.怎么写递归函数

第一步：确定临界值(循环结束的条件), 让函数结束
第二步：找关系,假设函数的功能已经实现，找f(n)和f(n-1)的关系
第三步：根据关系，用f(n-1)实现f(n)的功能
"""

"""
yt_sum(5) n=5 5!=1 return yt_sum(4)+5
yt_sum(4) n=4 4!=1 return yt_sum(3) + 4
yt_sum(3) n=3 3!=1 return yt_sum(2) + 3
yt_sum(2) n=2 2!=1 return yt_sum(1) + 2
yt_sum(1) n=1 1==1 return 1
"""
----# 写一个递归函数，实现：1+2+3+...n
def yt_sum(n):
# 1.找临界值
if n == 1:
return 1

# 2.找关系
"""
yt_sum(n) = 1+2+3+...+n
yt_sum(n-1) = 1+2+3+...+n-1
yt_sum(n) = yt_sum(n-1)+n
"""
# 3.用f(n-1)实现f(n)的功能
return yt_sum(n-1) + n

print(yt_sum(5))

----# 用递归实现以下功能
"""
n = 3

**

n = 4

**

f(n)和f(n-1)的关系：
先打印n颗星
f(n-1)
"""

def print_star(n):
if n == 1:
print('*')
return

print('*'*n)
print_star(n-1)

print_star(5)

"""
n = 3

**

n=4

**

"""

总结：递归，能不用就不用！！