在編寫程式的時候,如果想要**改變(重新賦值)**函數外部的變數,並且這個變數會作用於許多函數中,就需要告訴 Python 程式這個變數的作用域是全局變數,global 語句可以實現定義全局變數的作用。 ...
- Python global 語句的作用
- lambda 匿名函數好處
- Python 錯誤處理
- Python 內置錯誤類型
- 簡述 any() 和 all() 方法
- Python 中什麼元素為假?
- 提高 Python 運行效率的方法
- Python 單例模式
- 為什麼 Python 不提供函數重載
- 實例方法/靜態方法/類方法
- __new__和 __init __方法的區別
- Python 的函數參數傳遞
- Python 實現對函參做類型檢查
- 為什麼說 Python 是動態語言
- Python 裝飾器理解
- map 與 reduce 函數用法解釋
- Python 深拷貝、淺拷貝區別
- Python 繼承多態理解
- Python 面向對象的原則
- 參考資料
Python global 語句的作用
在編寫程式的時候,如果想要改變(重新賦值)函數外部的變數,並且這個變數會作用於許多函數中,就需要告訴 Python 程式這個變數的作用域是全局變數,global
語句可以實現定義全局變數的作用。
lambda 匿名函數好處
精簡代碼,lambda
省去了定義函數,map
省去了寫 for
迴圈過程:
str_1 = ["中國", "美國", "法國", "", "", "英國"]
res = list(map(lambda x: "填充值" if x=="" else x, str_1))
print(res) # ['中國', '美國', '法國', '填充值', '填充值', '英國']
Python 錯誤處理
和其他高級語言一樣,Python
也內置了一套try...except...finally...
的錯誤處理機制。
當我們認為某些代碼可能會出錯時,就可以用 try
來運行這段代碼,如果執行出錯,則後續代碼不會繼續執行,而是直接跳轉至跳轉至錯誤處理代碼,即 except
語句塊,執行完 except
後,如果有 finally
語句塊,則執行。至此,執行完畢。跳轉至錯誤處理代碼,
Python 內置錯誤類型
IOError
:輸入輸出異常AttributeError
:試圖訪問一個對象沒有的屬性ImportError
:無法引入模塊或包,基本是路徑問題IndentationError
:語法錯誤,代碼沒有正確的對齊IndexError
:下標索引超出序列邊界KeyError
: 試圖訪問你字典里不存在的鍵SyntaxError
: Python 代碼邏輯語法出錯,不能執行NameError
: 使用一個還未賦予對象的變數
簡述 any() 和 all() 方法
any()
: 只要迭代器中有一個元素為真就為真;all()
: 迭代器中所有的判斷項返回都是真,結果才為真.
Python 中什麼元素為假?
答案:(0,空字元串,空列表、空字典、空元組、None, False)
提高 Python 運行效率的方法
- 使用生成器,因為可以節約大量記憶體;
- 迴圈代碼優化,避免過多重覆代碼的執行;
- 核心模塊用
Cython PyPy
等,提高效率; - 多進程、多線程、協程;
- 多個
if elif
條件判斷,可以把最有可能先發生的條件放到前面寫,這樣可以減少程式判斷的次數,提高效率。
Python 單例模式
為什麼 Python 不提供函數重載
我們知道 函數重載
主要是為瞭解決兩個問題。
- 可變參數類型。
- 可變參數個數。
另外,一個函數重載基本的設計原則是,僅僅當兩個函數除了參數類型和參數個數不同以外,其功能是完全相同的,此時才使用函數重載,如果兩個函數的功能其實不同,那麼不應當使用重載,而應當使用一個名字不同的函數。
- 對於情況 1 ,函數功能相同,但是參數類型不同,Python 如何處理?答案是根本不需要處理,因為
Python
可以接受任何類型的參數,如果函數的功能相同,那麼不同的參數類型在 Python 中很可能是相同的代碼,沒有必要做成兩個不同函數。 - 對於情況 2 ,函數功能相同,但參數個數不同,Python 如何處理?大家知道,答案就是預設參數(預設參數)。對那些缺少的參數設定為預設參數(預設參數)即可解決問題。因為你假設函數功能相同,那麼那些缺少的參數終歸是需要用的。所以,鑒於情況 1 跟 情況 2 都有瞭解決方案,Python 自然就不需要函數重載了。
實例方法/靜態方法/類方法
Python
類語法中有三種方法,實例方法,靜態方法,類方法,它們的區別如下:
- 實例方法只能被實例對象調用,靜態方法(由
@staticmethod
裝飾器來聲明)、類方法(由@classmethod
裝飾器來聲明),可以被類或類的實例對象調用; 實例方法
,第一個參數必須要預設傳實例對象,一般習慣用self。靜態方法
,參數沒有要求。類方法
,第一個參數必須要預設傳類,一般習慣用cls
.
實例代碼如下:
class Foo(object):
"""類三種方法語法形式
"""
def instance_method(self):
print("是類{}的實例方法,只能被實例對象調用".format(Foo))
@staticmethod
def static_method():
print("是靜態方法")
@classmethod
def class_method(cls):
print("是類方法")
foo = Foo()
foo.instance_method()
foo.static_method()
foo.class_method()
print('##############')
Foo.static_method()
Foo.class_method()
程式執行後輸出如下:
是類 <class 'main.Foo'> 的實例方法,只能被實例對象調用
是靜態方法
是類方法
##############
是靜態方法
是類方法
__new__和 __init __方法的區別
__init__
方法並不是真正意義上的構造函數,__new__
方法才是(類的構造函數是類的一種特殊的成員函數,它會在每次創建類的新對象時執行);__new__
方法用於創建對象並返回對象,當返回對象時會自動調用__init__
方法進行初始化,__new__
方法比__init__
方法更早執行;__new__
方法是靜態方法,而__init__
是實例方法。
Python 的函數參數傳遞
參考這兩個鏈接,stackoverflow的最高贊那個講得很詳細
How do I pass a variable by reference?
Python 面試題
個人總結(有點不好):
- 將可變對象:列表list、字典dict、NumPy數組ndarray和用戶定義的類型(類),作為參數傳遞給函數,函數內部將其改變後,函數外部這個變數也會改變(對變數進行重新賦值除外
rebind the reference in the method
) - 將不可變對象:字元串string、元組tuple、數值numbers,作為參數傳遞給函數,函數內部將其改變後,函數外部這個變數不會改變
Python 實現對函參做類型檢查
Python
自帶的函數一般都會有對函數參數類型做檢查,自定義的函數參數類型檢查可以用函數 isinstance()
實現,例如:
def my_abs(x):
"""
自定義的絕對值函數
:param x: int or float
:return: positive number, int or float
"""
if not isinstance(x, (int, float)):
raise TypeError('bad operand type')
if x > 0:
return x
else:
return -x
添加了參數檢查後,如果傳入錯誤的參數類型,函數就可以拋出一個 TypeError
錯誤。
為什麼說 Python 是動態語言
在 Python
中,等號 =
是賦值語句,可以把任意數據類型
賦值給變數,同樣一個變數可以反覆賦值,而且可以是不同類型的變數,例如:
a = 100 # a是int型變數
print(a)
a = 'ABC' # a 是str型變數
print(a)
Pyhon 這種變數本身類型不固定,可以反覆賦值不同類型的變數稱為動態語言,與之對應的是靜態語言。靜態語言在定義變數時必須指定變數類型,如果賦值的時候類型不匹配,就會報錯,Java/C++ 都是靜態語言(int a; a = 100
)
Python 裝飾器理解
裝飾器本質上是一個 Python 函數或類,它可以讓其他函數或類在不需要做任何代碼修改的前提下增加額外功能,裝飾器的返回值也是一個函數/類對象。它經常用於有切麵需求的場景,比如:插入日誌、性能測試、事務處理、緩存、許可權校驗等場景,裝飾器是解決這類問題的絕佳設計。有了裝飾器,我們就可以抽離出大量與函數功能本身無關的雷同代碼到裝飾器中並繼續重用。概括的講,裝飾器的作用就是為已經存在的對象添加額外的功能。
map 與 reduce 函數用法解釋
1、map()
函數接收兩個參數,一個是函數,一個是 Iterable,map 將傳入的函數依次作用到序列的每個元素,並將結果作為新的 Iterator 返回,簡單示例代碼如下:
# 示例1
def square(x):
return x ** 2
r = map(square, [1, 2, 3, 4, 5, 6, 7])
squareed_list = list(r)
print(squareed_list) # [1, 4, 9, 16, 25, 36, 49]
# 使用lambda匿名函數簡化為一行代碼
list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
# 示例2
list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9])) # ['1', '2', '3', '4', '5', '6', '7', '8', '9']
註意map函數返回的是一個Iterator(惰性序列),要通過list函數轉化為常用列表結構。map()作為高階函數,事實上它是把運算規則抽象了。
2、reduce()
函數也接受兩個參數,一個是函數(兩個參數),一個是序列,與 map
不同的是reduce 把結果繼續和序列的下一個元素做累積計算,效果如下:
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
示例代碼如下:
from functools import reduce
CHAR_TO_INT = {
'0': 0,
'1': 1,
'2': 2,
'3': 3,
'4': 4,
'5': 5,
'6': 6,
'7': 7,
'8': 8,
'9': 9
}
def str2int(str):
ints = map(lambda x:CHAR_TO_INT[x], str) # str對象是Iterable對象
return reduce(lambda x,y:10*x + y, ints)
print(str2int('0'))
print(str2int('12300'))
print(str2int('0012345')) # 0012345
Python 深拷貝、淺拷貝區別
Python 中的大多數對象,比如列表
list
、字典dict
、集合set
、numpy
數組,和用戶定義的類型(類),都是可變的。意味著這些對象或包含的值可以被修改。但也有些對象是不可變的,例如數值型int
、字元串型str
和元組tuple
。
1、複製不可變數據類型:
複製不可變數據類型,不管 copy
還是 deepcopy
, 都是同一個地址。當淺複製的值是不可變對象(數值,字元串,元組)時和=“賦值”的情況一樣,對象的 id
值與淺複製原來的值相同。
2、複製可變數據類型:
- 直接賦值:其實就是對象的引用(別名)。
- 淺拷貝(
copy
):拷貝父對象,不會拷貝對象內部的子對象(拷貝可以理解為創建記憶體)。產生淺拷貝的操作有以下幾種:- 使用切片
[:]
操作 - 使用工廠函數(如
list/dir/set
), 工廠函數看上去像函數,實質上是類,調用時實際上是生成了該類型的一個實例,就像工廠生產貨物一樣. - 使用
copy
模塊中的copy()
函數,b = a.copy()
,a
和b
是一個獨立的對象,但他們的子對象還是指向統一對象(是引用)。
- 使用切片
- 深拷貝(
deepcopy
): copy 模塊的deepcopy()
方法,完全拷貝了父對象及其子對象,兩者是完全獨立的。深拷貝,包含對象裡面的子對象的拷貝,所以原始對象的改變不會造成深拷貝里任何子元素的改變。
註意:淺拷貝和深拷貝的不同僅僅是對組合對象來說,所謂的組合對象(容器)就是包含了其它對象的對象,如列表,類實例。而對於數字、字元串以及其它“原子”類型(沒有子對象),沒有拷貝一說,產生的都是原對象的引用。更清晰易懂的理解,可以參考這篇文章。
看一個示常式序,就能明白淺拷貝與深拷貝的區別了:
#!/usr/bin/Python3
# -*-coding:utf-8 -*-
import copy
a = [1, 2, 3, ['a', 'b', 'c']]
b = a # 賦值,傳對象的引用
c = copy.copy(a) # 淺拷貝
d = copy.deepcopy(a) # 深拷貝
a.append(4)
a[3].append('d')
print(id(a), id(b), id(c), id(d)) # a 與 b 的記憶體地址相同
print('a = ', a)
print('b = ', b)
print('c = ', c)
print('d = ', d) # [1, 2, 3, ['a', 'b', 'c']]
程式輸出如下:
2061915781832 2061915781832 2061932431304 2061932811400
a = [1, 2, 3, ['a', 'b', 'c', 'd'], 4]
b = [1, 2, 3, ['a', 'b', 'c', 'd'], 4]
c = [1, 2, 3, ['a', 'b', 'c', 'd']]
d = [1, 2, 3, ['a', 'b', 'c']]
Python 繼承多態理解
- 多態是指對不同類型的變數進行相同的操作,它會根據對象(或類)類型的不同而表現出不同的行為。
- 繼承可以拿到父類的所有數據和方法,子類可以重寫父類的方法,也可以新增自己特有的方法。
- 先有繼承,後有多態,不同類的對象對同一消息會作出不同的相應。