全篇大概 1000 字（含代码），建议阅读时间 5min

1. 将字符串 ‘a is a’ 改为 ‘b is b’

python">s = 'a is a'
s.replace('a', 'b')

什么是转义字符

在字符串中如果含有特殊字符如：单引号、双引号。需要再特殊字符前加 “” 反斜杠才能使用。

3.字符串前面加 r 和 b 意义

r 防止转义字符被转义， b转换为bytes数据格式

4. find() 和 rfind() 区别

find() 查询字符串的索引位置，如果没有找到则返回-1 rfind()
查询字符串的最后一次出现都得索引位置

python">s = 'abcdea'
print('find(a): ',s.find('a'))
print('rfind(a): ', s.rfind('a'))

5. index() 和 rindex() 区别

index() 查询字符串位置，可以应用在列表、字符串
rindex() 查询字符串最后一次出现的位置，只能在字符串中应用

python">s = 'abcdefa'
lst = ['a', 'b', 'c', 'd', 'e']
print('index to string a :', s.index('a'))
print('index to list a :', lst.index('a'))
print('rindex to string a :', s.rindex('a'))
print('rindex to list a error :', lst.rindex('a'))

6. continue 和 break 运作方式

continue : 在循环中，程序将不再往下执行，跳转到循环开始处
break: 在循环中满足条件，循环将会终止执行

7. 列表的正索引和负索引的用法

python">lst = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(lst[-1])
print(lst[-3])
print(lst[-5])

8. 什么是切片

当遇到取出前几个元素或后几个元素，在某个区间段的元素，这就是切片。

9. 列表当中的 append() 和 extend() 方法的区别

append() 在列表末尾添加元素
extend() 将一个列表加入到另一个列表的末尾

python">lst = [0, 1, 2, 3]
lst.append(4)
print(lst)

python">lst.extend([5, 6, 7])
print(lst)

10. 浅拷贝和深拷贝在不可变数据上的区别

浅拷贝地址不同，对被拷贝对象进行增加，拷贝对象不会更改，但是如果有一个子列表，那么两个子列表的地址是相同的。

python">a = [1, 2, 3, [4, 5, 6]]
b = a.copy()
id(a), id(b)
a.append(7) # 对a列表进行修改， 地址不同，ab内容不同
a, b

python">a[3].append(7) # 对 a与b的子列表修改， 子列表地址相同，内容同时改变
a, b

深拷贝的两个对象都是相独立的，不受任何一方干扰。

python">import copy
a = [1, 2, 3, [4, 5, 6]]
b = copy.deepcopy(a)
id(a), id(b)

python">a[3].append(7) # 对a列表的子列表进行修改
a, b # a与b不同

python">a.append(8) # 对a列表添加元素
a, b # a与b不同

11. 将字符串第1个字母大写

title() 将字符串第1个字母大写

python">s = 'join'
s.title()

12. 将字符串全部改成小写

lower() 将字符串全部改成小写

python">s = 'ABC'
s.lower()

13. 去除字符串头尾空格

strip() 去除头尾空格

python">s = ' hello world '
s.strip()

14. 将字符串以符号作为分隔符，将字符串拆开，成为列表

split() 以空格作为分隔符
split(符号) 以符号作为分隔符

python">s = 'a b c d e f g' 
s.split() # 以空格作为分隔符

python">s2 = 'a,b,c,d,e,f,g'
s2.split(',') # 以逗号作为分隔符

15. 比较两个对象指向的内存是否相同

is

python">a = [1, 2]
b = a
a is b

16. 判断一个对象是否属于另一个对象

in 返回一个布尔类型

python">data = [1, 2, 3, 4]
a = 1
a in data

17. 什么是列表打包

当等号左侧的变量与右边的变量不相符，就可以通过列表打包的方式，将剩余内容赋值给右边包含 *的变量

python">a, b, *c = 1, 2, 3, 4, 5, 6
a,b,c

python">a = [1, 2, 3]
b = [4, 5, 6]
c = [7, 8, 9]
for p in zip(a, b, c): # 多个列表也可以通过 zip() 函数进行打包print(p)

19. 什么是可迭代对象

可迭代对象就是可以被遍历或迭代的对象，如列表、元组、字典

20. 将一个字典合并到另一字典

被合并字典.update(合并字典)

python">a = {'a': 1, 'b': 2}
b = {'c': 3, 'd': 4}
a.update(b) # 合并两个字典
a

21. any() 和 all() 的区别

any(可迭代对象) 只要一个对象不为空、0、False 就返回True， 否则返回 False
all(可迭代对象) 只要所有的对象不为’'、0、False、空对象，返回True， 否则返回False

python">any([1, 2])

python">all([1, 2])

22. pass 是做什么用的

pass 用于修饰未完成的部分

23. 将连接符与列表元素组成一个字符串

连接符.join(列表)

