python的函数、魔法方法和案例

1.python函数中self的用法

---

在Python中，self 是一个对当前实例（对象）的引用，用于访问属于该类的变量和方法。在定义类的方法时，通常需要将 self 作为第一个参数。这允许在类的实例上调用方法时，自动将实例本身作为参数传递给方法。

class Person:  
    def __init__(self, name, age):  
        self.name = name  # 将name属性绑定到当前实例  
        self.age = age    # 将age属性绑定到当前实例  
  
    def greet(self):  
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")  
  
# 创建一个Person类的实例  
person1 = Person("Alice", 30)  
  
# 调用实例的greet方法  
person1.greet()  # 输出: Hello, my name is Alice and I am 30 years old.

2.魔法方法

---

2.1 __init__方法

---

__init__ 方法在Python中是一个特殊的方法，也被称为类的构造函数或初始化方法。这个方法的主要作用是在创建类的新实例时，为实例的属性（变量）设置初始值。每当使用类来创建新对象时，Python都会自动调用这个方法。

在__init__方法中，self参数是对新创建对象的引用，通过这个引用，可以访问类中的属性和其他方法。需要注意的是，虽然self在调用方法时是自动传递的，但在定义方法时，它必须作为第一个参数明确写出来。

class Car:  
    def __init__(self, make, model, year):  
        self.make = make  # 设置实例变量make  
        self.model = model  # 设置实例变量model  
        self.year = year  # 设置实例变量year  
  
    def display_info(self):  
        print(f"Make: {self.make}, Model: {self.model}, Year: {self.year}")  
  
# 创建一个Car类的实例  
my_car = Car("Toyota", "Corolla", 2020)  
  
# 调用实例的display_info方法  
my_car.display_info()  # 输出: Make: Toyota, Model: Corolla, Year: 2020

2.2 __str__方法

---

__str__ 方法是Python中的一个特殊方法（也称为魔法方法），它用于定义对象的字符串表示形式。当尝试将一个对象转换为字符串时（例如，使用 str(obj) 函数或在 print 语句中直接使用对象），Python会尝试调用该对象的 __str__ 方法来获取其字符串表示。

class Student:  
    def __init__(self, name, age):  
        self.name = name  
        self.age = age  
  
    def __str__(self):  
        return f"Student(name={self.name}, age={self.age})"  
  
# 创建一个学生对象  
student = Student("Alice", 20)  
  
# 打印学生对象  
print(student)  # 输出: Student(name=Alice, age=20)

2.3__del__方法

---

__del__ 方法在Python中是一个特殊方法（也称为析构函数或终结器），它用于定义在对象被销毁（删除）之前要执行的清理操作。当Python的垃圾回收机制检测到一个对象没有任何引用指向它时，它会自动销毁该对象，并在销毁之前调用该对象的 __del__ 方法（如果存在的话）。

class MyClass:  
    def __init__(self, name):  
        self.name = name  
        print(f"Object {self.name} is created")  
  
    def __del__(self):  
        print(f"Object {self.name} is being destroyed")  
  
# 创建对象  
obj = MyClass("Test Object")  
  
# 删除对象（在实际使用中，这一步通常是自动的，由Python的垃圾回收机制完成）  
# del obj  # 注释掉这行代码以观察程序结束时自动销毁对象的情况  
  
# 输出结果（假设没有显式调用del obj）  
# Object Test Object is created  
# ...（程序其他部分的输出）  
# Object Test Object is being destroyed  
# 这行输出是在程序结束时，由Python的垃圾回收机制自动触发的

2.4案例

案例分为两个类，一个家具类，一个房子类，都采用了上述的魔法方法，还有函数的调用，对象的创立和赋值，将一个家具类的对象赋值给一个房子类的对象。代码如下

class HouseItem:
    def __init__(self, name, area):
        self.name = name
        self.area = area

    def __str__(self):
        return f'家具名称{self.name},占地面积{self.area}'


class House:
    def __init__(self, name, area):
        self.name = name
        self.total_area = area
        self.free_area = area
        self.item_list = []

    def __str__(self):
        return f"户型:{self.name},总面积:{self.total_area}，
