const關鍵字

• const的作用：被const修飾的值不能改變，是只讀變量板鬓，必須在定義的時候賦初值
• 修飾指針分類：常量指針彪腔，指針常量

#include <iostream>
int main() {
    //1-常量指針
    int tmp1 = 10;
    int tmp2 = 11;
    const int* a = &tmp1;  //const修飾指針
    //*a = 9; //錯誤：更改對象值
    tmp1 = 9; //正確：在原對象上修改
    a = &tmp2; //正確：指針的指向可以修改攒钳，指向別的對象

    //2-指針常量
    int tmp3 = 12;
    int tmp4 = 14;
    int* const p = &tmp3;  //const修飾指針指向的值
    *p = 9;        //正確柠贤，可以修改指針指向的對象的值
    //p = &tmp4;   //錯誤：不可以修改指針指向的對象
    return -1;
}

C/C++中內存泄漏以及解決方法香浩？

• 內存泄漏：已動態(tài)分配的堆內存由于某種原因導致程序未釋放或無法釋放，造成系統(tǒng)內存的浪費臼勉，導致程序運行速度減慢邻吭，甚至系統(tǒng)崩潰
• 解決方法：使用new或malloc動態(tài)分配堆上的內存空間，而沒有使用delete或free及時釋放內存

C/C++中野指針的概念宴霸？

• 野指針：也叫空懸指針囱晴，不是指向NULL的指針，是未初始化或者未清零的指針
• 產生原因：指針變量未及時初始化瓢谢；指針free或delete之后沒有及時置空
• 解決方法：定義指針變量及時初始化或者置空畸写；釋放操作之后立即置空

C/C++中面向對象和面向過程的區(qū)別？

• 面向對象（Object Oriented Programming,OOP）：編程模型首先抽象出各種對象（各種類）氓扛，并專注于對象與對象之間的交互枯芬，對象涉及的方法和屬性都封裝在對象內部
• 面向過程（Procedure Oriented Programming,POP）:將問題分解成若干個步驟（動作），每個步驟（動作）使用一個函數(shù)來實現(xiàn)采郎，使用的時候將數(shù)據(jù)傳遞給這些函數(shù)
• 二者的區(qū)別：
• 1-安全性角度：面向對象安全性更高千所，面向對象將數(shù)據(jù)訪問隱藏在類的成員函數(shù)中，而且類的成員變量和成員函數(shù)都有不同的訪問屬性蒜埋，面向過程沒有方法來隱藏程序數(shù)據(jù)
• 2-程序設計角度：面向過程通常將程序分為一個個的函數(shù)淫痰；面向對象通常使用一個個對象，函數(shù)通常是對象的一個方法
• 3-邏輯過程角度：面向過程采用自上而下的方法整份；面向對象通常采用自下而上的方法
• 4-程序擴展性角度：面向對象編程更容易修改程序待错，更容易添加新功能

C/C++中常用容器功能匯總

• vector(數(shù)組)：vector是封裝動態(tài)數(shù)組的順序容器
• queue（隊列）：容器適配器，他是FIFO（先進先出）的數(shù)據(jù)結構烈评。
• deque（雙端隊列）：有下標順序容器火俄，它允許在其首尾兩段快速插入和刪除。
• set（集合）：集合基于紅黑樹實現(xiàn)础倍，有自動排序的功能烛占，并且不能存放重復的元素。
• unordered_set（無序集合）：無序集合基于哈希表實現(xiàn)沟启，不能存放重復的元素忆家。元素類型必須可以比較是否相等，因為這可以確定元素什么時候相等德迹。
• unordered_map（無序哈希表）：關聯(lián)容器芽卿，含有帶唯一鍵的鍵-值對。搜索胳搞、插入和元素移除擁有平均常數(shù)時間復雜度卸例。元素在內部不以任何特定順序排序称杨，而是組織進桶中。元素放進哪個桶完全依賴于其鍵的哈希筷转。這允許對單獨元素的快速訪問姑原，因為一旦計算哈希，則它準確指代元素所放進的桶呜舒。

C/C++中指針和引用的區(qū)別

