Python-сообщество

 from openpyxl import load_workbook
wbSearch = load_workbook("Отчет.xlsx", data_only=True)
wsSearch = wbSearch.active
wsSearch.cell(row=1, column=1).value = 10
wbSearch.save("Отчет.xlsx")

 # загрузим библиотеки и установим опции
 
from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns
 
import pickle
import numpy as np
import pandas as pd
from scipy.sparse import csr_matrix
from scipy.sparse import hstack
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import roc_auc_score
from sklearn.linear_model import LogisticRegression
 
from sklearn.datasets import load_files
from sklearn.svm import LinearSVC
 
 
# загрузим обучающую и тестовую выборки
train_df = pd.read_csv('C:/Users/Kazzi/Desktop/mlcourse_open-master/data/train_sessions.csv',
                       index_col='session_id')
test_df = pd.read_csv('C:/Users/Kazzi/Desktop/mlcourse_open-master/data/test_sessions.csv',
                      index_col='session_id')
 
# приведем колонки time1, ..., time10 к временному формату
times = ['time%s' % i for i in range(1, 11)]
train_df[times] = train_df[times].apply(pd.to_datetime)
test_df[times] = test_df[times].apply(pd.to_datetime)
 
# отсортируем данные по времени
train_df = train_df.sort_values(by='time1')
 
# посмотрим на заголовок обучающей выборки
train_df.head()
 
# приведем колонки site1, ..., site10 к целочисленному формату и заменим пропуски нулями
sites = ['site%s' % i for i in range(1, 11)]
train_df[sites] = train_df[sites].fillna(0).astype('int')
test_df[sites] = test_df[sites].fillna(0).astype('int')
 
# загрузим словарик сайтов
with open(r"C:/Users/Kazzi/Desktop/mlcourse_open-master/data/site_dic.pkl", "rb") as input_file:
    site_dict = pickle.load(input_file)
 
# датафрейм словарика сайтов
sites_dict = pd.DataFrame(list(site_dict.keys()), index=list(site_dict.values()), columns=['site'])
print(u'всего сайтов:', sites_dict.shape[0])
sites_dict.head()
 
# топ-сайты в обучающей выборке
top_sites = pd.Series(train_df[sites].fillna(0).values.flatten()
                     ).value_counts().sort_values(ascending=False).head(5)
print(top_sites)
sites_dict.ix[top_sites.index]
 
 
time_df = pd.DataFrame(index=train_df.index)
time_df['target'] = train_df['target']
 
# найдем время начала и окончания сессии
time_df['min'] = train_df[times].min(axis=1)
time_df['max'] = train_df[times].max(axis=1)
 
# вычислим длительность сессии и переведем в секунды
time_df['seconds'] = (time_df['max'] - time_df['min']) / np.timedelta64(1, 's')
 
time_df.head()
# создадим отдельный датафрейм, где будем работать со временем
time_df = pd.DataFrame(index=train_df.index)
time_df['target'] = train_df['target']
​
# найдем время начала и окончания сессии
time_df['min'] = train_df[times].min(axis=1)
time_df['max'] = train_df[times].max(axis=1)
​
# вычислим длительность сессии и переведем в секунды
time_df['seconds'] = (time_df['max'] - time_df['min']) / np.timedelta64(1, 's')
​
time_df.head()
 
# наша целевая переменная
y_train = train_df['target']
 
# объединенная таблица исходных данных
full_df = pd.concat([train_df.drop('target', axis=1), test_df])
 
# индекс, по которому будем отделять обучающую выборку от тестовой
idx_split = train_df.shape[0]
 
full_df.corr()
 
# табличка с индексами посещенных сайтов в сессии
full_sites = full_df[sites]
full_sites.head()
 
# последовательность с индексами
sites_flatten = full_sites.values.flatten()
 
# искомая матрица
full_sites_sparse = csr_matrix(([1] * sites_flatten.shape[0],
                                sites_flatten,
                                range(0, sites_flatten.shape[0]  + 10, 10)))[:, 1:]
 
%%time
# выделим из объединенной выборки только обучающую (для которой есть ответы)
X_train = full_sites_sparse[:idx_split, :]
 
