2020年3月31日火曜日

python基本規格測試

 之前寫的python規格測試用的東西。可以用jupyter丟進去觀察結果。


#!/usr/bin/env python3

# -*- coding: utf8 -*-
# 除了迴圈/if判斷/函式定義/class定義需要冒號":"之外,行尾不需終結符號
# 註解建議使用linux script style : 井號後面加上空格再開始寫
# 可以跳行的長字串: 使用三個雙引號定義(""")
#     第一個沒有被指定變數的長字串會被當成 class的 docstring (可用變數名稱 __doc__ 存取)
# 靠縮排4格來定義下一層的指令(函數,迴圈,判斷式的後續動作等等)

import sys # for console arguments

""" 這是長字串
第二行 """

longStr2 = """ 這是長字串2
 2的第二行 """

print("arg0=" + sys.argv[0])
print(longStr2)
print(__doc__)

__doc__ =""" 這是長字串3
3的第二行 """
print(__doc__)


print('unicode -------------------------------------')
strTmp= '一二三四' # 變數不需宣告,也會持續存在。重複使用時的初始值必須考慮。可以用del指令刪除變數。

# 注意,一個變數被assign初始之後,不要再assign不同的資料結構,容易出現不明問題。

i = -1
j = 6
print(strTmp[i:j])  # 多碼字不是以byte計算,以一個文字為單位。
print(strTmp[1])


# 使用陣列index做存取,在超過陣列範圍的情況下,會產生outbound index exception, 但是套用array slice則不會。
#    slice可以為負值,不管起終點都是指從陣列尾倒數。
# 字串物件其中的字不可被修改,只能經過處理產生新的



# 序列資料結構: list  [obj1, obj2, ...] ,可以單獨置換list元素,可以slice指定置換list元素,可以接合兩個list
# slice的置換可以只給1個元素"z",也可以丟list["y","z"],起點跟終點相同的話,視同插入。

print('list -------------------------------------')
arJ =  [3,4]
arI = [0,1,2] + arJ
print(arI)
print(len(arI))
arI[0:0] = "x"  #在陣列頭插入
print(arI)
arI[0:1] = "y"  #在陣列頭置換
print(arI)
arI[2:4] = ["a", "b"]  #在陣列中置換。
print(arI)
arI[2:3] = ["y", "z"]  #在陣列中置換。注意:若是slice的起終點的差,小於置入陣列的大小,視為插入。
print(arI)
arI[0:1] = arI  #在陣列頭插入自己,結果是會重複內容
print(arI)


# 多層list, 不可使用slice方式置入
arI[2] = arJ
print(arI)


# 迴圈, 條件表示式,需在尾巴加上":"

print('while loop -------------------------------------')
i = 0
j = 0
while (i < 10):
    j = j + i
    i = i + 1


print(j)

pass # pass: 不做任何事情。 在一定要有命令行的地方可以發揮作用。



# 序列資料結構 touple: 小括號"()"表示。只有一層可以不寫小括號,直接用逗號定義內容,
#     但是第二層之後必須有括號(obj1, int2, ...) ,應該是故意要跟function call相同
# 建立之後不可改變內容,但是裡面的元素可以改變內容。性質與list類似。元素內容有順序,可重複元素。
# 可使用index存取: touple[0]
# 建立0個元素的內容: 固定指令()
# 建立只有一個元素的內容,必須在後面加上逗號。 (obj, ) 原因猜測是會跟function call parameter重複定義



print('touple -------------------------------------')
x = "x"
y = "y"
z = "z"

touple = (x, y, z)  # touple packing
a, b, c = touple  # 可以拆解。 注意變數數量必須跟touple的元素數量相同, 太多或太少都會出ValueError
print(touple)
print(touple[0])
print(a + b + c)



