【Python】数据类型

数值

1. 整数（int）：
   • 表示整数，可以是正数、负数或零，通过不同的前缀还可以区分为二进制，八进制，十进制（默认），十六机制。
   • x = 5（默认十进制）
   • x = 0b0101 二进制
   • x = 0o005 八进制
   • x = 0x005 十六进制
2. 浮点数（float）：
   • 表示有小数点的数字。
   • y = 3.14
   • 有时候浮点数表达式的计算可能不准确
3. 布尔值（bool）：
   • 表示逻辑值，只有两个取值：True和False，一般情况下，非空和非零的值等价True，为空为零的值等价False。
   • is_true = True
   • 布尔值为False：False、整数0、浮点数0.0、None、空字符串、空列表、空元组、空字典、空集合
4. 空值（NoneType）：
   • 表示一个特殊的空值，通常用于表示变量未赋值或函数没有返回值。
   • x = None

列表

列表的基本概念：

• 使用方括号 [] 来表示列表，列表中的元素用逗号 , 分隔。

• 列表是一种可以包含不同类型元素的数据结构，这意味着列表中可以有整数、浮点数、字符串、甚至是其他列表或者不同的类型数据结构等等。

  my_list = [10, 3.14, "Hello", True, [1, 2, 3], {'name': 'Alice', 'age': 30}]
  
  print(my_list[0])    # 访问第一个元素，整数类型
  print(my_list[1])    # 访问第二个元素，浮点数类型
  print(my_list[2])    # 访问第三个元素，字符串类型
  print(my_list[3])    # 访问第四个元素，布尔类型
  print(my_list[4])    # 访问第五个元素，另一个列表类型
  print(my_list[5])    # 访问第六个元素，字典类型
  

• 列表是一种有序的数据结果，每一个元素都映射一个索引，列表中的元素可以通过索引来访问，可以使用正向索引（从左往右数，从 0 开始）和负向索引（从右往左数，从 -1 开始）来访问列表中的元素。

  # 定义一个包含一些元素的列表
  my_list = ['apple', 'banana', 'orange', 'grape', 'melon']
  
  # 使用索引访问列表中的元素
  first_fruit = my_list[0]  # 第一个元素，'apple'
  second_fruit = my_list[1]  # 第二个元素，'banana'
  last_fruit = my_list[-1]  # 最后一个元素，'melon'
  

• 列表是一种可变的数据结构，即可以通过索引来修改、添加或删除其中的元素，列表的长度和元素的值都可以发生变化。

列表的常用方法和操作：

• 列表具有丰富的方法和操作，例如：append()、insert()、remove()、pop()、extend()、sort()、reverse() 等等。
• 这些方法可以用来在列表中添加、删除、修改元素，或者对列表进行排序、翻转等操作。

1. append()：

   • append() 方法用于在列表末尾添加一个元素，可以添加整个列表、词典等。

   • 语法：list.append(element)

   • 参数：element - 要添加到列表末尾的元素。

   • 示例：

     my_list = [1, 2, 3]
     my_list.append(4)
     print(my_list)  # 输出：[1, 2, 3, 4]
     
     my_list.append([1, 2, 3])
     print(my_list)  # 输出：[1, 2, 3, 4, 1, 2, 3]
     

2. extend()：

   • extend() 方法用于将另一个列表中的所有元素添加到当前列表的末尾。使用 + 也可完成此操作

   • 语法：list.extend(iterable)

   • 参数：iterable - 可迭代对象，如列表、元组、集合等。

   • 示例：

     my_list = [1, 2, 3]
     another_list = [4, 5, 6]
     my_list.extend(another_list)
     print(my_list)  # 输出：[1, 2, 3, 4, 5, 6]
     

3. insert()：

   • insert() 方法用于在指定索引位置插入一个元素，可以添加整个列表、词典等。

   • 语法：list.insert(index, element)

   • 参数：index - 要插入元素的索引位置，element - 要插入的元素。

   • 示例：

     my_list = [1, 2, 3]
     my_list.insert(1, 1.5)
     print(my_list)  # 输出：[1, 1.5, 2, 3]
     
     my_list.insert(1, [1, 2])
     print(my_list)  # 输出：[1, [1, 2], 1.5, 2, 3]
     

