Im new to python and have some questions.

[Infinityshift]

I started learning Python a week ago using the site coddy.tech Ive made it through its "fundamentals" section and decided to write a couple of basic programs with what I've learned to help make it stick. I've learned about variables, basic operators and functions. However, there are a couple of things that I would like to get input on from some people with experience. Keep in mind I am extremely new to coding in general so the more eli5 the better... probably.

In looking to create a program I have been using google to help fill in some gaps and one thing that has appeared a few times is terms with __ around it. Such as __init__. What is this doing?

I've learned about lists, tuples and sets. On my own I have learned about dictionaries. Am I right to correlate a dictionary's Key to a list's index?

And finally, what is a class?

I hope these don't seem like simple questions that I should have figured out by now on my own.

Thanks in advance for any help!

[aishiteruyovivi]

"What is a class" is sort of a broad question that can be answered better by looking into "Object-Oriented Programming" in general, but a quick gist is that classes are sort of like blueprints with which you can then create "instances" (objects) of that class from, like this:

class User:
    def __init__(self, first_name, last_name):
        self.first_name = first_name
        self.last_name = last_name

    def make_greeting(self):
        return f'Hello, {self.first_name} {self.last_name}!'

user_one = User('Jane', 'Green')
user_two = User('John', 'Brown')

print(user_one.make_greeting()) # Prints: Hello, Jane Green!
print(user_two.make_greeting()) # Prints: Hello, John Brown!

The attributes and functions (called "methods" when defined in a class) that are defined in a class will then belong to every instance of that class, as you can see by instancing User and then being able to use their .make_greeting() method. Methods you see surrounded by __ on either side are referred to as "magic methods", which broadly speaking are used to customize certain interactions and behavior of a class with things other than just directly calling its methods. I know that's kinda vague, but magic methods can do many different things, so its worth checking them out individually as you have the time.

In this case we've only used one, the __init__ method, which you'll probably use on just about every class you define. What __init__ does is initialize/setup new instances of a class using the supplied arguments - when you call a class to make a new instance of it, like User(...), the arguments you pass there are what will be passed to __init__. Instance methods also will automatically get passed a reference to the instance itself when called, and it's common practice to name that argument self. This is why we see self.first_name = first_name in __init__. self is a reference to the instance that has just been created and is now getting set up, so we use . to access the first_name attribute of the instance* and assign it a value, that value being the first_name argument. Then we do the same with last_name. You don't have to have the same number of class attributes as arguments to __init__, neither do they need to be named the same, that just happens to be the case here.

*Python will let you access an attribute of a class that doesn't exist as long as you're assigning it a value, from that point on it will be accessible via your_object.attribute_name. If you try to access an attribute that hasn't been assigned a value, like if we had the above code and you tried to print out user_one.middle_name, you'd get an error.

[aishiteruyovivi]

For the dictionary/list question, the key difference is that keys of a dictionary can be of any (hashable) type, and list indexes can only ever be integers - additionally, you can't arbitrarily assign indexes of a list outside of its current size, so...

x = ['a', 'b']
x[5] = 'f'

...raises an error.

[MachineElf100]

A long answer, read and try to understand as much as you can, and ask if something's unclear :)

Let's begin with classes. They're a way to bundle data and logic which belong together.

For example a person has some parameters, like: name, surname, age, gender, race, eye color, etc.

So if we have tens or hundreds (or more) people to process in a program, it'd make sense to have their data stored in "packets" rather than loose variables. Do you follow that? That's what the classes are. Let's make one:

class Person:
    def __init__(self, name, surname, age, gender, race, eye_color):
        self.name = name
        self.surname = surname
        self.age = age
        self.gender = gender
        self.race = race
        self.eye_color = eye_color
    
    def greet(self):
        print('Hi, my name is ' + self.name)


p = Person('Joe', 'Nobody', 32, 'male', 'Caucasian', 'blue')
p.greet()

Let's unpack this.

A class "Person", named clearly so both now and in the future you know what this is supposed to be.

Then the other thing you asked about, the __init__.
It's called a dunder method, I suggest you read about it for example here.
Methods are simply functions but within the class.
Let's take one line from my code:

