2.43数据库魔兽世界(2.43数据)

一季度中国GDP同比激增18.3% 上一次GDP增速达到两位数是10年前

央广网北京4月16日消息（记者 张圣琪）16日上午10时，国家统计局新闻发言人、国民经济综合统计司司长刘爱华在国新办新闻发布会上介绍了2021年一季度国民经济运行情况。

初步核算，一季度国内生产总值249310亿元，按可比价格计算，同比增长18.3%，比2020年四季度环比增长0.6%；比2019年一季度增长10.3%，两年平均增长5.0%。上一次中国GDP季度同比增速达到两位数，是2011年二季度。

分产业看，第一产业增加值11332亿元，同比增长8.1%，两年平均增长2.3%；第二产业增加值92623亿元，同比增长24.4%，两年平均增长6.0%；第三产业增加值145355亿元，同比增长15.6%，两年平均增长4.7%。

（图源自CFP）

刘爱华称，一方面，一季度国内生产总值同比增长18.3%，受到上年较低基数、员工就地过年工作日有所增加等不可比因素影响；另一方面，一季度环比增长0.6%，两年平均增长5.0%，表明我国经济稳定恢复。

一、农业生产总体平稳，生猪产能显著恢复

数据显示，一季度，农业（种植业）增加值同比增长3.3%，两年平均增长3.4%。目前，全国主要农区气候条件总体有利，春耕春播进展顺利，冬小麦总体长势略好于常年。一季度，猪牛羊禽肉产量2200万吨，同比增长21.4%，其中猪肉产量增长31.9%；牛奶产量增长8.5%，禽蛋产量下降2.1%。生猪产能显著恢复，一季度末，生猪存栏41595万头，同比增长29.5%，其中能繁殖母猪存栏4318万头，增长27.7%。

二、工业生产稳步回升，制造业增势良好

工业生产方面，一季度，全国规模以上工业增加值同比增长24.5%，环比增长2.01%；两年平均增长6.8%。其中，3月份规模以上工业增加值同比增长14.1%；环比增长0.60%。分经济类型看，一季度国有控股企业增加值同比增长16.9%；股份制企业同比增长23.7%，外商及港澳台商投资企业同比增长29.2%；私营企业同比增长29.7%。分三大门类看，采矿业增加值同比增长10.1%，两年平均增长4.0%；制造业同比增长27.3%，两年平均增长6.9%；电力、热力、燃气及水生产和供应业同比增长15.9%，两年平均增长4.8%。装备制造业和高技术制造业增加值同比分别增长39.9%、31.2%，两年平均分别增长9.7%、12.3%。从产品产量看，新能源汽车，工业机器人，挖掘、铲土运输机械，微型计算机设备，集成电路同比增速均超过60%，两年平均增速均超过19%。3月份，中国制造业采购经理指数为51.9%，连续13个月高于临界点；企业生产经营活动预期指数为58.5%。

（图源自CFP）

1-2月份，全国规模以上工业企业实现利润总额11140亿元，同比增长1.79倍，两年平均增长31.2%；规模以上工业企业营业收入利润率为6.60%，比2020年1-2月份提高3.15个百分点。

三、服务业恢复性增长，市场预期向好

“一季度，服务业稳定恢复，其中交通运输、仓储和邮政业，房地产业增加值同比分别增长32.1%、21.4%，两年平均分别增长6.6%、6.8%。”刘爱华说，3月份，全国服务业生产指数同比增长25.3%，两年平均增长6.8%。1-2月份，规模以上服务业企业营业收入同比增长37.8%，两年平均增长10.0%，其中信息传输、软件和信息技术服务业，科学研究和技术服务业营业收入同比分别增长35.0%、47.8%，两年平均分别增长17.4%、11.5%。3月份，服务业商务活动指数为55.2%，比2月份回升4.4个百分点。其中铁路运输、航空运输、电信广播电视卫星传输服务、互联网软件及信息技术服务、货币金融服务等行业商务活动指数运行在60.0%以上高位景气水平；受年初局部疫情影响较大的住宿、租赁及商务服务、居民服务等行业商务活动指数回升至景气区间。从市场预期看，服务业业务活动预期指数为62.9%，连续两个月位于60.0%以上高位景气区间。

四、市场销售逐步改善，网上零售快速增长

一季度，社会消费品零售总额105221亿元，同比增长33.9%，环比增长1.86%；两年平均增长4.2%。其中，3月份社会消费品零售总额35484亿元，同比增长34.2%，比1-2月份加快0.4个百分点，两年平均增长6.3%，环比增长1.75%。按经营单位所在地分，一季度城镇消费品零售额91345亿元，同比增长34.6%，两年平均增长4.3%；乡村消费品零售额13875亿元，同比增长29.4%，两年平均增长3.2%。按消费类型分，餐饮收入10596亿元，同比增长75.8%，两年平均下降1.0%；商品零售94625亿元，同比增长30.4%，两年平均增长4.8%。从商品类别看，一季度限额以上单位商品零售额中，18个商品类别同比增速均超过10%，其中体育娱乐用品类和通讯器材类商品同比分别增长45.2%、42.4%，两年平均分别增长17.4%、17.1%。全国网上零售额28093亿元，同比增长29.9%，两年平均增长13.5%。其中，实物商品网上零售额23067亿元，同比增长25.8%，两年平均增长15.4%；占社会消费品零售总额的比重为21.9%，比1-2月份提高1.2个百分点。

五、固定资产投资稳步恢复，高技术产业和社会领域投资增长较快

一季度，全国固定资产投资（不含农户）95994亿元，同比增长25.6%，环比增长2.06%；两年平均增长2.9%。其中3月份固定资产投资（不含农户）比上月环比增长1.51%。

刘爱华介绍，分领域看，一季度基础设施投资同比增长29.7%，两年平均增长2.3%；制造业投资同比增长29.8%，两年平均下降2.0%；房地产开发投资同比增长25.6%，两年平均增长7.6%。全国商品房销售面积36007万平方米，同比增长63.8%，两年平均增长9.9%；商品房销售额38378亿元，同比增长88.5%，两年平均增长19.1%。分产业看，第一产业投资同比增长45.9%，两年平均增长14.8%；第二产业投资同比增长27.8%，两年平均下降0.3%；第三产业投资同比增长24.1%，两年平均增长4.0%。民间投资同比增长26.0%，两年平均增长1.7%。高技术产业投资同比增长37.3%，两年平均增长9.9%；其中高技术制造业和高技术服务业投资同比分别增长41.6%、28.6%，两年平均分别增长10.7%、8.2%。高技术制造业中，医疗仪器设备及仪器仪表制造业、计算机及办公设备制造业投资同比分别增长50.0%、49.5%，两年平均分别增长9.1%、24.2%；高技术服务业中，检验检测服务业、研发设计服务业投资同比分别增长55.7%、48.2%，两年平均分别增长14.8%、21.5%。社会领域投资同比增长31.7%，两年平均增长9.6%；其中卫生、教育投资同比分别增长50.9%、27.0%，两年平均分别增长22.3%、10.4%。

六、货物进出口增势明显，贸易结构继续改善

一季度，货物进出口总额84687亿元，同比增长29.2%。出口46140亿元，同比增长38.7%；进口38547亿元，同比增长19.3%。进出口相抵，贸易顺差7593亿元。3月份，进出口总额30228亿元，同比增长24.0%。出口15554亿元，同比增长20.7%；进口14674亿元，同比增长27.7%。贸易结构继续优化。一季度，一般贸易进出口占进出口总额的比重为61.2%，比上年同期提高1.3个百分点。民营企业进出口占进出口总额的比重为46.7%，比上年同期提高4.4个百分点。

七、居民消费价格同比持平，工业生产者出厂价格同比上涨

一季度，全国居民消费价格同比持平。其中，3月份全国居民消费价格同比上涨0.4%，2月份下降0.2%；环比下降0.5%。一季度，城市下降0.1%，农村持平。分类别看，食品烟酒价格同比上涨0.6%，衣着下降0.2%，居住下降0.2%，生活用品及服务下降0.1%，交通通信下降1.4%，教育文化娱乐上涨0.3%，医疗保健上涨0.3%，其他用品及服务下降1.1%。在食品烟酒价格中，粮食价格上涨1.5%；鲜菜价格上涨4.8%；猪肉价格下降12.5%，其中3月份下降18.4%，降幅比2月份扩大3.5个百分点。一季度，扣除食品和能源价格后的核心CPI同比持平。

