面向对象进阶:反射以及内置方法

一、反射

反射:使用字符串数据类型的变量名来获取这个变量的值

  input:用户输入的如果是a,那么打印1。如果输入的是b那么就打印2.如果输入name,那么打印alex

  文件:从文件中读出的字符串,想转换成变量的名字

  网络:将网络传输的字符串转换成变量的名字

1.反射类中的变量:静态属性,类方法

# class Foo:
#     School = ‘oldboy‘
#     Country = ‘China‘
#     language = ‘Chinese‘
#     @classmethod
#     def class_method(cls):
#         print(cls.School)
#     @staticmethod
#     def static_method():
#         print(Foo.School)
# # 反射实现
# while True:
#     inp = input(‘>>>‘)
#     if hasattr(Foo,inp):
#         print(getattr(Foo,inp))
#
# getattr(Foo,‘class_method‘)()
# getattr(Foo, ‘static_method‘)()

  

解析getattr方法:

# 解析getattr方法:
# getattr(变量名: 命名空间, 字符串:属于一个命名空间内的变量名)
# getattr(Foo, ‘School‘)  # 相当于Foo.School
# print(Foo.class_method)
# print(getattr(Foo, ‘class_method‘)) # 地址一样

2.反射模块中的变量

  

import os
# so.rename(‘a‘, ‘b‘)
# getattr(os, ‘rename‘)(‘a‘, ‘b‘)

  

3.反射本文件中的变量

# a = 1
# b = 2
# name = ‘alex‘
# def qqxing():
#     print(‘qqxing‘)
#
#
# import sys
# print(sys.modules[‘__main__‘])  # 本文件的命名空间
# print(sys.modules[‘__main__‘].a)
# print([__name__]) # 变量,内置的变量

分析过程

# 反射本文件中的变量  结论
# a = 1
# b = 2
# name = ‘alex‘
# def qqxing():
#     print(‘qqxing‘)
# class Foo:pass
#
# import sys
# print(sys.modules[__name__])     # 反射本文件中的变量 固定的使用这个命名空间
# print(getattr(sys.modules[__name__],‘a‘))
# print(getattr(sys.modules[__name__],‘b‘))
# print(getattr(sys.modules[__name__],‘name‘))
# getattr(sys.modules[__name__],‘qqxing‘)()
# print(getattr(sys.modules[__name__],‘Foo‘))
# obj = getattr(sys.modules[__name__],‘Foo‘)()
# print(obj)

结论

4.setattr

# class Foo:
#     Country = ‘China‘
#
# def func():
#     print(‘qqxing‘)
# Foo.School = ‘OLDBOY‘
# setattr(Foo,‘School‘,‘OLDOBY‘)  # 接受三个参数 命名空间 ‘变量名’ 变量值
# print(Foo.__dict__)
# print(getattr(Foo,‘School‘))
# print(Foo.School)
# #
# setattr(Foo,‘func‘,func)  # 一般没人往空间中添加函数
# print(Foo.__dict__)
# print(Foo.func)

  

5.delattr

# delattr
# del Foo.Country
# print(Foo.__dict__)
# delattr(Foo,‘Country‘)
# print(Foo.__dict__)

 

 

二、内置方法

定义:不需要程序员定义,本身就存在类中的方法就是内置方法

内置方法的形式:__名字__

名字又称为:双下方法,魔术方法,内置方法

作用:不需要我们主动调用,而是实例化时内部自动调用的。

  所有的双下方法,都不需要我们直接区调用,都有另外一种自动触发他的语法。

1.__str__ 和 __repr__

# __str__ __repr__
# class Course:
#     def __init__(self,name,period,price,teacher):
#         self.name= name
#         self.period = period
#         self.price = price
#         self.teacher = teacher
#
#     def __str__(self):
#         return ‘str : %s %s %s %s‘ % (self.name, self.period, self.price, self.teacher)
#
#     def __repr__(self):
#         return ‘repr : %s %s %s %s‘ % (self.name, self.period, self.price, self.teacher)
# course_lst = []
# python = Course(‘python‘,‘6 month‘,29800,‘boss jin‘)
# course_lst.append(python)
# linux = Course(‘linux‘,‘5 month‘,25800,‘oldboy‘)
# course_lst.append(linux)
# for id,course in enumerate(course_lst,1):
    # print(‘%s %s %s %s %s‘%(id,course.name,course.period,course.price,course.teacher))
    # print(id,course)
    # print(‘%s %s‘%(id,course))
    # print(str(course))
    # print(repr(course))
    # print(‘%r‘%course)

  

区别

__str__
当你打印一个对象的时候 触发__str__
当你使用%s格式化的时候 触发__str__
str强转数据类型的时候  触发__str__

__repr__
repr是str的备胎
有__str__的时候执行__str__,没有实现__str__的时候,执行__repr__
repr(obj)内置函数对应的结果是 __repr__的返回值
当你使用%r格式化的时候 触发__repr__

  

顺序

子类有__str__:Son.str
子类没有__str__:找父类,Foo.str

子类父类都没有__str__:Son.repr

