## 题目
```
给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

 



示例 1：

输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。
示例 2：

输入：nums = [1]
输出：1
示例 3：

输入：nums = [0]
输出：0
示例 4：

输入：nums = [-1]
输出：-1
示例 5：

输入：nums = [-100000]
输出：-100000
 

提示：

1 <= nums.length <= 3 * 104
-105 <= nums[i] <= 105
 

进阶：如果你已经实现复杂度为 O(n) 的解法，尝试使用更为精妙的 分治法 求解。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximum-subarray
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
```
## 自己花了很长时间的，代码改善
```
class Solution:
    def maxSubArray(self, a) :
        if len(a)==1:
            return a[0]
        result =sum(a)
        max_a  = max(a)
        max_index =a.index(max_a)
        result1,result2=[],[]
        if max_index !=0:
            for i in range(0,max_index+1):
                max_li = a[i:max_index+1]
                if sum(max_li) >result and len(max_li)!=0:
                    result1 = max_li
                    result = sum(result1)
        if max_index !=len(a)-1:
            for j in range(max_index+1,len(a)):
                max_li = a[max_index:j]
                if sum(max_li)>result and len(max_li)!=0:
                    result2 =max_li
                    result = sum(result2)
        if result1 and result2:
            result1.extend(result2[1:])
        return result

```
但是，还是有问题，自己后来看了看正确答案，对比了一下：

```
class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        # 定义dp[i]为前i个数里面的最大子序和
        # 举个例子：
        # nums: [-2, 1, 2] max = 1+2 = 3，最大子序和肉眼可见地为3
        # dp[0]:[-2, 0, 0] dp[0] = -2 初始化
        # 面临抉择：要不要把前面的最优算进来？如果算进来，就是dp[i-1]+nums[i], 如果不算，就是nums[i] 
        # dp[1]:[-2, 1, 0] max(1, -2+1) = max(1, dp[0]+1) = 1
        # dp[2]:[-2, 1, 3] max(2, dp[1]+2) = 3
        # 所以dp[i] = max(num[i], d[i-1]+num[i])
        # return max(dp)就好

        n = len(nums)
        dp = [0]*n
        dp[0] = nums[0]

        for i in range(1,n):
            dp[i] = max(nums[i], dp[i-1]+nums[i])
        return max(dp)

作者：yun6688
链接：https://leetcode-cn.com/problems/maximum-subarray/solution/pythonjie-fa-zui-da-zi-xu-he-by-yun6688-r4h1/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
```

## 需要改进的地方

1. 思路完全不是一个方向的，自己总想着先搞出列表来，然后再搞出最后的值。其实自己的目标错了，最终的结果，只要最大的值，就可以，不需要具体的列表是什么，所以自己相当于走个弯路。
2. max的使用，对于两两比较，这种认识不清楚。还老是使用if和对比的方法来进行判断。
3. 解决问题的关键：大神的解法，保留了之前的值，所以到最后，会不断进行叠加，然后最后一位肯定是里边最大的。但是，怎么保持连续呢。因为是先进行叠加，然后来进行比较，所以它可以保持值是最大的。如果出现小的话，根本不会往后边继续循环。
4. 总的来说，关于算法的题，自己还是需要自己多多练习，多多总结，多多试错，才能成长。加油@@@@@@@@


