def leave(self, car):
if car not in self.parking_lot:
raise ValueError('车不在车位内')
self.parking_lot.remove(car)
@property
def left_parking_lot_number(self):
return self.parking_lot_number - len(self.parking_lot)
def test_parking():
yuanling = YuanlingEightRoad()
yuanling.parking(cai_car)
yuanling.parking(gong_car)
yuanling.parking(cat_car)
def test_left_parking_log_number():
yuanling = YuanlingEightRoad()
yuanling.parking(cai_car)
yuanling.parking(gong_car)
print(yuanling.left_parking_lot_number)
if __name__ == '__main__':
cai_car = Car('cai')
gong_car = Car('gong')
cat_car = Car('baobao')
test_left_parking_log_number()
from nn import NeuralNetwork
import pickle
from car import Car
import time
import numpy as np
import timeit
car = Car('127.0.0.1', 5555, 0.4, 0.25)
clf = pickle.load(open('svr_redict', 'rb'))
def cal_direction(img):
x = img.flatten().reshape(-1)
dir = clf.predict(x)
return x
'''
network = NeuralNetwork(494, 10, 21, 1.2)
parameters_file_name = 'weights'
network.load_parameters(parameters_file_name)
def cal_direction(img):
x = img.flatten().reshape(-1)
vec = network.predict(x)
return vec
def test_cam():
# 2. 这种导入方式还可能引发名称方面的困惑。
# 如果你不小心导入了一个与程序文件中其他东西同名的类，将引发难以诊断的错误。
# 需要从一个模块中导入很多类时，最好导入整个模块，并使用module_name.class_name语法来访问类。(也就是方法三)
# 1. 这样做时，虽然文件开头并没有列出用到的所有类，但你清楚地知道在程序的哪些地方使用了导入的模块;
# 2. 你还避免了导入模块中的每个类可能引发的名称冲突。
# 这里之所以介绍这种导入方式，是因为虽然不推荐使用这种方式，但你可能会在别人编写的代码中见到它。
# from car import *
# 调用方法：Car() or ElectricCar() or Battery()
print('\n在一个模块中导入另一个模块')
# 有时候，需要将类分散到多个模块中，以免模块太大，或在同一个模块中存储不相关的类。
# 将类存储在多个模块中时，你可能会发现一个模块中的类依赖于另一个模块中的类。
# 在这种情况下，可在前一个模块中导入必要的类。
# ！！！！！！！！！！！！！！！！！（此处未实践）！！！！！！！！！！！！！！！！！！！！！！！
from car import Car, ElectricCar
my_new_car = Car('audi', 'a4', 2016)
print(my_new_car.get_descriptive_name())
my_new_car.odometer_reading = 23
my_new_car.read_odometer()
my_tesla = ElectricCar('tesla', 'models', 2016)
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()
my_tesla.battery.get_range()
from car import Car
print('\n*****\n')
my_new_car = Car('BMW', 'a4', '2016')
print(my_new_car.get_descriptive_name())
my_new_car.odometer_reading = 23
my_new_car.read_odometer()
from car import Car #导入模块下的类
import electric_car #导入整个模块
from collections import OrderedDict
my_car = Car("audi", "a9", 2019)
my_car.set_odometer(1000)
print(my_car.read_odometer())
my_car.fill_gas(999)
electric_car = electric_car.ElectricCar("audi", "a8", 3011)
electric_car.electric_run(10000)
electric_car.set_odometer(100)
print(electric_car.read_odometer())
electric_car.fill_gas(999)
languages = OrderedDict()
languages['jen'] = 'python'
languages['sarah'] = 'c'
languages['oliver'] = 'ruby'
languages['lee'] = 'python'
print(languages)
def test_object_type(self):
honda = Car('Honda')
self.assertTrue((type(honda) is Car),
msg='The object should be a type of `Car`')
def test_car_instance(self):
honda = Car('Honda')
self.assertIsInstance(
honda,
Car,
msg='The object should be an instance of the `Car` class')
def test_registered_cars(self):
a = Car('AAA-001')
b = Car('AAA-002')
self.assertEqual(b.registered_cars, ['AAA-001', 'AAA-002'],
"Should be ['AAA-001', 'AAA-002']")
def test_car_count(self):
a = Car('AAA-001')
b = Car('AAA-002')
self.assertEqual(b.car_count, 2, "Should be 2")
def test_add_car_number_in_class(self):
a = Car('AAA-002')
self.assertEqual(a.car_number, 'AAA-002', "Should be AAA-002")
def test_add_car_number_in_instance(self):
b = Car()
b.car_number = "AAA-001"
self.assertEqual(b.car_number, "AAA-001", "Should be AAA-001")
car.pos = pos
self.cars.append(car)
self.cells[pos[0], pos[1]] = self.possible_states['full']
return True
return False
def rmCar(self, car: Car):
"""Удалить указанную машину из списка машин на полосе.
:param car: машина для удаления.
"""
self.cars.remove(car)
self._update_cells()
if __name__ == '__main__':
print(Road(1, 2, 30, [], name='Wall Street', n_lanes=2))
u, v = 1, 2
capacity = 30
lanes = 4
n = 10
cars = [Car(pos=(i, j)) for i in range(0, lanes) for j in range(0, n, 2)]
for car in cars:
print(car)
r = Road(u, v, capacity, cars, name='Wall Street', n_lanes=lanes)
print(r)
print(r.cells)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2018/8/20 9:40
# @Author : Zhou
# @File : my_car.py
# @IDE : PyCharm
# @Description: my_car 从car模块中导入Car/ElectricCar类
from car import Car, ElectricCar # 或直接导入整个car模块
my_new_car = Car("audi", 'a4', 2016)
print(my_new_car.get_descriptive_name())
my_tesla = ElectricCar('tesla', 'roadster', 2016)
print(my_tesla.get_descriptive_name())
def handle_release_car():
car = Car(request.form)
return dispatcher.release_car(car)
from car import Car
import random
small_car = Car("white", "BMW", 250, 0, 0)
big_car = Car("brown", "Range Rover", 250, 0, 0)
# start the race
for x in range(3):
big_car.start()
small_car.start()
# accelerate cars
big_car.accelerate(x * random.randint(5, 20))
small_car.accelerate(x * random.randint(5, 20))
for x in range(3):
# brake cars
big_car.brake(x * random.randint(5, 20))
small_car.brake(x * random.randint(5, 20))
print(f"{big_car.brand} speed: ", big_car.get_current_speed())
print(f"{small_car.brand} speed: ", small_car.get_current_speed())
# find the winner
speed_small_car = small_car.get_current_speed()
speed_big_car = big_car.get_current_speed()
if speed_small_car == 0 and speed_big_car > 0:
# big car wins
print(f"{small_car.brand} has lost the race")
print(f"{big_car.brand} has won the race")
elif speed_big_car == 0 and speed_small_car > 0:
# small car wins
"""
File Description: car rental application
Student ID : 10543531
Student Name: Wenjuan Zhao
Git hub: https://github.com/lulu0066/B8IT105.git
"""
import pandas as pd
from car import Car, PetrolCar, DieselCar, ElectricCar, HybridCar
from carRental import CarFleet
dbsCarRental = CarFleet()
myCar = Car()
myCar.setColour('Silver')
petrol = PetrolCar()
petrol.setMake('Ford')
petrol.setModel('Focus')
petrol.setEngineSize('1.6')
diesel = DieselCar()
diesel.setMake('Renault')
diesel.setModel('Clio')
diesel.setEngineSize('1.5')
electric = ElectricCar()
electric.setMake('Nissan')
electric.setModel('Leaf')
electric.setNumberFuelCells('62KWH')
hybrid = HybridCar()
# mutation
return new_weights
# initialize weights in range -1 to 1
weights = 2 * np.random.rand(num_cars, 2, 12) - 1
for e in range(epochs + 1):
print(f"Epoch - {e} / {epochs}")
# create n_cars
my_cars = []
for n in range(num_cars):
my_cars.append(Car(track, example_accl_function))
# Test run the cars and get their utilities
utilities = []
for n in tqdm(range(len(my_cars)), desc="cars"):
car = my_cars[n]
for i in range(iter):
car.run(w=weights[n])
u = car.utility()
utilities.append(u[0])
# update the weights
weights = update_weights(weights, utilities)
# display relevant info
print(
def start(self):
def update(dt, batch):
distance = player_car.getDistance()
speed = player_car.getSpeed()
rotationspeed = player_car.getRotationSpeed()
rotation = player_car.getRotation()
action = RL.choose_action("d:{},s:{},rs:{},r:{}".format(
str(round(distance, 0)), str(round(speed, 0)),
str(round(rotationspeed, 0)), str(round(rotation, 0))))
player_car.action(action)
for obj in game_objects:
obj.update(dt, batch)
player_car.actionreset()
reward = player_car.getScore() - self.score
self.score = player_car.getScore()
print("{} -- {}".format(action, reward))
_distance = player_car.getDistance()
_speed = player_car.getSpeed()
_rotationspeed = player_car.getRotationSpeed()
_rotation = player_car.getRotation()
if (distance > 100 or reward > 10):
player_car.reset(200, 200)
else:
done = False
RL.learn(
"d:{},s:{},rs:{},r:{}".format(str(round(distance, 0)),
str(round(speed, 0)),
str(round(rotationspeed, 0)),
str(round(rotation,
0))), action, reward,
"d:{},s:{},rs:{},r:{}".format(str(round(_distance, 0)),
str(round(_speed, 0)),
str(round(_rotationspeed, 0)),
str(round(_rotation, 0))))
def updateh(dt, batch):
for obj in game_objects:
obj.update(dt, batch)
def updatel(dt, batch):
if (self.r != True):
learn(dt, batch)
self.r = True
else:
print("E")
def learn(dt, batch):
for episode in range(100):
player_car.reset(200, 200)
distance = player_car.getDistance()
speed = player_car.getSpeed()
done = False
while True:
action = RL.choose_action(str(distance))
player_car.action(action)
update(1 / 144, batch)
player_car.actionreset()
reward = player_car.getScore() + -1 * (
player_car.getDistance() / 100.0) * .5
_distance = player_car.getDistance()
_speed = player_car.getSpeed()
if (distance > 1000 or reward > 10):
done = True
else:
done = False
print(action)
print(distance)
print(reward)
RL.learn(str(distance), action, reward, str(_distance))
distance = _distance
speed = _speed
if done:
break
pyglet.resource.path = ['resources']
pyglet.resource.reindex()
#game_window = pyglet.window.Window()
game_window = pyglet.window.Window(width=1280, height=720)
gl.glClearColor(.25, .25, .25, 1)
batch = pyglet.graphics.Batch()
car_image = pyglet.resource.image("car.png")
center_image(car_image)
score_label = pyglet.text.Label(text="Rotations: 0",
x=10,
y=575,
batch=batch)
distance_label = pyglet.text.Label(text="Distance: 0",
x=10,
y=555,
batch=batch)
speed_label = pyglet.text.Label(text="Speed: 0",
x=10,
y=535,
batch=batch)
rotationspeed_label = pyglet.text.Label(text="Rotation Speed: 0",
x=10,
y=515,
batch=batch)
direction_label = pyglet.text.Label(text="Direction: 0",
x=10,
y=495,
batch=batch)
fps_label = pyglet.text.Label(text="fps: 0", x=10, y=475, batch=batch)
player_car = Car(img=car_image, x=200, y=200, batch=batch)
player_car.scale = CAR_SIZE
game_window.push_handlers(player_car)
game_objects = [player_car]
@game_window.event
def on_draw():
game_window.clear()
batch.draw()
score_label.text = "Rotations: {}".format(player_car.getScore())
distance_label.text = "Distance: {}".format(
player_car.getDistance())
speed_label.text = "Speed: {}".format(player_car.getSpeed())
direction_label.text = "Direction: {}".format(
player_car.getRotation())
rotationspeed_label.text = "Rotation Speed: {}".format(
player_car.getRotationSpeed())
try:
fps_label.text = "fps: {}".format(1 / player_car.getDT())
except:
pass
RL = ql.QLearningTable(actions=['u', 'd', 'l', 'r', 'n'])
pyglet.clock.schedule_interval(update, 1 / 144.0, batch)
#pyglet.clock.schedule_once(learn,1/144.0,batch)
pyglet.app.run()
def test_car_properties(self):
toyota = Car('Toyota', 'Corolla')
self.assertListEqual(
['Toyota', 'Corolla'], [toyota.name, toyota.model],
msg='The car name and model should be a property of the car')
from car import Car
from account import Account
if __name__ == "__main__":
print("Hola Mundo")
car = Car("AMS234", Account("Andres Herrera", "ANDA 876"))
print(vars(car))
print(vars(car.driver))
def test_car_type(self):
koenigsegg = Car('Koenigsegg', 'Agera R')
self.assertTrue(
koenigsegg.is_saloon(),
msg='The car type should be saloon if it is not a trailer')
from car import Car
from electricCar import Battery, ElectricCar
myAudi= Car("audi","a8",2018)
print(myAudi.descriptiveName())
myAudi.odometer=12345
myAudi.readOdometer()
myTesla=ElectricCar("Tesla","model S",2018)
print(myTesla.descriptiveName())
import picamera.array
from picamera import PiCamera
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import time
import cv2
import math
import threading
from car import Car
from infrad import Infrad
from lane_lines import *
from detect import *
from ultrasonic import *
car = Car()
inf = Infrad()
ul = Ultrasound()
camera = PiCamera()
def find_left(car, GO):
car.set_speed(-100, 100)
time.sleep(0.15)
if GO:
car.set_speed(50, 50)
else:
car.set_speed(0, 0)
def find_right(car, GO):
speed = 1
colorList = (RED, GREEN, PURPLE, YELLOW, CYAN, BLUE)
SCREENWIDTH=800
SCREENHEIGHT=600
size = (SCREENWIDTH, SCREENHEIGHT)
screen = pygame.display.set_mode(size)
pygame.display.set_caption("Car Racing")
#This will be a list that will contain all the sprites we intend to use in our game.
all_sprites_list = pygame.sprite.Group()
playerCar = Car(RED, 60, 80, 70)
playerCar.rect.x = 160
playerCar.rect.y = SCREENHEIGHT - 100
car1 = Car(PURPLE, 60, 80, random.randint(50,100))
car1.rect.x = 60
car1.rect.y = -100
car2 = Car(YELLOW, 60, 80, random.randint(50,100))
car2.rect.x = 160
car2.rect.y = -600
car3 = Car(CYAN, 60, 80, random.randint(50,100))
car3.rect.x = 260
car3.rect.y = -300
from car import Car
my_new_car = Car("Maruti", "Alto", 2010)
print(my_new_car.get_name())
from car import Car
from random import Random
node = attrs['node']
segments_starting_at = []
for i in range(self.num_segments):
if self.segment_start[i] == node:
segments_starting_at.append(i)
r = Random()
street_idx = segments_starting_at[r.randint(0,len(segments_starting_at) - 1)]
street = self.streets[street_idx]
pos = 0
if not street.cars.has_key(pos):
velocity = 0
dest = self.dests[r.randint(0,len(self.dests) - 1)]
c = Car(street,pos,velocity,dest,self)
self.cars[c.id] = c
(x,y) = c.coordinates()
color = self.car_color
c.representation = self.canvas.create_rectangle(x,y,x,y,fill=color,outline=color,width=0)
from car import Car, ElectricCar
# my_new_car = Car('audi','a4',2016)
# print(my_new_car.get_descriptive_name())
#
# my_new_car.odometer_reading = 23
# my_new_car.read_odometer()
my_beetle = Car('volkswagen', 'beetle', 2016)
print(my_beetle.get_descriptive_name())
my_tesla = ElectricCar('tesla', 'roadster', 2016)
print(my_tesla.get_descriptive_name())
from car import Car
from electricalcar import ElectricCar
c = Car('audi', 'a4', 2016, b)
def cv(fname):
logger = logging.getLogger()
# -------------- Configure track
points = [(120, 40), (210, 40), (210, 180), (30, 180), (30, 40)]
config = th.CONFIG(NUM_JUNCTURES=50,
NUM_MILESTONES=50,
NUM_LANES=5,
NUM_SPEEDS=3,
NUM_DIRECTIONS=20,
NUM_STEER_POSITIONS=3,
NUM_ACCEL_POSITIONS=3)
WIDTH = 20
track = LineTrack(points, WIDTH, config)
car = Car(config)
logger.debug("*Problem:\t%s", util.pre_problem)
logger.debug(" %s", config)
# --------- CV ---------
num_samples = 2
i_algs = np.array([x % 4 for x in range(num_samples)])
fas = np.array([th.FA['qtable'] for _ in range(num_samples)])
lambdas = np.random.uniform(0.0, 1, num_samples)
alphas = np.random.uniform(0.0, 1, num_samples)
expls = 10**np.random.uniform(1.0, 2.0, num_samples)
scores = []
erjs = []
for rep, (i_alg, fa, lam, alp,
expl) in enumerate(zip(i_algs, fas, lambdas, alphas, expls)):
logger.debug(
"--- rep %d --- %d:%d lam: %0.2f, alp: %0.2f, expl: %0.2f", rep,
i_alg, fa, lam, alp, expl)
#TODO: use 'fa' to pick f.a.
driver_fa = QLookup(config, alpha=alp)
driver = th.create_driver_i(config, i_alg, expl, lam, driver_fa, None)
trainer = Trainer(driver, track, car)
seed = 213 + rep
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
bp_times, e_bp, bp_R, bp_j = trainer.train(20 * 1000)
#bp_R=[random.randrange(20, 1000)]
score = 0
mult = 1
for i in range(len(bp_R)):
score += bp_R[-1 - i] / (bp_j[-1 - i] + 1) * mult
mult *= 0.95
scores.append(score)
logger.debug(" Score: %s", score)
erj = []
erj.extend(e_bp)
erj.extend(bp_R)
erj.extend(bp_j)
erjs.append(erj)
scores = np.array(scores)
erjs = np.array(erjs)
stackers = [i_algs, fas, lambdas, alphas, expls, scores]
stackers.extend([erj.T for erj in erjs.T])
A = np.stack(stackers).T
util.append(A, fname)
from car import Car
my_new_car = Car('Audi', 'a4' ,'2016')
print(my_new_car.get_descriptive_name())
my_new_car.odometer_reading = 23
my_new_car.read_odometer()
