摘要：一字典定義字典獲取元素這兩個的區別用在不存在的時候不會拋出設置當不存在的時候返回的內容增加和修改元素修改和增加元素的方法都是這個刪除元素刪除的同時返回刪除的內容如果刪除不存在的會報這個時候就需要給定返回值這樣返回的就是不會報錯誤從字典中隨機

定義字典:
d = {}
d = dict()
d = {"a":1, "b":2}

d["a"]
d.get("a")
>這兩個的區別,用get在key不存在的時候不會拋出Error;

d.get("a", "information")   //設置當key不存在的時候返回的內容;

d["a"] = 3   //修改和增加元素的方法都是這個

d.pop("c")  //刪除的同時返回刪除的內容
>如果刪除不存在的key會報KeyError,這個時候就需要給定返回值

d.pop("c", "information")
help(d.pop)

>這樣返回的就是information,不會報KeyError錯誤;

d.popitem()    //從字典中隨機刪除一個;

利用關鍵字del 刪除,del 可以刪除一個變量 同時也可以用來刪除字典:
del d["a"]

>[生成一個生成器,可以進行迭代操作][字典是無序的,所以返回的迭代對象也是無序的]

d.items()  生成器中是一個元組的列表
d.values()  
d.keys()    
    for i in d.keys()

    d = {}
    d["root"] = "root"
    d["root"]["left"] = "left"
    d["root"]["right"] = "right"
    d  //生成一個二叉樹

列表解析是Python重要的語法糖

列表解析的速度比for in 迭代 快

    ret = [expression for item in iterator]
    ret = [expression for item in iterator if iterator >=1 and iterator != 7 ] 
    ret = [expression for x in X for y in Y]   //返回的是一個笛卡爾積,相當于兩個嵌套的for循環

    等價于
    ret = []
    for item in iterator:
        ret.append(expression)

例子1:
    lst = list(range(10))
    [x + 1 for x in lst]

    import timeit
    def fn1():

    timeit.timeit(fn1())   //查看函數執行需要的時間

例子2:
    帶條件的列表解析:
    lst = list(range(10))
    [x + 1 for x in lst if x % 2 == 0]   //輸出奇數

    [x + 1 for x in lst if x % 2 == 0 and x > 2 ]   //兩個條件

例子3:
    l1 = [1, 3, 5, 7, 9]
    l2 = [0, 2, 4, 6, 8]
    [(x,y) for x in l1 for y in l2]
    [(1, 0-8)        //每個l1的值 x 都會循環一遍l2
      (3,0-8 )
     (5, 0-8)
    ] 
    
    

**集合解析中得到的元素只能有一個**
ret = {expression for item in iterator}

例子1:
     s = [1, 3, 5, 5] 
    {x + 1 for x in s}
    {2, 4, 6}

ret = {exprK:exprV for item in iterator}

例子1:
    d = {"a":1, "b":2}
    {k, v for k, v in d.items()}

例子2:
    {k:v for k, v in [("a",1), ("b", 2)]}
    {"a":1, "b":2}

python2 和python3最大的差別就是在于字符串
python2中字符串是byte的有序序列
python3中字符串是unicode的有序序列
字符串是不可變的
字符串支持下標和切片

t = "asdfzxv"     //前面是閉區間,從0開始,后面是開區間
t[1]
t[-1]
t[0:]
t[:]
t[1:-1]

"i love %s" % ("python",)
"i love %(name)s" % {"name":"python"}
"i love %(name)s %(name)s" % {"name":"python"}   //當有多個重復使用的值,可以使用字典的方式
"i love %s ,%s" % ("python", "python")  //進行多個不同數值的格式化

FLAG
flag |說明 |實例                                        輸出:
n    n表示一個數字       "%3s" % ("a", )                     "  a"    //在a前面會有兩個空格
0    使用0填充,僅適用與數字  "%03d" % (1, )          "001"
.     是有那個空格填充,默認行為  "%.3d" % (1, )      "  1"  //在1前面以空格填充

右邊使用空格填充 "%-3d" % (1, ) "1 " //在1后面以兩個空格填充

填充之前加"+" 僅對于正數 "%+03d" % (1, ) "+01" //在1前面填充0,增加正數標記符

CONVERSION
符號 說明

整數

整數

八進制整數

小寫十六進制整數
X 大寫十六進制整數

浮點數
F 浮點數

小寫科學計數法
E 大寫科學計數法

整數, 已廢棄

同f,如果指數小于-4,同e
G 同f,如果指數小于-4,同E

字符,接收unicode編碼或單字符字符串

字符串,使用ascii函數轉換

字符串,使用repr函數轉換

