python学习笔记_python 前插

---

一、安装python+pycharm集成开发环境

python安装教程
pycharm安装教程
python遇到的问题
给项目配置intergreter

二、基本语句

2.1 输出print()函数

可以输出数字，字符串（加单引号），含有运算符的表达式，输出到文件

2.2 转义字符

\n 换行
\t 空格
\b 退一个格
\r 覆盖
\反斜杠

ps:
如果不希望原来的转义字符起作用，就在原字符之前加上r或者R,但是最后一个字符不能是反斜杠，示例如下：

错误示例：前面有r，最后一位是反斜杠
正确示例：前面有r,最后一位可以是双斜杠

2.3 保留字和标识符

2.3.1 保留字

输入：

就会出来python默认的保留字，以下几种：

[‘False’, ‘None’, ‘True’, ‘peg_parser’, ‘and’, ‘as’, ‘assert’,
‘async’, ‘await’, ‘break’, ‘class’, ‘continue’, ‘def’, ‘del’, ‘elif’,
‘else’, ‘except’, ‘finally’, ‘for’, ‘from’, ‘global’, ‘if’, ‘import’,
‘in’, ‘is’, ‘lambda’, ‘nonlocal’, ‘not’, ‘or’, ‘pass’, ‘raise’,
‘return’, ‘try’, ‘while’, ‘with’, ‘yield’]

2.3.2 标识符

变量，函数，类，模块和其他对象起的名字就叫标识符

规则：

1.不能是保留字
2.不能以数字开头
3.严格区分大小写
4.字母，数字，下划线构成

2.4 变量定义和构成

2.4.1 变量的构成

变量由标识，类型和值构成
标识：内存地址
类型：数据类型
值：存储的具体数据

2.4.2 变量的多次赋值

2.5 数据类型

• 整数类型 int
• 浮点数类型 float
• 布尔类型 bool
• 字符串类型 str

2.5.1 整数类型（正数，附属，0）

二进制——以0b开头, 0-9
八进制——以0o开头, 0-7
十六进制——以0x开头，0-9，a-f

例子：

2.5.2 布尔类型

布尔值可以转换成整数计算
True 表示为1
False 表示为0

2.5.3 字符串类型

ps:单纯的单引号和双引号无法转行，三重的单引号和双引号可以转行

*类型转换

str()
int()
float()

转换成int类型的注意事项：

1. str类型的小数无法转换成int类型
2. 非整数的str类型也无法转换成int类型
   

ps：当将string类型与int类型连接时会报错，解决方案是进行类型转换，例如：

转换成float类型

2.6 注释

单行注释 #
多行注释 ‘’‘ 或者 “”"

2.7 输入input()函数

input函数默认输入的是字符串类型，印证如下：

改进以后，将str类型转换成int类型

2.8 运算符

2.8.1 算术运算符

注意：整除 // 的时候，一正一负向下取整

另外，取模运算的时候，余数的公式=被除数-除数×商
所以 9%-4的结果 9-（-4）×（-3）=-3

2.8.2 赋值运算符

1.执行顺序为从右向左
2.支持链式赋值， 比如a=b=c=20
3.支持参数赋值 +=、-=、*=、/=、//=、%=
4.支持系列解包赋值 a,b,c=20,30,40

2.8.3 比较运算符
对变量或表达式的结果进行大小，真假的比较，分别为：

1. ->, <, >=, <=, !=
2. ==
3. is, is not

注意：
比较运算符的结果类型为bool类型
==比较的是值是否相等，is比较的是id是否相等

2.8.4 布尔运算符

and
-true and true true
-其余为false

or
-false or false 结果为false
-其余为true

not 对布尔类型操作数取反
-not false 为true
-not true 为false

---

in与not in的运算

---

2.8.5 位运算

-按位与 & 对应结果都为1，结果为1，否则为0
-按位或 | 对应结果都为0，结果为0，否则为1
-左移位运算<<
-右移位运算>>