一季度，全国工业生产者出厂价格同比上涨2.1%。其中3月份同比上涨4.4%，涨幅比2月份扩大2.7个百分点，环比上涨1.6%。一季度，全国工业生产者购进价格同比上涨2.8%。其中3月份同比上涨5.2%，涨幅比2月份扩大2.8个百分点，环比上涨1.8%。

八、城镇调查失业率下降，就业形势总体稳定

一季度，全国城镇新增就业297万人。3月份，全国城镇调查失业率为5.3%，比2月份下降0.2个百分点，比上年同期下降0.6个百分点。本地户籍人口调查失业率为5.3%，外来户籍人口调查失业率为5.4%。16-24岁人口、25-59岁人口调查失业率分别为13.6%、4.8%。31个大城市城镇调查失业率为5.3%，比2月份下降0.2个百分点。3月份，全国企业就业人员周平均工作时间为46.9小时，比2月份增加0.6小时。一季度末，农村外出务工劳动力总量17405万人。

九、居民收入继续增加，农村居民收入增长好于城镇居民收入

一季度，全国居民人均可支配收入9730元，同比名义增长13.7%，两年平均名义增长7.0%；扣除价格因素同比实际增长13.7%，两年平均增长4.5%。按常住地分，城镇居民人均可支配收入13120元，同比名义增长12.2%，实际增长12.3%；农村居民人均可支配收入5398元，同比名义增长16.3%，实际增长16.3%。从收入来源看，全国居民人均工资性收入、经营净收入、财产净收入、转移净收入同比分别名义增长12.4%、19.5%、17.0%、10.7%。城乡居民人均收入比值2.43，比上年同期缩小0.09。全国居民人均可支配收入中位数8014元，增长12.7%。

刘爱华表示，总的来看，一季度国民经济呈现持续稳定恢复态势。“同时也要看到，全球疫情仍在蔓延，国际环境错综复杂，具有较强的不确定不稳定性；国内经济恢复的基础还不牢固，长期存在的结构性矛盾依然凸显，发展中又出现一些新情况新问题。”下一步，要持续巩固“稳”的基础、积蓄“进”的力量、守住“保”的底线，保持宏观政策连续性稳定性可持续性，深化改革开放创新，保持经济运行在合理区间，扎实推动经济高质量发展。

2.43神牧BIS装备 （Pre-raid）

　　牧师在前期各项属性都很缺，甚至是耐力。boss一个技能打过来如果没满血可能就被秒了。我们需要合理的分配属性，度过前期的真空期。

　　01 神牧BIS选择

　　头部：白色治愈兜帽

　　裁缝出品，品质保证。

　　项链：卡尔娅的勋章

　　任务关闭法力熔炉：艾拉最终奖励。

　　肩膀：原始月布护肩

　　裁缝出品，值得购买。

　　披风：羽叶披风

　　赛泰克大厅尾王出品。

　　胸甲：原始月布长袍

　　裁缝出品，非常棒的属性。

　　护腕：时光行者护腕

　　时光声望出品，找个T绑定一起吧。

　　手套：外科医生的手套

　　普通本就出，出了就roll吧，无敌的。

　　腰带：原始月布腰带

　　裁缝出品。

　　腿部：白色治愈短裤

　　裁缝出品。前期要想混得开，金币不会少花，但是这一套可以用到换t4。

　　靴子：平静便鞋

　　奥金尼地穴尾王出品

　　戒指1：先祖灵魂指环

　　这个在国内数据库发生了错误。我来翻译下：15智力，57点治疗加成，五秒回四蓝。出处是玛格汉声望崇敬。

　　戒指2：虚幻希望之戒

　　幽暗沼泽尾王出品

　　戒指3：灵魂师的沙塔尔印记

　　任务：火红岗哨之战，点击就送。

　　饰品1：殉难者精华

　　41个牌子，沙塔斯商人出售。

　　饰品2：无尽循环甲虫

　　黑色沼泽尾王出品，记得必刷。

　　饰品3：贫民窟祈祷之书

　　贫民窟崇敬声望出品

　　单手武器1：永恒之手

　　锻造出品，优秀。

　　单手武器2：冲击波权杖

　　暗影迷宫摩摩尔出品。

　　副手/盾牌1：天堂之泪

　　25个牌子。

　　副手/盾牌2：唤风者宝珠

　　塞纳里奥远征队崇拜。

　　魔棒：奥尔多灵魂魔棒

　　迷宫老1出品。

　　02 属性一览

　　治疗能量：2029

　　法术暴击：10.85%

　　智力：369

　　精神：301

　　五回：80

　　治疗量已经达标。但是其他属性略差。考虑到牧师的功能性，稳稳占据1到2个位置没有问题。

2.0 Python 数据结构与类型

数据类型是编程语言中的一个重要概念，它定义了数据的类型和提供了特定的操作和方法。在 python 中，数据类型的作用是将不同类型的数据进行分类和定义，例如数字、字符串、列表、元组、集合、字典等。这些数据类型不仅定义了数据的类型，还为数据提供了一些特定的操作和方法，例如字符串支持连接和分割，列表支持排序和添加元素，字典支持查找和更新等。因此，选择合适的数据类型是 python 编程的重要组成部分。

算数运算符在编程语言中是一种非常重要的工具，它用于执行数学运算。在 python 中，算数运算符大致可以分为 7 种类型：算术运算符、比较运算符、赋值运算符、逻辑运算符、位运算符、成员运算符和身份运算符。

除了运算符外，python 还支持多种数值类型，如int、float、bool和 complex复数等。这些数值类型的赋值和计算都是直观易懂的，因此，它们对于初学者来说是非常友好的。

数值间的数据互换可以参考如下列表:

函数名描述int(x)将 x 转换为一个整数long(x)将 x 转换为一个长整数float(x)将 x 转换为一个浮点数complex()创建一个复数str(x)将对象 x 转换为字符串repr(x)将对象 x 转换为表达式字符串eval(str)计算字符串中的有效 python 表达式tuple(x)将序列 x 转换为一个元组list(x)将序列 x 转换为一个列表chr(x)将一个整数转换为一个字符unichr(x)将一个整数转换为 Unicode 字符ord(x)将一个字符转换为它的整数值hex(x)将一个整数转换为一个十六进制字符串oct(x)将一个整数转换为一个八进制字符串

基本算术运算: 算数运算是任何一门编程语言中都存在的，使用算术运算可以实现对特定变量的加减乘除比较等基本功能，在Python中实现算数运算很容易。

>>> import math,os>>>>>> numberA = 10>>> numberB = 20>>> numberC = 10>>>>>> numberA + numberB30>>> numberA != numberBTrue>>> numberA += 10

位运算符号: 在程序中，位运算就是直接对整数在内存中的二进制位进行操作。

>>> a=60 # 60 = 0011 1100 >>> b=13 # 13 = 0000 1101>>>>>> c= a & b # 12 = 0000 1100>>> print("a与b: ",c)a与b: 12>>>>>> c= a | b # 61 = 0011 1101 >>> print("a或b: ",c)a或b: 61>>>>>> c=a^b # 49 = 0011 0001>>> print("a异或b:",c)a异或b: 49>>>>>> c=a << 2 # 240 = 1111 0000>>> print("a左移2",c)a左移2 240

其他运算符: 其他运算符包括常用的,逻辑运算,成员运算,身份运算等.

>>> num1 = 10>>> num2 = 20>>> num3 = 0>>> list = [10,20,30,40,50]>>>>>> num1 and num30>>> num1 in list # 判断num1是否在list里面True>>> num1 not in listFalse>>>>>> num1 is num3 # 判断两个标识符是不是引用自一个对象True>>> num1 is num2False>>> num1 is not num2True

整数转其他数值: 使用转换命令将一个整数转换为其他任意数值.

>>> number = 100>>>>>> float(number)100.0>>> complex(number)(100+0j)>>> str(number)'100'>>> chr(number)'d'>>> ord(chr(number))100

实现数值之间进制转换: 使用转换命令实现进制转换,bin二进制,oct八进制,hex十六进制,format也支持转换输出.

>>> import math>>>>>> number = 1024>>> bin(number)'0b10000000000'>>> oct(number)'0o2000'>>> hex(number)'0x400'>>>>>> format(number,"b")'10000000000'>>> format(number,"x")'400'>>>>>> int("-4d2",16)-1234

实现浮点数/负数之间运算: 复数的函数操作正弦、余弦和平方根，可以使用cmath模块

>>> import cmath,math>>> numberA = complex(2,4)>>> numberB = 3-5j>>> numberA,numberB # 复数相加((2+4j), (3-5j))>>>>>> numberA.real # 取实属部分2.0>>> numberA.imag # 取虚数部分4.0>>> math.ceil(3.14) # 四舍五入4>>> round(3.14) # 四舍五入3>>> cmath.sin(numberA)(24.83130584894638-11.356612711218174j)>>> cmaths(numberA)(-11.36423470640106-24.814651485634187j)>>> cmath.exp(numberA)(-4.829809383269385-5.5920560936409816j)

