第二章 函數

1. 通過代碼實現如下轉換：

　　二進制轉換成十進制：v = “0b1111011”

　　十進制轉換成二進制：v = 18

　　八進制轉換成十進制：v = “011”

　　十進制轉換成八進制：v = 30

　　十六進制轉換成十進制：v = “0x12”

　　十進制轉換成十六進制：v = 87　　

v = "0b1111011"
print(int(v,2))

v = 18
print(oct(v))

v = "011"
print(int(v,8))

v = 30
print(oct(v))

v = "0x12"
print(int(v,16))

v = 87
print(hex(v))

2. Python 遞歸的最大層數？　　

　　遞歸官方給出的最大次數是1000次，本人實際測試994-997次

3. 列舉常見的內置函數？

　　print()　　zip()　　map()　　sum()　　max()　　min()　　avg()　　abs()　　sorted()　　filter()

4. filter、map、reduce 的作用？

　　

1. filter() 相當於過濾器的作用

　　　　s=[1,2,3,5,6,8,9,10,25,12,30] 　　　　# 篩選出3的倍數 　　　　# 第一個參數為一個返回True或者False的函數，第二個參數為可迭代對象 　　　　# 該函數把可迭代對象依次傳入第一個函數，如果為True，則篩選 　　　　d=filter(lambda x:True if x % 3 == 0 else False,s) 　　　　print(list(d))

2. map()函數，

　　　　# 第一個參數為函數，依次將后面的參數傳給第一個函數，並執行函數 　　　　# 如果有多個參數則，依次將后面的對應傳給參數 　　　　s=map(lambda x,y:x+y,range(10),range(10)) 　　　　print(list(s)) 　　　　ss=map(lambda x:x*x,range(10)) 　　　　print(list(ss))

3. reduce()函數

　　　　from functools import reduce 　　　　# 開始的時候將可迭代對象的第一個數和第二個數當成x和y 　　　　# 然后將第一次函數的執行結果當成x，然后再傳入一個數當成y 　　　　# 再執行函數 　　　　s=reduce(lambda x,y:x+y,range(101)) 　　　　print(s) # 相當於0+1+2+……+99+100

5. 一行代碼實現 9*9 乘法表

print('\n'.join(['\t'.join([f"{i}x{j}={i*j}" for j in range(1,i+1)]) for i in range(1,10)]))

6. 什么是閉包？

　　嵌套函數內部使用外部非全局變量：　　

• 在函數中可以（嵌套）定義另一個函數時，如果內部的函數引用了外部的函數的變量，則可能產生閉包。閉包可以用來在一個函數與一組“私有”變量之間創建關聯關系。在給定函數被多次調用的過程中，這些私有變量能夠保持其持久性。

  # 內部函數使用了外部函數的變量，就相當於閉包
  def func1():
      a=1
      def inner():
          return a
      return inner
  print(func1()())

7. 簡述 生成器、迭代器、裝飾器以及應用場景？

　　參考解析

　　迭代器：同時具有iter()和next()[或者說同時具有__iter__()和__next__()]方法的對象；

裝飾器本質上是一個Python函數，它可以在讓其他函數在不需要做任何代碼的變動的前提下增加額外的功能，迭代器是一個更抽象的概念，任何對象，如果它的類有next方法和iter方法返回自己本身，對於string、list、dict、tuple等這類容器對象，使用for循環遍歷是很方便的。在后台for語句對容器對象調用iter()函數，iter()是python的內置函數。iter()會返回一個定義了next()方法的迭代器對象，它在容器中逐個訪問容器內元素，next()也是python的內置函數。在沒有后續元素時，next()會拋出一個StopIteration異常；

　　生成器：生成器是一種特殊的迭代器，是帶有yield關鍵字的特殊函數，具有send()方法（第一次迭代時必須傳遞一個參數None），生成器（Generator）是創建迭代器的簡單而強大的工具。它們寫起來就像是正規的函數，只是在需要返回數據的時候使用 yield 語句。每次 next()被調用時，生成器會返回它脫離的位置（它記憶語句最后一次執行的位置和所有的數據值）；　　

