Архив рубрики: Python

MongoDB базовые функции под python ( pymongo )

MongoDB — документо-ориентированная система управления базами данных (СУБД) с открытым исходным кодом, не требующая описания схемы таблиц.

# coding: utf8

import pymongo

from pymongo import Connection
connection = Connection()

# Удалить БД, если она существует
connection.drop_database("test_database")

# Выбираем БД
db = connection.test_database
# либо: db = connection["test_database"]

# Удалить коллекцию
db.drop_collection('users')

# Добавление документов в колекцию 'users'
db.users.save( { 'name':'user 1', 'level':1 } )
db.users.save( { 'name':'user 2', 'level':2 } )
db.users.insert( { 'name':'user 3', 'level':3 } )

# Полное имя колекции
print db.users.full_name

# Получить все документы
for user in db.users.find():
print user

# Выбрать конкретные атрибуты
users = db.users.find({},{ 'login':1, 'name':1 })

# Получить один документ по условию
user = db.users.find_one({'name':'user 1'})

# Получить/установить значение
print user['level']
user['level'] = 7

# Сохранить документ
db.users.save(user)

# Удалить документ
db.users.remove(user)

# Установить значение в документе
db.users.update({ 'name':'user 2' }, { "$set": { 'level':5 } })

# Кол-во документов
print 'Count',db.users.count()
print 'Count lvl=2',db.users.find({'level':2}).count()

# Сортировка
for user in db.users.find().sort('level'):
print user
# в обратном порядке: .sort('level',pymongo.DESCENDING)
# Сортировка по нескольким атрибутам
db.users.find({}).sort( [('status',1),('level',-< span class="mi">1)] )

# Ограничение выборки, пропустить один документ и выбрать не более двух
for user in db.users.find().skip(1).limit(2):
print user

# Условия
for user in db.users.find().where('this.name == "user 2" || this.level>3'):
print user

# Выбрать неповторяющиеся записи
for user in db.users.distinct('level'):
print user

# Поиск регулярным выражением
import re
regex = re.compile('^us', re.I | re.U)
result = db.collection.find({ 'name':regex })

Автор: D1VER
Дата публикации: 2013-12-16T05:15:00.002-08:00

Python полезности для игры Астероид

Выход за границы области экрана
>>> self.pos[0] = (self.pos[0] + self.vel[0]) % WIDTH
>>> self.pos[1] = (self.pos[1] + self.vel[1]) % HEIGHT
pos — координаты центра движущейся фигуры

Увеличение скорости астероидов в зависимости от счета score
# increase rock's velocity using score
for rock in rock_group:
    for i in range(2):
        rock.vel[i] = rock.init_vel[i] + (rock.init_vel[i] * score * 0.03)
или
rock_vel[i] = rock_vel[i] * (1 + score / 3)

Столкновение спрайтов (p q — координаты центров сталкивающихся спрайтов, dist — расчет дистанции между спрайтами)
def dist(p, q):
    return math.sqrt((p[0] — q[0]) ** 2 + (p[1] — q[1]) ** 2) 

def collide(self, other_object):
        return dist(self.pos, other_object.pos) <= self.radius + other_object.radius

Автор: Viktor

Python преобразовать список из [1, [2, 3], 4] в [1, 2, 3, 4]

Задача: преобразовать список из такого типа [1, [2, 3], 4]   в    [1, 2, 3, 4]

check_lst = [[[2]], [4, [5, 6, [6], 6, 6, 6]]]

def check(lst):
    check_bool = True
    out_lst = []
    copy_lst = list(lst)
    while check_bool:
        check_bool = False
        for i in copy_lst:            
            if isinstance(i, list):
                check_bool = True
                out_lst.extend(i)
            else:
                out_lst.append(i)
        if check_bool:
            copy_lst = list(out_lst)
            out_lst = []            
    return out_lst

print check(check_lst)

[2, 4, 5, 6, 6, 6, 6, 6]

Лучшее решение


def check(lst):
    'convert all elements in lst in one row'
    return sum(map(lambda a: check(a) if isinstance(a,(list)) else [a],lst),[])

Автор: Viktor

Python использование set с классом

Задача: создадим класс, создадим пустой set. Заполним set экземплярами созданного класса. Для примера пусть экземпляры будут случайным целым числом из диапазона 0-9. Теперь мы хотим удалить из set-а все экземпляры класса значения которых совпадают с «9» и «8»

Где это можно применить на практике? В gamedeveloping игра «Астероид», в set добавляем все летающие по экрану камни, пробегаемся по set-у и сверяем дистанцию между кораблем и камнями:
для этого вычисляем дистанцию между координатами центров фигур
>>> def dist(p, q):
>>>     return math.sqrt((p[0] — q[0]) ** 2 + (p[1] — q[1]) ** 2)
и вычитаем радиус корабля и радиус камня, если получившееся значение <= 0 значит столкновение, то добавляем экземпляр класса камень во временный set. После окончания обхода set-а с камнями - удаляем из этого set-а временный set (один или более камней при столкновении) и уменьшаем счетчик жизней кораблю.
>>> import random

>>> class A:
>>>     def __init__(self, a):
>>>         self.a = a
>>>     def __str__(self):
>>>         return («%s») % self.a
        
>>> st = set()
>>> for i in range(10):
>>>     st.add(A(random.randrange(0, 10)))

>>> print [str(x) for x in st]

