python之面向对象

Python的面向对象编程（OOP）是一种编程范式，它使用“对象”来设计软件和编写代码。在面向对象编程中，可以创建包含数据和功能的类，然后通过类的实例化来创建对象。这些对象可以交互，以完成更复杂的任务。

以下是面向对象编程的一些关键概念：

1. 类（Class）：

类是创建对象的模板或蓝图。它定义了对象将会有的属性（数据）和方法（函数）。

2. 对象（Object）：

对象是基于类创建的实例。每个对象都有自己的状态和行为。

3. 属性（Attribute）：

属性是对象的特征，比如颜色、大小等。在Python中，属性通常是变量。

4. 方法（Method）：

方法是对象可以执行的操作，类似于传统编程中的函数。在Python中，方法就是绑定在对象上的函数。

5. 封装（Encapsulation）：

封装是指将数据（属性）和操作数据的函数（方法）绑定在一起，形成一个整体即对象。

6. 继承（Inheritance）：

继承允许新创建的类（子类）继承父类的属性和方法。这有助于代码重用和扩展性。

7. 多态（Polymorphism）：

多态是指不同类的对象可以通过相同的接口进行操作，具体被调用的方法取决于对象的实际类型。

在Python中使用面向对象编程的基本步骤包括：

1. 定义类：使用`class`关键字定义一个类。

2. 添加属性：在类中定义变量来添加属性。

3. 添加方法：在类中定义函数来添加方法。

4. 访问权限控制：使用不同的访问修饰符（如`public`, `private`, `protected`）来控制属性和方法的访问权限。

总的来说，面向对象编程提供了一种组织和管理复杂程序的有效方式，使得代码更加模块化，易于理解和维护。通过类的继承和组合，可以构建出强大的程序结构。

python面向对象的三大特征

Python面向对象的三大特征是封装、继承和多态。

首先，封装指的是将数据（属性）和操作数据的函数（方法）绑定在一起，形成一个整体即对象。这样可以隐藏对象的内部细节，只暴露出需要的接口。在Python中，通过定义类来实现封装，类中的属性和方法可以被设置为私有的，从而限制外部直接访问。

其次，**继承**是一种机制，允许新创建的类（子类）继承父类的属性和方法。这有助于代码重用和扩展性，因为子类可以在父类的基础上添加新的属性或覆盖父类的方法。

最后，**多态**是指不同类的对象可以通过相同的接口进行操作，具体被调用的方法取决于对象的实际类型。这使得程序具有更好的灵活性和可扩展性，因为可以传递任何实现了特定接口的对象，而不必担心它们的具体类型。

综上所述，封装、继承和多态是面向对象编程的核心概念，它们共同构成了面向对象编程的基础。

接下来，上代码

1.面向对象的介绍

# 定义类
class Person:
    # 属性：一般用来描述静态的信息
    name = "张三"
    sex = "男"

    # 方法一般用来实现具体的功能，一般都是直接使用函数定义即可
    def ect(self):  # self表示本身的意思
        print("我是吃饭的方法")

    def say(self):
        print("我是说话的意思")


# 如何通过类得到具体的对象
ji = Person()
# 通过对象访问访问类中的属性
print(ji.name)
print(ji.sex)
# 通过对象调用类中的方法
ji.ect()
ji.say()

2.面向对象中的self介绍

class Student:
    def eat(self):
        print(self)


stu = Student()
stu.eat()  # 这个时候self表示的是stu这个对象
stu1 = Student()
stu1.eat()  # 这个时候self表示的是stu这个对象
# 综上所述：self描述的是当前这个对象

3.构造函数和析构函数

# 魔术方法是一些比较特殊的方法
# 特点：
"""
1.不需要手动调用，会在合适的时机自动触发
2.这些方法都是以__开始和使用__结束的
3.方法名都是系统规划好的
"""


class Person():
    """
    # 类属性(不推荐这样写)
    name = "张三"
    sex = "男"
    """

    # 构造函数:当创建了对象之后，给对象赋值属性的时候自动触发
    def __init__(self, name, sex):
        self.name = name
        self.sex = sex
        print("我的触发时机是：当你给对象赋值的时候自动触发")
        print(self.name,self.sex)

    def __del__(self):
        print("我的触发条件是：当对象被销毁的时候")