2.8.6 运算符的优先级

三、程序的组织结构

3.1 顺序结构

3.2 选择结构-分支结构

3.2.1 对象的布尔值

双分支结构

多分支结构：

嵌套if的使用：

3.3 pass语句

语句什么都不做，只是一个占位符，用在语法上需要语句的地方

3.4 内置函数 range()

• 用于生成一个整数序列
• 创建range的三种方式 -range(stop) -range(start,stop) -range(start,stop,step)

注意：不管range对象标识的整数序列有多长，所有range对象占用的内存空间都是相同的，至于再用到range对象的时候才会计算序列中的相关元素

3.5循环结构

循环的分类

• while
• for -in

3.5.1 while循环

例题，计算累加和

3.5.2 for -in循环

格式
for 自定义的变量 in 可迭代对象：
循环体

如果再循环体内不需要自定义变量，可用”_“代替

水仙花数：

3.5.3 break语句与continue语句

break指一旦满足条件，立刻退出循环结构，例如：

cotinue语句指当满足现有条件时，退出当前循环，进行下一循环，例如：

打印5的倍数

3.5.4 else语句的搭配

-和if搭配，if…else…
-和for循环&while循环搭配

例如：

3.5.5 嵌套循环

打印矩形：

打印直角三角形：

3.5.6 break和continue的复杂循环用法

break有两层嵌套的时候

continue有两层嵌套的时候：

四、列表

4.1 基础知识

1.变量可以存储一个元素，而列表可以存储许多个元素
2.列表相当于其他语言中的数组
3.列表的特点：
-列表元素按顺序有序排列
-索引映射唯一一个数据
-列表可以存重复数据
-任意数据类型混存
-根据需要动态分配和回收内存

列表的详解

4.2 获取指定元素的索引

-正向索引从0 ~ N-1
-逆向索引从-N ~ -1
-索引不存在，则会抛出Index Error

index()函数

注意1： 如果列表中存在n个相同元素，只返回相同元素中的第一个索引

注意2：如果查询的元素在列表中不存在，则会抛出ValueError

注意3：还可以在指定的start和stop之间进行查找

4.3 获取列表中的多个元素——切片操作

1.语法格式

列表名[ start: stop: step]

2.注意

1）切片范围[ start, stop]
2) step默认为1
3)step为正数，
[ :stop:step] 切片的第一个元素默认是列表的第一个元素 [start::step] 切片的最后一个元素默认是列表的最后一个元素
4）step为负数，
[:stop:step] 切片的第一个元素默认是列表的最后一个元素 [start::step] 切片的最后一个元素默认是列表的第一个元素
5）切出来的切片为新的列表对象

例1,切出来的切片为新的列表对象,因为id不一样了

例2.

4.4列表元素的判断与遍历

1.判断
in 与 not in

2.遍历

4.5 列表元素的增删改及排序

4.5.1 列表元素的添加

1.列表元素末尾增加一个元素

list.append(添加元素)

2.在列表末尾至少添加一个元素

list.extend()

3. 在任意一个位置上添加一个元素

list.insert(插入位置，插入元素)

切片：在列表的任意位置上添加N多个元素

4.5.2 列表元素的删除操作

1. list.remove(移除元素)

从列表中移除一个元素，如果有重复元素只移第一个，元素不存在则抛出ValueError

2.pop()

-根据索引移除元素
-如果指定的索引位置不存在将抛出异常
-如果不写索引值，默认删除最后一个元素

3.切片

删除至少一个元素，但是将产生新的列表对象

4.clear()与del

清空列表中的所有元素

del直接删除列表

下图中，列表直接不存在了

4.5.3 列表元素的修改操作

-为指定索引的元素赋予一个新值
-为指定切片赋予一个新值

4.5.4 列表元素的排序

