措施和函数,python之面向对象

一丶,isinstance/issubclass/type

第拾章 尤其空虚

![](http://picture-repository-of-heamon7.qiniudn.com/Python基础教程-第九章
特别抽象.png)

面向对象的知识点补充(进阶版)

classmethod和staticmethod:那七个函数的用途就是足以毫不实例化对象就可以调用方法

class Classmethod_Demo():
    role = 'dog'

    @classmethod
    def func(cls):
        print(cls.role)

Classmethod_Demo.func()


class Staticmethod_Demo():
    role = 'dog'

    @staticmethod
    def func():
        print("当普通方法用")

Staticmethod_Demo.func()

 

简介:

概念函数:

def xx():  

  print(“xxx”)

进行函数

xx()

  1.issubclass检讨第四个参数是不是是第1个参数的 子子孙孙类

class Foo():
    pass
class Boo(Foo):
    pass
class Aoo(Boo):
    pass
print(issubclass(Boo,Foo))      #True
print(issubclass(Aoo,Foo))      #True

第8章 特别空虚

isinstance和issubclass

  isinstance是用来检查实例化的靶子是还是不是是由想检查的类实例化出来的,重临的是布尔值。isinstance(obj,t)

class Fruit:
    def __init__(self,name):
        self.name=name

class Vegetable:
    def __init__(self,name):
        self.name=name

b=Fruit('banana')
print(isinstance(b,Fruit))#True
print(isinstance(b,Vegetable))#False

  issubclass是用来检查四个类是还是不是是想检查的类的子类,重返的是布尔值。issubclass(cls,classinfo)

class Plant:
    def __init__(self,name):
        self.name=name

class Fruit(Plant):
    def __init__(self,name):
        self.name=name

class Vegetable:
    def __init__(self,name):
        self.name=name

print(issubclass(Fruit,Plant))#True
print(issubclass(Fruit,Vegetable))#False

 

 

函数重返值:

def emile():
    print("发邮件")
    return '123'
r = emile()
print(r)

结果:
发邮件
123

上述中,return为再次来到值,重临给r。return想回来什么就回来什么,借使没有写再次来到值,就赶回None,就是空。

def emile():
    if True:
        return True
    else:
        return False
ret = emile()

if ret:
    print('好的')
else:
    print('滚')

结果:
好的

  2.type到手当前目的是由尤其类成立。

class Foo(object):
    pass

obj = Foo()

print(obj,type(obj))     #<__main__.Foo object at 0x000001B58F579D68> <class '__main__.Foo'>
if type(obj) == Foo:
    print('obj是Foo类型')  #obj是Foo类型

7.1 对象的魅力

对象最根本的亮点就是:多态(不相同类的目标使用同样地操作),封装(对外表世界隐藏对象的工作细节),继承(以普通类为底蕴建立专门的类对象)

不晓得对象是如何类型,又要执行某个操作时,就动用到了多态。唯一能毁掉多态的就是行使函数显式检查项目,如type,isinstance,issubclass函数等。那种多态格局被号称鸭子类型。从静态类型语言转化动态类型语言的用户寻常试图添加一些静态的(在运转从前的)类型检查,从而影响了鸭子类型的便宜和可伸缩性,并约束了言语的动态特性。

反射

python面向对象中的反射:通过字符串的样式操作对象相关的性质。python中的一切事物都以目的(都足以行使反射)

多个可以完结自省的函数:hasattr,getattr,setattr,delattr(前边三个不常用,日常不引进应用)

上述多少个函数适用于类和对象(一切皆对象,类自己也是3个对象)

上面用代码来提现每一个函数的功能:

class Sport:
    def __init__(self,name,place):
        self.name=name
        self.place=place
    def play(self):
        print('i like %s'%self.name)
    def where(self):
        print('we play at %s'%self.place)

bas=Sport('basketball','ground')
#hasattr#查看属性,返回布尔值
print(hasattr(bas,'name'))#检测是否有属性,输出布尔值

#getattr#得到属性,可以调用方法
print(getattr(bas,'where'))#检测是否有属性,输出的是方法的内存地址
n=getattr(bas,'where')
print(n)#检测是否有属性,与上面一个print里的内容一模一样,输出的是方法的内存地址
func=getattr(bas,'where')
func()#调用方法,输出为we play at ground
# print(getattr(bas,'price'))#不存在即报错
print(getattr(bas,'price','不存在啊'))#设置默认值即不报错,输出默认值

