Python基础语法第11节课（类对象）

一、类、对象的概念

类

1.什么是类？种类/分类 class

2.什么样的东西可以形成一个类? 人类禽类兽类

为什么可以分为类？因为他们有相似点，共同之处

　举例：男人类（共同的特质是男士） girl类（共同的特质是女士）

3.类是 具有相同特征或者相同行为的群体

对象

1.什么是对象？object 又被称为实例 instance

object：东西事物

2.对象是群体类当中的成员、个体

举例：男人类里面的对象：爸爸，爷爷，老公，儿子

二、类和对象在python当中的表示

1.类的定义

class 类名：----------类名后面不需要加（）了

　　类的组成部分

举例：

class man:

　　pass

2.类的调用

①类的调用表示：

print(类名)

变量 = 类名

②<class '__main__.Man'>

上面这样，看到有<>括号的，一般来说就是一个类/对象。

class Man:
    pass
# 类的调用
new_man = Man
print(new_man)
print(Man)
'''
<class '__main__.Man'>
<class '__main__.Man'>

'''

3.对象的表示方法------类名（）

class Man:
    pass
print(Man())
'''
<__main__.Man object at 0x000002067D1B3DC8>-------→表示man类里面的对象object
'''

4.经典面试题

class Man:
    pass
a = Man()
b = Man()
print(a)
print(b)
'''
<__main__.Man object at 0x0000013DC7903E08>
<__main__.Man object at 0x0000013DC78FE6C8>
'''

上述a,b是不同的对象，内存地址是不一样的，可以用is来判断下

print(a is b)
print((Man) is Man())
#False
#False

如何去进一步确认两个对象是不是同一个？打印他们的id看一下

#何去进一步确认两个对象是不是同一个？打印他们的id看一下
print(id(a))
print(id(b))
'''
1736456595144
1736456604104
'''

5.类的命名规则---大驼峰命名，即两个单词的首字母大写BigBoss 、 PerfectMan

函数的命名：下划线命名，即两个单子之间是加下划线def big_boss()

变量的命名：下划线命名，即两个单子之间是加下划线big_boss

6.先有类，才会生出一个一个的对象

#定义一个Cat类
class Cat:
    pass


#生成对象加菲猫  tom猫 蓝猫
jiafei = Cat()
Tom = Cat()
blue = Cat()
print(jiafei)
print(Tom)
print(blue)
'''
<__main__.Cat object at 0x000002077742A248>
<__main__.Cat object at 0x000002077742A288>
<__main__.Cat object at 0x000002077742A2C8>
'''

7.属性-----表示类和对象的特征

类属性实例属性的区别（面试题）

♥ ♥类属性（类变量）：这个类的特征，这个群体的特征，别的类（别的群体可能不具备），所有的成员都是一样的。

实例属性（实例变量）：这个个体的特征，类当中的其他成员可能不具备

♥ ♥ 类属性可以被实例、对象访问

实例属性不能被类获取

举例：类属性，所有的成员都是一样的

class Man:
    #定义类属性
    power = 'strong'
    gender = '男'
    
polo = Man()
Tom = Man()
#下面的类属性power，所有的成员都是一样的
print(polo.power)
print(polo.power)

举例，实例属性，不是每个人都一样，AttributeError 属性错误

class Man:
    #定义类属性
    power = 'strong'
    gender = '男'
    