![image.png](https://www.choumaomi.com/static/img/99aa85d5e2b1e289395d75cbf62ebd82.image.png)

算法题-返回最大的和

​
## 1、什么是中间件以及中间件的工作原理

 
中间件事一个镶嵌到django的request/response处理机制中的一个钩子框架。它是一个可以修改django全局输入和输出的一个底层插件系统。



换句话说

HTTP Web服务器工作原理一般都是接受用户发来的请求（request），然后给出响应（resonse）。Django也不例外，其一般工作方式是接受request对象和其他参数，交由视图(view)处理，然后给出它的响应数据：渲染过的html文件或json格式的数据。

然而在实际工作中并不是接收到request对象后，马上交给殊途函数或类处理，也不是在view执行后立马给用户返回response。

事实上，Django最初接受的是HttpRequest对象，而不是request对象，正是中间件的作用把HttpRequest对象和user对象打包成了一个全局变量request对象，这样你才可以view中使用request作为变量或者在模版中随意调用request.user

>中间件在整个django的request/response处理机制中的角色如下所示：

>HttpRequest —— Middleware  —— View  —— Middleware  ——  HttpResponse

正是由于一个请求HttpRequest在传递给视图view处理前要经过中间件处理，经过View处理后的响应也要经过中间件处理才能返回给用户，我们可以编写自己的中间件实现权限校验，限制用户请求、打印日志、改变输出内容等多种应用场景，比如：

* 禁止特定IP地址的用户或未登录的用户访问我们的view视图函数
* 对同一IP地址单位时间内发送的请求数量做出限制
* 在View视图函数执行前记录用户的IP地址
* 在View视图函数执行前传递额外的变量或参数
* 在View视图函数执行前或执行后把特定信息打印到log日志
* 在View视图函数执行后对response数据进行修改后返回给用户

值得一提的是中间件对django的输入或输出的改变是全局的，反之亦然，如果让你希望对django的输入或输出做出全局性的改变时，需要使用中间件。

举个例子：用@login_required装饰器要求用户必须先登陆才能访问我们的视图函数。试想我们有个网站绝大部分视图函数都需要用户登陆，每个视图函数前面都需要加上@login_required装饰器是比较傻的行为。借助于中间件，我们无需使用装饰器即可全局实现；

只有登陆用户才能访问视图函数，匿名用户跳转到登陆页面。实现原理也很简单：在一个request达到视图函数前，我们先对request.user是否验证通过进行判断，然后再进行跳转。

另外Django对Post表单中携带的CSRF token的全局校验也是通过csrfViewMiddleware这个中间件进行的，而不是通过单个装饰器实现的。

## 2、Django自带中间件介绍
```
MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]
```

* SecurityMiddleware：为request/response提供了几种安全改进，无它不安全
* SessionMiddleware: 开启session会话支持，无它无session
* CommonMiddleware：基于APPEND_SLASH和PREPEND_WWW的设置来重写URL。如果APPEND_SLASH设为true，并且初始化url没有以斜线结尾以及在URLconf中没找到对应定义，这时形成一个斜线结尾的新的URL；如果PREPEND_WWW设为true，前面缺少www.的url将会被重定向到相同但是以一个www.开头的url。
* CsrfViewMiddleware：添加跨站点请求伪造的保护，通过向POST表单添加一个隐藏的表单字短，并检查请求中是否有正确的值，无它无Csrf保护
* AuthenticationMiddleware：在视图函数执行前向每个接受到的user对象添加HttpRequest属性，表示当前登陆的用户。
* MessageMiddleware：开启基于cookie和会话的消息支持
* XFrameOptionsMIddleware：对点击劫持的保护。

如果你要实现全站缓存，还需要使用UpdateCacheMiddleware和FetchFromCacheMiddleware，但一定要注意它们的顺序，Update在前和Fetch在后。
```
MIDDLEWARE = [
    'django.middleware.cache.UpdateCacheMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.cache.FetchFromCacheMiddleware',
]
```
除此之外，Django还提供了压缩网站内容的GzipMiddleware，根据用户请求语言返回不同内容的localeMiddleware和给GET请求附加条件的ConditionalGetMiddleware。这些中间件都是可选的。

## 3、Django的中间件执行顺序

当你在settings.py注册中间件时一定要考虑中间件的执行顺序，中间件在request达到view之前是从上向下执行的，在view执行完成后返回response过程是从下向上执行的。


![image.png](https://www.choumaomi.com/static/img/b33c2a0ec247175f4f1e9d4d8959f31e.image.png)

### 1.自定义中间件

自定义中间件你首先要在app所属目录下新建一个文件middleware.py，添加好编写的中间代码，然后在项目settings.py中把它添加到middleware列表进行注册，添加时一定要注意顺序，Django提供了两种编写自定义中间件的形式：函数和类，基本框架如下所示：

1. 函数实现方式
```
def simple_middleware(get_response):
# One-time configuration and initialization. 一次性设置和初始化

    def middleware(request):
        # Code to be executed for each request before
# the view (and later middleware) are called.
        # request请求到达视图函数执行前的代码

        response = get_response(request)

        # Code to be executed for each request/response after
        # the view is called. 视图函数执行后的代码

        return response

    return middleware
```    

2. 类实现方式
```
class SimpleMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response
        # One-time configuration and initialization.一次性设置和初始化

    def __call__(self, request):
        # Code to be executed for each request before
# the view (and later middleware) are called.
        # 视图函数执行前的代码

        response = self.get_response(request)

        # Code to be executed for each request/response after
        # the view is called. 视图函数执行后的代码

        return response
```


运用到实际案例中。我们编写一个MyFirstMiddleware的中间件，介入到了django的request/response整个处理过程，打印出请求执行过程，并在视图函数前打印出用户是否登陆：
```
class MyFirstMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response
        # One-time configuration and initialization.一次性设置和初始化

    def __call__(self, request):
        # Code to be executed for each request before
        # the view (and later middleware) are called.
        print("接收到request请求，视图函数马上执行")
        if not request.user.is_authenticated:
            print("该请求用户尚未登录")

        response = self.get_response(request)
        # Code to be executed for each request/response after
        # the view is called. 视图函数执行后的代码
        print("视图函数执行结束，准备提供响应")

        return response
```


在settings.py里注册，最后一个中间件是自定义的，app名为users
```

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
    'users.middleware.MyFirstMiddleware',
]
```

因为我们自定义的中间件依赖于request对象，我们一定要放在AuthenticationMiddleware的后面。注册好中间件后，如果你运行 python manage.py runserver 你就会看到输出。

[参考链接](https://mp.weixin.qq.com/s?__biz=MjM5OTMyODA4Nw==&mid=2247484447&idx=1&sn=1c8292f771ae69e7b7313d46a9fb212f&chksm=a73c6427904bed315f108724384a1f3c134ec1bc2dd09d08f5227b0debbfd219fd0864f48fe2&scene=21#wechat_redirect)

django中间件

消息队列的对比

Real-world Interview Questions

# nginx的正向代理和反向代理

## 1.一句话解释
* 系统内部服务需要访问外部第三方地址，通过nginx配置代理出去为正向代理
* 外部用户访问内部服务通过nginx代理进入的反向代理



## 2. 正向代理
### 专业解释
正向代理服务器位于客户端和服务器之间，

为了从服务器之间，为了从服务器上获取数据，

客户端向代理服务器发起请求，然后服务器返回数据到客户端，这个代理是代理的客户端的请求

正向代理，对于服务来讲，来源地址是一个整体

### nginx配置示例
```shell
server {
  listen 8000；
  server_name localhost；
  
  location /proxy_zhihu/ {
      proxy_pass http://zhihu.com/;
  }
}
```

## 3. 反向代理
### 专业解释
客户端发起请求，实际对侯曼的处理流程是没有知晓的

代理服务器是接受客户端的请求，然后代理服务器一般会从所代理的节点中选择一个节点去获取数据

然后返回给客户端，此时反向代理服务器与后端服务器是一个整体

### nginx配置示例
```shell
upstream app{
  server 192.168.10.1:8000;
  server 192.168.10.2:8000;
}


server {
  listen 8000;
  server_name localhost;
  
  localtion / {
    proxy_pass htpp://app;
  }
}

```

## 4. 相关的程序及文件路径如下:
* 程序文件: 放在/usr/sbin/nginx目录中
* 全局配置文件: /etc/nginx/nginx.conf
* 访问日志文件: /var/log/nginx/access.log
* 错误日志文件: /var/log/nginx/error.log
* 站点配置文件: /etc/nginx/sites-enabled/default


## 5. 相关操作命令
```
sudo service nginx stop
sudo service nginx status
sudo service nginx restart

```