Mokymasis „Python“: nuo nulio iki herojaus

Visų pirma, kas yra „Python“? Pasak jo kūrėjo Guido van Rossumo, „Python“ yra:

„Aukšto lygio programavimo kalba ir jos pagrindinė dizaino filosofija yra susijusi su kodo įskaitomumu ir sintakse, leidžiančia programuotojams išreikšti sąvokas keliomis kodo eilutėmis.“

Pirmoji priežastis išmokti „Python“ man buvo ta, kad ji iš tikrųjų yra gražiprogramavimo kalba. Buvo tikrai natūralu joje užkoduoti ir išsakyti mintis.

Kita priežastis buvo ta, kad „Python“ kodavimą galime naudoti keliais būdais: čia viskas šviečia duomenų mokslas, interneto svetainių kūrimas ir mašininis mokymasis. „Quora“, „Pinterest“ ir „Spotify“ visi naudoja „Python“ kurdami savo vidinę programą. Taigi sužinokime apie tai šiek tiek.

Pagrindai

1. Kintamieji

Galite galvoti apie kintamuosius kaip apie žodžius, kuriuose saugoma vertė. Paprasta.

„Python“ yra labai lengva apibrėžti kintamąjį ir nustatyti jo vertę. Įsivaizduokite, kad norite išsaugoti skaičių 1 kintamajame, vadinamame „vienas“. Padarykime tai:

one = 1

Ar tai buvo paprasta? Jūs ką tik priskyrėte 1 reikšmę kintamajam „vienas“.

two = 2 some_number = 10000

Ir bet kokiems kitiems kintamiesiems galite priskirti bet kokią kitą vertę . Kaip matote aukščiau pateiktoje lentelėje, kintamasis „ duįrašo sveikąjį skaičių 2 , o „ kai_skaičius “ - 10 000 .

Be sveikųjų skaičių, mes taip pat galime naudoti logines reikšmes (True / False), eilutes, float ir tiek daug kitų duomenų tipų.

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

2. Kontrolės srautas: sąlyginiai teiginiai

Jei “ naudoja išraišką, kad įvertintų, ar teiginys yra teisingas, ar klaidingas. Jei tai tiesa, ji vykdo tai, kas yra sakinyje „jei“. Pavyzdžiui:

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

2 yra didesnis nei 1 , todėl vykdomas „ spausdinimo “ kodas.

Teiginys „ else “ bus vykdomas, jei išraiška „ if “ yra klaidinga .

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

1 yra ne didesnis kaip 2 , todėl kodas „ else “ viduje bus vykdomas.

Taip pat galite naudoti teiginį „ 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

„Python“ galime kartoti įvairiomis formomis. Aš kalbėsiu apie du: oir .

Looping“: nors teiginys yra „True“, bloke esantis kodas bus vykdomas. Taigi, šis kodas išspausdins skaičių nuo 1 iki 10 .

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

While“ kilpai reikalinga „ kilpos sąlyga. “Jei tai išlieka tiesa, ji kartojasi toliau. Šiame pavyzdyje, kai numyra 11su kilpa Būklė lygu False.

Kitas pagrindinis bitų kodas, kad geriau jį suprastumėte:

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

Kilpa sąlyga yra True, kad ji išlaiko Iteracja - kol mes nustatyti, kad jis False.

Looping : blokui pritaikote kintamąjį „ num “, o sakinys „ for “ pakartos jį už jus. Šis kodas bus atspausdintas taip pat, kaip ir kodas: nuo 1 iki 10 .

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

Pamatyti? Tai taip paprasta. Diapazonas prasideda 1ir eina iki 11th elemento ( 10yra 10th elementas).

Sąrašas: Kolekcija Masyvas | Duomenų struktūra

Įsivaizduokite, kad norite išsaugoti sveikąjį skaičių 1 kintamajame. Bet galbūt dabar norite išsaugoti 2. Ir 3, 4, 5…

Ar galiu kitaip išsaugoti visus norimus skaičius, bet ne milijonais kintamųjų ? Jūs atspėjote - iš tikrųjų yra dar vienas būdas juos laikyti.

Listyra kolekcija, kurią galima naudoti vertybių sąrašui (pvz., šiems norimiems sveikiesiems skaičiams) išsaugoti. Taigi naudokime:

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

Tai tikrai paprasta. Sukūrėme masyvą ir išsaugojome jį „ my_integer“ .

Bet galbūt jūs klausiate: „Kaip galėčiau gauti vertę iš šio masyvo?“

Puikus klausimas. Listturi sąvoką, vadinamą indeksu . Pirmasis elementas gauna indeksą 0 (nulis). Antrasis gauna 1 ir t. Jūs suprantate idėją.

Kad būtų aiškiau, galime pavaizduoti masyvą ir kiekvieną elementą su jo indeksu. Aš galiu jį nupiešti:

Naudojant „Python“ sintaksę, taip pat lengva suprasti:

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

Įsivaizduokite, kad nenorite saugoti sveikųjų skaičių. Tiesiog norite išsaugoti eilutes, pavyzdžiui, savo giminaičių vardų sąrašą. Mano atrodys maždaug taip:

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

Tai veikia taip pat, kaip sveikieji skaičiai. Malonu.

Mes ką tik sužinojome, kaip veikia Listsindeksai. Bet aš vis tiek turiu jums parodyti, kaip mes galime pridėti elementą prie Listduomenų struktūros (elementą į sąrašą).

Dažniausias būdas pridėti naują vertę Listyra append. Pažiūrėkime, kaip tai veikia:

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

appendyra labai paprasta. Jums tiesiog reikia taikyti elementą (pvz., „ Efektyvus inžinierius “) kaip appendparametrą.

