[TOC]
author：JevonWei
版權(quán)聲明：原創(chuàng)作品
blog:http://119.23.52.191/

一 基本數(shù)據(jù)類型

數(shù)字

int()

• 將字符串轉(zhuǎn)換為數(shù)字

a = '123'
b = int(a)
print(type(b),b)
    <class 'int'> 123

• 將十六進制數(shù)轉(zhuǎn)換為十進制輸出

num = "0011"
v = int(num,base=16)
print(v)
    17

bit_lenght()

• 當前數(shù)字的二進制，至少用N位表示

age = 5
r = age.bit_length()
print(r)
    3

字符串

• 字符串一旦創(chuàng)建，不可修改

• 一旦修改或者拼接，都會造成重新生成字符串

• 常用的內(nèi)置方法
  join(),split(),find(),strip(),replace(),upper(),lower()

capitalize()

• 首字母大寫

test = 'danran'
v = test.capitalize()
print(v)
    Danran

casefold()

lower()

• 字符串變小寫,casefold比lower效果更好

test = 'DanRan'   
v1 = test.casefold()
print(v1)
v2 = test.lower()
print(v2)
    danran
    danran

swapcase()

• 字符串中的字母大小寫轉(zhuǎn)換

test = "DanRan"
v = test.swapcase()
print(v)
    dANrAN

center()

• 設(shè)置字符串寬度，并將內(nèi)容居中，20代表總長度，* 空白未知填充

test = "Danran"
v = test.center(10)
print(v)
v1 = test.center(15,"*")
print(v1)
    Danran  
    *****Danran**** 

ljust()

• 設(shè)置字符串的長度,不足的位數(shù)以指定字符填充，字符串放在左邊

test = "Danran"
v = test.ljust(20,'*')
print(v)
    Danran**************

rjust()

• 設(shè)置字符串的長度,不足的位數(shù)以指定字符填充，字符串放在右邊

test = "Danran"
v = test.rjust(20,'*')
print(v)
    **************Danran

count()

• 在字符串中尋找子序列出現(xiàn)的次數(shù)

test = "DanranJevonDan"
v = test.count('e')
print(v)
v1 = test.count('a')        # 在test字符串中查找‘a(chǎn)’子字符串出現(xiàn)的次數(shù)
print(v1)
v1 = test.count('a',5)      # 在test字符串中從第五個字符開始查找‘a(chǎn)’子字符串出現(xiàn)的次數(shù)
print(v1)
v1 = test.count('a',5,7)    # 在test字符串中從第五個字符到第七個字符直間查找‘a(chǎn)’子字符串出現(xiàn)的次數(shù)
print(v1)
    1
    3
    1
    0

endswith()

• 判斷字符串是否是以指定字符結(jié)尾

test = "danran"
v = test.endswith("a")
print(v)
v = test.endswith("n")
print(v)
    False
    True

startswith()

• 判斷字符串是否以指定字符開始

test = "danran"
v = test.startswith("d")
print(v)
    True

find()

• 從開始往后找，找到第一個之后，獲取其位置

test = "danran"
v = test.find("an")
print(v)
            1
v = test.find("an",3,5)
print(v)
v = test.find("an",3,6)
print(v)
    -1
    4

format()

• 格式化字符串，將字符串中的占位符替換為指定的值

test = 'I am {name},age {age}'
print(test)
v = test.format(name='danran',age=18)   
print(v)
    I am {name},age {age}
    I am danran,age 18
        
test = 'I am {0},age {1}'       # 按參數(shù)的位置傳遞相應(yīng)的值
print(test)
v = test.format('danran',18)
print(v)
    I am {name},age {age}
    I am danran,age 18

format_map()

• 格式化，傳入的值為字典格式

test = 'I am {name},age {age}'
v1 = test.format(name='df',age=10)
v2 = test.format_map({"name":'danran','age':10})
print(v1)
print(v2)

index()

• 在字符串中尋找子字符串出現(xiàn)的位置，若在字符串中找不到子序列，則報錯

test = "danran"
v = test.index('n')
print(v)
v = test.index('q')    # 找不到此字符‘q’，則輸出報錯
print(v)
    Traceback (most recent call last):
      File "D:/Project/test.py", line 55, in <module>
        v = test.index('q')
    ValueError: substring not found
    2

