Python中的四种数据结构

转自 https://www.cnblogs.com/pychina/p/10219772.html

Python中的内置数据结构（Built-in Data Structure）:列表list、元组tuple、字典dict、集合set，涵盖的仅有部分重点。

 目录：

一、列表list

二、元组tuple

三、字典dict

四、集合set


一、列表list

list的显著特征：

  1. 列表中的每个元素都可变的，意味着可以对每个元素进行修改和删除；
  2. 列表是有序的，每个元素的位置是确定的，可以用索引去访问每个元素；
  3. 列表中的元素可以是Python中的任何对象；
  4. 可以为任意对象就意味着元素可以是字符串、整数、元组、也可以是list等Python中的对象。

----数据操作：

1、直接创建列表

mylist = [‘Google‘, ‘Yahoo‘, ‘Baidu‘]

2、对列表中的指定位置变更数据

mylist = [‘Google‘, ‘Yahoo‘, ‘Baidu‘]

#变更索引位置1Yahoo的内容为Microsoft
mylist[1] = ‘Microsoft‘

#运行结果： [‘Google‘, ‘Microsoft‘, ‘Baidu‘]

3、在列表后面追加元素

mylist.append(‘Alibaba‘)  #运行结果： [‘Google‘, ‘Microsoft‘, ‘Baidu‘, ‘Alibaba‘]

一、列表

4、在指定位置插入元素

mylist.insert(1, ‘Tencent‘)  # [‘Google‘, ‘Tencent‘, ‘Microsoft‘, ‘Baidu‘, ‘Alibaba‘]

5、删除元素

mylist = [‘Google‘, ‘Tencent‘, ‘Microsoft‘, ‘Baidu‘, ‘Alibaba‘]

# 删除尾部元素
mylist.pop()      # 会返回被删除元素
# 删除指定位置的元素
mylist.pop(1)  # 删除索引为1的元素，并返回删除的元素

mylist.remove(‘Microsoft‘) #删除列表中的Microsoft

del mylist[1:3]       #删除列表中索引位置1到位置 3 的数据

6、替换元素

mylist[0] = ‘Baidu‘
mylist[1] = [‘python‘, ‘java‘, ‘php‘]  # 集合的数据类型可以不同，也可以是集合

7、列表排序

mylist = [1, 2, 5, 4]
mylist.sort()          # [1, 2 ,4, 5]

如果列表里面是字母，则根据Ascii码来排序

8、获取列表长度

mylist = [1, 2, 5, 4]
len(mylist)

9、获取列表指定位置的数据

mylist = [‘Google‘, ‘Tencent‘, ‘Microsoft‘, ‘Baidu‘, ‘Alibaba‘,‘Sina‘]
#获取索引位置1的数据
mylist[1]        #‘Tencent‘
#获取索引位置1到5的数据，注意这里只会取到索引位置4,这里叫做取头不取尾
mylist[1:5]   # ‘Tencent‘, ‘Microsoft‘, ‘Baidu‘, ‘Alibaba‘
#获取从最头到索引位置5的数据
mylist[ :5]   #‘Google‘, ‘Tencent‘, ‘Microsoft‘, ‘Baidu‘, ‘Alibaba‘

#获取从索引位置2开到最后的数据
mylist[2:]    #‘Microsoft‘, ‘Baidu‘, ‘Alibaba‘,‘Sina‘

10、用循环来创建列表

a = [1,2,3,4,5,6]
#在a的数据基础上每个数据乘以10，再生成一个列表b，
b = [i*10 for i in a]
print(a)
print(b)

#运行结果如下:
#    [1, 2, 3, 4, 5, 6]
#    [10, 20, 30, 40, 50, 60]

11、过滤列表中的内容放入新的列表中

#生成一个从1到20的列表

a = [x for x in range(1,20)]

#把a中所有偶数生成一个新的列表b

b = [m for m in a if m % 2 == 0]

print(b)

#运行结果如下:
#        [2, 4, 6, 8, 10, 12, 14, 16, 18]

12、嵌套式生成列表

#生成一个列表a
a = [i for i in range(1,4)]
print(a)

#生成一个列表b
b = [i for i in range(100,400) if i % 100 == 0]
print(b)

# 嵌套式
c = [m+n for m in a for n in b]
print(c)

#运行结果：
#    [1, 2, 3]
#    [100, 200, 300]
#    [101, 201, 301, 102, 202, 302, 103, 203, 303]

Python中包含6中內建的序列：列表，元组，字符串、Unicode字符串、buffer对象和xrange对象。

----list函数

>>> list("Hello world")
[‘H‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘, ‘ ‘, ‘w‘, ‘o‘, ‘r‘, ‘l‘, ‘d‘]

可以通过list将序列创建为列表。

其实list为一种类型并非函数，但此处二者并无多大区别。下面的tuple、dict也是如此。

