hangman by python

import random

user=str(input("What's your name?"))

print("Are you ready?",user)

words=["hangman","egypt","apple","sony","tigger","spiderman","superman","sniper"]

secretkey=random.choice(words)

turns=10

print("You have turns:",turns)

guess=""

while True:

    failed=0

    for char in secretkey:

        if char in guess:

            print(char)

        else:

            print("_")  

            failed+=1

    if failed==0:

        print("you won")

        break       

    guesses=str(input("Enter your guess:"))

    guess+=guesses

    if guesses not in secretkey:

        print("Wrong")

        turns-=1

        print("You have turns :",turns)

        if turns==0:

            print("you lose")

            break

python 2

ثاني شروحات لغة البرمجة الشهيرة python
مميزات اللغة :
سهلة في التعلم
توفر الكثير من الاختيارات مثل اللغات الاحترافية مثل c++/java
لا تحتاج الي اجهزة قوية لتشغيلها بسلاسة

رابط الحلقة:
https://youtu.be/H3-Z8TIvH5I
رابط visual studio code:
https://code.visualstudio.com/
رابط برنامج python 3.0:
python

pacman by python

'''

Exercises

1. Change the board.

2. Change the number of ghosts.

3. Change where pacman starts.

4. Make the ghosts faster/slower.

5. Make the ghosts smarter.

'''

from random import choice

from turtle import *

from freegames import floor, vector

state = {'score': 0}

path = Turtle(visible=False)

writer = Turtle(visible=False)

aim = vector(5, 0)

pacman = vector(-40, -80)

ghosts = [

    [vector(-180, 160), vector(5, 0)],

    [vector(-180, -160), vector(0, 5)],

    [vector(100, 160), vector(0, -5)],

    [vector(100, -160), vector(-5, 0)],

]

tiles = [

    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

    0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0,

    0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0,

    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0,

    0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0,

    0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0,

    0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,

    0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0,

    0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0,

    0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0,

    0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0,

    0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0,

    0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,

    0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0,

    0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0,

    0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0,

    0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,

    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0,

    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

]

def square(x, y):

    "Draw square using path at (x, y)."

    path.up()

    path.goto(x, y)

    path.down()

    path.begin_fill()

    for count in range(4):

        path.forward(20)

        path.left(90)

    path.end_fill()

def offset(point):

    "Return offset of point in tiles."

    x = (floor(point.x, 20) + 200) / 20

    y = (180 - floor(point.y, 20)) / 20

    index = int(x + y * 20)

    return index

def valid(point):

    "Return True if point is valid in tiles."

    index = offset(point)

    if tiles[index] == 0:

        return False

    index = offset(point + 19)

    if tiles[index] == 0:

        return False

    return point.x % 20 == 0 or point.y % 20 == 0

