查漏补缺——【Python基础篇】

解释型语言和编译型语言的区别？

Python作为解释型语言区别于编译型语言（C/C++，JAVA等），主要在于代码的执行方式。

• 解释型语言在执行程序时通过解释器逐行翻译成机器语言，并立刻执行；
• 编译型语言通过编译器，将源程序整体编译称机器语言的可执行文件再执行。

解释型语言更灵活，但编译型语言的程序执行效率更高。

1）Python，执行时逐行编译，无需编译步骤；
2）C++，执行前整个文件编译成机器码，生成可执行文件；
3）错误处理：Python在执行时发现错误，C++在编译阶段就能找到大量错误；
4）编译型语言通常比解释型语言执行得更快；
5）平台依赖性：编译型语言生成平台特定的可执行文件，而解释型语言只依赖于解释器，更跨平台。

适用场景

• 开发周期：解释型语言（Python）因为没有编译步骤，开发和调试更为方便，适合快速开发、原型设计和脚本编写。编译型语言对性能要求更为苛刻，适合高性能的应用场景，如系统软件、嵌入式系统和大型游戏等。
• 混合模式：现代的一些编程语言（如JAVA）实际上属于混合模式（既有编译又有解释——JAVA编译后生成字节码，依赖于JVM解释执行），这样既保留了跨平台优势，又有一定程度的性能优化。
• 即时编译（JIT）：在Java编程语言和环境中，即时编译器是一个把Java的字节码（包括需要被解释的指令的程序）转换成可以直接发送给处理器（processor）的指令的程序。
• 工具链和生态：编译型语言通常具有丰富的编译优化选项，配备调试器、分析器等工具。解释型语言的交互式解释器和调试器，方便实时调试和实验，这也是Python被广泛用于数据科学、机器学习的原因之一。

Python的特点？

1）易读易写：语法简洁、结构清晰、代码可读性高、易上手。
2）跨平台：代码可以运行在任何安装Python解释器的OS上。

1. CPython：官方版本的解释器。这个解释器是用C语言开发的，所以也叫CPython。CPython是使用最广的Python解释器。我们通常说的、下载的、讨论的、使用的都是这个解释器。
2. IPython：基于CPython之上的一个交互式解释器，在交互方式上有所增强，执行Python代码的功能和CPython是完全一样的。CPython用>>>作为提示符，而IPython用In [序号]:作为提示符。
3. 其他解释器：
   PyPy：基于Python语言开发的一种追求执行速度的Python解释器。
   Jython：运行在Java平台的解释器，直接把Python代码编译成Java字节码执行。
   IronPython：运行在微软.net平台上的Python解释器，可以直接把Python代码编译成.net的字节码执行。

3）丰富的标准库和第三方库。
4）多种编程范式：支持面向对象编程、过程化编程和函数式编程。
5）解释型语言，开发调试便捷。
6）应用广泛：可用于Web开发、科学计算、数据分析、人工智能、流程自动化等多个领域。

扩展

1. Python作为一种动态类型语言，可以在运行过程中改变变量类型（开发更为灵活），但是容易产生类型相关错误。
2. Python社区活跃且庞大。
3. 内置数据结构（列表、字典、集合等），可以极大程度上方便数据处理和算法实现。
4. Python的模块和包机制，实现代码高度复用和模块化设计。

Python3中 is 和 == 的区别？

is 和 == 均用于比较两个对象是否相等。

• is 用来判断两个变量是否引用了同一个对象，比较对象的内存地址。
• == 是用来判断两个对象是否具有相同的值。

a = [1, 2, 3]
b = a
c = [1, 2, 3]

print(a == b)  # 输出: True
print(a is b)  # 输出: True
print(a == c)  # 输出: True
print(a is c)  # 输出: False

扩展（一些需要注意的点）

• 字符串缓存机制： 在 Python 内部，对于一些短字符串和数字，会启用缓存机制以优化性能。因为这些小型不可变对象会被频繁使用，所以 Python 预先创建并缓存了它们，以便可以多次引用，而不是每次新建实例。

  缓存范围一般是 -5 到 256，这点不同版本的解释器可能有所不同

• immutable（不可变）类型与 mutable（可变）类型： 对于不可变类型如字符串、数字、元组，常常会发生对象重用，而对于可变类型如列表、字典，每次创建都是新对象。

x = "hello"
y = "hello"
print(x is y)  # 输出: True

a = 256
b = 256
print(a is b)  # 输出: True

a = 257
b = 257
print(a is b)  # 输出: False

read()，readline() 和 readlines() 的区别?

三种方法都是用于从文件中读取内容，它们有不同的用途和返回类型：

1）read()

• 用法：file.read(size=-1)
• 功能：一次性读取整个文件内容，如果指定 size，则读取指定的字节数。
• 返回：一个字符串，包含整个文件的内容或指定的字节内容。

2）readline()

• 用法：file.readline(size=-1)
• 功能：读取文件中的一行内容，读取完成后，文件指针会移动到下一行。
• 返回：一个字符串，该字符串代表文件中的一行内容。

3）readlines()

• 用法：file.readlines(sizehint=-1)
• 功能：一次性读取文件中所有行，并把它们作为字符串列表返回。
• 返回：一个列表，列表中的每个元素是文件中的一行内容。

使用场景
理解这些方法的区别可以进一步让我们掌握文件操作的精度和效率问题。

• read() 使用场景
  适用于需要处理整个文件内容的场景，如读取配置文件、读取日志文件等。
  注意：对于大文件（例如几个 GB），使用 read() 可能会导致内存不足。

• readline() 使用场景
  适用于逐行处理文件的场景，如按行读取数据进行处理。
  可以结合循环读取文件，非常适合处理大文件而不会占用过多内存。

• readlines() 使用场景
  适用于需要处理文件所有行但操作较简单的场景，如将文件内容保存到列表中进行批量处理。
  注意：与 read() 类似，面对大文件需要小心内存问题。

介绍一些Python中的面向对象编程？

Python中的面向对象编程（OOP）是一种编程范式，通过”类“和对象”对象“组织代码，提高代码可重用性、可维护性和扩展性。四大特性：

• 封装（Encapsulation）：把数据和操作数据的方法封装在一个类中，保护数据不被外界意外修改，并减少全局变量的使用；（可以通过使用双下划线前缀来隐藏属性，一般使用单下划线来表示"受保护的“属性，而表面上并没有真正私有的属性，使用双下划线前缀会触发名称重整机制(name mangling)，使其较难被外部访问）

  • 封装的好处
    数据隐藏和保护：封装使得内部状态或行为对外部不可见，防止外部代码直接访问或修改内部数据，从而提高了安全性。
    简化接口：通过提供简洁明了的公共接口，可以隐藏对象的复杂实现细节，使得使用对象更加容易理解和使用。
    代码模块化：封装有助于将代码组织成独立的模块，提高代码的可读性、可维护性和可重用性。
  • 注意：尽管Python提供了封装机制，但它并不强制执行数据隐藏，程序员仍然可以通过特定方式访问私有成员（例如使用ClassName_private_.attribute)。因此，封装更多的是一种编程约定，而非绝对的访问控制手段。

  # 封装通过在类中定义私有属性和方法，并提供公共的方法(getter和setter))来访问和修改这些属性
  class MyClass:
      def __init__(self, value1, value2):
          self.__private = value1
          self._protected = value2
  
      def get_value(self):
          return self.__private, self._protected
  
  	def set_value(self, v1, v2)
  		self.__private = v1
  		self._protected = v2
  

• 继承（Inheritance）：定义新的类继承已有类的属性和方法，实现代码复用；

  class Animal:
      def __init__(self, name):
          self.name = name
  
      def speak(self):
          raise NotImplementedError("Subclasses must implement this method")
  
  
  class Dog(Animal):
      def speak(self):
          return f"{self.name} says Woof!"
  
  
  d = Dog("teddy")
  print(d.speak())  # teddy says Woof!
  

• 多态（Polymorphism）：不同的类实现相同的方法，使得相同的操作作用于不同对象产生不同的结果；

  • 子类继承父类并且重写（override）父类方法，调用的方法根据对象的实际类型来确定。
  • 接口（抽象基类）实现多态，使用抽象基类（ABC模块）定义抽象方法，子类必须实现这些抽象方法。
  • 鸭子类型，除了传统的继承和抽象基类，Python的动态类型特性导致其具有“鸭子类型"特性。如果一个对象具有实现所需方法，那么它能作为参数传递，无需显式地继承某个类。

