python基本数据类型

整型

# 正无穷：
a = float('inf')
# 负无穷：
b = float('-inf')
# 向下取整：
mid = (l + r) // 2
# 防止溢出：
mid = left + (right - left) // 2

字符型

# 反转字符串
ans = ans[::-1]

占位符

在处理一些字符串中，有时需要传入一些数据，而数据也是可变的，例如：网址（url），这时可以使用占位符来传递数值，格式化输出。

newc = '$'+f'{cost*(1-discount/100):.2f}'
$%d.%02d' % (i // 100, i % 100)

• %d 代表有符号十进制整数
  （1）'%d' % i 表示直接输出 i 的结果
  （2）'%2d' % i 表示输出长度为 2 的字符串，如果 i 的长度不够 2，则补空格
  （3）'%02d' % i 表示输出长度为 2 的字符创，如果 i 的长度不够 2，则补0
• %f 代表浮点数
  注意：传入整数默认保留小数点后六位，小数点前后加上小数点不超过
  （1）'%f' % i 表示直接输出 i 的结果，默认保留小数点后六位
  （2）'%9f' % i 表示输出长度为 2 的字符串，如果小数点后六位再加小数点和整数部分长度不够 9，则在整数部分前面补空格
  （3）'%09f' % i 表示输出长度为 2 的字符创，如果小数点后六位再加小数点和整数部分长度不够 9，则在整数部分前面补0
  （4）'%.2f' % i 表示输出小数点后长度为 2 的字符创，如果 i 的长度不够 2，则补0
  
• %s 表示字符串占位
  

注意：占位符可一次传入多个值

处理输出

• %.2f
  是一种表达式：'%.2f' % num
  在Python2.x和3.x都可用
• {:.2f}
  是字符串对象的方法：'{0:.2f}'.format(num)
  仅Python3.x可用

print('%.2f' % 3.454)
print('{:.2f}'.format(7.8234324))

print('test1:{0:3}'.format(3.4436566))  # 0可以省略
print('test2:{0:.3}'.format(3.4436566))  # 总共3位，不包括小数点
print('test3:{0:3f}'.format(3.4436566))
print('test4:{0:.3f}'.format(3.44356566)) # 小数点后3位

print(f'{4.54534:.2f}')  # python3.6之后用更简单的

列表list

1. 拼接列表

nums[: i] + nums[i + 1:]  # 拼接两个数组
path + [nums[i]]  # 拼接一个数组和一个数字

2. 向列表中添加列表元素，即变成内嵌列表：
   result.append(path[:])
   path[:]和 path.copy()才是等价的
   python是动态语言，变量名都只是对对象的引用，对于数组，字典，set等可变对象，后面的Path和结果数组里面的Path是同一个对象，一个改变，另一个也改变，了解一下copy和deepcopy

3. 在列表的指定索引位置插入：

que = []
        # print(people.sort(key = lambda x:(-x[0],x[1])))
        for p in people:
            # 按第2列的序号插到对应的位置，例如[4,4]就放在索引为4的位置
            # 但之前第1列比较大的就会被挤到后面去，例如[5,0],[7,0]
            que.insert(p[1],p)

4. 删除列表中的元素三种方法

4.1. remove: 删除单个元素，删除首个符合条件的元素，按值删除
举例说明:

mylist=[1,245,3,4,5,2,6]
mylist.remove(245)
mylist
# 输出：[1, 3, 4, 5, 2, 6]

4.2. pop: 删除单个或多个元素，按位删除(根据索引删除)
举例说明:

mylist=[0,1,2,3,4,5,6]
mylist.pop(1) #pop删除时会返回被删除的元素
mylist
# 输出：[0, 2, 3, 4, 5, 6]

mylist=['abc','bcd','dce']
mylist.pop(2)
# 输出：'dce'
mylist
# 输出：['abc', 'bcd']

4.3. del：它是根据索引(元素所在位置)来删除
举例说明:

mylist=[1,2,3,4,5,2,6]
del mylist[1]
mylist
# 输出：[1, 3, 4, 5, 2, 6]
mylist=['abc','bcd','dce']
del mylist[1]
mylist
# 输出：['abc', 'dce']

除此之外，del还可以删除指定范围内的值。

mylist=[0,1,2,3,4,5,6]
del mylist[2:4] #删除从第2个元素开始，到第4个为止的元素(但是不包括尾部元素)
mylist
# 输出：[0, 1, 4, 5, 6]

