python面試的100題（19）

時間 2019-11-11

標籤 python 面試欄目 Python 简体版

原文原文鏈接

61.如何在function裏面設置一個全局變量

Python中有局部變量和全局變量，當局部變量名字和全局變量名字重複時，局部變量會覆蓋掉全局變量。html

若是要給全局變量在一個函數裏賦值，必須使用global語句。global VarName的表達式會告訴Python， VarName是一個全局變量，這樣Python就不會在局部命名空間裏尋找這個變量了。python

咱們在全局命名空間裏定義一個變量money。咱們再在函數內給變量money賦值，而後Python會假定money是一個局部變量。然而，咱們並無在訪問前聲明一個局部變量money，結果就是會出現一個UnboundLocalError的錯誤。取消global語句的註釋就能解決這個問題。git

62.對缺省參數的理解？

缺省參數指在調用函數的時候沒有傳入參數的狀況下，調用默認的參數，在調用函數的同時賦值時，所傳入的參數會替代默認參數。 github

參考地址：https://blog.csdn.net/liulin1207/article/details/80889995編程

65.爲何函數名字能夠當作參數用?

在實際使用中，咱們有時但願將函數做爲參數傳遞給另外一個方法使用。

好比裝飾器實際就是函數調用函數

使用函數當作入參api

那就能夠把方法名A當作入參傳遞給方法B，調用的時候直接用【方法名()】來調用方法內容

使用函數當作入參，函數自己包含參數app

若是要調用的方法A有參數怎麼辦呢？在定義B方法的時候，也將參數傳進去，而後調用方法的時候使用【方法名(參數1，參數2)】

使用函數當作入參，函數自己包含不肯定個數的入參ssh

若是要調用的方法的入參個數不肯定，可使用*args或**args。可是必定要把*args放到最後面

參考地址：https://www.cnblogs.com/meitian/p/6756665.html

66.Python中pass語句的做用是什麼？

pass語句什麼也不作，通常做爲佔位符或者建立佔位程序，pass語句不會執行任何操做，好比：
while False:
pass
pass一般用來建立一個最簡單的類：
class MyEmptyClass:
pass
pass在軟件設計階段也常常用來做爲TODO，提醒實現相應的實現，好比：
def initlog(*args):
pass #please implement thisasync

參考地址：https://www.cnblogs.com/DjangoBlog/p/3501479.htmlide

68.如何交換兩個變量的值？

方法一:(全部語言均可以經過這種方式進行交換變量)
　　經過新添加中間變量的方式，交換數值.
　　下面經過一個demo1函數進行演示：

def demo1(a,b):
    temp = a
    a = b
    b = temp
    print(a,b)

方法二：（此方法是Python中特有的方法）

　　　　直接將a， b兩個變量放到元組中，再經過元組按照index進行賦值的方式進行從新賦值給兩個變量。

　　　　下面經過一個demo2函數進行演示:

def demo2(a,b):
    a,b = b,a
    print(a,b)

方法三：

　　經過簡單的邏輯運算進行將兩個值進行互換

　　下面經過一個demo3函數進行演示:

def demo3(a, b):
    a = a + b
    b = a - b
    a = a - b
    print(a, b)

方法四：

　　經過異或運算將兩個值互換異或運算的原理是根據二進制中的 "1^1=0 1^0=1 0^0=0"

　　下面經過一個demo4函數進行演示:

def demo4(a,b):
    a = a^b  
    b = a^b  # b = (a^b)^b = a
    a = a^b  # a = (a^b)^a = b
    print(a,b)

參考地址：https://www.cnblogs.com/aydenwang/p/9398826.html

69.map函數和reduce函數？

一、python3的map函數
map()函數接收兩個參數，一個是函數，一個是Iterable（可迭代對象），map將傳入的函數依次做用到序列的每一個元素，並把結果做爲新的Iterator（迭代器）返回。
舉例說明，好比咱們有一個函數f(x)=x2，要把這個函數做用在一個list [1, 2, 3, 4, 5, 6, 7, 8, 9]上，就能夠用map()實現以下：

>>> def f(x):
...     return x * x
...
>>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> list(r)
[1, 4, 9, 16, 25, 36, 49, 64, 81]

上述代碼中f是一個map對象，r是一個Iterator，Iterator是惰性序列，所以經過list()函數讓它把整個序列都計算出來並返回一個list。
不對r進行list函數的話，輸出結果以下：

def f(n):
    return n*n
r = map(f,[1,2,3])
print(r)

結果：

<map object at 0x000001FB4EC5D240>

map()做爲高階函數，事實上它把運算規則抽象了，所以，咱們不但能夠計算簡單的f(x)=x2，還能夠計算任意複雜的函數，好比，把這個list全部數字轉爲字符串：