4. remove()：

   • remove() 方法用于删除列表中指定的元素（第一个匹配的元素）。

   • 语法：list.remove(element)

   • 参数：element - 要删除的元素。

   • 示例：

     my_list = [1, 2, 3, 2, 4]
     my_list.remove(2)
     print(my_list)  # 输出：[1, 3, 2, 4]
     

5. pop()：

   • pop() 方法用于删除并返回列表中指定位置的元素。

   • 语法：list.pop([index])

   • 参数：index（可选） - 要删除的元素的索引，默认为最后一个元素。

   • 返回值：返回被删除的元素。

   • 示例：

     my_list = [1, 2, 3]
     popped_element = my_list.pop(1)
     print(popped_element)  # 输出：2
     print(my_list)         # 输出：[1, 3]
     
     # 使用这个也可以实现
     del my_list[0]
     print(my_list)         # 输出：[3]
     

6. sort()：

   • sort() 方法用于对列表进行排序。

   • 语法：list.sort(key=None, reverse=False)

   • 参数：

     • key（可选） - 指定一个函数用于从每个列表元素中提取比较键，默认为 None（直接比较元素本身）
     • reverse（可选） - 如果为 True，则按降序排序。

   • 示例：

     my_list = [3, 1, 2]
     my_list.sort()
     print(my_list)  # 输出：[1, 2, 3]
     

7. reverse()：

   • reverse() 方法用于反转列表中的元素顺序。

   • 语法：list.reverse()

   • 示例：

     my_list = [1, 2, 3]
     my_list.reverse()
     print(my_list)  # 输出：[3, 2, 1]
     

列表的迭代和遍历：

• 可以使用 for 循环来遍历列表中的元素，也可以使用列表推导式等方式进行迭代操作。

• 通过循环遍历列表，可以对列表中的每个元素进行处理，或者对列表进行相应的操作。

  # 创建一个包含元素的列表
  my_list = [1, 2, 3, 4, 5]
  
  # 使用 for 循环遍历列表中的元素并打印
  for element in my_list:
      print(element)
  

列表的内部实现原理：

• 在 Python 中，列表通常是通过动态数组来实现的，即在内存中分配一块连续的空间来存储列表中的元素。
• 当列表中的元素数量超过当前分配空间时，Python 会自动分配更大的空间，并将元素复制到新的空间中，以保证列表的可变性和性能。

不对二维和多维列表做讲述

字典

字典的基本概念：

• 字典是一种键值对（key-value）的数据结构，每个元素都由一个键和一个对应的值组成。键必须是唯一的，但值可以重复。

• 字典是无序的，即没有按照元素添加的顺序来存储和访问元素。

• 字典是可变的，可以通过键来引用、添加、修改或删除其中的元素。

  # 定义一个字典包含个人信息
  person_info = {
      'name': 'Alice',
      'age': 30,
      'address': '123 Main St'
  }
  
  # 将元素赋值给另一个变量
  new_var = person_info['address']
  
  # 添加新的元素
  person_info['email'] = 'alice@example.com'
  
  # 修改元素
  person_info['age'] = 31
  
  # 删除元素
  del person_info['address']
  

• 使用大括号 {} 来表示字典，键值对之间用冒号: 分隔，冒号: 左侧是键，右侧是值，每键值对之间用逗号 , 分隔。

字典的常用方法和操作：

• 字典具有丰富的方法和操作，例如：keys()、values()、items()、get()、pop()、update() 等等。
• 这些方法可以用来获取字典中的键、值、键值对，或者对字典进行添加、删除、更新等操作。

1. keys()：

   • keys() 方法用于获取字典中所有的键。

   • 语法：dict.keys()

   • 返回值：返回一个包含字典所有键的可迭代对象。

   • 示例：

     my_dict = {'a': 1, 'b': 2, 'c': 3}
     print(my_dict.keys())  # 输出：dict_keys(['a', 'b', 'c'])
     

2. values()：

   • values() 方法用于获取字典中所有的值。

   • 语法：dict.values()

   • 返回值：返回一个包含字典所有值的可迭代对象。

   • 示例：

     my_dict = {'a': 1, 'b': 2, 'c': 3}
     print(my_dict.values())  # 输出：dict_values([1, 2, 3])
     

