面向对象的程序设计

时间:2019-03-19
本文章向大家介绍面向对象的程序设计，主要包括面向对象的程序设计使用实例、应用技巧、基本知识点总结和需要注意事项，具有一定的参考价值，需要的朋友可以参考一下。

一、三大编程范式：

1.面向过程编程

2.函数式编程

3.面向对象编程

二、面向对象设计：

将一类具体事物的数据和动作整合到一起，即面向对象设计

def basketball_player(name, position, age):

    def init(name, position, age):          #具体事物的数据
        player = {
            'name': name,
            'position': position,
            'age': age,
            'score': score,
            'assist': assist,
            'reboud': reboud
        }
        return player

    def score(player):                            #具体事物的动作
        print('%s中投得手拿到2分' %player['name'])

    def assist(player):                           #具体事物的动作
        print('%s助攻队友' %player['name'])

    def reboud(player):                         #具体事物的动作
        print('%s旱地拔葱，收下一个篮板' %player['name'])

    return init(name, position, age)


#创建一个 basketball_player函数的对象
player1 = basketball_player('leborn','sf','34')
player1['score'](player1)           #leborn中投得手拿到2分

player2 = basketball_player('curry', 'pg', '31')
player2['assist'](player2)          #curry助攻队友

player3 = basketball_player('davis', 'pf', '25')
player3['reboud'](player3)         #davis旱地拔葱，收下一个篮板

三、面向对象编程：

用定义类+实例/对象的方式去实现面向对象的设计

类与对象：

1.什么是类：类是一种数据结构，就是把一类事物相同的特征和动作整合到一起就是类，类是一个抽象的概念，就好比一个模型，该模型用来表述一类事物(事物即数据和动作的结合体)，用它来生产真实的物体(实例)。

2.什么叫对象：就是基于类而创建的一个具体的事物（具体存在的），也是特征和动作整合到一起；可以理解为：睁开眼，你看到的一切的事物都是一个个的对象，你可以把对象理解为一个具体的事物(事物即数据和动作的结合体)

3.类与对象的关系：对象都是由类产生的，上帝造人，上帝首先有一个造人的模板，这个模板即人的类，然后上帝根据类的定义来生产一个个的人

4.什么叫实例化：由类生产对象的过程叫实例化，类实例化的结果就是一个对象，或者叫做一个实例（实例=对象）

类的定义：

在python中声明函数与声明类很相似

声明函数

def 函数名:
　　函数的文档字符串’
　　函数体
'''

声明类

class 类名：
　　类的文档字符串’
　　类体
'''

创建一个类

类名规则首字母大写（小写也可以，但不推荐）
属性：⑴数据属性 ⑵函数属性
class NBA_player:
　　'这是一个NBA球员的类‘’
　　pass

#用类NBA_player实例化出一个对象p1
p1 = NBA_player()

类之属性：

类是用来描述一类事物，类的对象指的是这一类事物中的一个个体

是事物就要有属性，属性分为

1：数据属性：就是变量

2：函数属性：就是函数，在面向对象里通常称为方法

注意：类和对象均用点(*.*)来访问自己的属性

数据属性即变量，类的定义与函数又极其类似，其实可以用函数的作用域来理解类的属性调用

类的数据属性

#定义一个Nbaplyer的类,然后在类中定义一个类的属性,所属联盟是‘美国男子职业球赛联盟’,这样，只要是Nbaplayer他们的所属永远都是‘美国男子职业球赛联盟’
#类属性又称为静态变量,或者是静态数据。这些数据是与它们所属的类对象绑定的,不依赖于任何类实例。
#这种类型的数据相当于在一个变量声明前加上static关键字。

class Nbaplayer:
    home = '美国男子职业球赛联盟'

print(Nbaplayer.home)    #美国男子职业球赛联盟

类的函数属性(又称为方法)

