公告

View Post

【python】python的数据类型 int,float,字符传,byte,bool

一、变量和变量赋值

变量的值不是一成不变的，它可以随时被修改，只要重新赋值即可；

另外你也不用关心数据的类型，可以将不同类型的数据赋值给同一个变量。请看下面的演示：

n = 10  #将10赋值给变量n
n = 95  #将95赋值给变量n
n = 200  #将200赋值给变量n
abc = 12.5  #将小数赋值给变量abc
abc = 85  #将整数赋值给变量abc
abc = "http://c.biancheng.net/"  #将字符串赋值给变量abc

View Code

Python 是弱类型的语言

在强类型的编程语言中，定义变量时要指明变量的类型，而且赋值的数据也必须是相同类型的，C语言、C++、Java 是强类型语言的代表。

和强类型语言相对应的是弱类型语言，Python、JavaScript、PHP 等脚本语言一般都是弱类型的。

弱类型语言有两个特点：

变量无须声明就可以直接赋值，对一个不存在的变量赋值就相当于定义了一个新变量。
变量的数据类型可以随时改变，比如，同一个变量可以一会儿被赋值为整数，一会儿被赋值为字符串。

注意，弱类型并不等于没有类型！弱类型是说在书写代码时不用刻意关注类型，但是在编程语言的内部仍然是有类型的。我们可以使用 type() 内置函数类检测某个变量或者表达式的类型，例如：

>>> num = 10
>>> type(num)
<class 'int'>
>>> num = 15.8
>>> type(num)
<class 'float'>
>>> num = 20 + 15j
>>> type(num)
<class 'complex'>
>>> type(3*15.6)
<class 'float'>

View Code

二、python的数据类型

2.1、int类型

整数就是没有小数部分的数字，Python 中的整数包括正整数、0 和负整数。

有些强类型的编程语言会提供多种整数类型，每种类型的长度都不同，能容纳的整数的大小也不同，开发者要根据实际数字的大小选用不同的类型。例如C语言提供了 short、int、long、long long 四种类型的整数，它们的长度依次递增，初学者在选择整数类型时往往比较迷惑，有时候还会导致数值溢出。
而 Python 则不同，它的整数不分类型，或者说它只有一种类型的整数。Python 整数的取值范围是无限的，不管多大或者多小的数字，Python 都能轻松处理。

#将 78 赋值给变量 n
n = 78
print(n)
print( type(n) )
#给x赋值一个很大的整数
x = 8888888888888888888888
print(x)
print( type(x) )
#给y赋值一个很小的整数
y = -7777777777777777777777
print(y)
print( type(y) )



最终的输出内容如下
78
<class 'int'>
8888888888888888888888
<class 'int'>
-7777777777777777777777
<class 'int'>

View Code

整数的不同进制

在 Python 中，可以使用多种进制来表示整数：

1) 十进制形式

我们平时常见的整数就是十进制形式，它由 0~9 共十个数字排列组合而成。
注意，使用十进制形式的整数不能以 0 作为开头，除非这个数值本身就是 0。

2) 二进制形式

由 0 和 1 两个数字组成，书写时以0b或0B开头。例如，101 对应十进制数是 5。

3) 八进制形式

八进制整数由 0~7 共八个数字组成，以0o或0O开头。注意，第一个符号是数字 0，第二个符号是大写或小写的字母 O。

4) 十六进制形式

由 0~9 十个数字以及 A~F（或 a~f）六个字母组成，书写时以0x或0X开头，

如果你对不同进制以及它们之间的转换方法不了解，请猛击下面的链接：

数字分隔符

为了提高数字的的可读性，Python 3.x 允许使用下划线_作为数字（包括整数和小数）的分隔符。通常每隔三个数字添加一个下划线，类似于英文数字中的逗号。下划线不会影响数字本身的值。

【实例】使用下划线书写数字：

click = 1_301_547
distance = 384_000_000
print("Python教程阅读量：", click)
print("地球和月球的距离：", distance)

运行结果：

Python教程阅读量：1301547
地球和月球的距离：384000000

