Python基础知识点——面向对象

最新推荐文章于 2023-06-23 14:02:43 发布
最新推荐文章于 2023-06-23 14:02:43 发布
阅读量376 收藏 2
点赞数 1
分类专栏： python 文章标签： python 封装 面向对象编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45572139/article/details/106454840
版权

目录

面向对象

简介：
面向对象编程(Object Oriented Programming-OOP) 是一种解决软件复用的设计和编程方法。 这种方法把软件系统中相近相似的操作逻辑和操作 应用数据、状态,以类的型式描述出来,以对象实例的形式在软件系统中复用,以达到提高软件开发效率的作用。
其实面向对象也很简单，却也很难，熟能生巧。你需要了解类和对象，要学会定义类，创建对象。

特点：

  1. 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
  2. 方法：类中定义的函数。
  3. 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
  4. 数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
  5. 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
  6. 局部变量：定义在方法中的变量，只作用于当前实例的类。
  7. 实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
  8. 继承：即一个派生类（derived class）继承基类（base
    class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。
  9. 实例化：创建一个类的实例，类的具体对象。
  10. 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

1. 方法

1.1 静态方法：

  • 定义：使用装饰器@staticmethod。参数随意，没有“self”和“cls”参数，但是方法体中不能使用类或实例的任何属性和方法；
  • 调用：实例对象和类对象都可以调用。
  • 特性: 静态方法只是名义上归类管理，实际上在静态方法里访问不了类或则实例中的任何属性
  • 作用：静态方法可以更好的组织代码，防止代码变大后变得比较混乱。
  • 静态方法使用场景：
    1. 我们要写一个只在类中运行而不在实例中运行的方法.
    2. 经常有一些跟类有关系的功能但在运行时又不需要实例和类参与的情况下需要用到静态方法.
    3. 比如更改环境变量或者修改其他类的属性等能用到静态方法.
    4. 这种情况可以直接用函数解决, 但这样同样会扩散类内部的代码，造成维护困难.
class Dog(object):
    def __init__(self,name):
        self.name = name
    @staticmethod
    def eat():
        print("I am a static method")
d = Dog("ChenRonghua")
d.eat()                     #方法1：使用实例调用

Dog.eat()                   #方法2：使用类直接调用

1.2 类方法：

  • 定义：使用装饰器@classmethod。第一个参数必须是当前类对象，该参数名一般约定为“cls”，通过它来传递类的属性和方法（不能传实例的属性和方法）；
  • 调用：实例对象和类对象都可以调用。
  • 作用：无需实例化直接被类调用
  • 类方法使用场景： 当我们还未创建实例，但是需要调用类中的方法
class Dog(object):
    name = '类变量' #在这里如果不定义类变量仅定义实例变量依然报错
    def __init__(self,name):
        self.name = '实例变量'
        self.name = name
    @classmethod
    def eat(self,food):
        print("%s is eating %s"%(self.name,food))
Dog.eat('baozi')                   #方法1：使用类直接调用
d = Dog("ChenRonghua")          
d.eat("包子")                      #方法2：使用实例d调用

1.3 实例方法：

  • 定义：第一个参数必须是实例对象，该参数名一般约定为“self”，通过它来传递实例的属性和方法（也可以传类的属性和方法）；
  • 调用：只能由实例对象调用。
class Dog(object):
    def __init__(self, name):
        self.name = name

    @property
    def eat(self):
        print(" %s is eating" % self.name)
d = Dog("ChenRonghua")
d.eat()
# 调用会出以下错误， 说NoneType is not callable, 因为eat此时已经变成一个静态属性了， 
# 不是方法了， 想调用已经不需要加()号了，直接d.eat就可以了

1.4 魔法方法:

我们在调用python类中的某个方法时，通常会看到某些特殊的方法，它们总被双下划线所包围，像这种格式：“方法名”，这些方法很强大，充满魔力，可以让你实现很多功能。，如果你的对象实现（重载）了这些方法中的某一个，那么这个方法就会在特殊的情况下被 Python 所调用，你可以定义自己想要的行为，而这一切都是自动发生的。因此了解这类方法的作用及用户很有必要，以下对基本魔法方法做出总结，请看：魔法方法表格

