Python 数据结构

最新推荐文章于 2021-01-29 09:29:41 发布
最新推荐文章于 2021-01-29 09:29:41 发布
阅读量256 收藏
点赞数
分类专栏： Python 文章标签： python 数据类型
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/c0586/article/details/82503751
版权

2.数据结构

  • 列表
  • 元组
  • 字典
  • 集合
  • 文本和字符序列
  • collection系列
  • 容器序列
    list,tuple,collections.deque 这些序列存放不同类型的数据
  • 扁平序列
    str,bytes,bytearray,memoryview,array.array 这类序列只能容纳一种类型
  • 可变序列
    list,bytearray,array.array, collections.deque, memoryview
  • 不可变序列
    tuple, str, bytes

列表

列表 能存放不同类型的元素，有序，可变序列，最基础最重要的序列。

'''创建列表的方式
1. 创建方式：[] 或 list()。
2. 列表的基本操作：索引index、切片 、追加append、删除del remove pop、长度len、循环for while、包含 x in obj[]、extend()、reverse()
'''
# 创建列表
list_test = ['aa',11,"##"]
print(list_test)
list_test_0 = list('abc')
print(list_test_0)

# 获取列表第二个元素
list_test[1]

# 列表切片
print(list_test[:1])
print(list_test[:-1])
print(list_test[1:2])

# 追加元素
list_test_0.append('bb')
list_test_0
['aa', 11, '##']
['a', 'b', 'c']
['aa']
['aa', 11]
[11]





['a', 'b', 'c', 'bb']

'''
列表推导是一种构建列表的方式
'''
symbols = '@#￥%'
codes = []
for symbol in symbols:
    codes.append(ord(symbol))
print("for循环：", codes)

codes = [ord(symbol) for symbol in symbols] # ord()返回对应的 ASCII 数值，或者 Unicode 数值
print("列表推导：" , codes)
for循环： [64, 35, 65509, 37]
列表推导： [64, 35, 65509, 37]

# 列表推导笛卡尔积
colors = ['black','white']
sizes = ['S','M','L']
tshirsts = [(color,size) for color in colors for size in sizes]
tshirsts
[('black', 'S'),
 ('black', 'M'),
 ('black', 'L'),
 ('white', 'S'),
 ('white', 'M'),
 ('white', 'L')]

'''
列表推导的作用只有一个：生成列表！
初始化元组，数组或其他序列类型，生成器表达式更好，它遵守迭代器协议，逐个产出元素,不是一次弹出所有的元素，节省内存。
生成器表达式 和列表推导语法相似，[] 换成（）而已
'''
# 生成器表达式生成 元组 ，数组
symbols = '@#$'
tuple(ord(symbol) for symbol in symbols)

import array
array.array('I',(ord(symbol) for symbol in symbols))
array('I', [64, 35, 36])

元组

不可变的“列表”，可用于没有字段名的记录（同关系表的记录），有序，不可变序列。

'''
1. 创建：用小括号 ( ) 表示或者tuple()，
2. 元组与列表一样有基本操作：索引、切片、循环、长度、包含。 没有插入、删除某一元素的操作。
'''
tuple_test = ('a',1,[2,'b'])  # 元组中只有一个元素 （a,）须加逗号消除歧义
tuple_test

tuple('aa')
tuple(['c',3,4])
('c', 3, 4)

# 元组拆包
lax_coordinates = (33.22,-118.11)
city, year, pop, chg, area = ('Tykyo', 2003,32450,0.66,8014)  # 用元组的每个值分别赋值给变量 其实已是一种元组拆包的应用
traveler_ids = [('USA','32205855'),('BRA','CE342567'),('ESP','XDA205856')]
for passport in sorted(traveler_ids):
    print('%s/%s' % passport)

for country, _ in traveler_ids:  # 并不是对元组所有的元素都有兴趣，占位符 "_" 可以帮我们解决
    print(country)

# 用“*”来处理剩下的元素
# a, b,*rest = range(5)
# a,b,rest

# 嵌套元组拆包
mutil= [ ('a','b',1,(0.1,0.2)),('w','q',2,(0.3,0.4))]
fmt = '{:15} | {:9.4f}| {:9.4f}'
for n1, n2, n3, (x, y) in mutil:
    print(fmt.format(n1,x,y))
BRA/CE342567
ESP/XDA205856
USA/32205855
USA
BRA
ESP
a               |    0.1000|    0.2000
w               |    0.3000|    0.4000

