python是一门面向对象的语言,所谓的面向对象就是在编程里尽可能去模拟真实的现实世界,按照现实世界中的逻辑去处理问题,分析问题中参与其中的有哪些实体,这些实体应该有什么属性和方法,如何通过调用这些实体的属性和方法去解决问题
面向对象:一种更符合我们人类思维习惯的编程思想,复杂事情简单化,就是不断创建对象,使用对象,操作对象做事情
面向过程:以过程为中心的编程思想,首先分析解决问题所需要的步骤,然后用函数将这些步骤一步一步的实现,然后按顺序一次调用运行
面向对象程序设计规则:首先分析有哪些类,每个类有哪些属性和行为,类与类直接存在的关系
类、方法、类变量的定义
类class:用来描述具有相同的属性和方法的对象的集合,定义了集合中每一个对象共有的属性和方法,对象是类的实例
方法:类中定义的函数。类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称,按照惯例它的名称是self(其实取什么名字不重要,只是这个参数就行,系统默认叫self)
类变量:类变量在整个实例化的对象中是公用的。类变量定义在类这种且在函数体之外,类变量通常不作为实例变量使用。
#类的定义
class Person():
name = "li" #类的属性
def get_name(self): #类的方法
return self.name
#调用
print(Person.name) #不实例化 #打印结果 li
#实例化
p = Person()
print(p.name) #调用属性 #打印结果 li
print(p.get_name()) #调用方法 #打印结果 li
#修改实例的属性
p.name = "lili"
print(p.name) #打印结果 lili
#修改类的属性
Person.name = "lilia"
print(Person.name) #打印结果 lilia
print(p.name) #打印结果 lili #已经实例化再修改类的属性,不会影响已经实例化的结果,就是实例化的属性还是类属性修改之前的属性
#再实例化一个
p1 = Person()
print(p1.name) #打印结果 lilia #修改类的属性后再实例化,实例化调用的属性为类修改之后的属性
实例是类的一个具体对象,比如,车类是一个类,摩托车和自行车就是车类的一个实例,类是抽象的,实例是具体的。
实例引用给对象起一个别名,比如a是对象,b是a的引用(别名),则a和b的地址空间是一样的,修改b,a同时被修改
实例变量:实例属性,在任意方法内部,以“self.变量名”的方式定义的变量。实例变量只能通过对象名访问,无法通过类名访问。
class Person:
#定义公用属性
def __init__(self,name,age,gender): #调用int方法,在方法里定义属性,int方法是当创建一个类的实例时会调用的构造函数,相当于构造方法
self.name = name
self.age = age
self.gender = gender
#定义公用方法
def eat(self):
print(f"name : {self.name}, age : {self.age}, gender : {self.gender} 我在吃")
def drink(self):
print(f"name : {self.name}, age : {self.age}, gender : {self.gender} 我在喝")
def run(self):
print(f"name : {self.name}, age : {self.age}, gender : {self.gender} 我在跑")
#定义非公用
def set_fit(self,value): #属性放方法里,属性value
self.value = "fit"
#实例化
xiaoming = Person('xioaming', 20, 'male')
print(xiaoming.name) #打印 xioaming
xiaoming.run() #调用方法,打印 name : xioaming, age : 20, gender : male 我在跑
#调用非公用属性
xiaoming.set_fit("fit")
print(xiaoming.value) #打印 fit
面向对象是一种编程思想,面向过程比较典型的就是c语言(结构化的方式),面向对象比较典型的是Java c++。解决了系统的可维护性、可扩展性和可重用性。
python的三大特性
封装:所有设计模式的基础,把同一类的事物的一些共性抽取出来,包括属性、方法,归结到一个类当中,方便去使用,一般来说,属性描述事物特征,方法描述事物动作,封装就是把信息隐藏在内部,不让别人知道,只有公布的一些方法,外部才能访问到
继承
多态,在继承基础上实现的,子类继承父类,在子类还可以添加类和属性
# 定义类,类名首字母大写,驼峰命名规则
class HouseWu:
# 静态属性:也叫类变量,定义在类中且在类的方法外
door = ''
floor = ''
# 私有属性,名称前需要加两个下划线,在类外面通过实例直接调用是不行的
# 如果要在类外面被调用,就需要先在类里面定义方法调用私有属性,然后再到类外面去调用这个方法,就可以使用这个私有属性了
__key = True
# 在类里面定义一个方法进行调用私有属性
def open_door(self):
if self.__key == True:
print('开门啦~')
else:
print('没钥匙,开不了门~')
# 构造函数,只要类实例化时有构造函数,就会先执行这个构造函数,然后类里以及类方法里的所有的变量都可以使用,就不需要再一条一条调用方法
# 如果在实例化类变量时,需要传参的话,这时也要用到构造函数
def __init__(self, door, floor):
# 实例变量也可以在构造函数中定义,所有类方法中都可以调用这个实例变量
self.chiken = '很美味'
# 调用类变量,把类变量转化为实例变量
self.door = door
self.floor = floor
# 动态方法,方法名称小写字母,单词与单词之间下划线连接,在类当中定义的所有方法,第一个参数都是self
# self为实例本身,传入实例方法才能被调用
def sleep(self):
# 局部变量:定义在类的方法中,不以self.开头,只能在当前所在方法中调用
bed = '席梦思'
# 实例变量:定义在类的方法中,以self.开头,在类的其他所有方法都可以调用
self.table = '桌子上可以放东西'
print(f'在房子里可以躺在{bed}床上睡觉')
def cook(self):
# 调用其他方法中的实例变量
print(self.table)
# 调用构造函数里面的实例变量
print(self.chiken)
print('在房子里面可以做饭')
# 如果非要用类名调用类方法,需要用到classmethod,其实就是变成了类方法
@classmethod
def class_method(cls):
print('类方法')
# 定义私有方法,在类外面通过实例直接调用是不行的
def __open_save(self):
print('打开保险箱')
# 在类里面定义一个公用方法调用私有方法,再到类外面去调用这个公用方法就可以使用私有方法了
def get_save(self):
self.__open_save()
# 类变量需要传参时,可以用位置传参,也可以关键字传参
wu_house = HouseWu('红色', '绿色')
print(wu_house.door)
print(wu_house.floor)
# 实例化:变量名(也叫实例)=类名(),要想使用类方法需要先实例化
# north_house = HouseWu()
# china_house = HouseWu()
# 定义实例的属性
# north_house.door = 'white'
# north_house.floor = 'black'
# china_house.door = 'yellow'
# china_house.floor = 'red'
# 调用方法:只有方法被调用了,方法里面的变量才可以被使用
# north_house.sleep()
# north_house.cook()
# print(north_house.door)
# print(north_house.floor)
# print(china_house.door)
# print(china_house.floor)
# 调用类的属性
# door1 = HouseWu.door
# print(door1)
# 修改类的属性
# HouseWu.door = 'blue'