Shpindel_t_800

data = [9, 8, 7, 7, 6, 3, 1, -2, -3, -7, -7, -9]
counter = 0
while not data[counter] < 0:
    counter += 1
print(data[counter], counter)

или

data = [9, 8, 7, 7, 6, 3, 1, -2, -3, -7, -7, -9]
for counter, temperature in enumerate(data):
    if temperature < 0:
        print(temperature, counter)
        break

но я не очень люблю break, это субъективно.

Ну и кривенький однострочничек:

data = [9, 8, 7, 7, 6, 3, 1, -2, -3, -7, -7, -9]
print(*[(temperature, counter) for counter, temperature in enumerate(data) if temperature < 0][0])

Также можете для удобства работать через PyCharm, чтобы не беспокоиться о создании виртуальных окружений. IDE сделает это за вас.

Вы просто venv не активировали и когда ставили requests он попал в центральный интерпретатор. После установки venv работайте только с активированным и также добавляйте пакеты - в зависимости от shell в Windows

# In cmd.exe
venv\Scripts\activate.bat
# In PowerShell
venv\Scripts\Activate.ps1

Мне кажется Вам подойдет что-то такое:

from collections import ChainMap

now = [{0 :  'какое-то значение'}, 
{1 :  'какое-то значение1'}, 
{3 :  'какое-то значение'}, 
{4 :  'какое-то значение'}, 
{7 :  'какое-то значение'}, 
{9 :  'какое-то значение'}, 
{10 :  'какое-то значение'}]

d = dict(ChainMap(*now))
print(d[1])

По моему, на русском чаще используют термин объявление, а не декларация. По крайней мере мне так привычнее.
Объявление в одном из возможных переводов на английский звучит как declaration.
https://en.cppreference.com/w/c/language/declarations
https://en.cppreference.com/w/c/language/type

Вы не правильно сопоставляете инициализацию и декларацию (объявление). Сопоставлять надо объявление и определение.
Инициализация - всего лишь присвоение переменной некоторого начального значения. Она может быть при определении переменной или потом - не важно. Важно то, что перед инициализацией память для переменной должна быть выделена.
Память выделяется когда переменная определяется.
При объявлении память не выделяется, а только описывается (объявляется) тип. Тип включает в себя информацию о размере, выравнивании, возможных операциях, что-еще. Встроенные типы (int и т.п.) уже объявлены заранее и известны компилятору.
Может быть предварительное объявление. Предварительных объявлений может быть сколько угодно много, если они не противоречат друг другу. Настоящее объявление может быть только одно.

Понять различие между объявлением и определением на простом встроенном типе (int) довольно сложно, потому что сам тип уже известен, его не нужно объявлять. Для примера буду использовать структуру.

Кроме того важно где конкретно в коде программы определена переменная - глобально (по отношению к файлу исходного кода) или локально (в функции).

struct s;                     // предварительное объявление
struct s { int v; };       // объявление структуры
strcut s s1;                // определение глобальной структуры
struct s s2 = { 0 };     // определение глобальной инициализированной структуры
int main()
{
  struct s s3;             // определение локальной структуры
}

Предварительное объявление - говорит о том, что где-то есть полное объявление. Тип объявленный только предварительным объявлением - не завершенный (не полный). Нельзя определить переменную по неполному типа. НО можно определить указатель на неполный тип. Но обращаться по указателю на неполный тип нельзя. Но присвоить адрес можно :-) Это можно использовать в своих интересах.
После полного объявления типа уже можно определять переменные этого типа.
s1 - глобальная не инициализированная структура. Память под нее выделяется в секции bss исполняемого файла. В исполняемом файле обычно не выделяется память непосредственно, но сохраняется размер секции. Загрузчик ОС читает размер секции из файла и выделяет память нужного размера. Глобальные не инициализированные переменные на самом деле инициализируются неявно нулем.
s2 - глобальная инициализированная структура. Память под нее выделяется в секции data исполняемого файла. Тут уже не достаточно сохранить информацию о секции, т.к. есть начальные значения. Поэтому такие переменные непосредственно присутствуют в исполняемом файле (точнее выделена память под них и присвоено начальное значение). Есть еще секция rodata - для константных данных.
s3 - локальная не инициализированная переменная. Память под нее выделяется на стеке. Не зависимо от того инициализирована переменная или нет, память выделена, а значит в этой памяти уже что-то лежит - не бывает "пустой" памяти. В случае не инициализированной переменной на стеке, в памяти лежит мусор, который остался тут от прошлых действий.

int some_v;
Эта конструкция называется декларацией и переменная не инициализирована. Что это значит? получается этой переменной нет даже в памяти и под нее не зарезервировано место?

Зависит от того есть ли дальше по коду обращение к данной переменной. Если есть, то независимо от инициализации будет выделена память на стеке, при этом если инициализации не было, то в переменной будет лежать неопределённое значение. Если обращения нет, то компилятор при оптимизации выкинет эту переменную.

Декларация - объявление переменной с указанием идентификатора и типа данных, который в ней будет лежать типа: int i
Инициализация - присвоение ей начального значения: int i = 9

Для начала замечу, что для сравнения есть два замечательных оператора == и is
Первый проверяет равенство, тогда как второй идентичность

a = [1, 2, 3]
b = a
print(a == b)  #True
print(a is b)  #True

a = [1, 2, 3]
b = list(a)
print(a == b)  #True
print(a is b)  #False

Теперь что касается среза он дает доступ к диапазону коллекции, в случае с [:] всему диапазону. Он создает объект, а затем вставляет ссылки на объекты из оригинала. Это можно легко посмотреть добавив дочерние элементы, ссылки на них останутся старые и при изменении они изменятся в обоих списках

original_lst = [1, 2, [3, 4]]
lst = original_lst[:]
lst[2][1] = 5
print(original_lst[2] is lst[2])  #True
print(original_lst) #[1, 2, [3, 5]]

Чтобы создать полностью независимый объект стоит использовать модуль copy

from copy import deepcopy
original_lst = [1, 2, [3, 4]]
lst = deepcopy(original_lst)
lst[2][1] = 5
print(original_lst[2] is lst[2])  #False
print(original_lst)  #[1, 2, [3, 4]]