本片文章部分參考地址：https://segmentfault.com/a/1190000018737045

python是動(dòng)態(tài)解釋性的強(qiáng)類型定義語言

強(qiáng)類型：不允許不同類型相加。例如：整形+字符串會(huì)報(bào)類型錯(cuò)誤。

動(dòng)態(tài)：不使用顯示數(shù)據(jù)類型聲明，且確定一個(gè)變量的類型是在第一次給它賦值的時(shí)候。

腳本語言：一般是解釋性語言，運(yùn)行代碼只需要一個(gè)解釋器，不需要編輯。

Python

面向?qū)ο驩OP

魔法方法：

__init__用來做變量初始化 或 賦值 操作，在類實(shí)例化對象的時(shí)候，會(huì)被自動(dòng)調(diào)用

__new__返回父類的new出來的實(shí)例self，或直接是object的new出來的實(shí)例self–>比init先調(diào)用生成實(shí)例供init用

__str__return 一個(gè)數(shù)據(jù)，并且只有self一個(gè)參數(shù)，當(dāng)在類的外部 print(對象) 則打印這個(gè)數(shù)據(jù)

__del__析構(gòu)函數(shù)，當(dāng)刪除對象時(shí)，python解釋器也會(huì)默認(rèn)調(diào)用

python面向?qū)ο筇匦?#xff1a;

封裝： 封裝就是把類中的屬性和方法定義為私有的，python會(huì)自動(dòng)將其轉(zhuǎn)換為_類名__屬性名（方法名）的格式,子類無法對進(jìn)行修改

繼承： 關(guān)于__mro__方法解析順序，新式類是廣度優(yōu)先查找,經(jīng)典類是深度優(yōu)先，

多態(tài)： python弱化了多態(tài)概念：不管對象類型，只要對象有該方法就可執(zhí)行。關(guān)于面向?qū)ο蟮亩鄳B(tài)理解，建議參考鴨子類型。

? ------ 鴨子類型： Python在使用傳入?yún)?shù)的過程中不會(huì)默認(rèn)判斷參數(shù)類型，只要參數(shù)具備執(zhí)行條件就可以執(zhí)行

新式類和經(jīng)典類：

2.2出現(xiàn)新式類，3全是新式類，新式類是廣度優(yōu)先查找,經(jīng)典類是深度優(yōu)先；

? 重點(diǎn)： 新式類的廣度優(yōu)先解決了經(jīng)典類的mro查找忽略同一級別的屬性的bug

使用dir()方法也可以看出新式類中定義很多新的屬性和方法

(new，call，dict模塊\屬性\方法\doc,class對象屬于的類，...等)，

而經(jīng)典類好像就2個(gè)(doc文檔,module屬于哪個(gè)模塊)：

靜態(tài)方法和類方法和實(shí)例方法

\實(shí)例方法類方法 @classmethod傳cls靜態(tài)方法@staticmethod不傳self和cls

a = A()	a.foo(x)	a.class_foo(x)	a.static_foo(x)
A	不可用	A.class_foo(x)	A.static_foo(x)

Python自省（特性）

自省就是面向?qū)ο蟮恼Z言通過一定的機(jī)制查詢到對象的內(nèi)部結(jié)構(gòu)

比如dir(對象), 對象.__dict__

Python元類 type(future_class_name, future_class_parents元祖, uppercase_attr字典)#返回一個(gè)類

創(chuàng)建類的類，元類要繼承type，創(chuàng)建一個(gè)類的時(shí)候，他還沒有在內(nèi)存中生成，直到被調(diào)用：

python做了如下操作：依次在—>當(dāng)前類中–>父類中–>模塊層次中–>查看有沒有__metacalss__屬性，都沒有就會(huì)調(diào)用內(nèi)置元類type創(chuàng)建這個(gè)類對象。

ORM（對象關(guān)系映射）核心：數(shù)據(jù)描述符和元類

優(yōu)缺點(diǎn)：

1）只需要面向?qū)ο缶幊? 不需要面向數(shù)據(jù)庫編寫代碼，對數(shù)據(jù)庫的操作都轉(zhuǎn)化成對類屬性和方法的操作.不用編寫各種數(shù)據(jù)庫的sql語句.