# считаем метрику на валидационной выборке
print(get_auc_lr_valid(X_train, y_train))
 
# функция для записи прогнозов в файл
def write_to_submission_file(predicted_labels, out_file,
                             target='target', index_label="session_id"):
    predicted_df = pd.DataFrame(predicted_labels,
                                index = np.arange(1, predicted_labels.shape[0] + 1),
                                columns=[target])
    predicted_df.to_csv(out_file, index_label=index_label)
 
# обучим модель на всей выборке
# random_state=17 для воспроизводимости
# параметр C=1 по умолчанию, но здесь мы его укажем явно
lr = LogisticRegression(C=1.0, random_state=17).fit(X_train, y_train)
 
# обучим модель на всей выборке
# random_state=17 для воспроизводимости
# параметр C=1 по умолчанию, но здесь мы его укажем явно
lr = LogisticRegression(C=1.0, random_state=17).fit(X_train, y_train)
 
def plot_grid_scores(grid, param_name):
    plt.plot(grid.param_grid[param_name], grid.cv_results_['mean_train_score'],
        color='green', label='train')
    plt.plot(grid.param_grid[param_name], grid.cv_results_['mean_test_score'],
        color='red', label='test')
    plt.legend();
 
visualize_coefficients(lr, site_dict)
 
 
full_new_feat = pd.DataFrame(index=full_df.index)
 
# добавим признак start_month
full_new_feat['start_month'] = full_df['time1'].apply(lambda ts: 100 * ts.year + ts.month)
# датафрейм для новых признаков
 
# рассчитаем количество сессий Элис по месяцам
tmp = full_new_feat.ix[:idx_split, 'start_month'].to_frame()
tmp['target'] = y_train
stm_vs_target = tmp.groupby('start_month')['target'].sum()
 
# вывод таблички
print(stm_vs_target)
 
 
# построим график
x_axis = stm_vs_target.index
y_axis = stm_vs_target.values
fig=plt.figure(figsize=(12, 8))
ax1=fig.add_subplot(111)
line1 = ax1.plot(y_axis,'ro',label='line1')
plt.xticks(range(len(y_axis)), x_axis)
ax1.set_ylabel('y values',fontsize=12)
lines = line1
labels = [l.get_label() for l in lines]
ax1.set_xlabel('ГГГГММ',fontsize=14)
ax1.set_ylabel('Кол-во сессий',fontsize=14)
plt.setp(ax1.get_xticklabels(), visible=True)
plt.suptitle(u'Количество сессий Элис по месяцам', y=1.0, fontsize=17)
fig.tight_layout()
fig.subplots_adjust(top=0.96,bottom=0.4)
plt.show() 
 
# добавим новый признак в разреженную матрицу
tmp = full_new_feat[['start_month']].as_matrix()
X_train = csr_matrix(hstack([full_sites_sparse[:idx_split,:], tmp[:idx_split,:]]))
 
# считаем метрику на валидационной выборке
print(get_auc_lr_valid(X_train, y_train))
 
# добавим новый стандартизированный признак в разреженную матрицу
tmp = StandardScaler().fit_transform(full_new_feat[['start_month']])
X_train = csr_matrix(hstack([full_sites_sparse[:idx_split,:], tmp[:idx_split,:]]))
 
# считаем метрику на валидационной выборке
print(get_auc_lr_valid(X_train, y_train))
 
full_new_feat['start_hour'] = full_df['time1'].apply(lambda ts: ts.hour)
full_new_feat['morning'] = full_new_feat['start_hour'].apply(lambda hour: int(hour <= 11))
 
 
# scaled start_hour
tmp_scaled = StandardScaler().fit_transform(full_new_feat[['start_month', 'start_hour']])
X_train = csr_matrix(hstack([full_sites_sparse[:idx_split,:], 
                             tmp_scaled[:idx_split,:]]))
print(get_auc_lr_valid(X_train, y_train))
# 0.957924006323 <---
 
# raw start_hour
tmp_raw = full_new_feat[['start_hour']].as_matrix()
tmp_scaled = StandardScaler().fit_transform(full_new_feat[['start_month']])
X_train = csr_matrix(hstack([full_sites_sparse[:idx_split,:], 
                             tmp_scaled[:idx_split,:]]))
