python AI应用开发编程实战 大模型实战基础（数据存储类型列表与字典）（二）

大模型开发中，需要和自己的业务融合，我们要对自己的数据处理，熟悉外理excle  word  pdf 数据然后处理后可以放到向量数据库，或者直接Assistants API传到大模型引用，不管怎么样数据处理是

必须要操握的必备技能，基础编程能力是大模型使用的天花板，好，现在我们来看看一下数据处理基础相关的知识。

数据类型：

Python中常见的数据类型包括数字（int、float、complex）和字符串。python的数值类型会自动转换，相对灵活，

1. 整数（int）: 例如，在32位机器上，整数的位数为32位，取值范围为-2**31 到 2**31-1，（4个G,）在64位系统上，整数的位数为64位，取值范围为-2**63 到 2**63-1。

2. 长整数（long）: Python中的长整数没有指定位宽，即没有限制长整数数值的大小。自从Python2.2起，如果整数发生溢出，Python会自动将整数数据转换为长整数。在之后的Python版本中，不加字母" L" 也不会导致严重后果了。

3. 浮点数（float）: 例如，3.23 和 52.3E-4 是浮点数的例子。浮点数用来处理实数，即带有小数的数字。类似于C语言中的double类型，占8个字节(64位)，其中52位表示底，11位表示指数，剩下的一位表示符号。

4. 复数（complex）: 复数由实数部分和虚数部分组成。一般形式为 x + yj，其中的 x 是复数的实数部分，y 是复数的虚数部分。
   示例
   type（2**32）//  输出int
   type（2**64）//  输出long      在python 3  对数据类型会自动转，所以显示都 是int 类型，不用花思维去看类型
   浮点数外形像小数，但小数不只包括有浮点，在数学中不完全一样，但是编程课不用这么细究，虚数复数这些对一般 程序员来说暂时用不到

5. 

   布尔值 对于二种状态的表达，比如真或假，0或1  可以用布尔来表达，

   布尔（boolean）是Python中的一种数据类型，用于表示真（True）或假（False）的值。在Python中，布尔类型通常用于控制流程和逻辑运算。在Python中，True和False是内置的布尔值，始终以大写字母开头。可以使用以下语法创建布尔变量：

   x = 5
   y = 10
   
   print(x > y)  # 输出False
   print(x < y)  # 输出Truef

   
   以下示列二：

   x = True
   y = False
   
   print(x and y)  # 输出False
   print(x or y)   # 输出True
   print(not x)    # 输出False
   

   　　

6. 字符串
   字符串如果用拼接，会创建一个变量空间，所以不建议用拼接。用变量引用的方式可以最高效率提高性能，

   在Python中，字符串处理是一种常见的操作，用于对文本数据进行操作和转换。Python提供了丰富的内置方法和函数来处理字符串，包括查找、替换、拆分、连接、大小写转换等。

   下面是一些常见的字符串处理方法及示例：

