01. 数据类型

1.1 类与对象

  • 类：是对具有公共特征的事物进行的归类，是一个抽象的描述。如人类、动物类、天体类。

  • 对象：是一个类下具体存在的一个实体，是真真实实存在的一个事物，是参与运算的实际数据。如张继科（人类的对象）、小黑（动物类的对象）、地球（天体类的对象）。

    1.2 数据类型与type()函数

    1.2.1 Python中的数据类型

  • Python中的数据类型有数值、字符串、列表、元组、字典、集合、空值七大类。

  • 数值类型：
    • 整形（int）：如1、51、58099、-123等。
    • 浮点型（float）：如3.14、5.26、-12.34等。
    • 布尔类型（bool）：True（1）和False（0）。
    • 复数类型（complex）：如123-234j。
  • 字符串（str）：如’Hi’、”Hello”、”””World”””等。
  • 列表（lst）：如[1, 2, 3, “Hello”, True]。
  • 元组（tuple）：如(1, 2, 3, ‘Hello’, True)。
  • 字典（dict）：如{‘k1’: ‘v1’, ‘k2’: ‘v2’}。
  • 集合（set）如：{1, 2, 3, 5}。

  • 空值（NoneType）：即什么都没有的数据，这个类型中只有一个值：None。

    • 当需要定义一个变量，但不知道该赋予什么初始值时，可以先赋值为None

      1.2.2 type()判断数据的类型

  • type(数据)函数可以判断数据的类型，其返回值是<class '数据类型'>类型的数据。

    1. a, b = 123, None
    2. c = [1, 2, 3]
    3. print(type(a), type(b), type(c))  # <class 'int'> <class 'NoneType'> <class 'list'>

    1.3 Python动态类型

  • 编程语言除了分为解释型语言和编译型语言外，还可以分为强类型语言（如C、Java等）和弱类型语言（也称动态类型语言，如Python、JavaScript等）。

  • 在强类型语言中，变量在定义时会致明其类型，一个变量只能被赋值一种类型的数据。

    1. int number = 12;  // 定义变量number，且规定其类型为整型。
    2. number = 245;  // 为其赋值一个整型数据，合法。
    3. number = "ABC";  // 为其赋值一个字符串类型数据，非法，报错。
    4. number = 3.14;  // 为其赋值一个浮点型数据，非法，报错。

  • 在弱类型语言中，变量在定义时不需要指明其类型，变量的类型是根据当前传入的值决定的，且一个变量可以传入不同类型的数据。 ```python data = 123 # 现在data是一个整型变量 print(type(data)) # ，type()函数返回变量或数据的类型，格式为

data = “ABC” # 现在data是一个字符串类型的变量。 print(type(data)) # 

  1. <a name="dZUw6"></a>
  2. ### 1.4 标记变量的数据类型（没有什么意义）
  4. - Python可以使用`变量名: 数据类型`的形式标记数据的类型。
  5. - 但是意义不大，因为这里只起到了一个标记的作用，没有强制的约束力。
  6. - 因此，哪怕给一个变量标记了int，这个变量还是可以被赋予其他类型的数据。
  7. ```python
  8. num: int = 199
  9. print(type(num))  # <class 'int'>
  11. num = "ABC"
  12. print(type(num))  # <class 'str'>
  • 这种方式标记变量，在PyCharm里如果赋予不同类型的数据时，其背景会进行高亮显示，但并不会报错。

