Jupyter Notebook->File->New Notebook ->python[default]
完整版->有道云筆記

一、變量與基本數據類型

1.變量

每個變量在內存中創建，都包括變量的標識，名稱和數據這些信息。每個變量在使用前都必須賦值，賦值號是“=”

int_var = 3
float_var = 3.1415926
str_var = "Hello"

print(int_var, float_var, str_var)
print(int_var, type(int_var))
print(float_var, type(float_var))
print(str_var, type(str_var))

輸出結果：
3 3.1415926 Hello
3 <class 'int'>
3.1415926 <class 'float'>
Hello <class 'str'>
Jupyter Notebook->File->New Notebook ->python[default]

2.Python的標識符

在Python里，標識符由字母、數字、下劃線組成，所有標識符可以包括英文、數字以及下劃線_，但不能以數字開頭

x_6 = 5
#錯誤標識符
6_x = 5   

  File "<ipython-input-19-430b4ee4710a>", line 2
    6_x = 5
      ^
SyntaxError: invalid syntax

Python3直接支持中文符號，包括標識符名

變量1 = 8
print(變量1)
# 8

3.保留字

保留字不能用作常數或變數，或任何其他標識符名稱。所有Python的關鍵字只包含小寫字母。

    import keyword
    keyword.kwlist
    # 輸出結果：['False','None','True','and','as', 'assert','break','class','continue','def','del',
    # 'elif','else','except', 'finally', 'for', 'from', 'global', 'if','import', 'in',
    # 'is','lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while',
    # 'with', 'yield']

4.數字數據類型

數字數據類型用于存儲數值，Python支持不同的數字類型：

• int(有符號整型)，缺省十進制，還可以表示2、8、16進制；Python不再保留長整型，統一為int；
• float(浮點型)，可以用科學計數法表示；

    var1 = 1e-5; var2 = 6.7e16; var3 = -1.8
    print(var1, var2, var3)
    # 1e-05 6.7e+16 -1.8

• complex(復數)，復數由實數部分和虛數部分構成，可以用a+bj后者complex(a,b)表示，復數的實部a和虛部b都是浮點型。

    var1 = 3+5.3j; var2 = complex(3.4e5,7.8)
    print(var1, type(var1), var2, type(var2))
   # (3+5.3j) <class 'complex'> (340000+7.8j) <class 'complex'>

• 0b, 0o, 0x分別代表2進制、8進制和16進制數

    # 多條語句可以放在一行，中間用分號隔開
    var1 = 0b10; var2 = 0o10; var3 = 0x10
    print(var1,var2,var3)
    # 2 8 16

• Python直接支持很長的整數

    var1 = 12334543544253421243524131
    print (var1, type(var1))
    # 12334543544253421243524131 <class 'int'>

• 布爾類型，bool值：True and False

5.注釋