'''
具名元组，又有称命名元组
collections.namedtuple 构建带字段名的元组和一个有名字的类，这对调试程序有很大的帮助。
'''
# card = collections.namedtuple('Card',['rank','suit'])
from collections import namedtuple
City = namedtuple('ty','name country  population coordinates') # 两个参数:类名，字段名。
tokyo = City('Tokyo','JP',36.933,(35.689722, 139.691667))
print(tokyo)
print(tokyo.population)
print(tokyo.coordinates)
print(City._fields) # 包含这个类的所有字段名称的元组
ty(name='Tokyo', country='JP', population=36.933, coordinates=(35.689722, 139.691667))
36.933
(35.689722, 139.691667)
('name', 'country', 'population', 'coordinates')
  • 大部分情况下，除了跟增减元素相关的方法之外，元组支持列表的其他所有方法

切片

列表，元组，字符串 这类序列支持切片

# 切片和区间会忽略最后一个元素
l = [10,20,30,40,50,60,70]
print(l[1])
print(l[:2])
print(l[2:])
print(l[:3])
s='tensorflow'
print(s[::3])
print(s[::-2])
20
[10, 20]
[30, 40, 50, 60, 70]
[10, 20, 30]
tsfw
wlrse

# 给切片赋值 ,赋值右侧需要是可迭代的对象
l = list(range(10))
l[2:5] = [20,30]
print(l)
del l[5:7]
print(l)
[0, 1, 20, 30, 5, 6, 7, 8, 9]
[0, 1, 20, 30, 5, 8, 9]

# 对序列使用+ 和*  两者不修改原来的序列，构建一个全新的序列,
# python tutor 来查看python运行原理
l = [1,2,3]
print(l*3)
print(l)
print(l+[9,8,7])
[1, 2, 3, 1, 2, 3, 1, 2, 3]
[1, 2, 3]
[1, 2, 3, 9, 8, 7]

''' 
list.sort 和 内置函数sorted
list.sort就地改动原来的列表，不会产生新表，返回None。sorted正好相反
两者都有可选的关键字参数：reverse, key
'''
fruits = ['grape','raspberry','apple','banana']
sorted(fruits)
sorted(fruits, reverse=True) # 降序排序
sorted(fruits, key=len) # 按照元素长度 排序
['grape', 'apple', 'banana', 'raspberry']
  • 如1000万浮点数 数组处理的很好，频繁对序列先进先出 deque(双端队列)速度很快，检查元素是否出现在集合中 set 更合适
'''
数组array.array
如对于1000万个浮点数，数组处理要好的多，
序列只包含数字，array.array 比list 效率更高
操作：.pop , .insert , .extend , .frombytes , .tofile
'''
from array import array 
from random import random
floats = array('d',(random() for i in range(10**7))) # 'd' 代表浮点数类型， 第二个参数可迭代对象是生成器的表达式
floats[1]
0.9267320195098516

字典

能够直接将一个对象映射到另一个对象，被存储的对象为值，被索引的对象为键，即键值对。
使用dict{}构造函数和{}快捷语法（较常用）来构造一个字典，如dic = {‘k1’:’v1’} 等价 dic=dict(k1=’v1’)。
基本操作：新增d[key]、删除del d[key]、键值对keys,values,items、循环、长度、fromkeys()

字典使用了高效的哈希算法，内部的键值对之间是无序的。字典循环时，默认循环key。

  • 可散列的数据类型
    若一个对象是可散列的，在他的生命周期汇总，它的散列值是不变，可用hash()方法实现
    原子不可变数据类型 如str、bytes和数值类型 ，都是可散列的类型。
    元组 中所有的元素是可散列的，该元组才是可散列的。
'''
创建：dict{}构造函数和{}快捷语法（较常用）来构造一个字典，如dic = {'k1':'v1'} 等价 dic=dict(k1='v1')。
'''
a = dict(one=1,two=2,three=3)
print(a)
b = {'one':1,'two':2,'three':3}
print(b)
c = dict(zip(['one','two','three'],[1,2,3]))
print(c)
d = dict([('two',2),('one',1),('three',3)])
e = dict({'three':3,'one':1,'two':2})
a==b==c==d==e
{'one': 1, 'two': 2, 'three': 3}
{'one': 1, 'two': 2, 'three': 3}
{'one': 1, 'two': 2, 'three': 3}





