Python基础数据结构

WARNING

elem是单词element（元素）的缩写，在程序定义中代表某一不确定的类型，也就是抽象的数据类型。

list

定义

由一系列元素按顺序进行排列而成的容器

• 元素可以是任意类型
• 元素按确定顺序排列，具有有序性

创建列表

先创建空列表实例再添加元素

• list()
• .append()方法

>>>wife = list()#实例化
>>>wife.append("西宫硝子")
>>>wife.append("樱岛麻衣")
>>>wife.append("爱莉希雅")
>>>wife
['西宫硝子','樱岛麻衣','爱莉希雅']

直接定义列表并填充元素

>>> phones = ["Apple", "Huawei", "Xiaomi"]
>>> phones
['Apple', 'Huawei', 'Xiaomi']

查看元素

1. 使用索引 用$[i]$查看第i+1个元素
2. index()方法 $$name.index(x)$$ 在list name中查找第一个值为x的元素，返回其索引
3. count()方法 $$name.count(x)$$ 在list name中查看有几个元素为x，返回个数
4. len()方法 $$name.len()$$ 查找list name中元素总个数，返回个数

新增元素

1. append()方法 $$name.append(x)$$ 向name末尾添加元素x
2. insert()方法 $$name.insert(i,x)$$ 将对象x插入name索引为i处，原来i以及i后面的元素顺位后移
3. extend()方法 $$name.extend(name2)$$ 将list name2接在list name 后面

修改元素

1. 用索引指明元素直接赋值修改

删除元素

1. pop()方法 $$name.pop()$$ 默认删除list最后一个元素 $$name.pop(i)$$ 删除索引为i的元素，后面的元素顺位前移
2. remove()方法 $$name.remove(x)$$ 删除第一个值为x的元素，后面的元素顺位前移
3. clear()方法 $$name.clear()$$ 删除所有元素（清空list）
4. del语句 $$del\ name[a:b]$$ 删除del索引$[a,b)$的元素，包括a不包括b $del\ name[:]$表示清空list $$del\ name[i]$$ 删除索引为i的元素

反转列表

1. reverse()方法 $$name.reverse()$$ 将列表name反转，最后一个元素变为第一个元素以此推类。
2. 切片法

>>> nums=[1,2,3,4,5]
>>> new_nums=nums[::-1]
>>> new_nums
[5,4,3,2,1]

原对象nums不变，产生新对象new_nums为反转列表

列表排序

1. sort()方法 $$name.sort()$$ $$name.sort(cmp=None,key=None,reverse=False)$$

• 该方法无返回值，会直接修改原list

• cmp为可选参数，

• key指明用元素的哪个参数作为比较权重，只有一个参数，取自比较的可迭代对象

  • 当比较元素elem仅包含一个参数（比如数字或单个字符）时，可省略key参数。

# 获取列表的第二个元素
def takeSecond(elem):
    return elem[1]
# 列表
random = [(2, 2), (3, 4), (4, 1), (1, 3)]

# 指定第二个元素排序
random.sort(key=takeSecond)
#通过函数takeSecond指定比较元组第二个元素（权重）

# 输出类别
print('排序列表：')
print(random)

排序列表：
[(4, 1), (2, 2), (1, 3), (3, 4)]

• reverse为排序规则，默认False升序，True为降序

tuple

定义

元组（tuple），由一系列元素按顺序进行排列形成的容器 元组不可变（immutable），列表可变（mutable）

创建元组

1. 直接使用$()$将所有元素包围，创建list是使用$[]$
2. 有时不使用$()$也能创建元组（不建议）
3. 元组推导式

atuple=(i+1 for i in range(31,42))

4. 当创建的元组仅包含一个对象时，在其后添加逗号$","$ 否则带小括号对象数据类型为对象类型而非元组
5. 创建空元组

a=tuple()
b=()

tuple不允许增删改查

tuple与list转换

tuple->list

atuple=(1,'love',3.334,'Y')
list(atuple)
'''此时atuple仍为tuple类型'''
alist=list(atuple)
'''alist为list类型'''
print(atuple)
输出(1, 'love', 3.334, 'Y')
print(alist)
输出[1, 'love', 3.334, 'Y']