#setattr可以更改属性,不推荐使用
setattr(bas,'price',100)#新设置一个属性
print(bas.price)
setattr(bas,'show_name',lambda self:self.name+' good')
print(bas.show_name(bas))#basketball good

#delattr#删除属性,不推荐使用
delattr(bas,'place')
# delattr(bas,'name111')#不存在,则报错
print(bas.__dict__)

 

类也是目标,自然也足以选拔上述函数:

class Foo(object):

    staticField = "old boy"

    def __init__(self):
        self.name = 'alex'

    def func(self):
        return 'func'

    @staticmethod
    def bar():
        return 'bar'

print getattr(Foo, 'staticField')
print getattr(Foo, 'func')
print getattr(Foo, 'bar')

 

也得以用来反光当前模块成员:

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import sys
def s1():
    print 's1'
def s2():
    print 's2'

this_module = sys.modules[__name__]
hasattr(this_module, 's1')
getattr(this_module, 's2')

 

导入其余模块,利用反射查找该模块是或不是存在有些方法

#文件一
#!/usr/bin/env python
# -*- coding:utf-8 -*-

def test():
    print('from the test')

#文件二
#!/usr/bin/env python
# -*- coding:utf-8 -*-

"""
程序目录:
    module_test.py
    index.py

当前文件:
    index.py
"""

import module_test as obj

#obj.test()

print(hasattr(obj,'test'))

getattr(obj,'test')()

 

 

 

函数的平凡参数:

def i1(p,q,r):    #p,q,r为形参
    print(p,q,r)    #打印出p,q,r的值    
    return True    #返回True
ret = i1('11',[22,11],'33')      #i1里面的为实参,是按照顺序给形参值
print(ret)

结果:
11 [22, 11] 33
True

一经实参不是循规蹈矩顺序给形参值的景观:(在实参内钦定就行了)

def i1(p,q,r):
    print(p,q,r)
    return True
ret = i1(q = '11',p = [22,11],r = '33')
print(ret)

结果:
[22, 11] 11 33
True

  type练习

澳门葡京备用网址 1澳门葡京备用网址 2

class Foo(object):
    pass

class Bar(object):
    pass

def func(*args):
    foo_counter =0
    bar_counter =0
    for item in args:
        if type(item) == Foo:
            foo_counter += 1
        elif type(item) == Bar:
            bar_counter += 1
    return foo_counter,bar_counter

result = func(Foo(),Bar(),Foo())
print(result)   #(2, 1)

v1,v2 = func(Foo(),Bar(),Foo())
print(v1,v2)    #2 1

type练习

7.2类和体系

有着的靶子都属于某1个类,成为类的实例。新式类的语法是在各种模块或脚本开首的地点停放赋值语句metaclass=type,可能接续新式类比如object

类中的每一种函数都应当把类实例作为第二个参数传入函数中,一般形象的命名为self,没有它的话,成员方法就心急火燎访问他们要对其特点开展操作的对象自小编了。self方法正是艺术和函数的分别,方法(准确说是绑定方法)将它们的第二个参数绑定到1个惯常函数上。

措施和函数,python之面向对象。为了让艺术成为私有的(从表面无法直接访问)定义时得以在措施前拉长双下划线,外界无法直接访问,内部还能用self.__func()访问,实际上外部还是得以经过class._Class__func()访问

在类中的方法外定义的变量,可以供全部类的积极分子(实例)访问。一旦有个别实例对这一个变量举行改动,那一个实例中的该变量就会就会私有化

将别的类名写在class语句后的圆括号内可以内定超类,子类可以重写超类中或多或少函数的概念

判定三个类是还是不是为另一个类的子类,能够利用内建的函数issubclass,要知道已知类的基类们,可以接纳它的异样品质base,还足以用isinstance方法检查3个对象是不是是一个类的实例,想了然3个类属于哪个类,能够利用class特点。新式类也足以行使type()函数查看实例的类

1个类能够有四个超类,先两次三番的类中的方法会重写后两次三番的类中的方法

