Python练习_函数进阶_day10

1.

1.作业

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

2,读代码，回答：代码中,打印出来的值a,b,c分别是什么？为什么？
    a=10
    b=20
    def test5(a,b):
             print(a,b)
    c = test5(b,a)
    print(c)

3,读代码，回答：代码中,打印出来的值a,b,c分别是什么？为什么？
    a=10
    b=20
    def test5(a,b):
        a=3
        b=5
         print(a,b)
    c = test5(b,a)
    print(c)
4,写函数,传入函数中多个实参(均为可迭代对象如字符串,列表,元祖,集合等),将每个实参的每个元素依次添加到函数的动态参数args里面.
例如 传入函数两个参数[1,2,3] (22,33)最终args为(1,2,3,22,33)

5,写函数,传入函数中多个实参(实参均为字典),将每个实参的键值对依次添加到函数的动态参数kwargs里面.
例如 传入函数两个参数{‘name’:’alex’} {‘age’:1000}最终kwargs为{‘name’:’alex’ ,‘age’:1000}

6, 下面代码成立么?如果不成立为什么报错?怎么解决?
6.1
    a = 2
    def wrapper():
            print(a)
    wrapper()

6.2
    a = 2
    def wrapper():
            a += 1
        print(a)
    wrapper()
6.3
def wrapper():
        a = 1
        def inner():
            print(a)
        inner()
    wrapper()
6.4
def wrapper():
        a = 1
        def inner():
            a += 1
            print(a)
        inner()
    wrapper()

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

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

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

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

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

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

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

2.

2.默写

1，形参的接收顺序。

2，什么是命名空间，什么是全局名称空间，什么是局部名称空间，什么是内置名称空间。

3，什么是全局作用域，什么是局部作用域。

4，名称空间的加载顺序，取值顺序。

5，解释一下什么是global，什么是nonlocal。

答案

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

def sum_func(*args):
    total = 0
    for i in args:
        total += i
    return total
print(sum_func(1,2,3,8,23,6))

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

a=10
b=20
def test5(a,b):
print(a,b)
c = test5(b,a)
print(c)

----------------------
结果：
a = 20
b = 10
c = None

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

a=10
b=20
def test5(a,b):
a=3
b=5
print(a,b)
c = test5(b,a)
print(c)
--------------------------
结果：
a = 3
b = 5
c = None

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

def sum(*objs):

    lis=[]
    for i in objs:
        for ii in i:
            lis.append(ii)
    return lis
ret=sum([1,2,3], (22,33))
print(ret)

5,写函数,传入函数中多个实参(实参均为字典),将每个实参的键值对依次添加到函数的动态参数kwargs里面.
例如 传入函数两个参数{‘name’:’alex’} {‘age’:1000}最终kwargs为{‘name’:’alex’ ,‘age’:1000}

def dic_to_sum(**kwargs):
  return kwargs
ret=dic_to_sum(**{"name":"alex"},**{"age":1000})
print(ret)

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

7.1
 a = 2
 def wrapper():
     print(a)
 wrapper()
 7.2
 a = 2
 def wrapper():
     global a#增加此行代码
     a += 1#报错,不能修改直接修改全局变量
     print(a)
 wrapper()
 print(a)
 7.3
 def wrapper():
     a = 1
     def inner():
         print(a)
     inner()
 wrapper()
 7.4
 def wrapper():
     a = 1
     def inner():
         nonlocal a#增加此行代码
         a += 1#报错,不能修改直接修改上层的局部变量
         print(a)
     inner()
 wrapper()

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

def comper(num1,num2):
    return num1 if num1>num2 else num2
ret=comper(99,98)
print(ret)

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

def hebin(*args):
    s=""
    for el in args:
        s = s + str(el) + "_"
    s = s[:-1]
    return s
dic=[1,"老男孩","武sir"]
ret=hebin(*dic)
print(ret)

10,写函数，传入n个数，返回字典{‘max’:最大值,’min’:最小值}

例如:min_max(2,5,7,8,4) 返回:{‘max’:8,’min’:2}(此题用到max(),min()内置函数)

def min_max(*args):
    dic={}
    dic["max"]=max(args)
    dic["min"]=min(args)
    return dic
ret=min_max(2,5,7,8,4)
print(ret)

11,写函数，传入一个参数n，返回n的阶乘

例如:cal(7)  计算7*6*5*4*3*2*1

def factorial(n):
    for i in range(1,int(n)):
        n = n * i
        print(n)
ret=factorial(7)#  7  ret=5040
print(ret)

12写函数，返回一个扑克牌列表，里面有52项，每一项是一个元组

例如：[(‘红心’，2),(‘草花’，2), …(‘黑桃’，‘A’)]

def  pai():
    se=["黑桃", "红桃", " 棉花", " 方块"]
    num=['A',2,3,4,5,6,7,8,9,10,'J','Q','K']
    s = ""
    result = []
    for ii in num:
        for i in se:
            s = (str(i), str(ii))
            result.append(s)
    return result
print(pai())
print(len(pai()))

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))_____
print(calc(1,2))____
print(calc(e=4,c=5,a=2,b=3))___
print(calc(1,2,3))_____
print(calc(1,2,3,e=4))____
print(calc(1,2,3,d=5,4))_____

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

def extendList(val,list=[]):
     list.append(val)
     return list
list1 = extendList(10)
list2 = extendList(123,[])
list3 = extendList('a')

print('list1=%s'%list1)
print('list2=%s'%list2)
print('list3=%s'%list3)

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 i in range(1,10):#1
    for j in range(1,i+1):#1
        if i ==j:
            print("%s*%s=%s"%(j,i,i*j),"n")
        else:
            print("%s*%s=%s"%(j,i,i*j),end=" ")

默写

默写:
    1，形参的接收顺序。
位置参数 => *args => 默认值参数 => **kwargs

    2，什么是命名空间，什么是全局名称空间，什么是局部名称空间，什么是内置名称空间
命名空间:存放名字和值的关系的空间
全局名称空间: 在代码运行初始,(俗称函数外)创建的存储名字和值的空间
局部名称空间: 函数运行中创建的空间
内置名称空间: python解释器内部运行时存储的:int,str,list,tuple这些名字的空间

    3，什么是全局作用域，什么是局部作用域。
全局作用域: 包含内置名称空间、全局名称空间，在整个文件的任意位置都能被引用、全局有效
局部作用域: 局部名称空间，只能在局部范围内生效

    4，名称空间的加载顺序，取值顺序。
加载顺序:内置命名空间(程序运行前加载)=>全局命名空间(程序运行中:从上到下加载)=>局部命名空间(程序运行中:调用时才加载)
调用顺序:
　　     在局部调用：局部命名空间->全局命名空间->内置命名空间
　　     在全局调用：全局命名空间->内置命名空间

    5，解释一下什么是global，什么是nonlocal。
global:    把全局变量拿到局部来用.
nonlocal:  在函数内部中,把最近的一层的变量拿过来.不会找全局