确定defaultdict

1、如果字典的value存储的是整数

dic = defaultdict(int)
for num in s:dic[num] += 1

2、如果字典的value存储的是字符串

dic = defaultdict(list)
for num in s:dic[num].append(i)

字典排序

# 字典dic
paixu = sorted(dic.items(), key=lambda x:x[1], reverse=True)
# 默认是降序，reverse = False
# sorted()第一个参数写dic.itens()而不是dic
# 第二个参数不直接写lambda x 而要写成 key = lambda x
# lambda x冒号后面写对什么排序，如果按照两个值，则作为元组填充

对于leetcode中do not return everything解决办法

制造一个新的列表tmp，让nums = tmp即可
但最终的输出要写为：nums[:] = tmp ，一定要记得用这个中括号+冒号

sorted()函数对于字典的具体使用

对字典中的元素按照value值由大到小的进行降序排列，

lst = sorted(dic.items(), key = lambda x:x[0], reverse = True)

Counter函数的遍历还是按照原本的顺序

Counter()函数可以对列表自动的进行排序，但是遍历的时候，还是按照列表中原本的字母顺序进行遍历

append()在列表末尾添加，及在字典中的应用

append() 方法用于在列表末尾添加新的对象
对于一个字典，如果想要使用append
1、这个字典定义dic = {}

if num not in dic:dic[key] = [num]
else:dic[key].append(num)

2、这个字典定义 dic=collections.defaultdict()

dic = collections.defaultdict()
for key, num in nums:dic[num].append(key)

类里面有函数，函数里面有self的调用方式

class Test():def test1():#print("test1")return "test1"def test2(self):print("test2")x = Test.test1()
print(x)
a = Test()
a.test1()

python将列表转化为链表

class ListNode:def __init__(self, val=0, next=None):self.val = valself.next = nextdef change(lst):if not lst:returnpre = ListNode(lst[0]) # 确定一个头节点head = precur = pren = len(lst)for i in range(1, n):node = ListNode(lst[i])cur.next = nodecur = cur.nextreturn headif __name__ == "__main__":li = ListNode.change([1,3,4,6,9])print(li)print(li.val, "-->",li.next.val, "-->", li.next.next.val, "-->", li.next.next.next.val, "-->",li.next.next.next.next.val)

输出：

<__main__.ListNode object at 0x000001E7FF271CF8>
1 --> 3 --> 4 --> 6 --> 9

bisect

bisect(stack, needle) # 是在stack中搜索needle的位置，然后插入到这个位置上，stack还能保持升序
bisect_left表示新元素会放置到它相等的元素的前面
bisect_right表示新元素会放置到它相等的元素的后面（bisect的别名）

python标准数据类型

Python有五个标准的数据类型：

Numbers（数字）
String（字符串）
List（列表）
Tuple（元组）
Dictionary（字典）
Python支持四种不同的数字类型：

int（有符号整型）
long（长整型[也可以代表八进制和十六进制]）
float（浮点型）
complex（复数）

while a and b : 先判断a，后判断b

while drop and stack and stack[-1] < i: # 先要判断stack是否为空,然后才判断stack[-1]

collections.defaultdict()

Python中通过Key访问字典，当Key不存在时，会引发‘KeyError’异常。为了避免这种情况的发生，可以使用collections类中的defaultdict()方法来为字典提供默认值

