Python 面向对象，类的属性和 类的方法

面向对象，类的属性和 类的方法

面向对象

1. 类和对象
2. Python类定义
3. 类属性
4. 类方法

面向过程和面向对象

面向过程 和 面向对象 编程

1. 面向过程 编程：函数式编程，C程序，shell等
2. 面向对象 编程：C++ ，Java，Python

类和对象
类和对象：是面向对象中的两个重要概念
1.类： 是对事物的抽象，比如：人类，球类
2.对象：是类的一个实例，比如：足球，篮球

实例说明：
球类可以对球的特征和行为进行抽象，然后可以实例化一个真实的球实体出来

静态属性，动态方法

为什么面向对象
面向对象的主要思想是：

1. 封装
2. 继承
3. 多态

这种思想方便解决较为复杂的项目，且维护起来较为容易

类的定义

类定义：
类把需要的变量和函数组合成一起，这样包含称为"封装"
class A(object):

类的结构：
class 类名：
成员变量 - 属性
成员函数 - 方法

class MyClass(object):
    def fun(self): print "i am function" 

类的方法中至少有一个参数 self

#!/usr/bin/python

class People(object): # 定义类(class)，object可以有，也可以没有 color = 'yellow' #定义了一个静态属性,成员变量 def think(self): #定义了一个动态方法，这个方法里一定要有self，还可以带多个属性，成员函数 self.color = "black" #如果需要调用类里的属性，就要用到self.color来调用该静态属性 print "I am a %s" % self.color #调用动态方法时的输出 print "i am a thinker" ren = People() #将类赋值给'ren'这个变量，就是一个对象，即为将类实例化 print ren # 单纯打印这个'ren'变量是一个对象(object)，所以将类实例化后的便是对象(object) print ren.color #输出，'ren'对象的静态属性， ren.think() #使用这个类里面的.think()方法 

输出结果：

[root@hc python]# python class.py 
<__main__.People object at 0x7f646d144690>    #打印这个方法的信息

yellow           #静态属性的输出结果 I am a black #这里输出的是 ren.think() i am a thinker 

对象的创建

创建对象的过程称之为实例化;
当一个对象被创建后，包含三个方面的特性

1. 对象句柄
2. 属性
3. 方法

句柄用于 区分不同的对象
对象的属性和方法与类中的成员变量和成员函数对应

obj = MyClass() # 创建类的一个实例(对象)通过对象来调用方法和属性

类的属性

类的属性按使用范围分为公有属性和私有属性，类的属性范围取决于属性的名称

公有属性：
在类中和类外都能调用的属性

私有属性：
不能再类外以及被类以外的函数调用

定义方式：
以"__"双下划线开始的成员变量就是私有属性
可以通过instance._classname__attribute方式访问

内置属性：由系统在定义类的时候默认添加的，由前后双下划线构成，__dict__ , __module__

#!/usr/bin/python
#coding:utf8
class People(object): color = 'yellow' __age = 30 #前面加两个__ 为私有属性，只能内部使用 def think(self): self.color = "black" print "I am a %s" % self.color print "i am a thinker" print self.__age #调用私有属性 ren = People() #将类实体化 ren.color = 'aaa' #对象内的color属性重新赋值 print ren.color #输出这个对象被新赋值的属性 print People.color() #调用类里的属性，是原来的值，是因为类实体化之前之后是不同的个体 print '-' *50 ren.think() #调用对象里的方法 print '-' *50 print ren.__dict__ #通过对象调用公有的属性，保存到字典里输出 print People.__dict__ #通过类调用内置属性，公私有属性全部保存到字典输出 print '-' *50 print ren._People__age #以这种方法查看对象里的私有属性，测试用 

输出结果：

[root@hc python]# python class1.py 

#  ren = People()      
#  ren.color = 'aaa'   
#  print ren.color   
# print People.color() aaa yellow -------------------------------------------------- # ren.think() I am a black i am a thinker 30 #这是私有属性 -------------------------------------------------- # print ren.__dict__ {'color': 'black'} # print People.__dict__ {'__module__': '__main__', 'color': 'yellow', '__doc__': None, '__dict__': <attribute '__dict__' of 'People' objects>, '_People__age': 30, '__weakref__': <attribute '__weakref__' of 'People' objects>, 'think': <function think at 0x7fe443e265f0>} -------------------------------------------------- # print ren._People__age 30 

类的方法

