3、Python中的高级数据类型

目录

序列类型

序列的类型支持成员关系操作符(in)，大小计算函数(len())、分片([])
Python有5中内置的序列类型：bytearray、bytes、list、str与tuple

元组tuple

元组是一个有序的序列，其中包含0个或多个对象引用。与字符串类似，都是固定的，一旦赋值，不能替换或删除其中的内容

#!/usr/bin/env python
# encoding: utf-8

# 创建一个元祖
my_tuple = (1, 2, 3, 4, 5)
print(my_tuple)
print(my_tuple[1])
print(my_tuple[3:])
print(my_tuple[:3])

#用分片复制一个元祖
my_tuple2 = my_tuple[:]
print(my_tuple2)

#创建只有一个元素的元祖
my_tuple3 = ('zeng',)#注意这里的，
print(my_tuple3)
print(type(my_tuple3))

另类捷径，用分片来替换和删除元祖中的数据

#!/usr/bin/env python
# encoding: utf-8

# 把元祖中的元素3替换成6
my_tuple = (1, 2, 3, 4, 5)
my_tuple1 = my_tuple[:2]+(6,)+my_tuple[3:]
print(my_tuple1)#(1, 2, 6, 4, 5)

# 把元祖中的元素4删除
my_tuple = (1, 2, 3, 4, 5)
my_tuple2 = my_tuple[:3]+my_tuple[4:]
print(my_tuple2)#(1, 2, 3, 5)

命名的元组

不怎么常用，在特殊场景下或许会带来一些方便

#!/usr/bin/env python
# encoding: utf-8

import collections

Sale = collections.namedtuple("Sale", "id name date")
sales = []
sales.append(Sale(444, 'zeng', "2018-6-5"))
sales.append(Sale(555, 'zeng2', "2018-6-6"))
print(sales[0].id) #取出第一个Sale的id
print(sales[0].name) #取出第一个Sale的name
print(sales[0].date) #取出第一个Sale的date

列表list

支持与字符串、元祖一样的分片与步距语法，而且能够支持数据项的替换、插入和删除
list数据类型可以作为函数进行调用
list()不带参数调用返回一个空列表
list()课通过另一个列表的值来创建
空列表可以使用空的方括号来创建

#!/usr/bin/env python
# encoding: utf-8

my_list = list()
print(type(my_list))
my_list2 = [1, 2, 3, 4]
print(type(my_list2))
print(my_list2)

#改变my_list2中的数据项，不会对my_list3有影响
my_list3 = list(my_list2)
print(my_list3)
my_list2[2] = 99
print(my_list2)
print(my_list3)

#改变my_list2中的数据项，my_list4
my_list4 = my_list2
print(my_list4)
my_list2[2] = 99999
print(my_list2)
print(my_list4)

#查看list的方法
print(dir(list))

同时也支持比较操作符(<、<=、==、！=、>=、>)

列表中用到的一些方法

---

集合类型set

集合是0个或多个对象的无序集合，由于其没有索引的位置，因此不能做分片操作
set数据类型可以作为函数进行调用
set ()不带参数调用返回一个空集合
空集必须要使用set()来创建

集合中每个数据项都是独一无二的，因为就算往集合添加重复数据项，显示也只有一份
集合支持len()函数，也支持使用in与not in进行关系测试

#!/usr/bin/env python
# encoding: utf-8

my_set = set("zengraoli")
print(my_set)#{'z', 'n', 'r', 'g', 'a', 'i', 'o', 'e', 'l'}

#浅拷贝操作
my_set2 = my_set
print(my_set2)#{'i', 'a', 'l', 'g', 'z', 'n', 'e', 'r', 'o'}
my_set.add('1')
my_set.add('1')
print(my_set2)#{'1', 'i', 'a', 'l', 'g', 'z', 'n', 'e', 'r', 'o'}

#相当于上面的操作
my_set3 = my_set2.copy()
print(my_set3)#{'1', 'i', 'a', 'l', 'g', 'z', 'n', 'e', 'r', 'o'}

---

映射类型

字典

映射是键-值数据项的组合，提供了存取数据及其键、值的方法。Python3支持两种无序的映射类型—内置的dict类型以及标准库中的—–类型，还有有序的映射类型—-

字典内涵

dict是一种无序的组合类型，其中包含0个或多个键值对。字典是可变的，可以对其数据项进行添加或者移除，字典又是无序的，因此，不能进行分片和按步距分片。
dict数据类型可以作为函数进行调用
dict ()不带参数调用返回一个空字典
字典也可以使用花括号创建，空的花括号{}或创建空字典

#!/usr/bin/env python
# encoding: utf-8

my_dict1 = dict({'id':1, 'name':'zengraoli'})#键的位置不能带上引号
print(my_dict1)#{'id': 1, 'name': 'zengraoli'}

#参数还可以是一个元祖序列（外层用括号括起来）
my_dict2 = dict((('id', 2), ('name', 'zengraoli2')))
print(my_dict2)#{'id': 2, 'name': 'zengraoli2'}

#参数还可以是一个列表序列（外层用括号括起来）
my_dict3 = dict([['id', 3], ['name', 'zengraoli3']])
print(my_dict3)#{'id': 3, 'name': 'zengraoli3'}

#通过提供具有映射关系的参数来创建
my_dict4 = dict(id=4, name='zengraoli4')
print(my_dict4)#{'id': 4, 'name': 'zengraoli4'}

#修改某个数据项
my_dict4['name'] = 'zengraoli44'
print(my_dict4)#{'id': 4, 'name': 'zengraoli44'}

#删除某个数据项
del my_dict4['name']
print(my_dict4)#{'id': 4}

可以通过字典的(key,value)项、根据键或根据值对其进行迭代

