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 标记变量的数据类型(没有什么意义)
  3. - Python可以使用`变量名: 数据类型`的形式标记数据的类型。
  4. - 但是意义不大,因为这里只起到了一个标记的作用,没有强制的约束力。
  5. - 因此,哪怕给一个变量标记了int,这个变量还是可以被赋予其他类型的数据。
  6. ```python
  7. num: int = 199
  8. print(type(num)) # <class 'int'>
  9. num = "ABC"
  10. 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

  1. - `-`:对于数值型数据来说,-就是进行减法运算的。
  2. ```python
  3. print(31 - 25) # 6
  4. print(3.14 - 5.26) # -2.1199999999999997
  5. 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

  1. - `%`:对于数值型数据来说,%是进行取余运算的。
  2. ```python
  3. 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 布尔数据参与算数运算
  3. - 如果布尔类型的数据【True 和 False】参与算术运算,则True会被当做1、False会被当做0进行运算。
  4. ```python
  5. print(True + 10) # 11
  6. print(25 + False) # 25
  7. print(True + False) # 1
  8. 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 海象运算符
  3. - 海象运算符是3.8中新增的语法;符号为:`:=`,原名为赋值表达式,因其符号的样子像海象的鼻子而得名海象运算符。
  4. - 海象运算符主要作用是在定义一个变量的同时,让这个变量参与到逻辑运算中,可用于简化代码。
  5. - 现有一个一次函数![](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中可以这么写:
  6. ```python
  7. x = 17
  8. y = 2 * x + 1
  9. 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
  3. - 计算规则:用or连接,只有当两个都为False时,结果才为Flase;只要有一个为True结果就为True。
  4. - 计算公式:(一真则全真,全假才为假)
  5. - True and True -> True
  6. - True and False -> True
  7. - False and True -> True
  8. - False and False -> False
  9. - 短路原则:若左边表达式为真,则直接返回True,右边表达式不会进行计算。
  10. - 示例:判断num是否大于20或者小于-10。
  11. ```python
  12. num = -31
  13. res = num > 20 or num < -10
  14. 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。 “””

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

  1. - `~`:按位取反,将二进制位置上的数据0110
  2. ```python
  3. print(~6) # -7
  4. """
  5. 6的补码:0000 0110
  6. 按位取反:1111 1001
  7. 结果为负数补码,要转原码:
  8. 反码(补码-1) : 1111 1000
  9. 原码(符号位不变,其余位按位取反): 1000 0111
  10. 转十进制数据:-7
  11. """
  • <<:按位左移,将二进制向左移动指定的位数,右边空出补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

“””

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

  1. - 注意,如果数据类型不满足整型的转换格式,会报错:`ValueError: invalid literal for int() with base 10: 'data'`
  2. ```python
  3. print(int('3.14')) # '3.14'是浮点型字符串,无法直接转换为整型数据
  4. # 正确写法
  5. print(int(float('3.14'))) # 3
  6. 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

  1. - 如果数据类型不满足浮点型的转换格式,也会报错。
  2. <a name="Tysav"></a>
  3. #### 3.2.3 str()转换为字符串类型
  4. - int()和float()恰好相反,`str(数据)`函数是将数据转换为字符串的形式。
  5. ```python
  6. str1 = str(123)
  7. 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

  1. - 而是需要先将数值型数据转换为字符串型数据,再用+号做连接操作。
  2. ```python
  3. name = "Dosbo"
  4. age = 21
  5. info = name + " is " + str(age) + " years old."
  6. 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()转换成二进制
  5. - `bin(数据)`函数可以将其他进制的数据转换成二进制数据。
  6. ```python
  7. print(bin(109)) # 0b1101101
  8. print(bin(0o765)) # 0b111110101
  9. 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)) # 亿