Введение в Python от DataCamp

В прошлом месяце я закончил курс Введение в Python от Hugo Bowne-Anderson, специалиста по данным в DataCamp!.

Введение в Python — это курс, который знакомит с основными понятиями Python. Узнайте, как использовать Python в интерактивном режиме и с помощью сценария. Создайте свои первые переменные и познакомьтесь с основными типами данных Python.

Итак, это резюме моего курса, которое я сделал во время обучения и хотел бы поделиться им со всеми, кто интересуется Python. ;)))

Основы Python

Введение в основные концепции Python. Узнайте, как использовать Python в интерактивном режиме и с помощью сценария. Создайте свои первые переменные и познакомьтесь с основными типами данных Python.

Когда использовать Python?

Python — довольно универсальный язык. Для каких приложений вы можете использовать Python?

Вы хотите сделать некоторые быстрые расчеты.
Для вашего нового бизнеса вы хотите разработать веб-сайт, управляемый базой данных.
Ваш босс просит вас очистить и проанализировать результаты последнего опроса удовлетворенности.

Любой комментарий?

вы можете добавлять комментарии в свои скрипты Python. Комментарии важны для того, чтобы вы и другие могли понять, о чем ваш код.

Чтобы добавить комментарии к вашему скрипту Python, вы можете использовать тег #. Эти комментарии не запускаются как код Python, поэтому они не повлияют на ваш результат.

Python как калькулятор

Python идеально подходит для базовых вычислений. Помимо сложения, вычитания, умножения и деления, также поддерживаются более сложные операции, такие как:

Возведение в степень: * Этот оператор возводит число слева от него в степень числа справа от него. Например, 4**2 даст 16 .
По модулю: % Этот оператор возвращает остаток от деления числа слева на число справа от него. Например, 18 % 7 равно 4.

Переменные

В Python переменная позволяет ссылаться на значение с учетом регистра имени. Чтобы создать переменную, используйте =, как в этом примере:

x = 5

Теперь вы можете использовать имя этой переменной x вместо фактического значения 5.

Помните, что = в Python означает присваивание, а не проверку на равенство!

Типы

int или целое число: число без дробной части.
float, или с плавающей запятой: число, имеющее как целую, так и дробную части, разделенные точкой.
str или строка: тип для представления текста. Вы можете использовать одинарные или двойные кавычки для построения строки.
bool или логическое значение: тип для представления логических значений. Может быть только True или False (большие буквы важны!).

Чтобы узнать тип значения или переменной, которая ссылается на это значение, вы можете использовать функцию type(). Предположим, вы определили переменную a, но забыли тип этой переменной. Чтобы определить тип a, просто выполните:

type(a)

Разные типы ведут себя по-разному в Python. Например, при суммировании двух строк вы получите другое поведение, чем при суммировании двух целых чисел или двух логических значений.

Преобразование типа

Использование оператора + для склеивания двух строк может быть очень полезным при создании пользовательских сообщений.

Предположим, например, что вы рассчитали доход от ваших инвестиций и хотите суммировать результаты в строке. Предполагая, что целое число savings и число с плавающей запятой result определены, вы можете попробовать что-то вроде этого:

print("I started with $" + savings + " and now have $" + result + ". Awesome!")

Однако это не сработает, поскольку вы не можете просто суммировать строки и целые числа/поплавки.

Чтобы исправить ошибку, вам нужно явно преобразовать типы ваших переменных. В частности, вам понадобится str(), чтобы преобразовать значение в строку. str(savings), например, преобразует целое число savings в строку.

Подобные функции, такие как int(), float() и bool(), помогут вам преобразовать значения Python в любой тип.

Списки Python

Научитесь хранить, получать доступ и управлять данными в списках: первый шаг к эффективной работе с огромными объемами данных.

Создать список

В отличие от int, bool и т. д., список представляет собой составной тип данных; вы можете группировать значения вместе:

a = "is"
b = "nice"
my_list = ["my", "list", a, b]

Создать список с разными типами

