July 25-day10-Python函数2

函数的返回值

1. 函数的返回值：
   a.就是函数返回给调用者的值
   b.就是return关键字后面的表达式的值
   c.就是函数调用表达式的值

python中每个函数都是有返回值的，返回值就是return后面的值。
如果函数中没有return，那么函数的返回值就是None

• 函数的调用：
  a.先回到函数调用的位置
  b.用实参给形参赋值（传参）
  c.执行函数体
  d.执行完函数体，将返回值返回给函数调用表达式
  e.回到函数调用的位置
• 函数的函数体只有在调用后才会执行

2. return关键字
   a.将return后面的值，返回给函数调用表达式
   b.结束函数

3. 函数调用表达式：
   python中每个函数调用表达式的都是有值（）

def func1():
    print('aaaa')

a = func1()      #函数调用表达式
print(a, func1())

def my_sum1(a , b):
    a, b=b,a
    print(a)
    print(b)
    return (a + b)
print(my_sum1(10,20))

# 练习：写一个函数，判断指定的年龄是否属于成年人（返回结果）

def is_adult(age):
    if age >= 18:
        return True
    else:
        return False

if is_adult(17):
    print('可以进网吧')
else:
    print('未成年人禁止入内')

person = {'name': '帅哥','is_adult': is_adult(19)}
print(person)
结果：
aaaa
aaaa
None None
20
10
30
未成年人禁止入内
{'name': '帅哥', 'is_adult': True}

4. 函数的结束：
   a.函数体执行完
   b.遇到retur

def func2():
    print('123')
    return
print(func2())
结果：
123
None

• 写一个函数，下载指定地址对应的数据
  def download(url):
  if 判断有没有网：
  return

  写网络请求
  请求数据
  保存数据

# 练习：写一个函数，求1+2+3+...+n，和不能大于10000
def my_sum1():
    sum1 = 0
    x = 1
    while True:
        if sum1 + x >= 10000:
            return (sum1,x-1)   #python中函数可以有多个返回值，在return后面返回多个值，每个值之间用逗号隔开。
                                #返回值是一个元组
        sum1 += x
        x += 1
print(my_sum1())
结果：
(9870, 140)

作用域

作用域：一个变量可以使用的范围，就是这个变量的作用域（函数和类可以影响变量的作用域）

全局变量：从声明开始，到文件结束都可以使用
局部变量：在函数中声明的变量是局部变量。作用域是从声明开始到函数结束

1. 全局变量

a = 10    #这是一个全局变量
print(a)
def func1():
    print(a)

for x in range(10):
    b = 100
    print(a)
    print(b)
结果：
10
10
100
10
100
10
100
10
100
10
100
10
100
10
100
10
100
10
100
10
100

2. 局部变量

def func3():
    aaa = 200
    print(aaa)
func3()
结果：
200

3. global和nonlocal
   global:在函数中声明一个全局变量

• 格式：
  global 变量名
  变量名 = 值

abc = 'abc'    #全局变量
bcd = 'bcd'
def func4():
   abc = 'aaa'
   print(abc)

   global bcd
   bcd = 300
   print(bcd)

func4()
print(abc)
print(bcd)
结果：
aaa
300
abc
300

• 练习：声明一个变量，统计一个函数调用的次数

count = 0
def mu_func():
    global count
    count += 1
    print('sss')
mu_func()
print(mu_func())
结果：
sss
sss
None

4. nonlocal ：在局部变量中，去声明一个局部变量

def func11():
    ab = '****'
    print('外部',ab)
    mu_func()
    #python中函数里面可以声明函数
    def func12():
        ab = '100'
        print('内部',ab)
        print('内部函数')
    func12()
func11()
结果：
外部 ****
sss
内部 100
内部函数

匿名函数

• 匿名函数：本质函数，以另外一种简单的方式来声明
• 匿名函数的声明：
  函数名 = lambda 参数列表：返回值 --->结果是一个函数变量

# 写一个函数计算两个数的和
def my_sum1(x, y):
    return x+y

print(my_sum1(10, 20))
# 匿名函数
my_sum2 = lambda x, y:x+y

print(my_sum2(10, 20))

funcs = []
for i in range(5):
    funcs.append(lambda x:x*i)

print(funcs[2](2))
print(funcs[4](2))
"""
i = (0,1,2,3,4)
i = 0
[lambda x:x*i,lambda x:x*i,lambda x:x*i,lambda x:x*i,lambda x:x*i]
所以为
8
8
"""
结果：
30
30
8
8

函数当做变量

1.声明一个函数就是在声明一个变量。函数名可以当成变量来使用。
可以打印，可以赋值，可以查看类型，可以作为函数的返回值

a = 10
a = 'a'
print(a)


# 函数名func1可以当成变量使用
def func1(a):
    print(a)
    return 10

print(func1,type(func1))

# 将函数func1赋给变量a，这个时候a就是一个函数
a = func1
b = func1(10) + 100
print(b)
a('aaa')

# 将函数func1作为列表的元素
functions = [func1]
functions[0]('========')
结果：
a
<function func1 at 0x002EBBB8> <class 'function'>
10
110
aaa
======== 

2. 将函数作为参数

def my_sum(*number):
    sum1 = 0
    for item in number:
        sum1 += item
    return sum1

def my_mul(*numbers):
    sum1 = 1
    for item in numbers:
        sum1 *= item
    return sum1

def operation(method, x, y):
    return method(x, y)

