36.Python封装对象推导

已于 2022-02-14 18:25:11 修改
阅读量825 收藏
点赞数
分类专栏： 0.Python 文章标签： python 开发语言 后端
于 2021-12-03 15:36:10 首次发布
风
本文链接：https://blog.csdn.net/qq_46137324/article/details/121699947
版权

文章目录

0.对比

互补:
面向过程的缺点就是面向对象的优点.
面向对象的缺点就是面向过程的优点.

1.面向过程的概念

核心:过程.
过程:解决问题的流程.

优点:复杂的问题流程化进而简单化.
一个复杂的问题,拆分成一个个的流程,分步完成.

缺点:牵一发动全身,扩展性差,可维护性差.

应用场景:对扩展性要求不高的地方.
逻辑不变的,固定死的代码.

"""
注册用户的功能
1.获取用户输入  用户名 和 密码
2.验证参数
3.写入文件,注册成功
"""


# 注册
def register():
    """
    :return: 字典 {
    'username': username,
    'password': password}
    """
    username = input('输入用户名称>>>:').strip()
    password = input('输入用户密码>>>:').strip()
    return {
        'username': username,
        'password': password
    }


# 账户密码验证
def check_info(userinfo):
    """

    :param userinfo: 字典 {需要有名称和密码}
    :return: is_valid 验证信息
    """
    is_valid = True
    if len(userinfo['username']) == 0:
        print('用户名称为空')

        is_valid = False

    if len(userinfo['username']) == 0:
        print('用户密码为空')

        is_valid = False

    return is_valid


# 写文件
def writer_file(userinfo, is_valid):
    """
    
    :param userinfo: 字典 {需要有名称和密码}
    :param is_valid: 验证后的信息
    :return: Tuer 或 False  True注册成功 False 注册失败
    """
    if is_valid:
        import json
        with open('%s.txt' % userinfo['username'], mode='w', encoding='utf8') as f1:
            json.dump(userinfo, f1)
            return True
    else:
        return False


# 主函数
def main():
    userinfo = register()
    is_valid = check_info(userinfo)
    is_success = writer_file(userinfo, is_valid)
    if is_success:
        print('注册成功!')
    else:
        print('输入不合法!')


# 启动程序
if __name__ == '__main__':
    main()

2.面向对象的概念

核心:对象

对象对象的三大特征:
封装,继承,多态

程序中:
函数是存放功能的容器,
对象是存放功能与数据的容器.

小说中: 陈北玄和李七夜
主角的特征(先装嫩后装逼):      变量 --> 属性 
主角的神通(扮猪吃老虎):        函数 --> 方法

优点:扩展性高,可维护性搞.
缺点:代码复杂度高
应用场景:对扩展性要求高的地方.

3.推导1

程序是由数据和功能组成,本质就是定义一系列的数据
然后再定义一系列的功能来对数据进行操作.

学生选课系统 Version 1.0
数据与功能是分离的
如果用户的数据多了维护麻烦

# 学生信息1
stu1_name = 'kid'
stu1_age = 18
stu1_gender = 'male'
stu1_school = 'xxx'
stu1_courses = []  # 可以用多门课程,先定义为一个空列表

# 学生信息2
stu2_name = 'qq'
stu2_age = 18
stu2_gender = 'female'
stu2_school = 'xxx'
stu2_courses = []  # 可以用多门课程,先定义为一个空列表


# 选课函数
def elective(stu_name, stu_courses, course):
    stu_courses.append(course)
    print('%s成功选择%s课程!' % (stu_name, course))


# 调用函数选课
elective(stu1_name, stu1_courses, 'Python')  # kid成功选择Python课程!
elective(stu2_name, stu2_courses, 'linux')  # qq成功选择linux课程

4.推导2

学生选课系统 Version 2

每个同学的信息,散乱,查找/修改不方便,
使用字典类型存储,将学生信息封装成到字典容器中,方便区分学生的信息.

# 学生信息1
stu1 = {
    'name': 'kid',
    'age': 18,
    'gender': 'male',
    'school' = 'xxx'
    'courses': []  # 可以用多门课程,先定义为一个空列表
}

# 学生信息2
stu2 = {
    'name': 'qq',
    'age': 18,
    'gender': 'male',
    'school' = 'xxx'
    'courses': []  # 可以用多门课程,先定义为一个空列表
}


# 选课函数
def elective(stu_name, stu_courses, course):
    stu_courses.append(course)
    print('%s成功选择%s课程!' % (stu_name, course))


