python基本语句详情讲解-第五弹！

一、面向对象

                面向对象是把构成问题的事务分解成各个对象，每个对象都有自己独立的属性和行为, 对象可以将整个问题事务进行分工, 不同的对象做不同的事情, 这种面向对象的编程思想由于更加贴近实际生活, 所以被计算机语言广泛应用。

常见的面向对象编程语言：Java / C++ / Python等等；

        面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。

面向过程：C

总之，Python中万事万物皆对象，而面向对象的三大特性：封装、继承和多态。

二、类的定义

                Python 中定义一个类使用 class 关键字实现，其基本语法格式如下：

class 类名：
    多个（≥0）类属性...
    多个（≥0）类方法...

注意，无论是类属性还是类方法，对于类来说，它们都不是必需的，可以有也可以没有。另外，Python 类中属性和方法所在的位置是任意的，即它们之间并没有固定的前后次序。

和变量名一样，类名本质上就是一个标识符，因此我们在给类起名字时，必须让其符合 Python 的语法。有读者可能会问，用 a、b、c 作为类的类名可以吗？从 Python 语法上讲，是完全没有问题的，但作为一名合格的程序员，我们必须还要考虑程序的可读性。

因此，在给类起名字时，最好使用能代表该类功能的单词，例如用Student作为学生类的类名；甚至如果必要，可以使用多个单词组合而成。

class Dog:
    name: str = "小黑"
    age: int = 2

注意，如果由单词构成类名，建议每个单词的首字母大写，其它字母小写；同属一个类的所有类属性和类方法，要保持统一的缩进格式，通常统一缩进 4 个空格

        1.实例化对象

                        对已定义好的类进行实例化，其语法格式如下：

类名(参数)

        定义类时，如果没有手动添加 __init__() 构造方法，又或者添加的 __init__() 中仅有一个 self 参数，则创建类对象时的参数可以省略不写。

# 1.实例化对象
# java方式：Dog d1=new Dog();
d1 = Dog()
d2 = Dog()
print(d1)
print(d2)

        2.类变量

                        类变量指的是在类中，但在各个类方法外定义的变量。举个例子：

class Dog:
    name: str="小花"
    type: str="金毛"
    age: int = 3

上述代码中，name和age都是类变量。

        类变量的特点是，所有类的实例化对象都同时共享类变量，也就是说，类变量在所有实例化对象中是作为公用资源存在的。类方法的调用方式有 2 种，既可以使用类名直接调用，也可以使用类的实例化对象调用。

• 通过类名调用类变量和修改类变量的值：

# 使用类名直接调用
print(f"name={Dog.name},type={Dog.type},age={Dog.age}")
# 修改类变量的值
Dog.name="钱多多"
print(Dog.name)

• 通过类对象来调用所属类中的类变量：(此方式不推荐使用)

# 实例化对象
d1 = Dog()
# 获取对象中的属性
print(f"name={d1.name},age={d1.age}")
# 修改对象中的属性
d1.name="小黑"
d1.gender="公"
print(f"name={d1.name},gender={d1.gender}")

注意：通过类对象是无法修改类变量的。通过类对象对类变量赋值，其本质将不再是修改类变量的值，而是在给该对象定义新的实例变量

• 所有类的实例化对象都同时共享类变量：

class Dog:
    name: str = "小黑"
    age: int = 3
​
d2 = Dog()
d3 = Dog()
print(d2.name)
print(d3.name)
Dog.name="小白"
print(d2.name)
print(d3.name)

显然，通过类名修改类变量，会作用到所有的实例化对象

        3.函数和实例变量

                       实例变量指的是在任意类方法内部，以“self.变量名”的方式定义的变量，其特点是只作用于调用方法的对象。另外，实例变量只能通过对象名访问，无法通过类名访问。

给类添加方法，方法就是定义再类中的函数：

class Dog:
    name: str="小花"
    type: str="金毛"
    age: int = 3
    
    def say(self):
        pass

        每个与类相关联的方法调用都自动传递实参self，它是一个指向实例本身的引用，让实例能够访问类中的属性和方法。相当于Java中的this

def say(self):
    print(f"你好，我是{self.name}")

        携带多个参数时，其他的参数放在 self 之后：

def say(self,food: str):
    print(f"你好，我是{self.name}！我喜欢吃{food}")

类中，实例变量和类变量可以同名，但这种情况下使用类对象将无法调用类变量，它会首选实例变量，这也是不推荐类变量使用对象名调用的原因。

案例：

#类属性和实例属性

#定义类

class Dog:

        name:str  = '小黑'

        age:int = 2

#实例化

dog = Dog()

dog2 = Dog()

#访问类属性

#类名.属性名

print(Dog.age)

#实例名.属性名

print(dog.name)

print(dog2.name)

#向dog实例添加name属性

dog.type='小红'

print(dog.type)

#向dog实例添加sex属性

Dog.sex = '公用'

