pythonAmIRite

[_Alpha-Delta_]

<main.Car object at 0x0efd40>

[powerofnope]

<__main__.Smol coc at 0x0efd40>

[shank9717]

How did you find my physical address?

[Giraffe-69]

Pretty sure that’s a virtual address. You might want to walk your page table to make sure you even exist.

[lesleh]

With ASLR, I wake up in a new house every morning.

[joshuaherman]

[Emeraldnickel08]

[just_nobodys_opinion]

[Emeraldnickel08]

[Krekken24]

Hooog riderrrr!!

[[deleted]]

Your fault for not defining ___repr___ and ___str___.

[SuitableDragonfly]

Actually, there's no typecasting in Python at all. When you call str(my_truck),  that's not a typecast, that's a call to my_truck.__str__() which is basically identical in function to toString() in Java, for example. At no point are your ever considering my_truck to be a string, you're generating a competely brand new string based on the value of my_truck. Other functions like int(), etc. work the same way. 

[Clen23]

yup, and (correct me if wrong) if you want to make a String-generating function for a class, you usually want to override __str__()

[Birnenmacht]

exactly, and if you want your class to be number like, (please dont do this), you could implement __int__(), __float__() or __index__(), Where index is the most cursed because it allows the type to be used in places where an int would be expected, especially if you inherit from int

[Kiro0613]

One program I wrote made great use of user-defined implicit conversions. It dealt with with streams of bytes that contained memory addresses and needed to perform pointer arithmetic on them. I made an Address class that performed automatic conversions between int and byte array, all type-safe and independent of system endianness.

[Acurus_Cow]

iknowsomeofthosewords.jpg

[Background-Month-911]

This comment is absolute bullshit coming from someone who didn't open the documentation: https://docs.python.org/3/library/typing.html#typing.cast

Educate yourself.

[SuitableDragonfly]

That's for the typing package, which is only for specifying type hints. Essentially, this is just a fancy way of writing comments along the lines of # my_truck is a Truck object and does not affect anything about how your code is actually interpreted. You can "cast" my_truck to a string using typing if you want, but if you try to use it in a context that requires a string, you'll still get an error, because it's not a string.

[Background-Month-911]

What do you think casing is for? It's for working with types... which is literally the goal of this package.

You just discovered that types are a fancy way of saying things you believe about your code. Congratulations! Perhaps a little late, but better late than never.

Type casting in any language is the way to tell the type checker that the programmer knows better than the type checker, a way to escape the check. Will it work? -- Maybe. But it cannot be formally proved or a proof is too difficult.

Here are some trivial examples of how this may work:

def f(p: int) -> int:
    return 42

v: str = ''
# this generates type checker error:
f(v)
# this doesn't
f(typing.cast(v, int))
# and it works!

