Python - отличный инструмент для науки о данных. Его очень легко читать и работать, и в нем есть множество ресурсов, на которых можно учиться. Если вы где-то застряли, в Интернете есть большое сообщество, которое поможет вам. У него масса преимуществ:

  1. Это открытый исходный код, то есть он полностью бесплатный.
  2. Создавать пакеты с помощью Python очень просто, особенно для науки о данных.
  3. В нем есть отличные библиотеки, такие как 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 ниже:

Управление элементами списка

Управление элементами списка включает три вещи:

  1. Изменение элемента списка: это можно сделать с помощью оператора присваивания. Вы можете изменить более одного элемента, используя технику нарезки списка.
  2. Добавление элемента в список. Добавление элемента можно выполнить с помощью оператора «+».
  3. Удаление элемента списка: элемент можно удалить, передав его в качестве аргумента в функции del().

Некоторые функции и методы могут быть выполнены со списками, чтобы получить из них эффективную информацию. Некоторые из наиболее распространенных из них перечислены ниже:

  1. max(): эта функция при применении к списку возвращает максимальный элемент из списка. Например, height = [1.68, 1.71, 1.55, 1.72, 1.82] - это наш список, тогда max(height) вернет 1.82 в качестве вывода.
  2. round(): эта функция принимает два аргумента: число и целое число. Затем он округлит это число до точности, указанной целым числом. Например, round(height[3],1) вернет 1.7. Если второй аргумент не указан, он будет округлен до ближайшего целого значения.
  3. index(): Этот метод используется для получения индекса определенного элемента в списке. Например, height.index(1.72) вернет 3. Если элемент появляется несколько раз, он вернет позицию при первом появлении.
  4. 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.