最新python面试题汇总(一)

最新推荐文章于 2023-01-25 18:32:59 发布

是阿采哦

最新推荐文章于 2023-01-25 18:32:59 发布

阅读量141

点赞数 1

分类专栏：面试题文章标签： python面试题 python语言特性

面试题专栏收录该内容

6 篇文章 0 订阅

订阅专栏

注：所有答案均为参考，并非标准，无需背诵。

资源来源于网络

1 Python的函数参数传递

看两个如下例子，分析运行结果:

代码一：

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

代码二：

a = []
def fun(a):
    a.append(1)
fun(a)
print(a)  # [1]

答案：所有的变量都可以理解是内存中一个对象的“引用”，或者，也可以看似c中void*的感觉。类型是属于对象的，而不是变量。而对象有两种,“可更改”（mutable）与“不可更改”（immutable）对象。在python中，strings, tuples, 和numbers是不可更改的对象，而list,dict等则是可以修改的对象。(这就是这个问题的重点)当一个引用传递给函数的时候,函数自动复制一份引用,这个函数里的引用和外边的引用没有关系了.第一个例子里函数把引用指向了一个不可变对象,当函数返回的时候,外面的引用无关。第二个例子函数内的引用指向的是可变对象,对它的操作就和定位了指针地址一样,在内存里进行修改.。

2 Python中的元类(metaclass)?

这个不是很常用，元类就是用来创建类的“东西”。你创建类就是为了创建类的实例对象，但是我们已经学习到了Python中的类也是对象。元类就是用来创建这些类（对象）的，元类就是类的类。

3 @staticmethod和@classmethod?

Python其实有3个方法,即静态方法(staticmethod),类方法(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()

答案：函数参数里面的self和cls是对类或者实例的绑定。对于实例方法,我们知道在类里每次定义方法的时候都需要绑定这个实例,就是foo(self, x),为什么要这么做呢?因为实例方法的调用离不开实例,我们需要把实例自己传给函数,调用的时候是这样的a.foo(x)(其实是foo(a, x)).类方法一样,只不过它传递的是类而不是实例。

对于静态方法其实和普通的方法一样,不需要对谁进行绑定,唯一的区别是调用的时候需要使用a.static_foo(x)或者A.static_foo(x)来调用.

——	实例方法	类方法	静态方法
a=A()	a.foo(x)	a.class_foo(x)	a.static_foo(x)
A	不可用	A.class_foo(x)	A.static_foo(x)

4 类变量和实例变量

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了.

5 Python自省？

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

6 字典推导式

可能你见过列表推导时,却没有见过字典推导式,在2.7中才加入的:

d = {key: value for (key, value) in iterable}

7 Python中单下划线和双下划线

 class MyClass():
      def __init__(self):
            self.__superprivate = "Hello"
            self._semiprivate = ", world!"
 
mc = MyClass()
print(mc.__superprivate)

运行结果：

Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: myClass instance has no attribute '__superprivate'

print(mc._semiprivate)

运行结果：

, world!

 print (mc.__dict__)

运行结果：

{'_MyClass__superprivate': 'Hello', '_semiprivate': ', world!'}

解释：__foo__:一种约定,Python内部的名字,用来区别其他用户自定义的命名,以防冲突.

_foo:一种约定,用来指定变量私有.程序员用来指定私有变量的一种方式.

__foo:这个有真正的意义:解析器用_classname__foo来代替这个名字,以区别和其他类相同的命名.

8 字符串格式化:%和.format？

答案：.format在许多方面看起来更便利.对于%最烦人的是它无法同时传递一个变量和元组.你可能会想下面的代码不会有什么问题:

"hi there %s" % name

但是,如果name恰好是(1,2,3),它将会抛出一个TypeError异常.为了保证它总是正确的,你必须这样做:

"hi there %s" % (name,)   # 提供一个单元素的数组而不是一个参数

9 迭代器和生成器

答案：在Python中，这种一边循环一边计算的机制，称为生成器：generator。

可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。

这个是stackoverflow里python排名第一的问题,值得一看: http://stackoverflow.com/questions/231767/what-does-the-yield-keyword-do-in-python

10 *args and **kwargs

用*args和**kwargs只是为了方便并没有强制使用它们.

当你不确定你的函数里将要传递多少参数时你可以用*args.例如,它可以传递任意数量的参数:

def print_everything(*args):
      for count, thing in enumerate(args):
           print '{0}. {1}'.format(count, thing)

print_everything('apple', 'banana', 'cabbage')

运行结果：

0. apple
1. banana
2. cabbage

相似的,**kwargs允许你使用没有事先定义的参数名:

def table_things(**kwargs):
    for name, value in kwargs.items():
         print ('{0} = {1}'.format(name, value))

table_things(apple = 'fruit', cabbage = 'vegetable')

运行结果：

cabbage = vegetable
apple = fruit

你也可以混着用.命名参数首先获得参数值然后所有的其他参数都传递给*args和**kwargs.命名参数在列表的最前端.例如:

def table_things(titlestring, **kwargs)

*args和**kwargs可以同时在函数的定义中,但是*args必须在**kwargs前面.

当调用函数时你也可以用*和**语法.例如:

def print_three_things(a, b, c):
    print ('a = {0}, b = {1}, c = {2}'.format(a,b,c))

mylist = ['aardvark', 'baboon', 'cat']
print_three_things(*mylist)

运行结果：

a = aardvark, b = baboon, c = cat

就像你看到的一样,它可以传递列表(或者元组)的每一项并把它们解包.注意必须与它们在函数里的参数相吻合.当然,你也可以在函数定义或者函数调用时用*.http://stackoverflow.com/questions/3394835/args-and-kwargs

11 面向切面编程AOP和装饰器

在运行时，动态地将代码切入到类的指定方法、指定位置上的编程思想就是面向切面的编程。是OOP编程的有效补充。

装饰器是一个很著名的设计模式，经常被用于有切面需求的场景，较为经典的有插入日志、性能测试、事务处理等。装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量函数中与函数功能本身无关的雷同代码并继续重用。概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能。

12 鸭子类型

“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。”

我们并不关心对象是什么类型，到底是不是鸭子，只关心行为。

比如在python中，有很多file-like的东西，比如StringIO,GzipFile,socket。它们有很多相同的方法，我们把它们当作文件使用。

又比如list.extend()方法中,我们并不关心它的参数是不是list,只要它是可迭代的,所以它的参数可以是list/tuple/dict/字符串/生成器等.鸭子类型在动态语言中经常使用，非常灵活，使得python不像java那样专门去弄一大堆的设计模式。

是阿采哦

关注

1
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
最新python面试题汇总(一)

注：所有答案均为参考，并非标准，无需背诵。资源来源于网络1 Python的函数参数传递看两个如下例子，分析运行结果:代码一：a = 1def fun(a): a = 2fun(a)print(a) # 1代码二：a = []def fun(a): a.append(1)fun(a)print(a) # [1]答案：所有的变量都...
复制链接

扫一扫