Изучаем Python

Python. Авторизация на сайт Vkontakte.ru или Vk.com без API

pythonblogg@mail.ru (Вячеслав) — Tue, 21 Jun 2011 01:19:00 -0700

Сайт Vkontakte.ru - это одна из самых популярных соц сетей России.
Большая известность, повлекла за собой программистов. Появилось много программ, для этого сайта. Например клиент-серверы.

Специально для этого Администраторы сайта создали API, через который зарегистрированные приложения могут совершать различные действия, такие как отправка сообщения, просмотр списка друзей и т.д

Но для тех кто не хочет регистрировать, вот скрипт для авторизации:

import urllib
import urllib2
import re
import sys
import math
import os
import time

class Vkontakte:
    def __init__(self, email, password):
        self.email = email
        self.password = password
        self.cookie = None

    def get_s_value(self):        
        #Возвращает уникальный идентификатор, который выдается на домене login.vk.com
        host = 'http://login.vk.com/?act=login'
        post = urllib.urlencode({'email' : self.email,
                                 'expire' : '',
                                 'pass' : self.password,
                                 'vk' : ''})

        headers = {'User-Agent' : 'Mozilla/5.0 (Windows; U; Windows NT 5.1; ru; rv:1.9.0.13) Gecko/2009073022 Firefox/3.0.13 (.NET CLR 3.5.30729)',
                   'Host' : 'login.vk.com',
                   'Referer' : 'http://vkontakte.ru/index.php',
                   'Connection' : 'close',
                   'Pragma' : 'no-cache',
                   'Cache-Control' : 'no-cache',
                  }

        conn = urllib2.Request(host, post, headers)
        data = urllib2.urlopen(conn)
        my_crack = str(data.read())[350:410]        
        return my_crack  

    def get_cookie(self):
        #Возвращает remixsid из куки
        if self.cookie: return self.cookie

        host = 'http://vkontakte.ru/login.php?op=slogin'
        post = urllib.urlencode({'s' : self.get_s_value()})
        headers = {'User-Agent' : 'Mozilla/5.0 (Windows; U; Windows NT 5.1; ru; rv:1.9.0.13) Gecko/2009073022 Firefox/3.0.13',
                   'Host' : 'vkontakte.ru',
                   'Referer' : 'http://login.vk.com/?act=login',
                   'Connection' : 'close',
                   'Cookie' : 'remixchk=5; remixsid=nonenone',
                   'Pragma' : 'no-cache',
                   'Cache-Control' : 'no-cache'
                  }
        conn = urllib2.Request(host, post, headers)
        data = urllib2.urlopen(conn)
        cookie_src = data.info().get('Set-Cookie')
        self.cookie = re.sub(r'(expires=.*?;\s|path=\/;\s|domain=\.vkontakte\.ru(?:,\s)?)', '', cookie_src)        
        return self.cookie
        
    def friends(self):    
        cook = self.get_cookie()
        host = 'http://vkontakte.ru/friends_ajax.php'
        post = urllib.urlencode({'s' : self.get_s_value()})
        headers = {'User-Agent' : 'Mozilla/5.0 (Windows; U; Windows NT 5.1; ru; rv:1.9.0.13) Gecko/2009073022 Firefox/3.0.13','Host' : 'vkontakte.ru','Referer' : 'http://login.vk.com/?act=login','Connection' : 'close','Cookie' : 'remixchk=5; '+cook,'Pragma' : 'no-cache','Cache-Control' : 'no-cache'}        
        conn = urllib2.Request(host, post, headers)
        data = urllib2.urlopen(conn)
        my_fr = str(data.read())
        return my_fr

Пример использования:

vk = Vkontakte(ваш email,ваш пароль)
print vk.get_cookie()

Python Создание анимированного графика # 23

pythonblogg@mail.ru (Вячеслав) — Thu, 31 Mar 2011 09:34:00 -0700

Для того, чтобы уметь строить анимированный график, необходимо первоначально просто уметь строить график. Это описано в посте ранее.

Для того, чтобы оживить наш график, используется специальная функция библиотеки MayPlotLib - pylab.ion(). Но это не всё.

Технология такова: Используется цикл. Если вы хотите получить фиксированное количество кадров, то используется for, иначе - While. Перед получением нового кадра, мы стираем старый и добавляем новый.

Вот пример (Будем рисовать синусоиду):

#!/usr/bin/env python
# -*- coding: UTF-8 -*-
import math
import pylab
from matplotlib import mlab

# Интервал изменения переменной по оси X
xmin = 0.0
xmax = 20.0
# Шаг между точками
dx = 0.01

#Создадим список координат по оиси X
#на отрезке [-xmin; xmax], включая концы
xlist = mlab.frange (xmin, xmax, dx)

#Включаем интерактивный режим
pylab.ion()
a = 1
n = 1
while a>0:
 
    #Данные для очередного кадра
    ylist = [math.sin (x + n / 2.0) for x in xlist]

    #Очистим график
    pylab.clf()

    #Выведем новые данные
    pylab.plot (xlist, ylist)

    #Нарисуем их
    pylab.draw()
    
    n = n+1

Python Построение графиков #22

pythonblogg@mail.ru (Вячеслав) — Wed, 30 Mar 2011 03:11:00 -0700

Построение графика на язык Python можно сделать при использовании многих библиотек. Над этим вопросом я много поработал и сделал вывод - лучше всего использовать MatPlotLib.

По мнению многих программистов этот продукт работает быстрее всех. Хоть и молодой, но функций больше, чем в остальных.

