欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

面试准备之Python篇

程序员文章站 2024-02-12 17:33:04
...

1 单引号,双引号,三引号的区别

题目:分别阐述3种引号用的场景和区别

1. 单引号和双引号主要用来表示字符串

比如:
单引号:'python'
双引号:"python"

2. 三引号

三单引号:'''python ''',也可以表示字符串一般用来输入多行文本,或者用于大段的注释
三双引号:"""python""",一般用在类里面,用来注释类,这样省的写文档,直接用类的对象__doc__访问获得文档

区别:

若你的字符串里面本身包含单引号,必须用双引号
比如:"can't find the log\n"

2 Python的函数参数传递

题目:举例说明Python函数参数传递的几种形式,并说明函数传参是值传递还是引用传递

1. Python的参数传递有:

  • 位置参数
  • 默认参数
  • 可变参数
  • 关键字参数

2. 函数的传值到底是值传递还是引用传递,要分情况:

  • 不可变参数用值传递:
    像整数和字符串这样的不可变对象,是通过拷贝进行传递的,因为你无论如何都不可能在原处改变不可变对象
  • 可变参数用引用传递:
    比如像列表,字典这样的对象是通过引用传递,和C语言里面的用指针传递数组很相似,可变对象能在函数内部改变.

3. 具体例子:

#整数为不可变对象,用值传递
a = 1
def fun(a):
    a = 2
fun(a)
print a  # 1

#列表为可变对象,用引用传递
a = []
def fun(a):
    a.append(1)
fun(a)
print a  # [1]

3 lambda函数

题目:举例说明lambda的用法,并说明用lambda的优点

1. lambda的用法

lambda是匿名函数,用法如下: lambda x,y : x+y, 冒号前的x,y为自变量,冒号后x+y为具体运算。

2. lambda的优点:

lambda能和def做同样种类的工作,特别是对于那些逻辑简单的函数,直接用lambda会更简洁,而且省去取函数名的麻烦(给函数取名是个技术活)

4 字符串格式化:%和.format的区别

题目:说明字符串格式化方法%和.format的区别

1. 字符串格式化: .format
字符串的format函数非常灵活,很强大,可以接受的参数不限个数,并且位置可以不按顺序,而且有较为强大的格式限定符(比如:填充,对齐,精度等)

具体用法如下,字符串中花括号 {} 的部分会被format传入的参数替代,传入的值可以是字符串,也可以是数字或者别的对象。

>>> '{} {} {}'.format('a', 'b', 'c')
'a b c'

可以用数字指定传入参数的相对位置:

>>> '{2} {1} {0}'.format('a', 'b', 'c')
'c b a'

还可以指定传入参数的名称:

>>> '{color} {n} {x}'.format(n=10, x=1.5, color='blue')
'blue 10 1.5'

可以在一起混用:

>>> '{color} {0} {x} {1}'.format(10, 'foo', x = 1.5, color='blue')
'blue 10 1.5 foo'

可以用{<field name>:<format>}指定格式:

>>> from math import pi
>>> '{0:10} {1:10d} {2:10.2f}'.format('foo', 5, 2 * pi)
'foo                 5       6.28'

2. 字符串格式化: %
旧式的 % 方法进行格式化,具体规则与C中相同。

>>> s = "some numbers:"
>>> x = 1.34
>>> y = 2
>>> # 用百分号隔开,括号括起来
... t = "%s %f, %d" % (s, x, y)
>>> t
'some numbers: 1.340000, 2'

5 写函数: 输入一个字符串, 返回倒序排列的结果

题目:输入: string_reverse(‘abcdef’), 返回: ‘fedcba’,写出你能想到的多种方法

1. 利用字符串本身的翻转

def string_reverse1(text='abcdef'):
    return text[::-1]

2. 把字符串变成列表,用列表的reverse函数

def string_reverse2(text='abcdef'):
    lst = list(text)
    lst.reverse()
    return ''.join(lst)

3. 新建一个列表,从后往前取

def string_reverse3(text='abcdef'):
    lst = []
    for i in range(len(text)-1, -1, -1):
        lst.append(text[i])
    return ''.join(lst)

4. 利用双向列表deque中的extendleft函数

from collections import deque

def string_reverse4(text='abcdef'):
    d = deque()
    d.extendleft(text)
    return ''.join(d)

5. 递归

def string_reverse5(text='abcdef'):
    if len(text) <= 1:
        return text
    else:
        return string_reverse5(text[1:])+text[0]

