devbox
AllinToyou
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

python数据结构实验设计(单链表)：通讯录管理_python数据结构课程设计

作者：AllinToyou | 2024-03-10 19:43:01

赞

踩

python数据结构课程设计

摘要

本课程设计结合本学期所学的数据结构和以前学习的python程序语言和c语言知识，数组、函数、结构体、指针、链表、文件读取操作等等，设计开发一个简单的通讯录管理程序。设计开发这个系统需要用到链表、文件读取操作、结构体、函数、指针、等C语言知识。本课程设计将会实现的功能包括：读取计算机文件里的通讯录联系人信息（姓名、号码、分组），并生成以名字为排序依据的单链表、统计联系人个数、对联系人信息进行准确查找和模糊查找、新增和删除联系人以及将两个通讯录合并。本着简单、易用的设计原则，设计出一款通讯录管理的程序。  

一、课程设计目的及内容

目的：用 python设计一个具有单向链表结构的通讯录管理程序，用于查询和修改

等便捷化操作通讯录信息文件。 

内容：

定义一个包含手机联系人信息（姓名，电话，分组）的链表，使其具有如下功能：

        (1) 从计算机已保存的文件读入联系人信息,并用直接插入排序法从无到有建立以姓名为排序 依据的单链表；

        (2) 统计联系人个数；

         (3) 根据联系人姓名或电话进行查找，成功返回联系人记录；

         (4) 实现通过姓名的部分字眼进行查询时，显示包含该字眼的所有联系人记录；

         (5) 对于一个从键盘数据的新增联系人，能插入到已排好序的链表中；

        (6) 删除指定姓名或电话的联系人记录。 

创新功能：

实现两个手机通讯录链表的合并，合并之后仍然以名字为关键字排序。相同姓名、相同电话号码的记录删除其中一个，相同姓名、不同电话号码的记录通过输出询问进行电话号码合并或分别保存。

 

二、算法及设计过程分析

1.总流程

 

2.主界面

每个功能对应一个模块，模块引用读取文件后生成的单链表信息，其中修改后的链表也会写入文件 

3.文件处理与生成单链表

         （1）使用.csv文件的优点：每一行都是一个数据元素作为节点，而每个数据项都存放在一个单元格里（如右图所示），从而对其进行读取就非常简单了。在python中，对csv文件的读取会每行以列表的默认形式输出，而列表只需要输入下标即可输出每行每列的信息，从而输入到链表时每个结点里面的数据也是一个保存着联系人信息的列表，然后对链表的结点处理也能按照列表方式进行，非常方便。

        （2）由于在python中，中文字符串的比较经常会出错，比如：

>>> "啊">"吧"

True

        很明显，”啊”在中文里的拼音应该小于”吧”，而且如果比较的两个字符串里的中文长度不一样比较结果也千变万化。所以需要进行对中文转拼音后再进行比较，可以完全解决这个问题。所以编写了以下代码进行转换拼音比较（需要第三方库）：

  1. #中文字符串比较问题
  2. from pypinyin import pinyin,Style
  3. from itertools import chain
  4. def toPinyin(s):
  5.     return ' '.join(chain.from_iterable(pinyin(s, style=Style.TONE3)))

结果输出也非常有效，也可以看出，中文被转换成了拼音形式，能正确进行中文比较了。

>>> print(toPinyin("啊")>toPinyin("吧"))

False

>>> print(toPinyin("数据结构"))

shu4 ju4 jie2 gou4

4.查看所有联系人信息

 

这个很简单，直接打印链表即可。

但是存在两个问题：

一是链表直接打印只会返回一串形如 <address_book.Linklist.LinkedList object at 0x0000028984E5F130> 的十六进制的地址，所以打印需要将链表遍历一遍所有结点，因此重写链表的repr或str函数，该函数就是在类里面遍历一遍所有内容，然后返回一个对象的string，就可以直接打印链表了。

二是由于链表的数据元素以列表形式存放，肯定每个数据项的长度不一，因此输出后对齐就非常重要了。而python里面可以用ljust()或rjust()进行左或右对齐。

5.查看人数

