python复习

最新推荐文章于 2023-05-08 17:06:09 发布

iwtbs_kevin

最新推荐文章于 2023-05-08 17:06:09 发布

阅读量770

点赞数

分类专栏：面试其他

本文链接：https://blog.csdn.net/qq_34219959/article/details/104788395

版权

其他同时被 2 个专栏收录

14 篇文章 0 订阅

订阅专栏

面试

12 篇文章 3 订阅

订阅专栏

文章目录

装饰器是什么
python多线程的限制以及多进程中传递参数的方式
python多线程与多进程的区别
Python是如何进行内存管理的
Python里面如何拷贝一个对象？
字典如何删除键和合并字典
*args和**kwargs
__new__和 __int__的区别
and & or
zip 拉链函数
内置函数：map、reduce、filter
re的match和search区别
简述生成器、迭代器、可迭代对象以及应用场景？
面向对象的三大特性
面向对象中super的作用
什么是反射？以及应⽤用场景？

装饰器是什么

如何理解Python装饰器

装饰器是要把原来的函数装饰成新的函数，并且返回这个函数本身的高阶函数

python多线程的限制以及多进程中传递参数的方式

python多线程有个全局解释器锁（global interpreter lock），这个锁的意思是任一时间只能有一个线程使用解释器，跟单cpu跑多个程序一个意思，大家都是轮着用的，这叫“并发”，不是“并行”

多进程间共享数据，可以使用 multiprocessing.Value 和 multiprocessing.Array

python多线程与多进程的区别

在UNIX平台上，当某个进程终结之后，该进程需要被其父进程调用wait，否则进程成为僵尸进程(Zombie)。所以，有必要对每个Process对象调用join()方法 (实际上等同于wait)。对于多线程来说，由于只有一个进程，所以不存在此必要性

多进程应该避免共享资源。在多线程中，我们可以比较容易地共享资源，比如使用全局变量或者传递参数。在多进程情况下，由于每个进程有自己独立的内存空间，以上方法并不合适。此时我们可以通过共享内存和Manager的方法来共享资源。但这样做提高了程序的复杂度，并因为同步的需要而降低了程序的效率。

Python是如何进行内存管理的

Python引用了一个内存池机制，即Pymalloc机制(malloc:n.分配内存)，用于管理对小块内存的申请和释放
当创建大量消耗小内存的对象时，频繁调用new/malloc会导致大量的内存碎片，致使效率降低。内存池的概念就是预先在内存中申请一定数量的，大小相等的内存块留作备用，当有新的内存需求时，就先从内存池中分配内存给这个需求，不够了之后再申请新的内存。这样做最显著的优势就是能够减少内存碎片，提升效率。
python中的内存管理机制——Pymalloc：
　　python中的内存管理机制都有两套实现，一套是针对小对象，就是大小小于256bits时,pymalloc会在内存池中申请内存空间；当大于256bits，则会直接执行new/malloc的行为来申请内存空间。
　　关于释放内存方面，当一个对象的引用计数变为0时，python就会调用它的析构函数。在析构时，也采用了内存池机制，从内存池来的内存会被归还到内存池中，以避免频繁地释放动作。

Python里面如何拷贝一个对象？

Python提供了3种复制方法，最常见的=、copy.copy()、copy.deepcopy()

import copy
 
def fun(list):
    print(id(list))
    for li in list:
        print id(li),
 
if __name__ == '__main__':
    a = [x for x in range(5)]
    a.append({'name':'zhangsan', 'age':20})
    print id(a)
    for x in a:
        print id(x),
    print ''
    print '----------'
    fun(a)
    print ''
    print '----------'
    fun(copy.copy(a))
    print ''
    print '----------'
    fun(copy.deepcopy(a))

在这里插入图片描述

import copy
a = [1, 2, 3, 4, ['a', 'b']] 
 
b = a 
c = copy.copy(a) 
d = copy.deepcopy(a) 
 
a.append(5) 
a[4].append('c') 
 
print 'a = ', a
print 'b = ', b
print 'c = ', c
print 'd = ', d

输出结果

a =  [1, 2, 3, 4, ['a', 'b', 'c'], 5]
b =  [1, 2, 3, 4, ['a', 'b', 'c'], 5]
c =  [1, 2, 3, 4, ['a', 'b', 'c']]
d =  [1, 2, 3, 4, ['a', 'b']]

