第五天，感覺開始燒腦了。遞歸邏輯難，模塊數量多，但是絕世武功都是十年磨一劍出來的！穩住！

1 遞歸。

定義-----遞歸就是在函數的內部調用自己
遞歸深度 998
不建議修改遞歸深度，因為如果998都沒有解決，那麽這個功能就不適合用遞歸寫
例子：
    猜年齡
    alex多大，alex比wusir大兩歲        40+2+2
    wusit多大，wusir比金老板大兩歲    40+2
    金老板多大了，40了

def age(n)
    if n == 3:
        return 40
    else:
        return age(n+1)+2
age(1)

遞歸求解二分查找算法：
99*99 可以  99*100-99  就是9900 - 99 = 9801
這個屬於人類的算法。
計算機的算法是 計算一些比較復雜的問題，所采用的 在空間上，或者時間上
更有優勢的方法
空間就是節省內存。時間是執行時間計算速度更快

比如排序50000萬個數找到最小的與最大的，一般是快速排序，堆排序，冒泡排序
查找功能使用算法

二分法： 只能查找有序的數字集合的查找問題
l = [2,3,4,5,6,7,8,9,0,11,22,23,24,27,33,37,44,46,55,59,66,67,77,74,88,90,92,98]
def cal(num=66):
    length - len(l)
    mid = length//2
    if num > l[mid]:
        l = l[mid:]

def cal(l,num,start,end)
    if start < = end
        mid = (end - start)//2 +start
        if l[mid] > num:
            return cal(l,num,start,mid-1)
        elif l[mid] < num:
            return cal(l,num,mid+1,end)
        else:
            print("找到了",mid,l[mid])
    else:
        return " 沒找到"

2 常用模塊1 模塊定義:模塊就是py文件,模塊是寫好了但不直接使用的功能。

2 模塊的意義（摘抄）：
如果你退出python解釋器然後重新進入，那麽你之前定義的函數或者變量都將丟失，因此我們通常將程序寫到文件中以便永久保存下來，需要時就通過python test.py方式去執行，此時test.py被稱為腳本script。
隨著程序的發展，功能越來越多，為了方便管理，我們通常將程序分成一個個的文件，這樣做程序的結構更清晰，方便管理。這時我們不僅僅可以把這些文件當做腳本去執行，還可以把他們當做模塊來導入到其他的模塊中，實現了功能的重復利用，

3 模塊的分類：
常用的 和某個操作相關的 根據相關性分為三類:內置模塊。擴展模塊。自定義模塊
    內置模塊
        安裝了Python解析器後就一起提供了這些模塊，一般是特別常用的
    擴展模塊
        需要自己下載安裝的模塊
        pypi網站:
            www.pypi.org
    自定義模塊
        自己寫的模塊

4 內置模塊：
    一 collections模塊
        orderedDict
        提供了很多其他的數據結構，比如有序字典orderedDict
        d = collections.OrderedDict()

        counter
            計算某一個字符串出現的次數

        defaultdict
            from collections import defaultdict
            l = [11,22,33,44,55,66,77,88]
            my_dict = defaultdict(list)
            默認這個字典的value是一個空列表
            print(my_dict["a"])
            my_dict["b"] = 10
            print(my_dict)
            如果新創建了key 並指定了值，那麽就按照你指定的值賦值，就不是默認列表了

        namedtuple
            創建一個元祖，但是裏面的元素都用一個名字代表。
            生成可以使用名字來訪問元素內容的tuple

        deque
            雙端隊列，可以快速的從另外一側追加和推出對象


    二 時間模塊
　　　　　定義：時間模塊通常有三種方式來表示時間：時間戳、格式化的時間字符串、元組(struct_time)

        1。時間戳時間：表示的是從1970年1月1日00:00:00開始按秒計算的偏移量
        　　print(time.time())

        2.格式化時間：
        　　time.strftime("%Y-%m-%d %H:%M:%S")
        　　還有%x  %c等常用的格式。

　　　　　　　格式化時間字符串（摘抄）：

