python 学习笔记9（面向对象）

面向过程、函数式、面向对象

  • 面向过程：根据业务逻辑从上到下写垒代码
  • 函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
  • 面向对象（Object Oriented Programming，OOP）：对函数进行分类和封装，让开发“更快更好更强...

　　　　面向过程

　　　　　　是用一长段代码来实现指定功能，开发过程中最常见的操作就是粘贴复制，即：将之前实现的代码块复制到现需功能处。

　　　　函数式编程

　　　　　　增强代码的重用性和可读性

　　　　面向对象

　　　　　　面向对象编程是一种编程方式，此编程方式的落地需要使用 “类” 和 “对象” 来实现，所以，面向对象编程其实就是对 “类” 和 “对　象”的使用。

创建类和对象

　　类就是一个模板，模板里可以包含多个函数，函数里实现一些功能

　　对象则是根据模板创建的实例，通过实例对象可以执行类中的函数

class bar:             #定义一个类
    def f(self,arg):   #方法
        print(arg)
        return 2
obj = bar()           #中间人
a = obj.f(1)              #类的调用
print(a)

class bar:             #定义一个类
    def f(self,arg):   #方法
        print(self,self.name,self.age,arg)
        return 2
obj = bar()           #中间人                     #self 就是对象（中间人）
print(obj)
obj.name="liu"                                     #<__main__.bar object at 0x0000000000A74160>
obj.age = 18                                                 #<__main__.bar object at 0x0000000000A74160> liu 18 1
obj.f(1)
#类的调用

obj2= bar()           #中间人                     #self 就是对象（中间人）
print(obj2)
obj2.name="Alex"                                    #<__main__.bar object at 0x0000000000D04240>
obj2.age = 38                                        #<__main__.bar object at 0x0000000000D04240> Alex 38 1
obj2.f(1)

创建方法

#普通方法
class bar:             #定义一个类
    def f(self,arg):
        print(arg)
        return 2
obj = bar()
a = obj.f(1)
print(a)               #1，2

#构造方法

class Person:
    def __init__(self,name,age):
        self.n = name
        self.a = age
    def foo(self):
        print(self.n,self.a)
liu =Person("liu",18)
print(liu)                              #<__main__.Person object at 0x00000000006EA630>
liu.foo()                             #liu 18

在构造方法中只要创建了对象，则第一时间会执行——init——方法

执行顺序

面向对象三大特性

一 、封装

#封装
class Person:
    def __init__(self,name,age):
        self.n = name
        self.a = age
        self.x = "o"
    def foo(self):
        print(self.n,self.a,self.x)
liu =Person("liu",18)
li = Person("li",20)
print(liu)                              #<__main__.Person object at 0x00000000007B42E8>
liu.foo()                               #liu 18 o

封装

封装在self中，即：封装在调用的对象中（本例中的liu、li），本例为构造方法，只要创建对象，python内部会第一时间自动执行

对于面向对象的封装来说，其实就是使用构造方法将内容封装到 对象 中，然后通过对象直接或者self间接获取被封装的内容。

二 、继承

　　继承，面向对象中的继承和现实生活中的继承相同，即：子可以继承父的内容。

　　1、继承
　　　　class 父类：           父类雅名：基类
　　　　　　pass
　　　　class 子类(父类):    子类雅名：派生类
　　　　　　pass

#继承
class A:
    def a1(self):
        print("1111111111")
    def a2(self):
        print("2222222222")
class B(A):
    def b1(self):
        print("3333333333333")
obj = B()
obj.b1()                  #3333333333333
obj.a1()                 #1111111111
obj.a2()                  #2222222222

继承

　　2、重写
　　　　防止执行父类中的方法

class A:
    def a1(self):
        print("1111111111")
    def a2(self):
        print("2222222222")
class B(A):
    def b1(self):
        print("3333333333333")
    def a2(self):
        print("44444444444")
obj = B()
obj.b1()         #3333333333333
obj.a1()         #1111111111
obj.a2()         #44444444444

重写

　　　　如果一定要执行父类中的方法

class A:
    def a1(self):
        print("1111111111")
    def a2(self):
        print("2222222222")
class B(A):
    def b1(self):
        print("3333333333333")
    def a2(self):
        super(B,self).a2()
        #A.a2(self)          #和上边的super方法一样，推荐使用super方法
        print("44444444444")
obj = B()
# obj.b1()
# obj.a1()
obj.a2()        #2222222222          44444444444

（1）super(子类, self).父类中的方法(...)
（2）父类名.父类中的方法(self,...)

　　3、self永远是执行方法的调用者

　　4、Python中支持多继承

　　a. 左侧优先
　　b. 一条道走到黑
　　c. 同一个根时，根最后执行　

#多父类的方法中
#1.从左到右
#2.一条道走到头
#3.多父类有共同父类，先左走到最高层（父类的共同父类不执行），然后#后层继续，最后执行父类的共同父类
class Basrequest:
    pass