• C語言指針具有直接操控內存的能力锭汛，C++在指針基礎上新增了引用
• C++中對象的定義：對象是指一塊能存儲數(shù)據(jù)并具有某種類型的內存空間
• 一個對象a，它有值和地址&a袭蝗，運行程序時唤殴，計算機為該對象分配存儲空間，來存儲該對象的值到腥，我們通過該對象的地址來訪問存儲空間中的值
• 指針p也是對象朵逝，它同樣有地址&p和存儲的值p，只不過p存儲的是其他對象的地址乡范。如果要以p中的存儲數(shù)據(jù)為地址訪問對象的值配名，需要解引用操作符，即p
• 對象有常量(const)和變量之分晋辆，指針常量（這個對象存放的地址是不可改變的）段誊，常量指針（指向常量的指針）
• 引用：可以理解為給變量起別名，定義一個引用時栈拖，程序應該把該引用和它的初始值綁定在一起，而不是拷貝它没陡。計算機必須在聲明引用r的同時將它初始化涩哟，并且r一旦聲明，就不可以再和其他對象綁定在一起
• 指針和引用的區(qū)別：
• 1.1-指針是一個新的變量盼玄，要占用存儲空間贴彼，存儲了另一個變量的地址，可以通過訪問這個地址來修改另一個變量埃儿。
• 1.2-引用只是一個別名器仗，還是變量本身，不占用具體存儲空間童番，只有聲明沒有定義精钮，對引用的任何操作就是對變量本身進行操作，以達到修改變量的目的
• 2.1-引用只有一級剃斧，指針可以多級
• 3.1-指針傳參的時候轨香，還是值傳遞，指針本身的值不可以修改幼东，需要解引用才能對指向的對象進行操作臂容。引用傳參的時候科雳，傳進來的就是變量本身，因此變量可以被修改
• 4.1-引用一定不為空脓杉，因此相對于指針糟秘，它不用檢查它所指對象是否為空，這樣就提高了效率
• 5.1-引用必須初始化球散，指針可以不初始化
  “&”不僅能表示引用尿赚，還可以表示成地址，還有可以作為按位與運算符沛婴。這個要根據(jù)具體情況而定吼畏。比如上面的例子，等號左邊的嘁灯，被解釋為引用泻蚊，右邊的被解釋成取地址。
  引用的操作加了比指針更多的限制條件丑婿，保證了整體代碼的安全性和便捷性性雄。引用的合理使用可以一定程度避免“指針滿天飛”的情況，可以一定程度上提升程序魯棒性羹奉。并且指針與引用底層實現(xiàn)都是一樣的秒旋，不用擔心兩者的性能差距。

int a, b, *p, &r = a;   //正確
r = 3; //正確诀拭，等價于 a = 3
int &rr; //出錯迁筛，引用必須初始化
p = &a;  //正確，p中存儲a的地址耕挨，即p指向a
*p = 4;  //正確：p中存儲a的地址细卧，a對應的存儲空間存入值 4
p = &b;  //正確：p可以多次賦值，p存儲b的地址

C/C++中宏定義的相關知識

• 宏定義：把一個名稱指定成任何一個文本筒占，在完成宏定義之后贪庙，無論宏名稱出現(xiàn)在源代碼的何處，預處理器都會將其替換成指定的文本
• 宏定義優(yōu)點：
• 1-方便程序修改翰苫，如果一個變量在程序中大量使用止邮，可以使用宏定義為其設置一個標識符，當我們想修改這個常量時奏窑，直接修改宏定義就可以导披，不必在海量的代碼中查找所有相關位置
• 2-提高程序運行效率：使用帶參數(shù)的宏定義可以完成函數(shù)的功能，但同時又比函數(shù)節(jié)省系統(tǒng)開銷埃唯，提升程序運行效率（無需調用函數(shù)這個流程）
• 宏定義和函數(shù)的區(qū)別：
• 1-宏在預處理階段完成盛卡，之后替換的文本參與編譯，相當于恒等代換過程
• 2-宏定義沒有返回值筑凫；函數(shù)調用有返回值
• 3-宏定義參數(shù)沒有類型滑沧，不進行類型檢查并村；函數(shù)參數(shù)具有類型，需要檢查類型
• 4-宏定義不是說明或者語句滓技，結尾不用加分號
• 5-宏定義必須寫在函數(shù)之外哩牍，作用域為宏定義命令開始到源程序結束，如果要終止其作用域令漂，可以使用 # undef 命令膝昆；而函數(shù)作用域在函數(shù)調用處