python">data = ['a', 'b', 'c']
'-'.join(data)

24. sort() 和 sorted() 的区别

sort() 没有返回值，原列表会被改变
sorded() 有返回值，原列表不会被改变

python">data = [ -1, -2, 3, 5, 2]
data.sort()
data # 原列表发生改变

python">data = [ -1, -2, 3, 5, 2]
newData = sorted(data)
data # 原列表不会改变

25. 如何打印字典的键值？

字典.keys()

python">maps = {'a':10, 'b':20, 'c':30}
for k in maps.keys():print(k)

26. 使用函数传递参数时，是传地址

27. 如果需要在函数内更改全局变量内容，需要使用 global 关键字进行修饰

python">x = 10def modify_global():global x # 使用 global 修饰x = 20modify_global()
print(x) # x值已经被修改

python">x = 10def try_modify():x = 20 # 没有使用global 修饰try_modify()
print(x) # x值没有被改变

28. init() 方法的作用?

就是类中的初始化类的方法，创建对象时，将自动执行这个方法。

python">class Person:def __init__(self, name, age):self.name = nameself.age = agedef speek(self):print(f"{self.name} 的年龄为: {self.age}")person = Person("小那同学", 26)
person.speek()

29. 类中self关键字的作用？

self 代表类的当前实例，在实例方法中可以通过 self 访问该实例的属性和方法。

30. Python中封装的含义

通过私有化属性和方法的访问权限，限制外部代码对内部数据的直接访问。
私有属性和方法： 通过在属性或方法前增加 双下划线__，标记为私有，让其外部类不可直接访问。 受保护属性和方法： 使用单下划线_
标记属性或方法，但是仍然可以被方法，只是作为一种约束。

python">class Person:def __init__(self, name, age):self.name = name # 公共属性self.__age = age # 私有属性def get_person_info(self):return f"{self.name} 的年龄为: {self.__age}"# 私有方法def __speek(self):print("说话")person = Person("小那同学", 26)
print(person.get_person_info())
print(person.name)
print(person.age) # 报错

31. super() 常常用于去调用父类的方法，允许子类去扩展或修改父类的行为，同时保留父类的功能

super().methhod(args)

python">class Animal:def __init__(self, name):self.name = namedef speak(self):print(f"{self.name} 说了声hello")class Dog(Animal):def __init__(self, name):super().__init__(name)def speak(self):super().speak()dog = Dog("join")
dog.speak()

32. 多态就是不同类的对象在调用相同方法时产生不同的行为。

“接口相同，行为不同”。
优势：
1.代码复用： 统一方法名来调用不同的类的方法，减少代码的重复
2.扩展性：新类只需要实现父类的方法即可

python">class Animal:def speak(self):passclass Dog(Animal):def speak(self):print("汪汪汪")class Cat(Animal):def speak(self):print("喵喵喵")dog = Dog()
cat = Cat()dog.speak()
cat.speak()

33. Python多重继承是指类可以继承多个父类

python">class Animal:def __init__(self, name):self.name = namedef speak(self):print(f"{self.name} 发出声音")class Pet:def __init__(self, owner):self.owner = ownerdef show_owner(self):print(f"{self.name} 属于 {self.owner}")class Dog(Animal, Pet):def __init__(self, name, owner):Animal.__init__(self, name)Pet.__init__(self, owner)dog = Dog("老大", "小那同学")dog.speak()
dog.show_owner()

34. 迭代器中的iter() 和 next()

iter() 会将可迭代对象转换为一个迭代器。可以通过
next()函数进行迭代

python">iter_obj = iter([1, 2, 3])print(next(iter_obj))
print(next(iter_obj))
print(next(iter_obj))

python">iter_obj = iter([10, 20, 30])print(iter_obj.__next__())
print(iter_obj.__next__())
print(iter_obj.__next__())

35. random 库下的shuffle()函数，可以将列表的内容打散

python">import randomporker = ['2', '3', '4', '5', 'J', 'Q', 'K', 'A']
random.shuffle(porker)
print(porker)

36. random 库下的sample()函数，将列表内容打散并取出相应数量。

sample(列表, 数量)

python">import randomporker = ['2', '3', '4', '5', '6', 'J', 'Q', 'K', 'A']
new_porker = random.sample(porker, 4)
print(new_porker)

37. random库下的randint()函数，在区间内随机产生一个整数。

randint(min, max)

python">import randomprint(random.randint(1, 10))

38. random库下的choice() 函数，从一个序列中随机选择一个元素。

python">import randomitems = ['苹果', '香蕉', '橘子']
selected_item = random.choice(items)
print(selected_item)

39. random库下的 seed()函数，产生随机数时，得到相同的随机数。

seed(x) x为种子值，通过设置一个种子值，确保每次产生的随机值都是相同的。

