Personal notes

Итераторы для начинающих. Путь С++

2011-08-20T17:52:00.000+03:00

Предисловие

Данный пост предназначен исключительно для начинающих и не преследует цели рассказать всё об итераторах в С++. Так что если вы знаете о чём-нибудь вроде iterator_traits<> , вам не будет интересно. Тем не менее, я надеюсь, что эта информация будет полезна для людей, которые раньше не сталкивались с итераторами.

Практическая задача

Предположим перед нами стоит простая задача - написать функцию, которая находила бы в массиве целых чисел максимальное значение и возвращала его индекс. Вы могли бы сделать это примерно так: Функция работает замечательно, но сразу видно её ограничение - она работает только с целыми значениями типа int. Для поиска максимального значения в массива из элементов типа float нам нужно написать такую же функцию, только изменив название типа. Мы знаем, что в таком случае, лучшие друзья С++-программиста - шаблоны (templates).

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

Мы знаем, что массивы в С++ представляют собой линейно выделенный участок памяти, в котором по порядку расположены элементы. Более того имя массива является указателем на его первый элемент. Указатели и массивы неразрывно связаны - для доступа к элементам массива можно использовать адресную арифметику.

Интервал элементов для нашей функции можно задавать при помощи двух указателей - указателя на первый нужный элемент (begin) и указателем на элемент, следующий за последним нужным элементом (end). Почему именно полуоткрытый интервал [begin; end)? Потому что это позволит формировать условие выхода из цикла очевидным образом.

Реализация выглядит примерно так: Используя этот вариант функции можно искать индекс максимального элемента во всём массиве, либо в какой-то его части:

А можно ли обобщить ещё больше?

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

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

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

Давайте ещё раз взглянем на нашу функцию: Какие операции для доступа к элементам мы используем?

* - разыменование указателя - получения значения, которое хранится по адресу указателя;
!= - сравнение двух указателей на неравенство (для определения конца интервала);
++ - инкремент - для перемещения указателя на следующий элемент.

Если бы мы могли передать в функцию max_element() вместо обычного указателя какой-нибудь объект, то определив для него данные операции, можно было бы заключить в них логику доступа к элементам связного списка. Это не сложно сделать, используя механизмы перегрузки операторов и шаблонов. Окончательный вариант функции выглядит так: Вместо указателя используется новый параметр шаблона - класс Iterator.Так что же такое итератор?

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

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

Пример своего итератора

Рассмотрим простейшую реализацию связного списка. Реализация узла списка: Реализация класса списка: Реализован минимальный набор методов:

Инициализация структуры данных, освобождение памяти - LinkedList(), ~LinkedList().
Добавление элементов в начало и в конец списка - push_front(), push_back().
Доступ к элементам списка - методы, вовзращающие итераторы на начало и конец (как вы помните, для итераторов конец - это элемент следующий сразу за последним) - begin(), end().

При помощи 2 итераторов можно пройти по всем элементам списка между ними. Реализация итератора для списка: Итератор инициализируется указателем на узел связного списка. Перегруженные операторы содержат логику перемещения между узлами и получения хранимого значения.

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

Заключение

Это, конечно же, лишь малая часть того, что нужно знать об итераторах. Мы рассмотрели лишь один вид итераторов, так называемые Forward Iterators, которые позволяют получать следующие элементы, двигаясь "прямо" (используется оператор ++). Существуют и другие виды итераторов, например, Bidirectional Iterators, которые также позволяют двигаться в обратном направлении (к операторам ++, !=, * добавляется оператор --), и другие.

В С++ в качестве интерфейса итераторов используется семантика указателей, но это просто условность - мог быть выбран любой другой интерфейс. Однако такая реализация позволяет использовать обычные указатели в качеcтве итераторов.

Итераторы играют очень важную роль в STL - они позволяют отделить алгоритмы от структур данных - являются прослойкой между ними. Таким образом алгоритмы могут быть обобщены для использования над различными структурами данных.

