【Python】Python变量类型和运算符 一

「这是我参与2022首次更文挑战的第7天，活动详情查看：2022首次更文挑战」

---

变量定义和使用

变量赋值

name = value

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

在强类型的编程语言中，定义变量时要指明变量的类型，而且赋值的数据也必须是相同类型的，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'>

int整数类型

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

有些强类型的编程语言会提供多种整数类型，每种类型的长度都不同，能容纳的整数的大小也不同，开发者要根据实际数字的大小选用不同的类型。例如C语言提供了 short、int、long、long long 四种类型的整数，它们的长度依次递增，初学者在选择整数类型时往往比较迷惑，有时候还会导致数值溢出。

而 Python 则不同，它的整数不分类型，或者说它只有一种类型的整数。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'>

x 是一个极大的数字，y 是一个很小的数字，Python 都能正确输出，不会发生溢出，这说明 Python 对整数的处理能力非常强大。

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

整数不同进制

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

1. 十进制形式

我们平时常见的整数就是十进制形式，它由 0~9 共十个数字排列组合而成。

注意，使用十进制形式的整数不能以 0 作为开头，除非这个数值本身就是 0。

2. 二进制形式

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

3. 八进制形式

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

在 Python 2.x 中，八进制数字还可以直接以0（数字零）开头。

4. 十六进制形式

由 09 十个数字以及 AF（或 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 3.x 允许使用下划线_作为数字（包括整数和小数）的分隔符。通常每隔三个数字添加一个下划线，类似于英文数字中的逗号。下划线不会影响数字本身的值。

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

运行结果

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

float小数/浮点数类型

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

Python中小数有两种书写形式

• 十进制形式：34.6、346.0、0.346

  书写小数时必须包含一个小数点，否则会被 Python 当作整数处理。

• 指数形式

  aEn 或 aen
  

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

  指数形式的小数举例：

  • 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 是指数。

  **只要写成指数形式就是小数，即使它的最终值看起来像一个整数。**例如 14E3 等价于 14000，但 14E3 是一个小数。

**Python 只有一种小数类型，就是 float。**C语言有两种小数类型，分别是 float 和 double：float 能容纳的小数范围比较小，double 能容纳的小数范围比较大。

应用

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 的值是 1让人奇怪的是 f6，12.3*0.1的计算结果很明显是 1.23，但是 print 的输出却不精确。这是因为小数在内存中是以二进制形式存储的，小数点后面的部分在转换成二进制时很有可能是一串无限循环的数字，无论如何都不能精确表示，所以小数的计算结果一般都是不精确的。0000，但是它依然是小数类型，而不是整数类型。

complex复数类型

复数（Complex）是 Python的内置类型，直接书写即可。换句话说，Python 语言本身就支持复数，而不依赖于标准库或者第三方库。

复数由实部（real）和虚部（imag）构成，在 Python 中，复数的虚部以j或者J作为后缀，具体格式为：

a + bj

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

使用

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 默认支持对复数的简单计算。

字符串

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

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

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

Python 字符串中的双引号和单引号没有任何区别。

处理字符串中的引号

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

'I'm a great coder!'

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

处理方案

• 对引号进行转义

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

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

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

字符串换行

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

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

