Učenje Pythona: od nič do junaka

Najprej, kaj je Python? Po besedah ​​njegovega ustvarjalca Guida van Rossuma je Python:

"Programski jezik na visoki ravni, njegova osnovna filozofija oblikovanja pa je berljivost kode in sintaksa, ki programerjem omogoča, da izrazijo koncepte v nekaj vrsticah kode."

Zame je bil prvi razlog za učenje Pythona ta, da je pravzaprav čudovitprogramski jezik. Res je bilo naravno, da sem vanj kodiral in izrazil svoje misli.

Drug razlog je bil, da lahko kodiranje v Pythonu uporabljamo na več načinov: tukaj se zasvetijo podatkovne vede, spletni razvoj in strojno učenje. Quora, Pinterest in Spotify uporabljajo Python za svoj spletni razvoj. Naučimo se torej malo o tem.

Osnove

1. Spremenljivke

O spremenljivkah lahko razmišljate kot o besedah, ki hranijo vrednost. Tako preprosto.

V Pythonu je zelo enostavno definirati spremenljivko in ji nastaviti vrednost. Predstavljajte si, da želite shraniti številko 1 v spremenljivko, imenovano "ena". Naredimo to:

one = 1

Kako preprosto je bilo to? Pravkar ste spremenljivki "ena" dodelili vrednost 1.

two = 2 some_number = 10000

In katerim koli drugim spremenljivkam lahko dodelite katero koli drugo vrednost . Kot vidite v zgornji tabeli, spremenljivka " dva " shrani celo število 2 , " some_number " pa 10.000 .

Poleg celih števil lahko uporabimo tudi logične vrednosti (True / False), nize, float in toliko drugih vrst podatkov.

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

2. Nadzor toka: pogojni stavki

» Če « uporablja izraz, da oceni, ali je stavek resničen ali neresničen. Če je True, izvrši tisto, kar je znotraj stavka "if". Na primer:

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

2 je večja od 1 , zato se izvede koda za tiskanje .

Stavek " else " se izvrši, če je izraz " if " napačen .

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

1 ni večji od 2 , zato se bo izvedla koda znotraj stavka " else ".

Uporabite lahko tudi izjavo " 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

V Pythonu lahko ponavljamo v različnih oblikah. Govoril bom o dveh: medtemin za .

Medtem ko zanka: medtem ko je stavek True, se bo izvedla koda znotraj bloka. Ta koda bo torej natisnila številko od 1 do 10 .

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

Pa zanka potrebuje " zanke stanje. ”Če ostane True, se ponavlja. V tem primeru, ko numse 11je stanje zanka Rezultat False.

Še en osnovni del kode za boljše razumevanje:

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

Pogoj zanke je Truetako, da se ponavlja - dokler ga ne nastavimo na False.

Za Looping : na blok uporabite spremenljivko " num " in stavek " for " vam jo ponovi. Ta koda bo natisnjena enako kot medtem ko : od 1 do 10 .

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

Vidiš? Tako preprosto je. Obseg se začne z 1in traja do 11elementa th ( 10je 10element th).

Seznam: Zbirka | Matrika | Struktura podatkov

Predstavljajte si, da želite celo število 1 shraniti v spremenljivko. Morda pa zdaj želite shraniti 2. In 3, 4, 5 ...

Ali imam še en način za shranjevanje vseh celih števil, ki jih želim, vendar ne v milijonih spremenljivk ? Uganili ste - res obstaja še en način za njihovo shranjevanje.

Listje zbirka, ki jo lahko uporabite za shranjevanje seznama vrednosti (kot so ta cela števila, ki jih želite). Torej, uporabimo ga:

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

Res je preprosto. Ustvarili smo matriko in jo shranili na my_integer .

Mogoče pa sprašujete: "Kako lahko dobim vrednost iz te matrike?"

Super vprašanje. Listima koncept, imenovan indeks . Prvi element dobi indeks 0 (nič). Drugi dobi 1 in tako naprej. Razumeš idejo.

Da bi bilo bolj jasno, lahko matriko in vsak element predstavimo s svojim indeksom. Lahko ga narišem:

Z uporabo sintakse Python je tudi enostavno razumeti:

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

Predstavljajte si, da ne želite shranjevati celih števil. Samo shraniti želite nize, kot je seznam imen sorodnikov. Moja bi izgledala nekako takole:

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

Deluje enako kot cela števila. Lepo.

Ravno smo izvedeli, kako Listsdelujejo indeksi. A vseeno vam moram pokazati, kako lahko v Listpodatkovno strukturo dodamo element (element na seznam).

Najpogostejši način za dodajanje nove vrednosti a Listje append. Poglejmo, kako deluje:

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

appendje zelo preprosto. Za parameter morate uporabiti le element (npr. " Učinkovit inženir ") append.

No, dovolj o Lists. Pogovorimo se o drugi strukturi podatkov.

Slovar: Struktura podatkov ključ-vrednost

