【Python基础教程·第二辑】数据类型和运算符

博主： LeoZHN
发布时间：2024 年 07 月 03 日
160 次浏览
暂无评论
11149字数
分类：学术菁英

Python(2)：数据类型和运算符

1 保留字

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

使用内置模块（inner module）keyword可以查询保留字，如下：

import keyword
print(keyword.kwlist) #输出保留字列表
print(len(keyword.kwlist)) #获取保留字的个数

保留字严格区分大小写，比如大写的True不允许被用作变量，但小写的true就可以。

2 标识符

2.1 作用

给变量、函数、类、模块和其他对象命名。

2.2 命名规则（必须遵守）

可以是字符（英文、中文）、下划线"_"和数字，但第一个字符不能是数字。
不能使用Python中的保留字。
标识符严格区分大小写。

2.3 命名规范（建议遵守）

以下划线开头的标识符有特殊意义，一般应避免使用。
允许以中文作为标识符，但不建议这么做。
模块名尽量短小，并全部使用小写字母，单词之间用下划线隔开。比如：grame_main
包名尽量短小，并全部使用小写字母，单词之间用点隔开。比如：com.ysjpython
类名采用单词首字母大写形式（Pascal style）。比如：MyClass
模块内部的类采用“下划线+Pascal”格式。比如：Example_InnerMyClass
函数、类的属性和方法的命名，全部使用小写字母，多个字母之间用下划线分割。
常量命名时采用全部大写字母，可以使用下划线。
使用单下划线开头的模块变量或函数是受保护的，在使用from xxx import *语句从模块中导入时，这些模块变量或函数不能被导入。
使用双下划线 __ 开头的实例变量或方法是类私有的。
以双下划线开头或结尾的是Python的专用标识，例如：__init__()表示初始化函数。

3 变量与常量

3.1 变量的语法结构

变量名=value

举例：luck_number=8 （这里的等号在Python中被称作“赋值运算符”）

内存示意图

3.1.1 查看数据信息的函数

print(type(变量名)) 查看数据的类型（整数，浮点数，复数，字符串……）

print(id(变量名)) 查看数据的内存地址

3.1.2 动态修改变量的数据类型

# 演示1：Python动态修改变量的数据类型，通过赋不同类型的值就可以直接修改
variant_a=8
print('variant_a的数据类型是',type(variant_a))
variant_a='北京欢迎您'
print('variant_a的数据类型是',type(variant_a))

# 演示2：在Python中允许多个变量指向同一个值
no=number=1024 # no和number都指向了1024这个整数值
print(id(no))
print(id(number)) # 这个演示说明了no和number的内存地址都相同

这几行代码的运行效果是：

演示1

variant_a 被赋值为整数 8。
- print('variant_a的数据类型是', type(variant_a)) 输出：variant\_a的数据类型是 \<class 'int'>。这说明 variant_a 的数据类型是整数。
variant_a 被赋值为字符串 '北京欢迎您'。
- print('variant_a的数据类型是', type(variant_a)) 输出：variant\_a的数据类型是 \<class 'str'>。这说明 variant_a 的数据类型变成了字符串。

在这个演示中，variant_a 先被赋予整数值，后来又被赋予字符串值，所以它的数据类型从整数变成了字符串。

演示2

no 和 number 被同时赋值为整数 1024。
- print(id(no)) 和 print(id(number)) 输出的值相同，这说明 no 和 number 指向了相同的内存地址，即它们都指向了整数值 1024。

在这个演示中，no 和 number 都指向了相同的整数值，这是因为在Python中，对于某个具体的值，多个变量可以指向同一个内存地址。

3.2 常量

常量就是在程序运行的过程中不允许改变的量（约定俗成）。
常量全部使用大写字母和下划线命名。

3.2.1 示例

# 演示：常量和变量的区别
pi=3.1415926 #定义了一个变量
PI=3.1415926 #定义了一个常量

在演示中：

pi 被定义为一个变量，因为其名字是小写。
PI 被定义为一个常量，因为其名字是全大写。

实际上，这只是一种约定，Python并不会强制执行常量的概念。你仍然可以改变 PI 的值，但是通常来说，开发者不会在程序中更改被认为是常量的值，以保持代码的清晰性和可读性。

4 数值类型

4.1 整数类型（int）

整数是Python当中的不可变数据类型。注意二进制、八进制和十六进制都是有引导符号的，在赋值中如下表示：

# 演示：不同进制整数的四类引导符
num_decimal=987 # 十进制（decimal）无引导符
num_binary=0b101101 # 二进制（binary）需要在数字前加上0b
num_octal=0o1756 # 八进制（octal）需要在数字前加上0o
num_hexadecimal=0x1f1e33 # 十六进制（hexadecimal）需要在数字前加上0x
print(num_decimal)
print(num_binary)
print(num_octal)
print(num_hexadecimal)
# 使用print()输出的数值均会转换成十进制数

4.2 浮点数类型（float）

浮点型也可以使用科学计数法表示。注意，e在这里不表示自然对数（≈2.718），而表示10的幂指数：

# 演示：浮点数类型的使用
height=187.6 # 身高
print(height)
print(type(height)) # 查看height变量的数值类型

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

x=1.99E1413 #表示极大数1.99×10^1413
print('科学计数法：',x,'x的数据类型',type(x))
print(0.1+0.2) # 浮点数相加，会导致不确定的尾数问题

print(round(0.1+0.2)) # 使用round()保留两位小数

注意，浮点数也是Python当中的不可变数据类型。

4.3 复数类型（complex）

Python中的复数与数学中的复数形式完全一致，由实部和虚部组成。

$$ j=\sqrt{-1} $$

在Python中，实数部分使用.real表示，虚数部分使用.imag表示：

# 演示：复数类型的使用
x=123+456j
print('实数部分',x.real)
print('虚数部分',x.imag)

4.4 字符串类型（str|string）

字符串类型是连续的字符序列，可以表示计算机所能识别的一切字符，也是不可变数据类型。

4.4.1 字符串的界定符

单引号、双引号、三引号。

# 演示1：字符串类型的使用
city='通辽'
address="通辽市科尔沁区霍林河大街1号"
# 一对单引号和一对双引号的效果是一致的
print(city)
print(address)

# 演示2：多行字符串定义
info='''地址：通辽市科尔沁区霍林河大街1号
    收件人：小约翰可汗
    手机号：18600000000
''' 
info2="""地址：通辽市科尔沁区霍林河大街1号
    收件人：小约翰可汗
    手机号：18600000000
"""
# 三个单双引号所得到的结果是一样的
print(info)
print('—'*40)
print(info2)

4.4.2 转义字符

