0基础学Python——类、对象、装饰器、闭包、属性及案例，按照年龄或成绩进行排序案例

Python类

Python 中的类（Class）是面向对象编程（OOP）的一个核心概念。通过类，你可以创建具有特定属性和方法的对象（Object）。类是对象的蓝图或模板，而对象则是类的实例。

创建类

定义一个类使用 class 关键字，后跟类名和冒号。类体内部通常包含属性（变量）和方法（函数）。

class Dog:  
    # 类属性  
    species = "helloworld"  
  
    # 初始化方法  
    def __init__(self, name, age):  
        self.name = name  # 实例属性  
        self.age = age    # 实例属性  
  
    # 实例方法  
    def bark(self):  
        return f"{self.name}"  
  
    # 类方法  
    @classmethod  
    def get_species(cls):  
        return cls.species  
  
    # 静态方法  
    @staticmethod  
    def print_info(info):  
        print(info)

创建对象

使用类名后加括号（可包含初始化参数）来创建对象。

d1 = Dog("Buddy", 3)  
d2 = Dog("Charlie", 5)

访问属性和方法

通过对象访问实例属性和方法，通过类名访问类属性和类方法、静态方法。

print(d1.name)         
print(d1.bark())         
print(Dog.get_species())  
Dog.print_info("静态方法")  # 静态方法

查看类型

print(type(zs))  # <class '__main__.Student'>
print(zs.__class__)  # <class '__main__.Student'>
print(isinstance(zs, Student))  # True

销毁对象

del ls
print(ls)

属性特征

静态特征：静态特征: 属性， 变量声明

动态特征：动态特征: 方法(函数)，逻辑代码

class Student:
    # 默认调用无参构造函数
    # def __init__(self):
    #     print('======')
    # 如果手动写了带参构造，无参构造不再默认生成或被覆盖
    def __init__(self, name1, age1):
        # self：谁调用指谁
        # name、age代表静态属性
        self.name = name1
        self.age = age1

创建实例

zs = Student('张三', 20)
ls = Student('李四', 30)
# ww = Student()

调用属性 对象名.属性名

print(zs.name, zs.age)
print(ls.name, ls.age)

添加属性 对象名.属性名=属性值

zs.sex = '男'
zs.address = '郑州'

修改属性

zs.age = 33

删除属性

del zs.address

查看对象的信息

print(zs.__dict__)

实例方法

class Student():
    # 属性
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # 函数 方法
    def study(self):
        print(f'{self.name}学习')

    def run(self, n):
        for i in range(n):
            print(f'{self.name}跑{i + 1}圈')

    def add(self, a, b):
        return a + b


zs = Student('张三', 20)
ls = Student('李四', 30)
# 调用方法 对象名.方法(实参)
zs.study()
ls.study()

zs.run(2)
ls.run(3)

print(zs.add(10, 20))
print(ls.add(1, 2))

print(zs.__dict__)

装饰器

不改变函数原有的功能，给函数添加额外的功能，使用@函数名

def outter(func):
    def inner():
        print('睡觉')
        func()
        print('打豆豆')

    return inner


@outter  # 装饰器
def eat():
    print('吃饭')


eat()

案例

进入购物车页面前必须登录

login_user = None


def login_required(func):
    def checked():
        global login_user
        if login_user:  # 如果登录
            func()  # 购物车
        else:
            while True:
                user = input('请输入用户名：')
                pwd = input("请输入密码:")
                if user == 'admin' and pwd == '123456':
                    login_user = {'user': user, 'pwd': pwd}
                    func()
                    break
                else:
                    print('用户名或密码错误')

    return checked


# @login_required
# def cart():
#     print('购物车')
#
#
# cart()


@login_required
def order():
    print('订单')


order()

闭包

1、外部函数嵌套内部函数
2、内部函数被返回到外部
3、内部函数访问外部函数非局部变量

特点

优点: 全局变量私有化，避免全局变量被随意污染
缺点: 由于内部函数持续引用外部函数的值,所以会导致这一部分内存空间不被释放，一直占用内存,内存泄漏
建议: 尽量避免使用闭包

def outter():
    a = 1

    def inner():
        nonlocal a
        a += 10
        return a

    return inner


print(outter()())


def outter1():
    b = 10

    def inner():
        nonlocal b
        return b

    return inner


b = outter1()()
print(b)

字符串表示

s = 'python'
print(s)
print(str(s))  # python  呈现给终端用户查看，用来阅读
print(repr(s))  # 'python' 呈现字符串原有的样子，‘官方’字符串


class Student:
    # 属性
    def __init__(self, name, age):
        self.name = name
        self.age = age

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

    def __repr__(self):
        return self.__str__()

    def __del__(self):
        print('删除')


zs = Student('张三', 20)
hr = Student('黄蓉', 30)
print(zs)

ls = [zs, hr]
print(ls)

del hr.age

案例

class Grade:
    def __init__(self, grade_name):
        self.grade_name = grade_name

    def __str__(self):
        return f"(grade_name={self.grade_name})"

    def __repr__(self):
        return self.__str__()


class Student:
    def __init__(self, name, age, grade):
        self.name = name
        self.age = age
        self.grade = grade

    def __str__(self):
        return f"(name={self.name},age={self.age},grage={self.grade.grade_name})"

    def __repr__(self):
        return self.__str__()


zs = Student('张三', 20, Grade('js0003'))
ls = Student('李四', 30, Grade('js0005'))
# print(zs.__dict__)
print(zs)

print(zs.name, zs.age, zs.grade.grade_name)
ls = [zs, ls]

for obj in ls:
    # print(obj.name, obj.age, obj.grade.grade_name)
    print(obj)

按照年龄或成绩进行排序

ls = [
    {'name': '张三', 'age': 20, 'score': 86},
    {'name': '李四', 'age': 15, 'score': 78},
    {'name': '王五', 'age': 22, 'score': 66},
    {'name': '王五', 'age': 20, 'score': 75},
]
# 先按照年龄排序，年龄相同在按照成绩排序
print(sorted(ls, key=lambda dic: (dic['age'], dic['score']), reverse=False))