1. 方法的定义和函数一样，但是需要self 作为第一个参数
2. 类方法：
   公有方法
   私有方法
   类方法
   静态方法

公有方法：在类中和类外都能调用的方法

私有方法：不能被类的外部调用，在方法前面加上"__"双下划线就是私有方法

self 参数
用于区分函数和类的方法(必须有一个self)，self参数表示执行对象本身

方法和函数的区别是：在括号内有没有self，有self就是方法，没有就是函数

self代表类的本事

通过类调用！
类的方法 (能被类直接调用的叫做类方法)
类方法：
被classmethod()函数处理过的函数，能被类所调用，也能被对象所调用(是继承的关系)

classmethod
修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。

静态方法：
相当于"全局函数"，可以被类直接调 用，可以被所有实例化对象共享，通过staticmethod()定义，
静态方法没有self参数。

装饰器：

@classmethod    
# 指定一个类的方法为类方法，通过这个函数classmethod，(单独写需要一个变量来接受值)
#动态方法占用资源比较少，用到了才会加载，但是访问速度比较慢


@staticmethod  
#只针对它下面的函数生效,它是将函数转为类的静态方法,静态方法比较占用资源，但是访问速度快 #静态方法无需实例化，但也可以也可以实例化后调用 

使用例子

#!/usr/bin/python
#coding:utf8
class People(object): color = 'yellow' __age = 30 def think(self): self.color = "black" print "I am a %s" % self.color print "i am a thinker" print self.__age def __aaa(self): # 私有方法，只能内部调用 print "使用私有方法 " def axx(self): #需要使用到一个类的方法内部调用才可以访问到内部的私有方法 self.__aaa()  @classmethod #类方法 def test(x): #修饰符对应的函数不需要实例化，不需要self参数，但第一个参数需要是表示自身类的x参数，可以来调用类的属性，类的方法，实例化对象等。 print x.color print "动态方法"  @staticmethod #静态方法无需实例化，但也可以也可以实例化后调用 def test1(): print "静态方法" print "通过实体化后的类访问" abc = People() abc.test() abc.test1() print "---------------------" print "通过类访问的" People.test() People.test1() print "---------------------" abc.axx()

类的内置方法  和 继承

python 内部类

所谓内部类，就是再类的内部定义的类，主要目的是为了更好的抽象实现世界
例子：
汽车是个类，汽车的底盘，轮胎也可以抽象为类，将其定义到汽车类中，则形成内部类，更好的描述汽车类，因为底盘，轮胎是汽车的一部分

内部类的实例化方法
方法1：直接使用外部类调用内部类
object_name = outclass_name.inclass_name()

方法2：先对外部类进行实例化，然后再实例化内部类

out_name = outclass_name()
in_name = out_name.inclass_name()
in_name,method()

方法3：公有属性，直接可以通过类直接调用

魔术方法

类的内置方法或者叫做魔术方法

__str__(self)
将输出对象更友好的输出

构造函数与析构函数
构造函数：
用于初始化类的内部状态，Python提供的构造函数是__init__();
__init__()方法是可选的，如果不提供，Python会给出一个默认的__init__方法

析构函数：
用于释放对象占用的资源，Python提供的析构函数是 __del__();
__del__()也是可选的。如果不提供，则Python 会在后台提供默认析构函数

垃圾回收机制

1.Python 采用垃圾回收机制来清理不再使用的对象；Python提供gc模块释放不再使用的对象。

2.Python采用"引用计数"的算法方式来处理回收
即：当某个对象在其作用域内不再被其他对象引用的时候，Python就自动清除对象；

3.gc模块的collect()可以一次性收集所有待处理的对象 print gc.collect()如果是0则为回收

类的继承

1. 继承是面向对象的重要特性之一；
2. 继承关系：继承是相对两个雷而言的父子关系，子类继承了父类的所有公有属性和方法
3. 继承实现了代码重用

使用继承
继承可以重用已经存在的数据和行为，减少代码的重复编写，Python在类名后使用一对括号来表示继承关系，括号中的类即为父类。

class Myclass(ParentClass) class Myclass继承了ParentClass类

如果父类定义了__init__方法，子类必须显示调用父类的__init__方法：
ParentClass.__init__(self,[args...])

如果子类需要扩展父类的行为，可以添加__init__方法的参数

简单的继承：

#!/usr/bin/python
#-*- coding:utf-8 -*-