hasattr()函数可以查看类是或不是包涵有些属性,callable(getattr(,,)函数也得以,而且只要天性不设有可以安装暗中认同值,更直接的主意是setattr(,,)函数

以下内容供进阶精通

函数的默许值:

temp = ""
def drive(name="小七"):  #这里的name = "小七",就是函数默认值,当函数没有给name实参时,就会用默认值。注意默认值,都会放在形参的最后的位置。
    temp = name + "开车"
    return temp

ret = drive("小二")
print(ret)

ret = drive("小三")
print(ret)

ret = drive()
print(ret)

结果:
小二开车
小三开车
小七开车

  3.isinstance,检查第一个参数(对象)是还是不是是第1个参数(类及父类)的实例。

class Base(object):
    pass

class Foo(Base):
    pass

obj1 = Foo()
print(isinstance(obj1,Foo))  # 检查第一个参数(对象)是否是第二个参数(类及父类)的实例。
print(isinstance(obj1,Base)) # 检查第一个参数(对象)是否是第二个参数(类及父类)的实例。

obj2 = Base()
print(isinstance(obj2,Foo))  # 检查第一个参数(对象)是否是第二个参数(类及父类)的实例。
print(isinstance(obj2,Base)) # 检查第一个参数(对象)是否是第二个参数(类及父类)的实例。

 

  

7.3部分关于面向对象的设计的思维

__str__、__repr__、__format__、__del__、__call__、__len__、__hash__、__eq__澳门葡京备用网址 ,、__item__系列

转移目标的字符串展现__str__,__repr__

自定制格式化字符串__format__

#_*_coding:utf-8_*_

format_dict={
    'nat':'{obj.name}-{obj.addr}-{obj.type}',#学校名-学校地址-学校类型
    'tna':'{obj.type}:{obj.name}:{obj.addr}',#学校类型:学校名:学校地址
    'tan':'{obj.type}/{obj.addr}/{obj.name}',#学校类型/学校地址/学校名
}
class School:
    def __init__(self,name,addr,type):
        self.name=name
        self.addr=addr
        self.type=type

    def __repr__(self):
        return 'School(%s,%s)' %(self.name,self.addr)
    def __str__(self):
        return '(%s,%s)' %(self.name,self.addr)

    def __format__(self, format_spec):
        # if format_spec
        if not format_spec or format_spec not in format_dict:
            format_spec='nat'
        fmt=format_dict[format_spec]
        return fmt.format(obj=self)

s1=School('oldboy1','北京','私立')
print('from repr: ',repr(s1))#from repr:  School(oldboy1,北京)
print('from str: ',str(s1))#from str:  (oldboy1,北京)
print(s1)#(oldboy1,北京)

'''
str函数或者print函数--->obj.__str__()
repr或者交互式解释器--->obj.__repr__()
如果__str__没有被定义,那么就会使用__repr__来代替输出
注意:这俩方法的返回值必须是字符串,否则抛出异常
'''
print(format(s1,'nat'))#oldboy1-北京-私立
print(format(s1,'tna'))#私立:oldboy1:北京
print(format(s1,'tan'))#私立/北京/oldboy1
print(format(s1,'asfdasdffd'))#oldboy1-北京-私立

 

class B:
     def __str__(self):
         return 'str : class B'

     def __repr__(self):
         return 'repr : class B'

b=B()
print('%s'%b)#repr : class B
print('%r'%b)#str : class B

 

__del__

析构方法,当对象在内存中被假释时,自动触发执行。

注:此措施一般不要定义,因为Python是一门高级语言,程序员在运用时无需关心内存的分配和假释,因为此工作都以付诸Python解释器来执行,所以,析构函数的调用是由解释器在拓展垃圾回收时自动触发执行的。

class Foo:
    def __del__(self):
        print('执行我啦')
f1=Foo()
del f1
print('------->')

#输出结果
执行我啦
------->

 

__call__

对象前边加括号,触发执行。

注:构造方法的推行是由创设对象触发的,即:对象 =
类名() ;而对此 __call__
方法的进行是由对象后加括号触发的,即:对象() 只怕 类()()

class Foo:
    def __init__(self):
        pass
    def __call__(self, *args, **kwargs):
        print('__call__')


obj = Foo() # 执行 __init__
obj()       # 执行 __call__

 

__len__

相当于内置的len()方法,纯粹检查长度

class A:
    def __init__(self):
        self.a = 1
        self.b ='b'

    def __len__(self):
        return len(self.__dict__)
a = A()
print(len(a))#2  其实电泳len方法的时候就是python在内部实现了__len__

 

__hash__

查看是还是不是可以hash

class A:
    def __init__(self):
        self.a = 1
        self.b = 2

    def __hash__(self):
        return hash(str(self.a)+str(self.b))
a = A()
print(hash(a))#其实调用hash方法的时候就是内部实现了__hash__

 

__eq__

class A:
    def __init__(self):
        self.a = 1
        self.b = 2

    def __eq__(self,obj):
        if  self.a == obj.a and self.b == obj.b:
            return True
a = A()
b = A()
print(a == b)#True

 

__item__系列:__getitem__、__setitem__、__delitem__

class Foo:
    def __init__(self,name):
        self.name=name

    def __getitem__(self, item):
        print(self.__dict__[item])

    def __setitem__(self, key, value):
        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)

