一、面向对象
类、对象、属性、方法
对象：
hh的手机
pp的手机
bb的手机
...
对象的集合 ---》共同特征：品牌、颜色、大小、价格 动作： 打电话 发短信 上网 打游戏
类别： 手机类
学生类
特征：姓名、年龄、性别、身高、血型、婚否 ------》属性
动作：刷抖音、敲代码、看书... ------》方法
多个对象---》提取对象的共同的特征和动作 ------》封装到一个类中
二、命名规则
所有的类名要求首字母大写，多个单词使用驼峰式命名
三、属性
class 类名[(父类)]
# 类默认继承object
'''
class 类名[(父类)]：
属性:特征
方法:方法
'''
class Phone:
# 类属性
brand = 'huawei'
# 方法
# 使用类创建对象
xx = Phone()
print(xx.brand)
hh = Phone()
# 对象属性，赋值操作
hh.brand = 'iphone'
print(hh.brand)
四、方法
1、普通方法
class Phone:
brand = 'xiaomi'
price = 4999
type = 'mate 80'
# 普通方法
'''
普通方法格式：
def 方法名(self[,参数,参数]):
pass
'''
def call(self):
print('self............',self)
print('正在访问通讯录：')
for person in self.address_book:
print(person.items())
print('正在打电话......')
print('留言：',self.note)
Phone1 = Phone()
Phone1.note = '我是xxxx'
Phone1.address_book = [{'122910291':'gg'},{'12321312':'hh'},{'1232132121':'xx'}]
Phone1.call()
2、魔术方法 名字()称作魔术方法，如：init、new、call
init:
class Person:
def __init__(self,name,age):
self.name = name
self.age = age
def eat(self,food):
print('{}正在吃{}！。。。'.format(self.name,food))
def run(self):
print('{}今年{}岁，正在跑步！'.format(self.name,self.age))
P = Person('lisi',18)
P.name = '李四'
P.run()
P.eat('苹果')
new:
# 魔术方法
# __init__:初始化魔术方法
# 触发时机：初始化对象时触发(不是实例化触发，但是和实例化在一个操作中)
# __new__:实例化的魔术方法
# 触发时机：在实例化时触发
# 向内存要空间--》地址
class Person:
def __init__(self,name):
print('------>init',self)
self.name = name
# __new__要重写，要return
def __new__(cls, *args, **kwargs):
print('------>new')
print(super(Person,cls).__new__(cls,*args,**kwargs))
return super(Person,cls).__new__(cls,*args,**kwargs)
'''
代码实现步骤：
1、创建实例时，__new__会申请新开辟内存空间
2、return __new__后会进行初始化init
3、在__new__新开辟的内存空间存放name属性
4、再把放name属性的地址给到Person()
'''
p = Person('hh')
call:
# __call__:对象调用方法
# 触发时机：将对象当成函数使用的时候，会默认调用此函数中内容
# __call__把对象当做函数调用时执行
def __call__(self,name, *args, **kwargs):
print('----->call',self)
print('执行对象得到的参数是：',name)
p = Person('hh')
p('hh')
del:
# __del__:delete缩写，析构魔术方法
# 触发时机：将对象没有用(没有任何变量引用)的时候触发
'''
__del__:
1、对象赋值
p = Person()
p1 = p
说明：p和p1共同指向一个地址
2、删除地址的引用
del p1 删除p1对地址的引用
3、查看对地址的引用次数：
import sys
sys.getrefcount(p)
4、当一块空间没有了任何引用，默认执行__del__
ref = 0
'''
def __del__(self):
print('------del------')
del p2
str:
# __str__:
# 触发时机:打印对象名时，会自动触发去调用__str__里面的内容
# 注意：一定要return，return后面内容就是打印对象看到内容
class Person:
def __init__(self,name):
# print('------>init',self)
self.name = name
# 单纯打印对象名称，出来的是一个地址，没有太大意义
# 如果想在打印对象名时能够给开发者更多的一些信息量
def __str__(self):
return self.name
p = Person('hh')
print(p)
总结:魔术方法
重点：init(构造方法，创建完空间之后调用的第一个方法)，str
了解：
new:作用 开辟新内存空间
del:作用 没有指针引用的时候会调用。99%不需要重写
call:作用 将对象当成函数用
3、类方法
# 类方法
'''
特点：
1、定义需要依赖装饰器@classmethod
2、类方法中参数不是一个对象，而是类
print(cls) # <class '__main__.Dog'>
3、类方法中只可以使用类属性
4、类方法能否使用普通方法? 不能
类方法作用：
因为只能访问类属性和类方法，所以可以再对象创建之前，如果需要完成一些工作(功能)
'''
class Dog:
def __init__(self,nickname):
self.nickname = nickname
# 只有对象去调
def run(self):
print('{}在院子里跑来跑去'.format(self.nickname))
def eat(self):
print('吃饭！！！')
self.run() # 类中方法的调用，需要通过self.方法名()
# 只有类去调
@classmethod
def test(cls): # cls 就是class的简写
print(cls) # <class '__main__.Dog'>
# print(cls.nickname) 无法访问nickname
d = Dog('大王')
d.run()
d.test()
class Person:
__age = 18
def show(self):
print('----->',Person.__age)
@classmethod
def update_age(cls):
cls.__age = 20
print('----->类方法')
@classmethod
def show_age(cls):
print('修改后的年龄是,',cls.__age)
Person.update_age()
Person.show_age()
4、静态方法
'''
静态方法：很类似类方法
1、需要装饰器@staticmethod
2、静态方法无需传递参数(cls,self)
3、也只能访问类的属性和方法，对象是无法访问的
4、加载时机同类方法
'''
class Person:
__age = 18
def show(self):
print('----->',Person.__age)
@classmethod
def update_age(cls):
cls.__age = 20
print('----->类方法')
@classmethod
def show_age(cls):
print('修改后的年龄是,',cls.__age)
@staticmethod
def test():
print('------>静态方法')
# print(self.name) 语法错误
print(Person.__age)
Person.update_age()
Person.show_age()
Person.test()
五、总结
总结：
类方法 静态方法
不同：
1、装饰器不同
2、类方法是有参数的，静态方法没有参数
相同：
1、只能访问类的属性和方法，对象是无法访问的
2、都可以通过类名调用访问
3、都可以在创建对象之前使用，因为是不依赖对象
普通方法与两者的区别
不同：
1、没有装饰器
2、普通方法永远是要依赖对象，因为每个普通方法都有一个self
3、只有创建了对象才可以调用普通方法，否则无法调用