　　裝飾器：對內開放對外封閉的閉包函數，以一個函數作為參數，在不改變原函數功能基礎上，返回一個增加額外功能的可執行函數，裝飾器的返回值也是一個函數的對象，它經常用於有切面需求的場景。 比如：插入日志、性能測試、事務處理、緩存、權限的校驗等場景 有了裝飾器就可以抽離出大量的與函數功能本身無關的雷同代碼並發並繼續使用。　　

8. 使用生成器編寫 fib 函數, 函數聲明為 fib(max), 輸入一個參數 max 值, 使得該函數可以這樣調用。　　

 for i in range(0,100):
　　 　　print fib(1000)

並產生如下結果(斐波那契數列),1,1,2,3,5,8,13,21...

def fib(num):
    a,b=0,1
    while b<num:
        yield b
        a, b = b, a + b
for i in fib(1000):
    print(i)

9. 一行代碼, 通過 filter 和 lambda 函數輸出以下列表索引為奇數對應的元素。　　list_a=[12,213,22,2,2,2,22,2,2,32]

list_a=[12,213,22,2,2,2,22,2,2,32]
print([i[1] for i in filter(lambda x:x[0]%2==1,enumerate(list_a))])

10. 寫一個 base62encode 函數, 62 進制。

　　即:0123456789AB..Zab..z(10個數字+26個大寫字母+26個小寫字母)。

　　　　base62encode(1)=1

　　　　base62encode(61) = z

　　　　base62encode(62)=10

#字母和數字的獲取方式一
s=''
for i in range(10):
   s+=str(i)
for i in range(65,91):
    s+=chr(i)
for i in range(97,123):
    s+=chr(i)
#字母和數字的獲取方式二
import string
lower=string.ascii_lowercase
upper=string.ascii_uppercase
digits=string.digits
s=digits+upper+lower
    

def base62encode(n):
    li=[]
    while  n:
        n,y=divmod(n,62)
        print(n,y)
        li.append(s[y])
    return ''.join(reversed(li))
print(base62encode(62))

11. 請實現一個裝飾器, 限制該函數被調用的頻率, 如 10 秒一次

import time
def wrapper(f):
    t = 0
    def inner(*args, **kwargs):
        t_now = time.time()
        nonlocal t
        if t_now - t >= 10:
            t = t_now
            return f()
        else:
            print('訪問過快！！！')
    return inner

@wrapper
def func():
    print(10)

func()
func()

12. 請實現一個裝飾器, 通過一次調用使函數重復執行 5 次。

import time
def wrapper(f):
    def inner(*args, **kwargs):
        for i in range(5):
            print(f"第{i}此執行：",end='')
            f()
    return inner
@wrapper
def func():
    print(f"{time.strftime('%X')}")

func()

13. python 一行 print 出 1~100 偶數的列表, (列表推導式, filter 均可)　　

print([i for i in range(101) if i%2==0])
print(list(filter(lambda x:x%2==0,range(101))))

14. 解釋生成器與函數的不同, 並實現和簡單使用 generator.

　生成器和函數的主要區別在於函數 return value，生成器 yield value同時標記或記憶point of the yield 以便於在下次調用時從標記點恢復執行。 yield 使函數轉換成生成器，而生成器反過來又返回迭代器。

# 簡單實現生成器
def dec():
    n=0
    for i in range(10):
        yield n
        n+=i
        
for i in dec():
    print(i)

15. 列表推導式和生成器表達式 [i % 2 for i in range(10)] 和 (i % 2 for i inrange(10)) 輸出結果分別是什么？

 [i % 2 for i in range(10)]輸出結果是列表。

 (i % 2 for i inrange(10))輸出結果是一個生成器地址，它和列表推導式類似，它一次處理一個對象，而不是一口氣處理和構造整個數據結構，可以節約內存。

16. map(str,[1,2,3,4,5,6,7,8,9]) 輸出是什么？

　　python3中輸出一個生成器

17. python 中定義函數時如何書寫可變參數和關鍵字參數?　　

　　def func(a,*args,b=1,**kwargs): 　　 pass　　

18. Python3.5 中 enumerate 的意思是什么？　　

• 枚舉的意思，同時得到可迭代對象，如列表和元組的索引和值，以元組形式返回

