2021-04-14面试常用问题

一. 迭代器

两个方法iter() 和 next()。
实列： 

list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
for x in it:
    print (x, end=" ")
输出结果：
1 2 3 4

实列2：

创建一个返回数字的迭代器，初始值为 1，逐步递增 1：

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self
 
  def __next__(self):
    x = self.a
    self.a += 1
    return x
 
myclass = MyNumbers()
myiter = iter(myclass)
 
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))

输出结果为：

1
2
3
4
5

二. 生成器。

生成器是一个返回迭代器的函数，只能用于迭代操作

使用 yield 实现斐波那契数列：

import sys
 
def fibonacci(n): # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n): 
            return
        yield a
        a, b = b, a + b
        counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成
 
while True:
    try:
        print (next(f), end=" ")
    except StopIteration:
        sys.exit()

输入结果为：

0 1 1 2 3 5 8 13 21 34 55

三.列表，集合，字典操作

集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。

如果要创建一个空集合，你必须用 set() 而不是 {} ；后者创建一个空的字典

构建字典：

>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'jack': 4098, 'guido': 4127}

方法	描述
list.append(x)	把一个元素添加到列表的结尾，相当于 a[len(a):] = [x]。
list.extend(L)	通过添加指定列表的所有元素来扩充列表，相当于 a[len(a):] = L。
list.insert(i, x)	在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引，例如 a.insert(0, x) 会插入到整个列表之前，而 a.insert(len(a), x) 相当于 a.append(x) 。
list.remove(x)	删除列表中值为 x 的第一个元素。如果没有这样的元素，就会返回一个错误。
list.pop([i])	从列表的指定位置移除元素，并将其返回。如果没有指定索引，a.pop()返回最后一个元素。元素随即从列表中被移除。（方法中 i 两边的方括号表示这个参数是可选的，而不是要求你输入一对方括号，你会经常在 Python 库参考手册中遇到这样的标记。）
list.clear()	移除列表中的所有项，等于del a[:]。
list.index(x)	返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误。
list.count(x)	返回 x 在列表中出现的次数。
list.sort()	对列表中的元素进行排序。
list.reverse()	倒排列表中的元素。
list.copy()	返回列表的浅复制，等于a[:]。

 1. 基本操作实例：

>>> a = [66.25, 333, 333, 1, 1234.5]
>>> print(a.count(333), a.count(66.25), a.count('x'))
2 1 0
>>> a.insert(2, -1)
>>> a.append(333)
>>> a
[66.25, 333, -1, 333, 1, 1234.5, 333]
>>> a.index(333)
1
>>> a.remove(333)
>>> a
[66.25, -1, 333, 1, 1234.5, 333]
>>> a.reverse()
>>> a
[333, 1234.5, 1, 333, -1, 66.25]
>>> a.sort()
>>> a
[-1, 1, 66.25, 333, 333, 1234.5]

 2.将列表当做堆栈使用

列表方法使得列表可以很方便的作为一个堆栈来使用，堆栈作为特定的数据结构，最先进入的元素最后一个被释放（后进先出）。用 append() 方法可以把一个元素添加到堆栈顶。用不指定索引的 pop() 方法可以把一个元素从堆栈顶释放出来。例如：

>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]

3. 矩阵转换

以下实例将3X4的矩阵列表转换为4X3列表：

matrix = [
    [1, 2, 3, 4],
   [5, 6, 7, 8],
   [9, 10, 11, 12]
]
print([[row[i] for row in matrix] for i in range(4)])
#输出结果为：[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]


#([[row[i] for row in matrix] for i in range(4)])等价于：

lis=[]
lis2=[]
for i in range(4):
    for row in matrix:
        lis.append(row[i])
    lis2.append(lis[0:3])
    lis.clear()
print(lis2)

 四：super（）：

继承父类：

1. 重写父类的函数

class A(object):
    def __init__(self):
        self.nameaa = 'aa'
    def funca(self):
        print('function funca' )
class B(A):
    def __init__(self):
        self.namebb = 'bb'
    def funcb(self):
        print('function funcb ' )
        
b = B() # 建立对象
print(b.funcb()) #调用子类的函数
print(b.funca()) # 调用父类的函数

 2. 调用出现错误：

class A(object):
    def __init__(self):
        self.nameaa = 'aa'
    def funca(self):
        print('function funca' )
class B(A):
    def __init__(self):
        self.namebb = 'bb'
    def funcb(self):
        A.funca()
        print('function funcb ' )

b = B() # 建立对象
print(b.funcb()) #调用子类的函数
print(b.funca()) # 调用父类的函数

3. 调用正确：

class A(object):
    def __init__(self):
        self.nameaa = 'aa'
    def funca(self):
        print('function funca' )
class B(A):
    def __init__(self):
        self.namebb = 'bb'
    def funcb(self):
        t=A()
        t.funca()
        print('function funcb ' )

b = B() # 建立对象
print(b.funcb()) #调用子类的函数
print(b.funca()) # 调用父类的函数

4.方便写法：

class A(object):
    def __init__(self):
        self.nameaa = 'aa'
    def funca(self):
        print('function funca' )
class B(A):
    def __init__(self):
        self.namebb = 'bb'
    def funcb(self):
        super().funca()
        print('function funcb ' )

b = B() # 建立对象
print(b.funcb()) #调用子类的函数
print(b.funca()) # 调用父类的函数

五：类。

• 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
• 方法：类中定义的函数。
• 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
• 数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
• 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
• 局部变量：定义在方法中的变量，只作用于当前实例的类。
• 实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
• 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
• 实例化：创建一个类的实例，类的具体对象。
• 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。
• 类的私有属性：__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。
• 类的私有方法：__private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类的外部调用。self.__private_methods。

 六：线程：

每个线程都有他自己的一组CPU寄存器，称为线程的上下文，该上下文反映了线程上次运行该线程的CPU寄存器的状态。

指令指针和堆栈指针寄存器是线程上下文中两个最重要的寄存器，线程总是在进程得到上下文中运行的，这些地址都用于标志拥有线程的进程地址空间中的内存。

线程可以分为:

• 内核线程：由操作系统内核创建和撤销。
• 用户线程：不需要内核支持而在用户程序中实现的线程。

• run(): 用以表示线程活动的方法。
• start():启动线程活动。
• join([time]): 等待至线程中止。这阻塞调用线程直至线程的join() 方法被调用中止-正常退出或者抛出未处理的异常-或者是可选的超时发生。
• isAlive(): 返回线程是否活动的。
• getName(): 返回线程名。
• setName(): 设置线程名。