Простой блог на Flask

Создание блога кажется квинтэссенцией опыта при изучении нового веб-фреймворк. Я надеюсь, что этот пост даст вам инструменты для создания блога. В этой статье мы рассмотрим основы, чтобы получить функциональный сайт, но оставим много места для персонализации и улучшения. Фактический исходник блога поместится в 200 строчек Python кода.

Эта статья предназначено для начинающих разработчиков Python, среднего уровня, или опытных разработчиков, которые решили изучить Flask.

Спецификация

Особенности создаваемого блога:

  • Записи, отформатированные с использованием markdown
  • Записи поддерживают подсветку синтаксиса
  • Автоматическое видео/мультимедиа вставка с помощью OEmbed.
  • Очень красивый полнотекстовый поиск благодаря расширению SQLite FST.
  • Пагинация
  • Публикация записей

Вот примерный вид того, как блог будет выглядеть в конце.

Главная страница

p1425775025.68_800x800
image-4249

 

Страница записей

p1425775019.9_800x800
image-4250

 

Начинаем

Если вы хотите, чтобы пропустить статью и перейти непосредственно к коду, вы можете перейти по ссылке на GitHub.

Для начала, давайте создадим virtualenv и установим необходимые пакеты. Virtualenv, это практически стандартная библиотека, и она используется для создания изолированных, автономных сред Python, в которую вы можете установить свои пакеты. Посмотрите документацию по установке virtualenv.

Для нашего приложения мы должны установить следующие пакеты:

  • Flask, сам веб-фреймворк.
  • Peewee,  для хранения записей в базе данных и выполнения запросов.
  • pygments, подсветка синтаксиса с поддержкой огромного количества разных языков.
  • Markdown, форматирование для наших записей.
  • micawber, для преобразования адресов в обьекты. Например, если вы хотите встроить видео с YouTube, просто поместите URL на видео в свой пост и видео-плеер будет автоматически появляться на этом месте.
  • BeautifulSoup, требуется Микобером для разбора HTML.

 

$ virtualenv blog
New python executable in blog/bin/python2
Also creating executable in blog/bin/python
Installing setuptools, pip...done.
$ cd blog/
$ source bin/activate
(blog)$ pip install flask peewee pygments markdown micawber BeautifulSoup
...
Successfully installed flask peewee pygments markdown micawber BeautifulSoup Werkzeug Jinja2 itsdangerous markupsafe
Cleaning up...

Наш приложение будет находится в файле app.py. Мы также создадим несколько папок для статических файлов(стилей, JavaScript файлов) и папку для шаблонов.

(blog)$ mkdir app
(blog)$ cd app
(blog)$ touch app.py
(blog)$ mkdir {static,templates}

Настройка приложения Flask

Давайте начнем редактирования app.py и настроим наше приложение. Значения конфигурации могут быть размещены в отдельном модуле, но для простоты мы будем просто добавим их в том же файле что и наше приложение.

# app.py
import datetime
import functools
import os
import re
import urllib
from flask import (Flask, abort, flash, Markup, redirect, render_template,
                   request, Response, session, url_for)
from markdown import markdown
from markdown.extensions.codehilite import CodeHiliteExtension
from markdown.extensions.extra import ExtraExtension
from micawber import bootstrap_basic, parse_html
from micawber.cache import Cache as OEmbedCache
from peewee import *
from playhouse.flask_utils import FlaskDB, get_object_or_404, object_list
from playhouse.sqlite_ext import *
ADMIN_PASSWORD = 'secret'
APP_DIR = os.path.dirname(os.path.realpath(__file__))
DATABASE = 'sqliteext:///%s' % os.path.join(APP_DIR, 'blog.db')
DEBUG = False
SECRET_KEY = 'shhh, secret!'  # Used by Flask to encrypt session cookie.
SITE_WIDTH = 800
app = Flask(__name__)
app.config.from_object(__name__)
flask_db = FlaskDB(app)
database = flask_db.database
oembed_providers = bootstrap_basic(OEmbedCache())

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

Определение моделей баз данных

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

У модели записей будут следующие столбцы:

  • title
  • slug: для понятного url.
  • content: содержание записи.
  • published:  флаг, указывающий публикуется ли запись.
  • timestamp: раз создается запись.
  • id: PeeWee автоматически создаст первичный ключ автоинкрементный для нас, так что мы не должны определять его явно.

Индекс поиска будут храниться с использованием модели класса FTSEntry:

  • entry_id: первичный ключ индексированной записи.
  • content: поиск контента для данной записи.

