一、面向过程与面向对象
1）过程：一组将输入转化为输出的活动。
2）面向过程：针对某一具体活动制定的执行方案，具备一定逻辑顺序，类似于设计一条流水线，可以将复杂的问题流程化、简单化。缺点是扩展性差（如果更改需求，可能整个代码都需要重写）。
3）对象：对象是具体的，指活动中作为具体指定的目标。python中对象由一系列的属性和方法组成，对象的变量叫“实例属性”，对象的函数叫“实例方法”。
4）类：类是抽象的，描述具有许多相同或相似事物特征的集合。python中类由一系列的属性和方法组成，类中的变量叫“类属性”，类中的函数叫“类方法”。
5）类与对象的关系：在python中，对象是类的实例化后的实体，类是对象的模板。实例化后的对象，可以调用类的属性和类的方法。一个类可以有多个对象，类就是创建对象的母版（类似PPT母板）。
6）面向对象：一种描述业务问题与实体之间关系的方法，是对现实世界的模拟。可以编写表示真实世界中的事物和情景中的类，并基于这些类来创建对象。优点：可使程序的维护和扩展变得更简单。
# 面向过程
def demo(x, y):
if x > y:
print(x)
return x
elif x < y:
print(y)
return y
else:
print(x + y)
return x + y
demo(12, 12)
>>24
# 面向对象
class Cat(object): # 定义一个猫类
print(‘喵喵！‘)
def hobby(self): # 实例方法，第1技能
print("我喜欢吃鱼！")
def color(self): # 实例方法，第2技能
print("我是灰色的！")
jiafei = Cat() # 实例化对象，实例化后才能调用方法。注意：给这个类取名叫加菲，这一类猫叫加菲猫，不是指具体某一只。
jiafei.hobby() # 让豆豆类使用猫的1技能
>>喵喵！
>>我喜欢吃鱼！
二、类的创建
# 示例语法：
class Name(): # ”类名“通常首字母大写，为了区分”函数名“
name = "变量" # 刻画类的通用特征
def ff_name(self,): # 描述类的行为
pass
class Men(object): # object是最大的类
gender = "male" # 刻画类的通用特征
def strong(self,name): # self名称是约定成俗的，指向类的实例化的对象本身
print(name,"可以干重活！") # 功能1（描述类的行为）
def job(self,name): # 设置name参数，可用于区分多个对象的识别
print(name,"工作很努力！")
zg_man = Men() # 实例化对象，实例化后可调用类的方法。zg_man定义为中国男人这一类。
zg_man.strong("Ttan") # 实例方法，给这个人取名叫“泰坦”，让他调用1技能
zg_man.job("猪八戒") # “猪八戒”，让他调用2技能
>>Ttan 可以干重活！
>>猪八戒 工作很努力！
三、面向对象中属性和方法解析
1）类的属性：一般分为私有属性和公有属性。如果属性中的变量是以两个下划线开始，就表示该属性为私有属性。
2）类的方法：类的方法也分私有方法和公有方法，私有方法不能被模块外的类或对象调用。
3）对象的属性：又称实例属性。只能被相应的对象调用，不能给其他对象共享。
4）对象的方法：又称实例方法（普通方法）。类实例化之后的对象，能够使用的方法。
# 面向对象中的属性与方法：
# 【魔术方法（初始化方法）、类方法（@classmethod）、静态方法（@staticmethod）、实例方法（普通方法）】
# 1）魔术方法：以“__”双下划线包起来的方法，都统称为“Magic Method”（魔术方法）,例如类的初始化方法 __init__。无需调用，自动触发。
# 2）类方法：用@classmethod装饰，默认参数【cls】。作为类的补充附加内容,可以使用实例对象/类名调用。类方法中只能使用类属性。
# 3）静态方法：用@staticmethod装饰的不带 self 参数的方法叫做静态方法，类的静态方法可以没有参数，可以使用实例对象/类名调用。
# 4）实例方法：即普通方法。第一个参数必须是实例本身，一般使用【self】表示，实例方法只能通过实例对象去调用。
class Men(object):
gender = "男" # 类属性，公共属性该类中的所有对象均可共享
height = 170
# 1）魔术方法（初始化方法）---相当于设置默认值，程序启动即执行的方法
def __init__(self, name, age):
self.name = name
self.age = age
print("1）魔术方法 -----大家好！------")
# 2）类方法，用装饰器 @classmethod---通过cls增加类变量的值，修改类变量属性
@classmethod
def modify_height(cls, height_add):
cls.height += height_add
print("2)类方法 你已经成功增加了平均高度" + str(height_add))
# 3）静态方法，用装饰器@staticmethod
@staticmethod
def character():
print("3)静态方法 他喜欢做一些对国家有意义的事情！")
# 4）实例方法（普通方法）
def talk(self):
self.name = "爆炸头" # 实例属性
print(f"4)实例方法 {self.name}说话像个孩子！身高为{self.height}")
def sleep(self, style_sl):
print("4)实例方法 {}中午在{}睡觉！".format(self.name, style_sl))
gd_man = Men("大头", 18) # 类的实例化,实参要传递初始化方法所有参数
print(gd_man.__dict__) # 显示对象的属性值
# Men.modify_height(0.05) # 实例对象和类均可调用类方法
gd_man.modify_height(0.5) # 实例对象，调用 2)类方法
gd_man.character() # 实例对象，调用 3)静态方法
gd_man.talk() # 实例对象，调用 4)实例方法中的talk方法
gd_man.sleep("趴在桌子上") # 实例对象，调用 4)实例方法中的sleep方法
>>1）魔术方法 -----大家好！------
>>{‘name‘: ‘大头‘, ‘age‘: 18}
>>2)类方法 你已经成功增加了平均高度0.5
>>3)静态方法 他喜欢做一些对国家有意义的事情！
>>4)实例方法 爆炸头说话像个孩子！身高为170.5
>>4)实例方法 爆炸头中午在趴在桌子上睡觉！
四、类的三大特点【封装、继承与多态】
1）封装性：将对象的特征（属性）和行为（方法）保存起来。
2）继承性：通过继承，子类可以快速获取父类的特征与行为。
3）多态性：不同的子类对象，调用相同的父类方法，产生不同的执行结果。
# 1）类的封装
class Card(object):
def __init__(self, num, pwd, ban):
self.num = num
self.pwd = pwd
self.__ban = ban # 余额，在属性前加两个下划线"__"，变成私有属性（只能在类的内部被访问）
def __cun(self): # 私有方法，加两个下划线"__"
print("存款")
# 设置拿到余额的条件
def getBan(self, numm, pwdd):
if numm == self.num and pwdd == self.pwd:
return self.__ban
else:
return "输入错误"
card = Card("1001", "123456", 1000) # 开卡
# print(card.getBan("1001","123456")) #通过验证,拿到属性，只有防止出错
print(card._Card__ban) # 也可以通过这种方法，直接拿到私有属性
# 一个下划线拿到Card，两个下划线拿到ban
>>1000
# 2-1）类的继承（单继承）---1个子类继承1个父类
class Animal(object):
def __init__(self,name):
self.name=name
def eat(self):
print("吃东西")
class People(Animal): # Animal继承object,People继承Animal
def talk(self):
print(‘say hello‘)
xiaoming=People("小明")
xiaoming.eat()
>>吃东西
# 2-2）类的继承（多继承）---1个子类继承多个父类
# A,B继承object；C分别继承A,B（新式类继承，广度优先）
class A(object):
def text(self):
print("AAA")
class B(object):
def text(self):
print("BBB")
class C(A,B):
print("打印试试！")
eee=C()
eee.text()
print(C.__bases__)
# 内置的__bases__属性,通过该属性可以查看该类的所有“直接父类”，该属性返回所有直接父类组成的元组。
>>打印试试！
>>AAA
>>(<class ‘__main__.A‘>, <class ‘__main__.B‘>)
# 2-3）类的继承（多继承）---多个子类继承1个父类
class Animal(object): # Animal继承object类
def __init__(self, color):
self.color = color
def eat(self):
print("动物在吃")
def run(self):
print("动物在跑")
class Cat(Animal): # Cat类继承Animal类
pass
class Dog(Animal): # Dog类继承Animal类
def __init__(self, name, age, color):
self.name = name
self.age = age
super(Dog, self).__init__(color) # 调用父类的初始化方法
def eat(self):
print("狗在啃骨头")
dog = Dog("小黑", 10, "红色") # 实例化的时候，优先调用子类的方法。
dog.eat()
print(dog.color)
# print(cat.color)
# cat.eat()
>>狗在啃骨头
>>红色
# 3）类的多态
class Animal(object): #同一类事物:动物
def talk(self):
pass
class People(Animal): #动物的形态之一:人,继承Animal的talk方法
def talk(self):
print(‘say hello‘)
class Dog(Animal): #动物的形态之二:狗，继承Animal的talk方法
def talk(self):
print(‘say wangwang‘)
class Pig(Animal): #动物的形态之三:猪，继承Animal的talk方法
def talk(self):
print(‘say aoao‘)
xiaomin=People()
xiaomin.talk()
xiaohuang=Dog()
xiaohuang.talk()
xiaobai=Pig()
xiaobai.talk()
>>say hello
>>say wangwang
>>say aoao
补充内容：继承中关键字的用法【super】
# 补充内容：类的继承（super关键字调用父类的方法）
# super 不仅可以调用父类构造函数，也可调用父类实例方法；
# super 可以解决父类名称频繁变化的问题
class Animal(object):
def __init__(self, name, age):
self.name = name
self.age = age
def sleep(self):
print(‘我要睡觉了！‘)
class People(Animal): # 修改继承父类名称
def __init__(self, name, age):
self.name = name
self.age = age
# Animal.__init__(self,name,age)
super(People, self).__init__(name, age)
# 该行代码并没有出现任何“父类”的名称，如果父类名称频繁变化，只需修改继承的父类名称即可
def talk(self):
print(‘say hello‘)
super(People, self).sleep() # 调用父类的方法
xiaoming = People("小明", 20)
xiaoming.sleep()
>>我要睡觉了！
原文：https://www.cnblogs.com/lovezhuzhu1314/p/15060464.html