USB (多态)
鼠标
键盘
网卡
画图板
... 

list.pop(index)
dict.pop(key)

class 类名:
    语句块

class MyClass:
    """
    这是一个类
    """
    x = "abc"  # 类属性

    def foo(self):  # 类属性foo,也是方法
        return "My Class"

print(MyClass.x)
print(MyClass.foo)
print(MyClass.__doc__)

class Student(object):
    # __init__是一个特殊方法用于在创建对象时进行初始化操作
    # 通过这个方法我们可以为学生对象绑定name和age两个属性
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def study(self, course_name):
        print(f'{self.name}正在学习{course_name}.')

    # PEP 8要求标识符的名字用全小写多个单词用下划线连接
    # 但是部分程序员和公司更倾向于使用驼峰命名法(驼峰标识)
    def watch_movie(self):
        if self.age < 18:
            print(f'{self.name}只能观看《熊出没》.')
        else:
            print(f'{self.name}正在观看XXX电影.')

def main():
    # 创建学生对象并指定姓名和年龄
    stu1 = Student('小明', 20)
    # 给对象发study消息
    stu1.study('Python程序设计')
    # 给对象发watch_av消息
    stu1.watch_movie()
    stu2 = Student('王大锤', 15)
    stu2.study('思想品德')
    stu2.watch_movie()


if __name__ == '__main__':
    main()            

    {
       int    id;
       string name;
       char   sex;
    }

    struct {
        int a;
        char b;
        double c;
    } s1;

# __new__() 方法是在类准备将自身实例化时调用; 
def __new__(cls,*args,**kwargs):
    return object.__new__(cls)

# 对象建立后，自动执行，初始化当前对象的相关属性，无返回值
def __init__(self,参数列表):
    # 需要被初始化的属性或方法
    pass

# 析构函数
def __del__(self):
    pass
# 当类被销毁时，执行的操作
# 一般用来释放对象占用的资源
# 如打开的文件或链接的网络
# 一般不用自定义析构函数

a= 类()
a.方法()
等价
类.方法(a)
私有方法
双下划线开头的方法
只能在类的内部被调用的方法

class Person(object):

    def __init__(self, name, age):
        self._name = name
        self._age = age

    # 访问器 - getter方法
    @property
    def name(self):
        return self._name

    # 访问器 - getter方法
    @property
    def age(self):
        return self._age

    # 修改器 - setter方法
    @age.setter
    def age(self, age):
        self._age = age

    def play(self):
        if self._age <= 16:
            print('%s正在玩飞行棋.' % self._name)
        else:
            print('%s正在玩斗地主.' % self._name)


def main():
    person = Person('王大锤', 12)
    person.play()
    person.age = 22
    person.play()
    # person.name = '白元芳'  # AttributeError: can't set attribute


if __name__ == '__main__':
    main()

class Person(object):

    # 限定Person对象只能绑定_name, _age和_gender属性
    __slots__ = ('_name', '_age', '_gender')

    def __init__(self, name, age):
        self._name = name
        self._age = age

    @property
    def name(self):
        return self._name

    @property
    def age(self):
        return self._age

    @age.setter
    def age(self, age):
        self._age = age

    def play(self):
        if self._age <= 16:
            print('%s正在玩飞行棋.' % self._name)
        else:
            print('%s正在玩斗地主.' % self._name)


def main():
    person = Person('王大锤', 22)
    person.play()
    person._gender = '男'
    # AttributeError: 'Person' object has no attribute '_is_gay'
    # person._is_gay = True

from math import sqrt


class Triangle(object):

    def __init__(self, a, b, c):
        self._a = a
        self._b = b
        self._c = c

    @staticmethod
    def is_valid(a, b, c):
        return a + b > c and b + c > a and a + c > b

    def perimeter(self):
        return self._a + self._b + self._c

    def area(self):
        half = self.perimeter() / 2
        return sqrt(half * (half - self._a) *
                    (half - self._b) * (half - self._c))


def main():
    a, b, c = 3, 4, 5
    # 静态方法和类方法都是通过给类发消息来调用的
    if Triangle.is_valid(a, b, c):
        t = Triangle(a, b, c)
        print(t.perimeter())
        # 也可以通过给类发消息来调用对象方法但是要传入接收消息的对象作为参数
        # print(Triangle.perimeter(t))
        print(t.area())
        # print(Triangle.area(t))
    else:
        print('无法构成三角形.')