На этом сайте (http://sovety.blogspot.com/2007/10/9.html) перечислены все библиотеки по работе с графикой в Python, имеются сравнения.

Вот официальный сайт (http://matplotlib.sourceforge.net/), где имеется полная документация по этой библиотеке с огромным изобилием примеров. Но там всё на английском языке.

Рассмотрим самый простейший пример.

Нарисуем график вида y=f(x) (на данный момент без использования Glade)

Вот исходный код:

#!/usr/bin/env python
# -*- coding: UTF-8 -*-

#Импортируем библиотеку Math
import math
#Импортируем один из пакетов Matplotlib
import pylab
#Импортируем пакет со вспомогательными функциями
from matplotlib import mlab

#Рисуем график функции y = sin(x)
def func (x):
    """
    sin (x)
    """
    return math.sin (x)
    
#Указываем X наименьее и наибольшее
xmin = -10.0
xmax = 10.0

# Шаг между точками
dx = 0.01

#Создадим список координат по оси 
#X на отрезке [-xmin; xmax], включая концы
xlist = mlab.frange (xmin, xmax, dx)

# Вычислим значение функции в заданных точках
ylist = [func (x) for x in xlist]

#Нарисуем одномерный график
pylab.plot (xlist, ylist)

#Покажем окно с нарисованным графиком
pylab.show()

Это самый простейший пример программы по построению графика.

Нижняя панель, которую вы видите, программировалась не нами - это составной элемент, который входит в библиотеку MatPlotLib и появляется автоматически.

Python Glade пример. Калькулятор # 21

pythonblogg@mail.ru (Вячеслав) — Sun, 27 Mar 2011 05:33:00 -0700

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

Для начала создаём проект Glade, заполняем его элементами (кнопки, поля).

Теперь переходим к исходному коду вашего проекта:

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

Не буду перечислять подробно каждое действие, так как всё проекты начинаются одинаково.

Все тонкости уже были описаны в предыдущем посте.

Вот исходный код Python-файла:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
try:  
    import pygtk  
    pygtk.require("2.0")  
except:  
    pass  
try:  
    import gtk  
    import gtk.glade  
except:  
    print("GTK Not Availible")
    sys.exit(1)
#такой импорт делать обязательно
import math       
        
class silver():
    wTree = None
    b = None
    def __init__(self):
        self.wTree = gtk.glade.XML( "m.glade" )
        
        dic = { 
            "exit" : self.quit,
            "add_in_hide(1)" : self.add1,
            "add_in_hide(2)" : self.add2,
            "add_in_hide(3)" : self.add3,
            "add_in_hide(4)" : self.add4,
            "add_in_hide(5)" : self.add5,
            "add_in_hide(6)" : self.add6,
            "add_in_hide(7)" : self.add7,
            "add_in_hide(8)" : self.add8,
            "add_in_hide(9)" : self.add9,
            "add_in_hide(0)" : self.add0,
            "add_in_hide(+)" : self.add_pl,
            "add_in_hide(-)" : self.add_min,
            "add_in_hide(*)" : self.add_um,
            "add_in_hide(/)" : self.add_de,
            "add_in_hide(()" : self.add_s1,
            "add_in_hide())" : self.add_s2,
            "result" : self.result,
            "clear" : self.clear,
            "m_sim" : self.m_sim,
            "sqrt" : self.sqrt,
            "x^y" : self.pow,
            ",":self.z,
            "t":self.t,
            "sin":self.sin,
            "cos":self.cos,
            "pow_v" : self.pow_v,
            "otm_d1" : self.otm_d1,
            "sq" : self.sq,
            "otm_d2" : self.otm_d2,
            "sin_v" : self.sin_v,
            "otm_d3": self.otm_d3,
            "cos_v":self.cos_v,
            "otm_d4":self.otm_d4,
            "root":self.root,
            "root_v":self.root_v,
            "otm_d5":self.otm_d5,            
            #"destroy" : self.quit,
        }
        self.wTree.signal_autoconnect( dic )                
        gtk.main()
        self.all= self.wTree.get_widget("entry3").get_text()
    
    all= '' 
    def root(self,widget):
        #root = a**(1/n)
        self.wTree.get_widget("dialog5").show()        
        
    def root_v(self, widget):
        self.all= self.wTree.get_widget("entry3").get_text()
        p1 = self.wTree.get_widget("entry7").get_text()    
        p2 = self.wTree.get_widget("entry8").get_text()    
        p3 = 1/float(p2)
        self.all = str(self.all) + 'math.pow('+p1+','+str(p3)+')'
        self.wTree.get_widget("entry3").set_text(self.all)
        self.all=b = self.wTree.get_widget("entry3").get_text()    
    
    def sin(self,widget):
        self.wTree.get_widget("dialog3").show()
        
    def sin_v(self, widget):
        self.wTree.get_widget("entry3").set_text(self.all)
        p1 = self.wTree.get_widget("entry5").get_text()        
        p1 = str(p1)
        if p1 == '':
            p1 == '0'
        
        self.all = str(self.all) + 'math.sin('+p1+')'
        self.wTree.get_widget("entry3").set_text(self.all)
        self.wTree.get_widget("entry5").set_text('')
        self.wTree.get_widget("dialog3").hide()    
        
        
    def cos(self,widget):
        self.wTree.get_widget("dialog4").show()
        
        
    def cos_v(self, widget):
        self.wTree.get_widget("entry3").set_text(self.all)
        p1 = self.wTree.get_widget("entry6").get_text()        
        p1 = str(p1)
        if p1 == '':
            p1 == '0'
        
        self.all = str(self.all) + 'math.cos('+p1+')'
        self.wTree.get_widget("entry3").set_text(self.all)
        self.wTree.get_widget("entry6").set_text('')
        self.wTree.get_widget("dialog3").hide()    
    
    def t(self,widget):
        self.all= self.wTree.get_widget("entry3").get_text()
        self.all = str(self.all) + ','
        self.wTree.get_widget("entry3").set_text(self.all)
        self.all=b = self.wTree.get_widget("entry3").get_text()
        
    
    def z(self,widget):
        self.all= self.wTree.get_widget("entry3").get_text()
        self.all = str(self.all) + '.'
        self.wTree.get_widget("entry3").set_text(self.all)
        self.all=b = self.wTree.get_widget("entry3").get_text()
        
    
    def pow(self,widget):
        #$#####
        self.wTree.get_widget("dialog1").show()
        
        #$#####
        
    def pow_v(self, widget):
        self.wTree.get_widget("entry3").set_text(self.all)
        p1 = self.wTree.get_widget("entry1").get_text()        
        p2 = self.wTree.get_widget("entry2").get_text()
        p1 = str(p1)
        if p1 == '':
            p1 == '0'
        if p2 == '':
            p2 =='0'
                
        self.all = str(self.all) + 'math.pow('+p1+','+p2+')'
        self.wTree.get_widget("entry3").set_text(self.all)
        self.wTree.get_widget("entry1").set_text('')
        self.wTree.get_widget("entry2").set_text('')
        self.wTree.get_widget("dialog1").hide()    
        
    
    def otm_d1(self, widget):
        self.wTree.get_widget("dialog1").hide()
        
    def otm_d2(self , widget):
        self.wTree.get_widget("dialog2").hide()
        
    def otm_d3(self , widget):
        self.wTree.get_widget("dialog3").hide()
        
    def otm_d4(self , widget):
        self.wTree.get_widget("dialog4").hide()
        
    def otm_d5(self , widget):
        self.wTree.get_widget("dialog5").hide()
    
    def sqrt(self,widget):
        self.wTree.get_widget("dialog2").show()        
     
    
    def add1(self, widget):
        self.all= self.wTree.get_widget("entry3").get_text()
        self.all= self.wTree.get_widget("entry3").get_text()
        self.all = str(self.all) + '1'
        self.wTree.get_widget("entry3").set_text(self.all)
        
        
    def add2(self, widget):
        self.all= self.wTree.get_widget("entry3").get_text()
        self.all = str(self.all) + '2'
        self.wTree.get_widget("entry3").set_text(self.all)
        self.all=b = self.wTree.get_widget("entry3").get_text()
        
    def sq(self,widget):
            self.wTree.get_widget("entry3").set_text(self.all)
            p3 = self.wTree.get_widget("entry4").get_text()        
            p3 = str(p3)
            if p3 == '':
                p3 == '0'
                            
            self.all = str(self.all) + 'math.sqrt('+p3+')'
            self.wTree.get_widget("entry3").set_text(self.all)
            self.wTree.get_widget("entry4").set_text('')
            self.wTree.get_widget("dialog2").hide()    
    
    def add3(self, widget):
        self.all= self.wTree.get_widget("entry3").get_text()
        self.all = str(self.all) + '3'
        self.wTree.get_widget("entry3").set_text(self.all)
        self.all=b = self.wTree.get_widget("entry3").get_text()
        
        
    def add4(self, widget):
        self.all= self.wTree.get_widget("entry3").get_text()
        self.all = str(self.all) + '4'
        self.wTree.get_widget("entry3").set_text(self.all)
        self.all=b = self.wTree.get_widget("entry3").get_text()
        
        
    def add5(self, widget):
        self.all= self.wTree.get_widget("entry3").get_text()
        self.all = str(self.all) + '5'
        self.wTree.get_widget("entry3").set_text(self.all)
        self.all=b = self.wTree.get_widget("entry3").get_text()
        
        
    def add6(self, widget):
        self.all= self.wTree.get_widget("entry3").get_text()
        self.all = str(self.all) + '6'
        self.wTree.get_widget("entry3").set_text(self.all)
        self.all=b = self.wTree.get_widget("entry3").get_text()
        
        
    def add7(self, widget):
        self.all= self.wTree.get_widget("entry3").get_text()
        self.all = str(self.all) + '7'
        self.wTree.get_widget("entry3").set_text(self.all)
        self.all=b = self.wTree.get_widget("entry3").get_text()
        
        
    def add8(self, widget):
        self.all= self.wTree.get_widget("entry3").get_text()
        self.all = str(self.all) + '8'
        self.wTree.get_widget("entry3").set_text(self.all)
        self.all=b = self.wTree.get_widget("entry3").get_text()
        
        
    def add9(self, widget):
        self.all= self.wTree.get_widget("entry3").get_text()
        self.all = str(self.all) + '9'
        self.wTree.get_widget("entry3").set_text(self.all)
        self.all=b = self.wTree.get_widget("entry3").get_text()
        
        
    def add0(self, widget):
        self.all= self.wTree.get_widget("entry3").get_text()
        self.all = str(self.all) + '0'
        self.wTree.get_widget("entry3").set_text(self.all)
        self.all=b = self.wTree.get_widget("entry3").get_text()
        
        
    def add_pl(self, widget):
        self.all= self.wTree.get_widget("entry3").get_text()
        self.all = str(self.all) + '+'
        self.wTree.get_widget("entry3").set_text(self.all)
        self.all=b = self.wTree.get_widget("entry3").get_text()
        
        
    def add_min(self, widget):
        self.all= self.wTree.get_widget("entry3").get_text()
        self.all = str(self.all) + '-'
        self.wTree.get_widget("entry3").set_text(self.all)
        self.all=b = self.wTree.get_widget("entry3").get_text()
        
        
    def add_um(self, widget):
        self.all = str(self.all) + '*'
        self.wTree.get_widget("entry3").set_text(self.all)
        self.all=b = self.wTree.get_widget("entry3").get_text()
        
        
    def add_de(self, widget):
        self.all= self.wTree.get_widget("entry3").get_text()        
        self.all = str(self.all) + '/'
        self.wTree.get_widget("entry3").set_text(self.all)
        self.all=b = self.wTree.get_widget("entry3").get_text()
        
        
    def m_sim(self, widget):
        self.all= self.wTree.get_widget("entry3").get_text()
        self.all = str(self.all)[:-1]
        self.wTree.get_widget("entry3").set_text(self.all)
        self.all=b = self.wTree.get_widget("entry3").get_text()
        
            
        
    def clear(self, widget):
        self.all = ''
        self.wTree.get_widget("entry3").set_text(self.all)
        self.all=b = self.wTree.get_widget("entry3").get_text()
        
         
    def add_s1(self, widget):
        self.all= self.wTree.get_widget("entry3").get_text()
        self.all = str(self.all) + '('
        self.wTree.get_widget("entry3").set_text(self.all)
        self.all=b = self.wTree.get_widget("entry3").get_text()
        
         
        
    def add_s2(self, widget):
        self.all= self.wTree.get_widget("entry3").get_text()
        self.all = str(self.all) + ')'
        self.wTree.get_widget("entry3").set_text(self.all)
        self.all=b = self.wTree.get_widget("entry3").get_text()
        
         
    def result(self, widget):
        try:
            #self.all=str(self.all)
            self.all=b = self.wTree.get_widget("entry3").get_text()
            
            self.all=eval(self.all)
            self.wTree.get_widget("entry3").set_text(str(self.all))
        except:
            self.wTree.get_widget("hbox1").show()
            self.wTree.get_widget("entry3").set_text("ERROR")
    
    
    def quit(self, widget):
        sys.exit(0)

letsdothis=silver()

Если у вас что то не получилось, то желательно внимательно проверить "орфографию". Нельзя забывать в проекте Glade кнопкам задавать события.

Также вы можете скачать этот проект полностью архивом:

Скачать

Python Glade простейший пример # 20

pythonblogg@mail.ru (Вячеслав) — Tue, 22 Mar 2011 05:24:00 -0700

В данном примере вы увидите простейшую программу, которая сделает сложение числовых данных, которые будут введены в поля при нажатии кнопки.

Рассмотрим пошагово:

Создаём проект так как рассказывалось в предыдущих постах
Создаём окно
Добавляем элементы:
Метки (Label), три поля, две кнопки
Задаём события кнопкам (как это сделать описывалось в предыдущем посте)
Теперь переходим к файлу Python. Создаём его в той же директории, где будет находиться файл проекта Glade.

Программируем его.

* Делаем импорт библиотек

import sys
try:  
    import pygtk  
    pygtk.require("2.0")  
except:  
    pass  
try:  
    import gtk  
    import gtk.glade  
except:  
    print("GTK Not Availible")
    sys.exit(1)

* Создаём главный класс, где будут происходить вычисления

class root():
    result = 0 
    def __init__( self, number1, number2 ):
        self.result = int( number1 ) + int( number2 )
  
    def giveResult( self ):
        return str(self.result)

* Создаём класс управляющий действиями окна GTK

class main():

    wTree = None

    def __init__( self ):
        self.wTree = gtk.glade.XML( "main.glade" )

        dic = { 
            "quit" : self.quit,
            "result" : self.result,

        }

        self.wTree.signal_autoconnect( dic )

        gtk.main()

    def result(self, widget):
        try:
            thistime = root(self.wTree.get_widget("entry1").get_text(), self.wTree.get_widget("entry2").get_text() )
        except ValueError:

            self.wTree.get_widget("entry3").set_text("ERROR")
            return 0

        self.wTree.get_widget("entry3").set_text(thistime.giveResult())

    def quit(self, widget):
        sys.exit(0)

letsdothis = main()

* Проверьте, не забыли ли вы задать события в проекте Glade, сохранить его.

Запускаем.

Если вы всё делали правильно по инструкции, то увидите результат. В случае ошибки желательно внимательно проверить предыдущие действия сделанные вами.

Также вы можете скачать этот проект в архиве:

Скачать

Python Работа с Glade. Азы # 19

pythonblogg@mail.ru (Вячеслав) — Mon, 21 Mar 2011 06:50:00 -0700

Если вы собираетесь работать с Glade в первые, то вам желательно прочитать предыдущий пост.

В этой статье будет рассматриваться, как связать проект Glade с вашей программой Python.

Во первых, желательно, чтобы файл Glade и Python лежали в одной директории (папке)

Во вторых, в самом файле Python необходимо делать такой импорт:

import sys
try:  
    import pygtk  
    pygtk.require("2.0")  
except:  
    pass  
try:  
    import gtk  
    import gtk.glade  
except:  
    print("GTK Not Availible")
    sys.exit(1)

Затем создаём класс, где должна быть обязательно такая функция:

wTree = None

def __init__(self):

    self.wTree = gtk.glade.XML( "ваш файл.glade" )

Теперь вы наверное хотите запрограммировать какой нибудь элемент.

Для задания события, используется следующая технология:

Создаётся словарь, пусть имеет имя dic{}

В него вставляем имена событий в Glade (ключ), потом self.имя переменной без круглых скобок


dic = { 
    "exit" : self.quit,
    "add_in_hide(1)" : self.add1,
    
}

В данном примере "exit" - сигнал в Glade, а self.quit - функция в Python.

Python Начало работы с Glade # 18

pythonblogg@mail.ru (Вячеслав) — Sun, 20 Mar 2011 13:57:00 -0700

Glade - это мощная платформа для создания оконных приложений на Python.

В данном приложении мы создаём окно, все элементы к нему (надписи, кнопки, поля и т.д.), задаём события к элементам (если надо).

Специализируется Glade на создании GTK приложения, то есть для рабочего стола Gnome, но после компиляции будет работать везде.

В интернете можно встретить платформу wxPython. Лично я от неё отказался, она мне показалась неудобной и также я опирался на мнения знающих программистов. Для примера, большинство приложений дистрибутива Ubuntu, Debian были сделаны не без использования Glade (Gimp, GCalk, Synaptic...).

Для начала расскажу о ситуациях, где долго долбался из-за незнания, но всё же методом тыка и копания в интернет добился результата.

Начнём с проекта:

При создании надо указать, что формат проекта Libglade, имена объектов уникальны для каждого окна, версию - самую последнюю. Это обязательно, иначе не будет работать. (см.рис ниже)

Затем создаём окно:

И самое главное: по умолчанию окно невидимое (так задано). Чтобы мы его увидели, на правой боковой панели выделяем объект window1, переходим на вкладку общие, там увидите свойство "Видимый". Установите параметр "Да".

Теперь, чтобы грамотно добавить какой нибудь элемент управления, необходимо в форму поместить контейнер.

Может получиться и так, это уже творчество каждого индивидуально

Чтобы кнопка выполняла функцию, нужно её выделить, на боковой панели перейдите в вкладку сигналы, а там уже будет понятно.

Как программировать оконное приложение, прикреплять проект Glade к исполняемому нами файлу Python - кода, будет рассмотрено в следующем посте.

Python Словари # 17

pythonblogg@mail.ru (Вячеслав) — Sat, 19 Mar 2011 05:08:00 -0700

Словари - один из сложнейших типов данных в языке программирования Python.

Словарь можно охарактеризовать как изменяемый неупорядоченный набор пар

"ключ : значение".

Для того, чтобы лучше понять что это такое, вспомните как устроен англо-русский словарь:

dog - собака, apple - яблоко.

dog - это ключ, а собака - значение.

Синтаксис словаря выглядит следующим образом:

a = {'dog':'собака', ' apple':'яблоко'}

Пример:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

def main():
    a = {'dog':'собака', 'apple':'яблоко'} 
    print a['dog']    

if __name__ == "__main__":
    main()

Словари как и списки можно изменять, добавлять элементы и удалять их.

Удаление элемента словаря осуществляется методом del.

Пример:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

def main():
    a = {'dog':'собака', 'apple':'яблоко'}    
    del a['dog']    
    print a

if __name__ == "__main__":
    main()

Данный тип данных (словари) широко используются в языке программирования Python, но в этом уроке описан минимум. Возможностей намного больше, о них будет сказано в следующих уроках.

Python Списки # 16

pythonblogg@mail.ru (Вячеслав) — Fri, 18 Mar 2011 04:42:00 -0700

В языке программирования Python списки, как и строки, являются упорядоченными последовательностями. Но в отличии от строк, списки состоят не из символов, а из объектов. Список находится между символами [..........]

пр. a = [3, 5, 4, 748, 5466]

Списки могут состоять из различных объектов: из строк, чисел и других списков.

Списки, как и строки тоже можно соединять.

пр. a = [2, 4, 5, 6, 74] + [7878, 0, 968987, 5454654, 6546546]

Также можно из списков извлекать срез.

Припер:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

def main():
    spisok = [2,3,4,5,6]    
    print spisok[1:4]

if __name__ == "__main__":
    main()

Нельзя забывать, что отчёт количества объектов в python начинается от нуля.

В данном примере из списка [2,3,4,5,6] мы извлекаем срез от второго до пятого объекта.

То есть мы увидим на экране при выполнении программы значение [3, 4, 5]

Списки - это изменяемые последовательности, а значит мы можем у любого из объектов изменить значение.

Пример:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

def main():
    spisok = [2,3,4,5,6] 
    print ('До = '+str(spisok[3]))
    spisok[3] = 7
    print ('После = '+str(spisok[3]))

if __name__ == "__main__":
    main()

В данном примере мы изменили четвёртый по счёту элемент (5 на 7).

Python GTK Простейшее оконное приложение # 15

pythonblogg@mail.ru (Вячеслав) — Thu, 17 Mar 2011 12:05:00 -0700

Для работы с оконными приложениями используется библиотека GTK. На ней можно делать любые вещи связанные с окнами.

Естественно, чтобы использовать эту библиотеку, её надо импортировать.

Сейчас будет рассмотрен пример создания простого окна с кнопкой Hello World.

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import pygtk
pygtk.require('2.0')
import gtk

class HelloWorld:

    def hello(self, widget, data=None):
        print "Hello World"

    def delete_event(self, widget, event, data=None):
        print "delete event occurred"        
        return False

    def destroy(self, widget, data=None):
        print "destroy signal occurred"
        gtk.main_quit()

    def __init__(self):
        # Создание нового окна
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)    
        self.window.connect("delete_event", self.delete_event)
        self.window.connect("destroy", self.destroy)
    
        # Граница окна
        self.window.set_border_width(10)
    
        # Задание события кнопки
        self.button = gtk.Button("Hello World")
    
        # Задаётся событие
        self.button.connect("clicked", self.hello, None)
        self.button.connect_object("clicked", gtk.Widget.destroy, self.window)    
        self.window.add(self.button)        
        self.button.show()       
        self.window.show()
    def main(self):
        gtk.main()


if __name__ == "__main__":
    hello = HelloWorld()
    hello.main()

Python Классы # 14

pythonblogg@mail.ru (Вячеслав) — Wed, 16 Mar 2011 06:01:00 -0700

Класс - это пользовательский тип, состоящий из методов и атрибутов.

Инстанс (Вызов) класса создается путем вызова имени класса как функции с параметрами. Объект состоит из атрибутов и методов.

Атрибут - это переменная, метод - это функция. Отличия метода от функции в том, что у него есть первый параметр - self.

Модель класса:

class имя_класса:
    инструкция 1
    ....
    инструкция N

Есть также другой тип объекта - инстанс класса, который генерируется при вызове:

инстанс_класса = имя_класса()

Объект класса и инстанс класса - это два разных объекта. Первый генерируется на этапе объявления класса, второй - при вызове имени класса. Объект класса может быть один, инстансов класса может быть сколько угодно.

Инструкция - это, как правило, определение функции. При определении класса создается новое пространство имен и создается объект-класс, который является оболочкой для всех инструкций.

Пример программы с использованием класса:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import math
class Student():
    def f (self, a, b) :
        self.a1=a
        self.b1=b
        print self.a1, self.b1

s1=Student()
s2=Student()
s1.f (6, 5)
s2.f (7, 6)
def main(): 

    return 0 

if __name__ == '__main__':
    main()

Python Табулирование функций # 13

pythonblogg@mail.ru (Вячеслав) — Tue, 15 Mar 2011 10:18:00 -0700

С помощью оператора цикла while удобно строить таблицы значений различных функций. Т.е. значения будут выстраиваться столбцами. По сути такие таблицы представляют собой список значений функции при различных значениях ее параметра.

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

Пример программы:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import math
def p1(): 
    x = 1.0
    while x < 10.0:
        print x, "\t", math.log(x)
        x += 1.0

def main(): 
    p1() 
    return 0 

if __name__ == '__main__':
    main()

Строка "\t" обозначает знак табуляции. Благодаря нему значения выстраиваются в два столбца.

Разберем, как эта программа работает. Параметр x изменяется от 1.0 с шагом 1.0, пока он меньше 10.0. В теле цикла выводится текущее значение параметра x, затем знак табуляции и результат вычисления функции math.log(x), т.е. натуральный логарифм от x

(log e x=ln  x ).

Результат работы программы будет выглядеть так:

1.0    0.0
2.0    0.69314718056
3.0    1.09861228867
4.0    1.38629436112
5.0    1.60943791243
6.0    1.79175946923
7.0    1.94591014906
8.0    2.07944154168
9.0    2.19722457734

Python Альтернативные ветки программы # 12

pythonblogg@mail.ru (Вячеслав) — Mon, 14 Mar 2011 06:56:00 -0700

Оператор условия if имеет расширенный формат, позволяющий проверять несколько независимых друг от друга условий и выполнять один из блоков, поставленных в соответствие с этими условиями. Синтаксис оператора выглядит так:

if условие_1:
    программа_1
 
elif условие_2:
    программа_2
 
elif условие_3:
    программа_3
...
else:
    программа если условия не удовлетворяются

Работает эта конструкция следующим образом. Сначала проверяется первое условие и, если оно истинно, то выполняется первая последовательность выражения (программа_1). После того поток выполнения переходит строке, которая следует после условного оператора . Если первое условие не удовлетворено, то проверяется второе условие (следующее после elif), и в случае его истинности выполняется последовательность 2, а затем снова поток выполнения переходит к строке, следующей за оператором условия.

Аналогично проверяются все остальные условия. До ветки программы else поток выполнения доходит только в том случае, если не выполняется ни одно из условий. Условие, которое следует после слова elif проверяется только тогда, когда все предыдущие условия ложны.

Пример:

#!/usr/bin/env python 
# -*- coding: utf-8 -*- 
 
def p1(): 
 a=raw_input('Введите число ') 
 if a == '1':
  print 'a=1' 
 elif a == '2':
  print 'a=2' 
 
 else:
  print '1<a>2' 
  
def main(): 
 p1() 
 return 0 
 
if __name__ == '__main__':
 main()

Сначала программа просит пользователя ввести число, затем условный оператор проверяет введенное значение на равенство со строкой '1' (если не помните, функция raw_input() возвращает строковое значение).

Если условие истинно, то на экране распечатывается текст который мы зададим и завершается; в противном случае значение переменной а сравнивается со строкой '2': если условие выполняется, то на экране распечатывается уже другой текст; иначе – программа выводит сообщение о том, что введенное или меньше одного, или больше двух.

Pithon Функции (def) # 11

pythonblogg@mail.ru (Вячеслав) — Sun, 13 Mar 2011 00:39:00 -0800

Ранее работая мы использовали встроенные функции Питона и функции из модулей,

которые входят в комплект его поставки.

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

Конструкция любой функции:

def название_функции(список параметров):
    программа

Правила выбора имени функции такие же, как у переменной. (см.Имена переменных # 3)

Список параметров определяет набор значений, которые могут быть переданы функции в качестве исходных данных (параметры по умолчанию) – параметры перечисляются через запятую.

Но у вас наверняка возникнет вопрос, а зачем нужны функции?

Использование функций сокращает объём исходного кода. Удобней будет вынести часто повторяющиеся выражения в отдельный блок и по мере надобности, обращаться к нему.

Вот простейший пример работы функции:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

def primer_11(object):
    print(object)
 
def main():
    primer_11("Silver")
    return 0

if __name__ == '__main__':
    main()

В данной программе у функции primer_11() параметром является object. При вызове функции будет сделана распечатка на экран того, что написано в скобках. В нашем случае - Silver.

Python Цикл for # 10

pythonblogg@mail.ru (Вячеслав) — Sat, 12 Mar 2011 04:29:00 -0800

В предыдущей статье уже рассматривался цикл while. Но это не единственный способ организации повторения какой либо "программы".

Также как и while, цикл for часто применяется. Используется для того, чтобы пройтись по упорядоченным элементам какого либо множества.

Пример:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

def primer_9(): 
    stroka=[10,20,30,40,50,60]
    f=0
    for element in stroka:
       f=f+1 # счётчик цикла

    print(f) # распечатываем количество 
             # элементов в переменной stroka
 
def main():
    primer_9()
    return 0
 
if __name__ == '__main__':
    main()

Также вот аналогичный пример:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

def primer_10(): 
    a='silver' 
    for bukva in a:
        print (bukva) 
 
def main():
    primer_10()
    return 0

if __name__ == '__main__':
    main()

В этих двух примерах выполняется простейший циклический алгоритм. В первом - цикл for обращается к каждому элементу переменной ch. Переменная f используется как счётчик того, сколько элементов было просмотрено.

Во втором примере мы "расчленили" слово silver, а точнее мы разбили его по буквам.

Python Цикл While # 9

pythonblogg@mail.ru (Вячеслав) — Fri, 11 Mar 2011 05:35:00 -0800

Цикл - это выполнение одного и того же действия пока действует определённое условие. Применяется такой приём в программировании очень часто. Даже можно сказать, что нет ни одной сложной программы, где не использовался цикл.

Всего в языке Python два цикла: While, For. Сейчас будет рассматриваться While.

Также как и в операторе условия if, у цикла While имеется конструкция. Она довольна схожая.

while условие :
программа

Пример:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
def primer_9():
    a=0
    b=10
    while b>a:
        print ('цикл выполнился '+str(a)+' раз')
        a=a+1  
def main():
    primer_9()
    return 0
 
if __name__ == '__main__':
    main()

Данная программа выполняет циклическую операцию, где a и b переменные над которыми происходят вычисления.

Первым действием распечатывается текст "цикл ..." и значение a.
Вторым к a прибавляется один. Затем цикл повторяется до тех пор, пока а не будет равно 10.

Вот более сложный пример:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
def main(): 
    option=1
    while option != 0:
        print "***********MENU*************"
        print "1.Сумма чмсел"
        print "2.Периметр и Площадь Окружности"
        print "0.Выход"
        print "*" *28
        option = input("Введите номер функции:")
        if option == 0:
            quit
        
        if option == 1:
            a=input("Введите первое число:")
            b=input("Введите второе число:")
            c=a+b
            print ("Сумма рабна:" ,c)

        elif option == 2:
            r=input("Введите радиус:")
            perimetros=2*3.14*r
            embado=3.14*(r**2)
            print ("Периметр равен :",perimetros)
            print ("Площадь равна:",embado)

        else:
            print ("Нет такой функции" )
        return 0

if __name__ == '__main__':
   main()

Операционная система

pythonblogg@mail.ru (Вячеслав) — Thu, 10 Mar 2011 11:56:00 -0800

Данный вопрос ранее не поднимался, но это играет роль в работе программиста.

А какую ОС вы используете?

Хотелось бы услышать и от вас ответ.

По моему мнению для работы большее предпочтение в сторону UNIX систем.

Лично сам работаю на UBUNTU. Удобство во многом.
И самое главное - НЕТ ВИРУСОВ.

Python Оператор условия If # 8

pythonblogg@mail.ru (Вячеслав) — Thu, 10 Mar 2011 05:59:00 -0800

Операторы условия и выбора являются неотъемлемой частью любого языка программирования. Суть работы является следующее:

если действие удовлетворяет условию, то выполняется программа заданная пользователем, иначе выполняется следующая.

Работа с оператором условия проста. Необходимо только знать конструкцию.

if условие :
    программа при 
    удовлетворении условия
else :
    программа при 
    неудовлетворении условия

Вот пример программы:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

def primer_7(): # Объявление функции primer_7()
    a=eval(raw_input('Введите значение переменной а '))
            # функция eval() исполняет python код с тексте.
            # В данном случае то число или выражение
            # которое будет в переменной a
    b=eval(raw_input('Введите значение переменной b '))
    if a>b:  # а больше b то
        print ('а больше b') 
         
    else:    # Иначе
        print ('а меньше b')
def main():
    primer_7()
    return 0
 
if __name__ == '__main__':
    main()

Python Операторы ввода и вывода информации на экран # 7

pythonblogg@mail.ru (Вячеслав) — Wed, 9 Mar 2011 05:22:00 -0800

Запрос для значения переменных осуществляется с помощью операторов ввода. Сообщение о значении переменных и результаты арифметических вычислений реализуются с помощью операторов вывода.

В основном с операторов ввода или вывода начинается изучение любого языка программирования. В этом разделе мы ограничимся рассмотрением функции raw_input() и оператора print(). Ввод в Python производится с помощью клавиатуры, а вывод - на экран дисплея.

Оператор вывода информации на экран осуществляет оператор print().

Для того, чтобы вывести на экран текст, необходимо написать его в кавычках.

пр. print('Hello world!') - в данной строке мы распечатали на экране текст Hello World.

Но если вы хотите вывести на экран значение переменной, то кавычки не ставятся.

пр. a=1

print(a) - в данной строке мы распечатали на экран значение переменной a.

Функция ввода информации с клавиатуры.

Речь пойдёт о функции raw_input(). Синтаксис такой же как у оператора print().

Изначально raw_input() присваивают какой либо переменной, а затем в скобках пишется текст, который выводится на экран перед вводом.

пр. a=raw_input('Введите число') - программа выводит на экран текст "Введите число" и ожидает ввода с клавиатуры. Затем, когда число будет введено, оно присвоется переменной a.

Python Вычисление сложных математических функций # 6

pythonblogg@mail.ru (Вячеслав) — Tue, 8 Mar 2011 05:15:00 -0800

То, что сейчас будет описано применяется не часто, но знать это нужно обязательно. Имеется ввиду такие действия как вычисление квадратного корня, синуса, косинуса и др. Первым шагом обязательно надо импортировать библиотеку math. В ней и содержатся математические функции. Чтобы выполнить какое нибудь вычисление надо написать math.функция(значение)

Функции в библиотеке math:

math.ceil(x)

Возвращает округленное x как ближайшее целое значение типа float, большее или равное x (округление "вверх").

math.copysign(x, y)

Возвращает число x со знаком числа y. На платформе, поддерживающей знак нуля copysign(1.0, -0.0) даст -1.0.

math.fabs(x)

Возвращает абсолютное значение (модуль) числа x. В Python есть встроенная функция abs, но она возвращает модуль числа с тем же типом, что число, здесь же всегда float abs (fabs).

math.factorial(x)

Возвращает факториал целого числа x, если x не целое возбуждается ошибка ValueError.

math.floor(x)

В противоположность ceil(x) возвращает округленное x как ближайшее целое значение типа float, меньшее или равное x (округление "вниз").

math.fmod(x, y)

Аналогична функции fmod(x, y) библиотеки C. Отметим, что это не то же самое, что выражение Python x%y. Желательно использовать при работе с объектами float, в то время как x % y больше подходит для int.

math.frexp(x)

Представляет число в экспоненциальной записи x = m * 2e и возвращает мантиссу m (действительное число, модуль которого лежит в интервале от 0.5 до 1) и порядок e (целое число) как пару чисел (m, e). Если x=0, то возвращает (0.0, 0)

math.fsum(iterable)

Возвращает float сумму от числовых элементов итерируемого объекта.

math.isinf(x)

Проверяет, является ли float объект x плюс или минус бесконечностью, результат соответственно True или False.

math.isnan(x)

Проверяет, является ли float объект x объектом NaN (not a number).

math.ldexp(x, i)

Возвращает значение x * 2i, то есть осуществляет действие, обратное функции math.frexp(x).

math.modf(x)

Возвращает часть, идущую после запятой и целую часть от float числа. Оба результата сохраняют знак исходного числа x и представлены типом float.

math.trunc(x)

Возвращает целую часть числа x в виде int объекта.

Степенные и логарифмические функции

math.exp(x)

Возвращает ex.

math.log(x[, base])

При передаче функции одного аргумента x, возвращает натуральный логарифм x. При передаче двух аргументов, второй берется как основание логарифма.

math.log1p(x)

Возвращает натуральный логарифм от x+1.

math.log10(x)

Возвращает десятичный логарифм x.

math.pow(x, y)

Возвращает x в степени y.

math.sqrt(x)

Квадратный корень (square root) из x.

Тригонометрические функции

math.acos(x)

Возвращает арккосинус x, в радианах.

math.asin(x)

Возвращает арксинус x, в радианах.

math.atan(x)

Возвращает арктангенс x, в радианах.

math.atan2(y, x)

Возвращает atan(y/x), в радианах. Результат лежит в интервале [-π, π]. Вектор, конец, которого задается точкой (x, y) образует угол с положительным направлением оси x. Поэтому эта функция имеет более общее назначение, чем предыдущая. Например и atan(1), и atan2(1, 1) дадут в результате pi/4, но atan2(-1, -1) это уже -3*pi/4.

math.cos(x)

Возвращает косинус x, где x выражен в радианах.

math.hyp(x, y)

Возвращает евклидову норму, то есть sqrt(x**2+y**2). Удобно для вычисления гипотенузы (hyp) и длины вектора.

math.sin(x)

Возвращает синус x, где x выражен в радианах.

math.tan(x)

Возвращает тангенс x, где x выражен в радианах.

Радианы в градусы и наоборот

math.degrees(x)

Конвертирует значение угла x из радиан в градусы.

math.radians(x)

Конвертирует значение угла x из градусов в радианы.

Пример программы:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import math     # Импортируем библиотеку math

def primer_6(): # Объявление функции primer_6()
    a=144
    b=16 
    math.sqrt(a) # Извлекаем корень квадратный
                 # из переменной а

    d=b ** 2  # Возводим b в квадрат
    print ('а равно '+str(a)) 
    print('d равно '+str(d))
     
def main():
    primer_6() # Вызов функции primer_6
    return 0
 
if __name__ == '__main__':
    main()

Python Работа со строками # 5

pythonblogg@mail.ru (Вячеслав) — Mon, 7 Mar 2011 03:00:00 -0800

Простейшие операции уже были разобраны в предыдущей статье. Здесь будут описаны особенности, расширенные возможности.

P = ''    # Пустая строка
P = "C'est une pomme" # Строка в кавычках
block = """.......""" # Блоки в тройных кавычках
P = r'\tmp\home' # Неформатированные строки
P = u'pomme' #  Строки с символами Юникода
P * 3 # Повторять строку (3 раза)
P [1] # Обратиться к символу (к 1-у)
P [:-1] # Текст без последнего символа
P [5:16] # Срез от 5 до 16 символа
P.find('Pa') # Поиск
P.rstrip() # Удаление пробельных символов
P.replace('Pa','xx') # Заменить (pa на xx)
P.split(',') # Разбитие по символу-разделителю
P.isdigit() # Проверка содержимого
P.lower() # Преобразование регистра символов
P.endswith('pomme') # Проверка окончания строки
P.encode('latin-1') # Кодирование строк Юникода

# ======= специальные символы =======

\newline # Продолжение на новой строке
\\  # Остаётся один символ \
\'  # Апостроф (Остаётся один символ ')
\"  # Кавычки (Остаётся один символ ")
\a  # Звонок
\b  # Забой
\f  # Перевод формата
\n  # Новая строка
\r  # Возврат каретки
\t  # Горизонтальная табуляция
\v  # Вертикальная табуляция
\xhh  # Символ с шестнадцатеричным кодом hh 
\ooo  # Символ с восьмеричным кодом 000
\0  # Символ Null
\N{id}  # Id базы данных Юникода
\uhhhh  # 16-битный символ Юникода
\Uhhhhhhhh  # 32-битный символ Юникода