数值格式化输出: 针对数值做格式化,并对齐进行输出显示.

>>> number = 1234.56789>>>>>> format(number,"0.2f")'1234.57' # 格式化时精确2位小数>>>>>> "value = > {:>20.3f}".format(number) # 输出右侧对齐'value = > 1234.568'>>> "value = > {:<20.3f}".format(number) # 输出左侧对齐'value = > 1234.568 '>>> "value = > {:^20.3f}".format(number) # 输出居中对齐'value = > 1234.568 '

数值类型格式化输出: 实例化数字类型,或将其他类型转换为数字类型,或各种进制转换为十进制.

>>> temp = int(21) # 实例化数字类型>>> print(type(temp),temp) # 打印类型,和参数值<class 'int'> 21>>> print(int("110101",base=2)) # 将二进制转为十进制53>>> print(int("156",base=8)) # 将八进制转为十进制110>>> print(int("1A2C31",base=16)) # 将十六进制转为十进制17152492.2 字符类型

字符串是字符的集合，是一种常见的数据类型。python 提供了强大的字符串处理功能，以支持各种字符串操作。例如，您可以使用字符串运算符进行字符串拼接、比较和替换；您还可以使用字符串内置函数对字符串进行搜索、切片、大小写转换等操作。

总的来说，字符串是 python 编程中不可或缺的一部分，它们在处理文本数据、输入输出、网络通信等方面都发挥了重要作用。因此，学习和掌握 python 中的字符串操作是非常必要的。

接下来我们将找出几个比较常用的字符串函数来进行演示.

方法描述str.capitalize()将字符串的首字母变为大写str.title()将字符串中的每个单词的首字母大写str.upper()将字符串转换为大写str.lower()将字符串转换为小写strdex()返回字符串中指定子字符串的索引str.find()返回字符串中指定子字符串的索引strunt()返回字符串中指定元素出现的次数str.format()格式化字符串str()用指定字符填充字符串使其居中str.join()以指定字符串连接字符串str.split()使用指定字符作为分隔符来分割字符串str.strip()去除字符串左右两边的空格str.replace()查找并替换字符串中的元素str.isupper()判断字符串是否为大写str.islower()判断字符串是否为小写str.isalnum()判断字符串是否为字母或数字str.isalpha()判断字符串是否为字母或下划线str.isdigit()判断字符串是否为数字str.isspace()判断字符串是否为空格str.startswith()返回以指定元素开头的字符串str.endswith()返回以指定元素结尾的字符串

首字母大写: 使用capitalize()函数,将一个指定字符串首字母变成大写.

>>> str="hello lyshark">>>>>> str.capitalize()'Hello lyshark'

全部首字母大写: 使用title()函数,将字符串中的每一个单词的首字母大写.

>>> str="hello lyshark">>>>>> str.title()'Hello Lyshark'

查找字符串位置: 使用index()查找字符串所在位置(不能存在则报错),使用find()查找字符串位置(不存在返回-1).

>>> str = "hello lyshark">>>>>> strdex("hello")0>>> strdex("lyshark")6>>> str.find("hello")0

统计字符串出现次数: 使用count()函数,统计指定字符串的出现次数.

>>> str="hello lyshark">>>>>> strunt("h")2>>> strunt("l")3>>> strunt("hello")1>>> strunt("mk")0

字符串文本对齐: 字符串对齐函数实现对字符串的对齐与填充,字符串方法包括ljust()、rjust()和center()

>>> str = "hello lyshark">>>>>> str.ljust(30)'hello lyshark '>>> str.rjust(30)' hello lyshark'>>>>>> str(30)' hello lyshark '>>>>>> str(50,"-")'------------------hello lyshark-------------------'

字符串连接: 使用join()函数,将序列中以指定的字符连接生成一个新字符串

>>> str="-">>> seq=("hello","lyshark","welcome")>>>>>> print(str.join(seq))hello-lyshark-welcome>>>>>> list =['1','2','3','4','5']>>> print(''.join(list))12345>>>>>> 'kill %s' % ' '.join(['1024','2234'])'kill 1024 2234'

切割字符串: 使用split()函数,指定分割一个字符串,并保存成列表.

>>> str="hello-lyshark-welcome">>>>>> str.split("-")['hello', 'lyshark', 'welcome']

去除字符串两边空格: 使用strip()函数去除两边的空格,而lstrip/rstrip则是分别去掉两边空格.

>>> str=" hello lyshark ">>>>>> str.strip() # 去掉两边空格'hello lyshark'>>> str.rstrip() # 去掉右边空格' hello lyshark'>>>>>> str.lstrip()'hello lyshark '

去除字符串中注释行: 将一个文件中的以警号开头的行注释掉.

>>> import os>>>>>> with open("test.log","r") as fp:... for each in fp:... if each[0]== "#":... continue... else:... print(each,end="")

字符串查找并替换: 通过使用replace()函数或者是re.sub()函数,查找并替换指定字符串.

>>> string = "hello lyshark ! ?">>>>>> string.replace("lyshark","world")'hello world ! ?'>>>>>> string.replace("!","").replace("?","")'hello lyshark '>>>>>> string = " <br>hello lyshark</br> !">>>>>> re.sub('[<br> | </br> | ]',"",string)'hellolyshak!'

判断是否为大写: 使用isupper()函数,判断指定字符串是否为大写.

>>> str="LYSHARK">>> str1="lyshark">>>>>> str.isupper()True>>> str1.isupper()False

实现字符串拆分: 通过split拆分分解元素,将一个字符串拆解成多个部分.

>>> string = "python">>> # 拆分上面的字符串,忽略某个值使用下划线代替>>> x,_,_,y,_,_ = string>>> x'p'>>>>>> passwd = 'root:x:0:0:root:/root:/bin/bash'>>> username,*_,homedir,sh = passwd.split(":")>>> username'root'

查找开头结尾: 使用startswith函数,找出指定字母开头的字符元素,endswith找出字母结尾的元素.

>>> from fnmatch import fnmatch,fnmatchcase>>> url = "https://www.baidu">>>>>> url.endswith("")True>>> url.startswith("http://")False>>> url.startswith("https://") and url.endswith("")True>>> fnmatch(url,"*")True>>> filename = ["a.py","b.zip","c.zip","d.doc","e.py","f.jpg","g.gz","h.tar.gz"]>>>>>> [ item for item in filename if item.endswith((".py",".jpg")) ] # 多个结果匹配时使用元组集合['a.py', 'e.py', 'f.jpg']>>>>>> any(item.endswith(".py") for item in filename) # 判断目录中是否有.py结尾的文件True>>> names = ['dat01.csv','dat99.csv','configi','foo.py']>>>>>> [i for i in names if fnmatch(i,'dat[0-9]*.csv')] # 支持正则匹配查询['dat01.csv', 'dat99.csv']>>>>>> addr = [... '5412 N CLARK ST',... '1060 W ADDISON ST',... '1039 W GRANVILLE E',... '2122 N CLARK ST',... '4802 N BROADWAY' ]>>>>>> [ i for i in addr if fnmatch(i,'*ST') ]['5412 N CLARK ST', '1060 W ADDISON ST', '2122 N CLARK ST']>>>>>> [ i for i in addr if fnmatch(i,'*CLARK*') ]['5412 N CLARK ST', '2122 N CLARK ST']2.3 列表类型

列表（List）是最常用的数据结构之一，它是一个有序的、可变的、元素可以重复的集合。列表中的每个元素都可以根据它们在列表中的位置或索引进行访问，第一个元素的索引为0，第二个为1，以此类推。列表可以容纳任意类型的对象，包括整数、浮点数、字符串、函数等。

列表操作函数来进行演示.

方法名描述listsert()在列表中指定索引位置前插入元素listend()在列表尾部插入list.remove()删除指定的元素list.pop()没有指定索引，则弹出最后一个元素，返回的结果是弹出的索引对应的元素listpy()浅复制，只复制第一层，如果有嵌套序列则不会复制，需要复制要导入copy模块list.extend()把另外一个列表合并，并不是追加listdex()列表中元素出现的索引位置listunt()统计列表中元素的次数list.reverse()进行逆序listrt()进行排序，无法把数字和字符串一起排序list1 + list2合并两个列表，返回一个新的列表，不会修改原列表list * N把list重复N次，返回一个新列表

正向/反向输出列表: 简单的实现正向输出列表元素,与反向输出列表元素.

