import java.util.Scanner;

public class TestSalary {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        System.out.println("***********我的薪水计算器***********");
        System.out.println("1.输入 88，退出程序\n2.输入 66，计算下一个年薪");
        while(true){
            System.out.println("请输入月薪：");
            int monthSalary = s.nextInt();
            System.out.println("请输入一年几个月薪资：");
            int months = s.nextInt();
            int yearSalary = monthSalary*months; //年薪
            System.out.println("年薪是："+yearSalary);
            if(yearSalary>=200000){
                System.out.println("恭喜你超越 98%的国人");
            }else if(yearSalary>=100000){
                System.out.println("恭喜你超越 90%的国人");
            }
            System.out.println("输入 88，退出系统；输入 66，继续计算。");
            int comm = s.nextInt();
            if(comm==88){
                System.out.println("系统退出！");
                break;
            }
            if(comm==66) {
                System.out.println("继续计算下一个薪资");
               continue;
            }
        }
    }
}

老师，因为这个循环本身是死循环，跳出这个循环和不跳出这个循环，之后执行结果都一样，是不是continue就可加可不加

/**
 * 创建发送消息类
 */

class ClientSend extends Thread {
    private  Socket socket;
    public ClientSend(Socket socket){
        this.socket = socket;
    }
    @Override
    public void run() {
        this.sendMsg();

    }
    /**
     * 发送消息
     */
    private void sendMsg(){
        Scanner scanner = null;
        PrintWriter pw = null;
        try {
            //键盘输入
            scanner = new Scanner(System.in);
            //创建向对方输出消息的流对象
            pw = new PrintWriter(this.socket.getOutputStream());
            while (true){
                String msg = scanner.nextLine();
                if ("exit".equals(msg)){
                    break;
                }
                pw.println(msg);
                pw.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (pw != null){
                pw.close();
            }
            if (scanner != null){
                scanner.close();
            }
            if(this.socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

/**
 * 创建接收消息线程类
 */
class ClientReceive extends Thread {
    private Socket socket;
    public ClientReceive(Socket socket){
        this.socket = socket;
    }
    @Override
    public void run() {

    }
    /**
     * 接收消息的方法
     */
    private void receiveMsg(){
        BufferedReader br = null;
        try {
            br = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
            while (true){
                String msg = br.readLine();
                System.out.println("他说： " +msg );

            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (br!=null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

public class PointSocketClient {
    public static void main(String[] args)  {

        try {
            Socket socket = new Socket("127.0.0.1",8888);
            System.out.println("连接成功");
            new ClientSend(socket).start();
            new ClientReceive(socket).start();
        } catch (IOException e) {
            e.printStackTrace();
        }
        
    }
}

/**
 * 创建发送消息类
 */

class Send extends Thread{
    private  Socket socket;
    public Send(Socket socket){

        this.socket = socket;
    }
    @Override
    public void run() {
        this.sendMsg();

    }

    /**
     * 发送消息
     */
    private void sendMsg(){
        Scanner scanner = null;
        PrintWriter pw = null;
        try {
            //键盘输入
            scanner = new Scanner(System.in);
            //创建向对方输出消息的流对象
            pw = new PrintWriter(this.socket.getOutputStream());
            while (true){
                String msg = scanner.nextLine();
                if ("exit".equals(msg)){
                    break;
                }
                pw.println(msg);
                pw.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (pw != null){
                pw.close();
            }
            if (scanner != null){
                scanner.close();
            }
            if(this.socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}
/**
 * 创建接收消息线程类
 */
class Receive extends Thread{
    private  Socket socket;

    public Receive(Socket socket){
        this.socket = socket;
    }

    @Override
    public void run() {
        this.receiveMsg();

    }
    /**
     * 接收消息的方法
     */
    private void receiveMsg(){
        BufferedReader br = null;
        try {
            br = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
            while (true){
                String msg = br.readLine();
                System.out.println("他说： " +msg );

            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (br!=null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
public class PointSocketServer {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        try {
            serverSocket =new ServerSocket(8888);
            System.out.println("服务器启动等待连接.....");
            Socket socket = serverSocket.accept();
            System.out.println("连接成功");
            new Send(socket).start();
            new Receive(socket).start();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if (serverSocket != null){
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

老师我这个代码只有客户端给服务端发消息的收回会输出

服务端给客户端发消息时没有反应，麻烦老师看下

有时候需要导包有很多选择，请问怎么选择应该导哪个包呢

/**
 * 测试方法的使用
 * @author yingh
 *
 */
public class TestMethod {
	public static void printSxt() {
		System.out.println("hahaaha1!");
		System.out.println("hahaaha2!");
		System.out.println("hahaaha3!");
	}
	
	int add(int a, int b, int c) {
		int sum=0;
		sum = a+b+c;
		System.out.println(sum);
		return sum;//1 return 的2个作用：1.结束方法的运行。2 返回值    void 是什么都不返回， 但是如果返回了值，则需要将void改为int
	}
	public static int add(int a, int b) {//public static 加入之后就不需要通过对象来调用了
		int sum=0;
		sum = a+b;
		//System.out.println(sum);
		return sum;
	}
	public static void main(String[] args) {
		//1 通过对象调用方法
		TestMethod tm= new TestMethod();
		printSxt();
		tm.add(5, 6, 7);
		int c=tm.add(6, 6, 10)+1000;//1如果有确切的返回值则可以直接计算, 形参与实参必须类型匹配 ，如double 
		System.out.println(add(1,2));
		System.out.println(c);
		
		
	}
}

问题1：老师，请问我这个输出为什么会有个22？我看了一下

int c=tm.add(6, 6, 10)+1000;

这个语句我并没有输出，但是好像自动默认用对象直接调用了，请问这个如何避免呢？

问题2：在一个方法中，如果我

System.out.println(sum);
return sum;

进行了如上操作，我想问的是如果在方法里不进行输出操作，直接return的话，那么在main函数中要想输出的话就必须用System.out.println(...)来输出是不是？

如果在方法中写了输出操作，静态方法就在main函数中直接调用即可输出结果，非静态方法通过对象调用就可以输出结果，就不需要再写一个System.out.println()了？

老师，这是啥意思啊

为什么flask db migrate老是报这个错

from pyspark import SparkConf, SparkContext


def myprint(one):
    print(one)


def top2list(one):
    website = one[0]
    locals = one[1]
    localdic = {}
    for local in locals:
        if local in localdic:
            localdic[local] += 1
        else:
            localdic[local] = 1
    site_locallist = sorted(localdic.items(), key=lambda tp: tp[1], reverse=True)
    returnlist = []
    if (len(site_locallist) > 2):
        for i in range(2):
            returnlist.append(site_locallist[i])
    else:
        returnlist = site_locallist
    return website, returnlist


def get_site_uid_count(one):
    uid = one[0]
    sites = one[1]
    siteDic = {}
    for site in sites:
        if site in siteDic:
            siteDic[site] += 1
        else:
            siteDic[site] = 1
    returnlist = []
    for site, count in siteDic.items():
        returnlist.append((site, (uid, count)))
    return returnlist


def top3list(one):
    website = one[0]
    uid_count_itr = one[1]
    top3lists = ['', '', '']
    for uid_count in uid_count_itr:
        count = uid_count[1]
        for i in range(len(top3lists)):
            if top3lists[i] == "":
                top3lists[i] = uid_count
                break
            elif top3lists[i][1] < count://运行时总是提示这行，str与int之间不能比较，打印type(top3lists[i][1])为int)
                for j in range(2, i, -1):
                    top3lists[j] = top3lists[j - 1]
                top3lists = uid_count
                break

    return website, top3lists


def getApv():
    conf = SparkConf()
    conf.setMaster("local")
    conf.setAppName("pv")
    sc = SparkContext(conf=conf)
    linesRDD = sc.textFile("D:\mypython\date\website")
    # linesRDD.map(lambda line:(line.split("\t")[2],1)).reduceByKey(lambda v1,v2:v1+v2).\
    #     sortBy(lambda tp:tp[1],ascending=False).foreach(lambda one:myprint(one=one))
    # 每个网站访问最多的top2地区
    # site_local = linesRDD.map(lambda line:(line.split("\t")[4],line.split("\t")[2])).groupByKey()
    # site_local.map(lambda one:top2list(one)).foreach(print)
    # 每个网站最活跃的用户top3
    linesRDD.map(lambda line: (line.split("\t")[3], line.split("\t")[4])).groupByKey() \
        .flatMap(lambda one: get_site_uid_count(one)).groupByKey().map(lambda one: top3list(one)).foreach(print)


if __name__ == "__main__":
    getApv()

w定义为一个不把方差写死的正态分布--上面作用于tanh

在relu上效果不怎么好

在xavier基础上除以2（也就是微调定制的思想）

对relu的契合度就大大提升了

w是变量，需要反复调整、训练、再调整

激活函数 -- relu；w合理的一个初始化 只能使得梯度消失的情况有所好转，是不能完全解决的，根本原因也是w是要调的

这个怎么就输出就一行，不是应该还有好几行吗

a={'姓名':'高小一','年龄':18,'薪资':3000,'城市':'北京'}
b={'姓名':'高小二','年龄':19,'薪资':2000,'城市':'上海'}
c={'姓名':'高小五','年龄':20,'薪资':1000,'城市':'深圳'}
d=[a,b,c]
print(d)
print(d[1].get('姓名')) # 获取列表1姓名是谁，输出结果：高小二，
                       # 需要注意的是列表1对应字典是b
                       # 需要注意的是列表0对应字典是a
                       # 需要注意的是列表2对应字典是c
for i in range(len(d)): # for循环,
                        # len(d)指的是列表d的长度，也可以直接写成for i in range(3)
   print(d[i])  # 输出结果
                #   {'姓名': '高小一', '年龄': 18, '薪资': 3000, '城市': '北京'}
                #  {'姓名': '高小二', '年龄': 19, '薪资': 2000, '城市': '上海'}
                #   {'姓名': '高小五', '年龄': 20, '薪资': 1000, '城市': '深圳'}
   print(d[i].get('姓名')) # 输出结果：高小一、高小二、高小五
for i in range(len(d)):
    print(d[i].get('姓名'),d[i].get('年龄'),d[i].get('薪资'),d[i].get('城市'))
    # 高小一 18 3000 北京
    # 高小二 19 2000 上海
    # 高小五 20 1000 深圳

老师，为什么我突然代码自动提示没有了。我重新安装了一次这个HBuilder还是没用。我按alt+/提示没有建议
。也没有设置到其他什么东西，为什么突然会这样啊

老师，问题如下图：

from tkinter import *
from tkinter import messagebox
import webbrowser


class Application(Frame):
    '''一个经典的GUI程序的类的写法'''

    def __init__(self, master=None):
        super(Application, self).__init__(master)           #super()代表的是父类的定义，而不是父类的对象/虽然继承了Frame,但不会调用Frame的构造器
        self.master = master
        self.pack()
        self.createwidget()                #需要创建多个窗口对象时，需要调用此


    def createwidget(self):
        '''创建组件'''
        self.w1 = Text(root, width=40, height=12, bg='gray')  #40列字符  12行字符的高度
        #宽度 20个字母（10个汉字），高度一个行高
        self.w1.pack()

        self.w1.insert(1.0, '123456789\nabcdefg')
        self.w1.insert(2.3, '锄禾日当午，汗滴禾下土，谁知盘中餐，粒粒皆辛苦\n')

        Button(self, text='重复插入文本', command=self.insertTest).pack(side='left')  #若写’left‘,默认垂直排列
        Button(self, text='返回文本', command=self.returnTest).pack(side='left')
        Button(self, text='添加图片', command=self.addImage).pack(side='left')
        Button(self, text='添加组件', command=self.addWidget).pack(side='left')
        Button(self, text='通过tag精确控制文本',command=self.bindTag).pack(side='left')


        def insertTest(self):
            # INSERT 索引表示在光标处插入
            self.w1.insert(INSERT, 'gaoqi')
            # END索引号表示在最后插入
            self.w1.insert(END, '[sxt]')
            self.w1.insert(1.8, 'gaoqi')

        def retuRntest(self):
            # Indexes(索引)是用来指向Text组件中的文本的位置，Text组件索引也是对应实际字符之间的位置
            # 核心：行号以1开始，列好以0开始
            print(self.w1.get(1.2, 1.6))
            print('所有文本内容：\n'+self.w1.get(1.0, END))  # 将文本内容返回到Run框中

        def addImage(self):
            global photo
            self.photo = PhotoImage(file='imgs/星球.gif')
            self.w1.image_create(END, image=self.photo)

        def addWidget(self):   #增加组件
            b1 = Button(self.w1, text='爱尚学堂')
            #在text 创建组件的命令
            self.w1.window_create(INSERT, window=b1)

        def bindTag(self):
            self.w1.delete(1.0,END)
            self.w1.insert(INSERT, 'good good study,day day up!\n北京尚学堂\n'
                                   '百战程序员\n百度，搜一下就知道')
            self.w1.tag_add('good', 1.0, 1.9)      #给’1.0‘到’1.9‘增加一个标记，’good‘或其他也可以
            self.w1.tag_config('good', background='yellow', foreground='red')
            #config 给标记处增加配置

            self.w1.tag_add('baidu', 4.0, 4.2)
            self.w1.tag_config('baidu', underground=True)   #加了下划线
            self.w1.tag_bind('baidu', '<Button-1>', self.webshow)
            #bind 绑定事件

        def webshow(self, event):
            webbrowser.open('http://www.baidu.com')


if __name__=='__main__':     # 规范写法，作为独立的个体去调用
    root = Tk()
    root.geometry('400x300+200+300')
    app = Application(master=root)
    root.mainloop()

怎么能让任务调度自动关闭呢？？？？？？？？？？？？？？？？？

提问：

        RPC跨域问题_JSONP解决 

老师，jsonp跨域问题我和第七部分_JAVA高级技术里面讲过的内容进行了验证，其中有一个原来的视频内容就是Springmvc对于jsonp的支持，但那个方法已经不建议使用了，以后是不是还是使用字符串拼接的方式？