image.png

  • 因此这种方式更像是定义了一种规范，而非规则。

    02. 运算符

    2.1 Python运算符概述

  • Python的运算符有：

    • 算术运算符：+、-、、/、//、%、*
    • 赋值运算符：=、+=、-=、=、/=、//=、%=、*=
    • 比较运算符：>、>=、<、<=、==、!=
    • 海象运算符：:=
    • 逻辑运算符：and、or、not
    • 成员运算符：in、not in
    • 身份运算符：is、is not
    • 位运算符：&、|、^、~、<<、>>
  • 运算符优先级：算数运算符 >> 位运算符 >> 比较运算符 >> 逻辑运算符 >> 赋值运算符
    • 优先级高的运算符先执行，优先级低的运算符后执行，但可以通过小括号改变运算符优先级。

  • 布尔类型的数据可以参与算术运算与位运算，参与运算时True视作1，False视作0。

    2.2 算数运算符

    2.2.1 算数运算符详解

  • +：对于数值型数据来说，+就是进行加法运算的；对于字符串而言，+号用于实现两个字符串之间的拼接。 ```python print(31 + 25) # 56 print(3.14 + 5.26) # 8.4 print(0.1 + 0.2) # 0.30000000000000004，二进制精度问题

print(“abc” + “def”) # abcdef

  2. - `-`：对于数值型数据来说，-就是进行减法运算的。
  3. ```python
  4. print(31 - 25)  # 6
  5. print(3.14 - 5.26)  # -2.1199999999999997
  6. print(0.1 - 0.2)  # -0.1

  • *：对于数值型数据来说，就是进行运算的；对于字符串而言，`str n`用于实现字符串str重复n次。

    1. print(34 * 32)  # 1088
    2. print(3.14 * 5.26)  # 16.5164
    3. print("ABC" * 3)  # ABCABCABC

  • /：对于数值型数据来说，/就是进行除法运算的，其结果为float类型。

    1. print(4 / 2)  # 2.0
    2. print(23.45 / 3.14)  # 7.468152866242038

  • //：对于数值型数据来说，//是进行整除运算的。

    • 整除的结果为一个整数，即对/除法运算的结果进行向下取整（小于等于商的整数）。
    • 当被除数是浮点数时，结果为x.0。 ```python print(4 // 2) # 2 print(4.0 // 2) # 2.0

向下取整

print(5 // 2) # 2 print(-10 // 4) # -3

  2. - `%`：对于数值型数据来说，%是进行取余运算的。
  3. ```python
  4. print(15 % 2)  # 1，3，15 / 2 = 7 …… 1
  • **：对于数值型数据来说，**是进行次幂运算的，即02. 数据类型与运算符 - 图2。
    • 若0 < y < 1，即02. 数据类型与运算符 - 图3时，其运算结果是浮点数的。 ```python print(2 3) # 8 print(27 (1/3)) # 3.0

**的优先级高于正负号

print(-1 2) # -1，实际上是-(1 2) print((-1) ** 2) # 1

  1. <a name="JJqdJ"></a>
  2. #### 2.2.2 布尔数据参与算数运算
  4. - 如果布尔类型的数据【True 和 False】参与算术运算，则True会被当做1、False会被当做0进行运算。
  5. ```python
  6. print(True + 10)  # 11
  7. print(25 + False)  # 25
  8. print(True + False)  # 1
  9. print(False - True)  # -1

  • 算术运算符的优先级：** >> 正+负-号 >> *、/、//、%（这四个是平级的） >> +、-（这两个是平级的）

    2.3 赋值运算符

  • =：将等号右边的表达式的计算结果，赋值给等号左边的变量。

    1. num = 12 * 24
    2. print(num)  # 288

  • +=：将符号左边变量的值取出，与符号右边的数据进行加法运算，再将计算结果赋值给符号左边的变量，x += n => x = x + n。

    • 如一个变量num = 34，num += 25就是将num的值取出与25做加法运算，即34 + 25 = 59，最后将59赋值给变量num。
      1. num = 34
      2. num += 25
      3. print(num)  # 59

  • -=：将符号左边变量的值取出，与符号右边的数据进行减法运算，再将计算结果赋值给符号左边的变量，x -= n => x = x - n。

    • 如一个变量num = 34，num -= 25就是将num的值取出与25做减法运算，即34 - 25 = 9，最后将9赋值给变量num。
      1. num = 34
      2. num -= 25
      3. print(num)  # 9

  • *=：将符号左边变量的值取出，与符号右边的数据进行乘法运算，再将计算结果赋值给符号左边的变量，x *= n => x = x * n。

    • 如一个变量num = 3，num = 4就是将num的值取出与4做乘法运算，即3 4 = 12，最后将12赋值给变量num。
      1. num = 3
      2. num *= 4
      3. print(num)  # 12

  • /=：将符号左边变量的值取出，与符号右边的数据进行除法运算，再将计算结果赋值给符号左边的变量，x /= n => x = x / n。

    • 如一个变量num = 35，num /= 7就是将num的值取出与7做除法运算，即35 / 7 = 5.0，最后将5.0赋值给变量num。
      1. num = 35
      2. num /= 7
      3. print(num)  # 5.0

  • //=：将符号左边变量的值取出，与符号右边的数据进行整除运算，再将计算结果赋值给符号左边的变量，x //= n => x = x // n。

    • 如一个变量num = -10，num //= 3就是将num的值取出与3做整除运算，即-10 / 3 = -4，最后将-4赋值给变量num。
      1. num = -10
      2. num //= 3
      3. print(num)  # -4

  • %=：将符号左边变量的值取出，与符号右边的数据进行取模运算，再将计算结果赋值给符号左边的变量，x %= n => x = x % n。

    • 如一个变量num = 22，num %= 4就是将num的值取出与4做整除运算，即22 % 4 = 2，最后将2赋值给变量num。
      1. num = 22
      2. num %= 4
      3. print(num)  # 2

  • **=：将符号左边变量的值取出，与符号右边的数据进行次幂运算，再将计算结果赋值给符号左边的变量，x **= n => x = x ** n。

    • 如一个变量num = 2，num = 3就是将num的值取出与3做次幂运算，即2 3 = 8，最后将8赋值给变量num。
      1. num = 2
      2. num **= 3
      3. print(num)  # 8

      2.4 比较运算符

      2.4.1 比较运算符详解

  • 比较运算符用于比较两个数据在数学关系中的大小，其结果是布尔类型的。

  • x > y：判断x是否大于y。

    1. print(3 > 5)  # False

  • x >= y：判断x是否大于等于y。

    1. print(25 >= 16)  # True

  • x < y：判断x是否小于y。

    1. print(14 < 35)  # True

  • x <= y：判断x是否小于等于y。

    1. print(35 <= 123)  # True

  • x == y：判断x是否等于y。

    1. print(12 == 12)  # True

  • x != y：判断x是否不等于y。

    1. print(12 != 12)  # False

    2.4.2 字符串比较大小

    1. 计算机基础概念与Python环境搭建 — 01. 计算机基础知识 — 04. 编码与解码中提到，计算机在存储数据时是先将数据转换成编码集对应的十进制数据，再转换成十进制对应的二进制数据，最后再存储到计算机的硬件设备上的。
  • 根据数据的存储规则，可以得出比较两个字符串的大小的规则为：比较两个字符串左边第一个字符对应的十进制数据，如果第一个字符一样，则比较第二个字符。以此类推，直到得出结果为止。 ```python print(‘a’ > ‘A’) # True，实际上比较的是97（a的ASCII码）和65（A的ASCII码）的大小。

print(“hello” > “head”) # True，h相同，比较e，e也相同，比较l和a，l的ASCII为108，a为97，因此”hello”大于”head”。

  1. <a name="BHHxi"></a>
  2. ### 2.5 海象运算符
  4. - 海象运算符是3.8中新增的语法；符号为：`:=`，原名为赋值表达式，因其符号的样子像海象的鼻子而得名海象运算符。
  5. - 海象运算符主要作用是在定义一个变量的同时，让这个变量参与到逻辑运算中，可用于简化代码。
  6. - 现有一个一次函数![](https://cdn.nlark.com/yuque/__latex/448c591515443994aab271b2ee5ed3eb.svg#card=math&code=f%28x%29%20%3D%202x%20%2B%201&id=XmXZk)，要求![](https://cdn.nlark.com/yuque/__latex/bad4a92ef03a3b344ee4163ce134e5d8.svg#card=math&code=f%2817%29&id=HKGWx)的值，在Python中可以这么写：
  7. ```python
  8. x = 17
  9. y = 2 * x + 1
  10. print(y)  # 35

  • 海象运算符就可以做到在定义x的同时，让x参与到y的赋值运算中。

    1. y = 2 * (x := 17) + 1
    2. print(y)  # 35

    2.6 逻辑运算符

  • 逻辑运算符用于判断逻辑条件是否成立，有逻辑与（and）、逻辑或（or）、逻辑非（not）三类。

    2.6.1 逻辑与and

  • 计算规则：用and连接，只有当两个都为True时，才会True；只要有一个为False，或者两个都为False，那么结果就为False。

  • 计算公式：（一假则全假，全真才为真）
    • True and True -> True
    • True and False -> False
    • False and True -> False
    • False and False -> False
  • 短路原则：若左边表达式为假，则直接返回False，右边表达式不会进行计算。
  • 示例：判断num是否及大于35，又小于64。 ```python num = 77 res = num > 35 and num < 64 print(res) # False

注：Python支持数学那样的连续比较，故第2行代码可写为：res = 35 < num < 64

但在理解上，依旧需要理解成逻辑与的关系。

  1. <a name="Z7Kr4"></a>
  2. #### 2.6.2 逻辑或or
  4. - 计算规则：用or连接，只有当两个都为False时，结果才为Flase；只要有一个为True结果就为True。
  5. - 计算公式：（一真则全真，全假才为假）
  6.    - True and True -> True
  7.    - True and False -> True 
  8.    - False and True -> True 
  9.    - False and False -> False
  10. - 短路原则：若左边表达式为真，则直接返回True，右边表达式不会进行计算。
  11. - 示例：判断num是否大于20或者小于-10。
  12. ```python
  13. num = -31
  14. res = num > 20 or num < -10
  15. print(res)  # True

