1.三元表达式
'''偷懒写法减少代码的行数'''
1.#获取用户输入的姓名如果是jason欢迎，如果不是则打印权限不足
user_name = input('输入用户名》>>>:').strip()
if user_name == 'jason':
print('欢迎')
else:
print('没有权限')
print('欢迎') if user_name == 'jason' else print('权限不足') # 简化之后的代码
def func(a, b):
if a > b:
return a
else:
return b
res = func(1, 2)
print(res)
def func1(a, b):
return a if a > b else b
res1 = func1(3,1)
print(res1)
# 结果1 if 条件 else 结果2 条件成立结果1 不成立结果2
func() if 1 else func1() # 三元表达式中函数体代码遵循要么1要么2
2.生成式
1.列表生成式
# 新列表 = [数据处理 for 数据 in 列表 if 条件成立处理数据后添加到列表中不成立则直接删除]
name_list = ['jason', 'tony', 'kevin']
new_name_list = [name + '_NB' for name in name_list if name != 'jason']
print(new_name_list)
name_list1 = [num for num in range(10)]
print(name_list1)
结论：先执行for循环然后将数据交给for循环前面处理 支持if判断 如果成立做处理添加不成立则摒弃
2.字典生成式
new_dict = {i:'jason'for i in range(10) if i == 0 }
print(new_dict)
3.集合生成式
new_set = {i for i in range(100)}
print(new_set)
匿名函数
没有名字的函数
语法结构
lambda 形参：返回值
具体案例
(lambda x:x+1)(123)
res = lambda x:x+1
print(res(123)) # 传x进去然后返回值是x+1 123 +1
匿名函数用于配合其他函数一起使用用于减少代码
常见内置函数
- max()最大值 map()最小值
l1 = [1,23,42,4,3,5,4,6,4,636,444,2,4,6,4,6,7,4,7,84,6,434,776443,7744,54,]
print(max(l1))
dic ={'jason':100,
'tony':99999,
'kiven':999,
'zero':99
}
res = max(dic,key = lambda k:dic.get(k) )
print(res)
dic ={'jason':100,
'tony':99999,
'kiven':999,
'zero':99
}
def index(k):
return dic.get(k)
res = max(dic,key=index) # for循环字典里的值交给函数取调用
print(res)
dic ={'jason':100,
'tony':99999,
'kiven':999,
'zero':99
}
def index(k):
return dic.get(k)
for i in dic:
print(index(i))
2.mpa（） 需求将列表的数据自增20
1.for循环
l1 = [11,22,33,44,55]
l2 = []
for i in l1:
i += 20
l2.append(i)
print(l2)
2.列表生成式
l1 = [11,22,33,44,55]
l2 = [num + 20 for num in l1]
print(l2)
3.内置函数
l1 = [11,22,33,44,55]
res = map(lambda x:x+20,l1)
print(list(res))
使用常规函数也可以
l1 = [11,22,33,44,55]
def func(x):
return x + 20
res = map(func,l1)
print(list(res))
3.filter()
l1 =['jason','tony','kiven','dana']
将tony 移除
for i in l1:
if i == 'tony':
res= l1.index(i)
l1.pop(res)
print(l1)
l1 =['jason','tony','kiven','dana']
# 将tony 移除
res = filter(lambda a: a != 'tony',l1)
print(list(res))
4.求和sum
l1 =[1,2,3,5,5,6,6,7,7452,5,2,535]
rse = sum(l1)
print(rse)
l1 = []
for i in range(1,101):
l1.append(i)
print(sum(l1))
l1 = [1,2,3,4,5]
from functools import reduce
res = reduce(lambda x,y:x+y,l1,)
print(res)
5.zip() 将数据意义对应组成元组
l1 = [1,2,3,4,5]
l2 = ['jason','tony','liven']
res = zip(l1,l2)
print(list(res))
[(1, 'jason'), (2, 'tony'), (3, 'liven')]
6.abs（）求绝对值
print(abs(-100)) # 100
- all() 与 any()
print(all([1, 3, 4, 5, 6, 7]))#所有成立
print(any([1, 3, 4, 5, 6, 7]))#有一个成立
- bin() int() oct() hex()
print(bin(100)) # 二进制0b1100100
print(hex(100)) #十六进制0x64
print(oct(100)) #八进制0o144
print(int(0o144)) # 100
- byyes() 二进制类型转换 str()字符串类型转换
res = bytes('现在多苦以后就有多轻松','utf8')
print(res)
res1 =str(res,'utf8')
print(res1)
- callable()判断某个变量是否可以加括号调用
name = 'jason'
def func():
print('努力不会白费')
res = callable(func) # True
res1 =callable(name) # False
print(res,res1)
11.chr() ord()依据ASCII码表实现数字与字符对应转换
print(chr(65)) # A
print(ord('s')) # 115
12.dir() 获取对象可以使用的名字
13.divmod() 获取整除和余数
rel_num,more = divmod(999,7)
if more:
rel_num += 1
print('总页数%s'%rel_num)
14.enumerate()枚举
name_list = ['jason','tony','kiven']
cont = 0
for i in name_list:
print(cont,i)
cont += 1
for i,k in enumerate(name_list，100): #里面加参数指定从什么位置开始
print(i,k)
15.eval()exec() 能够将字符串代码变成真正的代码
exec("print('打印')")
16.help() 查看帮组手册
print(help(len))
17.isinstance() 判断是否是同类型数据
print(isinstance(100,int))True
- pow() 幂指数
print(pow(2, 3)) # 8
可迭代对象
1.迭代如何理解 迭代就是更新换代每次迭代更新都需要基于上一次
2.迭代代码演示
n = 0
while n < 10:
print(n)
n += 1
3.判断可迭代对象 内置有__iter__的都叫可迭代对象
int #不是可迭代
float #不是可迭代
str #字符串是可迭代
list #列表是可迭代
dict #字典是可迭代
tuple #元组是可迭代
set #集合是可迭代
bool #布尔值不是可迭代
def index():pass #函数名不是可迭代
文件对象是可迭代对象
可迭代对象支持for循环迭代取值
迭代器对象
提供一种不依赖于索引取值的方式，因为有迭代器对象存在我们才可以对字典集合无序的类型循环取值 1.如何判断什么是迭代器对象 内置有__iter__和__next__的对象是迭代器对象 2.可迭代对象调用__iter__可变成迭代器对象 迭代对象再调用__iter__还是本身
res = 'jason'.__iter__()
print(res.__next__()) #j
print(res.__next__()) #a
print(res.__next__()) #s
print(res.__next__()) #o
print(res.__next__()) #n
不实用for循环依次取出列表的数据值
l1 = [1,2,3,4]
res = l1.__iter__()
count = 0
while count <len(l1):
print(res.__next__())
count += 1
#可迭代对象调用__iter__生成迭代器对象
l1 = [1,2,3,4]
print(l1.__iter__().__next__()) #1
print(l1.__iter__().__next__()) #1
print(l1.__iter__().__next__()) #1
print(l1.__iter__().__next__()) #1
print(l1.__iter__().__next__())
# 迭代器对象再调一次还是自己
res = l1.__iter__()
print(res.__iter__().__next__()) # 1
print(res.__iter__().__next__()) # 2
print(res.__iter__().__next__()) # 3
print(res.__iter__().__next__()) # 4
可迭代对象和迭代器对象通过打印操作无法直接看到内部数据的情况都可以节省内存
for 循环的本质
语法结构 for 变量名 in 可迭代对象 循环体代码 for自动将in后面的数据调__iter__()变成迭代器对象 之后每次循环调用__next__ 取值 最后没有__next__会报错自动处理报错
l1 = [1,2,3,4]
res = l1.__iter__()
while True:
try:
print(res.__next__())
except BaseException:
break
for i in []:
print(i)
for循环后没有数据不会运行
异常捕获
1.如何理解异常
异常就是程序运行中的bug 会导致整个程序运行结束
2.异常的机构分为三个
1.关键字line所在行，提示第几行出错了
2.最后一行冒号左侧错误的类型
3.最后一行冒号的右侧错误的具体原因
3.异常的类型
NameError
IndexError
ListError
TypeError
4.异常的分类
1.语法错误
不允许出现 出现必须立刻修改
2.逻辑错误
允许出现 允许出错之后修改即可
写代码自己跑一遍
异常捕获实际操作
当不确定是否会出错，提前预测可能会出现问题并提前给出处理措施
1.基本语法结构
try:
l1 =[]
l1[100]
except NameError: # 变量名错误
print('name not difend')
except IndexError as e: # 可以打印e让软件自动提示也可以自己打印提示
print('超出索引范围')
print(e)
except 错误类型 as e:
print(e)
#except 可以写多行预测多个情况
print(123)
2. 万能异常
try:
异常代码
except Exception as e： 万能预测所有逻辑错误都可以处理
print(e)
try:
jaosn
name = 'tony'
except Exception as e: #如果出错就打断程序执行子代码
print(e, '出错走这里')
else: # 不出错执行下面这个
print('没出错真厉害')
finally:
print('无论是否出错我都走')
断言预测
name = 'jaosn'
assert isinstance(name,list) # 猜对了运行猜错了报错
print('针对name数据使用列表的相关操作')
主动报错
username = input('name：')
if username == 'jason':
raise Exception('自毁程序') # 主动异常 如果输入的用户是jason主动报错
else:
print('不是jason')
折叠
异常捕获建议能少用就少用，被try检测的代码能少就少
异常捕获练习
1.for 循环底层
l1 = [1,2,3,4,5,6,8]
res = l1.__iter__()
while True:
try:
print(res.__next__()) #打印取值的数据
except Exception: #不知道报错原因使用万能
break
'''
1.先看具体报错信息
2.再看报错的位置
从下往上看
3.尽量讲错误缩小到某个具体的数字
'''
自定义迭代器对象
1.生成器对象本质就是迭代器对象，迭代器是解释器提过给我们现成的
生成器对对象是我们自定义的
iter 和__nxet__
2.学习生成器对象目的就是为了简化代码
一种不依赖于索引取值的通用方式
可以节省数据类型的内存占用空间
3.生成器对象的代码实现
def func():
print('你好')
yield # 可以在函数体代码中出现多次能够让代码停住
print('我在第二层')
yield 123 # 后面可以跟返回值参数 打印的时候 打印双下调用双下next即可获取
print(func) # <function func at 0x109e65ea0> 函数
res = func()
#当函数体代码中有yield 第一此调用不会运行
print(res) # <generator object func at 0x1006cb7d8> 生成器对象
res.__next__()
res.__next__()
res.__next__() # 函数体代码里有多少个关键字就只能调多少次没有就报错每次调用就会停在那一层
自定义迭代器练习题
编写生成器实现range功能
def index(star,end = None, step = 1):
if step < 1:
step = 1
if not end:
end = star
star = 0
while star < end:
yield star
star += step
for i in index(1,99,5):
print(i)
yield其他方法
def func(name,food = None):
print(f'{name}准备干饭')
while True:
food = yield
print(f'{name}吃{food}')
res = func('tony')
res.__next__()
res .send('狗粮') # send 传值并自动调用__next__
res.send('猫粮')
res.send('西北风')
生成器表达式
列表生成式
l1 =[i**2 for i in range(10) if i >3]
l1 =（i**2 for i in range(10) if i >3）
模块的简介
1.如何理解模块
'''
模块可以看成是一系列功能的结合体
使用模块就相当于拥有这个结合体内的所有功能
鸡哥说使用模块就相当于站在巨人的肩膀上
将来接到业务需求的时候先不要自己写，先看看有没有相应的模块可以实现需求的功能
'''
python小故事
#python 屈辱史
#python 刚出来时被其他编程程序员看不起
#太简单 写代码都是调用模块(调包侠 贬义词)
#随着业务的扩展其他程序员也需要使用python写代码写完之后发现python
#真好用 (调包侠 褒义词)
'python 厉害的原因：因为支持python 的模块非常多非常全非常完善'
模块的分类
1. 内置模块：
解释器自带的 直接可以使用的模块
比如 time 模块
import time
time.sleep(3)让程序等待三秒后运行
2.自定义模块
自己写的模块：
登陆注册功能
user_name = input('用户名>>>:')
3.第三方模块
别人写的模块，存在于网络上，使用之前提前下载
比如：图形识别，语音识别，图形可视化
模块的表现形式
1.py文件也可以称为模块文件
2.含有多个py文件的文件夹，按照模块功能的不同划分不同的文件夹存储
3.已被编译为共享库的DLL的c或c++扩展
4.使用c编写并链接到python解释器的内置模块
倒入模块的方式
'''
补充
以后真正的项目中所有的py文件名称都是英文 ，没有中文和编号
模块名：正确use01r.py
错误01user.
模块的起名需要使用英文否者无法导入
'''
倒入模块句式1.
import user # 执行文件生成全局名称空间，执行后名称空间中就会产生被导入模块的名字 此时该名字指向被导入模块的名称空间
# 导入相当于执行被导入文件user文件自动创名称空间user
#并执行user文件中的所有代码并将产生的名字存储导该名称空间中
print(user.name)
user.outer()
user.inter()
print(user.outer)
1.产生执行文件的名称空间
2.产生被导入文件的名称空间并运行被导入文件内的所有代码 存储名字
3.在执行文件中获取一个被导入文件名称空间的名字，通过该名字点的方式就可以使用到被导入文件的名称空间的名字
导入模块句式2.
from user import name # 从模块中导入name如果想要两个名字直接在后面加逗号
print(name) #导入的是变量名直接可以使用
'''
1.创建执行文件的名称空间
2.创建被被导入文件的名称空间
3.运行被导入文件中的所有代码并将名字存储到被导入文件的名称空间
4.在执行名称空间中获取到指定的名字指向被导入文件的名称空间中相同名字可以绑定其他数据将指向改为其他数据
'''
import user
print(user) # 导入模块就是让变量绑定该模块的名称空间当重新赋值时就会断开绑定关系
user = 123
print(user)
import user
print(user) # 断开后可以重新导入模块重新绑定未重新绑定之前无法使用名称空间里的名字
#重新导入后不会再次执行
两种导入局势的优缺点
import 模块名
优点:通过点的方式可以使用到模块内所有的名字，并且不会冲突，缺点是什么都可以用，有时候不想让别人用到所有的名字。
from 模块名 import 导入的名字
优点：指名道姓的使用使用指定的名字，不需要加模块名前缀
缺点：容易与执行文件中的名字冲突绑定关系被修改
起别名
1.多个模块名相同多个人写
2.原来的模块名复杂
代码演示：
import md as m 此时模块名会被修改
print(m)
from md import name as mdname # 修改导入的变量名
print(n)
from md1 import name as md1name # 导入不同文件的name
导入多个模块
1.
import time,sys,os
导入功能相似的模块使用逗号追加，不相似尽量分开 导入名字指的是模块名
import time
import sys
import os
2.
from md import name, age, add # 使用这个导入方式可以使用追加名字指的是变量名具体的数据值
3.不能使用模块名导入
全导：
from md import* # 星表示所有用的时候直接用
#可以在被导入模块中设置导入的权限
__all__ = [''] 在模块中使用双下all赋值后面的列表列表中填写想给人家导的数据当导入使用星的时候只能用到列表里的数据此功能只针对星号
循环导入
循环导入就是两个文件彼此导彼此
循环导入容易出现报错
使用彼此的名字可能在没有准备好的情况下使用
解决循环导入的问题提前就名字准备好
尽量避免循环导入
判断文件类型
#所有py文件中都有一个__name__内置名
#当py文件是执行文件的时候__name__的就过是__main__
#当py文件是被导入文件的时候__name__就是模块名
执行文件执行导入文件里的代码来查看结果
__name__主要用于开发模块作者测试自己代码所用
if __name__ == '__main__':
当文件是执行文件的时候才会执行if分支的子代码
上述判断一般在整个程序的启动文件中
在pycharm中mian按tab补全
模块的查找顺序
"""1先去内存中找
2再去内置空间找
3再去sys.path中找程序系统环境变量"""
1验证导入一个文件，然后在导入过程中删除该文件，发现还可以使用
2创建一个跟内置模块名相同的文件名
import time
print(time.time())
import time
print(name)
此时pycharm不知道我要导入的是那个模块
4.导入模块的时候要知道谁是执行文件
import sys
sys.path.append(r'/Users/ltianhao/PycharmProjects/循环导入/xxx')
import b
当文件在不同文件夹是无法直接导入找到需要导入文件所在路径然后添加到执行文件的程序系统的环境变量
import a
import sys
print(sys.path)
print(a.name)
"""
pycharm会自动将我们的根目录添加到程序的环境变量中
"""
from xxx.aaa import b
print(b.name)
可以使用这个方法从文件夹中直接导入模块名也可以导入变量名使用句点号进入下一层
绝对导入与相对导入
"""
只要涉及模块的导入，那么sys.path永远以执行文件未准
"""
1.绝对导入：
其实就是以执行文件所在的sys.path为起始路径往下一层层导
from aaa import c
from aaa.bbb.ccc import a
ps：由于pycharm会自动将根目录添加到sys.path中所以查找模块不报错的方法就是永远从根路径往下找
如果不是用pycharm运行需要将根目录添加到sys.path中（针对根目录有模块可以获取>>>os）
2.相对导入
符号在路径中的意思
. 在当前路径
..在上一层路径
../..在上上层路径
相对路径导入使用点的方式
from . import c # 导入模块的当前路径
from .. import c # 导入模块的上一层路径
from ../.. import c # 导入模块的上两层路径
"""
相对导入只能在模块中使用不能在执行文件中使用
相对导入在项目复杂的情况下容易出错
推荐使用绝对导入，不推荐使用相对导入
"""
- 执行文件的程序环境变量pycharm会自动把根目录添加到执行文件的sys.path中所以可以直接使用from导不再同一路径的文件
包的概念
1.如何理解包
内部含有__init__.py的文件夹
直观就是一个文件夹
2.包的作用
内部存放多个py文件，模块文件，便于管理文件，分类存放
3.如何创建包
1.直接创建文件夹 内部创建__init__
2.直接创建包 Python Package
4.如何使用包内的模块
导入包然后将包内的模块导入__init__文件中利用此文件帮助我们控制其他模块简介使用其他模块的功能，也可以跨包导内部模块文件
代码：
print('我在d')
print('我在c')
print('我在b')
from . import b
from . import c
from . import d
import aaa
print(aaa)
越过包导内部文件：
from aaa import b
"""
导包的内部文件时只要经过包那么包内部的__init__就会运行一次
"""
针对python3 文件夹下有没有__init__.py有没有都无所谓
python2 文件夹中必须有__init__.py才能被当作包
此处细节鸡哥没讲
编程思想的转变
1.小白阶段
按照需求从上往下堆叠代码 单文件
2.函数阶段
将代码按照功能的不同封装称不同的函数 单文件
3.模块阶段
根据功能的不同拆分不同的模块文件 多文件
将所有的文件全部存储在c盘，将所有的文件在c盘中分类，将所有文件按照功能不同分类到其他盘中
作用高效的管理资源
软件开发目录规范
针对模块阶段，分模块文件之后还需要有文件夹
我们所使用的所有程序目录都有一定的规范(多个文件夹)
1.bin 文件夹 用于存储程序的启动文件 start.py 可以不创直接放根目录
2.conf文件夹 用于存储程序的配置文件 settings.py
3.core文件夹 用于存储程序的核心逻辑 src.py
4.lib文件夹 用于存储程序的公共功能 common.py
5.da文件夹 用于存储程序的数据文件 userinfo.py
6.log文件夹 用于存储程序的日志文件 log.log
7.interface文件夹 用于存储程序借口的文件 user.py
8.readme文件夹 说明书 文本文件
编写的时候可以不按照上述名称创建，只需要提现出分门别类就行了
代码展示
def register():
print('注册功能')
def login():
print('登陆功能')
def tansfer():
print('转账功能')
def withdraw():
print('提现功能')
func_dict = {'1':register, '2':login, '3':tansfer, '4':withdraw}
def run():
while True:
print('''
1.注册功能
2.登陆功能
3.转账功能
4.提现功能
''')
choine = input('输入功能选项>>>:').strip()
if choine in func_dict:
func_dict.get(choine)()
else:
print('没有此功能') # 以上代码写在core文件夹src.py核心逻辑下列代码写在启动文件中
from core import src
if __name__ == '__main__':
src.run()
折叠
常见内置模块
collections 包名
1.namedtuple 具名元组
from collections import namedtuple
point = namedtuple(二维'坐标系',['x','y'])
print(point)
res = point(1,2)
print(res) # 坐标系(x=1, y=2)
print(res.x) # 1单独拿一个点就行
from collections import namedtuple
point = namedtuple('三坐标系',['x','y','z'])
print(point)
res = point(1,2,3) # 传三个参数即可
print(res) # 坐标系(x=1, y=2)
print(res.x) # 1单独拿一个点就行
扑克牌
2.from collections import namedtuple
name = namedtuple('扑克',['花色','点数'])
res = name('♥️','皮蛋')
res1 = name('♠️','皮蛋')
print(res,res1)
from collections import deque
list =deque()
list.append(123)
list.append(123)
list.append(123)
list.append(123)
print(list)
'''双端队列可以两边进两边出'''
队列先进先出，堆栈先进后出
from collections import OrderedDict #将字典转成有序的按照插入顺序排列
dict = OrderedDict([('1','A'),('2','B')])
print(dict)
3.
res = 'asdasfasfasgasfafasd'
new_list = {}
for i in res :
if i not in new_list:
new_list[i] = 1
else:
new_list[i] += 1
print(new_list)
from collections import Counter
k = Counter(res)
print(k)
折叠
时间模块
时间的三种格式
# 1.时间戳
import time
print(time.time()) #时间戳 1970年1月1日零时零秒
# 2.结构化时间
print(time.gmtime()) # time.struct_time(tm_year=2022, tm_mon=7, tm_mday=14, tm_hour=14, tm_min=24, tm_sec=21, tm_wday=3, tm_yday=195, tm_isdst=0)
# 格式化时间
print(time.strftime('%Y-%m-%d %H:%M:%S'))
print(time.strftime('%Y-%m-%d %X'))
格式化时间的对应字符
%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%M 分钟数（00=59）
%S 秒（00-59）
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身
时间可以互相转换未深入了解
内置模块
- datetime模块
import datetime # 时间模块
import time
res = datetime.datetime.today() # 2022-07-15 14:33:58.806285
res1 = datetime.date.today() # 2022-07-15
res2 = datetime.datetime.now() # 与today相同，ucnow东零区时间
print(res, res2)
print(res1)
print(res.year) # 只想取部分可以通过点的方式 2022 7
print(res.month)
print(res.day)
print(res.hour)
print(res.weekday()) # 0到6
'''
date 年月日
datetime 年月日 时分秒
'''
t1 = datetime.timedelta(days=3) # 三天的时间3 days, 0:00:00
print(t1)
print(res + t1) # 先获取当前时间然后加三天的时间也就是三天之后的时间2022-07-18 14:38:39.581186
print(res - t1) # 先获取当前时间然后加三天的时间也就是三天之前的时间2022-07-12 14:38:39.581186
time.sleep(3) # 程序休眠
print(123)
'''
timedelta（）括号内可以填很多参数没有的时间可以换算出来
'''
冷门补充
c = datetime.datetime(2014,3,3,12,30,15) # 年月日中间用逗号隔开即可
print('指定时间：',c)
- os模块（非常重要）
import os
1.#创建单级目录与删除
os.mkdir(r'k')
os.mkdir(r'log用于存储程序日志的文件夹类似于监控/log.log') # 通过撬棍进入文件夹内部创建文件
os.rmdir(r'/Users/ltianhao/PycharmProjects/day24/aaa/bbb/ccc')
os.rmdir(r'/Users/ltianhao/PycharmProjects/day24/aaa') # 内部有文件不能删除
2.#创建多级目录与删除
os.makedirs(r'aaa/bbb/ccc')
os.removedirs(r'aaa') # 内部有文件也无法删除
os.removedirs(r'aaa/bbb') # 内部没有文件依次往外删除最底层没有文件往上跳由内而外递归删除
3.# 列举指定路径下的文件名称包含文件夹 当前文件下一级的不算)
print(os.listdir())
print(os.listdir('/Users/ltianhao/PycharmProjects/day24/core用于存储核心逻辑的文件夹')) # 可以指定路径
4.#删除文件夹与删除文件的区别
os.rename(r'log用于存储程序日志的文件夹类似于监控/log.log','log用于存储程序日志的文件夹类似于监控/log.txt') # 可以通过代码改文件夹内部的文件名
os.remove(r'log用于存储程序日志的文件夹类似于监控/log.txt') # 删除内部文件
5.#获取当前工作的路径绝对路径
print(os.getcwd())
print(os.path.abspath(__file__)) # 获取当前文件的绝对路径
print(os.path.dirname(__file__)) # 获取当前文件所在的目录路径 括号内方__file__
6.#可以通过该方式切换路径
os.chdir(r'..')
os.removedirs(r'josn专属模块') # 通过切换路径删除空目录
print(os.getcwd())
os.removedirs(r'core用于存储核心逻辑的文件夹/k')
7.# 判断当前文件，目录中有没有该路径
print(os.path.exists(r'bin用于存储启动程序文件夹'))
print(os.path.exists(r'aaa'))
8.#判断是否是文件夹
print(os.path.isdir(r'bin用于存储启动程序文件夹')) # 判断路径是否是文件夹
print(os.path.isfile(r'bin用于存储启动程序文件夹')) # 判断路径是否是文件
9.#拼接路径
res_pathh = '/Users/ltianhao/PycharmProjects/day24/bin用于存储启动程序文件夹'
absolute_path = 'start.py'
print(os.path.join(res_pathh, absolute_path)) # 此方法自动识别操作系统
#/Users/ltianhao/PycharmProjects/day24/bin用于存储启动程序文件夹/start.py
10.#获取文件大小
print(os.path.getsize(r'run.py'))
折叠
import os
import sys
print(os.path.dirname(__file__)) # 文件所在目录绝对路径
res = os.path.dirname(os.path.dirname(__file__)) #文件所在目录上一层路径
print(res)
sys.path.append(res)
from core import src
src.func()
sys模块
import sys
# 1.#查看解释器的信息
# print(sys.path)
# 2.#查看当前解释的信息
# print(sys.version)
# 3.#查看当前平台
# print(sys.platform)
4.
res = sys.argv
'''需求命令行执行当前文件必须提供用户名和密码否则不能执行'''
if len(res) == 3:
user_name = res[1]
password = res[2]
if user_name == 'jason' and password == '123':
print('正在执行该文件')
else:
raise Exception('暂无执行权限') # 使用异常捕获
else:
print('请填写密码') # 什么都不输入就提示填写密码
print(res)
json模块(重要)
#josn模块
# josn模块称为序列化模块
# josn模块是不同编程语言之间数据交互必备的模块(处理措施)
# josn格式的数据应该是？
# 数据基于网络传输是二进制，在python中只有字符串是可以调用encode方法转成二进制数据，所以json数据也属于字符串
import json
d = {'name':'jason','age':18}
print(json.dumps(d)) # {"name": "jason", "age": 18} 序列化
with open(r'requirements.txt','w',encoding='utf8') as f:
f.write(str(d))
with open(r'requirements.txt','r',encoding='utf8') as f:
print(f.read()) # {'name': 'jason', 'age': 18}
with open(r'requirements.txt','a',encoding='utf8' ) as f:
f.write('\n'+json.dumps(d))
with open(r'requirements.txt','r',encoding='utf8') as f:
data = f.readlines()[1]
res = json.loads(data) # {'name': 'jason', 'age': 18} <class 'dict'>反序列化将json格式转成对应的编程语言中的数据类型
print(res,type(res))
#直接将json格式字符串写进文件，将文件中josn字符串读取出来并转换成对应的数据类型
with open(r'requirements.txt','w',encoding='utf8') as f:
json.dump(d,f)
with open(r'requirements.txt','r',encoding='utf8') as f:
res = json.load(f)
print(res,type(res))