isalnum()

• 判斷字符串中是否僅包含字符和數(shù)字

test = "danra123_"
v = test.isalnum()
print(v)
test = "danra123"
v = test.isalnum()
print(v)
    False
    True

isalpha()

• 判斷字符串中是否全為字母

test = "danran12"
v = test.isalpha()
print(v)

test = "danran"
v = test.isalpha()
print(v)
    False
    True

isdigit()

isdecimal()

isnumeric()

• 判斷字符串中是否全為數(shù)字，isdigit()比isdecimal()功能強大,isnumeric()還支持中文數(shù)字

test = "123456"
v1 = test.isdecimal()
v2 = test.isdigit()
print(v1,v2)
    True True
    
test = "②"
v1 = test.isdecimal()
v2 = test.isdigit()
print(v1,v2)
    False True
    
test = "二"
v1 = test.isdecimal()
v2 = test.isdigit()
v3 = test.isnumeric()
print(v1,v2,v3)
    False
    False
    True

isidentifier()

• 判斷字符串是否是合法的標識符，標識符由數(shù)字、字母及下劃線組成，且不能以數(shù)字開頭

a = "_123"
v = a.isidentifier()
print(v)    
    True

a = "123"
v = a.isidentifier()
print(v)
    False 

isprintable()

• 判斷是否存在不可顯示的字符，eg:/t,/n

test = "danran"
v = test.isprintable()
print(v)
    True

test = "dan\nZran"
v = test.isprintable()
print(v)
    False

isspace()

• 判斷字符串是否全為空格

test = "danran"
v = test.isspace()
print(v)
    False

test = "  dan  ran"
v = test.isspace()
print(v)
    False
    
test = "    "          # test字符串全為空，即空字符串
v = test.isspace()
print(v)
    True        

istitle()

• 將字符串修改為標題格式

test = "Dan ran Jevon Wei is me"
v = test.istitle()
print(v)
    False
    
test = "Dan ran Jevon Wei is me"
v1 = test.title()       # 將test字符串的所有字符轉(zhuǎn)換為首字母大寫，即標題格式
print(v1)
v2 = v1.istitle()       # v1即為標題，輸出為True
print(v2)
    Dan Ran Jevon Wei Is Me
    True

* join()

• 將字符串中的每個元素按照指定分隔符進行拼接

test = "DanranJevonWei"
print(test)
t = ' '
v1 = t.join(test)
v2 = "_".join(test)
print(v1)
print(v2)
    D a n r a n J e v o n W e i
    D_a_n_r_a_n_J_e_v_o_n_W_e_i

expandtabs()

• 斷句，即按指定字段分割

test = "username\temail\tpasswd\ndanran\tjevon@163.com\tPass1234\ndanran\tjevon@163.com\tPass1234\ndanran\tjevon@163.com\tPass1234"
v = test.expandtabs(15)    # \t制表符，每15位為一段，不足的以制表符填充
print(v)
    username       email          passwd
    danran         jevon@163.com  Pass1234
    danran         jevon@163.com  Pass1234
    danran         jevon@163.com  Pass1234

islower()

• 判斷字符串是否全為小寫字符

lower()

• 將字符串轉(zhuǎn)換為小寫

test = "DanRan"
v1 = test.islower()
v2 = test.lower()
print(v1)
print(v2)
    False
    danran

isupper()

• 判斷字符串是否全為大寫

upper()

• 將字符串轉(zhuǎn)換為大寫

test = "DanRan"
v1 = test.isupper()
v2 = test.upper()
print(v1)
print(v2)
    False
    DANRAN

lstrip()

• 去除字符串左邊指定的字符，默認去除空格，制表符及上邊空白行

rstrip()

• 去除字符串右邊指定的字符，默認去除空格，制表符及下邊空白行

strip()

• 去除字符串兩邊指定的字符，默認去除空格，制表符及兩邊空白行

test = "  Danran  "
v1 = test.lstrip()
v2 = test.rstrip()
v3 = test.strip()
print(v1)
print(v2)
print(v3)
    Danran  
      Danran
    Danran