results = operation(my_sum, 10, 20)
results3 = operation(lambda x,y:x>y,10, 20)
results4 = operation(lambda x,y: x if x > y else y,10, 20)
print(results,results3,results4, operation(my_mul,10,20))
结果：
30 False 20 200

• python中三目运算符
  值1 if 表达式 else 值2 --->判断表达式是否为True，为True整个表达式的结果是‘值1’，否则是‘值2’

x = 22
y = 32
a = x if x > y else y
print(a)
结果：
32

3.将函数作为函数的返回值

• 写一个函数有个参数，要求传入一个运算符号（+，-，*，>,<），返回符号对应的功能

• ---> 求和功能

• ---> 求差功能

def get_method(char):
    if char == '+':
        def func(x,y):
            return x+y
        return func
    elif char == '-':
        return lambda x,y:x-y
    elif char == '*':
        return lambda x,y:x*y
    elif char == '>':
        def func(m,n):
            return m>n
        return func
    elif char == '<':
        return lambda x,y:x<y
    else:
        def func(x,y):
            return None
        return func
print(get_method('+')(10, 20))
print(get_method('>')(10, 20))
print(get_method('&')(10, 20))
结果：
30
False
None

递归函数

1.什么是递归
递归函数：在函数的函数体中调用函数本身
理论上循环能做的事情，递归都可以
对递归的要求：能不用就不用
函数调用的过程是一个压栈的过程（每调用一次函数，系统都要为其分配内存空间，
用来存储函数中声明变量和参数等，这个内存在函数调用结束后会自动销毁）

这个函数就是递归函数
def fun1():
    print('===')
    fun1()
结果：
一直打印===进入死循环

2. 怎么写一个递归函数

• a.找临界值（跳出循环）#一般为最小值
• b.找关系：假设当前函数对应的功能已经实现，找到f（n）和f（n-1）的关系
• c.使用f（n-1）与前面找到关系去实现f（n）的功能

# 写一个递归函数实现：1+2+3+...n
def my_sum(n):
    sum1 = 0
    for x in range(1,n+1):
        sum1 += x
    return sum1
print(my_sum(10))
   """
def my_sum2(n):
    # 1.找临界值
    if n == 1:
        return 1
    #2.找my_sum2（n）和my_sum2（n-1）的关系：
    my_sum2(n):1+2+3+...+n-1+n
    my_sum2(n-1):1+2+3+...+n-1
    关系：my_sum2（n） = my_sum2（n-1）+n
    """
结果：
55

# 用递归求2*4*6...n（n是偶数）
def my_mul(n):
    if n == 2:
        return 2
    return my_mul(n-2)*n
print(my_mul(12))
结果:
46080

# 练习打印以下图形
n = 3
***
**
*

def daying(n):
    if n == 1:
        print('*')
        return
    #daying(n - 1)       此处交换以下位置就可以使得这个三角形换个方向打印
    print('*'*n)
    daying(n - 1)
daying(5)
结果：
*****
****
***
**
*

练习

1.写一个函数将⼀个指定的列表中的元素逆序(例如[1, 2, 3] -> [3, 2, 1])(注意：不要使用列表自带的逆序函数)

def hysteron(n):
    a = []
    while True:
        b = n.pop()
        a.append(b)
        if not n:
            break
    print(a)
n = [1, 2, 3]
hysteron(n)
结果：
[3, 2, 1]

2.写一个函数，提取出字符串中所有奇数位上的字符

def my_str1(n):
    m = ''
    y = list(n)
    for x in range(len(n)):
        if x %2 !=0:
            m += y[x]
    print(m)
n = 'dasggasdg'
my_str1(n)
结果：
agad

3.写一个匿名函数，判断指定的年是否是闰年

n = int(input())
m = (lambda n:'闰年' if n % 4 == 0 else '非闰年')
print(m(n))
结果：
2014
非闰年
2004
闰年

4.使用递归打印：
n = 3的时候
@
@@@
@@@@@
n = 4的时候:
@
@@@
@@@@@
@@@@@@@

m = int(input('请输入n的值：'))
def print_star(n):
    if n ==1:
        print(' '+'@'*(1+(m-1)*2))
        return
    print(' ' * n + '@' * ((m-n) * 2 + 1))
    print_star(n - 1)
print_star(m)
结果：
n = 4
    @
   @@@
  @@@@@
 @@@@@@@
n = 3
   @
  @@@
 @@@@@

5.写函数，检查传入列表的长度，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。

def lists(n):
    if len(n)>2:
        m = n[2:]
        return m
    else:
        return
x = lists([1,2,3,4,5])
print(x)
结果：
[3, 4, 5]

6.写函数，利用递归获取斐波那契数列中的第 10 个数，并将该值返回给调用者。

def get_number(n):
    if n <= 2 :
        return 1
    return get_number(n-1)+get_number(n-2)
print(get_number(6))
结果：
8

7.写一个函数，获取列表中的成绩的平均值，和最高分

def lists(n):
    sum1 = 0
    for x in n:
        sum1 += x
    return (sum1/len(n),max(n))
m = [80,90,90,80,70,100]
print(lists(m))
结果：
(85.0, 100)

8.写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其作为新的列表返回给调用者

def lists(n):
    m = []
    if type(n) == list:
        m = n[1::2]
        return m
    for x in range(len(n)):
        if x %2 != 0:
            y = n[x]
            m.append(y)
    return m
print(lists((10,20,30,40,50)))
结果：
[20, 40]