当前位置： 首页 > news >正文

哪些网站可以做帮助文档,全国网站建设汇编,wordpress 维文版,wordpress新建阅读量字段1 解释型和编译型语言的区别 解释是翻译一句执行一句#xff0c;更灵活#xff0c;eg#xff1a;python; 解释成机器能理解的指令#xff0c;而不是二进制码 编译是整个源程序编译成机器可以直接执行的二进制可运行的程序#xff0c;再运行这个程序 比如c 2 简述下 Pyth…1 解释型和编译型语言的区别 解释是翻译一句执行一句更灵活egpython; 解释成机器能理解的指令而不是二进制码 编译是整个源程序编译成机器可以直接执行的二进制可运行的程序再运行这个程序 比如c 2 简述下 Python 中的字符串、列表、元组和字典和集合 在 Python 中字符串、列表、元组、字典和集合是常用的数据结构每种结构都有其独特的特性和用途。 字符串 (String): ’ ’ 字符串是由字符组成的序列。在 Python 中字符串是不可变的这意味着一旦创建了一个字符串就不能修改它。字符串可以用单引号 ( ) 或双引号 ( ) 包围。示例: hello 或 world 列表 (List): [ ] 列表是一个有序的元素集合元素可以是任意类型整数、浮点数、字符串、另一个列表等。列表是可变的可以添加、删除或修改其中的元素。列表使用方括号 ([ ]) 创建。示例: [1, 2, 3, apple, [4, 5]] 元组 (Tuple): 元组与列表类似也是一个有序的元素集合但元组是不可变的。元组使用圆括号 (( )) 创建但空元组可以用单独的一个逗号创建如 t () 或 t ,。由于元组不可变它们在某些情况下比列表更高效。示例: (1, 2, 3, banana) 字典 (Dictionary): {} 字典是一个无序的键值对集合。每个键在字典中都是唯一的并与一个值相关联。字典使用大括号 ({ }) 创建键和值之间用冒号 (:) 分隔。字典是可变的可以增加、删除或修改键值对。示例: {name: Alice, age: 30} 集合 (Set): {} 集合是一个无序的、不重复的元素集合。集合使用大括号 ({ }) 创建但注意空集合必须使用 set() 函数创建而不是 {}这会创建一个空字典。集合支持数学运算如并集、交集、差集等。示例: {1, 2, 3, 4, 5}
有序元组 列表 唯一的集合、字典 不可变元组 3 简述上述数据类型的常用方法 字符串 切片[1:3] 格式化print(“Hello, {}! Today is {}.”.format(“Alice”, “Monday”)) 连接 a.join(b) 替换 ‘ddd’.repalce(‘d’,‘a’) 分割 .split(,) #用逗号分割列表 切片 添加元素 .append() .extend() 删除 del list[0] #下标 list. pop() # 最后一个元素 list.remove© # 元素 排序 sort 反转 reverse 字典 清空 .clear() 遍历 key for key in dict 新建 .formkeys(keyname, valuves) 4 简述 Python 中的字符串编码 UTF-8 是隶属于 Unicode 的可变长的编码方式。 在 Python 中以 Unicode 方式编码的字符串可以使用 encode() 方法来编码成指定的 bytes也可以通过 decode()方法来把 bytes编码成字符串。 你好.encode(utf-8) b\xe4\xbd\xa0\xe5\xa5\xbdb\xe4\xb8\xad\xe6\x96\x87.decode(utf-8) 你好5 一行代码实现数值交换 a, b b, a 6 is 和 的区别 is是判断对象的id内存地址是否一致判断值 可以理解为 是 和 等于 的区别 7 Python 函数中的参数类型 Python 函数的参数类型可以分为几种包括 位置参数Positional Arguments 这些参数必须按顺序提供并且不能使用参数名来指定。 默认参数Default Arguments 函数定义时可以为参数指定默认值。如果没有为这些参数提供值则使用默认值。 关键字参数Keyword Arguments 这些参数在调用函数时使用参数名指定这允许以任何顺序传递参数。 可变位置参数Variable Positional Arguments变的是数量 使用*表示可以接收任意数量的位置参数这些参数被存储在元组中。 可变关键字参数Variable Keyword Arguments 使用**表示可以接收任意数量的关键字参数这些参数被存储在字典中。 类型注解Type Hints Python 3.5 引入了类型注解允许开发者指定参数预期的数据类型但这不会对类型进行检查只是作为提示。
下面是一些示例来说明这些参数类型 # 类型注解 def calculate(a: int, b: int, operator: str) - int:if operator :return a belif operator -:return a - bresult calculate(5, 3, )在实际编程中使用默认参数和可变参数可以增加函数的灵活性。关键字参数和类型注解则可以提高代码的可读性和可维护性。类型注解在现代Python开发中越来越受欢迎尤其是在大型项目和团队协作中它们帮助工具和IDE进行类型检查从而减少错误。 8 *arg 和 kwarg 作用 可变位置和可变关键字只数量可变。*arg 会把位置参数转化为 tuplekwarg 会把关键字参数转化为 dict。 def test(*arg, kwarg): … if arg: … print(arg:, arg) … if kwarg: … print(kearg:, kwarg) …test(ni, hao, keyworld) arg: (ni, hao) kearg: {key: world} 9 获取当前时间 import timeimport datetimeprint(datetime.datetime.now()) 2022-09-12 19:51:24.314335print(time.strftime(%Y-%m-%d %H:%M:%S)) 2022-09-12 19:51:24 10 PEP8 规范 PEP 8 是 Python 的官方编码风格指南它提供了关于如何编写清晰、可读性强的 Python 代码的指导。以下是 PEP 8 中一些关键的规范 缩进4 使用 4 个空格进行缩进。 行宽 每行代码尽量不超过 79 个字符这样可以在不同的设备上查看代码时不需要水平滚动。 空行2 在函数定义之间使用两个空行。在类定义之间也使用两个空行但在类的方法定义之间使用一个空行。 导入1 每个导入应该独占一行。应该将 import 分为三部分标准库导入、相关第三方导入、本地应用/库特定导入。 变量命名小下划大是类 使用小写字母和下划线分隔的方式命名变量和函数snake_case。使用首字母大写的方式命名类CamelCase。 表达式和语句 不要在一行内写过多的语句。避免使用复杂的表达式尽量保持简单。 编码 代码应该默认使用 UTF-8 编码。 错误和异常 使用 raise 来引发异常而不是 raise Exception()。 代码注释 对复杂的操作进行注释解释为什么代码要这么做。 类型注解 从 Python 3.5 开始可以使用类型注解来提高代码的可读性和健壮性。 函数和方法 函数参数应该以单个空格分隔。函数应该完成一个单一的任务。 命名空间 避免使用全局变量。 布尔上下文 在布尔上下文中不要使用 if x: 这样的语句除非 x 明显是一个布尔值。 序列 使用列表推导式来创建列表。[expression for item in iterable if condition],其中iterable一个可迭代对象比如列表、元组、字典等。even_numbers [x for x in range(20) if x % 2 0] # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]squares_dict {x: x2 for x in range(5)} # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16} 元组 单元素元组应该包含一个尾随逗号例如 (a,)。 字典 键值对应该使用等号 分隔多个键值对之间用逗号分隔。 比较 使用 来检查对象的相等性使用 is 来检查对象的同一性。 字符串 使用一致的方式表示字符串通常是单引号 或双引号 。
PEP 8 只是一个指南并不是强制的规则。但在 Python 社区中遵循 PEP 8 可以使得代码风格统一提高代码的可读性。此外可以使用工具如 flake8 或 pylint 来检查代码是否符合 PEP 8 的规范。 Python 的深浅拷贝被问到 了一问一个不吱声大哭 先了解一下引用通过一个名字来用一个对象举例 a [1,2],此时a就是列表[1,2]这个对象的引用。如果b ab是列表[1,2]这个对象的另一个引用当我改变a的值b也会变。 所以变量名是对象的引用b这个新变量并没有创建新的实例而是指向同一个对象的新引用。 了解了引用再来看浅拷贝。 浅拷贝copy.copy 拷贝前后的列表只有外层独立内里嵌套列表还是共享的你变他也变。对于内层只复制了元素的引用没有复制元素本身两个都指向同一个对象。而外层对象是一个新的对象这个新的列表顶层对象包含了对子列表对象的引用比如下面的[1, 2, 3, [1, 2]]是新对象[1,2,3,[子列表对象的引用即12]] import copylist1 [1, 2, 3, [1, 2]]list2 copy.copy(list1)list2.append(a)list2[3].append(a)list1 [1, 2, 3, [1, 2, a]]list2 [1, 2, 3, [1, 2, a], a] 深拷贝copy.deepcopy 拷贝前后完全独立深深断联互不相干。因为复制的是元素本身生成的是新对象。 import copylist1 [1, 2, 3, [1, 2]]list3 copy.deepcopy(list1)list3.append(a)list3[3].append(a)list1 [1, 2, 3, [1, 2]]list3 [1, 2, 3, [1, 2, a], a] 深拷贝比浅拷贝更消耗资源因为它需要创建更多的对象。 12 [lambda x:i*x for i in range(4)]
首先lambda 匿名函数为啥用 只有一行的函数省去定义过程不需要重复使用的用完立即释放。 其次闭包。定义是在内部函数里引用了外部函数局部作用域的变量使外层函数已经执行完毕。闭包可以访问创建时的环境状态。闭包函数是指当前函数用到上一层函数的局部作用域的变量时触发了闭包规则的函数。注意只有在内部函数被调用时才去引用外部变量没被调用时变量命名空间还不存在哩。 回看[lambda x:i*x for i in range(4)]i是外层作用域lambda x:ix是内层函数在构建列表推导式时对于每一个i都创建一个ix就是[ix,ix,ix,ix]此时i 3所以内部的i*x还没开始计算也就是lambda x内部还没被调用i的递归只是创建了4个lambda 表达式。每个 lambda 表达式中的i只是对外部变量的引用 def num(): … return [lambda x:i*x for i in range(4)] #返回的是一个函数列表[3x,3x,3x,3x] …[m(1) for m in num()] #对于函数列表中的每一个函数,赋值参数为1 [3, 3, 3, 3] 想要解决确保了每个 lambda 表达式捕获了 i 的一个独立副本变局部作用域为闭包作用域局部作用是执行完毕就会被销毁闭包作用域是外部已经执行完毕了内部还可以访问外部的变量的值。 def num(): … return [lambda x, i i : ix for i in range(4)]13 打印九九乘法表 for i in range(1, 10): … for j in range(1, i 1): … print(f{i}{j}{i * j}, end ) … print() … 1*11 2*12 2*24 3*13 3*26 3*39 4*14 4*28 4*312 4*416 5*15 5*210 5*315 5*420 5*525 6*16 6*212 6*318 6*424 6*530 6*636 7*17 7*214 7*321 7*428 7*535 7*642 7*749 8*18 8*216 8*324 8*432 8*540 8*648 8*756 8*864 9*19 9*218 9*327 9*436 9*545 9*654 9*763 9*872 9*981 print函数默认是会换行的其有一个默认参数 end; range左闭右开打印一个下三角。 14 filter、map、reduce 的作用 reduce 递归遍历了每个元素返回一个值用一行代码解决求和、最大值、

