OOP基础 OOP进阶

最新推荐文章于 2022-03-19 20:09:26 发布
最新推荐文章于 2022-03-19 20:09:26 发布
阅读量466 收藏 1
点赞数 1
分类专栏： python Linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43395428/article/details/105560628
版权
Linux 同时被 2 个专栏收录
23 篇文章 1 订阅
订阅专栏
python
19 篇文章 2 订阅
订阅专栏
OOP基础
OOP简介
基本概念
创建类
创建实例
绑定方法
构造器方法
其他绑定方法

OOP基础

OOP简介

基本概念

• 类(Class)：用来描述具有相同的属性和方法的对象的 集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。 
• 实例化：创建一个类的实例，类的具体对象。 
• 方法：类中定义的函数。 
• 对象：通过类定义的数据结构实例。对象包括两个数 据成员（类变量和实例变量）和方法。

创建类

• 使用 class 语句来创建一个新类，class 之后为类的名称并以冒号结尾 
• 类名建议使用驼峰形式
class BearToy:
	pass
# 练习
lvbu = {'name': '吕布', 'weapon': '方天画戟', 'sex': '男'}
def walk():
    pass
def attack():
    pass

创建实例

• 类是蓝图，实例是根据蓝图创建出来的具体对象
tidy = BearToy()

绑定方法

构造器方法

• 当实例化类的对象是，构造器方法默认自动调用 
• 实例本身作为第一个参数，传递给self
class BearToy:
	def __init__(self, size, color):
		self.size =	size
		slef.color = color
        
if __name__=='__main__':
    tidy = BearToy('small', 'orange')

其他绑定方法

• 类中定义的方法需要绑定在具体的实例，由实例调用 
• 实例方法需要明确调用
class BearToy:
	def __init__(self, size, color):
		self.size =	size
		self.color = color
        
    def speak(self):
    	print('hahaha')
        
if __name__ ==	'__main__':
    tidy = BearToy('small',	'orange')
    tidy.speak()
# 练习
• OOP的思想，是将现实世界的物体抽象成一个类class，这个类中有属性和行为，将数据和行为融合到一起。相当于创建了一个蓝图，然后再根据蓝图创建出具体的实例。
class GameCharacter:
    def __init__(self, name, weapon):
        self.name = name
        self.weapon = weapon
    def speak(self, word):
        print('我是%s, %s' % (self.name, word))

>>> lvbu = GameCharacter('吕布', '方天画戟')
>>> lvbu.name
'吕布'
>>> lvbu.weapon
'方天画戟'
>>> lvbu.speak('人在塔在')
我是吕布, 人在塔在
>>> guanyu = GameCharacter('关羽', '青龙偃月刀')
>>> guanyu.name
'关羽'
>>> guanyu.weapon
'青龙偃月刀'
>>> guanyu.speak('呵呵')
我是关羽, 呵呵
# 练习
class GameCharacter:
    def __init__(self, name, weapon):
        self.name = name
        self.weapon = weapon

    def speak(self, word):
        print('我是%s, %s' % (self.name, word))

    def walk(self):
        print('我有%s，我能走' % self.weapon)


if __name__ == '__main__':
    lvbu = GameCharacter('吕布', '方天画戟')
    print(lvbu.name)
    print(lvbu.weapon)
    lvbu.speak('人在塔在')
    lvbu.walk()
    guanyu = GameCharacter('关羽', '青龙偃月刀')
    print(guanyu.name)
    print(guanyu.weapon)
    guanyu.speak('呵呵')
# 练习
class Weapon:
    def __init__(self, wname, strength, type):
        self.name = wname
        self.strength = strength
        self.type = type

class GameCharacter:
    def __init__(self, name, weapon):
        self.name = name
        self.weapon = weapon

    def speak(self, word):
        print('我是%s, %s' % (self.name, word))

if __name__ == '__main__':
    ji = Weapon('方天画戟', 100, '物理攻击')
    lvbu = GameCharacter('吕布', ji)
    print(lvbu.weapon.name)
    print(lvbu.weapon.type)
# 练习
class GameCharacter:
    def __init__(self, name, weapon):
        self.name = name
        self.weapon = weapon

    def speak(self, word):
        print('我是%s, %s' % (self.name, word))

class Warrior(GameCharacter):  # 括号中指定父类(基类)
    def attack(self):
        print('近身肉搏')

class Mage(GameCharacter):
    def attack(self):
        print('远程攻击')