print(get_auc_lr_valid(X_train, y_train))
# 0.919698464197
 
 
 
# scaled morning
tmp_scaled = StandardScaler().fit_transform(full_new_feat[['start_month', 'morning']])
X_train = csr_matrix(hstack([full_sites_sparse[:idx_split,:], 
                             tmp_scaled[:idx_split,:],
                             tmp_raw[:idx_split,:]]))
print(get_auc_lr_valid(X_train, y_train))
# 0.958430928728 <---
                         
# raw morning
tmp_raw = full_new_feat[['morning']].as_matrix()
tmp_scaled = StandardScaler().fit_transform(full_new_feat[['start_month']])
X_train = csr_matrix(hstack([full_sites_sparse[:idx_split,:], 
                             tmp_scaled[:idx_split,:],
                             tmp_raw[:idx_split,:]]))
print(get_auc_lr_valid(X_train, y_train))
# 0.948665199943
 
 
# start_hour и morning
tmp_scaled = StandardScaler().fit_transform(full_new_feat[['start_month', 'start_hour', 'morning']])
X_train = csr_matrix(hstack([full_sites_sparse[:idx_split,:], 
                             tmp_scaled[:idx_split,:]]))
print(get_auc_lr_valid(X_train, y_train))
# 0.959149043641 <---
 
full_new_feat.corr()
 
# формируем обучающую выборку
tmp_scaled = StandardScaler().fit_transform(full_new_feat[['start_month', 'start_hour', 'morning']])
X_train = csr_matrix(hstack([full_sites_sparse[:idx_split,:], 
                             tmp_scaled[:idx_split,:]]))
 
# зафиксируем качество с параметрами по умолчанию
score_C_1 = get_auc_lr_valid(X_train, y_train)
print(score_C_1)
 
%%time
# набор возможных значений С
Cs = np.logspace(-3, 1, 10)
 
scores = []
    
for C in Cs:
    scores.append(get_auc_lr_valid(X_train, y_train, C=C))
 
plt.plot(Cs, scores, 'ro-')
plt.xscale('log')
plt.xlabel('C')
plt.ylabel('AUC-ROC')
plt.title('Подбор коэффициента регуляризации')
# горизонтальная линия -- качество модели с коэффициентом по умолчанию
plt.axhline(y=score_C_1, linewidth=.5, color = 'b', linestyle='dashed') 
plt.show()
 
# подготовим данные для обучения и теста
tmp_scaled = StandardScaler().fit_transform(full_new_feat[['start_month', 'start_hour', 'morning']])
X_train = csr_matrix(hstack([full_sites_sparse[:idx_split,:], 
                             tmp_scaled[:idx_split,:]]))
X_test = csr_matrix(hstack([full_sites_sparse[idx_split:,:], 
                            tmp_scaled[idx_split:,:]]))
 
# обучим модель на всей выборке с оптимальным коэффициентом регуляризации
lr = LogisticRegression(C=C, random_state=17).fit(X_train, y_train)

 import asyncio
import asyncpg
async def run():
    conn = await asyncpg.connect(user='user', password='password',
                                 database='database', host='127.0.0.1')
    values = await conn.fetch('''SELECT * FROM mytable''')
    await conn.close()
loop = asyncio.get_event_loop()
loop.run_until_complete(run())

 @app.route("/", methods=['POST'])
async def test(request):
     run()
     return json({'status_code': 200})

 from tkinter import *
from tkinter import messagebox
from tkinter import filedialog
import time
from datetime import datetime
def popup(event):
    pmenu.tk_popup(event.x_root, event.y_root)
def app():
    messagebox.showinfo('About the App','The name of programm is Notepad\nVersion 0.1\nMade on Python 3.6.2 in 06.01.2018')
def author():
    messagebox.showinfo('About the Author','The Author of the programm is *********\nThanks for using us!')
def close(event=None):
    wn.destroy()
    
def newfile(event=None):
    wn.title('Untitled.txt') #Nameless.txt
    field.delete(1.0, END)
