python要素二：组合数据类型

时间：2021-04-28 11:49:14 收藏：0 阅读：0

python组合数据类型

序列类型

列表（list）

性质
- 可修改
- 可重复
- 可嵌套
- 有序
构造列表
- [,]
- list（）
  
  不带参数进行调用时将返回一个空列表,带一个list参数时，返回该参数的浅拷贝;对任意其他参数，则尝试将给定的对象转换为列表。该函数只接受一个参数的情况。
- [expression for item in iterable if condition]
  - ```
  leaps = [y for y in range(1900, 1940)
  if (y % 4 == 0 and y % 100 != 0) or (y % 400 == 0)]
```
方法
- L.append(x)
  - 将数据项X追加到列表L的尾部
- L.extend(m)
  - 即L+=m
- L.index(x, start, end)
  - 返回数据项X在列表L中（或L的startend分片中）最左边出现的索引
- L.insert(i, x)
  - 在i处将X插入
- L.pop()
  - 返回并移除list L最右边的数据项
- L.pop(i)
  - 返回并移除 i处的数据项
- L.remove(x)
  - 移除最左边出现的数据项X
- L.reverse()
  - 对列表L进行反转
- L.sort(...)
  - 排序，与内置的sorted()函数一样，可以接受可选的key与reverse 参数
- L.clear()
  - 清空列表

元组（tuple）

性质
- 元组是固定类型，不能替换或删除其中包含的任意数据项。可以使用list（）转换函数将其转换为列表再修改。
构造元组
- （,）
- tuple( )
  
  不指定参数时将返回一个空元组，使用tuple作为参数时将返回该参数的浅拷贝，对其他任意参数，将尝试把给定的对象转换为tuple类型。该函数最多只能接受一个参数。
- 命名的元组
  collections.namedtuple(typename,field_names)
  - ```
  Sale = collections.namedtuple("Sale","productid customend date quantity price")
  sale=Sale(432, 921, "2008-09-14", 3, 7.99)
  #sale.date与sale[2]等价
```
方法
- t.count（x）
- t.index（x）

字符串（str）

bytearray

bytes

通用操作

in，not in：成员关系测试
del：删除项 del seq[start : end]
<、<=、==、!=、>=、>：逐项比较
+，+=：连接、扩展序列
，=：二元操作符，复制序列

*:一元操作符，拆分操作

传递参数

def sum(a, b, c):
return a+b+c
L=[5,6,7]
sum1=sum(*L)
dic1={"a":2,"b":3,"c":4}
sum2=sum(**dic1)
print(‘{}+{}+{}={}‘.format(*L,sum1))#5+6+7=18
print(‘{a}+{b}+{c}={和}‘.format(**dic1,和=sum2))#2+3+4=9

提取多个数据项

first, *mid, last = "Charles Philip Arthur George Winds".split()
print(‘first={},mid={},last={}‘.format(first,mid,last))
#first=Charles,mid=[‘Philip‘, ‘Arthur‘, ‘George‘],last=Winds

[]:分片操作符
- 取值
  - seq[start：end：step]（当step为正数时，start从0开始算起，应满足start<=end；当step为负数时，start从-1开始算起，应满足start>=end）seq的每个元素可以用正反向两个下标表示，即seq[i]与seq[i-lenth]（0<=i<lenth），start、end、step必须是整数,可以缺省。
- 修改
  插入
  - seq[start:end]=sub_seq
    先删除索引start至end-1的元素，再插入sub_seq

集合类型(set)

性质

可哈希
- 成员为固定数据类型
  如float、frozenset、int、str、tuple
无序
不重复
- 可将列表转换为集合，以便去除重复项
可修改

构造集合

{,}
{expression for item in iterable if condition}
set( )

不带参数进行调用时将返回一个空集合；带一个set参数时返回该参数的浅拷贝；对任意其他参数，则尝试将给定的对象转换为集合。该函数只接受一个参数的情况。
frozenset( )

不带参数调用时，将返回一个空的固定集合，带一个frozenset参数时，将返回该参数的浅拷贝，对任何其他类型的参数，都尝试将给定的对象转换为一个frozenset。该函数只能接受一个参数。

操作符

如果将二元运算符应用于集合与固定集合，那么产生结果的数据类型与左边操作数的数据类型一致。

s|t
- 并集
s&t
- 交集
s-t
- 差集
s^t
- 对称差集
s==t
- 相等判断
s!=t
- 不等判断
s<t
- 真子集判断
s>t
- 真超集判断

方法

s.add(x)
- 将数据项X添加到集合S中~—如果S中尚未包含X
s.cIear()
- 移除集合S中的所有数据项
s.copy()
- 返回集合S的浅拷贝
s.discard(x)
s.remove(x)
- 如果数据项X存在于集合s中，就移除该数据项
  如果S中不包含X,remove会抛出异常