//define 宏名
#define WeThinkIn 6666589
//define 宏名（參數(shù)） 文本
#define R(a, b) (a/b)

C/C++中typedef關鍵字的相關知識

• 使用typedef關鍵字來定義自己習慣的數(shù)據(jù)類型名稱，來代替系統(tǒng)默認的基本類型名稱以及其他類型等名稱
• typedef 和 #define 的區(qū)別
• 1-宏主要用于定義常量及書寫復雜的內容叠必；typedef主要用于定義類型別名
• 2-宏替換發(fā)生在預處理階段荚孵，屬于文本恒等替換；typedef是編譯中發(fā)揮作用
• 3-宏定義參數(shù)沒有類型纬朝，不進行類型檢查收叶；typedef參數(shù)具有類型，需要檢查類型
• 4-宏不是語句共苛，不用在最后加分號判没；typedef是語句，要加分號標識結束
• 5-注意對指針的操作隅茎，typedef char * p_char 和 #define p_char char * 區(qū)別巨大

//1-為基本數(shù)據(jù)類型定義新的類型名
typedef unsigned int WeThinkIn_int;
typedef char* WeThinkIn_point;
//2-為自定義數(shù)據(jù)類型（結構體澄峰、共用體和枚舉類型）定義簡潔的類型名稱
typedef struct target_Object{
    int x;
    int y;
} WeThinkIn_Object;

C/C++中面向對象的相關知識

• 面向對象三大特征：封裝，繼承辟犀，多態(tài)
• 封裝：把客觀事物封裝成抽象的類俏竞，并且類可以把自己的數(shù)據(jù)和方法只讓可信的類或者對象操作，對不可信的進行信息隱藏堂竟。public成員：可以被任意實體訪問胞此；protected成員：只允許被子類及本類的成員函數(shù)訪問；private成員：只允許被本類的成員函數(shù)跃捣、友元類或友元函數(shù)訪問
• 繼承：基類（父類）-->派生類（子類）
• 多態(tài)：即多種狀態(tài)，可以將多態(tài)定義為消息以多種形式顯示的能力夺蛇，多態(tài)以封裝和繼承為基礎
• 多態(tài)的分類和實現(xiàn)：
• 1-重載多態(tài)（Ad-hocPloymorphism, 編譯器）：函數(shù)重載疚漆、運算符重載
• 2-子類型多態(tài)（Subtype Polymorphism，運行期）：虛函數(shù)
• 3-參數(shù)多態(tài)性（Parametric Polymorphism刁赦，編譯器）：類模板娶聘、函數(shù)模板
• 4-強制多態(tài)（Coercion Polymorphism，編譯器/運行期）：基本類型轉換甚脉、自定義類型轉換

C/C++中struct的內存對齊與內存占用計算丸升？

• 內存對齊：計算機系統(tǒng)對基本類型數(shù)據(jù)在內存中存放的位置有限，他們會要求這些數(shù)據(jù)的首地址的值是有效對齊值的倍數(shù)
• 有效對齊值：默認對齊系數(shù)n牺氨，可以通過#pragma pack(n)指定狡耻，有效對齊值 = min(對齊系數(shù)n, 結構體中最長的數(shù)據(jù)類型)
• 為什么要進行內存對齊：當沒有內存對齊墩剖，數(shù)據(jù)可以任意存儲，當有內存對齊時夷狰，比如4字節(jié)存取粒度的處理器岭皂，提高數(shù)據(jù)存取速度
• struct內存對齊規(guī)則
• 1-數(shù)據(jù)對齊規(guī)則：當?shù)谝粋€數(shù)據(jù)成員是int,第二個是double,有效對齊值為8
• 2-結構體作為成員：如果一個結構里有某些結構體成員，則結構體成員要從其內部有效對齊值的整數(shù)倍地址開始存儲
• 3-結構體內存的總大小沼头，必須是其有效對齊值的整數(shù)倍爷绘，補足的要補齊

//struct的內存占用為40bytes
#include <stdio.h>
#pragma pack(8)
int main()
{
  struct Test
  {
    int a;
    //long double大小為16bytes
    long double b;         
    char c[10];
  };
  printf("%d", sizeof(Test));
  return 0;
} 

