Python 基础语法 12 类的属性和方法

2018-12-03

2.7 面向对象介绍
2.8 类的属性
2.9 类的方法

2.7 面向对象介绍

面向过程和面向对象编程
- 面向过程编程：函数式编程，C程序等
- 面向对象编程：C++,Java,Python等

类和对象：是面向对象中的两个重要概念

实例说明：
- 类：是对事物的抽象，比如：人类、球类
- 对象：是类的一个实例，比如:足球、篮球
- 球类可以对球的特征和行为进行抽象，然后可以实例化一个真实的球实体出来。
  面向对象是把数据，对数据的操作方法放在一个主体里面，此整体为对象的这种思想方便解决较为复杂的项目，且维护起来较为容易。
  面向对象的主要思想是：- 封装 - 继承 - 多态
  Python类定义：
  定义类就是类把需要的变量和函数组合成一起，也称为“封装”
  类里面有静态属性和动态方法对应就是变量和函数

语法格式

1 2	class 类名(object): 代码块

脚本格式

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

class People(object): ##定义类 封装
    color = 'yellow'   ## 静态属性 == 变量

    def think(self):  ##动态方法 == 函数  self必须要填的参数
        self.color = 'black'  ##调用上面的属性 前面加上self
        print 'I an a %s man' %self.color
        print 'I an chinese'

kun = People()   ##创建对象kun == 类赋值给变量
print kun.color  ##调用对象的属性
kun.think()  ##调用对象的方法

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

2.8 类的属性

1）公有属性：在类中和类外都能调用的属性。
2）私有属性：不能在类外及被类以外的函数调用。以__双下划线开始的成员变量就是私有属性
可以通过对象名._类名私有属性名方式访问。
3）内置属性：由系统在定义类的时候默认添加的，由前后双下划线构成，__dict__, __module__。

class People(object): ##定义类 封装
    color = 'yellow'   ## 静态属性 == 变量
    __age = 30

    def think(self):  ##动态方法 == 函数  self必须要填的参数
        self.color = 'black'  ##调用上面的属性 前面加上self
        print 'I an a %s man' %self.color
        print 'I an chinese'
        print self.__age  ##私有属性只能在内部使用 调用属性加上self

kun = People()   ##创建对象kun == 类赋值给变量
print kun.color  ##调用对象的共有属性
kun.think()  ##调用对象的方法
print kun.__dict__  ##调用对象的内置函数 内置函数是不需要定义

kun.__age 使用对象（在类外）调用私有属性是错误的，但可以使用对象名._类名私有属性名来访问 kun._People__age 但一般在测试使用

实例化的对象的属性是可以自己对其修改当影响类中的属性的值

kun.color = 'white'  ##对象自己临时定义属性
print kun.color  ##调用对象的属性
print People.color  ##调用类的属性

white
yellow

2.9 类的方法

类的方法定义和函数一样，但是需要self作为第一个参数。self参数用于区分函数和类的方法(必须有一个self)，self参数表示执行对象本身。

公有方法：在类中和类外都能调用的方法。
私有方法：不能被类的外部调用，在方法前面加上__双下划线就是私有方法。
类方法：被classmethod()函数处理过的函数，能被类所调用，也能被对象所调用(是继承的关系)
静态方法：相当于”全局函数”，可以被类直接调用，可以被所有实例化对象共享，通过staticmethod()定义，静态方法没有”self”参数。
类方法和静态方法都可以使用装饰器来定义而不需要使用各自的函数来定义。只需要在类方法和静态方法上加上@classmethod 和 @staticmethod

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

class People(object):

    color = 'yellow'  ## 共有属性

    def think(self):   ##  共有方法
        print '共有方法'

    def __think(self):  ##私有方法
        print '私有方法'

    def test(self):
        self.think()   ##共有方法可以在类中调用
        self.__think()  ##私有方法只能在类中调用

    cm = classmethod(think)  ##通过classmethod函数把共有方法转变为类方法 也叫动态方法

    def test1():              #静态方法先定义没self的函数
        print '静态方法'      #再使用staticmethod函数转换为静态方法
    sm = staticmethod(test1)  #

    @classmethod                 #@classmethod装饰器来定义类方法
    def test2(self):             #
        print '装饰器定义类方法' #

    @staticmethod                  #@staticmethod装饰器定义静态方法
    def test3():                   #
        print '装饰器定义静态方法' #
kun = People()  ##实例化对象

kun.test()    ##共有方法可以在类外调用
kun._People__think()  ##在类外只能通过 实例._类名私有方法 访问，一般测试使用

People.cm()  ##类方法（动态方法）可以让类调用
People.sm()  ##静态方法可以让类调用

People.test2()   #类调用类方法
People.test3()   #类调用静态方法

Python内部类

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

语法格式

1
2
3

class 类名(object):
    class 类名(object):
        代码块

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


class People(object):
    color = 'yellow'


    class Chinese(object):   ##定义内部类
       name =  '我是内部类'

方法1：直接使用外部类调用内部类

1 2	kun = People.Chinese() #使用外部类调用内部类再实例化对象 print kun.name #通过实例对象来访问内部类属性

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

1
2
3

ren = People()           #先对外部类进行实例化
tom = ren.Chinese()      #再实例化内部类
print tom.name           #通过实例对象来访问内部类属性

方法3，不实例化对象，直接使用类来调用

1	print People.Chinese.name ##通过类直接调用内部类的属性