面向对象学习笔记

面向对象学习笔记
–一.面向对象（OPP)基本概念
–面向过程和面向对象是两种编写方式
–面向对象是更大的职责，根据职责在一个对象中封装更多的方法
–2.根据职责确定不同的对象，在对象内部封装不同的方法
–3.最后完成代码，让不同的对象调用不通过的方法
–二.类和对象的概念
–类是一个具有相同特征或者相同事物的方法
–对象是有类差构建出来的具体存在的事物
–先有类，再有对象
–类和对象的分类
–不同的对象之间属性可能有所不同
–3.类的设计
–1.类名 这类食物的名字，满足大驼峰命名法
–大驼峰命名法：每个单词的首字母大写，单词与单词之间没有下划线
–2.属性 这类事物具有什么样的特征
–3.和类事物之间具有什么样的行为
–3.1命名的确定
–对对象的特征描述，可以定义为属性
–对象就有行为
–面向对象基础语法
–目标
–dir内置函数
–1.__new__方法 创建对象时，会被自动调用
–2.__init__方法 对象被初始化时，会被自动调用
–3.__del__方法 对象被从内存中销毁时会被自动调用
–4.__str__方法 返回对象的描述信息，print函数输出使用
–2定义简单的类
–语法格式
–class 类名：
–def 方法1（self,参数列表):
–pass
–def 方法2(self,参数列表）：
–pass
–创建对象
–对象变量=类名（）
–2.3 第一个面向对象程序
–需求
–小猫爱吃鱼，小猫要喝水
–分析
–1.定义一个毛类：Cat
–2.定义两个方法eat和drink
–3.按照需求–不需要定义属性
–例子
class Cat:
def eat(self):
print(‘小猫爱喝水’)
def drink(self):
print(‘小猫要喝水’)
#创建猫对象
tom=Cat()
tom.eat()
tom.drink()
–在python中 ‘%d’可以以十进制输出数字，’%x’可以以十六进制输出数字

–3.方法中的self属性
–在方法内部，
–可以通过self.调用对象的属性
–也可以通过self.调用其他的对象方法
–4.初始化方法
–当使用类名（）创建爱你对象时，会自动执行以下操作
–1.为对象在内存中分配空间–创建对象
–2.为对象的属性设置初始值–初始化方法（init)
–这个初始化方法就是__init__方法，__init__是对象的内置方法
–使用类名（）加2对象时会自动进行初始化方法
–4.3 在初始化方法内部定义属性
–在__init__方法内部
–4.4改在初始化方法
class Cat:
def init(self,name):
print(‘这是一个初始化方法’)
self.name=name
def eat(self):
print(’%s 爱吃鱼’% self.name)
tom=Cat(‘鲨鱼’)
tom.eat()

–5.内置方法和属性
–__del__方法
–必须返回字符串
class Cat:
def init(self,new_name):
self.name=new_name
print(’%s 来了’ %self.name)
def del(self):
print(’%s 去了’% self.name)
tom=Cat(‘tom’)
del tom
–6.__str__方法
class Cat:
def init(self,new_name):
self.name=new_name
print(’%s 来了’ %self.name)
def del(self):
print(’%s 去了’% self.name)

def __str__(self):
    #必须返回一二字符串
    return '我是小猫[%s]'%self.name

tom=Cat(‘tom’)
print(tom)

–面向对象封装案例
–1.封装是面向对象编程的一大特点
–2.面向对象编程的第一步–将属性和方法封装在一个抽象的类中
–3.外界实用类创建对象，然后让对象调用方法
–4.对象方法的细节都被封装在细节内
class Person:
def init(self,name,weight):
self.name=name
self.weight=weight
def str(self):
return ‘我的名字叫%s,体重是%.2f 公斤’%(self.name,self.weight)
def run(self):
self.weight -= 0.5
print(’%s爱跑步,跑完步体重为%s’% (self.name,self.weight))
self.weight -=0.5
def eat(self):
self.weight += 0.5
print(’%s是吃货,吃完后的体重为%s’%( self.name,self.weight))

xiaoming=Person(‘小明’,75.0)
xiaoming.run()
xiaoming.eat()
print(xiaoming)

#小敏爱跑步
xiaomin=Person(‘小敏’,45)
xiaomin.run()
xiaomin.eat()
print(xiaomin)
print(xiaoming)

–房子案例
class HouseItem:
def init(self,name,area):
self.name=name
self.area=area
def str(self):
return ‘[%s]占地%.2f’%(self.name,self.area)

