函數進階做業

時間 2019-11-13

標籤函數進階简体版

原文原文鏈接

1,繼續整理函數相關知識點，寫博客。

2,寫函數，接收n個數字，求這些參數數字的和。（動態傳參）

3,讀代碼，回答：代碼中,打印出來的值a,b,c分別是什麼？爲何？
   a=10
   b=20
   def test5(a,b):
          print(a,b)
   c = test5(b,a)
   print(c)

4,讀代碼，回答：代碼中,打印出來的值a,b,c分別是什麼？爲何？
   a=10
   b=20
   def test5(a,b):
      a=3
      b=5
       print(a,b)
   c = test5(b,a)
   print(c)
   print(a,b)

5,寫函數,傳入函數中多個實參(均爲可迭代對象如字符串,列表,元祖,集合等),將每一個實參的每一個元素依次添加到函數的動態參數args裏面.
例如 傳入函數兩個參數[1,2,3] (22,33)最終args爲(1,2,3,22,33)

6,寫函數,傳入函數中多個實參(實參均爲字典),將每一個實參的鍵值對依次添加到函數的動態參數kwargs裏面.
例如 傳入函數兩個參數{‘name’:’alex’} {‘age’:1000}最終kwargs爲{‘name’:’alex’ ,‘age’:1000}

7, 下面代碼成立麼?若是不成立爲何報錯?怎麼解決?
7.1
   a = 2
   def wrapper():
       print(a)
   wrapper()    #成立

7.2
   a = 2
   def wrapper():
        a += 1   # 不成立,Python規定 局部不能修改全局的變量,要修改須要使用global將變量引入
        print(a)
   wrapper()

7.3
def wrapper():
    a = 1
    def inner():
        print(a)  # 成立,局部能夠調用全局的變量
    inner()
wrapper()

7.4
def wrapper():
        a = 1
        def inner():
            a += 1  # 不成立,內層修改外層的變量,須要nonlocal引入
            print(a)
        inner()
wrapper()

8，寫函數,接收兩個數字參數,將較小的數字返回.

9，寫函數,接收一個參數(此參數類型必須是可迭代對象),將可迭代對象的每一個元素以’_’相鏈接,造成新的字符串,並返回.
例如 傳入的可迭代對象爲[1,'老男孩','武sir']返回的結果爲’1_老男孩_武sir’

10,寫函數，傳入n個數，返回字典{‘max’:最大值,’min’:最小值}
例如:min_max(2,5,7,8,4) 返回:{‘max’:8,’min’:2}(此題用到max(),min()內置函數)

11,寫函數，傳入一個參數n，返回n的階乘
例如:cal(7)  計算7*6*5*4*3*2*1

12寫函數，返回一個撲克牌列表，裏面有52項，每一項是一個元組
例如：[(‘紅心’，2),(‘草花’，2), …(‘黑桃’，‘A’)]


13 有以下函數:
def wrapper():
          def inner():
              print(666)
   wrapper()

你能夠任意添加代碼,用兩種或以上的方法,執行inner函數.


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

明日默寫:
   1，形參的接收順序。
       位置參數 > *args > 默認值參數 > **kwargs

   2，什麼是命名空間，什麼是全局名稱空間，什麼是局部名稱空間，什麼是內置名稱空間。
        命名空間:用來存放名字(變量, 函數名, 類名, 引入的模塊名)和值的關係的空間
        1. 全局名稱空間: 咱們在py文件中本身寫的變量, 函數(只是函數名自身不包括內部)
        2. 內置名稱空間: python解釋器提供好的一些內置內容(print, input....)
        3. 局部名稱空間: 在咱們執行函數的時候,會產生一個局部名稱空間. 放的是: 函數內部的內容(變量, 函數,類...)


   3，什麼是全局做用域，什麼是局部做用域。
        全局做用域:在整個文件的任何位置均可以使⽤(遵循 從上到下逐⾏執⾏).
        局部做⽤用域: 在函數內部可使⽤用.
        1. 全局做用域: 內置+全局
        2. 局部做用域: 局部

   5，解釋一下什麼是global，什麼是nonlocal。
       global: 在局部引入全局變量
        nonlocal: 在局部...內層函數引入外層離他最近的那個(局部)變量.

# 參考答案
# t2  
def func(*args):
    sum = 0
    for el in args:
        sum += el
    return sum


print(func(1, 2, 3))

# t3
a=20,b=10,c=None,由於c是函數的返回值,這裏函數沒有return,默認返回None

# t4
c = None,由於函數沒有return. a = 10, b = 20

# t5
def func(*args):
    return args


print(func(*[1, 2, 3], *(22, 33)))

# t6
def func(**kwargs):
    return kwargs


print(func(**{'a': 'alex'}, **{'age': 1000}))  # 這裏的字典的鍵不能是純數字,由於要打散成關鍵字參數,不能是 1 = a這種,傳不到形參就不行了


# t7

# t8
def func(a, b):
    return a if a < b else b


print(func(1, 2))


# t9
# 我寫的 方法1
def func(args):  # 使用動態傳參的話會聚合成元組,元組不可變(好比:不可修改元素)
    s = ''
    for i in args:
        s += str(i)+'_'  # 拼接和累加  注意:字符串的索引是寫在[]裏面的
    return s.strip('_')  # s[:-1]


print(func([1,'老男孩','武sir']))

# 方法2:參考
def func(*args):
    # lst = []
    # for i in args:
    #     lst.append(str(i))
    lst = [str(i) for i in args]  # 同桌寫的,至關於上面的三行
    s = "_".join(lst)
    return s


print(func(*[1, '老男孩', '武sir']))