class re_request():
    def f(self):
        print("FFFFFFFFFFFF")
        self.h()       #self 相当于obj（zilei的），所以当执行obj.f()  时先打印FFFFFFFFFFFF，下边的调用self.h()，相当于obj.h()，先执行mini中的h方法，
    def h(self):
        print("HHHHHHHHHHHH")
class mini:
    def h(self):
        print("mininmininmini")
class zilei(mini,re_request):
    pass
obj = zilei()
#obj.h()                 #mininmininmini
obj.f()                   #FFFFFFFFFFFF
                          #mininmininmini

多继承

对于面向对象的继承来说，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法。

Python的类可以继承多个类，Java和C#中则只能继承一个类

Python的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先和广度优先

　　当类是经典类时，多继承情况下，会按照深度优先方式查找

　　当类是新式类时，多继承情况下，会按照广度优先方式查找

经典类和新式类，从字面上可以看出一个老一个新，新的必然包含了跟多的功能，也是之后推荐的写法，从写法上区分的话，如果 当前类或者父类继承了object类，那么该类便是新式类，否则便是经典类。

class D:

    def bar(self):
        print ‘D.bar‘

class C(D):

    def bar(self):
        print ‘C.bar‘

class B(D):

    def bar(self):
        print ‘B.bar‘

class A(B, C):

    def bar(self):
        print ‘A.bar‘

a = A()
# 执行bar方法时
# 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错
# 所以，查找顺序：A --> B --> D --> C
# 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
a.bar()

经典类多继承

class D(object):

    def bar(self):
        print ‘D.bar‘

class C(D):

    def bar(self):
        print ‘C.bar‘

class B(D):

    def bar(self):
        print ‘B.bar‘

class A(B, C):

    def bar(self):
        print ‘A.bar‘

a = A()
# 执行bar方法时
# 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错
# 所以，查找顺序：A --> B --> C --> D
# 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
a.bar()

新式类多继承

三 、多态

　　Pyhon不支持Java和C#这一类强类型语言中多态的写法，python中是原生多态　　

# Java
string v = ‘alex‘

def func(string arg):
print(arg)

func(‘alex‘)
func(123)                      #会报错

# Python
v = ‘alex‘

def func(arg):
print(arg)

func(1)
func(‘alex‘)

面向对象---适用场景

　　如果多个函数中有一些相同参数时，转换成面向对象

 class DataBaseHelper:

        def __init__(self, ip, port, username, pwd):
            self.ip = ip
            self.port = port
            self.username = username
            self.pwd = pwd

        def add(self,content):
            # 利用self中封装的用户名、密码等   链接数据
            print(‘content‘)
            # 关闭数据链接

        def delete(self,content):
            # 利用self中封装的用户名、密码等   链接数据
            print(‘content‘)
            # 关闭数据链接

        def update(self,content):
            # 利用self中封装的用户名、密码等   链接数据
            print(‘content‘)
            # 关闭数据链接

        def get(self,content):
            # 利用self中封装的用户名、密码等   链接数据
            print(‘content‘)
            # 关闭数据链接

s1 = DataBaseHelper(‘1.1.1.1‘,3306, ‘alex‘, ‘sb‘)

场景--访问数据库

　　函数式编程 和 面向对象 使用情景

　　　　对于 C# 和 Java 程序员来说不存在这个问题，因为该两门语言只支持面向对象编程（不支持函数式编程）。而对于 Python 和 PHP 等语言却同时支持两种编程方式，且函数式编程能完成的操作，面向对象都可以实现；而面向对象的能完成的操作，函数式编程不行（函数式编程无法实现面向对象的封装功能）。所以，一般在Python开发中，全部使用面向对象 或 面向对象和函数式混合使用

　　类和对象在内存中保存状况

　　　类以及类中的方法在内存中只有一份，而根据类创建的每一个对象都在内存中需要存一份

类成员

　　　一、字段

　　　　　　1.普通字段

　　　　　　2.静态字段

　　　二、方法

　　　　　　1.普通方法

　　　　　　2.静态方法

　　　　　　3.类方法

　　　三、属性（特性）

一、字段　　

　　普通字段属于对象

　　静态字段属于类　

class provice:
    country = "中国" #静态字段
    def __init__(self,name):
        self.name = name     #普通字段
        #self.country = "中国"
print(provice.country)         #中国
shanxi = provice("陕西")
a = shanxi.name
print(a)                      #陕西

时间： 2024-10-27 20:54:08

python 学习笔记9（面向对象）的相关文章

python学习笔记12-python面向对象

python学习笔记12-python面向对象 python一切皆对象 一.基本概念 1.面向对象和面向过程 面向对象编程:C++,Java,Python 面向过程编程:函数式编程,C程序等 2.类和对象 类:是对事物的抽象,比如:人类,球类 对象:是类的一个实例,比如:足球,篮球,对象就是对类的实例化 属性:五官,眼,鼻子,理解为一个变量,静态属性 方法:对人来说,吃穿住行,理解为一个函数,动态方法 实例说明:球类可以对球的特征和行为进行抽象,然后可以实例化一个真实的球实体出来 3.为什么要使

