elem是单词element（元素）的缩写，在程序定义中代表某一不确定的类型，也就是抽象的数据类型。
list
定义
由一系列元素按顺序进行排列而成的容器
- 元素可以是任意类型
- 元素按确定顺序排列，具有有序性
创建列表
先创建空列表实例再添加元素
- list()
- .append()方法
>>>wife = list()#实例化 >>>wife.append("西宫硝子") >>>wife.append("樱岛麻衣") >>>wife.append("爱莉希雅") >>>wife ['西宫硝子','樱岛麻衣','爱莉希雅']直接定义列表并填充元素
>>> phones = ["Apple", "Huawei", "Xiaomi"] >>> phones ['Apple', 'Huawei', 'Xiaomi']查看元素
- 使用索引
用$[i]$查看第i+1个元素 - index()方法
$$name.index(x)$$
在list name中查找第一个值为x的元素，返回其索引 - count()方法
$$name.count(x)$$
在list name中查看有几个元素为x，返回个数 - len()方法
$$name.len()$$
查找list name中元素总个数，返回个数新增元素
- append()方法
$$name.append(x)$$
向name末尾添加元素x - insert()方法
$$name.insert(i,x)$$
将对象x插入name索引为i处，原来i以及i后面的元素顺位后移 - extend()方法
$$name.extend(name2)$$
将list name2接在list name 后面修改元素
- 用索引指明元素直接赋值修改
删除元素
- pop()方法
$$name.pop()$$
默认删除list最后一个元素
$$name.pop(i)$$
删除索引为i的元素，后面的元素顺位前移 - remove()方法
$$name.remove(x)$$
删除第一个值为x的元素，后面的元素顺位前移 - clear()方法
$$name.clear()$$
删除所有元素（清空list） - del语句
$$del\ name[a:b]$$
删除del索引$[a,b)$的元素，包括a不包括b
$del\ name[:]$表示清空list
$$del\ name[i]$$
删除索引为i的元素反转列表
- reverse()方法
$$name.reverse()$$
将列表name反转，最后一个元素变为第一个元素以此推类。 - 切片法
>>> nums=[1,2,3,4,5] >>> new_nums=nums[::-1] >>> new_nums [5,4,3,2,1]原对象nums不变，产生新对象new_nums为反转列表
列表排序
- 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)]
- 当比较元素elem仅包含一个参数（比如数字或单个字符）时，可省略key参数。
指定第二个元素排序
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. 元组推导式
```python
atuple=(i+1 for i in range(31,42))- 当创建的元组仅包含一个对象时，在其后添加逗号$","$
否则带小括号对象数据类型为对象类型而非元组 - 创建空元组
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是一种压缩映射。
- hash：哈希（散列、杂凑），将任意长度输入通过散列（哈希）算法变换成固定长度输出（散列值）。
- value，可以为任意对象
创建字典
- 先创建空字典再添加元素
注意用等号连接标识符与对象（key&value）
此时key为标识符，标识符字符串不用加引号 - 直接使用大括号$\{\}$
注意用冒号连接key与value
此时冒号前为key，字符串需要引号 - 使用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. 字典推导式
```python
adict={i:i**2 for i in range(2,5)}
print(adict)
输出{2:4,3:9,4:16,5:25}查看元素
- 使用$$dict[key]$$
dict为字典名，key为键
key不存在时报错KeyValue - $dict.get(key[,value])$
dict为字典名，key为键，value为可选参数，初始值
当key不存在时返回设定的value，未设定value返回None
==如果键不存在于字典中，将会添加键并将value设为默认值。==新增元素
$$dict[key]=value$$
key为新增键，value为对应值修改元素
$$dict[key]=new\_value$$
删除元素
- $dict.pop(key)$
dict为字典名，key为键，字符串需带引号 - del函数
$$del\ dict[key]$$
dict为字典名其他重要方法
判断key是否存在
- $in,not in$
- $dict.has\_key()$函数
存在返回True，否则返回False
==仅在python2 中可使用，python3删除==设置key默认值
- 先判断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()方法创建。
```python
aset={1314,'520'}
print(aset)
输出：
{1314,'520'}
bset=set()#创建空集合aset
print(bset)
输出：
set()
cset=set(['I','love','ishimiya'])
print(cset)
输出：
{'I','love','ishimiya'}增加元素
-
$.add()$函数
$$set.add(elem)$$
==question==：如果elem为原set已有元素会发生什么？
注意：当添加的元素与set集合中的元素出现重复的时候，不会有任何效果，但是并不报错。添加的元素必须是不可变类型的，若添加可变类型的元素则会报错。
-
$.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()$
```python
aset={'朱冰倩','suki','for',10000,'years','name','age'}
aset.remove('name')
aset.remove('爱')
'''当remove不存在元素时报错'''
KeyError: '爱'- $.discard()$
存在元素则移除，不存在也不会报错aset={'朱冰倩','suki','for',10000,'years','age'} aset.discard('age') aset.discard('love') - $.pop()$
从集合中随即删除元素，不可传入任何参数aset={'朱冰倩','suki','for',10000,'love'} aset.pop() print(aset)
可能输出：
{'朱冰倩','suki','for',10000}
4. $.clear()$
清空集合中元素
$$set.clear()$$
## 修改元素
因为set中元素无序，所以集合没有索引，无法修改元素，只能增加或删除元素。
## 查看元素
同上，无索引无法查看元素。
**查看元素数量**
$$len(set)$$
返回集合中元素个数
## 集合运算
### 合集
使用$union$函数将两个集合合并并去重，返回合并后集合C
$$aset.union(bset)$$
等价于
$$aset\ |\ bset$$
### 差集
使用$difference$函数求差集：找出==存在于集合A==但是==不在集合B==中的元素并作为一个新集合C返回。
$$aset.difference(bset)$$
等价于
$$aset\ -\ bset$$
### 交集
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 提示无元素可取。
```python
alist=['人','生','若','只','如','初','见']
gen=iter(alist)
for i in alist:
print(next(gen))
输出：
人
生
若
只
如
初
见
for i in alist:
print(i)
输出：
人
生
若
只
如
初
见
可迭代对象与迭代器对象
- 可迭代对象指整体，如一个list
- 迭代器对象是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 虽然返回了，但是函数并没有结束。再次调用该函数赋值的标识符，函数继续运行。
```python
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))