polo = Man()
Tom = Man(）

polo.eye = 'big'  #eye是polo这个实例的属性
print(polo.eye)
print(Tom.eye)#AttributeError: 'Man' object has no attribute 'eye'

举例，实例属性不能被类获取

class Man:
    #定义类属性
    power = 'strong'
    gender = '男'
    
polo = Man()

polo.eye = 'big'  #eye是polo这个实例的属性
print(polo.eye)

print(Man.eye)#类不能获取实例属性

①类属性的获取

语法类.属性

类属性的定义：可以先天定义也可以后天添加

♥先天定义：

class 类名：

　　类属性1 = 属性值

♥后天添加：（不建议这么用）

类名.新类属性 = 属性值

#类属性的获取
class Man:
    #定义类属性（这里定义的类属性的先天就有的，）
    power = 'strong'
    gender = '男'
print(Man.gender)#Man类的gender属性，结果是男
print(Man.power)#Man类的power属性，结果是strong

#添加类属性（添加的类属性是类后天学习到的，即手工添加的）
Man.hello= 'hello world'
print(Man.hello)

②实例属性的获取

什么是初始化？

要通过定义的类得到一个具体的对象。生出一个对象

对象个体，初始化过程保证生出来是不一样的。（自己给东西进行出厂设置）

♥ 特点的方法中去控制：

_ _init_ _(self) :在这里设置先天的属性

♥ self: 在类里面，表示一个对象它自己，只能代表它一个

先天设置的实例属性：self.属性 = 参数

语法：def _ _init_ _ (self，name):

　　　　　　self.name = name

这个是实例方法，在实例方法里面设置实例属性。就是对象的初始化过程，让每个对象的属性不太一样

class Man:
    #定义类属性
    power = 'strong'
    gender = '男'

    def __init__(self,face_shape,name):
        #对象的实例化过程
        #定义在类里面，定义实例属性用self.属性 = 参数
        self.face = face_shape
        self.name  = name

polo = Man('圆脸','polo')
print(polo.face,polo.name)

_ _init_ _ (self) 里面的参数跟实际调用时传入的参数要一一对应。（位置参数一一对应）

举例，形式参数里设置默认参数

class Man:
    #定义类属性
    power = 'strong'
    gender = '男'

    def __init__(self,name,face_shape = '圆脸'): #默认参数要放在位置参数的后面
        #对象的实例化过
        #定义在类里面，定义实例属性用self.属性 = 参数
        self.face = face_shape
        self.name  = name
polo = Man('polo','方脸')
print(polo.face,polo.name)
'''
方脸 polo
'''

先天设置好实例属性，可以后天修改（整容的权利）

class Man:
    #定义类属性
    power = 'strong'
    gender = '男'

    def __init__(self,name,face_shape = '圆脸'): #默认参数要放在位置参数的后面
        #对象的实例化过
        #定义在类里面，定义实例属性用self.属性 = 参数
        self.face = face_shape
        self.name  = name
polo = Man('polo','方脸')
print(polo.face)
polo.face = '帅脸'
print(polo.face)
'''
方脸
帅脸
'''

_ _init_ _ (self) 总结：

♥必须return None（不写就是return None，写一个return，也会返回None。return 其他值会报错）

♥传入的参数必须设置为实例属性，才能被对象访问到

实例方法中的self调用_ _init_ _ 的实例属性

class Man:
    #定义类属性
    power = 'strong'
    gender = '男'

    def __init__(self,name,face_shape ):
        self.face = face_shape
        self.name  = name

    def drink(self,brand):
        print('{}正在喝{}酒'.format(self.name,brand))#如果没有self,就没法调用name

polo = Man('polo','方脸')
print(polo.drink('茅台'))
'''
polo正在喝茅台酒
None
'''

一个实例方法可以调用别的实例方法，也可以调用类方法（python的运行机制：运行时会先读顶格代码）

class Man:
    #定义类属性
    power = 'strong'
    gender = '男'

    @classmethod
    def eat(cls):
        print('在吃东西')

    def __init__(self,name,face_shape ):
        self.face = face_shape
        self.name  = name

    def drink(self,brand):
        print('{}正在喝{}酒'.format(self.name,brand))#如果没有self,就没法调用name
        self.play_game() #play_game()在后面也会正常调用到
        self.eat()#实例方法可以调用类方法

    def play_game(self):
        print('在玩游戏')

polo = Man('polo','方脸')

print(polo.drink('茅台'))
'''
polo正在喝茅台酒
在玩游戏
在吃东西
None
'''

后天学习获取（类外面，对象名.属性）

#实例属性的后天学习，获取
zhangsan = Man()
zhangsan.handsome = 'very handsome'
print(zhangsan.handsome)
lisi = Man()
print(lisi.handsome)#报错
lisi.handsome = 'just soso'#先后天学习，再获取
print(lisi.handsome)

#如何让所有类里面的人都是very handsome，

class Man:
    #定义类属性
    power = 'strong'
    gender = '男'
    handsome = 'very handsome'#very handsome加在类属性里面
zhangsan = Man()
lisi = Man()
print(zhangsan.handsome)
print(lisi.handsome)

总结：属性

先天具备的属性，不管是类属性，实例属性，都是在类名下面，__init__直接定义好。

后天培养的属性，不管是类属性，实例熟悉，都可以在其他的方法中定义/类外面定义（不建议使用，万不得已才会用）

6.方法--------表示类、对象的行为

方法再本质上是函数

属性名称：名词

方法是动词

①方法 VS 函数区别

♥ 方法：self

♥ 方法：放在类里面、缩进

♥ 调用过程不一样，方法需要加前缀，类名或对象名：对象.方法（）

　　　　　　　　函数前面要么不加，要么加导入的模块名称

class Man:
    #定义类属性
    power = 'strong'
    gender = '男'

    def Play_game(self):
       '''玩游戏'''
       pass
#对象.方法()
print(Man().Play_game())
#实例方法
polo = Man()
print(polo.Play_game())

②实例方法对象方法

♥ 第一个参数名称规定是self

♥实例方法的调用：只能被实例/对象调用

举例：实例方法在调用的时候，前缀是对象，不能是类

class Man:
    #定义类属性
    power = 'strong'
    gender = '男'

    def Play_game(self):
       '''玩游戏'''
       pass
    def drink(self):
        '''喝酒'''
        pass
#drink()是实例方法，是属于某个人的，不能被类调用
print(Man.drink())

实例方法中定义个实例属性，调用的时候，不能直接调用这个属性，要先调用这个方法，在调用属性

class Man:
    #定义类属性
    power = 'strong'
    gender = '男'

    def __init__(self,name,face_shape ):
        self.face = face_shape
        self.name  = name

    def drink(self,brand):
        print('{}正在喝{}酒'.format(self.name,brand))#如果没有self,就没法调用name
        self.single = False
 
polo = Man('polo','方脸')

polo.drink('茅台')
print(polo.single)

③类方法------在定义的方法上面加上@classmethod ,@表示装饰器 decorator

　　　　　　将方法中的 self 改为 cls

类方法的调用：实例和类都可以调用。

注意：如果不加@classmethod，就是个实例方法了

class Man:
    #定义类属性
    power = 'strong'
    gender = '男'

    @classmethod   #@表示装饰器 decorator
    def eatfood(cls):  #cls就是class的缩写
        print('在吃东西')

print(Man.eatfood())
'''
在吃东西
None # 类方法没有return，返回值是none,print会打印方法的返回值
'''

cls 表示：类，它自己，类方法可以调用类属性（下面黄底代码）

class Man:
    #定义类属性
    power = 'strong'
    gender = '男'

    @classmethod
    def eat(cls):
        print(cls.power)
        print('在吃东西')

    def __init__(self,name,face_shape ):
        self.face = face_shape
        self.name  = name

    def drink(self,brand):
        print('{}正在喝{}酒'.format(self.name,brand))#如果没有self,就没法调用name
        self.play_game() #play_game()在后面也会正常调用到
        self.eat()#实例方法可以调用类方法

    def play_game(self):
        print('在玩游戏')

polo = Man('polo','方脸')

print(polo.drink('茅台'))
'''
polo正在喝茅台酒
在玩游戏
strong
在吃东西
None
'''

④静态方法

♥ 静态方法的表示：在方法的上面加上@staticmethod

　　　　　　　　　不需要用self ,cls作为固定参数，如果有别的参数要传，就正常传参即可。

♥ 静态方法是什么？

1）是刚好放在类里面的普通函数而已，除了放在类当中，和普通函数没什么区别

（拿出类，就是个函数，放在类里，就必须加@staticmethod才能调用这个方法）

2）没有什么作用，和类对象没有关系

　　 3）为什么要用静态方法？为啥把普通函数放在类里面------方便管理，在指定的类里找就行了（不用也是可以的。）

♥ 调用静态方法-----类、对象都可以调用

即调用静态方法，只需要在静态方法前面加类名或对象名

class Man:
    #定义类属性
    power = 'strong'
    gender = '男'

    @staticmethod
    def hello(): #没有固定参数self
        print('在学习python')

print(Man.hello())
print(Man().hello())
'''
在学习python
None
在学习python
None

'''

⑤@property ：设置只读属性（只能读，不能改）---防止这个属性被被人篡改，设置为只读属性，比较安全。

被property装饰的方法，调用的时候，不需要加（），举个栗子：

class Play():

    def __init__(self,name):
        self.name = name


    def sing(self,sang_name):
        print(f"{self.name}正在唱{sang_name}歌")

    @property
    def dance(self):
        print(f"{self.name}正在跳舞")
        return "amazing"

#初始化类对象zhangsan
player = Play("zhangsan")
player.name = "lisi"  #修改实例属性的name为lisi
print(player.name)  #output:lisi

#访问只读属性dance
print(player.dance) #output ：amazing
player.dance = "good"
print(player.dance)  #AttributeError: can't set attribute

类使用总结：

1.实际使用过程中，实例方法占98%，实例方法占大多数情况，工作中不知该定义为什么方法，直接定义为实例方法。

2.静态方法：可以用普通函数替代，不是必须的（方便管理）

类知识点总结

1.实例属性和类属性的区别

实例可以获取实例属性和类属性

类只能获取类属性

2.方法

实例方法实例具备的，类不一定具备

类方法类具备的，实例可以获取

静态方法放在类里面的函数

3._ _init_ _

是对象的初始化过程。通常在里面定义实例属性

实例属性的值通过参数传递进来（参数必须要赋值时实例属性 self.属性 = 参数）

4.self 类定义的里面对象

　cls 类里面表示类

5.♥♥面试题.如果一个属性名，既是类属性，又是实例属性，实例优先访问实例属性

class Man:
    name = 'boy'

    def __init__(self,name):
        self.name = name

print(Man.name)
print(Man('polo').name)#实例优先访问实例属性
'''
boy
polo
'''

6.如果在一个具体的场景中，不知道是用类属性还是实例属性，-----→就用实例属性

posted on 2020-05-18 00:08 ananmy 阅读(371) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

导航

Python基础语法 第11节课（类 对象）

Python基础语法第11节课（类对象）