Python 快速刷题 技巧 | 知识点速览（持续更新）

Python 快速刷题

目录

目录

• Python 快速刷题
  • 目录
  • 背景
  • Tips
  • python基础知识
    • 1.输入
    • 2. 输出
    • 3. 基本数据类型
      • 算术运算符
      • String 字符串
      • List列表
      • Set集合
      • Tuple元组
      • Dict 字典

背景

Background背景: 本人在做企业笔试题的时候，有些企业的笔试不让使用Go语言，在C、C++、JAVA、Python中，Python的能够快速上手！所以将Python语言作为第二种刷题语言，并总结以下基础知识，便于做题的查询。

Python3 教程 | 菜鸟教程 (runoob.com)

Tips

在单页面无ide的情况下，如果查找函数名字

print(dir(dict))#显示所有dict字典类型的函数名
#['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__ior__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__ror__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
print(help(dict.get))
'''
Help on method_descriptor:
get(self, key, default=None, /)
    Return the value for key if key is in the dictionary, else default.
None
'''

python基础知识

1.输入

# input(prompt), input函数中可以放一些输入的提示语句prompt
# 默认读取是字符串，如果是非字符串，需要进行转换
#将input读取的字符串转化内int类型，input默认读取一行
a = int(input())
# 一行读取两个int类型，以空格间隔
n, m = map(int, input().split())
# 一行读取多个int类型的值，并转换为为list
l = list(map(int, input().split()))

2. 输出

print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=""：

print("a",end="")

# 简单拼接输出
print("name is",name)

# 指定分隔符
print("1","2","3",sep="-")

# 指定结尾
print("Hello", end=" world!")

# 格式化输出,采用%或者format()函数，以及f函数
print("%s is %.4f"%("ten",10)) 		 # ten is 10
print("{0} is {1}".format("ten",10)) # ten is 10

#此处注意f字符中，嵌套在 f 字符串中的字符串不能使用与 Python 3.12 之前的 f 字符串相同的引号字符,也就是{}中的变量不能为“ten”,只能为不同符号的'ten'
print(f"{'ten'} is {10}")

# ASCII码 转化输出
print(ord('a'),chr(65)) #输出97 A

# 打印输出到文件
# r后面跟着的路径，不会因为’\‘转生转义，比如"\n"正常表示回车
# 'a+'添加的模式存入文件n.txt，若文件不存在则创建新文件
fp = open(r"C:\n.txt",'a+') 

List实用输出

# 实用！! 
# 打印result列表中的元素，并以','逗号分隔，这样最后一个元素后面是没有逗号的！
result = [1,2,3,4]
print(",".join(str(x) for x in result)) # 输出: 1,2,3,4

3. 基本数据类型

• Number（数字） 不可变
• String（字符串）不可变
• bool（布尔类型）可变
• List（列表） 可变
• Tuple（元组）不可变
• Set（集合）可变
• Dictionary（字典）可变

算术运算符

0b101为二进制5，0o5为八进制5，0x5为16进制5

进制转化：

#将字符串，以16进制解析，转换成10进制数
int("2a",16) # 2*16+10=42
bin(3) # 将3转换为二进制0b11，输出为str
oct(11) # 将11转换为八进制0o13,输出为str
hex(11) # 将11转换为十六进制0xb,输出为str
int(0b101) # 二进制转化为10进制
int(0o5) # 八进制转化为10进制
int(0x5) # 十六进制转化为10进制，因为0x5是int类型，直接转
int(bin(3),2) # 因为bin输出是str，所以要指定进制数为2去解析str，继而转换为int

1. 幂次**

a = 2**3 # 2^3=8

2. 科学技术

#同Go语言
b = 2e3 #2*10^3
b = 2E3 #2*10^3

3. 向下取整 //

c = 9//2 #4

4. 右移 >>左移<<

# 同Go语言
d = 9>>1 # 二进制0b1001 >> 1 = 0b100 = 4
#>>1等价于，向下整除2，同python中//
e = 1<<2 # 0b001 << 2 = 0b100 = 4
# 相当于1乘二的2次方数，即1*(2**2)=4

5. 位运算&|^~

# 同Go语言
3&5 #0b011 & 0b101 = 0b001 = 1
3|5 #0b011 | 0b101 = 0b111 = 7
3^5 #0b011 ^ 0b101 = 0b110 = 6
~5  # ~ 0b101 = -0b110 = -6
# go语言中，取反是 ^5 =-6

6. 链式比较

x = 3
1<x<5 # true

String 字符串

