华为、阿里巴巴、字节跳动 100+ Python 面试问题总结(三)

系列文章目录

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


文章目录

  • 系列文章目录
  • Python 面试的高阶问题
    • 39. 简述面向对象的三大特性?
    • 40. 如何在 Python 中创建类?
    • 41. 有什么方法可以获取类的所有属性和方法?
    • 42. 继承在 Python 中是如何工作的?
    • 43. 如何访问子类中的父类成员
    • 44. 访问说明符是否在 Python 中使用?
    • 45. 是否可以在不创建实例的情况下调用父类?
    • 46. 如何在 Python 中创建空类?
    • 47. `new` 修饰符和 `override` 修饰符的区别。
    • 48. 为什么使用 `Finalize`?
    • 49. 什么是 Python 中的 `__init__` 方法?
    • 50. 如何检查一个类是否是另一个类的子类?
  • Python Pandas 面试问题:[待更新](https://blog.csdn.net/a2360051431)

本文是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 支持不同类型的继承,包括:

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

    华为、阿里巴巴、字节跳动 100+ Python 面试问题总结(三)_第1张图片

    # 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 的祖父类。

    华为、阿里巴巴、字节跳动 100+ Python 面试问题总结(三)_第2张图片

    # 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()
    
  • 多重继承:当一个子类从多个父类派生成员时,就会实现这一点。 子类继承了父类的所有功能。

    华为、阿里巴巴、字节跳动 100+ Python 面试问题总结(三)_第3张图片

    # 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()
    
  • 分层继承:当一个父类由多个子类派生时,称为分层继承。

    华为、阿里巴巴、字节跳动 100+ Python 面试问题总结(三)_第4张图片

    # 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 面试问题:待更新

你可能感兴趣的:(Python,面试,华为,python,面试,开发语言)