dong = Person("张三", "男")
print("hello word")
"""
构造函数：主要用于数据库的连接时
析构函数：主要用于数据库的关闭或者文件的保存等等
"""

4.类属性和对象属性

class Stuent():
    # 类属性
    name = "鱼类"

    # 构造函数 对象属性
    def __init__(self, wen):
        self.wen = wen

    def swin(self):
        print("游泳的方法")


# 创建对象
jingyu = Stuent(123)
liyu = Stuent(3567)

# 访问类属性  (对象和类都可以访问类属性)
# print(jingyu.name)  # 鱼类
# print(liyu.name)  # 鱼类
# print(Stuent.name)  # 鱼类
# 访问对象的属性
print(jingyu.wen)   # 123
print(liyu.wen)   # 3567
# print(Stuent.wen)   # 报错
# 总结如下：
"""
对象可以访问对象的属性，但是类不能访问对象的属性
"""
"""
总结：
    1.类属性可以使用类名访问(推荐)对象也可以访问类属性(不推荐)
    2.对象的属性可以使用对象访问(推荐)类不可以访问对象的属性(不推荐)   
"""
# 修改类属性
Stuent.name = "鲨鱼"
print(Stuent.name)
jingyu.name = "鳄鱼"
print(jingyu.name)
print(liyu.name)  # 其他对象访问类属性的时候，还是原来的结果
# 通过对象修改类属性的时候，只是动态的给当前对象添加了一个属性，并不能修改类属性
# 修改对象的属性
jingyu.wen = "哈哈"
Stuent.wen = "14"
print(Stuent.wen)
print(jingyu.wen)
"""
总结如下：
    1.类可以修改类的属性(推荐) 对象修改类的属性的时候，只是动态的给当前对象添加了一个属性，并没有修改类的属性，其他对象访问类属性时还是原来的值
    2.对象可以修改对象的属性(推荐) 类也可以修改对象的属性
"""

5.继承

# 面向对象的三大特征：继承，封装，多态
"""
1.封装
    函数的定义，类的定义，里面包含了属性和方法
2.继承：
    将一些公共的属性和方法提取出来，放到一个专门的父类中去，其他的子类去继承这个父类后，就可以直接使用这个父类的一些属性和方法了
3.多态
    更多的体现在解决一些特殊问题的时候的技巧
"""


class pen():
    def saty(self):
        print("说话的方法")


class ceat(pen):  # 在子类中继承父类只需要在定义子类的时候，参数列表上写上父类的名称即可
    def add(self):
        print("吃饭的方法")


# 创建一个对象
xiaoming = ceat()


# xiaoming.add()  # 对象直接调用子类的方法
# xiaoming.saty()  # 对象直接调用父类的方法
# 有构造函数的继承
class num():
    def __init__(self, name, sex):
        self.name = name
        self.sex = sex

    def shoe(self):
        print("我是跑的方法")


class Dog(num):
    def __init__(self, name, sex, weight):  # 先在子类的构造函数中继承父类的属性，然后在重构
        # 1.继承父类的构造方法
        # num.__init__(self, name, sex)
        # 2.隐士继承父类的构造函数
        super(Dog, self).__init__(name,sex)
        # 定义子类自己的属性
        self.weight = weight

    def wang(self):
        print("旺旺")


# 定义一个对象
taidi = Dog("泰迪", "公", 5000)
taidi.shoe()
print(taidi.name)
print(taidi.sex)

6.继承的注意事项

# 定义一个类
class pen():
    def __init__(self, name):
        self.name = name

    def show(self):
        print("跑步的方法")


"""
注意：
    1.object是所有类的父类，如果一个类没有显示指明他的父类，则默认是object(可以省略不写)
    2.Python中的面向对象是可以实现多继承的
"""
# 注意：
demo = pen("张三")
# demo.show()
# print(demo.name)
# 多继承语法
"""
class 子类类名(父类1,父类2,父类3):
    属性
    方法
"""


# 定义一个父类
class fun():
    def __init__(self, name):
        self.name = name

    def show(self):
        print("钱不好挣")


# 定义一个母亲类
class muther():
    def __init__(self, her):
        self.her = her

    def eat(self):
        print("一言不合就干饭！")


