Python3基本数据类型

(1).数字类型

　1）整数类型（int）

　　Python中的整数类型与数学中的整数概念一致，它可正可负没有取值范围限制（只是理论上的无限，实际上机器内存有限，不可能无限大）。

　　注意：在python2中整数型是有大小限制的，在32位机器上，整数的二进制位数为32，取值范围为-2^31~2^31-1，即-2147483648~2147483647；在64位机器上，整数的二进制位数为64，取值范围为-2^63~2^63-1，即-9223372036854775808~9223372036854775807。超过这个范围的整数类型就是long型。

　　整数类型的四种表现方式：

　　　　二进制：以0b或0B开头，例如0b010，-0B101

　　　　八进制：以0o或0O开头，例如0o123，-0O456

　　　　十进制：不做说明和演示

　　　　十六进制：以0x或0X开头，例如0x9a，-0X89

　2）浮点数类型

　　Python中的浮点数与数学中的实数概念一致，它指的是带有小数点以及小数的数字。与整数不同，浮点数的取值范围和小数精度都存在限制，但常规计算时可以忽略。

　　浮点数取值范围从数量级上讲大约是-10^308~10^308，精度数量级约为10^-16，也就是说两个小数之间的差别最小可以表示到10^-16这个数量级。

　　但是浮点数有一个特性需要特别注意：浮点数间运存存在不确定尾数，这不是BUG。这里举一个例子0.1+0.2应该得出的是0.3，但是Python计算出来的却不是0.3，如下：

>>> 0.1+0.2
0.30000000000000004
>>> 0.1+0.3
0.4

　　其实这个不确定尾数并不止Python中存在，许多编程语言中都存在，它涉及到了计算机对数字运算的内部实现原理。

　　Python使用的IEEE 754标准（52M/11E/1S），该标准采用8字节的64位二进制存储空间，分配了52位来存储浮点数的有效数字，11位存储指数，1位存储正负号（也是Python常说的53位二进制表示小数部分，52+1，2^53-2=9007199254740990，约为10^16），即这是一种二进制版的科学计数法格式。

　　还需要了解十进制小数与二进制小数之间互相转换问题，首先来看一下十进制小数转换为二进制小数：

原十进制小数为0.1
0.1*2=0.2——取整数部分填充当前二进制小数位——0——剩余非零部分用于继续运算——0.2
0.2*2=0.4——取整数部分填充当前二进制小数位——0——剩余非零部分用于继续运算——0.4
0.4*2=0.8——取整数部分填充当前二进制小数位——0——剩余非零部分用于继续运算——0.8
0.8*2=1.6——取整数部分填充当前二进制小数位——1——剩余非零部分用于继续运算——0.6
0.6*2=1.2——取整数部分填充当前二进制小数位——1——剩余非零部分用于继续运算——0.2
......之后进入无限循环

　　但是到了Python中并不能无限循环，从第53位开始进行舍入，舍入规则为0舍1入，那么0.1转换为二进制小数实际为0.00011001100110011001100110011001100110011001100110011010。注意：4个二进制为一个整体。

　　二进制小数转换为十进制小数：

原二进制小数为0.00011001100110011001100110011001100110011001100110011010
0*2^-1+
0*2^-2+
0*2^-3+
1*2^-4+
1*2^-5+
0*2^-6+
......
1*2^-53+
0*2^-54+
1*2^-55+
0*2^-56=
0.10000000000000000055511151231257827021181583404541015625

　　可以看到经过两次转行后出现了非常长的尾数，只是在浮点数输出时只输出了前16位小数。所以我们可以得出一个结论，二进制表示小数，可以无限接近，但不完全相同。这也是不确定尾数产生的原因，在运算时会先将十进制转换为二进制，再进行运算，运算完成后再由二进制转换为十进制。

　　随之也带来了另一个问题，运算后的数值比较。由于不确定尾数的存在，不能直接进行比较，必须使用round(x,d)函数，对数值x进行四舍五入，d为小数精确位数。

