第二阶段：python基础

1.2python基础

1.2.1python简介

1.2.1.1编译型语言和解释性语言

1. 编译器：计算机只能识别机器语言，而编程语言有很多种，编程语言要想被机器所识别就必须要有一个工具将编程语言转化为机器语言，这个工具就是编译器，编译器翻译的方式有两种，一种是编译，一种是解释，两种方式之间的区别在于翻译时间点的不同
2. 解释器：当编译器以解释的方式运行时，该编译器就被称为解释器，而这种使用解释器解释的语言则被称为解释型语言
3. 编译型语言和解释型语言的工作原理：
   • 编译型语言：一次性执行所有代码，编译型语言不可以跨平台，即在windows上编译好的程序不可以在其它操作系统上执行
   • 解释性语言：一行一行的执行代码，解释性语言可以跨平台
   • 比较：编译型语言执行的速度比解释型语言更快

1.2.1.2python的特点

1. python是完全面向对象的语言：面向对象是一种思维方式，要解决一个问题，有两种解决问题的方式，一种是自己一件一件的完成，另一种是找一个会做这个问题的人来帮你解决这个问题，这里的对象就是那个人；这个对象封装了一个问题的解决方案，你只需调用这个对象就可以解决这个问题
2. python拥有一个强大的标准库，这些库中封装了很多解决问题的对象，用户可以使用这些库来解决不同的问题
3. python社区提供了大量的第三方模块，这些模块是由当今的一些python爱好者开源出来的，这些模块也包含大量的对象且这些模块很多都涉及当前的许多前端领域：类似人工智能和大数据，用户可以利用这些模块中的对象来简化解决问题的方法
4. python语言具有可拓展性：在使用python编写代码的过程中如果希望某一段关键代码运行的更快或者某些算法不公开，可以把这些代码用c/c++编写，然后在python中使用他们

1.2.2第一个程序

1.2.2.1python程序演练

1. 在终端中运行python代码：python python文件名(以.py结尾)

1.2.2.2代码错误排查

1. SystaxError：语法出错；报错提示中出现指示箭头表示该位置代码出错(例如在一个单词的下方有一个箭头表示这个单词python解释器不认识，可能是语法出错导致了该问题，会出现SystaxvError的错误提示，表示语法出错)
2. IndentationError：缩进错误；在报错提示中会出现箭头提示出错的位置，同时说明unexpected indent表示不希望的缩进，表明缩进存在错误

1.2.2.3python2和python3的区别

1. python2的解释器是不支持中文的，但是python3的解释器支持中文，在终端中输入python3就可以用python3的解释器执行程序(输入python是使用python2进行执行)
2. 现在建议使用python3以上的版本进行程序的编写，但是如果在开发时，无法立刻使用python3以上的版本(还有极少的第三方库不支持3.0的语法)，建议先使用python3的版本进行开发，然后使用python2.6或者python2.7这两个过渡版本进行执行(这两个版本支持python2和不分python3的语法)，在执行的过程中根据系统的提示对代码进行一些兼容性的处理

1.2.3python执行方式和pycharm设置

1.2.3.1多种可以解析python的解释器

1. Cpython：使用c语言编写的python解释器，是官方版本的c语言实现
2. Jython：可以运行在Java平台的用java编写的python解释器
3. IronPython：可以运行在.net平台和mono平台
4. PyPy：使用python编写的python解释器，支持jit即时编译

1.2.3.2官方解释器交互式运行程序

1. 直接在终端中运行python代码会直接看到程序的执行结果，这种运行方式就是交互式运行程序
2. 如何退出python的交互式运行程序：方法一：在>>>中输入eixt()即可退出；方法二：在>>>中按住快捷键ctrl+d可以退出解释器；小技巧：在输入eixt后会提示退出解释器的快捷键

1.2.3.3IPython交互式执行python

1. 说明：IPython是一种shell，但这种shell比python官方的shell更适于编程
2. 优点：
   • 支持自动补全(安装tab键可以自动补全)
   • 支持自动缩进
   • 可以在IPython的shell中直接输入Linux的终端命令，即支持bash shell命令
   • 内置了很多函数
3. 使用：
   • python2的版本使用的解释器是ipython
   • python3的版本使用的解释器是ipython3
4. 退出解释器的方式
   • 直接输入exit
   • 按住快捷键ctrl+d

1.2.3.4集成开发环境IDE简介

1. 集成开发环境(IDE简称Integrated Development Environment)集成了开发软件所需要的所有工具，一般包括：图形用户界面、代码编辑器、编译器/解释器、调试器(断点/单步执行)

1.2.3.5pycharm断点调试

1. 在需要开始断点调试的行号前单击，生成一个红色的原点，点击编辑器右上角的小虫子按钮就可以从断点出开始一行一行执行程序，每点击一次f8按钮就会在控制台上输出每一行的执行结果

1.2.3.6pycharm初始设置

1. 恢复pycharm初始设置(mac)：可以重置所有相关的配置，恢复到刚安装的模样

   • 根据需要删除以下目录

   # Configuration
   rm -rf ~/Library/Preferences/PyCharm*
   # Caches
   rm -rf ~/Library/Caches/PyCharm*
   # Plugins
   rm -rf ~/Library/Application Support/PyCharm*
   # Logs
   rm -rf ~/Library/Logs/PyCharm*
   

2. 打开python项目

   • 在项目目录下有一个隐藏目录.idea(可以在终端下发现)，这个目录用来保存项目的相关的信息，例如解释器版本、项目包含的文件等等

3. 修改python解释器版本(Mac)

   • pycharm-preferences-project-project interpreter

4. 命名规则

   • 项目名命名规则：项目名前以数字编号；如：01_python基础
   • 文件名命名规则：建议只使用小写字母、数字和下划线

5. 修改控制台字体和编辑器字体

   • Pycharm-preferences-editor-font(修改编辑器字体)/color scheme-console font(修改控制台字体)

6. 在终端下安装pycharm(Linux)

   • 在官网下载pycharm(安装包的后缀是.tar.gz：表示这是一个tar形式的包并用gz压缩后所形成的压缩包)
   • 用tar的方式解压缩压缩包：tar -zxvf 压缩包名
   • 将压缩后的目录移动到/opt目录下(/opt目录是额外软件的安装目录)，方便其它用户使用(如果目录在某一个用户下那么其它的用户就无法使用该软件)：sudo mv 源文件地址 目标文件地址
   • 切换工作目录：切换到解压缩后的目录下的bin目录下：cd /opt/移动后的目录/bin
   • 启动pycharm：./pycharm.sh

7. pycharm有关说明：

   • 在Ubuntu中，应用程序启动的快捷方式通常保存在/usr/share/applications目录下

8. Ubuntu下卸载pycharm的步骤

   • 第一步：删除解压缩后的目录：opt下的解压缩文件
   • 第二步：删除pycharm的配置文件：.Pycharm***，是一个隐藏目录，在根目录下
   • 第三步：删除pycharm的快捷方式：在/usr/share/applications目录下

1.2.4程序注释和算术运算符

1.2.4.1程序的注释

1. 在python中默认在注释后要空一格，即在#后面要空一格，如何让所有未空一格的注释都空一格：在pycharm中点击注释前面的灯泡，点击reformate file就可以要所有的注释都规范化
2. 在python中默认注释单独一行要空一格，而在代码尾部添加注释要先空两格再输入注释
3. 在写注释时不要描述代码，要写为什么这里要写这个代码
4. pep8：pep是python enhancement proposals的简称，是python官方提供的文档，其中第八遍文档专门提到了python的代码格式，因此说到pep8就是python的代码格式建议

1.2.4.2算术运算符

1. 相关算术运算符

   运算符	描述
   //	除法取整
   /	除法保留小数
   %	除法取余
   **	幂运算

2. *运算符也可以用于字符串的输出

   • “–” * 70：表示将字符串的内容连续输出70次
   • 拼接字符串可以用+

3. 算术运算符的优先级

   • 最高级：幂运算
   • 第二级：乘、除、取余、取整
   • 最低级：加、减

1.2.5程序执行原理

1.2.5.1计算机中的三大件

1. 一个程序要运行有三个核心的硬件：cpu、内存、硬盘
2. Cpu：中央处理器，是一块超大规模大集成电路，负责处理数据/计算
3. 内存：临时存储数据(断电后，数据会消失)，速度快，空间小(单位价格高)
4. 硬盘：永久存储数据，速度慢，空间大(单位价格低)

1.2.5.2程序执行原理简介

1. 程序运行之前是保存在硬盘中的，当要运行一个程序时，操作系统首先会让cpu将程序复制到内存中然后cpu执行内存中的程序代码
2. 程序是用来处理数据的，而变量是用来存储数据的
   • 在打开QQ软件时，输入的账号和密码是以变量的形式保存在内存中的，即数据是保存在变量中而变量是保存在内存中的

1.2.5.3python程序执行原理

1. 执行原理：操作系统首先让cpu将python解释器的程序复制到内存中，python解释器根据语法规则从上至下让cpu翻译python程序中的代码，最后cpu执行翻译完成的代码

2. 查看python解释器的大小

   which python3
   # 返回结果/usr/bin/python3
   ls -lh /usr/bin/python3
   # 会出现一个软链接：/usr/bin/python3 -> python3.6
   ls -lh /usr/bin/python3.6
   

3. 建立软链接的目的是方便用户执行程序而不需要每次都输入python的版本

1.2.6变量

1.2.6.1变量的使用

1. 交互式环境和编辑器中输出变量的内容的区别：在交互式环境下可以直接输入变量名就可以输出变量的值，而在编辑器中要通过print函数来输出变量的值
2. pycharm中如何快速关闭当前运行程序外的所有其它python程序：鼠标右击上方显示的当前程序选项卡，选择close others即可
3. pycharm中调试代码是需要占用内存的，当代码调试完毕会自动释放内存(variables中的内容会被清空)

1.2.6.2变量的类型

1. 使用type函数可以查看变量的类型：type(a)
2. 在python3中将长整型和整型进行合并均称为整型(即在python3中只有int没有long)

1.2.6.3变量间的计算

1. 在使用bool进行计算时，默认将True认为1，将False认为是0

1.2.6.4变量的输入输出

1. input()函数实现从键盘输入，且所有输入的内容都被认为是字符串类型

2. 类型转换函数：int()和float()

3. 格式化输出

   price = 3
   weight = 4
   height = 3.0
   # 变量的格式化输出，占位符输出(将需要代替的内容用占位符代替)
   # print("格式化字符串" % （变量1,变量2，……）)
   # 格式化字符：%s,%d,%f,%%;分别表示字符串，十进制整数，浮点数，输出%
   # %06d表示输出位的显示位数，不足的地方用0补全，如果超过6位就显示原本的数字
   # %.2f表示小数后只显示2位,%.3f表示小数后只显示3位
   print("金额：%09d 价格：%.2f 重量：%d%%" % (price*weight,price*height,weight))
   print("金额：%09d" % price*2)  # 直接在变量后面*2会导致输出的内容连续输出两遍
   print("金额：%09d" % (price*2))  # 变量后面*2后加上括号会将变量*2后输出
   

1.2.6.5变量的命名

