python中类(class)
"""
面向过程 和 面向对象(oop:object oriented programming) 的基本概念
面向过程：---侧重于怎么做？
1.把完成某一个需求的 所有步骤 从头到尾 逐步实现
2.根据开发要求，将某些功能独立的代码封装成一个又一个函数
3.最后完成的代码，就是顺序的调用不同的函数
特点：
1.注重步骤与过程，不注重职责分工
2.如果需求复杂，代码会变得很复杂
3.开发复杂项目，没有固定的套路，开发难度很大
面向对象：--谁来做?
相比较函数，面向对象是更大的封装，根据职责在一个对象中封装多个方法
1.在完成某一个需求前，首先确定职责--要做的事(方法)
2.根据职责确定不同的对象，在对象内部封装不同的方法(多个)
3.最后完成代码，就是顺序的让不同的对象调用不同的方法
特点：
1.注重对象和职责，不同的对象承担不同的职责
2.更加适合对复杂的需求变化，是专门应对复杂项目的开发，提供的固定套路
3.需要在面向过程的基础上，再学习一些面向对象的语法
面向对象有两个核心的概念
类：是一群具有相同特征或行为的事物的一个统称，类是抽象的，不能直接使用
对象：由类创造出来的具体存在
在开发中，应该先有类再有对象
类和对象的关系
类是模板，对象是根据这个模板创建出来的
类只需要有一个，对象可以有多个(一张图纸可以造出多个飞机)
类：属性(信息)和方法(你能完成的动作)
1.类名
2.属性
3.方法
1.类名 这类事物的名字，满足大驼峰命名法
大驼峰命名法：
1.每一个单词的首字母大写
2.单词与单词之间没有下划线
2.属性 这个类创建出的对象有什么样的特征
3.方法 这个类创建出的对象有什么样的行为
类名的确定
名词提炼法分析整个业务流程，出现的名词，通常就是找到的类
属性和方法的确定
对 对象的特征描述，通常可以定义成属性
对象具有的行为(动词)，通常可以定义为方法
提示：需求中没有涉及的属性或方法在设计类时，不需要考虑
"""
"""
练习1：
需求：
小明今年18岁，身高1.75，每天早上要跑步，会去吃东西
小美今年17岁，身高1.65 小美不跑步，小美喜欢吃东西
Person
name
age
height
run()
eat()
练习2：
一只黄颜色的狗狗叫大黄
看见生人旺旺叫
看见家人摇尾巴
Dog
name
color
shout()
shake()
"""
# 小猫爱吃鱼 小猫要喝水
# Cat eat drink
class Cat:
def eat(self):
print('%s爱吃鱼' %self.name)
def drink(self):
print('小猫要喝水')
# 创建猫对象
# tom = Cat()
# tom.name = 'Tom'
# print(tom)
# addr = id(tom)
#print(addr)
# %x：打印格式为十六进制
# print('%x' %(addr))
# # %d:打印格式为十进制
# print('%d' %(addr))
# tom.drink()
# tom.eat()
"""
初始化方法
创建对象时
1.为对象在内存中分配空间--创建对象
2.调用初始化方法位对象的属性设置初始化值--初始化方法（--init--）
"""
class Cat():
# 初始化方法的参数，创建类时，必须给足
def __init__(self, name):
print('初始化方法')
self.name = name
# 使用类创建一个对象时，会调用初始化方法
cat = Cat('lala')
print(cat.__init__)
dog = Cat('dog')
print(dog.name)
"""
__str__
__del__
"""
class Cat:
def __init__(self, name):
self.name = name
print('%s coming' % (self.name))
# 对象名将不返回内存地址，返回改字符串
def __str__(self):
# 必须放回一个字符串
return '我是 %s' % self.name
# 释放内存时自动执行的方法
def __del__(self):
print(('%s leaving' % (self.name)))
#
tom = Cat('tom')
print(tom)
del tom
print('*' * 40)
小练习
""
需求
1.房子有户型，总面积和家具名称列表
新房子没有任何的家具
2.家具有名字和占地面积，其中
床：占地4平米
衣柜：占地2平米
餐具：占地1.5平米
3.将以上三件家具添加到房子中
4.打印房子时，要输出：户型，总面积，剩余面积，家具名称列表
"""
class house:
def __init__(self, houseType, houseArea):
self.houseType = houseType
self.area = houseArea
self.fire_area = houseArea
self.fitment = []
def __str__(self):
return '户型：%s\n总面积:%s平米\n剩余面积:%s平米\n家具：%s' % (self.houseType, self.area, self.fire_area, ','.join(self.fitment))
def add_fitment(self, fitmentname):
if fitmentname.area < self.fire_area:
self.fitment.append(fitmentname.name)
self.fire_area -= fitmentname.area
else:
print('%s的占地%s平米太大了，房子剩余面积%s平米太小了' % (fitmentname.name, fitmentname.area, self.fire_area))
class fitment:
def __init__(self, name, area):
self.name = name
self.area = area
def __str__(self):
return '%s占地%s平米' % (self.name, self.area)
bed = fitment('架子床', 4)
bureau = fitment('折叠衣柜', 2)
cutlery = fitment('餐桌', 1.5)
# print(bed)
# print(bureau)
# print(cutlery)
xiaoming_house = house('两室一厅', 100)
xiaoming_house.add_fitment(bed)
xiaoming_house.add_fitment(cutlery)
print(xiaoming_house)
python中class的继承
"""
继承: 实现代码的重用，相同的代码不需要重复的写
"""
# 定义父类
class Animal:
def eat(self):
print('吃~~~~')
def drink(self):
print('喝')
def run(self):
print('跑')
def sleep(self):
print('睡')
# 子类继承父类
class Cat(Animal):
def call(self):
print('喵～')
# 创建一个猫对象，可以直接调用继承父类的方法属性，还有自己的方法。
fentiao = Cat()
fentiao.eat()
fentiao.drink()
fentiao.run()
fentiao.sleep()
class Animal:
def eat(self):
print('吃~~~~')
def drink(self):
print('喝')
"""
继承具有传递性
"""
class Cat(Animal):
def call(self):
print('喵～')
class Tom(Cat):
def speak(self):
print('我可以说日语')
kt = Tom()
kt.speak()
# 子类可以继承父类的所有属性和方法
kt.call()
# 继承有传递性，包括父类继承的所有属性和方法
kt.eat()
kt.drink()
"""
当父类方法实现不能满足子类的需求时？可以对方法进行重写
1.覆盖父类的方法
2.对父类方法进行扩展
"""
class Animal:
def eat(self):
print('吃~~~~')
def drink(self):
print('喝')
def run(self):
print('跑')
def sleep(self):
print('睡')
class Cat(Animal):
def call(self):
print('喵～')
class Tom(Cat):
def speak(self):
print('我可以说日语')
def call(self):
print('这是我写的方法')
kt = Tom()
# 如果子类中，重写了父类的方法
# 在运行中，只会调用在子类中重写的方法而不会调用父类的方法
kt.call()
"""
子类重写方法，并调用父类的方法
"""
class Tom(Cat):
def speak(self):
print('我可以说日语')
def call(self):
# 1.针对子类特有的需求，编写代码
print('子类的方法')
# 2.调用原本在父类中封装的方法
# Cat.call(self)
super().call()kt = Tom()
kt.call()
"""
1.子类可以同时继承多个父类
2.如果方法或属性名称相同时，默认继承成首个参数父类的方法或属性
"""
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方法')
# 同时继承B和A，但是默认B的方法生效
class C(B, A):
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 cat:
pass
print(dir(cat))
"""
多态(以封装和继承为前提)，不同的子类对象调用相同的方法，产生不同的执行结果
人类
work(self)
程序员 设计师
"""
class Dog(object):
def __init__(self, name):
self.name = name
def game(self):
print('%s 蹦蹦跳跳的玩～' % (self.name))
class Gaofei(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()
# 1.创建一个狗对象
wangcai = Gaofei('高飞')
# 2.创建一个人对象
xiaoming = Person('小明')
# 3.让小明和狗玩
xiaoming.game_with_dog(wangcai)
"""
一切皆对象
类是一个特殊的对象---类对象
在程序运行的时候，类对象(创建实例对象的模板)在内存中只有
一份，通过它可以创建出和很多个对象实例
除了封装实例的属性和方法外，类对象还可以拥有自己的属性和方法
1.类属性
2.类方法
通过 类名. 的方式可以直接访问类的属性
类属性：就是给类对象定义的属性
通常用来记录与这个类相关的特征
类属性不会用于记录对象特征
"""
"""
定义一个工具类，每个工具都有自己的名字
需要知道使用这个类，创建了多少个工具对象
"""
class Tool(object):
# 1.使用赋值语句定义类属性，记录所有工具的数量
count = 0
def __init__(self, name):
self.name = name
# 让类属性 +1
Tool.count += 1
# 创建工具对象
tool1 = Tool('斧头')
# tool2 = Tool('榔头')
# tool3 = Tool('起子')
# 输出工具对象的总数
# 类名.属性名 来获取
print(Tool.count)
"""
类方法
类属性就是针对类对象定义的
使用赋值语句在class关键字下可以定义类属性
类属性用于记录于这个类相关的特性
类方法就是针对类对象定义的方法
在类方法内部就可以直接访问类属性或者调用其他类方法
"""
class Toy(object):
# 1.使用赋值语句定义类属性，记录所有工具的数量
count = 0
def __init__(self,name):
self.name = name
# 让类属性 +1
Toy.count += 1
@classmethod
def show_toy_count(cls):
print('玩具对象的数量 %d' %(cls.count))
# 创建玩具对象
toy1 = Toy('乐高')
toy2 = Toy('泰迪熊')
# 调用类方法
Toy.show_toy_count()
"""
静态方法
在开发的时候，如果需要在类中封装一个方法，这个方法
即不需要访问实例属性或者调用实例方法
也不需要访问类属性或者调用类方法
这个时候，我们就可以把这个方法封装成一个静态方法
"""
class Cat(object):
@staticmethod
def call():
print('喵～')
# 通过 类名. 调用静态方法
Cat.call()
# 不需要创建对象，直接就可以使用
"""
私有属性和私有方法
应用场景及定义方式
应用场景
在实际开发中，对象的某些属性或方法可能只希望在对象的内部使用，
而不希望在外部被访问到
私有属性 就是 对象 不希望公开的 属性
私有方法 就是 对象 不希望公开的 方法
定义方法
在定义属性或方法时，在属性名或者方法名前增加两个下划线，
定义的就是私有属性或方法
"""
class Women(object):
def __init__(self, name):
self.name = name
self.__age = 18
def __secrte(self):
print('%s 的年龄是 %d' % (self.name, self.__age))
lily = Women('lily')
print(lily.name)
# 私有属性,外界不能直接访问
print(lily.__age)
# 私有方法,外界不能直接访问
# lily.secrte()
python中的异常处理方式
"""
异常:
程序在运行的时候，如果python解释器遇到一个错误，会停止程序的执行，
并且提示一些错误的信息，这就是异常
我们在程序开发的时候，很难将所有的特殊情况都处理，通过异常捕获可以针对
突发事件做集中处理，从而保证程序的健壮性和稳定性
在程序开发中，如果对某些代码的执行不能确定(程序语法完全正确)
可以增加try来捕获异常
try:
尝试执行的代码
except 错误类型1：
针对错误类型1，对应的代码处理
except 错误类型2：
针对错误类型2，对应的代码处理
"""
try:
# 不能确定正确执行的代码
num = int(input('请输入一个整数:'))
print('lala')
except:
print('请输入一个整数')
print('#' * 50)
"""
1.提示用户输入一个整数
2.使用8除以用户输入的整数并输出
"""
try:
# 提示用户输入一个整数
num = int(input('请输入一个整数:'))
# 使用8除以用户输入的整数并输出
result = 8 / num
print(result)
except ZeroDivisionError:
print('0不能做除数')
except ValueError:
print('输入的不是数字')
except Exception as result:
print('未知错误 %s' % (result))
finally:
# 无论是否有异常,都会执行的代码
print('~~~~~~~~~~~~~~~~~~~~~')