Исходный код примеров доступен здесь:https://github.com/malor/iterators-source

P.S. Отрывки кода внутри поста размещены на pastebin-сервисе XSnippet.tk.

Python. List Comprehensions and Generator Expressions

2011-03-23T20:35:00.000+02:00

List Comprehensions

Предположим, у вас есть список целых чисел:

numbers = [1, 2, 3, 4, 5, 6]

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

squares = [] # создаём новый список
    for i in numbers: # проходим в цикле по всем элементам
        squares.append(i * i) # вычисляем квадрат и добавляем его в конец списка

В принципе, в этом нет ничего плохого, но в Python есть более удобная синтаксическая форма построения нового списка:

squares = [i * i for i in numbers]

Давайте разберёмся, что это значит:

Использование скобок [ ] говорит нам о том, что происходит создание нового списка.
Правая часть записи ("for i in numbers") представляет собой обычный цикл for: переменной i по очереди присваивается значения из списка numbers(1, 2, 3 ...).
Левая часть представляет собой произвольное выражение, возвращающее какое-то значение. В нашем случае вычисляется значение i * i.
После того, как выражение будет вычислено, результат будет добавлен в конец создаваемого списка.
Операция будет выполнена для каждого значения i, получаемого в цикле for.

Такой способ создания списка называется list comprehensions. Использование этой синтаксической особенности Python делает код более простым и читабельным (думаю, многие заметили, что list comprehensions чем-то напоминают задание множеств элементов в дискретной математике).

А что если нужно получить квадраты лишь чётных чисел? Опять таки, всё просто:

    squares = [i * i for i in numbers if i % 2 == 0]

Этот пример отличается от предыдущего лишь наличием оператора if, после которого следует предикат — какое-либо выражение (в том числе и вызов функции или метода), возвращающее значение типа bool. В этом случае в создаваемый список будут добавлены лишь те элементы, для которых значение предиката будет равно True.

Generator Expression

У list comprehensions, пожалуй, есть лишь один недостаток: происходит создание полного списка элементов в памяти, а это значит, что: для больших списков у вас может просто не хватить память, либо память будет использоваться неэффективно (например, если вы создаёте список, чтобы пройти по нему в цикле всего 1 раз).

Для решения этой проблемы существуют generator expressions. Синтаксически, они очень похожи на list comprehensions, отличие лишь в используемых скобках:

    squares = (i * i for i in numbers if i % 2 == 0)

В этом случае, squares уже не будет списком чисел. Теперь это т.н. генератор (generator). Генератор реализует протокол итераторов и может быть использован в цикле for. В этом случае следующее значение generator expressions будет генерироваться на каждой итерации цикла. В данный момент времени будет существовать лишь один элемент, что значительно сокращает количество используемой памяти. Реализуется т.н. метод lazy evalution — новые значения генерируются только при необходимости, а не все одновременно.

Что почитать?

Python. Основы. Классы

2011-03-17T13:58:00.009+02:00

Класс. Экземпляр класса

Класс — это пользовательский тип данных для создания объектов (objects). Объекты класса обычно называют экземплярами этого класса (class instances). Описание класса определяет поведение (методы) всех экземпляров класса.

Everything is an object

В Python всё является объектами (т. н. first-class object). Это не значит, что у всех объектов есть методы и атрибуты. Это значит, что каждый объект может быть присвоен переменной, передан в функцию как аргумент, получен как возвращаемое значение функции и т.д. Т.е. нет никакой разницы в использовании объектов и, скажем, числа типа int (которое, на самом деле, является объектом в Python).

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

Создание нового класса осуществляется просто:

    class Employee:  # классы принято именовать с большой буквы

        def __init__(self, age):  # "специальный" метод класса
            self.age = age

        def isEligible(self):  # метод класса
            return True