子类父类都没有str,子类有repr:Son.repr
否则:Foo.repr

  

class Foo:
    # def __str__(self):
    #     return ‘Foo.str‘
    def __repr__(self):
        return ‘Foo.repr‘

class Son(Foo):
    pass
    # def __str__(self):
    #     return ‘Son.str‘

    # def __repr__(self):
    #     return ‘Son.repr‘

s1 = Son()
print(s1)

  

原文地址:https://www.cnblogs.com/eaoo/p/9567511.html

时间: 2024-11-06 15:20:21

面向对象进阶:反射以及内置方法的相关文章

Python学习【第14篇】:面向对象之反射以及内置方法

面向对象之反射及内置方法 一.静态方法(staticmethod)和类方法(classmethod) 类方法:有个默认参数cls,并且可以直接用类名去调用,可以与类属性交互(也就是可以使用类属性) 静态方法:让类里的方法直接被类调用,就像正常调用函数一样 类方法和静态方法的相同点:都可以直接被类调用,不需要实例化 类方法和静态方法的不同点: 类方法必须有一个cls参数表示这个类,可以使用类属性 静态方法不需要参数 绑定方法:分为普通方法和类方法 普通方法:默认有一个self对象传进来,并且只能被

面向对象的进阶---反射--一些内置方法

反射 反射和一些类的内置方法 1 isinstance ---- issubclass type()--判断 是不是 ininstance(object,cls) 判断 是不是类的对象 如果这个类有父类 这个对象也是这个父类的对象 issubclaaa(cls,cls) 判断一个类是不是另一个类的子类 ============================= 反射 ================================= 把一个字符串 类型的变量 变成一个 真实存在这个程序中的变量名

面向对象之反射及内置方法

一.静态方法(staticmethod)和类方法(classmethod) 类方法:有个默认参数cls,并且可以直接用类名去调用,可以与类属性交互(也就是可以使用类属性) 静态方法:让类里的方法直接被类调用,就像正常调用函数一样 类方法和静态方法的相同点:都可以直接被类调用,不需要实例化 类方法和静态方法的不同点: 类方法必须有一个cls参数表示这个类,可以使用类属性 静态方法不需要参数 绑定方法:分为普通方法和类方法 普通方法:默认有一个self对象传进来,并且只能被对象调用-------绑定

面向对象:反射、内置方法

反射:通过字符串映射到对象或者类的属性 反射的方法: class People: country = "China" def __init__(self,name,age): self.name = name self.age = age def talk(self): print("%s is talking" % self.name) obj = People("neo",22) """ 判断是否拥有某个属性:

python全栈开发【第十七篇】面向对象反射和内置方法

一.静态方法(staticmethod)和类方法(classmethod) 类方法:有个默认参数cls,并且可以直接用类名去调用,可以与类属性交互(也就是可以使用类属性) 静态方法:让类里的方法直接被类调用,就像正常调用函数一样 类方法和静态方法的相同点:都可以直接被类调用,不需要实例化 类方法和静态方法的不同点: 类方法必须有一个cls参数表示这个类,可以使用类属性 静态方法不需要参数 绑定方法:分为普通方法和类方法 普通方法:默认有一个self对象传进来,并且只能被对象调用-------绑定

面向对象-反射-其他内置方法

1.反射 1.1反射含义 通过字符串的形式操作对象的相关属性.方法有hasattr,getattr,delattr #!/usr/bin/env python # -*- coding:utf-8 -*- # Author: vita class People: country='China' def __init__(self,name,age): self.name=name self.age=age def talk(self): print('%s is talking' %self.n

issubclass和isinstance,反射,内置方法

目录 面向对象进阶 一.issubclass 和 isinstance 1.1 issubclass 1.2 isinstance 二.反射 2.1 什么是反射 2.2 四个可以通过字符串操作对象属性和方法的内置函数 2.2.1 hasattr() 2.2.2 getattr() 2.2.3 setattr() 2.3.4 delattr() 三.内置方法 3.1 __str__和__repr__ 3.2 点拦截方法:__setattr__,__delattr__,__getattr__ 3.3

day27 反射、内置方法

一.isinstance和issubclass class Foo: pass class Son(Foo): pass s = Son() #判断一个对象是不是这个类的对象,传两个参数(对象,类) # print(isinstance(s,Son)) # print(isinstance(s,Foo)) # print(type(s) is Son) # print(type(s) is Foo) #判断一个类是不是另一类的子类,传两个参数(子类,父类) print(issubclass(So

Learning-Python【26】:反射及内置方法

反射的概念 可以用字符串的方式去访问对象的属性,调用对象的方法(但是不能去访问方法),Python 中一切皆对象,都可以使用反射. 反射有四种方法: hasattr:hasattr(object, name)判断一个对象是否有 name 属性或者 name 方法.有就返回 True,没有就返回 False getattr:获取对象的属性或者方法,如果存在则打印出来.hasattr 和 getattr 配套使用 需要注意的是,如果返回的是对象的方法,返回出来的是对象的内存地址,如果需要运行这个方法