list.sort() 或者list.sort(reverse=True)进行升序排序
list.sort(reverse=False)进行降序排序
这种方法不会产生新的列表元素
-------------------------------------------------------------------------------内置函数sorted()对列表进行排序时会产生新的列表元素
sorted(list)升序排序
sorted(list,reverse=True)降序排序

list.sort（）用法

sorted用法

4.5.5 列表生成式

五、字典

5.1.基础知识

1）python内置的数据结构之一，与列表一样是一个可变序列
2）以键值对的方式存储数据，字典是一个无序的序列 例如：scores={‘张三’：100，‘李四’：56}
3）元素按照关键值的hash值排序，与放进来的顺序无关

5.2 字典的常用操作

5.2.1 字典的创建

• 最常用的方式：使用花括号，如： scores={‘张三’：100，‘李四’：98，‘王五’：45}
• 使用内置函数dict（）

5.2.2 字典元素的获取

-使用[]获取元素
-使用get()方法获取元素

5.2.3 字典元素其他操作

1）key的判断
in / not in

2) 字典元素的删除

-del 删除指定的key-value对
-clear()清空字典的元素

3）新增字典元素

4）获取字典视图

• keys() 获取字典关键值
• values() 获取字典中所有
• items() 获取字典中所有key,value对

5)字典的遍历

for item in scores:
// 获取key值
…print(item)
//获取字典元素的value值
print(scores[item]) 或者
print(scores.get(item))

5.3 字典的特点

• 字典当中的所有元素都是一个key-value对，key不允许重复，value可以重复
• 字典中的元素是无序的
• 字典中的key必须是不可变对象（比如list可变就不能使用）
• 字典也可以根据需要动态的伸缩
• 字典hi浪费较大的内存，是一种使用空间换时间

5.4 字典生成式

生成过程：

所使用的函数：

内置函数zip() 用于将可迭代的对象作为参数，将对象中对应的元素打包成一个元组，然后返回这些元组组成的列表

ps:按元素少的那个部分来压缩成字典

六、元组（不可变）与集合

6.1 元组基础知识

python内置的数据结构之一，是一个不可变序列

ps:
不变可变序列——没有增、删、改的操作，如：字符串，元组
可变序列——可以进行增、删、改操作，对象地址不发生改变，如：列表、字典

6.2 元组的创建方式

-直接小括号
-使用内置函数tuple()
-只包含一个元组的元素需要使用逗号和小括号，如: t =(10, )

ps：如果元组中只有一个元素，逗号不能省略

**空元组的创建方式

6.3 注意事项：

元组中存储的是对象的引用 a)如果元组中的对象本身是不可变对象，则不能再引用其他对象
b)如果元组中的对象是可变对象，则可变对象的引用不允许改变，但数据可以改变，比如：元组中元素存在list,list不可以变为100，但是100可以添加到list中，示例如下：

正常情况

将100插入到t[1]

不允许直接插入，报错如下：

正确插入方法：

6.4 元组的遍历

-已知元组中元素个数的时候，可以使用索引
-for…in遍历

6.5集合概述

1）python内置的数据结构
2）与列表、字典一样都属于可变类型的序列
3）集合是没有value的字典，只有key

6.6 集合的创建

1.使用{}，集合中的元素不允许重复，如果重复打印的时候默认输出一个
2.使用内置函数set()

3.定义空集合
1）不可以使用 {} 直接定义空集合！！！因为 {}是字典类型
2）直接用set()函数定义

6.7 集合的相关操作

1.集合元素的判断 in or not in
2.集合的新增元素

调用add() 一次添加一个集合元素
调用update() 一次至少添加一个元素

3.集合元素的删除操作

-调用remove(),一次删除一个指定元素，如果指定元素不存在抛出KeyError
-调用discard(),一次删除一个指定元素，如果指定元素不存在不抛出KeyError
-调用pop(),一次只删除一个任意元素，注意，pop()函数不存在参数,因此括号里只能为空
-调用clear(),清空集合

