-
文件操作
-
打开文件
open(file,mode)函数：
-
file参数指定的是
文件路径和文件名，如果没有传入路径(绝对/相对)，默认就是将文件创建在python的主文件夹下面 -
mode:【可选参数】，打开的模式，常见参数：
参数值 作用 ‘r’ 读取（默认） ‘w’ 写入（如果文件已存在，则先截断、清空文件） ‘x’ 排他性创建文件（如果文件已存在，则打开失败） ‘a’ 追加（如果文件已存在，则在末尾追加内容） ‘b’ 二进制模式 ‘t’ 文本模式（默认） ‘+’ 更新文件（读取和写入）
-
-
文件对象
文件对象的各种方法及含义：
| 方法名 | 作用 |
|---|---|
| f.close() | 关闭文件对象 |
| f.flush() | 将文件对象中的缓存数据写入到文件中（不一定有效） |
| f.read(size=-1,/) | 从文件对象中读取指定数量的字符（或者遇到EOF停止）；当未指定该参数时，或者该参数为负值的时候，读取剩余的所有字符 |
| f.readable() | 判断该文件对象是否支持读取（如果返回值为False，则顶用read()方法会导致OSError异常） |
| f.readline(size=-1,/) | 从文件对象中读取一行字符串（包括换行符），如果指定了size 参数，则表示读取size个 字符 |
| f.seek(offset,whence=0,/) | 修改文件指针的位置，从whence参数指定的位置（0代表文件的起始位置，1代表当前位置，2代表文件末尾）偏移offset个字节，返回值是新的索引位置 |
| f.seekable() | -判断该文件对象是否支持修改文件指针的位置（如果返回的值为False,则调用seek()，tell(),truncate()方法都会导致OSError异常） |
| f.tell | 返回当前文件指针在对象中的位置 |
| f.truncate(pos=None,/) | 将文件对象截取到pos的位置，默认是截取到文件指针当前的位置 |
| f.write(text,/) | 将字符串写入到问价对象中，并返回写入的字符数量（字符长度） |
| f.writable() | 判断该文件对象是否支持写入（如果返回的值是False，则调用write()方法会导致OSError异常） |
| f.writelines(lines,/) | 将一系列字符串写入到文件对象中（不会自动添加换行符，所以通产是认为的加在每个字符串的末尾） |
（只介绍部分参数，更多的详情,请参考官方文档）
-
路径处理
pathlin–面向对象的文件系统路径，pathlib是python3.4之后添加的模块，可以让文件和路径操作变得快捷方便，完美带了os.path-
pathlib中path模块中文件对象：
- is_dir():判断一个路径是否为一个文件夹
- is_file()：判断一个路径是否为一个文件
- exists():检测一个路径是否存在
- name属性:获取路径的最后一部分
- stem属性：获取文件名
- suffix属性:获取文件的后缀
- parent属性：获取父级目录
- parents属性：获取逻辑祖先路径构成的一个不可变序列
- parts:将路径的各个组件拆分成元组
- stat():查询文件或文件夹的信息
- iterdir()；获取当前路径下所有子文件和子文件夹
- mkdir():创建文件夹，如果已创建的文件存在，就会
报错,将参数exist_ok = True，已经存在就不会报错；如果参数exist_ok = True,但路径中存在多个不存在的父级路径目录，也会报错，将parents = True就可以 - open():Path包内部还打包了一个open（）方法，跟open方法一样，不过路径参数不使用
- rename():修改文件或文件夹的名字，会移动文件
- repalce():替换指定的文件或文件夹
- rmdir:删除文件夹
- unlink():删除文件
- glob():查找功能
-
相对路径和绝对路径的转换：
resolve():可以将
相对路径转换为绝对路径复制代码1
2
3Path('../Python310').resolve() WindowsPath('C:/Users/Administrator/AppData/Local/Programs/Python/Python310')-
with语句和上下文管理器
为文件操作提供了一种更为便捷的方式，传统操作文件的方式是：打开文件，获得文件对象，写入文件内容，最后关闭文件；而使用with上下文管理器：
复制代码1
2
3
4
5
6
7
8##f = open('./day1.a.txt','a') ##f.write('叮当叮当丁呀丁呀叮当') ##f.close() #使用with with open('./day1.a.txt','a') as f: f.wirte('with的使用方法')使用with上下文管理最大的
优势：它能够确保资源的释放，即自动关闭文件；因为手动f.close()关闭文件之前有可能发生保证，打断文件的正常关闭：复制代码1
2
3
4with open('./day1.a.txt','a') as f: f.write(r'nwith的使用方法') 1/04. pickle
pickle模块可以将python对象
序列化(将python对象转换Wie二进制字节流)，解决的就是永久存储python对象的问题，它允许你将字符串、列表、字典这些python对象给保存为文件形式
相关函数：
-
dump:将python对象写入后缀
.pkl复制代码1
2
3
4
5
6
7
8
9
10
11
12
13
14
15import pickle strs = 'Hello Python !I love you forever' x,y,z = 1,2,3 l = [1,2,3,4,5] d = {'name':'小张', 'age':18} with open('data.pkl','wb') as f: pickle.dump((strs,x,y,x,l,d),f) ## pickle.dump(strs,f) ## pickle.dump(x,f) ## pickle.dump(y,f) ## pickle.dump(z,f) ## pickle.dump(l,f) ## pickle.dump(d,f) -
load:从后缀
.pkl读取python对象复制代码1
2
3
4
5
6
7
8
9
10
11import pickle with open('data.pkl','rb') as f: strs,x,y,z,l,d = pickle.load(f) ## strs = pickle.load(f) ## x = pickle.load(f) ## y = pickle.load(f) ## z = pickle.load(f) ## l = pickle.load(f) ## d = pickle.load(f) print(strs,x,y,z,l,d,sep='n')
-
-
-
异常exception
使用
try...except来捕获机制，语法：复制代码1
2
3
4
5try: 检测的代码 except [expression [as indentifier]]: 异常处理代码expression：为可选参数，可填异常类型，捕捉特定的异常形式；as:是将异常的原因给提取出来复制代码1
2
3
4
5try: 1/0 except ZeroDivisionError as err: print('被除数不可以为零',err)当需要捕获
多个异常的时候：复制代码1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16try: 1/0 '你好'+12 except (ZeroDivisionError,ValueError,TypeError) as e: print(e) #写法二 try: 2/0 12+'你好' except ZeroDivisionError as e: print('除数不能为零',e) except TypeError as e: print('类型为零',e) except ValueError as e: print('值不正确',e)-
try-except-else
当try语句里面的代码，没有检测出任何异常的情况下，那么就会执行else语句中的内容
复制代码1
2
3
4
5
6
7try: 1/1 except: print('捕捉到了错误') else: print("没有捕捉到错误")-
try-except-finally/try-except-finally-finally
无论是否捕获异常，必须执行finally里面的内容，通常用来执行一些收尾的代码，例如关闭文件
复制代码1
2
3
4
5
6
7
8try: f = open('day1.a.txt','a+') f.write('你好啊，python!') except: print('打开文件异常') finally: f.close()-
try-finally
发生异常时，程序在停止时，但会执行finally里面的内容，代码略
-
异常的嵌套
复制代码1
2
3
4
5
6
7
8
9
10
11
12
13try: try: 520+'你好啊' except: print('发生内部异常') 1/0 except: print('发生外部异常！') else: print('内外都没发生异常') finally: print('收尾工作~') -
raise语句：主动产生异常的语句
复制代码1
2raise ValueError('值不正确')注意：raise语句不能抛出一个
不存在的异常复制代码1
2
3
4
5try: 1/0 except: raise ValueError('能实现异常替换么？不能') -
异常链,raise…from
复制代码1
2raise ValueError('这是导致后一个异常原因') from ZeroDivisionError -
assert语句
assert跟raise类似，都是引发异常，但assert语句只能一个叫做
AssertionError的异常,这个语句通常是用来代码调试
复制代码1
2
3
4
5
6
7
8strs = 'hello' assert strs == 'hello' assert strs == 'Hello' Traceback (most recent call last): File "<pyshell#6>", line 1, in <module> assert strs == 'Hello' AssertionError-
利用异常来实现
goto语句
在多层循环中一次性跳出来，代码案列：
复制代码1
2
3
4
5
6
7
8
9
10
11
12
13
14# python实现goto语句的功能 try: while True: while True: for i in range(10): if i == 4: raise print(i) print('内层循环1') print("外层循环2") print('外层循环3') except: print("真正该执行的代码，在这里！！") -
-
类和对象
面向对象也是一种代码封装的方法，它的主要思想是将相关的数据和实现的函数给封装到一起.对象=属性+方法。
1. 创建类
使用类名大写字class关键字创建类，类名大写字母开头。通过像函数意向调用类名,就可以得到一个类的实例对象。封装、继承、多态是面向对象编程的是三个基本特征。
-
什么是封装？
封装就是在创建类之前将相关的特征属性和方法打包在一起，然后通过类来生成相应的对象。注意，封装一定要注意属性和方法的相关性
-
self是什么？
传递给类中方法的实参self,是类的实例对象;因此类中的方法第一个默认都是self.他的功能是将实例对象与类``绑定
； 当我们调用实例对象的方法时，其实是在调用类的方法,并将实例对象作为参数给传递进去，进而实现绑定.通过实例对象.dict`内省的方式可以知道对象自身所拥有的属性复制代码1
2
3
4
5
6
7
8class C: def set_property(self,value): self.property = value c = C() print(c.__dict__) c.set_property(250) print(c.__dict__) -
什么是继承？
通过继承创建的新类称为子类，而被继承的类称之为父类，（基类或者超类）
复制代码
1
2
3
4
5
6
7
8
9
10
11class Student: name='小明' age=18 course=['语文','英语','数学'] def getOwnCoures(self): return self.course class Xiaoming(Student): pass xm = Xiaoming() print(xm.getOwnCoures())
注意：
- 判断某个对象是否属于某个类，可以使用
isinstance()函数 - 检查一个类是否为某个类的子类，可以使用
issubclass()函数
2.多重继承
一个类继承自多个类，称为多重继承。继承方法和属性的顺序是从左向右。
3.什么是组合？
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21# 组合定义： class Birds: def fly(self): print('I'm a birds,Ican fly') class Pandas: def eating(self): print('I'm a panda,I like eating bambos') class Wolies: def howling(self): print('I'm a wolf,I want to eat meat') class Zoo: bird = Birds() panda = Pandas() wolf = Wolies() def showHabits(self): self.bird.fly() self.panda.eating() self.wolf.howling() zoo = Zoo() zoo.showHabits()
4.什么是多态？
多态是指同一个运算符、函数或对象在不同的场景下具有不同的作用效果
类继承的多态：Python允许我们在子类中定义和父类同名的方法进行覆盖，这个操作叫做重写.重写就是实现类继承的多态
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32# 多态 class Shape: def __init__(self,name): self.name = name def area(self): pass class Square(Shape): def __init__(self,length): super().__init__('正方形') self.length = length def area(self): return self.length**2 class Circle(Shape): def __init__(self, radius): super().__init__('圆形') self.radius = radius def area(self): return 3.14*self.radius**2 class Triangle(Shape): def __init__(self,base,height): super().__init__('圆形') self.base = base self.height = height def area(self): return self.base*self.height/2 s = Square(2) c = Circle(3) t = Triangle(3,4) print(s.area()) print(c.area()) print(t.area())
自定义函数是如何实现多态接口:
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35#自定义函数实现多态 class Cat: def __init__(self,name,age) -> None: self.name = name self.age = age def introduce(self): print(f"我是一只小猫咪，我叫{self.name}，今年{self.age}岁啦！") def talk(self): print("hi~") class Dog: def __init__(self,name,age) -> None: self.name = name self.age = age def introduce(self): print(f"我是一只小狗，我叫{self.name}，今年{self.age}岁啦！") def talk(self): print("hello~") class Pig: def __init__(self,name,age) -> None: self.name = name self.age = age def introduce(self): print(f"我是一只小猪，我叫{self.name}，今年{self.age}岁啦！") def talk(self): print("妞妞~") cat = Cat('小小',3) dog = Dog('礼貌',7) pig = Pig('妞妞',4) def animalInroduction(animals): animals.introduce() animals.talk() animalInroduction(cat) animalInroduction(dog) animalInroduction(pig)
5.构造函数/_ _ init_ _
类在实例化对象的时候也支持,只需要在类中定义_ _ init _ _化方法，就可以在实例化的同时实现个性化定制对象实例；通过类名访问类里面的方法的做法叫做调用类里面的未绑定父类方法
复制代码
1
2
3
4
5
6
7
8
9
10class C: def __init__(self,x,y,z): self.x = x self.y = y self.z = z z = lambda x, y : x + y c = C(1,2,z) print(c.__dict__,c.z(1,1))
６.重写
子类通过跟父类重名的方式去覆盖父类的方法或者变量的方式称为重写
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16class C: def __init__(self,x,y,z): self.x = x self.y = y self.z = z z = lambda x, y : x + y c = C(1,2,z) # print(c.__dict__,c.z(1,1)) class D(C): def __init__(self,x,y,z,w): C.__init__(self,x,y,z) self.w = w d = D(123,456,7,8) print(d.__dict__)
７. 钻石继承
当类B和类C同时继承于类A，且类D同时继承于B，C。它们之间的关系就想一颗钻石的形状，就叫做钻石继承。钻石继承的缺点是：类D的实例对象在调用类D的_ _ init _ _ 构造函数时会同时执行两次类A的_ _ init _ _ 构造函数:
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24class A: def __init__(self): print('我是类A') class B(A): def __init__(self): A.__init__(self) print('我是类B') class C(A): def __init__(self): A.__init__(self) print('我是类C') class D(B,C): def __init__(self): B.__init__(self) C.__init__(self) print('我是类D') d = D() """ 我是类A 我是类B 我是类A 我是类C 我是类D """
解决方法：super（）函数，它能够按照MRO方法解析顺序（Method,Resolution,Order）在父类中搜索指定的方法，并自动绑定好self参数，避免重复调用的问题。查找一个类的MRO有两种方法：
-
可以通过
类名.mro（） -
或者通过
类名.__mro__()复制代码1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25# 钻石排列 class A: def __init__(self): print('我是类A') class B(A): def __init__(self): super().__init__() print('我是类B') class C(A): def __init__(self): super().__init__() print('我是类C') class D(B,C): def __init__(self): super().__init__() print('我是类D') d = D() print(D.__mro__) print(D.mro()) ```
-
Mixin
Mixin是一种设计模式，叫混入或者乱入。用来给某些类外挂一些方法.注意它是严格按照MRO规则的
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19# Minxin案列举例 class Displayer: def display(self,message): print(message) class LoggerMixin: def log(self,message,filename=''): with open(filename,'a') as f: f.write(message) def display(self,message): super().display(message) self.log(message) class MySubClass(LoggerMixin,Displayer): def log(self,message): super().log(message,filename='subclasslog.txt') subclass = MySubClass() subclass.display('This is a test.')
-
私有变量
在定义类的时候，可以通过在变量名前面添加两个下划线的方式来，声明私有变量。一旦声明了私有变量，外部实例是无法通过
实例名.变量名的的方式访问。但可以通过实例名._类名__变量名的方式访问，但建议做好不要这样操作，建议在定义私有变量的时候设置对应的set方法和get方法。其他类型：
- _单个下横线开头的变量:仅供内部使用的变量，属于约定俗成的命名规则
- 单个下横线结尾的变量_：用来区别python内部的保留词
-
_ _ slots _ _属性
对象划分一个固定大小的空间来存放指定的属性，大大的节省了空间。，但使用了_ _ slots_ 就没有动态添加属性的功能了。
注意:继承自父类的 _ _ slots_ _ 属性是不会再子类中生效的。python只会关注各个具体的类中定义的__ slots __属性
-
对象
-
对象作用过程中魔法方法
在对象从创建到销毁的整个过程中，python都提供了魔法方法。我们可以对魔法方法进行重写,从而操作对象
方法名 作用 适用场景 __ new__（cls[, …]） 在__ init __之前调用，创建对象.因此， 对象的诞生流程：是先调用 _ _new _ _方法，创建一个类的实例(返回self)，;然后将其传递给 _ _ init _ _（）方法，再进行个性化定制1.元类中取定制类
2.在继承不可变数据类型的时候，可以重写new方法进行拦截__ init __（self） 在对象初始化的时候实现个性化定制，自动被调用 __ del __(self) 当检测到一个对象没有任何引用的时候，对象被销毁的时候才会调用 del方法是在对象销毁前的最后拦截，利用这个来实现对象的重生。即del方法可以通过创建一个该实例的新引用来推迟其销毁，这也被称之为 对象的重生对象复活代码示例：复制代码1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24class E: def __init__(self,name,func): self.name = name self.func = func def __del__(self): self.func(self) def outter(): x = 0#用来存放对象实例，当函数结束运行时，函数的外层变量值会保存 def inner(y =None): nonlocal x if y: x = y else: return x return inner # 实例化 f = outter() e = E('小红',f) print(e) del e e1 = f() print(e1)-
与运算相关的魔法方法：
-
算数运算
魔法方法名 相关运算 作用 __ add __(self,other) x + y(由运算符左侧的对象x触发) 加法运算 __ sub __(self,other) x - y(由运算法左侧的对象x触发) 减法运算 __ mul __(self,other) x * y (由运算法左侧的对象x触发) 乘法运算 __ matmul__(self, other) x @y (由运算符左侧的对象×触发) 矩阵乘法运算 __ truediv __(self, other) x / y(由运算符左侧的对象×触发) 真除法运算 _ _ floordiv_(self, other) x // y(由运算符左侧的对象×触发) 地板除法运算 _ _ mod__(self, other) x % y(由运算符左侧的对象×触发) 求余数运算 __ divmod__(self, other) divmod(x, y)(由对象×触发) 见divmod()函数 __ pow__(self, other[,module]) x**y或 pow(x, y)(由运算符左侧的对象×触发) 幂运算，见pow()函数 Ishift_(self, other) x<<y(由运算符左侧的对象×触发) 按位左移运算 __ rshift__(self, other) x >> y(由运算符左恻的对象×触发) 按位右移运算 __ and__(self, other) x &y(由运算符左很的对象x触发) 按位与运算 __ xor__(self,other) x ^y(由运算符左侧的对象×触发) 按位异或运算 __ or __(self, other) xl y(由运算符左侧的对象×触发) 按位或运算 -
反算数运算
什么时候使用反算数运算？
例如：__ radd __()方法调用的前提：当两个对象相加的时候，如果左侧的对象和右侧的对象不同类型，并且左侧的对象没有定义
__ add __()方法，或者其__ add __ ()方法返回NotImplemented,那么Python就会失去右侧对象中查找是否有__ radd()__方法的定义。魔法方法名 相关运算 作用 __ radd___(self,other) x+y(由运算符右侧的对象y触发) 加法运算 __ rsub_(self, other) x -y(由运算符右食的对象y触发) 减法运算 __ rmul__(self, other) x *y(由运算符右侧的对象y触发) 乘法运算 __ rmatmul__(self, other) x@y (由运算符右侧的对象y触发) 矩阵乘法运算 __ rtruediv__(self, other) x / y (由运算符右侧的对象y触发) 真除法运算 __ rfloardiv_(self, other) x //y(由运算符右侧的对象y触发) 地板除法运算 __ rmod___(self, other) x % y(由运算符右倒的对象y触发) 求余数运算 __ rdivmod _ __(self, other) divmod(x, y)(由对象y触发) divmod()函数 __ rpow__(self, other[,modulo]) x**y或pow(x. y)(由运算符右侧的对象y触发) 幂运算，见pow()函数 __ rlshift_(self, other) x <<y (由运算符右恻的对象y触发) 按位左移运算 __ rrshift___(self, other) x >>y(由运算符右侧的对象y触发) 按位右移运算 __ rand__(self, other) x &y(由运算符右假拍的对象y触发) 按位与运算 __ rxor_(self, other) ×^y(由运算符右侧的对象y触发) 按位异或运算 __ ror__(self, other) x |y(由运算符右侧的对象y触发) 按位或运算 -
增强赋值运算
魔法方法名 相关运算 作用 __ iadd___(self,other) x+y(由运算符右侧的对象y触发) 加法运算 __ isub_(self, other) x -y(由运算符右食的对象y触发) 减法运算 __ imul__(self, other) x *y(由运算符右侧的对象y触发) 乘法运算 __ imatmul__(self, other) x@y (由运算符右侧的对象y触发) 矩阵乘法运算 __ itruediv__(self, other) x / y (由运算符右侧的对象y触发) 真除法运算 __ ifloardiv_(self, other) x //y(由运算符右侧的对象y触发) 地板除法运算 __ imod___(self, other) x % y(由运算符右倒的对象y触发) 求余数运算 __ idivmod _ __(self, other) divmod(x, y)(由对象y触发) divmod()函数 __ ipow__(self, other[,modulo]) x**y或pow(x. y)(由运算符右侧的对象y触发) 幂运算，见pow()函数 __ ilshift_(self, other) x <<y (由运算符右恻的对象y触发) 按位左移运算 __ irshift___(self, other) x >>y(由运算符右侧的对象y触发) 按位右移运算 __ iand__(self, other) x &y(由运算符右假拍的对象y触发) 按位与运算 __ ixor_(self, other) ×^y(由运算符右侧的对象y触发) 按位异或运算 __ ior__(self, other) x |y(由运算符右侧的对象y触发) 按位或运算 -
跟｀属性访问｀有关的魔法方法：
跟对象属性有关的BIF：
hasattr(对象实例，属性名)：用于判断对象是否具有该属性
getattr(对象实例，属性名)：用俩获取对象的属性值，如果需要访问私有属性的话，需要使用getattr(对象名，_对象名__属性名)
setattr(对象名，属性名,值)：设置对象的值
delattr(对象名，属性名):删除属性对应的魔法方法：
属性名 作用 __ getattr __() 拦截用户试图去获取一个不存在的属性时，才会拦截的魔法方法 __ getattribute __() 拦截getattr方法或.号 __ setattr __() 拦截setattr方法或.号,注意在函数中出现死循环，列如在__ setattr (self,name,value)中设置self.name = value就会出现死循环，可以使用super()或者self. dict __[name] = value __ delattr __() 拦截delattr方法 -
最后
以上就是生动汉堡最近收集整理的关于day3.python基础中下的全部内容，更多相关day3内容请搜索靠谱客的其他文章。
本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
发表评论 取消回复