【python实战之】数据类型（data type）-含代码及详细讲解

整数类型

print('# 整数类型 integer-int-可表示正数、负数、零')
print('# 整数可表示为十进制、十六进制、八进制、二进制，默认十进制')
n1=90
n2=-76
n3=0
print(n1,type(n1))
print(n2,type(n2))
print(n3,type(n3))

print('十进制',118)
print('二进制',0b10101111)
print('八进制',0o176)
print('十六进制',0x1EAF)
print('十六进制',0X1EAF)  #不区分大小写

代码解释：

代码的解释如下：

1. `n1 = 90`
   - 这是一个赋值语句，将整数值 90 赋给变量 `n1`。
   - 变量 `n1` 存储了整数值 90。

2. `n2 = -76`
   - 这是一个赋值语句，将整数值 -76 赋给变量 `n2`。
   - 变量 `n2` 存储了整数值 -76。

3. `n3 = 0`
   - 这是一个赋值语句，将整数值 0 赋给变量 `n3`。
   - 变量 `n3` 存储了整数值 0。

4. `print(n1, type(n1))`
   - 这一行代码使用 `print()` 函数将变量 `n1` 的值和类型打印到控制台。
   - 输出结果是 `90 <class 'int'>`，表示变量 `n1` 的值是 90，类型是整数类型。

5. `print(n2, type(n2))`
   - 这一行代码使用 `print()` 函数将变量 `n2` 的值和类型打印到控制台。
   - 输出结果是 `-76 <class 'int'>`，表示变量 `n2` 的值是 -76，类型是整数类型。

6. `print(n3, type(n3))`
   - 这一行代码使用 `print()` 函数将变量 `n3` 的值和类型打印到控制台。
   - 输出结果是 `0 <class 'int'>`，表示变量 `n3` 的值是 0，类型是整数类型。

7. `print('十进制', 118)`
   - 这一行代码使用 `print()` 函数将字符串 `'十进制'` 和整数值 118 打印到控制台。
   - 输出结果是 `十进制 118`。

8. `print('二进制', 0b10101111)`
   - 这一行代码使用 `print()` 函数将字符串 `'二进制'` 和二进制数值 0b10101111 打印到控制台。
   - 输出结果是 `二进制 175`。
   - 在 Python 中，前缀为 `0b` 的数值表示二进制数。

9. `print('八进制', 0o176)`
   - 这一行代码使用 `print()` 函数将字符串 `'八进制'` 和八进制数值 0o176 打印到控制台。
   - 输出结果是 `八进制 126`。
   - 在 Python 中，前缀为 `0o` 的数值表示八进制数。

10. `print('十六进制', 0x1EAF)`
    - 这一行代码使用 `print()` 函数将字符串 `'十六进制'` 和十六进制数值 0x1EAF 打印到控制台。
    - 输出结果是 `十六进制 7855`。
    - 在 Python 中，前缀为 `0x` 的数值表示十六进制数。

11. `print('十六进制', 0X1EAF)`
    - 这一行代码使用 `print()` 函数将字符串 `'十六进制'` 和十六进制数值 0X1EAF 打印到控制台。
    - 输出结果是 `十六进制 7855`。
    - 在 Python 中，`0x` 和 `0X` 前缀都可以用来表示十六进制数。

浮点类型

print('************************************************')
print('# 浮点类型  使用浮点数计算时，可能出现小数位数不确定情况')
print('# 解决方案  导入模块decimal')
a=3.14159
print(a,type(a))

n1=1.1
n2=2.2
print(n1+n2)
from decimal import Decimal
print(Decimal('1.1')+Decimal('2.2'))

代码解释：

代码的解释如下：

1. `a = 3.14159`
   - 这是一个赋值语句，将浮点数值 3.14159 赋给变量 `a`。
   - 变量 `a` 存储了浮点数值 3.14159。

2. `print(a, type(a))`
   - 这一行代码使用 `print()` 函数将变量 `a` 的值和类型打印到控制台。
   - 输出结果是 `3.14159 <class 'float'>`，表示变量 `a` 的值是 3.14159，类型是浮点数类型。

3. `n1 = 1.1`
   - 这是一个赋值语句，将浮点数值 1.1 赋给变量 `n1`。
   - 变量 `n1` 存储了浮点数值 1.1。

4. `n2 = 2.2`
   - 这是一个赋值语句，将浮点数值 2.2 赋给变量 `n2`。
   - 变量 `n2` 存储了浮点数值 2.2。

5. `print(n1 + n2)`
   - 这一行代码使用 `print()` 函数将变量 `n1` 和 `n2` 的和打印到控制台。
   - 输出结果是 `3.3000000000000003`，这是因为在计算机中浮点数的精度有限，可能会导致小数计算时出现舍入误差。

6. `from decimal import Decimal`
   - 这一行代码导入了 Python 标准库中的 `Decimal` 类。

