Python 🇺🇦

>>> format(0.1, '.17f')
'0.10000000000000001'

>>> from decimal import Decimal
>>> Decimal(1) / Decimal(3)
Decimal('0.3333333333333333333333333333')
>>> (Decimal(1) / Decimal(3)) * Decimal(3) == Decimal(1)
False

>>> from fractions import Fraction
>>> (Fraction(1) / Fraction(3)) * Fraction(3) == Fraction(1)
True

Ist = ['p', 'y']
Ist.insert(-1, 'py')

print(lst)

class Foo(object): __slots__ = ('foo',)
class Bar(object): pass

def get_set_delete(obj):
   obj.foo = 'foo'
   obj.foo
   del obj.foo

def test_foo():
   get_set_delete(Foo())

def test_bar():
   get_set_delete(Bar())

class AddableDict(dict):

   def __add__(self, other0bj):
      self.update(other0bj)
      return AddableDict(self)

dict1 = AddableDict({1 : "ABC"})
dict2 = AddableDict({2 : "EFG"})

print (dict1 + dict2)

complex(1, 3)
(1+3j)
complex(1, 3).real
1.0
complex(1, 3).imag
3.0
abs(complex(3, 4))
5.0
str(complex(1, 3))
'(1+3j)'
(3 + 2j) - (2 - 5j)
(1+7j)|

lst = [2, 2, 3, 3, 1]
list(set(lst))

_MangledGlobal__mangled = "^_^"

class MangledGlobal:

   def test(self):
      return __mangled

assert MangledGlobal().test() == "^_^"

for (a, *b, c) in [(1, 2, 3), (4, 5, 6, 7)]:    
   print(a, b, c)

import shap
import xgboost
from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split

# завантаження даних
X, y = load_boston(return_X_y=True)
X_ train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)

# навчання моделі
model = xgboost.train({"learning_rate": 0.01}, xgboost.DMatrix(X_train, label=y_train), 100)

# створення об'єкта SHAP для інтерпретації моделі
explainer = shap.Explainer(model)
shap_values = explainer(X_test)

# виведення значень SHAP для першого об'єкта із тестових даних
shap_values[0].values

class Salary:
   def __init__(self, pay):
      self.pay = pay

   def get_total(self):
      return self.pay * 12

class Employee:
   def __init__(self, pay, bonus):
      self.salary = Salary(pay)
      self.bonus = bonus

   def get_salary(self):
      return self.salary.get_total() + self.bonus

employee = Employee(5000, 10000)
employee.get_salary() # 70000

for ((a, b), c) in [((1, 2), 3), ((4, 5), 6)]:
   print(a, b, c, end="; ")

nums = [2, 3, 1, 5, 6, 4, 0]

print(sorted(nums))   # [0, 1, 2, 3, 4, 5, 6]
print(nums)           # [2, 3, 1, 5, 6, 4, 0]

print(nums.sort())    # None
print(nums)           # [0, 1, 2, 3, 4, 5, 6]

from bottle import route, run, template