//struct的內存占用為48bytes
#include <stdio.h>
#pragma pack(16)
int main()
{
  struct Test
  {
    int a;
    //long double大小為16bytes
    long double b;         
    char c[10];
  }
  printf("%d", sizeof(Test));
  return 0;
}

C/C++中智能指針的定義與作用？

• 智能指針是一個類进倍，這個類的構造函數(shù)中傳入一個普通指針土至，析構函數(shù)中釋放傳入的指針。智能指針的類都是棧上的對象猾昆，所以當函數(shù)（或程序）結束時會自動被釋放
• 常用的智能指針：智能指針在C++11版本之后提供陶因，包含在頭文件中，主要是shared_ptr毡庆、unique_ptr坑赡、weak_ptr。unique_ptr不支持復制和賦值么抗。當程序試圖將一個 unique_ptr 賦值給另一個時毅否，如果源 unique_ptr 是個臨時右值，編譯器允許這么做蝇刀；如果原來的unique_ptr 將存在一段時間螟加，編譯器將禁止這么做。shared_ptr是基于引用計數(shù)的智能指針吞琐±μ剑可隨意賦值，直到內存的引用計數(shù)為0的時候這個內存會被釋放站粟。weak_ptr能進行弱引用黍图。引用計數(shù)有一個問題就是互相引用形成環(huán)，這樣兩個指針指向的內存都無法釋放奴烙。需要手動打破循環(huán)引用或使用weak_ptr助被。顧名思義，weak_ptr是一個弱引用切诀，只引用揩环，不計數(shù)。如果一塊內存被shared_ptr和weak_ptr同時引用幅虑，當所有shared_ptr析構了之后丰滑，不管還有沒有weak_ptr引用該內存，內存也會被釋放倒庵。所以weak_ptr不保證它指向的內存一定是有效的褒墨，在使用之前需要檢查weak_ptr是否為空指針炫刷。
• 智能指針的作用：C++11中引入了智能指針的概念，方便管理堆內存貌亭。使用普通指針柬唯，容易造成堆內存泄露（忘記釋放），二次釋放圃庭，野指針锄奢，程序發(fā)生異常時內存泄露等問題等，使用智能指針能更好的管理堆內存剧腻。

C/C++中程序的開發(fā)流程拘央？

• 開發(fā)流程：編輯、編譯书在、鏈接灰伟、運行和調試
• 編輯(.cpp)：程序文本的輸入和修改,頭文件.h
• 編譯：使用編譯器將C++高級語言“翻譯”成匯編語言
• 匯編(.obj)：將匯編語言翻譯成機器語言指令（二進制）
• 鏈接(.o)：將編譯后產生的一個或多個目標文件與程序中用到的庫文件鏈接起來，形成一個可以在操作系統(tǒng)中直接運行的可執(zhí)行程序
• 運行與調試：執(zhí)行程序儒旬，出現(xiàn)問題進行debug

C/C++中數(shù)組和鏈表的優(yōu)缺點栏账？

• 1-數(shù)組：在內存中，數(shù)組是一塊連續(xù)的區(qū)域栈源，并且數(shù)組需要預留空間
• 2-鏈表：在內存中挡爵，元素的空間可以在任何地方，空間是分散的甚垦，不需要連續(xù)茶鹃，鏈表元素有兩個屬性，一個是元素的值艰亮，另一個是指針闭翩，指針標記了下一個元素的地址，通過地址查找下一個元素
• 3-數(shù)組的優(yōu)點：查詢效率高迄埃，時間復雜度是O(1)
• 4-數(shù)組的缺點：新增和修改效率低疗韵，時間復雜度為O(N),內存分配是連續(xù)的內存，擴容需要重新分配內存
• 5-鏈表的優(yōu)點：新增和修改效率高侄非，只需要修改指針的指向蕉汪，時間復雜度可以達到O(1)疯汁；內存分配不需要連續(xù)的內存茬斧，占用連續(xù)內存少
• 6-鏈表的缺點：查詢效率低瑟啃，需要從鏈表的頭依次查找，時間復雜度為O(N)

C/C++中的new和malloc有什么區(qū)別骇钦？