['6', '5', '3', '8', '4', '9', '2', '9', '9', '8']

>>> temp = set()
>>> for x in st:
>>>     if str(x) == '9' or str(x) == '8':
>>>         temp.add(x)

>>> print [str(x) for x in temp]

['8', '9', '9', '9', '8']

>>> st.difference_update(temp)
>>> print [str(x) for x in st]

['6', '5', '3', '4', '2']

Автор: Viktor

Подчеркнутая защищенность

Инкапсуляция — одна из основ ООП. Мы договариваемся использовать только часть функциональности класса, а взамен получаем возможность работать с самыми разными типами, даже с теми, которые будут написаны после окончания работы над текущим кодом.

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

Попадая в питон С++/Java-программисты начинают искать замену родным private/protected в этом мире безудержного эксгибиционизма. И, как правило, быстро находят два подчеркивания. Не совсем то, что хотелось бы, но довольно сильно похоже на private. В итоге нижнее подчеркивание быстро становится самым популярным символом в коде.

Я попробую показать, что:

  • '__' — не эквивалент private и решает совсем другие задачи;
  • Можно отлично жить без private/protected/friend. Оружие массового запрещения не единственный способ реализовать инкапсуляцию;
  • При желании можно написать аналог private/protected и даже более гибкий контроль доступа для python (в следующем посте)

Итак зачем в python поля с двумя подчеркиваниями в начале имени. Пусть у нас есть такой код:

Без подсветки синтаксиса

from some_module import SomeClass

class SomeClassChildren(SomeClass):
def __init__(self):
super(SomeClassChildren, self).__init__()
self.some_field = 12

from some_module import SomeClass

class SomeClassChildren(SomeClass):
def __init__(self):
super(SomeClassChildren, self).__init__()
self.some_field = 12

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

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

Без подсветки синтаксиса

import dis

class A(object):
def func(self, x):
self.__attr1

class B(A):
def func(self, x):
self.__attr2

class C(A):
def func(self, x):
class C1(object):
def func(self):
x.__attr3

dis.dis(C1.func)

def r(self):
self.__attr4

class D(object):
func = r

dis.dis(A.func)
dis.dis(B.func)
C().func(A())
dis.dis(D.func)
dis.dis(lambda: A.__attr5)

import dis

class A(object):
def func(self, x):
self.__attr1

class B(A):
def func(self, x):
self.__attr2

class C(A):
def func(self, x):
class C1(object):
def func(self):
x.__attr3

dis.dis(C1.func)

def r(self):
self.__attr4

class D(object):
func = r

dis.dis(A.func)
dis.dis(B.func)
C().func(A())
dis.dis(D.func)
dis.dis(lambda: A.__attr5)

    # dis.dis(A.func)
0 LOAD_FAST 0 (self) << object
3 LOAD_ATTR 0 (_A__attr1) << attribute name
# == self._A__attr1

# dis.dis(B.func)
0 LOAD_FAST 0 (self)
3 LOAD_ATTR 0 (_B__attr2)

# dis.dis(C1.func)
0 LOAD_DEREF 0 (x)
3 LOAD_ATTR 0 (_C1__attr3)

# dis.dis(D.func)
0 LOAD_FAST 0 (self)
3 LOAD_ATTR 0 (__attr4)

# dis.dis(lambda: A.__attr5)
0 LOAD_GLOBAL 0 (A)
3 LOAD_ATTR 1 (__attr5)

Итого '__' приводит к переименованию поля и позволяет использовать поля с одинаковыми именами в разных классах одной иерархии. Но это не мешает добраться до такого поля, например x._X__some_priv_field. BTW — если нужно сделать действительно скрытое поле, то можно и так:

Без подсветки синтаксиса

class MyProxy(object):
def __init__(self, proxifyed):
self.__dict__[self] = proxifyed # <<<

def __getattr__(self, name):
return getattr(self.__dict__[self], name)

class MyProxy(object):
def __init__(self, proxifyed):
self.__dict__[self] = proxifyed # <<<

def __getattr__(self, name):
return getattr(self.__dict__[self], name)

self.__dict__ — обычный словарь и ключами в нем могут быть не только строки. Злоупотреблять таким хаком не стоит поскольку много различных библиотек, например сериализаторы, сильно удивятся увидев в __dict__ нестроковой ключ.

Итак: '__' — это очень специфический аналог частного поля и он предназначен для несколько других целей.

Модификаторы доступа защищают программиста от случайного и преднамеренного доступа к тем частям API, которые разработчик класса захотел скрыть.

Начнем со случайного доступа на примере С++. Случайно в нем можно вызвать:

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

Последний пункт скорее из области фантастики. Все остальные тоже не применимы к питону. Питон не копирует объекты, все всегда передается и хранится по ссылке, deepcopy/loads не вызывают конструктор. Деструктор вызывается непонятно когда и чаще всего его вызов сложно контролировать. Доступ к имеющиеся преобразования типов бессмысленно запрещать (__str__, __int__). Так что операции, выполняемые питоном без явного указания программиста не особо нуждаются в разграничении доступа.

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

Перейдем к преднамеренному вызову защищенного метода. Если очень хочется, то никакой private/protected не остановит:

    #define protected public
#include "foo.h"
#undef protected

Есть еще 666 способов добраться до защищенного метода. Есть они и в Java (reflections) и в C#, иначе контей

Инвайт для сайта по изучению языка Python

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

Автор: Viktor