2）實(shí)現(xiàn)了數(shù)據(jù)模型與數(shù)據(jù)庫的解耦, 屏蔽了不同數(shù)據(jù)庫操作上的差異.不在關(guān)注用的是mysql，oracle…等.通過簡單的配置就可以輕松更換數(shù)據(jù)庫, 而不需要修改代碼.

3）在映射過程中有性能缺失，面向?qū)ο缶幊痰絪ql語句之間的映射需要過程時(shí)間，造成性能缺失

定義一個(gè)ORM:

class Field:passclass CharField(Field):'''數(shù)據(jù)描述符, 好處在于可以在各方法中校驗(yàn)傳入值的合理性'''def __init__(self, col_name, max_length):if col_name is None or not isinstance(col_name, str):raise ValueError("col_name must be given as str")if max_length is None or not isinstance(max_length, numbers.Integral):raise ValueError("max_length must be given as int")self._col_name = col_nameself._max_length = max_lengthdef __get__(self, instance, owner):# return getattr(instance, self._col_name)return instance.fields[self._col_name]def __set__(self, instance, value):# 這里如果col_name和數(shù)據(jù)描述符對應(yīng)的名字一樣的話,如name=CharField(col_name="name",10)# 用setattr(instance, self._col_name, value)即user.name=value會(huì)再次進(jìn)入此__set__方法,導(dǎo)致無限遞歸instance.fields[self._col_name] = valueclass ModelMetaClass(type):'''元類'''def __new__(cls, cls_name, base_class, attrs):if cls_name == "Model":return super().__new__(cls, cls_name, base_class, attrs)fields = {}for k, v in attrs.items():if isinstance(v, Field):fields[k] = vattrs["fields"] = fields_meta = {}attrs_meta = attrs.get("Meta", None)if attrs_meta is not None and isinstance(attrs_meta, type):_meta["tb_name"] = getattr(attrs_meta, "tb_name", cls_name)del attrs["Meta"]else:_meta["tb_name"] = cls_name.lower()attrs["_meta"] = _metareturn super().__new__(cls, cls_name, base_class, attrs)class Model(metaclass=ModelMetaClass): # 指定要使用的元類def __init__(self, **kwargs):self.fields = {}for k, v in kwargs.items():setattr(self, k, v)# def more_func(self):# passclass User(Model):name = CharField(col_name="name", max_length=10)sex = CharField(col_name="sex", max_length=1)age = IntField(col_name="age", min_length=1, max_length=10)class Meta:tb_name = "User"

設(shè)計(jì)模式

單例模式：

該模式的主要目的是確保某一個(gè)類只有一個(gè)實(shí)例存在。當(dāng)你希望在整個(gè)系統(tǒng)中，某個(gè)類只能出現(xiàn)一個(gè)實(shí)例時(shí)，單例對象就能派上用場。（比如系統(tǒng)回收站）

# __new__方法實(shí)現(xiàn) class Singleton(object):def __new__(cls,*args,**kw)if not hasattr(cls,'_instance')cls._instance = super(Singleton,cls).__new__(cls,*args,**kw)return cls._instance # 創(chuàng)建一個(gè)類的實(shí)例或者繼承這個(gè)類的就是單例類 # 裝飾器方法 def singleton(cls,*args,**kwargs):instances={}def getinstance():if cls not in instances:instances[cls]=cls(*args,**kwargs)return instances[cls]return getinstance @singleton class MyClass(object):pass# 還有import 一個(gè)類的實(shí)例，就是天然的單例

工廠模式

核心的思想是： 通過傳遞給類或函數(shù)某種產(chǎn)品的信息來創(chuàng)建產(chǎn)品并返回。當(dāng)我們想得到產(chǎn)品a對象，只需把產(chǎn)品a的名字傳遞給工廠函數(shù)就能得到產(chǎn)品a對象。

