1.类的属性总结
脚本练习:
2.打印各种类的属性
（1）访问类的公有属性
执行结果：
（2）访问类的私有属性
执行结果：
不建议使用这种方式访问类的私有属性，只是为了测试。
（3）访问对象的公有属性
执行结果：
结论：必须要先调用方法，才能使用方法里面的属性。
（4）访问对象的私有属性
执行结果：
结果：这样访问是不行的，不能再类外面访问对象的私有属性。
（5）访问函数的局部变量
执行结果：
结果：也不能用这种方法访问函数的局部变量。
总结：类的公有属性，可以通过对象访问
类的私有属性，也可以通过对象来访问
对象的公有属性，要先调用方法，才能通过对象来访问。
对象的私有属性，通过对象不能访问
函数的局部变量，在类的外面，通过对象也不能访问。
下面我们通过类来访问这些属性：
（1）访问公有属性
执行脚本：
没问题
（2）通过类访问私有属性：
执行脚本：
不可以访问
（3）通过类访问对象的公有属性
执行脚本：
不能访问。
说明：对象的属性，只能通过对象来访问
执行脚本：
可以执行
补充：对象的属性和类的属性的区别
①脚本中位置不一样
②类的属性是定义在方法外
③对象的属性是对应在方法里
测试这些属性在类的内部使用：
（1）在内部访问类的公有、私有属性
执行结果：
公有、私有属性都可以被访问。
（2）在类内部访问对象的公有属性
执行结果
（3）在类内部访问对象的私有属性
执行结果：
也可以访问对象的私有属性。
（4）在方法内调用对象的私有属性和函数局部变量
执行结果：
可以访问到
var5可以再fun1()里面被访问，不能再fun2()中被访问，除非把var5定义为全局变量，全局变量是在类的外部定义的。
如下图所示：
（5）访问类的内置属性
执行结果：
2.类的方法总结
（1）定义方法
（2）调用一下，查看这些方法可以在什么地方被调用
①调用公有方法L:
执行脚本：
②调用私有方法：
执行脚本：
如图，不能被调用，私有方法只能在类的内部被调用。
③调用类方法：
在类方法上面加上“装饰器”，有了装饰器，表示这个方法可以被类来调用；
调用方法如下：
执行脚本：
可以执行，要加上装饰器才可以被类调用。
④调用静态方法
静态方法也是通过类来调用的，静态调用不能通过self，所以改成类来调用name,如下:
调用方法：
执行结果：
练习
memcache 的启动脚本：
import sys
import os
from subprocess import Popen, PIPE
class Process(object):
'''memcached rc script'''
args = {'USER':'memcached',
'PORT':'11211',
'MAXCONN':1024,
'CACHESIZE':64,
'OPTIONS':''}
def __init__(self, name, program, workdir):
self.name = name
self.program = program
self.workdir = workdir
def _init(self):
'''/var/run/memcached'''
if not os.path.exists(self.workdir):
os.mkdir(self.workdir)
os.chdir(self.workdir)
def _pidFile(self):
'''/var/run/memcached/memcached.pid'''
return os.path.join(self.workdir,"%s.pid" % self.name)
def _getPid(self):
p = Popen(['pidof',self.name],stdout=PIPE)
return p.stdout.read().strip()
def _writePid(self):
pid = self._getPid
if self.pid:
with open(self._pidFile(),'w') as fd:
fd.write(str(self.pid))
return pid
def _readConf(self,f):
with open(f) as fd:
lines = fd.readlines()
return dict([i.strip().replace('"','').split('=') for i in lines])
def _parseArgs(self):
conf = self._readConf('/etc/sysconfig/memcached')
if 'USER' in conf:
self.args['USER'] = conf['USER']
if 'PORT' in conf:
self.args['PORT'] = conf['PORT']
if 'MAXCONN' in conf:
self.args['MAXCONN'] = conf['MAXCONN']
if 'CACHESIZE' in conf:
self.args['CACHESIZE'] = conf['CACHESIZE']
options = ['-u', self.args['USER'],
'-p', self.args['PORT'],
'-m', self.args['CACHESIZE'],
'-c', self.args['MAXCONN']]
os.system("chown %s %s" % (self.args['USER'],self.workdir))
return options
def start(self):
pid = self._getPid()
if pid:
print "%s is runnig..." % self.name
sys.exit()
self._init()
cmd = [self.program] + self._parseArgs() + ['-d','-P',self._pidFile()]
print cmd
p = Popen(cmd, stdout = PIPE)
#self.pid = p.pid
#self._writePid()
print "%s start sucessful" % self.name
def stop(self):
pid = self._getPid()
print "kill the pid %s" % pid
if pid:
os.kill(int(pid),15)
if os.path.exists(self._pidFile()):
os.remove(self._pidFile())
print "%s is stopped" % self.name
def restart(self):
self.stop()
self.start()
def status(self):
pid = self._getPid()
if pid:
print "%s is already running" % self.name
else:
print "%s is not running" % self.name
def help():
print "Usage: %s {start|stop|status|restart}" % __file__
def main():
#pm = Process()
name = 'memcached'
program = '/usr/bin/memcached'
workdir = '/var/run/memcached'
pm = Process(name = name,program = program,workdir = workdir)
try:
cmd = sys.argv[1]
except IndexError, e:
print "Option error"
sys.exit()
if cmd == 'start':
pm.start()
elif cmd == 'stop':
pm.stop()
elif cmd == 'restart':
pm.restart()
elif cmd == 'status':
pm.status()
else:
pm.help()
if __name__ == '__main__':
main()