代码收藏家技术教程 2024-11-10

Python的使用技巧：四种数据类型的转换与七种运算符的介绍

一. 数据类型转换

1.1 转换为整型

1.1.1 字符串转为整型

1.1.2 浮点型转为整型

1.1.3 布尔型转为整型

1.2 转换为浮点型

1.2.1 字符串转浮点型

1.2.2 整型转为浮点型

1.2.3 布尔型转浮点型

1.3 转为布尔类型

1.3.1 字符串转布尔型

1.3.2 整型转为布尔型

1.3.3 浮点转为布尔型

1.4 转字符串类型

1.4.1 整型转为字符串

1.4.2 浮点型转字符串

1.4.3 布尔型转字符串

二. 七种运算符的介绍

2.1 算数运算符

2.2 赋值运算符

2.3 比较（关系）运算符

2.4 逻辑运算符

2.5 成员运算符

2.6 所有运算符的优先级顺序

一. 数据类型转换

整型，浮点型，字符串型，布尔类型相互转换。

1.1 转换为整型

字符串类型，浮点类型，布尔类型转换为整型。

1.1.1 字符串转为整型

纯数字字符串可以被转换为整型。

字符串内有小数点也会报错。

字符串内有其他字母转为整型的时候也会报错。

# 类型转为 int 型

# 字符串转为 int 型
# 字符串内纯整数情况
str1 = "2024"
num1 = int(str1)
print(str1,num1)
print("str1 的数据类型:%s,num1 的数据类型:%s" % (type(str1),type(num1)))

# 字符串内有小数点
# str2 = "2024.10"
# num2 = int(str2)    # 这一行就会报错
# print(str2,num2)
# print("str2 的数据类型:%s,num2 的数据类型:%s" % (type(str2),type(num2)))

# 字符串内有其他字母
# str3 = "2024asd"
# num3 = int(str3)  # 这一行就会报错
# print(str3,num3)
# print("str3 的数据类型:%s,num3 的数据类型:%s" % (type(str3),type(num3)))

"""
运行结果:
2024 2024
str1 的数据类型:<class 'str'>,num1 的数据类型:<class 'int'>

下面的两个报错
"""

1.1.2 浮点型转为整型

浮点型都是可以转成整型的。

浮点类型转为整型，都是向趋于零的整数靠近，不遵循四舍五入。

# 类型转为 int 型

# 浮点型转为整型
num_float = 12.3
num_float1 = 12.7
num_float2 = -0.1
num_float3 = -1.1

num_int = int(num_float)
num_int1 = int(num_float1)
num_int2 = int(num_float2)
num_int3 = int(num_float3)

print("num_float 的数据类型为 %s, 转化为整型为:%d,num_int 的数据类型是 %s" % (type(num_float), num_int, type(num_int)))
print("num_float1 的数据类型为 %s, 转化为整型为:%d,num_int1 的数据类型是 %s" % (type(num_float1), num_int1, type(num_int1)))
print("num_float2 的数据类型为 %s, 转化为整型为:%d,num_int2 的数据类型是 %s" % (type(num_float2), num_int2, type(num_int2)))
print(num_int3)
"""
运行结果:
num_float 的数据类型为 <class 'float'>, 转化为整型为:12,num_int 的数据类型是 <class 'int'>
num_float1 的数据类型为 <class 'float'>, 转化为整型为:12,num_int1 的数据类型是 <class 'int'>
num_float2 的数据类型为 <class 'float'>, 转化为整型为:0,num_int2 的数据类型是 <class 'int'>
-1
"""

1.1.3 布尔型转为整型

布尔类型为真（True）转为整型都为 1。

布尔类型为真（False）转为整型都为 0.

# 类型转为 int 型

# 布尔型转为整型
bool1 = True
bool2 = False

num1 = int(bool1)
num2 = int(bool2)

print("bool1 的数据类型为 %s, 转化为整型为:%d,num1 的数据类型是 %s" % (type(bool1), num1, type(bool1)))
print("bool2 的数据类型为 %s, 转化为整型为:%d,num2 的数据类型是 %s" % (type(bool2), num2, type(bool2)))

"""
运行结果:
bool1 的数据类型为 <class 'bool'>, 转化为整型为:1,num1 的数据类型是 <class 'bool'>
bool2 的数据类型为 <class 'bool'>, 转化为整型为:0,num2 的数据类型是 <class 'bool'>

"""

1.2 转换为浮点型

字符串类型，整型，布尔类型转换为浮点类型。

1.2.1 字符串转浮点型

字符串有两个及两个以上的逗号的时候不能转为浮点型。

字符串有字母的时候不能转为浮点型。

# 类型转为浮点型

