python - 数据类型

Posted 2021-01-31 Anec

 数据类型和变量

　　数据类型

　　　　计算机顾名思义就是可以做数学计算的机器，因此，计算机程序理所当然地可以处理各种数值。但是，计算机能处理的远不止数值，还可以处理文本、图形、音频、视频、网页等各种各样的数据，不同的数据，需要定义不同的数据类型。在Python中，能够直接处理的数据类型有以下几种：
　　　　　　整数
　　　　　　　　Python可以处理任意大小的整数，当然包括负整数，在程序中的表示方法和数学上的写法一模一样，例如：1，100，-8080，0，等等。
　　　　　　　　计算机由于使用二进制，所以，有时候用十六进制表示整数比较方便，十六进制用0x前缀和0-9，a-f表示，例如：0xff00，0xa5b4c3d2，等等。
　　　　　　浮点数
　　　　　　　　浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x109和12.3x108是完全相等的。浮点数可以用数学写法，如1.23，3.14，-9.01，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x109就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等。
整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是的！），而浮点数运算则可能会有四舍五入的误差。
　　　　　　字符串
　　　　　　　　字符串是以单引号\'或双引号"括起来的任意文本，比如\'abc\'，"xyz"等等。请注意，\'\'或""本身只是一种表示方式，不是字符串的一部分，因此，字符串\'abc\'只有a，b，c这3个字符。如果\'本身也是一个字符，那就可以用""括起来，比如"I\'m OK"包含的字符是I，\'，m，空格，O，K这6个字符。

　　　　　　布尔值
　　　　　　　　布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值（请注意大小写），也可以通过布尔运算计算出来
布尔值可以用and、or和not运算。
　　　　　　　　or运算是或运算，只要其中有一个为True，or运算结果就是True：

　　　　　　　　ot运算是非运算，它是一个单目运算符，把True变成False，False变成True：

　　　　　　空值
　　　　　　　　空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。
　　　　　　　　此外，Python还提供了列表、字典等多种数据类型，还允许创建自定义数据类型，我们后面会继续讲到。
　　　　　　变量
　　　　　　　　变量的概念基本上和初中代数的方程变量是一致的，只是在计算机程序中，变量不仅可以是数字，还可以是任意数据类型。
　　　　　　　　变量在程序中就是用一个变量名表示了，变量名必须是大小写英文、数字和_的组合，且不能用数字开头
　　　　　　常量
　　　　　　　　所谓常量就是不能变的变量，比如常用的数学常数π就是一个常量。在Python中，通常用全部大写的变量名表示常量

　　　　Python支持多种数据类型，在计算机内部，可以把任何数据都看成一个“对象”，而变量就是在程序中用来指向这些数据对象的，对变量赋值就是把数据和变量给关联起来。
　　

　　注意：Python的整数没有大小限制，而某些语言的整数根据其存储长度是有大小限制的，
　　例如Java对32位整数的范围限制在-2147483648-2147483647。
　　Python的浮点数也没有大小限制，但是超出一定范围就直接表示为inf（无限大）。

 

　　核心数据类型

    　　　　数字：int,long ,float,complex,bool
    　　　　字符:str,Unicode
    　　　　列表:list   
    　　　　字典:dict    
    　　　　元祖:tuple    
    　　　　文件:file    
    　　　　其他类型:

　　　　　　　　集合(set)

　　　　　　　　frozenset,

　　　　　　　　类类型,

　　　　　　　　None
 
　　　　　　其他文件类工具:
　　　　　　　　pipes
　　　　　　　　fifos

　　类型转换

　　　　str(),repr()或format() 将非字符数据转换为字符
　　　　int() 转化为整数
　　　　float()
　　　　list():将子串转为列表
　　　　tuple() 将字串转为元祖
　　　　set() 将字串转为集合
　　　　dict()创建字典,其d必须是(key,value) 的元祖序列
 
　　　　chr(x) 将整数转为字符
　　　　ord(x)将字符转为整数值
　　　　hex(x)将整数值转为16进制字符
　　　　bin(x)转为2进制
　　　　oct(x)转为8进制

 

python 使用5中数字类型:
布尔型
整型
长整型
浮点型
复数
所有数字类型均为不可变
True : 1

False: 0

 

 

序列类型
    字符类型
            字符串自变量:
                把文本放入单引号、双引号或三引号中
                \'\' , "", \'\'\'  \'\'\'
            如果要使用unicode 编码,则在字符之前使用字符u进行标识,如u"nihao"
            文档字串:
                模块、类或函数的第一条语句是一个字符的话,该字符串就成为文档字符串,可以使用_doc_属性引用
 
            运算符:
                索引运算:[i]
                切片运算:[i:j]
                扩展切片:[i:j:stride]

 支持运算
                索引、切片、min()、max()、len()等
            
            支持操作
                对象的自有的方法
        
        列表:
            容器类型
                任意对象的有序列集合,通过索引访问其中的元素,可变对象,长度可变,异构,任意嵌套.
            支持在原处修改
                修改制定的索引元素,修改制定的分片,删除语句,内置方法
 
            l1 + l2 :合并两个列表,返回一个新的列表,不会修改原列表
            l1 * N :把l1 重复 N次,返回一个新列表