1. 变量名不能以数字开头，只能包括字母、下划线和数字
2. 命名规则：常用的变量命名规则右驼峰命名法，驼峰命名法又分为小驼峰命名法和大驼峰命名法(区别在于第一个单词的字母是否大写)，但python不建议使用驼峰命名法，建议在定义变量时只使用小写字母，当需要多个单词组合时用下划线隔开，例如：first_name
3. if判断语句的条件一般不用括号：if a > 4:

1.2.7if判断语句

1.2.7.1pycharm代码块及光标位置提示

1. 在pycharm中，在代码的左边和行数的右边有一个加减号可以对同一类型的代码进行收纳，在代码的下方和控制台的上方有一个提示可以显示当前的代码处于哪个模块之下(例如：如果光标在判断语句的内部，那么又会提示是处于哪个语句内部)
2. 在pycharm中一般代码下方出现波浪号且这种波浪号是淡色的，那一般是因为代码不符合官方的要求，点击代码前面的小灯泡进行修正即可

1.2.7.2逻辑运算

1. 在编写代码时用and,or,not来表示与，或，非运算，其中非就是取反运算(True变为False)

2. 说明：在判断语句中，bool型的变量可以直接作为判断条件，因为正常语句的判断的结果就是bool型(2==3的结果就是False)

3. 代码编写技巧

   • 如果一行代码过长会导致阅读不方便，可以在大的条件上增加一个括号，然后对可以分行显示的内容进行换行处理，换行后为防止误解建议将换行后的代码再添加一个缩进(如果不添加缩进可能会错误的和后面的代码理解为处于同一级下：例如下面的代码如果不添加缩进可能会将or后面的内容理解为和print后面的内容都是执行语句)

     a = 1
     b = 1
     if((a == 1 and b == 1)
             or (a == 2 and b == 2)):
         print("exit")
     

4. 随机数的使用

   import random  # 使用随机数需要导入random模块
   random.randint(2,4)  # randint(a,b)函数可以随机产生a和b之间的随机整数，包括a和b，其中a<=b
   

1.2.7.3if后面的内容

1. if后面可以是一个等式，同时也可以是一个变量，这个变量可以是数字、元祖、字符串、None、False、True等。对于数字而言不是0就可以执行内部程序；对于元祖、字符串、列表这些而言只要不为空就可以执行内部程序；只要不是None,False就可以执行内部代码(原理就是if后面的内容只有一个结果要么为真要么为假，需要区分的就是各种类型的数据什么情况下为真什么情况下为假)

1.2.8while循环基本使用

1.2.8.1while循环基础

1. while循环的条件一般也不需要括号：while a > 4:
2. 赋值运算符：例如：a += b表示a = a + b

1.2.8.2循环嵌套

1. print输出说明，print函数默认输出后换行，如果不需要换行，可以如此做：print(“123”,end="")，其中end后面的内容就是在输出内容后会增加的内容，内部写什么输出什么，print("")表示换行

1.2.8.3字符串中的转义字符

1. 转义字符的介绍

   转义字符	描述
   \t	横向制表符
   \n	换行
   \\	反斜杠符号
   \r	回车
   \’	单引号
   \*	双引号

2. 说明：\t在控制台输出一个制表符，协助在输出文本时垂直方向对齐，制表符的功能是在不使用表格的情况下在垂直方向按列对齐文本，在Unix系统下执行 换行操作 用“\n” 在windows 操作做系统下执行 换行操作 用“\r\n” 在Mac操作系统下执行 换行操作用“\r”

3. 举例说明：

   # 九九乘法表
   row = 1
   while row <= 9:
       line = 1
       while line <= row:
           print("%d*%d=%d" % (line, row,line * row), end="\t")
           line += 1
       print("")
       row += 1
   

1.2.9函数

1.2.9.1函数的基本使用

1. 导入模块事例：
   • 写一个完成九九乘法表的函数multiplication_table()，将该函数所在的程序命名为multiplication_table.py(现在，这个程序将相当于一个模块，multiplication_table函数就是该模块中用于实现九九乘法表的函数)
   • 在另一个程序中导入该模块，import multiplication_table，在该程序中调用multiplication_table函数来实现输出九九乘法表的功能：multiplication_table.multiplication_table()
2. 说明：函数必须先定义再调用(因为python时解释型语言)
3. 断点调试：f8调试遇到函数时会直接输出函数的结果不会进入到函数内部，而f7调试遇到函数时可以进入到函数内部一步一步执行。其它方面f7和f8基本没有差别
4. 函数的注释(函数功能说明)
   • 一般官方要求在函数定义的上方必须空两行
   • 书写函数的功能注释时再函数名的下方所在行用三个双引号引起来书写注释
   • 在pycharm中选中函数名按住快捷键ctrl+q(有的是f1：查看view->quick documentation就可以查看注释)就可以调出书写的函数注释

1.2.9.2函数的参数和返回值

1. 函数参数的使用：

   """
      这里函数的参数的作用就相当于定义变量，在调用时就相当于给这两个变量赋值，
      函数内部就可以直接调用而不需要再定义
   """
   def sum(a,b):  
       """求两个数的和"""
       sum = a + b
       print(sum)
   sum(1,2)
   

2. 形参和实参

   • 在函数定义时使用的参数叫形参(定义时没有赋予数据)，在函数调用时使用的参数叫实参(是实实在在的数据)
   • 形参的两个作用：一个是定义变量可以在函数内部直接使用而不需要再次定义，另外一个是表示该函数可以赋予数据

3. 函数的返回值

   • 返回值是函数完成后给调用者一个结果

   • 使用return关键字可以返回结果

   • 调用函数的一方可以使用变量来接受函数的返回结果

     """
        这里函数的参数的作用就相当于定义变量，在调用时就相当于给这两个变量赋值，
        函数内部就可以直接调用而不需要再定义
     """
     def sum(a,b):
         """求两个数的和"""
         return a + b
     
     
     # python官方要求在函数的后面也要有两行空格
     result = sum(1,2)  # 使用result变量来接受函数的返回结果
     print(result)
     

   • return后续的代码不会被执行，所以return是函数的最后一行代码

1.2.9.3函数的嵌套调用

1. 事例：

   def line_line(char, time):
       """打印单行凭条"""
       return char * time
   
   
   def line(char, time, row):  # 这里python推荐再,后添加一个空格
       # 以下可以为函数的参数添加注释并按f1会有相关说明，注意下面的冒号后面应该有一个空格
       """打印多行凭条
   
       :param char: 要打印的字符
       :param time: 要打印的个数
       :param row: 要打印的行数
       """
       flat = 1
       while flat <= row:
           if flat != row:
               print(line_line(char, time))
           else:
               print(line_line(char, time), end="")
           flat += 1
   
   
   """以下定义的abc不要和函数内部的变量一致，否则会有提示：shadows name *** from outer scope，
      函数内部的变量，如果和函数被调用的外部的变量一样的话，就被PyCharm中叫做shadows name，
      也就是说形参和实参最好不要用同一个变量名
      """
   a = input("请输入要打印的字符：")
   b = int(input("请输入要打印的个数："))
   c = int(input("请输入要打印的行数："))
   line(a, b, c)
   

1.2.9.4模块

1. 模块的概念：在python中每一个以.py结尾的源代码文件就是一个模块
2. 模块的命名：模块名就是一个变量名，而变量名不能以数字开头，所以一般定义文件名不以数字开头
3. 新版pycharm新建工程后会自动创建一个包venv，我们可以在该包下新建一个包src，然后在src下新建python文件
4. 在一个python文件中导入一个模块时，系统会自动创建一个模块的编译后的文件，后缀名为.pyc，当调用模块中的函数时达到快速执行的目的而不需再对函数一行一行的进行编译执行，该文件存在于工程目录下，用于提高程序的执行效率

1.2.10列表

1.2.10.1列表的定义及作用

1. 列表是python中使用最频繁的数据类型，在其它语言中通常叫数组
2. 列表的定义：name_list = [“zhangsan”, “lisi”, “wangwu”]
3. 在ipython3中如果想知道一个列表下面可以有哪些方法，可以输入定义一个列表，然后输入列表名，再写.再按下tab键就可以看到方法

1.2.10.2列表的相关方法

1. 知道内容取出在列表中对应的索引：index()

   name_list = ["zhangsan", "lisi", "wangwu"]
   index_lisi = name_list.index("lisi")  # index()方法用来取出索引
   print(index_lisi)
   

2. 修改指定位置的内容：list_name[1] = “李四”

3. 向列表增加数据：insert(),extend(),append()

   name_list = ["zhangsan", "lisi", "wangwu"]
   name_list.append("zhaoliu")  # append方法就是将指定的内容追加到列表的末尾，如果追加的是一个列表则默认为该列表是一个独立的元素来插入原先列表中
   name_list.insert(1, "guohuai")  # insert方法可以在列表的指定位置插入数据，原先位置的数据往后移
   temp_list = ["张三", "李四"]
   name_list.extend(temp_list)  # extend方法可以将指定列表插入到列表的末尾
   print(name_list)
   

4. 从列表中删除数据：remove(),pop(),clear()

   name_list = ["zhangsan", "lisi", "wangwu", "zhaoliu"]
   name_list.remove("lisi")  # remove方法用于删除指定的数据，如果列表中有多个该数据会删除第一个出现的指定数据
   name_list.pop()  # pop方法如果不添加任何参数是删除列表中最后一个数据
   name_list.pop(1)  # pop方法可以删除指定索引的数据
   name_list.clear()  # clear方法可以清空整个列表
   # del跟上列表变量名后再跟索引就可以删除指定索引的数据
   del name_list[2]  # del关键字可以从内存中删除变量，后续不能使用被删除后的变量
   name = "123"
   del name
   # 在列表中删除数据时建议使用列表提供的方法，不建议使用del
   print(name_list)
   

5. 列表统计：count(),len()

   name_list = ["张三", "李四", "王五"]
   name_list.append("李四")
   list_len = len(name_list)  # len函数用来统计列表中元素的总数
   count = name_list.count("李四")  # count函数用来统计列表中某一个数据出现的次数
   print(list_len)
   print(count)
   name_list.remove("李四")
   

6. 说明：在使用pycharm时如果对某一个函数不清楚其具体作用可以使用f1来查看函数的具体作用(有的是ctrl+q)

7. 列表的排序和反转：sort(),reverse()

   name_list = ["lisi", "zhangsan", "wangwu"]
   name_list.sort()  # sort函数默认将列表按照升序进行排列
   name_list.sort(reverse=True)  # sort函数加上参数reverse(表示翻转)就可以降序排列
   name_list.reverse()  # reverse函数可以将列表中元素的顺序进行反转，将123变为321(注意这没有降序的功能)
   print(name_list)
   

8. 关键字、函数、方法的区别

   • 关键字后面不需要跟括号：如del 变量名

   • ipython3下查看python有多少关键字：

     import keyword
     print(deyword.kwlist)
     

   • 函数和方法后面都需要带括号而且函数和方法类似，但是函数需要死记硬背但方法不需要死记硬背，函数可以直接调用而方法需要对象名来调用，不知道函数名就无法使用函数，不知道方法名可以使用对象.来补全和查看方法名

9. 列表的循环遍历

   • 遍历：就是从头到尾依次从列表中获取数据，在python中，可以使用for循环遍历所有非数字类型的变量：列表、元祖、字典以及字符串

   • 使用for来实现遍历

     name_list = ["lisi", "zhangsan", "wangwu"]
     for name in name_list:  # for后面的变量是每一次遍历所得到数据的存储位置，in后面的内容是要遍历的列表变量名
         print(name)  # 每遍历一次都要执行for的内部内容
     