6.8 集合之间的关系

1.判断是否相等 ==或者！=
注意：集合是无序的，不管两个集合中的元素排列顺序是否一样，只要元素一致就说明两个集合相等

2.判断一个集合是否是另一个集合的子集
调用issubset方法
3.判断一个集合是否是另外一个集合的超集
调用issuperset方法
4.判断两个集合有无交集
调用isdisjoint方法，有交集结果为false,没有交集结果为true！！

# 判断两个集合是否相等
s1={10,20,30,40,100,500}
s2={30,20,10,100,40,500}
print(s1==s2)
print(s1!=s2)
# 判断一个集合是否是另一个集合的子集
s1={10,20,30,40,100,500}
s2={30,20,100,40,500}
s3={10,20}
s4={1,2,3}
print(s2.issubset(s1))
print(s3.issubset(s1))
# 判断一个集合是否是另一个集合的超集
print(s1.issuperset(s2))
print(s1.issuperset(s3))
# 判断两个集合有无交集,没有交集为true，有交集为false
print(s3.isdisjoint(s1))
print(s4.isdisjoint(s3))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

结果：

6.9 集合之间的数据操作

1.取交集

-调用intersection函数
-用&符号

2.取并集

-调用union()函数
-使用或 | 符号

3.取差集（s1减去s1与s2相交的部分）

-调用difference()函数
-用减号表示

4.对称差集

调用symmetric_difference()函数

为便于理解，见下图：

6.10 集合生成式

1.用于生成集合的公式

七、字符串（不可变）

7.1 字符串的创建与驻留机制

Python的驻留机制对相同的字符串只保留一份拷贝，后续创建相同字符串时，不会开辟新空间，而是把该字符串的地址赋给新创建的变量。

驻留机制的几种情况（交互模式）：

• 字符串的长度为0或1时
  

• 符合标识符的字符串
  例子：因为abc%不是标准的标识符（字母、数字、下划线组成），所以没有驻留机制
  例2：因为s1和s2是合法的标识符，所以产生驻留机制

• 字符串只在编译时进行驻留，而非运行时
  

• [-5,256]之间的整数数字
  
  ps:pycharm进行了优化处理，所以驻留机制失效

7.2 字符串的常用操作

7.2.1 查询操作的方法
1.查询方法

• index() 查找子串substr第一次出现的位置，如果查找的子串不存在时，则抛出ValueError
• rindex() 查找子串substr第最后一次出现的位置，如果查找的子串不存在时，则抛出ValueError
• find() 查找子串substr第一次出现的位置，如果查找的子串不存在时，则返回-1
• rfind() 查找子串substr最后一次出现的位置，如果查找的子串不存在时，则返回-1

7.2.2 字符串的大小写转换操作

• upper() 把字符串中所有字符转换成大写字母
• lower() 把字符串中所有字符转换成小写字母
• swapcase() 把字符串中所有小写字母转换成大写字母，把字符串中所有大写字母转换成小写字母
• capitalize() 把第一个字符转换成大写，把其余字符转换成小写
• title() 把每个单词的第一个字符转换为大写，把每个单词的其余字符转换为小写

7.2.3 字符串内容对齐操作的方法

• center() 居中对齐
• ljust() 左对齐
• rjust() 右对齐
• zfill() 右对齐，左边用0填充

7.2.4 字符串的劈分

• split() 从字符串的左边开始劈分、sep指定劈分字符串的劈分符，maxsplit指定劈分字符串时的劈分符
• rsplit() 从字符串的右边开始劈分、sep指定劈分字符串的劈分符，maxsplit指定劈分字符串时的劈分符

7.2.5 字符串的判断

• isidentifier() 判断是否是合法的标识符
• isspace() 指定的字符串是否全部由空白字符组成
• isalpha() 指定的标识符是否全部由字母组成
• isdecimal（） 判断指定的标识符是否全部由十进制数字组成
• isnumeric() 判断指定的字符串是否全部由数字组成
• isalnum() 判断指定的字符串是否全部由字母和数字组成

