Python常见面试题的详解3

1. 类和对象的区别、对象访问类的方法、创建对象时的操作

• 类和对象的区别：类是一种抽象的概念，它定义了一组具有相同属性和方法的对象的蓝图或模板。而对象是类的具体实例，是根据类创建出来的实体，每个对象都有自己独立的状态（属性值）。
• 对象访问类的方法：对象可以通过点号（.）来访问类中定义的方法。
• 创建对象时的操作：当创建一个对象时，Python 会为对象分配内存空间，然后调用类的 __init__ 方法（如果存在）来初始化对象的属性。

python

class MyClass:
    def __init__(self, value):
        self.value = value

    def print_value(self):
        print(self.value)

# 创建对象
obj = MyClass(10)
# 对象访问类的方法
obj.print_value()

2. 分组一个 list 里面的元素

python

def group_list(lst, group_size):
    return [lst[i:i+group_size] for i in range(0, len(lst), group_size)]

lst = list(range(1, 101))
result = group_list(lst, 3)
print(result)

3. 删除一个 list 里面的重复元素

python

lst = [1, 2, 2, 3, 4, 4, 5]
unique_lst = list(set(lst))
print(unique_lst)

4. 遍历目录与子目录，抓取.pyc 文件

python

import os

def find_pyc_files(root_dir):
    pyc_files = []
    for root, dirs, files in os.walk(root_dir):
        for file in files:
            if file.endswith('.pyc'):
                pyc_files.append(os.path.join(root, file))
    return pyc_files

root_directory = '.'  # 当前目录
pyc_files = find_pyc_files(root_directory)
print(pyc_files)

5. 生成含有 n 个元素值为 1~n 的数组，元素顺序随机，但值不重复

python

import random

def generate_random_array(n):
    arr = list(range(1, n + 1))
    random.shuffle(arr)
    return arr

n = 10
random_arr = generate_random_array(n)
print(random_arr)

6. 在不用其他变量的情况下，交换 a、b 变量的值

python

a = 5
b = 10
a, b = b, a
print(f"a = {a}, b = {b}")

7. 在一个 function 里设置一个全局变量

python

global_var = 0

def set_global_variable():
    global global_var
    global_var = 10

set_global_variable()
print(global_var)

8.写出下面代码的运行结果

python

def extendList(val, list=[]):

    list.append(val)

    return list

list1 = extendList(11)

list2 = extendList(111, ['a','b','c'])

list3 = extendList('a')

print "list1 = %s" % list1

print "list2 = %s" % list2

print "list3 = %s" % list3

以下代码的输出结果为：

python

list1 = [11, 'a']
list2 = ['a', 'b', 'c', 111]
list3 = [11, 'a']

关键分析：

1. 默认参数的陷阱
   Python 中函数的默认参数（如 list=[]）在函数定义时仅初始化一次，而非每次调用都新建。因此，多次调用函数且未显式传递 list 参数时，会共享同一个默认列表。

2. 执行过程

   • list1 = extendList(11)
     未传递 list 参数，使用默认的空列表 []。
     添加 11 后，默认列表变为 [11]，list1 指向该列表。

   • list2 = extendList(111, ['a','b','c'])
     显式传递新列表 ['a','b','c']，与默认列表无关。
     添加 123 后，返回 ['a','b','c', 111]，list2 独立。

   • list3 = extendList('a')
     再次使用默认列表（此时已为 [11]）。
     添加 'a' 后，默认列表变为 [11, 'a']，list1 和 list3 均指向此列表。

3. 最终表现

   • list1 和 list3 共享被修改后的默认列表，因此内容相同。

   • list2 因显式传递参数而独立。

总结：

Python 中若默认参数为可变对象（如列表），多次调用会导致共享同一对象。

解决方案：

将默认参数设为不可变对象（如 None），在函数内初始化可变对象。
例如：

python

def extendList(val, list=None):
    if list is None:
        list = []
    list.append(val)
    return list