python基础数据类型汇总

#!/usr/bin/env python
# -*- encoding:utf-8 -*-
# author:Administrator
# make_time:2018/6/9
'''
数据类型：
不可变数据类型：int、str、bool、tuple、frozenset
可变数据类型：list、dict、set
公共方法：count()、len()、del、copy()
len(所有都有)
count（数字、字典、集合没有此方法）
index（数字、字典、集合没有此方法）
可变数据类型都有copy（）

整数、字符串、列表、元组、布尔可以相加（字典、集合不可相加）

整数：  int
# 不可变数据类型
    bit_length()   查看数字在内存中最少占几位
    数学运算：+ - * /  //(整除) % **（幂）
    比较运算： >,<,>=,<=,==,!=
    赋值运算：=,+=,*=,/=,-=,%=,,//=,**=

    逻辑运算：not or and
            从左到右
            优先级：（） not  and  or
            1(非零整数)：true   0：false
            1 or 2  左边非零取左边，0 取右边，and相反

    身份运算：is  is not  判断两个对象是不是为同一个内存地址

    成员运算：in not in   判断字符/元素是否在目标中，str，list，dict，set，tuple

    位运算：
        &  与运算   1 1 得1 ， 1 0 得0  ，0 0 得 0
        |  或运算   1 1 得1，1 0 得1 ，0 0 得0

    方法：
        int.bit_lens()   查看数字在内存中占的字节数
布尔值：True  False
    #不可变数据类型、True为1，False为0   （0，None，False，[],(),{},set(),都为False）

字符串： str
    # 不可变数据类型、有序、可切片，可迭代循环，交互默认输入为字符串
    # 以单或双引号表示 ：'元素'
    # 不可增删改
    切片：从左到右字符串中的索引从0开始
    [start:end:step]  顾头不顾尾
    [1:3] 字符串中索引1到2的字符
    [1:-1] -1 表示最后一个字符
    操作方法：
            del str          删除字符串
            len(str)         统计字符串长度，内置方法
            str.count(元素）  统计字符串中的元素出现的个数
            str.center(宽度，"填充物可不写")  指定长度居中显示，默认填充物为空格
            str.title()      非字母隔开得首字母大写
                  china country --> China Country
        *   str.capitalize()  首字母大写，其他分开的单词首字母小写
                china_Country  --> China_country
            str.swapcase()    --->字符串大小写互转
        **  str.upper()    ----> 全部变成大写
            str.isupper()           是否全部为大写
        **  str.lower()    -----> 全部变成小写
            str.islower()           是否全部为小写
            str.encoding("将字符串以何种编码集进行编码")
        **  str.startswith("元素") 判断字符串是否以什么开头，返回bool值
            str.endswith("元素")
        *** str.find("元素"，star，end)  找元素的索引，如果元素不存在，返回-1
        *** str.index("元素",star,end)   找元素的索引，如果元素不存在，报错
        *** str.strip("元素可空")     去掉两端的\n,\t,\s等空白字符，也可指定字符从两端删
            str.lstrip()
            str.rstrip()
     ***** str.split("分割符可空，默认空格，多个空格看成一个")   分割字符串，返回列表
            str.lsplit()
            str.rsplit()
        *** str.replace(old,new,替换几次）
        *** str.format()  字符串格式化
                "{}my name is {}".format(11,"秀文")
                "{1}my name is {2}，next year is {1}".format(11,"秀文")
                {id}is old boy ,my name {name}".format(id =11,name="sun")  不能放字典
            % 百分号的方式格式化
                "my name is %s ,i am %d" %("sun",30)"
                "my name is %(name)s ,i am %(age)d" %(dic)"  可以放字典
                %s 字符串
                %d 整数
                %f 小数   %.2f 保留2为小数
            3.6以上版本格式话可以：f"{name}已经登录了"

            str.isalnum()  是否为字母或数字，返回bool值
            str.isalpha()  是否全为字母
            str.isdigit()  是否全为数字
            str.isspace()  是否有空白字符
     ***** str.join(iterable可迭代)   字符串拼接,括号里一定得是可迭代得数据，且只能为一个参数
                注：
                "sun".join([11,22])  报错，join不能将带有数字得list转换成字符串，需要先将数字转换成字符串
                "*".join("%s" %id for id in list)
            object  in  str    判断元素是否在str中

列表：list
    # 可变数据类型，有序，可切片，可迭代循环，元素可为任意类型数据
    # 以[元素，]表示
    # 可增删改查
    切片：
    同字符串一样，通过索引切
    增：
      list.append(元素）       向列表末尾添加元素
      list.insert(index,元素） 指定索引位置向列表添加元素
      list.extend(iterable)    迭代的向列表末尾添加多个元素
    删：
       list.pop(index)     根据索引删除，不添加元素时，默认删除最后一个
       list.remove(元素/object） 根据元素删除
       del list   删除列表
       del list[:3]  根据索引切片删除
       list.clear()  清空列表
    改：
        lis[index] = new_data    索引切片修改
            lis = [11,22,33,44,55]
            lis[:2] = [66,77,88]    # lis = [66, 77, 88, 33, 44, 55]  步长为1时，不考虑个数对应，切的时一片空间
            lis[:3:2] = [66,77]     # 报错，步长不为1时，左右元素个数需一致
                                    #ValueError: attempt to assign sequence of size 3 to extended slice of size 2
    查：
        lis[index]      通过索引查
        for i in list:   通过迭代循环查，i为列表中的每个元素
    方法：
        del list               删除列表
        len(list)             统计列表的长度
        list.count(object)   统计列表中指定元素出现的个数
        list.index(object,start,end)   查找元素的索引
        list.sort(reverse=False)     排序，默认为升序，当reverse值设为True时，降序排列
        list.reverse()      列表中元素顺序反转过来
        list.copy()         列表浅拷贝
        object in list      判断对象是否在列表中

元组：tuple
    # 不可变数据类型，有序，可切片，可迭代循环，元素可以是任意数据类型
    # 不可增删改
    # 以括号表示（）
    查：
       tuple[2]   通过切片查
       for i in tuple：   通过迭代循环查
    方法：
       tuple.count(object)
       tuple.index(object,start,end)
       len(tuple)
        object in tuple

字典：dict
    # 可变数据类型，键值对存在，键不可变,可哈希的（int，str,bool,frozenset)，值可以是任意数据类型，无序，不可切片，可迭代循环查询
    # 以大括号表示{key：value}
    # 可整删查
    增：
        dic = {}
        dic[new_key] = new_data    直接增加，如果key存在则更新value
        dic.setdefault(key,value)  本方法一旦key，value都创建，且value指定的不是[]、{}、set(),值都不能更改
        new_dic = dict.fromkeys(iterable,values)
            new_dic = dict.fromkeys([11,22],[33,44]) -->{11: [33, 44], 22: [33, 44]}
            前面的key对应相同的value,且当后面的value为可变数据类型时如列表，改变任意一个value，
            另一个也会改变，浅拷贝，否则不改变
    删：
        dic.pop(key)    指定key删除，默认删除最后一项,返回删除key对应的value,如果key不存在报错 KeyError:
        dic.popitem()   随机删除 ，返回删除的键值对以tuple形式显示
                        3.6以上字典内置为有序，popitem（）默认删除最后一个，但面试要说随机删除
        del dic[key]    指定key删除，如果key不存在报错 KeyError:
        del dic
        dic.clear()
    改：
        dic[key] = new_data
        dic.update(dic1)       dic将dic1更新到自己的字典中，key重复更新为新value
    查：
        dic[key]     key不存在时，报错
        dic.get[key,"不存在时自定义返回值"]   key不存在时默认返回None，也可自定义返回值
        dic.keys()   以仿列表形式存所有key，可迭代
        dic.values()
        dic.items()
        for i in dic   i 为dic的key
    方法：
        len(dic)
集合：set
    # 可变数据类型，无序，元素唯一不重复且不可哈希即不可变数据类型，可迭代
    # 以{}形式表现,主要用于去重
    # 不可切片（无序），可增删改查
    增：
        set.add(元素)
        set.update(iterable)    迭代的更新到set中
    删：
        set.pop()   随机删除
        set.remove(元素）  没有报错
        set.clear()
        del set
    改：
        因无序，只能通过先删除后整加的方式
        set.remove(待改元素)
        set.add(新增元素)
    查：
        for i in set:
    方法：
        len(set)
        交集： &     相同的部分
        并集： |     合体
        差集  a-b    去掉在a中b有的元素，减法
        s = frozenset([11,22,33])  将可变数据类型改为不可变