# 数据迁移
迁移的概念：就是将模型映射到数据库的过程

生成迁移文件：python manage.py makemigrations

执行迁移：python manage.py migrate

:::note{title="注"}
不需要初始化迁移文件夹，每个应用默认有迁移文件夹migrations
:::



# 基本视图
```pytnon
#首先我们在views.py中建立一个路由响应函数

from django.http import HttpResponse
def welcome(request):
    return HttpResponse('HelloDjango');
    
#接着我们在urls中进行注册
#1.直接访问视图
path(r'hello/',hello,name='hello'),

#2.导入App中的子路由urls.py文件
path('app/',include('App.urls'))

#3.使用命名空间(后面讲解)
path('app/',include(('App.urls','App'),namespace='App'))

#子路由写法如下：
urlpatterns =[

#django1.8,2.0正则表达式写法：不再使用，不推荐
#url(r'^index/$',index),

#Djangov2.0,v3.0,v4.0写法：常用
path(r'hello/',hello,name='hello'),
]
```

:::warning{title="注意"}
如果使用IDE创建工程时同时创建了应用，可能IDE自动在settings.py定义了应用，不要重复定义，不然在启动服务时可能会报下面的错误：
```shell
Watching for file changes with StatReloader
Exception in thread django-main-thread:
Traceback (most recent call last):
  File "E:\Python\Conda\envs\Django\lib\threading.py", line 1016, in _bootstrap_inner
    self.run()
  File "E:\Python\Conda\envs\Django\lib\threading.py", line 953, in run
    self._target(*self._args, **self._kwargs)
  File "E:\Python\Conda\envs\Django\lib\site-packages\django\utils\autoreload.py", line 64, in wrapper
    fn(*args, **kwargs)
  File "E:\Python\Conda\envs\Django\lib\site-packages\django\core\management\commands\runserver.py", line 125, in inner_run
    autoreload.raise_last_exception()
  File "E:\Python\Conda\envs\Django\lib\site-packages\django\utils\autoreload.py", line 87, in raise_last_exception
    raise _exception[1]
  File "E:\Python\Conda\envs\Django\lib\site-packages\django\core\management\__init__.py", line 394, in execute
    autoreload.check_errors(django.setup)()
  File "E:\Python\Conda\envs\Django\lib\site-packages\django\utils\autoreload.py", line 64, in wrapper
    fn(*args, **kwargs)
  File "E:\Python\Conda\envs\Django\lib\site-packages\django\__init__.py", line 24, in setup
    apps.populate(settings.INSTALLED_APPS)
  File "E:\Python\Conda\envs\Django\lib\site-packages\django\apps\registry.py", line 93, in populate
    raise ImproperlyConfigured(
django.core.exceptions.ImproperlyConfigured: Application labels aren't unique, duplicates: user
```
:::

Django——数据迁移和视图函数

# 罗马数字转整数
罗马数字包含以下七种字符: $I， V， X， L，C，D 和 M$。

| 字符 |  数值|
| --- | --- |
| $I$    |         1
$V$       |      5
$X$        |     10
$L$      |       50
$C$       |      100
$D$       |      500
$M $       |     1000 



例如， 罗马数字 2 写做 II ，即为两个并列的 1 。12 写做 $XII$ ，即为 $X + II$ 。 27 写做  $XXVII$, 即为 $XX + V + II$ 。

通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 $IIII$，而是 $IV$。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 $IX$。这个特殊的规则只适用于以下六种情况：

$I$ 可以放在 $V$ (5) 和 $X$ (10) 的左边，来表示 4 和 9。

$X$ 可以放在 $L$ (50) 和 $C$ (100) 的左边，来表示 40 和 90。

$C$ 可以放在 $D$ (500) 和 $M$ (1000) 的左边，来表示 400 和 900。

给定一个罗马数字，将其转换成整数。

示例 1:

输入: s = "$III$"

输出: 3

示例 2:

输入: s = "$IV$"

输出: 4

示例 3:

输入: s = "$IX$"

输出: 9

示例 4:

输入: s = "$LVIII$"

输出: 58

解释: $L$ = 50, $V$= 5, $III$ = 3.

示例 5:

输入: s = "$MCMXCIV$"

输出: 1994

解释: $M$ = 1000, $CM$ = 900, $XC$ = 90, $IV$ = 4.
 
