Hello again.

In this passage, we'll try to write a simple Python script together. We want the script to: 1 / ask the user to enter their first name, 2 / read the name the user will provide, 3 / write a greeting on the screen: Have a nice day, [name].

The dialogue between the program and the user will look like this:

Program: Give your name please.
User: Adam
Program: Have a nice day, Adam.

We will focus on the code itself, without any additional technical advice. If you don't know how to save the code to a file and then run it, see the previous post.

As you may have guessed, it will be difficult for the program to use the user's name in the greeting it generates: "Have a nice day [name]". In order for the program to use the previously read (remembered) user's name in response, we will have to use a variable. Variables are a very important element of any programming language. It's hard to imagine coding without understanding what variables are and how they work.

Okay. Let's start (as a warm-up) with a simplified version of the script to achieve the following effect when launched:

Program: Give your name please.
User: [name]
Program: Have a nice day.

So for now, without catching the given name by the program and inserting it in the third line (i.e. without using the variable yet).

We can easily write such a program. Here is the code:

Exercise02.py

print('Enter your name, please:')
input()
print('Have a nice day.')

The program asks the user for his name (print command), remembers it (input command), and finally generates a greeting: Have a nice day.

But how to make the program add the name given by the user after the words Have a nice day?
As we already mentioned, we will need a variable for this. Ok, and what exactly is it?

Python Variables

In Python, a variable is not the same as in math. A variable in Python is just a label that you tag a piece of data with. Imagine a "solid" piece of data, e.g. a list of the largest cities in Germany, that you entered at the very beginning of your new Python script:

In Python, on an "object" such as a list, you can execute various commands, print the list on the screen, sort it, delete selected items or add new items, merge with other lists, etc. However, how to refer to the list in the command? How to bring up the list we want? By typing out all of its contents? Every time we want to execute a command? You admit that it would be extremely tiring. Wouldn't it be easier to name this list with a letter, for example L? Then, in any command, we'll use that one short letter instead of having to tediously write out the entire contents of the list. This our magic letter is just a variable.

In Python, a variable is a substitute for the object it has been assigned to. We also call it a reference. Assigning a variable to a list (or any other object) is done using a simple equal sign (=)

   L = [
'Aachen', 'Augsburg', 'Bergisch Gladbach', 'Berlin', 'Bielefeld',
    'Bochum', 'Bonn', 'Bottrop', 'Braunschweig', 'Bremen',
    'Bremerhaven', 'Chemnitz', 'Cologne (Köln)',
    'Darmstadt', 'Dortmund', 'Dresden', 'Duisburg', 'Düsseldorf',
    'Erfurt', 'Erlangen', 'Essen', 'Frankfurt am Main', 'Freiburg im Breisgau',
    'Fürth', 'Gelsenkirchen', 'Göttingen', 'Hagen', 'Halle (Saale)',
    'Hamburg', 'Hamm', 'Hanover (Hannover)', 'Heidelberg', 'Heilbronn',
    'Herne', 'Hildesheim', 'Ingolstadt', 'Jena', 'Karlsruhe',
    'Kassel', 'Kiel', 'Koblenz', 'Krefeld', 'Leipzig',
    'Leverkusen', 'Lübeck', 'Ludwigshafen am Rhein', 'Magdeburg', 'Mainz',
    'Mannheim', 'Moers', 'Mönchengladbach', 'Mülheim an der Ruhr', 'Munich',
    'Münster', 'Neuss', 'Nuremberg (Nürnberg)', 'Oberhausen', 'Offenbach am Main',
    'Oldenburg', 'Osnabrück', 'Paderborn', 'Pforzheim', 'Potsdam',
    'Recklinghausen', 'Regensburg', 'Remscheid', 'Reutlingen', 'Rostock',
    'Saarbrücken', 'Salzgitter', 'Siegen', 'Solingen', 'Stuttgart',
    'Trier', 'Ulm', 'Wiesbaden', 'Wolfsburg', 'Wuppertal', 'Würzburg']

Let's take a look at what the script with the command to print the list above will look like:

L = [
    'Aachen', 'Augsburg', 'Bergisch Gladbach', 'Berlin', 'Bielefeld',
    'Bochum', 'Bonn', 'Bottrop', 'Braunschweig', 'Bremen',
    'Bremerhaven', 'Chemnitz', 'Cologne (Köln)',
    'Darmstadt', 'Dortmund', 'Dresden', 'Duisburg', 'Düsseldorf',
    'Erfurt', 'Erlangen', 'Essen', 'Frankfurt am Main', 'Freiburg im Breisgau',
    'Fürth', 'Gelsenkirchen', 'Göttingen', 'Hagen', 'Halle (Saale)',
    'Hamburg', 'Hamm', 'Hanover (Hannover)', 'Heidelberg', 'Heilbronn',
    'Herne', 'Hildesheim', 'Ingolstadt', 'Jena', 'Karlsruhe',
    'Kassel', 'Kiel', 'Koblenz', 'Krefeld', 'Leipzig',
    'Leverkusen', 'Lübeck', 'Ludwigshafen am Rhein', 'Magdeburg', 'Mainz',
    'Mannheim', 'Moers', 'Mönchengladbach', 'Mülheim an der Ruhr', 'Munich',
    'Münster', 'Neuss', 'Nuremberg (Nürnberg)', 'Oberhausen', 'Offenbach am Main',
    'Oldenburg', 'Osnabrück', 'Paderborn', 'Pforzheim', 'Potsdam',
    'Recklinghausen', 'Regensburg', 'Remscheid', 'Reutlingen', 'Rostock',
    'Saarbrücken', 'Salzgitter', 'Siegen', 'Solingen', 'Stuttgart',
    'Trier', 'Ulm', 'Wiesbaden', 'Wolfsburg', 'Wuppertal', 'Würzburg'
    ]

print(L)

/ the result will be the content of the list printed on your computer screen /

As you can see, we used a short single letter variable in the print command to print the entire long multi-item list.

If we hadn't used the variable, our script would look like this:

[
    'Aachen', 'Augsburg', 'Bergisch Gladbach', 'Berlin', 'Bielefeld',
    'Bochum', 'Bonn', 'Bottrop', 'Braunschweig', 'Bremen',
    'Bremerhaven', 'Chemnitz', 'Cologne (Köln)',
    'Darmstadt', 'Dortmund', 'Dresden', 'Duisburg', 'Düsseldorf',
    'Erfurt', 'Erlangen', 'Essen', 'Frankfurt am Main', 'Freiburg im Breisgau',
    'Fürth', 'Gelsenkirchen', 'Göttingen', 'Hagen', 'Halle (Saale)',
    'Hamburg', 'Hamm', 'Hanover (Hannover)', 'Heidelberg', 'Heilbronn',
    'Herne', 'Hildesheim', 'Ingolstadt', 'Jena', 'Karlsruhe',
    'Kassel', 'Kiel', 'Koblenz', 'Krefeld', 'Leipzig',
    'Leverkusen', 'Lübeck', 'Ludwigshafen am Rhein', 'Magdeburg', 'Mainz',
    'Mannheim', 'Moers', 'Mönchengladbach', 'Mülheim an der Ruhr', 'Munich',
    'Münster', 'Neuss', 'Nuremberg (Nürnberg)', 'Oberhausen', 'Offenbach am Main',
    'Oldenburg', 'Osnabrück', 'Paderborn', 'Pforzheim', 'Potsdam',
    'Recklinghausen', 'Regensburg', 'Remscheid', 'Reutlingen', 'Rostock',
    'Saarbrücken', 'Salzgitter', 'Siegen', 'Solingen', 'Stuttgart',
    'Trier', 'Ulm', 'Wiesbaden', 'Wolfsburg', 'Wuppertal', 'Würzburg'
    ]