Добавим следующий код после конфигурации в наш app.py:

class Entry(flask_db.Model):
    title = CharField()
    slug = CharField(unique=True)
    content = TextField()
    published = BooleanField(index=True)
    timestamp = DateTimeField(default=datetime.datetime.now, index=True)
    def save(self, *args, **kwargs):
        if not self.slug:
            self.slug = re.sub('[^\w]+', '-', self.title.lower())
        ret = super(Entry, self).save(*args, **kwargs)
        # Store search content.
        self.update_search_index()
        return ret
    def update_search_index(self):
        try:
            fts_entry = FTSEntry.get(FTSEntry.entry_id == self.id)
        except FTSEntry.DoesNotExist:
            fts_entry = FTSEntry(entry_id=self.id)
            force_insert = True
        else:
            force_insert = False
        fts_entry.content = '\n'.join((self.title, self.content))
        fts_entry.save(force_insert=force_insert)
class FTSEntry(FTSModel):
    entry_id = IntegerField(Entry)
    content = TextField()
    class Meta:
        database = database

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

Также обратите внимание, что мы создали несколько полей с индексом = True. Это говорит Peewee создать вторичный индекс по столбцам.

 

Код инициализации

Теперь, когда мы определили наши модели, давайте добавим код инициализации приложения. Когда мы запустим приложение в режиме отладки,  мы автоматически создадим таблицы базы данных, если они не существуют. Добавьте следующий код в конец файла app.py:

@app.template_filter('clean_querystring')
def clean_querystring(request_args, *keys_to_remove, **new_values):
    querystring = dict((key, value) for key, value in request_args.items())
    for key in keys_to_remove:
        querystring.pop(key, None)
    querystring.update(new_values)
    return urllib.urlencode(querystring)