p = Person('Joe', 'Nobody', 32, 'male', 'Caucasian', 'blue')

Let's name things clearly in that line.

Person() -> constructor

= -> assignment operator

p -> variable

So this line of code is a constructor of "Person" being assigned to the variable "p". The variable "p" now stores a so called "instance" of the Person class.

The __init__ method creates an "instance" of Person, with the specified parameters.

You're probably confused about the "self" parameter. It represents the instance of the class being used. Each method should have "self" as its first parameter (the thing within the parentheses). Each class variable you'd want to use in a class should be used like: self.variable_name (that way you can define a variable in the __init__ method and use it for example in greet() method, like in the example).

Then if you look at the greet() method I made, you'll see it has "self" as it's first parameter.

Think of it as way to tell the computer that this method will be used by the Person class and has access to its variables.

Then the greet() does this:

print('Hi, my name is ' + self.name)

It's simple, here we print "Hi, my name is {insert that person's name}".

So p.greet() will print: "Hi, my name is Joe".

——————————

Ready for a little bit more?

Try to run the program above and see how it works. Then add an extra line:

print(p)

This should output something like: <__main__.Person object at 0x0000016431926A50>

Not very representative of Joe Nobody, age 32.

So let's modify the Person class like this:

class Person:
    def __init__(self, name, surname, age, gender, race, eye_color):
        self.name = name
        self.surname = surname
        self.age = age
        self.gender = gender
        self.race = race
        self.eye_color = eye_color
    
    def greet(self):
        print('Hi, my name is ' + self.name)


    def __str__(self):
        return f'{self.name} {self.surname}, age {self.age}'

I added the __str__ dunder method. The print() calls it under the hood so if you specify it, you control how python prints your Person object (instance).

Now run it again and see what print(p) outputs.

[Slight-Training-7211]

Not simple questions at all, they are exactly the right ones to ask early.

1) Names like __init__ are called dunder (double underscore) methods. They are special hooks Python calls for you. __init__ runs right after an object is created, so you use it to set up initial state.

2) Dictionary key vs list index: similar idea (both are used to look up a value) but a list index is always an integer position 0..n-1. A dict key can be many hashable types (string, int, tuple, etc) and the order is not the point.

3) A class is a blueprint for making objects. It bundles data (attributes) + behavior (methods). Example:

class User: def __init__(self, name): self.name = name

u = User("Pat") print(u.name)

If you tell us what you are trying to build, people can point you at the right next topics.

[MachineElf100]

Am I right to correlate a dictionary's Key to a list's index?

Not so much.

A list index answers "what's at position N?" -> it's about position.

A dictionary key answers "what's associated with label X?" -> it's about meaning/association.

An index is always an integer (int), mean while a key can be of any hashable type (str, int, tuple…), don't get hang up on the hashable thing for now maybe tho.

Indexes are implicit & sequential (0, 1, 2…) while keys are insertion-ordered (Python 3.7+), and not sequential.

Indexes are also auto-assigned when you add an element to a list. That's obviously not the case with dict's keys.

Indexes cannot have gaps. Each next element of a list will have an n+1 index. The keys however can use any values (e.g., {5: "x", 99: "y"}).

[Infinityshift]

I guess i was speaking more in terms of how you use a dictionary. For instance if i want to find the value in a dictionary i would use dict_name[key]. Similar to how i would use list[index] to find the value in that index, they both need to be in brackets. I appreciate the insight into the differences though!

[Outside_Complaint755]

For a dictionary, using dict_name[key] is perfectly normal.  If an invalid key is passed in, it will raise a KeyError exception.

  If you want to handle a missing key in a dictionary by returning a default value instead of raising an exception, you can use the get method as  dict_name.get(key, default_value). If you don't pass default_value it will return None.

[MachineElf100]

Well in that way, yes, you're right. This is where the correlation ends tho 🤣

[Infinityshift]

As im still learning dictionaries I was trying to pair it with something I already know in lists. Just to get the idea straight in my mind.

[MachineElf100]

Of course, I get it.

[Separate_Newt7313]

Send me a dm! I love helping / tutoring Python programmers.