1. 为什么不建议函数的默认参数传入可变对象 默认参数是可变的那调用第二次传入的参数就是第一次调用完的结果效果会叠加如下 def append_to_element(element, append_to[]):element.append(append_to)return element# 第一次调用函数预期的行为 print(append_to_element(new item)) # 输出: [new item]# 第二次调用函数非预期的行为 print(append_to_element(another item)) # 输出: [new item, another item] 为了让每次调用都相互独立不要用可变变量为默认参数默认改为none当是默认none时再创建一个[ ] def append_to_element(element, append_toNone):if append_to is None:append_to []element.append(append_to)return element16. 面向对象中new 和 init 区别 new是类方法用于创建一个实例对象对其进行内存分配。参数是cls类名 创建完实例对象之后init作为实例方法对实例对象进行初始化一些属性和参数。参数是self实例名 在面向对象编程中new 和 init 是两个特殊的方法它们在创建对象时有不同的用途和行为 举例说明 假设我们有一个简单的类 MyClass class MyClass:def new(cls, *args, **kwargs):# 一般new不需要重写可以在这里执行一些逻辑例如改变创建的对象类型print(Creating object with new)instance super().new(cls) # 创建对象保留父类的方法避免重复return instancedef init(self, value):# 在这里设置对象的初始状态print(Initializing object with init)self.value value# 创建 MyClass 的实例 obj MyClass(10)输出将是 Creating object with new Initializing object with init在这个例子中new 首先被调用并创建了 MyClass 的一个新实例。然后init 被调用设置 value 属性。 重写 new 的例子 class BaseClass:def new(cls, *args, **kwargs):print(BaseClass new called)return super().new(cls)def init(self, value):self.value valueclass SubClass(BaseClass):def new(cls, *args, **kwargs):print(SubClass new called, changing object type)instance super().new(BaseClass) # 创建 BaseClass 的实例return instancedef init(self, value):super().init(value) # 初始化 BaseClass 的 initprint(fSubClass initialized with value: {self.value})# 创建 SubClass 的实例 sub_obj SubClass(20)输出将是 SubClass new called, changing object type BaseClass new called SubClass initialized with value: 20在这个例子中我们重写了 SubClass 的 new 方法使其创建了 BaseClass 的实例而不是 SubClass 的实例。这演示了 new 方法如何控制对象的创建过程。 通常new 方法在大多数情况下不需要重写除非你有特殊的对象创建逻辑。而 init 方法则更常用于初始化对象的状态。