3. items()：

   • items() 方法用于获取字典中所有的键值对。

   • 语法：dict.items()

   • 返回值：返回一个包含字典所有键值对的可迭代对象，每个元素是一个元组，包含键和对应的值。

   • 示例：

     my_dict = {'a': 1, 'b': 2, 'c': 3}
     print(my_dict.items())  # 输出：dict_items([('a', 1), ('b', 2), ('c', 3)])
     

4. get()：

   • get() 方法用于根据键获取字典中对应的值，如果键不存在，则返回指定的默认值（默认为 None）。

   • 语法：dict.get(key, default=None)

   • 参数：key - 要获取值的键，default（可选） - 键不存在时返回的默认值。

   • 返回值：返回键对应的值，如果键不存在，则返回默认值。

   • 示例：

     my_dict = {'a': 1, 'b': 2, 'c': 3}
     value = my_dict.get('b')
     print(value)  # 输出：2
     

5. pop()：

   • pop() 方法用于删除并返回字典中指定键的值。

   • 语法：dict.pop(key, default=None)

   • 参数：key - 要删除的键，default（可选） - 键不存在时返回的默认值。

   • 返回值：返回被删除的键对应的值，如果键不存在，则返回默认值或抛出 KeyError 异常。

   • 示例：

     my_dict = {'a': 1, 'b': 2, 'c': 3}
     value = my_dict.pop('b')
     print(value)  # 输出：2
     print(my_dict)  # 输出：{'a': 1, 'c': 3}
     

6. update()：

   • update() 方法用于更新字典中的键值对，可以接受一个字典或者包含键值对的可迭代对象作为参数。

   • 语法：dict.update([other])

   • 参数：other - 字典或包含键值对的可迭代对象。

   • 示例：

     my_dict = {'a': 1, 'b': 2}
     other_dict = {'b': 3, 'c': 4}
     my_dict.update(other_dict)
     print(my_dict)  # 输出：{'a': 1, 'b': 3, 'c': 4}
     

词典的迭代和遍历：

• 可以使用 for 循环来遍历字典中的键、值或键值对，也可以使用字典推导式等方式进行迭代操作。

• 通过循环遍历字典，可以对字典中的每个键值对进行处理，或者对字典进行相应的操作。

  for item in Zidian:  # 使用for in循环获取的也是键
  	print(item,Zidian.get(item)) # 前面是键，后面是值
  
  for key,value in user.items():
  	print("Key:" + key)
  	print("Value:" + value)
  

词典的内部实现原理：

• 在 Python 中，字典通常是通过哈希表来实现的，即通过哈希函数将键映射到对应的存储位置，以实现快速的查找和插入操作。
• 当发生哈希冲突时，Python 使用链表或其他方法来处理冲突，保证字典的性能和可靠性。

集合

集合（set）的基本概念：

• 使用大括号 {} 或 set() 函数来表示集合，元素之间用逗号 , 分隔，不存在像词典那样的键值对。
• 集合是一种无序的数据结构，这意味着集合不可以利用索引来操作数据。
• 集合是一种不重复的数据结构，存储的数据不能是相同的。
• 集合中的元素可以是任意不可变类型的数据，如整数、浮点数、字符串、元组等，但不能包含可变类型的数据，如列表、字典、集合等。若存在，则抛出TypeError异常。
• 集合是可变的，可以通过添加或删除元素来修改集合。

集合的常用方法和操作：

• 集合具有丰富的方法和操作，例如：add()、remove()、discard()、pop()、clear()、union()、intersection()、difference() 等等。
• 这些方法可以用来添加、删除、查找、合并、比较等操作集合中的元素。

1. add()：

   • add() 方法用于向集合中添加一个元素。

   • 语法：set.add(element)

   • 参数：element - 要添加的元素。

   • 示例：

     my_set = {1, 2, 3}
     my_set.add(4)
     print(my_set)  # 输出：{1, 2, 3, 4}
     

2. remove()：

   • remove() 方法用于删除集合中指定的元素，如果元素不存在则抛出 KeyError 异常。

   • 语法：set.remove(element)

   • 参数：element - 要删除的元素。

   • 示例：

     my_set = {1, 2, 3}
     my_set.remove(2)
     print(my_set)  # 输出：{1, 3}
     