• 抽象（Abstraction）：通过抽象类（ABC）和接口定义通用方法，隐藏复杂的实现细节。通过抽象，可以使代码更加模块化、可维护性更好，也更符合人类的思维模式。

  • 好处
    提高代码可维护性：代码的逻辑与细节实现分离，便于管理和维护。
    增强代码复用性：将共有的操作抽象出来，在多个地方复用同一个抽象接口。
    易于扩展：在不影响已有代码的情况下，可以轻松地扩展新功能，只需实现新的具体类。
  • 应用场景
    抽象非常适合用于需要在不同实例间共享接口定义的情况，例如各类API、插件系统等。
    常被用在大型系统中，在系统设计阶段利用抽象定义各模块接口，从而使各模块可独立开发。
  • 与其他面向对象特性的关系
    继承：抽象类通常作为基类被其他具体类继承，实现接口定义的功能。
    多态：抽象允许不同的具体类实现相同的接口，从而通过一个抽象引用来处理不同的具体对象。
    封装：抽象在一定程度上依赖于封装，通过将具体实现细节隐藏起来，只提供必要的接口。

  from abc import ABC, abstractmethod
  
  
  class Animal(ABC):
      @abstractmethod
      def speak(self):
          pass
  
  
  class Dog(Animal):
      def speak(self):
          return "Woof!"
  

什么是名称重整机制？

名称重整是Python中一种用于私有变量和函数命名的技巧。

当类定义中的成员名称以两个下划线开始，但不以两个下划线结束时（例如__myfunction），Python会自动将这样的成员名称重整，即在名称前增加一个下划线和类名。例如，如果有一个名为MyClass的类中包含一个名为__myfunction的私有函数，那么在外部访问时，其名称会被重整为_MyClass__myfunction。

• 私有属性和方法：通过在属性或方法名前加双下划线__，例如__private_attribute，让它们成为私有的，这意味着只能在类的内部访问。
• 保护的属性和方法：通过在属性或方法名前加单下划线_，例如_protected_attribute，虽然这是一个约定，但它表示变量不应该从类的外部直接访问。

class BaseClass:
    def __privateMethod(self):
        print("This is a private method in BaseClass.")

在派生类中，借助名称重整的规则，可以这样调用基类中的私有函数：

class DerivedClass(BaseClass):
    def callPrivateMethod(self):
        # 调用基类的私有方法
        self._BaseClass__privateMethod()

这种方式虽然可以实现对基类私有函数的调用，但是它破坏了类的封装性，因为它依赖于Python的名称重整规则，并且对类的内部结构有一定的依赖。因此，除非特殊情况，否则不推荐使用这种方式访问私有成员。

什么是鸭子类型（duck typing）？

一种动态类型检查的方法，广泛应用于动态语言如Python中。它的核心理念是：“如果它像鸭子一样走路
并且像鸭子一样叫，那么它很可能就是一只鸭子”。
从编程角度来看，鸭子类型关注对象的行为（方法和属性）而不是其实际类型。这样，使得编写更加灵活和简洁的代码成为可能。

扩展
为了进一步理解鸭子类型的概念，从以下几方面来展开：

• 设想有一个函数能够处理任何具有quack方法的对象：

  class Duck:
  	def quack(self):
  		print("Quack!")
  
  
  class Person:
  	def quack(self):
  		print("Quacking like a duck!")
  
  
  def make_it_quack(duck_like):
  	duck_like.quack()
  
  d = Duck()
  p = Person()
  make_it_quack(d)
  make_it_quack(p)
  

  在这个例子中，函数make_it_quack并不关心传递给它的对象是否真的是鸭子，只要这个对象有一个quack方法即可。这就是典型的鸭子类型的使用。
  • 与静态类型的比较：在静态类型语言中（如Java)，类型检查发生在编译期，要求对象必须是某个特定类型或该类型的子类。然而，在鸭子类型中，它不需要预定义类型，发生在运行时。类型约束由对象的行为来决定，而不是它继承的类。
  • 优缺点：
    • 优点：
      灵活性：鸭子类型允许更灵活的代码设计，不需要对类型进行严格的约束。
      代码简洁：减少了编写一大堆抽象类或者接口的需求。
    • 缺点：
      错误捕获：因为类型检查发生在运行时，所以有可能会因为不符合预期的对象而导致运行时错误，增加了调试的难度。
      可读性：代码的可读性和可维护性可能会下降，因为没有明确的类型标识，新入职或者协作的开发者可能需要更多时间来理解代码。
  • Python生态中的应用：许多Python框架和库，如Django、Flask都广泛运用了鸭子类型。在设计回调函数、处理请求对象以及其他动态行为时，经常会利用鸭子类型的特性。

Python是否支持多重继承？

Python支持多重继承，一个类可以同时从多个父类继承属性和方法。

扩展
多重继承是一个很强大的特性，但也增加了一些复杂性。
1）类的定义：可以通过在类定义中列出多个父类来实现多重继承。

class Parent1:
	def method1(self):
		print("Parent1 method1")

class Parent2:
	def method2(self):
		print("Parent2 method2")

class Child(Parent1,Parent2):
	pass
	
# Chi1d类继承了Parent1和Parent2,因此它可以调用从这两个父类继承的方法：
child = Child()
child.method1()  # 输出：Parent1 method1
child.method2()  # 输出：Parent2 method2

2）方法解析次序(MRO)
当一个类继承了多个父类时，Python使用一种称为C3线性化（也叫MRO，Method Resolution Order)的方法
来确定方法和属性的继承顺序。可以使用className.__mro__或className.mro()方法来查看某个类的MRO:

print(Child.__mro__)  # 输出：（Child,Parent1,Parent2,object)

3）钻石继承问题
Python的多重继承可以引发所谓的"钻石继承问题”。这是指在多个父类之间同名方法冲突的情况。幸运的是，C3线性化规则能很好的解决此类问题。举个例子：

class A:
    def method(self):
        print("A method")

class B(A):
    def method(self):
        print("B method")

class C(A):
    def method(self):
        print("C method")

class D(B, C):
    pass

# 在这种情况下，调用D类的method方法会按照MRO顺序找到B类中的method方法，而不是C类中的。
d = D()
d.method()
print(D.__mro__)  # (<class '__main__.D'>, B, C, A, <class 'object'>)

4）super()函数
Python提供了super()函数，可以按照MRO顺序调用父类的方法。对于多重继承尤其有用，因为它可以避免显式调用特定父类的方法，从而避免混乱（改写上面的程序）：

class A:
    def method(self):
        print("A method")

class B(A):
    def method(self):
        super().method()
        print("B method")

class C(A):
    def method(self):
        super().method()
        print("C method")

class D(B, C):
    def method(self):
        super().method()
        print("D method")

d = D()
d.method()
# 在这个例子中，`super().method()`会按照D类的MRO顺序依次调用父类的方法。
# 输出A method\n C method\n B method\n D method

解释一下Python类中的self？

在Python类中，self是一个重要的概念，它代表类的实例。用简单的话来说，它是引用类当前实例的方式。当我们定义一个类的方法时，必须把self作为第一个参数，因为这让方法能够访问该实例的属性和其他方法。

虽然self是一种约定俗成的命名方式，但可以使用其他名称来代替self，只不过这样会让代码看起来比较不常见，读代码的人需要额外理解。

类方法和静态方法：除了实例方法外，Python还有类方法(classmethod)和静态方法(staticmethod)。

• 类方法使用cls作为第一个参数，代表类本身；
• 静态方法则不需要self或cls参数。

class Dog:
    species = "Canis lupus"
    def __init__(self, name):
        self.name = name

    @classmethod
    def get_species(cls):
        return cls.species

    @staticmethod
    def bark():
        print("woof")

print(Dog.get_species())
Dog.bark()

__init__方法在Python中有什么作用？

__init__方法在Python中是类的构造方法，在创建一个类的实例时被自动调用，用来初始化实例的属性。

为什么要用__init__？
使用__init__方法可以确保类在实例化的时候，所需的属性能够被正确地初始化。避免手动逐个对属性进行赋值，同时提高代码的可读性和维护性。

class Person:
	def_init_(self,name,age):
		self.name = name
		self.age = age
p1 = Person("Alice",30)
p2 = Person("Bob",25)