if __name__ == '__main__':
    main()

from time import time, localtime, sleep


class Clock(object):
    """数字时钟"""

    def __init__(self, hour=0, minute=0, second=0):
        self._hour = hour
        self._minute = minute
        self._second = second

    @classmethod
    def now(cls):
        ctime = localtime(time())
        return cls(ctime.tm_hour, ctime.tm_min, ctime.tm_sec)

    def run(self):
        """走字"""
        self._second += 1
        if self._second == 60:
            self._second = 0
            self._minute += 1
            if self._minute == 60:
                self._minute = 0
                self._hour += 1
                if self._hour == 24:
                    self._hour = 0

    def show(self):
        """显示时间"""
        return '%02d:%02d:%02d' % \
               (self._hour, self._minute, self._second)


def main():
    # 通过类方法创建对象并获取系统时间
    clock = Clock.now()
    while True:
        print(clock.show())
        sleep(1)
        clock.run()


if __name__ == '__main__':
    main()

class Father:
    def say(self):
        print('Hello !')

    def introduce(self):
        print('Father')

class Son(Father):
    def say(self):
        super().say()
        # Father.say(self)   # 通过 类名.func()，输出结果一致
        print('你好 ~')

p = Son()
p.say()

class Person(object):
    """人"""

    def __init__(self, name, age):
        self._name = name
        self._age = age

    @property
    def name(self):
        return self._name

    @property
    def age(self):
        return self._age

    @age.setter
    def age(self, age):
        self._age = age

    def play(self):
        print('%s正在愉快的玩耍.' % self._name)

    def watch_av(self):
        if self._age >= 18:
            print('%s正在观看爱情动作片.' % self._name)
        else:
            print('%s只能观看《熊出没》.' % self._name)


class Student(Person):
    """学生"""

    def __init__(self, name, age, grade):
        super().__init__(name, age)
        self._grade = grade

    @property
    def grade(self):
        return self._grade

    @grade.setter
    def grade(self, grade):
        self._grade = grade

    def study(self, course):
        print('%s的%s正在学习%s.' % (self._grade, self._name, course))


class Teacher(Person):
    """老师"""

    def __init__(self, name, age, title):
        super().__init__(name, age)
        self._title = title

    @property
    def title(self):
        return self._title

    @title.setter
    def title(self, title):
        self._title = title

    def teach(self, course):
        print('%s%s正在讲%s.' % (self._name, self._title, course))


def main():
    stu = Student('王大锤', 15, '初三')
    stu.study('数学')
    stu.watch_av()
    t = Teacher('小明', 38, '砖家')
    t.teach('Python程序设计')
    t.watch_av()


if __name__ == '__main__':
    main()

from abc import ABCMeta, abstractmethod

# 多态与抽象类
class Pet(object, metaclass=ABCMeta):
    """宠物"""

    def __init__(self, nickname):
        self._nickname = nickname

    # 抽象方法，必须要被重写
    @abstractmethod
    def make_voice(self):
        """发出声音"""
        pass


class Dog(Pet):
    """狗"""

    def make_voice(self):
        print('%s: 汪汪汪...' % self._nickname)


class Cat(Pet):
    """猫"""

    def make_voice(self):
        print('%s: 喵...喵...' % self._nickname)


def main():
    pets = [Dog('旺财'), Cat('凯蒂'), Dog('大黄')]
    # 接口 适配
    for pet in pets:
        pet.make_voice()


if __name__ == '__main__':
    main()

from abc import ABCMeta, abstractmethod
from random import randint, randrange

# 战斗者抽象类
class Fighter(object, metaclass=ABCMeta):
    """战斗者"""

    # 通过__slots__魔法限定对象可以绑定的成员变量
    __slots__ = ('_name', '_hp') 

    def __init__(self, name, hp):
        """初始化方法
        :param name: 名字
        :param hp: 生命值
        """
        self._name = name
        self._hp = hp

    @property
    def name(self):
        return self._name

    @property
    def hp(self):
        return self._hp

    @hp.setter
    def hp(self, hp):
        self._hp = hp if hp >= 0 else 0

    @property
    def alive(self):
        return self._hp > 0

    @abstractmethod
    def attack(self, other):
        """攻击

        :param other: 被攻击的对象
        """
        pass


