高级开发的知识点

1、了解魔法函数的使用，使用__init__，__new__，__del__的调用顺序及原理，清楚垃圾回收机制。

2、掌握__str__，__repr__，__add__等魔法函数的作用，并且自己能做一定程度的封装。

3、清楚python的异常处理机制，能快速定位到错误问题，具备一定断点的调试能力。

4、清楚模块、包、库、框架的区别以及各自的特点，能轻松看到第三方模块的结构，具备一定的源码阅读能力

5、掌握基本的网络编程知识，清楚ip、端口的作用。能用socket实现简单的网络通信。

6、掌握多线程的调用顺序，知道多线程竞争出现的原因以及解决方案。

7、清楚多线程与多进程的区别，能解决多进程之间数据不共享的问题，并使用多进程+多线程处理IO密集型任务

8、清楚GIL的作用，能区分同步、异步、并发、并行的概念，以及IO密集型与 CPU密集型的区别

9、掌握函数式编程，熟悉使用常见的高级函数代码更加的pythonnic。

10、清楚作用域的调用顺序及闭包形成的原因，清楚装饰器原理并能实现手写装饰器，了解多层装饰器及类装饰器的用法

11、清楚迭代器的作用以及生成器的原理，能使用类封装生成器对象。清楚yield的作用以及其返回对象的用法。

以上内容均是做python开发的重要面试考点

高级函数

1、lambda表达式讲解

它们在其他的语言中也被称为是匿名函数。如果你不想在程序中对一个函数使用两次，则可以考虑lambda表达式。它们和普通函数的作用是一样的。

lambda argument: manipulate(argument)  # -> lambad 参数: 操作(参数)

实现两个数字相加的案例

# 实现两个数相加
def add(x, y):
    return x + y


print(add(3, 5))

# lambda都是一次性的
add = lambda x, y: x + y
print(add(3, 5))

输出的结果均为8

对二维列表进行排序

arr = [(1, 2), (4, 1), (9, 10), (8, -3)]


def f(x):
    return x[1]


arr.sort(key=f)
print(arr)

使用lambda

arr = [(1, 2), (4, 1), (9, 10), (8, -3)]
arr.sort(key=lambda x: x[1])
print(arr)

输出的结果均为

[(8, -3), (4, 1), (1, 2), (9, 10)]

思考题

1、对二维函数的排序规则修改为使用索引为0进行排序

2、对二维函数的排序规则修改为使用两数之和进行排序

在实际的开发过程中可能会遇到怎么样的案例呢？下面我们来看一下：

实际案例

假设你有一个需要处理的产品列表，每个产品是一个字典，包括产品的价格和名称，现在你需要找出价格低于某个值的产品。

products = [
    {'name': '苹果', 'price': 25},
    {'name': '雪梨', 'price': 20},
    {'name': '桃子', 'price': 15},
    {'name': '西瓜', 'price': 8}
]

接下来筛选出价格低于18的产品

filter_products = filter(lambda x: x['price'] < 18, products)
print(list(filter_products))

运行结果

[{'name': '桃子', 'price': 15}, {'name': '西瓜', 'price': 8}]

这里说一下filter函数的作用。

filter(function, iterable) # fileter(函数, 可以排序的对象)

function：用于测试序列中每个元素是否符合条件的函数
iterable：一个序列，filter函数会对这个序列中的每个元素进行测试。

filter函数的返回值是一个迭代器，可以通过list()函数将其转换为列表，也可以在循环中使用它。

思考题

现在定义了一个列表

numbers = [1, 2, 3, 4, 5, 6]

使用filter函数筛选出偶数，并将结果转换为列表输出。

numbers = [1, 2, 3, 4, 5, 6]

new_numbers = filter(lambda x: x%2 == 0, numbers)
print(list(new_numbers))

2、sorted函数讲解

sorted(iterable, *, key=None, reverse=False)

它的主要作用是排序，不过和前面的arr.sort的区别是sorted会返回一个新的排序对象，但不会改变原有的排序方式。

