Java Artisan / Neil Chan

Java Lambda 初體驗，就遇到 Project Reactor 的 GroupedFlux

2018-03-31T11:36:00.000+08:00

在練習書上的（不負責任的）範例時，遇到了「流中流」的問題，就是 Stream of Stream，一般都是用 flatMap 去打平，但這個 GroupedFlux 不太一樣。

先來說說需求，就是輸入一堆單字，然後統計每個字母（不分大小寫）的出現次數。

舉例來說，輸入「java」、「"hibernate」和「spring」三個單字，要得到以下的結果：

A => 3
B => 1
E => 2
G => 1
H => 1
I => 2
J => 1
N => 2
P => 1
R => 2
S => 1
T => 1
V => 1

第一次嘗試，試了好久才免強得到結果，但不符合我目前理解的標準。

Flux.just("java", "hibernate", "spring")// 1
        .map(String::toUpperCase)// 2
        .flatMap(s -> Flux.fromArray(s.split("")))// 3
        .groupBy(String::toString)// 4
        .sort((o1, o2) -> o1.key().compareTo(o2.key()))// 5
        .map(t -> t.key() + " => " + t.count().block())// 6
        .subscribe(System.out::println);// 7

先用 Flux.just() 這個 static 方法建立 String 流（在 Java 8 叫做 Stream，但在 Project Reactor 叫做 Flux，本質雖然類似，但實際上有很大的差異，就是非同步和非阻塞）。
為了不分大小寫，先用 Flux.map() 轉成大寫。
為了統計每個字母的數量，先用 String.split() 將字串拆成字母陣列，再用 Flux.fromArray() 將字母陣列轉換成 Flux<string>，這時候就是簡單的流中流（Flux of Flux），最後用 Flux.flapMap() 打平成單一個 Flux<string>，此時的 String 是單一字母。
使用 Flux.groupBy() 將 Flux<string>依照字母做統計，最終得到 GroupedFlux<string, String>，這時就是最棘手的流中流，Flux of GroupedFlux。
使用 Flux.sort() 將字母排序。
使用 Flux.map() 將 GroupedFlux 轉成目標字串，就是「字母 => 數量」，但問題來了，GroupedFlux.count() 回傳的是 Mono<long>，可以說是另一種流，Flux 可以看作是容納 0 到無限多物件的容器，而 Mono 是容納 0 到 1 個物件的容器，有點像是 Java 8 的 Optional，目前找不到方法可以得到 Mono<long> 裡的 Long，最終用了我覺得不該用的 Mono.block()，雖然可以得到數量，但 Mono.block() 就像是 Flux.subscribe()，是流的終點，是不是不應該在流的中間呼叫這樣的 API 呢？
最後呼叫 Flux.subscribe() 將內容輸出。

第二次嘗試，將 Mono.block() 的呼叫放到最後的 Flux.subscribe()，不過好像還是怪怪的。

Flux.just("java", "hibernate", "spring")// 1
        .map(String::toUpperCase)// 2
        .flatMap(s -> Flux.fromArray(s.split("")))// 3
        .groupBy(String::toString)// 4
        .sort((o1, o2) -> o1.key().compareTo(o2.key()))// 5
        .subscribe(g -> System.out.println(g.key() + " => " + g.count().block()));// 6

最後終於試出一種比較像樣的結果。

Flux.just("java", "hibernate", "spring")// 1
        .map(String::toUpperCase)// 2
        .flatMap(s -> Flux.fromArray(s.split("")))// 3
        .groupBy(String::toString)// 4
        .sort((o1, o2) -> o1.key().compareTo(o2.key()))// 5
        .flatMap(g -> g.count().map(count -> g.key() + " => " + count))// 6
        .subscribe(System.out::println); // 7

差別在第 6 步驟用 Flux.flatMap() 去打平 Flux of GroupedFlux，但特別的地方在對 GroupedFlux.count() 回傳的 Mono<Long> 去呼叫它的 map()，因為 Mono<Long> 也是流，所以可以呼叫 Mono.map() 來得到內容（也就是數量）再組成字串，不過因為是流的關係，所以最後要用 flatMap 去打平。
---
---
---

com.fasterxml.jackson.core 的 Jackson Annotations 2.9.3

2017-12-28T00:19:00.002+08:00

蠻常用 Jackson 將 Java 物件轉成 JSON（writeValueAsString），或者將 JSON 轉回 Java 物件（readValue）。

public class Book implements Serializable {

  private String title;
  private int year;

  public String getTitle() {
    return this.title;
  }

  public void setTitle(String title) {
    this.title = title;
  }

  public int getYear() {
    return this.year;
  }

  public void setYear(int year) {
    this.year = year;
  }

  @SuppressWarnings("unchecked")
  public static void main(String[] args) throws IOException {
    Book b = new Book();
    b.setTitle("Jackson");
    b.setYear(2017);
    String json = new ObjectMapper().writeValueAsString(b);
    System.out.println(json); // {"title":"Jackson","year":2017}
    Map<String, String> m = new ObjectMapper().readValue(json, Map.class);
    System.out.println(m); // {title=Jackson, year=2017}
  }
}

但聽說它有非常多特別的 Annotation。

@JsonIgnoreProperties & @JsonIgnore

使用 Jackson 最常見的需求就是，不要輸出某些欄位，可能原因有：安全考量（密碼欄位）、資料量（大物件或者 List / Map）、遞迴參考（會當掉？）以及 Lazy 屬性（Hibernate 未初始化的關聯屬性）。

有四種設定方式。

Class Level - @JsonIgnoreProperties

@JsonIgnoreProperties({
    "contractAmt"
})
public class Book implements Serializable {

  private String title;
  private int contractAmt;

  public String getTitle() {
    return this.title;
  }

  public void setTitle(String title) {
    this.title = title;
  }

  public int getContractAmt() {
    return this.contractAmt;
  }

  public void setContractAmt(int contractAmt) {
    this.contractAmt = contractAmt;
  }

  public static void main(String[] args) throws IOException {
    Book b = new Book();
    b.setTitle("Jackson");
    b.setContractAmt(1099);
    System.out.println(new ObjectMapper().writeValueAsString(b));
    // {"title":"Jackson"}
  }
}

Field Level - @JsonIgnore

public class Book8 implements Serializable {

  private String title;
  private int contractAmt;

  public String getTitle() {
    return this.title;
  }

  public void setTitle(String title) {
    this.title = title;
  }

  @JsonIgnore
  public int getContractAmt() {
    return this.contractAmt;
  }

  public void setContractAmt(int contractAmt) {
    this.contractAmt = contractAmt;
  }

  public static void main(String[] args) throws IOException {
    Book8 b = new Book8();
    b.setTitle("Jackson");
    b.setContractAmt(1099);
    System.out.println(new ObjectMapper().writeValueAsString(b));
    // {"title":"Jackson"}
  }
}

特定 Java Type - @JsonIgnoreType

public class Book implements Serializable {

  private String title;
  private Address address;

  public String getTitle() {
    return this.title;
  }

  public void setTitle(String title) {
    this.title = title;
  }

  public Address getAddress() {
    return this.address;
  }

  public void setAddress(Address address) {
    this.address = address;
  }

  public static void main(String[] args) throws IOException {
    Book b = new Book();
    b.setTitle("Jackson");
    System.out.println(new ObjectMapper().writeValueAsString(b));
    // {"title":"Jackson"}
  }
}

@JsonIgnoreType
class Address {

}

但是當你「摸不到」別人家的 Java type 時，可以改用 Mixin（混搭）的方式 - addMixIn。

public class Book implements Serializable {

  private String title;
  private Date signedDate;

  public String getTitle() {
    return this.title;
  }

  public void setTitle(String title) {
    this.title = title;
  }

  public Date getSignedDate() {
    return this.signedDate;
  }

  public void setSignedDate(Date signedDate) {
    this.signedDate = signedDate;
  }

  public static void main(String[] args) throws IOException {
    Book b = new Book();
    b.setTitle("Jackson");
    b.setSignedDate(new Date(117, 11, 31));

    ObjectMapper mapper = new ObjectMapper();
    System.out.println(mapper.writeValueAsString(b));
    // {"title":"Jackson","signedDate":1514649600000}

    mapper = new ObjectMapper();
    mapper.addMixIn(Date.class, SqlDateMixin.class);
    System.out.println(mapper.writeValueAsString(b));
    // {"title":"Jackson"}
  }
}

@JsonIgnoreType
class SqlDateMixin {

}

Filter - @JsonFilter

@JsonFilter("secret")
public class Book implements Serializable {

  private String title;
  private Date signedDate;

  public String getTitle() {
    return this.title;
  }

  public void setTitle(String title) {
    this.title = title;
  }

  public Date getSignedDate() {
    return this.signedDate;
  }

  public void setSignedDate(Date signedDate) {
    this.signedDate = signedDate;
  }

  public static void main(String[] args) throws IOException {
    Book b = new Book();
    b.setTitle("Jackson");
    b.setSignedDate(new Date(117, 11, 31));

    ObjectMapper mapper = new ObjectMapper();
    SimpleFilterProvider filters = new SimpleFilterProvider();
    filters.addFilter("secret", SimpleBeanPropertyFilter.serializeAllExcept("signedDate"));
    mapper.setFilterProvider(filters);
    System.out.println(mapper.writeValueAsString(b));
    // {"title":"Jackson"}
  }
}

@JsonProperty & @JsonGetter

預設狀況下，JSON 的屬性名稱是使用 Java Bean 的 property name，@JsonProperty 可以在不修改 Java Bean 的情況下自訂JSON 的屬性名稱，也可以用更為通用的 @JsonGetter 達成一樣的目的。

public class Book implements Serializable {

  private String title;
  private int year;

  @JsonProperty("name")
  public String getTitle() {
    return this.title;
  }

  public void setTitle(String title) {
    this.title = title;
  }

  public int getYear() {
    return this.year;
  }

  public void setYear(int year) {
    this.year = year;
  }

  public static void main(String[] args) throws IOException {
    Book b = new Book();
    b.setTitle("Jackson");
    b.setYear(2017);
    System.out.println(new ObjectMapper().writeValueAsString(b));
    // {"year":2017,"name":"Jackson"}
  }
}

Include.NON_NULL

不要輸出 null 值的欄位，有三個設定 level：global、class 與 field 。

Global Level - setSerializationInclusion(Include.NON_NULL)

public class Book implements Serializable {

  private String title;
  private String author;

  public String getTitle() {
    return this.title;
  }

  public void setTitle(String title) {
    this.title = title;
  }

  public String getAuthor() {
    return this.author;
  }

  public void setAuthor(String author) {
    this.author = author;
  }

  public static void main(String[] args) throws IOException {
    Book b = new Book();
    b.setTitle("Jackson");
    // b.setAuthor("MJ");
    System.out.println(new ObjectMapper().writeValueAsString(b));
    // {"title":"Jackson","author":null}
    System.out.println(new ObjectMapper().setSerializationInclusion(Include.NON_NULL).writeValueAsString(b));
    // {"title":"Jackson"}
  }
}

Class Level - @JsonInclude(Include.NON_NULL)

@JsonInclude(Include.NON_NULL)
public class Book implements Serializable {

  private String title;
  private String author;

  public String getTitle() {
    return this.title;
  }

  public void setTitle(String title) {
    this.title = title;
  }

  public String getAuthor() {
    return this.author;
  }

  public void setAuthor(String author) {
    this.author = author;
  }

  public static void main(String[] args) throws IOException {
    Book b = new Book();
    b.setTitle("Jackson");
    // b.setAuthor("MJ");
    System.out.println(new ObjectMapper().writeValueAsString(b));
    // {"title":"Jackson"}
  }
}

Field Level - @JsonInclude(Include.NON_NULL)

public class Book implements Serializable {

  private String title;
  private String author;

  public String getTitle() {
    return this.title;
  }

  public void setTitle(String title) {
    this.title = title;
  }

  @JsonInclude(Include.NON_NULL)
  public String getAuthor() {
    return this.author;
  }

  public void setAuthor(String author) {
    this.author = author;
  }

  public static void main(String[] args) throws IOException {
    Book b = new Book();
    b.setTitle("Jackson");
    // b.setAuthor("MJ");
    System.out.println(new ObjectMapper().writeValueAsString(b));
    // {"title":"Jackson"}
  }
}

@JsonInclude 雖然名為 include，但實際上卻是用來 exclude 的，Include 除了 NON_NULL，還有 ALWAYS（預設）、NON_ABSENT、NON_EMPTY 與 NON_DEFAULT。

@JsonAnyGetter

預設狀況下，Map 物件會轉成 JSON 物件。

public class Book implements Serializable {

  private String title;
  private Map<String, String> histories = new HashMap<String, String>();

  public String getTitle() {
    return this.title;
  }

  public void setTitle(String title) {
    this.title = title;
  }

  public Map<String, String> getHistories() {
    return this.histories;
  }

  public void setHistories(Map<String, String> histories) {
    this.histories = histories;
  }

  public static void main(String[] args) throws IOException {
    Book b = new Book();
    b.setTitle("Jackson");
    b.getHistories().put("rev1", "20170101...");
    b.getHistories().put("rev2", "20170201...");
    System.out.println(new ObjectMapper().writeValueAsString(b));
    // {"title":"Jackson","histories":{"rev2":"20170201...","rev1":"20170101..."}}
  }
}

@JsonAnyGetter 可以將 Map 裡的名值對抽出來，有點 flatten 的味道。

public class Book implements Serializable {

  private String title;
  private Map<String, String> histories = new HashMap<String, String>();

  public String getTitle() {
    return this.title;
  }

  public void setTitle(String title) {
    this.title = title;
  }

  @JsonAnyGetter
  public Map<String, String> getHistories() {
    return this.histories;
  }

  public void setHistories(Map<String, String> histories) {
    this.histories = histories;
  }

  public static void main(String[] args) throws IOException {
    Book b = new Book();
    b.setTitle("Jackson");
    b.getHistories().put("rev1", "20170101...");
    b.getHistories().put("rev2", "20170201...");
    System.out.println(new ObjectMapper().writeValueAsString(b));
    // {"title":"Jackson","rev2":"20170201...","rev1":"20170101..."}
  }
}

@JsonRawValue

直接輸出原始內容，不去處理 JSON 專用的雙引號，可以用來輸出手打的 JSON 字串。