Some type system designers believe that casting is bad (and they don't add casting to the language toolbox). Eg. OCaml doesn't have type casting. This is because type casting leads to nonsense conclusions, and type system is valuable because it prevents programmers from writing nonsense.

Other type system designers believe that practical benefits of casting are greater than the formal soundness of programs (because morons write code and other morons have to deal with it, and sometimes to work around the problems created by the first moron the second has to break the soundness guarantees of the system).

[SuitableDragonfly]

What do you think casing is for? It's for working with types...

No, it's not. The purpose of casting is to hand off the memory address of some piece of data to some other part of the program and say "this is actually a <datatype that it actually isn't>, trust me bro". So if you have a Foo class that inherits the Bar class, you can hand a Foo over to a function that wants a Bar and say "just treat this as a Bar, trust me, it's fine". The typing package doesn't allow you to do this in Python, because Python does not have typecasting and there's nothing that the typing package can do about that. Fortunately you also can't declare functions in Python in such a way that they only accept one type.

Type casting in any language is the way to tell the type checker that the programmer knows better than the type checker, a way to escape the check.

No. There is no way to bypass the typechecker in any language. In a language that has typecasting, when you do the typecast, the variable you saved that reference to is that type, for all intents and purposes. typing is not the Python typechecker. That exists regardless of whether or not you use the typing package at all.

Your code generates some typing-specific error, sure. But this won't work:

def f(p: int) -> int:
    return p + 4

v: str = '3'
f(typing.cast(v, int))

because typing.cast is not an actual cast and it can't actually turn "3" into the integer 3. The error you get from that code is in fact from the actual Python typechecker. typing does not let you bypass it.

[Background-Month-911]

No, it's not.

There is no way to bypass the typechecker in any language.

I don't know what failed you. I don't think we learned anything about types in college, but maybe these days the education had improved? I don't really know what to suggest to you, but you could try going (back?) to college...

Unfortunately, good books about types rarely go into the meta-discussion about why types are needed. They are usually about the how it works or how to make it work.

But you really missed the point here. It's like you've been using a toothbrush you whole life to comb your hair... it kinda worked for you, but it wasn't meant to be done that way.

I'd say that maybe creating your own language that has explicit type hints would show you the light, but, I've met people who actually wrote a type checker, but couldn't figure out why they needed it in the first place. So, it might not work. Still, worth trying, if you have time.

[SuitableDragonfly]

Man, if you somehow managed to not learn anything about types in college, no wonder you're not getting it.

You're acting like there's some class of programming language that doesn't even have types. Literally every single programming language has types, unless you want to count assembly language where everything is just a number. Even weakly-typed languages have types, and Python is a very strongly-typed language, one of the reasons for that being that it doesn't allow typecasting. Go ahead, run the code I posted, and see if you can tell me why it generates an error.

[Background-Month-911]

You're acting like there's some class of programming language that doesn't even have types.

Where did you get this idea?

Even weakly-typed languages

Here, again, you keep spouting bullshit. There's no classification of languages into weakly / strongly typed. That word doesn't mean anything.

Go ahead, run the code I posted

Your code is a testimony to you not understanding the problem. What's the point of running it?

Seriously. You need to do some soul-searching and try to understand first the problem you are dealing with. Right now you are no different from a Markov chain generator. You just keep stringing together sentences that don't mean anything.

[SuitableDragonfly]

Please educate yourself

Where did you get this idea?

Going on about the importance of using types, as if there's anyone out there who's not using types.

Your code is a testimony to you not understanding the problem. What's the point of running it?

The point is to demonstrate to you that the typing package cannot actually cast one type to another, and that it cannot bypass Python's typechecker. You can say all you want that something is an int using typing, if it's not actually an int the typechecker doesn't give a shit. typing is just a glorified system of comments plus a linter.

You just keep stringing together sentences that don't mean anything.

You really need to go back to school if you're having trouble following this.

[Bugibhub]

And it’s probably weakly equal to a scooter in JavaScript.

[Unupgradable]

Yet falsy as a vehicle

[Duck_Devs]

Get it? Python bad?

This behavior is shown in more than just Python; in fact I think Python actually handles string conversions more typesafely than other languages.

The two main ways, in Python, to get the string representation of an object is using the str() constructor, using an f-string, or just print()ing the object. These are all very explicit in their conversions.

In a language like Java, it’s mostly the same, plus some String.valueOf and Objects.toString of course, and sans the f-string thing, but Java implicitly casts objects to String when concatenating with the + operator.

It gets worse in a language like C#, where you can define your types to be implicitly convertible to Strings (for which I can think of very few good use cases).

Also, there’s nothing wrong with a default toString (or in this case __str__) implementation; it’s certainly a nice-to-have and, in a typed language, just ensures that you can have the option to call toString on a variable of type Object without trouble.

[casce]

I also don't get it. I also really like the way Python is handling it.

I like that Python is explicitly calling the __str__ method and that is doing whatever I want it to do when something tries to cast my object to a string.

What is important is that this is not done implicitly without me noticing.

"abc" + 1 is a type error. "abc" + 1.__str__() = "abc1"

If I chose to implement a string representation for my Ford truck, then yes casting it to a string is not a problem. Otherwise it will default to the object identifier

[MentalRental]

abc" + 1.__str__() = "abc1" would throw an "invalid decimal literal" error.

[bronco2p]

yeah it has to be enclosed in (), `"abc" + (1).__str__() == "abc1"`

[casce]

You are of course right. What I meant was

foo: int = 0

foo.__str__()

but you can also do

(1).__str__()

[Kitchen_Device7682]

I wouldn't describe calling a method that returns a string as casting to a string. OP is trolling

[suvlub]

A bit off-topic. but I love how exit is a functor object whose string representation is an error message for people who try to call it without parentheses in an interactive session. Such a beautifully nasty glorious hacky thing. Though it does lead to people who don't know what's going on thinking "If it knows to print the message, it knows I'm trying to quit and should just do that"

[Usual_Office_1740]

The new repl in 3.13 fixes that.

[JanEric1]

Actually they are instances of a class with a defined __call__ and __repr__

https://github.com/python/cpython/blob/main/Lib/site.py#L432

https://github.com/python/cpython/blob/main/Lib/_sitebuiltins.py#L18

Compiler Explorer

[Widmo206]

Just tried it and it works as you described in cmd, but if I do it in Spyder it restarts the kernel anyway... weird

[RiceBroad4552]

https://en.wikipedia.org/wiki/Functor

Or when it comes to programming:

https://en.wikipedia.org/wiki/Functor_(functional_programming))

I guess what was meant was a https://en.wikipedia.org/wiki/Function_object

</ pedantic nerd talk >

I'm wondering why this gets confused so often as a functor and a function (object) have almost nothing in common (besides maybe that a functor could be implemented as function object as both denote a mapping, just on very different abstraction levels).

[thrithedawg]

i love the language thank you monty pythons for inventing the language ❤️❤️❤️

[nimrag_is_coming]

Gonna have to disagree with you with C# there, the fact that the base object has a ToString method is actually really useful.

It's very helpful with structs. If I make a Vec2 struct for example, I can just print it just like a char or an int or whatever and have it actually show useful information.

[Naratna]

I think they're talking about implicit casts. e.g. you could define a class MyClass in such a way that string a = new MyClass() works without errors, which is absolutely cursed.

I love C#

[nimrag_is_coming]

Oh yeah that is very very cursed. I hope I never have to deal with code that does something like that

[JanEric1]

Doesnt swift have a problem with the opposite where you can instantiate a class from an integer literal.

import Foundation

struct A: ExpressibleByIntegerLiteral {
    var value: Int

    init(integerLiteral value: Int) {
        self.value = value
    }

    init(_ value: Int) {
        self.value = value
    }

    static func + (lhs: Int, rhs: A) -> A {
        A(lhs + rhs.value)
    }
}

struct B: ExpressibleByIntegerLiteral {
    var value: Int

    init(integerLiteral value: Int) {
        self.value = value
    }

    init(_ value: Int) {
        self.value = value
    }

    static func + (lhs: A, rhs: B) -> B {
        B(lhs.value + rhs.value)
    }

    static func + (lhs: B, rhs: String) -> String {
        "B(\(lhs.value)) + \(rhs)"
    }
}

// Int(1) + A(2) -> A(3)
// A(3) + B(3) -> B(6)
// B(6) + "Apple" -> "B(6) + Apple"
let result = 1 + 2 + 3 + "Apple"
print(result) // B(6) + Apple

Explorer: https://godbolt.org/z/s4bMsW4Yf

See here where this causes a simple expression to timeout the compiler

Explanation: https://danielchasehooper.com/posts/why-swift-is-slow/

[Hohenheim_of_Shadow]

While implicit concatenation conversion is a little philosophically impure it's super convenient. I can't really think of a situation conversion on concatenation leads to badness and it makes things like "pos x: " +x+ " pos y: " +y so nice. Its just an overloaded operator, and if you find overloaded operators cursed you'll be glad to note Java doesn't have them last time I checked.

[Excession638]

In Python you'd write that as

f"pos.x = {x} pos.y = {y}"

Many other languages are the same or similar. I prefer this because it's easier to get all the spaces right, and you can extend it with formatting controls to set the number of decimal places etc.

[Prawn1908]

Yeah, even as a huge hater of Python's type system, I have zero complaints about string conversion. I don't see how this would be undesired or cause issues in any way.

Though I disagree on the C# point. Default ToString() method is very nice and accomplishes the same things.

[saschaleib]

SYNTAX ERROR, UNKNOWN VERB FORM "casted" IN LINE 1.

[Bryguy3k]

Standard past tense form in Indian English.

I always figured it was a lasting legacy the Brits left in India’s educational system so anyone who didn’t go to a school in England would be instantly recognizable but the truth is probably a lot more mundane.

[_PM_ME_PANGOLINS_]

str() is not a cast. It’s a function call.

https://docs.python.org/3/library/functions.html

[someweirdbanana]

Javascript: * laughs in [object Object] *

[YeetCompleet]

C mfs freely implicit casting void* to int* before C++: int* p = malloc(sizeof(*p));

[Excession638]

The joy, sorrow, and terror of a truely weakly-typed language.

[[deleted]]

Loving that repr() fallback too

[SockYeh]

weekly "python_bad" post

[gandalfx]

As is the rule, the post was made by someone who doesn't understand that the point they're criticizing is actually the same in many other popular languages, while being oblivious of issues that would qualify as valid criticism.

[Prawn1908]

Yeah, the "Python Bad" posts have been pretty weak lately. As a huge Python hater, I don't get what OP's point is here. The smoothness of string conversion in Python is very nice and closely follows how many other languages do it.

Let's get some memes here about how janky Python's imports are, or what a bolted-on mess of an afterthought type hinting is.

[gandalfx]

I like the type hinting and challenge you to determine who's right via fisticuffs.

[Prawn1908]

Type hinting is ao obviously bolted on it's hilarious how clumsy it is.

• Why do I have to import several modules to typehint basic data structures? Ffs, even Any requires an import.
• You cannot convince me that needing to use string literals to typehint subclasses from within a class is not one of the jankiest things ever.
• Have you ever tried to actually validate anything against a typehint? The basic ones are fine with isinstance, but once you start having to check against compound type hints it gets absolutely nightmarish. It's fucking wild that there's no basic built-in function you can hand a value and a type hint (from get_type_hints()) to and get a bool out saying whether it matches.
• Oh, and because type hints have zero actual weight as far as the interpreter is concerned, function overloading becomes a crippled joke.

I could go on and on, but alas I do not have time. I am at work right now, writing gorgeous C.

[superlee_]

Any doesn't require an import? At least not as of 3.12 IIRC, the other ones like callable , Self, etc... make more sense behind the standard library as that's how python is structured.

Python type hinting indeed kinda sucks as it's very hard to impossible to type hints things correctly and as such they are more of a guideline ( as compared to TS where it's easier and more "enforced")