• 1-malloc和free是標準庫函數(shù)，支持覆蓋竞漾；new和delete是運算符眯搭，支持重載
• 2-malloc僅僅分配內存空間窥翩，free僅僅回收內存空間，不具備調用構造函數(shù)和析構函數(shù)功能鳞仙，用malloc分配空間存儲類的對象存在風險寇蚊；new和delete除了分配回收功能外，還會調用構造函數(shù)和析構函數(shù)
• 3-malloc和free返回的是void類型指針（必須進行類型轉換）,new和delete返回的是具體類型指針

C/C++中結構體的區(qū)別棍好？

• C中的結構體只涉及到數(shù)據(jù)結構仗岸，而不涉及到算法，也就是說在C中數(shù)據(jù)結構和算法是分離的借笙，而到C++中一類或者一個結構體可以包含函數(shù)（這個函數(shù)在C++我們通常中稱為成員函數(shù)）扒怖，C++中的結構體和類體現(xiàn)了數(shù)據(jù)結構和算法的結合

• C中的結構體和C++中結構體的不同之處：在C中的結構體只能自定義數(shù)據(jù)類型，結構體中不允許有函數(shù)业稼，而C++中的結構體可以加入成員函數(shù)盗痒。

C++中的結構體和類的異同

• 一、相同之處：結構體中可以包含函數(shù)低散；也可以定義public俯邓、private、protected數(shù)據(jù)成員熔号；定義了結構體之后稽鞭，可以用結構體名來創(chuàng)建對象。但C中的結構體不允許有函數(shù)跨嘉；也就是說在C++當中川慌，結構體中可以有成員變量，可以有成員函數(shù)祠乃，可以從別的類繼承梦重，也可以被別的類繼承，可以有虛函數(shù)亮瓷。

• 二琴拧、不同之處：結構體定義中默認情況下的成員是public，而類定義中的默認情況下的成員是private的嘱支。類中的非static成員函數(shù)有this指針蚓胸，（而struct中沒有是錯誤的，一直被誤導啊除师，經過測試struct的成員函數(shù)一樣具有this指針）沛膳，類的關鍵字class能作為template模板的關鍵字 即template<class T> class A{}; 而struct不可以。

C/C++中的namespace

• 命名空間作為附加信息來區(qū)分不同庫中相同名稱的函數(shù)汛聚、類锹安、變量等。使用命名空間即定義了上下文，本質上叹哭，命名空間就是定義了一個范圍
• 命名空間可以嵌套

#include <iostream>
using namespace std;

//第一個命名空間
namespace first_space {
    void func() {
        cout << "Inside first_space" << endl;
    }
    //第二個空間
    namespace second_space {
        void func() {
            cout << "Inside second_space" << endl;
        }
    }
}

using namespace first_space::second_space;

int main()
{
    //調用第二個命名空間中的函數(shù)
    func();
    return 0;
}

Python中assert（斷言）的作用忍宋？

• assert 用于判斷一個表達式，在表達式條件為false時觸發(fā)異常
• 斷言在條件不滿足程序運行的情況下直接返回錯誤风罩，而不必等待程序運行后出現(xiàn)崩潰

assert True
assert False

---------------------------------------------------------------------------

AssertionError                            Traceback (most recent call last)

~\AppData\Local\Temp/ipykernel_3860/2576994315.py in <module>
      1 assert True
----> 2 assert False


AssertionError: 

assert 1 == 1
assert 1 != 2
assert 1 == 2

---------------------------------------------------------------------------

AssertionError                            Traceback (most recent call last)

~\AppData\Local\Temp/ipykernel_3860/2410673052.py in <module>
      1 assert 1 == 1
      2 assert 1 != 2
----> 3 assert 1 == 2


AssertionError: 

Python中互換變量有不用創(chuàng)建臨時變量的方法嗎糠排？

• 首先一般情況下Python是從左到右解析一個語句的，但在賦值操作的時候超升，因為是右值具有更高的計算優(yōu)先級入宦，所以需要從右向左解析。
• 先計算右值y,x(這里是簡單的原值廓俭，但可能會有表達式或者函數(shù)調用的計算過程)云石， 在內存中創(chuàng)建元組(tuple)，存儲,y,x分別對應的值研乒；
• 計算左邊的標識符汹忠，元組被分別分配給左值，通過解包(unpacking)雹熬，元組中第一個標示符對應的值(y)宽菜，分配給左邊第一個標示符(x)，元組中第二個標示符對應的值(x)竿报，分配給左邊第二個標示符(y)铅乡，完成了x和y的值交換。

