Python的变量类型2

19/9/2022
阅读时间 4 分钟

任何的编程语言都需要处理数据，从而达到某种目的，但我们需要把这些数据存入到变量中方便我们的使用。

变量可以看成一种容器，里面有程序中的数据。每个变量都拥有独一无二的名字，通过名字就可以找到变量中的数据。

其实数据最终的归属都在内存中，所以也就是说名一个变量的名字，就相当于给一内存命名。

和变量与之对应的就是常量，常量和变量的不同就在于常量不可以被修改，而变量是可以被修改的。常量一旦保存某个数据后就不能被修改了。

Python 变量的赋值

在编程语言中我们将数据放进变量的过程称为赋值。当然在Python中用=作为赋值运算符。

name = value

name表示变量名；value 表示值，也就是要存的数据。

还有要注意的是，我们变量的命名一定要避开内置函数，和保留字。

变量中的值不是一成不变的，他可以随时被更改，只要再重新赋值即可，而且在python中你不必担心数据类型间转换的问题，可以将不同类型的数据赋值给同一个变量。

   n = 10 #将10赋值给变量n
   n = 95 #将95赋值给变量n
   n = 200 #将200赋值给变量n

   ab = 12.5 #将小数赋值给变量ab
   ab = 85 #将整数赋值给变量ab
   ab = "tianlangz.top" #将字符串赋值给变量ab

需要注意的是变量的值一旦被修改了，就相当于被覆盖了，找不回来了，换句话说变量只能容纳一个值。

我们除了能赋值单个数据，也可以将表达式的运行结果赋值给变量：

   s = 100 + 20 #将加法的结果赋值给变量
   rem = 25 * 30 % 7 #将余数赋值给变量
   t = "自己的博客" + "tianlangz.top" #将字符串拼接后的结果赋值给变量

Python 是弱类型语言

对于强类型编程语言来说，定义变量时必须声明变量类型，而且赋值时也要和变量类型相同，例如：C语言，C++语言，java等都是强类型语言。

类似于Python、PHP，Javascript等语言就属于弱类型语言，而弱类型语言有两个特点：

变量无需声明就可以直接赋值，对一个不存在的变量赋值就相当于定义了一个新的变量。
变量的数据类型可以随时被改变。

但需要注意的是，弱类型语言不代表它没有类型！弱类型语言只是说编写代码时不需要可以去关注变量的类型，但在编程语言的内部仍然是有类型的，我们可以使用type()内置函数类来检测某个变量或者表达式的类型。

整数

整数：在C语言中它的表示有很多种，它们的长度也都各不相同，能容纳的整数大小也各不相同。而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'>

不管对于多大或者多小的整数，Python只用一种类型存储，就是int。

在这里额外提一嘴，Python 3.x只用int一种类型存储整数，但是 Python 2.x会使用long类型来存储较大的整数。例如上面的代码，两个长的在显示类型时就会显示long。

但是不管哪个版本的Python，都不用程序员操心底层是int还是long类型，因为他都能轻松处理。

整数的不同进制

十进制形式
二进制形式

由0和1两个数字组成，书写时以0b或0B开头。
八进制形式

八进制由0 ~ 7 八个数字组成，以0o或0O开头。
十六进制形式

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

  #十六进制
  hex1 = 0x45
  hex2 = 0x4Af
  print("hex1Value: ", hex1)
  print("hex2Value: ", hex2)
  #二进制
  bin1 = 0b101
  print('bin1Value: ', bin1)
  bin2 = 0B110
  print('bin2Value: ', bin2)
  #八进制
  oct1 = 0o26
  print('oct1Value: ', oct1)
  oct2 = 0O41
  print('oct2Value: ', oct2)

运行结果

hex1Value:  69
hex2Value:  1199
bin1Value:  5
bin2Value:  6
oct1Value:  22
oct2Value:  33

为了提高数字的可读性，Python允许使用下划线_作为数字(包括整数和小数)的分隔符。类似于英文的逗号。下划线并不会影响数字本身的值。

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

运行结果：

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

小数/浮点数

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

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

十进制形式
指数形式

Python小数的指数写法aen或aEn。a为尾数部分，是一个十进制数；E和e是固定的字符，用于分割尾数部分和指数部分。

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

注意一点，只要写成指数形式的就是小数，即使它的最终值看起来像一个整数。

Python只有一种小数类型，就是float。

    f1 = 12.5
    print("f1Value: ", f1)
    print("f1Type: ", type(f1))
    f2 = 0.34557808421257003
    print("f2Value: ", f2)
    print("f2Type: ", type(f2))
    f3 = 0.0000000000000000000000000847
    print("f3Value: ", f3)
    print("f3Type: ", type(f3))
    f4 = 345679745132456787324523453.45006
    print("f4Value: ", f4)
    print("f4Type: ", type(f4))
    f5 = 12e4
    print("f5Value: ", f5)
    print("f5Type: ", type(f5))
    f6 = 12.3 * 0.1
    print("f6Value: ", f6)
    print("f6Type: ", type(f6))