print([
    'Aachen', 'Augsburg', 'Bergisch Gladbach', 'Berlin', 'Bielefeld',
    'Bochum', 'Bonn', 'Bottrop', 'Braunschweig', 'Bremen',
    'Bremerhaven', 'Chemnitz', 'Cologne (Köln)',
    'Darmstadt', 'Dortmund', 'Dresden', 'Duisburg', 'Düsseldorf',
    'Erfurt', 'Erlangen', 'Essen', 'Frankfurt am Main', 'Freiburg im Breisgau',
    'Fürth', 'Gelsenkirchen', 'Göttingen', 'Hagen', 'Halle (Saale)',
    'Hamburg', 'Hamm', 'Hanover (Hannover)', 'Heidelberg', 'Heilbronn',
    'Herne', 'Hildesheim', 'Ingolstadt', 'Jena', 'Karlsruhe',
    'Kassel', 'Kiel', 'Koblenz', 'Krefeld', 'Leipzig',
    'Leverkusen', 'Lübeck', 'Ludwigshafen am Rhein', 'Magdeburg', 'Mainz',
   'Mannheim', 'Moers', 'Mönchengladbach', 'Mülheim an der Ruhr', 'Munich',
    'Münster', 'Neuss', 'Nuremberg (Nürnberg)', 'Oberhausen', 'Offenbach am Main',
    'Oldenburg', 'Osnabrück', 'Paderborn', 'Pforzheim', 'Potsdam',
    'Recklinghausen', 'Regensburg', 'Remscheid', 'Reutlingen', 'Rostock',
    'Saarbrücken', 'Salzgitter', 'Siegen', 'Solingen', 'Stuttgart',
    'Trier', 'Ulm', 'Wiesbaden', 'Wolfsburg', 'Wuppertal', 'Würzburg'
    ])

/ the result will be the content of the list printed on your computer screen /

Failure to use a variable means (as you can see) the need to rewrite the entire long list in the print command, even though the list above has already been entered in the code once.

It's not hard to imagine what your script would look like if you wanted to enter more commands for this list. The list would be rewritten a great many times and the script would be devastatingly long and tiring to read.

The variable, therefore, saves us from thoughtless and tedious code duplication. But is it only?

Variable as Interceptor

The variable gives something more than what we wrote a moment ago. It allows you to refer to elements of the program that cannot be referred to in any other way. We mean the data entered by the user when the program is started — as in our case "name". After all, we cannot in any way predict what name the user will enter when the program asks for it. It may well be the name Adam and Thomas or Sarah.

User input is not a snippet of code. These are data entered "from the outside" in the program start-up phase. That is why they are called run-time data, and often also transient data, because when the program is closed, they disappear into oblivion.

To put it in a very simple language: the data entered during the program operation phase must be named somehow in order to be able to refer to it later.

Or to put it a bit more in a professional language: this data has to be assigned to a variable in order to be able to refer to it later.

The variable is assigned in the same way as in the above-mentioned list example. You choose any letter of the alphabet, say "a", and assign it to the entered data:

a = input()

We have marked the data that the user enters into the program as a. Now we can easily tell the program to print this data:

print (a)

Simple and easy, right?

We can finally return to our script from the beginning of the article and present its full form:

Exercise02.py

print('Enter your name, please:')
a = input()
print ('Have a nice day, '+ a+'.')

In the third line of the code, we connected three elements with the "+" sign: the phrase "Have a nice day", the variable a and the period. Have a nice day phrase and the period are in quotation marks. Note that the phrase Have a nice day includes a comma and a space at the end:

A few final remarks

We do not enclose variable names in quotation marks. The obligation to use quotation marks applies only to strings. Try to write 'a' instead of a in the last line of our script and see what happens when you run the program.

The variable name does not have to be a single letter. You can use a combination of letters and numbers to name your variables. Do not use spaces or hyphens, but you can use underscore. Letters can be uppercase or lowercase, but it is recommended that you use lowercase letters in your variable names.

Do not start a variable name with a digit.

A valid example of a variable name: your_name

Invalid variable name example: your-name

You can devote quite a lot of space to the topic of variables and reflect on various really interesting aspects of this topic. Let us mention, for example, the issue of prior declaration of variables — before we use them in the program, and a deeper analysis of the relationship between the variable and the value assigned to it. As you continue to learn Python, we assure you that you will be interested in these topics yourself. And we promise to come back to them.

For volunteers:

When you want to combine several text elements to be printed, in the print command you can concatenate them with the "+" sign. Another option is to combine using commas:

print('Have a nice day', a, '.')

Using commas will cause Python to separate items with spaces. Try and compare the effect.

Odcinek‑3

Zmienne w Pythonie

