from dbutil import MYdb
class MyService:
    def login(self,uname,password):
        sql = "select * from t_user where uname = %s and password = %s"
        user = MYdb().query_one(sql,uname,password)
        if user:
            return True
        else:
            return False

老师，这块会显示导入错误，可是我是照着视频来的，是哪儿有误吗？麻烦老师帮忙看一下，看了很久没看出来

关于return在方法中的作用，我不太明白，比如下代码：

public static int calculateScore(boolean gameOver,int score, int levelCompleted, int bonus) {
        if(gameOver) {
            int finalScore = score + (levelCompleted * bonus);
            finalScore += 2000;
            System.out.println("Your final score was " + finalScore);
            return finalScore;
        }
        return -1;
    }
boolean gameOver = true;
int score = 800;
int levelCompleted = 5;
int bonus = 100;
calculateScore(gameOver, score, levelCompleted, bonus);
calculateScore(false, score, levelCompleted, bonus);

有三个问题：

1. 在写的时候，如果不return，会报错。这里在执行最后一句和倒数第二句时，实际的作用是计算并print最终分数，所以我不懂为什么一定要return，否则报错。

2.return的数据最终在哪里？之前的课程讲过，方法执行完成后，会出栈并消失，值存与堆之中。那么，这个return的值，在方法出栈并消失后，存在哪里？在堆中吗？是以什么形式存在堆中呢？比如这里是int，就存于堆中吗？还是在方法区？

3. return的值，在这个方法中，是看不出来的。特别是，最后一行代码实际没有打印出任何东西。

如果我想把return的值打印出来（比如这里返回finalScore和-1)，我要怎么写代码才能看到return的值，谢谢

com.praticehomeWork2{
    () {
        }

    (x) {
        (x<){
            .= }
        .= x}

    () {
        }

    (y) {
        (y<){
            .= }
        .= y}

    (xy) {
        (x != y) {
            System..println()} {
            System..println()(i = i <= xi++) {
                (j = j <= yj++) {
                    System..print(+)}
                System..println()}
            System..println()(i = i <= xi++) {
                (j = j <= yj++) {
                    (i == || i == x || j == || j == y) {
                        System..print(+)} System..print(+)}
                System..println()}
        }
    }
}
Text{
    (String[] args) {
        homeWork2 C = homeWork2()C.()
    }
}

如果这样封装，为啥我重写的set get方法对我输入的值没有进行判断？那set get方法有什么用？

PageController

LoginController

下面也有同学和我这样同样的问题,在跳转页面的时候加上了page路径吗，而index页面和foot，menu，body都有关联,使得静态资源找不到了。怎么解决加上了page路径找不到静态资源,,,,不删除这个page路径的情况下找到静态资源呢?

老师我在安装MySql的时候提升我这个，试了下其他版本也是这样，这是怎么回事啊

老师，这样说来，基于dubb实现增删改查操作的代码，和基于Spring，Springboot的代码也差不了太多咯？只是到后面部署的时候不一样，是这样子的吗？

方法里都已经有了输出语句，为什么还要return，而且return了主方法里也没有定义变量接收，这个return是不是有点多余了

老师为啥我这个和视频里面 的不一样，不是说应该会报错吗，ename应该没法显示的，因为没法代表一整个部门呀（上面的图是视频里面的，下面的图是我自己的代码）

这是为啥？yum更新就是这样，安装gcc也是这样。。。

老师，这个错误我在代码中找不出来，这个错误意味着哪里错了？？

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

tf.compat.v1.disable_eager_execution()
# 读数据
mnist = input_data.read_data_sets("MINST_DATA_Bak", one_hot=True)
# 创建上下文为了后面的sess。run（）
sess = tf.compat.v1.InteractiveSession()


# 截断的正太分布噪声， 标准查设为0，1
# 同时我们使用relu， 也会给偏置项增加一些小的正值0.1用来避免死亡节点（dead neurons）
def weight_variable(shape):
    inital = tf.compat.v1.truncated_normal(shape, stddev=.1)
    return tf.Variable(inital)


def bias_variable(shape):
    inital = tf.constant(0.1, shape=shape)
    return tf.Variable(inital)


