Pythoni õppimine: nullist kangelaseni

Esiteks, mis on Python? Selle looja Guido van Rossumi sõnul on Python:

"Kõrgel tasemel programmeerimiskeel ja selle peamine disainifilosoofia on seotud koodide loetavusega ja süntaksiga, mis võimaldab programmeerijatel väljendada mõisteid mõne koodireaga."

Minu jaoks oli Pythoni õppimise esimene põhjus see, et see on tegelikult ilusprogrammeerimiskeel. See oli tõesti loomulik, et sinna sisse kodeeriti ja oma mõtteid avaldasin.

Teine põhjus oli see, et saame Pythonis kodeerimist kasutada mitmel viisil: andmeteadus, veebiarendus ja masinõpe kõik siin säravad. Kõik Quora, Pinterest ja Spotify kasutavad Pythoni oma veebiarenduse jaoks. Nii et õpime selle kohta natuke.

Põhitõed

1. Muutujad

Võite mõelda muutujatele kui sõnadele, mis salvestavad väärtust. Nii lihtne.

Pythonis on muutujat väga lihtne määratleda ja sellele väärtus määrata. Kujutage ette, et soovite numbri 1 salvestada muutujasse nimega üks. Teeme seda:

one = 1

Kui lihtne see oli? Määrasite just muutujale „üks” väärtuse 1.

two = 2 some_number = 10000

Ja saate määrata mis tahes muu väärtuse mis tahes muudele muutujatele, mida soovite. Nagu näete ülaltoodud tabelis, salvestab muutuja „ kaks ” täisarvu 2 ja „ mõni_arv10 000 .

Lisaks täisarvudele võime kasutada ka tõeväärtusi (True / False), stringe, ujukit ja nii palju muid andmetüüpe.

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

2. Kontrollvoog: tingimuslaused

" If " kasutab avaldist, et hinnata, kas lause on tõene või vale. Kui see on tõene, täidab see selle, mis on lause „kui” sees. Näiteks:

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

2 on suurem kui 1 , seega käivitatakse printimise kood.

Lause “ muu ” käivitatakse juhul, kui avaldis “ kui ” on vale .

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

1 pole suurem kui 2 , seega käivitatakse lause “ else ” sees olev kood .

Võite kasutada ka lauset “ 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 / iteraator

Pythonis saame korduda erinevates vormides. Ma räägin kahest: samasja võtta .

Kuigi Silmukoiminen: kui väide on õige, kood blokis viiakse. Niisiis, see kood trükib numbri vahemikus 1 kuni 10 .

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

Samas loop vajab " loop seisukorras. ”Kui see jääb tõeks, jätkab ta itereerimist. Sel näiteks siis, kui numon loop tingimus võrdsete .11False

Veel üks põhiline koodibitt selle paremaks mõistmiseks:

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

Loop tingimus on True, et see hoiab itereerimine - kuni me seadke see False.

Loopimise korral : rakendate plokile muutuja “ num ” ja lause “ for ” kordab selle teie eest. See kood printida sama ajal kood: alates 1 to 10 .

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

Näete? See on nii lihtne. Vahemik algab 1ja läheb kuni kolmanda 11elemendini ( 10on 10th-element).

Nimekiri: kogu | Massiiv | Andmete struktuur

Kujutage ette, et soovite täisarvu 1 muutujasse salvestada. Aga võib-olla soovite nüüd salvestada 2. Ja 3, 4, 5…

Kas mul on veel üks võimalus salvestada kõik soovitud täisarvud, kuid mitte miljonites muutujates ? Sa arvasid seda - nende salvestamiseks on tõepoolest veel üks viis.

Liston kogu, mida saab kasutada väärtuste loendi salvestamiseks (nagu need soovitud täisarvud). Nii et kasutame seda:

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

See on tõesti lihtne. Lõime massiivi ja salvestasime selle saidile my_integer .

Kuid võib-olla küsite: "Kuidas ma saan sellest massiivist väärtust saada?"

Suurepärane küsimus. Liston mõiste nimega indeks . Esimene element saab indeksi 0 (null). Teine saab 1 jne. Sa saad idee.

Selle selgemaks muutmiseks võime massiivi ja kõiki elemente tähistada oma indeksiga. Ma oskan selle joonistada:

Pythoni süntaksit kasutades on seda ka lihtne mõista:

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

Kujutage ette, et te ei soovi täisarvusid salvestada. Tahate lihtsalt salvestada stringe, näiteks oma sugulaste nimede loendit. Minu oma näeks välja umbes selline:

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

See töötab samamoodi nagu täisarvud. Kena.

Saime just teada, kuidas Listsindeksid töötavad. Kuid pean ikkagi teile näitama, kuidas saame Listandmestruktuuri lisada elemendi (üksus loendisse).

Kõige tavalisem meetod a-le uue väärtuse lisamiseks Liston append. Vaatame, kuidas see töötab:

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

appendon ülilihtne. Parameetrina peate lihtsalt rakendama elemendi (nt „ Tõhus insener ”) append.

Noh, piisavalt umbes Lists. Räägime teisest andmestruktuurist.

Sõnastik: võtmeväärtusega andmete struktuur

Nüüd teame, et Listsneed indekseeritakse täisarvudega. Aga mis siis, kui me ei soovi indeksidena kasutada täisarvusid? Mõned andmestruktuurid, mida saame kasutada, on arv-, stringi- või muud tüüpi indeksid.