__init__与__new__的区别
__new__方法和__init__方法都是类的构造方法，但它们有各自不同的功能。

• __new__用于创建并返回一个新的实例对象，是类级别的方法；
• 而__init__则用于初始化实例对象，是实例级别的方法。

通常情况下，只需重写__init__方法，而很少需要重写__new__方法。

---

调用时机和顺序
● __new__是在创建实例时首先被调用的。当调用ClassName()时，会自动调用__new__方法来创建一个新的实例。
● 创建完实例后，接着会调用__init__方法对实例进行初始化设置。

---

参数
● __new__方法的第一个参数通常是cls,表示当前要实例化的类。可以在__new__方法中进行一些类级别的操作，如自定义内存分配。
● __init__方法的第一个参数是self，表示实例本身，后续参数用于传递实例化时的初始值。

---

重写
● 重写__new__方法时，一定要返回一个实例对象，否则__init__一方法将不会被调用。
● 重写__init__方法可以设置属性默认值，并不会改变返回值。

class Example:
    def __new__(cls, *args, **kwargs):
        print(f"Creating instance of {cls.__name__}")
        instance = super(Example, cls).__new__(cls)
        return instance

    def __init__(self, name):
        print(f"Initializing instance to {name}")
        self.name = name


example1 = Example("Python")

应用场景
__new__方法主要用于自定义类的实例化过程，例如实现单例模式、元类等。
__init__主要用于实例属性的初始化，是最常见的操作。

与其他语言相比
在Java、C++等面向对象的编程语言中，也有类似的构造函数。比如Java的构造函数和Python的__init__方法扮演着同样的角色，就是初始化实例对象的属性。不同的是，Python的__init__方法不返回值，而Java的构造函数没有返回类型。

__init__属于什么方法，你还知道哪些？

在 Python 中，魔术方法（Magic Methods），也称为双下划线方法（Dunder Methods），是一些以双下划线开头和结尾的方法。这些方法让用户可以定义对象的行为，并在特定的情况下被自动调用。
除了上文提到的__init__之外，Python还有许多其他的魔法方法，比如：

• __str__——定义对象的字符串表示，用于 print() 或 str()

  class Person:
      def __init__(self,name,age):
          self.name= name
          self.age = age
  
      def __str__(self):
          return f"Person(name={self.name},age={self.age})"
  
  p = Person("Alice",30)
  print(p)  # Person(name=Alice,age=30)
  

• __repr__——定义对象的官方字符串表示，用于 repr() 函数
• __del__——析构函数，在对象被删除时调用）等
• __eq__——定义对象相等性比较，处理 == 运算符
• __lt__——定义对象小于比较，处理 < 运算符
• __add__——定义对象的加法操作，处理 + 运算符
• __call__——使对象可以像函数一样被调用
• __getitem__——定义获取元素的方法，允许使用索引访问
• __setitem__——定义设置元素的方法，允许使用索引赋值

扩展
Python 的魔术方法不仅限于上述列出的，还包括很多用于不同操作的特殊方法，这些方法有助于简化一些复杂的操作并提高代码的可读性和维护性。

• 运算符重载：通过定义 __add__、__sub__、__mul__ 等方法，自定义对象的加法、减法、乘法等运算。运算符重载使定制类像内置类一样使用。

  class Vector:
      def __init__(self, x, y):
          self.x = x
          self.y = y
  
      def __add__(self, other):
          return Vector(self.x + other.x, self.y + other.y)
  
      def __repr__(self):
          return f"Vector({self.x}, {self.y})"
  
  v1 = Vector(2, 3)
  v2 = Vector(5, 7)
  print(v1 + v2)  # 输出 Vector(7, 10)
  

• 上下文管理：通过定义 __enter__ 和 __exit__ 方法，使对象能够使用 with 语句。这在资源管理（如文件操作、数据库连接）中尤为常见。

  class CustomResource:
      def __enter__(self):
          print("Resource acquired")
          return self
  
      def __exit__(self, exc_type, exc_val, exc_tb):
          print("Resource released")
  
  with CustomResource() as resource:
      print("Using resource")
  # 输出：
  # Resource acquired
  # Using resource
  # Resource released
  

• 容器对象：通过定义 __len__、__getitem__、__setitem__、__delitem__ 和 __contains__ 等方法，可以自定义类的行为，使其像列表、字典等容器对象一样使用。

  class CustomList:
      def __init__(self):
          self.items = []
  
      def __len__(self):
          return len(self.items)
  
      def __getitem__(self, idx):
          return self.items[idx]
  
      def __setitem__(self, idx, value):
          self.items[idx] = value
  
      def __delitem__(self, idx):
          del self.items[idx]
  
  cl = CustomList()
  cl.items.append(1)
  cl.items.append(2)
  print(len(cl))    # 输出 2
  print(cl[0])      # 输出 1
  cl[1] = 3
  print(cl.items)   # 输出 [1, 3]
  

Python函数参数*args和**kwargs的区别？如何使用？

在Python函数中，*args（可变参数）和**kwargs（可变关键字参数）提供了一种灵活的方式来处理任意数量的未命名和命名参数。

• *args用于将多个未命名参数作为一个元组传递给函数。具体来说，你可以传入任意数量的位置参数，而这些参数会被收集到一个元组中供函数使用。
• **kwargs用于将多个关键字参数（即有命名的参数）作为一个字典传递给函数。你可以传入任意数量的关键字参数，这些参数会被收集到一个字典中供函数使用。

def demo_args(*args):
    print("类型：", type(args))
    for i,arg in enumerate(args,start=1):
        print(f"参数{i}:{arg}")
def demo_kwargs(**kwargs):
    print("类型：", type(kwargs))
    for key,value in kwargs.items():
        print(f"参数{key}:{value}")
# 调用带有*args的函数
print("使用*args调用demo_args函数：")
demo_args(1,2,3,"he11o",[4,5,6])
# 调用带有**kwargs的函数
print("\n使用**kwargs调用demo_kwargs函数：")
demo_kwargs(name="Alice",age=30,location="Wonderland")
"""
使用*args调用demo_args函数：
类型： <class 'tuple'>
参数1:1
参数2:2
参数3:3
参数4:he11o
参数5:[4, 5, 6]

使用**kwargs调用demo_kwargs函数：
类型： <class 'dict'>
参数name:Alice
参数age:30
参数location:Wonderland
"""

扩展

• *args可以结合其它参数使用，放在位置参数之后

  def combined_ex(a, b, *args):
  	print(a, b)
  	print(args)
  combined_ex(1,2,3,4,5)
  

• **kwargs可以结合其它参数使用，放在位置参数和*args之后

  def combined_ex(a, b, *args, **kwargs):
  	print(a, b)
  	print(args)
  	print(kwargs)
  combined_ex(1,2,3,4,5, name="python", age=25)
  

• 这两个参数不仅能接收传入的参数，还能通过解包把已有的元组或字典传入函数中。

  args = (3, 4, 5)
  kwargs = {'name': 'bob', 'age': 26}
  combined_ex(*args)
  combined_ex(**kwargs)
  

使用*args和**kwargs的技巧在编写灵活性高、可复用性强的函数时特别有用。它们可以有效地处理未知数量的参数，避免写大量的函数重载，更高效地管理代码。

---

Python没有函数重载(Function Override)，因为它的函数可以通过默认参数、*args、**kwargs等特性来实现同样的功能。Python是动态类型语言，函数的行为可以根据传入的参数类型和数量灵活调整。
此外，Python是一种动态类型语言。在Python中，函数参数不在编译期绑定到特定的类型上，而是在运行时进行检查。因此，不同于静态类型语言（如C++或Java)，Python不需要依靠重载来实现多态。

类型检查和重载库：
虽然Python本身不支持函数重载，但可以使用一些第三方库来实现类似的功能，例如functools.singledispatch，这是Python的标准库中提供的一种实现函数重载的方式。

from functools import singledispatch
@singledispatch
def fun(arg):
	print("default",arg)

@fun.register(int)
def _(arg):
	print("int",arg)

@fun.register(str)
def _(arg):
	print("str",arg)

fun(10)  # 输出：int 10
fun("10")  # 输出：str 10
fun(10.5)  # 输出：default 10.5

Python中的pass关键字作用？

