第三章 Python数据类型和运算符

第三章 Python数据类型和运算符

保留字

保留字是指在python中被赋予特定意义的一些单词，在开发程序时，不可以把这些保留字作为变量、函数、类、模块、和其他对象的名称来使用。

可以通过python的内置模块keyword关键字获取保留字。【内置模块是指在安装python解释器的时候，直接跟python解释器一起安装过来的，可以直接使用的】

import keyword
print(keyword.kwlist) # 获取关键字的列表
print(len(keyword.kwlist)) # 获取关键字的个数

会发现保留字有大写也有小写，注意保留字是严格区分大小写的。

标识符

标识符可以用来给变量、函数、类、模块和其他对象命名。

python标识符的命名规则(必须遵守)：

• 可以是字符(英文、中文)、下划线 ”_“ 和数字，并且第一个字符不能是数字
• 不能使用python中的保留字
• 标识符严格区分大小写
• 以下划线开头的标识符有特殊意义，不能随便使用
• 允许使用中文作为标识符，但不建议使用

python标识符的命名规范(建议遵守)：

• 模块名尽量短小，并且全部使用小写字母，可以使用下划线分隔多个字母。例如：grame_main
• 包名尽量短小，并且全部使用小写字母，不推荐使用下划线。例如：com.python，不推荐使用com_python
• 类名采用单词首字母大写形式(Pascal风格)。例如：MyClass
• 模块内部的类采用"_" + Pascal 风格的类名组成，例如：在MyClass中的内部类_InnerMyClass
• 函数、类的属性和方法的命名，全部使用小写字母，多个字母之间使用下划线分隔
• 常量命名时采用全部大写字母，可以使用下划线
• 使用单下划线 “_” 开头的模块变量或函数是受保护的，在使用 “from xxx import *” 语句从模块中导入时，这些模块变量或函数不能被导入
• 使用双下划线 “__” 开头的实例变量或方法是类私有的
• 以双下划线开头和结尾的是python的专用标识，例如：__init__()表示初始化函数

变量与常量

变量

内存示意图(值与变量的关系)

luck_number = 8  # 创建一个整形变量luck_number,并为其赋值为8

my_name = '中国'  # 字符串类型的变量

# 使用内置函数type查看变量的类型
print('luck_number的数据类型是：', type(luck_number))
print('my_name的数据类型是：', type(my_name))

print(my_name, '的幸运数字是：', luck_number)

# python动态修改变量的数据类型，通过赋不同类型的值就可以直接修改
luck_number = '北京欢迎你'
print('luck_number的数据类型是：', type(luck_number))

# 在python中允许多个变量指向同一个值
no = number = 1024  # no与number都指向了1024这个整数值
print(no, number)
print(id(no))  # id()是查看对象的内存地址的
print(id(number))

运行结果：

变量命名应遵循以下几条规则：

• 变量名必须是一个有效的标识符
• 变量名不能使用python中的保留字
• 慎用小写字母 i 和大写字母 O (因为看不清楚)
• 应选择有意义的单词作为变量名

常量

常量就是在程序运行过程中，值不允许改变的量。

常量应全部使用大写字母和下划线命名。

示例：

pi = 3.141592653589793 # 定义了一个变量
PI = 3.141592653589793 # 定义了一个常量

数据类型

数值类型

整形

python中的数值类型包括整数类型，浮点数类型以及复数类型。

整数类型是python中的不可变数据类型。

整数类型表示的数值是没有小数部分的数值，包含正整数、负整数和0。

进制种类	引导符号	描述
十进制	无	默认情况，例如：365
二进制	0b或0B	例如：0b10101，0B10101
八进制	0o或0O	例如：0o763，0O765
十六进制	0x或0X	例如：0x987A,0X987A

num = 987 # 默认是十进制，表示整数
num2 = 0b10101 # 使用二进制表示整数
num3 = 0o765 # 使用八进制表示整数
num4 = 0x87ABF # 使用十六进制表示整数

