學習Python一年，基礎忘記了，看看面試題回憶回議，Python面試題No3

這邊有幾個面試題，好棒

第1題：你如何管理不一樣版本的代碼？

git,svn兩個都要說到，github，碼雲也要說起，面試官想要的就是版本管理工具，你只要選擇一個你熟悉的，瘋狂的說一通就能夠了，最好說一下本身之前作過哪些開源的項目，放在上面，沒有，就另當別論了。

第2題：python中生成隨機整數、隨機小數、0~1之間小數方法？

python中生成隨機整數

import random
random.randint(1,10)
複製代碼

隨機小數

看本身習慣，能夠用random庫，也能夠用numpy庫

import random
random.random()

# 利用np.random.randn(5)生成5個隨機小數
import numpy as np
np.random.randn(5)
複製代碼

0~1之間小數

random.random()
複製代碼

第3題：迭代器、可迭代對象、生成器？

第一步，你要知道什麼是迭代

對list、tuple、str等類型的數據使用for...in...的循環語法從其中依次拿到數據進行使用，咱們把這樣的過程稱爲遍歷，也叫迭代。

從結果去分析緣由，能被for循環的就是「可迭代的」，可是若是正着想，for怎麼知道誰是可迭代的呢？

假如咱們本身寫了一個數據類型，但願這個數據類型裏的東西也可使用for被一個一個的取出來，那咱們就必須知足for的要求--- 這個要求就叫作 協議。

能夠被迭代要知足的要求就叫作：可迭代協議。

可迭代協議的定義很是簡單，就是內部實現了__iter()__方法

若是某個對象中有_ iter _()方法，這個對象就是可迭代對象 （Iterable）

if '__iter__' in dir(str)
複製代碼

通俗易懂 ：能夠被for循環迭代的對象就是可迭代對象。

從代碼上面可使用isinstance()判斷一個對象是不是Iterable對象

from collections import Iterable
a = isinstance([], Iterable)

b = isinstance({}, Iterable)

c = isinstance('abc', Iterable)

d = isinstance((x for x in range(10)), Iterable)

e = isinstance(100, Iterable)

print(a,b,c,d,e)
複製代碼

結論

True True True True False
複製代碼

只有最後的數字不是可迭代對象

可迭代對象的本質

咱們分析對可迭代對象進行迭代使用的過程，發現每迭代一次（即在for...in...中每循環一次）都會返回對象中的下一條數據，一直向後讀取數據直到迭代了全部數據後結束。

那麼，在這個過程當中就應該有一個「人」去記錄每次訪問到了第幾條數據，以便每次迭代均可以返回下一條數據。

咱們把這個能幫助咱們進行數據迭代的「人」稱爲迭代器(Iterator)

可迭代對象的本質就是能夠 向咱們提供一個這樣的中間「人」即迭代器 幫助咱們對其進行迭代遍歷使用。

可迭代對象經過__iter__方法向咱們提供一個迭代器，在迭代一個可迭代對象的時候，實際上就是先獲取該對象提供的一個迭代器，而後經過這個迭代器來依次獲取對象中的每個數據。

綜上所述，一個具有了__iter__方法的對象，就是一個可迭代對象。

class MyList(object):
    def __init__(self):
        self.container = []
    def add(self, item):
        self.container.append(item)
    def __iter__(self):
        """返回一個迭代器"""
        # 咱們暫時忽略如何構造一個迭代器對象
        pass
    
mylist = MyList()
from collections import Iterable
isinstance(mylist, Iterable)

複製代碼

iter()函數與next()函數

list、tuple等都是可迭代對象，咱們能夠經過iter()函數獲取這些可迭代對象的迭代器。 而後咱們能夠對獲取到的迭代器不斷使用next()函數來獲取下一條數據。iter()函數實際上就是調用了可迭代對象的__iter__方法。

>>> i = iter('spam')
>>> next(i)
's'
>>> next(i)
'p'
>>> next(i)
'a'
>>> next(i)
'm'
>>> next(i)
Traceback (most recent call last):
  File "<pyshell#5>", line 1, in <module>
    next(i)
StopIteration
>>> 

複製代碼

當序列遍歷完時，將拋出一個StopIteration異常。這將使迭代器與循環兼容，由於它們將捕獲這個異常以中止循環。 要建立定製的迭代器，能夠編寫一個具備next方法的類。

迭代器Iterator

經過上面的分析，如今你應該已經知道了，迭代器是用來幫助咱們記錄每次迭代訪問到的位置，當咱們對迭代器使用next()函數的時候，迭代器會向咱們返回它所記錄位置的下一個位置的數據。 實際上，在使用next()函數的時候，調用的就是迭代器對象的__next__方法（Python3中是對象的__next__方法，Python2中是對象的next()方法）。

因此，咱們要想構造一個迭代器，就要實現它的__next__方法。但這還不夠，python要求迭代器自己也是可迭代的，因此咱們還要爲迭代器實現__iter__方法，而__iter__方法要返回一個迭代器，迭代器自身正是一個迭代器，因此迭代器的__iter__方法返回自身便可。

一個實現了__iter__方法和__next__方法的對象，就是迭代器。

class MyList(object):
    """自定義的一個可迭代對象"""
    def __init__(self):
        self.items = []
 
    def add(self, val):
        self.items.append(val)
 
    def __iter__(self):
        myiterator = MyIterator(self)
        return myiterator
 
 
class MyIterator(object):
    """自定義的供上面可迭代對象使用的一個迭代器"""
    def __init__(self, mylist):
        self.mylist = mylist
        # current用來記錄當前訪問到的位置
        self.current = 0
 
    def __next__(self):
        if self.current < len(self.mylist.items):
            item = self.mylist.items[self.current]
            self.current += 1
            return item
        else:
            raise StopIteration
 
    def __iter__(self):
        return self
 
 
