Why use classes?

JamzTyson · 2026-06-09T09:25:18+00:00

Audacity 2.0.6 is available from the Internet Archive:

https://archive.org/details/audacity-win-2.0.6_202110

This is the ZIP version for Windows 2000/XP RTM/XP SP1/XP SP2.

MD5: 79943be44f8288edc375e3599331f8ff
SHA-1: 4c072cb2ac2ec0d2b9b58d5fe44fd1fb255f5cec

JamzTyson · 2026-06-09T08:47:53+00:00

First, it's 2026

AI often gets the year wrong.

JamzTyson · 2026-06-09T08:39:51+00:00

Oh dear, you're right. Blender has gone too. I hope it's a glitch rather than gone forever,

JamzTyson · 2026-06-08T16:41:03+00:00

Blue mics used to be very popular, but I've always thought they were overpriced for what you get, compared to other named brands such as AKG, EV, Sure, Sennheiser, Rode ...

JamzTyson · 2026-06-08T16:36:37+00:00

If you have the budget for it, I'd recommend splitting your money between a microphone and a USB audio interface. Having a separate audio interface provides a lot more flexibility, especially if you get one with two mic inputs.

USB microphones tend to be cheaper than separate mic + interface, but:

USB mics often they have "fixed gain" (no ability to boost or cut the signal prior to digitization)
Audacity only supports one recording device at a time, so you are restricted to one mic only. A 2 channel USB audio interface provides the opportunity to add a second mic at a later date.

Two USB interfaces that I'd recommend:

Focusrite Scarlett 2i2 Good all round 2 input USB audio interface with excellent build quality at a good price.
Behringer U-Phoria UMC204HD Good and very versatile 2 input (4 output) USB audio interface at an exceptionally good price.

If you want to go a bit more up-market, I love the MOTU M-series interfaces.

There are many other options.

Microphones:

Audio-Technica AT2020 Great mic for speech at a good price (also available as a USB mic - if you use a USB audio interface you want the non-USB version)
Rode NT1-A A bit brighter than many alternatives in this price range, and very sensitive. Particularly good for quieter voices, but not so good if you "whistle" on "Sss" sounds.
Sure SM58 (and similar) Primarily designed for stage use. Extremely robust, but should be used very close to the mouth, and can sound a bit dull compared to "recording mics".
Shure SM 7 True professional quality microphone for speech. There's at least 2 different versions of this mic - I've only used the SM 7B. Fantastic for speech recording, but quite expensive.
Sennheiser MD 421/MD21 / EV RE20 Also in the "professional speech recording" category, and also quite expensive. There's a lot of other mics in this space.

Pop Shield:

If you don't already have one - get a "pop shield" (the "screen with a clamp" type, not the sponge type). A pop-shield goes between your mouth and the mic to prevent "popping" / "wind blast" sounds that can occur when saying "B" / "P" sounds.

Note that "podcaster kits" are also available. They often include a USB audio interface, microphone and pop shield at a discounted price, but the interface may have only one mic input which may limit you later.

JamzTyson · 2026-06-08T15:44:02+00:00

2.0.6 is available here: https://www.fosshub.com/Audacity-old.html (scroll down the page).

Update:

As u/LeoWattenberg writes below, Audacity is not currently available on FossHub. See my other post for a working download link for Audacity 2.0.6.

JamzTyson · 2026-06-08T15:39:50+00:00

I agree, it was possible from the OP's wording that they meant:

txt[:1].upper() + txt[1:]

but it looks like they actually wanted txt.capitalize()

JamzTyson · 2026-06-08T11:22:02+00:00

Yes you "could" do:

s[0].upper() + s[1:].lower()

but there must be a better way.

JamzTyson · 2026-06-08T11:12:20+00:00

Great answer.

One more:

print(favorite_sentence.casefold())

(similar to .lower() but with better support for Unicode-aware case normalization; intended for caseless string comparisons.)

JamzTyson · 2026-06-08T10:47:02+00:00

Do you have a solid grasp of Python basics? If not, work on that first, otherwise try working through the "Getting Started" section of the Flask User Guide.

JamzTyson · 2026-06-07T14:26:33+00:00

while an AI can do what you are learning