运行结果

f1Value:  12.5
f1Type:  <class 'float'>
f2Value:  0.34557808421257
f2Type:  <class 'float'>
f3Value:  8.47e-26
f3Type:  <class 'float'>
f4Value:  3.456797451324568e+26
f4Type:  <class 'float'>
f5Value:  120000.0
f5Type:  <class 'float'>
f6Value:  1.2300000000000002
f6Type:  <class 'float'>

从运行结果可以看出，Python 能容纳极小和极大的浮点数。print 在输出浮点数时，会根据浮点数的长度和大小适当的舍去一部分数字，或者采用科学计数法。

f5 的值是 120000，但是它依然是小数类型，而不是整数类型。

让人奇怪的是 f6，12.3*0.1的计算结果很明显是 1.23，但是 print 的输出却不精确。这是因为小数在内存中是以二进制形式存储的，小数点后面的部分在转换成二进制时很有可能是一串无限循环的数字，无论如何都不能精确表示，所以小数的计算结果一般都是不精确的

复数

在这里我只能说作者我本人也没弄清楚复数是个啥，但是学到这里了，这个东西也比较简单，就跟大家简单说一下，只有输入输出，因为复数的计算不用我们来计算，这个东西交给计算机，所以我们不用担心不会原理做不出来。

复数(Cmplex)是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)

可以发现，复数在 Python 内部的类型是 complex，Python 默认支持对复数的简单计算。

字符串

若干个字符的集合就叫做字符串。Python中的字符串必须由双引号""或者单引号''包围。

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

字符串的内容可以包括字母、标点、特殊符号、中文、日文等世界上所有的文字。

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

处理字符串中额外的引号

当字符串内容中出现引号时，我们需要进行特殊处理，否则 Python 会解析出错，例如：

'I'm a great coder!'

由于上面字符串中包含了单引号，此时 Python 会将字符串中的单引号与第一个单引号配对，这样就会把’I’当成字符串，而后面的m a great coder!‘就变成了多余的内容，从而导致语法错误。

对引号进行转义

在需要转义的引号前面加\来对它进行转义。
使用不同的引号来包围字符串

字符串换行

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)

Python 的长字符串

Python长字符串的写法就是将原先的包围字符串的前后各一个单引号或者双引号换成三个，所谓长字符串，就是可以直接换行(不用加反斜杠\)书写的字符串。

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

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

在长字符串中放置单引号和双引号不会导致解析错误。

如果长字符串没有赋值给任何变量，那么这个长字符串就不会起到任何作用，和一段普通的文本无异，相当于被注释掉了。

但要记住，此时Python解释器并不会忽略掉这段字符串，也会按照语法解析，只是字符串起不到实际作用罢了。

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

longstr = '''It's not easy for me to write this program. 
I hope you will cherish it.'''
print(longstr)

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

longstr = '''
    It's not easy for me to write this program. 
    I hope you will cherish it.
'''
print(longstr)

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

    It's not easy for me to write this program. 
    I hope you will cherish it.

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

Python 原始字符串

Python 字符串中的反斜杠有着特殊的作用，就是转义字符。

但是转义字符有时候会带来一些麻烦，例如我要输入一个路径 D:\Program Files\Python 3.8\python.exe这样的字符串，在 Python 程序中直接这样写肯定是不行的，不管是普通字符串还是长字符串。因为\的特殊性，我们需要对字符串中的每个\都进行转义，也就是写成D:\\Program Files\\Python 3.8\\python.exe这种形式才行。

这种写法我们需要特别的谨慎，稍有疏忽就会出现错误。而为了解决这个问题，便出现了原始字符串，在原始字符串中\不会被当作转义字符，保持内容的原汁原味。

在普通的字符串或者长字符串前加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\

Python bool 布尔类型

Python 提供了bool类型来表示真假，在Python用True和False来表示。

例如：

>>> 570>399
Ture
>>>41>200
False

在Python中所有对象都可以进行真假值的测试。

值得一提的是bool类型也可以当作整数来对待，即Ture等于整数值1，Flase相当于整数0，因此有一个有趣的例子就产生了：

>>> False+1
1
>>> Ture+1
2

注意这里只是为了说明Ture和False对应的整数值，在实际应用中是不妥的，千万不要这么用。

Python bytes 类型及用法

Python 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岁了

Posts in this Series

编程基础 python基础