Mācīšanās Python: no nulles līdz varonim

Pirmkārt, kas ir Python? Saskaņā ar tā radītāju Gvido van Rosumu, Python ir:

"Augsta līmeņa programmēšanas valoda, un tās galvenā dizaina filozofija ir saistīta ar koda lasāmību un sintaksi, kas ļauj programmētājiem izteikt jēdzienus dažās koda rindiņās."

Man pirmais iemesls, kāpēc apgūt Python, bija tas, ka tas patiesībā ir skaistsprogrammēšanas valoda. Bija tiešām dabiski tajā iekodēties un izteikt savas domas.

Vēl viens iemesls bija tas, ka mēs varam izmantot kodēšanu Python vairākos veidos: šeit viss spīd datu zinātne, tīmekļa izstrāde un mašīnmācīšanās. Quora, Pinterest un Spotify visi izmanto Python savai tīmekļa izstrādei. Tāpēc uzzināsim mazliet par to.

Pamati

1. Mainīgie

Varat domāt par mainīgajiem lielumiem kā par vārdiem, kas glabā vērtību. Vienkārši.

Programmā Python ir ļoti viegli definēt mainīgo un iestatīt tam vērtību. Iedomājieties, ka vēlaties saglabāt numuru 1 mainīgajā ar nosaukumu “viens”. Darīsim to:

one = 1

Cik tas bija vienkārši? Jūs tikko piešķirāt 1. vērtību mainīgajam “one”.

two = 2 some_number = 10000

Un jebkuram citam mainīgajam var piešķirt jebkuru citu vērtību . Kā redzat iepriekš redzamajā tabulā, mainīgais “ divi ” saglabā skaitli 2 , bet “ daži_numurs ” - 10 000 .

Bez veseliem skaitļiem mēs varam izmantot arī booleans (True / False), virknes, float un tik daudz citu datu veidu.

# booleans true_boolean = True false_boolean = False # string my_name = "Leandro Tk" # float book_price = 15.80

2. Kontroles plūsma: nosacījuma paziņojumi

“ Ja ” izmanto izteiksmi, lai novērtētu, vai paziņojums ir patiess vai nepatiess. Ja tā ir patiesa, tā izpilda to, kas atrodas paziņojumā “ja”. Piemēram:

if True: print("Hello Python If") if 2 > 1: print("2 is greater than 1")

2 ir lielāks par 1 , tāpēc tiek izpildīts “ drukas ” kods.

Izraksts “ cits ” tiks izpildīts, ja izteiksme “ ja ” ir nepatiesa .

if 1 > 2: print("1 is greater than 2") else: print("1 is not greater than 2")

1 nav lielāks par 2 , tāpēc kods “ else ” iekšpusē tiks izpildīts.

Varat arī izmantot paziņojumu “ 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 / Iterators

Programmā Python mēs varam atkārtoties dažādās formās. Es runāšu par diviem: kamērun par .

Kaut cikla: kamēr paziņojums ir patiess, kods, kas atrodas blokā, tiks izpildīts. Tātad, šis kods izdrukās numuru no 1 līdz 10 .

num = 1 while num <= 10: print(num) num += 1

Kamēr cilpa nepieciešams " cilpas stāvokli. ”Ja tā paliek patiesa, tā turpina atkārtoties. Šajā piemērā kad numir vienāds 11ar cilpas nosacījumuFalse .

Vēl viens pamata koda bits, lai to labāk saprastu:

loop_condition = True while loop_condition: print("Loop Condition keeps: %s" %(loop_condition)) loop_condition = False

Cilpa nosacījums ir True, lai tā tur atkārtojot - līdz brīdim, kad mēs, kas to False.

Looping : blokam lietojat mainīgo “ num ”, un priekšraksts “ for ” to atkārtos jūsu vietā. Šis kods tiks drukāts tāpat kā kods , kamēr kods: no 1 līdz 10 .

for i in range(1, 11): print(i)

Redzi? Tas ir tik vienkārši. Diapazons sākas ar 1un iet līdz 11th elementam ( 10ir 10th elements).