>>> list[1, 2, 3, 4, 5, 6, 7, 'python']>>>>>> for each in list:... print("正向输出: ",each)>>>>>> for each in reversed(list):... print("反向输出: ",each)

向列表追加数据: 使用append()函数,追加写入几个数据到指定的列表里.

>>> list = [1,2,3,4,5]>>>>>> listend(6)>>> listend(7)>>> listend("python")>>>>>> list[1, 2, 3, 4, 5, 6, 7, 'python']

向列表插入数据: 使用insert()函数,向指定的列表插入几个数据到指定的位置.

>>> list = ["admin","lyshark"]>>> list['admin', 'lyshark']>>>>>> listsert(1,"python")>>> list['admin', 'python', 'lyshark']>>>>>> listsert(2,"ruby")>>> listsert(2,"ruby")>>> list['admin', 'python', 'ruby', 'ruby', 'lyshark']

修改指定数据: 使用names[]变量赋值的方式,修改指定元素的字段值.

>>> list['admin', 'python', 'ruby', 'ruby', 'lyshark']>>> list[0]="mkdirs">>> list['mkdirs', 'python', 'ruby', 'ruby', 'lyshark']>>>>>> list[3]="pip">>> list['mkdirs', 'python', 'ruby', 'pip', 'lyshark']

删除指定数据: 使用remove()函数,删除指定数据,或使用del()函数来删除.

>>> list['mkdirs', 'python', 'ruby', 'pip', 'lyshark']>>> >>> del list[2] #通过下标删除元素>>> list['mkdirs', 'python', 'pip', 'lyshark']>>> >>> list.remove("python") #删除指定的元素>>> list['mkdirs', 'pip', 'lyshark']>>> >>> list.pop() #删除列表的最后一个元素'lyshark'>>> list.pop()'pip'>>> list['mkdirs']

扩展一个列表: 使用extend()函数,将一个列表追加到另一个列表的后面.

>>> list1 = ["admin","guest","lyshark"]>>> list2 = [1,2,3]>>>>>> list1.extend(list2)>>> list1['admin', 'guest', 'lyshark', 1, 2, 3]

浅COPY列表: 使用copy()函数,实现列表的浅Copy.

>>> list1['admin', 'guest', 'lyshark', 1, 2, 3]>>>>>> list1_copy = list1py()>>> list1_copy['admin', 'guest', 'lyshark', 1, 2, 3]

统计元素次数: 使用count()函数,统计列表中元素出现的次数.

>>> list = ["admin","admin","lyshark","mkdirs"]>>>>>> listunt("admin")2>>> listunt("mkdirs")1

列表正反向排序: 使用sort()函数实现正向排序,使用reverse()函数则实现反向排序.

>>> list = ["admin","python","ruby","1","3","6","9"]>>> list['admin', 'python', 'ruby', '1', '3', '6', '9']>>>>>> listrt() #正向排序,必须元素类型一致>>> list['1', '3', '6', '9', 'admin', 'python', 'ruby']>>>>>> list['1', '3', '6', '9', 'admin', 'python', 'ruby']>>> list.reverse() #反向排序,必须元素类型一致>>> list['ruby', 'python', 'admin', '9', '6', '3', '1']

获取列表元素下标: 使用index()函数,我们可以获取到指定元素的下标值.

>>> list['ruby', 'python', 'admin', '9', '6', '3', '1']>>>>>> listdex("admin")2>>> listdex("1")6

实现列表的切片: 使用[]特殊符号既可以定义列表,也可以实现列表的各种切片操作.

>>> list=[1,2,3,4,5,6,7,8,9,0]>>>>>> list[1:4] #取出下标1-4的元素,不包括4[2, 3, 4]>>>>>> list[1:-1] #取出下标1至-1,不包括-1[2, 3, 4, 5, 6, 7, 8, 9]>>>>>> list[1:] #取出下标从1到最后的数据[2, 3, 4, 5, 6, 7, 8, 9, 0]>>>>>> list[:] #取出所有元素[1, 2, 3, 4, 5, 6, 7, 8, 9]>>>>>> list[0::2] #取元素时每次格2格[1, 3, 5, 7, 9]

通过分片删除数据: 通过使用分片来清除指定列表中的数据.

>>> list[123, 111, 111, 111, 8, 7, 6, 5, 4, 3, 2, 1]>>> list[0:3][123, 111, 111]>>>>>> list[0:3]=[] #将下标0-3替换成空,不包括3>>> print(list)[111, 8, 7, 6, 5, 4, 3, 2, 1]>>>

嵌套列表的实现: 一次性声明两个列表,并于数据名称相关联.

>>> list1,list2 = [[1,"a","b"],[2,"a","b"]]>>>>>> print(list1)[1, 'a', 'b']>>> print(list2)[2, 'a', 'b']

从列表中随机弹出元素: 在一个列表中随机弹出一个元素.

>>> import random>>> from random import randrange>>>>>> list = ["admin","python","ruby","1","3","6","9"]>>>>>> random.choice(list)'python'>>> random.choice(list)'9'>>>>>> random_index = randrange(0,len(list))>>> list[random_index]'9'

列表元素查找并修改: 查找列表中的指定元素,并将列表中所有的元素1修改为88888.

>>> number = [1,2,3,4,5,1,5,6,1]>>>>>> def FindNumber(num_list,number,modify):... for item in range(num_listunt(number)):... ele_index = num_listdex(number)... num_list[ele_index] = modify...>>> number[1, 2, 3, 4, 5, 1, 5, 6, 1]>>> FindNumber(number,1,88888)>>> number[88888, 2, 3, 4, 5, 88888, 5, 6, 88888]

列表生成式筛选元素: 通过使用列表生成式,我们可以灵活地筛选出列表中的元素.

>>> from itertools import compress>>>>>> mylist = [1,2,-5,10,-8,3,-1]>>>>>> list(item for item in mylist if item > 0) # 筛选出列表中大于0的数值[1, 2, 10, 3]>>>>>> list(item for item in mylist if item < 0) # 筛选出列表中小于0的数值[-5, -8, -1]>>>>>> list(item if item>0 else 0 for item in mylist) # 大于0的数值直接输出,小于0的直接填0[1, 2, 0, 10, 0, 3, 0]>>>>>> more = [item > 3 for item in mylist] # 列表中大于3的返回真假>>> more[False, False, False, True, False, False, False]

统计列表中元素出现频率: 统计出number列表中所有元素的出现频率,并组合成字典.

>>> number = ["12:10","12:20","12:10","12:20","12:20","12:10","12:10"]>>>>>> def GetFrequency(item):... dict = {}... for x in item:... dict[x] = dict.get(x,0) + 1... return dict...>>> dict = GetFrequency(number)>>> dict{'12:10': 4, '12:20': 3}>>>>>> from collections import Counter>>>>>> data = [1,1,1,1,2,3,4,4,5,6,5,3,3,4,5,6,7,8,9,6,5,4,5]>>> Counter(data) # 统计列表元素出现次数,以字典方式展现Counter({5: 5, 1: 4, 4: 4, 3: 3, 6: 3, 2: 1, 7: 1, 8: 1, 9: 1})>>>>>> Counter(data).most_common() # 统计列表元素出现次数,以元组方式展现[(5, 5), (1, 4), (4, 4), (3, 3), (6, 3), (2, 1), (7, 1), (8, 1), (9, 1)]>>>>>> Counter(data).most_common(2) # 统计列表元素出现次数,并取出前两个元素[(5, 5), (1, 4)]

定义固定长度的列表: 使用collections.deque保存有限的列表数据,deque用来创建一个固定长度的队列.

>>> from collections import deque>>>>>> queue = deque(maxlen=4) # 定义最大可存储4个元素>>> queueend(1)>>> queueend(2)>>> queueend(3)>>> queueend(4)>>> queuedeque([1, 2, 3, 4], maxlen=4)>>> queueend(5)>>> queue # 超出部分会被从左侧排除出去deque([2, 3, 4, 5], maxlen=4)>>>>>> queueendleft(6) # 从左边加入数据到队列,超出部分从右侧排除>>> queuedeque([6, 2, 3, 4], maxlen=4)>>> queue.pop() # 从末尾取出一个数据4>>> queue.popleft() # 从左侧取出一个数据6

列表中取出最大/最小值: 在heapq模块中有两个函数nlargest()从最大的值开始取,nsmallest()从最小的值开始取.