def openfile(event=None):
    filename = filedialog.askopenfilename()
    pos = filename.rfind('/') + 1
    newName = filename[pos:]
    
    file = open(filename, 'r')
    content = file.read()
    field.delete(1.0, END)
    field.insert(1.0, content)
    file.close()
    wn.title(newName)
def savefile(event=None):
    filename = filedialog.asksaveasfilename()     
    file = open(filename + '.txt', 'w')
    content = field.get(1.0, END)
    file.write(content)
    file.close()
    
def cut():
    field.event_generate('<<Cut>>')
def copy():
    field.event_generate('<<Copy>>')
def paste():
    field.event_generate('<<Paste>>')    
def undo():
    field.event_generate('<<Undo>>')
def redo(event=None):
    field.event_generate('<<Redo>>')
def delete():
    field.event_generate('<<Clear>>')
def selectall():
    field.event_generate('<<SelectAll>>')
def time_and_date(event=None):
    field.insert(END, datetime.now())
    
wn = Tk()
wn.geometry('400x400')
wn.title('Notepad')
menubar = Menu()
wn.config(menu=menubar)
fmenu = Menu(menubar)
menubar.add_cascade(label='File', menu=fmenu)
fmenu.add_command(label='New File', accelerator='Ctrl+N', command=newfile)
fmenu.add_command(label='Open', accelerator='Ctrl+O', command=openfile)
fmenu.add_command(label='Save As', accelerator='Ctrl+S', command=savefile)
fmenu.add_command(label='Close', accelerator='Ctrl+Q', command=close)
editmenu = Menu(menubar)
menubar.add_cascade(label='Edit', menu=editmenu)
editmenu.add_command(label='Cut', accelerator='Ctrl+X', command=cut)
editmenu.add_command(label='Copy', accelerator='Ctrl+C', command=copy)
editmenu.add_command(label='Paste', accelerator='Ctrl+V', command=paste)
editmenu.add_command(label='Undo', accelerator='Ctrl+Z', command=undo)
editmenu.add_command(label='Redo', accelerator='Shift+Ctrl+Z',command=redo)
editmenu.add_command(label='Delete', accelerator='Del', command=delete)
editmenu.add_command(label='Select All', accelerator='Ctrl+A', command=selectall)
editmenu.add_command(label='Time and Date', accelerator='Ctrl+Tab',command=time_and_date)
aboutmenu = Menu(menubar)
menubar.add_cascade(label='About', menu=aboutmenu)
aboutmenu.add_command(label='About the App', command=app)
aboutmenu.add_command(label='About the Author', command=author)
setingsmenu = Menu(menubar)
menubar.add_cascade(label='Setings', menu=setingsmenu)
field = Text(wn)
field.pack()
pmenu = Menu(field)
pmenu.add_command(label='Cut', accelerator='Ctrl+X', command=cut)
pmenu.add_command(label='Copy', accelerator='Ctrl+C', command=copy)
pmenu.add_command(label='Paste', accelerator='Ctrl+V', command=paste)
pmenu.add_command(label='Select All', accelerator='Ctrl+A', command=selectall)
pmenu.add_command(label='Undo', accelerator='Ctrl+Z', command=undo)
pmenu.add_command(label='Redo', accelerator='Shift+Ctrl+Z', command=redo)
field.bind('<Button-3>', popup)
field.bind('<Control-n>', newfile)
field.bind('<Control-o>', openfile)
field.bind('<Control-s>', savefile)
field.bind('<Control-Z>', redo)
field.bind('<Control-Tab>', time_and_date)
field.bind('<Control-q>', close)

  def MotorOff():

 def MotorOff():

 #!/usr/bin/env python
