python面试题

Posted 2020-10-15

目录：

• Python语言特性
• 1 Python的函数参数传递
  • 2 Python中的元类(metaclass)
  • 3 @staticmethod和@classmethod
  • 4 类变量和实例变量
  • 5 Python自省
  • 6 字典推导式
  • 7 Python中单下划线和双下划线
  • 8 字符串格式化:\\x和.format
  • 9 迭代器和生成器
  • 10 *args and **kwargs
  • 11 面向切面编程AOP和装饰器
  • 12 鸭子类型
  • 13 Python中重载
  • 14 新式类和旧式类
  • 15 __new__和init的区别
  • 16 单例模式
    • 1 使用__new__方法
    • 2 共享属性
    • 3 装饰器版本
    • 4 import方法
  • 17 Python中的作用域
  • 18 GIL线程全局锁
  • 19 协程
  • 20 闭包
  • 21 lambda函数
  • 22 Python函数式编程
  • 23 Python里的拷贝
  • 24 Python垃圾回收机制
    • 1 引用计数
    • 2 标记-清除机制
    • 3 分代技术
  • 25 Python的List
  • 26 Python的is
  • 27 read,readline和readlines
  • 28 Python2和3的区别
  • 29 super init
  • 30 range and xrange
• 操作系统
  • 1 select,poll和epoll
  • 2 调度算法
  • 3 死锁
  • 4 程序编译与链接
    • 1 预处理
    • 2 编译
    • 3 汇编
    • 4 链接
  • 5 静态链接和动态链接
  • 6 虚拟内存技术
  • 7 分页和分段
    • 分页与分段的主要区别
  • 8 页面置换算法
  • 9 边沿触发和水平触发
• 数据库
  • 1 事务
  • 2 数据库索引
  • 3 Redis原理
    • Redis是什么？
    • Redis数据库
    • Redis缺点
  • 4 乐观锁和悲观锁
  • 5 MVCC
    • mysql的innodb引擎是如何实现MVCC的
  • 6 MyISAM和InnoDB
• 网络
  • 1 三次握手
  • 2 四次挥手
  • 3 ARP协议
  • 4 urllib和urllib2的区别
  • 5 Post和Get
  • 6 Cookie和Session
  • 7 apache和nginx的区别
  • 8 网站用户密码保存
  • 9 HTTP和HTTPS
  • 10 XSRF和XSS
  • 11 幂等 Idempotence
  • 12 RESTful架构(SOAP,RPC)
  • 13 SOAP
  • 14 RPC
  • 15 CGI和WSGI
  • 16 中间人攻击
  • 17 c10k问题
  • 18 socket
  • 19 浏览器缓存
  • 20 HTTP1.0和HTTP1.1
  • 21 Ajax
• *NIX
  • unix进程间通信方式(IPC)
• 数据结构
  • 1 红黑树
• 编程题
  • 1 台阶问题/斐波那契
  • 2 变态台阶问题
  • 3 矩形覆盖
  • 4 杨氏矩阵查找
  • 5 去除列表中的重复元素
  • 6 链表成对调换
  • 7 创建字典的方法
    • 1 直接创建
    • 2 工厂方法
    • 3 fromkeys()方法
  • 8 合并两个有序列表
  • 9 交叉链表求交点
  • 10 二分查找
  • 11 快排
  • 12 找零问题
  • 13 广度遍历和深度遍历二叉树
  • 17 前中后序遍历
  • 18 求最大树深
  • 19 求两棵树是否相同
  • 20 前序中序求后序
  • 21 单链表逆置
  • 22 两个字符串是否是变位词
  • 23 动态规划问题

一、python语言特性

　　1.python的函数参数传递

　　　　函数参数时传值还是传引用？

# 不可变对象
a = 1
def fun(a):
    print("func_in",id(a))            # func_in 1868805184
    a = 2
    print( "re-point",id(a), id(2))   # re-point 1868805216 1868805216
print("func_out",id(a), id(1))        # func_out 1868805184 1868805184
fun(a)
print(a)                               # 1
# 不可变对象传值进去

# 可变对象
a = []
def fun(a):
    print("func_in", id(a))  # func_in 36683976
    a.append(1)
print("func_out",id(a))      # func_out 36683976
fun(a)
print(a)                     # [1]
# 可变对象传引用进去

　　这里记住的是类型是属于对象的，而不是变量。而对象有两种,“可更改”（mutable）与“不可更改”（immutable）对象。在python中，strings, tuples, 和numbers是不可更改的对象，而 list, dict, set 等则是可以修改的对象。(这就是这个问题的重点)