True

'''
字典推导  
可以从任何以键值对作为元素的可迭代对象中构建出字典。
'''
DIAL_CODES = [
    (86, 'China'),(91, 'India'),(1, 'United States'),(62, 'Indonesia'),(55,'Brazil'),(92,'Pakistan'),(880,'Bangladesh')
]
country_code = {country: code for code, country in DIAL_CODES} # 字典生成器
print(country_code)
{'China': 86, 'India': 91, 'United States': 1, 'Indonesia': 62, 'Brazil': 55, 'Pakistan': 92, 'Bangladesh': 880}

# setdefault 处理找不到的键
my_dict={'a':1,'b':2}
new_value=3
my_dict.setdefault('c', []).append(new_value)
# 等价于
if 'c' not in my_dict:
    my_dict['c'] = []
my_dict['c'].append(new_value)
# 后者进行了两次查询，若键值不在 就要查三次；setdefault只需要查一次。
print(my_dict)
{'a': 1, 'b': 2, 'c': [3]}

# defaultdict 处理找不到的键的一个选择
dd.defaultdict(list)
# 表达式dd['new-key']按照步骤：
# 调用list()类建立一个新列表
# 把这个新列表作为值，‘new_key’作为它的键，放到dd中
# 返回这个列表的引用


# 特殊方法 __missing__ 
# 当有类继承了dict类，在__getitem__找到不到键的时候，会自动调用__missing__，而不是抛出异常。

字典的变种

  • collectinos.OrderedDict
    这类型在添加键的时候，会保持顺序，键的迭代次序总是一致的。

  • collections.ChainMap
    该类型可容纳数个不同的映射对象，然后进行键查找操作的时候，这些对象会被当作一个整体被逐个查找。

  • collecions.Counter
    这个映射类型会给键准备一个整数的计数器，每次更新一个键的时候都会增加这个计数器。

  • collections.UserDict
    是让用户继承写子类的。

'''
不可变的映射类型：
之前见过不可变的序列，是否存在不可变的字典类型。
python3.3开始，types模块映入了一个封装类名MappingProxyType， 传给此类映射，会返回一个只读的映射视图，但是动态的（可以操作改动）
'''
from types import MappingProxyType
d = {1:'A'}
d_proxy = MappingProxyType(d)
# d_proxy[2] = 'B'  #抛出异常，不支持修改，
d[2]='B' # 对原来的字典 d 修改，发现MappingProxyType 的也被修改了
d_proxy
mappingproxy({1: 'A', 2: 'B'})

集合

  1. 集合的本质就是许多唯一对象的集合，集合可以用于去重。在爬虫中使用避免爬出重复的数据。
  2. 集合使用set()构造函数，或{}花括号（这里用逗号分隔值，不同与字典需要用冒号来分隔键值）
  3. 集合和字典是无序的，所以其不能通过索引查找，都是使用基于哈希的底层数据结构。
  4. 使用集合的目的：将全部事物分为两组：“属于集合的事物”和“不属于集合的事物”
  5. 将集合遍历很简单，但是对集合排序，则需要转换为列表。
'''
创建：set()构造函数，或{}花括号（这里用逗号分隔值，不同与字典需要用冒号来分隔键值）
'''
l = ['spam','spam','eggs','spam']
set(l)

# '''
# 以下{}创建形式，创建一个空集 使用不带任何参数的set()，但如果用{}会创建一个空字典 
# '''
# se = {'span',1,'asd'} #看起来和数学形式一摸一样能够
# se
{'eggs', 'spam'}

