python 类与对象

深拷贝和浅拷贝
深拷贝：拷贝出来的新对象和原对象是不一样，内存地址也不一致，原有对象怎么改变都不会影响当前对象，修改拷贝后的对象中的数据不会影响原对象内容。
浅拷贝：对象不一样，但是对象里面的可变元素的地址相同，修改拷贝后的对象中的数据会影响原对象内容。

import copy
list1 =[['北京多测师','成都多测师'],'上海多测师','深圳多测师']
list2=copy.deepcopy(list1)#进行深拷贝
#打印两个列表的内存地址--不一致
print(id(list1))#2889322336584
print(id(list2))#2889320181640
#打印两个子列表的内存地址
print(id(list1[0]))#2787285524296
print(id(list2[0]))#2787283378120
#修改拷贝后list2
list2[0][0]='杭州多测师'
print(list2)
print(list1)
#打印修改后的列表，结果list2列表修改了，但不影响list1列表数据
浅拷贝 可理解为藕断丝连
修改拷贝后的内容,原对象内容随之改变
import copy
list1 =[['北京多测师','成都多测师'],'上海多测师','深圳多测师']
list2=copy.copy(list1)#进行浅拷贝
#打印两个列表的内存地址--不一致
print(id(list1))#2970537758984
print(id(list2))#2970535599944
#打印两个子列表的内存地址--结果一致
print(id(list1[0]))#2970537746312
print(id(list2[0]))#2970537746312
#修改list2列表数据
list2[0][0]='杭州多测师'
print(list2)
print(list1)
#打印修改后的列表，结果list1列表数据随之改变

类与对象
类：class 用来描述具有相同属性和方法的对象的集合；
可以理解是一个模板，通过它可以创建出无数个具体实例；
对象：类不能直接使用，通过类创建出实例(又称对象)
这个有点像汽车图纸和汽车的关系，图纸本身(类)不能被人直接使用，
通过图纸创造出汽车(对象)才能使用；
对象和类的关系：就像模具和铸件的关系
类的实例化的结果就是对象，而对象的抽象体就是类；
属性：类中所有变量称为属性
在python中定义类是通过class 关键字
class Dcs(object):
注：class 后面紧接着是类名称，即Dcs 类名称通常大写开头，
后面(object)表示该类从哪个类继承下来的，如果没有合适的类。
就使用object类
类名称定义
不要以纯数字命名
不要以python中保留字符命名
不要以文件名命名
要简短且见名知意
当类名称有多个单词，应采用驼峰式(单词首字母大写)--Dcs()
class dcs1(object):#定义类
def add(self,a,b):#类方法(通过对象调用)
return a + b
def reduce(self,a,b):
return a - b
def ride(self,a,b):
return a * b
def Excrpt(self,a,b):
return a / b
p=dcs1()#创建对象
print(p.add(2,3))#通过对象调用方法
print(p.ride(2,3))
print(p.reduce(5,2))
print(p.Excrpt(4,2))
class dcs2():#定义类
def __init__(self,a,b):#构造函数
self.a=a#实例变量
self.b=b
def add(self):  # 类方法(通过对象调用)
return self.a + self.b
def reduce(self):
return self.a - self.b
def ride(self):
return self.a * self.b
def Excrpt(self):
return self.a / self.b
p=dcs2(12,4)#实例化创建对象
print(p.add())#对象调用方法
print(p.ride())
print(p.reduce())
print(p.Excrpt())
当类中的__init__中有参数存在时，则实例化时需要往实例化括号中传入参数，
不存在参数时，则实例化时不需要往实例化括号中传入参数，而在调用方法时进行传参；
class A(object) #新式类
class c:#经典类
python3当中：默认继承object类,所以不区分新式类和经典类
python2当中：没有默认继承的，需要自己取继承，所以它是区分新式类和经典类
a =300 #普通的全局变量
class dcs():#定义类
a1=200#类变量(如果方法中要调用它需要加self)
def __init__(self,name):#构造函数
self.a2=name#把形参变为实例变量(类的全局变量)
#实例变量在当前类中，只要是带有self的都可以取使用
def A1(self):
print(self.a2)#调用实例变量
print(self.a1)#调用类变量
print(a)#调用普通全局变量
if __name__ == '__main__':
c=dcs(100)#创建对象
c.A1()#对象调用方法


实例方法、静态方法、类方法的区别：
1.参数的区别
实例方法：定义实例方法时最少有一个形参--实例对象，通常self
类方法：定义类方法时最少有一个形参--类对象，通常cls
静态方法：定义静态方法时可以不用定义形参

2.方法定义时添加装饰器的区别
实例方法：不需要加装饰器
类方法：需要加装饰器-->@classmethon
静态方法：需要加装饰器-->@staticmethon

调用：
实例方法：通过对象直接调用，需要用类名称创建一个对象
类方法：可以通过类名称直接调用，也可以通过对象来调用（类方法不能访问实例变量，只能访问类变量）
静态方法：可以通过类名称直接调用，也可以通过对象来调用（静态方法不可以继承）
案例：
class student():#定义类
    age=33 #类变量
    def __init__(self):
        self.name='lilei' #实例变量
    def run(self):#实例方法
        print('{}岁的{}正在跑步!'.format(self.age,self.name))
    @classmethod
    def eat(cls):#类方法
        # print(cls.name)#类方法不能访问实例变量
        print("hanmeimei{}岁了".format(cls.age))
    @staticmethod
    def sleep(name):#静态方法，与类无关，只是类中的一个功能，静态方法不能访问实例变量
        print('{}在睡觉'.format(name))
a=student()
a.run()
student.run(a)#通过类名称调用实例方法，需要在方法中传入实例对象
student.eat()#通过类名称调用类方法
a.eat()#通过对象调用类方法
student.sleep('lily')#通过对象调用静态方法

类的继承特性
案例1：
class teacher():#定义父类
def __init__(self,name):
self.name=name
def Name(self):
print("my mother is {}".format(self.name))

class myself(teacher): #对父类方法重写
def Name(self):
print("my name is {}".format(self.name))
m=myself('X')
m.Name()

案例2：
class mother():
def bobby(self):
print('mother love shop')

class father:
def work(self):
print('father is a test engineer')
class son(father,mother):#多继承
pass
myself=son()
myself.bobby()
myself.work()
print(son.mro())