欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

面向对象初识

程序员文章站 2022-06-21 16:06:40
一、概念 在面向对象编程中,术语对象大致意味着一系列数据(属性)以及一套访问和操作这些数据的方法。使用面向对象而非全局变量和函数的原因有多个,但是面向对象的好处在于: 1 多态:可以对不同类型的对象执行相同的操作,而这些操作就像“被施了魔法”一样能够正常运行。 2 封装:对外部隐藏有关对象工作原理的 ......

 一、概念

在面向对象编程中,术语对象大致意味着一系列数据(属性)以及一套访问和操作这些数据的方法。使用面向对象而非全局变量和函数的原因有多个,但是面向对象的好处在于:

1 多态:可以对不同类型的对象执行相同的操作,而这些操作就像“被施了魔法”一样能够正常运行。
2 封装:对外部隐藏有关对象工作原理的细节。
3 继承:可通过父类创建出多个派生类。

面向对象编程是最有效的软件编写方法之一。
在面向对象编程中,可以编写表示现实世界中的事物和情景的类,并基于这些类来创建对象。
编写类时,你定义的一大类对象都有的通用行为。基于类创建对象时,每个对象都自动具备这种通用行为,然后可根据需要赋予每个对象独特的个性。
使用面向对象编程可模拟现实情境,其逼真程度达到了令人惊讶的地步。

根据类来创建对象被称为实例化,这能够使用类的实例。可在实例中存储什么信息,定义可对这些实例执行的那些操作。还可以编写一些类来扩展既有类的功能,让相似的类能够高效地共享代码。

理解面向对象编程有助于像程序员那样看世界,还可以帮助你真正的明白自己编写的代码:不仅是各行代码的作用,还有代码背后更宏大的概念。了解类背后的概念可培养逻辑思维,能够同规格编写程序来解决遇到的几乎任何问题。

1 创建和使用类

使用类几乎可以模拟任何东西。下面来编写一个表示小狗的简单类dog----它表示的不是特定的小狗,而是任何小狗。
对于大多数宠物狗,我们都知道些什么呢? 它们都有名字和年龄,我们还知道小狗会蹲下和打滚。由于大多数小狗都具备上述两项相息(名字和年龄)和两种行为(蹲下和打滚),我们的dog类将包含它们,这个类让python知道如何创建表示小狗的对象。编写这个类后,我们将使用它来创建表示特定小狗的实例。

1.1 创建dog类

根据dog类创建的每个实例都将存储名字和年龄。我们赋予了每条小狗蹲下(sit())和打滚(roll_over())的能力:

dog.py

class dog():                        # *1
    """一次模拟小狗的简单尝试"""        # *2
    def __init__(self,name,age):    # *3
        """初始化属性name和age"""
        self.name = name            # *4
        self.age = age
    def sit(self):                  # *5
        """模拟小狗被命令时蹲下"""
        print(self.name.title()+ " is now sitting.")
    def roll_over(self):
        """模拟小狗被命令时打滚"""
        print(self.name.title() + " is rolled over!")

这里需要注意的地方很多,但不用担心,还有大把的机会熟悉它,

1.1.1 基本说明

首先,在*1出,定义了一个名为dog的类。根据约定,python中,首字母大写的名称指的是类。 在*2处编写了一个文档字符对类的功能进行了描述。

1.1.2 初始化方法__init__()

类中的函数成为方法;有关函数的一切都适合于方法,就目前而言,唯一重要的差别就是调用方法的方式。*3处的方法__init__()是一个特殊方法,每当你根据dog类创建新实例时,python都会自动执行它。
在这个方法中,开头和末尾各有两个下划线,这是一种约定,旨在避免python默认方法与普通方法发生名称冲突。

1.1.3 为何定义形参包含self

将方法__init__()定义成了包含三个形参:self,name,age。在这个方法的定义中,形参self必不可少,还必须位于其它形参的前面。
因为python调用这个__init__()方法来创建dog实例时,将自动传入实参self。每个与类相关联的方法调用都自动传递实参self,它是一个指向实例本身的引用,让实例能够访问类中的属性和方法。创建dog类时。python将调用dog类的方法__init__()。将通过实参向dog传递名字和年龄;self会自动传递,因此我们不需要传递它。每当我们根据dog类创建实例时,都只需要给最够两个形参(name和age)提供值。

1.1.4 属性的赋值