Список может содержать любой тип Python. Хотя это не очень распространено, список также может содержать смесь типов Python, включая строки, числа с плавающей запятой, логические значения и т. д.

# area variables (in square meters)
hall = 11.25
kit = 18.0
liv = 20.0
bed = 10.75
bath = 9.50
# Adapt list areas
areas = ["hallway", hall, "kitchen", kit, "living room", liv, "bedroom", bed,"bathroom", bath]

Выберите действительный список

Список может содержать любой тип Python. Но сам список также является типом Python. Это означает, что список также может содержать список! Python с каждой минутой становится все забавнее, но не бойтесь, просто запомните синтаксис списка:

my_list = [el1, el2, el3]

Список списков

Как специалист по данным, вы часто будете иметь дело с большим количеством данных, и имеет смысл сгруппировать некоторые из этих данных.

Вместо создания плоского списка, содержащего строки и числа с плавающей запятой, представляющие названия и площади комнат в вашем доме, вы можете создать список списков.

# area variables (in square meters)
hall = 11.25
kit = 18.0
liv = 20.0
bed = 10.75
bath = 9.50
# house information as list of lists
house = [["hallway", hall],
         ["kitchen", kit],
         ["living room", liv],
         ["bedroom", bed],
         ["bathroom", bath]
        ]

Подмножество и завоевание

Подмножество списков Python — это кусок пирога. Возьмите приведенный ниже пример кода, который создает список x, а затем выбирает из него "b". Помните, что это второй элемент, поэтому он имеет индекс 1. Вы также можете использовать отрицательное индексирование.

x = ["a", "b", "c", "d"]
x[1]
x[-3] # same result!

Подмножество и расчет

После того, как вы извлекли значения из списка, вы можете использовать их для выполнения дополнительных вычислений. Возьмем этот пример, где извлекаются второй и четвертый элементы списка x. Полученные строки вставляются вместе с помощью оператора +:

x = ["a", "b", "c", "d"]
print(x[1] + x[3])

Нарезка и нарезка

Выбор отдельных значений из списка — это только часть истории. Также можно нарезать список, что означает выбор нескольких элементов из списка. Используйте следующий синтаксис:

my_list[start:end]

Индекс start будет включен, а индекс end нет.

Пример кода ниже показывает пример. Список с "b" и "c", соответствующий индексам 1 и 2, выбирается из списка x:

x = ["a", "b", "c", "d"]
x[1:3]

Элементы с индексом 1 и 2 включены, а элемент с индексом 3 — нет.

Однако можно и не указывать эти индексы. Если вы не укажете индекс begin, Python определит, что вы хотите начать свой фрагмент в начале списка. Если вы не укажете индекс end, срез будет идти до последнего элемента вашего списка.

x = ["a", "b", "c", "d"]
x[:2]
x[2:]
x[:]

Подмножество списков списков

Вы уже видели, что список Python может содержать практически что угодно; даже другие списки! Чтобы подмножить списки списков, вы можете использовать ту же технику, что и раньше: квадратные скобки.

x = [["a", "b", "c"],
     ["d", "e", "f"],
     ["g", "h", "i"]]
x[2][0]
x[2][:2]

x[2] приводит к списку, который вы можете снова подмножить, добавив дополнительные квадратные скобки.

Заменить элементы списка

Заменить элементы списка довольно просто. Просто подмножьте список и назначьте новые значения подмножеству. Вы можете выбрать отдельные элементы или изменить сразу целые фрагменты списка.

x = ["a", "b", "c", "d"]
x[1] = "r"
x[2:] = ["s", "t"]

Расширить список

Если вы можете изменять элементы в списке, вы наверняка хотите иметь возможность добавлять в него элементы, верно? Вы можете использовать оператор +:

x = ["a", "b", "c", "d"]
y = x + ["e", "f"]

Удалить элементы списка

Наконец, вы также можете удалить элементы из списка. Вы можете сделать это с помощью оператора del:

x = ["a", "b", "c", "d"]
del(x[1])