# 字符串转为浮点型
str0 = "2024"
str1 = "2024.10"
str2 = "2024.10.12"
str3 = "2024asd"

float0 = float(str0)
float1 = float(str1)
# float2 = float(str2) #运行会报错
# float3 = float(str3)  #运行会报错

print("str0 的数据类型为 %s, 转化为整型为:%f,float0 的数据类型是 %s" % (type(str), float0, type(float0)))
print("str1 的数据类型为 %s, 转化为整型为:%f,float1 的数据类型是 %s" % (type(str1), float1, type(float1)))

"""
运行结果:
str0 的数据类型为 <class 'type'>, 转化为浮点为:2024.000000,float0 的数据类型是 <class 'float'>
str1 的数据类型为 <class 'str'>, 转化为浮点为:2024.100000,float1 的数据类型是 <class 'float'>
"""

1.2.2 整型转为浮点型

整型都可以直接转为浮点类型。

# 类型转为浮点型

# 整型转为浮点型
int1 = 2024
int2 = 0
int3 = -2024

float0 = float(int1)
float1 = float(int2)
float2 = float(int3)


print("int1 的数据类型为 %s, 转化为整型为:%f,float0 的数据类型是 %s" % (type(int1), float0, type(float0)))
print("int2 的数据类型为 %s, 转化为整型为:%f,float1 的数据类型是 %s" % (type(int2), float1, type(float1)))
print("int3 的数据类型为 %s, 转化为整型为:%f,float2 的数据类型是 %s" % (type(int3), float2, type(float2)))

"""
运行结果:
int1 的数据类型为 <class 'int'>, 转化为整型为:2024.000000,float0 的数据类型是 <class 'float'>
int2 的数据类型为 <class 'int'>, 转化为整型为:0.000000,float1 的数据类型是 <class 'float'>
int3 的数据类型为 <class 'int'>, 转化为整型为:-2024.000000,float2 的数据类型是 <class 'float'>
"""

1.2.3 布尔型转浮点型

布尔类型也可以完全转为浮点类型。

# 类型转为浮点型

# 布尔转为浮点型
bool1 = True
bool2 = False

float0 = float(True)
float1 = float(False)

print("bool1 的数据类型为 %s, 转化为整型为:%f,float0 的数据类型是 %s" % (type(bool1), float0, type(float0)))
print("bool2 的数据类型为 %s, 转化为整型为:%f,float1 的数据类型是 %s" % (type(bool2), float1, type(float1)))

"""
运行结果:
bool1 的数据类型为 <class 'bool'>, 转化为整型为:1.000000,float0 的数据类型是 <class 'float'>
bool2 的数据类型为 <class 'bool'>, 转化为整型为:0.000000,float1 的数据类型是 <class 'float'>
"""

1.3 转为布尔类型

字符串类型，整型，浮点类型转换为布尔类型。

这三种类型在任何情况下都可以转为布尔类型。

1.3.1 字符串转布尔型

字符串不为空布尔类型就可以转为 True。

字符串为空布尔类型就可以转为 False。

# 类型转为布尔型

# 字符串转为布尔型
# 有内容切内容不为空的字符串
str1 = "hello"

# 有内容内容为空的字符串
str2 = "    "

# 内容为空的字符串
str3 = ""

bool1 = bool(str1)
bool2 = bool(str2)
bool3 = bool(str3)

print(bool1)
print(bool2)
print(bool3)
"""
运行结果:
True
True
False
"""

1.3.2 整型转为布尔型

整数只有为 0 的时候，布尔型才是 False。

其他情况都为 True。

# 类型转为布尔型

# 整型转为布尔型
int1 = 1
int2 = -1
int3 = 0

bool1 = bool(int1)
bool2 = bool(int2)
bool3 = bool(int3)

print(bool1)
print(bool2)
print(bool3)
"""
运行结果:
True
True
False
"""

1.3.3 浮点转为布尔型

浮点只有为 0.0 的时候，布尔型才是 False。

其他情况都为 True。

# 类型转为布尔型

# 整型转为布尔型
float1 = 1.0
float2 = -1.0
float3 = 0.0

bool1 = bool(float1)
bool2 = bool(float2)
bool3 = bool(float3)

print(bool1)
print(bool2)
print(bool3)
"""
运行结果:
True
True
False
"""

1.4 转字符串类型

布尔类型，整型，浮点类型转换为字符串类型。

这三种类型在任何情况下都可以转为字符串类型。

1.4.1 整型转为字符串

# 类型转为字符型

# 整型转为字符型
int1 = 1
str1 = str(int1)
print(str1,type(str1))
"""
运行结果:
1 <class 'str'>
"""

1.4.2 浮点型转字符串

# 类型转为字符型