Методы класса (instance methods, они же member functions в C++, class methods в Java) создаются как и обычные функции лишь за тем исключением, что первым аргументом они всегда принимают ссылку на экземпляр класса, для которого метод был вызван (как вы уже успели догадаться, известный всем this в Python объявляется явно). На самом деле вместо self могло быть использовано любое другое имя, но этого делать стоит, т.к. использование имя self является очень строгим coding convention — его игнорирование сделает ваш код менее читабельным для других программистов.

В отличии от С++ и Java в Python атрибуты экземпляра класса (instance variables, они же member variables в С++, class fields в Java) не нужно объявлять при создании класса. Python — динамический язык. Атрибуты могут иметь произвольные имена и быть добавлены к экземпляру в любое время (т. е. экземпляры одного и того же класса могут иметь различный набор атрибутов).

Метод __init__(self) не является обычным. Это "специальный метод", на что намекают символы нижнего подчёркивания по бокам (существует ещё множество таких методов, которые используются, например, для перегрузки операторов). Метод __init__(self) вызывается сразу после создания экземпляра класса и используется для задания атрибутов, которые должны иметь все экземпляры класса, т. е. очень похож на конструктор из С++ или Java.

Создание экземпляра класса происходит так же, как если бы мы вызывали функцию с именем класса (при этом передаются необходимые для __init__(self) аргументы):

    # создание класса
    class Employee:

        def __init__(self, age):
            self.age = age  # создание нового атрибута экземпляра с именем age


    # cоздание экземпляра класса 
    # (обратите внимание: метод __init__(self) требует передачи аргумента age)
    e = Employee(30)

Можно получать существующие атрибуты и добавлять новые:

    # создание экземпляра
    e = Employee(30)

    # чтение атрибута
    print e.age
    
    # создание новых атрибутов
    e.sex = 'male'
    e.salary = 2500

Вызов метода также не является чем-то необычным:

    e.isEligible()

Не смотря на то, что при объявлении метода self указывался явно, при вызове метода этого делать не нужно — интерпретатор сам подставит ссылку на экземпляр.

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

    class Employee:
    
        MAX_AGE = 80  # атрибут класса - он будет общим для всех экземпляров
        
        def __init__(self, age):
            self.age = age # атрибут экземпляра - он у каждого экземпляра свой

Либо после создания в любой момент выполнения программы:

    Employee.MAX_AGE = 90
    Employee.MIN_AGE = 20  # опять таки, атрибут доступен из всех экземпляров

Доступ к атрибутам класса осуществляется через имя класса либо через любой экземпляр класса:

    # доступ через имя класса
    print Employee.MAX_AGE

    e1 = Employee(20)
    e2 = Employee(30)

    # доступ через экземпляр
    print e1.MAX_AGE
    print e1.MAX_AGE == e2.MAX_AGE # True

Т. е. атрибуты класса очень похожи на статические члены в C++ и Java.

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

    e1 = Employee(20)
    e2 = Employee(30)
    # для 2 экземпляров атрибут класса один и тот же
    print e1.MAX_AGE == e2.MAX_AGE # True

    # создаётся атрибут экземпляра, который "прячет"
    # атрибут класса с таким же именем
    e1.MAX_AGE = 50
    # e1.MAX_AGE обращается к атрибуту экземпляра, а не класса!
    print e1.MAX_AGE == e2.MAX_AGE # False

При использовании атрибутов классов обращайтесь к ним через имя класса — это более очевидно и убережёт вас от неявных ошибок.

Есть в Python и аналог статических методов класса в C++ и Java. Если у вас есть метод, который не должен вызываться для какого-то экземпляра класса конкретно, но, тем не менее, связан с классом, вы можете сделать его статическим:

    class A:
        
        @staticmethod
        def f():
            pass

(синтаксис немного необычный — здесь используется декоратор, но объяснение принципов его работы выходит за рамки этого поста)

Данный метод отличается от обычного лишь тем, что при его вызове не будет передаваться ссылка на экземпляр объекта — self. Вызов происходит через имя класса либо через экземпляр класса:

    # вызов через имя класса
    A.f()

    # вызов через экземпляр класса
    a = A()
    a.f()

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