>>> list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
['1', '2', '3', '4', '5', '6', '7', '8', '9']

二、python3的reduce函數

reduce把一個函數做用在一個序列[x1, x2, x3, …]上，這個函數必須接收兩個參數，reduce把結果繼續和序列的下一個元素作累積計算，其效果就是：

reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

比方說對一個序列求和，就能夠用reduce實現：

>>> from functools import reduce
>>> def add(x, y):
...     return x + y
...
>>> reduce(add, [1, 3, 5, 7, 9])
25

字符串str也是一個序列，對上面的例子稍加改動，配合map()，咱們就能夠寫出把str轉換爲int的函數：

>>> from functools import reduce
>>> def fn(x, y):
...     return x * 10 + y
...
>>> def char2num(s):
...     digits = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
...     return digits[s]
...
>>> reduce(fn, map(char2num, '13579'))
13579

參考地址：https://blog.csdn.net/jin970505/article/details/79919263

70.回調函數，如何通訊的?

在計算機程序設計中，回調函數，或簡稱回調（Callback），是指經過函數參數傳遞到其它代碼的，某一塊可執行代碼的引用。這一設計容許了底層代碼調用在高層定義的子程序。

有兩種類型的回調函數：即blocking callbacks (also known as synchronous callbacks or just callbacks) and deferred callbacks (also known as asynchronous callbacks).

那麼，在python中如何實現回調函數呢，看代碼：

def my_callback(input):
    print "function my_callback was called with %s input" % (input,)
 
def caller(input, func):
    func(input)
 
for i in range(5):
    caller(i, my_callback)

參考地址：https://www.cnblogs.com/berlin-sun/p/callbackinpython.html

71.Python主要的內置數據類型都有哪些？ print dir( ‘a ’) 的輸出？

python的數據類型有

int 整型、bool 布爾、str 字符串、list 列表、tuple 元組、dict 字典、float 浮點型小數

print(dir("a"))的輸出是