组成：一个反斜杠 + 字母或符号。

如果在转义字符前加上一个原字符r或R，则转义字符会失去作用。

# 演示：转义字符的使用
print('北京')
print('欢迎您')
print('————————————')
print('北京\n欢迎您') # 此处的\n表示了换行
print('北\n京\n欢\n迎\n您') # 此处展示了\n可以连续换行
print('北京\t欢迎您') # 此处的\t表示跳到下一制表位，一个制表位包含8B字符（一个英文字母占1B，一个中文字符占2B）
# ‘北京’占用了4B，则在‘北京’和‘欢迎您’之间插入\t，会空出剩余4个制表位，即在‘北京’和‘欢迎您’之间产生4个空格。
print('hello\toooo') # 在'hello'和'oooo'间会产生3个空格
print('老师说：\'好好学习\'') # 使得单引号展示出来的办法，双引号和反斜杠亦然

# 演示2：原字符，使转义字符失效的符号r或R
print(r'北\n京\n欢\n迎\n您')
print(R'北\n京\n欢\n迎\n您')

这段代码演示了常见的转义字符，如换行符 \n、制表符 \t、单引号 \' 等的使用。另外，使用原始字符串（以 r 或 R 开头的字符串）可以使转义字符失效，直接按照字面意义解释字符串。

4.4.3 索引和切片

4.4.3.1 索引

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

对于字符长度为n的字符串，其正向递增符号从0到n-1，而反向递减序号从-1到-n。

4.4.3.2 切片

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

切片的语法结构：字符串或字符串变量[N:M] ，表示从N开始截到M前一个数为止（不包含M本身，也就是前闭后开）。

4.4.3.3 索引和切片的应用

# 演示：字符串的索引和切片
s='HELLOWORLD'
print(s[0],s[-10]) # 序号0和序号-10表示的是同一个字符
print('北京欢迎您'[4]) # 获取字符串中索引为4的字符
print('北京欢迎您'[-1]) # 获取字符串中索引为-1的字符
# 以上两个结果都会输出相同的“您”

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

4.4.4 常见的字符串操作

# 演示：字符串类型的操作
x='2022年'
y='北京冬奥会'
print(x+y) # 连接两个字符串
print(x*10) # 复制10次字符串
print(10*x) # 符合乘法交换律，结果一致

print('北京' in y) # 验证‘北京’是否存在于字符串y，Ture
print('上海' in y) # 验证‘上海’是否存在于字符串y，False

4.5 布尔类型（boolean）

用来表示“真”值或“假”值的数据类型。

在Python中使用标识符True或False表示布尔类型的值。

True表示整数1，False表示整数0。

# 演示：布尔类型的使用
x=True
print(x)
print(type(x))
print(x+10) # 11 --> 1+10
print(False+10) # 10 --> 0+10

4.5.1 测试对象的布尔值

在Python中，包括变量、函数、类、模块和其他，一切都是对象。

对不同对象的布尔值演示如下：

# 演示：测试对象的布尔值
print(bool(18)) # 测试整数18的布尔值 --> True
print(bool(0)) # 测试整数0和浮点数0.0的布尔值 --> False
print(bool('北京欢迎您')) # 测试字符串布尔值 --> True
print(bool('')) # 测试空字符串布尔值 --> False
print(bool(False)) # 测试保留字False的布尔值 --> False
print(bool(None)) # 测试保留字None的布尔值 --> False

4.5.1.1 布尔值为False的情况

保留字False和None
0（包含整数0、小数0.0、虚数0）
空序列（包含空字符串、空元组、空列表、空字典、空集合）
判空：自定义对象的实例。该对象的__bool__()方法返回False或__len__()方法返回0

5 数据类型之间的转换

5.1 转换类型

5.1.1 隐式转换

程序自动进行的转换，无需函数。比如：

x=True
print(x+10) # 11 --> 1+10 自动转换布尔类型为十进制数

再比如赋值x=10，y=3，z=x/y，在运算z时就会发生隐式转换，将结果换为一个浮点数。

5.1.2 显式转换

使用函数进行转换，如下：

# 系列：显式转换数据类型的函数
# 演示1：int()函数

# int()函数没有四舍五入，只会取整部分
print(int(-3.14)) # 负浮点数-负整数：-3
print(int(-3.9)) # 负浮点数-负整数：-3
print(int(3.14)) # 正浮点数-正整数：3
print(int(3.9)) # 正浮点数-正整数：3

# int()转换本身内容就是数值类型的字符串为整数，可以运算
print(int('100')+int('200')) # --> 300

# 演示2：float()函数
print(float(10)) # 整数-浮点数：多一位-->10.0

# 演示3：int()和float()转换字符串时会报错的情况
# print(int('18a')) # invalide literal for int() with base 10
# print(int('3.14')) # invalide literal for int() with base 10
# print(float('45a.987') # could not convert string to float: '45a.987'

# 演示4：ord()和chr()
print(ord('杨')) # '杨'在Unicode表中对应的整数值
print(chr('26472')) # 26472在Unicode表中对应的字符

# 演示5：进制转换
print(hex(26472)) # 10 base --> 16 base
print(oct(26472)) # 10 base --> 8 base
print(bin(26472)) # 10 base --> 2 base
# 转换后结果是字符串类型

5.2 eval()函数

eval()也是Python中的一个内置函数，用于去掉字符串最外侧的引号，并按照Python语句方式执行去掉引号后的字符串。

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

5.2.1 语法格式

x=eval(string)

5.2.2 演示

注意：如果字符串以非数字字符开始，eval() 会尝试找到表达式中的数字部分，并将其解析为数值，而忽略非数字字符。

# 演示1：eval函数的使用
s='8+6.14'
print(s,type(s)) # 验证s的内容和类型（字符串）

x=eval(s)
print(x,type(x)) # 使用eval去掉s引号，执行加法运算

# 演示2：eval和input的结合使用
# 使用eval转换年龄为整数，相当于int(age)
age=eval(input('请输入您的年龄:'))
print(age,type(age))

# 演示3：eval函数输出字符串
g='北京欢迎您'
print(eval('g')) # 会输出g变量对应的“北京欢迎您”
#print(eval('北京欢迎您')) # NameError

6 运算符

6.1 算术运算符及其优先级

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

6.1.1 基本运算（示例）