public class Book13 implements Serializable {

  private String title;
  private String json;

  public String getTitle() {
    return this.title;
  }

  public void setTitle(String title) {
    this.title = title;
  }

  @JsonRawValue
  public String getJson() {
    return this.json;
  }

  public void setJson(String json) {
    this.json = json;
  }

  public static void main(String[] args) throws IOException {
    Book13 b = new Book13();
    b.setTitle("Jackson");
    b.setJson("{\"title\":\"Jackson\"}");
    System.out.println(new ObjectMapper().writeValueAsString(b));
    // 一般欄位 - {"title":"Jackson","json":"{\"title\":\"Jackson\"}"}
    // @JsonRawValue - {"title":"Jackson","json":{"title":"Jackson"}}
  }
}

@JsonValue

效果類似 toString()，用該 method 回傳的值表示該 instance，適合用於enum。

public class Book14 implements Serializable {

  private String title;
  private BookType type;

  public String getTitle() {
    return this.title;
  }

  public void setTitle(String title) {
    this.title = title;
  }

  public BookType getType() {
    return this.type;
  }

  public void setType(BookType type) {
    this.type = type;
  }

  public static void main(String[] args) throws IOException {
    Book14 b = new Book14();
    b.setTitle("Jackson");
    b.setType(BookType.Computer);
    System.out.println(new ObjectMapper().writeValueAsString(b));
    // 一般欄位 - {"title":"Jackson","type":"Computer"}
    // @JsonValue - {"title":"Jackson","type":"COMPUTER"}
  }
}

enum BookType {
  Computer("COMPUTER"), Science("SCIENCE");

  private String name;

  BookType(String name) {
    this.name = name;
  }

  @JsonValue
  public String getName() {
    return name;
  }
}

@JsonRootName

Jackson 可以透過 SerializationFeature.WRAP_ROOT_VALUE 將自身也輸出，但自身預設為 class name，可以用 @JsonRootName 自訂自身名稱。

@JsonRootName("book")
public class Book15 implements Serializable {

  private String title;

  public String getTitle() {
    return this.title;
  }

  public void setTitle(String title) {
    this.title = title;
  }

  public static void main(String[] args) throws IOException {
    Book15 b = new Book15();
    b.setTitle("Jackson");
    ObjectMapper mapper = new ObjectMapper();
    mapper.enable(SerializationFeature.WRAP_ROOT_VALUE);
    System.out.println(mapper.writeValueAsString(b));
    // 一般欄位 - {"Book15":{"title":"Jackson"}}
    // @JsonRootName - {"book":{"title":"Jackson"}}
  }
}

@JsonSerialize

自訂物件輸出的內容。

public class Book16 implements Serializable {

  private String title;
  private Date publishDate;

  public String getTitle() {
    return this.title;
  }

  public void setTitle(String title) {
    this.title = title;
  }

  public Date getPublishDate() {
    return this.publishDate;
  }

  @JsonSerialize(using = DateSerialize.class)
  public Date getPublishDateFormatted() {
    return this.publishDate;
  }

  public void setPublishDate(Date publishDate) {
    this.publishDate = publishDate;
  }

  public static void main(String[] args) throws IOException {
    Book16 b = new Book16();
    b.setTitle("Jackson");
    b.setPublishDate(new Date());
    ObjectMapper mapper = new ObjectMapper();
    System.out.println(mapper.writeValueAsString(b));
    // {"title":"Jackson","publishDate":1514390929846,"publishDateFormatted":2017-12-28 00:08:49}
  }
}

class DateSerialize extends JsonSerializer<Date> {

  private SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

  @Override
  public void serialize(Date value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
    gen.writeRawValue(df.format(value));
  }

}

---
---
---

Java 腦袋學 Python Regular Expression

2017-06-03T00:03:00.000+08:00

Python Regular Expression 的套件為 re。

compile(), search() & findall()

#!python3
import re
regex = re.compile(r'\d{4}-?\d{6}') # r 表示使用 Raw string，即不 escape 反斜線 

s = '手機號碼有兩種，第一種是 0912-345678，第二種是 0912345678。'

# search 只會找到第一個符合的
mo = regex.search(s)
if mo != None:
    print(mo.group())
# 0912-345678

# findall 會找到全部符合的    
mo = regex.findall(s)
for mo in mobile_regex.findall(s):
    print(mo)
# 0912-345678
# 0912345678

Raw string 請參考 Java 腦袋學 Python 字串，如果不用 Raw string，那所有反斜線都要改用兩個反斜線，這樣變得很麻煩而且讓原本就難以閱讀的 RE 語法變得更加外星語。

快速複習 RE

\d 表示 0 到 9 的數字，也可以用 [0-9] 或者 (0|1|2|3|4|5|6|7|8|9) 表示
\D 表示 0 到 9 以外的任何字元，包括空白，也可以用 [^0-9] 表示
\w 表示字母、數字與底線，可以當作單字，也可以用 [a-zA-Z0-9_] 表示
\W 表示 \w 以外的任何字元，包括空白，也可以用 [^a-zA-Z0-9_] 表示
\s 表示空白、\t 與 \n，可以當作空白字元
\S 表示 \s 以外的任何字元
自訂字元用中括號 [] 包起來，也可以使用 - 連字號指定字母與數字的範圍
在中括號裡可以直接使用特殊字元，不用 \ Escape
在中括號裡第一個字元使用 ^ 表示指定相反的字元集合
^ 開頭與 $ 結尾
. 表示換行字元之外的任何字元，但對應的只有一個字元
.* 表示換行字元以外的所有字元，且為貪婪模式
.*? 表示換行字元以外的所有字元，但為非貪婪模式
非貪婪模式可以用在 {S,E}?、*? 與 +?
分組用 ( 與 )
或 |
出現零次或一次 ?
出現零次或 N 次 *
出現一次以上 +
出現指定次數 {N}、{S, E}、{S,}、{,E}

要找上述的特殊符號，就用 \ Escape。

指定字元

#!python3
import re

s = 'javascript java8 spring4 python3 css'

for mo in re.compile(r'\w+\d').findall(s):
    print(mo)
# java8
# spring4
# python3

Group 分組

#!python3
import re

# 用括弧分組
regex = re.compile(r'(\d{2})-(\d{8})')
s = '先來找簡單的電話號碼 04-22334455'

# search 只會找到第一個符合的
mo = regex.search(s)
print(mo.group()) # 04-22334455 符合字串
print(mo.group(0)) # 04-22334455 符合字串
print(mo.group(1)) # 04 符合字串的第一個分組
print(mo.group(2)) # 22334455 符合字串的第二個分組
print(mo.groups()) # ('04', '22334455') tuple 組成的分組
area, number = mo.groups()
print('{}-{}'.format(area, number)) # 04-22334455

或 |

#!python3
import re

regex = re.compile(r'python|java')
s = 'java spring python hibernate'

for mo in regex.findall(s):
    print(mo)
# java
# python

或也可以用 []。

#!python3
import re

regex = re.compile(r'[Pp]ython')
s = 'Python PYthon python'

for mo in regex.findall(s):
    print(mo)
# Python
# python

指定次數 ? * + { }

#!python3
import re

s = 'br bar baar baaar baaaar baaaaar'

# 零次或一次
for mo in re.compile(r'ba?r').findall(s):
    print(mo)
# br
# bar

# 零次或 N 次
for mo in re.compile(r'ba*r').findall(s):
    print(mo)
# br
# bar
# baar
# baaar
# baaaar
# baaaaar

# 一次以上
for mo in re.compile(r'ba+r').findall(s):
    print(mo)
# bar
# baar
# baaar
# baaaar
# baaaaar

# 指定次數{N}
for mo in re.compile(r'ba{3}r').findall(s):
    print(mo)
# baaar

# 指定次數 {S,E}
for mo in re.compile(r'ba{1,3}r').findall(s):
    print(mo)
# bar
# baar
# baaar

# 指定次數 {S,}
for mo in re.compile(r'ba{3,}r').findall(s):
    print(mo)
# baaar
# baaaar
# baaaaar

# 指定次數 {,E}
for mo in re.compile(r'ba{,3}r').findall(s):
    print(mo)
# br
# bar
# baar
# baaar

Greedy 貪婪模式

Python 預設是貪婪模式，即在符合條件的情況下，會找出最長的字串，例如 x{3,5} 可以找到五個 x 的話，就不會在 3 個 x 就結束。

可以在大括號後面加上 ?，改為非貪婪模式。

#!python3
import re

s = 'f fo foo fooo foooo fooooo'

for mo in re.compile(r'fo{1,3}').findall(s):
    print(mo)
# fo
# foo
# fooo
# fooo
# fooo

# 非貪婪模式
for mo in re.compile(r'fo{1,3}?').findall(s):
    print(mo)
# fo
# fo
# fo
# fo
# fo

findall() & Group 分組

findall() 會回傳所有符合的結果，但依據 RE 內容的不同而有不同的回傳物件。

當內容沒有分組時，回傳的是 list of str，但是有分組時，回傳的是 list of tuple。

#!python3
import re

s = '04-22334455 0912-345678 04-23456789'

for mo in re.compile(r'\d{2}-\d{8}').findall(s):
    print(mo)
# 04-22334455
# 04-23456789

s = '04-22334455 04-23456789'

for mo in re.compile(r'(\d{2})-(\d{8})').findall(s):
    print(mo)
# ('04', '22334455')
# ('04', '23456789')

額外的參數

re.DOTALL 讓 . 包括換行字元。

#!python3
import re

s = 'Ba\na\nar'
print(re.compile(r'B.*?r').search(s)) # None
print(re.compile(r'B.*?r', re.DOTALL).search(s).group()) # Ba\na\nar

re.IGNORECASE 或 re.I 不區分大小寫。

#!python3
import re

s = 'java Java JAVA'

for mo in re.compile(r'java').findall(s):
    print(mo)
# java

for mo in re.compile(r'java', re.IGNORECASE).findall(s):
    print(mo)
# java
# Java
# JAVA

# re.I 也行
for mo in re.compile(r'java', re.I).findall(s):
    print(mo)
# java
# Java
# JAVA

同時使用 re.DOTALL 與 re.IGNORECASE。

#!python3
import re

s = 'Ba\na\nar'
print(re.compile(r'b.*?r', re.DOTALL | re.IGNORECASE).search(s).group()) # Ba\na\nar

取代符合字串

用 sub() 取代 search() 或 findall()。

#!python3
import re

s = 'Python python'
print(re.compile(r'y').sub(r'*', s)) # P*thon p*thon

用原字串取代，使用 \N 表示分組 N，注意取代字串也是使用 Raw string 唷。

#!python3
import re

s = 'Python python'
print(re.compile(r'(python)', re.I).sub(r'[\1]', s)) # [Python] [python]

複雜的分組

當分組裡有分組時，如何判斷分組順序？依照左括號出現的順序。

#!python3
import re

s = 'Python3 python2'
print(re.compile(r'((python)(\d))', re.I).sub(r'\2[\3]', s)) # Python[3] python[2]

\1 表示 Python3 或 python2，\2 表示 Python 或 python，而 \3 表示 3 或 2。

分行並註解的語法

