20181204 面向对象、类的属性和方法

面向过程和面向对象

• 面向过程编程：函数式变成，C程序等
• 面向对象编程：C++,JAVA，Python等

类和对象

• 类和对象：是面向对象中的两个重要概念
  • 类：是对事物的抽象，比如：人类、球类
  • 对象：是类的一个实例，比如：足球、篮球
• 实例说明：
  • 球类可以对球的特征和行为进行抽象，然后可以实例化一个真实的球实体出来。

为什么面向对象

• 面向对象的主要思想是：
  • 封装
  • 继承
  • 多态
• 这种思想方便解决较为复杂的项目，且维护起来较为容易。

python类定义

• 类定义：
  类把需要的变量和函数组合成一起，这种包含为“封装”
  class A(object):
• 类的结构：
  class 类名：
  成员变量–属性
  成员函数–方法

类的创建

• class MyClass(object):
  def fun(self):
  print “I am function”
• 类的方法中至少有一个参数self

例1：
 #!/usr/bin/python
class People(object):
  color = 'yellow'

ren = People()  //得到的是一个object。<__main__.People object at 0x7f63dc0d6850>
print ren.color  //通过对象得到一个属性，叫静态属性


例2：
#!/usr/bin/python
class People(object):
  color = 'yellow'
  def think(self):  // self表示类的本身，表示使用上面的属性
      self.color = "black"
      print "I am a %s" % self.color
      print "I am a thinker"

ren = People() //访问属性和方法，需要先把类实例化。把类赋给一个变量，变量就是一个对象。
print ren.color //通过对象ren访问class里面的方法
ren.think()

类的属性

#!/usr/bin/python

class People(object):
    color = 'yellow'  //成员对象。类的属性
    
    def think(self):
        self.color = "black"
        print "I am a %s" % self.color
        print "I am a thinker"   // 成员函数。类的方法

ren = People()  // 这部分把类实例化。产生一个对象，包括三个特性对象句、属性和方法
print ren.color //ren 对象的属性
ren.think()  // ren 对象的方法

对象的创建

• 创建对象的过程称之为实例化：当一个对象被创建后，包含三个方面的特性：对象句柄、属性和方法。
  句柄用于区分不同的对象
  对象的属性和方法与类中的成员变量和成员函数对应
• obj = MyClass() //创建类的一个实例（对象）通过对象来调用方法和属性

类的属性

• 类的属性按使用范围分为公有属性和私有属性，类的属性范围取决于属性的名称
• • 公有属性：在类中和类外都有调用的属性
• • 私有属性：不能在类外及被类意外的函数调用
    定义方式：以“__”双下划线开始的成员变量就是私有属性
    可以通过instance._classname__attribute方式访问。
• 内置属性：由系统在定义类的时候默认添加的，由前后双下划线构成，dic,module

#!/usr/bin/python
#coding:utf7
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  = ’白色人‘ // 通过对象修改类的属性。实例化一个对象，这个对象就是一个个体，不影响通过类访问属性
print ren.color
print ren._People__age // 在类外部访问私有属性，不建议这么写。
ren.think() //通过访问类里的成员函数，间接的访问类里的私有属性
print ren.__dict__ // 通过对象调用内置属性，把类的公有属性保存到字典里
print '#' *30
print People.color // 通过类访问属性
print People.__age
print People.__dict__// 通过类调用内置属性，把公有私有函数都保存到字典

类的方法

• 方法的定义和函数一样，但是需要self作为第一个参数
• 类方法为：
  • 公有方法：在类中和类外都能调用的方法
  • 私有方法：不能被类的外部调用，在方法前面加上“__”双下划线就是私有方法
  • self参数：用于区分函数和类的方法（必须有一个self），self参数表示执行对象本身
  • 类方法：被classmethod()函数处理过的函数，能被类调用，也能被对象所调用（是继承的关系）
  • 静态方法：相当于“全局函数”，可以被类直接调用，可以被所有实例化对象共享，通过staticmethod()定义，静态方法没有“self”参数。
• 装饰器：
  • @classmethod
  • @staticmethod

#!/usr/bin/python
#coding=utf-8
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 __talk(self):
        print "i am talking"
    def test(self):
        print 'test....'
    cm = classmethod(test)
#jack = People()
People.cm()  //通过classmethod函数处理才能通过类直接调用。动态方法，直接访问类里面某个方法，没有把其它方法和属性加载到内存当中，占用资源很少。

#!/usr/bin/python
#coding=utf-8
class People(object):
    color = 'yellow'
    __age = 30
    
    def __talk(self):
        print "i am talking"
    def test():   //因为没有self参数不知道类里面有什么东西，会把所有的方法和属性加载到内存里。静态的速度要比动态快
        print 'test....'
        print People.__age  //没有self，通过类来访问 
    sm = staticmethod(test)
    
jack = People()
jack.sm()
People.sm()

用装饰器不需要函数来处理
#!/usr/bin/python
#coding=utf-8
class People(object):
   color = 'yellow'
   __age = 30
   
   def __talk(self):
       print "i am talking"
   @classmethod // 装饰器只对下面的函数起作用，表示这个函数是类方法
   def test(self):
       print 'test....'
@staticmethod
   def test1():
       print "this is static method"
jack = People()
People.test()