class People(object): #New Style 传统方式不加() color = 'yellow' def __init__(self, c): #父类的构造函数,如果self后跟了一个变量,则在继承的子类时需要重写这个构造函数然后引入这个值 print "Init..." self.dwell = 'Earth' #这是它的初始化变量 def think(self): print "I am a %s" % self.color print "I am a thinker " class Chinese(People): #Chinese继承了People父类 def __init__(self): #则在继承的子类时需要重写这个构造函数然后引入这个值 #People.__init__(self,'red') #第一种方法可以使用传统的方式 ，super 是第二种方法，不支持传统格式的类 super(Chinese, self).__init__('red') #使用super函数来继承父类，父类必须是NewStyle，不然会报错 pass cn = Chinese() #实例化调用这个类 print cn.color #输出里面定义的变量 cn.think() #还能通过继承的类，访问它内部的函数 print cn.dwell #也是会执行内部初始化的变量 

super 函数 来继承父类

class Chinese(People):
Chinese继承了People父类

`def __init__(self):   `   

则在继承的子类时需要重写这个构造函数然后引入这个值
super(Chinese, self).__init__('red') #使用super函数来继承父类，
pass

Help on class super in module __builtin__: class super(object) | super(type, obj) -> bound super object; requires isinstance(obj, type) | super(type) -> unbound super object | super(type, type2) -> bound super object; requires issubclass(type2, type) | Typical use to call a cooperative superclass method: | class C(B): | def meth(self, arg): | super(C, self).meth(arg) 

People.__init__(self,'red')
第一种方法可以使用传统的方式 ，super 是第二种方法，不支持传统格式的类

super(Chinese, self).__init__('red')
使用super函数来继承父类，父类必须是NewStyle，不然会报错

继承2

多重继承
Python 支持多重继承，即一个类可以继承多个父类
语法
class class_name(Parent_c1,Parent_c2,...)

注意：
当父类中出现多个自定义的__init__方法时，
多重继承只执行第一个类的__init__方法
其他不执行

类属性，方法 总结

类的属性-总结

1. 类属性，也是共有属性

2. 类的私有属性

3. 对象的共有属性

4. 对象的私有属性

5. 内置函数

6. 函数的局部变量

7. 全局变量

#!/usr/bin/python
#coding:utf8

var5 = '全局变量'
class MyClass(object): var1 = '类属性，类的公有属性 var1' __var2 = '类的私有属性 __var2' def func1(self): self.var3 = '对象的公有属性 var3' self.__var4 = '对象的私有属性 __var4' var5 = '函数的局部变量 var5' print self.__var4 print var5 def func2(self): print self.var1 print self.__var2 print self.var3 #需要先调用方法，才能被调用 print self.__var4 print var5 #全局变量！ return '这是函数的返回值,没有return就会出现None' mc = MyClass() mc.func1() print '---------' print mc.func2() print '---------' --------------------------------------------- mc = MyClass() #实例化类 print mc.var1 #私有属性都不能访问 mc.func1() #先调用方法 才能调用内部的公有属性 print mc.func1() mc1 = MyClass() print mc1.var3 #没调用内部的方法，所以不能调用 ---------------------------------------------- #通过类 ，对象的属性只能通过对象访问， print MyClass.var1 #访问类的公有属性 可以 print MyClass.var2 #访问类的私有属性 不可以 mc = MyClass() mc.fun1 mc.fun2 print '-' * 50 print mc.__dict__ #返回一个字典，里面包含的是'类的内置属性' print '-' * 50 print MyClass.__dict__ #通过类来调用'内置属性'，返回一个字典，里面包含的类来调用'内置属性' 

类方法总结

1. 公有方法

2. 私有方法

3. 类方法

4. 静态方法

5. 内置方法

#!/usr/bin/python 
#coding:utf8

class MyClass(object): name = 'Test' def __init__(self): #如果加了内部的构造函数，即当前的类别实例化会， self.func1() #会自动加载，并初始化里面的内容 self.__func2() self.classFun() #类方法，静态方法 这两种都可以通过对象来调用 self.staticFun() def func1(self): print self.name, print "我是公有方法" # self.__func2() def __func2(self): print self.name, print "我是私有方法" @classmethod #修饰器，这样就将类里的方法，转为类方法然后外部调用 def classFun(self): print self.name, print "我是类方法" @staticmethod #修饰器 def staticFun(): #静态方法不能有 self 方法 print MyClass.name, #因为是静态的，需要类名来调用 print "我是静态方法" mc = MyClass() #实例化 mc.func1() mc.__fun2() #直接调用不行。必须在内部调用,在func1里面调用才可以 ------------------------------------------------------------------------------------ MyClass.classFun() #类方法，需要加修饰器才可以再外部调用 MyClass.staticFun() #静态方法，需要加修饰器才可以再外部调用 #类方法，静态方法 这两种都可以通过对象来调用 

