Python基础知识点总结3

十一、魔法方法

1. type生成类调用顺序

 __new__  :  先于__init__方法，每生成一个实例执行一次，__new__ 类方法创建实例对象

 __init__   :  __init__方法每生成一个实例就会执行一次，初始化实例对象

__call__  :   后与__init__方法，C()() 使用类再加一个括号调用， C为类名称

__del__   :   析构方法，删除无用的内存对象（当程序结束会自动自行析构方法）

2. 类实例化时魔法方法调用顺序

class Student(object):

    def __new__(cls, *args, **kwargs):

        print('__new__')

        return object.__new__(cls)   # 必须返回父类的__new__方法，否则不不执行__init__方法，无法创建实例



    def __init__(self,name):

        print('__init__')

        self.name = name



    def __str__(self):                # 作用：打印实例时显示指定字符串，而不是内存地址

        print('__str__')

        return self.name



    def __call__(self, *args, **kwargs):        # 当执行C()(*args) 或者 s1(*args) 就会执行__call__

        print('__call__',*args)



    def __del__(self):                # 作用：清除无用的实例对内存的暂用

        print('__del__')



#1、实例化时机会执行__new__、__init__

s1 = Student('tom')



#2、执行 实例()  就会执行__call__ 方法，并将参数传递给__call__函数

s1('call01')



#3、当打印实例时就会执行 __str__ 方法下返回的字符串（默认返回的实例地址）

print(s1)

#4、析构方法：当删除实例时就会调用 __del__ 方法

del s1

# 析构方法作用：在程序结束后会自动执行析构方法删除所有实例

# 但是在程序运行时有很多实例是无用的，但是python内存回收机制却不会自动删除他们，这样就浪费内存

# 我们可以执行 del s1 ，那么在程序运行时，python内存回收机制会检测到这些实例时无用的，才会删除

# 其实我们执行del s1，并没有回收内存，只不过是摘除门牌号，python内存回收机制发现没有门牌号后会自动回收内存

十二、深浅拷贝

1. 预备知识一——python的变量及其存储

1. python的一切变量都是对象，变量的存储，采用了引用语义的方式，存储的只是一个变量的值所在的内存地址，而不是这个变量的只本身

2. 不管多么复杂的数据结构，浅拷贝都只会copy一层。

理解：两个人公用一张桌子，只要桌子不变，桌子上的菜发生了变化两个人是共同感受的。

2. 浅copy与deepcopy

1. 浅copy：  不管多么复杂的数据结构，浅拷贝都只会copy一层

2. deepcopy :  深拷贝会完全复制原变量相关的所有数据，在内存中生成一套完全一样的内容，我们对这两个变量中任意一个修改都不会影响其他变量

import copy

sourceList = [1,2,3,[4,5,6]]

copyList = copy.copy(sourceList)

deepcopyList = copy.deepcopy(sourceList)



sourceList[3][0]=100



print(sourceList)           # [1, 2, 3, [100, 5, 6]]

print(copyList)             # [1, 2, 3, [100, 5, 6]]

print(deepcopyList)         # [1, 2, 3, [4, 5, 6]]

十三、上下文管理

1. 什么是with语句

1. with是一种上下文管理协议，目的在于从流程图中把 try,except 和finally 关键字和资源分配释放相关代码统统去掉，简化try….except….finlally的处理流程。

2. 所以使用with处理的对象必须有enter()和exit()这两个方法

1）with通过enter方法初始化（enter方法在语句体执行之前进入运行）

2）然后在exit中做善后以及处理异常（exit()方法在语句体执行完毕退出后运行）

2. with语句使用场景

1. with 语句适用于对资源进行访问的场合，确保不管使用过程中是否发生异常都会执行必要的“清理”操作，释放资源

2. 比如文件使用后自动关闭、线程中锁的自动获取和释放等。

3.with处理文件操作的实例

with open('/etc/passwd') as f:

    for line in f:

        print(line)

# 这段代码的作用：打开一个文件，如果一切正常，把文件对象赋值给f，然后用迭代器遍历文件中每一行，当完成时，关闭文件；

# 而无论在这段代码的任何地方，如果发生异常，此时文件仍会被关闭。

十四、 高阶函数

1. lambda基本使用

1. lambda只是一个表达式，函数体比def简单很多。

2. lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。

3. lambda表达式是起到一个函数速写的作用。允许在代码内嵌入一个函数的定义。

4. 格式：lambda的一般形式是关键字lambda后面跟一个或多个参数，紧跟一个冒号，之后是一个表达式。

f = lambda x,y,z:x+y+z

print(f(1,2,3))                    # 6



my_lambda = lambda arg : arg + 1

print(my_lambda(10))                # 11

2. 三元运算

1. 三元运算格式：  result=值1 if x<y else 值2    if条件成立result=1,否则result=2

2. 作用：三元运算，又称三目运算，主要作用是减少代码量，是对简单的条件语句的缩写

name = 'Tom' if 1 == 1 else 'fly'

print(name)

# 运行结果： Tom



f = lambda x:x if x % 2 != 0 else x + 100

print(f(10))                    # 110

3. filter()函数可以对序列做过滤处理

利用 filter、lambda表达式 获取l1中元素小于33的所有元素 l1 = [11, 22, 33, 44, 55]

l1= [11,22,33,44,55]

a = filter(lambda x: x<33, l1)

print(list(a))

4. Map是对序列根据设定条件进行操作后返回他设置的是操作方法

 利用map，lambda表达式将所有偶数元素加100

l1= [11,22,33,44,55]

ret = map(lambda x:x if x % 2 != 0 else x + 100,l1)

print(list(ret))

# 运行结果： [11, 122, 33, 144, 55]

5. reduce函数

使用reduce进行求和运算

1. reduce()函数即为化简函数，它的执行过程为：每一次迭代，都将上一次的迭代结果与下一个元素一同传入二元func函数中去执行。

2. 在reduce()函数中，init是可选的，如果指定，则作为第一次迭代的第一个元素使用，如果没有指定，就取seq中的第一个元素。

from functools import reduce

def f(x, y):

 return x + y



print(reduce(f, [1, 3, 5, 7, 9]))  # 25

# 1、先计算头两个元素：f(1, 3)，结果为4；

# 2、再把结果和第3个元素计算：f(4, 5)，结果为9；

# 3、再把结果和第4个元素计算：f(9, 7)，结果为16；

# 4、再把结果和第5个元素计算：f(16, 9)，结果为25；

# 5、由于没有更多的元素了，计算结束，返回结果25。

print( reduce(lambda x, y: x + y, [1, 3, 5, 7, 9])  )  # 25

6. sorted函数

sorted对字典排序

d = {'k1':1, 'k3': 3, 'k2':2}

# d.items() = [('k1', 1), ('k3', 3), ('k2', 2)]

a = sorted(d.items(), key=lambda x: x[1])

print(a)            # [('k1', 1), ('k2', 2), ('k3', 3)]