class House:
def init(self,house_type,house_area):
self.house_type=house_type
self.house_area=house_area
#剩余面积
self.free_area=self.house_area
#家具名称列表
self.item_list=[]
def str(self):
return ‘户型：%s\n总面积 ：%.2f[剩余：%.2f]\n家具：%s’
%(self.house_type,self.house_area,self.free_area,self.item_list)
def add_item(self,item):
print(‘要添加%s’% item)
#1.判断家具的面积
if item.area>self.free_area:
print(’%s 太大了，无法添加’%item.name)

    #2.将家具添加到列表中
    self.item_list.append(item.name)
    #2.计算剩余面积
    self.free_area-=item.area

#创建家具
bed=HouseItem(‘席梦思’,4)
chest=HouseItem(‘衣柜’,2)
table=HouseItem(‘餐桌’,1.5)
#print(bed,chest,table)

#创建新房子
my_house=House(‘两室一厅’,60)

my_house.add_item(bed)
my_house.add_item(chest)
my_house.add_item(table)
print(my_house)

–面向对象封装案例
–士兵突击案例
–在python中，针对None进行比较时，建议使用 is 判断

–私有属性和私有方法
–私有对象就是对象不希望公开的属性
–私有方法就是队形不希望公开的方法

–私有属性在外界不能被直接访问

class Woman:
def init(self,name):
self.name=name
self.__age=18
def secret(self):
print(’%s 的年龄为%d’%(self.name,self.__age))
woman=Woman(‘小芳’)

woman.secret()

–伪私有属性和私有方法
–python中并没有正真意义的私有

–继承
–面向对象的三大特性
–封装：根据职责将属性和方法封装到一个抽象的类中
–继承：实现代码的复用，相同的代码不需要重复的编写
–多态：不同的对象调用相同的方法，产生不同的执行结果，增加代码的灵活度
–继承的语法
class 类名（父类名）：
pass

–专业术语
–dog是animal的子类，animal是dog的父类，dog类是animal类的继承
–dog类是animal类的派生类，animal类是dog类的基类，dog是animal类的派生

–3.继承的传递性
–子类拥有父类以及父类的父类中封装的所有属性和方法

–方法的重写
–子类享用父类的所有方法和属性
–当父类的方法实现不能满足子类的需要时，可以对方法进行重新编写
–重写父类方法有两种情况
–1.覆盖父类方法
–2.对父类方法进行扩展
–1在子类中，重写了父类的方法，会调用子类中重写的方法
–2在需要的位置使用super.父类方法来调用父类方法的执行
–代码其他的位置针对子类的需求，编写子类特有的代码进行实现
–关于super
–在python中super是一个特殊的类
–super()就是使用super类创建出来的对象
–最常使用的场景就是早重写父类方法时，调用在父类方法中封装的方法实现
–例子
class Animal:
def eat(self):
print(‘chi’)
def drink(self):
print(‘he’)
def run(self):
print(‘run’)
def sleep(self):
print(‘shui’)
#继承
class Dog(Animal):
def bark(self):
print(‘jiao’)
class Xiaotinaquan(Dog):
def fly(self):
print(‘fei’)
def bark(self):
#1.正对子类特有的方法，编写代码
print(‘神一样的叫唤’)
#2.使用super().调用原本在父类中分装的方法
super().bark()
#注意，如果使用子类调用方法，会出现递归调用–死循环
#Dog.bark(self)
#3.增加其他子类的代码
print(’#@%^ %^%% ’)
class Cat(Animal):
def catch(self):
print(‘miaomiao’)
animal=Xiaotinaquan()
animal.eat()
animal.bark()
animal.fly()

cat=Cat()
cat.catch()

–父类中的私有方法和私有属性
class A:
def init(self):
self.num1=100
self.__num2=200
def __test(self):
print(‘私有方法%d%d’%(self.num1,self.__num2))

class B(A):
def demo(self):
#1.访问父类的私有属性
print(‘访问父类的私有属性%d’%(self.__num2))
#2.调用父类的私有方法
self.__test()
pass
#创建一个子类对象
b=B()
b.demo()
#在外界不能直接调用私有犯法和私有属性
print(b.num1)
#print(b.__num2)
#b.__test()

–多继承
–子类可以拥有多个父类，并且具有所有父类的属性和方法
–语法：
class 子类名（父类名1，父类名2，…)
pass
–使用多继承的注意事项
–如果不同的父类中存在同名的方法，子类对象在调用方法时，会调用哪一个方法呢
–提示，在分开发时应该尽量避免这种容易产生混淆的情况，如果父类方法中存在同名的属性或方法，应该尽量避免使用多继承
class A :
def test(self):
print(‘A—test方法’)
def demo(self):
print(‘A—demo方法’)

