深入理解python（二）python基础知识之数据结构

数据结构

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=[,,]
>>> a.append([,])                 #使用append
>>> a
[, , , [, ]]
>>> a=[,,]
>>> a.extend([,])                 #使用extend
>>> a
[, , , , ]

2.列表的删除

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

例：

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

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

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

a.将列表倒序

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

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

[val for val in my_list if val != ]

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

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

给出几个例子：

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

关于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()
[, , , , , , , , , ]
>>> xrange()
xrange()
>>> list(xrange())
[, , , , , , , , , ]

关于惰性求值：

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

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

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

>>> a = [,,]
>>> b = [,,]
>>> c = [,,]
>>> d = zip(a, b, c)
>>> d
[(, , ), (, , ), (, , )]
#而在Python 3中则需要这样使用：
>>> a = [, , ]
>>> b = [, , ]
>>> c = zip(a, b)
>>> c
<zip object at 0x0000000003728908>
>>> list(c)
[(, ), (, ), (, )]

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

enumerate()函数：

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

例：

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

6.列表推导式

例：

>>> a = [x*x for x in range()]
>>> a
[, , , , , , , , , ]

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

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

例：

>>> [(x, y) for x in range() for y in range()]
[(, ), (, ), (, ), (, ), (, ), (, ), (, ), (, ), (, )]

>>> [(x, y) for x in [, , ] for y in [, , ] if x != y]
[(, ), (, ), (, ), (, ), (, ), (, ), (, )]

 元组

这里大概注意两点

一个是关于解包问题

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

>>> a=(,,)
>>> b,c,d=a
>>> b

>>> c

>>> d

>>> a={'a':,'b':,'c':}
>>> x,y,z=a
>>> a
{'a': , 'b': , 'c': }
>>> 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',,'zhaozhao','']
info_tuple=('192.168.1.1',,'zhaozhao','')
info_set={'192.168.1.1',,'zhaozhao',''}

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

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

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

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

dic_fun(**dic)

zhaozhao
123456

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

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

>>> g=((i+)** for i in range())
>>> g
<generator object <genexpr> at 0x02B15C60>
>>>tuple(g)
(, , , , , , , , , )
>>> tuple(g)
()
>>> g=((i+)** for i in range())
>>> g.next()    #在python 3中应改为__next__()

>>> g.next()

>>> g.next()

>>> g.next()

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

字典

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

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

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

字典的创建

#创建空字典1

d = {}
print(d)

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

#直接赋值方式

d = {"one":,"two":,"three":,"four":}

#常规字典生成式

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

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

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

访问、删除和变更

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

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

#运行结果如下：
{'one': 'eins', 'two': , 'three': , 'four': }
{'two': , 'three': , 'four': }

还有几点：

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

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

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

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