主页 / 问题

全部问题

Martin Hope
Dousman
Asked: 2023-10-09 13:51:28 +0000 UTC
  • 8

我研究循环while并执行下一个任务。

我有一定数量的糖果，我会慢慢吃掉并在屏幕上报告。
糖果一吃完，我就问自己：“我应该买更多的糖果吗？”
如果我还想吃甜的，我也会再买一些糖；如果我加了0，就意味着我已经吃饱了，退出这个循环。

无法回到循环的开头：

x_bullets = 11
end_bullets = 1 

while x_bullets > end_bullets:
    x_bullets -= 1
    print(x_bullets)

    if x_bullets == end_bullets:
        print("Recharge")
        ammo_recharge = int(input())

        if ammo_recharge >= 1:
          continue
        else:
          print("You are out of ammo!")
          break
python
Martin Hope
Master's Time
Asked: 2023-10-01 17:58:49 +0000 UTC
  • 8

我正在为一项工作编写算法，遇到一个问题：如何一次从数组中删除多个元素？例如，有这样的代码：

a = [1,2,3,4,5]
b = [1,3,5]
a.remove(*b)

这段代码不起作用（它给出了一个错误，.remove()它应该只获取一个元素）。

还有这样的代码：

a = [1,2,3,4,5]
b = [1,3,5]
for i in b:
    a.remove(i)

但这段代码的问题是速度很慢（并且a、 和b有超过 1000 个元素）。

有没有算法（或团队）可以解决这样的问题？

python
Martin Hope
teran
Asked: 2023-09-30 00:34:12 +0000 UTC
  • 8

同志们，出现了一个有趣的问题，也许有人能告诉我答案。

背景：有一个大小合适的表，大部分数据被一个 JSON 列占据。我需要以某种方式收紧空间，所以我正在做一些“研究”。

在本地扩展了约 130 万行的表片段。我们有如下表结构（InnoDB,row_format=DYNAMIC）：

a BIGINT,
b BIGINT,
c TINYINT,
d JSON NULL,
PRIMARY KEY (a,b,c)

这会占用5.8 GB磁盘空间（所有 JSON 字段均非空）。

  • 如果我们加起来，JSON_STORAGE_SIZE(d)我们得到~3.5GB。
  • 我们还可以假设所需的容量约为a,b,c = (8+8+1)*1300000/1024/1024 20MB

“理论”和实际大小之间2GB 的差异看起来还不错。

为了实验我做了两个表：

  • (a,b,c)没有 json 列的同一张表。大小48MB
  • (i,d)，其中 i - INT AUTO_INCREMENT（即将密钥简化为整数） - 大小4.8 GB。

这里，这两个表的总大小比原始表小1 GB（尽管实际上INT向数据中添加了一列）。

谁能解释一下造成这种体积差异的原因是什么？

PS：如果你有兴趣，它row_format=compressed比原来的 5.8 -> 2.4

PS2：仅创建表。即数据已创建并上传。没有进行任何删除/更新

我有一种感觉，答案将包括有关集群、页面等的内容。但在物理存储机制方面不强。

mysql
Martin Hope
Dice
Asked: 2023-09-28 05:53:19 +0000 UTC
  • 8

有两种代码变体，其中秒表以不同的方式测量经过的时间。我不明白为什么。这是代码 -

1.第一个例子（在AsyncAction方法中，同步部分在前，然后是异步部分）-

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

namespace DifferentTasks
{
    public class SyncAndAsyncPartsOfMethod
    {
        public async Task Execute()
        {
            IEnumerable<int> data = Enumerable.Range(0, 100);

            Stopwatch stopwatch = Stopwatch.StartNew();

            Task t = Task.WhenAll(data.Select(AsyncAction));
            await t;
            stopwatch.Stop();

            double elapsedSeconds = TimeSpan.FromMilliseconds(stopwatch.ElapsedMilliseconds).TotalSeconds;

            Console.WriteLine("Elapsed seconds overall - " + elapsedSeconds);
        }
        
