文章目录
1、文件的常用操作
import os
# - 删除:文件
os.remove("tq2.txt")
# 删除文件夹
os.rmdir("123")
# 删除一个有内容的文件夹，必须先删除文件夹里面的内容文件，才能删除空文件
# 获取文件加的列表文件
print(os.listdir("tianqiu"))
# 返回的数据内容是列表，可以通过遍历列表获取每个文件的名字+路径信息，进行remove删除
# - 重命名
os.rename("tq.txt", "tq3.txt")
# - 获取文件的路径信息
print(os.getcwd()) # D:\pythonProject_241
# # - 创建一个文件夹
os.mkdir("tq1")
os.rmdir("tq1")
os.rmdir("tianqiu") # 不能删除一个有内容文件的文件夹
# 只能删除空的文件夹：目录不是空的
os.rmdir("op")
# 递归删除目录
os.removedirs("op") # 前提：目录是空的
案例：删除一个有内容文件的目录
# 获取目录的文件列表
import os
# 先获取文件目录列表
names_list = os.listdir("op")
print(names_list)
# 找到目标全部文件删除之后，再删除文件夹
path = r'D:\pythonProject_241\op\\'
for i in names_list:
# 通过文件名，删除文件
print(path + i)
# 注意：文件名只要不在当前目录，都需要加上路径信息，才能定位操作
os.remove(path + i)
else:
os.rmdir("op")
# 使用shutil模块使用rmtree方法可以直接删除一个有内容文件的目录
import shutil
shutil.rmtree("op")
2、面向对象入门
主流的变成思想分为两种类型
- 面向过程
- 主要以流水线的代码为主，不会进行类的定义和对象的创建，然后基本上都是通过函数的封装及调用实现
- 需要实现具体一个功能的时候，看中是开发的步骤和流程
- 每一个步骤需要亲力亲为编写代码然后实现具体的功能
- 面向对象
- 主要以类和对象为主，通过定义类创建对象完成具体功能或者需求
- 需要实现一个具体的功能的时候，不看重开发步骤和过程
- 核心是通过定义封装的类创建一个对象完成对应的功能或需求
- 面向对象三大特性
- 封装
- 继承
- 多态
3、类的定义和封装
在创建对象之前，必须有一个类
类中可以封装行为和特征然后定义成方法和属性
- 特征：封装成类的实例属性
- 行为：封装成类的实例方法
定义一个英雄类
- 特征
- 名字
- 攻击力
- 生命值
- 防御值
- 行为
- 发起普通攻击
- 释放技能
- 回城
- 给队友发信息
4、实例属性和实例方法
类的定义
- 封装特征和行为
- 封装实例属性和实例方法
对象的创建
- 对象调用实例属性和实例方法
类的定义和对象的创建
# 定义类：使用class关键字类名:
# 类名需要符合标识符的命名规则，一般类名建议使用大驼峰命名法则
class Hero:
pass
# 通过类创建对象
# 类名()就是实例化一个对象
# 一个类可以创建0-无数个对象
hero1 = Hero()
hero2 = Hero()
hero3 = Hero()
hero4 = Hero()
类的实例属性和实例方法的封
通过类创建的对象都会拥有封装的实例属性和实例方法
# 定义类：使用class关键字类名:
# 类名需要符合标识符的命名规则，一般类名建议使用大驼峰命名法则
class Hero:
# 在类中定义实例属性需要使用魔法方法：__init__构造方法
# 魔法方法：以双下划线开头和结尾，而且在特殊情况下自动调用执行
# init魔法方法会在对象被创建的时候自动执行，也称为构造方法
# self代表通过类创建出来的对象
def __init__(self):
# 在类中封装对象实例属性
# - 名字
self.name = "百里守约"
# - 生命值
self.hp = 800
# 魔法值
self.mp = 500
# 行为和操作封装成实例方法
# 在类中定义的函数叫做实例方法
# 实例方法和函数的区别：实例方法一定有一个固定的参数self，代表对象本身
def attack(self):
print("英雄发起普通攻击")
def move(self):
print("执行移动英雄操作")
def back_city(self):
print("执行英雄回城操作")
# 通过类创建对象
# 类名()就是实例化一个对象
# 一个类可以创建0-无数个对象
hero1 = Hero()
# 对象一旦被创建，自动执行init魔法方法，获取对象的实例属性
# 对象可以调用实例属性：对象名.属性名
print(hero1.name)
print(hero1.mp)
print(hero1.hp)
hero2 = Hero()
print(hero2.name)
print(hero2.mp)
print(hero2.hp)
# 对象可以调用实例方法：对象名.方法名()
hero3 = Hero()
hero3.move()
hero4 = Hero()
hero4.attack()
hero1.back_city()
# 类中封装的实例属性和实例方法，通过该类被创建的对象就拥所有的实例属性和实例方法
5、自定义的实例属性
目前定义的类中的实例属性都是固定的值，每一个对象拥有的实例属性一致
实现自定义每个对象的实例属性值不一样
- 自定义实例属性语法格式
- 在通过类创建对象时，自动调用init魔法方法
- 在定义类的实例属性封装时，使用init魔法方法定义形参接收实
- 实例方法支持使用函数中任意参数
- 位置参数
- 关键字参数
- 默认参数
- 不定长位置，关键字
class Hero:
def __init__(self, name, hp, mp=0):
self.name = name
self.hp = hp
self.mp = mp
def attack(self):
print("英雄发起普通攻击")
def move(self, x, y):
print(f"执行移动英雄操作,x坐标为{x},y坐标为{y}")
def back_city(self):
print("执行英雄回城操作")
hero1 = Hero("赵云", 1000, 200)
# print(hero1.name)
# print(hero1.mp)
# print(hero1.hp)
hero1.move(300, 210)
# 创建hero2对象
# print("--" * 100)
# hero2 = Hero("刘备", 600, 100)
# print(hero2.name)
# print(hero2.mp)
# print(hero2.hp)
# print("--" * 100)
# hero3 = Hero("猪八戒", 11000)
# print(hero3.name)
# print(hero3.mp)
# print(hero3.hp)
# hero1.move()
目前封装实例属性和实例方法都是通过创建对象之后进行调用
在类中使用实例属性和实例方法：通过self进行调用
class Hero:
def __init__(self, name, hp, mp=0):
self.name = name
self.hp = hp
self.mp = mp
def attack(self):
print("英雄发起普通攻击")
def move(self, x, y):
print(f"执行移动英雄操作,x坐标为{x},y坐标为{y}")
def back_city(self):
print("执行英雄回城操作")
def a(self):
# 在类的实例方法中：使用实例属性:self.属性名
print(self.name)
def b(self):
print(f"我的英雄名字是{self.name},我的hp是{self.hp},我的mp是{self.mp}")
def c(self):
# 在类的实例方法中：使用实例方法：self.方法名()
self.attack()
hero1 = Hero("赵云", 1000, 200)
# hero1.a()
# hero1.b()
hero1.c()
注意点：如果实例属性和实例方法重名，那么只会有实例属性的存在，实例方法无效
6、类属性和类方法
class Hero:
# 类中定义的变量就是类属性
b = 88 # b就是Hero类的属性
def __init__(self, name, hp, mp=0):
# 定义在init魔法方法中的就是实例属性
self.name = name
self.hp = hp
self.mp = mp
self.a = 0
def attack(self):
print("英雄发起普通攻击")
def move(self, x, y):
print(f"执行移动英雄操作,x坐标为{x},y坐标为{y}")
def back_city(self):
print("执行英雄回城操作")
# 定义类方法：使用装饰器@classmethod
@classmethod
def c(cls): # cls当前类的名字：Hero
print("释放英雄技能")
hero1 = Hero("赵云", 1000, 200)
# 类属性对象和类都能调用
print(hero1.b) # 88
# # 类名.类属性名
print(Hero.b) # 88
# 类不能调用实例属性
print(Hero.a)
# 总结：对象可以使用实例属性和类属性，类只能使用类属性，不能调用实例属性
# 类方法和实例方法：对象可以调用实例方法和类方法，类只能使用类方法，不能调用实例方法
hero1.c()
Hero.c()
Hero.move(2, 3) # 如果类需要调用实例方法必须给一个实例对象
在类中除了实例方法和类方法还有另外一种方法叫做静态方法
# 定义静态方法:使用装饰器@staticmethod
@staticmethod
def d(): # 默认没有参数
print("给队友发信息")
# 静态方法：对象和类都可以调用
hero1.d()
Hero.d()
总结：
- 函数
- 定义在模块中具体实现的功能
- 方法
- 类中定义的函数就叫做方法，而且有不同的类型方法- 实例方法
- 第一个参数一定是self而且必带，代表对象本身
- 类方法
- 第一个参数一定是cls而且必带，代表类本身
- 静态方法
- 没有必带参数，可以通过对象和类直接调用
- 魔法方法
- 类中已经定义的方法，以双下划线开头和结尾，不需要手动调用，某种条件下自动化触发
- 实例方法
- 不管是函数还是方法共同点
- 参数的使用方法一致
- 可以使用return返回值
7、面向对象继承
继承的方式有两种类型
- 单继承
- 多继承
继承的概念：在程序中，继承的描述就是多个类之间的所属关系
- 如果一个B类继承了A类
- 那么B类会拥有A类所有的属性和方法
- A类叫做B类的父类，B类是A类的子类
单继承使用
class A:
a = 1
def __init__(self):
self.b = 2
def c(self):
print("A类中的c实例方法被调用")
@classmethod
def d(cls):
print("A类中的d类方法被调用")
class B(A): # B(继承的类名)
pass
# a1 = A()
b1 = B()
print(b1.a) # 1
print(b1.b) # 2
b1.c() # A类中的c实例方法被调用
b1.d() # A类中的d类方法被调用
使用继承可以提高代码的使用率，而且可以进行自定义的完善
习题：
# 定义一个电影类：
# 定义3实例属性（在__init__方法里面初始化实例属性，并且要求用户自己输入属性值（使用input函数获取））：
# 电影名称：name
# 电影导演：director
# 电影时长：time
# 定义3个实例方法
# 分别打印电影名称，电影导演，电影时长
# 用户手动输入属性
# 创建对象
# 调用方法
# 2. 定义程序类(coder),
# 定义工作(work)、睡觉(sleep)、幻想(imagine)方法
-------------------------------------------------------------
# 存款(money)属性
# 3. 定义小王类(xiaowang)继承自程序员类，并覆盖程序员coder的work方法
# 4. 小王类添加一个属性：公司(company),值为"程序员"
# 5. 小王类中添加show_company方法，显示属性company的值
# 所有的属性和方法的定义可以使类属性类方法也可以是实例属性和实例方法
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