print('set -------------------------------------')
# 序列資料結構 set: 以大括號"{}"表示。 而且跟list一樣必須寫。
# 元素順序由系統自行決定不可自訂(操作前是固定的,操作後不保證會不會變動)
# 元素內容可變,但不可重複。放入重複元素會以後蓋前的方式運作。
# 無法循序存取,只能遍歷。有基本的add / remove / pop / clear操作
# 建立0個元素的內容: 固定指令set(),不可使用{},會建立另一種資料結構:dict。
# 無刪除元素指令

a = set('abracadabra')  # 注意: 以set()初始化字串的話,結果會是一個單字串的set
b = set('alacazam')
print(a)
print(b)



# 序列資料結構 dictionary : 同樣以大括號"{}"表示,但是定義內容以key: value的方式定義。 運作方式類似java的map, objective c也有dictionary。
# key必須為不可變的物件,像是字串,數字,boolean。也可以用touple定義,但是此時的touple不可包含可變元素。
# 元素有順序,內容可變,要列舉可以用list(dic)取得key list,也可以用dict.items()取得key-value iterable
# 無法直接取得value list。使用 in 運算子只能比對key。
# key: value必須同時存在,key值不會重複,跟set一樣,設定重複的值會以後蓋前的方式運作。
# 比對兩個dict相同,不會管key值順序。



print('dict -------------------------------------')
tel = {'jack': 4098, 'sape': 4139, 'sape': 4140}
print(tel)
tel['guido'] = 4127  # 可使用list運算存取。
print(tel)
del tel['sape'] # 可以用del指令刪除key(value也會消失)。刪除不存在的key會出現KeyError。
print(tel)


tel = dict([('sape', 4139), ('guido', 4127), ('jack', 4098)]) # 可以靠touple定義key: value值
print(tel)
tel2 = dict(zip(['one', 'two', 'three'], [1, 2, 3])) # zip(): 把兩個同元素數量的序列以順序合併成touple組合
print(tel2)






# for : 只能對陣列型物件操作。 要寫一般的數字跑法的話,可以使用range(起始, 終點, step)產生iterable物件。
# 或是使用此法產生數字陣列: list(range(起始, 終點, step))
# for的list操作,建議使用slice功能產生copy,避免即時操作list導致iterate成為無窮迴圈
# for/while else : 疊代跑完沒被break的話就執行。若是要設計find流程好用。
# 其他技巧: 可以用dict.items()取得key-value iterable
# 可以用enumerate()取得index-value touple(iterable)
# 二階迴圈可以靠zip()實作

print('for loop -------------------------------------')
i = 0
for ar in range(10): # 只會跑0 ~ n-1的部份
    i = i + ar

print(i)
print(ar)  # 回傳值為9 (也就是n-1)。 參數會持續存在。



for f in enumerate(a):  # 印出來會是touple組合。
    print('enumerate {0}= {1}'.format(f[0], f[1]))


index = [0, 1, 2]
value = ['a', 'b', 'c']

for i, v in zip(index, value):  # 二階迴圈可以靠zip()實作
    print('index[{0}]= {1}'.format(i, v))

   

   

   

# function : 不可控制外部變數,除非以global做特別宣告。 參數加上預設值代表option參數(caller給不足參數的話就會使用預設值)
# 沒給預設值的參數,caller必須給值,要不然執行會錯誤。可以不照參數順序給,但是要使用<parameter name>=value的方式指定
# 使用<parameter name>=value的方式指定,不可重複給同一個參數值
# option參數也可以不照順序給,同樣使用<parameter name>=value的方式指定
# option參數的預設值假如是物件的話,操作過的結果會被保留。若是有重複call的動作要注意。解決方案如下面的程式碼的參數z。
# 函式的參數可以帶函式(因為函式本身就是一個物件)。
# 函式物件的物件定義: function.__self__ --- 一個帶著函式方法fucntion()的物件。
# 函式物件的函式定義: function.__func__(self, param1, param2, ...) --- 等同於class method。
# 參數名帶*號,會收集傳進來的所有照順序給的參數(除了已指定的之外)。
# 參數名帶**號,會收集傳進來的所有<parameter name>=value的方式指定的參數(除了已指定的之外)。
# 傳入順序參數時,可以利用list傳入。 但是要在參數名前面加上*號
# lambda function: 單行的無名function可以不需寫def來定義。參數可以參照上層。
print('function -------------------------------------')