pass语句是一个占位符。虽然它什么都不做，但它在编写代码时非常有用。具如果有些函数或循环还未实现，但不希望程序因为语法错误而中断，可以使用pass保持代码结构的完整。

pass在保持代码结构时应用，适用于开发阶段或调试阶段。

def my_function():
	pass  # 还没实现，但保持代码结构
for i in range(5):
	pass  # 为以后添加的逻辑空出
try:
	pass  # 预留错误处理代码位置
except:
	pass

扩展

• 1）代码占位：在编写代码的初期，尤其是在进行函数和类定义时，pass非常有用。它让你能够先搭建好代码框架，然后逐步细化和实现每个部分。
• 2）调试：当你调试代码时，有时候希望暂时禁用某些代码块（如一段还在开发中的代码）而不删除它们，这时候pass就可以派上用场。你可以用pass代替这段代码块，让程序继续执行而不报错。
• 3）与控制结构配合：pass也可以用于条件语句和循环中。例如：当你在写if-elif-else语句时，还没有决定某个分支的具体操作，可以使用pass来保持代码的完整性。
• 4）其他语言对比：对比其他编程语言，类似的概念也是有的。在C、C++和Java中，可以使用一个空的花括号{}作为占位符。在Ruby中，则使用nil。

Python中的any()和all()方法的作用？

any()和all()是两个内置函数，它们用来判断一个可迭代对象中的元素是否满足某些条件。

1. any(iterable)：如果可迭代对象中至少有一个元素为True,则返回True。否则，返回False，类似以我们常说的逻辑词“或”。
2. all(iterable)：只有当可迭代对象中的所有元素都为True时，才返回True。否则，返回False。类似我们常说的逻辑词”与”。

实际应用场景

• 用any()检查是否存在满足某个条件的元素

  li = [1, 2, 3, 4]
  print(any(x % 2 != 0 for x in li))  # 检查是否有奇数
  

• 用all()验证数据是否符合要求

  data = [True, True]
  print(all(data))  # 判断数据是否都有效
  

1. 短路求值：与逻辑运算符类似，any()和all()都具有短路求值的性质，即一旦找到结果，就会立即返回，而不会继续检查剩下的元素。
   2.数据类型：any()和all()可以用于任何可迭代对象（如列表、元组、集合、字符串等）。

Python中 help() 和 dir() 的作用？

用于帮助开发者了解对象的详细信息以及对象的属性和方法。

• help() 函数：主要用于查看对象（函数、模块、类等）的详细文档说明。
  help(object)，比如help(print)会输出print函数的用法和说明。

  help() 函数会进入交互式帮助模式，可以按q退出这个模式。
  可以用它来查看模块、函数、类或者变量的文档字符串(Docstring)。

• dir() 函数：主要用于查看对象的属性和方法列表。
  dir(object)，比如dir(str)会输出字符串对象的属性和方法列表。

  如果不传递参数给dir()，它返回当前范围内的命名列表。
  常用于探索和调试，比如查看一个类或实例有哪些方法和属性。

使用方式：先用dir()查看对象有哪些方法和属性；再用help()针对某个具体的属性或方法查看详细用法和说明。

