面向对象编程:OOP
面向对象编程的关注点在于谁来做,相比较函数,面向对象是更大的封装,根据职责在一个对象中封装多个方法
属性、行为
先有类,把具体的东西抽象并归类,然后根据类再生产出一个个对象
类:是对一群具有相同特征或者行为的事物的一个统称,是抽象的,不能直接使用
封装、继承、多态
# 有两个对象:
# 小明今年23岁,身高180cm,体重75kg,它能够睡觉
# 小红今年21岁,身高170cm,体重58kg,它能够睡觉
# 创建一个类,并且定义一个类名
class Person(object):
def __init__(self, name, age, height, weight):
self.name = name
self.age = age
self.height = height
self.weight = weight
def sleep(self): # 行为
print('正在睡觉!')
# 使用Person类创建了一个Person对象 p1
p1 = Person('小明', 23, '180cm', '75kg')
p1.sleep()
p2 = Person('小红', 21, '170cm', '58kg')
p2.sleep()
class Student(object):
def __init__(self, name, age, score):
self.name = name
self.age = age
self.score = score
def say_hello(self):
print('大家好,我的名字是{},我{}岁了'.format(self.name, self.age))
# print('大家好,我的名字是{},我{}岁了'.format(self.name, self.money) # 会报错,因为money属性是后面手动动态添加的
# __init__ 方法要求对象创建的时候就必须要有某些属性
s1 = Student('jerry', 18, 100)
print(s1.name)
print(s1.addr) # 会报错,因为没有addr属性,AttributeError: 'Student' object has no attribute 'addr'
# 对象创建好了以后,还可以随时动态的添加属性
s1.money = 1000
print(s1.money)
print(s1.age) # 18
s1.age = 20
print(s1.age) # 20
s1.say_hello() # 会成功打印,如果print中有动态属性,会报错
s2 = Student('chris', 20, 98)
s2.say_hello() # 会成功打印
class Dog(object):
def __init__(self, name, color):
self.xingming = name
self.yanse = color
def say_hello(self): # 谁调用这个方法,self指的就是谁
print('大家好,我是{}'.format(self.xingming))
d1 = Dog('大黄', '白色')
print(d1.yanse)
d1.say_hello() # d1调用了say_hell0()方法,self指的就是d1,self.xingming指的就是d1的姓名'大黄’
d2 = Dog('旺财', '黑色')
d2.say_hello()
在类里,以__开始,并且以__结束的方法,我们称之为魔法(魔术方法)
特点: 不用手动的调用,它们会在适当的时机自动调用
class Person(object):
def __init__(self, name, age):
print('__init__函数被调用了!!!!')
self.name = name
self.age = age
def __str__(self):
# 当一个对象要变成字符串的时候会自动调用
# __str__ 方法必须要有返回值,而且是一个字符串
print('__str__被调用了!!!!!')
# return 'hehe'
return 'name:' + self.name + ', age:{}'.format(self.age)
def __repr__(self):
# 当需要修改一个对象的输出结果时候
return 'name:' + self.name + ', age:{}'.format(self.age)
return 'yes'
def __del__(self):
# 当一个对象被销毁的时候,会自动调用这个方法
print('hehehehe')
del self
def sleep(self):
print('{}正在睡觉'.format(self.name))
p1 = Person('jerry', 18) # 自动被调用,会打印'__init__函数被调用了!!!!'
# print(p1) # <__main__.Person object at 0x0069F7D0>
print(p1) # {name:jerry,age:18}
# 1、 class Person(object): def __init__(self, name, age): self.name = name self.age = age p1 = Person('zhangsan', 18) p2 = Person('zhangsan', 18) print(p1 == p2) # False,对象==若不修改eq方法,默认比较的是内存地址 print(p1 is p2) # False n1 = ['zhangsan', 'lisi', 'wangwu'] n2 = ['zhangsan', 'lisi', 'wangwu'] print(n1 == n2) # True,列表==比较的是内容,is比较的是内存地址 print(n1 is n2) # False
class Person(object):
def __init__(self, name, age):
self.name = name
self.age = age
def __eq__(self, other):
# if self.name == other.name and self.age == other.age:
# return True # 如果name和age都一样的话,就返回true,否则返回false
# return False
return self.name == other.name and self.age == other.age # 等价
p1 = Person('张三', 18)
p2 = Person('张三', 18)
p3 = p2 # python的赋值是内存地址的赋值,即把p2的地址给了p3,指向同一块内存地址,p3没有创建新的对象,创建对象的格式如p1,p2
print(p3 is p2) # True
print(p3 is p1) # False
print(p1 == p2) # True,修改了eq方法,如果name和age都一样的话,就返回true
# p1 == p2 ==> p1.__eq__(p2)即p1==p2即p1调用的eq方法
print(p1 is p2) # False
class Person(object):
def __init__(self, name, age):
self.name = name
self.age = age
def __lt__(self, other): # 重写lt方法
return self.age < other.age
p1 = Person('chris', 18)
p2 = Person('allen', 19)
print(p1 > p2) # False
class Person(object):
def __init__(self, name, age, score):
self.name = name
self.age = age
self.score = score
def __lt__(self, other): # 重写it方法
# return self.age < other.age
return self.score < other.score
p1 = Person('jerry', 18, 98)
p2 = Person('tony', 20, 81)
p3 = Person('henry', 17, 86)
persons = [p1, p2, p3]
persons.sort()
# persons.sort(key=lambda ele: ele.score),在没有it方法时(无重写的那段代码)可以把key的📄传进来
for p in persons:
print(p.name)
# 字典排序
ps = [
{'name': 'zhangsan', 'age': 18},
{'name': 'lisi', 'age': 19},
{'name': 'wangwu', 'age': 17},
{'name': 'zhaoliu', 'age': 20},
{'name': 'tianqi', 'age': 16},
{'name': 'wangba', 'age': 21}
]
# def demo(ele): # 会不断地把一个个字典传进来,给参数ele
# return ele['age']
# ps.sort(key=demo)
ps.sort(key=lambda ele: ele['age']) # 可以用lambda表达式简写
print(ps)
# 1、小明体重 75.0 公斤,小明每次跑步会减肥 0.5 公斤,小明每次吃东西体重增加 1 公斤。
# 在打印小明这个对象时,输出小明的姓名,体重信息
class Person(object):
def __init__(self, name, weight):
self.name = name
self.weight = weight
def run(self):
self.weight -= 0.5
def eat(self):
self.weight += 1
def __int__(self): # 魔法方法
return 100
def __float__(self): # 魔法方法
return 34.5
def __str__(self): # 魔法方法,在需要返回一个字符串时,自动调用该魔法方法
return '姓名:{},体重{}kg'.format(self.name, self.weight)
p1 = Person('小明', 75)
p1.run()
p1.run()
p1.run()
p1.eat()
p1.run()
print(p1)
print(str(p1))
print(int(p1))
print(float(p1))
# 2、房子(House)有户型、总面积、剩余面积和家具名称列表属性
# 新房子没有任何的家具
# 将家具的名称追加到家具名称列表中
# 判断家具到面积是否超过剩余面积,如果超过,提示不能添加这件家具;
# 家具(HouseItem)有名字和占地面积属性,其中
# 席梦思(bed)占地4平米
# 衣柜(chest)占地2平米
# 餐桌(table)占地1.5平米
# 将以上三件家具添加到房子中
# 打印房子时,要求输出:户型、总面积、剩余面积、家具名称列表
class House(object):
def __init__(self, type, total_area):
self.type = type
self.total_area = total_area
self.free_area = total_area * 0.5
self.item_list = [] # 给一个空列表
def add_item(self, item):
if self.free_area < item.area * 1.5: # 假设家具占地面积乘以1.5为实际占地面积
print('已经放不下了!')
return # 如果放不下后,return后,之后到代码便不会再走了
self.item_list.append(item.name) # 如果还有剩余面积,往里面添加
self.free_area -= item.area * 1.5
def __str__(self):
return '户型{},总面积{},剩余面积{},家具列表{}'.format(self.type, self.total_area, self.free_area, self.item_list)
class HouseItem(object):
def __init__(self, name, area):
self.name = name
self.area = area
h1 = House('一居室', 20)
bed = HouseItem('席梦思', 4)
chest = HouseItem('衣柜', 2)
table = HouseItem('餐桌', 1.5)
h1.add_item(bed)
h1.add_item(chest)
h1.add_item(table)
print(h1)
# 3、士兵张三有一把M416
# 枪能够装填子弹
# 枪能够发射子弹
# 如果士兵没有枪,无法开火
# 如果枪里没有子弹,需要装填子弹
# 如果有枪又有子弹,则可以开火
class Solider(object):
def __init__(self, name, gun=None): # 缺省参数,后续不传gun也可以
self.name = name
self.gun = gun
def fire(self):
if not self.gun:
print('你还没有枪,不能开火!!!')
return
if self.gun.bullet_count == 0:
print('没有子弹,需要装填子弹')
return
if self.gun.bullet_count >= 3:
self.gun.bullet_count -= 3 # 每次开枪3连发
else: # 如果子弹小于3,则开火后子弹剩余0
self.gun.bullet_count = 0
print('有枪有子弹,开火!!!还剩{}发子弹'.format(self.gun.bullet_count))
class Gun(object):
def __init__(self, type, bullet_count=0): # 子弹给默认值0
self.type = type
self.bullet_count = bullet_count
g1 = Gun('m416', 30)
s1 = Solider('许三多')
# s1 = Solider('许三多', g1) # 实例创建时就已分配给枪
s1.gun = g1 # 如果没有该句,实例都已创建好,但是s1并没有拿到枪,即创建时没有枪,后来给了一把枪
s1.fire()
# 定义一个类 Point,有两个属性 x,y 创建三个Point对象 a,b,c 判断c是否在ab组成的线段上
import math
class Point(object):
def __init__(self, x, y):
self.x = x
self.y = y
class Line(object): # 隐藏线索,两段线段长度加起来总和相等,即在同一条线段上
def __init__(self, start_point, end_point):
self.start_point = start_point
self.end_point = end_point
def get_length(self, point1=None, point2=None): # 获取线段长度,即两点之间距离
point1 = point1 or self.start_point
point2 = point2 or self.end_point
return math.sqrt((point2.x - point1.x) ** 2 + (point2.y - point1.y) ** 2) # 开方,math模块
def is_inline(self, point): # 判断点是否在线上
return self.get_length() == self.get_length(self.start_point, point) + self.get_length(self.end_point, point)
p1 = Point(3, 3)
p2 = Point(6, 6)
p3 = Point(6, 7) # false该点不在线上
p4 = Point(9, 9) # true该点在线上
l = Line(p1, p2)
print(l.get_length()) # 如果什么参数也不传,则point1取默认值None,为false,则继续取or后面的值self.start_point,or一直取到第一个为true的值
# print(l.get_length(p1, p3)) # p1传给point1,p3传给point2
print(l.is_inline(p4))
定义一个类React,有start_x,start_y,width,height的属性,表示矩形的长和宽。判断(x,y)是否在矩形的范围内
# 1、
class React(object):
def __init__(self, start_x, start_y, width, height):
self.start_x = start_x
self.start_y = start_y
self.width = width
self.height = height
def is_inside(self, x, y):
# if self.start_x < x < self.start_x + self.width and self.start_y < y < self.start_y + self.height:
# return True
# return False
return self.start_x < x < self.start_x + self.width and self.start_y < y < self.start_y + self.height
r = React(4, 5, 10, 6)
print(r.is_inside(20, 25)) # False
print(r.is_inside(12, 9)) # True
# 2、再多加一个point类
class Point(object):
def __init__(self, x, y):
self.x = x
self.y = y
class React(object):
def __init__(self, start_point, width, height):
self.start_point = start_point
self.width = width
self.height = height
def is_inside(self, point):
return self.start_point.x < point.x < self.start_point.x + self.width and self.start_point.y < point.y < self.start_point.y + self.height
sp = Point(10, 18) # 实例化矩形的起始点:start_point(即start_x,start_y)
r = React(sp, 20, 25)
p = Point(22, 28)
print(r.is_inside(p)) # True
联系客服