s.pop()
- 返回并移除集合s中一个随机项
s.union(t) s|t
s.update(t) s |= t
- 返回一个新集合，其中包含集合S中的所有数据项以及在t中而不在S中的数据项
s.intersection(t) s s&t
s.intersection_update(t) s &= t
- 返回一个新集合，其中包含所有同时包含在集合t与S中的数据项
s.difference(t) s-t
s.difference_update(t) s-=t
- 返回一个新集合，其中包含在S中但不在集合t中的所有数据项
s.symmetric_difference(t) s^ t
s.symmetric_difEerence_update(t) s^= t
- 返回一个新集合，其中包含S与t中的每个数据项，但不包含同时在这两个集合中的数据项
s.issubset(t) s<=t
- 如果s是t的子集就返回true
s.issuperset(t) s >=t
- 如果s是t的超集就返回true
s.isdiyoint(t)
- 如果集合s与t没有相同的项，就返回True

映射类型（dict）

可以看做是键值对的集合，即数学上的映射函数，keys存储自变量，values存储应变量
可以看做是对事物多维度的描述，一个dict对象就是一条记录，字段名即key值，字段值即value值

性质

键-值映射
键必须可哈希

布尔值(1,0)、列表、字典不能作为字典的key，以下数据类型可以float、frozenset、int、str、tuple
键不重复
可修改
无序
有序字典
collections.OrderedDict
- 以数据项插入的顺序进行存储
- 改变某个数据项的值——即插入新的数据项，其键与已有键相同——则顺序不会改变。

构造字典

{:,}

空的花括号｛｝会创建空字典，非空的花括号必须包含一个或多个逗号分隔的项, 其中每一项都包含一个键、一个冒号以及一个值。
- ```
d1= {"id":1948,"name":"Washer","size":3} 
```
dict（）

不带参数调用该函数时，将返回一个空
字典；带一个映射类型参数时，将返回以该参数为基础的字典。比如，该参数本身为字典，则返回该参数的浅拷贝。使用序列型参数也是可能的，前提是序列中的每个数据项本身是一个包含两个对象的序列，其中第一个用作键，第二个用作值。还可以使用关键字参数，其中键作为关键字，值作为键的值。
- ```
d2 = dict(id=1948, name="Washer", size=3)
d3 = dict([("id",1948), ("name","Washer"), ("fsize", 3)])
d4 = dict(zip(("id", "name", "size"),(1948, "Washer", 3)))
```
有序字典
collections.OrderedDict（）
默认字典
collections.defaultdict

默认字典defoultdicts是diet的子类
读取默认字典的项目时，若该项不存在，会先按默认值插入该项，再返回默认值，而不会报错
- import collections
  words = collections.defaultdict(str)
  
  参数应为函数名或空，访问缺失的键时，将用该函数为其创建一个默认值
{keyexpression: valueexpression for key, value in iterable if condition}

操作符

[]
- 可用于通过键访问值
  添加新的键值对d[newkey]=value
  替换现有的键值对 d[key]=newvalue
in，not in
- 基于键的成员关系测试
del
- 删除项 del d[key]

方法

