字串的相關操作方法(簡):
一 寫轉來轉去
    1.  str.capitalize()   # 第一個字母轉大寫   ## 美 /'kæpɪtəlaɪz/ #
    返回值:該方法返回一個首字母大寫的字串
    例   ret1 = str.capitalize()
         print(ret1)
    2.  str.lower()        # 全部轉換成小寫     ## 美 /'loɚ/ #
    返回值:返回將字串中所有大寫字元轉換為小寫後生成的字串
    3.  str.upper()        # 全部轉換成大寫     ## 美 /'ʌpɚ/
    返回值:返回小寫字母轉為大寫字母的字串
    4.  str.title()        # 每個被特殊字元隔開的字母首字母大寫    ## 美 /'taɪtl/ #
    返回值:返回"標題化"的字串,就是說所有單詞的首字母都轉化為大寫。
    例   str = "alex eggon,taibai*yinwang_麻花藤"
        ret = str.title()  # Alex Eggon,Taibai*Yinwang_麻花藤  // # 中⽂也算是特殊字元
        print(ret)
二 切來切去
    5.  str.strip
 
()        # 去掉左右兩端的空格   ## 美 /strɪp/ #
    返回值:返回移除字串頭尾指定的字元序列生成的新字串
    5.1 擴充套件: str.lstrip()  # 去掉左邊空格     s.rstrip()   # 去掉右邊空格
          str = "abcdefgabc"
          print(str.strip("abc"))  # defg 也可以指定去掉的元素,
    6.  str.replace(old, new[, max])  # 字串替換 (max)替換次數    ## 美 /rɪ'ples/ #
    返回值:返回字串中的 old（舊字串） 替換成 new(新字串)後生成的新字串，
    如果指定第三個引數max，則替換不超過 max 次。
    7.  str.split
 
()        #  通過指定分隔符對字串進行切片   ##  美 /splɪt/ #
    返回值:返回分割後的字串列表.
    # str.split(str="", num=string.count(str))  #
    # str -- 分隔符，預設為所有的空字元，包括空格、換行(\n)、製表符(\t)等
    # num -- 分割次數
三 查詢
    8.  str.startswith("")  # 檢查字串是否是以指定子字串開頭，  ##美 /stɑrtswɪθ/ #
    返回值:如果是則返回 True，否則返回 False
    # str.startswith(str, beg=0,end=len(string))
    str -- 檢測的字串。
    strbeg -- 可選引數用於設定字串檢測的起始位置。
    strend -- 可選引數用於設定字串檢測的結束位置。
    例: str = "this is string example....wow!!!"
        print (str.startswith( 'this' ))
    8.1擴充套件:str.endswith("")  # 是否以'xxx'結尾
    9.  str.count
 
("x")   # 統計字串裡某個字元出現的次數      ##  美 /kaʊnt/ #
    返回值:該方法返回子字串在字串中出現的次數。
    # str.count(sub, start= 0,end=len(string))
    10.  str.find("x")  # 檢測字串中是否包含子字串 str,查詢'x'出現的位置  ## 美 /faɪnd/ #
    返回值:如果包含子字串返回開始的索引值，否則返回-1
    例:str1 = "Runoob example....wow!!!"
        str2 = "exam";
        print (str1.find(str2))
        print (str1.find(str2, 5))   # 切片找
        print (str1.find(str2, 10))
    11.  str.index()     # 求索引位置           ## 美 /'ɪndɛks/ #
    返回值:如果包含子字串返回開始的索引值，否則丟擲異常。
四  條件判斷
    12 str.isalnum()  # 是否由字母和數字組成   ## 美 /ɪznʌm/ #
    返回值:如果 string 至少有一個字元並且所有字元都是字母或數字則返回 True,否則返回 False
    13 str.isalpha()  # 是否由字母組成         ## 美 /ɪzpha/ #
    返回值;如果字串至少有一個字元並且所有字元都是字母則返回 True,否則返回 False
    14 str.isdigit()  是否由數字組成           ## 美 /ɪzɡɪt/ #
    返回值:如果字串只包含數字則返回 True 否則返回 False。
    例: s17 = "-123.12"
        s17 = s17.replace("-", "") # 替換掉負號
        if s17.isdigit():
         print("是整數")
        else:
         if s17.count(".") == 1 and not s17.startswith(".") and not s17.endswith("."):
         print("是小數")
         else:
         print("不是小數")
五. 計算字串的長度
    13 len(str)   # 計算字串的長度(返回物件（字元、列表、元組等）長度或專案個數)
    返回值:返回物件長度

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
===============================================================================================
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