3. discard()：

   • discard() 方法用于删除集合中指定的元素，如果元素不存在则不进行任何操作。

   • 语法：set.discard(element)

   • 参数：element - 要删除的元素。

   • 示例：

     my_set = {1, 2, 3}
     my_set.discard(2)
     print(my_set)  # 输出：{1, 3}
     

4. pop()：

   • pop() 方法用于移除并返回集合中的一个随机元素。

   • 语法：set.pop()

   • 返回值：返回被移除的元素。

   • 示例：

     my_set = {1, 2, 3}
     popped_element = my_set.pop()
     print(popped_element)  # 输出：随机一个元素
     print(my_set)           # 输出：移除随机元素后的集合
     

5. clear()：

   • clear() 方法用于移除集合中的所有元素，使集合变为空集。

   • 语法：set.clear()

   • 示例：

     my_set = {1, 2, 3}
     my_set.clear()
     print(my_set)  # 输出：set()
     

集合的数学运算：

• 集合支持并集、交集、差集等数学运算，可以使用相应的方法或运算符来实现。
• 这些运算可以用来对集合进行合并、查找共同元素、找出不同元素等操作。

1. union()：

   • union() 方法用于返回两个集合的并集，即包含两个集合中所有不重复的元素。

   • 语法：set.union(*others)

   • 参数：others - 其他要并集的集合。

   • 示例：

     set1 = {1, 2, 3}
     set2 = {3, 4, 5}
     union_set = set1.union(set2)
     print(union_set)  # 输出：{1, 2, 3, 4, 5}
     

2. intersection()：

   • intersection() 方法用于返回两个集合的交集，即包含两个集合中共同的元素。

   • 语法：set.intersection(*others)

   • 参数：others - 其他要交集的集合。

   • 示例：

     set1 = {1, 2, 3}
     set2 = {3, 4, 5}
     intersection_set = set1.intersection(set2)
     print(intersection_set)  # 输出：{3}
     

3. difference()：

   • difference() 方法用于返回两个集合的差集，即包含在第一个集合中但不在第二个集合中的元素。

   • 语法：set.difference(*others)

   • 参数：others - 其他要比较的集合。

   • 示例：

     set1 = {1, 2, 3}
     set2 = {3, 4, 5}
     difference_set = set1.difference(set2)
     print(difference_set)  # 输出：{1, 2}
     

集合的迭代和遍历：

• 通过 for 循环，可以依次迭代集合中的每个元素，并对每个元素进行相应的操作。

• 通过集合推导式，可以对集合中的每个元素进行操作，并生成一个新的集合。

  my_set = {1, 2, 3, 4, 5}
  
  # 使用 for 循环遍历集合中的元素并打印
  for element in my_set:
      print(element)
  

元组

元组（tuple）的基本概念：

• 使用小括号**()来表示元组，元素之间用逗号,** 分隔。

• 元组是一种有序的数据结构，可以使用索引访问元组，但元组是不可变的，即一旦创建就不能修改其内容，因此可以作为字典的键、集合的元素等。

  # 创建一个元组
  my_tuple = (10, 20, 30, 40, 50)
  
  # 使用索引访问元组中的元素并打印
  print("First element:", my_tuple[0])   # 访问第一个元素
  print("Second element:", my_tuple[1])  # 访问第二个元素
  print("Last element:", my_tuple[-1])   # 使用负向索引访问最后一个元素
  

• 元组可以包含任意类型的元素，包括整数、浮点数、字符串、元组等。

元组的常用方法和操作：

• 元组相对于列表的方法和操作较少，但仍包括一些常用的方法，例如：index()、count() 等。
• 这些方法可以用来查找元组中的元素索引、统计元素出现次数等。

1. index()：

   • index() 方法用于查找指定元素在元组中的索引。

   • 语法：tuple.index(element[, start[, end]])

   • 参数：element - 要查找的元素，start（可选） - 查找起始位置的索引，end（可选） - 查找结束位置的索引。

     可选参数 start 和 end 用于指定搜索范围的起始和结束位置（包含起始位置但不包含结束位置），如果未指定则默认搜索整个元组。

   • 返回值：返回指定元素在元组中第一次出现的索引，如果未找到则抛出 ValueError 异常。

   • 示例：

     my_tuple = (1, 2, 3, 2)
     index = my_tuple.index(2)
     print(index)  # 输出：1
     
     index = my_tuple.index(2, 2, 4)
     print(index)  # 输出：3
     

