python12_类和对象（二）

目录

1.类函数的进阶学习

1.1  类函数不带任何参数

1.2  类函数调用类属性

1.3  类函数带有位置参数

1.4 类函数带有默认参数

1.5 类函数之间的相互调用

1.5.1  类函数内调用不带参数的类函数

1.5.2 类函数内调用带参数的类函数

1.6 类函数带有动态参数

1.7 类函数带有关键字参数

2. 类的初始化函数__init__()

2.1 初学初始化函数

2.2  类函数调用初始化值

3.静态方法

---

1.类函数的进阶学习

1.1  类函数不带任何参数

在类和对象（一）中编写的小汽车类，可以看到，类里面的函数是不带任何参数的，  这个就是最简单的函数，只实现最简单的功能。

1.2  类函数调用类属性

仍以小汽车类为例，示范代码如下：

class Car:
    # 类的属性
    can_running = True
    engine = True
    wheel = True
    fly = False
    color = '白色'
    # 类的方法
    def run(self):
        print('一辆{}颜色的车在跑。。。'.format(self.color))

创建实例，调用类函数：

# 创建对象
my_car = Car()
# 实例调用类的方法
my_car.run()

由此我们可以总结出：

• 如果类函数里面要调用类属性，必须要在类属性之前加self关键字，调用方法是：self.类属性名。
• self  是用来在类的内部来表示对象的一个标记；在类里面用self表示 一个对象。

1.3  类函数带有位置参数

类函数其实跟学习的普通函数是没有区别的，只是在编写类函数的时候，需要在函数后面的括号里面，传入一个self关键字。这就是唯一跟普通函数的区别。示范代码如下：

class Car:
    # 类的属性
    can_running = True
    engine = True
    wheel = True
    fly = False
    color = '白色'
    # 类的方法
    def run(self,color):
        print('一辆{}颜色的车在跑。。。'.format(color))

创建实例，调用类函数：

# 创建对象
my_car = Car()
# 实例调用类的方法
my_car.run('蓝色')

可以看到类函数，即使加了位置参数，跟普通函数也是没有任何区别的，只是多了一个self关键字以及类函数必须是创建实例才能完成调用。

1.4 类函数带有默认参数

根据1.3的示例，我们可以总结出类函数其实跟普通函数是没有区别的，所以继续学习函数中的其他几种类型的参数，把位置参数参加一个默认值，示范代码如下：

class Car:
    # 类的属性
    can_running = True
    engine = True
    wheel = True
    fly = False
    color = '白色'
    # 类的方法
    def run(self,color='黑色'):
        print('一辆{}颜色的车在跑。。。'.format(color))

创建实例，调用类函数：

# 创建对象
my_car = Car()
# 传入参数
my_car.run('黄色')
# 不传入参数
my_car.run()

可以看到类函数中的位置参数如果带有默认参数，那么在创建实例调用函数的时候，如果传了值运用用户传入的值，如果没有传值，就会自动使用默认参数。

1.5 类函数之间的相互调用

1.5.1  类函数内调用不带参数的类函数

跟普通函数一样，类函数里面也可以调用别的类函数，示范代码如下：

class Car:
    # 类的属性
    can_running = True
    engine = True
    wheel = True
    fly = False
    color = '白色'
    # 类的方法
    def run(self,color='黑色'):
        print('一辆{}颜色的车在跑。。。'.format(color))
        # 调用类函数 cant_fly
        self.cant_fly()

    def cant_fly(self):
        print('我不会飞~')

 创建实例，调用类函数：

# 创建对象
my_car = Car()
# 传入参数
my_car.run('黄色')

可以看到类函数里面调用其他的类函数，跟普通函数调用，并无区别，只是需要在函数之前加入关键字：self。

1.5.2 类函数内调用带参数的类函数

class Car:
    # 类的属性
    can_running = True
    engine = True
    wheel = True
    fly = False
    color = '白色'
    # 类的方法
    def run(self,color='黑色'):
        print('一辆{}颜色的车在跑。。。'.format(color))

    def cant_fly(self,color):
        self.run(color)
        print('我不会飞~')

 创建实例，调用类函数：

# 创建对象
my_car = Car()

# 实例调用类的方法
my_car.cant_fly('黄色')

可以看到，如果要类函数内部需要调用某个带参数的类函数，那么就需要改写类函数，要带上被调用类函数的参数，否则调用会失败报错。

1.6 类函数带有动态参数

类函数中带有动态参数，示范代码如下：