#!/usr/bin/env python
# encoding: utf-8

my_dict1 = dict({'id':1, 'name':'zengraoli', 'age': 24, 'addr':'test'})#键的位置不能带上引号
print(my_dict1)#{'id': 1, 'name': 'zengraoli', 'age': 24, 'addr': 'test'}

#得到每一项的键值对
for item in my_dict1.items():
    print("key:{}, value:{}".format(item[0], item[1]))
print("==============")

for k, v in my_dict1.items():
    print("key:{}, value:{}".format(k, v))
print("==============")

#根据字典的key进行迭代
for k in my_dict1.keys():
    print("key:{}".format(k))
print("==============")

# 根据字典的value进行迭代
for v in my_dict1.values():
    print("value:{}".format(v))
print("==============")

#返回键k相关联的值，如果k不在就返回None
print("v:{0}".format(my_dict1.get('id3')))
print("v:{0}".format(my_dict1.get('id')))

#返回键k相关联的值，如果k不在就返回'not found'
print("v:{0}".format(my_dict1.get('id3', 'not found')))

一些常用的方法

*默认字典与有序字典

默认字典与普通字典相比，在于可以对遗失的键进行处理(结合工厂函数来用)，默认字典永远不会产生KeyError；

#!/usr/bin/env python
# encoding: utf-8

import collections

my_dict1 = dict({'id':1, 'name':'zengraoli', 'age': 24, 'addr':'test'})#键的位置不能带上引号
# print(my_dict1['id3'])#KeyError

#找不到键的时候，需要调用的工厂函数
def default_factory():
  return 'new value'
d = collections.defaultdict(default_factory, foo = 'bar')
print(d['bar'])#new value

*有序字典

有序字典一般用在生成排序字典的场景，效率也不会太低

#!/usr/bin/env python
# encoding: utf-8

import collections

my_dict1 = dict({'a':1, 'c':3, 'b':2})#键的位置不能带上引号
print(my_dict1)#{'a': 1, 'c': 3, 'b': 2}

od = collections.OrderedDict({'a':1, 'c':3, 'b':2})
od = collections.OrderedDict(sorted(od.items()))
#经过排序后，生成有序的item
print(od)#OrderedDict([('a', 1), ('b', 2), ('c', 3)])

---

组合数据类型的迭代

iterable数据类型每次返回其中的一个数据项。任意包含iter()方法的对象或任意序列都是一个iterable并课题提供一个迭代子。迭代子是一个对象提供next()方法，该方法会返回后一个数据项，在没有后续数据项时产生StopIteration异常

---

组合数据类型的复制

Python在使用=赋值时，没有进行复制操作。如果右边的操作数是字面值，比如字符串或数字，那么左边的操作数怎被设置为一个对象引用，只想右边的内存对象；如果右边是一个对象引用，那么左边还是一个对象引用，此时左右指向同一个地址

#!/usr/bin/env python
# encoding: utf-8

#右边是一个内存地址，
name = 'zengraoli'
name_ref = name
print(name_ref)#zengraoli
name = 'zeng'#改变了name的指向地址，不影响name_ref
print(name_ref)#zengraoli
print(name)#zeng

#my_list、my_list_ref指向同一个list地址
my_list = ['id', 23, 'zengraoli']
my_list_ref = my_list
print(my_list_ref)#['id', 23, 'zengraoli']
my_list[0] = 'id2'
print(my_list)#['id2', 23, 'zengraoli']
print(my_list_ref)#['id2', 23, 'zengraoli']

浅拷贝（不拷贝嵌套的对象内容）
通过对对象(比如list、set、tuple等结构)的copy，得到给定对象的一个副本，浅拷贝复制的是对象的引用，当改变拷贝对象内容的时候，并不影响浅层拷贝对象的内容

#!/usr/bin/env python
# encoding: utf-8

#my_list、my_list_ref指向同一个list地址
my_list = ['id', 23, 'zengraoli']
my_list_ref = my_list.copy()
print(my_list_ref)#['id', 23, 'zengraoli']
my_list[0] = 'id2'
print(my_list)#['id2', 23, 'zengraoli']
print(my_list_ref)#['id', 23, 'zengraoli']

但如果包含深层的拷贝（嵌套了一个对象），当改变拷贝对象所嵌套对象内容的时候，还是会影响浅层拷贝对象的内容

#!/usr/bin/env python
# encoding: utf-8

#my_list、my_list_ref指向同一个list地址，
inner_list1 = ['id1', 23, 'zengraoli1']
inner_list2 = ['id2', 24, 'zengraoli2']
my_list = [inner_list1, inner_list2]
my_list_ref = my_list.copy()
inner_list1[0] = 'id11'
print(my_list)#[['id11', 23, 'zengraoli1'], ['id2', 24, 'zengraoli2']]
print(my_list_ref)#[['id11', 23, 'zengraoli1'], ['id2', 24, 'zengraoli2']]

深拷贝（同时拷贝嵌套的对象内容）
对应深层的拷贝（嵌套了一个对象），当改变拷贝对象所嵌套对象内容的时候，不会影响浅层拷贝对象的内容

#!/usr/bin/env python
# encoding: utf-8

import copy

inner_list1 = ['id1', 23, 'zengraoli1']
inner_list2 = ['id2', 24, 'zengraoli2']
my_list = [inner_list1, inner_list2]
my_list_ref = copy.deepcopy(my_list)
inner_list1[0] = 'id11'
print(my_list)#[['id11', 23, 'zengraoli1'], ['id2', 24, 'zengraoli2']]
print(my_list_ref)#[['id1', 23, 'zengraoli1'], ['id2', 24, 'zengraoli2']]

---