>>>dir(1ist)  # 查看1ist的属性和方法
['__add__','__class_','_contains_',...,'append','clear','copy',...
>> help(list.append)  # 查看list.append方法的详细说明
Help on method_descriptor:

append(self,object,/)
	Append object to the end of the list.

Python 的 iterable 和 iterator 有什么区别？

iterable于iterator是两个不同的概念：

• iterable是可以被迭代的对象（元组、字符串、列表等），通过iter()方法可以得到它的迭代器（iterator）。
• iterator是一个实现了迭代协议（有__iter__和__next__方法）的对象，iterator可以从iterable中逐个读取元素。

  my_li = [1, 2, 3]
  my_iter = iter(my_li)
  print(next(my_iter))
  ...
  

手动实现一个简单的iterator（自定义类）：

class MyIterator:
    def __init__(self, data):
        self.data = data
        self.index = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.index < len(self.data):
            result = self.data[self.index]
            self.index += 1
            return result
        else:
            raise StopIteration

my_iterator = MyIterator([3, 5, 7])
print(next(my_iterator))

使用场景

• 使用iterables和iterators可以有效处理大数据，比如文件读取、网络流处理等。
• 避免将所有数据一次性加载到内存中，提高程序效率。

生成器
它们是一种特殊的迭代器，更加简洁，通过yield关键词生成。

什么是Python的生成器？

生成器是Python中的一种特殊类型的迭代器，在迭代过程中逐渐生成值，而不是一次性生成所有的值。生成器由函数创建，这些函数使用yield关键字而不是return来返回值。

yield是用于生成器(generator）的一种关键字。与return类似，它可以从函数返回值，但不同的是，yield返回的值可以在下次函数调用时继续执行，而不是退出函数。因此，yield的主要目的是使一个函数变成一个生成器，可以逐步迭代处理大数据或流数据，而不用一次性地占用大量内存。

扩展知识
生成器其实是一个非常强大的工具，特别适合处理大数据集或者流式数据。它们的实现使代码不仅更加简洁，还能显著降低内存消耗。

• 1）创建生成器：普通的函数使用
  return返回值，而生成器函数使用yield返回值并且记住返回之后的状态。下一次迭代从上一次停止的地方继续执行。例如：

  def gen_num():
      yield 1
      yield 2
  
  num = gen_num()
  print(next(num))
  print(next(num))
  

• 2）内存友好：由于生成器一次只产生一个值，它们非常内存友好，特别是在处理大型数据集时不像列表那样占用大量内存空间。例如，生成一个百万级别大小的列表和生成器的内存占用差异是巨大的。
• 3）迭代器协议：生成器遵循Python的迭代器协议，意味着它们支持__iter__()和__next__()方法。此外，也可以使用for循环直接迭代生成器，无需显式调用next()。
• 4）无限序列：生成器还可以用来生成无限序列，这种情况下无须担心内存不足。例如，生成自然数序列：

  def infinite_num(start=0):
      num = start
      while True:
          yield num
          num += 1
  
  infinite_gen = infinite_num()
  print(next(infinite_gen))
  print(next(infinite_gen))
  ...
  

• 5）生成器表达式：生成器还可以通过类似列表推导式的方式生成，只不过是用小括号而不是方括号。例如：my_gen = (x**2 for x in range(10))
• 6）双向通信：生成器不仅可以向调用者返回值，还可以从调用者接收值。这通过生成器的send()方法实现，在生成器执行过程中动态地将值传递回生成器。

  def double_yield():
      x = yield
      while True:
          x = yield x * 2
  
  gen = double_yield()
  next(gen)
  print(gen.send(2))  # 4
  print(gen.send(10))  # 20
  

• 7）生成器的其他方法除了next()和send()，还支持throw()和close()方法。
  • throw(exception_type,value=None,traceback=None)：向生成器引发一个异常。生成器可以捕获这个异常进行处理。
  • close()：关闭生成器，使其抛出一个GeneratorExit异常，从而终止迭代。

def exception_handling_generator():
    try:
        while True:
            yield
    except GeneratorExit:
        print("GeneratorExit has been raised")

gen = exception_handling_generator()
next(gen)
gen.close()

Python中enumerate()的用法？

enumerate()是一个内置函数，用于迭代元组、列表等可迭代对象时，同时获取元素的索引和值。

针对enumerate()扩展一些常见的用法以及细节：

• 1）指定起始索引：enumerate()的第二个参数可以用来设置索引的起始值，默认是0。例如：

  li_ = ['a', 'b', 'c']
  
  for index, item in enumerate(li_, start=1):
      print(f"index: {index}, item: {item}")
  

• 2）结合其他函数使用：enumerate()常与list()、dict()等函数结合使用，以生成不同的数据结构。例如：

  li_ = ['a', 'b', 'c']
  
  enum_list = list(enumerate(li_))
  print(enum_list)
  # [(0, 'a'), (1, 'b'), (2, 'c')]
  

• 3）应用在列表推导式：可以在列表推导式中使用enumerate()，以便快速生成带有索引的列表。

  li_ = ['a', 'b', 'c']
  
  enum_list = [(i, item) for i, item in enumerate(li_)]
  print(enum_list)
  # [(0, 'a'), (1, 'b'), (2, 'c')]
  

• 4）性能：由于enumerate()是生成器，它不会一次性生成所有元素，节省内存。这在处理大规模数据时特别有用。

Python3装饰器的用法？

装饰器可以用来扩展函数的功能，而不需要修改它们的定义。在Python3中，装饰器是通过在函数定义前加上@符号，然后跟上装饰器函数的名字来实现的。
装饰器本质上是一个可调用的对象（通常是一个函数），它接受一个函数作为参数，并返回一个经过修改或者扩展的函数。
下面是一个简单的例子来说明装饰器的基本用法：

def my_decorator(func):
    def wrapper():
        print("before the func is called")
        func()
        print("after the func is called")
    return wrapper

@my_decorator
def say_hello():
    print("hi! decorator")

say_hello()

在上面的例子中，my_decorator是装饰器函数，它接受say_hello函数作为参数，并在函数调用前后添加了额外的打印语句。通过@my_decorator把my_decorator应用于say_hello函数，在调用say_hello时，实际上会先执行my_decorator中wrapper函数的代码。

扩展

• 1）带参数的装饰器：向装饰器传递参数，需要在装饰器外再套一层函数。

  def repeat(num):
      def my_decorator(func):
          def wrapper(*args, **kwargs):
          	# before - doing something
              for i in range(num):
                  func(*args, **kwargs)
              # after - doing something
          return wrapper
      return my_decorator
  
  @repeat(3)  # 使say_hello函数被调用3次
  def say_hello(name):
      print('Hello {}'.format(name))
  
  say_hello('John')
  

• 2）类装饰器：语法和函数装饰器类似，装饰对象变成了类。

  def add_method(cls):
      cls.new_method = lambda self: "New Method added"
      return cls
  
  @add_method
  class MyClass:
      pass
  
  obj = MyClass()
  print(obj.new_method())
  

• 3）装饰器的组合使用：可以使用多个装饰器，每个装饰器从下到上依次生效。

  def decorator1(func):
      def wrapper():
          print("decorator1")
          func()
      return wrapper
  
  def decorator2(func):
      def wrapper():
          print("decorator2")
          func()
      return wrapper
  
  @decorator1
  @decorator2
  def say_hello():
      print("hello")
  
  say_hello()
  # 输出顺序：decorator1 decorator2 hello
  

• 4）functools.wraps：编写装饰器时，如果不使用functools.wraps，装饰器会丢失原函数的元信息（比如名字和文档字符串）。使用wraps可以保持这些信息。

  from functools import wraps
  def my_decorator(func):
      @wraps(func)
      def inner(*args, **kwargs):
          print("calling decorated function")
          return func(*args, **kwargs)
      return inner
  
  @my_decorator
  def say_hello():
      print("hello")
  
  print(say_hello.__name__)
  # 不使用@wraps注解输出 "inner"
  # 使用@wraps注解输出 "say_hello"
  

• 5）应用场景：装饰器在实际开发中有非常多的应用场景，如日志记录、权限校验、缓存等等，都可以通过装饰器来实现。它们能帮助提高代码的可读性和可复用性。

什么是Python的闭包？

闭包(Closure)是Python中的一种独特的函数机制。简而言之，闭包是指在一个内部函数中，引用了外部函数的变量，而这个外部函数已经执行完毕并返回了内部函数，然而内部函数仍然可以访问这些外部函数中的变量。

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

closure_func = outer_function(10)
print(closure_func(5))  # 输出15

outer_function返回了inner_function，而这个inner_function仍然可以访outer_function中的变量x。

1）闭包的使用场景：闭包常常用于函数工厂、装饰器和维持状态（例如计数器）等场景。它们允许创建带有状态的可重用函数，而无需依赖全局变量。

在上面的例子中，outer_function创建了带有状态的x的inner_function函数

2）闭包的优势：避免了全局变量，使代码更模块化和更易维护。通过闭包可以隐藏一些状态，使得外部无法随便修改，增强了数据的封装性。

3）cell对象：在Python里，闭包中的外部变量会被存储在一个叫做"cell对象"的东西里。可以通过.__closure__属性来访问，通常来说不需要特别去操作这些cell对象。

print(closure_func.__closure__[0].cell_contents)，通过这种方法可以看到闭包中的变量x

4）延迟计算和记忆化：闭包也常常用于延迟计算或记忆化(Memoization)技术中，这类技术可以显著提高程序的效率。

import time
def memoize(f):
    cache = {}
    def memoized_f(x):
        if x not in cache:
            cache[x] = f(x)
        return cache[x]
    return memoized_f

@memoize
def slow_f(x):
    # 一段耗时很长的代码
    for i in range(10000000):
        i += 1
    return x * x

start_t = time.time()
print(slow_f(5))  # 25
print(time.time() - start_t)  # 0.3500785827636719
start_t2 = time.time()
print(slow_f(5))  # 第二次调用时将从缓存中获取结果  25
print(time.time() - start_t2)  # 0.0

介绍一些Python的深拷贝、浅拷贝之间的区别？

• 浅拷贝（copy()）：创建一个新的对象，不复制内部嵌套的对象，只复制了原对象的引用。因此对任一对象的改动会影响到另一个对象。
• 深拷贝（deepcopy()）：创建一个新的对象，同时递归地复制所有嵌套的对象，即使复制对象被修改，也不会影响到原对象。

import copy

li_ = ['a', 'b', [3, 4]]

shallow_copy = copy.copy(li_)

deep_copy = copy.deepcopy(li_)

# 修改原列表中的嵌套列表
li_[2][0] = 99

print("orl list:", li_)  # orl list: ['a', 'b', [99, 4]]
print("shallow copy:", shallow_copy)  # shallow copy: ['a', 'b', [99, 4]]
print("deep copy:", deep_copy)  # deep copy: ['a', 'b', [3, 4]]

浅拷贝和原列表共享嵌套列表，修改其中一个会影响另一个。
深拷贝独立于原列表，不受其修改影响。

---

需要注意：Python中的大部分数据类型拷贝时对性能的影响。对于大型对象或嵌套结构比较复杂的数据，深拷贝的开销显然要比浅拷贝大得多，因为它需要递归地复制每一个层级的对象。所以在实际开发中，选择何种拷贝方式应根
据具体场景和性能需求权衡。另外，对于不可变对象（如字符串、元组等），无需用到深浅拷贝，因为它们的性质决定了不会受到修改。

Python内置数据结构有哪些？

• 1）列表(List)：有序、可变的序列，使用方括号[]表示。
  • 列表是Python中最通用的数据结构，支持多数数据类型作为元素。
  • 可通过索引和切片操作列表。
  • 支持各种方法如append(),remove(),pop(),sort(),reverse()等。
• 2）元组(Tuple)：有序、不可变的序列，使用小括号()表示。
  • 元组一旦创建，就不能修改，这使得它们是不可变的。
  • 因为不可变，元组更安全，尤其在作为字典的键时。
  • 操作方式与列表相似，如通过索引和切片读取。
• 3）集合(Set)：无序、唯一元素的集合，使用大括号{}表示。注意，空集合要用set()表示而不是{}，因为{}是用来表示空字典的。
  • 集合用于去重，对大型数据集进行去重操作尤其高效。
  • 支持各种集合操作如并集、交集、差集和对称差等。
  • 元素需是不可变类型，如数值、字符串或元组。
• 4）字典(Dictionary)：键值对的集合，使用大括号{}表示。
  • 字典是键值对的集合，键是唯一的且不可变，值可以是任何类型。
  • 可以快速查找、添加、删除元素。
  • 常用于需要频繁查找操作的场景。
• 5）字符串(String)：有序、不可变的字符序列，使用单引号''或双引号""表示。
  • 字符串是不可变的，这意味着每次修改字符串都会创建一个新字符串。
  • 作为一种序列，也可以通过索引和切片来读取字符。
  • Python提供了丰富的字符串操作方法，如find(),upper(),lower(),replace(),split(),strip(),join()等等。

Python中元组（tuple）和列表（list）的区别？

1）可变性：列表是可变的，即可以修改（添加、删除、改变元素）；元组是不可变的，一旦创建就无法修改。
2）语法：列表使用方括号[]表示，而元组使用圆括号()表示。
3）性能：由于元组是不可变的，操作速度通常比列表更快，内存使用也更少。
4）用法：列表常用于需要修改数据的情况，元组则更多用于保证数据不被意外改动。

扩展①

• 列表和元组可以通过内置函数list()和tuple()互相转换。
• 列表和元组都支持索引和切片。
• 列表支持：追加元素（append()）、移除元素（remove()）和排序（sort()）等；但元组不支持这些修改操作。
• 一些可用的内置函数：len()、max()、min()、sum()
• 使用元组的原因：
  • 元组可以作为字典的键，因为它们是不可变的
  • 可以用在函数的返回值中，当你不希望返回的值被修改
  • 存储数据更节省空间且提高访问速度

什么是Python元组的解封装？

Python元组的解封装(tuple unpacking)是将一个元组的多个元素分别赋值给对应数量的变量的操作。这种方法可以简化代码，使得代码更易读。举个例子，如果有一个含有四个元素的元组my_tuple = (a,b,c,d)，可以用a,b,c,d=my_tup1e这种形式将元组中的每个元素分别赋给变量a,b,c,d。

• 使用这种特性来交换变量

  x, y = 1, 2
  x, y = y, x
  

为列表添加元素有哪些方法？

列表操作中append()、insert()和extend()之间的区别：

• append(元素值)：将一个元素添加到列表的末尾。

  常见使用场景：当有一个新的单个元素需要添加到列表里，例如在读取文件行时将每行都添加到列表中。在这种情况下，每次调用append都添加一个单独的元素。

  ---

  O(1)，简单地再列表末尾增加元素

• insert(索引值，元素值)：在指定的位置插入一个元素。

  在需要在特定位置插入元素时非常有用，但一般来说，它的使用频率比append和extend要低，因为在中间插入元素会移动后面的元素，对性能可能产生一定影响。

  ---

  O(n)，尤其是再靠近列表开始的位置插入，需要依次将后面的元素移动。

• extend()：将另一个列表中的所有元素添加到当前列表的末尾。

  常见使用场景：需要将一个列表合并到另一个列表中，比如将多个子列表合并成一个大列表。

  ---

  假设列表1长度为m，列表2长度为n，要将列表2扩展到列表1上
  O(n)，取决于要扩展的子列表长度。

删除列表元素有哪些方法？

• remove(item)：从列表中删除第一个匹配到的项。注意，如果项不存在，会抛出ValueError。
• del：可以用于删除列表中的一个或多个元素，也可以用于删除变量。语法是del list[index]或del list[start:end]。它不会返回被删除的元素。
• pop([index])：默认删除并返回列表中的最后一项。如果指定索引，则删除并返回指定索引的项。如果索引不存在，会抛出IndexError。

应用场景：

• remove()适用于知道要删除某个具体值的场景，不适合要删除多个相同值的情况。
• del更灵活，适用于删除特定索引或范围内的元素，也能删除整个列表。
• pop()适用于需要删除某个索引的值并需要该值继续使用的场景。

性能考虑：

• remove() 查找元素并删除它，复杂度为O(n)，n是列表的长度。如果列表很长，删除会变慢；
• del 如果是删除单个元素，复杂度为O(1)。但如果是删除多个元素，则复杂度取决于范围的大小。
• pop() 若不指定索引，复杂度为O(1)；若指定索引，复杂度同样为O(n)，需遍历查找。

注意：

• 使用remove()和pop()需要确保元素或索引存在，否则会抛出错误。可以使用条件语句或异常处理机制来避免程序中断。
• del和pop()直接修改原列表，而remove()也会，但两个方法的实质操作不同，容易引发误解。
• 这些方法同样适用于多维列表，只需注意指定元素或索引的不同层级即可。

如何更改列表中的数据类型？

列表中的元素类型是可能各异的。有时可能需要将列表中的所有元素转换为相同的数据类型。

• 使用列表推导式结合类型转换函数（int()、str()、float()、bool()等）来实现

• 错误处理：转换过程中可能遇到无法转换的值，此时使用try...catch结构处理

  li_ = ['1', 'two', 3.5, True]
  
  def safe_trans(item):
      try:
          return int(item)
      except ValueError:
          return None  # 或者使用其它值
  
  int_li_ = [safe_trans(x) for x in li_]
  print(int_li_)  # [1, None, 3, 1]
  

  注意：当列表包含各种数据类型，比如混合了字符串、整数和布尔值，确保在类型转换时清楚地知道原始数据的特性和转换期望。例如，True转换为整数会得1，而False会得0；同理，浮点数接口转换为整型会只取其整数部分。

• 使用map()函数，对列表的每一个元素应用同一个函数，返回一个map对象（迭代器）

  li_ = ['1', 'two', 3.5, True]
  
  str_li_ = list(map(str, li_))
  print(str_li_)  # ['1', 'two', '3.5', 'True']
  

  使用列表推导式更加直观，而且可以方便处理嵌套列表的情况

介绍一下map()、filter()、和reduce()函数？

map(func, iteable, ...)函数在Python中是一种内置函数，主要作用是方便地对一个可迭代对象（如列表、元组等）中的每个元素应用一个指定的函数。返回的map对象是一个迭代器，使用list()函数将其转换为列表。

• 可以使用Python的匿名函数lambda来简化代码。

  li_ = [2, 3, 4]
  pow_li = list(map(lambda x: x ** 2, li_))  # [4, 9, 16]
  

• map函数也可以接受多个可迭代对象，它会将这些可迭代对象的元素分别传递给函数。例如，计算两个列表对应元素的和：

  li_ = [2, 3, 4]
  li_2 = [3, 4, 5]
  add_li = list(map(lambda x, y: x + y, li_, li_2))  # [5, 7, 9]
  

filter(func, iteable)函数用于根据特定的条件筛选序列中的元素，将序列中的每个元素传递给该函数并保留返回值为True的元素。最终返回一个过滤后的迭代器。

• 结合str.isdigit筛选列表中的数字字符串。

  strings =["hello","123","world","456"]
  digits = filter(str.isdigit, strings)
  print(list(digits))  # 输出：['123'，456']
  

• 惰性评估：filter返回的是一个迭代器，它是懒惰求值的。也就是说，它不会立即生成所有匹配的元素，而是在每次访问时动态生成，非常高效。
• map()和filter()结合：map()函数用于对可迭代对象的每个元素进行操作，而filter()函数侧是用来过滤不符合条件的元素。两者经常能配合使用。例如，先对列表的每个元素求平方，再保留其中大于10的元素：

  nums = [2, 3, 4, 5, 6]
  square_nums = map(lambda n: n ** 2, nums)
  filter_nums = filter(lambda x: x > 10, square_nums)  # [16, 25, 36]
  

reduce(参数1:func, 参数2:可迭代对象)函数主要用于对一个序列进行累积操作，它从functools模块导入。reduce()会依次将序列中的元素进行合并操作，最终得到一个单一的结果。

• 使用reduce()方法实现列表元素（数字）累加、累积操作。
• 实现字符串连接：

  from functools import reduce
  strs = ['I', 'like', 'Python']
  conn_str = reduce(lambda x, y: x + " " + y, strs)  # I like Python
  

• reduce()函数还可以接受一个初始值（如数字0或者''），以应对某些特殊的情况（如空列表）。
• 与map()和filter()组合使用，实现更复杂的需求（初始值设置为0）：

  from functools import reduce
  
  num_li = [2, 3, 4, 5]
  filter_li = filter(lambda x: x % 2 == 0, num_li)  # [2, 4]
  square_li = map(lambda n: n ** 2, filter_li)  # [4, 16]
  result = reduce(lambda x, y: x + y, square_li, 0)  # 20
  

Python中的字典用法有哪些？

Python的字典是一种可变、无序、键值对的数据结构。它允许我们通过键快速查找对应的值，键必须是唯一且不可变的（比如字符串、数字、元组等)，而值可以是任意的Python对象（例如字符串、数字、列表，甚至是另一个字典）。

基本用法包括：

• 使用大括号{}或dict()函数创建字典。
• 通过键来访问对应的值，也可以新增或修改元素。
• 使用del关键字或pop("key_name")方法。
• 使用for循环可以遍历字典的键、值或键值对。

  for key in my_dict:print(key)  # 仅遍历键
  for value in my_dict.values():print(value)  # 仅遍历值
  for key,value in my_dict.items():print(key,value)  # 同时遍历键和值
  

字典的方法

• get(key,default=None)：返回键对应的值，如果键不存在则返回默认值。
• keys()：返回字典所有键的视图。
• values()：返回字典所有值的视图。
• items()：返回键值对的视图。
• update([other])：用另一个字典或键值对更新当前字典。
• clear()：清空字典。

---

字典的应用场景

• 需要快速查找时，例如（爬虫数据）数据库存储。
• 需要关联数据存放时，例如存储学生信息（姓名为键，详细信息如年级、成绩为值)。
• 需要计数时，例如统计字符出现的次数。