f1=Foo('sb')
f1['age']=18
f1['age1']=19
del f1.age1
del f1['age']
f1['name']='alex'
print(f1.__dict__)

 

 

函数的动态参数: 

动态参数一(*a):

def i1(*args):     #保存为元组
    print(args)

i1(12,33,44,55)    #实参能够全部传给a

结果:
(12, 33, 44, 55)

动态参数二(**a):

def i1(**kwargs):    #保存为字典形式
    print(kwargs)

i1(k1 = 123, k2 = 234)      #实参全部传给a

结果:
{'k1': 123, 'k2': 234}

动态参数格局构成(万能参数):

def i1(p,*args,**kwargs):
    print(p)
    print(args)
    print(kwargs)

i1(11,22,33,43,k1 = 123, k2 = 234)

结果:
11
(22, 33, 43)
{'k1': 123, 'k2': 234}

def i1(**kwargs):
    print(kwargs,type(kwargs))
dic={"k1":123,"k2":345}
i1(**dic)

结果:
{'k1': 123, 'k2': 345} <class 'dict'>

 二丶方法和函数

说到底给两道大题压压惊

 一 、曾经的一道面试题:

class Person:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

    def __hash__(self):
        return hash(self.name+self.sex)

    def __eq__(self, other):
        if self.name == other.name and self.sex == other.sex:return True
#创建的对象中只要名字和性别相同,就认为是两个相同的类

p_lst = []
for i in range(84):
    p_lst.append(Person('egon',i,'male'))#将84个egon传入列表中

print(p_lst)
print(set(p_lst))#set是集合,具有去重功能,其实质就是在内部实现了__hash__和__eq__方法

② 、纸牌游戏题:

from collections import namedtuple
Cards=namedtuple('Cards',['ranks','suit'])
class FranchDeck:
    ranks = [str(n) for n in range(2,11)] + list('JQKA')
    suits = ['红心','方板','梅花','黑桃']

    def __init__(self):
        self._cards = [Cards(rank,suit) for rank in FranchDeck.ranks
                                        for suit in FranchDeck.suits]

    def __len__(self):
        return len(self._cards)

    def __getitem__(self, item):
        return self._cards[item]

    def __setitem__(self, key, value):
        self._cards[key] = value

deck = FranchDeck()
print(deck[0])#Cards(ranks='2', suit='红心')Cards(ranks='2', suit='红心')
from random import choice#随机取值,choice依赖于内置的__getitem__
print(choice(deck))#Cards(ranks='J', suit='黑桃')
print(choice(deck))#Cards(ranks='2', suit='红心')

from random import shuffle#洗牌,shuffle依赖于__getitem__和__setitem__
shuffle(deck)
print(deck[:5])#[Cards(ranks='Q', suit='方板'), Cards(ranks='2', suit='黑桃'), Cards(ranks='5', suit='梅花'), Cards(ranks='4', suit='方板'), Cards(ranks='2', suit='梅花')]

 

全局变量与一些变量:

全局变量要大写,局地变量要小写。

   称谓:

浓度拷贝:

对于int和str来说,深浅拷贝都以千篇一律的,都能拷贝完整。

对于其余,浅拷贝只拷贝最外侧一层,深拷贝除最内层都要拷贝。

import copy
i1 = "123avc"
i2 = copy.copy(i1)      #浅拷贝

i3 = copy.deepcopy(i1)    #深拷贝
print(i2)
print(i3)

结果:
123avc
123avc

    类,方法

lambda表达式:

def func1():
    return 123
i = func1()
print(i)

f2 = lambda :123
i1 = f2()
print(i1)

结果:
123
123

def func1(a1,a2):
    return a1+a2
i = func1(11,22)
print(i)

f2 = lambda a1,a2: a1+a2
i1 = f2(11,22)
print(i1)

结果
33
33

    外,函数

Python的松手函数: 

abs()    取绝对值

def func1(a1,a2):

    i2 = abs(a1+a2)
    print(i2)

i = func1(-11,-22)

结果:
33

type()    查看对象类型

all()    循环参数,借使逐个成分都为真,那么就回到真,只要有3个为假都回去False(假:0,None,空字符串,空列表,空元组,空字典)

