《 Python学习与实战 》--代码集合
Hello! 欢迎打开python的代码世界！ 1. 本python代码集合是根据王海诺学长整理编写的《Python学习与实战》敲下来的，参考为莫烦python、官方文档，如有错误敬请批评指出 2. 莫烦python网站里面有很详细的关于Python学习与实战路径，致谢 3. python是世界上最好的编程语言 :) 4. 代码集合与批注为博主所敲，如有错误敬请批评
【莫烦Python】https://mofanpy.com/
1.变量与运算
print("........................ 1.变量与运算 ............................")
name="文件管理系统"
name1,name2,name3="文件","管理","系统" #没有定义变量名字，直接赋值
a=1
a+=1
print("a+=",a)
b=11
c=11
b=b/2 # 一个/表示求除数
c=c//2 #两个//表示求余整数
print(b)
print(c)
print(name)
print(name1+name2+name3)
print("莫烦Python最棒")2.条件判断
print("........................ 2.条件判断 ............................")
in_trash=True
if in_trash:
print("可以被彻底删除") #没有大括号，但是用四个空格替代
if in_trash:
print("可以被彻底删除")
else:
print("不可以彻底删除")
print("..........................")
a,b="文件1","文件2"
print(a==b) #判断，打印结果是True或者Flase
print("2<3",2<3)
print("3<2",3<2)
print("2!=2",2!=2)
print(2<3)
print(3<2)
print(2!=2)
print("..........................")
#and、or、not True、中间链接需要打空格
print(2<3 and 2<5) #and两边为真则为真 and=并且
print(-1<2 and 1<3 )
print(2>3 or 3 == 3) #or一边为真则为真 or= 或者
print("..........................")
a,b=1,2
if a>b:
print("a大于b")
else:
print("a不大于b")
today=3
if today==1:
print("今天是周一")
elif today==2:
print("今天是周二")
elif today==3:
print("今天是周三")
else:
print("其他的一天")3. for和whlie循环
print("........................ 3. for和whlie循环 ............................")
for i in range(5): #range(start,stop,step)函数意思：strat:开始计数、stop:停止、step:步长 // 没有start默认从0开始 //range(5)放出0,1,2,3,4五个数字
print("新文件"+str(i)) #str()函数是把i数字转化为字符
print("..........................")
for i in range(2,5): #结束到stop前一个数字，即stop-1
print("新文件"+str(i))
print("..........................")
for i in range(2,10,2):
print("新文件"+str(i)) #字符串也可以相加减
print("..........................")
guess_num=10
while guess_num !=20: #猜到20就停止循环
guess_num+=1
print(guess_num)
print("..........................")
count=0
guess_num=30
while guess_num!=20 and count<10: #count 相当于计数器
guess_num-=1
count+=1
print(guess_num)
print("..........................")
count=0
guess_num=10
while guess_num!=20:
guess_num+=1
count+=1
if count>10:
break #弹出全部循环
print(guess_num)
print("..........................")
for i in range(10):
if i%2==0: # % 百分号的作用是取余 103%100=3
continue #结束本次循环 “算了，我接着来” // 函数作用：跳过偶数
print(i)4.数据种类
print("........................ 4.数据种类 ............................")
files=["f1.txt","f2,txt","f3,txt","f4,txt","f5,txt"] #数组标识符为 [] ,数组从0开始索引
print("files[0]储存值为：",files[0])
print("files[3]存储值为：",files[3])
print("files[-1]存储值为：",files[-1]) #负数代表反向索引 ,-1是倒数第一个
print("files[-3]存储值为：",files[-3])
print("files[:3]值为:",files[:3]) #连续索引[star:end],从star开始到end-1结束 // [:3]表示从0开始到2结束
print("files[2:4]值为：",files[2:4]) #从2开始到3
print("flies[-3:]值为：",files[-3:]) #从-3开始到结束
print(files[:-3])
print("..........................")
print("old files[1]值为：",files[1])
files[1]=12
print("new files[1]值为：",files[1]) #数组里面可以存储任意类型元素
print("..........................")
big_files=["重","邮",["第",1]]
print(big_files)
print(big_files[2][0]) #有点像二维数组，第二个框框里面的第零个
print("..........................")
l=[1,"files",["2",3.2]]
print(l)
l[2][0]="new string"
print(l)
print("..........................")
files={"ID":111,"passport":"my passport","books":[1,2,3]} #字典标识符为{ "XX":XX , "XX":XX } "XX"类似标签 注意：字典是乱序的！！！
print(files)
print(files["ID"])
print(files["books"]) #索引标签用 []
files["ID"]=222
print(files)
files["ID"]=[5,6,7]
print(files)
print("..........................")
files=("file1","file2","file3") #元组标识符为() 元组内部元素不能被修改
print(files[1])
# files[1]="file4" Tuple 元组不能被修改 修改会报错，不信把这注释删掉
print("..........................")
my_files=set(["file1","file2","file3"]) #set()合集里面存储数组
print(my_files)
my_files.add("file4") #.add()函数作用：添加
print(my_files) #为什么打印是乱序？？？又不是了，很奇怪，又是了——>set()合集与字典{ } 是乱序的，其中是hash表的原因
print("..........................")
list1=[1,2,3,4]
s=set(list1) #虽然int类型是有序的，但是字符是无序的 // 需要用索引排序
print(s)
s.add(4) #重复元素在合集中，会坍缩成一个
print(s)
s.add(5) #添加元素用 .add
print(s)
s.remove(2) #删除元素用 .remove
print(s)
print("..........................")
list1=['重','庆','邮','电','大','学']
list2=['邮','电','大','学']
s1=set(list1)
s2=set(list2)
print("合集s1值为",s1) #乱序
print("合集s2值为",s2)
s1=list(set(list1))
s2=list(set(list2)) #将合集打乱的元素存储在素组中
print("数组s1值为",s1)
print("数组s2值为",s2) #此时还是乱序
s1.sort(key=list1.index) #将数组按照原来数组的顺序索引排序 // XX.sort(key= XX.index) 按照key为某个数组的顺序索引 // s.sort(key=list1.index)
s2.sort(key=list2.index)
print("数组s1值为",s1) #完成排序 -->现在是顺序啦~
print("数组s2值为",s2)
print("..........................")
my_files={"file1","file6","file3"}
your_files={"file1","file2","file3"} #字典无序
print("your_files值为",your_files)
print("交集",your_files.intersection(my_files)) # .intersection( ) 求合集里面的交集 .intersection()
print("并集",your_files.union(my_files)) # .union( ) 求合集里面的并集 .union()
print("补集",your_files.difference(my_files)) # .difference( ) 求合集里面的补集 .difference()
print("差集",your_files.symmetric_difference(my_files)) #.symmetric_difference() 求合集里面的差集
print("..........................")
list1=[1,2,3,4]
list2=[3,4,5,6]
s1=set(list1)
s2=set(list2)
s3=s1&s2 # s1 & s2 中的& 是求交集 就是 s1.intersection(s2)
print("交集s3值为",s3)
s4=s1|s2
print("并集s4值为",s4) # s1 | s2 中的|是求并集 就是 s1.union(s2)
print("..........................")
files=["f1.txt","f2.txt","f3.txt","f4.txt"]
for i in range(len(files)): #len(XX) 函数是求数组的长度
if files[i]=="f3.txt":
print("I got f3.txt")
print("..........................")
files=["f1.txt","f2.txt","f3.txt"]
for f in files: #直接在数组中寻找字符串
if f =="f3.txt":
print("I got f3.txt")
print("..........................")
files={"ID":111,"passport":"my passport","books":[1,2,3]}
for key in files.keys(): # .keys() 查找字典里面的key标签
print("key值为:",key)
for value in files.values(): # .values() 查找字典里面的vlaue储存值
print("value值为:",value)
for key,value in files.items(): # .items() 查找字典里面的key与value的值
print("key值为:",key,",value值为:", value ) # print( XX , XX )中间只能用逗号
print("..........................")
files=[]
for i in range(5):
files.append("f"+str(i)+".txt") # .append( )是在数组里面添加
print("我有",files)
# for i in range(5):
# files.add("f"+str(i)+".txt") # .add()会报错
# print("我有",files)
print("..........................")
for i in range(len(files)):
print("出",files.pop()) # .pop()函数是从最后一个元素出
print("剩余",files)
print("..........................")
files=["f1.txt","f2.txt"]
# 扩充入另一个列表
files.extend(["f3.txt","f4.txt"]) # .extend( )扩充数组
print("扩充后：",files)
#按位置添加
files.insert(1,"file5.txt") # .insert( m,XX )在指定m位置添加元素XX // 注意数组首位是0
print("在第二个位置添加：",files)
#移除某索引
del files[1] # del XX[ m ] 删除XX数组中的第m个元素
print("移除第二处元素后：",files)
#移除某值
files.remove("f3.txt") # .remove( )直接对数组元素做移除处理
print("移除后：",files)
print("..........................")
files={"ID":111,"passport":"mypassport","books":[1,2,3]}
#按key拿取，并在拿取失败时候给一个设定好的默认值
print('files["ID"]:',files["ID"]) # 直接拿key对应的值
print('files.get("ID"):',files.get("unknown ID","不存在这个 ID")) # .get( XX ,YY )取XX如果不存在就是YY
#将另一个字典补充到当前字典
files.update({"files":["1","2"]}) # .update( {key:XX} ) 将一个字典补充到另外一个字典
print('补充后的字典:',files)
print("..........................")
#pop 调一个item,和列表的pop类似
popped=files.pop("ID") # .pop( XX ) 将字典里面的第一个组出掉
print('出',popped)
print("还剩",files)5.Function函数
print(".......................... 5.Function函数 ............................")
f1="f1"
f2="f2"
f1=f1+".txt"
f1="my_"+f1
f2=f2+".txt"
f2="my_"+f2
print(f1,f2)
print("..........................")
#定义一个函数
def modify_name(filesname): # def XX( m ): 定义一个函数名字为XX的函数，参数是m
filesname=filesname+".txt"
filesname="my"+filesname
print(filesname)
modify_name("f1") # 将"f1"传递给函数
modify_name("f2")
print("..........................")
def my_func(): #函数参数为空
filesname="f1"
ext=".txt"
total_name=filesname+ext
print(total_name)
my_func() #传递的函数为空
print("..........................")
def modify_name(filename):
filename+=".txt"
filename="my_"+filename
return filename #函数返回值
new_filename=modify_name("f1") #将函数返回值传递给new_filename储存起来
print(new_filename)
print("..........................")
def f(x,a,b,c): #函数f()里面设置形参
return a*x**2+b*x+c*1 #一元二次方程
print(f(2,1,1,0)) #按顺序传递参数
print(f(x=2,a=1,b=1,c=0)) #写上参数名字，按照名字传参
print(f(a=1,c=0,x=2,b=1)) #打乱顺序传参
print("..........................")
def f(x,a=1,b=1,c=0): #定义函数时就初始化形参
return a*x**2+b*x+c*1
print(f(2,a=2))
print(f(2))
print("..........................")
def modify_name():
filename="f1.txt" # 定义一个局部变量filename,仅在定义函数内有作用
print("local filename:",filename)
modify_name()
# print("global filename:",filename) 这里的filename找不到，仅在定义内的函数里面有储存空间
print("..........................")
filename="f1.txt" #定义在函数外，全局变量
def modify_name():
print("local filename:",filename)
modify_name()
print("global filename:",filename)
print("..........................")
filename="f1.txt" # 全局变量
def modify_name():
filename="f2.txt" # 在函数内改变形参
print("local filename:",filename)
modify_name()
print("global filename:",filename) # 全局变量不变
print("..........................")
filename="f1.txt"
def modify_name():
global filename # 在函数里面对参数申明为全局变量
filename="f3.txt" # 改变全局变量值
print("local filename:",filename)
modify_name()
print("global filename:",filename) # 在外面也改变了
6.Class类
print("....................... 6.Class类 .............................")
class File: # class XX: 定义XX为类 ，类的名字通常大写
def __init__(self): # def __init__( self ): 函数__init__( self )作用在类中索引自己
self.name='f1'
self.creat_time="today"
my_file=File() # 把类实例化
#print(my_file) 不能直接输出类
print(my_file.name) # .name 直接调用类里面的值
print(my_file.creat_time)
my_file.name="new_name" # 直接获取属性，直接修改属性的值
print(my_file.name)
print("....................................................")
class File:
def __init__(self,name,creat_time="today"): # 直接在init函数中传入参数
self.name=name
self.creat_time=creat_time
my_file=File("my_file")
print(my_file.name)
print(my_file.creat_time)
print("....................................................")
class File:
def __init__(self,name,creat_time="today"): #如果在函数申明了变量后
self.name=name #一定要在类对自己索引，否则会报错 // 并且类里面的一定要有初始值
self.creat_time=creat_time
def change_name(self,new_name): #在类里面定义函数
self.name=new_name
my_file=File("我的文件")
print(my_file.name)
my_file.change_name("新文件") #对类进行本身函数处理
print(my_file.name) #总结：类的定义比普通函数多出了一个self // def __init__( self, XX , YY ): 函数中XX与YY是形参，需要slef.XX=XX或者"具体值"进行初始化
print("....................................................")
class File:
def __init__(self,name,create_time="today"):
self.name=name
self.create_time=create_time
def get_info(self):
return self.name+" is created at "+self.create_time #返回值
my_file=File("my_file")
print(my_file.get_info())
print("....................................................")
class Video:
def __init__(self,name,window_size=(1080,720)): #window_size( XX,XX ) 括号是元组
self.name=name
self.window_size=window_size
self.create_time="today"
class Text:
def __init__(self,name,language="zh-ch"):
self.name=name
self.language=language
self.create_time="today"
print("....................... 继承 .............................")
class File: #父类的基本设置
def __init__(self,name,create_time="today"):
self.name=name
self.create_time=create_time
def get_info(self):
return self.name+" is created at "+self.create_time
class Video(File): # class XX( YY ) XX继承了YY的属性与设置
def __init__(self,name,window_size=(1080,720)):
super().__init__(name=name,create_time="today") # super(). 将共有属性的设置导入File父类
self.window_size=window_size # 子类的自己设置
class Text(File):
def __init__(self,name,language="zh-ch"):
super().__init__(name=name,create_time="today") # 用super(). 函数继承父类时形参一定要一致
self.language=language
def get_more_info(self): # 子类函数也可以复用父类的函数功能
return self.get_info()+",using language of "+self.language
v=Video("my_video")
print(v.get_info()) # 调用父类的功能
print("..........................")
t=Text("my_txt") # 调用父类的属性
print(t.create_time)
print("..........................")
print(t.language) # 调用自己的属性
print(t.get_more_info()) # 调用自己加父类的功能
print(".............私有属性与功能.............")
class File:
def __init__(self):
self.name="f1"
self.__deleted=False # 我不让别人用这个变量
self._type="txt" # 我不想让别人用这个变量
def delete(self):
self.__force_delete()
def __force_delete(self): # 我不让别人使用这个功能
self.__deleted=True
return True
def _soft_delete(self): # 我不想让别人使用这个功能
self.__force_delete() # 我自己可以在内部随便调用
return True
f=File()
print(f._type) # 可以拿到但是这个类的作者不想让你直接拿到
print(f._soft_delete()) # 可以调用但是这个类的作者不想让你直接调用 --> 一个下划线 _ 弱隐藏 // 两个下划线 __ 强隐藏
# print(f.__deleted)
# print(f.__force_delete()) 这里会报错因为被强隐藏起来了7.Module 模块
print("........................ 7.Module 模块 ............................")
# me .py
import file # import 文件名 ——> 调用file文件 // 引用库，引用包，引用代码
print(file.create_name()) # 文件名.函数功能
print("..........................")
# 调用模块功能与调用Python类功能异曲同工
import file as f1 # import 文件名 as XX ——> 将引用文件命名为XX ， 之后就可以对XX进行调用了 // 给模块重命名
print("f1: ",f1.create_name())
class File: # 定义类
def create_name(self):
return "new_file.txt"
f2=File()
print("f2: ",f2.create_name())
print("..........................")
from file import create_name # from 文件名 import XX函数 // 意思：从模块文件中引用create_name函数
print(create_name())
print("..........................")
from file import create_name,create_time # 修改引用函数后要重新输入 ， 并且在原来文件中重新运行
print(create_name())
print(create_time())
print("..........................")
#第一种引用方法
import file
print("1",file.create_name())
#第二种引用方法
from file import * # from 文件 import * // 引用文件中所有的函数功能 ——> 偷懒
print("2",create_name())
print("2",create_time())
print("......................... 大项目的模块管理 ...........................")
# from files import get_video_size 很奇怪
# print(get_video_size())
# from files import create_name
# import files.text
# print(files.text.create_name())
# from files import txet
# print(text.create_name())8.读写文件
print("........................ 8.读写文件 ............................")
f=open("new_file.txt","w") # open( "文件名字","w" ) 新建一个脚本文件保存在当前me.py目录下面 // "w" 表示新建文件可以写
f.write("some text...") # 在新建的文件里面写东西
f.close() # 关闭文件，关闭文件后不可以再进行读写操作 ——> 关闭文件是一个好操作
print("创建新文件成功")
print("..........................")
with open("new_file2.txt","w") as f : # with 架构 // with open( "文件名","w") as XX : // 打开新文件建立再目录下面,变量名字为XX
f.writelines(["some text for file2...\n"," 2nd line\n"]) # .writelines( [ XX ] ) 函数writelines在文件里面列表写东西
print("..........................")
f=open("new_file2.txt","r") # f是打开文件的参数名字，"r"是读的意思
print(f.read()) # f.read( ) 读写f 即使读文件里面所有的值
f.close()
print("..........................")
with open("new_file2.txt","r") as f:
print(f.readlines()) # 用readlines( ) 函数直接读取文件的列表
print("直接读取成功")
print("..........................")
with open("new_file2.txt","r") as f:
while True:
line=f.readline() # 一行一行读取代替一次性读取
print(line)
if not line:
break
print("..........................")
with open("chinese.txt","wb") as f: # "wb" 意思是write binary 取代默认的text形式 ，二进制文件
f.write("这是中文的,this is Chinese".encode("gbk")) # .encode("gbk") 表示字符用二进制编码
with open("chinese.txt","rb") as f:
print(f.read())
#print(f.read().decode("gbk")) 这行代码是将二进制文件解码 打印出来就不是二进制
print("..........................")
# 按照道理来说下面代码会报错
with open("chinese.txt","r") as f: # 但Vscode 中 PYthon 中自动将其编码回来了
print(f.read())
print("..........................")
with open("chinese.txt","r",encoding="gbk") as f : # encoding="XX" 用XX来解码 // gkb是国标，utf-8是后起之秀
print(f.read())
# 补充字符编码发展史
# --> ASCII ：阿斯克码计算机最早语言，美国人发明，ASCII码包含的字符够美国人用
# --> ASCII 255
# --> GBK ：gbk对于中/英的存储，都是16位，2字节，对中文存储友好，但是对于英文存储却不友好
# --> GB2312
# --> GBK1.0
# --> GB18030
# --> Unicode ：ucs-2只有16位无法兼容全世界常用字符，空间不够 // usc-4占32位空间虽然够但是极大浪费存储空间
# --> utf-8 ：兼容全世界的字符，对漂亮国友好，但是对中文不太友好
print("..........................")
with open ("new_file.txt","r") as f:
print(f.read())
with open ("new_file.txt","r+") as f: # r+ 表示文件可读又可以写
f.write("text has been replaced !")
f.seek(0) # seek(0) 将写好的文件，开始读的位置 从写入的最后 调到开头
print(f.read())9.文件目录管理
print("........................ 9.文件目录管理 ............................")
import os # import os 意思是导入os模块到当前程序
print("当前目录：",os.getcwd()) # os.getcwd() 函数是获取当前工作目录
print("当前目录里面有什么：",os.listdir()) # os.listdir() 函数是返回文件夹里面所有文件名字，按照字母顺序输出
print("..........................")
os.makedirs("project",exist_ok=True) # os.makedirs( "XX文件" ) 在当前文件夹目录下新建一个名字为XX的文件夹 // exist_ok=True 意思是创建的目录已经存在也不报错
#如果检测到当前目录下面已经有此XX文件则报错：---> FileExistsError: [WinError 183] 当文件已存在时，无法创建该文件
print(os.path.exists("project")) # os.path.exists( "XX文件" ) 判断当前目录下是否存在 XX 文件
print("............. 文件管理系统 .............")
if os.path.exists("user/Akaxi"):
print("The user's file is exist !")
else:
os.makedirs("user/Akaxi") # 创建文件
print("The user has been created !")
print("..........................")
if os.path.exists("user/Akaxi"):
os.removedirs("user/Akaxi") # os.removedirs("XX文件名") 删除当前目录下的XX文件 // 文件非空会报错: OSError: [WinError 145] 目录不是空的
print("The user' file has been removed !")
else:
print("The user not exist !")
print("..........................")
os.makedirs("user/GEM",exist_ok=True) # 在当前目录下面创建user文件夹并在user文件里面创建新的GEM文件夹 // 注意： 新建文件夹 / 新建文件夹
with open("user/GEM/a.txt","w") as f: # 打开新建的文件夹GEM里面并创建一个a.txt文本 ，可写 ，命名为f
f.write("something") # 在a.txt文本里面写"something"
# os.removedirs("user/Akaxi") # 试图移除文件夹，但是里面有东西会报错--> OSError: [WinError 145] 目录不是空的
print("..........................")
import shutil # 注意shutil库太强大了，不小心删除了其他东西真就没了，可以清空整个目录
shutil.rmtree("user/GEM") # .rmtree("XX/XX") 删除user文件夹里面的GEM文件
print(os.listdir("user"))
print("..........................")
shutil.rmtree("user/person")
os.makedirs("user/people1",exist_ok=True) # 注意，当文件存在时，无法创建该文件 --> 报错：FileExistsError: [WinError 183] 当文件已存在时，无法创建该文件
os.rename("user/people1","user/person")
print(os.listdir("user"))
print("............ 文件目录多种检验 ..............")
import os
os.makedirs("user/wang",exist_ok=True)
with open("user/wang/a.txt","w") as f:
f.write("something")
print(os.path.isfile("user/wang/a.txt")) # os.path.isfile("文件名") 用于判断某一对象（需提供绝对路径）是否为文件
print(os.path.exists("user/wang/a.txt")) # os.path.exists("文件名") 用于判断当前目录下是否存在 XX 文件
print(os.path.isdir("user/wang/a.txt")) # os.path.isdir("目录") 用于判断内容是否为目录
print(os.path.isdir("user/wang"))
print("..........................")
import os
import shutil
def copy(path): # 提供的路径为 C:\Users\Akaxi\Desktop\Akaxi python\user\wang\a.txt
filename=os.path.basename(path) # 返回最后的文件名 比如a.text
dir_name=os.path.dirname(path) # 返回最根的目录名 比如C:\user 字符 + 旧文件名
new_filename="new_"+filename # 新文件名 建立新文件new_filename = new_ + a.text
new_path=os.path.join(dir_name,new_filename) # 重组文件目录 链接文件路径--> os.path.join( XX,YY ) 链接旧路径到新路径 ： C:\user ——> new_a.txt 变成 C:\Users\Akaxi\Desktop\Akaxi python\user\wang\new_a.txt
shutil.copy2(path,new_path) # 复制文件 搬文件 shutil.copy2( XX,YY ) 将旧C:\Users\Akaxi\Desktop\Akaxi python\user\wang\a.txt -->搬到 C:\Users\Akaxi\Desktop\Akaxi python\user\wang\new_a.txt
return os.path.isfile(new_path),new_path # 返回 os.path.isfile(new_path)--> 判断为True或者Flase返回给copied // new_path返回给new_path
copied,new_path=copy("user/wang/a.txt")
if copied: # 如果判断路径下为文件——>Ture 则打印新文件的路径
print("copied to:",new_path)
else : # 否则打印失败
print("copy failed")
print("..........................")
def copy(path):
dir_name,filename=os.path.split(path) # os.path.split( 路径XX ) 函数是将路径与文件分开 C:\Users\Akaxi\Desktop\Akaxi python\user\wang\a.txt 分开成dirname= C:\Users\Akaxi\Desktop\Akaxi python\user\wang\ 和 filename=a.txt
new_filename="new2_"+filename # 新文件名字 new2_a.txt
new_path=os.path.join(dir_name,new_filename) # 新路径 C:\Users\Akaxi\Desktop\Akaxi python\user\wang\new2_a.txt
shutil.copy2(path,new_path) # 搬文件
return os.path.isfile(new_path),new_path # 返回真假 + 新文件路径
copied,new_path=copy("user/wang/a.txt")
if(copied):
print("copied to:",new_path) # 打印新文件
else:
print("copy failed")10.字符串的高级的玩法
print("........................ 10.字符串的高级的玩法 ............................")
name="莫烦Python"
print("我的名字是"+name+"!")
print("我的名字是%s!"%name) # %s , % XX 将XX按照字符串输出
print("..........................")
name="莫烦Python"
age=18
gender="男"
print("我的名字是"+name+"!我"+str(age)+"岁了,我是"+gender+"的~")
print("我的名字是%s!我%d岁了,我是%s的~"%(name,age,gender)) # %( XX,YY,ZZ ) 百分号后面连续传参
print("..........................")
name="莫烦Python"
age=18
gender="男"
print("我的名字是%(nm)s!我%(a)s岁了,我是%(gd)s的~"%{"nm":name,"a":age,"gd":gender}) # %(key)s %{"key":XX} 按照字典来传参-->可以打乱顺序
print("..........................")
name="莫烦Python"
age=18
height=1.8
print("我的名字是%s!我%d岁了,我%f米高~"%(name,age,height)) # %f 打印小数 默认保留6位
print("..........................")
print("%f"%(1/3))
print("%.2f"%(1/3)) # %.2f 保留两位小数
print("..........................")
print("%f"%(1/3))
print("%.2f"%(1/3)) # 限制2个位置
print("%4d"%(1/3)) # 前面补齐4个位置
print("%4d"%12)
print("%5d"%12) # 前面补齐5个位置
print("............. format功能 .............")
name="莫烦Python"
age=18
height=1.8
print("我的名字是%s!我%d岁了,我%.1f米高~"%(name,age,height))
print("我的名字是{}!我{}岁了,我{}米高~".format(name,age,height)) # .format()函数，用{}占位置
print("..........................")
name="莫烦Python"
age=18
height=1.8
print("我的名字是{0}!我{1}岁了,我{2}米高~我是{0}".format(name,age,height)) # 用{0} {1} {2}代表format里面的传参顺序
print("..........................")
print("我的名字是{nm}!我{a}岁了,我{ht}米高~我是{nm}".format(nm=name,a=age,ht=height)) # 也可以{key1} {key2} format( key1=XX , key2=YY )
print("..........................")
print("我{:.3f}米高".format(1.12345)) # :.3 保留三位小数
print("我{ht:.3f}米高".format(ht=1.12345))
print("我{:3d}米高".format(1)) # :3 整数前面补齐三个位置
print("我{:3d}米高".format(21))
print("我{:3d}米高".format(321))
print("我{:3d}米高".format(4321))
print("..........................")
txt="You scored {:%}" # :% 百分比模式
print(txt.format(2.1234))
txt="You scored {:.2%}" # :.2% 百分比模式,并且保留两位小数
print(txt.format(2.1234))
# 字符串意思
# %d 整数
# %i 整数
# %f 小数
# %s 字符
# 在format()函数中，{XX}以下意思
# :, 每3个0用逗号隔开，比如 47,000
# :b 该数字的二进制
# :d 整数型
# :f 小数模式
# :% 百分比模式
print("............ f格式化字符串 ..............")
name="莫烦Python"
age=18
height=1.8
print(f"我的名字是{name}!我{age}岁了,我{height}米高~") # 需要在字符串开头加上 f
print(f"我{age}岁了,明年我就{age+1}岁了~") # 甚至可以在{}里面做运算
score=2.1234
print(f"You scored {score:.2%}") # 百分号模式且保留两位小数
print(f"You scored {score:.3f}") # 保留三位小数
print(f"You scored {12:5d}") # 直接是12 且前面补齐5空格
print(" 我不想要前后的空白，但是 中间\n的空白可以有\n".strip())
print("..........................")
print("帮我替换掉莫烦".replace("莫烦","Akaxi")) # .replace( XX,YY ) 将字符串替换
print("How ABOUT lower CaSe?".lower()) # .lower() 将字符串全部做小写处理
print("And upper CaSe?".upper()) # .upper() 将字符串全部做大写处理
print("do tiTle For me".title()) # .title() 仅开头的字母大写
print("你|帮|我|拆分|一下|这句话".split("|")) # .split() 按要求分割
print("|".join(["你","帮","我","重组","一下","这句话"])) # .join() 按要求合并
print("..........................")
print("我在街头看到你".startswith("我在")) # .stratswith("开头") 如果是开头的字符串则判断为 True 否则是Flase
print("我在街头看到你".startswith("街头"))
print("我在巷尾看到你".endswith("看到你")) # .endswith("结尾") 如果是结尾的字符串则判断为 True 否则是Flase
print("我在巷尾看到你".endswith("巷尾"))11.Python的偷懒用法
print("........................ 11.Python的偷懒用法 ............................")
def add(a,b): # 用def定义一个函数
return a+b
print(add(1,2))
sum=lambda a,b : a+b # <函数名> = lambda <参数> ：<表达式> // 函数名是返回结果 // 用于定义简单的、能够在一行内表示的函数
print(sum(1,2))
print("..........................")
shuzu=[]
for i in range(10):
shuzu.append(i*2) # 数组.append() 在列表末尾添加新的对象 // [ ] --> C叫做数组，Python叫做列表
print(shuzu)
print("..........................")
shuzu=[i*2 for i in range(10)] # 这种方法更简单
print(shuzu)
print("..........................")
d={"index"+str(i):i*2 for i in range(10)} # 甚至可以用这种方法创造字典
print(d)
print("..........................")
done=False
if done: # if 参数(为真):
a=1
else: # else (为假) :
a=2
print(a)
done=False
a= 1 if done else 2 # <参数> = m if 真 else n
print(a)
print("..........................")
shuzu=[] # 普通生成数组，且判断条件
for i in range(10):
if i % 2==0:
shuzu.append(i*2) # 如果是偶数就添加到数组里面
print(shuzu)
print("..........................")
shuzu=[i*2 for i in range(10) if i%2==0] # for循环 + if判断 --> 生成数组 [ ]
print(shuzu)
print("..........................")
zidian={"index"+str(i): i*2 for i in range(10) if i%2==0} # 生成字典
print(zidian)
print("..........................")
count=0
shuzu=[11,22,33,44]
for data in shuzu:
if count ==2 :
data+=11
shuzu[count]=data
count+=1
print(shuzu)
print("..........................")
shuzu=[11,22,33,44]
for count,data in enumerate(shuzu): # enumerate() 函数在遍历中可以获得索引和元素值
if count==2:
data+=11
shuzu[count]=data
print(shuzu)
print("..........................")
shuzu=[11,22,33,44]
zidian={}
for count,data in enumerate(shuzu,start=5): # enumerate( <数组> , start=XX ) 下标从XX开始
zidian[count]=data
print(zidian)
print("..........................")
name=["a","b","c"] # 列表一
score=[100,99,60] # 列表二
zidian={} # 创造字典
for i in range(3):
zidian[name[i]]=score[i]
print(zidian)
print("..........................")
name=["a","b","c"]
score=[100,99,60]
zidian={}
for n,s in zip(name,score): # zip()函数将两个列表打包 --> 变成一个个tuple元组
zidian[n]=s
print(zidian)
print("..........................")
name=["a","b","c"] # 将多个列表打包
score=[1,2,3]
bonus=[1,0,1]
zidian={}
for n,s,b in zip(name,score,bonus):
zidian[n]=s+b
print(zidian)
print("..........................")
shuzu=[1,2,3,4]
_shuzu=[]
for i in range(len(shuzu)):
_shuzu.append(shuzu[-i-1]) # i从0开始 故-i-1是-1、-2 shuzu[-1]->shuzu[-2]->shuzu[-3]
print(_shuzu)
print("..........................")
shuzu=[1,2,3,4]
_shuzu=[shuzu[-i-1] for i in range(len(shuzu))]
print(_shuzu)
print("..........................")
shuzu=[1,2,3,4]
shuzu.reverse() # .reverse() 函数将数组本身元素倒序输出
print(shuzu)
print("..........................")
shuzu=[1,2,3,4]
for i in reversed(shuzu): # reversed() 函数将数组倒序
print(i)
print("..........................")
shuzu=[1,2,3]
_shuzu=shuzu[::-1] # a = b[ i : j : s ] 复制--> 将数组b中的元素从i复制到j-1 // s为-1表示从后往前 [ : : -1] 默认从0开始到最后
print(shuzu)
print(_shuzu)12.numpy功能
print("........................ 12.numpy功能 ............................")
# 首先在电脑终端安装 Numpy 三方库
# 在终端输入 pip install numpy --> pip 是 Python 的包管理器，用于依赖管理，使用pip可以在自己电脑上面安装很多库（pip相当于应用商店，类似的还有conda）
# 而Numpy是python的数据分析库，里面有很多函数，相当于一个手机app
import numpy as np # import 在导入numpy库时 给numpy起别名为 np ,引用该模块时直接简写为np
np.array([1,2,3])
my_list=[1,2,3]
print(my_list[0]) # py中的List的基本用法
print("..........................")
my_array=np.array([1,2,3])
print(my_array[0])
my_list[0]=-1
my_array[0]=-1
print(my_list)
print(my_array) # 改变内部值都一样 --> Numpy Array 在电脑储存地址是连续的，而Python List 在电脑储存地址是分散的，故Numpy Array 的运算更快
print("..........................")
import time
t0 = time.time() # 时间t1
#python list
shuzu=list(range(100))
for _ in range(10000):
for i in range(len(shuzu)):
shuzu[i]+=1
t1=time.time() # 时间t2
# numpy array
a=np.array(shuzu)
for _ in range(10000):
a+=1
t2=time.time() # 时间t3
print(" Python list spend{:.3f}s! ".format(t1-t0)) # python list 进行大数据计算花费时间0.068s
print(" Numpy array spend{:.3f}s! ".format(t2-t1)) # numpy array 进行大数据计算花费时间0.008s -->更快13.numpy的维度选择
print("........................ 13.numpy的维度选择 ............................")
import numpy as np
cars = np.array([5,10,12,6])
print("数据：",cars,"\n维度: ",cars.ndim) # .ndim表示有多少个维度
print("..........................")
cars = np.array( # 创建二维数据
[ # 一个[ A ] 代表一维数据 // [ [ m ] [ n ] ] 一个[ A ]里面又有[ m ] 与 [ n ]代表二维数据
[5,10,12,6],
[5.1,8.2,10,6.3],
[4.4,9.1,10,6.6]
]
)
print("数据：\n",cars,"\n维度: ",cars.ndim)
print("..........................")
cars=np.array(
[
[ # 蓝色[]代表二维 并且第一个二维蓝色框框是 cars[ 0 ]
[5,10,12,6],
[5.1,8.2,11,6.3],
[4.4,9.1,10,6.6]
],
[
[6,11,13,7],
[6.1,9.2,12,7.3],
[5.4,10.1,11,7.6]
]
]
)
# 可以在此处用加维度函数 cars=np.expand_dims( cars , k ) k = 1、2、3 ( k 不能为0 )
print("总维度：",cars.ndim)
print("场地 1 数据: \n",cars[0],"\n场地 1 维度: ",cars[0].ndim)
print("场地 2 数据: \n",cars[1],"\n场地 2 维度: ",cars[1].ndim)
print("..........................")
cars1=np.array([5,10,12,6])
cars2=np.array([5.2,4.2])
cars=np.concatenate([cars1,cars2])
print(cars,"\n维度为: ",cars.ndim)
print("..........................")
# 将两个一位数据变成二维
test1=np.array([5,10,12,6])
test2=np.array([5.1,8.2,11,6.3])
# 变二维的两种办法
test1=np.expand_dims(test1,0) # expand_dims( array , axis ) 函数表示将数组array升高维度 --> 注意axis值不同升维方式不同 // 很难理解，其实就是看 [ ] 框框画在哪里--> axis=0将框框画在第一个框框后面，axis=1将框框画在第二个人框框后面......以此类推
test2=test2[np.newaxis,:] # np.newaxis 函数功能是增加一个新的维度 --> x[np.newaxis, :] ，放在前面，会给行上增加维度 // x[:, np.newaxis] ，放在后面，会给列上增加维度
print("test1加维度后: ",test1)
print("test2加维度后: ",test2)
# 在第一个维度上面叠加
all_tests=np.concatenate([test1,test2])
print("扩展后: \n",all_tests)
print("..........................")
print("第一维度叠加：\n",np.concatenate([all_tests,all_tests],axis=0))
print("第二维度叠加：\n",np.concatenate([all_tests,all_tests],axis=1))
print("..........................")
a = np.array(
[
[1,2,3],
[4,5,6]
]
)
b = np.array(
[
[7,8],
[9,10]
]
)
print(np.concatenate([a,b],axis=1)) # 在[ [ 这里面合并 ] ]
# print(np.concatenate([a,b],axis=0)) # 在[ [m] [n] 在这里合并会报错]-->因为[m]与[n]的数据维度不对齐
print("..........................")
a = np.array(
[
[1,2],
[3,4]
]
)
b = np.array(
[
[5,6],
[7,8]
]
)
print("竖直合并：\n",np.vstack([a,b]))
print("水平合并：\n",np.hstack([a,b])) # hstack水平合并要求两个合并[][]数据大小一样 // 水平合并要求比较严格
print("........... 观察形态 ...............")
cars = np.array(
[
[5,10,12,6], # 相当于cars[ 1 ] -->cars[ 1 ] 里面有4个数据
[5.1,8.2,11,6.3], # 相当于cars[ 2 ] -->cars[ 2 ] 里面有4个数据
[4.4,9.1,10,6.6] # 相当于cars[ 3 ] -->cars[ 3 ] 里面有4个数据
]
)
count = 0
for i in range(len(cars)):
for j in range(len(cars[i])):
count+=1
print("总共多少测试数据：",count)
print("..........................")
print("总共多少测试数据：",cars.size) # .size数据 用来统计矩阵元素个数
print("..........................")
print("第一个维度：",cars.shape[0])
print("第二个维度：",cars.shape[1])
print("所有维度：",cars.shape)
# Numpy 数组的理解
#
# [ y1 y2 y3 y4
# x1 [ m , n , p , q ]
# x2 [ a , b , c , d ]
# x3 [ k , j , i , w ] --> 这是一个 x = 3,y = 4 的二维数组
# ]
#14.numpy的数据选择
print("........................ 14.numpy的数据选择 ............................")
import numpy as np
a = np.array([1,2,3])
print("a[0]值为: \n",a[0])
print("a[1]值为: \n",a[1])
print("a[0,1]值为：\n",a[[0,1]])
print("a[1,2,0]值为：\n",a[[1,2,0]]) # 切片划分 --> 按批拿出
print("..........................")
b = np.array(
[
[1,2,3,4],
[5,6,7,8],
[9,10,11,12]
]
)
# 选取第n行所有数
print("b[0]值为: \n",b[0])
print("b[1]值为: \n",b[1])
# 选取第n行，第n列数
print("b[1,0]值为: \n",b[1,0]) # b[1,0] 第2行第0列数
print("b[2,3]值为: \n",b[2,3]) # b[2,3] 第3行第4列数
print("..........................")
print("b[[1,0],[2,3]]值为: \n",b[[1,0],[2,3]]) # b[[1,0],[2,3]]将0与2换位 --> 变成b[[1,2],[0,3]] 很奇怪
print("............. 切片划分 .............")
a = np.array([1,2,3])
print("a[0:2]值为：",a[0:2]) # a[ m:n ] --> 从 m 到 n -1 切片
print("a[1:]值为：",a[1:])
print("a[-1]值为：",a[-1:]) # a[ -1 ] --> 从倒数第一个开始
print("..........................")
b = np.array(
[
[1,2,3,4],
[5,6,7,8],
[9,10,11,12]
]
)
print("b[:2]值为: \n",b[:2]) # 多维也可以切片划分 按照行来划分
print("..........................")
print("b[1:,:3]值为：\n",b[1:,:3]) # b[ x:m , n:y ] 第x行开始 ，到第y-1行，开始
print("..........................")
print("b[1:3,-2:]值为：\n",b[1:3,-2:])
print("..........................")
a = np.array(
[
[10,12,3,4],
[5,6,7,8],
[9,12,6,10]
]
)
print(a[a>7]) # 数组里面a>7的数筛选，按照列表顺序输出
print(a[a<7]) # 同理小于7数筛选，按照列表输出
print("..........................")
condition = a > 7
print(condition) # condition 返回值是一个True / Flase
print("..........................")
condition = ( a>7 ) & ( a!= 10 ) # 根据 a 的条件赋值给condition True / Flase
print(a[condition])
print("..........................")
condition = a>7
print(np.where(condition,-1,a)) # Numpy数据筛选函数where( if , x , y ) 如果Ture则将满足条件位置变为 x // 否则就变为 y
print("..........................")
print(np.where(condition,1,0)) # Numpy强大的数据筛选函数，可以将数组变为-1或者0的矩阵 --> 以便做数据处理，数模大数据分析等等
print("..........................")
condition = a>7
b=-a # 可以把 a 变换成 b 放在不满足的后面
print(np.where(condition,a,b)) 15.numpy的基础运算
print("........................ 15.numpy的基础运算 ............................")
shuzu = [150,166,183,170]
for i in range(len(shuzu)):
shuzu[i]+=3
print(shuzu)
print("..........................")
print(list(map(lambda x: x+3,[150,166,183,170]))) # map( fun , list ) --> map函数最少有两个参数，第一个参数为一个函数名，第二个参数是对应函数的参数
# lambda函数是匿名函数,表达式为 lambda m : x --> m 为参数、x为表达式
print("..........................")
import numpy as np
a=np.array([150,166,183,170])
print("a+3的值为: ",a+3) # 在numpy中批量计算，全元素计算 --> 向量化计算
print("a + 3的值为: ",a + 3)
print("a - 3的值为: ",a - 3)
print("a * 3的值为: ",a * 3)
print("a / 3的值为: ",a / 3) （更新ing）
2023.10.27
渝北仙桃数据谷
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