10. 列表的应用场景：列表一般用来存储具有相同类型的元素，一般很少用列表存储不同类型的数据

1.2.11元祖

1.2.11.1元祖的定义

1. 元祖与列表相似，但是元祖中的元素不能修改
2. 元祖的定义：
   • Info_tuple = (“zhangsan”, 18, 1.75)
   • 定义一个只包含一个元素的元祖：info_tuple = (12, )
   • 说明：定义一个只包含一个元素的元祖必须在元素后面写一个逗号，否则python不会将其识别为一个元祖
3. 通过索引查看元祖的数据：
   • Info_touple_first = info_touple[0]
   • 说明：通过索引查看元祖需要用[]而不是()

1.2.11.2元祖变量的相关操作

1. 要一个变量有哪些方法，只需在变量后写一个.然后根据提示就可知道有哪些方法(或者在ipython下输入变量.然后双击tab键也可以查看)
2. 取索引操作：和列表一样，通过index()函数即可查看指定内容所对应的索引
3. 统计某个元素出现的次数：和列表一样使用count()函数就可以查看出现的次数
4. 统计元祖包含元素的个数：和列表使用len函数(len(元祖变量名))
5. 使用for循环遍历元祖的数据：和列表遍历一样
6. 在实际开发中元祖通常保存数据类型不同的数据，所以对元祖的循环遍历通常不多(例如：很难对元祖中的数据进行拼接)

1.2.11.3元祖的应用场景

1. 作为函数的参数和返回值，一个函数可以接受任意多个参数或者返回多个数据

2. 格式化字符串(在格式化输出时，%后面括号内部的内容就是一个元祖)

   • print("%d %s %f" % (10, “123”, 1.22))

   • 元祖拼接字符串

     print("%d %s %f" % (10, "123", 1.22))
     info_tuple = (10, "123", 1.22)
     into_str = "%d %s %f" % info_touple  # 元祖拼接字符串最后得到的是一个字符串
     print(into_str)
     

3. 由于元祖内部的数据不可以修改所以间接保证了数据的安全，所以通常将列表转化为元祖以此来保证列表中数据的安全性

   • 利用list(元祖变量名)函数可以将元祖转化为列表
   • 利用tuple(列表变量名)函数可以将列表转化为元祖

1.2.12字典

1.2.12.1字典的定义

1. 字典和列表的区别：列表是有序的对象集合(索引就是顺序)，字典是无序的对象集合
2. 字典的定义：{}
3. 字典使用键值对存储数据的，键值对之间用,隔开，键必须是唯一的，键用来表示数据，值用来保存数据
4. 键key是索引，值value是数据，键和值之间用:分隔，键必须是唯一的，值可以取任何数据类型但键只能使用字符串、数字或者元祖
5. 在日常开发中，字典通常用于存储描述一个物体的相关信息

1.2.12.2字典的操作

1. 字典的定义

   # 字典是一个无序的集合，通常输出的顺序不一定就是字典中定义的顺序
   xiaoming = {"name": "小明",  # 在日常字典的编写中，每一个键值对通常只占用一行，直接回车即可下一个键值对书写
               "age": 18,
               "gender": True}
   print(xiaoming)
   

2. 字典的增删改查等常用操作

   • 字典的取值

     xiaoming = {"name": "小明"}
     print(xiaoming["name"])  # 在中括号中输入要取出值的键
     

   • 增加键值对

     xiaoming = {"name": "小明"}
     xiaoming["age"] = 18  # 添加键值对
     xiaoming["name"] = "小李"  # 修改键值对中的值
     print(xiaoming["name"])  # 在中括号中输入要取出值的键
     

   • 修改键值对的值

     xiaoming = {"name": "小明"}
     xiaoming["age"] = 18  # 添加键值对
     xiaoming["name"] = "小李"  # 修改键值对中的值
     print(xiaoming["name"])  # 在中括号中输入要取出值的键
     

   • 删除键值对

     xiaoming = {"name": "小明"}
     xiaoming["age"] = 18  # 添加键值对
     xiaoming["name"] = "小李"  # 修改键值对中的值
     xiaoming.pop("age")  # 使用pop()函数来删除指定的键值对
     print(xiaoming["name"])  # 在中括号中输入要取出值的键
     

3. 字典的统计、合并、清空操作

   • 统计字典中键值对的数量：len()函数统计键值对的数量

   • 合并两个字典

     xiaoming = {"name": "小明",
                "age": 18}
     temp = {"height": 1.75,
            "age": 19}
     xiaoming.update(temp)  # 使用update()函数来合并两个字典，如果两个字典有重复的键则括号内部的字典取代.前面的字典
     

   • 清空字典：使用clear()方法可以清空所有的键值对

   • 只有不可变类型才可以用作字典的key，可变类型(列表和字典)不能定义为字典的key

4. 字典的循环遍历

   xiaoming = {"height": 182,
              "age": 18}
   # 在日常使用中一般不对字典进行遍历，因为字典的值类型不同，遍历输出类型无法统一
   for temp in xiaoming:  # temp是获取到到key
       print("%s-%d" % (temp,xiaoming[temp]))  # 此处temp不需要打引号，此处temp包括引号
   

1.2.12.3字典和列表组合的应用场景

1. 在列表中插入字典，用字典当成列表的元素然后遍历列表

   card_list = [
       {"name": "张三",
       "age": 19},
       {"name": "李四",
        "age": 20}
   ]
   for k in card_list:
       print(k)
   

1.2.13字符串

1.2.13.1定义和基本使用

1. python可以用双引号或者单引号来定义一个字符串，但是在日常的编程学习过程中通常使用双引号来定义字符串

2. 单引号中使用双引号可以输出双引号，双引号中使用单引号可以输出单引号

3. 字符串的取值：

   str1 = "hello python"
   print(str1[6])  # 通过索引取出字符串中的值
   

4. 字符串的遍历

   str1 = "hello python"
   for k in str1:
       print(k, end="")
   

5. len()函数统计字符串的长度

   str1 = "hello python"
   print(len(str1))
   

6. count()方法统计特定字符出现的次数

   str1 = "hello python"
   print(str1.count("on"))
   

7. 使用index()方法取出指定字符的索引位置

   str1 = "hello python"
   print(str1.index("llo"))  # 当字符串出现多次时，默认显示第一次出现的索引,取出字符串的索引时默认是该字符串第一个字符的位置
   

1.2.13.2字符串的常用方法

1. 判断类型的方法：

   • 判断字符串是否是空白字符(\r\t\n以及空格都默认是空白字符)：isspace()，如果是就返回True

     str1 = "  \r"
     print(str1.isspace())
     

   • String.isalnum()：如果一个字符串至少有一个字符并且所有的字符串都是字母或者数字则返回True

   • String.isalpha()：如果一个字符串至少有一个字符并且所有的字符串都是字母则返回True

   • String.isdecimal()：如果一个字符串只包含全角数字则返回True，不能判断小数

   • String.isdigit()：如果一个字符串只包含数字(全角数字、(1)类型的数字(就是字符串内部的内容为(1))、\u00b2)则返回True，不断判断小数

   • String.isnumeric()：如果一个字符串只包含数字(全角数字、汉字数字、(1)类型的数字(就是字符串内部的内容为(1))、\u00b2)则返回True，不能判断小数

   • String.istitle()：如果一个字符串每个单词的首字母大写则返回True

     str1 = "Hello python"
     print(str1.istitle())
     

   • String.islower()：如果一个字符串全部都是小写字母则返回True

   • String.isupper()：如果一个字符串全部都是大写字母则返回True

2. 字符串的查找和替换方法

   • String.startswith(str)：检查字符串是否以str开头，是则返回True

   • String.endswith(str)：检查字符串是否以str结束，是则返回True

   • String.find(str, start=0, end=len(string))：检测str是否包含在string中，如果start和end指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1

     str_01 = "qwertyuiop"
     temp_01 = str_01.find("wer")  # 判断字符串是否在指定字符串中，如果在返回索引，如果不在返回-1
     temp_02 = str_01.find("ert",2,5)  # 判断字符串是否在指定区间的字符串中，2和5表示索引，区间包括2但不包5，如果在返回索引，如果不在返回-1
     print(temp_01, temp_02)
     

   • String.rfind(str, start=0, end=len(string))：类似于find()函数，不过是从右边开始查找，但返回的仍然是第一个字符的索引而不是最后一个字符的索引

   • String.index(str,start=0,end=len(string))：跟find()方法相似，只不过如果str不在string会报错

   • Sting.rindex(str,start=0,end=len(string))：类似于index()，不过是从右边开始

   • String.replace(old_str,new_str,num=string.count(old))：把string中的old_string替换成new_string，如果num指定则替换不超过num次，但这种替换不会修改原来字符串的内容只是replace方法输出的内容被改变

3. 大小写转换

   • String.capitalize()：把字符串第一个字符大写

   • String.title()：把字符串每个单词的首字母大写

     str_01 = "hello python"
     temp_01 = str_01.capitalize()  # 只将索引为0的字母变为大写
     temp_02 = str_01.title()  # 将字符串中每个单词的首字母变为大写
     print(str_01)
     print(temp_01)
     print(temp_02)
     

   • String.lower()：转换string中所有大写字母为小写

   • String.upper()：转换string中所有小写字母为大写

   • String.swapcase()：翻转string中的大小写

4. 文本对齐

   • String.ljust(width)：返回一个原字符串左对齐，并使用空格填充至长度width的新字符串

   • String.rjust(width)：返回一个原字符串右对齐，并使用空格填充至长度width的新字符串

   • String.center(width)：返回一个原字符串居中，并使用空格填充至长度width的新字符串

     poem = ["登鹳雀楼",           
             "王之涣",            
             "白日依山尽",          
             "黄河入海流",          
             "欲穷千里目",          
             "更上一层楼"]          
     for poem_str in poem:     
         print("｜%s｜" % (poem_str.center(100," ")))  # 这里不输入空格只写100也可以，表明使用默认的空格            
     """这里的左对齐表示每行靠左顶格输出且每行输出后空
     右对齐表示每行输出靠右且每行输出距离左边边界100个
     居中对齐表示每行输出距离左右边界各5个空格"""  
     

5. 去除空白字符

   • String.lstrip()：截掉字符串左边的空白字符
   • String.rstrip()：截掉字符串右边的空白字符
   • String.strip()：截掉字符串左右两边的空白字符
   • 说明：上述三种方法都不能截掉字符串中间的空白字符

6. 拆分和拼接字符串

   • String.partition(str)：把字符串string分成一个3元素的元祖(str前面，str，str后面)

   • String.rpartition(str)：类似partition方法，只不过是从右边开始查找,但输出仍然是从左边开始输出且输出是一个元祖

   • String.split(str="",num)：以str为分隔符拆分string，如果num有指定值则仅分割num+1个字符串,该方法返回的是一个列表；如果没有指定str(即没有指定分隔符)，则默认使用包含\r,\t,\n和空格的空白字符来进行分割

   • String.splitlines()：按照行(\r,\n,\r\n)分割，返回一个包含各行作为元素的列表

   • String.join(seq)：以string作为分隔符，将seq中所有的元素(的字符串表示)合并为一个新的字符串

     str_01 = "   abc   def   ghi\t\n  hui\t"
     print(str_01.split())  # 什么参数都不写会按照默认的空白字符来进行分割字符串，该函数返回的是一个列表
     str_02 = "".join(str_01.split())  # 将括号内变量的内容进行连接，连接的字符为""内部的字符，一般括号内部的内容是一个类似列表格式的元素
     print(str_02)
     print(str_02.partition("cde"))  # 返回的是一个元祖
     

