python基础学习笔记——类与对象

python基础学习笔记——类与对象

1. python继承使用()

   class Person:
       pass
   
   class Employee(Person):
       pass
   

2. python中静态变量定义在类之中

   class Employee(Person):
       __salary = 0
       def __init__(self,name,salary):
           self.name = name
           self.__salary = salary
   
   if __name__ == '__main__':
       employee = Employee("lijiayu",3000)
       print(employee._Employee__salary) # 可以访问数据，python的数据为伪私有
       # print(employee.__salary) # 访问不到数据
       print(employee.__dict__) # 对象的__dict__中存储了一些self.xxx的一些东西
       del employee
       print(Employee.__dict__) #  类的静态函数、类函数、普通函数、全局变量以及一些内置的属性都是放在类__dict__里的
       print(Employee._Employee__salary) # 访问静态变量
       """
       运行结果：
       3000
   	{'name': 'lijiayu', '_Employee__salary': 3000}
   	{'__module__': '__main__', '_Employee__salary': 	0, '__init__': <function Employee.__init__ at 		0x00000187024C9E50>, '__doc__': None}
   	0
       """
   

3. instanceof(object,classinfo)用法和输出的结果同Java关键字instanceof基本一样

   class Employee(Person):
       __salary = 0
       def __init__(self,name,salary):
           self.name = name
           self.__salary = salary
       def getName(self):
           return self.name
       def setName(self,name):
           self.name = name
       def delName(self):
           del self.name
       x = property(getName,setName,delName) # 第一个参数获取属性，第二次参数设置属性，第三个参数删除属性
       print(isinstance(employee,Employer))
       print(hasattr(employee,"_Employee__salary")) # 判断是否有某个属性
       print(getattr(employee,"salary","属性不存在")) # 获取属性
       setattr(employee,"age",20) # 给对象新建一个属性，第二个参数为名字，第三个参数为值
       print(employee.__dict__) # 类似与Java的toString()用法
       delattr(employee,"age") # 删除对象的属性，如果不存在该属性则会报错
       print(employee.__dict__)
       employee.x = "yyyj"
       print(employee.x)
       del employee.x
       """
       运行结果：
       False
   	True
   	属性不存在
   	{'name': 'lijiayu', '_Employee__salary': 3000, 		'age': 20}
   	{'name': 'lijiayu', '_Employee__salary': 3000}
   	yyyj
       """
   

4. 工厂函数就是类对象

   print(type(int))
   print(type(list))
   print(type(Employee))
   """
   运行结果：
   <class 'type'>
   <class 'type'>
   <class 'type'>
   """
   

5. 运算符的魔法方法：

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WoOk9QBg-1612758249403)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210128191905059.png)]

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JD7A0euW-1612758249419)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210128195636549.png)]

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-f8n9DzaQ-1612758249420)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210128195542284.png)]

   class Employee(Person):
       __salary = 0
   	def __add__(self, other): # 魔法方法(定义加法行为：+)
       	return self.__salary + other._Employee__salary
   
   	def __sub__(self, other): # 魔法方法(定义减法行为：-)
       	return self.__salary - other._Employee__salary
       
           def __rsub__(self, other): # 魔法方法(定义减法是可交换的)
           return other - self._Employee__salary
       
     	employee01 = Employee("lijiayu", 3000)
       employee02 = Employee("yyyj", 4000)
       print(employee01 + employee02)
       print(employee02 - employee01)
       print(3000 - employee01) # 不实现魔法方法rsub方法就会报错
       """
       运行结果：
       7000
       -1000
       0
       """
   

6. 计时器简单实现(使用time模块和__repr__（）方法)

   import time
   
   class MyTimer:
   
       def __init__(self):
           self.__starttime = 0
           self.__runtime = 0
           self.__flag = False
   
       def start(self):
           self.__flag = True
           self.__starttime = time.localtime()
   
       def stop(self):
           if(self.__flag):
               self.__runtime = time.localtime().__getattribute__("tm_sec") - self.__starttime.__getattribute__("tm_sec") + self.__runtime
               self.__flag = False
           else:print("提示：请先调用 start()开始计时")
   
       def __add__(self, other):
           return str(self.__runtime + other.__runtime)
   
       def __sub__(self, other):
           return str(self.__runtime - other.__runtime)
   
       # def __str__(self):
       #     return str(self.__runtime)
   
       def __repr__(self): # 默认情况下，它会返回当前对象的"类名+object at+内存地址"
           return str(self.__runtime)
   
   if __name__ == '__main__':
       timer01 = MyTimer()
       timer01.stop()
       timer01.start()
       time.sleep(1)
       timer01.stop()
       print(timer01)
       timer02 = MyTimer()
       timer02.start()
       time.sleep(4)
       timer02.stop()
       print(timer02)
       print(timer01 + timer02)
       timer01.start()
       time.sleep(2)
       timer01.stop()
       print(timer01)
       """
       运行结果：
       提示：请先调用 start()开始计时
       1
       4
       5
       3
       """
   

