func test2() {
defer func() {
fmt.Printf("你好，世界！\n")
}()
defer func() {
fmt.Printf("我是第二个defer函数\n")
}()
fmt.Printf("哈哈，我在外面\n")
}
func main() {
// fmt.Printf("main函数里的name111: %s\n", name)
// myname := myfunc()
// fmt.Println("main 函数里的myname333: ", myname)
// fmt.Printf("main函数里的name222: %s\n", name)
// fmt.Println("main 函数里的myname: ", myname)
test2()
}

var name string = "go"

func myfunc() string {
defer func() {
name = "python"
}()
fmt.Printf("myfunc 函数里的name: %s\n", name)
return name
}

func main() {
fmt.Printf("main函数里的name111: %s\n", name)
myname := myfunc()
fmt.Println("main 函数里的myname333: ", myname)
fmt.Printf("main函数里的name222: %s\n", name)
fmt.Println("main 函数里的myname: ", myname)
}

var (
old_name string
age      int
gender   float32
)

%b 格式化为二进制，
%c unicode码值
%d 十进制
%o 八进制
%x 十六进制
%X 十六进制
%U unicode格式
%E 科学计数法
%f 浮点数格式

type arr [3]int
var name arr = arr {1,2,3}

m := make([]int, 2, 10)
fmt.Println(m)

fmt.Printf("\n")
myarr := []int{}
fmt.Println(myarr)
myarr = append(myarr, 2)
fmt.Println(myarr)
myarr = append(myarr, []int{7, 8, 9}...) //解包切片
fmt.Println(myarr)
myarr = append([]int{100}, myarr...) //在第一个位置插入
fmt.Println(myarr)
fmt.Println(myarr[len(myarr)-1])
myarr = append(myarr[0:len(arr)-1], append([]int{520, 520}, myarr[len(myarr)-1:]...)...) //在最后一个元素之前插入元素
fmt.Println(myarr)

//********************************************
var socres map[string]int = map[string]int{"english": 92, "chinese": 85}
fmt.Println(socres)
users := make(map[string]int) //初始化一个字典
fmt.Println(users)
users["Echor"] = 19 //添加元素
users["zhou"] = 20
fmt.Println(users)
users["zhou"] = 21 //添加重复键元素
fmt.Println(users)
fmt.Println(users["zhou"]) //得到存在元素
_, ok := users["sss"]
fmt.Println(ok)       //得到不存在元素
delete(users, "zhou") //删除存在元素
fmt.Println(users)
delete(users, "sss") //删除不存在元素
fmt.Println(users)
   fmt.Println(users)
for k, v := range socres { //循环得到键值对
fmt.Println(k, v)
}

for [condition |  ( init; condition; increment ) | Range]
{
   statement(s);
}

goto flag:
****
flag:
****
    ****

class BaseHandler(web.RequestHandler):
    def initialize(self):
        self.session_save_tag = False
        self.session = None

    async def prepare(self):
        await self.init_session()
        if get_config().session['session_key_name'] in self.session:
            self.current_user = LoginUser(self.session[get_config().session['session_key_name']])
    def on_finish(self):
        if self.session is not None and self.session_save_tag:
            get_loop().add_callback(self.session.save)
        get_logger().info("[一次HTTP请求结束]")
        async def init_session(self):
        if not self.session:
            self.session = Session(self)
            await self.session.init_fetch()
            
    def save_session(self):
        self.session_save_tag = True
        self.session.generate_session_id()
        get_logger().info("【登录】生成session_id结束")

    def save_login_user(self, user: dict):
        login_user = LoginUser(None)
        login_user['username'] = user.get("username", "")
        login_user['email'] = user.get("email", "")
        login_user['phone'] = user.get("phone", "")
        self.session[get_config().session['session_key_name']] = login_user
        self.current_user = login_user
        self.save_session()

