小知识点

1、逻辑运算符的优先级

（）>not>and>or

两边都是数字：

x or y,if x is True,return x(and 与之相反)

example:

1 > 1 or 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6 #True
not 2 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6   #False

 2、split（小bug）

name=' alex taibai linhaifeng'
print(name.split())      #['alex', 'taibai', 'linhaifeng']
print(name.split(' '))      #['', 'alex', 'taibai', 'linhaifeng']

 3、切片修改列表

li=[1,2,3,4,5]
li[0:3]='abcde'
print(li)

4、input 后都带上strip

content=input(">>>:").strip()

5、可变不可变：可哈希的就是不可变的

 lst='aaaggfwr24224234'
print(hash(lst))

6、字典的键值对交换

dic={'a':1,"b":2}
dic2={v:k  for k,v in dic.items()}
print(dic2)

7、函数闭包

闭包必须满足一下条件：
1)必须嵌套函数
2)内嵌函数必须引用一个定义在闭合范围内(外部函数里)的变量——内部函数引用外部变量

def count():
    fs = []
    for i in range(1, 4):
        def f():
            return i * i
        fs.append(f)
    return fs
f1, f2, f3 = count()
print(f1(),f2(),f3())   # 9 9 9 
#列表里存的是f这个函数，当f1,f2,f3执行时，i已经变成了3

def foo():
    fs=[]
    for i in range(1,4):
        def f(i):
            def g():
                return i*i
            return g
        fs.append(f(i))
    return fs
print (foo())
print (foo()[0]())

8 默认参数为可变类型

def extend_list(val, list=[]):
    list.append(val)
    return list

list1 = extend_list(10)
list2 = extend_list(123, [])
list3 = extend_list('a')
print(list1) 
print(list2)
print(list3)

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

9.send

#1.能达到__next__的功能，可以取下个值
#2.参数是作为上一个yield的返回值。
#坑：1.send不能正常放在最前面，若有放最前面，参数必须为None
#2.最后一个yield也不能接受到send的值

 10、计算一个列表中出现频率最高的元素

ls = [1,2,3,1,2,3,2,2,1,2,3,2,1,1,2,3]
print(max(set(ls), key=ls.count))

11、转置二维数组如：[['a','b'],['c','d'],['e','f']] --->[['a', 'c', 'e'], ['b', 'd', 'f']]

ls = [['a','b'],['c','d'],['e','f']]
print(list(map(list,(zip(*ls)))))

 12、链式函数的使用

def my_add(x,y):
    return x+y
def my_mtl(x,y):
    return x*y
flag=True
print((my_add if flag else my_mtl)(1,2) )

 13、列表推导式和生成器函数的比较

v = [lambda :x for x in range(10)]
print(v[0]())
#输出为9

v = (lambda :x for x in range(10))
print(next(v)()) 
#输出为0

14、类初始化过程

1、开辟一个内存空间用于存储对象属性
2、利用类对象指针找到类执行init方法
3、给对象封装属性
4、自动返回封装后的对象

15、经典类和新式类的区别

1、新式类继承Object
2、新式类有mro
3.super查找顺序是按mro
4、新式类广度优先，经典类深度优先

 16、多态和多态性

多态指的是一类事物有多种形态，（一个抽象类有多个子类，因而多态的概念依赖于继承）

多态性是指具有不同功能的函数可以使用相同的函数名，这样就可以用一个函数名调用不同内容的函数。在面向对象方法中一般是这样表述多态性：向不同的对象发送同一条消息，
不同的对象在接收时会产生不同的行为（即方法）。也就是说，每个对象可以用自己的方式去响应共同的消息。所谓消息，就是调用函数，不同的行为就是指不同的实现，
即执行不同的函数。17、

 17、super 

class A:
    def func(self):
        print('A')

class B(A):
    def func(self):
        super().func()
        print('B')

class C(A):
    def func(self):
        super().func()
        print('C')

class D(B,C):
    def func(self):
        super().func()
        print('D')
print(D.mro())
D().func()

输入如下：

 18、fromkeys

d = dict.fromkeys([1,2,3],[])
d[1].append('666')
print(d)

 19、yield和yield from 的区别

def fun():
    for i in 'abc':
        yield i
g  = fun ()
print(list(g))

上面等价于：

def fun():
    yield from 'abc'
g  = fun ()
print(list(g))

 20、进制之间的转换

v = 0b1111011
print(int(v))
# 十进制转二进制
v = 123
print(bin(v))
#八进制转十进制
v = 0o12
print(int(v))
#十进制转八进制
print(oct(10))
#同上，十六进制 hex