浮点型

浮点数是python中的不可变数据类型。

x = 10
y = 10.0
print('x的数据类型是：', type(x))  # int
print('y的数据类型是：', type(y))  # float

x = 1.99E100
print('科学计数法：', x, 'x的数据类型是：', type(x))

注意：两个浮点类型的数在进行运算时，有一定的概率运算结果后增加一些"不确定的"尾数(因为浮点数在计算机中都是以IEEE 754形式存储的)。【浮点数可以使用内置函数 round() 限定运算结果需要保留的小数尾数。round() 函数的第一个参数是要计算的数；第二个参数是要保留的小数的位数】

print(0.1 + 0.2)  # 不确定尾数问题；输出结果为0.30000000000000004

# 要想得到0.3需要使用round函数，第二个参数表示保留小数的位数
print(round(0.1 + 0.2, 1))

复数

python中的复数与数学中的复数形式完全一致，由实部和虚部组成。其中 j = $\sqrt{-1}$ 。在python中实数部分使用 .real 表示，虚数部分使用 .imag 表示。

x = 123 + 456j
print('实数部分：', x.real)
print('虚数部分：', x.imag)

字符串类型

字符串类型、整数类型和浮点数类型都是python中的不可变数据类型。

city = '北京'
address = "北京市昌平区"

print(city)
print(address)

# 三个单引号(双引号)用于多行字符串
info = '''
地址：北京市昌平区
收件人：北京大学
联系方式：110
'''

info2 = """
地址：北京市昌平区
收件人：北京大学
联系方式：110
"""
print(info)
print('-------------')
print(info2)

转义字符	描述说明
\n	换行符
\t	水平制表位，用于横向跳到下一个制表位
\"	双引号
\’	单引号
\\	一个反斜杠

原字符：使转义字符失效的字符，r或R。

print('北京')
print('欢迎你')
print('------------')
print('北京\n欢迎你')  # 遇到\n即换行，可以连续换多行
print('北\n京\n欢\n迎\n你')
print('hello\toooo')  # hello是5个字符，一个制表位是8个字符，8-5=3
print('hellooooo')
print('老师说：\'好好学习\'')
print('老师说：\"好好学习\"')

# 原字符，使转义字符失效的符号r或R
print(r'北\n京\n欢\n迎\n你')
print(R'北\n京\n欢\n迎\n你')
# 使转义字符失效只需要在前面加r或R

字符串又被称为有序的字符序列，对字符串中某个字符的检索称为索引。

在字符串的索引的基础上，还可以实现对字符串的切片操作。

对字符串中某个子串或区间的检索称为切片。

切片的语法结构(表示从N开始到M结束但是不包括M)

字符串或字符串变量[N:M]

s = 'helloworld'
print(s[0], s[-10])  # 获取序号0和序号-10
print('北京欢迎你'[4])  # 获取字符串中索引为4
print('北京欢迎你'[-1])

print('-------------------')
print(s[2:7])  # 正向从2开始到7结束不包含7
print(s[-8:-3])  # 反向从-8开始到-3结束不包含-3
print(s[:5])  # 默认N从0开始
print(s[5:])  # M默认是切到字符串的结尾

常用的字符串操作：

操作符	描述说明
x + y	将字符串x与y连接起来
x*n 或 n*x	复制n次字符串x
x in s	如果x是s的子串，结果True，否则结果为False

x = '2022年'
y = '北京冬奥会'
print(x + y)  # 连接两个字符
print(x * 10)  # 对x这个字符串的内容复制10次
print(10 * x)

print('北京' in y)  # True
print('上海' in y)  # False

布尔类型

布尔类型是python中的不可变数据类型。

布尔类型是用来表示“真”值或“假”值的数据类型。在Python中使用标识符True或False表示布尔类型的值。布尔类型可以直接转换成整数类型，其中True表示整数1，False表示整数0。

x = True
print(x)
print(type(x))

