系列文章目录

个人简介：机电专业在读研究生，CSDN内容合伙人，博主个人首页
Python面试专栏：《Python面试》此专栏面向准备面试的2024届毕业生。欢迎阅读，一起进步！🌟🌟🌟
码字不易，如果觉得文章不错或能帮助到你学习，可以点赞👍收藏📁评论📒+关注哦！😊😊😊

---

本文是Python面试专栏的第三篇。在本专栏中，我将总结华为、阿里巴巴、字节跳动等互联网公司 Python 面试中最常见的 100+ 问题。每道题都提供参考答案，希望能够帮助你在求职面试中脱颖而出，找到一份高薪工作。这些面试题涉及 Python 基础知识、Python 编程、数据分析以及 Python 函数库等多个方面。

Python 面试的高阶问题

39. 简述面向对象的三大特性？

面向对象编程（Object-Oriented Programming，OOP）有三大特性，分别是封装（Encapsulation）、继承（Inheritance）和多态（Polymorphism）。

• 封装（Encapsulation）：

  • 封装是指将数据和操作（方法）组合在一起形成一个独立的单元，对外部隐藏内部实现细节。通过封装可以保护数据的安全性，只能通过预定义的接口（方法）访问和修改数据。
  • 封装可以使代码更加模块化和可维护，减少了对外部的依赖性，提高了代码的可重用性和安全性。

• 继承（Inheritance）：

  • 继承是指一个类（子类）可以继承另一个类的属性和方法，从而避免了重复编写相同的代码。被继承的类称为父类或基类，继承的类称为子类或派生类。

  • 通过继承，子类可以拥有父类的属性和方法，并且可以在此基础上进行扩展或修改。

• 多态（Polymorphism）：

  • 多态是指同一种操作或方法可以应用于不同类型的对象，而产生不同的行为。通过多态，可以以统一的方式对不同的对象进行操作，无需关心对象具体的类型。
  • 多态性使得程序更加灵活和可扩展，可以通过定义抽象类、接口或基类来实现统一的方法签名，然后由不同的子类实现自己的具体行为。这样可以提高代码的可读性、可维护性和可扩展性。

这三大特性是面向对象编程的基础，共同支持着代码的重用、封装和抽象，使得我们能够以更高效和结构化的方式进行软件开发。

40. 如何在 Python 中创建类？

要在 Python 中创建类，我们使用关键字 class，如下例所示：

class MLPEmployee:
   def __init__(self, emp_name):
       self.emp_name = emp_name

要从上面创建的类实例化或创建对象，我们执行以下操作：

emp_1 = MLPEmployee("Mr Employee")

要访问 name 属性，我们只需使用 . 运算符调用该属性，如下所示：

print(emp_1.emp_name)
# Print Mr Employee

为了在类中创建方法，我们将方法包含在类的作用域下，如下所示

class MLPEmployee:
   def __init__(self, emp_name):
       self.emp_name = emp_name
       
   def introduce(self):
       print("Hello I am " + self.emp_name)

__init__ 和 introduce 函数中的 self 参数表示对当前类实例的引用，该实例用于访问该类的属性和方法。

self 参数必须是类中定义的任何方法的第一个参数。可以访问类 MLPEmployee 中的方法，如下所示：

emp_1.introduce()

整个基本的类的创建示例如下：

class MLPEmployee:
   def __init__(self, emp_name):
       self.emp_name = emp_name
       
   def introduce(self):
       print("Hello I am " + self.emp_name)
       
# create an object of MLPEmployee class
emp_1 = MLPEmployee("Mr Employee")
print(emp_1.emp_name)    #print employee name
emp_1.introduce()        #introduce the employee

在 Python 中，类是面向对象编程的基本组件之一，它允许我们创建具有属性和方法的自定义数据类型。

41. 有什么方法可以获取类的所有属性和方法？

在 Python 中，可以使用内置函数 dir() 来获取类的所有属性和方法。dir() 函数返回一个列表，包含了指定对象（包括类）所拥有的所有有效属性和方法的名称。