a, b = 1, 2
a, b = b, a
print(a, b)

2 1

Python中的主要數(shù)據(jù)結構都有哪些烈菌？

• 列表（list）
• 元組（tuple）
• 字典（dict）
• 集合（set）

Python中的可變對象和不可變對象阵幸？

• 可變對象和不可變對象區(qū)別在于對象本身是否可變
• 可變對象：list(列表) dict(字典) set（集合）
• 不可變對象：tuple（元組） string（字符串） int(整型) float(浮點型) bool（布爾型）

Python中的None代表什么？

• None是一個特殊的常量芽世，表示空值挚赊，和 False, 0，空字符串不同济瓢，它是一個特殊的Python對象荠割，None的類型是NoneType
• None和任何其它數(shù)據(jù)類型比較返回False

print(None == 0)
print(None == ' ')
print(None == False)
print(None == None)

False
False
False
True

Python中?args和??kwargs的區(qū)別？

• 在函數(shù)定義時旺矾，將不定數(shù)量的參數(shù)傳遞給一個函數(shù)
• *args將一個非鍵值對的可變數(shù)量的參數(shù)列表傳遞給函數(shù)
• **kwargs

def test_var_args(f_arg, *args):
    print("first normal arg: ", f_arg)
    for arg in args:
        print("another arg through *args: ", arg)
test_var_args("hello", "python", "ddd", "test")

first normal arg:  hello
another arg through *args:  python
another arg through *args:  ddd
another arg through *args:  test

def test_var_kwargs(**kwargs):
    for key, value in kwargs.items():
        print("{0} == {1}".format(key, value))
test_var_kwargs(name = "kkwww", age = 18, weight = "60kg")

name == kkwww
age == 18
weight == 60kg

Python中Numpy的broadcasting機制蔑鹦？

• 根據(jù)計算情況擴展數(shù)組的維度，自動填充數(shù)據(jù)

import numpy as np
a = np.array([1, 2, 3])
b = np.array([6, 6, 6])
print(a + b)

c = a + 5
print(c)

d = np.arange(3).reshape(3, 1)
print(a + d)

[7 8 9]
[6 7 8]
[[1 2 3]
 [2 3 4]
 [3 4 5]]

Python中的實例方法箕宙、靜態(tài)方法和類方法三者區(qū)別嚎朽？

• 類方法：用@classmethod修飾，至少包含cls參數(shù)柬帕，調用類方法時不需要顯式為cls參數(shù)傳參
• 靜態(tài)方法：用@staticmethod修飾哟忍，沒有類似cls和self這樣的參數(shù)室囊，因此Python的解釋器不會對它包含的參數(shù)做任何類和對象的綁定
• 實例方法：不用@classmethod和@staticmethod修飾，類中定義的方法默認為實例方法魁索，特點是需要包含一個self參數(shù)，用于綁定調用此方法的實例對象

Python中常見的切片操作

• 切片是一個左閉右開區(qū)間[:] -> [:)

example = [1, 2, 3, 4, 5]
print(example[:3])
print(example[3:])
print(example[::-1])
print(example[2::-1])

[1, 2, 3]
[4, 5]
[5, 4, 3, 2, 1]
[3, 2, 1]

Python中如何進行異常處理盼铁？

• 當程序無法正常處理程序時會引發(fā)異常粗蔚，異常在python中是一個對象，表示一個錯誤饶火。當Python發(fā)生異常鹏控，需要捕獲，否則程序會終止執(zhí)行

try:
    6688 / 0
except:
    '''異常的父類肤寝，可以捕獲所有的異常'''
    print("0不能被除")
else:
    '''保護不拋出異常的代碼'''
    print("沒有異常")
finally:
    print("最后總是要執(zhí)行我")

0不能被除
最后總是要執(zhí)行我

Python中remove当辐，del以及pop之間的區(qū)別？

• 相同點：刪除列表鲤看、字符串等里面的元素
• 1-remove剔除第一個匹配的值
• 2-del通過索引刪除元素
• 3-pop通過索引刪除元素缘揪，默認刪除最后一個元素