def plusplus(n, x=1, y= ["zzzzz"], z = None):
    if z is None:
        z=[]

    n = n + 1  # python沒有累加算符(++)
    x= x + 1
    print(x)
    y.append("a")   # 操作的結果會被保留
    print(y)
    return n        # 不指定回傳值(包含只寫了return)的話,caller會接到None這個物件。


print(plusplus(i))
print(plusplus(i))
print(plusplus(*[i, 2]))
print(plusplus(i, y=['yyyyy'])) # lambda function
print(i)


def funcplus(a,b):
    return a(b)



print('function parameter -------------------------------------')
print(funcplus(plusplus, 1))


# 判斷式if : 可以用 in (datatype1, objet2, list3, ...) 的方式比對一個個obj。這種touple表示的物件,因為只比對第一層的obj表列,並不會比對陣列內部內容
print('if else elif -------------------------------------')
if (arI) in (45, arI):  # in也是比較運算子。其他的比較運算子: == && < > <= >=
    print("here")
else:
    print("there")

if ([4, 3]) in arI[:]:  # in直接丟一個list物件進去的場合,不同的list, 只要順序跟內容相同,就會被找到
    print("revarray")

if (arJ) in arI[:]:  # 不只是同一個list,不同的list, 只要順序跟內容相同,也會被找到
    print("array")

if ([3, 4]) in arI[:]:  # 不只是同一個list,不同的list, 只要順序跟內容相同,也會被找到
    print("newarray")

print(arI in (45, arI)) # 簡易比較的寫法。其他語言也有



# 資料型態: None (一般語言的null,注意大小寫,是系統預設的物件)
# NaN : 非數字,是系統預設的物件
# boolean : True / False (注意大小寫)
# assign 的動作只能出現在左端,不能出現在比較式內。
# None的比對敘述: if a is None:


# 模組: import 之後會跑一次模組檔案的內容,也就是所謂的初始動作。
# as : 別名
# 模組內參數存取:modname.itemname
# 模組只會初始化一次,而且永久有效。所以要是import過之後改了模組,在不重啟python執行器的狀況下要更新模組,
# 可以 import importlib,再執行 importlib.reload(modulename) 。

# 如何讓模組判斷現在是當成主程式在跑:  if __name__ == "__main__"   這樣方便單獨測試。

# 模組路徑: 1. 主模組執行的同一個目錄 2. PYTHONPATH
# 如何增加模組搜尋路徑: sys.path.append('<路徑>')

print('import -------------------------------------')

import requests as http

print(dir())  # 這樣可以印出目前有用到的所有method跟變數。



headers = {
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
    "Accept-Language": "zh-TW,zh;q=0.8,en-US;q=0.6,en;q=0.4",
    "Accept-Encoding": "gzip, deflate",
    "User-Agent": "Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.89 Safari/537.36",
}

url = "https://udn.com/news/story/7338/4091931"



# print(sys.path)
# try:

# r = http.get(
#    url, verify=False, headers=headers, timeout=(10, 30)
#    )  # ,proxies=proxies)
# except:
# print(r.text)


# 例外處理 : try / except 一個try可以有多個except, 若是except沒指定,會傳到上層的try / except。 都沒捕捉的話就拋出系統錯誤,停止執行
# except可以一次捕捉多個。  格式: except (RuntimeError, TypeError, NameError):
# raise : 丟出例外
# 在例外處理中再丟出例外,就是給上一層處理。
print('try except -------------------------------------')