2.6.3 and短路与or短路

  • and短路：左边表达式不成立时，右边表达式不执行【这里的表达式是指与and连接的表达式】，除了这个表达式不执行外，如果还有其他表达式，则其他表达式会执行。

    1. num = 0
    2. res1 = num != 0 and num % 3 == 0 or num % 5 == 0  # num % 3 == 0不执行，num % 5 == 0执行。
    3. res2 = num != 0 and (num % 3 == 0 or num % 5 == 0)  # (num % 3 == 0 or num % 5 == 0)整体不执行。
    4. print(res1, res2)  # True False

  • or短路：左边表达式成立，右边不执行，or可以短路后面的一切表达式。

    1. num = 0
    2. res = num % 3 == 0 or num % 5 == 0 and num != 0  # num % 5 == 0 and num != 0整体不执行。
    3. print(res)  # True

    2.6.4 逻辑非not

  • 计算规则：用not表示，即对逻辑结果取反，真变假，假变真。

  • 计算公式：（一真则全真，全假才为假）
    • not True -> False
    • not False -> True

  • 示例：判断一个字符是否不是小写英文字母。

    1. ch = "n"
    2. res = not ("a" <= ch <= "z")
    3. print(res)  # False，注意，若为True则表示ch不是小写英文字母；若为False则表示ch是小写英文字母。

    2.6.5 非布尔类型的数据进行逻辑运算

  • 非布尔类型的数据参与逻辑运算时会按照3.2.4中的转换规则进行隐式转换，转换完成后再参与逻辑运算。

    • 隐式转换：只是将数据当成转换后的结果进行运算，数据本身不变。
    • 如0转换后是False，13转换后是True，但0还是0，13还是13。

  • 逻辑与运算：因为and的短路原则，左边表达式不成立，右边表达式不执行，使得最后运算结果如下：

    • 左边表达式为假，结果就是左边表达式的值。
    • 左边表达式为真，结果就是右边表达式的值。
      1. print(10 and 11)  # 11；10隐式转换后为True，故结果是左边表达式的值。
      2. print([] and 13)  # []；空列表隐式转换后为False，False造成and短路，结果为[]
      3. print(not 1 and 0)  # False；1隐式转换为True，故not 1的结果为False，False造成and短路，结果为(not 1)的值False

  • 逻辑或运算：因为or的短路原则，左边表达式成立，右边表达式不执行，使得最后运算结果如下：

    • 左边表达式为真，结果为左边表达式的值。
    • 左边表达式为假，结果为右边表达式的值。
      1. print(10 or 11)  # 11
      2. print([] or 13)  # 13
      3. print(10 and 0 or 9)  # 9；10隐式转换后为True，即10 and 0结果为0，0隐式转换后为False，即0 or 9结果为9。

      2.7 成员运算符

  • 成员运算符用于判断某个数据是否在容器（字符串、列表、元组、字典、集合）中：

    • 数据 in 容器：判断数据是否在容器中。
    • 数据 not in 容器：判断数据是否不在容器中。

  • 示例：判断字符串Hel是否在字符串Hello中，123是否不在列表[234, 345, 456]中。

    1. print("Hel" in "Hello")  # True
    2. print(123 not in [234, 345, 456])  # True

    2.8 身份运算符

    2.8.1 id()获取对象内存地址

  • id(数据对象)函数用于获取数据对象在内存中的地址。

    1. >>> id(3.14)
    2. 3045776901712
    3. >>> id(False)
    4. 140727462754440

  • 如果是不可变类型的数据（整型、浮点型、布尔类型、字符串类型、元组），那么只要数据字面量一致，那么在内存中的地址一定一致。

    1. >>> a = 10
    2. >>> b = 10
    3. >>> id(a), id(b)
    4. (3045776255568, 3045776255568)
    5. >>> print(id(a) == id(b))
    6. True

  • 如果是可变类型的数据（列表、字典、集合），那么只要定义一个数据对象，内存中就会新产生一份。

    • 这种情况下，哪怕两个数据对象的字面量完全一样，其内存中的地址也不会一样。
      1. >>> l1 = [1, 2, 3]
      2. >>> l2 = [1, 2, 3]
      3. >>> id(l1), id(l2)
      4. (3045784655168, 3045784655552)
      5. >>> print(id(l1) == id(l2))
      6. False

      2.8.2 身份运算符详解

  • 身份运算符是基于id()函数的结果，对两个数据对象的内存地址进行判断的。

    • 数据1 is 数据2：判断两个数据的地址是否一致。

      1. >>> a, b = 10, 10
      2. >>> a is b
      3. True
      4. >>> l1, l2 = [1, 2, 3], [1, 2, 3]
      5. >>> l1 is l2
      6. False

    • 数据1 is not 数据2：判断两个数据的地址是否不一致。

      1. >>> a, b = 10, 10
      2. >>> a is not b
      3. False
      4. >>> l1, l2 = [1, 2, 3], [1, 2, 3]
      5. >>> l1 is not l2
      6. True

      2.8.3 一些特殊的数据

  • 数值型数据中的特殊部分：

    • -5~256之间的数值型数据会缓存在内存中，这部分数据在使用时会直接拿内存中的数据。

    • 故-5~256之间的数值型数据不管定义几个，都是同一个数据。

      1. >>> a, b = 3.14, 3.14
      2. >>> a is b
      3. True
      4. >>> c, d = -34, -34
      5. >>> c is d
      6. True

    • 但是如果超出了这个范围，就需要重新将数据加载到内存中，并且定义一次就会添加一次。

    • 故超出这个范围的数据其数据对象的地址是不一样的。
      1. >>> a = 257
      2. >>> b = 256
      3. >>> a is b
      4. False
      5. >>> c = -6
      6. >>> d = -6
      7. >>> c is d
      8. False

  • 字符串数据中的特殊部分：字符串中如果包含特殊字符，则定义一次就会产生一个新的数据对象。

    1. >>> s1 = "zxcvbnm,.mnbvcxz"
    2. >>> s2 = "zxcvbnm,.mnbvcxz"
    3. >>> s1 is s2  # s1和s2虽然字面量一样，但含有英文逗号和英文句号两个符号。
    4. False
    5. >>> s3 = "qwertyuiop"
    6. >>> s4 = "qwertyuiop"
    7. >>> s3 is s4  # s3和s4字面量一样，且没有任何特殊符号。
    8. True

    2.9 位运算符

    2.9.1 原码、反码与补码

  • 计算机中的数据是以二进制进行存储的，但是二进制又有以下三种形态：

    • 正数的原码、反码、补码相同，因此转换主要是针对于负数而言的。
    • 原码：十进制数据转为对应的二进制数据。
      • 正数13：0000 1101（数据在计算机中最小的存储单位是字节，占8个位）
      • 负数-13：1000 1101（最高位1为符号位，0表示正数，1表示负数）
    • 反码：在原码的基础上，除了最高位符号位外，其余位按位取反（0转1，1转0）
      • 正数13：0000 1101（原码、反码、补码相同）
      • 负数-13：1111 0010（将原码非符号位按位取反）
    • 补码：在反码的基础上+1。
      • 正数13：0000 1101（原码、反码、补码相同）
      • 负数-13：1111 0011（在反码的基础上+1）

  • 数据在进行运算时，是通过补码运算的；十进制和二进制数据间的转换是通过原码完成的。

    2.9.2 位运算符详解

  • 位运算符是将数据转为其对应的二进制数据，按位置依次进行运算的。

  • &：按位与，相同位置上有一个数据为0，则该位结果为0。 ```python print(6 & -7) # 0 “”” 6的补码：0000 0110 -7的补码：1111 1001 原码：1000 0111 反码：1111 1000 补码：1111 1001

按位与： 0000 0110

1111 1001

0000 0000 结果为正数补码，即原码转十进制为0。 “””

  2. - `|`：按位或，相同位置上有一个数据为1，则该位结果为1。
  3. ```python
  4. print(6 | -7)  # -1
  5. """
  6.  6的补码：0000 0110
  7. -7的补码：1111 1001
  8.     原码：1000 0111
  9.     反码：1111 1000
  10.     补码：1111 1001
  12. 按位或：
  13. 0000 0110
  14. 1111 1001
  15. ---------
  16. 1111 1111
  17. 结果为负数补码，要转原码：
  18.     反码（补码-1）                  ：  1111 1110
  19.     原码（符号位不变，其余位按位取反）：  1000 0001
  20.     转十进制数据：-1
  21. """
  • ^：按位异或，相同位置上数据相同，则该位结果为0；相同位置上数据不同，则该位结果为1。 ```python print(6 ^ -7) # -1 “”” 6的补码：0000 0110 -7的补码：1111 1001 原码：1000 0111 反码：1111 1000 补码：1111 1001

按位异或： 0000 0110

1111 1001

1111 1111 结果为负数补码，要转原码： 反码（补码-1） ： 1111 1110 原码（符号位不变，其余位按位取反）： 1000 0001 转十进制数据：-1 “”” print(6 ^ 7) # 1 “”” 6的补码：0000 0110 7的补码：0000 0111 按位异或： 0000 0110

0000 0111

0000 0001 结果为正数补码，即原码转十进制为1。 “””

  2. - `~`：按位取反，将二进制位置上的数据0转1，1转0。
  3. ```python
  4. print(~6)  # -7
  5. """
  6.  6的补码：0000 0110
  7. 按位取反：1111 1001
  8. 结果为负数补码，要转原码：
  9.     反码（补码-1）                  ：  1111 1000
  10.     原码（符号位不变，其余位按位取反）：  1000 0111
  11.     转十进制数据：-7
  12. """

  • <<：按位左移，将二进制向左移动指定的位数，右边空出补0。

    • 数据 << 移动位数的结果为02. 数据类型与运算符 - 图4
      1. print(3 << 2)  # 12
      2. """
      3. 3的补码：0000 0011
      4. 按位左移2位：0000 11__
      5. 右边空位补0：0000 1100
      6. 结果为正数补码，即原码转十进制为12。
      7. """
      8. print(3 << 5)  # 96
      9. """
      10. 3的补码：0000 0011
      11. 按位左移5位：011_ ____
      12. 右边空位补0：0110 0000
      13. 结果为正数补码，即原码转十进制为96。
      14. """

  • >>：按位右移，将二进制向右移动指定的位数，左边空出正数补0负数补1，右边超出位置舍去。

    • 数据 >> 移动位数的结果为02. 数据类型与运算符 - 图5
    • 正数右移最小为0；负数右移最大为-1。
      1. print(-48 >> 1)  # -24
      2. """
      3. -48 原码：1011 0000
      4. 反码：1100 1111
      5. 补码：1101 0000
      6. 按位右移：1110 1000 | 0 （舍弃部分）
      7. 结果为负数补码，要转原码：
      8. 反码（补码-1）                  ：  1110 0111
      9. 原码（符号位不变，其余位按位取反）：  1001 1000
      10. 转十进制数据：-24
      11. """
      12. print(-48 >> 3)  # -6
      13. """
      14. -48 原码：1011 0000
      15. 反码：1100 1111
      16. 补码：1101 0000
      17. 按位右移：1111 1111 | 1110 1000 0 （舍弃部分）
      18. 结果为负数补码，要转原码：
      19. 反码（补码-1）                  ：  1111 1110
      20. 原码（符号位不变，其余位按位取反）：  1000 0001
      21. 转十进制数据：-1
      22. """

      2.9.3 交换两个变量的值

  • 方式一：借助第三方临时变量。

    1. a, b = 10, 20
    2. tmp = a  # tmp = 10；a = 10；b = 20
    3. a = b  # tmp = 10；a = 20；b = 20
    4. b = tmp  # tmp = 10；a = 20；b = 10
    5. print(a, b)  # 20 10

  • 方式二：按位异或。（一个数与相同的数异或两次，结果是其本身）

    1. a, b = 10, 20
    2. a = a ^ b  # a = 10 ^ 20；b = 20
    3. b = a ^ b  # a = 10 ^ 20；b = 10 ^ 20 ^ 20 = 10
    4. a = a ^ b  # a = 10 ^ 20 ^ 10 = 20 ^ 10 ^ 10 = 20；b = 10
    5. print(a, b)  # 20 10

  • 方式三：距离求和求差。

    1. a, b = 10, 20
    2. a = a + b  # a = 10 + 20；b = 20
    3. b = a - b  # a = 10 + 20；b = 10 + 20 - 20 = 10
    4. a = a - b  # a = 10 + 20 - 10 = 20；b = 10
    5. print(a, b)  # 20 10

  • 方式四：Python独有的方法。

    1. a, b = 10, 20
    2. print(a, b)  # 10 20
    3. a, b = b, a
    4. print(a, b)  # 20 10

    03. 输入数据及数据类型转换

    3.1 input()输入函数

    3.1.1 input()函数实现输入功能

  • input()函数与print()函数是一对输入输出函数，input()函数负责在控制台上通过键盘输入数据。

  • input()函数的基础语法：变量名 = input(输入提示信息)
  • 示例：实现下图的程序：