>>> 0.1+0.2==0.3
False
>>> round(0.1+0.2,1)==0.3
True

　　Python浮点数可以使用字母e或E作为幂的符号，以10为基数的科学计数法，格式为<a>e<b>，表示a*10^b。例如96000，采用科学计数法就是9.6e4；0.0043，采用科学计数法就是4.3E-3。

　3）复数类型

　　在众多的编程语言中，只有Python提供了复数类型，复数类型与数学中的复数概念一致。定义j²=-1，即j=√(-1)，以此为基础构建的数学体系。a+bj被成称为复数，其中a为实部，bj整个是虚数部分，b为虚部。例如：z=1.23e-4+5.6e+89j，那么z就是一个复数类型，可以使用z.real获取实部1.23e-4，z.imag获取虚部5.6e+89。

　　客观的来说，在常规的计算机编程中复数类型很少被使用，但它却是进行空间变换，尤其是跟复变函数相关的科学体系中最常用的一种类型。

　4）数值运算操作符

　　二元操作符有对应的增强赋值操作符

　　注意：不同的数字类型可以进行混合运算，最终结果以最宽的类型为准。整数-->浮点数-->复数。

　5）数值运算函数

　　以下介绍的都是Python的内置函数，更多数值运算函数需要使用math库

　6）数字类型转换函数

(2).字符串类型

　　字符串提供了两类四种表示方法：

　　　　1、由一对单引号或双引号表示，仅表示单行字符串

　　　　2、由一对三单引号或三双引号表示，可以表示多行字符串

　　举例如下：

"请输入带有符号的温度值:"
‘C‘
‘‘‘Python
                语言‘‘‘
"""全输出结果为
     72C"""

　　说到一对三引号，很容易和Python的多行注释联系在一起。实际上，Python并没有真正提供多行注释的表达方式，三单引号构成的就是字符串，只是没有赋给任意变量，那么它就可以当做注释使用。

　　之所以Python通过了两类四种表达方式，是为了更好处理字符串中的单引号和双引号，如果同时存在单引号和双引号可以使用一对三单引号或三双引号。

　1）字符串的序号

　　一段字符串可以由左往右进行编号，实现正向递增序号，从0开始向上增长；也可以从结尾处想头部方向索引，那么构成的就是反向递减序号，从-1开始递减

　　字符串中最重要的两个操作：索引和切片，它们就使用到了字符串的序号。索引和切片使用[]来获取字符串中单个字符或一段字符。

　　索引：返回字符串中单个字符，格式：<字符串|变量名>[N]，实例：

>>> "请输入带有符号的温度值:"[1]
‘输‘
>>> Str="请输入带有符号的温度值:"
>>> Str[-2]
‘值‘

　　切片：返回字符串中的一段字符串，格式<字符串|变量名>[M:N]，M省略表示从头开始，N省略表示直到末尾，实例：

>>> "请输入带有符号的温度值:"[1:2]
‘输‘
>>> Str="请输入带有符号的温度值:"
>>> Str[:-2]
‘请输入带有符号的温度‘
>>> Str[-4:]
‘温度值:‘

　　注意：切片是从M到N-1的字符串，并不包含N。

　　下面介绍切片的高级用法，切片使用<字符串|变量名>[M:N:K]，根据步长K对字符串进行切片。实例：

>>> "零一二三四五六七八九"[1:8:2]
‘一三五七‘

　　切片还有一种特殊用法，倒序，即K=-1时。实例：

>>> "零一二三四五六七八九"[::-1]
‘九八七六五四三二一零‘

　2）转义字符

　　转义字符表达特定字符的本意

　3）字符串操作符

　4）字符串处理函数

　　Python中提供了一些以函数形式来实现的字符串处理功能，称之为字符串处理函数。Python提供了6个有用的内置函数，如下：

　5）字符串处理方法

