Найбільший спільний дільник і найменше спільне кратне

Приклади знаходження найбільшого спільного дільника і найменшого спільного кратного на Python.

Найбі́льший спі́льний дільни́к (НСД) — найбільше натуральне число, на яке ці числа діляться без залишку.

Найменше спільне кратне (НСК) для (a, b) — найменше натуральне число яке ділиться без залишку на обидва числа a, b.

Варіант перший:

a = int(input('a = '))
b = int(input('b = '))

def evklid(a, b): # Функція знаходження найбільшого спільного дільника
    if a % b == 0:
        return b
    else:
        return evklid(b, a%b)

print (evklid(a, b))

nsk = a * b // evklid(a, b) # Знаходимо найменше спільне кратне
print (nsk)

Варіант другий:

a = int(input('a = '))
b = int(input('b = '))

def nsd(a, b): # Функція знаходження найбільшого спільного дільника
    while a*b != 0:
        if a >= b:
            a = a % b
        else:
            b = b % a
    return a + b            

print (nsd(a, b))

nsk = a * b // nsd(a, b) # Знаходимо найменше спільне кратне
print (nsk)

ЗАДАЧА №9

Розв’язання завдання №9 на Python.

infile = open("INPUT.TXT")
outfile = open("OUTPUT.TXT", "w")

infile.readline()

line = [int(x) for x in infile.readline().split()]

summ = 0
for x in line:
    if x > 0:
        summ += x
        
mul = 1
nmin = line.index(min(line))
nmax = line.index(max(line))

if nmin > nmax:
    for x in line[nmax+1:nmin]:
        mul *= x
else:
    for x in line[nmin+1:nmax]:
        mul *= x

outfile.write(str(summ) + ' ' + str(mul))        
      
infile.close()
outfile.close()

via

ЗАДАЧА №8

Розв’язання завдання №8 на Python.

infile = open("INPUT.TXT")
outfile = open("OUTPUT.TXT", "w")

lst = [int(x) for x in infile.readline().split()]

if lst[2] == lst[0] * lst[1]:
    outfile.write('YES')
else:
    outfile.write('NO')        
      
infile.close()
outfile.close()

via

ЗАДАЧА №7

Розв’язання завдання №7 на Python.

infile = open("INPUT.TXT")
outfile = open("OUTPUT.TXT", "w")

line = [int(x) for x in infile.readline().split()]

outfile.write(str(max(line)))        
        
infile.close()
outfile.close()     

via

ЗАДАЧА №6

Розв’язання завдання №6 на Python.

infile = open("INPUT.TXT")
outfile = open("OUTPUT.TXT", "w")

line = infile.readline()

try:
    if (64 < ord(line[0]) and ord(line[3]) < 73) and (0 < int(line[1]) and int(line[4]) < 9):
        if abs(ord(line[0]) - ord(line[3])) == 2 and abs(int(line[1]) - int(line[4])) == 1:
            outfile.write('YES')
        elif abs(ord(line[0]) - ord(line[3])) == 1 and abs(int(line[1]) - int(line[4])) == 2:
            outfile.write('YES')
        else:
            outfile.write('NO')
except:
    outfile.write('ERROR')        
        
infile.close()
outfile.close()       

via

ЗАДАЧА №5

Розв’язання завдання №5 на Python.

infile = open('INPUT.TXT')
outfile = open('OUTPUT.TXT', 'w')

lines = infile.readlines()
lines[1] = [int(x) for x in lines[1].split()]

odd = []
even = []

for e in lines[1]:
    if e % 2:
        odd.append(e)
    else:
        even.append(e)
        
for e in odd:
    outfile.write(str(e) + ' ')
outfile.write('\n')            

for e in even:
    outfile.write(str(e) + ' ')
outfile.write('\n')            

if len(odd) < len(even):
    outfile.write('YES')
else:
    outfile.write('NO')        

via

ЗАДАЧА №4

Розв’язання завдання №4 на Python.

n = input('Введіть число: ')
print(n + '9' + str(9 - int(n)))

via

ЗАДАЧА №3

Розв’язання завдання №3 на Python.

def pw(n):
    if len(n) == 1:
        return int(n) ** 2
    else:
        return str(int(n[:-1]) * (int(n[:-1]) + 1)) + '25'

n = input('Введіть число: ')
print(pw(n))

via

ЗАДАЧА №2

Розв’язання завдання №2 на Python. Потрібно порахувати суму цілих чисел від 1 до N.

Варіант перший:

infile = open('input.txt')
outfile = open('output.txt', 'w')
 
N = int(infile.readline())
 
s = 0
for x in range(0, N+1):
    s += x

outfile.write(str(s))
 
infile.close()
outfile.close()

Варіант другий:

infile = open('input.txt')
outfile = open('output.txt', 'w')
 
N = int(infile.readline())
 
s = 0
while N > 0:
    s += N
    N -= 1

outfile.write(str(s))
 
infile.close()
outfile.close()          

via

Бульбашкове сортування

Бульбашкове сортування — у поданому наборі даних (списку чи масиві) порівнюються два сусідні елементи, якщо один з елементів не відповідає критерію сортування (є більшим, або ж, навпаки, меншим за свого сусіда), то ці два елементи міняються місцями. Прохід по списку продовжується до тих пір, доки дані не будуть відсортованими.

Перший варіант:

a = [1, 8, 3, 5, 7, 4]

print(a)

j = 1
while j < len(a):
    k = 0
    while k < (len(a) - 1):
        if a[k] > a[k+1]:
            a[k], a[k+1] = a[k+1], a[k]
        k += 1
    j += 1
     
print(a)            

Другий варіант:

a = [1, 8, 3, 5, 7, 4]

print(a)

for i in range(len(a), 0, -1):
    for j in range(0, len(a) - 1):
        if a[j] > a[j+1]:
            a[j], a[j+1] = a[j+1], a[j]
            
print(a)    

via

ЗАДАЧА №1 (A+B)

Розв’язання завдання №1 на Python

infile = open('input.txt')
outfile = open('output.txt', 'w')

line = infile.readline().split()

outfile.write(str(int(line[0]) + int(line[1])))

infile.close()
outfile.close()

via

Послідовність Фібоначчі

Послідовність Фібоначчі — послідовність в якій кожне наступне число дорівнює сумі двох попередніх чисел.

a, b = 0, 1
while b < 10000:
    print(b)
    a, b = b, a+b

Виведення числа у вигляді «великих цифр»

space = ['        ',
         '        ',
         '        ',
         '        ',
         '        ',
         '        ',
         '        ']

zero = ['   ***  ',
        '  *   * ',
        ' *     *',
        ' *     *',
        ' *     *',
        '  *   * ',
        '   ***  ']

one = ['   **   ',
       '  * *   ',
       ' *  *   ',
       '    *   ',
       '    *   ',
       '    *   ',
       ' * * * *']