type生成类调用顺序:

new : 先于__init__方法，每生成一个实例执行一次，new 类方法创建实例对象
init : __init__方法每生成一个实例就会执行一次，初始化实例对象
call : 后与__init__方法，C()() 使用类再加一个括号调用， C为类名称
del : 析构方法，删除无用的内存对象（当程序结束会自动自行析构方法）

类实例化时魔法方法调用顺序

class Student(object):
    def __new__(cls, *args, **kwargs):
        print('__new__')
        return object.__new__(cls)   # 必须返回父类的__new__方法，否则不不执行__init__方法，无法创建实例
    
    def __init__(self,name):
        print('__init__')
        self.name = name

    def __str__(self):                # 作用：打印实例时显示指定字符串，而不是内存地址
        print('__str__')
        return self.name

    def __call__(self, *args, **kwargs):        # 当执行C()(*args) 或者 s1(*args) 就会执行__call__
        print('__call__',*args)

    def __del__(self):                # 作用：清除无用的实例对内存的暂用
        print('__del__')

#1、实例化时机会执行__new__、__init__
s1 = Student('tom')

#2、执行 实例()  就会执行__call__ 方法，并将参数传递给__call__函数
s1('call01')

#3、当打印实例时就会执行 __str__ 方法下返回的字符串（默认返回的实例地址）
print(s1)

#4、析构方法：当删除实例时就会调用 __del__ 方法
del s1
# 析构方法作用：在程序结束后会自动执行析构方法删除所有实例
# 但是在程序运行时有很多实例是无用的，但是python内存回收机制却不会自动删除他们，这样就浪费内存
# 我们可以执行 del s1 ，那么在程序运行时，python内存回收机制会检测到这些实例时无用的，才会删除
# 其实我们执行del s1，并没有回收内存，只不过是摘除门牌号，python内存回收机制发现没有门牌号后会自动回收内存

new & __init__详解:

  1. new 至少要有一个参数cls，代表要实例化的类，此参数在实例化时由Python解释器自动 提供
  2. new 必须要有返回值，返回实例化出来的实例，这点在自己实现 new 时要特别注 意，可以return父类 new 出来的实例，或者直接是object的 new 出来的实例
  3. init 有一个参数self，就是这个 new 返回的实例， init 在 \new 的基础上 可以完成一些其它初始化的动作， init 不需要返回值 我们可以将类比作制造商， new 方法就是前期的原材料购买环节，
    init 方法就是在 有原材料的基础上，加工，初始化商品环节。

1.5 单例模式：

__new__方法书写：

class A(object):
	def __init__(self):
	print(self)
	print("这是 init 方法")

	def __new__(cls):
	print(id(cls))
	print("这是 __new__ 方法")
	ret = object.__new__(cls)
	print(res)
	return ret


print(id(A))
-->: 12345678987654321

a = A()
-->: 12345678987654321
这是 new 方法
-->: <__main__.A object at 0x105b96ac8>
-->: <__main__.A object at 0x105b96ac8>

线程安全的单例:

import threading

"""
线程安全的单利模式

紧跟with后面的语句被求值后，返回对象的 __enter__() 方法被调用，这个方法的返回值将被赋值给as后面的变量。
当with后面的代码块全部被执行完之后，将调用前面返回对象的 __exit__()方法
"""
def synchronized(func):
    func.__lock__ = threading.Lock()

    def lock_func(*args, **kwargs):
        with func.__lock__:
            return func(*args, **kwargs)

    return lock_func

class Singleton(object):
    instance = None

    @synchronized
    def __new__(cls):
        # 关键在于这，每一次实例化的时候，我们都只会返回这同一个instance对象
        if not cls.instance:
            cls.instance = super(Singleton, cls).__new__(cls)
        return cls.instance