test = "Danran\n  "
v1 = test.lstrip('Da')      # 去除字符串左邊的“Da”字符
v2 = test.rstrip()          # 去除字符串右邊的空格，制表符及空白行
v3 = test.strip()
print(v1)
print(v2)
print(v3)
    nran        # v1 
                # v1
    Danran      # v2
    Danran      # v3

maketrans()

• 構(gòu)建一個字符的對應(yīng)關(guān)系

translate()

• 根據(jù)指定的字符對應(yīng)關(guān)系將字符串進行轉(zhuǎn)換

test = "Wei are you Dan ran on"         # 定義一個字符串
v = str.maketrans("Danran","123456")    # 構(gòu)建一個字符對應(yīng)關(guān)系，Danran對應(yīng)為123345
new_test = test.translate(v)            # 將test字符串按照構(gòu)建的v字符對應(yīng)關(guān)系進行轉(zhuǎn)換
print(new_test)
    Wei 54e you 156 456 o6

partition()

• 將字符串按指定字符進行分割，僅分割為三份，從左邊開始分割

rpartition()

• 將字符串按指定字符進行分割，僅分割為三份，從右邊開始分割

split()

• 將字符串按指定字符串進行分割，可指定查找到的分割符的次數(shù)，不輸出分隔符

rsplit()

• 將字符串按指定字符串進行分割，可指定查找到的分割符的次數(shù)，不輸出分隔符

test = "Danrandanrandanran"     # 定義一個字符串
v1 = test.partition("a")        # 將字符串以‘a(chǎn)’字符分割為三份，從左邊開始分割
v2 = test.rpartition("a")       # 將字符串以‘a(chǎn)’字符分割為三份，從右邊開始分割
print(v1)   
print(v2)
    ('D', 'a', 'nrandanrandanran')
    ('Danrandanrandanr', 'a', 'n')
    

test = "Danrandanrandanran"     # 定義一個字符串
v1 = test.split("a",2)          # 將字符串以‘a(chǎn)’字符分割，從左邊開始查找兩個‘a(chǎn)’分割字符，拿不到'a'分隔符
v2 = test.rsplit("a",2)         # 將字符串以‘a(chǎn)’字符分割，從右邊開始查找兩個‘a(chǎn)’分割字符，拿不到'a'分隔符
print(v1) 
print(v2)
    ['D', 'nr', 'ndanrandanran']
    ['Danrandanrand', 'nr', 'n']

splitlines()

• 根據(jù)換行符分割字符串，參數(shù)為True時保留換行符，參數(shù)為False是移除換行符

test = "Dan\nran\n Jevo\nnan"
v = test.splitlines(True)       # 參數(shù)為True，保留換行符
print(v)    
    ['Dan\n', 'ran\n', ' Jevo\n', 'nan']
    
test = "Dan\nran\n Jevo\nnan"
v = test.splitlines(False)      # 參數(shù)為False，移除換行符
print(v)
    ['Dan', 'ran', ' Jevo', 'nan']

startswith()

• 判斷字符串是否以指定的字符開頭

endswith()

• 判斷字符串是否以指定的字符結(jié)尾

test = "backend 1.1.2.3"
v = test.startswith('a')
print(v)
    False

test = "backend 1.1.2.3"
v = test.endswith('3')
print(v)
    True

swapcase()

• 指定字符串大小寫轉(zhuǎn)換

test = 'DanRan'
v = test.swapcase()
print(v)
    dANrAN

len()

• 獲取當前字符串的長度

test = "Danran"
v=len(test)
print(v)
    6

replace()

• 查找字符串中的特定字符并替換

test = "Danran"
v=test.replace('a','AAA')
print(v)
    DAAAnrAAAn
 
test = "Danranaev" 
v=test.replace('a','AAA',2)   # 只替換前兩個匹配的字符
print(v)
    DAAAnrAAAnaev

range()

• 幫忙創(chuàng)建連續(xù)的數(shù)字。

v = range(100)   
for item in v:
    print(item)

v = range(0,100,5)    # 間隔為5，輸出0-100的數(shù)字
for item in v:
    print(item)

索引

• 通過下標獲取字符串中的某一個字符

test = "alex"
v=test[2]
print(v)    
    e

切片

• 將字符串進行切片