Пример программы:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

def primer_5(): # Объявление функции primer_5()
    a='Я программирую на языке Python \n'
    b='This is an apple'    
    print (a * 5) 
    print(b)
    print (b[5:10]+' с 5 по 10 символ')
     
def main():
    primer_5()
    return 0
 
if __name__ == '__main__':
    main()

Python Простейшие операции над строками # 4

pythonblogg@mail.ru (Вячеслав) — Sun, 6 Mar 2011 02:03:00 -0800

В общем говоря над строками нельзя производить такие же действия, что и с числами. Но оператор + работает с текстом и означает сцепление строк.

#!/usr/bin/env python
# -*- coding: utf-8 -*-

def primer_3(): # Объявление функции primer_2()
    a='Я'
    b=' программирую на языке'
    f=' Python'
    print (a+b+f+' :)') 
            # сцепляем строковые переменные a, 
         # b, f и 'текст' :)
def main():
    primer_3()
    return 0
 
if __name__ == '__main__':
    main()

Оператор * тоже можно использовать, но при условии, что одним из операндов будет целое число. данный оператор символизирует операцию повторения строки. Пример:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

def primer_4(): # Объявление функции primer_4()
    a='Я'
    b=' программирую на языке'
    f=' Python \n' # специальный символ \n
                # означает переход на следующую
                # строку
    g=a+b+f
    print (g * 3) 
               # распечатывам значение
            # переменной g 3 раза