內建函式(主)
基礎資料型別相關:
    和數字相關:
        數字型別:
            1. bool() # 函式用於將給定引數轉換為布林型別，如果沒有引數，返回 False (int的子類)
            返回值:返回 Ture 或 False。
            2. int()  # 用於將一個字串或數字轉換為整型
            返回值:返回整型資料。
            3. float() # 函式用於將整數和字串轉換成浮點數
            返回值:返回浮點數。
        數學運算:
            1. sum()  # 對系列進行求和計算
            返回值:計算結果
            2. min() # 返回給定引數的最小值，引數可以為序列
            返回值:返回給定引數的最小值。
            3. max() # 返回給定引數的最大值，引數可以為序列
            返回值:返回給定引數的最大值。
            4. abs() # 返回數字的絕對值
            返回值:函式返回 x（數字）的絕對值，如果引數是一個複數，則返回它的大小。
    和資料結構相關:
        序列:
            列表和元組:
                1. list() # 將一個可迭代物件轉換成列表
                返回值：返回列表。
                2. tuple() # 將⼀個可迭代物件轉換成元組
                返回值：返回元組。
            相關內建函式：
                1. reversed() # 將⼀個序列翻轉, 返回翻轉序列的迭代器
                返回值：返回一個反轉的迭代器。
            字串:
                1. str() # 將資料轉化成字串
                返回值：返回一個物件的string格式
                2. bytes()  # 把字串轉化成bytes型別
                返回值：返回一個新的 bytes 物件
        資料集合：
            字典:
                1. dict()  # 用於建立一個字典
            返回值：返回一個字典。
            集合：
                1. set()  # 建立一個無序不重複元素集，可進行關係測試，刪除重複資料
                返回值：返回新的集合物件{}
                2. frozenset() # 返回一個凍結的集合，凍結後集合不能再新增或刪除任何元素
                返回值：返回新的 frozenset 物件，如果不提供任何引數，預設會生成空集合
        相關內建函式：
            1. len() # 返回⼀個物件中的元素的個數
            返回值：返回物件（字元、列表、元組等）長度或專案個數

            2. sorted() # 對所有可迭代的物件進行排序操作
            返回值：返回重新排序的列表。
            語法: sorted(Iterable, key=None, reverse=False)
            Iterable: 可迭代物件
            key: 排序規則(排序函式), 在sorted內部會將可迭代物件中的每⼀個元素傳遞給這個函
            數的引數. 根據函式運算的結果進⾏排序
            reverse: 是否是倒敘. True: 倒敘, False: 正序
            例 lst = [1,5,3,4,6]
                lst2 = sorted(lst)
                print(lst) # 原列表不會改變
                print(lst2) # 返回的新列表是經過排序的
                dic = {1:'A', 3:'C', 2:'B'}
                print(sorted(dic)) # 如果是字典. 則返回排序過後的key
            例 和函式組合使用
                # 根據字串⻓度進⾏排序
                lst = ["麻花藤", "岡本次郎", "中央情報局", "狐仙"]
                # 計算字串⻓度
                def func(s):
                 return len(s)
                print(sorted(lst, key=func))
            例 和lambda組合使用
            # 根據字串⻓度進⾏排序
                lst = ["麻花藤", "岡本次郎", "中央情報局", "狐仙"]  # 計算字串⻓度
                def func(s):
                  return len(s)
                print(sorted(lst, key=lambda s: len(s)))
                ---------------------------------
                lst = [{"id":1, "name":'alex', "age":18},
                     {"id":2, "name":'wusir', "age":16},
                     {"id":3, "name":'taibai', "age":17}]   # 按照年齡對學⽣資訊進⾏排序
                print(sorted(lst, key=lambda e: e['age']))
            ## sort 與 sorted 區別：
            sort 是應用在 list 上的方法，sorted 可以對所有可迭代的物件進行排序操作。

            3. enumerate() # 函式用於將一個可遍歷的資料物件(如列表、元組或字串)組合為一個索引序列，
                             同時列出資料和資料下標，一般用在 for 迴圈當中。
            返回值：返回 enumerate(列舉) 物件。
            4. zip() # 用於將可迭代的物件作為引數，將物件中對應的元素打包成一個個元組，
                     然後返回由這些元組組成的物件，這樣做的好處是節約了不少的記憶體
            返回值：返回一個物件
            例：l1 = [1,2,3,]
                l2 = ['a','b','c',5]
                l3 = ('*','**',(1,2,3))
                for i in zip(l1,l2,l3):
                 print(i)

            5. fiter() # 用於篩選過濾序列，過濾掉不符合條件的元素，返回一個迭代器物件
            返回值：返回一個迭代器物件
            語法: filter(function. Iterable)
            function: ⽤來篩選的函式. 在filter中會⾃動的把iterable中的元素傳遞給function. 然後
            根據function返回的True或者False來判斷是否保留此項資料
            Iterable: 可迭代物件
            例 lst = [1,2,3,4,5,6,7]
                ll = filter(lambda x: x%2==0, lst) # 篩選所有的偶數
                print(ll)
                print(list(ll))
            -----------------------
            lst = [{"id":1, "name":'alex', "age":18},
                 {"id":2, "name":'wusir', "age":16},
                 {"id":3, "name":'taibai', "age":17}]
            fl = filter(lambda e: e['age'] > 16, lst) # 篩選年齡⼤於16的資料
            print(list(fl))

            6. map() # 根據提供的函式對指定序列做對映
            返回值:返回迭代器。
            語法: map(function, iterable) 可以對可迭代物件中的每⼀個元素進⾏對映. 分別取執⾏function
            例 計算列表中每個元素的平⽅ ,返回新列表
                def func(e):
                 return e*e
                mp = map(func, [1, 2, 3, 4, 5])
                print(mp)
                print(list(mp))
            ****改寫成lambda
                print(list(map(lambda x: x * x, [1, 2, 3, 4, 5])))
            ----------------
            例   計算兩個列表相同位置的資料的和
                lst1 = [1, 2, 3, 4, 5]
                lst2 = [2, 4, 6, 8, 10]
                print(list(map(lambda x, y: x+y, lst1, lst2)))

