小编Jey*_*mon的帖子

a我尝试用b给定的大字符串替换字符。我做了一个实验 - 首先我在整个字符串中替换它，然后我只在它的开头替换它。

import re
# pattern = re.compile('a')
pattern = re.compile('^a')
string = 'x' * 100000

pattern.sub('b', string)

我预计替换开头要比替换整个字符串快得多，因为您只需检查 1 个位置而不是 100000 个位置。我做了一些测量：

python -m timeit --setup "import re; p=re.compile('a'); string='x'*100000" "p.sub('b', string)"
10000 loops, best of 3: 19.1 usec per loop

python -m timeit --setup "import re; p=re.compile('^a'); string='x'*100000" "p.sub('b', string)"
1000 loops, best of 3: 613 usec per loop

结果表明，相反，尝试替换整个字符串大约快 30 倍。你会期待这样的结果吗？你能解释一下吗？

我创建了一个非常基本的脚本，定期将一些数据写入数据库：

测试.py

import sqlite3
import sys
import time

DB_CREATE_TABLE = 'CREATE TABLE IF NOT EXISTS items (item TEXT)'
DB_INSERT = 'INSERT INTO items VALUES (?)'
FILENAME = 'test.db'


def main():
    index = int()
    c = sqlite3.connect(FILENAME)
    c.execute(DB_CREATE_TABLE)
    c.commit()

    while True:
        item = '{name}_{index}'.format(name=sys.argv[1], index=index)
        c.execute(DB_INSERT, (item,))
        c.commit()
        time.sleep(1)
        index += 1

    c.close()


if __name__ == '__main__':
    main()

现在我可以通过多次运行脚本来实现简单的并发：

python3 test.py foo &
python3 test.py bar &

我尝试阅读一些有关脚本同时写入同一数据库文件的文章，但我仍然不确定我的脚本将如何处理此类事件，并且我不知道如何测试它。

我的期望是，在不太可能发生的情况下，当我的脚本的两个实例尝试在同一毫秒内写入数据库时​​，后一个实例将只是默默地等待，直到前一个实例完成其工作。

我当前的实施是否满足我的期望？如果没有，发生此类事件时它会如何表现以及如何修复？

从我的角度来看，可以（至少）有两种方法来为变量、函数、类等创建名称。

1. 结构化的：

   history_clear()
   history_save_to_file()
   cache_remove_entry()
   cache_find()
   browser_window_url_trim()
   

   Run Code Online (Sandbox Code Playgroud)

2. 人类可读：

   clear_history()
   save_history_to_file()
   remove_entry_from_cache()
   find_in_cache()
   check_for_updates()
   

   Run Code Online (Sandbox Code Playgroud)

首选词序是什么？有没有？我对编程很陌生，但我想从一开始就养成良好的编码习惯。我已经简要阅读了PEP 8风格指南，但我没有在那里找到答案。

这基本上是我第一次尝试理解C#中的类.我在互联网上经历了几个教程,但是我最缺少的东西和我还没有找到的东西,是一个简单的好例子.

我知道我的基本程序应该是什么样子,我将非常感谢你的帮助:

using System;

namespace Introduction_to_classes
{
    class Person
    {
        int Age;
        string Name;

        int DateOfBirth()
        {
            return 2013 - Age;
        }
    }

    class Program
    {
        public static void Main()
        {
            Person Mother = new Person(35, Alice);
            Person Son = new Person(12, Johny);

            Mother.Name = "Lucy";  // Just changing the value afterwards

            if(Mother.Age > Son.Age)
            {
                int year = Mother.DateOfBirth();
                Console.WriteLine("Mom was born in {0}.", year);
            }

            Console.ReadLine();
        }
    }
}

这只是一个想法,它绝对不起作用.但最重要的是,如果你能够将其改正为工作实例,它将对我有所帮助......

我是程序员初学者,但我想更深入地了解这些事情.我做了一些研究并阅读了很多文字,但我还没有理解一些东西......

编码基本内容时(在C中):

int myNumber;
myNumber = 3;
printf("Here's my number: %d", myNumber);

我发现(主要在32位CPU上)整数取代32位= 4个字节.所以在我的代码的第一行CPU进入内存.存储器是字节可寻址的,因此CPU为我的变量选择4个连续字节,并将地址存储到第一个(或最后一个)字节.

在我的代码的第二行,CPU使用他存储的MyNumber变量地址,转到内存中的那个地址,找到32位的保留空间.他现在的任务是在那里存储数字"3",所以他用序列00000000-00000000-00000000-00000011填充这四个字节.在第三行它执行相同的操作 - CPU转到内存中的该地址并加载存储在该地址中的数字.

(第一个问题 - 我明白了吗？)

我不明白的是:
32位CPU中该地址(指向该变量的指针)的大小为4字节.(这就是为什么32位CPU可以使用最大4GB的内存 - 因为只有2 ^ 32个不同的二进制长度32的地址)
现在,CPU存储这些地址的地方？他有自己的内存或缓存存储吗？而为什么它存储了32位长的地址为32位长整型？简单地在其缓存中存储实际数字而不是指向大小相同时的指针是不是更好？

最后一个 - 如果它存储在自己的缓存中的某个地方,那些整数和长度的地址是相同的(4个字节),它将需要与实际变量存储地址完全相同的空间.但变量最多可占用4GB的空间,因此CPU必须有4GB的空间来存储这些变量的地址.这听起来很奇怪..

谢谢你的帮助!
我试图理解这一点,但它太难了......: - [

首先，让我们生成一个压缩tar档案：

from io import BytesIO
from tarfile import TarInfo
import tarfile

with tarfile.open('foo.tgz', mode='w:gz') as archive:
    for file_name in range(1000):
        file_info = TarInfo(str(file_name))
        file_info.size = 100_000
        archive.addfile(file_info, fileobj=BytesIO(b'a' * 100_000))

现在，如果我按自然顺序读取存档内容：

import tarfile

with tarfile.open('foo.tgz') as archive:
    for file_name in archive.getnames():
        archive.extractfile(file_name).read()

并使用命令测量执行时间，我在 PC 上time得到的执行时间不到1 秒：

real    0m0.591s
user    0m0.560s
sys     0m0.011s

但是如果我以相反的顺序读取存档内容：

real    0m0.591s
user    0m0.560s
sys     0m0.011s

现在执行时间约为120 秒：

real    2m3.050s
user    2m0.910s
sys     0m0.059s

这是为什么？我的代码中有什么错误吗？或者是某些tar人的特点？它记录在某处吗？

当你执行这段代码时：

from typing import Dict

bar: Dict[int, int, int] = dict()

引发TypeError带有消息的异常。Too many parameters for typing.Dict; actual 3, expected 2但是当您在函数内定义变量时：

from typing import Dict

def foo():
    bar: Dict[int, int, int] = dict()

foo()

这次没有例外。这是预期行为还是错误？