Python基础80题

1、Python 和 java 对比

  1. python
  • 解释型：Python是一种解释型语言，这意味着代码直接由解释器执行，不需要编译。这可能使Python比像Java这样的编译语言慢，但也让它更灵活，更容易被使用。
  • 动态类型化：Python是动态类型的，这意味着变量在运行时可以被分配不同类型的值。这使编写和调试代码更容易。但如果变量的类型管理不当，也可能导致运行时错误
  • 静态类型化：Java是静态类型的，这意味着在使用变量之前，必须用特定的数据类型来声明它们，这样在编译时更容易发现错误，但它也会使代码更难读和写。
  • 编译的：Java是一种编译语言，这意味着代码在执行之前被翻译成机器代码。这让Java比Python等解释型语言更快、更有效。

2、python默认最大的递归层数

  • 998。 可以通过sys.setrecursionlimit()进行设置,但是一般默认不会超过3925-3929这个范围。

3、python2和3的区别

  • 键盘输入的区别。从键盘录入一个字符串，python2中是 raw_input( "hello world" )，python3则是 input( "hello world" )。
  • Python3去除print语句，加入print()函数实现相同的功能。

4、*args和*kwargs的作用

  • args通常被用作发送一个非键值对的可变数量的参数列表给一个函数。args可以接收任意多个参数并把这些参数作为元组传递给函数。args以元组的形式传递，是没有key值的。
  • kwargs存储可变的关键字参数，允许使用没有事先定义的参数名，将接收到任意多个关键字参数作为字典传递给函数。**kwargs是以字典的形式传递，有key值。

5、字符串、列表、元组、字典每个常用的5个方法？

  1. 字符串 (str)
    str.upper()：将字符串中的所有字符转换为大写。
    str.lower()：将字符串中的所有字符转换为小写。
    str.split()：将字符串按指定分隔符分割成列表。
    str.strip()：去除字符串两端的空白字符。
    str.replace(old, new)：将字符串中的某个子字符串替换为另一个子字符串。
  2. 列表 (list)
    list.append(x)：在列表末尾添加一个元素 x。
    list.remove(x)：移除列表中第一个匹配的元素 x。
    list.pop([i])：移除并返回列表中指定位置的元素，默认为最后一个元素。
    list.sort()：对列表中的元素进行排序（原地排序）。
    list.reverse()：反转列表中的元素（原地反转）。
  3. 元组 (tuple)
    tuple.count(x)：返回元组中元素 x 的出现次数。
    tuple.index(x)：返回元组中第一个匹配元素 x 的索引。
    tuple + tuple：连接两个元组。
    tuple * n：将元组重复 n 次。
    len(tuple)：返回元组的长度。
  4. 字典 (dict)
    dict.get(key)：返回指定键 key 对应的值，如果键不存在则返回 None。
    dict.keys()：返回字典中所有的键。
    dict.values()：返回字典中所有的值。
    dict.items()：返回字典中所有的键值对。
    dict.update(other_dict)：将 other_dict 中的键值对更新到当前字典中。

6、is和==的区别

  • == 用于比较对象的 值 是否相等。
  • is 用于比较对象的 身份 是否相同，判断是否是同一个对象。

7、lambda表达式格式以及应用场景

lambda 表达式是一个匿名函数，它可以在一行中定义一个简单的函数。其基本格式如下：
lambda arguments: expression
arguments：函数的输入参数，可以有多个，参数之间用逗号分隔。
expression：函数体，是一个单一的表达式，返回这个表达式的值。

一个简单的lambda表达式，表示加法运算
add = lambda x, y: x + y
print(add(3, 4))  # 输出 7

常见的 lambda 应用场景：

在函数式编程中作为回调函数：
lambda 表达式常用于作为参数传递给函数，特别是用于高阶函数如 map()、filter()、sorted() 等。
使用lambda和map函数将列表中的每个元素加倍
numbers = [1, 2, 3, 4]
doubled = list(map(lambda x: x * 2, numbers))
print(doubled)  # 输出 [2, 4, 6, 8]