two = [' * * * *',
       '       *',
       '       *',
       ' * * * *',
       ' *      ',
       ' *      ',
       ' * * * *']
       
three = [' * * * *',
         '       *',
         '       *',
         '   * * *',
         '       *',
         '       *',
         ' * * * *']

four = [' *     *',
        ' *     *',
        ' *     *',
        ' * * * *',
        '       *',
        '       *',
        '       *']
             
five = [' * * * *',
        ' *      ',
        ' *      ',
        ' * * * *',
        '       *',
        '       *',
        ' * * * *']

six = [' * * * *',
       ' *      ',
       ' *      ',
       ' * * * *',
       ' *     *',
       ' *     *',
       ' * * * *']
       
seven = [' * * * *',
         '      * ',
         '     *  ',
         '    *   ',
         '    *   ',
         '    *   ',
         '    *   ']       

eight = [' * * * *',
         ' *     *',
         ' *     *',
         ' * * * *',
         ' *     *',
         ' *     *',
         ' * * * *']           

nine = [' * * * *',
        ' *     *',
        ' *     *',
        ' * * * *',
        '       *',
        '       *',
        ' * * * *']
         
numbers = {'0': zero, '1': one, '2': two, '3': three,
           '4': four, '5': five, '6': six, '7': seven,
           '8': eight, '9': nine, ' ': space}

number = input('Веедіть число: ')

digits = []
for char in number:
    digits.append(char)
    
row = 0

while row < 7:
    for column in digits:
        print(numbers[column][row], end=' ')
    print()
    row += 1

via

Алгоритм Евкліда. Рекурсія.

Алгоритм Евкліда — ефективний метод обчислення найбільшого спільного дільника.

import sys

def evklid(m, n):
    if m%n == 0:
        return n
    else:
        return evklid(n, m%n)
        
def main():
    print('Файл називається', sys.argv[0])
    if len(sys.argv) == 3:
        m, n = (int(sys.argv[1]), int(sys.argv[2]))
    else:
        m = int(input('Введіть значення m: '))
        n = int(input('Введіть значення n: '))
        
    print(evklid(m, n))
    
if __name__ == '__main__':
    main()

via

ЗАДАЧА №10

Розв’язання завдання №10 на Python

infile = open('INPUT.TXT')
outfile = open('OUTPUT.TXT', 'w')

line = [int(x) for x in infile.readline().split()]

a, b, c, d = line

for x in range(-100, 101):
    if a*x**3 + b*x*x + c*x + d == 0:
        outfile.write(str(x) + ' ')
        print x
    
infile.close()
outfile.close()

via

Приклади з лекції «Transforming code into Beautiful, Idiomatic Python by Raymond Hettinger»

Цикли в діапазоні чисел

for i in [0,1,2,3,4,5]:
    print i**2
    
for i in range(6):
    print i**2
    
for i in xrange(6):
    print i**2

Цикл по колекції

colors = ['red','green','blue','yellow']

for i in range(len(colors)):
    print colors[i]

for color in colors:
    print color 

Зворотній цикл

colors=['red','green','blue','yellow']

for i in range(len(colors)-1,-1,-1):
    print colors[i]

for color in reversed(colors):
    print color

Цикл за індексами

colors=['red','green','blue','yellow']

for i in range(len(colors)):
    print i, '-->', colors[i]
    
for i, color in enumerate(colors):
    print i, '-->', colors[i]

Цикл двох колекцій

names=['raymond','rachel','matthew']
colors=['red','green','blue','yellow']

n = min(len(names), len(colors))

for i in range(n):
    print names[i], '-->', colors[i]

for name, color in zip(names, colors):
    print name, '-->', color

for name, color in izip(names, colors):
    print name, '-->', color

Цикл в певному порядку

colors=['red','green','blue','yellow']

for color in sorted(colors):
    print color

for color in sorted(colors, reverse=True):
    print color

Користувальницький порядок сортування

colors=['red','green','blue','yellow']

def compare_length(c1, c2):
    if len(c1) < len(c2):
        return -1
    if len(c1) > len(c2):
        return 1
    return 0

print sorted(colors,cmp=compare_length)
print sorted(colors, key=len)

Цикл за ключем словника

d = {'matthew':'blue','rachel':'green','raymond':'red'}

for k in d:
    print k

for k in d.keys():
    if k.startswith('r'):
        del d[k]

d = {k : d[k] for k in d if not k.startswith('r')}

Цикл за ключем і значенням словника

d = {'matthew':'blue','rachel':'green','raymond':'red'}

for k in d:
    print k, '-->', d[k]

for k, v in d.items():
    print k, '-->', v

for k, v in d.iteritems():
    print k, '-->', v

Побудова словника з одного або двох списків

names=['raymond','rachel','matthew']
colors=['red','green','blue']

d = dict(izip(names, colors))
{'matthew':'blue','rachel':'green','raymond':'red'}

d = dict(enumerate(names))
{0:'raymond', 1:'rachel', 2:'matthew'}

Підрахунок в словнику

colors=['red','green','red','blue','green','red']

d = {}
for color in colors:
    if color not in d:
        d[color] = 0
    d[color] += 1

{'blue': 1,'green': 2,'red': 3}

d = {}
for color in colors:
    d[color] = d.get(color, 0) + 1

d = defaultdict(int)
for color in colors:
    d[color] += 1

Групування словників - І

names=['raymond','rachel','matthew','roger',
       'betty','melissa','judith','charlie']
d = {}
for name in names:
    key = len(name)
    if key not in d:
        d[key] = []
    d[key].append(name)
    
{5: ['roger','betty'], 6: ['rachel','judith'],
 7: ['raymond','matthew','melissa','charlie']} 

Групування словників - ІІ

names=['raymond','rachel','matthew','roger',
       'betty','melissa','judith','charlie']

d = {}
for name in names:
    key = len (name)
    d.setdefault(key, []).append(name)

d = defaultdict(list)
for name in names:
    key = len(name)
    d[key].append(name)

Is a dictionary popitem() atomic?

d = {'matthew':'blue','rachel':'green','raymond':'red'}

while d:
    key, value = d.popitem()
    print key, '-->', value

Розпакування послідовності

p = 'Raymond','Hettinger', 0x30,'python@example.com'

fname = p[0]
lname = p[1]
age = p[2]
email = p[3]

fname, lname, age, email = p

Оновлення декількох змінних

def fibonacci(n):
    x = 0
    y = 1
    for i in range(n):
        print x
        t = y
        y = x+y
        x = t

def fibonacci(n):
    x, y = 0, 1
    for i in range(n):
        print x
        x, y = y, x+y

Зчеплення(конкатенація) рядків

names = ['raymond','rachel','matthew','roger',
         'betty','melissa','judith','charlie']

s = names[0]
for name in names[1:]:
    s += ', ' + name
print s

print ', ' .join(names)

Як відкривати і закривати файли

