在学习java的基础上学习python
变量：
变量的语法：
a=10
其中 a 为变量名. 当我们创建很多个变量的时候, 就可以用名字来进行区分.
= 为赋值运算符, 表示把 = 右侧的数据放到 = 左侧的空间中.
变量的名字要遵守一定规则:
硬性规则(务必遵守) 变量名由数字字母下划线构成（跟java不同，不包含美元符号）
数字不能开头
变量名不能和 "关键字" 重复.
变量名大小写敏感
建议遵守的规则：
使用 "驼峰命名法". 形如 totalCount , personInfo 这种, 除了首个单词外, 剩余单词首字母大写
变量的类型：
注意: 和 C++ / Java 等语言不同, Python 变量的类型不需要显式指定, 而是在赋值的时候确定的
整数：int
注意: 和 C++ / Java 等语言不同, Python 的 int 类型变量, 表示的数据范围是没有上限的. 只要内存足够 大, 理论上就可以表示无限大小的数据
小数：float
注意: 和 C++ / Java 等语言不同, Python 的小数只有 float 一种类型, 没有 double 类型， 但是实际上 Python 的 float 就相当于 C++ / Java 的 double, 表示双精度浮点数
字符串：str
使用 ' ' 或者 " " 引起来的，称为字符串. 可以用来表示文本
注意: 在 Python 中, 单引号构成的字符串和双引号构成的字符串, 没有区别. 'hello' 和 "hello" 是 完全等价的.与java不同，java中' '是字符 " "是字符串
注意：str 类型的变量, 只能跟字符串进行+ 操作 其他类型不行 (java中可以，把int类型转为字符串类型进行拼接)
s='hello'
a=10
print(s+10)#出现异常布尔：bool
布尔类型是一个特殊的类型, 取值只有两种, True (真) 和 False (假)
其他：自定义类型
除了上述类型之外, Python 中还有 list, tuple, dict
type() 打印数据类型:
a=10
print(type(a))动态类型特性:
在 Python 中, 一个变量是什么类型, 是可以在 "程序运行" 过程中发生变化的. 这个特性称为 "动态类型" （不像java 要进行类型转换）
a=10
print(type(a))
a='hello'
print(type(a))输出：
注解：
# 进行单行注解
""" 进行多行注解
"""
输入输出：
通过控制台输出 ：Python 使用 print 函数输出到控制台
count=1
print(f'输入{count}次')注意: 使用 f 作为前缀的字符串, 称为 f-string 里面可以使用 { } 来内嵌一个其他的变量/表达式
通过控制台输入：python 使用 input 函数, 从控制台读取用户的输入
a=input('请输入一个数：')
print(f'你输入的数为{a}')注意: input 的参数相当于一个 "提示信息", 也可以没有,input 的返回值就是用户输入的内容. 是字符串类型,如果要进行想要+= * / 等算数运算是不行的，可以通过以下进行转类型
a=input('请输入一个数：')
a=int(a)
b=10
print(a+b)其他的类型转换也可以通过以上方法进行转换 float() bool() str()
算数运算符
像 + - * / % ** // 这种进行算术运算的运算符, 称为算术运算符
注意1: / 中不能用 0 作为除数. 否则会 抛出异常
注意2: 熟悉C/Java 的同学可能认为, 2/3 结果为 0 (小数部分被截断). 但是在 Python 中得到的结果则是 一个小数. 更符合日常使用的直觉
注意3: % 不是 "百分数", 而是求余数
注意4: ** 是求乘方. 不光能算整数次方, 还能算小数次方
print(4**2)
print(4**0.5)输出：
注意5: // 是取整除法(也叫地板除). 整数除以整数, 结果还是整数(舍弃小数部分, 并向下取整. 不是四舍五 入)
关系运算符
像 < >= == != 这一系列的运算符称为 关系运算符, 它们是在比较操作数之间的关系
如果关系符合, 则表达式返回 True. 如果关系不符合, 则表达式返回 False
关系运算符不光针对整数/浮点数进行比较, 还能针对字符串进行比较
注意: 直接使用 == 或者 != 即可对字符串内容判定相等. (这一点和 C / Java 不同 java是堆地址的比较). 字符串比较大小, 规则是 "字典序"（一个单词在词典上越靠前, 就越小. 越靠后, 就越大.）
注意：对于浮点数来说, 不要使用 == 判定相等
a=0.1
b=0.2
c=0.3
print(a+b==c)
print(a+b)
print(c)输出：
正确的比较方式: 不再严格比较相等了, 而是判定差值小于允许的误差范围.
a=0.1+0.2
b=0.3
print(-0.000001<(a-b)<0.000001) #输出为true #java不能连续<逻辑运算符：
像 and or not 这一系列的运算符称为 逻辑运算符（相当于java中的&& || !）
赋值运算符:
= 表示赋值. 这个我们已经用过很多次了. 注意和 == 区分.
链式赋值
a=b=10多元赋值
a,b=10,20交换两个变量的值
a=10
b=20
a,b=b,a复合赋值运算符
Python 还有一些 复合赋值运算符. 例如 += -= *= /= %=
注意: 像 C++ / Java 中, 存在 ++ -- 这样的自增/自减运算符. Python 中则不支持这种运算. 如果需要使用, 则直接使用 += 1 或者 -= 1
其他：除了上述之外, Python 中还有一些运算符, 比如 身份运算符 (is, is not), 成员运算符 (in, not in), 位运算符 ( & | ~ ^ >) 等
条件语句
Python 中使用 if else 关键字表示条件语句
if
if expression:
do_something1
do_something2
next_something
if else
if expression:
do_something1
else:
do_something2if - elif - else
f expression1:
do_something1
elif expression2:
do_something2
else:
do_something3
注意: Python中的条件语句写法, 和很多编程语言不太一样.
if 后面的条件表达式, 没有 ( ), 使用 : 作为结尾.
if / else 命中条件后要执行的 "语句块", 使用缩进(通常是 4 个空格或者 1 个 tab)来表示, 而不是 { } 对于多条件分支, 不是写作 else if, 而是 elif (合体了).
有两个小练习
#判断一个数是否为偶数
a=int(input('请输入一个数：')) #这个方法在python中可以，因为-19除以2余数为1 而java 或者c++是-1
if a%2==1:
print('奇数')
else:
print('偶数')#判断是否是闰年
year =int(input('请输入一个年份：'))
if (year%100!=0 and year%4==0) or year%400==0:
print('闰年')
else:
print('平年')空语句 pass
其中 pass 表示 空语句, 并不会对程序的执行有任何影响, 只是占个位置, 保持 Python 语法格式符合要求 （跟java不一样，python 条件/循环语句不能为空）
循环语句
while 循环
while 条件:
循环体练习
#计算 1！+2！+3！+4！+5！
sum=0
num=1
while num<=5:
i=1
while i<=num
i*=i
i++
sum+=i
num+=1
print(sum)for 循环
for 循环变量 in 可迭代对象:
循环体
使用 range 函数, 能够生成一个可迭代对象. 生成的范围是 [1, 11), 也就是 [1, 10]
打印1-10
for i in range(1,11)
print(i)
通过 range 的第三个参数, 可以指定迭代时候的 "步长". 也就是一次让循环变量加几.
#打印 2 4 6 8 10
for i in range(2,12,2)
print(i)range 的 步长 也可以设定成负数
#打印10-1
for i in range(1,10,-1)
print(i)continue 表示结束这次循环, 进入下次循环.
break 表示结束整个循环
函数
def 函数名(形参列表):
函数体
return 返回值
注意：和 C++ / Java 不同, Python 是动态类型的编程语言, 函数的形参不必指定参数类型. 换句话说, 一个 函数可以支持多种不同类型的参数.
一个函数是可以一次返回多个返回值的. 使用 , 来分割多个返回值
def getPoint():
x = 10
y = 20
return x, y
a, b = getPoint()
如果只想关注其中的部分返回值, 可以使用 _ 来忽略不想要的返回值.
def getPoint():
x = 10
y = 20
return x, y
_, b = getPoint()
变量只能在所在的函数内部生效. 在函数 getPoint() 内部定义的 x, y 只是在函数内部生效. 一旦出了函数的范围, 这两个变量就不再生效了.
在不同的作用域中, 允许存在同名的变量 虽然名字相同, 实际上是不同的变量.
x = 20
def test():
x = 10
print(f'函数内部 x = {x}')
test()
print(f'函数外部 x = {x}') #10 20在函数内部的变量, 也称为 "局部变量" 不在任何函数内部的变量, 也称为 "全局变量"
如果函数内部尝试访问的变量在局部不存在, 就会尝试去全局作用域中查找
x = 20
def test():
print(f'x = {x}')
test() #20如果是想在函数内部, 修改全局变量的值, 需要使用 global 关键字声明
x = 20
def test():
global x
x = 10
print(f'函数内部 x = {x}')
test()
print(f'函数外部 x = {x}')# 10 10if / while / for 等语句块不会影响到变量作用域 换而言之, 在 if / while / for 中定义的变量, 在语句外面也可以正常使用.
if True:
x=10
print(x) #10 java for if while 是局部变量函数之间的调用关系, 在 Python 中会使用一个特定的数据结构来表示, 称为 函数调用栈 . 每次函数调用, 都会在调用栈里新增一个元素, 称为 栈帧.
每个函数的局部变量, 都包含在自己的栈帧中
函数递归
递归是 嵌套调用 中的一种特殊情况, 即一个函数嵌套调用自己.
#计算5!
def factor(n):
if n == 1:
return 1
return n * factor(n - 1)
result = factor(5)
print(result)
注意:
递归代码务必要保证 存在递归结束条件. 比如 if n == 1 就是结束条件. 当 n 为 1 的时候, 递归就结束了.
每次递归的时候, 要保证函数的实参是逐渐逼近结束条件的. 如果上述条件不能满足, 就会无限递归下去
参数的默认值
def add(x, y, debug=False):
if debug:
print(f'调试信息: x={x}, y={y}')
return x + y
print(add(10, 20))
print(add(10, 20, True))带有默认值的参数需要放到没有默认值的参数的后面
关键字参数
在调用函数的时候, 需要给函数指定实参. 一般默认情况下是按照形参的顺序, 来依次传递实参的. 但是我们也可以通过 关键字参数, 来调整这里的传参顺序, 显式指定当前实参传递给哪个形参.
def test(x, y):
print(f'x = {x}')
print(f'y = {y}')
test(x=10, y=20)
test(y=100, x=200)列表
列表就相对于java的数组
创建列表
创建列表主要有两种方式. [ ] 表示一个空的列表
如果需要往里面设置初始值, 可以直接写在 [ ] 当中
alist = [ ]
alist = list()
print(type(alist))
alist = [1, 2, 3, 4]
print(alist)列表中存放的元素允许是不同的类型. (这一点和 C++ Java 差别较大).
alist = [1, 'hello', True]
print(alist)
访问下标
可以通过下标访问操作符 [ ] 来获取到列表中的任意元素.
我们把 [ ] 中填写的数字, 称为下标或者索引
a=[1,2,3,4]
print(a[0]) #1通过下标不光能读取元素内容, 还能修改元素的值.
a=[1,2,3,4]
a[0]=2
print(a) #2234使用 len 函数可以获取到列表/str的元素个数
a=[1,2,3,4]
print(len(a)) #4下标可以取负数. 表示 "倒数第几个元素"
a=[1,2,3,4]
print(a[-1]) #4 相当于 print(len(a)-1)切片操作:
通过下标操作是一次取出里面第一个元素.
通过切片, 则是一次取出一组连续的元素, 相当于得到一个 子列表 使用 [ : ] 的方式进行切片操作.
a=[1,2,3,4]
prtint(a[0:4]) #1234 #不包含最后一个可以省略前后边界
a=[1,2,3,4]
print(a[1:]) #234 #省略后边界，从下标为1到结束
print(a[:-1]) #123 #省略前边界，从0下标开始
print(a[:]) #1234 #前后边界都省略，全部列表切片操作还可以指定 "步长" , 也就是 "每访问一个元素后, 下标自增几步"
alist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(alist[::1]) #1234567890
print(alist[::2]) #13579
print(alist[::3]) #14710
print(alist[::5]) #16切片操作指定的步长还可以是负数, 此时是从后往前进行取元素. 表示 "每访问一个元素之后, 下标自 减几步"
alist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(alist[::-1])#10,9,8,7,6,5,4,3,2,1
print(alist[::-2])#10,8,6,4,2
print(alist[::-3])#10,7,4,1
print(alist[::-5])#10,5如果切片中填写的数字越界了, 不会有负面效果. 只会尽可能的把满足条件的元素过去到.
alist = [1, 2, 3, 4]
print(alist[100:200]) #[]
遍历列表元素
for
a=[1,2,3,4,5]
for i in a:
print(i)for 下标
a=[1,2,3,4]
for i in range(0,len(a)):
print(a[i])
while
a=[1,2,3,4]
i=0
while i新添元素
使用 append 方法, 向列表末尾插入一个元素(尾插).
a=[1,2,3,4]
a.append(5)
print(a) #12345使用 insert 方法, 向任意位置插入一个元素
a=[1,2,3,4]
a.insert(1,1)
print(a) #11234查找元素
使用 in 操作符, 判定元素是否在列表中存在. 返回值是布尔类型.
a=[1,2,3,4]
print(1 in a) #True
print(1 not in a)#False
print('hello' in a)#False使用 index 方法, 查找元素在列表中的下标. 返回值是一个整数. 如果元素不存在, 则会抛出异常
a=[1,2,3,4]
print(a.insert(1))#0
print(a.insert(10)) #异常删除元素
使用 pop 方法删除最末尾元素
a=[1,2,3,4]
a.pop()
print(a)#123pop 也能按照下标来删除元素
a=[1,2,3,4]
a.pop(0)
print(a) #234使用 remove 方法, 按照值删除元素
a=[1,2,3,4]
a.remove(1)
print(a) #234连接列表
使用 + 能够把两个列表拼接在一起.
注意：此处的 + 结果会生成一个新的列表. 而不会影响到旧列表的内容.
a=[1,2,3,4]
b=[5,6,7,8]
print(a+b) #12345678
print(a) #1234使用 extend 方法, 相当于把一个列表拼接到另一个列表的后面.
注意：a.extend(b) , 是把 b 中的内容拼接到 a 的末尾. 不会修改 b, 但是会修改 a.
a=[1,2,3,4]
b=[5,6,7,8]
a.extend(b)
print(a)#12345678
print(b)#5678元组
元组和列表相比, 是非常相似的, 只是列表中放哪些元素可以修改调整, 元组中放的元素是创建元组的时候就设定好的, 不能修改调整.
元组的功能和列表相比, 基本是一致的. 元组使用 ( ) 来表示.
atuple=()
atuple = tuple()
因此, 像读操作,比如访问下标, 切片, 遍历, in, index, + 等, 元组也是一样支持的. 但是, 像写操作, 比如修改元素, 新增元素, 删除元素, extend 等, 元组则不能支持.
另外, 元组在 Python 中很多时候是默认的集合类型. 例如, 当一个函数返回多个值的时候.
def getPoint():
return 10, 20
result = getPoint()
print(type(result)) #
字典
创建一个空的字典. 使用 { } 表示字典.
a = { }
b = dict()
print(type(a))
print(type(b))
初始化
student = { 'id': 1, 'name': 'zhangsan' }
print(student)
最后一个键值对, 后面可以写 , 也可以不写.
student = {
'id': 1,
'name': 'zhangsan',
}查看key
使用 in 可以判定 key 是否在 字典 中存在. 返回布尔值.
student = {
'id': 1,
'name': 'zhangsan',
}
print('id' in student) #True
print('score' in student) #False
使用 [ ] 通过类似于取下标的方式, 获取到元素的值. 只不过此处的 "下标" 是 key. (可能是整数, 也 可能是字符串等其他类型). 如果 key 在字典中不存在, 则会抛出异常.
student = {
'id': 1,
'name': 'zhangsan',
}
print(student['id']) #1
print(student['name']) #zhangsan
print(student['score']) #异常
新增/修改元素
使用 [ ] 可以根据 key 来新增/修改 value
如果 key 不存在, 对取下标操作赋值, 即为新增键值对 如果 key 已经存在, 对取下标操作赋值, 即为修改键值对的值.
student = {
'id': 1,
'name': 'zhangsan',
}
student['score'] = 90
print(student) #id：1 name：zhangsan score：90如果 key 已经存在, 对取下标操作赋值, 即为修改键值对的值.
student = {
'id': 1,
'name': 'zhangsan',
'score': 80
}
student['score'] = 90
print(student) #id=1 name=zhangsan score：90
删除元素
使用 pop 方法根据 key 删除对应的键值对.
student = {
'id': 1,
'name': 'zhangsan',
'score': 80
}
student.pop('score')
print(student) #id=1 name：zhangsan
遍历字典元素
直接使用 for 循环能够获取到字典中的所有的 key, 进一步的就可以取出每个值了.
student = {
'id': 1,
'name': 'zhangsan',
'score': 80
}
for key in student:
print(key, student[key])
取出所有 key 和 value
使用 keys 方法可以获取到字典中的所有的 key
student = {
'id': 1,
'name': 'zhangsan',
'score': 80
}
print(student.keys()) [id,name,score]使用 values 方法可以获取到字典中的所有 value
student = {
'id': 1,
'name': 'zhangsan',
'score': 80
}
print(student.values()) #[1,zhangsan,80]使用 items 方法可以获取到字典中所有的键值对.
student = {
'id': 1,
'name': 'zhangsan',
'score': 80
}
print(student.items()) #[(id:1),(name:zhangsan),(score:80)]
合法的 key 类型
不是所有的类型都可以作为字典的 key.
字典本质上是一个 哈希表, 哈希表的 key 要求是 "可哈希的", 也就是可以计算出一个哈希值.
可以使用 hash 函数计算某个对象的哈希值.
但凡能够计算出哈希值的类型, 都可以作为字典的 key.
print(hash(0))
print(hash(3.14))
print(hash('hello'))
print(hash(True))
print(hash(())) 注意：列表无法计算哈希值. 字典也无法计算哈希值
文件
打开文件
使用内建函数 open 打开一个文件.
f = open('d:/test.txt', 'r')第一个参数是一个字符串, 表示要打开的文件路径
第二个参数是一个字符串, 表示打开方式. 其中 r 表示按照读方式打开. w 表示按照写方式打开. a 表示追加写方式打开.
如果打开文件成功, 返回一个文件对象. 后续的读写文件操作都是围绕这个文件对象展开.
如果打开文件失败(比如路径指定的文件不存在), 就会抛出异常. f = open('d:/test.txt', 'r') 比
关闭文件
使用 close 方法关闭已经打开的文件
f.close()使用完毕的文件要记得及时关闭,一个程序能同时打开的文件个数, 是存在上限的.
写文件
文件打开之后, 就可以写文件了.
写文件, 要使用写方式打开, open 第二个参数设为 'w' 使用 write 方法写入文件.
f = open('d:/test.txt', 'w')
f.write('hello')
f.close()注意：如果是使用 'r' 方式打开文件, 则写入时会抛出异常.
注意：使用 'w' 一旦打开文件成功, 就会清空文件原有的数据. 使用 'a' 实现 "追加写", 此时原有内容不变, 写入的内容会存在于之前文件内容的末尾.
针对已经关闭的文件对象进行写操作, 也会抛出异常.
读文件
读文件内容需要使用 'r' 的方式打开文件 使用 read 方法完成读操作. 参数表示 "读取几个字符"
f = open('d:/test.txt', 'r')
result = f.read(2)
print(result)
f.close()
如果文件是多行文本, 可以使用 for 循环一次读取一行.
f = open('d:/test.txt', 'r')
for line in f:
print(f'line = {line}')
f.close()注意: 由于文件里每一行末尾都自带换行符, print 打印一行的时候又会默认加上一个换行符, 因此 打印结果看起来之间存在空行. 使用 print(f'line = {line}', end='') 手动把 print 自带的换行符去掉.
f=open('D:\pyhton文件操作项目/text.txt','r',encoding='utf-8')
for line in f:
print(f'line={line}',end='')
f.close()使用 readlines 直接把文件整个内容读取出来, 返回一个列表. 每个元素即为一行.
f = open('d:/test.txt', 'r')
lines = f.readlines()
print(lines)
f.close()
关于中文的处理
此时修改打开文件的代码, 给 open 方法加上 encoding 参数, 显式的指定为和文本相同的字符集, 问题 即可解决.
f = open('d:/test.txt', 'r', encoding='utf8')
使用上下文管理器
打开文件之后, 是容易忘记关闭的. Python 提供了 上下文管理器 , 来帮助程序猿自动关闭文件. 使用 with 语句打开文件. 当 with 内部的代码块执行完毕后, 就会自动调用关闭方法.
with open('d:/test.txt', 'r', encoding='utf8') as f:
lines = f.readlines()
print(lines)
比特就业使用库
标准库: Python 自带的库. 只要安装了 Python 就可以直接使用.
第三方库: 其他人实现的库. 要想使用, 需要额外安装.
标准库
实例一
#计算日期差
import datetime
date1 = datetime.datetime(2012, 2, 14)
date2 = datetime.datetime(2022, 7, 12)
print(date2 - date1)
算法题 字符串 反转字符串
def reverseWords(s):
tokens = s.split(' ')
tokens.reverse()
return ' '.join(tokens)
print(reverseWords('I am a student.'))
旋转字符串
def rotateString(s, goal):
return len(s) == len(goal) and goal in s + s
统计是给定字符串前缀的字符串数目
def countPrefixes(words, s):
res = 0 # 符合要求字符串个数
for word in words:
if s.startswith(word):
res += 1
return res文件查找工具
import os
inputPath = input('请输入待搜索路径: ')
pattern = input('请输入待搜索关键词: ')
for dirpath, dirnames, filenames in os.walk(inputPath):
for f in filenames:
if pattern in f:
print(f'{dirpath}/{f}')第三方库
当我们确定了该使用哪个第三方库之后, 就可以使用 pip 来安装第三方库了.
实例一 生成二维码
pip install qrcode[pil] 下载第三方库
import qrcode
img = qrcode.make('zxy找到好工作')
img.save('qrcode.png')
实例二 操作 excel
pip install xlrd==1.2.0 下载第三方库
import xlrd
# 1. 打开 xlsx 文件
xlsx = xlrd.open_workbook('d:/test.xlsx')
# 2. 获取 0 号标签页. (当前只有一个标签页)
table = xlsx.sheet_by_index(0)
# 3. 获取总行数
nrows = table.nrows
# 4. 遍历数据
count = 0
total = 0
for i in range(1, nrows):
# 使用 cell_value(row, col) 获取到指定坐标单元格的值.
classId = table.cell_value(i, 1)
if classId == 101:
total += table.cell_value(i, 2)
count += 1
print(f'平均分: {total / count}')
实例三 程序猿鼓励师
pynput 用于监听键盘按键. 注意版本不要用最新.
playsound 用于播放音频.
pip install pynput==1.6.8
pip install playsound==1.2.2
from pynput import keyboard
from playsound import playsound
count = 0
def on_release(key):
print(key)
global count
count += 1
if count % 10 == 0:
playsound('ding.mp3')
listener = keyboard.Listener(
on_release=on_release)
listener.start()#使用 listener.start 启动监听器.
listener.join()#为了防止程序直接退出, 使用 listener.join 让程序等待用户按键.
加入线程，以及 队列
import random
from pynput import keyboard
from playsound import playsound
from threading import Thread
soundList = ['sound/1.mp3', 'sound/2.mp3', 'sound/3.mp3']
# 记录当前用户按了多少次键盘
count = 0
def onRelease(key):
"""
这个函数, 就是在用户释放键盘按键的时候, 就会被调用到.
这个函数不是咱们自己主动调用的, 而是把这个函数交给了 Listener ,
由 Listener 在用户释放按键的时候自动调用.
像这样的不是咱们自己主动调用, 而是交给别人, 在合适的时机进行调用, 这样的函数, 叫做 "回调函数" (callback function)
:param key: 用户按下了哪个键
"""
print(key)
global count
count += 1
if count % 20 == 0:
# 播放音频!
# 生成随机数
i = random.randint(0, len(soundList) - 1)
# 此处的播放音频, 消耗时间比较多, 可能会引起输入的卡顿(不流畅)
# 可以创建一个线程, 在线程里播放音频!!
# playsound(soundList[i])
t = Thread(target=playsound, args=(soundList[i], ))
t.start()
# 当我们创建好 Listener 之后, 用户的键盘按键动作就会被捕获到.
# 还希望在捕获到之后能够执行一段代码.
listener = keyboard.Listener(on_release=onRelease)
listener.start()
listener.join()
实例三 综合项目学生管理系统
#实现学生管理系统
import os.path
import sys
#使用这个全局变量来管理这个学生信息
#这个列表的元素是一个字典
students=[]
def save():
"""
用来存档
"""
#此处路径不是以d: 开头的绝对路径而是相对路径’
#此时这个写法的含义就是让 record.txt和当前的code42.py在同一个目录下
count=0
with open('record.txt','w',encoding='utf-8') as f:
for s in students:
f.write(f"{s['studentId']}\t{s['name']}\t{s['gender']}\t{s['className']}\n")
print(f'存档成功，共存档了{len(students)}行信息')
def load():
"""
用于读档
:return:
"""
#如果存档文件不存在，则直接跳过这个读档流程
#为了避免读方式打开文件时，文件不存在引发异常
if not os.path.exists('record.txt'):
return
#读档的时候要保证先把旧的数据清理干净
global students
students=[]
with open('record.txt','r',encoding='utf-8') as f:
for line in f:
#针对这一行，按照\t进行切割
#切割之前，要去除末尾的换行
line=line.strip()
tokens=line.split('\t')
if len(tokens)!=4:
print(f'当前行格式有问题 line={line}')
continue
studet={
'studentId':tokens[0],
'name':tokens[1],
'gender':tokens[2],
'className':tokens[3],
}
students.append(studet)
print(f'读档成功,共读了{len(students)}条信息')
def menu():
print('1.新增学生')
print('2.显示学生')
print('3.查看学生')
print('4.删除学生')
print('0.退出程序')
choice=input('请输入你的选择：')
return choice
def insert():
print('[新增学生]开始！')
studentId=input('请输入学生的学号：')
name=input('请输入学生的姓名：')
gender=input('请输入学生性别：')
if gender not in ('男','女'):
print('性别输入的内容不符合要求，新添失败！')
return
className=input('请输入学生的班级：')
student={
'studentId':studentId,
'name':name,
'gender':gender,
'className':className,
}
global students
students.append(student)
save()
print('[新添学生]完毕！')
def show():
print('显示学生开始')
for s in students:
print(f"[{s['studentId']}]\t{s['name']}\t{s['gender']}\t{s['className']}")
print(f'显示学生结束，共显示了{len(students)}位学生')
def find():
#根据学生姓名来进行查找
print('查找学生开始')
count=0
name=input('请输入学生姓名：')
for s in students:
if name ==s['name']:
count+=1
print(f"[{s['studentId']}]\t{s['name']}\t{s['gender']}\t{s['className']}")
print(f'查找学生结束,查找了{count}位学生')
def delete():
print('删除学生开始')
studentId=input('请输入学生id：')
for s in students:
if studentId==s['studentId']:
print(f"删除{s['name']}学生信息")
students.remove(s)
save()
print('删除学生结束')
def main():
"""
入口函数
:return:
"""
#通过控制台和用户进行交互
print('------------------------------------------')
print(' 欢迎来到学生管理系统 ')
print('------------------------------------------')
#程序启动时加载load
load()
while True:
#通过 menu函数来打印菜单
choice=menu()
if choice=='1':
insert()
elif choice=='2':
show()
elif choice=='3':
find()
elif choice=='4':
delete()
elif choice=='0':
print('goodbye')
sys.exit(0)
else:
print('你的输入有误，请重新输入')
continue
main()