['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

輸出字符串‘a’的內建方法；

參考地址：https://www.cnblogs.com/blog-rui/p/9858803.html

72.map(lambda x:xx，[y for y in range(3)])的輸出？

lambda原型爲：lambda 參數:操做(參數)

lambda函數也叫匿名函數，即沒有具體名稱的函數，它容許快速定義單行函數，能夠用在任何須要函數的地方。這區別於def定義的函數。

lambda與def的區別：

1）def建立的方法是有名稱的，而lambda沒有。

2）lambda會返回一個函數對象，但這個對象不會賦給一個標識符，而def則會把函數對象賦值給一個變量（函數名）。

3）lambda只是一個表達式，而def則是一個語句。

4）lambda表達式」 : 「後面，只能有一個表達式，def則能夠有多個。

5）像if或for或print等語句不能用於lambda中，def能夠。

6）lambda通常用來定義簡單的函數，而def能夠定義複雜的函數。
將一個 list 裏的每一個元素都平方：

map( lambda x: x*x, [y for y in range(10)] )

這個寫法要好過

def sq(x):
    return x * x
 
map(sq, [y for y in range(10)])

由於後者多定義了一個（污染環境的）函數，尤爲若是這個函數只會使用一次的話。

進一步講，匿名函數本質上就是一個函數，它所抽象出來的東西是一組運算。這是什麼意思呢？類比

a = [1, 2, 3]

和

f = lambda x : x + 1

咱們會發現，等號右邊的東西徹底能夠脫離等號左邊的東西而存在，等號左邊的名字只是右邊之實體的標識符。若是能習慣 [1, 2, 3] 單獨存在，那麼 lambda x : x + 1 也能單獨存在其實也就不難理解了，它的意義就是給「某個數加一」這一運算自己。

如今回頭來看 map() 函數，它能夠將一個函數映射到一個可枚舉類型上面。沿用上面給出的 a 和 f，能夠寫

map(f, a)

也就是將函數 f 依次套用在 a 的每個元素上面，得到結果 [2, 3, 4]。如今用 lambda 表達式來替換 f，就變成：

map( lambda x : x + 1, [1, 2, 3] )

會不會以爲如今很一目瞭然了？尤爲是類比

a = [1, 2, 3]
r = []
for each in a:
    r.append(each+1)

參考地址：https://i.cnblogs.com/EditPosts.aspx?opt=1

73.hasattr() getattr() setattr() 函數使用詳解？

hasattr(object, name)
判斷一個對象裏面是否有name屬性或者name方法，返回BOOL值，有name特性返回True，不然返回False。
須要注意的是name要用括號括起來

  >>> class test():
  ...     name="xiaohua"
  ...     def run(self):
  ...             return "HelloWord"
  ...
 >>> t=test()
  >>> hasattr(t, "name") #判斷對象有name屬性
  True
  >>> hasattr(t, "run")  #判斷對象有run方法
 True
 >>>

getattr(object, name[,default])
獲取對象object的屬性或者方法，若是存在打印出來，若是不存在，打印出默認值，默認值可選。
須要注意的是，若是是返回的對象的方法，返回的是方法的內存地址，若是須要運行這個方法，
能夠在後面添加一對括號。

 1 >>> class test():
 2 ...     name="xiaohua"
 3 ...     def run(self):
 4 ...             return "HelloWord"
 5 ...
 6 >>> t=test()
 7 >>> getattr(t, "name") #獲取name屬性，存在就打印出來。
 8 'xiaohua'
 9 >>> getattr(t, "run")  #獲取run方法，存在就打印出方法的內存地址。
10 <bound method test.run of <__main__.test instance at 0x0269C878>>
11 >>> getattr(t, "run")()  #獲取run方法，後面加括號能夠將這個方法運行。
12 'HelloWord'
13 >>> getattr(t, "age")  #獲取一個不存在的屬性。
14 Traceback (most recent call last):
15   File "<stdin>", line 1, in <module>
16 AttributeError: test instance has no attribute 'age'
17 >>> getattr(t, "age","18")  #若屬性不存在，返回一個默認值。
18 '18'

setattr(object, name, values)
給對象的屬性賦值，若屬性不存在，先建立再賦值。

 1 >>> class test():
 2 ...     name="xiaohua"
 3 ...     def run(self):
 4 ...             return "HelloWord"
 5 ...
 6 >>> t=test()
 7 >>> hasattr(t, "age")   #判斷屬性是否存在
 8 False
 9 >>> setattr(t, "age", "18")   #爲屬相賦值，並無返回值
10 >>> hasattr(t, "age")    #屬性存在了
11 True
12 >>>

一種綜合的用法是：判斷一個對象的屬性是否存在，若不存在就添加該屬性

1 >>> class test():
 2 ...     name="xiaohua"
 3 ...     def run(self):
 4 ...             return "HelloWord"
 5 ...
 6 >>> t=test()
 7 >>> getattr(t, "age")    #age屬性不存在
 8 Traceback (most recent call last):
 9   File "<stdin>", line 1, in <module>
10 AttributeError: test instance has no attribute 'age'
11 >>> getattr(t, "age", setattr(t, "age", "18")) #age屬性不存在時，設置該屬性
12 '18'
13 >>> getattr(t, "age")  #可檢測設置成功
14 '18'
15 >>>

參考地址：https://www.cnblogs.com/cenyu/p/5713686.html

74.一句話解決階乘函數？

def factorial(num):
    j = 1
    for i in range(1,num+1):
        j = j*i
    print(j)

num = int(input("請輸入階乘數字："))
factorial(num)

參考地址：https://www.cnblogs.com/gengyi/p/7967076.html

75.什麼是lambda函數？有什麼好處？

lambda 函數是一個能夠接收任意多個參數(包括可選參數)而且返回單個表達式值的匿名函數

好處：
一、lambda 函數比較輕便，即用即刪除，很適合須要完成一項功能，可是此功能只在此一處使用，
連名字都很隨意的狀況下；
二、匿名函數，通常用來給 filter， map 這樣的函數式編程服務;
三、做爲回調函數，傳遞給某些應用，好比消息處理

1、lambda函數的語法

　lambda語句中，冒號前是參數，能夠有0個或多個，用逗號隔開，冒號右邊是返回值。lambda語句構建的實際上是一個函數對象。

　1》無參數：

f = lambda:'Hello python lambda'
f()
#'Hello python lambda'

2》有參數，無默認值

f = lambda x,y: x*y
f(6,7)
#42

3》有參數，有默認值

f = lambda x=5, y=8: x*y
f()
#40
f(5,6)
#30

4》和map, reduce, filter連用

foo = [2, 18, 9, 22, 17, 24, 8, 12, 27]
 
print filter(lambda x: x % 3 == 0, foo)#python 2.x
list( filter(lambda x: x % 3 == 0, foo) )#python 3.x
#[18, 9, 24, 12, 27]
 
print map(lambda x: x * 2 + 10, foo)#python 2.x
list( map(lambda x: x * 2 + 10, foo) )#python 3.x
#[14, 46, 28, 54, 44, 58, 26, 34, 64]
 
from functools import reduce#python 3.x need import reduce
reduce(lambda x, y: x + y, foo)
#139