1.面向对象，理解为主
'''
面向对象
面向对象是一个编程思想（写代码的套路）
编程思想：
1.面向过程
2.面向对象
以上两种都属于写代码的套路(⽅法) ,最终⽬的都是为了将代码书写出来,只不过过程和思考⽅法不太⼀样.
面向过程：
1.关注的是具体步骤的实现，所有功能都是自己书写的
2.定义一个个函数，最终按照顺序调用函数
面向对象
1.关注的是结果，谁（对象）能帮我做这件事
2.找一个对象（），让对象去做
类和对象
面向对象的核心是找一个对象去帮我们处理事情，在程序代码中，对象是有类创建的，类和对象是面向对象编程中非常重要的两个概念
类
抽象的概念，对对个特征和行为相同或相似事物的统称
泛指的（指代多个，而不是具体的一个人）、
对象
具体存在的一个事物，看得见摸得着的
特指的（指代一个）
河豚---类
大河豚-----类
我家里的那只河豚宝宝----对象
类的组成
1.类名（给这多个事物起一个名字）
2.属性（事物的特征，即有什么，一般文字中的名词）
3.方法（事物的行为，即什么事，一般是动词）
类的抽象（类的设计）
类的抽象，其实就是找到类的类名，属性和方法
需求：
小明今年18岁，身高1.75，每天早上跑完步，回去吃东西
小美今年17岁，身高1.65，小美不跑步，小美喜欢吃东西
类名：人类（Human，People）
属性：名字（name），年龄（age），身高（height）
方法：跑步（run）吃（eat）
需求
一只黄颜色的狗狗叫大黄
看见生人汪汪叫
看见家人摇尾巴
类名：狗类（Dog）
属性：颜色（color），名字（name）
方法：汪汪叫（bark），摇尾巴（shake）
面向代码的步骤
1.定义类，在定义类之前先设计类
2.创建对象，使用第一步定义的类创建对象
3.通过对象调用方法
'''
'''
面向对象基本代码的书写
1.定义类
先定义简单的类，不包含属性，在python中定义类需要使用关键字class
方法：方法的本质是在类中定义的函数，只不过，第一个参数是self
class 类名：
#在缩进中书写的内容，都是类的代码
def 方法名（self）： #就是一个方法
pass
2.创建对象
创建对象是使用类名进行创建，即
类名（） #创建 对象，这个对象在后续不能继续使用，创建的对象想要在后续的代码中继续使用，需要使用一个变量将这个对象保存起来
变量 = 类名（） #这个变量中保存的是对象的地址，一般可以成为这个变量的对象
一个类可以创建多个对象，只要出现类名（）就是创建一个对象，每个对象的地址是不一样的
3.调用方法
对象.方法名()
列表.sort()
列表.append()
4.案例实现
需求：小猫爱吃鱼，小猫要喝水
类名：Cat
属性：无
方法：eat drink
'''
'''
class Cat:
def eat(self):
print('小猫爱吃鱼')
def drink(self):
print('小猫爱喝水')
miaomiao = Cat() #创建对象
miaomiao.eat() #通过对象调用方法
miaomiao.drink() #通过对象调用方法
'''
'''
self的说明
class Cat:
# 在缩进中书写 ⽅法
def eat(self): # self 会⾃动出现,暂不管
print('⼩猫爱吃⻥...')
black_cat.eat()
1. 从函数的语法上讲, self是形参, 就可以是任意的变量名,
只不过我们习惯性将这个形参写作 self
2. self 是普通的形参, 但是在调⽤的时候没有传递实参值,
原因是, Python 解释器在执⾏代码的时候, ⾃动的将调⽤这个
⽅法的对象 传递给了 self, 即 self 的本质是对象
3. 验证, 只需要确定 通过哪个对象调⽤, 对象的引⽤和 self
的引⽤是⼀样的
4. self 是函数中的局部变量, 直接创建的对象是全局变量
'''
'''
之间的关系
class Cat:
# 在缩进中书写 ⽅法
def eat(self): # self 会⾃动出现,暂不管
print(f'{id(self)}, self')
print('⼩猫爱吃⻥...')
# 2. 创建对象
blue_cat = Cat()
print(f'{id(blue_cat)}, blue_cat')
# 3. 通过对象调⽤类中的⽅法
blue_cat.eat() # blue_cat 对象调⽤ eat ⽅法, 解释器就
会将 blue_cat 对象传给 self
print('_*_' * 30)
# 创建对象
black_cat = Cat()
print(f"{id(black_cat)}, black_cat")
black_cat.eat() # black_cat 对象调⽤ eat ⽅法, 解释器
就会将 black_cat 对象传给 self
'''
'''
对象的属性的操作
添加属性
对象.属性名 = 属性值
类内部添加
在内部方法中，self是对象
self.属性名 = 属性值
类内部添加
在内部方法中，self是对象
self.属性名 = 属性值
#在类中添加属性一般写在__init__方法中
类外部添加
对象.属性名 = 属性值 #一般不用
获取属性
对象.属性名
类内部
在内部方法中，self是对象
self.属性名
类外部
对象.属性名 #一般很少用
'''
'''
class Cat(): #创建类
def eat(self):
print(f'{id(self)}',self)
print(f'喵喵{self.name}爱吃鱼')
jumiaomiao = Cat() #创建对象
print(f'{id(jumiaomiao)},jumiaomiao')
jumiaomiao.name = '橘猫' #给类添加属性
jumiaomiao.eat() #t通过对象调用类
print('-'*40)
baimiaomiao = Cat() #创建对象
baimiaomiao.name = '白猫'
print(f'{id(baimiaomiao)},baimiaomiao')
baimiaomiao.eat()
'''
'''
魔方方法
python 中有⼀类⽅法, 以两个下划线开头,两个下划线结尾,并
且在满⾜某个条件的情况下, 会⾃动调⽤, 这类⽅法称为 魔法⽅
法
学习:
1. 什么情况下⾃动调⽤
2. 有什么⽤, ⽤在哪
3. 书写的注意事项
__init__ ⽅法 **
1.什么情况下自动调用---创建对象后自动调用
2.有什么用，用在哪里---
给对象添加属性的, (初始化⽅法, 构造⽅法)
某些代码, 在每次创建对象之后, 都要执⾏,就可以将这⾏代码写在 __init__ ⽅法
3. 书写的注意事项，如果 init ⽅法中,存在出了 self之外的参数, 在创建对象的时候必须传参
'''
'''
class Cat:
# 定义添加属性的⽅法
def __init__(self, name, age): # 这个⽅法是创建对象之后调⽤
self.name = name # 给对象添加 name 属性
self.age = age # 给对象添加 age 属性
def show_info(self): # 输出属性信息
print(f'⼩猫的名字是: {self.name}, 年龄是:{self.age}')
blue_cat = Cat('蓝猫', 2) # 创建对象,不要在⾃⼰类缩进中创建# Cat() # 创建对象 ,会输出
blue = blue_cat
blue.show_info()
black_cat = Cat('⿊猫', 3)# Cat() # 创建对象 ,会输出
black_cat.show_info()
'''
'''
__str__ ⽅法 *
1. 什么情况下⾃动调⽤
> 使⽤ print(对象) 打印对象的时候 会⾃动调⽤
2. 有什么⽤, ⽤在哪
> 在这个⽅法中⼀般书写对象的 属性信息的, 即打印对象
的时候想要查看什么信息,在这个⽅法中进⾏定义的
> 如果类中没有定义 __str__ ⽅法, print(对象) ,默认
输出对象的引⽤地址
3. 书写的注意事项
> 这个⽅法必须返回 ⼀个字符串
'''
'''
class Cat:
def __init__(self, n, age): # 这个⽅法是创建对象 之后调⽤ # 定义添加属性的⽅法
self.name = n # 给对象添加 name 属性
self.age = age # 给对象添加 age 属性
def __str__(self):
return f'⼩猫的名字是: {self.name}, 年龄是:{self.age}'# ⽅法必须返回⼀个字符串, 只要是字符串就⾏,
blue_cat = Cat('蓝猫', 2) # 创建对象,不要在⾃⼰类缩进中创建 # Cat() # 创建对象 ,会输出
print(blue_cat)
# 创建⿊猫
black_cat = Cat('⿊猫', 3)
print(black_cat)
'''
'''
__del__ ⽅法 [了解]
_init__ ⽅法, 创建对象之后,会⾃动调⽤ (构造⽅法)
__del__ ⽅法, 对象被删除销毁时, ⾃动调⽤的(遗⾔, 处理后
事) (析构⽅法)
1. 调⽤场景, 程序代码运⾏结束, 所有对象都被销毁
2. 调⽤场景, 直接使⽤ del 删除对象(如果对象有多个名字(多
个对象引⽤⼀个对象),需要吧所有的对象都删除才⾏ )
'''
'''
class Demo:
def __init__(self, name):
print('我是 __init__, 我被调⽤了 ')
self.name = name
def __del__(self):
print(f'{self.name} 没了, 给他处理后事...')
a = Demo('a') # Demo('a')
b = Demo('b')
del a # 删除销毁 对象,
print('代码运⾏结束')
'''
'''
案例1
1.小明 体重75公斤
2.小明每次跑步会减肥0.5公斤
3.小明每次吃东西体重增加1公斤
类名: ⼈类 Person
属性: 姓名 name, 体重 weight
⽅法: 跑步 run
吃东⻄ eat
添加属性 __init__
属性信息 __str__
'''
'''
class Person:
def __init__(self, name, weight):
self.name = name
self.weight = weight
def __str__(self):
return f"姓名: {self.name}, 体重:{self.weight} kg"
def run(self):
print(f'{self.name} 跑步 5 km, 体重减少了')
self.weight -= 0.5 # 减体重, 即修改属性
def eat(self):
print(f'{self.name} ⼤餐⼀顿, 体重增加了')
self.weight += 1# 修改体重
xm = Person('⼩明', 75.0)
print(xm)
xm.run()
print(xm)
xm.eat()
print(xm)
'''
'''
# 定义家具类 封装案例
class HouseItem: # """家具类"""
def __init__(self, name, area): # """添加属性的方法"""
self.name = name
self.area = area
def __str__(self):
return f'家具名字{self.name}, 占地面积 {self.area} 平米'
class House: # 房子类
def __init__(self,name,area):
self.name = name# 户型
self.total_area= area # 总面积
self.free_area =area # 剩余面积
self.item_list = [] # 家具名称列表
def __str__(self):
return f"户型: {self.name}, 总面积:{self.total_area}平米, 剩余面积:{self.free_area} 平米, " \
f"家具名称列表: {self.item_list}"
def add_item(self, item): # item 表示的家具的对象
if self.free_area > item.area: # 判断房子的剩余面积(self.free_area)和家具的占地面积(item.area)之间的关系 # self 表示的 房子对象, 缺少一个家具对象使用传参解决
self.item_list.append(item.name) # 添加家具, ---> 向列表中添加数据
self.free_area -= item.area # 修改剩余面积
print(f'{item.name} 添加成功')
else:
print('剩余面积不足, 换个大房子吧')
# 创建家具对象
bed = HouseItem('席梦思', 4)
chest = HouseItem('衣柜', 2)
table = HouseItem('餐桌', 1.5)
print(bed)
print(chest)
print(table)
# 创建房子对象
house = House('三室一厅', 150)
print(house)
# 添加 床
house.add_item(bed)
print(house)
'''
'''
class LoginPage:
def __init__(self, username, password, code):
self.username = username
self.password = password
self.code = code
self.btn = '登录'
def login(self):
print(f'1. 输入用户名 {self.username}')
print(f'2. 输入密码 {self.password}')
print(f'3. 输入验证码 {self.code}')
print(f"4. 点击按钮 {self.btn}")
login = LoginPage('admin', '123456', '8888')
login.login()
'''
'''
私有和公有
1. 在 Python 中定义的方法和属性, 可以添加访问控制权限(即在什么地方可以使用这个属性和方法)
2. 访问控制权限分为两种, 公有权限, 私有权限
3. 公有权限
> 直接书写的方法和属性, 都是公有的
> 公有的方法和属性, 可以在任意地方访问和使用
4. 私有权限
> 在类内部, 属性名或者方法名 前边加上两个 下划线 , 这个属性或者方法 就变为 私有的
> 私有的方法和属性, 只能在当前类的内部使用
5. 什么时候定义私有
> 1. 某个属性或者方法,不想在类外部被访问和使用, 就将其定义为私有即可
> 2. 测试中,一般不怎么使用, 直接公有即可
> 3. 开发中,会根据需求文档, 确定什么作为私有
6. 如果想要在类外部操作私有属性, 方法是, 在类内部定义公有的方法, 我们通过这个公有方法去操作
# 补充:
# 对象.__dict__ 魔法属性, 可以将对象具有的属性组成字典返回
'''
'''
#定义一个 Person 类, 属性 name, age(私有)
class Person:
def __init__(self, name, age):
self.name = name # 姓名 私有的本质, 是 Python 解释器执行代码,发现属性名或者方法名前有两个_, 会将这个名字重命名 会在这个名字的前边加上 _类名前缀,即 self.__age ===> self._Person__age
self.__age = age # 年龄, 将其定义为私有属性, 属性名前加上两个 _
def __str__(self): # 在类内部可以访问私有属性的
return f'名字: {self.name}, 年龄: {self.__age}'
xm = Person('小明', 18)
print(xm)
# 在类外部直接访问 age 属性
# print(xm.__age) # 会报错, 在类外部不能直接使用私有属性
# 直接修改 age 属性
xm.__age = 20 # 这个不是修改私有属性, 是添加了一个公有的属性 __age
print(xm)# 名字: 小明, 年龄: 18
print(xm._Person__age)# 能用但是不要用 18
xm._Person__age = 19
print(xm) # 名字: 小明, 年龄: 19
'''
'''
继承
1. 继承描述的是类与类之间的关系
2. 继承的好处: 减少代码的冗余(相同的代码不需要多次重复书写), 可以直接使用
语法
# class A(object):
class A: # 没有写父类,但也有父类, object, object 类是 Python 中最顶级(原始)的类
pass
class B(A): # 类 B, 继承类 A
pass
术语:
1. A 类, 称为是 父类(基类)
2. B 类, 称为是 子类(派生类)
单继承: 一个类只继承一个父类,称为单继承
继承之后的特点:
> 子类(B)继承父类(A)之后, 子类的对象可以直接使用父类中定义的公有属性和方法
案例
1. 定义一个 动物类, 吃
2. 定义一个 狗类, 继承动物类, 吃, 叫
3. 定义一个 哮天犬类, 继承 狗类
'''
'''
# 1. 定义一个 动物类, 吃
class Animal:
def eat(self):
print('要吃东西')
# 2. 定义一个 狗类, 继承动物类, 吃, 叫
class Dog(Animal):
def bark(self):
print('汪汪汪叫....')
# 3. 定义一个 哮天犬类, 继承 狗类
class XTQ(Dog):
pass
# 创建 动物类的对象
# ani = Animal()
# ani.eat()
# 创建狗类对象
# dog = Dog()
# dog.eat() # 调用父类中的方法
# dog.bark() # 调用自己类中方法
# 创建哮天犬类对象
xtq = XTQ()
xtq.bark() # 调用 父类 Dog 类的方法
xtq.eat() # 可以调用 父类的父类中的方法
'''
'''
python 中 对象.方法() 调用方法
1. 现在自己的类中的去找有没有这个方法 如果有,直接调用
2. 如果没有去父类中 查找, 如果有,直接调用
3. 如果没有, 去父类的父类中查找, 如果有直接调用
4 ...
5. 如果 object 类中有,直接调用, 如果没有,代码报错
'''
'''
重写
重写: 在子类中定义了和父类中名字相同的方法, 就是重写
重写的原因: 父类中的方法,不能满足子类对象的需求,所以重写
重写之后的特点: 调用子类字节的方法, 不再调用父类中的方法
重写的方式:
>1. 覆盖(父类中功能完全抛弃,不要,重写书写)
>2. 扩展(父类中功能还调用,只是添加一些新的功能) (使用较多)
覆盖
1. 直接在子类中 定义和父类中名字相同的方法
2. 直接在方法中书写新的代码
'''
'''
class Dog:
def bark(self):
print('汪汪汪叫.....')
class XTQ(Dog): # XTQ 类bark 方法不再是汪汪汪叫, 改为 嗷嗷嗷叫
def bark(self):
print('嗷嗷嗷叫...')
xtq = XTQ()
xtq.bark()
'''
#扩展父类中的功能
'''
1. 直接在子类中 定义和父类中名字相同的方法
2. 在合适的地方调用 父类中方法 super().方法()
3. 书写添加的新功能
'''
'''
class Dog:
def bark(self):
print('汪汪汪叫.....')
print('汪汪汪叫.....')
class XTQ(Dog): #XTQ 类bark 方法不再是汪汪汪叫, 改为 # 1. 先 嗷嗷嗷叫(新功能) 2, 汪汪汪叫(父类中功能) 3. 嗷嗷嗷叫 (新功能)
def bark(self):
print('嗷嗷嗷叫...') # 调用父类中的代码
super().bark() # print() 如果父类中代码有多行呢?
print('嗷嗷嗷叫...')
xtq = XTQ()
xtq.bark()
'''
'''
多态[了解]
1. 是一种写代码,调用的一种技巧
2. 同一个方法, 传入不同的对象, 执行得到不同的结果, 这种现象称为是多态
3. 多态 可以 增加代码的灵活度
--------
哪个对象调用方法, 就去自己的类中去查找这个方法, 找不到去父类中找
属性和方法
Python 中一切皆对象.
即 使用 class 定义的类 也是一个对象
对象的划分
实例对象(实例)
1. 通过 类名() 创建的对象, 我们称为实例对象,简称实例
2. 创建对象的过程称为是类的实例化
3. 我们平时所说的对象就是指 实例对象(实例)
4. 每个实例对象, 都有自己的内存空间, 在自己的内存空间中保存自己的属性(实例属性)
类对象(类)
1. 类对象 就是 类, 或者可以认为是 类名
2. 类对象是 Python 解释器在执行代码的过程中 创建的
3. 类对象的作用: ① 使用类对象创建实例 类名(), ② 类对象 也有自己的内存空间, 可以保存一些属性值信息
(类属性)
4. 在一个代码中, 一个类 只有一份内存空间
'''
'''
属性的划分
实例属性
概念: 是实例对象 具有的属性
定义和使用
在 init 方法中, 使用 self.属性名 = 属性值 定义
在方法中是 使用 self.属性名 来获取(调用)
内存
实例属性,在每个实例中 都存在一份
使用时机
1. 基本上 99% 都是实例属性,即通过 self 去定义
2. 找多个对象,来判断这个值是不是都是一样的, 如果都是一样的, 同时变化,则一般定义为 类属性, 否则定义
为 实例属性
'''
'''
类属性
概念: 是 类对象 具有的属性
定义和使用
在类内部,方法外部,直接定义的变量 ,就是类属性
使用: 类对象.属性名 = 属性值 or 类名.属性名 = 属性值
类对象.属性名 or 类名.属性名
内存
只有 类对象 中存在一份
方法的划分
方法, 使用 def 关键字定义在类中的函数就是方法
实例方法(最常用)
定义
# 在类中直接定义的方法 就是 实例方法
class Demo:
def func(self): # 参数一般写作 self,表示的是实例对象
pass
定义时机(什么时候用)
如果在方法中需要使用实例属性(即需要使用 self), 则这个方法必须定义为 实例方法
调用
对象.方法名() # 不需要给 self 传参
类方法(会用)
定义
# 在方法名字的上方书写 @classmethod 装饰器(使用 @classmethod 装饰的方法)
class Demo:
@classmethod
def func(cls): # 参数一般写作 cls, 表示的是类对象(即类名) class
pass
定义时机(什么时候用)
1. 前提, 方法中不需要使用 实例属性(即 self)
2. 用到了类属性, 可以将这个方法定义为类方法,(也可以定义为实例方法)
调用
# 1. 通过类对象调用
类名.方法名() # 也不需要给 cls 传参, python 解释器自动传递
# 2. 通过实例对象调用
实例.方法名() # 也不需要给 cls 传参, python 解释器自动传递
'''
'''
静态方法(基本不用)
定义
# 在方法名字的上方书写 @staticmethod 装饰器(使用 @staticmethod 装饰的方法)
class Demo:
@staticmethod
def func(): # 一般没有参数
pass
定义时机(什么时候用)
1. 前提, 方法中不需要使用 实例属性(即 self)
2. 也不使用 类属性, 可以将这个方法定义为 静态方法
调用
# 1. 通过类对象调用
类名.方法名()
# 2. 通过实例对象调用
实例.方法名()
'''
'''
#练习 1 定义一个 Dog 类, 定义一个类属性 count,用来记录创建该类对象的个数. (即每创建一个对象,count 的值就要加1)实例属性 name
class Dog: # 定义类属性
count = 0
def __init__(self, name): # 定义实例属性, init 方法中
self.name = name # 实例属性
Dog.count += 1 # 因为每创建一个对象,就会调用 init 方法, 就将个数加 1 的操作,写在 init 方法中
print(Dog.count) # 0 # 在类外部 # 打印输出目前创建几个对象
dog1 = Dog('小花') # 创建一个对象
# 打印输出目前创建几个对象
print(Dog.count) # 1
dog2 = Dog # 不是创建对象, 个数不变的
dog3 = dog1 # 不是创建对象, 个数不变的
print(Dog.count) # 1
dog4 = Dog('大黄') # 创建一个对象 , 个数 + 1
print(Dog.count) # 2
dog5 = Dog('小白')
print(Dog.count) # 3
# 补充, 可以使用 实例对象.类属性名 来获取类属性的值 (原因, 实例对象属性的查找顺序, 先在实例属性中找,找到直接使用
# 没有找到会去类属性中 找, 找到了可以使用, 没有找到 报错)
print(dog1.count) # 3
print(dog4.count) # 3
print(dog5.count) # 3
'''
'''
补充
哈希（hash）: 是一个算法， 可以对数据产生一个唯一的值（指纹）
is 可以用来判断两个对象是不是同一个对象，即 两个对象的引用是否相同
a is b === > id(a) == id(b)
面试中可能会问： is 和 == 的区别？
== 只判断数据值是否相同， is 判断引用是否相同
'''
'''
import random
class Game: # 类属性, 游戏的最高分
top_score = 0
def __init__(self, name): # 定义实例属性 name
self.name = name
def show_help(self):
print('这是游戏的帮助信息')
def show_top_score(self):
print(f'游戏的最高分为 {Game.top_score}')
def start_game(self):
print(f'{self.name} 开始一局游戏, 游戏中 ...,', end='')
score = random.randint(10, 100) # 本次游戏的得分
print(f'本次游戏得分为 {score}')
if score > Game.top_score: # 修改最高分
Game.top_score = score
xw = Game('小王')
xw.start_game()
xw.show_top_score()
xw.start_game()
xw.show_top_score()
xw.show_help()
'''
2.明日计划，开始selenum学习
扫一扫
437
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