rc脚本(类的定义与脚本的结构)

#!/usr/bin/python
import sys
import os
from subprocess import Popen, PIPE #调用系统bash 启动，stdout的标准输出通过这个PIPE管道符传入一个临时文件里 class Process(object): '''memcached rc script''' #注释 def __init__(self, name, program, args, workdir): #类实例化的时候，初始化传递的参数 self.name = name self.program = program #初始化属性 self.args = args self.workdir = workdir def _init(self): #这里是一个下划线，是一个普通的方法 '''/var/tmp/memcached''' if not os.path.exists(self.workdir): # 判断目标不存在，则创建，进入该目录 os.mkdir(self.workdir) # mkdir 创建目录 os.chdir(self.workdir) # chdir 进入该目录 def _pidFile(self): '''/var/tmp/memcached/memcached.pid''' return os.path.join(self.workdir, "%s.pid" % self.name) #将目录连接到一起,然后返回这个结果 def _writhPid(self): if selp.pid: #判断这个pid 是否有值，有值则写入文件 with open(self._pidFile(),'w') as fd: fd.write(str(self.pid)) def start(self): #类里的方法 self._init() #这个方法判断这个目录在不在，不在就创建。 cmd = self.program + ' ' + self.args #启动脚本的路径 + ' ' + 启动选项参数 p = Popen(cmd, stdout=PIPE, shell=True) # 这条是执行命令，stdout=PIPE：是将标准输出传给管道,传给一个临时文件里 self.pid = p.pid #用了Popen里的一个pid方法输出PID self._wirthPid() #调用方法写PID 这个值 print "%s start Sucessful" % self.name def _getPid(self): p = Popen(['pidof',self.name],stdout=PEPI) pid = p.stdout.read().strip() # strip() 去除收尾的空格，换行等。可以执行去掉的字符，需要在括号内写 return pid def stop(self): self._getPid() if pid: #判断这个不为空则执行 os.kill(int(pid),15) #调用系统命令 kill 进程，用kill -15 相当正常退出，kill()里面需要两个参数，一个是PID和等级 if os.path.exists(self._pidFile()): os.remove(self._pifFile()) print " %s is stop" % self.name def restart(self): self.stop() self.start() def status(self): pid = self._getPid() if pid: print "%s is runing" % self.name elif pid: print "%s in stopped" % self.name def help(self): print "Usage: %s {start|stop|status|restart}" % __file__ # __file__ 打印这个内置属性，则是该文件名 def main(): #一个主体函数 name = 'memcached' #程序名 prog = '/usr/bin/memcached' #程序的启动脚本的路径 args = '-u nobody -p 11211 -c 1024 -m 64' #启动时带的参数 wd = '/var/tmp/memcached' #程序所在的路径 pm = Process(name = name, #上面的参数 传入类的属性里去 program = prog, args = args, workdir = wd) try: #处理输入的异常 cmd = sys.argv[1] #取输入脚本的第一个值 比如，start，stop等等。。 except IndexError, e: #except 异常的捕捉 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() 函数，print(__name__) 打印的输出就等于__main__ main() #这里等同于启动python程序的意思 

Linux kill 命令

9和15 的区别，最好还是用15，这样相当于正常退出
SIGNKILL（9） 的效果是立即杀死进程. 该信号不能被阻塞, 处理和忽略。
SIGNTERM（15） 的效果是正常退出进程，退出前可以被阻塞或回调处理。并且它是Linux缺省的程序中断信号。

linux 命令

echo $$ #当前PID的bash 进程
tty #显示当前终端号
pidof #取一个进程的PID

关于 get pid 的问题

from subprocess import Popen, PIPE #先加载模块

p = Popen(['pidof','memcached'], stdout=PIPE) #将Popen 实例化 给p

p.pid #p调用pid方法 ，这个PID 是 pidof命令的进程的PID
28675

pid = p.stdout.read() #这个PID才是我memcached的进程PID

pid
'28001\n'

pid.strip() #用strip() 字符串方法 去掉 特殊字符
'28001'