Saraksts: Kolekcija Masīvs | Datu struktūra

Iedomājieties, ka mainīgo vēlaties saglabāt veselu skaitli 1. Bet varbūt tagad jūs vēlaties uzglabāt 2. Un 3, 4, 5…

Vai man ir cits veids, kā saglabāt visus vēlamos skaitļus, bet ne miljonos mainīgo ? Jūs to uzminējāt - patiešām ir vēl viens veids, kā tos uzglabāt.

Listir kolekcija, kuru var izmantot, lai saglabātu vērtību sarakstu (piemēram, šos vēlamos skaitļus). Tāpēc izmantosim to:

my_integers = [1, 2, 3, 4, 5]

Tas ir patiešām vienkārši. Mēs izveidojām masīvu un saglabājām to vietnē my_integer .

Bet varbūt jūs jautājat: "Kā es varu iegūt vērtību no šī masīva?"

Lielisks jautājums. Listir jēdziens, ko sauc par indeksu . Pirmais elements iegūst indeksu 0 (nulle). Otrais saņem 1 utt. Jūs saņemat ideju.

Lai padarītu to skaidrāku, mēs varam attēlot masīvu un katru elementu ar tā indeksu. Es to varu uzzīmēt:

Izmantojot Python sintaksi, to ir arī viegli saprast:

my_integers = [5, 7, 1, 3, 4] print(my_integers[0]) # 5 print(my_integers[1]) # 7 print(my_integers[4]) # 4

Iedomājieties, ka nevēlaties glabāt veselus skaitļus. Jūs vienkārši vēlaties glabāt virknes, piemēram, savu radinieku vārdu sarakstu. Manējais izskatīsies apmēram šādi:

relatives_names = [ "Toshiaki", "Juliana", "Yuji", "Bruno", "Kaio" ] print(relatives_names[4]) # Kaio

Tas darbojas tāpat kā veseli skaitļi. Jauki.

We just learned how Lists indices work. But I still need to show you how we can add an element to the List data structure (an item to a list).

The most common method to add a new value to a List is append. Let’s see how it works:

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 Week

append is super simple. You just need to apply the element (eg. “The Effective Engineer”) as the append parameter.

Well, enough about Lists. Let’s talk about another data structure.

Dictionary: Key-Value Data Structure

Now we know that Lists are indexed with integer numbers. But what if we don’t want to use integer numbers as indices? Some data structures that we can use are numeric, string, or other types of indices.

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 Brazilian

I 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 Brazilian

Here 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_value

This 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_value

We 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 24

We 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: pass

We 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_velocity

We 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 = number

This 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 = number

And 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) # 2

This 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')

Kad mēs saucam šo metodi, tā vienkārši atgriež virkni “ VRRRRUUUUM. ”

tesla_model_s = Vehicle(4, 'electric', 5, 250) tesla_model_s.make_noise() # VRUUUUUUUM

Iekapsulēšana: informācijas slēpšana

Iekapsulēšana ir mehānisms, kas ierobežo tiešu piekļuvi objektu datiem un metodēm. Bet tajā pašā laikā tas atvieglo darbību ar šiem datiem (objektu metodēm).

“Iekapsulēšanu var izmantot, lai paslēptu datu dalībniekus un dalībnieku funkcijas. Saskaņā ar šo definīciju iekapsulēšana nozīmē, ka objekta iekšējais attēlojums parasti tiek paslēpts no skata ārpus objekta definīcijas. ” - Vikipēdija

Visa objekta iekšējā attēlošana ir paslēpta no ārpuses. Tikai objekts var mijiedarboties ar tā iekšējiem datiem.

Pirmkārt, mums ir jāsaprot, kā publicun non-publicgadījumu mainīgie un metodes darbojas.

Publiskās instances mainīgie

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_name

Here we apply the first_name value as an argument to the public instance variable.

tk = Person('TK') print(tk.first_name) # => TK

Within 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) # => TK

Cool. 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) # => Kaio