test="alex"
v=test[0:2]
print(v)
    al

test="alex"
v=test[0:-1]
print(v)
    ale

練習(xí)

• 將文件對應(yīng)的索引打印出來

test = input(">>>")
print(test)
l = len(test)
print(l)
    
r = range(0,l)
for item in r:
    print(item,test[item])
        danran      # print(test)
        6           # print(l),打印test字符串的長度
        0 d
        1 a
        2 n
        3 r
        4 a
        5 n

列表 (有序，元素可以被修改)

• 中括號括起來
• 使用“,”分割每個元素
• 列表中的元素可以是數(shù)字，字符串，列表，布爾值...
• “集合”內(nèi)部可嵌套任何類型

索引

索引取值
li = [1,2,3,"age",["Jevon","danran",44],1,5,7]
print(li[4])                    # 通過索引取列表中索引位置為4的值
print(li[3:6])              # 通過索引取列表中索引位置為3到6的值
    ['Jevon', 'danran', 44]
    ['age', ['Jevon', 'danran', 44], 1]

通過索引修改列表元素
li = [1,2,3,"age",["Jevon","danran",44],1,5,7]
li[1] = 100
print(li)
    [1, 100, 3, 'age', ['Jevon', 'danran', 44], 1, 5, 7]

li = [1,2,3,"age",["Jevon","danran",44],1,5,7]
    li[1] = [100,99,98] 
    print(li[1])
        [100, 99, 98]

切片

通過切片修改列表元素
li = [1,2,3,"age",["Jevon","danran",44],1,5,7]
li[1:3] = [100,90]              # 通過切片修改列表的第1到3位元素
print(li)
    [1, 100, 90, 'age', ['Jevon', 'danran', 44], 1, 5, 7]

for,while循環(huán)

for 循環(huán)取列表中的每個值
li = [1,2,3,"age",["Jevon","danran",44],1,5,7]
for item in li:
    print(item)
        1
        2
        3
        age
        ['Jevon', 'danran', 44]
        1
        5
        7

in

• 判斷指定元素是否包含在列表中

li = [1,2,3,"age",["Jevon","danran",44],1,5,7]
v = 'age' in li
print(v)
    True
    
li = [1,2,3,"age",["Jevon","danran",44],1,5,7]
v = 'danran' in li
print(v)
    False

li = [1,2,3,"age",["Jevon","danran",44],1,5,7]
v = 'danran' in li[4]
print(v)
    True

del

刪除列表元素
li = [1,2,3,"age",["Jevon","danran",44],1,5,7]
del li[0]                   # 刪除列表的第“0”位元素
print(li)
    [2, 3, 'age', ['Jevon', 'danran', 44], 1, 5, 7]
        
刪除列表多個元素
li = [1,2,3,"age",["Jevon","danran",44],1,5,7]
del li[1:3]                 # 通過切片刪除列表的第1到3個元素
print(li)
    [1, 'age', ['Jevon', 'danran', 44], 1, 5, 7]

查找元素

查找子列表中的元素
li = [1,2,3,"age",["Jevon","danran",[44,22]],1,5,7]
print(li[4][2][1])              # 查找列表中的22元素
    22      

數(shù)據(jù)類型轉(zhuǎn)換

將字符串轉(zhuǎn)換為列表

• 內(nèi)部通過調(diào)用for循環(huán)實現(xiàn)

s = "asdfqwertaffzxcvvbgfssaa"
new_li = list(s)                # 將字符串s轉(zhuǎn)換為列表
print(new_li)
    ['a', 's', 'd', 'f', 'q', 'w', 'e', 'r', 't', 'a', 'f', 'f', 'z', 'x', 'c', 'v', 'v', 'b', 'g', 'f', 's', 's', 'a', 'a']

列表轉(zhuǎn)換為字符串

若字符串為純字符組成
    li = ["12","age","danran"]
    v = "".join(li)             # 將每個字符間以“”分割
    print(v)
        12agedanran
        
若字符串由字符和數(shù)字組成，則需要通過for循環(huán)逐個處理
    li = [11,22,33,"abc",'danran']
    s = ""
    for i in li:
        s += str(i)
    print(s)
        112233abcdanran

append()