运行结果

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 took me 6 months to write this Python tutorial.
Please give me a to 'thumb' to keep it updated.'''
print(longstr)

长字符串中的换行、空格、缩进等空白符都会原样输出。

原始字符串

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"""原始字符串内容"""

应用

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

原始字符串的引号

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

demo

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

运行结果

I\'m a good coder!

Python 原始字符串中的反斜杠仍然会对引号进行转义，因此原始字符串的结尾处不能是反斜杠，否则字符串结尾处的引号会被转义，导致字符串不能正确结束

那我们该怎么写D:\Program Files\Python 3.8\呢？

可以这样

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

运行结果

D:\Program Files\Python 3.8\

我们先写了一个原始字符串r'D:\Program Files\Python 3.8'，紧接着又使用'\\'写了一个包含转义字符的普通字符串，Python 会自动将这两个字符串拼接在一起。

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

注意上面的波浪线信息。

PEP 8: W605 invalid escape sequence '\P'

所以使用原始字符串更好，可以解决转义字符的问题。

bytes类型

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对象

# 通过构造函数创建空 bytes
b1 = bytes()
# 通过空字符串构建空 bytes
b2 = b''
print("b1: ", b1)
print("b2: ", b2)

# 通过b前缀将字符串转换成 bytes
b3 = b'http://c.biancheng.net/python/'
print("b3: ", b3)
print(b3[3])
print(b3[7:22])

# 为 bytes() 方法指定字符集
b4 = bytes('我8岁了', encoding='UTF-8')
print("b4: ", b4)

运行结果

b1:  b''
b2:  b''
b3:  b'http://c.biancheng.net/python/'
112
b'c.biancheng.net'
b4:  b'\xe6\x88\x918\xe5\xb2\x81\xe4\xba\x86'
b5:  b'\xe6\x88\x918\xe5\xb2\x81\xe4\xba\x86'

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

字节串 ——> 字符串

decode() 方法，通过该方法可以将 bytes 对象转换为字符串。

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

运行结果

str1:  我8岁了

bool类型

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

值得一提的是，布尔类型可以当做整数来对待，即 True 相当于整数值 1，False 相当于整数值 0。

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

总的来说，bool 类型就是用于代表某个事情的真（对）或假（错），如果这个事情是正确的，用 True（或 1）代表；如果这个事情是错误的，用 False（或 0）代表。

input函数：获取用户输入的字符串

内置函数，用于从控制台读取用户输入的内容。。input() 函数总是以字符串的形式来处理用户输入的内容，所以用户输入的内容可以包含任何字符。

** input用法**：

str = input(tipmsg)

说明：

• str 表示一个字符串类型的变量，input 会将读取到的字符串放入 str 中。
• tipmsg 表示提示信息，它会显示在控制台上，告诉用户应该输入什么样的内容；如果不写 tipmsg，就不会有任何提示信息。

【示例】

a = input("Enter a number: ")
b = input("Enter another number: ")

print("aType: ", type(a))
print("bType: ", type(b))

result = a+b
print("result: ", result)
print("resultType: ", type(result))

运行结果

Enter a number: 2
Enter another number: 3
aType:  <class 'str'>
bType:  <class 'str'>
result:  23
resultType:  <class 'str'>

本例中我们输入了两个整数，希望计算出它们的和，但是事与愿违，Python 只是它们当成了字符串，+起到了拼接字符串的作用，而不是求和的作用。

使用 Python 内置函数将字符串转换成想要的类型

• int(string) 将字符串转换成 int 类型；
• float(string) 将字符串转换成 float 类型；
• bool(string) 将字符串转换成 bool 类型。

【修改上述demo】

a = input("Enter a number: ")
b = input("Enter another number: ")
a = float(a)
b = float(b)

print("aType: ", type(a))
print("bType: ", type(b))

result = a+b
print("result: ", result)
print("resultType: ", type(result))

运行结果

Enter a number: 2
Enter another number: 3
aType:  <class 'float'>
bType:  <class 'float'>
result:  5.0
resultType:  <class 'float'>

print()函数高级用法

** print()函数详细语法格式 **：

print (value,...,sep='',end='\n',file=sys.stdout,flush=False)

• value 参数可以接受任意多个变量或值，因此 print() 函数完全可以输出多个值。

例如

user_name ＝ 'Charlie'
user_age = 8
#同时输出多个变量和字符串
print("读者名：",user_name,"年龄：",user_age)

运行结果

读者名： Charlie 年龄： 8

• 使用 print() 函数输出多个变量时，print() 函数默认以空格隔开多个变量，如果读者希望改变默认的分隔符，可通过 sep 参数进行设置。

#同时输出多个变量和字符串，指定分隔符print
("读者名：" ,user_name,"年龄：",user_age,sep='|')

运行上面代码，可以看到如下输出结果：

读者名：|Charlie|年龄：|8

• 在默认情况下，print() 函数输出之后总会换行，这是因为 print() 函数的 end 参数的默认值是“\n”，这个“\n”就代表了换行。如果希望 print() 函数输出之后不会换行，则重设 end 参数即可。

#设置end 参数，指定输出之后不再换行
print(40,'\t',end＝"")
print(5O,'\t',end＝"")
print(60,'\t',end＝"")

运行结果

40    50    60

• file 参数指定 print() 函数的输出目标，file 参数的默认值为 sys.stdout，该默认值代表了系统标准输出，也就是屏幕，因此 print() 函数默认输出到屏幕。实际上，完全可以通过改变该参数让 print() 函数输出到特定文件中。

f = open("demo.txt","w")#打开文件以便写入
print('沧海月明珠有泪',file=f)
print('蓝回日暖玉生烟',file=f)
f.close()

• flush 参数用于控制输出缓存，该参数一般保持为 False 即可，这样可以获得较好的性能。

格式化字符串（格式化输出）

print() 函数使用以%开头的转换说明符对各种类型的数据进行格式化输出。

转换说明符	解释
%d、%i	转换为带符号的十进制整数
%o	转换为带符号的八进制整数
%x、%X	转换为带符号的十六进制整数
%e	转化为科学计数法表示的浮点数（e 小写）
%E	转化为科学计数法表示的浮点数（E 大写）
%f、%F	转化为十进制浮点数
%g	智能选择使用 %f 或 %e 格式
%G	智能选择使用 %F 或 %E 格式
%c	格式化字符及其 ASCII 码
%r	使用 repr() 函数将表达式转换为字符串
%s	使用 str() 函数将表达式转换为字符串

**转换说明符（Conversion Specifier）**只是一个占位符，它会被后面表达式（变量、常量、数字、字符串、加减乘除等各种形式）的值代替。

demo

age = 8
print("已经%d岁了！" % age)

在 print() 函数中，由引号包围的是格式化字符串，它相当于一个字符串模板，可以放置一些转换说明符（占位符）。本例的格式化字符串中包含一个%d说明符，它最终会被后面的 age 变量的值所替代。

中间的%是一个分隔符，它前面是格式化字符串，后面是要输出的表达式。

格式化字符串中也可以包含多个转换说明符，这个时候也得提供多个表达式，用以替换对应的转换说明符；多个表达式必须使用小括号( )包围起来。

demo

print("%s已经%d岁了，它的网址是%s。" % (name, age, url))

总之，有几个占位符，后面就得跟着几个表达式。