以下是一个示例代码，展示了如何使用 dir() 函数获取类的所有属性和方法：

class MyClass:
    def __init__(self):
        self.name = "Alice"

    def greet(self):
        print("Hello, my name is", self.name)

    def say_hello(self):
        print("Hello!")

obj = MyClass()

print(dir(obj))

运行上述代码，会输出包含了 MyClass 类的所有属性和方法的列表，例如：

['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__',
'__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', 
'__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 
'greet', 'name', 'say_hello']

需要注意的是，dir() 函数不仅适用于类对象，也可以用于其他对象、模块以及内置类型等。它返回的列表可能包含一些特殊命名的属性和方法，以双下划线开头和结尾的属性和方法，这些通常是 Python 内部定义的特殊成员。

42. 继承在 Python 中是如何工作的？

在 Python 中，继承（Inheritance）是一种实现代码重用和建立类之间关系的机制。通过继承，一个类（称为子类或派生类）可以从另一个类（称为父类或基类）继承属性和方法。

Python 支持不同类型的继承，包括：

• 单一继承：子类派生一个父类的成员。

  

  # Parent class
  class ParentClass:
  	def par_func(self):
       	print("I am parent class function")
  # Child class
  class ChildClass(ParentClass):
  	def child_func(self):
       	print("I am child class function")
  # Driver code
  obj1 = ChildClass()
  obj1.par_func()
  obj1.child_func()
  

• 多层继承：父类 A 由子类 B 继承，子类 B 再由另一个子类 C 继承。基类和派生类的功能进一步继承到新的派生类 C 中。在这里，A 是 C 的祖父类。

  

  # Parent class
  class A:
      def __init__(self, a_name):
          self.a_name = a_name
  
  
  # Intermediate class
  class B(A):
      def __init__(self, b_name, a_name):
          self.b_name = b_name
          # invoke constructor of class A
          A.__init__(self, a_name)
  
  
  # Child class
  class C(B):
      def __init__(self, c_name, b_name, a_name):
          self.c_name = c_name
          # invoke constructor of class B
          B.__init__(self, b_name, a_name)
  
      def display_names(self):
          print("A name : ", self.a_name)
          print("B name : ", self.b_name)
          print("C name : ", self.c_name)
  
  
  #  Driver code
  obj1 = C('child', 'intermediate', 'parent')
  print(obj1.a_name)
  obj1.display_names()
  

• 多重继承：当一个子类从多个父类派生成员时，就会实现这一点。 子类继承了父类的所有功能。

  

  # Parent class1
  class Parent1:
     def parent1_func(self):
         print("Hi I am first Parent")
  
  # Parent class2
  class Parent2:
     def parent2_func(self):
         print("Hi I am second Parent")
  
  # Child class
  class Child(Parent1, Parent2):
     def child_func(self):
         self.parent1_func()
         self.parent2_func()
  
  # Driver's code
  obj1 = Child()
  obj1.child_func()
  

• 分层继承：当一个父类由多个子类派生时，称为分层继承。

  

  # Base class
  class A:
      def a_func(self):
          print("I am from the parent class.")
  
  
  # 1st Derived class
  class B(A):
      def b_func(self):
          print("I am from the first child.")
  
  
  # 2nd Derived class
  class C(A):
      def c_func(self):
          print("I am from the second child.")
  
  
  # Driver's code
  obj1 = B()
  obj2 = C()
  obj1.a_func()
  obj1.b_func()  # child 1 method
  obj2.a_func()
  obj2.c_func()  # child 2 method
  

43. 如何访问子类中的父类成员

以下是 Python 访问子类中的父类成员的方法：

• 通过使用父类名：可以使用父类的名称来访问属性，如下例所示：

  class Parent(object):
      # Constructor
      def __init__(self, name):
          self.name = name
  
  
  class Child(Parent):
      # Constructor
      def __init__(self, name, age):
          Parent.name = name
          self.age = age
  
      def display(self):
          print(Parent.name, self.age)
  
  
  # Driver Code
  obj = Child("MLP", 6)
  obj.display()
  

