Python技術討論與筆記

魔術方法的樣子，兩個底下線+方法名稱+兩底下線

__魔術方法 __

為何需要魔術方法 ?

從應用上來看會發現，魔術方法與其他一般自定義方法的成效幾乎一樣，那為何還需要用這麼麻煩的方式命名?

此段說明參照

They’re mostly used for code that gets called implicitly when special syntax is used.

主要用於特殊語法時隱性調用的代碼

常用於以下場景

• overloaded operators
  (exist in C++ and others) 重載運算符（存在於 C++ 和其他中）
• constructor/destructor
  構造函數/析構函數
• hooks for accessing attributes
  用於訪問屬性
• tools for metaprogramming
  元程式等級操作

以及其他很多地方。

魔術函式別於一般自訂函數主要原因仍在於需要建立最初始的python必須做出最基礎的函式。

這些函式要能與上層C語言互動或者其他程式語言參照，同時也能與一般自定義函數做出最根本的區別。

所以絕大部分的魔術方法幾乎都是內建，除非程式需要動到整個python框架等級的操作，否則我們使用的魔術方法幾乎都是內置的，我們自定義的方法也不須參照魔術方法格式寫。

常用的魔術方法

__dict__

回傳物件的屬性名稱與值

#範例 1
#一個簡單的模組 Smartphone
#三個屬性 name,brand,price
#一個方法 on_sale
class Smartphone :
    def __init__(self,name,brand,price) :
        self.name = name
        self.brand = brand
        self.price = price
    def on_sale(self,discount) :
        self.price = self.price*(100-discount)/100
    
iphone_11 = Smartphone("iphone 11","Apple",1000)
iphone_11.on_sale(20)

print (Smartphone.__dict__) #返回所有可用的屬性(含內建與自定義屬性)
print (iphone_11.__dict__) #返回物件的自定義屬性

#執行結果
# >>> {‘__module__’: ‘__main__’,
‘__init__’: ,
‘on_sale’: ,
‘__dict__’: ,
‘__weakref__’: ,
‘__doc__’: None}

# >>> {‘name’: ‘iphone 11’, ‘brand’: ‘Apple’, ‘price’: 800.0}

__file__

回傳模組的路徑位置

#範例 2
import numpy as np
print(np.__file__)
print(np.ndarray.__file__)

#執行結果
 >>> 'C:\\Users\\Jia\\Anaconda3\\envs\\AI_L\\lib\\site-packages\\numpy\\__init__.py'
 >>>  AttributeError: type object 'numpy.ndarray' has no attribute '__file__'

__name__

直接使用時，回傳主程式(當前程式)py檔名稱

當作屬性使用時，使用模組的py檔名稱

#範例 3
print(__name__)
print(np.__name__)
print(np.ndarray.__name__)

#執行結果
>>> __main__
>>> numpy
>>> ndarray

問題回顧

• 為何需要魔術方法?

什麼是屬性(attribute)?

先從屬性(attribute)一詞描述，什麼是屬性，在python裡基本上在 . 之後的都是屬性。

所以取得某物件的屬性也可說是「從一個物件中取得附屬於該物件的另一個物件」，從屬性上也可以看出彼此的從屬關係。

以此理解，我們建立簡單的class。

#範例 1
class Smartphone :
	main_purpose = "call up" #此為類別屬性
	def __init__(self,year,price,brand) :
		self.year = year #實例屬性
		self.price = price #實例屬性
		self.brand = brand #實例屬性

• 類別屬性(class attribute) : 此屬性是跟隨類別的，一旦類別屬性變動，所以做好的物件都會被套上此類別屬性。
• 實例屬性/資料屬性(instance attribute) : 此屬性跟隨物件，每個物件都有自己的實例屬性，及變更物件A的實例屬性，也不會影響到物件B。

變量等於屬性嗎?

許多文章中，會將上訴兩個名詞用不同的名字說明。

• 類別屬性(class attribute) class variable、類別變數、類變數、類變量
• 實例屬性/資料屬性(instance attribute) : instance variable、實例變數、實例變量

將變數與屬性就使用與理解上混為一談無傷大雅，但其實就技術層面與思維層面上不太一樣。

就python的文本裡即提到，在符號 . (dot)之後的即稱為屬性，並且屬性可以是唯獨或者可寫的。

