Python基础篇（二）-- 数据类型和运算符

1 数据类型

        所有的编程语言都支持变量，变量是编程的起点，程序需要将数据存储到变量中。在编程语言中，变量是数据的载体，简单的说就是一块用来保存数据的内存空间，变量的值可以被读取和修改，这是所有计算和控制的基础。从底层看，程序中的数据最终都要放到内存（内存条）中，变量其实就是这块内存的名字。计算机能处理的远不止数值，还可以处理文本、图形、音频、视频、网页等各种各样的数据，不同的数据，需要定义不同的数据类型。在Python中，能够直接处理的数据类型有以下几种：

• 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
• 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）

        变量在Python内部是有类型的，比如int、float 等，但是我们在编程时无需关注变量类型，所有的变量都无需提前声明，赋值后就能使用。另外，Python是动态类型语言，可以将不同类型的数据赋值给同一个变量，所以变量的类型是随时可以改变的。

        任何编程语言都需要处理数据，比如数字、字符串、字符等，我们可以直接使用数据，也可以将数据保存到变量中，方便以后使用。

        Python中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

        在Python中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。等号（=）用来给变量赋值。

变量与常量
        常量是在程序运行过程中，值不能改变的量。Python中并未提供定义常量的保留字，在PEP8规定常量有大写字母和下划线组成。
        Python中，使用内置函数type()返回变量类型，使用id()返回变量所指内存区域。

>>> AGE_OF_NICK = 19
>>> id(AGE_OF_NICK)
>>> type(AGE_OF_NICK)

        在内存中存储的数据可以有多种类型。字符型、数值型、布尔型都是Python语言中提供的基本数据类型。

1.1 数字

        Python中提供了数字类型保存数值，数字类型包括整数、浮点数和复数。他们是不可改变的数据类型，这意味着改变数字数据类型会分配一个新的对象。当你指定一个值时，Number 对象就会被创建：

>>> number = 10

1、整数
        整数包括正整数、负整数和零。在Python3中，不管对于多大或者多小的整数，只用一种类型存储，就是int。Python整数的取值范围是无限的，不管多大或者多小的数字，Python都能轻松处理。当所用数值超过计算机自身的计算能力时，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开头

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

2、小数/浮点数
        浮点数由整数部分和小数部分组成，主要用于处理包括小数的数。有两种书写形式：

1. 十进制形式
   这种就是我们平时看到的小数形式，例如 34.6、346.0、0.346。

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

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

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

>>> print(12e4)
120000.0
>>> print(12.3*0.1)
1.2300000000000002

        温馨提示： 12.3*0.1的计算结果很明显是 1.23，但是print的输出却不精确。这是因为小数在内存中是以二进制形式存储的，小数点后面的部分在转换成二进制时很有可能是一串无限循环的数字，无论如何都不能精确表示，所以小数的计算结果一般都是不精确的。对于浮点数，不能直接使用比较判断是否相等。

3、复数类型
        复数由实部（real）和虚部（imag）组成，并且使用j或者J表示虚部。可以用a + bj，或者·complex(a,b)·表示， 复数的实部和虚部都是浮点型。

>>> a = complex(3, 4)
>>> print(a.real)
3.0
>>>print(a.imag)
4.0

4、布尔类型
        布尔类型主要用来表示真值或假值。在Python中，标识符True和False被解释为布尔值。另外，Python中的布尔值可以转化为数值，True表示1，False表示0。

        在Python中，所有的对象都可以进行真值测试。其中，只有下面列出的几种情况得到的值为假，其他对象在if或者while语句中都表现为真。

• False 或 None。
• 数值中的零，包括0、0.0、虚数0。
• 回空序列，包括字符串、空元组、空列表、空字典。
• 自定义对象的实例，该对象的_bool_方法返回False或者_len_方法返回0。

        温馨提示：Python中的布尔类型的值可以进行数值运算，例如，“False +1”的结果为1。但是不建议对布尔类型的值进行数值运算。

