1 面向过程和面向对象(oop:object oriented programming)
面向过程：—侧重于怎么做？
1.把完成某一个需求的 所有步骤 从头到尾 逐步实现
2.根据开发要求，将某些功能独立的代码封装成一个又一个函数
3.最后完成的代码，就是顺序的调用不同的函数
特点：
1.注重步骤和过程，不注重职责分工
2.如果需求复杂，代码变得非常复杂
3.开发复杂的项目的时候，没有固定的套路，开发难度很大
面向对象：----侧重于谁来做？
相比较函数，面向对象是更大的封装，根据职责在一个对象中封装多个方法
1.在完成某一个需求前，首先确定职责–要做的事(方法)
2.根据职责确定不同的对象，在对象内部封装不同的方法(多个)
3.最后完成代码，就是顺序的让不同的对象调用不同的方法
特点：
1.注重对象和职责，不同的对象承担不同的职责
2.更加适合对复杂的需求变化，是专门应对复杂项目的开发，提供固定的套路
3.需要在面向过程的基础上，再学习一些面向对象的语法
面向对象的两个核心概念
类：是一类具有相同特征或行为的事物的一个统称
对象：由类创建出来的一个具体的存在
类和对象的关系：先有类再有对象
类是模板 对象是根据这个模板创建出来的
类只需要有一个 对象可以有多个
类：属性(这一类事务的共同信息) 和 方法(你能完成的动作)
1.类名：这类事物的名字(大驼峰命名法)
大驼峰命名法：
1.每个单词的首字母大写
2.单词与单词之间没有下划线
2.属性:这个类创建出来的对象有什么特征
3.方法:这个类创建出来的对象有什么行为
类名的确定
名词提炼法分析整个业务流程，出现的名词，通常就是找到的类
属性和方法的确定
对 对象的特征描述，通常可以定义成属性
对象具有的行为(动词)，通常可以定义为方法
提示：需求中没有涉及的属性或方法在设计类时，不需要考虑
self
哪一个对象调用的方法，self就是哪一个对象的引用(指向对象的内存地址空间)
在调用方法的时候 程序员不需要传递self参数(定义的时候 第一个参数必须是self)
# 定义一个类
class Cat:
def eat(self):
print('%s 爱吃鱼' %(self.name))
def drink(self):
print('猫要喝水')
hellokitty = Cat()
hellokitty.name = 'HK'
hellokitty.eat()
hellokitty.drink()
hellokitty1 = Cat()
hellokitty1.eat()初始化方法
类名() 就可以创建一个对象
类名() 创建对象的时候，python解释器会自动执行以下操作
1.为对象在内存中分配空间–创建对象
2.调用初始化方法为对象的属性设置初始值
这个初始化方法是内置方法，是专门用来定义一个类据有哪些属性和方法的
class Cat:
def __init__(self,name):
self.name = name
print('这是一个初始化方法')
def eat(self):
print('%s 爱吃鱼' %(self.name))
def drink(self):
print('猫要喝水')
tom = Cat('Tom')
tom.eat()
print(tom)
hk = Cat('Hellokitty')
hk.eat()
str
str：在python中 使用print输出对象变量时候，默认情况下
会输出这个变量引用的对象是由哪一个类创建的对象以及在内存中的地址
如果在开发中，希望使用print输出变量的时候，能够打印自定义内容
就可以利用__str__这个内置的方法了
class Cat:
def __init__(self,name):
self.name = name
def __str__(self):
# 返回必须是一个字符串
return '我是 %s' %(self.name)
tom = Cat('Tom')
print(tom)
print(tom.name)
addr = id(tom)
print(addr)
# 十六进制
print('%x' %(addr))
# 十进制
print('%d' %(addr))del
del：如果希望在对象被销毁之前，再做一些事情，可以考虑一下__del__
当一个对象被从内存中销毁前(把这个对象从内存中删除掉)，会自动调用 __del__方法
class Cat:
def __init__(self,name):
self.name = name
print('%s 来了' %(self.name))
def __del__(self):
print('%s 走了' %(self.name))
tom = Cat('tom')
print(tom.name)
print('*' * 50)
del tom
print(tom.name)封装
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):
print('%s 去跑步' %(self.name))
self.weight -= 0.5
def eat(self):
print('%s 去吃东西' %(self.name))
self.weight += 1
xiaoming = Person('小明',75.5)
xiaoming.run()
xiaoming.eat()
print(xiaoming)
xiaomei = Person('小美',45)
xiaomei.eat()
xiaomei.run()
print(xiaomei)
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,area):
self.house_type = house_type
self.area = area
# 剩余面积
self.free_area = area
self.item_list = []
def __str__(self):
return '户型:%s,\n总面积:%.2f[剩余:%.2f]\n家具:%s'\
%(self.house_type,self.area,self.free_area,self.item_list)
def add_item(self,item):
# 1.判断家具的面积
if item.area > self.free_area:
print('%s的面积太大了，无法添加' %(item.name))
return
# 将家具的名称添加到列表中
self.item_list.append(item.name)
# 计算剩余面积
self.free_area -= item.area
# 创建家具
bed = HouseItem('床',600)
print(bed)
chest = HouseItem('chest',2)
print(chest)
table = HouseItem('桌子',4.5)
print(table)
# 创建房子对象
my_home = House('三室两厅',200)
# 将家具添加到房子里面去
my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)
print(my_home)继承
继承具有传递性
当父类方法的实现不能满足子类的需求的时候
可以对父类方法进行重写
1.覆盖父类方法
2.对父类的方法进行扩展
class Animal:
def eat(self):
print('吃！！！')
def drink(self):
print('喝！！！')
def run(self):
print('跑！！！')
def sleep(self):
print('睡！！！')
class Cat(Animal):
# def eat(self):
# print('吃！！！')
# def drink(self):
# print('喝！！！')
# def run(self):
# print('跑！！！')
# def sleep(self):
# print('睡！！！')
def call(self):
print('喵喵！！')
class Hellokitty(Cat):
def speak(self):
print('我可以说话')
def call(self):
# 调用原本在父类中封装的方法
super().call()
# Cat.call(self) python2.x
# 针对子类特有的需求 编写代码
print('#%@@#$#@%')
class Dog(Animal):
pass
cat = Hellokitty()
cat.eat()
cat.drink()
cat.run()
cat.call()
dog = Dog()
dog.run()
dog.eat()
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(A,B):
pass
c = C()
c.test()
c.demo()新式类和旧式(经典)类：
object是Python为所有对象提供的基类，提供有一些内置的属性和方法，可以使用dir函数查看
新式类：以object为基类的类
经典类 不以object为基类的类
在python3.X中定义的类时，如果没有指定父类，会默认使用object作为基类–python3.x中定义的类都是新式类
在python2.x中定义类时，如果没有指定父类，则不会以object作为基类
为保证编写的代码能够同时在python2.x和python3.x运行
今后在定义类时，如果没有父类，建议统一继承自object
class Bird(object):
def __init__(self):
self.hungry = True
def eat(self):
if self.hungry:
print('$$@#%@%')
self.hungry = False
else:
print('No thanks')
class SongBird(Bird):
def __init__(self):
super().__init__()
self.sound = 'aaaaaa'
def sing(self):
print(self.sound)
bird = SongBird()
bird.eat()
bird.sing()多态
多态(以封装和继承为前提)
不同的子类对象调用相同的方法 产生不同的执行结果
class Dog(object):
def __init__(self,name):
self.name = name
def game(self):
print('%s 开心的玩耍～' %(self.name))
class Gaifei(Dog):
# 父类的方法不能满足子类的需求 重写game方法
def game(self):
print('%s和米老鼠一起玩～' %(self.name))
class Person(object):
def __init__(self,name):
self.name = name
def game_with_dog(self,dog):
print('%s和%s玩～' %(self.name,dog.name))
dog.game()
# 创建一个狗对象
wangcai = Dog('大黄')
# wangcai = Gaifei('高飞')
# 创建一个人对象
xiaoming = Person('小明')
# 让小明和狗玩
xiaoming.game_with_dog(wangcai)