但它是可寫時，我們便能賦值，這樣看起來便像一個變數，但因為他能表示出一個完整的從屬關係，所以以變數來形容他變得不太合適。

在物件導向技術中三個經常使用到的名詞，我們可以用很多的描述去側面形容他們的關係

• 物件是類別的一個實例
• 將類別實例化就是個物件

#範例 1
#創建智慧型手機的類別，因為含有相機功能，所以繼承了相機的能力
class Camera :
    def __init__(self,pixel) :
        self.camera_function = True
        self.camera_pixel = pixel
    def take_picture(self) :
        print ("喀擦，照片已存檔")

class Smartphone(Camera) :
    def __init__(self,name,brand,price,pixel) :
				super().__init__(pixel)
        self.name = name
        self.brand = brand
        self.price = price
    def on_sale(self,discount) :
        self.price = self.price*(100-discount)/100

	

#創造一個物件，雖然沒給變數參考他，但他確實是個存在記憶體中的物件，也是smartphone的一個實例
Smartphone("iphone 11","Apple",1000,1000)

#又創造了一個物件 iphone_11，他是個物件，同時也是Smartphone的實例，同時也是Camera的一個實例   
iphone_11 = Smartphone("iphone 11","Apple",1000,1000)
iphone_11.on_sale(20)

類別很好區分，在上述範例可以理解，類別其實就是class裡的所有東西，是我們製作物件的一個藍圖，我們定義了一些屬型(name,brand,price)，也定義了一個方法(on_sale)。讓之後有人要在做出Smartphone這種類型的物件時，能直接使用。

那物件跟類別怎麼區分呢，其實可以按照字面上的意思來形容。

• 物件 就是一個存在的東西
• 實例 是某個類型 存在的東西

從上面程式碼的例子，我有一台iphone 11，他除智慧型手機定義的東西，還繼承了相機的內容。

我們用isinstance()，判斷是否有繼承關係以及判斷iphone 11是否為Camera的一個實例。

print(isinstance(iphone_11,Camera),isinstance(iphone_11,Smartphone))

#輸出結果
>>> True True

這個例子，我們有以下幾個正確的描述:

• iphone_11 是 個物件
• iphone_11 是 由Smartphone實例化的一個物件
• iphone_11 是 Smartphone的一個實例
• iphone_11 是 Camera 的一個實例

以幾以下幾個”錯誤”或者”不全”的描述

• iphone_11 是個Camera實例化的一個物件 (錯誤) iphone_11 是 由Smartphone實例化的一個物件
• iphone_11 是個實例 (解釋不全) iphone_11 是”某個東西”的實例

問題回顧

• 請用一句話告訴我 類別、實例、物件的關係 ?

Namespace(命名空間)、Scope(作用域)

這兩個專有名詞關係著變數存取的問題。

傳統程序導向

資料是靜態的，程序跟資料分開，主要思考是以function為主要思考模式，我給定資料、寫好方法，程式會返回另一筆靜態資料。我在將資料放到下一個function。

優點是直觀、易於開發。缺點是，完全不能重複使用，也不太能擴增，要新的功能或者是要別的已開發好的程式的功能都無法，都得重新設計，這也導致維護很困難，也許寫新的都會比較快。

物件導向程式設計(Object-oriented programming，簡稱OOP)

這裡小提一下什麼是物件導向，是以物件為主要概念的開發模式，相較於傳統程序導向提高了重複使用性、擴充與維護性。

在物件導向中導入了物件的概念，而這個物件並非只是靜態資料，他能參有自己的屬性以及方法。

那物件怎麼創造呢?就是用一個抽象的方法 class ，他像一張產品設計圖，我在設計圖內寫下了它的設計方法，裏面包含了我設計的產品有什麼基本的零件與功能、以及使用者能夠如何使用或者擴增產品的功能。我並不是真的製作了一個產品，而是做出了一張設計圖給大家使用，大家能參照設計圖設計出自己獨立的物件。

而相較於傳統程序導向的缺點

• 物件設計較不直觀
• 程式執行速度相對也較慢

物件導向的三大特點 : 繼承、封裝、多型

物件導向的三大特點 : 繼承、封裝、多型

特性一. 繼承 (inheritance)

有許多的功能其實早就已經寫好，物件導向的程式設計能夠將別的已經寫好的屬性與方法繼承自己開發中的類別裡，不用再重複撰寫那些已有的功能。