print('class -------------------------------------')
# class定義方式: class ClassName(Extend from class1, Extend from class2, ...):
# self : 物件本身 (就是java/c++的this)
# class的初始化: 定義函數 __init__(self, arg0, arg1,...)
# new一個class(產生一個class物件): ClassName(arg0, arg1,...)
# 物件函式與class函式的關係: 假設x為MyClass的物件, x.f() 等同於 MyClass.f(x) 。python不分class method或是object method...
# class內定義參數的話,所有從同一個class產生或是繼承的物件共享該參數。
# class method要操作物件的參數,必須以self操作。
# object.__class__ : 判斷該object是哪種class(就是傳回該物件的class定義結構)。
#    預設的class比對方法: isinstance(obj, <classname>)
#    是不是繼承class的比對: issubclass(object.__class__, <classname>)

# class內部參數: __name__ ,會給class的可讀名稱
# 定義一般函式,要給class/object 當作method用的話,第一個參數必須是self。

# 繼承可以指定模組內的某個class。
# 繼承來的class function可以改寫(因為沒有特別的阻擋機制)
# class function改寫後要call baseclass的函式也是可以的。就直接執行class method即可。
#   例:BaseClassName.methodname(self, arguments)
#   要注意,假如是class中的class,就不能這樣做。

# 空的class :  在class定義後加上一行"pass"。 就可以拿來放任何東西,不過這樣做比較難掌握其內容。(是可以靠dir()來列舉...)


class MyClass(int):
    def __init__(self):
        self.lArray = []
       
    def add(self, x):
        self.lArray.append(x)


myClass = MyClass()
print(issubclass(myClass.__class__, int))
print(myClass.__class__ is MyClass)
print(myClass.lArray.__class__.__name__)
print(myClass.add.__self__)
myClass.add.__func__(myClass, "a")
print(myClass.lArray)


print('namespace -------------------------------------')

# Namespace: global --- 此參數定義之後,會影響模組的最上層的區域。
#            nonlocal --- 此參數定義之後,會影響下了該定義的階層的上一層。
# 不建議依賴系統的動態變數解析。(乖乖的傳參數的意思)

def scope_test(): # 第二層
    def do_local(): # 第三層
        spam = "local spam"  # do_local 內部的spam

    def do_nonlocal():
        nonlocal spam # spam 定義在上一層。
        spam = "nonlocal spam" # 此例上一層已定義spam = "test spam", 所以執行此動作的話,第二層的spam會被定義為"nonlocal spam"

    def do_global():
        global spam # spam定義在此模組的第一層
        spam = "global spam" # 這時第一層的spam才被賦值

    spam = "test spam" # 第二層的spam定義。不會影響第一層
    do_local()
    print("After local assignment:", spam)
    do_nonlocal()
    print("After nonlocal assignment:", spam)
    do_global()
    print("After global assignment:", spam)

scope_test()
print("In global scope:", spam)  # 第一層




# iterator
# 只要該物件/class有實作__iter__(self), __next__(self),丟出StopIteration的動作的話,就可以被迴圈用來迭代。
# python原生函式: iterator = iter(obj) --- 獲得該物件的迭代器。
# python原生函式: next(iterator) --- 執行一次迭代。通常會回傳迭代物件
# 下面是一個簡單的可迭代class的實作。
class Reverse:
    """Iterator for looping over a sequence backwards."""
    def __init__(self, data):
        self.data = data
        self.index = len(data)

    def __iter__(self):
        return self

    def __next__(self):
        if self.index == 0:
            raise StopIteration
        self.index = self.index - 1
        return self.data[self.index]
   
print('iterator -------------------------------------')
rev = Reverse('spam')
iter(rev)
for char in rev:
    print(char)

   
   
# generator : 不需定義class就可以產生可迭代物件的方法。
# 只要函式定義裡面使用yield關鍵字(作用是回傳物件),就自動成為可迭代的動作。
def GenReverse(data):
    for index in range(len(data)-1, -1, -1):
        yield data[index]

print('generator -------------------------------------')
genReverse = GenReverse('abc')
print(next(genReverse))
print(next(genReverse))
print(next(genReverse))

0 件のコメント:

コメントを投稿