def hasattr(*args, **kwargs): # real signature unknown
    """
    Return whether the object has an attribute with the given name.
    
    This is done by calling getattr(obj, name) and catching AttributeError.
    """
    pass

def getattr(object, name, default=None): # known special case of getattr
    """
    getattr(object, name[, default]) -> value

    Get a named attribute from an object; getattr(x, ‘y‘) is equivalent to x.y.
    When a default argument is given, it is returned when the attribute doesn‘t
    exist; without it, an exception is raised in that case.
    """
    pass
getattr(object, name, default=None)

def setattr(x, y, v): # real signature unknown; restored from __doc__
    """
    Sets the named attribute on the given object to the specified value.

    setattr(x, ‘y‘, v) is equivalent to ``x.y = v‘‘
    """
    pass

setattr(x, y, v)

def delattr(x, y): # real signature unknown; restored from __doc__
    """
    Deletes the named attribute from the given object.

    delattr(x, ‘y‘) is equivalent to ``del x.y‘‘
    """
    pass

delattr(x, y)

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()

# getattr(b1,‘aaaaaaaa‘) #报错
print(getattr(b1,‘aaaaaaaa‘,‘不存在啊‘))

#设置属性
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,‘show_name‘)
delattr(b1,‘show_name111‘)#不存在,则报错

print(b1.__dict__)

四个方法的使用演示

class Foo(object):
 
    staticField = "old boy"
 
    def __init__(self):
        self.name = ‘wupeiqi‘
 
    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‘)()

class FtpClient:
    ‘ftp客户端,但是还么有实现具体的功能‘
    def __init__(self,addr):
        print(‘正在连接服务器[%s]‘ %addr)
        self.addr=addr

#from module import FtpClient
f1=FtpClient(‘192.168.1.1‘)
if hasattr(f1,‘get‘):
    func_get=getattr(f1,‘get‘)
    func_get()
else:
    print(‘---->不存在此方法‘)
    print(‘处理其他的逻辑‘)

不影响lili的代码编写

class Foo:

    def __del__(self):
        print(‘执行我啦‘)

f1=Foo()
# del f1
print(‘------->‘)

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



#为何啊？？？

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

    def __getitem__(self, item):
        if hasattr(self,item):
            return self.__dict__[item]

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

    def __delitem__(self, key):
        del self.__dict__[key]

f = Foo(‘egon‘,38,‘男‘)
print(f[‘name‘]) #egon   会触发类中的getitem方法，并把‘name‘传给itme
f[‘hobby‘] = ‘女‘  #会触发类中的setitemi方法，并把‘hobby‘传给key,‘女‘传给value
print(f.__dict__)  #{‘name‘: ‘egon‘, ‘age‘: 38, ‘sex‘: ‘男‘, ‘hobby‘: ‘女‘}
print(f.hobby,f[‘hobby‘])  #女 女
# del f.hobby      # object 原生支持  __delattr__
del f[‘hobby‘]     # 通过自己实现的  会触发类中的delitem方法，并把‘hobby‘传给key
print(f.__dict__)  #{‘name‘: ‘egon‘, ‘age‘: 38, ‘sex‘: ‘男‘}

class A:
    __instance = False
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __new__(cls, *args, **kwargs):
        if cls.__instance: #如果之前创建过对象就不在创建了，返回之前创建的对象
            return cls.__instance
        cls.__instance = object.__new__(cls) #如果之前没有创建过对象，创建对象
        return cls.__instance

egon = A(‘egg‘,38)
egon.cloth = ‘小花袄‘
nezha = A(‘nazha‘,25)
print(nezha) #<__main__.A object at 0x0000000001EAA9B0>
print(egon)  #<__main__.A object at 0x0000000001EAA9B0>  和上面内存地址一样，说明是同一个对象
print(nezha.name)  #nazha
print(egon.name)   #nazha
print(nezha.cloth) #小花袄

#第一实例化的时候可以比喻女娲造出了一个小人，给小人起了一个名字，赋予了年龄，
#第二次实例化的时候拿到的还是之前造出的那个小人，如果小人没有名字和年龄就给它名字和年龄
# 如果有名字年龄就把它们删了重新赋予名字和年龄，也就是它们操作的都是同一个对象

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

    def __eq__(self, other):
        if self.__dict__ == other.__dict__:
            return True
        else:
            return False

ob1 = A(‘egon‘)
ob2 = A(‘egg‘)
print(ob1 == ob2)  #False     此时==会触发eq方法

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

m=A(‘hui‘)
n=A(‘hui‘)  
print(hash(m))  #2005673  #默认根据对象的内存地址进行hash
print(hash(n))  #-9223372036852770132


class B:
    def __init__(self,name,sex):
        self.name = name
        self.sex = sex
    def __hash__(self):  #自定制hash
        return hash(self.name+self.sex)

a = B(‘egon‘,‘男‘)
b = B(‘egon‘,‘男‘)
print(hash(a))    #-4411851472115669131
print(hash(b))    #-4411851472115669131

c = B(‘egon0‘,‘男‘)
d = B(‘egon0‘,‘女‘)
print(hash(c))     #247660479663688395
print(hash(d))     #5874602778707716777

import json
from collections import namedtuple
Card = namedtuple(‘Card‘,[‘rank‘,‘suit‘])   # rank 牌面的大小 suit牌面的花色
class FranchDeck:
    ranks = [str(n) for n in range(2,11)] + list(‘JQKA‘)   # 2-A
    suits = [‘红心‘,‘方板‘,‘梅花‘,‘黑桃‘]

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

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

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

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

    def __str__(self):
        return json.dumps(self._cards,ensure_ascii=False)  #

deck = FranchDeck()
print(deck[10])                               #取牌      #Card(rank=‘4‘, suit=‘梅花‘)
from random import choice
print(choice(deck))  #choice依赖内置的len方法   #抽牌      #Card(rank=‘4‘, suit=‘红心‘)

from random import shuffle
shuffle(deck)       #shuffle依赖内置的setitem  #洗牌
print(deck[10])                                           #Card(rank=‘8‘, suit=‘红心‘)
print(deck)      #[["A", "红心"], ["5", "方板"], ["6", "方板"],["2", "方板"], ["3", "方板"],…… ["2", "黑桃"], ["A", "方板"]]
print(deck[:5])   #[Card(rank=‘A‘, suit=‘红心‘), Card(rank=‘5‘, suit=‘方板‘), Card(rank=‘6‘, suit=‘方板‘),
                  # Card(rank=‘2‘, suit=‘方板‘), Card(rank=‘3‘, suit=‘方板‘)]

# 内置函数 内置的模块 内置的基础类型 < --- >类的内置方法

# 100个人，name/sex/age
#每年录入他们的信息，特点 名字 和 性别相同， 年龄不同
#录入的信息怎么和之前录入的信息进行去重
# set
class A:
    def __init__(self,name,sex,age):
        self.name = name
        self.sex = sex
        self.age = age

    def __eq__(self, other):
        if self.name == other.name and self.sex == other.sex:
            return True
        return False

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

a = A(‘egg‘,‘男‘,38)
b = A(‘egg‘,‘男‘,37)
print(set((a,b)))   # unhashable   #{<__main__.A object at 0x00000000021DA7F0>}

# set 依赖对象的 hash eq