7. `print(Decimal('1.1') + Decimal('2.2'))`
   - 这一行代码使用 `Decimal` 类对字符串表示的 1.1 和 2.2 进行精确计算，并将结果打印到控制台。
   - 输出结果是 `3.3`，使用 `Decimal` 类可以避免浮点数舍入误差，得到更精确的计算结果。

布尔类型

print('************************************************')
print('# 布尔类型     boolean-bool   布尔值可转化为整数')
f1=True
f2=False
print(f1,type(f1))
print(f2,type(f2))
print(f1+1)
print(f2+1)

代码解释：

代码的解释如下：

1. `f1 = True`
   - 这是一个赋值语句，将布尔值 `True` 赋给变量 `f1`。
   - 变量 `f1` 存储了布尔值 `True`。

2. `f2 = False`
   - 这是一个赋值语句，将布尔值 `False` 赋给变量 `f2`。
   - 变量 `f2` 存储了布尔值 `False`。

3. `print(f1, type(f1))`
   - 这一行代码使用 `print()` 函数将变量 `f1` 的值和类型打印到控制台。
   - 输出结果是 `True <class 'bool'>`，表示变量 `f1` 的值是 `True`，类型是布尔类型。

4. `print(f2, type(f2))`
   - 这一行代码使用 `print()` 函数将变量 `f2` 的值和类型打印到控制台。
   - 输出结果是 `False <class 'bool'>`，表示变量 `f2` 的值是 `False`，类型是布尔类型。

5. `print(f1 + 1)`
   - 这一行代码将变量 `f1` 的值与整数值 1 相加，并使用 `print()` 函数打印结果到控制台。
   - 输出结果是 `2`。在 Python 中，布尔值 `True` 可以被视为整数值 1 进行运算。

6. `print(f2 + 1)`
   - 这一行代码将变量 `f2` 的值与整数值 1 相加，并使用 `print()` 函数打印结果到控制台。
   - 输出结果是 `1`。在 Python 中，布尔值 `False` 可以被视为整数值 0 进行运算。

字符串类型

print('************************************************')
print('# 字符串类型')
str1='人生苦短，我用Python'
print(str1,type(str1))
str2="人生苦短，我用Python"
print(str2,type(str2))
str3='''人生苦短，
        我用Python'''
print(str3,type(str3))
str4="""人生苦短，
        我用Python"""
print(str4,type(str4))

代码解释：

代码的解释如下：

1. `str1 = '人生苦短，我用Python'`
   - 这是一个赋值语句，将字符串 `'人生苦短，我用Python'` 赋给变量 `str1`。
   - 变量 `str1` 存储了这个字符串。

2. `print(str1, type(str1))`
   - 这一行代码使用 `print()` 函数将变量 `str1` 的值和类型打印到控制台。
   - 输出结果是 `'人生苦短，我用Python' <class 'str'>`，表示变量 `str1` 的值是 `'人生苦短，我用Python'`，类型是字符串类型。

3. `str2 = "人生苦短，我用Python"`
   - 这是一个赋值语句，将字符串 `"人生苦短，我用Python"` 赋给变量 `str2`。
   - 变量 `str2` 存储了这个字符串。

4. `print(str2, type(str2))`
   - 这一行代码使用 `print()` 函数将变量 `str2` 的值和类型打印到控制台。
   - 输出结果是 `"人生苦短，我用Python" <class 'str'>`，表示变量 `str2` 的值是 `"人生苦短，我用Python"`，类型是字符串类型。

5. `str3 = '''人生苦短，
        我用Python'''`
   - 这是一个赋值语句，将多行字符串赋给变量 `str3`。
   - 变量 `str3` 存储了包含换行的字符串。

6. `print(str3, type(str3))`
   - 这一行代码使用 `print()` 函数将变量 `str3` 的值和类型打印到控制台。
   - 输出结果是：
     ```
     人生苦短，
            我用Python
     <class 'str'>
     ```
     表示变量 `str3` 的值是包含换行的字符串，类型是字符串类型。

7. `str4 = """人生苦短，
        我用Python"""`
   - 这是一个赋值语句，将多行字符串赋给变量 `str4`。
   - 变量 `str4` 存储了包含换行的字符串。

8. `print(str4, type(str4))`
   - 这一行代码使用 `print()` 函数将变量 `str4` 的值和类型打印到控制台。
   - 输出结果和上一行相同：
     ```
     人生苦短，
            我用Python
     <class 'str'>
     ```
     表示变量 `str4` 的值是包含换行的字符串，类型是字符串类型。
     
这些代码演示了在 Python 中创建字符串的几种方式。单引号、双引号和三引号（三个连续的单引号或双引号）都可以用来定义字符串。三引号的字符串可以跨越多行，并保留字符串中的空格和换行符。