Программирование на языке Python

Надо:

выделять память
записывать данные в нужную ячейку
читать данные из ячейки

[1, 3, 4, 23, 5]

A = [0]*10

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

A = list ( range(10) )

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

A =[ i*i  for i in range(10) ]

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

for i in range(10)

i*i

from random import randint
A = [ randint(20,100)
for x in range(10)]

randint(20,100)

A = [ i for i in range(100)  
if isPrime(i)  ]

if isPrime(i)

случайные числа

условие отбора

append

Метод – операция, которую можно применить к списку.

A = [1, 2, 3]
A.insert ( 1, 35 )

# [1, 35, 2, 3]

insert

A.insert ( 0, 90 )

A = [90] + A

в конец списка

удалить A[1]

A = [1, 2, 3]
x = A.pop () # x = 3, A = [1, 2]

удалить последний

A = [11, 29, 37, 45]
A.remove( 37 ) # A = [11, 29, 45]

A[0] =
A[1] =
A[2] =
A[3] =
A[4] =

5
12
34
56
13

sep = ""

end = ""

не разделять элементы

не переходить на новую строку

data = input() # "1 2 3 4 5"
s = data.split() # ["1","2","3","4","5"]
A = [ int(x) for x in s ]
# [1,2,3,4,5]

int(input())

int(x)

или так:

s = input().split() # ["1","2","3","4","5"]
A = list( map(int, s) ) # [1,2,3,4,5]

применить int ко всем элементам s

построить список

N=int(input('Введите количество чисел ='))
A=[]
for i in range (1,N+1):
A.append(int(input('Введите число =')))

A=[]
N=int(input())
A = [int(input("Номер %d = " % i))
for i in range(N)]

n=int(input())
A=map(int,input().split(maxsplit = n))
print(n)
for y in A:
print(y, end = ' ' )

В строчку через пробел:

for i in range(N):
print ( A[i], end = " " )

1 2 3 4 5

или так:

for x in A:
print ( x, end = " " )

1 2 3 4 5

или так:

print ( *A )

print (1, 2, 3, 4, 5)

i += 1

Обработка в цикле:

i = 0
while i < N:
# обработать A[i]
i += 1

Цикл с переменной:

for i in range(N):
# обработать A[i]

randint(20,100)

случайные числа
[20,100]

from random import randint
N = 10
A = [0]*N
for i in range(N):
A[i] = randint(20,100)

или так:

Если не нужно изменять A[i]:

for x in A:
... # сделать что-то с x

for i in range(N):
A[i] += 1

x = A[0], A[1], ..., A[N-1]

for x in A:
print ( x )

Вывод созданного массива
(1 способ вывода)

Вывод обработанного массива
( 2 способ вывода)

Заполнение массива

Обработка массива

from random import random
N = 10
a = []
b = []
c = []
for i in range(N):
n = int(random() * 100)
a.append(n)
print("Введите числа")
for i in range(N):
n = int(input())
b.append(n)
for i in range(N):
n = a[i] + b[i]
c.append(n)
print(a)
print(b)
print(c)

Ввод чисел от A до B
в обратном порядке

print(*[i for i in range(int(input()))][::-1])

print(*[i for i in range
(int(input("Введи кол-во чисел")))]
[::-1])

Вывод случайных чисел
[20,100] в обратном порядке

Вывод случайных чисел
[20,100]

[::-1]

count = 0
for x in A:
if 180 < x and x < 190:
count += 1

Python:
180 < x < 190

print ( sum(A) )

или так:

среднее арифметическое

или так:

B = [ x for x in A ]
if 180 < x < 190]
print ( sum(B)/len(B) )

отбираем нужные

def print_rev(arr,k):
if k<0:
return
else:
print(arr[k],end=' ')
print_rev(arr,k-1)
a=list(map(int,input().split(' ')))
print_rev(a,len(a)-1)

i = 0
while i < N and A[i] != X:
i += 1
if i < N:
print ( "A[", i, "]=", X, sep = "" )
else:
print ( "Не нашли!" )

i < N

Вариант с досрочным выходом:

break

досрочный выход из цикла

номер найденного элемента