d.items()
d.keys()
d.values()
- 返回dietd中所有(key,value)对的视图、键的视图、值的视图
  
  通常，我们可以简单地将视图看做iterables,不过，视图与通常的iterates有两个不同点；第一，如果该视图引用的字典发生变化，那么视图将反映该变化：第二，键视图与项视图支持一些类似于集合的操作。给定字典视图V与set (或字典视图〉X, 支持的操作包括：
  V&X # 交集
  V |X # 并集
  V-X # 差集
  V^X #对称差集
d.get(k,V)
- 返回键k相关联的值，如果k不在dietd中就返回None或V(如果给定了参数v)
d.setdefault(k,v)
- 返回键k相关联的值，如果k没有包含在dietd中就插入一个键为k的新项，其值为None或V(如果给定了参数v)
d.fromkeys(s,v)
- 返回一个dict,该字典的键为序列S中的项，值为None或V(如果给定了参数V)
d.clear()
- 从dict d中移除所有项
d.copy()
- 返回dict d的浅拷贝
d.pop(k,V)
- 返回键k相关联的值，并移除键为k的项，如果k不包含在d中就产生KeyError异常，或返回V(如果给定了参数v)
d.popitem()
- 返回并移除dict d中一个任意的(key,value)对，如果d为空就产生KeyError异常
d.update(a)
- 用a的信息更新d，即将a中每个尚未包含在dict d中的(key,value)对添加到d,对同时包含在d与a中的每个键，使用a中对应的值替换d中对应的值。a可以是字典，也可以是(key,value)对的一个iterable（可迭代）,或关键字参数

组合数据类型的迭代与复制

迭代

Iteration

可迭代类型
Iterable

任意包含_iter_()方法的对象或任
意序列(也即包含_getitem_()方法的对象，该方法接受从0开始的整数参数)都是
一个iterable。
- 凡是可作用于iter（）函数的对象都是Iterable类型
迭代器
Iterator

迭代器是一个对象，该对象可以提供_next_( ) 方法，该方法依次返回每个相继的数据项，并在没有数据项时产生Stopiteration异常。可以通过collection模块的Iterator类的isinstance()方法来判断。
- 凡是可作用于next（）函数的对象都是Iterator类型
迭代原理
- 解释器需要迭代对象X时，会自动调用内置的iter（）函数。该函数有以下作用：
  检查对象是否实现了__iter__()方法，如果实现了就获取一个迭代器。如果没有实现，但是实现了__getitem__()方法，Python会创建一个迭代器，尝试按顺序（从索引0开始）获取元素。
迭代组合类型示例
- 显式迭代
  - ```
  iterator=iter([1,2,3,4]) #iter()获取数据的迭代器
  print(iterator)
  while True:
  try:
    i=next(iterator)#next()返回迭代器的下一个值
  except StopIteration:#当迭代器没有数据时退出
    break
  print(i)
```
- for 循环迭代
  
  使用for item in iterable循环时，Python在效果上是调用iter(iterable)来获取一个迭
  代器。之后在每次循环迭代时，将调用该迭代子的_next_()方法以获取下一个数据项，在产生Stopiteration异常时，将捕获这一异常，循环终止。
  - ```
  for i in [1,2,3,4]:
  print(i)
```

自定义迭代类示例

序列类型

import re
import reprlib
RE_WORD = re.compile(‘\w+‘)

#将句子按单词存储的类，类似于序列类型
class  Sentence:
    def __init__(self,text):
        self.text =text
        self.words = RE_WORD.findall(text)

def __getitem__(self, item):#此方法支持[]切片式访问对象
    return self.words[item]

#已定义__getitem__,不定义__iter__程序也可以
    def __iter__(self):
        for word in self.words:
            yield word

#yield 返回值以后函数不会释放，再次调用时从yield的下一句开始，直到再次遇到yeild。使用yield 相当于实现了__next__()方法

sen=Sentence(‘we are the world‘)#创建此句子时，单词列表已经生成
for i in sen:
    print(i)

迭代器类型

#可以无限迭代的斐波那契数列，不是一次性产生数列，而是在迭代过程中产生数列

class Fibonacci:
    def __init__(self,max=1000):
        self.a = 0
        self.b = 1
        self.max=max
    def __next__(self): #计算数列值，a存放当前值，b存放下个值

  self.a,self.b = self.b ,self.a+self.b
        if self.a <self.max:
            return self.a
        else:
            raise StopIteration
    def __iter__(self):
        return self

fibs=Fibonacci(2000)#创建此数列时并不生成数列，数列是在迭代过程中生成的
for fib in fibs:
    print(fib,end=‘  ‘)

操作符
- s + t
  - 返回S与t连接的序列
- s*n
  - 返回S的n个副本连接的序列
- X in i
  - 如果项X出现在iterable i中，就返回True
函数
- all(i)
  - 如果iterable i中的每一项都评估为True,就返回True
- any(i)
  - 如果iterable i中的任意项都评估为True,就返回True
- enumerate(i,start)
  - 通常用于for…in循环中，提供一个(index, item)元组序列，其中索引起始值为0或start
- len(x)
  - 返回X的“长度”
- max(i, key)
  - 返回iterable i中的最大的项，如果给定的是key函数，就返回key (item)值最大的项
- min(i,key)
  - 返回iterable i中的最小的项，如果给定的是key函数，就返回key (item)值最小的项
- range(start, stop, step)
  - 返回一个整数迭代子。使用一个参数(stop)时，迭代子的取值范围从0到stop-1；使用两个参数(start与stop)时，迭代子取值范围从start到sto-1；3个参数全部使用时，迭代子取值范围从start到stop-1,但每两个值之间间隔step
- reversed(i)
  - 返回一个迭代器，该迭代器以反序从迭代器i中返回项
- sorted(i, key, reverse)
  - 以排序后顺序从迭代子i返回项，key用于提供DSU (修饰、排序、反修饰)排序，如果reverse 为True,则排序以反序进行
- sum(i, start)
  - 返回iterable i中项的和，加上start (默认为0), i可以包含字符串
- zip(i1..., iN)
  - 返回元组的迭代子，使用迭代子i1到iN

复制

直接赋值（=）
- 并未复制对象，只是将两个对象引用（变量）指向同一个对象
浅拷贝

复制的是对象引用，而不是对象。对固定类型而言，与复制对象效果相同且更高效；对可变数据类型而言，这意味着相关对象同时被原来的组合与复制得来的组合引用。
- []切片复制
- X.copy（）函数
- import copy
  copy.copy（X）
- 组合数据类型名（）
  List（ X）
深拷贝

复制的是对象，原来的与复制的两个对象相互独立
- import copy
  copy.deepcopy（）