　　当一个引用传递给函数的时候,函数自动复制一份引用,这个函数里的引用和外边的引用没有半毛关系了.所以第一个例子里函数把引用指向了一个不可变对象,当函数返回的时候,外面的引用没半毛感觉.而第二个例子就不一样了,函数内的引用指向的是可变对象,对它的操作就和定位了指针地址一样,在内存里进行修改.

　　2.python中的元类（metaclass）

　　元类是一个类的类。就像一个类定义一个类的实例的行为一样，元类定义了一个类的行为。一个类是一个元类的一个实例。

　　

　　

　　在Python中，你可以为元类使用任意的可调用元素（比如Jerub显示），但更有用的方法实际上是使它成为一个实际的类本身。type是Python中通常的元类。如果你想知道，是的，type它本身就是一个阶级，而且是它自己的类型。你将无法像typePython 那样重新创建一些东西，但是Python会作弊。要在Python中创建自己的元类，你真的只想要子类type。

　　元类最常用作类工厂。就像通过调用类创建类的实例一样，Python通过调用元类来创建一个新的类（当它执行‘class‘语句时）。结合常规__init__和__new__方法，元类因此允许你在创建一个类的时候做“额外的事情”，比如用一些注册表来注册新类，或者甚至完全用别的东西替换类。

　　当class语句被执行时，Python首先class以正常的代码块的形式执行语句的主体。由此产生的命名空间（一个字典）保存待分类的属性。元类是通过查看将被类（元类继承的）的基类，要被类__metaclass__（如果有的话）或__metaclass__全局变量的属性来确定的。元类然后调用类的名称，基类和属性来实例化它。

　　然而，元类实际上定义了一个类的类型，而不仅仅是一个工厂，所以你可以做更多的事情。例如，您可以在元类上定义常规方法。这些元类方法就像类方法，因为它们可以在没有实例的情况下在类上调用，但是它们也不像类方法，因为它们不能在类的实例上调用。type.__subclasses__()是type元类的一个方法的一个例子。您还可以定义正常的“魔力”的方法，如__add__，__iter__和__getattr__，执行或更改类的行为。

　　详细链接：什么是元类？

　　[email protected]（静态方法）和@classmethod（类方法）

class A(object):
    # 普通方法
    def foo(self,x):
        print("executing foo(%s,%s)"%(self,x))
    # 类方法
    @classmethod
    def class_foo(cls,x):
        print("executing class_foo(%s,%s)"%(cls,x))
    # 静态方法
    @staticmethod
    def static_foo(x):
        print("executing static_foo(%s)"%x)

a=A()

　　对于实例a来说，实例a没有方法，它调用的是类A的方法，实例a只有定义def __init__(self)：后，创建自己的属性后，通过dir（a）可以看到自己拥有的属性；对于类方法来说传入的不是self参数，而是cls即类本身，实例a不能调用；对于静态方法来说，静态方法是类A的一个工具函数，相当于一个普通的外置函数，类A和实例a都可以调用。

 　　4.类变量和实例变量

　　类变量：

　　　　是可在类的所有实例之间共享的值（也就是说，它们不是单独分配给每个实例的）。例如下例中，num_of_instance 就是类变量，用于跟踪存在着多少个Test 的实例。

　　实例变量：

　　　　实例化之后，每个实例单独拥有的变量。

class Test(object):
    num_of_instance = 0
    def __init__(self, name):
        self.name = name
        Test.num_of_instance += 1

if __name__ == ‘__main__‘:
    print(Test.num_of_instance)         # 0
    t1 = Test(‘jack‘)
    print(Test.num_of_instance)         # 1
    t2 = Test(‘lucy‘)
    print(t1.name, t1.num_of_instance)  # jack 2
    print(t2.name, t2.num_of_instance)  # lucy 2

　　来一个例子：

class Person:
    name="aaa"

p1=Person()
p2=Person()
p1.name="bbb"
print(p1.name)      # bbb
print(p2.name)      # aaa
print(Person.name)  # aaa

　　这里p1.name="bbb"是实例调用了类变量,这其实和上面第一个问题一样,就是函数传参的问题,p1.name一开始是指向的类变量name="aaa",但是在实例的作用域里把类变量的引用改变了,就变成了一个实例变量,self.name不再引用Person的类变量name了.

　　再来一个例子：

class Person:
    name=[]

p1=Person()
p2=Person()
p1.name.append(1)
print(p1.name)      # [1]
print(p2.name)      # [1]
print(Person.name)  # [1]

　　这是为啥呢？因为只有是赋值操作才会给实例新建属性，现在是append操作，操作的是类中的name = [ ] 

　　5.python自省　　

　　这个也是python彪悍的特性.

　　自省就是面向对象的语言所写的程序在运行时,所能知道对象的类型.简单一句就是运行时能够获得对象的类型.比如type(),dir(),getattr(),hasattr(),isinstance().

　　

 

 

 

 

 

 

 

 

原文链接：面试题