• 通过使用 super()：在 Python 中，可以通过使用内置函数 super() 来访问子类中的父类成员。super() 函数返回一个特殊的对象，用于访问父类的方法、属性或构造函数。

  class Parent(object):
      # Constructor
      def __init__(self, name):
          self.name = name
  
  
  class Child(Parent):
      # Constructor
      def __init__(self, name, age):
          ''' 
          In Python 3.x, we can also use super().__init__(name)
          '''
          super(Child, self).__init__(name)
          self.age = age
  
      def display(self):
          # Note that Parent.name cant be used 
          # here since super() is used in the constructor
          print(self.name, self.age)
  
  
  # Driver Code
  obj = Child("MLP", 6)
  obj.display()
  

44. 访问说明符是否在 Python 中使用？

Python 中是使用访问说明符的。访问说明符用于控制类的属性和方法的可见性和访问级别。

在 Python 中，有三种常见的访问说明符：公有（Public）、私有（Private）和受保护（Protected）。

• 公有访问说明符（Public Access Specifier）：在 Python 中，默认情况下，所有的属性和方法都被视为公有的，可以在类内部和外部进行访问和使用。

• 私有访问说明符（Private Access Specifier）：在 Python 中，私有属性和方法以双下划线 “__” 开头，例如 “__attribute” 或 “__method”。私有属性和方法只能在类内部被访问和使用，无法在类外部直接调用。但是，可以通过特殊的命名规则来间接访问私有成员。

• 受保护访问说明符（Protected Access Specifier）：在Python中，受保护属性和方法以单下划线"_"开头，例如 “_attribute” 或 “_method”。受保护属性和方法可以在类及其子类中使用，但不应该在类外部直接访问。

需要注意的是，Python 的访问说明符并不像其他编程语言那样严格强制执行访问级别，而是依赖于程序员的自律。因此，在编写 Python 代码时，应该遵循命名约定，以便正确使用访问说明符。

45. 是否可以在不创建实例的情况下调用父类？

在不创建实例的情况下，是可以调用父类的。Python 提供了一种通过类名直接调用父类方法的方式。

使用 super() 函数可以在子类中调用父类的方法。这样可以在子类中扩展或修改父类的行为，同时保持继承关系。

以下是一个示例代码，演示了如何在不创建实例的情况下调用父类：

class ParentClass:
    def __init__(self, name):
        self.name = name

    def greet(self):
        print("Hello, I'm", self.name)


class ChildClass(ParentClass):
    def greet(self):
        super().greet()  # 调用父类的greet方法
        print("Nice to meet you!")


ChildClass.greet(ChildClass("Alice"))

输出结果为：

Hello, I'm Alice
Nice to meet you!

在上述示例中，我们定义了一个父类 ParentClass 和一个子类 ChildClass。子类 ChildClass 中的 greet() 方法使用 super() 函数调用父类的 greet() 方法，并在其后添加了额外的打印语句。

最后，我们通过在子类名后面加上括号并传入必要的参数，以类方法的方式调用子类的 greet() 方法，实现了在不创建实例的情况下调用父类的效果。

46. 如何在 Python 中创建空类？

在 Python 中创建空类非常简单：只需使用关键字 class 后跟一个类名即可，不需要为类定义任何属性或方法，可以直接使用 pass 语句来表示类体为空。

以下是创建空类的示例代码：

class EmptyClass:
    pass

在上述代码中，我们定义了一个名为 EmptyClass 的空类，其中的类体部分使用了 pass 语句表示为空。

通过这样的方式，就可以创建一个没有任何属性或方法的空类。可以根据需要后续添加属性和方法到该类中。

47. new 修饰符和 override 修饰符的区别。

在面向对象编程中，“new” 修饰符和 “override” 修饰符有不同的作用和含义。