Python中负索引的应用？

Python的负索引是一种用于从序列（如列表、元组、字符串等）末尾倒数访问元素的方式。负索引从-1开始，表示序列的最后一个元素，-2表示倒数第二个元素，以此类推。使用它可以更方便地访问序列未尾的元素，而不需要计算序列的长度。

• 逆序字符串

  str_te = "python"
  reverse_str = str_te[::-1]
  # 或者
  for i in range(-1, -len(str_te)-1, -1):
  	print(str_te[i], end="")
  

• 负索引在实际开发中的应用场景：比如获取文件路径中的文件名、截取URL的某部分内容等。例如：

  file_path = "/home/user/documents/file.txt"
  file_name = file_path.split("/")[-1]  # file.txt
  
  url = "https://example.com/documents/page.html"
  last_segment = url.split("/")[-1]  # page.html
  

Python 中 join() 和 split() 函数有什么区别？

1）split() 用于将字符串按指定的分隔符分割成列表。例如：

s = "hello,world"
lst=s.sp1it(",")  # 结果是['he11o','world']

split(sep=None,maxsplit=-1)：

• sep参数是分隔符，默认为None，表示以空白字符（空格、制表符、换行符等）作为分隔符
• maxsplit是分割次数，默认为-1，表示不限制分割次数。