排序操作：
lambda 可以与 sorted() 或 sort() 等函数一起使用，指定排序规则。
按字典的值进行排序
my_dict = {'a': 3, 'b': 1, 'c': 2}
sorted_dict = sorted(my_dict.items(), key=lambda x: x[1])
print(sorted_dict)  # 输出 [('b', 1), ('c', 2), ('a', 3)]

条件判断：
lambda 表达式可以用在条件判断中，简洁地写出条件表达式。
根据条件返回不同的值
check_even = lambda x: "Even" if x % 2 == 0 else "Odd"
print(check_even(4))  # 输出 "Even"
print(check_even(5))  # 输出 "Odd"

8、pass的作用

  • pass主要作用就是占位，让代码整体完整。如果定义一个函数里面为空或一个判断写好了之后还没想好满足条件需要执行执行什么逻辑，又想留着后面使用，但是函数和判断里面为空，那么就会报错，当你还没想清楚函数内部内容，就可以用pass来进行填坑。

9、简述Python的深浅拷贝以及应用场景？

  • 浅拷贝：仅复制外层对象，嵌套对象仍然引用原始对象。适用于不需要独立嵌套对象的场景，性能较好。
  • 深拷贝：递归地复制对象及所有嵌套对象，创建完全独立的副本。适用于需要完全独立对象的场景，性能较差。

10、Python的可变类型和不可变类型？

  1. 可变类型 指的是 对象创建后可以修改，修改对象不会改变其内存地址。
  2. 不可变类型 指的是 对象创建后不能修改，如果修改变量的值，会创建一个新的对象，而不是在原对象上修改。
  • 可变：list，dict，set
  • 不可变：数值型int，str，元组tuple，bool

11、列举常见的内置函数？

  • range（）返回一个可迭代对象，通常与list()函数或者for循环语句搭配使用
  • input()
  • sorted()
  • abs()
  • round() 是又一个处理数值的内置函数，它返回浮点数x的四舍五入值
  • reversed() 返回一个反转的迭代器，要转换的序列，可以是元祖、字符串、列表或者range
  • abs()
点击查看代码 
dict()        help()         min()         setattr()  
all()           dir()         hex()          next()        slice()   
any()           divmod()      id()           object()      sorted()   
ascii()         enumerate()   input()        oct()         staticmethod()   
bin()           eval()        int()          open()        str()   
bool()          exec()        isinstance()   ord()         sum()   
bytearray()     filter()       issubclass()   pow()         super()   
bytes()         float()        iter()         print()       tuple()   
callable()      format()      len()          property()    type()   
chr()           frozenset()   list()         range()       vars()   
classmethod()   getattr()     locals()       repr()        zip()   
compile()       globals()     map()          reversed()    __import__()   
complex()       hasattr()     max()          round()   
delattr()       hash()        memoryview()   set()

12、filter、map、reduce的作用？

1. filter()

  • filter() 用于从可迭代对象中筛选出符合条件的元素，返回一个迭代器，其中包含所有满足条件的元素。条件是由一个函数决定的，函数返回 True 或 False，filter() 只保留返回 True 的元素。
    ** 语法：**
filter(function, iterable)
function：用于判断每个元素是否符合条件的函数，返回布尔值 (True 或 False)。
iterable：待筛选的可迭代对象（如列表、元组等）。

使用filter筛选出所有偶数
numbers = [1, 2, 3, 4, 5, 6]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)  # 输出 [2, 4, 6]

2. map()

  • map() 用于将给定函数应用到可迭代对象的每个元素上，并返回一个新的迭代器，包含应用函数后的结果。它并不会修改原始的可迭代对象，而是返回一个新的迭代器。
    语法：
map(function, iterable)
function：将应用于可迭代对象每个元素的函数。
iterable：待处理的可迭代对象（如列表、元组等）。

# 使用map将列表中的每个元素平方
numbers = [1, 2, 3, 4, 5]
squared_numbers = list(map(lambda x: x ** 2, numbers))
print(squared_numbers)  # 输出 [1, 4, 9, 16, 25]