iterable：指的是排序对象
key：指的是排序规则
reverse：是一个布尔值。如果设置为True，则表示排序的顺序是从大到小。

对二维列表进行排序

# 传统
arr = [(3, 4), (1, 6), (5, 8), (8, 4)]


def f(x):
    return x[0]


new_arr = sorted(arr, key=f)
print(new_arr)

# lambda
arr = [(3, 4), (1, 6), (5, 8), (8, 4)]
new_arr = sorted(arr, key=lambda x: x[0])
print(new_arr)

为了让大家能够更好的使用sorted函数的用法，现在我为大家展现其他的案例说明。

1、现有一个字典列表，每个字典中包含着员工的信息，现在需要对员工的年龄进行排序。

employees = [
    {'name': 'Alice', 'age': 30},
    {'name': 'Bob', 'age': 25},
    {'name': 'Charlie', 'age': 35}
]
sort_by_age = sorted(employees, key=lambda x: x['age'])
print(sort_by_age)

2、现有一个人员信息列表，每个元素包含姓名和年龄。要求首先按年龄进行升序排序，年龄相同则按照姓名进行升序排序。

people = [
    {'name': 'Alice', 'age': 30},
    {'name': 'Bob', 'age': 30},
    {'name': 'Charlie', 'age': 25}
]

sorted_people = sorted(people, key=lambda x: (x['age'], x['name']))
print(sorted_people)

那在实际的开发过程中，一般会如何使用sorted函数帮助我们实现呢？

实际案例

思考题

假设我们正在开发图书管理系统，其中需要展示图书的列表，并允许用户根据不同的标准（如书名、作者名、出版年份）对图书进行排序。

图书信息示例

books = [
    {'title': 'python程序设计', 'author': 'Jack', 'year': 2019},
    {'title': '深度学习', 'author': 'lili', 'year': 2017},
    {'title': '机器学习', 'author': 'Alice', 'year': 2016},
    {'title': '数据分析', 'author': 'Bob', 'year': 2018}
]

1、根据作者名进行升序排序，该如何编写？

2、根据出版时间进行降序排序，该如何编写？

3、Map函数的讲解

map(function, iterable, ...)

返回一个将function应用于每一个iterable item的迭代器，从而产生结果。

现在我想对下面列表内的元素进行类型转换

arr = [4, 3, 7, 1, 9]

较为传统的方式，可以采用以下方式

arr = [4, 3, 7, 1, 9]
new_arr = []
for item in arr:
    new_arr.append(str(item))
print(new_arr)

现通过map函数来实现

arr = [4, 3, 7, 1, 9]
new_arr = map(str, arr)
print(new_arr)
print(list(new_arr))

你会发现实现的过程的代码已经减少。

为了让大家对Map函数有更深入的了解，接下来，我们将展示以下案例。

1、提取字典中的某个特定的值

假设，现在有个需要列表，列表中存放的是个人信息，现在使用map函数提取所有人的姓名。

people = [
    {"name": "Alice", "age": 25},
    {"name": "Bob", "age": 30},
    {"name": "Charlie", "age": 35}
]

处理方式：

names = list(map(lambda x: x["name"], people))
print(names)

2、将数字类型的列表格式化为字符串类型，并将每个数据添加货币符号。

prices = [1.99, 2.5, 4.75, 8.99]

formatted_prices = list(map(lambda x: f'${x:.2f}', prices))
print(formatted_prices)

思考题

1、对下面列表中的每个元素进行平方运算

nums = [1, 2, 3, 4, 5, 6, 7, 8, 9]

4、enumerate函数讲解

enumerate(*iterable *, *start = 0 *)

返回一个枚举对象。iterable必须是一个序列，一个迭代器获取其他支持迭代的对象。由enumerate()返回的迭代器的__next__()方法返回一个元组，该元组包含一个计数（从start开始，默认值为0）

arr = ['Spring', 'Summer', 'Fall', 'Winter']
for item in enumerate(arr):
    print(item)

运行结果

