Python 面向对象相关

1. 类基本定义

  • 默认构造器为只有一个self参数,内容只有一行pass。
  • 方法: 
    • 实例方法:以实例本身self作为第一个参数。
    • 类方法:以类对象本身cls作为第一个参数,以@classmethod修饰。
    • 静态方法:参数无要求,以@staticmethod修饰。
  • 变量: 
    • 实例变量:以self.开头的变量。
    • 类变量:在类定义后、方法外定义的变量。
    • 变量的引用: 
      • 类变量:

        • self.__class__.class_field_name:这种方法肯定成功。
        • self.class_field_name:如果成员变量中没有与类变量同名的变量,则该方法也可以调用类变量。
        • class_name.class_field_name:通过类名直接引用。
      • 成员变量:self.instant_field_name

class Foo:
    # 定义类变量
    class_field = "class field"
    field = "class normal field"

    def __init__(self, x, y=1):
        # 构造器定义,默认构造器为无参数,内容只有一行pass
        # 可以设置参数,如上,则x必填,y选填
        # 只能有一个构造器
        print("Foo constructor", x, y)

        # 定义成员变量
        self.x = x
        self.field = "instant normal field"

    def instant_function(self, field="method field"):
        print("实例方法")
        print(self.class_field)
        print(self.__class__.class_field)

        # 对于同名变量的处理
        print(field)
        print(self.field)
        print(self.__class__.field)
        print(Foo.field)

    @classmethod
    def class_function(cls):
        print("类方法")

    @staticmethod
    def static_function():
        print("静态方法")

foo = Foo(1)
foo.instant_function()

# 输出
# Foo constructor 1 1
# 实例方法
# class field
# class field
# method field
# instant normal field
# class normal field
# class normal field
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48

2. 超类相关

  • 若子类不显示定义构造器,则默认调用父类构造器。
  • 子类显示定义了父类方法/构造器后,不管参数列表是否相同,都会覆盖父类方法/父类构造器。 
    • 此处的方法包括实例方法、类方法、静态方法。
  • __mro__
class Father:
    @classmethod
    def class_method(cls, message):
        print(‘Father class method‘, message)

    @staticmethod
    def static_method():
        print(‘Father static method‘)

    def __init__(self):
        print(‘father constructor‘)

    def method1(self, message):
        print(‘Father method1‘, message)

    def method2(self, message):
        print(‘Father method2‘, message)

class Son(Father):
    @classmethod
    def class_method(cls):
        print(‘Son class method‘)

    @staticmethod
    def static_method(message):
        print(‘Son static method‘, message)

    def __init__(self, x, y=2):
        # 就算不调用父类也没关系
        # super方式调用父类构造器
        super(Son, self).__init__()
        print(‘son constructor‘)

    def method1(self):
        # 与父类方法名相同,参数不同
        # 直接覆盖父类方法
        print(‘Son method1‘)

    def method2(self, message):
        # 与父类方法名相同,参数相同
        # 覆盖父类方法

        # 调用父类方法
        # super方式调用父类方法
        super(Son, self).method2(message)
        print(‘Son method2‘)

son = Son(1)
son.class_method()
son.static_method("son")

# 输出
# father constructor
# son constructor
# Son class method
# Son static method son
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57

3. 访问控制

  • 以双下划线__开头的变量/方法,就是私有变量/方法。
  • 私有方法不能直接以__field_name__method_name进行访问,但可以通过_class_name__field_name_class_name__method_name访问。
  • Python中没有绝对的私有。
  • 单下划线:虽然不是私有的,但应被看作私有。如果有单下划线函数_method(),则: 
    1. 在别的模块使用from somemodule import _method导入方法成功。
    2. 在别的模块使用from somemodule import *则不会导入_method方法。
class Foo:
    __class_field_name = ‘private class field name‘

    def __init__(self):
        __instant_field_name = ‘private instant field name‘

    def __private_method(self):
        print(‘private method‘)

foo = Foo()
print(foo._Foo__class_field_name) #
foo._Foo__private_method()
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

4. 鸭子类型(Duck Typing)

  • 定义:动态类型的一种风格。在这种风格中,一个对象有效的语义,不是由继承自特定的类或实现特定的接口,而是由当前方法和属性的集合决定。这个概念的名字来源于由James Whitcomb Riley提出的鸭子测试,“鸭子测试”可以这样表述:“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子,那么这只鸟就可以被称为鸭子。”

