函数进阶

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

def sum(*nums):
    count=0
    for i in nums:
        count+=i
    return count
ret=sum(1,2,3,4,5,6,7,8,9,10)
print(ret)

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

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

# 5,写函数,传入函数中多个实参(均为可迭代对象如字符串,列表,元祖,集合等),
# 将每个实参的每个元素依次添加到函数的动态参数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)

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

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

# 7, 下面代码成立么?如果不成立为什么报错?怎么解决?
# 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()))

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()
# 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))_____

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，形参的接收顺序。

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

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

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

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