python中的class
Python 面向对象 | 菜鸟教程 (runoob.com)
#!/usr/bin/python
# -*- coding: UTF-8 -*-
class Employee:
'所有员工的基类'
empCount = 0 /empCount 变量是一个类变量，它的值将在这个类的所有实例之间共享。
def __init__(self, name, salary): /__init__()方法为类的构造函数，当创建了这个类的实例时就会调用该方法
self.name = name /self 代表类的实例，self 在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。
self.salary = salary
Employee.empCount += 1
def displayCount(self):
print "Total Employee %d" % Employee.empCount
def displayEmployee(self):
print "Name : ", self.name, ", Salary: ", self.salary
- 注释
print(self) /self 代表的是类的实例，print(self)得当前对象的地址<main.Test instance at 0x10d066878>
创建实例对象
实例化类其他编程语言中一般用关键字 new，但是在 Python 中并没有这个关键字，类的实例化类似函数调用方式。
"创建 Employee 类的第一个对象"
emp1 = Employee("Zara", 2000)
"第二个对象"
emp2 = Employee("Manni", 5000)
访问属性
您可以使用对象+点号 .来访问对象的属性。使用如下类的名称访问类变量:
emp1.displayEmployee() /对象+点号 .
emp2.displayEmployee()
print "Total Employee %d" % Employee.empCount /类的名称访问类变量
Name : Zara ,Salary: 2000
Name : Manni ,Salary: 5000
Total Employee 2
- 你可以添加，删除，修改类的属性，如下所示：
emp1.age = 7 # 添加一个 'age' 属性
emp1.age = 8 # 修改 'age' 属性
del emp1.age # 删除 'age' 属性
Python内置类属性
print "Employee.__doc__:", Employee.__doc__ /类的文档字符串
print "Employee.__name__:", Employee.__name__ /类名
print "Employee.__module__:", Employee.__module__ /类定义所在的模块
print "Employee.__bases__:", Employee.__bases__ /类的所有父类构成元素（包含了一个由所有父类组成的元组）
print "Employee.__dict__:", Employee.__dict__ / 类的属性（包含一个字典，由类的数据属性组成）
Employee.doc: 所有员工的基类
Employee.name: Employee
Employee.module: main
Employee.bases: ()
Employee.dict: {'module': 'main', 'displayCount':, 'empCount': 0, 'displayEmployee': , 'doc': '\xe6\x89\x80\xe6\x9c\x89\xe5\x91\x98\xe5\xb7\xa5\xe7\x9a\x84\xe5\x9f\xba\xe7\xb1\xbb', 'init': init at 0x10a939578>}
python对象销毁(垃圾回收)
- 当对象被创建时， 就创建了一个引用计数， 当这个对象不再需要时， 也就是说， 这个对象的引用计数变为0 时， 它被垃圾回收。但是回收不是"立即"的， 由解释器在适当的时机，将垃圾对象占用的内存空间回收。
- Python 的垃圾收集器实际上是一个引用计数器和一个循环垃圾收集器。作为引用计数的补充， 垃圾收集器也会留心被分配的总量很大（即未通过引用计数销毁的那些）的对象。 在这种情况下， 解释器会暂停下来， 试图清理所有未引用的循环。
a = 40 # 创建对象 <40>
b = a # 增加引用， <40> 的计数
c = [b] # 增加引用. <40> 的计数
del a # 减少引用 <40> 的计数
b = 100 # 减少引用 <40> 的计数
c[0] = -1 # 减少引用 <40> 的计数
类的继承
面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。
通过继承创建的新类称为子类或派生类，被继承的类称为基类、父类或超类。
继承语法
class 派生类名(基类名)
...
- 在python中继承中的一些特点：
- 1、如果在子类中需要父类的构造方法就需要显式的调用父类的构造方法，或者不重写父类的构造方法。详细说明可查看： python 子类继承父类构造函数说明。
- 2、Python 总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。
- 注释：第一条
如果重写了init 时，要继承父类的构造方法，可以使用 super 关键字：
super(子类，self).init(参数1，参数2，....)
还有一种经典写法：
父类名称.init(self,参数1，参数2，...)
class Father(object):
def __init__(self, name):
self.name=name
print ( "name: %s" %( self.name))
def getName(self):
return 'Father ' + self.name
class Son(Father):
def __init__(self, name):
super(Son, self).__init__(name) /super(子类，self).__init__(参数1，参数2，....)
print ("hi")
self.name = name
def getName(self):
return 'Son '+self.name
if __name__=='__main__':
son=Son('runoob')
print ( son.getName() )
name: runoob
hi
Son runoob
可见：是先执行了父类构造，super就是跳转到了父类的init；
且super(Son, self).init(name)中 前带self后不带。
方法重写
- 如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法
- 重写就只调用子类中的方法，重写即覆盖
类属性与方法
类的私有属性
__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。
类的方法
在类的内部，使用 def 关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数 self,且为第一个参数
类的私有方法
__private_method：两个下划线开头，声明该方法为私有方法，不能在类的外部调用。在类的内部调用 self.__private_methods
main函数中
print counter.__secretCount /报错，实例不能访问私有变量
- Python不允许实例化的类访问私有数据，但你可以使用 object.className__attrName（ 对象名.类名__私有属性名 ）访问属性，参考以下实例：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
class Runoob:
__site = "www.runoob.com"
runoob = Runoob()
print runoob._Runoob__site
www.runoob.com
- 单下划线、双下划线、头尾双下划线说明:
__ foo __: 定义的是特殊方法，一般是系统定义名字 ，类似 __init __() 之类的。
_foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能被作为外部类函数，不能用于 from module import *
__foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。