class Car:
    # 类的属性
    can_running = True
    engine = True
    wheel = True
    fly = False
    color = '白色'
    # 类的方法
    def run(self,*args):
        for color in args:
            print('一辆{}颜色的车在跑。。。'.format(color))

  创建实例，调用类函数：

# 创建对象
my_car = Car()

# 实例调用类的方法
my_car.run('粉色','黑色','蓝色','黄色')

总结：带有动态参数的类函数与带有动态参数的普通函数用法以及传递参数用法，并无区别， 

1.7 类函数带有关键字参数

类中带有关键字参数，示范代码如下：

class Car:
    # 类的属性
    can_running = True
    engine = True
    wheel = True
    fly = False
    color = '白色'
    # 类的方法
    def run(self,**kwargs):
        print('一辆{}的车在跑。。。'.format(kwargs))

  创建实例，调用类函数：

# 创建对象
my_car = Car()

# 实例调用类的方法
my_car.run(颜色='黑色',品牌='特斯拉',车龄='1年')

总结：带有关键字参数的类函数与带有关键字参数的普通函数用法以及传递参数用法，并无区别。

2. 类的初始化函数__init__()

2.1 初学初始化函数

改写1.7中的类，引入初始化函数，示范代码如下：

class Car:
    # 类的属性
    def __init__(self,color,brand,age):
        self.color = color
        self.brand = brand
        self.age = age

    # 类的方法
    def run(self):
        print('车在跑。。。')

创建实例，调用类函数：

# 创建对象
my_car = Car('粉色','特斯拉','1年')

# 实例调用类的方法
my_car.run()

# 能通过对象调用的属性，就是实例属性
# 能通过类调用的属性，就是类属性
# 对象是可以调用类属性的,本质上通过对象获取类属性得到的还是实例属性

# 实例调用类的属性值
print(my_car.color)

通过上述调用：

• 发现只要类里面有__init__()函数，每当创建实例时，python都会自动运行它。
• 它是生成对象的过程,最好是__init__里面定义属性。
• 类和对象的优点：可以共享属性，不用传参数了。
• 能通过对象调用的属性，就是实例属性。
• 能通过类调用的属性，就是类属性。
• 对象是可以调用类属性的,本质上通过对象获取类属性得到的还是实例属性。
• 定义类的时候，如果你不知道类属性还是实例属性，直接定义实例属性就行。因为所有的类属性几乎都可以用实例属性来表示。

注意：

在这个方法的名称中，开头和末尾各有两个下划线，这是一种约定，旨在避免Python默认方法与普通方法名称冲突。

2.2  类函数调用初始化值

改写1.7中的类，引入初始化函数，示范代码如下：

class Car:
    # 类的属性
    def __init__(self,color,brand,age):
        self.color = color
        self.brand = brand
        self.age = age

    # 类的方法
    def run(self):
        print('一辆车龄为{}的{}{}在跑。。。'.format(self.age,self.color,self.brand))

创建实例，调用类函数：

# 创建对象
my_car = Car('粉色','特斯拉','1年')

# 实例调用类的方法
my_car.run()

如果类函数里面要调用初始化的值，可以直接调用，要记得加self关键字。

3.静态方法

面试的时候会问静态方法，简单描述一下，就是放在类当中的一个普通函数，加上@staticmethod，调用时加前缀。示范代码如下：

class Car:
    color = '蓝色'
    def __init__(self,color='黄色',brand='特斯拉'):
        """它是生成对象的过程"""
        print('正在生产对象')
        self.color = color
        self.brand = brand
        self.can_running = True
        self.engine = True

    # 声明这是一个类方法
    @classmethod
    def run(cls):
        print(cls)
        print(f'一辆{cls.color}颜色的车在跑……')

    # 声明这是一个静态方法
    @staticmethod
    def fix():
        print('正在修理')

    
    def helloword(self):
        print(self.engine)
        # 调用方法要用self.方法()
        self.run()

创建实例，调用类函数：

# 类调用静态方法
Car.fix()

# 实例调用静态方法
Car().fix()

总结：

• 静态方法，既可以通过类调用，也可以通过实例调用。
• 能调用类方法，也不能调用实例属性，比较鸡肋。
• 静态方法既不能获取实例，又不能获取类，没有实际的作用，只是放在类下面的一个普通的函数。
• 作用：方便管理。

面试会问：

• 实例方法：通过实例去调用
• 类方法：类的方法，通过类去调用的
• 静态方法：就是放在类当中的一个普通函数，加上@staticmethod，调用时加前缀