class LoginHandler(BaseHandler):
    async def post(self):
        try:
            username = self.data['username']
            password = self.data['password']
            doc_user = await get_one_data(self.mongodb_manager, Config.mongodb_config['user_info'],
                                          {'username': username})
            print(doc_user)
            if doc_user is not None and password == doc_user['password']:
                self.save_login_user(doc_user)
                get_logger().info("登录成功,用户信息已经保存")
        except Exception as e:
            error = traceback.format_exc()
            get_logger().error("login fail[{}]:{}".format(e, error))

class Solution:
def middelTravel(self, r):
    stack, ret = [], []
    root = r
    while stack or root:
    if root:
        stack.append(root)
        root = root.left
      else:
        s = stack.pop()
         ret.append(s.val)
         root = s.right
    return ret

python解决方案
class TreeNode:
def __init__(self):
    self.val = val
    self.left = None
    self.right = None
class Solution:
def isSubtitle(t,s):
    def up(t):
    return (t.val, up(t.left), up(t.right)) if t else None
    return str(up(t))  in str(up(s))

class TreeNode:
def __init__(self,x):
      self.val = x
      self.left = None
      self.right = None

class Solution:
def rightDideView(self, root: TreeNode) -> List[int]:
    d = {}
      def f(r,i):
         if r:
          d[i] = r.val
            f(r.left, i+1)
            f(r.right, i+1)
      f(root,0)
      return [*d.values()]

先序遍历，注意rightSideView(r->left, i+1)与rightSideView(r-right, i+1)中的i相同，由此可以知道，字典中存储的数据一定是每层的最后一个数据

1.依赖关系
定义：有两个元素x和y，如果修改x的定义可能会引起对y的定义的修改，则称y依赖与元素x，用带箭头的虚线表示依赖关系，箭头指向被依赖的对象。

2.泛化关系
泛化关系就是子类与父类之间的继承关系。用带空心箭头的实线表示，箭头指向父类

3.关联关系
关联关系可以理解为ER图中的实体关系，用实现表示，上方标识数字来进行确认。

4.聚合关系
聚合关系是一种特殊的关联关系，聚合关系表示的是类之间整体与部分的关系，用带有空心菱形的实线表示，空心菱形指向代表整体的类。

5.实现关系
定义接口，用户带空心箭头的虚线来表示

说一个容易忽略的问题，import只能导入模块，不能导入模块中的对象（类、函数、变量等）。如一个模块A（A.py）中有个函数getName，另一个模块不能通过import A.getName将getName导入到本模块，只能用import A。如果想只导入特定的类、函数、变量则用from A import getName即可。

[A.py] 
from B import C
class D:
pass

[B.py]
from A import D
class C:
pass

另外一种嵌套指，在模块A中import B，而在模块B中import A。这时会怎么样呢？这个在Python列表中由RobertChen给出了详细解释，抄录如下：

[A.py] from B import D class C:pass [B.py] from A import C class D:pass

为什么执行A的时候不能加载D呢？

如果将A.py改为：import B就可以了。

这是怎么回事呢？

RobertChen：这跟Python内部import的机制是有关的，具体到from B import D，Python内部会分成几个步骤：

在sys.modules中查找符号"B"
果符号B存在，则获得符号B对应的module对象。
从的__dict__中获得符号"D"对应的对象，如果"D"不存在，则抛出异常

如果符号B不存在，则创建一个新的module对象，注意，这时，module对象的__dict__为空。执行B.py中的表达式，填充的__dict__ 。

从的__dict__中获得"D"对应的对象，如果"D"不存在，则抛出异常。

所以，这个例子的执行顺序如下：

1、执行A.py中的from B import D

由于是执行的python A.py，所以在sys.modules中并没有存在，首先为B.py创建一个module对象()，注意，这时创建的这个module对象是空的，里边啥也没有，在Python内部创建了这个module对象之后，就会解析执行B.py，其目的是填充这个dict。

2、执行B.py中的from A import C

在执行B.py的过程中，会碰到这一句，首先检查sys.modules这个module缓存中是否已经存在了，由于这时缓存还没有缓存，所以类似的，Python内部会为A.py创建一个module对象()，然后，同样地，执行A.py中的语句。

3、再次执行A.py中的from B import D

