类

class Circle:#类一般大写开头
    parents='two-dim' # 属于类的数据成员，公有成员
    __son='none'   # 属于类的数据成员，私有成员 
    
    def __init__(self,c,r,t): #构造方法，特殊方法，构造属于对象的数据成员，一般是在该函数中构造，也可以在其他方法中构造
        self.center=c       #self代表对象，通过 self.属性名 的形式来构建属性(属于对象的数据成员)并把参数的值赋给属性
        self.radius=r       #构造了两个属于对象的数据成员，并且都是公有的。
        self.__test=t       #t必须在创建对象时给出值，但是默认看不到这个属性，因为这是个私有成员，不能通过直接通过对象查看。
        Circle.parents='two-dim' #通过类名加成员名的方式访问类的数据成员
        
    def add_attr(self,dim=1):#通过调用这个实例方法可以实现为类添加对象成员但不可添加类成员
        self.__distance=sum([i**2 for i in self.center])**(1/2)#私有对象成员
        self.dimen=dim
        
    def __private_method(self):#私有方法，实例方法
        '''
        私有方法，不可使用对象直接调用，主要是供该对象类的其他方法使用
        '''
        return (self.__distance,Circle.__son)# 可以使用类和对象成员
    
    def public_method(self): # 公有方法，实例方法
        '''
        公有方法可以调用私有方法，也可以访问类成员和对象成员，公有方法可以被对象直接调用
        '''
        return self.__private_method()+(self.__distance,Circle.__son)
    
    @classmethod              #修饰器，声明类方法
    def classShowTotal(cls):  #类方法,一般以cls代表类，可以在调用时不传递cls参数
        print(cls.__son)

    @staticmethod             #修饰器，声明静态方法
    def staticShowTotal():    #静态方法,可以在调用时不传递参数
        print(Circle.__son)   

## 利用类数据成员的共享性，可以实时获得该类的对象数量，并且可以控制该类可以创建的对象最大数量。例如：
class Demo(object):
    total = 0
    def __new__(cls, *args, **kwargs):           #该方法在__init__()之前被调用
        if cls.total >= 3:                       #最多允许创建3个对象
            raise Exception('最多只能创建3个对象')
        else:
            return object.__new__(cls)
    def __init__(self):
        Demo.total = Demo.total + 1
t1 = Demo()
t1
t2 = Demo()
t3 = Demo()
t4 = Demo()#不能创建第四个对象

import abc

class Foo(metaclass=abc.ABCMeta):  #抽象类
    def f1(self):                  #普通实例方法
        print(123)

    def f2(self):                  #普通实例方法
        print(456)

    @abc.abstractmethod            #抽象方法
    def f3(self):
        raise Exception('You musr reimplement this method.')

class Bar(Foo):
    def f3(self):                  #必须重新实现基类中的抽象方法
        print(33333)

b = Bar()
b.f3()

class Root:
    __total = 0
    def __init__(self, v):    #构造方法
        self.__value = v
        Root.__total += 1

    def show(self):           #普通实例方法
        print('self.__value:', self.__value)
        print('Root.__total:', Root.__total)

    @classmethod              #修饰器，声明类方法
    def classShowTotal(cls):  #类方法
        print(cls.__total)

    @staticmethod             #修饰器，声明静态方法
    def staticShowTotal():    #静态方法
        print(Root.__total)

##可读
class Test:
    def __init__(self, value):
        self.__value = value

    @property
    def value(self):               #只读，无法修改和删除
        return self.__value

## 可读可写
class Test:
    def __init__(self, value):
        self.__value = value	

    def __get(self):
        return self.__value

    def __set(self, v):
        self.__value = v
    value = property(__get, __set)

    def show(self):
        print(self.__value)

## 可读、可修改、可删除的属性。
class Test:
    def __init__(self, value):
        self.__value = value

    def __get(self):
        return self.__value

    def __set(self, v):
        self.__value = v

    def __del(self):
        del self.__value

    value = property(__get, __set, __del)

    def show(self):
        print(self.__value)

