Python语法之面向对象思维导图

左手的ㄟ右手 2023-10-10 11:41 70阅读 0赞

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n_size_16_color_FFFFFF_t_70][]

Python3 相关功能代码:

import io
    import sys
    import math
    # 调用reduce 函数
    from functools import reduce
     
    sys.stdout = io.TextIOWrapper(sys.stdout.detach(),encoding='utf-8')
    
    # Python3 高阶函数之函数即变量
    
    # print函数赋值给变量p
    p = print
    # 通过变量p 调用print函数
    p("高阶函数之函数即变量")
    
    # Python3 高阶函数之传入函数
    
    def add(x,y,z):
        return abs(x) + abs(y)
    result = add(-11,128,abs)
    print("result is：",result)
    
    # Python3 匿名函数
    
    r = 10
    area = lambda r:math.pi*r*r
    print('半价为',r,'的面积为:',area(r))
    
    # Python3 map 函数
    
    number =[1,2,3,4,5,6,7,8,9]
    print(list(map(lambda x: x*x, number)))
    
    # Python3 reduce 函数
    
    number =[1,2,3,4,5,6,7,8,9]
    print(print(reduce(lambda x,y:x+y, number)))
    
    # Python3 filter 函数
    
    st =['A', '', 'C', 'D', '']
    print(list(filter(lambda x: x and x.strip(),st)))
    
    # Python3 sorted 函数之数字排序
    
    a =[11,90,-1,20,17]
    print(sorted(a))
    
    # Python3 sorted 函数之字符串排序
    
    aa =['a','12','b','z']
    print(sorted(aa))
    
    # Python3 之函数实现面向对象编程
    #函数实现面向对象编程
    def person(name,age,gender):  #理解一个人种类
        def play(name):
            print("[%s],正在玩python" %(name['name']))
        def eat(name):
            print("[%s]正在吃饭"%(name["name"]))
        def init(name,age,gender):
            person1 = {
                "name":name,
                "age":age,
                "gender":gender,
                "play":play,
                "eat":eat
            }
            return person1
        return  init(name,age,gender)
    aa = person("肉肉",2,"male")  #可以简单理解为生成了一个人的实例
    aa["play"](aa) #调用人的方法
    aa["eat"](aa)
    
    # Python 3 类定义
    class Data:
        '''类定义'''
        pass
    obj = Data()
    print(type(obj))
    
    # Python3 类属性
    class China:
        people='Chinese'
    print('China 类属性people:' + China.people)
    
    # Python3 类方法
    class English:
        def speak(self):
            print("%s 是个发达国家" %self)
    
    country ='英国'
    English.speak(country)
    
    # Python3 输出类属性和方法方式一
    print(dir(China))
    # Python3 输出类属性和方法方式二
    print(English.__dict__)
    # Python3 输出类指定属性或方法
    print(English.__dict__['speak'])
    
    # Python3 实例对象
    class Student:
        def __init__(self,name,age,gender):
            self.name = name
            self.age = age
            self.gender = gender
        def score(self):
            print("%s 成绩是99 "%self.name)
        def play(self):
            print("%s 喜欢玩球，年龄是 %s" %(self.name,self.age))
    
    one = Student("肉肉",2,"male")
    print(one.name)
    one.score()
    one.play()
    
    # Python3 类的静态方法
    class People(object):
        def __init__(self, name):
            self.name = name
        @staticmethod
        def eat(food):
            print('肉肉 is eating %s' % food)
    rourou = People('肉肉')
    rourou.eat('牛肉')
    
    # Python3 类方法
    class Person(object):
        name = '肉肉'
        def __init__(self, name):
            self.name = name
        @classmethod
        def eat(self, food):
            print('%s is eating %s' % (self.name, food))
    meta = Person('肉肉')
    meta.eat('牛肉')
    
    # Python3 静态属性之删除
    class Man(object):
        def __init__(self, name):
            self.name = name
            self.__food = None
        @property
        def eat(self):
             print('%s is eating %s' % (self.name, self.__food))
        @eat.setter
        def eat(self, food):
            # print('set food to eat', food)
            self.__food = food
        @eat.deleter
        def eat(self):
            del self.__food
    
    sheep = Man('肉肉')
    sheep.eat = '鹿肉'
    sheep.eat
    del sheep.eat
    
    # Python3 之子类调用父类的方法
    class Vehicle:  # 定义交通工具类    父类
        def __init__(self, name, speed, load, power):
            self.name = name
            self.speed = speed
            self.load = load
            self.power = power
        def run(self):
            print('开动啦...')
    class Subway(Vehicle):  # 地铁   子类
        def __init__(self, name, speed, load, power, line):
            super(Subway,self).__init__(name,speed,load,power) #注：调用父类的属性
            self.line = line
        def run(self):
            print('地铁%s号线欢迎您' % self.line)
            super(Subway,self).run()   #子类调用父类的方法supper
    line13 = Subway('中国地铁', '180m/s', '1000人/箱', '电', 13)
    line13.run()
    
    # Python3 之面向对象之类型判断
    class Foo(object): #父类
         pass
    class Bar(Foo): #父类的派生类
        pass
    print(issubclass(Bar, Foo))  #True
    
    # Python 3 面向对象之反射
    class BlackMedium:
        feature='Ugly'
        def __init__(self,name,addr):
            self.name=name
            self.addr=addr
     
        def sell_house(self):
            print('%s 黑中介卖房子啦,傻逼才买呢,但是谁能证明自己不傻逼' %self.name)
        def rent_house(self):
            print('%s 黑中介租房子啦,傻逼才租呢' %self.name)
     
    b1=BlackMedium('万成置地','回龙观天露园')
     
    # 检测是否含有某属性
    print(hasattr(b1,'name'))
    print(hasattr(b1,'sell_house'))
     
    # 获取属性
    n=getattr(b1,'name')
    print(n)
    func=getattr(b1,'rent_house')
    func()
    
     
    # 设置属性
    setattr(b1,'sb',True)
    setattr(b1,'show_name',lambda self:self.name+'sb')
    print(b1.__dict__)
    print(b1.show_name(b1))
     
    # 删除属性
    delattr(b1,'addr')
    delattr(b1,'name')
    #delattr(b1,'show_name111')#不存在,则报错
    
    # Python3 之getattr__和__getattribute__
    class Foo:
        # def __setattr__(self, key, value):
        #     print("setaaaa")
        #     self.__dict__[key] = value
        def __getattr__(self, item): #可以把__getattr__和__getattribute__分别注释看看
            print("执行getattr")
        def __getattribute__(self, item):
            print("执行attribute") #无论有没有该属性，都执行
            raise AttributeError("这是错误异常")    #遇到异常 ，去执行__getattr__
            #raise 错误属性    （"抛出异常的错误内容"）
     
    aa = Foo()
    aa.ssssss #不存在该属性会执行__getattribute__xxxxxxxxxx
    
    
    
    #__setitem__,__getitem,__delitem__
    class Foo:
        def __init__(self,name):
            self.name = name
        def __getitem__(self, item):
            print("执行getitem")
            return self.__dict__[item]
        def __setitem__(self, key, value):
            print("执行setitem")  #为了让效果明显所以用print
            self.__dict__[key] = value
        def __delitem__(self, key):
            print("del obj[key],执行")
            self.__dict__.pop(key)
        def __delattr__(self, item):
            print("del obj.key,执行")
            self.__dict__.pop(item)
     
    n = Foo("xiaoxi")
    # print(n.__dict__)
    # del n.name   #执行delattr
    # del n["name"] #执行delitem
     
    n["age"] = 18  #执行setitem
    print(n["age"]) #执行getitem
    # __setattr__,__delattr__,__getattr__
    class Foo1:
        x=1
        def __init__(self,y):
            self.y=y
     
        def __getattr__(self, item):
            print('----> from getattr:你找的属性不存在')
     
     
        def __setattr__(self, key, value):
            print('----> from setattr')
            # self.key=value #这就无限递归了,你好好想想
            self.__dict__[key]=value #应该使用它
     
        def __delattr__(self, item):
            print('----> from delattr')
            # del self.item #无限递归了
            self.__dict__.pop(item)
     
    #__setattr__添加/修改属性会触发它的执行
    f1=Foo1(10)
    print(f1.__dict__) # 因为你重写了__setattr__,凡是赋值操作都会触发它的运行,你啥都没写,就是根本没赋值,除非你直接操作属性字典,否则永远无法赋值
    f1.z=3  #添加
    print(f1.__dict__)
     
    #__delattr__删除属性的时候会触发
    f1.__dict__['a']=3#我们可以直接修改属性字典,来完成添加/修改属性的操作
    del f1.a
    print(f1.__dict__)
     
    #__getattr__只有在使用点调用属性且属性不存在的时候才会触发
    f1.xxxxxx
    
    # _str__,__repr__
    class Bar:
        def __init__(self,name,age):
            self.name = name
            self.age = age
     
        def __str__(self):
            print("this str")
            return "名字是%s age%s" %(self.name,self.age)
        def __repr__(self):  #转换字符串，在解释器中执行
            print("thsi repr")
            return "%s" %self.name
     
     
     
    test = Bar("xi",10)
    print(test)
    print(test.__repr__()) #print(repr(test))   执行的是__repr__
    
    # __format__
    #和生成实例化对象的内容相对应
    menu = {"ymd":"{0.year}{0.month}{0.day}", 
            "y-m-d":"{0.year}-{0.month}-{0.day}"} 
     
    class Foo:
        def __init__(self,year,month,day):
            self.year = year
            self.month = month
            self.day = day
        def __format__(self, format_spec):  #format_spec指定格式化的类型
            # print(format_spec,self)
            if not format_spec or format_spec not in menu: #如果没有传入格式，或则在menu中没有这个格式
                format_spec = "ymd" #则格式化的默认格式是ymd ，在menu中有
            fm = menu[format_spec]  #通过menu字典格式化成相应格式的类型
            # print(fm)
            return fm.format(self)  #把对象传入，格式化的内容
     
     
    ss = Foo(2016,12,26)
    # print(format(ss,"ymd"))
    print(format(ss,"y-m-d"))
    print(format(ss,"4565456"))
    # __next__和__iter__
    class Foo:
        def __init__(self,n):
            self.n = n
        def __iter__(self):
            return self
        def __next__(self):
            if self.n ==15:
                raise StopIteration("已经迭代完了")   #抛出异常的提示信息  StopIteration: 已经迭代完了
            self.n += 1
            return self.n
     
    aa = Foo(10)
    print(aa.n)
    print(next(aa))
    print(next(aa))
    print(next(aa))
    print(next(aa))
    print(next(aa))
    print(next(aa))

参考文章地址:[https://www.cnblogs.com/keme/p/6220853.html\#auto\_id\_15][https_www.cnblogs.com_keme_p_6220853.html_auto_id_15]

[https://www.cnblogs.com/zhangxinqi/p/8081731.html][https_www.cnblogs.com_zhangxinqi_p_8081731.html]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20201021002112122.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n,size_16,color_FFFFFF,t_70
[https_www.cnblogs.com_keme_p_6220853.html_auto_id_15]: https://www.cnblogs.com/keme/p/6220853.html#auto_id_15
[https_www.cnblogs.com_zhangxinqi_p_8081731.html]: https://www.cnblogs.com/zhangxinqi/p/8081731.html