7. getattribut(),getattr(),setattr()和delattr()魔法方法的使用

   class Test:
       def __getattribute__(self, item):
           print("getattribute")
           return super().__getattribute__(item)
       def __getattr__(self, item):
           print("getattr")
       def __setattr__(self, key, value):
           print("setattr")
           super().__setattr__(key,value)
       def __delattr__(self, item):
           print("delattr")
           super().__delattr__(item)
   
   class Rectangle:
       def __init__(self,width = 0,height = 0):
           self.width = width
           self.height = height
       def __setattr__(self, key, value):
           if(key == "square"):
               self.width = value
               self.height = value
           else:
               super().__setattr__(key,value)
               self.__dict__[key] = value # 同上可以实现
               # self.key = value # 会报错，这句导致setattr()方法被循环调用
   
       def getArea(self):
           return self.width * self.height
   
   if __name__ == '__main__':
       test = Test()
       print(test.x)
       test.x = 1
       print(test.x)
       del test.x
       print(test.x)
       """
       运行截图为：
       getattribute
       getattr
       None
       setattr
       getattribute
       1
       delattr
       getattribute
       getattr
       None
       """
   
       shape = Rectangle(2,3)
       print(shape.width)
       print(shape.height)
       print(shape.getArea())
       shape.square = 3
       print(shape.width)
       print(shape.height)
       print(shape.getArea())
       """
       运行结果：
       2
       3
       6
       3
       3
       9
       """
   

8. property类实现

   class MyTest:
       def __get__(self,instance,owner):
           print("getting",self,instance,owner)
       def __set__(self,instance,value):
           print("setting",self,instance,value)
       def __delete__(self, instance):
           print("deleting",self,instance)
   
   class My:
       x = MyTest()
   
   class MyProperty: # property类实现
       def __init__(self,fget = None,fset = None,fdel = None):
           self.fget = fget
           self.fset = fset
           self.fdel = fdel
       def __get__(self,instance,owner):
           return self.fget(instance)
       def __set__(self,instance,value):
           self.fset(instance,value)
       def __delete__(self, instance):
           self.fdel(instance)
   
   class C:
       def __init__(self):
           self._x = None
       def getX(self):
           return self._x
       def setX(self,value):
           self._x = value
       def delX(self):
           del self._x
       x = MyProperty(getX,setX,delX)
       
       
       my = My()
       print(my.x)
       print(my) # instance就是实例对象
       print(My)
       my.x = "my"
       del my.x
       """
       运行结果：
       getting <__main__.MyTest object at 0x000001FF61782E80> <__main__.My object at 0x000001FF61782A60> <class '__main__.My'>
       None
       <__main__.My object at 0x000001FF61782A60>
       <class '__main__.My'>
       setting <__main__.MyTest object at 0x000001FF61782E80> <__main__.My object at 0x000001FF61782A60> my
       deleting <__main__.MyTest object at 0x000001FF61782E80> <__main__.My object at 0x000001FF61782A60>
       """
   
       c = C()
       c.x = "ljy"
       print(c.x)
       del c.x
       """
       运行结果：
       ljy
       """
   

9. set与get的运用：

   class Celsius:
       def __init__(self,value=26.0):
           self.value = value
   
       def __get__(self,instance,owner):
           return self.value
   
       def __set__(self,instance,value):
           self.value = float(value)
   
   class Fahreheit:
       def __get__(self,instance,owner):
           return instance.cel*1.8 + 32
   
       def __set__(self,instance,value):
           instance.cel = (float(value) - 32) / 1.8
   
   class Temperature:
       cel = Celsius()
       fah = Fahreheit()
   
   if __name__ == '__main__':
       temperature = Temperature()
       print(temperature.cel)
       temperature.cel = 30.0
       print(temperature.fah) # 调用fah的__get__()方法通过instance.cel的值计算返回一个值
       temperature.fah = 100 # 调用fah的__set__()方法通过value的值计算修改instance.cel的值
       print(temperature.cel)
       """
       运行结果：
       26.0
       86.0
       37.77777777777778
       """
   

10. 魔法方法___iter___(),__next__()的使用（用于for循环里的迭代）

    class Fibs:
        def __init__(self):
            self.a = 0
            self.b = 1
        def __iter__(self):
            return self
        def __next__(self):
            self.a, self.b = self.b,self.a+self.b
            return self.a # 返回迭代器的一个结果
    
    if __name__ == '__main__':
        fib = Fibs()
        for i in fib:
            if(i < 20):
                print(i)
            else:
                break
        """
        运行结果：
        1
        1
        2
        3
        5
        8
        13
        """
    

11. 生成器

        def fibs(): #  如果一个函数中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator。调用函数就是创建了一个生成器(generator)对象
            a = 0
            b = 1
            while True:
                a,b=b,a+b
                yield a # yield相当于return返回一个值，并且记住这个返回的位置，下次迭代时，代码从yield的下一条语句开始执行
        for each in fibs():
            if each > 100:
                break
            print(each,end=" ")
        print()
    
        a = [i for i in range(10) if not i%2] # 列表推导式
        print(a)
        b = {i:i%2==0 for i in range(10)} # 字典推导式
        print(b)
        c = {i for i in [1,1,2,2,3,3,2,2,1,1]} # 集合推导式
        print(c)
        d = (i for i in range(100)) # 生成器推导式用()
        print(d)
        print(sum(d)) # 生成器本省就是一个迭代器
    """
    运行结果：
    1 1 2 3 5 8 13 21 34 55 89 
    [0, 2, 4, 6, 8]
    {0: True, 1: False, 2: True, 3: False, 4: True, 5: False, 6: True, 7: False, 8: True, 9: False}
    {1, 2, 3}
    <generator object <genexpr> at 0x000001E871F8F900>
    4950
    """
    

12. 模块

    from XXX import xx01,xx02 # 从XXX模块中导入xx01,xx02函数，可直接调用函数
    from XXX import * # 从XXX模块中导入所有函数，可直接调用函数
    import XXX as XX # 导入XXX模块并命名为XX