Python扩充

文件

文件流，使用完需要关闭

open()

open(name, mode, encoding)
# name为文件的路径
# mode为访问模式，r（只读，指针），w（覆盖），a（追加）
f = open("", mode, encoding = UTF-8)

r

指针

read()

返回值是str

f = open("D:\test.txt", "r", encoding = UTF-8)
# 读取指定字节
print(f"{f.read(10)}")
# 读取全部
print(f"{f.read()}")

readline()

readlines()

for line in f.readlines():

读取全部内容，返回一个list

遍历

for line in f:
    print(f"每一行的数据：{line}")

with open() as 方法名

with open("D:\test.txt", "r", encoding="UTF-8") as f:
    for line in f:
        print(f"{line}")

使用with open自动会关闭文档流

w

write()

f = open("D:\test.txt", "w", encoding = "UTF-8")

f.write("one of a kind")

# 将内存中的内容写到硬盘中的文件中
f.flush()
# 内置flush功能
f.close()

a

操作同w

异常

捕获具体异常

try:
    print(name)
except NameError:
    print("变量名为定义")

Exception

最大的异常

异常可以传递

Python模块

模块导入

①

# 导入time包
import time

print("休息会儿")
# 系统休眠
time.sleep(5)
print("休息好了")

 ②

# 导入time下面的sleep()
from time import sleep

print("休息会儿")
sleep(2)
print("休息好了")

③

# 导入time下面所有的方法
from time import *

print("休息会儿")
sleep(2)
print("休息好了")

④起别名

# from time as t
from time import sleep as s

print("休息会儿")
s(1)
print("休息好了")

自定义模块

自定义

_ _main_ _

自定义文件内部调用，如果不想在导包的时候输出结果，可以在自定义文件内添加_ _main_ _，在其中写入输出代码

_ _all_ _

使用import *时，不想导入的元素可以不写近all里面

Python包

自定义包

创建package包

安装第三方包

cmd命令行 pip install 包名（外网，速度慢）

国内的：

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名

然后再命令行进入python解析器，import下载的包就行了

类 对象

class Student:
    name = None

stu = Student()
stu.name = "whx"
print(f"{stu.name}")

成员方法

class Student()
    name = None
    # 里面必须有self，选填参数
    def say(self):
        print(f"你好，我叫{self.name}")

内置方法（魔术方法）

__init__()

class Student():
    name = None
    age = None
    gender = None

    def __init__(self):
        self.name = name
        self.age = age
        self.gender = gender

stu = Student("whx", 20, "男")

重写__str__()

重写__lt__()

    def __lt__(self, other):
        return self.age < other.age


stu1 = Student("whx", 20)
stu2 = Student("zsy", 18)
print(stu1 < stu2)

重写__le__() equal等于

重写__eq__()

比较与other值的关系

==

封装

私有化成员变量和成员方法

class Student():
    name = None
    # 私有化
    __age = None

    # 私有化
    def __how():
        print("如何去上学")

私有化的东西不能被类对象使用，但可以被自己的方法使用，类对象可以通过调用非私有化方法调用私有化属性和方法

继承

单继承

class Phone:
    P_id = 1001
    name = "Mi"
    producer = "whx"

    def play(self):
        print(f"您的手机当前版本为{self.P_id}")
# 单继承
class Phone_two(Phone):
    P_id = 1002

p = Phone_two()
p.play()

多继承

左边的优先级最高

class Phone_two(Phone, NFC, red):
    P_id = 1002

p = Phone_two()
p.play()

pass

继承之后子类如果不想有代码块，可以使用pass

super()

子类中调用父类用

super().

类型注解

①

# 基本数据类型注解
name : str = "whx"
age : int = 20
pai : float = 3.1415

# 对象类型注解
class Student:
    pass

stu : Student = Student()

# 容器类型注解
my_list : list = [1, 2 , 3]
my_tuple : tuple = (1 ,2 , 3)

# 容器类型注解详解
my_tuple : tuple[str, int] = ("whx", 20)

注释注解

class Student():
    pass

s = Student() # type : Student()

方法中的类型注解

# 形参的类型注解
def add(x : int, y : int):
    return x + y

add(1, 2)

# 返回值的类型注解
def func(data : list) -> list:
    return data

print(f"{func([1, 2, 3, 4])}")

Union类型注解

# 使用Union先导包
from typing import Union

my_list : list[Union[str, int]] = [1, 2, 3, "6666"]

def func(data : Union[str, int]) -> Union[str, int]
    pass

func()

多态

# 动物类
class Animal():
    def spark(self):
        pass
# 猫类
class Cat(Animal):
    def spark(self):
        print("喵")
# 狗类
class Dog(Animal):
    def spark(self):
        print("汪")
# 方法
def make_noise(animal : Animal):
    animal.spark()

# 实例化猫狗类
cat = Cat()
dog = Dog()

# 多态
make_noise(cat)
make_noise(dog)

抽象类

父类有具体方式不实现，子类实现父类具体的方法

空实现的方法（pass）就是抽象方法

包含抽象方法的类叫抽象类