import abcclass A(object):def __init__(self, product_type):self.product_type = product_typedef __str__(self):return 'product %s' % self.product_typeclass B(object):def __init__(self, product_type):self.product_type = product_typedef __str__(self):return 'product %s' % self.product_typeclass Abstract_factory(object):__metaclass__ = abc.ABCMeta@abc.abstractmethoddef yield_product(self):passclass Factory_a(Abstract_factory):def yield_product(self):return A('A')class Factory_b(Abstract_factory):def yield_product(self):return B('B')def factory(product_type):if product_type == 'A':return Factory_a()if product_type == 'B':return Factory_b()if __name__ == '__main__':factory_a = factory('A')a = factory_a.yield_product()factory_b = factory('B')b = factory_b.yield_product()print(a)print(b)

Python基礎(chǔ)

Py2和Py3區(qū)別

區(qū)別py2py3

print	print是一個(gè)打印語句	函數(shù) 可以多個(gè)位置的參數(shù)
input	raw_input得到str	input得到str
整除	3/2 -->1 但3/2.0–>1.5	3//2 得到1
range	range(4)–>[0,1,2,3]列表	range(4) 得到可迭代對象（type是對象）
xrange	xrange(4)–>生成器	只有range
unicode	默認(rèn)ASC II ，unicode() 是單獨(dú)的	源碼文件默認(rèn)使用utf-8編碼
nonlocal關(guān)鍵字	函數(shù)內(nèi)變量就是局部變量	可聲明為非局部變量，可以在外使用
True.False	視為全局變量，隨意賦值	變成關(guān)鍵字，指向固定對象，不能重新賦值。

Python中的list

是分離式的元素外置順序表，表頭區(qū)，元素區(qū)存id地址，數(shù)據(jù)區(qū)存數(shù)據(jù)可以不連續(xù)的內(nèi)存

dict底層結(jié)構(gòu)

• 為了支持快速查找使用了哈希表作為底層結(jié)構(gòu)

• 哈希表平均查找時(shí)間復(fù)雜度為o(1)

• CPython解釋器使用二次探查解決哈希沖突問題

字符串處理方法

mystr.find(str, start=0, end=len(mystr)) # 有返回下標(biāo)索引==無返回-1mystr.strip() # 刪除兩邊空白字符mystr.splitlines() # 按行分隔成列表mystr.split("，", 1) # 默認(rèn)全部分割,1代表分割第一個(gè)a.isalnum # 判斷全是字母數(shù)字"_".join(list) #每個(gè)元素后面加一個(gè)字符串_變成str

賦值、淺拷貝和深拷貝

• 直接賦值：其實(shí)就是對象的引用（別名）。=

• 淺拷貝(copy)：拷貝父對象，不會(huì)拷貝對象的內(nèi)部的子對象。切片，工廠函數(shù)list(), copy.copy()

• 深拷貝(deepcopy)： copy 模塊的 deepcopy 方法，完全拷貝了父對象及其子對象。

  ?
  python函數(shù)式編程 map，filter，reduce

# 高階函數(shù)--》函數(shù)的參數(shù)能夠接收別的函數(shù)。 map(lambda x: x * x, [1,3,4])) # 每個(gè)數(shù)都平方得到一個(gè)新迭代器 filter(lambda x:x%2==1,[1,2,3,4,5,6,7]) # 過濾掉列表中的奇數(shù)，第二個(gè)參數(shù)是可迭代對象或者迭代器 reduce(lambda x, y: x+y, [1,2,3,4,5]) # 計(jì)算列表和：1+2+3+4+5 sorted([36, 5, -12, 9, -21], key=abs[,reverse=True]) # 按絕對值大小排序 [3,4,2].sort(key=lambda x : x+1) # 對原列表更改

類裝飾器：要實(shí)現(xiàn)init和call方法
閉包裝飾器：外函數(shù)返回內(nèi)函數(shù)的引用，內(nèi)函數(shù)使用外函數(shù)的局部變量并調(diào)用被裝飾函數(shù)