'''
#  join連接的可迭代對象的元素也必須是字符串
# print('_'.join([1,'老男孩','武sir']))  #報錯:這裏的第一個元素是int類型的 TypeError: sequence item 0: expected str instance, int found

# print('_'.join('12acd'))  # 成功,這裏面的數字是字符串
'''


# t10
def min_max(*args):
    umin = min(args)
    umax = max(args)
    return {'max': umax, 'min': umin}


print(min_max(2, 5, 7, 8, 4))

# t11
def func(n):
    fac = 1
    for i in range(1, n + 1):
        fac *= i
    return fac


print(func(7))

# t12
def func():
    lst1 = ['紅心', '草花', '黑桃', '方片']
    lst2 = []
    for i in range(13):
        for el in lst1:
            lst2.append((el, i+1))
    return lst2


print(func())


# t13



# t14-1
def calc(a,b,c,d=1,e=2):
    return (a+b)*(c-d)+e
print(calc(1,2,3,4,5))  # 2
# print(calc(1,2))  # 這裏報錯,缺乏一個位置參數'c'c
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))  # 這裏的4報錯,帶等號的必須在最後邊

# t14-2
def extendList(val,list=[]):  # 函數調用沒給默認值新值的狀況下,屢次調用使用同一個默認列表(即共享)
    print(id(list))  # 默認值的內存
    list.append(val)
    return list
list1 = extendList(10)
print('list1=%s'%list1)  # list1=[10]  添加完本身的就打印
print(id(list))

list2 = extendList(123,[])
print('list2=%s'%list2)  # list2=[123]
print(id(list))

list3 = extendList('a')
print('list3=%s'%list3)  # list3=[10, 'a']  和第一個添加的是同一個列表

print('list1=%s'%list1)  # list1=[10, 'a']  ##注意:第三個和第一個添加的是同一個列表
print('list2=%s'%list2)  # list2=[123]
print('list3=%s'%list3)  # list3=[10, 'a']


# t14-3
for i in range(1, 10):
    for j in range(1, 10):
        if j < i:
            print(f'{i} * {j} = {i*j}', end=' ')
        elif j == i:
            print(f'{i} * {j} = {i*j}')


# t7-1
a = 2
def wrapper():
    a = 5
    def inner():
        a = 3
        a += 10
        print(a)
    inner()
wrapper()    #成立

def func():
    global a # 在局部引入全局變量, 若是這變量在全局不存在. 幫你建立一個全局變量
    a = 10
    print(a)
func()
print(a)

# 寫函數，接收n個數字，求這些參數數字的和。（動態傳參）
def func(*args):
    sum = 0
    for el in args:
        sum += el
    return sum

print(func(1,5,6,9,8,4,5,7))


# 寫函數,傳入函數中多個實參(均爲可迭代對象如字符串,列表,元祖,集合等),將每一個實參的每一個元素依次添加到函數的動態參數args裏面.
# 例如 傳入函數兩個參數[1,2,3] (22,33)最終args爲(1,2,3,22,33)
def func(*args):
    print(args)

func(*[1,2,3], *(22,33))


def func(**kwargs):
    print(kwargs)

func(**{"name":"李嘉誠", "age":123}, **{"address":"香港九龍"})



def wrapper():
    global a # a 全局變量
    a = 1
    def inner():
        nonlocal a # 局部
        a+=1
        print(a)
    inner()
wrapper()

# 9，寫函數,接收一個參數(此參數類型必須是可迭代對象),
# 將可迭代對象的每一個元素以’_’相鏈接,造成新的字符串,並返回.
# 例如 傳入的可迭代對象爲[1,'老男孩','武sir']返回的結果爲’1_老男孩_武sir’

def func(lst):
    s = ""
    for el in lst:
        s += str(el) + "_" # 拼接和累加

    return s[:-1]

print(func([1,"胡辣湯", "朱祁鎮"]))


# 寫函數，傳入n個數，返回字典{‘max’:最大值,’min’:最小值}
# 例如:min_max(2,5,7,8,4) 返回:{‘max’:8,’min’:2}(此題用到max(),min()內置函數)

def func(*args):
    return {'max':max(args),'min':min(args)}

print(func(1, 5, 7, 6, 5, 4, 2, 5, 8, 55, 4, 1, 2))

# 做業: 一個列表中的最大值


# 寫函數，傳入一個參數n，返回n的階乘
# 例如:cal(7)  計算7*6*5*4*3*2*1

def func(n):
    sum = 1
    for i in range(n, 0, -1):
        sum *= i
    return sum

print(func(7))


# 寫函數，返回一個撲克牌列表，裏面有52項，每一項是一個元組
# 例如：[(‘紅心’，2),(‘草花’，2), …(‘黑桃’，‘A’)]

def func():
    hua = ["紅心", "草花", "方塊", "黑桃"] # 花色
    dian = ["A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"]
    # 笛卡爾積, 笛卡爾乘 -> 關係型數據庫的原理

    result = []
    # 循環花色
    for h in hua: # h就是花色: 紅心
        for d in dian: # d是每個點數. A-K
            result.append((h, d))
    return result

print(func())


def wrapper():
    def inner():
        print(666)
    # inner()
    # inner = 10
    return inner # 函數能夠做爲返回值返回

wrapper()()

print(ret)

def func():
    return 123

a = func() + 10

print(a)


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


'''
寫代碼完成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):
    for j in range(1, i + 1):
        print("%s x %s = %s" % (i, j, i * j), end=" ")
    print() # 換行

'''
*
**
***
****
*****
******


     *
    ***
   *****
  *******
 *********
***********   



     *
    ***
   *****
  *******
 *********
***********   
 *********
  *******
   *****
    ***
     *
'''