　　这里的“方法”特指<a>.<b>()风格中的函数<b>()，或者说“方法”本身也是函数，但与<a>有关，它是<a>能够提供的函数，而且方法必须采用<a>.<b>()的形式使用。

　　字符串与变量也是一种<a>，存在一些操作方法。客观讲方法是面向对象语言的专有名词，<a>是对象，<b>()是方法。

　　这里介绍常用的8个字符串处理方法：

 　6）字符串类型的格式化

　　格式化是对字符串进行格式表达的方式。字符串格式化使用.format()方法，输出样式如下：<模板字符串>.format(<参数1>,<参数2>,...,<参数n>)。在具体的使用中需要用到一个新的概念：槽，槽相当于一个信息占位符，它是使用一对{}来表示，它只在字符串中有用。

　　实例1：

      字符串中槽{}的默认顺序                 format()中参数的顺序
-------------------------------->         ------------------>
      0        1              2                0       1   2
      ^        ^              ^                ^       ^   ^
      |        |              |                |       |   |
      |        |              |                |       |   |
>>> "{ }:计算机{ }的CPU占用率为{ }%".format("2020-03-13","A",10)
‘2020-03-13:计算机A的CPU占用率为10%‘

　　在实例1中，设置了三个槽，它与其他待输出的字符信息共同组成了字符串，每一个槽中所要添加的内容与.format()中对应的参数是一致的。

　　在不指定槽的序列的情况下，模板字符串的槽的序列从0开始，依次增加，与format中的参数序列一一对应，填充到槽中。进一步来说，我们可以在槽中，指定需要添加的参数位置。

　　我们将实例1进行变化，形成一个新的实例，实例2：

       _________________________________________________
      |         ________________________________        |
      |        |                                |       |
>>> "{1}:计算机{0}的CPU占用率为{2}%".format("2020-03-13","A",10)
                              |                            |
                               ————————————————————————————
‘A:计算机2020-03-13的CPU占用率为10%‘

　　在槽中填写format对应的参数序列，让槽去调取format中对应的参数，完成字符串的格式化。

　　还需要关注槽内部使用格式化的控制标记，来进行格式控制（参数的格式化），槽内部对格式化的配置方式，如下：{<参数序列>:格式控制标记}。简单来讲，在槽的内部，除了槽的参数序列之外，通过一个引号来引导一些参数，控制某一个变量在槽位置的输出格式，Python一共提供了六种格式控制标记，分别是<填充>、<对齐>、<宽度>、<,>、<.精度>和<类型>。六种格式控制标记可以分为两组，前三个一组，后三个一组。

　　<填充>、<对齐>和<宽度>，这一组概念的基本模式是：首先给出一个输出<宽度>，然后决定即将输出的这个参数在这个宽度中的<对齐>方式，最后如果还有空余的空间用什么字符<填充>（如果没有<填充>，那么采用空格补齐的方式），这三项就决定了一个基本的格式。举个例子，<填充>-->"="，<对齐>-->“^”，<宽度>-->“20”：

>>> "{0:=^20}".format("PYTHON")
‘=======PYTHON=======‘

　　<.>、<.精度>和<类型>都与具体的数字有关，第一个<,>比较特殊，它指的是数字的千位分隔符；第二个<.精度>需要注意，在精度前有一个小数点，它表示的是浮点数小数的精度，或者表示字符串最大的输出长度；第三个<类型>，表示以什么类型将变量放到槽中。举个例子：

>>> "{0:,.2f}".format(12345.6789)
‘12,345.68‘
>>> "{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}".format(425)
‘110101001,?,425,651,1a9,1A9‘
>>> "{0:e},{0:E},{0:f},{0:%}".format(3.14)
‘3.140000e+00,3.140000E+00,3.140000,314.000000%‘

(3).布尔类型

