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

 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/zhangxinqi/p/8081731.html