def main():
    primer_4()
    return 0
 
if __name__ == '__main__':
    main()

Python Имена переменных # 3

pythonblogg@mail.ru (Вячеслав) — Sat, 5 Mar 2011 01:11:00 -0800

Работа с переменными очень проста и уже рассказывалась ниже в примерах.

Но при работе столкнулся, что не любым именем можно называть переменные (выдаст ошибку). В таблице ниже перечислены имена, которыми нельзя называть переменные:

and      del      for      is      raise
assert      elif      from      lambda      return
break      else      global      not      try
class      except      if      or      while
continue      exec      import      pass      yield
def      finally      in      print

Python Тип данных # 2

pythonblogg@mail.ru (Вячеслав) — Fri, 4 Mar 2011 00:41:00 -0800

В языке программирования Python имеется несколько типов данных. Это может быть строка, целое число, дробное число. При выполнении программы в некоторых ситуациях необходимо поменять число на текст (меняется только тип данных, а сами данные остаются теми же).

Сейчас основные типы данных будут перечислены:

str() - строковый тип данных
inf() - целочисленный тип
float() - дробный
Например:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# ПЕРВЫЕ ДВЕ СТРОЧКИ КОТОРЫЕ ВЫ ВИДИТЕ ВЫШЕ
# НАДО ПИСАТЬ ОБЯЗАТЕЛЬНО