Наследование. Полиморфизм

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

    class Manager(Employee):
        
        def isEligible(self):     # методы могут быть переопределены в подклассах
            return self.age < 60

    class Worker(Employee): 
        
        def isEligible(self):
            return self.age < 35


    class Secretary(Employee):
        pass                      # подклассс может и не переопределять ничего

Если подкласс не определяет метод __init__(self), при инициализации экземпляра класса будет вызван соответствующий метод из суперкласса. Если же определяет, то необходимо явно вызывать метод инициализации из суперкласса:

    class Manager(Employee):
    
        def __init__(self, age, employees):
            Employee.__init__(self, age)   # обратите внимание, что указывается self
            self.employees = employees

В Python, говоря терминами С++, все методы автоматически являются виртуальными:

     m = Manager(50)
     w = Worker(40)
     s = Secretary(25)

     for e in [m, w, s]:
         print e.isEligible()

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

Что почитать?

О классах кратко:

Более сложное чтиво:

Unicode in a Nutshell

2010-10-17T14:16:00.001+03:00

Предисловие

Думаю, каждый из вас в своей жизни не раз сталкивался с проблемами, связанными с неправильным отображением текста на экране компьютера: будь то email'ы от ваших друзей, содержащие что-то вроде "оПХБЕР, ДПСФХЫЕ!" вместо "Привет, дружище!", web-страницы с повторяющимися знаками "?" вместо текста, странные символы вместо русского текста при выводе на консоль из простого Hello World, написанного на С++ и т. д. Проблемы такого рода связаны с тем, что многие программисты и сегодня не понимают, что такое Unicode и зачем он нужен.

Немного истории

Когда появились первые компьютеры, возник вопрос о представлении в них текстовой информации. Компьютер ничего не знает о символах 'j', '!', 'Б' и любых других. Компьютер не работает с символами - он работает с числами, представленными в виде последовательности байт (или одно байта).

Чтобы компьютер "понимал" символы, было предложено присвоить каждому символу свой числовой код.
Так родилась известная таблица ASCII, содержащая все буквы английского алфавита (в верхнем и нижнем регистре), знаки препинания и управляющие символы (переход на новую строку, возврат каретки и др.). Для этого понадобилось 128 различных кодов - от 0 до 127. Соответственно, для хранения кода символа нужен 1 байт, 7 бит которого используются, а старший всегда равен 0. Например, строка "HELLO" представляется в памяти как последовательность байт: 0x48 0x45 0x4C 0x4C 0x4F.

И всё было хорошо, пока в компьютерах был лишь один язык. Когда же возникла необходимость добавить поддержку других языков, появились проблемы. Решение было очевидным: использовать свободные 128 кодов байта для кодирование нового алфавита, а первые 128 взять из ASCII. Проблема была в том, что каждый хотел использовать эти 128 кодов по-разному (например для разных языков, ведь 128 кодов не хватало для хранения нескольких алфавитов). Так возникло понятие кодовых страниц (code pages - они же "кодировки"). Каждая кодовая страница позволяет представить символы таблицы ASCII, а также ещё 1-2 языка (как например KOI8-U, которая хранит коды для символов английского, русского и украинского алфавитов, управляющие символы и знаки препинания). Такие кодировки были названы 8-битными, т.к. для кодирования 1 символа использовался 1 байт.

Для того, чтобы правильно прочитать текст, нужно знать, в какой кодовой странице он представлен: байты остаются байтами и по-прежнему представляют собой одно и то же число, только это число в различных кодовых таблицах может указывать на совершенно разные символы. Отсюда вытекает важное утверждение: текст не представляет собой никакой ценности, если неизвестно, какой кодировкой он представлен(Joel Spolsky). Это просто набор байт, который может означать, в общем случае, что угодно. Поэтому если мой друг присылает мне письмо, содержащие слово "Привет" в кодировке CP-1251 (0xCF 0xF0 0xE8 0xE2 0xE5 0xF2), а кодировка моей системы KOI8-R, то я прочитаю его как: "оПХБЕР".