这时，由于在第1步时，创建的对象已经缓存在了sys.modules中，所以直接就得到了，但是，注意，从整个过程来看，我们知道，这时还是一个空的对象，里面啥也没有，所以从这个module中获得符号"D"的操作就会抛出异常。如果这里只是import B，由于"B"这个符号在sys.modules中已经存在，所以是不会抛出异常的。

Package（包） Import

包（Package）可以看成模块的集合，只要一个文件夹下面有个__init__.py文件，那么这个文件夹就可以看做是一个包。包下面的文件夹还可以成为包（子包）。更进一步，多个较小的包可以聚合成一个较大的包，通过包这种结构，方便了类的管理和维护，也方便了用户的使用。比如SQLAlchemy等都是以包的形式发布给用户的。

包和模块其实是很类似的东西，如果查看包的类型import SQLAlchemy type(SQLAlchemy)，可以看到其实也是。import包的时候查找的路径也是sys.path。

包导入的过程和模块的基本一致，只是导入包的时候会执行此包目录下的__init__.py而不是模块里面的语句了。另外，如果只是单纯的导入包，而包的__init__.py中又没有明确的其他初始化操作，那么此包下面的模块是不会自动导入的。如：

PA

--__init__.py

--wave.py

--PB1

??--__init__.py

??--pb1_m.py

--PB2

??--__init__.py

??--pb2_m.py

__init__.py都为空，如果有以下程序：

?

import?sys
import?PA.wave??#1
import?PA.PB1???#2
import?PA.PB1.pb1_m?as?m1??#3

import?PA.PB2.pb2_m?#4

PA.wave.getName()?#5

m1.getName()?#6

PA.PB2.pb2_m.getName()?#7
当执行#1后，sys.modules会同时存在PA、PA.wave两个模块，此时可以调用PA.wave的任何类或函数了。但不能调用PA.PB1(2)下的任何模块。当前Local中有了PA名字。

当执行#2后，只是将PA.PB1载入内存，sys.modules中会有PA、PA.wave、PA.PB1三个模块，但是PA.PB1下的任何模块都没有自动载入内存，此时如果直接执行PA.PB1.pb1_m.getName()则会出错，因为PA.PB1中并没有pb1_m。当前Local中还是只有PA名字，并没有PA.PB1名字。

当执行#3后，会将PA.PB1下的pb1_m载入内存，sys.modules中会有PA、PA.wave、PA.PB1、PA.PB1.pb1_m四个模块，此时可以执行PA.PB1.pb1_m.getName()了。由于使用了as，当前Local中除了PA名字，另外添加了m1作为 PA.PB1.pb1_m的别名。

当执行#4后，会将PA.PB2、PA.PB2.pb2_m载入内存，sys.modules中会有PA、PA.wave、PA.PB1、PA.PB1.pb1_m、PA.PB2、PA.PB2.pb2_m六个模块。当前Local中还是只有PA、m1。

下面的#5，#6，#7都是可以正确运行的。

注意的是：如果PA.PB2.pb2_m想导入PA.PB1.pb1_m、PA.wave是可以直接成功的。最好是采用明确的导入路径，对于./..相对导入路径还是不推荐用。

def length_common_strength(str1, str2) -> int:
    """
    递归法求解
    :param str1:
    :param str2:
    :return:
    """
    def dp(i, j):
        if i == -1 or j == -1: return 0
        if str1[i] == str2[j]:
            return dp(i-1, j-1) + 1
        else:
            return max(dp(i-1, j), dp(i, j-1))
    return dp(len(str1) - 1, len(str2) - 1)

def length_common_strength_dp(str1, str2) -> int:
    """
    dp背包
    :param str1:
    :param str2:
    :return:
    """
    m, n = len(str1), len(str2)
    dp = [[0] * (n + 1) for _ in range(m+1)]
    for i in range(1, m+1):
        for j in range(1, n+1):
            if str1[i-1] == str2[j-1]:
                dp[i][j] = dp[i-1][j-1] + 1
            else:
                dp[i][j] = max(dp[i-1][j], dp[i][j-1])
    return dp[m][n]