'''
字典中散列表
散列表本质是稀疏矩阵，散列表里的单元叫作表元bucket，dict的散列表中，每个键值都占用一个表元，表元：1对键的引用，2对值的引用。
表元大小一样，通过偏移量来读取某个表元。
对象存入到散列表中，首先要计算这个元素键的散列值。hash()方法

散列表算法
为获取my_dict[search_key]背后的值，python会调用hash(search_key)计算search_key的散列值，把这值最低的几位数字当作偏移量，在散列表里查找表元。
若表元是空的，则返回keyerror。若不为空，表元里会有一对 found_key:found_value。会被检验 search_key == found_key是否为真，相等的话返回found_value。

散列冲突
search_key 和found_key 不匹配，就称为散列冲突。

对字典的迭代并修改
最好：首先对字典迭代，得出需要添加的内容，把这些内容放在一个新的字典里， 迭代结束后再对原有的字典进行修改。

set的实现及导致的结果
set的实现需要依赖散列表，在散列表里只存放元素的引用（字典里是只存放键）。
集合中的元素必须是可散列的
集合很消耗内存
集合中判断元素的存在是非常迅速的
元素的次序取决于被添加到集合的次序
往集合添加元素，可能会改变集合中已有元素的次序
'''
'\n字典中散列表\n散列表本质是稀疏矩阵，散列表里的单元叫作表元bucket，dict的散列表中，每个键值都占用一个表元，表元：1对键的引用，2对值的引用。\n表元大小一样，通过偏移量来读取某个表元。\n对象存入到散列表中，首先要计算这个元素键的散列值。hash()方法\n\n散列表算法\n为获取my_dict[search_key]背后的值，python会调用hash(search_key)计算search_key的散列值，把这值最低的几位数字当作偏移量，在散列表里查找表元。\n若表元是空的，则返回keyerror。若不为空，表元里会有一对 found_key:found_value。会被检验 search_key == found_key是否为真，相等的话返回found_value。\n\n散列冲突\nsearch_key 和found_key 不匹配，就称为散列冲突。\n\n对字典的迭代并修改\n最好：首先对字典迭代，得出需要添加的内容，把这些内容放在一个新的字典里， 迭代结束后再对原有的字典进行修改。\n\nset的实现及导致的结果\nset的实现需要依赖散列表，在散列表里只存放元素的引用（字典里是只存放键）。\n集合中的元素必须是可散列的\n集合很消耗内存\n集合中判断元素的存在是非常迅速的\n元素的次序取决于被添加到集合的次序\n往集合添加元素，可能会改变集合中已有元素的次序\n'

文本序列和字节序列

有话说：人类使用文本，计算机使用字节序列。