Пока люди работали на своих машинах и обменивались информацией сравнительно редко, с кодовыми страницами можно было мирится. С появлением Internet всё изменилось. Необходимо было новое решение, способное облегчить обмен информацией. Так возник Unicode.

Unicode

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

Во-первых, в стандарт Unicode входят символы алфавитов всех языков мира.

Во-вторых, каждому символу соответствует уникальное число, называемое Unicode code point.

В-третьих, числовое значение символа ещё не говорит, как это число представляется в памяти компьютера в виде последовательности байт.

В-четвёртых, т.к. стандарт Unicode включает в себя более 107000 символов, то 1 байта явно не хватит для представления символа. И хотя первые стандарты Unicode позиционировали систему как 16-битную "классическую" кодировку (которой бы хватало для представления 65536 символов), в настоящее время это не так. Unicode - это не 16-битная кодировка.

Отсюда следует важный вывод: мы больше не может проводить прямое соответствие между символом и его значением в виде какого-то байта, как это было в "классических" кодировках. Байты - это байты, символы - это абстракция. (Mark Pilgrim, 'Dive Into Python 3').

Каждому символу в Unicode соответствует code point. Это просто число - ни больше, ни меньше. Представлением этого code point в виде последовательности байт в памяти занимаются кодировки Unicode, такие как UTF-8, UTF-16, UTF-32 (а также менее известные UTF-1, UTF-7). Каждая из них имеет свои достоинства и недостатки, являющиеся результатом компромиссов между скоростью работы и потреблением памяти.

UTF-32

Самая простая кодировка. Представляет каждый code point любого символа Unicode в виде последовательности из 4 байт. Это означает, что любой ваш текст в "классической" кодировке, при переводе в кодировку UTF-32 станет занимать в 4 раза больше места! Не многовато ли? Естественно, это очень нерационально, поэтому никто так не делает. Для чего же тогда нужна UTF-32? UTF-32 позволяет удобно представить символы Unicode внутри компьютерной программы, упрощая и ускоряя работу со строками (размер кода каждого символа фиксирован, поэтому доступ к i-ому символу в строке выполняется со сложностью O(1), т.к. делается простой отступ по адресу).

К сожалению, у UTF-32 есть и другие недостатки. Для кодирования любого символа используются 4 байта, поэтому для символов со значениями кодов 0-127 будет записано 3 байта со значением 0. К сожалению, старый С-код предполагает работу со строками, где байт '0' означает символ конца строки - такой код не сможет работать со строками в UTF-32.

Помимо этого возникает вопрос, а как представлять 4-байтовое целое число - в формате big-endian или little-endian - должен ли символ 'А' (U+0041) быть представлен как 0x0 0x0 0x0 0x41 или же как 0x41 0x0 0x0 0x0. Оказывается, он может представляться и так, и так. Как же тогда определить, какой порядок байт используется? Для этого перед UTF-32 строкой/текстовым файлом вставляется специальный символ BOM (byte order mark) - U+FEFF. Если вместо U+FEFF был прочитан символ U+FFFE, значит данный текст закодирован в UTF-32 с другим порядком байт, и необходимо инвертировать порядок байт во всех последующих символах при чтении.

UTF-16

В UTF-16 для кодирование одного символа используется 2 байта, что позволяет закодировать 65536 первых символов Unicode из так называемой BMP - Basic Multilingual Plane. Но стандарт включает в себя около 100000 символов, как же представляются остальные? С помощью 4 байт, используя т.н. surrogate pairs. Т.е. UTF-16 не является кодировкой с фиксированным размером кода символа. UTF-16 позволяет более экономно использовать память по сравнению с UTF-32, но не лишена 2 её недостатков: порядок байт по-прежнему имеет значение, и старый код также не может работать со строками в UTF-16. Кроме того нельзя гарантировать доступ к i-ому cимволу строки со сложностью O(1), т.к. в строке могут содержаться символы, занимающие различное количество байт.