# 调用函数选课
elective(stu1['name'], stu1['courses'], 'Python')  # kid成功选择Python课程!
elective(stu2['name'], stu2['courses'], 'linux')  # qq成功选择linux课程

5.推导3

学生选课系统 Version 3
函数名可以作为容器类型的元素.
对象的雏形:字典中同时具有学生数据和选课功能.

# 选课函数
def elective(stu, course):
    stu['courses'].append(course)
    print('%s成功选择%s课程!' % (stu['name'], course))


# 学生信息1
stu1 = {
    'name': 'kid',
    'age': 18,
    'gender': 'male',
    'courses': [],
    'school' = 'xxx'
    'elective': elective  # 使用函数的特性
}

# 学生信息2

stu2 = {
    'name': 'qq',
    'age': 18,
    'gender': 'male',
    'courses': [],
    'school' = 'xxx'
    'elective': elective  # 使用函数的特性
}

stu1['elective'](stu1, 'Python')  # kid成功选择Python课程!
stu2['elective'](stu2, 'Linux')  # qq成功选择Linux课程!

6.推导4

学生选课系统 Version 4
多个学生注册,字典中会产生一些重复且不变的数据.
将这部分的数据提取出来.定义成一个函数,存放在这个可以共用的容器中.
减少代码的冗余.

# 选课函数
def elective(stu, course):
    stu['courses'].append(course)
    print('%s成功选择%s课程!' % (stu['name'], course))


# 共同部分
Student = {
    'school': 'xxx',
    'elective': elective
}

# 学生信息1
stu1 = {
    'name': 'kid',
    'age': 18,
    'gender': 'male',
    'courses': [],
}

# 学生信息2
stu2 = {
    'name': 'kid',
    'age': 18,
    'gender': 'male',
    'courses': [],
}


Student['elective'](stu1, 'Python')  # kid成功选择Python课程!

Student['elective'](stu2, 'Linux')  # kid成功选择Linux课程!

Python语言提供了类来更好将数据和功能存放.

7.类的定义

类的作用：解决对象中数据的冗余。
7.1简介
对象:特征和技能的结合体
类:一系列相似的对象可以分为同一个类.
(同一个类中的事物都具备了相同的特征和技能)

站在不同的分类,划分的分类不一样.\:
我的盆友 xxx
xxx 与 石头 都是 东西类
xxx 与 猴子 都是 动物类
xxx 与 在座各位 都是人类 (你们都是大帅币)
7.2定义类
Python提供关键字 class 创建类.
语法格式:
class 类名(继承):
	""" 类的说明 """
	类体代码	

	
类名一般首字母大写,
# 注意事项：
1. 类名可以遵循变量名的命名规范
       驼峰体:
        大驼峰： UserName (类名推荐使用)
        小驼峰:  userName
# 2. 下划线 （类名尽量不使用使用）
类名后面的括号如果不写参数(继承)可以省略不写.

学生选课系统 Version 4 中
多个学生注册,字典中会产生一些重复且不变的数据.
数据-->学校  功能-->选课 

将对象中重复的数据提取出来.存放在一个共用的容器中.
那么这个容器可以是类.这个过程称为封装.
类就是为存放相同的特征和技能而存在.

定义类将相同的数据放入类中
在类中定义的变量称为 属性
在类中定义的函数称为 方法

class Student():
    # 定义属性 同一个学校
    school = 'xxx'

    # 定义方法 选课
    def elective(stu, course):
        stu['courses'].append(course)
        print('%s成功选择%s课程!' % (stu['name'], course))
7.3实例化造对象
类名加括号称为实例化.
实例化之后得到一个对象,为一个空字典{}. (默认为空)
(可以使用字典的方法.)

# 实例化得到一个对象 stu1
stu1 = Student()
print(stu1)  # <__main__.Student object at 0x000001E71ECEC5C0>

# __dict__　查看对象中的值
print(stu1.__dict__, type(stu1.__dict__))  # 结果为一个空字典   <class 'dict'>
7.4定义阶段
定义类发生的事:
1.立刻执行类体代码
2.产生一个类的名称空间,把类体内产生的名称都归档进名称空间.(字典)
3.把类的名称绑定给.__dict__ (类名.__dict__可以进行查看)

# 定义类
class Kind:
    num = 1
    print(num)  # 1


# 查看'字典'内的属性
print(Kind.__dict__)

"""
{'__module__': '__main__', 'num': 1,  <---< 看这里啊 <----<----<--
'__dict__': <attribute '__dict__' of 'Kind' objects>, 
'__weakref__': <attribute '__weakref__' of 'Kind' objects>,
 '__doc__': None}"""