提示：

`1 <= s.length <= 15`

`s` 仅含字符 ($'I', 'V', 'X', 'L', 'C', 'D', 'M'$)

题目数据保证 `s` 是一个有效的罗马数字，且表示整数在范围 [1, 3999] 内

题目所给测试用例皆符合罗马数字书写规则，不会出现跨位等情况。

$IL$ 和 $IM$这样的例子并不符合题目要求，49 应该写作 $XLIX$，999 应该写作 $CMXCIX$ 。

关于罗马数字的详尽书写规则，可以参考 [罗马数字 - Mathematics](https://b2b.partcommunity.com/community/knowledge/zh_CN/detail/10753/%E7%BD%97%E9%A9%AC%E6%95%B0%E5%AD%97#knowledge_article) 。

![罗马数字转整数](https://qncdn.oleehu.xyz/blog/LeetCode/%E7%BD%97%E9%A9%AC%E6%95%B0%E5%AD%97%E8%BD%AC%E6%95%B4%E6%95%B0.png)


```c++
class Solution {
public:
    int romanToInt(std::string s) {
        int num = 0;

        for (int i = 0; i < s.length(); i++) {
            switch (s[i]) {
            case 'I':
                if (i + 1 < s.length() && s[i + 1] == 'V') {
                    num += 4;
                    i++;
                } else if (i + 1 < s.length() && s[i + 1] == 'X') {
                    num += 9;
                    i++;
                } else {
                    num += 1;
                }
                break;
            case 'V':
                num += 5;
                break;
            case 'X':
                if (i + 1 < s.length() && s[i + 1] == 'L') {
                    num += 40;
                    i++;
                } else if (i + 1 < s.length() && s[i + 1] == 'C') {
                    num += 90;
                    i++;
                } else {
                    num += 10;
                }
                break;
            case 'L':
                num += 50;
                break;
            case 'C':
                if (i + 1 < s.length() && s[i + 1] == 'D') {
                    num += 400;
                    i++;
                } else if (i + 1 < s.length() && s[i + 1] == 'M') {
                    num += 900;
                    i++;
                } else {
                    num += 100;
                }
                break;
            case 'D':
                num += 500;
                break;
            case 'M':
                num += 1000;
                break;
            }
        }
        return num;
    }
};
```
# 题解：模拟
作者：力扣官方题解

链接：https://leetcode.cn/problems/roman-to-integer/solutions/774992/luo-ma-shu-zi-zhuan-zheng-shu-by-leetcod-w55p/

来源：力扣（LeetCode）

思路

通常情况下，罗马数字中小的数字在大的数字的右边。若输入的字符串满足该情况，那么可以将每个字符视作一个单独的值，累加每个字符对应的数值即可。

例如 $XXVII$ 可视作 $X+X+V+I+I=10+10+5+1+1=27$。

若存在小的数字在大的数字的左边的情况，根据规则需要减去小的数字。对于这种情况，我们也可以将每个字符视作一个单独的值，若一个数字右侧的数字比它大，则将该数字的符号取反。

例如 $XIV$ 可视作 $X−I+V=10−1+5=14$。

![罗马数字转整数(题解)](https://qncdn.oleehu.xyz/blog/LeetCode/%E7%BD%97%E9%A9%AC%E6%95%B0%E5%AD%97%E8%BD%AC%E6%95%B4%E6%95%B0%EF%BC%88%E9%A2%98%E8%A7%A3%EF%BC%89.png)

```c++
class Solution {
private:
    unordered_map<char, int> symbolValues = {
        {'I', 1},
        {'V', 5},
        {'X', 10},
        {'L', 50},
        {'C', 100},
        {'D', 500},
        {'M', 1000},
    };

public:
    int romanToInt(string s) {
        int ans = 0;
        int n = s.length();
        for (int i = 0; i < n; ++i) {
            int value = symbolValues[s[i]];
            if (i < n - 1 && value < symbolValues[s[i + 1]]) {
                ans -= value;
            } else {
                ans += value;
            }
        }
        return ans;
    }
};

```
复杂度分析

时间复杂度：$O(n)$，其中 $n$ 是字符串 $s$的长度。

空间复杂度：$O(1)$。

LeetCode（罗马数字转整数）

# SystemC模块
systemC模块:
1. 最小的功能容器，具有用于分层连接的状态、行为和结构。
2. 一个C类，它继承了一个systemC基本类:`sc_module`。
3. SystemC的主要结构构件。
4. 用于表示实际系统中的组件。



如何定义systemC模块:
1. `SC_MODULE(module_name){}`:它使用`systemC`定义的宏"`SC_MODULE`"，它是#2的设备。
2. `Struct module_name: public sc_module{}`:继承`sc_module`的`Struct`。
3. 类`module_name: public sc_module {public:}`:继承`sc_module`的类。
注意，与`struct`的“`public`”相比，`class`的默认访问控制模式为“`private`”，与`struct`的“`public`”不同。

如何使用systemC模块:
1. 类`sc_module`的对象只能在细化过程中构造。在模拟过程中实例化模块是错误的。
2. 每个直接或间接从`sc_module`派生的类都应该至少有一个构造函数。每个构造函数应该有且只有一个`sc_module_name`类的参数，但可以有`sc_module_name`以外的其他类的参数。
3. 一个字符串值的参数应该传递给每个模块实例的构造函数。如果存在这样的变量，则使该字符串名称与引用模块的C变量名称相同是一种良好的做法。
4. 模块间通信通常应该使用接口方法调用来完成;也就是说，模块应该通过其端口与其环境通信。其他通信机制是允许的，例如，用于调试或诊断目的。

# SystemC_Module.cpp
```c++
#include <systemc>
using namespace sc_core;

SC_MODULE(MODULE_A) { // 方法#1，使用systemC提供的SC_MODULE宏
  SC_CTOR(MODULE_A) { // 默认构造函数
    std::cout << name() << " constructor" << std::endl; // Name()返回对象名称，该名称在实例化期间提供
  }
};
struct MODULE_B : public sc_module { // 方法#2，使用c语法，可读性更强
  SC_CTOR(MODULE_B) {
    std::cout << name() << " constructor" << std::endl;
  }
};
class MODULE_C : public sc_module { // 方法#3，使用class代替struct
public: // 必须显式声明构造函数为public 
  SC_CTOR(MODULE_C) {
    std::cout << name() << " constructor" << std::endl;
  }
};

int sc_main(int, char*[]) { // 系统入口点
  MODULE_A module_a("module_a"); // 声明并实例化module_a，通常的做法是分配模块名==对象名
  MODULE_B module_b("modb"); // 声明并实例化module_b，模块名!=对象名
  MODULE_C module_c("module_c"); // 声明并实例化module_c
  sc_start(); // 在本例中可以跳过这一点，因为模块实例化发生在精化阶段，在sc_start之前
  return 0;
}
```
# 结果

```c++
        SystemC 2.3.3-Accellera --- Oct  4 2020 22:59:38
        Copyright (c) 1996-2018 by all Contributors,
        ALL RIGHTS RESERVED
module_a constructor
modb constructor
module_c constructor
```

SystemC入门（三）——SystemC模块

# 安装Django
可以直接使用pip或conda命令安装，各个Django对应的Python版本参照官方链接。https://docs.djangoproject.com/zh-hans/

测试Django是否安装成功:`pip show django`。



# 创建一个Django项目
●方式一：进入到指定要存放项目的目录，执行`django-admin startproject 项目名称`来创建一个工程。

●方式二：使用Pycharm专业版等IDE创建Django项目.

创建项目后，默认的目录结构：

manage.py:
- 是Django用于管理本项目的命令行工具，之后进行站点运行，数据库自动生成等都是通过本文件完成。

项目名称/__init__.py:
- 告诉python该目录是一个python包，暂无内容，后期一些工具的初始化可能会用到。

项目名称/settings.py:
- Django项目的配置文件，默认状态其中定义了本项目引用的组件，项目名，数据库，静态资源等。

```python
from pathlib import Path

# 项目根目录
# 当前文件的父目录的父目录

BASE_DIR = Path(__file__).resolve().parent.parent

# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = 'django-insecure-^m-243x3%5m61#2&t^*oxda!4d=0r!81qcu40!x$+4=r3dg025'

# 是否使用调试模式。
# Ture：调试模式，自动重启，一般用于开发中
# False：非调试模式，一般用于上线部署
DEBUG = True

# 服务器允许的域名列表或ip地址。
# *: 任何域名和ip地址
ALLOWED_HOSTS = ['*']

# 定义应用

INSTALLED_APPS = [
	'django.contrib.admin',
	'django.contrib.auth',
	'django.contrib.contenttypes',
	'django.contrib.sessions',
	'django.contrib.messages',
	'django.contrib.staticfiles',
	'user.apps.UserConfig',
	# 要在下面定义自己的应用于开发中。

]
# 中间件
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',
]
# 跟路由
ROOT_URLCONF = 'djangoProject1.urls'

# 模板
TEMPLATES = [
	{
		'BACKEND': 'django.template.backends.django.DjangoTemplates',
		'DIRS': [BASE_DIR / 'templates']
		,
		'APP_DIRS': True,
		'OPTIONS': {
			'context_processors': [
				'django.template.context_processors.debug',
				'django.template.context_processors.request',
				'django.contrib.auth.context_processors.auth',
				'django.contrib.messages.context_processors.messages',
			],
		},
	},
]

# WSGI目录
WSGI_APPLICATION = 'djangoProject1.wsgi.application'

# Database
DATABASES = {
	'default': {
		'ENGINE': 'django.db.backends.sqlite3',
		'NAME': BASE_DIR / 'db.sqlite3',
	}
}

# 密码验证
AUTH_PASSWORD_VALIDATORS = [
	{
		'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
	},
	{
		'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
	},
	{
		'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
	},
	{
		'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
	},
]

# 国际化
LANGUAGE_CODE = 'en-us' # 默认英语，zh-hans

TIME_ZONE = 'UTC'

USE_I18N = True

USE_TZ = True

# 静态文件 (CSS, JavaScript, Images)
STATIC_URL = 'static/'

# 默认的组件字段类型
DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'

```
项目名称/urls.py:
- 维护项目的URL路由映射，即定义当客户端访问时由哪个模块进行响应。

项目名称/wsgi.py:
- 全称为Python Web Server Gateway Interface,即Python服务器网关接口，是Python应用与Web服务器之间的接口，用于Django项目在服务器上的部署和上线，一般不需要修改。

项目名称/asgi.py:
- 定义ASGI的接口信息，和WSGI类似，在3.0以后新增ASGI,相比WSGI,ASGI实现了异步处理，用于启动异步通信服务，比如：实现在线聊天等异步通信功能。(类似Tornado异步框架)。

# 创建应用
使用`python manage.py startapp App`命令或IDE创建Django应用。

创建名称为App的应用使用应用前需要将应用配置到项目中，***在settings.py中将应用加入到INSTALLED_APPS选项中***。

应用目录介绍：

_init__.py:
- 其中暂无内容，使得app成为一个包。

admin.py:
- 管理站点模型的声明文件，默认为空。

apps.py:
- 应用信息定义文件，在其中生成了AppConfig,该类用于定义应用名等数据。

models.py:
- 添加模型层数据类文件。

yiews.py:
- 定义URL相应函数，视图函数。

migrations包：
- 自动生成，生成迁移文件的。

tests.py:
- 测试代码文件。

# 测试服务器的启动
使用`python manage.py runserver [ip:port]`命令启动服务器。

可以直接进行服务运行默认执行起来的端口是8000。

也可以自己指定ip和端口：

1.监听机器所有可用ip (电脑可能有多个内网ip或多个外网ip):`python manage.py runserver 0.0.0.0:8000`。

2.同时在settings.py中将`ALLOWED_HOSTS=['*']`。

3.在其他局域网电脑上可以通过在浏览器输入Django项目所在电脑的IP:8000来访问

Django——建立和启动工程

# 回文数
给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。

回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

例如，121 是回文，而 123 不是。
 



示例 1：

输入：`x = 121`

输出：`true`

示例 2：

输入：`x = -121`

输出：`false`

解释：从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。

示例 3：

输入：`x = 10`

输出：`false`

解释：从右向左读, 为 01 。因此它不是一个回文数。
 

提示：

`-231 <= x <= 231 - 1`
 

进阶：你能不将整数转为字符串来解决这个问题吗？
![回文数](https://qncdn.oleehu.xyz/blog/LeetCode/%E5%9B%9E%E6%96%87%E6%95%B0.png)

```c++
class Solution {
public:
    bool isPalindrome(int x) {
        if(x<0){
            return false;
        }
        else{
            std::string str = std::to_string(x);
            reverse(str.begin(), str.end());
            
            //int num = std::stoi(str);
            long int num = stol(str);
            if(num==x){
                return true;
            }
            else {return false;}
        }

    }
};
```
如果用`int num = std::stoi(str);`将会报错`terminate called after throwing an instance of 'std::out_of_range'`
` what():  stoi`，这是因为倒置后的数字太大，超出了`int`类型的范围，所以用`long int num = stol(str);`转换为`long int`。

# 题解：反转一半数字
作者：力扣官方题解

链接：https://leetcode.cn/problems/palindrome-number/solutions/281686/hui-wen-shu-by-leetcode-solution/

来源：力扣（LeetCode）

- 思路

映入脑海的第一个想法是将数字转换为字符串，并检查字符串是否为回文。但是，这需要额外的非常量空间来创建问题描述中所不允许的字符串。

第二个想法是将数字本身反转，然后将反转后的数字与原始数字进行比较，如果它们是相同的，那么这个数字就是回文。
但是，如果反转后的数字大于 `int.MAX`，我们将遇到整数溢出问题。

按照第二个想法，为了避免数字反转可能导致的溢出问题，为什么不考虑只反转 `int` 数字的一半？毕竟，如果该数字是回文，其后半部分反转后应该与原始数字的前半部分相同。

例如，输入 `1221`，我们可以将数字 “`1221`” 的后半部分从 “`21`” 反转为 “`12`”，并将其与前半部分 “`12`” 进行比较，因为二者相同，我们得知数字 `1221` 是回文。

- 算法

首先，我们应该处理一些临界情况。所有负数都不可能是回文，例如：`-123` 不是回文，因为 `-`不等于 `3`。所以我们可以对所有负数返回 `false`。除了 `0` 以外，所有个位是 `0` 的数字不可能是回文，因为最高位不等于 `0`。所以我们可以对所有大于 `0` 且个位是 `0` 的数字返回 `false`。

现在，让我们来考虑如何反转后半部分的数字。

对于数字 `1221`，如果执行 `1221 % 10`，我们将得到最后一位数字 `1`，要得到倒数第二位数字，我们可以先通过除以 `10` 把最后一位数字从 `1221` 中移除，`1221 / 10 = 122`，再求出上一步结果除以 `10` 的余数，`122 % 10 = 2`，就可以得到倒数第二位数字。如果我们把最后一位数字乘以 `10`，再加上倒数第二位数字，`1 * 10 + 2 = 12`，就得到了我们想要的反转后的数字。如果继续这个过程，我们将得到更多位数的反转数字。

现在的问题是，我们如何知道反转数字的位数已经达到原始数字位数的一半？

由于整个过程我们不断将原始数字除以 `10`，然后给反转后的数字乘上 `10`，所以，当原始数字小于或等于反转后的数字时，就意味着我们已经处理了一半位数的数字了。

![回文数（题解）](https://qncdn.oleehu.xyz/blog/LeetCode/%E4%B8%A4%E6%95%B0%E4%B9%8B%E5%92%8C%EF%BC%88%E9%A2%98%E8%A7%A3%EF%BC%89.png)

```c++
class Solution {
public:
    bool isPalindrome(int x) {
        // 特殊情况：
        // 如上所述，当 x < 0 时，x 不是回文数。
        // 同样地，如果数字的最后一位是 0，为了使该数字为回文，
        // 则其第一位数字也应该是 0
        // 只有 0 满足这一属性
        if (x < 0 || (x % 10 == 0 && x != 0)) {
            return false;
        }

        int revertedNumber = 0;
        while (x > revertedNumber) {
            revertedNumber = revertedNumber * 10 + x % 10;
            x /= 10;
        }

        // 当数字长度为奇数时，我们可以通过 revertedNumber/10 去除处于中位的数字。
        // 例如，当输入为 12321 时，在 while 循环的末尾我们可以得到 x = 12，revertedNumber = 123，
        // 由于处于中位的数字不影响回文（它总是与自己相等），所以我们可以简单地将其去除。
        return x == revertedNumber || x == revertedNumber / 10;
    }
};
```
复杂度分析

时间复杂度：`O(log⁡n)`，对于每次迭代，我们会将输入除以 `10`，因此时间复杂度为 `O(log⁡n)`。
空间复杂度：`O(1)`。我们只需要常数空间存放若干变量。