5. 对象信息

  • type方法:获取对象类型。
  • isinstance方法:判断的对象类型(包括继承)
  • dir方法:获取对象所有属性和方法。(结果为list
  • 有意向的朋友可以加扣扣群813622576一起交流学习,群内有免费资料给大家

原文地址:https://www.cnblogs.com/zxcv1234/p/9397677.html

时间: 2024-10-18 21:22:29

Python 面向对象相关的相关文章

python——面向对象相关

其他相关 一.isinstance(obj, cls) 检查是否obj是否是类 cls 的对象 1 2 3 4 5 6 class Foo(object):     pass obj = Foo() isinstance(obj, Foo) 二.issubclass(sub, super) 检查sub类是否是 super 类的派生类 1 2 3 4 5 6 7 class Foo(object):     pass class Bar(Foo):     pass issubclass(Bar,

Python 面向对象class(2)

Python 面向对象 Python从设计之初就已经是一门面向对象的语言,正因为如此,在Python中创建一个类和对象是很容易的.本章节我们将详细介绍Python的面向对象编程. 如果你以前没有接触过面向对象的编程语言,那你可能需要先了解一些面向对象语言的一些基本特征,在头脑里头形成一个基本的面向对象的概念,这样有助于你更容易的学习Python的面向对象编程. 接下来我们先来简单的了解下面向对象的一些基本特征. 面向对象技术简介 类(Class): 用来描述具有相同的属性和方法的对象的集合.它定

python面向对象进阶

isinstance(obj,cls)检查是否obj是否是类 cls 的对象. isinstance(obj,cls)检查是否obj是否是类 cls 的对象. 反射 python面向对象中的反射:通过字符串的形式操作对象相关的属性.python中的一切事物都是对象(都可以使用反射) 四个可以实现自省的函数(参数是对象,字符串格式的属性名) hasattr getattr setattr delattr __del__,就是析构方法,当对象在内存中被释放时,自动触发执行. 注:此方法一般无须定义,

Python面向对象-day07

写在前面 上课第七天,打卡: 时间的高效利用: 前言: 今天egon老师补充了下 is 和 == 的区别,整理如下:Python中变量的属性以及判断方法 一.面向过程和面向对象 - 1.面向过程 核心是过程,过程就是解决问题的步骤:流水线.机械式: 优点:复杂的问题简单化,分成多个功能单元: 缺点:可扩展性差 应用:Linux内核.httpd.git - 2.面向对象 核心是对象: 要理解对象,应该把自己当做上帝,在上帝眼里一切存在的事物都是对象,不存在的也可以创建出来: 对象是 特征(变量)和

Python面向对象编程-封装

1引言 你点击了桌面上的Chrome图标,一个浏览器窗口出现了,输入网址就可以在Internet世界愉快玩耍.这一切是怎么实现的呢?Chromium这个多进程的程序是如何启动各个进程的呢?浏览器主进程(界面进程)启动了哪些线程?如何启动的呢?这些问题一直萦绕在心头,一起来看看源代码吧.本文主要针对Chromium for Mac的源代码,其它操作系统大同小异. 2背景知识 浏览器作为一个应用程序,是以进程的形式运行在操作系统上的.首先,Chromium是一个多进程的应用程序,我们需要了解Chro

Python 面向对象-------补充

Python 面向对象 Python从设计之初就已经是一门面向对象的语言,正因为如此,在Python中创建一个类和对象是很容易的.本章节我们将详细介绍Python的面向对象编程. 如果你以前没有接触过面向对象的编程语言,那你可能需要先了解一些面向对象语言的一些基本特征,在头脑里头形成一个基本的面向对象的概念,这样有助于你更容易的学习Python的面向对象编程. 接下来我们先来简单的了解下面向对象的一些基本特征. 面向对象技术简介 类(Class): 用来描述具有相同的属性和方法的对象的集合.它定

Python面向对象之类的成员

Python面向对象的编程过程中,我们为类实例化了对象,并通过对象指针来访问类中对应的资源,那么这些资源大体分为三大部分,分别是字段.方法和属性,我们将这三大块统称为类的成员. 一.字段 字段可以分为静态字段.动态字段,下面通过代码展示类中的两种字段 class MyClass:     # 静态字段,属于类,多个对象共用一个静态字段     leader = "abuve"       def __init__(self):         # 动态字段,属于对象,也可以叫普通的字段

Python 面向对象的补充

isinstance(obj,cls)和issubclass(sub,super) isinstance(obj,cls)检查是否obj是否是类 cls 的对象 1 class Foo(object): 2 pass 3 4 obj = Foo() 5 6 isinstance(obj, Foo) issubclass(sub, super)检查sub类是否是 super 类的派生类 1 class Foo(object): 2 pass 3 4 class Bar(Foo): 5 pass 6

python面向对象编程 -- 基本概念(python3.5)

面向对象的编程简要概括就是将要处理的问题抽象为数据和操作的集合,用类对其进行封装.其中数据和操作都称为类的属性,它们是一般是不变的. 对类进行实例化生成我们所说的对象,对象有自己的属性.对象的属性一般是个性化的,不同的对象可能具有不同的属性.同一个类的所有对象都共享类的属性. 对象属性的查找顺序为:对象自身 --> 类 --> 类的祖先类 在python中一切皆对象. 以下我们讨论python中类相关的概念和语法. 1.类的定义 class ClassName: <statement-1