属性查找与绑定方法

属性查找

类有两种属性:数据属性和函数属性

1、类的数据属性是所有对象共享的

class LuffyStudent:
    school=‘luffycity‘

    def learn(self):
        print(‘is learning‘)

    def eat(self):
        print(‘is sleeping‘)

#后产生对象
stu1=LuffyStudent()
stu2=LuffyStudent()
stu3=LuffyStudent()

print(id(stu1.school))
print(id(stu2.school))
print(id(stu3.school))

# 43496496
# 43496496
# 43496496

2、类的函数数据是绑定给对象用的,称为绑定到对象的方法

#后产生对象
stu1=LuffyStudent()
stu2=LuffyStudent()
stu3=LuffyStudent()
#类的函数属性是绑定给对象使用的,obj.method称为绑定方法,内存地址都不一样
print(stu1.learn())
print(stu2.learn())
print(stu3.learn())

# <bound method LuffyStudent.learn of <__main__.LuffyStudent object at 0x00000000127085C0>>
# <bound method LuffyStudent.learn of <__main__.LuffyStudent object at 0x0000000012708518>>
# <bound method LuffyStudent.learn of <__main__.LuffyStudent object at 0x0000000012708630>>
#ps:id是python的实现机制,并不能真实反映内存地址,如果有内存地址,还是以内存地址为准

在obj.name会先从obj自己的名称空间里找name,找不到则去类中找,类也找不到就找父类...最后都找不到就抛出异常

 

绑定方法

定义类并实例化出三个对象

class LuffyStudent:
    school=‘luffy‘
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def eat(self):
        print(‘%s is eating‘ %self.name)

    def sleep(self):
        print(‘%s is sleeping‘ %self.name)

    def __del__(self):
        print("running del method, this person must be died.")

# 后产生对象
stu1=LuffyStudent(‘alex‘,18)
stu2=LuffyStudent(‘li‘,28)
stu3=LuffyStudent(‘hy‘,38)

stu1.eat()
stu2.eat()
stu3.eat()

# alex is eating
# li is eating
# hy is eating

 强调:绑定到对象的方法的特殊之处在于,绑定给谁就由谁来调用,谁来调用,就会将‘谁’本身当做第一个参数传给方法,即自动传值(方法__init__也是一样的道理)

stu1.eat() # 等同于LuffyStudent.eat(stu1)
stu2.eat() # 等同于LuffyStudent.eat(stu1)
stu3.eat() # 等同于LuffyStudent.eat(stu1)

 注意:绑定到对象的方法的这种自动传值的特征,决定了在类中定义的函数都要默认写一个参数self,self可以是任意名字,但是约定俗成地写出self。

类即类型

python中一切皆为对象,且python3中类与类型是一个概念,类型就是类

#类型dict就是类dict
>>> list
<class ‘list‘>

#实例化的到3个对象l1,l2,l3
>>> l1=list()
>>> l2=list()
>>> l3=list()

#三个对象都有绑定方法append,是相同的功能,但内存地址不同
>>> l1.append
<built-in method append of list object at 0x10b482b48>
>>> l2.append
<built-in method append of list object at 0x10b482b88>
>>> l3.append
<built-in method append of list object at 0x10b482bc8>

#操作绑定方法l1.append(3),就是在往l1添加3,绝对不会将3添加到l2或l3
>>> l1.append(3)
>>> l1
[3]
>>> l2
[]
>>> l3
[]
#调用类list.append(l3,111)等同于l3.append(111)
>>> list.append(l3,111) #l3.append(111)
>>> l3
[111]

数据与功能分离

class MySQLHandler:
    def __init__(self,host,port,db,charset=‘utf8‘):
        self.host=host
        self.port=port
        self.db=db
        self.charset=charset
        self.conn=self.connect(self.host,self.port,self.db,self.charset)

    def exc1(self,sql):
        return self.conn.execute(sql)

    def exc2(self,sql):
        return self.conn.call_proc(sql)

    def _connect(self,host,port,db,charset):
        print(‘connect %s,%s,%s,%s‘ %(host,port,db,charset))

obj=MySQLHandler(‘127.0.0.1‘,3306,‘db1‘)
obj.exc1(‘select * from tb1;‘)
obj.exc2(‘mycall‘)

小节练习

练习1:编写一个学生类,产生一堆学生对象

要求:

  1. 有一个计数器(属性),统计总共实例了多少个对象
class Student(object):
    count = 0

    def __init__(self,name):
        self.name = name
        Student.count+=1

    def learn(self):
        print(‘%s is learning‘%self.name)

s1 = Student(‘x1‘)
print(s1.count)  # 1
s2 = Student(‘x2‘)
print(s2.count) # 2
s3 = Student(‘x3‘)
print(s3.count) # 3

  

练习2:模仿王者荣耀定义两个英雄类

要求:

  1. 英雄需要有昵称、攻击力、生命值等属性;
  2. 实例化出两个英雄对象;
  3. 英雄之间可以互殴,被殴打的一方掉血,血量小于0则判定为死亡。
class HeroA:
    camp = ‘A‘
    def __init__(self,name,life_vale,aggresivity):
        self.name = name
        self.life_value = life_vale
        self.aggresivity = aggresivity

    def attack(self,enemy):
        if enemy.life_value == 0:
            print(‘%s is dead‘ %enemy.name)
        enemy.life_value -= self.aggresivity