Tur mēs ejam. Mēs vienkārši iestatījām vēl vienu vērtību ( kaio) first_nameinstances mainīgajam, un tā atjaunināja vērtību. Vienkārši. Tā kā tas ir publicmainīgais, mēs to varam izdarīt.

Publiskas instances mainīgais

Šeit mēs neizmantojam terminu “privāts”, jo neviens atribūts Python nav īsti privāts (bez vispār nevajadzīga darba apjoma). - PEP 8

Kā public instance variable, mēs varam definēt non-public instance variablegan konstruktora metodi, gan klasi. Sintakses atšķirība ir šāda: pirms nosaukuma non-public instance variablesizmantojiet pasvītrojumu ( _) variable.

"" Privātie "instances mainīgie, kuriem nevar piekļūt, izņemot objekta iekšpusi, Python nepastāv. Tomēr pastāv tāda konvencija, kurai seko lielākā daļa Python koda: nosaukums, kura prefikss ir pasvītrots (piem., _spam), Ir jāuzskata par API publisku daļu (neatkarīgi no tā, vai tā ir funkcija, metode vai datu dalībnieks) ” - Python programmatūras fonds

Lūk, piemērs:

class Person: def __init__(self, first_name, email): self.first_name = first_name self._email = email

Vai jūs redzējāt emailmainīgo? Tā mēs definējam non-public variable:

tk = Person('TK', '[email protected]') print(tk._email) # [email protected]

Mēs varam tai piekļūt un to atjaunināt. Non-public variablesir tikai konvencija, un pret tām vajadzētu izturēties kā pret API publisku daļu.

Tāpēc mēs izmantojam metodi, kas ļauj to darīt mūsu klases definīcijas ietvaros. Īstenosim divas metodes ( emailun update_email), lai to saprastu:

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._email

Tagad mēs varam atjaunināt un piekļūt, non-public variablesizmantojot šīs metodes. Paskatīsimies:

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_name TK and email [email protected]
Printed the email by accessing the non-public variable with a method
Tried to set a new email out of our class
We need to treat non-public variable as non-public part of the API
Updated the non-public variable with 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._age

Let’s test it:

tk = Person('TK', 25) print(tk.show_age()) # => 25

Great — 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._age

And now, we’ll try to call this non-public method with our object:

tk = Person('TK', 25) print(tk._show_age()) # => 25

Mēs varam tai piekļūt un to atjaunināt. Non-public methodsir tikai konvencija, un pret tām vajadzētu izturēties kā pret API publisku daļu.

Šeit ir piemērs, kā mēs to varam izmantot:

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()) # => 25

Šeit mums ir _get_agenon-public methodun show_agepublic method. To show_agevar izmantot mūsu objekts (ārpus mūsu klases) un _get_agevienīgais, ko izmanto mūsu klases definīcijā ( show_agemetode iekšā ). Bet atkal: pēc vienošanās.

Iekapsulēšanas kopsavilkums

Ar iekapsulēšanu mēs varam nodrošināt, ka objekta iekšējais attēlojums tiek paslēpts no ārpuses.

Mantojums: uzvedība un īpašības

Dažiem objektiem ir dažas kopīgas iezīmes: to uzvedība un īpašības.

Piemēram, no tēva es mantoju dažas īpašības un uzvedību. Es mantoju viņa acis un matus kā raksturīgās iezīmes, un viņa nepacietību un sevī iekļaušanos - kā uzvedību.

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_velocity

Our 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) # => 250

Beautiful.

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.

Ja vēlaties pabeigt Python kursu, apgūstiet vairāk reālās kodēšanas prasmes un veidojiet projektus, izmēģiniet One Month Python Bootcamp . Tiekamies tur there

Lai iegūtu vairāk stāstu un ziņu par manu ceļojuma apguvi un programmēšanas apgūšanu, skatiet manu publikāciju The Renaissance Developer .

Izklaidējieties, turpiniet mācīties un vienmēr turpiniet kodēt.

Mans Twitter un Github. ☺