python學習筆記（一）---基礎知識

依據廖雪峯官方網站的python教程整理

#!/usr/bin/env python3      # 首行必須指明所需要的解釋器，否則無法通過./xx.py的方式執行
# -*- coding: utf-8 -*-     # 指明瞭編碼格式，否則中文無法正常輸出
# 文件名【字母/數字/下劃線】.py

# import higher


# 數據類型
def lrn_basic():
    # 輸出Python的版本
    import platform
    print(platform.python_version())

    import sys
    print(sys.version)
    print(sys.version_info)

    # python3 必須括號
    print("Hello World.")
    print("你好，Python.")

    # 依次打印每個字符串，遇到，會輸出一個空格
    print('The quick brown fox', 'jumps over', 'the lazy dog.')
    # 可打印計算結果
    print('100 + 200 = ', 100 + 200)

    # input()輸入
    print('請輸入你的名字： ')
    name = input()
    print('Hello, ', name)

    # 以#作爲註釋
    # 縮進4個空格
    # 大小寫敏感

    # 整數
    # 可處理任意大小的整數， 0x表示16進制
    print(1)
    print(2000000)
    print(-8876544)
    # 浮點數
    print(1.23e9)
    print(3.24e-19)

    # 字符串，以單引號或雙引號括起來，互相嵌套，\轉義
    print("I'm OK, \"Tommy\".")
    # 以r''表示內部的內容不轉義
    print(r"\\\\ok")
    # 以'''...'''表示多行內容
    print(''' first line.
    second line.
    third line.''')

    # 布爾值 True/False, and/or/not
    print(True and False)

    # 空值 None, 並非0,0是有意義的
    print(None)

    # 變量
    # 動態語言類型，變量類型無需定義
    a = 'ABBC'
    b = a
    a = 'XYZ'
    print(b)    # ABBC
    print(a)    # XYZ

    # 常量
    pi = 3.14159
    print(pi)

    # 地板除和除法
    print(10 / 3)  # 3.333333
    print(10 // 3)  # 3
    print(-10 // 3)  # 取比之小的最大整數 -4

    # 運算符
    '''
        算術運算符：+   -   *   /   %(取餘)   **(冪次)  //(向下取整除)
        比較運算符：==    !=  <>  >   <   >=  <=  
        邏輯運算符：and   or  not
        賦值運算符：=     +=  -=  *=  /=  %=  **=     //=
        位運算符：   &   |   ^   ~   <<      >>
        成員運算符：  in      not in
        身份運算符： is       is not        

    '''
    ll = "a"
    ls = ["a", "b", "c"]
    print(ll in ls)
    # is 用於判斷兩個變量引用對象是否爲同一個， == 用於判斷引用變量的值是否相等。
    a = [1, 2, 3, 4]
    b = a
    print(b is a)       # True
    print(b == a)       # True
    b = a[:]
    print(b is a)       # False
    print(b == a)       # True


# 字符串和編碼
def lrn_str():
    print("Output for string")
    '''
    不可變對象
    '''
    # 單行字符串可用"或'表示
    i = "Hello world."
    print(i)
    print("Hello world")

    # 轉義字符不計入字符串內
    print("I'm OK, \\Tom\\")

    # 字符串前加r表示原始字符串，不需要轉義
    print(r"I'm OK, 'Lily', \\Tom\\")

    # 字符串前加u表示Unicode編碼
    print(u"你好")
    '''
        %d 整數
        %s 字符串
        %f 浮點數
        %x 十六進制數字
    '''
    print("I'm %s" % "Hello world")
    print("I'm {0}, want to {1} ！" .format("小明", "say hello world"))


# 列表
def lrn_list():
    print("output for list")
    classes = ["T1", "T2", "T3"]
    # 長度
    print(len(classes))                 # 3
    # 索引,索引可正可負，-1從最後一個元素開始
    print(classes[-1], classes[0])      # T3 T1
    # print(classes[3])                   # IndexError: list index out of range

    # 增刪改
    classes.insert(1, "IOT")
    print(classes)                      # ['T1', 'IOT', 'T2', 'T3']
    classes.pop(1)
    print(classes)                      # ['T1', 'T2', 'T3']
    classes[1] = "IOT"
    print(classes)                      # ['T1', 'IOT', 'T3']

    # 元素可可以不同類型，可以爲list
    s = ["Tom", 1, True]
    print(s)                            # ['Tom', 1, True]
    s = ["Tom", ["ada", 12, False], True]
    print(s)                            # ['Tom', ['ada', 12, False], True]


# 元組
def lrn_tuple():
    print("Output for tuple.")

    # tuple類似list，一旦初始化後不可修改
    groups = ()  # 空tuple
    print(groups)               # ()

    # 定義tuple
    groups = ("T1", "T2", "T3")
    print(groups)               # ('T1', 'T2', 'T3')

    # 要定義只有一個元素的tuple，必須加(,)，同樣的，輸出時，print也會加
    groups = (1,)
    print(groups)               # (1,)
    # 下面的情況會被解析爲小括號，而不是tuple
    groups = (1)
    print(groups)               # 1

    # tuple中包含list
    groups = ("T1", ["IOT", "WIFI"], "T2")
    print(groups)               # ('T1', ['IOT', 'WIFI'], 'T2')
    groups[1].insert(1, "NETWORK")
    print(groups)              # ('T1', ['IOT', 'NETWORK', 'WIFI'], 'T2')


def lrn_condition():
    age = 20
    if age > 28:
        print("age is %d" % age)
        print("more than 28")
    elif age > 10:
        print("age is %d" % age)
        print("more than ten")
    else:
        print("age is %d" % age)
        print("less than ten")


# 輸入輸出
def lrn_io():
    age_s = input("birth: ")      # input返回一個string類型的值
    age = int(age_s)
    print("age is %d" % age)


# 循環
def lrn_loop():
    # for...in循環，遍歷list/tuple中的內容
    groups = ("T1", "T2", "T3")
    for group in groups:
        print(group)

    # range 函數生成0-x的數字序列， 不包括x
    # list可強制轉換爲list
    # 計算0-100的加和
    s = 0
    nums = list(range(100))
    for num in nums:
        s += num
    print(s)

    # while 循環
    s = 0
    index = 0
    while index < 200:
        index += 1            # 如果放到continue的後面，災難就發生了
        if index == 50:
            continue        # continue跳過當次循環, 總和要減去50，index=50沒有執行加和
        s += index
        if index >= 100:
            break           # break跳出當前循環，後續條件都不再執行
    print(s)


# 使用字典
def lrn_dict():
    print("Output for dict")
    '''
    在其他語言中也稱爲map，使用鍵-值（key-value）存儲，具有極快的查找速度
    dict與list相比，有以下特點：
    1. 查找和插入的速度極快，不會隨着key的增加而變慢；
    2. 需要佔用大量的內存，內存浪費多；
    3. dict內部存放的順序和key放入的順序沒有關係
    '''

    # 直接以key-value形式定義一個字典
    d = {'T1': 7, 'T2': 12, "T3": 11, 'IOT': 6}
    print(d, d['T2'])       # {'T1': 7, 'T2': 12, 'T3': 11, 'IOT': 6} 12

    # 以key=value的形式追加定義
    d["WIFI"] = 34
    print(d, d['WIFI'])       # {'T1': 7, 'T2': 12, 'T3': 11, 'IOT': 6, 'WIFI': 34} 34

    # 避免key不存在的方法
    # 先判斷後使用
    if 'WIFI' in d:
        print(d['WIFI'])
    # 使用dict的get方法
    print(d.get("NETWORK"))       # 如果不存在，返回None
    print(d.get("NETWORK", -1))   # 如果不存在，返回-1， 此處的值可以自定義


def lrn_set():
    print("Output for  set")
    '''
    set和dict類似，也是一組key的集合，但不存儲value,key不能重複
    '''
    # 定義一個set需要一個list
    s = set([1, 2, 3, 4])               # {1, 2, 3, 4}
    print(s)
    s = set([1, 2, 2, 3, 4])            # {1, 2, 3, 4}
    print(s)
    s.add(4)
    print(s)                            # {1, 2, 3, 4}
    s.remove(4)
    print(s)                            # {1, 2, 3}


# 函數定義
def lrn_func():
    print("Output for func")
    '''
        定義函數以def開頭，括號後寫形參
        參數個數不一致會報錯，但參數類型不一致需要自行檢查
        不寫return相當於return None，可簡寫爲return

    '''

    # 參數傳遞
    def my_abs(x):
        if not isinstance(x, (float, int)):             # 檢查參數類型
            raise TypeError("bad operand type")      # 觸發參數類型錯誤
        if x >= 0:
            return x
        else:
            return -x
    print(my_abs(12))
    print(my_abs(-1))
    # my_abs('a')

    # 空函數
    def my_empty():
        pass                # pass什麼都不做，保證函數可以跑通，在最初定架構的時候可以用

    my_empty()

    # 返回多個值
    def my_multi_value():
        fir = "first arg"
        sec = "second arg"
        return fir, sec
    a, b = my_multi_value()
    print(a, b)

    # 位置參數(x)
    def product(x):
        return x * x

    print(product(2))       # 2*2 =  4

    # 默認參數
    # 必選參數在前，默認參數在後
    # 當函數有多個參數時，把變化大的參數放前面，變化小的參數放後面
    # 默認參數必須指向不變對象
    def product(x, n=2):
        s = 1
        while 0 < n:
            s *= x
            n -= 1
        return s
    print("2*2 = ", product(2))                 # 2*2 =  4
    print("power(2, 3) = ", product(2, 3))       # power(2, 3) =  8

    # 可變參數*numbers，函數內部得到的是個tuple
    def calc(*nbs):
        my_s = 0
        for n in nbs:
            my_s = my_s + n
        return my_s

    print("1+2+3 = ", calc(1, 2, 3))        # 1+2+3 =  6
    print("1+2 = ", calc(1, 2))             # 1+2 =  3
    numbers = [1, 2, 3]
    print("1+2+3 = ", calc(*numbers))       # 1+2+3 =  6

    # 關鍵字參數
    # 允許你傳入0個或任意個含參數名的參數，這些關鍵字參數在函數內部自動組裝爲一個dict
    def person(name, age, **kw):    # name, age 爲位置參數， kw爲關鍵字參數
        print("name: ", name, "age: ", age, "other: ", kw)
    person("Tom", 15)                                               # name:  Tom age:  15 other:  {}
    # name:  Tom age:  15 other:  {'city': 'Shanghai', 'job': 'Engineer'}
    person("Tom", 15, city="Shanghai", job="Engineer")
    my_kw = {'city': 'Shanghai', 'job': 'Engineer'}
    # name:  Tom age:  15 other:  {'city': 'Shanghai', 'job': 'Engineer'}
    person("Tom", 15, **my_kw)

    # 命名關鍵字參數
    # 關鍵字參數定義後，調用者仍可以傳入不受限制的關鍵字參數
    # 如果要限制關鍵字參數的名字，則使用命名關鍵字參數
    # 需要一個特殊分隔符*， 其後的部分均被視爲命名關鍵字
    def person(name, age, *, city="Shanghai", job="Engineer"):
        # name, age 爲位置參數， city,job 爲命名關鍵字參數,只接受city和job作爲關鍵字參數
        # 如果不定義默認值，則city和job爲none
        print(name, age, city, job)

    person("Tom", 15, city="Shanghai", job="Engineer")
    person("Tom", 15)

    # 如果定義了可變參數，則不需要*分隔符
    def person(name, age, *args, city="Shanghai", job="Engineer"):
        print(name, age, args, city, job)

    # Tom 15 ('beijing', 'worker') Shanghai Engineer
    person("Tom", 15, "beijing", "worker", city="Shanghai", job="Engineer")

    # 組合參數
    # 參數定義的順序必須是：必選參數、默認參數、可變參數、命名關鍵字參數和關鍵字參數
    def f1(x, y, z=0, *args, **kw):
        print('x =', x, 'y =', y, 'z =', z, 'args =', args, 'kw =', kw)

    f1(1, 2, 3, 'a', 'b')       # a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}
    my_args = (1, 2, 3, 4)
    my_kw = {'d': 99, 'x': '#'}
    f1(*my_args, **my_kw)             # a = 1 b = 2 c = 3 args = (4,) kw = {'d': 99, 'x': '#'}

    # 遞歸函數
    # 函數內部調用自身
    # 使用遞歸函數需要注意防止棧溢出
    def my_sum(n):
        if 1 >= n:
            return 1
        return sum(n-1) + n

    print("1+2+3 = ", my_sum(3))   # 1+2+3 =  6

    # 解決遞歸調用棧溢出的方法是通過尾遞歸優化
    # 尾遞歸是指，在函數返回的時候，調用自身本身，並且，return語句不能包含表達式
    # 這樣，編譯器或者解釋器就可以把尾遞歸做優化，使遞歸本身無論調用多少次，都只佔用一個棧幀，不會出現棧溢出的情況
    def my_sum(n):
        return sum_iter(n, 1)

    def sum_iter(x, y):
        if 1 >= x:
            return y
        return sum_iter(x-1, x+y)

    print("1+2+3 = ", my_sum(3))   # 1+2+3 =  6


# usage
def lrn_usage():
    print("%8s  %11s  %11s" % (u"序號", u"名稱", u"說明"))
    index = 0
    for func in funcs:
        print("%8s  %11s  %11s" % (index, func[0], func[2]))
        index += 1
    return


funcs = [
    ["basic",      lrn_basic,          "基礎語法"],
    ["str",      lrn_str,          "字符串"],
    ["list",        lrn_list,         "列表"],
    ["tuple",       lrn_tuple,        "元組"],
    ["condition",   lrn_condition,    "條件判斷"],
    ["loop",        lrn_loop,        "循環"],
    ["dict",        lrn_dict,       "字典"],
    ["function",    lrn_func,        "函數"],
    # ["highorder_list",    higher.lrn_higher_list,        "高階特性"],
    # ["highorder_func",    higher.lrn_higher_func,        "高階函數"],
    ["usage",       lrn_usage,       "用法說明"]
]


# main
if __name__ == "__main__":
    cname = ""
    lrn_usage()
    while cname != "end":
        cname = input(u"請輸入所需測試的知識點序號 or end-結束，help-幫助： ")
        if "help" == cname:
            lrn_usage()
            continue
        elif "end" == cname:
            break
        cno = int(cname)
        if cno < len(funcs) - 1:
            print("%s  %11s  %11s 
" % (cno, funcs[cno][0], funcs[cno][2]))
            funcs[cno][1]()
        else:
            print(u"請輸入正確的序號")
            lrn_usage()
    print("exit normally")

更多更及時的博客更新請戳—> KingRumn