1.2 字符串

        字符串就是连续的字符序列，可以是计算机所能表示的一切字符的集合。Python中字符串属于不可变序列，使用单引号'...'，双引号''...''，或'''...'''括起来。Python中单引号和双引号使用完全相同，只能单行；使用三引号(’’'或""")可以指定一个多行字符串。详细用法如下：

• 字符串可以用+运算符连接在一起，用*运算符重复。
• Python中的字符串有两种索引方式，从左往右以 0 开始，最大范围是字符串长度少1；从右往左以 -1 开始，最大范围是字符串开头。
• Python没有单独的字符类型，一个字符就是长度为 1 的字符串。
• 字符串的截取的语法格式如下：变量[头下标:尾下标:步长]，其中头下标是从 0 开始算起，可以是正数或负数；尾下标可以为空表示取到头或尾；步长表示间隔。获取的子字符串包含头下标的字符，但不包含尾下标的字符。

>>> str = 'Hello World!'
>>> print(str[2；5])
llo
>>> print(str*2)
Hello World!Hello World!
>>> print(str+"Test")
Hello World!Test

1.3 列表

        List（列表） 是 Python 中使用最频繁的数据类型。列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（即嵌套）。列表用[ ]标识，是python最通用的复合数据类型。

        列表中值的切割也可以用到变量 [头下标:尾下标] ，就可以截取相应的列表，从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标可以为空表示取到头或尾。

        加号+是列表连接运算符，星号*是重复操作。如下实例：

list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']
 
print list               # 输出完整列表
print list[0]            # 输出列表的第一个元素
print list[1:3]          # 输出第二个至第三个元素 
print list[2:]           # 输出从第三个开始至列表末尾的所有元素
print tinylist * 2       # 输出列表两次
print list + tinylist    # 打印组合的列表

输出结果：

[‘runoob’, 786, 2.23, ‘john’, 70.2]
runoob
[786, 2.23]
[2.23, ‘john’, 70.2]
[123, ‘john’, 123, ‘john’]
[‘runoob’, 786, 2.23, ‘john’, 70.2, 123, ‘john’]

1.4 元组

        元组是另一个数据类型，类似于 List（列表）。元组用 () 标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。

tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
tinytuple = (123, 'john')
 
print tuple               # 输出完整元组
print tuple[0]            # 输出元组的第一个元素
print tuple[1:3]          # 输出第二个至第四个（不包含）的元素 
print tuple[2:]           # 输出从第三个开始至列表末尾的所有元素
print tinytuple * 2       # 输出元组两次
print tuple + tinytuple   # 打印组合的元组

输出结果：

(‘runoob’, 786, 2.23, ‘john’, 70.2)
runoob
(786, 2.23)
(2.23, ‘john’, 70.2)
(123, ‘john’, 123, ‘john’)
(‘runoob’, 786, 2.23, ‘john’, 70.2, 123, ‘john’)

        温馨提示： 元组是不允许更新的，而列表是允许更新的。

1.5 集合

        Python中的集合，和数学中的集合概念一样，用来保存不重复的元素，即集合中的元素都是唯一的，互不相同。从形式上看，和字典类似，Python集合会将所有元素放在一对大括号 {} 中，相邻元素之间用“,”分隔，如下所示：

{element1, element2, …, elementn}

        从内容上看，同一集合中，只能存储不可变的数据类型，包括整形、浮点型、字符串、元组，无法存储列表、字典、集合这些可变的数据类型，否则 Python 解释器会抛出 TypeError 错误。

1.6 字典

        字典(dictionary)是除列表以外Python之中最灵活的内置数据结构类型。列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。字典用"{ }"标识。字典由索引(key)和它对应的值value组成。

dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"

tinydict = {'name': 'runoob','code':6734, 'dept': 'sales'}
 
print dict['one']          # 输出键为'one' 的值
print dict[2]              # 输出键为 2 的值
print tinydict             # 输出完整的字典
print tinydict.keys()      # 输出所有键
print tinydict.values()    # 输出所有值

输出结果为：

This is one
This is two
{‘dept’: ‘sales’, ‘code’: 6734, ‘name’: ‘runoob’}
[‘dept’, ‘code’, ‘name’]
[‘sales’, 6734, ‘runoob’]

小结

• 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
• 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

---

2 运算符

        运算符将各种类型的数据连接在一起形成表达式。Python 的运算符丰富但不混乱，比如 Python 支持自增和自减运算符，但是它只支持一种形式，就是前自增和前自减，而取消了后自增和后自减，避免了给程序员造成混乱。

        Python的运算符包括算术运算符、赋值运算符、比较运算符、逻辑运算符和位运算符。使用运算符将不同类型数据按照一定规则连接在一起的式子称为表达式。

2.1 转义字符

转义字符	描述
\n	换行符，将光标位置移到下一行开头
\r	回车符，将光标位置移到本行开头
\t	水平制表符，也即 Tab 键，一般相当于四个空格
\a	蜂鸣器响铃
\b	退格（Backspace），将光标位置移到前一列
\0	空
\f	换页
\	反斜线
\’	单引号
\”	双引号
\	在字符串行尾的续行符，即一行未完，转到下一行继续写

        温馨提示： 反斜杠可以用来转义，使用r可以让反斜杠不发生转义。 如r"this is a line with \n"则\n会显示，并不是换行。

2.2 数据类型转换

函数	描述
int(x [,base])	将x转换为一个整数
float(x)	将x转换到一个浮点数
complex(real [,imag])	创建一个复数
str(x)	将对象 x 转换为字符串
repr(x)	将对象 x 转换为表达式字符串
eval(str)	用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s)	将序列 s 转换为一个元组
list(s)	将序列 s 转换为一个列表
set(s)	转换为可变集合
dict(d)	创建一个字典。d 必须是一个序列 (key,value)元组。
frozenset(s)	转换为不可变集合
chr(x)	将一个整数转换为一个字符
unichr(x)	将一个整数转换为Unicode字符
ord(x)	将一个字符转换为它的整数值
hex(x)	将一个整数转换为一个十六进制字符串
oct(x)	将一个整数转换为一个八进制字符串