先看类，可以看出这里我们先定义了一个类属性instance，接着我们重写了父类的__new__方法，这个方法就是我们在实例化一个对象时最先调用的一个方法。和其他静态语言不一样，其他静态语言，直接调用了构造方法，一般情况下初始化的程序也写在构造方法之中。而python实例化一个对象和初始化是分开的。__new__是类方法，__init__是实例方法，也就是说，__init__是在对象已经创建完成之后，才执行。

在python3中，调用父类的方法是用super()来调用。所以我们这里的思路就是，还是用父类的方法去创造，但是我们要加一个判断，就是说，当这个对象也就是类属性并不为空的时候，我们就不在实例化，而是返回一个已经实例化的类属性。

线程不安全的单例

class Singleton(object):
	__instance = None

	def __new__(cls, name, age):
		# 如果类属性__instance的值为None，那么就创建一个对象
		if not cls.__instance:
			cls.__instance = object.__new__(cls)
		# 如果已经有实例存在，直接返回
		return cls.__instance

a = Singleton("Zhangsan", 18)
b = Singleton("lisi", 20)

print(id(a))
print(id(b))

a.age = 30   # 给a指向的对象添加一个属性
print(b.age)  # 获取b指向的对象的age属性

del

Python 通过调用 init() 方法构造当前类的实例化对象，而 del() 方法，功能正好和 init() 相反，其用来销毁实例化对象。

事实上在编写程序时，如果之前创建的类实例化对象后续不再使用，最好在适当位置手动将其销毁，释放其占用的内存空间（整个过程称为垃圾回收（简称GC））。
大多数情况下，Python 开发者不需要手动进行垃圾回收，因为 Python 有自动的垃圾回收机制，能自动将不需要使用的实例对象进行销毁。

无论是手动销毁，还是 Python 自动帮我们销毁，都会调用 del() 方法。

2. 特性

面向对象三大特性: 封装，继承，多态

2.1 封装:

  1. 在类中对数据的赋值、内部调用对外部用户是透明的
  2. 这使类变成了一个胶囊或容器，里面包含着类的数据和方法 作用：
    • 防止数据被随意修改
    • 使外部程序不需要关注对象内部的构造，只需要通过对外提供的接口进行直接访问

继承的种类：

  1. 单继承：一个类继承单个基类
  2. 多继承:一个类继承多个基类
  3. 多级继承：一个类继承自单个基类，后者继承自另一个基类
  4. 分层继承：多个类继承自单个基类
  5. 混合继承：两种或多种类型继承的混合

封装的好处：

  1. 将变化隔离
  2. 便于使用
  3. 提高复用性
  4. 提高安全性

封装：将数据进行封装到对象中，以供其他函数进行调用

2.2 Inheritance 继承（代码重用:

  1. 一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承
  2. 比如CS中的警察和恐怖分子，可以将两个角色的相同点写到一个父类中，然后同时去继承它
  3. 使用经典类： Person.init(self, name, age)
    并重写写父类Person的构造方法，实现，先覆盖，再继承，再重构

继承的优点：

  1. 节省代码,减少代码的重复性
  2. 增强耦合性(也就是增强代码可读性)
  3. 使代码更加规范化
  4. 子类可以调用父类的所有属性
class D:
    def talk(self):
        print('D')

class B(D):
    pass
    # def talk(self):
    #     print('B')

class C(D):
    pass
    def talk(self):
        print('C')

class A(B,C):
    pass
    # def talk(self):
    #     print('A')

a = A()
a.talk()


# 黑人，白人都继承父类Person就可以都有父类的属性和方法了

class Person(object):
    def __init__(self,name,age):  #执行Person.__init__(self,name,age)时就会将传入的参数执行一遍
        self.name = name          #所以在BlackPerson中不仅有name,age而且还有sex
        self.age = age
        self.sex = "normal"
    def talk(self):
        print("person is talking....")

class WhitePerson(Person):
    pass