二、元组tuple

重点：元组Tuple，用法与List类似，但Tuple一经初始化，就不能修改，没有List中的append(), insert(), pop()等修改的方法，只能对元素进行查询

下面看个例子来证实一下我们说的：

>>> a = (1,2,3,4)
>>> a
(1, 2, 3, 4)
>>> print(type(a))
<class ‘tuple‘>
>>> a[1]=5
Traceback (most recent call last):
  File "<pyshell#3>", line 1, in <module>
    a[1]=5
TypeError: ‘tuple‘ object does not support item assignment
>>> a[1:1] = 5
Traceback (most recent call last):
  File "<pyshell#4>", line 1, in <module>
    a[1:1] = 5
TypeError: ‘tuple‘ object does not support item assignment
>>> a[1]
2

从上面的例子，证实了tuple不支持对元素的修改（包括删除），tuple一初始化便固定下来了。

再来看一个例子：

>>> a = (‘a‘,‘b‘,[‘A‘,‘B‘])
>>> print(type(a))      #检测a的数据类型是什么
<class ‘tuple‘>        #检测出a的类型是元组tuple
>>> print(a)
(‘a‘, ‘b‘, [‘A‘, ‘B‘])
>>> a[2][0] = ‘X‘    #尝试变更数据，成功了，为什么？
>>> a[2][1] = ‘y‘
>>> print(a)            #打印出变更后的内容
(‘a‘, ‘b‘, [‘X‘, ‘y‘])
>>> print(type(a[2]))    #检测a的数据类型是什么
<class ‘list‘>                #检测出a[2]的类型是list

这里看似元素中的元素改变了，可是仔细分析下，元组中的第三个元素是一个列表。

代码4,5行改变的是列表中的值，元组所指的这个元素列表并没有改变，需要注意这点！

这就涉及到Python中的可变对象和不可变对象，像list这样的就是可变对象，tuple便是不可变对象。

元组是固定的列表，那么元组的意义何在呢？

因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple并且需要注意元组中元素的可变性！！

空的tuple可以记为()，若只有一个元素的tuple记为(1,)

t = (1,)  # 如果需要是Tuple，就必须加上逗号，否则变成成了数字1了
# 这里如果没有“,”就变成了“(1)”

因为记为(1)的话，这个实际代表的是数字1，此时()是数学公式中的小括号

因为元组是固定的列表，所以其内置的大多数的方法和列表是差不多的。

可以通过tuple将序列转换为元组，用法和list一样

>>> tuple(‘Hello,world!‘)
(‘H‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘, ‘,‘, ‘w‘, ‘o‘, ‘r‘, ‘l‘, ‘d‘, ‘!‘)

三、字典dict（dictionary）

字典dictionary全称这个概念就是基于现实生活中的字典原型，生活中的使用名称-内容对数据进行构建，Python中使用键(key)-值(value)存储，也就是java、C++中的map。

dict的显著特征：

  • 字典中的数据必须以键值对的形式出现，即k,v：

　　　　　　key:必须是可哈希的值，比如intmstring,float,tuple,但是，list,set,dict不行

　　　　　　value:任何值

  • 键不可重复，值可重复

　　　　　　键若重复字典中只会记该键对应的最后一个值

  • 字典中键(key)是不可变的，何为不可变对象，不能进行修改；而值(value)是可以修改的，可以是任何对象。

　　　　　　在dict中是根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。

----字典生成创建方式

#创建空字典1

d = {}
print(d)

#创建空字典2
d = dict()

#直接赋值方式

d = {"one":1,"two":2,"three":3,"four":4}

#常规字典生成式

dd = {k:v for k,v in d.items()}
print(dd)

#加限制条件的字典生成方式

ddd = {k:v for k,v in d.items() if v % 2 ==0}
print(ddd)

----字典的常见操作_____访问、删除、变更字典里面的内容

#访问字典中的数据
d = {"one":1,"two":2,"three":3,"four":4}
print(d["one"])
#变更字典里面的数据
d["one"] = "eins"
print(d)

#删除一个数据,使用del
del d["one"]
print(d)

#运行结果如下：
1
{‘one‘: ‘eins‘, ‘two‘: 2, ‘three‘: 3, ‘four‘: 4}
{‘two‘: 2, ‘three‘: 3, ‘four‘: 4}

----字典中成员检测

d = {"one":1,"two":2,"three":3,"four":4}

if 2 in d:
    print("value")

if "two" in d:
    print("key")

if ("two",2) in d:
    print("kv")

----使用for循环访问字典

d = {"one":1,"two":2,"three":3,"four":4}
#使用for循环，直接按key值访问

for k in d:
    print(k,d[k])

#上述代码也可以写成如下

for k in d.keys():
    print(k,d[k])