def log(func):@functools.wraps(func) # 讓now函數(shù)的名字還是原來的__name__def wrapper(*args, **kw):print('call %s():' % func.__name__)return func(*args, **kw)return wrapper @log # 把@log放到now()函數(shù)的定義處，相當(dāng)于執(zhí)行了語句：log = log(now) def now():print('2015-3-25')# 裝飾器傳參 def log(text):def decorator(func):@functools.wraps(func)def wrapper(*args, **kw):print('%s %s():' % (text, func.__name__))return func(*args, **kw)return wrapperreturn decorator @log('execute') # 相當(dāng)于執(zhí)行 now = log('execute')(now) def now():print('2015-3-25')

垃圾回收機(jī)制

• （主）引用計(jì)數(shù)（reference counting）： 引用計(jì)數(shù)為0時(shí)，該對象生命就結(jié)束了。維護(hù)引用計(jì)數(shù)消耗資源，循環(huán)引用L.append(L) L一直不回收

• （輔）標(biāo)記清除機(jī)制（mark and sweep）： 不改變真實(shí)引用計(jì)數(shù)，復(fù)制一份，如果A引用了B，將B計(jì)數(shù)-1，B也引用了A，將A也-1，這樣就顯示出了真是的引用計(jì)數(shù)

• （輔）分代計(jì)數(shù)： 將系統(tǒng)中的所有內(nèi)存塊根據(jù)其存活時(shí)間劃分為不同的集合，每一個(gè)集合就成為一個(gè)“代”，垃圾收集的頻率隨著“代”的存活時(shí)間的增大而減小。也就是說，活得越長的對象，就越不可能是垃圾，就應(yīng)該減少對它的垃圾收集頻率。那么如何來衡量這個(gè)存活時(shí)間：通常是利用幾次垃圾收集動(dòng)作來衡量，如果一個(gè)對象經(jīng)過的垃圾收集次數(shù)越多，可以得出：該對象存活時(shí)間就越長。

  面試回答： Python的GC模塊主要運(yùn)用了“引用計(jì)數(shù)”來跟蹤和回收垃圾。在引用計(jì)數(shù)的基礎(chǔ)上，還可以通過“標(biāo)記-清除”解決容器對象可能產(chǎn)生的循環(huán)引用的問題。通過“分代回收”以空間換取時(shí)間來進(jìn)一步提高垃圾回收的效率。

sys模塊幾個(gè)常用方法

• argv 命令行參數(shù)list,第一個(gè)是程序本身的路徑
• path 返回模塊的搜索路徑
• modules.keys() 返回已經(jīng)導(dǎo)入的所有模塊的列表
• exit(0) 退出程序

OS模塊幾個(gè)常用方法

os.system(command) #函數(shù)用來運(yùn)行shell命令

os.path模塊：
abspath(path) #返回絕對路徑
basename§ #返回路徑的最后一個(gè)/后面的內(nèi)容
dirname(file) #返回當(dāng)前文件/的目錄名 __file__也可以目錄
exits(path) #測試一個(gè)目錄存在與否
isabs(s) #判斷一個(gè)路徑是否是絕對路徑
isdir(s) #判斷是不是目錄
isfile(path) #判斷是不是文件
join(‘路徑’，‘路徑/文件’) #os.path.join(os.path.dirname(BASE_DIR), “l(fā)ogs/meiduo.log”)

globals/locals(可以變相操作代碼)

• globals中保存了當(dāng)前模塊中所有的變量屬性與值
• locals中保存了當(dāng)前環(huán)境中的所有變量屬性與值

實(shí)現(xiàn)從1-100每三個(gè)為一組分組

print([[x for x in range(1,101)][i:i+3] for i in range(0,100,3)])

單元測試

import unittest class MyTest(unittest.TestCase): # 繼承自TestCase 單獨(dú)運(yùn)行文件# 測試開始的方法def setUp(self):print("setup")#測試方法 必須test_開頭 可以多個(gè) 光標(biāo)放在哪個(gè)函數(shù)的內(nèi)部,就執(zhí)行哪個(gè)測試方法def test_login(self):print("test_login")# 測試結(jié)束的方法def tearDown(self):print("teardown")

GIL全局解釋器鎖

• 同一時(shí)間只能有一個(gè)線程執(zhí)行，競爭的是cpu內(nèi)存資源，CPython的特點(diǎn)，其他解釋器不存在