class BlackPerson(Person):
    def __init__(self,name,age,strength):     #先覆盖，再继承，再重构
        #先覆盖父类的__init__方法，再继承父类__init__，再加自己的参数
        Person.__init__(self,name,age)        #先继承父类Person，这里self就是BlackPerson本身
        #先将name,age传给子类BlackPerson,然后调用Person.__init__构造方法将参数出入父类（）
        self.strength = strength              #然后再重构自己的方法,即写自己的参数
        print(self.name,self.age,self.sex)
        print(self.strength)
    def talk(self):
        print("black balabla")
    def walk(self):
        print("is walking....")

b = BlackPerson("wei er smith",22,"Strong")
b.talk()
b.walk()


# 运行结果：
# wei er smith 22 normal
# Strong
# black balabla
# is walking....
# person is talking....

新式类经典类区别：

Python 2.x中默认都是经典类，只有显式继承了object才是新式类
Python 3.x中默认都是新式类，不必显式的继承object
当类是经典类时，多继承情况下，会按照深度优先方式查找
当类是新式类时，多继承情况下，会按照广度优先方式查找

2.3 Polymorphism 多态（接口重用）

  1. 多态是面向对象的重要特性,简单点说:“一个接口，多种实现”
  2. 指一个基类中派生出了不同的子类，且每个子类在继承同样的方法名的同时又对父类的方法做了不同的实现
  3. 这就是同一种事物表现出的多种形态
  4. 比如黄种人继承了人talk这个功能，但是他说的是中文，而美国人的talk是英文，但是他们是同样的talk

作用：简单的讲就是允许父类调用子类的方法

很多人喜欢将多态与多态性二者混为一谈，然后百思不得其解，其实只要分开看，就会很明朗。

  1. 多态指的是一类事物有多种形态，（一个抽象类有多个子类，因而多态的概念依赖于继承）
  2. 多态性是指具有不同功能的函数可以使用相同的函数名，这样就可以用一个函数名调用不同内容的函数。在面向对象方法中一般是这样表述多态性：向不同的对象发送同一条消息，不同的对象在接收时会产生不同的行为（即方法）。也就是说，每个对象可以用自己的方式去响应共同的消息。所谓消息，就是调用函数，不同的行为就是指不同的实现，即执行不同的函数。
# 多态举例

class Animal:
    def __init__(self, name):    # Constructor of the class
        self.name = name
    def talk(self):              # Abstract method, defined by convention only
        raise NotImplementedError("Subclass must implement abstract method")

class Cat(Animal):
    def talk(self):
        return 'Meow!'

class Dog(Animal):
    def talk(self):
        return 'Woof! Woof!'

animals = [Cat('Missy'),
           Dog('Lassie')]

for animal in animals:
    print(animal.name + ': ' + animal.talk())

# 运行结果：
# Missy: Meow!
# Lassie: Woof! Woof!

Python中多态的特点：

  1. 只关心对象的实例方法是否同名，不关心对象所属的类型；
  2. 对象所属的类之间，继承关系可有可无；
  3. 多态的好处可以增加代码的外部调用灵活度，让代码更加通用，兼容性比较强；
  4. 多态是调用方法的技巧，不会影响到类的内部设计。

3. 属性

  1. 类的公有属性
    public_attrs：能在类的外部被使用或直接访问。在类内部的方法中使用时 public_attrs_attrs，在类的外部class_name.public_attrs。

  2. 类的私有属性
    __private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

  3. 类的(公有)方法
    在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self，且为第一个参数，self 代表的是类的实例。
    self 的名字并不是规定死的，也可以使用 this，但是最好还是按照约定是用 self。

  4. 类的私有方法
    __private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类的外部调用。self.__private_methods。

4. 反射: hasattr、getattr、setattr 和 delattr

在做程序开发中，我们常常会遇到这样的需求：需要执行对象里的某个方法，或需要调用对象中的某个变量，但是由于种种原因我们无法确定这个方法或变量是否存在，这是我们需要用一个特殊的方法或机制要访问和操作这个未知的方法或变量，这中机制就称之为反射。