f = open('data.txt')
try:
    data = f.read()
finally:
    f.close()

with open('data.txt') as f:
    data = f.read()

Списки і генератор виразу

result = []
for i in range(10):
    s = i**2
    result.append(s)
print sum(result)

print sum([i**2 for i in xrange(10)])

print sum(i**2 for i in xrange(10))

via via

Вибірка з книги «A Byte of Python» (продовження)

Модулі

Модуль можна «імпортувати» до іншої програми, щоб використовувати функції з нього. Точно так само ми використовуємо стандартну бібліотеку Python. Спершу подивимося, як використовувати модулі стандартної бібліотеки.

(Якщо ви хочете імпортувати змінну argv прямо у вашу програму (щоб не писати щоразу sys. при зверненні до неї), ви можете скористатися оператором from sys import argv. Якщо ви хочете імпортувати всі імена, що використовуються в модулі sys, ви можете виконати команду from sys import *. Це працює для будь-яких модулів.

У загальному випадку вам «слід уникати» використання цього оператора, і використовувати замість цього оператор import, оскільки це не допустить конфліктів імен, і програму буде легше читати).

#!/usr/bin/python
# Filename: using_sys.py
import sys
print('The command line arguments are:')
for i in sys.argv:
print(i)
print('\n\nThe PYTHONPATH is', sys.path, '\n')

$ python using_sys.py we are arguments
The command line arguments are:
using_sys.py
we
are
arguments
The PYTHONPATH is ['', 'C:\\Windows\\system32\\python30.zip',
'C:\\Python30\\DLLs', 'C:\\Python30\\lib',
'C:\\Python30\\lib\\plat-win', 'C:\\Python30',
'C:\\Python30\\lib\\site-packages']

Ім'я модуля — __name__

У кожного модуля є ім'я, і команди в модулі можуть дізнатися ім'я їх модуля. Це корисно, коли потрібно знати, чи запущений модуль сам по собі або імпортований. Як уже згадувалося вище, коли модуль імпортується вперше, код, який в ньому міститься, виконується. Ми можемо скористатися цим для того, щоб змусити модуль вести себе по-різному в залежності від того, чи використовується він сам по собі або імпортується в інший модуль. Цього можна досягти із застосуванням атрибуту модуля під назвою __name__.

#!/usr/bin/python
# Filename: using_name.py
if __name__ == '__main__':
print('This program is being run by itself')
else:
print('I am being imported from another module')

$ python using_name.py
This program is being run by itself
$ python
>>> import using_name
I am being imported from another module
>>>

Функція dir

Ви можете використовувати вбудовану функцію dir, щоб отримати список ідентифікаторів, які об'єкт визначає. Наприклад, до ідентифікатора модуля входять функції, класи і змінні, визначені в цьому модулі.

Коли ви передаєте функції dir() ім'я модуля, вона повертає список імен, визначених в цьому модулі. Якщо ніякого аргументу не передавати, вона поверне список імен, визначених в поточному модулі.