print(dog.sex)

print(dog2.sex)

        4、init()构造函数

                在创建类时，我们可以手动添加一个 __init__() 方法，该方法是一个特殊的类实例方法，称为构造方法（或构造函数）。

构造方法用于创建对象时使用，每当创建一个类的实例对象时，Python解释器都会自动调用它。Python类中，手动添加构造方法的语法格式如下：

def __init__(self,...):
    代码块

注意，此方法的方法名中，开头和结尾各有 2 个下划线，且中间不能有空格。Python 中很多这种以双下划线开头、双下划线结尾的方法，都具有特殊的意义

• 定义类时，如果没有手动添加 __init__() 构造方法，又或者添加的 __init__() 中仅有一个 self 参数，则创建类对象时的参数可以省略不写，如下所示：

class Dog:
    
    def __init__(self):
        print("实例化")
        
d = Dog()

• init() 方法可以包含多个参数，但必须包含一个名为 self 的参数，且必须作为第一个参数。也就是说，类的构造方法最少也要有一个 self 参数。如下所示：

class Dog:
    
    def __init__(self,sname: str,sage: int):
        print("正在使用多参数的init函数进行实例化")
        
d = Dog("小白",2)

• 在python没有重载一说，如果硬是要做，可以使用默认值方式：

class Dog:
    
    def __init__(self,sname: str='',sage: int=0):
        print("正在使用多参数的init函数进行实例化")
​
d = Dog(sname="小白")

案例：

        init构造函数

'''
init函数
1、self：名称可以任意，位于方法第一个参数，代表当前对象
2、当实例化时，init方法会被自动调用
3、python中没有重载，参数使用默认值

'''

class Car:
    #类变量：所有实例共享
    total_count:int=0
    def __init__(self,brand:str,color:str):
        #实例变量，动态向当前对象self中添加brand，color实例变量
        self.brand = brand
        self.color = color
        Car.total_count +=1


c1 = Car("比亚迪","黄色")
c2 = Car("哈哈","ae")
print(c1.brand,c1.color)
print(c2.brand,c2.color)
print(Car.total_count)

        new构造函数

'''
单例模式
public class singlenton{
    privste static singlenton s = null;
    private singlenton (){
    }
    公共方法
    public static singlenton getinstance(){
    if(s==null)
        s = new singlenton();
        return s;
    }
}
'''
'''
1、new和init都会被自动调用
2、new 创建对象,它是静态方法，init使用new创建的对象进行初始化属性

cls:当前类
'''

class Appconfig(object):
    ac = None
    def __new__(cls, *args, **kwargs):
        print('new...')
        if not cls.ac:
            ac = object.__new__(cls, *args, **kwargs)
        return ac
    def __init__(self):
        print('init...')

a1 = Appconfig()
a2 = Appconfig()
print(a1==a2)

        5.魔法函数

                Python 类中，凡是以双下划线 "" 开头和结尾命名的成员（属性和方法），都被称为类的特殊成员（特殊属性和特殊方法）。例如，类的 init__(self) 构造方法就是典型的特殊方法。

• 示例一：__str__()

重载父类object中的__str__()用于将值转化为字符串形式：

class Dog:
    def __str__(self):
        return f"name={self.name},age={self.age},sex={self.sex}"

• 示例二：__call__()

Python类中一个非常特殊的实例方法，即 __call__()。该方法的功能类似于在类中重载 () 运算符，使得类实例对象可以像调用普通函数那样，以“对象名()”的形式使用。

class Dog:
    # 定义__call__方法
    def __call__(self,name,age):
        print("调用__call__()方法",name,age)
d1 = Dog()
d1("小花",2)

可以看到，通过在 Dog 类中实现 __call__() 方法，使的 d1实例对象变为了可调用对象。

更多内容，请查看Python中的魔法函数。

案例：

'''
__str__：默认返回类的全路径，内存地址
特点print时会自动被调用
——call——:类实例对象像普通函数那样调用call函数
'''
class Car:
    def __init__(self,brand:str,color:str):
        #实例变量，动态向当前对象self中添加brand，color实例变量
        self.brand = brand
        self.color = color
    def __str__(self):
        return  f"品牌:{self.brand}\n颜色:{self.color}"
    def __class__(cls, *args, **kwargs):
        print("调用——class——",self.brand, self.color)
c1 = Car("宝马","白色")
c1()#调用call函数
print(c1)

三、三大特征

        1.封装

简单的理解封装（Encapsulation），即在设计类时，刻意地将一些属性和方法隐藏在类的内部，这样在使用此类时，将无法直接以“类对象.属性名”（或者“类对象.方法名(参数)”）的形式调用这些属性（或方法），而只能用未隐藏的类方法间接操作这些隐藏的属性和方法。

             a、property()函数

我们一直在用“类对象.属性”的方式访问类中定义的属性，其实这种做法是欠妥的，因为它破坏了类的封装原则。正常情况下，类包含的属性应该是隐藏的，只允许通过类提供的方法来间接实现对类属性的访问和操作。

