1 >>> dict #类型dict就是类dict
2 <class 'dict'>
3 >>> d=dict(name='egon') #实例化
4 >>> d.pop('name') #向d发一条消息，执行d的方法pop
5 'egon'

1 def functionName(args):
2      '函数文档字符串'
3       函数体 

 1 '''
 2 class 类名:
 3     '类的文档字符串'
 4     类体
 5 '''
 6 
 7 #我们创建一个类
 8 class Data:
 9     pass 

class Garen:        #定义英雄盖伦的类，不同的玩家可以用它实例出自己英雄;
    camp='Demacia'  #所有玩家的英雄(盖伦)的阵营都是Demacia;
    def attack(self,enemy):   #普通攻击技能，enemy是敌人;
        enemy.life_value-=self.aggressivity #根据自己的攻击力，攻击敌人就减掉敌人的生命值。

>>> Garen.camp #引用类的数据属性，该属性与所有对象/实例共享
'Demacia'
>>> Garen.attack #引用类的函数属性，该属性也共享
<function Garen.attack at 0x101356510>
>>> Garen.name='Garen' #增加属性
>>> del Garen.name #删除属性

class Garen:        #定义英雄盖伦的类，不同的玩家可以用它实例出自己英雄;
    camp='Demacia'  #所有玩家的英雄(盖伦)的阵营都是Demacia;
    def __init__(self,nickname,aggressivity=58,life_value=455): #英雄的初始攻击力58...;
        self.nickname=nickname  #为自己的盖伦起个别名;
        self.aggressivity=aggressivity #英雄都有自己的攻击力;
        self.life_value=life_value #英雄都有自己的生命值;
    def attack(self,enemy):   #普通攻击技能，enemy是敌人;
        enemy.life_value-=self.aggressivity #根据自己的攻击力，攻击敌人就减掉敌人的生命值。

>>> g1=Garen('草丛伦') #就是在执行Garen.__init__(g1,'草丛伦')，然后执行__init__内的代码g1.nickname=‘草丛伦’等

>>> g1=Garen('草丛伦') #类实例化得到g1这个实例，基于该实例我们讲解实例相关知识
>>> type(g1) #查看g1的类型就是类Garen
<class '__main__.Garen'>
>>> isinstance(g1,Garen) #g1就是Garen的实例
True

#对象/实例本身其实只有数据属性
>>> g1.nickname
'草丛伦'
>>> g1.aggressivity
58
>>> g1.life_value
455
'''
查看实例属性
同样是dir和内置__dict__两种方式
特殊实例属性
__class__
__dict__
....
'''

>>> g1.attack #对象的绑定方法
<bound method Garen.attack of <__main__.Garen object at 0x101348dd8>>

>>> Garen.attack #对象的绑定方法attack本质就是调用类的函数attack的功能，二者是一种绑定关系
<function Garen.attack at 0x101356620>

class Riven:
    camp='Noxus'  #所有玩家的英雄(锐雯)的阵营都是Noxus;
    def __init__(self,nickname,aggressivity=54,life_value=414): #英雄的初始攻击力54;
        self.nickname=nickname  #为自己的锐雯起个别名;
        self.aggressivity=aggressivity #英雄都有自己的攻击力;
        self.life_value=life_value #英雄都有自己的生命值;
    def attack(self,enemy):   #普通攻击技能，enemy是敌人;
        enemy.life_value-=self.aggressivity #根据自己的攻击力，攻击敌人就减掉敌人的生命值。 

>>> r1=Riven('锐雯雯')

>>> g1.life_value
455
>>> r1.attack(g1)
>>> g1.life_value
401 

>>> id(r1.camp) #本质就是在引用类的camp属性，二者id一样
4315241024
>>> id(Riven.camp)
4315241024

>>> id(r1.attack) 
4302501512
>>> id(Riven.attack)
4315244200

'''
r1.attack就是在执行Riven.attack的功能，python的class机制会将Riven的函数属性attack绑定给r1，r1相当于拿到了一个指针，指向Riven类的attack功能

除此之外r1.attack()会将r1传给attack的第一个参数
'''

class Riven:
    camp='Noxus'
    def __init__(self,nickname,
                 aggressivity=54,
                 life_value=414,
                 money=1001,
                 armor=3):
        self.nickname=nickname
        self.aggressivity=aggressivity
        self.life_value=life_value
        self.money=money
        self.armor=armor
    def attack(self,enemy):
        damage_value=self.aggressivity-enemy.armor
        enemy.life_value-=damage_value