8.对象独有属性

每次实例化之后的对象,都拥有自己独立的名称空间.
可以使用对象.__dict__查看对象中所有的值.
对象是一个字典,可以使用字典的方法.
一般情况下推荐使用对象的提供的.方式,不使用__dict__.
8.1增
实例化的对象是一个字典,使用字典添加值的方式,创建对象独有的属性.
对象.__dict__[key] = value
类提供.的方式创建值.
对象.key = value

# 定义类
class Student:
    # 定义属性 同一个学校
    school = 'xxx'

    # 定义方法 选课
    def elective(stu, course):
        stu['courses'].append(course)
        print('%s成功选择%s课程!' % (stu['name'], course))


# 实例化
stu1 = Student()
stu1.__dict__['name'] = 'kid'
stu1.__dict__['age'] = 18
stu1.__dict__['gender'] = 'male'
print(stu1.__dict__)  # {'name': 'kid', 'age': 18, 'gender': 'male'}

stu2 = Student()
# 类提供快捷方式
stu2.name = 'qz'
stu2.age = 18
stu2.gender = 'male'
print(stu2.__dict__)  # {'name': 'qz', 'age': 18, 'gender': 'male'}
8.2查
对象.__dict__[key]
对象.key

# 实例化
stu1 = Student()
stu1.__dict__['name'] = 'kid'
stu1.__dict__['age'] = 18
stu1.__dict__['gender'] = 'male'
print(stu1.__dict__)  # {'name': 'kid', 'age': 18, 'gender': 'male'}
print(stu1.__dict__['name'])  # kid
print(stu1.__dict__['age'])  # 18
print(stu1.__dict__['gender'])  # male


stu2 = Student()
# 类提供快捷方式
stu2.name = 'qz'
stu2.age = 18
stu2.gender = 'male'
print(stu2.__dict__)  # {'name': 'qz', 'age': 18, 'gender': 'male'}
print(stu2.name)  # qz
print(stu2.age)  # 18
print(stu2.gender)  # male
8.3改
对象.__dict__[key] = value (新值)
对象.key = value (新值)

# 实例化
stu1 = Student()
stu1.__dict__['name'] = 'kid'
stu1.__dict__['name'] = 'qzq'
stu1.age = 18
stu1.age = 19
print(stu1.__dict__['name'])  # qzq
print(stu1.age)  # 19
8.4删
# 实例化
stu1 = Student()
stu1.__dict__['name'] = 'kid'
del stu1.__dict__['name']
print(stu1.__dict__)  # {}

stu1.__dict__['age'] = 18
del stu1.__dict__['age']
print(stu1.__dict__)  # {}

9.推导5

学生选课系统 Version 5
1.先调用类产生一个对象(空字典{}),
2.在通过.的方式添加学生的数据到字典中.
3.对象调用方法,会将自己(对象自己)作为第一个参数进行传参,所以可以省略不写.

*** stu1.elective('Python') ==> stu1.elective(stu1, 'Python') ***

# 定义类
class Student:
    # 定义属性 同一个学校
    school = 'xxx'

    # 定义方法 选课
    def elective(stu, courses):
        stu.courses.append(courses)
        print('%s成功选择%s课程!' % (stu.name, courses))  # kid成功选择python课程!


# 实例化
stu1 = Student()
stu1.name = 'kid'
stu1.age = 18
stu1.gender = 'male'
stu1.courses = []

stu1.elective('Python')

# 实例化
stu2 = Student()
stu2.name = 'qz'
stu2.age = 19
stu2.gender = 'male'
stu2.courses = []

stu2.elective('Linux')

10.推导5升级

学生选课系统 Version 5升级
定义方法时约定俗成使用self作为形参接收对象.

# 定义类
class Student():
    # 定义属性 同一个学校
    school = 'xxx'

    # 定义方法 选课
    def elective(self, courses):
        self.courses.append(courses)
        print('%s成功选择%s课程!' % (self.name, courses))  # kid成功选择python课程!


# 实例化
stu1 = Student()
stu1.name = 'kid'
stu1.age = 18
stu1.gender = 'male'
stu1.courses = []

stu1.elective('Python')

# 实例化
stu2 = Student()
stu2.name = 'qq'
stu2.age = 19
stu2.gender = 'male'
stu2.courses = []

stu2.elective('Linux')

11.推导6

学生选课系统 Version 6升级

为对象增加值的过程重复,写进函数.
在创建对象独有属性时调用.