>>> import heapq>>>>>> data = [1,3,4,9,11,34,55,232,445,9812,321,45,67,434,555]>>>>>> heapq.heappush(data,1000) # 追加写入一个元素>>> data[1, 3, 4, 9, 11, 34, 55, 232, 445, 9812, 321, 45, 67, 434, 555, 1000]>>> heapq.heappop(data) # 取出第一个元素>>> data[3, 9, 4, 232, 11, 34, 55, 1000, 445, 9812, 321, 45, 67, 434, 555]>>>>>> heapq.nlargest(3,data) # 取出最大的三个数[9999, 9812, 1000]>>> heapq.nsmallest(3,data) # 取出最小的三个数[4, 9, 11]

将二维列表横竖颠倒: 将一个横向排列的二维数组,以竖向排列,每一排代表一条记录.

>>> val = \ [ ["/etc/system/winsss", "/proc/", "/sys", "/abc/lyshark"], ["1024GG", "2048GB", "111GB", "1111GB"], ["1024GG", "2048GB", "111GB", "22GB"], ["10%", "50%", "20%", "33%"] ]>>> ref_xor = list ( map(list,zip(*val)) )>>> for num in ref_xor:... print(num)...['/etc/system/winsss', '1024GG', '1024GG', '10%']['/proc/', '2048GB', '2048GB', '50%']['/sys', '111GB', '111GB', '20%']['/abc/lyshark', '1111GB', '22GB', '33%']

多个列表的同步输出: 通过使用enumerate()/zip()函数,可以实现多个列表同时遍历输出.

>>> data = ["C","Java","python","Shell","Ruby","Go","perl"]>>># enumerate() 函数可用输出元素序列>>> for key,value in enumerate(data,1):... print(key,value)...1 C2 Java3 python4 Shell5 Ruby# 迭代打印一个嵌套列表结构>>> data = [(1,2),(3,4),(5,6)]>>>>>> for num,(key,value) in enumerate(data,1):... print("ID: {} Value: {} {}".format(num,key,value))...ID: 1 Value: 1 2ID: 2 Value: 3 4ID: 3 Value: 5 6# 同时迭代多个序列可使用zip()函数,它将迭代对象产生出一个元组,整个迭代的长度取其中最短的序列>>> list1 = [1,2,3,4,5]>>> list2 = ["a","b","c","d"]>>> list3 = ["jar","py","sh"]>>>>>> for x,y,z in zip(list1,list2,list3):... print(x,y,z)...1 a jar2 b py3 c sh>>> from itertools import zip_longest>>>>>> for each in zip_longest(list1,list2,list3):... print(each)...(1, 'a', 'jar')(2, 'b', 'py')(3, 'c', 'sh')(4, 'd', None)(5, None, None)

遍历列表的所有组合: itertools 模块中提供了3个函数来解决枚举所有列表元素的组合排列的可能情况.

>>> from itertools import permutations>>># 第一个itertools.permutations()>>> item = [1,2,3]>>> for each in permutations(item):... print(each)...(1, 2, 3)(1, 3, 2)(2, 1, 3)(2, 3, 1)(3, 1, 2)(3, 2, 1)# 如果要限定排序的长度可用指定长度参数>>> for each in permutations(item,2):... print(each)...(1, 2)(1, 3)(2, 1)(2, 3)(3, 1)(3, 2)

追加列表保持元素数: 保持列表中最多只有Size个元素,如果超出则自动shift左移或自动unshift右移,保证只有Size个元素.

>>> def shift(Array, Size, Push):... if len(Array) <= Size and len(Array) >= 0:... Array.pop(0)... Arrayend(Push)... return True... return False...>>> def unshift(Array, Size, Push):... if len(Array) <= Size and len(Array) >= 0:... Array.pop(Size-1)... Arraysert(0,Push)>>> >>> Array = [1,1,1,1,1,1,1,1,1,1]>>> >>> shift(Array,10,0)>>> shift(Array,10,0)>>> print(Array)[1, 1, 1, 1, 1, 1, 1, 1, 0, 0]>>> >>> unshift(Array,10,0)>>> unshift(Array,10,0)>>> print(Array)[0, 0, 1, 1, 1, 1, 1, 1, 1, 1]2.4 字典类型

字典（Dictionary）是一种内置数据结构，它是一种可变的容器模型，可以存储任意类型的对象，不仅如此，字典的一个重要特性是它可以通过任意不可变对象通常是字符串或数字来作为键key来存储和检索值value。字典是基于哈希表实现的，可以快速地根据键找到对应的值。

字典的定义使用大括号{}包含键值对，每个键值对使用冒号:连接键和值，键值对之间使用逗号, 分割。例如：

d = {'name': 'Alice', 'age': 20, 'gender': 'female'}

在上面的例子中，d 是一个字典，包含三个键值对，'name'、'age' 和 'gender' 分别是键，而它们对应的值分别是 'Alice'、20 和 'female'。可以使用键来访问对应的值，例如：

print(d['name']) # 输出 'Alice'

需要注意的是，字典中的数据是无序存储的，这意味着字典中的键值对的顺序不固定，不能通过下标来访问，只能通过键来访问对应的值。

另一个字典的特性是，字典中的键必须是唯一的，如果多个键对应的值相同，后面的键值对会覆盖前面的键值对。这是因为字典是基于哈希表实现的，每个键的哈希值是唯一的，如果多个键的哈希值相同，就会发生哈希冲突，这个冲突会被解决为一个链表。所以，字典中的键天生就是去重的。

如下是字典的几种格式声明:

person = {"name": "lyshark", "age": 22}person = dict({"name": "lyshark", "age": 22})info = { 'stu1': "administrator", 'stu2': "lyshark", 'stu3': "redhat",}

字典需要使用字典专有的操作函数,字典的常用函数有以下这几种,后面我会使用不同的例子进行说明.

函数描述dict.get(key)取得某个key的valuedict.has_key(key)判断字典是否有这个key（python3中已废除，使用in）dict.keys()返回所有的key为一个列表dict.values()返回所有的value为一个列表dict.items()将字典的键值拆成元组，全部元组组成一个列表dict.pop(key)弹出某个key-valuedict.popitem()随机弹出key-valuedict.clear()清除字典中所有元素dictpy()字典复制，d2=d1py()是浅复制，深复制需要copy模块dict.fromkeys(s)生成一个新字典dict.update(key)将一个字典合并到当前字典中dict.iteritems()生成key-value迭代器，可以用next()取下个key-valuedict.iterkeys()生成key迭代器dict.itervalues()生成values迭代器

增加字典: 在info字典的基础上,增加一个字段info["stu4"] = "root".

>>> info{'stu1': 'administrator', 'stu2': 'lyshark', 'stu3': 'redhat'}>>> info["stu4"] = "root">>>>>> info{'stu1': 'administrator', 'stu2': 'lyshark', 'stu3': 'redhat', 'stu4': 'root'}

修改字典: 在info字典的基础上,修改将stu1:administrator修改为stu1:centos.

>>> info{'stu1': 'administrator', 'stu2': 'lyshark', 'stu3': 'redhat', 'stu4': 'root'}>>>>>> info["stu1"] = "centos">>> info{'stu1': 'centos', 'stu2': 'lyshark', 'stu3': 'redhat', 'stu4': 'root'}

删除字典: 在info字典的基础上,删除几个字典,以下提供多种删除方法.

>>> info{'stu1': 'centos', 'stu2': 'lyshark', 'stu3': 'redhat', 'stu4': 'root'}>>>>>> info.pop("stu1") #通过pop函数删除'centos'>>> info{'stu2': 'lyshark', 'stu3': 'redhat', 'stu4': 'root'}>>>>>> del info["stu4"] #通过del命令删除>>> info{'stu2': 'lyshark', 'stu3': 'redhat'}>>>>>> info.popitem() #随机删除元素('stu3', 'redhat')

查找字典: 在info字典基础上,完成几个查询任务,这里提供几种方法.

>>> info{'stu1': 'administrator', 'stu2': 'lyshark', 'stu3': 'redhat'}>>>>>> "stu1" in info #标准的查询方式True>>>>>> info.get("stu1") #使用get函数查询'administrator'>>>>>> info["stu2"]'lyshark'

更新字典: 在info字典的基础上,更新字典内容,将temp字典与info字典合并.

>>> info{'stu1': 'administrator', 'stu2': 'lyshark', 'stu3': 'redhat'}>>>>>> temp = {1:2,"stu4":"root"}>>>>>> info.update(temp)>>> info{'stu1': 'administrator', 'stu2': 'lyshark', 'stu3': 'redhat', 1: 2, 'stu4': 'root'}

遍历字典: 这里提供两种字典遍历方法,建议使用第二种,因为其遍历速度最快.