Не смотря на имеющиеся недостатки, UTF-16 широко используется, в частности для представления символов в языках C#/Java, классе QChar фреймворка Qt.

UTF-8

Кодировка UTF-8 решает проблемы своих предшественниц. При кодировании символов Unicode при помощи UTF-8 для code point'ов в промежутке [0, 127] используется 1 байт, для остальных символов - 2, 3 либо 4 байта по мере увеличения значения code point. Это означает, что:

Текст, закодированный в ASCII, является также текстом, закодированным в UTF-8.
Наиболее эффективно используется память. Для английского алфавита, управляющих символов и знаков препинания - не хуже чем ASCII (или любая другая 8-битная кодировка), для остальных - на равне с UTF-16 либо лучше.
Старый код работает со строками в UTF-8.
Порядок байт не имеет значения - текст всегда будет прочитан правильно.

К сожалению, т.к. UTF-8 является кодировкой с переменной длиной кода символа, это означает, что доступ к i-ому элементу строки производится со сложностью O(n).

Выводы

Unicode - не 16-битная кодировка.
Символы - это абстракция, компьютеры работают с байтами - не с символами.
Кодировка - это отображение(таблица соответствия, map) символа его представлению в виде последовательности байт(либо одного байта в случае использования 8-битной кодировки, например, ASCII или CP-1251).
Стандарт Unicode ставит каждому символу любого алфавита мира в соответствие уникальное число, называемое code point.
Представлением code point в виде последовательности байт занимаются кодировки Unicode: UTF-8, UTF-16, UTF-32, каждая из которых имеет свои достоинства и недостатки.
UTF-16/UTF-32 более эффективны с точки зрения скорости обработки символов - они используются для внутрипрограммного представления символов Unicode.
UTF-8 более эффективна с точки зрения количества используемой памяти, возможности работы со старым кодом, отсутствия проблем с порядком байт. Она используется для хранения текстовой информации и передачи её между различными компьютерами.
Текст не представляет собой ценности, если неизвестно, в какой кодировке он представлен.

Использованная литература

C++. Преобразование числа в строку

2010-10-07T01:19:00.001+03:00

Часто возникает необходимость иметь представление числа в виде строки (например, если есть функция, которая выводит заданную строку на экран, и нужно вывести число). Обычно для этого используют С-шные фунции snprintf(wsnprintf) или, что ещё хуже, sprintf(wsprintf). Это очень неудобно по нескольким причинам:

Нужно знать, сколько памяти необходимо выделить (пусть даже в виде массива char/wchar_t на стеке).
Для разных числовых типов данных необходимо применять различные спецификаторы.
Нужно помнить формат спецификаторов.

В С++ есть красивое решение с использованием строковых потоков, которое я подсмотрел у Строуструпа:

std::stringstream s;
int a = 42;

s << a;
std::string str = s.str();

Для получения С-строки можно просто вызвать метод c_str() класса std::string. Для wchar_t применяются классы std::wstringstream и std::wstring соответственно. При необходимости можно перегрузить оператор << для своего класса и преобразовывать какие-либо данные в строку таким же образом.

Writing C-code in Python

2010-08-01T11:37:00.000+03:00

В настоящее время всё больше программистов выбирают Python в качестве 2/3/etc языка для изучения. Их "родными" языками обычно являются C/C++/Java/C#. Имея за плечами определённый опыт программирования на любом из этих языков, освоение нового языка не кажется сложной задачей.
Алгоритмические конструкции в большинстве современных языков достаточно похожи, остаётся лишь "привыкнуть" к новому синтаксису. К сожалению, не всё так просто.

Язык программирования - это не просто синтаксис, а ещё и набор определённых подходов, особенностей, методов решения практических задач. И далеко не всегда, методы, которые хорошо работают в привычном для вас языке, будут так же работать в другом языке, который вы хотите изучить. Именно опыт работы с каким-либо из языков программирования может сыграть с вами злую шутку при изучении Python.

