Прежде всего, что такое Python? По словам его создателя Гвидо ван Россума, Python-это:
“язык программирования высокого уровня и его основная философия дизайна-это читаемость кода и синтаксис, который позволяет программистам выражать концепции в нескольких строках кода.”
Для меня первой причиной изучения Python было то, что это, по сути, прекрасный язык программирования. Было действительно естественно кодировать в нем и выражать свои мысли.
Другая причина заключалась в том, что мы можем использовать кодирование на Python несколькими способами: наука о данных, веб-разработка и машинное обучение-все это блестит здесь. Quora, Pinterest и Spotify используют Python для своей внутренней веб-разработки. Так что давайте немного об этом узнаем.
Основы
1. Переменные
Вы можете думать о переменных как о словах, которые хранят значение. Все очень просто.
В Python очень легко определить переменную и задать ей значение. Представьте, что вы хотите сохранить число 1 в переменной под названием “один.” Давайте сделаем это:
one = 1
Насколько это было просто? Вы только что присвоили значение 1 переменной “один.”
two = 2 some_number = 10000
И вы можете присвоить любое другое значение любым другим переменным , которые вы хотите. Как вы видите в таблице выше, переменная ” two “хранит целое число 2 , и” some_number ” магазины 10,000 .
Помимо целых чисел, мы также можем использовать логические значения (True/False), строки, float и многие другие типы данных.
# booleans true_boolean = True false_boolean = False # string my_name = "Leandro Tk" # float book_price = 15.80
2. Поток управления: условные операторы
” If ” использует выражение для оценки того, является ли утверждение истинным или ложным. Если это правда, он выполняет то, что находится внутри оператора “if”. Например:
if True:
print("Hello Python If")
if 2 > 1:
print("2 is greater than 1")
2 больше, чем 1 , таким образом, выполняется код ” print “.
Оператор ” else “будет выполнен, если выражение” if ” имеет значение false .
if 1 > 2:
print("1 is greater than 2")
else:
print("1 is not greater than 2")
1 не больше, чем 2 , таким образом, код внутри оператора ” else ” будет выполнен.
Вы также можете использовать оператор ” 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. Зацикливание/Итератор
В Python мы можем выполнять итерации в различных формах. Я расскажу о двух: while и for .
While Looping: пока оператор истинен, код внутри блока будет выполнен. Итак, этот код выведет номер из 1 чтобы 10 .
num = 1
while num <= 10:
print(num)
num += 1
Цикл while нуждается в состоянии ” loop”. ” Если он остается верным, он продолжает повторяться. В этом примере, когда num 11 условие цикла равно False .
Еще один базовый бит кода, чтобы лучше понять его:
loop_condition = True
while loop_condition:
print("Loop Condition keeps: %s" %(loop_condition))
loop_condition = False
Условие цикла равно True , поэтому оно продолжает повторяться — пока мы не установим его в False .
Для цикла : вы применяете переменную ” num “к блоку, и оператор” for ” будет повторять ее за вас. Этот код будет напечатан так же, как while code: from 1 чтобы 10 .
for i in range(1, 11): print(i)
Видишь? Это так просто. Диапазон начинается с 1 и идет до тех пор, пока 11 th элемент ( 10 является ли 10 го элемента).
Список: Коллекция | Массив | Структура данных
Представьте, что вы хотите сохранить целое число 1 в переменной. Но, может быть, теперь вы хотите сохранить 2. И 3, 4, 5 …
Есть ли у меня другой способ хранить все целые числа, которые я хочу, но не в миллионах переменных ? Вы уже догадались — есть действительно другой способ их хранения.
List – это коллекция, которая может быть использована для хранения списка значений (например, этих целых чисел, которые вы хотите). Так что давайте использовать его:
my_integers = [1, 2, 3, 4, 5]
Это действительно просто. Мы создали массив и сохранили его на my_integer .
Но, может быть, вы спрашиваете: “Как я могу получить значение из этого массива?”
Отличный вопрос. List имеет понятие, называемое index . Первый элемент получает индекс 0 (ноль). Второй получает 1, и так далее. Вы поняли идею.
Чтобы было понятнее, мы можем представить массив и каждый элемент с его индексом. Я могу его нарисовать:
Используя синтаксис Python, его также легко понять:
my_integers = [5, 7, 1, 3, 4] print(my_integers[0]) # 5 print(my_integers[1]) # 7 print(my_integers[4]) # 4
Представьте, что вы не хотите хранить целые числа. Вы просто хотите хранить строки, как список имен ваших родственников. Мой будет выглядеть примерно так:
relatives_names = [ "Toshiaki", "Juliana", "Yuji", "Bruno", "Kaio" ] print(relatives_names[4]) # Kaio
Он работает так же, как и целые числа. Ницца.
Мы только что узнали, как работают Списки индексы. Но мне все равно нужно показать вам, как мы можем добавить элемент в структуру данных List (элемент в список).
Наиболее распространенным методом добавления нового значения в List является append . Давайте посмотрим, как это работает:
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 .
Ну, хватит о Списках . Давайте поговорим о другой структуре данных.
Словарь: Структура данных Ключ-Значение
Теперь мы знаем, что Списки индексируются целыми числами. Но что, если мы не хотим использовать целые числа в качестве индексов? Некоторые структуры данных, которые мы можем использовать, являются числовыми, строковыми или другими типами индексов.
Давайте познакомимся со структурой данных Dictionary . Словарь – это набор пар ключ-значение. Вот как это выглядит:
dictionary_example = {
"key1": "value1",
"key2": "value2",
"key3": "value3"
}
Ключ – это индекс, указывающий на значение . Как мы получаем доступ к Словарю | значению ? Вы догадались — с помощью ключа /. Давайте попробуем:
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
Я создал Словарь о себе. Мое имя, прозвище и национальность. Эти атрибуты-это Словарь | ключи .
Поскольку мы научились обращаться к Списку с помощью индекса, мы также используем индексы ( ключи в Словаре контексте) для доступа к значению , хранящемуся в Словаре .
В этом примере я напечатал фразу о себе, используя все значения, хранящиеся в словаре . Довольно просто, правда?
Еще одна интересная вещь о Словаре заключается в том, что мы можем использовать что угодно в качестве значения. В Словаре , который я создал, я хочу добавить ключ “возраст” и мой реальный целочисленный возраст в нем:
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
Здесь у нас есть пара ключ (возраст) значение (24), использующая строку в качестве ключа и целое число в качестве значения .
Как и в случае с Списками , давайте научимся добавлять элементы в Словарь . Ключ , указывающий на значение , является большой частью того, что представляет собой Словарь . Это также верно, когда мы говорим о добавлении элементов к нему:
dictionary_tk = {
"name": "Leandro",
"nickname": "Tk",
"nationality": "Brazilian"
}
dictionary_tk['age'] = 24
print(dictionary_tk) # {'nationality': 'Brazilian', 'age': 24, 'nickname': 'Tk', 'name': 'Leandro'}
Нам просто нужно присвоить значение словарю | ключу . Здесь ведь нет ничего сложного, правда?
Итерация: Циклическое Прохождение Через Структуры Данных
Как мы узнали из Python Basics , итерация List очень проста. Мы Python разработчики обычно используем Для циклирования. Давайте сделаем это:
bookshelf = [
"The Effective Engineer",
"The 4 hours work week",
"Zero to One",
"Lean Startup",
"Hooked"
]
for book in bookshelf:
print(book)
Поэтому для каждой книги на книжной полке мы ( можем делать с ней все ) печатаем ее. Довольно просто и интуитивно понятно. Это Питон.
Для хэш-структуры данных мы также можем использовать цикл form , но мы применяем ключ :
dictionary = { "some_key": "some_value" }
for key in dictionary:
print("%s --> %s" %(key, dictionary[key]))
# some_key --> some_value
Это пример того, как его использовать. Для каждого ключа в словаре мы печатаем ключ и соответствующее ему значение .
Другой способ сделать это-использовать метод iteritems .
dictionary = { "some_key": "some_value" }
for key, value in dictionary.items():
print("%s --> %s" %(key, value))
# some_key --> some_value
Мы назвали эти два параметра как key и value , но это не обязательно. Мы можем назвать их как угодно. Давайте посмотрим:
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
Мы видим , что использовали атрибут в качестве параметра для Словаря | ключа , и он работает правильно. Отлично!
Классы и объекты
Немного теории:
Объекты – это представление объектов реального мира, таких как автомобили, собаки или велосипеды. Объекты имеют две основные характеристики: данные и поведение .
У автомобилей есть данные, такие как количество колес, количество дверей и вместимость сидений, они также демонстрируют поведение : они могут ускоряться, останавливаться, показывать, сколько топлива осталось, и так много других вещей.
Мы идентифицируем данные как атрибуты и поведение как методы в объектно-ориентированном программировании. Снова:
Данные → Атрибуты и поведение → Методы
А Класс – это чертеж, из которого создаются отдельные объекты. В реальном мире мы часто находим много объектов одного и того же типа. Как машины. Все те же марки и модели (и у всех есть двигатель, колеса, двери и так далее). Каждый автомобиль был построен из одного и того же набора чертежей и имеет одни и те же компоненты.
Режим объектно-ориентированного программирования Python: ВКЛ.
Python, как объектно-ориентированный язык программирования, имеет следующие понятия: класс и объект .
Класс-это чертеж, модель для своих объектов.
Итак, опять же, класс-это просто модель или способ определения атрибутов и поведения (как мы говорили в разделе теории). Например, транспортное средство класс имеет свои собственные атрибуты , которые определяют, какие объекты являются транспортными средствами. Количество колес, тип бака, вместимость и максимальная скорость-все это атрибуты транспортного средства.
Имея это в виду, давайте рассмотрим синтаксис Python для классов :
class Vehicle:
pass
Мы определяем классы с помощью оператора class — и все. Легко, не правда ли?
Объекты являются экземплярами класса . Мы создаем экземпляр, называя класс.
car = Vehicle() print(car) # <__main__.Vehicle instance at 0x7fb1de6c2638>
Здесь автомобиль является объектом (или экземпляром) класса | Транспортного средства .
Помните, что наш автомобиль класс имеет четыре атрибута : количество колес, тип бака, вместимость и максимальная скорость. Мы задаем все эти атрибуты при создании транспортного средства объекта . Итак, здесь мы определяем наш класс для получения данных, когда он их инициирует:
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
Мы используем метод init |/. Мы называем его методом конструктора. Поэтому , когда мы создаем транспортное средство объект , мы можем определить эти атрибуты . Представьте себе, что мы любим Tesla Model S, и хотим создать такой объект . Он имеет четыре колеса, работает на электрической энергии, имеет место для пяти сидений, а максимальная скорость составляет 250 км/час (155 миль в час). Давайте создадим этот объект:
tesla_model_s = Vehicle(4, 'electric', 5, 250)
Четыре колеса + электрический “танковый тип” + пять сидений + максимальная скорость 250 км/час.
Все атрибуты заданы. Но как мы можем получить доступ к значениям этих атрибутов? Мы посылаем сообщение объекту с просьбой о них . Мы называем его методом . Это поведение объекта . Давайте его реализуем:
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
Это реализация двух методов: number_of_wheels и set_number_of_wheels . Мы называем его getter & setter . Потому что первый получает значение атрибута, а второй устанавливает новое значение для атрибута.
В Python мы можем сделать это, используя @property ( decorators ) для определения getters и setters . Давайте посмотрим на это с помощью кода:
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
И мы можем использовать эти методы в качестве атрибутов:
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
Это несколько отличается от определения методов. Методы работают как атрибуты. Например, когда мы устанавливаем новое количество колес, мы не применяем два в качестве параметра, а устанавливаем значение 2 в number_of_wheels . Это один из способов написания pythonic | getter и setter кода.
Но мы также можем использовать методы для других вещей, таких как метод ” make_noise “. Давайте посмотрим:
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')
Когда мы вызываем этот метод, он просто возвращает строку “VRRRROOOOOM.”
tesla_model_s = Vehicle(4, 'electric', 5, 250) tesla_model_s.make_noise() # VRUUUUUUUM
Инкапсуляция: Скрытие информации
Инкапсуляция-это механизм, ограничивающий прямой доступ к данным и методам объектов. Но в то же время это облегчает работу с этими данными (методами объектов).
“Инкапсуляция может использоваться для скрытия элементов данных и функций членов. В соответствии с этим определением инкапсуляция означает, что внутреннее представление объекта обычно скрыто от взгляда за пределами определения объекта.” — Википедия
Все внутреннее представление объекта скрыто от внешнего. Только объект может взаимодействовать со своими внутренними данными.
Во-первых, нам нужно понять, как работают переменные и методы экземпляра public и non-public .
Переменные Открытого экземпляра
Для класса Python мы можем инициализировать переменную public instance в нашем методе конструктора. Давайте посмотрим:
Внутри метода конструктора:
class Person:
def __init__(self, first_name):
self.first_name = first_name
Здесь мы применяем значение first_name в качестве аргумента к переменной public instance .
tk = Person('TK')
print(tk.first_name) # => TK
Внутри класса:
class Person:
first_name = 'TK'
Здесь нам не нужно применять first_name в качестве аргумента, и все объекты экземпляра будут иметь атрибут class , инициализированный с помощью TK .
tk = Person() print(tk.first_name) # => TK
Круто. Теперь мы узнали, что можем использовать общедоступные переменные экземпляра и атрибуты класса . Еще одна интересная вещь о части public заключается в том, что мы можем управлять значением переменной. Что я имею в виду? Наш объект может управлять своим переменным значением: Get и Set переменные значения.
Имея в виду класс Person , мы хотим установить другое значение для его переменной first_name :
tk = Person('TK')
tk.first_name = 'Kaio'
print(tk.first_name) # => Kaio
Вот так. Мы просто установили другое значение ( kaio ) в переменную first_name instance, и она обновила это значение. Все очень просто. Поскольку это переменная public , мы можем это сделать.
Непубличная переменная экземпляра
Мы не используем здесь термин “частный”, поскольку ни один атрибут не является действительно частным в Python (без обычно ненужного объема работы). — БОДРОСТЬ ДУХА 8
В качестве переменной public instance мы можем определить переменную non-public instance как в методе конструктора , так и в классе. Синтаксическое различие заключается в следующем: для непубличных переменных экземпляра используйте символ подчеркивания ( _ ) перед именем переменной .
“”Частные” переменные экземпляра, к которым нельзя получить доступ, кроме как изнутри объекта, не существуют в Python. Однако существует соглашение, которому следует большинство кодов Python: имя с префиксом подчеркивания (например, _spam) должно рассматриваться как непубличная часть API (будь то функция, метод или элемент данных)”- Python Software Foundation
Вот пример:
class Person:
def __init__(self, first_name, email):
self.first_name = first_name
self._email = email
Вы видели переменную email ? Вот как мы определяем непубличную переменную :
tk = Person('TK', 'tk@mail.com')
print(tk._email) # tk@mail.com
Мы можем получить доступ и обновить его. Непубличные переменные-это просто соглашение, и их следует рассматривать как непубличную часть API.
Поэтому мы используем метод, который позволяет нам делать это внутри нашего определения класса. Давайте реализуем два метода ( email и 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
Теперь мы можем обновлять и получать доступ к непубличным переменным с помощью этих методов. Давайте посмотрим:
tk = Person('TK', 'tk@mail.com')
print(tk.email()) # => tk@mail.com
tk._email = 'new_tk@mail.com'
print(tk.email()) # => tk@mail.com
tk.update_email('new_tk@mail.com')
print(tk.email()) # => new_tk@mail.com
Публичный Метод
С помощью public methods мы также можем использовать их вне нашего класса:
class Person:
def __init__(self, first_name, age):
self.first_name = first_name
self._age = age
def show_age(self):
return self._age
Давайте проверим это:
tk = Person('TK', 25)
print(tk.show_age()) # => 25
Отлично — мы можем использовать его без каких-либо проблем.
Непубличный Метод
Но с помощью непубличных методов мы не можем этого сделать. Давайте реализуем тот же Person класс, но теперь с помощью show_age /непубличного метода с использованием подчеркивания ( _ ).
class Person:
def __init__(self, first_name, age):
self.first_name = first_name
self._age = age
def _show_age(self):
return self._age
А теперь попробуем вызвать этот непубличный метод с нашим объектом:
tk = Person('TK', 25)
print(tk._show_age()) # => 25
Мы можем получить доступ и обновить его. Непубличные методы-это всего лишь соглашение, и их следует рассматривать как непубличную часть API.
Вот пример того, как мы можем его использовать:
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
Здесь у нас есть _get_age | непубличный метод и show_age | публичный метод . show_age может использоваться нашим объектом (вне нашего класса), а _jet_age используется только внутри вашего определения класса (внутри метода show_age ). Но опять же: в порядке условности.
Резюме инкапсуляции
С помощью инкапсуляции мы можем гарантировать, что внутреннее представление объекта скрыто от внешнего.
Наследование: поведение и характеристики
Некоторые объекты имеют некоторые общие черты: их поведение и характеристики.
Например, я унаследовал некоторые черты характера и поведения от своего отца. Я унаследовал его глаза и волосы как характерные черты, а нетерпение и интровертность-как поведение.
В объектно-ориентированном программировании классы могут наследовать общие характеристики (данные) и поведение (методы) от другого класса.
Давайте рассмотрим другой пример и реализуем его в Python.
Класс Electric Car наследует эти же атрибуты от обычного класса Car .
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
Наш Автомобиль класс реализован:
my_car = Car(4, 5, 250) print(my_car.number_of_wheels) print(my_car.seating_capacity) print(my_car.maximum_velocity)
После инициализации мы можем использовать все переменные экземпляра созданные. Ницца.
В Python мы применяем родительский класс к дочернему классу в качестве параметра. Класс Электромобиль может наследовать от нашего класса Автомобиль .
class ElectricCar(Car):
def __init__(self, number_of_wheels, seating_capacity, maximum_velocity):
Car.__init__(self, number_of_wheels, seating_capacity, maximum_velocity)
Все очень просто. Нам не нужно реализовывать какой-либо другой метод, потому что этот класс уже имеет его (унаследованный от Car class). Давайте докажем это:
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
Красивый.
Вот оно!
Мы узнали много нового об основах Python:
Как работают переменные Python
Как работают условные операторы Python
Как работает цикл Python (while & for)
Как использовать списки: Коллекция | Массив
Коллекция Ключ-Значение словаря
Как мы можем перебирать эти структуры данных
Объекты и классы
Атрибуты как данные объектов
Методы как поведение объектов
Использование Python getters и setters & property decorator
Инкапсуляция: скрытие информации
Наследование: поведение и характеристики
Поздравляю! Вы завершили этот плотный фрагмент контента о Python.
Если вы хотите пройти полный курс Python, узнать больше реальных навыков кодирования и создавать проекты, попробуйте One Month Python Bootcamp . Увидимся там ☺
Для получения дополнительных историй и постов о моем путешествии обучение и освоение программирования, следуйте моей публикации Ренессанс Девелопер .
Получайте удовольствие, продолжайте учиться и всегда продолжайте кодировать.