# 定义类
class Student:
    # 定义属性 同一个学校
    school = 'xxx'

    # 定义方法 选课
    def elective(self, courses):
        self.courses.append(courses)
        print('%s成功选择%s课程!' % (self.name, courses))  # kid成功选择python课程!




# 定义函数
def init(self, name, age, gender, courses):
    self.name = name
    self.age = age
    self.gender = gender
    self.courses = courses


# 实例化
stu1 = Student()
stu2 = Student()

init(stu1, 'kid', 18, 'male', [])
stu1.elective('Python')  # kid成功选择Python课程!


init(stu2, 'qz', 19, 'male', [])
stu2.elective('Linux')  # qz成功选择Linux课程!

12.推导7

函数部分是共用的,将共同分放进类中.

# 定义类
class Student:
    # 定义属性 同一个学校
    school = 'xxx'

    # 定义函数
    def init(self, name, age, gender, courses):
        self.name = name
        self.age = age
        self.gender = gender
        self.courses = courses

    # 定义方法 选课
    def elective(self, courses):
        self.courses.append(courses)
        print('%s成功选择%s课程!' % (self.name, courses))  # kid成功选择python课程!


# 实例化
stu1 = Student()
stu2 = Student()

Student.init(stu1, 'kid', 18, 'male', [])
Student.init(stu2, 'kid', 18, 'male', [])

stu1.elective('Python')  # kid成功选择Python课程!
stu2.elective('Linux')  # qz成功选择Linux课程!

13.推导7升级

类提供__init__方法,在实例时会自动执行__init__方法,
__init__方法会接收实例化时括号中传递的参数.类提供__init__方法,在实例时会自动执行__init__方法,
__init__方法会接收实例化时括号中传递的参数.
__init__方法称为初始化方法,它不能有返回值，如果非要返回，返回None.

# 定义类
class Student:
    # 定义属性 同一个学校
    school = 'xxx'

    def __init__(self, name, age, gender, courses):
        self.name = name
        self.age = age
        self.gender = gender
        self.courses = courses

    # 定义方法 选课
    def elective(self, courses):
        self.courses.append(courses)
        print('%s成功选择%s课程!' % (self.name, courses))  # kid成功选择python课程!


# 实例化
stu1 = Student('kid', 18, 'male', [])
stu1.elective('Python')

stu2 = Student('qz', 19, 'male', [])
stu2.elective('Linux')

最终的这个推导而来的就是面向对象编程,
对象编程:提前先定义类,在创造对象.

在这里插入图片描述

在这里插入图片描述

14.注意点

在这里插入图片描述

