python语法

5i吃鱼

已于 2023-04-05 20:50:58 修改

阅读量2k

点赞数 7

分类专栏： python 文章标签： python

于 2021-08-04 10:44:37 首次发布

本文链接：https://blog.csdn.net/zb13283881541/article/details/119378705

版权

python 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

文章目录

标蓝(设置项目根目录)
文件夹右键 - Mark Directory - Sources Root
zip
生成器表达式
lambda 表达式
内置高阶函数
Enclosing外部嵌套作用域：函数嵌套。
闭包
函数装饰器decorator
文件读写操作
os模块
- - 下面是实例

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") # 删除文件