@app.errorhandler(404)
def not_found(exc):
    return Response('
<h3>Not found</h3>
'), 404
def main():
    database.create_tables([Entry, FTSEntry], safe=True)
    app.run(debug=True)
if __name__ == '__main__':
    main()

Если вы хотите, вы можете попробовать запустить приложение сейчас. Но вы не сможем сделать какие-либо запросы, так как нет еще views, но база данных будет создана, и вы увидите следующий вывод:

$ cd blog  # switch to the blog virtualenv directory.
$ source bin/activate  # activate the virtualenv
(blog)$ cd app  # switch to the app subdirectory
(blog)$ python app.py
 * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
 * Restarting with reloader

Добавим функции входа и выхода

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

def login_required(fn):
    @functools.wraps(fn)
    def inner(*args, **kwargs):
        if session.get('logged_in'):
            return fn(*args, **kwargs)
        return redirect(url_for('login', next=request.path))
    return inner
@app.route('/login/', methods=['GET', 'POST'])
def login():
    next_url = request.args.get('next') or request.form.get('next')
    if request.method == 'POST' and request.form.get('password'):
        password = request.form.get('password')
        if password == app.config['ADMIN_PASSWORD']:
            session['logged_in'] = True
            session.permanent = True  # Use cookie to store session.
            flash('You are now logged in.', 'success')
            return redirect(next_url or url_for('index'))
        else:
            flash('Incorrect password.', 'danger')
    return render_template('login.html', next_url=next_url)
@app.route('/logout/', methods=['GET', 'POST'])
def logout():
    if request.method == 'POST':
        session.clear()
        return redirect(url_for('login'))
    return render_template('logout.html')

Обратите внимание, что вьюхи входа и выхода делают разные вещи в зависимости от того, был ли запрос GET или POST. При переходе на страницу /login/, вы увидите шаблон с полем ввода. Когда вы отправляете форму, вьюха будет проверять пароль, и перенаправить на главную или отобразить сообщение об ошибке.

Реализация views

Теперь, когда мы создали фундамент нашего сайта, мы можем начать работать над тем, что на самом деле будет использоваться для отображения и управления записей в блоге. Благодаря некоторым из помощников в модуле flask_utils Playhouse, код будет минимальным.

Главная, поиск, черновики

Давайте начнем с главной страницы. Это будет страница с записями, с сортировкой по времени, и будут отображаться последние 20 записей. Мы будем использовать object_list из flask_utils, который принимает запрос и возвращает запрошенную страницу объектов. Кроме того, индекс страницы позволит пользователям осуществлять поиск.

Добавим следующий код после кода аутентификации:

@app.route('/')
def index():
    search_query = request.args.get('q')
    if search_query:
        query = Entry.search(search_query)
    else:
        query = Entry.public().order_by(Entry.timestamp.desc())
    return object_list('index.html', query, search=search_query)

Если поисковый запрос присутствует, как указано в GET аргумента q, будем вызывать метод Entry.search(). Этот метод будет использовать SQLite полнотекстовый поисковый индекс для запроса соответствующих записей. Полнотекстовый поиск SQLite поддерживает логические запросы, цитирование, и многое другое.

Вы можете заметить, что мы также вызываем Entry.public(),  если нет поискового запроса. Этот метод вернет только опубликованные записи.

Для реализации этого, добавим следующие методы в наш класс:

@classmethod
def public(cls):
    return Entry.select().where(Entry.published == True)
@classmethod
def search(cls, query):
    words = [word.strip() for word in query.split() if word.strip()]
    if not words:
        # Return empty query.
        return Entry.select().where(Entry.id == 0)
    else:
        search = ' '.join(words)
    return (FTSEntry
            .select(
                FTSEntry,
                Entry,
                FTSEntry.rank().alias('score'))
            .join(Entry, on=(FTSEntry.entry_id == Entry.id).alias('entry'))
            .where(
                (Entry.published == True) &
                (FTSEntry.match(search)))
            .order_by(SQL('score').desc()))

Давайте кратко разберемся в методе search. Здесь мы запрашиваем таблицу FTSEntry, в которой хранится поисковые индексы наших записей. Полнотекстовый поиск SQLite внедряет оператор MATCH, который мы будем использовать, чтобы соответствовать индексированный контент от поискового запроса. Мы также присоединяемся к таблице записей таким образом, что мы вернем только опубликованные записи.

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

@classmethod
def drafts(cls):
    return Entry.select().where(Entry.published == False)
@app.route('/drafts/')
@login_required
def drafts():
    query = Entry.drafts().order_by(Entry.timestamp.desc())
    return object_list('index.html', query)

Детальная страница записей

Мы будем использовать дружественные URL. Вы, возможно, помните, что мы перегрузили метод Entry.save() для заполнения поля slug с URL. Добавим следующий код в наше приложение:

@app.route('/<slug>/')
def detail(slug):
    if session.get('logged_in'):
        query = Entry.select()
    else:
        query = Entry.public()
    entry = get_object_or_404(query, Entry.slug == slug)
    return render_template('detail.html', entry=entry)

Get_object_or_404 определен в модуле Playhouse flask_utils и, если объект, соответствующих запросу не найдено, возвращает ответ 404.

Отображение содержание записей

Для того, чтобы преобразовать тексты записей в формате HTML, мы добавим дополнительное свойство к нашему классу. Это свойство будет включить содержание записи в HTML и конвертировать медиа ссылки в встроенных объекты (т.е. URL YouTube становится видеоплеер).

Добавим следующее свойство модели:

@property
def html_content(self):
    hilite = CodeHiliteExtension(linenums=False, css_class='highlight')
    extras = ExtraExtension()
    markdown_content = markdown(self.content, extensions=[hilite, extras])
    oembed_content = parse_html(
        markdown_content,
        oembed_providers,
        urlize_all=True,
        maxwidth=app.config['SITE_WIDTH'])
    return Markup(oembed_content)

Объект Markup говорит Flask что мы доверяем содержание HTML, поэтому он не будет обрезать его при выводе.

Создание и редактирование записей

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

@app.route('/create/', methods=['GET', 'POST'])
@login_required
def create():
    if request.method == 'POST':
        if request.form.get('title') and request.form.get('content'):
            entry = Entry.create(
                title=request.form['title'],
                content=request.form['title'],
                published=request.form.get('published') or False)
            flash('Entry created successfully.', 'success')
            if entry.published:
                return redirect(url_for('detail', slug=entry.slug))
            else:
                return redirect(url_for('edit', slug=entry.slug))
        else:
            flash('Title and Content are required.', 'danger')
    return render_template('create.html')
@app.route('/<slug>/edit/', methods=['GET', 'POST'])
@login_required
def edit(slug):
    entry = get_object_or_404(Entry, Entry.slug == slug)
    if request.method == 'POST':
        if request.form.get('title') and request.form.get('content'):
            entry.title = request.form['title']
            entry.content = request.form['content']
            entry.published = request.form.get('published') or False
            entry.save()
            flash('Entry saved successfully.', 'success')
            if entry.published:
                return redirect(url_for('detail', slug=entry.slug))
            else:
                return redirect(url_for('edit', slug=entry.slug))
        else:
            flash('Title and Content are required.', 'danger')
    return render_template('edit.html', entry=entry)

Далее осталось добавить только шаблоны у статический файлы. Их вы можете скачать с GitHux, ссылка в начале статьи.

Продвинутые концепции Flask

flask
image-888

Введение — приложение, которое можно масштабировать.

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

Существует два тесно связанных понятий связанных с масштабированием — как влияет на приложение увеличение числа пользователей и как влияет на разработку приложения увеличение числа программистов. Эти проблемы являются центральными в разработке программного обеспечения. Центральные вопросы: Как мы эффективно будем работать в командах 20 разработчиков, 40 разработчиков, или даже тысячи? И как нам справиться с максимальной нагрузки на нашей системе?

Эти вопросы могут показаться простыми, но всегда есть подводные камни. В плохо разработанное приложение, миллионы строк в итоге могут быть выброшены. С другой стороны, есть некоторые системы, которые были разработаны еще в 70-х годах и до сих пор используется.

Масштабирование кодовой базы

Масштабирование кодовой базы требует хорошего проектирования, который может быть трудным с изменением требований со стороны конечных пользователей и клиентов. Для того, чтобы управлять скоростью, при которой происходит разработка, важно знать как должно работать ваше приложение и что он должно делать. Благодоря этому вы можете сократить написание кода.

Есть некоторые идеи которые можно использовать при проектировании  кода:

  1. Модульность
  2. Слабосвязанный код лучше, чем тесно связанный (обычно)
  3. Используйте комментарии
  4. Повторно используйте код, как можно чаще
  5. Пишете код, который является как можно более общим
  6. Тестируйте так часто, как это возможно, и на уровне модуля и на уровень системы
  7. Дайте себе достаточно времени, чтобы добиться своей цели, и затем останьтесь в рамках бюджета
  8. Сотрудничество является крайне важным

Следует отметить, что все из перечисленных выше пунктов, не будут рассмотрены в этой статье; Пункты 6 — 8 будет в значительной степени игнорироваться.

Давайте поговорим о модульности. При разработке программы, как правило, вы будете сначала думать над всем приложением. Например: если создать сайт, который позволяет повысить уровень информированности о рабстве, какие функции нужны?

  1. Сервер для обслуживания страниц. — конкретно
  2. База данных для хранения данных пользователей. — конкретно
  3. Способ входа активных пользователей, и взаимодействия с ними. — расплывчато
  4. Система управления контентом для администратора сайта, для обновления сайта. — конкретно
  5. Способ взаимодействовать с сообществом которое мы разрабатываем. — расплывчато
  6. RSS фиды — конкретно
  7. Способ централизованного управления нашей социальной наличием. — конкретно
  8. Поддержка видео контента. — конкретно

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

Итак, давайте разобьем расплывчатые понятия:

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

  1. Таблица базы данных регистрации пользователей в нашей системе.
  2. Функция или набор функций, которые необходимо работы с пользователями.

Способ взаимодействовать с сообществом которое мы разрабатываем. Можно разделить на:

  1. Форум для обсуждения тем
  2. Раздел комментарий после каждого поста в блоге.
  3. Обратная связь и контакты для связи с администрацией сайта

Теперь, когда у нас есть план для нашего приложения, давайте посмотрим, что уже есть у Flask и что мы должны написать сами.

Что мы получаем с Flask

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

База данных — Flask поставляется с SQLite, но есть и много других вариантов.

Вход пользователей? Мы должны создать эту функциональность в нашем приложении.

То, что мы должны написать:

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

Форум — это может быть частью нашей системы управления контентом, но вероятно лучше, чтобы создать для этого свой собственный модуль.

RSS — мы создадим это в его собственном разделе приложения.

Почтовый клиент — мы должны создать тоже с нуля.

Имея свой дизайн настроен, как правило, сэкономить время. В этом примере, зная доска объявлений и CMS потребуется некоторое повторное использование кода, необходимо сохранить какое-то время.

Blue prints (эскизы)

Так что мы идем вперед и создаем пять раздельных приложений, и код будет повторятся в каких то местах? Конечно нет! Эскизы позволяют создать одно большое приложение, работающее с несколькими приложениями одновременно. Благодаря этому увеличивается модульность приложения и в целом облегчит разработку. Это также делают ваш код более отказоустойчивым. Это означает, что когда часть вашего кода не работает, будет легче найти причину, и у вас будете меньше ошибок (потому что у вас есть куча небольших приложений вместо одного очень большого).

Настройка нашего проекта

Если вы уже работали с Flask, создание  настройка эскизов будет вам знакома.

Настройка эскизов имеет почти тот же синтаксис, как создание приложений Flask. Разница лишь в том, что вы регистрируете эскизы в приложение после того как вы создали их.

Структура каталога:

run.py
/slavery_website/
    __init__.py
    blog/
        __init__.py
        static/
        templates/
        views.py
        models.py
    cms/
        __init__.py
        static/
        templates/
        views.py
        models.py
    email_client/
        __init__.py
        static/
        templates/
        views.py
        models.py
    feeder/
        __init__.py
        static/
        templates/
        views.py
        models.py
    logger/
        __init__.py
        static/
        templates/
        views.py
        models.py
    message_board/
        __init__.py
        static/
        templates/
        views.py
        models.py

Некоторые из views.py файлов

cms/views.py

from flask import Blueprint, render_template
from models import *
cms = Blueprint("cms",__name__,template_folder='templates')
@cms.route("/add",methods=["GET","POST"])
def add():
    return render_template("admin.html")
@cms.route("/remove",methods=["GET","POST"])
def remove():
    return render_template("admin.html")
@cms.route("/view_entries",methods=["GET","POST"])
def view_entries():
    entries = get_entries()
    return render_template("entries.html",entries=entries)

logger/views.py

from flask import Blueprint, render_template
from models import *
logger = Blueprint('logger',__name__,template_folder="templates")
@logger.route("/analytics/page_views",methods=["GET","POST"])
def page_views():
    pages = get_page_views()
    return render_template("viewer.html",pages=pages)
@logger.route("/analytics/button_press", methods=["GET","POST"])
def button_press():
    buttons = get_button_press()
    return render_template("viewer.html",buttons=buttons)
**Some functions snipped**

slavery_website/init.py:

from flask import Flask
from cms.views import cms
from logger.views import logger
app = Flask(__name__)
app.register_blueprint(cms, url_prefix='/admin')
app.register_blueprint(logger,url_prefix='/analytics')

ООП и Python

За и против использования ООП в Python. Как решить нужно ли помещать код в класс или функций достаточно. Как применять классические принципы ООП к Python.

Как настроить Python для Android разработки с Ubuntu и Buildozer

В этой статье мы увидим, как собрать Python для Android разработки с Ubuntu (проверено на Ubuntu 14.04) и Buildozer. Итак, давайте начнем.

buildozer-cloud[1]
image-859

 

Установка Buildozer

Вы можете прочитать полную документацию здесь про Buildozer.

Сам Buildozer не зависит от какой-либо библиотеки, и работает на Python 2.7 и >= 3.3. Я рекомендую вам использовать Python 2.7.

Во-первых, нам нужно скачать pip, инструмент для установки и управления пакетами Python.

apt-get install python-pip

Теперь, чтобы установим Buildozer:

pip install --upgrade buildozer

Если все работает нормально, вы увидите результат: Successfully installed buildozer

Настройка для Android

Для разработки под Android, необходимо установить как минимум Cython и Java SDK. Некоторые двоичные файлы Android SDK все еще находятся в 32 битных библиотеках, так что нужно сделать их доступными.

Установка Cython:

apt-get install python2.7-dev
pip install --upgrade cython

Теперь, сделаем 32х битные библиотеки доступными:

dpkg --add-architecture i386

После этого, вы можете обновить и установить необходимые пакеты:

apt-get update
apt-get install build-essential ccache git lib32z1 libncurses5:i386 libstdc++6:i386 python2.7 openjdk-7-jdk unzip zlib1g-dev zlib1g:i386

Хорошо, теперь у нас есть все, чтобы начать разработку с Python под Android. Давайте попробуем.

Простой пример

Давайте создадим Hello World приложение, чтобы проверить, все ли работает. В этом примере, я собираюсь использовать Kivy. Если у вас не установлен Kivy, запустите следующую команду:

apt-get install python-kivy

Теперь создадим новый файл с именем main.py, и не забудьте добавить строку __version__ = "1.0" в вашем файле, потому что buildozer будет пытаться найти эту строку, чтобы определить версию приложения.

Код программы Hello World:

__version__ = “1.0”
from kivy.app import App
from kivy.uix.button import Button
class Hello(App):
    def build(self):
        btn = Button(text='Hello World')
        return  btn
Hello().run()

Теперь откройте терминал и перейдите к папке с main.py. После этого, создадим buildozer.spec файл, с помощью команды:

buildozer init

Вы можете открыть файл buildzoer.spec и изменить настройки приложения, такие как имя, разработчик и другие подобные параметры.

Для создания проекта, выполним:

buildozer -v android debug

Эта команда скачивает python-for-android, Android SDK и Android NDK, если вы запускаете ее первый раз. Это процесс займет определенное время, так как их размеры не маленькие.

После этого, вы увидите сообщение:

# Android packaging done!
# APK MyApplication-1.2.0-debug.apk available in the bin directory

Теперь вы можете взять apk файл из папки bin, и установить его на ваше устройство. Если ваше устройство подключено к usb, просто запустите эту команду для установки:

adb install bin/MyApplication-1.2.0-debug.apk

Пример работы приложения:

screenshot_2014-05-21-21-47-56
image-860

Android разработка с Python и Kivy

В этой статье я покажу вам, как начать разработку для Android с использованием Python и Kivy. Вы увидите, как загрузить и настроить Kivy, и создать простое Hello World приложение. В конце, мы построим наше APK приложение, и установим его на Android.

kivy-logo-black-256
image-849

Установка

Чтобы облегчить разработку, Kivy предоставили нам виртуальную машину готовую для использования. Нужно просто скачать ее и использовать.

Прокрутите сайт к концу страницы и вы увидите ссылку на скачивание.

captura-de-tela-de-2014-05-21-201146
image-850

Каждая платформа имеет разный процесс установки, поэтому я рекомендую вам скачать и установить виртуальную машину, чтобы избежать проблем. Вы можете запустить виртуальную машину (на основе Ubuntu 32 бит) с использованием Oracle Virtual Box.

Создание первого проекта

Сейчас мы создадим простой проект, чтобы проверить, все ли работает. Вы сможете запустить его на компьютере. После того как мы закончим, мы сможем создать приложение для Android.

from kivy.app import App
from kivy.uix.button import Button
class Hello(App):
    def build(self):
        btn = Button(text='Hello World')
        return  btn
Hello().run()

Этот код создаст простое окно, и кнопку с текстом «Hello World».

Создание Android приложения

Теперь, давайте построим нашу программу для Android. (Основной файл проекта должен назван main.py)

Для создания Android проекта с Python и Kivy, откройте терминал и выполните команду:

git clone git://github.com/kivy/python-for-android
cd python-for-android

Эта команда загрузит необходимые инструменты, чтобы начать разработку.

Теперь, вам нужно построить модули, которые вы будете использовать в вашем проекте. В этом случае, мы используем только Kivy. Таким образом, запустите:

./distribute.sh -m "kivy"

Эта команда скачает и настроит все что вам нужно.

Теперь перейдите к папке dist/default и выполним команду:

./build.py --dir <path to your app>
           --name "<title>"
           --package <org.of.your.app>
           --version <human version>
           --icon <path to an icon to use>
           --orientation <landscape|portrait>
           --permission <android permission like VIBRATE> (multiple allowed)
           <debug|release> <installd|installr|...>

В нашем случаем мы получим:

./build.py --dir /tmp/python
           --name "Hello"
           --package com.wordpress.bytedebugger.hello
           --version 1
           debug installd

Эта команда создаст Apk. Apk создаст папку bin.Теперь установите приложение на ваше Android устройство.

screenshot_2014-05-21-21-47-56
image-851

 

Вот и все. Теперь, вы можете разрабатывать с помощью Python + Kivy под Android.

Использование Python для разбора табличных данных

python_excel_logos

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

В этой статье мы обсудим различные способы обработки этих файлов и анализа их, чтобы получить необходимую информацию с помощью Python (2.7).

Электронная таблица

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

1419667062spreadsheet
image-618

Например, в данном примере, таблица содержит только один лист, Query1. Ячейка 2A соответствует второй строке и первом столбце. Значение ячейки А2 является «12510001».

Хотя программы с графическим интерфейсом назначать буквы названия столбцов, когда мы разбираем данные, мы начнем номера строк и столбцов с 0 Это означает, что клетка A2 будет соответствовать (1, 0),  В4, это (1,3) , 3C (2, 2), и так далее.

Быстрый Резюме CSV-файлов

CSV означает «значения разделенные запятыми» (или любым другим разделителем). Типичный файл CSV выглядит следующим образом:

"ID", "Name", "Age"
"1", "John", "11"
"2", "Mary", "12"
"3", "Sherlock", "13"

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

Получение необходимых модулей Python

Для чтения и записи XLS файлов, вам нужно будет установить два модуля — xlrd и xlwt. Вы можете установить их с помощью одного из Python менеджеров: pipили easy_install.

pip install xlrd
pip install xlwt

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

Чтение электронной таблицы

Если у вас есть файл, и вы хотите анализировать данные в нем, необходимо выполнить следующее пункты в указанном порядке:

  • Импорт модуля xlrd
  • Откройте файл электронной таблицы (или книги)
  • Выберите лист
  • Извлеките данные из отдельных ячеек

Откройте файл электронной таблицы

Давайте сначала открыть файл в Python.

import xlrd
workbook = xlrd.open_workbook('my_file_name.xls')

Если ваш файл имеет символы, отличные от ASCII, вы должны открыть его в формате Юникод следующим образом:

workbook = xlrd.open_workbook('my_file_name.xls', encoding='cp1252')

Если ваша электронная таблица очень большая, вы можете добавить аргумент on_demand в open_workbook, который загружает только текущие листы в память:

workbook = xlrd.open_workbook('my_file_name.xls', on_demand = True)

Открытие листа

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

worksheet = workbook.sheet_by_name('My_Sheet_Name')

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

worksheet = workbook.sheet_by_index(0)

workbook.nsheets возвращает количество листов. workbook.sheet_names() выдает список имен листов в файле, который поможет вам с перебором листов.

Получение данных из ячеек

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

# Value of 1st row and 1st column
worksheet.cell(0, 0).value

Вы можете использовать циклы для получения всех данных.

Вы можете обнаружить пустую ячейку с помощью empty_cell.

if worksheet.cell(0, 0).value == xlrd.empty_cell.value:
    # Do something

Создание электронной таблицы

Процесс создания таблицы состоит из следующих пунктов:

  • Импортировать модуль xlwt
  • Создайте пустой файл электронной таблицы (или книги)
  • Создать лист в файле
  • Разместить значения в ячейках
  • Сохранить книгу

Создайте новый файла

Вы можете создать новый файл электронной таблицы с помощью xlwt. Пример создания файла:

import xlwt
workbook = xlwt.Workbook()
workbook.save('my_file.xls')

Вы можете открыть его в Unicode так же, как и в случае с xlrd.

Добавление листов

Вы можете добавить листы с помощью add_sheet.

sheet = workbook.add_sheet('Sheet_1')

Работа с ячейками

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

sheet.write(0, 0,'Inserting data in 1st Row and 1st Column')

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

row = sheet.row(1) # Selecting the second row
row.write(0,'2nd Row and 1st Column')
row.write(1,'1st Row and 2nd Column')

Если вы хотите, чтобы удалить данные в строке, это может быть сделано одной командой.

row.flush_row_data()

Так же, вы можете установить ширину столбца

sheet.col(0).width = 625 # In pixels

Добавление стилей к ячейкам

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

style = xlwt.XFStyle()
font = xlwt.Font('Arial')
style.font = font
pattern = xlwt.Pattern()
pattern.pattern = xlwt.Pattern.SOLID_PATTERN
pattern.pattern_fore_colour = xlwt.Style.colour_map['red']
style.pattern = pattern
sheet.write(0, 0, "Some data", style)

Вывод

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

Языки и фреймворки, которые вы должны изучить в 2015м году

Языки / платформы

Node.js является победителем в этом списке,  PHP второй, и JavaScript — третий. Существует большое сообщество вокруг Node.js, так что это не удивительно. Если вы знаете JavaScript, вы уже наполовину способны к создания веб-приложений в Node.js.

Фреймворки

AngularJS занимает первое место среди фреймворков. Крупные компании и предприятия приняли Angular, и вырос спрос на специалистов знающих данный фреймворк. Дело в том, что он опирается на некоторые из лучших инженеров Google, также помогает ему достичь первое место.

Чтобы помочь вам сделать свой выбор, ниже небольшой обзор из вышеперечисленных технологий!

Вот то, чему вы должны научиться в 2015 году

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

1. JavaScript везде

офмфыскшзе
image-323

Если вы занимаетесь веб-разработкой, JavaScript является языком, который вы должны знать, независимо от того, какой язык программирования используете. Сегодня вы можете использовать JS в браузере, на сервере, в мобильных приложениях и даже на программируемом оборудовании. ES6 принесет необходимых улучшений и сделает язык еще более мощным и легко в написании. Это также хорошая идея, чтобы узнать о Bower и npm, а также инструменты, такие как jshint и jscs.

2. AngularJS

angular
image-324

AngularJS является JavaScript фреймворком от Google, который быстро зарекомендовал себя как инструмент для создания мощных веб-приложений. При этом признании приходит повышенный спрос на программистов умеющих работать с ним, по этому вы найдете упоминание о нем в списке требований почти в каждом вакансии JavaScript разработчика. Причин не изучать его просто нет.

3. React

react
image-325

React является новичком в этом списке. Библиотека разработана Facebook и обеспечивает очень быструю работу благодаря производительности своей виртуальной DOM, и может быть легко подключен в существующие проекты. Она также имеет очень активное сообщество, которое развивается все виды компонентов. На наш взгляд, React имеет большой потенциал и является фреймворком, который стоит чтобы посмотреть (и учить) в 2015 году.

4. Node.js

nodejs
image-326

С Node.js вы можете разрабатывать сетевые серверные приложения на JavaScript. Он может быть использован для простых движков веб-сайтов с использованием такой структуры, как Express, конечных точек API, WebSocket серверов или даже торрент-клиентов. Node имеет невероятно активное сообщество и превысил всех других языков по количеству модулей в этом году.

5. NoSQL databases

nosql
image-327

Базы данных, которые не нужны ни таблицы, ни SQL высоко ценятся современные веб-разработчики, и мы считаем, что эти базы данных станут только более популярным в следующем году. Два примечательных варианты MongoDB и Redis. Это гораздо проще начать с одного из этих баз данных, чем с MySQL и Postgres. Но не ведитесь, думая, что базы данных NoSQL являются идеальной заменой — в некоторых ситуациях классический реляционная база данных сделает ваше развитие легче даже если это займет больше усилий.

6. Less/Sass/Stylus

lesscss
image-328

Существует много что не нравится в CSS. Это слишком просто, в конечном итоге получаются громоздкие файлы с 1000 линиями, который трудно ориентироваться и измененять. Чтобы решить эту проблему, есть языки, такие как Less, Sass и Styles, которые составляются для CSS и предлагают переменные, макросы и другие вкусности, которые помогут вам улучшить ваш код. Вы можете изучить один из них за один день.

7. Потрясающие новые фреймворки

exciting-new-frameworks
image-329

Meteor принципиально новый подход к развитию веб-приложений, которые размывает границы между фронтендом и бекендом. Это позволяет писать Reall-time приложения, и имеет быстро растущее сообщество. Hood.ie является небольшим его соперником, и предлагает новый подход. Он обрабатывает серверную часть для вас, так что вы можете полностью сосредоточиться на фронтенде вашего приложения.

8. Потрясающие новые языки

exciting-new-languages
image-330

Для языковых ботаников, вот некоторые новые языки. Golang, Rust и Elixir набирают обороты в программировании и используются в ситуациях, когда требуется очень высокая производительность.

9. Классические популярные фремворки

full-stack-frameworks
image-331

Несмотря на то что одностраничные приложения набирает популярность, до сих пор огромный спрос имеют на классические серверных веб-приложения. Ruby on Rails, Django, Laravel, Play, ASP.NET являются наиболее популярными фреймворками в данный момент.

10. Старая гвардия

the-old-guard
image-332

Существует большая коллекция установленных языков и платформ, которые по-прежнему востребованы — Java, .NET, Python, Ruby. Они имеют большие сообщества и будет хорошо смотреться в любом резюме. Все они имеют свои плюсы и минусы.

Топ 10 Python проектов на GitHub

Есть много репозоториев для языка Python в GitHub и вот список топ-10 среди них.

1. Django

высокого уровень Python веб-фреймворка, что способствует быстрому развитию проекта

2. Requests

HTTP для человека — HTTP библиотека, написанная в Python, для человека

3. HTTPie

HTTP клиент командной строки

4. flask

микрофреймворк для Python на основе Werkzeug, Jinja 2

5. Tornado

Python веб-фреймворк и асинхронные библиотеки, первоначально разработанная в FriendFeed

6. Ansible

Это очень просто IT двигатель с помощью которого можно легко развертывать приложения и системы. Язык может быть автоматизирован, подходит простым английским языком, используя SSH, без агентов для установки на удаленных системах

7. Python Guide

руководство по Python, лучший гайд из написанных

8. Sentry

Sentry является в режиме реального времени, платформа агностик регистрации ошибок и платформа агрегации

9. Scrapy

Scrapy является веб кравлинг фреймворком для Python, который также экран выскабливание высокого уровня.

10. YouCompleteMe

Автозавершения кода для Vim