一、Python簡介
-----------------------------------------------------------
    1.Python是一種解釋型，面向物件，動態資料型別的高階程式語言

    2.像Perl語言一樣, Python 原始碼同樣遵循 GPL(GNU General Public License)協議

二、Python特點
-----------------------------------------
    1.Python 是一種解釋型語言：
        這意味著開發過程中沒有了編譯這個環節。類似於PHP和Perl語言。

    2.Python 是互動式語言：
        這意味著，您可以在一個Python提示符，直接互動執行寫你的程式。

    3.Python 是面嚮物件語言:
        這意味著Python支援面向物件的風格或程式碼封裝在物件的程式設計技術。

    4.Python 是初學者的語言：
        Python 對初級程式設計師而言，是一種偉大的語言，它支援廣泛的應用程式開發，
        從簡單的文書處理到 WWW 瀏覽器再到遊戲。

    5.易於學習：

        Python有相對較少的關鍵字，結構簡單，和一個明確定義的語法，學習起來更加簡單。
    6.易於閱讀：
        Python程式碼定義的更清晰。

    7.易於維護：
        Python的成功在於它的原始碼是相當容易維護的。

    8.一個廣泛的標準庫：
        Python的最大的優勢之一是豐富的庫，跨平臺的，在UNIX，Windows和Macintosh相容很好。

    9.互動模式：
        互動模式的支援，您可以從終端輸入執行程式碼並獲得結果的語言，互動的測試和除錯程式碼片斷。

    10.可移植：
        基於其開放原始碼的特性，Python已經被移植（也就是使其工作）到許多平臺。

    11.可擴充套件：
        如果你需要一段執行很快的關鍵程式碼，或者是想要編寫一些不願開放的演算法，你可以使用C或C++完成那部分程式，然後從你的Python程式中呼叫。

    12.資料庫：
        Python提供所有主要的商業資料庫的介面。

    13.GUI程式設計：
        Python支援GUI可以建立和移植到許多系統呼叫。

    14.可嵌入:
        你可以將Python嵌入到C/C++程式，讓你的程式的使用者獲得"指令碼化"的能力。


三、Ubuntu上Python安裝
----------------------------------------
    1.Ubuntu已經整合

    2.檢視Python版本和幫助
        $> python -V
        $> python --help

    3.進入Python的命令列
        $> python
        >>> print("hello world")

    4.編寫python指令碼檔案
        $> cat test.py
        #!/usr/bin/python
        print("hello world")

        $> python test.py
        hello world


