from random import choice as rc

class Cards:
    def __init__(self, rank, suit):
        rank = (1,2,3,4,5,6,7,8,9,10,11,12,13)
        suit = ("Diamonds","Clubs","Hearts","Spades")
        
    def getRank(self):
        self.rank = rc(self.rank)
        return self.rank
    def getSuit(self):
        self.suit = rc(self.suit)
        return self.suit
    
def main():
    rank1 = getRank()
    print rank1
    suit1 = getSuit()
    print suit1



main()

Balam fucked around with this message at 16:44 on Jun 13, 2009

import random

class Cards:
	"""Represents a deck of cards.
	
	This class allows you to make a deck
	that can remove cards, shuffle cards,
	and insert cards."""

	def __init__(self, ranks=None, suits=None):
		"""makes one deck of cards, in order"""
		self.ranks = list(range(1,14)) if ranks is None else list(ranks)
		
		self.suits = ["Diamonds","Clubs","Hearts","Spades"] if suits is None else list(suits)
		self.cards = [(suit, rank) for suit in self.suits for rank in self.ranks]

	def shuffle(self):
		"""shuffles remaining cards"""
		random.shuffle(self.cards)

	def remove_card(self):
		"""remove the 'top' card. 'Top' in this case is the last thing
		in the list but only we need to know that. 
		Pops last card from cards"""
		return self.cards.pop()

	def insert_card(self, card, index=0):
		"""place the card at the given index. Defaults to the 'bottom'
		of the deck."""
		self.cards.insert(index, card)
	
def main():
	#get a new deck
	c = Cards()
	print 'This is the starting deck:'
	print c.cards
	c.shuffle()
	print
	print 'shuffled deck:'
	print c.cards

	print

	print 'here is a card from the "top" of the deck:'
	card = c.remove_card()
	print card

	print 'putting card back into deck, now its at the "bottom"'
	c.insert_card(card)
	
	print
	print c.cards

if __name__ == '__main__':
	#called only when run as the starting module
	main()

hlfrk414 fucked around with this message at 00:32 on Jun 14, 2009

#!/bin/env python

import sys, re
from os import popen
from optparse import OptionParser

class Process(object):
    def __init__(self, pid, ppid, etime, cmd):
        self.pid = pid
        self.ppid = ppid
        self.etime = etime
        self.cmd = cmd

class JavaProcess(Process):
    def __init__(self, pid, ppid, etime, cmd):
        super(JavaProcess, self).__init__(pid, ppid, etime, cmd)

        for key, string in [('instance','weblogic.Name=(.*?) '), ('jvm','/opt/bea/(.*?)/bin/java'), ('weblogic','wls.home=/opt/bea/(.*?)/server')]:
            temp = re.compile(string).findall(self.cmd)
            if temp:
                setattr(self, key, temp[0])
            else:
                setattr(self, key, '-')


class ProcessList(dict):
    def __init__(self):
        self.refresh()
        print self

    def refresh(self, top=True):
        self = {}

        #do a `ps` and turn output lines into processes
        ps = popen('ps axww -o "pid ppid etime args" | grep java | grep -v grep','r').read()
        ps = ps.split('\n')[:-1]

        for line in ps:
            pid, ppid, etime, cmd = line.split()[:3] + [' '.join(line.split()[3:])]
            self[pid] = JavaProcess(pid, ppid, etime, cmd)

        #get cpu and memory usage data from `top`
        if top:
            top_output = popen('top bn1 | grep java','r').read()
            top_output = top_output.split('\n')[:-1]

            for line in top_output:
                line = line.lstrip().rstrip().split()
                if self.has_key(line[0]):
                    setattr(self[line[0]], 'tcpu', line[8])
                    setattr(self[line[0]], 'tmem', line[9])

        #determine whether or not a pid is a parent process
        #only matters when java threads are shown as individual processes
        def _setParent(pid):
            if self[pid].ppid in self.keys():
                _setParent(self[pid].ppid)
                setattr(self[pid], 'parent', False)
            else:
                setattr(self[pid], 'parent', True)

        for pid in self.keys():
            _setParent(pid)


def main(argv=sys.argv[1:]):
    parser = OptionParser(usage="usage: %prog [options] <list of instances or pids>", version="%prog 2.0")
    parser.add_option('-a', '--all', action='store_true', default=False, dest='all', help='show all pids, displays threads and child processes')
    parser.add_option('-p', '--pipe', action='store_true', default=False, dest='pipe', help='display output in pipe-delimited format')
    options, arguments = parser.parse_args(argv)

    process_list = ProcessList()

    if options.pipe:
        lineout = '%(pid)s|%(etime)s|%(tcpu)s|%(tmem)s|%(instance)s'
    else:
        print 'PID     Uptime       %CPU %MEM Instance                              '
        print '------- ------------ ---- ---- --------------------------------------'
        lineout = '%(pid)-7s %(etime)12s %(tcpu)4s %(tmem)4s %(instance)-38s'

    for p in process_list:
        if options.all:
            print lineout % process_list[p]
        elif p.parent:
            print lineout % process_list[p]


if __name__=='__main__':
    main()

deedee megadoodoo fucked around with this message at 17:12 on Jun 14, 2009