2. count()：

   • count() 方法用于统计元组中指定元素的出现次数。

   • 语法：tuple.count(element)

   • 参数：element - 要统计出现次数的元素。

   • 返回值：返回指定元素在元组中出现的次数。

   • 示例：

     my_tuple = (1, 2, 3, 2)
     count = my_tuple.count(2)
     print(count)  # 输出：2
     

主要的遍历方法

• 通过 for 循环，可以依次迭代元组中的每个元素，并对每个元素进行相应的操作。

• 通过 enumerate() 函数，可以同时获取元组中每个元素的索引和值，然后进行相应的操作

  my_tuple = (1, 2, 3, 4, 5)
  
  # 使用 for 循环遍历元组中的元素并打印
  for element in my_tuple:
      print(element)
  

  my_tuple = (1, 2, 3, 4, 5)
  
  # 使用 enumerate() 函数遍历元组中的元素及其索引并打印
  for index, element in enumerate(my_tuple):
      print("Index:", index, "Element:", element)
  

字符串

字符串的基本概念：

• 字符串是一种有序的字符序列，用于表示文本数据。
• 字符串是不可变的，即一旦创建就不能修改其内容，但可以通过一些操作来生成新的字符串。
• 使用单引号 ' '、双引号 " " 或三引号 ''' '''、""" """ 来表示字符串，其中三引号用于表示多行字符串。

字符串的常用方法和操作：

• 字符串具有丰富的方法和操作，例如：split()、join()、strip()、replace()、find()、startswith() 、endswith()等等。
• 这些方法可以用来对字符串进行分割、连接、去除空白字符、替换、查找等操作。

1. split()：

   • split() 方法用于将字符串分割成子串，并返回一个包含分割结果的列表。

   • 语法：str.split(sep=None, maxsplit=-1)

   • 参数：

     • sep（可选） - 分隔符，默认为任意空白字符
     • maxsplit（可选） - 最大分割次数。

   • 返回值：返回一个包含分割后子串的列表。

   • 示例：

     my_string = "apple,banana,orange"
     splitted = my_string.split(',')
     print(splitted)  # 输出：['apple', 'banana', 'orange']
     

2. join()：

   • join() 方法用于将列表中的字符串元素连接成一个字符串。

   • 语法：separator.join(iterable)

   • 参数：separator - 连接的分隔符，iterable - 包含字符串的可迭代对象。

   • 返回值：返回连接后的字符串。

   • 示例：

     fruits = ['apple', 'banana', 'orange']
     joined = ','.join(fruits)
     print(joined)  # 输出：'apple,banana,orange'
     

3. strip()：

   • strip() 方法用于去除字符串两端的空白字符（空格、制表符、换行符等）。

   • 语法：str.strip(chars=None)

   • 参数：chars（可选） - 要去除的指定字符。

   • 返回值：返回去除空白字符后的字符串。

   • 示例：

     my_string = "   hello   "
     stripped = my_string.strip()
     print(stripped)  # 输出：'hello'
     

4. replace()：

   • replace() 方法用于替换字符串中的指定子串。

   • 语法：str.replace(old, new[, count])

   • 参数：old - 要被替换的子串，new - 替换后的新子串，count（可选） - 替换次数。

   • 返回值：返回替换后的新字符串。

   • 示例：

     my_string = "apple pie"
     replaced = my_string.replace('apple', 'banana')
     print(replaced)  # 输出：'banana pie'
     

5. find()：

   • find() 方法用于在字符串中查找指定子串，并返回第一次出现的索引，如果未找到则返回 -1。

   • 语法：str.find(sub[, start[, end]])

   • 参数：sub - 要查找的子串，start（可选） - 查找起始位置的索引，end（可选） - 查找结束位置的索引。

   • 返回值：返回第一次出现的子串的索引，如果未找到则返回 -1。

   • 示例：

     my_string = "hello world"
     index = my_string.find('world')
     print(index)  # 输出：6
     