any()    循环参数,只要有三个因素是真就再次回到真(True)

ascii(对象)    对象的类中找_repr_作用,获取其再次回到值

class Foo:
    def __repr__(self):
        return "hello"

obj = Foo()
r = ascii(obj)
print(r)

结果:
hello

bin()    二进制

oct()    八进制

int()    十进制

hex()    十六进制

#!/bin/bash/env python
# -*- coding:utf-8 -*-
#functio:二进制改为十进制

i = int("0b11",base=2)    #其他进制之间的转换也一样,注意base的作用
print(i)

结果:
3

boll()    判断真伪,把三个目标转换为布尔值

bytes()    字节(和bytearray类似于str和list的关系)  bytes(“xxx”,encoding=”utf-8″)

bytearray()    字节列表

chr()    输入一个数字找到相呼应的字符(参照ascii表,数字找到相应的字符)

ord()    接受二个字母找到相应的数字(只使用于ascii码)

兑现自由验证码:(应用到chr()–这么些是比照ascii表和str())

import random

tmp = ""
for i in range(6):
    num = random.randrange(0,4)
    if num == 1 or num == 3:
        rad2 = random.randrange(0,10)
        tmp = tmp + str(rad2)
    else:
        rad1 = random.randrange(65,91)
        c1 = chr(rad1)
        tmp = tmp + c1

print(tmp)

flush()    使对象及时保存在硬盘中

callable()    检查输入对象是还是不是足以实施(若是命令加()表示该命令可以被执行)

complie()    编译对象,使之能成为python可以推行的代码

divmod()    求除数的商和余数

i1 = 10/3
print(i1)
i2 = divmod(10,3)
print(i2)

结果:
3.3333333333333335
(3, 1)

enumerate()   自动生成一列,暗中认可从0开首自增1,也可以协调内定字符串转换到数字int(字符串)

i1 = ["you","i","she","he"]
for key,item in enumerate(i1):
    print(key,item)

结果:
0 you
1 i
2 she
3 he

eval()    (做报表汇总)执行二个字符串格局的表明式

i1 = eval("1 + 3")
print(i1)

结果:
4

filter(函数,可迭代对象)    循环可迭代的靶子,获取每二个参数(函数),筛选效用

澳门葡京备用网址 3

ret = filter(lambda x:x > 22,[11,22,33,44])
for i in ret:
    print(i)

结果:
33
44

map(函数,可迭代对象)    

def func1(x):
    return x + 100
ret = map(func1,[1,2,3,4,5])
print(ret)
for i in ret:
    print(i)

结果:
<map object at 0x000000000260B2B0>
101
102
103
104
105

globals()    获取全体的全局变量

locals()    获取全部的一对变量