@route('/hello/<name>')
   def index(name):
   return template(<b>Hello, {{name}}</b>!', name=name)

run(host='localhost', port=5000)

import numpy as np
arr = np.array([1, 2, 3, 4, 5, 4, 4])
x = np.where(arr == 4)
print(x) # (array([3, 5, 6]),)

Ist = [[0], [1, 2], [3, 4], [5]]
sum(lst, [1])

[_ for _ in range(5,0,-1) if _ == True]

txt = "Thank you for the music\n Welcome to the jungle"
x = txt.splitlines()
print(x)
# ['Thank you for the music', 'Welcome to
the jungle']

import lime
import lime.lime_tabular
import numpy as np
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_ selection import train_test_split

# завантаження даних
wine = pd.read_csv('juice.csv')

# поділ даних на тренувальні та тестові
X = juice.drop('quality', axis=1)
y = juice['quality']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# навчання моделі
model = RandomForestClassifier(random_state=42)
model.fit(X_train, y_train)

# створення об'єкта LIME для інтерпретації моделі
explainer = lime.lime_tabular.LimeTabularExplainer(
   X_train.values,
   feature_names=X.columns,
   class_names=['bad', 'good'],
   mode='classification'
)

# вибір індексу об'єкта для інтерпретації передбачення
i = 0

# отримання пояснення для передбачення
exp = explainer.explain_instance(X_test.values[i], model.predict_proba)

# виведення пояснення у вигляді списку
exp.as_list()

# pip3 install speedtest-cli

import speedtest

st = speedtest.Speedtest( )

download_speed = st.download()
print(download_speed / (2 ** 20))

# 85.1634030205186

upload_speed = st.upload()
print(upload_speed / (2 ** 20))

# 20.926127321782126

str = 'py'
del str
print(str(1.))

list1 = [1, 2, 3, 4, 1, 2, 6]
list1.reverse()
print(list1)
# [6, 2, 1, 4, 3, 2, 1]

list2 = ['a', 'b', 'c', 'd', 'a', 'a']
list2.reverse()
print(list2)
# ['a', 'a', 'd', 'c', 'b', 'a']

>>> from ast import literal_eval
>>>
>>> example = literal_eval("{'a': 1, 'b': 2}")
>>> type(example)
<class 'dict'>
>>> example
{'a': 1, 'b': 2}

class Person:
   def __init_(self, name, age):
   self.name = name
   self.age = age

def __eq__(self, other):
   return isinstance(other, Person) and self.age == other.age

def get_user_by_id(user_id):
   assert type(user_id) is int, 'user_id must be integer'
   print('Searching...')

get_user_by_id(4267)
# Searching...

get_user_by_id('foo')
# AssertionError: user_id must be integer

import numpy as np
from catboost import CatBoostClassifier

# ініціалізація даних
train_data = np.random.randint(0, 100, size=(100, 10))
train_labels = np.random.randint(0, 2, size=(100))

model = CatBoostClassifier(iterations=2, depth=2, learning_rate=1, loss_function='Logloss', verbose=True)

# навчання моделі
model.fit(train_data, train_labels)

# передбачення за допомогою отриманої моделі
preds_class = model.predict(test_data)
preds_proba = model.predict_proba(test_data)
print("class =", preds_class)
print("proba =", preds_proba)

import autosklearn.classification

cls = autosklearn.classification.AutoSklearnClassifier()
cls.fit(X_train, y_train)
predictions = cls.predict(X_test)

>>> import urllib.request
>>> import chardet
>>>
>>> data = urllib.request.urlopen('http://yahoo.com/')
>>> chardet.detect(rawdata.read())
{'encoding': 'utf-8', 'confidence': 0.99, 'language': ''}

d = {0: "p"}
d |= {1: "y"}
d

from annoy import AnnoyIndex
import random
f = 40 # Довжина індексованого векторного елемента
t = AnnoyIndex(f, 'angular')
for i in range (1000):
   v = [random.gauss(0, 1) for z in range(f)]
   t.add_item(i, v)

t.build(10) # 10 дерев
t.save('test.ann')

# ...
u = AnnoyIndex(f, 'angular')
u.load('test.ann') # дуже швидко, просто відображає файл в пам'ять
print(u.get_nns_by_item(0, 1000)) # знайде 1000 найближчих сусідів

а = 3250
b = 67_543_423_778

type(a) # <class 'int'>
type(b) # <class 'int'>
type(a) == type(b) # True

def get_user_by_id(user_id):
   assert type(user_id) is int, 'user_id must be integer'
   print('Searching...')

get_user_by_id(4267)
# Searching...

get_user_by_id('foo')
# AssertionError: user_id must be integer

d = {0: "p"}
d + {1: "p"}

languages = ['Java', 'Python', 'JavaScript']
versions = [14, 3, 6]

result = zip(languages, versions)
print(list (result))

# [('Java', 14), ('Python', 3), ('JavaScript', 6)]

>>> int('٩')
9
>>> int ('𑄺৬𝟙੩')
1613
>>> '۴'.isdecimal()
True
>>> bool(re.match('\d', '౫'))
True

>>> float('infinity')
inf
>>> float('inf')
inf
>>> float('inf') == float('infinity')
True
>>> float('-inf')
-inf
>>> float('inf') > 100 ** 100
True
>>> type float('inf'))
<class 'float'>

from fbprophet import Prophet
import pandas as pd

# Завантаження даних
df = pd.read_csv('AirPassengers.csv')
df.head()

# Підготовка даних
df.columns = ['ds', 'y']
df['ds'] = pd.to_datetime(df['ds'])

# Створення та навчання моделі
m = Prophet()
m.fit(df)

# Створення майбутніх дат для прогнозування
future = m.make_future_dataframe(periods=365)
future.tail()

# Прогнозування
forecast = m.predict(future)
forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].tail()

# Візуалізація прогнозу
fig1 = m.plot(forecast)
fig2 = m.plot_components(forecast)

>>> import jmespath
>>>
>>> jmespath.search('foo.bar', {'foo': {'bar': 'baz'}})

'baz'

>>> jmespath.search('foo.*name', {'foo': {'bar': {'name': 'one'}, 'baz': {'name': 'two'}}})
['one', 'two']