class Ultraman(Fighter):
    """奥特曼"""

    __slots__ = ('_name', '_hp', '_mp')

    def __init__(self, name, hp, mp):
        """初始化方法

        :param name: 名字
        :param hp: 生命值
        :param mp: 魔法值
        """
        super().__init__(name, hp)
        self._mp = mp

    def attack(self, other):
        other.hp -= randint(15, 25)

    def huge_attack(self, other):
        """究极必杀技(打掉对方至少50点或四分之三的血)
        :param other: 被攻击的对象
        :return: 使用成功返回True否则返回False
        """
        if self._mp >= 50:
            self._mp -= 50
            injury = other.hp * 3 // 4
            injury = injury if injury >= 50 else 50
            other.hp -= injury
            return True
        else:
            self.attack(other)
            return False

    def magic_attack(self, others):
        """魔法攻击
        :param others: 被攻击的群体
        :return: 使用魔法成功返回True否则返回False
        """
        if self._mp >= 20:
            self._mp -= 20
            for temp in others:
                if temp.alive:
                    temp.hp -= randint(10, 15)
            return True
        else:
            return False

    def resume(self):
        """恢复魔法值"""
        incr_point = randint(1, 10)
        self._mp += incr_point
        return incr_point

    def __str__(self):
        return '~~~%s奥特曼~~~\n' % self._name + \
            '生命值: %d\n' % self._hp + \
            '魔法值: %d\n' % self._mp


class Monster(Fighter):
    """小怪兽"""

    __slots__ = ('_name', '_hp')

    def attack(self, other):
        other.hp -= randint(10, 20)

    def __str__(self):
        return '~~~%s小怪兽~~~\n' % self._name + \
            '生命值: %d\n' % self._hp


def is_any_alive(monsters):
    """判断有没有小怪兽是活着的"""
    for monster in monsters:
        if monster.alive > 0:
            return True
    return False


def select_alive_one(monsters):
    """选中一只活着的小怪兽"""
    monsters_len = len(monsters)
    while True:
        index = randrange(monsters_len)
        monster = monsters[index]
        if monster.alive > 0:
            return monster


def display_info(ultraman, monsters):
    """显示奥特曼和小怪兽的信息"""
    print(ultraman)
    for monster in monsters:
        print(monster, end='')


def main():
    u = Ultraman('迪迦', 1000, 120)
    m1 = Monster('炎魔战士', 250)
    m2 = Monster('哥布纽', 500)
    m3 = Monster('迪莫杰厄', 750)
    ms = [m1, m2, m3]
    fight_round = 1
    while u.alive and is_any_alive(ms):
        print('========第%02d回合========' % fight_round)
        m = select_alive_one(ms)  # 选中一只小怪兽
        skill = randint(1, 10)   # 通过随机数选择使用哪种技能
        if skill <= 6:  # 60%的概率使用普通攻击
            print('%s使用普通攻击打了%s.' % (u.name, m.name))
            u.attack(m)
            print('%s的魔法值恢复了%d点.' % (u.name, u.resume()))
        elif skill <= 9:  # 30%的概率使用魔法攻击(可能因魔法值不足而失败)
            if u.magic_attack(ms):
                print('%s使用了魔法攻击.' % u.name)
            else:
                print('%s使用魔法失败.' % u.name)
        else:  # 10%的概率使用究极必杀技(如果魔法值不足则使用普通攻击)
            if u.huge_attack(m):
                print('%s使用究极必杀技虐了%s.' % (u.name, m.name))
            else:
                print('%s使用普通攻击打了%s.' % (u.name, m.name))
                print('%s的魔法值恢复了%d点.' % (u.name, u.resume()))
        if m.alive > 0:  # 如果选中的小怪兽没有死就回击奥特曼
            print('%s回击了%s.' % (m.name, u.name))
            m.attack(u)
        display_info(u, ms)  # 每个回合结束后显示奥特曼和小怪兽的信息
        fight_round += 1
    print('\n========战斗结束!========\n')
    if u.alive > 0:
        print('%s奥特曼胜利!' % u.name)
    else:
        print('小怪兽胜利!')


if __name__ == '__main__':
    main()

import random