Witajcie ponownie.

W obecnym odcinku spróbujemy wspólnie napisać prosty skrypt w języku Python.

Chcemy aby: 1/ skrypt poprosił użytkownika o podanie imienia, 2/ zaczytał imię, które użytkownik poda, 3/ napisał na ekranie pozdrowienie: Miłego dnia, [imię].

Dialog pomiędzy programem a użytkownikiem wyglądał będzie zatem np. tak:

Program: Podaj twoje imię, proszę.
Użytkownik: Adam
Program: Miłego dnia, Adam.

Skupimy się na samym kodzie, bez dodatkowych porad technicznych. Jeśli nie wiesz, jak zapisać kod w pliku, a później go uruchomić, zajrzyj do poprzedniego postu.

Jak pewnie się domyślasz, pewną trudność stanowić będzie użycie przez program imienia użytkownika, w generowanym pozdrowieniu Miłego dnia [imię].

Aby program użył w odpowiedzi wcześniej zaczytane (zapamiętane) imię użytkownika, będziemy musieli posłużyć się zmienną. Zmienne to bardzo ważny element każdego języka programowania. Trudno wyobrazić sobie kodowanie, bez zrozumienia czym są zmienne i jak działają.

No dobrze. Zacznijmy (dla rozgrzewki) od uproszczonej wersji skryptu, aby po uruchomieniu osiągnąć taki efekt:

Program: Podaj twoje imię, proszę.
Użytkownik: [imię]
Program: Miłego dnia.

Na razie zatem bez przechwycenia przez program podanego imienia i wstawienia go w trzeciej linii (czyli jeszcze bez użycia zmiennej).

Taki program potrafimy już z łatwością napisać.

Oto kod:

Exercise02.py

print('Podaj twoje imię, proszę:')
input()
print('Miłego dnia.')

Program prosi użytkownika o podanie imienia (polecenie print), zapamiętuje je (polecenie input), na koniec generuje pozdrowienie: Miłego dnia.

Ale jak zrobić, aby po słowach Miłego dnia program dopisywał podane przez użytkownika imię? Jak już wspomnieliśmy, do tego celu potrzebować będziemy zmiennej. Cóż to takiego?

Zmienne w Pythonie

W Pythonie zmienna nie jest tym samym, co w matematyce. Zmienna w Pythonie to po prostu etykietka, którą oznakowujesz fragment danych. Wyobraź sobie jakiś "solidny" kawał danych, np. listę największych miast w Niemczech, którą wpisałeś na samym początku nowotworzonego skryptu w Pythonie:

W Pythonie na takim "obiekcie" jak lista możesz wykonywać rozmaite polecenia, drukować tę listę na ekranie, sortować ją, usuwać wybrane elementy bądź dodawać nowe, łączyć z innymi listami itd[1].

Jak jednak odwołać się w poleceniu do listy? Jak przywołać listę, o którą nam chodzi? Wypisując całą jej zawartość? Za każdym razem, gdy chcemy zrealizować polecenie?

Przyznasz, że byłoby to wyjątkowo męczące. Czy nie prościej nazwać tę listę jakąś literką, np. L? Wówczas, w dowolnym poleceniu, użyjemy tej jednej krótkiej literki, zamiast żmudnie wypisywać całą zawartość listy. Ta nasza magiczna literka to właśnie zmienna.

W Pythonie zmienna jest zamiennikiem obiektu, do którego została przypisana. Mówimy na nią także odnośnik (reference).

Przypisanie zmiennej do listy (czy też dowolnego innego obiektu) wykonujemy poprzez zwykły znak równości (=)

