file 通信 dsw urn ria isp 其它 details 有時

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

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

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

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

62.對缺省參數的理解 ？

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

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

65.為什麽函數名字可以當做參數用?

在實際使用中，我們有時希望將函數作為參數傳遞給另一個方法使用。 比如裝飾器實際就是函數調用函數

使用函數當做入參

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

使用函數當做入參，函數本身包含參數

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

使用函數當做入參，函數本身包含不確定個數的入參

如果要調用的方法的入參個數不確定，可以使用*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 this

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

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函數？

1、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‘]

2、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 函數是一個可以接收任意多個參數(包括可選參數)並且返回單個表達式值的匿名函數

好處：
1、lambda 函數比較輕便，即用即刪除，很適合需要完成一項功能，但是此功能只在此一處使用，
連名字都很隨意的情況下；
2、匿名函數，一般用來給 filter， map 這樣的函數式編程服務;
3、作為回調函數，傳遞給某些應用，比如消息處理

一、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

參考地址：https://www.cnblogs.com/lmh001/p/9790378.html

python面試的100題（19）