*4处定义的两个变量都有前缀self。以self为前缀的变量都可提供类中的所有方法使用,我们还可以通过类的任何实例类访问这些变量。
self.name = name 获取存储在name中的值,并且其存储到变量name 中,然后该变量被关联到当前创建的实例。
self.age = age的作用与此类似。像这样可通过实例访问的变量称为属性。

1.1.5 类的普通方法

dog类还定义了另外两个方法:sit()roll_over(),如*5处所示。
由于这些方法不需要额外的信息,如名字和年龄。因此它们只要一个形参self。换句话说,它们都会蹲下和打滚,当前sit() 和roll_over()所有的有限,它们至少打印一条信息,指出小狗正在蹲下或者打滚。但可以扩展这些方法以模拟实际情况:如果这个类包含在一个计算机游戏中,这些方法将包含创建小狗和打滚的的动画效果的代码。当然也可以加入你想要的功能。

1.2 根据类创建实例

可将类视为有关如何创建实例的说明。dog类时一系列说明,让python知道如何创建表示特定小狗的实例。
说了这么多,下面创建一个表示特定小狗的实例:

dog1 = dog('ahuang',3)                      # *1
print("the dog's name is " + dog1.name.title() + ".")  # *2
print("the dog is " + str(dog1.age) + " year old.")    # *3

这里使用的是前,面编写的dog类,在*1处我们让python创建一个名字为ahuang、年龄为4岁的小狗。
遇到这个代码是,python使用实参“ahuang”和4调用dog类中的方法__init__()。方法__init__()创建一个表示特定小狗的实例,并使用我们提供的值来设置属性name和age。方法__init__()并未显式地包含return语句,但python自动返回一个表示这条小狗的实例,并将这个实例存储在变量dog1中。
在这里命名约定很有用:我们通常认为首字母大写的名称(如dog)指的是类。而小写的名称(如dog1)指的是根据类创建的实例。

1.2.1 属性的访问

要访问实例的属性,可使用句点(.)的方法。如*2处的dog1.name,
.(点)表示法在python中很常用,这种语法演示了python如何获悉属性的值。在这里,python先找到实例dog1。再查找与这个实例相关联的属性name。在dog类中引用这个属性时,使用的是self.name。在*3处我们使用同样的方法来获悉age的值。
以上代码的输出如下:

the dog's name is ahuang.
the dog is 3 year old.

1.2.2 调用方法

根据dog类创建实例后,就可以使用句点表示法来调用dog类中定义的任何方法。
下面让小狗蹲下和打滚

dog1.sit()
dog1.roll_over()

输出如下:

ahuang is now sitting.
ahuang is rolled over!

要调用方法,可指定实例的名称(这里是dog1)和要调用的方法,并用句点分隔它们。遇到代码dog1.site()时,python在类dog中查找方法site()并运行其代码。python以同样的方法解读代码dog1.roll_over()。
这种语法很有用。如果给属性和方法指定了合适的描述性名称,如name、age、sit()和roll_over(),即便是从未见过的代码块,我们也能够轻松地推断出它是做什么的。

1.2.3 创建多个实例

可根据需求创建任意数量的实例。下面再来创建一个dog2的实例:

my_dog = dog("ahua", 3)
your_dog = dog("erha", 2)
print("my dog's name is " + my_dog.name.title() + ".") # *2
print("my dog is " + str(my_dog.age) + " year old.") # *3
my_dog.sit()
print("your dog's name is " + your_dog.name.title() + ".") # *2
print("your dog is " + str(your_dog.age) + " year old.") # *3
your_dog.sit()

在这个实例中,我们创建了两条小狗,它们分别为ahua和erha。每条小狗都是一个独立的实例,有自己一组属性,能够执行相同的操作:

my dog's name is ahua.
my dog is 3 year old.
ahua is now sitting.
your dog's name is erha.
your dog is 2 year old.
erha is now sitting.

就是我们给第二条狗指定同样的名字和年龄,python依然会根据dog类创建另一个实例。可按需求根据一个类创建任意数量的实例,条件是将每个实例都存储在不同的变量中,或者占用列表或字典的不同位置。

二 操作静态变量的两种方式:

先创建一个类
class person:
    '''内容'''
    animal='高级动物'
    soul='有思想'
    #animal,soul为静态变量

    def __init__(self,name,sex,eye,high,weight):  #这是构造方法
        self.name=name  #属性
        self.sex=sex
        self.eye=eye
        self.high=high
        self.weight=weight
        print(666)

    def work(self): #动态变量,动态方法,方法
        print(self)
        print('人会工作')

2.1 类名.__dict__方法 只能查看,不能增删改。