# 浮点型转为字符型
float1 = 2024.0
str1 = str(float1)
print(str1,type(str1))
"""
运行结果:
2024.0 <class 'str'>
"""

1.4.3 布尔型转字符串

布尔类型转为字符串之后，Ture 字符串再变化为布尔类型的时候为真， False 字符串再变化为布尔类型的时候也为真。

# 类型转为字符型

# 布尔转为字符型
bool1 = True
bool2 = False

str1 = str(bool1)
str2 = str(bool2)

print(str1,type(str1))
print(str2,type(str2))
"""
运行结果:
True <class 'str'>
False <class 'str'>
"""

二. 七种运算符的介绍

由两个运算符组成的符号是不能分开写的，会报错。

只介绍五种，位运算符和身份运算符用的比较少。

七种运算符的介绍
类型	内容
算数运算符	+，-，，/，//，%，*
赋值运算符	=，+=，-=，*=，/=，//=，%=
位运算符	`, &, ~, <<, >>, ^
关系运算符（比较运算符）	==，！=， <, >,<=, >=
逻辑运算符	and，or，not
成员运算符	in，not in
身份运算符	is

2.1 算数运算符

**七种算数运算符的介绍**
运算符	描述
+	加法
–	减法
*	乘法
/	除法（保留小数）
//	除法（不保留小数）
%	取余数
**	平方，又被称为幂

**算数运算符的优先级**
运算符	描述
**	幂的优先级最高
*，/，%，//	优先级第二
+，-	优先级最低

代码解释：

# 算数运算符
sum1 = 10
sum2 = 3

# 加法
print("加法:",sum1 + sum2)

# 减法
print("减法:",sum1 - sum2)

# 乘法
print("乘法:",sum1 * sum2)

# 除法保留小数
print("除法保留小数:",sum1 / sum2)

# 除法不保留小数
print("除法不保留小数:", sum1 // sum2)

# 求余数
print("求余数:", sum1 % sum2)

# 二次方
print("sum1 的sum2 次方:", sum1 ** sum2)

"""
运行结果:
加法: 13
减法: 7
乘法: 30
除法保留小数: 3.3333333333333335
除法不保留小数: 3
求余数: 1
sum1 的sum2 次方: 1000

"""

2.2 赋值运算符

赋值运算符的符号是不能拆开写的。

赋值运算符类似于算数运算符的简写。

**八种赋值运算符的介绍**
运算符	描述	实例子
=	赋值运算符	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

简单介绍自增自减。

自增：

# 赋值运算符
sum1 = 10
sum2 = 3

# 自增
sum1 += sum2
print("自增:",sum1)

"""
运行结果:
自增: 13

"""

自减：

# 赋值运算符
sum1 = 10
sum2 = 3

# 自减
sum1 -= sum2
print("自减:",sum1)

"""
运行结果:
自减: 13

"""

2.3 比较（关系）运算符

整型和浮点型可以直接比较。

字符串和布尔值也可以通过比较（关系）运算符进行比较。有兴趣的可以试一下。

**六种比较运算符的介绍**
运算符	描述	结果
==	等于	判定成功，显示为 True，否则为 False
!=	不等于
>	大于
<	小于
>=	大于等于
<=	小于等于

代码解释：

# 比较运算符
sum1 = 1
sum2 = 2

print("sum1 等于 sum2为",sum1 == sum2)
print("sum1 不等于 sum2为",sum1 != sum2)
print("sum1 大等于 sum2为",sum1 >= sum2)
print("sum1 小等于 sum2为",sum1 <= sum2)
print("sum1 大于 sum2为",sum1 > sum2)
print("sum1 小于 sum2为",sum1 < sum2)

"""
运行结果:
sum1 等于 sum2为 False
sum1 不等于 sum2为 True
sum1 大等于 sum2为 False
sum1 小等于 sum2为 True
sum1 大于 sum2为 False
sum1 小于 sum2为 True

"""

2.4 逻辑运算符

逻辑运算符and，or，not 相当于数学上的与或非。

下表中的x 和y 可以是运算公式，也可以是整型，浮点型，布尔型，字符串等内容。

**逻辑运算符**
运算符	逻辑表达式	描述
and	x and y	x 和y 只要有一个为假的，那么都会为假的，两个都是真才是真
or	x or y	x 和y 只要有一个为真的，那么都会为真的，两个都是假才是假
not	not x	x 原来为真，现在为假。x 原来为假，现在为真。

优先级排序：

not > and >or

2.5 成员运算符

**成员运算符解释**
运算符	解释
in	x in（a,v,x）。当x 在一个字符串或者元组等集合区域存在的时候，为真。
not in	x in（a,v,x）。当x 在一个字符串或者元组等集合区域不存在的时候，为真。