• 在列表的最后追加元素

li = [11,22,33,"abc",'danran']
li.append("Jevon")
print(li)
    [11, 22, 33, 'abc', 'danran', 'Jevon']

clear()

• 清空列表

li = [11,22,33,"abc",'danran']
li.clear()
print(li)
    []

copy()

• 拷貝復(fù)制列表，淺拷貝

li = [11,22,33,"abc",'danran']
v = li.copy()
print(v)
    [11, 22, 33, 'abc', 'danran']

count()

• 統(tǒng)計指定元素在列表中出現(xiàn)的次數(shù)

    li = [11,2,33,"abc",'danran',2]
    v = li.count(2)
    print(v)
        2

extend()

• 將指定的元素或子列表擴展到原列表中，參數(shù)為可迭代對象

li = [11,2,33,"abc",'danran',2]
li.extend("Jevon")
print(li)
    [11, 2, 33, 'abc', 'danran', 2, 'J', 'e', 'v', 'o', 'n']

li = [11,2,33,"abc",'danran',2]
li.extend([999,"Jevon"])
print(li)
    [11, 2, 33, 'abc', 'danran', 2, 999, 'Jevon']
    
比較append()
li = [11,2,33,"abc",'danran',2]
li.append([999,"Jevon"])
print(li)
    [11, 2, 33, 'abc', 'danran', 2, [999, 'Jevon']]         

index()

• 根據(jù)指定的值獲取當前值的索引位置，默認從左向右查找，可指定查找的起始及終止位置

li = [11,2,33,"abc",'danran',2]
v = li.index(2)             # 默認從前向后查找
print(v)
    1

li = [11,2,33,"abc",'danran',2]
v = li.index(2,2)           # 指定查找的起始位置為2
print(v)    
    5

insert()

• 在列表的指定索引位置插入元素

li = [11,2,33,"abc",'danran',2]
li.insert(1,"Jevon")            # 在列表的第1索引位置插入元素“Jevon”
print(li)
    [11, 'Jevon', 2, 33, 'abc', 'danran', 2]

pop()

• 刪除列表指定索引位置的元素，并可獲取刪除的值，默認刪除刪除最后的元素
  li = [11,2,33,"abc",'danran',2]
  v = li.pop() # 刪除列表最后以為元素
  print(v) # 返回刪除的元素
  print(li)
  2
  [11, 2, 33, 'abc', 'danran']

  刪除列表索引位置為3的元素
  li = [11,2,33,"abc",'danran',2]
  v = li.pop(3)
  print(v)
  print(li)
  abc
  [11, 2, 33, 'danran', 2]

remove()

• 刪除列表指定元素，左邊優(yōu)先

li = [11,2,33,"abc",'danran',2]
li.remove(33)               # 刪除列表中的元素“33”
print(li)
    [11, 2, 'abc', 'danran', 2]         

reverse()

• 將當前列表進行反轉(zhuǎn)

li = [11,2,33,"abc",'danran',2]
li.reverse()
print(li)
    [2, 'danran', 'abc', 33, 2, 11]

sort()

• 將列表中的元素排序

從小到大排序
li = [11,22,44,11,2,77]
li.sort()
print(li)
    [2, 11, 11, 22, 44, 77]
    
從大到小排序
li = [11,22,44,11,2,77]
li.sort(reverse=True)                   
print(li)
    [77, 44, 22, 11, 11, 2]         

元組 (有序的)

• 習(xí)慣寫元組的時候，隨后在最后加入“,”
• 元素不可被修改，不能被刪除或增加

tu = (11,"danran",(1,2,3),[(33,44)],True,123,)
print(tu)
    (11, 'danran', (1, 2, 3), [(33, 44)], True, 123)

取值

通過切片取值

tu = (11,"danran",(1,2,3),[(33,44)],True,123,)
v = tu[2:5]
print(v)
    ((1, 2, 3), [(33, 44)], True)

通過索引取值

tu = (11,"danran",(1,2,3),[(33,44)],True,123,)
v = tu[2]
print(v)        
    (1, 2, 3)           

通過for循環(huán)取元組中的值

tu = (11,"danran",(1,2,3),[(33,44)],True,123,)
for item in tu:
  print(item)   
        11
        danran
        (1, 2, 3)
        [(33, 44)]
        True
        123

