python基础查漏补缺

最近在阿里天池平台报名了龙珠训练营，学习python已经有一段时间了，借此机会系统查漏补缺一下。

本篇博文都是我个人不太熟悉的python语法和数据结构等。

1、三元操作符

简洁操作

x,y = 4,5
small=x if x<y else y
print(small)   #4

2、is和in的用法和区别

（1）is判断二者是否相等 in判断是否包含

（2）比较相等的两种方法is和==的区别

    is, is not 对比的是两个变量的内存地址
    ==, != 对比的是两个变量的值
    比较的两个变量，指向的都是地址不可变的类型（str等），那么is，is not 和 ==，！= 是完全等价的。
    对比的两个变量，指向的是地址可变的类型（list，dict，tuple等），则两者是有区别的。

a = "hello"
b = "hello"
c = "he"
print(a is b)
print(a is c)
print(c in a)   #T F T

3、通过位运算进行快速计算  *2或/2

<<

4、while-else循环、for-else循环

i = 0
while(i<5):
    print(i)
    i = i+1
else:
    print("跳出了")
#0 1 2 3 4 跳出了

5、enumerate函数

enumerate(sequence：一个序列、迭代器或其他支持迭代对象。 start：下标起始位置。 返回对象和索引

seasons = ["spring","summer","autumn","winter"]
for i,j in enumerate(seasons):
    print(i,"is",j)

for i,j in enumerate(seasons,start=1):
    print(i,"is",j)
#0 spring 1 summer 2 autumn 3 winter
#1 spring 2 summer 3 autumn 4 winter

6、字典推导式

b = {i: i % 2 == 0 for i in range(10) if i % 3 == 0}
print(b)
# {0: True, 3: False, 6: True, 9: False}

7、spilt函数可以控制切割次数

u = "www.baidu.com"
print((u.split(".", 1)))  # ['www', 'baidu.com.cn']

8、hashable

    数值、字符和元组 都能被哈希，因此它们是不可变类型。
    列表、集合、字典不能被哈希，因此它是可变类型。

9、函数参数

（1）可变参数

    *args - 可变参数，可以是从零个到任意个，自动组装成元组。
    加了星号（*）的变量名会存放所有未命名的变量参数。

def printinfo(arg1, *args):
    print(arg1)
    for var in args:
        print(var)

printinfo(10)  # 10
printinfo(70, 60, 50)
#输入的没有符合arg1要求的，则都传入*args
# 70  60  50

（2）关键字参数
    输入的关键字参数自动组合为字典

def printinfo(arg1, *args, **kwargs):
    print(arg1)
    print(args)
    print(kwargs)

printinfo(70, 60, 50,a=1,b=2)
#输出 70 [60 50] {'a':1,'b':2}

10、lambda表达式

定义的函数没有函数名
lambda argument_list:expression
    lambda - 定义匿名函数的关键词。
    argument_list - 函数参数，它们可以是位置参数、默认参数、关键字参数，和正规函数里的参数类型一样。
    :- 冒号，在函数参数和表达式中间要加个冒号。
    expression - 只是一个表达式，输入函数参数，输出一些值。

def sqr(x):
    return x*2

y = lambda x: x*2
y = lambda x,y:x+y
y = lambda *args:sum(args)
print(y(1,2,3))  #6

11、python的__new__方法

    __new__(cls[, ...]) 在一个对象实例化的时候所调用的第一个方法，在调用__init__初始化前，先调用__new__。
    __new__至少要有一个参数cls，代表要实例化的类，此参数在实例化时由 Python 解释器自动提供，后面的参数直接传递给__init__。
    __new__对当前类进行了实例化，并将实例返回，传给__init__的self。但是，执行了__new__，并不一定会进入__init__，只有__new__返回了，当前类cls的实例，当前类的__init__才会进入。

class A(object):
    def __init__(self, value):
        print("into A __init__")
        self.value = value

    def __new__(cls, *args, **kwargs):
        print("into A __new__")
        print(cls)
        return object.__new__(cls)


class B(A):
    def __init__(self, value):
        print("into B __init__")
        self.value = value

    def __new__(cls, *args, **kwargs):
        print("into B __new__")
        print(cls)
        return super().__new__(cls, *args, **kwargs)


b = B(10)
# 结果：
# into B __new__
# <class '__main__.B'>
# into A __new__
# <class '__main__.B'>
# into B __init__

 

class A(object):
    def __init__(self, value):
        print("into A __init__")
        self.value = value

    def __new__(cls, *args, **kwargs):
        print("into A __new__")
        print(cls)
        return object.__new__(cls)


class B(A):
    def __init__(self, value):
        print("into B __init__")
        self.value = value

    def __new__(cls, *args, **kwargs):
        print("into B __new__")
        print(cls)
        return super().__new__(A, *args, **kwargs)  # 改动了cls变为A


b = B(10)

# 结果：
# into B __new__
# <class '__main__.B'>
# into A __new__
# <class '__main__.A'>