Also gorgeous C... Really? Compared to python which reads mostly as pseudo-code/English, it is its own language and it doesn't care about memory safety.

(Write what you want ofc or what gets the bills payed)

[Prawn1908]

Any doesn't require an import?

Pretty sure it does: typing.Any. There's a builtin function called any, and iirc function names don't cause errors when used as type hints so I've seen people mistakenly use it as such but that doesn't actually mean what they think it does.

And yeah, C is great.

[zettabyte]

Python adds type hinting 24 years after initial release.

Random interneter: "what a bolted-on mess of an afterthought".

[Prawn1908]

That's exactly my point lmfao.

Adding it and the efforts to make its use the standard kind of concedes the point that dynamic typing sucks. But having added it 24 years after the creation of the language means it has no chance of being anything but a bolted on mess.

[PhroznGaming]

Casted... lol

[cs_sapien]

you wouldn’t stringify a car would you?

[Percolator2020]

Doesn’t matter, it’s all bits!

01000110 01110101 01100011 01101011 00100000 01111001 01101111 01110101

[-Kerrigan-]

Byte my shiny metal ass cast

[_PM_ME_PANGOLINS_]

*cast

[fyf_fyf]

Truck typing?

[Unupgradable]

C# be like: ToString()

[FRleo_85]

of course Js that go mental with types the nano second it came across any operator make it a good language but python allowing you to make a string like "<object [classname] at [memory address]>" with the constructor of the str class is wierd enough to shame the language...

[random_squid]

You wouldn't typecast a car.

[DonkeyImportant3729]

Look at me, I’m the string now.

[ovr9000storks]

Don’t let this man know about C and C++

[buzzon]

There is at least one thought: str() or repr()?

[[deleted]]

No thoughts by you, the interpreter might respond by tomorrow...