前言
之所以在這裡寫下python爬蟲常見面試題及解答，
一是用作筆記，方便日後回憶；
二是給自己一個和大家交流的機會，互相學習、進步，希望不正之處大家能給予指正；
三是我也是互聯網寒潮下崗的那批人之一，為了找工作而做準備。
一、題目部分
1、python中常用的數據結構有哪些？請簡要介紹一下。
python中常見的數據結構有：列表(list)，字典(dict)，元組(tuple)，字符串(string)，集合(set)，數字（int或long或float。。。）等。
其中，列表，元祖和字符串可以統一歸為序列類，即這三種數據結構中的元素是有序的。比如，他們都有索引（下標）操作，還有切片、相加和長度(len)，最大值(max)，最小值(min)操作。這是他們的共同點。
補充：python中常見的數據結構可以統稱為容器（container）。序列（如列表和元組）、映射（如字典）以及集合（set）是三類主要的容器。
另外，關於這個問題，面試官很容易引出另一個問題：python中的哪些數據類型是可變的，哪些是不可變的？
首先，可變/不可變是針對該對象所指向的內存中的值是否可變來判斷的。如可變類型的數據類型有列表和字典，還有集合不可變類型的數據類型有字符串，元組，數字。
就舉個最簡單的數字的例子，python中有小整數池的概念，即[-5,256]範圍內的整數，python解釋器對他們做了特殊處理，都放在內存中的固定位置，不會因為你的操作二發生變化。
現在：a = 1 ，然後我們又重新對a賦值，a = 2，在重新賦值的過程中，整數1所對應的內存地址沒有和數字的大小都沒有發生變化，還在內存中的固定位置。整數2也是如此。變化的是a的指針（這裡引用C中的概念）從指向數字1變成數字2。a對象指向的內存中的值沒有發生變化，因此數字是不可變類型的數據類型。字符串，集合也是同理。
2、簡要描述python中單引號、雙引號、三引號的區別。
首先，單引號和雙引號在使用時基本上沒有什麼區別；
唯一需要注意的是：
當字符串中有單引號時，最好在外面使用雙引號；
當有雙引號時，最好在外面使用單引號。
三引號一般不常用，除了用來做註釋之外，還可以用來打印多行字符串。特殊用途，是可以打印多行字符串。
3、如何在一個function裡設置一個全局的變量。
先說概念，全局變量是指定義在函數外部的變量。全局變量的作用域為全局。
局部變量是指定義在函數內部的變量。局部變量的作用域為函數內，除了函數就無效了。
這裡舉個例子，如果把函數比作國家，那麼全局就是全球，全局變量好比是阿拉伯數字，每個國家都認識。
4、python裡面如何拷貝一個對象？（賦值、淺拷貝、深拷貝的區別）
在python中如何拷貝一個對象是需要根據具體的需求來定的。
（1）賦值：其實就是對象的引用。相當於C的指針，修改了其中一個對象，另一個跟著改變。注意對於不可變對象而言，如果修改了其中一個對象，就相當於修改它的指針指向，另一個對象是不會跟著變化的。
（2）淺拷貝：拷貝父對象，但是不會拷貝父對象的子對象。（具體的方法有：b = copy.copy(a)，切片如b = a[1:4]）
（3）深拷貝：完全拷貝了父對象和子對象（具體的方法有：b = copy.deepcopy(a)）
下面是圖解：
1、b = a: 賦值引用，a 和 b 都指向同一個對象。
前言
之所以在這裡寫下python爬蟲常見面試題及解答，
一是用作筆記，方便日後回憶；
二是給自己一個和大家交流的機會，互相學習、進步，希望不正之處大家能給予指正；
三是我也是互聯網寒潮下崗的那批人之一，為了找工作而做準備。
一、題目部分
1、python中常用的數據結構有哪些？請簡要介紹一下。
python中常見的數據結構有：列表(list)，字典(dict)，元組(tuple)，字符串(string)，集合(set)，數字（int或long或float。。。）等。
其中，列表，元祖和字符串可以統一歸為序列類，即這三種數據結構中的元素是有序的。比如，他們都有索引（下標）操作，還有切片、相加和長度(len)，最大值(max)，最小值(min)操作。這是他們的共同點。
補充：python中常見的數據結構可以統稱為容器（container）。序列（如列表和元組）、映射（如字典）以及集合（set）是三類主要的容器。
另外，關於這個問題，面試官很容易引出另一個問題：python中的哪些數據類型是可變的，哪些是不可變的？
首先，可變/不可變是針對該對象所指向的內存中的值是否可變來判斷的。如可變類型的數據類型有列表和字典，還有集合不可變類型的數據類型有字符串，元組，數字。
就舉個最簡單的數字的例子，python中有小整數池的概念，即[-5,256]範圍內的整數，python解釋器對他們做了特殊處理，都放在內存中的固定位置，不會因為你的操作二發生變化。
現在：a = 1 ，然後我們又重新對a賦值，a = 2，在重新賦值的過程中，整數1所對應的內存地址沒有和數字的大小都沒有發生變化，還在內存中的固定位置。整數2也是如此。變化的是a的指針（這裡引用C中的概念）從指向數字1變成數字2。a對象指向的內存中的值沒有發生變化，因此數字是不可變類型的數據類型。字符串，集合也是同理。
2、簡要描述python中單引號、雙引號、三引號的區別。
首先，單引號和雙引號在使用時基本上沒有什麼區別；
唯一需要注意的是：
當字符串中有單引號時，最好在外面使用雙引號；
當有雙引號時，最好在外面使用單引號。
三引號一般不常用，除了用來做註釋之外，還可以用來打印多行字符串。特殊用途，是可以打印多行字符串。
3、如何在一個function裡設置一個全局的變量。
先說概念，全局變量是指定義在函數外部的變量。全局變量的作用域為全局。
局部變量是指定義在函數內部的變量。局部變量的作用域為函數內，除了函數就無效了。
這裡舉個例子，如果把函數比作國家，那麼全局就是全球，全局變量好比是阿拉伯數字，每個國家都認識。
4、python裡面如何拷貝一個對象？（賦值、淺拷貝、深拷貝的區別）
在python中如何拷貝一個對象是需要根據具體的需求來定的。
（1）賦值：其實就是對象的引用。相當於C的指針，修改了其中一個對象，另一個跟著改變。注意對於不可變對象而言，如果修改了其中一個對象，就相當於修改它的指針指向，另一個對象是不會跟著變化的。
（2）淺拷貝：拷貝父對象，但是不會拷貝父對象的子對象。（具體的方法有：b = copy.copy(a)，切片如b = a[1:4]）
（3）深拷貝：完全拷貝了父對象和子對象（具體的方法有：b = copy.deepcopy(a)）
下面是圖解：
1、b = a: 賦值引用，a 和 b 都指向同一個對象。
2、b = a.copy():淺拷貝, a 和 b 是一個獨立的對象，但他們的子對象還是指向統一對象（是引用）。
前言
之所以在這裡寫下python爬蟲常見面試題及解答，
一是用作筆記，方便日後回憶；
二是給自己一個和大家交流的機會，互相學習、進步，希望不正之處大家能給予指正；
三是我也是互聯網寒潮下崗的那批人之一，為了找工作而做準備。
一、題目部分
1、python中常用的數據結構有哪些？請簡要介紹一下。
python中常見的數據結構有：列表(list)，字典(dict)，元組(tuple)，字符串(string)，集合(set)，數字（int或long或float。。。）等。
其中，列表，元祖和字符串可以統一歸為序列類，即這三種數據結構中的元素是有序的。比如，他們都有索引（下標）操作，還有切片、相加和長度(len)，最大值(max)，最小值(min)操作。這是他們的共同點。
補充：python中常見的數據結構可以統稱為容器（container）。序列（如列表和元組）、映射（如字典）以及集合（set）是三類主要的容器。
另外，關於這個問題，面試官很容易引出另一個問題：python中的哪些數據類型是可變的，哪些是不可變的？
首先，可變/不可變是針對該對象所指向的內存中的值是否可變來判斷的。如可變類型的數據類型有列表和字典，還有集合不可變類型的數據類型有字符串，元組，數字。
就舉個最簡單的數字的例子，python中有小整數池的概念，即[-5,256]範圍內的整數，python解釋器對他們做了特殊處理，都放在內存中的固定位置，不會因為你的操作二發生變化。
現在：a = 1 ，然後我們又重新對a賦值，a = 2，在重新賦值的過程中，整數1所對應的內存地址沒有和數字的大小都沒有發生變化，還在內存中的固定位置。整數2也是如此。變化的是a的指針（這裡引用C中的概念）從指向數字1變成數字2。a對象指向的內存中的值沒有發生變化，因此數字是不可變類型的數據類型。字符串，集合也是同理。
2、簡要描述python中單引號、雙引號、三引號的區別。
首先，單引號和雙引號在使用時基本上沒有什麼區別；
唯一需要注意的是：
當字符串中有單引號時，最好在外面使用雙引號；
當有雙引號時，最好在外面使用單引號。
三引號一般不常用，除了用來做註釋之外，還可以用來打印多行字符串。特殊用途，是可以打印多行字符串。
3、如何在一個function裡設置一個全局的變量。
先說概念，全局變量是指定義在函數外部的變量。全局變量的作用域為全局。
局部變量是指定義在函數內部的變量。局部變量的作用域為函數內，除了函數就無效了。
這裡舉個例子，如果把函數比作國家，那麼全局就是全球，全局變量好比是阿拉伯數字，每個國家都認識。
4、python裡面如何拷貝一個對象？（賦值、淺拷貝、深拷貝的區別）
在python中如何拷貝一個對象是需要根據具體的需求來定的。
（1）賦值：其實就是對象的引用。相當於C的指針，修改了其中一個對象，另一個跟著改變。注意對於不可變對象而言，如果修改了其中一個對象，就相當於修改它的指針指向，另一個對象是不會跟著變化的。
（2）淺拷貝：拷貝父對象，但是不會拷貝父對象的子對象。（具體的方法有：b = copy.copy(a)，切片如b = a[1:4]）
（3）深拷貝：完全拷貝了父對象和子對象（具體的方法有：b = copy.deepcopy(a)）
下面是圖解：
1、b = a: 賦值引用，a 和 b 都指向同一個對象。
2、b = a.copy():淺拷貝, a 和 b 是一個獨立的對象，但他們的子對象還是指向統一對象（是引用）。
3、b = copy.deepcopy(a):深度拷貝, a 和 b 完全拷貝了父對象及其子對象，兩者是完全獨立的。
前言
之所以在這裡寫下python爬蟲常見面試題及解答，
一是用作筆記，方便日後回憶；
二是給自己一個和大家交流的機會，互相學習、進步，希望不正之處大家能給予指正；
三是我也是互聯網寒潮下崗的那批人之一，為了找工作而做準備。
一、題目部分
1、python中常用的數據結構有哪些？請簡要介紹一下。
python中常見的數據結構有：列表(list)，字典(dict)，元組(tuple)，字符串(string)，集合(set)，數字（int或long或float。。。）等。
其中，列表，元祖和字符串可以統一歸為序列類，即這三種數據結構中的元素是有序的。比如，他們都有索引（下標）操作，還有切片、相加和長度(len)，最大值(max)，最小值(min)操作。這是他們的共同點。
補充：python中常見的數據結構可以統稱為容器（container）。序列（如列表和元組）、映射（如字典）以及集合（set）是三類主要的容器。
另外，關於這個問題，面試官很容易引出另一個問題：python中的哪些數據類型是可變的，哪些是不可變的？
首先，可變/不可變是針對該對象所指向的內存中的值是否可變來判斷的。如可變類型的數據類型有列表和字典，還有集合不可變類型的數據類型有字符串，元組，數字。
就舉個最簡單的數字的例子，python中有小整數池的概念，即[-5,256]範圍內的整數，python解釋器對他們做了特殊處理，都放在內存中的固定位置，不會因為你的操作二發生變化。
現在：a = 1 ，然後我們又重新對a賦值，a = 2，在重新賦值的過程中，整數1所對應的內存地址沒有和數字的大小都沒有發生變化，還在內存中的固定位置。整數2也是如此。變化的是a的指針（這裡引用C中的概念）從指向數字1變成數字2。a對象指向的內存中的值沒有發生變化，因此數字是不可變類型的數據類型。字符串，集合也是同理。
2、簡要描述python中單引號、雙引號、三引號的區別。
首先，單引號和雙引號在使用時基本上沒有什麼區別；
唯一需要注意的是：
當字符串中有單引號時，最好在外面使用雙引號；
當有雙引號時，最好在外面使用單引號。
三引號一般不常用，除了用來做註釋之外，還可以用來打印多行字符串。特殊用途，是可以打印多行字符串。
3、如何在一個function裡設置一個全局的變量。
先說概念，全局變量是指定義在函數外部的變量。全局變量的作用域為全局。
局部變量是指定義在函數內部的變量。局部變量的作用域為函數內，除了函數就無效了。
這裡舉個例子，如果把函數比作國家，那麼全局就是全球，全局變量好比是阿拉伯數字，每個國家都認識。
4、python裡面如何拷貝一個對象？（賦值、淺拷貝、深拷貝的區別）
在python中如何拷貝一個對象是需要根據具體的需求來定的。
（1）賦值：其實就是對象的引用。相當於C的指針，修改了其中一個對象，另一個跟著改變。注意對於不可變對象而言，如果修改了其中一個對象，就相當於修改它的指針指向，另一個對象是不會跟著變化的。
（2）淺拷貝：拷貝父對象，但是不會拷貝父對象的子對象。（具體的方法有：b = copy.copy(a)，切片如b = a[1:4]）
（3）深拷貝：完全拷貝了父對象和子對象（具體的方法有：b = copy.deepcopy(a)）
下面是圖解：
1、b = a: 賦值引用，a 和 b 都指向同一個對象。
2、b = a.copy():淺拷貝, a 和 b 是一個獨立的對象，但他們的子對象還是指向統一對象（是引用）。
3、b = copy.deepcopy(a):深度拷貝, a 和 b 完全拷貝了父對象及其子對象，兩者是完全獨立的。
總結：
（1）當對象為不可變類型時，不論是賦值，淺拷貝還是深拷貝，那麼改變其中一個值時，另一個都是不會跟著變化的。
（2）當對象為可變對象時，如果是賦值和淺拷貝，那麼改變其中任意一個值，那麼另一個會跟著發生變化的；如果是深拷貝，是不會跟著發生改變的。
5、如果custname字符串的編碼格式為uft-8,如何將custname的內容轉化為gb18030的字符串？
先將custname編碼格式轉換為unicode，在轉換為gb18030。即custname.decode('utf-8').encode('gb18030')。
注意：unicode編碼是一種二進制編碼，是轉換編碼的中間橋樑。比如需要將utf-8轉換為gbk，那麼就需要先轉換為unicode（decode），再轉為gbk（encode）。
前言
之所以在這裡寫下python爬蟲常見面試題及解答，
一是用作筆記，方便日後回憶；
二是給自己一個和大家交流的機會，互相學習、進步，希望不正之處大家能給予指正；
三是我也是互聯網寒潮下崗的那批人之一，為了找工作而做準備。
一、題目部分
1、python中常用的數據結構有哪些？請簡要介紹一下。
python中常見的數據結構有：列表(list)，字典(dict)，元組(tuple)，字符串(string)，集合(set)，數字（int或long或float。。。）等。
其中，列表，元祖和字符串可以統一歸為序列類，即這三種數據結構中的元素是有序的。比如，他們都有索引（下標）操作，還有切片、相加和長度(len)，最大值(max)，最小值(min)操作。這是他們的共同點。
補充：python中常見的數據結構可以統稱為容器（container）。序列（如列表和元組）、映射（如字典）以及集合（set）是三類主要的容器。
另外，關於這個問題，面試官很容易引出另一個問題：python中的哪些數據類型是可變的，哪些是不可變的？
首先，可變/不可變是針對該對象所指向的內存中的值是否可變來判斷的。如可變類型的數據類型有列表和字典，還有集合不可變類型的數據類型有字符串，元組，數字。
就舉個最簡單的數字的例子，python中有小整數池的概念，即[-5,256]範圍內的整數，python解釋器對他們做了特殊處理，都放在內存中的固定位置，不會因為你的操作二發生變化。
現在：a = 1 ，然後我們又重新對a賦值，a = 2，在重新賦值的過程中，整數1所對應的內存地址沒有和數字的大小都沒有發生變化，還在內存中的固定位置。整數2也是如此。變化的是a的指針（這裡引用C中的概念）從指向數字1變成數字2。a對象指向的內存中的值沒有發生變化，因此數字是不可變類型的數據類型。字符串，集合也是同理。
2、簡要描述python中單引號、雙引號、三引號的區別。
首先，單引號和雙引號在使用時基本上沒有什麼區別；
唯一需要注意的是：
當字符串中有單引號時，最好在外面使用雙引號；
當有雙引號時，最好在外面使用單引號。
三引號一般不常用，除了用來做註釋之外，還可以用來打印多行字符串。特殊用途，是可以打印多行字符串。
3、如何在一個function裡設置一個全局的變量。
先說概念，全局變量是指定義在函數外部的變量。全局變量的作用域為全局。
局部變量是指定義在函數內部的變量。局部變量的作用域為函數內，除了函數就無效了。
這裡舉個例子，如果把函數比作國家，那麼全局就是全球，全局變量好比是阿拉伯數字，每個國家都認識。
4、python裡面如何拷貝一個對象？（賦值、淺拷貝、深拷貝的區別）
在python中如何拷貝一個對象是需要根據具體的需求來定的。
（1）賦值：其實就是對象的引用。相當於C的指針，修改了其中一個對象，另一個跟著改變。注意對於不可變對象而言，如果修改了其中一個對象，就相當於修改它的指針指向，另一個對象是不會跟著變化的。
（2）淺拷貝：拷貝父對象，但是不會拷貝父對象的子對象。（具體的方法有：b = copy.copy(a)，切片如b = a[1:4]）
（3）深拷貝：完全拷貝了父對象和子對象（具體的方法有：b = copy.deepcopy(a)）
下面是圖解：
1、b = a: 賦值引用，a 和 b 都指向同一個對象。
2、b = a.copy():淺拷貝, a 和 b 是一個獨立的對象，但他們的子對象還是指向統一對象（是引用）。
3、b = copy.deepcopy(a):深度拷貝, a 和 b 完全拷貝了父對象及其子對象，兩者是完全獨立的。
總結：
（1）當對象為不可變類型時，不論是賦值，淺拷貝還是深拷貝，那麼改變其中一個值時，另一個都是不會跟著變化的。
（2）當對象為可變對象時，如果是賦值和淺拷貝，那麼改變其中任意一個值，那麼另一個會跟著發生變化的；如果是深拷貝，是不會跟著發生改變的。
5、如果custname字符串的編碼格式為uft-8,如何將custname的內容轉化為gb18030的字符串？
先將custname編碼格式轉換為unicode，在轉換為gb18030。即custname.decode('utf-8').encode('gb18030')。
注意：unicode編碼是一種二進制編碼，是轉換編碼的中間橋樑。比如需要將utf-8轉換為gbk，那麼就需要先轉換為unicode（decode），再轉為gbk（encode）。
6、請寫出一段python代碼實現刪除list中的重複元素。
兩種方法：
（1）利用字典的fromkeys來自動過濾重複值
（2）利用集合set的特性，元素是非重複的
方法一：
前言
之所以在這裡寫下python爬蟲常見面試題及解答，
一是用作筆記，方便日後回憶；
二是給自己一個和大家交流的機會，互相學習、進步，希望不正之處大家能給予指正；
三是我也是互聯網寒潮下崗的那批人之一，為了找工作而做準備。
一、題目部分
1、python中常用的數據結構有哪些？請簡要介紹一下。
python中常見的數據結構有：列表(list)，字典(dict)，元組(tuple)，字符串(string)，集合(set)，數字（int或long或float。。。）等。
其中，列表，元祖和字符串可以統一歸為序列類，即這三種數據結構中的元素是有序的。比如，他們都有索引（下標）操作，還有切片、相加和長度(len)，最大值(max)，最小值(min)操作。這是他們的共同點。
補充：python中常見的數據結構可以統稱為容器（container）。序列（如列表和元組）、映射（如字典）以及集合（set）是三類主要的容器。
另外，關於這個問題，面試官很容易引出另一個問題：python中的哪些數據類型是可變的，哪些是不可變的？
首先，可變/不可變是針對該對象所指向的內存中的值是否可變來判斷的。如可變類型的數據類型有列表和字典，還有集合不可變類型的數據類型有字符串，元組，數字。
就舉個最簡單的數字的例子，python中有小整數池的概念，即[-5,256]範圍內的整數，python解釋器對他們做了特殊處理，都放在內存中的固定位置，不會因為你的操作二發生變化。
現在：a = 1 ，然後我們又重新對a賦值，a = 2，在重新賦值的過程中，整數1所對應的內存地址沒有和數字的大小都沒有發生變化，還在內存中的固定位置。整數2也是如此。變化的是a的指針（這裡引用C中的概念）從指向數字1變成數字2。a對象指向的內存中的值沒有發生變化，因此數字是不可變類型的數據類型。字符串，集合也是同理。
2、簡要描述python中單引號、雙引號、三引號的區別。
首先，單引號和雙引號在使用時基本上沒有什麼區別；
唯一需要注意的是：
當字符串中有單引號時，最好在外面使用雙引號；
當有雙引號時，最好在外面使用單引號。
三引號一般不常用，除了用來做註釋之外，還可以用來打印多行字符串。特殊用途，是可以打印多行字符串。
3、如何在一個function裡設置一個全局的變量。
先說概念，全局變量是指定義在函數外部的變量。全局變量的作用域為全局。
局部變量是指定義在函數內部的變量。局部變量的作用域為函數內，除了函數就無效了。
這裡舉個例子，如果把函數比作國家，那麼全局就是全球，全局變量好比是阿拉伯數字，每個國家都認識。
4、python裡面如何拷貝一個對象？（賦值、淺拷貝、深拷貝的區別）
在python中如何拷貝一個對象是需要根據具體的需求來定的。
（1）賦值：其實就是對象的引用。相當於C的指針，修改了其中一個對象，另一個跟著改變。注意對於不可變對象而言，如果修改了其中一個對象，就相當於修改它的指針指向，另一個對象是不會跟著變化的。
（2）淺拷貝：拷貝父對象，但是不會拷貝父對象的子對象。（具體的方法有：b = copy.copy(a)，切片如b = a[1:4]）
（3）深拷貝：完全拷貝了父對象和子對象（具體的方法有：b = copy.deepcopy(a)）
下面是圖解：
1、b = a: 賦值引用，a 和 b 都指向同一個對象。
2、b = a.copy():淺拷貝, a 和 b 是一個獨立的對象，但他們的子對象還是指向統一對象（是引用）。
3、b = copy.deepcopy(a):深度拷貝, a 和 b 完全拷貝了父對象及其子對象，兩者是完全獨立的。
總結：
（1）當對象為不可變類型時，不論是賦值，淺拷貝還是深拷貝，那麼改變其中一個值時，另一個都是不會跟著變化的。
（2）當對象為可變對象時，如果是賦值和淺拷貝，那麼改變其中任意一個值，那麼另一個會跟著發生變化的；如果是深拷貝，是不會跟著發生改變的。
5、如果custname字符串的編碼格式為uft-8,如何將custname的內容轉化為gb18030的字符串？
先將custname編碼格式轉換為unicode，在轉換為gb18030。即custname.decode('utf-8').encode('gb18030')。
注意：unicode編碼是一種二進制編碼，是轉換編碼的中間橋樑。比如需要將utf-8轉換為gbk，那麼就需要先轉換為unicode（decode），再轉為gbk（encode）。
6、請寫出一段python代碼實現刪除list中的重複元素。
兩種方法：
（1）利用字典的fromkeys來自動過濾重複值
（2）利用集合set的特性，元素是非重複的
方法一：
方法二：
前言
之所以在這裡寫下python爬蟲常見面試題及解答，
一是用作筆記，方便日後回憶；
二是給自己一個和大家交流的機會，互相學習、進步，希望不正之處大家能給予指正；
三是我也是互聯網寒潮下崗的那批人之一，為了找工作而做準備。
一、題目部分
1、python中常用的數據結構有哪些？請簡要介紹一下。
python中常見的數據結構有：列表(list)，字典(dict)，元組(tuple)，字符串(string)，集合(set)，數字（int或long或float。。。）等。
其中，列表，元祖和字符串可以統一歸為序列類，即這三種數據結構中的元素是有序的。比如，他們都有索引（下標）操作，還有切片、相加和長度(len)，最大值(max)，最小值(min)操作。這是他們的共同點。
補充：python中常見的數據結構可以統稱為容器（container）。序列（如列表和元組）、映射（如字典）以及集合（set）是三類主要的容器。
另外，關於這個問題，面試官很容易引出另一個問題：python中的哪些數據類型是可變的，哪些是不可變的？
首先，可變/不可變是針對該對象所指向的內存中的值是否可變來判斷的。如可變類型的數據類型有列表和字典，還有集合不可變類型的數據類型有字符串，元組，數字。
就舉個最簡單的數字的例子，python中有小整數池的概念，即[-5,256]範圍內的整數，python解釋器對他們做了特殊處理，都放在內存中的固定位置，不會因為你的操作二發生變化。
現在：a = 1 ，然後我們又重新對a賦值，a = 2，在重新賦值的過程中，整數1所對應的內存地址沒有和數字的大小都沒有發生變化，還在內存中的固定位置。整數2也是如此。變化的是a的指針（這裡引用C中的概念）從指向數字1變成數字2。a對象指向的內存中的值沒有發生變化，因此數字是不可變類型的數據類型。字符串，集合也是同理。
2、簡要描述python中單引號、雙引號、三引號的區別。
首先，單引號和雙引號在使用時基本上沒有什麼區別；
唯一需要注意的是：
當字符串中有單引號時，最好在外面使用雙引號；
當有雙引號時，最好在外面使用單引號。
三引號一般不常用，除了用來做註釋之外，還可以用來打印多行字符串。特殊用途，是可以打印多行字符串。
3、如何在一個function裡設置一個全局的變量。
先說概念，全局變量是指定義在函數外部的變量。全局變量的作用域為全局。
局部變量是指定義在函數內部的變量。局部變量的作用域為函數內，除了函數就無效了。
這裡舉個例子，如果把函數比作國家，那麼全局就是全球，全局變量好比是阿拉伯數字，每個國家都認識。
4、python裡面如何拷貝一個對象？（賦值、淺拷貝、深拷貝的區別）
在python中如何拷貝一個對象是需要根據具體的需求來定的。
（1）賦值：其實就是對象的引用。相當於C的指針，修改了其中一個對象，另一個跟著改變。注意對於不可變對象而言，如果修改了其中一個對象，就相當於修改它的指針指向，另一個對象是不會跟著變化的。
（2）淺拷貝：拷貝父對象，但是不會拷貝父對象的子對象。（具體的方法有：b = copy.copy(a)，切片如b = a[1:4]）
（3）深拷貝：完全拷貝了父對象和子對象（具體的方法有：b = copy.deepcopy(a)）
下面是圖解：
1、b = a: 賦值引用，a 和 b 都指向同一個對象。
2、b = a.copy():淺拷貝, a 和 b 是一個獨立的對象，但他們的子對象還是指向統一對象（是引用）。
3、b = copy.deepcopy(a):深度拷貝, a 和 b 完全拷貝了父對象及其子對象，兩者是完全獨立的。
總結：
（1）當對象為不可變類型時，不論是賦值，淺拷貝還是深拷貝，那麼改變其中一個值時，另一個都是不會跟著變化的。
（2）當對象為可變對象時，如果是賦值和淺拷貝，那麼改變其中任意一個值，那麼另一個會跟著發生變化的；如果是深拷貝，是不會跟著發生改變的。
5、如果custname字符串的編碼格式為uft-8,如何將custname的內容轉化為gb18030的字符串？
先將custname編碼格式轉換為unicode，在轉換為gb18030。即custname.decode('utf-8').encode('gb18030')。
注意：unicode編碼是一種二進制編碼，是轉換編碼的中間橋樑。比如需要將utf-8轉換為gbk，那麼就需要先轉換為unicode（decode），再轉為gbk（encode）。
6、請寫出一段python代碼實現刪除list中的重複元素。
兩種方法：
（1）利用字典的fromkeys來自動過濾重複值
（2）利用集合set的特性，元素是非重複的
方法一：
方法二：
7、這兩個參數是什麼意思？args和 kwargs。
首先，我想說的是*args和**kwargs並不是必須這樣寫，只有前面的*和**才是必須的。你可以寫成*var和**vars。而寫成*args和**kwargs只是約定俗稱的一個命名規定。
*args和**kwargs主要用於函數定義，你可以將不定量的參數傳遞給一個函數。其中，*args是用來發送一個非鍵值對的可變數量的參數列表給一個函數；**kwargs允許你將不定長度的鍵值對, 作為參數傳遞給一個函數。 如果你想要在一個函數裡處理帶名字的參數, 你應該使用**kwargs。
前言
之所以在這裡寫下python爬蟲常見面試題及解答，
一是用作筆記，方便日後回憶；
二是給自己一個和大家交流的機會，互相學習、進步，希望不正之處大家能給予指正；
三是我也是互聯網寒潮下崗的那批人之一，為了找工作而做準備。
一、題目部分
1、python中常用的數據結構有哪些？請簡要介紹一下。
python中常見的數據結構有：列表(list)，字典(dict)，元組(tuple)，字符串(string)，集合(set)，數字（int或long或float。。。）等。
其中，列表，元祖和字符串可以統一歸為序列類，即這三種數據結構中的元素是有序的。比如，他們都有索引（下標）操作，還有切片、相加和長度(len)，最大值(max)，最小值(min)操作。這是他們的共同點。
補充：python中常見的數據結構可以統稱為容器（container）。序列（如列表和元組）、映射（如字典）以及集合（set）是三類主要的容器。
另外，關於這個問題，面試官很容易引出另一個問題：python中的哪些數據類型是可變的，哪些是不可變的？
首先，可變/不可變是針對該對象所指向的內存中的值是否可變來判斷的。如可變類型的數據類型有列表和字典，還有集合不可變類型的數據類型有字符串，元組，數字。
就舉個最簡單的數字的例子，python中有小整數池的概念，即[-5,256]範圍內的整數，python解釋器對他們做了特殊處理，都放在內存中的固定位置，不會因為你的操作二發生變化。
現在：a = 1 ，然後我們又重新對a賦值，a = 2，在重新賦值的過程中，整數1所對應的內存地址沒有和數字的大小都沒有發生變化，還在內存中的固定位置。整數2也是如此。變化的是a的指針（這裡引用C中的概念）從指向數字1變成數字2。a對象指向的內存中的值沒有發生變化，因此數字是不可變類型的數據類型。字符串，集合也是同理。
2、簡要描述python中單引號、雙引號、三引號的區別。
首先，單引號和雙引號在使用時基本上沒有什麼區別；
唯一需要注意的是：
當字符串中有單引號時，最好在外面使用雙引號；
當有雙引號時，最好在外面使用單引號。
三引號一般不常用，除了用來做註釋之外，還可以用來打印多行字符串。特殊用途，是可以打印多行字符串。
3、如何在一個function裡設置一個全局的變量。
先說概念，全局變量是指定義在函數外部的變量。全局變量的作用域為全局。
局部變量是指定義在函數內部的變量。局部變量的作用域為函數內，除了函數就無效了。
這裡舉個例子，如果把函數比作國家，那麼全局就是全球，全局變量好比是阿拉伯數字，每個國家都認識。
4、python裡面如何拷貝一個對象？（賦值、淺拷貝、深拷貝的區別）
在python中如何拷貝一個對象是需要根據具體的需求來定的。
（1）賦值：其實就是對象的引用。相當於C的指針，修改了其中一個對象，另一個跟著改變。注意對於不可變對象而言，如果修改了其中一個對象，就相當於修改它的指針指向，另一個對象是不會跟著變化的。
（2）淺拷貝：拷貝父對象，但是不會拷貝父對象的子對象。（具體的方法有：b = copy.copy(a)，切片如b = a[1:4]）
（3）深拷貝：完全拷貝了父對象和子對象（具體的方法有：b = copy.deepcopy(a)）
下面是圖解：
1、b = a: 賦值引用，a 和 b 都指向同一個對象。
2、b = a.copy():淺拷貝, a 和 b 是一個獨立的對象，但他們的子對象還是指向統一對象（是引用）。
3、b = copy.deepcopy(a):深度拷貝, a 和 b 完全拷貝了父對象及其子對象，兩者是完全獨立的。
總結：
（1）當對象為不可變類型時，不論是賦值，淺拷貝還是深拷貝，那麼改變其中一個值時，另一個都是不會跟著變化的。
（2）當對象為可變對象時，如果是賦值和淺拷貝，那麼改變其中任意一個值，那麼另一個會跟著發生變化的；如果是深拷貝，是不會跟著發生改變的。
5、如果custname字符串的編碼格式為uft-8,如何將custname的內容轉化為gb18030的字符串？
先將custname編碼格式轉換為unicode，在轉換為gb18030。即custname.decode('utf-8').encode('gb18030')。
注意：unicode編碼是一種二進制編碼，是轉換編碼的中間橋樑。比如需要將utf-8轉換為gbk，那麼就需要先轉換為unicode（decode），再轉為gbk（encode）。
6、請寫出一段python代碼實現刪除list中的重複元素。
兩種方法：
（1）利用字典的fromkeys來自動過濾重複值
（2）利用集合set的特性，元素是非重複的
方法一：
方法二：
7、這兩個參數是什麼意思？args和 kwargs。
首先，我想說的是*args和**kwargs並不是必須這樣寫，只有前面的*和**才是必須的。你可以寫成*var和**vars。而寫成*args和**kwargs只是約定俗稱的一個命名規定。
*args和**kwargs主要用於函數定義，你可以將不定量的參數傳遞給一個函數。其中，*args是用來發送一個非鍵值對的可變數量的參數列表給一個函數；**kwargs允許你將不定長度的鍵值對, 作為參數傳遞給一個函數。 如果你想要在一個函數裡處理帶名字的參數, 你應該使用**kwargs。
這裡傳遞了3個參數，按位置傳參，'123'為test傳參，'hello'和'2019'為*args傳參，這裡傳了2個參數。
注意，看下面的*args的另一種用法：用來解壓數據。
前言
之所以在這裡寫下python爬蟲常見面試題及解答，
一是用作筆記，方便日後回憶；
二是給自己一個和大家交流的機會，互相學習、進步，希望不正之處大家能給予指正；
三是我也是互聯網寒潮下崗的那批人之一，為了找工作而做準備。
一、題目部分
1、python中常用的數據結構有哪些？請簡要介紹一下。
python中常見的數據結構有：列表(list)，字典(dict)，元組(tuple)，字符串(string)，集合(set)，數字（int或long或float。。。）等。
其中，列表，元祖和字符串可以統一歸為序列類，即這三種數據結構中的元素是有序的。比如，他們都有索引（下標）操作，還有切片、相加和長度(len)，最大值(max)，最小值(min)操作。這是他們的共同點。
補充：python中常見的數據結構可以統稱為容器（container）。序列（如列表和元組）、映射（如字典）以及集合（set）是三類主要的容器。
另外，關於這個問題，面試官很容易引出另一個問題：python中的哪些數據類型是可變的，哪些是不可變的？
首先，可變/不可變是針對該對象所指向的內存中的值是否可變來判斷的。如可變類型的數據類型有列表和字典，還有集合不可變類型的數據類型有字符串，元組，數字。
就舉個最簡單的數字的例子，python中有小整數池的概念，即[-5,256]範圍內的整數，python解釋器對他們做了特殊處理，都放在內存中的固定位置，不會因為你的操作二發生變化。
現在：a = 1 ，然後我們又重新對a賦值，a = 2，在重新賦值的過程中，整數1所對應的內存地址沒有和數字的大小都沒有發生變化，還在內存中的固定位置。整數2也是如此。變化的是a的指針（這裡引用C中的概念）從指向數字1變成數字2。a對象指向的內存中的值沒有發生變化，因此數字是不可變類型的數據類型。字符串，集合也是同理。
2、簡要描述python中單引號、雙引號、三引號的區別。
首先，單引號和雙引號在使用時基本上沒有什麼區別；
唯一需要注意的是：
當字符串中有單引號時，最好在外面使用雙引號；
當有雙引號時，最好在外面使用單引號。
三引號一般不常用，除了用來做註釋之外，還可以用來打印多行字符串。特殊用途，是可以打印多行字符串。
3、如何在一個function裡設置一個全局的變量。
先說概念，全局變量是指定義在函數外部的變量。全局變量的作用域為全局。
局部變量是指定義在函數內部的變量。局部變量的作用域為函數內，除了函數就無效了。
這裡舉個例子，如果把函數比作國家，那麼全局就是全球，全局變量好比是阿拉伯數字，每個國家都認識。
4、python裡面如何拷貝一個對象？（賦值、淺拷貝、深拷貝的區別）
在python中如何拷貝一個對象是需要根據具體的需求來定的。
（1）賦值：其實就是對象的引用。相當於C的指針，修改了其中一個對象，另一個跟著改變。注意對於不可變對象而言，如果修改了其中一個對象，就相當於修改它的指針指向，另一個對象是不會跟著變化的。
（2）淺拷貝：拷貝父對象，但是不會拷貝父對象的子對象。（具體的方法有：b = copy.copy(a)，切片如b = a[1:4]）
（3）深拷貝：完全拷貝了父對象和子對象（具體的方法有：b = copy.deepcopy(a)）
下面是圖解：
1、b = a: 賦值引用，a 和 b 都指向同一個對象。
2、b = a.copy():淺拷貝, a 和 b 是一個獨立的對象，但他們的子對象還是指向統一對象（是引用）。
3、b = copy.deepcopy(a):深度拷貝, a 和 b 完全拷貝了父對象及其子對象，兩者是完全獨立的。
總結：
（1）當對象為不可變類型時，不論是賦值，淺拷貝還是深拷貝，那麼改變其中一個值時，另一個都是不會跟著變化的。
（2）當對象為可變對象時，如果是賦值和淺拷貝，那麼改變其中任意一個值，那麼另一個會跟著發生變化的；如果是深拷貝，是不會跟著發生改變的。
5、如果custname字符串的編碼格式為uft-8,如何將custname的內容轉化為gb18030的字符串？
先將custname編碼格式轉換為unicode，在轉換為gb18030。即custname.decode('utf-8').encode('gb18030')。
注意：unicode編碼是一種二進制編碼，是轉換編碼的中間橋樑。比如需要將utf-8轉換為gbk，那麼就需要先轉換為unicode（decode），再轉為gbk（encode）。
6、請寫出一段python代碼實現刪除list中的重複元素。
兩種方法：
（1）利用字典的fromkeys來自動過濾重複值
（2）利用集合set的特性，元素是非重複的
方法一：
方法二：
7、這兩個參數是什麼意思？args和 kwargs。
首先，我想說的是*args和**kwargs並不是必須這樣寫，只有前面的*和**才是必須的。你可以寫成*var和**vars。而寫成*args和**kwargs只是約定俗稱的一個命名規定。
*args和**kwargs主要用於函數定義，你可以將不定量的參數傳遞給一個函數。其中，*args是用來發送一個非鍵值對的可變數量的參數列表給一個函數；**kwargs允許你將不定長度的鍵值對, 作為參數傳遞給一個函數。 如果你想要在一個函數裡處理帶名字的參數, 你應該使用**kwargs。
這裡傳遞了3個參數，按位置傳參，'123'為test傳參，'hello'和'2019'為*args傳參，這裡傳了2個參數。
注意，看下面的*args的另一種用法：用來解壓數據。
這段代碼和上面的效果是一樣的，但是這裡第8行的*args和第1行的*args可是不一樣的。第一行是表示函數可以接受不定數量的非鍵值對的參數，用來傳參使用的。第八行是用來解壓列表
['hello', '2019']的每一項數據的，用來解壓參數的。這是*args的兩種用法，也可說是*的兩種用法，因為args是可變的。
接下來說說**kwargs。
前言
之所以在這裡寫下python爬蟲常見面試題及解答，
一是用作筆記，方便日後回憶；
二是給自己一個和大家交流的機會，互相學習、進步，希望不正之處大家能給予指正；
三是我也是互聯網寒潮下崗的那批人之一，為了找工作而做準備。
一、題目部分
1、python中常用的數據結構有哪些？請簡要介紹一下。
python中常見的數據結構有：列表(list)，字典(dict)，元組(tuple)，字符串(string)，集合(set)，數字（int或long或float。。。）等。
其中，列表，元祖和字符串可以統一歸為序列類，即這三種數據結構中的元素是有序的。比如，他們都有索引（下標）操作，還有切片、相加和長度(len)，最大值(max)，最小值(min)操作。這是他們的共同點。
補充：python中常見的數據結構可以統稱為容器（container）。序列（如列表和元組）、映射（如字典）以及集合（set）是三類主要的容器。
另外，關於這個問題，面試官很容易引出另一個問題：python中的哪些數據類型是可變的，哪些是不可變的？
首先，可變/不可變是針對該對象所指向的內存中的值是否可變來判斷的。如可變類型的數據類型有列表和字典，還有集合不可變類型的數據類型有字符串，元組，數字。
就舉個最簡單的數字的例子，python中有小整數池的概念，即[-5,256]範圍內的整數，python解釋器對他們做了特殊處理，都放在內存中的固定位置，不會因為你的操作二發生變化。
現在：a = 1 ，然後我們又重新對a賦值，a = 2，在重新賦值的過程中，整數1所對應的內存地址沒有和數字的大小都沒有發生變化，還在內存中的固定位置。整數2也是如此。變化的是a的指針（這裡引用C中的概念）從指向數字1變成數字2。a對象指向的內存中的值沒有發生變化，因此數字是不可變類型的數據類型。字符串，集合也是同理。
2、簡要描述python中單引號、雙引號、三引號的區別。
首先，單引號和雙引號在使用時基本上沒有什麼區別；
唯一需要注意的是：
當字符串中有單引號時，最好在外面使用雙引號；
當有雙引號時，最好在外面使用單引號。
三引號一般不常用，除了用來做註釋之外，還可以用來打印多行字符串。特殊用途，是可以打印多行字符串。
3、如何在一個function裡設置一個全局的變量。
先說概念，全局變量是指定義在函數外部的變量。全局變量的作用域為全局。
局部變量是指定義在函數內部的變量。局部變量的作用域為函數內，除了函數就無效了。
這裡舉個例子，如果把函數比作國家，那麼全局就是全球，全局變量好比是阿拉伯數字，每個國家都認識。
4、python裡面如何拷貝一個對象？（賦值、淺拷貝、深拷貝的區別）
在python中如何拷貝一個對象是需要根據具體的需求來定的。
（1）賦值：其實就是對象的引用。相當於C的指針，修改了其中一個對象，另一個跟著改變。注意對於不可變對象而言，如果修改了其中一個對象，就相當於修改它的指針指向，另一個對象是不會跟著變化的。
（2）淺拷貝：拷貝父對象，但是不會拷貝父對象的子對象。（具體的方法有：b = copy.copy(a)，切片如b = a[1:4]）
（3）深拷貝：完全拷貝了父對象和子對象（具體的方法有：b = copy.deepcopy(a)）
下面是圖解：
1、b = a: 賦值引用，a 和 b 都指向同一個對象。
2、b = a.copy():淺拷貝, a 和 b 是一個獨立的對象，但他們的子對象還是指向統一對象（是引用）。
3、b = copy.deepcopy(a):深度拷貝, a 和 b 完全拷貝了父對象及其子對象，兩者是完全獨立的。
總結：
（1）當對象為不可變類型時，不論是賦值，淺拷貝還是深拷貝，那麼改變其中一個值時，另一個都是不會跟著變化的。
（2）當對象為可變對象時，如果是賦值和淺拷貝，那麼改變其中任意一個值，那麼另一個會跟著發生變化的；如果是深拷貝，是不會跟著發生改變的。
5、如果custname字符串的編碼格式為uft-8,如何將custname的內容轉化為gb18030的字符串？
先將custname編碼格式轉換為unicode，在轉換為gb18030。即custname.decode('utf-8').encode('gb18030')。
注意：unicode編碼是一種二進制編碼，是轉換編碼的中間橋樑。比如需要將utf-8轉換為gbk，那麼就需要先轉換為unicode（decode），再轉為gbk（encode）。
6、請寫出一段python代碼實現刪除list中的重複元素。
兩種方法：
（1）利用字典的fromkeys來自動過濾重複值
（2）利用集合set的特性，元素是非重複的
方法一：
方法二：
7、這兩個參數是什麼意思？args和 kwargs。
首先，我想說的是*args和**kwargs並不是必須這樣寫，只有前面的*和**才是必須的。你可以寫成*var和**vars。而寫成*args和**kwargs只是約定俗稱的一個命名規定。
*args和**kwargs主要用於函數定義，你可以將不定量的參數傳遞給一個函數。其中，*args是用來發送一個非鍵值對的可變數量的參數列表給一個函數；**kwargs允許你將不定長度的鍵值對, 作為參數傳遞給一個函數。 如果你想要在一個函數裡處理帶名字的參數, 你應該使用**kwargs。
這裡傳遞了3個參數，按位置傳參，'123'為test傳參，'hello'和'2019'為*args傳參，這裡傳了2個參數。
注意，看下面的*args的另一種用法：用來解壓數據。
這段代碼和上面的效果是一樣的，但是這裡第8行的*args和第1行的*args可是不一樣的。第一行是表示函數可以接受不定數量的非鍵值對的參數，用來傳參使用的。第八行是用來解壓列表
['hello', '2019']的每一項數據的，用來解壓參數的。這是*args的兩種用法，也可說是*的兩種用法，因為args是可變的。
接下來說說**kwargs。
**kwargs用來傳遞帶鍵值對的參數，而**也是用來解壓字典容器內的參數。
總結：
*args和**kwargs都是用於函數中傳遞參數的，*args傳遞的是非鍵值對的參數，**kwargs傳遞的是帶鍵值對的參數，如果還有普通參數需要傳遞，那麼應該先傳遞普通的參數。
8、
（1）統計如下list單詞及其出現的次數。
前言
之所以在這裡寫下python爬蟲常見面試題及解答，
一是用作筆記，方便日後回憶；
二是給自己一個和大家交流的機會，互相學習、進步，希望不正之處大家能給予指正；
三是我也是互聯網寒潮下崗的那批人之一，為了找工作而做準備。
一、題目部分
1、python中常用的數據結構有哪些？請簡要介紹一下。
python中常見的數據結構有：列表(list)，字典(dict)，元組(tuple)，字符串(string)，集合(set)，數字（int或long或float。。。）等。
其中，列表，元祖和字符串可以統一歸為序列類，即這三種數據結構中的元素是有序的。比如，他們都有索引（下標）操作，還有切片、相加和長度(len)，最大值(max)，最小值(min)操作。這是他們的共同點。
補充：python中常見的數據結構可以統稱為容器（container）。序列（如列表和元組）、映射（如字典）以及集合（set）是三類主要的容器。
另外，關於這個問題，面試官很容易引出另一個問題：python中的哪些數據類型是可變的，哪些是不可變的？
首先，可變/不可變是針對該對象所指向的內存中的值是否可變來判斷的。如可變類型的數據類型有列表和字典，還有集合不可變類型的數據類型有字符串，元組，數字。
就舉個最簡單的數字的例子，python中有小整數池的概念，即[-5,256]範圍內的整數，python解釋器對他們做了特殊處理，都放在內存中的固定位置，不會因為你的操作二發生變化。
現在：a = 1 ，然後我們又重新對a賦值，a = 2，在重新賦值的過程中，整數1所對應的內存地址沒有和數字的大小都沒有發生變化，還在內存中的固定位置。整數2也是如此。變化的是a的指針（這裡引用C中的概念）從指向數字1變成數字2。a對象指向的內存中的值沒有發生變化，因此數字是不可變類型的數據類型。字符串，集合也是同理。
2、簡要描述python中單引號、雙引號、三引號的區別。
首先，單引號和雙引號在使用時基本上沒有什麼區別；
唯一需要注意的是：
當字符串中有單引號時，最好在外面使用雙引號；
當有雙引號時，最好在外面使用單引號。
三引號一般不常用，除了用來做註釋之外，還可以用來打印多行字符串。特殊用途，是可以打印多行字符串。
3、如何在一個function裡設置一個全局的變量。
先說概念，全局變量是指定義在函數外部的變量。全局變量的作用域為全局。
局部變量是指定義在函數內部的變量。局部變量的作用域為函數內，除了函數就無效了。
這裡舉個例子，如果把函數比作國家，那麼全局就是全球，全局變量好比是阿拉伯數字，每個國家都認識。
4、python裡面如何拷貝一個對象？（賦值、淺拷貝、深拷貝的區別）
在python中如何拷貝一個對象是需要根據具體的需求來定的。
（1）賦值：其實就是對象的引用。相當於C的指針，修改了其中一個對象，另一個跟著改變。注意對於不可變對象而言，如果修改了其中一個對象，就相當於修改它的指針指向，另一個對象是不會跟著變化的。
（2）淺拷貝：拷貝父對象，但是不會拷貝父對象的子對象。（具體的方法有：b = copy.copy(a)，切片如b = a[1:4]）
（3）深拷貝：完全拷貝了父對象和子對象（具體的方法有：b = copy.deepcopy(a)）
下面是圖解：
1、b = a: 賦值引用，a 和 b 都指向同一個對象。
2、b = a.copy():淺拷貝, a 和 b 是一個獨立的對象，但他們的子對象還是指向統一對象（是引用）。
3、b = copy.deepcopy(a):深度拷貝, a 和 b 完全拷貝了父對象及其子對象，兩者是完全獨立的。
總結：
（1）當對象為不可變類型時，不論是賦值，淺拷貝還是深拷貝，那麼改變其中一個值時，另一個都是不會跟著變化的。
（2）當對象為可變對象時，如果是賦值和淺拷貝，那麼改變其中任意一個值，那麼另一個會跟著發生變化的；如果是深拷貝，是不會跟著發生改變的。
5、如果custname字符串的編碼格式為uft-8,如何將custname的內容轉化為gb18030的字符串？
先將custname編碼格式轉換為unicode，在轉換為gb18030。即custname.decode('utf-8').encode('gb18030')。
注意：unicode編碼是一種二進制編碼，是轉換編碼的中間橋樑。比如需要將utf-8轉換為gbk，那麼就需要先轉換為unicode（decode），再轉為gbk（encode）。
6、請寫出一段python代碼實現刪除list中的重複元素。
兩種方法：
（1）利用字典的fromkeys來自動過濾重複值
（2）利用集合set的特性，元素是非重複的
方法一：
方法二：
7、這兩個參數是什麼意思？args和 kwargs。
首先，我想說的是*args和**kwargs並不是必須這樣寫，只有前面的*和**才是必須的。你可以寫成*var和**vars。而寫成*args和**kwargs只是約定俗稱的一個命名規定。
*args和**kwargs主要用於函數定義，你可以將不定量的參數傳遞給一個函數。其中，*args是用來發送一個非鍵值對的可變數量的參數列表給一個函數；**kwargs允許你將不定長度的鍵值對, 作為參數傳遞給一個函數。 如果你想要在一個函數裡處理帶名字的參數, 你應該使用**kwargs。
這裡傳遞了3個參數，按位置傳參，'123'為test傳參，'hello'和'2019'為*args傳參，這裡傳了2個參數。
注意，看下面的*args的另一種用法：用來解壓數據。
這段代碼和上面的效果是一樣的，但是這裡第8行的*args和第1行的*args可是不一樣的。第一行是表示函數可以接受不定數量的非鍵值對的參數，用來傳參使用的。第八行是用來解壓列表
['hello', '2019']的每一項數據的，用來解壓參數的。這是*args的兩種用法，也可說是*的兩種用法，因為args是可變的。
接下來說說**kwargs。
**kwargs用來傳遞帶鍵值對的參數，而**也是用來解壓字典容器內的參數。
總結：
*args和**kwargs都是用於函數中傳遞參數的，*args傳遞的是非鍵值對的參數，**kwargs傳遞的是帶鍵值對的參數，如果還有普通參數需要傳遞，那麼應該先傳遞普通的參數。
8、
（1）統計如下list單詞及其出現的次數。
方法一：
利用字典。
前言
之所以在這裡寫下python爬蟲常見面試題及解答，
一是用作筆記，方便日後回憶；
二是給自己一個和大家交流的機會，互相學習、進步，希望不正之處大家能給予指正；
三是我也是互聯網寒潮下崗的那批人之一，為了找工作而做準備。
一、題目部分
1、python中常用的數據結構有哪些？請簡要介紹一下。
python中常見的數據結構有：列表(list)，字典(dict)，元組(tuple)，字符串(string)，集合(set)，數字（int或long或float。。。）等。
其中，列表，元祖和字符串可以統一歸為序列類，即這三種數據結構中的元素是有序的。比如，他們都有索引（下標）操作，還有切片、相加和長度(len)，最大值(max)，最小值(min)操作。這是他們的共同點。
補充：python中常見的數據結構可以統稱為容器（container）。序列（如列表和元組）、映射（如字典）以及集合（set）是三類主要的容器。
另外，關於這個問題，面試官很容易引出另一個問題：python中的哪些數據類型是可變的，哪些是不可變的？
首先，可變/不可變是針對該對象所指向的內存中的值是否可變來判斷的。如可變類型的數據類型有列表和字典，還有集合不可變類型的數據類型有字符串，元組，數字。
就舉個最簡單的數字的例子，python中有小整數池的概念，即[-5,256]範圍內的整數，python解釋器對他們做了特殊處理，都放在內存中的固定位置，不會因為你的操作二發生變化。
現在：a = 1 ，然後我們又重新對a賦值，a = 2，在重新賦值的過程中，整數1所對應的內存地址沒有和數字的大小都沒有發生變化，還在內存中的固定位置。整數2也是如此。變化的是a的指針（這裡引用C中的概念）從指向數字1變成數字2。a對象指向的內存中的值沒有發生變化，因此數字是不可變類型的數據類型。字符串，集合也是同理。
2、簡要描述python中單引號、雙引號、三引號的區別。
首先，單引號和雙引號在使用時基本上沒有什麼區別；
唯一需要注意的是：
當字符串中有單引號時，最好在外面使用雙引號；
當有雙引號時，最好在外面使用單引號。
三引號一般不常用，除了用來做註釋之外，還可以用來打印多行字符串。特殊用途，是可以打印多行字符串。
3、如何在一個function裡設置一個全局的變量。
先說概念，全局變量是指定義在函數外部的變量。全局變量的作用域為全局。
局部變量是指定義在函數內部的變量。局部變量的作用域為函數內，除了函數就無效了。
這裡舉個例子，如果把函數比作國家，那麼全局就是全球，全局變量好比是阿拉伯數字，每個國家都認識。
4、python裡面如何拷貝一個對象？（賦值、淺拷貝、深拷貝的區別）
在python中如何拷貝一個對象是需要根據具體的需求來定的。
（1）賦值：其實就是對象的引用。相當於C的指針，修改了其中一個對象，另一個跟著改變。注意對於不可變對象而言，如果修改了其中一個對象，就相當於修改它的指針指向，另一個對象是不會跟著變化的。
（2）淺拷貝：拷貝父對象，但是不會拷貝父對象的子對象。（具體的方法有：b = copy.copy(a)，切片如b = a[1:4]）
（3）深拷貝：完全拷貝了父對象和子對象（具體的方法有：b = copy.deepcopy(a)）
下面是圖解：
1、b = a: 賦值引用，a 和 b 都指向同一個對象。
2、b = a.copy():淺拷貝, a 和 b 是一個獨立的對象，但他們的子對象還是指向統一對象（是引用）。
3、b = copy.deepcopy(a):深度拷貝, a 和 b 完全拷貝了父對象及其子對象，兩者是完全獨立的。
總結：
（1）當對象為不可變類型時，不論是賦值，淺拷貝還是深拷貝，那麼改變其中一個值時，另一個都是不會跟著變化的。
（2）當對象為可變對象時，如果是賦值和淺拷貝，那麼改變其中任意一個值，那麼另一個會跟著發生變化的；如果是深拷貝，是不會跟著發生改變的。
5、如果custname字符串的編碼格式為uft-8,如何將custname的內容轉化為gb18030的字符串？
先將custname編碼格式轉換為unicode，在轉換為gb18030。即custname.decode('utf-8').encode('gb18030')。
注意：unicode編碼是一種二進制編碼，是轉換編碼的中間橋樑。比如需要將utf-8轉換為gbk，那麼就需要先轉換為unicode（decode），再轉為gbk（encode）。
6、請寫出一段python代碼實現刪除list中的重複元素。
兩種方法：
（1）利用字典的fromkeys來自動過濾重複值
（2）利用集合set的特性，元素是非重複的
方法一：
方法二：
7、這兩個參數是什麼意思？args和 kwargs。
首先，我想說的是*args和**kwargs並不是必須這樣寫，只有前面的*和**才是必須的。你可以寫成*var和**vars。而寫成*args和**kwargs只是約定俗稱的一個命名規定。
*args和**kwargs主要用於函數定義，你可以將不定量的參數傳遞給一個函數。其中，*args是用來發送一個非鍵值對的可變數量的參數列表給一個函數；**kwargs允許你將不定長度的鍵值對, 作為參數傳遞給一個函數。 如果你想要在一個函數裡處理帶名字的參數, 你應該使用**kwargs。
這裡傳遞了3個參數，按位置傳參，'123'為test傳參，'hello'和'2019'為*args傳參，這裡傳了2個參數。
注意，看下面的*args的另一種用法：用來解壓數據。
這段代碼和上面的效果是一樣的，但是這裡第8行的*args和第1行的*args可是不一樣的。第一行是表示函數可以接受不定數量的非鍵值對的參數，用來傳參使用的。第八行是用來解壓列表
['hello', '2019']的每一項數據的，用來解壓參數的。這是*args的兩種用法，也可說是*的兩種用法，因為args是可變的。
接下來說說**kwargs。
**kwargs用來傳遞帶鍵值對的參數，而**也是用來解壓字典容器內的參數。
總結：
*args和**kwargs都是用於函數中傳遞參數的，*args傳遞的是非鍵值對的參數，**kwargs傳遞的是帶鍵值對的參數，如果還有普通參數需要傳遞，那麼應該先傳遞普通的參數。
8、
（1）統計如下list單詞及其出現的次數。
方法一：
利用字典。
方法二：
利用python的collections包。
前言
之所以在這裡寫下python爬蟲常見面試題及解答，
一是用作筆記，方便日後回憶；
二是給自己一個和大家交流的機會，互相學習、進步，希望不正之處大家能給予指正；
三是我也是互聯網寒潮下崗的那批人之一，為了找工作而做準備。
一、題目部分
1、python中常用的數據結構有哪些？請簡要介紹一下。
python中常見的數據結構有：列表(list)，字典(dict)，元組(tuple)，字符串(string)，集合(set)，數字（int或long或float。。。）等。
其中，列表，元祖和字符串可以統一歸為序列類，即這三種數據結構中的元素是有序的。比如，他們都有索引（下標）操作，還有切片、相加和長度(len)，最大值(max)，最小值(min)操作。這是他們的共同點。
補充：python中常見的數據結構可以統稱為容器（container）。序列（如列表和元組）、映射（如字典）以及集合（set）是三類主要的容器。
另外，關於這個問題，面試官很容易引出另一個問題：python中的哪些數據類型是可變的，哪些是不可變的？
首先，可變/不可變是針對該對象所指向的內存中的值是否可變來判斷的。如可變類型的數據類型有列表和字典，還有集合不可變類型的數據類型有字符串，元組，數字。
就舉個最簡單的數字的例子，python中有小整數池的概念，即[-5,256]範圍內的整數，python解釋器對他們做了特殊處理，都放在內存中的固定位置，不會因為你的操作二發生變化。
現在：a = 1 ，然後我們又重新對a賦值，a = 2，在重新賦值的過程中，整數1所對應的內存地址沒有和數字的大小都沒有發生變化，還在內存中的固定位置。整數2也是如此。變化的是a的指針（這裡引用C中的概念）從指向數字1變成數字2。a對象指向的內存中的值沒有發生變化，因此數字是不可變類型的數據類型。字符串，集合也是同理。
2、簡要描述python中單引號、雙引號、三引號的區別。
首先，單引號和雙引號在使用時基本上沒有什麼區別；
唯一需要注意的是：
當字符串中有單引號時，最好在外面使用雙引號；
當有雙引號時，最好在外面使用單引號。
三引號一般不常用，除了用來做註釋之外，還可以用來打印多行字符串。特殊用途，是可以打印多行字符串。
3、如何在一個function裡設置一個全局的變量。
先說概念，全局變量是指定義在函數外部的變量。全局變量的作用域為全局。
局部變量是指定義在函數內部的變量。局部變量的作用域為函數內，除了函數就無效了。
這裡舉個例子，如果把函數比作國家，那麼全局就是全球，全局變量好比是阿拉伯數字，每個國家都認識。
4、python裡面如何拷貝一個對象？（賦值、淺拷貝、深拷貝的區別）
在python中如何拷貝一個對象是需要根據具體的需求來定的。
（1）賦值：其實就是對象的引用。相當於C的指針，修改了其中一個對象，另一個跟著改變。注意對於不可變對象而言，如果修改了其中一個對象，就相當於修改它的指針指向，另一個對象是不會跟著變化的。
（2）淺拷貝：拷貝父對象，但是不會拷貝父對象的子對象。（具體的方法有：b = copy.copy(a)，切片如b = a[1:4]）
（3）深拷貝：完全拷貝了父對象和子對象（具體的方法有：b = copy.deepcopy(a)）
下面是圖解：
1、b = a: 賦值引用，a 和 b 都指向同一個對象。
2、b = a.copy():淺拷貝, a 和 b 是一個獨立的對象，但他們的子對象還是指向統一對象（是引用）。
3、b = copy.deepcopy(a):深度拷貝, a 和 b 完全拷貝了父對象及其子對象，兩者是完全獨立的。
總結：
（1）當對象為不可變類型時，不論是賦值，淺拷貝還是深拷貝，那麼改變其中一個值時，另一個都是不會跟著變化的。
（2）當對象為可變對象時，如果是賦值和淺拷貝，那麼改變其中任意一個值，那麼另一個會跟著發生變化的；如果是深拷貝，是不會跟著發生改變的。
5、如果custname字符串的編碼格式為uft-8,如何將custname的內容轉化為gb18030的字符串？
先將custname編碼格式轉換為unicode，在轉換為gb18030。即custname.decode('utf-8').encode('gb18030')。
注意：unicode編碼是一種二進制編碼，是轉換編碼的中間橋樑。比如需要將utf-8轉換為gbk，那麼就需要先轉換為unicode（decode），再轉為gbk（encode）。
6、請寫出一段python代碼實現刪除list中的重複元素。
兩種方法：
（1）利用字典的fromkeys來自動過濾重複值
（2）利用集合set的特性，元素是非重複的
方法一：
方法二：
7、這兩個參數是什麼意思？args和 kwargs。
首先，我想說的是*args和**kwargs並不是必須這樣寫，只有前面的*和**才是必須的。你可以寫成*var和**vars。而寫成*args和**kwargs只是約定俗稱的一個命名規定。
*args和**kwargs主要用於函數定義，你可以將不定量的參數傳遞給一個函數。其中，*args是用來發送一個非鍵值對的可變數量的參數列表給一個函數；**kwargs允許你將不定長度的鍵值對, 作為參數傳遞給一個函數。 如果你想要在一個函數裡處理帶名字的參數, 你應該使用**kwargs。
這裡傳遞了3個參數，按位置傳參，'123'為test傳參，'hello'和'2019'為*args傳參，這裡傳了2個參數。
注意，看下面的*args的另一種用法：用來解壓數據。
這段代碼和上面的效果是一樣的，但是這裡第8行的*args和第1行的*args可是不一樣的。第一行是表示函數可以接受不定數量的非鍵值對的參數，用來傳參使用的。第八行是用來解壓列表
['hello', '2019']的每一項數據的，用來解壓參數的。這是*args的兩種用法，也可說是*的兩種用法，因為args是可變的。
接下來說說**kwargs。
**kwargs用來傳遞帶鍵值對的參數，而**也是用來解壓字典容器內的參數。
總結：
*args和**kwargs都是用於函數中傳遞參數的，*args傳遞的是非鍵值對的參數，**kwargs傳遞的是帶鍵值對的參數，如果還有普通參數需要傳遞，那麼應該先傳遞普通的參數。
8、
（1）統計如下list單詞及其出現的次數。
方法一：
利用字典。
方法二：
利用python的collections包。
（2）給列表中的字典排序：例如有如下list對象：
前言
之所以在這裡寫下python爬蟲常見面試題及解答，
一是用作筆記，方便日後回憶；
二是給自己一個和大家交流的機會，互相學習、進步，希望不正之處大家能給予指正；
三是我也是互聯網寒潮下崗的那批人之一，為了找工作而做準備。
一、題目部分
1、python中常用的數據結構有哪些？請簡要介紹一下。
python中常見的數據結構有：列表(list)，字典(dict)，元組(tuple)，字符串(string)，集合(set)，數字（int或long或float。。。）等。
其中，列表，元祖和字符串可以統一歸為序列類，即這三種數據結構中的元素是有序的。比如，他們都有索引（下標）操作，還有切片、相加和長度(len)，最大值(max)，最小值(min)操作。這是他們的共同點。
補充：python中常見的數據結構可以統稱為容器（container）。序列（如列表和元組）、映射（如字典）以及集合（set）是三類主要的容器。
另外，關於這個問題，面試官很容易引出另一個問題：python中的哪些數據類型是可變的，哪些是不可變的？
首先，可變/不可變是針對該對象所指向的內存中的值是否可變來判斷的。如可變類型的數據類型有列表和字典，還有集合不可變類型的數據類型有字符串，元組，數字。
就舉個最簡單的數字的例子，python中有小整數池的概念，即[-5,256]範圍內的整數，python解釋器對他們做了特殊處理，都放在內存中的固定位置，不會因為你的操作二發生變化。
現在：a = 1 ，然後我們又重新對a賦值，a = 2，在重新賦值的過程中，整數1所對應的內存地址沒有和數字的大小都沒有發生變化，還在內存中的固定位置。整數2也是如此。變化的是a的指針（這裡引用C中的概念）從指向數字1變成數字2。a對象指向的內存中的值沒有發生變化，因此數字是不可變類型的數據類型。字符串，集合也是同理。
2、簡要描述python中單引號、雙引號、三引號的區別。
首先，單引號和雙引號在使用時基本上沒有什麼區別；
唯一需要注意的是：
當字符串中有單引號時，最好在外面使用雙引號；
當有雙引號時，最好在外面使用單引號。
三引號一般不常用，除了用來做註釋之外，還可以用來打印多行字符串。特殊用途，是可以打印多行字符串。
3、如何在一個function裡設置一個全局的變量。
先說概念，全局變量是指定義在函數外部的變量。全局變量的作用域為全局。
局部變量是指定義在函數內部的變量。局部變量的作用域為函數內，除了函數就無效了。
這裡舉個例子，如果把函數比作國家，那麼全局就是全球，全局變量好比是阿拉伯數字，每個國家都認識。
4、python裡面如何拷貝一個對象？（賦值、淺拷貝、深拷貝的區別）
在python中如何拷貝一個對象是需要根據具體的需求來定的。
（1）賦值：其實就是對象的引用。相當於C的指針，修改了其中一個對象，另一個跟著改變。注意對於不可變對象而言，如果修改了其中一個對象，就相當於修改它的指針指向，另一個對象是不會跟著變化的。
（2）淺拷貝：拷貝父對象，但是不會拷貝父對象的子對象。（具體的方法有：b = copy.copy(a)，切片如b = a[1:4]）
（3）深拷貝：完全拷貝了父對象和子對象（具體的方法有：b = copy.deepcopy(a)）
下面是圖解：
1、b = a: 賦值引用，a 和 b 都指向同一個對象。
2、b = a.copy():淺拷貝, a 和 b 是一個獨立的對象，但他們的子對象還是指向統一對象（是引用）。
3、b = copy.deepcopy(a):深度拷貝, a 和 b 完全拷貝了父對象及其子對象，兩者是完全獨立的。
總結：
（1）當對象為不可變類型時，不論是賦值，淺拷貝還是深拷貝，那麼改變其中一個值時，另一個都是不會跟著變化的。
（2）當對象為可變對象時，如果是賦值和淺拷貝，那麼改變其中任意一個值，那麼另一個會跟著發生變化的；如果是深拷貝，是不會跟著發生改變的。
5、如果custname字符串的編碼格式為uft-8,如何將custname的內容轉化為gb18030的字符串？
先將custname編碼格式轉換為unicode，在轉換為gb18030。即custname.decode('utf-8').encode('gb18030')。
注意：unicode編碼是一種二進制編碼，是轉換編碼的中間橋樑。比如需要將utf-8轉換為gbk，那麼就需要先轉換為unicode（decode），再轉為gbk（encode）。
6、請寫出一段python代碼實現刪除list中的重複元素。
兩種方法：
（1）利用字典的fromkeys來自動過濾重複值
（2）利用集合set的特性，元素是非重複的
方法一：
方法二：
7、這兩個參數是什麼意思？args和 kwargs。
首先，我想說的是*args和**kwargs並不是必須這樣寫，只有前面的*和**才是必須的。你可以寫成*var和**vars。而寫成*args和**kwargs只是約定俗稱的一個命名規定。
*args和**kwargs主要用於函數定義，你可以將不定量的參數傳遞給一個函數。其中，*args是用來發送一個非鍵值對的可變數量的參數列表給一個函數；**kwargs允許你將不定長度的鍵值對, 作為參數傳遞給一個函數。 如果你想要在一個函數裡處理帶名字的參數, 你應該使用**kwargs。
這裡傳遞了3個參數，按位置傳參，'123'為test傳參，'hello'和'2019'為*args傳參，這裡傳了2個參數。
注意，看下面的*args的另一種用法：用來解壓數據。
這段代碼和上面的效果是一樣的，但是這裡第8行的*args和第1行的*args可是不一樣的。第一行是表示函數可以接受不定數量的非鍵值對的參數，用來傳參使用的。第八行是用來解壓列表
['hello', '2019']的每一項數據的，用來解壓參數的。這是*args的兩種用法，也可說是*的兩種用法，因為args是可變的。
接下來說說**kwargs。
**kwargs用來傳遞帶鍵值對的參數，而**也是用來解壓字典容器內的參數。
總結：
*args和**kwargs都是用於函數中傳遞參數的，*args傳遞的是非鍵值對的參數，**kwargs傳遞的是帶鍵值對的參數，如果還有普通參數需要傳遞，那麼應該先傳遞普通的參數。
8、
（1）統計如下list單詞及其出現的次數。
方法一：
利用字典。
方法二：
利用python的collections包。
（2）給列表中的字典排序：例如有如下list對象：
利用list的內建函數，list.sort()來進行排序。
前言
之所以在這裡寫下python爬蟲常見面試題及解答，
一是用作筆記，方便日後回憶；
二是給自己一個和大家交流的機會，互相學習、進步，希望不正之處大家能給予指正；
三是我也是互聯網寒潮下崗的那批人之一，為了找工作而做準備。
一、題目部分
1、python中常用的數據結構有哪些？請簡要介紹一下。
python中常見的數據結構有：列表(list)，字典(dict)，元組(tuple)，字符串(string)，集合(set)，數字（int或long或float。。。）等。
其中，列表，元祖和字符串可以統一歸為序列類，即這三種數據結構中的元素是有序的。比如，他們都有索引（下標）操作，還有切片、相加和長度(len)，最大值(max)，最小值(min)操作。這是他們的共同點。
補充：python中常見的數據結構可以統稱為容器（container）。序列（如列表和元組）、映射（如字典）以及集合（set）是三類主要的容器。
另外，關於這個問題，面試官很容易引出另一個問題：python中的哪些數據類型是可變的，哪些是不可變的？
首先，可變/不可變是針對該對象所指向的內存中的值是否可變來判斷的。如可變類型的數據類型有列表和字典，還有集合不可變類型的數據類型有字符串，元組，數字。
就舉個最簡單的數字的例子，python中有小整數池的概念，即[-5,256]範圍內的整數，python解釋器對他們做了特殊處理，都放在內存中的固定位置，不會因為你的操作二發生變化。
現在：a = 1 ，然後我們又重新對a賦值，a = 2，在重新賦值的過程中，整數1所對應的內存地址沒有和數字的大小都沒有發生變化，還在內存中的固定位置。整數2也是如此。變化的是a的指針（這裡引用C中的概念）從指向數字1變成數字2。a對象指向的內存中的值沒有發生變化，因此數字是不可變類型的數據類型。字符串，集合也是同理。
2、簡要描述python中單引號、雙引號、三引號的區別。
首先，單引號和雙引號在使用時基本上沒有什麼區別；
唯一需要注意的是：
當字符串中有單引號時，最好在外面使用雙引號；
當有雙引號時，最好在外面使用單引號。
三引號一般不常用，除了用來做註釋之外，還可以用來打印多行字符串。特殊用途，是可以打印多行字符串。
3、如何在一個function裡設置一個全局的變量。
先說概念，全局變量是指定義在函數外部的變量。全局變量的作用域為全局。
局部變量是指定義在函數內部的變量。局部變量的作用域為函數內，除了函數就無效了。
這裡舉個例子，如果把函數比作國家，那麼全局就是全球，全局變量好比是阿拉伯數字，每個國家都認識。
4、python裡面如何拷貝一個對象？（賦值、淺拷貝、深拷貝的區別）
在python中如何拷貝一個對象是需要根據具體的需求來定的。
（1）賦值：其實就是對象的引用。相當於C的指針，修改了其中一個對象，另一個跟著改變。注意對於不可變對象而言，如果修改了其中一個對象，就相當於修改它的指針指向，另一個對象是不會跟著變化的。
（2）淺拷貝：拷貝父對象，但是不會拷貝父對象的子對象。（具體的方法有：b = copy.copy(a)，切片如b = a[1:4]）
（3）深拷貝：完全拷貝了父對象和子對象（具體的方法有：b = copy.deepcopy(a)）
下面是圖解：
1、b = a: 賦值引用，a 和 b 都指向同一個對象。
2、b = a.copy():淺拷貝, a 和 b 是一個獨立的對象，但他們的子對象還是指向統一對象（是引用）。
3、b = copy.deepcopy(a):深度拷貝, a 和 b 完全拷貝了父對象及其子對象，兩者是完全獨立的。
總結：
（1）當對象為不可變類型時，不論是賦值，淺拷貝還是深拷貝，那麼改變其中一個值時，另一個都是不會跟著變化的。
（2）當對象為可變對象時，如果是賦值和淺拷貝，那麼改變其中任意一個值，那麼另一個會跟著發生變化的；如果是深拷貝，是不會跟著發生改變的。
5、如果custname字符串的編碼格式為uft-8,如何將custname的內容轉化為gb18030的字符串？
先將custname編碼格式轉換為unicode，在轉換為gb18030。即custname.decode('utf-8').encode('gb18030')。
注意：unicode編碼是一種二進制編碼，是轉換編碼的中間橋樑。比如需要將utf-8轉換為gbk，那麼就需要先轉換為unicode（decode），再轉為gbk（encode）。
6、請寫出一段python代碼實現刪除list中的重複元素。
兩種方法：
（1）利用字典的fromkeys來自動過濾重複值
（2）利用集合set的特性，元素是非重複的
方法一：
方法二：
7、這兩個參數是什麼意思？args和 kwargs。
首先，我想說的是*args和**kwargs並不是必須這樣寫，只有前面的*和**才是必須的。你可以寫成*var和**vars。而寫成*args和**kwargs只是約定俗稱的一個命名規定。
*args和**kwargs主要用於函數定義，你可以將不定量的參數傳遞給一個函數。其中，*args是用來發送一個非鍵值對的可變數量的參數列表給一個函數；**kwargs允許你將不定長度的鍵值對, 作為參數傳遞給一個函數。 如果你想要在一個函數裡處理帶名字的參數, 你應該使用**kwargs。
這裡傳遞了3個參數，按位置傳參，'123'為test傳參，'hello'和'2019'為*args傳參，這裡傳了2個參數。
注意，看下面的*args的另一種用法：用來解壓數據。
這段代碼和上面的效果是一樣的，但是這裡第8行的*args和第1行的*args可是不一樣的。第一行是表示函數可以接受不定數量的非鍵值對的參數，用來傳參使用的。第八行是用來解壓列表
['hello', '2019']的每一項數據的，用來解壓參數的。這是*args的兩種用法，也可說是*的兩種用法，因為args是可變的。
接下來說說**kwargs。
**kwargs用來傳遞帶鍵值對的參數，而**也是用來解壓字典容器內的參數。
總結：
*args和**kwargs都是用於函數中傳遞參數的，*args傳遞的是非鍵值對的參數，**kwargs傳遞的是帶鍵值對的參數，如果還有普通參數需要傳遞，那麼應該先傳遞普通的參數。
8、
（1）統計如下list單詞及其出現的次數。
方法一：
利用字典。
方法二：
利用python的collections包。
（2）給列表中的字典排序：例如有如下list對象：
利用list的內建函數，list.sort()來進行排序。
（3）寫出下列代碼的運行結果
前言
之所以在這裡寫下python爬蟲常見面試題及解答，
一是用作筆記，方便日後回憶；
二是給自己一個和大家交流的機會，互相學習、進步，希望不正之處大家能給予指正；
三是我也是互聯網寒潮下崗的那批人之一，為了找工作而做準備。
一、題目部分
1、python中常用的數據結構有哪些？請簡要介紹一下。
python中常見的數據結構有：列表(list)，字典(dict)，元組(tuple)，字符串(string)，集合(set)，數字（int或long或float。。。）等。
其中，列表，元祖和字符串可以統一歸為序列類，即這三種數據結構中的元素是有序的。比如，他們都有索引（下標）操作，還有切片、相加和長度(len)，最大值(max)，最小值(min)操作。這是他們的共同點。
補充：python中常見的數據結構可以統稱為容器（container）。序列（如列表和元組）、映射（如字典）以及集合（set）是三類主要的容器。
另外，關於這個問題，面試官很容易引出另一個問題：python中的哪些數據類型是可變的，哪些是不可變的？
首先，可變/不可變是針對該對象所指向的內存中的值是否可變來判斷的。如可變類型的數據類型有列表和字典，還有集合不可變類型的數據類型有字符串，元組，數字。
就舉個最簡單的數字的例子，python中有小整數池的概念，即[-5,256]範圍內的整數，python解釋器對他們做了特殊處理，都放在內存中的固定位置，不會因為你的操作二發生變化。
現在：a = 1 ，然後我們又重新對a賦值，a = 2，在重新賦值的過程中，整數1所對應的內存地址沒有和數字的大小都沒有發生變化，還在內存中的固定位置。整數2也是如此。變化的是a的指針（這裡引用C中的概念）從指向數字1變成數字2。a對象指向的內存中的值沒有發生變化，因此數字是不可變類型的數據類型。字符串，集合也是同理。
2、簡要描述python中單引號、雙引號、三引號的區別。
首先，單引號和雙引號在使用時基本上沒有什麼區別；
唯一需要注意的是：
當字符串中有單引號時，最好在外面使用雙引號；
當有雙引號時，最好在外面使用單引號。
三引號一般不常用，除了用來做註釋之外，還可以用來打印多行字符串。特殊用途，是可以打印多行字符串。
3、如何在一個function裡設置一個全局的變量。
先說概念，全局變量是指定義在函數外部的變量。全局變量的作用域為全局。
局部變量是指定義在函數內部的變量。局部變量的作用域為函數內，除了函數就無效了。
這裡舉個例子，如果把函數比作國家，那麼全局就是全球，全局變量好比是阿拉伯數字，每個國家都認識。
4、python裡面如何拷貝一個對象？（賦值、淺拷貝、深拷貝的區別）
在python中如何拷貝一個對象是需要根據具體的需求來定的。
（1）賦值：其實就是對象的引用。相當於C的指針，修改了其中一個對象，另一個跟著改變。注意對於不可變對象而言，如果修改了其中一個對象，就相當於修改它的指針指向，另一個對象是不會跟著變化的。
（2）淺拷貝：拷貝父對象，但是不會拷貝父對象的子對象。（具體的方法有：b = copy.copy(a)，切片如b = a[1:4]）
（3）深拷貝：完全拷貝了父對象和子對象（具體的方法有：b = copy.deepcopy(a)）
下面是圖解：
1、b = a: 賦值引用，a 和 b 都指向同一個對象。
2、b = a.copy():淺拷貝, a 和 b 是一個獨立的對象，但他們的子對象還是指向統一對象（是引用）。
3、b = copy.deepcopy(a):深度拷貝, a 和 b 完全拷貝了父對象及其子對象，兩者是完全獨立的。
總結：
（1）當對象為不可變類型時，不論是賦值，淺拷貝還是深拷貝，那麼改變其中一個值時，另一個都是不會跟著變化的。
（2）當對象為可變對象時，如果是賦值和淺拷貝，那麼改變其中任意一個值，那麼另一個會跟著發生變化的；如果是深拷貝，是不會跟著發生改變的。
5、如果custname字符串的編碼格式為uft-8,如何將custname的內容轉化為gb18030的字符串？
先將custname編碼格式轉換為unicode，在轉換為gb18030。即custname.decode('utf-8').encode('gb18030')。
注意：unicode編碼是一種二進制編碼，是轉換編碼的中間橋樑。比如需要將utf-8轉換為gbk，那麼就需要先轉換為unicode（decode），再轉為gbk（encode）。
6、請寫出一段python代碼實現刪除list中的重複元素。
兩種方法：
（1）利用字典的fromkeys來自動過濾重複值
（2）利用集合set的特性，元素是非重複的
方法一：
方法二：
7、這兩個參數是什麼意思？args和 kwargs。
首先，我想說的是*args和**kwargs並不是必須這樣寫，只有前面的*和**才是必須的。你可以寫成*var和**vars。而寫成*args和**kwargs只是約定俗稱的一個命名規定。
*args和**kwargs主要用於函數定義，你可以將不定量的參數傳遞給一個函數。其中，*args是用來發送一個非鍵值對的可變數量的參數列表給一個函數；**kwargs允許你將不定長度的鍵值對, 作為參數傳遞給一個函數。 如果你想要在一個函數裡處理帶名字的參數, 你應該使用**kwargs。
這裡傳遞了3個參數，按位置傳參，'123'為test傳參，'hello'和'2019'為*args傳參，這裡傳了2個參數。
注意，看下面的*args的另一種用法：用來解壓數據。
這段代碼和上面的效果是一樣的，但是這裡第8行的*args和第1行的*args可是不一樣的。第一行是表示函數可以接受不定數量的非鍵值對的參數，用來傳參使用的。第八行是用來解壓列表
['hello', '2019']的每一項數據的，用來解壓參數的。這是*args的兩種用法，也可說是*的兩種用法，因為args是可變的。
接下來說說**kwargs。
**kwargs用來傳遞帶鍵值對的參數，而**也是用來解壓字典容器內的參數。
總結：
*args和**kwargs都是用於函數中傳遞參數的，*args傳遞的是非鍵值對的參數，**kwargs傳遞的是帶鍵值對的參數，如果還有普通參數需要傳遞，那麼應該先傳遞普通的參數。
8、
（1）統計如下list單詞及其出現的次數。
方法一：
利用字典。
方法二：
利用python的collections包。
（2）給列表中的字典排序：例如有如下list對象：
利用list的內建函數，list.sort()來進行排序。
（3）寫出下列代碼的運行結果
第一段代碼的運行結果為：1
分析，在函數外面定義了一個全局變量a為1，在函數內部定義了一個局部變量a為2。局部變量在離開函數後就失效了。
所以，結果為全局變量的a的值。如果在a=2之前加上global a，聲明為全局變量，那麼結果為2。
第二段代碼的運行結果為：[1]
這是因為，將a傳入到function中，這相當於對a進行賦值引用。由於a是可變類型的，所以在函數內部修改a的時候，外部的全局變量a也跟著變化。
第三段代碼的運行結果為：
Bob
Lily
Lily
最後小編為大家準備了一些python的學習教程分享，希望可以幫助到大家。
前言
之所以在這裡寫下python爬蟲常見面試題及解答，
一是用作筆記，方便日後回憶；
二是給自己一個和大家交流的機會，互相學習、進步，希望不正之處大家能給予指正；
三是我也是互聯網寒潮下崗的那批人之一，為了找工作而做準備。
一、題目部分
1、python中常用的數據結構有哪些？請簡要介紹一下。
python中常見的數據結構有：列表(list)，字典(dict)，元組(tuple)，字符串(string)，集合(set)，數字（int或long或float。。。）等。
其中，列表，元祖和字符串可以統一歸為序列類，即這三種數據結構中的元素是有序的。比如，他們都有索引（下標）操作，還有切片、相加和長度(len)，最大值(max)，最小值(min)操作。這是他們的共同點。
補充：python中常見的數據結構可以統稱為容器（container）。序列（如列表和元組）、映射（如字典）以及集合（set）是三類主要的容器。
另外，關於這個問題，面試官很容易引出另一個問題：python中的哪些數據類型是可變的，哪些是不可變的？
首先，可變/不可變是針對該對象所指向的內存中的值是否可變來判斷的。如可變類型的數據類型有列表和字典，還有集合不可變類型的數據類型有字符串，元組，數字。
就舉個最簡單的數字的例子，python中有小整數池的概念，即[-5,256]範圍內的整數，python解釋器對他們做了特殊處理，都放在內存中的固定位置，不會因為你的操作二發生變化。
現在：a = 1 ，然後我們又重新對a賦值，a = 2，在重新賦值的過程中，整數1所對應的內存地址沒有和數字的大小都沒有發生變化，還在內存中的固定位置。整數2也是如此。變化的是a的指針（這裡引用C中的概念）從指向數字1變成數字2。a對象指向的內存中的值沒有發生變化，因此數字是不可變類型的數據類型。字符串，集合也是同理。
2、簡要描述python中單引號、雙引號、三引號的區別。
首先，單引號和雙引號在使用時基本上沒有什麼區別；
唯一需要注意的是：
當字符串中有單引號時，最好在外面使用雙引號；
當有雙引號時，最好在外面使用單引號。
三引號一般不常用，除了用來做註釋之外，還可以用來打印多行字符串。特殊用途，是可以打印多行字符串。
3、如何在一個function裡設置一個全局的變量。
先說概念，全局變量是指定義在函數外部的變量。全局變量的作用域為全局。
局部變量是指定義在函數內部的變量。局部變量的作用域為函數內，除了函數就無效了。
這裡舉個例子，如果把函數比作國家，那麼全局就是全球，全局變量好比是阿拉伯數字，每個國家都認識。
4、python裡面如何拷貝一個對象？（賦值、淺拷貝、深拷貝的區別）
在python中如何拷貝一個對象是需要根據具體的需求來定的。
（1）賦值：其實就是對象的引用。相當於C的指針，修改了其中一個對象，另一個跟著改變。注意對於不可變對象而言，如果修改了其中一個對象，就相當於修改它的指針指向，另一個對象是不會跟著變化的。
（2）淺拷貝：拷貝父對象，但是不會拷貝父對象的子對象。（具體的方法有：b = copy.copy(a)，切片如b = a[1:4]）
（3）深拷貝：完全拷貝了父對象和子對象（具體的方法有：b = copy.deepcopy(a)）
下面是圖解：
1、b = a: 賦值引用，a 和 b 都指向同一個對象。
2、b = a.copy():淺拷貝, a 和 b 是一個獨立的對象，但他們的子對象還是指向統一對象（是引用）。
3、b = copy.deepcopy(a):深度拷貝, a 和 b 完全拷貝了父對象及其子對象，兩者是完全獨立的。
總結：
（1）當對象為不可變類型時，不論是賦值，淺拷貝還是深拷貝，那麼改變其中一個值時，另一個都是不會跟著變化的。
（2）當對象為可變對象時，如果是賦值和淺拷貝，那麼改變其中任意一個值，那麼另一個會跟著發生變化的；如果是深拷貝，是不會跟著發生改變的。
5、如果custname字符串的編碼格式為uft-8,如何將custname的內容轉化為gb18030的字符串？
先將custname編碼格式轉換為unicode，在轉換為gb18030。即custname.decode('utf-8').encode('gb18030')。
注意：unicode編碼是一種二進制編碼，是轉換編碼的中間橋樑。比如需要將utf-8轉換為gbk，那麼就需要先轉換為unicode（decode），再轉為gbk（encode）。
6、請寫出一段python代碼實現刪除list中的重複元素。
兩種方法：
（1）利用字典的fromkeys來自動過濾重複值
（2）利用集合set的特性，元素是非重複的
方法一：
方法二：
7、這兩個參數是什麼意思？args和 kwargs。
首先，我想說的是*args和**kwargs並不是必須這樣寫，只有前面的*和**才是必須的。你可以寫成*var和**vars。而寫成*args和**kwargs只是約定俗稱的一個命名規定。
*args和**kwargs主要用於函數定義，你可以將不定量的參數傳遞給一個函數。其中，*args是用來發送一個非鍵值對的可變數量的參數列表給一個函數；**kwargs允許你將不定長度的鍵值對, 作為參數傳遞給一個函數。 如果你想要在一個函數裡處理帶名字的參數, 你應該使用**kwargs。
這裡傳遞了3個參數，按位置傳參，'123'為test傳參，'hello'和'2019'為*args傳參，這裡傳了2個參數。
注意，看下面的*args的另一種用法：用來解壓數據。
這段代碼和上面的效果是一樣的，但是這裡第8行的*args和第1行的*args可是不一樣的。第一行是表示函數可以接受不定數量的非鍵值對的參數，用來傳參使用的。第八行是用來解壓列表
['hello', '2019']的每一項數據的，用來解壓參數的。這是*args的兩種用法，也可說是*的兩種用法，因為args是可變的。
接下來說說**kwargs。
**kwargs用來傳遞帶鍵值對的參數，而**也是用來解壓字典容器內的參數。
總結：
*args和**kwargs都是用於函數中傳遞參數的，*args傳遞的是非鍵值對的參數，**kwargs傳遞的是帶鍵值對的參數，如果還有普通參數需要傳遞，那麼應該先傳遞普通的參數。
8、
（1）統計如下list單詞及其出現的次數。
方法一：
利用字典。
方法二：
利用python的collections包。
（2）給列表中的字典排序：例如有如下list對象：
利用list的內建函數，list.sort()來進行排序。
（3）寫出下列代碼的運行結果
第一段代碼的運行結果為：1
分析，在函數外面定義了一個全局變量a為1，在函數內部定義了一個局部變量a為2。局部變量在離開函數後就失效了。
所以，結果為全局變量的a的值。如果在a=2之前加上global a，聲明為全局變量，那麼結果為2。
第二段代碼的運行結果為：[1]
這是因為，將a傳入到function中，這相當於對a進行賦值引用。由於a是可變類型的，所以在函數內部修改a的時候，外部的全局變量a也跟著變化。
第三段代碼的運行結果為：
Bob
Lily
Lily
最後小編為大家準備了一些python的學習教程分享，希望可以幫助到大家。
前言
之所以在這裡寫下python爬蟲常見面試題及解答，
一是用作筆記，方便日後回憶；
二是給自己一個和大家交流的機會，互相學習、進步，希望不正之處大家能給予指正；
三是我也是互聯網寒潮下崗的那批人之一，為了找工作而做準備。
一、題目部分
1、python中常用的數據結構有哪些？請簡要介紹一下。
python中常見的數據結構有：列表(list)，字典(dict)，元組(tuple)，字符串(string)，集合(set)，數字（int或long或float。。。）等。
其中，列表，元祖和字符串可以統一歸為序列類，即這三種數據結構中的元素是有序的。比如，他們都有索引（下標）操作，還有切片、相加和長度(len)，最大值(max)，最小值(min)操作。這是他們的共同點。
補充：python中常見的數據結構可以統稱為容器（container）。序列（如列表和元組）、映射（如字典）以及集合（set）是三類主要的容器。
另外，關於這個問題，面試官很容易引出另一個問題：python中的哪些數據類型是可變的，哪些是不可變的？
首先，可變/不可變是針對該對象所指向的內存中的值是否可變來判斷的。如可變類型的數據類型有列表和字典，還有集合不可變類型的數據類型有字符串，元組，數字。
就舉個最簡單的數字的例子，python中有小整數池的概念，即[-5,256]範圍內的整數，python解釋器對他們做了特殊處理，都放在內存中的固定位置，不會因為你的操作二發生變化。
現在：a = 1 ，然後我們又重新對a賦值，a = 2，在重新賦值的過程中，整數1所對應的內存地址沒有和數字的大小都沒有發生變化，還在內存中的固定位置。整數2也是如此。變化的是a的指針（這裡引用C中的概念）從指向數字1變成數字2。a對象指向的內存中的值沒有發生變化，因此數字是不可變類型的數據類型。字符串，集合也是同理。
2、簡要描述python中單引號、雙引號、三引號的區別。
首先，單引號和雙引號在使用時基本上沒有什麼區別；
唯一需要注意的是：
當字符串中有單引號時，最好在外面使用雙引號；
當有雙引號時，最好在外面使用單引號。
三引號一般不常用，除了用來做註釋之外，還可以用來打印多行字符串。特殊用途，是可以打印多行字符串。
3、如何在一個function裡設置一個全局的變量。
先說概念，全局變量是指定義在函數外部的變量。全局變量的作用域為全局。
局部變量是指定義在函數內部的變量。局部變量的作用域為函數內，除了函數就無效了。
這裡舉個例子，如果把函數比作國家，那麼全局就是全球，全局變量好比是阿拉伯數字，每個國家都認識。
4、python裡面如何拷貝一個對象？（賦值、淺拷貝、深拷貝的區別）
在python中如何拷貝一個對象是需要根據具體的需求來定的。
（1）賦值：其實就是對象的引用。相當於C的指針，修改了其中一個對象，另一個跟著改變。注意對於不可變對象而言，如果修改了其中一個對象，就相當於修改它的指針指向，另一個對象是不會跟著變化的。
（2）淺拷貝：拷貝父對象，但是不會拷貝父對象的子對象。（具體的方法有：b = copy.copy(a)，切片如b = a[1:4]）
（3）深拷貝：完全拷貝了父對象和子對象（具體的方法有：b = copy.deepcopy(a)）
下面是圖解：
1、b = a: 賦值引用，a 和 b 都指向同一個對象。
2、b = a.copy():淺拷貝, a 和 b 是一個獨立的對象，但他們的子對象還是指向統一對象（是引用）。
3、b = copy.deepcopy(a):深度拷貝, a 和 b 完全拷貝了父對象及其子對象，兩者是完全獨立的。
總結：
（1）當對象為不可變類型時，不論是賦值，淺拷貝還是深拷貝，那麼改變其中一個值時，另一個都是不會跟著變化的。
（2）當對象為可變對象時，如果是賦值和淺拷貝，那麼改變其中任意一個值，那麼另一個會跟著發生變化的；如果是深拷貝，是不會跟著發生改變的。
5、如果custname字符串的編碼格式為uft-8,如何將custname的內容轉化為gb18030的字符串？
先將custname編碼格式轉換為unicode，在轉換為gb18030。即custname.decode('utf-8').encode('gb18030')。
注意：unicode編碼是一種二進制編碼，是轉換編碼的中間橋樑。比如需要將utf-8轉換為gbk，那麼就需要先轉換為unicode（decode），再轉為gbk（encode）。
6、請寫出一段python代碼實現刪除list中的重複元素。
兩種方法：
（1）利用字典的fromkeys來自動過濾重複值
（2）利用集合set的特性，元素是非重複的
方法一：
方法二：
7、這兩個參數是什麼意思？args和 kwargs。
首先，我想說的是*args和**kwargs並不是必須這樣寫，只有前面的*和**才是必須的。你可以寫成*var和**vars。而寫成*args和**kwargs只是約定俗稱的一個命名規定。
*args和**kwargs主要用於函數定義，你可以將不定量的參數傳遞給一個函數。其中，*args是用來發送一個非鍵值對的可變數量的參數列表給一個函數；**kwargs允許你將不定長度的鍵值對, 作為參數傳遞給一個函數。 如果你想要在一個函數裡處理帶名字的參數, 你應該使用**kwargs。
這裡傳遞了3個參數，按位置傳參，'123'為test傳參，'hello'和'2019'為*args傳參，這裡傳了2個參數。
注意，看下面的*args的另一種用法：用來解壓數據。
這段代碼和上面的效果是一樣的，但是這裡第8行的*args和第1行的*args可是不一樣的。第一行是表示函數可以接受不定數量的非鍵值對的參數，用來傳參使用的。第八行是用來解壓列表
['hello', '2019']的每一項數據的，用來解壓參數的。這是*args的兩種用法，也可說是*的兩種用法，因為args是可變的。
接下來說說**kwargs。
**kwargs用來傳遞帶鍵值對的參數，而**也是用來解壓字典容器內的參數。
總結：
*args和**kwargs都是用於函數中傳遞參數的，*args傳遞的是非鍵值對的參數，**kwargs傳遞的是帶鍵值對的參數，如果還有普通參數需要傳遞，那麼應該先傳遞普通的參數。
8、
（1）統計如下list單詞及其出現的次數。
方法一：
利用字典。
方法二：
利用python的collections包。
（2）給列表中的字典排序：例如有如下list對象：
利用list的內建函數，list.sort()來進行排序。
（3）寫出下列代碼的運行結果
第一段代碼的運行結果為：1
分析，在函數外面定義了一個全局變量a為1，在函數內部定義了一個局部變量a為2。局部變量在離開函數後就失效了。
所以，結果為全局變量的a的值。如果在a=2之前加上global a，聲明為全局變量，那麼結果為2。
第二段代碼的運行結果為：[1]
這是因為，將a傳入到function中，這相當於對a進行賦值引用。由於a是可變類型的，所以在函數內部修改a的時候，外部的全局變量a也跟著變化。
第三段代碼的運行結果為：
Bob
Lily
Lily