Python - отличный инструмент для науки о данных. Его очень легко читать и работать, и в нем есть множество ресурсов, на которых можно учиться. Если вы где-то застряли, в Интернете есть большое сообщество, которое поможет вам. У него масса преимуществ:
- Это открытый исходный код, то есть он полностью бесплатный.
- Создавать пакеты с помощью Python очень просто, особенно для науки о данных.
- В нем есть отличные библиотеки, такие как numpy, pandas и т. Д., Которые, в частности, предназначены для улучшения анализа данных.
В этом блоге я хотел бы познакомить вас с базовым синтаксисом Python и некоторыми конкретными функциями и методами, присущими Data Science, которые упрощают работу.
Я бы использовал Python 3 и J upyter notebook, чтобы продемонстрировать свою работу. Его можно скачать по предоставленной ссылке.
Основы Python
Python полностью совместим с математическими операциями. Он хорошо подходит для выполнения основных операций, таких как сложение, вычитание, умножение и деление. Он также выполняет некоторые сложные операции, такие как возведение в степень и по модулю. Это показано в блокноте jupyter ниже.
Переменные
Чтобы эффективно использовать эти вычисления, Python позволяет сохранять их в переменных, которые определяются с использованием конкретного имени, чувствительного к регистру. Присвоение значений переменной и использование их для расчета делают код воспроизводимым.
type()
функция
Python поддерживает несколько различных типов переменных, включая integer
, float
, string
, bool
и многие другие. Вы можете проверить тип переменной с помощью функции type()
в любой точке программы.
Операторы конкатенации
С разными типами переменных операции выполняются по-разному. Две интересные операции - это операторы «+
» и «*
», широко известные как операторы конкатенации. Мы уже обсуждали, как они действуют при использовании с числовыми типами данных. Но как они действуют при использовании со строковым типом данных.
Оператор ‘+
’ принимает две строки в качестве операнда и объединяет их без пробелов в качестве вывода. С другой стороны, оператор ‘*
’ принимает строку и целочисленное значение в качестве операндов и выводит строку, повторяющуюся целое число раз.
Списки
Python предоставляет немного сложный тип данных, известный как список. Список можно использовать для хранения более одного значения. Он определяется с помощью квадратных скобок. Он может содержать вместе элементы разных типов данных. Список также может содержать сам список. Чтобы получить доступ к любому элементу списка, вы можете просто написать его имя, а затем индекс элемента в квадратных скобках.
Списки в python могут быть нарезаны и могут быть полезны при выборе сразу нескольких значений из списка. Нарезку можно выполнить, указав имя списка, за которым следуют начальная и конечная позиции, разделенные двоеточием в квадратных скобках.
list_name[start:end]
Здесь start
включен, а end
- нет.
Значения start
и end
также могут быть отрицательными. Если значения для start
и end
не указаны, Python выберет все элементы из списка. Это показано в файле jupyter ниже:
Управление элементами списка
Управление элементами списка включает три вещи:
- Изменение элемента списка: это можно сделать с помощью оператора присваивания. Вы можете изменить более одного элемента, используя технику нарезки списка.
- Добавление элемента в список. Добавление элемента можно выполнить с помощью оператора «
+
». - Удаление элемента списка: элемент можно удалить, передав его в качестве аргумента в функции
del()
.
Некоторые функции и методы могут быть выполнены со списками, чтобы получить из них эффективную информацию. Некоторые из наиболее распространенных из них перечислены ниже:
max()
: эта функция при применении к списку возвращает максимальный элемент из списка. Например,height = [1.68, 1.71, 1.55, 1.72, 1.82]
- это наш список, тогдаmax(height)
вернет1.82
в качестве вывода.round()
: эта функция принимает два аргумента: число и целое число. Затем он округлит это число до точности, указанной целым числом. Например,round(height[3],1)
вернет1.7
. Если второй аргумент не указан, он будет округлен до ближайшего целого значения.index()
: Этот метод используется для получения индекса определенного элемента в списке. Например,height.index(1.72)
вернет3
. Если элемент появляется несколько раз, он вернет позицию при первом появлении.count()
: он возвращает количество раз, когда элемент появляется в списке. Например,height.count(1.72)
вернет1
.
Существует множество функций и методов, облегчающих нашу работу с python. Вы можете ознакомиться с документацией здесь.
Кортежи
Как и list, Python предлагает так называемый кортеж. Он очень похож на список, с той разницей, что кортеж представляет собой набор неизменяемых объектов, тогда как объект списка является изменяемым. Кортеж создается путем помещения всех объектов в ()
. Например, tupl = (1,2,4.8,'hello')
.
Доступ к элементам кортежа
Доступ к элементам кортежа можно получить, индексируя его аналогично списку. Он также поддерживает отрицательную индексацию. Доступ к нескольким элементам можно получить с помощью нарезки.
tupl = (1,2,4.8,'hello') print(tupl) # Accessing tuple elements via indexing print(tupl[3]) # Accessing the same element using negative indexing print(tupl[-1]) # Acceesng multiple elements using slicing print(tupl[2:4])
Выход:
(1, 2, 4.8, 'hello') hello hello (4.8, 'hello')
Распаковка кортежа
Распаковка кортежа производится следующими способами:
my_tuple = (1, 2, 4.8, "hello") print(my_tuple) # tuple unpacking a, b, c, d = my_tuple print(a) print(b) print(c) print(d)
Выход:
(1, 2, 4.8, 'hello') 1 2 4.8 hello
Пользовательские функции
Мгновение назад мы обсуждали встроенные функции Python. Теперь посмотрим, как определить собственную функцию. Определение нашей собственной функции пригодится несколько раз. Нам не придется писать один и тот же фрагмент кода снова и снова, плюс это делает наш код воспроизводимым. Простую функцию в Python можно определить следующим образом:
def function_names(parameter1, parameter2,...): body statements ... ... return value
Функция может либо не принимать никаких параметров, либо принимать несколько параметров. Он также может ссылаться на другую функцию и на себя. Использование функций в коде - хорошее упражнение, если один и тот же или похожий фрагмент кода повторяется несколько раз.
Как только функция определена, вы можете вызвать ее, написав ее имя, за которым следует значение параметров, то есть аргументы. Ниже определена функция square()
, которая принимает один параметр и возвращает его квадрат:
#function definition def square(number): squared = number**2 return squared #calling function num = square(5) print(str(num)+'is the square of 5')
Выход:
25 is the square of 5
Как вы уже могли понять, в чем полезность function. Чтобы сделать его еще лучше, вы можете использовать кортеж для возврата нескольких значений. Например, :
#function definition def sum_multiple(number1, number2): sum = number1 + number2 multiple = number1*number2 result = (sum, multiple) # packing values with tuple return result #calling function summation, multiplication = sum_multiple(5,8) # unpacking print('Summation:'+str(summation)+' Multiplication: '+str(multiplication))
Выход:
Summation:13 Multiplication: 40
Вложенные функции
Функция может быть вложена в другую. Демонстрация показана ниже:
#function definition def sm(number1, number2): def sm_nested(number1, number2): sm = number1 + number2 print(sm) sm_nested(number1, number2) #calling function sm(5,8)
Выход:
13
Аргументы
Python поддерживает гибкие аргументы для функций. Это можно сделать, добавив *
перед параметром и **
, если это аргумент ключевого слова.
#function definition def summation(*args): sm=0 for num in args: sm+=num print(sm) #calling function summation(1) #one argument summation(1,2) #two argument summation(1,2,3,4,5) #five argument
Выход:
1 3 15
Лямбда-функция
Теперь мы поговорим об одной из моих любимых вещей в Python, которую я, как специалист по данным, люблю все время использовать, - лямбда-функции. Его рекомендуется использовать только тогда, когда у вас есть хорошая практика, поскольку это снижает читаемость кода. Простые функции могут быть написаны с использованием лямбда-функции, чтобы уменьшить количество строк кода. Например,
power = lambda x, y: x ** y # a function that calculates power power(2, 3)
Вышеупомянутая строка кода выведет 8
.
В некоторых случаях лямбда-функция используется с map()
для встраивания простых функций в более крупные выражения. map()
всегда используется для объектов Python, например list. Он принимает два аргумента: функцию и объект. Например,
x = [1,2,3,4,5] y = map(lambda a: a**2, x) print(y) print(list(y))
Выход:
<map object at 0x00E289B0> [1, 4, 9, 16, 25]
Лямбда-функцию также можно комбинировать с другими функциями, такими как filter()
и reduce()
, чтобы сделать ее более эффективной. Помните, что все эти функции применимы к объектам Python, а не сами по себе.
Итераторы
Как следует из названия, итераторы помогают перемещаться по объектам Python, которые итерируемы. Он может включать список, строку, объект диапазона, словарь и т. Д. Итерация - это объект, который в качестве iter()
метода может быть применен к нему для создания итератора. Итератор - это объект, с которым связан next()
метод, который можно применить для создания следующего элемента итерации. Например,
name = 'Mark' itr = iter(name) print(next(itr)) print(next(itr)) print(next(itr)) print(next(itr))
Выход:
M a r k
Другой next()
метод на itr
вызовет ошибку:
-------------------------------------------------------------------- StopIteration Traceback (most recent call last) <ipython-input-8-6119ae216990> in <module> ----> 1 print(next(itr)) StopIteration:
В приведенном выше примере все элементы строки итерируемой можно обойти с помощью оператора *
.
print(*itr)
выдаст M a r k
на выходе.
Аналогичным образом итераторы можно использовать для словарей и файловых объектов.
Теперь мы рассмотрим две очень важные функции, которые используются с итерациями для продуктивного вывода:
enumerate()
: enumerate()
принимает в качестве аргумента итерацию ab, такую как список или кортеж, и возвращает специальный объект перечисления, который дает пару, содержащую элемент списка вместе с их индексом в этой итерации. Например:
name = ['Mark', 'Adam', 'Austin', 'Jay'] enum = enumerate(name) print(enum)
Это выведет: <enumerate object at 0x05F7DA30>
Чтобы получить пару элемент и индекс, нам нужно будет привести тип объекта перечисления в список с list()
.
print(list(enum))
выведет:
[(0, 'Mark'), (1, 'Adam'), (2, 'Austin'), (3, 'Jay')]
zip()
: он принимает произвольное количество итераций и возвращает итератор кортежей, то есть:
f_name = ['Mark', 'Austin', 'Ben'] l_name = ['Adams', 'Jay', 'Fernando'] z = zip(f_name,l_name) print(list(z))
Выход:
[('Mark', 'Adams'), ('Austin', 'Jay'), ('Ben', 'Fernando')]
Мы можем использовать цикл for для перебора zip-объекта и печати кортежей:
f_name = ['Mark', 'Austin', 'Ben'] l_name = ['Adams', 'Jay', 'Fernando'] z = zip(f_name,l_name) for z1, z2 in z: print(z1,z2)
Выход:
Mark Adams Austin Jay Ben Fernando
Понимание списка
Понимание списка - это метод создания нового списка с использованием существующего списка. Это очень элегантный стиль кодирования, благодаря которому наш код выглядит намного умнее. Его синтаксис следующий:
[expression for item in object]
В имени есть список, но объектом может быть что угодно: список, строка, объект диапазона или словарь. Ниже показано простое использование понимания списка:
num = [1, 2 , 3, 4, 5] num_sq = [x**2 for x in num] print(num_sq)
Выход:
[1, 4, 9, 16, 25]
Понимание списка также может использоваться во вложенных циклах:
num_sq = [(x,y) for x in range(2) for y in range(3)] print(num_sq)
Выход:
[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2)]
Условные выражения также можно использовать в понимании списков:
num = [1,2,3,4,5,6,7] num_2 = [x if x>3 else -1 for x in num] num_2
Выход:
[-1, -1, -1, 4, 5, 6, 7]
Объекты-генераторы
В квадратных скобках мы определили понимание списка. Если мы заменим квадратные скобки круглыми скобками, мы получим объекты генератора. Объекты генератора почти похожи на понимание списка, за исключением того факта, что он не хранит список списка в памяти, но является итерируемым, то есть его можно повторять для создания элемента списка.
num = [1,2,3,4,5,6,7] num_2 = (x**2 for x in num) print(num_2)
Приведенный выше код даст результат как <generator object <genexpr> at 0x05F34C30>
. Чтобы напечатать его элемент, мы можем либо привести его к списку, либо выполнить итерацию с помощью цикла for. Последний способ является более предпочтительным и полезным:
for x in num_2: print(x)
Выходы:
1 4 9 16 25 36 49
Функцию генератора также можно определить так же, как и любую другую функцию, но заменив ключевое слово return
на yield
.
Это был довольно длинный блог, но он обладал необходимыми знаниями Python, которые необходимы для начала карьеры в области науки о данных. По крайней мере, вы должны знать перечисленные выше функции и методы, чтобы эффективно изучать другие алгоритмы и методы машинного обучения. Отдыхайте, все дело в практике и как можно раньше использовать этот синтаксис.
Я не говорил о словарях, которые представляют собой очень мощный инструмент, предоставляемый python для улучшения обработки данных. Я расскажу о них в своем следующем блоге, который будет кратко о библиотеках Numpy и Matplot. Это был бы небольшой блог, чтобы вы познакомились, чтобы у вас не возникло проблем, когда я буду писать о сложных алгоритмах машинного обучения и их приложениях.
Я старался максимально упростить и продемонстрировал большинство из них. Надеюсь, этот блог помог вам познакомиться с Python.