剩余面积:{self.free_area}，家具名称列表:{self.item_list}"

    def add_item(self, item):
        if self.free_area > item.area:
            self.item_list.append(item.name)
            self.free_area -= item.area
            print(f"{item.name},添加成功,剩余空间:{self.free_area}")
        else:
            print('添加失败')


# 创建两个家具
bed = HouseItem('大床', 4)
print(bed)
table = HouseItem('新桌子', 2)
print(table)
# 创建一栋房子
house = House('三室一厅', 150)
print(house)
# 把bed塞进house里
house.add_item(bed)
house.add_item(table)
print(house)

输出结果：

3.python的公有与私有属性

在Python中，对象的属性（包括变量和方法）可以是公有的（public）或私有的（private）。这种区分主要通过命名约定来实现，而不是通过语言本身的强制机制。Python并没有像一些其他语言（如Java或C++）那样有严格的访问控制关键字（如public、private、protected）。

私有属性的标志：“__属性名”

# 公有
class MyClass:  
    def __init__(self, value):  
        self.public_attribute = value  
  
# 使用  
obj = MyClass(10)  
print(obj.public_attribute)  # 可以访问



# 私有
class MyClass:  
    def __init__(self, value):  
        self.__private_attribute = value  
  
# 错误的访问方式  
obj = MyClass(20)  
print(obj.__private_attribute)  # AttributeError: 'MyClass' object has no attribute '__private_attribute'  
  
# 正确的（但通常不推荐）访问方式  
print(obj._MyClass__private_attribute)  # 20

4.pyton的实例方法、静态方法和类方法

在Python中，类可以定义三种类型的方法：实例方法（Instance Methods）、静态方法（Static Methods）和类方法（Class Methods）。每种方法都有其特定的用途和调用方式。

# 实例方法
class MyClass:  
    def __init__(self, value):  
        self.value = value  
  
    def instance_method(self):  
        print(f"Value: {self.value}")  
# 创建实例  
my_instance = MyClass(10)  
# 调用实例方法  
my_instance.instance_method()  # 输出: Value: 10




# 静态方法
class MyClass:  
    @staticmethod  
    def static_method(arg1, arg2):  
        print(f"Arguments: {arg1}, {arg2}")  
  
# 无需通过实例，直接通过类调用  
MyClass.static_method(1, 2)  # 输出: Arguments: 1, 2





# 类方法
class MyClass:  
    counter = 0  
  
    @classmethod  
    def class_method(cls):  
        cls.counter += 1  
        print(f"Counter: {cls.counter}")  
  
# 通过类调用  
MyClass.class_method()  # 输出: Counter: 1  
MyClass.class_method()  # 输出: Counter: 2  
  
# 注意，通过实例调用也是有效的，但通常我们直接通过类调用类方法  
my_instance = MyClass()  
my_instance.class_method()  # 输出: Counter: 3

5.python文件

python文件的打开方式有两种

1.open(....)

2.with open(....)

5.1使用open的方式操作文件

# 写操作
f=open('a.txt','w',encoding='utf-8')
f.write('hello')
f.write(' world')
f.close()
# 读操作
f=open('a.txt','r',encoding='utf-8')
buf=f.read()
print(buf)
f.close()

5.2使用with open的方式操作文件

# 使用with open方法会自动关闭，不需要再用close
# a表示新增
with open('a.txt','a',encoding='utf-8')as f:
    f.write('\ngood')
# 按行读取文件readline()
# 可以用while和for循环来逐行读取
with open('a.txt',encoding='utf-8')as f:
    buf =f.readline()
    print(buf)
    print(f.readline())

5.3使用python打开json文件

import json
with open('info.json',encoding='utf-8')as f:
    result=json.load(f)
    print(type(result))
    print(result.get('name'))
    print(result.get('age'))
    print(result.get('address').get('city'))
    pass

JSON文件内容为：

{
  "name":"xiaoming",
  "age": 20,
  "like": [
    "king",
    "eat",
    "drink",
    "sleep"
  ],
  "address": {
    "country": "China",
    "city": "changsha"
  }
}

输出结果为：