Python基础语法：基本数据类型（数字类型和布尔类型）

在我们的日常生活中，经常会用到数字，所以数字（numbers）是 pytthon 中的一个基本数据类型。在 python 里面啊，numbers 这种数据类型是一个大类，在 numbers 这个大类下面有整型、浮点型（小数）、复数等子类。

1  整形（int）与浮点型（float）

1.1  整型（int）

整型是Python中一种基本的数据类型，用于表示正整数和负整数。在Python中，整型没有固定的上限或下限，它的大小取决于可用内存和系统的架构。

1.1.1  整型的特点

• 无限制大小：Python的整型可以是任意大的（或者小），只受限于计算机的内存和系统的架构。

• 没有专门的符号：不像其他一些编程语言，Python中的整数不需要使用特殊的符号或前缀来表示正数或负数。

• 支持运算：整型变量可以参与数学运算，如加法、减法、乘法、除法和取模等。

• 类型推断：当你给变量赋值时，Python会根据你赋的值自动推断变量的类型。

  1.1.2  创建整型变量

  在Python中，创建整型变量非常简单，只需要给变量赋一个整数值即可。

  # 创建整型变量  
  my_integer = 10  
  print(my_integer, type(my_integer))  # 输出: 10 

  1.1.3  整型运算

  整型变量可以进行各种数学运算。

  a = 10  
  b = 5  
    
  # 加法  
  add_result = a + b  
  print(add_result)  # 输出: 15  
    
  # 减法  
  subtract_result = a - b  
  print(subtract_result)  # 输出: 5  
    
  # 乘法  
  multiply_result = a * b  
  print(multiply_result)  # 输出: 50  
    
  # 除法  
  divide_result = a / b  
  print(divide_result)  # 输出: 2.0  
    
  # 取模（求余数）  
  modulus_result = a % b  
  print(modulus_result)  # 输出: 0  
    
  # 幂运算（需要使用 ** 运算符）  
  power_result = a ** b  
  print(power_result)  # 输出: 100000

  1.1.4  类型转换

  整型可以与其他数据类型进行转换，通常使用内置的int()函数来将其他数据类型转换为整型。 

  # 将浮点数转换为整型（会截断小数部分）  
  float_number = 3.14  
  int_number = int(float_number)  
  print(int_number)  # 输出: 3  
    
  # 将整数字符串转换为整型（字符串必须包含有效的整数值）  
  str_number = "123"  
  int_from_str = int(str_number)  
  print(int_from_str)  # 输出: 123  
    
  

  注意：如果尝试将非整数字符串转换为整型会引发ValueError异常。

  non_int_str = "abc"
  print(int(non_int_str))
  # 报错：ValueError: invalid literal for int() with base 10: 'abc'

  整型在Python编程中非常常见，因为它们可以用来表示计数、索引、大小、年龄等概念。同时，由于Python的动态类型特性，整型变量也可以随时与其他类型进行转换和运算。

  1.2  浮点型（float）

  浮点型是Python中用于表示实数的数据类型，包括整数部分和小数部分。浮点数的精度是有限的，因此在处理浮点数时可能会遇到精度问题。Python中的浮点数通常以双精度形式存储，这意味着它们可以存储非常大或非常小的数，以及小数点后很多位的数。

  在很多其他的语言里面，浮点数（也就是数学里的小数）还有进一步的细分，分单精度和双精度。精度越高能表示的数值就越准确，在其他很多的语言里单精度用 float 来表示，双精度用 double 来表示。双精度表示的精度要比单精要更高一些。

  在 python 里面没有单精度和双精度之分，python 浮点数的数据类型只有 float，因为 python 里面的 float 支持的精度就是其他语言里面所谓的双精度。

  1.2.1  浮点型的特点

  • 近似表示：浮点数在计算机中是以近似值的形式表示的，因此它们可能无法精确表示某些小数。

  • 精度限制：虽然Python的浮点数可以表示非常大或非常小的数，但它们的精度是有限的。对于需要高精度计算的场景，可能需要使用专门的库，如decimal。

  • 运算支持：浮点数支持各种数学运算，如加法、减法、乘法、除法等。

    1.2.2  创建浮点型变量

    在Python中，创建浮点型变量非常简单，只需要给变量赋一个浮点数值即可。

    # 创建浮点型变量  
    my_float = 3.14  
    print(my_float, type(my_float))  # 输出: 3.14 

    1.2.3  浮点型运算

    浮点型变量同样可以进行各种数学运算。

    a = 3.14  
    b = 2.71  
      
    # 加法  
    add_result = a + b  
    print(add_result)  # 输出: 5.85  
      
    # 减法  
    subtract_result = a - b  
    print(subtract_result)  # 输出: 0.43  
      
    # 乘法  
    multiply_result = a * b  
    print(multiply_result)  # 输出: 8.5054  
      
    # 除法  
    divide_result = a / b  
    print(divide_result)  # 输出: 1.1586676646706588

    1.2.4  浮点型的精度问题

    由于浮点数的近似表示，进行浮点运算时可能会遇到精度问题。例如，两个看似相等的浮点数可能在比较时并不相等。

    x = 0.1 + 0.2
    y = 0.3
    print(x == y)  # 输出: False

    在上面的例子中，尽管x和y看起来应该相等（都是0.3），但由于浮点数的精度问题，它们并不完全相等。

    1.2.5  类型转换

    整型可以转换为浮点型，反之亦然。通常使用内置的float()函数将其他数据类型转换为浮点型，使用int()函数将浮点型转换为整型（会截断小数部分）。

    # 将整型转换为浮点型  
    int_number = 3  
    float_number = float(int_number)  
    print(float_number)  # 输出: 3.0  
      
    # 将浮点型转换为整型（会截断小数部分）  
    float_number = 3.14  
    int_number = int(float_number)  
    print(int_number)  # 输出: 3

    浮点型在Python中广泛用于科学计算、数据处理、图形渲染等领域，但需要注意的是，在处理需要高精度计算的场景时，应该特别小心浮点数的精度问题。如果需要高精度计算，可以考虑使用decimal模块或第三方库。 

    1.3  Python中的 / 和 //

    在Python中，/ 和 // 是两种不同的除法运算符，它们各自有特定的用途和行为。

    1.3.1  浮点数除法（/ 运算符）

    当你使用 / 运算符进行除法运算时，Python会返回一个浮点数结果，即使两个操作数都是整数，或者除法的结果是整数（在数学里） 。

    # 两个整数相除，结果为浮点数  
    result = 6 / 3  
    print(result)  # 输出: 2.0  
      
    # 浮点数除法  
    result = 6.0 / 3.0  
    print(result)  # 输出: 2.0

    这种除法会保留除法运算的结果的小数部分，即使在数学上它应该是一个整数。例如，6 / 3 的结果不是 2，而是 2.0。 

    1.3.2  整数除法（// 运算符）

    当你使用 // 运算符进行除法运算时，Python会返回一个整数结果，这个整数是除法运算结果的商的整数部分（向下取整，即地板除）。

    # 两个整数相除，结果为整数  
    result = 7 // 3  
    print(result)  # 输出: 2  
      
    # 浮点数与整数相除，结果仍为整数  
    result = 7.0 // 3  
    print(result)  # 输出: 2  
      
    # 注意，负数相除时，结果仍向负无穷大方向取整  
    result = -7 // 3  
    print(result)  # 输出: -3

    这种除法会丢弃除法运算结果的小数部分，只保留整数部分。因此，7 // 3 的结果是 2，而不是 2.3333333333333335。

    这两种除法运算符在编程中各有用途。当你需要保留小数部分时，使用 / 运算符；当你只需要整数结果时，使用 // 运算符。特别是在需要避免浮点数精度问题或者进行模运算时（比如 a % b），使用 // 运算符通常更为合适。

    1.4  二进制、八进制、十进制、十六进制

    1.4.1  二进制、八进制、十六进制表示符

    • 二进制表示符：0b
    • 八进制表示符：0o
    • 十六进制表示符：0x

      1.4.2  二进制、八进制、十进制、十六进制的相互转换

      • 使用 bin() 方法，可以把其他进制的数转换为二进制。
      • 使用 int() 方法，可以把其他进制的数转换为十进制。
      • 使用 oct() 方法，可以把其他进制的数转换为八进制。
      • 使用 hex() 方法，可以把其他进制的数转换为十六进制。

        print(bin(10)) # 0b1010
        print(bin(0o10)) # 0b1000
        print(bin(0x10)) # 0b10000
        print(oct(10)) # 0o12
        print(oct(0b10)) # 0o2
        print(oct(0x10)) # 0o20
        print(int(0b10)) # 2
        print(int(0o10)) # 8
        print(int(0x10)) # 16
        print(hex(10)) # 0xa
        print(hex(0b10)) # 0x2
        print(hex(0o10)) # 0x8

        1.5  复数（complex）

        在Python中，复数（complex）是数学上表示实数和虚数组合的数。复数的形式通常写作 a + bj，其中 a 是实部，b 是虚部，j 是虚数单位，满足 j^2 = -1。

        Python中的复数可以使用 complex() 函数来创建，该函数接受两个参数：实部和虚部。例如：

        c = complex(4, 3)  # 创建一个复数，实部为4，虚部为3

        你也可以直接在代码中用 j 来表示虚数单位，例如：

        c = 4 + 3j  # 同样创建了一个复数，实部为4，虚部为3

        Python提供了很多内置方法来处理复数，例如：

        • real：返回复数的实部。
        • imag：返回复数的虚部。
        • conjugate()：返回复数的共轭（实部不变，虚部取反）。
        • real 和 imag 属性也可以用于赋值，以改变复数的实部或虚部。

          复数在Python中有广泛的应用，特别是在科学计算、信号处理、电子工程等领域，它们经常用于解决涉及周期性、波动、旋转等问题的数学模型。Python的标准库（如cmath模块）提供了很多用于处理复数的函数，如正弦、余弦、对数、幂运算等。

          2  布尔类型（bool）

          布尔类型（bool）在编程中是一种非常重要的数据类型，它只有两个取值：true（真）和false（假）。这种类型在多种编程语言中都有广泛应用，包括Python。布尔类型主要用于逻辑判断、条件控制、循环控制以及开关状态表示等场景。

          在 Python 里面，布尔类型用来表示真（True）和假（False）。注意：这里的 True 和 False 与其它语言有些不一样，它们的首字母都要大写。

          2.1 与数字类型有关的布尔类型

          在Python中，布尔类型（bool）与数字类型有关，但它不是传统的数字类型（如整数int或浮点数float）的直接子类。Python的布尔类型只有两个值：True 和 False，并且它们具有与整数 1 和 0的等价性。这意味着在需要数值上下文的场合中（比如数学运算），True 会被视为 1，False 会被视为 0。

          2.1.1  布尔类型和整型可以相互转换

          print(int(True))   # 1
          print(int(False))  # 0
          print(bool(1))  # True
          print(bool(0))  # False

          在上面的例子中，布尔类型和整型可以相互转换。这种等价性在多种情况下都很有用，比如在进行数学运算时，或者在需要布尔值与其他数字类型进行交互时。例如：

          x = True  
          y = 2  
          result = x + y  # 这里True被当作1来处理，所以结果是3  
          print(result)  # 输出: 3

          这种设计使得布尔值可以很容易地在需要整数的场合中使用，同时也保留了它们作为逻辑值的本质。

          然而，从类型系统的角度来看，bool 并不是 int 的子类。它们是不同的类型，只是在某些情况下可以互相转换或表现出类似的行为。你可以通过 isinstance() 函数来验证这一点：

          print(isinstance(True, bool))  # 输出: True  
          print(isinstance(True, int))   # 输出: False

          2.1.2  非零的数字表示真（True），0表示假（False）

          print(bool(2))    # True
          print(bool(-2))   # True
          print(bool(0.2))  # True
          print(bool(0))    # False

          2.1.3  其它的数据类型也可以转化为布尔类型

          print(bool('python'))  # 字符串:True
          print(bool(''))  # 空字符串:False
          print(bool([1,3,5]))  # 列表:True
          print(bool([]))  # 空列表:False

          从上面的例子，我们可以看出：凡是非空的数据类型都是 True，空的数据类型都是 False。

          Python里还有个特殊的类型 None，它的布尔类型也是 False 。

          print(bool(None))  # False

          因此，虽然布尔类型与数字类型有交互性，并且在某些上下文中可以视为数字，但从类型定义的角度来说，布尔类型不是数字类型的一种。它们在Python的类型系统中是分开定义的，并且具有不同的用途和行为。 

          2.2  布尔类型的常见用法

          2.2.1  条件判断

          布尔类型最常见的用法是在条件判断语句中，如 if 语句。根据布尔值的真假，程序会执行不同的代码块。例如：

          x = 5  
          if x > 3:  
              print("x 大于 3")  
          else:  
              print("x 不大于 3")

          在这个例子中，x > 3 是一个布尔表达式，如果其结果为true，则执行 if 语句块中的代码；如果为false，则执行 else 语句块中的代码。

          2.2.2  循环控制

          布尔类型也常用于循环控制语句中，如 while 循环。循环会一直执行，直到布尔表达式的值为false。例如：

          count = 0  
          while count  
          在这个例子中，count  
          2.2.3  逻辑运算
           
          布尔类型支持逻辑运算，包括与（and）、或（or）和非（not）。这些运算符用于组合多个布尔表达式，以产生更复杂的逻辑条件。例如：
           
          x = 5  
          y = 10  
          if (x > 3) and (y  
          在这个例子中，(x > 3) and (y  3和y  
          2.2.4  表示开关状态
           
          布尔类型也常用于表示某种开关状态或标记状态。例如，一个程序可能有一个布尔变量来跟踪用户是否已登录，或者一个游戏可能使用布尔变量来表示某个对象是否可见。
           
          is_logged_in = True  # 用户已登录  
          is_visible = False   # 对象不可见
           
          需要注意的是，在Python中，一些其他类型的值在布尔上下文中会被解释为true或false。例如，非零数字、非空字符串和非空列表等通常被视为true，而0、空字符串和空列表等被视为false。这种特性使得布尔类型在与其他类型交互时更加灵活。
           
          总的来说，布尔类型是编程中不可或缺的一部分，它使得程序能够基于逻辑条件进行决策和控制流程。