2. 三元运算规则 执行1 if 条件 else 执行2 a, b 1, 2h a - b if a b else a bh 3

3. 生成随机数 用np.random也可以 import randomrandom.random() 0.7571910055209727random.randint(1, 100) 23random.uniform(1, 5) #random.uniform(a, b) 返回一个随机浮点数 N使得 a N b 3.064073283115168719. zip 函数用法 zip() 函数将可迭代的对象作为参数将对象中对应的元素打包成一个元组然后返回由这些元组组成的列表。 一对一打包成元组 list1 [zhangfei, guanyu, liubei, zhaoyun]list2 [0, 3, 2, 4]list(zip(list1, list2)) [(zhangfei, 0), (guanyu, 3), (liubei, 2), (zhaoyun, 4)]20. range和xrange的区别 只有Python2中才有xrange()和range()Python3中的range()其实就是Python2中xrange()。即都用range

4. with方法打开文件的作用 打开文件在进行读写的时候可能会出现一些异常状况如果按照常规的f.open()写法我们需要 tryexceptfinally做异常判断并且文件最终不管遇到什么情况都要执行f.close() 关闭文件with方法帮我们实现了finally 中 f.close()。 所以能在代码执行完毕后资源能够被正确地关闭或释放即使在代码执行过程中发生异常也是如此。 with open(hello.txt, a) as f:f.write(hello world!)总结文件会遇到异常也都需要关闭用with打开不论是否遇到异常都能正确关闭。

5. 字符串转列表 s.split(‘,’) s 1,2,3,4,5,6,7,8,9s.split(,) [1, 2, 3, 4, 5, 6, 7, 8, 9]字符串split返回列表

6. 字符串转整数 list(map(lambda x: int(x), s.split(,)))先转为列表再用map遍历转int 24.删除列表中的重复值 先变成set集合再list变过去再变回来集合去重 list(set(mylist))

7. 字符串单词统计 统计字母个数用collection的counter from collections import Countermystr sdfsfsfsdfsd,were,hrhrgege.sdfwe!sfsdfsCounter(mystr) Counter({s: 9,d: 5,f: 7,,: 2,w: 2,e: 5,r: 3,h: 2,g: 2,.: 1,!: 1})统计单词个数先变为列表在计算列表长度 mystr2 hello, Nice to meet you!len(mystr2.split( )) 5

8. 列表推导求奇偶数 [x for x in range(20) if x % 2 1]

9. 一行代码展开列表 对于list1中的每个元素i子列表遍历其所有元素j并将这些元素收集到一个新的列表中:list1 [[1, 2, 3], [4, 5, 6], [7, 8, 9]] [ j for i in list1 for j in i]

10. 实现二分法查找函数 //向下取整到最接近的整数 非递归 def binary_search(data, item):left 0right len(data) - 1while left right:mid (left right) // 2if data[mid] item:return Trueelif data[mid] item:left mid 1else:right mid - 1return False 递归 def binary_search(data, item):n len(data)if n 0:mid n // 2if data[mid] item:return Trueelif data[mid] item:return binary_search(data[:mid], item)else:return binary_search(data[mid 1:], item)return False 不管怎样都是返回等于更新是中间值-1和中间值1