數(shù)據(jù)類型轉(zhuǎn)換

• 將字符串，列表，元組互相轉(zhuǎn)換

    s = "asdfghj124"
    li = ["danran",123,[11,23]]
    tu = (123,123,"danran")
    
    將字符串s轉(zhuǎn)換Wie元組
    v = tuple(s)
    print(v)
        ('a', 's', 'd', 'f', 'g', 'h', 'j', '1', '2', '4')
        
    將列表轉(zhuǎn)換為元組
    v = tuple(li)
    print(v)    
        ('danran', 123, [11, 23])
        
    將元組轉(zhuǎn)換為列表
    v = list(tu)
    print(v)
        [123, 123, 'danran']
        
    將元組轉(zhuǎn)換Wie字符串
    v = str(tu)
    print(v)
    print(type(v))
        (123, 123, 'danran')
        <class 'str'>           

count()

• 統(tǒng)計指定元素在元組中出現(xiàn)的次數(shù)

tu = (11,"danran",(11,22,3),11,True,)
v = tu.count(11)
print(v)
    2

index()

• 返回指定元素在元組中的索引位置，左邊優(yōu)先

tu = (11,"danran",(11,22,3),11,True,)
v = tu.index(11)
print(v)
    0

元組中列表一級元素不可修改，但列表中的元素可被修改

tu = (11,"danran",(11,22,3),[(12,23,34),12],True,)
tu[3][1] = 1111
print(tu)
    (11, 'danran', (11, 22, 3), [(12, 23, 34), 1111], True)

字典

• 字典的value可以是任何值
• 列表、字典不能作為字典的key
• 字典是無序的

info = {"k1":"12","k2":"23"}
print(info)
    {'k1': '12', 'k2': '23'}

獲取字典的值

info = {"k1":"12","k2":"23"}
v = info["k2"]
print(v)
    23

del()

• 字典支持del刪除

info = {"k1":"12","k2":"23"}
del info["k1"]
print(info)
    {'k2': '23'}

for循環(huán)字典

默認for循環(huán)只返回key鍵
info = {"k1":"12","k2":"23"}
for item in info:
  print(item)
    k1
        k2
        
for循環(huán)返回字典的key鍵
info = {"k1":"12","k2":"23"}
for item in info.keys():
  print(item)
        k1
        k2
        
for循環(huán)獲取字典的value值
info = {"k1":"12","k2":"23"}
for item in info.values():
  print(item)
        12
        23
        
for同時返回字典的key鍵和value值
info = {"k1":"12","k2":"23"}
for k,v in info.items():
  print(k,v)
    k1 12
        k2 23

clear()

• 清空元組

copy（）

• 復(fù)制拷貝元組

fromkeys()

• 根據(jù)序列創(chuàng)建字典，并指定統(tǒng)一的值

v = dict.fromkeys(["k1",12,"danran"])
print(v)
    {'k1': None, 12: None, 'danran': None}
    
v = dict.fromkeys(["k1",12,"danran"],"Jevon")
print(v)
    {'k1': 'Jevon', 12: 'Jevon', 'danran': 'Jevon'}

get()

• 根據(jù)字典的鍵取值

info = {"k1":"12","k2":"23"}
v = info.get("k1")
print(v)
    12
    
若指定的鍵不存在，則返回None,并將默認值賦給此不存在的鍵
info = {"k1":"12","k2":"23"}
v = info.get("k1111"，"danran")
print(v)
    None
    
info = {"k1":"12","k2":"23"}
v = info.get("k1111","danran")
print(v)
    danran

pop()

• 刪除字典中的鍵值對，當刪除的鍵值對不存在時，可返還默認值

info = {"k1":"12","k2":"23"}
v = info.pop("k1")          # 刪除k1鍵值對
print(info)         
print(v)                    # 將刪除的k1鍵值對打印出來
    {'k2': '23'}
    12

刪除的鍵值對k1111不存在，則返回“danran”  
info = {"k1":"12","k2":"23"}
v = info.pop("k1111","danran")
print(info)
print(v)
    {'k1': '12', 'k2': '23'}
    danran

popitem()