直接调用链表函数ListLength()就可以了查看链表长度（即总人数）了。

而查看分组人数就需要先筛选出所有分组，然后再统计每个分组的人数，用两个循环就完成了。

6.查找联系人（以姓名或号码为依据）

 

 

7.对姓名或号码输入关键字进行模糊查找

 

 8.添加联系人

9.删除联系人 

输入信息后，遍历链表。若在链表中查找到该数据项则删除，否则提示无该联系人。

修改源通讯录文件：遍历文件的每一行的相关数据项（名字和号码），搜索到即删除该行信息。

10.合并两个通讯录

         输入两个文件路径后生成两个链表，若出现相同的联系人信息则合并，相同的名字不同的电话号码则分别输出两个信息后询问是合并号码还是分别保存

三、实验结果分析与总结

1.实验结果

        程序设计的运行结果比较理想，但是也有许多不足。比如排版尚未完全对齐，原版本在合并链表时发现相同的信息没有显示出来，左图。所以答辩结束后及时进行了修改，右图。

 2.总结

        通过完成这个通讯录管理的程序，很大程度上进一步了解了有关链表和结构体课程理论知识，这也是单纯的课堂上学不到的。“实践即是检验真理的唯一标准”，只有通过自己动手，才能更加了解理论知识，也才能更好地去一步步熟悉运用。

        做程序不仅仅是敲代码这么简单。当然，扎实的编程基础是最基本的，但是更需要的是注意力的集中和清晰地逻辑思维能力，这样在设计算法的时候才不会那么容易被自己写的东西绕晕，最好是在本子上写出或脑海里形成一个脉络框架然后一步步完成。最后再细心调试，修改bug，优化程序编译界面，添加必要注释，这一点也非常重要，因为有时候数据太多导致面板太乱，自己也会忘了数据内容（在做排序比较时改bug改到凌晨三点，最后发现居然是少打了个半括号...）。

        其次，团队合作能力也非常重要，总有擅长和不擅长的，所以在队伍里主动承担自己擅长的部分，遇到自己不熟悉的小组内一起解决，这样能大大提高工作效率。

四、完整代码

文件夹下：__init__.py为空文件，方便导入同目录下的模块包, .csv文件需要自己新建并以右图格式存放信息，首行为标注信息，第一列姓名，第二列号码，第三列分组

 

 