del 也可以删除整个数据对象(列表、集合等)

mylist=[0,1,2,3,4,5,6]
del mylist
mylist #删除后，找不到对象

5. 一次删除多个元素

方法1：不申请新的空间。该方法遍历两次列表，没有申请新的空间

def rmall(aa,e):#aa 待处理列表，e是删除的元素
    cnt=0
    for ee in aa:
        if e==ee:
            cnt+=1     #统计元素e出现的次数
    for i in range(cnt):
        aa.remove(e)     #调用cnt次remove函数，将元素e都删除掉。
    return aa

bb=rmall(a,1)
print(bb)

bb=rmall(ba,1)
print(bb)


a=[1,2,3,1,3,3,4,4,5,4,4,33,55,3,2,2,1,1,2,1,1,3,1,1,2]
ba=[1,1,2]

处理后，

a=[2, 3, 3, 3, 4, 4, 5, 4, 4, 33, 55, 3, 2, 2, 2, 3, 2]
ba=[2]

方法2：申请新的空间，该方法申请了一个新的列表控件，并只遍历一次列表。

a=[1,2,3,4,4]

def rmall(a,e):
    b=[]
    for ee in a:
        if ee!=e:
            b.append(ee)
        else:
            continue
    return b

b=rmall(a,4)
print(b)

6. 对嵌套数组中的数组进行排序，再对每个数组中的元素进行排序，并去重
   edge_index = list(k for k, _ in itertools.groupby(sorted(edge_index)))
   

7. 当作小根堆，每次加入元素时最小的都在第一个

from heapq import heappop, heappush, heapreplace
tmp = [3,5,1]
heappush(tmp, 0)
print(tmp)
# 输出：[0, 3, 1, 5]
# heapreplace(tmp, 7) # 相当于下面两行
heappop(tmp)
heappush(tmp, 7)
print(tmp)
# 输出：[1, 3, 7, 5]

6178. 将区间分为最少组数

字典类型dict

1. 三种修改字典key值的方法：
   dict={'a':1, 'b':2}
   1.dict["c"] = dict.pop("a")
   2.dict.update({'c':dict.pop("a")})
   3.dict['c']=dict['a']
   del dict['a']

6092. 替换数组中的元素

class Solution:
    def arrayChange(self, nums: List[int], operations: List[List[int]]) -> List[int]:
        map_ = dict()
        for i in range(len(nums)):  # 步骤1
            map_[nums[i]] = i
        for i in range(len(operations)):
            nums[map_[operations[i][0]]] = operations[i][1]  # 步骤2
            map_[operations[i][1]] = map_.pop(operations[i][0])  # 步骤3  # 方式1
            # map_.update({operations[i][1]:map_.pop(operations[i][0])})  # 方式2
            # map_[operations[i][1]]=map_[operations[i][0]]               # 方式3
            # del map_[operations[i][0]]  # 可省略
                                    
        return nums

2. 批量修改键和值

map1 = {1:'A', 2:'B', 3:'C', 4:'D', 5:'S', 14:'E', 53:'A+', 54:'B+', 55:'C+', 56:'D+', 57:'E+', 
              58:'-', 213:'Da', 214:'Db', 215:'Ea', 216:'Eb'} 
result = {3 : [1, 2], 14 : [], 213 : [215, 216]}

for k in list(result):
    if result[k]:
        for i, neib in enumerate(result[k]):
            result[k][i] = map1[neib]
    result[map1[k]] = result.pop(k)
result

3. 字典转成二维列表

edge_index = []
for src, dst in adj_dict.items():
    edge_index.extend([src, v] for v in dst)
    edge_index.extend([v, src] for v in dst)  # 无向图

defaultdict

对于普通的dict，key不存在就报错。
但是对于defaultdict，key不存在就会返回默认值。
from collections import defaultdict
332. 重新安排行程

# defaultdic(list) 是为了方便直接append
        tickets_dict = defaultdict(list)
        for item in tickets:
            tickets_dict[item[0]].append(item[1])
        '''
        tickets_dict里面的内容是这样的
         {'JFK': ['SFO', 'ATL'], 'SFO': ['ATL'], 'ATL': ['JFK', 'SFO']})
        '''