2.2、Python小数/浮点数（float）类型详解

在编程语言中，小数通常以浮点数的形式存储。浮点数和定点数是相对的：小数在存储过程中如果小数点发生移动，就称为浮点数；如果小数点不动，就称为定点数。

如果你对浮点数的底层存储格式不了解，请猛击：小数在内存中是如何存储的，揭秘诺贝尔奖级别的设计（长篇神文）

Python 中的小数有两种书写形式：

1) 十进制形式

这种就是我们平时看到的小数形式，例如 34.6、346.0、0.346。
书写小数时必须包含一个小数点，否则会被 Python 当作整数处理。

2) 指数形式

Python 小数的指数形式的写法为：

aEn 或 aen

a 为尾数部分，是一个十进制数；n 为指数部分，是一个十进制整数；E或e是固定的字符，用于分割尾数部分和指数部分。整个表达式等价于 a×10ⁿ。

指数形式的小数举例：

2.1E5 = 2.1×10⁵，其中 2.1 是尾数，5 是指数。
3.7E-2 = 3.7×10^-2，其中 3.7 是尾数，-2 是指数。
0.5E7 = 0.5×10⁷，其中 0.5 是尾数，7 是指数。

注意，只要写成指数形式就是小数，即使它的最终值看起来像一个整数。例如 14E3 等价于 14000，但 14E3 是一个小数。
Python 只有一种小数类型，就是 float。C语言有两种小数类型，分别是 float 和 double：float 能容纳的小数范围比较小，double 能容纳的小数范围比较大。

Python浮点数精度问题（包含解决方案）

前面章节提到，Python 中浮点类型之间的运算，其结果并不像我们想象的那样，例如：

>>> 0.1+0.2
0.30000000000000004
>>> 0.1+0.1-0.2
0.0
>>> 0.1+0.1+0.1-0.3
5.551115123125783e-17
>>> 0.1+0.1+0.1-0.2
0.10000000000000003

View Code

为什么在计算这么简单的问题上，计算机会出现这样的低级错误呢？真正的原因在于十进制和数和二进制数的转换。
我们知道，计算机其实是不认识十进制数，它只认识二进制数，也就是说，当我们以十进制数进行运算的时候，计算机需要将各个十进制数转换成二进制数，然后进行二进制间的计算。
以类似 0.1 这样的浮点数为例，如果手动将其转换成二进制，其结果为：

0.1(10)=0.00011001100110011...(2)

View Code

可以看到，结果是无限循环的，也就是说，0.1 转换成二进制数后，无法精确到等于十进制数的 0.1。同时，由于计算机存储的位数是有限制的，所以如果要存储的二进制位数超过了计算机存储位数的最大值，其后续位数会被舍弃（舍弃的原则是“0 舍 1 入”）。

这种问题不仅在 Python 中存在，在所有支持浮点数运算的编程语言中都会遇到，它不光是 Python 的 Bug。

明白了问题产生的原因之后，那么该如何解决呢？就 Python 的浮点数运算而言，大多数计算机每次计算误差不会超过 2⁵³，这对于大多数任务来说已经足够了。
如果需要非常精确的结果，可以使用 decimal 模块（其实就是别人开发好的程序，我们可以直接拿来用），它实现的十进制数运算适合会计方面的应用和有高精度要求的应用。例如：

#使用模块前，需要使用 import 引入
import decimal
a = decimal.Decimal("10.0")
b = decimal.Decimal("3")
print(10.0/3)
print(a/b)

运行结果为：

3.3333333333333335
3.333333333333333333333333333

可以看到，相比普通运算的结果，使用 decimal 模块得到的结果更精确。

如果 decimal 模块还是无法满足需求，还可以使用 fractions 模块，例如：

#引入 decimal 模块
from fractions import Fraction
print(10/3)
print(Fraction(10,3))

运行结果为：

3.3333333333333335
10/3

可以看到，通过 fractions 模块能很好地解决浮点类型数之间运算的问题。

2.3、Python复数类型（complex）详解

