day10——动态参数，名称空间，global，nonlocal

动态参数
    *args：位置参数动态传参，接受到的是元祖，传多少都可以，不传也可以
    **kwargs：关键字参数动态传参

    顺序：
        位置参数—*args—默认值参数—**kwargs
        以上参数可以随意搭配使用


    def func():
        pass

    形参的位置*，**  ——聚合
    实参的位置*，**  ——打散

命名空间
    内置命名空间
    全局命名空间
    局部命名空间

    作用域
        全局作用域：内置+全局
        局部作用域：局部（被函数调用）

    globals()   查看全局中的内容
    locals()    查看当前作用域中的内容



global和nolocal
    global：在局部中生命全局变量
    nolocal：局部作用域中找父级中的变量声明新的变量，找到位置

day10——作业

1, 继续整理函数相关知识点，写博客。

2, 写函数，接收n个数字，求这些参数数字的和。（动态传参）

①
def func(*args):
    count = 0
    for i in args:
        count += i
    return count
print(func(1,2,3,4,5,6,7))

②
def func(*args):
    return sum(args)
print(func(1,2,3,4,5))

3, 读代码，回答：代码中, 打印出来的值a, b, c分别是什么？为什么？

a = 10
b = 20
def test5(a, b):
    print(a, b)     #   a = 20   b = 10
c = test5(b, a)
print(c)            #   c = None    c是None是因为没有返回值，就是None

4, 读代码，回答：代码中, 打印出来的值a, b, c分别是什么？为什么？

a = 10
b = 20
def test5(a, b):
    a = 3
    b = 5
print(a, b)       # a = 10 , b = 20
c = test5(b, a)
print(c)          # c = None
print(a, b)       # a = 10 , b = 20

5, 写函数, 传入函数中多个实参(均为可迭代对象如字符串, 列表, 元祖, 集合等), 将每个实参的每个元素依次添加到函数的动态参数args里面.
例如
传入函数两个参数[1, 2, 3](22, 33)
最终args为(1, 2, 3, 22, 33)

def func(*args):
    return args
print(func(*[1, 2, 3],*(22, 33)))

6, 写函数, 传入函数中多个实参(实参均为字典), 将每个实参的键值对依次添加到函数的动态参数kwargs里面.
例如
传入函数两个参数

{‘name’:’alex’} {‘age’:1000}最终kwargs为
{‘name’:’alex’, ‘age’:1000}
def func(**kwargs):
    return kwargs
print(func(**{'name':'alex'},**{'age':1000}))

7, 下面代码成立么?如果不成立为什么报错?怎么解决?

7.1

a = 2
def wrapper():
    print(a)
wrapper()


成立
a = 2


7.2
a = 2
def wrapper():
    a += 1
    print(a)
wrapper()


不成立
局部里面不能更改全局变量
在里面加一个global


7.3
def wrapper():
    a = 1
    def inner():
        print(a)
    inner()
wrapper()


成立
a = 1


7.4
def wrapper():
    a = 1
    def inner():
        a += 1
        print(a)
    inner()
wrapper()


不成立
不能随意对上一层变量进行修改
在里面加一个 nolocal

8，写函数, 接收两个数字参数, 将较小的数字返回.

def func(a,b):return a if a < b else b
print(func(10,20))

9，写函数, 接收一个参数(此参数类型必须是可迭代对象),
将可迭代对象的每个元素以’_’相连接, 形成新的字符串, 并返回.
例如
传入的可迭代对象为[1, '老男孩', '武sir']
返回的结果为’1_老男孩_武sir’

def func(*args):
    s = ''
    for i in args:
        s += '_'+ str(i)
    return s.strip('_')
print(func(*[1, '老男孩', '武sir']))


def func(*args):
    s = ''
    for i in args:
        s = s + str(i) + "_"
    return s.strip('_')
print(func(*[1, '老男孩', '武sir']))

10, 写函数，传入n个数，返回字典
{‘max’:最大值,’min’:最小值}
例如: min_max(2, 5, 7, 8, 4)
返回: {‘max’:8,’min’:2}(此题用到max(), min()内置函数)