19. 說說 Python 中的裝飾器,迭代器的用法:描述下 dict 的 items 方法與iteritems 方法的不同　　

　　裝飾器是在不修改原函數的基礎上添加一個功能

　　迭代器是讀取大文件時使用的

　　python3中沒有iteritems

　　　items和iteritems大致相同，只是items返回的是一個列表，iteritems返回的是一個迭代器

20. 是否使用過 functools 中的函數？其作用是什么？

　　

1. functools.wraps()
   • 在裝飾器中用過，如果不使用wraps，則原始函數的__name__和__doc__的值就會丟失
2. functools.reduce()
   • 第一個參數是一個函數，第二個參數是一個可迭代對象，代碼如下：

　　# 下面代碼相當於從1加到9 　　from functools import reduce 　　a=reduce(lambda x,y:x+y,range(10)) 　　print(a)

21. 如何判斷一個值是函數還是方法？　　

參考鏈接

1. 使用type()來判斷，如果是method為方法，如果是function則是函數。
2. 與類和實例無綁定關系的function都屬於函數（function）
3. 與類和實例有綁定關系的function都屬於方法
4. 調用如果是隱式傳參就是方法（比如self,cls），顯式傳參就是函數

22. 請編寫一個函數實現將 IP 地址轉換成一個整數。

　　如 10.3.9.12 轉換規則為：

　　　　10 00001010

 　　　　3 00000011

 　　　　9 00001001

　　　　12 00001100

　　再將以上二進制拼接起來計算十進制結果：00001010 00000011 00001001 00001100 = ？

def ip(ip_str):
    return int(''.join(["%08d"%int(bin(int(i))[2:]) for i in ip_str.split('.')]),2)

print(ip('127.0.0.1'))

def ip(ip_str):
    a=ip_str.split(".")
    lb=[]
    for i in a:
        lb.append("%08d"%int(bin(int(i))[2:]))
    return int(''.join(lb),2)

print(ip('127.0.0.1'))

23. lambda 表達式格式以及應用場景？

• 格式：lambda 參數列表 : 返回表達式
• 應用場景：常見的在filter，reduce以及map中使用

24. pass 的作用？

• 　　通常用來標記一個還未寫的代碼的位置，pass不做任何事情，一般用來做占位語句，保持程序結構的完整性

25. *args 和**kwargs 作用?

　　*args接收動態位置參數，**kwargs接收動態位置參數

26. 如何在函數中設置一個全局變量 ?

　　在函數中使用global關鍵字定義變量

27. 請寫出打印結果：

1. # 例 1
2. def func(a,b=[]):
3.     b.append(a)
4.     print(b)
5. func(1)
6. func(1)
7. func(1)
8. func(1)
9.
10. # 例 2
11. def func(a,b={}):
12.     b[a] = 'v'
13.     print(b)
14. func(1)
15. func(2)

[1]
[1, 1]
[1, 1, 1]
[1, 1, 1, 1]
{1: 'v'}
{1: 'v', 2: 'v'}

28. 求結果： lambda

1. def num():
2.     return [lambda x:i*x for i in range(4)]
3. print([m(2) for m in num()])

[6,6,6,6]

29. 簡述 yield 和 yield from 關鍵字。

　　yield 和yield from都是返回生成器，后者接收列表、元組、rang()等可迭代對象簡化使用yield的循序，提高效率

30. 有 processFunc 變量 ,初始化為 processFunc = collapse and (lambda s:"".join(s.split())) or (lambda s:s)調用上下文如下

1. collapse = True
2. processFunc = collapse and (lambda s:" ".join(s.split())) or (lambda s:s)
3. print processFunc("i\tam\ntest\tobject !")
4.
5. collapse = False
6. processFunc = collapse and (lambda s:" ".join(s.split())) or (lambda s:s)
7. print processFunc("i\tam\ntest\tobject !")

　　以上代碼會在控制台輸出什么?

i am test object !

i am
test object !

31. 請給出下面代碼的輸出結果

 a = 1
def fun(a):
    a = 2
fun(a)
print a

a = []
def fun(a):
    a.append(1)
 fun(a)
print a

1

[1]