反射就是通过字符串的形式，导入模块；通过字符串的形式，去模块寻找指定函数，并执行。利用字符串的形式去对象（模块）中操作（查找/获取/删除/添加）成员，一种基于字符串的事件驱动！

四大属性:

  • hasattr(ogj,name_str) 判断一个对象里是否有对应的字符串方法
class Dog(object):
    def eat(self,food):
        print("eat method!!!")
d = Dog()

#hasattr判断对象d是否有eat方法，有返回True，没有返回False
print(hasattr(d,'eat'))     #True
print(hasattr(d,'cat'))     #False
  • getattr(obj,name_str) 根据字符串去获取obj对象里的对应的方法的内存地址
class Dog(object):
    def eat(self):
        print("eat method!!!")
d = Dog()

if hasattr(d,'eat'):          # hasattr判断实例是否有eat方法
    func = getattr(d, 'eat')  # getattr获取实例d的eat方法内存地址
    func()                    # 执行实例d的eat方法
#运行结果：  eat method!!!
  • 使用stattr给类实例对象动态添加一个新的方法
def abc(self):
    print("%s正在交谈"%self.name)

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

p = Person("汇森")
setattr(p,"talk",abc)   # 将abc函数添加到对象中p中，并命名为talk
p.talk(p)               # 调用talk方法，因为这是额外添加的方法，需手动传入对象

# 打印结果 汇森正在交谈

setattr(p,"age",30)     # 添加一个变量age,复制为30
print(p.age)            # 打印结果:30
  • delattr删除对象中的变量。注意：不能用于删除方法
class Person(object):
    def __init__(self,name):
        self.name = name
    def talk(self):
        print("%s正在交谈"%self.name)

p = Person("汇森")

