Prije svega, što je Python? Prema njegovom tvorcu Guidu van Rossumu, Python je:
"Programski jezik na visokoj razini, a njegova temeljna filozofija dizajna sastoji se od čitljivosti koda i sintakse koja programerima omogućava da izraze koncepte u nekoliko redaka koda."Za mene je prvi razlog za učenje Pythona bio taj što je, zapravo, lijepprogramski jezik. Bilo je stvarno prirodno kodirati u njemu i izraziti svoje misli.
Drugi je razlog bio taj što kodiranje u Pythonu možemo koristiti na više načina: ovdje sjaje znanost o podacima, web razvoj i strojno učenje. Quora, Pinterest i Spotify svi koriste Python za njihov pozadinski web razvoj. Pa naučimo malo o tome.
Osnove
1. Varijable
O varijablama možete razmišljati kao o riječima koje pohranjuju vrijednost. Jednostavno kao to.
U Pythonu je stvarno lako definirati varijablu i postaviti joj vrijednost. Zamislite da želite pohraniti broj 1 u varijablu koja se naziva "jedan". Učinimo to:
one = 1Koliko je to jednostavno bilo? Upravo ste dodijelili vrijednost 1 varijabli "jedan".
two = 2 some_number = 10000A možete dodijeliti bilo koju drugu vrijednost na ono što drugi varijable koje želite. Kao što vidite u gornjoj tablici, varijabla " dva " pohranjuje cijeli broj 2 , a " neki_broj " pohranjuje 10.000 .
Osim cijelih brojeva, možemo koristiti i logičke vrijednosti (True / False), nizove, float i toliko drugih vrsta podataka.
# booleans true_boolean = True false_boolean = False # string my_name = "Leandro Tk" # float book_price = 15.802. Kontrolni tok: uvjetni izrazi
" Ako " koristi izraz za procjenu je li izjava istinita ili netačna. Ako je Istina, izvršava ono što je unutar naredbe "ako". Na primjer:
if True: print("Hello Python If") if 2 > 1: print("2 is greater than 1")2 je veći od 1 , pa se izvršava " print " kod.
Izraz " else " izvršit će se ako je izraz " if " netačan .
if 1 > 2: print("1 is greater than 2") else: print("1 is not greater than 2")1 nije veći od 2 , pa će se izvršiti kôd unutar naredbe " else ".
Možete koristiti i izjavu " elif ":
if 1 > 2: print("1 is greater than 2") elif 2 > 1: print("1 is not greater than 2") else: print("1 is equal to 2")3. Looping / Iterator
U Pythonu možemo ponavljati u različitim oblicima. Govorit ću o dvoje: doki za .
While Looping: dok je naredba True, izvršit će se kôd unutar bloka. Dakle, ovaj će kôd ispisati broj od 1 do 10 .
num = 1 while num <= 10: print(num) num += 1Dok petlja treba „ petlje. ”Ako ostane Istina, nastavlja se ponavljati. U ovom primjeru, kada numje 11u petlji stanje jednaki False.
Još jedan osnovni bit koda za njegovo bolje razumijevanje:
loop_condition = True while loop_condition: print("Loop Condition keeps: %s" %(loop_condition)) loop_condition = FalseUvjet petlje je Truetakav da se neprestano ponavlja - sve dok ga ne postavimo na False.
Za petlje : primijenite varijablu " num " na blok, a naredba " for " će vam je ponoviti. Ovaj kôd ispisat će se isto kao i kod: od 1 do 10 .
for i in range(1, 11): print(i)Vidjeti? To je tako jednostavno. Raspon započinje 1i ide sve do 11th elementa ( 10jest 10th elementa).
Popis: Zbirka | Niz | Struktura podataka
Zamislite da želite pohraniti cijeli broj 1 u varijablu. Ali možda sada želite pohraniti 2. I 3, 4, 5 ...
Imam li još jedan način da pohranim sve cijele brojeve koje želim, ali ne u milijune varijabli ? Pogađate - zaista postoji još jedan način da ih pohranite.
Listje zbirka koja se može koristiti za spremanje popisa vrijednosti (poput ovih cijelih brojeva koje želite). Pa iskoristimo ga:
my_integers = [1, 2, 3, 4, 5]Zaista je jednostavno. Stvorili smo niz i pohranili ga na my_integer .
Ali možda pitate: "Kako mogu dobiti vrijednost iz ovog polja?"
Super pitanje. Listima koncept koji se naziva indeks . Prvi element dobiva indeks 0 (nula). Drugi dobiva 1, i tako dalje. Shvatili ste ideju.
Da bi bilo jasnije, možemo predstaviti niz i svaki element sa svojim indeksom. Mogu to nacrtati:
Korištenjem Python sintakse lako je razumjeti:
my_integers = [5, 7, 1, 3, 4] print(my_integers[0]) # 5 print(my_integers[1]) # 7 print(my_integers[4]) # 4Zamislite da ne želite pohraniti cijele brojeve. Vi samo želite pohraniti nizove, poput popisa imena vaše rodbine. Moja bi izgledala otprilike ovako:
relatives_names = [ "Toshiaki", "Juliana", "Yuji", "Bruno", "Kaio" ] print(relatives_names[4]) # KaioDjeluje na isti način kao i cijeli brojevi. Lijepo.
Upravo smo saznali kako Listsrade indeksi. Ali svejedno vam moram pokazati kako možemo dodati element u Liststrukturu podataka (stavku na popis).
Najčešća metoda za dodavanje nove vrijednosti a Listje append. Pogledajmo kako to funkcionira:
bookshelf = [] bookshelf.append("The Effective Engineer") bookshelf.append("The 4 Hour Work Week") print(bookshelf[0]) # The Effective Engineer print(bookshelf[1]) # The 4 Hour Work Weekappendje super jednostavno. Samo trebate primijeniti element (npr. " Učinkoviti inženjer ") kao appendparametar.
Pa, dosta o tome Lists. Razgovarajmo o drugoj strukturi podataka.
Rječnik: Struktura podataka ključ / vrijednost
Sada znamo da Listssu indeksirane cjelobrojnim brojevima. Ali što ako ne želimo koristiti cjelobrojne brojeve kao indekse? Neke strukture podataka koje možemo koristiti su numeričke, niz ili druge vrste indeksa.
Let’s learn about the Dictionary data structure. Dictionary is a collection of key-value pairs. Here’s what it looks like:
dictionary_example = { "key1": "value1", "key2": "value2", "key3": "value3" }The key is the index pointing to thevalue. How do we access the Dictionaryvalue? You guessed it — using the key. Let’s try it:
dictionary_tk = { "name": "Leandro", "nickname": "Tk", "nationality": "Brazilian" } print("My name is %s" %(dictionary_tk["name"])) # My name is Leandro print("But you can call me %s" %(dictionary_tk["nickname"])) # But you can call me Tk print("And by the way I'm %s" %(dictionary_tk["nationality"])) # And by the way I'm BrazilianI created a Dictionary about me. My name, nickname, and nationality. Those attributes are the Dictionarykeys.
As we learned how to access the List using index, we also use indices (keys in the Dictionary context) to access the value stored in the Dictionary.
In the example, I printed a phrase about me using all the values stored in the Dictionary. Pretty simple, right?
Another cool thing about Dictionary is that we can use anything as the value. In the DictionaryI created, I want to add the key “age” and my real integer age in it:
dictionary_tk = { "name": "Leandro", "nickname": "Tk", "nationality": "Brazilian", "age": 24 } print("My name is %s" %(dictionary_tk["name"])) # My name is Leandro print("But you can call me %s" %(dictionary_tk["nickname"])) # But you can call me Tk print("And by the way I'm %i and %s" %(dictionary_tk["age"], dictionary_tk["nationality"])) # And by the way I'm BrazilianHere we have a key (age) value (24) pair using string as the key and integer as the value.
As we did with Lists, let’s learn how to add elements to a Dictionary. The keypointing to avalue is a big part of what Dictionary is. This is also true when we are talking about adding elements to it:
dictionary_tk = { "name": "Leandro", "nickname": "Tk", "nationality": "Brazilian" } dictionary_tk['age'] = 24 print(dictionary_tk) # {'nationality': 'Brazilian', 'age': 24, 'nickname': 'Tk', 'name': 'Leandro'} We just need to assign a value to a Dictionarykey. Nothing complicated here, right?
Iteration: Looping Through Data Structures
As we learned in the Python Basics, the List iteration is very simple. We Pythondevelopers commonly use For looping. Let’s do it:
bookshelf = [ "The Effective Engineer", "The 4-hour Workweek", "Zero to One", "Lean Startup", "Hooked" ] for book in bookshelf: print(book)So for each book in the bookshelf, we (can do everything with it) print it. Pretty simple and intuitive. That’s Python.
For a hash data structure, we can also use the for loop, but we apply the key :
dictionary = { "some_key": "some_value" } for key in dictionary: print("%s --> %s" %(key, dictionary[key])) # some_key --> some_valueThis is an example how to use it. For each key in the dictionary , we print the key and its corresponding value.
Another way to do it is to use the iteritems method.
dictionary = { "some_key": "some_value" } for key, value in dictionary.items(): print("%s --> %s" %(key, value)) # some_key --> some_valueWe did name the two parameters as key and value, but it is not necessary. We can name them anything. Let’s see it:
dictionary_tk = { "name": "Leandro", "nickname": "Tk", "nationality": "Brazilian", "age": 24 } for attribute, value in dictionary_tk.items(): print("My %s is %s" %(attribute, value)) # My name is Leandro # My nickname is Tk # My nationality is Brazilian # My age is 24We can see we used attribute as a parameter for the Dictionarykey, and it works properly. Great!
Classes & Objects
A little bit of theory:
Objects are a representation of real world objects like cars, dogs, or bikes. The objects share two main characteristics: data and behavior.
Cars have data, like number of wheels, number of doors, and seating capacity They also exhibit behavior: they can accelerate, stop, show how much fuel is left, and so many other things.
We identify data as attributes and behavior as methods in object-oriented programming. Again:
Data → Attributes and Behavior → Methods
And a Class is the blueprint from which individual objects are created. In the real world, we often find many objects with the same type. Like cars. All the same make and model (and all have an engine, wheels, doors, and so on). Each car was built from the same set of blueprints and has the same components.
Python Object-Oriented Programming mode: ON
Python, as an Object-Oriented programming language, has these concepts: class and object.
A class is a blueprint, a model for its objects.
So again, a class it is just a model, or a way to define attributes and behavior (as we talked about in the theory section). As an example, a vehicle class has its own attributes that define what objects are vehicles. The number of wheels, type of tank, seating capacity, and maximum velocity are all attributes of a vehicle.
With this in mind, let’s look at Python syntax for classes:
class Vehicle: passWe define classes with a class statement — and that’s it. Easy, isn’t it?
Objects are instances of a class. We create an instance by naming the class.
car = Vehicle() print(car) # Here car is an object (or instance) of the classVehicle.
Remember that our vehicle class has four attributes: number of wheels, type of tank, seating capacity, and maximum velocity. We set all these attributes when creating a vehicle object. So here, we define our class to receive data when it initiates it:
class Vehicle: def __init__(self, number_of_wheels, type_of_tank, seating_capacity, maximum_velocity): self.number_of_wheels = number_of_wheels self.type_of_tank = type_of_tank self.seating_capacity = seating_capacity self.maximum_velocity = maximum_velocityWe use the initmethod. We call it a constructor method. So when we create the vehicle object, we can define these attributes. Imagine that we love the Tesla Model S, and we want to create this kind of object. It has four wheels, runs on electric energy, has space for five seats, and the maximum velocity is 250km/hour (155 mph). Let’s create this object:
tesla_model_s = Vehicle(4, 'electric', 5, 250)Four wheels + electric “tank type” + five seats + 250km/hour maximum speed.
All attributes are set. But how can we access these attributes’ values? We send a message to the object asking about them. We call it a method. It’s the object’s behavior. Let’s implement it:
class Vehicle: def __init__(self, number_of_wheels, type_of_tank, seating_capacity, maximum_velocity): self.number_of_wheels = number_of_wheels self.type_of_tank = type_of_tank self.seating_capacity = seating_capacity self.maximum_velocity = maximum_velocity def number_of_wheels(self): return self.number_of_wheels def set_number_of_wheels(self, number): self.number_of_wheels = numberThis is an implementation of two methods: number_of_wheels and set_number_of_wheels. We call it getter & setter. Because the first gets the attribute value, and the second sets a new value for the attribute.
In Python, we can do that using @property (decorators) to define getters and setters. Let’s see it with code:
class Vehicle: def __init__(self, number_of_wheels, type_of_tank, seating_capacity, maximum_velocity): self.number_of_wheels = number_of_wheels self.type_of_tank = type_of_tank self.seating_capacity = seating_capacity self.maximum_velocity = maximum_velocity @property def number_of_wheels(self): return self.__number_of_wheels @number_of_wheels.setter def number_of_wheels(self, number): self.__number_of_wheels = numberAnd we can use these methods as attributes:
tesla_model_s = Vehicle(4, 'electric', 5, 250) print(tesla_model_s.number_of_wheels) # 4 tesla_model_s.number_of_wheels = 2 # setting number of wheels to 2 print(tesla_model_s.number_of_wheels) # 2This is slightly different than defining methods. The methods work as attributes. For example, when we set the new number of wheels, we don’t apply two as a parameter, but set the value 2 to number_of_wheels. This is one way to write pythonicgetter and setter code.
But we can also use methods for other things, like the “make_noise” method. Let’s see it:
class Vehicle: def __init__(self, number_of_wheels, type_of_tank, seating_capacity, maximum_velocity): self.number_of_wheels = number_of_wheels self.type_of_tank = type_of_tank self.seating_capacity = seating_capacity self.maximum_velocity = maximum_velocity def make_noise(self): print('VRUUUUUUUM')Kada pozovemo ovu metodu, ona samo vraća niz „ VRRRRUUUUM. "
tesla_model_s = Vehicle(4, 'electric', 5, 250) tesla_model_s.make_noise() # VRUUUUUUUMKapsulacija: skrivanje informacija
Inkapsulacija je mehanizam koji ograničava izravan pristup podacima i metodama objekata. Ali istodobno, olakšava rad s tim podacima (metode objekata).
“Inkapsulacija se može koristiti za sakrivanje članova podataka i funkcije članova. Pod ovom definicijom, enkapsulacija znači da je unutarnji prikaz predmeta općenito skriven od pogleda izvan njegove definicije. " - WikipedijaSav unutarnji prikaz predmeta skriven je izvana. Samo objekt može komunicirati sa svojim unutarnjim podacima.
Prvo, moramo shvatiti kako publici non-publicvarijable instance i metode rada.
Varijable javne instance
For a Python class, we can initialize a public instance variable within our constructor method. Let’s see this:
Within the constructor method:
class Person: def __init__(self, first_name): self.first_name = first_nameHere we apply the first_name value as an argument to the public instance variable.
tk = Person('TK') print(tk.first_name) # => TKWithin the class:
class Person: first_name = 'TK'Here, we do not need to apply the first_name as an argument, and all instance objects will have a class attribute initialized with TK.
tk = Person() print(tk.first_name) # => TKCool. We have now learned that we can use public instance variables and class attributes. Another interesting thing about the public part is that we can manage the variable value. What do I mean by that? Our object can manage its variable value: Get and Set variable values.
Keeping the Person class in mind, we want to set another value to its first_name variable:
tk = Person('TK') tk.first_name = 'Kaio' print(tk.first_name) # => KaioIdemo tamo. Upravo smo postavili drugu vrijednost ( kaio) na first_namevarijablu instance i ona je ažurirala vrijednost. Jednostavno kao to. Budući da je riječ o publicvarijabli, to možemo i učiniti.
Nejavna varijabla instance
Ovdje ne koristimo izraz "privatno", jer niti jedan atribut u Pythonu nije stvarno privatan (bez općenito nepotrebne količine posla). - PEP 8Kao public instance variable, možemo definirati i jedno non-public instance variablei drugo unutar metode konstruktora ili unutar klase. Sintaksna razlika je: jer non-public instance variables, koristite podvlaku ( _) prije variableimena.
_spam) Treba tretirati kao nejavni dio API-ja (bilo da je to funkcija, metoda ili član podataka) " - Python Software Foundation
Evo primjera:
class Person: def __init__(self, first_name, email): self.first_name = first_name self._email = emailJeste li vidjeli emailvarijablu? Evo kako definiramo non-public variable:
tk = Person('TK', '[email protected]') print(tk._email) # [email protected]Non-public variablessu samo konvencija i treba ih tretirati kao nejavni dio API-ja.
Dakle, koristimo metodu koja nam omogućuje da to učinimo unutar naše definicije klase. Primijenimo dvije metode ( emaili update_email) kako bismo to razumjeli:
class Person: def __init__(self, first_name, email): self.first_name = first_name self._email = email def update_email(self, new_email): self._email = new_email def email(self): return self._emailSada možemo ažurirati i pristupiti non-public variablestim metodama. Da vidimo:
tk = Person('TK', '[email protected]') print(tk.email()) # => [email protected] # tk._email = '[email protected]' -- treat as a non-public part of the class API print(tk.email()) # => [email protected] tk.update_email('[email protected]') print(tk.email()) # => [email protected]- We initiated a new object with
first_nameTK andemail[email protected] - Printed the email by accessing the
non-public variablewith a method - Tried to set a new
emailout of our class - We need to treat
non-public variableasnon-publicpart of the API - Updated the
non-public variablewith our instance method - Success! We can update it inside our class with the helper method
Public Method
With public methods, we can also use them out of our class:
class Person: def __init__(self, first_name, age): self.first_name = first_name self._age = age def show_age(self): return self._ageLet’s test it:
tk = Person('TK', 25) print(tk.show_age()) # => 25Great — we can use it without any problem.
Non-public Method
But with non-public methods we aren’t able to do it. Let’s implement the same Person class, but now with a show_agenon-public method using an underscore (_).
class Person: def __init__(self, first_name, age): self.first_name = first_name self._age = age def _show_age(self): return self._ageAnd now, we’ll try to call this non-public method with our object:
tk = Person('TK', 25) print(tk._show_age()) # => 25Non-public methodssu samo konvencija i treba ih tretirati kao nejavni dio API-ja.
Evo primjera kako ga možemo koristiti:
class Person: def __init__(self, first_name, age): self.first_name = first_name self._age = age def show_age(self): return self._get_age() def _get_age(self): return self._age tk = Person('TK', 25) print(tk.show_age()) # => 25Ovdje imamo a _get_agenon-public methodi a show_agepublic method. show_ageSe može koristiti od strane našeg objekta (iz naše klase), a _get_agekoristi se samo u našem razredu razlučivosti (unutar show_agemetoda). Ali opet: kao stvar konvencije.
Sažetak enkapsulacije
Inkapsulacijom možemo osigurati da je unutarnji prikaz predmeta skriven izvana.
Nasljeđivanje: ponašanja i karakteristike
Određenim objektima zajedničke su neke stvari: njihovo ponašanje i karakteristike.
Primjerice, naslijedio sam neke osobine i ponašanja od oca. Naslijedio sam njegove oči i kosu kao karakteristike, a njegovu nestrpljivost i zatvorenost kao ponašanje.
In object-oriented programming, classes can inherit common characteristics (data) and behavior (methods) from another class.
Let’s see another example and implement it in Python.
Imagine a car. Number of wheels, seating capacity and maximum velocity are all attributes of a car. We can say that anElectricCar class inherits these same attributes from the regular Car class.
class Car: def __init__(self, number_of_wheels, seating_capacity, maximum_velocity): self.number_of_wheels = number_of_wheels self.seating_capacity = seating_capacity self.maximum_velocity = maximum_velocityOur Car class implemented:
my_car = Car(4, 5, 250) print(my_car.number_of_wheels) print(my_car.seating_capacity) print(my_car.maximum_velocity)Once initiated, we can use all instance variables created. Nice.
In Python, we apply a parent class to the child class as a parameter. An ElectricCar class can inherit from our Car class.
class ElectricCar(Car): def __init__(self, number_of_wheels, seating_capacity, maximum_velocity): Car.__init__(self, number_of_wheels, seating_capacity, maximum_velocity)Simple as that. We don’t need to implement any other method, because this class already has it (inherited from Car class). Let’s prove it:
my_electric_car = ElectricCar(4, 5, 250) print(my_electric_car.number_of_wheels) # => 4 print(my_electric_car.seating_capacity) # => 5 print(my_electric_car.maximum_velocity) # => 250Beautiful.
That’s it!
We learned a lot of things about Python basics:
- How Python variables work
- How Python conditional statements work
- How Python looping (while & for) works
- How to use Lists: Collection | Array
- Dictionary Key-Value Collection
- How we can iterate through these data structures
- Objects and Classes
- Attributes as objects’ data
- Methods as objects’ behavior
- Using Python getters and setters & property decorator
- Encapsulation: hiding information
- Inheritance: behaviors and characteristics
Congrats! You completed this dense piece of content about Python.
If you want a complete Python course, learn more real-world coding skills and build projects, try One Month Python Bootcamp. See you there ☺
For more stories and posts about my journey learning & mastering programming, follow my publication The Renaissance Developer.
Have fun, keep learning, and always keep coding.
My Twitter & Github. ☺