image.png

  • 代码实现：

    1. name = input("请输入你的姓名：")
    2. gender = input("请输入你的性别（男士/女士）：")
    3. print("您好，", name, gender)

    3.1.2 input()输入数据的类型

  • input()函数在运行时，不管从键盘中获取到什么类型的数据，这个数据都会被当成字符串处理，并不会自动解析其类型。

  • 如下列代码，按理来说name应该是字符串型数据，age应该是整型数据，但结果却都是字符串型数据。 ```python name = input() age = input() print(type(name), type(age))

“”” 运行结果： Jack 18

“””

  2. - 如果要输入指定格式的数据，还需要在input()外面套一层类型转换函数。
  3. <a name="N8Vnf"></a>
  4. ### 3.2 数据类型转换
  5. <a name="e0xvZ"></a>
  6. #### 3.2.1 int()转换为十进制整型
  8. - `int(数据)`函数会将括号内的参数转换为十进制整型数据，详细来说有如下三个功能：
  9.    - 将整型字符串中的整型数据转换出来。
  10.    - 对浮点型数据进行取整。
  11.    - 将其他进制的数据转换成十进制数据。
  12. ```python
  13. num1 = int("123")
  14. print(type(num1), num1)  # <class 'int'> 123
  16. num2 = int(12.34)
  17. print(type(num2), num2)  # <class 'int'> 12
  19. num3 = int(0b1001)
  20. print(type(num3), num3)  # <class 'int'> 9
  • 对于其他进制的字符串数据，直接转换是会报错的，需要根据进制指定base参数的值。 ```python

    直接转换，报错。

    print(int(“0b1011”)) # ValueError: invalid literal for int() with base 10: ‘0b1011’

根据字符串中数据的进制，指定base的值。

print(int(“0b1011”, base=2)) # 11 print(int(“0o62”, base=8)) # 50 print(int(“0xA1C7”, base=16)) # 41415

不知道字符串中数据的几进制时，指定base的值为0，Python会自动识别。

print(int(“0b1011”, base=0)) # 11 print(int(“0o62”, base=0)) # 50 print(int(“0xA1C7”, base=0)) # 41415

  2. - 注意，如果数据类型不满足整型的转换格式，会报错：`ValueError: invalid literal for int() with base 10: 'data'`
  3. ```python
  4. print(int('3.14'))  # '3.14'是浮点型字符串，无法直接转换为整型数据
  5. # 正确写法
  6. print(int(float('3.14')))  # 3
  8. print(int("数据是：10"))  # ”数据是：“这部分是字符串数据，无法转换。