        private async Task AsyncAction(int x)
        {
            Stopwatch stopwatch = Stopwatch.StartNew();
            
            Thread.Sleep(TimeSpan.FromSeconds(1));
            await Task.Delay(TimeSpan.FromSeconds(1)); 
            
            stopwatch.Stop();
                
            double elapsedSeconds = TimeSpan.FromMilliseconds(stopwatch.ElapsedMilliseconds).TotalSeconds;
                
            Console.WriteLine($"AsyncAction {x} is finished, elapsed seconds - {elapsedSeconds}, thread - {Thread.CurrentThread.ManagedThreadId}");
        }
    }
}

结论：总经过秒数 - 102 秒

AsyncAction 方法中的秒表显示该方法每次运行正好两秒：

AsyncAction 95 is finished, elapsed seconds - 2,046, thread - 5
AsyncAction 96 is finished, elapsed seconds - 2,032, thread - 4
AsyncAction 97 is finished, elapsed seconds - 2,015, thread - 4
AsyncAction 98 is finished, elapsed seconds - 2,029, thread - 4
AsyncAction 99 is finished, elapsed seconds - 2,046, thread - 5

2.第二个例子（在AsyncAction方法中，异步部分在前，然后是同步部分）-

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

namespace DifferentTasks
{
    public class SyncAndAsyncPartsOfMethod
    {
        public async Task Execute()
        {
            IEnumerable<int> data = Enumerable.Range(0, 100);

            Stopwatch stopwatch = Stopwatch.StartNew();

            Task t = Task.WhenAll(data.Select(AsyncAction));
            await t;
            stopwatch.Stop();

            double elapsedSeconds = TimeSpan.FromMilliseconds(stopwatch.ElapsedMilliseconds).TotalSeconds;

            Console.WriteLine("Elapsed seconds overall - " + elapsedSeconds);
        }
        
        private async Task AsyncAction(int x)
        {
            Stopwatch stopwatch = Stopwatch.StartNew();
            
            await Task.Delay(TimeSpan.FromSeconds(1)); 
            Thread.Sleep(TimeSpan.FromSeconds(1));
            
            stopwatch.Stop();
                
            double elapsedSeconds = TimeSpan.FromMilliseconds(stopwatch.ElapsedMilliseconds).TotalSeconds;
                
            Console.WriteLine($"AsyncAction {x} is finished, elapsed seconds - {elapsedSeconds}, thread - {Thread.CurrentThread.ManagedThreadId}");
        }
    }
}

结论：总经过秒数 - 13 秒

AsyncAction 方法中的秒表现在显示 AsyncAction 方法每次执行所需的时间更长 -

AsyncAction 92 is finished, elapsed seconds - 3,066, thread - 6
AsyncAction 89 is finished, elapsed seconds - 4,035, thread - 8
AsyncAction 87 is finished, elapsed seconds - 4,082, thread - 6
AsyncAction 85 is finished, elapsed seconds - 4,082, thread - 5
AsyncAction 83 is finished, elapsed seconds - 5,051, thread - 8
AsyncAction 81 is finished, elapsed seconds - 5,067, thread - 4

启动这些课程的代码 -

using System;
using System.Runtime.InteropServices;

namespace DifferentTasks
{
    internal class Program
    {
        public static void Main(string[] args)
        {
            SyncAndAsyncPartsOfMethod syncAndAsyncPartsOfMethod = new();
            syncAndAsyncPartsOfMethod.Execute().Wait();
            Console.ReadLine();
        }
    }
}

我想了解为什么 -

  1. 根据是先执行异步部分还是先执行同步部分，总运行时间会有所不同
  2. 为什么先执行异步部分，方法的执行时间每次都会增加。
c#
Martin Hope
Глеб
Asked: 2023-09-21 18:53:44 +0000 UTC
  • 8

通常，当我需要打开一个文件并读取其中的所有行时，我会编写如下内容：

f = open('data.txt')
data = f.readlines()

然而，有一个建议说最好使用上下文管理器来做到这一点：

with open('data.txt') as f:
    data = f.readlines()

问题：这两个片段有何不同？为什么第二个比第一个更好？

python
上一页
下一页