python面向对象简介：
Python是一个面向对象的编程语言，但是很多人就要问了，到底什么叫做面向对象呢？面向对象编程又是什么呢？
Python的类就像一个模具，是始终不变的，但是如果往里面倒的东西不一样，那么出来的东西虽然形状一样，但是说到底还是有区别的。
- 一个类占有一个独立的空间，类中的属性叫做类变量，类中的函数，叫做类的方法。
- 类(Class)：也可以成为类对象。类对象中包含了一批实例对象共有的属性和方法。
- 类变量：定义在类中且在函数体之外的变量。类变量在所有的实例变量中是共享的，类变量修改了，所有实例对象读取到的值都会修改。
- 实例变量：定义在类的实例方法中的变量，只作为当前实例的属性。
- 数据成员：类变量或者实例变量，以及用于处理类及其实例对象的相关的数据的统称。
- 方法：类中定义的函数。包含普通方法，类方法，静态方法，魔术方法。
- 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。其实只是在派生类中添加了同名方法，以至于查询方法时不会再向基类查询。
1、类和对象
面向对象是更大的封装，在一个类中封装多个方法，这样通过这个类创建出来的对象，就可以直接调用这些方法了！
- 定义简单的类
class 类名:
def 方法1(self, 参数列表):
pass
def 方法2(self, 参数列表):
pass
- 创建对象
对象变量 = 类名()
例1：
class Cat:
def eat(self):
print("小猫爱吃鱼")
def drink(self):
print("小猫要喝水")
# 创建猫对象
tom = Cat()
tom.eat()
tom.drink()
print(tom)
addr = id(tom)
print("%x" % addr)
2、方法中的self参数
在 Python 中，要 给对象设置属性，非常的容易，但是不推荐使用 因为：对象属性的封装应该封装在类的内部 只需要在 类的外部的代码
中直接通过 “ . ” 设置一个属性即可 注意：这种方式虽然简单，但是不推荐使用！
给对象增加属性：
由哪一个对象调用的方法，方法内的 self 就是哪一个对象的引用在类封装的方法内部，self
就表示当前调用方法的对象自己调用方法时，程序员不需要传递 self 参数。在方法内部可以通过 self. 访问对象的属性，也可以通过
self. 调用其他的对象方法。
例2：
class Cat:
def eat(self):
# 哪一个对象调用的方法，self就是哪一个对象的引用
print("%s 爱吃鱼" % self.name)
def drink(self):
print("%s 要喝水" % self.name)
# 创建猫对象
tom = Cat()
# 可以使用 .属性名 利用赋值语句就可以了
tom.name = "Tom"
tom.eat()
tom.drink()
3、类中方法
类中方法：动作
方法：普通方法 静态方法 类方法 魔术方法
1. 普通方法：
普通方法格式：
def 方法名(self[,参数,参数,参数,参数]):
pass
例3：
class Phone:
brand = 'xiaomi'
price = 2999
type = 'mix3'
# Phone里面的类方法：call
def call(self):
print('self-------------->', self)
print('正在打电话。。。。。')
print('请留言......', self.note)
phone1 = Phone()
print(phone1)
print(phone1.brand)
phone1.note = '134524787678'
phone1.call()
phone2 = Phone()
print(phone2)
print(phone2.brand)
phone2.note = '178524577999'
phone2.call()
运行结果：
<__main__.Phone object at 0x000001710CF42940>
xiaomi
self--------------> <__main__.Phone object at 0x000001710CF42940>
正在打电话。。。。。
请留言...... 134524787678
<__main__.Phone object at 0x000001710CF42748>
xiaomi
self--------------> <__main__.Phone object at 0x000001710CF42748>
正在打电话。。。。。
请留言...... 178524577999
2. 类方法：
类方法 :在定义的普通方法上加一个 @classmethod
# 类方法 :在定义的普通方法上加一个 @classmethod
"""
特点：
1、定义需要依赖装饰器 @classmethod
2、类方法中参数不是一个对象，而是类
print(cls) <class '__main__.Dog'>
3、类方法中只可以使用类属性
4、类方法中可否使用普通方法？ 不能
5、普通方法可以调用类方法吗？ 可以，通过 self.类方法名()
类方法作用：
因为只能访问类方法和类属性，所以可以在对象创建之前，如果需要完成一些动作（功能）
"""
class Dog:
def __init__(self, nickname):
self.nickname = nickname
def run(self):
print('{}在院子里走来走去！'.format(self.nickname))
self.test()
def eat(self):
print('正在吃饭。。。。')
self.run() # 类中方法的调用，需要通过self.方法名()
@classmethod
def test(cls):
print('--------------------')
print(cls)
print('********************')
# print(cls.nickname) 报错
# print(self.nickname) 报错
d = Dog('aasd')
d.run()
d.eat()
d.test()
Dog.test()
运行结果：
aasd在院子里走来走去！
--------------------
<class '__main__.Dog'>
********************
正在吃饭。。。。
aasd在院子里走来走去！
--------------------
<class '__main__.Dog'>
********************
--------------------
<class '__main__.Dog'>
********************
--------------------
<class '__main__.Dog'>
********************
3. 静态方法：
静态方法： 很类似 类方法，需要装饰器@staticmethod
# 补充类方法
"""
静态方法： 很类似 类方法
1、需要装饰器@staticmethod
2、静态方法是无需传递参数(cls,self)
3、也只能访问类的属性和方法，对象是无法访问的
4、加载时机同类方法
总结：
类方法 静态方法
不同：
1、装饰器不同
2、类方法有参数，静态方法没有参数
相同：
1、只能访问类的属性和方法，对象的属性和 方法是无法访问的
2、都可以通过类名调用访问
3、都可以在创建对象之前使用，因为不依赖于对象
普通方法与两者的区别：
1、没有装饰器
2、普通方法永远要依赖对象，因为每个普通方法都有一个self
3、只有创建了对象才可以调用普通方法，否则无法调用
"""
class Person:
__age = 18
name='lly'
def show(self):
self.salary=1900
print('---------->NAME:',Person.name)
print('-------------->', Person.__age)
print('---------->salary------->',self.salary)
@classmethod
def test(cls):
cls.__age = 19
print('--------------->类方法')
print('多少岁了：', cls.__age)
@staticmethod
def test1():
print('静态方法----------->')
# print(self.salary) 报错
p1 = Person()
p1.test()
p1.show()
p1.test1()
运行结果：
--------------->类方法
多少岁了： 19
---------->NAME: lly
--------------> 19
---------->salary-------> 1900
静态方法----------->
4. 魔术方法、初始化：
在 Python 中 对象几乎是无所不在的，我们之前学习的 变量、数据、函数 都是对象
在 Python 中可以使用以下两个方法验证：
在 标识符 / 数据 后输入一个 .，然后按下 TAB 键，iPython 会提示该对象能够调用的 方法列表
使用内置函数 dir 传入 标识符 / 数据，可以查看对象内的 所有属性及方法
提示 mingzhi__格式的方法是 Python 提供的 内置方法 / 属性，稍后会给大家介绍一些常用的 内置方法 / 属性
初始化：
使用类名()创建对象的时候，会自动调用初始化方法 init__
例4：
class Phone:
# 魔术方法之一：称作魔术方法 __名字__()
def __init__(self):
self.brand = 'xiaomi'
self.price = 4999
print('------------>init')
def call(self):
print('---------->call')
print('价格：', self.price)
p = Phone()
p.call()
p1 = Phone()
p1.price = 5999
p1.call()
运行结果：
------------>init
---------->call
价格： 4999
------------>init
---------->call
价格： 5999
del方法：
class Cat:
def __init__(self, new_name):
self.name = new_name
print("%s 来了" % self.name)
def __del__(self):
print("%s 我去了" % self.name)
# tom 是一个全局变量
tom = Cat("Tom")
print(tom.name)
# del 关键字可以删除一个对象
del tom
print("-" * 50)
运行结果：
Tom 来了
Tom
Tom 我去了
--------------------------------------------------
str方法：
在 Python 中，使用 print 输出 对象变量，默认情况下，会输出这个变量 引用的对象 是 由哪一个类创建的对象，以及 在内存中的地址（十六进制表示）
如果在开发中，希望使用 print 输出 对象变量 时，能够打印 自定义的内容，就可以利用 str 这个内置方法了
注意：__ str __方法必须返回一个字符串
class Cat:
def __init__(self, new_name):
self.name = new_name
print("%s 来了" % self.name)
def __del__(self):
print("%s 我去了" % self.name)
def __str__(self):
# 必须返回一个字符串
return "我是小猫[%s]" % self.name
# tom 是一个全局变量
tom = Cat("Tom")
print(tom)
运行结果：
Tom 来了
我是小猫[Tom]
Tom 我去了