if __name__ == '__main__':
    gl = Warrior('盖伦', '大刀')
    tm = Mage('提莫', '蘑菇')
    gl.speak('人在塔在')
    gl.attack()
    tm.speak('我去前面用脸探探路')
    tm.attack()

__init__方法一般用于为实例对象绑定属性。当创建实例的时候，__init__方法自动调用，实例（lvbu）会作为第一个参数传递。self不是关键字，java用this，但是都不是必须的名字，可以随意更换。一旦创建了实例，实例就会自动拥有类中定义的属性和方法（函数）。

self.属性 是绑定到某个实例上的属性，该属性在所有方法中均可见可用。没有绑定到对象上的，只是局部变量。

编写游戏人物

1. 创建游戏角色类
2. 游戏人物角色拥有名字、武器等属性
3. 游戏人物具有攻击和行走的方法
4. 武器通过武器类实现
OOP进阶
组合和派生
什么是组合
组合应用
创建子类
继承
通过继承覆盖方法
多重继承
特殊方法
__init__方法
__str__方法
__call__方法

OOP进阶

组合和派生

什么是组合

• 类被定义后，目标就是要把它当成一个模块来使用，并把这些对象嵌入到你的代码中去 
• 组合就是让不同的类混合并加入到其它类中来增加功能和代码重用性 
• 可以在一个大点的类中创建其它类的实例，实现一些其它属性和方法来增强对原来的类对象
• 当两个类完全不同，其中一个类是另一个类的组件时，使用组合

组合应用

• 两个类明显不同 
• 一个类是另一个类的组件
class Manufacture:
	def __init__ (self, phone, email):
        self.phone = phone
        self.email = email

创建子类

• 当类之间有显著的不同，并且较小的类是较大的类所 需要的组件时组合表现得很好；但当设计“相同的类但有一些不同的功能”时，派生就是一个更加合理的选择了 
• OOP 的更强大方面之一是能够使用一个已经定义好的类，扩展它或者对其进行修改，而不会影响系统中使用现存类的其它代码片段 
• OOD（面向对象设计）允许类特征在子孙类或子类中进行继承

创建子类（续1）

• 创建子类只需要在圆括号中写明从哪个父类继承即可
class BearToy:
def __init__ (self, size, color):
    self.size =	size
    self.color = color

继承

• 继承描述了基类的属性如何“遗传”给派生类 
• 子类可以继承它的基类的任何属性，不管是数据属性还是方法
class BearToy:
def __init__ (self, size, color):
    self.size =	size
    self.color = color
    
class NewBearToy(BearToy):
	pass
if __name__	== '__main__':
    tidy = NewBearToy('small', 'orange')
    tidy.speak()
• 当两个类有很多相似之处，只有一部分不同，使用继承。

• 子类可以有多个父类。当多个类有同名方法的时候，查找的顺序是自下向上，自左向右。

通过继承覆盖方法

• 如果子类中有和父类同名的方法，父类方法将被覆盖 
• 如果需要访问父类的方法，则要调用一个未绑定的父类方法，明确给出子类的实例
class BearToy:
    def __init__ (self, size, color, phone,	email):
        self.size =	size
        self.color = color
        self.vendor = Manufacture(phone, email)
        
class NewBearToy(BearToy):
def __init__ (self,	size, color, phone,	email, date):
    super(NewBearToy, self).__init__(size, color,phone, email)
    self.date =	date

多重继承