# coding: utf-8
# Load library functions we want
import SocketServer
import serial
import time
#***************INIT BLOK************************
port = serial.Serial("/dev/ttyACM0", baudrate=9600, timeout=3.0) #для отладки
#port = serial.Serial("/dev/ttyS2", baudrate=9600, timeout=3.0) #для робота
#структура массива для передачи команд [x1,y1,x2,y2,x3,x4,key_axis_L ... key_B] и того 6-Осей 10-Кнопок
#utp_command_resiv = ['X', 'X', 'X', 'X','X', 'X', 'X', 'X','X', 'X', 'X', 'X','X', 'X', 'X', 'X']     
# Map of drives to pins
lDrives = ["a", "a", 'a', "a"]
#port.write("\xAA\x0A\x04\x01\x05\x55\x2A") #motor pwm= 150hz save
#rcv =  port.readline () # читаем ответ конроллера
#print  ("\r\return:" + repr(rcv)) # return =0 ok иначе команда не принята
#*****************END INIT BLOK********************
# Function to set all drives off
 
def MotorOff():
    port.write("\xAA\x0A\x06\x00") # motor M0 stop!!!
    port.write("\xAA\x0A\x07\x00") # motor M1 stop!!!
    pass
    
def Motor_M0(value_M0):       
    if value_M0 > 255 :
        value_M0 = 255 
    elif  value_M0 < -255:
        value_M0 = -255
    #print   (value_M0)
    if value_M0 < -15 and value_M0 > -256 :    # -15 до -255  зона джойстика X1 Назад
        if abs(value_M0) > 127:
            #print   ("M0= ", value_M0)
            port.write(("\xAA\x0A\x0B")+chr(abs(value_M0)-128)) #
        else:
            #print   ("M0-1= ",value_M0)
            port.write (("\xAA\x0A\x0A")+chr(abs(value_M0)))    #
        pass
    elif value_M0 > 15 and value_M0 < 256 :    # 15 до 255 зона джойстика X1 Вперед
        if value_M0 > 127:
            #print   ("M0= ",value_M0)
            port.write (("\xAA\x0A\x09")+chr(abs(value_M0)-128))   #
        else:
            #print   ("M0= ",value_M0)
            port.write (("\xAA\x0A\x08")+chr(abs(value_M0)))   #              
        pass
    else :                # значение в районе 0 остановим двигатель 
        port.write("\xAA\x0A\x06\x00") # motor M0 stop!!!
        #port.write("\xAA\x0A\x07\x00") # motor M1 stop!!!
        print   ("M0= 0")
        pass
def Motor_M1(value_M1):
    
    if value_M1 > 255 :
        value_M1 = 255 
    elif  value_M1 < -255:
        value_M1 = -255
    #print   (value_M1)    
    if value_M1 < -15 and value_M1 > -256 :    # -15 до -255  зона джойстика X1 Назад
        if abs(value_M1) > 127:
            #print   ("M1= ",value_M1)
            port.write (("\xAA\x0A\x0F")+chr(abs(value_M1)-128))   #
        else:
            #print   ("M1= ",value_M1)
            port.write (("\xAA\x0A\x0E")+chr(abs(value_M1)))   #
        pass
    elif value_M1 > 15 and value_M1 < 256 :    # 15 до 255 зона джойстика X1 Вперед
        if value_M1 > 127:
            #print   ("M1= ",value_M1)
            port.write (("\xAA\x0A\x0D")+chr(abs(value_M1)-128))   #
        else:
            #print   ("M1= ",value_M1)
            port.write (("\xAA\x0A\x0C")+chr(abs(value_M1)))   #              
        pass
    else :                # значение в районе 0 остановим двигатель 
        #port.write("\xAA\x0A\x06\x00") # motor M0 stop!!!
        port.write("\xAA\x0A\x07\x00") # motor M1 stop!!!
        print   ("M1= 0")
        pass
# Settings for the RemoteKeyBorg server
portListen = 9038                       # What messages to listen for (LEDB on an LCD)
# Class used to handle UDP messages
class PicoBorgHandler(SocketServer.BaseRequestHandler):
    # Function called when a new message has been received
    def handle(self):
        global isRunning
        #global var_x1
        #global var_y1
        request, socket = self.request          # Read who spoke to us and what they said
        request = request.upper()               # Convert command to upper case
        driveCommands = request.split(',')      # Separate the command into individual drives
        if len(driveCommands) == 1:
            # Special commands
            if request == 'ALLOFF':
                # Turn all drives off
                MotorOff()
                print 'All drives off'
            elif request == 'EXIT':
                # Exit the program
                isRunning = False
            else:
                # Unknown command
                print 'Special command "%s" not recognised' % (request)
                
        elif len(driveCommands) == 16: # 16 - длинна принятого массива команд
            #print   (driveCommands, )  #для отладки
            #print   (driveCommands[0]) #для отладки
            #структура массива для передачи команд [x1,y1,x2,y2,x3,x4,key_axis_L ... key_B] и того 6-Осей 10-Кнопок
            #utp_command_resiv = ['X', 'X', 'X', 'X','X', 'X', 'X', 'X','X', 'X', 'X', 'X','X', 'X', 'X', 'X']            