7.2.6 字符串的替换

• replace() 第1个参数指定被替换的子串，第2个参数指定替换子串的字符串，该方法返回替换后得到的字符串，调用该方法时可用第3个参数指定最大替换次

7.3 字符串的比较

运算符:>,>=,<,<=,==,!=
比较规则：先比第一个，相等再比dirge，依次类推
比较原理：比较的是ordinal value(原始值)，调用内置函数ord可以得到

ps: ==与is的区别

== 比较的是value is 比较的是id是否相等

7.4 字符串的切片操作

字符串是不可变类型，不具备增删改操作，切片操作将产生新的对象

7.5 格式化字符串

格式化字符串的两种方式：

• %做占位符
• {}做占位符
• f-string

7.6 字符串的编码

1.为什么需要字符串的编码转换?

2.编码与解码

编码：将字符串转换为二进制数据（bytes）
解码：将bytes类型的数据转换成字符串类型

八、函数

7.1 函数的创建

• 格式
  def 函数名（[输入参数]):
  函数体
  [return xxx]

7.2 函数调用的参数传递

• 位置实参
  根据形参对应的位置进行实参传递
• 关键字实参
  根据形参名称进行实参传递
  
  ps: 在函数调用过程中，进行参数的传递

• 如果是不可变对象，在函数体的修改不会影响实参的值，arg1的修改为100，不会影响n1的值
• 如果是可变对象，在函数体的修改会影响到实参的值，arg2的修改为append(10),会影响到n2的值

7.3 函数的返回值

函数的返回值
（1）如果函数没有返回值，return可以省略不写
（2）函数的返回值可以是一个，直接返回原数据类型
（3）函数的返回值如果是多个，结果是元组

没有返回值和返回值为一个：

函数的返回值有多个，返回元组类型：

7.4 默认值参数

7.5 参数

1.个数可变的位置参数

定义函数时，如果无法实现确定位置实参的个数，括号里加 “*”变成fun(*args)，输出结果为一个“元组”，个数可变的位置参数只能为一个

例子1：

例子2：

2.个数可变的关键字形参

• 函数前面加两个*
• 可变的关键字喜感的输出结果为字典
• 个数可变的关键字参数只能为一个

例子1：

例子2：

3.注意
一个函数定义的过程中，既有个数可变的关键字形参，也有个数可变的位置形参，要求，位置形参放在关键字形参之前！！

7.6 递归函数

例子1：

例子2：斐波那契函数

0、1、1、2、3、5、8、13、21、34、……
F(0)=0，
F(1)=1,
F(n)=F(n - 1)+F(n - 2)（n ≥2，n ∈ N*）

九、python的异常处理机制

1. try…except…else结构

• 如果try块中没有抛出异常，则执行else块，如果try中抛出异常，则执行except块

2. try…except…else…finally结构
** finally块无论是否发生异常都会被执行，能常用来释放try块中申请的资源

3.常见的异常类型

3. traceback包

十、编程思想-面向对象和面向过程

10.1 面向对象与面向过程

10.2 类与对象

• python中一切皆对象
• 不同的数据类型属于不同的类

10.3类的创建

class Student:
  内容
1
2

类名—默认规则为由一个或多个打你组成，每个单词的首字母大写，其余小写

10.4 类的组成

• 类属性
• 实例方法
• 静态方法
• 类方法

定义一个标准的学生类：

10.5 对象的创建

1.格式：

实例名=类名（）
例如：stu=Student()

2.调用方法的两种方式：

• 对象名.方法名（）
• 类名.方法名（类的对象）

3.类属性，类方法和静态方法

• 类属性：
  
• 类方法与静态方法的使用方式
  

10.6 动态绑定属性和方法

0.动态绑定与静态绑定