import random

mylist = ["apple", "banana", "cherry", "strawberry", "orange"]

print(random.sample(mylist, k=2))
# ['apple', 'strawberry']

import numpy as np
>>> np.array((0., 1, 2))
???

import pandas as pd

# Замінюємо всі комірки
df = pd.read_csv('data.csv')
df.fillna(130, inplace = True)

# Замінюємо тільки в Calories
df = pd.read_csv ('data.csv')
df["Calories"].fillna(130, inplace = True)

import mysql.connector

mydb = mysql.connector.connect(
   host="localhost",
   user="yourusername",
   password="yourpassword",
   database="mydatabase"
)

mycursor = mydb.cursor()

sql = "UPDATE customers SET address = 'Canyon 123' WHERE address = 'Valley 345'"

mycursor.execute(sql)

mydb.commit()

print(mycursor.rowcount, "record(s) affected")

import numpy as np
>>> np.array(0., 1, 2)
???

import numpy as np
x = np.array([0, 1, 2, 5, 2, 6, 5, 2, 3, 1])
u, indices = np.unique(x, return_inverse=True)
print(u)
# [0, 1, 2, 3, 5, 6]

class Generator(nn.Module):

   def __init__(self):
      super().__init__()
      self.model = nn.Sequential(
         nn.Linear(2, 16),
         nn.ReLU(),
         nn.Linear(16, 32),
         nn.ReLU(),
         nn.Linear(32, 2),
      )

   def forward(self, x):
      output = self.model(x)
      return output

generator = Generator()

import numpy as np
>>> np.array([0., 1, 2])
???

import numpy as np

arr = np.trunc([-3.1666, 3.6667])
print(arr) # [-3. 3.]

arr1 = np.fix([-3.1666, 3.6667])
print(arrl) # [-3. 3.]

arr2 = np.around(3.1666, 2)
print(arr2) # 3.17

arr3 = np.floor([-3.1666, 3.6667])
print(arr3) # [-4. 3.]

arr4 = np.ceil([-3.1666, 3.6667])
print(arr4) # [-3. 4.]

items = [1, 2, 3, 4, 5]
for item in items:
   print(item)

import pandas as pd

df = pd.read_csv('data.csv')
new_df = df.dropna()
df.dropna(inplace = True)

print(df.to_string())

>>> tp = (,)
>>> (1, 2) + tp

class DefaultDict(dict):
   def __init__(self, default_value, *args, **kwargs):
      self.default_value = default_value
      super().__init__(*args, **kwargs)

   def __missing__(self, key):
      return self.default_value

d = DefaultDict('default')
print(d['key']) # Виведе: 'default'

def square(x):
   return x * x

if __name__ == "__main__":
   import doctest
   doctest.testmod(verbose=True)

import numpy as np
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
arr = np.concatenate((arr1, arr2))
print(arr) # [1 2 3 4 5 6]

i = 10
print(i(5%2))

import numpy as np
from bashplotlib.histogram import plot_hist

arr = np.random.normal(size=1000, loc=0, scale=1)
plot_hist(arr, bincount=50)

import pymongo

myclient = pymongo.MongoClient("mongodb: //localhost: 27017/")
mydb = myclient["mydatabase"]
mycol = mydb["customers"]

myquery = {"address": {"$gt": "S"}}

mydoc = mycol.find(myquery)

for x in mydoc:
   print(x)

f = open("test.txt", "a")
f.writelines(["See you soon!", "Over and out."])
f.close()

f = open("test.txt", "r")
print(f.read())

fruits = {"apple", "banana", "cherry"}

fruits.discard("banana")

print(fruits)
# ['cherry', 'apple']

class Foo:
   obj=None

   def obj(self):
      return 'py'

ob = Foo()

print(type(ob.obj), type(ob.obj()))

import wx

class TestFrame(wx.Frame):
   def __init__(self, parent, title):
      wx.Frame.__init__(self, parent, id=-1, title=title)
      text = wx.StaticText(self, label=title)

app = wx.App()
frame = TestFrame(None, "Hello, world!")
frame.Show()
app.MainLoop()

class Person:
   name = "John"
   age = 36
   country = "norway"

x = vars(Person)
print(x)
# {'age': 36, '__module__': '__main__', '__doc__': None, 'name': 'John', 'country': 'norway'}

class Functor(object):
   def __init__(self, n=10):
      self.n = n

   def __call__(self, x):
      x_first = x[0]
      if type(x_first) is int:
         return self. __MergeSort(x)
      if type(x_first) is float:
         return self. __HeapSort(x)
      else:
         return self. __QuickSort(x)

