Why does rotated image move by itself?

I rotate an image and I adjust the rect to the rotated image. When I start the program, the image starts moving, without any order by the program. There are, for testing, some pictures needed. I hope, as more experienced users, can take some standards.

import pygame
import sys
from pygame.constants import KEYUP
from pygame.constants import KEYDOWN
import math
import random

pygame.init()

cell_size = 40
cell_number = 20
breite = int(cell_size * cell_number )
hoehe  = int( cell_size * cell_number ) 
screen = pygame.display.set_mode((breite,hoehe))
clock = pygame.time.Clock()

anzahl_gegenstaende = 10 # gehört zu landschaft

class MeinAuto(pygame.sprite.Sprite):
       
    def __init__(self,x,y):
        pygame.sprite.Sprite.__init__(self) 
        self.image = pygame.transform.scale(auto_img,(30,66)).convert_alpha()         
        self.rect = self.image.get_rect(center=(x,y))            
        self.rect.x = x
        self.rect.y = y 
        self.mask = pygame.mask.from_surface(self.image )   
        self.wagen_winkel = 0
        self.speed = 5
        self.links = False
        self.rechts = False 
        self.vor = False 
        self.zurueck = False      
        self.lenk_winkel = 0
        self.block_vor = False
        self.block_zurueck = False       
      
    def update(self):  
        for event in events:
            if event.type == pygame.KEYDOWN:     

                if event.key == pygame.K_LEFT: 
                    if self.vor or self.zurueck:                    
                        self.links = True                        
                if event.key == pygame.K_RIGHT:
                      if self.vor or self.zurueck:  
                        self.rechts = True
                        
                if event.key == pygame.K_UP:
                        self.vor = True                       
                if event.key == pygame.K_DOWN:
                        self.zurueck = True   
                                      
            elif event.type == pygame.KEYUP:        
                if event.key == pygame.K_LEFT:                  
                        self.links = False
                if event.key == pygame.K_RIGHT:
                        self.rechts = False
                if event.key == pygame.K_UP:
                        self.vor = False
                if event.key == pygame.K_DOWN:
                        self.zurueck = False

        self.winkel_berechnung(1) 
         
        dx = math.cos(math.radians(self.wagen_winkel))
        dy = math.sin(math.radians(self.wagen_winkel))  

        if self.vor and self.block_vor == False:
            self.rect.y -= int(self.speed * dx)
            self.rect.x -= int(self.speed * dy)
            self.block_zurueck = False
          
        elif self.zurueck and self.block_zurueck == False:
            self.rect.y += int(self.speed * dx)
            self.rect.x += int(self.speed * dy)
            self.block_vor = False

        if self.links:
            self.lenk_winkel +=5            
            self.lenk_winkel=min(self.lenk_winkel,120) 
        elif self.rechts:
            self.lenk_winkel -=1            
            self.lenk_winkel=max(self.lenk_winkel,-120)

        if not self.links and not self.rechts: self.lenk_winkel = 0
    
    def winkel_berechnung(self,dt):
  
        if self.rechts:                   
            self.wagen_winkel += self.lenk_winkel           
            while self.wagen_winkel < 0:
               self.wagen_winkel += 360
        elif self.links:                       
            self.wagen_winkel += self.lenk_winkel           
            while self.wagen_winkel > 359:
                  self.wagen_winkel -= 360
     
class Lenkung(pygame.sprite.Sprite):       
    def __init__(self,x,y):
        pygame.sprite.Sprite.__init__(self) 
        self.image = pygame.transform.scale(lenkrad_img,(120,120)).convert_alpha()           
        self.rect = self.image.get_rect()
        self.rect.x = x
        self.rect.y = y       
        self.wagen_winkel = 0

class Landschaft(pygame.sprite.Sprite):
       
    def __init__(self,image):
        pygame.sprite.Sprite.__init__(self) 
        self.image = image 
        self.mask = pygame.mask.from_surface(self.image )
        x=random.randrange(60, breite -60) 
        y=random.randrange(200, hoehe - 200) 
        self.rect = self.image.get_rect(center =(x,y))              
 
def zeichne_hintergrund():
    background = pygame.image.load("Bilder/background_gelb.jpg") 
    screen.blit(background,(0,0))  

def blitRotateCenter(image, left, top, angle):
    rotated_image = pygame.transform.rotate(image, angle)
    new_rect = rotated_image.get_rect(center = image.get_rect(center = (left, top)).center)
    screen.blit(rotated_image, new_rect)
    return new_rect

########## Bilder laden
auto_img = pygame.image.load("Bilder/car.png") 
lenkrad_img = pygame.image.load("bilder/lenkrad.png")


#########  Gruppen bilden

auto = MeinAuto(breite/2,hoehe-100)
auto_sprite = pygame.sprite.Group()
auto_sprite.add(auto)

lenkung = Lenkung(breite/2,60)
lenkung_sprite = pygame.sprite.Group()
lenkung_sprite.add(lenkung)


land = pygame.sprite.Group()
while len(land) < anzahl_gegenstaende:
        ii = len(land)   
        img = pygame.image.load(f"Bilder/Gegenstaende/geg{ii}.png")    
        img = pygame.transform.scale(img,(100,100))  
        m = Landschaft(img) 
      
        if not pygame.sprite.spritecollide(m, land, False):
            land.add(m)

while True:
    clock.tick(6)   
    zeichne_hintergrund()

    events = pygame.event.get()
    for event in events:                     
        if event.type == pygame.QUIT:
            pygame.quit()
            sys.exit() 

        hits = pygame.sprite.spritecollide( auto, land, False, pygame.sprite.collide_mask)
        for hit in hits:
            pass               
     
    auto_sprite.update()
  
    land.draw(screen)
          
    new_auto_rect =blitRotateCenter(auto.image, auto.rect.x, auto.rect.y, auto.wagen_winkel)
    auto.rect=new_auto_rect
    new_auto_rect = new_auto_rect.inflate(-80,-50)
    
    blitRotateCenter(lenkung.image, lenkung.rect.x, lenkung.rect.y, auto.lenk_winkel)
    pygame.draw.rect(screen,(0,250,0),auto.rect,4)
    pygame.draw.rect(screen,(250,250,0),new_auto_rect,1)    
    pygame.display.flip()

from Recent Questions - Stack Overflow https://ift.tt/3EELWnX
https://ift.tt/eA8V8J