print(True + 10)  # 11----> 1+10
print(False + 10)  # 10----> 0+10

在Python中一切皆对象，一个变量其实就是一个对象，而每一个对象都会有一个布尔值，可以使用内置函数 bool 去测试对象的布尔值。

布尔值为False的情况如下：

• False 或者是 None
• 数值中的0，包含0，0.0，虚数0
• 空序列，包含空字符串、空元组、空列表、空字典、空集合
• 自定义对象的实例，该对象 __bool__() 方法返回False或 __len__()方法返回0

print(bool(18))  # 测试整数18的布尔值----->True
print(bool(5.4))  # 测试浮点数5.4的布尔值----->True
print(bool(0), bool(0.0))  # 测试0的布尔值---->False

print(bool('北京欢迎您'))  # True
print(bool(''))  # False

print(bool(False))  # False
print(bool(None))  # False

'''
总结：
非0的数的布尔值都为True；0的布尔值为False。
所有非空字符串的布尔值都是True。
'''

数据类型之间的转换

类型转换分为隐式转换与显式转换。

函数	描述说明
int(x)	将x转换为整数类型
float(x)	将x转换为浮点数类型
str(x)	将x转成字符串
chr(x)	将整数x转换为一个字符
ord(x)	将一个字符x转换为其对应的整数值
hex(x)	将一个整数x转换为一个十六进制字符串
oct(x)	将一个整数x转换为一个八进制字符串
bin(x)	将一个整数x转换为一个二进制字符串

x = 10
y = 3
z = x / y  # 在执行除法运算的时候，将运算结果赋值给z
print(z, type(z))  # 隐式转换，通过运算隐式的转了结果的类型

# float类型转成int类型，只保留整数部分
print('float类型转成int类型：', int(3.14))
print('float类型转成int类型：', int(3.9))
print('float类型转成int类型：', int(-3.14))
print('float类型转成int类型：', int(-3.9))

# 将int转成float类型
print('将int转成float类型：', float(10))
# 将str转成int类型
print(int('100') + int('200'))

# 将字符串转成int或float时报错的情况
'''
print(int('18a'))
报错：ValueError: invalid literal for int() with base 10: '18a'
分析：因为a不是十进制数

print(int('3.14'))
报错：ValueError: invalid literal for int() with base 10: '3.14'
分析：'3.14'这个字符串不是十进制整数

print(float('45a.987'))
报错：ValueError: could not convert string to float: '45a.987'
'''

# chr() ord() 是一对互为相反操作
print(ord('中'))  # '中'在Unicode表中对应的整数值
print(chr(20013))  # 20013整数在Unicode表中对应的字符

# 进制之间的转换操作，十进制与其他进制之间的转换。注意转换的结果是字符串类型
print('十进制转成十六进制：', hex(666))
print('十进制转成八进制：', oct(666))
print('十进制转成二进制：', bin(666))

eval函数

eval 函数同 print 和 input 一样，都是python的内置函数，不需要使用任何前缀，直接就可以使用。

eval函数用于去掉字符串最外侧的引号，并按照Python语句格式执行去掉引号后的字符串。

eval()函数经常和input()函数一起使用。

eval的语法格式：

变量 = eval(字符串)

s = '3.14+3'
print(s, type(s))
x = eval(s)  # 使用eval函数去掉s这个字符串中左右的引号，执行加法运算
print(x, type(x))

# eval函数经常与input()函数一起使用，用来获取用户输入的数值
age = eval(input('请输入您的年龄：'))
print(age, type(age))

height = eval(input('请输入您的身高：'))
print(height, type(height))
'''
age = eval(input('请输入您的年龄：'))
input返回的类型都是字符串，所以以上操作是将字符串类型转成了int类型，
相当于int(age)

height = eval(input('请输入您的身高：'))
input返回的类型都是字符串，所以以上操作是将字符串类型转成了float类型，
相当于float(height)
'''

