python知识补充

确定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 = val
        self.next = next

    def change(lst):
        if not lst:
            return
        pre = ListNode(lst[0]) # 确定一个头节点
        head = pre
        cur = pre
        n = len(lst)
        for i in range(1, n):
            node = ListNode(lst[i])
            cur.next = node
            cur = cur.next
        return head

if __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('双端队列为空')
            return
        for 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): # 插入到尾部 append
        self.__members.append(data)
 
    def head_outer(self): # 从头部弹出pop(0)
        if self.is_empty():
            return
        return self.__members.pop(0)
 
    def end_outer(self): #从尾部弹出pop()
        if self.is_empty():
            return
        return self.__members.pop()
 
    def length(self): # 求解长度
        return len(self.__members)
 
    def check(self, index):
        if index < 0 or index > len(self.__members)-1:
            raise IndexError
        return self.__members[index]

十进制转换为二进制

number = 9 # 转化为二进制1001
binary_test = format(number, 'b') # 十进制转换为二进制
print('binary_test:',binary_test)

binary = ''
while number > 0:
    remainder = number % 2
    binary = str(remainder) + binary # 每次除模2,加入到字符串中
    number = number // 2 # number每次除以2
    if 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) + number

    Digits = Digits-1

print(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 Counter

List = ['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]¹

---

1. 0,1 ↩︎