L = [
    'Aachen', 'Augsburg', 'Bergisch Gladbach', 'Berlin', 'Bielefeld',
    'Bochum', 'Bonn', 'Bottrop', 'Braunschweig', 'Bremen',
    'Bremerhaven', 'Chemnitz', 'Cologne (Köln)',
    'Darmstadt', 'Dortmund', 'Dresden', 'Duisburg', 'Düsseldorf',
    'Erfurt', 'Erlangen', 'Essen', 'Frankfurt am Main', 'Freiburg im Breisgau',
    'Fürth', 'Gelsenkirchen', 'Göttingen', 'Hagen', 'Halle (Saale)',
    'Hamburg', 'Hamm', 'Hanover (Hannover)', 'Heidelberg', 'Heilbronn',
    'Herne', 'Hildesheim', 'Ingolstadt', 'Jena', 'Karlsruhe',
    'Kassel', 'Kiel', 'Koblenz', 'Krefeld', 'Leipzig',
    'Leverkusen', 'Lübeck', 'Ludwigshafen am Rhein', 'Magdeburg', 'Mainz',
    'Mannheim', 'Moers', 'Mönchengladbach', 'Mülheim an der Ruhr', 'Munich (München)',
    'Münster', 'Neuss', 'Nuremberg (Nürnberg)', 'Oberhausen', 'Offenbach am Main',
    'Oldenburg', 'Osnabrück', 'Paderborn', 'Pforzheim', 'Potsdam',
    'Recklinghausen', 'Regensburg', 'Remscheid', 'Reutlingen', 'Rostock',
    'Saarbrücken', 'Salzgitter', 'Siegen', 'Solingen', 'Stuttgart',
    'Trier', 'Ulm', 'Wiesbaden', 'Wolfsburg', 'Wuppertal', 'Würzburg'
    ]

Spójrzmy, jak będzie wyglądał skrypt z poleceniem wydrukowania powyższej listy:

L = [
    'Aachen', 'Augsburg', 'Bergisch Gladbach', 'Berlin', 'Bielefeld',
    'Bochum', 'Bonn', 'Bottrop', 'Braunschweig', 'Bremen',
    'Bremerhaven', 'Chemnitz', 'Cologne (Köln)',
    'Darmstadt', 'Dortmund', 'Dresden', 'Duisburg', 'Düsseldorf',
    'Erfurt', 'Erlangen', 'Essen', 'Frankfurt am Main', 'Freiburg im Breisgau',
    'Fürth', 'Gelsenkirchen', 'Göttingen', 'Hagen', 'Halle (Saale)',
    'Hamburg', 'Hamm', 'Hanover (Hannover)', 'Heidelberg', 'Heilbronn',
    'Herne', 'Hildesheim', 'Ingolstadt', 'Jena', 'Karlsruhe',
    'Kassel', 'Kiel', 'Koblenz', 'Krefeld', 'Leipzig',
    'Leverkusen', 'Lübeck', 'Ludwigshafen am Rhein', 'Magdeburg', 'Mainz',
    'Mannheim', 'Moers', 'Mönchengladbach', 'Mülheim an der Ruhr', 'Munich (München)',
    'Münster', 'Neuss', 'Nuremberg (Nürnberg)', 'Oberhausen', 'Offenbach am Main',
    'Oldenburg', 'Osnabrück', 'Paderborn', 'Pforzheim', 'Potsdam',
    'Recklinghausen', 'Regensburg', 'Remscheid', 'Reutlingen', 'Rostock',
    'Saarbrücken', 'Salzgitter', 'Siegen', 'Solingen', 'Stuttgart',
    'Trier', 'Ulm', 'Wiesbaden', 'Wolfsburg', 'Wuppertal', 'Würzburg'
    ]

print(L)

/wynikiem będzie treść listy wydrukowana na ekranie twojego komputera/

Jak widzisz, w poleceniu print skorzystaliśmy z krótkiej jednoliterowej zmiennej, aby wydrukować całą długą, wieloelementową listę.

Gdybyśmy nie skorzystali ze zmiennej, nasz skrypt wyglądałby tak:

[
    'Aachen', 'Augsburg', 'Bergisch Gladbach', 'Berlin', 'Bielefeld',
    'Bochum', 'Bonn', 'Bottrop', 'Braunschweig', 'Bremen',
    'Bremerhaven', 'Chemnitz', 'Cologne (Köln)',
    'Darmstadt', 'Dortmund', 'Dresden', 'Duisburg', 'Düsseldorf',
    'Erfurt', 'Erlangen', 'Essen', 'Frankfurt am Main', 'Freiburg im Breisgau',
    'Fürth', 'Gelsenkirchen', 'Göttingen', 'Hagen', 'Halle (Saale)',
    'Hamburg', 'Hamm', 'Hanover (Hannover)', 'Heidelberg', 'Heilbronn',
    'Herne', 'Hildesheim', 'Ingolstadt', 'Jena', 'Karlsruhe',
    'Kassel', 'Kiel', 'Koblenz', 'Krefeld', 'Leipzig',
    'Leverkusen', 'Lübeck', 'Ludwigshafen am Rhein', 'Magdeburg', 'Mainz',
    'Mannheim', 'Moers', 'Mönchengladbach', 'Mülheim an der Ruhr', 'Munich (München)',
    'Münster', 'Neuss', 'Nuremberg (Nürnberg)', 'Oberhausen', 'Offenbach am Main',
    'Oldenburg', 'Osnabrück', 'Paderborn', 'Pforzheim', 'Potsdam',
    'Recklinghausen', 'Regensburg', 'Remscheid', 'Reutlingen', 'Rostock',
    'Saarbrücken', 'Salzgitter', 'Siegen', 'Solingen', 'Stuttgart',
    'Trier', 'Ulm', 'Wiesbaden', 'Wolfsburg', 'Wuppertal', 'Würzburg'
    ]
print([
    'Aachen', 'Augsburg', 'Bergisch Gladbach', 'Berlin', 'Bielefeld',
    'Bochum', 'Bonn', 'Bottrop', 'Braunschweig', 'Bremen',
    'Bremerhaven', 'Chemnitz', 'Cologne (Köln)',
    'Darmstadt', 'Dortmund', 'Dresden', 'Duisburg', 'Düsseldorf',
    'Erfurt', 'Erlangen', 'Essen', 'Frankfurt am Main', 'Freiburg im Breisgau',
    'Fürth', 'Gelsenkirchen', 'Göttingen', 'Hagen', 'Halle (Saale)',
    'Hamburg', 'Hamm', 'Hanover (Hannover)', 'Heidelberg', 'Heilbronn',
    'Herne', 'Hildesheim', 'Ingolstadt', 'Jena', 'Karlsruhe',
    'Kassel', 'Kiel', 'Koblenz', 'Krefeld', 'Leipzig',
    'Leverkusen', 'Lübeck', 'Ludwigshafen am Rhein', 'Magdeburg', 'Mainz',
   'Mannheim', 'Moers', 'Mönchengladbach', 'Mülheim an der Ruhr', 'Munich (München)',
    'Münster', 'Neuss', 'Nuremberg (Nürnberg)', 'Oberhausen', 'Offenbach am Main',
    'Oldenburg', 'Osnabrück', 'Paderborn', 'Pforzheim', 'Potsdam',
    'Recklinghausen', 'Regensburg', 'Remscheid', 'Reutlingen', 'Rostock',
    'Saarbrücken', 'Salzgitter', 'Siegen', 'Solingen', 'Stuttgart',
    'Trier', 'Ulm', 'Wiesbaden', 'Wolfsburg', 'Wuppertal', 'Würzburg'
    ])

/wynikiem będzie treść listy wydrukowana na ekranie twojego komputera/

Brak posiłkowania się zmienną oznacza (jak widać) konieczność przepisania całej długiej listy w poleceniu print, pomimo że powyżej lista ta była już raz wpisana do kodu.

Nietrudno sobie wyobrazić, jak wyglądałby twój skrypt, gdybyś chciał wprowadzić więcej poleceń dotyczących tej listy. Lista byłaby przepisywana ogromną ilość razy, a skrypt byłby porażająco długi i męczący w czytaniu.

Zmienna zatem ratuje nas przed bezrefleksyjnym i nużącym powielaniem kodu.

Ale czy tylko?

Zmienna przechwytująca

Zmienna daje jeszcze coś więcej, ponad to co napisaliśmy przed chwilą. Pozwala odwołać się do takich elementów programu, do których nie ma sposobu odwołania się w żaden inny sposób. Mamy na myśli dane wprowadzane przez użytkownika podczas uruchomienia programu – jak w naszym przypadku "imię". Nie jesteśmy przecież w żaden sposób w stanie przewidzieć, jakie imię wpisze użytkownik, gdy program go o to poprosi. Równie dobrze może to być imię Adam, jak i Thomas albo Sara.