class Card(object):
    """一张牌"""

    def __init__(self, suite, face):
        self._suite = suite
        self._face = face

    @property
    def face(self):
        return self._face

    @property
    def suite(self):
        return self._suite

    def __str__(self):
        if self._face == 1:
            face_str = 'A'
        elif self._face == 11:
            face_str = 'J'
        elif self._face == 12:
            face_str = 'Q'
        elif self._face == 13:
            face_str = 'K'
        else:
            face_str = str(self._face)
        return '%s%s' % (self._suite, face_str)

    def __repr__(self):
        return self.__str__()


class Poker(object):
    """一副牌"""

    def __init__(self):
        self._cards = [Card(suite, face) 
                       for suite in '♠♥♣♦'
                       for face in range(1, 14)]
        self._current = 0

    @property
    def cards(self):
        return self._cards

    def shuffle(self):
        """洗牌(随机乱序)"""
        self._current = 0
        random.shuffle(self._cards)

    @property
    def next(self):
        """发牌"""
        card = self._cards[self._current]
        self._current += 1
        return card

    @property
    def has_next(self):
        """还有没有牌"""
        return self._current < len(self._cards)


class Player(object):
    """玩家"""

    def __init__(self, name):
        self._name = name
        self._cards_on_hand = []

    @property
    def name(self):
        return self._name

    @property
    def cards_on_hand(self):
        return self._cards_on_hand

    def get(self, card):
        """摸牌"""
        self._cards_on_hand.append(card)

    def arrange(self, card_key):
        """玩家整理手上的牌"""
        self._cards_on_hand.sort(key=card_key)


# 排序规则-先根据花色再根据点数排序
def get_key(card):
    return (card.suite, card.face)


def main():
    p = Poker()
    p.shuffle()
    players = [Player('东邪'), Player('西毒'), Player('南帝'), Player('北丐')]
    for _ in range(13):
        for player in players:
            player.get(p.next)
    for player in players:
        print(player.name + ':', end=' ')
        player.arrange(get_key)
        print(player.cards_on_hand)


if __name__ == '__main__':
    main()

"""
某公司有三种类型的员工 分别是部门经理、程序员和销售员
需要设计一个工资结算系统 根据提供的员工信息来计算月薪
部门经理的月薪是每月固定15000元
程序员的月薪按本月工作时间计算 每小时150元
销售员的月薪是1200元的底薪加上销售额5%的提成
"""
from abc import ABCMeta, abstractmethod


class Employee(object, metaclass=ABCMeta):
    """员工"""

    def __init__(self, name):
        """
        初始化方法

        :param name: 姓名
        """
        self._name = name

    @property
    def name(self):
        return self._name

    @abstractmethod
    def get_salary(self):
        """
        获得月薪

        :return: 月薪
        """
        pass


class Manager(Employee):
    """部门经理"""

    def get_salary(self):
        return 15000.0


class Programmer(Employee):
    """程序员"""

    def __init__(self, name, working_hour=0):
        super().__init__(name)
        self._working_hour = working_hour

    @property
    def working_hour(self):
        return self._working_hour

    @working_hour.setter
    def working_hour(self, working_hour):
        self._working_hour = working_hour if working_hour > 0 else 0

    def get_salary(self):
        return 150.0 * self._working_hour


class Salesman(Employee):
    """销售员"""

    def __init__(self, name, sales=0):
        super().__init__(name)
        self._sales = sales

    @property
    def sales(self):
        return self._sales

    @sales.setter
    def sales(self, sales):
        self._sales = sales if sales > 0 else 0

    def get_salary(self):
        return 1200.0 + self._sales * 0.05


def main():
    emps = [
        Manager('刘备'), Programmer('诸葛亮'),
        Manager('曹操'), Salesman('荀彧'),
        Salesman('吕布'), Programmer('张辽'),
        Programmer('赵云')
    ]
    for emp in emps:
        if isinstance(emp, Programmer):
            emp.working_hour = int(input('请输入%s本月工作时间: ' % emp.name))
        elif isinstance(emp, Salesman):
            emp.sales = float(input('请输入%s本月销售额: ' % emp.name))
        # 同样是接收get_salary这个消息但是不同的员工表现出了不同的行为(多态)
        print('%s本月工资为: ￥%s元' %
              (emp.name, emp.get_salary()))


if __name__ == '__main__':
    main()

class Person(object):
    def __init__(self,name):
        self.name = name
    def talk(self):
        print("%s正在交谈"%self.name)

p = Person("laowang")        
print(hasattr(p,"talk"))    # True。因为存在talk方法
print(hasattr(p,"name"))    # True。因为存在name变量
print(hasattr(p,"abc"))     # False。因为不存在abc方法或变量