　　布尔类型是一个非常特殊的类型，所有标准对象均可用于布尔测试，同类型的对象之间可以比较大小。每个对象天生具有布尔True或False值。空对象,值为零的任何数字或者Null对象None的布尔值都是False。在Python3中True=1，False=0，可以和数字型进行运算。

　　下列对象的布尔值是False：None；False；0（整型），0.0（浮点型）；0L（长整形）；0.0+0.0j（复数）；“”（空字符串）；[]（空列表）；（）（空元组）；{}（空字典）。

　　值不是上列的任何值的对象的布尔值都是True，例如non-empty,non-zero等。用户创建的类实例如果是定义了nonzero(_nonzeor_())或length(_len_())且值为0，那么它们的布尔值就是False。

(4).列表

　　列表（List）是Python中使用最频繁的数据类型，是Python六个序列中最常用的序列之一（另一个是元组），格式为[value1,value2,...,valuen]。列表中的数据项不需要具有相同的类型，支持数字、字符串甚至列表。

　1）列表的序号

　　列表的序号与字符串的序号类似，由左向右进行编号，实现真向递增序号，从0开始增长；由右向左进行编号，实现反向递减序号，从-1开始递减。

　　同样实现了两个重要操作：索引和切片，使用[]来获取列表中的单个或多个有效值。

　　索引：返回列表中的单个有效值，格式<列表|变量名>[N]，实例：

>>> ["1",2,"3"][1]
2
>>> list1=["1",2,"3"]
>>> list1[-1]
‘3‘

　　切片：返回列表中的多个有效值，格式<列表|变量名>[N]，实例：

>>> ["1",2,"3"][:1]
[‘1‘]
>>> list1=["1",2,"3"]
>>> list1[-2:]
[2, ‘3‘]

　　童谣也存在步长的用法<列表|变量名>[M:N:K]

>>> [0,1,2,3,4,5,6,7,8,9][::-1]
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
>>> [0,1,2,3,4,5,6,7,8,9][1:8:2]
[1, 3, 5, 7]

　2）列表的操作符

　3）列表处理函数

　4）列表处理方法

(5).元组

　　元组与列表类似，只是采用的小括号包裹元素，并且元素不可修改，格式为(value1,value2,...,valueN)。（列表是中括号包裹元素，元素可以进行更改）

　　元组没有提供方法，其他的包括序号、操作符以及函数与列表完全一致，只有类型转换函数不同。类型转换函数师tuple(iterable)，将可迭代系列（序列，包含列表）转换为元组。

>>> tuple([1,2,3,‘4‘])
(1, 2, 3, ‘4‘)

(6).字典

　　字典是一种可变容器模型，可以存储任意类型对象，采用键值对模式，与.json文件格式类似，格式{key1:value1,key2:value2,...,keyn:valuen}。

　　在字典中，键是必须的，而且不可更改；值不是必须的，而且可以更改。

　　有需要可以看：https://www.runoob.com/python3/python3-dictionary.html

(7).集合

　　集合是一个无序的不重复元素序列，使用{}或set()函数创建。注意：创建空集合必须采用set()，因为{ }是用来创建空字典的。

　　有需要可以看：https://www.runoob.com/python3/python3-set.html

(8).扩展：删除变量

　　使用del [变量名]可以删除变量，最好不要出现与函数相同的变量名，否则容易报错。

>>> list={1,2,3,4}
>>> list((1,2,3))　　#此时就会报错
Traceback (most recent call last):
  File "<pyshell#3>", line 1, in <module>
    list((1,2,3))
TypeError: ‘set‘ object is not callable
>>> del list　　#删除这个变量
>>> list((1,2,3))　　#删除之后又可以使用了
[1, 2, 3]

参考：https://www.cnblogs.com/aiwanbuhui/p/7766352.html

　　　https://www.runoob.com/python3/python3-data-type.html

　　　https://www.cnblogs.com/hdk1993/p/8893954.html

Python3基本数据类型

原文：https://www.cnblogs.com/diantong/p/12463040.html