class Garen:
    camp='Demacia'
    def __init__(self,nickname,
                 aggressivity=58,
                 life_value=455,
                 money=100,
                 armor=10):
        self.nickname=nickname
        self.aggressivity=aggressivity
        self.life_value=life_value
        self.money=money
        self.armor=armor
    def attack(self,enemy):
        damage_value=self.aggressivity-enemy.armor
        enemy.life_value-=damage_value

class BlackCleaver:
    def __init__(self,price=475,aggrev=9,life_value=100):
        self.price=price
        self.aggrev=aggrev
        self.life_value=life_value
    def update(self,obj):
        obj.money-=self.price #减钱
        obj.aggressivity+=self.aggrev #加攻击
        obj.life_value+=self.life_value #加生命值
    def fire(self,obj): #这是该装备的主动技能,喷火,烧死对方
        obj.life_value-=1000 #假设火烧的攻击力是1000

r1=Riven('草丛伦')
g1=Garen('盖文')
b1=BlackCleaver()

print(r1.aggressivity,r1.life_value,r1.money) #r1的攻击力,生命值,护甲

if r1.money > b1.price:
    r1.b1=b1
    b1.update(r1)


print(r1.aggressivity,r1.life_value,r1.money) #r1的攻击力,生命值,护甲

print(g1.life_value)
r1.attack(g1) #普通攻击
print(g1.life_value)
r1.b1.fire(g1) #用装备攻击
print(g1.life_value) #g1的生命值小于0就死了 

class ParentClass1: #定义父类
    pass

class ParentClass2: #定义父类
    pass

class SubClass1(ParentClass1): #单继承，基类是ParentClass1，派生类是SubClass
    pass

class SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类
    pass

>>> SubClass1.__bases__ #__base__只查看从左到右继承的第一个子类，__bases__则是查看所有继承的父类
(<class '__main__.ParentClass1'>,)
>>> SubClass2.__bases__
(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)

>>> ParentClass1.__bases__
(<class 'object'>,)
>>> ParentClass2.__bases__
(<class 'object'>,)

class Hero:
    def __init__(self,nickname,aggressivity,life_value):
        self.nickname=nickname
        self.aggressivity=aggressivity
        self.life_value=life_value

    def move_forward(self):
        print('%s move forward' %self.nickname)

    def move_backward(self):
        print('%s move backward' %self.nickname)

    def move_left(self):
        print('%s move forward' %self.nickname)

    def move_right(self):
        print('%s move forward' %self.nickname)

    def attack(self,enemy):
        enemy.life_value-=self.aggressivity
class Garen(Hero):
    pass

class Riven(Hero):
    pass

g1=Garen('草丛伦',100,300)
r1=Riven('锐雯雯',57,200)

print(g1.life_value)
r1.attack(g1)
print(g1.life_value)

'''
运行结果
300
243
'''

class Riven(Hero):
    camp='Noxus'
    def attack(self,enemy): #在自己这里定义新的attack,不再使用父类的attack,且不会影响父类
        print('from riven')
    def fly(self): #在自己这里定义新的
        print('%s is flying' %self.nickname)

class Riven(Hero):
    camp='Noxus'
    def __init__(self,nickname,aggressivity,life_value,skin):
        Hero.__init__(self,nickname,aggressivity,life_value) #调用父类功能
        self.skin=skin #新属性
    def attack(self,enemy): #在自己这里定义新的attack,不再使用父类的attack,且不会影响父类
        Hero.attack(self,enemy) #调用功能
        print('from riven')
    def fly(self): #在自己这里定义新的
        print('%s is flying' %self.nickname)

r1=Riven('锐雯雯',57,200,'比基尼')
r1.fly()
print(r1.skin)

'''
运行结果
锐雯雯 is flying
比基尼

'''

>>> class Equip: #武器装备类
...     def fire(self):
...         print('release Fire skill')
... 
>>> class Riven: #英雄Riven的类,一个英雄需要有装备,因而需要组合Equip类
...     camp='Noxus'
...     def __init__(self,nickname):
...         self.nickname=nickname
...         self.equip=Equip() #用Equip类产生一个装备,赋值给实例的equip属性
... 
>>> r1=Riven('锐雯雯')
>>> r1.equip.fire() #可以使用组合的类产生的对象所持有的方法
release Fire skill

>>> class Teacher:
...     def __init__(self,name,gender):
...         self.name=name
...         self.gender=gender
...     def teach(self):
...         print('teaching')
... 
>>> 
>>> class Professor(Teacher):
...     pass
... 
>>> p1=Professor('egon','male')
>>> p1.teach()
teaching

