字串其他的內建方法

字串的strip

    strip方法可移除字串的首尾指定的字元，但無法移除字串中的
    eg：
        hai = '&&&&jiliji&&qide&&&&&'
        print(hai.strip('&'))   #1. 移除字元首尾的& 輸出結果：jiliji&&qide
        print(hai.lstrip('&'))  #2. 移除字元左邊的& 輸出結果：jiliji&&qide&&&&&
        print(hai.lstrip('&'))  #2. 移除字元右邊的& 輸出結果：&&&&&jiliji&&qide
 

字母大小寫

     eg： hai = 'Hello World'
    1.'lower'方法將所有的英文字母變為小寫
        print(hai.lower())  # 輸出結果： hello world

    2.'upper'方法將所有的英文字母變為大寫
        print(hai.upper())  # 輸出結果： HELLO WORLD

    3.'islower'判斷字串的英文字母是否都是小寫  判斷結果為布林值
        tlt = (hai.lower())   # 將'Hello World'變為小寫然後賦值給變數名tlt
        print(tlt.islower())  # 輸出結果： True

    4.'isupper'判斷字串的英文字母是否都是大寫  判斷結果為布林值
        print(hai.isupper())  # 'Hello World'不都是大寫 輸出結果： False
 

startswith和endswith方法

    eg： nice = 'my girl you are a start!'
    1.'startswith'用於判斷字串開頭是否是指定的字元 結果為布林值
       print(nice.startswith('y'))  # 不以y開頭 結果為：False
       print(nice.startswith('m'))  # 以m開頭 結果為：Ture
    2.'endswith'用於判斷字串結尾是否是指定的字元 結果為布林值
       print(nice.startswith('t'))  # 不以t結尾 結果為：False
       print(nice.startswith('!'))  # 以!結尾 結果為：Ture
 

format方法格式化輸出

    之前的格式化輸出方式用的是佔位符%s，%d，但缺點就是每個佔位符都要寫上對應的值這樣會顯得很繁瑣，
    而format方法的用法有很多種而且也更加簡便
    format用法：
      用法1：跟佔位符一樣 使用的是{}來佔位
       eg: 
          print('my {} {} {}are a {}!'.format('teacher', 'and', 'jason', 'sao boy'))
          # 結果為：my teacher and jasonare a sao boy!

      用法2：根據索引取值  可以反覆使用
       eg: 
          print('你是{0}，我是{1}，你是{0}{0}，我是{1}{1}'.format('風兒', '沙'))
          # 結果為：你是風兒，我是沙，你是風兒風兒，我是沙沙

      用法3：直接在字串的{}內寫入變數名
        eg: 
          print('你是{name1}，我是{name2}}'.format(name1='風兒', name2='沙'))
          # 結果為：你是風兒，我是沙

      用法4：直接使用已經出現過的變數名  # *注 要在字串前面加字母'f'
        eg: 
          name = '吳彥祖'
          print(f'你是{name}，你也是{name}')   # 結果為：你是吳彥祖，你也是吳彥祖

列表的內建函式

    '型別轉換' list()   # int float 資料型別不能轉換成列表
       字串轉列表 # 類似用for迴圈把字串的字元一個個取出然後再放到列表裡
       print(list('jason'))  # ['j', 'a', 's', 'o', 'n']

      字典轉列表 # 只能轉換字典中的key 無法取到value
      print(list({'name': 'jason', 'pwd': 123}))  # ['name', 'pwd']

      元組轉換列表  # 類似用for迴圈把元組元素一個個取出並放到列表裡
      print(list((11,22,33,44,55)))  # [11, 22, 33, 44, 55]

      集合轉換列表  # 類似用for迴圈把集合元素一個個取出並放到列表裡
      print(list({1, 2, 3, 4, 5}))  # [1, 2, 3, 4, 5]

      布林轉列表
      print(list(True))

   '常見的操作'
    date_info = ['monday', 'friday', 'sunday', 'likeday', 'fatherday']
    1.索引取值
      列表是有序的 可索引取值
      eg: print(date_info[2])  # 結果： sunday

    2.切片操作
      print(date_info[1:4])  # 結果：['friday', 'sunday', 'likeday']
    3.間隔 （步長）
      print(date_info[0:4:1])  # 結果:['monday', 'friday', 'sunday', 'likeday']
      print(date_info[1:4:2])  # 結果： ['friday', 'likeday']
      print(date_info[-1:-4:-1])  # 結果:['fatherday', 'likeday', 'sunday']
    4.統計列表中元素的個數
      print(leg(date_info[1:4:2]))  # 結果:5
    5.成員運算 最小判斷單位是元素不是元素裡面的單個字元
      print('day' in date_info)  # False
      print('sunday' in date_info)  # True
    6.列表新增元素的方式
        # 尾部追加'單個'元素
          date_info.append('oneday')
          print(date_info)
        # 指定位置插入'單個'元素
          date_info.insert(0, 'old')
        # 合併列表
           date_info.extend([1, 2, 3])
    7.刪除元素
      # 通用的刪除方式
        del date_info[0]
      # 就地刪除  # 指名道姓的直接刪除某個元素
        print(date_info.remove('sunday'))
      # 延遲刪除
        print(date_info.pop()) # 預設末尾彈出
        print(date_info.pop(2)) # 指定彈出
    8.修改列表元素
      date_info[0] = 'SB'
    9.排序
      a = [1, 2, 3, 4]
      a.sort()  # 升序
      a.sort(reverse=Ture)
    10.翻轉 
      a = [1, 2, 3, 4]
      a.reverse()  # 前後反轉
    11.比較運算
      a = [1, 2, 3, 4]
      b = [4，1，0，6]
      print(b > a)  # True
    12.統計列表中某個元素出現的次數
      num = [1, 1, 5,6,5, 6, 1]
      print(num.count(1))  # 統計元素1出現的次數
    13.清空列表
      num = [1, 1, 5,6,5, 6, 1]
      num.clear()  # 清空列表
##可變和不可變型別
  **記憶體地址用id關鍵字檢視
```python
  '''
     可變型別  # list、 dict、 set
          值發生改變 記憶體地址不會改變
  ''' 
      就比如列表，列表中修改元素並不會使列表的地址改變

  '''
     不可變型別  # str、 int、 tuple、 float、 bool
          值改變記憶體地址也一定會發生改變
  '''
      如字串，字串是一個整體不能修改其中的某個字元只能修改整個字串
      修改字串之後它的值變了記憶體地址也發生了變化

拓展

佇列：
　　佇列本質進是按照先來後到的順序依次執行
　　就比如排隊做核酸，只能按照先來後到的順序一個個來
　　　　例圖如下：

堆疊：
　　先進後出的原則 
　　可以理解為一個堆滿東西的倉庫之前先放進去的東西無法直接取出來，
　　要先把後面放的東西一件一件的取出來才可以把最先放進去的東西取出
　　　　例圖如下：