class Person(object):
    def __init__(self,name):
        self.name = name
    def talk(self):
        print("%s正在交谈"%self.name)
p = Person("laowang")

n = getattr(p,"name")   # 获取name变量的内存地址
print(n)                # 此时打印的是:laowang

f = getattr(p,"talk")   # 获取talk方法的内存地址
f()                     # 调用talk方法

我们发现getattr有三个参数，那么第三个参数是做什么用的呢?
s = getattr(p,"abc","not find")
print(s)                # 打印结果：not find。因为abc在对象p中找不到，本应该报错，属性找不到，但因为修改了找不到就输出not find

def abc(self):
    print("%s正在交谈"%self.name)

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

p = Person("laowang")
setattr(p,"talk",abc)   # 将abc函数添加到对象中p中，并命名为talk
p.talk(p)               # 调用talk方法，因为这是额外添加的方法，需手动传入对象


setattr(p,"age",30)     # 添加一个变量age,复制为30
print(p.age)            # 打印结果:30

class Person(object):
    def __init__(self,name):
        self.name = name
    def talk(self):
        print("%s正在交谈"%self.name)

p = Person("laowang")

delattr(p,"name")       # 删除name变量
print(p.name)           # 此时将报错

def printable(cls):
    # 内层函数作为是给类增加的实例方法
    def _print(self):
        print("装饰器")

    # 将内层函数和类绑定
    cls.print = _print
    return cls


@printable
class A:
    pass


a = A()
a.print()

class PrintableMixin:
    def print(self):
        print(f"Word print {self.content}")


class Docment:
    def __init__(self, content):
        self.content = content


class Word(PrintableMixin, Docment):
    pass


w = Word("YES")
w.print()

class MyRange(object):
    def __init__(self, n):
        self.idx = 0
        self.n = n

    def __iter__(self):
        return self

    def __next__(self):
        if self.idx < self.n:
            val = self.idx
            self.idx += 1
            return val
        else:
            raise StopIteration()

myRange = MyRange(3)
for i in myRange:
    print(i) 

class SingleNode:
    """这是单向链表的节点"""

    def __init__(self, value, _next=None):
        self.value = value
        self.next = _next

# 实现单向链表
class LinkedList:
    def __init__(self):
        self.head = None
        self.tail = None
        self.length = 0
        self.n = 0
        self.temp = None

    def append(self, value):
        node = SingleNode(value)
        if self.head is None:
            self.head = node
        else:
            self.tail.next = node
        self.tail = node
        self.length += 1

    def iternodes(self):
        data = self.head
        while data:
            yield data
            data = data.next

    def __iter__(self):
        return self

    def __next__(self):
        if self.n < self.length:
            if self.temp is None:
                self.temp = self.head
            else:
                self.temp = self.temp.next
            self.n += 1
            return self.temp.value
        else:
            self.temp = None
            self.n = 0
            raise StopIteration


lls = LinkedList()
lls.append(10)
lls.append(2)
lls.append(33)
lls.append(4)
for i in lls:
    print(i)

print([i for i in lls])

class Node:
    """这是一个节点"""

    def __init__(self, value, _next=None, prev=None):
        self.value = value
        self.next = _next
        self.prev = prev

    def __str__(self):
        return str(self.value)

    def __repr__(self):
        return self.__str__()


