• 字元

encode
decode

test = 'aLexaLex'
v = test.find('ex',5,7)    #預設從開始往後找現在設定5到7的閉開區間
print(v)                   #找到第一個之後，獲取其位置，沒找到返回-1


test = '你是風兒我是沙'
print(test)
t = ' '
v = t.join(test)               #將字串中的每一個元素按照指定分隔符進行拼接
print(v)

test = 'aLex'
v1 = test.islower()              #判斷全是小寫
v3 = test.isupper()              #判斷全是大寫
 

v2 = test.lower()                #全是變成小寫
v4= test.upper()                 #全是變成大寫
print(v1,v2,v3,v4)

test = 'testasdsdfgs'
v1 = test.rpartition('s')               #找到最右邊的字元分割成3份
v2 = test.partition('s')                #找到最左邊的字元分割成3份
v3 = test.rsplit('s',2)                 #找到字元(預設全部，這找2個從右邊開始)，去除字元並分割
 

v4 = test.split('s')                    #找到字元，去除字元並分割
print(v1,v2,v3,v4)

test = '\n1 \naLe xx'
v1 = test.lstrip()               #去除空白\n\t，從最左邊開始連續的
v2 = test.rstrip()                #去除空白\n\t，從最右邊開始連續的
v3 = test.strip()                #去除空白\n\t，從2邊開始連續的
v4 = test.rstrip('x')            #指定去除x，從2變開始連續的
 

print(v1,v2,v3,v4)

test = 'aLex'
v = test[0:2]
v = len(test)  #可以讀列表元素
index = 0
while index < len(test):
    index += 1
for index in test:
    print(index)
v = range(0,100,5)   #建立一個100個數的陣列，for迴圈才真實建立，預設0開始，可設定0到100步長5
for item in rang(0,len(test)):
    print(item,test[item])
print('=====================')

test = 'aLex'
v = test.capitalize()   #首字母大寫其他字母小寫
print(v)

test = 'aLex'
v1 = test.casefold()      #將字串中所有語言中大寫變小寫
print(v1)
v2 = test.lower()         #將字串中英文大寫變小寫
print(v2)

test = 'aLex'
v = test.center(20,'*')    #設定寬度，並內容居中，20代指總長度，*空白未知填充，一個字元，可有可無
v1 = test.ljust(20,'*')    #設定寬度，並內容居左，20代指總長度，*空白未知填充，一個字元，可有可無
v2 = test.rjust(20,'*')    #設定寬度，並內容居右，20代指總長度，*空白未知填充，一個字元，可有可無
v3 = test.zfill(20)        #設定寬度，並內容居右，20代指總長度，只用0來填充
print(v,v1,v2,v3)

test = 'aLexaLex'
v = name.count('ex')       #去字串中尋找子序列出現次數
print(v)

test = 'aLexaLex'
v = name.count('ex',6,8)   #數字符出現次數，預設全部，設定從第6個到第8個的閉開區間
print(v)

test = 'aLex'
v = test.endswith('ex')      #判斷以什麼結尾
print(v)
v = test.startwith('ex')     #判斷以什麼開始
print(v)

test = "username\temail\tpassword\nlaiying\tying@qq.com\t123\nlaiying\tying@qq.com\t123\nlaiying\tying@qq.com\t123"
v = test.expandtabs(20)         #\t是製表符，expandtabs,斷句20，到\t不足20補空格
print(v,len(v))



test = 'i am {name},age {a}'
print(test)
v = test.format(name='alex',a=19)  #格式化，將一個字串中的佔位符替換為指定的值
print(v)
test = 'i am {0},age {1}'
print(test)
v = test.format('alex',19)         #格式化，將一個字串中的佔位符替換為指定位置的值
print(v)

test = 'i am {name},age {a}'
v = test.format_map({"name":'alex',"a":19})  #格式化，傳入的值只能是字典
print(v)

test = 'aLexaLex'
v = test.index('ex',5,8)    #預設從開始往後找現在設定5到7的閉開區間
print(v)                   #找到第一個之後，獲取其位置，沒找到報錯

test = "uasf890"
v = test.isalnum()          #判斷字串中字串中是否只包含數字和字母
print(v)

test = "uasf"
v = test.isalpha()           #判斷字串中字串中是否只包含字母
print(v)

test = "二"
v1 = test.isdecimal()          #判斷字串中字串中是否只包含數字 2
v2 = test.isdigit()            #判斷字串中字串中是否只包含數字（還有數字符號）②
v3 = test.isnumeric()          #判斷字串中字串中是否只包含數字（還有數字符號、漢字）二
print(v1,v2,v3)

a = "la_123"
v = a.isidentifier()           #判斷標誌符 識別符號只包含，字母、數字、下劃線且首字母不是數字
print(v)

test = 'oiue\turyyffb'
v = test.isprintable()           #判斷字串是否存在不可顯示的字元\t製表\n換行
print(v)


test = ' '
v = test.isspace()                 #判斷字元全空格
print(v)

test = 'sdusdjnd and sdin is hwj'
v1 = test.istitle()                 #判斷標題，也是所有單詞首字母大寫
test1 = test.title()
v2 = test1.istitle()
print(v1,test1,v2)