因此，在不破坏类封装原则的基础上，为了能够有效操作类中的属性，类中应包含读（或写）类属性的多个 getter（或 setter）方法，这样就可以通过“类对象.方法(参数)”的方式操作属性，例如：

通过添加 __ 修饰符将变量声明为私有化属性。

class Dog:
    name: str = '小黑'
    age: int = 3
    __sex: str = '公'

被修饰的变量无法再类的外部被访问，但是可以通过 self 对象来调用。

# 提供getter/setter
def get_sex(self):
    return self.__sex
​
def set_sex(self, sex: str):
    self.__sex = sex

                b、类方法

Python 类方法和实例方法相似，它最少也要包含一个参数，只不过类方法中通常将其命名为 cls，Python 会自动将类本身绑定给 cls 参数（注意，绑定的不是类对象）。也就是说，我们在调用类方法时，无需显式为 cls 参数传参。

和 self 一样，cls 参数的命名也不是规定的（可以随意命名），只是 Python 程序员约定俗称的习惯而已。

和实例方法最大的不同在于，类方法需要使用＠classmethod修饰符进行修饰，例如：

class Dog:
    # 类方法
    @classmethod
    def info(cls):
        print(cls)

注意，如果没有 ＠classmethod，则 Python 解释器会将 fly() 方法认定为实例方法，而不是类方法。

类方法推荐使用类名直接调用，当然也可以使用实例对象来调用（不推荐）。

d1 = Dog()
d1.info()
Dog.info()

案例：

class Dog:
    name: str = '小黑'
    age: int = 3
    __sex: str = '公'

# 提供getter/setter
    def get_sex(self):
      return self.__sex

    def set_sex(self, sex: str):
      self.__sex = sex
dog = Dog();
print(dog.get_sex)

                c、静态方法

静态方法，其实就是我们学过的函数，和函数唯一的区别是，静态方法定义在类这个空间（类命名空间）中，而函数则定义在程序所在的空间（全局命名空间）中。

静态方法没有类似 self、cls 这样的特殊参数，因此 Python 解释器不会对它包含的参数做任何类或对象的绑定。也正因为如此，类的静态方法中无法调用任何类属性和类方法。

静态方法需要使用＠staticmethod修饰，例如：

class Dog:
    # 静态方法
    @staticmethod
    def say():
        print("静态方法被调用了...")

静态方法的调用，既可以使用类名，也可以使用类对象，例如：

d1 = Dog()
d1.say()
Dog.say()

案例：
class Dog:
    # 类方法cls代表当前类，通过cls调用类的成员
    @classmethod
    def info(cls):
        print(cls)

    # 静态方法:无法调用任何类属性和类方法
    @staticmethod
    def say():
        print("静态方法被调用了...")

Dog.info()
Dog.say()

        2.继承

Python 中，实现继承的类称为子类，被继承的类称为父类（也可称为基类、超类）。

子类继承父类时，只需在定义子类时，将父类（可以是多个）放在子类之后的圆括号里即可。语法格式如下：

class 类名(父类1, 父类2, ...)：
    #类定义部分

注意，如果该类没有显式指定继承自哪个类，则默认继承 object 类（object 类是 Python 中所有类的父类，即要么是直接父类，要么是间接父类）。另外，Python 的继承是多继承机制（和 C++一样），即一个子类可以同时拥有多个直接父类。

class Father(object):
    height=180
    money=100
    def work(self):
        print("会工作")
    pass
​
class Mother(object):
    fact='漂亮'
    money=90
    def cook(self):
        print("会做饭")
    pass
​
class Son(Father,Mother):
    pass
​
# 创建son的实例
s=Son()
s.cook()
s.work()
print(s.fact)
print(s.height)
print(s.money)

同时继承 Father类和 Mother类时，Father类在前，当属性和方法重复时，越往前优先级越高。

查看继承关系

print(Dog.__bases__)
print(Dog.__mro__)

案例：

class Father(object):
    height=180
    money=100
    def work(self):
        print("会工作")
    pass

class Mother(object):
    fact='漂亮'
    money=90
    def cook(self):
        print("会做饭")
    pass

class Son(Father,Mother):
    pass
son = Son()

son.work()
son.cook()
print(son.height)
print(son.money)

print(son.__bases__)
print(son.__mro__)#mro决定查找方法的路径

        3、多态

class Animal(object):
    def play(self):
        print("Animal play")

class Tiger(Animal):
    def play(self):
        print("正在表演老虎后脚直立行走")


class Lion(Animal):
    def play(self):
        print("正在表演狮子跳火圈")


class Person(object):
    def show(self, a: Animal):#声明父类类型，传入子类实例
        print("动物表演开始了")
        a.play()#多态


p = Person()
a = Animal()
t = Tiger()
l = Lion()

p.show(a)