1.单链表模块（LinkList.py）

  1. #此模块为单链表以及各个函数的定义模块
  2.  
  3. class LNode:
  4.     """链表结点，名称为LNode"""
  5.     def __init__(self, elem: int or str, next=None):
  6.         self.elem = elem    #结点数据域
  7.         self.next = next    #结点指针域
  8.  
  9.  
  10. class LinkedList:
  11.     """链表"""
  12.     def __init__(self):
  13.         #链表初始化
  14.         self.head = None    #头结点指针域为空
  15.  
  16.     def ListEmpty(self):
  17.         """判断是否为空链表，头节点为None则是空"""
  18.         return self.head is None
  19.  
  20.     def ListLength(self):
  21.         """求链表的长度"""
  22.         p = self.head
  23.         count = 0
  24.         while p:
  25.             count += 1
  26.             p = p.next
  27.         return count
  28.  
  29.     def ListClear(self):
  30.         """清空链表"""
  31.         self._head = None
  32.  
  33.  
  34.     def LocateElem(self, value: int or str):
  35.         # 根据值查找节点，函数返回结点
  36.         p = self.head
  37.         while p and p.elem != value:
  38.             p = p.next
  39.         if p==None:
  40.             return None
  41.         else:
  42.             return p
  43.  
  44.     def LocateElem_first(self, value: int or str):
  45.         # 根据值查找节点第一个元素项，函数返回是否查找到
  46.         p = self.head
  47.         while p and p.elem[0] != value:
  48.             p = p.next
  49.         if p==None:
  50.             return False
  51.         else:
  52.             return True
  53.  
  54.  
  55.     def GetElem(self, position: int or str):
  56.         # 根据索引位置查找节点，需要挨个遍历，返回数据域的值
  57.         p = self.head
  58.         index = 0
  59.         while p and index != position:
  60.             p = p.next
  61.             index += 1
  62.         if p==None:
  63.             return None
  64.         else:
  65.             print(p.elem)
  66.             return p.elem
  67.  
  68.  
  69. ##########################################################
  70.     #前插法
  71.     def insert_node_to_head(self, node):    #创建新节点插入表头，因之后函数需要用到插入新节点，所以单独创建函数
  72.         if node:
  73.             node.next = self.head
  74.             self.head = node
  75.  
  76.     def insert_value_to_head(self, value: int or str):     #将数据赋予表头结点数据域
  77.         node = LNode(value)
  78.         self.insert_node_to_head(node)
  79.  
  80.  
  81.  
  82. ##########################################################
  83.     def insert_elem_to_last(self, elem):
  84.         #尾插法
  85.         node = LNode(elem)
  86.         p = self.head
  87.         if not p:
  88.             self.head = node
  89.         else:
  90.             while p.next:
  91.                 p = p.next
  92.             p.next = node
  93.  
  94. ##########################################################
  95.     def insert_node_after(self, node, new_node):
  96.         #插在指定元素后
  97.         if not node or not new_node:
  98.             return
  99.         new_node.next = node.next
  100.         node.next = new_node
  101.  
  102.     def insert_value_after(self, old_node, new_value):
  103.         new_node = LNode(new_value)
  104.         self.insert_node_after(old_node, new_node)
  105.  
  106. #########################################################
  107.     def insert_node_before(self, node, new_node):
  108.         #插在指定元素前
  109.         if not self.head or not node or not new_node:
  110.             return
  111.         if node == self.head:
  112.             self.insert_node_to_head(new_node)
  113.             return
  114.  
  115.         p = self.head
  116.         while p and p.next != node:
  117.             p = p.next
  118.  
  119.         if not p:
  120.             return
  121.         new_node.next = node
  122.         p.next = new_node
  123.  
  124.     def insert_value_before(self, value: int or str, node):
  125.         new_node = LNode(value)
  126.         self.insert_node_before(node, new_node)
  127.  
  128. #########################################################
  129.     def delete_by_node(self, node):
  130.         # 删除某个节点
  131.         if not self.head or not node:
  132.             return
  133.  
  134.         # 不是最后一个节点，可以直接删除, 删除的复杂度为O(1)
  135.         if node.next:
  136.             node.elem = node.next.elem
  137.             node.next = node.next.next
  138.         else:
  139.             p = self.head
  140.             while p and p.next != node:
  141.                 p = p.next
  142.  
  143.             if not p:
  144.                 return
  145.  
  146.             p.next = node.next
  147.  
  148.     def delete_by_value(self, value: int or str):
  149.         # 删除某个值对应的节点
  150.         if not self.head or not value:
  151.             return
  152.         fake_head = LNode(-1)
  153.         fake_head.next = self.head
  154.         prev, current = fake_head, self.head
  155.         while current:
  156.             if current.elem != value:
  157.                 prev.next = current
  158.                 prev = prev.next
  159.             current = current.next
  160.  
  161.         if prev.next:  # current.item == value
  162.             prev.next = prev.next.next
  163.         self.head = fake_head.next
  164.  
  165. ######################################################
  166.     def InsertSort(self):
  167.         if not self.head:
  168.             return
  169.         fakehead=LNode(None)      #创建哨兵
  170.         p=self.head
  171.         while p:
  172.             t=p.next        #下一结点
  173.             q=fakehead      #将每一次遍历的结点赋予哨兵
  174.  
  175.             #找到p结点插入的位置
  176.             while q.next and q.next.elem<=p.elem:
  177.                 q=q.next
  178.             p.next=q.next
  179.             q.next=p
  180.             p=t
  181.  
  182. ######################################################
  183.     def __repr__(self):         #由于直接将链表结果打印出来会变成一串十六进制码，所以需要进行重写函数
  184.         # 打印链表，重写repr或者str函数
  185.         a = []
  186.         p = self.head
  187.         while p:
  188.             a.append(p.elem)
  189.             p = p.next
  190.         return "\t\n".join(map(str, a))