3. reduce()

  • reduce() 用于对可迭代对象中的元素进行累计操作，最终返回一个单一的结果。它从可迭代对象的第一个元素开始，依次与后面的元素做累计操作，并将结果传递给下一个元素，直到遍历完整个可迭代对象。
    语法：
from functools import reduce
reduce(function, iterable[, initializer])
function：用于将前两个元素累计为一个值的函数。
iterable：待累计操作的可迭代对象。
initializer（可选）：如果提供，它会作为初始值传递给函数。

from functools import reduce
# 使用reduce求列表中所有元素的和
numbers = [1, 2, 3, 4, 5]
sum_result = reduce(lambda x, y: x + y, numbers)
print(sum_result)  # 输出 15

13 、简述 生成器、迭代器、可迭代对象 以及应用场景

特性	生成器	迭代器	可迭代对象
定义	使用 yield 生成惰性序列	实现了 __iter__() 和 __next__()	实现了 __iter__()
产生的对象类型	生成器对象（是迭代器）	迭代器	可迭代对象（需要转化为迭代器）
迭代方式	逐次生成（按需计算）	通过 next() 迭代	通过 iter() 转化为迭代器
记忆状态	记住上次 yield 的状态	不会保持状态	需要转化为迭代器才可迭代

14、是否使用过functools中的函数？其作用是什么？

  1. functools 是 Python 的一个标准库模块，提供了一些高阶函数，用于函数式编程、提高函数的灵活性和可重用性。它包含多个非常有用的函数，特别是在处理函数、迭代器、装饰器等方面。
  • partial：用于固定函数的一部分参数，简化函数调用。
  • lru_cache：缓存函数结果，提高性能。
  • reduce：将一个二元函数作用于可迭代对象，返回一个单一结果。
  • wraps：确保装饰器不会改变原函数的元数据。
  • total_ordering：自动生成比较方法，减少手动编写代码。

15、isinstance作用以及应用场景？

isinstance() 是 Python 中的一个内置函数，用于判断一个对象是否是某个特定类或类的实例，或者是否是该类的子类的实例。它的主要作用是进行类型检查，确保对象符合特定的类型要求。
isinstance() 的语法：
isinstance(object, classinfo)
object：需要检查的对象。
classinfo：可以是一个类类型，也可以是一个由多个类构成的元组

16、闭包

  • 函数嵌套：在外部函数中定义内部函数。
  • 自由变量：内部函数使用了外部函数的变量，这些变量在外部函数执行后依然可用。
  • 返回内部函数：外部函数返回内部函数作为结果。

17、os和sys，re，datetime，collections模块的作用？

  1. os 模块的作用
    os 模块提供了与操作系统交互的功能，包括文件和目录的操作、进程管理、环境变量、路径操作等。
  2. sys 模块的作用
    sys 模块提供了与 Python 解释器和系统相关的功能，主要用于处理与 Python 运行环境有关的操作，例如：命令行参数、标准输入输出、Python 环境等。
  3. re
    正则表达式处理：
  • re.match(pattern, string)：从头匹配。
  • re.search(pattern, string)：全局搜索。
  • re.findall(pattern, string)：查找所有匹配项。
  1. datetime
    日期和时间处理：
  • datetime.datetime.now()：获取当前日期时间。
  • datetime.datetime.strptime()：字符串转日期。
  • datetime.datetime.strftime()：日期转字符串。
  1. collections
    提供高级数据结构：
  • collections.Counter：计数器。
  • collections.defaultdict：带默认值的字典。
  • collections.namedtuple：具名元组。

18、random 模块来生成随机数。

19、静态方法和类方法区别？

  1. 静态方法（staticmethod）
    静态方法是与类绑定而不是与实例绑定的方法。它不需要访问类或实例的属性或方法，因此它不会自动接收类或实例作为第一个参数（如 self 或 cls）。静态方法是独立的，通常用于执行一些与类逻辑相关但不依赖于类或实例的功能。
    特点：
    静态方法不会接收隐式的 self 或 cls 参数。
    可以在没有创建类实例的情况下调用静态方法。
    静态方法不能访问类的属性和实例的属性。