---

用正则表达式re.split()进行更复杂的分割操作：

import re
s = "apple,orange;banana"
lst = re.split('[,;]',s)  # 结果是['apple','orange','banana']

2）join() 用于将列表中的元素连接成一个字符串，以指定的分隔符连接。例如：

lst = ['hello','world']
s=",".join(lst)  # 结果是"hel1o,world"

join(iterable)：

• iterable参数是可迭代对象（如列表、元组等），元素必须是字符串类型。

---

join()常用于生成以某字符分隔的字符串，例如文件路径、URL参数等：

paths = ['home','user','documents']
full_path = "/".join(paths)  # 结果是"home/user/documents"
params = {'param1':'value1','param2':'value2'}
query_string = "&".join([f"{k}={v}"for k,v in params.items()])  # "param1=value1&param2=value2"

---

• split()和join()都是用于处理字符串的内置方法，效率较高。
• 在处理较大数据和高操作时，尽量避免不必要的多次split()和join()，以改善性能。

Python是否区分大小写以及命名规则？

Python区分大小写。在Python中，变量名、函数名、类名，以及其他标识符如果大小写不同，它们会被视为不同的对象。

标识符是变量、函数、类、模块或其他对象的名称。Python对标识符的命名有一些基本的规则：

• 1）标识符只能包含字母（大写或小写）、数字和下划线(_)，但不能以数字开头。
• 2）标识符不能是Python的保留关键字。例如：False,class,finally,is,return等等。
• 3）标识符是区分大小写的。
• 4）标识符尽量具有描述性，便于代码阅读和维护。例如，total_sum比ts更易读。
• 5）遵循PEP8风格指南。例如，变量和函数名应使用小写字母加下划线的方式(snake_case)，类名应使用首字母大写的驼峰命名法(CamelCase)，常量名应全大写并用下划线分隔单词(SNAKE_CASE)。
• 6）加下划线变量_：单个下划线_在Python中通常用于临时变量或不需要记录的值，像是在列表生成式中用_来取代每一个不关心的值。

Python 中如何删除字符串中的空格？

• 1）str.rstrip()：删除字符串末尾的空格字符（包括空格、制表符等）。
• 2）str.strip()：删除字符串两边的空格字符（包括空格、制表符等）。
• 3）自定义字符删除：str.lstrip()、str.rstrip()和str.strip()方法可以接收可选参数，指定要移除的字符范围。例如：

  my_string = "xxHello,World!xx"
  trimmed_string = my_string.strip('x')  # 输出："Hel1lo,World!"
  

Python 中如何进行字符串大小写转换？

• 要将Python中的字符串转换为小写，可以使用字符串的lower()方法。语法：my_str.lower()
• upper()：将字符串中的所有字母转换为大写。
• capitalize()：将字符串的第一个字母转换为大写，其他字母转换为小写。
• title()：将字符串中的每个单词的首字母转换为大写。
• casefold()：这个方法类似于lower()，但转换的力度更强，例如德语的'β'会转换成'ss'。适用于处理国际化字符。

什么是Python中的zip函数？

Python中的zip()函数是一个在标准库中非常有用的函数，主要用于将多个可迭代对象（例如列表、元组等）“压缩"到一起，形成一个迭代器，每次迭代返回一个包含来自各个可迭代对象的元素的元组。简而言之，zip可以将很多行平铺的数据”拉链”起来，使其变成便于逐行访问的形式。

1ist1=[1,2,3]
1ist2=['a','b','c']
result = zip(list1,list2)
print(1ist(result))  # 输出[(1,'a'),（2,b'),（3,'c')]

# 可以通过”*"运算符进行反转
list1,list2 = zip(*result)