Zdaj vemo, da Listsso indeksirane s celoštevilčnimi številkami. Kaj pa, če ne želimo celih števil uporabljati kot indekse? Nekatere podatkovne strukture, ki jih lahko uporabimo, so številski, nizni ali drugi tipi indeksov.

Spoznajmo Dictionarystrukturo podatkov. Dictionaryje zbirka parov ključ / vrednost. Evo, kako izgleda:

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

Ključ je indeks kaže navrednost . Kako dostopamo do Dictionaryvrednosti ? Uganili ste - s pomočjo ključa . Poskusimo:

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

Ustvaril sem Dictionarypribližno sebe. Moje ime, vzdevek in državljanstvo. Ti atributi so Dictionaryključi .

Ko smo se naučili dostopati do Listuporabljenega indeksa, za dostop do vrednosti, shranjene v datoteki, uporabljamo tudi indekse ( ključe v Dictionarykontekstu) .Dictionary

V primeru sem natisnil stavek o sebi z uporabo vseh vrednosti, shranjenih v Dictionary. Precej preprosto, kajne?

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

Ko pokličemo to metodo, vrne niz » VRRRRUUUUM. "

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

Kapsulacija: skrivanje informacij

Kapsulacija je mehanizem, ki omejuje neposreden dostop do podatkov in metod predmetov. Hkrati pa olajša delovanje s temi podatki (metode predmetov).

“Z enkapsulacijo lahko skrijete podatke in funkcije članov. Po tej definiciji enkapsulacija pomeni, da je notranja predstavitev predmeta na splošno skrita pred očmi zunaj definicije predmeta. " - Wikipedija

Vsa notranja predstavitev predmeta je skrita od zunaj. Samo objekt lahko komunicira s svojimi notranjimi podatki.

Najprej moramo razumeti, kako publicin non-publicprimerkov spremenljivke in metode dela.

Spremenljivke javnega primerka

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

No pa gremo. Pravkar smo nastavili drugo vrednost ( kaio) na first_namespremenljivko primerka in ta vrednost je posodobila. Tako preprosto. Ker gre za publicspremenljivko, lahko to storimo.

Nejavna spremenljivka primerka

Tu ne uporabljamo izraza "zasebno", saj noben atribut v Pythonu ni zares zaseben (brez na splošno nepotrebnega dela). - PEP 8

Kot public instance variablelahko določimo non-public instance variableoboje znotraj metode konstruktorja ali znotraj razreda. Sintaksna razlika je: pred imenom non-public instance variablesuporabite podčrtaj ( _) variable.

"'Zasebne' spremenljivke primerka, do katerih ni mogoče dostopati, razen znotraj predmeta, v Pythonu ne obstajajo. Vendar obstaja konvencija, ki ji sledi večina kode Python: ime s predpono podčrtaja (npr. _spam) Je treba obravnavati kot nejavni del API-ja (ne glede na to, ali gre za funkcijo, metodo ali podatkovnega člana). " - Fundacija za programsko opremo Python

Tu je primer:

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

Ste videli emailspremenljivko? Tako definiramo non-public variable:

tk = Person('TK', '[email protected]') print(tk._email) # [email protected]
Do njega lahko dostopamo in ga posodobimo. Non-public variablesso le dogovor in jih je treba obravnavati kot nejavni del API-ja.

Zato uporabljamo metodo, ki nam omogoča, da to storimo znotraj definicije našega razreda. Uvedimo dve metodi ( emailin update_email) za njegovo razumevanje:

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

Zdaj lahko non-public variableste metode posodabljamo in dostopamo . Pa poglejmo:

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]
  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
Do njega lahko dostopamo in ga posodobimo. Non-public methodsso le dogovor in jih je treba obravnavati kot nejavni del API-ja.

Tu je primer, kako ga lahko uporabimo:

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

Tu imamo a _get_agenon-public methodin a show_agepublic method. show_ageSe naš objekt lahko uporablja (iz našega razreda), in _get_agese uporablja samo znotraj našega razreda definiciji (znotraj show_agemetoda). Ampak še enkrat: po dogovoru.

Povzetek enkapsulacije

Z enkapsulacijo lahko zagotovimo, da je notranja predstavitev predmeta skrita od zunaj.

Dedovanje: vedenje in značilnosti

Nekaterim predmetom je skupno nekaj: njihovo vedenje in značilnosti.

Na primer, nekatere značilnosti in vedenja sem podedoval po očetu. Podedoval sem njegove oči in lase kot značilnosti, njegovo nestrpnost in zaprtost pa kot vedenje.

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.

Če želite popoln tečaj za Python, se naučite več resničnih veščin kodiranja in gradite projekte, poskusite enomesečni Python Bootcamp . Se vidimo ☺

Za več zgodb in objav o mojem učenju in obvladovanju programov spremljajte mojo publikacijo The Renaissance Developer .

Zabavajte se, nadaljujte z učenjem in vedno kodirajte.

Moj Twitter in Github. ☺