复数（Complex）是 Python 的内置类型，直接书写即可。换句话说，Python 语言本身就支持复数，而不依赖于标准库或者第三方库。
复数由实部（real）和虚部（imag）构成，在 Python 中，复数的虚部以j或者J作为后缀，具体格式为：

a + bj

a 表示实部，b 表示虚部。

【实例】Python 复数的使用：

c1 = 12 + 0.2j
print("c1Value: ", c1)
print("c1Type", type(c1))
c2 = 6 - 1.2j
print("c2Value: ", c2)
#对复数进行简单计算
print("c1+c2: ", c1+c2)
print("c1*c2: ", c1*c2)



#运行结果如下
c1Value:  (12+0.2j)
c1Type <class 'complex'>
c2Value:  (6-1.2j)
c1+c2:  (18-1j)
c1*c2:  (72.24-13.2j)

2.4、Python字符串详解（包含长字符串和原始字符串）

若干个字符的集合就是一个字符串（String）。Python 中的字符串必须由双引号" "或者单引号' '包围，具体格式为：

"字符串内容"
'字符串内容'

字符串的内容可以包含字母、标点、特殊符号、中文、日文等全世界的所有文字。
下面都是合法的字符串：

"123789"
"123abc"
"http://c.biancheng.net/python/"
"C语言中文网成立8年了"

Python 字符串中的双引号和单引号没有任何区别。而有些编程语言的双引号字符串可以解析变量，单引号字符串一律原样输出，例如 PHP 和 JavaScript。

2.4.1、处理字符串中的引号的

1) 对引号进行转义

在引号前面添加反斜杠\就可以对引号进行转义，让 Python 把它作为普通文本对待，例如：

str1 = 'I\'m a great coder!'
str2 = "引文双引号是\"，中文双引号是“"
print(str1)
print(str2)

2) 使用不同的引号包围字符串

如果字符串内容中出现了单引号，那么我们可以使用双引号包围字符串，反之亦然。例如：

str1 = "I'm a great coder!"  #使用双引号包围含有单引号的字符串
str2 = '引文双引号是"，中文双引号是“'  #使用单引号包围含有双引号的字符串
print(str1)
print(str2)

2.4.2、字符串的换行

Python 不是格式自由的语言，它对程序的换行、缩进都有严格的语法要求。要想换行书写一个比较长的字符串，必须在行尾添加反斜杠\，请看下面的例子：

s2 = 'It took me six months to write this Python tutorial. \
    Please give me more support. \
    I will keep it updated.'

上面 s2 字符串的比较长，所以使用了转义字符\对字符串内容进行了换行，这样就可以把一个长字符串写成多行。

另外，Python 也支持表达式的换行，例如：

num = 20 + 3 / 4 + \
    2 * 3
print(num)

2.4.3、Python长字符串

在《Python注释》一节中我们提到，使用三个单引号或者双引号可以对多行内容进行注释，这其实是 Python 长字符串的写法。所谓长字符串，就是可以直接换行（不用加反斜杠\）书写的字符串。