class Player:
    home = '美国男子职业球赛联盟'
    
    def activity(self):
        print('%s参加球队组织日常训练或者比赛' % self)

Player.activity('lebron')    #lebron参加球队组织日常训练或者比赛

查看类属性
(1)、dir(类名)：查出的是一个名字列表

(2)、类名.__dict__:查出的是一个字典，key为属性名，value为属性值

class Player:
    home = '美国男子职业球赛联盟'

    def activity(self):
        print('%s参加球队组织日常训练或者比赛' % self)


print(dir(Player))
print(Player.__dict__)
>>>
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'activity', 'home']

{'__module__': '__main__', 'home': '美国男子职业球赛联盟', 'activity': <function Player.activity at 0x000001E6932A97B8>, '__dict__': <attribute '__dict__' of 'Player' objects>, '__weakref__': <attribute '__weakref__' of 'Player' objects>, '__doc__': None}

对象与实例化：对象是由类实例化而来，类实例化的结果称为一个实例或者称作一个对象

实例化：

class Player:
    home = '美国男子职业球赛联盟'

    def hoppy(self):
        print('逛夜店，办派对')

    def activity(self):
        print('%s参加球队组织日常训练或者比赛' %self)

p1 = Player()    #类名加上括号就是实例化(可以理解为函数的运行,返回值就是一个实例)
#这就是实例化，只不过得到的p1实例，没有做任何事情

构造函数：

上述的实例化过程，没有做任何事情，啥意思？类是数据属性和函数属性的结合，描述的是一类事物,这类事物的一个具体表现就是一个实例/对象，比方说Player是一个类，而詹姆斯就是这个类的一个实例，詹姆斯除了有属于‘美国男子职业球赛联盟’这个数据属性外，还应该有名字，年龄，性别等数据属性。如何为实例定制数据属性，可以使用类的一个内置方法__init__()该方法，在类()实例化是会自动执行。

class Player:
    home = '美国男子职业球赛联盟'
    def __init__(self, name, age, gender):  #实例化的过程可以简单理解为执行该函数的过程，实例本身会当作参数传递给self（这是默认的步骤）
        self.xingming = name
        self.nianji = age
        self.xingbie = gender

    def hoppy(self):
        print('逛夜店，办派对')

    def activity(self):
        print('%s参加球队组织日常训练或者比赛' %self.xingming)


p1 = Player('lebron', '34', 'male')  #实例化
p2 = Player('curry', '31', 'male')
p3 = Player('davis', '25', 'male')

注意：在讲实例化的时候说过，执行类()会自动返回一值，这个值就是实例，而类()会自动执行__init__，所以一定不要在该函数内定义返回值，会冲突。

实例属性：

实例化的过程实际就是执行__init__的过程，这个函数内部只是为实例本身即self设定了一堆数据(变量)，所以实例只有数据属性。

class Player:
    '这是NBA球员的类'
    home = '美国男子职业球赛联盟'
    def __init__(self, name, age, gender):
        self.xingming = name
        self.nianji = age
        self.xingbie = gender

    def hoppy(self):
        print('%s喜欢逛夜店，办派对' %self.xingming)

    def activity(self):
        print('%s参加球队组织日常训练或者比赛' %self.xingming)

p1 = Player('lebron', '34', 'male')  #实例化
p2 = Player('harden', '29', 'male')

print(p1.__dict__)   #查看实例属性{'xingming': 'lebron', 'nianji': '34', 'xingbie': 'male'}

#查看实例的属性,发现里面确实只有数据属性，函数属性只存在于类中
#我们只能通过类去调用类的函数属性,然后把实例当做变量传递给self
Player.hoppy(p2)
p2.hoppy()   #本质就是Player.hoppy(p2)

查看实例属性

同样是dir和内置__dict__两种方式

