【python】核心對象類型

1 python是動態類型、強類型語言

動態類型：不須要提早聲明變量類型，變量在代碼運行的時候進行建立
    強類型：不容許不一樣類變量進行相關操做(除非強制類型轉化)

2 數字

2.1> 常見內置函數(存在於built_in命名空間)
            pow(2,4)  ==> 16  // 冪運算
            abs(-1) ==> 1  // 絕對值
            int、oct、hex、bin  // ×××、八進制、十六進制、二進制
            random.random()  // 生成隨機數
            random.randint(1,10)  // 生成1~10內的整數
            random.choice([1,2,3]) // 從序列中隨機取出某個元素
    2.2> 格式化
            a = 11.11
            >>> "{0:0<8.1f}".format(a)  // 寬度爲8，精度爲1,左對齊，其他位補0
            '11.10000'
            >>> "{0:0>8.1f}".format(a)  // 寬度爲8，精度爲1,右對齊，其他位補0
            '000011.1'

3 字符串 不可變、有序

a = "123456789"
    3.1> 索引
            a[-1]  // 獲取字符串最後一個元素
            a[:-1] // 獲取字符串0~-1元素(不包含-1元素)
    3.2> 切片 // a[上邊界,下邊界,步長]
            a[::-1]  // 反轉字符串
            a[1::2] // 求字符串偶數位元素
            a[::2]  // 求字符串奇數位元素
    3.3>常見操做
            拼接 // + / join
            a.index("1")  // 子元素1的索引
            a.find("1")  // 查找子元素1,找到返回索引位置,不然返回-1
            in // 判斷某個元素是否存在
            a.replace("1","2")  //將字符串中全部的1替換成2
            a.split("",2)  // 分割字符串(默認爲空字符串,包括換行符、空字符),分割2次,返回list
            a.rsplit()  // 從最後面開始分割
            a.endswith("9") // 字符串以某個元素結尾,返回Bool值
            a.startwith("1") // 字符串以某個元素開頭,返回Bool值
            a.strip() // 移除字符串頭部和尾部的字符(默認爲換行符和空白格)
            a.lsrtip() // 移除字符串頭部的空格
            a.rstrip()  // 移除字符串尾部的空格和換行符
            // 移除字符串中間空格
            a.replace(' ','')
            "".join(a.split())
    3.4>格式化
           參考數字格式化 // ^ 居中對齊

4 列表 可變、有序

4.1> 索引
            a[-1]  // 獲取列表最後一個元素
            a[:-1] // 獲取列表0~-1元素(不包含-1元素)
    4.2> 切片
            a[::-1]  // 反轉列表
            a[1::2] // 求列表偶數位元素
            a[::2]  // 求列表奇數位元素
    4.3> 常見操做
            拼接  // + / join
            a.index(1)  // 獲取列表中1的索引
            a.append(1)  // 列表尾部增長元素
            a.extend(b)  // 列表批量更新元素(b是序列:字符串、列表、字典等)
            a.insert()
            a.pop() // 默認彈出最後一個元素;pop(index) 彈出指定索引處的元素(可用變量接收)
            a.insert(0,2) // 指定索引處添加元素(可添加序列) 
            a.remove(index) // 刪除指定索引處的元素
            a.count(1)  // 列表a中1的個數
            in // 判斷某個元素是否存在
            a.reverse() // 列表反轉(做用於列表自己) 
            list(reversed(a)) // 列表反轉(生成新的列表)
            a.sort() a.sort(reverse=True)  // 列表排序(做用於原始list)
            sorted(l) // 列表排序(生成新的list)  **此處能夠添加name=value，怎麼用
    4.4> 列表解析
            列表解析 ==> 對序列每一項應用一個表達式 生成新的表達式
            例子：
            a.sorted([x.lower() for x in a],reverse=True)
    4.5> 注意
            **有時候清空list不必定要remove等
            a[1:] = []

5 字典 可變、無序

5.1> 常見操做
            a['k3'] = 3 // 更新字典元素(單個)
            a.update(b)  // 將字典b插入到字典a內部(批量插入)
            a.pop('k1') // 刪除字典k1鍵值對(變量可接收)
    5.2> 判斷鍵值是否存在
            in // python3和python2.6都適用
            a.get('k1',0)  // 獲取k1鍵值，若不存在則返回0
    5.3> 字典解析
            {x:x**2 for x in [1,2,3,4]}
    5.4> 動態初始化字典
            list(zip(['a','b','c'],[1,2,3])) ==> [('a',1),('b',2),('c',3)]
            dict(zip(['a','b','c'],[1,2,3])) ==> {'a':1,'b':2,'c':3}

6 元祖 不可變(頂層)、有序

6.1> 索引
            a[-1]  // 獲取元祖最後一個元素
            a[:-1] // 獲取元祖0~-1元素(不包含-1元素)
    6.2> 切片
            a[::-1]  // 反轉元祖
            a[1::2] // 求元祖偶數位元素
            a[::2]  // 求元祖奇數位元素
    6.3> 常見操做
            拼接  // + / join
            不可變性 // 僅僅針對頂層元素，要是底層有list等，那麼是可變的
            (1,)  // 單一元祖
            a.index(1) // 獲取元素1的索引
            a.count(1) // 獲取元素1出現的次數
            in // 判斷某個元素是否存在

7 文件

7.1> 操做符
             open()  // 打開文件
             read()  // 將單個文件讀進一個字符串
             read(N) // 讀取N個字節到一個字符串
             readline() // 讀取下一行(包括行末標識符)到一個字符串
             readlines()  // 讀取整個文件到字符串列表
             write()  // 寫入字節字符串到文件
             writelines()  // 寫入列表中字符串到文件
             flush()  // 刷新緩存區內容到硬盤(不關閉文件)
             seek(N)  // 指定讀取文件偏移量
        7.2> 文件上下文管理器
             with open(file) as fp:  // 不用手動關閉文件

8 集合 可變、無序

8.1> 常見操做
            a.add()  // 新增單個元素(不可傳入可變元素)
            a.update() // 新增多個元素(傳入序列)
            a.remove()  // 移除某個元素(注意：這裏不是索引，由於set是無序的)

            & | -  // 交集、並集、差集
            intersection union  difference  // 交集、並集、差集

            s <= t  // s中的元素是否都在t中
            s >= t  // t中的元素是否都在s中
            s ^ t  // 返回一個新的set，包含s和t中不重複的元素