python易忘操作和小知识点集锦_python true sum 可以吗-优快云博客

本文链接：https://blog.youkuaiyun.com/Code_LT/article/details/120484204

取反：

s=s[::-1]

s=inversed(s)

三目运算

h = "变量1" if a>b else "变量2"
# 可用于推导表达式
arr = (x if x>5 else x*2 for x in range(10))

造数组

a1=[0]*8 # 错误，这是浅拷贝，见下几行解析
a1= [0 for _ in range(8)) # 可行
a1=list(itertools.repeat(0,8)) # 可行
 
a3=[[0]*3 for _ in range(0,5)] #5行3列0
a1=list(itertools.repeat([0]*3,5))

## 误区-浅拷贝
>>> mat=[[0]*3]*3 
>>> mat
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
>>> mat[0][0]=1
>>> mat
[[1, 0, 0], [1, 0, 0], [1, 0, 0]]

正负无穷大

>>> a = float("inf")
>>> b = float("-inf")
>>> a
inf
>>> b
-inf

True的数字含义，1

>>> sum([True,False])
1
>>> sum([True,False,True])
2
>>> 0+True
1
>>> 2+True
3

增加元素，或可迭代对象

# 列表
l1= [1,2,3,4]
l2= [5,6，7，8]
l1.append(9) # 增加元素
l1.extend(l2) # 增加可迭代对象

# 元组
tup1 = ("a", "b", "c","d")
y = ("e",)
tup1 += y # 增加元素和可迭代对象

# 集合
s1={1,2,3,4}
s2={3,4,5,6}
s1.add(5) # 增加元素
s1.update(s2)  # 增加元素和可迭代对象
s1.union(s2)   # 和udpate作用相同

多层循环生成器


# grid=[[r1],[r2],...]
ans += sum(v > 0 for row in grid for v in row)

一次性初始化多个变量

# 直接赋值
a,b,c,d=1,2,3,4
a=b=c=d=1

# 利用列表或元组
li = [1,2,3] # li=(1,2,3)也可以
x,y,z=li # (x,y,z)=li也行，即使li是list,[x,y,z]=li也可以

字典推导

testDict = {i: i * i for i in xrange(10)} #{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
testSet = {i * 2 for i in xrange(10)} #set([0, 2, 4, 6, 8, 10, 12, 14, 16, 18])

循环枚举索引


list = [10, 20, 30]
for i, value in enumerate(list):
   print(i, ': ', value)

#1-> 0 : 10
#2-> 1 : 20
#3-> 2 : 30

原地交换

# 实际上，等号右边先处理成常量，然后再从左到右赋值
x,y=y,x

else的两个知识点

else的两个用法：

    - 跟在循环for或者while后，若被break停止，则后面的else语句块不执行

    - 跟在try...except..后，若有异常被捕获，则else不执行

嵌套表达式

l = [[1,2,3],[4,5,6]]
l2= [y for x in l for y in x]
>> [1,2,3,4,5,6]

方向数组

dx=[-1,1,0,0,-1,1,-1,1]
dy=[0,0,-1,1,-1,1,1,-1]
#用于搜索树
for k in range(8):
    x,y=i+dx[k],j+dy[k]
    if 0<=x<=self.m and 0<=y <-self.n and 其他剪枝条件:
        recursion(x,y,...)

列表相关

# 多个列表更改
mylist = [1,2，3,4，5]
mylist[1:3]=[9,10]

# 插入列表
mylist.insert(2,88)

# 尾部添加
mylist.append(99)

# 合并列表
mylist2 = [5,6，7，8]
mylist.extend(mylist2)
mylist=mylist+mylist2 #另一种写法

# 删除指定元素
mylist.remove(2)

# 删除指定位置
mylist.pop(2)
del mylist[2] #等价写法

# 默认删除最后一位
mylist.pop()

# 清空列表
mylist.clear()

set丢弃元素

s1={1,2,3}
s1.remove(4) # 没有4，会报错
s1.discard(4)  # 没有4，不会报错

函数参数，可混合，要遵守顺序：必选参数（又叫位置参数）、默认参数、可变参数、命名关键字参数和关键字参数

# 必选参数a,b
def fun(a,b) 

# 默认参数c
def fun(a,b,c='a')

# 可变参数d
def fun(a,b,c='a',*d) #剩余参数会作为元组，赋值给d，例如fun(1,2,3,4),结果为a:1,b:2,c:3,d:(4,)
def fun(*d) #也可单独一个d，则fun(1,2,3,4),d为(1,2,3,4)

# 关键字参数kw
def fun(a,b,**kw) #  fun(1,2,c=3,d=4)，则kw为{'c':3,'d':4}，也可解包裹法赋值，见后

# 命名关键字参数c,d
def fun(a,b,*,c,d) # fun(1,2,c=3,d=4),后的参数为命名关键字参数，函数调用时，必须赋值，否则会报错
def fun2(a,b,*arg,c,d) #这样，就不需要单独的*,c,d也是 命名关键字参数
fun(1,2,5,c=3,d=4) # 报错 可见 *,c,d是一体的，而不是*把其他参数作为可变参数
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: fun() takes 2 positional arguments but 3 positional arguments (and 2 keyword-only arguments) were given

# 混合规则：必选参数（又叫位置参数）、默认参数、可变参数、命名关键字参数和关键字参数
def func(a, b, c=0, *arg, d, **kw)

解包裹

# 当我们创建一个元组时，我们通常会为其分配值。这称为“打包”
# 我们也可以将值提取回变量中。这称为“解包”
li = (1,2,3,4) #打包, li =[1,2,3,4]也是
x,y,z,w=li #解包

# 带*号的解包
x,*y,z=li # y为[2,3]
x,y,*z=li # zw为[3,4]
m1={'a':1,'b':2,'c':3,'d':4,'e':5}
x,*y,z=m1 #y为['b','c','d']

# 函数传参的解包
def fun(a,b,c,d) #调用时 fun(*li)
def fun(**kw)  # 调用时解包fun(**m1)，注意：kw为m1的一个拷贝，修改kw不会改变m1

按列取元素


>>> a=[[1,2,3], [4,5,6]]
>>> a[:, 0]                   # 尝试用数组的方法读取一列失败,这是numpy的用法
TypeError: list indices must be integers or slices, not tuple

# 一种可行方法 
>>> b = [i[0] for i in a]     # 从a中的每一行取第一个元素。
>>> print(b)
[1, 4]
 
# 经典用法zip(*a)方案
>>> a=[[1,2],[3,4],[5,6]]
>>> list(zip(*a))
[(1, 3, 5), (2, 4, 6)]
>>> list(zip(*a))[0]
(1, 3, 5)
 
# 解释：zip可同时zipN个可迭代对象，所以可以用*a来解包裹
>>> b=[[1,2,3],[4,5,6],[7,8,9]]
>>> list(zip(*b))
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
>>> a=[1,2,3]
>>> b=[4,5,6]
>>> c=[7,8,9]
>>> list(zip(a,b,c))
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]