• cpu密集型：多進(jìn)程+進(jìn)程池

• io密集型：多線程/協(xié)程

  • **釋放：**GIL會(huì)根據(jù)執(zhí)行的字節(jié)碼行數(shù)以及時(shí)間片釋放GIL，GIL在遇到io的操作時(shí)候主動(dòng)釋放

  tip：什么是Cpython==將python解釋成C代碼工具

進(jìn)程，線程，協(xié)程，鎖

• 進(jìn)程：系統(tǒng)資源分配的最小單位, 一個(gè)運(yùn)行的程序(代碼)就是一個(gè)進(jìn)程,進(jìn)程擁有自己獨(dú)立的內(nèi)存空間,所以進(jìn)程間數(shù)據(jù)不共享,開銷大
  • **進(jìn)程做并發(fā)處理：**Linux系統(tǒng)函數(shù)fork()可以在父進(jìn)程中創(chuàng)建一個(gè)子進(jìn)程，這樣的話，在一個(gè)進(jìn)程接到來自客戶端新的請求時(shí)就可以復(fù)制出一個(gè)子進(jìn)程讓其來處理，父進(jìn)程只需負(fù)責(zé)監(jiān)控請求的到來，然后創(chuàng)建子進(jìn)程讓其去處理，這樣就能做到并發(fā)處理。
• 線程：調(diào)度執(zhí)行的最小單位, 依賴進(jìn)程存在. 一個(gè)進(jìn)程至少有一個(gè)線程,叫主線程,而多個(gè)線程共享內(nèi)存(數(shù)據(jù)共享,共享全局變量),從而極大地提高了程序的運(yùn)行效率.
• 協(xié)程：用戶層面的輕量級的線程，由程序員根據(jù)需要自己調(diào)度。我們把一個(gè)線程中的一個(gè)個(gè)函數(shù)叫做子程序，那么子程序在執(zhí)行過程中可以中斷去執(zhí)行別的子程序；別的子程序也可以中斷回來繼續(xù)執(zhí)行之前的子程序，這就是協(xié)程。
  • 協(xié)程包gevent有個(gè)monkey.patch_all()補(bǔ)丁，讓gevent框架識(shí)別耗時(shí)操作，比如：time.sleep，網(wǎng)絡(luò)請求延時(shí)

鎖

• 線程互斥鎖：當(dāng)多個(gè)線程同時(shí)修改同一條數(shù)據(jù)時(shí)可能會(huì)出現(xiàn)臟數(shù)據(jù)，產(chǎn)生了互斥鎖保證同一時(shí)刻只有一個(gè)線程訪問數(shù)據(jù) threading.Lock()

• 線程安全：因?yàn)槎嗑€程是共享系統(tǒng)資源的，有了互斥鎖，每個(gè)線程對數(shù)據(jù)進(jìn)程操作都能得到正確的結(jié)果

  ?

避免死鎖

死鎖：2個(gè)線程互相等待對方的鎖，互相占用著資源不釋放， 某一個(gè)線程沒有正常釋放鎖

利用上下文管理器with 自動(dòng)申請并釋放鎖

with在執(zhí)行時(shí)需要這兩個(gè)方法：__enter__與__exit__ 比如open就有

進(jìn)程與線程的使用場景

• 多進(jìn)程適合在CPU密集型操作(CPU指令比較多, 如位數(shù)多的浮點(diǎn)運(yùn)算).
• 多線程適合在IO密集型操作(讀寫數(shù)據(jù)操作較多的, 比如爬蟲)

**進(jìn)程間通訊 **multiprocessing中的Manager類和Pipe類和Queue類，進(jìn)程池用Manager().Queue(10)

• Manager().dict()

  progress_dict = Manager().dict() # 傳給子進(jìn)程任務(wù)函數(shù)

• Pipe(適用于兩個(gè)進(jìn)程) 管道

  recevie_pipe, send_pipe = Pipe() # 傳給接受和發(fā)送的任務(wù)函數(shù)

• Queue（10） 消息隊(duì)列

  queue = Queue(10) # 傳給子進(jìn)程 queue.get(),queue.put()

unix進(jìn)程間通信方式(IPC)