　　　　　　　　%y 兩位數的年份表示（00-99）
　　　　　　　　%Y 四位數的年份表示（000-9999）
　　　　　　　　%m 月份（01-12）
　　　　　　　　%d 月內中的一天（0-31）
　　　　　　　　%H 24小時制小時數（0-23）
　　　　　　　　%I 12小時制小時數（01-12）
　　　　　　　　%M 分鐘數（00=59）
　　　　　　　　%S 秒（00-59）
　　　　　　　　%a 本地簡化星期名稱
　　　　　　　　%A 本地完整星期名稱
　　　　　　　　%b 本地簡化的月份名稱
　　　　　　　　%B 本地完整的月份名稱
　　　　　　　　%c 本地相應的日期表示和時間表示
　　　　　　　　%j 年內的一天（001-366）
　　　　　　　　%p 本地A.M.或P.M.的等價符
　　　　　　　　%U 一年中的星期數（00-53）星期天為星期的開始
　　　　　　　　%w 星期（0-6），星期天為星期的開始
　　　　　　　　%W 一年中的星期數（00-53）星期一為星期的開始
　　　　　　　　%x 本地相應的日期表示
　　　　　　　　%X 本地相應的時間表示
　　　　　　　　%Z 當前時區的名稱
　　　　　　　　%% %號本身

        3.元組時間（struct_time） ：struct_time元組共有9個元素共九個元素:(年，月，日，時，分，秒，一年中第幾周，一年中第幾天等）
            print(time.localtime())
            t = time.localtime()
　　　　　　 格式（摘抄）

　　　　　4.時間的轉換：
        　　可以接收一個時間戳時間變成本地化的時間
            　　print(time.localtime(1550000000))
        　　格式化時間轉字符串時間
            　　stryct_time = time_gmtime(20000000000)
            　　print(time.strftime("%Y-%m-%d %H:%M:%S",stryct_time))
        　　格式化時間轉時間戳時間
            　　s = "1988-12-22 9:23:22"
            　　ret = time.strptime(s,"%Y-%m-%d %H:%M:%S",stryct_time")
            　　print(ret)
            　　print(time.rmktime(ret))
　　　　  

　　　　　　
        練習題：
        1 拿到當前時間的月初1號的0點的時間戳時間。
        2 計算任意 兩個時間點之間經過了多少年月日時分秒
        datetime是根據time模塊再次封裝的模塊 更上層

    三 random模塊
        隨機小數
            random.random()  大於0且小於1之間的小數
            random.uniform(1,3) 大於1小於3的小數
        練習：
            發紅包

        隨機整數
            random.randint(0,9)  取一到二
        練習：
            驗證碼
            s = ""
            for i in range(4):
            s += rangom.randint(0,9)
            print(s)
            字母與數字都有：
            id = ""
            num = random.randint(65,90)
            c = chr(num)
            num2 = random.randint(0,9)
            print(num2)
            s = random.choice([c,num2])
            print(s)
            for i in range(4):
              id += s
            print(ss)
            隨機選擇一個返回
            隨機選擇多個返回，返回的個數為函數的第二個參數


    四 os模塊
        系統相關模塊
        文件操作：
            刪除文件
                os.remove()
            重命名文件
                os.rename("old","new")
        目錄操作：
            os.makedirs("dir1/dir2")  多層遞歸創建目錄
            os.removedirs("dir1") 若目錄為空則刪除，並遞歸到上一級目錄。如果也為空則刪除。以此類推
            os.mkdir("dir1")    生成單級目錄
            os.rmdir("dir1")    刪除單級空目錄 目錄不為空則無法刪除。
            os.listdir("dir1")    列出指定目錄下的所有文件和子目錄。包括隱藏文件並以列表方式打印
        當前工作目錄有關操作：
            os.getcwd()         獲取當前工作目錄。即當前python腳本工作的目錄路徑。
            os.chdir("dir1")   改變當前腳本工作目錄。相對於shell 的cd   ，註意如果改變了路徑 open 文件時候會在改變的路徑下創建文件。
            os.curdir()     返回當前目錄:"."
            os.pardir()     放回上一級目錄:".."
        stat 屬性操作：
            os.stat("dir/file")
                st_mode　　inode保護模式
                st_ino　　inode節點號
                st_dev　　inode駐留設備
                st_nlink　　inode的連接數
                st_uid　　所有者的用戶ID
                st_gid　　所有者的組ID
                st_size　　普通文件以字節為單位大小，包含等待某些特殊文件的數據
                st_atime  上次訪問時間
                st_mtime   上次修改元數據時間
                st_ctime   上次修改文件內容數據的時間
        操作系統差異：
            os.sep   輸出操作系特定的路徑分隔符   win是\\  linux /
            os.linesep    輸出當前平臺使用的行終止符   win是\t\n   linux是\n
            os.pathsep    輸出用於分割文件路徑的字符串 win ；  linux ：
                        "path1%spath2%s",%os.pathsep
            os.name   輸出字符串指示當前使用平臺， win是 nt  linux是posix
        操作系統命令執行:
            os.system   執行系統的命令，直接顯示。
                os.system("dir")  執行dir命令
            os.popen   執行系統命令，返回返回值。
                ret = os.popen("dir").read()
                print(ret)
            截屏


    五 sys模塊
        Python解析器模塊
        sys.exit()  解釋器退出，程序結束
        sys.modules   #放了所有在解釋器運行過程中導入的模塊名稱。
        sys.path   程序相關的路徑。 一個模塊能否導入需要看是否在這裏sys.path列表裏面存放的路徑下面
        sys.argv   在執行Python腳本的時候，可以傳遞一些參數進來
            if sys.argv[1] == "alex" and sys.argv[2] == "alex3714":
                print("可以執行下面的代碼")
            else:
                print("密碼錯誤退出")
                sys.exit()
             這個只能從命令行中執行並傳入參數來使用

    六 re正則表達式模塊
        功能比如簡單的校驗
        正則表達式   字符串匹配相關的操作的時候用到的一種規則
        正則表達式的規則
        使用python中的re模塊去操作正則表達式
        在線測試工具
        http://tool.chinaz.com/regex

        正則表達式：
            [] 匹配一個字符位置的字符
            [0-9] 匹配0到9的字符
            [a-z] 匹配a到z的字母
            [A-Za-z]  匹配大小寫字母
            [0-9a-fA-F]  匹配一個十六進制字符

        元字符：
            .  匹配任意一個字符
            \d 匹配任意一個數字
            \w 匹配任意一個數字，字母，下劃線
            \s 匹配任意一個空白符
            \n 匹配換行符
            \t 匹配制表符
            a\b 匹配單詞結尾，這裏是結尾是否是a
            ^a  匹配最開始 這裏是匹配是a開頭的字符
            a$ 匹配結尾 這裏是匹配a為結尾的字符

        大寫的就都是相反的
        \W 就是匹配非數字，字母，下劃線
        [\w\W]  這是一種全組，可以匹配所有

        ABC|ABCD  如果兩個正則表達式先匹配到ＡＢＣ那麽就不往後匹配了，所以要先把長的寫到前面
        應該寫為ABCD|ABC

        [^...]    如果在字符組中加^ 那麽就是除了字符組的其他的都匹配[^ABC]

        量詞
            {num} 約束出現幾次，只約束緊挨著前面的
            [1][3-9][0-9]{9}   就是可以匹配前面[0-9]字符組出現9次
            量詞跟在一個元字符的後面 約束某個字符的規則能夠重復多少次
            如果要匹配的字符剛好是和元字符一模一樣，那麽需要對這個元字符進行轉義 \

        * 重復零次或多次
        + 重復一次或多次
        ？重復0次或一次
        {n} 匹配n次
        {n,} 重復n次或多次
        {n,m} 重復n次到m次


        貪婪普配
            正則表達式中的所有量詞，都會盡量多的為你匹配
            +表示匹配一次或多次
            算法：回朔算法
        練習：
            匹配整數與小數
            \d+(/.\d+)?

        惰性匹配
         ？ 如果在量詞的後面 ?號就是惰性匹配
         \d+?
         \d{3,5}?  只匹配3次
         ？？      只匹配0次或一次 盡量少匹配
         {n,}?      匹配n次或多次，盡量只配置n次
         .*?x   匹配任意字符碰到一個x就停止

        匹配身份證
            ^[1-9]\d{14}(\d{2}[0-9x])?$

    re模塊方法：
        re.findall()   匹配全部符合條件的值，並全部返回
            ret = re.findall("\d+","df12 dsfs23dd sdfs21")
            print(ret)

        re.search()    找第一個符合條件的。同時返回的值是一個內存地址。需要group()調用
            ret = re.search("\d+","df12 dsfs23dd sdfs21")
            print(ret.group())
            一般是
            if ret:
                print(ret.group())

        re.match   在search基礎上，給每一條都加上了^ 匹配開頭
            ret = re.match("\d+","df12 dsfs23dd sdfs21")
            print(ret)
            結果是空

        re.split 匹配切割


        re.sub   把數字替換成字符串  後面指定替換幾次
            ret = re.sub("\d","g","adfasdf2131sdfsdf",1)

        re.subn  吧數字替換成字符串 並返回元祖（替換的結果，替換了多少次）

        re.cap 不常用

        註意：
        findall 的優先級
        如果匹配中有分組，那麽只返回分組的匹配，所以需要在分組前加?:來取消分組優先級

作業：
    字符串計算器，加減乘除小括號，使用正則
    提示：先算小括號裏面的
    然後在算乘除，再算加減

    三級菜單 遞歸 或堆棧
    時間模塊
    紅包

python修煉第五天