Обратите внимание: как только вы удаляете элемент из списка, индексы элементов, следующих за удаленным элементом, меняются!

areas = ["hallway", 11.25, "kitchen", 18.0,
        "chill zone", 20.0, "bedroom", 10.75,
         "bathroom", 10.50, "poolhouse", 24.5,
         "garage", 15.45]

Произошла ошибка! Сумма, которую вы выиграли в лотерею, в конце концов, не так уж велика, и похоже, что пула не будет. Вы решаете удалить соответствующую строку и float из списка areas.

del(areas[-4:-2])

Знак ; используется для размещения команд в одной строке. Следующие два фрагмента кода эквивалентны:

# Same line
command1; command2
# Separate lines
command1
command2

Внутренняя работа списков

Код Python в скрипте уже создает список с именем areas и копию с именем areas_copy. Затем изменяется первый элемент в списке areas_copy и распечатывается список areas. Если вы нажмете Выполнить код, вы увидите, что хотя вы изменили areas_copy, это изменение также вступит в силу в списке areas. Это потому, что areas и areas_copy указывают на один и тот же список.

# Create list areas
areas = [11.25, 18.0, 20.0, 10.75, 9.50]
# Create areas_copy
areas_copy = areas
# Change areas_copy
areas_copy[0] = 5.0
# Print areas
print(areas)
> Result    [5.0, 18.0, 20.0, 10.75, 9.5]

