输入输出流
print list
数学运算
整除 //
Python遵循的取整方式为:向下取整
取余 %
取余结果 = 被除数 - 除数 * 整除结果
eg: -10 % 3 = -10 - 3 * (-4) = 2
整除 | 取模(求余) |
---|---|
10 // 3 = 3 | 10 % 3 = 1 |
10 // -3 = -4 | 10 % -3 = -2 |
-10 // 3 = -4 | -10 % 3 = 2 |
-10 // -3 = 3 | -10 % -3 = -1 |
常用函数
求长度
len(list)
求最大值/最小值:
max(val1, val2, val3)
求和sum()
内置求和函数sum(iterable, start = 0)
# Return the sum of a 'start' value (default: 0) plus an iterable of numbers
max_s = sum(weights)
排序
(1)原地排序 list.sort()
(2)自定义排序:sorted(iterable[, cmp[, key[, reverse]]])
特点:可以对所有可迭代的对象进行排序操作。返回的是一个新的 list,不修改原来的对象。
参数:
iterable – 可迭代对象。
cmp – 可选,比较的函数,这个具有两个参数,参数的值都是从可迭代对象中取出,此函数必须遵守的规则为,大于则返回1,小于则返回-1,等于则返回0。
key – 可选,主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中,指定可迭代对象中的一个元素来进行排序。
reverse – 可选,排序规则,reverse = True 降序 ,reverse = False 升序(默认)。
1. 按照第一个元素排序
sorted(a, key=lambda x:x[0])
>>> [('a',2),('b',3),('c',1),('d',4)]
2. 自定义比较函数
functools.cmp_to_key()将cmp函数转化为 key。
# 先比较第一个数的大小,再比较第二个数的大小
def compare(a, b):
if a[0] != b[0]:
return -1 if a[0] < b[0] else 1
else:
if a[1] < b[1]:
return -1
elif a[1] > b[1]:
return 1
else: return 0
s = [[1,6],[2,3],[1,4],[3,5]]
s = sorted(s, key=functools.cmp_to_key(compare))
print(s) # [[1, 4], [1, 6], [2, 3], [3, 5]]
lambda表达式
定义:lambda表达式是一行的函数。它们在其他语言中也被称为匿名函数,即函数没有具体的名称,
# 可直接调用/保存并调用:
add = lambda x, y: x + y # 保存niming print(add(3, 5)) # 调用函数
list
1. 初始化
mlist = [6,0,3]
2. 访问/修改元素
val = mlist[0] , mlist[0] = 1
3. 添加元素
末尾添加: mlist.append(val)
指定位置添加元素:list.insert(n,'4')
若指定的下标不存在,那么就是在末尾添加
4. 删除元素
mlist.pop() # 删除最后一个元素
mlist.pop(n) # 删除指定下标的元素
del mlist[0] # 删除指定下标的元素
5. 切片
返回副本:
t = mylist[:] 要使用这个,不然可变对象的值会被覆盖!!!!!
倒序:
t = mlist[::-1]
6.列表生成器
# 一维列表
list = [x * x for x in range(1,11)]
list = [0] * 10
# 二维列表
list = [[0] * m for i in range(n)] # 生成n行m列的二维
list list = [m + n for m in 'ABC' for n in 'XYZ'] # 两层循环,生成全排列
7.函数中返回一个新的list: return [val1, val2]
8. 计数count()
统计list中某元素次数
aList = [123, 'xyz', 'zara', 'abc', 123]
print "Count for 123 : "
aList.count(123)
遍历list
for i, num in enumerate(nums):
队列
from collections import deque
mq = deque() mq.append(val) #末尾添加元素
mq.popleft() #队首取出元素
哈希表
1. 初始化:
(1) mdict = dict()
(2) mdict = {}
2. 添加/修改键值对:
mdict[key] = val # mdict中没有key则添加键值对,有key则修改查出来的键对应对值为val
# !!!!! 注意不能自增
# 要取出来再加1
# eg:
mdict[key] = mdict.get(key,0) + 1
3. 根据key查询val:
dict.get(key, default=None)
val = mdict.dict.get(key) # key 不存在返回None
val = mdict.dict.get(key, 0) # key 不存在返回0
最小堆heapq
import heapq
1. 构建最小堆
heap = [22, 4, 8, 1] # 定一个list
heapq.heapify(list) # 原地将一个list转换为一个最小堆
2. 添加元素
heapq.heappush(heap, num) # 加入堆
3. 访问堆内容
## 弹出堆顶元素,即最小元素
print(heapq.heappop(nums))
# out: 2
4. 堆排序
## 获取所有堆排序后的元素
result = [heapq.heappop(nums) for _ in range(len(nums))]
print(result)
# out: [1,8,4,22]
## 获取堆最大或最小值
如果需要获取堆中最大或最小的范围值,则可以使用heapq.nlargest() 或heapq.nsmallest() 函数
## 限定排序范围,返回堆排序后的结果
nums = [1, 3, 4, 5, 2]
print(heapq.nlargest(3, nums)) # 返回nums最大的3个元素
print(heapq.nsmallest(3, nums)) # 返回最大的3个元素
"""
输出:
[5, 4, 3]
[1, 2, 3]
"""
## 自定义堆排序key
这两个函数还接受一个key参数,用于dict或其他数据结构类型使用
portfolio = [
{'name': 'IBM', 'shares': 100, 'price': 91.1},
{'name': 'AAPL', 'shares': 50, 'price': 543.22},
{'name': 'FB', 'shares': 200, 'price': 21.09},
{'name': 'HPQ', 'shares': 35, 'price': 31.75},
{'name': 'YHOO', 'shares': 45, 'price': 16.35},
{'name': 'ACME', 'shares': 75, 'price': 115.65}
]
cheap = heapq.nsmallest(3, portfolio, key=lambda s: s['price'])
expensive = heapq.nlargest(3, portfolio, key=lambda s: s['price'])
pprint(cheap)
pprint(expensive)
"""
输出:
[{'name': 'YHOO', 'price': 16.35, 'shares': 45},
{'name': 'FB', 'price': 21.09, 'shares': 200},
{'name': 'HPQ', 'price': 31.75, 'shares': 35}]
[{'name': 'AAPL', 'price': 543.22, 'shares': 50},
{'name': 'ACME', 'price': 115.65, 'shares': 75},
{'name': 'IBM', 'price': 91.1, 'shares': 100}]
"""
4. heapq应用
实现heap堆排序算法
>>> def heapsort(iterable):
... h = []
... for value in iterable:
... heappush(h, value)
... return [heappop(h) for i in range(len(h))]
...
>>> heapsort([1, 3, 5, 7, 9, 2, 4, 6, 8, 0])
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
该算法和sorted(iterable) 类似,但是它是不稳定的。
堆的值可以是元组类型,可以实现对带权值的元素进行排序。
>>> h = []
>>> heappush(h, (5, 'write code'))
>>> heappush(h, (7, 'release product'))
>>> heappush(h, (1, 'write spec'))
>>> heappush(h, (3, 'create tests'))
>>> heappop(h)
(1, 'write spec')
collections.Counter
from collections import Counter
c = Counter('adccbccdf') # c是类Counter的实例化。
print(c)
print(c.items()) # c.item()是将字典转化成列表,这个列表的每个元素是一个元组。
word_counts = [x for x in c.items()]
word=[x[0] for x in c.items()] # 提取元组x的第一位
print(word_counts)
print(word)
# 结果如下:
Counter({'c': 4, 'd': 2, 'a': 1, 'f': 1, 'b': 1})
dict_items([('a', 1), ('c', 4), ('f', 1), ('b', 1), ('d', 2)])
[('a', 1), ('c', 4), ('f', 1), ('b', 1), ('d', 2)]
['a', 'c', 'f', 'b', 'd']