Skip to content
SRE运维进阶之路SRE运维进阶之路
github icon
    • 1 Python 简介

      • 1.1 初识Python
        • 1.2 Python 代码规范
          • 1.3 Python 虚拟环境
            • 1.4 使用 vscode 打造 python 开发环境
              • 1.5 pypi 配置国内镜像
              • 2 Python 基础

                • 2.1 Python基础语法
                  • 2.2 程序控制
                    • 2.3 Python数据类型

                      • 2.3.1 数值型
                        • 2.3.2 字符串 str
                          • 2.3.3 字节序列
                            • 2.3.4 列表 list & 元组 tuple
                              • 2.3.5 集合 set & 字典 dict
                            • 3 高级特性

                              • 3.1 线性结构特征 可迭代 & 切片
                                • 3.2 列表、集合、字典解析式
                                  • 列表解析式
                                    • 集合解析式
                                      • 字典解析式
                                        • 总结
                                        • 3.3 生成器
                                          • 3.4 迭代器
                                          • 4 函数

                                            • 4.1 函数的定义 & 调用 & 返回值
                                              • 4.2 函数参数
                                                • 4.3 作用域
                                                  • 4.4 递归函数
                                                  • 5 函数式编程

                                                    • 5.1 高阶函数
                                                      • 5.2 返回函数
                                                        • 5.3 匿名函数
                                                          • 5.4 装饰器
                                                            • 5.5 偏函数
                                                            • 6 模块

                                                              • 6.1 Python 模块常用的几种安装方式
                                                                • 6.2 Python 的 setup.py 详解
                                                                • 7 IO编程

                                                                  • 7.1 操作文件和目录
                                                                    • 7.2 序列化和反序列化
                                                                    • 8 异常、调试和测试

                                                                      • 8.1 异常处理
                                                                      • 9 面向对象编程

                                                                        • 9.1 类、实例和封装
                                                                          • 9.2 访问控制和属性装饰器
                                                                            • 9.3 继承、多态和Mixin
                                                                            • 10 进程和线程

                                                                              • 10.1 多进程
                                                                                • 10.2 多线程
                                                                                  • 10.2 线程同步
                                                                                  • 11 网络编程

                                                                                    • 11.1 SocketServer
                                                                                      • 11.2 TCP 编程
                                                                                      • 11 魔术方法
                                                                                        • 17 IO 模型
                                                                                          • python 实际工作中的实例
                                                                                          • 前端学习笔记

                                                                                            3.2 列表、集合、字典解析式

                                                                                            author iconClaycalendar icon2021年6月9日category icon
                                                                                            • Python
                                                                                            timer icon大约 2 分钟

                                                                                            此页内容
                                                                                            • 列表解析式
                                                                                            • 集合解析式
                                                                                            • 字典解析式
                                                                                            • 总结

                                                                                            # 3.2 列表、集合、字典解析式

                                                                                            # 列表解析式

                                                                                            列表解析式 List Comprehension,也叫列表推导式。

                                                                                            # 生成一个列表,元素0~9,将每一个元素加1后的平方值组成新的列表
                                                                                            x = []
                                                                                            for i in range(10):
                                                                                                x.append((i+1)**2)
                                                                                            print(x)
                                                                                            
                                                                                            1
                                                                                            2
                                                                                            3
                                                                                            4
                                                                                            5
                                                                                            # 列表解析式
                                                                                            print([(i+1)**2 for i in range(10)])
                                                                                            
                                                                                            1
                                                                                            2

                                                                                            语法

                                                                                            • [返回值 for 元素 in 可迭代对象 if 条件]
                                                                                            • 使用中括号[],内部是 for 循环,if 条件语句可选
                                                                                            • 返回一个新的列表

                                                                                            列表解析式是一种语法糖

                                                                                            • 编译器会优化,不会因为简写而影响效率,反而因优化提高了效率
                                                                                            • 减少程序员工作量,减少出错
                                                                                            • 简化了代码,增强了可读性
                                                                                            [expr for item in iterable if cond1 if cond2]
                                                                                            等价于
                                                                                            ret = []
                                                                                            for item in iterable:
                                                                                                if cond1:
                                                                                                	if cond2:
                                                                                                    	ret.append(expr)
                                                                                            #
                                                                                            [expr for i in iterable1 for j in iterable2 ]
                                                                                            等价于
                                                                                            ret = []
                                                                                            for i in iterable1:
                                                                                                for j in iterable2:
                                                                                                    ret.append(expr)
                                                                                            
                                                                                            1
                                                                                            2
                                                                                            3
                                                                                            4
                                                                                            5
                                                                                            6
                                                                                            7
                                                                                            8
                                                                                            9
                                                                                            10
                                                                                            11
                                                                                            12
                                                                                            13
                                                                                            14
                                                                                            # 因为循环或判断只有一个,一斜到底,所以结果相同
                                                                                            [(i,j) for i in range(7) if i>4 for j in range(20,25) if j>23]
                                                                                            [(i,j) for i in range(7) for j in range(20,25) if i>4 if j>23]
                                                                                            [(i,j) for i in range(7) for j in range(20,25) if i>4 and j>23]
                                                                                            # 都是[(5, 24), (6, 24)]
                                                                                            
                                                                                            1
                                                                                            2
                                                                                            3
                                                                                            4
                                                                                            5

                                                                                            # 集合解析式

                                                                                            语法

                                                                                            • {返回值 for 元素 in 可迭代对象 if 条件}
                                                                                            • 列表解析式的中括号换成大括号{}就变成了集合解析式
                                                                                            • 立即返回一个集合
                                                                                            {(x, x+1) for x in range(10)}
                                                                                            {[x] for x in range(10)} # 可以吗? 不可以 list是不可hash的
                                                                                            
                                                                                            1
                                                                                            2

                                                                                            # 字典解析式

                                                                                            语法

                                                                                            • {key:value for 元素 in 可迭代对象 if 条件}
                                                                                            • 列表解析式的中括号换成大括号{},元素的构造使用 key:value 形式
                                                                                            • 立即返回一个字典
                                                                                            print({x:(x,x+1) for x in range(10)})
                                                                                            print({x:[x,x+1] for x in range(10)})
                                                                                            print({(x,):[x,x+1] for x in range(10)})
                                                                                            # print({[x]:[x,x+1] for x in range(10)}) # 错误 key要求 可hash
                                                                                            print({str(x):y for x in range(3) for y in range(4)}) # 输出多少个元素? 返回三个元素,key值唯一,{'0': 3, '1': 3, '2': 3}
                                                                                            
                                                                                            1
                                                                                            2
                                                                                            3
                                                                                            4
                                                                                            5

                                                                                            # 总结

                                                                                            • Python2 引入列表解析式
                                                                                            • Python2.4 引入生成器表达式
                                                                                            • Python3 引入集合、字典解析式,并迁移到了2.7

                                                                                            一般来说,应该多应用解析式,简短、高效。如果一个解析式非常复杂,难以读懂,要考虑拆解成for循环。

                                                                                            生成器和迭代器是不同的对象,但都是可迭代对象。

                                                                                            如果不需要立即获得所有可迭代对象的元素,在Python 3中,推荐使用惰性求值的迭代器。

                                                                                            内建函数函数签名说明
                                                                                            sortedsorted(iterable[,key][,reverse])默认升序,对可迭代对象排序
                                                                                            立即返回列表
                                                                                            # 排序一定是容器内全体参与
                                                                                            print(sorted([1,2,3,4,5]))
                                                                                            print(sorted(range(10, 20), reverse=True))
                                                                                            print(sorted({'a':100, 'b':'abc'}))
                                                                                            print(sorted({'a':100, 'b':'abc'}.items()))
                                                                                            print(sorted({'a':'ABC', 'b':'abc'}.values(), key=str, reverse=True))
                                                                                            
                                                                                            1
                                                                                            2
                                                                                            3
                                                                                            4
                                                                                            5
                                                                                            6
                                                                                            edit icon编辑此页open in new window
                                                                                            上次编辑于: 2021/6/23 03:40:27
                                                                                            贡献者: clay-wangzhi
                                                                                            上一页
                                                                                            3.1 线性结构特征 可迭代 & 切片
                                                                                            下一页
                                                                                            3.3 生成器
                                                                                            备案号:冀ICP备2021007336号
                                                                                            Copyright © 2023 Clay