• 隨機刪除鍵值對，并返回刪除的鍵值對
  info = {"k1":"12","k2":"23"}
  v = info.popitem()
  print(info)
  print(v)
  {'k1': '12'}
  ('k2', '23')

setdefault()

• 設(shè)置鍵的默認值，若鍵值對已存在，則獲取當前key對應(yīng)的值，若key不存在，則設(shè)置此key對應(yīng)的值為指定的值

info = {"k1":"12","k2":"23"}
v = info.setdefault("k111","12334")
print(info)
print(v)
    {'k1': '12', 'k2': '23', 'k111': '12334'}
    12334

update()

• 更新字典，如key存在，則更新相應(yīng)的鍵值，若key不存在，則增加相應(yīng)的鍵值對

info = {"k1":"12","k2":"23"}
info.update({"k1":"1234","k3":"11"})
print(info)
    {'k1': '1234', 'k2': '23', 'k3': '11'}

集合

• 集合為無序的，且為不可變數(shù)據(jù)類型。
• 定義：由不同元素組成的集合，集合中是一組無序排列的可hash值，可作為字典的key，即必須為不可變類型。
• 特性：
  集合的目的是將不同的值存放在一起，不同的集合間用來做關(guān)系運算，無須糾結(jié)于集合中單個值。

創(chuàng)建集合

s = {1,2,3,4,5}
print(type(s))
    <class 'set'>

set()

• 創(chuàng)建集合

s = set("danran")
print(s)
    {'a', 'r', 'd', 'n'}

frozenset()

• 創(chuàng)建不可變集合

s = frozenset("danrna")
print(s)
    frozenset({'n', 'd', 'a', 'r'})

add()

• 集合中添加元素

s = {1,2,3,4,5}
s.add("danran")
print(s)    
    {1, 2, 3, 4, 5, 'danran'}

clear

• 清空集合

s = {1,2,3,4,5}
s.clear()
print(s)
    set()

copy()

• 集合拷貝復(fù)制

  s = {1,2,3,4,5}
  a = s.copy()
  print(a)
  {1, 2, 3, 4, 5}

pop()

• 隨機刪除集合中的元素

s = {1,2,3,4,5}
s.pop()
print(s)
    {2, 3, 4, 5}

remove()

• 刪除集合中的指定元素，若指定元素不存在，則報錯

s = {1,2,3,4,5,"danran"}        
s.remove("danran")          # 刪除集合中的元素“danran”
print(s)
    {1, 2, 3, 4, 5}

discard()

• 刪除集合中的指定元素，若指定元素不存在，則不返回報錯信息

s = {1,2,3,4,5,"danran"}
s.discard("danran")
print(s)
    {1, 2, 3, 4, 5}

intersection()

• 兩個集合的交集，等同于"&".

p = set(["danran","Jevon","Wei","Jevon"])
l = set(["dan","Wei"])
print(p,l)
print(p.intersection(l))        # intersection()等用于"&".
print(p&l)
    {'Jevon', 'danran', 'Wei'} {'dan', 'Wei'}
    {'Wei'}
    {'Wei'}

union()

• 兩個集合的并集，等同于"|"。

p = set(["danran","Jevon","Wei","Jevon"])
l = set(["dan","Wei"])
print(p,l)
print(p.union(l))       # 輸出兩個集合的并集，等同于"|"符合。
print(p|l)
    {'Jevon', 'danran', 'Wei'} {'dan', 'Wei'}
    {'dan', 'Jevon', 'danran', 'Wei'}
    {'dan', 'Jevon', 'danran', 'Wei'}

difference()

• 兩個集合的差集，等同于"-"符號。

p = set(["danran","Jevon","Wei","Jevon"])
l = set(["dan","Wei"])
print(p,l)                      # 打印兩個集合
print(p.difference(l))          # 集合p于集合l的差集
print(p-l)                      # 集合p于集合l的差集
print(l.difference(p))          # 集合l于集合p的差集
print(l-p)                      # 集合l于集合p的差集
    {'danran', 'Jevon', 'Wei'} {'Wei', 'dan'}           # 打印兩個集合
    {'danran', 'Jevon'}                                 # 集合p于集合l的差集
    {'danran', 'Jevon'}                                 # 集合p于集合l的差集
    {'dan'}                                             # 集合l于集合p的差集
    {'dan'}                                             # 集合l于集合p的差集