• 静态绑定： 在程序执行前方法已经被绑定（也就是说在编译过程中就已经知道这个方法到底是哪个类中的方法），此时由 编译器或其它连接程序实现。
• 动态绑定： 后期绑定： 在运行时根据具体对象的类型进行绑定。

简单理解就是比如Student类中已经规定属性home=‘东北’，那所有新创建的对象stu1,stu2…stuN的home属性就都是东北，这个属于静态绑定。
但是，如果Student类中没有规定gender属性,而单纯想给一个新创建的对象stu2添加gender属性,这个属于动态绑定

1.一个Student类可以创建N多个Student类的实例对象，每个实体对象的属性值不同。

2.python是动态语言，在创建对象之后，可以动态的绑定属性和方法

例子1.动态绑定属性

例子2.动态绑定方法

10.7 面向对象的三大特征

• 封装：提高程序的安全性

将数据（属性）和行为（方法）包装到类对象中。在方法内部对属性进行类对象的外部调用方法。这样，无需关心方法内部的具体实现细节，从而降低复杂度
在python中没有专门的修饰用于属性的私有，如果该属性不希望再类对象外部被访问，前边使用两个’_‘

• 继承:提高代码的复杂度
• 多态

10.7.1 封装性的例子：

例子：使用两个’_‘对禁止类的属性被外部使用
解决方法：

10.7.2 继承

1.基础了解
1）语法格式

class 子类类名（父类1，父类2…）:
pass

2）如果一个类没有继承任何类，则默认继承object
3）python 支持多继承
4）定义子类时，必须在其构造函数中调用父类的构造函数

2.例子
例子：Person是父类，Student与Teacher都是子类继承父类

Student与Teacher继承Person类,Person类又继承Object类

例子：

多继承的理解

3.Object类

• Object类是所有类的父类，因此所有类都有Object类的属性和方法
• 内置函数dir()可以查看指定对象的所有属性
• Object有一个_str_()方法，用于返回一个对于“对象的描述”，对应于内置函数str()经常用于print()方法，帮我们查看对象的信息，所以我们经常会对_str_()进行重写

例子中可以看到默认的Object类的属性

原始数据:

后来通过str改写

10.7.3 多态

多态就是拥有多种形态，即便不知道一个变量所引用的对象是什么类型，仍然可以通过这个变量调用方法，在运行过程中根据变量所引用的对象类型，动态决定调用哪个对象中的方法

Java静态语言实现多态的三个必要条件

• 继承
• 方法重写
• 父类引用指向子类对象

python是动态语言，与java不同

例子：

10.8 特殊方法和特殊属性

1.概述

2.特殊属性
__dict__应用

__class __ 输出对象所属的类

其他特殊属性

3.特殊方法

1.add
1)add简单实例

2)字符串之间的相加

刚开始不能直接相加

使用add特殊方法之后

2.len

普通用法

求字符串的长度

3.创建对象的特殊方法 new与init

传参方式

10.9 类的赋值与浅拷贝

1.变量的赋值操作

只是形成两个变量，实际上还是指向同一个对象

2.类的浅拷贝

Python拷贝一般是浅拷贝，拷贝是，对象包含的子对象内容不拷贝，因此，元对象与拷贝对象会引用同一个子对象

3.类的深拷贝

使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象、源对象和拷贝对象左右的子对象也不相同

十一、模块和包

11.1 概述

1.一个保重可以包含N多个模块，一个模块中可以包含N多个模块，也可以包含N多个类和语句，这些模块组合在一起就成了python程序
2.在python中一个拓展名为.py的文件就是一个模块

理解图

11.2 模块的导入

1.格式

1. import 模块名称 [as 别名]

2. from 模块名称 import 函数/变量/类

例子1.

例子2.

2.如何导入自定义模块

step1.自定义一个模块calc

step2.找到需要导入模块的那个文件，右键选择Make Directory as——Sources Root