7. 切片和倒序索引

   • 切片适用于字符串、列表、元祖

   • 切片的语法：待切片的内容[开始索引:结束索引:步长]：开始索引就是第一刀的位置，结束索引就是第二刀的位置；按顺序索引进行切片：结束索引所在的元素不在切片之内；如果设定开始索引为0，步长为2则表示隔一个字符进行切片，可以理解为一个一个进行切片，第一个且索引为0的元素，第二个切索引为2的元素；如果将开始索引设置为0，结束索引设置为-1则最后一个元素不在切片内，可以将结束索引不写就可以切到整个索引

   • 倒序索引：最后一个字符对应的索引为-1，倒数第二个为-2

   • 图片理解切片

     [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-V17KeNJH-1581325663322)(/Users/dedicationyu/Pictures/Photos Library.photoslibrary/originals/6/6DD6233D-DA37-4A7A-B2F4-1D5146AA0FD5.png)]

   • 代码理解切片

     num_str = "0123456789"
     num_str_01 = num_str[1:4]  # 将123进行切片，同理包括左边不包括右边
     num_str_02 = num_str[1:]  # 将1之后的内容进行切片，只用写1所在的索引，结束索引不写但冒号必须有
     num_str_03 = num_str[:6]  # 将5之前但内容进行切片，只需写5后面但索引，开始索引不需要写但冒号必须有
     num_str_04 = num_str[:]  # 截取完整但字符串
     num_str_05 = num_str[::2]  # 从0开始每隔一个字符串取一个字符串
     num_str_06 = num_str[-2:]  # 截取最后两个字符89
     num_str_07 = num_str[-1::-1]  # 倒序切片(将字符串通过切片的方式进行倒序输出)，这里也可以不写开始索引，-1默认从最后一个开始切片
     print(num_str_01)
     print(num_str_02)
     print(num_str_03)
     print(num_str_04)
     print(num_str_05)
     print(num_str_06)
     print(num_str_07)
     # 总结：开始索引和结束索引确定切片的范围，步长确定切片的内容，如果不指明步长就默认将范围内的内容全部进行切片；对于步长而言，2表示从左至右隔一个切片，-2表示从右往左隔一个切片，切哪个索引就表示取出索引所在的字符
     

1.2.14公共方法

1.2.14.1python内置函数

1. 公共方法的概念：就是列表、索引、字典、字符串等都可以使用的方法就是公共方法
2. 内置函数的概念：就是不需要导入相应的模块就可以直接使用的函数就是内置函数
3. python的5大内置函数
   • len(item)：计算容器(item)中元素的个数，所谓容器可以形象的理解为装元素的东西，像集合、列表、元祖、字符串甚至一个变量都可以理解为容器，它们内部都装了元素
   • del(item)：删除变量；在python中del有两种表现形式，一种以关键字的形式出现，一种以函数的形式出现，这两种方式效果完全一致，python为了保证和其它函数的一致性就将del也以函数的形式出现
   • max(item)：返回容器中元素的最大值，如果容器是字典比较的是key的大小，返回的是最大的key,是一个字符串类型
   • min(item)：返回容器中元素的最小值，如果容器是字典比较的是key的大小，返回的是最小的key,是一个字符串类型
   • python3中可以用比较运算符比较容器的大小，对于像列表这种包含多个元素的容器而言，是按照顺序从左至右比较大小的，但注意字典之间是不能比较大小的

1.2.14.2切片

1. 切片的说明：切片是使用索引值来进行范围限定，所以向元祖、列表、字符串这些有索引位置的都可以使用切片，但像字典这种没有索引位置的不可以使用切片

1.2.14.3运算符

1. +：在字符串、列表、元祖中都可以用来实现拼接(最后输出一个新的字符串、列表、元祖)
2. *：在字符串、列表、元祖中都可以用来实现重复(最后输出一个新的字符串、列表、元祖)，由于字典的key唯一所以不能重复
3. in：在字符串、列表、元祖、字典中都可以用来判断元素是否存在(3 in (1,2,3)的结果为True)，注意在字典中判断的是key，被称为成员运算符
4. not in：在字符串、列表、元祖、字典中都可以用来判断元素是否不存在(4 not in (1,2,3)的结果为True)，注意在字典中判断的是key，被称为成员运算符
5. >,<,<=,>=,==：在字符串、列表、元祖中用来进行元素比较

1.2.14.3完整的for循环语法

1. 语法格式：

   for 变量 in 集合：
   
   	循环体代码
   else:
     没有通过break退出循环，循环结束后会执行的代码
   

2. for else循环的实际应用

   # 使用迭代遍历来判断容器中是否有我们所需要的值(判读要查找的学生是否是本校的学生)
   name = [
       {"name": "张三"},
       {"name": "李四"}
   ]
   name_find = input("请输入要查找的姓名：")
   for name_stu in name:
       if name_stu["name"] == name_find:
           print("你所查找的姓名为%s的在我们的学校" % name_find)
           break  # 查找成功则不需要继续遍历，结束循环
   else:
       print("你所查找的姓名为%s的不在我们的学校" % name_find)
   print("查找完毕")
   

3. 说明：在日常的开发中一般使用for遍历不会使用else，当使用嵌套遍历时来进行相关查询时，如果需要输出查询未果的消息提示时可以使用else来进行实现

1.2.15名片管理系统

1.2.15.1框架搭建

1.2.15.1.1目标

1. 准备文件，确定文件名，保证能够在需要的都位置编写代码
2. 编写主运行循环，实现基本的用户输入和判断

1.2.15.1.2文件准备

1. 新建一个cards_main.py程序保存主程序功能代码
2. 新建一个cards_tools.py程序保存所有的名片和函数：
   • 将对名片的新增、查询、删除、修改等功能封装在不同的函数中

1.2.15.1.3用户输入判断和pass关键字

1. 在主函数中实现用户输入的判断

   action_str = input("请输入你要执行的操作：")
   print("你选择的操作是【%s】" % action_str)
   # 输入其它内容提示输入错误请重新输入
   else:
       print("你的输入不正确请重新输入")
   

1.2.15.1.4无限循环保证用户能够重复选择操作

1. TODO注释的使用：

   • 格式：# TODO(kl@gmail.com): Use a “*” here for string repetition.
   • 说明：TODO注释应该在所有开头处包含”TODO”字符串, 紧跟着是用括号括起来的你的名字, email地址或其它标识符. 然后是一个可选的冒号. 接着必须有一行注释, 解释要做什么. 主要目的是为了有一个统一的TODO格式, 这样添加注释的人就可以搜索到(并可以按需提供更多细节). 写了TODO注释并不保证写的人会亲自解决问题. 当你写了一个TODO, 请注上你的名字.
   • 应用：在日常开发中当一个功能需要实现但还未实现为防止遗忘该处有一个共功能需要实现就需要写TODO注释用来标注这里有一个什么样的功能需要谁来实现，括号内写需要实现该功能的程序员，冒号后面写需要实现什么样的功能，按住alt+6就可以快速查看一个程序中有哪些功能还未实现，并通过点击的形式快速定位到这些TODO注释以便来进行代码说明
   • 问题：在pycharm中出现TODO无法使用的情况即该注释无法使用

2. 在主函数中实现无限循环

   while True:
       action_str = input("请输入你要执行的操作：")
       print("你选择的操作是【%s】" % action_str)
       # 1,2,3是针对名片的操作
       if action_str in ["1", "2", "3"]:
           pass  # 在开始编写框架时不写具体要实现的功能但为了保证代码能够过运行可以使用pass关键字来进行占位
       # 0是退出系统
       elif action_str == "0":
           print("欢迎再次使用名片管理系统")
           break
       # 输入其它内容提示输入错误请重新输入
       else:
           print("你的输入不正确请重新输入")
   

1.2.15.1.5if嵌套判断用户的具体操作预留代码位置

1. 在主函数中实现循环嵌套判断用户操作

   # 无限循环执行操作，由用户决定什么时候退出循环
   while True:
       action_str = input("请输入你要执行的操作：")  # 这里不要使用int进行转换，否则用户输入不是数字时会报错
       print("你选择的操作是【%s】" % action_str)
       # 1,2,3是针对名片的操作
       if action_str in ["1", "2", "3"]:  # 可以在此处增加断点来判断所写的判断语句是否可以达到功能需求
           # 新增名片
           if action_str == "1":
               pass
           # 显示全部名片
           elif action_str == "2":
               pass
           # 查询名片
           elif action_str == "3":
               pass
       # 0是退出系统
       elif action_str == "0":
           print("欢迎再次使用名片管理系统")
           break
       # 输入其它内容提示输入错误请重新输入
       else:
           print("你的输入不正确请重新输入")
   

1.2.15.1.6显示欢迎界面及功能菜单

1. 在tools函数中实现欢迎界面的函数编写

   def show_menu():
       """显示菜单"""
       print("*" * 50)
       print("欢迎使用【名片管理系统】V1.0")
       print("输入数字1可以新增名片")
       print("输入数字2可以显示全部")
       print("输入数字3可以搜索名片")
       print("输入数字0可以退出系统")
       print("*" * 50)
   

2. 在主函数中调用tools中有关欢迎界面的函数来实现欢迎界面的功能

   import cards_tools
   # 无限循环执行操作，由用户决定什么时候退出循环
   while True:
       cards_tools.show_menu()  # 导入show_menu()函数来实现欢迎界面的显示
       action_str = input("请输入你要执行的操作：")  # 这里不要使用int进行转换，否则用户输入不是数字时会报错
       print("你选择的操作是【%s】" % action_str)
       # 1,2,3是针对名片的操作
       if action_str in ["1", "2", "3"]:  # 可以在此处增加断点来判断所写的判断语句是否可以达到功能需求
           # 新增名片
           if action_str == "1":
               pass
           # 显示全部名片
           elif action_str == "2":
               pass
           # 查询名片
           elif action_str == "3":
               pass
       # 0是退出系统
       elif action_str == "0":
           print("欢迎再次使用名片管理系统")
           break
       # 输入其它内容提示输入错误请重新输入666
       else:
           print("你的输入不正确请重新输入")
   

1.2.15.1.7准备名片操作函数

1. 在tools函数中编写名片相关的操作函数

   def show_menu():
       """显示菜单"""
       print("*" * 50)
       print("欢迎使用【名片管理系统】V1.0")
       print("输入数字1可以新增名片")
       print("输入数字2可以显示全部")
       print("输入数字3可以搜索名片")
       print("输入数字0可以退出系统")
       print("*" * 50)
   
   
   def new_card():
       """新增名片"""
       print("新增名片")
   
   
   def show_all():
       """显示所有名片"""
       print("显示所有名片")
   
   
   def search_card():
       """搜索名片"""
       print("搜索名片")
   