$ python
>>> import sys # отримаємо список атрибутів модуля «sys»
>>> dir(sys)
['__displayhook__', '__doc__', '__excepthook__', '__name__',
'__package__', '__s
tderr__', '__stdin__', '__stdout__', '_clear_type_cache',
'_compact_freelists',
'_current_frames', '_getframe', 'api_version', 'argv',
'builtin_module_names', '
byteorder', 'call_tracing', 'callstats', 'copyright', 'displayhook',
'dllhandle'
, 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix',
'executable',
'exit', 'flags', 'float_info', 'getcheckinterval',
'getdefaultencoding', 'getfil
esystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount',
'getsizeof',
'gettrace', 'getwindowsversion', 'hexversion', 'intern', 'maxsize',
'maxunicode
', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache',
'platfor
m', 'prefix', 'ps1', 'ps2', 'setcheckinterval', 'setprofile',
'setrecursionlimit
', 'settrace', 'stderr', 'stdin', 'stdout', 'subversion', 'version',
'version_in
fo', 'warnoptions', 'winver']

>>> dir() # отримаємо список атрибутів поточного модуля
['__builtins__', '__doc__', '__name__', '__package__', 'sys']

>>> a = 5 # створимо нову змінну «a»

>>> dir()
['__builtins__', '__doc__', '__name__', '__package__', 'a', 'sys']

>>> del a # видалимо ім'я «a»

>>> dir()
['__builtins__', '__doc__', '__name__', '__package__', 'sys']
>>>

Пакунки

Пакунки — це каталоги з модулями і спеціальним файлом __init__.py, який показує Python, що цей каталог особливий, бо містить модулі Python.

Уявімо, що ви хочете створити пакет під назвою «world» з субпакетами «asia», «africa» і т.д, а субпакети ці повинні містити модулі «india», «madagascar» і т.д.

Для цього вам слід було б створити таку структуру каталогів:

| - <деякий каталог із sys.path>/
| |---- world/
|      |---- __init__.py
|      |---- asia/
|      |    |---- __init__.py
|      |    |---- india/
|      |         |---- __init__.py
|      |         |---- foo.py
|      |---- africa/
|           |---- __init__.py
|           |---- madagascar/
|                |---- __init__.py
|                |---- bar.py

Структури даних — Список

Список — це структура даних, яка містить упорядкований набір елементів, тобто ви можете зберігати в списку послідовність елементів.

Список елементів повинен бути укладений у квадратні дужки, щоб Python зрозумів, що ви вказуєте список. Як тільки ви створили список, ви можете додавати, видаляти або шукати елементи в цьому списку. Оскільки ми можемо додавати і видаляти елементи, ми говоримо, що список — це змінюваний тип даних, тобто його можна змінювати.

(Зверніть увагу на використання ключового аргументу end в функції print, який показує, що ми хочемо закінчити виведення пробілом замість звичайного переведення рядка).

#!/usr/bin/python
# Filename: using_list.py

# This is my shopping list
shoplist = ['apple', 'mango', 'carrot', 'banana']

print('I have', len(shoplist), 'items to purchase.')

print('These items are:', end=' ')
for item in shoplist:
    print(item, end=' ')

print('\nI also have to buy rice.')
shoplist.append('rice')
print('My shopping list is now', shoplist)

print('I will sort my list now')
shoplist.sort()
print('Sorted shopping list is', shoplist)

print('The first item I will buy is', shoplist[0])
olditem = shoplist[0]
del shoplist[0]
print('I bought the', olditem)
print('My shopping list is now', shoplist)

$ python using_list.py
I have 4 items to purchase.
These items are: apple mango carrot banana
I also have to buy rice.
My shopping list is now ['apple', 'mango', 'carrot', 'banana',
'rice']
I will sort my list now
Sorted shopping list is ['apple', 'banana', 'carrot', 'mango',
'rice']
The first item I will buy is apple
I bought the apple
My shopping list is now ['banana', 'carrot', 'mango', 'rice']

Структури даних — Кортеж

Кортежі служать для зберігання кількох об'єктів разом. Одна з найважливіших особливостей кортежів, це те, що вони незмінні, так само, як і рядки.

Кортежі зазвичай використовуються в тих випадках, коли оператор або функція повинні напевно знати, що набір значень, тобто кортеж значень, не зміниться.

#!/usr/bin/python
# Filename: using_tuple.py

zoo = ('python', 'elephant', 'penguin') # remember the parentheses are
optional
print('Number of animals in the zoo is', len(zoo))

new_zoo = ('monkey', 'camel', zoo)
print('Number of cages in the new zoo is', len(new_zoo))
print('All animals in new zoo are', new_zoo)
print('Animals brought from old zoo are', new_zoo[2])
print('Last animal brought from old zoo is', new_zoo[2][2])
print('Number of animals in the new zoo is',
len(new_zoo)-1+len(new_zoo[2]))

$ python using_tuple.py
Number of animals in the zoo is 3
Number of cages in the new zoo is 3
All animals in new zoo are ('monkey', 'camel', ('python',
'elephant', 'penguin'))
Animals brought from old zoo are ('python', 'elephant', 'penguin')
Last animal brought from old zoo is penguin
Number of animals in the new zoo is 5

Структури даних — Словник

Словник — аналог адресної книги, де ви можете знайти адресу або контактну інформацію про людину, знаючи лише її ім'я, тобто ми пов'язуємо деякі ключі (імена) зі значеннями (інформацією). Зауважте, що ключ повинен бути унікальним.

В якості ключів ви можете використовувати тільки незмінні об'єкти, а в якості значень можна використовувати як незмінні, так і змінні об'єкти. Це, по суті, означає, що ви повинні використовувати тільки прості об'єкти в якості ключів.

Пари ключ-значення вказуються в словнику таким чином: d = {key1: value1, key2: value2}. Зверніть увагу, як ключ і значення розділяються двокрапкою, а пари один від одного відокремлюються комами, а потім все це укладається у фігурні дужки.

Пам'ятайте, що пари ключ-значення жодним чином не впорядковані в словнику. Якщо вам необхідний деякий порядок, вам доведеться окремо відсортувати словник перед зверненням до нього.

#!/usr/bin/python
# Filename: using_dict.py

# 'ab' - скорочення від 'a'ddress'b'ook

ab = {  'Swaroop'   : 'swaroop@swaroopch.com',
        'Larry'     : 'larry@wall.org',
        'Matsumoto' : 'matz@ruby-lang.org',
        'Spammer'   : 'spammer@hotmail.com'
     }

print("Адреса Swaroop'а:", ab['Swaroop'])

# Видалення пари ключ-значення
del ab['Spammer']

print('\nВ адресній книзі {0} контактів\n'.format(len(ab)))

for name, address in ab.items():
    print('Контакт {0} з адресою {1}'.format(name, address))

# Додавання пари ключ-значення
ab['Guido'] = 'guido@python.org'

if 'Guido' in ab:
    print("\nАдреса Guido:", ab['Guido'])

$ python using_dict.py
Адреса Swaroop’а: swaroop@swaroopch.com

В адресній книзі 3 контактів

Контакт Swaroop з адресою swaroop@swaroopch.com
Контакт Matsumoto з адресою matz@ruby-lang.org
Контакт Larry з адресою larry@wall.org

Адреса Guido: guido@python.org

Структури даних — Множина

Множини — це невпорядковані набори простих об'єктів. Це необхідно тоді, коли присутність об'єкта в наборі важливіше порядку або того, скільки разів даний об'єкт там зустрічається.

Використовуючи множини, ви можете здійснювати перевірку належності, чи є дана множина підмножиною іншої множини, знаходити перетин множин і так далі.

>>> bri = set(['brazil', 'russia', 'india'])
>>> 'india' in bri
True
>>> 'usa' in bri
False
>>> bric = bri.copy()
>>> bric.add('china')
>>> bric.issuperset(bri)
True
>>> bri.remove('russia')
>>> bri & bric # OR bri.intersection(bric)
{'brazil', 'india'}

Структури даних — Рядки

Всі рядки, що використовуються вами в програмах, є об'єктами класу str. Деякі корисні методи цього класу продемонстровані на прикладі нижче. Щоб подивитися весь список методів, виконайте help (str).

#!/usr/bin/python
# Filename: str_methods.py

name = 'Swaroop' # This is a string object

if name.startswith('Swa'):
    print('Yes, the string starts with "Swa"')

if 'a' in name:
    print('Yes, it contains the string "a"')

if name.find('war') != -1:
    print('Yes, it contains the string "war"')

delimiter = '_*_'
mylist = ['Brazil', 'Russia', 'India', 'China']
print(delimiter.join(mylist))

$ python str_methods.py
Yes, the string starts with "Swa"
Yes, it contains the string "a"
Yes, it contains the string "war"
Brazil_*_Russia_*_India_*_China

via via

Приклад використання календарного модуля

import calendar
time_cal=calendar.TextCalendar(calendar.FRIDAY)
print time_cal.formatmonth(2009,02)

 February 2009
Fr Sa Su Mo Tu We Th
     1  2  3  4  5
6  7  8  9 10 11 12
13 14 15 16 17 18 19
20 21 22 23 24 25 26
27 28

via

Простий спосіб обернути рядок

>>> text='0123456789'
>>> reverse_text=text[::-1]
>>> print reverse_text
9876543210

via

Вибірка з книги «A Byte of Python»

Метод Format

#!/usr/bin/python
# Filename: str_format.py

age = 26
name = 'Swaroop'

print('{0} is {1} years old'.format(name, age))
print('Why is {0} playing with that python?'.format(name))

$ python str_format.py
Swaroop is 25 years old
Why is Swaroop playing with that python?

Використання змінних і констант

# Filename : var.py

i = 5
print(i)
i = i + 1
print(i)

s = '''This is a multi-line string.
This is the second line.'''
print(s)

$ python var.py
5
6
This is a multi-line string.
This is the second line.

Вирази

#!/usr/bin/python
# Filename: expression.py

length = 5
breadth = 2

area = length * breadth
print('Area is', area)
print('Perimeter is', 2 * (length + breadth))

$ python expression.py
Area is 10
Perimeter is 14

Оператор if

Оператор if використовується для перевірки умов: «якщо» умова вірна, виконується блок виразів «if-блок», «інакше» виконується інший блок виразів «else-блок». Блок «else» не є обов'язковим.

#!/usr/bin/python
# Filename: if.py

number = 23
guess = int(input('Enter an integer : '))

if guess == number:
    print('Congratulations, you guessed it.') # New block starts here
    print('(but you do not win any prizes!)') # New block ends here
elif guess < number:
    print('No, it is a little higher than that') # Another block
    # You can do whatever you want in a block ...
else:
    print('No, it is a little lower than that')
    # you must have guess > number to reach here

print('Done')
# This last statement is always executed, after the if statement is
executed

$ python if.py
Enter an integer : 50
No, it is a little lower than that
Done
$ python if.py
Enter an integer : 22

Оператор while

Оператор while дозволяє вам багаторазово виконувати блок команд до тих пір, поки виконується умова. Оператор while — приклад того, що називають оператором циклу. Оператор while може мати необов'язковий пункт else.

#!/usr/bin/python
# Filename: while.py

number = 23
running = True

while running:
    guess = int(input('Enter an integer : '))

    if guess == number:
        print('Congratulations, you guessed it.')
        running = False # this causes the while loop to stop
    elif guess < number:
        print('No, it is a little higher than that.')
    else:
        print('No, it is a little lower than that.')
else:
    print('The while loop is over.')
    # Do anything else you want to do here

print('Done')

$ python while.py
Enter an integer : 50
No, it is a little lower than that.
Enter an integer : 22
No, it is a little higher than that.
Enter an integer : 23
Congratulations, you guessed it.
The while loop is over.
Done

Цикл for

#!/usr/bin/python
# Filename: for.py

for i in range(1, 5):
    print(i)
else:
    print('The for loop is over')

$ python for.py
1
2
3
4
The for loop is over

Оператор break

Оператор break слугує для «переривання» циклу, тобто зупинення виконання команд навіть якщо умова виконання циклу ще не прийняла значення False або послідовність елементів не закінчилася. Важливо відзначити, що якщо ви перериваєте цикл for чи while оператором break, відповідні їм блоки else виконуватиметься не будуть.

#!/usr/bin/python
# Filename: break.py

while True:
    s = (input('Enter something : '))
    if s == 'quit':
        break
    print('Length of the string is', len(s))
print('Done')

$ python break.py
Enter something : Programming is fun
Length of the string is 18
Enter something : When the work is done
Length of the string is 21
Enter something : if you wanna make your work also fun:
Length of the string is 37
Enter something :       use Python!
Length of the string is 12
Enter something : quit
Done

Оператор continue

Оператор continue використовується для вказівки, що необхідно пропустити всі команди, які залишилися в поточному блоці циклу і «продовжити» з наступної ітерації циклу.

#!/usr/bin/python
# Filename: continue.py

while True:
    s = input('Enter something : ')
    if s == 'quit':
        break
    if len(s) < 3:
        print('Too small')
        continue
    print('Input is of sufficient length')
    # Do other kinds of processing here...

$ python test.py
Enter something : a
Too small
Enter something : 12
Too small
Enter something : abc
Input is of sufficient length
Enter something : quit

Функції

Функції — це фрагменти програми, які багаторазово використовуються. Вони дозволяють вам дати ім'я певному блоку команд з тим, щоби згодом запускати цей блок, використовуючи вказане ім'я. Функції визначаються за допомогою зарезервованого слова «def». Після цього слова вказується «ім'я» функції, за яким слідує пара дужок, в яких можна вказати імена деяких змінних, і заключна двокрапка в кінці рядка.

#!/usr/bin/python
# Filename: function1.py

def sayHello():
    print('Hello World!') # block belonging to the function
# End of function

sayHello() # call the function
sayHello() # call the function again

$ python function1.py
Hello World!
Hello World!

Параметри функцій

Параметри вказуються в дужках при оголошенні функції та розділяються комами. Аналогічно ми передаємо значення, коли викликаємо функцію. Зверніть увагу на термінологію: імена, зазначені в оголошенні функції, називаються «параметрами», тоді як значення, які ви передаєте до функції при її виклику, «аргументами».

#!/usr/bin/python
# Filename: func_param.py

def printMax(a, b):
    if a > b:
        print(a, 'is maximum')
    elif a == b:
        print(a, 'is equal to', b)
    else:
        print(b, 'is maximum')

printMax(3, 4) # directly give literal values

x = 5
y = 7

printMax(x, y) # give variables as arguments

$ python func_param.py
4 is maximum
7 is maximum

Локальні змінні

Коли ви оголошуєте змінні всередині визначення функції, вони жодним чином не пов'язані з іншими змінними з таким же ім'ям поза функцією — тобто імена змінних є «локальними» в функції. Це називається «областю видимості» змінної. Область видимості всіх змінних обмежена блоком, в якому вони оголошені.

#!/usr/bin/python
# Filename: func_local.py

x = 50

def func(x):
    print('x is', x)
    x = 2
    print('Changed local x to', x)

func(x)
print('x is still', x)

$ python func_local.py
x is 50
Changed local x to 2
x is still 50

Зарезервоване слово global

Якщо ви хочете присвоїти деяке значення змінній, що визначена на вищому рівні програми, ви повинні вказати, що її ім'я не локальне, а глобальне (global).

#!/usr/bin/python
# Filename: func_global.py

x = 50

def func():
    global x
    
    print('x is', x)
    x = 2
    print('Changed global x to', x)

func()
print('Value of x is', x)

$ python func_global.py
x is 50
Changed global x to 2
Value of x is 2

Зарезервоване слово nonlocal

Ще один тип області видимості, так звана «нелокальна» (nonlocal), яка являє собою щось середнє між «глобальною» і «локальною». Нелокальні області видимості зустрічаються, коли ви визначаєте функції всередині функцій.

#!/usr/bin/python
# Filename: func_nonlocal.py

def func_outer():
    x = 2
    print('x is', x)
    
    def func_inner():
        nonlocal x
        x = 5

    func_inner()
    print('Changed local x to', x)

func_outer()

$ python func_nonlocal.py
x is 2
Changed local x to 5

Значення аргументів за замовчуванням

Для деяких функцій ви можете зробити частину параметрів «необов'язковими» і використовувати деякі задані значення за замовчуванням, якщо користувач не бажає вказувати власні значення для них. Ви можете вказати значення аргументів за замовчуванням, додавши до імені параметра у визначенні функції оператор присвоювання «=» з наступним значенням.

#!/usr/bin/python
# Filename: func_default.py

def say(message, times = 1):
    print(message * times)

say('Hello')
say('World', 5)

$ python func_default.py
Hello
WorldWorldWorldWorldWorld

Ключові аргументи

Якщо у вас є деяка функція з великим числом параметрів, і ви хочете вказувати тільки деякі з них при виклику, ви можете задавати значення цих параметрах за їхнім ім’ям — це називається «ключові параметри». У цьому випадку ми використовуємо ім'я (ключ) замість позиції (як було досі), щоб передати аргументи функції.

Є дві «переваги» такого підходу: по-перше, використання функції стає простіше, оскільки немає необхідності відстежувати порядок аргументів; по-друге, ми можемо задавати значення тільки деяким обраним аргументам, за умови, що інші параметри мають значення аргументу за замовчуванням.

#!/usr/bin/python
# Filename: func_key.py

def func(a, b=5, c=10):
    print('a is', a, 'and b is', b, 'and c is', c)

func(3, 7)
func(25, c=24)
func(c=50, a=100)

$ python func_key.py
a is 3 and b is 7 and c is 10
a is 25 and b is 5 and c is 24
a is 100 and b is 5 and c is 50

Змінне число параметрів

Вам може іноді знадобитися визначити функцію, здатну приймати будь яке число параметрів. Цього можна досягти із застосуванням зірочок.

Коли ми оголошуємо параметр із зірочкою, як наприклад, «*numbers», всі позиційні аргументи починаючи з цієї позиції і до кінця будуть зібрані в кортеж під ім'ям «numbers».

Аналогічно, коли ми оголошуємо параметри з двома зірочками, як наприклад «**keywords», всі ключові аргументи починаючи з цієї позиції і до кінця будуть зібрані в словник під ім'ям «keywords».

#!/usr/bin/python
# Filename: total.py

def total(initial=5, *numbers, **keywords):
    count = initial
    for number in numbers:
        count += number
    for key in keywords:
        count += keywords[key]
    return count

print(total(10, 1, 2, 3, vegetables=50, fruits=100))

$ python total.py
166

Тільки ключові параметри

Якщо ми хочемо зазначити, що деякі ключові параметри повинні бути доступні тільки по ключу, а не як позиційні аргументи, їх можна оголосити після параметра із зірочкою. Оголошення параметрів після параметра із зірочкою дає тільки ключові аргументи. Якщо для таких аргументів не вказано значення за замовчуванням, звернення до функції викличе помилку.

#!/usr/bin/python
# Filename: keyword_only.py

def total(initial=5, *numbers, vegetables):
    count = initial
    for number in numbers:
        count += number
    count += vegetables
    return count

print(total(10, 1, 2, 3, vegetables=50))
print(total(10, 1, 2, 3))
# Raises error because we have not supplied a default argument value
for 'vegetables'

$ python keyword_only.py
66
Traceback (most recent call last):
File "test.py", line 12, in 
print(total(10, 1, 2, 3))
TypeError: total() needs keyword-only argument vegetables

Оператор return

Оператор return використовується для повернення з функції, тобто для припинення її роботи і виходу з неї. При цьому можна також «повернути деяке значення» з функції.

#!/usr/bin/python
# Filename: func_return.py

def maximum(x, y):
    if x > y:
        return x
    else:
        return y

print(maximum(2, 3))

$ python func_return.py
3

Рядки документації

Python має особливість, так звані «рядки документації», які зазвичай позначаються скорочено «docstrings». Це дуже важливий інструмент, яким ви повинні користуватись, оскільки він допомагає краще документувати програму і полегшує її розуміння. Вражаюче, але ми можемо отримати рядок документації, наприклад, з функції, навіть під час виконання програми!

#!/usr/bin/python
# Filename: func_doc.py

def printMax(x, y):
    '''Prints the maximum of two numbers.

    The two values must be integers.'''
    x = int(x) # convert to integers, if possible
    y = int(y)

    if x > y:
        print(x, 'is maximum')
    else:
        print(y, 'is maximum')

printMax(3, 5)
print(printMax.__doc__)

$ python func_doc.py
5 is maximum
Prints the maximum of two numbers.
The two values must be integers.

via via

Основи мови програмування Python за 10 хвилин

Python не вимагає явного оголошення змінних, є регістро-залежною (змінна var не еквівалентна змінній Var або VAR — це три різні змінні) об'єктно-орієнтованою мовою.

Синтаксис

По перше варто відзначити цікаву особливість Python. Він не містить операторних дужок (begin.. End в pascal або {..} в Сі), замість цього блоки виділяються відступами: пробілами або табуляцією, а вхід в блок з операторів здійснюється двокрапкою. Однорядкові коментарі починаються зі знака фунта «#», багаторядкові — починаються і закінчуються трьома подвійними лапками «"""». Щоб привласнити значення змінній використовується знак «=», а для порівняння — «==». Для збільшення значення змінної, або додавання до рядка використовується оператор «+=», а для зменшення — «-=». ​​Всі ці операції можуть взаємодіяти з більшістю типів, у тому числі з рядками. Наприклад:

>>> myvar = 3 
>>> myvar += 2 
>>> myvar -= 1 

"""Це багаторядковий коментар
Рядки між трьома подвійними лапками ігноруються"""

>>> mystring = "Hello" 
>>> mystring += " world." 
>>> print mystring
Hello world.

# Наступний рядок міняє значення змінних місцями. (Всього один рядок!)
>>> myvar, mystring = mystring, myvar

Структури даних

Python містить такі структури даних як списки (lists), кортежі (tuples) і словники (dictionaries). Списки — схожі на одновимірні масиви (але ви можете використовувати список який включає списки — багатовимірний масив), кортежі — незмінні списки, словники — теж списки, але індекси можуть бути будь-якого типу, а не тільки числовими.

«Масиви» в Python можуть містити дані будь-якого типу, тобто в одному масиві можуть знаходитися числові, рядкові й інші типи даних. Масиви починаються з індексу 0, а останній елемент можна отримати за індексом -1, ви можете привласнювати змінним функції і використовувати їх відповідно.

# Список складається з цілого числа, іншого списку і кортежу
>>> sample = [1, ["another", "list"], ("a", "tuple")]

# Цей список містить рядок, ціле і дробове число 
>>> mylist = ["List item 1", 2, 3.14]
# Змінюємо перший (нульовий) елемент списку mylist
>>> mylist[0] = "List item 1 again"
# Змінюємо останній елемент списку
>>> mylist[-1] = 3.14

# Створюємо словник, з числовими і цілочисловим індексами
>>> mydict = {"Key 1": "Value 1", 2: 3, "pi": 3.14}
# Змінюємо елемент словника під індексом "pi"
>>> mydict["pi"] = 3.15

# Задаємо кортеж
>>> mytuple = (1, 2, 3)

# Python дозволяє таким чином оголошувати синоніми функцій
>>> myfunction = len
>>> print myfunction(list) 
3

Ви можете використовувати частину масиву, задаючи перший і останній індекс через двокрапку «:». У такому випадку ви отримаєте частину масиву, від першого індексу до другого не включно. Якщо не зазначений перший елемент, то відлік починається з початку масиву, а якщо не вказано останній — то масив зчитується до останнього елемента. Негативні значення визначають положення елемента з кінця. Наприклад:

>>> Mylist = ["List item 1", 2, 3.14]

# Зчитуються всі елементи масиву
>>> Print mylist [:]
['List item 1', 2, 3.1400000000000001]

# Зчитуються нульовий і перший елемент масиву
>>> Print mylist [0:2]
['List item 1', 2]

# Зчитуються елементи від нульового (-3) до другого (-1) (не включно)
>>> Print mylist [-3: -1]
['List item 1', 2]

# Зчитуються елементи від першого, до останнього
>>> Print mylist [1:]
[2, 3.14]

Рядки

Рядки в Python відокремлюються лапками подвійними «"» або одинарними «'». Всередині подвійних лапок можуть бути присутніми одинарні або навпаки. До прикладу рядок "Він сказав 'привіт'!", буде виведена на екран як «Він сказав 'привіт'!». Якщо потрібно вивести текст використовувати декілька рядків, то ці рядки потрібно починати і закінчувати трьома подвійними лапками «"""». Ви можете підставити в шаблон рядка елементи з кортежу або словника. Знак відсотка «%» між рядком і кортежем, замінює в рядку символи «%s» на елемент кортежу. Словники дозволяють вставляти в рядок елемент під заданим індексом. Для цього треба використовувати в рядку конструкцію «%(індекс)s». У цьому випадку замість «%(індекс)s» буде підставлено значення словника під заданим індексом.

>>> print "Name: %s\
Number: %s\
String: %s" % (myclass.name, 3, 3 * "-")
Name: Poromenos
Number: 3
String: ---

strString = """Цей текст розташований
на декількох рядках"""

>>> print "This %(verb)s a %(noun)s." % {"noun": "test", "verb": "is"}
This is a test.

Оператори

Оператори while, if, for — оператори переміщення. Тут немає аналога оператора select, так що доведеться обходитися if. В операторі for відбувається порівняння змінної і списку. Щоб отримати список цифр до числа — використовуйте функцію range (). Ось приклад використання операторів:

# Отримуємо список з десяти цифр (від 0 до 9)
rangelist = range(10)
>>> print rangelist
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# Цикл виконується поки змінна number (яка щоразу збільшується на одиницю)
# входить до списку...
for number in rangelist:
    # Перевіряємо чи входить змінна number
    # в кортеж чисел (3, 4, 7, 9)
    if number in (3, 4, 7, 9):
        # Якщо змінна number входить в кортеж (3, 4, 7, 9)
        # Операція «break» забезпечує вихід з циклу в будь-який момент
        break
    else:
        # «continue» здійснює «прокручування» циклу.
        # Тут це не потрібно, так як після цієї операції
        # в будь-якому випадку програма переходить знову до обробки циклу
        continue
else:
    # «else» вказувати необов'язково, умова виконується
    # якщо цикл не був перерваний за допомогою «break».
    pass # Нічого не робити

if rangelist[1] == 2:
    print "The second item (lists are 0-based) is 2"
elif rangelist[1] == 3:
    print "The second item (lists are 0-based) is 3"
else:
    print "Dunno"

while rangelist[1] == 1:
    pass

Функції

Для оголошення функції використовується ключове слово «def». Аргументи функції задаються в дужках після назви функції. Можна задавати необов'язкові аргументи, привласнюючи їм значення за замовчуванням. Функції можуть повертати кортежі, в такому випадку треба писати значення, що повертаються, через кому. Ключове слово «lambda» служить для оголошення елементарних функцій.

# Same as def funcvar(x): return x + 1
funcvar = lambda x: x + 1
>>> print funcvar(1)
2

# an_int і a_string необов'язкові аргументи, які приймають значення
# оголошені за замовчуванням
# if one is not passed (2 and "A default string", respectively).
def passing_example(a_list, an_int=2, a_string="A default string"):
    a_list.append("A new item")
    an_int = 4
    return a_list, an_int, a_string

>>> my_list = [1, 2, 3]
>>> my_int = 10
>>> print passing_example(my_list, my_int)
([1, 2, 3, 'A new item'], 4, "A default string")
>>> my_list
[1, 2, 3, 'A new item']
>>> my_int
10

Класи

Мова Python обмежена у множинному спадкуванні в класах. Внутрішні змінні та внутрішні методи класів починаються з двох знаків нижнього підкреслення «__» (наприклад «__myprivatevar»). Ми можемо також присвоювати значення змінної класу ззовні. Приклад:

class MyClass(object):
    common = 10
    def __init__(self):
        self.myvariable = 3
    def myfunction(self, arg1, arg2):
        return self.myvariable
    # Тут ми оголосили клас Myclass.
    # Функція __ init__ викликається автоматично
    # при ініціалізації класів.

# Ініціалізуємо клас, змінна myvariable набуває значення 3
# як заявлено в методі ініціалізації
>>> classinstance = MyClass()
# Метод myfunction класу Myclass повертає значення змінної myvariable 3
>>> classinstance.myfunction(1, 2)
3

# Змінна common оголошена в усіх класах
>>> classinstance2 = MyClass()
>>> classinstance.common
10
>>> classinstance2.common
10

# Тому, якщо ми змінимо її значення в класі Myclass зміняться 
# її значення в усіх об'єктах, ініціалізованих класом Myclass
>>> MyClass.common = 30
>>> classinstance.common
30
>>> classinstance2.common
30

# А тут ми не змінюємо змінну класу. Замість цього
# ми оголошуємо її в об'єкті і присвоюємо їй нове значення
>>> classinstance.common = 10
>>> classinstance.common
10
>>> classinstance2.common
30
>>> MyClass.common = 50
# Тепер зміна змінної класу не торкнеться 
# змінних об'єктів цього класу
10
>>> classinstance2.common
50

# Наступний клас є спадкоємцем класу Myclass
# наслідуючи його властивості та методи, до того ж клас може
# успадковуватися з декількох класів, в цьому випадку запис
# такий: class Otherclass(Myclass1, Myclass2, MyclassN)
class OtherClass(MyClass):
    def __init__(self, arg1):
        self.myvariable = 3
        print arg1

>>> classinstance = OtherClass("hello")
hello
>>> classinstance.myfunction(1, 2)
3

# Цей клас не має властивість test, але ми можемо
# оголосити таку змінну для об'єкта. Причому
# змінна tеsт буде членом тільки classinstance.
>>> classinstance.test = 10
>>> classinstance.test
10

Винятки

Винятки в Python мають структуру try-except [exceptionname]:

def some_function():
    try:
        # Ділення на нуль викликає помилку
        10 / 0
    except ZeroDivisionError:
        # Але програма не виконує неприпустиму операцію
        # а обробляє блок виключення відповідний
        # помилці «ZeroDivisionError»
        print "Oops, invalid."
    else:
        # Exception didn't occur, we're good.
        pass
    finally:
        # This is executed after the code block is run
        # and all exceptions have been handled, even
        # if a new exception is raised while handling.
        print "We're done with that."

>>> some_function()
Oops, invalid.
We're done with that.

Імпорт

Зовнішні бібліотеки можна підключити процедурою «import [libname]», де [libname] — назва бібліотеки, що підключається. Ви так само можете використовувати команду «from [libname] import [funcname]», щоб ви могли використовувати функцію [funcname] з бібліотеки [libname]:

import random # Імпортуємо бібліотеку «random»
from time import clock # Імпортуємо функцію «clock» з бібліотеки «time»

randomint = random.randint(1, 100)
>>> print randomint
64

Робота з файловою системою

Python має багато вбудованих бібліотек. У цьому прикладі ми спробуємо зберегти в бінарному файлі структуру списку, прочитати її і збережемо рядок в текстовому файлі. Для перетворення структури даних ми будемо використовувати стандартну бібліотеку «pickle»:

import pickle
mylist = ["This", "is", 4, 13327]

# Відкриємо бінарний файл C:\\binary.dat для запису. Символ «r»
# запобігає заміні спеціальних сиволів (таких як n, t, b та ін.)
myfile = open(r"C:\\binary.dat", "w")
pickle.dump(mylist, myfile)
myfile.close()

# Відкриємо текстовий файл text.txt для запису
myfile = open(r"C:\\text.txt", "w")
myfile.write("This is a sample string")
myfile.close()

# Відкриємо текстовий файл text.txt для читання
myfile = open(r"C:\\text.txt")
>>> print myfile.read()
'This is a sample string'
myfile.close()

# Відкриємо бінарний файл C:\\binary.dat для читання
myfile = open(r"C:\\binary.dat")
loadedlist = pickle.load(myfile)
myfile.close()
>>> print loadedlist
['This', 'is', 4, 13327]

Особливості

>>> lst1 = [1, 2, 3]
>>> lst2 = [3, 4, 5]
>>> print [x * y for x in lst1 for y in lst2]
[3, 4, 5, 6, 8, 10, 9, 12, 15]
>>> print [x for x in lst1 if 4 > x > 1]
[2, 3]

# Оператор «any» повертає true, якщо хоча б одна з умов, виконується.
>>> any([i % 3 for i in [3, 3, 4, 4, 3]])
True
# This is because 4 % 3 = 1, and 1 is true, so any()
# returns True.

# Наступна процедура підраховує кількість
# підходящих елементів у списку
>>> sum(1 for i in [3, 3, 4, 4, 3] if i == 4)
2
>>> del lst1[0]
>>> print lst1
[2, 3]
>>> del lst1

Глобальні змінні оголошуються поза функціями і можуть бути прочитані без оголошень. Але якщо вам необхідно змінити значення глобальної змінної з функції, то вам необхідно оголосити її на початку функції ключовим словом «global», якщо ви цього не зробите, то Python оголосить змінну, доступну тільки для цієї функції.

number = 5

def myfunc():
    # Виводить 5
    print number

def anotherfunc():
    # Це викликає виключення, оскільки глобальна змінна
    # не була викликана з функції. Python в цьому випадку створює
    # однойменну змінну всередині цієї функції, доступну
    # тільки для операторів цієї функції.
    print number
    number = 3

def yetanotherfunc():
    global number
    # І тільки з цієї функції значення змінної змінюється
    number = 3

Переваги Python

• Швидкість виконання програм написаних на Python дуже висока. Це пов'язано з тим, що основні бібліотеки Python написані на C++ і виконання завдань займає менше часу, ніж на інших мовах високого рівня.
• У зв'язку з цим ви можете писати свої власні модулі для Python на C або C++.
• У стандартних бібліотеках Python ви можете знайти засоби для роботи з електронною поштою, протоколами Інтернету, FTP, HTTP, базами даних та багато іншого.
• Скрипти, написані за допомогою Python виконуються на більшості сучасних операційних систем.
• Python підходить для будь-яких рішень в області програмування, будь то офісні програми, веб-додатки, GUI-додатки і т.д.
• Над розробкою Python трудилися тисячі ентузіастів зі всього світу. Підтримкою сучасних технологій в стандартних бібліотеках ми можемо бути зобов'язані саме тому, що Python був відкритий для всіх, хто забажає.

via via

Відправлення листа на електронну адресу — Python

У Python є спеціальна бібліотека smtplib, яку ми і будемо використовувати. У даному прикладі для надсилання електронного листа використовується сервер Gmail.

#!/usr/bin/env python  
# -*- coding: utf-8 -*-
# python '2.6.5'  
      
import smtplib  
import email.utils  
from email.mime.text import MIMEText  
      
from_addr = 'sender@gmail.com'  
to_addrs  = 'recipient@gmail.com'  
      
text = 'Текст листа'  
      
# Зазначаємо кодировку листа  
msg = MIMEText(text, "", "utf-8")  
      
# Створюємо заголовок листа
msg['To'] = email.utils.formataddr(('Ім'я одержувача', to_addrs))  
msg['From'] = email.utils.formataddr(('Ім'я відправника', from_addr))  
msg['Subject'] = 'Тестовий лист'  
      
     
# Параметри авторизації  
username = 'username'  
pwd = 'password'  
      
# Відправка листа
server = smtplib.SMTP('smtp.gmail.com:587')  
server.starttls()  
server.login(username,pwd)  
server.sendmail(from_addr, to_addrs, msg.as_string())  
server.quit()  

via

Програма сортування чисел по порядку

# -*- coding: utf-8 -*-

first = int(raw_input('Введіть перше число: '))
last = int(raw_input('Введіть останнє число: '))

print range(first, last)

via

Знаходження максимального числа серед парних чисел в списку, який складається з випадкових позитивних чисел

# -*- coding: utf-8 -*-
import random

# Порожній список, до якого ми будемо заносити парні числа
list2 = []

print "Скільки чисел будемо генерувати?"
n = int(raw_input("n= "))
print "Ви ввели n =", n
print "Яким максимальним буде випадкове число?"
m = int(raw_input("m= "))
print "Вы ввели m=", m

list = [random.randint(1,m+1) for i in range(n)]

for i in list:
    if i % 2 == 0:
        # Число, яке задовольняє умові, додається до списку list2
        list2.append(i)

print "Отриманий список", list2
print "Максимальне число = ", max(list2)

via

Складаємо із двох списків третій, упорядкований за зростанням

# -*- coding: utf-8 -*-
# Складаємо із двох списків третій, упорядкований за зростанням

import random

n = int(raw_input("N for list1="))
list1 = [random.randint(1,100) for i in range(n)]
m = int(raw_input("N for list2="))
list2 = [random.randint(1,100) for i in range(m)]

print "Перший список: ", list1
print "Другий список: ", list2

list3 = list1+list2
sortlist3 = sorted(list3)
print "Упорядкований список: ", sortlist3

Метод .sort() проводить дії з вихідним списком, переставляючи елементи всередині нього самого, і не повертає відсортовану копію вихідного списку. Для отримання відсортованої копії потрібно використовувати метод .sorted().

via

Обчислюємо середнє арифметичне число на Python

# -*- coding: utf-8 -*-

allsum, n, num = 0,0,0

while True:
    print 'Введіть число'
    num = raw_input()
    if num == "":
        break
    num = int(num)
    allsum += num
    n += 1

print 'Середнє арифметичне число дорівнює ', allsum/n

via