可以透過 re.VERBOSE 參數來使用多行模式（'''），並可加入註解。

#!python3
import re

s = '1976-7-6 2017-1-7'
print(re.compile(r'''
((19|20)\d\d # 年
-
[0-1]?\d # 月
-
[0-3]?\d) # 日
''', re.VERBOSE).findall(s))
# [('1976-7-6', '19'), ('2017-1-7', '20')]

---
---
---

Python 執行檔

2017-06-02T06:11:00.000+08:00

指定 Python 版本

由於可以同時安裝多個版本的 Python，因此 Python 須指名使用的 Python 版本。

在 Windows 上，每個 Python 檔案都要加上以下的檔頭，表示使用 Python 3。

#!python3

而在 Linux 上，則是加上以下的檔頭。

#!/usr/lib/python3

這是從命令提示字元下執行 Python 檔案才需要指定版本的檔頭，如果是從 IDLE 或者直接執行 python.exe，就不需要指名版本，因為已經在特定版本的 Python 環境裡了。

hello.py

#!python3
print('Hello Python!')

之前都是用 python.exe 執行 py 檔，加上檔頭後可以改用 py.exe 執行 py 檔，py.exe 的特色在於會讀取 #! 並使用對應的 Python 版本來執行。

D:\_Work\python361>py hello.py
Hello Python!

Windows 執行檔

在 Windows 可以建立 bat 來方便執行 Python。

hello.bat

@py.exe -O D:\_Work\python361\hello.py %*
@pause

-O 表示停用 aassert，可以增加一點效能，%* 表示將傳入 bat 的參數全部轉傳給 py。

在 Python 裡可以用 sys.argv 取得傳入的參數（list of str），第一個 item 永遠是 Python 檔案名稱（包含全部路徑），第二個以後的 item 才是傳入參數（如果有的話）。

hello.py

#!python3
import sys
if len(sys.argv) > 1:
    print('Hello {}!'.format(' '.join(sys.argv[1:])))
else:
    print('Hello Python!')

print(sys.argv)

D:\_Work\python361>hello.bat Neil Chan
Hello Neil Chan!
['D:\\_Work\\python361\\hello.py', 'Neil', 'Chan']
請按任意鍵繼續 . . .

D:\_Work\python361>hello.bat
Hello Python!
['D:\\_Work\\python361\\hello.py']
請按任意鍵繼續 . . .

用 pyperclip 剪貼簿取代檔案讀取

以前要處理檔案，都是在程式裡開啟檔案並讀取內容，有了剪貼簿套件，可以省略這段程式，改以更彈性的方式讀取外部內容。

clip.py

#!python3
import pyperclip
lines = pyperclip.paste()
print(lines)

複製待處理文字後，執行 Python。

D:\_Work\python361>clip.bat
顧荷包看清楚！6月新制上路
脫了馬來衫 府前憲兵換勁裝
106國中會考 落點分析 選填志願
請按任意鍵繼續 . . .

只要每次執行前複製不同的內容，就可以直接處理，而不需要修改程式或改變傳入參數，這在重複處理大量外部即時來源時，相當方便。
---
---
---

Java 腦袋學 Python OOP

2017-05-31T06:54:00.003+08:00

Python OOP 基本概念與 java 類似，但不需要預先定義 API。

class Point:
    '''This is a doc string'''

# 不需要 new 關鍵字
p = Point()
print(p) # <__main__.Point object at 0x01C5BD70>
print(p.__doc__) # This is a doc string

# 動態建立欄位
p.x = 3
p.y = 4

print('(%d, %d)' % (p.x, p.y)) # (3, 4)
import math
print(math.sqrt(p.x**2 + p.y**2)) # 5.0

init() 與 str()

當然也可以預先定義屬性（API），這裡的__init__() 就是 Java 的 constructor，並定義 __str__() 回傳的字串，也就是 Java 裡的 toString()。

class Point:
    '''This is a doc string'''
    def __init__(self, x=0, y=0): # 可以給預設值，也可以不要
        self.x = x
        self.y = y
    def __str__(self):
        return 'Point (%d, %d)' % (self.x, self.y)

p = Point() # 使用預設值
print(p) # Point (0, 0)
p.x = 3
p.y = 4
print(p) # Point (3, 4)

print(Point(1, 2)) # Point (1, 2) 使用自訂值

物件特徵

和 Java 一樣，Python 物也是 pass by reference 與 mutable。

class Point:
    '''This is a doc string'''
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y
    def __str__(self):
        return 'Point (%d, %d)' % (self.x, self.y)

p = Point()
# print(p.z) # 存取未定義的屬性會得到 AttributeError
print(hasattr(p, 'x')) # True
print(hasattr(p, 'z')) # False

# try-except
try:
    z = p.z
except AttributeError:
    z = 0
print(z) # 0

# 型別檢查
print(type(p)) # <class '__main__.Point'>
print(isinstance(p, Point)) # True

克隆

class Point:
    '''This is a doc string'''
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y
    def __str__(self):
        return 'Point (%d, %d)' % (self.x, self.y)

p = Point()
p2 = p
print(p is p2) # True
print(p == p2) # True
p.x = 5
print(p2) # Point (5, 0)

import copy
p3 = copy.copy(p) # 淺層複製

print(p is p3) # False，已經是不同物件（reference）
print(p == p3) # False，理論上應該是 True，但自訂物件預設的 == 是 is
p3.y = 10
print(p) # Point (5, 0)
print(p2) # Point (5, 0)
print(p3) # Point (5, 10)

p4 = copy.deepcopy(p) # 深層克隆

eq() 與 ==

透過自訂 __eq__() 來實做 == 的行為。

class Point:
    '''This is a doc string'''
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y
    def __str__(self):
        return 'Point (%d, %d)' % (self.x, self.y)
    def __eq__(self, other):
        return (self.x, self.y) == (other.x, other.y)

p = Point()
import copy
p3 = copy.copy(p)

print(p is p3) # False
print(p == p3) # True，透過自訂 __eq__() 來實做 == 的行為，取代預設的 is

Class and instance attributes

class Point:
    '''This is a doc string'''
    original = 0 # class attribute
    def __init__(self, x=0, y=0):
        self.x = x # instance attributes
        self.y = y
    def __str__(self):
        return 'Point (%d, %d)' % (self.x, self.y)

p = Point(3, 4)
print(p) # Point (3, 4)
print(Point.original)

Static and instance method

在 Python，method 可以同時是 static 與 instance。

class Point:
    '''This is a doc string'''
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y
    def __str__(self):
        return 'Point (%d, %d)' % (self.x, self.y)
    def print(self):
        return self.__str__()

p = Point(3, 4)
print(Point.print(p)) # Point (3, 4) static 呼叫
print(p.print()) # Point (3, 4) instance 呼叫

運算子重載 Operator overloading

只要 class 定義了 __add__()，就可以對 object 使用 +。

class Point:
    '''This is a doc string'''
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y
    def __str__(self):
        return 'Point (%d, %d)' % (self.x, self.y)
    def __add__(self, other):
        return Point(self.x + other.x, self.y + other.y)

p1 = Point(3, 4)
p2 = Point(2, 1)
print(p1) # Point (3, 4)
print(p2) # Point (2, 1)
print(p1 + p2) # Point (5, 5)

還有其他運算子重載可以定義（__sub__、__mul__、__mod__等），當然前提是情境必須「合適」。

上面的重載是算術運算子，也可以重載比較運算子，前提也是情境必須「合適」。

甚至可以針對不同型別進行運算。

class Point:
    '''This is a doc string'''
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y
    def __str__(self):
        return 'Point (%d, %d)' % (self.x, self.y)
    def __add__(self, other):
        if isinstance(other, Point):
            return Point(self.x + other.x, self.y + other.y)
        else:
            return Point(self.x + other, self.y)
    def __radd__(self, other):
        return Point(self.x, self.y + other)

p1 = Point(3, 4)
p2 = Point(2, 1)
print(p1) # Point (3, 4)
print(p2) # Point (2, 1)
print(p1 + p2) # Point (5, 5) 呼叫 __add__
print(p1 + 3) # Point (6, 4) 呼叫 __add__
print(5 + p1) # Point (3, 9) 呼叫 __radd__

甚至只要 class 定義了 __add__()，也就是支援 +，其他使用 + 的函式都可以用了，例如 sum()。

print(sum([Point(1, 2), Point(2, 3), Point(3, 4)])) # Point (6, 9)

繼承

目前只知道 method 有繼承下來，但 attribute 沒有，也不知道可不可以存取 super class 的 attribute。

class Point3D(Point):
    def __init__(self, x=0, y=0, z=0):
        self.x = x
        self.y = y
        self.z = z

p2 = Point3D(3, 4, 5)
print(p2) # Point (3, 4)

Debug or Reflection

可以使用 vars()、getattr() 與 setattr() 檢視或操作物件屬性。

p = Point(3, 4)
print(vars(p)) #{'x': 3, 'y': 4} dict of attributes and values
print(getattr(p, 'x')) # 3

setattr(p, 'x', 5)
print(getattr(p, 'x')) # 5

---
---
---

Python Module 模組

2017-05-27T05:11:00.000+08:00

任何 Python 檔案都可以作為 module 來 import。

first.py

def a():
    print('This is a from first')

直接 import 後就可以使用。

import first
first.a() # This is a from first

但是一個完整的 module 是需要附上測試程式的，可是測試程式只會在「直接」執行時使用，如果是 import，那就不要執行測試程式。

可以使用全域變數 __name__ 來判斷，到底是直接執行或者是 import。

second.py

def a():
    print('__name__ of a is ' + __name__)

if __name__ == '__main__': # 直接執行時，__name__ 是 __main__
    print('start test...')
    a()

直接執行 second.py。

start test...
__name__ of a is __main__

當作 module 來 import，__name__ 變成是 module 名稱。

import second
second.a() # __name__ of a is second

重複 import 相同的 module，Python 並不會做任何事情，也就是不會重複 impot，即使 module 已經經過修改，但可以用 reload() 來強迫重新 import，但有點棘手，倒不如重新啟動直譯器。
---
---
---

Python 呼叫外部程式

2017-05-26T16:03:00.001+08:00

一分鐘結束。

import os

# 一次讀取所有結果
p = os.popen('dir')
print(p.read()) # 回傳全部
print(p.close()); # 回傳 None 表示正常結束

# 逐行讀取
p = os.popen('dir')
line = p.readline()
while line:
    print(line, end = '')
    line = p.readline()
print(p.close()); # 回傳 None 表示正常結束

---
---
---

Python 套件 - 簡易資料庫 dbm 與醃漬工具 pickle

2017-05-26T07:01:00.000+08:00

dbm

dbm 和 dict 很像，都是用 key-value pair。

import dbm

# c 表示有則用，沒有則新增
# 在目前工作目錄產生 foods.bak、foods.dat 與 foods.dir 三個檔案
db = dbm.open('foods', 'c')

# 新增一筆資料
db['apple'] = '蘋果' # insert

# value 為 bytes 物件，要 decode 成字串
print(db['apple']) # b'\xe8\x98\x8b\xe6\x9e\x9c'，bytes 物件
print(db['apple'].decode('utf-8')) # 蘋果

# 用已存在的 key 表示更新
db['apple'] = '小蘋果' # update

# 用完要關
db.close()

dbm 的 key 與 value 都必須是字串或是 bytes 物件。

import dbm
db = dbm.open('foods', 'c')
db['banana'] = '香蕉'
db['durian'] = '榴槤'
# db[86] = '芭樂' # keys must be bytes or strings
# db['basket'] = [ 'Pear', 'Tomato'] # values must be bytes or strings
db.close()

dbm 沒有 keys() 與 items()，但可以用 for-in，只是透過 for-in 拿到的 key 與 value 都是 bytes 物件。

import dbm
db = dbm.open('foods', 'c')
for key in db:
    print('%s > %s' % (key.decode('utf-8'), db[key].decode('utf-8')))
    # apple > 小蘋果
    # banana > 香蕉
    # durian > 榴槤
db.close()

pickle

如果 value 只能是字串，那 dbm 就用處不大了，但可以透過另一個套件 pickle，將任意型別「醃漬」成 bytes 物件。

import dbm
import pickle

db = dbm.open('foods', 'c')

# dumps 表示 dump 成 string
db['basket'] = pickle.dumps([ 'Pear', 'Tomato'])
db.close()

db = dbm.open('foods', 'c')
print(db['basket']) # b'\x80\x03]q\...
# print(db['basket'].decode('utf-8')) # UnicodeDecodeError

# loads 表示 load string
print(pickle.loads(db['basket'])) # ['Pear', 'Tomato']
db.close()

從 pickle 還原的物件，已經不是原來那個物件（reference），是一個複製品。

import pickle
t1 = [ 'Pear', 'Tomato']
b = pickle.dumps(t1)
t2 = pickle.loads(b)
print(t1) # ['Pear', 'Tomato']
print(t2) # ['Pear', 'Tomato']
print(t1 == t2) # True
print(t1 is t2) # False

---
---
---

Java 腦袋學 Python File

2017-05-26T05:59:00.000+08:00

一分鐘入門。

fout = open('d:/a.txt', 'w') # w 表示新建或覆蓋
print(fout.write('Hello Python' + '\n')) # 13，write() 回傳寫入字元數
print(fout.write('Python 你好' + '\n')) # 10，必須手動加上換行
fout.close() # 否則直到程式結束才會關閉

fout = open('d:/a.txt', 'a') # a 表示 append
print(fout.write('Python 吃飽沒' + '\n')) # 11
fout.close()

fin = open('d:/a.txt')
for line in fin:
    print(line, end='') # 因為內文已有換行，print 不需要再換行
# Hello Python
# Python 你好
# Python 吃飽沒

三分鐘進階。

fout = open('a.txt', 'w') # 使用相對路徑，相對於目前工作目錄
print(fout.write('Hello Python' + '\n'))
fout.close()

import os

# 取得目前工作目錄，預設為 py 檔所在位置
print(os.getcwd()) # D:\_Work\python361

# 取得絕對路徑，該檔案不必存在
print(os.path.abspath('b.txt'))

# 判斷檔案或資料夾是否存在
print(os.path.exists('a.txt')) # True
print(os.path.exists('b.txt')) # False
print(os.path.exists('Scripts')) # True

# 判斷是否為檔案或資料夾
print(os.path.isdir('a.txt')) # False
print(os.path.isfile('a.txt')) # True
# 檔案不必存在，一律回傳 False
print(os.path.isdir('b.txt')) # False
print(os.path.isfile('b.txt')) # False

# 列出指定目錄下所有檔案與資料夾，可指定目錄，預設為目前工作目錄
t = os.listdir()
for d in t:
    print(d) # 檔案或資料夾名稱
    
    # 取得完全路徑（包含檔案與資料夾名稱）
    print(os.path.join(os.getcwd(), d))

不同作業系統間的換行符號，得自行手動處理，Python 沒有幫處理。
---
---
---

Python 字串格式化（套用變數）

2017-05-25T23:14:00.001+08:00

Python 字串格式化就像是 Hibernate 的 HQL 語法中，用 ? 或者 :name 表示 place holder，稍後可以帶入變數，HQL 的好處是可以改進效能與防止 SQL Injection，Python 字串格式化則是可以簡化靜態字串與變數的串接，並格式化變數。

來到 3.6 版，Python 已經有三種字串格式化的方法。

printf-style：由於對 tuple 與 dict 支援不夠，建議使用另外兩種方法。
Formatted string literal：3.6 版新增。
str.format()：最強的字串格式化。

printf-style

官方文件

整數後加上 % 是求餘數，字串後加上 % 是格式運算子 Format Operator。

% 前是包含 Conversion specifier 的待格式化字串，% 後是用來取代 Conversion specifier 的變數，視情況可以使用單一變數、tuple 與 dict。

print('I have %d books.' % 3) # I have 3 books.，可以使用單一變數也可以使用一個 item 的 tuple

print('In %d months, I have read %d books.' % (3, 10))
# In 3 months, I have read 10 books.

print('In %(months)d months, I have read %(books)d books.' % {'months':3, 'books':10})
# In 3 months, I have read 10 books.

變數的數量要對，格式也要對，不然會報錯。

Conversion specifier 由兩個以上字元組成，組成解析如下。

第一個字元是 %，表示從靜態字串進入 Conversion specifier 宣告
非必要的 Mapping key，由小括號和字串組成，例如 (months)，當 % 後是 dict 時，就必須使用 Mapping key
非必要的 Conversion flags，用來設定某些 Conversion type 的輸出
非必要的最小字串長度，直接指名長度或者使用 *，改由 tuple 第一個 item 指定
非必要的精確度，必須接在 . 之後，精確度包括整數與小數，直接指名精確度或者使用 *，改由 tuple 第一個 item 指定
非必要的 Length modifier，可以使用 h、l 或 L，但沒有任何用處，被 Python 略過
Conversion type

只有第一個 % 字元和最後一個 Conversion type 是必要，語法與 Format Specification Mini-Language 非常雷同，請參考下方說明。

可以在 Conversion specifier 指定最小字串長度。

print('I have %5d books.' % (105))    # I have   105 books.，直接指名長度
print('I have %*d books.' % (5, 10))  # I have    10 books.，使用 * 表示從 tuple 第一個 item 指定
print('I have %*d books.' % (5, 105)) # I have   105 books.，使用 * 表示從 tuple 第一個 item 指定

print('I have %05d books.' % (105))    # I have 00105 books.，可以在長度前加上 Padding 字元
# print('I have %*d books.' % (05, 10))  # 語法錯誤 05，Padding 字元 不可以放在 tuple 裡 
print('I have %0*d books.' % (5, 10))  # I have 00010 books.

可以在 Conversion specifier 指定 Conversion flags。

# 號：有點複雜
數字 0：可以在數值前面加上 Padding 0
- 號：靠左對齊，右邊留白，可以用在字串與數值上
空白：Padding
+ 號：靠右對齊，左邊留白，用在字串上

print('I have %05d books.' % (105))    # I have 00105 books.，可以在長度前加上 Padding 0
# print('I have %*d books.' % (05, 10))  # 語法錯誤 05，0 是 Conversion Flag，不可以放在 tuple 裡 
print('I have %0*d books.' % (5, 10))  # I have 00010 books.

# 使用 0 或空白 padding
print('I have %05d books.' % (105))    # I have 00105 books.
print('I have % 5d books.' % (105))    # I have   105 books.

# 使用 - 號
print('I have %-5d books.' % (105))    # I have 105   books. 靠左對齊
print('I have %-05d books.' % (105))   # I have 105   books. - 號蓋過數字 0
print('I have %- 5d books.' % (105))   # I have  105  books. 置中對齊？

# 使用 + 號
print('I read %+10s.' % ('Python'))     # I read     Python.
print('I read %+ 10s.' % ('Python'))    # I read     Python.
print('I read %+010s.' % ('Python'))    # I read     Python.

print('I read %-10s.' % ('Python'))     # I read Python    .
print('I read %- 10s.' % ('Python'))    # I read Python    .
print('I read %-010s.' % ('Python'))    # I read Python    .

可以在 Conversion specifier 指定精確度，必須接在 . 之後，精確度包括整數與小數。

print('A precise number [%.6g]' % (123.45)) # A precise number [123.45]
print('A precise number [%.5g]' % (123.45)) # A precise number [123.45]
print('A precise number [%.4g]' % (123.45)) # A precise number [123.5]
print('A precise number [%.3g]' % (123.45)) # A precise number [123]
print('A precise number [%.2g]' % (123.45)) # A precise number [1.2e+02]
print('A precise number [%.1g]' % (123.45)) # A precise number [1e+02]
print('A precise number [%.0g]' % (123.45)) # A precise number [1e+02]
print('A precise number [%.*g]' % (4, 123.45)) 
# A precise number [123.5]，使用 * 表示從 tuple 第一個 item 指定

Conversion type，以下列出可能會用到的，其他的請看官方文件。

d：包括正負號的十進位整數
i：同 d
u：同 d，已改用 d
o：包括正負號的八進位
x：包括正負號的十六進位（小寫）
X：包括正負號的十六進位（大寫）
e：指數顯示浮點數（小寫）
E：指數顯示浮點數（大寫）
f：十進位浮點數
F：同 f
g：類似 e
G：類似 E
c：單一字元，可用整數或單一字元的字串
r：字串，透過 repr() 轉換成字串
s：字串，透過 str() 轉換成字串
a：字串，透過 ascii() 轉換成字串
%：就是顯示 %

Formatted string literal

官方文件

就像一般的字串表示式一樣，只是在單引號或雙引號前面加上 f 或者 F（Raw 字串是加上 r），字串裡的變數用大括號，就可以直接取用當下 scope 的變數，不用再透過 % 餵變數進去。

books = 3
print('I have {books} books.') # I have {books} books.
print(f'I have {books} books.') # I have 3 books.
print(F'I\thave\t{books}\tbooks.') # I have 3 books.，Escape 字元都可以用
print(f'I have {books} {{books}}.') # I have 3 {books}. 用 {{ 與 }} Escape { 與 }

可以同時使用 f 與 r（Raw 字串），也可以在 f 裡使用續行符號，也就是說除了解析 {變數} 外，就是一般的字串。

print(rf'I\thave\t{books} books.') # I\thave\t3\tbooks.，可以同時使用 r 讓 Escape 字元失效
print(f'I\thave\t{books} \
books.') # I have 3 books.，也可以使用續行符號

用 f 標示的字串稱為 f_string，f_string 由三部份組成，不一定都要有。

一般字串
由大括號組成的 replacement_field
用 {{ 與 }} Escape { 與 }

replacement_field 的語法如下。

{
f_expression
!conversion：非必要
:format_spec：非必要
}

f_expression 最複雜，留到最後看，先看 conversion 的組成。

!
s 或 r 或 a：分別表示 str()、repr() 與 ascii()，也就是將前面的 f_expression 結果丟到這三個函式裡，再將結果輸出。

goods = 'books'
print(f'I have 3 {goods}.') # I have 3 books.
print(f'I have 3 {goods!r}.') # I have 3 'books'.
print(f'I have 3 {repr(goods)}.') # I have 3 'books'. 結果和 !r 一樣

比較令人驚嚇的是在 f_expression 呼叫了函式。

再看 format_spec 組成，這個也很複雜，詳細文件在這，format_spec 不只用在這裡，也可以用在第三個字串格式化 str.format，以及內建函式 format() 裡，這裡先舉簡單的例子，下面在 str.format() 之後也有進一步的研究。

冒號 : 後面表示 format_spec，10 為 width，4 為 precision。

print(f"Result: {12.3456789:10.4}") # Result:      12.35

f_expression 可以做的事很多，有些我還看不懂，以下列出我現在了解的。

f_expression 可以使用 list 與 dict。

books = '123'
print(f'I have {books[2]} books.') # I have 3 books.

d = { 'm': 'Magazine', 'b': 'Book' }
print(f'I have 1 {d["m"]}.') # I have 1 Magazine.

f_expression 可以呼叫函式。

books = 3
goods = 'books'
print(f'I have {books} {goods.upper()}.') # I have 3 BOOKS.

f_expression 可以使用巢狀 replacement_field，但只限一層。

print(f"Result: {12.3456789:10.4}") # Result:      12.35
value = 12.3456789
print(f"Result: {value:10.4}") # Result:      12.35
width = 10
precision = 4
print(f"Result: {value:{width}.{precision}}") # Result:      12.35

f_expression 可以使用 Conditional expression。

books = 3
print(f'I have {books} {"books" if books > 1 else "book"}.') # I have 3 books.
books = 1
print(f'I have {books} {"books" if books > 1 else "book"}.') # I have 1 book.

f_expression 不可以直接使用反斜線 \，但可以透過變數傳入。

# print(f'show tab {"\t"}!') # 語法錯誤
t = "\t"
print(f'show tab {t}!') # show tab  !

最後 f_string 不可以作為 docstring，即使它沒有使用 replacement_field。

def foo():
    "docstring...."
print(foo.__doc__) # docstring....

def bar():
    """docstring...."""
print(bar.__doc__) # docstring....

def nope():
    f"docstring...."
print(nope.__doc__) # None

str.format()

官方文件1、官方文件2

str 為一般字串與由大括號定義的 replacement fields 組成，replacement fields 可以用 positional 的 index 或者 keyword 的字串定義變數，format() 傳入配合 replacement fields 定義的變數，回傳取代後的新字串。

print('The sum of {0} + {1} is {2}'.format(1, 2, 1 + 2)) # The sum of 1 + 2 is 3
print('My name is {first} {last}'.format(last="Chan", first="Neil")) # My name is Neil Chan

str.format() 與 Formatter class 使用相同的字串格式化語法，與 Formatted string literal 語法近似但不同。

str.format() 字串組成和 Formatted string literal 一樣。

一般字串
由大括號組成的 replacement_field
用 {{ 與 }} Escape { 與 }

replacement_field 的語法和 Formatted string literal 有些不一樣，從 f_expression 換成 field_name。

{
field_name：用 positional 的 index 或者 keyword 的字串定義變數
!conversion：非必要
:format_spec：非必要
}

使用 positional index 時，如果變數依照順序定義，則可以省略 index，直接使用 {}。

print('The sum of {} + {} is {}'.format(1, 2, 1 + 2)) # The sum of 1 + 2 is 3

取用 list 的 item 與物件的 attribute。

print('The food is {foods[0]}'.format(foods=['banana', 'apple'])) # The food is banana
class A:
    def __init__(self, name):
        self.name = name
    def __str__(self):
        return 'A({self.name})'.format(self=self)
print('My name is {0.name}'.format(A('Neil'))) # My name is Neil
print(A('Neil')) # A(Neil)

取用 dict 要用 ** 炸開。

# print('My name is {0.name}'.format({'name':'Neil'})) # AttributeError
# print('My name is {0['name']}'.format({'name':'Neil'})) # 語法錯誤
# print('My name is {0["name"]}'.format({'name':'Neil'})) # KeyError
# print('My name is {info["name"]}'.format(info={'name':'Neil'})) # KeyError
print('My name is {name}'.format(**{'name':'Neil'})) # My name is Neil

也可以用 * 炸開 list。

print('{} {} {}'.format(*'ABC')) # A B C

conversion 用法和 Formatted string literal 不一樣。

!
s 或 r 或 a：分別表示 str()、repr() 與 ascii()，也就是將前面的 field_name 結果丟到這三個函式裡，再將結果輸出。

print('My name is {!r}'.format('Neil')) # My name is 'Neil'

format_spec 使用方式和 Formatted string literal 完全相同，是最複雜的部份，複雜到可以獨立出來研究。

Format Specification Mini-Language

官方文件

format_spec 定義字串的輸出方式，包括寬度、對齊方向、padding 與數值精確度等。

format_spec 可以使用巢狀 replacement field（也就是 field_name、conversion 與 format_spec），但僅限一層。

format_spec 可以用在 Formatted string literal、str.format() 與內建函式 format() 裡。

format_spec 的格式選項可以用在大部份的資料型別，但部份的格式選項僅支援數值型別。

使用空字串作為 format_spec 等於將變數傳入 str() 後的結果帶入字串，其他的格式選項幾乎都會「修改」變數後帶入。

print('My name is {0:}'.format('Neil')) # My name is Neil
print('My name is {0!s}'.format('Neil')) # My name is Neil

完整的 format_spec 語法如下。

[[fill]align][sign][#][0][width][grouping_option][.precision][type]

各項設定說明如下。

fill：Padding 字元，可以使用任意字元，僅限單一字元，但在 Formatted string literal 與 str.format() 不能使用大括號（ { 和 }）。
align：對齊方式，可以使用靠左對齊 <、靠右對齊 >、置中對齊 ^ 與數值型別專用的 =。
sign：可以使用加號 +、減號 - 與空白字元。
# 與 0：用在整數與浮點數型別。
width：整數。
grouping_option：可以使用底線 _ 與逗號 , 作為千分號。
precision：整數。
type：可以使用 b、c、d、e、E、f、F、g、G、n、o、s、x、X、%

type 分成三類

字串（s）、整數（b、c、d、n、o、x、X）與浮點數（e、E、f、F、g、G、n、%）。

字串 type

字串 type 只有一個設定值 s，由於只有一個選項，s 可以當作預設值，可以省略不用。

print('My name is {0}!'.format('Neil')) # My name is Neil!
print('My name is {0:s}!'.format('Neil')) # My name is Neil!，沒有差別

由於 type 有三類，字串的預設是 s，整數預設是 d，浮點數預設是 g（類似），當不指定 type 時，如何在 s、d 與 g 中抉擇？很簡單，就是看傳進來的變數是哪一種型別，傳進來的變數是字串就用 s，是整數就用 d，是浮點數就用 g（類似）。

使用 fill、align 與 width 設定對齊方式與 Padding

當 width 大於內容長度時，才會出現 Padding ，換句話說，當 width 小於內容或沒有指定 width 時，是不會出現 Padding 的，也就是 fill 與 align 就沒有存在的意義了。

預設的 Padding 字元為空白，Padding 在數值型別和其他型別有不同的對齊行為，數值型別預設靠右對齊，其他型別預設靠左對齊。

print('My age is {0:10}!'.format(42)) # My age is         42!
print('My name is {0:10}!'.format('Neil')) # My name is Neil      !
# 10 為 width

可以使用 align 來修改對齊行為。

print('My age is {0:<5}!'.format(42)) # My age is 42   !
print('My age is {0:>5}!'.format(42)) # My age is    42!
print('My age is {0:^5}!'.format(42)) # My age is  42  !
# <、>、^ 為 align
# 5 為 width

print('My name is {0:<10}!'.format('Neil')) # My name is Neil      !
print('My name is {0:>10}!'.format('Neil')) # My name is       Neil!
print('My name is {0:^10}!'.format('Neil')) # My name is    Neil   !
# <、>、^ 為 align
# 10 為 width

可以加上 Padding 字元（fill），fill 只有在 align 存在下才能使用，換句話說，fill 一定要搭配 align 使用。

print('My name is {0:!<10}!'.format('Neil')) # My name is Neil!!!!!!!
print('My name is {0:.>10}!'.format('Neil')) # My name is ......Neil!
print('My name is {0:o^10}!'.format('Neil')) # My name is oooNeilooo!
# !、.、o 為 fill
# <、>、^ 為 align
# 10 為 width

數值型別的 sign 與 Padding

sign 為 + 時顯示正負號。

print('Max is {0:0=+5} and Min is {1:0=+5}!'.format(4, -3)) # Max is +0004 and Min is -0003!
# 0 為 fill
# = 為 align，數值型別專用的對齊設定 
# + 為 sign
# 5 為 width

sign 為 - 時僅顯示負號，不寫正號是常用的寫法，但是正數會比負數多出一個 Padding 字元。

print('Max is {0:0=-5} and Min is {1:0=-5}!'.format(4, -3)) # Max is 00004 and Min is -0003!
# 0 為 fill
# = 為 align，數值型別專用的對齊設定 
# - 為 sign
# 5 為 width

sign 可以使用空白字元來拿掉這個多出來的 Padding 字元。

print('Max is {0:0= 5} and Min is {1:0= 5}!'.format(4, -3)) # Max is  0004 and Min is -0003!
# 0 為 fill
# = 為 align，數值型別專用的對齊設定 
# 空白字元為 sign
# 5 為 width

數值型別專用的 align =

若對數值型別使用靠右對齊 > 與 Padding 字元，並顯示正負號，結果會嚇死人。

print('Max is {0:0>+5} and Min is {1:0>+5}!'.format(4, -3)) # Max is 000+4 and Min is 000-3!

應該改用 = 為對齊字元。

print('Max is {0:0=+5} and Min is {1:0=+5}!'.format(4, -3)) # Max is +0004 and Min is -0003!

使用 0 簡易且快速的設定數值型別與浮點數型別 Padding

在不設定 align 的前提下，只要在 width 前面多個 0，就可以達到 fill（0）搭配 align（=）的效果。

只用 width 的情況下，Padding 預設為空白字元。

print('Max is {0:5} and Min is {1:5}!'.format(5, -3)) # Max is     5 and Min is    -3!
print('Max is {0:5} and Min is {1:5}!'.format(5.5, -3.3)) # Max is   5.5 and Min is  -3.3!

在 width 前面多加一個 0，就可以達成漂亮的 Padding，連正負號的位置都對了。

print('Max is {0:05} and Min is {1:05}!'.format(5, -3)) # Max is 00005 and Min is -0003!
print('Max is {0:05} and Min is {1:05}!'.format(5.5, -3.3)) # Max is 005.5 and Min is -03.3!

效果如同 fill（0）搭配 align（=）。

print('Max is {0:0=5} and Min is {1:0=5}!'.format(5, -3)) # Max is 00005 and Min is -0003!
print('Max is {0:0=5} and Min is {1:0=5}!'.format(5.5, -3.3)) # Max is 005.5 and Min is -03.3!

也可以使用 sign 來控制正號顯示與否。

print('Max is {0: 05} and Min is {1: 05}!'.format(5, -3)) # Max is  0005 and Min is -0003!
print('Max is {0: 05} and Min is {1: 05}!'.format(5.5, -3.3)) # Max is  05.5 and Min is -03.3!

整數 type 與 #

Python 用 0b 前置字串（零B）表示二進位，例如 0b101 為十進位的 5，用 0o 前置字串（零歐）表示八進位，例如 0o12 為十進位的 10，用 0x 前置字串（零差）表示十六進位，例如 0x12 為十進位的 18。

整數 type 預設是 d（十進位），因此不管傳入是 N 進位，在為指定 type 或者指定 type 為 d 時，均會轉成十進位。

print('{0:}'.format(12)) # 12
print('{0:}'.format(0b10)) # 2
print('{0:}'.format(0o12)) # 10
print('{0:}'.format(0x12)) # 18

print('{0:d}'.format(12)) # 12
print('{0:d}'.format(0b10)) # 2
print('{0:d}'.format(0o12)) # 10
print('{0:d}'.format(0x12)) # 18

整數 type 可以指定 b（二進位）、o（八進位）、x（小寫的十六進位）與 X（大寫的十六進位）。

print('12 is {0:d} in base 10!'.format(12)) # 12 is 12 in base 10!
print('12 is {0:b} in base 2!'.format(12)) # 12 is 1100 in base 2!
print('12 is {0:o} in base 8!'.format(12)) # 12 is 14 in base 8!
print('12 is {0:x} in base 16!'.format(12)) # 12 is c in base 16!
print('12 is {0:X} in base 16!'.format(12)) # 12 is C in base 16!

但是直接顯示 1100、14、c 與 C，會造成誤解，這時候可以加上 #，輸出時就會自動產生相對應的前置字串了。

print('12 is {0:#d} in base 10!'.format(12)) # 12 is 12 in base 10!
print('12 is {0:#b} in base 2!'.format(12)) # 12 is 0b1100 in base 2!
print('12 is {0:#o} in base 8!'.format(12)) # 12 is 0o14 in base 8!
print('12 is {0:#x} in base 16!'.format(12)) # 12 is 0xc in base 16!
print('12 is {0:#X} in base 16!'.format(12)) # 12 is 0XC in base 16!

整數 type 另外有 c（轉成 Unicode 字元，但試不出效果來）與 n（類似 d，但加上千分號，須搭配 Locale 使用）。

整數變數也可以使用下面的浮點數 type，只是會先透過 float() 轉換成浮點數再行套用。

浮點數 type

浮點數可以分成以下三組。

e/E：以指數符號呈現浮點數，precision 預設為 6。
f/F：以固定長度顯示浮點數，precision 預設為 6。
g/G：常用格式，依照數值大小以 e/E 或 f/F 顯示，precision 預設為 6。

e/E 差別在於指數符號的大小寫。

f = 12345.6789
print('{0:e}'.format(f)) # 1.234568e+04
print('{0:E}'.format(f)) # 1.234568E+04

f/F 差別在於 nan（非數值）與 inf（無窮大）的大小寫。

print('{0:f} {0:F}'.format(12345.6789)) # 12345.678900 12345.678900
print('{0:f} {0:F}'.format(float('nan'))) # nan NAN
print('{0:f} {0:F}'.format(float('inf'))) # inf INF

浮點數另外有 n 與 % 兩種 type，n 請參考下面「為整數或浮點數加上千分號」一節，% 則是用來顯示百分比。

print('{0:%}'.format(0.12)) # 12.000000%
print('{0:.2%}'.format(0.12)) # 12.00%

浮點數 type 與 #

當變數的小數位數少於 precision 時，一般會以真實的狀況顯示，也就是少於 precision。

print('{0:g}'.format(12)) # 12，precision 預設為 6
print('{0:.4g}'.format(12)) # 12，precision 指定為 4

如果有特殊需求，一定要顯示準確的 precision，不足得零時，可以透過 # 達成。

print('{0:#g}'.format(12)) # 12.0000，precision 預設為 6
print('{0:#.4g}'.format(12)) # 12.00，precision 指定為 4

浮點數 type g 會移除結尾的零，雖然 # 可以保留結尾的零，但不是原始的狀態。

print('{0:g}'.format(12.30)) # 12.3

precision

precision 只能用在字串 type 與浮點數 type，不能用在整數 type，會報錯（ValueError: Precision not allowed in integer format specifier）。

precision 表示顯示的位數，但在 g/G 與 e/E/f/F 有不同的計算方式，在 g/G 是指所有的位數，包括整數與小數，但是在 e/E/f/F 只算小數位數。

print('g/G is {0:.5g}, f/F is {0:.5f}, e/E is {0:.5e}'.format(12.3456))
# g/G is 12.346, f/F is 12.34560, e/E is 1.23456e+01

precision 在 g/G 與 e/E/f/F 還有一個明顯的差異，在 g/G 會刪掉結尾的零，不保證顯示的位數，而 f/F 保證顯示的位數，不足的補零。

print('g/G is {0:.5g}, f/F is {0:.5f}, e/E is {0:.5e}'.format(12.34))
# g/G is 12.34, f/F is 12.34000, e/E is 1.23400e+01
print('g/G is {0:.5g}, f/F is {0:.5f}, e/E is {0:.5e}'.format(12.340000))
# g/G is 12.34, f/F is 12.34000, e/E is 1.23400e+01

precision 可以用在非數值型別，也就是字串 type，作為「最長字元數」，效果與 width 成對比。

字串比 width 寬時會完整呈現，比 width 窄時會使用 Padding，但是當字串比 precision 寬時會被截掉，比 precision 窄時則完整呈現（不會有 Padding）。

print('My name is {0:5}!'.format('Neil')) # My name is Neil !，Padding
print('My name is {0:.5}!'.format('Neil')) # My name is Neil!
print('My name is {0:5.5}!'.format('Neil')) # My name is Neil !，Padding

print('My name is {0:3}!'.format('Neil')) # My name is Neil!
print('My name is {0:.3}!'.format('Neil')) # My name is Nei!，截掉
print('My name is {0:3.3}!'.format('Neil')) # My name is Nei!，截掉

當字串同時比 width 窄（會有 Padding）與比 precision 寬時（會被截掉），會發生什麼事？先截掉再 Padding。

print('My name is {0:5.3}!'.format('Neil')) # My name is Nei  !

為整數或浮點數加上千分號

有兩種方法，簡單的是只要在 d 或 g 前面加上逗號或底線（誰用底線做千分號？）就可以了。

print('{0:,d}'.format(12345)) # 12,345
print('{0:_d}'.format(12345)) # 12_345

print('{0:,g}'.format(1234.5)) # 1,234.5
print('{0:_g}'.format(1234.5)) # 1_234.5

比較複雜的是透過 locale 與 n。

print('{0:n}'.format(12345)) # 12345，無效
print('{0:n}'.format(1234.5)) # 1234.5，無效

import locale
locale.setlocale(locale.LC_ALL, '')
print('{0:n}'.format(12345)) # 12,345，生效
print('{0:n}'.format(1234.5)) # 1,234.5，生效

官方文件說底線_可以用在 b、o、x 與 X 的千分號，但實做會報錯（ValueError: Cannot specify ',' or '_' with 'o'.）。

日期格式化

import datetime
d = datetime.datetime(2017, 6, 5, 4, 3, 2)
print('{:%Y-%m-%d %H:%M:%S}'.format(d)) # 2017-06-05 04:03:02

---
---
---

使用 Python Generator Expression 產生器

2017-05-19T05:42:00.001+08:00

Python Generator Expression 產生器很像 Python List Comprehensions，只是它是 Lazy 的。

Lazy 指的不是在建立物件時，就馬上執行所有計算並產生所有 item，而是「輪到了才計算」。

什麼叫輪到了？用 next() 或 for 呼叫時。

語法

( 加工 a 與 b for a in t1 if 符合這個條件 for b in t2 if 符合那個條件...)

和 List Comprehensions 只有一個不一樣，用小括號取代中括號。

Generator 會紀錄目前的讀取位置，只能一直往前讀，不能回頭，硬是要超過邊界會報錯。

g = (x**2 for x in range(5))
print(next(g)) # 0
print(next(g)) # 1
print(next(g)) # 4
print(next(g)) # 9
print(next(g)) # 16
# print(next(g)) # StopIteration

g = (x**2 for x in range(5))
print(next(g)) # 0
print(next(g)) # 1
for v in g:
    print(v) # 4, 9, 16

應用

g = (x**2 for x in range(5))
print(sum(g)) # 30
    
print(min(x**2 for x in range(5))) # 0
    
print(max(x**2 for x in range(5))) # 16

只有一個參數時，可以省去小括號。

官方文件
---
---
---

Python List Comprehensions - 終於找到 Map 與 Filter

2017-05-18T06:43:00.002+08:00

在 Javascript 學過這三個好用的概念：Map、Filter 與 Reduce，終於在 Python 也找到部份對應的功能。

Map 將一個 list 轉換成另一個 list，item 數不變，但每個 item 變了，就像一對一的轉換。

Filter 將一個 list 過濾成另一個 list，重點是 item 數變少了，一般狀況下 item 不會改變，可以改變是加分。

Reduce 掃過整個 list，得出單一個結果，例如累加。

這功能在 Python 叫做 List Comprehensions。

List Comprehensions

t = ['Apple', 'BANANA', 'guava']
print(t) # ['Apple', 'BANANA', 'guava']

# map，一對一轉換
print([ s.upper() for s in t ]) # ['APPLE', 'BANANA', 'GUAVA']

# filter，不只可以過濾，還可以轉換
print([ s.upper() for s in t if s.isupper()]) # ['BANANA']

# reduce，還是沒找到

語法

[ 加工 a 與 b for a in t1 if 符合這個條件 for b in t2 if 符合那個條件...]

List Comprehensions 有一個特色是變數在定義前呼叫使用。

中括號，就是一個 list 物件
處理變數，表示要回傳什麼
for 變數 in 某個 sequence 或 iterable，可以有 N 個 for，就會有 N 個變數
if 符合某個條件，可以有 N 個 if

效能比 for 好，但較難除錯。

範例

可以回傳複雜的物件。

print([ (x, x**2) for x in range(5) ]) 
# [(0, 0), (1, 1), (2, 4), (3, 9), (4, 16)]

可以使用多個變數（for）。

print([ (x, y) for x in range(3) for y in range(3) if x != y])
# [(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)]

甚至使用多個條件（if）。

print([ (x, y) for x in range(4) if x % 2 == 0 for y in range(4) if y % 2 == 1]) 
# [(0, 1), (0, 3), (2, 1), (2, 3)]

說穿了這些功能都可以用 for 作到，包括 Reduce，但簡潔的語法看起來就比較厲害一點。

官方文件
---
---
---

使用 Python Counter 計數器

2017-05-17T06:46:00.001+08:00

Python Counter 為 dict 的 subclass，key 的限制不變，value 固定為 int，用來統計 key 的出現次數，或者說是 key 被放入的次數。

from collections import Counter

c = Counter('Apple')
print(sorted(c.items())) # [('A', 1), ('e', 1), ('l', 1), ('p', 2)]

c['A'] += 1
print(sorted(c.items())) # [('A', 2), ('e', 1), ('l', 1), ('p', 2)]

c['A'] = -5 # 可以使用負數
print(sorted(c.items())) # [('A', -5), ('e', 1), ('l', 1), ('p', 2)]

print(c['X']) # 0，遇到不存在的 key 回傳 0

建立 Counter

有許多方式可以建立 Counter。

用 value 為 int 的 dict。

from collections import Counter
c = Counter({ 'apple': 3, 'banana': 5})
print(sorted(c.items())) # [('apple', 3), ('banana', 5)]

用 Keyword argument 建立 Counter。

from collections import Counter
c = Counter(apple=3, banana=5)
print(sorted(c.items())) # [('apple', 3), ('banana', 5)]

用 list 建立 Counter，加總重複的 item。

from collections import Counter
c = Counter(['apple', 'banana', 'apple'])
print(sorted(c.items())) # [('apple', 2), ('banana', 1)]

用 set 建立 Counter。

from collections import Counter
c = Counter({'apple', 'banana', 'apple'})
print(sorted(c.items())) # [('apple', 1), ('banana', 1)]

將 Counter 變成 Bag

利用 Counter.elements() 可以得到一袋的 item。

from collections import Counter
c = Counter({ 'apple': 2, 'banana': 3})
print(sorted(c.items())) # [('apple', 2), ('banana', 3)]
print(sorted(c.elements())) # ['apple', 'apple', 'banana', 'banana', 'banana']

取得出現頻率最高的 item

利用 Counter.most_common(N) 可以得到出現頻率前 N 大的 item。

from collections import Counter
c = Counter('azsxszaaxsaszasa')
print(sorted(c.items())) # [('a', 6), ('s', 5), ('x', 2), ('z', 3)]
print(c.most_common(2)) # [('a', 6), ('s', 5)]

Counter 減去 Counter

有兩個方式可以執行 Counter 減 Counter，使用運算子 - 與 Counter.subtract()，但要小心運算子 - 是回傳新的 Counter，而 Counter.subtract() 是修改原 Counter 物件，並回傳 None。

from collections import Counter
c1 = Counter('azsxszaaxsaszasa')
c2 = Counter('sxszaxsa')
print(sorted(c1.items())) # [('a', 6), ('s', 5), ('x', 2), ('z', 3)]
print(sorted(c2.items())) # [('a', 2), ('s', 3), ('x', 2), ('z', 1)]
c3 = c1 - c2;
print(sorted(c3.items())) # [('a', 4), ('s', 2), ('z', 2)]
c2.subtract(c1);
print(sorted(c2.items())) # [('a', -4), ('s', -2), ('x', 0), ('z', -2)]

官方文件
---
---
---

用 Python defaultdict 解決 Dict key 不存在的問題

2017-05-17T06:05:00.000+08:00

每次要取用 dict 時，得先檢查 key 是否存在，否則會得到 KeyError，雖然有 setdefault() 與 getdefault() 可以緩解症狀，但還是不夠直覺且有一點點的效能浪費。

常常忘記要檢查

每次取用前得先用 setdefault() 確認，不夠直覺，容易忘記。

# setdefault with int()
d = dict()

for c in 'Apple':
    d.setdefault(c, 0)
    d[c] += 1

print(d) # {'A': 1, 'p': 2, 'l': 1, 'e': 1}

可能沒必要的呼叫

就算 key 已經存在，還是會執行一次 [] 產生一個空的 list，效能浪費了。

# setdefault with list()
s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]

d = dict()

for k, v in s:
    d.setdefault(k, []).append(v)

print(sorted(d.items())) # [('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]

defaultdict 來簡化

用 defaultdict 來簡化使用的過程，只要在建立 dict 時（事實上是 defaultdict）傳入 key 不存在時，用來建立 key 對應的 value 的函式即可。

defaultdict() 回傳的是 dict 的 subclass，擁有 dict 所有的功能。

# defaultdict with int()
from collections import defaultdict
d = defaultdict(int) # 表示 int()，傳入函式名稱，並未呼叫執行

for c in 'Apple':
    d[c] += 1 # 一旦遇到 key 不存在時，就會呼叫 int() 產生預設值並存入 dict 中

print(d) # defaultdict(<class 'int'>, {'A': 1, 'p': 2, 'l': 1, 'e': 1})

defaultdict 來救效能

只有 key 不存在時才會呼叫 list()。

# defaultdict with list()
s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
from collections import defaultdict
d = defaultdict(list) # 表示 list()，傳入函式名稱，並未呼叫執行

for k, v in s:
    d[k].append(v)

print(sorted(d.items())) # [('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]

dict of sets 也是常用的功能。

# defaultdict with set()
s = [('red', 1), ('blue', 2), ('red', 3), ('blue', 4), ('red', 1), ('blue', 4)]
from collections import defaultdict
d = defaultdict(set)

for k, v in s:
    d[k].add(v)

print(sorted(d.items())) # [('blue', {2, 4}), ('red', {1, 3})]

官方文件
---
---
---

用 Python namedtuple 快速定義 class

2017-05-17T05:27:00.001+08:00

在 Python 定義一個 class，需要一些囉唆的基本工作。

class Book:
    def __init__(self, title, author):
        self.title = title
        self.author = author
    def __str__(self):
        return 'Book(title=\'' + self.title +'\', author=\'' + self.author + '\')'

b = Book('Python Vol.2', 'Jet')
print(b) # Book(title='Python Vol.2', author='Jet')
print(b.title, b.author) # Python Vol.2 Jet

透過 namedtuple 來定義一個 class 只要一行 code，而且可以用 [N] 取用欄位。

Book = namedtuple('Book', ['title', 'author'])

b = Book('Python Vol.3', 'Swan')
print(b) # Book(title='Python Vol.3', author='Swan')
print(b.title == b[0]) # True
print(b.author == b[1]) # True
t, a = b
print(t, 'by', a) # Python Vol.3 by Swan

也可以透過繼承來增加自訂的 method。

class Ebook(Book):        
    def format(self):
        return self.title + ', ' + self.author

b = Ebook('Python Vol.4', 'Queen')
print(b) # Ebook(title='Python Vol.4', author='Queen')
print(b.format()) # Python Vol.4, Queen

但有一些限制。

最大的一點是 immutable，因為 namedtuple 是建立一個 tuple 的 subclass，所以在建立後不能改值。
就算是透過繼承，也不能再增加新的欄位定義。

官方文件
---
---
---

Java 腦袋學 Python Set

2017-05-17T00:13:00.003+08:00

Python Set 概念上和 Java Set 一樣。

無序
唯一（去重複）
Hashable

Hashable 保證唯一，同時讓 set 和 list 比起來，新增快，查找快，常用 set 來去除 sequence 中重複的 item，或者檢查 item 是否存在。

Set 的 item 必須是 Hashable，像 dict 的 key 一樣，也就表示 set 的 item 必須是 immutable，所以不可以把 set 裝到 set 裡，目前知道 immutable 的集合物件只有 tuple 一個，很快就會出現另一個了，像 tuple 是 immutable 的 list 一樣，set 也有 immutable 的版本。

set() & {}

語法類似半套的 dict，用大括號，但只有 key，沒有 value。

s = {'a', 'A', 'a'}
print(s) # {'A', 'a'}

比較常用其他 sequence 來建立 set，同時去除重複。

s = 'Pineapple & Apple'
li1 = list(s)
print(len(li1)) # 17
print(li1) # ['P', 'i', 'n', 'e'...
print(sorted(li1)) # [' ', ' ', '&', 'A'...
s1 = set(s)
print(len(s1)) # 10
print(s1) # {'P', ' ', 'p', 'a', '&', 'A', 'l', 'i', 'e', 'n'}
print(sorted(s1)) # [' ', '&', 'A', 'P', 'a', 'e', 'i', 'l', 'n', 'p']

可以使用所有 sequence 和順序無關的操作，例如 len() 與 for-in，但是不能用 [N] 或者 slice。

set 的 method

除了使用 set() 與 {} 建立 set 外，也可以使用 set.add() 與 set.remove() 操作 set 裡的 item。

s1 = set('Apple')
print(s1) # {'p', 'A', 'l', 'e'}

s1.add('E')
print(s1) # {'E', 'p', 'e', 'l', 'A'}

s1.remove('p')
print(s1) # {'e', 'E', 'A', 'l'}
# s1.remove('X') # KeyError

s1.discard('X') # 同 remove() 但不存在不會報錯

print(s1.pop()) # e，任意丟出一個，如果 set 空了會丟出 KeyError

s1.clear() # 清空
print(s1) # set()

set item 比對

print('A' in set('Apple')) # True
print('p' not in set('Apple')) # False

print(set('Apple').isdisjoint(set('Banana'))) # True，兩個 set 沒有相同的 item，也就是交集為空

# 子集
print(set('Apple').issubset(set('Apple'))) # True，s <= other
print(set('Apple').issubset(set('PineApple'))) # True，s < =other
print(set('Apple') == set('Apple')) # True
print(set('Apple') <= set('PineApple')) # True

# 超集
print(set('PineApple').issuperset(set('Apple'))) # True，s >= other
print(set('PineApple') > set('Apple')) # True，s >= other

# 聯集
u1 = set('PineApple').union(set('Apple'))
u2 = set('PineApple') | set('Apple')
print(u1 == u2) # True
print(u1) # {'i', 'P', 'n', 'A', 'p', 'l', 'e'}

# 交集
u1 = set('PineApple').intersection(set('Apple'))
u2 = set('PineApple') & set('Apple')
print(u1 == u2) # True
print(u1) # {'p', 'e', 'l', 'A'}

# 差集
u1 = set('PineApple').difference(set('Apple'))
u2 = set('PineApple') - set('Apple')
print(u1 == u2) # True
print(u1) # {'i', 'P', 'n'}

# 對稱差集，只能一邊有，不能兩邊有，當然不會有兩邊都沒有
u1 = set('abc').symmetric_difference(set('bcd'))
u2 = set('abc') ^ set('bcd')
print(u1 == u2) # True
print(u1) # {'d', 'a'}

# 複製
s1 = set('Apple')
s2 = s1.copy()
s1.add('X')
print(s1) # {'A', 'p', 'l', 'e', 'X'}
print(s2) # {'l', 'A', 'p', 'e'}

特別的是 union()、intersection()、difference()、symmetric_difference()、issubset() 與 issuperset() 可以接受 iterable 參數，並不限制只能傳 set，但是相對應的運算子（==、>、>=、<、<=、!=、|、&、-、^、）就只能 set 對 set。

還有一點特別要注意的，並沒有 set + set 運算子，兩個 set 相加只能用 | 或者 union()。

frozenset() - immutable set

唯讀的 set，上面所有唯讀的操作都可以使用，也可以用在 dict 的 key，以及 set of frozenset。

print(frozenset('Apple')) # frozenset({'l', 'p', 'e', 'A'})

官方文件。
---
---
---

Java 腦袋學 Python Zip（與 enumerate()）

2017-05-15T06:48:00.000+08:00

Zip 又是一個對 Java 陌生的概念。

Zip 可以接受兩個以上的 sequence，然後回傳一個 iterator of tuple，像拉鍊一樣把 sequence 裡每個 item 鍊在一起變成一個 tuple，以最短的 sequence 為準。

z = zip('Python', range(3))
print(z) # <zip object at 0x03D47AD0>
for t in z:
    print(t)
# ('P', 0)
# ('y', 1)
# ('t', 2)

zip 回傳的 zip 物件是一個 iterator 物件，可以用 for-in 讀取每個 item（tuple），不同於 list-like 的地方在於不能用中括號 [N] 讀取指定的 item，也不可以用 list() 轉成 list物件，list() 吃的是 iterable 物件，不是 iterator 物件。

可以搭配多重指定（Tuple assignment）與 for-in 來讀取 Zip 物件。

z = zip('Python', range(9))
for a, b in z:
    print(a, b)
# P 0
# y 1
# t 2
# h 3
# o 4
# n 5

enumerate()

Python 還有一個便捷的函式可以同時取得 sequence 裡的 item 與 index。

for index, item in enumerate('Python'):
    print(index, item)
# 0 P
# 1 y
# 2 t
# 3 h
# 4 o
# 5 n

---
---
---

Python - 真值判斷（Truth Value Testing）、布林運算（Boolean Operation）與相等運算（Comparison Operation）

2017-05-12T06:06:00.001+08:00

在 Python，除了布林型別的值以外，任何物件都可以用來作為真值判斷（Truth Value Testing），而真值判斷（Truth Value Testing）可以用在於 if、while 與布林運算（Boolean Operation）中，這很重要，因為也只有這三個地方可以進行真值判斷（Truth Value Testing），最常誤用的地方是相等運算（Comparison Operation）。

真值判斷（Truth Value Testing）

以下的值在上述三個地方（if、while 與布林運算（Boolean Operation）），會被認為是 False。

None
False
整數 0 與浮點數 0.0
空的 sequence，例如空字串、空 list 與空 tuple
空的 dict
自訂 class，且__bool__() 回傳 False
自訂 class，且__len__() 回傳 0

上述以外的值則視為 True。

def t_or_f(v):
    if v:
        print(True)
    else:
        print(False)

t_or_f(None) # False
t_or_f(False) # False
t_or_f(0) # False
t_or_f(5) # True
t_or_f(0.0) # False
t_or_f(0.5) # True
t_or_f('') # False
t_or_f('A') # True
t_or_f([]) # False
t_or_f([ 'Neil' ]) # True
t_or_f(()) # False
t_or_f(( 'Neil' )) # True
t_or_f({}) # False
t_or_f({ 'name': 'Neil' }) # True

class bool_f:
    def __init__(self, v = False):
        self.v = v
    def __bool__(self):
        return self.v
t_or_f(bool_f(False)) # False
t_or_f(bool_f(True)) # True

class len_f:
    def __init__(self, v = 0):
        self.v = v
    def __len__(self):
        return self.v
t_or_f(len_f(0)) # False
t_or_f(len_f(1)) # True

布林運算（Boolean Operation）

布林運算有三個運算子。

除了 if 與 while，布林運算（Boolean Operation）是唯一可以使用真值判斷（Truth Value Testing）的地方。

def bln_and(v, x):
    if v and x:
        print(True)
    else:
        print(False)

def bln_or(v, x):
    if v or x:
        print(True)
    else:
        print(False)

def bln_not(v):
    if not v:
        print(True)
    else:
        print(False)
        
bln_and(None, False) # False
bln_or(None, False) # False
bln_and(0, 0.5) # False
bln_or(0, 0.5) # True
bln_not('') # True
bln_not([ 'Neil' ]) # False

相等運算（Comparison Operation）

相等運算有八個運算子。

>
>=：小心不要用成 =>
<
<=：小心不要用成 =<
==
!=
is：相同的物件參照，適用於 mutable object
is not：不同的物件參照，適用於 mutable object

除了 int 與 float 可以進行跨型別的相等運算，其他跨型別的相等運算一律得到 False。

運算優先權都相同，也就是遇到這八個運算子時，如果沒有括弧，就是從左算到右。

八個相等運算子的優先權都高於布林運算子。

a = 1
b = 2
print(a == b) # False
print(not a == b) # True，等於 not (a == b)
print(not (a == b)) # True
# print(a == not b) # Invalid Syntax
print(False == (not b)) # True

用來判斷物件參照的 is 與 is not，要特別小心是不是「mutable」，正常使用方式如下。

a = []
b = a
c = []
print(id(a)) # 31564344
print(id(b)) # 31564344
print(id(c)) # 31564144
print(a == b) # True，值相同
print(a is b) # True，參照相同
print(a == c) # True，值相同
print(a is c) # False，參照不同

b 參照 a 變數，所以 a 與 b 是參照同一個物件，因此 a is b。

而 c 是另外建立的，雖然內容和 a 相同（因此 a == c），但是參照不同的物件，所以 a is not c。

但是對 immutable 物件來說，Python 為了節省資源，通常會參照相同的物件，不論是如何建立的（甚至是計算或組裝的結果），只要值相同，就會使用相同的物件參照。

a = 256
b = 256
c = 250 + 6
print(id(a)) # 1362847456
print(id(b)) # 1362847456
print(id(c)) # 1362847456
print(a == b) # True
print(a is b) # True
print(a is c) # True
a = 'Hello'
b = 'Hello'
c = 'He' + 'llo'
print(id(a)) # 32444640
print(id(b)) # 32444640
print(id(b)) # 32444640
print(a == b) # True
print(a is b) # True
print(a is c) # True

因此 is 與 is not 只適用於 mutable 物件的「參照」比對，若是「值」的比對，不管是 mutable 或者 immutable，都適用其他六個相等運算子（>、>=、<、<=、==、!=）。

x = 6
y = 7
z = 7
print(x < y) # True
print(y <= z) # True
print(x < y and y <= z) # True
print(x < y <= z)  # True, 最不可思議的語法

同一個 class 的不同 instance 預設視為不相等（!=），除非 class 定義了__eq__。

class A:
    def a():
        pass

a1 = A()
a2 = A()
print(str(a1) + ' - ' + str(id(a1))) # <__main__.A object at 0x01A2CD70> - 27446640
print(str(a2) + ' - ' + str(id(a2))) # <__main__.A object at 0x01A47690> - 27555472
print(a1 == a2) # False

class B:
    def __init__(self, name):
        self.name = name;
    def __eq__(self, other):
        return self.name == other.name
b1 = B('Neil')
b2 = B('Neil')
b3 = B('Nail')
print(str(b1) + ' - ' + str(id(b1))) # <__main__.B object at 0x0151F130> - 22147376
print(str(b2) + ' - ' + str(id(b2))) # <__main__.B object at 0x01EF1DB0> - 32447920
print(str(b3) + ' - ' + str(id(b3))) # <__main__.B object at 0x01EF1E10> - 32448016
print(b1 == b2) # True
print(b1 == b3) # False

可以依此類推，要對同一個 class 的不同 instance 進行相等運算（Comparison Operation），必須分別定義 __lt__、__le__、__gt__ 與 __ge__，當然還有前面提到的 __eq__ 以及 __ne__。

class C:
    def __init__(self, age):
        self.age = age;
    def __eq__(self, other):
        return self.age == other.age
    def __ne__(self, other):
        return self.age != other.age
    def __lt__(self, other):
        return self.age < other.age
    def __le__(self, other):
        return self.age <= other.age
    def __gt__(self, other):
        return self.age > other.age
    def __ge__(self, other):
        return self.age >= other.age
c1 = C(2)
c2 = C(2)
c3 = C(6)
print(str(c1) + ' - ' + str(id(c1))) # <__main__.C object at 0x01A3CD70> - 27512176
print(str(c2) + ' - ' + str(id(c2))) # <__main__.C object at 0x01A57690> - 27621008
print(str(c3) + ' - ' + str(id(c3))) # <__main__.C object at 0x01EF13B0> - 32445360
print(c1 == c2) # True
print(c1 == c3) # False
print(c1 >= c2) # True
print(c1 <= c2) # True
print(c1 > c3) # False
print(c2 < c3) # True
print(c1 != c2) # False
print(c2 != c3) # True

最後，不能也不需要為自訂 class 進行 is 與 is not 的自訂。

官方文件
---
---
---

Python 內建函式庫與標準函式庫

2017-05-05T10:08:00.001+08:00

內建函式庫與標準函式庫

Python 內建許多必要的函式，像是 input()、print() 與 len() 等，除此之外還有一些常用的函式庫，視需要再 import 即可，稱為標準函式庫，像是 math 或者 random。

import math
import math,random

from import

類似 Java 的 static import，一般使用 import 語法，在呼叫外部函式時，得加上函式庫名稱，但是改用 from import 後，就可以之接呼叫外部函式庫的函式，不用再加上函式庫名稱。

但實務上容易搞混，分不清這個函式是內建的或者來自某個函式庫，所以很少使用，或者只用在函式庫「路徑非常長」時。

from random import *
for i in range(10):
    print(randint(1, 5))

input()

與使用者互動的函式，等待 user 輸入並按下 Enter 後，可以取得使用者輸入的內容。

input() 回傳的是 str 型別，不管使用者輸入的內容是什麼，即使是整數，也是得到型別為 str 的值。

>>> v = input()
This is a string.
>>> v
'This is a string.'
>>> v = input()
100
>>> v
'100'
>>> v = input()
True
>>> v
'True'

另外 input() 可以接受提示字。

name = input('Please input your name:\n') # 換行輸入
print('Hello ' + name)
name = input('Please input your name: ')# 同一行輸入
print('Hello ' + name)

執行結果。

Please input your name:
Neil
Hello Neil
Please input your name: Neil
Hello Neil

print()

輸出內容，不傳入參數會輸出一空白行。

>>> print('Hello')
Hello
>>> print('')

>>> print()

print() 有兩個關鍵字參數。

end：輸出的結尾字元，預設為換行字元，可以用來取代換行為空白、逗號或者 nothing。
sep：print() 可以同時傳入 N 的參數，print() 會以空白字元串起來後再輸出

print('Apple', 'Banan', 'Pineapple', sep=', ')
# Apple, Banan, Pineapple

len()

可以傳入 str、list、tuple，否則報錯，用來取得傳入 str 的字元數或者 list 與 tuple 的 item 數。

>>> len('Hello')
5
>>> len('99.99')
5
>>> len(5)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: object of type 'int' has no len()

eval()

執行動態語法，但只能執行 expression，不能執行 statement，expression 與 statement 簡單的判斷差別就是 expression 不能有 =。

x = 1
print(globals()['x']) # 1
print(eval('x + 1')) # 2，預設在「所在環境」執行，即 global
print(eval('x + 1', globals())) # 2，指定使用預設的 global 環境執行，效果同上
# print(eval('x + 1', {})) # NameError，x 未定義
print(eval('x + 1', { 'x': 2 })) # 3，指定使用客制的 global 環境執行
g = globals();
g['x'] += 1
print(x) # 2，x 改了唷
print(eval('x + 1', g)) # 3，指定使用客制的 global 環境執行

x = 1
print(globals() == locals()) # True，在 global 環境下，global() 與 locals() 是相同的
print(locals()['x']) # 1
print(eval('x + 1', None, locals())) # 2，指定使用預設的 local 環境執行
print(eval('x + 1', None, {})) # 2，指定使用客制的 local 環境執行
print(eval('x + 1', None, { 'x': 3 })) # 4，指定使用客制的 local 環境執行
loc = locals()
loc['x'] += 1;
print(x) # 2，x 改了唷
print(eval('x + 1', None, loc)) # 3，指定使用客制的 local 環境執行

print(eval('x + 1', { 'x': 2 }, { 'x': 3 }))
# 4，同時指定 global 與 local 環境時，先從 local 再到 global 查找變數
print(eval('x + 1', { 'x': 2 }, { })) 
# 3，同時指定 global 與 local 環境時，先從 local 再到 global 查找變數

# print(eval('x = x + 1')) # SyntaxError，不能使用指定語法

exec()

執行動態語法，可以執行 statement，和 eval() 一樣可以傳入 global 與 local 環境。

x = 1
print(exec('x = x + 1')) # None
print(x) # 2 
print(exec('x + 1')) # None，都是回傳 None 唷

repr()

不是很懂的一個函式，在某些型別（str）會回傳和 str() 不一樣的字串，但某些型別（list, tuple...）卻回傳一樣的字串。

print('hello') # hello
print(repr('hello')) # 'hello'

print(['hello']) # ['hello']
print(repr(['hello'])) # ['hello']

print(('hello',)) # ('hello',)
print(repr(('hello',))) # ('hello',)

class a:
    def __init__(self):
        pass
print(a()) # <__main__.a object at 0x01FAD230>
print(repr(a())) # <__main__.a object at 0x01FAD230>

在自訂 class 回傳的也不一樣，但分別可以透過 __str__() 與 __repr__() 自訂回傳的字串。

class b:
    def __str__(self):
        return 'b'
print(b()) # b
print(repr(b())) # <__main__.b object at 0x01F0F110>

class c:
    def __str__(self):
        return 'c.str'
    def __repr__(self):
        return 'c.repr'
print(c()) # c.str
print(repr(c())) # c.repr

目前理解是 str() 回傳的是給人看的字串，repr() 回傳的是給直譯器（也就是 eval()）讀的字串。

# print(eval('hello')) # NameError: name 'hello' is not defined
print(eval(repr('hello'))) # hello

print(eval("['hello']")) # ['hello']
print(eval(repr("['hello']"))) # ['hello']

any() & all()

傳入 Iterable 物件，使用真值判斷，只要一個為真，any() 回傳 True，必須全部為真，all() 才會回傳 True。

print(any([ 0, 0.0, False, ''])) # False
print(any([ 0, 0.0, False, 'A'])) # True
print(any([ ])) # False

print(all([ 0, 0.0, False, ''])) # False
print(all([ 1, 1.5, True, 'A'])) # True
print(all([ ])) # True

但是 any() 與 all() 對空集合有不同的反應，至少要一個為真的 any() 回傳 False，而全部要為真的 all() 卻回傳 True。

官方文件

數學函式庫 math

在使用任何內建以外的函式庫前要先 import，接下來就可以使用該函式庫名稱加上「點」語法，就可以呼叫函式庫內的函式（function）。

>>> import math
>>> math
<module 'math' (built-in)>
>>> math.pi
3.141592653589793
>>> math.sqrt(2)
1.4142135623730951

隨機函式庫 random

官方文件。

import random
print(random.random()) # 0 <= x < 1
print(random.randint(5, 10)) # 5 <= x <= 10，比較特別是包括 10
print(random.choice(tuple('Python'))) # P ~ n，直接丟 sequence 進去，就不用管 index 了

最常用的為 random.randint(start, end)，start 與 end 都是包含的。

import random
fruits = ['Apple', 'Banana', 'Tomoto']
for i in range(3):
    print(fruits[random.randint(0, len(fruits)-1)])

系統函式庫 sys

sys.exit() 可以提前結束程式，Ctrl + C 是從外部結束程式，sys.exist() 是從程式內部發起的，一般是搭配條件判斷決定是否提前結束。

---
---
---

Python 小烏龜（Turtle）

2017-05-05T01:10:00.000+08:00

我的老天啊，怎麼又會遇到這隻可愛的小烏龜！

Python 提供 turtle 繪圖功能來建立影像。

import turtle
turtle.forward(50)
turtle.left(120)
turtle.forward(50)
turtle.left(120)
turtle.forward(50)

turtle.penup()
turtle.forward(50)

turtle.pendown()
turtle.forward(50)
turtle.left(120)
turtle.forward(50)
turtle.left(120)
turtle.forward(50)
turtle.right(120)

turtle.penup()
turtle.forward(100)
turtle.right(60)

turtle.pendown()
turtle.forward(50)
turtle.right(120)
turtle.forward(50)
turtle.right(120)
turtle.forward(50)

想像在烏龜尾巴綁一枝筆，然後可以控制烏龜前進（forward）、後退（back）、右轉（right)、左轉（left）、抬起尾巴（penup，不會劃線）、放下尾巴（pendown，劃線）、、、等許多動作。

Koch 曲線

畢業三百年後又遇到您了，有興趣的可以先看這裡！

def draw(t, length, loop):
    leng = length / 3;
    if loop == 0:
        return
    elif loop == 1:
        dr(t, length)
        return
        
    if loop == 2:
        dr(t, leng)
    else:
        draw(t, leng, loop-1)
    t.left(angle)
    if loop == 2:
        dr(t, leng)
    else:
        draw(t, leng, loop-1)
    t.right(angle * 2)
    if loop == 2:
        dr(t, leng)
    else:
        draw(t, leng, loop-1)
    t.left(angle)
    if loop == 2:
        dr(t, leng)
    else:
        draw(t, leng, loop-1)
        
def dr(t, length):
    t.forward(length)
    t.left(angle)
    t.forward(length)
    t.right(angle * 2)
    t.forward(length)
    t.left(angle)
    t.forward(length)
    
import turtle
turtle.penup()
turtle.back(300)
turtle.pendown()
angle = 60
draw(turtle, length = 200, loop = 3)

簡單幾行程式就可以產生漂亮又複雜的圖案，碎形（fractal）真的是遞迴 Recursive 的極致。

angle=60, loop=1

angle=60, loop=2

angle=60, loop=3

angle=60, loop=4

angle=75, loop=3

雪花

import turtle
turtle.penup()
turtle.back(300)
turtle.left(90)
turtle.forward(200)
turtle.right(90)
turtle.pendown()
angle = 60
draw(turtle, length = 120, loop = 3)
turtle.right(120)
draw(turtle, length = 120, loop = 3)
turtle.right(120)
draw(turtle, length = 120, loop = 3)

---
---
---

刪除 Gmail 郵件後直接到下一封郵件，不要回到收件匣

2017-05-04T10:50:00.001+08:00

在閱讀一封 Gmail 內容後按下刪除或封存，Gmail 就會跳回收件匣，我就得在收件匣與下一封信件間來來回回，用的很不順手。

有可能按下刪除或封存後，直接跳到下一封郵件嗎？

在 Gmail 的基本設定中找不到這樣的功能，但是在「研究室 Lab」可以找到唷～

自動重新載入 Gmail 後，就可以用了，也可以設定刪除後的行為。

有點複雜的 Python Scope

2017-05-03T23:51:00.001+08:00

Python 的變數 scope 和 Java 的 scope 還蠻不一樣的，要特別注意。

函式的傳入參數只存在於 local scope（也可以叫做 function scope），有別於 global scope。

在函式內指定的變數為 local scope，在函式外指定的變數為 global scope，這裡的指定就是 =。

global_var = 'Neil'
def aFunction(local_var):
    another_local_var = 'Egg'
    print(global_var) # Neil
    print(local_var) # Emma
    print(another_local_var) # Egg
print(global_var) # Neil
aFunction('Emma')
print(local_var) # NameError: name 'local_var' is not defined
print(another_local_var) # NameError: name 'another_local_var' is not defined

local scope 變數在函式結束後就消失了，不能再呼叫。

在函式裡（local scope）可以使用 global scope 變數，但不能對 global scope 變數改值（使用 = ），除非使用 global 語句。

global_var = 'Neil'
def aFunction():
    print(global_var) # Neil
    global_var = 'Egg' # UnboundLocalError: local variable 'global_var' referenced before assignment
aFunction()

在函式裡直接修改 global scope 變數的值會報錯，這個錯誤（UnboundLocalError: local variable 'global_var' referenced before assignment）很奇怪，呆會再解釋。

global_var = 'Neil'
def aFunction():
    global global_var
    print(global_var) # Neil
    global_var = 'Egg' # 沒報錯了
    print(global_var) # Egg
aFunction()

在函式裡先用 global 語句標注 global scope 變數，之後就可以在函式裡修改 global scope 變數的值。

接下來回頭解釋沒有使用 global 語句的那個奇怪訊息（UnboundLocalError: local variable 'global_var' referenced before assignment）。

先看一段類似的程式，沒有用 global 語句，也沒有先呼叫 global scope 變數，而是先修改 global scope 變數的值再印出來，這次就沒有報錯，奇怪吧？

global_var = 'Neil'
def aFunction():
    global_var = 'Egg'
    print(global_var) # Egg
aFunction()

了解原因後就不會覺得太奇怪。

首先，Python 允許 local scope 裡使用與 global scope「同名」的變數，這就解釋前一個範例為什麼不會報錯，因為函式裡的 global_var 根本就一個 local scope 變數，和函式外的 global_var 一點關係也沒有。

雖然說 Python 允許 local scope 裡使用與 global scope「同名」的變數，但不建議這麼做，因為這樣只會找自己麻煩。

再來就是 Python 有一個非常奇怪的行為，至少對一個 Java PG 來說是很不習慣的，那就是函式裡的任何變數指定，只要該變數沒有使用 global 語句，一律視為 local scope 變數，不管它出現的位置為何。

最後一句話最重要，Python 在一個函式裡會先去掃出所有的變數指定，先確認它是 local scope 或 global scope，然後才開始執行函式內容。

global_var = 'Neil'
def aFunction():
    print(global_var) # Neil
    global_var = 'Egg' # UnboundLocalError: local variable 'global_var' referenced before assignment
aFunction()

以上面函式為例，Python 先找到 global_var = 'Egg'，然後沒看到 global global_var，所以認定 global_var 是 local scope 變數，最後在執行函式內容時，於第一行遇到 print(global_var) 就會報錯說：等等，你不可以在指定變數前就呼叫它。

這就是那個奇怪的錯誤訊息在說的事，UnboundLocalError: local variable 'global_var' referenced before assignment，不可以在指定變數前就呼叫它。

因此如果要在函式裡使用 global scope 變數，那就在函式一開始的地方就使用 global 語句。

另外也不能使用不同 local scope 間的變數，例如在 A 函式裡呼叫了 B 函式，在 B 函式裡不能使用 A 函式的 local scope 變數，也就是 A 函式不會變成 B 函式的 global 環境，global 永遠只有一個，就是主程式所在的位置。

以下列出幾點識別變數 scope 的準則：

在函式外指定的變數，為 global scope
在函式內使用 global 語句的變數，為 global scope
在函式內指定但沒有使用 global 語句的變數，為 local scope
在函式內呼叫但沒有指定的變數，為 global scope

可以再簡化成：在函式內使用 global scope 變數時，global 語句只有在修改（重新指定）才需要，只有呼叫時不需要。

一個變數的 scope 只會屬於一種，local 或 global，不會同時兼具兩種 scope，不能在函式先把變數當成 global scope，事後又想轉成 local scope，或者想把 local scope 變數再透過 global 語句轉成 global scope 變數。

最後，有一條簡單的原則可以避免這個複雜的 scope 邏輯，就是「不要在函式裡直接呼叫 global scope 變數，改以參數的方式傳入，若有需要，再用 return 的方式回傳」。

這就是 Utility Function 的設計概念，Python 的內建函式都是這麼做的。
---
---
---

無極限的 Python Slice 語法

2017-05-03T23:11:00.001+08:00

Python Slice 就像是刀子，可以「任意切出」想要的部份，這把刀可以用在字串、list 與 tuple 這類「有序」的集合。

有序的集合

簡單舉例就是排隊，可以用第一位、第二位、、、一路指出每一個 item 的 index。

str = 'SLICE'
print(str[0]) # S
print(str[1]) # L
print(str[2]) # I

li = ['S', 'L', 'I', 'C', 'E']
print(li[0]) # S
print(li[1]) # L
print(li[2]) # I

Slice 語法

[start : stop : step]

以中括號組成，最多可以放入三個參數，每個參數都是 optional。

start：起始 index，預設為 0，包含
stop：結束 index，預設為總長度，不包含
step：進位，預設為 1

step 看似很陌生的概念，其實已經用到爛了，就是以下 Java 迴圈裡的 2，一次進 2 位的意思。

for (int i=0; i<10; i+=2) {
    // i
}

Slice 實務

直接看 code 最有感覺了。

str = 'Python'
print(str) # Python

li = list(str)
print(li) # ['P', 'y', 't', 'h', 'o', 'n']

# zero-based
print(str[0]) # P
print(li[0]) # P，是 str，不是 list 喔

# 透過起迄取得子字串，包括起，不包括迄
print(str[0:4]) # Pyth
print(li[0:4]) # ['P', 'y', 't', 'h']

# 起預設為 0，可用來取「前 n 碼」
print(str[:4]) # Pyth
print(li[:4]) # ['P', 'y', 't', 'h']

# 迄預設為總長度
print(str[4:]) # on
print(li[4:]) # ['o', 'n']

# 起迄都用預設值，就是指全部
print(str[:]) # Python
print(li[:]) # ['P', 'y', 't', 'h', 'o', 'n']

# 迄小於等於起，得空字串或 list
print(str[2:2]) # 
print(str[5:2]) # 
print(li[2:2]) # []
print(li[5:2]) # []

# 可以使用負整數，-1 表示最後一個 item，可用來取「後 n 碼」
print(str[-1]) # n
print(li[-1]) # n，是 str，不是 list 喔

# 起可以低於 0，但不會回折，而是改用 0
print(str[-10:4]) # Pyth
print(li[-10:4]) # ['P', 'y', 't', 'h']

# 迄可以超過總長度，但不會回折，而是改用總長度
print(str[0:10]) # Python
print(li[0:10]) # ['P', 'y', 't', 'h', 'o', 'n']

# 還有神奇的第三個參數，表示一次跳幾位，預設為 1 位
# 可用來取奇數或偶數 item
print(str[::2]) # Pto
print(li[::2]) # ['P', 't', 'o']
print(str[1::2]) # yhn
print(li[1::2]) # ['y', 'h', 'n']

# 神奇的第三個參數遇到負數，已瘋，表示反向
print(str[::-1]) # nohtyP
print(li[::-1]) # ['n', 'o', 'h', 't', 'y', 'P']
# 已經無法思考了！！！
print(str[::-2]) # nhy
print(li[::-2]) # ['n', 'h', 'y']

---
---
---

Python 套件 - 剪貼簿 pyperclip

2017-05-02T23:57:00.000+08:00

pyperclip 整合 Windows 的剪貼簿，可以從 Python 程式複製 copy「文字」到 Windows 的剪貼簿，也可以從 Windows 的剪貼簿貼 paste「文字」到 Python 程式裡。

目前僅支援「純文字」，不支援圖片等其他格式。

import pyperclip
pyperclip.copy('Hello') # 將 Hello 複製到 Windows 的剪貼簿
print(pyperclip.paste()) # 從 Windows 的剪貼簿取出 Hello

如果 import pyperclip 發生錯誤，可以先執行 pip install pyperclip 來安裝 pyperclip 套件。

一個有趣的應用，如果程式需要處理一份長文字，以前的作法就是在程式裡讀取檔案長文字，這裡也可以利用 pyperclip 快速的讀入長文字。

import pyperclip
''' 執行程式前，先透過 Windows 的剪貼簿將長文字複製，
再到程式裡透過 pyperclip 貼上就可以了
'''
long_str = pyperclip.paste();
# process long string...

---
---
---

安裝 Python 3rd Party Library

2017-05-02T23:38:00.002+08:00

Python 的 library 好像有幾種名字，目前還不確定這些是不是都是指一樣的東西。

Library 函式庫
Module 模組
Package 套件

所以目前可能會混用 Library 函式庫與 Package 套件。

3rd Party Library 是影響一個語言是否受歡迎的一項重要因素。

Python 的 3rd Party Library 平台在 PyPI（Python Package Index），目前已經有超過10萬個 package。

安裝套件

Python 提供了類似 Linux 套件的安裝機制，pip。

不確定 package 是否已經安裝，可以直接使用 import 指令來檢查，只要執行沒有出現任何錯誤，表示已經安裝。

import pyautogui

在程式中使用（import）尚未下載安裝的 package 時，會得到 ModuleNotFoundError。

ModuleNotFoundError: No module named 'pyautogui'

利用 Scripts/pop.exe 可以安裝或升級 package，pip 同時會下載並安裝必要的 package。

C:\Users\Neil>pip install pyautogui
Collecting pyautogui
  Downloading PyAutoGUI-0.9.36.tar.gz (46kB)
    100% |████████████████████████████████| 51kB 204kB/s
Collecting pymsgbox (from pyautogui)
  Downloading PyMsgBox-1.0.6.zip
Collecting PyTweening>=1.0.1 (from pyautogui)
  Downloading PyTweening-1.0.3.zip
Collecting Pillow (from pyautogui)
  Downloading Pillow-4.1.1-cp36-cp36m-win32.whl (1.3MB)
    100% |████████████████████████████████| 1.3MB 431kB/s
Collecting pyscreeze (from pyautogui)
  Downloading PyScreeze-0.1.9.tar.gz
Collecting olefile (from Pillow->pyautogui)
  Downloading olefile-0.44.zip (74kB)
    100% |████████████████████████████████| 81kB 1.4MB/s
Installing collected packages: pymsgbox, PyTweening, olefile, Pillow, pyscreeze, pyautogui
  Running setup.py install for pymsgbox ... done
  Running setup.py install for PyTweening ... done
  Running setup.py install for olefile ... done
  Running setup.py install for pyscreeze ... done
  Running setup.py install for pyautogui ... done
Successfully installed Pillow-4.1.1 PyTweening-1.0.3 olefile-0.44 pyautogui-0.9.36 pymsgbox-1.0.6 pyscreeze-0.1.9

C:\Users\Neil>

安裝完成後，再執行 import pyautogui 就不會出現錯誤訊息，也就是安裝成功了。

升級套件

C:\Users\Neil>pip install -U pyautogui
Requirement already up-to-date: pyautogui in d:\_work\python361\lib\site-packages
Requirement already up-to-date: pymsgbox in d:\_work\python361\lib\site-packages (from pyautogui)
Requirement already up-to-date: PyTweening>=1.0.1 in d:\_work\python361\lib\site-packages (from pyautogui)
Requirement already up-to-date: Pillow in d:\_work\python361\lib\site-packages (from pyautogui)
Requirement already up-to-date: pyscreeze in d:\_work\python361\lib\site-packages (from pyautogui)
Requirement already up-to-date: olefile in d:\_work\python361\lib\site-packages (from Pillow->pyautogui)

C:\Users\Neil>

套件衝突

在建立自己的 py 檔案時，千萬不要用已知的套件名稱，例如 math.py 或者 sys.py，如果這麼做之後又呼叫 import math, sys，這時 import 的是你自己建立的 math.py 與 sys.py，而不是 Python 內建的套件了。

可以用以下的指令查出 Python 的套件位置。

import sys
print(sys.path)
'''
[
 '...', # 目前目錄
 '...\\python361\\Lib\\idlelib',
 '...\\python361\\python36.zip',
 '...\\python361\\DLLs',
 '...\\python361\\lib',
 '...\\python361',
 '...\\python361\\lib\\site-packages']