作用域相關:
    1.locals()  返回當前作用域中的名字
    返回值:返回字典型別的區域性變數
    2.globals() 返回全域性作用域中的名字
    返回值:返回全域性變數的字典。

====================================
====================================

迭代器相關:
    1. range() # 返回的是一個可迭代物件（型別是物件），而不是列表型別， 所以列印的時候不會列印列表
    range(stop)
    range(start, stop[, step])
    start: 計數從 start 開始。預設是從 0 開始。例如range（5）等價於range（0， 5）;
    stop: 計數到 stop 結束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]沒有5
    step：步長，預設為1。例如：range（0， 5） 等價於 range(0, 5, 1)
    2. next() 迭代器向下執行下一次, 內部實際使用了__next__()⽅法返回迭代器的下一個專案
    3. iter() 獲取迭代器, 內部實際使⽤的是__iter__()方法來獲取迭代器
    返回值:迭代器物件

其他:
    字串型別程式碼的執行:
        1. evel()  # 用來執行一個字串表示式，並返回表示式的值
        返回值:返回表示式計算結果
        2. exec()  # 執行儲存在字串或檔案中的 Python 語句，
        相比於 eval，exec可以執行更復雜的 Python 程式碼
        返回值:exec 返回值永遠為 None
        3. compile()  # 將一個字串編譯為位元組程式碼
        返回值:返回表示式執行結果
    輸入輸出:
        1. input() # 接受一個標準輸入資料
        返回值:返回為 string 型別
        2. print() # 用於列印輸出，最常見的一個函式
    記憶體相關:
        1. hash()  # 用於獲取取一個物件（字串或者數值等）的雜湊值
        返回值:返回物件的雜湊值
        2. id()   # 用於獲取物件的記憶體地址。
        返回值:返回物件的記憶體地址
    檔案操作相關:
        1. open()  #  用於扣列表開啟一個檔案, 建立一個檔案控制代碼
    模組相關:
        1. __import__  # 用於動態載入類和函式
        返回值:返回元組列表
    呼叫相關:
        1. callable()   # 用於檢查一個物件是否是可呼叫的。如果返回True，object仍然可能呼叫失敗；
                         但如果返回False，呼叫物件ojbect絕對不會成功。
        語法:callable(object物件)
        返回值:可呼叫返回 True，否則返回 False
    檢視內建屬性:
        1. dir()  #  函式不帶引數時，返回當前範圍內的變數、方法和定義的型別列表；
        帶引數時，返回引數的屬性、方法列表。如果引數包含方法__dir__()，該方法將被呼叫。
        如果引數不包含__dir__()，該方法將最大限度地收集引數資訊。
        返回值:返回模組的屬性列表
    匿名函式:
        1. lamda   #  表示的是匿名函式. 不需要用def來宣告, 一句話就可以宣告出一個函式
        語法: 函式名 = lambda 引數: 返回值
        注意: 1. 函式的引數可以有多個. 多個引數之間⽤逗號隔開
              2. 匿名函式不管多複雜. 只能寫一行, 且邏輯結束後直接返回資料
              3. 返回值和正常的函式⼀樣, 可以是任意資料型別