Na, pakankamai apie Lists. Pakalbėkime apie kitą duomenų struktūrą.

Žodynas: Pagrindinės vertės duomenų struktūra

Dabar mes žinome, kad Listsjie indeksuojami sveikaisiais skaičiais. Bet ką daryti, jei nenorime naudoti sveikųjų skaičių kaip indeksų? Kai kurios duomenų struktūros, kurias galime naudoti, yra skaitiniai, eilutiniai ar kitokio tipo indeksai.

Sužinokime apie Dictionaryduomenų struktūrą. Dictionaryyra raktų ir verčių porų rinkinys. Štai kaip tai atrodo:

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

Raktas yra indeksas nukreipta įvertė . Kaip mes pasiekiame Dictionaryvertę ? Jūs atspėjote - naudodamiesi raktu . Pamėginkime:

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

Aš sukūriau Dictionaryapie mane. Mano vardas, slapyvardis ir tautybė. Tie atributai yra Dictionaryraktai .

Kaip mes sužinojome, kaip pasiekti Listnaudojant indeksą, mes taip pat naudoti indeksai ( raktus į Dictionarykontekstą) ir atidarykite vertę saugomi Dictionary.

Pavyzdyje išspausdinau frazę apie mane, naudodamas visas aplanke saugomas reikšmes Dictionary. Gana paprasta, tiesa?

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

Kai mes vadiname šį metodą, jis tiesiog pateikia eilutę VRRRRUUUUM.

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

Kapsuliavimas: informacijos slėpimas

Kapsuliavimas yra mechanizmas, ribojantis tiesioginę prieigą prie objektų duomenų ir metodų. Bet tuo pačiu metu tai palengvina tų duomenų (objektų metodų) valdymą.

„Kapsuliacija gali būti naudojama paslėpti duomenų narius ir narių funkcijas. Pagal šį apibrėžimą kapsuliavimas reiškia, kad objekto vidinis vaizdavimas paprastai yra paslėptas nuo žvilgsnio už objekto apibrėžimo ribų “. - Vikipedija

Visas vidinis objekto vaizdavimas yra paslėptas iš išorės. Tik objektas gali sąveikauti su savo vidiniais duomenimis.

Pirma, mes turime suprasti, kaip publicir non-publicegzempliorių kintamieji ir metodai veikia.

Viešosios instancijos kintamieji

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

Ten mes einame. Tiesiog nustatėme kitą reikšmę ( kaio) first_nameegzemplioriaus kintamajam ir ji atnaujino vertę. Paprasta. Kadangi tai yra publickintamasis, mes galime tai padaryti.

Ne viešosios instancijos kintamasis

Čia nenaudojame termino „privatus“, nes „Python“ joks atributas nėra privatus (be paprastai nereikalingo darbo kiekio). - PEP 8

Kadangi public instance variable, mes galime apibrėžti non-public instance variabletiek konstruktorius būdą arba per klasę. Sintaksės skirtumas yra toks: prieš vardą non-public instance variablesnaudokite pabraukimą ( _) variable.

„Python nėra„ privačių “egzempliorių kintamųjų, prie kurių negalima pasiekti, išskyrus iš objekto vidaus. Tačiau egzistuoja sutartis, kurios laikosi dauguma „Python“ kodų: vardas, prieš kurį pažymėtas pabraukimas (pvz., _spamTurėtų būti traktuojamas kaip nevieša API dalis (nesvarbu, ar tai funkcija, ar metodas, ar duomenų narys) “. - „Python“ programinės įrangos fondas

Štai pavyzdys:

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

Ar matėte emailkintamąjį? Štai kaip mes apibūdiname non-public variable:

tk = Person('TK', '[email protected]') print(tk._email) # [email protected]
Mes galime jį pasiekti ir atnaujinti. Non-public variablesyra tik konvencija ir turėtų būti traktuojama kaip nevieša API dalis.

Taigi mes naudojame metodą, kuris leidžia mums tai padaryti pagal klasės apibrėžimą. Įgyvendinkime du metodus ( emailir update_email), kad tai suprastume:

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

Dabar mes galime atnaujinti ir pasiekti non-public variablesnaudodami tuos metodus. Pažiūrėkime:

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
Mes galime jį pasiekti ir atnaujinti. Non-public methodsyra tik konvencija ir turėtų būti traktuojama kaip nevieša API dalis.

Štai pavyzdys, kaip mes galime jį naudoti:

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

Čia mes turime _get_agenon-public methodir a show_agepublic method. Tai show_agegali naudoti mūsų objektas (ne mūsų klasėje) ir _get_agevienintelis naudojamas mūsų klasės apibrėžime (viduje show_agemetodas). Bet dar kartą: kaip susitarimo reikalas.

Kapsuliavimo santrauka

Apkapsuliavę galime užtikrinti, kad objekto vidinis vaizdavimas būtų paslėptas iš išorės.

Paveldėjimas: elgesys ir savybės

Tam tikrus daiktus sieja keli dalykai: jų elgesys ir savybės.

Pavyzdžiui, kai kurias savybes ir elgesį paveldėjau iš tėvo. Aš paveldėjau jo akis ir plaukus kaip savybes, o jo nekantrumą ir uždarumą - kaip elgesį.

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.

Jei norite baigti „Python“ kursus, sužinokite daugiau realaus pasaulio kodavimo įgūdžių ir kurkite projektus, išbandykite „ One Month Python Bootcamp“ . Iki pasimatymo ten ☺

Norėdami sužinoti daugiau istorijų ir įrašų apie savo kelionių mokymąsi ir programavimo įvaldymą, skaitykite mano leidinį „ The Renaissance Developer“ .

Smagiai praleiskite laiką, mokykitės ir visada koduokite.

Mano „Twitter“ ir „Github“. ☺