Код на Python призван быть лаконичным и читабельным. Для достижения данных целей используются различные особенности синтаксиса языка (принудительные отступы вместо привычных фигурных скобок, etc). К сожалению, программисты на других языках часто осваивают лишь синтаксис Python, забывая о необходимости ознакомления со всеми этими особенностями. А потом они начинают писать ужасный код. И хотя это код является рабочим, его точно нельзя охарактеризовать как pythonic.

Я бы хотел выделить наиболее часто допускаемые ошибки:

Циклы for

Неправильно:
```
nums = [1, 2, 3]
for i in range(len(nums)):
    print nums[i]
```
```
msg = 'hello'
for i in range(len(msg)):
    print msg[i]
```
Правильно:
```
nums = [1, 2, 3]
for i in nums:
    print i
```
```
msg = 'hello'
for c in msg:
    print c
```
Мораль:
В Python для доступа к элементам списков и строк используются итераторы (справедливо и для словарей, множеств, кортежей и др.). При прохождении по всем элементам контейнера нет необходимости в использовании индексной выборки.

Проверка списка(строки, словаря, etc) на пустоту

Неправильно:

nums = []
if len(nums) == 0:
    print 'The list is empty!'

str = ''
if len(str) == 0:
    print 'The string is empty!'

Правильно:

nums = []
if not nums:
    print 'The list is empty!'

str = ''
if not str:
    print 'The string is empty!'

Мораль:
Не нужно загрязнять код проверками длины. Каждый "объект-контейнер" (если можно так сказать), является False (при проверке в условном операторе if), если он пуст, True - если не пуст.

Проверка вхождения элемента в список
Неправильно:

nums = [1, 2, 3]
for i in nums:
    if i == 2:
        print 'Found!'
        break

info = {'server': '127.0.0.1', 'port': 80}
for key in info.keys():
    if key == 'port':
        # do something

Правильно:

nums = [1, 2, 3]
if 2 in nums:
    print 'Found!'

info = {'server': '127.0.0.1', 'port': 80}
if key in info:
    # do something

Мораль:
Для проверки вхождения элемента в "контейнер"(строку, список, кортеж, множество, словарь, пользовательские типы) используется оператор in: лаконично, удобно, просто, быстро.

Multiple assignment
Неправильно:

a = 1
b = 2

# swap values of variables a and b
temp = a
a = b      # 2
b = temp   # 1

SUNDAY  = 0
MONDAY  = 1
TUESDAY = 2
# ...

Правильно:

a = 1
b = 2

# swap values of variables a and b
a, b = b, a

SUNDAY, MONDAY, TUESDAY, WEDNESDAY, \
THURSDAY, FRIDAY, SATURDAY = range(7)

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

Стандартная библиотека

Неправильно:

dir = '/home/user/'
name = '1.txt'

with open(dir + name) as f:
    # do something

nums = [1, 2, 3]
allGreatherThanZero = True

for num in nums:
    if num <= 0:
        allGreatherThanZero = False
        break

if allGreatherThanZero:
    # do something

nums = [1, 2, 3]

sum = 0
for num in nums:
    sum += num

print sum

nums = [1, 2, 3]

min = nums[0]
for num in nums[1:]:
    if num < min:
        min = num

print min

Правильно:

import os

dir = '/home/user/'
name = '1.txt'

with open(os.path.join(dir, name)) as f:
    # do something

nums = [1, 2, 3]

if all(num > 0 for num in nums):
    # do something

nums = [1, 2, 3]

print sum(nums)

nums = [1, 2, 3]

print min(nums)

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

Преобразование списка в строку

Неправильно:

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

str = 'RGB stands for '
for color in colors:
    str += ', ' + color

Правильно:

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

str = 'RGB stands for ' + ', '.join(colors)

Мораль:
Использование метода join делает код более читабельным и лаконичным, к томе же работает такой код быстрее, чем при использовании конкатенации строк.

List comprehensions
Неправильно:

nums = [1, 2, 3, 4, 5]