# tf.nn.conv2d 是tensorflow 的二位卷积函数， 参数x是输入，w是卷积的参数， 比如[5,5,1,32]
# 前面两个数字代表卷积核的尺寸，第三个数字代表有多少个channel，因为我们只有灰度单色，所以是1，如果是彩色的RGB，则是3
# 最后代表卷积核的数量，也就是卷积核会提取多少类的特征
# srides 代表卷积核的步长，都是1，代表不会漏划过图片的每一个点
# 边界加上Padding让卷积的输出和输入保持同样的SAME 的尺寸，仅当步长为1的时候


def conv2d(x, W):
    return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding="SAME")


# tf.nn.max_pool是tensflow 的最大池化函数，这里我们使用2*2的最大池化，即将2*2的像素降为1*1的像素
# 最大池化会保留原始像素块中灰度值最高的那一个像素，既保留原始像素最明显的特征，因为希望整体上的缩小图片尺寸，因此池化层
# strides 也设为横竖两个方向以2为步长，如果步长还是1，那么我们会得到一个尺寸不变的图片


def max_pool_2x2(x):
    return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding="SAME")


# 因为卷积神经网络会用到空间结构信息， 因此需要1D的输入向量转化为2D 的图片结构，即从1*764的象视转化原始的28*28的形式
x = tf.compat.v1.placeholder(tf.float32, [None, 704])
y_ = tf.compat.v1.placeholder(tf.float32, [None, 10])
x_iamge = tf.reshape(x, [-1, 28, 28, 1])

# 定义第一个卷积层，我们先使用前面写好的参数进行初始化， 包括weights和bias, 这里的[5,5,1,32]代表卷积层
# 赫尺寸为5*5 ，1个颜色通道，32个不同的卷积核，然后使用conv2d 函数进行卷积操作，并加上偏置项，接着再使用Relu 激活函数
# 非线性处理， 最后使用最大池化函数max_pool_2*2 对卷积的结果进行池化操作

w_conv1 = weight_variable([5, 5, 1, 32])  #通道必须是1
b_conv1 = bias_variable([32])
# 进行cov2d 进行卷积
h_conv1 = tf.nn.relu(conv2d(x_iamge, w_conv1) + b_conv1)
h_pool1 = max_pool_2x2(h_conv1)

# 第二层和第一层一样， 但是卷积核变成了64
w_conv2 = weight_variable([5, 5, 32, 64])
b_conv2 = bias_variable([64])
h_conv2 = tf.nn.relu(conv2d(x_iamge, w_conv1) + b_conv1)
h_pool2 = max_pool_2x2(h_conv2)

# 因为前面经历了两次步长为2*2的做大池化，所以边长已经为1/4了，图片尺寸由28*28变成了7*7
# 而第二个卷积层的卷积核数量是64，输出的tensor尺寸即为7*7*64
# 然后我们使用tf。reshape 函数对第二个卷积层的输出tensor进行变形，将其转成1D的向量
# 然后使用一个全连接层，隐含节点为1024，并使用reLu激活函数
w_fc1 = weight_variable([7 * 7 * 64, 1024])
b_fc1 = bias_variable([1024])
h_pool2_flat = tf.reshape(h_pool2, [-1, 7 * 7 * 64])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, w_fc1) + b_fc1)

# 防止过拟合，使用Dropout 层
keep_prob = tf.compat.v1.placeholder(tf.float32)
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

# 多添加一个全连接，
# 初始化 w, b
w_fc_plus = weight_variable([1024, 256])
b_fc_plus = bias_variable([256])
h_fc_plus_drop = tf.nn.relu(tf.matmul(h_fc1_drop, w_fc_plus) + b_fc_plus)

# 接softmax 分类
w_fuc2 = weight_variable([256, 10])
b_fuc2 = bias_variable([10])
y_conv = tf.nn.softmax(tf.matmul(h_fc_plus_drop, w_fuc2) + b_fuc2)


cross_entropy = tf.compat.v1.reduce_mean(-tf.compat.v1.reduce_sum(y_ * tf.compat.v1.log(y_conv),
                                              reduction_indices=[1]))
train_step = tf.compat.v1.train.AdamOptimizer(1e-4).minimize(cross_entropy)
correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1))
accuacy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

# 训练
tf.compat.v1.global_variables_initializer().run()
for i in range(20000):
    batch = mnist.train.next_batch(50)
    if i % 100 == 0:
        train_accuracy = accuacy.eval(feed_dict={x: batch[0], y_: batch[1],
                                                  keep_prob: 1.0})
        print("step %d , train accuacy %g" % (i, train_accuracy))
    train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})