Dane wprowadzane przez użytkownika nie są fragmentem kodu. Są to dane wprowadzane "z zewnątrz" w fazie uruchomieniowej programu. Dlatego nazywa się je run-time data, a często także transient data (dane ulotne), gdyż wraz z zamknięciem programu ulatują w niebyt[2].

Mówiąc bardzo prostym językiem: dane wprowadzone w fazie działania programu musisz jakoś nazwać, aby móc się do nich następnie odwołać.

A mówiąc trochę bardziej profesjonalnym językiem: dane te trzeba przypisać do zmiennej, aby móc się do nich następnie odwołać.

Przypisanie zmiennej odbywa się identycznie, jak we wcześniej przytoczonym przykładzie listy. Wybierasz sobie dowolną literkę alfabetu, powiedzmy "a" i przyporządkowujesz ją do wprowadzonych danych:

a = input()

Dane, które użytkownik wprowadza do programu, oznaczyliśmy jako a.

Teraz z łatwością możemy nakazać programowi, aby wydrukował te dane:

print(a)

Proste i łatwe, prawda?

Możemy wreszcie wrócić do naszego skryptu z początku artykułu, i zaprezentować jego pełną postać:

Exercise02.py

print('Podaj twoje imię, proszę:')
a = input()
print('Miłego dnia, '+a+'.')

W trzeciej linijce kodu połączyliśmy znakiem "+" trzy elementy: frazę Miłego dnia, zmienną a oraz kropkę. Fraza Miłego dnia i kropka ujęte są w cudzysłów.

Zauważ że fraza Miłego dnia obejmuje przecinek oraz spację na jej końcu:

Dla chętnych: Gdy w poleceniu print zamierzasz połączyć kilka elementów tekstowych, które mają być wydrukowane, możesz łączyć je właśnie znakiem "+". Inną opcją jest łączenie z wykorzystaniem przecinków: print('Miłego dnia', a, '.') Użycie przecinków będzie miało ten skutek, że Python rozdzieli elementy spacjami. Wypróbuj i porównaj efekt.

Parę uwag na zakończenie

Nazw zmiennych nie ujmujemy w cudzysłów. Obowiązek stosowania cudzysłowu dotyczy jedynie łańcuchów znaków. Spróbuj w ostatniej linijce kodu naszego skryptu napisać 'a' zamiast a i zobacz, co się stanie, gdy uruchomisz program.

Nazwa zmiennej nie musi być pojedynczą literką. Możesz używać kombinacji liter i cyfr dla nazywania swoich zmiennych. Nie używaj spacji ani myślników, natomiast możesz użyć podkreślnika (underscore). Litery mogą być duże lub małe, ale rekomenduje się używanie małych liter w nazwach zmiennych.

Nie rozpoczynaj nazwy zmiennej od cyfry.

Poprawny przykład nazwy zmiennej: your_name

Niepoprawny przykład nazwy zmiennej: your-name

Tematowi zmiennych można poświęcić całkiem sporo miejsca i pozastanawiać się nad różnymi naprawdę ciekawymi aspektami tego tematu. Wspomnijmy choćby o kwestii uprzedniego deklarowania zmiennych – zanim użyjemy ich w programie oraz o głębszej analizie relacji pomiędzy zmienną a przypisaną do niej wartością. Gdy będziesz kontynuował naukę Pythona, zapewniamy, że sam z zainteresowaniem sięgniesz po te tematy. A my obiecujemy do nich wrócić.

[1] nie przejmuj się tym, że, prezentujemy przykład listy, choć jeszcze nie omówiliśmy list w Pythonie; na ten moment wystarczy nam zupełnie intuicyjne pojmowanie, czym jest lista;

[2] Dane ulotne są przechowywane w pamięci RAM komputera (pamięć o dostępie swobodnym). Po zakończeniu programu dane są usuwane (unicestwiane). Transient data is stored in the computers RAM (random access memory). When a program completes, the data is de-allocated (it dies).

Juthon

Passage 3: A few words about Variables

Python Variables

Variable as Interceptor

A few final remarks

For volunteers:

Zmienne w Pythonie

Zmienne w Pythonie

Zmienna przechwytująca

Parę uwag na zakończenie