squares = []
for num in nums:
    squares.append(num ** 2)

import os
import glob

extensions = ['.mp3', '.ogg']

fileList = glob.glob('*.*')

audio = []
for f in fileList:
    if os.path.splitext(f)[1] in extensions:
        audio.append(os.path.join(os.getcwd(), f))

Правильно:

nums = [1, 2, 3, 4, 5]

squares = [num ** 2 for num in nums]

import os
import glob

extensions = ['.mp3', '.ogg']

fileList = glob.glob('*.*')

audio = [os.path.join(os.getcwd(), f)
         for f in fileList 
         if os.path.splitext(f)[1] in extensions]

Мораль:
List comprehensions - ещё одна из синтаксических особенностей Python, позволяющая сделать код более читабельным и оптимальным.

Изучая новый язык, постарайтесь не перетягивать сюда свои вредные привычки из других языков программирования. Потратьте время на освоение новых подходов и методов решения задач. Нужно не просто перейти на использование нового синтаксиса, а "приобщиться к культуре" языка. Приложив необходимые усилия вы начнёте писать код, который действительно можно будет назвать pythonic.
Следует почитать:

Students Coffee & Code #2. Unicode

2010-02-14T20:57:00.001+02:00

Сегодня провели ещё один SC&C - выкладываю свою презентацию по Unicode и примеры. Может когда-нибудь напишу полноценную статью. Критика и предложения приветствуются.

P.S. В презентации всего не объяснишь - обязательно прочитайте статью Joel'a Spolsky по ссылке в конце.

slides: http://docs.google.com/present/edit?id=0Ac4bqn8_YtynZGZncjc3N18xM2c3YmJjZ2hw&hl=en
code: http://gitorious.org/amd4ever/my-git/trees/master/coffee/unicode

Blog updates

2010-02-10T09:38:00.002+02:00

Решил немного обновить блог:

Перевёл его на новый домен: http://www.amd4ever.org.ua
Удалил почти все старые посты. Почему? Во-первых, там практически не было полезной информации. Во-вторых, практически все ссылки на код были либо на showmecode.com(который приказал долго жить), либо на мой старый git, в-третьих - там было много откровенно плохого и бесполезного кода.

В ближайшее время планирую написать о чём-нибудь полезном (в частности о Unicode и LaTeX), а также о своих программах, имеющих хоть какую-нибудь практическую ценность.

Just for fun

2009-06-24T20:19:00.001+03:00

Первый год обучения в университете получился очень интересным и необычным. Во-первых, я безумно рад что выбрал именно ХНУРЭ, а не НАУ или ДонНТУ. Почему? Потому что только у нас есть такие интересные вещи как CET и такие люди как: Zoresvit, Владимир Обризан, Макс Давыдов, Сергей Зайченко, Александр Адамов и многие-многие другие. Общаться с ними очень интересно, а гланое - полезно. А курсы CET - прогрессивная модель получения высшего образования.

Я хотел выделить наиболее интересные вещи, с которыми столкнулся в этом году:
1. С++. Да, я раньше изучал С, но это совершенно другой язык, чтобы там не говорили =). По правде говоря, мне долгое время больше нравился именно С, пока не начались курсы Зайченко, на которых он показал нам истинную красоту С++ =)
2. Parallel Programming: OpenMP,PThreads, TBB. В век многоядерных процессоров без этого никуда. Спасибо Владимиру Обризану за его курс по многоядерному программированию и оптимизации ПО!
3. Python. Я рекомендую обратить ваше внимание на этот интересный язык программирования, позволяющий решать определённые задачи действительно просто и красиво. В Интернете доступна хорошая книга по Python для программистов на других языках - Dive into Python.
4. LaTeX - система подготовки документов. О LaTeX можно почитать здесь. Есть учебный курс здесь.
5. QT - воопреки существующим заблуждениям, QT - это не только библиотека для GUI, но и мощный фреймворк для создания пользовательских приложений.

Заканчивается сессия и наконец-то появится время для их изучения =).