# 演示：算术运算符的使用
print(1+1) # 加法
print(1-1) # 减法
print(2*3) # 乘法
print(10/2) # 除法
print(10//3) # 整除
print(10%3) # 取余
print(2**4) # 幂运算
#print(10/0) # ZeroDivisionError: divison by zero

6.1.2 算术运算符的优先级

第一级：**

第二级：* / % //

第三级：+ -

6.2 赋值运算符

赋值运算符是用于为变量进行赋值操作的运算符。

在Python中，最基础的赋值符号就是=。

注意，赋值运算的计算顺序是从右到左的。它会先计算右侧的结果，右侧结果计算完毕后才会赋值给左侧变量。

6.2.1 基本运算（示例）

# 演示：赋值运算符的使用
x=20 # 直接赋值20给x
y=10 # 直接赋值10给y
x=x+y # 将x+y的和赋值给x
print(x)

x+=y # 效果和‘x=x+y’一致，再叠加一遍
print(x)

x-=y # 减等于
print(x)

x*=y # 乘等于
print(x)

x/=y # 除等于（浮点）
print(x,type(x)) # 发生了数据类型的隐式转换(int->float)

x%=2 # 取余赋值给x，相当于x=x%2
print(x)

z=3 # 直接赋值3给z
y//=z # 整除等于
print(y)

y**=2 # 幂运算等于
print(y)

# 链式复制
a=b=c=100 # 相当于a=100 b=100 c=100
print(a,b,c)

# 系列解包赋值
a,b=10,20 # 相当于a=10 b=20
print(a,b)

# 利用系列解包赋值交换两个变量的值
a,b=b,a # 相当于同时执行a=b和b=a
print(a,b)

6.3 比较运算符

比较运算符用以比较大小和真假，也称为关系运算符。比较的结果只有两种：真或假，分别对应了布尔类型True和False。

6.3.1 基本运算（示例）

 # 演示：比较运算符的使用
 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)

6.4 逻辑运算符

逻辑运算符是针对布尔类型值（True和False）的运算，其结果仍然是一个布尔值。

Python当中存在三种逻辑，分别是与、或和非，对应逻辑运算符为and, or, not。

对它们逻辑的说明如下：

6.4.1 “与”和“或”的短路特性

在 Python 中，逻辑运算符 or 和 and 具有短路特性。这意味着如果在 or 运算中第一个表达式为 True，或在 and 运算中第一个表达式为 False，那么不会再继续计算后面的表达式，因为整个表达式已经确定结果。

例子见下。

6.4.2 基本运算（示例）

# 演示：逻辑运算符的使用
# 逻辑与'AND'布尔值演示：仅一种情况为True
print(True and True) # --> True
print(True and False)
print(False and True)
print(False and False)

# 逻辑与'AND'表达式演示：短路特性
print(8>7 and 6>5) # --> True
print(8>7 and 6<5) # --> False
print(8<7 and 10/0) # --> False且不执行10/0运算

# 逻辑或'OR'布尔值演示：仅一种情况为False
print(True or True)
print(True or False)
print(False or True)
print(False or False) # --> False

# 逻辑或'OR'表达式演示：短路特性
print(8>7 or 10/0) # --> True且不执行10/0运算

# 逻辑非'NOT'布尔值/表达式演示：
print(not True) # --> False
print(not False) # --> True
print(not (8>7)) # 对True取反 --> False

6.5 位运算符（了解）

位运算符把数字看作二进制数进行运算。

6.5.1 按“位与”运算（&）

将二进制数按位对齐，同一数位上，值都为1的，结果为1，否则为0。

以下实例中，1100(bin)=12(dec), 1000(bin)=8(dec)，因此看作是12和8的按位与运算。

6.5.1.1 按位与运算示例

# 演示：按位与运算
print(12&8)

6.5.2 按“位或”运算（|）

将二进制数按位对齐，同一数位上，值中只要有一个为1的，结果为1；除非两个都为0，结果才为0。

以下实例中，0100(bin)=4(dec), 1000(bin)=8(dec)，因此看作是4和8的按位与运算。

6.5.2.1 按位或运算示例

# 演示：按位或运算
print(4|8)

6.5.3 按“位异或”运算（^）

将二进制数按位对齐，同一数位上，两个数位不相等，结果为1；两个数位相等，结果为0。

以下实例中，1111(bin)=4(dec), 0110(bin)=6(dec)，因此看作是4和8的按位异或运算。

6.5.3.1 按位异或运算示例

# 演示：按位异或运算
print(31^22)

6.5.4 按“位取反”运算（\~）

按位取反的操作数只有一个，它会将这个操作数的所有数位取反。

6.5.4.1 按位取反运算示例

# 演示：按位取反运算
print(123~)

6.5.5 左移位运算和右移位运算

“左移位”运算（<<）是将一个二进制数向左移动指定的位数，高位端溢出的位被丢弃，低位端的空位补0。

“右移位”运算（>>）则恰恰相反，是将一个二进制数向右移动指定的位数，低位端溢出的位被丢弃，而高位端的空位按照原数的正负补0（正）或1（负）。

# 演示：左移位和右移位运算
print(2<<2) # --> 0000 0010 - 0000 1000  --> 2*(2*2)=8
print(2<<3) # --> 0000 0010 - 0001 0000  --> 2*(2*2*2)=16

print(8>>2) # --> 0000 1000 - 0000 0010  --> 8//(2*2)=2
print(-8>>2) # --> 1111 0101 - 1111 1101 --> -8//(2*2)=-2

6.5.5.1 补充：二进制取相反数——补码

将原数全部取反：0000 1011 —> 1111 0100
加一得到正确结果：1111 0100 —> 1111 0101

6.6 所有运算符的优先级

括号（()）
幂运算（**）
取反（~）、正号和负号（+ -）
算术运算符：乘、浮点除、取余、整除（* / % //）
算术运算符：加和减（+ -）
左移位（<<）和右移位（>>）
按位与（&）
按位异或（^）
按位或（|）
比较运算符：大于、大于等于、小于、小于等于、不等于、等于（> >= < <= != == ）
赋值运算符（=）

7 课后实践题

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

提示：可以使用取余、取整等公式进行操作。

题目2：从键盘输入父母的身高，并预测儿子的身高。计算公式：儿子身高=（父亲身高+母亲身高）*0.54

# 题目1：从键盘获取一个4位整数，分别输出个位、十位、百位、千位上的数字。
# 自己的答案
x=input('请输入一个四位整数:')
x=eval(x)
a=x%10
b=x%100//10
c=x%1000//100
d=x//1000
print('个位上的数字为',a)
print('十位上的数字为',b)
print('百位上的数字为',c)
print('千位上的数字为',d)