import numpy as np

arr = np.array([1, 2, 3, 4, 5, 4, 4])

x = np. where(arr == 4)

print(x)
# (array([3, 5, 6],)

import mysql.connector

mydb = mysql.connector.connect(
   host="localhost"
   user="yourusername",
   password="yourpassword",
   database="mydatabase"
)

mycursor = mydb.cursor()

sql =
"SELECT * FROM customers WHERE address ='Park Lane 38'"

mycursor.execute(sql)

myresult = mycursor.fetchall()

for x in myresult:
   print(x)

import matplotlib.pyplot as plt
import numpy
from sklearn import metrics

actual = numpy.random.binomial(1,.9,size = 1000)
predicted = numpy.random.binomial(1,.9,size = 1000)

confusion_matrix = metrics.confusion_matrix(actual, predicted)

cm_display = metrics.ConfusionMatrixDisplay(confusion_matrix = confusion_matrix, display_labels = [False, True])

cm_display.plot()
plt.show()

import pymongo

myclient = pymongo.MongoClient("mongodb://localhost:27017/")
mydb = myclient["mydatabase"]
mycol = mydb["customers"]

mydict = {"name": "John", "address": "Highway 37"}

x = mycol.insert_one(mydict)

def div(a:float, b: float) -> float:
   return a/b

print(div(4,2))

x = {"f", "e", "d", "c", "b", "a"}
y = {"a", "b", "c"}

z = x.issuperset(y)

print(z) # True

from scipy.spatial import KDTree

points = [(1, -1), (2, 3), (-2, 3), (2, -3)]

kdtree = KDTree(points)

res = kdtree.query((1, 1))

print(res) # (2.0, 0)

import numpy as np
from scipy.sparse.csgraph import dijkstra
from scipy.sparse import csr_matrix

arr = np.array([
   [0, 1, 2],
   [1, 0, 0],
   [2, 0, 0]
])

newarr = csr_matrix(arr)

print(dijkstra(newarr, return_predecessors=True, indices=0))
# (array([0., 1., 2.]), array([-9999,        0,       0]))

class Foo:
   def__new__(cls,*args,**kwargs):
      print ('new', end=' ')
   def__init__(self):
      print('init', end=' ')

>>> Foo()
???

import itertools

a_list = [("Animal", "cat"),
              ("Animal", "dog"),
              ("Bird", "peacock"),
              ("Bird", "pigeon")]

an_iterator = itertools.groupby(a_list, lambda x : x[0])
for key, group in an_iterator:
   key_and_group = {key : list (group)}
   print(key_and_group)

# {'Animal': [('Animal', 'cat'), ('Animal', 'dog')]}
# {'Bird': [('Bird', 'peacock'), ('Bird', 'pigeon')]}

class Calculator:
   def add(x, y):
      return x + y

   @staticmethod
   def substruct(x, y):
      return x - y

Calculator.add = staticmethod(Calculator.add)
Calculator.add(10, 15)
# 25

Calculator.substruct (30, 20)
# 10

from fnmatch import fnmatch

fnmatch('foo.txt', '*,txt') # True
fnmatch('foo.txt', '?oo. txt') # True
fnmatch('Dat45.csv', 'Dat [0-9]*') # True
names = ['Dat1.csv', 'Dat2.csv', 'config.ini', 'foo-py']
[name for name in names if fnmatch (name, 'Dat*,csv')]
# ['Dat1.csv', 'Dat2. csv']

>>> from datetime import date, timedelta
>>> dt = date(2022, 11, 3)
>>> dt-timedelta(days=1)
???

import shutil

total_b, used_b, free_b = shutil.disk_usage('.')

gb = 10 ** 9

print('Total: {:6.2f} GB'.format(total_b / gb))
print('Used: {:6.2f} GB'.format(used_b / gb))
print('Free : {:6.2f} GB'.format(free_b / gb))

# Output:
# Total: 245.11 GB
# Used : 128.38 GB
# Free: 99.04 GB

f = open ("demofile2.txt", "a")
f.truncate(20)
f.close()

f = open("demofile2.txt", "r")
print(f.read())

import statistics
print(statistics.stdev([1, 3, 5, 7, 9, 11]))
# 3.7416573867739413
print(statistics.stdev([2, 2.5, 1.25, 3.1, 1.75, 2.8]))
# 0.6925797186365383
print(statistics.stdev([-11, 5.5, -3.4, 7.1]))
# 8.414471660973927
print(statistics.stdev([1, 30, 50, 100]))
# 41.67633221226008