def primer_2(): # Объявление функции primer_2()
    a=1
    b=5
    f=a+b
    print ('f равно '+str(f)) 
            #str(f) - этим действием
            # переменная f из целого числа 
            # стала строкой. Без этого
            # программа выдала бы ошибку потому
            # что мы складываем текст "f  равно"
            # и значение переменной f

    print (int(-2.3)) 
            # здесь мы переводим дробное число
            # -2.3 в целое (отбрасывается остаток)

    print (float(15)) 
            # а тут наоборот целое число 15
            # преобразуем в дробное (выйдет 15.0) 
  
def main():
    primer_2()
    return 0
 
if __name__ == '__main__':
    main()

Python Синтаксис языка # 1

pythonblogg@mail.ru (Вячеслав) — Thu, 3 Mar 2011 10:11:00 -0800

У каждого языка программирования свой синтаксис, но все они схожи. Python в этом плане очень прост. Сейчас будет перечислено самое основное:

Во первых если элемент вложен в другой, то делается отступ как показано ниже

#!/usr/bin/env python
# -*- coding: utf-8 -*-

def a_d(): # создана функция a_d() 
 a=2
 b=5
 c=a+b
 print('c равно == ',c) # вывод на экран текта 
   # "с равно " и значение переменной c
def main():
 a_d()
 return 0

