list

#
 
from pprint import pprint
pprint(list(primer))
 
 
# just think .whatever((s, p, o))
# here we report on what we know
 
pprint(list(primer.subjects()))
pprint(list(primer.predicates()))
pprint(list(primer.objects()))

# and other things that make sense
 
# what do we know about pat?
pprint(list(primer.predicate_objects(myNS.pat)))
 
# who is what age?
pprint(list(primer.subject_objects(myNS.age)))

 
# for more insight into things already done, lets see the namespaces
 
list(primer.namespaces())
 
# lets ask something about the data
 
list(primer.objects(myNS.pat, myNS.child))

                d = dist_point_to_segment(p, s0, s1)
                if d<=self.epsilon:
                    self.poly.xy = array(
                        list(self.poly.xy[:i]) +
                        [(event.xdata, event.ydata)] +
                        list(self.poly.xy[i:]))
                    self.line.set_data(zip(*self.poly.xy))

    def test_frozen_as_dictkey(self):
        seq = range(10) + list('abcdefg') + ['apple']
        key1 = self.thetype(seq)
        key2 = self.thetype(reversed(seq))
        self.assertEqual(key1, key2)
        #self.assertNotEqual(id(key1), id(key2))
        d = {}

    def test_copy(self):
        dup = self.set.copy()
        dup_list = list(dup); dup_list.sort()
        set_list = list(self.set); set_list.sort()
        self.assertEqual(len(dup_list), len(set_list))
        for i in range(len(dup_list)):
            self.failUnless(dup_list[i] is set_list[i])
 
    def test_deep_copy(self):
        dup = copy.deepcopy(self.set)
        ##print type(dup), repr(dup)
        dup_list = list(dup); dup_list.sort()
        set_list = list(self.set); set_list.sort()

                for g in (G, I, Ig, S, R):
                    s = set('january')
                    t = s.copy()
                    getattr(s, methname)(list(g(data)))
                    getattr(t, methname)(g(data))
                    self.assertEqual(sorted(s), sorted(t))
 

                FG = lambdify( [x,y], [dx,dy,dz] )
                iu.v_steps /= 5
                iv.v_steps /= 5
                Gvl = list(list([FF(u, v), FG(u, v)]
                        for v in iv.frange())
                        for u in iu.frange())
 

            objects.append(product)
            for subtype in product.get_subtypes():
                objects.append(getattr(product,subtype.lower()))
            objects.extend(list(product.price_set.all()))
            objects.extend(list(product.productimage_set.all()))
            if include_images:
                for image in product.productimage_set.all():

        if include_categories:
            for category in categories.keys():
                objects.append(category)
                objects.extend(list(category.translations.all()))
                if include_images:
                    for image in category.images.all():
                        objects.append(image)
                        objects.extend(list(image.translations.all()))

    del v
    d[s] = 0
    S = []
    Q = list(G.V)
 
 
    while Q:
        u = Extract_Min(Q, d)

  def get(self):
    self.response.out.write(
        template.render('names.html', {
            'first_users': list(FirstUserKind.all()),
            'second_users': list(SecondUserKind.all()),
        }))
 

  def get(self):
    self.response.out.write(
        template.render('counters.html', {
          'counters': list(Counter.all())
        }))
 
  def post(self):

# (return only key and value tokens, and construct dict from key-value pairs)
# - empty ahead of restOfLine advances past leading whitespace, does implicit lstrip during parsing
macroDef = Suppress("#define") + ident + Suppress("=") + empty + restOfLine
macros = dict(list(macroDef.searchString(testData)))
print "macros =", macros
print
 

# (return only key and value tokens, and construct dict from key-value pairs)
# - empty ahead of restOfLine advances past leading whitespace, does implicit lstrip during parsing
macroDef = Suppress("#define") + ident + Suppress("=") + empty + restOfLine
macros = dict(list(macroDef.searchString(testData)))
print "macros =", macros
print
 

integer = Word(nums).setParseAction(lambda t:int(t[0]))
int4 = Group(Word(nums,exact=4).setParseAction(lambda t: [int(t[0][:2]),int(t[0][2:])] ))
qty = integer | couple | a_qty
dayName = oneOf( list(calendar.day_name) )
 
dayOffset = (qty("qty") + (week | day)("timeunit"))
dayFwdBack = (from_ + now.suppress() | ago)("dir")