32. 全局變量和局部變量的區別, 如何給 function 里面的一個全局變量賦值

　　全局變量可以作用在全局作用域，局部變量作用於局部作用域，在局部修改全局變量需要使用關鍵字global

33. 什么是 lambda 函數, 下面這段代碼的輸出是什么

nums = range(2,20)
for i in nums:
    nums = filter(lambda x:x==i or x % i, nums)
nums

　　生成器<filter object at 0x076C3D90>----list(nums)==[2,3,4...19]

34. 指出下面程序存在的問題

def Lastllindextem(src, index):
    '''''請返回傳入 src使用空格或者"\"切分后的倒數第 index個子串'''
    return src.split("\")[-index]

　　split("\")中的\需要進行轉義處理

35. 有一個數組[3,4,1,2,5,6,6,5,4,3,3] 請寫一個函數, 找出該數組中沒有重復的數的總和. (上面數據的么有重復的總和為 1+2=3)

#方法一
def func(l):
    dic = {}
    s = 0
    for i in l:
        if i not in dic:
            dic[i] = 1
        else:
            dic[i] += 1
    for k, v in dic.items():
        if v == 1:
            s += k
    return s

l = [3, 4, 1, 2, 5, 6, 6, 5, 4, 3, 3]
print(func(l))

#方法二
from collections import Counter
def func(l):
    dic = Counter(l)
    s = 0
    for k, v in dic.items():
        if v == 1:
            s += int(k)
    return s
l = [3, 4, 1, 2, 5, 6, 6, 5, 4, 3, 3]
print(func(l))

36. 求打印結果

arr = [1,2,3]
def bar():
    arr+=[5]
bar()
print arr

　　A. error　　B. [5]　　C. [1,2,3]　　D. [1,2,3,5]

37. 請寫一個函數, 計算出如下幾個字母代表的數字

　　AB-CD=EF

　　EF+GH = PPP

　　

for A in range(1, 10):
    for B in range(10):
        if A in [B]: continue
        for C in range(1, 10):
            if C in [A, B]: continue
            for D in range(10):
                if D in [A, B, C]: continue
                for E in range(1, 10):
                    if E in [A, B, C, D]: continue
                    for F in range(10):
                        if F in [A, B, C, D, E]: continue
                        for G in range(1, 10):
                            if G in [A, B, C, D, E, F]: continue

                            for H in range(10):
                                if H in [A, B, C, D, E, F, G]: continue
                                for P in range(1,10):
                                    if P in [A, B, C, D, E, F, G, H]: continue
                                    if (A * 10 + B) - (C * 10 + D) == (E * 10 + F) and (E * 10 + F) + (G * 10 + H) == (P * 100 + P * 10 + P):
                                        print(A, B, C, D, E, F, G, H, P)

38. 請給出下面代碼片段的輸出

def say_hi(func):
    def wrapper(*args,**kwargs):
        print("HI")
        ret = func(*args,**kwargs)
        print("BYE")
        return ret
    return wrapper

def say_yo(func):
    def wrapper(*args,**kwargs):
        print("YO")
        return func(*args,**kwargs)
    return wrapper

@say_hi
@say_yo
def func():
    print("ROCK & ROLL")

func()            

HI

YO
ROCK & ROLL
BYE

39. 請簡述標准庫中 functools.wraps 的作用

　　在使用函數裝飾器時，被裝飾的函數的函數名在執行過程中名稱已經變成裝飾器函數內部嵌套的函數名，為了保留原來被裝飾的函數名稱，需要使用 @functools.wraps(fn),fn為裝飾器外層函數傳入的被裝飾的函數名

40. 請給出下面代碼片段的輸出

def test():
    try:
        raise ValueError("something wrong")
    except ValueError as e:
        print("Error occurred")
        return
    finally:
        print("Done")


test()

Error occurred

Done

41. 下面的函數,那些會輸出 1,2,3 三個數字

for i in range(3):
    print(i)
alist = [0, 1, 2]
for i in alist:  5     print(i + 1)  6 i = 1
while i < 3:
    print(i)
    i += 1
for i in range(3): 11     print(i + 1)

0　　1　　2
1　　2　　3
1　　2
1　　2　　3

42. 以下函數需要在其中引用一個全局變量 k, 請填寫語句

　　def fun():

　　　　__________

　　　　k = k+1

global k

43. 請把以下函數轉化為 python lambda 匿名函數

　　def add(x,y):

　　　　return x+y

add = lambda x, y: x + y

44. 閱讀以下代碼, 並寫出程序的輸出結果

my_dict = {"a":0,"b":1}
def func(d):
    d["a"]=1
    return d

func(my_dict)
my_dict["c"]=2
print my_dict

　　{'a': 1, 'b': 1, 'c': 2}

45. 填空題

# 有函數定義如下
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,3) # ____
print calc(1,2) # ____
print calc(1,2,3,e=4) # ____
print calc(e=4, c=5, a=2,b=3) # ____
print calc(1,2,3, d=5,4) # ____

2　　8　　error　　10　　24　　error

46. def(a, b=[])這種寫法有什么陷阱？

　　b=[]默認參數，在函數調用沒有傳遞時會使用形參中定義的共有列表

47. 函數

def add_end(l=[]):
    l.append("end")
    return l

add_end() # 輸出什么
add_end() # 再次調用輸出什么? 為什么

['end']　　#使用默認參數列表
['end', 'end']　　#使用共有的默認參數列表

48. 函數參數 *args,**kwargs 的作用是什么

　　def func(a,b,c=0,*args,**kwargs):

　　　　pass

　*args動態接收位置參數　　** kwargs動態接收關鍵字參數

49. 可變參數定義 *args,**kwargs的區別是什么?並且寫出下邊代碼的輸入內容

def foo(*args,**kwargs):
     print("args=",args)
     print("kwargs=",kwargs)
     print("-----------------")

if __name__ =='__main__':
    foo(1,2,3,4)
    foo(a=1,b=2,c=3)
    foo(1,2,3,4,a=1,b=2,c=3)
    foo("a",1,None,a=1,b="2",c=3)

args= (1, 2, 3, 4)

kwargs= {}
-----------------
args= ()
kwargs= {'a': 1, 'b': 2, 'c': 3}
-----------------
args= (1, 2, 3, 4)
kwargs= {'a': 1, 'b': 2, 'c': 3}
-----------------
args= ('a', 1, None)
kwargs= {'a': 1, 'b': '2', 'c': 3}
-----------------

50. 請寫出 log 實現(主要功能時打印函數名)

@log
def now():
    print ("2013-12-25")

now()

#輸出
#call now()
#2013-12-25

　　

from functools import wraps
def log(func):
    @wraps(func)
    def inner(*args,**kwargs):
        print(f"call {func.__name__}()")
        return func(*args,**kwargs)
    return inner

51. Python 如何定義一個函數

　　A. class <name>(<Type> arg1, <type> arg2, ...)　　B. function <name>(arg1,arg2,...)

　　C. def <name>(arg1, arg2,...)　　　　　　　　　　D. def <name>(<type> arg1, <type> arg2...)

52. 選擇代碼運行結果

country_counter ={}
def addone(country):
    if country in country_counter:
        country_counter[country ]+=1
    else:
        country_counter[country ]= 1

addone("China")
addone("Japan")
addone("china")
print len(country_counter )    

　　A. 0　　B. 1　　C. 2　　D. 3　　E. 4

53. 選擇輸出結果

def doff(arg1,*args):
    print type(args)

doff("applea","bananas","cherry")

　　A. str 　　B. int　　C. tuple　　D. list　　E. dict

54. 下面程序的輸出結果是

d = lambda p:p*2
t = lambda p:p*3

x = 2
x = d(x)
x = t(x)
x = d(x)
print x

24

55. 什么是 lambda 表達式？

　　匿名函數形如：lambda x,y:x+y　　一行代碼的函數

56. 以下代碼輸出是什么,請給出答案並解釋

def multipliers():
    return [lambda x:x*i for i in range(4)]

print([m(2) for m in multipliers()])

　　請修改 multipliers的定義來產生期望的結果

　#[6, 6, 6, 6]　

def multipliers():
    return (lambda x:x*i for i in range(4))

print([m(2) for m in multipliers()])

57. 有 0 < x <= 10, 10 < x <= 20, 20 < x <= 30, .，190 < x〈= 200,200 < x 這樣的21 個區間分別對應 1-21 二十一個級別，請編寫一個函數 level (x)根據輸 入數值返回對應級別。

# 方式一
import math
def level(x):
    if x <= 0: return None
    if x > 200: return 21
    return math.ceil(x / 10)


print(level(101))


# 方式二
def level(x):
    if x > 200: return 21
    m, n = divmod(x, 10)
    return m if n == 0 else m + 1


print(level(11))

58. 寫函數

　　有一個數據結構如下所示，請編寫一個函數從該結構數據中返回由指定的字段和對應的值組成的字典。如果指定字段不存在，則跳過該字段。

data:{
    "time":"2016-08-05T13:13:05",
    "some_id":"ID1234",
    "grp1":{"fld1":1, "fld2":2,},
    "xxx2":{"fld3":0, "fld4":0.4,},
     "fld6":11,
    "fld7": 7,
    "fld46":8
    }

 #fields:由"|"連接的以 fld開頭的字符串, 如 fld2|fld7|fld29

def select(data,fields):
     return result

def select(data, fields):
    result = {}
    field_list = fields.split("|")
    for k,v in data.items():
        if k in field_list:
            result[k] = data[k]
            break
        if type(v) is dict:
            k_v = select(v,fields)
            result.update(**k_v)


    return result


print(select(data, "fld2|fld7|fld29"))

59. 補全代碼

　　若要將 N個 task分配給 N個 worker同時去完成, 每個 worker分別都可以承擔這 N個 task,但費用不同. 下面的程序用回溯法計算總費用最小的一種工作分配方案, 在該方案中, 為每個 worker分配 1個 task.程序中,N個 task從 0開始順序編號, N個 worker也從 0開始順序編號, 主要的變量說明如下:

　　　　- ci:將任務 i分配給 worker j的費用

　　　　- task[i]: 值為 0表示 task i未分配, 值為 j表示 task,i分配給 worker j

　　　　- worker[k] 值為 0表示未分配 task, 值為 1表示 worker k已分配 task;

　　　　- mincost: 最小總費用

　　程序

1 N=8
 2 mincosr = 65535
 3 worker = []
 4 task = []
 5 temp = []
 6 c = []
 7 
 8 def plan(k, cost):
 9     global mincosr
10     if __(1)__ and cost<mincosr:
11          mincosr = cost
12          for i in xrange(N):
13              temp[i] = task[i]
14     else:
15          for i in xrange(N):
16              if worker[i] ==0 and __(2)__:
17                  worker[i] = 1
18                  task[k] = __(3)__
19                  plan(__(4)__,cost+c[k][i])
20                  __(5)__
21                 task[k] = 0
22 
23 def main():
24      for i in xrange(N):
25         worker.append(0)
26         task.append(0)
27         temp.append(0)
28         c.append(0)
29         for j in xrange(N):
30             print "請輸入 worker"+str(i)+"完成 task" + str(j)+"的花費"
31             input_value = input()
32             c[i].append(int(input_value))
33 plan(0,0)
34 print('\n 最小費用: '+str(mincosr))
35 for i in xrange(N):
36      print "Task"+str(i)+"is assigned to Worker" + str(temp[i])
37 
38 if __name__ == "__main__":
39     main()             

 

　　寫個函數接收一個文件夾名稱作為參數, 顯示文件夾中文件的路徑, 以及 其中包含文件夾中文件的路徑。

# 方法一
import os
def func(path):
    if os.path.isfile(path):return None
    paths=os.listdir(path)
    for i in paths:
        p = os.path.join(path,i)
        print(p)
        if os.path.isdir(p):
            func(p)

func(r'C:\Users\Administrator\Desktop\tk')

print('###################')

# 方法二
import os
def Test1(rootDir):
    list_dirs = os.walk(rootDir)
    for root, dirs, files in list_dirs:
        print(root,'====')
        for d in dirs:
            print(os.path.join(root, d))
        for f in files:
            print(os.path.join(root, f))
Test1(r'C:\Users\Administrator\Desktop\tk')