# 定义一个子类
class son(fun, muther):  # 子类继承多个父类的时候，只需要把父类的名字写在参数列表中就行，中间使用逗号隔开
    def __init__(self, her, name, ser):
        # 继承父类的构造函数
        fun.__init__(self, name)
        muther.__init__(self, her)
        # 定义子类的属性
        self.ser = ser
    def play(self):
        print("打游戏")
san = son("李四",178,130)
print(san.name)
print(san.her)
print(san.ser)
san.show()

7.类方法和静态方法

# 类方法：使用@classmethod装饰器修饰的方法叫做类方法，可以通过类名调用，也可以通过调用，一般情况下使用类名调用
class aimint():
    # 类属性
    name = "动物类"

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

    @classmethod
    def from_str(cls):
        print("我是类方法")
        print(cls)
        print(cls == aimint)  # cls表示的是当前类
        print(cls.name)

    @staticmethod
    def eat():
        print("我是静态方法")


# aimint.from_str()  # 通过类名调用类方法
dog = aimint("土狗")
# dog.from_str()  # 对象调用类方法
aimint.eat()  # 通过类名调用静态方法
dog.eat()  # 通过对象调用静态方法
"""
总结：
    类方法
        1.通过@classmethod装饰器修饰的方法叫做类方法
        2.类方法可以使用类名调用(推荐) 对象也可以调用类方法
        3.没有self，在类方法中不可以使用其他对象的属性和方法(包括私有属性和方法)
        4.可以调用类属性和其他的类方法
        5.类方法中的cls是class的简写，可以更换为其他的，一般使用cls表示当前类
        6.cls表示当前类
    静态方法：
        1.通过@staticmethod装饰器的方法叫做静态方法
        2.通过类名调用静态方法(推荐)  对象也可以调用
        3.静态方法中的形参没有cls,在静态方法中不建议使用(类属性\类方法\静态方法)
        4.静态方法一般是一个单独的方法，只写在类中
"""

8.私有属性和私有方法

class git():
    def __init__(self, name, sex, age):
        self.name = name
        self.sex = sex
        # 私有属性的设置
        # 比如女孩的年龄是私密的，不能任意地访问，可以设置为私有的
        self.__age = age

    # 私有方法：__方法名
    def __getname(self):
        print("一亲定终身")  # 只可以在类的内部可以访问

    def sat(self):
        print("说话的方法")
    def swh(self,gx):
        if gx == "情侣":
            self.__getname()
        else:
            print("我不是你的情侣，你不可以调用我")
    # 在类的内部定义一个方法，可以访问私有属性
    def unm(self, body):
        if body == "小明":
            print(f"{self.name}偷偷的告诉你{body}说，我今年{self.__age}岁了")
        else:
            print("我不和你说")


hon = git("小红", "女", 14)
print(hon.name)  # 小红
print(hon.sex)  # 女
# print(hon.age)  # 报错
# 在类的外部不可以直接访问对象的私有属性
hon.unm("小明")
# hon.__getname()
hon.swh("情侣")
'''
总结：
私有属性：
    1.格式：在属性的前面加 __比如__age 
    2.用法：只可以在类的内部访问，在类的外部是访问不了的，可以在类的内部设置一个对外开放的接口，(这个接口一般都会设置各种条件和各种判断，满足后才可以访问)，主要用于各种私密的信息
私有方法：
    1.格式：在方法的前面加__比如：__age()
    2.用法：只能在类的内部访问不能在类的外部访问，私有方法一般用于类的内部实现某一些功能，对于外部来说没有实际的意义
'''

9.多态

# 多态:一种事物的多种体现形式，函数的重写就是多态的一种体现形式
# 在面向对象中的多态，指的是父类的引用指向子类的对象
class stu():
    def eat(self):
        print("我是吃饭的方法")


# 子类
class fish(stu):
    def eat(self):
        print("大鱼吃小鱼，小鱼吃虾米")


class don(stu):
    def eat(self):
        print("狼行千里吃肉，狗行千里吃粑")


class mao(stu):
    def eat(self):
        print("猫爱吃鱼")

# 严格意义上的多态
class jiu():
    def ete(self,amin):
        amin.eat()
# 最简单的多态
"""
在父类和子类中出现了函数重名的情况，会调用子类的函数，子类和父类重名的情况就叫做重载或者重写
不同的子类调用和父类方法名一样的方法，调用都是自己的方法，这就是多态的一种体现
"""
fch = fish()
d = don()
m = mao()
m.eat()
d.eat()
fch.eat()
# 严格意义上的多态的体现
jiu().ete(d)
jiu().ete(m)

 10.单例模式