四、Python程式碼規範
-----------------------------------------------
    1.識別符號
        a.在python裡，識別符號有字母、數字、下劃線組成。

        b.在python中，所有識別符號可以包括英文、數字以及下劃線（_），但不能以數字開頭。

        c.python中的識別符號是區分大小寫的。

        d.以下劃線開頭的識別符號是有特殊意義的。
        以單下劃線開頭（_foo）的代表不能直接訪問的類屬性，需通過類提供的介面進行訪問，
        不能用"from xxx import *"而匯入；

        e.以雙下劃線開頭的（__foo）代表類的私有成員；
        以雙下劃線開頭和結尾的（__foo__）代表python裡特殊方法專用的標識，如__init__（）代表類的建構函式。

    2.行和縮排的格式錯誤
        a.IndentationError: unexpected indent 錯誤
            是python編譯器是在告訴你"Hi，老兄，你的檔案裡格式不對了，可能是tab和空格沒對齊的問題"，所有python對格式要求非常嚴格。

        b.如果是 IndentationError: unindent does not match any outer indentation level錯誤
            表明，你使用的縮排方式不一致，有的是 tab 鍵縮排，有的是空格縮排，改為一致即可。
            因此，在Python的程式碼塊中必須使用相同數目的行首縮排空格數。
            建議你在每個縮排層次使用 單個製表符 或 兩個空格 或 四個空格 , 切記不能混用

    3.多行語句
        a.Python語句中一般以新行作為為語句的結束符

        b.但是我們可以使用斜槓（ \）將一行的語句分為多行顯示
            total = a + \
                    b + \
                    c

        c.語句中包含[], {} 或 () 括號就不需要使用多行連線符
            totle = { a +
                      b +
                      c}

    4.引號
        Python 可以使用引號( ' )、雙引號( " )、三引號( ''' 或 """ ) 來表示字串，
        引號的開始與結束必須的相同型別的。
        其中三引號可以由多行組成，編寫多行文字的快捷語法，常用語文件字串，在檔案的特定地點，被當做註釋。
        word = 'word'
        sen = "這是一個句子"
        para = """這是一個
                包含了多個句子的段落"""

    5.註釋
        python的註釋是# 開頭
        #!/usr/bin/python
        # 我是一個註釋
        # 指定編碼，解決print列印中文亂碼問題
        # -*- coding:UTF-8 -*-
        print("你好") #註釋也可以放在句子後面

        '''
        我是多行註釋
        我是多行註釋
        我是多行註釋
        '''

        """
        我也是多行註釋
        我也是多行註釋
        我也是多行註釋
        """

    6.空行
        函式之間或類的方法之間用空行分隔，表示一段新的程式碼的開始。
        類和函式入口之間也用一行空行分隔，以突出函式入口的開始。
        空行與程式碼縮排不同，空行並不是Python語法的一部分。
        書寫時不插入空行，Python直譯器執行也不會出錯。
        但是空行的作用在於分隔兩段不同功能或含義的程式碼，便於日後程式碼的維護或重構。
        記住：空行也是程式程式碼的一部分。


    7.標準輸入舉例
        a.等待鍵盤輸入
            raw_input("please input a number!")

        b.一行多條語句
            print 1;print 2;print 3;

        c.程式碼與子句
           if True:
               print("true")
           else:
               print("false")


五、變數
------------------------------------------------
    1.5種基本型別
        a.Numbers
            int         //a = 10
            long
            float       //a = 10.0
            complex     //複數 a = 1 + 2j ; a = complex(1,2)

        b.String
           str = 'Hello World!'     # 輸出完整字串
           print str[0]             # 輸出字串中的第一個字元
           print str[2:5]           # 輸出字串中第三個至第五個之間的字串
           print str[2:]            # 輸出從第三個字元開始的字串
           print str * 2            # 輸出字串兩次
           print str+"TEST"         # 輸出連線的字串

        c.List
            list = ['hello',1,100.0,"world"]
            list                                #輸出完整字串
            list[0]
            list[0] = 100                       #ok
            list[1:3]
            list[2:]
            list * 2
            list + list + list

        d.Tuple
            相當於只讀列表，使用(,,)表示，不可二次賦值
            t = ( 'runoob', 786 , 70.2 )        #輸出完整字串
            t[0]                                #print
            t[0]
            t[0] = 5                            #wrong
            t[1:3]
            t[1:]
            t[:2]
            t * 2
            t + t

        f.Dictionary
            無序集合，通過key存取，{}表示
            dict = {}
            dict['one'] = "This is one"
            dict[2] = "This is two"
            tinydict = {'name': 'john','code':6734, 'dept': 'sales'}
            print dict['one']              # 輸出鍵為'one' 的值
            print dict[2]                  # 輸出鍵為 2 的值
            print tinydict                 # 輸出完整的字典
            print tinydict.keys()          # 輸出所有鍵
            print tinydict.values()        # 輸出所有值

    2.型別轉換
        int(x [,base])          #將x轉換為一個整數
        long(x [,base] )        #將x轉換為一個長整數
        float(x)                #將x轉換到一個浮點數
        complex(real [,imag])   #建立一個複數
        str(x)                  #將物件 x 轉換為字串
        repr(x)                 #將物件 x 轉換為表示式字串
        eval(str)               #計算在字串中的Python表示式,返回物件
        tuple(s)                #將序列 s 轉換為一個元組
        list(s)                 #將序列 s 轉換為一個列表
        set(s)                  #轉換為可變集合
        dict(d)                 #建立一個字典。d 必須是一個序列           #(key,value)元組。
        frozenset(s)            #轉換為不可變集合
        chr(x)                  #將一個整數轉換為一個字元
        unichr(x)               #將一個整數轉換為Unicode字元
        ord(x)                  將一個字元轉換為它的整數值
        hex(x)                  #將一個整數轉換為一個十六進位制字串
        oct(x)                  #將一個整數轉換為一個八進位制字串


六、運算子
------------------------------------------------
    1.算術雲算符
        +
        -
        *
        /
        %
        **      冪運算,3**3 = 27
        //      整除,5//3 = 1

    2.比較運算子
        ==
        !=
        <>
        <
        >
        >=
        <=

    3.賦值運算子
        +=
        -=
        *=
        /=
        %=
        **=     冪運算,3**3 = 27
        //=     整除,5 //3 = 1

    4.位運算子
        &           //0 & 1 = 0
        |           //-1 | 0 = -1
        ^           //亦或運算。相同為0,不同為1.
        ~           //取反。
        <<          //
        >>          //有符號

    5.邏輯運算子
        a和b均為boolean型別。
        and         //a and b   如果ab是int,也可以是按位的與運算,有0為0
        or          //a or b    如果ab是int,也可以是按位的或運算，有1為1
        not         //not a


    6.成員運算子
        in                  //a and b
        not in              //a or
        list = [1,2,3]
        a = 1
        a in list           //True
        a not in list       //False

    7.身份運算子
        身份運算子  判斷物件間儲存單元的內容
        a = 100
        b = 100
        a is b                  //True
        a is not b              //False


七、條件語句
-----------------------------------------------------
    1.if
        if cond :
        xxx

    2.if-else
        if cond:
            xxx
        else:
            xxx

    3.if-elif-else
        if cond:
            xxx
        elif:
            xxx
        else:
            xxx


八、迴圈語句
------------------------------------------------------
    1.列印9*9  for...in...:
        rows = [1,2,3,4,5,6,7,8,9]
        cols = [1,2,3,4,5,6,7,8,9]
        for r in rows:
            for c in cols:
                if r >= c:
                    print(str(c) + "*" + str(r) + "=" + str(c * r), end="   ")   #不換行，並以“  ”結束
            print()

    2.while ... break ... continue
        print("========== while 迴圈 ===========")
        i = 1
        while(i <= 9):
            j = 1
            while(j <= i):
                print("%d * %d = %d" %(i,j,i*j),end="\t")
                j += 1
            i += 1
            print()


九、元組Tuple
-------------------------------------------------------------
    1.Python的元組與列表類似，不同之處在於元組的元素不能修改。
      元組使用小括號，列表使用方括號。
      元組建立很簡單，只需要在括號中新增元素，並使用逗號隔開即可。
      如下例項：

      tup1 = ('physics', 'chemistry', 1997, 2000);
      tup2 = (1, 2, 3, 4, 5 );
      tup3 = "a", "b", "c", "d";
      tup4 = (1,2),(2,3);
      tup5 = (1,),(2,);

    2.訪問元組
        元組可以使用下標索引來訪問元組中的值,從0開始，
        tup2[1:5]
        tup2[1]

    3.元組的結合
        tup3 = tup1 + tup2

    4.刪除元組
        del tup1

    5.元組運算子
        print(tup2 * 3)             #複製三份
        print(len(tup2))            # 5
        print(tup1 + tup2)          #連線操作
        print(3 in tup2)
        for i in tup2: print(i);    #遍歷操作

    6.函式
        len(t1)
        max(t1)
        min(t1)
        tuple(sep)


十、字串String
----------------------------------------------------
    1.字串格式化輸出
        print("My name is %s and weight is %d kg!" % ('Zara', 21) )
        以上例項輸出結果：
        My name is Zara and weight is 21 kg!
        %c  格式化字元
        %s  格式化字串
        %d  格式化整數
        %u  無符號整型
        %f  格式化浮點

    2.r"hello \r\n world"
        字串前面加r表示原樣輸出，忽視轉義

    3.Python 中定義一個 Unicode 字串和定義一個普通字串一樣簡單：
      >>> u'Hello World !'
      u'Hello World !'
      引號前小寫的"u"表示這裡建立的是一個 Unicode 字串。如果你想加入一個特殊字元，可以使用 Python 的 Unicode-Escape 編碼。如下例所示：
      >>> u'Hello\u0020World !'
      >>> 'Hello World !'
      被替換的 \u0020 標識表示在給定位置插入編碼值為 0x0020 的 Unicode 字元（空格符）



十一、列表List
------------------------------------------------------
    1.序列是Python中最基本的資料結構。序列中的每個元素都分配一個數字 - 它的位置，或索引，第一個索引是0，第二個索引是1，依此類推。
      Python有6個序列的內建型別，但最常見的是列表和元組。
      序列都可以進行的操作包括索引，切片，加，乘，檢查成員。
      此外，Python已經內建確定序列的長度以及確定最大和最小的元素的方法。
      列表是最常用的Python資料型別，它可以作為一個方括號內的逗號分隔值出現
      列表的資料項不需要具有相同的型別
      建立一個列表，只要把逗號分隔的不同的資料項使用方括號括起來即可建立一個列表，只要把逗號分隔的不同的資料項使用方括號括起來即可

    2.修改List
        print("========== 結果 ==========")
        lst1 = [1,2,3,4,5,6]
        print(lst1[2])
        lst1[2] = 10
        print(lst1[2])
        del lst1[2]
        print(lst1)

        ========== 結果 ==========
        3
        10
        [1, 2, 4, 5, 6]

    3. + *
        print("=======結果=========")
        lst2 = [6,7,8,9,0,11]
        print(lst1 + lst2)
        print(lst1 * 2)
        print(lst1[:4])
        print(lst1[-2])


        ========結果========
        [1, 2, 4, 5, 6, 6, 7, 8, 9, 0, 11]
        [1, 2, 4, 5, 6, 1, 2, 4, 5, 6]
        [1, 2, 4, 5]
        5

    4.函式
       len(lst)
       max(lst)
       min(lst)
       list(seq)
       lst.pop(i)               //不加引數i,表示彈出最後一個元素
       lst.append(1)            //在結尾追加元素
       lst.append(1,4)          //在1的位置插入元素
       lst.clear()              //清空集合
       lst.remove(2)            //刪除指定的元素2,注意不是索引，如果元素不存在，移除的時候會出異常

        print("========結果========")
        print(lst1)
        print(lst1.pop(2))
        print(lst1)
        print(lst1.remove(6))
        print(lst1)
        print(lst1.reverse())
        print(lst1)
        print(lst1.sort())
        print(lst1)

        ========結果========
        [1, 2, 4, 5, 6]
        4
        [1, 2, 5, 6]
        None
        [1, 2, 5]
        None
        [5, 2, 1]
        None
        [1, 2, 5]


    5.二維列表
        print("============================================")
        list_2d = [[1,2],[3,4],[5,6]]
        print(list_2d)
        rows = [1,2,3,4,5,6,7,8,9]
        cols = [1,2,3,4]
        list_2d = [[col for col in cols] for row in rows]       #row表示外層幾個
        print(list_2d)

        ============================================
        [[1, 2], [3, 4], [5, 6]]
        [[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]]


十二、字典表Dictionary
------------------------------------------------------------
    1.字典是另一種可變容器模型，且可儲存任意型別物件。

      字典的每個鍵值(key=>value)對用冒號(:)分割，每個對之間用逗號(,)分割，整個字典包括在花括號({})中 ,格式如下所示：
      d = {key1 : value1, key2 : value2 }

      鍵必須是唯一的，但值則不必。

      值可以取任何資料型別，但鍵必須是不可變的，如字串，數字或元組。

    2.修改字典
        向字典新增新內容的方法是增加新的鍵/值對，修改或刪除已有鍵/值對如下例項:
        print("============結果=============")
        dict0 = {"1":"tom1",2:"tom2",3:"tom3"}
        print(dict0)
        dict0["1"] = "jerry1"                           #修改元素
        print(dict0)
        dict0[1] = "tom1"                               #增加元素
        print(dict0)
        del dict0["1"]                                  #刪除字典表的“1”
        print(dict0)
        del dict0                                       #刪除整個字典表
        print(dict0[0])                                 #會出錯，因為已經刪除了

        ============結果=============
        {'1': 'tom1', 2: 'tom2', 3: 'tom3'}
        {'1': 'jerry1', 2: 'tom2', 3: 'tom3'}
        {'1': 'jerry1', 2: 'tom2', 3: 'tom3', 1: 'tom1'}
        {2: 'tom2', 3: 'tom3', 1: 'tom1'}

    3.字典key,value的特性
        字典value可以沒有限制地取任何python物件，既可以是標準的物件，也可以是使用者定義的，但key不行
        不允許同一個key出現兩次。建立時如果同一個鍵被賦值兩次，後一個值會被記住,前一個會被覆蓋掉
        key必須不可變，所以可以用數字，字串或元組充當，所以用列表就不行

    4.字典表的函式
        print("============結果=============")
        dict0 = {"1":"tom1",2:"tom2",3:"tom3"}
        dict1 = {"1":"tom77","2":"tom2",3:"tom3",4:"tom4"}

        print(len(dict0))       #返回字典的長度
        print(str(dict0))       #返回字典的字串表示
        print(type(dict0))      #返回字典型別
        print(dict0.copy())     #返回字典的一個副本
        print(dict0.get("2",50))    #返回字典中key對應的value,如果不存在，就返回後面定義的值
        print(dict0.items())    #以元組陣列的方式返回一個可遍歷的列表
        print(dict0.keys())     #返回keys
        print(dict0.values())     #返回values
        print(dict0.setdefault("2",50))    #返回字典中key對應的value,如果不存在，就返回後面定義的值
        print(dict0.update(dict1))    #合併兩個字典，相同的鍵會按照dict1的來
        print(dict0)    #返回字典中key對應的value,如果不存在，就返回後面定義的值

        ============結果=============
        3
        {'1': 'tom1', 2: 'tom2', 3: 'tom3'}
        <class 'dict'>
        {'1': 'tom1', 2: 'tom2', 3: 'tom3'}
        50
        dict_items([('1', 'tom1'), (2, 'tom2'), (3, 'tom3')])
        dict_keys(['1', 2, 3])
        dict_values(['tom1', 'tom2', 'tom3'])
        50
        None
        {'1': 'tom77', 2: 'tom2', 3: 'tom3', '2': 'tom2', 4: 'tom4'}



十三、檔案操作
---------------------------------------------------------------
    1.輸入函式
        print("=====================================")
        a = input("請輸入：")
        print(a)

        =====================================
        請輸入：1+2+3
        1+2+3

    2.open() and readlines()
        print("---------------------------------")
        a = open("d://calllog.log")
        print(a.readline())
        lines = a.readlines()
        for line in lines :
            print(line,end="")

        print("---------------------------------")
        a = open("d://calllog.log")
        while True :
            line = a.readline();
            if line == "" :
                break;
            else:
                print(line,end="")

        open的時候可以指定引數：開啟方式，預設是"r"
        "r":只讀方式開啟檔案，指標在開頭
        "rb":以二進位制格式開啟和只讀
        "r+":讀寫，指標位於首
        "rb+":二進位制，讀寫，首
        "w":只寫，已存在覆蓋，不存在建立
        "wb":二進位制，只寫
        "w+":讀寫，存在覆蓋，不存在建立
        "a":只寫，追加，存在指標在尾。不存在建立.
        "ab":只寫，二級制追加
        "a+":讀寫，追加，存在指標在尾。不存在建立.
        "ab+":讀寫，二級制追加


    3.write()
        file = open("d:\\1.py","w");            #以寫的方式開啟一個檔案，如果檔案不存在，就建立一個。如果存在就覆蓋
        file.write("hello world1111")

    4.實現二進位制檔案的複製
        print("==============複製小檔案====================")
        f1 = open("d:\\1.jpg","rb");
        arrStr = f1.read()          #讀取所有位元組
        f2 = open("d:\\1_1.jpg","wb");
        f2.write(arrStr);

        print("==============複製大檔案====================")
        f1 = open("d:\\1.jpg","rb");
        f2 = open("d:\\1_1.jpg","wb");
        while True:
            buf = f1.read(1024);
            if len(buf) != 0:
                f2.write(buf)
            else:
                f1.close()
                f2.close()
                break;

    5.使用os模組
        匯入包
        import os
        os.rename(old,new)      //檔案重新命名
        os.remove(filename)     //移除檔案
        os.mkdir(dir)           //建立目錄
        os.rmdir(dir)           //移除目錄
        os.chdir(dir)           //改變目錄

        print("==============os 模組====================")
        import os

        # os.rename("d:\\1.jpg","d:\\a.jpg")      #更改目錄或者檔名，不能跨磁碟d --> e 是不行的
        # os.remove("d:\\1_1.jpg")
        # os.mkdir("d:\\py\\data")                  #次一級目錄不能為空，才可以建立完整目錄
        # os.mkdir("d:\\py\\data\\1.txt")            #次一級目錄不能為空，才可以建立完整目錄.只能建立目錄。
        # os.remove("d:\\py")
        # os.chdir("d:\\py","d:\\py1")