dp[i] : 表示数组中的第i位置的最长子序列的长度,初始默认所有位置的dp[i] = 1

#include <cstdio>
#include <algorithm>
using namespace std;
/*求最长子序列*/

int main() {
const int MaxN = 100;
int Subsequence[MaxN];
int dp[MaxN];
for (int j = 0; j < MaxN; ++j) {
dp[j] = 1;
}
int n;
scanf_s("%d", &n);
if (n != 0) {
for (int i = 0; i < n; ++i) {
scanf_s("%d", &Subsequence[i]); //子序
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < i; ++j) {
if (Subsequence[i] > Subsequence[j]) {
dp[i] = max(dp[j] + 1, dp[i]);
}
}
}                                    
printf("输入结束!\n");
for (int j = 0; j < n; ++j) {
printf("%d", Subsequence[j]);
}
printf("\n");
for (int j = 0; j < n; ++j) {
printf("%d", dp[j]);
}
}
return 0;
}

#include <cstdio>
#include <ctime>

int BaseFib(int n) {//暴力递归斐波拉契数列
if (n == 1 || n == 2) return 1; //递归出口
return BaseFib(n - 1) + BaseFib(n - 2);
}

int DpTableFib(int n) {//dpTable,自底向上
int dp[1000] = {0}; //初始化为0
dp[1] = 1;
dp[2] = 1;
for (int i = 3; i <= n; ++i) {
dp[i] = dp[i - 1] + dp[i - 2];
}
return dp[n];
}


int main() {
int n = 20;
int m = n;
printf("%d", BaseFib(n));
printf("%d", DpTableFib(m));
return 0;
}

/*
区间不相交问题
*/
#include <algorithm>
using namespace std;

const int MaxN = 10;
struct interval
{
int x, y; //开区间左右端点
} I[MaxN];

bool cmp(interval a, interval b) {
if (a.x != b.x) return a.x > b.x; //先按照左端点从大到小的顺序排序
return a.y < b.y; // 如果左端点相同, 则按照右端点从小到大的顺序排序
}


int main() {
int n;
while (scanf_s("%d", &n), n!=0){
for (int i = 0; i < n; ++i) {
scanf_s("%d%d", &I[i].x, &I[i].y);
}
sort(I, I + n, cmp);
int ans = 1, lastX = I[0].x;
for (int i = 1; i < n; ++i) {
if (I[i].y <= lastX) {
lastX = I[i].x;
ans++;
}
}
printf("%d",ans);
}
return 0;
}

/*
递归求全排
*/
const int MaxN = 10;
const int MAXSIZE = 1000;
int P[MaxN];
bool hashTable[MAXSIZE] = { false }; //空间换取时间
int n;
void generateP(int index) {
if (index == n + 1) {
for (int i = 1; i <= n; ++i) {
printf("%d", P[i]);
}
printf("\n");
return;
}
for (int j = 1; j <= n; ++j) {
if (hashTable[j] == false) {
P[index] = j;
hashTable[j] = true;
generateP(index + 1);
hashTable[j] = false;
}
}
}
int main() {
n = 5;
generateP(1);
}

//n皇后问题,回溯法
int count = 0;
void queen(int index) {//第n列的皇后
if (index == n + 1) {//此时每一列都有一个皇后
count++;
printf("%d\n",count);
return;
}
for (int i = 1; i <= n; ++i) {
if (hashTable[i] == false) {//没有被使用过
bool flag = true; //表示当前序列与之前的皇后不冲突
for (int pre = 1; pre <= index; ++pre) {//回溯剪枝
//不能在同一对角线上
if (abs(pre - index) == abs(i - P[pre])) {
flag = false;
break;
}
}
if (flag) {
P[index] = i;
hashTable[i] = true;
queen(index + 1);
hashTable[i] = false;
}
}
}

}

int main() {
n = 8;
queen(1);
}

