python自我记忆
文章目录
-
-
- 1.常用基础相关
-
- **单列表推导式**
- 二维列表推导式
- **列表和元组的区别**
- **字典**
- 使用set创建空集
- **zip的迭代遍历**
- **列表推导式**
- **python转码与解码**
- **python检索字符串**
- **字符串分割和合并**
- 字符串展示
- 字符串组成判断
- 字符串压缩
- 正则匹配
- 2.函数相关
-
- 动态添加
- 函数中的标注
- 函数的参数默认值
- 可变长度参数
- 局部变量为全局变量
- 匿名小函数
- 面向对象程序设计（Object Oriented Programming，OOP）
- 类的定义
- 类方法
- 类属性的保护
- 构造与释放
- 继承
- 3.文件操作
-
- 文件打开方式
- 文件对象常用属性
- 文件对象常用方法
-
- 序列化
- 4.文件级操作
-
- os模块常用的文件操作函数
- os.path常用的文件操作函数
- shutil模块
- 目录操作
-
1.常用基础相关
单列表推导式
1.多次执行
[print("执行"+str(i)+"遍") for i in range(10)]
2.生成列表
listA1 = [ i for i in range(10) ]
print(listA1)
listA1[1:3] = 4,6
print(listA1)
二维列表推导式
listA2 = [ [ j for j in range(5) ] for i in range(4) ]
print(listA2)
列表和元组的区别
1.列表为可变序列，例如可以使用del、append()、extend()、insert()、remove()、pop()对列表的元素的操作。元组为不可变序列，而元组只能del
2.列表可以通过切片访问和修改列表元素。而元组只支持访问元组访问，不能修改
3.元组比列表访问和处理速度快
4.列表不能做为字典的键，而元组可以
字典
1.创建的字典的形式1
dic1={
"1":1,"2":"2"}
print(dic1)
字典的修改
dic1.update({
"3":3})
print(dic1)
2.创建的字典的形式2
dictory=dict((("你好","1"),("再见","2")))
print(dictory)
3.字典的推导
list1=[1,2]
list2=[3,4]
dicttest={
i:j for i,j in zip(list1,list2)}
print(dicttest)
使用set创建空集
集合的操作方法是add(),remove(),pop()
set1=set()
set1={
1,2,3,4}
print(set1)
set多用于两个集和的交集、并集、差集运算
查看set的帮助。
help(set)
zip的迭代遍历
for i in zip(list1,list2):
#为元组形式
print(i)
#单个值遍历
for i,j in zip(list1,list2):
print(i,j)
列表推导式
import files as files
#列表推导，获得指定文件夹的文件完整路径
lista=[ os.path.join(root,file) for root, dirs, files in os.walk(r"E:\csv") for file in files if file.endswith(".csv")]
#以上列表推导式等同于以下
# 5 def path_file(r"E:\csv"):
# 6 lista=[]
# 7 for root, dirs, files in os.walk(r"E:\csv"):
# 8 for file in files:
# 9 if os.path.splitext(file)[1] == '.csv':
# 10 lista.append(os.path.join(root, file))
# 11 return lista
print(lista)
#列表数的相加
list1=[1,3,4,5,6]
print([ listnum+1 for listnum in list1 if listnum >2])
python转码与解码
version="窗前明月光"
#########转码
#默认是utf-8的转码二进制数据
utfVar=version.encode("UTF-8")
print(utfVar)
#转GBK转码二进制数据
gbkVar=version.encode("GBK")
print(gbkVar)
#########解码
#使用utf-8解码
deVar=utfVar.decode("UTF-8")
print(deVar)
#使用GBK解码
gbkStr=gbkVar.decode("GBK")
print(gbkStr)
python检索字符串
test='Hello word 世界'
test2="end time"
test3=" YYGood very one \r\n\t"
#%格式化操作 %s字符串，-左对齐，+右对齐。%d数字
test41="天青色等烟雨，而我等你"
test42="论曰昭成空"
test5="编号:%-s %+s" %(test41,test42)
test6="编号:%-40s %+s,%d" %(test41,test42,40)
test71='彩色烟云，空晚霞'
test72="生是人，做浩是"
#>右对齐 <左对齐
test8="实验：{:>30s}"
test9="实验：{:<30s} {:s}"
test10=['1',2]
print(test8.format(test71))
print(test9.format(test72,"xxxx"))
print("{test}".format(test="再见"))
site = {
"name": "哈哈", "url": "com"}
#*做为元组处理 **作为字典处理。以下key对应输出value值
print("网站名：{name}, 地址 {url}".format(**site))
print("{0[1]}".format(test10))
print("统计l的数量:",test.count('l'))
print("查询l的存在索引:",test.find('l'))
print("he开始：",test.startswith("He"))
print('me结尾：',test2.endswith("me"))
print("去除左右的空格和特殊字符:",test3.strip())
print("去除左右的空格和特殊字符\t:",test3.strip(' \t'))
print(test5)
print(test6)
字符串分割和合并
strs="你的名字，闻如雷惊，"
#只分割1次，不分割剩余
print(strs.split('，', 1))
#合并'str'.join(list)
print('，让我'.join(strs.split('，', 1)))
字符串展示
#指定字符显示长度为30。并且居中显示
print("hello word".center(30))
#指定字符显示长度为30。并且居中显示，字符=进行填补
print("hello word".center(30,"="))
#指定字符显示长度为30。并且左对齐显示，字符=进行填补
print("hello word".ljust(30,"="))
#指定字符显示长度为30。并且右对齐显示，字符=进行填补
print("hello word".rjust(30,"="))
字符串组成判断
#判断字母和数字
print('123abc'.isalnum())
#判断字母
print("abc".isalpha())
#判断数字
print('123'.isdigit())
#判断空白
print(' '.isspace())
字符串压缩
#字符串的压缩（compress）和解压(decompress)
#字符串转字节后压缩
strings='''Japan Railway简称，交通网络覆盖面积最大。早期是日本国有铁路公司，后来经过拆分，下设7个子公司负责不同区域及功能的交通路线，堪称日本国民线。
新干线就隶属于日本JR，适合在日本跨城市地区乘坐，相当于国内的高铁，速度最快价格也最贵。
以新宿为例，包括新宿站、东新宿站、西新宿站、新宿三丁目站、新宿御苑前站、西武新宿站等有6个车站之多，从名字上看都是新宿，可是这些站点相隔距离并不算近，一旦搞错，就可能会费时费力，多走不少冤枉路。
'''
print(len(strings.encode()))
#压缩
stringt=zlib.compress(strings.encode())
print(len(stringt))
#解压
print(zlib.decompress(stringt).decode())
正则匹配
#元字符 .除换行外的任意的一个字符 \w 字符、数字、下划线 \W非字符、数字、下划线 \s 任意空白符、制表符、换页符 \S与s相反 \d 数字 \b 单词的开始与结束 ^字符串开始 $字符串结尾 [^ ]排除 \转义符
#限定符 ?零次或1次 + 1次或多次 *零次或多次 {n} 匹配n次 {n,}匹配至少n次 {n,m} 匹配至少n次，至多m次
# ()内容作为一个整体 []匹配任意其中一个字符
#字符类[0-9] [a-z] [A-Z]
#选择字符 (a)指定选择a (A|B) 选择A或者B
#分组（a|b）c 匹配ac或者bc
#习题：'[^a-zA-Z]' 不匹配字母 '\bm\w*\b' 匹配单词m开始，任意字母（重复多次）。 '\\bm\\w*\\b' 转移\\。匹配bmw*b
#r'\bm\w*\b' 保持原生字符。方便定义的时候使用
#经典实例
# 子模式后面加上问号表示可选。
# r'(http://)?(www\.)?python\.org'只能匹配 'http://www.python.org'、'http://python.org'、'www.python.org'和'python.org
# (pattern)*：允许模式重复0次或多次
# (pattern)+：允许模式重复1次或多次
# (pattern){m,n}：允许模式重复m~n次
# '^[a-zA-Z]{1}([a-zA-Z0-9._]){4,19}$'：匹配长度为5-20的字符串，必须以字母 开头、可带数字、“_”、“.”的字串。
# '^(\w){6,20}$'：匹配长度为6-20的字符串，可以包含字母、数字、下划线。
# '^(\-)?\d+(\.\d{1,2})?$'：检查给定字符串是否为最多带有2位小数的正数或负数。
# '\d{4}-\d{1,2}-\d{1,2}'：匹配指定格式的日期，例如2016-1-31。
#使用re模块
text='alpha. beta....gamma delta'
#减少了分割，多次的使用
print(re.split('[\. ]+', text))#匹配值分割
print(re.split('[\. ]+', text,maxsplit=1))
pat='[a-zA-Z]+' #查找所有单词
print(re.findall(pat,text))
pat='{name}'
text='Dear {name}....'
print(re.sub(pat, 'mr', text)) #字符串替换
s='a b c'
print(re.sub('a|s|c|b', "good", s)) #字符串替换
s = "It's a very good good idea"
#匹配一次或者多次的字符串。()作为一个结果。其中，作为返回值给\1 \1的值就是good
#处理连续的重复单词
print(re.sub(r'(\b\w+) \1', r'\1', s))
example = 'Beautiful is better than ugly.'
##以字母b开头的完整单词 #此处问号?表示非贪心模式
print(re.findall('\\bb.+?\\b', example))
##以字母b开头的完整单词 #无?表示贪心模式
print(re.findall('\\bb.+\\b', example))
#所有单词
print(re.findall('\\b\w.+?\\b', example))
#单词的开头和结尾。查找所有字符的，非空格
print(re.findall('\\b[a-zA-Z][^ ]*\\b', example))
print(re.findall('\d+\.\d+\.\d+', 'Python 192.168.101.11 10.10.10.11'))
s = 'This is head.This is body2.'
pattern = r'(.+)(.+)'
print(re.search(pattern, s).groups())
print(re.findall(pattern, s))
strings="OMA who are this OMA are you two"
print(re.match('O\w.+?', strings).group())
print(re.search("OMA.+?", strings).group())
print(re.findall("O\w.+?", strings))#查找O开有的所有单词
pattern=re.compile(r'\bw\w+\b')
#查找以w开头的单词
print(pattern.findall(strings))
#查找以A结尾的单词
pattern=re.compile(r'\w+A\b')
print(pattern.findall(strings))
#指定多个可能的分隔符
example = r'one,two,three.four/five\six?seven[eight]nine|ten'
pattern = re.compile(r'[,./\\?[\]\|]')
print(pattern.split(example))
#子模式与match对象
##使用()表示一个子模式，即()内的内容作为一个整体出现
#例如’(red)+’可以匹配’redred’、’redredred‘等多个 重复’red’的情况。
telNumber = '''Suppose my Phone No. is 0535-1234567, yours is 010-12345678, his is 025-87654321.'''
pattern = re.compile(r'(\d{3,4})-(\d{7,8})') #匹配数字3到4位。数字7到8位的
print(pattern.findall(telNumber))
#自身扩展了解子模式与match对象
2.函数相关
动态添加
#python是动态编程语言。变量类型可随时改变
#函数和自定义对象动态增加新成员
def func():
print(func.x)
func.x=4 #动态成员
func()
del func.x #删除动态成员
#因动态成员已删除，所以以下执行会报错
func().x
函数中的标注
#Python支持对函数参数和返回值类型的标注,Python支持对函数参数和返回值类型的标注
def Test(a:int,b:int) ->int:
c=a+b
return c
print(Test(1, 2))
print(Test(1, 2.3))
函数的参数默认值
#参数值的默认
def returns(a=1,b=2):
c=a+b
return c
print(returns())
print(returns(10,123))
#__defaults__查看所有默认参数的当前值
print(returns.__defaults__)
#关键参数主要指实参，即调用函数时的参数传递方式。以下为关键参数传值方式
##通过关键参数，实参顺序可以和形参顺序不一致，但不影 响传递结果，避免了用户需要牢记位置参数顺序的麻烦。
print(returns(a=12, b=45))
可变长度参数
可变长度参数主要有两种形式：
*parameter用来接受多个实参并将其放在一个元组中
**parameter接受关键参数并存放到字典中
def demoTest(*p):
print(p)
def demoDic(**p):
print(p)
demoTest(1, 2, 3, 'a')
#**p,使用关键参数方式传参
demoDic(a=1,b=3,d=4,e='C')
#传递参数时，可以通过在实参序列前加星号将其解包，然后传递给多个单变量形参
def demoK(a,b,c):
print(a+b+c)
dic={
'1':'s','4':'x','12':'d'}
seq=['das','xx','45']
sets={
1,3,2}
tup=('1','物理','dasfas')
ss="xxa"
#词典、列表、集合、元组、字符串的解包
demoK(*dic.values())
demoK(*seq)
demoK(*sets)
demoK(*tup)
demoK(*ss)
局部变量为全局变量
#return语句用来从一个函数中返回一个值，同时结束函数。
#如果函数没有return语句，或者有return语句但是没有执行 倒，或者只有return而没有返回值，Python将认为该函数 以return None结束
#局部变量声明为全局变量global进行声明
def functionA():
global var1
var1="12"
#需先调用函数。
functionA()
print(var1)
匿名小函数
lambda表达式可以用来声明匿名函数，也就是没有函数名字的临时使用的小函数，尤其适合需要一个函数作为另一个函数参数的场合。
lambda表达式只可以包含一个表达式，该表达式的计算 结果可以看作是函数的返回值
f=lambda x,y,z:x+y+z
print(f(1, 2, 3))
f=lambda x,y,z=3:x+y+z
print(f(1, 2, 4))
print(f(1, 2))
面向对象程序设计（Object Oriented Programming，OOP）
面向对象程序设计的一个关键性观念是将数据以及对数据的操作封装在一起，组成一个相互依存、不可分割的整体，即对象。
对于相同类型的对象进行分类、抽象后，得出共同的特征而形成了类，面向对象程序设计的关键就是如何合理地定义和组织这些类以及类之间的关系。
Python支持面向对象的基本功能，如封装、继承、多态 以及对基类方法的覆盖或重写
创建类时用变量形式表示的对象属性称为数据成员，用函数形式表示 的对象行为称为成员方法，成员属性和成员方法统称为类的成员
类的定义
#类名的首字母一般要大写
class Car:
Cname="彭科"
def rprint(self):
print("my name is car")
def rpass(self):
#关键字来“占位”，“什么也不做”
pass
#实例化对象，并通过“对象名. 成员”的方式来访问其中的数据成员或成员方法。
car=Car()
print(car.Cname)
car.rprint()
#方法isinstance()来测试一个对 象是否为某个类的实例
print(isinstance(car, Car))
类的所有实例方法都必须至少有一个名为self的参数，并且必须是方法的第一个形参（如果有多个形参的话）， self参数代表将来要创建的对象本身。
class Car:
Cname = "彭科"
# ###rprint为实例方法
self做第一个形式参数
def rprint(self):
print("my name is car")
car=Car() #实例化
##car代表创建的对象，即是self
#self”只是一个习惯，
#而实际上类的实例方法中第一个参 数的名字是可以变化的，而不必须使用“self”这个名字, 尽管如此，建议编写代码时仍以self作为方法的第一个参数名字。
class Kar:
def rprint(a1):
print("my name is kar")
kar=Kar()
kar.rprint()
属于实例的数据成员一般是指在构造函数__init__()中定义 的，定义和使用时必须以self作为前缀；属于类的数据成 员是在类中所有方法之外定义的。
在主程序中（或类的外部），实例属性属于实例(对象)， 只能通过对象名访问；而类属性属于类，可以通过类名或 对象名访问
class Waring:
#类数据成员cname。与类中的方法都是类属性
cName="xxx"
def __init__(self,age,addres):
# age address为属于实例的实例数据成员(实例属性)
self.ages=age
self.address=addres
waring=Waring(12,"虎豹")
#属于实例的数据成员，通过实例获得。此步骤为定义实例化属性
print(waring.ages,waring.address)
#访问类的属性，并修改
print(Waring.cName)
Waring.cName="赵薇"
print(Waring.cName)
#访问实例的属性，并修改
print(waring.ages)
waring.ages=123
print(waring.ages)
Waring.psthor="网元" #动态增加类属属性
print(Waring.psthor)
waring.ssp="实例属性" #动态增实例属性
print(waring.ssp)
动态增加成员方法 基本不常用。主要参考
import types
def setCar(self,s):
self.spped=s
waring.setSpeed =types.MethodType(setCar,waring) #动态增加成员方法,（称为方法）
waring.setSpeed(50)
print(waring.spped)
def getCar(self,s):
self.getspe=s
waring.getCar=getCar #称为普通的函数
print(waring.getCar)
#动态为自定义类及其对 象增加新的属性和行为，俗称混入（mixin）机制
#方法一般指与特定 实例绑定的函数
##例如以上：
# waring.setSpeed =types.MethodType(setCar,waring) #动态增加成员方法
# waring.setSpeed(50) #setSpeed就是方法
# 而相当于
# waring.getCar=getCar #称为普通的函数
# print(waring.getCar)
成员名以两个下划线“__”开头则表示是私有成员，类的外部不能直接访问
class One1:
def __init__(self,age=12,profile=78):
self.age=age
self.__profile=profile
def setValue(self,age,profile):
self.age = age
self.__profile = profile
def show(self):
print(self.age)
print(self.__profile)
# 1.公有成员方法来访问
one=One1()
one.show()
# 2.Python支持的特殊方式来访问
print(one._One1__profile)
类方法
公有方法、私有 方法、静态方法和类方法
私有方法的名字以两个下划线“__”开始
class ClassCeshi:
#以下为构造方法
__total=0
def __init__(self,v):
self.__value=v
ClassCeshi.__total+=1
def __ceshi(self):
return "私有方法"
def ceshi2(self):
return "实例方法"
#静态方法和类方法都可以通过类名和对象名调用，但不能直接访问属于对象 的成员，只能访问属于类的成员。
@classmethod #修饰器，声明类方法
def classShow(cls):
print(cls.__total)
@staticmethod #修饰器，声明静态方法
def classStatic():
print(ClassCeshi.__total)
##访问静态方法和类方法
r=ClassCeshi(3)
r.classShow()
r.classStatic()
ClassCeshi.classShow()
ClassCeshi.classStatic()
类属性的保护
Python 3.x中，属性得到了较为完整的实现，支持更加 全面的保护机制,也可以将属性设置为可读、可修改、可删除。
class Test:
def __init__(self, value):
self.__value = value
def __get(self):
return self.__value
def __set(self, v):
self.__value = v
def __del(self):
del self.__value
value = property(__get, __set, __del)
def show(self):
print(self.__value)
#可读
test=Test(3)
print(test.value)
#可改写
test.value=10
print(test.value)
#可删除
del test.value
print(test.value)
#AttributeError: 'Test' object has no attribute '_Test__value'
#翻译：AttributeError:“Test”对象没有属性“\u Test\u value”
test.value=11
test.show()
构造与释放
Python中类的构造函数是__init__()，一般用来为数据成员设置初值或进行其 他必要的初始化工作，在创建对象时被自动调用和执行。
Python中类的析构函数是__del__()，一般用来释放对象占用的资源，在 Python删除对象和收回对象空间时被自动调用和执行。
class TestOne:
def __init__(self):
return "构造方法"
def __del__(self):
return "释放方法"
继承
继承是为代码复用和设计复用而设计的。已有的、设计好的类称为父类或基类,新设计的类称 为子类或派生类。派生类可以继承父类的公有成员，
但是不能继承其 私有成员。如果需要在派生类中调用基类的方法，
可以使用内置函数 super()或者通过“基类名.方法名()”的方式来实现这一目的。
class dayCeshiA(object):
def __init__(self):
#声明私有方法
self.__private()
#声明公有方法
self.public()
def __private(self):
print('__private 私有方法的A')
def public(self):
print('public 共有方法的A')
#子类继承，并重写
class dayCeshiB(dayCeshiA):
def __private(self):
print("__private 私有方法的B")
def public(self):
print('public 共有方法的B')
b=dayCeshiB()
print(b)
#返回参数的属性、方法列表。
print(dir(b))
# 结果：__private 私有方法的A
# public 共有方法的B
class dayCeshiC(dayCeshiA):
def __init__(self): # 显式定义构造函数
self.__private()
self.public()
def __private(self):
print("__private 私有方法的C")
def public(self):
print('public 共有方法的C')
c=dayCeshiC()
print(c)
# 结果：__private 私有方法的C
# public 共有方法的C
class Animal(object):
#定义基类
def show(self):
print('I am an animal.')
def prints(self):
print("特殊对待")
class Cat(Animal):
#派生类，覆盖了基类的show()方法
def __init__(self):
#继承。除了覆盖的，其他保持不变
super().__init__()
def show(self):
print('I am a cat.')
class Dog(Animal):
#派生类
def show(self):
print('I am a dog.')
cat=Cat()
cat.show()
cat.prints()
3.文件操作
文本文件：文本文件存储的是常规字符串，由若干文本行组成，通常每行以 换行符’\n’结尾。
如英文字母、汉字、数字字符串。 文本文件可以使用字处理软件如gedit、记事本进行编辑。
二进制文件：二进制文件把对象内容以字节串(bytes)进行存储，
常见的如图形图 像文件、音视频文件、可执行文件、资源文件、各种数据库文件、各类office 文档等都属于二进制文件
# open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
#1 file文件名指定了被打开的文件名称。
#2 mode打开模式指定了打开文件后的处理方式。
#3 buffering缓冲区指定了读写文件的缓存模式。表示不缓存，1表示缓存，如大于1则表 示缓冲区的大小。默认值是缓存模式。
#4 encoding参数encoding指定对文本进行编码和解码的方式，只适用于文本模式，可以使 用Python支持的任何格式，如GBK、utf8、CP936等等。
#5 errors报错级别
#6 newline区分换行符
#7 closefd传入的file参数类型
#8 opener和closefd联合使用，都是对基础文件描述符的操作
# open( )函数返回1个文件对象，该对象可以对文件进行各种操作。
#查看帮助
# help(open)
#open()函数返回1个可迭代的文件对象， 通过该文件对象可以对文件进行读写操作
#创建f1读（read）对象
f1=open('file.txt','r')
#正常的关闭
f1.close()
#创建f2写（write）对象
f2=open('file.txt','w')
#正常的关闭
f2.close()
管理文件对象时推荐with关键字，在打开文件之后和关闭 文件之前发生了错误导致程序崩溃，这时文件就可以正常关闭。
#使用with做读。
with open('file.txt','r') as f:
f.close()
#联合使用。读file一文件，写fileTest一文件
with open('file.txt','r') as src,open('fileTest.txt','a') as des:
des.write(src.read())
文件打开方式
| 模式 | 说明 |
|---|---|
| 模式 | 说明 |
| r | 读模式（默认模式，可省略），如果文件不存在则抛出异常 |
| w | 写模式，如果文件已存在，先清空原有内容 |
| x | 写模式，创建新文件，如果文件已存在则抛出异常 |
| a | 追加模式，不覆盖文件中原有内容 |
| b | 二进制模式（可与其他模式组合使用） |
| t | 文本模式（默认模式，可省略） |
| + | 读、写模式（可与其他模式组合使用） |
文件对象常用属性
| 属性 | 说明 |
|---|---|
| buffer | 返回当前文件的缓冲区对象 |
| closed | 判断文件是否关闭，若文件已关闭则返回True |
| fileno | 文件号，一般不需要太关心这个数字 |
| mode | 返回文件的打开模式 name 返回文件的名称 |
文件对象常用方法
| 方法 | 功能说明 |
|---|---|
| close() | 把缓冲区的内容写入文件，同时关闭文件，并释放文件对象 |
| detach() | 分离并返回底层的缓冲，底层缓冲被分离后，文件对象不再可用，不允许做任何操作 |
| flush() | 把缓冲区的内容写入文件，但不关闭文件 |
| read([size]) | 从文本文件中读取size个或字符（Python 3.x）的内容作为结果返回，或从二进制文 件中读取指定数量的字节并返回，如果省略size则表示读取所有内容 |
| readable() | 测试当前文件是否可读 |
| readline() | 从文本文件中读取一行内容作为结果返回 |
| readlines() | 把文本文件中的每行文本作为一个字符串存入列表中，返回该列表，对于大文件会占 用较多内存，不建议使用 |
| seek(offset[, whence]) | 把文件指针移动到新的位置，offset表示相对于whence的位置。whence为0表示从文件 头开始计算，1表示从当前位置开始计算，2表示从文件尾开始计算，默认为0 |
| seekable() | 测试当前文件是否支持随机访问，如果文件不支持随机访问，则调用方法seek()、 tell()和truncate()时会抛出异常 |
| tell() | 返回文件指针的当前位置 |
| truncate([size]) | 删除从当前指针位置到文件末尾的内容。如果指定了size，则不论指针在什么位置都 只留下前size个字节，其余的一律删除 |
| write(s) | 把字符串s的内容写入文件 |
| writable() | 测试当前文件是否可写 |
| writelines(s) | 把字符串列表写入文本文件，不添加换行符 |
#查看文件的编码格式
with open('file.txt','rb') as f:
print(chardet.detect(f.read()))
#解码的方式。encoding指定解码
with open('file.txt','r',encoding="GBK") as f:
print(f.read())
#读取前5字符
print(f.read(5))
#指针跳过前13的字符
print(f.seek(13))
#读取从第14字符开始
print(f.read(1))
序列化
数据库文件、图像文件、可执行文件、音视频文件、Office文档等等 均属于二进制文件
所谓序列化，简单地说就是把内存中的数据在不丢失其类型信息的情况下转成对象的二进制形式的过程，对象序列化后的形式经过正确的
反序列化过程应该能够准确无误地恢复为原来的对象。序列的使用，一般在服务做传输的时候使用
#Python中常用的序列化模块有struct、pickle、marshal和shelve
import pickle
i = 13000000
a = 99.056
s = '中国人民123abc'
lst = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
tu = (-5, 10, 8)
coll = {
4, 5, 6}
dic = {
'a':'apple', 'b':'banana', 'g':'grape', 'o':'orange'}
data = [i, a, s, lst, tu, coll, dic]
with open("sample_pickle.dat",'wb') as f:
try:
pickle.dump(len(data),f) ##表示后面将要写入的数据个数
for item in data:
pickle.dump(item,f)
except:
print("写文件异常")
with open('sample_pickle.dat', 'rb') as f:
n = pickle.load(f) #读出文件的数据个数
for i in range(n):
x = pickle.load(f)
print(x)
4.文件级操作
os模块常用的文件操作函数
| 方法 | 功能说明 |
|---|---|
| access(path, mode) | 测试是否可以按照mode指定的权限访问文件 |
| chdir(path) | 把path设为当前工作目录 |
| chmod(path, mode, *, dir_fd=None, follow_symlinks=True) | 改变文件的访问权限 |
| curdir | 当前文件夹 |
| environ | 包含系统环境变量和值的字典 |
| extsep | 当前操作系统所使用的文件扩展名分隔符 |
| get_exec_path() | 返回可执行文件的搜索路径 |
| getcwd() | 返回当前工作目录 |
| listdir(path) | 返回path目录下的文件和目录列表 |
| mkdir(path[, mode=0777]) | 创建目录，要求上级目录必须存在 |
| makedirs(path1/path2…, mode=511) | 创建多级目录，会根据需要自动创建中间缺 失的目录 |
| open(path, flags, mode=0o777, *, dir_fd=None) | 按照mode指定的权限打开文件，默认权限为可读、可写、 可执行 |
| popen(cmd, mode=‘r’, buffering=-1) | 创建进程，启动外部程序 rmdir(path) 删除目录，目录中不能有文件或子文件夹 |
| remove(path) | 删除指定的文件，要求用户拥有删除文件的权限，并且 文件没有只读或其他特殊属性 |
| removedirs(path1/path2…) | 删除多级目录，目录中不能有文件 |
| rename(src, dst) | 重命名文件或目录，可以实现文件的移动，若目标文件 已存在则抛出异常，不能跨越磁盘或分区 |
| replace(old, new) | 重命名文件或目录，若目标文件已存在则直接覆盖，不 能跨越磁盘或分区 |
| scandir(path=’.’) | 返回包含指定文件夹中所有DirEntry对象的迭代对象， 遍历文件夹时比listdir()更加高效 |
| sep | 当前操作系统所使用的路径分隔符 |
| startfile(filepath [, operation]) | 使用关联的应用程序打开指定文件或启动指定应用程序 |
| stat(path) | 返回文件的所有属性 |
| system() | 启动外部程序 |
| truncate(path, length) | 将文件截断，只保留指定长度的内容 |
| walk(top, topdown=True, οnerrοr=None) | 遍历目录树，该方法返回一个元组，包括3个元素：所有 路径名、所有目录列表与文件列表 |
| write(fd, data) | 将bytes对象data写入文件fd |
os.path常用的文件操作函数
| 方法 | 功能说明 |
|---|---|
| abspath(path) | 返回给定路径的绝对路径 |
| basename(path) | 返回指定路径的最后一个组成部分 |
| commonpath(paths) | 返回给定的多个路径的最长公共路径 commonprefix(paths) |
| dirname( p ) | 返回给定路径的文件夹部分 |
| exists(path) | 判断文件是否存在 |
| getatime(filename) | 返回文件的最后访问时间 |
| getctime(filename) | 返回文件的创建时间 |
| getmtime(filename) | 返回文件的最后修改时间 |
| getsize(filename) | 返回文件的大小 |
| isabs(path) | 判断path是否为绝对路径 |
| isdir(path) | 判断path是否为文件夹 |
| isfile(path) | 判断path是否为文件 |
| join(path, *paths) | 连接两个或多个 |
| path realpath(path) | 返回给定路径的绝对路径 |
| relpath(path) | 返回给定路径的相对路径，不能跨越磁盘驱动器或分区 |
| samefile(f1, f2) | 测试f1和f2这两个路径是否引用的同一个文件 split(path) 以路径中的最后一个斜线为分隔符把路径分隔成两部分，以列表形式返回 |
| splitext(path) | 从路径中分隔文件的扩展名 |
| splitdrive(path) | 从路径中分隔驱动器的名称 |
#文件级操作
print(os.path.exists("path.txt")) #判断文件是否存在
#修改文件名称
#os.rename(r'E:\untitled\ConpyFile\sample_pickle.dat',r'E:\untitled\ConpyFile\sample_pickle1.dat')
path=r"E:\untitled\ConpyFile\sample_pickle1.dat"
#返回文件的目录
print(os.path.dirname(path))
#分割为目录或文件(返回值元组)
print(os.path.split(path))
#分割为盘符与文件路径(返回值元组)
print(os.path.splitdrive(path))
#分割为路径、文件和尾缀
print(os.path.splitext(path))
for fname in os.listdir(r'E:\untitled\ConpyFile'):
if fname.endswith('.py'):
print(os.path.abspath(fname))
#推导式如下
print([os.path.abspath(fname) for fname in os.listdir(r'E:\untitled\ConpyFile') if fname.endswith('.py')])
print("使用walk如下")
for root,dirs,files in os.walk(r'E:\untitled\ConpyFile'):
for file in files:
if os.path.splitext(file)[1] == '.py':
print(os.path.join(root,file))
shutil模块
import shutil
#copyfile()方法复制文件
shutil.copyfile(r"F:\iso\txtFile.txt",r"F:\iso\txtFile2.txt")
#将F:\\iso\zips 文件夹以及该文件夹中所有文件压缩 至F:\iso.zip文件
shutil.make_archive(r'F:\iso','zip',r'F:\iso','zips')
#将刚压缩得到的文件解压缩至F:\iso
shutil.unpack_archive(r'F:\iso.zip',r'F:\iso')
#删除刚刚解压缩得到的文件夹
shutil.rmtree(r"F:\iso")
目录操作
os模块常用的目录操作函数
| 函数名称 | 使用说明 |
|---|---|
| mkdir(path[,mode=0777]) | 创建目录 |
| makedirs(path1/path2…,mode=511) | 创建多级目录 |
| rmdir(path) | 删除目录 |
| removedirs(path1/path2…) | 删除多级目录 |
| listdir(path) | 返回指定目录下所有文件信息 |
| getcwd() | 返回当前工作目录 |
| chdir(path) | 把path设为当前工作目录 |
| walk(top,topdown=True,onrror=None) | 遍历目录树 |