class Car:
    price = 100000                     #定义类属性
    def __init__(self, c):
        self.color = c                 #定义实例属性

car1 = Car("Red")                      #实例化对象
car2 = Car("Blue")
print(car1.color, Car.price)           #查看实例属性和类属性的值
Car.price = 110000                     #修改类属性
Car.name = 'QQ'                        #动态增加类属性
car1.color = "Yellow"                  #修改实例属性
print(car2.color, Car.price, Car.name)
print(car1.color, Car.price, Car.name)

import types#增加成员方法要用到

def setSpeed(self, s): 
    self.speed = s

car1.setSpeed = types.MethodType(setSpeed, car1) #动态增加成员方法，注意使用types.MethodType方法
car1.setSpeed(50)                                #调用成员方法
print(car1.speed)

## -*- coding:utf-8 -*-
## Filename: AccessMembersOfBaseclass.py
## --------------------
## Function description:
## Show how to access method and data of parent class
## --------------------
## Author: 董付国
## Email: dongfuguo2005@126.com
##--------------------
## Date: 2014-11-27,Updated on 2017-4-4
## --------------------

class Person(object):
    def __init__(self, name = '', age = 20, sex = 'man'):
        self.setName(name)
        self.setAge(age)
        self.setSex(sex)
        
    def setName(self, name):
        assert isinstance(name, str), 'name must be string.'
        self.__name = name
        
    def setAge(self, age):
        assert isinstance(age, int), 'age must be integer.'
        self.__age = age
        
    def setSex(self, sex):
        assert sex in ('man', 'woman'), 'sex must be "man" or "woman"'
        self.__sex = sex
        
    def show(self):
        print('Name:', self.__name)
        print('Age:', self.__age)
        print('Sex:', self.__sex)

class Teacher(Person):
    def __init__(self, name='', age = 30, sex = 'man', department = 'Computer'):
        super(Teacher, self).__init__(name, age, sex)
        # 也可以使用下面的形式对基类数据成员进行初始化
        #Person.__init__(self, name, age, sex)
        self.setDepartment(department)
        
    def setDepartment(self, department):        
        assert isinstance(department, str), 'department must be a string.'
        self.__department = department
        
    def show(self):
        super(Teacher, self).show()
        print('Department:', self.__department)

if __name__ =='__main__':
    print('='*30)
    zhangsan = Person('Zhang San', 19, 'man')
    zhangsan.show()

    print('='*30)
    lisi = Teacher('Li Si',32, 'man', 'Math')
    lisi.show()
    print('='*30)
    lisi.setAge(40)
    lisi.show()

>>> class Animal(object):      #定义基类
    def show(self):
        print('I am an animal.')
>>> class Cat(Animal):         #派生类，覆盖了基类的show()方法
    def show(self):
        print('I am a cat.')
>>> class Dog(Animal):         #派生类
    def show(self):
        print('I am a dog.')
>>> class Tiger(Animal):       #派生类
    def show(self):
        print('I am a tiger.')
>>> class Test(Animal):        #派生类，没有覆盖基类的show()方法
    pass
>>> x = [item() for item in (Animal, Cat, Dog, Tiger, Test)]
>>> for item in x:        #遍历基类和派生类对象并调用show()方法
    item.show()