if __name__ == '__main__':
 main()

Во вторых, после объявления функции, цикла, класса ставится двоеточие

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


def silver(): # объявление функции silver()
    a=2 # присваиваем переменной а значение 2
    b=3
    c=a+b
    print (c) # операция вывода на экран значение
              # переменной c

def main():  
    silver()  # вызов функции silver()           
            
    return 0  

if __name__ == '__main__':
    main()

Также необходимо знать, чтобы программа функции выполнилась, функцию нужно вызвать.

В предыдущем примере:

Функция main() запускается автоматически при запуске приложения. Функция silver() была вызвана и из-за этого выполнена.

И ещё, то что написано на одной строке после знака # является комментарием, а то есть не выполняется и никак не влияет на работу программы. Также если вы хотите закомментировать несколько строк, то их необходимо поставить между """ и """. (как на примере ниже)

def silver(): # объявление функции silver()
    a=2 # присваиваем переменной а значение 2
    b=3
    c=a+b
    print (c) # операция вывода на экран значение
              # переменной c

def main():  
    silver()  # вызов функции silver()           
            
    return 0  

if __name__ == '__main__':
    main()

Ещё один пример:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

def primer_11(object):
    print(object)
"""
Пример
Комментария

""" 
def main():
    primer_11("Silver")
    return 0

if __name__ == '__main__':
    main()