①
def func(*args):
    dic = {}
    dic['max'] = max(args)
    dic['min'] = min(args)
    return dic
print(func(1,2,3,4,5,6))

②
def func(*args):
    return {'max':max(args),'min':min(args)}
print(func(1,2,3,4,5,6,7,8))

11, 写函数，传入一个参数n，返回n的阶乘
例如: cal(7)
计算7 * 6 * 5 * 4 * 3 * 2 * 1

①
def func(n):
    sum = 1
    while n >= 1:
        sum *= n
        n -= 1
    return sum
print(func(5))


②
def func(a):
    cal = 1
    while a > 0:
        cal *= a
        a -= 1
    return cal
print(func(5))

12
写函数，返回一个扑克牌列表，里面有52项，每一项是一个元组
例如：[(‘红心’，2), (‘草花’，2), …(‘黑桃’，‘A’)]

li = ['红心','方块','梅花','黑桃']
def func(*args):
    ls = []
    for a in args:
        for b in li:
            if a == 1:
                ls.append((b,'A'))
            elif a == 11:
                ls.append((b,"J"))
            elif a == 12:
                ls.append((b,"Q"))
            elif a == 13:
                ls.append((b,"K"))
            else:
                ls.append((b,a))
    print(ls)
func(1,2,3,4,5,6,7,8,9,10,11,12,13)

13
有如下函数:
def wrapper():
    def inner():
        print(666)
wrapper()

你可以任意添加代码, 用两种或以上的方法, 执行inner函数.

①
def wrapper():
    def inner():
        print(666)
    inner()
wrapper()

②
def wrapper():
    def inner():
        print(666)
    return inner
ret = wrapper()
ret()

③
def wrapper():
    def inner():
        print(666)
    ret = inner()
    print(ret)
wrapper()

14
相关面试题（先从纸上写好答案，然后在运行）：
1，有函数定义如下：
def calc(a, b, c, d=1, e=2):
    return (a + b) * (c - d) + e

请分别写出下列标号代码的输出结果，如果出错请写出Error。
print(calc(1, 2, 3, 4, 5))
2

print(calc(1, 2))
Error    缺少参数

print(calc(e=4, c=5, a=2, b=3))
24

print(calc(1, 2, 3))
8

print(calc(1, 2, 3, e=4))
10

print(calc(1, 2, 3, d=5, 4))
Error     关键字参数不能在默认参数前面

2，(此题有坑)
下面代码打印的结果分别是_________, ________, ________.

def extendList(val, list=[]):   #默认值如果是可变的数据类型，每次使用都是同一个
    list.append(val)
    return list
list1 = extendList(10)
list2 = extendList(123, [])
list3 = extendList('a')
print('list1=%s' % list1)   # list1=[10, 'a']
print('list2=%s' % list2)   # list2=[123]
print('list3=%s' % list3)   # list3=[10, 'a']

默认参数会创建一块内存地址，list1和list3传的10和a都添加到了默认参数的这个列表中，
他俩就指向同一个内存地址，list2新传了一个列表，又创建了一个内存地址，
所以list2是[123]，list1和list3是[10, 'a']

    3, 写代码完成99乘法表.(升级题)

1 * 1 = 1
2 * 1 = 2
2 * 2 = 4
3 * 1 = 3
3 * 2 = 6
3 * 3 = 9
......
9 * 1 = 9
9 * 2 = 18
9 * 3 = 27
9 * 4 = 36
9 * 5 = 45
9 * 6 = 54
9 * 7 = 63
9 * 8 = 72
9 * 9 = 81

for m in range(1,10):
    for n in range(1,m+1):
        print('%s*%s=%s' % (m,n,m*n),end = ' ')
    print()  #里面相当于有一个end="
"

直角三角形

for m in range(1,10):
    for n in range(1,m+1):
        print('*',end = ' ')
    print()  #里面相当于有一个end="
"