3.2.2 float()转换为浮点型

  • float(数据)函数会将括号内的参数转换为浮点型数据，详细来说有如下两个功能：
    • 将浮点型字符串转换为浮点型数据。
    • 将整型数据转换为num.0形式的浮点数。（不常用） ```python num1 = float(“3.14”) print(type(num1), num1) # 3.14

num2 = float(3) print(type(num2), num2) # 3.0

  2. - 如果数据类型不满足浮点型的转换格式，也会报错。
  3. <a name="Tysav"></a>
  4. #### 3.2.3 str()转换为字符串类型
  6. - 与int()和float()恰好相反，`str(数据)`函数是将数据转换为字符串的形式。
  7. ```python
  8. str1 = str(123)
  9. print(type(str1), str1)  # <class 'str'> 123
  • 当字符串类型的数据需要与数值型的数据进行拼接时，不能直接使用+号连接两个数据。 ```python name = “Dosbo” age = 21 info = name + “ is “ + age + “ years old.” print(info)

运行报错：TypeError: can only concatenate str (not “int”) to str

  2. - 而是需要先将数值型数据转换为字符串型数据，再用+号做连接操作。
  3. ```python
  4. name = "Dosbo"
  5. age = 21
  6. info = name + " is " + str(age) + " years old."
  7. print(info)  # Dosbo is 21 years old.