# 字符串倒序输出
order = "Hello world!"
res = order[::-1] # 逆序 !dlrow olleH

List列表

类似于go里面slice切片

# 声明
l = []
l = set([])
# 添加元素
l.append(1)
l.insert(0,1)#在索引0的位置插入1,原函数索引0以及后面的元素后移
a = l.copy() # 复制列表
# 删除元素
del l[0]
l.remove(1) #删除1这个元素
l.pop([index=-1])#默认移除列表最后一个元素
l.clear() # 删除整个列表元素
#长度
len(l)
# 组合
[1,2,3]+[4,5] # [1,2,3,4,5]
[1]*2 # [1,1]
# 查询
l.index(1) # 返回1元素的第一个的位置，其中1必须是列表l中的元素，否则使用下面的判断
2 in [1,2,3] # True
# 读取
l[-1] # list元素最后一个
# 最大值，最小值，求和
max(l),min(l),sum(l)
#在l数组中计数
l.count(2)
#排序
l.sort() #原列表l进行排序
a = sorted(l,[reserve = True]) # 返回排序后的列表，原列表不受影响
l.reverse() # 倒序
# 遍历
l = [1,2] 	# list
for x in l: print(x)
for i, item in enumerate(l):
	print i, item

# 截取-深拷贝
l = [1,2,3,4]
a = l[1:3] #2,3
a[0] = 5
print(l,a) #[1, 2, 3, 4] [5, 3]

# 截取，并且有步长，步长-1，为倒序
# seq[start:end:step]
l = [1,2,3,4,5,6,7,8]
r1 = l[::-1] # [8,7,6,5,4,3,2,1]
r2 = l[::2] # [1,3,5,7]

# 比较
import operator
l1 = [1,2,3,4]
l2 = [2,3,4,5]
print(operator.eq(l1,l2)) # False

Set集合

s = set()# 创建空的set
s.add("a")# 添加单个元素
s.update("abcde")#将元素拆个单个字符添加入集合中
s.remove("a") #删除元素,若不存在元素“a"，则报错
s.discard("a")#删除元素，若不存在，则啥事不干
s.pop() # 随机删除一个元素，若为空，则报错
s.clear()#清空集合

s = {1,2} 	# set 集合内不存在重合元素
for i, item in enumerate(l):
	print i, item
    
# 没有sort函数，默认已经sort
a = [9,8,7,6,2,2,1]
print(set(a)) # {1,2,6,7,8,9}

# 集合操作
s1 = {1,2,3,4,5}
s2 = {4,5,6,7,8}
# 交集，以下不修改原集合，返回新集合
print(s1&s2) #{4,5}
print(s1.intersection(s2)) #{4,5}
# 差集，以下不修改原集合，返回新集合
print(s1-s2)#{1,2,3}
print(s1.difference(s2))#{1,2,3}
#并集，以下不修改原集合，返回新集合
print(s1|s2)#{1, 2, 3, 4, 5, 6, 7, 8}
print(s1.union(list(s2)))#{1, 2, 3, 4, 5, 6, 7, 8}

# 集合对比>,>=,<,<=,==,!= 子集含包关系
s1＝set([1, 2, 3, 4, 5])
s2＝set([1, 2, 3, 4])
print(s1>s2)#True
print(s2>s1)#True
print(s1!=S2)#True

# 不可变集合frozenset，不可修改，其他同set
f = frozenset('asdf')#frozenset(['a', 's', 'd', 'f'])

Tuple元组

t = (1,"2") # tuple
for i, item in enumerate(l):
	print i, item

Dict 字典

类似于Go语言里面的map

# 初始化
d = set({})
#添加元素
d[1]=1
d[key]=value
#删除元素
del d[key] # 删除指定键值对
d.pop(key)# 删除并返回指定键值对的
d.popitem()#删除并返回最后一对键值对
d.clear() #删所有键值对
#获取元素值
d.get(1) # 若存在则返回等同于d[1],否则返回None
#浅拷贝
d1 = d.copy()
#深拷贝
d1 = d.deepcopy()

# 获取dict中的key
d = {1:"a",2:"b",3:"c"}
a = list(d.keys()) # "1","2","3"

# 获取dict中的value
d = {1:"a",2:"b",3:"c"}
a = list(d.values()) # "a","b","c"

# 遍历
d = {1:"a",2:"b",3:"c"}
for a,b in d.items():
	print(a,b)
    
# 按key排序排序
l = {3:"a",1:"b",2:"c",4:"d"}
[l[key] for key in sorted(list(l.keys()))] # ["b","c","a","d"]