#include <cstdio>
#define MAXSIZE 1000
void HashInt(int a[], int b[]) {
bool c[MAXSIZE] = { false };
int m, n;
printf("a,b数组元素的个数:");
scanf("%d%d", &m, &n);
for (int i = 0; i < m; ++i) {
int tmp;
scanf("%d", &tmp);
a[i] = tmp;
c[tmp] = true;
}//空间换取时间
for (int j = 0; j < n; ++j) {
int tmp;
scanf("%d", &tmp);
b[j] = tmp;
if (c[tmp]) printf("%d在a中存在",tmp);
}

}

for(int i=0; i<len(s): ++i){
id = id*26 + (s[i]- 'A')
}

for(int i=0; i<len(s): ++i){
if(s[i]>'A' && s[i]<'Z')
id = id*26 + (s[i]- 'A')
else(s[i]>'a' && s[i]<'z')
id = id*52 + (s[i]-'a') + 26
}

void BubbleSort(int a[], int n) {//冒泡排序,a为数据数组, n为数组元素个数
int tmp;
for (int i = 1; i < n; ++i) {
for (int j = 0; j < n - i; ++j) {
if (a[j] > a[j + 1]) {//前一个元素大于后一个元素
tmp = a[j];
a[j] = a[j + 1];
a[j + 1] = tmp;
}
}
}
}

void selectSort(int a[], int n) {//选择排序
for (int i = 0; i < n; ++i) {
int m = i;
for (int j = i; j < n; ++j ) {
if (a[m] > a[j]) {
m = j;
}
}
int tmp = a[i];
a[i] = a[m];
a[m] = tmp;
}
}

给定一个数n,求出从1-n的所有子集

#include <stdio.h>
#define MaxN 100 //元素的最大值
#define MaxSize 100 //子集的最大值

typedef struct{
int n; //子集我的个数
int data[MaxSize][MaxN]; //元素
}PsetType;


void copy(int a[], int b[], int n){//将a数组的值复制给b数组
for(int i=0; i<=n; ++i)
b[i] = a[i];
}

void pset(int n, PsetType &p){
int a[MaxN];
//初始化
p.data[0][0] = 0;
p.n = 1;
//初始化结束
for(int i=1; i<=n; ++i){
int m = p.n; //原幂集中子集的个数
for(int j=0; j<m; ++j){
copy(p.data[j], a, p.data[j][0]);
a[0]++; //子集元素个数加1
a[a[0]] = i;
copy(a, p.data[p.n], a[0]);
p.n++;
}
}
}


void disp(PsetType p){
for(int i=0; i<p.n; ++i){
printf("{");
for(int j=1; j<=p.data[i][0];++j){
printf("%d",p.data[i][j]);
}
printf("}\n");
}
}

int main(){
PsetType p;
int n = 5;
pset(n, p);
disp(p);
return 0;
}

#include <stdio.h>
#define MaxN 100 //元素的最大值
#define MaxSize 100 //子集的最大值

typedef struct{
int n; //子集我的个数
int data[MaxSize][MaxN]; //元素
}PsetType;


void copy(int a[], int b[], int n){//将a数组的值复制给b数组
for(int i=0; i<=n; ++i)
b[i] = a[i];
}

void pset(int n, PsetType &p){
int a[MaxN];
//初始化
p.data[0][0] = 0;
p.n = 1;
//初始化结束
for(int i=1; i<=n; ++i){
int m = p.n; //原幂集中子集的个数
for(int j=0; j<m; ++j){
copy(p.data[j], a, p.data[j][0]);
a[0]++; //子集元素个数加1
a[a[0]] = i;
copy(a, p.data[p.n], a[0]);
p.n++;
}
}
}


void disp(PsetType p){
for(int i=0; i<p.n; ++i){
printf("{");
for(int j=1; j<=p.data[i][0];++j){
printf("%d",p.data[i][j]);
}
printf("}\n");
}
}

int main(){
PsetType p;
int n = 5;
pset(n, p);
disp(p);
return 0;
}

1. 感叹句,祈使句,疑问句都不是命题
2. 悖论不是命题
3.判断结果不能唯一确定的不是命题

P并且Q
不但P而且Q
既P又Q
尽管P还Q
虽然P但是Q