7. 示例一  字符串拼接
   str1 = "Hello"
   str2 = "World"
   result = str1 + " " + str2
   print(result)  # 输出：Hello World
   ​
   示例二：字符串查找：使用find()方法来查找子字符串在主字符串中的位置。
   myString = "Hello, welcome to Python world." 
   print(myString.find("welcome")) # 输出：7
   示例三，字符串替换：
   使用replace()方法来替换字符串中的指定子串。
   myString = "I like apples and oranges."
   newString = myString.replace("apples", "bananas")
   print(newString) # 输出：I like bananas and oranges.　　
   示例：大小写转换
   myString = "Hello, World!"
   print(myString.lower())  # 输出：hello, world!
   print(myString.upper())  # 输出：HELLO, WORLD!
   
   

   Python3 字符串处理常用方法有很多，下面是一个简单的文档，列出了其中一些常用的方法及其描述：
   
   # Python3 字符串处理常用方法
   ## 1. 首字母大写
   **方法**：`str.capitalize()`
   **描述**：返回字符串的副本，其中第一个字符为大写，其余为小写。
   **示例**：
   ```python
   s = "hello world"
   print(s.capitalize())  # 输出：Hello world
   
   2. 居中
   方法：str.center(width[, fillchar])
   描述：返回一个指定的宽度居中的字符串，两侧用指定的字符填充（默认为空格）。
   示例：
   python
   s = "hello"
   print(s.center(10, '*'))  # 输出：***hello***
   
   3. 计数子串
   方法：str.count(sub[, start[, end]])
   描述：返回子串在字符串中出现的次数。
   示例：
   python
   s = "hello world, hello python"
   print(s.count("hello"))  # 输出：2
   
   4. 解码
   方法：str.encode(encoding='utf-8', errors='strict')
   
   注意：实际上这个方法是编码，但字符串本身有一个与之对应的decode方法，通常用于字节串。在Python3中，字符串已经是Unicode，所以更常用的是encode。但为了完整性，这里也提及一下。
   
   描述：以指定的编码将字符串编码为字节串。
   
   5. 结束检查
   方法：str.endswith(suffix[, start[, end]])
   
   描述：检查字符串是否以指定的后缀结束。
   
   示例：
   
   python
   s = "hello.txt"
   print(s.endswith(".txt"))  # 输出：True
   6. 展开制表符
   方法：str.expandtabs(tabsize=8)
   
   描述：返回字符串的副本，其中所有的制表符（'\t'）都被替换为一个或多个空格，具体取决于当前列和给定的制表符大小。
   
   7. 查找子串
   方法：str.find(sub[, start[, end]])
   描述：返回子串在字符串中首次出现的最低索引，如果没有找到则返回-1。
   示例：
   python
   s = "hello world"
   print(s.find("world"))  # 输出：6
   
   8. 格式化字符串
   方法：str.format(*args, **kwargs)
   描述：格式化字符串，类似于旧式的%格式化，但更加灵活和强大。
   示例：
   
   python
   s = "Hello, {}!"
   print(s.format("world"))  # 输出：Hello, world!
   9. 索引子串
   注意：实际上并没有直接名为index的方法来获取子串，但str.index(sub[, start[, end]])方法与find类似，不同之处在于，如果子串不存在，它会引发一个异常。
   
   10. 判断字母、数字等
   str.isalpha()：检查字符串是否只包含字母字符。
   str.isdigit()：检查字符串是否只包含数字字符。
   str.isalnum()：检查字符串是否只包含字母和数字字符。
   ... 还有其他相关方法。
   
   11. 连接
   方法：str.join(iterable)
   描述：将迭代器中的元素连接成一个字符串。
   示例：
   
   python
   s = "-"
   print(s.join(["a", "b", "c"]))  # 输出：a-b-c
   12. 转换为小写/大写
   str.lower()：返回字符串的小写版本。
   str.upper()：返回字符串的大写版本。
   str.swapcase()：返回字符串的大小写反转版本。
   str.title()：返回字符串的标题化版本（每个单词的首字母大写）。
   str.casefold()：返回字符串的小写版本，用于更强大的大小写不敏感的比较。
   13. 去除空白
   str.strip([chars])：返回字符串的副本，去除两侧的空白字符（默认为空格）。也可以指定其他字符。
   str.lstrip([chars])：只去除左侧的空白或指定字符。
   str.rstrip([chars])：只去除右侧的空白或指定字符。
   14. 分割字符串
   方法：str.split(separator=None, maxsplit=-1)
   
   描述：使用指定的分隔符将字符串分割为一个列表。如果不指定分隔符，则默认使用空白字符。
   示例：
   python
   s = "apple,banana,cherry"
   print(s.split(","))  # 输出：['apple', 'banana', 'cherry']
   
   15. 替换子串
   方法：str.replace(old, new[, count])
   描述：返回字符串的副本，其中所有的old子串都被new子串替换。如果指定了count，则只替换前count个匹配项。
   示例：
   python
   s = "hello world, hello python"
   print(s.replace("hello", "hi"))  # 输出：hi world, hi python
   以上只是Python3字符串处理的一部分常用方法，实际上还有很多其他的方法和功能等待你去探索和使用！
   

   　　

   Python 3最重要的新特性大概要算是对文本和二进制数据作了更为清晰的区分。文本总是Unicode，由str类型表示，二进制数据则由bytes类型表示。Python 3不会以任意隐式的方式混用str和bytes，正是这使得两者的区分特别清晰。你不能拼接字符串和字节包，也无法在字节包里搜索字符串（反之亦然），也不能将字符串传入参数为字节包的函数（反之亦然）。这是件好事。

   但是有时候文本也可能以二进制保存，所以需要用到编吗与解码，编码用encode 参数如果不传py2.7为系统默认编码，如果是py3  默认为utf-8    如果需要解码我编码请参考以下示例：

   # 字符串转字节（编码）
   string = "你好，世界！"
   bytes_data = string.encode("utf-8")
   print(bytes_data)

   如果是二进制解码成字符则用以下示例：在这个示例中，首先我们将一个字符串"你好，世界！"转换为字节数据，然后再将这个字节数据解码为字符串并打印出来。

   # 字节转字符串（解码）
   bytes_data = b'\xe4\xbd\xa0\xe5\xa5\xbd\xef\xbc\x8c\xe4\xb8\x96\xe7\x95\x8c\xef\xbc\x81'
   string = bytes_data.decode("utf-8")
   print(string)
   

   　

   　计算机进制

   进制是我们使用的数字系统的一种表示方式。在计算机科学中，常用的进制有十进制、二进制、八进制和十六进制。

   十进制是人类最常用的进制，使用了0-9这10个数字。但在计算机科学中，底层的物理电路更适合处理二进制数（使用0和1表示）而不是十进制数。因此，在计算机科学中，采用其他进制来表示数字有其优势。

   二进制（base-2）是计算机内部常用的进制，因为计算机使用开关电路，其中一个开关只有两个状态，即开或关，可以用0和1来表示。二进制数位运算简单，便于计算机内部的逻辑和算术运算，同时可以提高存储效率。

   八进制（base-8）和十六进制（base-16）是对于二进制的缩写表示，它们能够更紧凑地表示二进制数，方便人类阅读和书写。八进制使用0-7这8个数字来表示，十六进制使用0-9和A-F这16个字符（A代表10，B代表11，以此类推）来表示。

   进制的使用解决了计算机内部物理特性和人类可读性之间的矛盾。二进制提供了计算机底层处理数据的方式，八进制和十六进制则提供了一种更方便的表示和书写方式，使得编程和计算机操作更加高效和可读。

   在编程中，我们经常需要将不同进制的数字进行转换，例如将二进制转换为十进制或将十六进制转换为二进制。Python提供了丰富的函数和方法来进行进制转换，使我们能够方便地在不同的进制之间进行转换和处理数据。

   1. 二进制转换为其他进制：

      • 二进制转十进制：从二进制数的最右侧开始，每一位乘以对应的权值（2的幂），然后将相加得到的结果即为十进制数。
      • 二进制转八进制：将二进制数每三位进行分组，并将每组转换为对应的八进制数。
      • 二进制转十六进制：将二进制数每四位进行分组，并将每组转换为对应的十六进制数。

   2. 十进制转换为其他进制：

      • 十进制转二进制：使用整数除以2并取余的方式，重复该过程直到商为0，最后将取余结果倒序排列即为二进制数。
      • 十进制转八进制：使用整数除以8并取余的方式，重复该过程直到商为0，最后将取余结果倒序排列即为八进制数。
      • 十进制转十六进制：使用整数除以16并取余的方式，重复该过程直到商为0，最后将取余结果倒序排列，并将10-15分别表示为A-F，即为十六进制数。

   3. 八进制和十六进制转换为其他进制：

      • 八进制和十六进制转十进制：将每位上的数乘以对应的权值（8的幂或16的幂），然后将相加得到的结果即为十进制数。
      • 八进制和十六进制转二进制：将每位上的数转换为对应的三位二进制数（八进制）或四位二进制数（十六进制）。

   这些转换方法基于数学推理，根据不同进制的权值和数位来进行运算和计算。通过这些数学推理方式，我们可以在不同进制之间进行转换。在实际编程中，使用内置的转换函数和方法能够更方便地进行进制之间的转换。

   　

8. 以下是Python中进行不同进制之间转换的示例代码：

   1. 二进制转换为十进制：

   binary_num = '1010' decimal_num = int(binary_num, 2) 

   print(decimal_num) # 输出：10 ​

   1. 十进制转换为二进制：

    

   decimal_num = 10 binary_num = bin(decimal_num)

    print(binary_num) # 输出：0b1010 ​

   1. 十进制转换为八进制：

   decimal_num = 10 octal_num = oct(decimal_num) 

   print(octal_num) # 输出：0o12 ​

   1. 八进制转换为十进制：

   octal_num = '12' decimal_num = int(octal_num, 8) 

   print(decimal_num) # 输出：10 ​

   1. 十进制转换为十六进制：

   decimal_num = 16 hex_num = hex(decimal_num)

    print(hex_num) # 输出：0x10 ​

   1. 十六进制转换为十进制：

   hex_num = '10' decimal_num = int(hex_num, 16) 

   print(decimal_num) # 输出：16
   在python 中二进制转16进制方式如下，通常我们平时都 用函数实现转换，所以转换的原理请百度，这儿采用最简单 的函数帮我们完成，

   binary_num = '11010101'  # 二进制数
   decimal_num = int(binary_num, 2)  # 将二进制数转换为十进制数
   hex_num = hex(decimal_num)  # 将十进制数转换为十六进制数
   print(hex_num)  # 输出：0xd5
   

   　python 中的三元运算符 可以优化if 语句，以下示例一个if 语句，然后用三元语句来优化，x if condition else y

   在Python中，虽然没有严格意义上的三元运算符（类似于其他语言中的条件运算符），但可以使用条件表达式来实现类似功能。一种常见的三元运算符有时也被称为条件表达式，其语法如下：

   # 使用 if 语句进行条件判断
   num = 10
   if num % 2 == 0:
       result = "偶数"
   else:
       result = "奇数"
   print(result)
   

   # 使用三元运算符来优化代码
   num = 10
   result = "偶数" if num % 2 == 0 else "奇数"
   print(result)
   

   示例二：

   age = 20
   status = "成年" if age >= 18 else "未成年"
   print(status)  # 如果age >= 18输出："成年"，否则输出："未成年"
   

   　　

   集合元字典，和列表
   

   在Python 3中，集合、列表和字典是三种常用的数据结构，它们各自有不同的特性和用途。以下是关于这三种数据结构的文档整理：需要注意的是，在实际使用中，集合、列表和字典可以相互转换，例如使用 list()、set() 和 dict() 函数。此外，这些数据结构还可以嵌套使用，以满足更加复杂的数据处理需求。

   集合（Set）：

   • 定义：集合是一个无序的、不包含重复元素的序列。
   • 创建：可以使用大括号 {} 来创建一个集合，或者使用 set() 函数。
   • 操作：支持交集（&）、并集（|）、差集（-）等集合操作。
   • 用途：适合用于去重和集合运算等场景。

   列表（List）：

   • 定义：列表是一个有序的、可包含重复元素的序列。
   • 创建：可以使用方括号 [] 或 list() 函数来创建一个列表。
   • 操作：支持索引访问、切片、元素添加、删除和修改等。
   • 用途：适合用于存储和操作一系列有序的数据。

   字典（Dictionary）：

   • 定义：字典是一个无序的、键值对（key-value）集合。
   • 创建：可以使用大括号 {} 来创建一个字典，键值对之间用逗号分隔，键和值用冒号连接。
   • 操作：支持通过键来访问、添加、删除和修改值。
   • 用途：适合用于关联数据的存储和快速检索。

   Python中的list（列表）是一种有序且可变的数据结构，用于存储多个元素。其特点包括：

   1. 有序性：列表中的元素按照特定的顺序排列，每个元素都有一个索引（位置编号），第一个元素的索引是0，第二个是1，以此类推。
   2. 可变性：列表是可变的，这意味着可以对列表进行添加、删除或修改元素的操作。
   3. 灵活性：列表中的元素不需要具有相同的类型，这为存储不同类型的数据提供了极大的灵活性。
   4. 可迭代性：列表是一个可迭代的对象，可以使用for循环遍历列表中的每个元素。
   5. 切片操作：列表支持切片操作，可以通过指定索引范围来获取列表的子集。
   6. 内置函数：Python提供了list()函数，可以将其他可迭代对象转换为列表，也可以创建空列表。
      关于列表示列：

      # 创建一个列表
      l = [1, 2, 3, 4, 5]
      print(l)  # 输出: [1, 2, 3, 4, 5]  
      
      # 访问元素
      print(l[0])  # 输出: 1
      print(l[-1])  # 输出: 5  
      
      # 修改元素
      l[0] = 10
      print(l)  # 输出: [10, 2, 3, 4, 5]  
      
      # 添加元素
      l.append(6)
      print(l)  # 输出: [10, 2, 3, 4, 5, 6]  
      
      # 删除元素
      l.remove(3)
      print(l)  # 输出: [10, 2, 4, 5, 6]  
      
      # 切片操作
      print(l[1:4])  # 输出: [2, 4, 5]
      

      　　关于集合set   由于集合是唯一的，所以就可以有了多了交集差集合集的运算，还有一个区别是这是一个大括号

      # 创建一个集合
      s = {1, 2, 3, 4, 4, 5}  # 注意：集合会自动去重
      print(s)  # 输出: {1, 2, 3, 4, 5}  
      
      # 添加元素
      s.add(6)
      print(s)  # 输出: {1, 2, 3, 4, 5, 6}  
      
      # 删除元素
      s.remove(4)
      print(s)  # 输出: {1, 2, 3, 5, 6}  
      
      # 检查元素是否存在
      if 3 in s:
          print("3 在集合中")
      else:
          print("3 不在集合中")  
      
      # 集合运算
      s1 = {1, 2, 3, 4}
      s2 = {3, 4, 5, 6}  
      
      # 交集
      print(s1 & s2)  # 输出: {3, 4}  
      
      # 并集
      print(s1 | s2)  # 输出: {1, 2, 3, 4, 5, 6}  
      
      # 差集（s1中有但s2中没有的元素）
      print(s1 - s2)  # 输出: {1, 2}  
      
      # 对称差集（在s1或s2中，但不同时出现在s1和s2中的元素）
      print(s1 ^ s2)  # 输出: {1, 2, 5, 6}
      

      　　最后说一下字典，字典的目的是为了保存一个数据有健值对，比如key  和  value 这样的格式保存，所以就注意格式：

      # 创建一个字典
      d = {'name': 'Alice', 'age': 25, 'city': 'New York'}
      print(d)  # 输出: {'name': 'Alice', 'age': 25, 'city': 'New York'}  
      
      # 访问元素
      print(d['name'])  # 输出: Alice  
      
      # 修改元素
      d['age'] = 26
      print(d)  # 输出: {'name': 'Alice', 'age': 26, 'city': 'New York'}  
      
      # 添加元素
      d['country'] = 'USA'
      print(d)  # 输出: {'name': 'Alice', 'age': 26, 'city': 'New York', 'country': 'USA'}  
      
      # 删除元素
      del d['city']
      print(d)  # 输出: {'name': 'Alice', 'age': 26, 'country': 'USA'}  
      
      # 检查键是否存在
      if 'name' in d:
          print("name 在字典中")
      else:
          print("name 不在字典中")　
      
      基础练习：上机试验：
      假设有一个班,学生有张三，李四，王五，赵六 那么这个列表样是这样的。names = ["张三"，“李四”，“王五”，“赵六”]  
      //备注：手工打的这儿引用有问题，需要英文状态下的引用才行
      打印这个班所有同学   print(names)
      打印这个列表第二个同学  pring([1])
      打印最后二个同学  print([-1:-2]) 错误理解 //python是从左到右的，但是pring([-2: -1])也不行，它是顾始不顾属，最后一位取不到，只能是print([-2:])
      打印最后一同学  print(names[-1])
      追加一个同学    naems.append("黄八")
      按顺序插入  names.insert(1,"陈9")
      改变位置为二的同学为谢哥  names[2]= "谢哥"  记住这儿只能是下标
      删除方法可以del 和 remove 和pop   如果pop的参数输入下标，功能就和del一样了，默认删除最后一个
      例如： names.remove("张三") 示例二： del names[1]  示例三，删除最后一个   names.pop()
      如果有相同重复的，打印一共有多少个 print(names.count("张三"))

      如何查看列表有那些方法可以在编辑时查看代码提示：

      

      
      Python 列表是一个可变序列，提供了丰富的方法来操作列表中的元素。以下是 Python 列表的一些主要方法和它们的功能：
      append(x): 在列表的末尾添加一个元素。
      extend(L): 将另一个列表的所有元素添加到当前列表的末尾。
      insert(index, x): 在指定索引位置插入一个元素。
      remove(x): 移除列表中第一个出现的指定元素。
      pop([index]): 移除并返回指定索引位置的元素，如果未指定索引则默认移除并返回最后一个元素。
      clear(): 移除列表中的所有元素。
      index(x): 返回列表中第一个出现的指定元素的索引。
      count(x): 返回列表中指定元素出现的次数。
      sort(key=None, reverse=False): 对列表中的元素进行排序，key 参数用于指定排序依据的函数，reverse 参数用于指定是否降序排列。
      reverse(): 反转列表中元素的顺序。
      copy(): 返回列表的一个浅拷贝（浅复制）。
      __getitem__(index): 通过索引获取列表中的元素。
      __setitem__(index, value): 通过索引设置列表中的元素。
      __delitem__(index): 通过索引删除列表中的元素。
      __len__(): 返回列表中的元素个数。
      __add__(other): 将两个列表连接起来。
      __mul__(n): 返回列表重复 n 次的结果。
      这些只是 Python 列表的一些常用方法，它们提供了对列表进行各种操作的能力。注意，有些方法会修改原列表（如 append, extend, insert, remove, pop, clear, sort, reverse），而有些方法则不会（如 index, count, copy）。此外，列表还支持使用 in 关键字来检查一个元素是否存在于列表中，以及使用 for 循环来遍历列表中的元素。
      

      　　其它方法示例

      在Python中，列表的 ​copy​方法用于创建列表的浅拷贝。所谓浅拷贝是指只复制了原始列表中的每个元素的引用，而不是复制元素本身。这意味着如果原始列表中的元素是可变对象（如列表、字典等），那么在浅拷贝后修改原始列表中的可变对象的操作会影响到新列表，因为它们共享同一份可变对象。
      
      下面是一个简单的例子来说明浅拷贝的概念：
      # 创建一个原始列表
      original_list = [1, [2, 3], 4]
      # 使用copy方法进行浅拷贝
      new_list = original_list.copy()
      # 修改原始列表中可变对象的值
      original_list[1][0] = 5
      # 打印两个列表的值
      print("原始列表：", original_list)
      print("新列表：", new_list)
      # 创建一个原始列表
      # 使用copy方法进行浅拷贝
      new_list = original_list.copy()
      # 修改原始列表中可变对象的值
      original_list[1][0] = 5
      # 打印两个列表的值
      print("原始列表：", original_list)
      print("新列表：", new_list)​
      上述代码中，我们首先创建了一个包含整数和列表的原始列表 ​original_list​，然后对其使用 ​copy​方法进行浅拷贝得到 ​new_list​。接着，
      我们修改了原始列表中嵌套列表的第一个元素的值。最后输出原始列表和新列表的值，你会发现新列表也受到了原始列表元素的影响，因为它们共享相同的嵌套列表。
      因此，在上面的示例中，原始列表和新列表共享同一个子列表对象的引用，所以对新列表中子列表的修改也会影响到原始列表中对应的子列表。
      这就是浅复制的特性所致。如果希望完全独立地复制所有嵌套对象，可以使用深度复制工具 ​copy.deepcopy()​来实现。需要导入一个copy的包

      import copy
      # 创建一个原始列表，其中包含子列表
      original_list = [1, [2, 3], 4]
      # 使用 deepcopy 进行深度复制
      new_list = copy.deepcopy(original_list)
      # 修改新列表中子列表的值
      new_list[1][0] = 5
      # 打印两个列表的值
      print("原始列表：", original_list)
      print("新列表：", new_list)
      

      　附录：实际浅拷备的方法，

      对于大多数情况下，这三种方法都可以实现浅复制。但是需要注意它们的细微差别。

      1. 使用切片运算符 ​org = names[:]​：这种方式是最常见和简单的浅复制方法之一，对于列表来说是可行的，可以创建一个与原始列表相同的新列表。

      2. 使用列表的构造函数 ​org = list(names)​：这种方式也是一种常见的浅复制方法，通过将原始列表作为参数传递给 ​list()​构造函数创建新列表并复制元素。

      3. 使用 ​copy.copy(names)​：这种方式使用了 ​copy​模块中的 ​copy()​函数进行浅拷贝，也可以实现浅复制。函数 ​copy()​会创建原始对象的浅拷贝副本。

      需要注意的是，在某些特殊情况下，这些方法可能有不同的行为。例如，如果列表中的元素是可变对象（如列表、字典等），

      那么浅复制之后的新列表中的这些元素仍然是原始列表中相同对象的引用。这意味着对新列表中的元素进行修改会影响原始列表，因为它们共享相同对象的引用。

      实现浅复制的方法：这儿采用list(names),只是进行了函数封装。

      def shallow_copy(obj):
          if isinstance(obj, list):
              return list(obj)
          elif isinstance(obj, dict):
              return dict(obj)
          else:
              return obj
      # 创建一个原始列表，其中包含子列表
      original_list = [1, [2, 3], 4]
      # 使用自定义的 shallow_copy 函数进行浅拷贝
      new_list = shallow_copy(original_list)
      # 修改新列表中子列表的值
      new_list[1][0] = 5
      
      # 打印两个列表的值
      print("原始列表：", original_list)
      print("新列表：", new_list)
      

      　　以下代码是实现深复制，核习原理就是new 一个新对角，然后将老对象的值重新赋值过来。

      def deep_copy(obj):
          if isinstance(obj, dict):  //判断是不是字典类型
              new_dict = {}   //new 一个新字典
              for key, value in obj.items():  遍历key 和值，
                  new_dict[key] = deep_copy(value)
              return new_dict
          elif isinstance(obj, list):   // 判断是不是一个列表，如果是new 一个新列表
              new_list = []
              for item in obj: //  遍历一个新列表的值追加到一个新列表
                  new_list.append(deep_copy(item))
              return new_list
          else:
              return obj
      # 创建一个原始列表，其中包含子列表
      original_list = [1, [2, 3], 4]
      # 使用自定义的 deep_copy 函数进行深度复制
      new_list = deep_copy(original_list)
      # 修改新列表中子列表的值
      new_list[1][0] = 5
      # 打印两个列表的值
      print("原始列表：", original_list)
      print("新列表：", new_list)
      

      　　还有一种特殊的类型，和列表一样，叫元组，功能是不能修改，所以样子是括号，不是【】。大家可以把它当只读列表，

      以查和统记，如果你写的程序，希望是不能改变的，比如数据库存，帐号密码不能改的地方，

      本次作业  
      写一个商品购物示列，先要求用户输入工资收入，然后程序输出商品列表，
      请用户选择商品编号进行购物，用户选择商品后，再要求用户输入购买的数量，
      用户输入后，计算用户的余额是不是够扣除，如果够就直接扣除，输入成功购商品编号，和扣除多少钱，
      还剩多少钱，如果不够刚提示余额不够，
      在完成作业的时候需要了解一下二个函数  enumrate()  可迭代对象，它的作用是将一个例表循环展示出来，语法为：

      my_list = ['apple', 'banana', 'cherry', 'date']
      for index, value in enumerate(my_list):
          print(index, value)以

      以下三种方式功能一样，请理解一下思路和语法，并上机调试成功。
      
      #示列一，只购买一次就退出
       定义商品列表，包含商品名称和价格
      products = [
          {'name': '商品1', 'price': 10},
          {'name': '商品2', 'price': 20},
          {'name': '商品3', 'price': 30},
          {'name': '商品4', 'price': 40},
          {'name': '商品5', 'price': 50}
      ]
      
      # 获取用户输入的工资金额
      salary = input("请输入您的工资金额：")  # 获取用户输入的工资金额字符串
      try:
          salary = float(salary)  # 尝试将输入的工资金额字符串转换为浮点数
      except ValueError:  # 如果转换失败，说明用户输入的不是合法数字
          print("输入无效，请输入有效的数值。")
          exit()  # 退出程序
      
      # 输出商品列表
      print("商品列表：")
      for i, product in enumerate(products):
          print(f"{i+1}. {product['name']} - 价格：{product['price']}")
      
      # 获取用户选择的商品编号
      choice = input("请输入您要购买的商品编号（输入0退出）：")  # 获取用户输入的商品编号字符串
      if not choice.isdigit():  # 验证输入是否为整数
          print("输入无效，请输入有效的整数。")
          exit()  # 退出程序
      choice = int(choice)  # 将商品编号字符串转换为整数
      if choice == 0:  # 如果用户输入0，退出程序
          exit()
      elif choice < 1 or choice > len(products):  # 验证商品编号是否在有效范围内
          print("无效的商品编号。")
          exit()  # 退出程序
      
      # 获取用户输入的购买数量
      quantity = input("请输入购买数量：")  # 获取用户输入的购买数量字符串
      if not quantity.isdigit():  # 验证输入是否为整数
          print("输入无效，请输入有效的整数。")
          exit()  # 退出程序
      quantity = int(quantity)  # 将购买数量字符串转换为整数
      if quantity <= 0:  # 验证购买数量是否大于零
          print("购买数量必须大于零。")
          exit()  # 退出程序
      
      # 计算购买金额，检查是否足够扣除
      product = products[choice-1]  # 获取用户选择的商品信息
      total_price = product['price'] * quantity  # 计算购买商品的总金额
      if total_price > salary:  # 检查用户余额是否足够支付
          print("余额不足，无法购买。")
          exit()  # 退出程序
      
      # 扣除购买金额并计算余额
      salary -= total_price
      
      # 输出购买信息
      print(f"成功购买商品：{product['name']}")
      print(f"扣除金额：{total_price}，剩余金额：{salary}")
      

      　示例二： 这个代码可以多次购买，一直买到没有钱为止，但是也经购买的商品并没有统计，在示列三中继续完善

      # 定义一个简单的商品列表
      products = {
          1: {"name": "商品A", "price": 100},
          2: {"name": "商品B", "price": 200},
          3: {"name": "商品C", "price": 150},
          # 可以继续添加更多商品
      }  
      
      # 主程序
      while True:
          # 获取用户输入的工资
          salary = float(input("请输入您的工资："))
          balance = salary  
      
          # 显示商品列表
          print("商品列表：")
          for id, product in products.items():
              print(f"{id}. {product['name']} - 价格：{product['price']}元")  
      
          # 获取用户选择的商品编号
          choice = int(input("请选择商品编号（输入0退出）："))
          if choice == 0:
              print("程序已退出。")
              break
          if choice not in products:
              print("无效的商品编号，请重新选择。")
              continue  
      
          selected_product = products[choice]
          product_name = selected_product['name']
          product_price = selected_product['price']  
      
          # 获取用户输入的购买数量
          quantity = int(input(f"请输入您要购买{product_name}的数量："))  
      
          # 计算总价
          total_price = product_price * quantity  
      
          # 检查余额是否足够
          if total_price > balance:
              print("余额不足，购买失败。")
              continue  
      
          # 扣除金额
          balance -= total_price  
      
          # 输出购买成功信息
          print(f"购买成功！您购买了{quantity}个{product_name}，总金额：{total_price}元。")
          print(f"余额还剩：{balance}元。")  
      
          # 询问是否继续购物
          continue_shopping = input("是否继续购物？(y/n) ").strip().lower()
          if continue_shopping != 'y':
              print("感谢您的购物，程序已退出。")
              break
      

      　　以上代码实现了用户输入工资金额、选择商品、输入购买数量等操作，并根据用户的选择计算扣除金额和余额。程序中包含了对用户输入的验证，以确保输入的有效性。随着用户的交互操作，程序逐步进行数据处理和输出结果。

      但是如查用户多次购买后应记用户购买的商品，以下换个写法完善一下写法，在定义商品属性时不用字典，直接纯列表实现，列表加上元组实现，

      示例三:

      # 先定义一个商品属性，用列表中套元组
      product_list = [
          ('iphon',6900),
          ('MinMi',2900),
          ('huawei920',3500),
          ('oppo',2500),
          ('coffee',10600)
          ('Boot',12000)
      ]
      # 用与存放也购买的商品的列表
      shopping_list = []
      
      # 先要求用户输入收入,salary是保存用户的收入
      salary = input("请输入你的工资收入")
      # isdigit()​是字符串对象的一个方法，用于检查字符串是否仅包含数字字符（0至9）
      if salary.isdigit():
          salary = int(salary)
          while True:
              for index,item in enumerate(product_list):
                  print(index,item)
              user_choice = input("选择商口编号")
              # 如果用户有输入数字
              if user_choice.isdigit():
                  user_choice = int(user_choice)
                  # 用户输入的数字只能在列表的大小之间
                  if user_choice < len(product_list) and user_choice >= 0:
                  #    获取用户输入的索引中的列表的数据
                     p_item = product_list[user_choice]
                  #    如果商品的价格小与用户的金额
                     if p_item[1] <= salary:
                      #    将这个用户选中的购买的商品放到也购买的列表中
                         shopping_list.append(p_item)
                      #    将用户的金额减掉
                         salary -= p_item[1]
                         print("也经成功购买了一个商品")
                     else:
                         print("你也经没有钱了")
                  else:
                   print("商品不存在")
              elif user_choice == "q":
                  # 如果用户输入q则退了， 退出前提示一下商品和用户的钱
      
                  print("----------------shopping list--------")
                  for p in shopping_list:
                      print(p)
                  print("Your current bakance",salary)
                  exit()
              else:
                  # 如果用户输入的不是Q 也不是有效数字，比如大过了列表的索引
                  print("invalid option")
      

      　　

      # 先定义一个商品属性，用列表中套元组
      product_list = [
          ('iphon',6900),
          ('MinMi',2900),
          ('huawei920',3500),
          ('oppo',2500),
          ('coffee',10600)
          ('Boot',12000)
      ]
      # 用与存放也购买的商品的列表
      shopping_list = []
      
      # 先要求用户输入收入,salary是保存用户的收入
      salary = input("请输入你的工资收入")
      # isdigit()​是字符串对象的一个方法，用于检查字符串是否仅包含数字字符（0至9）
      if salary.isdigit():
          salary = int(salary)
          while True:
              for index,item in enumerate(product_list):
                  print(index,item)
              user_choice = input("选择商口编号")
              # 如果用户有输入数字
              if user_choice.isdigit():
                  user_choice = int(user_choice)
                  # 用户输入的数字只能在列表的大小之间
                  if user_choice < len(product_list) and user_choice >= 0:
                  #    获取用户输入的索引中的列表的数据
                     p_item = product_list[user_choice]
                  #    如果商品的价格小与用户的金额
                     if p_item[1] <= salary:
                      #    将这个用户选中的购买的商品放到也购买的列表中
                         shopping_list.append(p_item)
                      #    将用户的金额减掉
                         salary -= p_item[1]
                         print("也经成功购买了一个商品")
                     else:
                         print("你也经没有钱了")
                  else:
                   print("商品不存在")
              elif user_choice == "q":
                  # 如果用户输入q则退了， 退出前提示一下商品和用户的钱
      
                  print("----------------shopping list--------")
                  for p in shopping_list:
                      print(p)
                  print("Your current bakance",salary)
                  exit()
              else:
                  # 如果用户输入的不是Q 也不是有效数字，比如大过了列表的索引
                  print("invalid option")