[学校招聘-编程语言] Python问题摘要

任务，浅拷贝和深拷贝

Python的赋值语句b = a为对象提供别名b。此时，对b的操作会影响a。

In [1]: a = [1, 2, 3]
In [2]: b = a
In [3]: b.append(4)
In [4]: b
Out[4]: [1, 2, 3, 4]
In [5]: a
Out[5]: [1, 2, 3, 4]
In [6]: b[0] = 0
In [7]: b
Out[7]: [0, 2, 3, 4]
In [8]: a
Out[8]: [0, 2, 3, 4]

此处的副本是指要复制的对象的副本，而不是别名。

例如，下面的b = list（a）或b = copy.copy（a）是浅表副本。此时，向b中添加或删除元素对原始对象a无效，而更改通过浅表复制获得的对象的第0维对原始对象无效。

更改通过浅拷贝获得的对象的第0维之外的元素，可以更改原始对象。

In [9]: a = [1, 2, 3]
In [10]: b = list(a) # b = copy.copy()
In [11]: b.append(4)
In [12]: b
Out[12]: [1, 2, 3, 4]
In [13]: a
Out[13]: [1, 2, 3]
In [14]: b[0] = 0
In [15]: b
Out[15]: [0, 2, 3, 4]
In [16]: a
Out[16]: [1, 2, 3]
In [17]: a = [[1,2], [3, 4]]
In [18]: b = list(a)
In [19]: b[0][0] = 5
In [20]: b
Out[20]: [[5, 2], [3, 4]]
In [21]: a
Out[21]: [[5, 2], [3, 4]]

b = copy.deepcopy（a）是一个深层副本。通过深度复制获得的对象与原始对象无关，并且任何修改都不会影响原始对象。但是深层复制会占用更多空间，这是它的缺点。

是和==

在python中，is比较两个对象的内存地址，而==通过调用该类的__eq__函数进行比较。

python中的“不等于无”不能写“！= None”，但是“不是None”。原因如下：

在python中，None是一个单例对象。所有None存储器地址都相同，因此使用is是最准确的。如果使用==，则将根据特定的__eq__函数确定结果。那么为什么要使用数字比较==，因为数字的比较是数字本身是否相等，而不是比较内存地址，并且具有相同数字的两个对象可能具有不同的内存。

In [2]: class Student:
   ...:     def __eq__(self, other):
   ...:         return True
   ...:
In [3]: s = Student()
In [4]: s is None
Out[4]: False
In [5]: s == None
Out[5]: True   # 这里就和我们期望的不一样了，s不是None但是却返回True
In [6]: id(s)
Out[6]: 2636099000136
In [7]: id(None)
Out[7]: 1471456400

Python中pass，continue，break和exit（）之间的区别

通过：什么都不做，只是扮演一个占位符

继续：跳出此循环

休息：结束循环

exit（）：结束整个程序

Python的装饰器，迭代器和装饰器

装饰器本质上是一个函数，它允许其他函数在不进行任何代码更改的情况下添加其他函数。装饰器的返回值也可以是一个函数对象。简而言之，装饰器旨在为现有对象添加额外的功能。常见方案包括：插入日志，检查权限等。

迭代器

在Python中，一切都是对象。对象的抽象是一个类，而对象的集合是一个容器。迭代器是访问集合元素的一种方式。从集合的第一个元素访问迭代器对象，直到访问所有元素。迭代器只能前进，而不能后退。

对于诸如列表，字符串，元组，字典等容器对象，使用for循环进行遍历非常方便。在后台，for语句在容器对象上调用iter（）函数。 iter（）是python的内置函数。 iter（）函数返回一个迭代器对象，该对象定义了next（）方法，该方法一个接一个地访问容器中的元素。 next（）也是python的内置函数。如果没有后续元素，则next（）将抛出StopIteration异常，以通知for语句循环结束。

迭代器用于帮助我们记录每次迭代中访问的位置。当我们在迭代器上使用next（）函数时，迭代器将向我们返回记录位置的下一个位置的数据。实际上，当使用next（）函数时，将调用迭代器对象的__next__方法（在Python3中为对象的__next__方法，在Python2中为对象的next（）方法）。因此，如果要构造迭代器，则必须实现其__next__方法。但这还不够。 Python要求迭代器本身也是可迭代的，因此我们必须为迭代器实现__iter__方法，并且__iter__方法需要返回一个迭代器。迭代器本身就是一个迭代器，因此要进行迭代。设备的_iter_方法返回self。

Builder

功能：延迟操作。那是在需要时立即产生结果。

注意：

第一类：函数：仍然使用def定义函数，但是使用yield而不是return语句返回结果。 yield语句一次返回一个结果，在每个结果的中间，该函数的状态被挂起，以便它可以从下一次中断的地方继续执行。

第二种类型：表达式：与列表理解相似，不同之处在于将一对方括号[]转换为一对小括号（）。但是，表达式按需生成结果对象。要获取每个元素，您需要遍历它。