需要特别注意 变量 = eval(字符串) 中字符串本身就是一个字符串的情况：

hello = '北京欢迎你'
print(hello)
print(eval('hello'))

print(eval('北京欢迎你'))

'''
print(eval('hello'))也会输出 北京欢迎你 ；
因为eval去掉字符串左右的引号后就会变成没有引号的hello，
而没有引号的hello是这段代码中的一个变量，
这个变量的值是 北京欢迎你 


print(eval('北京欢迎你'))
会报错NameError: name '北京欢迎你' is not defined
因为'北京欢迎你'去掉左右的引号后就会变成没有引号的 北京欢迎你 ，
而没有引号的 北京欢迎你 应该表示一个变量，
但是这个变量在这段代码中没有被定义，所以报错
'''

运算符

算术运算符

算术运算符：用于处理四则运算的符号。

运算符	描述说明	示例	结果
+	加法	1+1	2
-	减法	1-1	0
*	乘法	2*3	6
/	除法	10/2	5.0
//	整除	10//3	3
%	取余	10%3	1
**	幂运算	2**4	16

算术运算符的优先级由高到低是：
第一级：**
第二级：*、/、%、//
第三级：+、-

注意：
除法：两个整数做除法的运算结果是一个浮点数
整除：只要运算结果的整数部分

