python 传感器数据结构_Python的数据结构

Python的数据结构

Python有6个序列的内置类型，但最常见的是列表和元组。

序列都可以进行的操作包括索引，切片，加，乘，检查成员。

Python已经内置确定序列的长度以及确定最大和最小的元素的方法。

此处介绍四种数据结构，分别是：

list(列表)

tuple(元组)

dictionary(字典)

set(集合)

一、list(列表)

序列是Python中最基本的数据结构。序列中的每个元素都有索引，索引正序从0开始，索引反序从-1开始。

列表是最常用的Python数据类型，列表的数据元素不需要具有相同的类型。列表是可变的类型。

总结起来：内容可变、长度可变、类型可以不同，有序，可以容纳任何类型任意数量的对象。

1、声明列表

列表使用[]表示，其中的元素以逗号隔开。

代码示例：

l1 = [] # 声明一个空列表

l1 = list() #声明一个空列表

l2 = [1,2,3]

l3 = ['a','b','c','d']

l4 = [1,2,3,'a','b','c',[],[10,'xyz']]

2、相关操作

针对列表有和字符串有相同的操作。列表和字符串都是序列。列表是一种容器型序列，字符串是一种扁平型的序列。

操作如下：

+：列表拼接。拼接完成之后返回一个新的列表。

*：重复列表,将列表重复拼接指定次数。

[index]：获取指定索引的元素。

[indexbegin:indexend]：获取列表中的一段元素。

del：删除元素或列表

len()：获取列表长度。

in：判断元素是否在列表中。

for in：遍历列表。

max()：获取最大值。

min()：获取最小值

cmp()：比较两个列表的元素。此方法只存在于2.x的版本中，3.x版本已经删除了此方法。

比较规则：

首先比较两个列表的长度，长度大的列表大。

长度一样比较内容：

比较的时候是按照顺序比较的，只要能比较出大小，就不在往后进行了。

如果比较的元素是同类型的，则比较其值，返回结果(-1表示list1小，0表示相等，1表示list1大)。

如果两个元素不是同一种类型，数字小于字母

如果是数字，执行必要的数字强制类型转换，然后比较。

如果有一方的元素是数字，则另一方的元素"大"(数字是"最小的")。

否则，通过类型名字的字母顺序进行比较。

两个列表的元素个数以及所有元素都是相等的，那么结果0。

代码示例：

l2 + l3

[1, 2, 3, 'a', 'b', 'c', 'd']

print l2[2]

print l2[2:3]

print l2[:3]

print l2[2:]

l2[2] = "abc"

print l2

3

[3]

[1, 2, 3]

[3]

[1, 2, 'abc']

list1 = [1,2,3]

list1 * 2

[1, 2, 3, 1, 2, 3]

print 1 in list1

print 2 not in list1

for x in list1:print x,

True

False

1 2 3

del list1[2]

print list1

del list1

[1, 2]

len(l2)

3

list1 = (3,2,5,4,9)

list2 = (1,2,3,4)

max(list1)

9

min(list1)

2

cmp(list1,list2)

1

3、函数

Python中提供了很多操作list的函数，具体如下：

# 向列表中追加元素，空列表只能使用此函数添加。

l1.append("2")

l1

['2']

# 列表拼接，和+有区别，+是返回一个新的列表，此方法是直接在列表后面添加

l2.extend(l3)

# 在指定位置插入指定原酸

l2.insert(0,100)

# 从列表中找出指定元素第一次出现的位置。如果没有找到则报错。

l2.index(2)

1

# 针对原列表进行操作，反转列表。

l2.reverse()

l2

[3, 2, 1]

# 删除并返回指定位置的元素，不指定默认删除并返回最后一个元素。

l2.pop()

'd'

# 删除第一次出现的指定元素。删除不存在的元素，会报错。

l2.remove(2)

l2

[100, 'a', 'abc', 'b', 'c']

# 排序

l2.sort()

l2

[100, 'a', 'abc', 'b', 'c']

二、tuple(元组)

Python中元组被称为不能修改的列表。元组本身就像一个做了限制的列表。

Python的元组与列表类似，不同之处在于：

元组的元素不能修改，也不能删除。

元组使用小括号，列表使用方括号。

1、声明元组

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

元组中只包含一个元素时，需要在元素后面添加逗号。

代码示例：

t1 = tuple()

t2 = ()

t3 = (1,)

t4 = (1, 2, 3, "a", "b")

type(t2)

tuple

2、相关操作

元祖和列表的操作也及其的相似。也有以下几种操作：

+：元祖拼接。拼接完成之后返回一个新的元祖。

*：重复元祖,将元祖重复拼接指定次数，返回一个新的元祖。

[index]：获取指定索引的元素。

[indexbegin:indexend]：获取元祖中的一段元素。

del：删除元素或元祖

len(list)：获取元祖长度。

in：判断元素是否在元祖中。

for in：遍历元祖。

max()：获取最大值。

min()：获取最小值

cmp()：比较。

代码示例：

tuple1 = (1,2,3,4)

tuple2 = (7,8,9,0)

tuple1 + tuple2

(1, 2, 3, 4, 7, 8, 9, 0)

tuple1 * 2

(1, 2, 3, 4, 1, 2, 3, 4)

tuple1[1]

2

tuple1[0:2]

(1, 2)

1 in tuple1

True

for x in tuple1: print x,

1 2 3 4

max(tuple1)

4

min(tuple1)

1

len(tuple1)

4

3、函数

Python也提供了一些操作元祖的函数：