6149. 边积分最高的节点
步骤：
1.求每个节点的边积分，用defaultdict()存，dic[dst] += src这句就不会报错，因为当key=dst这个节点还没存进去的时候，默认dic[dst] = 0
2.得到边积分的最大值max(dic.values())
3.找边积分最大值对应的键max_node = [k for k,v in dic.items() if v==max_score]
4.取字典序最小的min(max_node)

class Solution:
    def edgeScore(self, edges: List[int]) -> int:
        dic = defaultdict(int)
        for i in range(len(edges)):
            dic[edges[i]] += i  # 步骤1
        # print(dic)
        max_score = max(dic.values())  # 步骤2
        # print(max_score)
        max_node = [k for k,v in dic.items() if v==max_score]  # 步骤3
        # print(max_node)
        return min(max_node)  # 步骤4

OrderedDict

有序字典

hashmap

# 声明hashmap
hashmap = dict()
hashmap = {}
# 使hashmap里的元素频率+1：
hashmap[s[end]] = hashmap.get(s[end], 0) + 1
# 遍历hashmap
for k,v in cnt.items():

169. 多数元素
用一个循环遍历数组 nums 并将数组中的每个元素加入哈希映射中。遍历哈希映射中的所有键值对，返回值最大的键。

counts = collections.Counter(nums)
return max(counts.keys(), key=counts.get)

hashset

lookup = set()
while s[i] in lookup:
      lookup.remove(s[left])
lookup.add(s[i])

双端队列

from collections import deque
que = deque([root])
cur = que.popleft()  #返回并删除队首元素
cur = que.pop()  #返回并删除队尾元素

优先队列

import heapq
dummy = ListNode(0)
heapq.heappush(head, (lists[i].val, i))
val, idx = heapq.heappop(head)


while l:
      heapq.heappush(minHeap, l.val)  #把l中的数据逐个加到堆中
      l = l.next

val = heapq.heappop(minHeap) #依次弹出最小堆的数据

面试题 17.09. 第 k 个数

class Solution:
    def getKthMagicNumber(self, k: int) -> int:
        # 使用小顶堆处理（因为每次需要得到最小的数字）
        heap = [1]  # 第一个元素是1
        for _ in range(k):
            res = heapq.heappop(heap)  # 每次取出堆中的首元素（最小元素）
            while heap and res == heap[0]:  # 去除重复元素
                heapq.heappop(heap)
            heapq.heappush(heap, res * 3)  # 依次将当前元素乘以3，5，7的值压入堆中
            heapq.heappush(heap, res * 5)
            heapq.heappush(heap, res * 7)
        return res

895. 最大频率栈
哈希表 + 优先队列（大根堆）O(logn)

class FreqStack:

    def __init__(self):
        self.q = []
        self.cnt = defaultdict(int)
        self.ts = 0

    def push(self, val: int) -> None:
        self.ts += 1
        self.cnt[val] += 1
        # 记录每次压入栈中的次数和索引,默认栈顶是最小值，因此取反
        heappush(self.q, (-self.cnt[val], -self.ts, val))

    def pop(self) -> int:
        res = heappop(self.q)[2]
        self.cnt[res] -= 1
        return res

# Your FreqStack object will be instantiated and called as such:
# obj = FreqStack()
# obj.push(val)
# param_2 = obj.pop()

tuple、list、dictionary操作

运算符

/ 、 //、%

/表示浮点整除法，返回浮点结果，也就是结果为浮点数;
而//表示整数除法，返回小于结果的一个最大的整数，意思就是除法结果向下取整，相当于floor(5/2)
%表示取模（取余）

位运算符

&：按位与运算符，见0得0；
|：按位或运算符，见1得1；
^：按位异或运算符，相异得1，相同得0；
~：按位取反运算符，对数据的每个二进制位取反，即把1变为0，把0变为1；
>>：右移动运算符，把 >> 左边的运算数的各二进位全部右移若干位，>> 右边的数指定移动的位数；
<<：左移动运算符，运算数的各二进位全部左移若干位，由 << 右边的数指定移动的位数，高位丢弃，低位补0。

3<<2解法:11向左移动两位变为1100,即12
10>>1解法:10的二进制是1010,向右边移动一位是101,即5.

参考资料：
菜鸟教程
python %d， %f， %s占位符的使用
Python六大基本数据类型
python 删除列表中某个元素的3种方法
Python——有序字典 (OrderedDict)
字典dict批量更改键/更改指定某一个键 python
Python批量修改字典的值