symmetric_difference()

• 兩個集合的交叉補集運算，等同于"^"符號

p = set(["danran","Jevon","Wei","Jevon"])
l = set(["dan","Wei"])
print(p,l)
print(p.symmetric_difference(l))        # p集合于l集合的交叉補集
print(p^l)                              # p集合于l集合的交叉補集
print(l.symmetric_difference(p))        # l集合于p集合的交叉補集
print(l^p)                              # l集合于p集合的交叉補集
    {'Wei', 'Jevon', 'danran'} {'Wei', 'dan'}           
    {'danran', 'Jevon', 'dan'}          # p集合于l集合的交叉補集
    {'danran', 'Jevon', 'dan'}          # p集合于l集合的交叉補集
    {'Jevon', 'danran', 'dan'}          # l集合于p集合的交叉補集
    {'Jevon', 'danran', 'dan'}          # l集合于p集合的交叉補集

difference_update()

• 更新兩個集合的差集

p = set(["danran","Jevon","Wei","Jevon"])
l = set(["dan","Wei"])
print(p,l)
s = p.difference(l)
print(s)
p.difference_update(l)          # 更新p集合與l集合的差集
print(s)
    {'Wei', 'Jevon', 'danran'} {'dan', 'Wei'}
    {'Jevon', 'danran'}
    {'Jevon', 'danran'}         # 更新后的差集

symmetric_difference_update

• 更新兩個集合的交叉補集

p = set(["danran","Jevon","Wei","Jevon"])
l = set(["dan","Wei"])
print(p,l)
s = p.symmetric_difference(l)
print(s)
p.symmetric_difference_update(l)        # 更新兩個集合的交叉補集
print(s)                
    {'danran', 'Wei', 'Jevon'} {'Wei', 'dan'}
    {'danran', 'Jevon', 'dan'}
    {'danran', 'Jevon', 'dan'}          # 輸出更新后的兩個集合的交叉補集

intersection_update()

• 更新兩個集合的交集

isdisjoint()

• 如果兩個集合沒有交集，即返回"True"

p = set(["danran","Jevon","Wei","Jevon"])
l = set(["dan","Wei"])
q = set(["li","ran"])
print(p.isdisjoint(l))      # 集合p和集合l交集不為空，即返回False
print(l.isdisjoint(q))      # 集合l和集合q交集為空，即返回True
    False
    True

issubset()

• 判斷集合是否是子集關(guān)系，等同于"l<=p"符號。

p = set(["danran","Wei","Jevon"])
l = set(["danran","Wei"])
print(l.issubset(p))        # 集合l是集合p的子集
print(l<=p)
print(p.issubset(l))
    True
    True
    False

issuperset()

• 判斷集合是否是父集關(guān)系，等同于"p>=l"符號。

p = set(["danran","Wei","Jevon"])
l = set(["danran","Wei"])
print(p.issuperset(l))          # 集合p是集合l的父集
print(p>=l)
    True
    True

update()

• 對集合更新多個值

p = set(["danran","Wei","Jevon"])
l = set(["danran","xin"])
p.update(l)
print(p)        
    {'Wei', 'danran', 'Jevon', 'xin'}
    
對可迭代的數(shù)據(jù)都可更新到集合中
p = set(["danran","Wei","Jevon"])
p.update(["dan"])
print(p)
    {'dan', 'Wei', 'danran', 'Jevon'}

字符串格式化

• 百分號格式
• format格式

百分號格式

%[(name)][flags][width].[precision]typecode

- (name)        # 可選，用于選擇指定的key
- flags         # 可選，可供選擇的值由
    +           右對齊：正數(shù)前加正號，負數(shù)前加負號
    -           左對齊：正數(shù)前無符號，負數(shù)前加負號
    空格  右對齊：正數(shù)前加空格，負數(shù)前加負號
    0           右對齊：正數(shù)前無符號，負數(shù)前加負號；用0填充空白處
    
- width     # 可選，占有寬度
- .precision    # 可選，小數(shù)點后保留的位數(shù)
- typecode      # 必選            

format格式