class BirthDate:
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day

class Couse:
    def __init__(self,name,price,period):
        self.name=name
        self.price=price
        self.period=period

class Teacher:
    def __init__(self,name,gender):
        self.name=name
        self.gender=gender
    def teach(self):
        print('teaching')
class Professor(Teacher):
    def __init__(self,name,gender,birth,course):
        Teacher.__init__(self,name,gender)
        self.birth=birth
        self.course=course

p1=Professor('egon','male',
             BirthDate('1995','1','27'),
             Couse('python','28000','4 months'))

print(p1.birth.year,p1.birth.month,p1.birth.day)
print(p1.course.name,p1.course.price,p1.course.period)
'''
运行结果:
1995 1 27
python 28000 4 months
'''

class Interface:#定义接口Interface类来模仿接口的概念，python中压根就没有interface关键字来定义一个接口。
    def read(self): #定接口函数read
        pass

    def write(self): #定义接口函数write
        pass


class Txt(Interface): #文本，具体实现read和write
    def read(self):
        print('文本数据的读取方法')

    def write(self):
        print('文本数据的读取方法')

class Sata(Interface): #磁盘，具体实现read和write
    def read(self):
        print('硬盘数据的读取方法')

    def write(self):
        print('硬盘数据的读取方法')

class Process(Interface):
    def read(self):
        print('进程数据的读取方法')

    def write(self):
        print('进程数据的读取方法')

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
#一切皆文件
import abc #利用abc模块实现抽象类

class All_file(metaclass=abc.ABCMeta):
    all_type='file'
    @abc.abstractmethod #定义抽象方法，无需实现功能
    def read(self):
        '子类必须定义读功能'
        pass

    @abc.abstractmethod #定义抽象方法，无需实现功能
    def write(self):
        '子类必须定义写功能'
        pass

# class Txt(All_file):
#     pass
#
# t1=Txt() #报错,子类没有定义抽象方法

