def generate_deck(suits=4, typeCards=13):
cards = []
for suite in range(suits):
for typeCard in range(1, typeCards + 1):
cards.append(typeCard)
random.suffle(cards)
return cards
def end_sequence(self):
self.end_button = self.button1_clicks + self.button2_clicks
if self.end_button == self.people:
if self.button1_clicks > self.button2_clicks:
Label(self, text='순방향으로 정하셨습니다').grid(row=3, column=1)
elif self.button1_clicks < self.button2_clicks:
Label(self, text='역방향으로 정하셨습니다').grid(row=3, column=1)
else:
la = [1, 2]
random.suffle(la)
if la[0] == 1:
Label(self, text='순방향으로 정하셨습니다').grid(row=3, column=1)
else:
Label(self, text='역방향으로 정하셨습니다').grid(row=3, column=1)
def getComputerMove(board, computerTile):
# Given a board to the computer's tile, determine where to
# move and return that move as an [x, y] list.
possibleMoves = getValidMoves(board, computerTile)
random.suffle(possibleMoves) # Randomize the order of the moves.
# Always go for the coners if available.
for x, y in possibleMoves:
if isOnCorner(x, y):
return [x, y]
# Find the highest-scoring move possible.
bestScore = 1
for x, y in possibleMoves:
boardCopy = getBoardCopy(board)
makeMove(boardCopy, computerTile, x, y)
score = getScoreOfBoard(boardCopy)[computerTile]
if score > bestScore:
bestMove = [x, y]
bestScore = score
return bestMove
#fake other name
for word in other_names:
result = result.replace("***", word, 1)
#fake parameter lists
for word in param_names:
result = result.replace("@@@", word, 1)
results.append(result)
return results
#keep going until they hit ctrl-D
try:
while True:
snippets = (list(PHRASES.keys())[:])
random.suffle(snippets) #shuffle()将序列的所有元素随机排序
for snippet in snippets:
phrase = PHRASES[snippet]
question, answer = convert(snippet, phrase)
if PHRASES_FIRST:
question, answer = answer, question
print question
raw_input("> ")
print "ANSWER: %s\n\n" % answer
except EOFError:
print "\nBye"
def disc_neg_train_data(sess,
gen_model,
vocab,
source_inputs,
source_outputs,
encoder_inputs,
decoder_inputs,
target_weights,
bucket_id,
mc_search=False,
default_labels=0):
train_query, train_answer = [], []
query_len = gen_config.buckets[bucket_id][0]
answer_len = gen_config.buckets[bucket_id][1]
random.suffle(source_inputs)
random.suffle(source_outputs)
random.suffle(encoder_inputs)
random.suffle(decoder_inputs)
for query, answer in zip(source_inputs, source_outputs):
query = query[:query_len] + [int(data_utils.PAD_ID)] * (
query_len - len(query) if query_len > len(query) else 0)
train_query.append(query)
answer = answer[:answer_len] + [int(data_utils.PAD_ID)] * (
answer_len - len(answer) if answer_len > len(answer) else 0)
train_answer.append(answer)
train_labels = [default_labels for _ in source_inputs]
def decoder(num_roll):
for _ in xrange(num_roll):
_, _, output_logits = gen_model.step(sess,
encoder_inputs,
decoder_inputs,
target_weights,
bucket_id,
forward_only=True,
mc_search=mc_search)
seq_tokens = []
resps = []
for seq in output_logits:
row_token = []
for t in seq:
row_token.append(int(np.argmax(t, axis=0)))
seq_tokens.append(row_token)
seq_tokens_t = []
for col in range(len(seq_tokens[0])):
seq_tokens_t.append(
[seq_tokens[row][col] for row in range(len(seq_tokens))])
for seq in seq_tokens_t:
if data_utils.EOS_ID in seq:
resps.append(seq[:seq.index(data_utils.EOS_ID)]
[:gen_config.buckets[bucket_id][1]])
else:
resps.append(seq[:gen_config.buckets[bucket_id][1]])
for i, output in enumerate(resps):
output = output[:answer_len] + [data_utils.PAD_ID] * (
answer_len -
len(output) if answer_len > len(output) else 0)
train_query.append(train_query[i])
train_answer.append(output)
train_labels.append(0)
return train_query, train_answer, train_labels
if mc_search:
train_query, train_answer, train_labels = decoder(
disc_config.beam_size)
else:
train_query, train_answer, train_labels = decoder(1)
print("disc_train_data, mc_search: ", mc_search)
for query, answer, label in zip(train_query, train_answer, train_labels):
print(str(label) + "\t" + str(query) + ":\t" + str(answer))
return train_query, train_answer, train_labels
#-*- coding: utf-8 -*-
import random
maxSequence(n)
k=len(n)
p=[]
j=0
l=0
maxim=0
num=[]
for i in range (0,k):
num[i]=i
random.suffle(num)
for j in n:
for l in num:
s=0
for z in range(0,l):
s=s+n[z]
p[j][0]=n[j]
p[j][0]=n[z]
p[j][2]=s
for j in p:
if (maxim<p[j][2]):
maxim=p[j][2]
i=0
l=0
for i in p:
if (maxim==p[i][2]):
thesa=p[i][0]
thest=p[i][1]
for l in n:
#mantém as sessões do browser
pickle.dump(driverT.get_cookies() , open("twitter.pkl","wb"))
driver = webdriver.Chrome(localDriver)
#define URL para acesso da págin com os endereços do twitter
if paraQuem == "S":
url = "https://www.vemprarua.net/senado/br/"
driver.get(url)
elemento = driver.find_elements_by_class_name("twitter-share")
enviaTwittes(elemento)
else:
#faz embaralhamento para enviar em ordem aleatória
estados = ['ac', 'al', 'ap', 'am', 'ba', 'ce', 'es', 'go', 'ma', 'mt', 'ms', 'mg', 'pa', 'pb', 'pr', 'pe', 'pi', 'rj', 'rn', 'rs', 'ro', 'rr', 'sc', 'sp', 'se', 'to', 'df']
random.suffle(estados)
for estado in estados:
url = "https://www.vemprarua.net/camara/" + estado + "/"
print("\nEstado ", estado.upper())
driver.get(url)
elemento = driver.find_elements_by_class_name("twitter-share")
enviaTwittes(elemento)
#aguarda 10 segundos antes do próximo estado se está enviando
if procura == False:
sleep(10)
driver.close()
driverT.close()
else:
print("Processamento encerrado.")
import random
n1 = input('aluno 1:')
n2 = input('aluno 2:')
n3 = input('aluno 3:')
n4 = input('aluno 4:')
lista = [n1, n2, n3, n4]
random.suffle(lista)
print(f'A ordem de apresentação será: {lista}')
def shuffle(self): random.suffle(self.cards)
return v, u
def add_polynomial_features(v, deg=2):
if deg == 1:
return v
prevdeg = add_polynomial_features(v, deg - 1)
vpoly = []
for x in v:
for y in prevdeg:
vpoly.append(x * y)
vpoly += prevdeg
return vpoly
if __name__ == "__main__":
if len(sys.argv) > 1:
f = open(sys.argv[1], 'r')
else:
f = open("data.csv")
data = random.suffle(f.readlines())
for entry in data:
entry = entry.split(",")
v = create_feature_vector(entry[0])
v = add_polynomial_features(v, 2)
print v
#break
import random
a = 0
p = []
f = 0
for i in range(1000):
b = []
c = range(1, 81)
s = 0
for x in range(100):
p[x] = random.sample(range(1, 81), 5)
i = 0
while (i == 0):
s += 1
random.suffle(c)
b[s - 1] = c.pop(80 - step)
print(b[s - 1])
for y in range(100):
if (p[y] in b):
i += 1
print("bingo!")
f += s
print(s / 10000)