python">import randomrandom.seed(10) # 设置种子值
print(random.random())random.seed(10)
print(random.random())random.seed(5) # 设置种子值为5，与上生成不相符
print(random.random())

40. random库下的 random() 函数，随机生成0-1之间的随机浮点数

python">import randomprint(random.random())

41. random库下的 uniform() 函数，随机生成区间之间的随机浮点数。

random.uniform(min, max)

python">import randomprint(random.uniform(1, 10))

42. lambda 匿名函数允许在一行代码内定义一个简单的函数

python">add = lambda a, b: a + b
print(add(3, 5))

43. sorted() 函数与lambda配合实现对列表降序排列

python">numbers = [1, 2, 3, 4, 5]
sorted_numbers = sorted(numbers, key=lambda x: -x) # 降序排列
print(sorted_numbers)

44. sorted() 和 lambda 对字典进行排列

python">member = [{'name': '小那同学'}, {'name': '李四'}, {'name': '王五'}]sorted_name = sorted(member, key=lambda x:x['name'])
print(sorted_name)

45. map() 函数用于将一个函数应用于可迭代对象的每个元素

python">numbers = [1, 2, 3, 4, 5]
squared_numbers = map(lambda x: x ** 2, numbers)
print(list(squared_numbers))

46. filter() 函数用于过滤处符合条件的元素

python">numbers = [1, 2, 3, 4, 5, 6]
even_numbers = filter(lambda x: x % 2 == 0, numbers)
print(list(even_numbers))

47. reduce() 是functools 库中的函数，将一元操作函数应用到序列的每个元素上。

python">from functools import reducenumbers = [1, 2, 3, 4]
result = reduce(lambda x, y: x + y, numbers)
print(result)

48. 函数传递任意数量的参数

python">def my_function(*args):for arg in args:print(arg)my_function(1, 2, 3, 4, 5)

** kwargs 允许传递多个关键字参数，最终收集到字典中

python">def my_function(**kwargs):for key, value in kwargs.items():print(f"{key}: {value}")my_function(name="小那同学", age=26)

如果 * 和 ** 同时出现时候， * 必须要在 ** 参数之前

python">def my_function(*args, **kwargs):pass

49. 函数可以当做参数传递给其他函数中，当函数作为参数时，可以不加括号()，如果加上括号，就是视为调用这个函数。

python">def add(a, b):return a + bdef run(func, arg1, arg2):return func(arg1, arg2)result = run(add, 10, 20)
print(result)

50. 闭包是一个函数对象，即时这个函数在外部作用域中被调用，仍然可以访问原作用域的变量。

闭包条件：

1. 嵌套函数： 函数A中定义一个函数B
2. 函数B引用了函数A的局部变量
3. 函数B作为返回值返回

闭包作用：

1. 数据封装和隐藏：用来封装一些数据，防止外部直接访问。
2. 回调函数：常用于回调函数中，保存上下文信息。
3. 装饰器： python中装饰器使用闭包来动态修改函数行为。

python">def outer(x):def inner(y):return x + yreturn innerclosure = outer(10)print(closure(5))

51. 生成器yield， 用于定义一个生成器函数，它将函数的执行暂停，并返回一个值。当生成器被调用时，函数从上次暂停的地方继续执行。

python">def count_up_to(n):count = 1while count <= n:yield count # 暂停返回countcount += 1gen = count_up_to(3)
print(next(gen))
print(next(gen))
print(next(gen))

52. 获取生成器下一个值next()，会从生成中获取下一个值，并暂停生成器执行，直到再次调用 next()

python">gen = count_up_to(3)print(next(gen))

53. send() 允许向生成器中发送一个值，既可以发送一个值，还可以恢复生成器的执行，继续从 yield 暂停的地方开始执行。

如果是第一次调用send() 会启动生成器，因为第一次 yield 没有值的传入。

python">def echo():received = yieldwhile True:received = yield receivedprint(f"{received}")gen = echo()
next(gen) # 启动生成器，执行第一个yieldprint(gen.send("hello"))
print(gen.send("world"))

54. 装饰器是一个函数，允许在不修改函数笨的情况下，给函数添加额外功能。

基本结构：
一个装饰器是一个接收函数作为参数并返回一个新函数的函数。 通常使用 @ 语法应用到目标函数。

python">def decorator(func):def wrapper():print("调用之前") # 调用函数之前func()  # 原始函数print("调用之后") # 调用函数之后return wrapper@decorator
def speak():print("hello, python")speak()

55. if name == ‘main’ 用于去判断当前文件是否是直接运行的文件，而不是被作为模块导入其他文件中的。

“name” 变量在每个模块当中都存在，当python去执行某个代码时，将会设置这个变量。如果该代码是被直接运行，那么
变量会被设置为 ‘main’，如果该代码被作为模块导入的，那么这个变量值就是该模块的名称。

python">if __name__ == '__main__':print("直接运行")
else:print("不能直接运行")