class B:
def test(self):
print(‘B—test方法’)
def demo(self):
print(‘B—demo方法’)
class C(B,A):
pass
c=C()
c.test()
c.demo()

–python中的MRO–方法顺序搜索
–在python中针对类提供了一个内置属性 mro 可以查看方法搜索顺序
–MRO 是method resolution order ，主要用于在都继承判断的方法，属性的调用路径
print(C.mro)

–新式类与旧式类
–object为所有对象提供一个基类，提供一些内置的属性和方法，可以使用dir函数查看
–新式类 以object为基类的类，推荐使用
–为保证能够在python2和3中运行，建议统一继承自object
class 类名(object)
pass

–多态
–多态：不同的子类调用相同的父类方法，产生不同的执行效果
–多态可以增加代码的灵活度
–以继承和重写父类方法为前提
–是调用方法的技巧，不会影响到类的内部设计

–类的结构
–创建出来的对象叫做类的实例
–创建对象的动作叫做实例化
–对象的属性叫做实例属性
–对象调用的方法叫做实例方法
–1.2类是一个特殊的对象

–类属性
class Tool(object):
count=0
def init(self,name):
self.name=name
#让类的属性加1
Tool.count+=1
tool1=Tool(‘斧头’)
tool2=Tool(‘榔头’)
tool3=Tool(‘水桶’)
print(Tool.count)
print(‘工具对象总数%d’%Tool.count)

–类方法和静态方法
–类方法就是正对类对象定义的方法
–在类方法内部可以直接访问类属性或者调用其他的类方法
–语法：
@classmethod
def 类方法(cls):
pass
–类方法需要使用修饰器@classmethod来标示，告诉解释器这是一个类方法
–类方法的第一个参数应该是cls

–例子
class Tool(object):
count=0
@classmethod
def show_tool_count(cls):
print(‘工具对象的数量%d’%cls.count)
def init(self,name):
self.name=name
#让类的属性加1
Tool.count+=1
tool1=Tool(‘斧头’)
tool2=Tool(‘榔头’)
tool3=Tool(‘水桶’)
#调用类方法
Tool.show_tool_count()
#print(Tool.count)
#print(‘工具对象总数%d’%Tool.count)

–静态方法
–在开发中，如果需要在类中分装一个方法，这个方法：既不需要访问实例属性或者调用实例方法，也不需要访问类属性或者调用类方法
–在这个时候就可以分装成静太方法
–语法
@staticmethod
def 静态方法名():
pass
–静态方法名需要修饰器@staticmethod 来表示，告诉解释器这是一个静态方法
–通过类名调用静态名
class Dog(object):
dog_count=0
@staticmethod
def run():
print(‘狗仔跑’)

#通过类名调用静太方法
Dog.run()

–案例
class Game(object):
#历史最高分
top_score=0
def init(self,player_name):
self.player_name=player_name
@staticmethod
def help():
print(‘帮助信息，让僵尸进入大门’)
#类方法
@classmethod
def show_top_score(cls):
print(‘显示历史最高分%d’% cls.top_score)
#实例方法
def start_game(self):
print(’%s 开始游戏啦。。。’% self.player_name)
#1.查看游戏的帮助信息
Game.help()
#2.查看历史最高分
Game.show_top_score()
#创建游戏对象
game=Game(‘小敏’)
game.start_game()

–案例小结
–1.实例方法：方法内部需要访问实例属性
–实例方法：内部可以使用类名，访问类属性
–2.类方法：方法内部只需访问类属性
–3.静态方法：方法内部，不需要访问实力属性和类属性

–单例
–单例设计模式
–__nuw__方法
–单例设计模式
–目的–让类创建对象，在系统中只有唯一一个实例
–每次执行类名()返回对象，内存地址是相同的
–单例模式的应用场景
–音乐播放对象
–回收站对象。。。
–__new__方法
–__new__方法是由object基类提供的内置静态方法，主要作用有：–1.在内卒中为对象分配空间2.返回对象的引用
–重写__new__方法的代码非常固定
–重写__new__方法一定要return super().new(cls)
–否则python解释器得不到分配子空间的应用对象，就不会调用兑现的初始化方法
–静太方法需要调用cls传递参数
#__new__方法
class MusicPlayer:
def new(cls, *args, **kwargs):
print(‘开始’)
sup=super().new(cls)
return sup
def init(self):
print(‘音乐播放器’)
player=MusicPlayer()
print(player)