# 什么是设计模式
""""
经过多次的实验，总结出一些特殊的解决方案
常见的设计模式有23种，比如：单例设计模式/工厂模式/门面设计模式/代理模式/装饰设计模式等等
"""
# 单例设计模式
"""
单例：单个实例对象，在程序运行的过程中，确保某一个类只能有一个实例[对象]，不管在哪个模块中获取对象，获取到的都是同一个对象
"""


# 应用场景：数据库的连接操作
# 单例设计模式的实现
class Solution:
    def __init__(self, name):
        self.name = name

    # 创建一个类属性
    instead = None

    @classmethod
    def __new__(cls, *args, **kwargs):
        print("__new__")
        # 如果类属性的instead == None表示，改类未创建对象
        if cls.instead is None:
            cls.instead = super().__new__(cls)
        return cls.instead


p1 = Solution("张三")
p2 = Solution("李四")
p3 = Solution("王五")
print(p1 == p2 == p3)

**Python的文件操作主要包括打开文件、读写文件内容以及关闭文件等步骤**。

首先，**打开文件**是进行文件操作的第一步。在Python中，可以使用`open()`函数来打开一个文件，这个函数接受文件名和模式作为参数。例如，使用`'r'`模式可以以只读方式打开文件，而使用`'w'`模式则可以打开文件进行写入。如果文件不存在，使用`'w'`模式会创建一个新文件。

接下来，**读取文件内容**可以通过多种方式进行。如果想要读取整个文件的内容，可以使用文件对象的`read()`方法。如果只需要读取部分内容，可以使用`readline()`或`readlines()`方法来逐行读取。此外，还可以使用`for`循环直接迭代文件对象，这样可以逐行访问文件内容。

然后，**写入文件内容**也是文件操作的一个重要部分。使用`write()`方法可以将字符串写入文件。如果是要写入多行内容，可以在每行末尾添加换行符`'
'`。当完成文件的写操作后，通常需要调用`flush()`方法来确保所有的写入操作都已经被执行。

最后，不要忘记**关闭文件**。在完成文件操作后，应该使用`close()`方法关闭文件，以释放系统资源。也可以使用`with`语句来自动管理文件的打开和关闭，这是一种更加安全的做法。

除了上述基本操作，Python还支持更高阶的文件操作，如文件夹的递归访问和Excel文件的读取与写入等。此外，`seek()`函数可以用来改变文件指针的位置，从而实现随机访问文件中的数据。

总的来说，Python提供了丰富的文件操作功能，可以满足不同场景下对文件处理的需求。在进行文件操作时，应该注意选择合适的模式和正确的方法，以确保数据的安全和操作的正确性。

11.文件的打开和关闭

# open()用于打开文件
""""
参数介绍：
第一个参数：file表示文件的路径
第二个参数：mode 表示打开文件时的模式  默认的模式是r (r表示read 读   w 表示write  写   a表示 append  追加内容)
第三个参数：encoding   表示编码格式
返回值：
    打开后的文件对象
"""
file = open("demo.txt", encoding="utf-8")
# print(type(file))
"""
在Windows系统中，打开文件模式是以gbk的方式打开文件demo.txt文件中写入的内容的时候，是以utf-8的格式写入的内容
解决方案：读取文件和写入文件要以相同的编码格式
"""
# read()读取文件中的内容
print(file.read())

# 文件的内容读取后，要关闭文件
file.close()

12.文件的操作

# open()
"""
路径分为两种：
    1.绝对路径
    2.相对路径
"""
file = open("./demo.txt", encoding="utf-8")  # 打开文件
print(file.read())  # 读取文件中的内容
file.close()  # 关闭文件

13.写入文件

# open()打开指定的文件
file = open("fhj.txt", "w", encoding="utf-8")
"""
注意：
    1.如果打开的文件路径不存在，则会直接创建一个新文件
    2.mode = "w"会把原文件的内容直接替换掉
    3.mode="a"会以追加的方式向文件中写入内容，不会影响原文件的内容
"""
# write()
# flush()刷新管道
file.flush()
file.write("你好啊，朋友")

创作不易，请各位美女点个赞在走呗，