if __name__ == '__main__':
    mylist = MyList()
    mylist.add(1)
    mylist.add(2)
    mylist.add(3)
    mylist.add(4)
    mylist.add(5)
    for num in mylist:
        print(num)
複製代碼

本部分代碼來源： blog.csdn.net/weixin_4222… 博主這篇博客寫的真好

可迭代對象與迭代器

1. 可迭代對象包含迭代器。
2. 若是一個對象擁有__iter__方法，那麼它是可迭代對象；若是一個對象擁有next方法，其是迭代器。
3. 定義可迭代對象，必須實現__iter__方法；定義迭代器，必須實現__iter__和next方法。

• _iter_() 該方法返回的是當前對象的迭代器類的實例。由於可迭代對象與迭代器都要實現這個方法

• next() 返回迭代的每一步，實現該方法時注意要最後超出邊界要拋出StopIteration異常。

迭代器必定是可迭代對象，反過來則不必定成立。用iter()函數能夠把list、dict、str等Iterable變成Iterator

生成器

1. 生成器是一種特殊的迭代器，生成器自動實現了「迭代器協議」（即__iter__和next方法），不須要再手動實現兩方法。
2. 生成器在迭代的過程當中能夠改變當前迭代值，而修改普通迭代器的當前迭代值每每會發生異常，影響程序的執行。
3. 具備yield關鍵字的函數都是生成器，yield能夠理解爲return，返回後面的值給調用者。不一樣的是return返回後，函數會釋放，而生成器則不會。在直接調用next方法或用for語句進行下一次迭代時，生成器會從yield下一句開始執行，直至遇到下一個yield。

第4題：單引號，雙引號，三引號的區別？

• 單引號和雙引號主要用來表示字符串

  好比: 
    單引號:'python'
    雙引號:"python"
  複製代碼

• 三引號

三單引號:'''python '''，也能夠表示字符串通常用來輸入多行文本，或者用於大段的註釋； 三雙引號："""python"""，通常用在類裏面,用來註釋類,這樣省的寫文檔,直接用類的對象__doc__訪問得到文檔。

區別

若你的字符串裏面自己包含單引號,必須用雙引號

例子:"can't find the log\n"
複製代碼

第5題：Python是如何進行內存管理的？

對象的引用計數機制 Python內部使用引用計數，來保持追蹤內存中的對象，全部對象都有引用計數。

引用計數增長的狀況：

總結一下對象會在一下狀況下引用計數加1：

1. 對象被建立：x='spam'
2. 另外的別人被建立：y=x
3. 被做爲參數傳遞給函數：foo(x)
4. 做爲容器對象的一個元素：a=[1,x,'33']

引用計數減小狀況

1. 一個本地引用離開了它的做用域。好比上面的foo(x)函數結束時，x指向的對象引用減1。
2. 對象的別名被顯式的銷燬：del x ；或者del y
3. 對象的一個別名被賦值給其餘對象：x=789
4. 對象從一個窗口對象中移除：myList.remove(x)
5. 窗口對象自己被銷燬：del myList，或者窗口對象自己離開了做用域。

垃圾回收

1. 當內存中有再也不使用的部分時，垃圾收集器就會把他們清理掉。它會去檢查那些引用計數爲0的對象，而後清除其在內存的空間。固然除了引用計數爲0的會被清除，還有一種狀況也會被垃圾收集器清掉：當兩個對象相互引用時，他們自己其餘的引用已經爲0了。
2. 垃圾回收機制還有一個循環垃圾回收器, 確保釋放循環引用對象(a引用b, b引用a, 致使其引用計數永遠不爲0)。

在Python中，許多時候申請的內存都是小塊的內存，這些小塊內存在申請後，很快又會被釋放，因爲這些內存的申請並非爲了建立對象，因此並無對象一級的內存池機制。這就意味着Python在運行期間會大量地執行malloc和free的操做，頻繁地在用戶態和核心態之間進行切換，這將嚴重影響Python的執行效率。爲了加速Python的執行效率，Python引入了一個內存池機制，用於管理對小塊內存的申請和釋放。

內存池機制

1. Python提供了對內存的垃圾收集機制，可是它將不用的內存放到內存池而不是返回給操做系統；
2. Pymalloc機制：爲了加速Python的執行效率，Python引入了一個內存池機制，用於管理對小塊內存的申請和釋放；
3. 對於Python對象，如整數，浮點數和List，都有其獨立的私有內存池，對象間不共享他們的內存池。也就是說若是你分配又釋放了大量的整數，用於緩存這些整數的內存就不能再分配給浮點數。

第6題：寫一個函數, 輸入一個字符串, 返回倒序排列的結果？

使用字符串自己的翻轉

def order_by(str):
    return str[::-1]
 
print(order_by('123456'))
 
輸出：654321
複製代碼

把字符串變爲列表，用列表的reverse函數

def reverse2(text='abcdef'):
    new_text=list(text)
    new_text.reverse()
    return ''.join(new_text)

reverse2('abcdef')

複製代碼

新建一個列表，從後往前取

def reverse3(text='abcdef'):
    new_text=[]
    for i in range(1,len(text)+1):
        new_text.append(text[-i])
    return ''.join(new_text)

reverse3('abcdef')

複製代碼

利用雙向列表deque中的extendleft函數

from collections import deque
def reverse4(text='abcdef'):
    d = deque()
    d.extendleft(text)
    return ''.join(d)

reverse4('abcdef')
複製代碼

微信搜索：非本科程序員

關注微信公衆號「非本科程序員」，獲取2T學習資源