11. 合并两个元组到字典zip一对一打包 先zip再dict a (zhangfei, guanyu)b (66, 80)dict(zip(a, b)) ## {zhangfei: 66, guanyu: 80}

12. 给出如下代码的输入并简单解释 a (1, 2, 3, [4, 5, 6, 7], 8)a[3] 2✘()是元组元组不能修改不可变 a (1, 2, 3, [4, 5, 6, 7], 8)a[3][2] 2a (1, 2, 3, [4, 5, 2, 7], 8)✔:列表可修改就元组不行

13. 列表推导式[]、字典推导式{}和生成器表达式() 列表推导式是方括号[]返回一个列表list [ k for k in range(10)] 字典推导式是花括号还有键和值返回一个字典dic dic {k: 2 for k in [a, b, c, d]}dic {a: 2, b: 2, c: 2, d: 2}type(dic) dict生成器是圆括号(),用next访问元素 ge (i for i in range(20))ge_list generator object genexpr at 0x000001C3C127AAC8 #由一个生成器表达式genexpr创建并存储在内存地址0x000001C3C127AAC8处 next(ge)33. 简述 read、readline、readlines 的区别 read() 读取整个文件 readline() 读取下一行,使用生成器方法 readlines() 读取整个文件到一个迭代器,需要一行一行遍历才能输出

    假设有一个名为 example.txt 的文件内容如下

    Line 1

    Line 2

    Line 3with open(example.txt, r) as file:# 使用 read() 方法读取整个文件content file.read()print(content)# 重置文件指针到开始位置file.seek(0)# 使用 readline() 方法逐行读取print(file.readline()) # 输出: Line 1\nprint(file.readline()) # 输出: Line 2\n# 再次重置文件指针到开始位置file.seek(0)# 使用 readlines() 方法读取所有行lines file.readlines()for line in lines:print(repr(line)) # 输出: Line 1\n, Line 2\n, Line 3\n34. 打乱一个列表 andom.shuffle import randomlist list(range(1, 10))random.shuffle(list)list

    [3, 9, 1, 4, 6, 2, 8, 7, 5]35. 反转字符串 ‘luobodazahui’[::-1]表示以-1的步长向前遍历相当于从后往前遍历一遍也就是反转。而列表可以直接用reverse

14. 单下划线和双下划线的作用

15. 新式类和旧式类 在 python 里凡是继承了 object的类都是新式类 Python3 里只有新式类 又是一个版本的问题

16. Python 面向对象中的继承有什么特点 继承是一种创建新类的方式在 Python 的面向对象编程中继承具有以下特点 基类父类与子类子类在继承关系中被继承的类称为基类或父类继承基类的类称为子类。子类会继承基类的属性和方法。 属性与方法继承子类会继承基类的所有属性和方法因此在子类中可以访问基类的属性和方法。根据继承方式的不同如单继承、多重继承子类可以继承多个基类的属性和方法。 扩展与覆盖子类可以在继承基类的基础上进行扩展添加新的属性和方法。同时子类也可以覆盖重写基类的方法以实现不同的功能。当子类中定义了与基类同名的方法时子类会优先调用自己的方法。 super() 函数在子类中可以使用 super() 函数来调用基类的方法。这在子类需要在重写方法的基础上扩展基类功能时非常有用。使用 super() 函数可以确保基类的方法按照方法解析顺序MRO正确地调用。 方法解析顺序MROPython 中使用 C3 线性化算法来解决多重继承的顺序问题。MRO 是一个包含类自身及其所有基类的有序列表它决定了类继承体系中调用方法的顺序。可以使用 ClassName.mro() 或 super() 函数查看 MRO 列表。 抽象基类ABCPython 中的抽象基类用于定义接口规范它强制子类实现特定的方法。抽象基类可以通过 abc 模块的 ABCMeta 元类和 abstractmethod 装饰器来实现。
    下面是一个简单的继承示例 class Animal:def init(self, name):self.name namedef speak(self):passclass Dog(Animal):def speak(self):return f{self.name} says Woof!class Cat(Animal):def speak(self):return f{self.name} says Meow!animals [Dog(Max), Cat(Molly)]for animal in animals:print(animal.speak())在这个示例中Dog 和 Cat 类都继承了 Animal 类并分别覆盖了 speak() 方法。

17. super 函数的作用 用于调用父类超类的方法或初始化父类在init中 class Parent:def init(self, value):self.value valuedef show(self):print(fParent value: {self.value})class Child(Parent):def init(self, value, extension):super().init(value) # 初始化父类的 initself.extension extensiondef show(self):super().show() # 调用父类的 show 方法print(fChild extension: {self.extension})# 创建 Child 类的实例 child Child(10, extra info) child.show()40. 类中的各种方法 在类中我们可以定义各种不同类型的函数主要包括以下几种 实例方法这是类中最常见的函数类型它们需要通过实例来调用第一个参数默认为 self代表实例本身可以访问和修改实例的属性。 class MyClass:def instance_method(self, a, b):return a b类方法类方法是定义在类上的函数通过 classmethod 装饰器来修饰它们的第一个参数默认为 cls代表类本身可以访问和修改类属性但不能访问实例属性。 class MyClass:class_variable 123classmethoddef class_method(cls):cls.class_variable 1return cls.class_variable静态方法静态方法是定义在类上的函数通过 staticmethod 装饰器来修饰它们不需要特定的第一个参数不能访问类或实例的任何属性。 class MyClass:staticmethoddef static_method(a, b):return a * b属性方法属性方法可以让类的一个方法变成只读属性或者为属性的读写提供特定的方法。通过 property 装饰器实现。 class MyClass:def init(self, value):self._value valuepropertydef value(self):return self._valuevalue.setterdef value(self, new_value):if isinstance(new_value, int):self._value new_valueelse:raise ValueError(Value must be an integer)魔法方法这些方法以双下划线开头和结尾由 Python 自动调用用于实现类的内部机制。比如 init, del, str, eq 等。 class MyClass:def init(self, value):self.value valuedef str(self):return fMyClass with value {self.value}def eq(self, other):if isinstance(other, MyClass):return self.value other.valuereturn False以上就是类中常见的几种函数类型。