def world():

    "Draw world using path."

    bgcolor('black')

    path.color('blue')

    for index in range(len(tiles)):

        tile = tiles[index]

        if tile > 0:

            x = (index % 20) * 20 - 200

            y = 180 - (index // 20) * 20

            square(x, y)

            if tile == 1:

                path.up()

                path.goto(x + 10, y + 10)

                path.dot(2, 'white')

def move():

    "Move pacman and all ghosts."

    writer.undo()

    writer.write(state['score'])

    clear()

    if valid(pacman + aim):

        pacman.move(aim)

    index = offset(pacman)

    if tiles[index] == 1:

        tiles[index] = 2

        state['score'] += 1

        x = (index % 20) * 20 - 200

        y = 180 - (index // 20) * 20

        square(x, y)

    up()

    goto(pacman.x + 10, pacman.y + 10)

    dot(20, 'yellow')

    for point, course in ghosts:

        if valid(point + course):

            point.move(course)

        else:

            options = [

                vector(5, 0),

                vector(-5, 0),

                vector(0, 5),

                vector(0, -5),

            ]

            plan = choice(options)

            course.x = plan.x

            course.y = plan.y

        up()

        goto(point.x + 10, point.y + 10)

        dot(20, 'red')

    update()

    for point, course in ghosts:

        if abs(pacman - point) < 20:

            return

    ontimer(move, 100)

def change(x, y):

    "Change pacman aim if valid."

    if valid(pacman + vector(x, y)):

        aim.x = x

        aim.y = y

setup(420, 420, 370, 0)

hideturtle()

tracer(False)

writer.goto(160, 160)

writer.color('white')

writer.write(state['score'])

listen()

onkey(lambda: change(5, 0), 'Right')

onkey(lambda: change(-5, 0), 'Left')

onkey(lambda: change(0, 5), 'Up')

onkey(lambda: change(0, -5), 'Down')

world()

move()

done()

tetris by python

import pygame

import random

 

"""

10 x 20 square grid

shapes: S, Z, I, O, J, L, T

represented in order by 0 - 6

"""

 

pygame.font.init()

 

# GLOBALS VARS

s_width = 800

s_height = 700

play_width = 300  # meaning 300 // 10 = 30 width per block

play_height = 600  # meaning 600 // 20 = 20 height per blo ck

block_size = 30

 

top_left_x = (s_width - play_width) // 2

top_left_y = s_height - play_height

 

 

# SHAPE FORMATS

 

S = [['.....',

      '.....',

      '..00.',

      '.00..',

      '.....'],

     ['.....',

      '..0..',

      '..00.',

      '...0.',

      '.....']]

 

Z = [['.....',

      '.....',

      '.00..',

      '..00.',

      '.....'],

     ['.....',

      '..0..',

      '.00..',

      '.0...',

      '.....']]

 

I = [['..0..',

      '..0..',

      '..0..',

      '..0..',

      '.....'],

     ['.....',

      '0000.',

      '.....',

      '.....',

      '.....']]

 

O = [['.....',

      '.....',

      '.00..',

      '.00..',

      '.....']]

 

J = [['.....',

      '.0...',

      '.000.',

      '.....',

      '.....'],

     ['.....',

      '..00.',

      '..0..',

      '..0..',

      '.....'],

     ['.....',

      '.....',

      '.000.',

      '...0.',

      '.....'],

     ['.....',

      '..0..',

      '..0..',

      '.00..',

      '.....']]

 

L = [['.....',

      '...0.',

      '.000.',

      '.....',

      '.....'],

     ['.....',

      '..0..',

      '..0..',

      '..00.',

      '.....'],

     ['.....',

      '.....',

      '.000.',

      '.0...',

      '.....'],

     ['.....',

      '.00..',

      '..0..',

      '..0..',

      '.....']]

 

T = [['.....',

      '..0..',

      '.000.',

      '.....',

      '.....'],

     ['.....',

      '..0..',

      '..00.',

      '..0..',

      '.....'],

     ['.....',

      '.....',

      '.000.',

      '..0..',

      '.....'],

     ['.....',

      '..0..',

      '.00..',

      '..0..',

      '.....']]

 

shapes = [S, Z, I, O, J, L, T]

shape_colors = [(0, 255, 0), (255, 0, 0), (0, 255, 255), (255, 255, 0), (255, 165, 0), (0, 0, 255), (128, 0, 128)]

# index 0 - 6 represent shape

 

 

class Piece(object):

    rows = 20  # y

    columns = 10  # x

 

    def __init__(self, column, row, shape):

        self.x = column

        self.y = row

        self.shape = shape

        self.color = shape_colors[shapes.index(shape)]

        self.rotation = 0  # number from 0-3

 

 

def create_grid(locked_positions={}):

    grid = [[(0,0,0) for x in range(10)] for x in range(20)]

 

    for i in range(len(grid)):

        for j in range(len(grid[i])):

            if (j,i) in locked_positions:

                c = locked_positions[(j,i)]

                grid[i][j] = c

    return grid

 

 

def convert_shape_format(shape):

    positions = []

    format = shape.shape[shape.rotation % len(shape.shape)]

 

    for i, line in enumerate(format):

        row = list(line)

        for j, column in enumerate(row):

            if column == '0':

                positions.append((shape.x + j, shape.y + i))

 

    for i, pos in enumerate(positions):

        positions[i] = (pos[0] - 2, pos[1] - 4)

 

    return positions

 

 

def valid_space(shape, grid):

    accepted_positions = [[(j, i) for j in range(10) if grid[i][j] == (0,0,0)] for i in range(20)]

    accepted_positions = [j for sub in accepted_positions for j in sub]

    formatted = convert_shape_format(shape)

 

    for pos in formatted:

        if pos not in accepted_positions:

            if pos[1] > -1:

                return False

 

    return True

 

 

def check_lost(positions):

    for pos in positions:

        x, y = pos

        if y < 1:

            return True

    return False

 

 

def get_shape():

    global shapes, shape_colors

 

    return Piece(5, 0, random.choice(shapes))

 

 

def draw_text_middle(text, size, color, surface):

    font = pygame.font.SysFont('comicsans', size, bold=True)

    label = font.render(text, 1, color)

 

    surface.blit(label, (top_left_x + play_width/2 - (label.get_width() / 2), top_left_y + play_height/2 - label.get_height()/2))

 

 

def draw_grid(surface, row, col):

    sx = top_left_x

    sy = top_left_y

    for i in range(row):

        pygame.draw.line(surface, (128,128,128), (sx, sy+ i*30), (sx + play_width, sy + i * 30))  # horizontal lines

        for j in range(col):

            pygame.draw.line(surface, (128,128,128), (sx + j * 30, sy), (sx + j * 30, sy + play_height))  # vertical lines

 

 

def clear_rows(grid, locked):

    # need to see if row is clear the shift every other row above down one

 

    inc = 0

    for i in range(len(grid)-1,-1,-1):

        row = grid[i]

        if (0, 0, 0) not in row:

            inc += 1

            # add positions to remove from locked

            ind = i

            for j in range(len(row)):

                try:

                    del locked[(j, i)]

                except:

                    continue

    if inc > 0:

        for key in sorted(list(locked), key=lambda x: x[1])[::-1]:

            x, y = key

            if y < ind:

                newKey = (x, y + inc)

                locked[newKey] = locked.pop(key)

 

 ### Draw Next Shape##

def draw_next_shape(shape, surface):

    font = pygame.font.SysFont('comicsans', 30)

    label = font.render('Next Shape', 1, (255,255,255))

 

    sx = top_left_x + play_width + 50

    sy = top_left_y + play_height/2 - 100

    format = shape.shape[shape.rotation % len(shape.shape)]

 

    for i, line in enumerate(format):

        row = list(line)

        for j, column in enumerate(row):

            if column == '0':

                pygame.draw.rect(surface, shape.color, (sx + j*30, sy + i*30, 30, 30), 0)

 

    surface.blit(label, (sx + 10, sy- 30))

 

 

def draw_window(surface):

    surface.fill((0,0,0))

    # Tetris Title

    font = pygame.font.SysFont('comicsans', 60)

    label = font.render('TETRIS', 1, (255,255,255))

 

    surface.blit(label, (top_left_x + play_width / 2 - (label.get_width() / 2), 30))

 

    for i in range(len(grid)):

        for j in range(len(grid[i])):

            pygame.draw.rect(surface, grid[i][j], (top_left_x + j* 30, top_left_y + i * 30, 30, 30), 0)

 

    # draw grid and border

    draw_grid(surface, 20, 10)

    pygame.draw.rect(surface, (255, 0, 0), (top_left_x, top_left_y, play_width, play_height), 5)

    # pygame.display.update()

 

 

def main():

    global grid

 

    locked_positions = {}  # (x,y):(255,0,0)

    grid = create_grid(locked_positions)

 

    change_piece = False

    run = True

    current_piece = get_shape()

    next_piece = get_shape()

    clock = pygame.time.Clock()

    fall_time = 0

 

    while run:

        fall_speed = 0.27

 

        grid = create_grid(locked_positions)

        fall_time += clock.get_rawtime()

        clock.tick()

 

        # PIECE FALLING CODE

        if fall_time/1000 >= fall_speed:

            fall_time = 0

            current_piece.y += 1

            if not (valid_space(current_piece, grid)) and current_piece.y > 0:

                current_piece.y -= 1

                change_piece = True

 

        for event in pygame.event.get():

            if event.type == pygame.QUIT:

                run = False

                pygame.display.quit()

                quit()

 

            if event.type == pygame.KEYDOWN:

                if event.key == pygame.K_LEFT:

                    current_piece.x -= 1

                    if not valid_space(current_piece, grid):

                        current_piece.x += 1

 

                elif event.key == pygame.K_RIGHT:

                    current_piece.x += 1

                    if not valid_space(current_piece, grid):

                        current_piece.x -= 1

                elif event.key == pygame.K_UP:

                    # rotate shape

                    current_piece.rotation = current_piece.rotation + 1 % len(current_piece.shape)

                    if not valid_space(current_piece, grid):

                        current_piece.rotation = current_piece.rotation - 1 % len(current_piece.shape)

 

                if event.key == pygame.K_DOWN:

                    # move shape down

                    current_piece.y += 1

                    if not valid_space(current_piece, grid):

                        current_piece.y -= 1

 

                if event.key == pygame.K_SPACE:

                   while valid_space(current_piece, grid):

                       current_piece.y += 1

                   current_piece.y -= 1

                   print(convert_shape_format(current_piece))

 

        shape_pos = convert_shape_format(current_piece)

 

        # add piece to the grid for drawing

        for i in range(len(shape_pos)):

            x, y = shape_pos[i]

            if y > -1:

                grid[y][x] = current_piece.color

 

        # IF PIECE HIT GROUND

        if change_piece:

            for pos in shape_pos:

                p = (pos[0], pos[1])

                locked_positions[p] = current_piece.color

            current_piece = next_piece

            next_piece = get_shape()

            change_piece = False

 

            # call four times to check for multiple clear rows

            clear_rows(grid, locked_positions)

 

        draw_window(win)

        draw_next_shape(next_piece, win)

        pygame.display.update()

 

        # Check if user lost

        if check_lost(locked_positions):

            run = False

 

    draw_text_middle("You Lost", 40, (255,255,255), win)

    pygame.display.update()

    pygame.time.delay(2000)

 

 

def main_menu():

    run = True

    while run:

        win.fill((0,0,0))

        draw_text_middle('Press any key to begin.', 60, (255, 255, 255), win)

        pygame.display.update()

        for event in pygame.event.get():

            if event.type == pygame.QUIT:

                run = False

 

            if event.type == pygame.KEYDOWN:

                main()

    pygame.quit()

 

 

win = pygame.display.set_mode((s_width, s_height))

pygame.display.set_caption('Tetris')

 

main_menu()  # start game

game tile by python

"""Tiles, number swapping game.

Exercises

1. Track a score by the number of tile moves.

2. Permit diagonal squares as neighbors.

3. Respond to arrow keys instead of mouse clicks.

4. Make the grid bigger.

"""

from random import *

from turtle import *

from freegames import floor, vector

tiles = {}

neighbors = [

    vector(100, 0),

    vector(-100, 0),

    vector(0, 100),

    vector(0, -100),

]

def load():

    "Load tiles and scramble."

    count = 1

    for y in range(-200, 200, 100):

        for x in range(-200, 200, 100):

            mark = vector(x, y)

            tiles[mark] = count

            count += 1

    tiles[mark] = None

    for count in range(1000):

        neighbor = choice(neighbors)

        spot = mark + neighbor

        if spot in tiles:

            number = tiles[spot]

            tiles[spot] = None

            tiles[mark] = number

            mark = spot

def square(mark, number):

    "Draw white square with black outline and number."

    up()

    goto(mark.x, mark.y)

    down()

    color('black', 'white')

    begin_fill()

    for count in range(4):

        forward(99)

        left(90)

    end_fill()

    if number is None:

        return

    elif number < 10:

        forward(20)

    write(number, font=('Arial', 60, 'normal'))

def tap(x, y):

    "Swap tile and empty square."

    x = floor(x, 100)

    y = floor(y, 100)

    mark = vector(x, y)

    for neighbor in neighbors:

        spot = mark + neighbor

        if spot in tiles and tiles[spot] is None:

            number = tiles[mark]

            tiles[spot] = number

            square(spot, number)

            tiles[mark] = None

            square(mark, None)

def draw():

    "Draw all tiles."

    for mark in tiles:

        square(mark, tiles[mark])

    update()

setup(420, 420, 370, 0)

hideturtle()

tracer(False)

load()

draw()

onscreenclick(tap)

done()

ping pong by python

# Simple Pong in Python 3 for Beginners

# By @TokyoEdTech

import turtle

import os

wn = turtle.Screen()

wn.title("Pong")

wn.bgcolor("black")

wn.setup(width=800, height=600)

wn.tracer(0)

# Score

score_a = 0

score_b = 0

# Paddle A

paddle_a = turtle.Turtle()

paddle_a.speed(0)

paddle_a.shape("square")

paddle_a.color("white")

paddle_a.shapesize(stretch_wid=5,stretch_len=1)

paddle_a.penup()

paddle_a.goto(-350, 0)

# Paddle B

paddle_b = turtle.Turtle()

paddle_b.speed(0)

paddle_b.shape("square")

paddle_b.color("white")

paddle_b.shapesize(stretch_wid=5,stretch_len=1)

paddle_b.penup()

paddle_b.goto(350, 0)

# Ball

ball = turtle.Turtle()

ball.speed(0)

ball.shape("square")

ball.color("white")

ball.penup()

ball.goto(0, 0)

ball.dx = 2

ball.dy = 2

# Pen

pen = turtle.Turtle()

pen.speed(0)

pen.shape("square")

pen.color("white")

pen.penup()

pen.hideturtle()

pen.goto(0, 260)

pen.write("Player A: 0  Player B: 0", align="center", font=("Courier", 24, "normal"))

# Functions

def paddle_a_up():

    y = paddle_a.ycor()

    y += 20

    paddle_a.sety(y)

def paddle_a_down():

    y = paddle_a.ycor()

    y -= 20

    

    paddle_a.sety(y)

def paddle_b_up():

    y = paddle_b.ycor()

    y += 20

    paddle_b.sety(y)

def paddle_b_down():

    y = paddle_b.ycor()

    y -= 20

    paddle_b.sety(y)

# Keyboard bindings

wn.listen()

wn.onkeypress(paddle_a_up, "w")

wn.onkeypress(paddle_a_down, "s")

wn.onkeypress(paddle_b_up, "Up")

wn.onkeypress(paddle_b_down, "Down")

# Main game loop

while True:

    wn.update()

    

    # Move the ball

    ball.setx(ball.xcor() + ball.dx)

    ball.sety(ball.ycor() + ball.dy)

    # Border checking

    # Top and bottom

    if ball.ycor() > 290:

        ball.sety(290)

        ball.dy *= -1

        os.system("afplay bounce.wav&")

    

    elif ball.ycor() < -290:

        ball.sety(-290)

        ball.dy *= -1

        os.system("afplay bounce.wav&")

    # Left and right

    if ball.xcor() > 350:

        score_a += 1

        pen.clear()

        pen.write("Player A: {}  Player B: {}".format(score_a, score_b), align="center", font=("Courier", 24, "normal"))

        ball.goto(0, 0)

        ball.dx *= -1

    elif ball.xcor() < -350:

        score_b += 1

        pen.clear()

        pen.write("Player A: {}  Player B: {}".format(score_a, score_b), align="center", font=("Courier", 24, "normal"))

        ball.goto(0, 0)

        ball.dx *= -1

    # Paddle and ball collisions

    if ball.xcor() < -340 and ball.ycor() < paddle_a.ycor() + 50 and ball.ycor() > paddle_a.ycor() - 50:

        ball.dx *= -1 

        os.system("afplay bounce.wav&")

    

    elif ball.xcor() > 340 and ball.ycor() < paddle_b.ycor() + 50 and ball.ycor() > paddle_b.ycor() - 50:

        ball.dx *= -1

        os.system("afplay bounce.wav&")