数据类型

发表于 更新于 分类于 > > 本文字数： 15k 阅读时长 ≈ 25 分钟

单位换算

  • 最小的单位 bit，表示一个二进制的 0 或 1，一般使用小写的 b 表示
  • 存储的最小单位字节 (Byte)，1B = 8b
  • 1024B = 1KB
  • 1024KB = 1MB
  • 1024MB = 1GB
  • 1024GB = 1TB
  • 1024TB = 1PB
  • 2^32 = 2^10 * 2^10 * 2^10 * 2^2 = 4GB

进制转换

  • 十进制

    • 基数 0-9，逢 10 进 1
    • 示例：123 = 1 * 10^2 + 2 * 10^1 + 3 * 10^0 = 100 + 20 + 3 = 123

  • 二进制

    • 基数 0 和 1，缝 2 进 1，python 中以 'ob' 开头
    • 示例：0b110100 = 2^5 + 2^4 + 2^2 = 52
    • 十进制转换二进制：除 2 取余，倒序书写
      • 22 = 0b10110

  • 八进制

    • 基数 0-7，缝 8 进 1，python 中以 '0o' 开头
    • 示例：0o123 = 1* 8^2 + 2 * 8^1+ 3 * 8^0 = 64 + 16 + 3 = 83
    • 八进制转换二进制：八进制 1 位表示 3 位二进制
      • 0o123 = 0b 001 010 011

  • 十六进制

    • 基数 0-9、A-F，缝 16 进 1，python 中以 '0x' 开头
    • 示例：0xAB = 10 * 16^1 + 11 * 16^0 = 160 + 11 = 171
    • 十六机制转换二进制：十六进制 1 位表示 4 位二进制
      • 0xABC = 0b 1010 1011 1100

  • 计算机中的数据是以哪种进制存储的？为什么？

    • 二进制，因为计算机只识别二进制，具体原因如下：
      • 稳定性高（只有 0 和 1）
      • 成本低（技术上容易实现）
      • 与生活中的真假逻辑相吻合

  • 计算机中的数据是如何存储的？

    • 如何存储负数？
      • 最高位为符号位，0 表示正数，1 表示负数
      • 虽然牺牲了最不常用的最高位，但是解决了负数问题，并简化了硬件设计（节约成本）
      • 示例：（1 + 1） （1 - 1）
        1
        2
        3
        0000 0001                  0000 0001
        0000 0001                  1000 0001  
        0000 0010                  1000 0010  = -2
    • 原码、反码、补码？
      • 正数的三码一致，只有负数才有反码和补码
      • 反码：原码符号位不变，其余位取反
      • 补码：原码的反码加 1
      • 计算机中的数据都是以补码的形式存在
    • 示例：
      1
      2
      3
      4
      5
      6
      7
      原码：1000 0001
      反码：1111 1110
      补码：1111 1111
      （1 - 1）
      0000 0001
      1111 1111
      0000 0000 = 0

