python 知识扫盲

v1 = 1 or 3
print(v1)
v2 = 1 and 3
print(v2)

v1 = 1
v2 = 3
or 具有截断效果,满足条件之后不会再匹配

v3 = 0 or False and 1
print(v3)
v4 = False or 0 and 1]
print(v4)

v3 = False
v4 = 0
False和0意义上是一样的,由于or的截断效果导致结果不一致

将字典按值的顺序排序

sorted(dic_items(), key=lambda x:x[1])

[(‘a’, 1), (‘b’, 2), (‘m’, 11), (‘k’, 18)]
dict()之后就是字典了
sorted()是用在可迭代对象的排序上,有四个参数:
参数1:需要排序的可迭代对象
参数2:被比较的函数False
参数3:按哪个值进行排序
参数4reverse:布尔值,默认为False,升序排序

python集合的运算
并集:|
交集:&
差集:-
异或:^
超集,真子集,真超集等等

去重之后按照原来的顺序排序

l1 = ['a', 'b', 'c', 'a', 'b', 'm', 'e']
print(l1.index)
l2 = list(set(l1))
print(l2)
l2 = sorted(l2, key=l1.index)
print(l2)

<built-in method index of list object at 0x000001EB6BF17408>
['m', 'b', 'c', 'a', 'e']
['a', 'b', 'c', 'm', 'e']

l1 = ['a', 'b', 'c', 'a', 'b', 'm', 'e']
print(l1.index)
l2 = sorted(set(l1), key=l1.index)
print(l2)

还有一种是使用遍历的方法
,这里就不写了.

下列程序的运行结果:

def appendlist(val, lst=[]):
    lst.append(val)
    return lst


lst1 = appendlist(10)
print(lst1)
lst2 = appendlist(123, [])
lst3 = appendlist('a')
print(lst1)
print(lst2)
print(lst3)

[10]
[10, 'a']
[123]
[10, 'a']

这从一个侧面也反应了编译型语言的特点.对于lst,如果没有特定的传参时,默认的lst将会参与到运算中.
带有参数的函数在定义的时候被运算,而不是被调用的时候被运算

反射与深浅拷贝

求打印结果

v = dict.fromkeys(['k1','k2'],[])
v['k1'].append(666)
print(v) #{'k1': [666], 'k2': [666]}
v['k1'] = 777
print(v)#{'k1': 777, 'k2': [666]}
#第一次字典的两个k指向的是同一块内存地址，所以k1的内存地址追加666，
k2的值也同样会是666，
而当给k1赋值时，改变了k1指向的内存地址，所以这个时候，k2不会随之发生变化

99乘法表

print("\n".join("\t".join(["%s*%s=%s" %(x,y,x*y) for y in range(1, x+1)]) 
                
# 递归
def f(i):
     if i>=1:
        f(i-1)
        print(['%dx%d=%d'%(j,i,i*j) for j in range(1,i+1)])
        
if __name__=='__main__':
    f(9)

打乱排好序的list

random.shuffle(list)