hash()    获取哈希值(为了节省外存,而且非常快找到,优化key

isinstance()    判断有个别对象是不是由有个别类创制的

issubclass()    判断是还是不是是子类

iter()    next()

obj = iter([11,22,33,44])
print(obj)
r1 = next(obj)
print(r1)
r2 = next(obj)
print(r2)

结果:
<list_iterator object at 0x000000000291B1D0>
11
22

max()    取最大值

min()    取最小值

pow()    求幂

round()    四舍五入

sum()    求和

sorted()    排序:(想要排序必须是同样种档次,比如都以数字)字符串相比,先比第三个字符,以往四个二个比,然后排序

i1 = [11,22,11,33,22,44,55,66,]
new_list = sorted(i1)
print(new_list)

结果:
[11, 11, 22, 22, 33, 44, 55, 66]

澳门葡京备用网址 4

  到底如何是格局,什么是函数?

打开文件的形式有:

私下认同是只读格局

r:只读格局(暗许)

w:只写方式(不可读,不设有创建键;存在则清空内容)

x:只写格局(不可读,不设有创立键,存在则报错)

a:追加情势(不可读,不设有创制键,存在则只增添内容)

 

+表示能够同时读写有个别文件:

r+:读写(可读,可写)

w+:写读(可读,可写) 先清空,再写之后就可以读了

x+:写读(可读,可写和地点大致)

a+:写读(可读,可写)  打开同时,指针已经到最终了,写时扩大,放在最后

 

b表示以字节的形式操作:

rb  或r+b

wb  或w+b

xb  或x+b

ab  或a+b

f = open('cai.log','r',encoding="utf-8")
i1 = f.read()
f.close()
print(i1)

结果:
中国

主干打开:

#1、只读r
i1 = open('cai.log','r')
i2 = i1.read()
i1.close()
print(i2)

#2、w,只写模式,清空原来的内容,重新输入,文件不存在则创建
i3 = open('cai.log','w')
i4 = i3.write('111')
i3.close()

#3、x,只写模式,原来有内容则报错
i5 = open('cai.log','x')
i6 = i5.write('222')
i5.close()

#4、追加模式,追加在末尾
i1 = open('cai.log','a')
i2 = i1.write('222')
i1.close()

以字节(二进制)的不二法门打开:

①只读,rb

澳门葡京备用网址 5

②只写wb

澳门葡京备用网址 6

 

 澳门葡京备用网址 7

 

 澳门葡京备用网址 8

 

    对象.xxx  —>  xxx就是艺术

 澳门葡京备用网址 9

澳门葡京备用网址 10

澳门葡京备用网址 11

 

 

关闭:

with open(“cai.log”,”r”) as f:

  f.read()

推行过后协调关闭,不须要close

 

Python2.7从此,with可以同时扶助打开三个文件:

with open(“log1”) as obj1,open(“log2”) as obj2:

  pass

澳门葡京备用网址 12

 

 不必要用度一点都不小的内存的复制

 

 

  

    类.xxx    —> xxx就是函数

 

 

    xxx  —>  xxx就是函数

  打印查看:

    function

    method

 

代码演示:

from types import MethodType,FunctionType
class Foo:
    def display(self):
        pass
def check(arg):
    """
    检查arg是方法还是函数?
    :param arg:
    :return:
    """
    if isinstance(arg,MethodType):
        print('arg是一个方法')
    elif isinstance(arg,FunctionType):
        print('arg是一个函数')

    else:
        print('不知道是什么')
check(check)        #arg是一个函数
obj = Foo()
check(obj.display)      #arg是一个方法

 

三丶反射 

  1.getattr : 依照字符串的款型,去对象中找成员

class Foo(object):

    country = "中国"

    def func(self):
        pass
v = getattr(Foo,'func') # Foo.func # 根据字符串为参数,去类中寻找与之同名的成员。
print(v)    #<function Foo.func at 0x000001E1A557D8C8>

obj = Foo()
v = getattr(obj,"func") # obj.func # 根据字符串为参数,去对象中寻找与之同名的成员。
print(v)    #<bound method Foo.func of <__main__.Foo object at 0x000001E1A5579F28>>

  2.hasattr : 依照字符串的款式,去看清目的中是或不是有成员.

a = 123
class Foo(object):
    country = "中国"
    def func(self):
        pass
v2 = hasattr(Foo,"a")       #判断Foo中是否有a成员
v3 = hasattr(Foo,'country') #判断Foo中是否有country成员
v4 = hasattr(Foo,"func")    #判断Foo中是否有func成员
v5 = hasattr(Foo,'xxxxxxx')

print(v2,v3,v4,v5)    # False True True False

  3.setattr : 依照字符串的花样,动态的设置一个分子(内存)

# 根据字符串的形式,动态的设置一个成员(内存)
x1 = 123
class Foo:
    def f1(arg):
        print(arg,666)

setattr(Foo,'x2',999)
v1 = getattr(Foo,'x2')
print(v1)   #999

  4.基于字符串的形式,动态的删减一个成员(内存)

x1 = 123
class Foo:
    def f1(arg):
        print(arg,666)
delattr(Foo,'x1')
v9 = getattr(Foo,'x1')
print(v9)

  应用

澳门葡京备用网址 13澳门葡京备用网址 14

class Account(object):
    func_list = ['login', 'logout', 'register']

    def login(self):
        """
        登录
        :return:
        """
        print('登录111')

    def logout(self):
        """
        注销
        :return:
        """
        print('注销111')

    def register(self):
        """
        注册
        :return:
        """
        print('注册111')

    def run(self):
        """
        主代码
        :return:
        """
        print("""
            请输入要执行的功能:
                1. 登录
                2. 注销
                3. 注册
        """)

        choice = int(input('请输入要执行的序号:'))
        func_name = Account.func_list[choice-1]
        func = getattr(self, func_name)  # self.login
        func()

obj1 = Account()
obj1.run()

obj2 = Account()
obj2.run()

应用

 四丶callable 判断是或不是足以调用

def func():
    pass

class Foo(object):
    def __call__(self, *args, **kwargs):
        pass
    def func(self):
        pass
obj = Foo()

print(callable(func))
print(callable(Foo))
print(callable(obj))
print(callable(obj.func))

 

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website