(0, 'Spring')
(1, 'Summer')
(2, 'Fall')
(3, 'Winter')

因为，输出的结果有元组构成，元组中包含两个元素，分别是索引的数据，也可也将索引和数据分开打印出来，具体代码如下：

arr = ['Spring', 'Summer', 'Fall', 'Winter']
for index, item in enumerate(arr):
    print(f'index: {index}, season: {item}')

运行结果：

index: 0, season: Spring
index: 1, season: Summer
index: 2, season: Fall
index: 3, season: Winter

为了让大家更好的理解enumerate在开发过程中一般是怎么样使用的，下面我来说说具体的案例。

首先，我们有一个包含多个产品的列表。每个产品是一个字典，包括id、name（产品的名字）、price（产品的价格）、stock（库存）

products = [
    {"id": 1, "name": "T恤", "price": 19.99, "stock": 100},
    {"id": 2, "name": "短袖", "price": 29.99, "stock": 50},
    {"id": 3, "name": "长裤", "price": 39.99, "stock": 0},  # 售罄
    {"id": 4, "name": "毛衣", "price": 89.99, "stock": 20}
]

遍历产品列表，对库存少于30件的价格上调10%

for product in products:
    if product['stock'] < 30 and product['stock'] != 0:
        product['price'] *= 1.1

遍历产品列表，对库存为0件的产品添加标记sold out

for product in products:
    if product['stock'] == 0:
        product['name'] += '(Sold Out)'

遍历产品列表根据不同价格进行分类

budget = []  # 价格低于30的产品
mid_range = []  # 价格在30-60之间的产品
premium = []    # 价格高于60的产品

for product in products:
    if product['price'] < 30:
        budget.append(product['name'])
    elif 30 <= product['price'] < 60:
        mid_range.append(product['name'])
    else:
        premium.append(product['name'])

增加售罄产品的评论数量

comment = [10, 5, 2, 8]
for index, product in enumerate(products):
    if product['stock'] == 0:
        comment[index] += 15
print(comment)

5、zip函数讲解

zip(*iterables)

制作一个迭代器用于聚合来自每个迭代器的元素。

返回元组的迭代器，其中第i个元素包含来自每个参数序列或迭代的第i个元素。

与*操作符一起使用zip()可以用于解压缩列表

x = [1,2,3]
y = ['a', 'b', 'c']
z = ['A', 'B', 'C']
zipped = zip(x, y, z)
print(list(zipped))

输出结果

[(1, 'a', 'A'), (2, 'b', 'B'), (3, 'c', 'C')]

接下来，我们展示一下如何对序列进行解压

pairs = [(1, 'a'), (2, 'b'), (3, 'c')]
numbers, letters = zip(*pairs)
print(numbers)
print(letters)

(1, 2, 3)
('a', 'b', 'c')

为了让大家更加深入的理解到zip函数，接下来我们继续为大家展示相关的案例

假设，现在我们有两个列表，一个是学生的名字，现在想要打印每个学生的名字以及他们对应的分数

students = ['John', 'Smith', 'Mark']
scores = [90, 80, 77]
for student, score in zip(students, scores):
    print(f'{student} score: {score}')

案例

print(list(map(lambda x: float(x[0] + x[1]), score)))

1、合并分数

print(list(map(lambda x: float(x[0] + x[1]), score)))

2、将电影名与分数一一对应

new_scores = list(map(lambda x: float(x[0] + x[1]), score))
print(list(zip(name, new_scores)))

3、筛选出9分以上的电影

new_scores = list(map(lambda x: float(x[0] + x[1]), score))
movies = list(zip(name, new_scores))
scores_by_nine = list(filter(lambda x: x[1] >= 9.0, movies))
print(scores_by_nine)

4、将分数从高到低进行排序

new_scores = list(map(lambda x: float(x[0] + x[1]), score))
movies = list(zip(name, new_scores))
scores_by_nine = list(filter(lambda x: x[1] >= 9.0, movies))
sort_by_movie = sorted(movies, key=lambda x: x[1], reverse=True)
print(sort_by_movie)