#只访问字典的值

for v in d.values():
    print(v)

#以下是特殊用法

for k,v in d.items():
    print(k,‘--->‘,v)

----字典相关函数

通用函数：len,max,min,dict

d = {"one":1,"two":2,"three":3,"four":4}
print(max(d))
print(min(d))
print(len(d))

dict() 函数的使用方法：

dict0 = dict()  # 传一个空字典
print(‘dict0:‘, dict0)

dict1 = dict({‘three‘: 3, ‘four‘: 4})  # 传一个字典
print(‘dict1:‘, dict1)

dict2 = dict(five=5, six=6)  # 传关键字
print(‘dict2:‘, dict2)

dict3 = dict([(‘seven‘, 7), (‘eight‘, 8)])  # 传一个包含一个或多个元祖的列表
print(‘dict3:‘, dict3)

dict5 = dict(zip([‘eleven‘, ‘twelve‘], [11, 12]))  # 传一个zip()函数
print(‘dict5:‘, dict5)

str(字典)：返回字典的字符串格式

d = {"one":1,"two":2,"three":3,"four":4}

print(str(d))

clear：清空字典

items：返回字典的键值对组成的元组格式

d = {"one":1,"two":2,"three":3,"four":4}

i = d.items()
print(type(i))
print(i)

d.clear()
print(d)

keys：返回字典的键组成的一个结构

d = {"one":1,"two":2,"three":3,"four":4}
k = d.keys()
print(type(k))
print(k)

values：返回字典的值组成的一个结构

d = {"one":1,"two":2,"three":3,"four":4}
v = d.values()
print(type(v))
print(v)

get：根据制定键返回相应的值，好处是可以设置默认值

d = {"one":1,"two":2,"three":3,"four":4}

print(d.get("one333"))

#get默认值是None,可以设置
print(d.get("one",100))
print(d.get("one222",100))

fromkeys：使用指定的序列作为键，使用一个值作为字典的所有的键的值

p = ["one","two","three","four",]
#注意fromkeys两个参数的类型
#注意fromkeys的调用主体
d = dict.fromkeys(p,"222")
print(d)

四、集合set

  • 集合更接近数学上集合的概念。集合中每个元素都是无序的、不重复的任意对象。
  • 可以通过集合去判断数据的从属关系，也可以通过集合把数据结构中重复的元素减掉。集合可做集合运算，可添加和删除元素。
  • 集合内数据无序，即无法使用索引和分片
  • 集合内部数据元素具有唯一性，可以用来排除重复数据
  • 集合内的数据:str,int,float,tuple,冰冻集合等，即内部只能放置可哈希数据
----集合的定义

#集合的定义,set()
s = set()
print(type(s))
print(s)

#也可以像下面这样做,大括号内一定要有值，否则定义出的将是一个dict
s = {1,2,3,4,5,6,7}
print(s)

创建集合时需要用list作为输入集合，可通过add()方法增加元素，remove()方法删除元素

s = set([1,2,3])
s.add(6)
s.remove(2)

集合的内涵

普通集合内涵
--------以下集合会在初始化后自动过滤掉重复元素

s = {33,1,33,6,9,126,8,6,3,77,88,99,126}
print(s)

普通循环集合内涵

s = {33,1,33,6,9,126,8,6,3,77,88,99,126}
ss = {i for i in s}
print(ss)

带条件的集合内涵

s = {33,1,33,6,9,126,8,6,3,77,88,99,126}
sss = {i for i in s if i % 2 ==0}
print(sss)

多循环集合的内涵

s1 = {1,2,3,4}
s2 = {"nice","to","meet","you"}

s = {m*n for m in s2 for n in s1}
print(s)

----集合函数

  • intersection：交集
  • difference：差集
  • union：并集
  • issubset：检查一个集合是否为另一个子集
  • issuperset：检查一个集合是否为另一个超集

通过代码来看区别：

s1 = {1,2,3,4,5,6,7}
s2 = {5,6,7,8,9}

#交集
s_1 = s1.intersection(s2)
print("交集:",s_1)

#差集
s_2 = s1.difference(s2)
print("差集:",s_2)

#并集
s_3 = s1.union(s2)
print("并集:",s_3)

#检查一个集合是否为另一个子集
s_4 = s1.issubset(s2)
print("检查子集结果：",s_4)

#检查一个集合是否为另一个超集
s_5 = s1.issuperset(s2)
print("检查超集结果：",s_5)

这里是运行结果：交集: {5, 6, 7}
差集: {1, 2, 3, 4}
并集: {1, 2, 3, 4, 5, 6, 7, 8, 9}
检查子集结果： False
检查超集结果： False

frozen set:冰冻集合

  • 冰冻集合是不可以进行任何修改的集合
  • frozenset是一种特殊集合

创建冰冻集合的方式：

