"""运算符"""
# 算数运算符:+ - * / // % ** 最后三个:地板除(比如a/b=3.几,就砍掉小数保留整数部分),取余,乘方
保留小数位: float('%.2f' % 1.23456) 或 float(format(1.23456, '.2f'))
# 比较运算符: > < >= <= == != 运算后只会产生两个结果True False
# 赋值运算符 = += -= *= /= //= %= **= 都是a//=b => a=a(运算符)b
# 成员运算符:in和not in (针对容器型数据)
# 身份运算符 is 和is not(检测两个数据在内存中是否是同一个值)
# 逻辑运算符 and or not
# 位运算符: & | ~ ^ << >> 分别是位与,位或,按位取反,按位异或,左移,右移
注意:位运算都是每一位都参与运算,不管是不是符号位
位运算符举个栗子:
# ~ 按位取反(每一位都取反,不管是不是符号位),结果就是-5
print(~4) # 4 = 0b00...100 按位取反 0b111...011 --> 0b100...100 + 0b1 = 0b100...101 = -5
# ^ 按位异或(每一位都异或,不管是不是符号位),结果就是1
print(4^5) # 4 = 0b00...100 按位异或 5 = 0b000...101 --> 0b000...001 = 1
"""运算符的优先级"""
以下所列优先级顺序按照从低到高优先级的顺序；同行为相同优先级。
Lambda #运算优先级最低
逻辑运算符: or
逻辑运算符: and
逻辑运算符:not
成员测试: in, not in
同一性测试: is, is not
比较: <,<=,>,>=,!=,==
按位或: |
按位异或: ^
按位与: &
移位: << ,>>
加法与减法: + ,-
乘法、除法与取余: *, / ,%
正负号: +x,-x
"""原码,反码,补码"""
# 1 计算机底层二进制中,最高位为1表示负数,最高位为0代表正数
# 2 计算机都是在补码下运算数值的,运算好了再还原成原码
# 3 规则:
原码=补码取反+1
补码=原码取反+1
# 4 这里的取反都是最高位(符号位)不变,其他位取反
# 5 注意: 二进制都是0b开头,这里只是省略没写
# 举个栗子,模拟计算机计算 5-3:
5:
原码=反码=补码=0000...101
-3:
原码=1000...011
反码=1111...100
补码=1111...101
5+(-3)=
0000...101
+1111...101
=0000...010 #此补码0开头为正数,原码反码补码相同
=2
# format 字符串填充符号{who:*^10s} s代表填充类型为字符串型 ^居中 >居右 <居左,三种传递方式(顺序传参,关键字传参who,索引传参)
# isinstance #isinstance(XXX,(可能的类型)) 判断是否是某种类型,只写一个类型就不加()
'''字符串相关'''
# [:] [::] 全截取
# [开始值:结束值:间隔值] 取不到结束值
注意,取不到结束值,想取到结束值就这样取[a:]
# capitalize #字符串.capitalize() 首字母大写
# titile #每个单词首字母大写
# upper #每个字母大写
# lower #每个字母小写
# center #按XX填充字符串,默认填空格 strvar.center(10,"*")
# strip #默认删除首尾空白符 \r \n \t 空格 #需要接收 res=strvar.strip("我")删除首尾的字符"我",最多只能带一个参数
# replace *** #旧字符换新字符(默认可替换多个),需要接收 #res=strvar.replace(旧字符串,新字符串)
要连续替换就用strvar=strvar.replace(旧字符串,新字符串) 可切片cardid1=a.replace(a[2:4],"***")
# swapcase #大小写互换
# len #统计字符串长度
# count #统计某元素出现次数
# find #查找某元素第一次出现索引位置,注:列表没有find方法
# index #同find,找不到报错,列表也有index方法
# isdecimal *** #是不是纯数字的字符串 a.isdecimal()
# split #按分割符分割成列表,默认按空格
# join #把列表按添加的字符拼接成字符串 #"拼接符".join(listvar)
'''使用join注意:列表里面必须都是字符串元素才可以拼接'''
# startswith #是否以某字符串为开始
# endswith #是否以某字符串为结尾
# isupper #是否全大写
# islower #是否全小写
# isalpha*** #是否是字母或文字
# isdigit*** #是否是数字,(接受二进制字节流 b"1122")
Str.ljust(8, "0") # 字符串补全(右补0, 注意是原字符串放在左边, 所以是右补0), rjust同理, zfill(8)左补0
'''列表相关'''
# append #末尾追加 # 不需要接收, 直接在原有列表上修改
# insert #索引前添加 listvar.insert(索引,想添加的元素) #可用insert(length(list),xxx)把元素添加到末尾, # 不需要接收, 直接在原有列表上修改
# extend #迭代追加(可迭代型数据), # 不需要接收, 直接在原有列表上修改
# pop #索引删除,默认删最后一个 ###只能删一级列表
# remove #给定值删除,若含多个这样的值默认删第一个,本来不存在的话报错,有且只能有一个参数
"""remove是在原列表的基础上删的,不需要返回值接收,接收的话就是个None"""
# clear #清空列表
# del xxx #索引删除,可切片
del listvar[0]
del listvar[2:4]
# index #通过元素获取索引,没有就报错 listvar.index(要索引的元素) , 有多个时默认只取第一个
# count #统计元素数量
# sort #排序,默认从大到小, 从小到大排序(reverse=True) #无返回,直接改变原本的列表
alist.sort() # 注意 区别于sorted(alist) # 后者不会改变原列表alist
# reverse #列表反转 #无返回,直接改变原本的列表, alist[::-1]也可以反转,需要接收
'''拷贝'''
import copy要调用模块
# copy.copy #浅拷贝 #只能复制一级容器中的值
# copy.deepcopy #深拷贝 #可以复制多级容器内的值,原值更改后深拷贝不变
'''字典相关'''
# fromkeys #默认值创建字典(赋初值) dic={}.fromkeys(listvar,None) 把一个列表的每个元素都赋作字典的键,如果用字符串也可以
或者dic={}.fromkeys(strvar,666) 把strvar拆成每个字符然后当做键,并初始化值666
# pop #通过键删除键值对,并且有返回值,返回值就是这个键对应的值,dictvar.pop("key"),如果不存在这个键则报错
# popitem #删除最后一个键值对
# clear #清空字典
# update #有该键更新,无该键添加 #等同于dictvar[键]=值, 不过update可以一次性更新多个键值对, 添加键值对或者更改值 dictvar.update({"我":"666"})
# get #通过键获取值,无此键不报错 dictvar.get("我","该键不存在") 可设置默认值,预防报错,若不存在,则返回后一个参数
# keys() #将字典键组成新可迭代对象
# values() #将字典值组成可迭代对象
# items() #将键值对组成一个个元组 res接收,
通过for i,j in 字典.items()可以同时遍历出键和值
'''集合相关'''
# intersection 或 & #交集
# difference或 - #差集 {1, 2, 3}.difference({2, 3, 4})得到{1}
# union或 | #并集
# symmetric_difference或 ^ #对称差集,两集合中不同的元素
# issubset或< <= #是否是子集
# issupperset或> >= #是否是父集
# isdisjoint #是否不相交 不相交True
# add #增加数据
# update 增加可迭代数据setvar.update({XX1,XX2...}),中间用{},[]还是啥自己选,可一次性添加多个
# clear #清空集合
# remove #删除指定的值,不存在则报错
# discard #删除指定的值,不存在就不删除
# pop #随机删除集合中一个数据
# fz=frozenset(list或set或str都行) #冰冻集合,不能做修改,只能做交差并布
# min() #返回最小值 max(alist)
# max() #返回最大值
'''循环相关'''
# pass #过,暂时写入空循环或者空判断语句作为占位用,不会报错
# break #终止当前循环,只能跳出当前所在的循环
# continue #跳过当前循环,直接执行下一次循环
'''文件操作相关'''
打开相对路径的文件 with open(r"myfile/test777.txt",mode="w",charset="utf-8") as fp
注意:在windows里面路径用\分割,在linux里用/分割
# open 打开文件 fp=open("2.1text1.txt",mode="w",encoding="utf-8")
# read() 从光标处开始,读取所有内容(里面的可以带参数,代表要读的字符个数)
# write() 向里面写入,如果光标在第一行行首,如果里面有内容,则写入多少替换多少
write往文件中只能写入字符串或二进制字节流
# seek() 调整指针(光标)位置(里面可以加参数,代表移动到第几个字节后)
seek(0) 把文件指针移动到行首 #seek(0,2) 把文件移动到(第二种0)倒数0字节后,即末尾
# tell() 告诉我当前光标左侧所有字节数(返回字节数)
# w+模式可读可写可创建,写了之后光标在末尾,w+模式打开文件就清空原有内容 ,w模式也是清空原有内容
# r+模式可读可写不可创建,打开文件时,默认把光标挪到开头,如果写入有内容的文件,则写多少替换多少
# a+追加模式,可读可写可创建,追加内容时,强制把光标挪到末尾
# flush #可以瞬间刷新缓冲区,把内容直接写入到文件中 fp.flush()
# readline() # 读取一行文件内容,需res接收
# readlines() # 将文件中的内容按照每一行读取到列表当中
# writelines() # 将内容是字符串的可迭代性数据写入文件中 参数:内容为字符串的可迭代数据 fp.writelines(["大","黄","蜂"])
# truncate() # 把要截取的字符串提取出来,然后清空内容将提取的字符串重新写入文件中 (字节)
truncate()括号不带参数的话默认清空文件内容
# readable() # 判断文件对象是否可读
# writable() # 判断文件对象是否可写
# encode() 编码 将字符串转化为字节流(Bytes流),用法 字符串.encode(encoding="utf-8"),默认就是转化成utf-8格式,可以不传参
"""如果这个字符串只由ASCII码表上的字符组成,则可以使用 bytes(字符串)实现相同的功能"""
# decode() 解码 将Bytes流转化为字符串
strvar = "我爱你"
res=strvar.encode("utf-8")
print(res)
print(res.decode("utf-8"))
'''函数相关'''
# __doc__ # 查看函数功能 res=函数名.__doc__
# help # 查看函数功能 help(函数名)
# global b 把b变量从函数外叫到函数内,可做修改操作,也可以直接定义全局变量b
# nonlocal b 把b变量从外层函数叫到内层函数,可做修改操作
# *args 函数调用处用来解包列表;函数定义处用来收集没人要的普通实参, 例如 func2(a1, a2) 等价于 func2(*[a1, a2])
# **kwargs 函数调用处用来解包字典,解成一个个等式;函数定义处用来收集没人要的关键字实参, 例如 func2(a1="666") 等价于 func2(**{"a1": "666"})
# locals res=locals()函数外,打印前,所有变量成字典;函数内,调用前,局部变量成字典
# globals res=globals()函数外,打印前,所有变量成字典;函数内,调用前,所有变量成字典
# lambda函数(也就是匿名函数), 接收任意多个参数, 返回单个表达式值
例如 lambda n: n * n if n < 0 else n + 1, 调用方式: (lambda表达式)(),或者拿个变量去接收lambda表达式,不过这和写普通函数没啥区别了
前面的n为参数,冒号后面的表达式为返回值,意思就是无法写函数体语句,只能写参数和返回值,鸡肋
即用即扔, 节约内存, 一般与filter和map等结合使用
# dir 查看该数据的内部成员(查看方法或函数) dir({X,X,X})
dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，
返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息
# iter 把可迭代对象强转迭代器 iter(Iterable)
如果该数据成员当中含有__iter__方法,就是可迭代对象
# next 获取迭代器中数据(一次只获取一个) res=next(Iterator)
"""""" iter和next一个是定义迭代器,一个是调用迭代器,其中定义迭代器我只知道有这一种方法,调用的话除了next(it),it就是迭代器对象,还可以for,list强转
@@@可迭代对象/迭代器
from collections import Iterator, Iterable
# Iterable 可用于isinstance中,判断是否是可迭代对象
# Iterator 可用于isinstance中,判断是否是迭代器 # 文件对象是迭代器
# map 迭代运算器 map(func,Iterable)把可迭代对象中的值一个个拿到函数中运算,把函数的返回值放入迭代器,如果是字典,运算的就只是键,返回迭代器
# reduce 两两运算器 reduce(func,Iterable)从可迭代对象中一次拿两个数据,
扔到函数中运算,然后把运算的结果与可迭代对象中的第三个数据一起放到函数中运算,以此类推,返回计算结果
import reduce
# sorted 排序 sorted(Iterable,key=函数,reverse=False)从小到大,True从大到小,默认从小到大,返回一个列表,列表中放着排序后的结果
# filter 真假过滤器 filter(func,Iterable) 相当于遍历功能,放入自定义函数中,返回True则保留数据,False则舍弃数据,返回迭代器
filter(func,Iterable),如果可迭代对象是个字典,那就迭代的是字典的键
"""推导式 #Iterable后可加if单项分支,for前可加if双项分支 """
例: 取出alist中的所有偶数 [i for i in alist if i % 2 == 0]
通过一行判断,遍历出一系列数据的推导式,得到的都是迭代器
# (val for val in Iterable) 生成器
# [val for val in Iterable] 列表推导式
# {val for val in Iterable} 集合推导式
# {a:b for a,b in Iterable} 字典推导式(Iterable必须是等长的二级容器)
"""其它常用内置函数(高级用法)"""
# enumerate 索引号匹配器 enumerate(iterable,start=0) start表示从..开始(不传start默认从0开始),
将索引号与Iterable中的值一个个拿出来配对成元组,返回迭代器
# zip 多对象匹配器 zip(Iterable1,Iterable2...) 将多个Iterable中的值,一个一个按顺序拿出来配对组成元组放入迭代器,返回迭代器. 如果可迭代对象是个字典,那就迭代的是字典的键
a = [1, 2, 3]
b = (4, 5, 6, 7)
print(list(zip(a, b))) # [(1, 4), (2, 5), (3, 6)]
"""generator object生成器对象""" # 自定义生成器 gen=(i for i in range(5))
# 两种创建方式
(1)gen=(里面是推导式,外面用圆括号) 其中gen是生成器名,自己取
(2)函数里面一定要有yield
def mygen():
code1
yield 返回值1
code2
yield 返回值2
...
#mygen是生成器名,自己取,生成器也是一个迭代器,可用next调用
# yield 相当于return,但是下次调用时就接着这个yield返回处执行
# send 获取生成器中的数据并把send括号中的值发送给上一个yield,如果不想发送数据,就用next或for i in
注意,send发送的第一个值只能是None,因为没有上一个yield
# yield from 将可迭代对象变成一个迭代器返回,用在函数里,后加Iterable
# 取出迭代器中的值的方法: for遍历 多次next 循环+next list强转
# def digui(n):
# code
# return digui(n-1) #递归函数
"""内置函数"""
# abs 绝对值函数 abs(number)
# round 四舍五入保留xx位小数 (特殊情况 n.5的话 n为奇数就进1,n为偶数则不进1) 奇进偶不进
# sum 计算一个序列的和 sum(Iterable)
# max 获取一个序列中的最大值
# max高阶函数的使用 max(Iterable,key=func) #先遍历,把遍历的东西(注意字典遍历的是键)
丢到func中,取出得到的数据中最大值,返回这个最大值所对应的遍历数据
# min 获取一个序列中的最小值
# min高阶函数的使用 和max高阶函数一样
# pow 计算某个数值的x次方 pow(2,10)
若括号里有三个参数,前两个算平方,然后对第三个参数取余
# range 产生指定范围数据的可迭代对象
# bin 将10进制数据转化为二进制
# oct 将10进制转化为八进制
# hex 将10进制转化为16进制
# chr 将ASCII编码转化为字符
# ord 将字符转化为ASCII编码
# eval 将字符串当作python代码执行 有局限性,不能在里面创建变量
print(eval("9-2*5/3+7/3*99/4*2998+10*568/14"))
# exec 将字符串当作python代码执行(功能更强大) 谨慎使用,存在安全隐患
exec("a=9-2*5/3+7/3*99/4*2998+10*568/14")
print(a)
# repr 不转义字符输出字符串
# input 接受输入字符串
# hash 生成哈希值 相同的字符串,无论哈希多少次,都是相同的哈希值,可用于判断两个文件的内容是否完全相同
"""pickle序列化模块""" #将数据类型序列化成二进制字节流
import pickle
文件当中,只能存储字符串或二进制字节流,其他数据类型不行
# dumps 把任意对象序列化成一个bytes res=pickle.dumps(XXX)
# lodes 把任意bytes反序列化成原来数据 res2=pickle.loads(res)
# dump 直接序列化并写入文件 pickle.dump(lst,fp)
with open("ceshi666.txt",mode="wb") as fp:
pickle.dump(lst,fp)
# load 直接读出内容并反序列化 res=pickle.load(fp) 并且可以连续load,直到把文件内容读完
with open("ceshi666.txt",mode="rb") as fp:
print(pickle.load(fp))
"""math数学模块"""
import math
# ceil() 向上取整(对比内置round)
# floor() 向下取整(对比内置round)
# pow 计算一个数值的N次方(计算结果为浮点型)(对比内置pow) pow(2, 10) # 1024
# sqrt 开方(结果为浮点型)
# fabs 计算一个数值的绝对值(结果为浮点型)(对比内置abs)
# modf 将一个数值拆分成整数和小数两个部分,组成元组
# copysign 将第二个参数的符号拷贝给第一个参数 math.copysign(5,-14)
# fsum 将一个Iterable中的数据进行求和运算(结果为浮点型)(对比内置sum)
# pi 圆周率常数 math.pi
"""json: 将数据类型序列化成json字符串"""#download,先dump后load,先write后read
json能够转换的数据类型: int float bool str list tuple dict None
# dumps 把python对象(例如字典)序列化成一个json字符串
# loads 把任意json字符串反序列化成python对象(例如字典)
# dump json可以连续dump,序列化成str并写入文件, dump和load都是针对文件句柄的, 要传参文件句柄
dictvar={"name":"常远","age":20,"sex":"男"}
with open("ceshi_json.txt",mode="w",encoding="utf-8") as fp:
json.dump(dictvar,fp,ensure_ascii=False,sort_keys=True)
# ensure_ascii=False:显示为中文,sort_keys=True:对字典的键进行排序
with open("ceshi_json.txt",mode="r",encoding="utf-8")as fp:
res=json.load(fp)
print(res)
# load 但是不能连续load,是一次性拿出所有数据并反序列化成原本数据
"""异常处理"""
try:
把有问题的代码写到try代码块中
except:
如果执行到出错的地方,直接执行except这个代码块
else:
无异常时执行此代码块
finally:
无论执行报不报错,都会执行finally代码块
try:
print(aaa)
except Exception as e:
print(e) #结果 name 'aaa' is not defined
# 即在程序正常运行的前提下能够捕获所有错误信息(Exception能捕获所有错误信息)
"""随机模块 random"""
import random
# random.random() 获取随机0-1之间的小数(左闭右开) 0<= x < 1
# randrange() 随机获取指定范围内的整数(包含开始值,不包含结束值,间隔值),一,二,三个参数都可以
# randint() 随机产生指定范围内的随机整数(了解)括号只能写两个参数(包含边界值),但不能定义间隔值
# uniform() 获取指定范围内的随机小数(左闭右开)-2<x<=1 参数的大小可以反着写,但不推荐.
# choice() 随机获取序列中的值(多选一) res=random.choice(listvar)
# sample() 随机获取序列中的值(多选多)[返回列表] res=random.sample(listvar,2)
# shuffle() 随机打乱序列中的值(直接打乱原序列)
"""时间模块 time"""
import time
# time() 获取本地时间戳 (时间戳 : 秒数)
# mktime() 通过[时间元组]获取[时间戳] (参数是时间元组)
# localtime() 通过[时间戳]获取[时间元组] (默认当前时间)
# ctime() 通过[时间戳]获取[时间字符串] (默认当前时间)
# asctime() 通过[时间元组]获取[时间字符串](参数是时间元组) (了解)
# strftime() 通过[时间元组]格式化[时间字符串] (格式化字符串,[可选时间元组参数]),
不填时间元组参数就默认以当前时间进行转换 strftime在linux系统中支持添加中文,windows不支持
例如ttp = (1955,10,28,11,39,10,0,0,0)
print(time.strftime("%Y-%m-%d %H:%M:%S")) # 当前时间的时间字符串(默认)
print(time.strftime("%Y-%m-%d %H:%M:%S", ttp)) # 传第二个参数:时间元组
# 或者,和上面两个结果一样
from datetime import datetime
print(datetime.now().strftime("%Y-%m-%d %H:%M:%S")) #当前时间的时间字符串(默认)
print(datetime.now().strftime("%Y-%m-%d %H:%M:%S"),ttp)
# strptime() 通过[时间字符串]提取出[时间元组] (时间字符串,格式化字符串), 例如 time.strptime("2022-6-20 17:26:01", "%Y-%m-%d %H:%M:%S")
# sleep() 程序睡眠等待
# perf_counter() 用于计算程序运行的时间 (了解)
startime=time.perf_counter() #或者startime=time.time()
code
endtime=time.perf_counter() #或者endtime=time.time()
res=endtime-startime
'''datetime 时间日期模块'''
# 将时间格式化为带有毫秒的时间字符串
import datetime
print(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')) # 当前时间的时间字符串
# 时间字符串与datetime两者互相转换
import datetime
time_str = '2021-07-05 16:17:46.805064'
# 字符串转化为datetime.datetime格式,可存入模型类的DateTimeField中
date_time = datetime.datetime.strptime(str(time_str), '%Y-%m-%d %H:%M:%S.%f') # 没有毫秒就去掉.%f
date2 = datetime.datetime.now() # 当前时间的datetime.datetime格式
print("--1--", date_time, type(date_time))
str_time = date_time.strftime('%Y-%m-%d %H:%M:%S.%f') # 当前时间的时间字符串: date_time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
print("--2--", str_time, type(str_time))
# --1-- 2021-07-05 16:17:46.805064 <class 'datetime.datetime'>
# --2-- 2021-07-05 16:17:46.805064 <class 'str'>
计算7天前的时间: date_time_ago = datetime.datetime.now() - datetime.timedelta(days=7)
# 将datetime.datetime格式转化成秒数(浮点数), 可用于后续计算时间加时间间隔 = 新的时间: xxx.timestamp()
"""zipfile 压缩模块 (zip)"""
import zipfile
创建ceshi1.zip压缩包 zipfile.ZIP_DEFLATED打包并压缩
# with zipfile.ZipFile("ceshi1.zip","w",zipfile.ZIP_DEFLATED) as zf: 压缩文件
"""在压缩包中添加压缩文件"""# zf.write(想压缩的文件起始路径,压缩包名字)
# zf.write("/bin/cat","cat")
创建一个临时文件叫tmp , 在tmp文件夹中放入chacl文件,并压缩在一起
# zf.write("/bin/chacl","tmp/chacl")
压缩包路径和创建路径都可以用绝对路径,注意前面一定要加 r 防止转义
# with zipfile.ZipFile("ceshi1.zip","r") as zf: 解压ceshi1.zip这个压缩包
# zf.extract(要解压的文件名,路径或文件名) 解压单个文件到某路径或当前路径的文件夹中
# zf.extractall(路径或文件名) 解压所有文件到某路径或当前路径的文件夹中
# (3) 追加文件 往ceshi1.zip压缩包里追加chmod压缩文件
# with zipfile.ZipFile("ceshi1.zip","a",zipfile.ZIP_DEFLATED) as zf:
# zf.write("/bin/chmod","chmod")
# namelist 查看压缩包中的内容,也要with打开 res=zf.namelist()
"""os模块-对系统进行操作"""
import os
# os.system("touch ceshi1028.txt") #创建文件
# os.system("rm -rf ceshi1028.txt") #删除文件
# os.system("ipconfig") #查看windows系统工作变量,linux里是ifconfig
# popen() 执行系统命令返回对象,通过read方法读出字符串
优点:在输出字符串时,可以优先转换成utf-8编码集
# listdir() 获取指定文件夹中所有内容的名称列表
# getcwd() 获取当前文件所在的默认路径
# __file__ 获取路径+当前文件名 print(__file__),只要路径不要文件名os.path.dirname(__file__)
# chdir(目标路径) 修改当前文件工作的默认路径
# environ 获取或修改环境变量(environment的缩写)
print( os.environ ) #获取环境变量
print( os.environ["PATH"] ) #获取PATH环境变量
os.environ["PATH"] += ":/home/wangwen/mywork" #把路径添加进去
# os.name 获取系统标识 linux,mac ->posix windows -> nt
# os.sep 获取路径分割符号 linux,mac -> / window-> \
# os.linesep 获取系统的换行符号 linux,mac -> \n window->\r\n 或 \n print(repr(os.linesep))
os.walk() # 必选参数: path(遍历的目录), 可选参数: topdown(为 True，则优先遍历 top 目录，否则优先遍历 top 的子目录, 默认为False),
返回: root 所指的是当前正在遍历的这个文件夹的本身的地址; dirs 是一个 list ，内容是该文件夹中所有的目录的名字(不包括子目录); files 同样是 list , 内容是该文件夹中所有的文件(不包括子目录)
"""os模块-创建和删除"""
import os
# os.mknod 创建文件 os.mknod(文件名)
# os.remove 删除文件 os.remove(文件名)
# os.mkdir 创建目录(文件夹) os.mkdir(文件夹名)
# os.rmdir 删除目录(文件夹) os.rmdir(文件夹名)
# os.rename 对文件(目录)重命名 os.rename(旧名字,新名字)
# os.makedirs 递归创建文件夹 os.makedirs("a/b/c/d")
# os.removedirs 递归删除文件夹(空文件夹) os.removedirs("a/b/c/d")
"""shutil模块-复制和删除"""
import shutil
# copyfileobj(fsrc, fdst[, length=16*1024]) 复制文件 (length的单位是字符
(在r模式下,read单位是字符个数,在rb模式read单位是字节个数))
fp1 = open("ceshi100.py",mode="r",encoding="utf-8")
fp2 = open("ceshi101.py",mode="w",encoding="utf-8")
shutil.copyfileobj(fp1,fp2) 单纯仅仅复制文件内容 fp1和fp2是句柄,需要打开
# copyfile(src,dst) #单纯的仅复制文件内容,底层调用了copyfileobj shutil.copyfile("ceshi101.py","ceshi102.py")
# copymode(src,dst) #单纯的仅复制文件权限,不包括内容shutil.copymode("ceshi102.py","103.py") (虚拟机共享目录都是默认777)
# copystat(src,dst) #复制所有状态信息,包括权限，修改时间等,不包括内容 shutil.copystat("ceshi102.py","104.py")
# copy(src,dst) #复制文件权限和内容
# copy2(src,dst) #复制文件权限和内容,还包括权限,时间等
# copytree(src,dst) #拷贝文件夹里所有内容(递归拷贝)
# rmtree(path) #删除当前文件夹及其中所有内容(递归删除) shutil.rmtree("ceshi1002")
# move(path1,paht2) #移动文件或者文件夹 path路径 shutil.move("ceshi1001","../ceshi1003")移动文件夹或文件
"""os.path模块"""
import os
# basename() 返回文件名部分 res=os.path.basename(strvar) 其中strvar需要给定路径字符串,
例如strvar = "/home/wangwen/mywork/ceshi1.py"
# dirname() 返回路径部分 同上
# split() 将路径拆分成单独的文件部分和路径部分 组合成一个元组 res=os.path.split(strvar)
# join() 将多个路径和文件组成新的路径,可以自动根据不同的系统加不同的斜杠
linux加/ windows加\ pathvar=os.path.join(path1,path2,path3) 当然你也可以用字符串拼接
# splitext() 将路径分割为后缀(比如.py)和其他部分(了解) 当然用字符串中的split也可以分割出后缀部分
# getsize() *** 获取文件的大小os.path.getsize(pathvar)
"""isdir / isfile / islink"""
# isdir() 检测路径是否是一个文件夹 res = os.path.isdir("ceshi100")
# isfile() 检测路径是否是一个文件,同上
# islink() 检测路径数否是一个链接
"""getctime / getmtime / getatime"""
# getctime() [windows]文件的创建时间,[linux]权限的改动时间(返回时间戳)
res = os.path.getctime(pathvar) 执行之后最好把时间戳转化成时间字符串
import time
str_time = time.ctime(res)
# getmtime() 获取文件最后一次修改时间(返回时间戳)
# getatime() 获取文件最后一次访问时间(返回时间戳)
# exists() 检测指定的路径是否存在
# isabs() 检测一个路径是否是绝对路径 res = os.path.isabs(pathvar)
# abspath() 将相对路径转化为绝对路径 res = os.path.abspath(pathvar)
"""tarfile 压缩模块 后缀为.tar .tar.gz .tar.bz2"""
import tarfile
# 1 创建压缩包
# (1) 创建.tar压缩包
.tar的压缩包,只打包不压缩
# with tarfile.open("ceshi1029.tar","w",encoding="utf-8")as tf:
# (2) 写入文件到压缩包中
# tf.add(路径,文件名) 或 tf.add(路径,文件夹/文件名)
# tf.add("/bin/ntfscmp","ntfscmp")
# tf.add("/bin/grep","tmp/grep")
# 2.创建.tar.gz压缩包
# with tarfile.open("ceshi1030.tar.gz","w:gz",encoding="utf-8")as tf:
# (2) 写入文件到压缩包中
# tf.add("/bin/ntfscmp","ntfscmp")
# tf.add("/bin/grep","tmp/grep")
# 3.创建.tar.bz2压缩包,把上面的.gz换成.bz2
# 2.解压压缩包
# with tarfile.open("ceshi1030.tar.gz","r",encoding="utf-8")as tf:
# extract(文件,路径)
# tf.extract("ntfscmp","ceshi1030")
# extractall(路径)
# tf.extractall("ceshi1030")
# 3.追加文件 支持with语法
# with tarfile.open("ceshi1029.tar","a",encoding="utf-8") as tf :
# tf.add("/bin/gzip","gzip")
"""error tarfile中的追加,只能是对只打包不压缩的包进行追加,其他的模式不可以;"""
# 4.查看压缩包中的内容
# with tarfile.open("ceshi1029.tar","r",encoding="utf-8") as tf :
# lst = tf.getnames()
# print(lst)
if any([A,B,C]): # 表示 if A or B or C:
if all([A,B,C]): # 表示 if A and B and C:
"""sys"""
print(sys.path) # 打印系统环境变量路径
sys.path.append(PATH) # 将路径加入到环境变量, 例如 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
# 这样就可以从加入环境变量中的这个路径作为顶级包开始找包导入了
# assert 断言
assert bool值/bool表达式, ["抛错提示语(字符串)"] # 若bool表达式为False则会抛错, 可附带抛错提示语
# importlib 通过字符串导入模块
import importlib
# from apps.index.urls import index_blue
# app.register_blueprint(index_blue)
app.register_blueprint(importlib.import_module("apps.index.urls").index_blue) # 一行代码替代上面两行
# jupyter的使用(pip install jupyter)
右键打开powershell, 输入jupyter notebook, 有提示
To access the notebook, open this file in a browser:
file:///C:/Users/chen/AppData/Roaming/jupyter/runtime/nbserver-32556-open.html
输入即可