in :成员关系判断字符,用法obj in container
            not in :obj not in contaner
            
            列表解析:
                []
            列表复制方式:
                l1  = [1,2,3,4]
                l2 = l1
                import copy 
                l2 = copy.deepcopy(l1)
                l2 = l1[:]
-----------------------------------------------------------------
元组:

表达式符号()
容器类型
        任意对象的有序集合,通过索引访问其中的元素,不可变对象,长度固定
        异构,嵌套
常见操作
    ()
    (1,)
    (1,2)
 
    t1 + t2 :
    t1 * N
in
    not in 
    
    虽然元组本身不可变,但如果元组内嵌套了可变类型元素,那么此类元素的修改不会返回新元组.
 
序列类型支持的操作符:

 

容器、类型、对象
1、
2、所有对象都有引用计数
3、列表和字典都支持两种类型的复制操作：
    浅复制和深复制；
    深复制可以使用copy模块中的deepcopy（）实现。
4、python中的所有对象都是‘第一类的’这意味着使用标识符命名的所有对象都具有相同状态，于是，能够命名所有对象都可以直接当做数据进行处理。
5、所有序列都支持迭代。
6、所有序列都支持的操作和方法：
s[i]
s[i:j]
s[i:j:stride]
len(s)
min(s)
max(s)
sum(s)
all(s)
any(s)
s1 + s2 :连接
s1 * N :重复
obj in s1 ：成员关系判断
obj not in s1：成员关系判断
 
7、可变序列的操作：
 s1[index] = value :元素赋值
s1[i:j] = t  :切片赋值
del s1[i:j]
del s1[i:j:stride]
 
python 的表达式和语句：
表达式
语句

python 中常用表达式操作符：
            x + y ; x -y;
            x * y ; x / y ; x // y , x % y;
            逻辑运算：
            x or y ; x and y ; not x 
            成员关系运算：
            x in y , x not in y 
            对象实例测试：
            x is y , x not is y 
            比较运算：
            x < y , x > y, x ! y
            位运算：
            x | y , x & y , x ^ y , x << y ,x >> y
            一元运算：
            -x , +x , ~x
            幂运算：
            x ** y
            索引和分片
            x[i],x[i:j],x[i:j:stride]
            调用：
            x(...)
            取属性：
            x.attribute
            
            元组：（...）
            序列：[...]
            字典：{...}
 
            三元表达式：    x if y else z
            匿名函数：        lambda args : expression
            生成器函数发送协议： yield x
 
    运算优先级：
        （...），【...】,{...}
        s[i],s[i:j]
        s.attribute
        s(...)
        +x,-x,~x
        x**y
        *,/,//,%
        <<,>>
        &
        ^
         |
        <,<=,>,>=,=,!=
        is,not is
        in ,not in
        not
        and
        or
        lambda
        
    语句：
           赋值语句
           调用
           print : 打印对象
           if/elif/else: 条件判断
           while/else：普通循环
           pass：占位符
            
            break：
            continue
            def
            return
            yield
            global ：命名空间
            raise    : 触发异常
            import
            from    模块属性访问
            class    类
            try/except/finally  捕捉异常
            del 删除引用
            assert 调试检查
            with/as 环境管理器。
 
            赋值语句：
                隐式赋值：
                    import,from,def,class,for 函数参数
                元组和列表分解赋值：
                    当赋值符号= 的左侧为元组或列表时，python会按照位置把右边的对象和左边的目标自左而右逐一进行匹配。
                多重目标赋值：
                增强赋值： +,-,*,/,

 

引用VS拷贝           

　　　　顶层复制
            深层复制
        比较、相等性和真值
            ‘==’操作符测试值的相等性
            ‘is’表达式测试对象的一致性
                
python 中不同类型比较方法：
    1.数字通过相对大小进行比较
    2.字符串是按照字典顺序，一个字符接一个字符的对比进行比较（‘abc’<\'ac\'）
    3.列表和元组从左到右对每部分的内容进行比较
    4.字典通过排序之后（键，值）列表进行比较。字典的相对大小比较在python3.0中不支持，但是，他们在python2.6及更早的版本中有效，就像比较排序的（键，值）列表一样。
    5.数字混合类型比较（例如，1<\'\'spam\'\')在python3中是错误的，python2中允许这样叫，但是使用一种固定但任意的排序规则。通过代理，这也适用于排序，它在内部使用比较，非数字的混合类型集合不能在python3中排序。
 
python中的其他类型：
    1. 赋值生产引用，而不是拷贝
    2.重复能够增加层次深度
    3.留意循环数据结构
    4.不可变类型不可以在原处修改