class Player:
    home = '美国男子职业球赛联盟'
    def __init__(self, name, age, gender):
        self.xingming = name
        self.nianji = age
        self.xingbie = gender

    def hoppy(self):
        print('%s喜欢逛夜店，办派对' %self.xingming)

    def activity(self):
        print('%s参加球队组织日常训练或者比赛' %self.xingming)



p1 = Player('lebron', '34', 'male')  #实例化
print(p1.__dict__)   
print(dir(p1))
>>>
{'xingming': 'lebron', 'nianji': '34', 'xingbie': 'male'}

['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'activity', 'home', 'hoppy', 'nianji', 'xingbie', 'xingming']

类属性的增删改查：

class Player:
    '这是NBA球员的类'
    home = '美国男子职业球赛联盟'
    def __init__(self, name, age, gender):
        self.xingming = name
        self.nianji = age
        self.xingbie = gender

    def hoppy(self):
        print('%s喜欢逛夜店，办派对' %self.xingming)

    def activity(self):
        print('%s参加球队组织日常训练或者比赛' %self.xingming)


#查看类数据属性
print(Player.home)   #美国男子职业球赛联盟

#修改类数据属性
Player.home = 'NBA'
print(Player.home)   #NBA

#增加类数据属性
Player.country = 'usa'
print(Player.country)   #usa

#删除类数据属性
del Player.country

#增加类函数属性
def money(self):
    print('%s为慈善事业奉献了很多钱' %self.xingming)

Player.money = money
p1.money()   #lebron为慈善事业奉献了很多钱

实例的增删改查:

class Player:
    '这是NBA球员的类'
    home = '美国男子职业球赛联盟'
    def __init__(self, name, age, gender):
        self.xingming = name
        self.nianji = age
        self.xingbie = gender

    def hoppy(self):
        print('%s喜欢逛夜店，办派对' %self.xingming)

    def activity(self):
        print('%s参加球队组织日常训练或者比赛' %self.xingming)

#查看实例数据属性
print(p1.xingming)  #lebron

#增加实例属性
p1.high_school = 'st.marry'
print(p1.high_school)   #st.marry

#修改
p1.age = 19
print(p1.age)

#删除
del p1.high_school

1.其实你会发现，实例化就是 类名()，然后返回的结果是一个对象，加上括号是不是跟函数运行很像，函数运行完了有返回值，是不是很像，没错，就是一样的。

2.函数又作用域的概念，其实类也有作用域的概念，二者一样

3.你可以把class当做最外层的函数，是一个作用域

4.实例化会自动触发init函数的运行，最后返回一个值即实例，我们要找的实例属性就存放在init函数的局部作用域里

5.类有类的属性字典，就是类的作用域，实例有实例的属性字典，即实例的作用域

6.综上，一个点代表一层作用域，obj.x先从自己的作用域找，自己找不到去外层的类的字典中找，都找不到，就会报错

country = '美国'
class person:
    country = '中国'
    def __init__(self,name):
        self.name = name
        print('------>',country)
    def eat(self):
        print('吃饭啦')

p1 = person('chen')  #运行__init__函数，因为函数内的country不是用*.country调用，所以country为一个普通变量，与类和实例的属性都没有关系。所以输出为【美国】
print(p1.country)  #用*.country调用，直接先找实例属性，实例属性中没有country，则去找类属性。类属性如果还没有将会报错。在这里输出的是【中国】
class Chinese:
    li = ['a','b']
    def __init__(self,name):
        self.name=name

    def play_ball(self,ball):
        print('%s 正在打%s'%(self.name,ball))

p1 = Chinese('alex')    #实例化一个对象
print(p1.li)   # ['a','b']
p1.li_st=[1,2,3]       #相当于在__init__函数中定义了一个list列表，与class里的列表无关
print(p1.li)    #[1,2,3]
print(Chinese.li)    #['a','b']
p1.li.append('c')       #找到的是class里的列表，进行append操作
print(p1.li)    #['a','b','c']
print(Chinese.li)    #['a','b','c']
随机文章
本站知识点必读
最近更新