'''

---
---
---

Java Artisan / Neil Chan

Java Lambda 初體驗，就遇到 Project Reactor 的 GroupedFlux

com.fasterxml.jackson.core 的 Jackson Annotations 2.9.3

@JsonIgnoreProperties & @JsonIgnore

Class Level - @JsonIgnoreProperties

Field Level - @JsonIgnore

特定 Java Type - @JsonIgnoreType

Filter - @JsonFilter

@JsonProperty & @JsonGetter

Include.NON_NULL

Global Level - setSerializationInclusion(Include.NON_NULL)

Class Level - @JsonInclude(Include.NON_NULL)

Field Level - @JsonInclude(Include.NON_NULL)

@JsonAnyGetter

@JsonRawValue

@JsonValue

@JsonRootName

@JsonSerialize

Java 腦袋學 Python Regular Expression

compile(), search() & findall()

快速複習 RE

指定字元

Group 分組

或 |

指定次數 ? * + { }

Greedy 貪婪模式

findall() & Group 分組

額外的參數

取代符合字串

複雜的分組

分行並註解的語法

Python 執行檔

指定 Python 版本

Windows 執行檔

用 pyperclip 剪貼簿取代檔案讀取

Java 腦袋學 Python OOP

__init__() 與 __str__()

物件特徵

克隆

__eq__() 與 ==

Class and instance attributes

Static and instance method

運算子重載 Operator overloading

繼承

Debug or Reflection

Python Module 模組

Python 呼叫外部程式

Python 套件 - 簡易資料庫 dbm 與醃漬工具 pickle

dbm

pickle

Java 腦袋學 Python File

Python 字串格式化（套用變數）

printf-style

Formatted string literal

str.format()

Format Specification Mini-Language

type 分成三類

字串 type

使用 fill、align 與 width 設定對齊方式與 Padding

數值型別的 sign 與 Padding

數值型別專用的 align =

使用 0 簡易且快速的設定數值型別與浮點數型別 Padding

整數 type 與 #

浮點數 type

浮點數 type 與 #

precision

為整數或浮點數加上千分號

日期格式化

使用 Python Generator Expression 產生器

語法

應用

Python List Comprehensions - 終於找到 Map 與 Filter

List Comprehensions

語法

範例

使用 Python Counter 計數器

建立 Counter

將 Counter 變成 Bag

取得出現頻率最高的 item

Counter 減去 Counter

init() 與 str()

eq() 與 ==