delattr(p,"name")       # 删除name变量
print(p.name)           # 此时将报错
初心ya
关注
专栏目录
100天精通Python丨基础知识篇 —— 04、Python基础知识扫盲（第一个Python程序，13个小知识点）
独木不成林，单弦不成音。
03-26 4万+
Python基础语法包括基本数据类型和变量、基本语句和控制流程、函数和模块以及面向对象编程。掌握Python基础语法可以编写更加复杂的Python程序，实现更加复杂的功能。《100天精通Python专栏 - 快速入门到黑科技》不吃西红柿。
Python教程——面向对象进阶
LONG
04-20 216
在前面的章节我们已经了解了面向对象的入门知识，知道了如何定义类，如何创建对象以及如何给对象发消息。为了能够更好的使用面向对象编程思想进行程序开发，我们还需要对Python中的面向对象编程进行更为深入的了解。 @property装饰器 之前我们讨论过Python中属性和方法访问权限的问题，虽然我们不建议将属性设置为私有的，但是如果直接将属性暴露给外界也是有问题的，比如我们没有办法检查赋给属性的值是否有效。我们之前的建议是将属性命名以单下划线开头，通过这种方式来暗示属性是受保护的，不建议外界直接访问，那么如
python 面向对象知识点
IT_in1314的博客
08-19 1606
一. 类与对象 面向对象的初衷是让开发者可以自己定义数据类型。 其中有两个核心概念： （1）一个是类型(简称类)， （2）另一个是对象（又称实例 ）。 比如整数指代一类数字，它不是具体的哪个数。而数字100是一个具体的数，是一个个体。 类型往往是具有共同特征的一类事物，而对象则是这类型指代那类事物中的一个 个体而已。 抽象概念并不能干活，只能依赖具...
Python面向对象编程知识点
weixin_41524411的博客
05-31 263
上 1-简述self在类中的意义。 不用实例化对象就能够在本类中访问自身的属性或方法。 2-类是由哪三个部分组成的？ 类名，属性，方法 3-构造方法和析构方法的作用 分别用于初始化对象的属性和释放类所占用的资源。 下 1.请简述如何保护类的属性。 （1）把属性定义为私有属性，即在属性名的前面加上两个...
python 面向对象编程知识点
melody96313的博客
04-02 265
教程来源：廖雪峰大神的网站https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/0014318645694388f1f10473d7f416e9291616be8367ab5000 面向对象编程 1、和普通的函数相比，在类中定义的函数只有一点不同，就是第一个参数永远是实例变量sel...
python面向对象编程，知识点总结
bigchen
11-30 332
字符中常见的内置方法 (可以用 dir(str) 来查) 有 capitalize()：大写句首的字母 split()：把句子分成单词 find(x)：找到给定词 x 在句中的索引，找不到返回 -1 replace(x, y)：把句中 x 替代成 y strip(x)：删除句首或句末含 x 的部分 正则表达式示例说明： pattern = re.compile("’[0-9/:\s]+’") 抽象...
python3 面向对象编程知识点介绍
程序猿-Jojo
04-25 748
python3 面向对象编程介绍简阶第1章 面向对象设计第2章 Python 对象第3章 对象相似时第4章 异常捕获第5章 何时使用面向对象编程第6章 Python 数据结构第7章 Python 面向对象的捷径第8章 字符串与序列化第9章 迭代器模式第10章 Python 设计模式I第11章 Python 设计模式II第12章 测试面向对象程序第13章 并发 简阶 这里的内容全部来自《python...
Python基础——面向对象基础（练习）
Alice
09-05 1934
文章目录一、二、 一、 面向对象编程：OOP 面向对象编程的关注点在于谁来做，相比较函数，面向对象是更大的封装，根据职责在一个对象中封装多个方法 二、
python面向对象presentation——PPT（含源码）.rar
12-27
这份“python面向对象presentation——PPT（含源码）”是为学习者提供了一个深入理解面向对象编程的资源，适合学生用于presentation或自我学习。 1. **面向对象编程基础** - 类（Class）：类是创建对象的模板，...
python类与面向对象基础语法全集（csdn）————程序.pdf
12-03
Python 类与面向对象是编程语言中一种重要的抽象和组织数据的方式。面向对象编程（OOP）的核心理念是通过创建对象来模拟现实世界中的实体，使得代码更加模块化、可重用和易于维护。Python 中，一切皆对象，类是创建...
【编程语言】python面向对象知识整理
Interest drives progress
07-07 390
类和对象的关系：⽤类去创建⼀个对象，类是对⼀系列具有相同特征和⾏为的事物的统称，是⼀个抽象的概念，不是真实存在的事物，对象是类创建出来的真实存在的事物 1、理解self 2. 创建对象 语法： 2、添加和获取对象属性类外⾯添加和获取对象属性，语法：类外面获取对象属性，语法：类⾥⾯获取对象属性，语法： 3. 魔法方法 1、 带参数的，作⽤：对不同的对象设置不同的初始化属性 2、 3、 4. 类属性和实例属性 （1）类属性 1、设置和访问类属性 2、修改类属性 （2）实例属性 5. 类方法和静态
python 面向对象知识点概括
玛卡巴卡
02-21 348
目录 1 .面向对象介绍 2 .类 3 .对象 4 .对象的属性 5 .方法 / 魔法方法 6 .继承 内容 : 一 面向对象介绍 为了更容易理解面向对象 , 我们先说面向过程: 面向过程 和 面向对象 都是一种思想 面向过程 : 面向过程是一种以过程(步骤)为中心的编程思想； 面向过程是人类的思考问题的...
Python面向对象基础知识（学习笔记）
qq_45753475的博客
12-17 902
面向对象 两个核心概念 类 和 对象 类是一个模板 对象则是按照这个模板创建出来的实例 类和对象的关系 类是模板，对象是根据类这个模板创建出来的 应该先有类 后有对象 类只有一个，而对象可以有多个 不同对象之间的属性可能会不同 类中定义了什么属性和方法，对象中就有什么属性和方法，不可能多也不可能少 要设计一个类通常要满足 类名：大驼峰命名法 首字母大写 属性：这类事物具有什么样的特征 方法：这类事物具有什么样的行为 属性和方法的确定 对象的特征描述：通常定义为属性 对象具有的行为（动词）：通常定义
【小思考】Python里面有声明和定义分离这一说么？
weixin_30432179的博客
07-10 161
第一部分： 探究这个问题，还是因为编程的时候碰到了这个错误： 提示tcplink没有定义，tcplink是我自己写的一个给监听到的tcp连接请求分配新线程的函数，不过是写在了下面，就像这样： 如果是C++里面的话，解决这个问题很简单。在文件开头的时候，加上该函数的声明式就OK，这样不仅方便，还能最大限度的保持美观（雾）。但是问题来了，Python里面好像没有声明和定义这一说...
python基础----多态与多态性、super函数用法、继承原理
dejiong3425的博客
04-23 183
一、多态与多态性 ㈠多态： 多态指的是一类事物有多种形态，（一个抽象类有多个子类，因而多态的概念依赖于继承） 1. 序列类型有多种形态：字符串，列表，元组。 2. 动物有多种形态：人，狗，猪 1 import abc 2 cla...
Python面向对象详解（非常详细）
热门推荐
ZTLJQ的博客
04-21 2万+
面向对象编程（Object-Oriented Programming，OOP）是一种常用的编程思想，它强调万物皆对象，因此在编程时我们可以将现实世界中的事物抽象成程序中的对象，从而更好实现软件的设计与开发。与传统的基于函数的编程不同，面向对象编程注重于将数据与行为封装在一起，即对象既包含数据状态，还包含可调用的行为方法。面向对象编程的特点在于，它具有封装、继承和多态三大特性。封装意味着将对象的状态和行为进行封装，使其对外只暴露必要的接口，从而提高了安全性和可维护性；
Python基础篇(七)：面向对象的编程思想
最新发布
后端开发
06-23 1567
面向对象编程（Object-Oriented Programming，简称OOP）是一种编程思想，它将数据和操作数据的方法封装在对象中。OOP的核心思想是以对象为中心，通过定义类来创建对象，并通过对象之间的交互来实现程序的功能。类的使用有助于组织和管理代码，并实现更高级的软件设计和开发。在Python中，类的定义使用class关键字，后跟类的名称示例：创建一个名为Person的类，表示人物，包含name和age属性，并具有一个greet方法来打招呼。
python面向对象三大特性_Python 面向对象(创建类和对象，面向对象的三大特性是指：封装、继承和多态，多态性)...
weixin_39860952的博客
11-23 209
概念：面向过程：根据业务逻辑从上到下写垒代码函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可面向对象：对函数进行分类和封装，让开发“更快更好更强...”面向过程编程最易被初学者接受，其往往用一长段代码来实现指定功能，开发过程中最常见的操作就是粘贴复制，即：将之前实现的代码块复制到现需功能处。123456789101112131415161718while True：if cpu...
python快速入门【五】---- 面向对象编程、python类
丨汀、的博客
03-12 1974
目录 Python面向对象编程 什么是面向对象编程（OOP）？ Python中的类 Python对象（实例） 如何在Python中定义类 实例属性 类属性 实例化对象 这是怎么回事？ 练习 实例方法 修改属性 Python对象继承 狗公园示例 扩展父类的功能 父类与子类 覆盖父类的功能 练习: 狗狗继承 练习: 狗狗饿不饿 Python面向对象编程 在本文中，您将学习Python中的OOP的以下基本概念： Python类 对象实例 定义和使用方法 OOP继承
Python编程入门教程——从基础到实践
1. **Python特色**：Python以其简洁、易读的语法而闻名，支持多种编程范式（面向过程、面向对象、函数式），拥有丰富的标准库和强大的社区支持。 2. **安装Python**：Python可以在各种操作系统上安装，包括Linux、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值