print("年薪;"+str((int(salary)*12)))
这里的str有什么用

关于分数100和输错一次成绩的调整，上次传输不成功，这次发的图片

 int[] i={}；调用System.out.println(i)之后出现[I@5d76b067，这后面的5d76b067是空数组的地址吗？如下图

老师，这个io.StringIO()方式修改和replace进行替换有点类似啊，都是创建了新的对象实现对字符串改变的吧

本质就是一种数据库的设计思想嘛？zszszs

老师，同步代码块中 wait(）方法及 notify() 方法是用 this 对象调用的，那这个对象到底是哪个类下的对象？是 缓冲区 BufferZone 类下实例化的对象嘛？

// 馒头类
class SteamBread {
    private int id;

    public SteamBread(int id) {
        this.id = id;
    }

    public int getId() {
        return this.id;
    }
}

// 缓冲区类
class BufferZone {
    // 存放馒头的盒子
    private SteamBread[] sb = new SteamBread[10];
    // 定义操作盒子的索引
    private int index;

    // 生产者方法馒头
    public synchronized void put(SteamBread steamBread) {
        while (this.index >= this.sb.length) {
            try {
                this.wait();   // this 引用当前类的实例，所以对应的对象为 BufferZone 类下实例化的对象 bz
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.notify();
        this.sb[this.index] = steamBread;
        this.index++;
    }

    // 取馒头
    public synchronized SteamBread take() {
        while (this.index == 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.notify();
        this.index--;
        return this.sb[this.index];
    }
}

// 生产者线程类
class ProducerThread extends Thread {
    private BufferZone bz;

    public ProducerThread(BufferZone bz) {
        this.bz = bz;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; ++i) {
            System.out.println("生产馒头:" + i);
            SteamBread sb = new SteamBread(i);
            this.bz.put(sb);
        }
    }
}

// 消费者线程类
class ConsumerThread extends Thread {
    private BufferZone bz;

    public ConsumerThread(BufferZone bz) {
        this.bz = bz;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; ++i) {
            SteamBread sb = this.bz.take();
            System.out.println("消费馒头:" + i);
        }
    }
}


// 测试生产者消费者模式
public class ProducerConsumerModel {
    public static void main(String[] args) {
        BufferZone bz = new BufferZone();
        new ProducerThread(bz).start();
        new ConsumerThread(bz).start();
    }

}

老师我这哪里转错了                

代码

socket *
struct
filename=server_ip=send_data = struct.pack(.format((filename))filename.encode().encode())
s=socket(AF_INETSOCK_DGRAM)
s.sendto(send_data(server_ip))
f=(filename)
:
    recv_data=s.recvfrom() caozuomaack_num=struct.unpack(recv_data[][:]) rand_port=recv_data[][] (caozuoma)==:
        ()
        (.format(caozuomaack_numrand_port(recv_data)))
    f.write(recv_data[][:]) (recv_data[])<:
        ()
        ack_data=struct.pack(ack_num)
    s.sendto(ack_data(server_iprand_port))

运行结果

提问：为什么数据长度都是2？而且下载的文件的空文件？

 查了下好像是更改src后整个页面刷新导致的，有木有办法只刷新iframe不刷新整个页面，求教

老师，问问你这个实现一个方法的快捷键？谢谢老师

为什么我操作的时候会让我重新登录？

老师，请问一下这里的-1L是表示什么意思啊

join（）合并有两个疑问

1. join()合并时间计算问题。append（）在列表中实现了列表创建，虽然没有将列表中每个对象进行连接，但已经完成了列表对象的排列。join()合并时间测试是否应该以列表创建创建完成起算？

   代码：

import time
T0=time.time()
li=[]
for i in range(10000000):
    li.append('sxt')
T1=time.time()
a=''.join(li)
T2=time.time()
print('列表创建时间：{}'.format(T1-T0))
print('join()合并时间：{}'.format(T2-T1))
print('程序运行总时间：{}'.format(T2-T0))

        执行结果：

列表创建时间：1.6939454078674316
join()合并时间：0.1049344539642334
程序运行总时间：1.798879861831665
>>>

1. join()使用环境导致的结果差异。在开发环境中jion()列表合并结果仍为列表，未实现字符串的连接，在解释器中可实现字符连接。为什么会出现这样的情况？

   开发环境中代码：

for i in range(3):
    li.append('sxt')
    print('循环内列表：{}'.format(li))
a=''.join(li)
print('最终列表：{}'.format(li))

        运行结果：

循环内列表：['sxt']
循环内列表：['sxt', 'sxt']
循环内列表：['sxt', 'sxt', 'sxt']
最终列表：['sxt', 'sxt', 'sxt']
>>> a=''.join(li)
>>> a
'sxtsxtsxt'
>>>

double a[3][2] = {{2,4},{5,2},{1,1}};
for(int i=0; i<3; i++){
  a[i][0] -= a[2][0];
  a[i][1] -= a[2][1];
}
double s = fabs(a[0][0]*a[1][1] - a[0][1]*a[1][0]) * 0.5;

a【3】【2】里面的3 ，2表示什么

a[i][0] -= a[2][0];
  a[i][1] -= a[2][1];

这个什么意思

老师，我有两个问题。pickle既然可以完成对对象的存储，那write也具有类似功能，那请问他们的区别是不是在于：write只能将字符串写入文档；而pickle能将任意对象进行有序组织，然后存入某文件中呢？ 2.这里读取数据时，等号右边都是pickle.load(f)，那么是按照什么顺序将对象返回给前面变量b1,b2,b3的呢？是不是和对象储存的时间顺序一样呢？这是不是一种典型的队列数据结构？谢谢老师，麻烦老师回答这么多问题了