JAVA开发转型大模型开发（用时4天）-Python了解基本语法，目录变量和类型类型带来的意义-动态类型-（有利有弊 单人开发爽，多人开发不爽，还要写文档)注释使用#输入与输出-与类型
目录变量和类型类型带来的意义-动态类型-（有利有弊 单人开发爽，多人开发不爽，还要写文档)注释使用#输入与输出-与类型转换python不能把字符串和数字进行拼接类型转换运算符算术运算符关系运算符逻辑运算符链式求值python不支持++,--条件语句(if)-需要缩进组while /for循环continue/break函数Python一个函数可以返回多个值 （区别于C++,Java-(需要包装成一
目录
类型带来的意义-动态类型-（有利有弊 单人开发爽，多人开发不爽，还要写文档)
Python一个函数可以返回多个值 （区别于C++,Java-(需要包装成一个对象))
外面的默认是全局变量，函数先尝试去局部变量查找，然后再去往上一级作用域，及全局～
使用index方法，判定当前元素在列表中的位置，得到一个下标
判断是否存在 - not in 来判定key在字典中不存在,通过下标的名字是key，来访问
#使用open打开文件 -r按照读方式打开， -w表示write，表示写方式打开，-a append写打开，把内容写到原有的文件末尾
avg=(67.5+89.0+12.9+32.2)/4 total=(67.5-avg)**2+(89.0-avg)**2+(12.9-avg)**2+(32.2-avg)**2 //**2代表 平方，也是非常简单的 print(total/3) 1173.2866666666666计算机由以下几个组成
1.CPU （Intel,AMD，高通）
2.存储器(内存，外存)存储数据
3.输入设备，键盘，鼠标，麦克风
4.输出设备，显示器，音箱，耳机，打印机
内存，外存的区别:
1.内存存储空间较小，外存的存储空间比较大。
2.内存访问速度快，外存访问速度慢。
3.内存没有外存大，内存的成本高(所以就会比外存小)
4.内存中的数据易丢失，外存中的数据持久化存储(断电数据也存储)
py
缺点，执行效率偏弱，多核心并发程序支持不好，动态类型系统对大型项目不友好(类型在运行时候，可以发生改变)
非常简单，没有java的类，方法啥的，直接就运行了
print("hello")print(1 + 9 - 3) print(1*9/7) //默认是double类型，然后他的就是真除，并不是取整，而且编程中，没有四舍五入的规则，浮点数有内部规则，规则下处理浮点数，可能会有微小的误差。 print((67.5+2+30)/5) 7 1.2857142857142858 19.9
变量和类型
假如求方差:
1.先计算平均值，
2.分别针对每个数字，计算数字和平均值的差值，再平方
3.把上述平方值相加
4.除以项数-1
变量-存入内存中
type() //获取类型
a=10 print(type(a)) b="您好" print(type(b)) c=1.11111111 print(type(c)) d='c'; print(type(d)) e=True print(e) //不区分字符和字符串 <class 'int'> <class 'str'> <class 'float'> -c++/java-float四个字节的，也叫做单精度浮点数 ，把一个二进制位，称为bit,8个bit放在一起，就称为一个字节。double 八个字节-也叫双精度浮点数 float==double <class 'str'> <class 'bool'>经典变量名字:字母数字下划线，数字不开头，不用关键字
int-数据范围是无穷（因此也没有long这样类型)
Python设计哲学-解决一个问题，只提供一种方案
我们可以发现，单引号和双引号，都是str
但是有啥区别呢
比如
k="My name is "LichuanLong" -中间这个部分Python不认识了就里面是单引号，就加双引号，里面是双引号就加单引号。
'My name is "Lcl" '
假如里面是双引号，就外面单引号，外面双引号，里面单引号，里面单双都有，那么三引号
字符串函数，len
k='''My name "is" 'LichuanLong' '''
print(len(k));
27字符串拼接
k='''My name "is" 'LichuanLong' '''
a='hello'
print(a+k);
helloMy name "is" 'LichuanLong'
我们不能把字符串和数字，混合相加
比如
b1='hello'
b2=10
print(b1+b2)
类型带来的意义-动态类型-（有利有弊 单人开发爽，多人开发不爽，还要写文档)
1.不同的类型，占用的内存空间是不同的，占几个字节，
int 是默认4个字节，动态扩容
float固定8字节
bool一个字节即可
str变长的
2.不同的类型，对应能进行的操作是不同的
int/float ,+ - * / 不可以用len
str + 但是不可以-*/ ,可以用len
动态类型:
程序在运行过程中，类型有可能改变
可以从数字，转化成字符串啥的
a=10 a="hello" a=True print(a) a=False print(a)一定规模之后，动态类型劣势就体现， 一般公司都会进行一个重构
注释使用#
#这个是注释
"""
这是一个文档字符串，起到作用和注释意义，也是解释说明的效果
"""输入与输出-与类型转换
输出
python不能把字符串和数字进行拼接
a=10 print(f"a = {a}") print(f"a = {a+10}") a = 10f表示format -格式化 可以使用{}这样的语法，往字符串嵌入变量或者表达式。
输入
m=input("请输入一个整数:") print(f"m = {m}") print(type(m)) m = 10 <class 'str'>input返回的值，其实是一个字符串
如果单纯拿到用户的输入，然后打印，按照str处理就好
假如后续要操作，还是要转化为int
a=input("请输入第一个整数") b=input("请输入第二个整数") print(f"a+b={a+b}") a=int(a) b=int(b) print(f"a+b={a+b}") 请输入第一个整数1 请输入第二个整数2 a+b=12 a+b=3类型转换
整数转化成字符串str()
字符串转为浮点数float()
a=input("请输入第一个整数") b=input("请输入第二个整数") c=input("请输入第三个整数") d=input("请输入第四个整数") a=float(a) b=float(b) c=float(c) d=float(d) avg=(a+b+c+d)/4 print(f"avg的值是{avg}") 请输入第一个整数1 请输入第二个整数2 请输入第三个整数3 请输入第四个整数4 avg的值是2.5假如输入任意个数字-循环
运算符
算术，关系，逻辑 -0不可以做除数
算术运算符
运行时的错误-叫做抛出异常 -除0异常
抛出异常，本质和java大体相同。
py除精准除
求余数-
**是乘方运算 -同时支持小数次平方，比如0.5 就是根号
a=100; print(f"a的平方是{a**2}") print(f"a的根号是{a**0.5}") a的平方是10000 a的根号是10.0//地板除法 -对计算结果向下取整，跟java，C++的除法一致
但是-7//2 往较小的取，就会取到-4
a=-7; print(f"a的向下取是{a//2}") print(f"a的根号是{a**0.5}") a的向下取是-4 a的根号是(1.6200554372175822e-16+2.6457513110645907j)关系运算符
< > <= >= == 字符串也可以比较(比较字典序列，比如h更先),中文比较大小，更没有意义了。中文属于是用多个字节构成的一个较大的数字来比较。
a = "hello" b = "world" print(a>b) Falsepython == 和!=来比较字符串内容相同，是大部分语言遵守的规则(java,c是小众哥)
针对浮点数，使用==比较相等，存在一定风险
一般校验，看a-b的差值是否是一个非常小的数字，是否在误差范围之内，比如
a=0.1 b=0.2 print(f"a+b的值{a+b}") print(0.3) a+b的值0.30000000000000004 0.3a=0.1 b=0.2 print(f"a+b的值{a+b}") print(-0.000001<(a+b-0.3)<0.000001) print(0.3) a+b的值0.30000000000000004 True 0.3逻辑运算符
and && 两侧操作数都为true,表达式值为true
or ll
not ! 取反
a=0.1 b=0.2 c=0.3 print(a<b and b<c) print(a < b < c) //上面的变式 这个相当于java的lambda短路求值
比如 and 一个flase 后面就不用看了
or 一个ture， 后面也不用看了
还包括一些有意思的运算符
身份运算符(is not) 成员运算符(in, not in ) 位运算符(& | ^ << >>)
链式求值
# 先把b=20,然后a=b 不建议用
a=b=20
a,b=10,20; 按照顺序的
交换操作也很有意思 -简单
a,b=b,a
print(a,b) python不支持++,--
先读取a ,才可以这样+1.
a=a+1 a+=1;
true=1 false=0(整数可以加布尔值，可以当成整数算数运算) true 为1，false 为0
True Python认识的True
条件语句(if)-需要缩进组
这块就非常不同了
if xx: (与别的语言不同的是，他表示条件的结束使用:)
oooo(使用tab键作为缩进）
elif xx: (还是结束使用 : ) (把else if 合体了)
kkkk(使用tab键进行缩进)
else:
pppp
# 先把b=20,然后a=b 不建议用 choice=input("输入1表示学习 ，输入2表示摆烂：") # 此处比较的是字符串1，而不是整数1 if choice=='1': #字符串‘1’ print("成功") elif choice=='2': print("失败") else: print("666")if,else,while,for 需要跟上代码块的部分，都是需要使用缩进表示
两级索引，就如同if(){ if(){ 这里面的语句块} }
a=input("请输入一个整数") b=input("请输入一个整数") if a=='1': if b=='2': print(f"b的值{b}") print(f"a的值{a}") print(10) 请输入一个整数1 请输入一个整数2 b的值2 a的值1 10多级条件嵌套，当前语句属于哪些代码块，完全取决于缩进的级别
多重条件的嵌套-两语句对应哪一级代码块，并不容易观察，因此写错容易出错
a=input("请输入一个整数") #a的值是字符串，无法%2==0 a=int(a) if a%2==0: print("当前值是偶数") else: print("当前值是奇数")在python中
假如-19%2 结果最后是1， 因为除数
2是正数，所以取模结果必然是正数，最终得到1。-19%-2 等于-1。 请输入一个整数-19 -1 实践出真知
但是java那边是-1 也需要注意
条件满足时候，什么都不做/啥都不写，就会出错 ，可以使用空语句占用位置pass
a=input("请输入一个数字:")
if a!='1':
pass
else:
print("hello")
请输入一个数字:1
hellowhile /for循环
while 条件:
xxx
#打印1-10的整数 num=1 while num<=100: print(num) num=num+1 print("循环已经完成")#计算阶乘和 num=1 sum=0 while num<=5: #用来计算阶乘 floater=1; i=1 #依次计算每个阶乘 while i<=num: floater*=i; i = i + 1 #保存阶乘的和 sum+=floater num+=1 print(f"sum的值是{sum}")#可迭代对象，特殊变量，内部包含很多其他的值 //从1到11小于 range内建函数，获得到一个可迭代对象，包含一系列整数[begin,end) for i in range(1,11): print(i)range 还提供了第三个参数，表示步长值为1。
打印1，3，5，7，9
for i in range(1,11,2): print(i) //后面那个2表示步子的长度 1 3 5 7 9打印10-1
//步子长短是一个负数 打印从10-1 for i in range(10,0,-1): print(i)它里面有些变量和你定义的重复名字了，所以需要改名
一般是shift +f6 但是有点f6是不太容易按，所以可以shift+fn+f6
continue/break
继续下次循环和结束当前循环
sum=0 for i in range(10,0,-1): if i==2: continue print(i)python 只提供while和for,没有do while
函数
一段可以被重复使用的代码
#定义一个函数 def calSum(begin,end): theSum=0 for i in range(begin,end+1): theSum+=i; print(f"theSume的值{theSum}") calSum(1,100)函数的定义
def - define ：定义
def 函数名
-代码块需要带有缩进，才是内部的语句
-函数返回值，执行到return 就意味着，执行完毕了，return 后面的值，就是函数的返回值，return语句并非是必须的，可以有可以无。
2.函数调用(开始完成任务)
函数名(实参列表-实参)
假如定义函数，不去调用，那么内部就不会执行。
Python更推荐蛇形命名 比如cal_sum（但是你用啥都可以)
PEP8意思要求函数和调用，有两个空行
def test(begin,end): sum=0 for i in range(begin,end+1): sum+=i; //返回值，只负责运算，返回值，返回 return sum result=test(1,100) print(result)让逻辑和交互/界面分离
解耦合
True和False注意不是小写。
Python一个函数可以返回多个值 （区别于C++,Java-(需要包装成一个对象))
但是python天然可以返回多个值， -很有意思的机制
def getPoint(): x=10 y=20 return x,y a,b=getPoint() print(a,b) 10 20假如我们只想要一部分，不关注其他的，使用下划线给他忽略(就是把a的名字换成_，但是实际上和a没区别)。
外面的默认是全局变量，函数先尝试去局部变量查找，然后再去往上一级作用域，及全局～
假如想去改全局变量,使用global 说明他是全局变量的x
x=10 def change(): global x x=20 print(x) 10但是if,else,while ,for 这些关键字引入的代码块，不会对变量的作用域产生影响，即 可以在外面访问
递归
def f(n): if n==1: return 1 return n*f(n-1) print(f(5))函数加上特殊开关-便于调试
def f(a,b,debug): if debug==True: print("打印") return a+b print(f(1,2,True)) print("********") print(f(1,2,False)) 打印 3 ******** 3带有默认值的函数-灵活设计-（默认参数一定要放后面)
def f(a,b,debug=False): if debug==True: print("打印") return a+b print(f(1,2,True)) print("********") print(f(1,2)) 打印 3 ******** 3
使用关键字传参
def test(x,y): print(f"x={x}") print(f"y={y}") #按照参数的名字来传参 test(x=10,y=20) test(y=200,x=10) x=10 y=20 x=10 y=200关键值参数，一般都是搭配默认参数使用的，一个函数提供很多的参数，为了降低使用成本，对大部分参数设定出默认值
当调用者需要调整其中一部分参数时候，可以搭配关键字进行操作。
列表和(元组-对标数组)
如果表示的数据少，直接定义几个变量就好
列表是可变的:创建好了，随时能改
元组是不可变的:创建好了，改不了，要是想改，只能丢弃旧的，搞个新的
创建列表
#直接使用字面值来创建 #[]表示一个空列表 -优点，可以指定初始值 a=[] b=list() print(type(a)) print(type(b)) <class 'list'> <class 'list'> a=[1,2,3,4] print(a) #优点2:可以在同一个列表里存放不同类型的变量,可以随心所欲的往里面放值 a=[1,True,[4,5,6],7] print(a) [1, True, [4, 5, 6], 7]列表访问下标-并且修改
a=[1,True,[4,5,6],7] print(a[1]) print(a[2]) print(a[3]) a[2]=100 print(a[2]) print(len(a)) True [4, 5, 6] 7 100 4Python下标可以写成负数，负数就是len(a)-1 = a[-1] ,相当于简化了len。
切片操作
#切片操作 a=[1,True,[4,5,6],7] #左闭右开 print(a[1:3]) #切片操作-省略边界，从开始位置，一直到整个结束 a=[1,True,[4,5,6],7] print(a[1:]) #切片操作-省略边界，从开始位置，到结束位置 a=[1,True,[4,5,6],7] print(a[:3]) #切片操作-省略边界， 也可以是-1，但是注意是左闭右开 a=[1,True,[4,5,6],7] print(a[:-1]) [True, [4, 5, 6]] [True, [4, 5, 6], 7] [1, True, [4, 5, 6]] [1, True, [4, 5, 6]] #切片操作-省略边界，都省略，就是全体都打印一遍 a=[1,True,[4,5,6],7] print(a[:]) [1, True, [4, 5, 6], 7]设置步长
a=[1,True,[4,5,6],7] print(a[::2]) #隔着一个取一个 [1, [4, 5, 6]]步长也可以是负数，从后往前取值
a=[1,True,[4,5,6],7] print(a[::-2]) [7, True]当切片超出有效下标时候，不会有异常，而是尽可能的把符合要求的元素获取到
a=[1,True,[4,5,6],7] print(a[0:100]) #底层不是复制，而是正常获取，所以性能比较优秀 [1, True, [4, 5, 6], 7]a=[1,True,[4,5,6],7] for elem in a: #i代表列表内每个元素,他是把每个值赋值给elem print(elem) 1 True [4, 5, 6] 7 #for循环遍历，通过下标的方式 a=[1,True,[4,5,6],7] for i in range(0,len(a)): //这个是获取range里面的元素，我们可以进行操作的 a[i]=i+10 print(a)使用while遍历
#使用while循环，通过下标遍历 a=[1,2,3,4,5] i=0 while i<len(a): print(a[i]) i+=1添加操作(这种要搭配对象来使用的函数)-append
a=[1,2,3,4] a.append(5) a.append("你好") print(a) #可以使用insert方法，往列表的任意位置添加元素 a.insert(1,"hello") print(a) #假如我们insert(100,'k')越界的话，他就会默认放最后面 [1, 2, 3, 4, 5, '你好'] [1, 'hello', 2, 3, 4, 5, '你好']使用in 判定某个元素是否在列表中存在
a=[1,2,3,4] print(1 in a) print (10 in a) True False使用index方法，判定当前元素在列表中的位置，得到一个下标
a=[1,2,3,4] print(1 in a) print (10 in a) print(a.index(1)) print(a.index(100)) #越界报错就完事了 True False 0 Traceback (most recent call last): File "/Users/lcl/PycharmProjects/PythonProject3/my_main.py", line 103, in <module> print(a.index(100)) ValueError: 100 is not in list使用pop删除列表中最末尾的元素
#使用pop()可以删除任意位置的元素，pop的参数可以传递一个下标过去 a=[1,2,3,4] a.pop() #默认是删除末尾元素 print(a) a.append(1) a.pop(0) print(a)使用remove,根据值来删除
#remove方法，可以按照值来进行删除。 a=[1,2,3,4] a.append("hello") print(a) a.remove("hello") print(a)
连接链表
#使用+拼接列表 a=[1,2,3,4,5] b=[6,7,8,9,10] c=a+b print(c) [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]使用+号的时候，只是出来一个新的，但是a,b没有变化，如同字符串拼接
使用extend来进行拼接
#使用extend:把后面一个的链表，拼接到前一个列表里面 a=[1,2,3,4,5] b=[6,7,8,9,10] c=a.extend(b) #因为没有返回值的是 print(c) print(a) print(b) None -表示什么都没有 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] [6, 7, 8, 9, 10]None如同C的NULL,java的null
使用+=操作，如同extend（更加推荐）
a.extend(直接b拼接，更加高效一点)和a+=b (把a的值扔了，重新赋值)
元组(读取元组大部分和list一致，只可以读，不可以改)
#创建元组 a=() print(type(a)) b=tuple() print(type(b))元组初始化
#如何指定初始值,也可以任意类型 a=(1,2,3,4,True,[1,2],(3,4)) print(a) <class 'tuple'> <class 'tuple'> (1, 2, 3, 4, True, [1, 2], (3, 4))通过下标来访问元组中的元素，下标也是从0开始，到len-1结束，越界报错
a=(1,2,3,4) print(a[1]) print(a[-1]) print(a[100]) 2 4 Traceback (most recent call last): File "/Users/lcl/PycharmProjects/PythonProject3/my_main.py", line 133, in <module> print(a[100]) IndexError: tuple index out of range元组遍历
a=(1,2,3,4) print(a[1:3]) #和列表大致一致 (2, 3)可以使用for循环方式遍历元素
a=(1,2,3,4) for elem in a: print(elem) print(3 in a) print(a.index(3)) 1 2 3 4 True 2可以使用+来拼接两个元组
a=(1,2,3) b=(4,5,6) print(a+b) (1, 2, 3, 4, 5, 6)当进行多元赋值的时候，本质是按照元组的方式进行工作的
def getPoint(): x=10 y=20 return x,y x,y=getPoint() print(x,y) 10 20
元组和列表的优/劣
假如把参数传递过去了，A是否会把我的参数内容给改了呢？，因此使用的元组作为参数，就可以避免这样的纠结 ，元组 - 不可变对象，是可以哈希的
字典(存储键值对 - 哈希表)
#创建字典 a={} print(type(a)) b=dict() print(type(b)) #创建字典同时设置初始值 包含两个键值对 ,key是id value 是1 。 key是name 。value是zhangsan a={'id':1,'name':'zhangsan'} print(a) <class 'dict'> <class 'dict'> {'id': 1, 'name': 'zhangsan'}添加键值对，推荐以多行的形式，比如 直观，如同json的逗号格式
a={ 'id':1, 'name':'zhangsan' }判断是否存在 - not in 来判定key在字典中不存在,通过下标的名字是key，来访问
a={ 'id':1, 'name':'zhangsan' } #使用in来判定某个key是否存在某个key print('id' in a) print('id' not in a) print('zhangsan' not in a) print(a['id']) print('name' in a) print(a['name']) True False True 1 True zhangsan假如访问不存在的a['key']值，会报错，当前key在字典中不存在
对于字典来说，使用in 或者[]来获取value,都很搞笑
但是列表，使用in比较，低效，需要遍历一遍， 使用[]比较高效
字典添加元素-写,修改操作，(跟数组一样，非常爽了可以说)
a={ 'id':1, 'name':'zhangsan' } a['password']=90 print(a['password']) a['password']=80 print(a['password']) 90 80字典删除-pop(key)
a={ 'id':1, 'name':'zhangsan' } a['password']=90 print(a['password']) a['password']=80 print(a['password']) a.pop('password') print(a) 90 80 {'id': 1, 'name': 'zhangsan'}
字典遍历-（效率不高)
a={ 'id':1, 'name':'zhangsan' } a['password']=90 #哈希链表，遍历是有序的 for key in a: #key-只算一个代号，其实叫什么都行，这个字典我理解LinkedHashMap print(key,a[key])keys获取字典中所有key
values获取字典中所有value
items获取字典中所有的键值对
a={ 'id':1, 'name':'zhangsan' } a['password']=90 print(a.keys()) print(a.values()) print(a.items()) dict_keys(['id', 'name', 'password']) dict_values([1, 'zhangsan', 90]) dict_items([('id', 1), ('name', 'zhangsan'), ('password', 90)])可以当作列表使用，但是返回的不是列表
a={ 'id':1, 'name':'zhangsan' } a['password']=90 for key,value in a.items(): print(key,value) id 1 name zhangsan password 90
合法key的类型-可哈希
python中，专门提供了hash这个函数。元组，整数，浮点，bool,这个可以，但是列表(list),字典也不行会直接报错
print(hash('hello')) -5727897689096063603不可变的对象，一般可以hash,但是可变的，无法hash.
文件操作-8193 是2的13次方
#使用open打开文件
-r按照读方式打开，
-w表示write，表示写方式打开，
-a append写打开，把内容写到原有的文件末尾#使用open打开文件 -r按照读方式打开 f=open('/Users/lcl/Desktop/测试文件操作.txt','r') print(type(f)) <class '_io.TextIOWrapper'>返回了一个文件对象
文件对象是内存上的一个变量，后续读写操作都是拿文件对象进行操作。-句柄，就是远程操控的遥控器
关闭文件
f.close() - 文件打开之后一定要去关闭，打开文件是在申请一定的系统资源，所以不需要使用文件时候，资源应该及时释放。-不然容易造成文件资源泄露，导致别的资源打不开(资源有限，近8k个(8189(个)+3=8193)，当然你系统里面可以设置，可以适当放宽，但是也是有限制的）小知识:标准输入，标准输出，标准错误-键盘，显示器，显示器 -这个是默认打开的三个文件，所以+3就凑够了
python(也有垃圾回收GC):文件对象在循环一次，下个循环之后，就自动回收了
写文件
#使用open打开文件 -r按照读方式打开 f=open('/Users/lcl/Desktop/测试文件操作.txt','w') #覆盖写，假如用r方式打开，再去写，会报错 f.write("hello") f.close()写方式打开，两种情况，一个直接写，一个追加写
这个就是直接写，会先情况，然后你write，去写，不然就是直接空。
使用a方式打开 - 追加写
#使用open打开文件 -r按照读方式打开 f=open('/Users/lcl/Desktop/测试文件操作.txt','a') #覆盖写，假如用r方式打开，再去写，会报错,换行符，就是转义字符 f.write("\nworld") f.close()
读文件内容
直接read,指定读几个字符
注意假如是中文-代码默认是按照GBK，utf-8更加广泛
f=open('/Users/lcl/Desktop/测试文件操作.txt','r') #覆盖写，假如用r方式打开，再去写，会报错,换行符，就是转义字符 result=f.read(2) f.close() print(result)手动指定字符编码utf-8
#使用open打开文件 -r按照读方式打开 f=open('/Users/lcl/Desktop/测试文件操作.txt','r',encoding='utf-8') #覆盖写，假如用r方式打开，再去写，会报错,换行符，就是转义字符 result=f.read(2) #读取两个字符， f.close() print(result)更加常见的需求，按行读取- 最简单方法，直接for循环
f=open('/Users/lcl/Desktop/测试文件操作.txt','r',encoding='utf-8') for line in f: print(f"line={line}") print("*********") for e in f: print(f"e={e}") f.close() 问题发现1，两个都可以正常打印，但是放在一起，只打印一个， 问题发现2:他每次都隔一行打印 line=懒洋洋大王来了 line=helloworld line=world line=world *********默认情况下，这个end代表默认有一个空行，我们给他改成空格就好
f=open('/Users/lcl/Desktop/测试文件操作.txt','r',encoding='utf-8') for line in f: print(f"line={line}",end='') print("*********") for e in f: print(f"e={e}") f.close() line=懒洋洋大王来了 line=helloworld line=world line=world *********读行的方法2: 一次读完
f=open('/Users/lcl/Desktop/测试文件操作.txt','r',encoding='utf-8') lines=f.readlines() print(lines) f.close() ['懒洋洋大王来了\n', 'helloworld\n', 'world\n', 'world\n']
上下文管理器
因为有些情况，你把close放最后面了，但是有一个条件，直接跳出，就不去支持close了
当with代码块执行结束时候，就会自动执行f的close
def fe(): with open('/Users/lcl/Desktop/测试文件操作.txt','r',encoding='utf-8') as f: i=1 if i==1: return
python的库-（如同java的依赖)
标准库 -python自带
第三方库 -大佬们做出来的
datetime
import datetime #先构造datatime变量 ,前面模块，后面是模块里面包含的类型 date1=datetime.datetime(2025,9,29) date2=datetime.datetime(year=2025,month=9,day=27) print(date1-date2) 2 days, 0:00:00 #这个方法也可以 from datetime import datetime date1=datetime(2025,9,29) date2=datetime(year=2025,month=9,day=27) print(date1-date2)字符串
I am student 翻转成 student am I
#有时候，动态类型，不知道能不能使用对应方法 def reverseWord(s: str): tokens=s.split(' ') tokens.reverse() return ' '.join(tokens) print(reverseWord('I am student'))
旋转自负
s="abcde" ->bcdea ->cdeab ...
把左侧的字符，放到最右侧
def reverseWords(s: str,goal): if(len(s)!=len(goal)): return False return goal in (s+s) print(reverseWords("abcde","cdeab"))统计前缀，是否以这个字符串开头的
startwith
def countPrefixes(words:list,s:str): count=0 for word in words: #s是以word开头 if s.startswith(word): count+=1 return count print(countPrefixes(['a','b','c','d','ab','abc'],'abc'))
文件搜索的代码-(文件不是文件夹 )
import os
inputPath=input('请输入你要搜索的路径')
pattern=input('请输入你要搜索的关键词')
#找目录，以及子目录，遇到子目录，也要去查找，往深找，
# 使用os.walk 这个是遍历操作系统目录的操作。简单循环就可以，无需递归了
#分别代表，对应路径，对应的目录，列表包含多个文件名字
for dirpath,dirname,filenames in os.walk(inputPath):
# print(f"dirpath:{dirpath}")
# print("-------------------")
# print(f"dirname:{dirname}")
# print("-------------------")
# print(f"filenames:{filenames}")
for f in filenames:
if pattern in f:
print(f"{dirpath}/{f}")
第三方库使用pip - 包管理器
python搞了一个网址-pypi,直接使用pip工具，就可以下载第三方库
命令行程序，点击那个teminal中断
pip install +库名
如使用python 制作二维码
import qrcode img=qrcode.make('密码是李传龙真滴帅') img.save('qrcode.jpg')
操作excel
假如统计班级内xx，为xx的，所以需要操作excel的库
读取excel-xlrd -带版本号 ，新版本的不只是xlsx
pip install xlrd==1.2.0 //之前加入按照别的了，直接就会替换修改excel，使用xlwt
pip install xlwtimport xlrd #1.先打开xlsx文件 xlsx=xlrd.open_workbook('/Users/lcl/Desktop/工作簿2.xlsx') #2.获取到指定的标签页 table=xlsx.sheet_by_index(0) #3.获取到表格里面有多少行 nrows=table.nrows print(f"nrows={nrows}") #4.进行循环统计操作 for i in range(0,nrows): #拿到当前的下标,打印第0列 print(table.cell_value(i,0))计算平均分
import xlrd #1.先打开xlsx文件 xlsx=xlrd.open_workbook('/Users/lcl/Desktop/工作簿2.xlsx') #2.获取到指定的标签页 table=xlsx.sheet_by_index(0) #3.获取到表格里面有多少行 nrows=table.nrows total=0 count=0 print(f"nrows={nrows}") #4.进行循环统计操作 for i in range(1,nrows): name=table.cell_value(i,0) classId=table.cell_value(i,1) if(classId==5): print(name) print(table.cell_value(i,2)) total+=table.cell_value(i,2) count+=1 print(total) print(count) print(f"平均分：{total/count}")
程序员鼓励师
背景，每隔一段时间，让电脑发出声音，鼓励一下我们
playsound第三方库
舰艇键盘按键，比如连续按键N次，播放一个音频，且每次播放的都不同， pynput
老版本的更吃香
pip install pynput==1.6.8 pip install playsound==1.2.2准备音频文件，拷贝项目中
from pynput import keyboard from playsound import playsound soundList = ['sound1.mp3', 'sound2.mp3', 'sound3.mp3'] def onRelease(key): """ 这个函数，用户在释放键盘按键的时候，就会被调用到， 这个函数不是我们主动调用，而是函数交给Listener，Listener在拥护释放按键时候。自动调用 像是这种不是主动调用，而是交给别人，在合适的时机调用，-回调函数 key:用户按下了，哪个键 """ print(key) global count count += 1 if count%10==0: # 播放音频! 每10个字，放歌 #生成随机数,从声音的第一个，到最后一个，随机出 i=random.randint(0,len(soundList)-1) playsound(soundList[i]) listener=keyboard.Listener(on_release=onRelease) listener.start() listener.join()但是播放音频消耗时间比较多，会引起输入的卡顿，可以去创建一个线程
学生管理系统
新增学生，显示学生，增删查改，保存到文件- 这个是对应的代码练手
def menu(): print('1:新增学生') print('2.显示学生') print('3查找学生') print('4.删除学生') print('0.退出程序') choice = (input('请输入你的选择')) return choice #列表的每一个元素都是一个字典，每个字典表示一个同学，（字典如同哈希表和对象合在一起了) students=[] 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 find(): #根据学生姓名查找 print('查找学生开始') count=0; name=input('请输入要查找的同学姓名') for s in students: if name==s['name']: print(f"{s['studentId']}\t{s['name']}\t{s['gender']}\t{s['classname']}") count+=1; print(f"共查找到:{count}") 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 delete(): print('删除学生开始') studentId=input('请输入要删除的学生学号') for s in students: if studentId==s['studentId']: print(f"已删除这个同学{s['studentId']}\t{s['name']}\t{s['gender']}\t{s['classname']}") students.remove(s) print('删除学生结束') save() print() def main(): """ 入口函数 通过控制台和用户交互 增删查改 """ print("欢迎来到学生管理系统") #程序启动的时候，读档一次就好 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("bye") #退出 sys.exit() else: print("您的输入有误") def save(): """ 用于存档 此处这个路径不是以d:开头的绝对路径，而是相对路径 此时这个写法的含义就是让recode.txt和当前code66.py在同一个目录里面 :return: """ with open('record.txt','w',encoding='utf8') 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(): """ 如果存档文件不存在，则直接跳过读档 """ if not os.path.exists('record.txt'): return #读档时候，要清理旧的睡觉 global 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 student={ 'studentId':tokens[0], 'name':tokens[1], 'gender':tokens[2], 'classname':tokens[3], } #添加进去 students.append(student) #加载存档逻辑 print(f'[读档成功]共读取了{len(students)}条记录!') main()
更多推荐
25
0- 0
已为社区贡献1条内容
所有评论(0)