Python 长字符串由三个双引号"""或者三个单引号'''包围，语法格式如下：

"""长字符串内容"""
'''长字符串内容'''

在长字符串中放置单引号或者双引号不会导致解析错误。
如果长字符串没有赋值给任何变量，那么这个长字符串就不会起到任何作用，和一段普通的文本无异，相当于被注释掉了。

注意，此时 Python 解释器并不会忽略长字符串，也会按照语法解析，只是长字符串起不到实际作用而已。

当程序中有大段文本内容需要定义成字符串时，优先推荐使用长字符串形式，因为这种形式非常强大，可以在字符串中放置任何内容，包括单引号和双引号。

【实例】将长字符串赋值给变量：

longstr = '''It took me 6 months to write this Python tutorial.
Please give me a to 'thumb' to keep it updated.
The Python tutorial is available at http://c.biancheng.net/python/.'''
print(longstr)

长字符串中的换行、空格、缩进等空白符都会原样输出，所以你不能写成下面的样子：

longstr = '''
    It took me 6 months to write this Python tutorial.
    Please give me a to 'thumb' to keep it updated.
    The Python tutorial is available at http://c.biancheng.net/python/.
'''
print(longstr)

虽然这样写格式优美，但是输出结果将变成：

    It took me 6 months to write this Python tutorial.
    Please give me a to 'thumb' to keep it updated.
    The Python tutorial is available at http://c.biancheng.net/python/.

字符串内容前后多出了两个空行，并且每一行的前面会多出四个空格。

2.4.4、Python原始字符串

Python 字符串中的反斜杠\有着特殊的作用，就是转义字符，例如上面提到的\'和\"，我们将在《Python转义字符》一节中详细讲解，这里大家先简单了解。
转义字符有时候会带来一些麻烦，例如我要表示一个包含 Windows 路径D:\Program Files\Python 3.8\python.exe这样的字符串，在 Python 程序中直接这样写肯定是不行的，不管是普通字符串还是长字符串。因为\的特殊性，我们需要对字符串中的每个\都进行转义，也就是写成D:\\Program Files\\Python 3.8\\python.exe这种形式才行。

这种写法需要特别谨慎，稍有疏忽就会出错。为了解决转义字符的问题，Python 支持原始字符串。在原始字符串中，\不会被当作转义字符，所有的内容都保持“原汁原味”的样子。

在普通字符串或者长字符串的开头加上r前缀，就变成了原始字符串，具体格式为：

str1 = r'原始字符串内容'
str2 = r"""原始字符串内容"""

将上面的 Windows 路径改写成原始字符串的形式：

rstr = r'D:\Program Files\Python 3.8\python.exe'
print(rstr)

原始字符串中的引号

如果普通格式的原始字符串中出现引号，程序同样需要对引号进行转义，否则 Python 照样无法对字符串的引号精确配对；但是和普通字符串不同的是，此时用于转义的反斜杠会变成字符串内容的一部分。

请看下面的代码：

str1 = r'I\'m a great coder!'
print(str1)

输出结果：

I\'m a great coder!

需要注意的是，Python 原始字符串中的反斜杠仍然会对引号进行转义，因此原始字符串的结尾处不能是反斜杠，否则字符串结尾处的引号会被转义，导致字符串不能正确结束。
在 Python 中有两种方式解决这个问题：一种方式是改用长字符串的写法，不要使用原始字符串；另一种方式是单独书写反斜杠，这是接下来要重点说明的。

例如想表示D:\Program Files\Python 3.8\，可以这样写：

str1 = r'D:\Program Files\Python 3.8' '\\'
print(str1)

我们先写了一个原始字符串r'D:\Program Files\Python 3.8'，紧接着又使用'\\'写了一个包含转义字符的普通字符串，Python 会自动将这两个字符串拼接在一起，所以上面代码的输出结果是：

D:\Program Files\Python 3.8\

由于这种写法涉及到了字符串拼接的相关知识，这里读者只需要了解即可，后续会对字符串拼接做详细介绍。

2.5、Python bytes类型及用法

Python bytes 类型用来表示一个字节串。“字节串“不是编程术语，是我自己“捏造”的一个词，用来和字符串相呼应。

bytes 是 Python 3.x 新增的类型，在 Python 2.x 中是不存在的。

字节串（bytes）和字符串（string）的对比：

字符串由若干个字符组成，以字符为单位进行操作；字节串由若干个字节组成，以字节为单位进行操作。
字节串和字符串除了操作的数据单元不同之外，它们支持的所有方法都基本相同。
字节串和字符串都是不可变序列，不能随意增加和删除数据。

bytes 只负责以字节序列的形式（二进制形式）来存储数据，至于这些数据到底表示什么内容（字符串、数字、图片、音频等），完全由程序的解析方式决定。如果采用合适的字符编码方式（字符集），字节串可以恢复成字符串；反之亦然，字符串也可以转换成字节串。

说白了，

bytes 只是简单地记录内存中的原始数据，至于如何使用这些数据，bytes 并不在意，你想怎么使用就怎么使用，bytes 并不约束你的行为。
bytes 类型的数据非常适合在互联网上传输，可以用于网络通信编程；
bytes 也可以用来存储图片、音频、视频等二进制格式的文件。

字符串和 bytes 存在着千丝万缕的联系，我们可以通过字符串来创建 bytes 对象，或者说将字符串转换成 bytes 对象。有以下三种方法可以达到这个目的：

如果字符串的内容都是 ASCII 字符，那么直接在字符串前面添加b前缀就可以转换成 bytes。
bytes 是一个类，调用它的构造方法，也就是 bytes()，可以将字符串按照指定的字符集转换成 bytes；如果不指定字符集，那么默认采用 UTF-8。
字符串本身有一个 encode() 方法，该方法专门用来将字符串按照指定的字符集转换成对应的字节串；如果不指定字符集，那么默认采用 UTF-8。

#通过构造函数创建空 bytes
b1 = bytes()
#通过空字符串创建空 bytes
b2 = b''
#通过b前缀将字符串转换成 bytes
b3 = b'http://c.biancheng.net/python/'
print("b3: ", b3)
print(b3[3])
print(b3[7:22])
#为 bytes() 方法指定字符集
b4 = bytes('C语言中文网8岁了', encoding='UTF-8')
print("b4: ", b4)
#通过 encode() 方法将字符串转换成 bytes
b5 = "C语言中文网8岁了".encode('UTF-8')
print("b5: ", b5)

运行结果：

b3:  b'http://c.biancheng.net/python/'
112
b'c.biancheng.net'
b4:  b'C\xe8\xaf\xad\xe8\xa8\x80\xe4\xb8\xad\xe6\x96\x87\xe7\xbd\x918\xe5\xb2\x81\xe4\xba\x86'
b5:  b'C\xe8\xaf\xad\xe8\xa8\x80\xe4\xb8\xad\xe6\x96\x87\xe7\xbd\x918\xe5\xb2\x81\xe4\xba\x86'

从运行结果可以发现，对于非 ASCII 字符，print 输出的是它的字符编码值（十六进制形式），而不是字符本身。非 ASCII 字符一般占用两个字节以上的内存，而 bytes 是按照单个字节来处理数据的，所以不能一次处理多个字节。

如果你对进制不了解，请猛击：

如果你对字符集（字符编码）不了解，请猛击：

bytes 类也有一个 decode() 方法，通过该方法可以将 bytes 对象转换为字符串。紧接上面的程序，添加以下代码：

#通过 decode() 方法将 bytes 转换成字符串
str1 = b5.decode('UTF-8')
print("str1: ", str1)

输出结果：

str1:  C语言中文网8岁了

2.6、Python bool布尔类型

Python 提供了 bool 类型来表示真（对）或假（错），

比如5 > 3比较算式，这个是正确的，在程序世界里称之为真（对），Python 使用 True 来代表；
比如4 > 20比较算式，这个是错误的，在程序世界里称之为假（错），Python 使用 False 来代表。

True 和 False 是 Python 中的关键字，当作为 Python 代码输入时，一定要注意字母的大小写，否则解释器会报错。

值得一提的是，布尔类型可以当做整数来对待，即 True 相当于整数值 1，False 相当于整数值 0。因此，下边这些运算都是可以的：

>>> False+1
1
>>> True+1
2

注意，这里只是为了说明 True 和 False 对应的整型值，在实际应用中是不妥的，不要这么用。
总的来说，bool 类型就是用于代表某个事情的真（对）或假（错），如果这个事情是正确的，用 True（或 1）代表；如果这个事情是错误的，用 False（或 0）代表。

【例 1】

>>> 5>3
True
>>> 4>20
False

在 Python 中，所有的对象都可以进行真假值的测试，包括字符串、元组、列表、字典、对象等，由于目前尚未学习，因此这里不做过多讲述，后续遇到时会做详细的介绍。

posted on 2024-07-26 22:28 无信不立阅读(110) 评论(0) 收藏举报

刷新页面返回顶部