为什么使用发电机？因为效率。使用表达式而不是列表推导可以节省CPU和内存（RAM）。如果构造列表的目的只是将其传递给另一个函数，例如tuple（）或set（），请改用表达式！

迭代器是有限集，而可以是无限集。只需调用next（），就会根据计算结果自动生成新元素，然后返回。

Python下划线

Python中的不同下划线具有不同的含义。

class My_class:
    def __xxxxx(self):
        print(1)
print(dir(My_class))
# 输出的list里面有_Myclass__xxxxx，没有__xxxxx。

Python的自省功能

自省是使用面向对象的语言编写的程序在运行时可以知道的对象的类型，即可以在运行时获得的对象的类型。例如，type（），dir（），getattr（），hasattr（），isinstance（）和其他方法。

Python的多线程和多处理

多线程是多线程，而多进程是多处理。打开线程的成本小于打开一个进程的成本，并且更易于通信，但是多个进程更稳定。毕竟，如果线程崩溃，则整个进程将挂起，并且多个进程通常是独立的。

区别：

（1）一个进程可以包含多个线程，并且一个线程是该进程的实体。

（[2）线程共享内存空间；进程内存是独立的。

（3）同一进程的线程可以直接通信；如果两个进程要通信，则必须通过中间代理来实现。

（4）创建新线程很容易；创建新进程需要克隆其父进程。

（5）一个线程可以在同一进程中控制和操作其他线程；但是该进程只能操作子进程。

（6）更改主线程（例如优先级）可能会影响其他线程；更改父进程不会影响子进程。

垃圾收集机制

就python而言，主要使用通用引用计数机制，并结合了标记清除和世代收集这两种机制。 python中的所有内容都是一个对象，每个Python对象都有一个引用计数器，以记录有多少其他对象指向（引用）此对象。当引用计数变为0时，将回收该对象以释放内存空间。

引用计数方法具有明显的优势：

但是也有非常明显的缺点：

为了解决以上两个问题，python引入了两种GC机制：

函数传递参数

在C ++中，值传递，引用传递和地址传递之间是有区别的。

查看示例程序

Jack Stark：[学校招聘-编程语言] C ++问题摘要1

但是python中函数的参数传递与这三个不同。 Python的参数传递是通过赋值传递或通过对象引用传递。 python中的所有数据类型都是对象，因此在传递参数时，只需让新变量和原始变量指向同一对象，就不会进行值传递或引用传递。

将不可变对象作为参数传递给函数时，更改不可变对象不会更改原始对象的值。

def fun(a):
    a = 2
    return
a = 1
fun(a)
print(a) # 1

将变量对象作为参数传递给函数时，更改变量对象的值将影响指向它的所有变量。

def fun(a):
    a[0] = 2
    return
a = [0]
fun(a)
print(a) # [2]

但是，如果将一个列表传递给该函数，并将int类型分配给该函数中的列表，则它只会在函数中创建一个新对象，而不会影响原始变量对象的值。

def fun(a):
    a = 2
    return
a = [0]
fun(a)
print(a) # [0]

python函数参数中的

* args和** kwargs

*它不是像C ++这样的python中的取消引用功能。

* args表示传入的args是元组，长度不确定。

def fun(*args):
    print(type(args))
    for val in args:
        print(val)
fun(1)
fun(1,2,3)
# 输出结果如下
# 
# 1
# 
# 1
# 2
# 3

** kwargs表示传入的kwargs是字典，长度不确定。

def fun(**kwargs):
    print(type(kwargs))
    for key in kwargs:
        print(key, kwargs[key])
fun(a=1,b=2,c=3)
# 输出结果如下
# 
# a 1
# b 2
# c 3

Python中列表和元组的内部实现

list的源代码包括listobject.h和listobject.c。

可以看出，该列表实质上是一个过度分配的数组。其中，ob_item是一个指针列表，并且其中的每个指针都指向该列表的一个元素。已分配存储为此列表分配的空间量。

值得注意的是，分配的实际空间大小与列表不一定相同。列表的实际空间大小是指len（list）返回的结果，即源代码注释中的ob_size，它指示列表中存储了多少个元素。实际上，为了优化存储结构并避免每次添加元素时都需要重新分配内存，分配给该列表的预分配空间通常大于ob_size。

因此，分配的> = len（list）= ob_size。

如果为当前列表分配的空间已满（即，已分配== len（list）），它将从系统请求更多内存空间并复制所有原始元素。每次列表遵循以下模式时分配的空间大小：

0, 4, 8, 16, 25, 35, 46, 58, 72, 88, ...

元组的源代码是tupleobject.h和tupleobject.c。

元组类似于列表，本质上是一个数组，但是空间的大小是固定的。 Python中的元组进行了许多优化，以提高程序的效率。例如，当一个元组的大小不超过20时，Python会将其缓存在内部空闲列表中。如果将来需要创建相同的元组，则可以直接从缓存中加载Python，从而提高了程序的效率。

参考资料：

Jing Xiao，列表和元组的内部实现是什么？

本文来自电脑杂谈，转载请注明本文网址：
http://www.pc-fly.com/a/shoujiruanjian/article-318386-1.html