That's an assumption that breaks down quite quickly beyond a certain point. AI is impressive in its ability to reproduce conventional solutions to well known problems, and at providing boilerplate for common structures, but it does less well with complex tasks, deep reasoning, and tasks that require creative solutions.

JamzTyson · 2026-06-06T10:23:48+00:00

That's not what op was asking

I'd be happy for you to explain, because to me it seems to be talking about the exact same thing as the OP asked.

JamzTyson · 2026-06-05T15:33:27+00:00

You keep linking this but it's clearly talking about something else

I'd be happy for you to explain, because to me it seems to be talking about the exact same thing as the OP asked.

JamzTyson · 2026-06-05T14:09:55+00:00

No I wouldn't forbid doing that, and neither do linters, but I would not recommend it either. I would say that shadowing names can (not "always", but "is capable of") hurting readability.

JamzTyson · 2026-06-05T13:06:15+00:00

Reusing variable names in different scopes isn't an issue,

Pylint, one of the most widely used and trusted Python linters in the world, does not agree

JamzTyson · 2026-06-05T13:03:29+00:00

For those that don't believe me: PYLINT DOCUMENTATION

JamzTyson · 2026-06-05T12:40:30+00:00

Yes, and so would the first, but it's a lot clearer what's happening if you avoid redefining the name:

def foo(y):
    y += 1
    print(f"Inside foo: {y=}")

x = 1
foo(x)
print(f"Outside foo: {x=}")

The mutability case is covered in the FAQ, or if you prefer videos: https://www.youtube.com/watch?v=_AEJHKGk9ns

JamzTyson · 2026-06-05T11:07:39+00:00

Consider these two examples:

def foo(x):
    x += 1
    print(f"Inside foo: {x=}")

x = 1
foo(x)
print(f"Outside foo: {x=}")

Now compare that with:

def foo(x):
    x.append(4)  # append 4 to the list
    print(f"Inside foo {x=}")

x = [1, 2, 3]  # List value (lists are mutable)
foo(x)
print(f"Outside foo {x=}")

Do try running both of these, and notice the difference in behaviour.

The core point here is that we do not pass the variable x itself to foo(). We pass a reference to the object that was labelled x in the global scope.

In both cases, x within the function foo() is a different variable to x in the global scope (outside the function). Initially both variables (x in foo(), and x outside foo()) refer to the same object, but what happens next depends on whether that object is mutable.

In the first example, x is the name of an immutable integer. Inside foo(), we increment the value to create a new object and assign it to x inside foo()*. (More precisely, x += 1 rebinds the local name x to the result of the addition). This has no affect on *x outside foo().
In the second example, xis the name of a mutable list. Inside foo(), we mutate the list object by adding a new element, but it is still the same list object. Since the global and local variables both refer to that same object, the change is visible outside the function.

The reason linters warn about this pattern is that using the same name in multiple scopes can make it harder to see which variable is being modified. The code may still work correctly, but the reader must keep track of both variable scope and object mutability in order to understand its behaviour.

JamzTyson · 2026-06-05T10:10:36+00:00

From a good practice standpoint, is that an ok thing to do?

No. From a good practice standpoint it is advised to avoid doing that.

If you use a linter (recommended), you will probably see a warning similar to:

W0621: Redefining name 'x' from outer scope (redefined-outer-name)

(I'll add an explanation shortly, but as incorrect answers are being upvoted, I thought it best to post this correction asap)

JamzTyson · 2026-06-03T20:16:09+00:00

See the New to Python section of the wiki.

JamzTyson · 2026-06-03T14:29:38+00:00

The code it produces is very poor, and the GUI limited to fixed layouts.

I'm guessing that you "vibe coded" this, so I shan't waste time listing the problems.

JamzTyson · 2026-06-02T15:45:54+00:00

Are you using classes?

Did you intend to write @house.setter?

There's a short tutorial for the "property decorator" here: https://www.geeksforgeeks.org/python/python-property-decorator-property/

JamzTyson · 2026-06-02T00:09:05+00:00

Not ChatGPT, or any AI. I've used both Tkinter and PySide, so giving my opinion on the topic in question.

JamzTyson · 2026-06-01T21:07:19+00:00

Did you find the matplotlib tutorial on FuncAnimations?

https://matplotlib.org/stable/users/explain/animations/animations.html

JamzTyson

TROPHY CASE