v = 'aesdioujkdfhiudoiasdoiuf'
m = str.maketrans('aeiou','12345')  #設定前後對應關係
new_v = v.translate(m)              #對m中字元進行對應關係變換
print(new_v)

v = 'alexalex'
new_v = v.replace('ex','apeiou',2)     #對匹配到的序列替換，預設全替換，現在只替換前2個
print(new_v)

test = 'asdfadsf\nasdasfdsf\nsdfa'
v = test.splitlines(True)                #分割，只能根據，true，false；是否保留換行
print(v)

test = 'backend1.1.1.1'
v  = test.startswith('a')                #判斷以XXX開頭
v1 = test.endswith('a')                  #判斷以XXX結尾
print(v,v1)

test = 'aLex1'
v = test.swapcase()                      #大小寫轉換
print(v)

• 列表

li = [11, 22, 33, 44]
v = li.append(5)     #直接修改list無返回值，元素做整體追加
print(li)
li = [11, 22, 33, 44]
li.extend([22])           #把元素迴圈擴充套件到列表中
print(li)

li = [11, 22, 33, 44]
li.clear()           #清空
print(li)

li = [11, 22, 33, 44]
v = li.copy()          #淺拷貝
print(v)

li = [11, 22, 33, 44]
v = li.count(22)         #計算元素出現的個數
print(v)

li = [11, 22, 33, 44]
v = li.index(22)           #根據值獲取當前值獲取位置
print(v)

li = [11, 22, 33, 22, 44]
li.insert(0, 99)           #在指定索引位置插入元素
print(li)

li = [11, 22, 33, 22, 44]
v = li.pop()               #預設刪除最後一個位置的值並返回當前值
print(li,v)

li = [11, 22, 33, 22, 44]
li.remove(11)               #刪除第一個指定值
print(li)

li = [11, 22, 33, 22, 44]
li.remove(11)               #刪除第一個指定值
print(li)

li = [11, 22, 33, 22, 44]
li.reverse()               #將當前列表反轉
print(li)

li = [11, 22, 33, 22, 44]
li.sort(reverse=True)               #列表從小到大排序,現在從大到小
print(li)


li = [1, 2, 43, [1, 2, 3], "age", "alex"]
for item in range(0, 5):
    print(li[item])
print(li[3][2])
li[1:3] = [1, 20, 32, 33]
print(li)
del li[1:3]

• 元組

tu = (11, 22, 11, 33, 44,)
tu.count(11)      # 獲取指定元素在元組中出現次數
v = tu.index(11)  # 獲取指定元素在元組中第一個的位置
print(v)

tu = (111, 222, 333, )  # 元素不可被修改。

v = tu[0]

v = tu[0:2]

for item in range(0, 5):
    print(tu[item])

s = "djqwuidsdaf"
li = ["dgfhfsd", "djksd"]
tu = (123, 123, "asd")

v = list(tu)    #元組轉換列表

• 字典

info = {
    "k1": "v1",      # 鍵值對
    "k2": "v2"
}
v = dict.fromkeys([123, 'k1', 999], 123)  # 根據序列建立字典,附上固定值
print(v)

v = info.get('k1')    # 獲取鍵值，key不存在，可以指定預設值
v = info.pop('k11', 90)    # 刪除並獲取值，如沒有返回指定值
v = info.popitem()     # 隨機刪除專案
print(v)

v = info.setdefault('k1', '123')   # 設定值，若key存在，獲取當前key對應的值。

info.update({'k1': '1111', 'k3': 123})
info.update(k1='1121', k3=123)       # 更新
print(info)


info = {            # 鍵值對鍵值的key必須是確定值，hashable轉換存
    2: "asd",
    "k1": 'sda',
    "k4": 'ssa',
    "k2": "v1",      # 鍵值對
    "k3": [22, 33, 44],
    True: 'sda',
    (10, 20): 'sda'
}
print(info)

del info[1]  # 根據k值尋找操作

for k, v in info.items():
    print(k, v)

• 集合

s = frozenset('hello')        # 不可變集合
s = {1, 1, 2, 3, 4, 5, '1'}   # 去重,集合
s.pop()
s.pop()
s.remove(4)
v = s.discard(11)
print(s, v)

Python_1 = {'alex', 'apple', 'orange', 'alex'}
linux_1 = {'alex', 'apple', 'banana'}
p_s = set(Python_1)
l_s = set(linux_1)
print(p_s, l_s)
print(p_s.intersection(l_s))   # 合集
print(p_s & l_s)

print(p_s.union(l_s))   # 並集
print(p_s | l_s)

print(p_s - l_s)       # 差集
print(l_s.difference(p_s))       # 差集
print(p_s.difference_update(l_s),p_s)

print(p_s.symmetric_difference(l_s)) # 交叉補集
print(p_s ^ l_s)

s1 = {1, 2}
s2 = {3, 5}
print(s1.isdisjoint(s2))

s1 = {1, 2}
s2 = {1, 4, 3}
print(s1.issubset(s2))
print(s2.issuperset(s1))
s1.update(s2)           # 更新多個值比union多個賦值add()只能傳一個值
print(s1)