list->tuple

alist=['I',2,3.1415,'polaris']
atuple=tuple(alist)
'''alist仍为list，atuple为tuple'''

dict

定义

• 字典（dict），由一系列键值对（key-value） 组合而成的数据结构。
• key必须为可以hash的值，如==字符串==、数值
  • hash：哈希（散列、杂凑），将任意长度输入通过散列（哈希）算法变换成固定长度输出（散列值）。 hash是一种压缩映射。
• value，可以为任意对象

创建字典

1. 先创建空字典再添加元素 注意用等号连接标识符与对象（key&value） 此时key为标识符，标识符字符串不用加引号
2. 直接使用大括号$\{\}$ 注意用冒号连接key与value 此时冒号前为key，字符串需要引号
3. 使用dict()函数从键值对序列（如tuple、list）创建dict

profile=dict(name='孤筝',age=19,爱好='明月栞那')

profile={name:'孤筝',age:19,爱好:'明月栞那'}

alist=[('name','孤筝'),('age',19),('爱好','明月栞那')]
profile=dict(alist)
此时alist仍为list，profile对象为dict

print(profile)
输出{'name':'孤筝','age':19,'爱好':'明月栞那'}

4. 字典推导式

adict={i:i**2 for i in range(2,5)}
print(adict)
输出{2:4,3:9,4:16,5:25}

查看元素

1. 使用 $$dict[key]$$ dict为字典名，key为键 key不存在时报错KeyValue
2. $dict.get(key[,value])$ dict为字典名，key为键，value为可选参数，初始值 当key不存在时返回设定的value，未设定value返回None ==如果键不存在于字典中，将会添加键并将value设为默认值。==

新增元素

key为新增键，value为对应值

修改元素

删除元素

1. $dict.pop(key)$ dict为字典名，key为键，字符串需带引号
2. del函数 $$del\ dict[key]$$ dict为字典名

其他重要方法

判断key是否存在

1. $in,not in$
2. $dict.has\_key()$函数 存在返回True，否则返回False ==仅在python2 中可使用，python3删除==

设置key默认值

1. 先判断key是否在dict中，若不在则赋值

profile = {"name": "王炳明", "age": 27, "公众号": "Python编程时光"}

if "gender" not in profile:
    profile["gender"] = "male"

2. $setdefault()$方法 $$dict.setdefault(key,default=None)$$ default为key不存在时设置的值，默认为None

set

定义

集合（set），同数学集合，一个无序的不重复元素序列。 ==question==：既然无序，那么print set时元素是按照什么顺序，储存时是什么顺序？

创建集合

1. 使用花括号创建，$\{\}$内可以有重复元素，但最后set会去重
2. 使用set()方法创建。

aset={1314,'520'}
print(aset)

输出：
{1314,'520'}

bset=set()#创建空集合aset
print(bset)

输出：
set()

cset=set(['I','love','ishimiya'])
print(cset)

输出：
{'I','love','ishimiya'}

增加元素

1. $.add()$函数

   $$set.add(elem)$$

   ==question==：如果elem为原set已有元素会发生什么？ 注意：当添加的元素与set集合中的元素出现重复的时候，不会有任何效果，但是并不报错。

   添加的元素必须是不可变类型的，若添加可变类型的元素则会报错。

2. $.update()$函数

   $$set.update(ElemType)$$

   ElemType必须为一个序列（string，list，tuple，dict，set等）

aset={'朱冰倩'}
aset.add('suki')
aset.update({'for'})
'''接集合{'for'}'''
aset.update([10000])
'''接列表[10000]'''
aset.update(('years',))
'''接元组，仅有一个元素时带上逗号'''
aset.update({'name':'guzheng','age':19})
'''接字典，仅将key加入set'''
print(aset)

输出：
{'朱冰倩','suki','for',10000,'years','name','age'}

删除元素

1. $.remove()$

aset={'朱冰倩','suki','for',10000,'years','name','age'}
aset.remove('name')

aset.remove('爱')
'''当remove不存在元素时报错'''
KeyError: '爱'

