一、类与对象
类的定义
class OldboyStudent:
# 用变量表示特征
school="Oldboy"
def __init__(self,name,age,sex): #self=stu1 name= "马冬梅" age=18 sex="female"
self.name=name # stu1.name = "马冬梅"
self.age=age # stu1.age = 18
self.sex=sex # stu1.sex = "female"
# 用函数表示技能
def learn(self):
print('is learning...',self)
def choose(self):
print('choose course...')
stu1=OldboyStudent()
stu1.NAME='马冬梅'
stu1.AGE=18
stu1.SEX="female"
print(stu1.NAME,stu1.school)
#以上方法是在产生对象之后方能为对象增加属性，而实际情况更多的是希望在产生对象的过程中为对象增加属性
调用类发生哪些事：
1、首先会产生一个空对象stu1
2、会自动触发类内部的__init__函数
3、然后将空对象stu1连同调用类时括号内的参数组成（stu1,"马冬梅",18,'female'）,将这四个参数一起传给__init__函数
stu1=OldboyStudent("马冬梅",18,'female') #OldboyStudent.__init__(stu1,"马冬梅",18,'female')
stu2=OldboyStudent("甜蜜蜜",21,'male') #OldboyStudent.__init__(stu2,"甜蜜蜜",21,'male')
stu3=OldboyStudent("原石开",22,'male')
print(stu1.name,stu1.age,stu1.sex)
# .左边一定是一个名称空间。.右边是属性
二、对象的使用
school='xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
class OldboyStudent:
school='oldboy'
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
def learn(self):
print('%s is learning' %self.name)
def choose(self,course):
print('%s is choosing %s' %(self.name,course))
调用类---》产生类的对象，该对象也可以称为类的一个实例，调用类的过程也称为类的实例化
stu1=OldboyStudent('李三胖',18,'male') #OldboyStudent.__init__(stu1,'李三胖',18,'male')
stu2=OldboyStudent('王大炮',28,'male')
先在对象的名称空间中查找，若查不到接着去类的名称空间中查找，若依然查不到则报错，不会去全局名称空间中查找。
print(stu1.school) #但前缀，只在对象及类的名称空间查找
print(school) #不带前缀，查的是全局名称空间中的名字
类内部定义的变量是给所有对象共享，所有对象指向的都是同一个内存地址
print(id(stu1.school))
print(id(stu2.school))
print(id(OldboyStudent.school)) #以上三者的id一致
类内部定义的函数，类可以使用，但类来用的时候就是一个普通函数，普通函数有几个参就传几个参数
print(OldboyStudent.learn)
OldboyStudent.learn(123)
类内部定义的函数，其实是给对象使用的，而且是绑定给对象用，绑定给不同的对象就是不同的绑定方法(bound method)
print(stu1.learn)
print(stu2.learn)
绑定方法的特殊之处在于，谁来调用，就会将谁当作第一个参数自动传入
三、一切皆对象
class OldboyStudent:
school='oldboy'
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
def learn(self):
print('%s is learning' %self.name)
def choose(self,course):
print('%s is choosing %s' %(self.name,course))
stu2=OldboyStudent('王大炮',28,'male')
print(id(stu2))
print(type(stu2)) # 类与类型是一个概念(在python3中，统一了类与类型的概念)
l1=[1,2,3] #l1=list([1,2,3])
print(type(l1)) # class list
l1.append(4) #list.append(l1,4)
print(l1)
l2=['a','b','c']
l2.append('d') # list.append('d')
print(l2)
print(int)
print(str)
print(dict)
print(tuple)
print(set)
print(OldboyStudent)
四、小练习
class Foo:
n=0
def __init__(self):
Foo.n+=1 # Foo.n=3 #必须用Foo，否则不共享
增删改查
class Bar:
n=1111111111
def __init__(self,x):
self.x=x
obj=Bar(111)
print(obj.__dict__)
print(obj.n)
obj.y=2
obj.n=3
print(obj.__dict__)
print(obj.n)
obj.x=123
del obj.x
print(obj.x)
人狗大战
class People:
def __init__(self, name, aggresivity, life_value=100):
self.name = name
self.aggresivity = aggresivity
self.life_value = life_value
def bite(self, enemy): #self=p1 enemy=d1
enemy.life_value-=self.aggresivity
print("""
人[%s] 咬了一口狗 [%s]
狗掉血[%s]
狗还剩血量[%s]
""" %(self.name,enemy.name,self.aggresivity,enemy.life_value)
)
class Dog:
def __init__(self, name, dog_type, aggresivity, life_value):
self.name = name
self.dog_type = dog_type
self.aggresivity = aggresivity
self.life_value = life_value
def bite(self, enemy): #self = d1 enemy= p1
enemy.life_value-=self.aggresivity
print("""
狗[%s] 咬了一口人 [%s]
人掉血[%s]
人还剩血量[%s]
""" %(self.name,enemy.name,self.aggresivity,enemy.life_value)
)
p1 = People('刘清政', 60)
d1=Dog('李杰',"藏獒",200,200)
p1.bite(d1)
d1.bite(p1)
总结：
一、类的实例化：调用类产生对象的过程称为类的实例化，实例化的结果是一个对象，或称为一个实例
class People:
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
def run(self):
print('%s is running' %self.name)
实例化做了三件事
1、先产生一个空对象
2、自动触发类内部__init__函数的执行
3、将空对象，以及调用类括号内传入的参数，一同传给__init__，为对象定制独有的属性
obj=People('egon',18,'male') #People.__init__(obj,'egon',18,'male')
会产生对象的名称空间,如何查看
print(obj.__dict__)
二；对象的操作
print(obj.name) #obj.__dict__
obj.education='哈佛'
del obj.name
obj.age=19
print(obj.__dict__)
三：对象属性的查找顺序:先找对象自己的名称空间----》类的名称空间
class People:
x=1
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
def run(self): #self=obj
print('%s is running' %self.name) #obj.name
obj=People('egon',18,'male') #People.__init__(obj,'egon',18,'male')
obj1=People('egon1',18,'male') #People.__init__(obj,'egon',18,'male')
obj2=People('egon2',18,'male') #People.__init__(obj,'egon',18,'male')
1、类的数据属性:是给对象用的，而且直接共享给所有对象用的，内存地址都一样
print(People.x)
People.x=11111
print(id(People.x),People.x)
obj.x='obj================》'
print(id(obj.x),obj.x)
print(id(obj1.x),obj1.x)
print(id(obj2.x),obj2.x)
2、类的函数属性：也是给对象用，但是绑定给对象用的，绑定到不同的对象就是不同的
绑定方法，内存地址都不一样，但其实只想都是同一个功能
print(People.run) #<function People.run at 0x00000226E7C78A60>
People.run(123123)
People.run(obj)
print(obj.run)
print(obj1.run)
print(obj2.run)
四：绑定方法的特殊之处：
1、 绑定给谁就应该由谁来调用，
2、谁来调用就会把谁当做第一个参数传入
class People:
x=1
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
def run(self): #self=obj
print('%s is running' %self.name) #obj.name
def f1():
print('from f1')
def f2(self):
pass
obj=People('egon',18,'male') #People.__init__(obj,'egon',18,'male')
obj1=People('egon1',18,'male') #People.__init__(obj,'egon',18,'male')
obj2=People('egon2',18,'male') #People.__init__(obj,'egon',18,'male')
obj.run()
obj1.run()
obj2.run()
print(People.f1)
People.f1()
print(obj.f1)
obj.f1() #People.f1(obj)
五：一切皆对象:在python3中统一了类与类型的概念，类即类型
l=list([1,2,3])
print(type(l))
print(type(obj))
l.append(4)