a = [i for i in range(10)]
a.remove(1)
print(a)
del a[0]
print(a)
a.pop(2)
print(a)

[0, 2, 3, 4, 5, 6, 7, 8, 9]
[2, 3, 4, 5, 6, 7, 8, 9]
[2, 3, 5, 6, 7, 8, 9]

Python中迭代器的概念？

• 可迭代對象是迭代器义桂、生成器和裝飾器的基礎找筝。簡單來說，可以用for循環(huán)遍歷的對象就是可迭代對象慷吊，比如 list袖裕，set，dict
• 可以通過 iter(object)來返回一個迭代器
• 所有實現(xiàn)了iter和next兩個方法的對象溉瓶，都是迭代器
• Python的 for 循環(huán)本質上就是通過不斷調用next()函數(shù)實現(xiàn)的

from collections import Iterable
print(isinstance("abcsde", Iterable))
print(isinstance([1, 2, 3, 4, 5, 6], Iterable))
print(isinstance(123456, Iterable))

x = [1, 2, 3]
y = iter(x)
print(type(x))
print(type(y))

print(next(y))
print(next(y))
print(next(y))
print(next(y))

True
True
False
<class 'list'>
<class 'list_iterator'>
1
2
3

---------------------------------------------------------------------------

StopIteration                             Traceback (most recent call last)

~\AppData\Local\Temp/ipykernel_3860/363111041.py in <module>
     12 print(next(y))
     13 print(next(y))
---> 14 print(next(y))


StopIteration: 

Python中生成器的相關知識

• Python在創(chuàng)建列表時急鳄，收到內存限制，容量有限堰酿，不可能全部一次性枚舉疾宏，Python常用列表生成式有一個致命缺點就是定義即生成，非常浪費空間和效率
• 生成器 generator: 在循環(huán)中不斷推算出后續(xù)元素胞锰，不必創(chuàng)建完整的list灾锯，節(jié)省大量空間
• yield：定義生成器函數(shù)，使用yield來支持迭代器協(xié)議
• python支持協(xié)程嗅榕，也就是微線程顺饮，通過generator來實現(xiàn)

a = [x*x for x in range(10)]
print(a)
b = (x*x for x in range(10))
print(type(b))

def spam():
    yield"first"
    yield"second"
    yield"third"
for x in spam():
    print(x)

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
<class 'generator'>
first
second
third

Python中裝飾器的相關知識

• 裝飾器允許將現(xiàn)有函數(shù)傳遞給裝飾器，從而向現(xiàn)有函數(shù)中添加額外的功能凌那，裝飾器將執(zhí)行現(xiàn)有函數(shù)和添加的額外功能
• 裝飾器本身就是一個函數(shù)兼雄，可以在不改變已有函數(shù)的情況下增加功能
• 如果需要給當前函數(shù)添加功能，重寫函數(shù)使代碼不能復用
• 通過@語法糖來起到bar = use_log(bar)的作用帽蝶，使用高級封裝

def foo():
    print("I am foo")
def foo():
    print("foo is running")
    print("I am foo")

# 改寫
import logging
def use_log(func):
    logging.warning("%s is running" % func.__name__)
    func()
def bar():
    print("I am bar")
    
#將函數(shù)作為參數(shù)傳入新定義函數(shù)
use_log(bar)

WARNING:root:bar is running


I am bar

import logging 
def use_log(func):
    def wrapper(*args, **kwargs):
        logging.warning("%s is running" % func.__name__)
        return func(*args, **kwargs)
    return wrapper

def bar():
    print("I am bar")

bar = use_log(bar)
bar()

WARNING:root:bar is running


I am bar

import logging 
def use_log(func):
    def wrapper(*args, **kwargs):
        logging.warning("%s is running" % func.__name__)
        return func(*args, **kwargs)
    return wrapper

@use_log
def bar():
    print("I am bar")

@use_log
def haha():
    print("I am haha")
    
bar()
haha()

WARNING:root:bar is running
WARNING:root:haha is running


I am bar
I am haha

Python的深拷貝與淺拷貝赦肋？