3.2.4 bool()转换为布尔类型

  • bool(数据)函数可以将数据转换为布尔类型的数据。

  • 转换规则：

    • 当数据为整型或浮点型时，数据非0即为True，为0即为False。

      1. print(bool(0))  # False
      2. print(bool(5))  # True
      3. print(bool(31.23))  # True
      4. print(bool(0.0))  # False
      5. print(bool(-31.1))  # True

    • 当数据为容器类型的数据时，容器非空即为True，为空即为False。

      1. print(bool(""))  # False
      2. print(bool(" "))  # True
      3. print(bool("ABC"))  # True
      4. print(bool([]))  # False
      5. print(bool((12, 34, 56)))  # True

    • 空类型None为False。

      1. print(bool(None))  # False

      3.2.5 eval()动态类型转换

  • eval()会自动识别括号内参数的类型，然后将其转换为对应的类型。

  • 注意：eval()不能识别str类型的数据，否则会报错。 ```python name = input(“请输入姓名：”) # name是字符串类型的数据，因此外面不能套eval()函数。 age = eval(input(“请输入年龄：”)) gpa = eval(input(“请输入绩点：”))

print(type(name), name) print(type(age), age) print(type(gpa), gpa)

“”” 运行结果： 请输入姓名：杜沈波 请输入年龄：21 请输入绩点：4.5

杜沈波

21

4.5 “””

  1. <a name="BuPXt"></a>
  2. ### 3.3 其他形态数据之间的转换
  3. <a name="Dii3N"></a>
  4. #### 3.3.1 bin()转换成二进制
  6. - `bin(数据)`函数可以将其他进制的数据转换成二进制数据。
  7. ```python
  8. print(bin(109))  # 0b1101101
  9. print(bin(0o765))  # 0b111110101
  10. print(bin(0x9ADF))  # 0b1001101011011111

3.3.2 oct()转换成八进制

  • oct(数据)函数可以将其他进制的数据转换成八进制数据。

    1. print(oct(0b1101101))  # 0o155
    2. print(oct(109))  # 0o155
    3. print(oct(0x9ADF))  # 0o115337

    3.3.3 hex()转换成十六进制

  • hex(数据)函数可以将其他进制的数据转换成十六进制数据。

    1. print(hex(0b1101101))  # 0x6d
    2. print(hex(0o115337))  # 0x9adf
    3. print(hex(109))  # 0x6d

    3.3.4 ord()字符数据转换成十进制数据

  • ord(字符)函数获取字符数据对应的十进制数据。

    1. print(ord("A"))  # 65
    2. print(ord("a"))  # 97
    3. print(ord("0"))  # 48
    4. print(ord("亿"))  # 20159

    3.3.5 chr()十进制数据转换成字符数据

  • chr(数据)函数可以按照文本的编码规则，获取十进制数据对应的字符。

    1. print(chr(65))  # A
    2. print(chr(97))  # a
    3. print(chr(48))  # 0
    4. print(chr(20159))  # 亿