从零开始的Linux运维屌丝之路,资源免费分享平台   运维人员首选:简单、易用、高效、安全、稳定、社区活跃的开源软件

42、初识 面向对象 类 命名空间

发布:蔺要红06-11分类: Python


面向对象编程:是一类相似功能函数的集合,使你的代码更清晰化,更合理化

面向对象的三大特性:继承、多态、封装

 

处理一类事物,这些事物都具有相同的属性和功能,可以使用面向对象
当有几个函数,
需要反反复复调用传入相同参数的时候,可以使用面向对象,这些参数都是对象的属性
 

>>> 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>>

 
温馨提示如有转载或引用以上内容之必要,敬请将本文链接作为出处标注,如有侵权我会在24小时之内删除!

欢迎使用手机扫描访问本站