2.1.1 查看全部静态变量

print(person.__dict__)
结果为:{'__module__': '__main__', '__doc__': '内容', 'animal': '高级动物', 'soul': '有思想', '__init__': <function person.__init__ at 0x000002100833a8c8>, 'work': <function person.work at 0x000002100833a950>, '__dict__': <attribute '__dict__' of 'person' objects>, '__weakref__': <attribute '__weakref__' of 'person' objects>}

2.1.2查看单个静态变量

print(person.__dict__['animal'])
结果为:
高级动物

2.2 类名.变量名 可增删改查

2.2.1 查

print(person.animal)
结果为:
高级动物

2.2.2 增加

person.kind='有性格'
print(person.kind)
结果为:
有性格

2.2.3 删

del person.kind

2.2.4修改

person.kind='有个性'
print(person.kind)
结果为:
有个性

三 类操作方法的两种方式

3.1 类名.__dict__方法名

print(person.__dict__['work'](11))
结果为:
11
人会工作
none

3.2 类名.方法名()

person.work(222)
结果为:
222
人会工作

3.3 如果类操作方法:类名.方法名()

只要创建一个类,里面的内容就已经加载到内存中

四 对象

4.1 概念

对象:类名() 实例化一个对象

4.2 实例化

**实例化:类名加括号就是实例化,会自动触发__init__函数的运行,可以用它来为每个实例定制自己的特征
(1)实例化一个对象,在内存中产生一个对象空间
(2)自动执行init方法,并将这个空间对象<main.person object at 0x0000000001f5abe0> 传给self
(3)通过构造方法里的代码给空间对象添加一些属性,并返回给对象**
例如:

p1=person('张三','男','大眼睛',176,170)
print(p1.__dict__)
结果为:
{'name': '张三', 'sex': '男', 'eye': '大眼睛', 'high': 176, 'weight': 170}

五 对象操作属性变量的两种方式

5.1 对象.__dict__方法,只能查看不能增删改

p2=person('李四','男','小眼睛',170,170)
print(p2.__dict__)
结果为:
{'name': '李四', 'sex': '男', 'eye': '小眼睛', 'high': 170, 'weight': 170}

5.2 对象.变量名,可增删改查

5.2.1 查

print(p2.name)
结果为:
李四

5.2.2 增加

p2.color='黄皮肤'
print(p2.color)

5.2.3 删除

del p2.name
print(p2.__dict__)
结果为:
{'sex': '男', 'eye': '小眼睛', 'high': 170, 'weight': 170, 'color': '黄皮肤'}

5.2.4 改

print(p2.__dict__)
p2.name='王麻子'
print(p2.__dict__)
结果为:
{'name': '李四', 'sex': '男', 'eye': '小眼睛', 'high': 170, 'weight': 170}
{'name': '王麻子', 'sex': '男', 'eye': '小眼睛', 'high': 170, 'weight': 170}

5.3 可以访问类的静态变量

5.3.1 查询全部变量

print(p2.__dict__)
{'name': '李四', 'sex': '男', 'eye': '小眼睛', 'high': 170, 'weight': 170}

5.3.2 查询单个变量,类名.变量名

print(p2.animal)
结果为:
高级动物

六 对象操作的两种方式

6.1 对象.方法名()

p2.work()
结果为:
<__main__.person object at 0x0000025324099d68>
人会工作
print(p2.__dict__)
{'name': '李四', 'sex': '男', 'eye': '小眼睛', 'high': 170, 'weight': 170}

6.2 类名.方法名()

person.work('abc')
abc
人会工作

七 类空间、对象空间

class person:
    animal='高级动物'
    soul='有思想'
    name='孙悟空'

    def __init__(self,name,sex,eye,high,weight):
        self.name=name
        self.sex=sex
        self.eye=eye
        self.high=high
        self.weight=weight
        print(666)
    def work(self,job):
        print('人会工作')
p1=person('alex','女','小眼睛',178,160)

print(p1.name)
print(p1.soul)
print(p1.__dict__)
print(p1.eye)
p1.work('it')
print(p1.__dict__)
结果为:
666
alex
有思想
{'name': 'alex', 'sex': '女', 'eye': '小眼睛', 'high': 178, 'weight': 160}
小眼睛
人会工作
{'name': 'alex', 'sex': '女', 'eye': '小眼睛', 'high': 178, 'weight': 160}

可以看到self约定俗成叫self,不能改变

通过实例化对象查找属性时,先从对象空间找,没有则通过类对象指针从类空间找。