字典如何删除键和合并字典

在这里插入图片描述

*args和**kwargs

可变位置参数：
python中规定参数前带 * 的，称为可变位置参数，只是我们通常称这个可变位置参数为*args而已，叫其他的一样
*args：是一个元组，传入的参数会被放进元组里。
可变关键字参数：
同理，python中规定参数前带 ** 的，称为可变关键字参数，通常用**kwargs表示。
**kwargs：是一个字典，传入的参数以键值对的形式存放到字典里。

new和 int的区别

区别

__new__是在实例创建之前被调用的，因为它的任务就是创建实例然后返回该实例对象，是个静态方法。
__init__是当实例对象创建完成后被调用的，然后设置对象属性的一些初始值，通常用在初始化一个类实例的时候。是一个实例方法。
也就是： __new__先被调用，__init__后被调用，__new__的返回值（实例）将传递给__init__方法的第一个参数，然后__init__给这个实例设置一些参数

and & or

求结果：1 or 3
print(1 or 3) # 1
求结果：1 and 3
print(1 and 3) # 3
求结果：0 and 2 and 1
print(0 and 2 and 1) # 0
求结果：0 and 2 or 1
print(0 and 2 or 1) # 1
求结果：0 and 2 or 1 or 4
print(0 and 2 or 1 or 4) # 1
求结果：0 or Flase and 1
print(0 or False and 1) # Flase

总结：
　　# x or y 如果 x为真，则值为x，否则为y
　　# x and y 如果 x 为真，则值为 y，否则为 x

zip 拉链函数

将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表迭代器。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同

>>> print(list(zip([0,1,3],[5,6,7],['a','b'])))

[(0, 5, 'a'), (1, 6, 'b')]

>>> zipped = [(1, 4), (2, 5), (3, 6)]
>>> zip(*zipped)

[(1, 2, 3), (4, 5, 6)]

内置函数：map、reduce、filter

map：映射

>>> ret = map(abs,[-1,-5,6,-7])
>>> print(list(ret))
[1, 5, 6, 7]

reduce：过滤

def is_odd(x):
    if x>10:
        return True

>>> ret = filter(is_odd,[1,4,5,7,8,9,76])  # 为迭代器
>>> print(list(ret))

output:[76]

filter：对于序列内所有元素进行累计操作

from functools import reduce
def add(x,y):
    return x + y

>>> print(reduce(add,[1,2,3,4,5]))

output: 15

re的match和search区别

re.match：尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。
re.search：扫描整个字符串并返回第一个成功的匹配。

简述生成器、迭代器、可迭代对象以及应用场景？

迭代器
含有__iter__和__next__方法 (包含__next__方法的可迭代对象就是迭代器)
生成器
包括含有yield这个关键字，生成器也是迭代器，调动next把函数变成迭代器
可迭代对象
一个类内部实现__iter__方法且返回一个迭代器

面向对象的三大特性

继承

将多个类的共同属性和方法封装到一个父类下面，然后在用这些类来继承这个类的属性和方法

继承概念的实现方式主要有2类：实现继承、接口继承。

实现继承是指使用基类的属性和方法而无需额外编码的能力；
接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力(子类重构爹类方法)；

继承分为单继承和多继承，Python是支持多继承的
如果没有指定基类，python的类会默认继承object类，object是所有python类的基类，它提供了一些常见方法（如__str__）的实现

对象可以调用自己本类和父类的所有方法和属性，先调用自己的自己没有才调父类的。谁（对象）调用方法，方法中的self就指向谁

封装

将有共同的属性和方法封装到同一个类下面
第一层面：创建类和对象会分别创建二者的名称空间，我们只能用类名.或者obj.的方式去访问里面的名字，这本身就是一种封装
第二层面：类中把某些属性和方法隐藏起来(或者说定义成私有的)，只在类的内部使用、外部无法访问，或者留下少量接口（函数）供外部访问。

多态

Python天生是支持多态的。指的是基类的同一个方法在不同的派生类中有着不同的功能

面向对象中super的作用

什么是反射？以及应⽤用场景？

反射的核心本质就是以字符串的形式去导入个模块，利用字符串的形式去执行函数。

Django中的 CBV就是基于反射实现的。