for-if-while

for i in range(5): print(i, end=' ')		# 0 1 2 3 4 
print() # новая строка
for i in range(4,10): print(i, end=' ')		# 4 5 6 7 8 9 
print()
for i in range(1,10,3): print(i, end=' ')	# 1 4 7 
print()
for i in range(10,5,-1): print(i, end=' ')	# 10 9 8 7 6 
print()
for i in range(10,1,-3): print(i, end=' ')	# 10 7 4

if num > 100:
	if num < 150:
		print "Число больше ста, но меньше ста пятидесяти"
	elif num <  200:
		print "Число больше ста, но меньше двухсот"
elif num > 50:
	if num < 90:
		print "Число больше пятидесяти, но меньше девяноста"
	else:
		print "Число больше пятидесяти и больше девяноста"
else:
	print "Число меньше пятидесяти"

n=10
while n>3:
    print(n, end=' ')
    n-=1

Возбудить исключение:

    raise Exception("k=%5d, x=%10.5f"%(k, x))
    raise RuntimeError("Something bad happened")

Целые числа

k = int(input('Введите целое число: '))

print( 10/3)     # 3.3333333333333335
print( 10//3)    # 3
print( 10%3)     # 1
print( 2**8, pow(2,8)) # 256 256
print( pow(2,8, 10)) # 2**8 mod 10 = 6

q, r = divmod(-137, 10)  #  q=-14, r=3

print( 6&3, 6|3, 6^3)	# 2 7 5
print( 5<<1, 5<<2)	# 10 20
print( 5>>1, 5>>2)	# 2 1

import math
print(math.factorial(5))  # 120
print(math.factorial(155))  # 478...000

N=2*10**6; prs=[2]	# в начале prs - список из одного элемента0
for n in range(3,N,2):	# цикл по нечётным начиная с 3
  for p in prs:		# цикл по элементам списка prs
    if n%p==0: break
    if p*p>n:
      prs.append(n)
      break
#print(prs) 		# этот список будет слишком велик
print(len(prs), max(prs)) # количество элементов и максимальный элемент

for i in range (0,1777):
    if (i%20)==0: 
        print(i)
    n1= 10**i
    n = n1+1
    for p in [2,3,5,7]:
        k = pow(p,n1,n)
        if k!=1:
            if p>2:
                print(i, 'not prime  ', p)
            break
    else:
        print(i, 'prime', n, '--------')

t = True; f = False
print(type(t)) # Prints ""
print(t and f) # Logical AND; prints "False"
print(t or f)  # Logical OR; prints "True"
print(not t)   # Logical NOT; prints "False"
print(t != f)  # Logical XOR; prints "True"

Дата и время

import time
print(time.time())  # 1553929407.9740036, текущее время в секундах

import datetime
now = datetime.datetime.now()
print(now)             # 2018-09-20 17:46:38.502740
print(now.date())      # 2018-09-20
print(now.time())      # 17:46:38.502740
dt = datetime.date(1924, 6, 24)
print(dt)              # 1924-06-24
print(now.date()-dt)   # 34421 days, 0:00:00

Строки

s='abc'
r='Русские буквы'
t="Двойные кавычки"
print(s+t)             # abcДвойные кавычки
print(s*4)             # abcabcabcabc       Повтор 4 раза

    s = '''Тройные кавычки!
      Продолжение
     кавычки " внутри и одинарная кавычка' конец'''
    print(s)

print(r[:7])           # Русские           
print(r[2:7])          # сские             
print(r[-5:])          # буквы              Начиная с конца
print(r[-11:-2])       # сские бук         
print(r[-11:-2:2])     # скебк              Через одну букву

print(' k=%5d, x=%10.6f'%( k, x)) # k=   77, x= 33.330000

line = '   один  два  три   '
lin2 = '   один,  два,  три   '
print('<%s>' %line.lstrip())    # <один  два  три   >
print('<%s>' %line.rstrip())    # <   один  два  три>
print('<%s>' %line.strip())     # <один  два  три>

words = line.split()
for key in words: print(key.strip(), end='-')  # один-два-три-
print('')
words = line.split(',')
for key in words: print(key.strip(), end='-')  # один  два  три-
print('')

words = lin2.split()
for key in words: print(key.strip(), end='-')  # один,-два,-три-
print('')
words = lin2.split(',')
for key in words: print(key.strip(), end='-')  # один-два-три-
print('')

s = "hello"
print(s.capitalize())  # Capitalize a string; prints "Hello"
print(s.upper())       # Convert a string to uppercase; prints "HELLO"
print(s.rjust(7))      # Right-justify a string, padding with spaces; prints "  hello"
print(s.center(7))     # Center a string, padding with spaces; prints " hello "
print(s.replace('l', '(ell)'))  # Replace all instances of one substring with another;
                                # prints "he(ell)(ell)o"
print('  world '.strip())  # Strip leading and trailing whitespace; prints "world"

s = '''Тройные кавычки!
  Продолжение
 и кавычки " внутри одинарная' вот'''
print(s)

Списки

xs = [3, 1, 2]    # Create a list
print(len(xs)     # Длина последовательности, 3
print(xs, xs[2])  # Prints "[3, 1, 2] 2"
print(xs[-1])     # Negative indices count from the end of the list; prints "2"
xs[2] = 'foo'     # Lists can contain elements of different types
print(xs)         # Prints "[3, 1, 'foo']"
xs.append('bar')  # Add a new element to the end of the list
print(xs)         # Prints "[3, 1, 'foo', 'bar']"
x = xs.pop()      # Remove and return the last element of the list
print(x, xs)      # Prints "bar [3, 1, 'foo']"
xs.extend(L)      # Расширяет список xs, добавляя в конец все элементы списка L
x in xs           # Проверка принадлежности элемента последовательности. 
                  # Можно проверять принадлежность подстроки строке. Возвращает True или False 
x not in xs       # = not x in xs 
xs + xs1          # Конкатенация последовательностей
xs*n или n*xs     # Последовательность из n раз повторенной xs. Если n < 0, возвращается пустая последовательность. 
min(xs)           # Наименьший элемент xs
max(xs)           # Наибольший элемент xs
xs[i:j:d] = t     # Срез от i до j (с шагом d) заменяется на (список) t
del xs[i:j:d]     # Удаление элементов среза из последовательности  

L = [54,67,48,99,27]
for i, v in enumerate(L): print(i, v)

a = [2, 2.25, "Python"]
b = list("help")		# Преобразуем строку в список
c = [x ** 3 for x in range(20) if x%2==1] # кубы нечетных чисел от 0 до 19

nums = list(range(5))     # range is a built-in function that creates a list of integers
print(nums)               # Prints "[0, 1, 2, 3, 4]"
print(nums[2:4])          # Get a slice from index 2 to 4 (exclusive); prints "[2, 3]"
print(nums[2:])           # Get a slice from index 2 to the end; prints "[2, 3, 4]"
print(nums[:2])           # Get a slice from the start to index 2 (exclusive); prints "[0, 1]"
print(nums[:])            # Get a slice of the whole list; prints "[0, 1, 2, 3, 4]"
print(nums[:-1])          # Slice indices can be negative; prints "[0, 1, 2, 3]"
nums[2:4] = [8, 9]        # Assign a new sublist to a slice
print(nums)               # Prints "[0, 1, 8, 9, 4]"

L = sorted(L, key=lambda el: el[3:])

L=list(range(99))         		# 0..98
L2=L[::3]                 		# с шагом 3
L3=[x for x in L2 if x%7==0]    # только делящиеся на 7

Методы списков

Словари

d = {'cat': 'cute', 'dog': 'furry'}  # Create a new dictionary with some data
d['fish'] = 'wet'                    # Set an entry in a dictionary
print(d['monkey'])                   # KeyError: 'monkey' not a key of d
print(d.get('monkey', 'N/A'))        # Get an element with a default; prints "N/A"
del d['fish']                        # Remove an element from a dictionary
for k in dic: print(k)               # цикл по ключам словаря
for k, val in dic.items():           # цикл по парам (ключ, значение)
    print(k)
    print(val)

print({'aa': 77, None: 88})          # {'aa': 77, None: 88}

Методы словарей
dict.clear() - очищает словарь.
dict.copy() - возвращает копию словаря.
classmethod dict.fromkeys(seq[, value]) - создает словарь с ключами из seq и значением value (по умолчанию None).
dict.get(key[, default]) - возвращает значение ключа, но если его нет, не бросает исключение, а возвращает default (по умолчанию None).
dict.items() - возвращает пары (ключ, значение).
dict.keys() - возвращает ключи в словаре.
dict.pop(key[, default]) - удаляет ключ и возвращает значение. Если ключа нет, возвращает default (по умолчанию бросает исключение).
dict.popitem() - удаляет и возвращает пару (ключ, значение). Если словарь пуст, бросает исключение KeyError. Помните, что словари неупорядочены.
dict.setdefault(key[, default]) - возвращает значение ключа, но если его нет, не бросает исключение, а создает ключ с значением default (по умолчанию None).
dict.update([other]) - обновляет словарь, добавляя пары (ключ, значение) из other. Существующие ключи перезаписываются. Возвращает None (не новый словарь!).
dict.values() - возвращает значения в словаре.

itertools

from itertools import *

for i in count(2, 3):
    if i > 20: break
    print(i, end=' ')
# 2 5 8 11 14 17 20 

cnt=1
for i in cycle((5,6,7)):
    print(i, end=' ')
    if cnt > 20: break
    cnt +=1
# 5 6 7 5 6 7 5 6 7 5 6 7 5 6 7 5 6 7 5 6 7 

cnt=1
for i in cycle('абвгд'):
    print(i, end='')
    if cnt > 20: break
    cnt +=1
# абвгдабвгдабвгдабвгда

for i in product((0, 1,2), (3,4,5)):
    print(i, end=' ')
# (0, 3) (0, 4) (0, 5) (1, 3) (1, 4) (1, 5) (2, 3) (2, 4) (2, 5)

for i in chain(range(4), range(10,14)):
    print(i, end=' ')
# 0 1 2 3 10 11 12 13 

L = list(combinations((2,3,4,5), 2))
print(L)       # [(2, 3), (2, 4), (2, 5), (3, 4), (3, 5), (4, 5)]
print(L[1])    # (2, 4)
print(L[1][1]) # 4

L = list(combinations((2,3,4,5), 3))
print(L)       # [(2, 3, 4), (2, 3, 5), (2, 4, 5), (3, 4, 5)]

for i in combinations_with_replacement('абвг', 3):
    print(''.join(i), end=' ')
# ааа ааб аав ааг абб абв абг авв авг агг ббб ббв ббг бвв бвг бгг ввв ввг вгг ггг

for i in permutations('абв'):
    print(''.join(i), end=' ')
# абв авб бав бва ваб вба 

for i in permutations('абвг', 2):
    print(''.join(i), end=' ')
# аб ав аг ба бв бг ва вб вг га гб гв 

Файлы

  open(name[, mode[, buffering]])

Таблица синусов:

import math
f = open("sin.txt", "w")
f.write(" x,     sin(x)\n")
x=-2
while(x<=2):
    f.write("%5.2f, %10.7f\n" % (x, math.sin(x)))
    x += 0.1
f.close()

 x,     sin(x)
-2.00, -0.9092974
-1.90, -0.9463001
 ...
 1.80,  0.9738476
 1.90,  0.9463001

f = open('sin.txt', 'r', encoding="utf-8")
for line in f: print(line, end='')
f.close()

f = open('input.txt')
for line in f:
    words = line.split(',')
    for key in words: print(key.strip())
f.close()

f = open("Python_tasks.7z", "rb")
b = f.read(255)		# получаем массив из 255 целых чисел
f.close()
for i in range(30): print(b[i])

import os
files = os.listdir('\\00\\best')
for fn in files: print(fn)

numpy

import numpy as np

ndarray.ndim - число измерений ("осей") массива.

ndarray.shape - размеры массива, его форма. Кортеж натуральных чисел, показывающий длину массива по каждой оси. Для матрицы из n строк и m столбов, shape будет (n,m). Число элементов кортежа shape равно ndim.

ndarray.size - количество элементов массива. Очевидно, равно произведению всех элементов атрибута shape.

ndarray.dtype - объект, описывающий тип элементов массива. Можно определить dtype, используя стандартные типы данных Python (bool_, character, int8, int16, int32, int64, float8, float16, float32, float64, complex64, object_). Можно определить собственные типы данных, в том числе и составные.

ndarray.itemsize - размер каждого элемента массива в байтах. Информация о типе данных:

print(np.finfo(np.longdouble))
 Ответ:
Machine parameters for float64
---------------------------------------------------------------
precision =  15   resolution = 1.0000000000000001e-15
machep =    -52   eps =        2.2204460492503131e-16
negep =     -53   epsneg =     1.1102230246251565e-16
minexp =  -1022   tiny =       2.2250738585072014e-308
maxexp =   1024   max =        1.7976931348623157e+308
nexp =       11   min =        -max
---------------------------------------------------------------

Разное:
a = np.array([1, 2, 3])                # строка
b = np.array([[1.5, 2, 3], [4, 5, 6]]) # матрица 2*3
ed = np.eye(8)                         # единичная матрица 8*8
Z = np.zeros(10)                       # одномерный массив из нулей
Z = np.ones(10)                        # одномерный массив из единиц
Z = np.full(10, 2.5)                   # вектор длины 10, заполненный числом 2.5
Z = np.arange(10,50)                   # вектор  со значениями от 10 до 49
Z = Z[::-1]                            # Развернуть вектор (первый становится последним)
Z = np.arange(9).reshape(3,3)          # матрица 3x3 со значениями от 0 до 8
Z = np.random.random((3,3,3))          # массив 3x3x3 со случайными значениями [0..1]
Z = np.random.randint(10, 20, size = (3,4))# массив 3*4 с целыми сл. значениями [10..19]
Zmin, Zmax = Z.min(), Z.max()          # минимум и максимум в массиве
m = Z.mean()                           # среднее значение
print(Z.argmax())                      # ЛИНЕЙНЫЙ индекс максимального элемента (одно число)
print(Z.argmax(2))                     # матрица 3*3, число (i,j) показывает индекс наибольшего элемента среди Z[i,j,:]

Z = np.ones((10,10)); Z[1:-1,1:-1] = 0 # матрица с 0 внутри, и 1 на границах

Z = np.zeros((8,8), dtype=int)
Z[1::2,::2] = 1
Z[::2,1::2] = 1                        #  0,1 в шахматном порядке
Z = np.dot(np.ones((5,3)), np.ones((3,2))) # Перемножить матрицы 5x3 и 3x2

Z = np.arange(11)
Z[(3 < Z) & (Z <= 8)] *= -1            #  поменять знак у элементов, значения которых между 3 и 8
Z=np.linspace(0, 2, 9) # 9 чисел от 0 до 2 включительно: [0., .25, .5, .75, 1., 1.25, 1.5, 1.75, 2.] 
Z = np.linspace(0,1,12)[1:-1]          #  вектор размера 10 со значениями от 0 до 1, не включая ни то, ни другое
                                       #  0.09090909 0.18181818 0.27272727 ... 0.81818182 0.90909091]

Z = np.random.random(10)
Z[Z.argmax()] = 0                      # Заменить максимальный элемент на ноль (в одномерном массиве)


Найти индексы ненулевых элементов в [1,2,0,0,4,0]
nz =np.nonzero([1,2,0,0,4,0])
print(nz)                    # (array([0, 1, 4], dtype=int64),)
print(nz[0])                 # [0 1 4]

Количество отрицательных элементов:
a =np.array([1,2,0,-3.0,4,-1])
print( (a<0).sum())          # 2


Умножение матрицы на вектор:
a = np.arange(9).reshape((3,-1))
b = np.array([1,0,0])
print('b.a=', b.dot(a))              # первая строка матрицы: b*A
print('a.b=', a.dot(b))              # первый столбец матрицы: A*(b.T)
print('a.b=', a.dot(b.T))            # тоже самое


Отнять среднее из каждой строки в матрице:
X = np.random.rand(5, 10)
Y = X - X.mean(axis=1, keepdims=True)

Отсортировать матрицу по n-ому столбцу
Z = np.random.randint(0,10,(3,3))
n = 1  # Нумерация с нуля
print(Z)
print(Z[Z[:,n].argsort()])

Бинаризация признака со значениями (0,1,2,3):
a = np.array([[2,3,0,0,3,3]])
aBin = np.eye(4)[a]

Из каждого столбца матрицы X вычесть его среднее значение:
X -= X.mean(axis=0)

Каждый столбец матрицы X поделить на его ср.кв.отклонение:
X /= X.std(axis=0)

В матрицу a высотой my строк вставить в начало столбец из единиц:
a = np.column_stack((np.ones(my).reshape((my,1)),a))

Найти матрицу, составленную из скалярных произведений столбцов матрицы a:
B = np.dot(a.T, a)       # or:
B = a.T.dot(a)           # or:
B = a.transpose().dot(a) # or:

Собственные значения и векторы (в строках v) симметричной матрицы:
w, v = np.linalg.eigh(B)



Найти линейную аппроксимацию 0-го столбца матрицы X через остальные, 

т.е. найти вектор w такой, что для каждой строки v матрицы X:

     v[0] ~= w[0] + w[1]*v[1] + ... + w[mx-1]*v[mx-1]
Y = np.copy(X[:,0])        # выбираем 0-й столбцец
X[:,0]=np.ones(my)         # в матрице X заполняем его единицами
A =  np.dot(X.T, X)        # система уравнений: A*w=b
b =  np.dot(X.T, Y)
w = np.linalg.solve(A,b)   # нашли решение системы
err = X.dot(w)-Y           # найдем отклонения для каждой строки матрицы X
print('sigm=', err.std())  # среднеквадратичное отклонение
print('var =', err.var())  # дисперсия (std**2)

B := матрицу из ненулевых строк матрицы A:
B = A[~np.all(A==0, axis=1)]

В каждой строке матрицы a найти индекс последнего ненулевого элемента:
N = a.shape[0]
for i in range(N):
    print(i, N-(a[i,:]!=0)[::-1].argmax())

Выбрать элементы с данным значением в другом массиве:
a = np.array([1,1,1,2,2,2,2,2])
b = np.array([3,4,5,6,7,8,9,0])
print(b[a==2])  # [6 7 8 9 0]

Удаление:
LZero = np.all(Aeq == 0, axis=1)  # список нулевых строк матрицы
Aer = Aeq[~LZero]                 # удалить нулевые строки матрицы
ber = beq[~LZero]                 # удалить из вектора элементы с теми же номерами
a = a[~np.isnan(a)]               # скопировать только not np.nan()

Разное:

b = a[ np.argsort(a[:,2]) ]       # Сортировка матрицы a по 3-у столбцу:
q, r    = np.linalg.qr(A)         # найти QR-разложение матрицы
L, S, R = np.linalg.svd(A)        # найти SVD-разложение матрицы
A1      = np.linalg.pinv(A)       # псевдообратная матрица





cosine Fourier
Дискретное двумерное косинус-преобразовании Фурье
from scipy.fftpack import dctn
g = dctn(a, type=2, norm='ortho')

Подробнее см. 35.py




numpy файлы

Пусть в файле 01.txt лежит:
 4 3 matrix
1.0  3.88 6.77 1.098
9.8  5.88 1.37 1.198
2.3  3.58 6.72 2.098

Для чтения файла напишем:
Z = np.loadtxt('01.txt', skiprows=1) 
print(Z)


Записать np-массив в текстовый файл:
b = np.array([[1.5, 235, 3], [4.1245, 5, 6]])
np.savetxt("b.txt", b, fmt="%3.0f", delimiter=" ",\
	header=" 2 3 a, b, c", comments=" ")

Если не указать поле comments, в начале заголовка будет добавлен символ #

Запись в файл:
my_file = open("some.txt", "w")
print("Имя файла: ", my_file.name)
print("Файл закрыт: ", my_file.closed)
print("В каком режиме файл открыт: ", my_file.mode)
print("Пробелы: ", my_file.softspace)
my_file.write("Hello")
my_file.close()


Запись нескольких массивов в сжатый файл. Внешние имена могут отличаться от внутренних:
aT = np.ones((10,10)); bT = np.zeros((3,7)); cT = np.ones((9,1)); 
np.savez_compressed("abc", a=aT, b=bT, c=cT)
aT = np.ones(1); bT=np.ones(1); cT=np.ones(1);
print("Clear:", aT, bT, cT);
abc = np.load("abc.npz")
print(abc.files) # ['a', 'b', 'c']
aT = abc["a"]
bT = abc["b"]
cT = abc["c"]
print("Readed:aT=", aT, "\nbT=", bT, "\ncT=", cT)


Чтение сжатого файла:
mnist = np.load("mnist.npz")
for name, matrix in mnist.items():
    print(name, "\t", matrix.shape)
x_test = mnist['x_test']
y_test = mnist['y_test']
x_train = mnist['x_train']
y_train = mnist['y_train']



Чтение csv-файла (должны быть только числа):
m  = np.loadtxt(inName, skiprows=1, delimiter= ",")




Классы

Поле из 8 элементов:

class gf8:
  exptable = ( 1,2,4,3,6,7,5)
  #              1 2 3 4 5 6 7 
  logtable = (-1,0,1,3,2,6,4,5) 
  def __init__(self, x): self.x=x
  def __str__(self):     return "%s" % (self.x)
  def __add__(self, b):  return gf8(self.x ^ b.x)
  __radd__ = __add__
  def __neg__(self):     return self
  def __mul__(self, b):  
      if self.x == 0 or b.x == 0:
      return GR8(0)
    x = gf8.logtable[self.x]
    y = gf8.logtable[b.x]
    z = (x + y) % 7
    return gf8(gf8.exptable[z])
  def __pow__(self, power):
    print('xx=', self.x)
    x = gf8.logtable[self.x]
    z = (x * power) % 7
    return gf8(gf8.exptable[z])
#----------------------
a = gf8(3); b = gf8(5)
print(a, b, a+b, -b, a*b)
c = gf8(2)**5; print('c=', c); print('c**3:', c**3)






tkinter

Вывод картинки на экран:
import tkinter  as tk
mx = 256
cGray = 1+256+256*256

root = tk.Tk()
c = tk.Canvas(root, width=mx, height=mx, bg='white')
c.create_oval(50, 10, 150, 110, width=2)
for y in range(90,99):
    for x in range(mx):
        c.create_line(x,y, x+1, y, fill="#"+"{:06x}".format((x)*cGray))
c.pack()

Получаем: