December 22, 2019

Python的函數(Function)vs方法(method)

前言

※ 本段有些難度，略過並不影響後續理解。

在幾天前，我實現了一個可以傳入函數呼叫的類別（Callable Class），相關可以參考「用Python實現Callable Class」。

起初，我實現Meta-Class的方式，是在defineclz.__new__(clz, *args, **kwargs)實例(instance)後，將實例增加函數成員(Function Member)。不過這樣做並不太成功。會需要使用instance.__call__(f, *args, **kargs)去執行。而直接複寫defineclz.__call__的話，以會造成不斷呼叫的問題，而且無法讓後續繼承子孫，再進一步調整方法。這也是為什麼後來以內部類別實現，並且另擁有__call__能力的類別，後於defineclz，好讓自定義的__call__可以複寫掉預設行為。

※ Note: 本文寫到的函數成員(Function Member)，主要是指實例屬性，但這個屬性是一個函數。更多時候，成員(Member)可能就包含方法(Method)和屬性(Attribute)，而函數成員(Function Member)可能就直指方法(Method)。

定義方法(method)vs定義函數(function)

※ 尚為去翻找文件，可能有錯誤。

在Python，可以用def關鍵字去定義一個函數：

def f1():
    print("call f1")

f1()

而方法的定義也是使用def：

class C1:
    class_attr1 = {}
    def __init__(self):
        self.instance_attr1 = {}
    def _f1(self):
        print("C1: f1")
    def f1(self):
        self._f1() # if wrote `_f1()`, it will not found
    def f2(self):
        def _f2():
            print("C1.f2: _f2")
        _f2()

c1 = C1()
c1.f1()
c1.f2()

但其實這裡就可以看出一些行為的不同。上面_f1()和f1()看是在同一個scope，但是如果f1()需要呼叫_f1()，必須使用self._f1()或是C1._f1(self)，如果直接寫_f1()會報錯說找不到。相對來說f2()是C1類別的方法，但是內部函式_f2不是，因此就不需要這樣寫。現在在把f1()移出類別外，變成一般函式看看：

December 20, 2019

用Python實現Callable Class，FP更好寫

This Article has English Version, please goto here to read.

前言

最近，和朋友們在解LeetCode的題目。看著不同人寫出來的程式，也讓我對於一個題目的解法，有更寬廣的視野。

938. Range Sum of BST

URL: https://leetcode.com/problems/range-sum-of-bst/

這篇文章與這個想法，也是受到朋友寫的一個Ruby寫法的啟發。我用同樣的邏輯去寫Python，如下圖：

當然，這題目有更好更快的寫法，但這樣寫更為有趣有意思。
但是，內部隱含的block函數，從函數型語言的設計原則來看，他是危險、骯髒的。這是因為每次他的執行，都會修改到外部變數s的的值。(這辦法不夠 純函數 )

因此，我修改成以下方式：

如此，你還可以改寫成一行：

December 13, 2019

關於Python 3.8的象牙運算符(:=)

我沒想到一天會來寫個三篇😅。不過看完PEP 572 and The Walrus Operator後，對於象牙運算符(:=)，稍微產生了點不同樣的看法。至於稍早前覺得蠻新鮮的想法…可以去看看我上一篇。

此外，感謝Chang-Ning Tsai在社團分享該篇文章。

有爭議的象牙運算符(:=)

it is ambiguous for developers to distinguish the difference between the walrus operator (:=) and the equal operator (=). Even though sophisticated developers can use “:=” smoothly, they may concern the readability of their code.

最近在解LeetCode，在沒有這個賦予值的方法前，真覺得有些時候有點不方便。可是這個運算符在是否納入時，似乎有引起一些爭議。像是:=可能難與閱讀，不過我覺得比較有問題的還是賦予值運算子(=)和象牙運算子(:=)的混搖，更正確的說，我是覺得兩者有點太像，這似乎有點違反Python的則學之一：「There should be one– and preferably only one –obvious way to do it.」，用同樣的方式做事。

Python哲學

然後，不好意思，有一條是怎麼回事？
Although that way may not be obvious at first unless you're Dutch.
Dutch怎麼了嗎？

繼續深入

Developers may confuse the difference between “:=” and “=.” In fact, they serve the same purpose, assigning somethings to variables. Why Python introduced “:=” instead of using “=”? What is the benefit of using “:=”? One reason is to reinforce the visual recognition due to a common mistake made by C/C++ developers. For instance,

int rc = access("hello_walrus", R_OK);

// rc is unintentionally assigned to -1
if (rc = -1) {
    fprintf(stderr, "%s", strerror(errno));
    goto end;
}

December 13, 2019

Python3.8的幾個我覺得有意思的新特性

Python 3.8同樣有不少變動，有些蠻細微的，需要詳細了解可能還是直接看Python 3.8 有什么新变化der好。現在文檔都有(簡體)中文版，覺得比英文好讀多了。所以這篇只會分享幾個我覺得有意思的新特性。

遺憾的是，我還沒有更新到3.8，只能看看而已😭。

f-Strings

這個特性我單獨寫了一篇，歡迎看看：Python-3.8後的f-String。

象牙運算符(:=)

18:00更新
關於這看起來有點好用的東西，在做了更深一步的了解，可參考：關於Python 3.8的象牙運算符(:=)

寫過Golang的同鞋，對於這個運算符應該蠻熟悉的，這另這兩個語言有自動推導類型的能力。不過在Python裡，是相較於asign運算符(=)，象牙運算符(:=)更像表達式(expression)，而非語句(statements)。要我寫的話，偽代碼可能有點像：

※ Note: 表達式(expressions)也是一種語句(statements)。表達式會嘗試求值，但是語句不一定。此處主要是想表達 象牙運算符(:=) 會嘗試求值。

# @symbol var
def :=(val):
    nonlocal var
    var = val
    return var

賦予完變數值後，返回變數的值。這麼一來可以寫在任何需要表達式的地方(如果我沒理解錯的話0.0)。來看幾個文件上的範例：

if (n := len(a)) > 10:
    print(f"List is too long ({n} elements, expected <= 10)")

原本f-Strings裡可能要寫"{len(a)}"，但是這樣做的話就無須在對len(a)求值一次；或是在外圍設定變數值n = len(a)。(儘管最近觀察，內置內行的len(var)求值，可能還比賦予值(=)消耗成本還低)

接下來這例子就讓我真的很想用了：

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)

我一度在想會不會有while expr as var:的語句。雖然沒有，不過用:=可以更為靈活。

PEP 578: Python 運行時審核鉤子(Runtime Audit Hooks)

December 13, 2019

Python-3.8後的f-String

近況

最近在翻itertools、collections，和已經很常在用，但想看看還有啥的functools。這裡頭的東西並非必須，大部分我都有能力自幹。但沒必要再造輪子，甚至可以從此獲得一些啟發。譬如，itertools.groupby，我看到第一個想法就是：「這不就可以更簡單實現Hadoop裡，Map-Reduce分組的功能？」。於是乎就寫了下面一段程式：

from itertools import groupby
from functools import reduce

a = [1,2,3,4,5,6,7,8,9,]

def pipe(data, *process):
  result = data
  for proce in process:
    result = proce(result)
  return result

p = pipe(a, lambda x: map(lambda y:y**2, x),
         lambda x: sorted(x, key=lambda y: y%2),
         lambda x: groupby(x, key=lambda y: y%2),)

for g, d in p:
    l = list(d)
    s = sum(l)
    print("{g}: {d}, sum:{s}".format(g=g, d=l, s=s))

不知道python有沒有pipe的內部實現？

這段程式碼是將list a裡的奇數和偶數分組取平方加總。比較麻煩的是groupby依照官方文件寫法，相當於以下程式碼：

class groupby:
    # [k for k, g in groupby('AAAABBBCCDAABBB')] --> A B C D A B
    # [list(g) for k, g in groupby('AAAABBBCCD')] --> AAAA BBB CC D
    def __init__(self, iterable, key=None):
        if key is None:
            key = lambda x: x
        self.keyfunc = key
        self.it = iter(iterable)
        self.tgtkey = self.currkey = self.currvalue = object()
    def __iter__(self):
        return self
    def __next__(self):
        self.id = object()
        while self.currkey == self.tgtkey:
            self.currvalue = next(self.it)    # Exit on StopIteration
            self.currkey = self.keyfunc(self.currvalue)
        self.tgtkey = self.currkey
        return (self.currkey, self._grouper(self.tgtkey, self.id))
    def _grouper(self, tgtkey, id):
        while self.id is id and self.currkey == tgtkey:
            yield self.currvalue
            try:
                self.currvalue = next(self.it)
            except StopIteration:
                return
            self.currkey = self.keyfunc(self.currvalue)

December 3, 2019

關於C#內建類型的怪異設計(LeetCode:reverse string)

前言

先說一下我的背景，可能會比較了解為什麼我會這樣想。我自己學過C++和Java，這兩個都不算是完全物件導向。相對來說，另外一個蠻愛使用的Python就連基本型態也是物件。至於C#，因為一些個人喜好的因素，並沒有去好好學習。不過也有好一段時間幫朋友除錯，除ASP.NET的錯誤。

之所以能夠幫忙，或快速上手，應該也與C++、Java、C#三者的歷史有關。在C++之後，推出了一個更物件導向的程式語言：Java，最基礎的單獨單位是class，並且在JVM上運行，號稱可以跨平台、跨設備；隨後，Microsoft為了與Java競爭，並推廣自家的.Net Framework，學習了Java的設計，推出了C#。(早期更是有J#)

基礎型別&基礎類別

所以，三個是很相像的，更重要的是在物件導向的概念上。所以會一個，基本上另外兩個也就應該容易上手。不過C++從C遺留下來的基礎型態int、char、float以及struct等等，註定讓它不那麼物件。Java可能也有類似歷史因素，而為了處理這樣問題，Java將所有基礎型態做了包裝，一一對應¹。

※ Java基本型態對應的類別

Java中有兩個型態系統，基本型態與類別型態，使用基本型態目的在於效率，然而更多時候，會使用類別建立實例，因為物件本身可以攜帶更多資訊，如果要讓基本型態像物件一樣操作，可以使用Long、Integer、Double、Float、Boolean、Byte等類別來包裹（Wrap）基本型態。 –Source: https://openhome.cc/Gossip/Java/Wrapper.html

為什麼會突然覺得C#設計的有點怪？

這主要是最近寫到一題LeetCode，要做字元陣列的反轉。如果使用C#的話，需要使用Array的類別方法。

public class Solution {
    public void ReverseString(char[] s) {
        Array.Reverse(s)
    }
}