6. startswith()：

   • startswith() 方法用于判断字符串是否以指定的前缀开头。

   • 语法：str.startswith(prefix[, start[, end]])

   • 参数：

     • prefix - 要检查的前缀，
     • start（可选） - 检查起始位置的索引，
     • end（可选） - 检查结束位置的索引。

   • 返回值：如果字符串以指定前缀开头则返回 True，否则返回 False。

   • 示例：

     my_string = "hello world"
     starts_with_hello = my_string.startswith('hello')
     print(starts_with_hello)  # 输出：True
     

字符串的格式化：

字符串的格式化是指在字符串中插入变量、表达式或者其他字符串，并按照一定的格式进行排列和显示。在 Python 中，有多种方式可以进行字符串的格式化，包括使用字符串的 format() 方法、使用 f-strings（格式化字符串字面值）以及旧式的 % 运算符。在下面示例中，{} 或者 % 被用作占位符，后面的变量会按照顺序依次替换这些占位符。而在 f-strings 中，使用 {} 包含变量名或表达式即可，Python 会在运行时将这些表达式的值插入到字符串中。

• 使用 format() 方法：

  name = "Alice"
  age = 30
  formatted_string = "My name is {} and I am {} years old.".format(name, age)
  print(formatted_string)
  

  My name is Alice and I am 30 years old.

  还可以在{}进行如下操作：

  1. 指定变量名：
     在大括号中可以使用变量名，对应 .format() 方法中的关键字参数名。

     pythonCopy code
     formatted_string = "My name is {name} and I am {age} years old.".format(name="Alice", age=30)
     print(formatted_string)
     

     My name is Alice and I am 30 years old.

  2. 索引位置：
     在大括号中也可以使用参数的索引位置。

     pythonCopy code
     formatted_string = "My name is {0} and I am {1} years old.".format("Alice", 30)
     print(formatted_string)
     

     My name is Alice and I am 30 years old.

  3. 格式指令：

  • 更多格式指令

    1. <、>、=：分别表示左对齐、右对齐和居中对齐，默认是左对齐。

       "{:<9s}".format("hello")  # 左对齐
       "{:>9s}".format("hello")  # 右对齐
       "{:^9s}".format("hello")  # 居中对齐
       

    2. 宽度：使用数字指定字段的最小宽度。

       "{:10s}".format("hello")  # 总宽度为10个字符
       

    3. 精度：在小数部分指定数字的精度。

       "{:.2f}".format(3.14159)  # 保留两位小数
       

    4. 符号：控制数字的正负号显示。

       "{:+}".format(10)  # 显示正负号
       "{:-}".format(-10)  # 仅显示负号
       

    5. 填充：指定填充字符。

       "{:_>10s}".format("hello")  # 使用下划线填充
       "{:^10s}".format("hello")  # 使用空格填充（默认）
       

    6. 类型：指定格式化的类型。

       "{:b}".format(10)  # 二进制表示
       "{:x}".format(255)  # 十六进制表示
       

• 使用 f-strings（格式化字符串字面值）：

  name = "Alice"
  age = 30
  formatted_string = f"My name is {name} and I am {age} years old."
  print(formatted_string)
  

  My name is Alice and I am 30 years old.

• r"string"：raw，原始字符串，用于防止转义字符的特殊处理。

• u"string"：Unicode 字符串，在 Python 2 中用于指示字符串为 Unicode 类型，但在 Python 3 中默认所有字符串都是 Unicode 类型，因此此前缀不再需要。

• f"string": 格式化字符串字面值，可以在字符串中直接引用变量和表达式，并将它们的值插入到字符串中。

• 使用旧式的 % 运算符：

  name = "Alice"
  age = 30
  formatted_string = "My name is %s and I am %d years old." % (name, age)
  print(formatted_string)
  

  My name is Alice and I am 30 years old.

字符串的驻留机制：

字符串的驻留机制是指在 Python 中对相同的字符串字面值进行内存优化，使得它们共享相同的内存地址，以减少内存使用和提高性能。在 Python 中，字符串的驻留机制遵循以下原则：

