Help! I need help thinking of python projects I can do. browsing

• posted
0

Help! I need help thinking of python projects I can do. I’m not very good at thinking of projects. I’m not looking for super advanced projects. Like, beginner-ish projects to help me learn more python. Don’t suggest, like, a web scraper or something like that. I’ve already done rock, paper, scissors; guess the number; calculator; dice; and flip the coin. Any other ideas?

• posted
0

@Bumbo-Cactoni
i just posted Space Escape

you could use this to understand Scene more and create somthing from there? or even add to it. im going to start a new project of a game that will let you set tasks and give experience acordingly with rewards. mostly for kids and to help motivate doing stuff like chores.

i alo have a RPG Template in the works.this is a more long term project but i hope to get it done soon lol

• posted
1

This post is deleted!

• posted
0

Hi maybe you can help me with this one?
I am trying to put together a tactical kneepad tool for virtual fighter pilots.
It helps with situational awareness concrening bullseye BRAA calls in game.
This is what i got so far and should work out of the box so you can check it out:

import matplotlib.pyplot as plt
import numpy as np
import math

class Vector (list):
''' Simple 2D vector class to make vector operations more convenient. If
performance is a concern, you are probably better off looking at numpy.
Supports the following operations:
* Initialization from two arguments, two keyword  arguments (`x` and `y`),
tuple, list, or another Vector.
* Equality and unequality comparisons to other vectors. For floating point
numbers, equality tolerance is 1e-10.
* `abs`, `int` and `round`
* Subtraction
* Multiplication and division by a scalar
* `len`, which is the same as `magnitude`, see below.
Sample usage:
v = Vector(x = 1, y = 2)
v2 = Vector(3, 4)
v += v2
assert str(v) == '[4, 6]'
assert v / 2.0 == Vector(2, 3)
assert v * 0.1 == Vector(0.4, 0.6)
assert v.distance_to(v2) == math.sqrt(1+4)
v3 = Vector(Vector(1, 2) - Vector(2, 0)) # -1.0, 2.0
v3.magnitude *= 2
assert v3 == [-2, 4]
v3.radians = math.pi # 180 degrees
v3.magnitude = 2
assert v3 == [-2, 0]
v3.degrees = -90
assert v3 == [0, -2]
'''

abs_tol = 1e-10

def __init__(self, *args, **kwargs):
x = kwargs.pop('x', None)
y = kwargs.pop('y', None)

if x and y:
self.append(x)
self.append(y)
elif len(args) == 2:
self.append(args)
self.append(args)
else:
super().__init__(*args, **kwargs)

@property
def x(self):
''' x component of the vector. '''
return self

@x.setter
def x(self, value):
self = value

@property
def y(self):
''' y component of the vector. '''
return self

@y.setter
def y(self, value):
self = value

def __eq__(self, other):
return math.isclose(self, other, abs_tol=self.abs_tol) and math.isclose(self, other, abs_tol=self.abs_tol)

def __ne__(self, other):
return not self.__eq__(other)

def __abs__(self):
return type(self)(abs(self.x), abs(self.y))

def __int__(self):
return type(self)(int(self.x), int(self.y))

return type(self)(self.x + other.x, self.y + other.y)

self.x += other.x
self.y += other.y
return self

def __sub__(self, other):
return type(self)(self.x - other.x, self.y - other.y)

def __mul__(self, other):
return type(self)(self.x * other, self.y * other)

def __truediv__(self, other):
return type(self)(self.x / other, self.y / other)

def __len__(self):
return self.magnitude

def __round__(self):
return type(self)(round(self.x), round(self.y))

def dot_product(self, other):
''' Sum of multiplying x and y components with the x and y components of another vector. '''
return self.x * other.x + self.y * other.y

def distance_to(self, other):
''' Linear distance between this vector and another. '''
return (Vector(other) - self).magnitude

@property
def magnitude(self):
''' Length of the vector, or distance from (0,0) to (x,y). '''
return math.hypot(self.x, self.y)

@magnitude.setter
def magnitude(self, m):
self.polar(r, m)

@property
''' Angle between the positive x axis and this vector, in radians. '''
#return round(math.atan2(self.y, self.x), 10)
return math.atan2(self.y, self.x)

m = self.magnitude
self.polar(r, m)

def polar(self, r, m):
''' Set vector in polar coordinates. `r` is the angle in radians, `m` is vector magnitude or "length". '''
self.y = math.sin(r) * m
self.x = math.cos(r) * m