特性二. 封裝 (encapsulation)

我們建立好class後，以後的使用者只須如何使用即可，不需了解整個物件製造的架構或設計過程。

特性三. 多型 (polymorphism)

不同的類別裡，能擁有同樣名字的函式。

所以做出來的物件呼叫相同名字函式時，會回溯到各自類別的函式名稱，而有不一樣的結果。

#範例 1 

def a(x,y) :
	return x+y
if __name__ == "__main__" :
	a(x,y)

程式碼第三行，__name__ == “__main__“到底該怎麼理解 ? 本文將慢慢解析

什麼是name?

__name__是一個內置屬性，當你訪問__name__時，會回覆你當前文件(模組)或者引入的模組名稱。

#範例 2-1

print(__name__)

執行結果
>>> __main__

上面的程式，詢問執行中的文件，名字(__name__)是什麼?程式回傳名稱__main__
python對於自己執行的主程式，會用__main__來自稱。

如果匯入模組，訪問其名字，則會回傳模組名稱。

#範例 2-2

import numpy as np
print (np.__name__)
# >>> numpy

print (np.random.__name__)
#  >>> numpy.random

什麼是main?

如上段提到，訪問__name__時，他會回覆你所使用的模組的名稱。

如果直接訪問，會回傳當前程式(主程式)的資訊，但不會用模組名(或說.py檔名、當前程式名稱)，而是會用__main__自稱。見範例程式 2-1。

if __name__ == “__main__” 是什麼意思 ?

可以程式使用口語翻譯理解這句話

” 如果 模組名稱 就是 “__main__”的話，…… “

意思是如果執行模組時，他是當作主程式進行的話(而不是被引入的模組)，就執行if後的內容。

我們寫的.py檔有時會當主程式運行，有時會被當模組引入。

如果沒這個條件句寫在程式內，在import引入會遇到一些問題，我只是想引入一些def方法而已，但程式會把所有的內容執行完。

範例 3-1是被引入的模組 bar.py，範例 3-2是主要執行的程式 foo.py

#範例 3-1
#被引入的模組 bar.py
def test1():
	print ("被引入的模組名稱",__name__)
test1()
print("今天要偷買珍珠奶茶")

#範例 3-2
#主要執行的模組(文件) foo.py
import bar
def test2():
	print ("主程式名稱",__name__)
test2()
bar.test1()

執行範例3-2的執行結果

>>> 被引入的模組名稱 bar #在import那行執行了test1()，因為被引入了所以變成 bar
今天要偷買珍珠奶茶 #在import那行，執行了print()
主程式名稱 __main__ #主程式執行test2()
被引入的模組名稱 bar #主程式引入模組bar的test1執行，因為被引入了所以變成 bar

以上範例，討論最後的兩個結果，但因為引入模組有其他零碎的程式碼，所以會被跑出很多我不需要的東西。

那解決的思維就是，bar.py這個檔案

• 當作主程式(當前程式)執行時，才希望有”今天要偷買珍珠奶茶”的字串以及test1()的執行。

• 當作主程式(當前程式)執行時，才希望有”今天要偷買珍珠奶茶”的字串以及test1()的執行。

那該如何實現，這時就要用到 if __name__ == “__main__” ，這個判斷式的口語意思是 判斷當前檔案是否為主程式，主程式的__name__都是”__main__“，如果是引入的話__name__就是檔名。

所以上方程式碼就該修改為下面示範，即能達到效果

#範例 4-1
#被引入的模組 bar.py
def test1():
	print ("被引入的模組名稱",__name__)
if __name__ == "__main__" : 
	test1()
	print("今天要偷買珍珠奶茶")

執行結果
>>> 被引入的模組名稱 __main__
今天要偷買珍珠奶茶

引用”愛學習的豆包“的文章圖示與範例，展示模組運行命名流程

狀況1 : 直接執行指令碼

#被引入的模組 bar.py
def test1():
	print ("被引入的模組名稱",__name__)
if __name__ == "__main__" : 
	test1()
	print("今天要偷買珍珠奶茶")

狀況2:從其他腳本里匯入

import nameScript as ns
ns.myFunction()

問題回顧

• __name__是什麼 ?
• __main__是什麼?
• 如何理解 if name == “main” :