class MyClass:
    @staticmethod
    def greet(name):
        print(f"Hello, {name}!")

# 调用静态方法
MyClass.greet("Alice")  # 输出: Hello, Alice!
  1. 类方法（classmethod）
    类方法是与类绑定的方法，而不是与实例绑定。类方法接收类本身作为第一个参数（通常命名为 cls），因此它可以访问类的属性和方法。类方法通常用于对类进行一些操作，或者在没有实例的情况下访问类的状态。

** 特点：**
类方法会自动接收类作为第一个参数（cls）。
类方法可以访问类的属性和方法，但不能访问实例的属性和方法。
类方法可以通过类本身或类的实例调用。

class MyClass:
    class_variable = "I am a class variable"
    
    @classmethod
    def show_class_variable(cls):
        print(cls.class_variable)

# 调用类方法
MyClass.show_class_variable()  # 输出: I am a class variable

# 也可以通过实例调用
obj = MyClass()
obj.show_class_variable()  # 输出: I am a class variable

20、单例模式

单例模式（Singleton Pattern）是一种常用的设计模式，确保一个类只有一个实例，并提供全局访问点。在 Python 中，可以通过多种方法实现单例模式。下面我将介绍尽量多的方法来实现这一设计模式。

  1. 使用类变量
    这是最简单和直接的方法之一，通过类变量来存储单例实例。
class Singleton:
    _instance = None
    
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super(Singleton, cls).__new__(cls)
        return cls._instance

# 测试
s1 = Singleton()
s2 = Singleton()
print(s1 is s2)  # 输出 True，两个实例是相同的
  1. 使用装饰器
    可以使用装饰器来封装类的实例化过程，确保类只有一个实例。
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 Singleton:
    pass

# 测试
s1 = Singleton()
s2 = Singleton()
print(s1 is s2)  # 输出 True
  1. 使用模块级别的单例
    在 Python 中，模块是天然的单例，因为模块只会被导入一次，因此也可以通过模块级别的变量来实现单例模式。
# singleton_module.py
class Singleton:
    pass

singleton_instance = Singleton()

# 测试
from singleton_module import singleton_instance
s1 = singleton_instance
s2 = singleton_instance
print(s1 is s2)  # 输出 True

21、异常处理写法以及如何主动跑出异常（应用场景）

在 Python 中，异常处理是通过 try、except、else 和 finally 语句来实现的。这些语句帮助你捕获和处理程序中的错误，避免程序崩溃。你还可以使用 raise 语句主动抛出异常来控制错误的发生和处理。

  1. 异常处理写法
try:
    # 可能抛出异常的代码
    x = 1 / 0  # 这里会抛出 ZeroDivisionError 异常
except ZeroDivisionError as e:
    # 处理捕获的异常
    print("Error:", e)
else:
    # 如果没有异常，执行这部分
    print("No error occurred.")
finally:
    # 不管是否发生异常，都会执行这部分
    print("This will always run.")
  • 数据验证：确保函数接收到的参数类型和范围是正确的。
  • 例如，用户输入的内容需要进行验证，如果不符合要求，则抛出异常。
  • 文件操作：在处理文件时，检查文件是否存在，或者文件是否可以正常读取。如果发现问题，可以抛出异常。
  • 网络请求：在网络操作中，捕获异常以处理连接错误、超时等问题。
  • 操作系统接口：在与操作系统交互时（如文件读写、进程管理等），异常处理可以帮助你捕获权限错误、路径错误等。

22、上下文管理器 with

with 语句是 Python 中的一种上下文管理器，用于简化资源管理（如文件、网络连接、数据库连接等）的操作。它可以自动处理资源的获取和释放，尤其是在涉及需要清理的资源时（如关闭文件或释放锁）。使用 with 可以确保即使发生异常，资源也能正确地被释放。
1. 基本用法
with 语句常常与上下文管理器一起使用。上下文管理器是一个对象，它定义了 enter() 和 exit() 方法，前者在进入 with 语句块时执行，后者在退出时执行。