2. 在主函数调用相关的名片操作函数

   import cards_tools
   # 无限循环执行操作，由用户决定什么时候退出循环
   while True:
       cards_tools.show_menu()  # 导入show_menu()函数来实现欢迎界面的显示
       action_str = input("请输入你要执行的操作：")  # 这里不要使用int进行转换，否则用户输入不是数字时会报错
       print("你选择的操作是【%s】" % action_str)
       # 1,2,3是针对名片的操作
       if action_str in ["1", "2", "3"]:  # 可以在此处增加断点来判断所写的判断语句是否可以达到功能需求
           # 新增名片
           if action_str == "1":
               cards_tools.new_card()  # 调用new_card()函数来实现新增名片的功能
           # 显示全部名片
           elif action_str == "2":
               cards_tools.show_all()  # 调用show_all()函数来实现显示全部名片的功能
           # 查询名片
           elif action_str == "3":
               cards_tools.search_card()  # 调用search_card()函数来实现查询名片的功能
       # 0是退出系统
       elif action_str == "0":
           print("欢迎再次使用名片管理系统")
           break
       # 输入其它内容提示输入错误请重新输入666
       else:
           print("你的输入不正确请重新输入")
   
   

1.2.15.2数据结构的确定

1.2.15.2.1确定名片管理系统的数据结构

1. 在tools中定义列表变量

   # 记录所有的名片字典
   card_list = []  # 定义一个初始为空的名片列表
   
   
   def show_menu():
       """显示菜单"""
       print("*" * 50)
       print("欢迎使用【名片管理系统】V1.0")
       print("输入数字1可以新增名片")
       print("输入数字2可以显示全部")
       print("输入数字3可以搜索名片")
       print("输入数字0可以退出系统")
       print("*" * 50)
   
   
   def new_card():
       """新增名片"""
       print("新增名片")
   
   
   def show_all():
       """显示所有名片"""
       print("显示所有名片")
   
   
   def search_card():
       """搜索名片"""
       print("搜索名片")
   

1.2.15.3新增名片

1.2.15.3.1新增名片功能实现

1. 在tools中实现新增名片的功能

   # 记录所有的名片字典
   card_list = []  # 定义一个初始为空的名片列表
   
   
   def show_menu():
       """显示菜单"""
       print("*" * 50)
       print("欢迎使用【名片管理系统】V1.0")
       print("输入数字1可以新增名片")
       print("输入数字2可以显示全部")
       print("输入数字3可以搜索名片")
       print("输入数字0可以退出系统")
       print("*" * 50)
   
   
   def new_card():
       """新增名片"""
       print("新增名片")
       # 1.提示用户输入名片的详细信息
       name_str = input("请输入姓名：")
       phone_str = input("请输入电话：")
       email_str = input("请输入邮箱：")
       qq_str = input("请输入QQ：")
       # 2.将用户的输入信息封装成一个名片字典
       card_dict = {"name": name_str,
                    "phone": phone_str,
                    "email": email_str,
                    "qq": qq_str}
       # 3.将名片字典添加到名片列表中
       card_list.append(card_dict)
       print(card_list)
       # 4.提示用户添加成功
       print("添加%s的名片成功" % name_str)
   
   
   def show_all():
       """显示所有名片"""
       print("显示所有名片")
   
   
   def search_card():
       """搜索名片"""
       print("搜索名片")
   

2. pycharm批量修改变量名的技巧

   • 在需要修改的变量名上右击鼠标选择Refactor(重构)然后选择Rename，当变量名出现红色边框时即可开始修改，按住回车键就可以结束修改

1.2.15.4显示全部

1.2.15.4.1遍历列表显示字典

1. 在tools中通过遍历将列表中的信息全部显示

   # 记录所有的名片字典
   card_list = []  # 定义一个初始为空的名片列表
   
   
   def show_menu():
       """显示菜单"""
       print("*" * 50)
       print("欢迎使用【名片管理系统】V1.0")
       print("输入数字1可以新增名片")
       print("输入数字2可以显示全部")
       print("输入数字3可以搜索名片")
       print("输入数字0可以退出系统")
       print("*" * 50)
   
   
   def new_card():
       """新增名片"""
       print("新增名片")
       # 1.提示用户输入名片的详细信息
       name_str = input("请输入姓名：")
       phone_str = input("请输入电话：")
       email_str = input("请输入邮箱：")
       qq_str = input("请输入QQ：")
       # 2.将用户的输入信息封装成一个名片字典
       card_dict = {"name": name_str,
                    "phone": phone_str,
                    "email": email_str,
                    "qq": qq_str}
       # 3.将名片字典添加到名片列表中
       card_list.append(card_dict)
       print(card_list)
       # 4.提示用户添加成功
       print("添加%s的名片成功" % name_str)
   
   
   def show_all():
       """显示所有名片"""
       print("显示所有名片")
       # 打印表头
       for card_table_head in ["姓名", "电话", "邮箱", "QQ"]:
           print(card_table_head,end="\t\t")  # \t的数量多少影响空格的大小
       print("")  # 输出一个空字符保证表头部分输出完毕后换行
       # 遍历显示列表中所有名片的字典信息
       for card_dict_temp in card_list:
           print("%s\t\t%s\t\t%s\t\t%s\t\t" % (card_dict_temp["name"],
                                               card_dict_temp["phone"],
                                               card_dict_temp["email"],
                                               card_dict_temp["qq"]))
   
   
   
   def search_card():
       """搜索名片"""
       print("搜索名片")
   

1.2.15.4.2判断列表数量，列表中没有任何名片直接输出提示不输出其它内容

1. 在tools中实现列表为空时输出提示同时不输出任何其它内容

   # 记录所有的名片字典
   card_list = []  # 定义一个初始为空的名片列表
   
   
   def show_menu():
       """显示菜单"""
       print("*" * 50)
       print("欢迎使用【名片管理系统】V1.0")
       print("输入数字1可以新增名片")
       print("输入数字2可以显示全部")
       print("输入数字3可以搜索名片")
       print("输入数字0可以退出系统")
       print("*" * 50)
   
   
   def new_card():
       """新增名片"""
       print("新增名片")
       # 1.提示用户输入名片的详细信息
       name_str = input("请输入姓名：")
       phone_str = input("请输入电话：")
       email_str = input("请输入邮箱：")
       qq_str = input("请输入QQ：")
       # 2.将用户的输入信息封装成一个名片字典
       card_dict = {"name": name_str,
                    "phone": phone_str,
                    "email": email_str,
                    "qq": qq_str}
       # 3.将名片字典添加到名片列表中
       card_list.append(card_dict)
       print(card_list)
       # 4.提示用户添加成功
       print("添加%s的名片成功" % name_str)
   
   
   def show_all():
       """显示所有名片"""
       print("显示所有名片")
       # 判断列表中是否有值，当列表为空时输出提示同时不输出其它任何信息
       if len(card_list) == 0:
           print("当前列表中没有任何名片记录")
           return  # 在函数中return关键字如果不添加任何内容表示该函数中return后面的内容都不会执行，return语句时函数的最后一行代码，后面的内容都不会执行，不管return后面有没有语句
       # 打印表头
       for card_table_head in ["姓名", "电话", "邮箱", "QQ"]:
           print(card_table_head,end="\t\t")  # \t的数量多少影响空格的大小
       print("")  # 输出一个空字符保证表头部分输出完毕后换行
       # 遍历显示列表中所有名片的字典信息
       for card_dict_temp in card_list:
           print("%s\t\t%s\t\t%s\t\t%s\t\t" % (card_dict_temp["name"],
                                               card_dict_temp["phone"],
                                               card_dict_temp["email"],
                                               card_dict_temp["qq"]))
   
   
   
   def search_card():
       """搜索名片"""
       print("搜索名片")
   

1.2.15.5查询名片

1.2.15.5.1查询功能的实现

1. 在tools中实现查询功能

   # 记录所有的名片字典
   card_list = []  # 定义一个初始为空的名片列表
   
   
   def show_menu():
       """显示菜单"""
       print("*" * 50)
       print("欢迎使用【名片管理系统】V1.0")
       print("输入数字1可以新增名片")
       print("输入数字2可以显示全部")
       print("输入数字3可以搜索名片")
       print("输入数字0可以退出系统")
       print("*" * 50)
   
   
   def new_card():
       """新增名片"""
       print("新增名片")
       # 1.提示用户输入名片的详细信息
       name_str = input("请输入姓名：")
       phone_str = input("请输入电话：")
       email_str = input("请输入邮箱：")
       qq_str = input("请输入QQ：")
       # 2.将用户的输入信息封装成一个名片字典
       card_dict = {"name": name_str,
                    "phone": phone_str,
                    "email": email_str,
                    "qq": qq_str}
       # 3.将名片字典添加到名片列表中
       card_list.append(card_dict)
       print(card_list)
       # 4.提示用户添加成功
       print("添加%s的名片成功" % name_str)
   
   
   def show_all():
       """显示所有名片"""
       print("显示所有名片")
       # 判断列表中是否有值，当列表为空时输出提示同时不输出其它任何信息
       if len(card_list) == 0:
           print("当前列表中没有任何名片记录")
           return  # 在函数中return关键字如果不添加任何内容表示该函数中return后面的内容都不会执行
       # 打印表头
       for card_table_head in ["姓名", "电话", "邮箱", "QQ"]:
           print(card_table_head,end="\t\t")  # \t的数量多少影响空格的大小
       print("")  # 输出一个空字符保证表头部分输出完毕后换行
       # 遍历显示列表中所有名片的字典信息
       for card_dict_temp in card_list:
           print("%s\t\t%s\t\t%s\t\t%s\t\t" % (card_dict_temp["name"],
                                               card_dict_temp["phone"],
                                               card_dict_temp["email"],
                                               card_dict_temp["qq"]))
   
   
   
   def search_card():
       """搜索名片"""
       print("搜索名片")
       # 提示用户输入要搜索的姓名
       name_find = input("请输入要搜索的姓名：")
       # 遍历名片列表，查询要搜索的姓名，如果没有找到需要提示用户
       for find_temp in card_list:
           if find_temp["name"] == name_find:  # 如果查询到要搜索的姓名则输出对应的信息
               print("------搜索到%s的信息------" % name_find)
               for card_table_head in ["姓名", "电话", "邮箱", "QQ"]:  # 打印表头
                   print(card_table_head, end="\t\t")  # \t的数量多少影响空格的大小
               print("")
               print("%s\t\t%s\t\t%s\t\t%s\t\t" % (find_temp["name"],
                                                   find_temp["phone"],
                                                   find_temp["email"],
                                                   find_temp["qq"]))
               break  # 查询到就结束遍历
           else:
               print("抱歉没有查到%s的相关信息" % name_find)
   

1.2.15.5.2处理名片函数

