谷歌程序员14个Python面试题

于 2024-04-24 11:04:58 发布
阅读量479 收藏 8
点赞数 7
文章标签： python windows 开发语言 pycharm 人工智能 爬虫
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2402_84205067/article/details/138152899
版权

1.请解释Python中的列表推导式。

original_list = [1, 2, 3, 4, 5]
squared_list = [x**2 for x in original_list]
print(squared_list)

2.在Python中，如何实现类的继承，并重写父类的方法？

#定义父类
class Animal:
    def make_sound(self):
        print("动物发出了声音")

#定义子类继承自父类
class Dog(Animal):
    def make_sound(self):
        print("汪汪汪！")

#创建父类实例
animal = Animal()
#调用父类方法
animal.make_sound()

#创建子类实例
dog = Dog()
#调用子类方法，会重写父类的方法
dog.make_sound()

3.Python中的异常处理是如何工作的?

def divide(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        print("错误：不允许除以零。")
    except TypeError:
        print("错误：两个操作数必须是数字。")

print(divide(10, 2))  #输出: 5.0
print(divide(10, 0))  #输出: 错误：不允许除以零。
print(divide('10', 2))  #输出: 错误：两个操作数必须是数字。

4.解释一下Python中的迭代器和生成器

#生成器表达式示例
gen = (x**2 for x in range(5))

#打印生成器中的元素
for num in gen:
    print(num)

5.在Python中，如何使用*args和**kwargs参数？

def example_function(*args, **kwargs):
    print("位置参数 (*args):")
    for arg in args:
        print(arg)
    
    print("\n关键字参数 (**kwargs):")
    for key, value in kwargs.items():
        print(f"{key}: {value}")

example_function(1, 2, 3, name='Alice', age=30)

6.请解释什么是Python中的上下文管理器

class MyContextManager:
    def __enter__(self):
        print("进入上下文")
        # 在这里执行一些初始化操作
        return self  # 返回对象本身或者其他需要返回的值

    def __exit__(self, exc_type, exc_value, traceback):
        print("离开上下文")
        # 在这里执行一些清理操作
        if exc_type is not None:
            print(f"出现异常: {exc_type}, {exc_value}")

# 使用with语句调用上下文管理器
with MyContextManager() as obj:
    # 在这个代码块中可以使用由上下文管理器返回的对象
    print("在上下文中执行一些操作")
    # 如果在这个代码块中发生了异常，异常会被传递到__exit__方法中

7.解释一下Python中的深拷贝和浅拷贝的区别


import copy
#原始列表
original_list = [1, 2, [3, 4]]
#浅拷贝
shallow_copied_list = copy.copy(original_list)
#深拷贝
deep_copied_list = copy.deepcopy(original_list)
#修改原始列表的子对象
original_list[2][0] = 999
#输出浅拷贝后的列表
print("浅拷贝后的列表：", shallow_copied_list)  # 输出：[1, 2, [999, 4]]
#输出深拷贝后的列表
print("深拷贝后的列表：", deep_copied_list)  # 输出：[1, 2, [3, 4]]

‍

8.在Python中，如何实现单例模式？


#使用装饰器实现单例模式
def singleton(cls):
    instances = {}
    def get_instance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return get_instance

@singleton
class SingletonClass:
    def __init__(self, name):
        self.name = name

# 创建单例对象
singleton_obj1 = SingletonClass("Instance 1")
singleton_obj2 = SingletonClass("Instance 2")

print(singleton_obj1 is singleton_obj2)  #输出：True

#方法2
#使用元类实现单例模式
class SingletonMeta(type):
    _instances = {}

    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(SingletonMeta, cls).__call__(*args, **kwargs)
        return cls._instances[cls]

class SingletonClass(metaclass=SingletonMeta):
    def __init__(self, name):
        self.name = name

# 创建单例对象
singleton_obj1 = SingletonClass("Instance 1")
singleton_obj2 = SingletonClass("Instance 2")

print(singleton_obj1 is singleton_obj2)  #输出：True

9.请解释Python中的元类？

class DebugMeta(type):
    def __new__(cls, name, bases, attrs):
        print(f"Creating class: {name}")
        print(f"Bases: {bases}")
        print(f"Attributes:")
        for attr, value in attrs.items():
            print(f" - {attr}: {value}")
        return super().__new__(cls, name, bases, attrs)

class MyClass(metaclass=DebugMeta):
    static_var = "static variable"
    
    def __init__(self, x):
        self.x = x
    
    def method(self):
        pass

# 输出:
# Creating class: MyClass
# Bases: ()
# Attributes:
#  - static_var: static variable
#  - __init__: <function MyClass.__init__ at 0x7f95d43ab3a0>
#  - method: <function MyClass.method at 0x7f95d43ab430>

10.请简述Python中的闭包？

def outer_function(x):
    def inner_function(y):
        return x + y
    return inner_function

closure = outer_function(5)
result = closure(3)
print(result)  #输出：8

11.在Python中，如何使用模块functools中的lru_cache装饰器优化函数性能？


from functools import lru_cache

@lru_cache(maxsize=None)  #使用 lru_cache 装饰器，maxsize=None 表示缓存不限大小
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

#第一次调用 fibonacci 函数会进行计算
print(fibonacci(10))
#第二次调用同样的参数，结果会直接从缓存中获取，无需重新计算
print(fibonacci(10))

12.在Python中，如何实现多进程编程？


from multiprocessing import Process

def worker(num):
    """子进程要执行的任务"""
    print(f"Worker: {num}")

if __name__ == "__main__":
    #存储即将创建的子进程
    processes = []

    #创建5个子进程，每个子进程执行worker函数，传入不同的参数
    for i in range(5):
        p = Process(target=worker, args=(i,))
        processes.append(p)
        p.start()

    #等待所有子进程执行完毕
    for process in processes:
        process.join()

13.请解释Python中的面向对象编程中的封装、继承和多态？


#封装：通过类的内部方法来操作私有属性，隐藏对象的内部细节
class Car:
    def __init__(self, brand, model):
        self.__brand = brand  #私有属性
        self.__model = model

    def get_brand(self):  #公共方法，用于获取品牌信息
        return self.__brand

    def drive(self):  #公共方法，用于驾驶汽车
        print(f"Driving the {self.__brand} {self.__model}")

#继承：子类继承父类的属性和方法，并可以添加自己的属性和方法
class ElectricCar(Car):
    def __init__(self, brand, model, battery_size):
        super().__init__(brand, model)
        self.battery_size = battery_size

    def charge(self):  #子类独有的方法
        print(f"Charging the {self.get_brand()} {self._Car__model}")

    def drive(self):  #重写父类方法
        print(f"Driving the {self.get_brand()} {self._Car__model} silently") 

#多态：不同子类对象对同一方法有着不同的实现方式
def test_drive(car):
    car.drive()

#创建Car对象并调用drive方法
car1 = Car("Toyota", "Corolla")
car1.drive()

#创建ElectricCar对象并调用drive方法
electric_car = ElectricCar("Tesla", "Model S", 75)
test_drive(electric_car)

14.一个类可以从已有的类派生出新的类，新类继承了原有类的属性和方法


#定义父类 Vehicle
class Vehicle:
    def __init__(self, brand, model):
        self.brand = brand
        self.model = model

    def drive(self):
        print(f"Driving the {self.brand} {self.model}")

#定义子类 Car 继承自 Vehicle
class Car(Vehicle):
    def __init__(self, brand, model, color):
        super().__init__(brand, model)  # 调用父类的初始化方法
        self.color = color

    def honk(self):
        print("Beep beep!")

#创建 Car 对象并调用方法
my_car = Car("Toyota", "Corolla", "blue")
print(my_car.brand)  #访问父类的属性
print(my_car.color)  #访问子类的属性
my_car.drive()       #调用继承自父类的方法
my_car.honk()        #调用子类自己的方法

关于Python学习指南

学好 Python 不论是就业还是做副业赚钱都不错，但要学会 Python 还是要有一个学习规划。最后给大家分享一份全套的 Python 学习资料，给那些想学习 Python 的小伙伴们一点帮助！

包括：Python激活码+安装包、Python web开发，Python爬虫，Python数据分析，人工智能、自动化办公等学习教程。带你从零基础系统性的学好Python！

👉Python所有方向的学习路线👈

Python所有方向路线就是把Python常用的技术点做整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。（全套教程文末领取）

在这里插入图片描述

👉Python学习视频600合集👈

观看零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。

在这里插入图片描述

温馨提示：篇幅有限，已打包文件夹，获取方式在：文末

👉Python70个实战练手案例&源码👈

光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。

在这里插入图片描述

👉Python大厂面试资料👈

我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。

在这里插入图片描述

在这里插入图片描述

👉Python副业兼职路线&方法👈

学好 Python 不论是就业还是做副业赚钱都不错，但要学会兼职接单还是要有一个学习规划。

在这里插入图片描述

👉 这份完整版的Python全套学习资料已经上传，朋友们如果需要可以扫描下方CSDN官方认证二维码或者点击链接免费领取【保证100%免费】

～小羊没烦恼～
关注
  • 7
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值