s = frozenset()

每天进步一点点，不要停止前进的脚步

原文地址：https://www.cnblogs.com/zhncnblogs/p/11909976.html

时间： 2024-11-06 12:02:41

Python中的四种数据结构的相关文章

Python中的三种数据结构

Python中,有3种内建的数据结构:列表.元组和字典.1.列表     list是处理一组有序项目的数据结构,即你可以在一个列表中存储一个序列的项目.列表中的项目.列表中的项目应该包括在方括号中,这样python就知道你是在指明一个列表.一旦你创建了一个列表,你就可以添加,删除,或者是搜索列表中的项目.由于你可以增加或删除项目,我们说列表是可变的数据类型,即这种类型是可以被改变的,并且列表是可以嵌套的.实例:#coding=utf-8animalslist=['fox','tiger','ra

python四种数据结构以及list详解

四种数据结构: list 使用[]表示,线性的数据结构,适合查找数据,不适合增删数据  链表: 适合增删数据,不适合查找数据  queue:队列:(先进先出或后进先出) 不允许队列在中间进行变化.  stack:栈 后进先出(落盘子) 列表表示l1 = []l2 = [1,2,'abc']l3 = list()l4 = list(range(5))可以嵌套l5 = [1,'ab',[bool,str]]l5[0] :打印出1,正数进行正索引,负数进行负索引l5[-1] :打印出[bool,str

序列是Python中最基本的数据结构

list是一种有序可重复的集合,可以随时添加和删除其中的元素.序列是Python中最基本的数据结构.序列中的每个元素都分配一个数字 - 它的位置,或索引,第一个索引是0,第二个索引是1,依此类推.列表是最常用的Python数据类型,它可以作为一个方括号内的逗号分隔值出现.列表的数据项不需要具有相同的类型创建一个列表,只要把逗号分隔的不同的数据项使用方括号括起来即可.如下所示:1 list1 = ['Google', 'Runoob', 1997, 2000];2 list2 = [1, 2, 3

Activity中的四种启动模式

在Android中每个界面都是一个Activity,切换界面操作其实是多个不同Activity之间的实例化操作.在Android中Activity的启动模式决定了Activity的启动运行方式. Android总Activity的启动模式分为四种: [html] view plaincopy Activity启动模式设置: <activity android:name=".MainActivity" android:launchMode="standard" 

C++中的四种转型操作符

在详细介绍C++中的四种转型操作符之前,我们先来说说旧式转型的缺点: ①它几乎允许将任何类型转换为任何其他类型,这是十分拙劣的.如果每次转型都能够更精确地指明意图,则更好. ②旧式转型难以辨识.旧式转型的语法结构是由一对小括号加上一个对象名称组成,而小括号和对象名称在C++的任何地方都有可能被使用. 为解决C旧式转型的缺点,C++导入了4个新的转型操作符:static_cast.const_cast.dynamic_cast.reinterpret_cast.下面我来一一分析这四种转型操作符.

JAVA中的四种引用以及ReferenceQueue和WeakHashMap的使用示例

简介: 本文主要介绍JAVA中的四种引用: StrongReference(强引用).SoftReferenc(软引用).WeakReferenc(弱引用).PhantomReference(虚引用)的作用.同时我们还将介绍ReferenceQueue和WeakHashMap的功能和使用示例. 欢迎探讨,如有错误敬请指正 如需转载,请注明出处 http://www.cnblogs.com/nullzx/ 1. JAVA中的四种引用 四种引用中,软引用.若引用.虚引用都需要相关类来创建.创建的时候

java中的四种单例实现方式

在java中,单例设计模式是非常常见的设计模式,对单例设计模式的概念,不做过多的介绍,下面将逐一介绍四种单例设计模式: 1.第一种单例设计模式 1.1 代码实现 package com.singleton.one; /**  * 第一种单例设计模式  * @author Administrator  *  */ public class SingleTonOne { // 实例化 private static SingleTonOne instance = new SingleTonOne();

Redis中的五种数据结构

Strings: Lists: Sets: Hashes: Zsets: Redis中的五种数据结构

对称加密和分组加密中的四种模式(ECB、CBC、CFB、OFB)

对称加密和分组加密中的四种模式(ECB.CBC.CFB.OFB) 一. AES对称加密: AES加密 分组 二. 分组密码的填充 分组密码的填充 e.g.: PKCS#5填充方式 三. 流密码:   四. 分组密码加密中的四种模式: 3.1 ECB模式 优点: 1.简单: 2.有利于并行计算: 3.误差不会被传送: 缺点: 1.不能隐藏明文的模式: 2.可能对明文进行主动攻击: 3.2 CBC模式: 优点: 1.不容易主动攻击,安全性好于ECB,适合传输长度长的报文,是SSL.IPSec的标准.