# 使用 with 打开文件
with open('example.txt', 'r') as file:
    content = file.read()
    print(content)

在这个例子中：

  • open('example.txt', 'r') 打开文件并返回一个文件对象，它是一个上下文管理器。
  • with 语句会自动调用文件对象的 enter() 方法来获取文件资源，执行 with 块中的代码。
  • with 块结束时，自动调用文件对象的 exit() 方法，文件会被关闭，无需显式调用 file.close()。
    ** 2. 自定义上下文管理器**
    你可以通过实现 enter() 和 exit() 方法来创建自定义的上下文管理器。自定义上下文管理器可以管理自己的资源（如数据库连接、网络套接字等）。

示例：自定义上下文管理器

class MyContextManager:
    def __enter__(self):
        print("Entering the context...")
        return self  # 这里可以返回一个对象或资源
    
    def __exit__(self, exc_type, exc_value, traceback):
        print("Exiting the context...")
        if exc_type:
            print(f"An exception occurred: {exc_value}")
        return True  # 如果返回 True，则不会抛出异常

# 使用自定义的上下文管理器
with MyContextManager() as cm:
    print("Inside the context")
    # 你可以在这里放置可能抛出异常的代码
    # 如果抛出异常，__exit__ 方法将会处理它
    raise ValueError("Something went wrong!")
输出：
Entering the context...
Inside the context
Exiting the context...
An exception occurred: Something went wrong!

23、 列举面向对象中带爽下划线的特殊方法，如：new、init

init

  • 构造函数，用于初始化对象属性。
  • 调用时机：对象创建完成后自动调用。
  • 常用于赋值实例变量。
class Example:
    def __init__(self, value):
        self.value = value
obj = Example(10)
print(obj.value)  # 10

new

  • 实例化方法，用于创建对象本身。
  • 调用时机：实例化时最先被调用（在 __init__ 之前）。
  • 常用于控制对象的创建过程。
class Example:
    def __new__(cls, *args, **kwargs):
        print("Creating instance")
        instance = super().__new__(cls)
        return instance

    def __init__(self, value):
        print("Initializing instance")
        self.value = value

obj = Example(10)

输出：

Creating instance
Initializing instance

区别

  • __new__：负责创建实例，是一个类方法。
  • __init__：负责初始化实例，是一个实例方法。

24、什么是负载均衡

  • 负载均衡（Load Balancing）是一种将网络流量、请求或工作负载分配到多个服务器或计算资源上的技术。其目的是提高系统的性能、可靠性和可扩展性。
    在一个高流量或高负载的网络环境中，单个服务器可能无法处理所有的请求或工作负载。负载均衡通过将流量分发到多个服务器上，使得每个服务器都能够平均分担负载，从而提高整个系统的处理能力。

  • 负载均衡可以通过多种方式实现，常见的有以下几种：

  1. 基于网络层的负载均衡：通过在网络层（如路由器、交换机）上进行流量分发，将请求分发到不同的服务器上。常见的协议有基于IP的负载均衡（如Round Robin、Least Connections）和基于DNS的负载均衡（如DNS轮询、DNS解析返回多个IP地址）。
  2. 基于应用层的负载均衡：通过在应用层（如负载均衡设备、反向代理服务器）上进行流量分发，根据请求的内容、协议或其他特征将请求分发到不同的服务器上。常见的协议有HTTP、HTTPS、SMTP等。
  • 负载均衡的优势：
  1. 提高系统性能：通过将流量分发到多个服务器上，可以提高系统的处理能力和响应速度，减少单个服务器的负载压力。
  2. 提高系统可靠性：当某个服务器发生故障或不可用时，负载均衡可以自动将流量转移到其他可用的服务器上，保证系统的可用性和稳定性。
  3. 实现可扩展性：通过添加更多的服务器，负载均衡可以实现系统的水平扩展，满足不断增长的流量和负载需求。
posted @ 2024-12-11 16:29  XieBuWan  阅读(9)  评论(0)    收藏  举报