from collections import defaultdict
s=[('yellow',1),('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
d=defaultdict(list)
for k, v in s:d[k].append(v)
print("d:", d)
a=sorted(d.items())
print("a:", a)

输出结果

d: defaultdict(<class 'list'>, {'yellow': [1, 3], 'red': [1], 'blue': [2, 4]})
a: [('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]

read,readline,readlines

python中有神奇的三种读操作：read、readline和readlines
read() ：一次性读取整个文件内容。推荐使用read(size)方法，size越大运行时间越长
readline() ：每次读取一行内容。内存不够时使用，一般不太用
readlines() ：一次性读取整个文件内容，并按行返回到list，方便我们遍历
————————————————
原文链接

bin()

返回一个整型或者长整型的二进制

eval()

十六进制转化为十进制的函数

ljust

ljust()方法语法：
str.ljust(width[, fillchar])
lst = “abc”
print(lst.ljust(8, “0”) == “abc00000” 长度为8，不满足8零代替

Counter()

把一个数组表示为字典，以value从大到小的排序
for key in ans=Counter(lst):
这里的key是按数组的顺序进行遍历的

正无穷，负无穷

算法题中min=float(“inf”) or max = float("-inf")
正无穷
print(float(“inf”))
print(float(“inf”)+1)
负无穷
print(float("-inf"))
print(float("-inf")+1)

Counter()函数

1、Counter(lst) 直接传入列表之后，就有对应的计数值
2、查看 res = Counter(lst) print(dict(lst))
3、Counter 可以传入数组字符串和列表等
4、获取所有元素 list(res.elements())
5、最常见的k个元素 res.most_common(k)
参考：https://blog.csdn.net/rocking_struggling/article/details/104851741

def topKFrequent(nums, k):lst = Counter(nums)return lst.most_common(k)
lst = topKFrequent([3,0,1,0], 1)
print(lst)
输出：
[(0, 2)]

**sorted函数

sorted(iterable, , key=None, reverse=False)*
从可迭代的项中返回一个新的排序列表。
有两个可选的命名关键字参数。
key：
指定一个参数的函数，该函数用于从每个列表元素中提取比较键：key = str.lower。默认值为None（直接比较元素）。
如果列表中的元素是字符串，那么key = str.lower可以使比较都按小写字母的ASCII码进行比较。
reverse：
是一个布尔值。如果设置为True，则列表元素将按照每个比较相反的方式进行排序。从小到达大排序改为从大到小

动态规划中建立二维数组

*df = [[0]n for _ in range(m)]

format()

m = format(max([2,10,8]), ‘b’) 求解与或之后的最大值的二进制值
print(m) # 1010

print(format(8, “b”)) # 1000 求解当前数字的二进制值
print(format(10, “b”)) # 1010
print(format(2, “b”)) # 0010
print(format(2^8, “b”)) # 1010

位运算符

& : 按位与操作, 只有 1&1 为 1, 其它情况为 0. 可用于进位运算
| : 按位或操作 , 只有 0|0 为0 ,其他情况为1
~ : 逐位取反
^ : 异或, 相同为 0 ,相异为 1 . 可用于加操作 (不包括进位项 )
<< : 左移操作, 2的幂有关

: 右移操作, 2的幂有关

3<<2则是将数字3左移动2位

计算过程：

3<<2首先把3转换为二进制数字00000000000000000000000000000011
然后把该数字高位(左侧)的两个零移出，其他的数字都朝左平移2位，最后在低位(右侧)
的连个空位补零。则得到的结果是00000000000000000000000000001100，
则转换为十进制是12
在数学没有溢出的前提下，对于正数和负数，左移以为都相当于乘以2的1次方，左移n位
就相当于乘以2的n次方

11>>2则是将数字11右移2位

计算过程：

11的二进制形式为：00000000000000000000000000001011然后把低位的最
后两个数字移出，因为该数字是正数，所以在高位补0，则得到的最终的二进制结果为：
00000000000000000000000000000010转换为十进制数为3
数学意义：
右移一位相当于除以2，右移n位相当于除以2的n次方，这里取的是商，不要余数

python中的队列Queue

python queue模块有三种队列:
1、python queue模块的FIFO队列先进先出。
2、LIFO类似于堆。即先进后出。
3、还有一种是优先级队列级别越低越先出来。
针对这三种队列分别有三个构造函数:
1、class Queue.Queue(maxsize) FIFO
2、class Queue.LifoQueue(maxsize) LIFO
3、class Queue.PriorityQueue(maxsize) 优先级队列
介绍一下此包中的常用方法:
Queue.qsize() 返回队列的大小
Queue.empty() 如果队列为空，返回True,反之False
Queue.full() 如果队列满了，返回True,反之False
Queue.full 与 maxsize 大小对应
Queue.get([block[, timeout]])获取队列，timeout等待时间
Queue.get_nowait() 相当Queue.get(False)
非阻塞 Queue.put(item) 写入队列，timeout等待时间
Queue.put_nowait(item) 相当Queue.put(item, False)
Queue.task_done() 在完成一项工作之后，Queue.task_done()函数向任务已经完成的队列发送一个信号
Queue.join() 实际上意味着等到队列为空，再执行别的操作

先进先出

python的双端队列

原文地址：http://blog.sina.com.cn/s/blog_b5fe6b270101esju.html

什么是双端队列

deque，全名double-ended queue）是一种具有队列和栈的性质的数据结构。双端队列中的元素可以从两端弹出，其限定插入和删除操作在表的两端进行。

下面简单的介绍一下python中双端队列的操作函数；

from collections import deque #首先从collections 模块中导入deque类

下来我们定义一个双端队列

1.A=deque([]) #创建一个空的双队列
2.A.append(n) #从右边像队列中增加元素，n表示增加的元素，即最先进的在最前面
3.A.appendleft(n) #从左边像队列中增加元素，n表示增加的元素，即最先进的在最后面
4.A.clear() #清空队列
5.A.count(n) #在队列中统计元素的个数，n表示统计的元素
6.A.extend(n) #从右边扩展队列，n表示扩展的队列
7.A.extendleft(n) #从左边扩展队列，n表示扩展的队列
8.A.pop() #从队列的右边删除元素，并且返回删除值
9.A.popleft() #从队列的左边删除元素，并且返回删除值
10.A.remove(n) #从队列中删除指定的值
11.A.reverse() #翻转队列
12.A.rotate(n) #旋转队列，默认时值为1，由右边开始旋转，负值代表左边旋转，n代表从队列的第一个元素开始，n从1开始计数

双端队列旋转演示图

# python中的双端队列
# coding=utf-8
class SequenceDoubleQueue(object):def __init__(self):self.__members = list()def is_empty(self): # 判断是否为空return not len(self.__members)def show(self):if self.is_empty():print('双端队列为空')returnfor member in self.__members:if self.__members.index(member) != len(self.__members)-1:print(member, end='|')else:print(member)def head_enter(self, data): # 插入到头部insert(index, value)self.__members.insert(0, data)def end_enter(self, data): # 插入到尾部 appendself.__members.append(data)def head_outer(self): # 从头部弹出pop(0)if self.is_empty():returnreturn self.__members.pop(0)def end_outer(self): #从尾部弹出pop()if self.is_empty():returnreturn self.__members.pop()def length(self): # 求解长度return len(self.__members)def check(self, index):if index < 0 or index > len(self.__members)-1:raise IndexErrorreturn self.__members[index]

十进制转换为二进制

number = 9 # 转化为二进制1001
binary_test = format(number, 'b') # 十进制转换为二进制
print('binary_test:',binary_test)binary = ''
while number > 0:remainder = number % 2binary = str(remainder) + binary # 每次除模2,加入到字符串中number = number // 2 # number每次除以2if binary == binary_test: # 当所求的binary和给定的binary_test相等，输出print('转换结果binary：'+binary)

输出结果：

binary_test: 1001
转换结果binary：1001

二进制转化为十进制

# print('需要转换为二进制的数字：'+binary)
binary = '1001'
Digits = len(binary)
number = 0
while Digits > 0:number = int(binary[-Digits])*2**(Digits-1) + numberDigits = Digits-1print(f'转换结果number：{number}')

输出结果：

转换结果number：9

类和init函数和self

哪一个对象调用的方法，self就是哪一个对象的引用
类名：Cat:
创建猫对象： tom = Cat()
可以利用.属性名 利用赋值语句就可以1、__init__方法是专门用来定义一个类具有哪些属性的方法
2、在__init__方法内部使用
self.属性名=属性的初始值   就可以定义属性
3、定义属性之后，再使用Cat类创建对象，就会默认拥有该属性
4、使用类名()创建对象的时候，会自动调用初始化方法__init__class Cat:def __init__(self,new_name): # new_name 形参self.name = new_name# self.name = "Tom" # 不希望固定name,加形参def eat(self):print("%s爱吃鱼“ %self.name)

tom = Cat(“Tom”)
tom.eat()
lazy_cat = Cat(“Lazy_cat”)

python的索引：左包右不包
如你所见，切片适用于提取序列的一部分，其中的编号非常重要：第一个索引是包含的第一个元素的编号，但第二个索引是切片后余下的第一个元素的编号。请看下面的示例：

>>> numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> numbers[3:6] [4, 5, 6]
>>> numbers[0:1] [1]

简而言之，你提供两个索引来指定切片的边界，其中第一个索引指定的元素包含在切片内，但第二个索引指定的元素不包含在切片内。
————————————————
版权声明：本文为CSDN博主「zaf赵」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/zaf0516/article/details/90756825

0、删除列表中的指定元素
方法一：通过位置索引删除元素用 pop() 方法
方法二：删除列表中某个指定元素，用 remove() 方法

1、字符串的拼接

res = ['2','3','5']
ret = ''
for i in res:ret += i
print(ret)

最终输出结果： 235

2、map()函数
map是python内置函数，会根据提供的函数对指定的序列做映射。

map()函数的格式是：

map(function,iterable,…)
第一个参数接受一个函数名，后面的参数接受一个或多个可迭代的序列，返回的是一个集合。

把函数依次作用在list中的每一个元素上，得到一个新的list并返回。注意，map不改变原list，而是返回一个新list。

***将元组转换成list***
>>> map(int, (1,2,3))
[1, 2, 3]
***将字符串转换成list***
>>> map(int, '1234')
[1, 2, 3, 4]
***提取字典的key，并将结果存放在一个list中***
>>> map(int, {1:2,2:3,3:4})
[1, 2, 3]
***字符串转换成元组，并将结果以列表的形式返回***
>>> map(tuple, 'agdf')
[('a',), ('g',), ('d',), ('f',)]
#将小写转成大写
def u_to_l (s):return s.upper()
print map(u_to_l,'asdfd')

map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。

例如，对于list [1, 2, 3, 4, 5, 6, 7, 8, 9]

如果希望把list的每个元素都作平方，就可以用map()函数：

因此，我们只需要传入函数f(x)=x*x，就可以利用map()函数完成这个计算：

def f(x):return x*x
print map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
1
2
3
输出结果：[1, 4, 9, 10, 25, 36, 49, 64, 81]

原文链接：map

————————————————

3、Counter()函数
可以形成一个key：value键值对
Counter()也可以用于统计字符出现的个数或列表中元素出现的次数。返回结果按出现次数从多至少排列。
一个Counter是一个dict的子类，用于计数可哈希对象。

**Counter().most_common(n)**返回数组中出现次数最多的元素。参数n表示的含义是：输出出现次数最多的前n个元素。

from collections import CounterList = ['appel','pear','orange','banana','pear','mango','grape']
a = Counter(List)
print(a)b = Counter("It's fine today.")     # 空格以及符号出现次数也会统计
print(b)b.update(List)  # 添加
print(b)c = b.most_common(3)
print('出现次数前三的元素：',c)

输出结果：
Counter({‘pear’: 2, ‘appel’: 1, ‘orange’: 1, ‘banana’: 1, ‘mango’: 1, ‘grape’: 1})
Counter({‘t’: 2, ’ ‘: 2, ‘I’: 1, "’": 1, ‘s’: 1, ‘f’: 1, ‘i’: 1, ‘n’: 1, ‘e’: 1, ‘o’: 1, ‘d’: 1, ‘a’: 1, ‘y’: 1, ‘.’: 1})
Counter({‘t’: 2, ’ ‘: 2, ‘pear’: 2, ‘I’: 1, "’": 1, ‘s’: 1, ‘f’: 1, ‘i’: 1, ‘n’: 1, ‘e’: 1, ‘o’: 1, ‘d’: 1, ‘a’: 1, ‘y’: 1, ‘.’: 1, ‘appel’: 1, ‘orange’: 1, ‘banana’: 1, ‘mango’: 1, ‘grape’: 1})
出现次数前三的元素： [(‘t’, 2), (’ ', 2), (‘pear’, 2)]

————————————————
counter函数
4、bin()函数
将整数转换为二进制字符串

7、字符串的删除
删除字符串的两种方法

tmp.replace(a, ‘’) 将字母a替换成无字符

8、将列表合并为字符串
join函数将列表合并成自付差U
stack = [‘a’, ‘b’]
‘’.join(stack) === ‘ab’

sort 与 sorted 区别：

sort 是应用在 list 上的方法，属于列表的成员方法，sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
sort使用方法为ls.sort()，而sorted使用方法为sorted(ls)

range()函数
range(5) ⇒ 0,1,2,3,4
range(1,5) => 1,2,3,4

tmp = input() # 输入的是一个整数  12300
sting = str(tmp) # 整数变为字符串  ‘12300’
lst = [] # 给定一个空的列表
for i in sting:lst.append(i) # 列表将每一个字符串独自包装起来 lst = ['1','2','3','0','0']
ret = lst[::-1] # 数组可以倒序 # lst = ['0','0','1','2','3']
res = '' # 定义一个空字符串
for j in ret: # 遍历当前数组res += ''.join(j) # 每次找到一个元素加到字符串里面 res = '00123'
print(res) # 返回字符串类型

字符串可以直接 str[::-1]

9、pop(i) 里面加的是index索引

10、换位符<< >> & |

和 <<都是位运算，对二进制数进行移位操作。

<< 是左移，末位补0，类比十进制数在末尾添0相当于原数乘以10，x<<1是将x的二进制表示左移一位，相当于原数x乘2。比如整数4在二进制下是100，4<<1左移1位变成1000(二进制)，结果是8。

是右移，右移1位相当于除以2。
而>>=和<<=，就是对变量进行位运算移位之后的结果再赋值给原来的变量，可以类比赋值运算符+=和-=可以理解。
比如x>>=2，就是把变量x右移2位，再保留x操作后的值。

首先 & 是位运算符，and 是逻辑运算符
举例1: 设a和b是两个整数，a=1，b=2
a&b 分析：a以二进制表示就是01，b以二进制表示就是10，故&的运算结果就是00，即十进制的0

a|b ==> a or b

11、两个函数要调用的时候
主函数的输出是 return def次函数()才能有值，不然只可以返回None
12、字典

    for key in map.keys(): # 爱输出字典的key值print(key)for value in map.values(): # 输出字典的value值print(value)for key, value in map.items(): # 输出字典的键值对print('---')print(key, value)

python中与除法相关的三个运算符是// 和 / 和 %，
“/”，这是传统的除法，3/2=1.5 浮点数
“//”，在python中，这个叫“地板除”，3//2=1 整数
“%”，这个是取模操作，也就是区余数，4%2=0，5%2=1 余数
% / //

**异或 **
他的意思就是“位值”一样的就为0 不一样就为1
所以 3异或4 就是011 异或100 也就是111 也就是等于7 懂了吗
二进制的求解：
0111 == 12^0+1*21+12^2 =7
0001 xor 0011 = 0010 = 0*2^0+1*21 = 2

前缀异或：利用异或的特点进行消除
1, 2, 3, 4 [0,3]
3^4 = 1²3^4 ^ 1^ 2
3^4 = [0,3]¹

0,1 ↩︎

python知识补充相关推荐

Python学习---django知识补充之CBV
Django知识补充之CBV Django: url --> def函数 FBV[function based view] 用函数和URL进行匹配 url --> ...
ES6 复习，知识补充
ES6 知识补充概念 ECMAScript 6.0(以下简称 ES6)是 JavaScript 语言的下一代标准,已经在 2015 年 6 月正式发布了. 它的目标,是使得 JavaScript 语 ...
Java常用知识补充
Java常用知识补充目录 Java常用知识补充 1.sort与comparator 1)Java的sort 2)Java 的Comparator 2.java lamda 3.java集合 Arra ...
《Python知识手册》，V3.0版来了，2021年，走起！
"种一棵树,最好的时间是十年前,其次是现在." 一.前言大家好,今天给大家推荐我的一位好朋友,公众号「Python数据之道」号主 Lemon . 从 2017 年开始,Lemon ...
python下载教程1001python下载教程-Python知识圈
我们知道,苹果手机上的 APP 如果要做自动化测试的话,硬件上我们需要在 MAC 电脑,所以,我们需要在 Mac 电脑上搭建 APP 自动化环境.其中,Appium 是需要安装的,安装 Appium ...
太赞了！《Python知识手册》更新到v2.2版
"种一棵树,最好的时间是十年前,其次是现在." 一.前言大家好,今天给大家推荐我的一位好朋友,公众号「Python数据之道」号主 Lemon . 从 2017 年开始,Lemon ...
《Python知识手册》，高清pdf免费获取
"种一棵树,最好的时间是十年前,其次是现在." 一.前言大家好,今天给大家推荐我的一位好朋友,公众号「Python数据之道」号主阳哥 . 从 2017 年开始,阳哥陆陆续续在公 ...
肝了我好久，《Python知识手册V1.0》出来了！！！
最近这段时间,每天抽空整理了一份Python知识手册,当然也可以称为Python面试手册.以问答的形式去整理,包含基础篇.进阶篇.练习篇.爬虫篇.正则篇.Flask篇.Django篇.目前版本V1.0 ...
python之路day9_亮仔的Python之路Day9——Python知识体系重组
day9:2019-09-03 今日目的: 梳理python知识框架体系温故而知新最近总是在想如何构建一个知识体系我们经常接受碎片化的知识但是缺乏积累,无法搭建属于自己的知识框架我目前的解 ...

python知识补充