类和对象

类和对象

返回首页

类

类型class就是类，在类里面定义函数和变量。

class Garen:
    camp='Demacia'
    def attack(self):
        print('attack')

#如何使用类
#一：实例化
# x=int(10)
# print(x)

# obj=Garen() #实例化
# print(obj)

#二：引用类的特征（类的变量）和技能（类的函数）
print(Garen.camp) #调用类的特征
print(Garen.attack) #调用类的技能
Garen.attack(1231231)  

如何使用类的实例化

####如何使用实例
class Test:
    camp='三国'
    def __init__(self,nickname):
        """
        init的作用：self.nick是给自己定义了一个别名，叫nickname
        实例化Test(),就会自动触发__init__方法的执行。
        :param nickname:
        """
        self.nick=nickname  #g1.nick='曹操' self是自己，self.nick=nickname就是给自己定义一个别名
    def attack(self,enemy):
        # print('---------->',self.nick) #g1.nick
        print('%s attack %s' %(self.nick,enemy))

g1=Test('曹操')  #Test.__init___(g1,'曹操')
g2=Test('司马懿')  #g1和g2都在使用Test类，但是因为参数不同，结果也就不同。但g1和g2都可以使用Test类的方法。
print(g1.nick) #获取g1的nickname，也既是self.nick的名字
print(g2.nick)
print(g1.camp) #打印g1的类型
print(g2.camp)
g1.attack('刘备') #实例化，加（）就能运行
print(g1.attack) #打印的是绑定方法，绑定给g1
print(Test.attack) #打印的是attack函数，就是Test类的attack函数，没有任何绑定
# Test.attack()  #调用的是函数，但因为attack需要参数，所以调用时没有传参会报错
Test.attack(g1,"诸葛")
# g1.attack()  #self=g1 g1是一个实例对象，g1.attack是一种以绑定方法，调用attack的方式，因为attack定义了参数，所以依旧需要传参
####Test.attack 和 g1.attack 的区别是Test.attack如何没有定义参数但有init，也必须传参，而g1.attack如何没有定义参数而有init的前提下，
##### 不需要传参也能被调用。
g1.attack("蜀")

总结：
类：一：实例化，二：引用名字（类名.变量名，类名.函数名）
实例：引用名字（实例名.类的变量，实例名.绑定方法，实例名.实例自己的变量名）

对象

对象也称为实例

class Student:
    country = 'China'

    def __init__(self, ID, NAME, SEX, PROVINCE):
        self.id = ID
        self.name = NAME
        self.sex = SEX
        self.province = PROVINCE

    def search_score(self):
        print('tell score')

    def study(self): #self=s1
        print('study',self)

s1 = Student('371818181818181', 'cobila', 'female', 'shanxi')

对象也称为实例
对象的属性：对象本身就只有特征（变量）

对象的用法：属性引用
print(s1.id,s1.name,s1.sex,s1.province)
s1.weight=100

weight=1111111111111111111111111111111111111111111111
print(s1.weight)
# del s1.weight
# print(s1.weight)

s1.id=123
print(s1.id)

 

面向对象的程序设计OOD   找对象 ---》找类（归纳对象相同的特征和技能，还有每个对象独有的特征）

面向对象编程OOP    先定义类 ---》实例化出对象

定义对象：

　　1）先有共同的特征。   2）在有共同的技能。   3）在有独有的特征。

#对象：学生---->归类
    #共同的特征：
    #共同的技能：search_score,handin
    #独有的特征：学号，名字，性别，课程
class Student:
    """
    学生类
    """
    def __init__(self,ID,name,sex):
        self.id=ID
        self.name=name
        self.sex=sex
        self.course_list=[] #课程列表
    def search_score(self):
        print("tell socre")

    def handin(self):
        pass

对象的属性：对象的本身就只有特征（变量）

对象的用法：属性引用

#对象：学生---->归类
    #共同的特征：
    #共同的技能：search_score,handin
    #独有的特征：学号，名字，性别，课程
class Student:
    """
    学生类
    """
    def __init__(self,ID,name,sex):
        self.id=ID
        self.name=name
        self.sex=sex
        self.course_list=[] #课程列表
    def search_score(self):
        print("tell socre")

    def handin(self):
        pass

class Course:
    def __init__(self,name,price,period):
        self.name=name
        self.price=price
        self.period=period

s1=Student('123123123123','cobila','female')
print(s1.id,s1.name,s1.sex)
print(s1.course_list)
s1.search_score()
s1.course_list.append('python')
s1.course_list.append('linux')
print(s1.course_list)

 

新式类和经典类：在python3中，所有的类，都是新式类

经典类：

class 类名:
    pass

 

新式类：新式类必须继承至少一个父类。

class 类名（父类）：
    pass

类名.__bases__ 可以查看继承的类

class A:pass
print(A.__bases__)

#在python2中，新式类
class B(object):pass
class C(B):pass

print(B.__bases__)
print(C.__bases__)

#在python2中，经典类
class D:pass
print(D.__bases__)

 

类的名称空间与对象的名称空间

x=123123123123
class Student:
    country = 'China'

    def __init__(self, ID, NAME, SEX, PROVINCE):
        self.id = ID
        self.name = NAME
        self.sex = SEX
        self.province = PROVINCE


    def search_score(self):
        print('tell score')

    def study(self): #self=s1
        print('study',self)
    def walk(self):
        print('name:%s is walking' %self.name)

s1 = Student('371818181818181', 'cobila', 'female', 'shanxi')
s2 = Student('371818181sadf818181', 'cobilamei', 'femaleasfd', 'shasdfanxi')

# print(Student.__dict__) #查看类的名称空间
# print(Student.country)
# print(s1.__dict__)#查看对象的名称空间
# print(s1.id)
# s1.country="123123123"
# print(id(s1.country))
# print(id(s2.country))
# print(id(Student.country))print(s1.study,id(s1.study))
print(Student.study,id(Student.study))
#绑定方法的核心在于‘绑定’，唯一绑定一个确定的对象
s1.walk()
s2.walk()

 

 

----------- END -----------