• 變量賦值：只是給當前內存中的對象增加一個“標簽”（改個名字）
• 淺拷貝：創(chuàng)建一個新的對象，其內容是原對象中元素的引用（新對象與原對象內存中的子對象），常見的淺拷貝方法包括：切片操作佃乘，工廠函數(shù)囱井，對象的copy()方法，copy模塊中的copy函數(shù)
• 深拷貝：創(chuàng)建一個新的對象趣避，然后遞歸的拷貝原對象所包含的子對象庞呕。深拷貝出來的對象與原對象沒有任何關聯(lián)。深拷貝只有一種方式程帕，copy模塊中的deepcopy()函數(shù)

# 變量賦值
a = [1, 2, 3, 4, 5]
b = a
print(id(a), id(b))
print(a == b)

1868670559168 1868670559168
True

#淺拷貝
a = [4, 3, 2]
b = list(a)
print(id(a), id(b))      #a和b的地址不同
print("------------------")
for x, y in zip(a, b):
    print(id(x), id(y))  #他們的子對象地址相同

1868672945792 1868690687168
------------------
1868592736656 1868592736656
1868592736624 1868592736624
1868592736592 1868592736592

import copy
#深拷貝
a = [[1, 2],
    [3, 4],
    [5, 6]]
b = copy.copy(a)  #淺拷貝
c = copy.deepcopy(a) #深拷貝
print(id(a), id(b), id(c))
print("---------------------")
for x, y in zip(a, b):
    print(id(x), id(y))
print("----------------------")
for x, y in zip(a, c):
    print(id(x), id(y))

1868690646400 1868670536832 1868668928256
---------------------
1868690461952 1868690461952
1868690720896 1868690720896
1868690647872 1868690647872
----------------------
1868690461952 1868670467968
1868690720896 1868690461824
1868690647872 1868690720384

Python是解釋語言還是編譯語言住练？

• Python是解釋性語言
• 解釋語言優(yōu)點是可移植性好，缺點是運行需要解釋環(huán)境愁拭，運行起來比編譯語言慢讲逛，占用資源多，代碼效率低
• 編譯語言的優(yōu)點是運行速度快岭埠，代碼效率高盏混，編譯之后程序不能修改，保密性好惜论。缺點是代碼需要經過編譯才能運行括饶，可移植性較差，只能在兼容的操作系統(tǒng)上運行

Python的垃圾回收機制

• 在Python中来涨，使用引用計數(shù)進行垃圾回收
• 同時通過標記-清除算法解決容器對象可能產生的循環(huán)引用問題
• 最后通過分代回收算法提高垃圾回收效率

Python里有多線程嗎图焰？

• Python中的多線程是假的多線程
• Python解釋器由于設計時有GIL全局鎖，導致了多線程無法利用多核蹦掐，只有一個線程在解釋器中運行

Python中range和xrange的區(qū)別技羔？

• 二者用法相同，不同之處在于xrange函數(shù)生成一個生成器
• 在python3中卧抗，xrange被移除

Python中列表和元組的區(qū)別藤滥？

• 列表是可變的，在創(chuàng)建之后可以對其進行任意修改
• 元組是不可變的社裆，一旦創(chuàng)建不可改變
• 元組無法復制
• Python將低開銷的較大的塊分配給元組拙绊，因為它們是不可變的。對于列表則分配小內存塊泳秀。與列表相比标沪，元組的內存更小。當你擁有大量元素時嗜傅，元組比列表快金句。

Python中dict（字典）的底層結構？

• 為了支持快速查找吕嘀，使用哈希表作為底層結構违寞，哈希表查找的平均時間復雜度是O(1)
• CPython使用二次探查解決哈希沖突問題

常用的深度學習框架有哪些贞瞒，都是哪家公司開發(fā)的？

• PyTorch：Facebook
• TensorFlow：Google
• Keras：Google
• MxNet：Dmlc社區(qū)
• Caffe：UC Berkeley
• PaddlePaddle：百度

PyTorch動態(tài)圖和TensorFlow靜態(tài)圖的區(qū)別趁曼？

• PyTorch動態(tài)圖：計算圖的運算與搭建同時進行军浆；比較靈活，方便調節(jié)
• TensorFlow靜態(tài)圖:計算圖時先搭建圖挡闰，后運算瘾敢；比較高效，不靈活