• python允许多重继承，即一个类可以是多个父类的 子类，子类可以拥有所有父类的属性
>>>	class A:
    def foo(self):
    	print('foo	method’)
>>>	class B:
    def bar(self):
    	print('bar method’)
>>>	class C(A, B):
	pass
>>>	c =	C()
>>>	c.foo()
foo	method
>>>	c.bar()
bar	method

特殊方法

__ init __方法

• 实例化类实例时默认会调用的方法
class BearToy:
    __init__(self, size, color):
        self.size =	size
        slef.color = color
        
if __name__	== '__main__':
	tidy = BearToy('small', 'orange')

__ str __方法

• 打印/显示实例时调用方法 
• 返回字符串
class BearToy:
    def	__init__(self, size, color):
        self.size =	size
        slef.color = color
        
    def __str__(self):
    	return '<Bear: %s %s>' % (self.size, self.color)
    
if __name__	== '__main__':
    tidy = BearToy('small',	'orange')
    print(tidy)

__ call __方法

• 用于创建可调用的实例
class BearToy:
    def __init__(self, size, color):
        self.size =	size
        slef.color = color

    def __call__(self):
        print('I am a %s bear' % self.size)
    
if __name__ == '__main__':
    tidy = BearToy('small',	'orange')
    print(tidy)

出版商程序

1. 为出版商编写一个Book类
2. Book类有书名、作者、页数等属性
3. 打印实例时，输出书名
4. 调用实例时，显示该书由哪个作者编写
re模块
正则表达式
匹配单个字符
匹配一组字符
其他元字符
核心函数和方法
match函数
search函数
group方法
findall函数
finditer函数
compile函数
split方法
sub方法

re模块

正则表达式

例：为mac地址加冒号

​ 1.定位到mac地址

​ 2.每2个mac地址分一组

​ 3.在组之间加冒号

192.168.1.1     00525412A3B4
192.168.1.2     000C29123456

:%s/\(..\)\(..\)\(..\)\(..\)\(..\)\(..\)$/\1:\2:\3:\4:\5:\6/

匹配单个字符

记号说 明
.匹配任意字符（换行符除外）
[…x-y…]匹配字符组里的任意字符
[^…x-y…]匹配不在字符组里的任意字符
\d匹配任意数字，与[0-9]同义
\w匹配任意数字字母字符，与[0-9a-zA-Z_]同义
\s匹配空白字符，与[ \r\v\f\t\n]同义

匹配一组字符

记号说 明
literal匹配字符串的值
re1|re2匹配正则表达式re1或re2
*匹配前面出现的正则表达式零次或多次
+匹配前面出现的正则表达式一次或多次
?匹配前面出现的正则表达式零次或一次
{M, N}匹配前面出现的正则表达式至少M次最多N次

其他元字符

记号说 明
^匹配字符串的开始
$匹配字符串的结尾
\b匹配单词的边界
()对正则表达式分组
\nn匹配已保存的子组

核心函数和方法

match函数

• 尝试用正则表达式模式从字符串的开头匹配，如果匹配成功，则返回一个匹配对象；否则返回None
>>>	import re
>>>	m = re.match('foo', 'food')	 #成功匹配
>>>	print(m)
<_sre.SRE_Match object;	span=(0, 3), match='foo'>
>>>	
>>>	m =	re.match(‘foo’,	‘seafood’) #未能匹配
>>>	print(m)
None
# 练习
>>> import re
# 在进行匹配的时候，如果匹配到了，返回匹配对象，否则返回None
>>> re.match('f..', 'food')
<_sre.SRE_Match object; span=(0, 3), match='foo'>
>>> re.match('f..', 'seafood')
>>> print(re.match('f..', 'seafood'))
None

search函数

• 在字符串中查找正则表达式模式的第一次出现，如果匹配成功，则返回一个匹配对象；否则返回None
>>>	import re
>>>	m =	re.search('foo', 'food')
>>>	print(m)
<_sre.SRE_Match object;	span=(0, 3), match='foo'> >>>	
>>>	m =	re.search(‘foo’, ‘seafood’) #可以匹配在字符中间的模式
>>>	print(m)
<_sre.SRE_Match object;	span=(3, 6), match='foo'>
# 练习
>>> re.search('f..', 'food')
<_sre.SRE_Match object; span=(0, 3), match='foo'>
>>> re.search('f..', 'seafood')
<_sre.SRE_Match object; span=(3, 6), match='foo'>
>>> m = re.search('f..', 'seafood')
>>> m.group()   # 返回匹配到的内容
'foo'

>>> re.search('f..', 'food')
<_sre.SRE_Match object; span=(0, 3), match='foo'>
>>> re.search('f..', 'seafood')
<_sre.SRE_Match object; span=(3, 6), match='foo'>
>>> m = re.search('f..', 'seafood')
>>> m.group()   # 返回匹配到的内容
'foo'

group方法

>>>	import re
>>>	m =	re.match('foo',	'food')
>>>	print(m.group())
foo

>>>	m =	re.search('foo', 'seafood')
>>>	m.group()
'foo'

findall函数

• 在字符串中查找正则表达式模式的所有（非重复）出现；返回一个匹配对象的列表
>>>	import re
>>>	m =	re.search('foo', 'seafood is food')
>>>	print(m.group()) #search只匹配模式的第一次出现
foo
>>>	
>>>	m =	re.findall(‘foo’, ‘seafood is food’) #获得全部的匹配项
>>>	print(m)
['foo',	'foo']

finditer函数

• 和findall()函数有相同的功能，但返回的不是列表而是迭代器；对于每个匹配，该迭代器返回一个匹配对象
>>>	import re
>>>	m =	re.finditer('foo', 'seafood	is food')
>>>	for	item in m:
...	print(item.group())
...	
foo
foo
# 练习
>>> list(re.finditer('f..', 'seafood is food'))
[<_sre.SRE_Match object; span=(3, 6), match='foo'>, <_sre.SRE_Match object; span=(11, 14), match='foo'>]
>>> for m in re.finditer('f..', 'seafood is food'):
...     print(m.group())
... 
foo
foo

split方法

• 根据正则表达式中的分隔符把字符分割为一个列表，并返回成功匹配的列表 
• 字符串也有类似的方法，但是正则表达式更加灵活
>>>	import re #使用 . 和 - 作为字符串的分隔符
>>>	mylist = re.split('\.|-', 'hello-world.data')
>>>	print(mylist)
['hello', 'world', 'data']
# 练习
>>> re.split('-|\.', 'hello-world.tar.gz')
['hello', 'world', 'tar', 'gz']

sub方法

• 把字符串中所有匹配正则表达式的地方替换成新的字符串
>>>	import re
>>>	m =	re.sub('X',	'Mr. Smith', 'attn:	X\nDear X')
>>>	print(m)
attn: Mr. Smith
Dear Mr. Smith
# 练习
>>> re.sub('X', 'tom', 'Hi X. Nice to meet you X.')
'Hi tom. Nice to meet you tom.'

compile函数

• 对正则表达式模式进行编译，返回一个正则表达式对象
• 不是必须要用这种方式，但是在大量匹配的情况下，可以提升效率
>>>	import re
>>>	patt = re.compile('foo')
>>>	m = patt.match('food')
>>>	print(m.group())
foo
# 练习
# 当有大量内容需要匹配的时候，先把正则表达式的模式编译一下，将会有更好的执行效率
>>> patt = re.compile('f..')
>>> patt.search('seafood')
<_sre.SRE_Match object; span=(3, 6), match='foo'>
>>> patt.findall('seafood is food')
['foo', 'foo']

分析apache访问日志

• 编写一个apche日志分析脚本
    1. 统计每个客户端访问apache服务器的次数
    2. 将统计信息通过字典的方式显示出来
    3. 分别统计客户端是Firefox和MSIE的访问次数
    4. 分别使用函数式编程和面向对象编程的方式实现

def coun_patt(fname, patt):


if __name__ == '__main__':
    fname = 'access_log'
    ip = '^(\d+\.){3}\d+'  # 192.168.199.23, 12345.67890.1.132234354
    br = 'Firefox|MSIE|Chrome'
    print(coun_patt(fname, ip))
    print(coun_patt(fname, br))

Counter对象

>>> from collections import Counter
>>> c = Counter()
>>> c.update('1.1.1.1')
>>> c
Counter({'1': 4, '.': 3})
>>> c1 = Counter()
>>> c1.update(['1.1.1.1'])
>>> c1
Counter({'1.1.1.1': 1})
>>> c1.update(['1.1.1.1'])
>>> c1.update(['1.1.1.1'])
>>> c1.update(['1.1.1.1'])
>>> c1.update(['1.1.1.2'])
>>> c1.update(['1.1.1.2'])
>>> c1.update(['1.1.1.2'])
>>> c1.update(['1.1.1.3'])
>>> c1.update(['1.1.1.3'])
>>> c1
Counter({'1.1.1.1': 4, '1.1.1.2': 3, '1.1.1.3': 2})
>>> c1.most_common(2)
[('1.1.1.1', 4), ('1.1.1.2', 3)]

import re
from collections import Counter

def count_patt(fname, patt):
    cpatt = re.compile(patt)  # 先编译模式
    c = Counter()  # 用于保存结果

    # 打开文件，从每一行中匹配，将匹配结果更新到c中
    with open(fname) as fobj:
        for line in fobj:
            m = cpatt.search(line)
            if m:  # 如果匹配到内容，才是真；None是False
                c.update([m.group()])

    return c

if __name__ == '__main__':
    fname = 'access_log'
    ip = '^(\d+\.){3}\d+'  # 192.168.199.23, 12345.67890.1.132234354
    br = 'Firefox|MSIE|Chrome'
    ips = count_patt(fname, ip)
    print(ips)
    print(ips.most_common(5))
    print(count_patt(fname, br))

2

import re
from collections import Counter

class CountPatt:
    def __init__(self, fname):
        self.fname = fname

    def count_patt(self, patt):
        cpatt = re.compile(patt)  # 先编译模式
        c = Counter()  # 用于保存结果

        # 打开文件，从每一行中匹配，将匹配结果更新到c中
        with open(self.fname) as fobj:
            for line in fobj:
                m = cpatt.search(line)
                if m:  # 如果匹配到内容，才是真；None是False
                    c.update([m.group()])

        return c

if __name__ == '__main__':
    ip = '^(\d+\.){3}\d+'  # 192.168.199.123, 12345.67890.1.132234354
    cp = CountPatt('access_log')
    result = cp.count_patt(ip)
    print(result)
    print(result.most_common(5))

    cp2 = CountPatt('/etc/passwd')
    shell = 'bash$|nologin$'
    print(cp2.count_patt(shell))
Blank memory
关注
专栏目录
java初级oop基础
06-01
本资源适合java初学者，针对于基础的面向对象oop
OOP-基础知识(c#)
dhrsacoi102577的博客
11-15 106
面向对象基础 一、类的定义 访问修饰符 class 类名{ 类成员列表 } 访问修饰符：public和package（默认） package表示一个包中可以访问，是java默认的访问修饰符，package不能写出来。 类名：首字母必须大写 类成员列表： 静态特性：属性 动态特性：方法 属性：访问修饰符数据类型 属性名称 [=默认值]; eg:public ...
oop 基础
Esc80的专栏
06-06 667
1、const用于类成员变量定义,一旦定义且不能改变其值,如果定义的常量由多个单词组成，使用  _  连接，这是约定。define定义全局常量，在任何地方都可以访问。 2、define不能在类中定义而const可以。 3.、const采用一个普通的常量名称，define可以采用表达式作为名称。 4、const只能接受静态的标量，而define可以采用任何表达式。 5、con
面向对象和接口
wj1055035867的博客
09-14 213
今天讲了抽象和接口的用法 抽象:  1,抽象类里面可以有抽象方法,也可以没有抽象方法  2,如果一个类里面有抽象方法,那么这个类必然是抽象类  3,抽象类不能实例化,不能创建对象 接口  1,属性是常量,方法都没有实现  2,不能创建实例  3,内部方法只能用用public修饰  4,接口可以继承多个接口,类实现接口也可以实现多个接口,弥补了类单根继承的缺陷  
oop基础点
weixin_44241821的博客
01-16 178
接口： 用interface来定义， 例如： public interface inface {void fun();} 可以被类多重实现，接口的方法要被类全部实现. 抽象类和抽象方法: 用abstract来定义 例如：public/protected abstact cla { public/protected abstract void fun1(); vod fun2() { //实现的方...
进阶OOP
02-21
进阶OOP不仅仅是掌握类、对象、封装、继承和多态等基础概念，更涉及到设计模式、接口、抽象类、访问修饰符、异常处理、泛型以及并发处理等多个高级主题。下面我们将详细探讨这些知识点。 1. **设计模式**：设计模式...
工业自动化 TwinCAT3 OOP编程进阶例程
02-07
《工业自动化 TwinCAT3 OOP编程进阶例程》是一个深入探讨TwinCAT3对象导向编程（OOP）技术的应用实例教程。在这个教程中，我们将深入理解如何利用TwinCAT3这一强大的自动化软件进行高效、模块化的编程。TwinCAT3是...
工业自动化 TwinCAT3 OOP编程基本例程（方法，接口，属性，实现）
02-07
本教程将深入探讨TwinCAT3中的面向对象编程（OOP）概念，包括方法、接口、属性以及它们的实现。这将帮助工程师更高效地编写和组织复杂的自动化程序。 首先，我们来看**方法**。在OOP中，方法是对象可以执行的操作。...
2020老杜最新版Java零基础进阶视频教程-面向对象课件
12-10
面向对象编程（OOP）基于类和对象的概念，允许我们通过封装、继承和多态性来组织和管理代码。以下是一些关于Java面向对象的基础知识： 1. **final关键字**： - `final`关键字用于创建不可变的对象，它可以用来修饰...
老王python基础进阶项目
08-07
根据提供的文件信息，“老王python基础进阶项目”是一套旨在帮助学习者深入了解Python编程语言的教程。下面将从以下几个方面来详细解析该教程可能涉及的重要知识点： ### 一、Python语言简介 Python是一种高级、...
OOP基础
kjlsb_1007的博客
08-11 1072
OOP：面向对象编程 Object Oriendted Programming    ：即将一切事物都看作是对象，将其所具有的特征和行为抽象划分为属性和方法然后进行操作。    ：这样的编程思想提高了代码的重用性、灵活性和扩展性。    对象含有属性和方法    ：通常来讲属性和方法被封装在一起 ，共同体现事物的特性。 三大特性： 封装：将对象所持有的属性和方法隐藏，仅对外提供公开的接...
OOP基础——类中基本概念、深/浅复制、静态变量等
Mr.翟的博客
04-22 1678
文章目录 类的使用方法： 定义一个类 声明一个句柄 创建一个对象 对象内存空间的释放 在类中声明另一个类 对类的句柄对象的深复制与浅复制的区别 静态变量的定义与用法 module OOP_BASIC(); class statistic; static int count; //声明静态变量 int id; function new()...
oop(一）基础知识总
yunyun0203的博客
08-01 414
面向对象的概念（OOP） OOP(Object-Oriented Programming,面向对象的编程)技术为编程人员敞开了一扇大门，使其变成的代码更简洁，更易于维护，并且具有更强的可重用性。 OOP达到了软件工程的三个目标：重用性、灵活性、扩展性 OOP面向对象编程的特性：封装、继承、多态 学习PHP面向对象的两个方向：面向对象技术的语法、面向对象的编程思想 面向对象的三个主要特性：
面向对象（OOP）基础
狗窝窝
03-12 247
（1）面向对象特性：封装、继承、多态。 （2）OOP概念 类（class） 对象（object） 字段（field）：描述类的某些性质。 属性（attribute）：通过方法访问和操作字段。 方法（method）：定义类的行为。 （3）类的创建：修饰符 class 类名 {} class Computer{} （4）对象的声明（实例化的
php面向对象的oop,php面向对象编程（oop）基础
weixin_36124631的博客
04-02 164
php面向对象编程(英语：Object-oriented programming，缩写：OOP)，对象是一个由信息及对信息进行处理的描述所组成的整体，是对现实世界的抽象。个人理解，万物皆对象，通过定义类然后为这个类添加属性方法，再将其实例化的过程为面向对象编程，抽象是抽象了点，但是实质上对象无处不在，看个人如何去定义，有这样一句话“佛说：要有光，于是就有了光”，对象也是如此，你可以成为这个佛，但是...
面向对象(oop)基础篇
calorie的博客
07-02 362
面向对象基础 1. 面向对象基础概念 面向过程 是一种看待问题、解决问题的思维方式。着眼点在于问题是如何一步步的解决的，然后亲力亲为的去解决这个问题 面向对象 是一种看待问题、解决问题的思维方式。着眼点在于找到一个能够帮助解决问题的实体，然后委托这个实体去解决问题 把大象装冰箱： 面向过程： 1、打开冰箱门 --> 我 2、把大象装进去 --> 我 3、关上冰箱门 --> ...
oop基础语法
m0_58441715的博客
03-19 131
内置函数： dir 类的简单定义
面向对象OOP基础
Transform
01-02 300
对象和类： 对象是OOP应用程序的组成部件。类是用于实例化对象的类型定义。在.NET中，所有的东西都是对象。对象的生存周期： 对象通过调用它的一个构造函数来实例化。不需要对象时，就执行其析构函数，删除它。静态和实例成员：实例成员只能在类的对象实例上使用，静态成员只能直接通过类定义使用。它与实例不关联。接口：接口是可以在类上实现的公共属性和方法的集合，可以给实例类型的变量赋予其类定
18python_面向对象(OOP)基本概念
weixin_44785193的博客
08-21 99
面向对象(OOP)基本概念 面向对象编程 —— Object Oriented Programming 简写 OOP 目标 了解 面向对象 基本概念 01. 面向对象基本概念 我们之前学习的编程方式就是 面向过程 的 面相过程 和 面相对象，是两种不同的 编程方式 对比 面向过程 的特点，可以更好地了解什么是 面向对象 1.1 过程和函数（科普） 过程 是早期的一个编程概念 过程 类似于函数，只能执行，但是没有返回值 函数 不仅能执行，还可以返回结果 1.2 面相过程 和 面相对象 基本概念 1
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值