class Student:

    f = open('student', encoding='utf-8')

    def __init__(self):

        pass

    @classmethod #类方法 ：有个默认参数cls，并且可以直接使用类名去

                 #调用，还可以与类属性交互（也就是可以使用类属性）

    def show_student_info_class(cls):

        # f = open('student', encoding='utf-8')

        for line in cls.f:

            name,sex = line.strip().split(',')

            print(name,sex)

    @staticmethod  #静态方法:可以直接使用类名去调用，就像正常的函数调用一样

    def show_student_info_static(): #不用传self

        f = open('student',encoding='utf-8')

        for line in f:

            name,sex = line.strip().split(',')

            print(name,sex)

# egon = Student()

# egon.show_student_info_static()  #也可以这样调，但是还是推荐用类名去调

# egon.show_student_info_class()

Student.show_student_info_class()#类名.方法名()

print('-------------------')

Student.show_student_info_static()#类名.方法名()

staticmethod和classmethod

class Foo:

    pass

class Son(Foo):

    pass

s = Son()

print(isinstance(s,Son))  #判断s是不是Son的对象

print(type(s) is Son)

print(isinstance(s,Foo))  #判断s是不是Foo的对象  不精准

print(type(s) is Foo)  #type比较精准

print(issubclass(Son,Foo)) #判断Son是不是Foo的子类

print(issubclass(Son,object))

print(issubclass(Foo,object))

print(issubclass(int,object))

class Foo:

    def __init__(self):

        self.name = 'egon'

        self.age = 51

    def func(self):

        print('hello')

egg = Foo()

setattr(egg,'sex','男')

print(egg.sex)

# 2.

def show_name(self):

    print(self.name+'sb')

setattr(egg,'sh_name',show_name)

egg.sh_name(egg)

show_name(egg)

delattr(egg,'name')

print(egg.name)

class Foo:
def __init__(self):
self.name = 'egon'
self.age = 51
def func(self):
print('hello')
egg = Foo()
print(hasattr(egg,'name')) #先判断name在egg里面存在不存在
print(getattr(egg,'name')) #如果为True它才去得到
print(hasattr(egg,'func'))
print(getattr(egg,'func')) #得到的是地址
# getattr(egg,'func')() #在这里加括号才能得到，因为func是方法
if hasattr(egg,'func'):
getattr(egg,'func')()
else:
print('没找到')

 1 class Foo:

 2     def __init__(self):

 3         self.name = 'egon'

 4         self.age = 51

 5     def func(self):

 6         print('hello')

 7 egg = Foo()

 8 print(hasattr(egg,'name'))  #先判断name在egg里面存在不存在

 9 print(getattr(egg,'name')) #如果为True它才去得到

10 print(hasattr(egg,'func'))

11 print(getattr(egg,'func'))  #得到的是地址

12 # getattr(egg,'func')()  #在这里加括号才能得到，因为func是方法

13 if hasattr(egg,'func'):

14     getattr(egg,'func')()

15 else:

16     print('没找到')

class Foo:
f = 123
@classmethod
def class_method_dome(cls):
print('class_method_dome')

@staticmethod
def static_method_dome():
print('static_method_dome')
print(hasattr(Foo,'class_method_dome'))
method = getattr(Foo,'class_method_dome')
method()
print('------------')
print(hasattr(Foo,'static_method_dome'))
method1 = getattr(Foo,'static_method_dome')
method1()

 1 class Foo:

 2     f = 123

 3     @classmethod

 4     def class_method_dome(cls):

 5         print('class_method_dome')

 6

 7     @staticmethod

 8     def static_method_dome():

 9         print('static_method_dome')

10 print(hasattr(Foo,'class_method_dome'))

11 method = getattr(Foo,'class_method_dome')

12 method()

13 print('------------')

14 print(hasattr(Foo,'static_method_dome'))

15 method1 = getattr(Foo,'static_method_dome')

16 method1()

# 1.导入其他模块引用
import mymodule
print(hasattr(mymodule,'test'))
getattr(mymodule,'test')()

# # 这里的getattr(mymodule,'test')()这一句相当于
# p = getattr(mymodule,'test')
# p()

1 # 1.导入其他模块引用

2 import mymodule

3 print(hasattr(mymodule,'test'))

4 getattr(mymodule,'test')()

5

6 # # 这里的getattr(mymodule,'test')()这一句相当于

7 # p = getattr(mymodule,'test')

8 # p()

# 2.在本模块中应用反射
def demo1():
print('wwww')
import sys
# print(sys.modules)
module_obj = sys.modules[__name__] #相当于'__main__'
print(module_obj)
print(hasattr(module_obj,'demo1'))
getattr(module_obj,'demo1')()

# 举例

def 注册():

    print('regiester')

def 登录():

    print('login')

def 购物():

    pass

print('注册，登录，购物')

ret = input('请输入你要做的操作：')

import sys

my_module = sys.modules[__name__]  #利用sys模块导入一个自己的模块

if hasattr(my_module,ret):

    getattr(my_module,ret)()

导入自己的模块的一个简单小例子