1. 在tools中对查询到的名片进行处理操作，封装一个处理名片的函数，然后在查询函数中调用来实现处理的功能

   # 记录所有的名片字典
   card_list = []  # 定义一个初始为空的名片列表
   
   
   def show_menu():
       """显示菜单"""
       print("*" * 50)
       print("欢迎使用【名片管理系统】V1.0")
       print("输入数字1可以新增名片")
       print("输入数字2可以显示全部")
       print("输入数字3可以搜索名片")
       print("输入数字0可以退出系统")
       print("*" * 50)
   
   
   def new_card():
       """新增名片"""
       print("新增名片")
       # 1.提示用户输入名片的详细信息
       name_str = input("请输入姓名：")
       phone_str = input("请输入电话：")
       email_str = input("请输入邮箱：")
       qq_str = input("请输入QQ：")
       # 2.将用户的输入信息封装成一个名片字典
       card_dict = {"name": name_str,
                    "phone": phone_str,
                    "email": email_str,
                    "qq": qq_str}
       # 3.将名片字典添加到名片列表中
       card_list.append(card_dict)
       print(card_list)
       # 4.提示用户添加成功
       print("添加%s的名片成功" % name_str)
   
   
   def show_all():
       """显示所有名片"""
       print("显示所有名片")
       # 判断列表中是否有值，当列表为空时输出提示同时不输出其它任何信息
       if len(card_list) == 0:
           print("当前列表中没有任何名片记录")
           return  # 在函数中return关键字如果不添加任何内容表示该函数中return后面的内容都不会执行
       # 打印表头
       for card_table_head in ["姓名", "电话", "邮箱", "QQ"]:
           print(card_table_head,end="\t\t")  # \t的数量多少影响空格的大小
       print("")  # 输出一个空字符保证表头部分输出完毕后换行
       # 遍历显示列表中所有名片的字典信息
       for card_dict_temp in card_list:
           print("%s\t\t%s\t\t%s\t\t%s\t\t" % (card_dict_temp["name"],
                                               card_dict_temp["phone"],
                                               card_dict_temp["email"],
                                               card_dict_temp["qq"]))
   
   
   
   def search_card():
       """搜索名片"""
       print("搜索名片")
       # 提示用户输入要搜索的姓名
       name_find = input("请输入要搜索的姓名：")
       # 遍历名片列表，查询要搜索的姓名，如果没有找到需要提示用户
       for find_temp in card_list:
           if find_temp["name"] == name_find:  # 如果查询到要搜索的姓名则输出对应的信息
               print("------搜索到%s的信息------" % name_find)
               for card_table_head in ["姓名", "电话", "邮箱", "QQ"]:  # 打印表头
                   print(card_table_head, end="\t\t")  # \t的数量多少影响空格的大小
               print("")
               print("%s\t\t%s\t\t%s\t\t%s\t\t" % (find_temp["name"],
                                                   find_temp["phone"],
                                                   find_temp["email"],
                                                   find_temp["qq"]))
               # 针对查找到的信息进行修改和删除的操作
               deal_card(find_temp)
               break  # 查询到就结束遍历
           else:
               print("抱歉没有查到%s的相关信息" % name_find)
   
   
   def deal_card(find_dict):
       """处理名片"""
       print(find_dict)
   

1.2.15.6处理名片

1.2.15.6.1增加分支判断用户的操作类型

1. 在tools中对查询到指定信息后的用户操作进行一个判断

   # 记录所有的名片字典
   card_list = []  # 定义一个初始为空的名片列表
   
   
   def show_menu():
       """显示菜单"""
       print("*" * 50)
       print("欢迎使用【名片管理系统】V1.0")
       print("输入数字1可以新增名片")
       print("输入数字2可以显示全部")
       print("输入数字3可以搜索名片")
       print("输入数字0可以退出系统")
       print("*" * 50)
   
   
   def new_card():
       """新增名片"""
       print("新增名片")
       # 1.提示用户输入名片的详细信息
       name_str = input("请输入姓名：")
       phone_str = input("请输入电话：")
       email_str = input("请输入邮箱：")
       qq_str = input("请输入QQ：")
       # 2.将用户的输入信息封装成一个名片字典
       card_dict = {"name": name_str,
                    "phone": phone_str,
                    "email": email_str,
                    "qq": qq_str}
       # 3.将名片字典添加到名片列表中
       card_list.append(card_dict)
       print(card_list)
       # 4.提示用户添加成功
       print("添加%s的名片成功" % name_str)
   
   
   def show_all():
       """显示所有名片"""
       print("显示所有名片")
       # 判断列表中是否有值，当列表为空时输出提示同时不输出其它任何信息
       if len(card_list) == 0:
           print("当前列表中没有任何名片记录")
           return  # 在函数中return关键字如果不添加任何内容表示该函数中return后面的内容都不会执行
       # 打印表头
       for card_table_head in ["姓名", "电话", "邮箱", "QQ"]:
           print(card_table_head,end="\t\t")  # \t的数量多少影响空格的大小
       print("")  # 输出一个空字符保证表头部分输出完毕后换行
       # 遍历显示列表中所有名片的字典信息
       for card_dict_temp in card_list:
           print("%s\t\t%s\t\t%s\t\t%s\t\t" % (card_dict_temp["name"],
                                               card_dict_temp["phone"],
                                               card_dict_temp["email"],
                                               card_dict_temp["qq"]))
   
   
   
   def search_card():
       """搜索名片"""
       print("搜索名片")
       # 提示用户输入要搜索的姓名
       name_find = input("请输入要搜索的姓名：")
       # 遍历名片列表，查询要搜索的姓名，如果没有找到需要提示用户
       for find_temp in card_list:
           if find_temp["name"] == name_find:  # 如果查询到要搜索的姓名则输出对应的信息
               print("------搜索到%s的信息------" % name_find)
               for card_table_head in ["姓名", "电话", "邮箱", "QQ"]:  # 打印表头
                   print(card_table_head, end="\t\t")  # \t的数量多少影响空格的大小
               print("")
               print("%s\t\t%s\t\t%s\t\t%s\t\t" % (find_temp["name"],
                                                   find_temp["phone"],
                                                   find_temp["email"],
                                                   find_temp["qq"]))
               # 针对查找到的信息进行修改和删除的操作
               deal_card(find_temp)
               break  # 查询到就结束遍历
           else:
               print("抱歉没有查到%s的相关信息" % name_find)
   
   
   def deal_card(find_dict):
       """处理名片"""
       print("-" * 30)
       # 提示用户要执行的操作
       action_str = input("输入数字1修改名片的相关信息，"
                          "输入数字2删除所找名片，"
                          "输入数字0返回上一级，"
                          "请输入你要执行的操作：")  # 按回车键可以将一个字符串分行输出，使代码阅读起来更加清晰
       # 判断用户的操作
       if action_str == "1":
           print("修改名片")
       if action_str == "2":
           print("删除名片")
       # 这里不需要对输入0的情况进行判断，因为在主函数中的框架下无论用户输入什么内容系统最后都会返回主界面
   

1.2.15.6.2删除名片

1. 在tools程序中执行删除指定名片的操作

   # 记录所有的名片字典
   card_list = []  # 定义一个初始为空的名片列表
   
   
   def show_menu():
       """显示菜单"""
       print("*" * 50)
       print("欢迎使用【名片管理系统】V1.0")
       print("输入数字1可以新增名片")
       print("输入数字2可以显示全部")
       print("输入数字3可以搜索名片")
       print("输入数字0可以退出系统")
       print("*" * 50)
   
   
   def new_card():
       """新增名片"""
       print("新增名片")
       # 1.提示用户输入名片的详细信息
       name_str = input("请输入姓名：")
       phone_str = input("请输入电话：")
       email_str = input("请输入邮箱：")
       qq_str = input("请输入QQ：")
       # 2.将用户的输入信息封装成一个名片字典
       card_dict = {"name": name_str,
                    "phone": phone_str,
                    "email": email_str,
                    "qq": qq_str}
       # 3.将名片字典添加到名片列表中
       card_list.append(card_dict)
       print(card_list)
       # 4.提示用户添加成功
       print("添加%s的名片成功" % name_str)
   
   
   def show_all():
       """显示所有名片"""
       print("显示所有名片")
       # 判断列表中是否有值，当列表为空时输出提示同时不输出其它任何信息
       if len(card_list) == 0:
           print("当前列表中没有任何名片记录")
           return  # 在函数中return关键字如果不添加任何内容表示该函数中return后面的内容都不会执行
       # 打印表头
       for card_table_head in ["姓名", "电话", "邮箱", "QQ"]:
           print(card_table_head,end="\t\t")  # \t的数量多少影响空格的大小
       print("")  # 输出一个空字符保证表头部分输出完毕后换行
       # 遍历显示列表中所有名片的字典信息
       for card_dict_temp in card_list:
           print("%s\t\t%s\t\t%s\t\t%s\t\t" % (card_dict_temp["name"],
                                               card_dict_temp["phone"],
                                               card_dict_temp["email"],
                                               card_dict_temp["qq"]))
   
   
   
   def search_card():
       """搜索名片"""
       print("搜索名片")
       # 提示用户输入要搜索的姓名
       name_find = input("请输入要搜索的姓名：")
       # 遍历名片列表，查询要搜索的姓名，如果没有找到需要提示用户
       for find_temp in card_list:
           if find_temp["name"] == name_find:  # 如果查询到要搜索的姓名则输出对应的信息
               print("------搜索到%s的信息------" % name_find)
               for card_table_head in ["姓名", "电话", "邮箱", "QQ"]:  # 打印表头
                   print(card_table_head, end="\t\t")  # \t的数量多少影响空格的大小
               print("")
               print("%s\t\t%s\t\t%s\t\t%s\t\t" % (find_temp["name"],
                                                   find_temp["phone"],
                                                   find_temp["email"],
                                                   find_temp["qq"]))
               # 针对查找到的信息进行修改和删除的操作
               deal_card(find_temp)
               break  # 查询到就结束遍历
           else:
               print("抱歉没有查到%s的相关信息" % name_find)
   
   
   def deal_card(find_dict):
       """处理名片"""
       print("-" * 30)
       # 提示用户要执行的操作
       action_str = input("输入数字1修改名片的相关信息，"
                          "输入数字2删除所找名片，"
                          "输入数字0返回上一级，"
                          "请输入你要执行的操作：")  # 按回车键可以将一个字符串分行输出，使代码阅读起来更加清晰
       # 判断用户的操作
       if action_str == "1":
           print("修改名片")
       if action_str == "2":
           card_list.remove(find_dict)  # 使用列表中的remove()方法来删除列表中指定的元素
           print("删除名片%s成功" % find_dict["name"])
   
       # 这里不需要对输入0的情况进行判断，因为在主函数中的框架下无论用户输入什么内容系统最后都会返回主界面
   

1.2.15.6.3修改名片