6 按升序合并两个list, 并去除重复的元素

题目:按升序合并如下两个list, 并去除重复的元素
list1 = [2, 3, 8, 4, 9, 5, 6]
list2 = [5, 6, 10, 17, 11, 2]

1. 用set方法(最简单)

list3 = list1 + list2
print(sorted(list(set(list3))))

2. 递归方法(略)

7 Pythonic的代码

题目:写出你认为最Pythonic的代码

Pythonic编程风格是Python追求的一种风格,精髓就是追求直观,简洁而容易读.

1. 交互变量

  • 非pythonic
temp = a
a = b
b = temp
  • pythonic
a, b = b, a


2. 判断其值真假

name = 'Tim'
langs = ['AS3', 'Lua', 'C']
info = {'name': 'Tim', 'sex': 'Male', 'age':23 }
  • 非pythonic
if name != '' and len(langs)>0 and info !={}:
    print('All True!')
  • pythonic
if name and langs and info:
    print('All True!')


3. 列表推导式

[x for x in range(1,100) if x%2==0]


4. zip创建键值对

keys = ['Name', 'Sex', 'Age']
values = ['Jack', 'Male', 23]
dict(zip(keys,values))

8 range 和 xrange

题目:说明range和xrange的区别

xrange用法与 range 都在循环时使用且用法相同,所不同的是xrange生成的不是一个list对象,而是一个生成器。因此要生成很大的数字序列的时候,用xrange会比range性能优很多,因为不需要一上来就开辟一块很大的内存空间。

9 迭代器和生成器

题目:将列表生成式中[]改成() 之后数据结构是否改变

答:是,从列表变为生成器。

通过列表生成式,可以直接创建一个列表。但是,受到内存限制,列表容量肯定是有限的。而且,创建一个包含百万元素的列表,不仅是占用很大的内存空间,如:我们只需要访问前面的几个元素,后面大部分元素所占的空间都是浪费的。因此,没有必要创建完整的列表(节省大量内存空间)。在Python中,我们可以采用生成器:边循环,边计算的机制—>generator

10 *args 和 **kwargs

题目:说明*args 和 **kwargs的使用

1. *args 的使用

当你不确定你的函数里将要传递多少参数时你可以用*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

2. **kwargs 的使用

**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

3. 其他

  • *args和**kwargs可以同时在函数的定义中,但是*args必须在**kwargs前面.
  • 任何函数都可以用 universal_func(*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
"""

11 Python垃圾回收机制

题目:描述Python的垃圾回收机制

Python GC主要使用引用计数(reference counting)来跟踪和回收垃圾。在引用计数的基础上,通过“标记-清除”(mark and sweep)解决容器对象可能产生的循环引用问题,通过“分代回收”(generation collection)以空间换时间的方法提高垃圾回收效率。

1. 引用计数

PyObject是每个对象必有的内容,其中ob_refcnt就是做为引用计数。当一个对象有新的引用时,它的ob_refcnt就会增加,当引用它的对象被删除,它的ob_refcnt就会减少.引用计数为0时,该对象生命就结束了。

  • 优点:简单、实时
  • 缺点:维护引用计数消耗资源、循环引用

2. 标记-清除机制

基本思路是先按需分配,等到没有空闲内存的时候从寄存器和程序栈上的引用出发,遍历以对象为节点、以引用为边构成的图,把所有可以访问到的对象打上标记,然后清扫一遍内存空间,把所有没标记的对象释放。

3. 分代回收

分代回收的整体思想是:将系统中的所有内存块根据其存活时间划分为不同的集合,每个集合就成为一个“代”,垃圾收集频率随着“代”的存活时间的增大而减小,存活时间通常利用经过几次垃圾回收来度量。

Python默认定义了三代对象集合,索引数越大,对象存活时间越长。
举例: 当某些内存块M经过了3次垃圾收集的清洗之后还存活时,我们就将内存块M划到一个集合A中去,而新分配的内存都划分到集合B中去。当垃圾收集开始工作时,大多数情况都只对集合B进行垃圾回收,而对集合A进行垃圾回收要隔相当长一段时间后才进行,这就使得垃圾收集机制需要处理的内存少了,效率自然就提高了。在这个过程中,集合B中的某些内存块由于存活时间长而会被转移到集合A中,当然,集合A中实际上也存在一些垃圾,这些垃圾的回收会因为这种分代的机制而被延迟。

转载于:https://www.jianshu.com/p/ed956ca05a48