【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中不重复的元素