class HeroB:
    camp =‘B‘
    def __init__(self,name,life_vale,aggresivity):
        self.name = name
        self.life_value = life_vale
        self.aggresivity = aggresivity

    def attack(self,enemy):
        if enemy.life_value == 0:
            print(‘%s is dead‘ % enemy.name)
        enemy.life_value -= self.aggresivity

a = HeroA(‘a1‘,160,50)
b = HeroB(‘b1‘,150,40)

while b.life_value > 0:
    a.attack(b)
    print(‘b life‘, b.life_value)
    b.attack(a)
    print(‘a life‘, a.life_value)

a.attack(b)

#结果
b life 100
a life 120
b life 50
a life 80
b life 0
a life 40
b1 is dead

  

原文地址:https://www.cnblogs.com/xiao-apple36/p/9127751.html

时间: 2024-11-05 18:45:27

属性查找与绑定方法的相关文章

python:属性查找与绑定方法

属性查找 类有两种属性:数据属性和函数属性 1.类的数据属性是所有对象共享的 # 类的数据属性是所有对象共享的,id是一样的 print(id(OldboyStudent.school)) # 4830576 print(id(s1.school)) # 4830576 print(id(s2.school)) # 4830576 print(id(s3.school)) # 4830576 2. 类的函数属性是绑定给对象用的,称为绑定到对象的方法 # 类的函数属性是绑定给对象使用的,obj.m

类属性查找与绑定方法

class luffystudent: def __init__(self,name,sex,age): self.name=name self.sex=sex self.age=age school='luffycity' def learn(self,x): print('%s is learning %s' %(self.name,x)) def eat(self): print('is eating') def sleep(self): print('is sleeping') #后产生

003---属性查找和绑定方法

属性查找与绑定方法 属性查找 类有两种属性:数据属性和函数属性 class LuffyStudent: school = 'Luffy' def __init__(self, name, sex, age): self.name = name self.sex = sex self.age = age def learn(self, class_name): print('%s 正在学习 %s' % (self.name, class_name)) def eat(self): print('吃

属性查找;绑定到对象的方法的特殊之处;对象之间的交互

四 属性查找 类有两种属性:数据属性和函数属性 1. 类的数据属性是所有对象共享的 2. 类的函数属性是绑定给对象用的 #类的数据属性是所有对象共享的,id都一样 print(id(OldboyStudent.school)) print(id(s1.school)) print(id(s2.school)) print(id(s3.school)) ''' 4377347328 4377347328 4377347328 4377347328 ''' #类的函数属性是绑定给对象使用的,obj.

python-属性的查找与绑定方法

类的属性: 类中有两种属性: 数据属性:类的数据属性是所有对象共享的. eg:   在类中定义了一个  school = 'luffycity'  #这个称类的数据属性. 当这个类生成了多个对象时,这些对象都享有这个数据属性. 函数属性:类的函数属性是绑定给对象使用的. eg: 类中定义了一个 函数: def eat(): print ('is eatting') 当生成一个stu1对象并使用这个eat方法是时,执行结果只影响stu1 注意:当定义了一个对象时它的查找顺序如下: 先由对象的名称空

beautifulsoup 根据class属性查找标签的方法。

写爬虫的时候遇到的: 导入beautifulSoup后, 查找类似<div  class = "abcd">的时候, 直接使用beautifulsoup的方法: soup.findall("div", class="abcd") 这样写的时候回报错, 按照官方的一种方法写在class后加“_“试了试没什么用.虽说不报错,但返回的时空,匹配不到值, 使用另一种方法: soup.findAll(name="div",

第十一章、对象属性查找顺序与属性和方法

目录 第十一章.对象属性查找顺序与属性和方法 一.属性查找 二.对象赋属性 三.绑定方法 第十一章.对象属性查找顺序与属性和方法 一.属性查找 对象自身-->子类-->父类(多继承)-->报错 二.对象赋属性 方式一:给自己对象加一个属性 student=Student() student.name='nick' 方拾二:__init__()方法内赋值 方式三:对象.方法 change_name(self,name) self.name='nick' 三.绑定方法 定义在类内部的方法 类

绑定与非绑定方法 继承 继承与抽象 查找属性关系 派生与覆盖 访问父类的内容

类属性与对象属性 类中应该仅存储所有对象共有的内容 如所有人的国籍相同那就放到类中 对象中存储每个对象独有的内容 ? 如每个人的名字都不同 初始化函数class Person: color = 'white' def read(self): print('hamlet') # 创建对象 也称之为实例化 产生的对象也称之为实例a1=Person()print(a1)print(a1.color)print(a1.__dict__) a2 = Person()print(a2)print(a2.re

面向对象二次整理(基础,属性引用,方法引用.绑定方法)

概念之类的去百度一下... 基础 类 属性 实例变量 类变量(默认共享) 私有属性(__var) 方法 构造方法 析构方法或析构函数 私有方法 对象: 实例化一个类之后得到的对象 封装 把一些功能的实现细节不对外暴露 类的初始化(__init__): 就是给对象定义一些自己的特征,不能有返回值 继承 代码的重用 单继承 多继承 2.7的经典类-->深度优先,新式类-->广度优先 3.x 均是广度优先 class Foo() 多态 接口重用,一种接口,多种实现 高级属性: 静态方法 与类无关,不