index
int64 4
23.2k
| вопрос
stringlengths 56
27.9k
| ответ
stringlengths 25
27.3k
|
|---|---|---|
23,150 | Объединить две таблицы с разными форматами Pandas Python
Итак, есть исходный DF:
<code>
YEAR COM SEC
2010 1 B
2011 1 B
2012 1 B
2013 1 B
2014 1 B
2015 1 B
2012 2 C
2013 2 C
2014 2 C
2015 2 C
</code>
Есть второй DF:
<code>
SEC 2008 2009 2010 2011 2012 2013 2014 2015
A 45 53 53 3 5 3 5 3
B 5 3 4 3 3 5 33 4
C 4 3 4 5 6 7 3 3
</code>
Необходимо сопоставить два DF по году и графе SEC
На выходе должно получиться нечто такое:
<code>
YEAR COM SEC X1
2010 1 B 4
2011 1 B 3
2012 1 B 3
2013 1 B 5
2014 1 B 33
2015 1 B 4
2012 2 C 6
2013 2 C 7
2014 2 C 3
2015 2 C 3
</code>
|
<code>
d2 = (d2.set_index('SEC')
.unstack()
.reset_index(name='X1')
.assign(YEAR=lambda d: d.pop('level_0').astype('int')))
res = d1.merge(d2)
</code>
Результат:
<code>
In [132]: res
Out[132]:
YEAR COM SEC X1
0 2010 1 B 4
1 2011 1 B 3
2 2012 1 B 3
3 2013 1 B 5
4 2014 1 B 33
5 2015 1 B 4
6 2012 2 C 6
7 2013 2 C 7
8 2014 2 C 3
9 2015 2 C 3
</code>
Если столбцы, представляющие годы во втором фрейме являются числами (<code>
[2009,2010, ...]</code>), а не строками (<code>
['2009','2019',...]</code>), то решение можно упростить:
<code>
In [138]: (d1.merge(d2.set_index('SEC')
.unstack()
.reset_index(name='X1')
.rename(columns={'level_0':'YEAR'}))
Out[138]:
YEAR COM SEC X1
0 2010 1 B 4
1 2011 1 B 3
2 2012 1 B 3
3 2013 1 B 5
4 2014 1 B 33
5 2015 1 B 4
6 2012 2 C 6
7 2013 2 C 7
8 2014 2 C 3
9 2015 2 C 3
</code>
|
23,151 | Валидация json данных в python
Я новичок в Python, не судите строго... Кажется, это действительно тривиальный вопрос.
Мне нужно создать функцию, которая проверяет входящие данные JSON и возвращает Python dict. Я хочу быть уверен, что необходимые мне поля присутствуют в JSON файле и они заполнены корректно, а также проверить типы данных этих полей. Мне нужно использовать try-catch.
Не могли бы вы поделиться какими-то сниппетами или примерами, которые дадут мне ответы?
|
Вам нужна библиотека <code>
jsonschema</code>, данная библиотека позволяет проводить верификацию json по заданной схеме. И если обнаружены ошибки будет выдавать их в виде исключений с описанием. В схеме можно указывать как тип полей, так и диапазон допустимых значений, значения по умолчанию и пр.
<code>
from jsonschema import validate
schema = {
"type": "object",
"properties": {
"name": {
"type": "string"
},
"age": {"type": "number",
"minimum": 18,
"maximum": 110
},
"role": {
"type": "string",
"enum": ["admin", "user"]
}
}
}
message = {"name": "Vasya", "age": 15, "role": "user"}
validate(message, schema)
</code>
Более подробно про создание схем можно посмотреть в стандарте JSON Schema
|
23,152 | Django. Увеличения значения поля в модели
Застрял вроде на таком простом моменте, но тем не менее. В гугле ничего не нашел. Ситуация такая, нужно чтобы пользователь вводил некое число и это значение, что он ввел прибавлялось к уже имеющему значению некоторому полю в модели.
Из кода, что приведен ниже необходимо, что когда пользователь вводит в поля development и testing цифры, эти цифры не обновлялись, а прибавлялись к уже имеющим значениям в базе, которые были до них.
Пример: в базе в полях development и testing хранятся значения 10 и 15, пользователь вводит в одно поля 5, в другое 3, и тогда в базе обновляются значения до 15 и 18 соответственно.
Скажем, так, вот модель:
<code>
Class Project(models.Model):
company = models.ForeignKey('projects.Company', on_delete=models.PROTECT, related_name='projects')
title = models.CharField('Project title', max_length=128)
development = models.DecimalField('development hours', default=0, decimal_places=2, max_digits=6)
testing = models.DecimalField('testing hours', default=0, decimal_places=2, max_digits=6)
</code>
Вот форма:
<code>
class ProjectForm(ModelForm):
class Meta:
model = Project
fields = ['development', 'testing']
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.helper = FormHelper()
self.helper.add_input(Submit('submit', 'UPDATE'))
</code>
View:
<code>
class ProjectUpdateView(LoginRequiredMixin, UpdateView):
model = Project
form_class = ProjectForm
success_url = reverse_lazy('home')
</code>
html
<code>
<div class="row justify-content-center">
<div class="col-md-8">
<div class="card bg-light">
<div class="card-body">
{% crispy form %}
</div>
</div>
</div>
</code>
Спасибо.
|
Вам нужно переопределить один из методов в <code>
UpdateView</code>. Наверное это должен быть <code>
form_valid()</code>. То есть на этапе, когда форма валидная, мы берем существующие данные из объекта и добавляем их в соответствующие поля экземпляра формы.
Я не проверял работает код или нет, но вы хотя бы будете знать в каком направлении двигаться.
<code>
class ProjectUpdateView(LoginRequiredMixin, UpdateView):
model = Project
form_class = ProjectForm
success_url = reverse_lazy('home')
def form_valid(self, form):
form.instance.development += self.object.development
form.instance.testing += self.object.testing
return super().form_valid(form)
</code>
|
23,154 | Как максимально улучшить архитектуру нейронной сети?
Архитектура сети
<code>
max_features = len(lexicon)
num_classes = len(labels_lexicon)
early_stop = EarlyStopping(monitor='val_acc', min_delta=0.001,
patience=3, verbose=1, mode='auto')
chkpt = ModelCheckpoint('architecture.hdf5',
monitor='val_loss',
verbose=1,
save_best_only=True,
mode='auto')
callbacks = [early_stop, chkpt]
model = Sequential()
model.add(Embedding(max_features, 32))
model.add(SpatialDropout1D(0.2))
model.add(LSTM(100, dropout=0.2, recurrent_dropout=0.2))
model.add(Dense(num_classes, activation="softmax"))
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
model.fit(x_train, y_train, batch_size=128, epochs=50,
validation_data=(x_test, y_test), verbose=1, callbacks=callbacks)
scores = model.evaluate(x_test, y_test, batch_size=128)
</code>
Данные по текущей архитектуре сети
val_acc - 86%
val_loss - 0.3
acc - 89%
кол-во эпох обучения: 10 (после 10ой эпохи начинается переобучение)
Подключение модулей и создание словоря категорий
<code>
import sklearn
import numpy as np
from collections import Counter
from sklearn.model_selection import train_test_split as tts
from keras.preprocessing import sequence
from keras import utils as ku
from nltk.stem.snowball import SnowballStemmer
from keras.models import Sequential
from keras.layers import Dense, Activation, Embedding
from keras.layers import LSTM, SpatialDropout1D
import re
from nltk.stem.snowball import SnowballStemmer
from keras.models import load_model
from keras.callbacks import EarlyStopping, ModelCheckpoint
np.random.seed(42)
labels_lexicon = []
for i in range(0, 33):
labels_lexicon.append("_label_"+str(i))
</code>
Загрузка данных из файла
<code>
def get_data_from_the_file():
labels, descriptions, lexicon, lexicon_base = [], [], [], []
for i, line in enumerate(open('testtext.txt', 'r', encoding='utf8', errors='ignore')):
content = line.split()
labels.append(content[0].replace(u'\ufeff', ''))
descriptions.append(content[1:])
lexicon_base += content[1:]
count_lexicon = Counter(lexicon_base).most_common()
for count_item in count_lexicon:
if count_item[1] >= 10:
lexicon.append(count_item[0])
return labels, descriptions, lexicon
labels, descriptions, lexicon = get_data_from_the_file()
</code>
Токенизация обучающих текстов(функция)
<code>
def get_descriptions_to_index(lexicon): #функция для преоброзования слов в индесы(для описаний)
cache = {}
word2index = {}
for i,word in enumerate(lexicon):
if cache.get(word) == None:
cache[word] = i
word2index[word] = i
return word2index
word2index = get_descriptions_to_index(lexicon)
</code>
Токенизация label(функция)
<code>
def get_labels_to_index(labels_lexicon):
cache = {}
labels2index = {}
for i,word in enumerate(labels_lexicon):
if cache.get(word) == None:
cache[word] = i
labels2index[word] = i
return labels2index
labels2index = get_labels_to_index(labels_lexicon)
</code>
Токенизация обучающих текстов и label к ним
<code>
list_of_tokenize_descriptions = []
list_of_tokenize_labels = []
for description_item in descriptions: # преоброзование описаний тендеров из текста в индексы
prepare_list_of_tokenize_descriptions = []
for descriptions_piece in description_item:
if word2index.get(descriptions_piece) != None:
prepare_list_of_tokenize_descriptions.append(word2index[descriptions_piece])
list_of_tokenize_descriptions.append(prepare_list_of_tokenize_descriptions)
for label in labels: # преоброзование категорий тендеров из текста в индексы
if labels2index.get(label) != None:
list_of_tokenize_labels.append(labels2index[label])
</code>
Разделение на тестовую и обучающую части
<code>
x_train, x_test, y_train, y_test = tts(list_of_tokenize_descriptions, list_of_tokenize_labels, test_size=0.1, random_state=42) # разделения на тренироввые и тренировачны части
</code>
Привидение label к категориальному виду:
<code>
y_test = ku.to_categorical(y_test, num_classes=len(labels_lexicon))
y_train = ku.to_categorical(y_train, num_classes=len(labels_lexicon))
</code>
Привидение всех описаний к одной длине
<code>
MaxDescriptionLen = 0
for count_description_item in descriptions:
if len(count_description_item) > MaxDescriptionLen:
MaxDescriptionLen = len(count_description_item)
#преведение всех описаний к одинаковой длине
x_train = sequence.pad_sequences(x_train, maxlen=MaxDescriptionLen)
x_test = sequence.pad_sequences(x_test, maxlen=MaxDescriptionLen)
</code>
Ссылки: dataset, полный код
Задача
Максимально улучшить архитектуру данной сети.
|
Вот CNN архитектура (без использования LSTM), которая даёт точность: 90.25% на тестовой выборке:
<code>
In [75]: model.summary()
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
embedding_7 (Embedding) (None, 100, 50) 300000
_________________________________________________________________
dropout_10 (Dropout) (None, 100, 50) 0
_________________________________________________________________
conv1d_4 (Conv1D) (None, 98, 250) 37750
_________________________________________________________________
global_max_pooling1d_4 (Glob (None, 250) 0
_________________________________________________________________
dense_8 (Dense) (None, 250) 62750
_________________________________________________________________
dropout_11 (Dropout) (None, 250) 0
_________________________________________________________________
activation_4 (Activation) (None, 250) 0
_________________________________________________________________
dense_9 (Dense) (None, 8) 2008
=================================================================
Total params: 402,508
Trainable params: 402,508
Non-trainable params: 0
In [76]: model.evaluate(X_test, Y_test)
6123/6123 [==============================] - 0s 71us/step
Out[76]: [0.3342062237993596, 0.9024987751005056]
</code>
Полный код:
<code>
from pathlib import Path
import pandas as pd
from keras.models import Sequential
from keras.layers import Embedding, Conv1D, MaxPool1D, GlobalMaxPool1D, Dense, Dropout, Activation
from keras.preprocessing.text import Tokenizer, text_to_word_sequence
from keras.preprocessing.sequence import pad_sequences
from keras import optimizers
from keras.callbacks import EarlyStopping, ModelCheckpoint, TensorBoard
from keras.models import save_model, load_model
from sklearn.model_selection import train_test_split
path = Path(r'D:\work\SO_ru\939264-Keras_CNN_LSTM')
filename = path / 'testtext.txt'
model_fn = path / 'model_CNN.h5'
max_features = 6000
maxlen = 100
embedding_dims = 50
filters = 250
kernel_size = 3
hidden_dims = 250
batch_size = 32
epochs = 15
os.chdir(str(path))
##################################################################
def get_data(filename, max_features=5000, maxlen=100, frac=1.0):
data = (pd.read_csv(filename, header=None, names=['text'], sep='~')
.sample(frac=frac))
data[['label','text']] = data.pop('text').str.split(n=1, expand=True)
data = data.dropna()
data = data.loc[data['label'].str.contains(r'^_label')]
# build vocabulary
tok = Tokenizer(num_words=max_features)
tok.fit_on_texts(data['text'])
# convert texts to sequences
X = tok.texts_to_sequences(data['text'])
lb = LabelBinarizer()
Y = pd.DataFrame(lb.fit_transform(data['label']),
columns=lb.classes_, index=data.index)
return (pad_sequences(X, maxlen=maxlen), Y, tok)
def build_model(max_features=1000, num_classes=1,
embedding_dims=128, maxlen=100, fc_dropout=0.2,
last_activation='sigmoid', optimizer='adam',
loss='binary_crossentropy', metrics=['accuracy']):
if num_classes == 1:
last_activation = 'sigmoid'
loss = 'binary_crossentropy'
else:
last_activation = 'softmax'
loss = 'categorical_crossentropy'
model = Sequential()
model.add(Embedding(max_features, embedding_dims, input_length=maxlen))
model.add(Dropout(0.1))
model.add(Conv1D(filters,
kernel_size,
padding='valid',
activation='relu',
strides=1))
model.add(GlobalMaxPool1D())
model.add(Dense(hidden_dims))
model.add(Dropout(fc_dropout))
model.add(Activation('relu'))
model.add(Dense(num_classes, activation=last_activation))
model.compile(loss=loss,
optimizer=optimizer,
metrics=metrics)
return model
X, Y, tok = get_data(filename, max_features=max_features)
# split data set to train / dev
X_train, X_test, Y_train, Y_test = \
train_test_split(X, Y, test_size=0.05, random_state=123, stratify=Y)
print('X_train.shape:\t{}\t\tY_train.shape:\t{}'.format(X_train.shape, Y_train.shape))
print('X_test.shape:\t{}\t\tY_test.shape:\t{}'.format(X_test.shape, Y_test.shape))
#############################
early_stop = EarlyStopping(monitor='val_acc', min_delta=0.001,
patience=5, verbose=1, mode='auto')
chkpt = ModelCheckpoint(str(model_fn),
monitor='val_acc',
verbose=1,
save_best_only=True,
mode='auto')
callbacks = [early_stop, chkpt]
if Y_train.ndim == 1:
num_classes = 1
elif Y_train.ndim == 2:
num_classes = Y_train.shape[1]
else:
raise Exception('[Y_train] must be either 1D or 2D array')
model = build_model(max_features=max_features, num_classes=num_classes,
embedding_dims=embedding_dims, maxlen=maxlen,
fc_dropout=0.4, last_activation='softmax',
optimizer='adam', loss='categorical_crossentropy',
metrics=['accuracy'])
model.fit(X_train, Y_train, batch_size=batch_size, epochs=epochs,
validation_split=0.2, verbose=1,
callbacks=callbacks)
print(model.evaluate(x_test, y_test, batch_size=batch_size))
</code>
|
23,156 | Составил код, но не могу вывести числа. Числа в обратном порядке
Мой код разбивает число. Например введём число 450, он должен вывести 4 5 0, но выводит 0 5 4. Код считает всё верно, но выводит цифры не в правильном порядке. Что нужно записать в Print???
<code>
a=input()
b=len(a)
a=int(a)
c=a
d=a
for i in range(b):
c=d%10
print(c, end=' ')
d=d//10
</code>
|
Сохраняйте цифры в массив и возвращайте массив в реверсивном виде (задом наперёд)
Пример:
<code>
def digitalize(num):
num = abs(num)
res = []
while num > 0:
res.append(num % 10)
num = num // 10
return list(reversed(res))
In [4]: digitalize(12345)
Out[4]: [1, 2, 3, 4, 5]
In [5]: digitalize(450)
Out[5]: [4, 5, 0]
</code>
|
23,157 | Преобразование данных ImageDataGenerator
Имеется код:
<code>
from tensorflow.python.keras.preprocessing.image import ImageDataGenerator
from tensorflow.python.keras.models import Sequential
from tensorflow.python.keras.layers import Conv2D, MaxPooling2D
from tensorflow.python.keras.layers import Activation, Dropout, Flatten, Dense
datagen = ImageDataGenerator(rescale=1. / 255)
train_generator = datagen.flow_from_directory(
'train',
target_size=(32, 32),
batch_size=32,
class_mode='categorical')
val_generator = datagen.flow_from_directory(
'val',
target_size=(32, 32),
batch_size=32,
class_mode='categorical')
model = Sequential()
model.add(Conv2D(64, (3, 3), input_shape=(32, 32, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(64, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.3))
model.add(Flatten())
model.add(Dense(64))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(7))
model.add(Activation('sigmoid'))
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
model.fit_generator(
train_generator,
steps_per_epoch=3000// 32,
epochs=3,
validation_data=val_generator,
validation_steps=1500// 32)
</code>
И он хорошо работает, но для моей задачи требуется изначально плоская нейронная сеть(Все нейроны сети должны быть типа Dense), подскажите как это реализовать. Прошу не кидать камнями с нейронными сетями я на вы)
|
В указанной в вопросе архитектуре несовместимые параметры:
<code>
model.add(Dense(7))
model.add(Activation('sigmoid')) # <---- здесь бы подошла функция 'softmax'
model.compile(loss='categorical_crossentropy', ...)
</code>
Функция активации <code>
sigmoid</code> используется только для бинарной классификации - т.е. такой, у которой на последнем скрытом слое используется один нейрон и в качестве функции потери используют <code>
binary_crossentropy</code>:
<code>
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy', ...)
</code>
Если же у вас мультиклассовая задача, т.е. присутствует более двух классов классификации, то в качестве функции активации используют <code>
softmax</code>, а в качестве функции потери используют <code>
categorical_crossentropy</code>:
<code>
model.add(Dense(num_classes, activation='softmax'))
model.compile(loss='categorical_crossentropy', ...)
</code>
|
23,159 | Правильная подборка количества слоев в сверточной нейросети
Всех приветствую.
Такой вопрос:
К примеру, есть нейронка с 2 слоями свертки:
<code>
model = Sequential()
model.add(Conv2D(32, kernel_size=(3, 3),
activation='relu',
input_shape=input_shape))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(num_classes, activation='softmax'))
model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=keras.optimizers.Adadelta(),
metrics=['accuracy'])
</code>
Но также я встречал нейронки и по 7 сверточных слоев.
Отсюда вопрос:
На что влияет количество слоев?
Как я понимаю, влияет именно на точность или же качество распознавания чего либо.
Но тогда почему бы не сделать, к примеру, 50 слоев сразу?
Как вообще подбирается количество слоев и количество нейронов в них?
|
Вы угадали - одна из очень популярных CNN архитектур - ResNet50 состоит из 50 скрытых слоев.
Также существуют другие популярные сверточные сети с гораздо большим числом слоев, например <code>
DenseNet-250</code> с 250-ю слоями.
Количество слоев влияет на сложность (абстрактность) образов рассматриваемых НС. На начальных слоях распознаются простые примитивы, например прямые под различными углами, дальше могут идти дуги, сектора и т.д. Чем глубже слой тем более сложные / абстрактные примитивы он рассматривает - например глаз или клюв, или если копнуть еще глубже - человек, птица или машина. Дальше можно, например, различать чем занят человек на картинке - сидит, лежит, едет на велосипеде, на скейте и т.д.
Как вообще подбирается количество слоев и количество нейронов в них?
Это целое искусство - подобрать удачную архитектуру, которая будет:
хорошо обучаться
быстро обучаться
не переобучаться
будет стойкой к размытым / некачественным изображениям
сможет хорошо до-обучаться
...
На практике люди изучают последние теоретические и практические наработки и очень много эксперементируют
|
23,162 | Распаковка списков и словарей в строку
есть такой простой пример
<code>
def test(x, y, z):
print(x, y, z)
l = [1, 2, 3]
d = {'x': 1, 'y': 2, 'z': 3}
print(*l)
print(*d)
</code>
тут все распаковывается на ура, но если попробовать получить значение из словаря
<code>
print(**d)
</code>
уже не пашет
|
Попробуйте распаковать <code>
d.values()</code>
<code>
print(*d.values())
</code>
|
23,163 | Как посмотреть сколько ОЗУ занимает процесс?
Как с помощью Python посмотреть сколько ОЗУ занимает любой процесс (например <code>
chrome.exe</code> и т.п.)?
|
Пример:
<code>
import psutil
In [171]: [(proc.name(), proc.memory_info().rss)
for proc in psutil.process_iter()
if 'firefox' in proc.name().lower()]
Out[171]:
[('firefox.exe', 446230528),
('firefox.exe', 93122560),
('firefox.exe', 450588672),
('firefox.exe', 216768512),
('firefox.exe', 546209792),
('AppleFirefoxHost.exe', 22958080),
('firefox.exe', 371126272),
('firefox.exe', 401686528),
('firefox.exe', 118554624)]
</code>
|
23,164 | django не видит шаблоны на боевом сервере
Всем очень добрый день!
Столкнулся с такой проблемой. При загрузке сайта на боевом сервере линукс джанго стал ругаться на отсутствие шаблона: TemplateDoesNotExist at /home
main/index.html.
web/site.ru/mainApp/views.py in home
return render(request, 'main/index.html', {'form':form}, locals())
Хотя на локальном сервере все работало. Я подозреваю, что это из-за различий относительных путей на винде и линуксе (разработка проекта ведется на локальной машине под виндой)
settings.py
<code>
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [os.path.join('templates')],
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
</code>
]
<code>
TEMPLATE_DIRS = (os.path.join(BASE_DIR, 'templates'),)
</code>
views.py
<code>
def home(request):
form = RequestForm(request.POST or None)
if request.method == 'POST' and form.is_valid():
new_form = form.save()
messages.success(request, 'Ваш запрос успешно отправлен')
return HttpResponseRedirect(request.META.get('HTTP_REFERER'))
return render(request, 'main/index.html', {'form':form}, locals())
</code>
|
Решил проблему добавлением BASE_DIR в начало settings.py и в DIRS:
<code>
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
</code>
...
<code>
'DIRS': [os.path.join(BASE_DIR, 'templates')],
</code>
|
23,165 | Как получить конкретное имя ключа в словаре Python?
Имеется программа, определяющая наименьшее отклонение среднемесячной температуры от средней годовой. Вот сама программа:
<code>
min=1000
slovar={a:[] for a in range(1,13)} ### Создаём пустой словарь, состоящий из 12-ти ключей (от 1 до 12)
for i in range(366):
data, temp=input().split() ### Вводим dd.mm t (день.месяц температура) (например 13.09 -11)
data=int(data[3:5]) ### Мне не нужны дни, их обрезаем
temp=float(temp)
slovar[data].append(temp) ### Заполняем словарь по ключу "data" значением "temp"
for i in range(1,13):
slovar.update({i:round(sum(slovar[i])/len(slovar[i]), 1)}) ### Находим среднемесячную температуру каждого месяца, заменяем температуру дней на среднюю температуру месяца
avg_y=round(sum(slovar.values())/12, 1) ### Находим среднее за год
for i in range(1,13):
if abs(abs(avg_y)-abs(slovar[i]))<min: min=abs(abs(avg_y)-abs(slovar[i]) ### Находим минимальное значение отклонения (ВАЖНО! Поиск минимума сделан так колхозно (не используется операция min), т.к. данная задача формата ЕГЭ (27 номер) и там не очень приветствуются min, avg и тд)
print(avg_y)
mounth=list(slovar.keys()) ### Создаётся список mounth, значения в котором - это ключи словаря slovar (номера месяцев)
for i in range(1, 13):
if abs(abs(avg_y)-abs(slovar[i]))==min: ### Если отклонение месяца равно минимальному отклонению, то мы его выводим
print('%02d'%mounth[i-1], '%g'%slovar.get(i), min) ### Выводим номер месяца, температуру, отклонение (Например 09, 10, 5)
</code>
Возник вопрос, как можно нормально сделать вывод ключа словаря (последние 4 строчки)? Такое ощущение, что можно сделать куда проще. Также можно ли написать <code>
min=abs(abs(avg_y)-abs(slovar[i])</code> как-то "по-культурнее"? Если есть какие-либо другие советы касательно программы - прошу поделиться. Заранее - всем откликнувшимся огромное спасибо!
|
У словарей есть метод <code>
items()</code>, который возвращает последовательность, состоящую из пар ключ-значение.
<code>
slovar = {1: 3, 2: 10, 3: 4}
print(type(slovar.items()))
print(slovar.items())
# <class 'dict_items'>
# dict_items([(1, 3), (2, 10), (3, 4)])
</code>
Это примерно то же самое, что список из кортежей:
<code>
lst = [(1, 3), (2, 4)]
for a, b in lst:
print('{} - {}'.format(a, b))
</code>
Можно использовать это в коде:
<code>
min_value = 10
avg_y = 20
slovar = {1: 3, 2: 10, 3: 4}
for key, value in slovar.items():
if abs(abs(avg_y) - abs(value)) == min_value:
print('%02d' % key, '%g' % value, min_value)
# Результат: 02 10 10
</code>
Не используйте "min" в качестве имени переменной, потому что такое же имя имеет встроенная и всегда доступная функция - из-за этого могут быть проблемы вроде этой:
<code>
>>> min(1, 2)
1
>>> min = 10
>>> min(1, 2)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'int' object is not callable
</code>
|
23,166 | Как разделить список кортежей двух элементов на два отдельных списк? ("unzip")
Есть список вида <code>
[(1,2), (3,4), (5,6)]</code>. Как его изящно разделить на два вот таких списка?:
<code>
[1,3,5]
[2,4,6]
</code>
Вопрос не в том как это сделать, а есть ли готовая функция которая разделит их(что то типа "unzip")
Ну и на всяких случай код, как это делаю я:
<code>
tlist = [(1, 2), (3, 4), (5, 6)]
list1 = [a for a, _ in tlist]
list2 = [b for _, b in tlist]
print(list1, list2)
</code>
Хотелось бы вот так сделать:
<code>
list1, list2 = unzip(tlist, valuecount=2)
</code>
|
<code>
In [123]: items = [(1,2), (3,4), (5,6)]
In [124]: a,b = list(zip(*items))
In [125]: a
Out[125]: (1, 3, 5)
In [126]: b
Out[126]: (2, 4, 6)
</code>
|
23,168 | Реверсивный ManyToManyField
Могут ли два объекта с ManyToManyField использовать одну промежуточную таблицу?
<code>
class ObjectOne(models.Model):
bars = ManyToManyField('ObjectTwo', db_table=object_one_to_object_two)
class ObjectTwo(models.Model):
bars = ManyToManyField(ObjectOne , db_table=object_one_to_object_two)
</code>
При создании файла миграции выходит примерно такая ошибка.
(fields.E340) The field's intermediary table 'objects_one' clashes with the table name of 'object_two'.
|
Что бы использовать промежуточную таблицу для двух моделей, вам необходима создать для этой таблицы модель, а потом передать ее в параметре through у ManyToManyField
Пример из документации django
<code>
from django.db import models
class Person(models.Model):
name = models.CharField(max_length=128)
def __str__(self):
return self.name
class Group(models.Model):
name = models.CharField(max_length=128)
members = models.ManyToManyField(Person, through='Membership')
def __str__(self):
return self.name
class Membership(models.Model):
person = models.ForeignKey(Person, on_delete=models.CASCADE)
group = models.ForeignKey(Group, on_delete=models.CASCADE)
date_joined = models.DateField()
invite_reason = models.CharField(max_length=64)
</code>
Если же в промежуточной модели нет дополнительных полей то вам достаточно будет такого варианта:
<code>
class ObjectOne(models.Model):
bars = ManyToManyField('ObjectTwo')
class ObjectTwo(models.Model):
....
</code>
Django автоматически создаст таблицу которая свяжет две эти модели
|
23,169 | PyQt5 и способ получения в переменную пути к файлу
Хочу просто и легко запускать в <code>
PyQt5</code> диалоговое окно выбора файла типа такого (старый метод работает идеально кстати):
<code>
from tkinter import filedialog
wb_patch = filedialog.askopenfilename()
</code>
А вот такой код PyQt5:
<code>
from PyQt5 import QtCore, QtWidgets
wb_patch = QtWidgets.QFileDialog.getOpenFileName()
</code>
падает с 3 неизвестными ошибками в консоль.
Он вообще должен работать?
|
А так?
<code>
from PyQt5 import QtCore, QtWidgets
app = QtWidgets.QApplication([])
wb_patch = QtWidgets.QFileDialog.getOpenFileName()[0]
print(wb_patch)
# Не обязательно нужен чтобы только путь получить,
# но при создании виджетов станет обязательным
# app.exec()
</code>
|
23,170 | Подсчет количества гласных в предложении
Моя программа должна рассчитать кол-во гласных букв в предложении. Подсчета количества повторов букв смог добиться через ассоциативный массив. Дальше мои знания упираются в тупик..
<code>
from collections import Counter
a = input()
s = a
bukvi = []
i = []
glasnie = [ 'а' , 'у' , 'о' , 'ы' , 'и' , 'э' , 'я' , 'ю' ,
'ё' , 'е' , ]
lst = s.split()
for item in lst:
R = item
bukvi += R
print(bukvi)
Q = list(set(bukvi) & set(glasnie))
print(Q)
D = [ x for x in bukvi if bukvi.count(x) > 1 ]
print(D)
t = 0
array = D
c = Counter(array)
print(c)
</code>
|
Решение в функциональном стиле:
<code>
count = sum(map(lambda c: c in 'ауоыиэяюёе', input().lower()))
print(count)
</code>
Вариант без лямбды используя <code>
count</code>:
<code>
count = sum(map('ауоыиэяюёе'.count, input().lower()))
print(count)
</code>
Вариант без лямбды используя магический метод оператора <code>
in</code> (не нужно так делать):
<code>
count = sum(map('ауоыиэяюёе'.__contains__, input().lower()))
print(count)
</code>
|
23,171 | Как пересечь элементы списков?
Допустим, есть список <code>
a</code>, состоящий из:
<code>
['Зелёный','грустный','Красный','Весёлый'],['Синий','Оранжевый','Белый','Чёрный','Серый']
</code>
Каким образом я могу сделать так, чтобы получился список:
<code>
`['зелёный синий', 'зелёный оранжевый', 'зелёный белый', 'зелёный чёрный', 'зелёный серый', 'грустный синий','грустный оранжевый','грустный белый' и т.д]`
</code>
?
|
<code>
from itertools import product
a = ['Зелёный', 'Грустный', 'Красный', 'Весёлый']
b = ['Синий', 'Оранжевый', 'Белый', 'Чёрный', 'Серый']
c = [' '.join(i) for i in product(a, b)]
</code>
Ну или без импорта
<code>
c = ['{} {}'.format(x, y) for x in a for y in b]
</code>
|
23,172 | django отображение название моделей
Вопрос глупый но всё же , хочу спросить.
В чем разница отображения в стринге в моделях
<code>
class Simple(models.Model):
name = models.CharField(max_length=255,unique=True)
slug = models.SlugField(max_length=255,unique=True)
</code>
Вариант 1
<code>
def __str__(self):
return '%s' % (self.name)
</code>
Вариант 2
<code>
def __str__(self)
return '{}'.format(self.name)
</code>
|
Разницы никакой - результат будет один. Это просто разные способы форматирования строк. <code>
format()</code> был введен на замену <code>
%</code>, исправляя какие-то его недостатки.
Начиная с Python 3.6 доступен новый метод форматирования - <code>
f-strings</code>:
<code>
def __str__(self)
return f'{self.name}'
</code>
|