文章目录
pycharm常用快捷键
- 移动到本行开头:home键
- 移动到本行末尾:end键盘
- 注释代码:Ctrl+/
- 复制一行代码Ctrl+D
- 删除一行代码Shift+Delete
- 选择列:Shift+alt+鼠标左键
- 移动行:Shift+alt+上下箭头
- 代码格式化:Ctrl+Alt+L(复制别人代码常用)
- 统一改变量名:Shift+F6
- Ctrl + P 参数信息(在方法中调用参数)
- Ctrl + Q 快速查看文档
- Ctrl + Alt + M 提取方法
- Ctrl + O方法重写
- Ctrl+Shift+ -收齐全部代码
- Ctrl+Shift+ +展开全部代码
- property读写:props + 回车
- property只读:prop + 回车
- for快捷键:iter + 回车
- enumerate枚举快捷键:itere + 回车
del语句
#语法
del 变量1,变量2
#作用:用于删除变量,同时解除与对象的关联,如果可能则释放对象
自动化内存管理的引用计数:每个对象记录被变量绑定(引用)的数量,当为0时被销毁。
强制类型转换—注意
字符串转换为其他类型时,必须是目标类型的字符串表达形式。
运算符
/ 除法
// 整除
% 取余(取模)
** 幂运算(次方运算)
If elif else语句
#语法
if 条件1:
语句块1
elif 条件2:
语句块2
else:
语句块3
#真值判断:布尔值为false的有0(int),0.0(float),"(str)
三元表达:if放中间 满足放前面 不满足放后面
值交换:a,b=b,a
生成随机数(随机int数)
import random
a = random.randint(1,100)
列表list
index(),返回指定数据所在位置的索引。
count(),统计数据在列表中出现的次数。
len(),索引长度
in,not in
append(),追加一个数据。(可以结合+=追加多个)
insert(下标位置,数据),根据索引插入数据
del 删除,del list[下标]。
remove(数据),移除列表内指定数据。
sort(),排序。
reverse(),逆置
注意:reverse表示排序规则,reverse=True降序,reverse=False升序(默认)
函数(方法)
语法:
def 函数名(形式参数):
函数体
返回值
语法:return 数据
#调用者,可以接收也可以不接收返回值
函数参数解释
def fun01 (p1,p2,p3)#位置形参
fun01(1,2,3)#位置实参
fun02(p1=1,p2=2,p3=3)#默认实参
def fun02(p1=1,p2=2,p3=3)#默认形参
def fun03(*args):#星号元组形参
print(args)#(1,2,3,4,5)
a=[1,2,3,4,5]
fun03(*a)#星号实参
def fun04(**kwargs):#双星号字典形参
print(kwargs)
fun04(a=1,b=2,c=3)#{a=1,b=2,c=3}
global全局作用域:模块(.py文件)内部
a=1
def set():
global a#在函数内把全局变量a直接拿来了
a = 2#修改了全局变量
pyint(a)#a=2
面向对象
定义类
class 类名:
def init(self,参数列表):
self.实例变量=参数
class Whaser():
#初始化作用,每创建一个新的对象就初始化一次,默认被调用。
def __init__(self,name):
self.name = name
def wash(self):
print(f'{self.name}在洗衣服')
s = Whaser('s')
s.wash()#s洗衣服
v = Whaser('v')
v.wash()#v洗衣服
实例变量(成员变量)
class Wife():
def __init__(self,name):
self.name = name #成员变量
w01 = Wife('丽丽')
print(w01.__dict__)#__dict__以字典的形式遍历成员变量
类成员
类变量
定义:在类中,方法外定义。
class 类名():
变量名 = 值
类名.变量名#调用
类方法
用处:控制类变量使用的
语法:@classmethod
@classmethod
def 方法名称(cls,参数列表):
方法体
调用:类名.方法名(参数列表)
===================================================
class A():
a = 1
@classmethod
def aa(cls):
cls.a+=2
print(cls.a)
A().aa()#3
面向对象变量使用建议:类变量要用类名点,成员变量要用对象点。类变量要用类方法操作。
私有成员(私有变量)
语法:以双下划线开头命名
作用:类外不能使用
类外强行使用私有变量:_(单下划线)+类名+私有变量
属性property
作用:保障数据在有效范围内
原理:创建类变量,关联属性对象,覆盖成员变量
属性对象需要读取和写入函数(get,set)
核心思想:拦截
class Whifu():
def __init__(self, name='', age=0):
self.name = name#第2步
self.age = age#第3步,相当于执行了self.age(23)
@property
def age(self):
return self.__age
@age.setter
def age(self,v):#第4步执行了这个方法
if 30>v>18:
self.__age = v#把30传给了私有变量
else:
raise Exception('错误')
whifu = Whifu('双',23)#第1步
print(whifu.name)#第5步拉取了成员变量name并打印
print(whifu.age)#第6步相当于执行了whifu.age(),打印了私有变量__age
属性的各种写法,读写,只读,只写
#1读写
class Enemy():
def __init__(self, a=''):
self.a = a
@property
def a(self):
return __a
@a.setter
def a(self,value):
self.__a = value
#只读
class Enemy():
def __init__(self): #不传值
self.__a = 值 #成员变量改为以双下划线开头,并赋值
@property
def a(self):
return __a
#只写(基本不用)
class Enemy():
def __init__(self, a=''):
self.a = a
a = property()
@a.setter
def a(self,value):
self.__a = value
继承
内置函数
# 内置函数
# isinstance(对象, 类型)
# 返回指定对象是否是某个类的对象。
# issubclass(类型,类型)
# 返回指定类型是否属于某个类型。
class A():
pass
class B(A):
pass
class C(A):
pass
a = A()
b = B()
# 1. 对象 与 类型的关系判定
print(isinstance(b,B))#True
print(isinstance(b,A))#True
print(isinstance(b,C))#false
print(isinstance(a,C))#false
##################################
# 2. 类型 与 类型的关系判定
print(issubclass(B,B))#True
print(issubclass(B,A))#True
print(issubclass(B,C))#false
print(issubclass(A,C))#false
##################################
# 3. 对象的类型 与 类型的关系判定
print(type(b) == B)# True
print(type(b) == A)#False
print(type(b) == C)#False
print(type(b) == C)# False
继承使用
继承数据
#继承 - 数据
class A():
def __init__(self, a='ss', b=''):
self.pp = a
self.sd = b
class B(A):
# 子类构造函数参数:父类 + 子类
def __init__(self, a='ss', b='', c=''):
# 如果子类有构造函数,覆盖父类构造函数.
# 内部一定通过super()调用父类构造函数
super().__init__(a, b)
self.dc = c
b = B('1', '2', '3')
super()调⽤⽗类⽅法
多继承
广度优先
下图如果B继承了A,必须这样写classC(B,A)
类.MRO() 打印出的继承的顺序类自身 --> 父类继承列表(由左至右)–> 再上层父类
class E(C, D):
def func01(self):
# 如果指定某个父类的同名方法
# 需要使用类名.实例方法名(self)
D.func01(self)
__str__函数
:将对象转换为字符串,打印对象时直接调用__str__函数
魔法方法——算数运算
#魔法方法的使用。以add为例
class A():
def __init__(self, x, y):
self.x = x
self.y = y
def __str__(self):
return f"{self.x},{self.y}"
def __add__(self, other):
if type(other) == A:
x = self.x + other.x
y = self.y + other.y
else:
x = self.x + other
y = self.y + other
return A(x,y)
b = A(1,2)+1#自动调用 __add__
c = A(1,2)+A(3,4)#自动调用 __add__
print(b) #(2,3) 调用的是str方法
print(c)#(4,6)
魔法方法——复合运算
class A():
def __init__(self, x, y):
self.x = x
self.y = y
def __str__(self):
return f"{self.x},{self.y}"
def __iadd__(self, other):
self.x += other.x
self.y += other.y
return self
b = A(1,2)
b+=b#自动调用 __iadd__
print(b) #(2,4) 调用的是str方法
魔法方法——比较运算
class A():
def __init__(self, x):
self.x = x
def __eq__(self, other): #下面图片使用方法和这个一样,只是函数名不一样
return self.x == other.x #定义方法体
#如果是小于就写self.x**2 < other.x**2
a = A(1)
b = A(1)
print(a == b) #True 调用的是eq方法
静态⽅法
静态⽅法特点
需要通过装饰器 @staticmethod 来进⾏修饰,静态⽅法既不需要传递类对象也不需要传递实例对象 (形参没有self/cls)。
静态⽅法 也能够通过 实例对象 和 类对象 去访问。
静态⽅法使⽤场景
当⽅法中 既不需要使⽤实例对象(如实例对象,实例属性),也不需要使⽤类对象 (如类属性、类⽅法、创建实例等)时,定义静态⽅法
取消不需要的参数传递,有利于减少不必要的内存占⽤和性能消耗
模块
模块分类:
1. 系统自带的模块 os sys time random abc
2. 第三方模块 pymysql(连接数据库) paramiko(连接linux) openpyxl(操作excel)
3. 自定义的模块
命名:包的命名,模块的命名
1. 遵守标识符命名规则
2. 不准命名成系统自带的模块名
import 模块名
from 模块名 import 功能名
from 模块名 import * (代表导入所有的)
import 模块名 as 别名
from 模块名 import 功能名 as 别名
标蓝(设置项目根目录)
文件夹右键 - Mark Directory - Sources Root
all
如果⼀个模块⽂件中有 all 变量,当使⽤ from xxx import * 导⼊时,只能导⼊这个列表中的元素。
my_module1模块代码
导⼊模块的⽂件代码
在终端中写代码帮助
import random
# 1.__doc__ 存储当前模块的文档注释
# 在交互式python中使用
print(random.__doc__)#random的解释
导入顺序
# 主模块:第一次运行的模块
# 根目录:主模块所在文件夹
# 导入成功的唯一标准:
# 导入路径 + 系统路径 = 真实路径
# 列表
# 第一个元素是根目录
import sys
print(sys.path)
时间戳
import time
# 人类时间:公元元年~2021年1月19日 16:34:05
# 机器时间:1970年元旦~1611045288.4559357
# 1.获取当前机器时间 - 时间戳(单位是秒)
time.time() # 1611045288.4559357
# 2.获取当前人类时间 - 时间元组(年/月/日/时/分/秒/星期/一年第一几天/是否夏令时)
time_tuple = time.localtime()
# 3. 时间戳 -> 时间元组
# 时间元组 = time.localtime(时间戳)
time.localtime(1611045288.4559357)
# 4. 时间元组 -> 时间戳
time.mktime(time_tuple)
# 5. 时间元组 -> 字符串
time.strftime("%y-%m-%d %H:%M:%S",time_tuple)#这里time_tuple是第2个知识的变量
# 2021-01-19 16:56:08
time.strftime("%Y-%m-%d %H:%M:%S",time_tuple)
# 6. 字符串 -> 时间元组
time.strptime("2021-01-19 16:56:08", "%Y-%m-%d %H:%M:%S")
utc时区(国际时间)
utc时区与本地时区差8个小时
休眠时间
异常(有Traceback)
常见异常类型:
– 名称异常(NameError):变量未定义。
– 类型异常(TypeError):不同类型数据进行运算。
– 索引异常(IndexError):超出索引范围。
– 属性异常(AttributeError):对象没有对应名称的属性。
– 键异常(KeyError):没有对应名称的键。
–值异常(ValueError):不是对应的值。
– 异常基类Exception。
语法:
try:
可能触发异常的语句
except 错误类型1 [as 变量1]:
处理语句1
except 错误类型2:
处理语句2
except Exception:
不是以上错误类型才执行,或者是单独使用发生异常了执行
else:
没有异常执行
finally:
无论是否发生异常都执行
捕获指定异常
捕获所有异常
Exception是所有程序异常类的⽗类。
raise人为创造异常
def hp(a):
if a <10:
pass
else:
# 扔出 异常对象
raise Exception("错误原因,这里是元组,可以有多个",1001,'错误编号')
# 接收异常
try:
hp(11)
except Exception as e:
print(e.args)#也可以自己设置东西
#打印结果是raise扔过来的('错误原因,这里是元组,可以有多个', 1001, '错误编号')
迭代>>>>>>生成器
每一次对过程的重复称为一次“迭代”,而每一次迭代得到的结果会作为下一次迭代的初始值。例如:循环获取容器中的元素。
"""
迭代 iteration:重复获取下一个元素的过程
可迭代 iterable:可以被迭代,能够参与for循环
迭代器 iterator:完成迭代过程的对象
"""
a = [1, 2, 3, 4, 5]
# 迭代(for循环原理)
# 1. 获取迭代器对象
b = a.__iter__()
while True:
try:
# 2. 获取下一个元素
c = b.__next__()
print(c)
# 3. 如果停止迭代异常,结束循环
except StopIteration:
break
############# ############# ############# ############# #############
#下面是上面的原理
class B():
def __init__(self, __list_b):
self.__list_b = __list_b
self.b = -1
def __next__(self):
self.b += 1
if self.b == len(self.__list_b):
raise StopIteration()
return self.__list_b[self.b]
class A():
def __init__(self):
self.__list_a = []
def add(self, param):
self.__list_a.append(param)
def __iter__(self):
return B(self.__list_a)
a = A()
a.add(1)
a.add(2)
a.add(3)
a.add(4)
a.add(5)
b = a.__iter__()
while True:
try:
c = b.__next__()
print(c)
except StopIteration:
break
############# ############# ############# ############# #############
#下面是简写方式,不写迭代器,直接生成
class A():
def __init__(self):
self.__list_a = []
def add(self, param):
self.__list_a.append(param)
def __iter__(self):
# return B(self.__list_a)
a = 0
yield self.__list_a[a]
a +=1
yield self.__list_a[a]
a += 1
yield self.__list_a[a]
a += 1
yield self.__list_a[a]
a += 1
yield self.__list_a[a]
a = A()
a.add(1)
a.add(2)
a.add(3)
a.add(4)
a.add(5)
b = a.__iter__()
while True:
try:
c = b.__next__()
print(c)
except StopIteration:
break
############# ############# ############# ############# #############
#用迭代器思想写(这个才是重点)
def aaa(list_a):
a = 0
while a<len(list_a):
yield list_a[a]
a += 1
b = [1,2,3,4]
d = aaa(b)
while True:
try:
c = d.__next__()
print(c)
except StopIteration:
break
生成器函数
定义:含有yield语句的函数,返回值为生成器对象。
语法
1 创建:
def 函数名():
…
yield
数据
…
2调用:
for 变量名 in 函数名():
语句
举个例子解释
在列表中找出所有偶数
def aaa(list_a):
for i in list_a:
if i%2==0:
yield i
a = [43,43,54,56,76,98,87]
b = aaa(a)
for i in b:
print(i)
内置生成器enumerate(枚举)
enumerate 根据元素生成对应的索引
可以通过元素判断数据
索引修改数据
又几乎不占用内存
语法:
快捷键:itere + 回车
for 变量 in enumerate(可迭代对象):
语句
for 索引, 元素in enumerate(可迭代对象):
语句
# 练习:将列表中所有偶数自增1
b = [2,32,5,46,5,24,7]
for i,j in enumerate(b):
if j%2==0:
b[i]+=1
print(b)
zip
语法:
for item in zip(可迭代对象1, 可迭代对象2….):
语句
# 练习:使用列表封装以下三个列表中数据
name = ["悟空", "八戒", "白骨精"]
age = [28, 25, 36]
sex = ["男", "男", "女"]
a = []
for i in zip(name,age,sex):
a.append(i)
print(a)
#[('悟空', 28, '男'), ('八戒', 25, '男'), ('白骨精', 36, '女')]
##################################################################
map = [
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
[13, 14, 15, 16],
]
# 矩阵转置
new_map = []
for item in zip(*map):#可以用*接收
new_map.append(list(item))
print(new_map)
#[[1, 5, 9, 13], [2, 6, 10, 14], [3, 7, 11, 15], [4, 8, 12, 16]]
生成器表达式
定义:用推导式形式创建生成器对象。
语法:变量 = ( 表达式 for 变量 in 可迭代对象 [if 真值表达式] )
生成器表达式
将列表推导式的[]替换为()即可
生成器表达式优点:
节省内存
生成器表达式缺点:
只能使用一次
读取数据不灵活(不支持索引切片)
列表推导式优点:
可以反复使用
操作数据灵活
列表推导式缺点:
比较占内存
lambda 表达式
定义:是一种匿名方法。
作用:作为参数传递时语法简洁,优雅,代码可读性强。
随时创建和销毁,减少程序耦合度。
语法
变量 = lambda 形参: 方法体
–
调用:变量(实参)
def,小括号,return 都不写
"""
lambda 表达式
匿名函数
匿名函数支持的功能,有名函数都支持.
但是匿名函数只能有一句话,且不能是赋值语句。
"""
# 写法1:有参数有返回值
# def func01(p1,p2):
# return p1 > p2
func01 = lambda p1, p2: p1 > p2
print(func01(10, 20))
######################################################################
# 写法2:无参数有返回值
# def func02():
# return 100
func02 = lambda: 100
print(func02())
######################################################################
# 写法3:有参数无返回值
# def func03(p1):
# print("参数是:",p1)
func03 = lambda p1: print("参数是:", p1)
func03(10)
######################################################################
# 写法4:无参数无返回值
# def func04():
# print("func04")
func04 = lambda: print("func04")
func04()
######################################################################
# 注意1:lambda 不支持赋值语句
def func05(p1):
p1[0] = 2
# func05 = lambda p1:p1[0] = 2
list01 = [1]
func05(list01)
print(list01) # [2]
######################################################################
# 注意2:lambad 函数体只能有一句话
def func06():
for item in range(3):
print(item)
# func06 = lambda :for item in range(3):print(item)
func06()
############################################################
内置高阶函数
class Employee:
def __init__(self, eid, did, name, money):
self.eid = eid # 员工编号
self.did = did # 部门编号
self.name = name
self.money = money
# 员工列表
list_employees = [
Employee(1001, 9002, "师父", 60000),
Employee(1002, 9001, "孙悟空2", 50000),
Employee(1003, 9002, "猪八戒", 20000),
Employee(1002, 9001, "孙悟空", 50000),
Employee(1004, 9001, "沙僧", 30000),
Employee(1005, 9001, "小白龙", 15000),
]
map 映射:
# map 映射:
# select
for name in map(lambda item:item.name,list_employees):
print(name)
filter 过滤器:
# filter 过滤器:
# find_all
for emp in filter(lambda item:item.money > 20000,list_employees):
print(emp.__dict__)
max 最大值 min 最小值
# max 最大值 min 最小值
# get_max
emp = max(list_employees,key = lambda item:item.money)
print(emp.__dict__)
升序排列
# 升序排列
# sorted(list_employees,key = lambda item:item.money)
# descending_by
# 注意:没有修改原有列表,而是返回新列表
new_list = sorted(list_employees,key = lambda item:item.money,reverse=True)#降序
print(new_list)
############################################################
Enclosing外部嵌套作用域 :函数嵌套。
内函数只能读取,不能修改外函数变量,修改只能用 nonlocal
def func01():
a = 10
def func02():
# 内函数不能修改外函数变量
# a = 20
# 必须通过nonlocal声明
nonlocal a
a = 20
func02()
print(a)
func01()
闭包
三要素:
– 必须有一个内嵌函数。
– 内嵌函数必须引用外部函数中变量。
– 外部函数返回值必须是内嵌函数。
语法
– 定义:
def 外部函数名(参数):
外部变量
def 内部函数名(参数):
使用外部变量
return 内部函数名
– 调用:
变量 = 外部函数名(参数)
变量(参数)
#例子
def give_gife_money(money):
print(f"获得了{money}元压岁钱")
def child_buy(commodity, price):
nonlocal money
money -= price
print(f"购买{commodity}花了{price},还剩下{money}")
return child_buy
action = give_gife_money(1000)
action("遥控汽车", 300)
action("遥控飞机", 500)
action("变形金刚", 200)
函数装饰器decorator
wrapper()不用传参数就可以享用外层函数的参数
定义:在不改变原函数的调用以及内部代码情况下,为其添加新功能的函数。
语法
def 函数装饰器名称(func):
def wrapper(*args, **kwargs):
这里写需要添加的新功能
return func(*args, **kwargs)#这里相当于调用的是原函数(传进来的函数)
return wrapper
@ 函数装饰器名称 #原函数 = 内嵌函数,所以最下面:原函数(参数) 调用的其实是wrapper()
def 原函数名称(参数):
函数体
原函数(参数)
下面是举的例子
# 例子:不改变插入函数与删除函数代码,为其增加验证权限的功能
def verify_permissions(func):
def wrepper(*args, **kwargs):#参数处理,完美固定写法
print("验证权限") #增加的新功能
return func(*args, **kwargs) #返回的是原函数(传进来的函数)
return wrepper
@verify_permissions #相当于把内嵌wrepper给了insert
def insert():
print("插入")
return 100
@verify_permissions #相当于把内嵌wrepper给了delete
def delete(data):
print("删除", data)
return True
#下面调用,其实调用的是内嵌函数wrepper(),因为装饰器@verify_permissions把原函数 = 内嵌函数
print(insert()) #这里insert()
print(delete('数据'))
文件读写操作
打开文件
file_object = open(file_name, access_mode='r', buffering=-1,encoding=None)
功能:打开一个文件,返回一个文件对象。
参数:file_name 文件名;
access_mode 打开文件的方式,如果不写默认为‘r’
buffering 1表示有行缓冲,默认则表示使用系统默认提供的缓冲机制。
encoding='UTF-8' 设置打开文件的编码方式,一般Linux下不需要
返回值:成功返回文件操作对象。
######################################################################
这里是举个例子
a = open('./a.txt','w')
关闭文件
变量.close()
读取文件
方法1
read(7)
功能: 来直接读取文件中字符。
参数: 如果没有给定7,文件将被读取直至末尾,给定7最多读取7个字符(字节)。
返回值: 返回读取到的内容
注意:1. 文件过大时候不建议直接读取到文件结尾,占用内存较多,效率较低
- 读到文件结尾如果继续进行读操作会返回空字符串。
# 例子:读方式打开
file = open("file.txt",'r')
# 二进制打开 读取出字节串
file = open("file.txt",'rb')
# 读取内容
data = file.read()
print(data)
file.close()
#————————————————————————————————————————————————————————————————————————————————————
file = open("file.txt",'r')
# 循环读取文件内容
while True:
data = file.read(1)
if data == "":
break
print(data,end='')
file.close()
方法2
readline(7)
功能: 用来读取文件中一行
参数: 如果没有给7,表示读取一行,给定7表示最多读取7个字符(字节)。
返回值: 返回读取到的内容
方法3
readlines(7)
功能: 读取文件中的每一行作为列表中的一项
参数: 如果没有给定7,文件将被读取直至末尾,给定7表示读取到7个字符所在行为止。
返回值: 返回读取到的内容列表
方法4
# 文件对象本身也是一个可迭代对象,在for循环中可以迭代文件的每一行。
for line in f:
print(line)
写文件
方法1
write(参数)
功能: 把文本数据或二进制数据块的字符串写入到文件中去
参数:要写入的内容
返回值:写入的字符个数
注意: 如果需要换行要自己在写入内容中添加\n
方法2
writelines(str_list)
功能:接受一个字符串列表作为参数,将它们写入文件。
参数: 要写入的内容列表
with操作
python中的with语句也可以用于访问文件,在语句块结束后会自动释放资源。
with open('file.txt','r') as f:
a = f.read()
print(a)
注意 : with语句块结束后会自动释放f所以不再需要close().
读写缓冲区
定义
系统自动的在内存中为每一个正在使用的文件开辟一个空间,在对文件读写时都是先将文件内容加载到缓冲区,再进行读写。
刷新缓冲区条件
1缓冲区被写满
2程序执行结束或者文件对象被关闭
3程序中调用flush()函数
file_obj.flush()
缓冲区设置
类型 | 设置方法 | 注意事项 |
---|---|---|
系统自定义 | buffering= -1 | |
行缓冲 | buffering=1 | 当遇到\n时会刷新缓冲 |
指定缓冲区大小 | buffering>1 | 必须以二进制方式打开 |
buffering=1 当遇到\n时会刷新缓冲
file = open('file.txt','w',buffering=1)#buffering=1
#写入输入的,回车结束
while True:
data = input('>>')
if data == '':
break
file.write(data+'\n')#当遇到\n时会刷新缓冲
file.close()
buffering>1 必须以二进制方式打开
#二进制方式打开
file = open('file.txt','wb',buffering=10)#buffering>1 =10 就等于超过10个字节会刷新缓存区
#写入输入的,回车结束
while True:
data = input('>>')
if data == '':
break
file.write(data.encode())#以二进制的方式写
# file.flush()
file.close()
文件偏移量控制
tell()
功能:获取文件偏移量大小
返回值:文件偏移量
seek(offset,whence)
功能: 移动文件偏移量位置
参数:offset 代表相对于某个位置移动的字节数。负数表示向前移动,正数表示向后移动。
whence是基准位置的默认值为 0,代表从文件开头算起,1代表从当前位置算起,2 代表从文件 末尾算起。
#################################
文件.seek(3,0)#代表从文件开头算起向后偏移3个字节
os模块
os模块是Python标准库模块,包含了大量的文件处理函数。
获取文件大小
os.path.getsize(file)
功能: 获取文件大小
参数: 指定文件
返回值: 文件大小
查看文件列表
os.listdir(dir)
功能: 查看文件列表
参数: 指定目录
返回值:目录中的文件名列表
判断文件是否存在
os.path.exists(file)
功能: 判断文件是否存在
参数: 指定文件
返回值: 布尔值
删除文件
os.remove(file)
功能: 删除文件
参数: 指定文件
下面是实例
import os
print('文件大小是:', os.path.getsize('file.txt'))
print('文件列表是:', os.listdir('..'))#..是看上一级文件夹的列表
print('文件是否存在:', os.path.exists('file.py'))
os.remove("file.txt") # 删除文件