Python列表，排序，字典

列表（list）

• 创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可
• Python已经内置确定序列的长度以及确定最大和最小的元素的方法。
• 数据项不需要具有相同的类型
• 删除列表元素用 del list[i]

list = ['Google', 'Runoob', 1997, 2000]
del list[2]

## ['Google', 'Runoob', 2000]

操作符

• len(列表)： 返回长度
• list1 + list2： 组合列表(加法)
• list * n : 列表元素重复（乘法）

  [‘Hi!’] * 4 ===> [‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]

• element in list : 元素是否在列表中

  3 in [1,2,3] ===> True

• for x in list : 列表可用于迭代（迭代）

• list[i] : 返回下表为i的元素
• list[-i] : 返回倒数第i个元素
• list[a:b] : 截取下标为 [a,b)的元素（b可选，表示截取到尾）
• 列表可嵌套

a = ['a', 'b', 'c']
n = [1, 2, 3]
x = [a, n]

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

函数

• len(list) ： 列表元素个数
• max(list) ： 返回列表元素最大值
• min(list) ： 返回列表元素最小值
• list(seq) ： 将元组转换为列表

函数	作用
append(obj)	在列表末尾添加新的对象（返回值为None，不可链式调用）
count(obj)	统计某个元素在列表中出现的次数
extend(seq)	在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
index(obj)	从列表中找出某个值第一个匹配项的索引位置
insert(index, obj)	将对象插入列表
pop([index=-1])	默认类似于出栈，并且返回该元素的值。也可指定特定的下标
remove(obj)	移除列表中某个值的第一个匹配项
reverse()	反向列表中元素
sort(cmp=None, key=None, reverse=False)	对原列表进行排序。key是自定义排序方法。reverse=True 降序，reverse=False 升序
clear()	清空列表
copy()	复制列表

元组（tuple）

• 是不可变对象（只读），没有增删改
• 用小括号表示()
• a = ()， 空元组不是空元素
• 一个元素不能丢逗号 (1,)

创建

tup1 = (‘Google’, ‘Runoob’, 1997, 2000);
tup2 = (1, 2, 3, 4, 5 );

不需要括号也可以

tup3 = “a”, “b”, “c”, “d”;
type(tup3) ==> <class ‘tuple’>

单个元素不能少逗号：

tup4 = (1,)
tup5 = (1)
type(tup4) ===> <class ‘tuple’>
type(tup5) ===> <class ‘int’>

操作

• 与列表基本一致，使用下标访问。
• 不可以修改元组，但可以连接和删除元组（tup3 = tup1+tup2，del tup）
• 也可使用负数索引 list[-i]，索引也可以截断使用 list[a:b] ==> 截取下标为[a,b)的元素

以下操作也和列表一致

• len((1, 2, 3)) 计算元素个数
• (1, 2, 3) + (4, 5, 6) 连接
• ('Hi!',) * 4 复制
• 3 in (1, 2, 3) 元素是否存在
• for x in (1, 2, 3): print (x,) 迭代

函数

• len(tuple) 计算元组元素个数
• max(tuple) 返回元组中元素最大值
• min(tuple) 返回元组中元素最小值
• tuple(seq) 将列表转换为元组

命名元组（nametuple）

用namedtuple构造出来的类其本质就是一个tuple元组，所以仍然可以使用下标的方式来访问属性。并且在任何要求类型为元组的地方都可以使用这个namedtuple。 [参考]

namedtuple (typename, field_names, verbose=False, rename=False )

例如：

from collections import namedtuple
Student = namedtuple('Student', ['name', 'age', 'sex', 'email'])
s = Student('Jim', 21, 'male', '123@qq.com')
s.name

type(Student) ==> type

isinstance(s,tuple) ==> True

字典（dict）

1. key-value 键值对的数据集合
2. 可变、无序、key不能重复
3. 键的值不可变，列表不可作为key

In [43]: dict?

Init signature: dict(self, /, *args, **kwargs)

d = dict{}
d = {}
d = dict(a=1,b=2)
d = {'a':1,'b':2}

访问：

d[‘a’]
如果对应的键值对不存在会报错

修改：

d[key] = value 如果key存在则是修改，不存在就是添加新键值对

删除：

• del dict['Name'] : 删除键 ‘Name’
• dict.clear() : 清空字典
• del dict : 删除字典

方法：

函数	作用
clear()	删除字典内所有元素
copy()	返回一个字典的浅复制
fromkeys(seq[, value])	创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
get(key, default=None)	返回指定键的值，如果值不在字典中返回default值
key in dict	如果键在字典dict里返回true，否则返回false
items()	以列表返回可遍历的(键, 值) 元组数组
keys()	返回一个迭代器，可以使用 list() 来转换为列表
setdefault(key, default=None)	和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
update(dict2)	把字典dict2的键/值对更新到dict里
values()	返回一个迭代器(并不是list)，包含重复的value，可以使用 list() 来转换为列表
pop(key[,default])	删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
popitem()	随机返回并删除字典中的一对键和值(一般删除末尾对)。

遍历：

• for i in dict <==> for i in dict.keys() ： 按key遍历
• for value in d.values() ： 按值遍历
• for key,value in d.items() ： 按键值对遍历
• for i in dict 循环中不能改变字典的长度（不能增，不能删），但是在while中可以

集合(Set)

基本功能是进行成员关系测试和删除重复元素。

可以使用大括号 { } 或者 set() 函数创建集合。 空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

In [19]: sets = {1,2,3,4,5,4,3,2,1}
==> {1, 2, 3, 4, 5}  # 去重

添加元素：

• add(elem) 添加元素
• update(elem/iterator) 添加元素或集合（可迭代对象都可：list、tuple、str）

移除元素：

• remove(elem) 移除，不存在时会报错
• discard(elem) 移除，不存在时不报错
• pop() 没有参数，随机移除一个元素

判断元素是否存在：
i in set

运算：

• union(set1[,set2,…]) 返回两个集合的并集，与 a|b 等效
• intersection(set1[,set2,…]) 返回两个集合的交集，与 a&b 等效
• x.difference(y) 返回两个集合的差集，与 x-y 等效
• set1.symmetric_difference(set2) 返回两个集合中不重复的元素。与 x^y 等效。

Supplement

• type() 返回元素的类型。如 type(tuple)

• isinstance(object, classinfo) 判断两个类型是否相同,classinfo 可以写父类

• 报错信息

  TypeError: ‘int’ object is not callable
  变量名和函数名重复

• doc 类的帮助信息:

  class ClassName:
     '类的帮助信息'   #类文档字符串
     class_suite  #类体
  

• a,b = (1,2) 直接给a，b按顺序赋值

• OrderedDict 有序字典，按照元素插入的顺序。

• [i for i in range(n)] 创建一个长度为n的列表，列表的元素全为i.

  # n = 10
  [i for i in range(n)]
  ==> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  
  [1 for i in range(n)]
  ==> [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] # 相当于[1]*10