print('加法：', 1 + 1)
print('减法：', 1 - 1)
print('乘法：', 2 * 3)
print('除法：', 10 / 2)  # 除法：两个整数做除法的运算结果是一个浮点数
print('整除：', 10 // 3)  # 整除：只要运算结果的整数部分
print('取余：', 10 % 3)
print('幂运算：', 2 ** 4)  # 2*2*2*2

# 0不能作除数
print(10 / 0)  # 报错：ZeroDivisionError: division by zero

赋值运算符

运算符	描述说明	示例	展开结果
=	简单的赋值运算	x=y	x=y
+=	加赋值	x+=y	x=x+y
-=	减赋值	x-=y	x=x-y
*=	乘赋值	x*=y	x=x*y
/=	除赋值	x/=y	x=x/y
%=	取余赋值	x%=y	x=x%y
**=	幂赋值	x**=y	x=x**y
//=	整除赋值	x//=y	x=x//y

x = 20  # 直接赋值，直接将20赋值给左侧的变量x
y = 10
x = x + y  # 将x+y的和赋值给x
x += y  # 相当于x=x+y
x -= y  # 相当于x=x-y
x *= y  # 相当于x=x*y
x /= y  # 相当于x=x/y
x %= 2  # 相当于x=x%2
x //= y  # 相当于x=x//y
x **= 2  # 相当于x=x**2

 
Python支持链式赋值：

# Python支持链式赋值
a = b = c = 100  # 相当于执行a=100,b=100,c=100
print(a, b, c)

 
Python支持系列解包赋值；Python还可以利用系列解包赋值交换两个变量的值

# Python支持系列解包赋值
a, b = 10, 20  # 相当于执行了a=10,b=20
print(a, b)

# Python还可以利用系列解包赋值交换两个变量的值
a, b = b, a
print(a, b)  # 将b的值赋给a，将a的值赋给b

a = 10
b = 20
c = 30
# b的值赋给a，c的值赋给b,a的值赋给c
a, b, c, = b, c, a
print(a, b, c)  # 20 30 10

比较运算符

比较运算符也称关系运算符。

运算符	描述说明	示例	结果
>	大于	98>90	True
<	小于	98<90	False
==	等于	98==90	False
!=	不等于	98!=90	True
>=	大于或等于	98>=98	True
<=	小于或等于	98<=98	True

print('98大于90吗？', 98 > 90)
print('98小于90吗？', 98 < 90)
print('98等于90吗？', 98 == 90)
print('98不等于90吗？', 98 != 90)
print('98大于等于98吗？', 98 >= 98)
print('98小于等于98吗？', 98 <= 98)

逻辑运算符

运算符	描述说明	用法	结合方向
and	逻辑与	表达式1 and 表达式2	从左到右
or	逻辑或	表达式1 or 表达式2	从左到右
not	逻辑非	not 表达式	从右到左

not 表达式 的结合顺序是从右到左，即先计算右边表达式的值，然后再取非。

表达式1	表达式2	表达式1 and 表达式2	表达式1 or 表达式2	not 表达式1
True	True	True	True	False
True	False	False	True	False
False	False	False	False	True
False	True	False	True	True

print(True and True)
print(True and False)
print(False and False)
print(False and True)
print('-' * 30)

print(8 > 7 and 6 > 5)  # True
print(8 > 7 and 6 < 5)  # False
print(8 < 7 and 10 / 0)  # False，10/0并没有运算
'''
print(8 < 7 and 10 / 0)的结果为False，并没有报错。
已知在除法运算中0不可以作为除数，但是在这里并没有报错。
这是因为当第一个表达式的结果为False，直接得结果，不会计算and 右侧的表达式
'''
print('-' * 30)

print(True or True)
print(True or False)
print(False or False)  # False
print(False or True)
print('-' * 30)

print(8 > 7 or 10 / 0)  # True。左侧表达式结果为True时，or的右侧表达式根本不执行运算
print('-' * 30)

print(not True)  # False
print(not False)  # True
print(not (8 > 7))  # False

位运算符

对于位运算符，了解即可。

位运算符是把数字看作二进制数来进行计算的。[所以需要先将要执行运算的数据转换成二进制，然后才能执行运算]

print('按位与运算：', 12 & 8)
print('按位或运算：', 4 | 8)
print('按位异或运算：', 31 ^ 22)
print('按位取反：', ~123)

print('左移位：', 2 << 2)  # 8,表示的是2向左移动两位    2*2*2
print('左移位：', 2 << 3)  # 16,表示的是2向左移动三位   2*2*2*2

print('右移位：', 8 >> 2)  # 2。 8向右移动两位相当于 8//2,4//2
print('右移位：', -8 >> 2)  # -2。 -8向右移动两位相当于 -8//2，-4//2

# 左乘右除。左移作乘法；右移作除法

优先级

有括号先算括号，括号的优先级最高。

运算符	描述说明
**	幂运算
~、+、-	取反、正号、负号
*、/、%、//	乘、除、取余、整除
+、-	加、减
<<、>>	位运算符中的左移位和右移位
&	位运算符中的按位与
^	位运算符中的异或
|	位运算符中的按位或
<、<=、>、>=、!=、==	比较运算符
=	赋值运算符

练习题

习题一：从键盘获取一个4位整数，分别输出个位、十位、百位、千位上的数字。

方法1：使用eval()函数或者int()函数将从键盘获取的数字串转成int类型，通过整除和取余操作分别获取数字。

方法2：使用字符串的索引。

# 使用eval()函数或者int()函数将从键盘获取的数字串转成int类型，通过整除和取余操作分别获取数字。
num = eval(input('请输入一个四位整数：'))
print('个位上的数：', num % 10)
print('十位上的数：', num // 10 % 10)
print('百位上的数：', num // 100 % 10)
print('千位上的数：', num // 1000)
print('-' * 30)

# 利用字符串索引实现
num = input('请输入一个四位整数：')  # 此时num是一个字符串类型
print('个位上的数：', num[3])
print('十位上的数：', num[2])
print('百位上的数：', num[1])
print('千位上的数：', num[0])

习题二：根据父母身高预测儿子的身高。从键盘输入父母的身高，并使用 eval() 函数或 float() 转换输入的数据类型。计算公式：儿子身高 = ( 父亲身高 + 母亲身高 ) * 0.54 。

father_height = eval(input('请输入爸爸的身高：'))
mother_height = eval(input('请输入妈妈的身高：'))
son_height = (father_height + mother_height) * 0.54
print('预测儿子的身高：', son_height)