Python面经

文章目录

• Python
• • 基本概念
  • • 1. Python是**解释型**语言还是**编译型**语言
    • 2. Python是**面向对象**语言还是面向过程语言
    • 3. Python基本数据类型
    • 4.append和 extend区别
    • 5.del、pop和remove区别
    • 6. sort和sorted区别
    • 介绍一下Python 中的字符串编码
    • is 和 == 的区别
    • *arg 和**kwarg作用
    • 浅拷贝（Shallow Copy）&深拷贝（Deep Copy）
    • lambda

      Python

      持续更新中~

      
      （图片来源网络，侵删）

      基本概念

      1. Python是解释型语言还是编译型语言

      是解释型。解释型是边编译边执行。编译型语言是把源程序全部编译成二进制的可运行程序后再运行，如C/C++ 。

      注：java程序不是直接编译成机器语言，而是编译成字节码，然后用解释方式执行字节码。

      2. Python是面向对象语言还是面向过程语言

      是面向对象。面向对象编程（OOP）的特点包括：

      • 封装：将数据和操作这些数据的方法组合在一起。
      • 继承：允许新创建的类（子类）继承现有类（父类）的属性和方法。
      • 多态：允许不同类的对象对同一消息做出响应，但具体的行为会根据对象的实际类型而有所不同。

        面向过程编程的特点包括：

        • 将程序分解为一系列的过程或函数，每个过程或函数执行特定的任务。
        • 强调过程和函数的调用，而不是对象和类。

          3. Python基本数据类型

          • Numbers（数字）：3.7以后存储字节数会根据数字大小变化（28+48（num/230））
          • List（列表）：有序集合。多维列表本质就是列表里面叠列表
          • Tuple（元组）：有序集合。元组是只读的列表
          • Dictionary（字典）：无序集合，由键值对（key-value）组成。
          • 集合（set）：是一组 key 的集合，每个元素都是唯一，不重复且无序的。
            • a=(4)，a的类型为整数

              4.append和 extend区别

              • append()方法用于将一个对象添加到列表的末尾。当使用append()方法添加一个列表到另一个列表时，实际上是将整个列表作为一个单独的元素添加到原列表中。

              • extend()方法用于将一个可迭代对象（如列表、元组、字符串等）的所有元素添加到列表的末尾。使用extend()方法添加一个列表到另一个列表时，实际上是将这个列表中的所有元素逐个添加到原列表中。

                my_list = [1, 2, 3]
                my_list.extend([4, 5])  # 结果: [1, 2, 3, 4, 5]
                my_list.append([5, 6])  # 结果: [1, 2, 3, 4, [5, 6]]
                

                5.del、pop和remove区别

                • del：根据下标进行删除
                • pop：根据下标进行删除并返回删除值，默认删除最后一个元素
                • remove：根据元素的值进行删除

                  my_list = [1, 2, 3, 4, 5]
                  del my_list[2]  # my_list: [1, 2, 4, 5]
                  a=my_list.pop(0)  # my_list: [2, 4, 5], a: 0
                  my_list.remove(4)  # my_list: [2, 5]
                  

                  6. sort和sorted区别

                  • sorted()是一个内置函数，不会修改原始的序列，而是返回一个新的排序后的列表。不会修改原始的序列，而是返回一个新的排序后的列表。
                  • sort()是列表（list）的一个方法，它直接修改原列表，按照指定的顺序对列表中的元素进行排序。

                    my_list = [3, 1, 4, 1, 5]
                    my_list.sort()
                    print(my_list)  # 输出: [1, 1, 3, 4, 5]
                    sorted_list = sorted(my_list, reverse=True)  # 设置reverse为True进行降序排序
                    print(my_list)  # 输出: [1, 1, 3, 4, 5]
                    print(sorted_list)  # 输出: [5, 4, 3, 1, 1]
                    

                    reverse和reversed同理

                    my_list = [1, 2, 3, 4, 5]
                    reversed_iterator = reversed(my_list)
                    print(list(reversed_iterator))  # 输出: [5, 4, 3, 2, 1]
                    print(my_list)  # 原始列表未被修改: [1, 2, 3, 4, 5]
                    my_list.reverse()
                    print(my_list)  # 输出: [5, 4, 3, 2, 1]
                    

                    介绍一下Python 中的字符串编码

                    1. ASCII (American Standard Code for Information Interchange):

                       • 最早的字符编码标准，使用7位二进制数表示128个字符，包括英文大小写字母、数字和一些特殊符号。
                       • 由于只支持英文字符，因此不适合表示其他语言。

                       • Unicode:

                         • 为了解决ASCII编码的局限性，Unicode提供了一种可以表示世界上几乎所有文字的字符集。

                         • UTF-8 (8-bit Unicode Transformation Format):

                           • 是Unicode的一种实现方式，可以根据字符的不同使用不同长度(1-4)的字节来表示一个字符。

                           • UTF-8最大的特点是它对ASCII编码是兼容的，即ASCII字符在UTF-8中用一个字节表示，与ASCII编码相同。

                    • str.encode(): 将字符串编码为指定格式的字节串。
                    • bytes.decode(): 将字节串解码为字符串。

                      is 和 == 的区别

                      ==是比较操作符，只是判断对象的值（value）是否一致，而 is 则判断的是对象之间的身份（内存地址）是否一致。

                      对象的身份，可以通过 id() 方法来查看。

                      *arg 和**kwarg作用

                      • *args代表可变数量的位置参数（arguments），它允许你将不定数量的位置参数传递给函数。这些参数被组织为一个元组(tuple)，在函数内部可以通过索引来访问。

                      • **kwargs代表可变数量的关键字参数（keyword arguments），它允许你将不定数量的关键字参数传递给函数。这些参数被组织为一个字典(dictionary)，在函数内部可以通过键来访问。

                        def my_function(*args, **kwargs):
                            for arg in args:
                                print(arg)
                            for key, value in kwargs.items():
                                print(f"{key}: {value}")
                        my_function(1, 2, name="Alice", age=25)
                        # 输出: 1, 2, name: Alice, age: 25
                        

                        浅拷贝（Shallow Copy）&深拷贝（Deep Copy）

                        • 浅拷贝复制的是原始对象中包含的引用，而不是对象本身。
                        • 深拷贝递归地复制了原始对象中的所有对象。这意味着深拷贝会创建原始对象的完整副本，包括所有嵌套的对象，修改原始对象不会影响深拷贝。

                          import copy
                          original_list = [[1, 2, 3], [4, 5, 6]]
                          shallow_copied_list = copy.copy(original_list)
                          # 浅拷贝
                          original_list[0][0] = 'X'
                          print(shallow_copied_list)  # 输出: [['X', 2, 3], [4, 5, 6]]
                          # 深拷贝
                          deep_copied_list = copy.deepcopy(original_list)
                          original_list[0][0] = 'X'
                          print(deep_copied_list)  # 输出: [[1, 2, 3], [4, 5, 6]]
                          

                          lambda

                          lambda是一个用于创建匿名函数的关键字。匿名函数是一种没有名称的函数，它们通常用于需要函数对象的地方，但又不想去定义一个完整的函数。

                          people = [("Alice", 30), ("Bob", 25), ("Charlie", 35)]
                          sorted_people = sorted(people, key=lambda person: person[1])
                          print(sorted_people)  # 输出: [('Bob', 25), ('Alice', 30), ('Charlie', 35)]
                          def num():
                              return [lambda x:i*x for i in range(4)]
                          [m(1) for m in num()]  # 输出: [3, 3, 3, 3]