step 3.直接导入

11.3 包

1.包与目录的区别

• 包含_init_.py文件的目录成为包
• 目录里通常不包含_init_.py文件

2.包的导入

import 包名.模块名

示例：

step1.
新建一个package,在package里新建一个模块
结果如下：

step2.

在main.py中导入包

3.注意事项

i. 使用import方式导入的时候，只能跟包名或者模块名
即：

import package
import module

ii. 使用from…import可以导入包，模块，函数，变量

from package1 import module_A
from package1.module_A import a

11.4 python中常用的内置模块

使用案例

11.5 第三方模块的安装和使用

1.安装

打开dos窗口，输入：

pip install 模块名

十二、文件

12.1 编码格式

• python的解释器使用的是Unicode（内存）
• .py文件在磁盘上使用UTF-8存储（外存）
  

12.2 文件的读写原理

1.文件的读写俗称“IO”操作
2.原理

3.文件操作流程

4.语法规则

file=open(filename [ ,mode,encoding])

5.常用的文件打开模式

12.3 os模块

• os模块是python内置的与操作系统功能和文件系统相关的模块，该模块中的语句的执行结果通常与操作系统有关，在不同的操作系统上运行，得到的结果可能不一样

例子：运行该文件时分别打开了win10系统上的记事本，计算器和迅雷软件

os模块操作目录相关函数

12.4 os.path

十三、案例分析

13.1 学生信息管理系统系统设计

总体业务流程

13.2 系统开发环境

• 操作系统 win10
• python解释器
• 开发巩固：pyCharm
• python内置模块：os,re

13.3 主函数设计

def main():
    while True:
      menm()
      choice=int(input('请选择：'))
      if choice in [0,1,2,3,4,5,6,7]:
          if choice==0:
              answer=input('您确定退出系统吗？y/n')
              if answer=='y':
                    print('谢谢您的使用')
                    break
              else:
                    continue
          elif choice==1:
              insert()
          elif choice==2:
              search()
          elif choice==3:
              delete()
          elif choice==4:
              modify()
          elif choice==5:
              sort()
          elif choice==6:
              total()
          elif choice==7:
              show()
def menm():
print('===============学生信息管理系统================')
print('--------------------功能菜单------------------')
print('\t\t\t\t 1.录入学生信息')
print('\t\t\t\t 2.查找学生信息')
print('\t\t\t\t 3.删除学生信息')
print('\t\t\t\t 4.修改学生信息')
print('\t\t\t\t 5.排序')
print('\t\t\t\t 6.统计学生总人数')
print('\t\t\t\t 7.显示所有学生信息')
print('\t\t\t\t 0.退出系统')
def insert():
    pass
def search():
    pass
def delete():
    pass
def modify():
    pass
def sort():
    pass
def total():
    pass
def show():
    pass
if __name__=='__main__':
    main()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

13.4 insert()函数的实现

def insert():
   student_list=[]
   while True:
      id=input('请输入学生id:')
      if not id:
          break
      name=input('请输入姓名：')
      if not name:
          break
      try:
          english=int(input('请输入英语成绩：'))
          java=int(input('请输入Java成绩：'))
          python=int(input('请输入python成绩：'))
      except:
          print('输入无效，不是整数类型，请重新输入')
          continue
      # 将录入的学生信息保存在字典里
      student={'id':id,'name':name,'english':english,'java':java,'python':python}
      # 将学生信息添加到列表当中
      student_list.append(student)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

13.5 delete()函数的实现

13.6 修改学生信息modify()

13.7 查找学生信息

13.8 统计学生总人数

13.9 显示所有学生信息功能

13.10 排序方式的实现

十四、安装第三方库遇到的问题

1. pip点击安装失败，显示Fatal error in launcher: Unable to create process using。。。

检查:
1)环境变量配置问题
2）使用python -m pip或者其他命令解决

import无法导入问题，我人傻了
解决