字符串,使用str函數轉換

例子1:
"%d" % 3.4
> 3

https://docs.python.org/3.4/library/stdtypes.html?highlight=format#str.format
template format(args, *kwargs) (1) (2) (3) (4)
1.template 使用 {} 標示變量
2.{}或{d+} 使用 *args 按順序填充
3.{key} 使用 **kwargs 按 key 填充
4.Format String Syntax

例子1:
"{0}, {name}".format("hello",name="world")

字符串連接join
字符串分割split, rsplit, splitlines, partition, rpartition
字符串修改-大小寫 capitalize, title, lower, upper, swapcase
字符串修改-填充清除 center, ljust, rjust, zfill, strip, rstrip,lstrip
字符串判斷 startswith, endswith,is*
字符串查找替換 count, find, rfind, index, rindex, replace

    lst = ["i", "like", "python"]
    " ".join(lst)
    "_".join(lst)
    ret = ""
    for i in lst:
          ret += i
          ret += " "
    ret

    內置函數split是不支持正則表達式的,需要先import re模塊;
    help(str.split)
    S.split(sep=None, maxsplit=-1) 
    
    例子1:
    s＝"i like python"
    s.split()
    ["i", "like", "python"]

    例子2:
    s.split("o")      //指定的分割符不會被保留;
    >["i like pyth", "n"] 
    
    例子3:
    s.split(" ", 1)  //后面的數表示分割幾次,默認是最大分割, -1表示從后開始分割
    ssplit(" ", -1)
    這里可以使用UNPACKING:
    s = "root:x:0:0:root:/root:/bin/bash"
    username,_ = s.plit(":", 1)
    username
    > "root"

    例子4:
    s = "root
:x:0
:0
:root:/root:/bin/bash"   //按照換行符分割
    s = """                  //像這樣需要多行的且需要按行分割的就需要用到splitlines
    11111111          //這里總共是4行,按照換行符算,第一行也有換行符
    22222222
    33333333
    """
    s.splitlines()
    > ["root", ":x:0", ":0", ":root:/root:/bin/bash"]
    s.splitlines(True)   //填寫True將會保留換行符,默認False

    s = "root
:x:0
:0
:root:/root:/bin/bash"
    s.partition(":")         //partition會按照順序 將分隔符多帶帶分割成一個元素,
    >("root", ":", "x:0:0:root:/root:/bin/bash")

capilize :   第一個字母變大寫,其他字母變小寫
       title:   每個單詞的首字母大寫,其他字母變小寫
    lower:   將所有字母變小寫
    upper:   將所有字母變大寫

swapcase: 將大小寫對換;

center: 前后填充

            s.center(20)   //默認用空格進行前后填充,填充滿20個字符
            s.center(20,"#") //以"#"進行前后填充.

 ljust:     填充向左邊
            s.ljust(20,"#")  #號將會填充在原來字符串的右邊,因為是向左填充

 rjust:     填充向右邊
            與ljust方向相反;

   zfill:    zfill() 方法返回指定長度的字符串，原字符串右對齊，前面填充0
            str.zfill(width)

 strip:    刪除頭尾匹配符,默認刪除換行符和空格,tab鍵
rstrip:    刪除結尾匹配符
lstrip:    刪除開頭匹配符

            f = open("/etc/passwd", "r")
            f.readline()   //返回的一行帶有換行符
            f.readline().strip()  //這樣將不會帶上換行符

            for line in f.readlines():
                    line = line.strip()
                    if line.startwith("root:"):
                        _, shell = line.rsplit(":",1)
                        print(shell)

        f = "sdfsdfsdfsadfsdf"
        f.count("r")  //統計有多少個r,如果是多個字符就是多個字符進行匹配統計
        
        f.find("fs")      //從左開始查找第一次匹配到的位置; 找不到會返回 -1
        f.find("fs", 2, 4)  //設置 [開始] [結束] 位置
        f.index("fs")     //從左開始查找第一次匹配到的位置;找不到會返回ValueError

        f.replace("fs","pp")     //替換   將fs替換成pp
        f.replace("fs","pp", 2)  //從左向右進行替換,替換兩個;

Python3中嚴格區分了文本和二進制數據
Python2并沒有嚴格區分
文本數據使用str類型,底層實現是unicode
二進制數據使用bytes類型,底層是byte
str使用encode方法轉化為bytes
bytes方法使用decode方法轉化成str
由于清晰的區分文本和二進制,Python3解決了大多數python2的編碼問題

python3 中json的應用:

   import json
   json.loads("{"name":"comyn"}")

socket中的發送信息;需要將str轉換成bytes才能發送;
s.send("{"name":"comyn"}".encode())