Поиск в массиве

Варианты в стиле Python:

if X in A:
nX = A.index(X)
print ( "A[", nX, "]=", X, sep = "" )
else:
print ( "Не нашли!" )

M = A[0]
for x in A:
if x > M:
M = x

Варианты в стиле Python:

M = max ( A )

Вариант в стиле Python:

N//2

остановиться на середине!

Варианты в стиле Python:

for i in range(N//2):
A[i], A[N-i-1]= A[N-i-1], A[i]

A.reverse()

A[:3]

[7, 12, 5]

A[0:3]

с начала

A[3:N-2]

[8,…,18,34]

A[3:]

[8,…,18,34,40,23]

A[3:N]

до конца

A[:]

[7,12,5,8,…,18,34,40,23]

копия массива

[18, 34]

A[N-4:N-2]

A[::3]

[7, 8, 34]

A[8:2:-2]

[23, 34, 76]

A[::-1]

[23,40,34,18,76,8,5,12,7]

реверс!

A.reverse()

шаг

B = []
сделать для i от 0 до N-1
если условие выполняется для A[i] то
добавить A[i] к массиву B

B = []
for x in A:
if x % 2 == 0:
B.append(x)

добавить x в конец массива B

B = [ x for x in A ] 
if x % 2 == 0  ]

если x – чётное число

перебрать все элементы A

A

B

A[0] = 0

A = [1, 2, 3]
B = A[:]

копия массива A

[1, 2, 3]

A

[1, 2, 3]

B

A[0] = 0

0

«Глубокое» копирование:

D = copy.deepcopy(C)

Алгоритмы:
простые и понятные, но неэффективные для больших массивов
метод пузырька
метод выбора
сложные, но эффективные
«быстрая сортировка» (QuickSort)
сортировка «кучей» (HeapSort)
сортировка слиянием (MergeSort)
пирамидальная сортировка

сравниваем два соседних элемента; если они стоят «неправильно», меняем их местами
за 1 проход по массиву один элемент (самый маленький) становится на свое место

1-й проход:

2-й проход:

сделать для j от N-2 до 1 шаг -1
если A[j+1]< A[j] то
# поменять местами A[j] и A[j+1]

1

единственное отличие!

2-й проход:

for j in range(N-2,  0 ,-1):
if A[j+1]< A[j]:
# поменять местами A[j] и A[j+1]

0

единственное отличие!

от N-2 до 0 шаг -1

i-1

for i in range(N-1):
найти номер nMin минимального элемента из A[i]..A[N]
if i != nMin:
поменять местами A[i] и A[nMin]

nMin = i
for j in range(i+1,N):
if A[j] < A[nMin]:
nMin = j

пока оба массива непустые

добавить остаток

слияние

выход из рекурсии

копируем результат в массив A

Процедура слияния:

«Разделяй и властвуй» (divide and conquer):

работает быстро

нужен дополнительный массив

Asort = qSort( A )

расход памяти!

Шаг 1: выбрать некоторый элемент массива X

Шаг 3: так же отсортировать две получившиеся области

Разделяй и властвуй (англ. divide and conquer)

L

R

L

R

78

44

44

78

Основная программа:

массив

начало

конец

qSort ( A, nStart, R )
qSort ( A, L, nEnd )

рекурсивные вызовы

while A[L] < X: L += 1
while A[R] > X: R -= 1

разделение на 2 части

массив

начало

конец

меняем местами

X = A[randint(L,R)]

или так:

from random import choice
def qSort ( A, nStart, nEnd ):
...
X = choice ( A[L:R+1] )
...

X = choice ( A[L:R+1] )

По убыванию:

reverse = True

По последней цифре:

def lastDigit ( n ):
return n % 10
B = sorted( A, key = lastDigit )

key = lastDigit

или так:

B = sorted( A, key = lambda x: x % 10  )

lambda x: x % 10

«лямбда»-функция
(функция без имени)

По убыванию:

reverse = True

По последней цифре:

def lastDigit ( n ):
return n % 10
A.sort ( key = lastDigit )

key = lastDigit

или так:

A.sort( key = lambda x: x % 10  )

lambda x: x % 10