# 标准答案1：使用eval % 和 //
num=eval(input('请输入一个四位整数：'))
print('个位上的数字为：',num%10)
print('十位上的数字为：',num//10%10)
print('百位上的数字为：',num//100%10)
print('千位上的数字为：',num//1000)

# 标准答案2：直接使用索引
num=input('请输入一个四位整数：')
print('个位上的数字为：',num[3])
print('十位上的数字为：',num[2])
print('百位上的数字为：',num[1])
print('千位上的数字为：',num[0])

# 题目2：从键盘输入父母的身高，并预测儿子的身高。计算公式：儿子身高=（父亲身高+母亲身高）*0.54
# 自己的答案
dad=eval(input('请输入爸爸的身高：'))
mom=eval(input('请输入妈妈的身高：'))
print('预测儿子的身高为：',(dad+mom)*0.54)

# 标准答案
fh=eval(input('请输入爸爸的身高：'))
mh=eval(input('请输入妈妈的身高：'))
sh=(fh+mh)*0.54
print('预测儿子的身高为：',sh)

最后修改：2024 年 07 月 03 日

喵~

发表评论取消回复
本站使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款。支持Emoji评论。

评论 *

私密评论

名称 *

🎲

邮箱 *

地址

LeoZHN Pad
吐槽不是你妈楼上的大中午弹那个勾八琴，就是有小逼养的放摔炮。...
LeoZHN Pad
你好
LeoZHN Pad
吐槽是不是我最近翻墙翻太多了，被网络供应商盯上了，网速慢的跟...
LeoZHN Pad
吐槽煞笔5G，不开还不能上网了是吧逼养的
LeoZHN Pad
随想我不想让“逃避”成为我人生遗憾的代名词。

今日已经过去小时

这周已经过去天

本月已经过去天

今年已经过去个月

【Python基础教程·第二辑】数据类型和运算符

LeoZHN • 2024 年 07 月 03 日

<h1>Python(2)：数据类型和运算符</h1><h1>1 保留字</h1><ul><li>指在Python中被赋予特定意义的一些单词（共35个），在开发程序时，不可以使用保留字作为变量、函数、类、模块和其他对象的名称来使用。</li><li><p>使用内置模块（inner module）<code>keyword</code>可以查询保留字，如下：</p><pre><code class="lang-python">import keyword
print(keyword.kwlist) #输出保留字列表
print(len(keyword.kwlist)) #获取保留字的个数</code></pre></li></ul><p>保留字<strong>严格区分大小写</strong>，比如大写的True不允许被用作变量，但小写的true就可以。</p><h1>2 标识符</h1><h2>2.1 作用</h2><p>给变量、函数、类、模块和其他对象命名。</p><h2>2.2 命名规则（必须遵守）</h2><ol><li>可以是<strong>字符（英文、中文）、下划线"<strong><em><em><code>_</code></em></strong></em>"和数字</strong>，但<strong>第一个字符不能是数字</strong>。</li><li>不能使用Python中的保留字。</li><li>标识符严格区分大小写。</li></ol><h2>2.3 命名规范（建议遵守）</h2><ol><li>以下划线开头的标识符有特殊意义，一般应避免使用。</li><li>允许以中文作为标识符，但<strong>不建议</strong>这么做。</li><li>模块名尽量短小，并全部使用小写字母，单词之间用下划线隔开。比如：<strong><code>grame_main</code></strong></li><li>包名尽量短小，并全部使用小写字母，单词之间用点隔开。比如：<strong><code>com.ysjpython</code></strong></li><li>类名采用单词首字母大写形式（Pascal style）。比如：<strong><code>MyClass</code></strong>&#x20;</li><li>模块内部的类采用“下划线+Pascal”格式。比如：<strong><code>Example_InnerMyClass</code></strong></li><li>函数、类的属性和方法的命名，全部使用小写字母，多个字母之间用下划线分割。</li><li>常量命名时采用全部大写字母，可以使用下划线。</li><li>使用单下划线开头的模块变量或函数是受保护的，在使用<code>from xxx import *</code>语句从模块中导入时，这些模块变量或函数不能被导入。</li><li>使用双下划线 <code>__</code> 开头的实例变量或方法是<strong>类私有</strong>的。</li><li>以双下划线开头或结尾的是Python的专用标识，例如：<code>__init__()</code>表示初始化函数。</li></ol><h1>3 变量与常量</h1><h2>3.1 变量的语法结构</h2><p><code>变量名=value</code></p><p>举例：<code>luck_number=8</code> （这里的等号在Python中被称作“赋值运算符”）</p><p><img src="http://blog.leozhn.cn/usr/uploads/2024/07/2085077026.png" alt="内存示意图" title="内存示意图" style=""></p><h3>3.1.1 查看数据信息的函数</h3><p><code>print(type(变量名))</code> 查看数据的类型（整数，浮点数，复数，字符串……）</p><p><code>print(id(变量名))</code> 查看数据的内存地址</p><h3>3.1.2 动态修改变量的数据类型</h3><pre><code class="lang-python"># 演示1：Python动态修改变量的数据类型，通过赋不同类型的值就可以直接修改
variant_a=8
print('variant_a的数据类型是',type(variant_a))
variant_a='北京欢迎您'
print('variant_a的数据类型是',type(variant_a))

# 演示2：在Python中允许多个变量指向同一个值
no=number=1024 # no和number都指向了1024这个整数值
print(id(no))
print(id(number)) # 这个演示说明了no和number的内存地址都相同</code></pre><p>这几行代码的运行效果是：</p><h4><strong>演示1</strong></h4><ol><li><p><code>variant_a</code> 被赋值为整数 8。</p><ul><li><code>print('variant_a的数据类型是', type(variant_a))</code> 输出：variant\_a的数据类型是 \&lt;class 'int'&gt;。这说明 <code>variant_a</code> 的数据类型是整数。</li></ul></li><li><p><code>variant_a</code> 被赋值为字符串 '北京欢迎您'。</p><ul><li><code>print('variant_a的数据类型是', type(variant_a))</code> 输出：variant\_a的数据类型是 \&lt;class 'str'&gt;。这说明 <code>variant_a</code> 的数据类型变成了字符串。</li></ul></li></ol><p>在这个演示中，<code>variant_a</code> 先被赋予整数值，后来又被赋予字符串值，所以它的数据类型从整数变成了字符串。</p><h4><strong>演示2</strong></h4><ul><li><p><code>no</code> 和 <code>number</code> 被同时赋值为整数 1024。</p><ul><li><code>print(id(no))</code> 和 <code>print(id(number))</code> 输出的值相同，这说明 <code>no</code> 和 <code>number</code> 指向了相同的内存地址，即它们都指向了整数值 1024。</li></ul></li></ul><p>在这个演示中，<code>no</code> 和 <code>number</code> 都指向了相同的整数值，这是因为在Python中，对于某个具体的值，多个变量可以指向同一个内存地址。</p><h2>3.2 常量</h2><ul><li>常量就是在程序运行的过程中不允许改变的量（约定俗成）。</li><li>常量全部使用大写字母和下划线命名。</li></ul><h3>3.2.1 示例</h3><pre><code class="lang-python"># 演示：常量和变量的区别
pi=3.1415926 #定义了一个变量
PI=3.1415926 #定义了一个常量</code></pre><p>在演示中：</p><ol><li><code>pi</code> 被定义为一个变量，因为其名字是小写。</li><li><code>PI</code> 被定义为一个常量，因为其名字是全大写。</li></ol><p>实际上，这只是一种约定，Python并不会强制执行常量的概念。你仍然可以改变 <code>PI</code> 的值，但是通常来说，开发者不会在程序中更改被认为是常量的值，以保持代码的清晰性和可读性。</p><h1>4 数值类型</h1><h2>4.1 整数类型（int）</h2><p><img src="http://blog.leozhn.cn/usr/uploads/2024/07/2651550784.png" alt="" title="" style=""></p><p>整数是Python当中的<strong>不可变数据类型</strong>。注意二进制、八进制和十六进制都是有引导符号的，在赋值中如下表示：</p><pre><code class="lang-python"># 演示：不同进制整数的四类引导符
num_decimal=987 # 十进制（decimal）无引导符
num_binary=0b101101 # 二进制（binary）需要在数字前加上0b
num_octal=0o1756 # 八进制（octal）需要在数字前加上0o
num_hexadecimal=0x1f1e33 # 十六进制（hexadecimal）需要在数字前加上0x
print(num_decimal)
print(num_binary)
print(num_octal)
print(num_hexadecimal)
# 使用print()输出的数值均会转换成十进制数</code></pre><h2>4.2 浮点数类型（float）</h2><p><img src="http://blog.leozhn.cn/usr/uploads/2024/07/3903508610.png" alt="" title="" style=""></p><p>浮点型也可以使用科学计数法表示。注意，e在这里不表示自然对数（≈2.718），而表示10的幂指数：</p><pre><code class="lang-python"># 演示：浮点数类型的使用
height=187.6 # 身高
print(height)
print(type(height)) # 查看height变量的数值类型

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

x=1.99E1413 #表示极大数1.99×10^1413
print('科学计数法：',x,'x的数据类型',type(x))
print(0.1+0.2) # 浮点数相加，会导致不确定的尾数问题

print(round(0.1+0.2)) # 使用round()保留两位小数</code></pre><p>注意，浮点数也是Python当中的<strong>不可变数据类型</strong>。</p><h2>4.3 复数类型（complex）</h2><p>Python中的复数与数学中的复数形式完全一致，由实部和虚部组成。</p><p>$$
j=\sqrt{-1}
$$</p><p>在Python中，实数部分使用<code>.real</code>表示，虚数部分使用<code>.imag</code>表示：</p><pre><code class="lang-python"># 演示：复数类型的使用
x=123+456j
print('实数部分',x.real)
print('虚数部分',x.imag)</code></pre><h2>4.4 字符串类型（str|string）</h2><p>字符串类型是连续的字符序列，可以表示计算机所能识别的一切字符，也是<strong>不可变数据类型</strong>。</p><h3>4.4.1 字符串的界定符</h3><p>单引号、双引号、三引号。</p><pre><code class="lang-python"># 演示1：字符串类型的使用
city='通辽'
address=&quot;通辽市科尔沁区霍林河大街1号&quot;
# 一对单引号和一对双引号的效果是一致的
print(city)
print(address)

# 演示2：多行字符串定义
info='''地址：通辽市科尔沁区霍林河大街1号
    收件人：小约翰可汗
    手机号：18600000000
''' 
info2=&quot;&quot;&quot;地址：通辽市科尔沁区霍林河大街1号
    收件人：小约翰可汗
    手机号：18600000000
&quot;&quot;&quot;
# 三个单双引号所得到的结果是一样的
print(info)
print('—'*40)
print(info2)</code></pre><h3>4.4.2 转义字符</h3><p>组成：一个反斜杠 + 字母或符号。</p><p><img src="http://blog.leozhn.cn/usr/uploads/2024/07/1422608143.png" alt="" title="" style=""></p><p>如果在转义字符前加上一个原字符r或R，则转义字符会失去作用。</p><pre><code class="lang-python"># 演示：转义字符的使用
print('北京')
print('欢迎您')
print('————————————')
print('北京\n欢迎您') # 此处的\n表示了换行
print('北\n京\n欢\n迎\n您') # 此处展示了\n可以连续换行
print('北京\t欢迎您') # 此处的\t表示跳到下一制表位，一个制表位包含8B字符（一个英文字母占1B，一个中文字符占2B）
# ‘北京’占用了4B，则在‘北京’和‘欢迎您’之间插入\t，会空出剩余4个制表位，即在‘北京’和‘欢迎您’之间产生4个空格。
print('hello\toooo') # 在'hello'和'oooo'间会产生3个空格
print('老师说：\'好好学习\'') # 使得单引号展示出来的办法，双引号和反斜杠亦然

# 演示2：原字符，使转义字符失效的符号r或R
print(r'北\n京\n欢\n迎\n您')
print(R'北\n京\n欢\n迎\n您')
</code></pre><p>这段代码演示了常见的转义字符，如换行符 <code>\n</code>、制表符 <code>\t</code>、单引号 <code>\'</code> 等的使用。另外，使用原始字符串（以 <code>r</code> 或 <code>R</code> 开头的字符串）可以使转义字符失效，直接按照字面意义解释字符串。</p><h3>4.4.3 索引和切片</h3><h4>4.4.3.1 索引</h4><p>字符串又被称为有序的字符序列，对字符串中某个字符的检索称为索引。</p><p><img src="http://blog.leozhn.cn/usr/uploads/2024/07/3893907252.png" alt="" title="" style=""></p><p>对于字符长度为n的字符串，其正向递增符号从0到n-1，而反向递减序号从-1到-n。</p><h4>4.4.3.2 切片</h4><p>对字符串中某个子串或区间的检索称为切片。</p><p>切片的语法结构：<code>字符串或字符串变量[N:M]</code> ，表示从N开始截到M前一个数为止（<strong>不包含M本身</strong>，也就是<strong>前闭后开</strong>）。</p><p><img src="http://blog.leozhn.cn/usr/uploads/2024/07/3798492106.png" alt="" title="" style=""></p><h4>4.4.3.3 索引和切片的应用</h4><pre><code class="lang-python"># 演示：字符串的索引和切片
s='HELLOWORLD'
print(s[0],s[-10]) # 序号0和序号-10表示的是同一个字符
print('北京欢迎您'[4]) # 获取字符串中索引为4的字符
print('北京欢迎您'[-1]) # 获取字符串中索引为-1的字符
# 以上两个结果都会输出相同的“您”

print(s[2:7]) # 从2开始到7结束，不包含7（正向）
print(s[-8:-3]) # 从-8开始到-3结束，不包含-3（反向）
print(s[:5]) # 默认N从0开始
print(s[5:]) # 默认切片到字符串结尾</code></pre><h3>4.4.4 常见的字符串操作</h3><p><img src="http://blog.leozhn.cn/usr/uploads/2024/07/337759970.png" alt="" title="" style=""></p><pre><code class="lang-python"># 演示：字符串类型的操作
x='2022年'
y='北京冬奥会'
print(x+y) # 连接两个字符串
print(x*10) # 复制10次字符串
print(10*x) # 符合乘法交换律，结果一致

print('北京' in y) # 验证‘北京’是否存在于字符串y，Ture
print('上海' in y) # 验证‘上海’是否存在于字符串y，False
</code></pre><h2>4.5 布尔类型（boolean）</h2><p>用来表示“真”值或“假”值的数据类型。</p><p>在Python中使用标识符<code>True</code>或<code>False</code>表示布尔类型的值。</p><p><code>True</code>表示整数1，<code>False</code>表示整数0。</p><pre><code class="lang-python"># 演示：布尔类型的使用
x=True
print(x)
print(type(x))
print(x+10) # 11 --&gt; 1+10
print(False+10) # 10 --&gt; 0+10</code></pre><h3>4.5.1 测试对象的布尔值</h3><p>在Python中，包括变量、函数、类、模块和其他，一切都是对象。</p><p>对不同对象的布尔值演示如下：</p><pre><code class="lang-python"># 演示：测试对象的布尔值
print(bool(18)) # 测试整数18的布尔值 --&gt; True
print(bool(0)) # 测试整数0和浮点数0.0的布尔值 --&gt; False
print(bool('北京欢迎您')) # 测试字符串布尔值 --&gt; True
print(bool('')) # 测试空字符串布尔值 --&gt; False
print(bool(False)) # 测试保留字False的布尔值 --&gt; False
print(bool(None)) # 测试保留字None的布尔值 --&gt; False</code></pre><h4>4.5.1.1 布尔值为False的情况</h4><ul><li>保留字False和None</li><li>0（包含整数0、小数0.0、虚数0）</li><li>空序列（包含空字符串、空元组、空列表、空字典、空集合）</li><li>判空：自定义对象的实例。该对象的<code>__bool__()</code>方法返回False或<code>__len__()</code>方法返回0</li></ul><h1>5 数据类型之间的转换</h1><h2>5.1 转换类型</h2><h3>5.1.1 隐式转换</h3><p>程序自动进行的转换，无需函数。比如：</p><pre><code class="lang-python">x=True
print(x+10) # 11 --&gt; 1+10 自动转换布尔类型为十进制数</code></pre><p>再比如赋值<code>x=10，y=3，z=x/y</code>，在运算z时就会发生隐式转换，将结果换为一个浮点数。</p><h3>5.1.2 显式转换</h3><p>使用函数进行转换，如下：</p><p><img src="http://blog.leozhn.cn/usr/uploads/2024/07/27843056.png" alt="" title="" style=""></p><pre><code class="lang-python"># 系列：显式转换数据类型的函数
# 演示1：int()函数

# int()函数没有四舍五入，只会取整部分
print(int(-3.14)) # 负浮点数-负整数：-3
print(int(-3.9)) # 负浮点数-负整数：-3
print(int(3.14)) # 正浮点数-正整数：3
print(int(3.9)) # 正浮点数-正整数：3

# int()转换本身内容就是数值类型的字符串为整数，可以运算
print(int('100')+int('200')) # --&gt; 300

# 演示2：float()函数
print(float(10)) # 整数-浮点数：多一位--&gt;10.0

# 演示3：int()和float()转换字符串时会报错的情况
# print(int('18a')) # invalide literal for int() with base 10
# print(int('3.14')) # invalide literal for int() with base 10
# print(float('45a.987') # could not convert string to float: '45a.987'

# 演示4：ord()和chr()
print(ord('杨')) # '杨'在Unicode表中对应的整数值
print(chr('26472')) # 26472在Unicode表中对应的字符

# 演示5：进制转换
print(hex(26472)) # 10 base --&gt; 16 base
print(oct(26472)) # 10 base --&gt; 8 base
print(bin(26472)) # 10 base --&gt; 2 base
# 转换后结果是字符串类型</code></pre><h2>5.2 eval()函数</h2><p><code>eval()</code>也是Python中的一个内置函数，用于去掉字符串最外侧的引号，并按照Python语句方式执行去掉引号后的字符串。</p><p><code>eval()</code>函数经常和<code>input()</code>函数一起使用。</p><h3>5.2.1 语法格式</h3><p><code>x=eval(string)</code>&#x20;</p><h3>5.2.2 演示</h3><p>注意：如果字符串以非数字字符开始，<code>eval()</code> 会尝试找到表达式中的数字部分，并将其解析为数值，而忽略非数字字符。</p><pre><code class="lang-python"># 演示1：eval函数的使用
s='8+6.14'
print(s,type(s)) # 验证s的内容和类型（字符串）

x=eval(s)
print(x,type(x)) # 使用eval去掉s引号，执行加法运算

# 演示2：eval和input的结合使用
# 使用eval转换年龄为整数，相当于int(age)
age=eval(input('请输入您的年龄:'))
print(age,type(age))

# 演示3：eval函数输出字符串
g='北京欢迎您'
print(eval('g')) # 会输出g变量对应的“北京欢迎您”
#print(eval('北京欢迎您')) # NameError
</code></pre><h1>6 运算符</h1><h2>6.1 算术运算符及其优先级</h2><p>算术运算符是用于处理四则运算的符号。</p><p><img src="http://blog.leozhn.cn/usr/uploads/2024/07/1459732943.png" alt="" title="" style=""></p><h3>6.1.1 基本运算（示例）</h3><pre><code class="lang-python"># 演示：算术运算符的使用
print(1+1) # 加法
print(1-1) # 减法
print(2*3) # 乘法
print(10/2) # 除法
print(10//3) # 整除
print(10%3) # 取余
print(2**4) # 幂运算
#print(10/0) # ZeroDivisionError: divison by zero</code></pre><h3>6.1.2 算术运算符的优先级</h3><p>第一级：<code>**</code></p><p>第二级：<code>*</code> <code>/</code> <code>%</code> <code>//</code></p><p>第三级：<code>+</code> <code>-</code>&#x20;</p><h2>6.2 赋值运算符</h2><p>赋值运算符是用于为变量进行赋值操作的运算符。</p><p>在Python中，最基础的赋值符号就是<code>=</code>。</p><p><img src="http://blog.leozhn.cn/usr/uploads/2024/07/1853973317.png" alt="" title="" style=""></p><p>注意，赋值运算的计算顺序是<strong>从右到左</strong>的。它会先计算右侧的结果，右侧结果计算完毕后才会赋值给左侧变量。</p><h3>6.2.1 基本运算（示例）</h3><pre><code class="lang-python"># 演示：赋值运算符的使用
x=20 # 直接赋值20给x
y=10 # 直接赋值10给y
x=x+y # 将x+y的和赋值给x
print(x)

x+=y # 效果和‘x=x+y’一致，再叠加一遍
print(x)

x-=y # 减等于
print(x)

x*=y # 乘等于
print(x)

x/=y # 除等于（浮点）
print(x,type(x)) # 发生了数据类型的隐式转换(int-&gt;float)

x%=2 # 取余赋值给x，相当于x=x%2
print(x)

z=3 # 直接赋值3给z
y//=z # 整除等于
print(y)

y**=2 # 幂运算等于
print(y)

# 链式复制
a=b=c=100 # 相当于a=100 b=100 c=100
print(a,b,c)

# 系列解包赋值
a,b=10,20 # 相当于a=10 b=20
print(a,b)

# 利用系列解包赋值交换两个变量的值
a,b=b,a # 相当于同时执行a=b和b=a
print(a,b)</code></pre><h2>6.3 比较运算符</h2><p>比较运算符用以比较大小和真假，也称为关系运算符。比较的结果只有两种：真或假，分别对应了布尔类型True和False。</p><p><img src="http://blog.leozhn.cn/usr/uploads/2024/07/3194341520.png" alt="" title="" style=""></p><h3>6.3.1 基本运算（示例）</h3><pre><code class="lang-python"> # 演示：比较运算符的使用
 print('98大于90吗',98&gt;90)
 print('98小于90吗',98&lt;90)
 print('98等于90吗',98==90)
 print('98不等于90吗',98!=90)
 print('98大于等于98吗',98&gt;=98)
 print('98小于等于98吗',98&lt;=98)</code></pre><h2>6.4 逻辑运算符</h2><p>逻辑运算符是针对布尔类型值（True和False）的运算，其结果仍然是一个布尔值。</p><p>Python当中存在三种逻辑，分别是与、或和非，对应逻辑运算符为and, or, not。</p><p><img src="http://blog.leozhn.cn/usr/uploads/2024/07/1173193847.png" alt="" title="" style=""></p><p>对它们逻辑的说明如下：</p><p><img src="http://blog.leozhn.cn/usr/uploads/2024/07/225513853.png" alt="" title="" style=""></p><h3>6.4.1 “与”和“或”的短路特性</h3><p>在 Python 中，逻辑运算符 <code>or</code> 和 <code>and</code> 具有短路特性。这意味着如果在 <code>or</code> 运算中第一个表达式为 <code>True</code>，或在 <code>and</code> 运算中第一个表达式为 <code>False</code>，那么不会再继续计算后面的表达式，因为整个表达式已经确定结果。</p><p>例子见下。</p><h3>6.4.2 基本运算（示例）</h3><pre><code class="lang-python"># 演示：逻辑运算符的使用
# 逻辑与'AND'布尔值演示：仅一种情况为True
print(True and True) # --&gt; True
print(True and False)
print(False and True)
print(False and False)

# 逻辑与'AND'表达式演示：短路特性
print(8&gt;7 and 6&gt;5) # --&gt; True
print(8&gt;7 and 6&lt;5) # --&gt; False
print(8&lt;7 and 10/0) # --&gt; False且不执行10/0运算

# 逻辑或'OR'布尔值演示：仅一种情况为False
print(True or True)
print(True or False)
print(False or True)
print(False or False) # --&gt; False

# 逻辑或'OR'表达式演示：短路特性
print(8&gt;7 or 10/0) # --&gt; True且不执行10/0运算

# 逻辑非'NOT'布尔值/表达式演示：
print(not True) # --&gt; False
print(not False) # --&gt; True
print(not (8&gt;7)) # 对True取反 --&gt; False</code></pre><h2>6.5 位运算符（了解）</h2><p>位运算符把数字看作二进制数进行运算。</p><h3>6.5.1 按“位与”运算（&）</h3><p>将二进制数按位对齐，同一数位上，值都为1的，结果为1，否则为0。</p><p>以下实例中，<code>1100(bin)=12(dec)</code>, <code>1000(bin)=8(dec)</code>，因此看作是12和8的按位与运算。</p><p><img src="http://blog.leozhn.cn/usr/uploads/2024/07/416383398.png" alt="" title="" style=""></p><h4>6.5.1.1 按位与运算示例</h4><pre><code class="lang-python"># 演示：按位与运算
print(12&amp;8)</code></pre><h3>6.5.2 按“位或”运算（|）</h3><p>将二进制数按位对齐，同一数位上，值中只要有一个为1的，结果为1；除非两个都为0，结果才为0。</p><p>以下实例中，<code>0100(bin)=4(dec)</code>, <code>1000(bin)=8(dec)</code>，因此看作是4和8的按位与运算。</p><p><img src="http://blog.leozhn.cn/usr/uploads/2024/07/3511651530.png" alt="" title="" style=""></p><h4>6.5.2.1 按位或运算示例</h4><pre><code class="lang-python"># 演示：按位或运算
print(4|8)</code></pre><h3>6.5.3 按“位异或”运算（^）</h3><p>将二进制数按位对齐，同一数位上，两个数位不相等，结果为1；两个数位相等，结果为0。</p><p>以下实例中，<code>1111(bin)=4(dec)</code>, <code>0110(bin)=6(dec)</code>，因此看作是4和8的按位异或运算。</p><p><img src="http://blog.leozhn.cn/usr/uploads/2024/07/1351156069.png" alt="" title="" style=""></p><h4>6.5.3.1 按位异或运算示例</h4><pre><code class="lang-python"># 演示：按位异或运算
print(31^22)</code></pre><h3>6.5.4 按“位取反”运算（\~）</h3><p>按位取反的操作数只有一个，它会将这个操作数的所有数位取反。</p><p><img src="http://blog.leozhn.cn/usr/uploads/2024/07/2038316075.png" alt="image_TNe3FNGGp-.png" title="image_TNe3FNGGp-.png" style=""></p><h4>6.5.4.1 按位取反运算示例</h4><pre><code class="lang-python"># 演示：按位取反运算
print(123~)</code></pre><h3>6.5.5 左移位运算和右移位运算</h3><p>“左移位”运算（&lt;&lt;）是将一个二进制数向左移动指定的位数，高位端溢出的位被丢弃，低位端的空位补0。</p><p><img src="http://blog.leozhn.cn/usr/uploads/2024/07/1112242139.png" alt="" title="" style=""></p><p>“右移位”运算（&gt;&gt;）则恰恰相反，是将一个二进制数向右移动指定的位数，低位端溢出的位被丢弃，而高位端的空位按照原数的正负补0（正）或1（负）。</p><p><img src="http://blog.leozhn.cn/usr/uploads/2024/07/1951665854.png" alt="" title="" style=""></p><pre><code class="lang-python"># 演示：左移位和右移位运算
print(2&lt;&lt;2) # --&gt; 0000 0010 - 0000 1000  --&gt; 2*(2*2)=8
print(2&lt;&lt;3) # --&gt; 0000 0010 - 0001 0000  --&gt; 2*(2*2*2)=16

print(8&gt;&gt;2) # --&gt; 0000 1000 - 0000 0010  --&gt; 8//(2*2)=2
print(-8&gt;&gt;2) # --&gt; 1111 0101 - 1111 1101 --&gt; -8//(2*2)=-2</code></pre><h4>6.5.5.1 补充：二进制取相反数——补码</h4><ol><li>将原数全部取反：<code>0000 1011 —&gt; 1111 0100</code>&#x20;</li><li>加一得到正确结果：<code>1111 0100 —&gt; 1111 0101</code>&#x20;</li></ol><h2>6.6 所有运算符的优先级</h2><ol><li>括号（<code>()</code>）</li><li>幂运算（<code>**</code>）</li><li>取反（<code>~</code>）、正号和负号（<code>+</code> <code>-</code>）</li><li>算术运算符：乘、浮点除、取余、整除（<code>*</code> <code>/</code> <code>%</code> <code>//</code>）</li><li>算术运算符：加和减（<code>+</code> <code>-</code>）</li><li>左移位（<code>&lt;&lt;</code>）和右移位（<code>&gt;&gt;</code>）</li><li>按位与（<code>&amp;</code>）</li><li>按位异或（<code>^</code>）</li><li>按位或（<code>|</code>）</li><li>比较运算符：大于、大于等于、小于、小于等于、不等于、等于（<code>&gt;</code> <code>&gt;=</code> <code>&lt;</code> <code>&lt;=</code> <code>!=</code> <code>==</code> ）</li><li>赋值运算符（<code>=</code>）</li></ol><h1>7 课后实践题</h1><p><strong>题目1：</strong>从键盘获取一个4位整数，分别输出个位、十位、百位、千位上的数字。</p><p><strong>提示：</strong>可以使用取余、取整等公式进行操作。</p><p><strong>题目2：</strong>从键盘输入父母的身高，并预测儿子的身高。计算公式：儿子身高=（父亲身高+母亲身高）*0.54</p><pre><code class="lang-python"># 题目1：从键盘获取一个4位整数，分别输出个位、十位、百位、千位上的数字。
# 自己的答案
x=input('请输入一个四位整数:')
x=eval(x)
a=x%10
b=x%100//10
c=x%1000//100
d=x//1000
print('个位上的数字为',a)
print('十位上的数字为',b)
print('百位上的数字为',c)
print('千位上的数字为',d)

# 标准答案1：使用eval % 和 //
num=eval(input('请输入一个四位整数：'))
print('个位上的数字为：',num%10)
print('十位上的数字为：',num//10%10)
print('百位上的数字为：',num//100%10)
print('千位上的数字为：',num//1000)

# 标准答案2：直接使用索引
num=input('请输入一个四位整数：')
print('个位上的数字为：',num[3])
print('十位上的数字为：',num[2])
print('百位上的数字为：',num[1])
print('千位上的数字为：',num[0])

# 题目2：从键盘输入父母的身高，并预测儿子的身高。计算公式：儿子身高=（父亲身高+母亲身高）*0.54
# 自己的答案
dad=eval(input('请输入爸爸的身高：'))
mom=eval(input('请输入妈妈的身高：'))
print('预测儿子的身高为：',(dad+mom)*0.54)

# 标准答案
fh=eval(input('请输入爸爸的身高：'))
mh=eval(input('请输入妈妈的身高：'))
sh=(fh+mh)*0.54
print('预测儿子的身高为：',sh)</code></pre>

Python(2)：数据类型和运算符

1 保留字

2 标识符

2.1 作用

2.2 命名规则（必须遵守）

2.3 命名规范（建议遵守）

3 变量与常量

3.1 变量的语法结构

3.1.1 查看数据信息的函数

3.1.2 动态修改变量的数据类型

演示1

演示2

3.2 常量

3.2.1 示例

4 数值类型

4.1 整数类型（int）

4.2 浮点数类型（float）

4.3 复数类型（complex）

4.4 字符串类型（str|string）

4.4.1 字符串的界定符

4.4.2 转义字符

4.4.3 索引和切片

4.4.3.1 索引

4.4.3.2 切片

4.4.3.3 索引和切片的应用

4.4.4 常见的字符串操作

4.5 布尔类型（boolean）

4.5.1 测试对象的布尔值

4.5.1.1 布尔值为False的情况

5 数据类型之间的转换

5.1 转换类型

5.1.1 隐式转换

5.1.2 显式转换

5.2 eval()函数

5.2.1 语法格式

5.2.2 演示

6 运算符

6.1 算术运算符及其优先级

6.1.1 基本运算（示例）

6.1.2 算术运算符的优先级

6.2 赋值运算符

6.2.1 基本运算（示例）

6.3 比较运算符

6.3.1 基本运算（示例）

6.4 逻辑运算符

6.4.1 “与”和“或”的短路特性

6.4.2 基本运算（示例）

6.5 位运算符（了解）

6.5.1 按“位与”运算（&）

6.5.1.1 按位与运算示例

6.5.2 按“位或”运算（|）

6.5.2.1 按位或运算示例

6.5.3 按“位异或”运算（^）

6.5.3.1 按位异或运算示例

6.5.4 按“位取反”运算（\~）

6.5.4.1 按位取反运算示例

6.5.5 左移位运算和右移位运算

6.5.5.1 补充：二进制取相反数——补码

6.6 所有运算符的优先级

7 课后实践题

发表评论 取消回复 本站使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款。支持Emoji评论。

【Python基础教程·第二辑】数据类型和运算符

发表评论取消回复
本站使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款。支持Emoji评论。