• "new"修饰符：

  • “new” 修饰符用于在派生类中隐藏基类中的成员。当在派生类中使用 “new” 修饰符来声明一个与基类中同名的成员时，该成员将隐藏基类中的同名成员。这意味着在通过派生类的实例访问该成员时，实际上访问的是派生类中的成员而不是基类中的成员。
  • 使用 “new” 修饰符并不会覆盖或修改基类中的成员，只是在派生类中添加了一个具有相同名称的新成员。因此，当通过基类引用调用被隐藏的成员时，仍然会访问到基类中的成员。

• “override” 修饰符：

  • “override” 修饰符用于在派生类中重写（覆盖）基类中的虚拟方法或抽象方法。通过在派生类中使用 “override” 修饰符声明一个与基类中同名、参数和返回类型相同的方法，可以重写基类中的方法实现。
  • 当通过派生类的实例调用重写的方法时，实际上会执行派生类中的方法实现，而不是基类中的方法实现。
  • 注意，使用 “override” 修饰符要求基类中的方法必须是虚拟方法（使用 “virtual” 关键字）或抽象方法（使用 “abstract” 关键字）。否则，编译器会报错。

48. 为什么使用 Finalize？

在 Python 中，finalize() 是一个特殊方法，用于对象在被垃圾回收之前的清理工作。当一个对象不再被引用时，即没有变量指向它时，Python 的垃圾回收机制会自动回收该对象，并在回收之前调用该对象的 finalize() 方法（如果定义了的话）。

使用 finalize() 方法可以在对象被销毁之前执行一些必要的清理操作，例如关闭打开的文件、释放占用的资源、解除对象与其他对象之间的关联等。这样可以确保在对象生命周期结束时进行必要的清理工作，避免资源泄漏或不良影响。

需要注意的是，finalize() 方法并不是 Python 中常用的资源管理方式。更好的做法是使用上下文管理器（Context Manager）来管理资源，通过 with 语句来确保资源的正确释放，而不依赖于垃圾回收机制去调用 finalize() 方法。这种方式更具可读性和可靠性。

值得注意的是，从 Python 3.4 开始，finalize() 方法已经不推荐使用。取而代之的是使用上下文管理器、try…finally 语句或其他资源管理模式来进行资源清理，以提高代码的可读性和可维护性。

49. 什么是 Python 中的 __init__ 方法？

在 Python 中，__init__() 方法是一个特殊的方法，用于在创建类的实例时进行初始化操作。它是类的构造函数，会在对象创建后自动调用。

当使用类名加括号 () 创建一个类的实例时，__init__() 方法会被自动调用，并负责初始化该实例的属性和其他必要设置。

以下是一个示例代码，展示了如何定义和使用 __init__() 方法：

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

    def greet(self):
        print("Hello, my name is", self.name)


obj = MyClass("Alice")
obj.greet()

在上述代码中，我们定义了一个名为 MyClass 的类，其中的 __init__() 方法接受一个参数 name，并将其赋值给 self.name。在创建 MyClass 的实例时，传入一个名为 “Alice” 的参数，这样就调用了 __init__() 方法来初始化实例的 name 属性。

在实例化之后，我们通过 obj.greet() 调用了类中的 greet() 方法，并输出了相应的结果。

50. 如何检查一个类是否是另一个类的子类？

在 Python 中，可以使用 issubclass() 函数来检查一个类是否是另一个类的子类。

issubclass(subclass, superclass) 函数接受两个参数，即待检查的子类和超类。如果子类是超类的直接或间接子类，则返回 True；否则返回 False。

以下是一个示例代码，展示了如何使用 issubclass() 函数来检查类之间的继承关系：

class Parent(object):
   pass   
 
class Child(Parent):
   pass   
 
print(issubclass(Child, Parent))    # 输出 True
print(issubclass(Parent, Child))    # 输出 False

需要注意的是，issubclass() 函数只能用于判断类与类之间的继承关系，无法用于检查对象与类之间的关系。如果需要检查对象是否属于某个类的实例，可以使用 isinstance() 函数。

obj1 = Child()
obj2 = Parent()
print(isinstance(obj2, Child))    # 输出 False 
print(isinstance(obj2, Parent))   # 输出 True 

Python Pandas 面试问题：待更新