• 管道pipe：兩個(gè)親戚進(jìn)程

• 命名管道named pipe：允許不是親戚的進(jìn)程間通信

• 信號(hào)signal：信號(hào)是比較復(fù)雜的通信方式，用于通知接受進(jìn)程有某種事件發(fā)生

• 消息隊(duì)列message： 息隊(duì)列克服了信號(hào)承載信息量少，管道只能承載無格式字節(jié)流以及緩沖區(qū)大小受限等缺

• 共享內(nèi)存、使得多個(gè)進(jìn)程可以訪問同一塊內(nèi)存空間，是最快的可用IPC形

• 內(nèi)存映射：內(nèi)存映射允許任何多個(gè)進(jìn)程間通信，每個(gè)進(jìn)程通過把一個(gè)共享的文件映射到自己的進(jìn)程地址空間來實(shí)現(xiàn)它

• 信號(hào)量： 主要作為進(jìn)程間以及同一進(jìn)程不同線程之間的同步手段。

• 套接口： 更為一般的進(jìn)程間通信機(jī)制，可用于不同機(jī)器之間的進(jìn)程間通信。

生成器和迭代器

• 實(shí)現(xiàn)__next__和__iter__方法的對象就是迭代器
  • 可迭代對象只需要實(shí)現(xiàn)__iter__方法
• 使用生成器表達(dá)式或者yield的生成器函數(shù)(生成器是一種特殊的迭代器)
  • 節(jié)省資源，在用戶需要訪問數(shù)據(jù)的時(shí)候 才延遲產(chǎn)生，
  • yield會(huì)記錄代碼停止的地方，從哪里跌倒從哪里爬起來，send(None給yield傳參), next(gen)

編程題

對字典列表按年齡進(jìn)行倒序排序d_list = [{'name':'a','age':18},....]

d_list.sort(key=lambda x:x['age'],reverse = True)

如何將一個(gè)可迭代對象的每個(gè)元素變成一個(gè)字典的所有鍵？

{}.fromkeys(['jim','han'],21) # output:{'jim': 21, 'han': 21}

一只青蛙一次可以跳上1級臺(tái)階，也可以跳上2級。求該青蛙跳上一個(gè)n級的臺(tái)階總共有多少種跳法。

fib = lambda n: n if n <=2 else fib(n-1) + fib(n-2)

實(shí)現(xiàn)刪除一個(gè) L1=[1,2,3,3,2]里面的重復(fù)元素

L2 = list(set(L1)) L2.sort(key = L1.index) # 使用列表生成時(shí) append L2 = [] [L2.append(i) for i in L1 if i not in L2]

合并兩個(gè)有序列表

def loop_merge_sort(l1, l2):tmp = []while len(l1) > 0 and len(l2) > 0:if l1[0] > l2[0]:tmp.append(l2[0])del l2[0] # 列表刪除時(shí)間復(fù)雜度大else:tmp.append(l1[0])del l1[0]tmp.extend(l1)tmp.extend(l2)return tmp # 不刪除元素，時(shí)間復(fù)雜度低 def text(listone,listtwo):join_list=[]i,j=0,0while True:if len(listone) <=i:join_list.extend(listtwo[j:])breakelif len(listtwo)<=j:join_list.extend(listone[i:])breakif listone[i]>= listtwo[j]:join_list.append(listtwo[j])j+=1else:join_list.append(listone[i])i+=1return join_list

ｌｉｎｕｘ基礎(chǔ)

多路復(fù)用io

其實(shí)所有的I/O都是輪詢的方法,只不過實(shí)現(xiàn)的層面不同罷了.

python的select模塊，提供了：select、poll、epoll三個(gè)方法，分別調(diào)用系統(tǒng)的 select，poll，epoll 從而實(shí)現(xiàn)IO多路復(fù)用。

• select

  • 連接數(shù)受限
  • 查找配對速度慢
  • 數(shù)據(jù)由內(nèi)核拷貝到用戶態(tài)

• poll

  • 比select提高鏈接數(shù)的并不多，改善第一個(gè)缺點(diǎn)

