Python面向对象编程-基础

一、面向对象程序设计

编程式范式分为：面向过程的编程范式和面向对象的编程范式

编程式范式：就是程序员使用特定的语法+数据结构和算法编写代码，最终的目的是告诉计算机来解析并且来执行这些代码。

面向过程的编程范式:也就是说流程化的干一件事，严格的按照顺序来进行，就像流水线的工作一样，主要针对的是C语言。

面向对象的编程范式：站在上帝的视角，世间万物一切皆对象。

二、类

1、类的定义解读

类：把拥有相同特征或者行为的事物进行归类，这一过程叫class。它是抽象的，不能直接使用。

特征也被称为属性。

行为也被称为方法。

比如：我们定义一个人，人里面包含年龄，姓名，性别等特征。

注意：在程序里应先定义类，再对类进行一系列的实例化。

           class定义类的时候，类的首字母必须大写。比如：class Person()。

           在Python中定义类，使用的关键字是class，所有类的基类是object，即是一切类的“祖先”。

           经典类：没有object；新式类：在Python3中，所有的类都继承object。

2、类的内置方法：

__init__:类的构造方法，初始化

__del__:类的清理方法

__str__:返回对象的字符串

__doc__:返回document的信息

__call__:对象加()返回的内容

示例如下：

class Person(object):
    '''定义人类'''

    def __init__(self):
        print("初始化")

    def __del__(self):
        print("清理")

    def __str__(self):
        return "返回对象的字符串"

    def __call__(self, *args, **kwargs):
        print("对象加()返回的内容")
obj=Person()
print(obj)
obj()
print(obj.__doc__)

运行结果如下：

初始化
返回对象的字符串
对象加()返回的内容
定义人类
清理

Process finished with exit code 0

三、对象：是由类创建出来的一个具体存在的，可以直接使用。

1、类与对象的关系

a：先有类，再有对象.

b：类只有一个，而对象可以有很多个，不同对象之间的属性可能是各不相同的。

c：类中定义了什么属性和方法，对象中就有什么属性和方法。

四、类和对象

1、示例解释

1-1：在Python中定义一个只包含方法的类：

class 类名(object):  #object是基类，是一切类的“祖先”，而且类的首字母必须“大写”
    def 方法1(self,参数列表): 
        内容
    def 方法2(self，参数列表): #必须有“self”
        内容

注意：类名的命名规则：每个单词的首字母都要大写；单词与单词之间没有下划线。

1-2：当一个类定义完后，要使用这个类来创建对象：

对象变量=类名()   #叫做类的实例化过程

如下图所示：

class Person(object): #object是基类，是一切类的“祖先”，而且类的首字母必须“大写”
    def show(self):  #self叫做类的本身，“def show(self)”叫做类的方法(函数)
        print("人是有姓名、性别、年龄的。") 
#创建人的对象
obj=Person() #使用类来创建对象  #"obj"只是个代号，我们也可以起其它的名字
obj.show() 

运行结果如下：

人是有姓名、性别、年龄的。

Process finished with exit code 0

1-3：在类的外部给已经实例化的对象添加属性，并通过类内部方法来打印类内部的信息：

class Person(object): 
     def show(self):  
         print("人是有姓名、性别、年龄的。")
#创建人的对象
obj=Person() 类的实例化，对象叫做“obj”
obj.show()
obj.city="xi'an" #在类的外部给已经实例化的对象添加属性
print(obj.city)

运行结果如下：

人是有姓名、性别、年龄的。
xi'an

Process finished with exit code 0

1-4：类有一个名为 __init__() 的特殊方法(构造方法/函数)，该方法在类实例化时会自动调用。

class Person(object):
    def __init__(self, name, age):
        self.username=name  #self.属性名=属性的初始值
        self.old=age
x=Person(name="Lucy",age=23) #要调用类里面的变量，以及方法等，首先要进行实例化
#对象名=类名() x是类Person()的实例化的对象，类实例化的过程，也是类初始化的过程
6 print(x.username,x.old)

运行结果如下：

Lucy 23

Process finished with exit code 0

1-5：综合上面的知识点示例：

class Person(object):  #object是基类，是一切类的“祖先”，而且类的首字母必须“大写”
     def __init__(self,name,age): #Person()类的方法里需要形参，这时init()里的属性，充当Person()类里的形参 
#"name,age"可以理解为类的属性
         self.name=name   #实例属性
         self.age=age   #实例属性
     def show(self):  #self叫做类的本身，“def show(self)”叫做类的方法(函数)
         print("Hello World!") 
         print("name:{0},age:{1}".format(self.name,self.age))  
obj=Person(name="Lucy",age=23) #类的实例化
obj.show() 
obj.city="China" #给已经实例化的对象添加属性
print(obj.city)

运行结果如下：

Hello World!
name:Lucy,age:23
China

Process finished with exit code 0

1-6：__del__(self)方法：希望在对象被销毁之前，在执行一些操作

class Person(object):
    def __init__(self,name,age): 
#Person()类的方法里需要形参，这时init()里的属性，充当Person()类里的形参 
#"name,age"可以理解为类的属性
        self.name=name   #实例属性
        self.age=age   #实例属性
        print("start")
        #清理操作
    def __del__(self):
        print("end")
    def show(self):  #self叫做类的本身，“def show(self)”叫做类的方法(函数)
        print("name:{0},age:{1}".format(self.name,self.age)) 
obj=Person(name="Lucy",age=23) #类的实例化
obj.show() 
obj.name="China" #类的实例化对象添加属性
print(obj.name)