–python中的单例
–1.定义一个类，初始化为None
class MusicPlayer(object):
#记录第一个被创建对象的引用
instance=None
def new(cls, *args, **kwargs):
#1.判断类属性是否为空对象
if cls.instance is None:
#2.调用父类的方法，为第一个对象分配空间
cls.instance=super().new(cls)
#3.返回类属性保存的对象引用
return cls.instance

player1=MusicPlayer()
print(player1)
player2=MusicPlayer()
print(player2)

–只执行一次初始化工作
–让初始化的动作只被执行一次
–解决办法：
–1.定义一个类属性init_flag标记是否执行过初始化动作，初始值为false
–2.在__init__方法中，判断init_flag,如果为false就执行初始化动作
–3.然后在init_flag设置为true
–4.这样再次调用__init__方法时，初始化动作就不再被执行了

–异常

–程序运行时，如果python解释器遇到一个错误，就会停止并抛出一个错误信息，这就是异常
–程序停止并抛下一个错误信息这个动作，我们称之为抛出异常
–捕获异常
–语法
try:
尝试执行的代码
except:
出现错误的出处

–多异常错误
try:
num=int(input(‘请输入一个整数：’))
result=8/num
print(result)
except ZeroDivisionError :
print(‘除0错误’)
except ValueError:
print(‘输入类型错误’)

–捕获未知异常
如果希望程序无论出现任何错误都不会应为python解释器抛出异常而被终止，可以再增加一个expext
–语法
expect Exception as result:
print(‘未知错误%s’% result)
–例子
try:
num=int(input(‘请输入一个整数：’))
result=8/num
print(result)
except ZeroDivisionError :
print(‘除0错误’)
except ValueError:
print(‘输入类型错误’)
except Exception as result:
print(‘未知错误 %s’% result)

–异常捕获的完整语法
–else 只有在没有异常时才会执行
–finally 无论是否有异常，都会执行的代码

try:
num=int(input(‘请输入一个整数：’))
result=8/num
print(result)
except ZeroDivisionError :
print(‘除0错误’)
except ValueError:
print(‘输入类型错误’)
except Exception as result:
print(‘未知错误 %s’% result)
else:
print(‘执行成功’)
finally:
print(‘无论是否出现错误都会被执行’)
print(’-’*50)

–异常的传递
可以在主程序中增加捕获异常的代码

–抛出异常
–创建一个异常对象函数Exception异常类
–在开发时，如果满足特定也无需求时，希望抛出异常，可以：
–1.创建一个Expection函数，提示用户输入密码
–2.如果用户输入密码长度小于八，抛出异常
–3，如果大于等于八，则返回密码
#主动跑出异常
def input_password():
psd=input(‘请输入密码：’)
#。返回合适的代码
if len(psd)>=8:
return psd
#2.跑出代码异常
print(‘代码异常’)
#1.定义代码异常的类
exp=Exception(‘输入的代码长度不够’)
raise exp
try:
ipd=input_password()
print(ipd)
except Exception as result:
print(result)

–__name__属性
–__name__属性可以做到，测试模块的代码只在测试情况下运行
–例子
def main():
pass
pass
#根据__name__判断是否执行
if name==‘main’:
main()

–包(package)
–概念
–包是一个包含多个模块的特殊目录
–目录下有一个特殊文件__init__.py
–目录的命名方式和百年两名一致，小写字母+ _
–好处：
–使用import 包名 可以一次性导入保重所有的模块
–init.py
–要在外界使用包中的模块，要在__init__.py中指定对外界提供的模块列表
–from . import send_message
–from . import receive_message

–压缩模块
–3.1制作发布压缩包步骤
–1.创建setup.py
from distutils .core import setup
setup(name=‘hm_message’,
version=‘1.0’,
description=“itheima’s 发布和接收消息模块”,
long_description=‘完整的发送和接收消息的模块’,
author=‘itheima’,
author_email=‘itheima@163.com’,
url=‘www.itheima.com’,
py_modules=[‘hm_message.send_message’,
‘hm_message.receive_message’])
–2.构建模块
–打开所在文件夹的终端
$ python3 setup.py build

–3.生成发布压缩包
$ python3 setup.py sdist

–安装模块
$ tar -zxvf hm_message-10.tar.gz
$ sudo python3 setup.py install

–卸载模块
–直接从安装目录下，把安装模块的目录删除
–首先确定安装的地址
在ipython中打开
import hm_message
hm_message.file
‘/home/hadhad/hm_message-1.0/hm_message/init.py’
–确定安装的地址，打开
cd /home/hadhad/hm_message-1.0/hm_message
删除目录
sudo rm -r hm_message

–pip 安装及卸载
sudo pip install 模块名
sudo pip uninstall 模块名