>>> info = {'stu1': 'administrator', 'stu2': 'lyshark', 'stu3': 'redhat'}>>>>>> for keys,values in info.items():... print(keys,values)...stu1 administratorstu2 lysharkstu3 redhat>>> for keys in info:... print(keys,info[keys])...stu1 administratorstu2 lysharkstu3 redhat

索引字典: 字典也支持索引的方式获取字典中的元素,只不过必须以key作为索引.

>>> info = {'stu1': 'administrator', 'stu2': 'lyshark', 'stu3': 'redhat'}>>>>>> info['stu2']'lyshark'>>>>>> len(info)3>>>>>> dict = {"姓名":"administrator","得分":[98,99,87]}>>>>>> dict["姓名"]'administrator'>>> dict["得分"][98, 99, 87]>>> dict["得分"][2:][87]

字典嵌套: 字典内部可继续存放列表或新的字典,遍历时只需要逐级输出即可.

>>> info = {'name': 'lyshark', 'gender': 'male', 'age': 22, 'company': ['oldboy', 'beijing', 50]}>>>>>> info["name"]'lyshark'>>> info["company"][1]'beijing'>>>>>> info = {'name': 'lyshark', 'gender': 'male', 'age': 22, 'company': {'c_name': 'oldboy', 'c_addr': 'shandong'}}>>>>>> info["company"]["c_addr"]'shandong'

将字典解包: 将字典分解为独立的元组并将元组赋值给其他变量.

>>> dict = {"姓名":"administrator","得分":[98,99,87]}>>> t1,t2 = dict.items()>>>>>> print(t1)('姓名', 'administrator')>>> print(t2)('得分', [98, 99, 87])>>>>>> k1,k2 = {"x":100,"y":200}>>> print(k1)x

根据字典的值找键: 通常情况下是根据key找值,但是有时需要反过来,根据值找key.

>>> Dict = { "admin":"001" , "guest":"002" , "lyshark":"003" }>>>>>> Dict.get("admin",0) # 一般用法'001'>>> list(Dict.keys())[list(Dict.values())dex("001")] # 单值返回'admin'>>>>>> def get_keys(d, value): # 多值返回列表... return [k for k,v in d.items() if v == value]...>>> get_keys(Dict,"002")['guest']

列表合并为字典: 将两个列表合成一个字典,其中list1是key,list2是values.

>>> dict = {}>>> list = [100,200,300,400,500]>>> head = ["MemTotal","MemFree","Cached","SwapTotal","SwapFree"]>>>>>> for (keys,values) in zip(head,list):... dict[keys] = values...>>> dict{'MemTotal': 100, 'MemFree': 200, 'Cached': 300, 'SwapTotal': 400, 'SwapFree': 500}>>>>>> dict(map(lambda x,y:[x,y],head,list)){'MemTotal': 100, 'MemFree': 200, 'Cached': 300, 'SwapTotal': 400, 'SwapFree': 500}>>>>>> dict(zip(head,list)){'MemTotal': 100, 'MemFree': 200, 'Cached': 300, 'SwapTotal': 400, 'SwapFree': 500}

字典键值对调: 将字典中的键与字典中的值进行位置的对调,第一个是列表对调,第二个是字典对调.

>>> list = [100,200,300,400,500]>>> head = ["MemTotal","MemFree","Cached","SwapTotal","SwapFree"]>>>>>> {key:value for key,value in zip(head,list)}{'MemTotal': 100, 'MemFree': 200, 'Cached': 300, 'SwapTotal': 400, 'SwapFree': 500}>>>>>> {value:key for key,value in zip(head,list)}{100: 'MemTotal', 200: 'MemFree', 300: 'Cached', 400: 'SwapTotal', 500: 'SwapFree'}>>> dict = {'MemTotal': 100, 'MemFree': 200, 'Cached': 300, 'SwapTotal': 400, 'SwapFree': 500}>>>>>> {key:value for key,value in dict.items()}{'MemTotal': 100, 'MemFree': 200, 'Cached': 300, 'SwapTotal': 400, 'SwapFree': 500}>>>>>> {value:key for key,value in dict.items()}{100: 'MemTotal', 200: 'MemFree', 300: 'Cached', 400: 'SwapTotal', 500: 'SwapFree'}

字典拆分为列表: 将一个完整的字典拆分为两个列表.

>>> dict = {'stu1': 'administrator', 'stu2': 'lyshark', 'stu3': 'redhat'}>>> keys= dict.keys()>>> values = dict.values()>>>>>> print("keys:{}".format(keys))keys:dict_keys(['stu1', 'stu2', 'stu3'])>>>>>> dict = {'stu1': 'administrator', 'stu2': 'lyshark', 'stu3': 'redhat'}>>>>>> keys,values = zip(*dict.items())>>> print("Keys:",str(keys))Keys: ('stu1', 'stu2', 'stu3')>>> dict = {'stu1': 'administrator', 'stu2': 'lyshark', 'stu3': 'redhat'}>>>>>> keys = []>>> values = []>>> items = dict.items()>>> for x in items:... keysend(x[0]),valuesend(x[1])...>>> print(str(keys))['stu1', 'stu2', 'stu3']

字典合并与拷贝: 合并字典,但是在有相同的key时会覆盖原有的key的值.

>>> dict1 = {"x":1,"y":2}>>> dict2 = {"a":3,"b":4}>>> dict3 = {}>>>>>> dict3 = {**dict1,**dict2}>>> print(dict3){'x': 1, 'y': 2, 'a': 3, 'b': 4}>>>>>> dict3.update(dict1)>>> dict3.update(dict2)>>> print(dict3){'x': 1, 'y': 2, 'a': 3, 'b': 4}>>>>>> import copy>>> n1 = {"k1": "wu", "k2": 123, "k3": ["lyshark", 456]}>>> n2 = {}>>>>>> n2 = copy.deepcopy(n1)>>> print(n2){'k1': 'wu', 'k2': 123, 'k3': ['lyshark', 456]}

复杂字典数据存储: 首先定义三个字典用于存储用户信息,然后将其放入一个列表中,并对列表中的元素进行取值.

>>> dict1 = {"name":"admin","age":19,"salary":3000,"address":"beijing"}>>> dict2 = {"name":"guest","age":20,"salary":4000,"address":"shanghai"}>>> dict3 = {"name":"lyshark","age":21,"salary":5000,"address":"shenzhen"}>>> table = [dict1,dict2,dict3]# 用于获取指定人的指定字段数据>>> print(table[1].get("name"))guest>>> print(table[2].get("address"))shenzhen# 打印表格中所有人的名字>>> for i in range(len(table)):... print(table[i].get("name"))...adminguestlyshark

统计字典中的重复记录数: 就是统计两个字典中key的出现频率,并输出.

>>> dictA = {'a': 3,'c': 2, 'b': 1, 'd': 2, 'e': 1, 'r': 1, 'w': 2}>>> dictB = {'a': 3, 'b': 2, 'd': 1, 'c': 1, 'r': 2, 'e': 1, 's': 1, 'w': 1}>>>>>> def GetDict(A,B):... for key,value in B.items():... A[key] = A.get(key,0) + value... return A...>>> item = GetDict(dictA,dictB)>>> item{'a': 6, 'c': 3, 'b': 3, 'd': 3, 'e': 2, 'r': 3, 'w': 3, 's': 1}

让字典保持有序存储: 字典默认是无序排列的,使用内置模块,当对字典做迭代时,它会严格按照元素初始添加的顺序进行迭代.

>>> from collections import OrderedDict>>>>>> dict = OrderedDict()>>>>>> dict["one"] = 1>>> dict["two"] = 2>>> dict["three"] = 3>>>>>> for key,value in dict.items():... print(key,value)...one 1two 2three 3

字典中实现的列表推导: 通过使用列表推导式,对字典进行迭代操作,筛选字典元素.

>>> prices = {... 'ACME':45.23,... 'AAPL':612.78,... 'IBM':205.55,... 'HPQ':37.20,... 'FB':10.75,... }>>>>>> P1 = { key:value for key,value in prices.items() if value > 30 }>>>>>> print(P1){'ACME': 45.23, 'AAPL': 612.78, 'IBM': 205.55, 'HPQ': 37.2}>>>>>> tech = {'ACME','IBM','HPQ','FB'}>>> P2 = { key:value for key,value in prices.items() if key in tech }>>> print(P2){'ACME': 45.23, 'IBM': 205.55, 'HPQ': 37.2, 'FB': 10.75}>>>>>> P3 = dict((key,value) for key,value in prices.items() if value > 100)>>> P3{'AAPL': 612.78, 'IBM': 205.55}>>>>>> numbers = [ {'name':'GOOG','shares':50},{'name':'YHOO','shares':75} ]>>> sumnmber = sum(item["shares"] for item in numbers)>>> sumnmber125