class myDeque:
    #构造方法，默认队列大小为10
    def __init__(self, iterable=None,maxlen = 10):
        if iterable==None:
            self._content = []
            self._current = 0
        else:
            self._content = list(iterable)
            self._current = len(iterable)
        self._size = maxlen
        if self._size < self._current:
            self._size = self._current

    #析构方法
    def __del__(self):
        del self._content

    #修改队列大小
    def setSize(self, size):
        if size < self._current:
            #如果缩小队列，需要同时删除后面的元素
            for i in range(size, self._current)[::-1]:
                del self._content[i]
            self._current = size
        self._size = size

    #在右侧入队
    def appendRight(self, v):
        if self._current < self._size:
            self._content.append(v)
            self._current = self._current + 1
        else:
            print('The queue is full')

    #在左侧入队
    def appendLeft(self, v):
        if self._current < self._size:
            self._content.insert(0, v)
            self._current = self._current + 1
        else:
            print('The queue is full')

    #在左侧出队
    def popLeft(self):
        if self._content:
            self._current = self._current - 1
            return self._content.pop(0)
        else:
            print('The queue is empty')

    #在右侧出队
    def popRight(self):
        if self._content:
            self._current = self._current - 1
            return self._content.pop()
        else:
            print('The queue is empty')

    #循环移位
    def rotate(self, k):
        if abs(k) > self._current:
            print('k must <= '+str(self._current))
            return
        self._content = self._content[-k:] + self._content[:-k]

    #元素翻转
    def reverse(self):
        self._content = self._content[::-1]

    #显示当前队列中元素个数
    def __len__(self):
        return self._current

    #使用print()打印对象时，显示当前队列中的元素
    def __str__(self):
        return 'myDeque(' + str(self._content) + ', maxlen='+ str(self._size) + ')'

    #直接对象名当做表达式时，显示当前队列中的元素
    __repr__ = __str__

    #队列置空
    def clear(self):
        self._content = []
        self._current = 0

    #测试队列是否为空
    def isEmpty(self):
        return not self._content

    #测试队列是否已满
    def isFull(self):
        return self._current == self._size

if __name__ == '__main__':
    print('Please use me as a module.')

'''
Author: 董付国
部分成果：《Python程序设计基础》、《Python程序设计（第2版）》
          《Python可以这样学》
微信公众号：Python小屋，关注人数12000人，分享文章近500篇
email: dongfuguo2005@126.com
Date: 2014-11-10, Updated on 2017-12-8
'''

class Stack:
    def __init__(self, size = 10):
        '''创建栈对象并进行初始化，默认栈大小为10'''
        # 使用列表存放栈的元素
        self._content = []
        # 初始栈大小
        self._size = size
        # 栈中元素个数初始化为0
        self._current = 0
        
    def empty(self):
        '''清空栈'''
        self._content = []
        self._current = 0
        
    def isEmpty(self):
        '''测试栈是否为空'''
        return not self._content

    def setSize(self, size):
        '''调整栈的大小，可以增大或缩小栈空间'''
        # 如果缩小空间时指定的新大小，小于已有元素个数
        # 则删除指定大小之后的已有元素
        if size < self._current:
            for i in range(size, self._current)[::-1]:
                del self._content[i]
            self._current = size
        self._size = size
    
    def isFull(self):
        '''测试栈是否已满'''
        return self._current == self._size
        
    def push(self, v):
        '''将新元素入栈'''
        # 模拟入栈，需要先测试栈是否已满
        if self._current < self._size:
            self._content.append(v)
            # 栈中元素个数加1
            self._current = self._current+1
        else:
            print('Stack Full!')

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

    __repr__ = __str__
            
    def pop(self):
        '''将栈顶元素出栈'''
        # 模拟出栈，需要先测试栈是否为空
        if self._content:
            # 栈中元素个数减1
            self._current = self._current-1
            return self._content.pop()
        else:
            print('Stack is empty!')
            
    def show(self):
        '''显示当前栈对象中的元素'''
        print(self._content)

    def showRemainderSpace(self):
        '''显示栈对象剩余空间大小'''
        print('Stack can still PUSH ', self._size-self._current, ' elements.')

if __name__ != '__main__':
    s = '''本模块由董付国编写，仅供学习和参考，
更多资源请关注微信公众号“Python小屋”
或参照《Python程序设计基础》、
      《Python程序设计（第2版）》、
      《Python可以这样学》、《Python程序设计开发宝典》系列图书
或与作者邮箱dongfuguo2005@126.com联系
使用方法：
        from stackDfg import Stack
        s = Stack()
        然后通过dir(s)命令查看详细用法
        并使用help(s.push)之类的命令查看具体用法'''
    print(s)