数据类型

  • 简介

    • 数据类型是为了处理不同的运算而存在的
    • Python 中的数据类型有：整数、浮点数、字符串、布尔值、列表、元组、集合、字典、空值

  • 整数 (int)

    • 在 Python 中，整数（int）是一种基本的数据类型，用于表示整数值（正整数和负整数）。整数在 Python 中没有固定的大小限制，可以表示任意大或小的整数。
    • 对于很大的数，例如 10000000000 ，很难数清楚 0 的个数。Python 允许在数字中间以 _ 分隔，因此，写成 10_000_000_000 和 10000000000 是完全一样的。
    • 整数方法：整数对象还提供了一些有用的方法，例如 abs() 用于获取整数的绝对值，divmod() 用于同时获取整数的商和余数，pow() 用于计算整数的幂等等。
    • 示例 
      1
      2
      3
      4
      # 整数
      a = 10
      # 获取变量的类型
      print(type(a))

  • 浮点数 (float)

    • 在 Python 中，浮点数（float）是一种数据类型，用于表示带有小数点的数值。浮点数在 Python 中用于处理实数运算和精确度要求较高的计算。
    • 浮点数由整数部分与小数部分组成，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x109 和 12.3x108 是完全相等的。
    • 浮点数可以用数学写法，如 1.23，3.14，-9.01，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把 10 用 e 替代，1.23x10^9 就是 1.23e9，或者 12.3e8，0.000012 可以写成 1.2e-5，等等。
    • 整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是的！），而浮点数运算则可能会有四舍五入的误差。
    • 浮点数方法：浮点数对象还提供了一些有用的方法，例如 abs() 用于获取浮点数的绝对值，round() 用于对浮点数进行四舍五入，is_integer() 用于检查浮点数是否为整数等。
    • 示例 
      1
      2
      3
      4
      5
      6
      7
      # 小数(浮点数)
      b = 3.14
      print(type(b))

      # 科学计数法
      c = 3.14e-3
      print(c)

  • 布尔值 (bool)

    • 在 Python 中，布尔值（bool）是一种数据类型，用于表示真（True）和假（False）两个逻辑值。布尔值通常用于控制程序的流程和执行条件判断。
    • 创建布尔值：可以直接使用关键字 True 和 False 来创建布尔值对象，例如：x = True、y = False。
    • 布尔运算：布尔值支持逻辑运算操作，包括逻辑与（and）、逻辑或（or）和逻辑非（not）等。例如：result = True and False、result = True or False。
    • 比较运算：布尔值可以通过比较运算符进行比较操作，例如相等比较（==）、不等比较（!=）、大于（>）、小于（<）、大于等于（>=）和小于等于（<=）等。比较运算的结果是布尔值。例如：result = 5 > 3、result = "hello" == "world"。
    • 布尔转换：可以使用 bool() 函数将其他类型的数据转换为布尔值。在布尔上下文中，一些值被视为假（False），如 0、空字符串、空列表、空字典等，其他非零或非空值被视为真（True）
    • 布尔操作的短路求值：在逻辑运算中，如果根据前面的条件已经可以确定整个表达式的结果，Python 会进行短路求值。例如，在逻辑与运算中，如果第一个条件为假（False），则整个表达式的结果必定为假（False），后续条件不会被计算。
    • 示例 
      1
      2
      3
      # bool类型，只有两个值，True、False
      d = False
      print(type(d))

  • 空值 (NoneType)

    • 在 Python 中，空值（None）是一种特殊的数据类型，用于表示空或缺失的值。空值通常用于表示变量尚未被赋予具体的值或函数没有返回任何有效结果的情况。
    • None 不能理解为 0，因为 0 是有意义的，而 None 是一个特殊的空值。
    • 创建空值：可以使用关键字 None 来创建空值对象。例如：x = None。
    • 空值的特性：空值是一个特殊的对象，它不代表任何具体的值。它不等于任何其他的对象，包括空字符串、零和空容器（如空列表、空字典等）。
    • 变量赋值：可以将空值赋给变量，表示该变量当前没有具体的值。例如：x = None。
    • 函数返回值：在函数中，可以使用 return 语句返回空值，表示函数没有返回任何有效结果。例如：
      1
      2
      def my_function():
          return None
    • 空值的比较：空值之间可以进行比较操作，使用相等比较运算符（==）进行比较。例如：x is None 可以用来检查变量 x 是否为空值。
    • 条件判断：空值在条件判断中被视为假（False），因此可以在条件语句中使用空值来判断某个变量是否有值。例如：
      1
      2
      if x is None:
          print("x is None")
    • 示例 
      1
      2
      3
      # 空值
      e = None
      print(type(e))

  • 字符串 (str)

    • 在 Python 中，字符串（string）是一种表示文本数据的数据类型。字符串由一系列字符组成，可以包含字母、数字、符号和空格等。
    • 创建字符串：可以使用单引号（'）或双引号（"）将文本括起来创建字符串。例如：
      1
      2
      s1 = 'Hello, World!'
      s2 = "Python is awesome!"
    • 多行字符串：如果字符串需要跨越多行，可以使用三引号（'''）或三双引号（"""）来创建多行字符串。例如：
      1
      2
      s3 = '''This is a multi-line
      string in Python.'''
    • 字符串操作：可以对字符串进行多种操作，包括拼接、切片、长度获取等。
      • 字符串拼接：可以使用加号（+）将两个字符串连接起来。例如：s4 = s1 + s2。
        1
        2
        3
        4
        5
        6
        7
        # 直接拼接
        s2 = 'hello' + 'world'
        print(s2)

        # 指定的字符串重复若干次，然后拼在一起
        s3 = 'abc' * 3
        print(s3)
      • 切片操作：可以使用索引和切片操作符（[]）截取字符串的部分内容，遵循左闭右开原则。例如：s5 = s1[7:12] 可以获取字符串中的子串。
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        s5 = 'abcdefg'
        # s[起始下标：结束下标]，包括起始下标元素，不包括结束下标元素
        print(s5[0:3])
        # 从开头提取到指定位置
        print(s5[:4])
        # 从指定下标提取到结尾
        print(s5[3:])
        # 从指定位置提取到倒数第一个，不包括倒数第一个
        print(s5[3:-1])
        # 提取最后四个字符
        print(s5[-4:])
        # 提取全部元素
        print(s5[:])
        # 指定步进值，默认为一
        print(s5[::2])
        # 字符串逆序
        print(s5[::-1])

        ## 提取单个字符
        s4 = '123456'
        # 从开头提取，下标从0开始
        print(s4[0])
        # 从末尾提取，下标从-1开始
        print(s4[-1])
      • 字符串长度：可以使用 len() 函数获取字符串的长度。例如：length = len(s1)。
        1
        2
        3
        # 无论什么字符，都是一个长度
        s = 'hello你好'
        print(len(s))
    • 字符串格式化：可以使用字符串的 format() 方法或者使用 f-string（格式化字符串字面值）来格式化字符串，还支持使用百分号（%）进行字符串格式化。例如：
      1
      2
      3
      4
      5
      6
      name = "Alice"
      age = 25

      s6 = "My name is {} and I'm {} years old.".format(name, age)
      s7 = f"My name is {name} and I'm {age} years old."
      s8 = "My name is %s and I'm %d years old." % (name, age)
      python 字符串格式化符号
      符 号 描述
      %c 格式化字符及其 ASCII 码
      %s 格式化字符串
      %d 格式化整数
      %u 格式化无符号整型
      %o 格式化无符号八进制数
      %x 格式化无符号十六进制数
      %X 格式化无符号十六进制数（大写）
      %f 格式化浮点数字，可指定小数点后的精度
      %e 用科学计数法格式化浮点数
      %E 作用同 % e，用科学计数法格式化浮点数
      %g % f 和 % e 的简写
      %G % f 和 % E 的简写
      %p 用十六进制数格式化变量的地址
    • 字符串方法：字符串对象有许多内置方法，可以对字符串进行各种操作，如查找子串、替换、大小写转换等。
      方法 描述
      capitalize() 将字符串的第一个字符转换为大写
      center(width, fillchar) 返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。
      count(str, beg= 0,end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
      bytes.decode(encoding="utf-8", errors="strict") Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode () 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode () 来编码返回。
      encode(encoding='UTF-8',errors='strict') 以 encoding 指定的编码格式编码字符串，如果出错默认报一个 ValueError 的异常，除非 errors 指定的是 'ignore' 或者 'replace'
      endswith(suffix, beg=0, end=len(string)) 检查字符串是否以 suffix 结束，如果 beg 或者 end 指定则检查指定的范围内是否以 suffix 结束，如果是，返回 True, 否则返回 False。
      expandtabs(tabsize=8) 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。
      find(str, beg=0, end=len(string)) 检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回 - 1
      index(str, beg=0, end=len(string)) 跟 find () 方法一样，只不过如果 str 不在字符串中会报一个异常。
      isalnum() 如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True，否则返回 False
      isalpha() 如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False
      isdigit() 如果字符串只包含数字则返回 True 否则返回 False..
      islower() 如果字符串中包含至少一个区分大小写的字符，并且所有这些 (区分大小写的) 字符都是小写，则返回 True，否则返回 False
      isnumeric() 如果字符串中只包含数字字符，则返回 True，否则返回 False
      isspace() 如果字符串中只包含空白，则返回 True，否则返回 False.
      istitle() 如果字符串是标题化的 (见 title ()) 则返回 True，否则返回 False
      isupper() 如果字符串中包含至少一个区分大小写的字符，并且所有这些 (区分大小写的) 字符都是大写，则返回 True，否则返回 False
      join(seq) 以指定字符串作为分隔符，将 seq 中所有的元素 (的字符串表示) 合并为一个新的字符串
      len(string) 返回字符串长度
      ljust(width[, fillchar]) 返回一个原字符串左对齐，并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。
      lower() 转换字符串中所有大写字符为小写.
      lstrip() 截掉字符串左边的空格或指定字符。
      maketrans() 创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
      max(str) 返回字符串 str 中最大的字母。
      min(str) 返回字符串 str 中最小的字母。
      replace(old, new [, max]) 把 将字符串中的 old 替换成 new, 如果 max 指定，则替换不超过 max 次。
      rfind(str, beg=0,end=len(string)) 类似于 find () 函数，不过是从右边开始查找.
      rindex( str, beg=0, end=len(string)) 类似于 index ()，不过是从右边开始.
      rjust(width[, fillchar]) 返回一个原字符串右对齐，并使用 fillchar (默认空格）填充至长度 width 的新字符串
      rstrip() 删除字符串末尾的空格或指定字符。
      split(str="", num=string.count(str)) 以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串
      splitlines([keepends]) 按照行 ('\r', '\r\n', \n') 分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
      startswith(substr, beg=0,end=len(string)) 检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。
      strip([chars]) 在字符串上执行 lstrip () 和 rstrip ()
      swapcase() 将字符串中大写转换为小写，小写转换为大写
      title() 返回 "标题化" 的字符串，就是说所有单词都是以大写开始，其余字母均为小写 (见 istitle ())
      translate(table, deletechars="") 根据 table 给出的表 (包含 256 个字符) 转换 string 的字符，要过滤掉的字符放到 deletechars 参数中
      upper() 转换字符串中的小写字母为大写
      zfill (width) 返回长度为 width 的字符串，原字符串右对齐，前面填充 0
      isdecimal() 检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。

  • 列表 (list)

    • 在 Python 中，列表（List）是一种有序、可变的数据类型，用于存储多个元素。列表可以包含不同类型的元素，如整数、浮点数、字符串等。
    • 创建列表：可以使用方括号 [] 来创建一个空列表，或者在方括号中用逗号分隔的元素来初始化列表。例如：
      1
      2
      3
      empty_list = []
      numbers = [1, 2, 3, 4, 5]
      fruits = ['apple', 'banana', 'orange']
    • 访问列表元素：可以使用索引来访问列表中的元素。列表的索引从 0 开始，可以使用正向索引和反向索引。当索引超出了范围时，Python 会报一个 IndexError 错误。例如：
      1
      2
      3
      4
      5
      lt = ['小芳', '小乔', '小王', '小杜', '小韩']

      # 提取元素
      print(lt[0])
      print(lt[-1])
    • 修改列表元素：列表是可变的，可以通过索引来修改列表中的元素。
      1
      2
      # 将列表中索引为1的元素修改为'grape'
      fruits[1] = 'grape'
    • 列表操作：可以对列表进行多种操作，包括添加元素、删除元素、切片、长度获取等。
      • 添加元素：可以使用 append() 方法在列表末尾添加一个元素，或使用 insert() 方法在指定位置插入元素。例如：
        1
        2
        fruits.append('pear')
        fruits.insert(1, 'kiwi')
      • 删除元素：可以使用 del 语句或 remove() 方法删除列表中的元素。例如：
        1
        2
        del fruits[0]
        fruits.remove('banana')
      • 切片操作：可以使用切片操作符（[]）截取列表的部分内容。例如：
        1
        2
        3
        4
        5
        6
        7
        8
        # 获取列表中索引从1到3的元素
        sliced_list = numbers[1:4]

        # 清空列表
        lt[:] = []

        # 删除前两个元素
        lt[:2] = []
      • 列表长度：可以使用 len() 函数获取列表的长度。例如：
        1
        length = len(numbers)
      • 列表拼接（+）和重复（*）
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        # 列表可以使用加号 + 进行拼接操作，将两个列表合并为一个新的列表
        list1 = [1, 2, 3]
        list2 = [4, 5, 6]
        result = list1 + list2
        print(result)  # 输出 [1, 2, 3, 4, 5, 6]

        # 列表还可以使用乘号 * 进行重复操作，将列表中的元素重复多次
        list1 = [1, 2, 3]
        result = list1 * 3
        print(result)  # 输出 [1, 2, 3, 1, 2, 3, 1, 2, 3]

        需要注意的是，拼接和重复操作都会生成一个新的列表，原始列表本身不会被修改。

    • 列表方法：列表对象有许多内置方法，可以对列表进行各种操作，如排序、反转、查找元素等。
      方法 描述
      list.append(obj) 在列表末尾添加新的对象
      list.count(obj) 统计某个元素在列表中出现的次数
      list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
      list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
      list.insert(index, obj) 将对象插入列表
      list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
      list.remove(obj) 移除列表中某个值的第一个匹配项
      list.reverse() 反向列表中元素
      list.sort( key=None, reverse=False) 对原列表进行排序
      list.clear() 清空列表
      list.copy() 复制列表

  • 元组 (tuple)

    • 在 Python 中，元组（Tuple）是一种有序、不可变的数据类型。元组可以存储多个元素，可以是不同的数据类型，例如整数、浮点数、字符串等。元组的特点是一旦创建后，其元素和结构不能被修改，是不可变的。
    • 元组使用小括号 () 来表示，元素之间使用逗号 , 分隔。元组中只包含一个元素时，需要在元素后面添加逗号 , 否则括号会被当作运算符使用。示例：
      1
      2
      my_tuple = (1, 2, 3, 'apple', 'banana')
      t = (123,)
    • 可以通过索引来访问元组中的元素，索引从 0 开始。例如：
      1
      2
      # 表示访问元组中的第一个元素，结果为1
      my_tuple[0]
    • 元组支持切片操作，可以使用切片来获取元组的子集。例如：
      1
      2
      # 表示获取元组中索引为1和2的元素，结果为 (2, 3)。
      my_tuple[1:3]
    • 元组还可以进行拼接和重复操作。拼接可以使用加号 +。重复操作可以使用乘号 *，示例：
      1
      2
      3
      4
      5
      6
      7
      my_tuple = (1, 2, 3, 'apple', 'banana')

      # 拼接
      new_tuple = my_tuple + (4, 5)
      print(new_tuple)  # (1, 2, 3, 'apple', 'banana', 4, 5)
      # 重复
      print(my_tuple * 2)  # (1, 2, 3, 'apple', 'banana', 1, 2, 3, 'apple', 'banana')
    • 元组的优点是不可变性，这使得元组在某些情况下更适合使用，例如：用作字典的键（因为键需要是不可变的）。此外，元组也可以用于存储不希望被修改的数据集合。
    • 需要注意的是，虽然元组本身是不可变的，但如果元组中包含可变对象（例如列表），那么这些可变对象可以被修改。因此，元组的不可变性是指元组本身的结构和元素，而不是元组中的可变对象。

  • 集合 (set)

    • 在 Python 中，集合（Set）是一种无序且不重复的数据类型。集合中的元素是唯一的，不会重复出现。集合可以用于去除重复元素、判断元素的存在性以及进行集合运算，如交集、并集、差集等。
    • 集合使用大括号 {} 或者 set() 函数来创建，元素之间使用逗号 , 分隔。注意：创建一个空集合必须用 set() 而不是 {}，因为 {} 是用来创建一个空字典。
      1
      2
      3
      4
      # 创建非空集合
      my_set = {1, 2, 3, 4, 5}
      # 创建空集合
      empty_set = set()
    • 可以使用 set() 函数将其他可迭代对象（如列表、元组、字符串等）转换为集合。例如：
      1
      2
      my_list = [1, 2, 3, 3, 4, 4, 5]
      my_set = set(my_list)
    • 类似列表推导式，同样集合支持集合推导式 (Set comprehension)
      1
      2
      3
      >>> a = {x for x in 'abracadabra' if x not in 'abc'}
      >>> a
      {'r', 'd'}
    • 集合操作：
      • 添加元素：使用 add() 方法向集合中添加单个元素，使用 update() 方法向集合中添加多个元素 
        1
        2
        3
        4
        # 添加单个元素
        my_set.add(4)
        # 添加多个元素
        my_set.update([4, 5, 6])
      • 删除元素：使用 remove() 方法删除指定的元素，如果元素不存在会引发 KeyError 异常。使用 discard() 方法删除指定的元素，如果元素不存在不会引发异常。使用 pop() 方法随机删除并返回集合中的一个元素，因为集合是无序的，所以无法确定删除的是哪个元素。
        1
        2
        3
        4
        5
        6
        # 删除指定的元素，如果元素不存在会引发 KeyError 异常
        my_set.remove(4)
        # 删除指定的元素，如果元素不存在不会引发异常
        my_set.discard(4)
        # 随机删除并返回集合中的一个元素
        my_set.pop()
      • 清空集合：用 clear() 方法清空集合中的所有元素 
        1
        2
        # 清空集合
        my_set.clear()
    • 集合运算：
      • 交集：使用 intersection() 方法或 & 运算符，例如：set1.intersection(set2) 或 set1 & set2。
      • 并集：使用 union() 方法或 | 运算符，例如：set1.union(set2) 或 set1 | set2。
      • 差集：使用 difference() 方法或 - 运算符，例如：set1.difference(set2) 或 set1 - set2。
      • 对称差集：使用 symmetric_difference() 方法或 ^ 运算符，例如：set1.symmetric_difference(set2) 或 set1 ^ set2。
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        set1 = {1, 2, 3}
        set2 = {2, 3, 4}

        # 交集：集合 set1 和 set2 中都包含了的元素
        intersection = set1 & set2
        # 并集：集合 set1 和 set2 中包含的所有元素
        union = set1 | set2
        # 差集：集合 set1 中包含而集合 set2 中不包含的元素
        difference = set1 - set2
        # 对称差集：两个集合中不重复的元素的集合
        symmetric_difference = set1 ^ set2

        print(intersection)  # 输出 {2, 3}
        print(union)  # 输出 {1, 2, 3, 4}
        print(difference)  # 输出 {1}
        print(symmetric_difference)  # 输出 {1, 4}
    • 集合方法：
      方法 描述
      add() 为集合添加元素
      clear() 移除集合中的所有元素
      copy() 拷贝一个集合
      difference() 返回多个集合的差集
      difference_update() 移除集合中的元素，该元素在指定的集合也存在。
      discard() 删除集合中指定的元素
      intersection() 返回集合的交集
      intersection_update() 返回集合的交集。
      isdisjoint() 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
      issubset() 判断指定集合是否为该方法参数集合的子集。
      issuperset() 判断该方法的参数集合是否为指定集合的子集
      pop() 随机移除元素
      remove() 移除指定元素
      symmetric_difference() 返回两个集合中不重复的元素集合。
      symmetric_difference_update() 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
      union() 返回两个集合的并集
      update() 给集合添加元素
      len() 计算集合元素个数

  • 字典 (dict)

    • Python 字典（Dictionary）是一种可变、无序、可迭代的数据结构，用于存储键值对的集合，每个键值对由一个键（key）和一个对应的值（value）组成。
    • 在字典中，键和值之间用冒号 : 分隔，每个键值对之间用逗号 , 分隔。键必须是不可变的数据类型，如字符串、数字或元组，而值可以是任意类型的数据，包括字符串、数字、列表、字典等。
    • 创建字典：
      • 使用花括号 {} 和冒号 : 来定义键值对，多个键值对之间用逗号 , 分隔。例如：
        1
        my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
      • 使用 dict() 函数，将键值对作为参数传递给函数。例如：
        1
        my_dict = dict(key1='value1', key2='value2', key3='value3')
      • 通过将其他可迭代对象（如列表或元组）转换为字典。例如：
        1
        my_dict = dict([('key1', 'value1'), ('key2', 'value2'), ('key3', 'value3')])
      • 创建空字典 
        1
        2
        # 使用大括号 {} 来创建空字典
        empty_dict = {}
    • 访问字典元素：
      • 使用索引操作符 [] 通过键访问对应的值，键不存在时会报错，例如：
        1
        print(my_dict['key1'])  # 输出：value1
      • 使用 dict.get(key, default) 方法获取指定键的值，如果键不存在，则返回默认值。例如：
        1
        print(my_dict.get('key4', 'default_value'))  # 输出：default_value
    • 添加或修改字典元素：
      • 使用索引操作符 [] 来添加或修改键值对。例如：
        1
        2
        3
        my_dict = {'key1': 'value1', 'key2': 'value2'}
        my_dict['key3'] = 'value3'  # 添加键值对（没有则添加键值对）
        my_dict['key2'] = 'new_value'  # 修改值（已存在则修改）
      • 使用 dict.update(other_dict) 方法将其他字典中的键值对更新到当前字典中。例如：
        1
        2
        3
        my_dict = {'key1': 'value1', 'key2': 'value2'}
        other_dict = {'key3': 'value3', 'key4': 'value4'}
        my_dict.update(other_dict)  # 更新字典
    • 删除字典元素：
      • 使用 del 关键字删除指定键的键值对。例如：
        1
        2
        my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
        del my_dict['key2']  # 删除键值对
      • 使用 dict.pop(key) 方法删除并返回指定键的值。例如：
        1
        2
        my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
        value = my_dict.pop('key2')  # 删除并返回值
    • 遍历字典：
      • 使用 for 循环遍历字典的键。例如：
        1
        2
        3
        my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
        for key in my_dict:  # 或：for key in my_dict.keys():
            print(key)  # 输出：key1, key2, key3
      • 使用 for 循环遍历字典的值。例如：
        1
        2
        3
        my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
        for value in my_dict.values():
            print(value)  # 输出：value1, value2, value3
      • 使用 for 循环遍历字典的键值对。例如：
        1
        2
        3
        my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
        for key, value in my_dict.items():
            print(key, value)  # 输出：key1 value1, key2 value2, key3 value3
    • 字典的特性：
      • 无序性：字典中的键值对是无序的，即存储顺序与添加顺序不一定相同。
      • 可变性：字典中的元素可以被修改、添加和删除。
      • 键的唯一性：字典中的键是唯一的，不允许重复。
      • 可迭代性：可以通过循环遍历字典中的键或值。
      • 动态性：字典的大小和内容可以动态地改变。
    • 字典方法
      方法 描述
      len(dict) 返回字典中键值对的数量
      dict.clear() 删除字典内所有元素
      dict.copy() 返回一个字典的浅复制
      dict.fromkeys() 创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
      dict.get(key, default=None) 返回指定键的值，如果键不在字典中返回 default 设置的默认值
      key in dict 如果键在字典 dict 里返回 true，否则返回 false
      dict.items() 以列表返回一个视图对象
      dict.keys() 返回一个视图对象
      dict.setdefault(key, default=None) 和 get () 类似，但如果键不存在于字典中，将会添加键并将值设为 default
      dict.update(dict2) 把字典 dict2 的键 / 值对更新到 dict 里
      dict.values() 返回一个视图对象
      pop(key[,default]) 删除字典 key（键）所对应的值，返回被删除的值
      popitem() 返回并删除字典中的最后一对键和值

  • 强制类型转换

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    int()   # 转换成整型
    float() # 转换成浮点数
    str()   # 转换成字符串
    list()  # 抓换成列表
    tuple() # 转化成元组
    set()   # 转化成集合
    dict()  # 转换成字典

    l = [('name', 'xiaoming'), ('age', 18)]
    print(type(l))
    # 将列表转换成字典
    l1 = dict(l)
    print(l1)
    print(type(l1))
    # 将字典转化成列表，转换后的列表由字典的键组成
    l2 = list(l1)
    print(l2)

    列表去重：列表 => 集合 => 列表

  • 获取变量的地址

    1
    2
    3
    # 获取变量的地址
    a = 10
    print(id(a))

    不必深究变量的地址问题