字典中元素的排序: 使用zip()将字典中的值映射为元组的迭代器,并求最大值、最小值和排序.

>>> prices = {... 'ACME':45.23,... 'AAPL':612.78,... 'IBM':205.55,... 'HPQ':10.75,... 'FB':10.75... }>>>>>> max(zip(prices.values(),prices.keys()))(612.78, 'AAPL')>>>>>> min(zip(prices.values(),prices.keys()))(10.75, 'FB')>>>>>> sorted(zip(prices.values(),prices.keys()))[(10.75, 'FB'), (10.75, 'HPQ'), (45.23, 'ACME'), (205.55, 'IBM'), (612.78, 'AAPL')]

字典间差异对比与元素排除: 比较两个字典之间存在的差异,和排除字典中指定的key并生成新字典.

>>> dictA = {"x": 1 , "y": 2 , "z": 3}>>> dictB = {"a": 10 , "y": 11 , "z": 12}>>>>>> dictA.keys() & dictB.keys() # dictA和dictB中同时都有的Key{'y', 'z'}>>>>>> dictA.keys() - dictB.keys() # dictA中的键不在dictB中出现的Key{'x'}>>>>>> dictA.items() - dictB.items() # dictA和dictB中键值都相同的元素{('y', 2), ('x', 1), ('z', 3)}>>>>>> dictOld = { "admin":123 , "guest":456, "lyshark":123123, "zhangsan": 123456 }>>>>>> dictNew = { key:dictOld[key] for key in dictOld.keys() - {"guest","zhangsan"} }>>> dictNew{'lyshark': 123123, 'admin': 123}

高级字典列表的排序: operator模块中的itemgetter函数可以对嵌套数据结构的排序会非常简单且运行很快

>>> from operator import itemgetter>>> data = [... {'fname':'Brian','lname':'Jones','uid':1003},... {'fname':'David','lname':'Beazley','uid':1002},... {'fname':'John','lname':'Cleese','uid':1001},... {'fname':'Big','lname':'Jones','uid':1004},... ]>>>>>> sorted(data,key=itemgetter("uid")) # 以UID字段作为排序条件,从小到大的排列>>> sorted(data,key=itemgetter("uid"),reverse=True) # 以UID字段作为排序条件,从大到小的排列>>> sorted(data,key=itemgetter("uid","fname")) # 通过多个公共键排序>>> max(data,key=itemgetter("uid")) # 找出UID字段最大的一条字典

高级字典取出最大/最小值: 在heapq模块中有两个函数nlargest()从最大的值开始取,nsmallest()从最小的值开始取.

>>> import heapq>>>>>> data = [... {'name':'dhcp','port':67},... {'name':'mysql','port':3306},... {'name':'memcached','port':11211},... {'name':'nginx','port':80},... {'name':'ssh','port':22}]>>>>>> heapq.nlargest(2,data,key=lambda x:x["port"]) # 取出port字段最大的两个字典[{'name': 'memcached', 'port': 11211}, {'name': 'mysql', 'port': 3306}]>>>>>> heapq.nsmallest(3,data,key=lambda x:x["port"]) # 取出port字段最小的三个字典[{'name': 'ssh', 'port': 22}, {'name': 'dhcp', 'port': 67}, {'name': 'nginx', 'port': 80}]

高级字典记录的分组: itertools模块中的函数groupby()可以通过扫描序列,并将相同元素进行分组排序.

>>> from operator import itemgetter>>> from itertools import groupby>>>>>> rows = [... { "name":"c++","date": "2012/12/11" },... { "name":"python","date": "2016/01/12" },... { "name":"ruby","date": "2012/12/11" },... { "name":"perl","date": "2020/11/12" },... { "name":"c#","date": "2020/11/12" }... ]>>>>>> rowsrt(key=itemgetter("date")) # 通过date字段对字典进行排序>>> for date,items in groupby(rows,key=itemgetter("date")):... print("时间归档: {}".format(date))... for value in items:... print("--> {}".format(value))...时间归档: 2012/12/11--> {'name': 'c++', 'date': '2012/12/11'}--> {'name': 'ruby', 'date': '2012/12/11'}时间归档: 2016/01/12--> {'name': 'python', 'date': '2016/01/12'}>>># 根据数据分组来构建一个一键多值的字典 {'2012/12/11': [{'name': 'c++', 'date': '2012/12/11'}]>>> from collections import defaultdict>>> rows_data = defaultdict(type(list))>>> for row in rows:... rows_data[row["date"]]end(row)>>> print(rows_data)2.5 元组类型

元组是一种不可变的有序数据结构，由多个元素组成，每个元素可以是不同的数据类型，包括数字、字符串、元组等。元组的创建很简单，只需要使用小括号将元素括起来，并使用逗号隔开即可。元组一旦创建后，不能对其中的元素进行修改，所以也被称为只读列表。元组通常用于存储一些固定不变的数据，如一行记录或一组配置参数等。元组可以作为函数的参数和返回值，也可以与列表等数据类型进行相互转换。与列表不同，元组中的元素是不可变的，这使得元组在某些场景下比列表更加安全和高效。

函数名描述tupleunt(x)返回元组中x出现的次数tupledex(x)返回元组中第一个出现x的位置tuple1 + tuple2合并两个元组len(tuple)返回元组的长度max(tuple)返回元组中最大值min(tuple)返回元组中最小值tuple(seq)将列表转换为元组

创建元组: 同个几个实例看一下元组是如何被创建的.

>>> tup1 = ("google","baidu",1997,1998)>>> tup2 = (1,2,3,4,5,6,7)>>> tup3 = "a","b","c","d">>>>>> tup1('google', 'baidu', 1997, 1998)>>> tup2(1, 2, 3, 4, 5, 6, 7)>>> tup3('a', 'b', 'c', 'd')>>>>>> type(tup1)<class 'tuple'>

访问元组: 元组可以使用下标索引来访问元组中的值.

>>> tup1('google', 'baidu', 1997, 1998)>>>>>> print("tup1[0:]",tup1[0])tup1[0:] google>>> print("tup1[1:2]",tup1[1:2])tup1[1:2] ('baidu',)

连接元组: 元组中的元素值是不允许修改的,但我们可以对元组进行连接组合.

>>> tup1 = (1,2,3,4)>>> tup2 = ("abc","xyz")>>>>>> tup3 = tup1+tup2>>> print(tup3)(1, 2, 3, 4, 'abc', 'xyz')

删除元组: 元组中的元素值是不允许删除的,但我们可以使用del语句来删除整个元组.

>>> tup = ("admin","lyshark", 1997, 2000)>>>>>> print(tup)('admin', 'lyshark', 1997, 2000)>>> del tup;>>> print(tup)

列表转元组: 将一个列表,强制转换成元祖.

>>> list = ["admin","lyshark","guest"]>>>>>> tuple = tuple(list)>>>>>> tuple('admin', 'lyshark', 'guest')

数据统计: 通过使用count(),index()函数统计元组中的其他数据.

>>> tuple('admin', 'lyshark', 'guest')>>>>>> tupleunt("lyshark") #统计lyshark出现次数1>>> tupledex("lyshark") #统计lyshark索引位置1

元素修改: 在没有嵌套的情况,元组是不可变对象,但是元组内的列表是可变的.

>>> tup=("lyshark",[1,2,3,4,5])>>> tup('lyshark', [1, 2, 3, 4, 5])>>>>>> tup[1].pop()5>>> tup('lyshark', [1, 2, 3, 4])

元组解包: 将两个元组,查分开,分别存储在两个变量中.

>>> tup1,tup2=((1,2,3),("a","b","c"))>>> print(tup1)(1, 2, 3)>>>>>> print(tup2)('a', 'b', 'c')

创建可命名元组: 根据namedtuple可以创建一个包含tuple所有功能以及其他功能的类型.

>>> from collections import namedtuple>>>>>> tup = namedtuple("tup1",["x","y","z"])>>> obj = tup(1,2,3)>>>>>> obj.x1>>> obj.y2

任意长度对象分解元素: 从某个可迭代对象中分解出N个元素,可以使用python的*表达式.

>>> grades = (68,98,85,78,84,79,88)>>> first,*middle,last = grades>>> sum(middle) / len(middle)84.8>>>>>> records = [... ('foo',1,2,3),... ('bar',11,22,33),... ('foo',4,5,6),... ('bar',44,55,66),... ]>>> for tag,*args in records:... if tag == "foo":... print(*args)1 2 34 5 62.6 集合类型