@property
def degrees(self):
''' Angle between the positive x axis and this vector, in degrees. '''

@degrees.setter
def degrees(self, d):

def steps_to(self, other, step_magnitude=1.0):
""" Generator that returns points on the line between this and the other point, with each step separated by `step_magnitude`. Does not include the starting point. """
if self == other:
yield other
else:
step_vector = other - self
steps = math.floor(step_vector.magnitude/step_magnitude)
step_vector.magnitude = step_magnitude
current_position = Vector(self)
for _ in range(steps):
current_position += step_vector
yield Vector(current_position)
if current_position != other:
yield other

def rounded_steps_to(self, other, step_magnitude=1.0):
''' As `steps_to`, but returns points rounded to the nearest integer. '''
for step in self.steps_to(other):
yield round(step)

bearingblue = int(input("Bearing blue:"))
rangeblue = int(input("Range blue:"))

bearingred = int(input("Bearing red:"))
rangered = int(input("Range red:"))

blue = Vector(rangeblue, 0)
blue.degrees = bearingblue

red = Vector(rangered, 0)
red.degrees = bearingred

delta = red - blue

print('Distance:', delta.magnitude)
print('Bearing:', delta.degrees)

fig = plt.figure()

ax.scatter(thetablue,rangeblue)
ax.scatter(thetared,rangered, color='r')

ax.set_theta_direction(-1)
"""ax.set_rmax(120)"""
ax.set_theta_zero_location('N')
ax.set_title("Plot", va='bottom')

plt.show()

What i want to do next is integrate this into something like sketch.py demo.
To make it possible to draw things onto like flightpath & annotations etc.
Also the feature of exporting as img is handy for recap and debriefing.

Take a look maybe you like this project.

Regards,

Robert.

• posted
0