18. 如何判断是函数还是方法 与类和实例无绑定关系的 function都属于函数function 与类和实例有绑定关系的 function都属于方法method

19. isinstance 的作用以及与type()的区别 区别 type()不会认为子类是一种父类类型不考虑继承关系 isinstance()会认为子类是一种父类类型考虑继承关系。 class A(object):passclass B(A):pass a A()b B() print(isinstance(a, A)) Trueprint(type(a) A) True print(isinstance(b, A)) #考虑继承 Trueprint(type(b) A) #不考虑继承 False43. 单例模式与工厂模式 单例模式和工厂模式是两种常用的软件设计模式它们在软件设计中扮演着不同的角色具有各自的特点和适用场景。以下是两种模式的详细介绍 单例模式 定义单例模式是一种设计模式它确保一个类只有一个实例并提供一个全局访问点来访问该实例。特点 唯一性单例模式保证一个类在整个应用程序中只有一个实例。全局访问点通过单例模式可以提供一个全局访问点来访问该类的唯一实例。 适用场景适用于创建一个对象需要消耗过多资源或者需要保证对象唯一性的场景如数据库连接池、线程池等。实现方式单例模式有多种实现方式包括懒汉式、饿汉式、双重检查锁和登记式等。 工厂模式 定义工厂模式是一种设计模式它通过一个工厂类来封装和抽象对象的创建过程使得客户端代码不需要直接进行对象的实例化。特点 封装性工厂模式封装了对象创建的细节降低了系统各部分之间的耦合度。接口一致性所有创建的对象通常都实现自同一个接口或继承自同一个基类增加了代码的灵活性。 适用场景适用于需要生成复杂对象或者需要灵活应对不同条件创建不同实例的场景如数据库访问、日志记录等。实现方式工厂模式有多种实现方式包括简单工厂模式、工厂方法模式和抽象工厂模式。 区别 目的单例模式主要用于控制类的实例数量确保只有一个实例而工厂模式主要用于封装对象的创建过程提高代码的可维护性和可扩展性。实现方式单例模式通过类的静态方法和私有构造函数来实现工厂模式通过工厂类来创建对象实例。适用场景单例模式适用于需要保证对象唯一性的场景工厂模式适用于需要灵活创建不同对象实例的场景。 通过以上分析我们可以看到单例模式和工厂模式在设计模式中各有其独特的用途和优势选择哪种模式取决于具体的应用场景和需求。

20. 查看目录下的所有文件 import os print(os.listdir(.)) # 其中 . 表示当前工作目录。这个函数会返回一个列表包含了当前目录下所有的文件和目录名。45. 计算由1到5组成的互不重复的三位数 for i in range(1,6):for j in range(1,6):for k in range(1,6):if i ! j and j ! k and k !i:print(f{i}{j}{k})46. 去除字符串首尾空格 .strip(删除字符串两端的空白字符或者指定字符 hello world .strip() hello world

21. 去除字符串中间的空格 hello you are good.replace( , ) helloyouaregood.join(hello you are good.split( )) helloyouaregood48. 字符串格式化方式 方法一使用 % 操作符 print(“This is for %s” % “Python”) print(“This is for %s, and %s” %(“Python”, “You”)) 方法二str.format在 Python3 中引入了这个新的字符串格式化方法 print(“This is my {}”.format(“chat”)) print(“This is {name}, hope you can {do}”.format(name“zhouluob”, do“like”)) 方法三f-strings在 Python3-6 中引入了这个新的字符串格式化方法 name “luobodazahui” print(fhello {name})

22. 将hello world转换为首字母大写Hello World 1 对字符串.title()函数 str1 “hello world” str1.title() 2 .对单词capitalize()函数 .join(list(map(lambda x: x.capitalize(), str1.split( )))) 3 对字符.upper() .join(list(map(lambda x: x[0].upper() x[1:], str1.split( )))) map()函数将这个函数应用到分割后的单词列表的每个元素上 50. 一行代码转换列表中的整数为字符串 list1 [1, 2, 3]list(map(lambda x: str(x) for x in list1))# 或者 [lambda x: str(x) for x in list1]列表推导式 [1, 2, 3]51. Python 中的反射27号 基于字符串的事件驱动利用字符串的形式对模块的内存进行修改 getattrhasattrsetattrdelattr 对模块的修改都在内存中进行并不会影响文件中真实内容。