Если вы хотите, чтобы изменения в areas_copy не вступали в силу в areas, вам придется сделать более явную копию списка areas. Вы можете сделать это с помощью [list()](https://docs.python.org/3/library/functions.html#func-list) или с помощью [:].

# Create list areas
areas = [11.25, 18.0, 20.0, 10.75, 9.50]
# Create areas_copy
areas_copy = areas[:]
# Change areas_copy
areas_copy[0] = 5.0
# Print areas
print(areas)
> Result    [11.25, 18.0, 20.0, 10.75, 9.5]

Функции и пакеты

Вы узнаете, как использовать функции, методы и пакеты для эффективного использования кода, написанного блестящими разработчиками Python. Цель состоит в том, чтобы уменьшить количество кода, необходимого для решения сложных задач!

Знакомые функции

По умолчанию Python предлагает множество встроенных функций, которые упростят вашу жизнь специалиста по обработке и анализу данных. Вы уже знаете две такие функции: print() и type(). Вы также использовали функции str(), int(), bool() и float() для переключения между типами данных. Это тоже встроенные функции.

Вызов функции прост. Чтобы получить тип 3.0 и сохранить вывод в виде новой переменной result, вы можете использовать следующее:

result = type(3.0)

Общий рецепт вызова функций и сохранения результата в переменной таков:

output = function_name(input)

Помощь!

Возможно, вы уже знаете название функции Python, но вам все еще нужно понять, как ее использовать. Как ни странно, вы должны запрашивать информацию о функции с другой функцией: help(). В частности, в IPython вы также можете использовать ? перед именем функции.

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

help(max)
?max

Несколько аргументов

В предыдущем упражнении вы определили необязательные аргументы, просмотрев документацию с помощью help(). Теперь вы примените это, чтобы изменить поведение функции sorted().

Посмотрите документацию sorted(), набрав help(sorted) в оболочке IPython.

Вы увидите, что sorted() принимает три аргумента: iterable, key и reverse.

key=None означает, что если вы не укажете аргумент key, будет None. reverse=False означает, что если вы не укажете аргумент reverse, по умолчанию он будет равен False.

В этом упражнении вам нужно будет указать только iterable и reverse, а не key. Первый ввод, который вы передаете sorted(), будет сопоставлен с аргументом iterable, но как насчет второго ввода? Чтобы сообщить Python, что вы хотите указать reverse, ничего не меняя в key, вы можете использовать =, чтобы присвоить ему новое значение:

sorted(____, reverse=____)

Два списка были созданы для вас. Можете ли вы склеить их вместе и отсортировать в порядке убывания?

Примечание. На данный момент мы можем понимать iterable как любой набор объектов, например, список.

Строковые методы

Строки поставляются с кучей методов. Внимательно следуйте инструкциям, чтобы открыть для себя некоторые из них. Если вы хотите узнать о них более подробно, вы всегда можете ввести help(str) в оболочке IPython.

Строка place уже создана для экспериментов.

# string to experiment with: place
place = "poolhouse"
# Use upper() on place: place_up
place_up = place.upper()
# Print out place and place_up
print(place)
print(place_up)
# Print out the number of o's in place
print(place.count('o'))
> Result    poolhouse
>           POOLHOUSE 
>           3

Список методов

Строки — не единственные типы Python, с которыми связаны методы. Списки, числа с плавающей запятой, целые числа и логические значения также являются типами, которые поставляются с набором полезных методов. В этом упражнении вы будете экспериментировать с:

index(), чтобы получить индекс первого элемента списка, соответствующего входным данным, и
count(), чтобы узнать, сколько раз элемент появляется в списке.

# Create list areas
areas = [11.25, 18.0, 20.0, 10.75, 9.50]
# Print out the index of the element 20.0
print(areas.index(20.0))
# Print out how often 9.50 appears in areas
print(areas.count(9.50))
> Result    2
>           1

Большинство методов списка изменяют список, к которому они вызываются. Примеры:

append(), который добавляет элемент в список, к которому он вызывается,
remove(), который удаляет первый элемент списка, соответствующий входным данным, и
reverse(), который меняет порядок элементов в списке, к которому он вызывается.

# Create list areas
areas = [11.25, 18.0, 20.0, 10.75, 9.50]
# Use append twice to add poolhouse and garage size
areas.append(24.5)
areas.append(15.45)
# Print out areas
print(areas)
# Reverse the orders of the elements in areas
areas.reverse()
# Print out areas
print(areas)
> Result    [11.25, 18.0, 20.0, 10.75, 9.5, 24.5, 15.45] 
>           [15.45, 24.5, 9.5, 10.75, 20.0, 18.0, 11.25]

Пакет импорта

Как специалисту по данным, некоторые понятия геометрии никогда не помешают. Давайте освежим некоторые основы.

Для необычного алгоритма кластеризации вам нужно найти длину окружности C и площадь A круга. Когда радиус окружности равен r, вы можете рассчитать C и A следующим образом:

Чтобы использовать константу pi, вам понадобится пакет math. Переменная r уже закодирована в скрипте. Введите код для вычисления C и A и посмотрите, как функции print() создают красивые распечатки.

# Definition of radius
r = 0.43
# Import the math package
import math
# Calculate C
C = 2 * math.pi * r
# Calculate A
A = math.pi * r ** 2
# Build printout
print("Circumference: " + str(C))
print("Area: " + str(A))
> Result    Circumference: 2.701769682087222 
>           Area: 0.5808804816487527

Выборочный импорт

Общий импорт, такой как import math, делает все функции пакета math доступными для вас. Однако, если вы решите использовать только определенную часть пакета, вы всегда можете сделать свой импорт более избирательным:

from math import pi

Различные способы импорта

Есть несколько способов импортировать пакеты и модули в Python. В зависимости от вызова импорта вам придется использовать другой код Python.

Предположим, вы хотите использовать функцию inv(), которая находится в подпакете linalg пакета scipy. Вы хотите иметь возможность использовать эту функцию следующим образом:

my_inv([[1,2], [3,4]])

Какой оператор import вам понадобится, чтобы приведенный выше код выполнился без ошибок?

from scipy.linalg import inv as my_inv

Нампи

NumPy — это фундаментальный пакет Python для эффективной практики обработки данных. Научитесь работать с мощными инструментами в массиве NumPy и приступайте к исследованию данных.

Ваш первый массив NumPy

В этой главе мы собираемся погрузиться в мир бейсбола. Попутно вы освоитесь с основами numpy, мощного пакета для работы с данными.

# Create list baseball
baseball = [180, 215, 210, 210, 188, 176, 209, 200]
# Import the numpy package as np
import numpy as np
# Create a numpy array from baseball: np_baseball
np_baseball = np.array(baseball)
# Print out type of np_baseball
print(type(np_baseball))
> Result    <class 'numpy.ndarray'>

Вы большой фанат бейсбола. Вы решаете позвонить в MLB (Высшая лига бейсбола) и узнать еще немного статистики о росте основных игроков. Они передают данные о более чем тысяче игроков, которые хранятся в виде обычного списка Python: height_in. Высота выражается в дюймах. Можете ли вы сделать из него массив numpy и преобразовать единицы измерения в метры?

# height_in is available as a regular list
# Import numpy
import numpy as np
# Create a numpy array from height_in: np_height_in
np_height_in = np.array(height_in)
# Print out np_height_in
print(np_height_in)
# Convert np_height_in to m: np_height_m
np_height_m = np_height_in * 0.0254
# Print np_height_m
print(np_height_m)
> Result    [74 74 72 ... 75 75 73] 
>           [1.8796 1.8796 1.8288 ... 1.905 1.905 1.8542]

MLB также предлагает анализировать данные о весе. Опять же, оба доступны в виде обычных списков Python: height_in и weight_lb. height_in — в дюймах, а weight_lb — в фунтах.

# height_in and weight_lb are available as regular lists
# Import numpy
import numpy as np
# Create array from height_in with metric units: np_height_m
np_height_m = np.array(height_in) * 0.0254
# Create array from weight_lb with metric units: np_weight_kg
np_weight_kg = np.array(weight_lb) * 0.453592
# Calculate the BMI: bmi
bmi = np_weight_kg / np_height_m ** 2
# Print out bmi
print(bmi)
> Result    [23.11037639 27.60406069 28.48080465 ... 25.62295933 23.74810865 25.72686361]

Для подмножества как обычных списков Python, так и массивов numpy вы можете использовать квадратные скобки:

x = [4 , 9 , 6, 3, 1]
x[1]
import numpy as np
y = np.array(x)
y[1]

В частности, для numpy вы также можете использовать логические массивы numpy:

high = y > 5
y[high]**
**# height_in and weight_lb are available as a regular lists
# Import numpy
import numpy as np
# Calculate the BMI: bmi
np_height_m = np.array(height_in) * 0.0254
np_weight_kg = np.array(weight_lb) * 0.453592
bmi = np_weight_kg / np_height_m ** 2
# Create the light array
light = bmi < 21
# Print out light
print(light)
# Print out BMIs of all baseball players whose BMI is below 21
print(bmi[light])
> Result    [False False False ... False False False] 
>           [20.54255679 20.54255679 20.69282047 20.69282047 20.34343189 20.34343189 20.69282047 20.15883472 19.4984471 20.69282047 20.9205219 ]

NumPy побочные эффекты

numpy отлично подходит для векторной арифметики. Однако если вы сравните его функциональность с обычными списками Python, кое-что изменилось.

Во-первых, массивы numpy не могут содержать элементы разных типов. Если вы попытаетесь построить такой список, некоторые типы элементов будут изменены, чтобы в итоге получить однородный список. Это называется приведением типов.

Во-вторых, типичные арифметические операторы, такие как +, -, * и /, имеют разное значение для обычных списков Python и массивов numpy.

Взгляните на эту строку кода:

np.array([True, 1, 2]) + np.array([3, 4, False])

Можете ли вы сказать, какой фрагмент кода создает точно такой же объект Python? Пакет numpy уже импортирован как np, поэтому вы можете сразу начать экспериментировать в оболочке IPython!

np.array([4, 3, 0]) + np.array([0, 2, 2])

Подмножество массивов NumPy

Вы видели это своими глазами: списки Python и массивы numpy иногда ведут себя по-разному. К счастью, в этом мире все еще есть определенность. Например, подмножество (используя квадратные скобки для списков или массивов) работает точно так же. Чтобы убедиться в этом, попробуйте выполнить следующие строки кода в оболочке IPython:

x = ["a", "b", "c"]
x[1]
np_x = np.array(x)
np_x[1]

Ваш первый 2D-массив NumPy

Прежде чем работать с фактическими данными MLB, давайте попробуем создать двумерный массив numpy из небольшого списка списков.

В этом упражнении baseball — это список списков. Основной список содержит 4 элемента. Каждый из этих элементов представляет собой список, содержащий рост и вес 4 бейсболистов в указанном порядке.

# Create baseball, a list of lists
baseball = [[180, 78.4],
            [215, 102.7],
            [210, 98.5],
            [188, 75.2]]
# Import numpy
import numpy as np
# Create a 2D numpy array from baseball: np_baseball
np_baseball = np.array(baseball)
# Print out the type of np_baseball
print(type(np_baseball))
# Print out the shape of np_baseball
print(np_baseball.shape)
> Result    <class 'numpy.ndarray'> 
>           (4, 2)

Вы еще раз взглянули на данные MLB и поняли, что имеет смысл реструктурировать всю эту информацию в двумерном массиве numpy. В этом массиве должно быть 1015 строк, соответствующих 1015 бейсболистам, о которых у вас есть информация, и 2 столбца (для роста и веса).

MLB, опять же, был очень полезен и передал вам данные в другой структуре, в виде списка списков Python. В этом списке списков каждый подсписок представляет рост и вес одного бейсболиста. Имя этого встроенного списка — baseball.

Можете ли вы сохранить данные в виде двумерного массива, чтобы разблокировать дополнительные функции numpy?

# baseball is available as a regular list of lists
# Import numpy package
import numpy as np
# Create a 2D numpy array from baseball: np_baseball
np_baseball = np.array(baseball)
# Print out the shape of np_baseball
print(np_baseball.shape)
> Result    (1015, 2)

Подмножество 2D-массивов NumPy

Если ваш двумерный массив numpy имеет регулярную структуру, т. е. каждая строка и столбец имеют фиксированное количество значений, сложные способы подмножества становятся очень простыми. Посмотрите на приведенный ниже код, в котором элементы "a" и "c" извлекаются из списка списков.

# regular list of lists
x = [["a", "b"], ["c", "d"]]
[x[0][0], x[1][0]]
# numpy
import numpy as np
np_x = np.array(x)
np_x[:, 0]

Для обычных списков Python это настоящая проблема. Однако для двумерных массивов numpy это довольно интуитивно понятно! Индексы перед запятой относятся к строкам, а индексы после запятой относятся к столбцам. : для нарезки; в этом примере он указывает Python включить все строки.

# baseball is available as a regular list of lists
# Import numpy package
import numpy as np
# Create np_baseball (2 cols)
np_baseball = np.array(baseball)
# Print out the 50th row of np_baseball
print(np_baseball[49])
# Select the entire second column of np_baseball: np_weight_lb
np_weight_lb = np_baseball[:,1]
# Print out height of 124th player
print(np_baseball[123,0])
> Result    [ 70 195] 
>           75

2D-арифметика

Помните, как вы вычисляли индекс массы тела для всех бейсболистов? numpy смог выполнить все вычисления поэлементно (то есть поэлементно). Для 2D-массивов numpy это ничем не отличается! Вы можете комбинировать матрицы с отдельными числами, с векторами и с другими матрицами.

Выполните приведенный ниже код в оболочке IPython и посмотрите, поняли ли вы:

import numpy as np
np_mat = np.array([[1, 2],
                   [3, 4],
                   [5, 6]])
np_mat * 2
np_mat + np.array([10, 10])
np_mat + np_mat
> Result    array([[ 2, 4], [ 6, 8], [10, 12]])
# baseball is available as a regular list of lists
# updated is available as 2D numpy array
# Import numpy package
import numpy as np
# Create np_baseball (3 cols)
np_baseball = np.array(baseball)
# Print out addition of np_baseball and updated
print(np_baseball + updated)
# Create numpy array: conversion
np_conversion = np.array([0.0254, 0.453592, 1])
# Print out product of np_baseball and conversion
print(np_baseball * np_conversion)
> Result    [[ 75.2303559  168.83775102  23.99 ] 
>              [ 75.02614252 231.09732309 35.69 ]
>              [ 73.1544228 215.08167641 31.78 ]
>              ...
>              [ 76.09349925 209.23890778 26.19 ]
>              [ 75.82285669 172.21799965 32.01 ]
>              [ 73.99484223 203.14402711 28.92 ]]
>           [[ 1.8796 81.64656 22.99 ]
>              [ 1.8796 97.52228 34.69 ]
>              [ 1.8288 95.25432 30.78 ]
>              ...
>              [ 1.905 92.98636 25.19 ]
>              [ 1.905 86.18248 31.01 ]
>              [ 1.8542 88.45044 27.92 ]]

Среднее по сравнению с медианным

Теперь вы знаете, как использовать функции numpy, чтобы лучше понять свои данные. В основном все сводится к импорту numpy и последующему вызову нескольких простых функций для массивов numpy:

import numpy as np
x = [1, 4, 8, 10, 12]
np.mean(x)
np.median(x)

Исследуйте данные

Поскольку среднее значение и медиана так далеки друг от друга, вы решаете пожаловаться в MLB. Они находят ошибку и отправляют вам исправленные данные.

# np_baseball is available
# Import numpy
import numpy as np
# Print mean height (first column)
avg = np.mean(np_baseball[:,0])
print("Average: " + str(avg))
# Print median height. Replace 'None'
med = np.median(np_baseball[:,0])
print("Median: " + str(med))
# Print out the standard deviation on height. Replace 'None'
stddev = np.std(np_baseball[:,0])
print("Standard Deviation: " + str(stddev))
# Print out correlation between first and second column. Replace 'None'
corr = np.corrcoef(np_baseball[:,0], np_baseball[:,1])
print("Correlation: " + str(corr))
> Result    Average: 73.6896551724138 
>           Median: 74.0
>           Standard Deviation: 2.312791881046546
>           Correlation: [[1. 0.53153932]
>                         [0.53153932 1. ]]

В последних нескольких упражнениях вы узнали все, что нужно знать о росте и весе бейсболистов. Теперь пришло время погрузиться в другой вид спорта: футбол.

Вы связались с ФИФА для получения некоторых данных, и они передали вам два списка. Списки следующие:

positions = ['GK', 'M', 'A', 'D', ...]
heights = [191, 184, 185, 180, ...]

Каждый элемент в списках соответствует игроку. Первый список, positions, содержит строки, представляющие позицию каждого игрока. Возможные позиции: 'GK' (вратарь), 'M' (полузащита), 'A' (атака) и 'D' (защита). Второй список, heights, содержит целые числа, представляющие рост игрока в сантиметрах. Первый игрок в списках — вратарь и довольно высокий (191 см).

Вы вполне уверены, что средний рост вратарей выше, чем у других игроков на футбольном поле. Некоторые из ваших друзей вам не верят, поэтому вы полны решимости показать им это, используя данные, полученные от FIFA, и свои недавно приобретенные навыки Python.

# heights and positions are available as lists

# Import numpy

import numpy as np

# Convert positions and heights to numpy arrays: np_positions, np_heights

np_heights = np.array(heights)
np_positions = np.array(positions)

# Heights of the goalkeepers: gk_heights

gk_heights = np_heights[np_positions == 'GK']

# Heights of the other players: other_heights

other_heights = np_heights[np_positions != 'GK']

# Print out the median height of goalkeepers. Replace 'None'

print("Median height of goalkeepers: " + str(np.median(gk_heights)))

# Print out the median height of other players. Replace 'None'

print("Median height of other players: " + str(np.median(other_heights)))

> Result    Median height of goalkeepers: 188.0
>           Median height of other players: 181.0

Заявление о Благоустройство

После завершения курса я немедленно получу Заявление об успеваемости от DataCamp!