python-for-data-python基础

本文主要是对Python的数据结构进行了一个总结，常见的数据结构包含：列表list、元组tuple、字典dict和集合set。

索引

左边0开始，右边-1开始
通过index()函数查看索引编号

lang = ['python', 'java', 'html']
lang.index('python')
0  # 索引从0开始
lang.index('html')
2

切片

索引左边从0开始，右边-1开始
含头不含尾
步长可正可负

lst = [1, 2, 3, 4, 5, 6]
print(lst[:])     #  相当于是复制 lst
[1, 2, 3, 4, 5, 6]
print(lst[::2])  #  步长是2    [开始:结束:步长]
[1, 3, 5]
print(lst[-3:-1])

lst = [1,2,3,4,5,6]
print(lst[1:5:2])     # 常规用法
print(lst[-5:-2:2])   # 标号-5代表的是元素2，标号-2代表的是5，步长为2
print(lst[-5:4:2])
print(lst[1:-2:2])
[2,4]

list列表[]

特点

长度可变的
内容是可以修改的

创建

直接通过[]
通过list()函数

1 2	list(range(10)) list(1,2,3,4)

操作

列表和字符串一样，都是序列，里面的元素是有序的，也有索引和切片。索引index左边从0开始，右边从-1开始，index()函数可以查看某个元素的索引编号。

追加

append：末尾追加，单个追加
insert(location, obj)：指定位置追加元素
extend：整体的扩编

删除

pop(2)：删除指定索引为2的元素，有返回值即删除的元素值
remove(obj)：删除指定元素，没有返回值；如果存在多个，则删除第一个元素

排序

sort：obj.sort(key=len)
sorted：sorted(obj)；默认是从小到大排序
bisect模块：import bisect
- bisect.bisect(obj,col)：返回插入的位置
- bisect.insort(obj,col)：直接插入元素

反转

通过步长-1进行反转，[::-1]
通过reversed()进行反转，得到的是可迭代对象，并且将迭代对象转为为列表显示

# 反转1
print(lst[::-1])  # 通过步长为-1进行反转
print(lst)   # 不影响原来对象
[6, 5, 4, 3, 2, 1]
[1, 2, 3, 4, 5, 6]

# 反转2
print(list(reversed(lst)))  # 通过reversed函数进行反转
[6,5,4,3,2,1]

print(list(reversed('abcde')))    # 对字符串进行反转，列表显示
['e', 'd', 'c', 'b', 'a']

元组tuple()

特点

固定长度、不可变
元组中的元素可以是任意类型
如果内部存在列表等可变的元素，则内部元素能够进行修改
元组中的元素能够通过索引进行访问

创建

使用小括号，元素之间用逗号隔开；若只有元素，末尾也必须加上逗号：(5,)
通过tuple函数进行创建

tup = ()        # 创建空元组
print(tup)

tup1 = ('python', )   # 创建单个元组，必须在最后带上逗号
print(tup1)

tup2 = (1, 2, (3, ), ["python", "java", "php"])     # 创建多重元组

元组和列表之间是互通的，通过list()和tuple()能够实现列表和元组之间的转化。通过dir(tuple)能够查看元组对象的方法

操作

统计

统计元素出现的个数count()

嵌套拆包

1 2	tup = 4,5,(6,7) a,b,(c,d) = tup # 嵌套拆包

遍历序列

seq = [(1,2,3), (4,5,6), (7,8,9)]
for a, b, c in seq:
  print('a={0}, b={1}, c={2}'.format(a,b,c))

# 结果
a=1, b=2, c=3
a=4, b=5, c=6
a=7, b=8, c=9

高级功能

特殊语法*rest

values = 1,2,3,4,5
a,b,*rest =  values
rest
[3,4,5]

如果想丢弃某些元素，将rest换成下划线_

1	a,b,*_ = values

用途

元组表列表操作速度快；
在进行遍历操作的时候，请用元组代替列表
如果对不需要修改的数据进行“写保护”，即改数据是常量，也要使用元组；如果需要改变这些值，转换为列表进行修改
元组在字典中可以当做key来使用，但是列表不可以

字典dict{}

特点

常用的名字是哈希表或者关联数组
由键值对组成，键是不可变的（哈希的），值是可变的

创建

通过dict函数
直接通过{}中括号创建，中间用逗号隔开

操作

删除

del：del dict[k1]，内存中也没有了
clear：D.clear()变成了空字典，但内存中仍存在
pop：D.pop(k[,d])，以字典的键为参数，删除键值对

更新

update：更新字典，没有返回值

获取键、值

关于键值对、键、值的获取主要用到的是items()、keys()、values()三种方法，三种方法得到的结果都能够用for进行遍历，获取单个元素：

函数	作用
items	获取键值对
keys	获取所有的键
values	获取所有的值

默认值相关

get	获取某个键key的值value：dict.get(k, [,d])键不存在返回指定的值d
setdefault	类似get方法，如果键不存在，返回指定的值，并在字典中增加这个键值对；如果不指定返回值，默认是None

看一个具体的例子

ab = {'language': 'python', 'city': 'shenzhen', 'code': '101'}
print(ab.get("language"))
print(ab['language'])     # 当键存在时，二者作用相同
print(ab.get('number'))   # 返回的是None，但是原来的字典不变
# print(ab['number'])    报错
print(ab.get('number', '1234'))  # 返回值是1234，但是原来的字典不变
print(ab.setdefault('number', '1234'))  # 返回值是1234，并且原来的字典添加了键值对'number':'1234'