• 單行注釋用 "#"
• 多行注釋用 '''或者"""

    print("1")
    '''
    print("注釋")
    print("注釋")
    '''
    print("1")
    
    # 1
    # 1

二、基本運算

1.算術運算

以下假設變量：x=10, y=3

2.比較運算

比較運算符，包括>, <, ==, >=, <=, !=，<>，返回為True或False

3.賦值運算

4.邏輯運算

邏輯運算符包括and or not，非0的值視作True，False的值就是0，True的值就是1.

三、字符串

• 字符串可以用雙引號”，也可以用單引號'。
• 轉義字符是反斜杠“\”，若不想讓反斜杠發生轉義，可以在字符串前添加一個r,表示原始字符串。
• 多行字符串可通過三個連續的單引號或是雙引號來進行標示。
• 使用+進行字符串鏈接

    "Hello" + " World!"
    # 'Hello World!'

• 使用*進行字符串鏈接

    "Bye" * 2
    # 'ByeBye'

四、List列表

1.寫法

List是Python中使用最頻繁的數據類型，寫在方括號[]之間、元素之間用逗號分隔開

2.元素類型

列表中的元素類型可以不相同，它支持數字，字符串甚至可以包含列表(嵌套)

    list1 = [1,2,3,4,5,6,"hello python",[7,8,9,10]]
    print(list1)
    # [1, 2, 3, 4, 5, 6, 'hello python', [7, 8, 9, 10]]

3.列表元素訪問

可用于通過索引(下標)和截取(切片)，列表被截取后返回一個包含所需元素的新列表。列表下標從0開始，-1表示倒數第1個。下標訪問不要越界。

• 單個列表元素訪問語法格式為：列表名[下標]

    list1[0]
    # 1
    list1[-1]
    # [7,8,9,10]

• 列表截取語法格式為：列表名[頭下標:尾下標]，返回包含所需內容的新列表，結果不包含尾下標元素。

    list1[6:8]
    # ['hello python', [7, 8, 9, 10]]
    # 切片步長
    list1[::2]
    # [1, 3, 5, 'hello python']
    list1[1::2]
    # [2, 4, 6, [7, 8, 9, 10]]

• 訪問嵌套列表元素：層層深入

    print(list1[-1][1:])
    # [8, 9, 10]
    

• 字符串是一種特殊列表，可以按列表元素的訪問方法來訪問字符串中的元素

    str1 = "hello, hangzhou!"
    print(str1[2:5])
    # llo

五、Tuple元組

1.寫法

元組寫在小括號()里，元素之間用逗號隔開

2.元素類型

元組中元素的類型可以不相同，和列表類似，也支持嵌套

    tuple1 = (1,2,3,4,5,6,"hello python",[8,9,10],(11,12))
    print(tuple1, type(tuple1))
    # (1, 2, 3, 4, 5, 6, 'hello python', [8, 9, 10], (11, 12)) <class 'tuple'>

3.訪問方式

元組的元素訪問和截取方式與列表相同，通過下標來操作

    print(tuple1[0])
    print(tuple1[-1])
    print(tuple1[6:-1])
    print(tuple1[-1][-1])
    #        1
    #        (11, 12)
    #        ('hello python', [8, 9, 10])
    #        12

4.與列表區別

元組一旦定義好就不能修改，是只讀的，而列表可修改

    #元組
    tuple1[1] = 7
    # TypeError: 'tuple' object does not support item assignment
    
    #列表
    list1 = [1,2,3,4,5,6,7]
    list1[2] = 1000
    print(list1)
    # [1, 2, 1000, 4, 5, 6, 7]

六、Set(集合)

集合(set)是一個無序、且不含重復元素的序列，集合主要用來進行成員關系測試和刪除重復元素。

1.寫法

可以使用大括號{}或者set()函數創建集合

    #自動去除重復元素
    set1 = {1,3,5,5,3,1}
    print(set1)
    # {1, 3, 5}
    
    #成員是否在集合中
    5 in set1
    # True
    8 in set1
    # False

2.常見操作

• 集合的并

    set1 = {1, 2, 3}
    set2 = {2, 4, 5}
    #集合的并
    set1 | set2 
    # {1, 2, 3, 4, 5}

• 集合的交

    #集合的交
    set1 & set2 
    # {2}

• 集合的差

    #集合的差(在set1不在set2中的元素)
    set1 - set2
    # {1, 3}

• 集合的補(兩個集合中不同時存在的元素集合)

    #集合的補
    set1 ^ set2
    # {1, 3, 4, 5}
    
    #相當于并集與交集的差
    (set1 | set2) - (set1 & set2)
    # {1, 3, 4, 5}

七、Dictionary字典

1.寫法

字典是一種映射類型，用“{ }”標識，它是一個無序的 鍵(key) : 值(value) 對集合
鍵必須使用不可變類型，在同一個字典中，鍵是唯一的

    dict1 = {"name":"giggle", "height":176, "weight":72}

2.存取方式

字典當中的元素是通過鍵來存取的

    dict1["height"]
    # 176

3.常見操作

• 修改字典某項的值

    dict1["weight"] = 73
    print(dict1)
    # {'name': 'giggle', 'height': 176, 'weight': 73}

• 在字典中增加一項

    dict1["sex"] = "M"
    print(dict1)
    # {'name': 'giggle', 'height': 176, 'weight': 73, 'sex': 'M'}

• 構建空字典

    dict2 = {}
    print(dict2)
    # {}

• 通過元組序列構造字典

    dict2 = dict([('name', 'giggle'),('height', 176)])
    print(dict2)
    # {'name': 'giggle', 'height': 176}
    
    dict2 = dict(name = 'giggle', weight = 72)
    print(dict2)
    # {'name': 'giggle', 'weight': 72}

• 內置函數

    #查看字典的鍵名
    dict2.keys()
    # dict_keys(['name', 'weight'])
    
    #查看字典的值
    dict2.values()
    # dict_values(['giggle', 72])
    
    #清空字典
    dict2.clear()
    print(dict2)
    # {}

八、格式化輸出

1. print的字符串格式化符號

• %c 格式化字符串及其ASCII碼

    print("%c" % "A")
    print("%c" % 65)
    # A
    # A

• %s 格式化字符串

    print("%s" % "Hello World")
    # Hello World

• %d 格式化整數

    print("%d" % 10)
    # 10

• %o 格式化無符號八進制數

    print("%o" % 10)
    # 12

• 格式化十六進制數(在前面顯示'0x'或'0X')

    print("%#x" % 20)
    # 0x14
    print("%#X" % 20)
    # 0X14

• %f 格式化浮點數字，可指定小數點后的精度

    print("%f" % 3.14)
    # 3.140000

• %e 用科學計數法格式化浮點數

    print("%e" % 3140000)
    # 3.140000e+06

• %g 根據輸入數字確定普通/科學計數法

    print("%g" % 3140000)
    print("%g" % 314000)
    # 3.14e+06
    # 314000

2.格式化操作符輔助指令

    # m.n.  是顯示的最小總寬度，n是小數點后的位數
    print("%5.2f" % 31400.1234) #原長度超過5位，仍保留5位
    print("%5.2f" % 3.1234) #不足5位，右對齊，前面補空格
    # 31400.12
    #  3.12
              
    # -左對齊補位 
    print("%10.6f" % 3.1234)
    print("%-10.6f" % 3.1234)
    #   3.123400
    # 3.123400 
    
    # +在正數前面顯示加號 
    print("%+10.6f" % 3.1234)
    #  +3.123400
    
    # 用*從后面的元組中讀取字段寬度或精度
    pi = 3.1415926
    print("pi = %.*f" % (5,pi))
    # pi = 3.14159
    
    #通過變量填充格式控制字符串
    print("I like %s and can eat %.2f kg." % ("orange", 1.5))
    # I like orange and can eat 1.50 kg.
    
    #使用字典來對應填充
    print("I like %(fruit_name)s and can eat %(weight).2f kg." % {"fruit_name":"orange", "weight":1.5})
    # I like orange and can eat 1.50 kg.
    

九、類型轉換

數據類型的轉換，只需要將數據類型作為函數名即可使用，這些函數返回一個新的對象，表示轉換的值，如：int(), float()和str()等。

1. 整型-字符串轉換

    x = "6"
    print(x, type(x))
    x = int("6")
    print(x, type(x))
    輸出結果：6 <class 'str'>
             6 <class 'int'>
             
    str(4)
    輸出結果：'4'

2. ASCII碼-字符轉換

    #查看 ASCII 碼
    ord("a")
    # 97
    
    #根據 ASCII 碼轉換成對應字符
    chr(65)
    # 'A'

3. 元組-列表/集合轉換

    tuple1 = (1, 2, 3, 4, 4, 1)
    list1 = list(tuple1)
    set1 = set(tuple1)
    print(tuple1)
    print(list1)
    print(set1)
    #  (1, 2, 3, 4, 4, 1)
    #  [1, 2, 3, 4, 4, 1]
    #  {1, 2, 3, 4}

4. 元組-字典轉換

    tuple1 = (("name", "giggle"), ("height", 176))
    dict1 = dict(tuple1)
    print(tuple1)
    print(dict1)
    #  (('name', 'giggle'), ('height', 176))
    #  {'name': 'giggle', 'height': 176}

5.超強的表達式計算(表達式字符串到數值的轉換)

    x = 8 
    calc = "5 * x + 9 "
    eval(calc)
    # 49

十、程序結構與控制語句

1. Python的行

可以用( \ )將一行的語句分為多行顯示

    thisIsaVeryLongVariableNameSoCantWriteInOneLineVariable1 = 1
    thisIsaVeryLongVariableNameSoCantWriteInOneLineVariable2 = 2
    thisIsaVeryLongVariableNameSoCantWriteInOneLineVariable3 = 3
    plusResult = thisIsaVeryLongVariableNameSoCantWriteInOneLineVariable1 +\
    thisIsaVeryLongVariableNameSoCantWriteInOneLineVariable2 +\
    thisIsaVeryLongVariableNameSoCantWriteInOneLineVariable3
    
    print(plusResult)
    #6

語句中包含[ ], { }或( )括號中間換行的就不需要使用多行連接符

    days = ('Monday', 'Tuesday', 'Wednesday',
            'Thursday', 'Friday', 'Saturday', 'Sunday')

2. 三種基本結構

順序、條件(選擇、分支)、循環

3. 條件語句

代碼塊是通過縮進來指示的，縮進代表一個代碼塊的開始，逆縮進表示一個代碼塊的結束
聲明以冒號：字符結束，并且開啟一個縮進級別

    # 語法格式 1
    if 條件表達式:
        語句塊1
    else:
        語句塊2
        
    #示例 1    
    print("請輸入體重(kg):")
    weight = float(input())
    
    if weight > 50:
        print("少吃點！！！")
    else:
        print("好好吃飯！")
    # 請輸入體重(kg):
    # 100
    # 少吃點！！！
    # 請輸入體重(kg):
    # 45
    # 好好吃飯！

    #語法格式 2
    if 條件表達式:
        語句塊1
    elif 條件表達式2:
        語句塊2
    else:
        語句塊3
        
    #示例 2：計算BMI指數
    print("請輸入體重(kg):")
    weight = float(input())
    print("請輸入身高(m)")
    height = float(input())
    
    BMI = weight / height **2
    
    if BMI < 20:
        print("你的BMI指數是%.2f，太輕了哦！" %BMI)
    elif BMI > 25:
        print("你的BMI指數是%.2f，太重了哦！" %BMI)
    else:
        print("你的BMI指數是%.2f，非常正常，請保持！" %BMI)
    # 請輸入體重(kg):
    # 72
    # 請輸入身高(m)
    # 1.76
    # 你的BMI指數是23.24，非常正常，請保持！

4. 循環語句

• while 循環

    #語法格式
    while 條件表達式:
        語句塊
        
    #統計6在2的100次方中出現的次數
    num = 2 ** 100
    print(num)
    
    count = 0
    
    while num > 0:
        if num % 10 == 6:
            count = count + 1
        num = num // 10
    
    print(count)
    # 1267650600228229401496703205376
    # 5

• for 循環

    #語法格式
    for 循環變量 in 序列:
        語句塊
    
    #統計6在2的100次方中出現的次數
    num = 2 ** 100
    print(num)
    count = 0
    for digit in str(num): #轉換成字符串(字符串是特殊的列表，列表的每一項會賦值給digit)
        if digit == "6":
            count = count + 1
    print(count)
    # 1267650600228229401496703205376
    # 5

• 使用for和range來枚舉列表中的元素

    for i in range(3):
        print(i)
    # 0
    # 1
    # 2
    
    for x in range(1, 3):
        print(x) #結果不包含最后的 3
    # 1
    # 2

5. 列表推導式

提供了一個創建和操作列表的有力工具

• 由一個表達式以及緊跟這個表達式的 for 語句構成，for 語句還可以跟 0 或多個 if 或 for 語句

    lst1 = [1, 2, 3]
    lst2 = [3, 4, 5]
    [x * y for x in lst1 for y in lst2]
    # [3, 4, 5, 6, 8, 10, 9, 12, 15]

• 數值判斷可以鏈接使用，例如 1<x<3 能夠判斷變量 x 是否在1和3之間

    [x for x in lst1 if 4 > x > 1]
    # [2, 3]

6. 多重循環

    #9*9乘法口訣表
    for i in range(1, 10):
        for j in range(1, i+1):
            result = j * i
            print('%s x %s = %-5s' % (j, i, result), end = '') #end=''表示不需要換行
        print() #換行
# 1 x 1 = 1    
# 1 x 2 = 2    2 x 2 = 4    
# 1 x 3 = 3    2 x 3 = 6    3 x 3 = 9    
# 1 x 4 = 4    2 x 4 = 8    3 x 4 = 12   4 x 4 = 16   
# 1 x 5 = 5    2 x 5 = 10   3 x 5 = 15   4 x 5 = 20   5 x 5 = 25   
# 1 x 6 = 6    2 x 6 = 12   3 x 6 = 18   4 x 6 = 24   5 x 6 = 30   6 x 6 = 36   
# 1 x 7 = 7    2 x 7 = 14   3 x 7 = 21   4 x 7 = 28   5 x 7 = 35   6 x 7 = 42   7 x 7 = 49   
# 1 x 8 = 8    2 x 8 = 16   3 x 8 = 24   4 x 8 = 32   5 x 8 = 40   6 x 8 = 48   7 x 8 = 56   8 x 8 = 64   
# 1 x 9 = 9    2 x 9 = 18   3 x 9 = 27   4 x 9 = 36   5 x 9 = 45   6 x 9 = 54   7 x 9 = 63   8 x 9 = 72   9 x 9 = 81           

7. break語句

break 語句用在 while 和 for 循環中
break 語句用來終止循環語句，即循環條件沒有 False 或者序列還沒被完全遞歸完，也會停止執行循環語句

    #統計第1個9在2的100次方中出現的位置
    num = 2 ** 100
    pos = 0
    for digit in str(num):
        pos = pos + 1
        if digit == '9':
            break
    print("2**100 is: %d \nthe first position of 9 is Pos.%d" %(num, pos))
    # 2**100 is: 1267650600228229401496703205376 
    # the first position of 9 is Pos.16

如果在嵌套循環中，break語句將停止執行本層的循環

    #求 2到10之間的素數
    i = 2
    while(i < 10):
        flag = 0
        j = 2
        while(j <= (i / j)): 
            if i % j == 0: #i能被j整除，一定不是素數，不必繼續判斷i能否被>j的數整除
                flag = 1 
                break
            j = j + 1
        if(flag == 0):
            print(i, "是素數")
        i = i + 1    
    # 2 是素數
    # 3 是素數
    # 5 是素數
    # 7 是素數

8. continue語句

continue語句用來跳過當前循環的剩余語句，然后繼續進行下一輪循環

    #求在2的100次方中刪除所有的9后的數字
    num = 2 ** 100
    without9 = ''
    for digit in str(num):
        if digit == "9":
            continue
        without9 += digit
    print("2**100 is: %d\nwithout 9 is :%s" %(num, without9))    
    # 2**100 is: 1267650600228229401496703205376
    # without 9 is :12676506002282240146703205376

9. pass語句

pass是空語句，是為了保持程序結構的完整性，一般用做占位語句

    #求在2的100次方中刪除所有的9后的數字
    num = 2 ** 100
    without9 = ''
    for digit in str(num):
        if digit == "9":
            pass
        else:    
            without9 += digit
    print("2**100 is: %d\nwithout 9 is :%s" %(num, without9))    
    # 2**100 is: 1267650600228229401496703205376
    # without 9 is :12676506002282240146703205376

10. 函數

Python提供了許多內建函數，如print()
開發者也可以自己創建用戶自定義函數

    #函數定義語法
    def functionname( parameters ):
        "函數_文檔字符串"
        function_suite
        return [expression]
    
    #定義一個求n!的函數，并調用求5！    
    def fact(n):
        result = 1
        for i in range(1, n+1):
            result = result * i
        return result
    fact(5) #調用函數
    # 120

可選參數以集合的方式出現在函數聲明中并緊跟著必選參數，可選參數可以在函數聲明中被賦予一個默認值。已命名的參數需要賦值。

    #intp 和 stringp 是可選參數，有默認值
    #如果調用fun_example時只指定一個參數，那么 intp 缺省為 0，stringp 缺省為A default string
    #如果調用fun_example時只指定兩個參數，那么 stringp 仍缺省為A default string
    # listp是必備參數，因為它沒有指定缺省值
    def fun_example(listp, intp = 0, stringp = "A default string"):
        "這是一個復雜的例子，所以我在此處寫了幫助文檔信息"
        listp.append("A new item")
        intp += 1
        return listp, intp, stringp
    my_list = [1, 2, 3]
    my_int = 10
    print(fun_example(my_list, my_int))
    print(my_list)
    # ([1, 2, 3, 'A new item'], 11, 'A default string')
    # [1, 2, 3, 'A new item']

函數的第一行語句可以選擇性地使用文檔字符串——用于存放函數說明

    #打印函數的幫助文檔信息
    fun_example.__doc__
    # '這是一個復雜的例子，所以我在此處寫了幫助文檔信息'

函數可以返回一個元組(使用元組拆包可以有效返回多個值)

    v1, v2, v3 = fun_example(my_list, my_int)
    print(v1)
    print(v2)
    print(v3)
    # [1, 2, 3, 'A new item']
    # 11
    # A default string

11. 全局變量和局部變量

全局變量在函數之外聲明

    number = 5  #全局變量
    def fun1():
        print(number)
    fun1()
    print(number)
    # 5
    # 5

局部變量在函數內容聲明

    number = 5  
    def fun2():
        number = 3 #局部變量
        print(number)
    fun2()
    print(number)
    # 3
    # 5

全局變量可以不需要任何特殊的聲明即能讀取，但如果想要修改全局變量的值，就必須在函數開始之處用global關鍵字進行聲明，否則Python會將此變量按照新的局部變量處理。

    number = 5  
    def fun3():
        global number #聲明后修改全局變量
        number = 3
        print(number)
    fun3()
    print(number)
    # 3
    # 3

函數參數也是局部變量，不需要在函數內部重復定義

    #定義一個求 n!的函數
    def fact(n):
        result = 1
        for i in range(1, n+1):
            result = result * i
        return result
    fact(5) #5賦值給函數參數 n作為局部變量    
    # 120

12. 類

類用來描述具有相同的屬性和方法的對象的集合
它定義了該集合中每個對象所共有的屬性和方法

    #語法格式
    #使用 class語句來創建新類，class之后為類的名稱并以冒號結尾
    class ClassName:
        '類的幫助信息' #類文檔字符串
        class_suite #類體，由類成員、方法、數據屬性組成
    
    #定義一個類
    class DeepLearner(object):
    'DeepLearner是深度學習者的類，這是有關這個類的幫助文檔'
    #learnerCount 變量是一個類的屬性，它的值將在這個類的所有實例之間共享
    #你可以在內部類或外部類使用DeepLearner.learnerCount訪問
    learnerCount = 0
    
    #__init__()方法是一種特殊的方法，被稱為類的構造函數或初始化方法，當創建了這個類的實例時就會調用該方法
    #類的方法與普通函數只有一個特別的區別——它們必須有一個額外的第一個參數名稱，按照慣例它的名稱是 self
    #self 代表類的實例，參數self 在定義類的方法時是必須要的，雖然在調用時不必傳入相應的參數
    def __init__(self, name, schoolName):
        self.name = name
        self.schoolName = schoolName
        DeepLearner.learnerCount = DeepLearner.learnerCount +1
    def getName(self):
        return self.name
    def getSchoolName(self):
        return self.schoolName
    def displayCount(self):
        print("Total DeepLearner count is %d" % DeepLearner.learnerCount)
    def displayLearner(self):
        print("Name: %s, School: %s" % (self.name, self.schoolName))
        

打印類幫助文檔

    print(DeepLearner.__doc__)
    # DeepLearner是深度學習者的類，這是有關這個類的幫助文檔

對象是類的實例，實例化類其它編程語言中一般用new，但是Python中沒有這個關鍵字

    #新建對象
    newLearner1 = DeepLearner('lucky','Fuzhou University')
    newLearner2 = DeepLearner('happy','Xiamen University')
    #使用點號.訪問對象的屬性和方法
    print(DeepLearner.learnerCount)
    print(newLearner1.getName(), newLearner1.getSchoolName())
    print(newLearner2.getName(), newLearner2.getSchoolName())
    newLearner1.displayLearner()
    newLearner2.displayLearner() 
    # 2
    # lucky Fuzhou University
    # happy Xiamen University
    # Name: lucky, School: Fuzhou University
    # Name: happy, School: Xiamen University

13. 文件

Python針對文件的處理有很多內建的函數庫可以調用

    #寫文件
    with open("test.txt", "wt") as out_file: #寫入到當前Python執行的目錄下的test.txt中
        out_file.write("該文本會寫入文件中\n看到我了吧！")
    #讀取文件
    with open("test.txt", "rt") as in_file:
        text = in_file.read()
    print(text)
    # 該文本會寫入文件中
    # 看到我了吧！

14. 異常

Phython中的異常由 try-except[exceptionname] 塊處理

    def except_function():
        try:
            #故意除零
            10 / 0
        except ZeroDivisionError: #除零異常名 ZeroDivisionError
        #若不知道可能發生什么異常，可不指定，直接用 except:
            print("發生除零異常啦")
        else:
            #正常情況
            print("一切正常哦")
            pass
        finally:
            #無論是否發生異常都將執行最后的代碼
            print("這是必然執行的代碼塊呀")
    
    except_function()
    # 發生除零異常啦
    # 這是必然執行的代碼塊呀

15. 導入外部庫

外部庫可以使用 import[libname] 關鍵字來導入
可以用 from[libname] import [funcname] 來導入所需要的函數

    import random  #導入random庫
    from time import time #導入具體time函數
    import numpy as np #導入numpy庫取別名np
    import matplotlib.pyplot as plt #導入繪圖函數庫取別名plt
    
    randomint = random.randint(1, 100) #在1-100之間產生的隨機數
    print(randomint)
    
    startTime = time()
    print(startTime)
    
    # 75
    # 1581313764.6087253
    
    #直接采用np生成等差數列的方法，生成100個點，每個點的取值在-1~1之間
    x_data = np.linspace(-1, 1, 100)
    #y = 2x + 1
    y_data = 2 * x_data + 1.0
    
    #在Jupyter中，使用matplotlib顯示圖像需要設置為 inline模式，否則不會顯示圖像
    %matplotlib inline
    
    plt.figure()
    plt.scatter(x_data, y_data) #畫出隨機生成數據的散點圖
    
    #顯示運行的總時間
    duration = time() - startTime
    print(duration)

image

16. 獲取幫助信息

調用help() 來獲取一個對象是如何工作的

    help(int)

調用dir()來顯示該對象的所有方法

    dir(int)

輸入時打出.加tab鍵可查看可調用的方法