• 处理不同长度的可迭代对象：默认情况下，zip函数会在最短的输入可迭代对象耗尽时停止。如果有不同长度的数据集合，使用itertools.zip_longest可以方便地处理，这个函数会用指定的填充值填充较短的可迭代对象。例如：

  from itertools import zip_longest
  1ist1=[1,2,3]
  1ist2=['a',b']
  result = zip_longest(list1,list2,fillvalue='x')
  print(list(resu1t))  # 输出[(1,'a'),(2,'b'),(3,'x')]
  

• 应用场景：zip函数在数据处理、文件操作和多维数组转换等场景非常有用。例如，在读写CSV文件时，可能需要将多列数据拼接成行。此外，zip在处理矩阵运算、平行迭代等任务时也很常见。
• 兼容问题：虽然zip在大多数情况下表现非常稳定，但要注意在Python2和Python3之间存在一些差异。在Python2中，zp返回的是列表，而在Python3中返回的是迭代器。如果需要兼容Python2和3代码，可以使用list(zip(..))来强制将结果转为列表。
• 性能优化：在大数据处理场景下，考虑到内存使用，直接使用迭代器而不是列表可能是更优的选择。这时Python3的zip函数由于返回迭代器会更省内存。使用生成器(generator)等懒加载策略会有效提升性能。

Python的namedtuple有什么作用？怎么使用？

namedtuple是Python标准库collections模块中的一个工厂函数，用于创建具名元组，它可以让你像访问对象的属性一样访问元组元素。它的主要作用就是提高代码的可读性和可维护性。

使用方法如下：

1. 导入collections模块。
2. 使用namedtuple创建一个具名元组类。
3. 实例化具名元组对象并使用。

from collections import namedtuple
# 创建一个名为'Point'的具名元组类，它有两个字段：'x和'y'
Point = namedtuple('Point',['x','y']
# 创建一个Point对象
p = Point(10,20)
# 访问属性
print(p.x)  # 输出：10
print(p.y)  # 输出：20
#也可以像元组一样访问
print(p[0])#输出：10
print(p[1])#输出：20

1. 和普通元组的区别
   • 普通元组访问元素时需要通过索引，代码可读性较低；而具名元组通过属性名访问，代码更清晰。
   • 具名元组也可以通过索引访问元素，灵活性更高。
2. 可读性和可维护性
   • 具名元组的属性名让代码更具自解释性，特别是当元组有多个元素时，就算别人接手你的代码，通过属性名也能快速理解代码意图。
3. 命名空间
   • 具名元组可以通过_fields属性获取所有字段名，增强了元组的自描述能力。
   • 如需将具名元组转换为字典，可以使用_asdict方法，这对于序列化或传递数据非常有用。
4. 默认值
   • namedtuple默认实例化对象时必须传递所有字段值，但是可以利用_replace方法提供默认值的功能。

   Point = namedtuple('Point',['x','y','z']
   pt = Point(1,2,0) # z默认为0
   pt = pt._replace(z=3)
   prnt(pt)  # 输出：Point(x=1,y=2,z=3)
   

5. 子类化具名元组
   • 可以通过继承namedtuple来添加方法或增强功能。

   from collections import namedtuple
   class Point(namedtuple("Point", ["x", "y"])):
       __slots__ = ()
       def __str__(self):
           return f"Point ({self.x}, {self.y})"
   
   p = Point(1, 2)
   print(p)  # Point (1, 2)
   

Python中如何使用多进制数？

在Python中，多进制数字即是非十进制数字，包括二进制、八进制和十六进制。使用这些进制的表示方法如下：

• 二进制：通过前缀"0b”或"0B"表示，例如0b1010表示二进制的1010，等于十进制的10
• 八进制：通过前缀"0o"或"0O"表示，例如0o12表示八进制的12，等于十进制的10
• 十六进制：通过前缀"0x"或"0X”表示，例如0xA表示十六进制的A,等于十进制的10。

将其他进制转换为十进制：Python的int()函数可以带两个参数，第二个参数代表输入数字的进制（基数）。例如：

binary_num = '1010'
decimal_from_binary = int(binary_num,2)
print(decimal_from_binary) # 输出：10
octal_num = '12'
decimal_from_octal = int(octal_num,8)
print(decimal_from_octal) # 输出：10
hex_num = 'A'
decimal_from_hex = int(hex_num,16)
print(decimal_from_hex)  # 输出：10

将十进制转换为其他进制：可以使用bin(十进制数字)、oct和hex函数。例如：

无符号数与溢出：在处理不同进制时，如果要求较高的精度，可能需要特别注意可能的溢出问题。特别在硬件相关的编程中，需要了解无符号数的表示和计算方法。

什么是Python的位运算符？

位运算符是在二进制级别操作的运算符。Python支持以下几种主要的位运算符：

• 1）按位与(&)：对应位都为1时，结果是1，否则为0。
• 2）按位或(|)：对应位只要有一个为1，结果就是1。
• 3）按位异或(^)：对应位不同，结果为1，否则为0。
• 4）按位取反(~)：将所有位取反，即1变0，0变1，等价于-x-1。
• 5）左移(<<)：将二进制位左移指定的次数，右侧用0填充。
• 6）右移(>>)：将二进制位右移指定的次数，左侧用符号位填充（正数填充0，负数填充1）。

实际应用场景和一些进阶应用：

• 1）按位与(&)的应用：
  布尔图运算：用来提取一个数中的某些特定位。例如，0b1100&0b1010=b1000，它可以用来屏蔽某些特定位。

• 2)按位或(|)的应用：

  • 设置某些位为1：可以用于将特定位置1。例如，0b1100|b1010=b1110，有时会用在权限管理上。

• 3)按位异或(^)的应用：

  • 翻转特定位：在计算缓存校验和、加密解密等方面有广泛应用。例如，0b1100 ^ 0b1010 = 0b0110。

• 4）按位取反(~)的应用：

  • 在很多场景中用于快速求负数，~x等价于-x-1。例如，~0b1100会返回-0b1101,等价于-13。

  例如，对9按位取反的计算过程如下：
  （1）因为9是正数，计算机中正数的原码=反码=补码，所以9的补码为00001001
  （2）对正数9的补码00001001进行取反操作，取反后结果为补码11110110
  （3）（负数的原码为符号位不变，其他位取反，然后+1得到原码）将补码11110110取反得到11111001，+1得到最终结果为11111010，即-10。

  ---

  注意：负数在内存中以补码的形式保存，在按位与计算时，是按负数的补码形式进行计算。

• 5）左移(<<)和右移(>>)的应用：

  • 左移和右移主要用来实现快速运算，比如乘以二、除以二。例如
    ，0b1100 << 2 = 0b110000,相当于12乘以4得到48。同理，
    0b1100 >> 2 = 0b11，相当于12除以4得到3。

运算还有一些特定的优化技巧和进阶话题：
快速判断奇偶性：通过x&1，如果结果是1则为奇数，否则为偶数。
交换两个整数：可以通过x=x^y,y=x^y,x=x^y来进行交换而不需要额外变量。

如何在Python中管理内存？

Python中，内存管理主要依赖于自动内存管理机制，特别是垃圾回收机制。Python使用引用计数和垃圾回收相结合的方式管理内存，确保无需手动释放内存资源。

• 引用计数：Python通过引用计数来跟踪每个对象的引用次数。当引用数降为零时，Python会立即回收相关内存。sys.getrefcount(对象名)查看引用数。
• 垃圾回收：Python内置了一个垃圾回收器，专门处理引用循环的问题。例如两个对象彼此引用但都不再被需要时，引用计数无法释放它们，这时候垃圾回收机制就会发挥作用。

垃圾回收器的工作原理：垃圾回收器使用"分代收集"的机制，Python把对象按年龄分为三代：年轻代、中代、老代。每一代都有自己的垃圾收集频率，年轻代较频繁，老代较少。

import gc
gc.collect()  # 手动触发垃圾回收

---

内存池机制：Python使用内存池机制来减少内存分配和释放的开销。比如，小对象由私有的内存池（如PyObject_Malloc)管理，而大对象则由系统分配（如malloc和free）

---

内存泄漏检测与调优：通过工具和模块来检测和优化内存使用，主要用到以下工具：

• objgraph：用于分析和绘制对象引用图。
• memory_profiler：用于监测Python脚本的内存占用情况。
• tracemalloc：用于跟踪Python应用程序的内存分配情况。

import tracemalloc
tracemalloc.start()
# code
snapshot = tracemalloc.take_snapshot()
tracemalloc.stop()

---

内存优化技巧：

• 避免生成过多的短生命周期对象。
• 使用生成器（generator）代替列表来节省内存。
• 预分配内存空间，如使用__slot__来限制对象属性。
• 在处理大量数据时，利用numpy或者pandas这些高效内存管理库。

Python程序退出时，是否释放所有内存分配？

在Python程序退出时，不一定完全释放所有内存。虽然Python标准库的垃圾回收机制(Garbage Collector)会尝试回收不再使用的内存，但由于一些引用循环、外部C库的资源管理问题，某些内存可能无法被消费。
特别是在基于CPython的实现中，这种情况尤其明显。

扩展

• 1）Python的垃圾回收机制：上一节已经介绍。
• 2）循环引用的问题：循环引用是指两个或更多对象互相持有对方的引用，导致它们的引用计数永远不会归零。例如：A引用B，B引用A。Python的垃圾回收机制可以在程序运行中检测到这些循环引用并清除它们，但在程序终止时，并不保证有足够的时间处理所有循环引用。
• 3）外部资源和C库的管理：如果Python代码使用了外部的C库（例如通过ctypes或cffi)，那么这些C库可能分配了程序的一些内存。Python在退出时并不负责清理这些外部库分配的内存，需要依靠这些库本身提供的清理机制，否则就可能发生内存泄漏。
• 4）内存调试工具：开发者可以使用一些内存调试工具来检查内存释放情况，比如objgraph可以用于查找没有被正确回收的对象，gc模块可以根据需求手动启动垃圾回收器。此外，valgrind等工具可以用于检测C扩展中可能存在的内存泄漏。
• 5）内存管理策略：为了确保更好的内存管理，我们建议开发者使用上下文管理器来管理资源，比如使用with open()as file来确保文件操作后文件会自动关闭。此外，尽量减少全局变量的使用，及时清理不再需要的对象。

如何用Python实现汉诺塔问题？

利用递归栈可以容易实现Hanoi问题（整体移动与递归调用）：

• 重点在于设置递归基（递归出口）：考虑仅有一个需要移动的情况，之间从’A’移动到’C’即可。
• 无论有多少个需要移动的块，将上面的看作一个整体，移动到“辅助”柱’B’上，剩下底部的一个块又回到递归基的情况。
• 最后，设置移动块数-1，将整体移动到’C’即可。
  

def hanoi(n, a, b, c):
    if n == 1:  # 【递归基】
        print(f'{a} --> {c}')  # 从'A'柱移动到'C'柱
        return None
    hanoi(n-1, a, c, b)  # 将整体(多个视为一个)移动到'B'柱
    print(f'{a} --> {c}')  # 整体移动完剩下的一个（'A'柱上）移动到'C'柱 【递归基】
    hanoi(n-1, b, a, c)  # 将整体从'B'柱子移动到'C'柱， 【递归基】的情况

hanoi(3, 'A', 'B', 'C')

如何在Python中实现多线程？

请介绍Python中多线程和多进程的应用场景，以及优缺点？

请解释Python线程池的工作原理？