x_test, y_test = mnist.train.next_batch(5000)
print("test accuracy %g" % accuacy.eval(feed_dict={
    x: x_test, y_: y_test, keep_prob: 1.0
}))

老师，请问在pycharm中怎样启用pyecharts的notebook的模式？还有，为什么视频里教学的代码运行环境总是变来变去的，一下使用vs code，一下又是pycharm，没有规矩？随心所欲？就是玩？虽然说两个软件都可以运行python文件，但是使用的话还是有区别的，希望百战在这方面重视一下

辛苦老师看一下，这个提示是什么意思？十分感谢

老师请问为什么我每次只要离开我的游戏画面（换去另一个窗口，或者是缩小窗口），程序就会崩？

package com.bjsxt.planeWar;

import java.awt.*;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

/**
 * 游戏主窗口
 */
public class MyGameFrame extends Frame {

    Image planeImage = GameUtil.getImage("Images/plane.png");
    Image bg = GameUtil.getImage("Images/bg.jpg");

    Plane p1 = new Plane(planeImage, 100, 100, 7);

    boolean left, right, up, down;  //飞机方向控制

    @Override
    public void paint(Graphics g) { //g当做是一支画笔

        g.drawImage(bg, 0, 0, 500, 500, null);

        p1.drawMyself(g);

        if (left) {
            p1.x -= p1.speed;   //为什么是 - ：记住画面是从左上角开始的
        }
        if (right) {
            p1.x += p1.speed;
        }
        if (up) {
            p1.y -= p1.speed;
        }
        if (down) {
            p1.y += p1.speed;
        }

    }

    // 初始化窗口
    public void launchFrame() {
        this.setTitle("飞机大战-尚学堂");
        setVisible(true); //窗口是否可见

        setSize(Constant.GAME_WIDTH, Constant.GAME_HEIGHT); //窗口大小

        setLocation(100, 100); //窗口打开位置

        // 增加关闭窗口的动作
        this.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0); // 正常退出程序

            }
        });

        new PaintThread().start(); //启动重画窗口的线程
        this.addKeyListener(new KeyMonitor()); //启动键盘监听
    }

    /**
     * 定义了一个重画窗口的线程类
     * 定义成内部类是为了方便直接使用窗口类的相关方法
     */
    class PaintThread extends Thread {
        @Override
        public void run() {
            while (true) {
                repaint();      // 内部类可以直接使用外部类的成员

                try {
                    Thread.sleep(50);  //1s = 1000ms, 1s画20次
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    // 内部类， 实现键盘的监听处理
    class KeyMonitor extends KeyAdapter {
        @Override
        public void keyPressed(KeyEvent e) {
            System.out.println("按下："+e.getKeyCode());
//            if (e.getKeyCode() == KeyEvent.VK_LEFT) {
//                left = true;
//            }

            switch (e.getKeyCode()) {
                case KeyEvent.VK_LEFT:
                    left = true;
                    break;
                case KeyEvent.VK_RIGHT:
                    right = true;
                    break;
                case KeyEvent.VK_UP:
                    up = true;
                    break;
                case KeyEvent.VK_DOWN:
                    down = true;
                    break;
            }

        }

        @Override
        public void keyReleased(KeyEvent e) {
            System.out.println("抬起："+e.getKeyCode());
            switch (e.getKeyCode()) {
                case KeyEvent.VK_LEFT:
                    left = false;
                    break;
                case KeyEvent.VK_RIGHT:
                    right = false;
                    break;
                case KeyEvent.VK_UP:
                    up = false;
                    break;
                case KeyEvent.VK_DOWN:
                    down = false;
                    break;
            }
        }
    }


    private Image offScreenImage = null;
    public void update(Graphics g) {
        if(offScreenImage == null)
        offScreenImage = this.createImage(Constant.GAME_WIDTH, Constant.GAME_HEIGHT);//这是游戏窗口的宽度和高度
        Graphics gOff = offScreenImage.getGraphics(); paint(gOff);
        g.drawImage(offScreenImage, 0, 0, null);
    }

    public static void main(String[] args) {
        MyGameFrame gameFrame = new MyGameFrame();
        gameFrame.launchFrame();
    }
}

三点问题

1、不管则么设置索引列只显示btree

2、先创建的唯一索引，然后创建的唯一性约束，删除索引后唯一性无效了，尴尬的时约束还在

3、keys与index显示内容一样.....

火狐放到Python根目录，谷歌放到Script文件夹内？？？