• epoll

  • 適用于連接數(shù)量較多，但活動(dòng)鏈接數(shù)少的情況 改善select三個(gè)缺點(diǎn)

    ?
    說一些你比較常用linux指令

ls/ll、cd、cat、tree、touch、mkdir、rm-rf、cp、mv、ps -aux| grep xxx、kill -9、top、tar -xvf file.tar

權(quán)限 ls -l

chmod u=rw, g=x, o=r test.py

搜索文本grep grep -n ‘^a’ file.txt

查找文件:find find ./ -name ‘*.sh’

遠(yuǎn)程登錄ssh 用戶名@IP

SSH（openssh-server） 是專為遠(yuǎn)程登錄會(huì)話和其他網(wǎng)絡(luò)服務(wù)提供安全性的協(xié)議。常用于遠(yuǎn)程登錄，以及用戶之間進(jìn)行資料拷貝

遠(yuǎn)程拷貝 (前提是已經(jīng)安裝了openssh)如果是文件夾+-r

scp 本地文件名 遠(yuǎn)程用戶名@遠(yuǎn)程ip:文件 本地上傳到遠(yuǎn)程

scp 遠(yuǎn)程用戶名@遠(yuǎn)程ip:遠(yuǎn)程文件 本地文件名 復(fù)制遠(yuǎn)程到本地

• FileZilla 軟件

  可以通過圖形化操作的方式進(jìn)行遠(yuǎn)程主機(jī)的文件上傳和下載.

vim（vi）編輯器