1. 在tools程序中对要修改的名片进行相关操作，实现用户输入来修改名片的相关内容

   # 记录所有的名片字典
   card_list = []  # 定义一个初始为空的名片列表
   
   
   def show_menu():
       """显示菜单"""
       print("*" * 50)
       print("欢迎使用【名片管理系统】V1.0")
       print("输入数字1可以新增名片")
       print("输入数字2可以显示全部")
       print("输入数字3可以搜索名片")
       print("输入数字0可以退出系统")
       print("*" * 50)
   
   
   def new_card():
       """新增名片"""
       print("新增名片")
       # 1.提示用户输入名片的详细信息
       name_str = input("请输入姓名：")
       phone_str = input("请输入电话：")
       email_str = input("请输入邮箱：")
       qq_str = input("请输入QQ：")
       # 2.将用户的输入信息封装成一个名片字典
       card_dict = {"name": name_str,
                    "phone": phone_str,
                    "email": email_str,
                    "qq": qq_str}
       # 3.将名片字典添加到名片列表中
       card_list.append(card_dict)
       print(card_list)
       # 4.提示用户添加成功
       print("添加%s的名片成功" % name_str)
   
   
   def show_all():
       """显示所有名片"""
       print("显示所有名片")
       # 判断列表中是否有值，当列表为空时输出提示同时不输出其它任何信息
       if len(card_list) == 0:
           print("当前列表中没有任何名片记录")
           return  # 在函数中return关键字如果不添加任何内容表示该函数中return后面的内容都不会执行
       # 打印表头
       for card_table_head in ["姓名", "电话", "邮箱", "QQ"]:
           print(card_table_head,end="\t\t")  # \t的数量多少影响空格的大小
       print("")  # 输出一个空字符保证表头部分输出完毕后换行
       # 遍历显示列表中所有名片的字典信息
       for card_dict_temp in card_list:
           print("%s\t\t%s\t\t%s\t\t%s\t\t" % (card_dict_temp["name"],
                                               card_dict_temp["phone"],
                                               card_dict_temp["email"],
                                               card_dict_temp["qq"]))
   
   
   
   def search_card():
       """搜索名片"""
       print("搜索名片")
       # 提示用户输入要搜索的姓名
       name_find = input("请输入要搜索的姓名：")
       # 遍历名片列表，查询要搜索的姓名，如果没有找到需要提示用户
       for find_temp in card_list:
           if find_temp["name"] == name_find:  # 如果查询到要搜索的姓名则输出对应的信息
               print("------搜索到%s的信息------" % name_find)
               for card_table_head in ["姓名", "电话", "邮箱", "QQ"]:  # 打印表头
                   print(card_table_head, end="\t\t")  # \t的数量多少影响空格的大小
               print("")
               print("%s\t\t%s\t\t%s\t\t%s\t\t" % (find_temp["name"],
                                                   find_temp["phone"],
                                                   find_temp["email"],
                                                   find_temp["qq"]))
               # 针对查找到的信息进行修改和删除的操作
               deal_card(find_temp)
               break  # 查询到就结束遍历
           else:
               print("抱歉没有查到%s的相关信息" % name_find)
   
   
   def deal_card(find_dict):
       """处理名片"""
       print("-" * 30)
       # 提示用户要执行的操作
       action_str = input("输入数字1修改名片的相关信息，"
                          "输入数字2删除所找名片，"
                          "输入数字0返回上一级，"
                          "请输入你要执行的操作：")  # 按回车键可以将一个字符串分行输出，使代码阅读起来更加清晰
       # 判断用户的操作
       if action_str == "1":
           find_dict["name"] = input("输入新名字：")
           find_dict["phone"] = input("输入新电话：")
           find_dict["email"] = input("输入新邮件：")
           find_dict["qq"] = input("输入新QQ：")
           print("修改名片成功")
       if action_str == "2":
           card_list.remove(find_dict)  # 使用列表中的remove()方法来删除列表中指定的元素
           print("删除名片%s成功" % find_dict["name"])
   
       # 这里不需要对输入0的情况进行判断，因为在主函数中的框架下无论用户输入什么内容系统最后都会返回主界面
   

1.2.15.6.4修改名片功能升级

1. 在tools程序中新增一个函数用来实现修改名片的相关操作

   # 记录所有的名片字典
   card_list = []  # 定义一个初始为空的名片列表
   
   
   def show_menu():
       """显示菜单"""
       print("*" * 50)
       print("欢迎使用【名片管理系统】V1.0")
       print("输入数字1可以新增名片")
       print("输入数字2可以显示全部")
       print("输入数字3可以搜索名片")
       print("输入数字0可以退出系统")
       print("*" * 50)
   
   
   def new_card():
       """新增名片"""
       print("新增名片")
       # 1.提示用户输入名片的详细信息
       name_str = input("请输入姓名：")
       phone_str = input("请输入电话：")
       email_str = input("请输入邮箱：")
       qq_str = input("请输入QQ：")
       # 2.将用户的输入信息封装成一个名片字典
       card_dict = {"name": name_str,
                    "phone": phone_str,
                    "email": email_str,
                    "qq": qq_str}
       # 3.将名片字典添加到名片列表中
       card_list.append(card_dict)
       print(card_list)
       # 4.提示用户添加成功
       print("添加%s的名片成功" % name_str)
   
   
   def show_all():
       """显示所有名片"""
       print("显示所有名片")
       # 判断列表中是否有值，当列表为空时输出提示同时不输出其它任何信息
       if len(card_list) == 0:
           print("当前列表中没有任何名片记录")
           return  # 在函数中return关键字如果不添加任何内容表示该函数中return后面的内容都不会执行
       # 打印表头
       for card_table_head in ["姓名", "电话", "邮箱", "QQ"]:
           print(card_table_head,end="\t\t")  # \t的数量多少影响空格的大小
       print("")  # 输出一个空字符保证表头部分输出完毕后换行
       # 遍历显示列表中所有名片的字典信息
       for card_dict_temp in card_list:
           print("%s\t\t%s\t\t%s\t\t%s\t\t" % (card_dict_temp["name"],
                                               card_dict_temp["phone"],
                                               card_dict_temp["email"],
                                               card_dict_temp["qq"]))
   
   
   
   def search_card():
       """搜索名片"""
       print("搜索名片")
       # 提示用户输入要搜索的姓名
       name_find = input("请输入要搜索的姓名：")
       # 遍历名片列表，查询要搜索的姓名，如果没有找到需要提示用户
       for find_temp in card_list:
           if find_temp["name"] == name_find:  # 如果查询到要搜索的姓名则输出对应的信息
               print("------搜索到%s的信息------" % name_find)
               for card_table_head in ["姓名", "电话", "邮箱", "QQ"]:  # 打印表头
                   print(card_table_head, end="\t\t")  # \t的数量多少影响空格的大小
               print("")
               print("%s\t\t%s\t\t%s\t\t%s\t\t" % (find_temp["name"],
                                                   find_temp["phone"],
                                                   find_temp["email"],
                                                   find_temp["qq"]))
               # 针对查找到的信息进行修改和删除的操作
               deal_card(find_temp)
               break  # 查询到就结束遍历
           else:
               print("抱歉没有查到%s的相关信息" % name_find)
   
   
   def deal_card(find_dict):
       """处理名片"""
       print("-" * 30)
       # 提示用户要执行的操作
       action_str = input("输入数字1修改名片的相关信息，"
                          "输入数字2删除所找名片，"
                          "输入数字0返回上一级，"
                          "请输入你要执行的操作：")  # 按回车键可以将一个字符串分行输出，使代码阅读起来更加清晰
       # 判断用户的操作
       if action_str == "1":  # 修改名片的相关信息
           find_dict["name"] = input_card_info(find_dict["name"],"输入新名字(直接按回车键可以不修改)：")
           find_dict["phone"] = input_card_info(find_dict["phone"],"输入新电话(直接按回车键可以不修改)：")
           find_dict["email"] = input_card_info(find_dict["email"],"输入新邮件(直接按回车键可以不修改)：")
           find_dict["qq"] = input_card_info(find_dict["qq"],"输入新QQ(直接按回车键可以不修改)：")
           print("修改名片成功")
       if action_str == "2":  # 删除相关的名片
           card_list.remove(find_dict)  # 使用列表中的remove()方法来删除列表中指定的元素
           print("删除名片%s成功" % find_dict["name"])
   
       # 这里不需要对输入0的情况进行判断，因为在主函数中的框架下无论用户输入什么内容系统最后都会返回主界面
   
   
   def input_card_info(dict_value, tip_message):
       """函数用来实现删除名片的操作
   
       :param dict_value: 参数传入的是原先字典中的值，用来实现不修改相关内容时可以输出原有的值
       :param tip_message: 传入提示用户修改的信息，实现修改名片的操作
       :return: 如果修改就返回修改后的值如果没有修改就返回原先的值
       """
       # 1.提示用户输入内容
       result_str = input(tip_message)
       # 2.针对用户的输入进行判断，如果用户输入了内容，直接返回结果
       if len(result_str) > 0:
           return result_str
       # 3.如果用户不输入内容，返回字典中原有的值
       else:
           return dict_value
   

1.2.15.7执行程序

1. 在终端下执行python程序的两种方式
   • 第一种：直接在python终端下通过python3+代码源程序执行
   • 第二种：在要执行的python主程序代码下的第一行输入#! python3编辑器的位置(在终端中通过which python3来查找python3的位置)

1.2.15.8管理系统总结

1.2.15.8.1系统搭建步骤

1. 确定系统的主界面(画出界面图)
2. 确定要写几个程序(一般至少有两个程序，一个主程序负责运行和主界面的设置，一个功能程序负责主界面中相关功能的实现)并创建这些程序
3. 在主函数对主界面进行代码编写，其具体实现部分用pass代替，然后运行代码保证程序能够正常运行
4. 在功能程序中对相关的功能进行完整编写，每实现一个功能在主函数中调用相关函数对代码进行测试来保证代码能够正常运行
5. 最后进行总体测试和功能完善

1.2.16变量的引用以及是否可变

1.2.16.1变量的引用

1. 变量和数据是分开存储的，变量和数据都是保存在内存中的，数据是保存在内存中的一个位置而变量是保存着数据在内存中的位置，变量中记录着数据在内存中的地址这就叫引用

2. 使用id()函数可以查看变量中保存数据的地址,在计算机中地址的本质就是一个数字

3. 在内存中对于不可变的类型数据而言同一个数据只会有一个内存给它，不会用两个内存来保存两个同样的数据，即同样的数据其内存地址是唯一的；但对于可变类型的数据而言就不存在唯一性

   a = 1
   id(a)
   b = 1
   id(b)
   a = [1,2,3]
   id(a)
   b = [1,2,3]
   id(b)
   

4. 在函数中实参向形参传递的是数据的内存地址

5. 函数的返回值返回的也是数据的内存地址

1.2.16.2可变类型和不可变类型

1. 不可变类型中的数据一旦在内存中被开发和定义后就无法修改，而可变类型的数据可以修改内存中的数据而不更改数据在内存中的地址，可以通过相关的方法来修改内存中的数据
2. 可变类型：列表、字典
3. 不可变类型：数字类型(类似int,float等)、字符串、元祖

1.2.16.3哈希(hash)

1. python中有一个内置的函数hash()，接受一个不可变类型作为一个参数，返回结果是一个整数(一般返回的是参数的内存位置)
2. 哈希是一种算法，其作用是提取数据的特征码(指纹)：相同的内容得到相同的结果，不同的内容得到不同的结果
3. 在python中，设置字典的键值对时会首先对key进行hash已决定如何在内存中保存字典的数据以便后期的增删改查

1.2.17局部变量和全局变量

1.2.17.1基本概念

1. 局部变量是在函数内部定义的变量，只能在函数内部使用
2. 全局变量是在函数外部定义的变量，所有的函数都可以使用这个变量
3. 提示：在其它开发语言中，不建议使用全局变量，因为可变范围太大导致程序不好维护

1.2.17.2局部变量

1. 局部变量的生命周期：在函数执行时局部变量被定义，当函数执行完毕后局部变量的生命周期结束，内存被回收
2. 在不同函数的内部可以定义相同的局部变量

1.2.17.3全局变量