# 统计一个元素在元祖中出现的次数。

tuple1.count(1)

1

# 同list一样

tuple1.index(1)

0

三、Dictionary(字典)

字典是另一种可变容器模型，且可存储任意类型对象。相当于java中的map。

1、声明字典

字典的每个键值 key value 对用冒号“:”分割，每个键值对之间用逗号“,”分割，整个字典包括在花括号“{}”中。

字典值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的。

字典的键必须满足以下两个条件：

1)键必须唯一，不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住。

2)键必须不可变。可以用数字，字符串或元组充当。

代码示例：

d1 = {} #声明一个空字典

d2 = dict() #声明一个空字典

type(d2)

dict

d1 = {"name":"xh", "age":28}

d1["name"]

'xh'

2、相关操作

字典有以下几种操作：

[key]：获取指定key对应的值以及赋值。

del：删除元素，删除字典。

cmp()：比较两个字典。

len()：获取字典的长度。

str()：字典的字符串形式。

type()：获取对象类型。

代码示例：

dic1 = {"name":"xinghan", "age":28}

print dic1["name"]

dic1["age"] = 29

print dic1["age"]

print len(dic1)

print str(dic1)

print type(dic1)

del dic1["age"]

del dic1

print dic1

xinghan

29

2

{'age': 29, 'name': 'xinghan'}

---------------------------------------------------------------------------

NameError Traceback (most recent call last)

in ()

8 del dic1["age"]

9 del dic1

---> 10 print dic1

NameError: name 'dic1' is not defined

3、函数

字典本身也提供了一些操作函数：

# 复制一个字典，浅拷贝

dic1 = {"name":"xinghan", "age":28, "gender":"man"}

dic2 = dic1.copy()

dic2

{'age': 28, 'gender': 'man', 'name': 'xinghan'}

# 创建一个以序列元素为key，指定固定值的字典。

li = ["zhangsan", "lisi", "wangwu", "maliu"]

dic3 = dict.fromkeys(li, "man")

dic3

{'lisi': 'man', 'maliu': 'man', 'wangwu': 'man', 'zhangsan': 'man'}

# 获取指定key的值。如果存在，那么获取的是第二个参数的值。

dic1.get("name", "haha")

'xinghan'

# 判断字典中是否存在指定的key，存在返回True，不存在返回False。

dic1.has_key("name")

True

# 将字典转换为list返回，元素为元祖。

dic1.items()

[('gender', 'man'), ('age', 28), ('name', 'xinghan')]

# 返回一个list，元素为字典的key。

dic1.keys()

['gender', 'age', 'name']

# 如果字典中包含给定的键，则返回该键的值，否则返回为该键设置的值。

dic1 = {"name":"xinghan", "age":28, "gender":"man"}

dic1.setdefault("addr")

dic1

{'addr': None, 'age': 28, 'gender': 'man', 'name': 'xinghan'}

# 将另外一个字典，追加到当前字典中，存在相同key，当前字典的key对应的value会被覆盖。

dic2 = {"host":"local"}

dic1.update(dic2)

dic1

{'addr': None, 'age': 28, 'gender': 'man', 'host': 'local', 'name': 'xinghan'}

# 以list的形式返回所有value

dic1.values()

['local', 'xinghan', 'man', 28, None]

# 删除指定的key，并返回key对应的value。

dic1.pop("host")

'local'

# 随机返回并删除一对键值，如果字典为空，则报错。

dic1.popitem()

('name', 'xinghan')

# 清空字典

dic1.clear()

dic1

{}

四、set(集合)

在Python中，set是基本数据类型的一种集合类型，它有可变集合(set())和不可变集合(frozenset)两种。

set是一个无序且不重复的元素集合。

set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。

set有如下特性：

1.不重复

2.元素为不可变对象

1、声明集合

在Python中，创建空set必须使用函数set()。创建非空set可以使用{}或者set()函数。

代码示例：

se1 = set()

se2 = {"wang", "li", "hu", "hei"}

2、相关操作

集合的操作，和数学概念中的集合类似，有如下：

-：差集

&：交集

|：并集

!=：不等于

==：等于

in：是否是成员关系

not in：是否不是成员关系

代码示例：

se1 = {1, 2, 3, 4}

se2 = {3, 4, 5, 6}

se2 - se1

{5, 6}

se1 & se2

{3, 4}

se1 | se2

{1, 2, 3, 4, 5, 6}

se1 != se2

True

se1 == se2

False

se1 in se2

False

se1 not in se2

True

3、函数

set自身提供了一些操作函数，如下：

# 向集合中添加元素

s1 = {1, 2, 3, 4, 5}

s1.add(63456)

s1

{1, 2, 3, 4, 5, 63456}

# 将另外一个set的内容添加到当前set中。

s2 = {'abc', 'ab', "c", 'd'}

s1.update(s2)

s1

{1, 2, 3, 4, 5, 63456, 'ab', 'abc', 'c', 'd'}

# 移除指定的元素，元素不存在，不做任何操作。

s1.discard("abc")

s1

{1, 2, 3, 4, 5, 63456, 'ab', 'c', 'd'}

# 删除指定元素，元素不存在将报错。

s1.remove(1)

s1

{2, 3, 4, 5, 63456, 'ab', 'c', 'd'}

#随机删除一个元素,并返回该元素，当集合为空时，报错。

s1.pop()

63456

# 清空集合

s1.clear()

s1

set()

# 浅拷贝

s1 = {1,2,3,4}

s2 = s1.copy()

s2

{1, 2, 3, 4}

下一篇：