这个部门既然为null，那为什么在分组时不会忽略这个null值呢？

老师为什么我无论什么命令写在第二行选择执行的话都会报下面这个错，只要把第二行命令放在第一行就是一个查询窗口只有一条语句时它就能运行，如果多一行选择他就运行不出来，每次敲的时候都要敲一行运行完清一次窗口

列表标签为什么不能凡在center标签里面？一放进去就会出现下面的情况。。

/**
 * 使用字节缓冲流复制文件
 * @param src
 * @param des
 * @throws IOException
 */
public  static  void copyFile1(String src,String des) throws IOException {
    long start = System.currentTimeMillis();
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src));
    BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(new File(des)));
    byte[]bytes = new byte[1024];
    int len =0;
    while((len=bis.read(bytes))!=-1){
        bos.write(bytes, 0, len);
        bos.flush();
    }
    bos.close();
    bis.close();
    long  end = System.currentTimeMillis();
    long time =(end-start);
    System.out.println("复制完成，用时："+time+"毫秒");
}

之前格式弄错了，抱歉，问题一样

(String srcString des) IOException {
    start = System.()BufferedInputStream bis = BufferedInputStream(FileInputStream(src))BufferedOutputStream bos = BufferedOutputStream(FileOutputStream(File(des)))[]bytes = []len =((len=bis.read(bytes))!=-){
        bos.write(byteslen)bos.flush()}
    bos.close()bis.close()end = System.()time =(end-start)System..println(+time+)}

以上代码不明白，既然BufferedInputStream和BufferedOutputStream已经是缓冲流了，为什么在数据读取和写入时还需要用一个bytes数组来缓冲呢？

执行

  后

在solrconfig.xml中加入以下配置：

<!-- 配置数据导入的请求处理器-->

 <requestHandler name="/dataimport" class="org.apache.solr.handler.dataimport.DataImportHandler">-->

    <!-- See below for information on defining

         updateRequestProcessorChains that can be used by name

         on each Update Request

      -->

       <!--  加载数据导入文件，该文件中会定义sql语句，对数据库进行查询 -->

   <lst name="defaults">

         <str name="config">data-config.xml</str>

        </lst>

</requestHandler>

然后执行：

老师，你好。我按照要求设置，可以正常使用。就是重启后，ip又变为默认的了，必须得 执行一次 service network restart 命令，ip才能设置好。  请问，这是缺少什么设置吗？

一、代码

#coding=utf-8

import threading
import time
from queue import Queue

class Pro(threading.Thread):
    def run(self):
        global q
        count=0
        while True:
            if q.qsize()<1000:
                for i in range(100):
                    count = count+1
                    msg = "生成产品"+str(count)
                    q.put(msg)
                    print(msg)
            time.sleep(1)

class Con(threading.Thread):
    def run(self):
        global q
        while True:
            if q.qsize()>100:
                for i in range(3):
                    msg = self.name + "消费了" + q.get()
                    print(msg)
            time.sleep(1)


if __name__ == "__main__":
    q = Queue()
    for i in range(500):
        q.put("初始产品"+str(i))
    for i in range(2):
        p = Pro()
        p.start()
    for i in range(5):
        c = Con()
        c.start()

二、问题

1、

上述产生数据的两个进程是同时运行的还是一个运行完再运行下一个？

如其同时运行，当第一个进程已经往池中写入“生成产品1”，第二个进程还可以往里面写入“生成产品1”吗？

老师，上面这条语句的作用是什么，刚开始使锁处于False状态，怎样会变成True呢？

老师你好，请帮忙解释一下字典在内存中到底是如何存储的。以下代码中，字典a和b并不相等，为什么它们的items/keys/values的id都相等呢？

老师，你的这个 self.search 没有加任何参数，这样写有什么作用？

@ConfigurationProperties(prefix = "jdbc")

老师，prefix = "jdbc",这个前缀是指啥？

老师salarys.append(float(s)) 为什么不能写成 salarys = salarys.append(float(s))?

NODE_LIST = [
    {'data': 60, 'left': 12, 'right': 90, 'is_root': True},
    {'data': 12, 'left': 4, 'right': 41, 'is_root': False},
    {'data': 4, 'left': 1, 'right': None, 'is_root': False},
    {'data': 1, 'left': None, 'right': None, 'is_root': False},
    {'data': 41, 'left': 29, 'right': None, 'is_root': False},
    {'data': 29, 'left': 23, 'right': 37, 'is_root': False},
    {'data': 23, 'left': None, 'right': None, 'is_root': False},
    {'data': 37, 'left': None, 'right': None, 'is_root': False},
    {'data': 90, 'left': 71, 'right': 100, 'is_root': False},
    {'data': 71, 'left': None, 'right': 84, 'is_root': False},
    {'data': 100, 'left': None, 'right': None, 'is_root': False},
    {'data': 84, 'left': None, 'right': None, 'is_root': False},
]


class Node():
    def __init__(self, date, left=None, right=None):
        self.date = date
        self.left = left
        self.right = right

    def __str__(self):
        return "数据是：{}".format(self.date)


class Tree():
    def __init__(self, root=None):
        self.root = root

    def install_date(self, dates):
        node_list = {}
        for n in dates:
            node = Node(n['data'], n['left'], n['right'])
            node_list[n['data']] = node
        for m in dates:
            node = node_list[m['data']]
            if node.left:
                node.left = node_list[node.left]
            if node.right:
                node.right = node_list[node.right]
            if m["is_root"]:
                self.root = node

    def search(self, subtree, value):
        if subtree is None:
            return None
        elif subtree.date > value:
            return self.search(subtree.left, value)
        elif subtree.date < value:
            return self.search(subtree.right, value)
        else:
            return subtree

    def iter_node(self, node):
        if node:
            print(node.date)
            self.iter_node(node.left)
            self.iter_node(node.right)

    def get_min(self, subtree):
        if subtree is None:
            return None
        elif subtree.left:
            return self.get_min(subtree.left)
        else:
            return subtree

    def add(self, value):
        node = self.search(self.root, value)
        if node:
            return False
        else:
            self.root = self.insert_data(self.root,value)
            return True

    def insert_data(self, subtress, value):
        if subtress is None:
            subtress = Node(value)
        elif subtress.date > value:
            subtress.left = self.insert_data(subtress.left, value)
        else:
            subtress.right = self.insert_data(subtress.right, value)
        return subtress

老师，我这里为啥曝出 重复代码片段，我找不到哪里重复了

老师，线程之间是共享资源的，num公用同一个内存地址，为什么主线程等所有子线程跑完，num内存里的值不应该是2000000吗？