class LinkedList:
    def __init__(self):
        self.data = []
        self.head = None
        self.tail = None
        self.length = 0
        self.n = 0
        self.temp = None

    def append(self, value):
        node = Node(value)
        self.data.append(node)
        if self.head is None:
            self.head = node
        else:
            self.tail.next = node
            node.prev = self.tail
        self.tail = node
        self.length += 1

    def pop(self):
        self.data.pop()
        tail = self.tail
        prev = tail.prev
        if prev is None:
            self.head = self.tail = None
        else:
            self.tail = prev
            prev.next = None
        self.length -= 1
        return tail.value

    def getitem(self, index):
        if isinstance(index, int):
            if index < 0:
                index = abs(index) - 1
                data = self.iternodes(reverse=True)
            else:
                data = self.iternodes()
            current = None

            for i, node in enumerate(data):
                if i == abs(index):
                    current = node
                    break
            if current:
                return current

    def iternodes(self, reverse=False):
        data = self.tail if reverse else self.head
        while data:
            yield data
            data = data.prev if reverse else data.next

    def insert(self, index, value):
        node = self.getitem(index)
        if node is None:
            self.append(value)
            return

        prev = node.prev
        new_node = Node(value, _next=node, prev=prev)
        if prev is None:
            self.head = new_node
        else:
            prev.next = new_node
            node.prev = new_node
        self.data.insert(index, new_node)
        self.length += 1

    def remove(self, item):
        if self.tail is None:
            return None
        for i, v in enumerate(self.iternodes()):
            if item == v.value:
                data = v
                break
        else:
            return None
        prev = data.prev
        _next = data.next
        if prev is None and _next is None:
            self.head = None
            self.tail = None
        elif prev is None:
            self.head = _next
            _next.prev = None
        elif _next is None:
            prev.next = _next
        else:
            prev.next = _next
            _next.prev = prev
        self.length -= 1
        del data

    def __len__(self):
        return self.length

    def __iter__(self):
        return self

    def __next__(self):
        if self.n < self.length:
            if self.temp is None:
                self.temp = self.head
            else:
                self.temp = self.temp.next
            self.n += 1
            return self.temp
        else:
            self.temp = None
            self.n = 0
            raise StopIteration

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

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


lls = LinkedList()
lls.append(10)
lls.append(2)
lls.append(33)
lls.append(4)
lls.insert(-1, 3000)

for i in enumerate(lls):
    print(i)
print("=" * 50)
# lls.remove(10)
lls.remove(33)
# print(v)
for i in enumerate(lls):
    print(i)

class Person(models.Model):
  name = models.CharField(max_length=30)
  age = models.IntegerField()

guy = Person(name='bob', age='35')
print(guy.age)
guy.save()

def fun():
    print('hello world!')


if __name__=="__main__":
    Hello = type('Hello',(object,),dict(hello=fun()))
    tc = Hello()
    tc.hello

Hello = type('Hello',(object,),dict(f1=fun)
tc = Hello()
tc.f1

def add(x,y):
    return x + y

Hello.add = add(1, 2)

print(tc.add)

from time import ctime

class MetaC(type):
    def __init__(self, *args):
        super().__init__(*args)
        print('调用类的init')

    def __call__(self, *args, **kwargs):
        print('调用类的call')
        _instance = super().__call__(*args, **kwargs)
        print('call return %s' %_instance)
        return _instance

class Foo(metaclass=MetaC):
    # __metaclass__ = MetaC

    def __init__(self, version=None):
        print('调用对象的init')

    def __new__(cls, *args, **kwargs):
        print('调用对象的new')
        _instance = super().__new__(cls)
        print('new return %s' %_instance)
        return _instance

foo = Foo('hello')

>>
调用类的init
调用类的call
调用对象的new
new return <__main__.Foo object at 0x0000018D2F57EF98>
调用对象的init
call return <__main__.Foo object at 0x0000018D2F57EF98>

import weakref
frome functools import wraps

def single_obj(cls):
    #实例缓存为弱引用，实例不被使用时会释放该实例
    _spam_cache = weakref.WeakValueDictionary()
    @wraps(cls)
    def wrapper(*args, **kwargs):
        if cls not in _spam_cache :
            _instance = cls(*args, **kwargs)
            _spam_cache [cls] = _instance
            return _instance
        else:
            return _spam_cache [cls]
    return wrapper

@single_obj
class A():
    def __init__(self, version):
        self.version = version
        print(self.version)

a1 = A(1.3)
a2 = A(1.2)
print('a1 id:',id(a1))
print('a2 id:',id(a2))

class Singleton(type):
    def __init__(self, *args, **kwargs):
        self._instance = None
        super().__init__(*args, **kwargs)

    def __call__(self, *args, **kwargs):
        if self._instance is None:
            self._instance = super().__call__(*args, **kwargs)
            return self._instance
        else:
            return self._instance

class B(metaclass=Singleton):
    def __init__(self, name):
        self.name = name
        print(name)

b1 = B('what')
b2 = B('hell')
print(b2.name)
print('b1 id:',id(b1))
print('b2 id:',id(b2))

class C(object):
    _instance = None

    def __init__(self, name):
        self.name = name
        print(name)

    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

c1 = C('dsfsfd')
c2 = C('java')

print('c1 id:',id(c1))
print('c2 id:',id(c2))