# 执行setdefault()后的结果
{'language': 'python', 'city': 'shenzhen', 'code': '101', 'number': '1234'}

栗子

根据首字母分类为包含列表的字典

words = ['apple', 'bat', 'bar', 'atom', 'book']
by_letter = {}
for word in words:
  letter = word[0]   # 取出每个单词的首字母
  if letter not in by_letter:
    by_letter[letter] = [word]   # 首字母第一次不存在则创建
  else:
    by_letter[letter].append(word)   # 当首字母之后，直接进行追加

使用setdefault来解决

words = ['apple', 'bat', 'bar', 'atom', 'book']
by_letter = {}
for word in words:
  letter = word[0]
  by_letter.setdefault(letter, []).append(word)   # 创建letter为首字母的键，值为word组成的列表的键值对

使用内建模块defaultdict来解决，**defaultdict(function_factory)**构建的是一个类似dictionary的对象

keys的值，自行确定赋值；values的类型，是function_factory的类实例，而且具有默认值。
比如**default(int)**则创建一个类似dictionary对象，里面任何的values都是int的实例，而且就算是一个不存在的key, d[key] 也有一个默认值，这个默认值是*int()*的默认值0

from collections import defaultdict
by_letter = defaultdict(list)   # 创建一个类似dict的对象，values都是list类型
for word in words:
  by_letter[word[0]].append(word)

集合set{}

特点

无序的，没有索引，不属于序列
元素唯一，不重复
元素不可变，可哈希
空集合只能通过set()创建

创建

set方法
通过{}直接创建，还带去重功能

方法

常见的集合方法及其作用

方法	作用
add()	给一个集合增加元素，参数只能有一个：增加的元素
update	用原有集合自身和其他东西构成的新集合，来更新原来的集合
pop	随机删除一个元素，返回元素本身；不能指定参数，不能指定删除某个元素
remove(obj)	`obj`必须是集合`set`中的元素，否则报错；没有返回值
discard(obj)	`obj`如果在集合中就执行删除，否则不进行任何操作，与`remove`不同
clear()	删除所有元素，`bool(set)`为`False`

操作

常见的操作

并集：union、|
交集：intersection、&
子集（包含于）：issubset()
超集（包含）：issuperset()

内建函数

enumerate

遍历序列的同事跟踪其索引，使用enumerate()，返回的是(i, value)

lst = ["foo", "bat", "bar"]
mapping = {}
for i,v in enumerate(lst):
  mapping[v] = i   # 键是lst中的元素，值是该元素的索引

sorted

sorted函数返回的是排序好的一个列表，默认是从小到大

1 2	sorted([1,3,4,2,6,5]) [1,2,3,4,5,6]

zip

配对

将列表、元组或者其他序列中的元素进行配对组合，新建一个元组构成的列表

生成的长度由最短的序列决定。有时和enumerate()连用：

1 2	for i, (a,b) in enumerate(zip(seq1, seq2)): print('{0}:{1},{2}'.format(i,a,b))

拆分

将已经配对的序列用zip进行拆分，注意*的使用

1	first_name, last_name = zip(*pitchers)

利用zip实现矩阵转置

list2 = [[1, 2], [3, 4], [5, 6]]
list(zip(*list2))

[(1,3,5), (2,4,6)]

map

方法中有两个参数，一个是函数，另一个是待运行的序列，基本样式：map(func, seq)
func是一个函数对象，seq是序列对象
执行：可迭代序列对象seq中的元素，依次取出来放入函数func对象进行执行，相当于是for循环。
返回值被放入一个列表

items = list(range(10))
def square(x):
  return x*2

list(map(square, items))   # 函数+序列

1
2
3

list1 = range(1, 6)
list2 = range(6, 11)
list(map(lambda x, y: x + y, list1, list2))   # 将两个list中的对象一次相加

求出两个列表中对应位置的较大值

1
2
3

a = [1, 2, 3, 4, 5]
b = [2, 3, 2, 4, 8]
list(map(lambda x: max(x), zip(a,b)))

reduce

在Python3中reduce已经被转移到functools模块里面了，使用的时候需要进行导入：

from functools import reduce
两个参数 reduce(function, seq)
执行：从左到右根据函数一次执行
返回值是一个value

高斯求和利用reduce函数实现

1 2	lst = range(1, 101) reduce(lambda x, y: x+y, lst)

filter

filter翻译成中文就是过滤器的意思，在Python起到了过滤的作用，将满足条件的对象进行输出:

两个参数：函数+可迭代对象
满足条件的对象进行输出

1 2	numbers = range(-5, 5) list(filter(lambda x: x < 0, numbers)) # 选出小于0的数，返回列表list

推导式

列表推导式

1	[x.upper() for x in strings if len(x) > 2]

字典推导式

1	dict_comp = {key-expr: value-expr for value in collections if condition}

创建一个字符串与其位置相匹配的字典

1	loc_mapping = {val: index for index, val in enumerate(strings)}

集合推导式

1	set-comp = {expr for value in collection if condition}

1	unique_len = {len(x) for x in strings}

上述功能使用map函数

1	set(map(len, strings))

嵌套推导式

some_tuples = [(1,2,3),(4,5,6),(7,8,9)]
# 方法1
flattened = [x for tup in some_tuples for x in tup]

# 方法2：列表推导式中的列表推导式
[[x for x in tup] for tup in some_tuples]

# 方法3:for循环
flattened = []
for tup in some_tuples:
  for x in tup:
    flattened.append(x)   # 不断地追加到末尾