This project is used as a preview, not yet used for production workflow. Integrations efforts are ongoing as well as figuring out the funding.

Please refer to https://devguide.python.org/documentation/translating/ for guidance about the translations.

This project is in a trial period, be cautious while contributing. Setup can still change before being approved as a libre project.

Translation status

51 Strings 11%
Browse Translate
1,794 Words 1%
10,895 Characters 1%

Strings status

Strings Words Characters
51 1,794 10,895
All strings Browse Translate Zen
6 23 177
Translated strings Browse Translate Zen
45 1,771 10,718
Unfinished strings Browse Translate Zen
45 1,771 10,718
Untranslated strings Browse Translate Zen
45 1,771 10,718
Unfinished strings without suggestions Browse Translate Zen

Overview

Project website docs.python.org
Instructions for translators

See devguide.python.org/documentation/translating.
Project maintainers User avatar rafaelff User avatar josix User avatar m-aciek
Translation license Creative Commons Zero v1.0 Universal
Translation process
  • Translations can be made directly.
  • Translation suggestions can be made.
  • Any authenticated user can contribute.
  • The translation uses bilingual files.
Source code repository git@github.com:m-aciek/python-docs-weblate.git
Repository branch main
Last remote commit [3.12] gh-126259: Fix "unclosed database" warning in sqlite3 doctest (GH-126260) (#126266) dc52670
github-actions[bot] authored 2 hours ago
Last commit in Weblate [3.12] gh-126259: Fix "unclosed database" warning in sqlite3 doctest (GH-126260) (#126266) dc52670
github-actions[bot] authored 2 hours ago
Weblate repository https://hosted.weblate.org/git/python-docs/latest/bugs/
File mask */latest/library/heapq.po
Translation file Download pt-br/latest/library/heapq.po
Last change Nov. 11, 2023, 11:41 p.m.
Last change made by None
Language Portuguese (Brazil)
Language code pt_BR
Text direction Left to right
Number of speakers 192,661,560
Number of plurals 3
Plural type Unknown
Plurals Singular 0, 1
Plural 1000000, 2000000
Plural form 2 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, …
Plural formula (n == 0 || n == 1) ? 0 : n != 0 && n % 1000000 == 0 ? 1 : 2
a month ago

String statistics

Strings percent Hosted strings Words percent Hosted words Characters percent Hosted characters
Total 51 1,794 10,895
Translated 11% 6 1% 23 1% 177
Needs editing 0% 0 0% 0 0% 0
Read-only 0% 0 0% 0 0% 0
Failing checks 0% 0 0% 0 0% 0
Strings with suggestions 0% 0 0% 0 0% 0
Untranslated strings 88% 45 98% 1,771 98% 10,718
Last 12 months Previous

Activity in last 12 months

0 changes 53 changes 0 changes 0 changes 0 changes 0 changes 0 changes 0 changes 0 changes 0 changes 0 changes 0 changes 0 changes 0 changes 0 changes 0 changes 0 changes 0 changes 0 changes 0 changes 0 changes 0 changes 0 changes 0 changes
Nov Dec Jan Feb Mar Apr May Jun Jul Aug Sep Oct

Quick numbers

1,794
Hosted words
51
Hosted strings
11%
Translated
0
Contributors
and previous 30 days

Trends of last 30 days

—
Hosted words
+100%
—
Hosted strings
+100%
—
Translated
+11%
—
Contributors
—
User avatar None

Resource updated
Parsing of the “pt-br/latest/library/heapq.po” file was enforced. 11 months ago
User avatar None

Resource updated
File “pt-br/latest/library/heapq.po” was added. 11 months ago
User avatar None

String updated in the repository
The disk balancing algorithms which are current, nowadays, are more annoying than clever, and this is a consequence of the seeking capabilities of the disks. On devices which cannot seek, like big tape drives, the story was quite different, and one had to be very clever to ensure (far in advance) that each tape movement will be the most effective possible (that is, will best participate at "progressing" the merge). Some tapes were even able to read backwards, and this was also used to avoid the rewinding time. Believe me, real good tape sorts were quite spectacular to watch! From all times, sorting has always been a Great Art! :-)
 
11 months ago
User avatar None

String updated in the repository
Footnotes
Notas de rodapé
11 months ago
User avatar None

String updated in the repository
In a word, heaps are useful memory structures to know. I use them in a few applications, and I think it is good to keep a 'heap' module around. :-)
 
11 months ago
User avatar None

String updated in the repository
Moreover, if you output the 0'th item on disk and get an input which may not fit in the current tournament (because the value "wins" over the last output value), it cannot fit in the heap, so the size of the heap decreases. The freed memory could be cleverly reused immediately for progressively building a second heap, which grows at exactly the same rate the first heap is melting. When the first heap completely vanishes, you switch heaps and start a new run. Clever and quite effective!
 
11 months ago
User avatar None

String updated in the repository
Heaps are also very useful in big disk sorts. You most probably all know that a big sort implies producing "runs" (which are pre-sorted sequences, whose size is usually related to the amount of CPU memory), followed by a merging passes for these runs, which merging is often very cleverly organised [#]_. It is very important that the initial sort produces the longest runs possible. Tournaments are a good way to achieve that. If, using all the memory available to hold a tournament, you replace and percolate items that happen to fit the current run, you'll produce runs which are twice the size of the memory for random input, and much better for input fuzzily ordered.
 
11 months ago
User avatar None

String updated in the repository
Various structures for implementing schedulers have been extensively studied, and heaps are good for this, as they are reasonably speedy, the speed is almost constant, and the worst case is not much different than the average case. However, there are other representations which are more efficient overall, yet the worst cases might be terrible.
 
11 months ago
User avatar None

String updated in the repository
A nice feature of this sort is that you can efficiently insert new items while the sort is going on, provided that the inserted items are not "better" than the last 0'th element you extracted. This is especially useful in simulation contexts, where the tree holds all incoming events, and the "win" condition means the smallest scheduled time. When an event schedules other events for execution, they are scheduled into the future, so they can easily go into the heap. So, a heap is a good structure for implementing schedulers (this is what I used for my MIDI sequencer :-).
 
11 months ago
User avatar None

String updated in the repository
If this heap invariant is protected at all time, index 0 is clearly the overall winner. The simplest algorithmic way to remove it and find the "next" winner is to move some loser (let's say cell 30 in the diagram above) into the 0 position, and then percolate this new 0 down the tree, exchanging values, until the invariant is re-established. This is clearly logarithmic on the total number of items in the tree. By iterating over all items, you get an O(n log n) sort.
 
11 months ago
Browse all translation changes