深入理解pythonpython基础知识之数据结构

Posted halaya

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了深入理解pythonpython基础知识之数据结构相关的知识,希望对你有一定的参考价值。

数据结构

Python中的内置数据结构(Built-in Data Structure):列表list、元组tuple、字典dict、集合set,这里只着重说前三个

>>> d=dict(zip((\'e\',\'r\'),(1,2)))
>>> d.keys()
dict_keys([\'e\', \'r\'])
>>> d.values()
dict_values([1, 2])
>>> d.items()
dict_items([(\'e\', 1), (\'r\', 2)])

列表

列表是Python中内置可变序列,是若干元素的有序集合。列表中的每一个数据称为元素,列表的所有元素放在一对中括号 [ 和 ] 中,并使用逗号分隔开

关于列表的一些重要操作函数汇总

 

 

 接下来是几个列表涉及的重要知识点

1.extend()和append()

extend()是将加入对象中的元素拼接到列表对象的后面,而append()则是将加入对象直接加入列表末尾。

例:

>>> a=[1,2,3]
>>> a.append([2,3])                 #使用append
>>> a
[1, 2, 3, [2, 3]]
>>> a=[1,2,3]
>>> a.extend([2,3])                 #使用extend
>>> a
[1, 2, 3, 2, 3]

2.列表的删除

一般想到列表的删除会想到循环+remove()的方法,但是在python中这种方法可能会产生想不到的错误。

例:

 

>>> a=[1,2,1,1,2,3,1]
>>> for x in a:
...    if x==1:                #寻找出等于1的元素并删除
...       a.remove(x)
...
>>> a
[2, 2, 3, 1]

 

可以看到并没有完全删除等于1的元素,原因在于python删除列表中的元素后,元素后面的索引会跟着每个加一,而遍历到的索引值不变,这就会造成一些元素被跳过的情况。

解决这个问题我们可以使用列表的浅拷贝或者使用while循环进行删除,但这两种办法并不是高效的,这里给出两种较为高效率的办法。

a.将列表倒序

>>> a=[1,2,1,1,2,3,1]
>>> for x in a[::-1]:
...    if x==1:
...       a.remove(x)
...
>>> a
[2, 2, 3]

b.使用列表生成式将不删除的元素筛选出来

[val for val in my_list if val != 1]

3.切片操作和range()函数

切片返回的是对象的浅拷贝,切片使用2个冒号分隔的3个数字来完成,第一个数字表示切片开始位置(默认为0),第二个数字表示切片截止(但不包含)位置(默认为列表长度),第三个数字表示切片的步长(默认为1),当步长省略时可以顺便省略最后一个冒号。

给出几个例子:

>>> a=[2,4,6,2,1,4,7,3]
>>> a[1:3]      #注意结尾是不算在给出的列表之中
[4, 6]
>>> a[:7:2]     #将步长设置为2
[2, 6, 1, 7]
>>> a[::-1]     #步长为-1则为逆序
[3, 7, 4, 1, 2, 6, 4, 2]
>>> a[:-2]      #尾项为负数代表从最后一项相减开始
[2, 4, 6, 2, 1, 4]
>>> a[3:0:-1]    #逆序切片时需注意首尾的颠倒
[2, 6, 4]

关于range()函数,这里借我们老师的一个说法来说明

内置函数range()的语法为:
range([start,] stop[, step])
其接收3个参数,第一个参数表示起始值(默认为0),第二个参数表示终止值(结果中不包括这个值),第三个参数表示步长(默认为1)

该函数在Python 3中返回一个range可迭代对象,在Python 2中返回一个包含若干整数的列表。另外,Python 2还提供了一个内置函数xrange()(Python 3中不提供该函数),语法与range()函数一样,但是返回xrange可迭代对象,类似于Python 3的range()函数,其特点为惰性求值,而不是像range()函数一样返回列表。例如下面的Python 2.7代码:

>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> xrange(10)
xrange(10)
>>> list(xrange(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

关于惰性求值:

大意延迟求值,即返回时不给定数据结构,根据需要来进行转化,以便于节省计算机资源,这个思路在python3中很常见。

5.zip()函数和enumerate()函数

zip(列表1,列表2,…) 将多个列表对应位置元素组合为元组,并返回包含这些元组的列表

 

>>> a = [1,2,3]
>>> b = [4,5,6]
>>> c = [7,8,9]
>>> d = zip(a, b, c)
>>> d
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
#而在Python 3中则需要这样使用:
>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> c = zip(a, b)
>>> c
<zip object at 0x0000000003728908>
>>> list(c)
[(1, 4), (2, 5), (3, 6)]

 

同样,python3采用了惰性求值的思路

enumerate()函数:

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中。

例:

>>>i = 0
>>> seq = [\'one\', \'two\', \'three\']
>>> for element in seq:
...     print i, seq[i]
...     i +=1
... 
0 one
1 two
2 thre

6.列表推导式

例:

 

>>> a = [x*x for x in range(10)]
>>> a
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

 

前面的x*x可以换成任何函数

当然也可以加入嵌套循环和条件判定

例:

>>> [(x, y) for x in range(3) for y in range(3)]
[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

>>> [(x, y) for x in [1, 2, 3] for y in [3, 1, 4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

 元组

这里大概注意两点

一个是关于解包问题

首先是字典和元组的解包:

 

>>> a=(1,2,3)
>>> b,c,d=a
>>> b
1
>>> c
2
>>> d
3
>>> a={\'a\':1,\'b\':2,\'c\':3}
>>> x,y,z=a
>>> a
{\'a\': 1, \'b\': 2, \'c\': 3}
>>> x
\'a\'
>>> y
\'b\'
>>> z
\'c\'

 

作为参数传参时会使用到*,这里给出例子:

列表解包时,保持列表项数与参数数一致

#解包--list,元组,集合
def connect(ip,port,username,password):
    print(ip)
    print(port)
    print(username)
    print(password)

info_list=[\'192.168.1.1\',3309,\'zhaozhao\',\'123456\']
info_tuple=(\'192.168.1.1\',3309,\'zhaozhao\',\'123456\')
info_set={\'192.168.1.1\',3309,\'zhaozhao\',\'123456\'}

connect(*info_list)
connect(*info_tuple)
connect(*info_set)

字典解包时,使用两个**代表对值的解包,但需要参数名称和key的值一样:

dic={"name":"zhaozhao","password":"123456"}

def dic_fun(name,password):
    print(name)
    print(password)

dic_fun(**dic)

zhaozhao
123456
 

第二个是关于生成器推导式

生成器推导式和列表推导式相近,不过与列表推导式不同的是,生成器推导式的结果是一个生成器对象,而不是列表,也不是元组。使用生成器对象的元素时,可以根据需要将其转化为列表或元组,也可以使用生成器对象的next()方法(Python 2.x)或__next__()方法(Python 3.x)进行遍历,或者直接将其作为迭代器对象来使用

>>> g=((i+2)**2 for i in range(10))
>>> g
<generator object <genexpr> at 0x02B15C60>
>>>tuple(g)
(4, 9, 16, 25, 36, 49, 64, 81, 100, 121)
>>> tuple(g)
()
>>> g=((i+2)**2 for i in range(10))
>>> g.next()    #在python 3中应改为__next__()
4
>>> g.next()
9
>>> g.next()
16
>>> g.next()
25

注意这个生成器推导式产生的对象的一个特点:一次性,如在变成一个元组后,生成的可迭代对象就变成了空值,这个和前面python3中range函数和zip函数以及map函数返回的值相近,也就是惰性求值的思想。

字典

字典其实一直是我比较烦的地方了,,,,这里借用我们老师的话对之进行一个概述


字典是键值对(key-value pair)的无序可变集合
定义字典时,每个元素的键和值用冒号分隔,元素之间用逗号分隔,所有的元素放在一对大括号{ 和 }中
字典中的每个元素包含两部分:键和值,向字典添加一个键的同时,必须为该键增添一个值
字典中的键可以为任意不可变对象,比如整数、实数、复数、字符串、元组等等
字典中的键不允许重复

这里索性就把所有关于字典的东西整理一下吧

字典的创建

#创建空字典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)

#运行结果如下:
{\'one\': \'eins\', \'two\': 2, \'three\': 3, \'four\': 4}
{\'two\': 2, \'three\': 3, \'four\': 4}

还有几点:

使用字典对象的get方法获取指定键对应的值,并且可以在键不存在的时候返回指定值。如不指定,默认返回None

在Python 2.7中:
使用字典对象的items()方法可以返回字典的键、值对列表
使用字典对象的keys()方法可以返回字典的键列表
使用字典对象的values()方法可以返回字典的值列表

python3中以上几个函数返回的不再是列表,为一个可迭代的视图对象

#python3
>>> d=dict(zip((\'e\',\'r\'),(1,2))) >>> d.keys() dict_keys([\'e\', \'r\']) >>> d.values() dict_values([1, 2]) >>> d.items() dict_items([(\'e\', 1), (\'r\', 2)])

 

以上是关于深入理解pythonpython基础知识之数据结构的主要内容,如果未能解决你的问题,请参考以下文章

深入理解pythonpython语法总结:基础知识和对python中对象的理解

深入理解pythonpython字符编码和字符串处理

深入理解JVM之知识体系

图文并茂带你深入理解三次交换之单臂路由

SQL Server之深入理解STUFF

深入理解闭包之定义及运行