c0586
关注
专栏目录
python元组和列表都支持的方法_python列表方法和元组
weixin_35171513的博客
01-29 1896
Python列表方法1、append()在列表末尾追加新对象>>> lst=[1,2,3]>>> lst[1, 2, 3]>>> lst.append(4)>>> lst[1, 2, 3, 4]2、count()统计元素再列表中的出现次数>>> lst[1, 2, 3, 4, 1]>>> l...
史上最全Python列表和元组的使用方法及区别 详解
python_first1的博客
05-10 749
本文主要介绍了python列表和元组的区别,通过示例代码的详细介绍，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考！
Python元组与列表的异同点详解
zag666的博客
03-15 5984
Python元组与列表的异同点 相同点： 列表和元组都属于有序序列； 都支持使用双向索引访问其中的元素； 以及使用count()方法统计指定元素的出现次数和index()方法获取指定元素的索引，len()、map()、filter()等大量内置函数和+、in等运算符也都可以作用于列表和元组。 不同点： 元组属于不可变序列，不可以直接修改元组中元素的值，也无法为元组增加或删除元素。 >...
python--列表
shenhaiwhales的博客
09-21 211
列表 简单数据类型： 1.整形<class ‘int’> 2.浮点型<class ‘float’> 3.布尔型<'class ‘bool’> 容器数据类型： 1.列表<class ‘list’> 2.元组<class ‘tuple’> 3.字典<class ‘dict’> 4.集合<class ‘set’> 5.字符串<class ‘str’> 列表的定义 列表是有序集合，没有固定大小，能够保存任意数量任意类型的
python列表和元组的方法和属性
weixin_34364071的博客
07-04 352
python序列的共性 python序列包括列表和元组，序列都有索引，第一个元素索引为0，序列都可以进行索引、加、乘、切片、检查成员。 python列表 列表是最常用的数据类型之一，通过[，，，]建立，可以给变量赋值空列表[]。列表的数据项可以是不同类型的，可以嵌套。 列表的索引和字符串操作一样，同样可以截取例如a[1:2] / a[1:] / a[:3] 列表的更新： 1.修改...
Python数据结构与算法分析（第2版）1
08-03
【Python数据结构与算法分析（第2版）】是一本专为Python程序员设计的书籍，旨在帮助读者深入了解数据结构和算法在Python环境中的应用。作者布拉德利·米勒和戴维·拉努姆以其丰富的实战经验，清晰地阐述了如何高效...
Python数据结构课程 数据结构与算法Python语言描述 配套源代码集合 共9个章节.rar
02-26
【完整源码列表】 chapter_01_Introduction chapter_03_Linear_List chapter_04_String chapter_05_Stack_and_Queue chapter_06_Binary_tree chapter_07_Graph chapter_08_Dict_and_Set chapter_09_Sort
数据结构python数据结构练习题目与源代码
最新发布
06-05
3. python数据结构 4. python三大结构 5. 函数 第二部分--线性数据结构 1. 线性表 第三部分--非线性数据结构 1. 树和二叉树 2. 图 第四部分--数据结构操作 1. 查找 2. 排序 例如： 第七章 哈夫曼编码 # 树节点类...
Python数据结构与算法分析.docx
09-13
Python 数据结构与算法分析 Python 数据结构与算法分析是计算机科学中的一门重要课程，涵盖了数据结构和算法两个方面的内容。在 Python 中，数据结构是指对数据的组织、存储和管理方式，而算法则是指解决问题或完成...
python元组和列表都支持的方法_Python学习（四）—— 列表和元组的类中方法
weixin_39939530的博客
11-26 590
列表list：用中括号括起来，用“，”分割每个元素，列表中的元素可以是 数字、字符串、列表、布尔值......所有东西，可以说就是一个“集合”li = [1,3,5,'alex','age',['sister',5],True]列表是有序的支持用索引、切片的方式取值支持for、while循环列表元素是可以用索引、切片的方式进行修改和删除的1 li = [1,3,5,'alex','age',['s...
python元组和列表都支持的方法是_Python进阶1－元组和列表
weixin_39661129的博客
01-29 541
本系列文章是一系列学习笔记，希望较为深入地分析Python3中的原理、性能，文章中绝大部分观点都是原作作者的观点(如下)，本人对书中示例加以实践和总结，并结合相应的Python的C语言源码(3.6.1)，分享出来。原著：《High Performance Python》by O'Relly Media，作者Micha Gorelick，Ian Ozsvald《Fluent Python》by O'...
(3)python 列表和元组
ainixi7099的博客
02-01 165
列表 元组 字段 等都是一种数据结构。其中列表和元组比较相似都是顺序保存的，都可以通过索引来找到元素。 列表和元组的主要区别：列表是可以修改的，元组不可以修改。列表用[]表示，元组用()表示 一、列表、元组的通用用法 1.通过索引使用元素 也可以直接使用索引，不需要赋值给变量 如果函数返回一个序列，可对返回结果进行索引操作 2.切片 也就是截取字符...
Python元组
manmanoy的博客
06-09 419
元组：Python 的元组与列表类似，不同之处在于元组的元素不能修改。      元组使用小括号，列表使用方括号。      元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。      元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用，如：a(1) 1是数字类型      元组与字符串类似，下标索引从0开始，可以进行截取，组合不可以添加,修改 删除，     ...
python基础知识（1）——列表和元组
码上的生活
03-04 971
序列概览在python中，最基本的数据结构是序列（sequence）。序列中的每个元素被分配一个序列号–即元素的位置，也称索引。第一个索引是0，第二个是1。 列表和元组是python最常用的两种类型。列表和元组的主要区别在于，列表可以修改，元组则不能。通用序列操作索引（index）、分片（slicing）、加（adding）、乘（multiplying）、以及检查某个元素是否属于序列的成员（成员资
Python基础入门：从变量到异常处理（Task02-1列表）——天池
weixin_43848117的博客
09-07 932
1.列表 x = [0 for i in range(5)] print(x, type(x)) [0, 0, 0, 0, 0] <class ‘list’> x = [i for i in range(100) if (i % 2) != 0 and (i % 3) == 0] print(x, type(x)) [3, 9, 15, 21, 27, 33, 39, 45, 51, 57, 63, 69, 75, 81, 87, 93, 99] <class ‘list’> 1.1
列表和元组常见的函数及方法
qq_31835117的博客
07-18 1505
num=[1,2,3,4,5,6,7] 列表里面常用的函数和方法 list('hello') 返回的是一个列表 del num[0] 按照索引号进行删除一个列表中的元素 另外一种删除方式是用插入空来删除 例如num[1:1]=[] 相当于删除了数值2 方法：调用方式 对象.方法（） 在列表末尾追加新的对象x.append（） num.append(4)  ;num=[1,2,3,4...
python 的序列方法，元组和列表的方法。
Taoqun的专栏
04-11 882
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值