#            for driveNo in range(len(driveCommands)):
#                command = driveCommands[driveNo]
            pass 
            Motor_M0 ((int(driveCommands[0])+int(driveCommands[1])))
            Motor_M1 ((int(driveCommands[0])-int(driveCommands[1])))
        else:
            # Did not get the right number of drive commands
            print 'Command "%s" did not have %d parts!' % (request, len(lDrives))
try:
    global isRunning #начало ****************************
    value_M0 = 0   
    value_M1 = 0
    # Start by turning all drives off
    MotorOff()
    #raw_input('Теперь вы можете включить питание, нажмите клавишу ВВОД')
    # слушать UDP
    remoteKeyBorgServer = SocketServer.UDPServer(('', portListen), PicoBorgHandler)
    
    isRunning = True
    while isRunning: # проверка пока приходит телеметрия *****************************
        remoteKeyBorgServer.handle_request()   
    # Выключите driver и освободить контакты GPIO закончилась телеметрия
    print 'Finished'
    MotorOff()
    raw_input('Выключите питание, нажмите клавишу ВВОД, чтобы продолжить')
    #GPIO.cleanup()
    pass
except KeyboardInterrupt: # если нажали CTRL+C ***********************
    # CTRL + C выход, отключить диски и освободить контакты GPIO
    print 'Terminated'
    MotorOff()
    raw_input('Выключите питание, нажмите клавишу ВВОД, чтобы продолжить')
    MotorOff()
    pass
    #GPIO.cleanup()

 from ftplib import FTP
import os
ftp = FTP('ftp.ubuntu.com')
print(ftp.login())
ftp.cwd('ubuntu')
data = ftp.retrlines('LIST')
print(data)
filenames = ftp.nlst()
for filename in filenames:
    host_file = os.path.join(
        'D:\\files', filename
    )
    try:
        with open(host_file, 'wb') as local_file:
            ftp.retrbinary('RETR ' + filename, local_file.write)
    except ftplib.error_perm:
        pass
ftp.quit()

 import gi
gi.require_version('Gtk', '3.0')           # NOQA
gi.require_version('WebKit', '3.0')        # NOQA
from gi.repository import Gtk, Gdk, WebKit
from urllib.request import pathname2url
import os
import time
def get_source(webj, frame):
    print ("loading...doc2")
    while True:
        try:
            web.execute_script("$('nav').html('1');")
        except:
            print(" неудачно")
        time.sleep(2.2) 
win = Gtk.Window()
web = WebKit.WebView()
url = 'index.html'
startpage = 'file://' + pathname2url(os.path.abspath(url))
web.open(startpage)
web.connect('load-finished', get_source)
win.add(web)
win.show_all()
Gtk.main()

 s = np.cumsum((p1 * r1), axis = 1)+np.cumsum((p2*r2),axis = 1)+np.cumsum((p3*r3),axis = 1)
        print(s)

 lexone@DebianWorkStation:~/Документы/python/pygame-master$ python3 setup.py build
Traceback (most recent call last):
  File "setup.py", line 109, in <module>
    from setuptools import setup, find_packages
ModuleNotFoundError: No module named 'setuptools'
lexone@DebianWorkStation:~/Документы/python/pygame-master$ sudo apt-get install python3-setuptools
Чтение списков пакетов… Готово
Построение дерева зависимостей       
Чтение информации о состоянии… Готово
Уже установлен пакет python3-setuptools самой новой версии (33.1.1-1).
обновлено 0, установлено 0 новых пакетов, для удаления отмечено 0 пакетов, и 104 пакетов не обновлено.