23. metaclass 元类 type就是创建object类对象的类,obeject是type的实例创建一个类其实是type的call运算符的重载 正常的 MyClass 定义和手工去调用type运算符的结果是一样的 class X:a 1X type(X, (object,), dict(a1))那元类是干嘛的呢 是type的子类通过替换type中的call运算符重载机制可以实现父类对子类的属性进行操作。 class MyMeta(type):def new(cls, *args, **kwargs):print(MyMeta.new)print(cls.name)return super().new(cls, *args, **kwargs)def init(self, classname, superclasses, attributedict):super().init(classname, superclasses, attributedict)print(MyMeta.init)print(self.name)print(attributedict)print(self.tag)def call(self, *args, **kwargs):print(MyMeta.call)obj self.new(self, *args, **kwargs)self.init(self, *args, **kwargs)return objclass Foo(object, metaclassMyMeta):tag !Foodef new(cls, *args, **kwargs):print(Foo.new)return super().new(cls)def init(self, name):print(Foo.init)self.name name

    ———————-输出———————-

    MyMeta.new

    MyMeta

    MyMeta.init

    Foo

    {module: main, qualname: Foo, tag: !Foo, new: function Foo.new at 0x000001B1B2379678, init: function Foo.init at 0x000001B1B2379708, classcell: cell at 0x000001B1B23880A8: MyMeta object at 0x000001B1B1A509A8}

    !Foo print(test start)foo Foo(test)print(test end)

    test start

    MyMeta.call

    Foo.new

    Foo.init

    test end创建一个类时1先在属性中查找是否有metaclass属性2没有就在父类中查找3没有就在模块中查找4再没有就用type来创建对象。 注意通过metaclass必须返回一个类return obj 同时可以实现在创建时就对子类的属性进行操作。(一般父类是不可以对子类的属性操作的哦

    def MyMetaFunction(classname, superclasses, attributedict):attributedict[year] 2019return type(classname, superclasses, attributedict)class Foo(object, metaclassMyMetaFunction):tag !Foodef new(cls, *args, **kwargs):print(Foo.new)return super().new(cls)def init(self, name):print(Foo.init)self.name name foo Foo(test) Foo.new Foo.initprint(name:%s,tag:%s,year:%s % (foo.name, foo.tag, foo.year)) name:test,tag:!Foo,year:2019 先有元类再有类再有实例。

24. sort 和 sorted 的区别 sort改变原列表。sorted返回一个新的对象

25. Python 中的 GIL GIL 是 Python 的全局解释器锁同一进程中假如有多个线程运行一个线程在运行 Python 程序的时候会占用 Python 解释器加了一把锁即 GIL使该进程内的其他线程无法运行等该线程运行完后其他线程才能运行。如果线程运行过程中遇到耗时操作则解释器锁解开使其他线程运行。所以在多线程中线程的运行仍是有先后顺序的并不是同时进行。 进程Process 定义进程是操作系统进行资源分配和调度的一个独立单位。它是应用程序运行的实例拥有独立的内存空间。地址空间每个进程有自己的地址空间这包括代码段、数据段和堆栈等。全局数据进程拥有自己的全局变量和静态变量。独立性进程之间相互独立一个进程的崩溃不会直接影响到其他进程。资源占用进程间通信IPC和进程切换开销较大因为它们需要操作系统进行协调。创建和销毁开销进程的创建和销毁需要较多的资源和时间。 线程Thread 定义线程是进程中的一个实体是CPU调度和执行的单位是程序执行的最小单位。地址空间同一进程内的线程共享进程的地址空间包括代码段和数据段。全局数据线程共享相同的全局变量和静态变量。轻量级线程的创建、同步和销毁的开销比进程小。并发性线程使得多任务并发执行成为可能它们可以并行处理任务。资源共享线程之间可以轻松共享数据但这也可能导致数据同步问题。 进程与线程的区别 资源占用进程拥有独立的资源线程共享进程的资源。执行进程是程序的执行流程线程是进程中执行的子流程。创建开销进程的创建和销毁开销较大线程相对较小。通信进程间通信需要使用IPC机制线程间可以直接访问共享内存。独立性进程间独立线程间共享。错误影响进程的一个错误通常不会影响其他进程但线程的错误可能影响整个进程。上下文切换线程间的上下文切换比进程快因为它们共享同样的内存空间。 理解示例 进程可以比作一个工厂每个工厂拥有自己的资源和生产流程。线程可以比作工厂中的工人他们共享工厂的资源协同工作以完成生产任务。 55. 产生8位随机密码 random.choice选择string.printable生成字符串 import randomimport string.join(random.choice(string.printable[:-7]) for i in range(8)) # 从 string.printable 中移除最后 7 个字符 生成器表达式和列表推导式list comprehension都是简洁地创建新数据结构的方法但它们之间存在一些关键区别 内存使用列表推导式会立即生成一个新的列表这意味着它会占用与列表大小成正比的内存。对于大型数据集这可能导致内存不足。而生成器表达式不会立即生成值而是返回一个生成器对象。这个对象在迭代过程中逐个产生值因此它的内存占用很小无论它表示的序列有多大。 语法生成器表达式的语法与列表推导式非常相似只是在圆括号而不是方括号内编写。例如 列表推导式[expr for item in iterable if condition]生成器表达式(expr for item in iterable if condition) 返回类型列表推导式返回一个列表而生成器表达式返回一个生成器对象generator 类型。生成器对象实现了迭代器协议可以使用 next() 函数或 for 循环进行迭代。 可迭代性生成器表达式返回的生成器对象只能迭代一次。当所有值都被迭代完后生成器对象就会耗尽。要再次迭代需要重新创建一个新的生成器对象。而列表推导式返回的列表可以多次迭代。 以下是一个简单的例子展示了列表推导式和生成器表达式的用法

    列表推导式 squares [random.randint(1, 100) ** 2 for _ in range(5)] print(squares)# 生成器表达式 squares_gen (random.randint(1, 100) ** 2 for _ in range(5)) for square in squares_gen:print(square, end ) 56. 输出原始字符 print(hello\nworld)

    hello worldprint(bhello\nworld) bhello\nworldprint(rhello\nworld) hello\nworldb 前缀表示字节字符串byte string即 b’hello\nworld’ 是一个包含字节的不可变序列。这种字符串用于处理二进制数据。 r 前缀表示原始字符串raw string在这种字符串中转义字符不会被处理。

26. 简述 any() 和 all() 方法 all 可迭代对象中的所有元素是否都为 True any 函数用于判断可迭代对象中是否至少有一个元素为 True 0 none false都是false

27. 反转整数 是否是整数是否一位数是否负数 def reverse_int(x):if not isinstance(x, int):return Falseif -10 x 10:return xtmp str(x)if tmp[0] ! -:tmp tmp[::-1]return int(tmp)else:tmp tmp[1:][::-1]x int(tmp)return -x

28. 函数式编程 函数式编程是一种抽象程度很高的编程范式纯粹的函数式编程语言编写的函数没有变量因此任意一个函数只要输入是确定的输出就是确定的这种纯函数称之为没有副作用。而允许使用变量的程序设计语言由于函数内部的变量状态不确定同样的输入可能得到不同的输出因此这种函数是有副作用的。由于 Python 允许使用变量因此Python 不是纯函数式编程语言。 函数式编程允许参数是函数也允许返回一个函数

29. 简述闭包 如果在一个内部函数里对在外部作用域但不是在全局作用域的变量进行引用那么内部函数就被认为是闭包closure。允许函数“记住”其被创建时的环境状态即使外层函数已经执行完毕 闭包特点 必须有一个内嵌函数 内嵌函数必须引用外部函数中的变量 外部函数的返回值必须是内嵌函数。 闭包的应用场景 柯里化Currying将一个多参数的函数转换成多个单参数函数。 数据隐藏通过闭包实现封装和数据隐藏。 装饰器Python中的装饰器就是一个典型的闭包应用。 迭代器和生成器迭代器和生成器的 next 方法经常使用闭包来保持迭代状态。 61. 简述装饰器 装饰器是一个嵌套函数不需要修改被装饰函数的源代码用于给被装饰的函数修改或添加功能内部的wrapper函数替代原始函数。 被装饰函数作为参数传入装饰器内部函数替代原始函数执行后还可以添加一些功能。 广泛应用于缓存、权限校验如django中的login_required和permission_required装饰器、性能测试比如统计一段程序的运行时间和插入日志等应用场景 基本用法 定义装饰器 创建一个装饰器函数通常接受一个函数作为参数。 包装函数 在装饰器内部定义一个包装函数通常命名为 wrapper它将被返回以替代原始函数。 调用原始函数 在包装函数中你可以添加额外的逻辑然后调用原始函数。 返回包装函数 装饰器返回包装函数这样当原始函数被调用时实际上是调用了包装函数。
    示例 def my_decorator(func):def wrapper():print(Something is happening before the function is called.)func()print(Something is happening after the function is called.)return wrappermy_decorator def say_hello():print(Hello!)say_hello()输出 Something is happening before the function is called. Hello! Something is happening after the function is called.在这个例子中my_decorator 是一个装饰器它接受一个函数 func 作为参数并返回一个新的函数 wrapper。say_hello 函数被 my_decorator 装饰这意味着 say_hello 函数被 my_decorator 包装。 带参数的装饰器 装饰器也可以接受参数。为了实现这一点你可以在装饰器外层再定义一个函数该函数接受参数并返回实际的装饰器。 def repeat(num_times):def decorator(func):def wrapper(*args, **kwargs):for _ in range(num_times):result func(*args, **kwargs)return resultreturn wrapperreturn decoratorrepeat(num_times3) def greet(name):print(fHello, {name}!)greet(World)输出 Hello, World! Hello, World! Hello, World!在这个例子中repeat 函数接受一个参数 num_times然后返回一个装饰器 decorator该装饰器接受一个函数并返回一个新的包装函数 wrapper。 装饰器的用途 日志记录在函数执行前后添加日志记录。性能测试测量函数执行时间。事务处理确保数据库事务的一致性。权限检查在执行函数前检查用户权限。缓存缓存函数的结果以提高性能。

30. 协程的优点

31. 实现斐波那契数列

32. 正则切分字符串 items re.split(pattern, text) 正则表达式Regular Expression简称regex是一种强大的文本处理工具用于搜索、替换、切分或匹配字符串中的模式。在Python中正则表达式通过内置的re模块提供支持。 使用正则表达式切分字符串的基本步骤 导入re模块 import re编写正则表达式 正则表达式是一个字符串包含了用于定义搜索模式的字符和特殊符号。 使用re.split()方法 re.split(pattern, string)使用正则表达式pattern来切分字符串string。 获取结果 re.split()返回一个列表其中包含了被正则表达式定义的模式切分后的子字符串。
    示例 假设我们有一个字符串包含了用逗号分隔的数值我们想要将这些数值单独切分出来 import retext apple,101,banana,202,cherry,303

    正则表达式非数字字符,

    pattern r[^\d]# 使用正则表达式切分字符串 items re.split(pattern, text) print(items) # 输出: [apple, 101, banana, 202, cherry, 303]在这个例子中[^\d]是一个正则表达式表示匹配一个或多个非数字字符。re.split()使用这个模式来切分字符串text。 注意事项 正则表达式需要根据具体需求来编写不同的模式会有不同的切分效果。特殊字符如*、.、?、[ ]、( )等在正则表达式中有特殊含义如果需要匹配这些字符本身通常需要使用反斜杠\进行转义。使用正则表达式时要注意其性能复杂的正则表达式可能会影响程序的执行效率。 正则表达式是一种非常灵活和强大的文本处理工具掌握它可以大大提高处理字符串的效率。

33. yield 用法

34. 冒泡排序

35. 快速排序 快速排序Quick Sort是一种高效的排序算法由英国计算机科学家 Tony Hoare 于 1960 年代提出 快速排序的工作原理如下 选择一个基准元素pivot可以是列表的任意元素。通常选择列表的第一个元素、最后一个元素或中间元素作为基准。将列表中小于基准元素的值移动到基准的左侧将大于基准元素的值移动到基准的右侧。这个过程称为分区partitioning操作。经过分区后基准元素将位于其最终排序位置。对基准元素左侧和右侧的子列表进行递归处理分别选择左侧子列表和右侧子列表的基准元素并进行分区。递归终止条件是处理的子列表只有一个元素或为空。 以下是一个使用 Python 实现的快速排序示例 def quick_sort(arr):if len(arr) 1:return arrpivot arr[len(arr) // 2]left [x for x in arr if x pivot]middle [x for x in arr if x pivot]right [x for x in arr if x pivot]return quick_sort(left) middle quick_sort(right)# 示例 arr [64, 34, 25, 12, 22, 11, 90] sorted_arr quick_sort(arr) print(Sorted array is:, sorted_arr)输出结果 Sorted array is: [11, 12, 22, 25, 34, 64, 90]快速排序的平均时间复杂度为 O(nlog(n))最坏情况下的时间复杂度为 O(n^2)。但在实际应用中快速排序通常比其他 O(nlog(n)) 算法更高效因为它的内部循环可以在大部分架构上更有效地利用缓存。为了避免最坏情况的发生可以使用随机方法选择基准元素。

36. requests 简介

37. 比较两个 json 数据是否相等

38. 读取键盘输入 input() def forinput():input_text input()print(your input text is: , input_text) forinput() ? 2 your input text is: 273. enumerate()的用法

39. pass 语句 占位不做操作为了保持结构完整性 def forpass(n):if n 1:passelse:print(not 1) forpass(1)

40. 正则匹配邮箱

41. 统计字符串中大写字母的数量 ·if i.isupper()

42. json 序列化时保留中文 ensure_asciiFalse

43. 简述继承

44. 什么是猴子补丁 猴子补丁Monkey Patch和装饰器Decorator都是 Python 中用于修改或增强已有对象功能的技术但它们的用途、实现方式以及适用场景有所不同 猴子补丁Monkey Patch 猴子补丁是在运行时动态地修改类或模块的行为。通过直接修改类或模块的属性可以添加、修改或删除现有的方法、属性等。猴子补丁的主要优点是可以在不修改原始代码的情况下调整行为这在调试、测试和扩展第三方库时非常有用。然而猴子补丁可能导致代码难以维护和理解因为它改变了对象的内部实现。另外使用猴子补丁时需要谨慎因为在某些情况下它可能导致意外的副作用或不可预见的错误。 以下是一个猴子补丁的示例用于修改字符串类的 upper 方法 def custom_upper(self):return self[::-1].upper()str.upper custom_uppertext hello print(text.upper()) # 输出 OLLEh装饰器Decorator 装饰器是一种设计模式用于在不修改原始函数或类的基础上为其添加新功能或者修改现有功能。装饰器本质上是一个接受函数或类作为参数的高阶函数它返回一个新的函数或类以实现对输入对象功能的扩展或修改。装饰器语法使用 decorator_name 语法糖并放在要修饰的函数或类定义之前。 以下是一个使用装饰器记录函数执行时间的示例 import timedef timer_decorator(func):def wrapper(*args, **kwargs):start_time time.time()result func(*args, **kwargs)end_time time.time()print(f{func.name} took {end_time - start_time:.2f} seconds to execute.)return resultreturn wrappertimer_decorator def some_function():time.sleep(1)some_function()总结 猴子补丁是在运行时动态修改对象的行为而装饰器是通过高阶函数在编译时修改或增强对象的功能。猴子补丁主要适用于对模块或类的内部实现进行修改而装饰器主要用于修改或增强函数或类的功能而不改变其内部实现。装饰器提供了更好的封装、可维护性和可读性而猴子补丁可能导致代码变得难以理解和维护。尽量使用装饰器来实现功能扩展而避免使用猴子补丁除非确实需要在运行时修改对象的行为。

45. help() 函数和 dir() 函数

46. 解释 Python 中的//和**运算符

47. 主动抛出异常 raise def test_raise(n):if not isinstance(n, int):raise Exception(not a int type)else:print(good) test_raise(8.9) Traceback (most recent call last):File D:\Anaconda3\lib\site-packages\IPython\core\interactiveshell.py, line 3331, in run_codeexec(code_obj, self.user_global_ns, self.user_ns)File ipython-input-106-27962090d274, line 1, in moduletest_raise(8.9)File ipython-input-105-8095f403c7e2, line 3, in test_raiseraise Exception(not a int type) Exception: not a int type

48. tuple 和 list 转换 tuple () list() tuple1 (1, 2, 3, 4)list1 list(tuple1)print(list1)tuple2 tuple(list1)print(tuple2)84. 简述断言 Python 的断言就是检测一个条件如果条件为真它什么都不做反之它触发一个带可选错误信息的 AssertionError。

49. 什么是异步非阻塞

50. 什么是负索引

51. 退出 Python 后内存是否全部释放

52. Flask 和 Django 的异同

53. 创建删除操作系统上的文件

54. 简述 logging 模块

55. 统计字符串中字符出现次数

56. 正则 re.complie 的作用

57. try except else / finally 的意义

58. 反转列表

59. 字符串中数字替换 import restr1 我是周萝卜今年18岁re.sub(r\d, 20, str1) 我是周萝卜今年20岁

60. 读取大文件

61. 输入日期 判断这一天是这一年的第几天

62. 排序

63. 将字符串处理成字典

64. 下面代码的输出结果将是什么 补充 被问的 101 python协程 异步 协程 线程 进程都属于并发并发是在一个处理器上轮流处理任务强调资源的共享和分配并行是在多个处理器上同时处理任务强调硬件资源的利用。 asyncio异步函数库 request : 同步函数库 详细见metagpt异步编程 102 python子类不用super调用父类属性 不用super一般是不可以调用父类的方法的但是子类执行行父类执行new 函数创建实例所以想不用super调用父类可以写到new里 问题参考自python八股