class MySQlHelper(object):

    print('MySQlHelper1111111')

    def fetchone(self):

        print('你好')

class PoolHelper(object):

    print('PoolHelper')

DB_PATH = 'db.mysql.MySQlHelper'

#吧字符串切割

module_name,cls_name = DB_PATH.rsplit('.',maxsplit=1)

# print(module_name,cls_name)  #db.mysql    MySQlHelper

#导入模块

# from db.mysql import MySQlHelper

import importlib

moudel_obj = importlib.import_module(module_name)

print(moudel_obj,type(moudel_obj))

#导入模块中的类

cls = getattr(moudel_obj,cls_name)

print(cls)

#对类进行实例化

obj = cls()

obj.fetchone()

# getattr()

class Foo:

    def __init__(self,name):

        self.name = name

    def __repr__(self):

        return 'obj in str'  #这里只能是return

    # def __str__(self):

    #     return '%s obj in str'%self.name

f = Foo('egon')

print(f)  #优先执行__str__里面的内容

# 那么你是不是据地__repr__没用呢？

# print('%s'%f)  #执行的是__str__里面的返回值

# print('%r'%f)  #执行的是__repr__里面的返回值

print('==============')

print(str(f))  #当执行str(f)时，会去找__str__这个方法，如果找不到的时候，__repr__这个方法就给替补了

print(repr(f))

#1.当打印一个对象的时候，如果实现了__str__方法，打印__str__中的返回值

# 2.当__str__没有被实现的时候，就会调用__repr__方法

# 3.但是当你用字符串格式化的时候，%s和%r会分别调用__str__和__repr__方法

# 4.不管是在字符串格式化的时候还是在打印对象的时候，

# __repr__方法都可以作为__str__方法的替补，但反之则不行

# 5.用于友好的表示对象。如果__str__和__repr__方法你只能实现一个：先实现__repr__

 __str__和__repr__

class Foo:

    def __del__(self):

        print('执行我啦')

f= Foo()

print(123)

print(123)

print(123)

print(123)

class Foo:

    def __init__(self):

        self.name = 'egon'

        self.age = 73

        self.l=[1,2,3]

    def __getitem__(self, item):  #得到

        # return  self.l[item]

        # return self.__dict__[item]

        # print(Foo.__dict__)

        return 123

    def __setitem__(self, key, value):  #修改

        print(key,value)

        self.__dict__[key] = value

    def __delitem__(self, key):  #删除

        del self.__dict__[key]

f = Foo()

print(f['qqq'])  #不管里面放的啥值，它都会得到返回值的内容，调用的是__getitem__方法

f['name']='alex' #修改egon的值为alex，调用 __setitem__方法

# del f['name'] #删除name，就会报错了，说明在调用__delitem__方法调用成功了，就已经删了，就会报错了

print(f.name)

f1 = Foo()

print(f == f1)

# print(f.name)

# print(f[0])  #一开始不能这样取值，但是提供了一个__getitem__方法，这样就可以用了

# print(f[1])

# print(f[2])

三个方法的使用

# 4.__new__方法

# 单例模式：是一种设计模式

class Singleton:

    def __new__(cls, *args, **kw):

        if not hasattr(cls, '_instance'):

            orig = super(Singleton, cls)

            cls._instance = orig.__new__(cls, *args, **kw)

        return cls._instance

one = Singleton()

two = Singleton()

print(one,two)   #他们两个的地址一样

one.name = 'alex'

print(two.name) 

单例模式

# class A:

#     def __init__(self):  #有一个方法在帮你创造self

#         print('in init function')

#         self.x = 1

#

#     def __new__(cls, *args, **kwargs):

#         print('in new function')

#         return object.__new__(A, *args, **kwargs)

# a = A()

# b = A()

# c = A()

# d = A()

# print(a,b,c,d)

__new__

class Foo:

2     def __call__(self, *args, **kwargs):

3         print(123)

4 # f = Foo()

5 # f() #如果不写上面的__call__方法，就不会调用。如果加上，就正确了

6 Foo()() #也可以这样表示

class Foo:

    def __hash__(self):

        print('aaaaaaaaaa')

        return hash(self.name)

        # print('aaas')

f = Foo()

f.name = 'egon'

print(hash(f))  #hash方法是可以重写的

__hash__

class A:

    def __eq__(self, other):

        return True

a = A()

b = A()

print(a==b) #不加方法的时候返回的是False，加了个__eq__方法就返回了个True

# '=='内部就调用了__eq__方法

print(a is b)

__eq__

from collections import namedtuple

Card = namedtuple('Card',['rank','suit'])  #两个属性：一个是数，一个是花色（每一个card的对象就是一张纸牌）

class FranchDeck: #纸牌数据类型

    ranks = [str(n) for n in range(2,11)] + list('JQKA')

    suits = ['红心','方板','梅花','黑桃']

    def __init__(self):

        self._cards = [Card(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])

# print(deck[0])

# print(deck[0])

# print(deck[0])

from random import choice

print(choice(deck))

print(choice(deck))

from random import shuffle

shuffle(deck)

print(deck[:5])

纸牌游戏