Tutvume Dictionaryandmestruktuuriga. Dictionaryon võtme-väärtuse paaride kogu. See näeb välja järgmine:

dictionary_example = { "key1": "value1", "key2": "value2", "key3": "value3" }

Võti on indeks, mis osutabväärtus . Kuidas me Dictionaryväärtusele juurde pääseme ? Sa arvasid seda - võtit kasutades . Proovime seda:

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

Ma lõin Dictionaryminust. Minu nimi, hüüdnimi ja kodakondsus. Need atribuudid on Dictionaryvõtmed .

Nagu me õppinud, kuidas pääseda List, kasutades indeksit, me kasutada ka indeksite ( võtmed on Dictionarykontekstis), et pääseda väärtus salvestatakse Dictionary.

Näites printisin enda kohta fraasi, kasutades kõiki rakendusse salvestatud väärtusi Dictionary. Päris lihtne, eks?

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

Kui me seda meetodit nimetame, tagastab see lihtsalt stringi VRRRRUUUUM.

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

Kapseldamine: teabe varjamine

Kapseldamine on mehhanism, mis piirab otsest juurdepääsu objektide andmetele ja meetoditele. Kuid samal ajal hõlbustab see nende andmete (objektide meetodite) kasutamist.

„Kapseldamist saab kasutada andmeliikmete ja liikmete funktsiooni peitmiseks. Selle määratluse all tähendab kapseldamine seda, et objekti sisemine esitus on väljaspool objekti definitsiooni üldiselt varjatud. " - Vikipeedia

Kogu objekti sisemine esitus on väliselt varjatud. Ainult objekt saab oma siseandmetega suhelda.

Esiteks peame mõistma, kuidas publicja non-publiceksemplari muutujad ja meetodid töötavad.

Avaliku astme muutujad

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

Seal me läheme. Määrasime eksemplari muutujale lihtsalt teise väärtuse ( kaio) first_nameja see värskendas väärtust. Nii lihtne. Kuna see on publicmuutuja, saame seda teha.

Muutumatu avaliku astme muutuja

Me ei kasuta siin mõistet “privaatne”, kuna ükski atribuut pole Pythonis tegelikult privaatne (ilma üldiselt tarbetu tööta). - PEP 8

Nagu public instance variable, saame määratleda non-public instance variablemõlemad konstruktori meetodis või klassi sees. Süntaksi erinevus on järgmine: jaoks non-public instance variableskasutage nime ees alljooni ( _) variable.

"" Privaatseid "eksemplari muutujaid, millele pääseb juurde ainult objekti seest, Pythonis pole. Siiski on olemas kokkulepe, mida järgib enamik Pythoni koode: alakriipsuga (nt _spam) eeldeldud nime tuleks käsitleda API mitteavaliku osana (olgu see funktsioon, meetod või andmeliige) ” - Pythoni tarkvara sihtasutus

Siin on näide:

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

Kas nägite emailmuutujat? Nii määratleme non-public variable:

tk = Person('TK', '[email protected]') print(tk._email) # [email protected]
Me saame sellele juurde pääseda ja seda värskendada. Non-public variableson lihtsalt konventsioon ja neid tuleks käsitleda API mitteavaliku osana.

Seega kasutame meetodit, mis võimaldab meil seda teha oma klassi definitsiooni sees. Rakendame selle mõistmiseks kaks meetodit ( emailja update_email):

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

Nüüd saame non-public variablesneid meetodeid kasutades värskendada ja neile juurde pääseda . Vaatame:

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].com tk.update_email('[email protected]') print(tk.email()) # => [email protected]
  1. We initiated a new object with first_name TK and email [email protected]
  2. Printed the email by accessing the non-public variable with a method
  3. Tried to set a new email out of our class
  4. We need to treat non-public variable as non-public part of the API
  5. Updated the non-public variable with our instance method
  6. 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
Me saame sellele juurde pääseda ja seda värskendada. Non-public methodson lihtsalt konventsioon ja neid tuleks käsitleda API mitteavaliku osana.

Siin on näide selle kohta, kuidas seda kasutada:

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

Siin on meil a _get_agenon-public methodja a show_agepublic method. Seda show_agesaab kasutada meie objekt (väljaspool meie klassi) ja _get_ageainus, mida kasutatakse meie klassi definitsioonis ( show_agemeetod sees ). Aga jällegi: kokkuleppena.

Kapseldamise kokkuvõte

Kapseldamise abil saame tagada, et objekti sisemine esitus oleks väljastpoolt varjatud.

Pärand: käitumine ja omadused

Teatud objektidel on mõned ühised jooned: nende käitumine ja omadused.

Näiteks pärisin isalt mõned omadused ja käitumisviisid. Pärisin tema silmad ja juuksed kui omadused ning tema kannatamatuse ja introvertsuse kui käitumise.

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.

Kui soovite täielikku Pythoni kursust, õppige rohkem reaalse maailma kodeerimisoskusi ja koostage projekte, proovige ühe kuu pikkust Pythoni alglaadimist . Kohtumiseni seal ☺

Kui soovite rohkem lugusid ja postitusi oma teekonna õppimise ja programmeerimise valdamise kohta, järgige minu väljaannet The Renaissance Developer .

Lõbutsege, jätkake õppimist ja jätkake kodeerimist.

Minu Twitter ja Github. ☺