2. $.discard()$ 存在元素则移除，不存在也不会报错

aset={'朱冰倩','suki','for',10000,'years','age'}
aset.discard('age')
aset.discard('love')

3. $.pop()$ 从集合中随即删除元素，不可传入任何参数

aset={'朱冰倩','suki','for',10000,'love'}
aset.pop()
print(aset)

可能输出：
{'朱冰倩','suki','for',10000}

4. $.clear()$ 清空集合中元素 $$set.clear()$$

修改元素

因为set中元素无序，所以集合没有索引，无法修改元素，只能增加或删除元素。

查看元素

同上，无索引无法查看元素。 查看元素数量

返回集合中元素个数

集合运算

合集

使用$union$函数将两个集合合并并去重，返回合并后集合C

等价于

差集

使用$difference$函数求差集：找出==存在于集合A==但是==不在集合B==中的元素并作为一个新集合C返回。

等价于

交集

1. 使用$intersection$函数求交集：找出==同时存在于集合A和B==中的元素并返回集合C。 $$aset.intersection(bset)$$ 或 $$bset.intersection(aset)$$ 等价于 $$aset\ \&\ bset$$ $$bset\ \&\ aset$$
2. 使用$intersection\_update$函数求交集：找出交集并赋给aset，不会返回交集。 $$aset.intersection\_update()$$
3. 使用$\&$，返回交集不改变aset、bset $$aset\ \&\ bset$$

不重合集

1. $symmetric\_difference$函数，返回不重合集 $$aset.symmetric\_difference(bset)$$
2. 使用$symmetric\_difference\_update$函数，将不重合集返回aset $$aset.symmetric\_difference\_update(bset)$$

others

1. 判断set是否含有某元素，用in $$print(elem\ in\ aset)$$
2. 判断两set是否有相同元素 $$aset.isdisjoint(bset)$$ 如果有相同元素则返回False
3. 判断bset是否为aset子集 $$bset.issubset(aset)$$ 若bset为aset子集则返回True

iterator

迭代器

可迭代对象

可以利用 for 循环的对象，都叫可迭代对象。

可迭代协议

1. 第一种场景：如果一个对象内部实现了 __iter__() 方法 ，并返回一个迭代器实例，那么该对象就是可迭代对象。
   1. 对于该场景，isinstance(my_list,Iterable)返回True
2. 第二种场景：假设一个对象没有实现 __iter__() ，Python 解释器 __getitem__() 方法获取元素，如果可行，那么该对象也是一个可迭代对象。
   1. 对于该类可迭代对象，isinstance(my_list,Iterable)返回False

迭代器对象

当你对一个可迭代对象使用 iter 函数后，它会返回一个迭代器对象，对于迭代器对象，我们可以使用 next 函数，去获取元素，每执行一次，获取一次，等到全部获取完毕，会抛出 StopIteration 提示无元素可取。

alist=['人','生','若','只','如','初','见']
gen=iter(alist)
for i in alist:
    print(next(gen))

输出：
人
生
若
只
如
初
见

for i in alist:
    print(i)

输出：
人
生
若
只
如
初
见

可迭代对象与迭代器对象

1. 可迭代对象指整体，如一个list
2. 迭代器对象是iter()函数返回的对象，可对该对象使用next()函数不断获取元素。

generator

生成器，是一个可以像迭代器那样使用for循环来获取元素的函数。

生成器创建

列表推导式

alist=[i for i in range(5)]
print(alist)
输出：
[0,1,2,3,4]
'''
用[]创建列表对象
'''

alist=(i for i in range(5))
print(alist)
输出：
0
'''
此时alist为生成器对象
'''

yield

yield与renturn的区别

• 当一个函数运行到 yield 后，函数的运行会暂停，并且会把 yield 后的值返回出去。
• 若 yield 没有接任何值，则返回 None。
• yield 虽然返回了，但是函数并没有结束。再次调用该函数赋值的标识符，函数继续运行。

def generator():
    top=5
    i=0
    while i<top:
        print('当前值为：'+str(i))
        i+=1
        yield i
    raise StopIteration
gen=generator()

for i in range(6):
    print(next(gen))