面向对象的程序设计
一、三大编程范式:
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']