集合是一种无序的、不重复的数据结构。集合中的元素必须是可哈希的，因此支持数字、字符串、元组等不可变类型，不支持列表、字典等可变类型。可以通过工厂函数set()或使用花括号{}来创建集合。将列表传入set()中可以快速实现去重，而添加重复元素则会被忽略。

集合可以进行并集、交集、差集等基本运算，也支持添加、删除、清空等操作。由于集合是无序的，因此不支持索引、切片等操作，只能通过迭代遍历来访问集合中的元素。

值得注意的是，集合支持使用推导式（set comprehension）来创建集合，形如{expression for item in iterable}，这在创建大型集合时比使用循环和add()方法更为高效。另外，python中还提供了frozenset()函数，创建一个不可变集合，它可以作为字典的键值，而普通集合不能作为键值。

方法说明set.add(item)将item添加到set中,如果item已经在set中,则无任何效果set.remove(item)从set中删除item,如果item不是set的成员,则引发KeyError异常set.discard(item)从set中删除item.如果item不是set的成员,则无任何效果set.pop()随机删除一个集合元素,并从set删除,有变量接收则会接收删除到的元素set.clear()删除set中的所有元素setpy()浅复制set.update(t)将t中的所有元素添加到set中,t可以是另一个集合、一个序列set.union(t)求并集,返回所有在set和t中的元素settersection(t)求交集,返回所有同时在set和t中的都有的元素settersection_update(t)计算set与t的交集,并将结果放入setset.difference(t)求差集,返回所有在set中,但不在t中的元素set.difference_update(t)从set中删除同时也在t中的所有元素set.symmetric_difference(t)求对称差集,返回所有set中没有t中的元素和t中没有set中的元素组成的集合set.sysmmetric_difference_update(t)计算set与t的对称差集,并将结果放入setset.isdisjoint(t)如果set和t没有相同项,则返回Trueset.issubset(t)如果s是t的一个子集,则返回Trueset.issuperset(t)如果s是t的一个超集,则返回True

set(): 实例化可变集合类型,或其他类型转换成集合类型.

(1) 实例化集合类型>>> s = set({"fedora","geentoo","debian","centos"})>>> print(type(s),s)<class 'set'> {'fedora', 'centos', 'debian', 'geentoo'}(2) 将其他类型转换成集合set类型>>> l = ["centos","centos","redhat","ubuntu","suse","ubuntu"]>>> s = set(l)>>> print(type(s),s)<class 'set'> {'ubuntu', 'centos', 'redhat', 'suse'}>>> d = {"kernel":"Linux","os":"ubuntu","version":"15.10"}>>> s = set(d.keys())>>> print(type(s),s)<class 'set'> {'kernel', 'version', 'os'}

frozenset(): 实例化不可变集合,或类型转换成不可变集合类型.

(1) 实例化不可变集合>>> fs = frozenset({"redhat","centos","fedora","debian","ubuntu"})>>> print(type(fs),fs)<class 'frozenset'> frozenset({'fedora', 'ubuntu', 'centos', 'debian', 'redhat'})(2) 类型转换成不可变集合>>> l = [1,2,3,4,4,5,5]>>> fs1 = frozenset(l)>>> print(type(fs1),fs1)<class 'frozenset'> frozenset({1, 2, 3, 4, 5})

创建集合: 使用两种方式分别创建一个集合元素.

>>> s = {"tom","cat","name","lyshark"}>>> s = set({"tom","cat","name","lyshark"})>>>>>> s{'tom', 'cat', 'name', 'lyshark'}>>> type(s)<class 'set'>

定义可变集合: 定义一个可变集合,集合中的元素不可重复,都是不同的.

>>> set_test = set("hello")>>> set_test{'o', 'e', 'l', 'h'}

定义不可变集合: 定义一个不可变集合,集合中的元素不可重复,都是不同的.

>>> set_test = set("hello")>>> set_test{'o', 'e', 'l', 'h'}>>>>>> no_set_test = frozenset(set_test)>>> no_set_testfrozenset({'o', 'e', 'l', 'h'})

求子集: 子集为某个集合中一部分的集合,故亦称部分集合.

>>> A = set('abcd')>>> B = set("cdef")>>> C = set("ab")>>>>>> C<A #C是A的子集True>>> C.issubset(A) #C是A的子集True>>> C<B #C不是B的子集False

求并集: 一组集合的并集是这些集合的所有元素构成的集合,而不包含其他元素.

>>> A{'d', 'a', 'c', 'b'}>>> B{'f', 'd', 'e', 'c'}>>>>>> A | B{'f', 'b', 'c', 'a', 'e', 'd'}>>> A.union(B){'f', 'b', 'c', 'a', 'e', 'd'}

求交集: 两个集合A和B的交集是含有所有既属于A又属于B的元素,而没有其他元素的集合.

>>> A{'d', 'a', 'c', 'b'}>>> B{'f', 'd', 'e', 'c'}>>>>>> A & B{'c', 'd'}>>> Atersection(B){'c', 'd'}

求差集: A与B的差集是,所有属于A且不属于B的元素构成的集合.

>>> A{'d', 'a', 'c', 'b'}>>> B{'f', 'd', 'e', 'c'}>>>>>> A - B{'a', 'b'}>>> A.difference(B){'a', 'b'}

对称差: 两个集合的对称差是只属于其中一个集合,而不属于另一个集合的元素组成的集合.

>>> A{'d', 'a', 'c', 'b'}>>> B{'f', 'd', 'e', 'c'}>>>>>> A ^ B{'f', 'b', 'a', 'e'}>>> A.symmetric_difference(B){'f', 'b', 'a', 'e'}

添加元素: 使用add()函数,向一个现有的集合添加一个元素.

>>> s = {1,2,3,4,5,6}>>> s{1, 2, 3, 4, 5, 6}>>> s.add("s")>>> s.add("e")>>> s.add("t")>>>>>> s{1, 2, 3, 4, 5, 6, 't', 's', 'e'}

清空集合: 使用clear()函数,清空一个集合中的所有元素.

>>> s{1, 2, 3, 4, 5, 6, 't', 's', 'e'}>>>>>> s.clear()>>>>>> sset()

删除指定元素: 使用remove,discard函数,删除集合中的指定元素.

>>> s = {1,2,3,4,5}>>> s{1, 2, 3, 4, 5}>>>>>> s.remove(3)>>> s{1, 2, 4, 5}

批量更新元素: 使用update()函数,用自己和另一个的并集来更新这个集合.

>>> s ={"p","y"}>>> s{'p', 'y'}>>>>>> s.update(["H","e"],{"1","2","3"})>>> s{'H', '1', 'y', 'p', '2', 'e', '3'}2.7 序列类型

序列类型是指由索引为非负整数的有序对象集合组成的数据类型，包括字符串、列表和元组。其中字符串是由字符组成的不可变序列，列表和元组都是由任意python对象组成的序列。列表支持插入、删除和替换元素等操作，而元组是不可变序列，对元素的操作是不支持的，但是可以嵌套包含列表和字典等可变对象进行操作。所有序列类型都支持迭代操作，可以通过for循环遍历序列中的每一个元素。此外，还可以使用切片操作对序列进行分片，以获取子序列或进行元素复制。

以下是几个常用的序列操作函数:

方法描述s + r连接字符串、数据s * n重复 s 的 n 次复制v1, v2, ..., vn = s变量解包 (unpack)s[i]索引s[i:j]切片s[i:j:stride]扩展切片x in s, x not in s成员关系for x in s:迭代all(s)如果 s 中的所有项都为 True，则返回 Trueany(s)如果 s 中的任意项为 True，则返回 Truelen(s)长度，元素个数min(s)s 中的最小项max(s)s 中的最大项sum(s[, initial])具有可选初始值的项的和，按照上面的处理

all判断: 如果temp中的所有项都为True,则返回True.

>>> temp = [1,1,1,1,1,1]>>> temp1 = [1,1,1,1,0,1]>>>>>> all(temp)True>>> all(temp1)False

any判断: 如果temp中的任意项为True,则返回True.

>>> temp = [1,1,1,1,1,1]>>> temp1 = [1,1,1,1,0,1]>>>>>> any(temp)True>>> any(temp1)True

len计算元素个数: 计算列表或字典等相关的元素个数.

>>> temp = [1,1,1,1,1,1]>>> len(temp)6

min返回最小: 返回列表中最小的数值.

>>> temp = [1,2,3,4,5,6,7,8,9]>>>>>> min(temp)1

max返回最大: 返回列表中最大的数值.

>>> temp = [1,2,3,4,5,6,7,8,9]>>>>>> max(temp)9

本文作者： 王瑞 本文链接： https://www.lyshark/post/5c5c4a4e.html 版权声明： 本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！