运行过程的执行顺序：def _ _init_ _() >def show(self) > print(obj.name) > def _ _del_ _(self)运行结果如下：

start
name:Lucy,age:23
China
end

Process finished with exit code 0

五、属性查找

1-1：实例属性：在实例对象中定义的属性。

1-2：数据属性(类属性)：在类中定义的属性，并且多个实例对象之间共享一份类属性。使用方式：

类名.类属性
也可以是： 对象名.类属性

具体表现在：

class Animal(object):
    address="earth" #数据属性（类里面的变量），全局变量
    def __init__(self,age):
        self.age=age
    def show(self):
        print("It comes from {0},and age is {1}.".format(self.address,self.age))
objAnimal=Animal(age=23) #实例属性
objAnimal.show()
print(objAnimal.address) 使用 对象名.类属性来打印
print(objAnimal.age)

运行结果如下：

It comes from earth,and age is 23.
earth
23

Process finished with exit code 0

六、类的方法

1-1：在Python的类里面编写的特性函数叫做方法，这些方法主要分为：

1-1-1：普通方法（方法可以读写）：默认有个self参数，且只能被对象调用。

定义与调用格式：

语法：
        def 方法名(self，参数1，参数2):
                方法体
调用：
        对象名=类名(属性值)
        对象名.方法名(属性值)

示例如下：

#展示1
class Person(object):
    def show(self):
        print("My name is Lucy")
people=Person()
people.show()

#展示2
class Person(object):
    def show(self, name, age):
        self.name = name
        self.age = age
        print("My name is {0} and I am {1} years old.".format(self.name, self.age))
people=Person()
people.show(name="Lucy", age=23)

#展示3
class Person(object):
    def __init__(self,name,age):
        self.username=name
        self.old=age
    def show(self):
        print("My name is {0} and I am {1} years old.".format(self.username,self.old))
people=Person(name="Lucy",age=23)
people.show()

运行结果如下：

My name is Lucy
My name is Lucy and I am 23 years old.
My name is Lucy and I am 23 years old.

Process finished with exit code 0

1-1-2：特性方法（具备只读属性，方法不能有形式参数），会使用装饰器@property修饰。

定义与调用格式：

语法：
        @property
        def 方法名(self):
                方法体
调用：
        对象名=类名(属性值)
        对象名.方法名

示例如下：

class Person(object):
    def __init__(self,name,weight,height):
        self.name=name
        self.weight=weight
        self.height=height
    @property  #装饰器
    def info(self): #特性方法,只有"self"
        print("Hello World!") #特性方法可以读取出来
    @property  #装饰器
    def getBMI(self): #特性方法,只有"self"
        return self.weight/(self.height**2)
people=Person(name="Mike",weight=70,height=1.8)#实例属性
people.info #特性方法这里无括号，因而只能读不可以写
print(people.getBMI)

运行结果如下：

Hello World!
21.604938271604937

Process finished with exit code 0

1-1-3：静态方法（属于类，只能使用类名来调用），一般将数据属性使用静态方法处理。 使用装饰器@staticmethod来修饰。

定义与调用格式：

语法：
        @staticmethod
        def 方法名():
                方法体
调用：
        对象名=类名()
        对象名.方法名()

 示例如下：

class Animal(object):
    # address="地球" #数据属性（类里面的变量），全局变量
    @staticmethod
    def address():
        print("地球")
objAnimal=Animal() #实例属性
Animal.address()

运行结果如下：

地球

Process finished with exit code 0

1-1-4：动态参数:

所谓的动态参数就是在写函数时，你可以传递1个参数，2个参数，3个参数甚至更多，同时也可以忽略它。

动态参数：一般有两种表示方法： *args 和**kwargs ，它的区别不是在于 args和kwargs这里可以替换成任意字母，这里最主要的区别是*和**。

*args：1个*表示接收的任意参数，调用的时候，会将实际参数以元组的形式传给形式参数。如果参数是一个列表，将会把整个列表当做一个参数传递。

示例如下：

class Animal(object):
    def func(self,*args):  #动态参数
        print(args)
objAnimal=Animal()
objAnimal.func("a","b","c")
objAnimal.func(["1","2","3"])

运行结果如下：

('a', 'b', 'c')
(['1', '2', '3'],)

Process finished with exit code 0

Process finished with exit code 0

**kwargs：2个**表示接收的是任意键值对的关键字参数，这里调用的时候是以字典的形式传递给形式参数。

示例如下：

class Animal(object):
    def func(self,**kwargs):  #动态参数
        print(kwargs)
objAnimal=Animal()
objAnimal.func(name="dog",age=2)

运行结果如下：

{'name': 'dog', 'age': 2}

Process finished with exit code 0

1-1-5：综合运用

示例如下：

class Animal(object):
    def __init__(self,name,height):
        self.name=name
        self.height=height

    def show(self,weight):  #普通方法
        self.weight=weight
        print("The animal name is {0} and it weight is {1}.".format(self.name,self.weight))

    def func(self,**kwargs):  #动态参数
        print(kwargs)

    @staticmethod  #静态方法
    def address():
        print("地球")

    @property  #动态参数
    def getHeight(self):
        return self.height

objAnimal=Animal(name="dog",height=12)
objAnimal.show(weight=10)
objAnimal.func(name="dog",age=2)
print(objAnimal.getHeight)

运行结果如下：

The animal name is dog and it weight is 10.
{'name': 'dog', 'age': 2}
12

Process finished with exit code 0