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

Posted ananmy

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了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
‘‘‘

 

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

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

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

 

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

#定义一个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>
‘‘‘

 

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

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

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

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

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

      实例属性不能被类获取

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

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

　　　　　　pass

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

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)




 


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

‘‘‘




 


类使用总结：


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


2.类方法后面课程有特殊情况介绍


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


       


 ♥类知识点总结


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


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


类  只能获取类属性


 


2.方法


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


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


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


 


3._ _init_ _


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


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


 


4.self 类定义的里面 对象


　cls  类里面  表示类


 
以上是关于Python基础语法 第11节课（类 对象）的主要内容，如果未能解决你的问题，请参考以下文章
 

 Python基础语法介绍 -  面向对象（下）和异常处理


 Python基础语法 第6节课（函数的定义函数的参数）


 python基础语法 第5节课      ( if  for )


 Python基础语法 第8节课（打开文件 ）


 Python基础语法 第8节课（打开文件 ）


 C++&Python基础│暑假科创技能培训