提示:实例属性应该在init中定义
在其他的方法对值进行修改的操作
而不是新增加,如果没初始化不要有值就写None.
开局签到Python基础
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
14.Python数据类型（五）【dict字典类型】
孤寒者的博客
06-24 10万+
14.Python数据类型（五）【dict字典类型】
VS2019 Boost.Python封装C++库学习记录
12-21
本人安装的是Python3，安装目录为C:\Python37； 1.下载boost库在windows下通过b2.exe自己尝试编译库文件，编译方法可参考本文。 boost库下载链接：下载链接 boost库编译方法：boost库编译方法 2.打开VS2019,新建类型...
python 列表推导式_Python对象类型之列表推导式
weixin_33617670的博客
01-13 166
intumu.com：机器学习（ML）、人工智能（AI）和土木工程的（TM）关系？​zhuanlan.zhihu.com着手开始写的时候就一直有一个画面在脑子中出现：小猪佩奇第N级，猪爸爸拿出来一本《混凝土的故事》，打开书的时候说道：混凝土是由砂子、水、水泥组成的，结果其他人都睡着了。于是，我在想，要是给土木人讲：python万法皆对象，对象类型有：数字:int,long,float,comple...
Python_面向对象_dict推导式
weixin_30641999的博客
07-30 105
字典推导式: {推导式} ***enumerate***""" 　　enumerate(sequence,[start=0]) 　　功能:将索引号和sequence的值一一对应组成一个个元祖放入迭代器中 　　sequence: 数据具有可迭代性 　　start: 选择开始的索引号(默认从0开始索引) 　　返回:迭代器"""...
python 之 推导式
xuefei1121的博客
08-15 177
推导式 概念: 通过一行循环判断,遍历一系列数据的方式叫推导式 语法: val for val in Iterable 三种方式: [val for val in Iterable] 列表推导式 {val for val in Iterable} 集合推导式 {k:v for k,v in Iterable} 字典推导式 ...
python 字典转对象
周迪新的博客
07-20 1133
class Struct: def __init__(self, **entries): self.__dict__.update(entries) args = {'a': 1, 'b': 2} s = Struct(**args) >>> s.a 1 >>> s.b 2
4.python学习路线
2301_78108987的博客
05-31 394
学习资源包括书籍《Python编程：从入门到实践》、《利用Python进行数据分析》、《流畅的Python》等，在线课程如Coursera, edX, Udemy上的Python课程，以及官方文档和社区如Stack Overflow, Reddit的Python板块，GitHub项目和代码示例。
Python 教学 | 列表推导式 & 字典推导式
weixin_55633225的博客
08-08 401
本期文章我们将详细介绍推导式中最常见的列表推导式和字典推导式。
Python简洁优雅的推导式
bigzql的博客
04-12 6729
❝Python语言有一种独特的推导式语法，相当于语法糖的存在，可以帮助你在某些场合写出较为精简酷炫的代码。但没有它，也不会有太多影响。Python语言有几种不同类型的推导式。❞1. 列表推...
python常用的推导式
albertjone的博客
04-30 3241
转自：http://www.liujiangblog.com/course/python/36Python语言有一种独特的推导式语法，相当于语法糖的存在，可以帮你在某些场合写出比较精简酷炫的代码。但没有它，也不会有太多的影响。Python语言有几种不同类型的推导式，下面逐一介绍：1. 列表推导式列表推导式是一种快速生成列表的方式。其形式是用方括号括起来的一段语句，如下例子所示：lis = [x *...
05.python面向对象.md
05-10
05.python面向对象.md
4.python面向对象1
08-08
4.python面向对象1
Python面向对象封装操作案例详解 II
09-18
主要介绍了Python面向对象封装操作,结合案例形式详细分析了Python面向对象在游戏中封装角色的属性、动作相关原理与使用技巧,需要的朋友可以参考下
64位和32位系统的python36.dll
03-25
由于各种原因，程序无法启动.计算机丢失python36.dll 或者 应用程序无法正常启动(0xc000007b)， 可以下载python36.dll放在相应系统下。
删除目录
橙子味冰可乐的博客
06-07 526
shutil.rmtree("C:\\demo\\test") # 删除C:\demo目录下的test子目录及其内容。os.rmdir("C:\\demo\\test\\dir\\mr") # 删除C:\demo\test\dir\mr目录。path = "C:\\demo\\test\\dir\\mr" # 指定要创建的目录。os.rmdir("C:\\demo\\test\\dir\\mr") # 删除目录。
自制植物大战僵尸：HTML5与JavaScript实现的简单游戏
m0_73367097的博客
06-08 1904
自制植物大战僵尸
基于JavaScript 如何实现爬山算法以及优化方案
乐闻世界
06-10 1204
爬山算法（Hill Climbing Algorithm）是一种常见的启发式搜索算法，常用于解决优化问题。其核心思想是从一个初始状态出发，通过逐步选择使目标函数值增大的邻近状态来寻找最优解。接下来，我们将通过 JavaScript 实现一个简单的爬山算法，帮助大家理解其原理和应用。从一个初始状态开始。评估当前状态的目标函数值。在当前状态的邻居中选择一个目标函数值更大的状态。如果找到了更优的邻居，则移动到该邻居并重复步骤2和步骤3。如果没有更优的邻居，则算法结束，当前状态即为局部最优解。
找出Python潜在的编程问题
最新发布
svygh123的专栏
06-13 786
Pylint 是一个非常强大的静态代码分析工具，主要用于检查 Python 代码的语法错误、代码风格问题以及潜在的编程错误。它是 Open Source Initiative 认证的开源软件，由 Logilab 团队开发维护。
python编程逐级进阶2
06-01
好的，我可以帮你回答关于Python编程逐级进阶的问题。以下是一些建议： 1. 深入学习Python的基础知识，包括变量、数据类型、运算符、流程控制语句、函数和模块等。 2. 学习Python的高级特性，如列表推导式、生成器、装饰器、上下文管理器等。 3. 学习Python的面向对象编程，包括类、对象、继承、多态和封装等。 4. 学习Python的函数式编程，包括高阶函数、匿名函数和闭包等。 5. 学习Python的并发编程，包括多线程、多进程、协程和异步编程等。 6. 学习Python的网络编程，包括Socket编程和HTTP协议等。 7. 实践项目，将所学的知识应用到实际项目中，以提高编程能力和实践经验。 希望这些建议能够帮助你进一步提高Python编程水平。如果你有任何疑问，请随时问我。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值