面向对象 （普通方法，魔术方法，静态方法，类方法）

类

1：所有的类名的首字母都要求是大写，多个单词使用驼峰式命名法

类的命名格式：

class Phone:
     #属性
    pass
     #方法

使用类创建对象

class Phone:
    brand = '华为'

#使用类创建对象
小明=Phone()
小红=Phone()
print(小明)
print(小红)

<__main__.Phone object at 0x000001A2B2C54390>
<__main__.Phone object at 0x000001A2B2CF7978>

当存在一些属性的时候在来创建对象看看

class Phone:
    brand = '华为'


yz=Phone()   #使用类创建对象
yz.brand
print(yz.brand)

ab=Phone()  #使用类创建对象
ab.brand
print(ab.brand)

华为
华为


class Phone:
    brand = '华为'


yz=Phone()   #使用类创建对象
# print(yz.brand)
yz.brand = 'iphone'   ###修改该对象的属性值
print(yz.brand)
ab=Phone()  #使用类创建对象
print(ab.brand)

iphone
华为

 

定义类和属性

对象在判断自己的属性的时候先查看自己是否存在该属性，如果没有的话再去类里面去找

class Student:
    name = 'dog'   ##类属性
    age =2


xiaowei=Student() ##使用Student类创建对象xiaowei
xiaowei.name = "pig"  ##对象属性
print(xiaowei.name)
print(xiaowei.age)

xiaoming = Student()
print(xiaoming.name)
print(xiaoming.age)

pig   ###发现对象在使用属性的时候先查看自己的空间中是否存在对应的熟悉，如果没有的话再去类中去找。
2
dog
2

 

类中的方法部分（动作）

种类：普通方法 类方法 静态方法 魔术方法

1：普通方法

#类中的方法：动作
#种类：普通方法 类方法 静态方法 魔术方法
class Phone:
    brand = '小米手机'
    price = '3500'

    def call(self):   ###定义一个call的方法
        print(self)   ###此处可以看出来，self就是对象，phone1和phone2
        print(self.note)  ###谁调用就拿谁的note瞒不过这里有一个要注意的，此处如果使用self.note，那么我传进来的self对象中必须都要有note属性，否则就会报错
        print(self.brand)


phone1 = Phone()  ##用Phone类创建一个对象
phone1.brand = 'huawei'  ##修改phone1的brand属性
# print(phone1.brand)
phone1.note = "我是phone1的通信录"  ##phone1的属性note
phone1.call()



phone2 = Phone()
print(phone2.price)
phone2.note = "我是phone2的通信录"   ##phone2的属性note
phone2.call()


<__main__.Phone object at 0x000002407FE15E80>
我是phone1的通信录
huawei
3500
<__main__.Phone object at 0x000002407FE15EF0>
我是phone2的通信录
小米手机

2：魔术方法

 

class Phooe:
    def __init__(self):  ###魔术方法
        print('--------------init')
    def call(self):
        print('--------------self')
        print('价格',self.price)   ###在ide集成环境中，此时的price下面其实是标成阴影的，因为在call函数中，当我传进来self的时候，并不知道我传进来的所有对象都有price这个属性

p1 = Phooe()
p2 = Phooe()

那么我们怎么去解决这个问题呢？ 此时就我们就会使用到魔术方法

class Phone:
    def __init__(self):  ###魔术方法
        self.brand = "小米"   ##用来做一个统一的，如果我传递给call函数的对象没有brand，price属性，则会给它进行赋值之歌默认的，保证代码不会出错。
        self.price = 4399
    def call(self):
        print('价格为{}'.format(self.price))

p1 = Phone()
p1.price= 5999   ###如果对象中定义了对象的属性，那么就不会只要默认，而是使用我对象自带的那个属性
p1.call()


p2 = Phone()
p2.call()

价格为5999
价格为4399

 

魔术方法和普通方法接受参数的情况

##在类中定义的对象的属性等级是最低的，其次是在魔术方法中，优先级最高的是在对象中定义的属性
class Person:
    name = '小p'
    def __init__(self,name,age): ###接受来自对象的参数
        self.age = age
        self.name = name
    def eat(self,food):
        print("{}爱{}".format(self.name,food))  ##记住此时传进来的food的参数只是一个普通的参数，不是对象自身的属性，所以不是self.food
    def run(self):
        print("{}今年{}岁爱跑步".format(self.name,self.age))

p1=Person('小光',20) ##此处就必须要加上与魔术方法对应的参数
# p1.name = "小明"
p1.run()
p1.eat("臭豆腐")

p2=Person('小黑',19)
p2.eat("炸酱面")
p2.run()


小光今年20岁爱跑步
小光爱臭豆腐
小黑爱炸酱面
小黑今年19岁爱跑步

3：类方法

1：定义的时候依赖装饰器@classmethod

2：类方法中的参数不是一个对象而是你定义的类

print(cls)      <class '__main__.Dog'>  ###打印出来是我定义的Dog类

3：类方法中只能使用我的类熟悉，就是我类中定义的属性，在对象中定义的属性不可以使用

4：在类方法中不能使用普通方法

 

类方法的作用：因为其只能访问类熟悉和类方法，如果需要在对象创建之前，需要创建一些动作（功能），此时就可以使用类方法。

 

class Dog():  ###定义的Dog类
    price = 3000  ##定义的类熟悉
    age = 4

    def __init__(self,name,color):  ##魔术方法
        self.name =  name
        self.color = color

    def buy(self):  ##buy方法
        print("当时买的时候{}元".format(self.price))

    def eat(self,food):  ##eat方法
        print("{}爱吃{}".format(self.name,food))
        self.buy()  ###在一个方法中，调用另一个方法，需要使用self然后进行调用

    def sleep(self,time):  ##sleep方法
        if time > 5:
            print("{}快起来去干活，你都睡了{}小时了".format(self.name,time))
    
    @classmethod   ###定义的类方法
    def test(cls):
        print(cls)
        print("今年{}岁了".format(cls.age))  ##这里面传入的参数只能是类中定义的属性，比如price和age


dog = Dog("小黄","黄色")
# dog.price = 4000
dog.buy()
dog.eat("鸡腿")
dog.sleep(8)
dog.test()


当时买的时候3000元
小黄爱吃鸡腿
当时买的时候3000元
小黄快起来去干活，你都睡了8小时了

<class '__main__.Dog'>
今年4岁了

 

类方法补充

场景：不依赖于对象，修改类中的属性

###在我还没有创建对象之前就对类的属性进行了修改
class Person:
    age = 18

    @classmethod
    def update_age(cls):
        cls.age += 1
        print("年龄是{}".format(cls.age))

Person.update_age()


年龄是19 

 

静态方法

1：很类似于类方法

2：需要装饰器@staticmethod

3：静态方法不需要传递参数（self，cls）

4：也只能访问类的属性和方法，对象的是无法进行访问的

5：加载实际需要同类方法

 

总结：类方法和静态方法比较

不同：

• 装饰器不同
• 类的方法是需要参数的，静态方法没有参数

相同：

• 只能访问类的属性和方法，对象的是无法进行访问的
• 都可以通过类名进行调用访问
• 都可以在创建对象之前使用，因为都是不依赖于对象的

 

普通方法与两者的区别

• 普通方法没有装饰器
• 普通方法都是要依赖于对象的，因为每个普通方法都是有一个self的，只有创建了对象才可以调用普通方法，否则无法使用