@robStacks
You want me to help?
I don’t know much Python, so I don’t think I’ll be able to help. Sorry. I am working on learning a lot more python, but right now I just don’t have the knowledge or experience to help. I wish I could help. Sorry. :(

• posted
0

@Bumbo-Cactoni that request has already be takin care of in another thread but helping others is the best way to learn 😉 you will research stuff and learn aspects you may never have or create new objects to put in your cook book. for example i created this ButtonNode and i probably wouldnof made one at some point but not as neat and propbably not so universal in a way. jump out there help people help you 🤠 community is about teamwork💯

• posted
0

Ok no worries Bumbo i am also a beginner in python and it is a great code language.
Its easy to read and understand and with a great communitie very helpfull.
I managed to create something awesome and usefull in a short time thx to that.
I'll show you my progress so you can see:

import math
import ui
import console
import photos
import matplotlib.pyplot as plt
import numpy as np
from io import BytesIO

class Vector(list):
abs_tol = 1e-10

def __init__(self, *args, **kwargs):
x = kwargs.pop('x', None)
y = kwargs.pop('y', None)

if x and y:
self.append(x)
self.append(y)
elif len(args) == 2:
self.append(args)
self.append(args)
else:
super().__init__(*args, **kwargs)

@property
def x(self):
''' x component of the vector. '''
return self

@x.setter
def x(self, value):
self = value

@property
def y(self):
''' y component of the vector. '''
return self

@y.setter
def y(self, value):
self = value

def __eq__(self, other):
return math.isclose(
self, other, abs_tol=self.abs_tol) and math.isclose(
self, other, abs_tol=self.abs_tol)

def __ne__(self, other):
return not self.__eq__(other)

def __abs__(self):
return type(self)(abs(self.x), abs(self.y))

def __int__(self):
return type(self)(int(self.x), int(self.y))

return type(self)(self.x + other.x, self.y + other.y)

self.x += other.x
self.y += other.y
return self

def __sub__(self, other):
return type(self)(self.x - other.x, self.y - other.y)

def __mul__(self, other):
return type(self)(self.x * other, self.y * other)

def __truediv__(self, other):
return type(self)(self.x / other, self.y / other)

def __len__(self):
return self.magnitude

def __round__(self):
return type(self)(round(self.x), round(self.y))

def dot_product(self, other):
''' Sum of multiplying x and y components with the x and y components of another vector. '''
return self.x * other.x + self.y * other.y

def distance_to(self, other):
''' Linear distance between this vector and another. '''
return (Vector(other) - self).magnitude

@property
def magnitude(self):
''' Length of the vector, or distance from (0,0) to (x,y). '''
return math.hypot(self.x, self.y)

@magnitude.setter
def magnitude(self, m):
self.polar(r, m)

@property
''' Angle between the positive x axis and this vector, in radians. '''
#return round(math.atan2(self.y, self.x), 10)
return math.atan2(self.y, self.x)

m = self.magnitude
self.polar(r, m)

def polar(self, r, m):
''' Set vector in polar coordinates. `r` is the angle in radians, `m` is vector magnitude or "length". '''
self.y = math.sin(r) * m
self.x = math.cos(r) * m

@property
def degrees(self):
''' Angle between the positive x axis and this vector, in degrees. '''

@degrees.setter
def degrees(self, d):

def steps_to(self, other, step_magnitude=1.0):
""" Generator that returns points on the line between this and the other point, with each step separated by `step_magnitude`. Does not include the starting point. """
if self == other:
yield other
else:
step_vector = other - self
steps = math.floor(step_vector.magnitude / step_magnitude)
step_vector.magnitude = step_magnitude
current_position = Vector(self)
for _ in range(steps):
current_position += step_vector
yield Vector(current_position)
if current_position != other:
yield other

def rounded_steps_to(self, other, step_magnitude=1.0):
''' As `steps_to`, but returns points rounded to the nearest integer. '''
for step in self.steps_to(other):
yield round(step)

bearingblue = int(input("Bearing blue: "))
rangeblue = int(input("Range blue:   "))

bearingred = int(input("Bearing red:  "))
rangered = int(input("Range red:    "))

blue = Vector(rangeblue, 0)
blue.degrees = bearingblue

red = Vector(rangered, 0)
red.degrees = bearingred

delta = red - blue

ways = way[:, 0]
r = way[:, 1]

if delta.degrees < 0:
print('Bearing: ', int(delta.degrees + 360))
print('Distance:', int(delta.magnitude))
else:
print('Bearing: ', int(delta.degrees))
print('Distance:', int(delta.magnitude))

class PathView(ui.View):
def __init__(self, frame):
self.frame = frame
self.flex = 'WH'
self.path = None
self.action = None

def touch_began(self, touch):
x, y = touch.location
self.path = ui.Path()
self.path.line_width = 1
self.path.line_join_style = ui.LINE_JOIN_ROUND
self.path.line_cap_style = ui.LINE_CAP_ROUND
self.path.move_to(x, y)

def touch_moved(self, touch):
x, y = touch.location
self.path.line_to(x, y)
self.set_needs_display()

def touch_ended(self, touch):
# Send the current path to the SketchView:
if callable(self.action):
self.action(self)
# Clear the view (the path has now been rendered
# into the SketchView's image view):
self.path = None
self.set_needs_display()

def draw(self):
if self.path:
self.path.stroke()

ax = plt.subplot(111, projection='polar')
plt.polar(thetawayp, r)
plt.polar(thetawayp, r, 'k.', zorder=3)
ax.scatter(thetablue,rangeblue)
ax.scatter(thetared,rangered, color='r')
ax.set_theta_direction(-1)
ax.set_rmax(120)
ax.set_theta_zero_location('N')
ax.set_title("N ", va='bottom')
ax.grid(True)
b = BytesIO()

plt.savefig(b)

class SketchView(ui.View):
def __init__(self, width=768, height=768):
self.bg_color = '#ffffff'
iv = ui.ImageView(frame=(0, 0, width, height))
bg = ui.Image.from_data(b.getvalue())
iv.image = bg
iv.content_mode = ui.CONTENT_SCALE_ASPECT_FILL
image_view = ui.ImageView()
image_view.image = ui.Image.named('Bullseye.png')
image_view.present()
pv = PathView(frame=self.bounds)
pv.action = self.path_action
blue_button = ui.ButtonItem()
blue_button.title = 'Bluebulls'
blue_button.action = self.bluebulls_action
red_button = ui.ButtonItem()
red_button.title = 'Redbulls'
red_button.tint_color = '#990000'
red_button.action = self.redbulls_action
maps_button = ui.ButtonItem()
maps_button.title = 'Maps'
maps_button.tint_color = '#000d99'
maps_button.action = self.map_action
save_button = ui.ButtonItem()
save_button.title = 'Save Image'
save_button.action = self.save_action
plot_button = ui.ButtonItem()
plot_button.title = 'Plot'
plot_button.tint_color = '#000d99'
plot_button.action = self.plot_action
clear_button = ui.ButtonItem()
clear_button.title = 'Clear'
clear_button.tint_color = '#af0000'
clear_button.action = self.clear_action
self.right_button_items = [save_button, plot_button, red_button]
self.left_button_items = [clear_button, maps_button, blue_button]
self.image_view = iv

def map_action(self, sender):
# Show an image picker dialog (allowing multiple selection) and print the result
assets = photos.pick_asset(title='Pick a Map', multi=True)

def path_action(self, sender):
path = sender.path
old_img = self.image_view.image
width, height = 768, 768

with ui.ImageContext(width, height) as ctx:
if old_img:
old_img.draw()
path.stroke()
self.image_view.image = ctx.get_image()

def redbulls_action(self, sender):
m=1
def bluebulls_action(self, sender):
m=1
def plot_action(self, sender):
self.image_view.image = ui.Image.from_data(b.getvalue())

def clear_action(self, sender):
self.image_view.image = None

def save_action(self, sender):
if self.image_view.image:
# We draw a new image here, so that it has the current
# orientation (the canvas is quadratic).
with ui.ImageContext(self.width, self.height) as ctx:
self.image_view.image.draw()
img = ctx.get_image()
photos.save_image(img)
else:

sv = SketchView()
sv.present()

Its starting to look like an useable app already👍🏻

I am looking into API's right Now not so hard to use and lots of them look it up.
Maybe you can find a nice project for u with the use of API's

Goodluck finding a Nice project!

• posted
0

Thank you!
Also, I kinda have a slightly random question. What is your favorite app or website to learn python on? I use SoloLearn right now, since it’s free.

• posted
1

@robStacks, suggest moving the Vector implementation to a file called vector.py in site-packages. Then you can import it and it does not distract you from your own code.

• posted
0

@mikael Yes thx for pointing that out to me did so and is so much better👍🏻

• posted
0

Yay! I’ve thought of a good project to do! Hopefully it won’t be too complicated... by the way, does anyone know how to display a picture? I’ve tried googling it, but it’s all a load of mumbo jumbo to me.

• posted
1

@Bumbo-Cactoni

Using Image Module:

import Image

with Image.open('my_img.png') as img:
img.show()

Using ui Module:

import ui

class MyView(ui.View):
def __init__(self, *args, **kwargs):
self.img = ui.Image.named('my_img.png')
self.iv = ui.ImageView(
image=self.img,
width=ui.get_screen_size(),
height=ui.get_screen_size())

MyView().present('fullscreen')

Using scene Module:

import scene

class MyScene(scene.Scene):
def setup(self):
self.sn=scene.SpriteNode(
texture=scene.Texture('my_img.png'),
parent=self,
position=self.size/2)

scene.run(MyScene())

• posted
0

@stephen
Thank you!

• posted
1

• posted
0

Now I have another question: How do you display a picture that you can move with your finger?

• posted
0

@Bumbo-Cactoni

😁 I like making these examples! Give me just a few.

• posted
0

@stephen
Have you ever seen, like, those super simple block-programming apps? That they use to semi-teach people to program?

• posted
0

I am trying to make my own block-programming thingy, but I don’t know how to create the blocks, make them movable, or even make them connect together.

• posted
0

@Bumbo-Cactoni

Like minecraft/terreria?

• posted
0

@stephen

You mean like moving the items in the inventories?
If so, yes, that is kinda what I mean.

• posted
1

@Bumbo-Cactoni

from scene import *

def Dirt(parent, pos, size=(64, 64)):
sn=SpriteNode(
texture=Texture('plf:Ground_GrassCenter'),
parent=parent,
anchor_point=(0.0, 0.0),
size=size,
position=pos)
return sn

def Stone(parent, pos, size=(64, 64)):
sn=SpriteNode(
texture=Texture('plf:Ground_DirtCenter'),
parent=parent,
anchor_point=(0.0, 0.0),
size=size,
position=pos)
return sn

def fixed_position(x, fixed_val=64):
return x - x%fixed_val

class MyScene(Scene):
def setup(self):
self.active_block=None
self.anchor_point=(0.0, 0.0),
self.dirt_button=Dirt(self, (self.size/2-80, self.size-196))
self.stone_button=Stone(self, (self.size/2+80, self.size-196))

def touch_began(self, touch):
if touch.location in self.dirt_button.frame:
self.active_block=Dirt(self, touch.location)
if touch.location in self.stone_button.frame:
self.active_block=Stone(self, touch.location)

def touch_moved(self, touch):
if self.active_block:
self.active_block.position=touch.location

def touch_ended(self, touch):
x, y = self.active_block.position
self.active_block.position=(fixed_position(x), fixed_position(y))
self.active_block=None

run(MyScene())

Internal error.

Oops! Looks like something went wrong!