Python学习笔记八 面向对象高级编程（二）元类

参考教程:廖雪峰官网https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000 在廖老师的学习网站里"使用元类"这部分还是把我给看晕了...网上搜到一篇感觉讲的相对易懂一些,贴出链接:两句话掌握 Python 最难知识点--元类--以此文作为这篇笔记的源本. "道生一,一生二,二生三,三生万物" 1.在Python世界中,"type"即为道

python学习笔记之面向对象编程特性(二)

面向对象程序设计中的术语对象(Object)基本上可以看做数据(特性)以及由一系列可以存取.操作这些数据的方法所组成的集合.传统意义上的"程序=数据结构+算法"被封装"掩盖"并简化为"程序=对象+消息".对象是类的实例,类的抽象则需要经过封装.封装可以让调用者不用关心对象是如何构建的而直接进行使用. 首先说明一下python编程规范: #!/usr/bin/env python #coding=utf-8 #编程规范,示例如下:   class 

python 学习笔记7 面向对象编程

一.概述 面向过程:根据业务逻辑从上到下写垒代码 函数式:将某功能代码封装到函数中,日后便无需重复编写,仅调用函数即可 面向对象:对函数进行分类和封装,让开发"更快更好更强..." 二.创建类和对象 面向对象编程是一种编程方式,此编程方式的落地需要使用 "类" 和 "对象" 来实现,所以,面向对象编程其实就是对 "类" 和 "对象" 的使用. 类就是一个模板,模板里可以包含多个函数,函数里实现一些功能 对象

python学习笔记之面向对象、类以及I/O操作

一.I/O 操作: open(name[,mode]) 等价于file(name[,mode]) 模式说明: r 打开只读文件,该文件必须存在. r+ 打开可读写的文件,该文件必须存在. w 打开只写文件,若文件存在则文件长度清为0,即该文件内容会消失.若文件不存在则建立该文件. w+ 打开可读写文件,若文件存在则文件长度清为零,即该文件内容会消失.若文件不存在则建立该文件. a 以附加的方式打开只写文件.若文件不存在,则会建立该文件,如果文件存在,写入的数据会被加到文件尾,即文件原先的内容会被

python学习笔记(七):面向对象编程、类

一.面向对象编程 面向对象--Object Oriented Programming,简称oop,是一种程序设计思想.在说面向对象之前,先说一下什么是编程范式,编程范式你按照什么方式来去编程,去实现一个功能.举个例子,你要做饭,可以用电磁炉,也可以用煤气灶.不同的编程范式本质上代表对各种类型的任务采取的不同的解决问题的思路,两种最重要的编程范式分别是面向过程编程和面向对象编程. 提到面向对象,就不得不提到另一种编程思想,面向过程:什么是面向过程呢,面向过程的思想是把一个项目.一件事情按照一定的顺

python学习笔记(6)--面向对象学习

本节内容: 面向对象编程介绍 为什么要用面向对象进行开发? 面向对象的特性:封装.继承.多态 类.方法. 引言 你现在是一家游戏公司的开发人员,现在需要你开发一款叫做(人狗大战)的游戏,你就思考啊,人狗作战,那么至少需要两个角色,一个是人,一个是狗,且人和狗都有不同的技能,比如人拿棍子打狗,狗可以进行咬人等等,怎么描述这种不同角色和他们各自的功能呢? 你搜罗了自己掌握的所有技能,写下了下面的代码来描述这两个角色 1 def person(name,age,sex,job): 2 data = {

Python学习笔记八 面向对象高级编程（一）

参考教程:廖雪峰官网https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000 一.使用__slots__ 正常情况下,当定义了一个类之后,我们可以给这个类的实例绑定任何属性,这就是动态语言的优势: class Student(object): def __init__(self,name,age): self.name=name self.age=age bob=Student('Bob

python学习笔记(七) - 面向对象高级编程

一. 为类动态添加属性和方法: 1. 动态给一个实例添加属性和方法: 给一个实例绑定的方法,对另一个实例是不起作用的. class Student(object): pass s = Student() s.name = 'Michael' # 动态给实例绑定一个属性 print s.name def set_age(self, age): # 定义一个函数作为实例方法 self.age = age from types import MethodType s.set_age = MethodT

Python学习笔记捌——面向对象高级编程

__slots__特殊变量的使用: 由于Python是动态语言,允许先编写类,然后在创建实例的时候添加属性或者方法:而__slots__特殊变量就是,限制往类里添加属性的: 在创建类的时候,使用__slots__ =('name','age'),就是在创建实例时候,只允许添加绑定name和age两个属性:注意!__slots__只对当前类有效,不会作用于子类: @property装饰器:为了实现数据的封装,不把属性暴露在外面,所以如果想访问实例内部属性的话,就需要使用get和set方法,但是这样