blob_id stringlengths 40 40 | repo_name stringlengths 5 127 | path stringlengths 2 523 | length_bytes int64 22 545k | score float64 3.5 5.34 | int_score int64 4 5 | text stringlengths 22 545k |
|---|---|---|---|---|---|---|
046c8f695ebefbe7fb30651c7b6444610702d93e | Whatsupyuan/python_ws | /10. 第十章_02-异常except/10_1004_test01.py | 349 | 3.921875 | 4 | def plus():
try:
num1 = int(input("Please input first number.."))
num2 = int(input("Please input second number.."))
# python 3.6 捕获多个异常，不能使用 ， 号分隔
except TypeError:
print("error.")
except ValueError:
print("valueError")
else:
return num1 + num2
print(plus()) |
1622d36817330cc707a1a4e4c4e52810065aa222 | Whatsupyuan/python_ws | /4.第四章-列表操作/iterator_044_test.py | 1,306 | 4.15625 | 4 | # 4-10
players = ['charles', 'martina', 'michael', 'florence', 'eli']
print("The first three items in the list are" )
print(players[:3])
print()
# python3 四舍五入 问题
# 官方文档写了，round(number[, ndigits]) values are rounded to the closest multiple of 10 to the power minus ndigits;
# if two multiples are equally close, rounding is done toward the even choice
# (so, for example, both round(0.5) and round(-0.5) are 0, and round(1.5) is 2).
# 就是说round(1/2)取离它最近的整数，如果2个数（0和1）离它一样近，则取偶数（the even choice）。
# 因此round(1.5)=2, round(2.5)=2, round(3.5)=4, round(4.5)=4。
# http://www.cnblogs.com/lxmwb/p/7988913.html
# 4-10-2 打印列表中间的3个元素
print("Three items from the middle of the list are:")
import decimal
half_length = len(players)
a = decimal.Decimal(half_length)/2
decimal.getcontext().rounding = decimal.ROUND_UP
half_num = round(a,0)
print(players[int(half_num-2):int(half_num+1)])
print()
# 4-10-3 打印列表尾部的3个元素
print("The last three items in the list are:")
print(players[half_length-3:])
# 4-11-1
pizzas = ["one_pizza" , "two_pizza" , "thress_pizza"]
friend_pizzas = pizzas[:]
pizzas.append("none-pizza");
print(pizzas)
print(friend_pizzas)
for p in pizzas:
print(p) |
6eec6a9e295edab7320b350776335b60ce1080ae | Whatsupyuan/python_ws | /9.第九章-类class/09_class_0910_testRandom.py | 305 | 3.78125 | 4 | from random import randint
# 生成 1 到 6 之间的随机数
x = randint(1, 6)
print(x)
class Die():
def __init__(self, sides=6):
self.sides = sides
def roll_die(self):
print(randint(1, 6))
die = Die()
print("开始投掷骰子")
for num in range(1, 11):
die.roll_die()
|
975d3f6ea1518c2e1f8d3939da09bbaf66b4acb3 | Whatsupyuan/python_ws | /5.第五章-if/if_0230_test.py | 471 | 4 | 4 | # 5.2.1
str1 = "print info"
str2 = "print name"
print(str1 == str2)
# 5.2.2
print(str1.lower() == str2)
# 5.2.3
int1 = 100
int2 = 110
print(int1 == int2)
print(int1 != int2)
print(int1 > int2)
print(int1 < int2)
print(int1 >= int2)
print(int1 <= int2)
# 5.2.4
if int1 == int2 or int1 <= int2:
print(1)
if int1 != int2 and int1 < int2:
print(22)
# 5.2.5
print()
cars = ["benz", "bmw", "toyota"]
if "uia" in cars:
print(1)
if "uia" not in cars:
print(2) |
98d23e0af9f04e9ba50bdf07a6f04bec5b1e2d57 | Whatsupyuan/python_ws | /4.第四章-列表操作/iterator_044_split.py | 461 | 3.71875 | 4 |
players = ['charles', 'martina', 'michael', 'florence', 'eli']
split_arr = players[0:1]
print(split_arr)
split_arr = players[1:]
print(split_arr)
# 内容指向一直的 list , 则两个list不能相互独立
new_players = players
new_players.insert(0,"yuan")
print(new_players)
print(players) ;
print()
# 复制列表 [:] , 复制之后的列表是独立的内存指向
new_players = players[:]
new_players.append("Kobe")
print(players)
print(new_players) |
134d4811b1e629067e1f711f145fff9b889617aa | Whatsupyuan/python_ws | /6.第六章-字典(Dictionary)/06_dic_0603_iteratorDictionary.py | 734 | 4.28125 | 4 | favorite_num_dic = {"Kobe": 24, "Jame": 23, "Irving": 11}
# 自创方法,类似于Map遍历的方法
for num in favorite_num_dic:
print(num + " " + str(favorite_num_dic[num]))
print()
# 高级遍历方法 items() 方法
print(favorite_num_dic.items())
for name,number in favorite_num_dic.items():
print(name + " " + str(number))
print()
# key获取 字典 中的所有key --- keys()
# 如果将上述代码中的for name in favorite_languages.keys(): 替换为for name in favorite_languages: ，输出将不变。
for key in favorite_num_dic.keys():
print(key)
print()
# 字典获取所有的 value --- values()
# 类似于 Map.keys() 与 Map.values()
vals = favorite_num_dic.values()
for val in vals:
print(val)
|
9c54989a85bd5020fe1407b3ea1a90046034c8b4 | Whatsupyuan/python_ws | /7.第七章-用户输入input和while循环/07_input_0201_while_0705test.py | 237 | 4 | 4 | # 电影院
while True:
info = int(input("岁数?"))
if info == 888:
break
if info < 3:
print("免费")
elif info > 3 and info < 12:
print("10美元")
elif info > 15:
print("15美元")
|
81ba73b968e2676a4d6d4485dce939b5c1e3443e | Whatsupyuan/python_ws | /4.第四章-列表操作/test.py | 736 | 3.953125 | 4 | # 4-3
# for num in range(1,20):
# print(num)
def iteratorMethod(list):
for val in list:
print(val)
numArr = list(range(1, 1000 * 1000 + 1))
# iteratorMethod(numArr)
# print(min(numArr))
# print(max(numArr))
# print(sum(numArr))
# numArr = list(range(1,20,2))
# iteratorMethod(numArr)
# numArr = list(range(3, 31, 3))
# iteratorMethod(numArr)
# arr = []
# for num in range(1,11):
# arr.append(num**3)
# iteratorMethod(arr)
# arrNum = [num**3 for num in range(1,11)]
# iteratorMethod(arrNum)
# orderedDict 保存插入字典中的顺序
from collections import OrderedDict
dict = OrderedDict()
dict["h3"] = "hello3"
dict["h1"] = "hello1"
dict["h2"] = "hello2"
for k, v in dict.items():
print(k + " " + v) |
689e63b9210d28d7d709c06806b607e4b1d22831 | Whatsupyuan/python_ws | /9.第九章-类class/09_class_0905_extend.py | 636 | 3.765625 | 4 | '''
父类 , 子类
继承
'''
class Car():
def __init__(self , name , series):
self.name = name
self.series = series
def carInfo(self):
print(self.name + " " + self.series)
class ElectriCar(Car):
def __init__(self , name , series ):
# super() 必须写成方法体形态 , 与JAVA不同
super().__init__(name , series)
def printElectriCarInfo(self):
print(self.name + " " + self.series + "Electri")
car = Car("toyota" , "霸道")
car.carInfo()
carElec = ElectriCar("特斯拉" , "P80")
carElec.printElectriCarInfo()
# 输出
# toyota 霸道
# 特斯拉 P80Electri |
3d36ddfcdb53ea51d3e0b1b44ac347ec35c58c18 | Whatsupyuan/python_ws | /3.第三章-列表/list_03_sorted.py | 262 | 3.828125 | 4 | # list排序
cars = ['bmw', 'audi', 'toyota', 'subaru'] ;
sorted_cars = sorted(cars);
print("排序之后列表 : " + str(sorted_cars));
print("原始列表 : " + str(cars));
# sorted 反响排序
print("sorted倒序排列:" + str(sorted(cars,reverse=True))) ; |
8a042aa4d931d9ed16594b4f3988ad35d6222325 | Whatsupyuan/python_ws | /10. 第十章_02-异常except/10_1003_pass.py | 923 | 3.703125 | 4 | def countWord(fileName):
if fileName:
try:
with open(fileName) as file:
content = file.readlines()
# except 之后要捕获的异常可以不写
# 程序一样会执行
except FileNotFoundError:
# pass 当程序出现异常时 , 什么操作都不执行
pass
else:
wordsCount = 0
for line in content:
wordsCount += len(line.split())
return wordsCount
# 第二种方法: 一次性读取所有文件内容
def countFileIncludWord(fileName):
if fileName:
try:
with open(fileName) as file:
content = file.read()
except:
pass
else:
return len(content.split())
num = countWord("10_1001_exception.py")
num2 = countFileIncludWord("10_1001_exception.py")
if num:
print(num)
if num2:
print(num2) |
4804a7005c71ed635bbd1dbff0be64ff46cd78ad | Whatsupyuan/python_ws | /10. 第十章_01-文件操作File/10_file_1007_test.py | 210 | 3.703125 | 4 | flag = True
while flag:
name = input("Pleas input your name ... ")
if name and name == 'q':
flag = False
continue
with open("guest.txt", "a") as file:
file.write(name + "\n") |
3d999ca8f12348a3cb229be5af0f9cdba4ccc0b2 | ArvindAROO/algorithms | /sleepsort.py | 1,052 | 4.125 | 4 | """
Sleepsort is probably the wierdest of all sorting functions
with time-complexity of O(max(input)+n) which is
quite different from almost all other sorting techniques.
If the number of inputs is small then the complexity
can be approximated to be O(max(input)) which is a constant
If the number of inputs is large then the complexity is
approximately O(n)
This function uses multithreading a kind of higher order programming
and calls n functions, each with a sleep time equal to its number.
Hence each of the functions wake in Sorted form
But this function is not stable for very large values
"""
from time import sleep
from threading import Timer
def sleepsort(values):
sleepsort.result = []
def add1(x):
sleepsort.result.append(x)
mx = values[0]
for v in values:
if mx < v:
mx = v
Timer(v, add1, [v]).start()
sleep(mx+1)
return sleepsort.result
if __name__ == '__main__':
x = [3,2,4,7,3,6,9,1]
sorted_x=sleepsort(x)
print(sorted_x)
|
5ff98430566fb288495995803076102ae131d7f8 | artheadsweden/python_adv_april19 | /Day1/Print.py | 528 | 3.609375 | 4 | from functools import wraps
def print_with_start(original_print):
@wraps(original_print)
def wrapper(*args, **kwargs):
pre = ""
if "start" in kwargs:
pre = kwargs['start']
kwargs.pop('start')
original_print(pre, *args, **kwargs)
return wrapper
print = print_with_start(print)
def main():
x = 10
print("x is", x)
print("x", end="")
print(x, start=" =")
print(f"x is {x}", start="<", end=">\n", sep="")
if __name__ == '__main__':
main()
|
f5703afe5db60099c947aafae9847b96e3b3b9a7 | noeldelgadom/devF | /easy:P/easy2.py/product.py | 454 | 4.03125 | 4 | # -*- encoding: utf8 -*-
lista1=[1,2,4,5,9,4]
lista2=[6,1,2,3,1,4]
print "sumar de las listas"
for i in range(len(lista1)):
print lista1[i]+lista2[i]
print ""
print "Resta de las listas"
for i in range(len(lista1)):
print lista1[i]-lista2[i]
print ""
print "Divicion de las listas"
for i in range(len(lista1)):
print lista1[i] / lista2[i]
print ""
print "Multiplicacion de las listas"
for i in range(len(lista1)):
print lista1[i]*lista2[i]
|
0ebdd0da9d050cd2f5f70738697a84e26a385b35 | Dedlipid/PyBits | /basechanger.py | 408 | 3.734375 | 4 | def f():
n=int(raw_input("Enter number "))
b=int(raw_input("Enter base "))
l=[]
if n == 0 :
print "0 in any base is 0"
else:
while n > 0:
l.extend([n % b])
n /= b
l = l[::-1]
if b <=10:
l = ''.join(str(e) for e in l)
else :
l = ' '.join(str(e) for e in l)
print l
c = raw_input("Press enter to run again")
if c == "":
f()
f()
|
77d4482ba88837a3bca6280a08320a2b0eb70aac | KD4N13-L/Data-Structures-Algorithms | /Sorts/merge_sort.py | 1,591 | 4.21875 | 4 | def mergesort(array):
if len(array) == 1:
return array
else:
if len(array) % 2 == 0:
array1 = []
half = (int(len(array) / 2))
for index in range(0, half):
array1.append(array[index])
array2 = []
for index in range(half, len(array)):
array2.append(array[index])
array1 = mergesort(array1)
array2 = mergesort(array2)
return merge(array1, array2)
else:
array1 = []
half = (int((len(array) + 1) / 2))
for index in range(0, half):
array1.append(array[index])
array2 = []
for index in range(half, len(array)):
array2.append(array[index])
array1 = mergesort(array1)
array2 = mergesort(array2)
return merge(array1, array2)
def merge(array1, array2):
temp_array = []
while array1 and array2:
if array1[0] > array2[0]:
temp_array.append(array2[0])
array2.pop(0)
else:
temp_array.append(array1[0])
array1.pop(0)
while array1:
temp_array.append(array1[0])
array1.pop(0)
while array2:
temp_array.append(array2[0])
array2.pop(0)
return temp_array
def main():
array = input("Enter the number of array members, seperated by a coma")
array = array.split(',')
length = len(array)
for item in range(length):
array[item] = int(array[item])
print(mergesort(array))
main()
|
e9225939223ee4486cd867bfe1018e5788716e4a | AngiesEmail/ARTS | /ProgrammerCode/mergeTwoSortedLists.py | 757 | 3.515625 | 4 | class ListNode(Onject):
def __init__(self,x):
self.val = x
self.next = None
def mergeLists(l1,l2):
dummy = result = ListNode(l1.val)
node1 = l1.next
node2 = l2
while node1 != None and node2 != None:
if node1.val <= node2.val:
result.next = node1
node1 = node1.next
result = result.next
else:
if result.val <= node2.val:
result.next = node2
node2 = node2.next
result = result.next
else:
curNode = result
result.val = node2.val
result.next = curNode
node2 = node2.next
result = result.next
return dummy
mergeLists |
7c3abbae1e51ca3e6b12f151000b2e06d01b6ded | iagoguimaraes/introducaopython | /aula2/decisao.py | 1,067 | 4.09375 | 4 | def ex_16():
primeiro_numero = float(input('Digite um número: '))
segundo_numero = float(input('Digite outro número: '))
if(primeiro_numero > segundo_numero):
print('O número {} é maior.'.format(primeiro_numero))
elif(segundo_numero > primeiro_numero):
print('O número {} é maior.'.format(segundo_numero))
else:
print('Os números {0} e {1} são iguais.'.format(primeiro_numero, segundo_numero))
def ex_17(numero):
if (float(numero) < 0):
print('O número {} é negativo.'.format(numero))
elif(float(numero) > 0):
print('O número {} é positivo.'.format(numero))
else:
print('Você digitou {}.'.format(numero))
def ex_19(letra):
if(letra.isalpha()):
vogais = ['A', 'E', 'I', 'O', 'U']
print('{} é uma vogal.'.format(letra)) if letra.upper() in vogais else print('{} é uma consoante.'.format(letra))
else:
print('Letra inválida.')
def run():
ex_16()
ex_17(input('Digite um número: '))
ex_19(input('Digite uma letra: '))
|
6e0f318c5fcbccfc8e04a6c0866b04e8b84a76f4 | cristigavrila/Python-Basics | /string_null_bool.py | 114 | 3.859375 | 4 | #a string with 0 is still true in boolean condiion
s = '0'
if s:
print('true')
else:
print('False')
|
2ab2af6ab1a063d85753251cd3a7e7575f4a40c2 | k-j-m/KenGen | /kengen/model.py | 4,931 | 3.734375 | 4 | class Model(object):
def __init__(self, classes, package):
self.classes = classes
self.package = package
class ClassElement(object):
"""
ClassElement class contains a description of a class in our data
model.
Please note that I've made sure to keep this class completely unaware
of the format of the model. Please don't let the xml (or replacement format)
slip in here.
Note:
We don't currently support user classes with generics/type-parameters.
"""
def __init__(self, name, attrs, extends, class_parameters, isabstract):
"""
All values are set in the constructor and must be read by the parser.
"""
self.name = name
self.attrs = attrs
self.extends = extends
self.class_parameters = class_parameters
self.isabstract = isabstract
def get_precedents(self):
"""
Returns a list of all types that are referenced by this class.
This is especially important when generating the python code
since the python classes need to be written in an order such that
all classes are read by the interpreter before they are referenced.
"""
precedents=[]
if not self.extends is None:
precedents.append(self.extends)
for type_ref in self.attrs.values():
precedents.extend(type_ref.get_precedents())
return precedents
class TypeRef(object):
"""
This class is the nuts-and-bolts of our type-system.
It contains the type name and a {name:type_ref} dict
of all nested type parameters. An example of this is a
list where all of the items must be of a certain type.
In Java-speak: List<Integer> or Map<String,Double>
"""
def __init__(self, type_, type_params=[]):
"""
Value constructor.
All of the info needs to be parsed from the data model by code
in another module. That is not the job here!
"""
self.type_ = type_
self.type_params = type_params
def get_precedents(self):
"""
Returns a list of all types that need to be available
to be able to use this type (including the top level
type itself and the types of any nested attributes).
"""
precedents = [self.type_]
for tp in self.type_params:
print tp[1]
precedents.extend(tp[1].get_precedents())
return precedents
def __repr__(self):
return 'TypeRef(%s, %s)'%(self.type_, repr(self.type_params))
def order_classes(classes):
"""
Function orders classes such that they can be written with
no classes being referenced before they are read by the interpreter.
Note that this will raise an error in the following 2 cases:
+ Circular dependencies
+ Mistakenly underfined types
"""
unsorted_classes = classes[:]
sorted_classes = []
custom_types=[]
for _ in range(len(classes)):
nxt_class,unsorted_classes = find_resolved_class(unsorted_classes,custom_types)
sorted_classes.append(nxt_class)
custom_types.append(nxt_class.name)
return sorted_classes
def find_resolved_class(classes, custom_types):
"""
Takes a list of classes and a list of already-defined custom_types
and returns a class with no unresolved dependencies and a list
of the remaining classes.
"""
assert len(classes) > 0, 'Trying to find a class in an empty list...'
ok_classes = [c for c in classes
if class_is_resolved(c, custom_types)]
if len(ok_classes) == 0:
raise Exception("Can't find any resolved classes. Check for circular dependencies or undefined types.")
classes2=classes[:]
classes2.remove(ok_classes[0])
return ok_classes[0],classes2
def class_is_resolved(cls_elem, custom_types):
"""
Returns true of the given class element doesn't require
any data types that are not in the builtins or the list
of custom_types passed in as the 2nd argument.
"""
precedents = cls_elem.get_precedents()
def check_type(type_name):
return type_is_resolved(type_name, custom_types)
return all(map(check_type, precedents))
# This is NASTY! This is meant to be language neutral in here
# I guess I need to add some language specific (but not library
# specific) utility modules.
# A list of what builtin data types we support.
python_primitives = ['float','int','string','boolean']
python_structures = ['List', 'Map']
def type_is_resolved(type_name, custom_types):
"""
Returns true of the given type_name is found either in
the builtins or the list of custom_types passed in
as the 2nd argument.
"""
return any([type_name in python_primitives,
type_name in python_structures,
type_name in custom_types])
|
5b21093884fa7272edafaabf4dfab40581f8e29e | njdevengine/nltk-exploration | /nltk-chapter-3.py | 2,568 | 3.671875 | 4 | from urllib import request
url = "http://www.gutenberg.org/files/2554/2554-0.txt"
response = request.urlopen(url)
raw = response.read().decode('utf-8')
type(raw)
len(raw)
raw[:100]
#tokenize the text, splitting all words and punctuation
import nltk, re, pprint
from nltk import word_tokenize
tokens = word_tokenize(raw)
type(tokens)
len(tokens)
tokens[:10]
#convert to nltk Text object
text = nltk.Text(tokens)
#top bigrams in the text
text.collocations()
# Method##########Functionality####################################################
# s.find(t) index of first instance of string t inside s (-1 if not found)
# s.rfind(t) index of last instance of string t inside s (-1 if not found)
# s.index(t) like s.find(t) except it raises ValueError if not found
# s.rindex(t) like s.rfind(t) except it raises ValueError if not found
# s.join(text) combine the words of the text into a string using s as the glue
# s.split(t) split s into a list wherever a t is found (whitespace by default)
# s.splitlines() split s into a list of strings, one per line
# s.lower() a lowercased version of the string s
# s.upper() an uppercased version of the string s
# s.title() a titlecased version of the string s
# s.strip() a copy of s without leading or trailing whitespace
# s.replace(t, u) replace instances of t with u inside s
#dealing with different encodings
path = nltk.data.find('corpora/unicode_samples/polish-lat2.txt')
f = open(path, encoding='latin2')
for line in f:
line = line.strip()
print(line)
# Pruska Biblioteka Państwowa. Jej dawne zbiory znane pod nazwą
# "Berlinka" to skarb kultury i sztuki niemieckiej. Przewiezione przez
# Niemców pod koniec II wojny światowej na Dolny Śląsk, zostały
# odnalezione po 1945 r. na terytorium Polski. Trafiły do Biblioteki
# Jagiellońskiej w Krakowie, obejmują ponad 500 tys. zabytkowych
# archiwaliów, m.in. manuskrypty Goethego, Mozarta, Beethovena, Bacha.
f = open(path, encoding='latin2')
for line in f:
line = line.strip()
print(line.encode('unicode_escape'))
#b'Pruska Biblioteka Pa\\u0144stwowa. Jej dawne zbiory znane pod nazw\\u0105'
#b'"Berlinka" to skarb kultury i sztuki niemieckiej. Przewiezione przez'
#b'Niemc\\xf3w pod koniec II wojny \\u015bwiatowej na Dolny \\u015al\\u0105sk, zosta\\u0142y'
#b'odnalezione po 1945 r. na terytorium Polski. Trafi\\u0142y do Biblioteki'
#b'Jagiello\\u0144skiej w Krakowie, obejmuj\\u0105 ponad 500 tys. zabytkowych'
#b'archiwali\\xf3w, m.in. manuskrypty Goethego, Mozarta, Beethovena, Bacha.'
|
fd284f5ceefa02965d794923ecac5e367e461184 | FireHo57/mud_wizard | /mudWizard/game/game_object_base.py | 277 | 3.609375 | 4 | from abc import ABCMeta
class game_object_base:
"""
This class is abstract! it makes sure that every (visible) object has
a looks like method on it.
"""
def looks_like(self):
raise NotImplementedError( "You haven't implemented looks_like()!" )
|
26f3a1474e7b23a69abcc233bac02684266a1c67 | Tomek189/day2 | /Zmiennap.py | 179 | 3.796875 | 4 | a=3
b=4
x=b/(2.0+a)
print("zmienna a:{} zmienna b:{}".format(a,b))
print("{:.17}".format(x))
print(True)
print(False)
print (True==True)
print(True!=False)
print(True!=False)
|
f7d79acd5833d909c9fb4f81268da7f5b5f58994 | Rahix/frequency-bands | /gen_data.py | 1,113 | 4 | 4 | # Simple python script to add new entries
def gen_entry():
ob = input("Operating Band: ")
ul = input("Uplink(UL) lower: ")
uu = input("Uplink(UL) upper: ")
dl = input("Downlink(DL) lower: ")
du = input("Downlink(DL) upper: ")
dm = input("Duplex Mode: ")
ne = input("Note(Leave empty for no note): ")
if ne == "":
ne = "-"
return ",".join([ob, ul, uu, dl, du, dm, ne])
print("""Add frequency band to list:
Information:
- Uplink lower = F UL_low
- Uplink upper = F UL_high
- Downlink lower = F DL_low
- Downlink upper = F DL_high
- If only one band is used set the values for Uplink to the same as Downlink
""")
while True:
entry = gen_entry()
r = input("Is the above data correct(Y/N)?")
if r == "Y" or r == "y" or r == "":
f = open("data/fb.csv", "a")
f.write(entry + "\n")
f.close()
print("Entry written.")
else:
print("Please enter again!")
continue
r = input("Do you want to enter another frequency band(Y/N)?")
if r == "Y" or r == "y" or r == "":
continue
else:
exit()
|
f02d5df44baa691d9b8b8beb4609785764e80a46 | kaylalee44/Computing-Kids | /info_extract.py | 5,960 | 3.828125 | 4 | import pandas as pd
from bs4 import BeautifulSoup
from urllib.request import urlopen
import csv
def jobsUpdated(file_name):
"""
Goes through a data set file and looks through all the job listings for the date it was posted. If the days posted
was 1, 7, 14, or 21 days ago, then the counter goes up. Prints out the number of jobs that were posted within the
number range.
:param file_name: name of data set file passed in
:return: number of jobs that were updated
"""
df = pd.read_csv(file_name)
url_column = df["IndeedJobListingURL"] # gets url column from .csv file
urls = url_column.tolist()
num_last_updated = 0
base_url = 'https://www.indeed.com/'
job_num = 1
for url in urls:
if (job_num == 1):
print("Checking first 10 jobs...")
elif ((job_num % 10) == 0):
print("Checking next 10 jobs...")
html = urlopen(base_url + url) # connects to url
soup = BeautifulSoup(html.read(), features="lxml") # gets html
last_updated_days = soup.find('div', attrs={'class': 'jobsearch-JobMetadataFooter'}).text # text
for s in last_updated_days.split(): # extracting number
if s.isdigit():
days = int(s)
# print(days)
if (days == 1 or days == 7 or days == 14 or days == 21):
num_last_updated += 1
job_num += 1
return (str(num_last_updated) + " jobs were updated 1, 7, 14, or 21 days ago" + "\n")
# test = jobsUpdated("indeedJobs_WA_computerprogrammer_entrylevel.csv")
# print(test)
def companyCount(file_name):
"""
Goes through the data set passed in and creates a data frame of all the companies and a count of each company.
:param file_name: name of data set file passed in
:return: data frame of all the companies and the counts for them
"""
df = pd.read_csv(file_name)
company_column = df["Company"] # gets company column from .csv file
companies = company_column.tolist()
count = {}
for company in companies:
if company not in count:
count[company] = 1
else:
count[company] = count.get(company, 0) + 1
df = pd.DataFrame.from_dict(count, orient='index', columns=['Count'])
df.index.name = 'Company'
df = df.sort_values(by=['Count'], ascending=False)
return df
test1 = companyCount("indeedJobs_WA_computerprogrammer_entrylevel.csv")
print(test1)
# test1.to_csv("test.csv")
def locationCount(file_name):
"""
Goes through the data set passed in and creates a data frame of all the location cities and states and a count for
each location.
:param file_name: name of data set file passed in
:return: data frame of all the locations and the counts for them
"""
df = pd.read_csv(file_name)
locationstate_column = df["LocationState"] # gets location state column from .csv file
locationstate = locationstate_column.tolist()
locationcity_column = df["LocationCity"]
locationcity = locationcity_column.tolist()
count = {}
for i in range(0, len(locationcity)):
location = str(locationcity[i]) + ", " + str(locationstate[i])
if location not in count:
count[location] = 1
else:
count[location] = count.get(location, 0) + 1
df = pd.DataFrame.from_dict(count, orient='index', columns=['Count'])
df.index.name = 'Location'
df = df.sort_values(by=['Count'], ascending=False)
return df
test2 = locationCount("indeedJobs_WA_computerprogrammer_entrylevel.csv")
print(test2)
# test2.to_csv("test.csv")
def countJobType(file_name):
"""
Goes through the data set and creates a data frame of all the job types and a count for each job type.
:param file_name: name of data set file passed in
:return: data frame of all the job types and the counts for them
"""
df = pd.read_csv(file_name)
jobtype_column = df["JobType"]
jobtype = jobtype_column.tolist()
count = {}
for type in jobtype:
if type not in count:
count[type] = 1
else:
count[type] = count.get(type, 0) + 1
df = pd.DataFrame.from_dict(count, orient='index', columns=['Count'])
df.index.name = 'JobType'
df = df.sort_values(by=['Count'], ascending=False)
return df
test2 = countJobType("indeedJobs_WA_software_internship_entrylevel.csv")
print(test2)
# test2.to_csv("test.csv")
def countSalary(file_name):
"""
Goes through the data set and identifies how many jobs have salaries attached and how many don't. Also, identifies
all possible options of the salary units and converts all salaries to the same unit (hourly).
:param file_name: name of data set file passed in
:return: a string with details on how many jobs have salaries and how many don't.
"""
df = pd.read_csv(file_name)
minsalary_column = df["MinimumSalary"]
min = minsalary_column.tolist()
min_null = minsalary_column.isnull()
maxsalary_column = df["MaximumSalary"]
max = maxsalary_column.tolist()
max_null = maxsalary_column.isnull()
salaryunits_column = df["SalaryTimeUnits"]
salaryunits = salaryunits_column.tolist()
units = []
for unit in salaryunits:
if unit not in units:
units.append(unit)
print(units)
withSalary = 0
withoutSalary = 0
print(min)
for i in range(0, len(min)):
if min_null[i] and max_null[i]:
withoutSalary += 1
else:
withSalary += 1
# if salaryunits[i] != "Hourly":
# min[i] = int(min[i]) / 2080
# max[i] = int(max[i]) / 2080
# print(min)
return "There are " + str(withSalary) + " jobs with salaries attached and " + str(withoutSalary) + \
" without salaries attached."
test3 = countSalary("indeedJobs_WA_computerprogrammer_entrylevel.csv")
print(test3)
# test3.to_csv("test.csv")
|
c68ca2b8fbd9f772b509bda0cb4a226e94bac90d | kaylalee44/Computing-Kids | /test.py | 757 | 3.515625 | 4 | import requests
from urllib.request import urlopen
import re
from bs4 import BeautifulSoup
url = "https://www.indeed.com/jobs?q=data+scientist&l=WA&explvl=entry_level&start={}"
# page_response = requests.get(url, timeout=3)
# soup = BeautifulSoup(page_response.content, 'html.parser')
html = urlopen(url) #connects to url
soup = BeautifulSoup(html.read(), features="lxml") #gets html
num_jobs_area = soup.find(id = 'searchCount').string
job_numbers = re.findall('\d+', num_jobs_area) # Extract the total jobs found from the search result
if len(job_numbers) >= 3: # Have a total number of jobs greater than 1000
total_num_jobs = (int(job_numbers[1]) * 1000) + int(job_numbers[2])
else:
total_num_jobs = int(job_numbers[1])
print(total_num_jobs) |
3b563267fbc6c016985e4b8c7e5c657b7cd0f2e3 | OctopusHugz/holbertonschool-higher_level_programming | /0x01-python-if_else_loops_functions/1-last_digit.py | 282 | 3.8125 | 4 | #!/usr/bin/python3
import random
number = random.randint(-10000, 10000)
ld = abs(number) % 10
if number < 0:
ld = -ld
print("Last digit of {:d} is {:d} and is ".format(number, ld), end='')
print("greater than 5" if ld > 5 else "0"
if ld == 0 else "less than 6 and not 0")
|
3d57998b7d52f7ff65567e000ca0eb6aefec57b3 | OctopusHugz/holbertonschool-higher_level_programming | /0x06-python-classes/100-singly_linked_list.py | 2,867 | 4.03125 | 4 | #!/usr/bin/python3
"""This module implements a class Node that defines a node of a singly
linked list."""
class Node:
"""This class Node assigns data and next_node."""
def __init__(self, data, next_node=None):
"""This function initializes an instance of the Node class and assigns
the public attribute size to the instance if size is the correct int type. It
then assigns the public attribute position once it's validated."""
self.data = data
self.next_node = next_node
@property
def data(self):
"""This getter function gets the data attribute of the instance
and returns it"""
return self.__data
@data.setter
def data(self, value):
"""This setter function validates the data argument given at instantiation.
If valid, it sets the private data attribute for the instance."""
if isinstance(value, int):
self.__data = value
else:
raise TypeError("data must be an integer")
@property
def next_node(self):
"""This getter function gets the next_node attribute of the instance
and returns it"""
return self.__next_node
@next_node.setter
def next_node(self, value):
"""This setter function sets the next_node attribute to None, the value
passed to the function, or raises a TypeError if those fail"""
if value is None:
self.__next_node = None
elif isinstance(value, Node):
self.__next_node = value
else:
raise TypeError("next_node must be a Node object")
class SinglyLinkedList:
"""This class SinglyLinkedList assigns head to None and adds
Node instances through sorted_insert()."""
def __init__(self):
"""This function initializes an instance of the SinglyLinkedList class and
assigns the private attribute head to None."""
self.__head = None
def __str__(self):
"""This function prints the string representation of the SLL"""
string = ""
tail = self.__head
while tail:
string += str(tail.data)
if tail.next_node:
string += "\n"
tail = tail.next_node
return string
def sorted_insert(self, value):
"""This function determines the correct positioning of the new Node
instance and creates it at that position"""
if self.__head is None:
self.__head = Node(value)
return
else:
tail = self.__head
if value < tail.data:
self.__head = Node(value, tail)
return
while tail and tail.next_node:
temp = tail
tail = tail.next_node
if value < tail.data:
temp.next_node = Node(value, tail)
return
tail.next_node = Node(value)
|
7d5484155698ffad5a8413aed26d70e69a627db6 | OctopusHugz/holbertonschool-higher_level_programming | /0x0C-python-almost_a_circle/models/base.py | 3,748 | 3.796875 | 4 | #!/usr/bin/python3
"""This module implements the Base class"""
import json
import os
import csv
class Base:
"""This is the Base class's instantiation"""
__nb_objects = 0
def __init__(self, id=None):
"""This function creates the Base instance"""
if id is not None:
self.id = id
else:
Base.__nb_objects += 1
self.id = Base.__nb_objects
@staticmethod
def to_json_string(list_dictionaries):
"""This function returns the JSON string representation of
list_dictionaries"""
if list_dictionaries is None:
return "[]"
return json.dumps(list_dictionaries)
@classmethod
def save_to_file(cls, list_objs):
"""This function writes the JSON string representation of list_objs
to a file"""
filename = cls.__name__ + ".json"
new_list = []
with open(filename, "w") as fp:
if list_objs is None:
fp.write("[]")
else:
for objs in list_objs:
new_list.append(cls.to_dictionary(objs))
fp.write(cls.to_json_string(new_list))
@staticmethod
def from_json_string(json_string):
"""This function returns the list of the JSON string representation"""
new_list = []
if json_string is None:
return new_list
else:
return json.loads(json_string)
@classmethod
def create(cls, **dictionary):
"""This function returns an instance with all attributes already set"""
new_inst = cls.__new__(cls)
if cls.__name__ == "Rectangle":
new_inst.__init__(42, 98)
elif cls.__name__ == "Square":
new_inst.__init__(42)
new_inst.update(**dictionary)
return new_inst
@classmethod
def load_from_file(cls):
"""This function returns a list of instances"""
filename = cls.__name__ + ".json"
new_list = []
if not os.path.isfile(filename):
return new_list
with open(filename) as fp:
json_string = fp.read()
cls_list = cls.from_json_string(json_string)
for items in cls_list:
new_inst = cls.create(**items)
new_list.append(new_inst)
return new_list
@classmethod
def save_to_file_csv(cls, list_objs):
"""This functions saves a list of objects to a CSV file"""
r_fields = ['id', 'width', 'height', 'x', 'y']
s_fields = ['id', 'size', 'x', 'y']
filename = cls.__name__ + ".csv"
new_list = []
with open(filename, "w") as fp:
if cls.__name__ == "Rectangle":
dict_writer = csv.DictWriter(fp, fieldnames=r_fields)
elif cls.__name__ == "Square":
dict_writer = csv.DictWriter(fp, fieldnames=s_fields)
dict_writer.writeheader()
for objs in list_objs:
dict_writer.writerow(objs.to_dictionary())
@classmethod
def load_from_file_csv(cls):
"""This functions loads a list of objects from a CSV file"""
fields = []
rows = []
new_dict = {}
new_list = []
key = ""
filename = cls.__name__ + ".csv"
with open(filename) as fp:
reader = csv.reader(fp)
fields = next(reader)
for row in reader:
rows.append(row)
for row in rows:
i = 0
new_dict = new_dict.fromkeys(fields)
for attr in fields:
key = fields[i]
value = row[i]
new_dict[key] = value
i += 1
new_list.append(cls.create(**new_dict))
return new_list
|
84c103cbb20b0f72d368d731eef4dcec402d872e | OctopusHugz/holbertonschool-higher_level_programming | /0x0C-python-almost_a_circle/tests/test_rectangle.py | 3,023 | 3.6875 | 4 | #!/usr/bin/python3
"""This module implements the TestRectangle class"""
import unittest
# from models.base import Base
from models.rectangle import Rectangle
class TestRectangle(unittest.TestCase):
"""This is an instance of the TestRectangle class"""
def test_rectangle_instantiation(self):
"""This function tests the setting of id attribute"""
r1 = Rectangle(10, 2)
self.assertEqual(r1.width, 10)
self.assertEqual(r1.height, 2)
r2 = Rectangle(10, 2, 0, 0, 12)
self.assertEqual(r2.x, 0)
self.assertEqual(r2.y, 0)
self.assertEqual(r2.id, 12)
r3 = Rectangle(10, 2, 42, 98, 12)
self.assertEqual(r3.x, 42)
self.assertEqual(r3.y, 98)
self.assertEqual(r3.id, 12)
self.assertEqual(r3.__str__(), "[Rectangle] (12) 42/98 - 10/2")
r4 = Rectangle(10, 2, 42, 98, -12)
self.assertEqual(r4.id, -12)
self.assertEqual(r4.area(), 20)
r5 = Rectangle(1, 1, 1, 1, 1)
r5.update(13, 22, 42, 98, 140)
self.assertEqual(r5.id, 13)
self.assertEqual(r5.width, 22)
self.assertEqual(r5.height, 42)
self.assertEqual(r5.x, 98)
self.assertEqual(r5.y, 140)
r6 = Rectangle(1, 1, 1, 1, 1)
r6.update(x=98, height=42, y=140, id=13, width=22)
self.assertEqual(r6.id, 13)
self.assertEqual(r6.width, 22)
self.assertEqual(r6.height, 42)
self.assertEqual(r6.x, 98)
self.assertEqual(r6.y, 140)
r6_dict = r6.to_dictionary()
self.assertEqual(
r6_dict, {'x': 98, 'y': 140, 'id': 13, 'height': 42, 'width': 22})
# json_dict = Base.to_json_string([r6_dict])
# r5 = Rectangle(2, 2)
# self.assertEqual(r5.display(), "#""#""\n""#""#")
# r6 = Rectangle(2, 2, 2, 2)
# self.assertEqual(r6.display(), "\n""\n"" "" ""#""#""\n"" "" ""#""#")
with self.assertRaises(TypeError):
r1 = Rectangle()
with self.assertRaises(TypeError):
r1 = Rectangle(42)
with self.assertRaises(TypeError):
r1 = Rectangle(-42)
with self.assertRaises(TypeError):
r1 = Rectangle(None)
with self.assertRaises(TypeError):
r1 = Rectangle("holbie")
with self.assertRaises(TypeError):
r1 = Rectangle("holbie", 98)
with self.assertRaises(TypeError):
r1 = Rectangle(42, "holbie")
with self.assertRaises(TypeError):
r1 = Rectangle(42, 98, "holbie", 0)
with self.assertRaises(TypeError):
r1 = Rectangle(42, 98, 0, "holbie")
with self.assertRaises(ValueError):
r1 = Rectangle(-42, 98)
with self.assertRaises(ValueError):
r1 = Rectangle(42, -98)
with self.assertRaises(ValueError):
r1 = Rectangle(42, 98, -1, 0)
with self.assertRaises(ValueError):
r1 = Rectangle(42, -98, 0, -1)
if __name__ == "__main__":
unittest.main()
|
c621bf99110cfda89e2b6196bd363155569883eb | OctopusHugz/holbertonschool-higher_level_programming | /0x0B-python-input_output/8-load_from_json_file.py | 279 | 3.546875 | 4 | #!/usr/bin/python3
"""This module implements the load_from_json_file function"""
import json
def load_from_json_file(filename):
"""This function loads a JSON object from a file filename"""
with open(filename) as fp:
text = fp.read()
return json.loads(text)
|
ab64f97d2ab84c34fe1af4c973abba878038559b | OctopusHugz/holbertonschool-higher_level_programming | /0x0B-python-input_output/6-from_json_string.py | 231 | 3.5 | 4 | #!/usr/bin/python3
"""This module implements the from_json_string function"""
import json
def from_json_string(my_str):
"""This function returns the Python object represented
by a JSON string"""
return json.loads(my_str)
|
379f87707f737e0b2daabbff27120cd6767fbbe7 | dgoffredo/pattern | /pattern.py | 8,376 | 3.765625 | 4 | """simple pattern matching"""
from collections import defaultdict
import collections.abc as abc
def match(pattern, subject):
"""whether `subject` matches `pattern`"""
return Matcher()(pattern, subject)
class Matcher:
def __init__(self, num_variables=0):
self.vars = tuple(Variable() for _ in range(num_variables))
self.matched = False
def __iter__(self):
yield self
yield self.vars
def variables(self):
return self.vars
def values(self):
for var in self.vars:
yield var.value
def __bool__(self):
return self.matched
def __call__(self, pattern, subject):
self.matched = False # for starters
if any(count > 1 for var, count in _count_variables(pattern).items()):
raise Exception('Pattern contains one or more variables that '
'appear more than once. Each variable may appear '
'at most once in a pattern.')
self.matched, bindings = _match(pattern, subject)
if self.matched:
for var, value in bindings.items():
var.value = value
return self.matched
def _is_listy(value):
"""whether `value` is a sequence, but not a `str` or similar."""
return ( isinstance(value, abc.Sequence) and
not isinstance(value, abc.ByteString) and
not isinstance(value, str))
def _count_variables(pattern):
counts = defaultdict(int)
def visit(pattern):
if isinstance(pattern, Variable):
counts[pattern] += 1
visit(pattern.pattern)
elif isinstance(pattern, abc.Set) or _is_listy(pattern):
for subpattern in pattern:
visit(subpattern)
elif isinstance(pattern, abc.Mapping):
for key, value in pattern.items():
visit(key)
visit(value)
visit(pattern)
return counts
def _are_similar(left, right):
"""whether either of `left` and `right` is derived from the other"""
return isinstance(left, type(right)) or isinstance(right, type(left))
def _match(pattern, subject):
if isinstance(pattern, abc.Set):
if not isinstance(subject, abc.Set) or len(subject) < len(pattern):
return False, {}
else:
return _match_set(pattern, subject)
elif isinstance(pattern, abc.Mapping):
if not isinstance(subject, abc.Mapping) or len(subject) < len(pattern):
return False, {}
else:
return _match_mapping(pattern, subject)
elif _is_listy(pattern):
# of similar types (e.g. distinguish between tuple and list, but not
# between tuple and NamedTuple).
if not _are_similar(subject, pattern):
return False, {}
# of the same length
if len(subject) != len(pattern):
return False, {}
else:
return _match_sequence(pattern, subject)
elif isinstance(pattern, type):
if isinstance(subject, pattern):
return True, {}
else:
return False, {}
elif isinstance(pattern, Variable):
matched, bindings = _match(pattern.pattern, subject)
if matched:
bindings[pattern] = subject
return matched, bindings
elif pattern is ANY:
return True, {}
else:
return subject == pattern, {}
def _match_sequence(pattern, subject):
assert _is_listy(pattern)
assert _is_listy(subject)
assert len(pattern) == len(subject)
combined_bindings = {}
for subpattern, subsubject in zip(pattern, subject):
matched, bindings = _match(subpattern, subsubject)
if not matched:
return False, {}
combined_bindings.update(bindings)
return True, combined_bindings
def _match_unordered(pattern, subject):
# This code is common to matching Sets and Mappings (e.g. sets and dicts)
# We assume that the input `pattern` and `subject` are iterables of
# distinct (either by key or by value, depending on the caller) values.
used = set() # set of subject indices currently "taken" by a pattern index
pattern_list = list(pattern) # in some order
# `table` is all combinations of matching between subject elements and
# pattern elements.
table = [[_match(pat, sub) for sub in subject] for pat in pattern_list]
# Before trying all possible combinations of pattern/subject match
# assignments, sort the patterns in order of increasing matchness, so that
# highly constrained patterns are likely to fail early, avoiding
# unnecessary work.
num_matches = [(sum(matched for matched, _ in column), p) for p, column in enumerate(table)]
num_matches.sort()
# `num_matches` now contains the new `pattern_list` order. Now reorder
# `pattern_list` and `table` accordingly.
pattern_list = [pattern_list[p] for _, p in num_matches]
table = [table[p] for _, p in num_matches]
p = 0 # index into `pattern_list`
s = [0 for _ in pattern_list] # index corresponding to a subject in
# `table` for a given `p`
while True:
if p == len(pattern_list):
# All pattern elements have found distinct matching subject
# elements, so we're done.
combined_bindings = {}
for pattern_index in range(len(pattern_list)):
subject_index = s[pattern_index]
matched, bindings = table[pattern_index][subject_index]
assert matched
combined_bindings.update(bindings)
return True, combined_bindings
if s[p] == len(subject):
# We've run out of possible subjects to match the current pattern.
# Backtrack to the previous pattern and see if it will match a
# different pattern, this possibly freeing up a subject for this
# pattern to match.
if p == 0:
# ...unless, of course, there's no subject to go back to. Then
# there is no match overall.
return False, {}
# reset me (since we're going back to the previous pattern)
s[p] = 0
# and go back to the previous pattern
p -= 1
used.remove(s[p])
s[p] += 1
continue
if s[p] in used:
# Even if the current pattern element matches the current subject
# element, the subject element is already "taken" by a previous
# pattern element, so try another subject element.
s[p] += 1
continue
matched, bindings = table[p][s[p]]
if not matched:
# The current pattern element does not match the current subject
# element, so try another subject element.
s[p] += 1
continue
# We have a partial match consistent with previous partial matches.
# Mark the matching subject element "used" and carry on to the next
# pattern element.
used.add(s[p])
p += 1
# Program execution can't reach here.
def _match_set(pattern, subject):
assert isinstance(pattern, abc.Set)
assert isinstance(subject, abc.Set)
assert len(pattern) <= len(subject)
return _match_unordered(pattern, subject)
def _match_mapping(pattern, subject):
assert isinstance(pattern, abc.Mapping)
assert isinstance(subject, abc.Mapping)
assert len(pattern) <= len(subject)
return _match_unordered(pattern.items(), subject.items())
class _Symbol:
"""A `_Symbol` is a distinct value that displays with a specified name."""
def __init__(self, name):
self._name = name
def __repr__(self):
return f'<{self.__module__}.{self._name}>'
ANY = _Symbol('ANY')
UNMATCHED = _Symbol('UNMATCHED')
class Variable:
def __init__(self):
self.pattern = ANY
self.value = UNMATCHED
def __getitem__(self, pattern):
self.pattern = pattern
return self
def __repr__(self):
if self.value is UNMATCHED:
# Use the default __repr__
return object.__repr__(self)
else:
return f'<{self.__module__}.{type(self).__name__} value={repr(self.value)}>'
|
c10ae32a117863a4df1df1d4a2666f0caa8e943e | MetalSeed/python3_demo2 | /base_syntax/base/the_list.py | 499 | 3.671875 | 4 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Date : 2019-04-26 21:39:07
# @Author : MetalSeed (=.=)
# @Link :
# @Version : $Id$
classmates = ['Michael', 'Bob', 'Tracy']
print('len(classmates) =', len(classmates))
print('classmates[0] =', classmates[0])
print('classmates[2] =', classmates[2])
print('classmates[-1] =', classmates[-1])
classmates[1] = 'Sarah'
classmates.append('Adam')
classmates.pop()
classmates.insert(1, 'Jack')
classmates.pop(1)
print('classmates =', classmates)
|
3ce4f43aeb0732eddd88177beb3a5c55e99c9a86 | darshanmest47/Pythonoops | /oops/methodoverloading.py | 562 | 3.875 | 4 | # In Python a method is said to be overloaded if it can perform multiple tasks
# General method overloading example (not supported in python)
class Methodover:
def one(self,num1):
print(num1)
def one(self,num1,num2):
print(num1,num2)
def one(self,num1,num2,num3):
print(num1,num2,num3)
mo = Methodover()
mo.one(2)
#o/p
# Traceback (most recent call last):
# File "E:/pyoops/oops/methodoverloading.py", line 17, in <module>
# mo.one(2)
# TypeError: one() missing 2 required positional arguments: 'num2' and 'num3'
|
835584228978e6a4f5275ef9c4f4635683348dec | darshanmest47/Pythonoops | /oops/methodoverpython.py | 527 | 3.609375 | 4 | # method overloading python style
class Methodovpython:
def results(self, num1=None, num2=None, num3=None, num4=None):
if num1 != None and num2 != None and num3 != None and num4 != None:
return num1 + num2 + num3 + num4
elif num1 != None and num2 != None and num3 != None:
return num1 + num2 + num3
elif num1 != None and num2 != None:
return num1 + num2
else:
print('requires atleast 2 args')
m = Methodovpython()
print(m.results(1,2,3))
|
2cc4cc80205a7b5350e254bb7ec0137fa33a8041 | darshanmest47/Pythonoops | /oops/sort.py | 314 | 3.65625 | 4 | list1= [1,3,2,5,100,0]
for i in range(len(list1)):
pos1 = list1.index(list1[i])
for j in range(len(list1)):
pos2= list1.index(list1[j])
if list1[i] > list1[j]:
temp = list1[pos1]
list1[pos1] = list1[pos2]
list1[pos2] = temp
else:
pass
print(list1)
# [100, 5, 3, 2, 1, 0]
|
33aa49cd41a89f73924aa29990eaa46fff43f55e | joel-jaimon/Certificate_Maker | /generate_certificates.py | 1,193 | 3.5 | 4 | #check installation of Pillow:
def install_Pillow(package):
import importlib
try:
from PIL import Image
print("PIL already installed \n")
except ImportError:
print("Pillow not installed \n Installing Pillow... (Make sure you have an active internet connection.)")
import pip
pip.main(['install', package])
install_Pillow('Pillow')
#importing required files
from PIL import Image
from PIL import ImageFont
from PIL import ImageDraw
file = open("candidate_list.txt")
#Adjust you y-coordinate here
y_coordinate = 656
try:
for name in file:
name = name.rstrip()
img = Image.open("Your-Blank-Certificate/certificate.png")
width, height = img.size
draw = ImageDraw.Draw(img)
#Change Font size here, currently its set to 90
font = ImageFont.truetype("Font/j.ttf", 90)
offset = 10
x_coordinate = int(width / 2 - font.getsize(name)[0] / 2) + offset
draw.text((x_coordinate, y_coordinate), name, (255, 0, 0), font=font)
img.save("Your-Certificates/" + str(name) + ".png", "PNG")
print(f"Done For {name}")
except:
print("Woah.... Try Again") |
04a50ca364fbff8ad7367adb31625d00352f69c8 | srikanthpragada/python_14_dec_2020 | /demo/assignments/char_freq.py | 148 | 3.828125 | 4 |
s = "how do you do"
used_chars = []
for ch in s:
if ch not in used_chars:
print(f"{ch} - {s.count(ch)}")
used_chars.append(ch) |
36c15c15ede4798c5dd4fc837bd668e6371f4dc1 | srikanthpragada/python_14_dec_2020 | /demo/basics/for_demo.py | 87 | 3.5 | 4 | for n in range(1, 10):
print(n)
for n in range(10, 0, -1):
print(n, end= ' ')
|
348b24c93c33437d0431ecc6dcefd1b3056bf451 | srikanthpragada/python_14_dec_2020 | /demo/basics/factorial.py | 134 | 4.3125 | 4 | num = int(input("Enter a number :"))
fact = 1
for n in range(2, num + 1):
fact = fact * n
print(f"Factorial of {num} is {fact}") |
e4d5faad45457275d81cfe4be1e0d2fa6c9369ac | srikanthpragada/python_14_dec_2020 | /demo/funs/prime.py | 170 | 3.671875 | 4 |
def isprime(n):
for v in range(2, n//2 + 1):
if n % v == 0:
return False
return True
print(isprime(11), isprime(35), isprime(3939391113))
|
8b931447c65e8fa149b275a1c8c841b9bd534b52 | srikanthpragada/python_14_dec_2020 | /demo/funs/line_with_defaults.py | 225 | 3.578125 | 4 | def print_line(length=10, char='-'):
for n in range(length):
print(char, end='')
print_line()
print("\nSrikanth Technologies")
print_line(char='*') # Keyword arguments
print()
print_line(20, '.') # Positional
|
c3d980ccde2ec6c45f9f74eb20cc137a7e631697 | jakubsolecki/MOwNiT | /lab2/zad_6.py | 2,204 | 3.5 | 4 | import numpy as np
import time
def add_vectors(v1, v2):
if len(v1) == len(v2):
start = time.time()
for i in range(len(v1)):
v1[i] += v2[i]
end = time.time()
return v1, end - start
else:
print("You shouldn't add vectors of different lengths")
def cross_multiply_vectors(v1, v2):
if isinstance(v1, np.ndarray):
v1 = v1.tolist()
if isinstance(v2, np.ndarray):
v2 = v2.tolist()
if len(v1) == len(v2):
start = time.time()
v3 = v1[1:] + v1[:-1]
v4 = v2[1:] + v2[:-1]
v5 = []
for i in range(0, len(v3) - 1):
v5 += [v3[i]*v4[i+1] - v3[i+1]*v4[i]]
end = time.time()
return v5, end - start
else:
return "You shouldn't multiply vectors of different lengths"
def multiply_matrices(m1, m2):
if len(m1[0]) != len(m2):
return "Incorrect dimensions"
start = time.time()
m3 = np.zeros((len(m1), len(m2[0])))
for i in range(len(m1)):
for j in range(len(m2[0])):
for k in range(len(m2)):
m3[i][j] += m1[i][k] * m2[k][j]
end = time.time()
return m3, start - end
def numpy_add_vectors(v1, v2):
start = time.time()
v3 = np.add(v1, v2)
end = time.time()
return v3, end - start
def numpy_cross_multiply_vectors(v1, v2):
start = time.time()
v3 = np.cross(v1, v2)
end = time.time()
return v3, end - start
def numpy_multiply_matrices(m1, m2):
start = time.time()
r = np.dot(m1, m2)
end = time.time()
return r, end - start
a = [[12, 7, 3],
[4, 5, 6]]
b = [[5, 8, 1, 2],
[6, 7, 3, 0],
[4, 5, 9, 1]]
c = [1, 2, 3]
d = [3, 2, 1]
print("Numpy add two vectors:", numpy_add_vectors(c, d))
print("My add two vectors:", add_vectors(c, d), "\n")
print("Numpy cross multiply two vectors:", numpy_cross_multiply_vectors(c, d), "\n")
print("My cross multiply two vectors:", cross_multiply_vectors(c, d), "\n")
print("Numpy multiply matrices: \n", numpy_multiply_matrices(a, b)[0],
"\n", numpy_multiply_matrices(a, b)[1])
print("My multiply matrices: \n", multiply_matrices(a, b)[0],
"\n", multiply_matrices(a, b)[1])
|
97a9e78a34d68244e5f4c14b3b35130d4cd82870 | jakubsolecki/MOwNiT | /lab3/zad_2.py | 965 | 3.5 | 4 | import sympy as sp
import math
from lab3.zad_1 import to_table
def lagrange_polynomial(x_values, y_values):
if len(x_values) != len(y_values):
exit("There must be exact same number of x and y values")
return -1
x = sp.symbols('x')
y = 0
for k in range(len(x_values)):
i = 1
for j in range(len(x_values)):
if j != k:
i = i*((x - x_values[j]) / (x_values[k] - x_values[j]))
y += i*y_values[k]
return sp.simplify(y)
# x_arr, y_arr, _ = to_table(0, 10, 3, math.sqrt, "sqrt(x)")
# print("Lagrange polynomial for sqrt(x):", lagrange_polynomial(x_arr, y_arr), "\n")
#
# x_arr, y_arr, _ = to_table(0, 10, 3, math.sin, "sin(x)")
# print("Lagrange polynomial for sqrt(x):", lagrange_polynomial(x_arr, y_arr), "\n")
#
# f = lambda x: x**3 + 2*x
# x_arr, y_arr, _ = to_table(0, 10, 3, f, "x^3 + 2x")
# print("Lagrange polynomial for sqrt(x):", lagrange_polynomial(x_arr, y_arr), "\n")
|
571a7eb8101ba3438e83a58b132d5d35d661625a | parwisenlared/BiologicallyInspiredCW | /Scripts/PSO_2_configurable.py | 9,170 | 3.828125 | 4 | # Import modules
import numpy as np
import random
import pandas as pd
import matplotlib.pyplot as plt
import time
import NN_2
class PSO:
def __init__(self, n_networks):
"""
The PSO object contains an input n_networks which is the number of neural networks
that are to be initialised.
networks: is a list to store the initialised networks
global_best_value: is initialised as infinity
global_best_position: gets its shape from the Neural Network's getParams function
yHat: is initialised at floating point 0. It is needed to plot a graph
yHat_l: is a list to store the yHat values that is needed to plot a graph
"""
self.neurons = int(input("Inform the number of neurons in hidden layer of NN: "))
self.n_networks = n_networks
self.networks = [NN_2.NeuralNetwork(NN_2.x,NN_2.y, self.neurons) for i in range(self.n_networks)]
self.global_best_value = float("inf")
self.global_best_position = NN_2.NeuralNetwork(NN_2.x,NN_2.y, self.neurons).getParams.shape
self.global_best_yHat = 0
def set_personal_best(self):
"""
The set_personal_best method loops through a list of networks, assisigns a
fitness_candidate which is the network's fitness. If the networks'
personal_best_value is greater that fitness_candidate; it then assigns the
personal_best_value as the fitness_candidate. It then updates the network's
personal_best_position as the network's position.
"""
for network in self.networks:
if(network.personal_best_value > network.fitness):
network.personal_best_value = network.fitness
network.personal_best_position = network.position
def get_personal_best(self):
particles_position = []
for network in self.networks:
particles_position.append(network.position)
return
# The variable informants is in each network, here I just create informants for each of them.
def set_informants(self):
for network in self.networks:
informants = random.choices(self.networks, k=3) # 3 informants for each particle
network.informants = informants
# In this funcion I am instantiating the best_value of each informant in
def set_informants_best(self):
for network in self.networks:
for informant in network.informants:
if(informant.personal_best_value > informant.fitness):
informant.informants_best_value = informant.fitness
informant.informants_best_position = informant.position
def set_global_best(self):
"""
The set_global_best method loops through a list of networks and assigns the
best_fitness_candidate to the network's fitness. If the global_best_value
is greater than the best_fitness_candidate the global_best_value is assigned as
best_fitness_candidate and the global_best_position becomes the network's position
"""
for network in self.networks:
if(self.global_best_value > network.personal_best_value):
self.global_best_value = network.personal_best_value
self.global_best_position = network.position
self.global_best_yHat = network.yHat
def get_global_best(self):
print (f"Value:{self.global_best_value}, Position: {self.global_best_position}")
def move_particles(self):
"""
The move_particles method contains: the Intertia weight(a),
Cognitive(b), Social (c) and Informants (d) weights of the PSO algorithm which can be adjusted
and affect directly the value of the velocity.
There is an extra weight value (e) that is called the Jump and is used over the whole velocity.
This method loops through a list of neural networks and stores the product of
of interia weight multiplied by network's velocity plus a random number multiplied
by the cognitive weight multiplied by the difference of the personal_best_position
of the network and network's position plus the social weight into a random number
multiplied by the difference of global_best_position of the networks and network's
position plus the weighted value of the informants best position minus the network position
in a variable called new_velocity.
This will be weighted by the jump value and then it ssigns the network's velocity
to this variable and calls the move function from the NeuralNetwork class.
"""
a = 0.5 # Intertia: proportion of velocity to be retained
b = 0.8 # Cognitive/personal velocity: proportion of personal best to be retained
c = 1 # Social velocity: proportion of the informants' best to be retained
d = 0.9 # Global: proportion of global best to be retained
e = 1 # Jump size of a particle
for network in self.networks:
new_velocity = (a*network.velocity) + (b*random.random())*\
(network.personal_best_position - network.position) +\
(c*random.random())*(network.informants_best_position - network.position) +\
(d*random.random())*(self.global_best_position - network.position)
network.velocity = e*new_velocity
network.move()
# I added the Jump (the value is 1 by the pseudocode of the book they suggest, so does not affect)
# but I think we do need to put it.
def optimise(self):
"""
The optimise method loops through a list of neural networks and:
w1: takes the first three numbers from network's position array which is then
reshaped to the dimensions of the NeuralNetwork object's W1 parameter
w2: takes the next three numbers from network's position array which is then
reshaped to the dimensions of the NeuralNetwork object's W2 parameter
b1: takes the 7th item from the array
b2: takes the 8th item from the array
and uses these variables to forward propagate the neural network with these values.
z2: is the dot product of input(x) and w1 plus bias(b1)
a2: is the activation of the z2 using the activation function in NeuralNetwork class
z3: is the dot product of a2 and W2 plus bias(b2)
yHat: is the activation of the z3 using the activation function in NeuralNetwork class
yHat_l: the yHat values are stored in a list for plotting graphs
error: is calculated by using the Mean Square Error(mse) method using the target value(y)
and predicted value(yHat). The network's fitness is updated using the error.
"""
for network in self.networks:
# by calling the methods here, the optimization is automatic and I do not need to call them outside.
# just by calling PSO(num_NN) it is done.
network.forward()
network.mse()
self.set_personal_best()
self.set_informants()
self.set_informants_best()
self.set_global_best()
self.move_particles()
# Update of weights
W1 = network.position[0:(len(network.pw1))]
W2 = network.position[(len(network.pw1)):(len(network.pw1)+len(network.pw2))]
network.W1 = np.reshape(W1,network.W1.shape)
network.W2 = np.reshape(W2,network.W2.shape)
network.b1 = network.position[len(network.position)-2]
network.b2 = network.position[len(network.position)-1]
"""
pso1.optimise()
pso1.get_global_best()
plt.figure()
yHat1 = pso1.global_best_yHat
plt.plot(NN.y,"red",yHat1,"blue")
plt.title("y,yHat")
# plt.xlabel("Iterations")
# plt.ylabel("Errors")
plt.show()
"""
if __name__ == "__main__":
pso = PSO(10)
n_iterations = 100
error_list = []
yHat = 0
# The start time to calculate how long the algorithm takes.
start = time.process_time()
# Sets the number of starting iterations/epochs
iterations = 0
while(iterations < n_iterations):
pso.optimise()
error_list.append(pso.global_best_value)
yHat = pso.global_best_yHat
iterations +=1
#the global_best_value and the time taken to execute the algorithm
print(f"GlobalBest: {pso.global_best_position} iters: {iterations} GlobalBestVal: {pso.global_best_value}")
print(f"------------------------ total time taken: {time.process_time() - start} seconds")
# Show the graph
yHat = pso.global_best_yHat
plt.figure()
plt.plot(NN_2.y,"red",yHat,"blue")
plt.xlabel("Input values")
plt.ylabel("Output values")
plt.title("Desired vs Predicted output")
plt.show()
fitness = error_list
plt.figure()
plt.plot(fitness)
plt.xlabel("Number of iterations")
plt.ylabel("Mean square error")
plt.title("Mean Square Error per iteration")
plt.show() |
c5bbd43328a8c5d6e5133d72827cbbf94c219c26 | AdaptiveStep/pokerhands | /Cards/testpairs.py | 5,930 | 3.734375 | 4 | #!/usr/bin/env python
# -*- coding: utf8 -*-
import random
#Skapar en ordnad kortlek
class Cards(list):
def __init__(self,shuffled="no"):
self.pointer = 0 #used in check for wins.
#1 representerar Ess, .., 13 representerar kung
siffror = range(1,14)
# H = hjärter, R=Ruter, S=spader, T= treklöver
symboler =["♥","♦","♠","♣"] # 0,1,2,3
for r in symboler:
for s in siffror:
self.append(str(r)+str(s))
if shuffled == "shuffled":
self.shuffle()
def shuffle(self):
random.shuffle(self)
def Ntipples(self, N=2):
#check for pairs:
counter = 1
cards = self.copy()
templist =[]
for i in cards:
minilist =[]
h = cards.count("♥" + i[1:])
if h == 1:
minilist.append("♥" + i[1:])
cards.remove("♥" + i[1:])
s = cards.count("♠" + i[1:])
if s == 1:
minilist.append("♠" + i[1:])
cards.remove("♠" + i[1:])
r = cards.count("♦" + i[1:])
if r == 1:
minilist.append("♦" + i[1:])
cards.remove("♦" + i[1:])
k = cards.count("♣" + i[1:])
if k == 1:
minilist.append("♣" + i[1:])
cards.remove("♣" + i[1:])
totalt = int(h + s + r + k)
if totalt >= 2 and totalt >=N:
if N == 2 and totalt ==2 or N == 2 and totalt == 3:
templist.append(minilist)
elif N==2 and totalt ==4:
templist.append([minilist[0],minilist[1]])
templist.append([minilist[2],minilist[3]])
elif N >=3 and totalt >=3:
templist.append(minilist)
return templist
def hasPairs(self):
#check for pairs:
return len(self.Ntipples(2))>0
def hasTripples(self):
return len(self.Ntipples(3))>0
def hasQuads(self):
return len(self.Ntipples(4))>0
def hasKauk(self):
if self.hasPairs() and self.hasTripples():
return True
else:
return False
def hasLadder(self,n=5):
counter=0
cardsremaining = len(self.copy())
templist=[]
tempcards = self.copy()
tempcards.sort()
while cardsremaining > n:
if tempcards[counter] == tempcards[counter+1]-1:
counter+=1
def hasColors(self,n=5,interval="atleast"):
"""
n representerar hur många av en symbol man söker minst/mest/exakt av.
Interval kan vara någon av atleast, atmost, exact
"""
interval = str(interval)
colors = self.Colors(n,interval)
return len(colors)>0
def Colors(self,n=5,interval="atleast"):
"""
n representerar hur många av en symbol man söker minst/mest/exakt av.
Interval kan vara någon av atleast, atmost, exact
"""
counter = 1
cards = self.copy()
templist = []
interval = str(interval)
tcounter,scounter, hcounter,rcounter = 0,0,0,0
#rakna hjartan
for i in kortlek:
if "♣" in i: tcounter += 1
elif "♠" in i: scounter += 1
elif "♥" in i: hcounter += 1
elif "♦" in i: rcounter += 1
if interval == "atleast":
if tcounter >= n:
templist.append((tcounter, "♣"))
if scounter >= n:
templist.append((scounter, "♠"))
if hcounter >= n:
templist.append((hcounter, "♥"))
if rcounter >= n:
templist.append((rcounter, "♦"))
elif interval =="atmost":
if tcounter <= n:
templist.append((tcounter, "♣"))
if scounter <= n:
templist.append((scounter, "♠"))
if hcounter <= n:
templist.append((hcounter, "♥"))
if rcounter <= n:
templist.append((rcounter, "♦"))
elif interval =="exact":
if tcounter == n:
templist.append((tcounter, "♣"))
if scounter == n:
templist.append((scounter, "♠"))
if hcounter == n:
templist.append((hcounter, "♥"))
if rcounter == n:
templist.append((rcounter, "♦"))
#Skickar dock tom lista om inget har fyllts in.
return templist
## Vinster som räknas:
## Par (P), Triss (T), kåk(K),Fyrtal (F), stege (S), färg (C)
## [P,T,F,K,S,C]
## (hur många finns det av varje?)
#
#print()
#print("Pairs: ", kortlek.Pairs())
# ############ ####### SAMPLE DATA ######### ##########
loopcounter = 0
while 1:
kortlek = Cards("shuffled")
for i in range(40):
kortlek.pop()
print(kortlek)
print()
#print("Tripples: ", kortlek.Tripples())
k = 4
print("HAR,",k,"tippler: ", kortlek.Ntipples(k))
print()
q = 4
print("Dessa symboler förekommer minst", q,"antal gånger: ", kortlek.Colors(q))
print("Har",q ," färger: ", kortlek.hasColors(q))
print("HAR PAR: ", kortlek.hasPairs(), kortlek.Ntipples())
print("HAR TRISS: ", kortlek.hasTripples())
print("HAR FYRTAL: ", kortlek.hasQuads())
print("HAR FÄRG: ", kortlek.hasColors(5))
print("HAR KÅK: ", kortlek.hasKauk())
#print("This is kortlek tripples: ",kortlek.Tripples())
print(" ")
print(" ")
loopcounter +=1
print("ANTAL UTDELNINGAR: ",loopcounter,"\n -------------------")
if kortlek.hasColors(5):
break |
911d4753a01ab601346e3bc2f3b483a61d21c7ae | bspindler/python_sandbox | /classes.py | 1,180 | 4.3125 | 4 | # A class is like a blueprint for creating objects. An object has properties and methods (functions)
# associated with it. Almost everything in Python is an object
# Create Class
class User:
# constructor
def __init__(self, name, email, age):
self.name = name
self.email = email
self.age = age
def greeting(self):
return f'My name is {self.name} and I am {self.age}'
def increase_age(self):
self.age += 1
# Extends class
class Customer(User):
def __init__(self, name, email, age):
self.name = name
self.email = email
self.age = age
self.balance = 0
def set_balance(self, balance):
self.balance = balance
def greeting(self):
return f'My name is {self.name} and I am {self.age} and my balance is {self.balance}'
# Init user object
brad = User('Brad Traversy', 'brad@gmail.com', 37)
print(type(brad), brad)
janet = Customer('Janet Z', 'janet@gmail.com', 57)
print(type(janet), janet)
janet.set_balance(500)
print(janet.greeting())
# Access properties
print(brad.name, brad.email, brad.age)
# Run method on class
print(brad.greeting())
brad.increase_age()
print(brad.greeting()) |
87510f359917c5655e65b842d39c5e6d97656701 | kaynat149/CPS-3320 | /hangman.py | 846 | 3.9375 | 4 | from random import choice
word = choice(["Binary", "Bitmap", "Driver", "Editor", "Google",
"Laptop", "Parser", "Router", "Python", "Update"])
guessed = []
wrong = []
tries = 6
while tries > 0:
out = ""
for letter in word:
if letter in guessed:
out = out + letter
else:
out = out + "_"
if out == word:
break
print("Guess the a letter:", out)
print(tries, "chances left")
guess = input()
if guess in guessed or guess in wrong:
print("This word has been guessed already", guess)
elif guess in word:
print("GREAT JOB!")
guessed.append(guess)
else:
print("BAD GUESS!")
tries = tries - 1
wrong.append(guess)
print()
if tries:
print("GREAT JOB!", word)
else:
print("You didn't get", word)
|
7f3a1e22abc5ad919d8681847bad9097f41b631d | haitaka/mad | /src/main/python/test.py | 271 | 3.578125 | 4 |
N1 = 10
N2 = 20
M = 24
delta = 10**(-3)
def x(i):
t = i - N1
if t in range(-N1, 0):
return - float(t) / float(N1)
elif t in range(0, N2):
return float(t) / float(N2)
if __name__ == '__main__':
print([x(i) for i in range(0, N2 + N1)])
|
2a5e7d076fedc19e4dc9ad03dfbcf35826a06b67 | OncDocCoder/projects | /distance.py | 1,529 | 3.859375 | 4 | import math
blue = False
while blue == False:
dims = input('how many dimensions (2 or 3)?')
if dims == '2':
value_1 = (input('first point, x and y'))
x1, y1 = value_1.split(',')
x1, y1 = float(x1), float(y1)
value_2 = (input('second point x and y'))
x2, y2 = value_2.split(',')
x2, y2 = float(x2), float(y2)
distance_x = x2 -x1
distance_y = y2 - y1
x_sqrd = math.pow(distance_x, 2)
y_sqrd = distance_y**2
final_distance = math.sqrt(x_sqrd + y_sqrd)
print('the distance is {:.2f}'.format(final_distance))
response = input('do you want to go again y/n'.lower())
if response == 'n':
raise SystemExit
if dims == '3':
value_1 = (input('first point, x, y and z'))
x1, y1, z1 = value_1.split(',')
x1, y1, z1 = float(x1), float(y1), float(z1)
value_2 = (input('second point x, y, and Z'))
x2, y2, z2 = value_2.split(',')
x2, y2, z2 = float(x2), float(y2), float(z2)
distance_x = x2 -x1
distance_y = y2 - y1
distance_z = z2 - z1
x_sqrd = math.pow(distance_x, 2)
y_sqrd = distance_y**2
z_sqrd = math.pow(distance_z, 2)
final_distance = math.sqrt(x_sqrd + y_sqrd +z_sqrd)
print('the distance is {:.2f}'.format(final_distance))
response = input('do you want to go again y/n'.lower())
if response == 'n':
raise SystemExit |
0bf1af41e1afa7b7a5ebc0a9a08663ce138b1e8b | OncDocCoder/projects | /elipses.py | 2,593 | 3.625 | 4 | #x2/a2 + y2/b2 = 1
import matplotlib
import math
# a>b
# the length of the major axis is 2a
# the coordinates of the vertices are (±a,0)
# the length of the minor axis is 2b
# the coordinates of the co-vertices are (0,±b)
# the coordinates of the foci are (±c,0)
# , where c2=a2−b2.
#(x-h)^2/a^2 + (y-v)^2/b^2 = 1 horizontal
#center is (h, v)
#major axis is 2*a
#minor axis is 2*b
#(x-h)^2/b^2 + (y-v)^2/a^2 = 1
both_verticies = (input('do you know both verticies?'))
if both_verticies == 'y':
value_l = (input('first axis verticie, x and y'))
xl, yl = value_l.split(',')
xl, yl = float(xl), float(yl)
value_r = (input('second axis verticies, x and y'))
xr, yr = value_r.split(',')
xr, yr = float(xr), float(yr)
h = (xl + xr) / 2
a = (xr - h)
value_t = (input('upper co verticie, x and y'))
xt, yt = value_t.split(',')
xt, yt = float(xt), float(yt)
value_b = (input('lower co verticies, x and y'))
xb, yb = value_b.split(',')
xb, yb = float(xb), float(yb)
v = (yt + yb) / 2
b = (yt - v)
f = math.sqrt(a**2 - b**2)
value_f = (input('what are the foci x and y'))
if value_f == '':
pass
else:
xf, yf = valuef.split(',')
xf, yf = float(xf), float(yf)
c2 = xf ** 2
# a2 = h**2
# b2 = a2 - c2
print('the equation for the elipse is x2/',a**2, ' + y2/', b**2, ' = 1')
print('the centerpoint is ', h, ', ', v)
print('the focus is {:.2f}'.format (f))
else:
single_verticies = (input('do you know one of the verticies?'))
if single_verticies == 'y':
value_l = (input('left end point of the verticie, x and y'))
xl, yl = value_l.split(',')
xl, yl = float(xl), float(yl)
value_r = (input('right end point of the verticie, x and y'))
xr, yr = value_r.split(',')
xr, yr = float(xr), float(yr)
h = (xl + xr) / 2
a = (xr - h)
foci = (input('do you know the foci?'))
if foci == 'y':
focus_l = (input('left end point of the focus, x and y'))
flx, fly = focus_l.split(',')
flx, fly = float(flx), float(fly)
focus_r = (input('right end point of the focus, x and y'))
frx, fry = focus_r.split(',')
frx, fry = float(frx), float(fry)
f_sqrd = frx**2
b = f_sqrd - a**2
print('the equation for the elipse is x2/', a ** 2, ' + y2/', round(abs(b), 0), ' = 1')
else:
raise SystemExit
|
527d334d8909c84b131250c70d53c402556b1d30 | Manishthakur1297/Card-Game | /Card_Game.py | 5,225 | 3.953125 | 4 | import random
class Game:
# Intialize Cards and Players
def __init__(self, n):
self.size = n
self.card_names = {1: "A", 2:"2", 3:"3", 4:"4", 5:"5", 6:"6", 7:"7", 8:"8", 9:"9", 10:"10", 11:"J", 12:"Q", 13:"K"}
self.card_values = {"A": 1, "2": 2, "3": 3, "4": 4, "5": 5, "6": 6, "7": 7, "8": 8, "9": 9, "10": 10, "J": 11, "Q": 12, "K": 13}
self.card_quantity = dict()
self.players = [["_" for i in range(3)] for j in range(n)]
# Distribute cards to players
def distributeCards(self):
for i in range(self.size):
for j in range(3):
self.players[i][j] = self.findUniqueCard()
# Find Unique Random Card
def findUniqueCard(self):
value = random.randint(1,13)
card_name = self.card_names[value]
if card_name in self.card_quantity:
if self.card_quantity[card_name] < 4:
self.card_quantity[card_name] += 1
else:
self.findUniqueCard()
else:
self.card_quantity[card_name] = 1
return card_name
# Print Players Cards
def printCards(self):
for i,player in enumerate(self.players):
print("Player",i+1,":",player)
# Condition 1 -> 3 cards of the same number like 3,3,3
def condition1(self,player):
if len(set(player))==1:
return True
return False
# Condition 2 -> Numbers in order like 4,5,6
def condition2(self,player):
player = sorted([self.card_values[i] for i in player])
if player[0]+1==player[1] and player[1]+1==player[2]:
return True
return False
# Condition 3 -> Pair of Cards like two Kings or two 10s
def condition3(self, player):
player = sorted([self.card_values[i] for i in player])
if player[0] == player[1] or player[1] == player[2]:
return True
return False
# Condition 4 -> Maximum Sum of All 3 cards Win
def condition4(self, players):
sm = []
for i,player in enumerate(players):
tmp = 0
for j in player:
tmp+=self.card_values[j]
sm.append(tmp)
print("\n=====Players Card Sum =====")
print(sm)
mx = max(sm)
if sm.count(mx)==1:
return sm.index(mx)
else:
filter_players = [i for i in range(len(sm)) if sm[i] == mx]
return self.tieWinner(filter_players)
# Winner Function -> Check Each condition One by One
def winner(self):
tmp = [0]*self.size
tmp_count = {}
for i,v in enumerate(self.players):
if self.condition1(v):
tmp[i] = 1
if '1' not in tmp_count:
tmp_count['1'] = 1
else:
tmp_count['1'] += 1
elif self.condition2(v):
tmp[i] = 2
if '2' not in tmp_count:
tmp_count['2'] = 1
else:
tmp_count['2'] += 1
elif self.condition3(v):
tmp[i] = 3
if '3' not in tmp_count:
tmp_count['3'] = 1
else:
tmp_count['3'] += 1
if sum(tmp)==0:
return self.condition4(self.players)
else:
if '1' in tmp_count:
if tmp_count['1']>1:
filter_players = [i for i in range(len(tmp)) if tmp[i] == 1]
return self.tieWinner(filter_players)
else:
return tmp.index(1)
elif '2' in tmp_count:
if tmp_count['2']>1:
filter_players = [i for i in range(len(tmp)) if tmp[i] == 2]
return self.tieWinner(filter_players)
else:
return tmp.index(2)
elif '3' in tmp_count:
if tmp_count['3'] > 1:
filter_players = [i for i in range(len(tmp)) if tmp[i] == 3]
return self.tieWinner(filter_players)
else:
return tmp.index(3)
# Tie Winner -> Draws New Cards till Winner declared
def tieWinner(self, players):
print("\n===== Tie Condition =======\n")
print("=== Players Tie Indexes ====")
print(players)
arr = [0] * len(players)
mx = -1
for i in range(len(players)):
card_name = self.findUniqueCard()
card_value = self.card_values[card_name]
if card_name=='A':
arr[i] = 14
else:
arr[i] = card_value
if mx<arr[i]:
mx = arr[i]
print("\n==== New Cards Drawn for Each Tie Player ====");
print(arr)
count = arr.count(mx)
if count==1:
return players[arr.index(mx)]
else:
filter_players = [players[i] for i in range(len(players)) if arr[i] == mx]
return self.tieWinner(filter_players)
# Game Object
if __name__ == '__main__':
card = Game(4)
card.distributeCards()
card.printCards()
print("\nPlayer",card.winner()+1,"Wins!!")
|
ed972573af7247640ecaafc94c09b096cce1e838 | karelbondan/Intro_to_program | /1.py | 226 | 4.0625 | 4 | # -*- coding: utf-8 -*-
"""
Created on Mon Sep 21 12:37:57 2020
@author: karel
"""
degrees = eval(input("Enter number= "))
radians = degrees*3.14/180
print("Degrees:", degrees)
print("Radians:", degrees*3.14/180)
|
8a8c5b36cafb18508e837b9d398c9d3516aaa5a5 | mintas123/MIW | /Class04/knn.py | 3,584 | 3.546875 | 4 | import numpy as np # for data
from matplotlib import pyplot as plt # for visualization
import math # for square root
from sklearn.preprocessing import LabelEncoder # for labeling data
from scipy.stats import mode # for voting
plt.style.use('seaborn-whitegrid')
def plot_dataset(f, l):
# Females
x0 = f[l == 0, 0]
y0 = f[l == 0, 1]
plt.plot(x0, y0, 'ok', label='all Females')
# Males
x1 = f[l == 1, 0]
y1 = f[l == 1, 1]
plt.plot(x1, y1, 'or', label='all Males')
def plot_neighbors(f, l):
x = f[:, 0]
y = f[:, 1]
k = len(f)
plt.plot(x, y, 'oy', label=f'{k} neighbors')
def plot_query(q, p):
x = q[0]
y = q[1]
label = 'Male' if p[0] == 1 else 'Female'
plt.plot(x, y, 'sg', label=f'It\'s a {label}')
print(f'Height: {x}')
print(f'Wight: {y}')
print(f'Class: {label}')
def load_data():
raw_data = []
# with open('500_Person_Gender_Height_Weight_Index.csv', 'r') as file:
with open('weight-height.csv', 'r') as file:
# Discard the first line (headings)
next(file)
# Read the data into a table
for line in file.readlines():
data_row = line.strip().split(',')
raw_data.append(data_row)
return np.array(raw_data)
def euclidean_distance(point1, point2):
sum_squared_distance = 0
for i in range(len(point1)):
sum_squared_distance += math.pow(point1[i] - point2[i], 2)
return math.sqrt(sum_squared_distance)
def manhattan_distance(point1, point2):
pass
def preprocess(raw_data):
le = LabelEncoder()
label_rows = []
features = []
labels = []
for row in raw_data:
feature_row = list(map(float, row[1:3]))
# select feature data
# label = row[0][1:-1]
label = row[0]
features.append(feature_row)
label_rows.append(label)
# transform categorical data (labels)
labels = le.fit_transform(label_rows)
return np.array(features), np.array(labels)
def knn(features, labels, query, k, distance_fn):
all_neighbors = []
for index, sample in enumerate(features):
# 1
distance = distance_fn(sample, query)
all_neighbors.append((distance, index)) # it's a tuple!
# 2
sorted_all_neighbors = sorted(all_neighbors)
# 3
k_neighbor_distances = sorted_all_neighbors[:k]
# print(np.array([labels[index] for _, index in k_neighbor_distances]))
# 4
k_labels = np.array([labels[index] for _, index in k_neighbor_distances])
k_neighbors = np.array([features[index] for _, index in k_neighbor_distances])
return k_neighbors, k_labels, mode(k_labels) # mode == voting for the class
def main():
data = load_data() # how many columns? what are they?
plt.xlabel('height [inches]')
plt.ylabel('weight [pounds]')
k = 10
features, labels = preprocess(data) # how do we split features/labels? what are we doing with N/A or '2,1'?
plot_dataset(f=features, l=labels)
query = np.array(
[70, 175]
) # what if it's a 2D array with rows as queries?
k_neighbors, k_classes, predicted_class = knn(features,
labels,
query=query,
k=k,
distance_fn=euclidean_distance) # distance
plot_neighbors(f=k_neighbors, l=k_classes)
plot_query(q=query, p=predicted_class)
plt.legend()
plt.show()
main()
|
3f30e91059cba3f37fb76224ab070c369a250611 | Demondul/python_algos | /functionIntermediateII.py | 1,057 | 3.578125 | 4 | # PART I
""" students = [
{'first_name': 'Michael', 'last_name' : 'Jordan'},
{'first_name' : 'John', 'last_name' : 'Rosales'},
{'first_name' : 'Mark', 'last_name' : 'Guillen'},
{'first_name' : 'KB', 'last_name' : 'Tonel'}
]
for student in students:
print(str(student["first_name"]) + " " + str(student["last_name"])) """
###################
# PART II
users = {
'Students': [
{'first_name': 'Michael', 'last_name' : 'Jordan'},
{'first_name' : 'John', 'last_name' : 'Rosales'},
{'first_name' : 'Mark', 'last_name' : 'Guillen'},
{'first_name' : 'KB', 'last_name' : 'Tonel'}
],
'Instructors': [
{'first_name' : 'Michael', 'last_name' : 'Choi'},
{'first_name' : 'Martin', 'last_name' : 'Puryear'}
]
}
for userType in users:
print(str(userType))
for user in users[userType]:
fName=str(user["first_name"])
lName=str(user["last_name"])
fullName=fName+lName
print("1 - " + fName + " " + lName + " - " + str(len(fullName)))
|
6acb4ba5dcc6ae13f0ca0552cacee774b249218f | Demondul/python_algos | /store.py | 392 | 3.53125 | 4 | import product
class Store:
def __init__(self,products,address,owner):
self.products=products
self.address=address
self.owner=owner
def add_product(item):
self.products.append(item)
def remove_product(item_name):
for item in range(0,len(self.products)):
if self.products[item].item_name == item_name:
|
c12890b5a29c284c0cd5bdc4591ea94e057ac06b | Sammyalhashe/CSC_Course_Work | /twoSum_withIceCream.py | 2,466 | 3.59375 | 4 | '''input
"2"
"4"
"5"
"1 4 5 3 2"
"4"
"4"
"2 2 4 3"
'''
class tuples2:
def __init__(self, val1, val2):
self.tupl = (val1, val2)
def comparitor(self):
return self.tupl[1]
t = int(input().strip())
for a0 in range(t):
m = int(input().strip())
n = int(input().strip())
a = list(map(int, input().strip().split(' ')))
# This next line is messy (I know), but what it does is takes the array, a, and then turns it into a sorted array
# based on the price value (the second value in the enumeration) and places the result into a 2 valued tuple object I created.
# To sort, it uses python's sorting function and sorts based on the price value (key takes a function of one paramater, in this
# case comparitor, and applies it to all elements in the list and sorts based on the result). The comparitor returns the second
# value of the tuple (the price). I then take that sorted array of tuple2
# objects, and make it look nicer.
final = list(map(lambda x: x.tupl, sorted(
[tuples2(i, j) for i, j in enumerate(a)], key=tuples2.comparitor)))
# Logic: Greedy Algorithm
# 1) Choose the largest priced item first, if it's too large, remove it as an option
# 2) If I haven't bought anything yet, try to buy one and see if you have an exact amount of money left for one of the items left
# if you don't remove it as an option
# 3) Otherwise, buy an item and subtract from the money you have available
bought = 0
ice_cream = []
while m > 0 or bought != 2:
if(final != []):
if(m < final[-1][1]):
final.pop()
else:
# Theoretically buy an ince-cream, if you can't buy anything
# else after you bought the current one you shouldn't have
# bougthen it in the first place
if(len(list(filter(lambda x: x[1] == m - final[-1][1], final[:len(final) - 1]))) == 0 and bought == 0):
final.pop()
else:
m -= final[-1][1]
bought += 1
# plus 1 due to indexing
ice_cream.append(str(final[-1][0] + 1))
final.pop() # pop because we choose distinct flavours and not the same multiple times: remove the option
else:
print("No two sum solution")
break
print(" ".join(sorted(ice_cream, key=lambda x: int(x))))
|
b92950bff370296369bee2e13b4f1e8d3cbcf79a | Sammyalhashe/CSC_Course_Work | /FindInversions.py | 1,045 | 4.09375 | 4 | def merge(left, right):
swaps = 0
result = []
i, j = 0, 0
while (len(left) > i and len(right) > j):
if left[i] <= right[j]:
result.append(left[i])
i += 1
else:
swaps += len(left) - i
result.append(right[j])
j += 1
if i == len(left) or j == len(right):
result.extend(left[i:] or right[j:])
break
return result, swaps
def mergesort(lists):
if len(lists) < 2:
return lists, 0
else:
middle = (len(lists) // 2)
left, swaps0 = mergesort(lists[:middle])
right, swaps1 = mergesort(lists[middle:])
res, swaps = merge(left, right)
return res, (swaps + swaps0 + swaps1)
def countInversions(arr):
# Complete this function
sort_arr, swaps = mergesort(arr)
return sort_arr, swaps
if __name__ == '__main__':
test = [1, 32, 122, 32, 12, 311, 2, 3, 21, 2]
result, no_swaps = countInversions(test)
print("sorted array:", result, "swaps:", no_swaps)
|
7b2a85d1a6226de574ba11269572c80480f6cc9f | Sammyalhashe/CSC_Course_Work | /Merge_Sort_Pythonic.py | 1,686 | 4 | 4 | '''input
10
"12 4 19 3 2"
"2 8 9 17 7"
"2 3 15 9 4"
"16 10 20 4 17"
"18 11 7 20 12"
"19 1 3 12 9"
"13 5 7 9 6"
"9 18 3 16 10"
"16 18 6 3 9"
"1 10 14 19 6"
'''
# More pythonic implementation of merge sort
def Merge_Sort_Pythonic(array):
return mergesort_Pythonic(array)
def mergesort_Pythonic(array):
if(len(array) < 2):
return array
# Integer division for middle index
mid = ((len(array)) // 2)
# Merge-sort left and right halves
left = mergesort_Pythonic(array[:mid])
right = mergesort_Pythonic(array[mid:])
res = merge(left, right)
return res
def merge(left, right):
# size = right - left + 1 #len(temp)?
i, j, ind = 0, 0, 0
l, r = len(left), len(right)
length = l + r
temp = [0 for i in range(length)]
while(len(left) > i and len(right) > j):
if(left[i] < right[j]):
temp[ind] = left[i]
i += 1
else:
temp[ind] = right[j]
j += 1
ind += 1
# Once one of either left_ind or right_ind goes out of bounds, we have to copy into temp the rest of
# the elements
# Note: inly one of these loops will execute as one of right_ind or left_ind will have already reached
# it's boundary value
if i == len(left) or j == len(right):
temp.extend(left[i:] or right[j:])
break
return temp
if __name__ == '__main__':
test = [1, 32, 122, 32, 12, 311, 2, 3, 21, 2]
result = Merge_Sort_Pythonic(test)
print(result)
t = input()
for i in range(t):
test = list(map(lambda x: int(x), input().strip().split(' ')))
tested = Merge_Sort_Pythonic(test)
print(tested)
|
c87810a69b35215a9e8590580dd19a75ccd5029e | Sammyalhashe/CSC_Course_Work | /minimizeUnfairness.py | 1,589 | 3.890625 | 4 | """Greedy Algorithm minimizes unfairness of an array by choosing K values
unfairness == max(x0,x1,...,xk)-min(x0,x1,...,xk)
Variables:
int: N -> number of elements in list
int: K -> number of list elements to choose
list: vals -> list to minimize unfairness
Example Input:
10 (N)
4 (K)
(The Rest are list elements)
1
2
3
4
10
20
30
40
100
200
Example Output:
3 (the minimum unfairness)
"""
def calcUnfairness(reduced_array):
return (reduced_array[-1] - reduced_array[0])
def minimizeUnfairness(n, k, arr):
unfairness = (arr[k - 1] - arr[0])
if len(arr) == k or len(arr) == 1:
unfairness = calcUnfairness(arr)
else:
for i in range(1, n - (k - 1)):
if((arr[i + k - 1] - arr[i]) < unfairness):
unfairness = (arr[i + k - 1] - arr[i])
if(unfairness == 0):
break
print(unfairness)
# First Greedy Idea: Farthest from average remove and test again
# average = int(sum(arr)/len(arr))
# ldev = int(abs(arr[-1]-average))
# sdev = int(abs(arr[0]-average))
# if (ldev>=sdev):
# sorts.pop()
# return minimizeUnfairness(k,sorts)
# else:
# sorts.pop(0)
# return minimizeUnfairness(k,sorts)
if __name__ == '__main__':
N = int(input().strip())
K = int(input().strip())
vals = []
for i in range(N):
vals.append(int(input().strip()))
if(K == 0):
print("Should at least be 1")
else:
reduced_arr = minimizeUnfairness(N, K, sorted(vals)) |
304d59ca7759125373f19c497c664438c7f78b14 | DinaShaim/GB_Algorithms_data_structures | /Les_5_HomeWork/les_5_task_1.py | 2,114 | 3.515625 | 4 | # Пользователь вводит данные о количестве предприятий, их наименования и прибыль
# за 4 квартал (т.е. 4 числа) для каждого предприятия.
# Программа должна определить среднюю прибыль (за год для всех предприятий) и
# отдельно вывести наименования предприятий, чья прибыль выше среднего и ниже среднего.
from collections import Counter
print('Введите количество предприятий:')
n = int(input())
i = 0
company_array = [0]*n
total_profit = 0
for i in range(len(company_array)):
print('Введите название предприятия:')
company_name = input()
print('Введите последовательно прибыль за 4 квартала данного предприятия:')
qrt1 = input()
qrt2 = input()
qrt3 = input()
qrt4 = input()
summa_profit = int(qrt1) + int(qrt2) + int(qrt3) + int(qrt4)
company_array[i] = Counter(name=company_name, quarter_1=qrt1, quarter_2=qrt2, quarter_3=qrt3,
quarter_4=qrt4, profit=summa_profit)
total_profit += company_array[i]['profit']
average_profit = total_profit/n
print(f"Средняя прибыль за год для всех предприятий = {average_profit}.")
print()
print('Предприятия, чья прибыль выше средней:')
for i in range(len(company_array)):
if float(company_array[i]['profit']) > average_profit:
print(f"Предприятие {company_array[i]['name']} с прибылью {company_array[i]['profit']}.")
print()
print('Предприятия, чья прибыль ниже средней:')
for i in range(len(company_array)):
if float(company_array[i]['profit']) < average_profit:
print(f"Предприятие {company_array[i]['name']} с прибылью {company_array[i]['profit']}.")
|
afbb4590c1e77843dc2dbdcc20f77fa75716d2dd | DinaShaim/GB_Algorithms_data_structures | /Les_1_HomeWork/les_1_task_5.py | 811 | 3.984375 | 4 | #Пользователь вводит две буквы. Определить, на каких местах алфавита они стоят,
# и сколько между ними находится букв.
import string
print("Введите две строчные буквы латинского алфавита от a до z:")
letter1 = str(input("первая буква = "))
letter2 = str(input("вторая буква = "))
index1 = ord(letter1) - ord("a") +1
index2 = ord(letter2) - ord("a") +1
s = abs(index1 - index2) -1
print("Буква %c является %d буквой алфавита" % (letter1, index1))
print("Буква %c является %d буквой алфавита" % (letter2, index2))
print(f'Между ними находится букв: {s}')
|
b2a620d6e016513b0c8eeddc1fdf4f48206c0e49 | DinaShaim/GB_Algorithms_data_structures | /Les_4_HomeWork/les_4_task_1.py | 8,303 | 4.3125 | 4 | # Проанализировать скорость и сложность одного любого алгоритма из разработанных
# в рамках домашнего задания первых трех уроков.
# Задание № 2 урока № 2:
# Посчитать четные и нечетные цифры введенного натурального числа.
# Например, если введено число 34560, в нем 3 четные цифры (4, 6 и 0) и 2 нечетные (3 и 5).
# 1 Вариант
import timeit
import cProfile
even = 0 # четный
odd = 0 # нечентый
def counting_recursion(x, even=even, odd=odd):
if ((x % 10) % 2) == 0:
even = even + 1
else:
odd = odd + 1
if (x // 10) != 0:
return counting_recursion(x // 10, even=even, odd=odd)
return even, odd
# 2 Вариант
def counting_while(x, even=even, odd=odd):
while True:
if ((x % 10) % 2) == 0:
even = even + 1
else:
odd = odd + 1
x = x // 10
if not x != 0:
break
return even, odd
# 3 Вариант
def counting_list(x, even=even, odd=odd):
array_numbers = [x % 10]
while (x // 10) != 0:
x = x // 10
a = x % 10
array_numbers.append(a)
for j in range(len(array_numbers)):
if array_numbers[j] % 2 == 0:
even = even + 1
else:
odd = odd + 1
return even, odd
A1 = 1e+3
A2 = 1e+7
A3 = 1e+15
A4 = 1e+31
A5 = 1e+63
A6 = 1e+127
print(timeit.timeit('counting_recursion(A1)', number=100, globals=globals())) # 0.0009046000000000054
print(timeit.timeit('counting_recursion(A2)', number=100, globals=globals())) # 0.0020120000000000138
print(timeit.timeit('counting_recursion(A3)', number=100, globals=globals())) # 0.004119700000000004
print(timeit.timeit('counting_recursion(A4)', number=100, globals=globals())) # 0.007559099999999985
print(timeit.timeit('counting_recursion(A5)', number=100, globals=globals())) # 0.015897899999999993
print(timeit.timeit('counting_recursion(A6)', number=100, globals=globals())) # 0.0371291
print()
print(timeit.timeit('counting_while(A1)', number=100, globals=globals())) # 0.0005190999999999946
print(timeit.timeit('counting_while(A2)', number=100, globals=globals())) # 0.0009889000000000148
print(timeit.timeit('counting_while(A3)', number=100, globals=globals())) # 0.0019822999999999924
print(timeit.timeit('counting_while(A4)', number=100, globals=globals())) # 0.004015200000000024
print(timeit.timeit('counting_while(A5)', number=100, globals=globals())) # 0.009873900000000019
print(timeit.timeit('counting_while(A6)', number=100, globals=globals())) # 0.018753200000000025
print()
print(timeit.timeit('counting_list(A1)', number=100, globals=globals())) # 0.0010371999999999604
print(timeit.timeit('counting_list(A2)', number=100, globals=globals())) # 0.001844300000000021
print(timeit.timeit('counting_list(A3)', number=100, globals=globals())) # 0.0035182999999999742
print(timeit.timeit('counting_list(A4)', number=100, globals=globals())) # 0.0069190000000000085
print(timeit.timeit('counting_list(A5)', number=100, globals=globals())) # 0.015661900000000006
print(timeit.timeit('counting_list(A6)', number=100, globals=globals())) # 0.035929199999999994
# Все разработанные алгоритмы имеют линейную вычислительную сложность:
# Вариант с рекурсией пораждает вызов одной рекурсивной фукнции, что соотвествует линейной сложности O(n)
# Решение с циклом while будет реализован n раз, т.е. получаем O(n)
# Третий вариант решения цикл while пробегает n раз и формирует массив,
# далее цикл for аналогично пробегает n раз. Тогда O(n+n) = O(n), т.е. тоже линейная вычислительная сложность.
# Проведенный анализ подтверждается полученными временными значениями функции timeit,
# где с увеличением n в 2 раза, время увеличивается тоже примерно в 2 раза.
print()
cProfile.run('counting_recursion(A1)')
# 7 function calls (4 primitive calls) in 0.000 seconds
#
# Ordered by: standard name
# ncalls tottime percall cumtime percall filename:lineno(function)
# 1 0.000 0.000 0.000 0.000 <string>:1(<module>)
# 4/1 0.000 0.000 0.000 0.000 les_4_task_1.py:13(counting_recursion)
# 1 0.000 0.000 0.000 0.000 {built-in method builtins.exec}
# 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects}
cProfile.run('counting_recursion(A2)')
cProfile.run('counting_recursion(A3)')
cProfile.run('counting_recursion(A4)')
cProfile.run('counting_recursion(A5)')
cProfile.run('counting_recursion(A6)')
# 131 function calls (4 primitive calls) in 0.001 seconds
# Ordered by: standard name
# ncalls tottime percall cumtime percall filename:lineno(function)
# 1 0.000 0.000 0.001 0.001 <string>:1(<module>)
# 128/1 0.000 0.000 0.000 0.000 les_4_task_1.py:13(counting_recursion)
# 1 0.000 0.000 0.001 0.001 {built-in method builtins.exec}
# 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects}
print()
cProfile.run('counting_while(A1)')
cProfile.run('counting_while(A2)')
cProfile.run('counting_while(A3)')
cProfile.run('counting_while(A4)')
cProfile.run('counting_while(A5)')
cProfile.run('counting_while(A6)')
# 4 function calls in 0.000 seconds
# Ordered by: standard name
# ncalls tottime percall cumtime percall filename:lineno(function)
# 1 0.000 0.000 0.000 0.000 <string>:1(<module>)
# 1 0.000 0.000 0.000 0.000 les_4_task_1.py:25(counting_while)
# 1 0.000 0.000 0.000 0.000 {built-in method builtins.exec}
# 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects}
print()
cProfile.run('counting_list(A1)')
cProfile.run('counting_list(A2)')
cProfile.run('counting_list(A3)')
cProfile.run('counting_list(A4)')
cProfile.run('counting_list(A5)')
cProfile.run('counting_list(A6)')
# 132 function calls in 0.001 seconds
# Ordered by: standard name
# ncalls tottime percall cumtime percall filename:lineno(function)
# 1 0.000 0.000 0.000 0.000 <string>:1(<module>)
# 1 0.000 0.000 0.000 0.000 les_4_task_1.py:38(counting_list)
# 1 0.000 0.000 0.001 0.001 {built-in method builtins.exec}
# 1 0.000 0.000 0.000 0.000 {built-in method builtins.len}
# 127 0.000 0.000 0.000 0.000 {method 'append' of 'list' objects}
# 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects}
# Анализируя результаты, проведенного профилирования, можно отметить, что вызовы всех функций были выполнены
# за 0.000 секунд, что говорит об отсутствии слабых (медленных) мест.
# Необходимо отметить, что в первом и третьем методах решений количество вызовов функций
# растет прямопропорционально n, что требует большего времени выполнения методов.
# Во втором алгоритме всегда происходит вызов 4 функций, что делает этот
# метод решения самым быстрым (что подтверждается вычислительными значениями функции timeit)
# и неиболее оптимальным.
|
c676c6a3e43c95656e6643a30a91120a3e3f9e4e | openseg-group/openseg.pytorch | /lib/utils/tools/average_meter.py | 626 | 3.59375 | 4 | #!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author: Donny You (youansheng@gmail.com)
# Utils to store the average and current value.
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
class AverageMeter(object):
""" Computes ans stores the average and current value"""
def __init__(self):
self.reset()
def reset(self):
self.val = 0.
self.avg = 0.
self.sum = 0.
self.count = 0
def update(self, val, n=1):
self.val = val
self.sum += val * n
self.count += n
self.avg = self.sum / self.count
|
c9690b333c631fa91c79405707d45182ce1874f8 | Doodlebug511/hello-world | /myscraper.py | 2,412 | 3.8125 | 4 | # basic web page scraper as final project for bootcamp...
# import needed modules
import requests
from bs4 import BeautifulSoup
import pandas as pd
# bring desired webpage into python and create soup object via beautifulsoup
url = 'https://pauladeen.com/recipe/mashed-potatoes-with-sautaed-mushrooms/'
# url = 'https://pauladeen.com/recipe/hash-brown-quiche/'
# url = 'https://pauladeen.com/recipe/paulas-sugared-rose-parade-layer-cake/'
r = requests.get(url)
# parse website into soup object
soup = BeautifulSoup(r.text, 'html.parser')
# different parsers for different websites and output, these are the main ones
# soup = BeautifulSoup(r.text, 'lxml.parser')
# will need a pip install of lxml first
# soup = BeautifulSoup(r.text, 'html5lib.parser')
# pip install of html5lib first
# main container for soup object
records = []
# adding title text to records array
records.append(soup.find('title').text)
# adding spacer between texts for readability
records.append(' ')
print(soup.find('title').text)
print()
# for title of saved csv file
recipe_title = soup.find('title').text
recipe_title = str(recipe_title) + '.csv'
recipe_title = recipe_title.replace('|', '-')
# url of recipe image from soup object
pic = soup.find('img', class_='img-fluid').get('data-src')
# add url of recipe image to main container
records.append('Picture of finished dish...')
records.append(pic)
records.append(' ')
print('Picture of finished dish...')
print(pic)
print()
# create list of ingredients from soup object, add to container
records.append('Ingredients...')
ingredients = []
for results1 in soup.find_all('li', itemprop='ingredients'):
ingredients.append(results1.text)
records.append(results1.text)
records.append(' ')
print('Ingredients...')
for item in ingredients:
print(item)
print()
# create list of instructions from soup object, add to container
records.append('Directions...')
directions = []
for results in soup.find_all('p'):
directions.append(results.text)
records.append(results.text)
records.append(' ')
print('Directions...')
for item in directions:
print(item)
print()
# create data frame object out of records
df = pd.DataFrame(records)
# send to folder of source file as .csv file, open with spreadsheet app(excel)
df.to_csv(recipe_title, index=False, encoding='utf-8')
|
ec6d2983bfe00b677d39b49759406dc482e60fd0 | vankhoakmt/pyHTM | /pyhtm/support/getsetstate.py | 1,134 | 3.890625 | 4 | def GetSomeVars(self, names):
"""Grab selected attributes from an object.
Used during pickling.
Params:
names: A sequence of strings, each an attribute name strings
Returns:
a dictionary of member variable values
"""
return {i: getattr(self, i) for i in names}
def CallReader(self, readFunc, parents, state):
"""Call the function specified by name string readFunc on self
with arguments parents and state: i.e.
self.readFunc(parents, state)
Params:
self: Object to call readFunc callable on
readFunc: String name of a callable bound to self
parents: Arbitrary argument to be passed to the callable
state: Arbitrary argument to be passed to the callable
"""
getattr(self, readFunc)(parents, state)
def UpdateMembers(self, state):
"""Update attributes of self named in the dictionary keys in state
with the values in state.
Params:
self: Object whose attributes will be updated
state: Dictionary of attribute names and values
"""
for i in state.keys():
setattr(self, i, state[i])
|
b3b7bab386391dab91910d4bd64a5c094da05a94 | shwetasharma18/test_questions | /insert.py | 359 | 3.859375 | 4 | def insertion_sort(num):
i = 1
while i < len(num):
temp = num[i]
j = i - 1
while j >= 0 and temp < num[j]:
num[j+1] = num[j]
j = j -1
num[j+1] = temp
i = i + 1
return num
l = [5,7,3,9,8,2,4,1]
print insertion_sort(l) |
eba24ce1802c67d7f48289e4abd88f0084ea317b | abd124abd/algo-toolbox | /week3/1.py | 356 | 3.671875 | 4 | #python3
# money change
import sys
def get_money_change(n):
count = 0
if n <= 0: return 0
denominations = [10,5,1]
for i in denominations:
count = count + int(n / i)
n = n % i
return count
if __name__ == '__main__':
input = sys.stdin.read()
n = int(input)
print(get_money_change(n))
|
3eb6094bde8eb1a842fd4cbcbd0049cb2fd81373 | abd124abd/algo-toolbox | /week2/8.py | 863 | 3.96875 | 4 | #python3
# last digit of sum of squares of fib
from sys import stdin
# last digit sum of squares at n = ((last digit at n) * (last digit at n + 1)) % 10
def last_digit_sum_squares_fib(n):
if n <= 2: return n
last_digits = last_digits_fib(n+1)
return (last_digits[0] * last_digits[1]) % 10
def last_digits_fib(n):
n = (n) % pisano_period(10)
n_one, n_two = 0, 1
for i in range(2, n+1):
n_one, n_two = n_two, (n_one + n_two) % 10
return [n_one, n_two]
def pisano_period(m):
previous, current = 0, 1
end = m * m
for i in range(end):
mod = (previous + current) % m
previous, current = current, mod
if previous == 0 and current == 1:
return i + 1
if __name__ == '__main__':
n = int(stdin.read())
print(last_digit_sum_squares_fib(n))
|
91d55ae511d7b2c47a07569496d1e55d6bbc2204 | chrispoch/adventofcode | /13.py | 1,825 | 3.5625 | 4 | import os
import sys
debug = False
fileName = ""
try:
fileName = sys.argv[1]
if len(fileName) < 1:
fileName = "13.txt"
except:
fileName = "13.txt"
print(fileName)
with open(fileName) as file:
time = int(file.readline())
note = file.readline()
note2 = note.replace(",x","")
buses = note2.split(",")
for i in range(len(buses)):
buses[i] = int(buses[i])
leaves = []
for i in range(len(buses)):
leaves.append(time + buses[i] - (time % buses[i]))
min = leaves[0]
mini = 0
for i in range(len(leaves)):
if leaves[i] < min:
min = leaves[i]
mini = i
wait = leaves[mini] - time
print(buses[mini], wait, buses[mini] * wait)
#part 2
print("Part 2")
buses = note.split(",")
#print(buses)
for i in range(len(buses)):
if buses[i] == "x":
buses[i] = 0
else:
#print(buses[i])
buses[i] = int(buses[i])
leaves = []
for bus in buses:
leaves.append(0)
time = 0
step = 1
#influenced by https://gist.github.com/joshbduncan/65f810fe821c7a3ea81a1f5a444ea81e
"""Since you must find departure times for each bus based off of the previous bus schedule (which is based on the previous bus and so on...), all following buses must depart at a multiple of all previous buses departures since they have to stay in the order provided.
Step Progression
1 * 7 = 7
7 * 13 = 91
91 * 59 = 5369
5369 * 31 = 166439
Then you just need to add the cumulative time (t) and the minute offset for each bus in the list to get the final answer."""
p2 = [(int(i), j) for j, i in enumerate(buses) if i != 0]
for bus, offset in p2:
while (time + offset) % bus != 0:
time += step
step *= bus
print(time)
|
d5dee3c68ce06e1f95046d443f68c447be0af944 | korynewton/Intro-Python-II | /src/room.py | 783 | 3.59375 | 4 | # Implement a class to hold room information. This should have name and
# description attributes.
from item import Item
class Room:
n_to = None
s_to = None
e_to = None
w_to = None
def __init__(self, name, description):
self.name = name
self.description = description
self.items = []
def __repr__(self):
string_of_items = "\n".join([str(x) for x in self.items])
return f"\nCurrent Location: {self.name}...{self.description}.\n\n \
Items availabe: \n{string_of_items}"
def add_to_room(self, item):
self.items.append(item)
print(f'**{item.name} added to room**')
def remove_from_room(self, item):
self.items.remove(item)
print(f'**{item.name} removed from room**')
|
3b4ffa6d1ced6ad6b7328cd686d6cd5868dd6b18 | KuanHsuanTiffanyLin/stanCode-project | /stanCode Projects for GitHub/breakout_game/breakout.py | 1,535 | 3.953125 | 4 | """
stanCode Breakout Project
Adapted from Eric Roberts's Breakout by
Sonja Johnson-Yu, Kylie Jue, Nick Bowman,
and Jerry Liao
-----------------------------------------
SC101 - Assignment 2
File: breakout.py
Name: Tiffany Lin
"""
from campy.gui.events.timer import pause
from breakoutgraphics import BreakoutGraphics
FRAME_RATE = 1000 / 120 # 120 frames per second.
NUM_LIVES = 3 # Number of times the ball can hit bottom wall before the game ends.
def main():
"""
This program creates the Breakout Game.
A ball will be bouncing around the GWindow and
bounce back if it hits the walls, paddles or the bricks.
Bricks are removed if hit by the ball.
Player can use the paddle to prevent ball from falling out of
the bottom window by moving the mouse.
The game ends if all the bricks are removed or
the ball falls out of the bottom wall for over NUM_LIVES.
"""
graphics = BreakoutGraphics()
# Add animation loop here!
lives = NUM_LIVES
while True:
pause(FRAME_RATE)
while graphics.mouse_lock is True:
if graphics.ball_out():
lives -= 1
if lives > 0:
graphics.reset_ball()
break
elif lives <= 0:
break
if graphics.brick_left == 0:
break
graphics.move_ball()
graphics.handle_collision()
pause(FRAME_RATE)
if graphics.brick_left == 0:
break
if __name__ == '__main__':
main()
|
69b7fe0a027b868cc731e45c263387893e9db832 | Tsunamicom/Hackerrank-Solutions | /FromParagraphsToSentences.py | 702 | 3.859375 | 4 | # https://www.hackerrank.com/challenges/from-paragraphs-to-sentences
sample = input()
def processSentences(text):
sentence = []
isQuote = False
charCount = 0
sentenceTerminators = ['.', '?', '!']
for character in text:
sentence.append(character)
charCount += 1
if character in sentenceTerminators:
if isQuote == False:
if charCount >= 2:
print(''.join(sentence))
charCount = 0
sentence = []
elif character == '"':
if isQuote == False:
isQuote = True
else:
isQuote == False
processSentences(sample)
|
e425c1e23f27acc4519eea7506cbaebd75e747b1 | MiaoJiawei/Python-voltage-correct | /correct.py | 606 | 3.828125 | 4 | import matplotlib.pyplot as plt
def correct_func(voltage, current, resistance):
voltage_correct = []
for i in range(len(voltage)):
voltage_correct.append(voltage[i] - (current[i] * resistance))
return voltage_correct
voltage = [8.19,2.72,6.39,8.71,4.7,2.66,3.78]
current = [7.01,2.78,6.47,6.71,4.1,4.23,4.05]
resistance = 0.6134953432516345
'''
plt.figure(figsize=(8,6))
plt.grid(alpha=0.25)
plt.xlabel('Voltage')
plt.ylabel('Current')
plt.plot(voltage, current, label='raw data')
plt.plot(voltage_correct, current, label='corrected data')
plt.legend(loc='upper left')
plt.show()
''' |
f9684d6cafaf0381618bd01423b4a7227427e665 | brunston/goeuler | /3.py | 923 | 3.828125 | 4 | """
brunston 2016
Euler 3
"""
from math import ceil, sqrt
#make is_prime only search to square root
#make main() begin with low values that % = 0, then divide n by that value to get the corresponding
# big value and test *that* value for prime-ness.
def is_prime(n):
if n % 2 == 0:
return True
else:
for i in range(3,ceil(sqrt(n)),2):
#print("now dividing "+str(n)+" by "+str(i))
if (n % i) == 0:
return False
return True
def main():
n = 600851475143
limit_of_search = ceil(sqrt(n))
highest_prime_factor = 2
for i in range(n-2,limit_of_search,-2):
if n % i == 0:
print("found candidate"+str(i))
if (is_prime(i) == True):
highest_prime_factor = i
break
print(highest_prime_factor)
return highest_prime_factor
if __name__ == '__main__':
main()
|
d17ec96b85f652027381ee14c761ecd15758e829 | sadipgiri/Sensor-DashBoard | /sensor_api.py | 2,619 | 3.59375 | 4 | #!/usr/bin/env python3
"""
sensor_api - python3 program to return sensor readings hitting the given endpoints
Author: Sadip Giri (sadipgiri@bennington.edu)
Created: 15 May, 2018
"""
import re
import requests
import json
def last_hour_sensor_data():
try:
req = requests.request('GET', 'http://54.197.182.144:5000/read/last_hour')
json_data = req.json()
return json_data
except Exception as e:
return offline_sensor_data()
def particular_sensor_data(id=1):
if id:
try:
req = requests.request('GET', 'http://54.197.182.144:5000/read/{0}'.format(id))
json_data = req.json()
return json_data["data"]
except Exception as e:
return offline_sensor_data()
try:
req = requests.request('GET', 'http://34.201.69.120:5000/read/1')
json_data = req.json()
return json_data["data"]
except Exception as e:
return offline_sensor_data()
def offline_sensor_data():
with open('./offline_data/sensor_readings.json') as json_file:
json_data = json.load(json_file)
sensor_readings = json_data
return sensor_readings
def dict_of_sensors_list(data):
temps = []
humids = []
timestamps = []
for i in data:
temps.append(i["data"]["temperature"]["value"])
humids.append(i["data"]["humidity"]["value"])
timestamps.append(i["timestamp"])
dicts = {"temps": temps, "humids": humids, "timestamps": timestamps}
return dicts
def scan_sensors():
dct = {}
req = requests.request('GET', 'http://54.197.182.144:5000/scan')
json_data = req.json()
data = json_data["sensors"]
for i in data:
dct[i['id']] = i['location']
return dct
def split_location(location):
location = location.lower()
match = re.match(r"([a-z]+)([0-9]+)", location, re.I)
items = match.groups()
return items
def convert():
sensors = scan_sensors()
x = []
y = []
temp = []
id = []
req = requests.request('GET', 'http://54.197.182.144:5000/read/last_hour')
json_data = req.json()
for i in json_data:
if i["id"] not in id:
id.append(i["id"])
loc_info = split_location(sensors[int(i["id"])])
y.append(loc_info[0])
x.append(loc_info[1])
temp.append(i["data"]["temperature"]["value"])
return {'y': y, 'x': x, 'temp': temp}
if __name__ == '__main__':
# print(dict_of_sensors_list(last_hour_sensor_data()))
# print(particular_sensor_data(id=5))
print(scan_sensors())
print(convert())
|
c246c6a153b6bc176ed0e279a60d32f1b2100711 | ntkawasaki/complete-python-masterclass | /7: Lists, Ranges, and Tuples/tuples.py | 1,799 | 4.5625 | 5 | # tuples are immutable, can't be altered or appended to
# parenthesis are not necessary, only to resolve ambiguity
# returned in brackets
# t = "a", "b", "c"
# x = ("a", "b", "c") # using brackets is best practice
# print(t)
# print(x)
#
# print("a", "b", "c")
# print(("a", "b", "c")) # to print a tuple explicitly include parenthesis
# tuples can put multiple data types on same line
welcome = "Welcome to my Nightmare", "Alice Cooper", 1975
bad = "Bad Company", "Bad Company", 1974
budgie = "Nightflight", "Budgie", 1981
imelda = "More Mayhem", "Emilda Way", 2011
metallica = "Ride the Lightening", "Metallica", 1984
# print(metallica)
# print(metallica[0]) # print one part of tuple
# print(metallica[1])
# print(metallica[2])
# cant change underlying tuple, immutable object
# metallica[0] = "Master of Puppets"
# ca get around this like this though
imelda = imelda[0], "Emilda Way", imelda[2]
# python also evaluates the right side of this expression first, then assigns it to a new variable "imelda"
# creates a new tuple
print(imelda)
# can alter a list though
metallica2 = ["Ride the Lightening", "Metallica", 1984]
print(metallica2)
metallica2[0] = "Master of Puppets"
print(metallica2)
print()
# metallica2.append("Rock")
# title, album, year = metallica2
# print(title)
# print(album)
# print(year)
# will draw a too many values to unpack error because not enough variables assigned
# unpacking the tuple, extract values from and assign to variables
title, album, year = imelda
print(imelda)
print("Title: {}".format(title))
print("Album: {}".format(album))
print("Year: {}".format(year))
# tuples don't have an append() method
imelda.append("Rock")
# notes
# lists are intended to hold objects of the same type, tuples not necessarily
# tuples not changing can protect code against bugs
|
acf3384d648aa16c781ac82c61b8e3c275538bae | ntkawasaki/complete-python-masterclass | /10: Input and Output/shelve_example.py | 1,638 | 4.25 | 4 | # like a dictionary stored in a file, uses keys and values
# persistent dictionary
# values pickled when saved, don't use untrusted sources
import shelve
# open a shelf like its a file
# with shelve.open("shelf_test") as fruit: # makes a shelf_test.db file
# fruit["orange"] = "a sweet, orange fruit"
# fruit["apple"] = "good for making cider"
# fruit["lemon"] = "a sour, yellow fruit"
# fruit["grape"] = "a small, sweet fruit grown in bunches"
# fruit["lime"] = "a sour, green citrus fruit"
# when outside of the with, it closes the file
# print(fruit) # prints as a shelf and not a dictionary
# to do this with manual open and closing
fruit = shelve.open("shelf_test")
# fruit["orange"] = "a sweet, orange fruit"
# fruit["apple"] = "good for making cider"
# fruit["lemon"] = "a sour, yellow fruit"
# fruit["grape"] = "a small, sweet fruit grown in bunches"
# fruit["lime"] = "a sour, green citrus fruit"
# # change value of "lime"
# fruit["lime"] = "goes great with tequila!"
#
# for snack in fruit:
# print(fruit[snack])
# while True:
# dict_key = input("Please enter a fruit: ")
# if dict_key == "quit":
# break
#
# if dict_key in fruit:
# description = fruit[dict_key]
# print(description)
# else:
# print("We don't have a " + dict_key)
# alpha sorting keys
# ordered_keys = list(fruit.keys())
# ordered_keys.sort()
#
# for f in ordered_keys:
# print(f + " - " + fruit[f])
#
# fruit.close() # remember to close
for v in fruit.values():
print(v)
print(fruit.values())
for f in fruit.items():
print(f)
print(fruit.items())
fruit.close() |
fcd60015393e712316586a32f75462eff2f4543f | ntkawasaki/complete-python-masterclass | /11: Modules and Functions/Functions/more_functions.py | 2,460 | 4.125 | 4 | # more functions!
# function can use variables from main program
# main program cannot use local variables in a function
import math
try:
import tkinter
except ImportError: # python 2
import Tkinter as tkinter
def parabola(page, size):
"""
Returns parabola or y = x^2 from param x.
:param page:
:param size
:return parabola:
"""
for x_coor in range(size):
y_coor = x_coor * x_coor / size
plot(page, x_coor, y_coor)
plot(page, -x_coor, y_coor)
# modify the circle function so that it allows the color
# of the circle to be specified and defaults to red
def circle(page, radius, g, h, color="red"):
""" Create a circle. """
for x in range(g * 100, (g + radius) * 100):
page.create_oval(g + radius, h + radius, g - radius, h - radius, outline=color, width=2)
# x /= 100
# print(x)
# y = h + (math.sqrt(radius ** 2 - ((x - g) ** 2)))
# plot(page, x, y)
# plot(page, x, 2 * h - y)
# plot(page, 2 * g - x, y)
# plot(page, 2 * g - x, 2 * h - y)
def draw_axis(page):
"""
Draws a horizontal and vertical line through middle of window to be used as
the x and y axis.
:param page:
:return:
"""
page.update() # allows you to use winfo_width/height
x_origin = page.winfo_width() / 2
y_origin = page.winfo_height() / 2
page.configure(scrollregion=(-x_origin, -y_origin, x_origin, y_origin))
# create_line(x1, y1, x2, y2)
page.create_line(-x_origin, 0, x_origin, 0, fill="black") # horizontal
page.create_line(0, y_origin, 0, -y_origin, fill="black") # vertical
# shows all local variables in this function
print(locals())
def plot(page, x_plot, y_plot):
"""
Plots points on canvas from params x and y.
:param page:
:param x_plot:
:param y_plot:
:return:
"""
page.create_line(x_plot, -y_plot, x_plot + 1, -y_plot + 1, fill="red")
# window
main_window = tkinter.Tk()
main_window.title("Parabola")
main_window.geometry("640x480")
# canvas
canvas = tkinter.Canvas(main_window, width=640, height=480, background="gray")
canvas.grid(row=0, column=0)
# call function
draw_axis(canvas)
parabola(canvas, 300)
parabola(canvas, 20)
circle(canvas, 100, 100, 100, color="blue")
circle(canvas, 100, 100, 100, color="yellow")
circle(canvas, 100, 100, 100, color="green")
circle(canvas, 10, 30, 30, color="black")
main_window.mainloop()
|
b9096be499b5324792acee537eb36a6cf1121c5b | ntkawasaki/complete-python-masterclass | /6: Flow Control/if_program_flow.py | 1,098 | 4.0625 | 4 | print()
name = input("Please tell me your name: ")
age = int(input("How old are you, {0}? ".format(name)))
if not (age < 18):
print("You are old enough to vote.")
print("Please put an X in the box.")
else:
print("Please come back in {0} years".format(18 - age))
# print("Please guess a number between 1 and 10.")
# guess = int(input())
#
# if guess != 5:
# if guess < 5:
# print("Please guess higher.")
# else:
# print("Please guess lower.")
# guess = int(input())
#
# if guess == 5:
# print("Well done!")
# else:
# print("Sorry, you are wrong again.")
# else:
# print("Nice, first try!!!")
# age = int(input("How old are you? "))
# if (age >= 16) and (age <= 65):
# if 15 < age < 66:
# print("Have a great day at work!")
# if (age < 16) or (age > 65):
# print("Enjoy your free time!")
# else:
# print("Have a good day at work!")
# x = input("Please enter some text: ")
#
# if x:
# print("You entered {0}.".format(x))
# else:
# print("You did not enter anything.")
#
# print(not True)
# print(not False) |
053003b71dcec146dcccdfcbba06c4bcd8406f54 | ntkawasaki/complete-python-masterclass | /6: Flow Control/for_loops.py | 862 | 3.59375 | 4 | # for i in range(1, 21):
# print("i is now {}".format(i))
number = "9,333,455,768,234"
cleaned_number = ""
# for i in range(0, len(number)):
# if number[i] in "0123456789":
# cleaned_number = cleaned_number + number[i] # concatenation of strings
# through a sequence of values
for char in number:
if char in "0123456789":
cleaned_number = cleaned_number + char
new_number = int(cleaned_number)
print("The new number is: {}.".format(new_number))
for state in ["not pinin'", "no more", "sad", "a stiff", "bereft of life"]:
print("This parrot is " + state)
# print("This parrot is {}".format(state))
for i in range(0, 100, 5):
print("i is {0}.".format(i))
for i in range(1, 13):
for j in range(1, 13):
print("{0} times {1} = {2}".format(j, i, i * j), end="\t")
# print("===============")
print("") |
4ef8a7a07238c6930ff101f62fed0eead560b3bd | TheLoneGuy/Home-Loan-Calculator | /index.py | 8,544 | 3.546875 | 4 | from tkinter import *
from tkinter import ttk
from tkinter import font
from threading import Timer
import math
import random
from Graph import *
from background import Background
random.seed()
TRANSPARENT = "#576890"
DECIMAL_POINTS = "{:.2f}"
inputs = {
'loan': 10000,
'down': 10,
'rate': 4.5,
'year': 10
}
outputs = {
'repayment': 0,
'principle': 0,
'interest': 0,
'month': 0
}
LargeFont = ("Times New Roman", 15)
def debounce(wait):
""" Decorator that will postpone a functions
execution until after wait seconds
have elapsed since the last time it was invoked. """
def decorator(func):
def debounced(*args, **kwargs):
def call_it():
func(*args, **kwargs)
try:
debounced._timer.cancel()
except(AttributeError):
pass
debounced._timer = Timer(wait, call_it)
debounced._timer.start()
return debounced
return decorator
def is_float(potential_float):
try:
float(potential_float)
return True
except ValueError:
return False
def mortgage(loan, down, rate, year, format="%"):
if format == "%":
# down payment in percentage format
principle = loan * (100 - down) / 100
elif format == "RM":
# down payment in cash format
principle = loan - down
month = int(year * 12)
monthly_rate = rate / 12 / 100
compound = (1 + monthly_rate) ** month
repayment = principle / ((compound - 1) / (monthly_rate * compound)) * month
interest = repayment - principle
return repayment, principle, interest, month
@debounce(0.3)
def mortgage_list():
debt = outputs['repayment']
interest = outputs['interest']
rate = inputs['rate']
month = outputs['month']
# Use treeview or something to display the data in a table like forma
month_debt = debt/month
interest /= month
results = ResultListTopLevel(root)
for i in range(1, month + 1):
interest = debt * rate / 100 / 12
principle = month_debt - interest
debt = debt - principle - interest
results.list.insert('', 'end', text=i, values=(DECIMAL_POINTS.format(principle), DECIMAL_POINTS.format(interest), DECIMAL_POINTS.format(debt)))
# Widget function callbacks
@debounce(0.3)
def display_update(repayment, prin, rate, month):
debt.label.config(text=DECIMAL_POINTS.format(repayment))
principle.label.config(text=DECIMAL_POINTS.format(prin))
interest.label.config(text=DECIMAL_POINTS.format(rate))
outputs.update({
'repayment': repayment,
'principle': prin,
'interest': rate,
'month': month
})
circle_graph.cal([
{
"subject": "Principle",
"value": prin,
"color": "#90ee90"
},
{
"subject": "Interest",
"value": rate,
"color": "#006400"
}
])
circle_graph.animate()
# widgets
class ValidatedEntry(Entry):
def __init__(self, master, name, default, *args, **kwargs):
super().__init__(master, *args, **kwargs)
self.name = name
self.default = default
self.upperbound = None
self.insert(0, self.default)
vcmd = (root.register(self._validation), "%P")
self.configure(validate="key", validatecommand=vcmd)
def _validation(self, value):
tmp = None
try:
if value == "":
value = float(self.default)
elif is_float(value):
value = float(value)
if self.upperbound:
if self.upperbound <= value:
raise ValueError("Sorry, no numbers {} and above".format(self.upperbound))
else:
raise TypeError("Entry only allows floats input")
tmp, inputs[self.name] = inputs[self.name], value
output = mortgage(**inputs)
display_update(*output)
return True
except Exception as ex:
if tmp:
inputs[self.name] = tmp
template = "An exception of type {0} occurred. Arguments:\n{1!r}"
message = template.format(type(ex).__name__, ex.args)
print(message)
return False
def set_range(self, upperbound=None):
self.upperbound=upperbound
class EntryFrame(LabelFrame):
def __init__(self, master, name, default, *args, **kwargs):
super().__init__(master, bg=TRANSPARENT, *args, **kwargs)
self.ent = ValidatedEntry(self, name, default, font=LargeFont)
self.ent.grid()
class ResultFrame(LabelFrame):
def __init__(self, master, *args, value="", **kwargs):
super().__init__(master, *args, **kwargs)
self.label = Label(self, bg=TRANSPARENT)
self.label.grid()
class ResultListTopLevel(Toplevel):
def __init__(self, master):
super().__init__(master)
self.geometry("600x600+700+50")
headings = 'Principle', 'Interest', 'Debt'
self.list = ttk.Treeview(self, columns=headings, selectmode='browse')
self.sb = Scrollbar(self, orient=VERTICAL)
self.sb.pack(side=RIGHT, fill=Y)
self.list.config(yscrollcommand=self.sb.set)
self.sb.config(command=self.list.yview)
self.list.heading("#0", text="Month")
self.list.column("#0", minwidth=0, width=100, anchor="center")
for heading in headings:
self.list.heading(heading, text=heading)
self.list.column(heading, minwidth=0, width=100, anchor="center")
self.list.pack(fill=BOTH,expand=1)
self.list.bind('<Button-1>', self.handle_click)
def handle_click(self, event):
if self.list.identify_region(event.x, event.y) == "separator":
return "break"
root = Tk()
root.title("Home Loan Calculator")
root.wm_attributes("-transparentcolor", TRANSPARENT)
root.resizable(False, False)
root.wm_attributes("-topmost", True)
root.geometry("600x600+50+50")
root.configure(bg=TRANSPARENT)
root.bind_all("<1>", lambda event:event.widget.focus_set())
bg_root = Toplevel(root)
bg_root.geometry("600x600+50+50")
bg = Background(bg_root)
topframe = Frame(root, bg=TRANSPARENT)
topframe.place(relx=0.5, rely=0.5, anchor=CENTER)
loan = EntryFrame(topframe, 'loan', inputs['loan'], font=LargeFont)
down = EntryFrame(topframe, 'down', inputs['down'], font=LargeFont)
rate = EntryFrame(topframe, 'rate', inputs['rate'], font=LargeFont)
year = EntryFrame(topframe, 'year', inputs['year'], font=LargeFont)
loan.config(text="Loan:")
down.config(text="Down Payment:")
rate.config(text="Interest Rate:")
year.config(text="Year:")
down.ent.set_range(upperbound=100)
rate.ent.set_range(upperbound=100)
loan.grid()
down.grid()
rate.grid()
year.grid()
debt = ResultFrame(topframe, text="Debt:", bg=TRANSPARENT, font=LargeFont)
principle = ResultFrame(topframe, text="Principle:", bg=TRANSPARENT, font=LargeFont)
interest = ResultFrame(topframe, text="Interest:", bg=TRANSPARENT, font=LargeFont)
debt.label.config(justify="center", font=LargeFont)
principle.label.config(justify="center", font=LargeFont)
interest.label.config(justify="center", font=LargeFont)
debt.grid(sticky="EW")
principle.grid(sticky="EW")
interest.grid(sticky="EW")
graph_frame = Frame(topframe, bg=TRANSPARENT)
graph_frame.grid(column=1, row=0, rowspan=7)
circle_graph = GraphCanvas(graph_frame, width=250, height=250, bg=TRANSPARENT, highlightthickness=0)
graph_title = Label(graph_frame, text="Payment Breakdown", bg=TRANSPARENT, font=LargeFont)
graph_frame_label = Frame(graph_frame, width=100, bg=TRANSPARENT)
graph_label1 = GraphLabel(graph_frame_label, text="Principle", color="#90ee90")
graph_label2 = GraphLabel(graph_frame_label, text="Interest", color="#006400")
graph_label1.text.config(bg=TRANSPARENT, font=LargeFont)
graph_label2.text.config(bg=TRANSPARENT, font=LargeFont)
graph_label1.grid(sticky="W")
graph_label2.grid(sticky="W")
graph_title.grid()
circle_graph.grid()
graph_frame_label.grid()
btn_print = Button(root, text="Print List", command=mortgage_list)
btn_print.place(relx=0.9, rely=0.9)
loan.ent._validation("")
bg.setup()
bg.animation()
root.mainloop() |
72808324afe7943941c3ea9673bfba435561ab82 | ZibingZhang/Minesweeper | /src/minesweeper.py | 13,869 | 3.859375 | 4 | import tkinter as tk
from random import randint
from itertools import product
from cell import Cell
class Minesweeper(object):
""" The minesweeper game.
The minesweeper game. It includes all the widgets for the GUI.
Class Attributes:
PAD_X (int): The amount of horizontal padding for the top and bottom half frames.
PAD_Y (int): The amount of vertical padding for the top and bottom half frames.
Instance Attributes:
rows (int): The number of cells, vertically, for the minesweeper game.
columns (int): The number of cells, horizontally, for the minesweeper game.
bombs (int): The number of bombs on the board.
root (Tk): The root window.
top (Frame): The top half of the window, the part where the game is played.
bottom (Frame): The bottom half of the window, the part where information is displayed.
menu_bar (Menu): The menu bar.
message (StringVar): The message being displayed at the bottom.
message_label (Label): The widget where the number of bombs left is displayed.
cells (List-of (List-of Cell)): 2D array of all the Cell objects.
generated_bombs (bool): Has the bombs been generated yet?
game_over (bool): Is the game over?
Methods:
bind_shortcuts: Binds the appropriate keyboard shortcuts.
resize: Resize the board.
create_menu_bar: Creates the menu bar.
new: Resets the game.
generate_bombs: Randomly generates the bombs and updates the 2D cell array accordingly.
uncover_neighbors: Uncovers neighboring cells.
neighboring_bombs: Counts the number of neighboring bombs.
neighboring_flags: Counts the number of neighboring flags.
alter_counter: Updates the counter.
has_won: Has the user won the game?
win_game: Win the game.
lose_game: Lose the game.
"""
PAD_X = 10
PAD_Y = 10
def __init__(self, root):
""" Initializes the object.
Initializes the instance attributes as described above.
Generates the GUI components for the game, namely the two halves and the menu bar.
The top half includes the 2D array of buttons that represents the cells.
The bottom half includes the display message which indicates how many bombs are left or if the game is over.
The menu bar has options to restart, change the size, and exit.
Binds shortcuts to various key combinations as described below.
Args:
root: The root window.
"""
self.root = root
# Board size
self.rows = 16
self.columns = 16
self.bombs = 40
# Window Settings
self.root.title("Minesweeper")
self.root.resizable(False, False)
# Two halves of the screen
self.top = tk.Frame(root, padx=self.PAD_X, pady=self.PAD_Y)
self.top.pack(side=tk.TOP)
self.bottom = tk.Frame(root, padx=self.PAD_X, pady=self.PAD_Y)
self.bottom.pack(side=tk.BOTTOM)
# Menu Bar
self.menu_bar = tk.Menu(self.root)
self.create_menu_bar()
self.root.config(menu=self.menu_bar)
# Footer
self.message = tk.StringVar()
self.message_label = tk.Label(self.bottom, textvariable=self.message)
self.message.set(str(self.bombs))
self.message_label.pack()
# Tkinter Board
self.cells = []
for row in range(self.rows):
self.cells.append([])
for column in range(self.columns):
button = Cell(self, self.top, row, column)
self.cells[row].append(button)
self.generated_bombs = False
self.game_over = False
# Keyboard Shortcuts
self.bind_shortcuts()
def bind_shortcuts(self):
""" Binds the appropriate keyboard shortcuts.
<Ctrl-q> : exits the game.
<Ctrl-n> : or F2 starts a new game.
<Ctrl-z> : starts a new game with a small sized board.
<Ctrl-x> : starts a new game with a medium sized board.
<Ctrl-c> : starts a new game with a large sized board.
"""
self.root.bind("<Control-q>", lambda event: self.root.destroy())
self.root.bind("<Control-n>", lambda event: self.new())
self.root.bind("<F2>", lambda event: self.new())
self.root.bind("<Control-z>", lambda event: self.resize(9, 9, 10))
self.root.bind("<Control-x>", lambda event: self.resize(16, 16, 40))
self.root.bind("<Control-c>", lambda event: self.resize(16, 30, 99))
def create_menu_bar(self):
""" Creates the menu bar. """
file_menu = tk.Menu(self.menu_bar, tearoff=0)
file_menu.add_command(label="New", command=self.new)
# create more pull down menus
size_menu = tk.Menu(file_menu, tearoff=0)
size_menu.add_command(label="Small", command=lambda: self.resize(9, 9, 10))
size_menu.add_command(label="Medium", command=lambda: self.resize(16, 16, 40))
size_menu.add_command(label="Large", command=lambda: self.resize(16, 30, 99))
file_menu.add_cascade(label="Size", menu=size_menu)
file_menu.add_separator()
file_menu.add_command(label="Exit", command=self.root.destroy)
self.menu_bar.add_cascade(label="File", menu=file_menu)
def resize(self, rows, columns, bombs):
""" Resize the board.
Args:
rows: The new number of rows.
columns: The new number of columns.
bombs: The new number of bombs.
"""
for row in range(self.rows):
for column in range(self.columns):
self.cells[row][column].button.destroy()
self.cells = []
self.rows = rows
self.columns = columns
self.bombs = bombs
self.message.set(self.bombs)
for row in range(self.rows):
self.cells.append([])
for column in range(self.columns):
self.cells[row].append(Cell(self, self.top, row, column))
self.new()
def new(self):
""" Resets the game. """
for row in range(self.rows):
for column in range(self.columns):
self.cells[row][column].reset()
self.generated_bombs = False
self.game_over = False
self.message.set(self.bombs)
def generate_bombs(self, initial_row, initial_column):
""" Randomly generates the bombs and updates the 2D cell array accordingly.
Generates the bombs such that they do not they do not border the first cell clicked.
Args:
initial_row: The row of the cell that should not border a bomb.
initial_column: The column of the cell that should not border a bomb.
"""
self.generated_bombs = True
bombs = self.bombs
while bombs > 0:
row = randint(0, self.rows-1)
column = randint(0, self.columns-1)
if not self.cells[row][column].is_bomb and \
((row-initial_row)**2 + (column-initial_column)**2)**0.5 > 1.5:
self.cells[row][column].is_bomb = True
bombs -= 1
# Test Case :
# 1 bomb left, guessing required
# -------------------------------
# self.generated_bombs = True
# self.cells[0][2].is_bomb = True
# self.cells[1][1].is_bomb = True
# self.cells[1][2].is_bomb = True
# self.cells[2][2].is_bomb = True
# self.cells[3][0].is_bomb = True
# self.cells[3][7].is_bomb = True
# self.cells[5][1].is_bomb = True
# self.cells[6][8].is_bomb = True
# self.cells[8][6].is_bomb = True
# self.cells[8][7].is_bomb = True
# Test Case :
# 3 bombs left
# ---------------------------------
# self.generated_bombs = True
# self.cells[2][4].is_bomb = True
# self.cells[3][0].is_bomb = True
# self.cells[4][1].is_bomb = True
# self.cells[5][2].is_bomb = True
# self.cells[5][4].is_bomb = True
# self.cells[5][8].is_bomb = True
# self.cells[6][0].is_bomb = True
# self.cells[7][0].is_bomb = True
# self.cells[7][1].is_bomb = True
# self.cells[7][7].is_bomb = True
# Test Case :
# 5 bombs left (right half)
# ---------------------------------
# self.generated_bombs = True
# self.cells[0][6].is_bomb = True
# self.cells[1][4].is_bomb = True
# self.cells[3][4].is_bomb = True
# self.cells[4][5].is_bomb = True
# self.cells[5][1].is_bomb = True
# self.cells[5][4].is_bomb = True
# self.cells[5][6].is_bomb = True
# self.cells[6][4].is_bomb = True
# self.cells[7][3].is_bomb = True
# self.cells[8][1].is_bomb = True
# Test Case :
# 7 bombs left (upper right)
# ---------------------------------
# self.generated_bombs = True
# self.cells[1][1].is_bomb = True
# self.cells[3][1].is_bomb = True
# self.cells[3][2].is_bomb = True
# self.cells[4][2].is_bomb = True
# self.cells[5][5].is_bomb = True
# self.cells[7][1].is_bomb = True
# self.cells[7][4].is_bomb = True
# self.cells[7][7].is_bomb = True
# self.cells[8][0].is_bomb = True
# self.cells[8][5].is_bomb = True
def uncover_neighbors(self, row, column):
""" Uncovers neighboring cells.
Uncovers the neighbors of the cell at the position given by row and column.
Args:
row: The row of the cell whose neighbors are being uncovered.
column: The column of the cell whose neighbors are being uncovered.
"""
for row_offset, column_offset in product((-1, 0, 1), (-1, 0, 1)):
try:
if (self.cells[row + row_offset][column + column_offset].state == "covered" and
row + row_offset >= 0 and column + column_offset >= 0):
self.cells[row + row_offset][column + column_offset].left_click()
except (TypeError, IndexError):
pass
def neighboring_bombs(self, row, column):
""" Counts the number of neighboring bombs.
Args:
row: The row of the cell whose neighboring bombs are being counted.
column: The column of the cell whose neighboring bombs are being counted.
Returns:
int: The number of neighboring bombs.
"""
# Unable to see the number of the cell unless it is uncovered.
assert self.cells[row][column].state == "uncovered"
bombs = 0
for row_offset, column_offset in product((0, -1, 1), (0, -1, 1)):
try:
if (not (row_offset == 0 and column_offset == 0) and
row + row_offset >= 0 and column + column_offset >= 0 and
self.cells[row + row_offset][column+column_offset].is_bomb):
bombs += 1
except IndexError:
pass
return bombs
def neighboring_flags(self, row, column):
""" Counts the number of neighboring flags.
Args:
row: The row of the cell whose neighboring flags are being counted.
column: The column of the cell whose neighboring flags are being counted.
Returns:
int: The number of neighboring flags.
"""
flags = 0
for row_offset, column_offset in product((0, -1, 1), (0, -1, 1)):
try:
if (not (row_offset == 0 and column_offset == 0) and
row + row_offset >= 0 and column + column_offset >= 0 and
self.cells[row + row_offset][column + column_offset].state == "flagged"):
flags += 1
except IndexError:
pass
return flags
def alter_counter(self, increment):
""" Changes the counter by the increment to indicate the number of bombs remaining.
Args:
increment: The change to the counter.
"""
try:
self.message.set(int(self.message.get()) + increment)
except ValueError:
# Not sure why it sometimes throws errors...
pass
def has_won(self):
""" Has the user won the game?
Is the total number of uncovered cells plus the number of cells that are bombs
equal to the total number of cells?
Returns:
bool: Has the user won the game?
"""
total = self.rows*self.columns
for row in range(self.rows):
for column in range(self.columns):
if self.cells[row][column].is_bomb:
total -= 1
elif not self.cells[row][column].state == "covered":
total -= 1
return total == 0
def win_game(self):
""" Win the game.
Flags the remaining bombs that have not yet been flagged
"""
for row in range(self.rows):
for column in range(self.columns):
if self.cells[row][column].is_bomb and not self.cells[row][column].state == "flagged":
self.cells[row][column].flag()
self.game_over = True
self.message.set("You Win")
def lose_game(self):
""" Lose the game.
Removes all flags, presses all cells down, and displays all the cells.
"""
for row in range(self.rows):
for column in range(self.columns):
self.cells[row][column].state = "uncovered"
self.cells[row][column].show_text()
self.cells[row][column].remove_flag()
self.game_over = True
self.message.set("You Lose")
|
b44f64493cd2afd91cb134580625091c4ca0aa96 | dlcios/coding-py | /basic/mail_re.py | 376 | 3.546875 | 4 | import re
#验证email的正则表达式，邮箱名可以使英文字母或数字或 -,_ 符号，后巷后缀网址名可以是英文或数字，域名可以使 com,org,edu
#例: chu-tian-shu_1981@heibanke2015.com
# mail = "1905790854@qq.com"
mail = "chu-tian-shu_1981@heibanke2015.com"
pattern = re.compile(r"^[\w\-\,]+@[a-zA-Z0-9]+\.(com|org|edu){1}$")
match = pattern.match(mail)
if match :
print('ok')
else:
print('false') |
42b5a11339851544418f71b3cd7e1ceb8ab46966 | dlcios/coding-py | /basic/def.py | 594 | 3.65625 | 4 | #coding: utf-8
# to16mod = hex
# n1 = to16mod(25)
# print(n1)
# #定义函数
# def mabs(num):
# if num > 0:
# return num
# else:
# return -num
# a = -15
# b = 15
# print(mabs(a), mabs(b))
# def power(x):
# return x * x
# print(power(a))
# def powern(x,y = 2):
# s = 1
# while y > 0:
# s = s * x
# y -= 1
# return s
# print(powern(2,1))
def add_append(l=None):
if l == None:
l = []
l.append('hello')
return l
print(add_append([1,2]))
print(add_append([3,4]))
print(add_append())
print(add_append())
|
50c94f0dcf4ed5abc4af1bd3a4b6fe7a190a3471 | Geo-Root/code5 | /code5/console_scripts.py | 2,526 | 3.71875 | 4 | #!/usr/bin/env python
"""
code5 - Convert stdin (or the first argument) to a Code5 Code.
When stdout is a tty the Code5 Code is printed to the terminal and when stdout is
a pipe to a file an image is written. The default image format is PNG.
"""
import sys
import optparse
import os
import code5
def main(args=sys.argv[1:]):
parser = optparse.OptionParser(usage=__doc__.strip())
opts, args = parser.parse_args(args)
c5 = code5.Code5()
image_factory = None
decode = False
alphabet = False
if args:
data = ''
if args[0] == 'alphabet':
alphabet = True
else:
if '.png' in args[0]:
decode = True
data = args[0]
else:
try:
with open(args[0], 'r') as data_file:
data = data_file.read()
data = data.replace('\n',',')
except:
data = args[0]
else:
stdin_buffer = getattr(sys.stdin, 'buffer', sys.stdin)
data = stdin_buffer.read()
if args[0] == 'alphabet':
alphabet = True
else:
if '.png' in args[0]:
decode = True
data = args[0]
else:
try:
with open(args[0], 'r') as data_file:
data = data_file.read()
data = data.replace('\n',',')
except:
data = args[0]
if alphabet:
c5.dump_alphabet(image_factory=image_factory)
else:
if not decode:
blocks = data.split(',')
for block in blocks:
c5.add_data(block)
img = c5.make_image(image_factory=image_factory)
with open('debug.txt', 'w') as debug_file:
debug_file.write(c5.UR+'\n')
debug_file.write(c5.C+'\n')
debug_file.write(c5.DL+'\n')
debug_file.write(c5.DR+'\n')
try:
img.save_to_path('%s.png'%block, format=None)
except:
img.save('%s.png'%block)
else:
result = c5.revert(image_factory=image_factory, image_path=data)
with open('debug.txt', 'w') as debug_file:
debug_file.write(c5.log)
with open('result.txt', 'w') as result_file:
result_file.write(result)
if __name__ == "__main__":
main()
|
b0bce312122d6b733dc4c63bd6f7e432e8084d78 | georgebzhang/Python_LeetCode | /14_longest_common_prefix.py | 854 | 3.703125 | 4 | class Solution(object):
def longestCommonPrefix(self, strs):
if not strs:
return ''
lcp = ''
ind = 0
while True:
letters = []
for item in strs:
if ind == len(item):
return lcp
letters.append(item[ind])
letter = set(letters) # convert list to set
if len(letter) == 1: # only 1 element in set if all items in list were same
lcp += letter.pop()
else:
return lcp
ind += 1
return lcp
def print_answer(self, ans):
print(ans)
def test(self):
strs = ["flower", "flow", "flight"]
ans = self.longestCommonPrefix(strs)
self.print_answer(ans)
if __name__ == '__main__':
s = Solution()
s.test()
|
af3a21971e6ca7593bdc88efb05563dd37892cb6 | georgebzhang/Python_LeetCode | /142_linked_list_cycle_II_2.py | 1,838 | 3.734375 | 4 | class ListNode(object):
def __init__(self, x):
self.val = x
self.next = None
class Solution(object):
def detectCycle(self, head):
def hasCycle():
slow = head
while fast[0] and fast[0].next:
slow = slow.next
fast[0] = fast[0].next.next
if slow is fast[0]:
return True
return False
fast = [head]
if hasCycle():
slow, fast = head, fast[0]
while fast:
if slow is fast:
return slow
slow, fast = slow.next, fast.next
return None
def print_answer(self, ans, head):
ind = 0
ptr = head
while ptr:
if ans is ptr:
break
ind += 1
ptr = ptr.next
print('tail connects to node index {}'.format(ind))
def build_linked_list(self, vals, pos):
n = len(vals)
head = ListNode(vals[0])
prev = head
for i in range(1, n):
curr = ListNode(vals[i])
prev.next = curr
prev = curr
if i == n-1: # tail
if pos != -1:
loop = head
for i in range(pos):
loop = loop.next
curr.next = loop
return head
def print_linked_list(self, head):
ptr = head
while ptr:
print(ptr.val, ' ', end='')
ptr = ptr.next
print()
def test(self):
vals = [3, 2, 0, -4]
pos = 1
head = self.build_linked_list(vals, pos)
# self.print_linked_list(head)
ans = self.detectCycle(head)
self.print_answer(ans, head)
if __name__ == '__main__':
s = Solution()
s.test()
|
4bc07ecb11ed78ec76815d8058ea67924109584d | georgebzhang/Python_LeetCode | /88_merge_sorted_array_2.py | 670 | 3.78125 | 4 | class Solution(object):
def merge(self, nums1, m, nums2, n):
if not n:
return
i, j = m-1, n-1
ind = m+n-1
while j >= 0:
if i < 0 or nums2[j] > nums1[i]:
nums1[ind] = nums2[j]
j -= 1
else:
nums1[ind] = nums1[i]
i -= 1
ind -= 1
def print_answer(self, ans):
print(ans)
def test(self):
nums1 = [1, 2, 3, 0, 0, 0]
m = 3
nums2 = [2, 5, 6]
n = 3
self.merge(nums1, m, nums2, n)
self.print_answer(nums1)
if __name__ == '__main__':
s = Solution()
s.test()
|
b0757ed59534e19f646e054abb4ba6b001e5cc2e | georgebzhang/Python_LeetCode | /22_generate_parentheses.py | 958 | 3.578125 | 4 | class Solution:
def generateParenthesis(self, n):
def permute(perm, rem):
if not rem:
perms.add(perm[:])
for i in range(len(rem)):
permute(perm+rem[i], rem[:i]+rem[i+1:])
def validParenthesis(s):
mapping = {')': '('}
stack = ''
for k in s:
if k in mapping:
if not stack or mapping[k] != stack[-1]:
return False
stack = stack[:-1]
else:
stack += k
return not stack
perms = set()
s = '('*n + ')'*n
permute('', s)
return [s for s in perms if validParenthesis(s)]
def print_answer(self, ans):
print(ans)
def test(self):
n = 3
ans = self.generateParenthesis(n)
self.print_answer(ans)
if __name__ == '__main__':
s = Solution()
s.test()
|
a3788a58c6702af9e8bd0c397f298bf6c74f979f | georgebzhang/Python_LeetCode | /690_employee_importance_2.py | 1,224 | 3.8125 | 4 | from collections import deque
class Employee:
def __init__(self, id, importance, subordinates):
# It's the unique id of each node.
# unique id of this employee
self.id = id
# the importance value of this employee
self.importance = importance
# the id of direct subordinates
self.subordinates = subordinates
class Solution(object):
def getImportance(self, employees, id):
def dfs(e):
result[0] += e.importance
for s in e.subordinates:
dfs(e_dict[s])
result = [0]
e_dict = {}
for e in employees:
e_dict[e.id] = e
dfs(e_dict[id])
return result[0]
def print_ans(self, ans):
print(ans)
def build_employees_list(self, vals):
employees = []
for val in vals:
employees.append(Employee(val[0], val[1], val[2]))
return employees
def test(self):
vals = [[1, 5, [2, 3]], [2, 3, []], [3, 3, []]]
id = 1
employees = self.build_employees_list(vals)
ans = self.getImportance(employees, id)
self.print_ans(ans)
if __name__ == '__main__':
s = Solution()
s.test()
|
7bce04d20e4c7b828831040372bfddb25820ebd0 | georgebzhang/Python_LeetCode | /62_unique_paths_2.py | 509 | 3.640625 | 4 | from math import factorial
class Solution(object):
def uniquePaths(self, m, n):
def num_combinations(n, k):
return int(factorial(n)/(factorial(k)*factorial(n-k)))
steps = m-1 + n-1
down_steps = m-1
return num_combinations(steps, down_steps)
def print_ans(self, ans):
print(ans)
def test(self):
m, n = 3, 2
ans = self.uniquePaths(m, n)
self.print_ans(ans)
if __name__ == '__main__':
s = Solution()
s.test()
|
cf66a9a5256601495187f39d1db14b329138207b | georgebzhang/Python_LeetCode | /139_word_break.py | 729 | 3.5625 | 4 | class Solution(object):
def wordBreak(self, s, wordDict):
def wordBreakRec(s):
if s in wordSet:
return True
for i in range(len(s)):
s1 = s[:i+1]
if s1 in wordSet:
s2 = s[i+1:]
if wordBreakRec(s2):
return True
return False
wordSet = set(wordDict)
return wordBreakRec(s)
def print_ans(self, ans):
print(ans)
def test(self):
s = "goalspecial"
wordDict = ["go", "goal", "goals", "special"]
ans = self.wordBreak(s, wordDict)
self.print_ans(ans)
if __name__ == '__main__':
s = Solution()
s.test()
|
ff90d9c953787cbb9975ca6130b5a2cd810a3716 | georgebzhang/Python_LeetCode | /973_k_closest_points_to_origin_6.py | 714 | 3.5 | 4 | from heapq import heapify, heappop, heappush, nsmallest
class Point(object):
def __init__(self, c): # c for coords
self.c = c
self.dist2 = c[0] ** 2 + c[1] ** 2
class Solution(object):
def kClosest(self, points, K):
l_points = []
for c in points:
l_points.append(Point(c))
l_points_k = nsmallest(K, l_points, key=lambda point: point.dist2)
return [point.c for point in l_points_k]
def print_ans(self, ans):
print(ans)
def test(self):
points = [[3, 3], [5, -1], [-2, 4]]
K = 2
ans = self.kClosest(points, K)
self.print_ans(ans)
if __name__ == '__main__':
s = Solution()
s.test()
|
07cb7d2e8c636cb9ba70afe4d555be52a9cad251 | georgebzhang/Python_LeetCode | /287_find_the_duplicate_number.py | 470 | 3.65625 | 4 | class Solution(object):
def findDuplicate(self, nums):
s = set()
for i in range(len(nums)):
if nums[i] in s:
return nums[i]
else:
s.add(nums[i])
return -1
def print_ans(self, ans):
print(ans)
def test(self):
nums = [1, 3, 4, 2, 2]
ans = self.findDuplicate(nums)
self.print_ans(ans)
if __name__ == '__main__':
s = Solution()
s.test()
|
cbc9d6af1d0a443eb6c9f4c2c0da318e9653a911 | georgebzhang/Python_LeetCode | /102_binary_tree_level_order_traversal.py | 2,149 | 3.765625 | 4 | from collections import deque
class TreeNode:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
class Solution(object):
def levelOrder(self, root):
if not root:
return []
q = deque()
q.append(root)
levels_vals = []
while q:
level_vals = []
for i in range(len(q)):
node = q.popleft()
level_vals.append(node.val)
if node.left:
q.append(node.left)
if node.right:
q.append(node.right)
levels_vals.append(level_vals)
return levels_vals
def print_answer(self, ans):
print(ans)
def build_tree_inorder(self, vals):
def build_tree_rec(node, i):
if i < n:
if vals[i] != 'null':
node = TreeNode(vals[i])
node.left = build_tree_rec(node.left, 2*i+1)
node.right = build_tree_rec(node.right, 2*i+2)
return node
n = len(vals)
root = None
root = build_tree_rec(root, 0)
return root
def print_tree(self, root):
q = deque()
q.append(root)
level_order_vals = []
while q:
level_vals = []
for i in range(len(q)):
node = q.popleft()
level_vals.append(node.val)
if node.val == 'null':
continue
if node.left:
q.append(node.left)
else:
q.append(TreeNode('null'))
if node.right:
q.append(node.right)
else:
q.append(TreeNode('null'))
level_order_vals.append(level_vals)
print(level_order_vals)
def test(self):
vals = [3, 9, 20, 'null', 'null', 15, 7]
root = self.build_tree_inorder(vals)
self.print_tree(root)
ans = self.levelOrder(root)
self.print_answer(ans)
if __name__ == '__main__':
s = Solution()
s.test()
|
6e393d2f96a5cc60b428b5fb699079e75586280e | georgebzhang/Python_LeetCode | /python_heapq.py | 1,443 | 3.8125 | 4 | import heapq
class Solution(object):
class Person(object):
def __init__(self, name, age):
self.name = name
self.age = age
class PersonHeap(object):
def __init__(self, l_init=None, key=lambda person: person.age): # -person.age for max heap on age
self.key = key
if l_init:
self._data = [(key(person), person) for person in l_init]
heapq.heapify(self._data)
else:
self._data = []
def push(self, person):
heapq.heappush(self._data, (self.key(person), person))
def pop(self):
return heapq.heappop(self._data)[1]
def peek(self):
return self._data[0][1]
def heappushpop(self, person): # good for heaps of fixed size
return heapq.heappushpop(self._data, (self.key(person), person))[1]
def test_personheap(self):
names = ['George', 'Alice', 'Bob', 'Jane', 'Will']
ages = [24, 17, 12, 45, 30]
l_init = []
for i in range(len(names)):
p = Solution.Person(names[i], ages[i])
l_init.append(p)
ph = Solution.PersonHeap(l_init)
print(ph.peek().age)
# print(ph.pop())
# print(ph.heappushpop(Solution.Person('Max', 19)))
def test_heapq(self):
self.test_personheap()
if __name__ == '__main__':
s = Solution()
s.test_heapq()
|
22f0b2868c705c4980c2cfac39349ff93974cc80 | georgebzhang/Python_LeetCode | /43_multiply_strings_2.py | 857 | 3.609375 | 4 | class Solution:
def multiply(self, num1, num2):
def str2int(s):
result = 0
for k in s:
result = 10*result + ord(k)-ord('0')
return result
def int2str(i):
digits = []
while i > 0:
digits.append(i % 10)
i = i // 10
digits.reverse()
keys = '0123456789'
result = ''
for d in digits:
result += keys[d]
return result
result = int2str(str2int(num1)*str2int(num2))
return '0' if not result else result
def print_answer(self, ans):
print(ans)
def test(self):
num1, num2 = '2', '3'
ans = self.multiply(num1, num2)
self.print_answer(ans)
if __name__ == '__main__':
s = Solution()
s.test()
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.