1. pycharm中当调试一个程序时，frames栏中会显示当前正在执行的程序是哪一个模块(函数)以及当前正在执行第几行(一般在函数外执行会显示一个模块，模块名就是程序名，在函数内执行会显示函数名)，在frames栏中可以通过切换函数和模块然后点击variables来查看函数和模块内部的内存使用情况(变量的定义情况)，variables栏中会显示当前模块(函数)中的内存分配情况(就是变量的定义情况)

2. 在函数内部赋值语句不能修改全局变量的值：函数内部对全局变量的相关操作是在函数内部又重新定义了一个和全局变量同名的局部变量，所有的操作都是对该局部变量进行操作和全局变量没有任何关系，局部变量只会在函数内部实用，当函数执行完毕后局部变量生命周期结束

3. 在函数内部进行变量的相关操作时，系统会先在函数内部查找是否有相关的变量，如果有就使用该变量来进行相关的操作，如果没有就在函数外部来进行查找使用

4. global关键字修改全局变量(在函数内部修改)：

   def demo_1():
       global num  # global关键字会告诉解释器后面的变量是全局变量，可以在函数内部修改全局变量的值
       num = 2
       print(num)
   
   
   def demo_2():
       print(num)
       print(num_1)
   
   
   num = 1
   num_1 = 2
   demo_1()
   demo_2()
   

5. 在实际开发过程中，将所有的全局变量都定义到函数的上方，防止函数在执行时会回出现全局变量未定义的错误(当全局变量定义在执行函数的下方而函数内部要调用该全局变量)

6. 当局部变量和全局变量同名时，在局部变量的下方pycharm会显示一个灰色的波浪线，当将鼠标移动到上方时会显示一句话：shadows name *** from outer scope，表明该局部变量有一个同名的全局变量，在实际开发中在全局变量前面加一个前缀g_或者gl__来强调这是一个全局变量

   gl_num = 1  # 表明这是一个全局变量
   
   
   def test():
       num = 2  # 表明这是一个局部变量
       print(num)
       print(gl_num)
       
       
   test()
   

1.2.18函数的返回值和参数进阶

1.2.18.1函数参数和返回值的作用

1. 当外界希望在函数内部处理数据时可以通过参数向函数内部传递要处理的数据，一般在实际开发中，如果函数内部处理的数据不确定时就可以通过参数的形式将外界的数据传递到函数内部来进行处理
2. 函数通过返回值向外界传递函数的执行结果，在实际开发中，如果希望一个函数执行完毕后向外界输出一个执行结果则需要设置返回值

1.2.18.2函数的返回值

1.2.18.2.1利用元祖返回多个值

def measure():
    temp_01 = 1
    temp_02 = 2
    """
    在python中通过返回一个数组可以实现返回多个返回值，其中python返回一个元祖时不需要写括号，如果写括号python系统会提示不符合规则但不会报错，需要知道当看见返回值是多个值时就要知道这是一个元祖
    """
    return temp_01, temp_02  


gl_temp = measure()
print(gl_temp)

1.2.18.2.2接受返回元祖函数的方式

1. 使用多个变量来接受函数的多个返回值

   def measure():
       temp_01 = 1
       temp_02 = 2
       """
       在python中通过返回一个数组可以实现返回多个返回值，其中python返回一个元祖时不需要写括号，
       如果写括号python系统会提示不符合规则但不会报错，需要知道当看见返回值是多个值时就要知道这
       是一个元祖
       """
       return temp_01, temp_02
   
   
   # 使用多个变量来接受函数的多个返回值，其中变量的个数要和函数的返回值个数相同，其中变量分别对应每个返回值
   gl_temp_01, gl_temp_02 = measure()
   print(gl_temp_01)
   

1.2.18.2.3交换两个变量的值(不使用其它变量：面试题)

1. 解法1(常规解法)：

   a = 6
   b = 100
   # 解法1：常规解法
   a = a + b
   b = a - b
   a = a - b
   print(a)
   print(b)
   

2. 解法2(python独特解法：用元祖实现变量的交换)：

   a = 6
   b = 100
   # 解法2：python中使用元祖来交换两个变量的值
   a, b = b, a  # 右边省略了括号，其实是一个元祖，左边用两个变量来接受元祖中的两个值
   print(a)
   print(b)
   

1.2.18.3函数的参数

1.2.18.3.1在函数内部使用方法修改可变参数会影响外部实参

gl_temp_list = [1, 2, 3]


def temp_list(temp_list):
    temp_list.append(4)


temp_list(gl_temp_list)
print(gl_temp_list)
"""
起初定义的gl_temp_list变量指向列表[1, 2, 3]的位置，调用temp_list函数后将gl_temp_list变量指向的位置
传递给形式参数temp_list，则变量temp_list指向列表[1, 2, 3]的位置，然后使用temp_list.append(4)方法
向列表[1, 2, 3]末尾添加一个数字4则原列表变为[1, 2, 3, 4]，而此时gl_temp_list变量指向的是该列表的位置，
因此输出gl_temp_list会得到[1, 2, 3, 4]，即原列表的数据被修改了
"""

1.2.18.3.2在函数内部对形参赋值不会影响外部实参

gl_temp_list = [1, 2, 3]


def temp_list(temp_list):
    temp_list = [1, 2, 3, 4]


temp_list(gl_temp_list)
print(gl_temp_list)
"""
起初定义的gl_temp_list变量指向列表[1, 2, 3]的位置，调用temp_list函数后将gl_temp_list变量指向的位置
传递给形式参数temp_list，则变量temp_list指向列表[1, 2, 3]的位置，然后使用temp_list = [1, 2, 3, 4]
对变量temp_list进行新的赋值则temp_list变量断开与列表[1, 2, 3]的指向而指向新的列表[1, 2, 3, 4]，
此时gl_temp_list变量指向的是原先列表[1, 2, 3]的位置，
因此输出gl_temp_list会得到[1, 2, 3]，即原列表的数据没有被修改了
"""

1.2.18.3.3列表使用+=本质上是调用extend()方法

1. 面试题：+=

   gl_temp_list = [1, 2, 3]
   
   
   def temp_list(temp_list_temp):
       temp_list_temp += temp_list_temp  # +=在列表中的功能就相当于extend()函数，用于向一个列表末尾添加一个新的列表
   
   
   temp_list(gl_temp_list)
   print(gl_temp_list)  # 由于对可变参数使用来方法，因此外部变量会受影响
   

1.2.18.4缺省参数

1.2.18.4.1缺省参数对概念和作用

1. 定义函数时，可以给某个参数指定一个默认的值，具有默认值的参数就是缺省参数

2. 调用函数时，如果没有传入缺省参数的值，则在函数内默认使用定义函数时使用的参数默认值

3. 将常见的值设置为函数的缺省参数，从而简化函数的调用(在日常开发中，通常将参数使用最多的值设置为该参数的值以便简便使用该参宿而不需要再次传递参数)

   gl_temp_list = [1, 3, 2]
   
   
   def temp_list(temp_list_temp):
       # sort()方法没有返回值
       temp_list_temp.sort()  # 这里的参数reverse就是缺省参数，系统默认的值为False，所有可以不写表示默认
       list_01 = temp_list_temp
       print(list_01)
       temp_list_temp.sort(reverse=True)
       list_02 = temp_list_temp
       return list_02
   
   
   a = temp_list(gl_temp_list)
   print(a)
   

1.2.18.4.2指定缺省参数的默认值

def temp(name, gender=True):  # 指定缺省参数的默认值为True，一般指定缺省参数的的默认值都是以True和False来指定
    if not gender:  # 只有if后面为真时才运行后面的程序
        print("%s是%s" % (name, "女生"))
    else:
        print("%s是%s" % (name, "男生"))



temp("yfx")  # 默认使用缺省参数值为True
temp("lm", gender=False)  # 指定缺省参数值为False

1.2.18.4.3缺省参数定义的注意事项

1. 缺省参数定义必须在函数参数的末尾，也就是说缺省参数后面不能定义非缺省参数
2. 在pycharm中如何快速为新增加的函数参数添加注释说明：将鼠标移动至新增的参数上，然后点击出现的小灯泡，选择add docstring parameter **就可以快速添加参数注释

1.2.18.5多值参数

1.2.18.5.1定义和作用

1. 有时可能需要一个函数能够处理的参数时不确定的，这个时候就可以使用多值参数

2. python中有两种多值参数

   • 参数名前增加一个*可以接受元祖
   • 参数名前增加两个*可以接受字典

3. 一般在给多值参数命名时，习惯使用以下两个名字

   • *args：存放元祖参数(arguments：有变量的含义)
   • **kwargs：存放字典参数(keyword arguments：键值对参数)

4. 代码演练

   def demo(num, *args, **kwargs):
       print(num)
       print(args)
       print(kwargs)
   
   # 这里可以输入任意个参数，其中1会被自动传给num,234会被当作元祖中的元素传递给args,后面的内容会被传递给字典
   demo(1,2,3,4,name="yfx",age=18)
   

1.2.18.5.2元祖和字典的拆包

1. 在调用带有多值参数的函数时，如果希望将一个元祖变量直接传递给args或者将一个字典变量直接传递给kwargs就可以使用拆包，用来简化参数的传递

2. 拆包的方式：

   • 在元祖变量前增加一个*
   • 在字典变量前增加两个*

3. 代码演练

   tuple_temp = (1, 2, 3)
   dict_temp = {"name":"yfx",
                "age":18}
   
   
   def demo(*args, **kwargs):
       print(args)
       print(kwargs)
   
   
   # demo(tuple_temp,dict_temp)  # 这样系统会将tuple_temp和dict_temp都传递给args，不会传递给kwargs
   demo(*tuple_temp,**dict_temp)  # 这样系统会将tuple_temp传递给args，将dict_temp传递给kwargs
   # demo(1, 2, 3, name="yfx", age=18)
   """
   拆包就是将元祖或者字典中都元素拆分开，*tuple_temp拆包后的效果就是1, 2, 3；
   **dict_temp拆包后的效果就是name="yfx", age=18
   """
   

1.2.18.6递归

1.2.18.6.1递归的特点

1. 函数调用自身就称为递归(在函数内部自己调用自己)

2. 递归函数必须有一个出口，否则会出现死循环(就是对参数进行判断，当参数满足某个条件时不再执行函数)

3. 代码演练

   def number(num):
       print(num)
       # 递归的出口
       if num == 1:
           return
       # 自己调用自己
       number(num - 1)  # 在该处打一个断点可以观察到递归函数的执行情况
       print("test")
       “”“
       递归函数执行时会不断深入进行函数调用，也就是说会不断执行内部的函数，当执行到最内层函数时会遇到递归的出口，然后一层一层往上执行直到第一层函数执行完毕
       ”“”
   
   number(3)
   

1.2.18.6.2递归实现数字累加

# 定义一个函数sum_numbers
# 能够接受一个num的整数参数
# 计算1+2+3+……+num的结果
def sum_numbers(num):
    # 出口
    if num == 1:
        return 1
    # 数字的累加：num+(1+2+3+……+num-1)
    temp = sum_numbers(num - 1)  # temp用来接受递归函数的返回值
    return num + temp


result = sum_numbers(7)
print(result)
"""
思路分析：
1.确定函数的出口：这里为递归到1时出来
2.确定递归的参数：这里递归的是要求和的参数
2.确定每层函数的返回值：每层函数返回每层的递归参数和之前所有曾递归函数的返回值的和
3.进入到最底层函数然后慢慢往上进行代码的书写和判断

"""