CREATETRIGGER trg_check_insert_sc BEFORE INSERTON SC FOREACHROW BEGIN DECLARE student_exists INT; DECLARE course_exists INT; -- 检查学号是否存在 SELECTCOUNT(*) INTO student_exists -- 把查询出来的结果写入student_exists FROM Student WHERE Sno = NEW.Sno; -- 默认新插入的一行为new IF student_exists =0THEN SIGNAL SQLSTATE'45000' SET MESSAGE_TEXT ='错误：学号不存在于学生表中！'; END IF; -- 检查课程号是否存在 SELECTCOUNT(*) INTO course_exists FROM Course WHERE Cno = NEW.Cno; IF course_exists =0THEN SIGNAL SQLSTATE'45000' SET MESSAGE_TEXT ='错误：课程号不存在于课程表中！'; END IF; -- 检查成绩是否在0-100范围内 IF NEW.Score <0OR NEW.Score >100THEN SIGNAL SQLSTATE'45000' SET MESSAGE_TEXT ='错误：成绩必须在0-100范围内！'; END IF; END$$
graph LR A[红外遥控器] -->|红外信号| B[红外接收模块] B -->|电平信号| C[51单片机] C -->|段码/位选| D[数码管显示模块] style A fill:#e1f5ff style B fill:#ffe1e1 style C fill:#fff4e1 style D fill:#e1ffe1
graph TD A[main.c 主程序] --> B[ired模块<br/>红外接收] A --> C[smg模块<br/>数码管显示] A --> D[public模块<br/>公共函数] B --> E[ired_init<br/>红外初始化] B --> F[中断服务函数<br/>信号解析] C --> G[smg_display<br/>动态扫描显示] D --> H[delay_10us<br/>微秒延时] D --> I[delay_ms<br/>毫秒延时] style A fill:#ffcccc style B fill:#ccffcc style C fill:#ccccff style D fill:#ffffcc
4.2 程序流程设计
4.2.1 主程序流程
flowchart LR A([开始]) --> B[红外初始化] --> C[主循环] --> D{按键0-20?} D -->|是| E[十进制显示] --> F[刷新数码管] D -->|否| G[十六进制显示] --> F F --> C
主程序设计要点：
初始化红外接收模块（配置外部中断0）
进入主循环，持续检测红外数据
根据接收到的控制码，映射到对应的按键编号（0-20）
根据按键编号选择显示模式：
0-9：左位空白，右位显示个位
10-20：左位显示十位，右位显示个位
其他：显示十六进制编码
调用数码管显示函数更新显示内容
4.2.2 红外接收流程
flowchart LR A([中断触发]) --> B[检测引导码] --> C[接收4字节数据] --> D{校验通过?} D -->|是| E[保存数据] D -->|否| F[清零数据] E --> G([返回]) F --> G
NEC协议解析要点：
引导码识别：9ms低电平 + 4.5ms高电平
数据位解码：
每位以0.56ms低电平开始
数据"0"：0.56ms高电平
数据"1"：1.68ms高电平
数据格式：4字节（地址码 + 地址反码 + 控制码 + 控制反码）
校验机制：控制码与控制反码互为按位取反，用于验证数据正确性
4.2.3 数码管显示流程
flowchart LR A([smg_display]) --> B[循环8位] --> C[位选控制] --> D[输出段码] --> E[延时] --> F{继续?} F -->|是| B F -->|否| G([返回])
动态扫描原理：
利用人眼视觉暂留效应（>50Hz刷新率）
依次点亮每一位数码管，快速循环扫描
每位显示时间约1-2ms，总刷新周期约8-16ms
4.3 核心代码分析
4.3.1 按键映射表（main.c）
本系统将红外遥控器的21个按键映射到0-20的编号：
1 2 3 4 5 6 7 8
// 红外遥控器从上到下从左到右21个键对应0-20（行优先，每行3个按钮） switch(gired_data[2]) { case0x45: num = 0; break; // 第1行第1个 case0x46: num = 1; break; // 第1行第2个 case0x47: num = 2; break; // 第1行第3个 // ... 以此类推 case0x4A: num = 20; break; // 第7行第3个 }
/*-------------------------------------------------------------------------- REG52.H Header file for generic 80C52 and 80C32 microcontroller. Copyright (c) 1988-2002 Keil Elektronik GmbH and Keil Software, Inc. All rights reserved. --------------------------------------------------------------------------*/
Imagine you can call only the following three functions:
f(x): Subtracts one from an integer x
g(x): Doubles an integer x
h(x, y): Concatenates the digits of two different positive integers x and y. For example, h(789, 12) evaluates to 78912 and h(12, 789) evaluates to 12789.
Definition: A small expression is a call expression that contains only f, g, h, the number 5, and parentheses. All of these can be repeated. For example, h(g(5), f(f(5))) is a small expression that evaluates to 103.
What’s the shortest small expression you can find that evaluates to 2024?
环境图：So environment diagrams are a way for us to keep track of what’s going on within the Python interpreter when it executes a program that we type in.they are the way in which an interpreter for a programming language keeps track of what names mean.So it’s sort of memory that keeps track of the bindings between names and values.
summary:An environment is a sequence of frames. A frame is a binding between names and values,one of the boxes in the environment diagram.涉及到局部变量和全局变量的使用。
交互式会话，Python的交互式会话会以>>> 为开头。开启Python会话的方法是： Type python3 at a terminal prompt (Mac/Unix/Linux) or open the Python 3 application in Windows. 会话中会记录代码历史，按ctrl+p(previous)/n(next)查看历史，或者是键盘上下键，Ctrl+d退出会话。
ch1.3 同样重点介绍函数，其中A description of the formal parameters of a function is called the function's signature. 点明了函数签名的本质 Bind the arguments to the names of the function's formal parameters in a new local frame. 指明函数定义的细节，比如from math import sin 就是定义了一个全局“变量”sin，使得名字sin 与math库中的内置函数sin绑定(bind)在一起，所以sin可作为函数执行相关操作，但全局变量sin的任何改变都不影响内置函数的sin，同理，def add(a,b): return a+b是将名称(name)add与用户定义的函数add绑定。函数的形式参数也是这样，在函数调用的时候就定义了一个局部变量(比如x),然后将x名称(name)与值绑定，也就是x=2,一旦函数调用完，其本地框架(local frame)也不复存在，所以这就是局部变量不影响全局变量的原理。
函数的本质
The domain of a function is the set of arguments it can take. The range of a function is the set of values it can return. The intent of a function is the relationship it computes between inputs and output (as well as any side effects it might generate)
Each function should have exactly one job：每一个函数都应该有一个确定的功能且=
Don’t repeat yourself is a central tenet of software engineering(DRY principle)：减少重复，一旦出现重复就要考虑函数或者是其他的抽象封装。
Functions should be defined generally： 定义函数的时候要笼统，或者说普适性 能写出pow这种能得到任意次幂的函数就不要用sqrt这种只能开方的函数。
Functions with many arguments can be awkward to call and difficult to read.：函数的参数不宜过多，对于很少改变的形式参数可以设置默认值(比如阿伏伽德罗常数、重力加速度等)
如何写一个好的文档(准确的说是函数的注释)
Docstrings are conventionally triple quoted：函数的注释要使用三引号
The first line describes the job of the function in one line. The following lines can describe arguments and clarify the behavior of the function.第一行描述函数的功能，后面几行介绍参数和明确函数的行为。示例代码如下
1 2 3 4 5 6 7 8 9 10 11
defpressure(v, t, n): """Compute the pressure in pascals of an ideal gas. 计算理想气体的帕斯卡压强 Applies the ideal gas law: http://en.wikipedia.org/wiki/Ideal_gas_law 应用理想气体定律： 网站链接 v -- volume of gas, in cubic meters v -- 气体体积，立方米 t -- absolute temperature in degrees kelvin t -- 绝对温度，开尔文 n -- particles of gas n -- 气体粒子 """ k = 1.38e-23# Boltzmann's constant 玻耳兹曼常数 return n * k * t / v
code is written only once, but often read many times:代码只会写一次，但是会被阅读成千上万次。可以参考Python的文档编写指导学习docstring guidelines
This definition exposes the essential structure of a recursively defined sequence: a sequence can be decomposed into its first element and the rest of its elements. 用中文的话说就是：一棵树上有多少片叶子，答案是一片叶子，以及剩下的叶子。当你重复这样做的时候，叶子数量也就被你数出来了。
When the expression being asserted evaluates to a true value, executing an assert statement has no effect. When it is a false value, assert causes an error that halts execution
defsum_naturals(n): """Return the sum of the first n natural numbers. >>> sum_naturals(10) 55 >>> sum_naturals(100) 5050 """ total, k = 0, 1 while k <= n: total, k = total + k, k + 1 return total
# 定义一个自定义函数 defsum_naturals(n): """返回从1到n的自然数之和 >>> sum_naturals(10) 55 >>> sum_naturals(100) 5050 """ total, k = 0, 1 while k <= n: total, k = total + k, k + 1 return total
defrace(x, y): """The tortoise always walks x feet per minute, while the hare repeatedly runs y feet per minute for 5 minutes, then rests for 5 minutes. Return how many minutes pass until the tortoise first catches up to the hare. >>> race(5, 7) # After 7 minutes, both have gone 35 steps 7 >>> race(2, 4) # After 10 minutes, both have gone 20 steps 10 """ assert y > x and y <= 2 * x, 'the hare must be fast but not too fast' tortoise, hare, minutes = 0, 0, 0 while minutes == 0or tortoise > =hare: # 修改的地方 tortoise += x if minutes % 10 < 5: hare += y minutes += 1 return minutes
int a = 10; if (10 == a) { cout << "a=10" << endl; } //如果你写成=会自动给你报错,防止出事 if(10 = a) { }
循环语句的效率
规则
建议将最长的循环放在内层,减少CPU跨切循环层的次数
逻辑判断最好在循环外面
示例
1 2 3 4 5 6 7 8 9 10 11 12
//不用for循环里面每次都判断条件,提高了效率 if (condition) { for (i=0;i<N;i++) DoSomething(); } else { for (i=0;i<N;i++) DoOtherthing(); }
for循环与switch多分支
规则
不要轻易在for里面改变循环变量
for循环控制变量取值采用前闭后开的方法.能写for (int i = 0;i < 5;i++) 就不要写`for (int i = 0;i <=4;i++)
每个case都要写break防止case击穿.保留default语句
goto
慎用goto,用的好能跳出重重封锁(比如嵌套循环),用不好就万劫不复
常量
使用常量的好处在于一劳永逸,见文知意
规则
用常量表示多次出现的数字或者字符串
建议用const代替#define,方便调试.
公开的常量放在头文件中,不公开的放在定义文件中
常量之间有关联的用常量代替而不是用数字
示例
1 2 3 4 5
#define MAX 100 /*C语言的宏常量*/ constint MAX = 100; //C++语言的const常量 constfloat PI = 3.14159; //C++语言的const常量 const string NAME = "Lloyd"; constint NUN = MAX * 10;
类中设计常量 不能直接用const,建议使用枚举
示例
1 2 3 4 5 6 7
classA { enum{SIZE1=100,SIZE2=200};//枚举常量 int array_fir[SIZE1]; int array_sec[SIZE1]; }
char a[] = "hello"; char b[10]; strcpy(b, a);//不能用b = a; if (strcmp(b, a) == 0) {};// 不能用if(b = a)
//指针 int num = 10; int *a = # int len = strlen(a); char* p = (char*)malloc(sizeof(char) * (len + 1)); strcpy(p, a); //不要用p=a; if (strcmp(p, a) == 0) // 不要用if(p = a)
接下来就从写好一篇文章开始讲解代码是什么.首先,写作者的名字,这就引出了“版权和版本“的声明,表明作品是你写的,作品处于哪个阶段.然后,给人物取名字,一般老师会让学生用什么典雅的古文等方法给人物取名,不过在计算机这里就不适用了,要简洁直白,能叫"many"就不要用"quite a number of",又不是给英语作文凑字数(doge)
sequenceDiagram participant Alice participant Bob Alice->>John: Hello John, how are you? loop HealthCheck John->>John: Fight against hypochondria end Note right of John: Rational thoughts <br/>prevail! John-->>Alice: Great! John->>Bob: How about you? Bob-->>John: Jolly good!
除了计算机编程外，我想不出还有其他让我感兴趣的工作。 我可以无中生有地创造出精美的范式和结构， 在此过程中也解决了无数的小谜团。 I can’t think of any other job other than computer programming that interests me. I can create beautiful paradigms and structures out of nothing, Countless small mysteries are also solved in the process.
text ,颜色可选default/blue/pink/red/purple/orange/green红色]]>主要用于测试hexo新功能和butterfly主题相关的一些新特性,在不确定效果的时候优先以本文件作为测试用例算法系列(四)从零开始的算法刷题生活https://lloydkai.cn/posts/algorithm-restart/2025-03-02T12:50:14.000Z2026-04-23T01:45:40.606Z
std::queue<Node*> q; q.push(root); int depth = 1; while (!q.empty()) { int sz = q.size(); for (int i = 0; i < sz; i++) { Node* cur = q.front(); q.pop();
int ord;//DFS序计数 int rnk[MAXN];//rnk[i]代表入序为i的节点编号
structNODE { int fa;//当前节点的父节点 int in;//当前节点的DFS入序 int out;//当前节点的DFS出序 int son;//当前节点的重儿子编号 int top;//当前节点所需链的首节点编号 int deep;//当前节点在树中的深度 int size;//当前节点的子树大小 };
#include<bits/stdc++.h> usingnamespace std; constint N = 1e5+9;
structEdge { int x, y, c; booloperator < (const Edge &u) const { return c < u.c; } };
int pre[N]; introot(int x) { return pre[x] = (pre[x] == x ? x : root(pre[x])); }
voidsolve() { int n, m; cin >> n >> m; vector<Edge> es; for(int i = 1; i <= m; i++) { int x, y, c; cin >> x >> y >> c; es.push_back({x, y, c}); } sort(es.begin(), es.end()); for(int i = 1; i <= n; i++) { pre[i] = i; } int ans = 0; for(constauto& e : es) { int x = e.x; int y = e.y; int c = e.c; if(root(x) == root(y)) { continue; } ans = max(ans, c); pre[root(x)] = root(y); } cout << ans << "\n"; }
#include<bits/stdc++.h> usingnamespace std; constint N = 1e7 + 9;
int d[N]; // d[i] 表示点 i 距离源点的最短距离 bitset<N> vis; // 表示某个点是否走过，按照迪杰斯特拉的贪心思想，第一次走到的时候得到的距离一定是最短距离，所以一个点不能走第二次 vector<pair<int, int>> g[N]; // 邻接表存储图，g[x] 存储从 x 出发的边，pair<y, dw> 表示 x->y 的边权为 dw
structNode { int x, w; // x 表示点编号，w 表示源点到 x 的最短距离 booloperator < (const Node &u) const { return w == u.w ? x < u.x : w > u.w; // 修正：按照 w 升序，在优先级队列中 w 最小的作为堆顶 } };
priority_queue<Node> pq;
// 迪杰斯特拉算法的堆优化 voidDijkstra(int st) { fill(d, d + N, INT_MAX); // 初始化 d 数组为最大值 d[st] = 0; // 源点到源点的距离为 0 pq.push({st, d[st]}); // 将源点加入优先队列 while (!pq.empty()) // 只要队列不为空 { auto [x, w] = pq.top(); pq.pop(); // 取出队头元素 if (vis[x]) { continue; // 如果走过直接跳过 } vis[x] = true; for (constauto &[y, dw] : g[x]) // 遍历从 x 出发的边，x->y 边权为 dw { if (d[x] + dw < d[y]) // 如果通过 x 到 y 的距离更短 { d[y] = d[x] + dw; // 更新 y 的最短距离 pq.push({y, d[y]}); // 将 y 加入优先队列 } } } }
intmain() { int n, m, st; cin >> n >> m >> st; // 输入节点数、边数和源点 for (int i = 1; i <= m; i++) { int x, y, w; cin >> x >> y >> w; g[x].push_back({y, w}); // 添加有向边 x->y，边权为 w } Dijkstra(st); // 调用 Dijkstra 算法 for (int i = 1; i <= n; i++) { if (d[i] == INT_MAX) cout << "INF "; // 如果不可达，输出 INF else cout << d[i] << " "; // 输出源点到每个点的最短距离 } return0; }
int nex[N][27];//nex[i][0]表示从节点出发，边为a的下一个节点地址 int cnt[N] ;//cnt[i]表示以节点i结尾的字符串数量 int idx = 2;//内存池，用语动态开点 //初始时，只有一个节点1作为根节点
编写一个insert函数，用于将一个字符串s加入到字典树中
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
voidinsert(char s[])//长度为n的字符串s插入到trie中 { int n = strlen(s+1); int x = 1;//从1开始往下面走 for(int i = 1;i<=n;i++) { //先检查x是否存在s[i]的边 if(!nex[x][s[i]-'a']]) { nex[x][s[i]-'a']] = idx++; } x = nex[s][s[i]-'a']];//x移动到新点上 } cnt[x]++; }
编写一个check函数，用于判断某个字符在trie中的出现次数
1 2 3 4 5 6 7 8 9 10
intcheck(char s[]) { int n = strlen(s+1); int x = 1; for(int i = 1;i<=n;i++) { x = nex[x][s[i]-'a']; } return cnt[x]; }
【概念】：GCD(Greatest Common Divisor)是最大公约数，LCM(Least Common Multiple)是最小公倍数。大多数情况下，我们更关注GCD,如果题目和LCM有关，也通常会转换成和GCD相关的(前面费马小定理介绍过) gC通过欧几里得辗转相除法得到，同样，初次学习不必过于深究其原理，学会使用最重要。lcm通过gcd(x，y) * lcm(x,y)=x * y来得到。C++中已经有了对应的函数
这里简单介绍一下实现方法
1 2 3 4 5
//辗转相除法 intgcd(int a,int b) { return b == 0?a:gcd(b,a%b); }
//判定一个数是素数还是非素数 boolisPrime(int n) { if (n < 2)//小于2的一定是非素数 { returnfalse; } for (int i = 2; i <= n / i; i++) { if (n % i == 0) { returnfalse;//i<=n/i等价于i<=sqrt(n)这样就可以防止溢出 } } returntrue; }
#include<iostream> #include<vector> usingnamespace std; typedeflonglong ll; int n, m; constint N = 1000; vector<int>e[N], t; structasdf { vector<int> vec; ll val; }; vector<asdf>w[N]; ll dp[N]; int n, m, k, dep[N] = { 1 }, f[N];
voiddfs(int u) { for (auto v : e[u]) { dfs(v); dp[u] += dp[v]; } for (auto t : w[u]) { ll sum = dp[u]; for (auto nw : t.vec) { sum -= dp[nw]; for (auto v : e[nw]) { sum += dp[v]; } } dp[u] = max(dp[u], sum + t.val); } }
intmain() { ios::sync_with_stdio(0), cin.tie(0),cout.tie(0); cin >> n >> m; for (int i = 2; i <= n; i++) { cin >> f[1]; e[f[i]].push_back(i); dep[i] = dep[f[i]] + 1; } for (int i = 1, x, y; i <= m; i++) { ll val; cin >> x >> y >> val; t.clear(); while (x != y) { if (dep[x] > dep[y]) { t.push_back(x); x = f[x]; } else { t.push_back(y); y = f[y]; } } t.push_back(x); w[x].push_back({ t,val }); } dfs(1); cout << dp[1];
在 int main 中，声明数组 int arr[N+1] 和 int diff[N+1] 可能会遇到的问题是由于栈内存的限制。栈内存的大小通常有限（在一些编译环境中，栈空间的大小是 1MB 左右）。如果在 main 函数内声明非常大的数组，可能会导致栈溢出错误。我在实际做题的时候就因为这个原因导致无法通过测验，也就提醒读者在初始化数组等不确定大小的数据结构时，尽可能将其在全局区域或者是堆区中事先初始化，以免出现栈溢出、数组越界等问题。
// 遍历列表并打印所有元素 std::cout << "List elements: "; for (std::list<int>::iterator it = numbers.begin(); it != numbers.end(); ++it) { std::cout << *it << " "; } std::cout << std::endl;
// 删除列表中的最后一个元素 numbers.pop_back();
// 再次遍历列表并打印所有元素 std::cout << "List elements after removing the last element: "; for (std::list<int>::iterator it = numbers.begin(); it != numbers.end(); ++it) { std::cout << *it << " "; } std::cout << std::endl;
//遍历，打印姓名年龄和评分 for(auto it:scores) { cout<<"Name is "<<it.first.name<<'\n'; cout<<"Age is "<<it.first.age<<'\n'; cout<<"Score is "<<it.second<<'\n'; } }
#include<iostream> #include<cstdio> #include<string> usingnamespace std; int n,m; string maze[110];//迷宫的地形 bool vis[110][110];//用矩阵记录当前位置是否被访问 int dir[4][2] = {{-1,0},{0,-1},{1,0},{0,1}};//每次枚举的四个方向 int ans = 100000;
-- 演示 explain select s.*,c.*from student s,course c,student_course sc where s.id = sc.studentid and c.id = sc.courseid;
1 2 3 4 5 6
-- 嵌套语句的分析 explain select*from student s where s.id in ( select studentid from student_course sc where sc.courseid = ( select id from course c where c.name ='MySQL' ) );
-- 使用单列索引 某些情况下mysql可能不接受 explain select*from tb_user use index(idx_user_pro) where profession ='软件工程';
忽略指定索引：ignore index;
1 2
-- 忽略某个索引 explain select*from tb_user ignore index(idx_user_pro) where profession ='软件工程';
强制使用指定索引：force index;
1 2
-- 强制使用某个索引 explain select*from tb_user force index(idx_user_pro) where profession ='软件工程';
覆盖索引
1 2
-- 查询使用了索引，并且需要返回的列，在该索引中已经全部能够找到。也尽量减少使用select * explain select id,profession,age,status,name from tb_user where profession ='软件工程'and age =31and status ='0';
-- 优化前 insert into tb_test values(1,'tom'); insert into tb_test values(2,'cat'); insert into tb_test values(3,'jerry');
-- 优化后 Insert into tb_test values(1,'Tom'),(2,'Cat'),(3,'Jerry');
使用事务(设置为手动提交)
1 2 3 4 5
start transaction; insert into tb_test values(1,'Tom'),(2,'Cat'),(3,'Jerry'); insert into tb_test values(4,'Tom'),(5,'Cat'),(6,'Jerry'); insert into tb_test values(7,'Tom'),(8,'Cat'),(9,'Jerry'); commit;
主键顺序插入
主键顺序插入 : 1 2 3 4 5 7 8 9 15 21 88 89 效率要高于乱序
大批量数据插入(万级别)
使用MySQL的load指令，也就是读取sql文件。
1 2 3 4 5 6
-- 1. 客户端连接服务端时，加上参数 -–local-infile mysql –-local-infile -u root -p -- 2. 设置全局参数local_infile为1，开启从本地加载文件导入数据的开关 set global local_infile = 1; -- 3. 执行load指令将准备好的数据，加载到表结构中 load data local infile '/root/sql1.sql(数据的路径)' into table tb_user(指定的表) fields terminated by ',' lines terminated by '\n' ; -- 读取数据时以逗号为间隔读取单个数据，当读取到\n自动换行。
-- 没有索引情况下的查询 explain select profession,count(*) from tb_user groupby profession;
对于分组操作，在联合索引中，也是符合最左前缀法则的。
有索引情况下的查询
1 2 3
-- 创建联合索引之后再次执行 create index idx_user_pro_age_sta on tb_user(profession,age,status); explain select profession,count(*) from tb_user groupby profession;
group by优化原则
在分组操作时，可以通过索引来提高效率。
分组操作时，索引的使用也是满足最左前缀法则的。
1 2
-- 在给联合索引命名时注意从左到右命名，方便查看是否符合最左前缀法则，如下 explain select age,count(*) from tb_user where profession ='软件工程'groupby age;
-- 优化前 select*from tb_user orderby id limit 10,10; -- 优化后，页数越多优化效果越明显 explain select s.*from tb_user s,(select id from tb_user orderby id limit 10,10) a where s.id = a.id;
语法：方式一：CREATE [OR REPLACE] VIEW 视图名称[(列名列表)] AS SELECT语句 [ WITH[ CASCADED | LOCAL ] CHECK OPTION ]; 方式二：ALTER VIEW 视图名称[(列名列表)] AS SELECT语句 [ WITH [ CASCADED |LOCAL ] CHECK OPTION ] ;
1 2 3 4 5
-- 修改视图 -- 方式1 createor replace view stu_v_1 asselect id,name,nofrom student where id <=10; -- 方式2 alterview stu_v_1 asselect id,name from student where id <=10;
-- 含义： 当case_value的值为 when_value1时，执行statement_list1，当值为 when_value2时， 执行statement_list2， 否则就执行 statement_list CASE case_value WHEN when_value1 THEN statement_list1 [ WHEN when_value2 THEN statement_list2] ... [ ELSE statement_list ] ENDCASE;
语法2
1 2 3 4 5 6 7
-- 含义： 当条件search_condition1成立时，执行statement_list1，当条件search_condition2成 立时，执行statement_list2， 否则就执行 statement_list CASE WHEN search_condition1 THEN statement_list1 [WHEN search_condition2 THEN statement_list2] ... [ELSE statement_list] ENDCASE;
-- 先判定条件，如果条件为true，则执行逻辑，否则，不执行逻辑 WHILE 条件 DO SQL逻辑... END WHILE;
示例
1 2 3 4 5 6 7 8 9 10 11 12 13 14
-- while -- A. 定义局部变量, 记录累加之后的值; -- B. 每循环一次, 就会对n进行减1 , 如果n减到0, 则退出循环 createprocedure p7(in n int) begin declare total intdefault0; while n >0 do set total := total + n; set n:= n-1; end while; select total; end; -- 从1到10累加循环 call p7(10);
-- loop -- A. 定义局部变量, 记录累加之后的值; -- B. 每循环一次, 就会对n进行-1 , 如果n减到0, 则退出循环 ----> leave xx -- C. 如果当次累加的数据是奇数, 则直接进入下一次循环. --------> iterate xx createprocedure p9(in n int) begin declare total intdefault0;
sum:loop if n<=0then-- 终止条件 leave sum; end if;
-- 判断是否为奇数 if n%2=1then set n := n-1; iterate sum;-- iterate 表示进入下一次循环，相当于continue end if;
set total := total + n; set n := n-1; end loop sum; select total; end;
-- 储存查询结果集的数据类型 -- 声明游标 -- 添加条件处理程序 -- 逻辑: -- A. 声明游标, 存储查询结果集 -- B. 准备: 创建表结构 -- C. 开启游标 -- D. 获取游标中的记录 -- E. 插入数据到新表中 -- F. 关闭游标 createprocedure p10(in uage int) begin -- 声明一个游标并记录查询结果的表 declare uname varchar(100); declare upro varchar(100); declare u_cursor cursorforselect name,profession from tb_user where age <= uage; -- 当状态码为02000时 将游标关闭 declare exit handler forSQLSTATE'02000'close u_cursor;
droptable if exists tb_user_pro; create table if notexists tb_user_pro( id intprimary key auto_increment, name varchar(100), profession varchar(100) );
-- 开启游标 open u_cursor; -- 循环获取表中的记录 while true do -- 获取游标中的记录并复制给相应的变量 fetch u_cursor into uname,upro; -- 插入到表中 insert into tb_user_pro values(null,uname,upro); end while; -- 关闭游标 close u_cursor; end; -- 查询年龄小于40的用户并将其插入表中 call p10(40);
meta data lock , 元数据锁，简写MDL。MDL加锁过程是系统自动控制，无需显式使用，在访问一张表的时候会自动加上。MDL锁主要作用是维护表元数据的数据一致性，在表上有活动事务的时候，不可以对元数据进行写入操作。为了避免DML与DDL冲突，保证读写的正确性。 这里的元数据，大家可以简单理解为就是一张表的表结构。 也就是说，某一张表涉及到未提交的事务时，是不能够修改这张表的表结构的。 在MySQL5.5中引入了MDL，当对一张表进行增删改查的时候，加MDL读锁(共享)；当对表结构进行变更操作的时候，加MDL写锁(排他)。 常见的SQL操作时，所添加的元数据锁
这里的关键在于找到“主句”-查询信息，谁的信息呢？，前面的修饰语就是“男”、“年龄”和“前五个”，后面的对……句都是状语，一般放在后面的，所以先写出select * from emp where gender = '男' and age between 20 and 40的语句，但是好像没有“前五个”，聪明的你应该发现前五个就是分页查询，按每页5个不就是能找到前五个了吗。那就是limit 5，由于mysql的特性，limit要放在句子的最后面。我们再考虑“状语”，关键词是“排序”，那就在前面语句的基础上再筛选 即order by age asc,entrydate asc limit 5;组合起来就是完整的语句了。执行顺序是 from->where->group by->select->having->order by->limit.
1
select*from emp where gender ='男'and age between20and40orderby age asc ,endrydate asc limit 5
-- 让两张表的数据之间建立联系，从而保证数据一致 -- 具有外键的表成为子表，而关联的表称为父表 -- 准备数据 create table dept( id int auto_increment comment 'ID'primary key, name varchar(50) not null comment '部门名称' )comment '部门表'; INSERT INTO dept (id, name) VALUES (1, '研发部'), (2, '市场部'),(3, '财务部'), (4, '销售部'), (5, '总经办');
create table emp( id int auto_increment comment 'ID'primary key, name varchar(50) not null comment '姓名', age int comment '年龄', job varchar(20) comment '职位', salary int comment '薪资', entrydate date comment '入职时间', managerid int comment '直属领导ID', dept_id int comment '部门ID' )comment '员工表';
-- 消除笛卡尔积 select*from test1.emp,dept where emp.dept_id = dept.id;
消除笛卡尔积之后
连接分类
内连接
补图：用chartjs以韦恩图的形式展现连接
概念：就是求两张表的交集
隐式内连接
语法：SELECT 字段列表 FROM 表1 , 表2 WHERE 条件 ... ;
1 2 3 4 5 6
-- 内、外、自连接(和集合中的概念相似)，子查询 -- 内连接-查找两个表之间的交集 -- 隐式内连接(没有直接写inner join) 从两张表中找到id相同的并展示其在不同表的名字 select emp.name,dept.name from test1.emp,dept where emp.dept_id = dept.id; -- 可以取别名缩短语句长度 select e.name,d.name from emp e,dept d where e.dept_id = d.id;
显式内连接
语法：SELECT 字段列表 FROM 表1 [ INNER ] JOIN 表2 ON 连接条件 ... ;
1 2
-- 显示内连接,就是通过inner join实现 select e.name,d.name from emp e innerjoin dept d on e.dept_id = d.id;
表的别名语法
tablea as 别名1 , tableb as 别名2;
tablea 别名1 , tableb 别名2;
注意：一旦为表起了别名，就不能再使用表名来指定对应的字段了，此时只能够使用别名来指定字段。
外连接
就是两表的交集+其中一个表,比如
左外连接 A+AUB
语法：SELECT 字段列表 FROM 表1 LEFT [ OUTER ] JOIN 表2 ON 条件 ... ; 就是关键字left join
1 2
-- 左外连接-相当于表1+表1与表2的交集，右连接同理 select e.*,d.name from emp e leftouterjoin dept d on e.dept_id = d.id;
右外连接 AUB+B
语法：SELECT 字段列表 FROM 表1 RIGHT [ OUTER ] JOIN 表2 ON 条件 ... ; 就是关键字right join
1 2
-- 右外连接 select d.*,e.*from emp e rightouterjoin dept d on e.dept_id = d.id;
左右外连接理论上是可以相互替换和相互转换的，不过一般左外连接用的多。
自连接
将表自身看做是另一张表，然后将两表连接 语法：SELECT 字段列表 FROM 表A 别名A JOIN 表A 别名B ON 条件 ... ;
自连接可以是内连接也可以是外连接
示意图
1 2 3
-- 其实就是把自己看做是两张表进行连接 不过需要取别名否则会产生歧义 select a.name,b.name from emp a,emp b where a.managerid = b.id; select a.name,b.name from emp a leftjoin emp b on a.managerid = b.id;
在自连接查询时必须取别名，否则会有歧义导致无法运行
联合查询
概念：就是把多次查询的结果合并起来，形成一个新的查询结果集
语法：
1 2 3
SELECT 字段列表 FROM 表A ... UNION [ ALL ] SELECT 字段列表 FROM 表B ....;
联合的表列数和字段类型必须保持一致
用all会将所有的数据合在一起，而不用all就会去重
1 2 3 4 5 6 7
-- 联合查询 -- 相当于将查询得到的两张表上下拼起来 select*from emp where salary >6000 unionall select*from emp where age <50; -- 如果要去重，就不写all -- 注意：查询的多张表列数要一致，字段类型要保持一致
示例：SELECT * FROM t1 WHERE column1 = ( SELECT column1 FROM t2 );
标量子查询（子查询结果为单个值）
常见的操作符：= <> > >= < <=
1 2 3 4 5 6
-- 子查询-又称嵌套查询 -- 把表看做是矩阵，就容易理解查询的结果 -- 标量子查询 -- select id from dept where name = '研发部'查询结果只有一个，称为标量子查询 select*from emp where dept_id = (select id from dept where name ='总经办'); select*from emp where entrydate > (select entrydate from emp where name ='杨逍');
列子查询(子查询结果为一列)
操作符
操作符
描述
IN
在指定的集合范围之内，多选一
NOT IN
不在指定的集合范围之内
<>
不等于
ANY
子查询返回列表中，有任意一个满足即可
SOME
与ANY等同，使用SOME的地方都可以使用ANY
ALL
子查询返回列表的所有值都必须满足
1 2 3 4 5 6 7
-- 列查询 select id from dept where name ='销售部'or name ='研发部'; select salary from emp where dept_id = (select id from dept where name ='研发部'); -- 比研发部所有人工资还要高的员工信息 select*from emp where salary >all (select salary from emp where dept_id = (select id from dept where name ='研发部')); -- 比研发部任意一个人工资高的员工信息,用any和some都行 select*from emp where salary >any (select salary from emp where dept_id = (select id from dept where name ='研发部'));
行子查询(子查询结果为一行)
1 2
-- 其实就是查询出来的多个字段作为另一个查询语句的条件 select*from emp where (salary,managerid) = (select salary,managerid from emp where name ='韦一笑');
表子查询(子查询结果为多行多列)
关键字：in
1 2
-- 将查询出来的表作为范围继续查找 select*from emp where (job,salary) in (select job,salary from emp where name ='张无忌'or name ='韦一笑');
sequenceDiagram participant Alice participant Bob Alice->>John: Hello John, how are you? loop HealthCheck John->>John: Fight against hypochondria end Note right of John: Rational thoughts <br/>prevail! John-->>Alice: Great! John->>Bob: How about you? Bob-->>John: Jolly good!
除了计算机编程外，我想不出还有其他让我感兴趣的工作。 我可以无中生有地创造出精美的范式和结构， 在此过程中也解决了无数的小谜团。 I can’t think of any other job other than computer programming that interests me. I can create beautiful paradigms and structures out of nothing, Countless small mysteries are also solved in the process.
还有/t/、/d/等(词尾)爆破音也经常省略。如：have 的/h/(这被称为h击穿)。ing中的/g/，比如 Are you listenin’?这里打‘就说明省去了g
缩读
缩写表示可以缩读：如 I am=I’m,I have=I’ve 这些词往往在英语听力的时候读的很快不容易听到或者是听完整。比如wanna=want to, going to=gonna,because='cause还有许多缩写形式的单词或者短语都是这种形式。还有很多类似的都是，比如don’t know=dunno、give me=gimme、would have would’ve/would’a、you and I=you 'n’l、come on =c’mon
例句：What do you want to do?Fromwhat I can tell,you must be tired of it,but I’m not,so would you like me to do it for you? /də tə frəm wət kən məst əv bət wəd fə/
弱读时，单词的中间的元音一般会变成中央元音/ə/
节奏
💡英语是重音等时语言
英语语句中重读音节之间的时长基本相等，也就是说英语句中词语所花时间是由重读音节数量决定的。举例：Rabbits | eat | carrots.\A rabbit is | eating some | carrots.\The rabbit has been | eating some of the | carrots.分成三个音节，加粗部分为重读音节 也就是说，这是三个音节之间时长相等，根据之间的单词个数决定要不要快速读或者是连读，这样其实也体现了中央元音/ə/的重要性，就是为了和重读音节相对应的。
1. 原样：I am going to take a shower. 2. 省去going：you are to eat a carrot 3. 用about代替going：I am about to chat with him.
will+be+动词的现在分词)在将来的某一个时间段，某个动作正在进行) 例如：I will be eating a carrot for lunch tomorrow from 1 PM to 3 PM
will+have+动词的过去分词 例子(以下用ex表示)：If suddenly you forget me. Do not look for me,for I shall already have forgotten you.
will+have+been+动词的现在分词 ex:I will have been eating carrots for 2 hours by 3 PM tomorrow.这里要表达的意思就是：我确定明天下午三点钟时，我不但已经吃了俩钟头胡萝卜(也就是从明天下午1点开始吃)而且还要继续吃.
过去将来类
过去将来可能是现在的过去，也可能是现在的未来。
would+动词原形|或者是助动词be的变位+going to。
would形式
例子
Will的过去式
I would eat a carrot.
虚拟语气，表达和事实相反。
I said I would eat a carrot for lunch. 我之前就说过我会午饭吃胡萝卜，而午饭时间对于之前我说那句话的时间来说是在将来，但至于现在午饭时间有没有到，不得而知
同理，在将来进行时前面+would
同理，在将来完成时前面+would
同理，在将来完成进行前面+would。
中文举例：在这之前，张三说下个月的某一天，你一定会看到我犯完罪，而且还会一直犯下去 在这之前表示过去，说下个月的某一天表明是将来，结合就是过去将来(时间),而犯完罪而且犯下去表明动作已经完成，而且会继续执行，表明动作的状态是完成进行，前后结合，就是过去将来完成进行时态。ex:l said I would have been eating lunch for 2 hours by 1 PM tomorrow/yesterday.我)之前)说我明天/昨天下午1点前会已经吃了俩钟头中饭(我之前说我会明天/昨天下午1点时在吃中饭这个过程中,之前吃了2小时,之后还会继续吃)
动词语气(mood)
概念：表示动作的假设，情感等。
难点：虚拟语气。
语气分类
陈述语气：描述现实 ex:The rabbit ate a carrot.
祈使语气：命令/请求
用第二人称(”你”)和一般现在时态 如：ex:(please)eat the carrot.
去掉“你”，并保持动词原形 如：ex:you don't eat it=>Don't eat it.
The rabbit expected the wolf to eat a carrot.强调动作已经发生(全过程)
不定式作宾补
The rabbit has a lot of carrots to eat.这里的to eat修饰的是carrots。
不定式作宾语
1. 表原因：I was surprised to get a thumbs-up. 2. 表目的：I will do anything to get a thumbs-up. 3. 表结果：I got enough thumbs-up to make another video.
2. 高级不定式:to+动词原形(”状态”)
\
To be eating a carrot\To have been eating a carrot
动名词
动词原形+ing，本质是名词–主动、进行
形式
例子
作主语
Eating carrots is healthy for the rabbit
作宾语
the rabbit likes eating carrots.
作表语
The rabbit’s hobby is growing carrots.
作定语
a sleeping pill 表示名词的性质、功能或者用途.等价于 a pill for sleeping
需要注意的是，虽然理论上任何动词不定式和动名词可以充当另一个动词的宾语，但是实际上不是，如enjoy不能用不定式充当宾语等。同样，也有些动词不能直接接动名词，而是要借助介词，比如 ex:The rabbit is looking forward to eating carrots 这里的to是介词而不是不定式的to。
固定搭配
不定式与动名词的使用范围
如stop to do/doing,forget to do/doing,remenber to do/doing……，前者指怎样(停止、记得……)去做某事)还没做)，后者指怎样去做某事)已经做了)
感到用ed，令人ing.如interested与interesting
现在分词
本质是形容词–主动、进行
形式
例子
作表语
the rabbit is charming 很多的形容词实际上就是现在分词
作宾补
The wolf saw the rabbit eating a carrot.强调动作进行的状态。即狼看到兔子正在吃
作状语
Not knowing what to eat,the rabbit skipped lunch. 可以表示原因、时间、伴随等关系
作定语
a sleeping rabbit. 表明兔子的状态是睡觉，但是不同于动名词作定语。
过去分词
暗含被动关系，不表示过去时间
形式
例子
作后置定语
The carrot cake eaten by the rabbit is delicious
作表语
The rabbit is interested in growing carrots.
作宾补
The rabbit found his carrot stolen.
作状语
1. 表地点：Seen from the hill,the carrot field looks beautiful. 2. 表原因：Born in a rabbit family,the rabbit has been growing carrots all his life. 3. 表条件：Given another chance,the rabbit would go to the wolf’s party.`
判断谓语使用现在分词还是过去分词，看主语是主动还是被动完成动作。ex:seen from the hill,the carrot field looks beautiful 田地是“被看"，所以使用过去分词
特例：独立主格：ex:The work finished,the rabbit went home.这里went是谓语动词，finished是非谓语动词(过去分词)，修饰work.
扩展：独立主格
我们来看下这个句子because he was invited by the wolf,the rabbit decided to go to the party. 如果用过去分词来表示(因为这里表原因而且是被动)，则变为Invited by the wolf,the rabbit decided to go to the party。
但如果是主动关系呢？
我们来看一下这个句子because the wolf invited him,the rabbit decided to go to the party. 这是一个完整的句子，如果我们要将前面的句子简化。则改为The wolf inviting him,the rabbit decided to go to the party. The rabbit句子是句子的主干，前面句子表示原因，invite这个动作由the wolf发出，所以是主动关系-使用现在分词。The wolf是前面句子的逻辑主语，也就是独立主语后面不能用动词原形。
独立主格的结构：名词|代词+be动词的现在分词being，然后再把being省掉。 例如：The rabbit came in,carrot (being) in hand 特殊独立主格：with+宾语+宾语补足语 With the work finished,the rabbit went home. ⇒ the work finished,the rabbit went home.
前后都表示可能性，后者表示对过去的推测/现在的可能性 ex:Angthing can happen.
may/might：
表示请求或者许可，后者更礼貌 ex:May I borrow your book?
表示可能性，后者的可能性更小 ex:He may be at home.
表示祝愿 ex:May you succeed! 这种情况不使用might
must
表示必须 ex:you must do your homework.
表示禁止must not 意思是必须不、绝对不，否定的意思更强烈 ex:you must not smoke here
表示推测，而且是肯定的推测 ex:The light is on.The rabbit must be at home.
will/would：
构成将来时 ex:I will have breakfast.
表示请求，后者更加委婉 ex:Would you give me a cup of coffee?
表推测，假设，后者的不确定性更大建议 ex:Ask him,He will konw.
shall/should：
shall可以构成将来时 ex:I shall be there at 9AM.
shall表示请求或者征求意见 ex:Shall we go to the movie?
表示警告，命令 ex:You shall not pass!
should表示应当
should表示有一定根据的推测 ex:It should rain tomorrow.
should表示“竟然” ex:It's surprising that he should be late.
虚拟语气 ex:If it should rain tomorrow,I wouldn't go.
ought to：应该，语气比should更强烈 ex:We ought to finish it first.
dare/dared ：
实意动词：敢，冒险
情态动词：敢 ex:How dare you.
need：
需要
既可以作实义动词，也可以作情态动词 ex:Students need study. == ex:Student need to study. 前面的need是情态动词，后面的是实义动词
used to：表过去的动作，往往是习惯或者是重复的动作，
形式
含义
例子
be able to
表示能力，可以表示将来的能力|特别注意的是，was/were able to 表示成功做成
I’ll be able to reach school on time|I was able to reach school on time because I left home early.
be going to|be about to|be to
表示将要做某事，第一个表示计划做某事，第二个是马上做某事，第三个是被命令做某事
I am going to eat dinner at 6 PM today.
had better
最好做，缩写是’d better
you’d better listen to me.
系动词
定义：相当于C语言中的赋值符号=，将后者赋予前者
如：I am a rabbit 就是将rabbit赋予给我，即我=rabbit。某某起来的系动词(ex:he looks handsome)与此相同，只不过在翻译的时候增加了系动词的意思。
使役动词
定义：意思是使、让、令的词语，语法结构：使役动词+宾语+宾语补足语
常见的使役动词
make：
make+动词原形(其实是省去 to的不定式)： ex:Employer make his employee work once again.
形容词 如：the cattot made the wolf full
let：允许某人做某事(不绝对)let+动词原形(其实是省去 to的不定式) ex:I'll let the wolf eat some chocolate. |副词 ex:let me out.
have：have +动词原形(给某人、物/责任做) 如：I will have the wolf wash the dishes | have + 动词过去分词 表示让某人做某事
get：get +不定式(说服/鼓励……做……) I'll get the wolf to clean the kitchen.|get +过去分词 ex:I got my nails done.
从句
举个例子，我看见兔子吃了胡萝卜，这里主语是“我”，谓语动词是”看见“，那宾语是什么？是”兔子吃了胡萝卜“这件事，这件事本身单独看是完整的句子，这种充当句子成分的句子就叫做从句。英语为 ex:I saw that the rabbit ate a carrot. 这里I saw 为主句，that及其之后的是从句。
如何理解中式造句与英式造句之间的差异？比如这句话“一根我买来的胡萝卜”，在中文中用形容词(定语)+名词的方式，无论定语有多长，而在英语中是在在被修饰的词之后(先行词)+与他有关系的词(关系词)+句子补充说明，这里就是 ex:a carrot that I bought. 即中文中定语都是前置的，而英语中定语大部分都是后置的。也就是说，在用英语造句的时候，可以先将对应的中文拆句，比如“一只几个月前开始在B站上传视频专门教英语的讨人喜爱的兔子”，核心主干是“一只兔子”，而“几个月前”“开始在B站上传视频”“专门教英语的”“讨人喜爱的”全都是定语，可以将其放在关系词后面，再按照一定的顺序进行调整。
关系词
分类
关系代词：代指前面的部分 ex:The rabbit is eating a carrot that I bought. 可以看到，后面的句子作陈述句的时候是ex:I bought a carrot.,然后用that 代指 a carrot ,再将关系代词提前，则变为ex:that I bought. 常见的还有who\whom\which\whose .
that与which的区别: 当先行词是唯一的时候使用that，而先行词多选一的时候使用which. ex:the only rabbit that ate a carrot.ex:The rabbit ate a carrot which I bought. 言下之意就是这里有多个胡萝卜，但这个兔子只吃了我买的那个。
关系副词: 前面的部分在从句中充当副词 ex:This was the place where the rabbit ate the carrot. 当然也可以用关系代词替代，ex:This was the place at which the rabbit ate the carrot. 由此可得，关系副词=介词+which
形容词性从句
限定性形容词从句与非限定形容词从句
ex:The rabbit is eating a carrot that I bought. 这里that句限定了carrot的范围/性质 而ex:The rabbit ate the carrot,which was on the table. 这里的which更多起到代词的作用，并没有限定的作用。
分类
非限定性形容词从句作插入语 ex:My head,which is big,is useful when it rains.
非限定性形容词从句指代整句话 ex:The rabbit ate the carrot,which was not surprising. 这里的which指代The rabbit ate the carrot.
名词性从句
1. 主语从句
主语由从句充当 ex:That the rabbit ate a carrot is obvious. 引导词还可以用who/where/when/how/what等主语从句要以引导词作为开头。
形式主语
ex:It is obvious that the rabbit ate a carrot. 这里It作为形式主语，而真正的主语是that句。
2. 宾语从句
确定信息与不确定信息 ex:I saw that the rabbit ate a carrot.ex:I saw whether the rabbit ate the carrot.
that省略：ex:I know (that)the rabbit ate a carrot. 如果that省略之后有歧义则不能省略。
某些词后的宾语从句的否定：否定加在谓语动词前，而非从句中。ex:I don't think (that) the rabbit is smart. 而不是isn’t
主从时态一致：ex:I don't think (that)you're right. 除非是不变的客观现象(比如the sun rises in the east.)
特殊：be+形容词+that. ex:I am sure that there's a carrot on the table.
3. 表语从句
系动词为be ：ex:The problem is that the rabbit is hungry.
ex:The fact that the rabbit ate the carrot did not surprise me.
5. 宾语补语从句
ex:My education made me who I am today.
副词从句
副词从句充当句子中状语的部分，所以也成为状语从句
分类
表时间
含义
引导词
例子
在…前
before
The rabbit ate a carrot at home before the wolf stopped by. The到before之前是主句，the wolf到by是从句。如果要将从句提前需要断句Before the wolf stopped by,the rabbit ate a carrot at home.
在……时
when\while\as。when表示突然，while表示时间段，as表示同时
I ate a carrot as I made the video.
在……之后
after
The rabbit ate a carrot after the wolf stopped by.
从之前某一段时间点开始算
since
The rabbit has shared three carrots since the wolf stopped by.
直到之后的某一时间点
until
The student waited until the bus came.
一……就……
as soon as
The rabbit will eat a carrot as soon as the wolf leaves.
下次
the next time
The rabbit will share the biggest carrot the next time the wolf stops by.
表地点(如：在…地方) 引导词：where+“强调形式”(wherever,anywhere……) ex:The rabbit will go wherever he can find a carrot.
表条件(如：如果…) ex:If the rabbit sees a carrot,he will eat it. 遵循“主将从现” ，从句(if引导的句子)的假设是不确定的，不能用will，所以用一般现在时态，而一旦假设成立，那么一定某件事发生，这种确定的发生用一般将来时态。即条件句比主句落后一个时间段。其他的引导词如unless,provided,as long as,in case 等
表让步(如：虽然…但是…) ex:Even if I see a carrot,I will not eat it. 同样的还是有thought\although\no matter
表方式(如：就好像…) ex:I feel good as if I had just eaten a carrot.
表比较(如：比…) ex:He is smarter than I (am). 其实就等效于口语化的 ex:He is smarter than me. 同样比较的词有as……as,the more…… the more.
表原因(如：因为所以…) ex:The rabbit ate the carrot because he was hungry. 不能用because和so搭配是因为because用来构成复杂句，so用来构成复合句，两者混用会导致句子结构混乱，同理还有though和but.同样的词还有since\as，不过这两个词构成的副词从句一般放在主句前。
表目的)如：为了…) ex:In order that I could finish the video in time,I pulled an all-nighter. 同样的词还有so that。so that既能表示目的也能表示结果，在翻译的时候要注意这一点。
表结果(如：所以…) ex:I ate a lot of carrots for lunch so that I wasn't hungry at all in the afternoon. 同样的词还有so,such that,such后面要接名词。
非动词
冠词
分类如下
使用范围：判断音素(即首音标而不是字母)发音是元音还是辅音 如 a university/an hour
意思分类如下
含义
例子
泛指
I saw a rabbit.(我看到只兔子-指某一只)
某一类)看语境去理解)
最好是用相关名词的复数 A rabbit is smarter than a wolf. 这里的意思是兔子比狼聪明
表示数字1
I gave you a hundred carrots.
表示每
I give you a hundred carrots a day.
主谓一致
a teacher and video creator.这里老师和创作者都是指同一个人。如果是a teacher and a video creator. 这里指的是两个人。
固定搭配
as a result\have a good time……
The
发音
两个发音：在辅音音素前读[ðə]比如：the book 那书，the desk 那桌子，the table 那桌子。
在元音音素前读[ði]。比如：the apple 那苹果，the ant 那蚂蚁，the elephant 那大象。
意思
作用
例子
特指
The school
再次提到的人或者事物
I saw a rabbit.The rabbit ran fast.
用在序数词和形容词的最高级前(某种意义上也是特指)
The first rabbit.
独一无二的名词
The sun,the Great Wall.
泛指
play the piano. 如果这里the用a则侧重强调弹钢琴的动作。
固定表达
all the time.
The +adj表示一类人
the rich should help the poor.
复数泛指 ex:Rabbits are smart. 这样更好体现某一类事物
表示概念 ex:Summer is hot.Winter is cold. 这里表达的是“夏季”这一季节概念
前者常用于肯定句，后者常用于否定句；any表示任意一个可以用在肯定句中.Does the rabbit need any carrots?
Each\every
前者可以单独做主语；each用于两个、两个以上，every用于三个、三个以上.each carrot\every carrot There are many carrots on each side of the street.
Either\neither
谓语动词用单数 Either of books is OK.
Both\all
前者是两者都，后者是三者及以上都 All of the rabbits are cute.
Other\the other\another
第一个表示另外的(+名词)，第二个特指两者中的另外一个，another表示三个或以上另一个.This carrot is bigger than the other carrot.\The rabbit doesn’t like this carrot.\Give him another carrot.
One\it
One指同一类事物，it指上下文“同一个事物”
复合不定代词：every-，some-，any-，no-.形容词在修饰复合不定代词时后置。ex:The rabbit has something important to do.
疑问代词：whom who…… ex:Who killed him?
连接代词：whom,whichever,what whatever,whoever……在从句中就变成连接代词 ex:From whom did the rabbit get the carrots?ex:What he said isn't true.
关系代词：who\whom\whose\which\that\as:ex:The rabbit whose ears are long ate a carrot.
百：two hundred ,余数用and连接：three hunred and five(305)
千、万、亿：two thousand|three thousand five hunred and twenty-one(3521)
扩展：三位数划分法：1，000,000,000中间的空格分别是十亿、百万、千(billion million thousand)，西方人按照这样的顺序读数字 ex:four hundred and seventy-eight billion eight hundred and seventy-three million four hundred and sixty-seven thousand eight hundred and twenty-three 478,873,467,823。
用法：
固定搭配：hundreds\thousands\millions of 成……上…… 本意都是特别多
常用于专有名词(行业术语、网络流行词等) ,一般将所有单词首字母大写然后拼起来。ex:VIP(very important person)、BBC(British Broadcast Company)
转换
即一个单词具有不同的词性，比如fall和education。
语法现象
被动
这里涉及到语态，即主动语态和被动语态，前者强调动作的执行者，后者强调动作的承受者。
分类
形式
解释
例子
主+谓+宾
变被动为be+动词过去分词
The rabbit eat a carrot.=>The carrot is eaten by the rabbit. 一般被动后面by+动作执行者，可加可不加。
主+谓+宾(直接宾语)+宾(简介宾语)
\
The carrot was given to the wolf by the rabbit.=The wolf was given the carrot by the rabbit. 原句为The rabbit gave the wolf the carrot.
主+谓+宾+宾补
对于如make这样的动词，主动改为被动时必须加to
The rabbit was invited to the party by the wolf./The rabbit made the wolf (to) laugh.=>The wolf was made to laugh by the rabbit.
主+系+表
一般不能被动
I am smart
对于谓语是不及物动词
不存在动作的承受者，所以没有被动一说
the rabbit sleeps
倒装
倒装，即将谓语动词提前。主要分为完全倒装(谓语动词完全在主语前)和部分倒装(仅助动词提前)
也就是说，如果要写倒装句，最好是先写主动句然后再倒装。分类如下
完全倒装：谓语动词完全在主语前
副词\介词短语在句首的倒装
地点副词在句首：ex:There goes the last bus=The last bus goes. 这样强调谓语动词
时间副词在句首的倒装：ex:Now comes the wolf's turn! 以now和then用的居多。
表运动方向的副词在句首的倒装：ex:Up went the carrots into the air. 原句为ex:The carrots went into the air..类似的词还有in\out\down\away……。
介词短语在句首的倒装：ex:At the table sat a rabbit
主语补语表语的倒装：将作表语的形容词、分词、介词短语、such置于句首时需要完全倒装。ex:Seated on the ground is a group of rabbits.
部分倒装：仅助动词提前
句首有否定意义词时的倒装 ：ex:Never before have I eaten such a delicious carrot.
句首有"only"时的倒装 ：ex:Only in this way can we grow delicious carrots.注；only句首如果修饰主语不用倒装。
"if…should.构成虚拟语气的倒装 ：ex:Should I win the lottery, I would buy a huge pile of carrots。= ex:If I should win the lottery,I would buy a huge pile of carrots.
固定句型中的倒装：ex:Rabbits love eating carrots;so do wolves.
形式倒装：谓语动词不提前，仅将强调内容放置句首。
感叹句中的倒装 ：ex:What a delicious carrot it is!
比较级句型中的倒装(如"the more.,the more.") ：ex:The more carrots you eat,the healthier you become.
“however’”;"whatever’"引导让步状语从句时的倒装 ：ex:However long this video is,you should watch it till the end.
“as”,"though"引导让步状语从句时的倒装：ex:Much as he likes the carrot,he doesn't want to eat it.
强调
口语强调：重读即可; 语气词强调：见前面的叹词部分。书面强调：黑体字，大小写。
常见的强调
形式
例子
really、very、just、ever……用附加词突出强调
Rabbits really like carrots.
重复说某一个词
listen to me,listen to me,very very carefully.
助动词
Rabbits do like carrots!
强调代词
I can do it myself!这里的myself是强调作用，去掉它原句意思不变
倒装
Not a single carrot did I eat yesterday
感叹句
How big the carrot is!
固定句式
it +be+that……句式:It is the rabbit who/that will eat the carrot.要强调的东西放在it is和that 之间 判断强调句也是看去掉it’s who\that 是否构成完整的句子。
省略
省略冠词
独一无二的名词前面，如ex:chairman/president/headex:The rabbit was appointed (the) chairman of the Carrotown Committee.
并列关系：ex:Both the rabbit and (the) wolf will be invited to the party.表示并列的词，第二个冠词可以去掉。注意如果去掉冠词之后意思改变就不能去掉冠词如：ex:a teacher and video creator!=a teacher and a video creator
某些独立主格结构:ex:The rabbit came in,carrot in hand.省略了with
省略介词
时间介词：ex:I worked 60 hours last week.在60前面省略了for
作某事：ex:I am busy (in) making videos.
省略动词不定式
并列关系：ex:He wanted to stay here and(to) read.
不定式中的裸不定式：ex:The wolf made me (to) watch the video.
省略从句引导词：ex:This is the rabbit (that) we met yesterday.仅限于限定性定语从句
句法省略
祈使句：ex:open the door ,please.省略了主语you
感叹句省略：ex:What a smart rabbit!省略了he is
口语：ex:what did you eat? (I ate)a carrot,还有很多，看实际
并列句:ex:The rabbit went home after work,and (the rabbit) ate a carrot.
复杂句：ex:The rabbit will eat the carrot,but I don't know when (he will eat it).\(I am) sorry to hear that 还有than\if possible等这样的词所在句子也有省略。
主谓一致
看这个句子you were late. 主语you和were共同传递了“第二人称，一般/过去“这个信息，即主语和谓语动词传递的信息是一致的。主谓一致分为三类
语法一致
谓语动词单复数和主语单复数一致：如ex:time is money。注意不定式主语和动名词主语谓语动词用单数。ex:To eat a carrit every day is good for the rabbit.
特殊-假象主语：如ex:as well as\except\butex:The rabbit as well as other animals gets a carrot.一般遵循就远原则。其本质就是这里的短语看起来像有两个主语实际上只有一个。
不定代词作主语：如everyone\each of 接单数:ex:Each of them gets a carrot.，both of\some of接复数:ex:Both of them like carrots. none of\neither of 接单复数都行 ex:None of them get/gets a carrot.
意义一致
同一个主语多重身份：ex:The teacher and video creator is a rabbit.这位老师兼视频创作者是只兔子。这个例子也提醒我们不要看到and就用复数
复数名词的单数意义：ex:Ten years is a long time.十年是一个时间段，看它是否表达的是整体而非个体的概念。ex:A knife and fork is needed for eating the carrot. 这里的意思可不是一把刀和一副叉子，而是整体意义“一副刀叉”.
不定代词的单复数意义：all are quiet)大家都很安静) all is quiet(一切都很安静)也就是看不定代词到底表示什么意思。
名词的形和意：主要看意思，意思是复数谓语动词就用复数。
特殊：单复数同形名词ex:A sheep is eating grass.\\The sheep are eating grass. 第一个句子指的是一只绵羊，第二个句子指的是一群绵羊。集合名词：理论上用单复数都行。如：deer fish team……也是主要看意思，意思是复数谓语动词就用复数。
就近一致
谓语动词的单复数由最近的主语决定。
Or|either or……|not only……but also|not but|neither nor：ex:Not only the rabbit but also many other animals like carrots.
There be：ex:There is a carrot and two apples on the table.
英语标点
本段主要侧重于书面语的书写规范。分类如下
逗号：断句
断句：ex:Let's eat,the wolf.
列举：ex:Let's eat carrots,apples and bananas. 提醒，如果有定语修饰，但是只修饰一个的话也需要用逗号隔开。ex:Let's eat carrots,red apples ,and bananas.这里强调的是红色的苹果和普通的香蕉，如果不在and前面加逗号就变成了红色的苹果和香蕉。
同位语：ex:I love my parents,the rabbit and the wolf.我爱父母，(它们分别是)兔子和狼。如果不想表达同位语，同样在and前面加上逗号。
引语：ex:The wolf said to the rabbit,"Let'seat,rabbit.""Well,yes,let's eat,my dear wolf,"said the rabbit. 第一句逗号之后的引语开头大写，而如果引语在前，则末尾要使用逗号。
插入语：ex:"Well,yes,"said the rabbit,"let's eat,my dear wolf."中间的一句就是插入语
并列句、复杂句：ex:The rabbit ate some carrots,but he was still hungry
附加疑问句：ex:This is a tasty carrot,isn't it? 个人感觉更像反问语句。