有命令模式、輸入模式、末行模式三種模式。
　　命令模式：查找內(nèi)容(/abc、跳轉(zhuǎn)到指定行(20gg)、跳轉(zhuǎn)到尾行(G)、跳轉(zhuǎn)到首行(gg)、刪除行(dd)、插入行(o)、復(fù)制粘貼(yy,p)
　　輸入模式：編輯文件內(nèi)容
　　末行模式：保存退出(wq)、強(qiáng)制退出(q!)、顯示文件行號(hào)(set number)
　　在命令模式下，輸入a或i即可切換到輸入模式，輸入冒號(hào)(:)即可切換到末行模式；在輸入模式和末行模式下，按esc鍵切換到命令模式

排序算法

快速排序：不穩(wěn)定，最優(yōu)O(nlogn)，差O(n*n)

取第一個(gè)值為中間值，其他的與之比較，放左邊和右邊，再對左右兩邊分別排序

def quick_sort(arr):if len(arr) < 2:return arrmid = arr[0]less = [i for i in arr[1:] if i <= mid]more = [i for i in arr[1:] if i > mid]return quick_sort(less) + [mid] + quick_sort(more)

歸并排序：穩(wěn)定，最優(yōu)O(nlogn)，最差O(nlogn) 產(chǎn)生了多一份的空間

先拆分成最小的單元，然后兩兩判斷合并

def merge(left, right): L,R = 0, 0 # 先考慮左邊一個(gè)和右邊一個(gè)進(jìn)行比較 添加到新列表中slist = []while L < len(left) and R < len(right):if left[L] <= right[R]:slist.append(left[L])L += 1else:slist.append(right[R])R += 1slist += left[L:]slist += right[R:]return slistdef merge_sort(arr):if len(arr) < 2:return arrelse:mid_i = len(arr) // 2 # 分而治之left = merge_sort(arr[:mid_i])right = merge_sort(arr[mid:])return merge(left, right)

插入排序： 穩(wěn)定，最優(yōu)O(n)，差O(n*n)

認(rèn)定一個(gè)值是有序的，后面的依次浮動(dòng)比較前一個(gè)值，小了就交換，目的是把后面的插入到前面的有序序列

def insert_sort(arr):for i in range(1,len(arr)):j = i # 1,2,3,4 ...n-1while j > 0:if arr[j] < arr[j-1]:arr[j], arr[j-1] = arr[j-1], arr[j]j -= 1else:break # 希爾排序 gap = len(arr) // 2 while gap >0 :...插入排序里面的1換成gapgap //= 2

冒泡排序： 穩(wěn)定， 最優(yōu)O(n)，差O(n*n)

臨近的兩個(gè)值比較，大的放后面,第一遍的時(shí)候最后一個(gè)正確位置，第二遍時(shí)后兩個(gè)都正確。。。。

def bubule_sort(arr):for i in range(len(arr)-1,0,-1) # n-1, n-2,... 2, 1flag = Falsefor j in range(i):if arr[j+1] < arr[j]:arr[j], arr[j+1] = arr[j+1], arr[j]flag = Trueif not flag:break

選擇排序： 不穩(wěn)定，最優(yōu)最壞都是O(n*n)

假設(shè)最后一個(gè)最大，從左到右（除了最后一個(gè)）依次與最大值進(jìn)行比較并交換

def selection_sort(arr):for i in range(len(arr)-1, 0, -1): # n-1, n-2,... 2, 1for j in range(i):if arr[j] >arr[i]:array[j], array[i] = array[i], array[j]return array

堆排序[heapq模塊] 不穩(wěn)定，時(shí)間復(fù)雜度與歸并一樣 nlogn，nlogn

堆是一顆完全二叉樹：除了最后一層之外的其他每一層都被完全填充，并且所有結(jié)點(diǎn)都保持向左對齊的樹

最大堆：任意節(jié)點(diǎn)的值不大于其父親節(jié)點(diǎn)的值。

最小堆：任意節(jié)點(diǎn)的值不小于其父親節(jié)點(diǎn)的值。

堆有什么用途？

堆最常用于優(yōu)先隊(duì)列以及相關(guān)動(dòng)態(tài)問題。

優(yōu)先隊(duì)列指的是元素入隊(duì)和出隊(duì)的順序與時(shí)間無關(guān)，既不是先進(jìn)先出，也不是先進(jìn)后出，而是根據(jù)元素的重要性來決定的

from heapq import nsmallest def heap_sort(_list):return nsmallest(len(_list),_list)

二分查找： 最優(yōu)O(1)，差O(logn)

二分查找必須是有序的序列,

def binary_find(arr, item):'''非遞歸''' # 定義頭和尾的游標(biāo)，依次進(jìn)行判斷進(jìn)行移動(dòng)游標(biāo)first,end = 0, len(arr)-1while first <= end:mid = (first + end) //2if item < arr[mid]:end = midelif item > arr[mid]:first = mid + 1else:return midreturn False print(binary_find([1,2,3], 1))def binary_search(alist, item):'''遞歸實(shí)現(xiàn)'''if len(alist) == 0:return Falseelse:mid = len(alist)//2if alist[mid]==item:return Trueelse:if item < alist[mid]:return binary_search(alist[:midpoint],item)else:return binary_search(alist[midpoint+1:],item)

棧與隊(duì)列

class Stack(object):"""棧"""def __init__(self):self.items = []def is_empty(self):"""判斷是否為空"""return self.items == []def push(self, item):"""加入元素"""self.items.append(item)def pop(self):"""彈出元素"""return self.items.pop()def peek(self):"""返回棧頂元素"""return self.items[len(self.items)-1]def size(self):"""返回棧的大小"""return len(self.items) class Queue(object):"""隊(duì)列"""def __init__(self):self.items = []def is_empty(self):return self.items == []def enqueue(self, item):"""進(jìn)隊(duì)列"""self.items.insert(0,item)def dequeue(self):"""出隊(duì)列"""return self.items.pop()def size(self):"""返回大小"""return len(self.items)

用兩個(gè)棧實(shí)現(xiàn)一個(gè)隊(duì)列（面試遇到的題）

class Queue(object):def __init__(self):self.stack1 = []self.stack2 = []def append_tail(self,item):self.stack1.append(item)def del_head(self):if not self.stack2:if self.stack1:while self.stack1:item = self.stack1.pop()self.stack2.append(item)else:raise Exception('stack1 is empty')item = self.stack2.pop()return item q = Queue() q.append_tail(1) q.append_tail(2) q.append_tail(3) print(q.del_head()) # 輸出先進(jìn)入隊(duì)列的1，

總結(jié)

以上是生活随笔為你收集整理的一片文章概括大部分python面试基础常考题（部分有详解）的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。