1. 对于长度不超过20个字符的字符串，Python 在程序编译时会自动将其驻留（intern），即使是不同的字符串对象，只要它们的值相同，都会指向相同的内存地址。

   s1 = "hello"
   s2 = "hello"
   print(id(s1), id(s2))  # 两个字符串对象的内存地址相同
   

2. 对于长度超过20个字符的字符串，Python 不会自动驻留，即使它们的值相同，也不会共享内存地址。

   好像还是一样的，不确定的事情等以后再考验

   s1 = "a" * 21
   s2 = "a" * 21
   print(id(s1), id(s2))  # 两个字符串对象的内存地址不同
   

3. 使用 intern() 函数可以强制将一个字符串驻留，使得它与其他相同值的字符串共享内存地址。

   s1 = "hello"
   s2 = intern("hello")
   print(id(s1), id(s2))  # 两个字符串对象的内存地址相同
   

   import sys
   
   s1 = "hello"
   s2 = sys.intern("hello")
   print(id(s1), id(s2))  # 两个字符串对象的内存地址相同
   

虽然字符串驻留机制可以节省内存，但也可能导致意外的内存泄漏问题，因为驻留的字符串不会被垃圾回收。因此，不要在运行时动态地创建大量长度不超过20个字符的字符串，以避免潜在的内存泄漏问题。

综合示例

# 定义学生的数据结构
# 使用字典来存储学生信息，其中键是学生ID（字符串），值是另一个字典，包含姓名、年龄、成绩（列表）和联系方式（元组）

students = {
    "S001": {
        "name": "Alice",
        "age": 20,
        "grades": [88, 92, 85],
        "contact": ("alice@email.com", "123-456-7890")
    },
    "S002": {
        "name": "Bob",
        "age": 22,
        "grades": [76, 85, 90],
        "contact": ("bob@email.com", "098-765-4321")
    },
    "S003": {
        "name": "Carol",
        "age": 21,
        "grades": [92, 88, 91],
        "contact": ("carol@email.com", "345-678-9012")
    }
}

# 显示所有学生信息的函数
def display_students():
    print("Displaying all students' information:")
    for student_id, info in students.items():
        print(f"Student ID: {student_id}")
        print(f"Name: {info['name']}")
        print(f"Age: {info['age']}")
        print(f"Grades: {info['grades']}")
        print(f"Contact Email: {info['contact'][0]}, Phone: {info['contact'][1]}")
        print("-" * 40)

# 添加新学生的函数
def add_student(student_id, name, age, grades, email, phone):
    if student_id in students:
        print("Error: Student ID already exists.")
        return

    students[student_id] = {
        "name": name,
        "age": age,
        "grades": grades,
        "contact": (email, phone)
    }
    print(f"Student {name} added successfully.")

# 删除学生的函数
def delete_student(student_id):
    if student_id in students:
        del students[student_id]
        print(f"Student {student_id} has been deleted.")
    else:
        print("Error: Student ID not found.")

# 搜索学生信息的函数
def search_student(student_id):
    if student_id in students:
        info = students[student_id]
        print(f"Found student: {student_id}")
        print(f"Name: {info['name']}")
        print(f"Age: {info['age']}")
        print(f"Grades: {info['grades']}")
        print(f"Contact Email: {info['contact'][0]}, Phone: {info['contact'][1]}")
    else:
        print("Student not found.")

# 计算学生平均成绩的函数
def calculate_average(student_id):
    if student_id in students:
        grades = students[student_id]['grades']
        average = sum(grades) / len(grades)
        print(f"Average grades for {students[student_id]['name']}: {average:.2f}")
    else:
        print("Error: Student ID not found to calculate average.")


# 主函数，用于运行脚本
def main():
    # 测试添加和删除功能
    add_student("S004", "David", 23, [85, 80, 88], "david@email.com", "456-789-0123")
    display_students()
    delete_student("S002")
    display_students()

    # 测试搜索和计算平均成绩功能
    search_student("S001")
    calculate_average("S001")

    add_student("S005", "Eve", 19, [92, 87, 90], "eve@email.com", "987-654-3210")
    delete_student("S003")
    search_student("S004")
    calculate_average("S004")

    display_students()

if __name__ == "__main__":
    main()

本篇文章，如有错误，欢迎指正，感激不尽。