2.主代码

  1. import os
  2. import csv
  3. from pypinyin import pinyin,Style
  4. from itertools import chain
  5. import re
  6. from Linklist import *          #同目录下找到LinkList.py文件，例如LinkList.py 在文件夹address_book下，
  7.                                 #则修改为from address_book.LinkList import *（需要在目录下新建一个__init__.py的空文件）
  8.                                 #或者将LinkList.py文件复制到环境包目录下，或者将所有代码放在同一个代码文件里不使用import
  9. import pandas
  10.  
  11.  
  12. #中文字符串比较
  13. def toPinyin(s):
  14.     return ' '.join(chain.from_iterable(pinyin(s, style=Style.TONE3)))
  15.  
  16. #判断字符串是否为中文
  17. def is_CN (mail_text: str):
  18.     tmp_text = ''.join(mail_text.split())
  19.     count = 0
  20.     for s in tmp_text.encode('utf-8').decode('utf-8'):
  21.         if u'\u4e00' <= s <= u'\u9fff':
  22.             count += 1
  23.     if float(count / (tmp_text.__len__())) > 0.1:
  24.         return True
  25.     else:
  26.         return False
  27.  
  28. class LinkList:
  29.  
  30.     #链表初始化读入文件信息，并排序
  31.     def __init__(self):
  32.         self.l=LinkedList()
  33.  
  34.         global path             #文件路径
  35.         while 1:
  36.             # path = input(r"请输入通讯录文件路径，例如C:\book.csv:""\n")
  37.             path=r"info.csv"                                        #csv文件空行不能大于1，否则新增联系人会报错或每次多一个空行
  38.             if not os.path.exists(path):
  39.                 print("->文件不存在，请重新选择文件\n")
  40.  
  41.             f=open(path,'r',encoding='utf-8')
  42.             read=csv.reader(f)
  43.             for i,lines in enumerate(read):
  44.                 if i>=1 and lines:
  45.                     empty=0
  46.                     break
  47.             if not os.path.getsize(path):
  48.                 f.close()
  49.                 print("->文件为空，已为您增加表头注释信息，稍后请增加新联系人")
  50.                 first = ['姓名(names)', '电话号码(tel_number)', '分组(group)']
  51.                 f=open(path,'a',newline='')
  52.                 writer=csv.writer(f)
  53.                 writer.writerow(first)
  54.                 f.close()
  55.                 empty=1
  56.                 continue
  57.             else:
  58.                 if next(read):
  59.                     empty = 0
  60.                     break
  61.                 if not next(read):
  62.                     print("联系人为空，请重新选择文件或手动添加联系人")
  63.                     empty=1
  64.                     break
  65.  
  66.         if empty==0:
  67.             f=open(path,'r',encoding='utf-8')        #以读取方式打开文件
  68.             reader=csv.reader(f)
  69.             next(reader)            #第一行为注释信息，从第二行开始读取
  70.             sort_info=[]            #获取排列信息
  71.             for lines in reader:
  72.                 sort_info.append(lines[0])
  73.             f.close()
  74.  
  75.             sort_info=sorted(sort_info,key=toPinyin)    #若有中文通过拼音进行排序
  76.  
  77.             for i in range(len(sort_info)):                 #将按照姓名排序好的信息依次插入单链表
  78.                 f = open(path, 'r',encoding='utf-8')
  79.                 reader = csv.reader(f)
  80.                 next(reader)
  81.                 for lines in reader:
  82.                     if sort_info[i]==lines[0]:
  83.                         self.l.insert_elem_to_last(lines)
  84.                 f.close()
  85.  
  86.     # 功能1，显示以名字为排序的单链表表示的通讯录
  87.     def fun1(self):
  88.         if self.l.ListLength()>0:
  89.             print("-"*87)
  90.             print("->信息按姓名进行从小到大排序，姓名信息的优先序列分别为：数字、大写字母开头英文字母、中文（小写英文开头）")
  91.             print("-" * 87)
  92.  
  93.             #打印信息对齐
  94.             s=["姓名(name)","电话(tel_number)","分组(group)"]
  95.             maxname=len(s[0])
  96.             maxnum=len(s[1])
  97.             maxgroup=len(s[2])
  98.             p=self.l.head
  99.             while p:
  100.                 if len(p.elem[0])>maxname:
  101.                     maxname=len(p.elem[0])
  102.                 if len(p.elem[1])>maxnum:
  103.                     maxnum=len(p.elem[1])
  104.                 if len(p.elem[2])>maxgroup:
  105.                     maxgroup=len(p.elem[2])
  106.                 p=p.next
  107.             maxlen=max(maxnum, maxgroup, maxname)
  108.  
  109.             print(s[0].ljust(maxlen, " "), s[1].ljust(maxlen, " "), s[2].ljust(maxlen, " "))
  110.             p=self.l.head
  111.             while p:
  112.                 if is_CN(p.elem[0]):            #中文对齐英文比较困难，放弃了，就这样吧
  113.                         print(p.elem[0].ljust(maxlen-1, " "),
  114.                               p.elem[1].ljust(maxlen, " "), p.elem[2].ljust(maxlen, " "))
  115.  
  116.                 else:
  117.                     print(p.elem[0].ljust(maxlen, " "),
  118.                           p.elem[1].ljust(maxlen, " "), p.elem[2].ljust(maxlen, " "))
  119.                 p=p.next
  120.  
  121.         else:
  122.             print("->通讯录为空")
  123.  
  124.  
  125.     #功能2，获取通讯录人数
  126.     def fun2(self):
  127.         print("->通讯录总人数：", self.l.ListLength())
  128.         p=self.l.head
  129.         if p!=None:             #输出每个分组人数
  130.             group=[p.elem[2]]
  131.             while p:
  132.                 if not p.elem[2] in group:
  133.                     group.append(p.elem[2])
  134.                 p=p.next
  135.  
  136.             num=[]
  137.             for i in range(len(group)):
  138.                 sum=0
  139.                 p = self.l.head
  140.                 while p:
  141.                     if p.elem[2]==group[i]:
  142.                         sum+=1
  143.                     p=p.next
  144.                 num.append(sum)
  145.             max=len(group[0])
  146.             for i in range(len(group)):
  147.                 if len(group[i])>max:
  148.                     max=len(group[i])
  149.             print("每组人数分别是：")
  150.             for i in range(len(group)):
  151.                 print(group[i].ljust(max," "),num[i])
  152.         else:
  153.             print("暂无分组信息")
  154.  
  155.  
  156.  
  157.  
  158.     #功能3，根据姓名或号码查找联系人信息
  159.     def fun3(self):
  160.         while 1:
  161.             print("\n")
  162.             p=self.l.head
  163.             if p==None:
  164.                 print("->通讯录为空，请新增联系人后再查找")
  165.                 break
  166.             info=input("->输入想要查找的联系人姓名或电话号码，输入exit可退出：  ")
  167.             if info=='exit':
  168.                 os.system("cls")
  169.                 break
  170.             flag=0
  171.             while p:
  172.                 if p.elem[0]==info or p.elem[1]==info:
  173.                     print(p.elem,"\n")
  174.                     flag=1
  175.                     break
  176.                 else:
  177.                     p=p.next
  178.                 if p==None and flag==0:
  179.                     print("\n->查找失败，请重新输入，或输入exit退出。\n")
  180.                     break
  181.  
  182.  
  183.     #功能4模糊查找
  184.     def fun4(self):
  185.         while 1:
  186.             if self.l.head==None:
  187.                 print("通讯录为空，请新增联系人")
  188.                 break
  189.             print("->请选择：\n"
  190.                   "1.模糊查找姓名\n"
  191.                   "2.模糊查找电话号码\n")
  192.             choice=input("->请输入功能选择序号，输入exit退出模糊查找: " )
  193.             if choice=='1':
  194.                 info=input("->请输入要查找的信息： ")
  195.                 p=self.l.head
  196.                 flag=0
  197.                 while p:
  198.                     if re.findall(info,p.elem[0]):
  199.                         print(p.elem)
  200.                         print()
  201.                         flag=1
  202.                     p=p.next
  203.                     if p==None and flag==0:
  204.                         print("-=>无您所查找的信息")
  205.                 print("-"*50)
  206.  
  207.             elif choice=='2':
  208.                 info=input("->请输入要查找的信息： ")
  209.                 p=self.l.head
  210.                 flag=0
  211.                 while p:
  212.                     if re.findall(info,p.elem[1]):
  213.                         print(p.elem)
  214.                         print()
  215.                         flag=1
  216.                     p=p.next
  217.                     if p==None and flag==0:
  218.                         print("->无您所查找的信息")
  219.                 print("-"*50)
  220.  
  221.             elif choice=='exit':
  222.                 break
  223.             else:
  224.                 print("->输入有误")
  225.                 print("-" * 50)
  226.  
  227.  
  228.     #功能5新增联系人
  229.     def fun5(self):
  230.         p=self.l.head
  231.         if p==None:         #通讯录为空时不显示分组信息
  232.             print("当前无联系人信息，请新增联系人")
  233.             newname=input("->请输入新联系人名字： ")
  234.             newnumber=input("->请输入新联系人号码： ")
  235.             newgroup = input("->请输入新联系人加入的分组： ")
  236.             print("\n")
  237.             newinfo = [newname, newnumber, newgroup]
  238.             f = open(path, 'a',encoding="utf-8",newline='')
  239.             writer = csv.writer(f)
  240.             writer.writerow(newinfo)  # 将新信息写入文件
  241.             f.close()
  242.  
  243.             p.elem=newinfo
  244.             print("->已经增加新联系人:\n姓名：{}，电话号码：{}，分组：{}".format(newname, newnumber, newgroup))
  245.             print(self.l)
  246.  
  247.         else:              #通讯录不为空时显示分组信息
  248.             newname=input("->请输入新联系人名字： ")
  249.             newnumber=input("->请输入新联系人号码： ")
  250.             group=[self.l.head.elem[2]]
  251.             p=self.l.head
  252.             while p:
  253.                 if not p.elem[2] in group:
  254.                     group.append(p.elem[2])
  255.                 p=p.next
  256.             print(group)
  257.             newgroup=input("->请输入新联系人加入的分组,目前所有分组如上（若无该分组则自动创建分组）： ")
  258.  
  259.             newinfo=[newname,newnumber,newgroup]
  260.             f=open(path,'a',encoding='utf-8',newline='')
  261.             writer=csv.writer(f)
  262.             writer.writerow(newinfo)        #将新信息写入文件
  263.             f.close()
  264.  
  265.             p = self.l.head
  266.             while p:
  267.                 if p.next==None:
  268.                     self.l.insert_elem_to_last(newinfo)
  269.                     break
  270.                 elif toPinyin(p.elem[0]) < toPinyin(newinfo[0]) and\
  271.                         toPinyin(p.next.elem[0]) > toPinyin(newinfo[0]):
  272.                     self.l.insert_value_after(p,newinfo)
  273.                     break
  274.                 elif toPinyin(p.elem[0])>toPinyin(newinfo[0]):
  275.                     self.l.insert_value_to_head(newinfo)
  276.                     break
  277.                 else:
  278.                     p=p.next
  279.             print("->已经增加新联系人:\n姓名：{}，电话号码：{}，分组：{}".format(newname,newnumber,newgroup))
  280.  
  281.     #6,通过姓名或号码删除联系人
  282.     def fun6(self):
  283.         delete=input("->请输入想要删除的联系人姓名或号码： ")
  284.         p=self.l.head
  285.         while p:
  286.             if p.elem[0]==delete or p.elem[1]==delete:
  287.                 self.l.delete_by_node(p)
  288.                 print("->已删除")
  289.                 break
  290.             if p.next==None:
  291.                 print("->联系人信息不存在!")
  292.                 break
  293.             p=p.next
  294.  
  295.         #查找删除信息在文件中的位置
  296.         f=open(path,'r',encoding='utf-8')
  297.         i=1
  298.         reader=csv.reader(f)
  299.         next(reader)
  300.         for lines in reader:
  301.             if lines[0]==delete or lines[1]==delete:
  302.                 break
  303.             i+=1
  304.         f.close()
  305.  
  306.         #在文件中删除该信息行
  307.         data = pandas.read_csv(path,encoding='utf-8')
  308.         data.drop(data.index[i-1], inplace=True)
  309.         data.to_csv(path, index=0)
  310.  
  311.  
  312. #合并两个通讯录,先合并，后排序
  313. def connnect():
  314.     while 1:
  315.         path1=input(r"->请输入通讯录1文件路径： ")
  316.         path2=input(r"->请输入通讯录2文件路径： ")
  317.         if os.path.exists(path1) and os.path.exists(path2):
  318.             break
  319.         else:
  320.             print("->其中有文件不存在，请重新输入：")
  321.  
  322.     #通讯录1
  323.     l1=LinkedList()
  324.     f1=open(path1,'r',encoding='utf-8')
  325.     reader1=csv.reader(f1)
  326.     next(reader1)
  327.     for lines in reader1:                   #将文件信息写入链表，暂不排序
  328.         l1.insert_elem_to_last(lines)
  329.  
  330.     #通讯录2
  331.     l2=LinkedList()
  332.     f2=open(path2,'r',encoding='utf-8')
  333.     reader2=csv.reader(f2)
  334.     next(reader2)
  335.     for lines in reader2:
  336.         l2.insert_elem_to_last(lines)
  337.  
  338.     #两个链表合并后将新链表的内容写入新文件保存
  339.     l3=LinkedList()
  340.     p1=l1.head
  341.     while p1:
  342.         p2=l2.head
  343.         while p2:
  344.             if p1.elem[0]==p2.elem[0] and p1.elem[1]==p2.elem[1]:       #两个通讯录相同的
  345.                 l3.insert_elem_to_last(p1.elem)
  346.                 p2=p2.next
  347.                 continue
  348.             if p1.elem[0]==p2.elem[0] and p1.elem[1]!=p2.elem[1]:
  349.                 while 1:
  350.                     print("检查到有联系人号码不相同：\n",p1.elem,"\n",p2.elem)
  351.                     print("请选择：\n"
  352.                           "1.合并号码\n"
  353.                           "2.分别保存\n")
  354.                     choi=input("输入选择: ")
  355.                     if choi=='1':
  356.                         l3.insert_elem_to_last(p1.elem)
  357.                         p3=l3.LocateElem(p1.elem)
  358.                         p3.elem[1]=p1.elem[1]+'、'+p2.elem[1]
  359.                         p2=p2.next
  360.                         break
  361.                     if choi=='2':
  362.                         l3.insert_elem_to_last(p1.elem)
  363.                         l3.insert_elem_to_last(p2.elem)
  364.                         p2=p2.next
  365.                         break
  366.                     else:
  367.                         print("输入有误，请重新输入")
  368.                         continue
  369.             else:
  370.                 p2=p2.next
  371.         p1=p1.next
  372.     print("重复的信息有\n：",l3)
  373.     print()
  374.  
  375.     #将剩余没有重复的加入l3
  376.     p1=l1.head
  377.     p2=l2.head
  378.     p3=l3.head
  379.     if p3!=None:
  380.         while p1:
  381.             if not l3.LocateElem_first(p1.elem[0]):
  382.                 l3.insert_elem_to_last(p1.elem)
  383.             p1=p1.next
  384.         while p2:
  385.             if not l3.LocateElem_first(p2.elem[0]):
  386.                 l3.insert_elem_to_last(p2.elem)
  387.             p2=p2.next
  388.  
  389.     if p3==None:
  390.         l3=l1
  391.         while p2:
  392.             p3=l3.head
  393.             while p3:
  394.                 if p2.elem[0]!=p3.elem[0]:
  395.                     l3.insert_elem_to_last(p2.elem)
  396.                 p3=p3.next
  397.             p2=p2.next
  398.  
  399.     l1.ListClear()
  400.     l2.ListClear()
  401.  
  402.     #l3排序后写入文件
  403.     sortl=[]
  404.     p=l3.head
  405.     while p:
  406.         sortl.append(p.elem)
  407.         p=p.next
  408.     sortl=sorted(sortl,key=toPinyin)
  409.     p=l3.head
  410.     i=0
  411.     while p:
  412.         p.elem=sortl[i]
  413.         p=p.next
  414.         i+=1
  415.  
  416.     print("合并后的通讯录为\n",l3)
  417.     print()
  418.  
  419.     #写入文件
  420.  
  421.     first = ['姓名(names)', '电话号码(tel_number)', '分组(group)']
  422.     f = open('connect.csv', 'a', encoding='utf-8',newline='')
  423.     writer = csv.writer(f)
  424.     writer.writerow(first)
  425.     f.close()
  426.     p=l3.head
  427.     while p:
  428.         f=open('connect.csv','a',encoding='utf-8',newline='')
  429.         writer=csv.writer(f)
  430.         writer.writerow(p.elem)
  431.         p=p.next
  432.         f.close()
  433.  
  434.  
  435.  
  436. #主界面
  437. def choose():
  438.     os.system("cls")
  439.     devide = "--"
  440.     print(devide * 40)
  441.     print("                               1.查看通讯录\n"
  442.           "                               2.查看通讯录人数\n"
  443.           "                               3.查找联系人\n"
  444.           "                               4.模糊查找通讯录（输入姓名）\n"
  445.           "                               5.新增联系人\n"
  446.           "                               6.删除联系人\n"
  447.           "                               7.合并两个通讯录\n"
  448.           "                               8.退出\n"
  449.           "-------------------------------------------------------------------------------------"
  450.           "-----------------------------作者：华南农业大学 2021人工智能系 VIK------------------------"
  451.           "-----------------------------如有使用请标明参考地址出处--------------------------------------")
  452.     print(devide * 40, )
  453.  
  454.  
  455. #主函数
  456. if __name__=='__main__':
  457.     l=LinkList()
  458.     devide="--"
  459.     choose()
  460.     while 1:
  461.         choiec=input("->请输入功能对应的序号,输入menu唤出功能菜单，按回车键结束: ")
  462.         os.system("cls")
  463.  
  464.         if choiec== '1':
  465.             os.system("cls")
  466.             try:
  467.                 l.fun1()
  468.                 input("点击回车返回主界面")
  469.                 choose()
  470.             except:
  471.                 print("未知错误，请重启选择菜单")
  472.                 continue
  473.         elif choiec== '2':
  474.             try:
  475.                 l.fun2()
  476.                 input("点击回车返回主界面")
  477.                 choose()
  478.             except:
  479.                 print("未知错误，请重启选择菜单")
  480.                 continue
  481.         elif choiec== '3':
  482.             try:
  483.                 l.fun3()
  484.                 choose()
  485.             except:
  486.                 print("未知错误，请重启选择菜单")
  487.                 continue
  488.         elif choiec== '4':
  489.             try:
  490.                 l.fun4()
  491.                 choose()
  492.             except:
  493.                 print("未知错误，请重启选择菜单")
  494.                 continue
  495.         elif choiec== '5':
  496.             try:
  497.                 l.fun5()
  498.                 input("点击回车返回主界面")
  499.                 choose()
  500.             except:
  501.                 print("未知错误，请重启选择菜单")
  502.                 continue
  503.         elif choiec== '6':
  504.             try:
  505.                 l.fun6()
  506.                 input("点击回车返回主界面")
  507.                 choose()
  508.             except:
  509.                 print("未知错误，请重启选择菜单")
  510.                 continue
  511.         elif choiec=='7':
  512.             try:
  513.                 connnect()
  514.                 input("点击回车返回主界面")
  515.                 choose()
  516.             except:
  517.                 print("未知错误，请重启选择菜单")
  518.                 continue
  519.         elif choiec=='8':
  520.             break
  521.         elif choiec=='menu':
  522.             os.system("cls")
  523.             choose()
  524.             continue
  525.         else:
  526.             print("***************************输入有误,请重新输入*****************************")
  527.         print(devide*40)

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/AllinToyou/article/detail/218411
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号