2.3 算术运算符

        这里以 $a=10,b=20$ 为例

运算符	描述	实例
+	加 - 两个对象相加	a + b 输出结果 30
-	减 - 得到负数或是一个数减去另一个数	a - b 输出结果 -10
*	乘 - 两个数相乘或是返回一个被重复若干次的字符串	a * b 输出结果 200
/	除 - x除以y	b / a 输出结果 2
%	取模 - 返回除法的余数	b % a 输出结果 0
**	幂 - 返回x的y次幂	a**b 为10的20次方， 输出结果 100000000000000000000
//	取整除 - 返回商的整数部分（向下取整）	>>> 9//2 4 >>> -9//2 -5

1、/ 和 // 除法运算符
        Python支持/和//两个除法运算符，但它们之间是有区别的：

• /表示普通除法，使用它计算出来的结果和数学中的计算结果相同。
• //表示整除，只保留结果的整数部分，舍弃小数部分；注意是直接丢掉小数部分，而不是四舍五入。

>>> print(20/4)
5.0
>>> print(20//4)
5
>>> print(20.4/4)
5.0

温馨提示：

• /的计算结果总是小数，不管是否能除尽，也不管参与运算的是整数还是小数。当有小数参与运算时，//结果才是小数，否则就是整数。
• 需要注意的是，除数始终不能为 0，除以 0 是没有意义的，这将导致ZeroDivisionError错误。在某些编程语言中，除以 0 的结果是无穷大（包括正无穷大和负无穷大）。
  2、% 求余运算符
          %运算符用来求得两个数相除的余数，包括整数和小数。Python使用第一个数字除以第二个数字，得到一个整数的商，剩下的值就是余数。对于小数，求余的结果一般也是小数。

>>> print("7.7%2.2 =", 7.7%2.2)
7.7%2.2 = 1.0999999999999996
>>> print("-7.7%2.2 =", -7.7%2.2)
-7.7%2.2 = 1.1000000000000005
>>> print("7.7%-2.2 =", 7.7%-2.2)
7.7%-2.2 = -1.1000000000000005
>>> print("-7.7%-2.2 =", -7.7%-2.2)
-7.7%-2.2 = -1.0999999999999996

        从运行结果可以发现两点：

• 只有当第二个数字是负数时，求余的结果才是负数。换句话说，求余结果的正负和第一个数字没有关系，只由第二个数字决定。
• %两边的数字都是整数时，求余的结果也是整数；但是只要有一个数字是小数，求余的结果就是小数。

2.4 赋值运算符

运算符	描述	示例
=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c *= a 等效于 c = c * a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c **= a 等效于 c = c ** a
//=	取整除赋值运算符	c //= a 等效于 c = c // a
:=	海象运算符，可在表达式内部为变量赋值	b = [(a:=0)+1, a-1, a*1, a/1]

        温馨提示： 海象运算符是Python3.8版本新增运算符。

2.5 比较运算符

        比较运算符，也称关系运算符，用于对常量、变量或表达式的结果进行大小比较。如果这种比较是成立的，则返回 True（真），反之则返回 False（假）。

运算符	描述
==	等于——比较对象是否相等，返回True/False
!=	不等于——比较两个对象是否相等，返回True/False
>	大于——判断x是否大于y，返回True/False
<	小于——判断x是否小于y，返回True/False
>=	大于等于——判断x是否大于等于y，返回True/False
<=	小于等于——判断x是否小于等于y，返回True/False

        补充：在Python中，当需要判断一个变量是否介于两个值之间时，可以采用“值1<变量<值2"的形式，例如“0

2.6 逻辑运算符

逻辑运算符	描述
and	逻辑与运算，a and b，如果a为False，返回a的计算值，否则返回b的计算值
or	逻辑或运算，a or b，如果a是True，则返回a的计算值，否则返回b的计算值
not	逻辑非运算，not a，如果a为 True，返回 False，反之，则返回True

        对于and运算符，两边的值都为真时最终结果才为真，但是只要其中有一个值为假，那么最终结果就是假，所以 Python按照下面的规则执行and运算：

• 如果左边表达式的值为假，那么就不用计算右边表达式的值了，因为不管右边表达式的值是什么，都不会影响最终结果，最终结果都是假，此时and会把左边表达式的值作为最终结果。
• 如果左边表达式的值为真，那么最终值是不能确定的，and会继续计算右边表达式的值，并将右边表达式的值作为最终结果。

        对于or运算符，情况是类似的，两边的值都为假时最终结果才为假，只要其中有一个值为真，那么最终结果就是真，所以Python按照下面的规则执行or运算：

• 如果左边表达式的值为真，那么就不用计算右边表达式的值了，因为不管右边表达式的值是什么，都不会影响最终结果，最终结果都是真，此时or会把左边表达式的值作为最终结果。
• 如果左边表达式的值为假，那么最终值是不能确定的，or会继续计算右边表达式的值，并将右边表达式的值作为最终结果。

>>> print(1 and 2)
2
>>> print(1 and 0)
0
>>> print("" or "Python")
Pyhton
>>> print(18.5 or "Python")
18.5

        温馨提示： 在Python中，and和or不一定会计算右边表达式的值，有时候只计算左边表达式的值就能得到最终结果。另外，and和or运算符会将其中一个表达式的值作为最终结果，而不是将True或者False作为最终结果。

2.7 位运算符

        位运算符把数字看作二进制进行计算。Python中的按位运算法则如下：下表中变量 a 为 60，b 为 13，二进制格式如下：

>>> a = 0011 1100
>>> b = 0000 1101

运算符	描述	实例
&	按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0	(a & b) 输出结果 12 ，二进制解释： 0000 1100
|	按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。	(a | b) 输出结果 61 ，二进制解释： 0011 1101
^	按位异或运算符：当两对应的二进位相异时，结果为1	(a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~	按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1 。~x 类似于 -x-1	(~a ) 输出结果 -61 ，二进制解释： 1100 0011，在一个有符号二进制数的补码形式。
<<	左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0。	a << 2 输出结果 240 ，二进制解释： 1111 0000
>>	右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数	a >> 2 输出结果 15 ，二进制解释： 0000 1111

        温馨提示： 由于移位运算的速度很快，在程序中遇到表达式乘以或除以2的n次幂的情况时，一般采用移位运算来代替。

2.8 其他运算符

1、成员运算符

运算符	描述
in	如果在指定的序列中找到值返回 True，否则返回 False
not in	如果在指定的序列中没有找到值返回 True，否则返回 False

2、身份运算符

运算符	描述
is	判断两个标识符是不是引用自一个对象，返回True/False
is not	判断两个标识符是不是引用自不同对象，返回True/False

        is判断两个对象是否相同，就是判断两个对象的内存地址。如果内存地址相同，说明两个对象使用的是同一块内存，当然就是同一个对象了。 ==用于判断引用变量的值是否相等。

2.9 运算符优先级

        优先级高的优先计算，优先级一样的从左往右依次计算(此为3.8官方文档数据)

优先级	运算符	描述
1	(experession,…)，[expression,…]，{key:datum,…}，{expression,…}	绑定或元组显示,列表显示,字典显示,设置显示
2	x[index]，x[index:index]，f(arguments…)，x.attribute	抽取（下标）切片（寻址段）调用（函数调用），属性引用
3	await x	await表达式
4	**	乘方
5	+x，-x，~x	正，负，按位非 NOT
6	*，/，%,//,@	乘法、除法、取余、整除、矩阵乘
7	+,-	加法与减法
8	<<,>>	移位
9	&	按位与AND
10	^	按位异或XOR
11	|	按位或OR
12	<，<=，>，>=，!=，==，in，not in，is，is not	比较运算，包括成员检测和标识号检测
13	not x	布尔逻辑“非” NOT
14	and	布尔逻辑“与” AND
15	or	布尔逻辑“或” OR
16	if–else	条件表达式
17	lambda	Lambda表达式
18	:=	海象运算符

        温馨提示： 虽然Python运算符存在优先级的关系，但不推荐过度依赖运算符的优先级，这会导致程序的可读性降低。因此，建议编程时：

• 不要把一个表达式写得过于复杂，如果一个表达式过于复杂，可以尝试把它拆分来书写。
• 不要过多地依赖运算符的优先级来控制表达式的执行顺序，这样可读性太差，应尽量使用( )来控制表达式的执行顺序。

以上内容仅作为自己学习使用，主要整理自以下Python教程网站：

• C语言中文网Python教程：http://c.biancheng.net/python/variable/
• 菜鸟教程：https://www.runoob.com/python/python-variable-types.html
• 廖雪峰Python教程：https://www.liaoxuefeng.com/wiki/1016959663602400/1017063413904832