面向对象编程:是一类相似功能函数的集合,使你的代码更清晰化,更合理化
面向对象的三大特性:继承、多态、封装
处理一类事物,这些事物都具有相同的属性和功能,可以使用面向对象
当有几个函数,需要反反复复调用传入相同参数的时候,可以使用面向对象,这些参数都是对象的属性
>>> print(list)
<class 'list'> #list 类
>>> print(dict)
<class 'dict'> #dict 类
>>> d = {'key','value'} #对象
>>> print(d)
{'key', 'value'}
#自定义一个最简单的类
class 类名:
属性 = 'a'
def action(): #方法
pass
面向对象引入:定义一个游戏人物和怪物
linyaohong = {'name':"法师",'hp' : "100",'aggr':'1','sex':"None"}
dog = {'name':'树精','hp':"1000",'aggr':'100','kind':'teddy'}
改变引入面向对象编程:
模子,类、抽象。确定有什么属性,有什么技能,但是不知道具体属性,具体的值
gouzi nezha 是对象,有具体的值,属性和技能都是根据类规范
def Person(name,hp,aggr,sex):
person = {
'name': name,
'hp': hp,
'aggr':aggr,
'sex': sex
}
# 人物技能
def attack(dog):
dog['hp'] -= person['aggr']
print('%s被打了,掉了%s的血' % (dog['name'], person['aggr']))
person['attack'] = attack
return person
def Dog(name,hp,aggr,kind):
# 怪物技能
dog = {
'name': name,
'hp': hp,
'aggr':aggr,
'kind': kind
}
def bite(person):
person['hp'] -= dog['aggr']
print('%s被打了,掉了%s的血' % (person['name'], dog['aggr']))
dog['bite'] = bite
return dog
gouzi = Dog("树精",3000,200,'公')
print(gouzi)
honghaier = Person('狗剩',1000,1,'不详')
nezha = Person('哪吒',5000,3,'女')
print(honghaier)
print(nezha)
gouzi['bite'](nezha)
nezha['attack'](gouzi)
#D:\python\python.exe F:/运维笔记/python/面向对象/01面向对象引入.py
{'name': '树精', 'hp': 3000, 'aggr': 200, 'kind': '公', 'bite': <function Dog.<locals>.bite at 0x00000204FFB908C8>}
{'name': '狗剩', 'hp': 1000, 'aggr': 1, 'sex': '不详', 'attack': <function Person.<locals>.attack at 0x00000204FFB90950>}
{'name': '哪吒', 'hp': 5000, 'aggr': 3, 'sex': '女', 'attack': <function Person.<locals>.attack at 0x00000204FFB909D8>}
哪吒被打了,掉了200的血
树精被打了,掉了3的血
面向对象
# -*- coding:utf-8 -*-
#----------------------------------------改造定义一个类-------------------------------------
class Person:
def __init__(self,*args):
print(self.__dict__) #self是可以存储很多属性的字典
self.name = args[0] #往self对象里里添加属性的方式发生了一些改变
self.hp = args[1]
self.aggr = args[2]
self.sex = args[3]
print(self.__dict__)
print(id(self))
nezha = Person('哪吒',5000,3,'女') # 类名() 得到 对象 过程是:实例化
print(nezha.__dict__) #查看全部属性
print(id(nezha))
print(nezha) #<__main__.Person object at 0x0000024BAC926780>类的对象
print(nezha.name)
#D:\python\python.exe F:/运维笔记/python/面向对象/02面向对象交互.py
{}
{'name': '哪吒', 'hp': 5000, 'aggr': 3, 'sex': '女'}
3139636277768
{'name': '哪吒', 'hp': 5000, 'aggr': 3, 'sex': '女'}
3139636277768
<__main__.Person object at 0x000002DB00E7B208>
哪吒
#通过打印id可以看出self就等于nezha这个对象、
#--------------------------------解释__init__用法----------------------------------
# -*- coding:utf-8 -*-
def Person(*args,**kwargs):
self = {}
def attack(self,dog):
dog['life_value'] -= self['aggressivity']
def __init__(name,aggressivity,life_value):
self['name'] = name
self['aggressivity'] = aggressivity
self['life_value'] = life_value
self['attack'] = attack
__init__(*args,**kwargs)
return self
egg = Person('egon',78,10)
print(egg['name'])
#D:\python\python.exe F:/运维笔记/python/面向对象/03面向对象协助了解03.py
egon
对象:类名()
过程:
类名() 首先创造一个对象,创建了一个self变量
调用init方法,类名括号里的参数都会被这里接收
执行init方法
返回self
对象:
查看属性
调用方法
__dict__可以通过字典的语法,对对象进行增删改查,
类名:
实例化
调用方法:需要传递self参数
调用类的属性(调用静态属性)
面向对象详细说明
# -*- coding:utf-8 -*-
class Person: #Person类名
country = 'CN ' #创建一个类的公共属性 / 类属性/静态属性
def __init__(self,*args): #init:初始化方法 self是对象(必须传的一个参数)
self.name = args[0] #往字典里添加属性的方式不同
self.hp = args[1]
self.aggr = args[2]
self.sex = args[3]
def walkleft(self,n): #方法,必须传self参数,必须写在第一个,后面还可以传其他参数
print("%s往左走"%self.name,n)
print(Person.country) #类名可以查看类中的属性,不需要实例化就可以查看
nezha = Person('哪吒',5000,3,'女') # 类名() 得到 对象 过程是:实例化
print(nezha.hp) #获取对象的属性值
print(nezha.__dict__) #查看对象全部,所有属性
print(Person.__dict__) #类里所有的
Person.walkleft(nezha,5) #调类名掉用方法: 类名.方法名(对象名) = nezha.walk()
nezha.walkleft(5) # 对象调用方法:使用对象可也调用这个对象所在类里面的方法、切把自己传值给self
#补充(和补充二等价)
# print(Person.__dict__['country'])
# print(nezha.__dict__['hp'])
# nezha.__dict__['hp'] = '888' #修改对象nezha的hp值
# print(nezha.__dict__)
# print(nezha.hp)
#补充二:对象的增删改查
nezha.hp = '999' #修改对象nezha的hp值(推荐)
print(nezha.hp)
nezha.age = 83 #对象增加一个属性
print(nezha.__dict__)
del nezha.hp #删除对象的hp值
print(nezha.__dict__)
#补充三(了解即可)
Person.country = '中国' #修改类的静态属性
Person.size = '111'
print(Person.country)
print(Person.size)
#-------------------------------------------------------------------------------------------------
D:\python\python.exe F:/运维笔记/python/面向对象/04面向对象深入.py
CN
5000
{'name': '哪吒', 'hp': 5000, 'aggr': 3, 'sex': '女'}
{'__module__': '__main__', 'country': 'CN ', '__init__': <function Person.__init__ at 0x000001DA29860840>, 'walkleft': <function Person.walkleft at 0x000001DA298608C8>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}
哪吒往左走 5
哪吒往左走 5
999
{'name': '哪吒', 'hp': '999', 'aggr': 3, 'sex': '女', 'age': 83}
{'name': '哪吒', 'aggr': 3, 'sex': '女', 'age': 83}
中国
111
面向对象进一步练习
# -*- coding:utf-8 -*-
class Dog:
def __init__(self,*args):
self.name = args[0]
self.hp = args[1]
self.aggr = args[2]
self.kind = args[3]
def bite(self,person):
person.hp -= self.aggr
print('%s攻击了%s,%s掉了%s的血' %(self.name,person.name,person.name, self.aggr))
class Person:
def __init__(self,*args):
self.name = args[0]
self.hp = args[1]
self.aggr = args[2]
self.sex = args[3]
def attack(self,dog):
dog.hp -= self.aggr
print('%s攻击了%s,%s掉了%s的血' %(self.name,dog.name,dog.name, self.aggr))
gouzi = Dog('gouzi',1000,200,'taidi')
nezha = Person('nezhan',1000,300,'女')
print(nezha.hp)
print(gouzi.hp)
gouzi.bite(nezha)
print(nezha.hp)
nezha.attack(gouzi)
print(gouzi.hp)
#-----------------------------------------------------------------------------------
D:\python\python.exe F:/运维笔记/python/面向对象/05面向对象游戏.py
1000
1000
gouzi攻击了nezhan,nezhan掉了200的血
800
nezhan攻击了gouzi,gouzi掉了300的血
700
面向对象 进一步练习
# -*- coding:utf-8 -*-
class Person:
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
def shang(self):
print('%s,%s岁,%s,123'%(self.name,self.age,self.sex,))
def love(self):
print('%s,%s岁,%s,456'%(self.name,self.age,self.sex,))
def shan(self):
print('%s,%s岁,%s,789'%(self.name,self.age,self.sex,))
ming = Person('小明','18','男')
ming.shan()
ming.shang()
ming.love()
zhang = Person('老张','90','男')
zhang.shan()
zhang.shang()
zhang.love()
#--------------------------------------------------------------------------
D:\python\python.exe F:/运维笔记/python/面向对象/06面向对象练习.py
小明,18岁,男,789
小明,18岁,男,123
小明,18岁,男,456
老张,90岁,男,789
老张,90岁,男,123
老张,90岁,男,456
面向对象练习、
# # -*- coding:utf-8 -*-
#案例:计算正方形的面积和周长
x = 8
class circle:
def __init__(self,n):
self.n = n
def area(self):
return self.n*self.n
def perimeter(self):
return self.n*4
m1 = circle(x)
print(m1.area())
print(m1.perimeter())
#-------------or--------------
# x = 8
# print('面积:',x*x)
# print('周长:',x*4)
面向对象-总结
定义类
class
函数:方法 动态属性 类中可以定义方法,方法必须都有一个必须传的参数self
变量:类属性 静态属性 类中可以定义静态属性
init方法
python自动创建一个对象self(空的)
调用类的时候自动触发,默认传self
在init方法里可以对self赋值
self是什么 self拥有的属性都属于对象
在类的内部,self是一个对象
nezha = Person()
nezha.walk = Person.walk(nezha)
实例化
对象 = 类(参数是init方法的)
实例、对象 没有区别
对象查看属性
对象.属性名字
对象调用方法
对象.方法(参数)
创建一个类,每实例化一个对象就计数、最终所有的数据共享这个数据
# -*- coding:utf-8 -*-
class Foo:
count = 0
def __init__(self):
Foo.count +=1
f1 = Foo()
f2 = Foo()
f3 = Foo()
print(f1.count)
#-----------------------------------------------------
D:\python\python.exe F:/运维笔记/python/面向对象/010类和对象命名空间练习.py
3
面向对象 命名空间
# -*- coding:utf-8 -*-
class Course:
language = 'Chinese'
def __init__(self,teacher,course_name,period,price):
self.teacher = teacher
self.course_name = course_name
self.period = period
self.price = price
def func(self):
pass
python = Course('linyaohong','python','6 months',20000)
linux = Course('ding','linux','6 months',60000)
print(Course.language)
print(python.language)
print(linux.language)
Course.language = 'EN' #通过类 修改类的静态属性/对象调用静态属性、统一会变
print(Course.language)
print(python.language)
print(linux.language)
#------------------------------------------------------------------
D:\python\python.exe F:/运维笔记/python/面向对象/09类和对象的命名空间.py
Chinese
Chinese
Chinese
EN
EN
EN
# -*- coding:utf-8 -*-
class Course:
language = 'Chinese'
def __init__(self,teacher,course_name,period,price):
self.teacher = teacher
self.course_name = course_name
self.period = period
self.price = price
def func(self):
pass
python = Course('linyaohong','python','6 months',20000)
linux = Course('ding','linux','6 months',60000)
python.language = "CN" #对象不能修改类的静态属性,会赋值新的属性给对象、修改后想从新调用类的静态属性,需要删除自己赋值的
print(python.language)
print(linux.language)
print(Course.language)
print(python.__dict__)
print('-----------------------------------------------------------------')
del python.language #修改后想从新调用类的静态属性,需要删除自己赋值的
print(Course.language)
print(python.__dict__)
print(python.language)
print(linux.__dict__)
print(linux.language)
#---------------------------------------------------------
D:\python\python.exe F:/运维笔记/python/面向对象/09类和对象的命名空间.py
CN
Chinese
Chinese
{'teacher': 'linyaohong', 'course_name': 'python', 'period': '6 months', 'price': 20000, 'language': 'CN'}
-----------------------------------------------------------------
Chinese
{'teacher': 'linyaohong', 'course_name': 'python', 'period': '6 months', 'price': 20000}
Chinese
{'teacher': 'ding', 'course_name': 'linux', 'period': '6 months', 'price': 60000}
Chinese
类中的静态变量可以被对象和类调用
对于不可变数据来说、类变量最好使用类名操作
对于可变数据类型来说,对象名的修改是共享的,重新赋值是独立的
# -*- coding:utf-8 -*-
class Course:
language = ['Chinese']
def __init__(self,teacher):
self.teacher = teacher
python = Course('lin')
linux = Course('yao')
python.language = ['EN'] #重新赋值是独立的
print(Course.language) #['Chinese']
print(python.language) #['EN']
print(python.__dict__) #{'teacher': 'lin', 'language': ['EN']}
print(Course.language) #['Chinese']
print(linux.__dict__) #{'teacher': 'yao'}
print(linux.language) #['Chinese']
#-------------------------------------------------------------------------------
D:\python\python.exe F:/运维笔记/python/面向对象/09类和对象的命名空间.py
['Chinese']
['EN']
{'teacher': 'lin', 'language': ['EN']}
['Chinese']
{'teacher': 'yao'}
['Chinese']
# -*- coding:utf-8 -*-
class Course:
language = ['Chinese']
def __init__(self,teacher):
self.teacher = teacher
python = Course('lin')
linux = Course('yao')
python.language[0] = 'EN' #通过list修改,修改后全部修改、是共享的
print(Course.language)
print(linux.language)
print(python.language)
#--------------------------------------------------------------------------
D:\python\python.exe F:/运维笔记/python/面向对象/09类和对象的命名空间.py
['EN']
['EN']
['EN']
绑定关系
# -*- coding: UTF-8 -*-
#绑定关系
class Foo:
def func(self): #
pass
f1 = Foo()
print(f1)
print(Foo.func)
print(f1.func) #把f1传给func的self参数
#----------------------------------------------------------------------
D:\python\python.exe F:/运维笔记/python/面向对象/010类和对象命名空间练习.py
<__main__.Foo object at 0x0000025BB87D4438>
<function Foo.func at 0x0000025BB8880598>
<bound method Foo.func of <__main__.Foo object at 0x0000025BB87D4438>>