class Txt(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('文本数据的读取方法')

    def write(self):
        print('文本数据的读取方法')

class Sata(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('硬盘数据的读取方法')

    def write(self):
        print('硬盘数据的读取方法')

class Process(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('进程数据的读取方法')

    def write(self):
        print('进程数据的读取方法')

wenbenwenjian=Txt()

yingpanwenjian=Sata()

jinchengwenjian=Process()

#这样大家都是被归一化了,也就是一切皆文件的思想
wenbenwenjian.read()
yingpanwenjian.write()
jinchengwenjian.read()

print(wenbenwenjian.all_type)
print(yingpanwenjian.all_type)
print(jinchengwenjian.all_type)

>>> F.mro() #等同于F.__mro__
[<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

import abc
class Animal(metaclass=abc.ABCMeta): #同一类事物:动物
    @abc.abstractmethod
    def talk(self):
        pass

class People(Animal): #动物的形态之一:人
    def talk(self):
        print('say hello')

class Dog(Animal): #动物的形态之二:狗
    def talk(self):
        print('say wangwang')

class Pig(Animal): #动物的形态之三:猪
    def talk(self):
        print('say aoao')

import abc
class File(metaclass=abc.ABCMeta): #同一类事物:文件
    @abc.abstractmethod
    def click(self):
        pass

class Text(File): #文件的形态之一:文本文件
    def click(self):
        print('open file')

class ExeFile(File): #文件的形态之二:可执行文件
    def click(self):
        print('execute file')

>>> def func(animal): #参数animal就是对态性的体现
...     animal.talk()
... 
>>> people1=People() #产生一个人的对象
>>> pig1=Pig() #产生一个猪的对象
>>> dog1=Dog() #产生一个狗的对象
>>> func(people1) 
say hello
>>> func(pig1)
say aoao
>>> func(dog1)
say wangwang

>>> def func(f):
...     f.click()
... 
>>> t1=Text()
>>> e1=ExeFile()
>>> func(t1)
open file
>>> func(e1)
execute file

>>> class Cat(Animal): #属于动物的另外一种形态：猫
...     def talk(self):
...         print('say miao')
... 
>>> def func(animal): #对于使用者来说，自己的代码根本无需改动
...     animal.talk()
... 
>>> cat1=Cat() #实例出一只猫
>>> func(cat1) #甚至连调用方式也无需改变，就能调用猫的talk功能
say miao

'''
这样我们新增了一个形态Cat，由Cat类产生的实例cat1，使用者可以在完全不需要修改自己代码的情况下。使用和人、狗、猪一样的方式调用cat1的talk方法，即func(cat1)
'''

>>> r1.nickname
'草丛伦'
>>> Riven.camp
'Noxus'

class A:
    __N=0 #类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N
    def __init__(self):
        self.__X=10 #变形为self._A__X
    def __foo(self): #变形为_A__foo
        print('from A')
    def bar(self):
        self.__foo() #只有在类内部才可以通过__foo的形式访问到.

>>> a=A()
>>> a._A__N
0
>>> a._A__X
10
>>> A._A__N
0

#正常情况
>>> class A:
...     def fa(self):
...         print('from A')
...     def test(self):
...         self.fa()
... 
>>> class B(A):
...     def fa(self):
...         print('from B')
... 
>>> b=B()
>>> b.test()
from B

#把fa定义成私有的，即__fa
>>> class A:
...     def __fa(self): #在定义时就变形为_A__fa
...         print('from A')
...     def test(self):
...         self.__fa() #只会与自己所在的类为准,即调用_A__fa
... 
>>> class B(A):
...     def __fa(self):
...         print('from B')
... 
>>> b=B()
>>> b.test()
from A

class People:
    def __init__(self,name,weight,height):
        self.name=name
        self.weight=weight
        self.height=height
    @property
    def bmi(self):
        return self.weight / (self.height**2)

p1=People('egon',75,1.85)
print(p1.bmi)

import math
class Circle:
    def __init__(self,radius): #圆的半径radius
        self.radius=radius

    @property
    def area(self):
        return math.pi * self.radius**2 #计算面积

    @property
    def perimeter(self):
        return 2*math.pi*self.radius #计算周长

c=Circle(10)
print(c.radius)
print(c.area) #可以向访问数据属性一样去访问area,会触发一个函数的执行,动态计算出一个值
print(c.perimeter) #同上
'''
输出结果:
10
314.1592653589793
62.83185307179586
'''

c.area=3 #为特性area赋值
'''
抛出异常:
AttributeError: can't set attribute
'''

ps：面向对象的封装有三种方式:
【public】
这种其实就是不封装,是对外公开的
【protected】
这种封装方式对外不公开,但对朋友(friend)或者子类(形象的说法是“儿子”,但我不知道为什么大家 不说“女儿”,就像“parent”本来是“父母”的意思,但中文都是叫“父类”)公开
【private】
这种封装对谁都不公开

class Foo:
    def __init__(self,val):
        self.__NAME=val #将所有的数据属性都隐藏起来

    @property
    def name(self):
        return self.__NAME #obj.name访问的是self.__NAME(这也是真实值的存放位置)

    @name.setter
    def name(self,value):
        if not isinstance(value,str):  #在设定值之前进行类型检查
            raise TypeError('%s must be str' %value)
        self.__N
第十篇：面向对象系列之三大特性(代码片段)
 　　本篇主要介绍面向对象的三大特性及封装、继承、多态。一、封装　第一层意义上的封装：　　封装：从封装本身的理解，装--将一系列东西（苹果、梨子、香蕉等）一股脑的塞进一个盒子内，而封--自然就是密封，即...  查看详情  
                
第十篇：装饰器
三、装饰器1、装饰器是在函数调用之上的修饰2、这些修饰仅是当声明一个函数或者方法的时候，才会应用的额外调用3、使用装饰器的情形有：3.1引入日志3.2增加计时逻辑来检测性能3.3给函数加入事务的能力 装饰器基础：1...  查看详情  
                
数据结构第十篇——顺序队列
...叫做队尾(rear)，允许删除的一端称为队头(front)。队列在程序设计中也经常出现。一个最典型的例子就是操作系统中的作业排队。在允许多道程序运行的计算机系统中，同时有  查看详情  
                
java基础第十篇之异常
...的子类)来完成。这样将功能的定义与实现分离，优化了程序设计。	请记住：一切事物均有功能，即一切事物均有接口。	与定义类的class不同，接口定义时需要使用interface  查看详情  
                
杨玲201771010133《面向对象程序设计（java）》第十三周学习总结(代码片段)
 《面向对象程序设计（java）》第十三周学习总结第一部分：理论知识学习部分1、事件源（eventsource）：能够产生事件的对象都可以成为事件源，如文本框、按钮等。一个事件源是一个能够注册监听器并向监听器发送事件对...  查看详情  
                
perfview专题(第十篇)：洞察c#终结队列引发的内存泄漏(代码片段)
一：背景C#程序内存泄漏的诱发因素有很多，但从顶层原理上来说，就是该销毁的用户根对象没有被销毁，从而导致内存中意料之外的对象无限堆积，导致内存暴涨，最终崩溃，这其中的一个用户根就...  查看详情  
                
达拉草201771010105《面向对象程序设计（java）》第十三周学习总结(代码片段)
达拉草201771010105《面向对象程序设计（java）》第十三周学习总结第一部分：理论知识事件处理基础：事件源：能够产生事件的对象都可以成为事件源，如文本框、按钮等。一个事件源是一个能够注册监听器并向监听器发送事件...  查看详情  
                
201771010126王燕《面向对象程序设计（java）》第十三周学习总结(代码片段)
实验十三  图形界面事件处理技术实验时间 2018-11-221、实验目的与要求(1) 掌握事件处理的基本原理，理解其用途；事件源（eventeventeventeventsourcesourcesource）：能够产生事件的对象都可：能够产生事件的对象都可：...  查看详情  
                
第十五章面向对象程序设计
15.1虚函数：基类的成员函数，并在其前面添加关键字virtual，此类函数是基类希望其派生类进行覆盖的函数 15.2protected：对应受保护成员，派生类可以访问该成员，但其他用户则禁止访问该成员 15.31classQuote{2public:3Quote()=def...  查看详情  
                
杨玲201771010133《面向对象程序设计（java）》第十周学习总结(代码片段)
《面向对象程序设计（java）》第十周学习总结第一部分：理论知识学习部分  第八章  泛型程序设计一、泛型程序设计的定义1、JDK5.0中增加的泛型类型，是Java语言中类型安全的一次重要改进。2、泛型：也称参数...  查看详情  
                
张季跃201771010139《面向对象程序设计（java）》第十三周学习总结(代码片段)
张季跃201771010139《面向对象程序设计（java）》第十三周学习总结实验部分：1、实验目的与要求(1)掌握事件处理的基本原理，理解其用途；(2)掌握AWT事件模型的工作机制；(3) 掌握事件处理的基本编程模型；(4)了解GUI界面组件...  查看详情  
                
达拉草201771010105《面向对象程序设计（java）》第十一周学习总结(代码片段)
达拉草201771010105《面向对象程序设计（java）》第十一周学习总结实验十一   集合实验时间 2018-11-8第一部分：理论知识1.集合(Collection或称为容器)是一种包含多个元素并提供对所包含元素操作方法的类，其包含的元...  查看详情  
                
python自动化第十篇：
复习：　　线程与进程的区别：　　　　进程：资源的集合　　　　线程：最小调度单位进程至少包含一个线程线程之间的内存是共享的，两个线程操作同一个数据就会修改整个结果（需要mutex加锁来保持数据的一致性），递归...  查看详情  
                
刘志梅2017710101152.《面向对象程序设计（java）》第十三周学习总结(代码片段)
实验十三 图形界面事件处理技术实验时间2018-11-221、理论知识(1)任何支持GUI的操作环境都要不断地监视按键或点击鼠标这样的事件。JAVA这样的面向对象语言，都将事件的相关的信息封装在一个事件对象中。不同的事件源可以...  查看详情  
                
201771010125王瑜《面向对象程序设计（java）》第十三周学习总结(代码片段)
...　　　　　　　　　　　　　　201771010125王瑜《面向对象程序设计（Java）》第十三周学习总结一.理论部分1.上周学习了GUI为用户提供的交互式的图形化操作界面；AWT包组件，Component组件，Container容器以及Swing组件等；而这周则主...  查看详情  
                
张季跃201771010139《面向对象程序设计（java）》第十二周学习总结
张季跃201771010139《面向对象程序设计（java）》第十二周学习总结第二部分：实验部分1、实验目的与要求(1)掌握JavaGUI中框架创建及属性设置中常用类的API；(2)掌握JavaGUI中2D图形绘制常用类的API；(3)了解JavaGUI中2D图形中字体与颜色...  查看详情  
                
达拉草201771010105《面向对象程序设计（java）》第十四周学习总结(代码片段)
达拉草201771010105《面向对象程序设计（java）》第十四周学习总结第一部分：理论知识布局管理器：布局管理器是一组类。实现java.awt.LayoutManager接口，决定容器中组件的位置和大小。Java.awt包中定义了5种布局管理类，每一种布局...  查看详情  
                
王艳201771010127《面向对象程序设计（java）》第十三周学习总结(代码片段)
一：理论部分。1.事件处理基础。1）事件源：能够产生事件的对象都可以成为事件源，如文本框、按钮等。一个事件源是一个能够注册监听器并向监听器发送事件对象的对象。2）事件监听器：事件监听器对象接收事件源发送的...  查看详情