def car(request):
islogin = request.session.get('is_login')
# 判断是否登录，已登录从数据库中获取购物车数据渲染页面
if islogin:
# 判断购物车表中是否有该用户的购物车,如果有则获取数据
username = request.session.get('username')
user_id = TUser.objects.get(username=username).id
books = ShoppingCart.objects.filter(user=user_id)
addresss = TAddress.objects.filter(user_id=user_id)
if books:
# 从购车表中拿出这个人的购物车的书和数量构建前端购物车car对象
car = Car()
for book in books:
id = book.book_id
count = book.book_num
car.add_book(id, count)
# 计算每本书的总计
total = 0
for i in car.book_list:
total += float(i.price) * int(i.count)
return render(
request, 'car.html', {
'car': car.book_list,
'total': round(total, 2),
'islogin': islogin,
'username': username,
'addresss': addresss
})
# 如果没有购物车，则返回空购物车
else:
return render(request, 'car.html', {
'islogin': islogin,
'username': username,
'addresss': addresss
})
# 未登录状态，从session中获取购物车数据
else:
car = request.session.get('car')
username = request.session.get('username')
# 如果已有购物车，返回购物车页面、购物车数据、小计、
if car:
json.dumps(list(car.book_list), default=mydefault)
total = 0
for i in car.book_list:
total += (float(i.price) * int(i.count))
return render(
request, 'car.html', {
'car': car.book_list,
'total': round(total, 2),
'islogin': islogin,
'username': username
})
# 若没有购物车则返回空购车
else:
return render(request, 'car.html', {
'islogin': islogin,
'username': username
})
def index(request):
user = request.session.get('is_login')
car = request.session.get('car')
if user:
user = TUser.objects.get(username=user)
tcar = list(user.tcar_set.filter(user_id=user.id))
if tcar:
car = Car()
for i in tcar:
car.add_book(i.book_id, i.count)
count = 0
if car:
for i in car:
count += i.count
cate_1 = Category.objects.filter(level=1)
cate_2 = Category.objects.filter(level=2)
new_book = TBook.objects.all().order_by('pub_time')[:8]
top_selling1 = TBook.objects.filter(
pub_time__gte=str(datetime.datetime.now() + datetime.timedelta(
days=-200))[:10]).order_by('-sales_volume')[:5]
top_comments = TBook.objects.order_by('comments')
top_selling2 = TBook.objects.filter(
pub_time__gte=str(datetime.datetime.now() + datetime.timedelta(
days=-1000))[:10]).order_by('-sales_volume')[:10]
content = {
'cate_1': cate_1,
'cate_2': cate_2,
'new_book': new_book,
'top_selling1': top_selling1,
'top_comments': top_comments,
'top_selling2': top_selling2,
'user': user,
'count': count
}
return render(request, 'index.html', content)
def add_car(request, user):
id = request.POST.get('id')
count = request.POST.get('count1')
car = request.session.get('car')
if user:
t_user = TUser.objects.filter(user_name=user)
if t_user:
t_user = t_user[0].id
book = TCar.objects.filter(book_id=id, user_id=t_user)
if book: # 还在登录状态(且这本书添加过了)
book[0].product_number = int(count) + int(book[0].product_number)
book[0].save()
return HttpResponse("登录中更改旧书")
else: # 一直在登录状态(添加新书)
TCar.objects.create(book_id=id,
user_id=t_user,
product_number=count)
return HttpResponse("登录中添加新书")
else:
if car:
car.add_book(id, count)
request.session['car'] = car
return HttpResponse('未登录添加书')
else:
car = Car()
car.add_book(id, count)
request.session['car'] = car
return HttpResponse("未登录添加新购物车")
def test_car_constructor():
car1 = Car()
car2 = Car(70, 0.8, Point(1, 1), 'Toyota')
assert car1.fuel_capacity == 60 and car1.fuel_consumption == 0.6 and car1.fuel_amount == 0
assert car1.location.x == 0.0 and car1.location.y == 0.0
assert car1.model == 'Mercedes'
assert car2.fuel_capacity == 70 and car2.fuel_consumption == 0.8 and car2.fuel_amount == 0
assert car2.location.x == 1.0 and car2.location.y == 1.0
assert car2.model == 'Toyota'
def indent(request):
username = request.session.get('username')
user_id = TUser.objects.get(username=username).id
books = ShoppingCart.objects.filter(user=user_id)
addresss = TAddress.objects.filter(user_id=user_id)
car = Car()
for book in books:
id = book.book_id
count = book.book_num
car.add_book(id, count)
total = 0
for i in car.book_list:
total += float(i.price) * int(i.count)
return render(request, 'indent.html', {'car': car.book_list, 'username': username,
'total': round(total, 2), 'addresss': addresss})
def change_maps(self, dest, x, y):
if self.player.isInCar:
self.current_map.game_objects.remove(self.player.car)
self.current_map.not_player.remove(self.player.car)
self.loadLevel(dest)
self.player.x = x * TILE_SIZE
self.player.y = y * TILE_SIZE
self.player.rect.left = self.player.x + self.player.left_offset
self.player.rect.top = self.player.y + self.player.top_offset
if self.player.isInCar:
if isinstance(self.player.car, ImperviousCar):
self.player.car = Car(None,0,0,self)
self.player.car.driver = self.player
self.player.car.driving = True
self.player.car.x = x * TILE_SIZE
self.player.car.y = y * TILE_SIZE
self.player.car.rect.left = self.player.car.x
self.player.car.rect.top = self.player.car.y
self.player.car.avoidMapLinks()
self.current_map.game_objects.add(self.player.car)
elif self.player.isInTree:
self.player.getOutOfTree()
self.player.x = TILE_SIZE
self.player.y = TILE_SIZE
self.player.rect.left = self.player.x + self.player.left_offset
self.player.rect.top = self.player.y + self.player.top_offset
def test_car_to_string():
car = Car(70, 0.8, Point(1, 1), 'Toyota')
assert str(car) == 'Car location: (1.0, 1.0)\n' \
'Fuel amount: 0\n' \
'Fuel capacity: 70.0\n' \
'Fuel consumption: 0.8\n' \
'Car model: Toyota\n'
def test_car_drive():
car = Car()
car.refill(60)
car.drive(0, 0)
assert round(car.fuel_amount, 2) == 60.00
assert car.location == Point(0, 0)
car.drive(2, 2)
assert round(car.fuel_amount, 2) == 58.30
assert car.location == Point(2, 2)
def add_car(request):
id = request.GET.get('id')
count = int(request.GET.get('count'))
# 判断是否登录,已登录存入数据库
if request.session.get('is_login'):
# 判断是已存在这本书，直接修改数量
username = request.session.get('username')
user_id = TUser.objects.get(username=username).id
books = ShoppingCart.objects.filter(user=user_id, book=id)
if books:
books[0].book_num = books[0].book_num + count
books[0].save()
# 判断否则，创建一行数据
else:
username = request.session.get('username')
user_id = TUser.objects.get(username=username).id
ShoppingCart.objects.create(
book_id=id,
book_num=count,
user_id=user_id,
)
# 购物车里点加减号所需的总价和数量
# car = Car()
price = TBook.objects.filter(book_id=id)[0].discount_price
count = ShoppingCart.objects.get(book_id=id).book_num
total = price * count
return JsonResponse({"total": total, 'count': count})
# 未登录状态，存入session
else:
# 如果有购物车
car = request.session.get('car')
if car:
pass
else:
car = Car()
car.add_book(id, count)
request.session['car'] = car
total = 0
for i in car.book_list:
total += float(i.price) * int(i.count)
if i.id == id:
count = i.count
return JsonResponse({"total": total, 'count': count})
def book_list(request):
user = request.session.get('is_login')
car = request.session.get('car')
if user:
user = TUser.objects.get(username=user)
tcar = list(user.tcar_set.filter(user_id=user.id))
if tcar:
car = Car()
for i in tcar:
car.add_book(i.book_id, i.count)
count = 0
if car:
for i in car:
count += i.count
cate_1 = Category.objects.filter(level=1)
cate_2 = Category.objects.filter(level=2)
level = request.GET.get('level', 1)
num = request.GET.get('num', 1)
cate_id = request.GET.get('cate_id', 1)
cate = Category.objects.filter(id=0)
if level == '1':
book = TBook.objects.filter(category__parent_id=cate_id)
cate = cate | Category.objects.filter(id=cate_id)
else:
book = TBook.objects.filter(category_id=cate_id)
cc = Category.objects.filter(id=cate_id)
cate = cate | Category.objects.filter(id=cc[0].parent_id) | cc
paginator = Paginator(book, per_page=2)
page = paginator.page(num)
content = {
'cate_1': cate_1,
'cate_2': cate_2,
'title': cate,
'page': page,
'paginator': paginator,
'level': level,
'num': num,
'user': user,
'count': count
}
return render(request, 'booklist.html', content)
def book_detail(request):
user = request.session.get('is_login')
car = request.session.get('car')
if user:
user = TUser.objects.get(username=user)
tcar = list(user.tcar_set.filter(user_id=user.id))
if tcar:
car = Car()
for i in tcar:
car.add_book(i.book_id, i.count)
count = 0
if car:
for i in car:
count += i.count
book_id = request.GET.get('book_id')
book = TBook.objects.get(id=book_id)
cate1 = Category.objects.get(id=book.category.parent_id)
content = {'book': book, 'cate': cate1, 'user': user, 'count': count}
return render(request, 'Book details.html', content)
def get_players(self):
car_img = pg.image.load('graphics/car.png')
player_list = []
for i in range(self.NUM_PLAYERS):
x_min = i * DISPLAY_WIDTH / self.NUM_PLAYERS
x_max = (i + 1) * DISPLAY_WIDTH / self.NUM_PLAYERS - 1 # -1 cause its inclusive and we want it exclusive
car = Car(x_min, x_max, 8, car_img)
player = Player(i, LIVES, car, KEYS[i]['left'], KEYS[i]['right'])
player_list.append(player)
return player_list
def del_car(request):
id = request.GET.get('id')
islogin = request.session.get('is_login')
# 判断是否是登陆状态，若已登录
if islogin:
username = request.session.get('username')
user_id = TUser.objects.get(username=username).id
# 从购物车表删除该用户的该id书的数据
ShoppingCart.objects.filter(user=user_id, book=id)[0].delete()
# 拿出这个用户的购物车，创建页面显示购物车对象car
books = ShoppingCart.objects.filter(user=user_id)
car = Car()
for book in books:
book_id = book.book_id
count = book.book_num
car.add_book(book_id, count)
# 利用页面显示购物车对象car,计算总价total
total = 0
for i in car.book_list:
total += (float(i.price) * int(i.count))
return JsonResponse({"total": total})
# 未登录：则从session中获取购物车>删除指定id的书
else:
# 从session中获取购物车
car = request.session.get('car')
# 删除购物车中指定书id的数据
car.remove_book(id)
request.session['car'] = car
# 计算总价
total = 0
for i in car.book_list:
total += (float(i.price) * int(i.count))
return JsonResponse({"total": total})
def test_car_setters():
point1 = Point(4, 4)
car1 = Car(30, 90, 10, point1, "MAzda")
assert car1.fuel_amount == 30
car1.fuel_amount = 10
assert car1.fuel_amount == 10
assert car1.fuel_capacity == 90
car1.fuel_capacity = 10
assert car1.fuel_capacity == 10
assert car1.fuel_consumption == 10
car1.fuel_consumption = 5
assert car1.fuel_consumption == 5
assert car1.model == 'Mazda'
car1.model = 'Tesla'
assert car1.model == 'Tesla'
def test_car_refill(actual, expected):
car = Car()
car.refill(30)
car.refill(actual)
assert car.fuel_amount == expected
@socket_io.on('connect')
def connect():
socket_io.send('Connection established')
@socket_io.on('message')
def handle_messages(message):
print('Message from client: ' + message)
@socket_io.on('disconnect')
def disconnect():
print('Client disconnected')
@app.route('/')
def index():
return render_template("index.html")
if __name__ == '__main__':
car = Car(17, 18, 22, 23, 5, 6, 12, 13, 1920, 1080, 270)
imageAnalysisService = ImageAnalysisService()
carService = CarService(car=car,
image_analysis_service=imageAnalysisService)
carController = CarController(car=car,
car_service=carService,
flask_app=app)
car_event_processor = CarEventProcessor(app, socket_io)
socket_io.run(app)
def _can_collide_X(car: Car, obstacle: Obstacle, x_car_shift):
return car.get_left_x() + x_car_shift <= obstacle.get_right_x() \
and car.get_right_x() + x_car_shift >= obstacle.get_left_x()
import time
from car.car import Car
if __name__ == '__main__':
car = Car()
car.forward()
car.speed(20)
time.sleep(5)
car.speed(50)
time.sleep(5)
car.stop()
time.sleep(5)
car.back()
car.speed(20)
time.sleep(5)
car.speed(50)
time.sleep(5)
del car
import sys
import os
from utils.keyboard_reader import KeyboardReader
# Set Jetson GPIO Mode
GPIO.setmode(GPIO.BCM)
# Create mqtt car class
mqtt = MqttCar()
# Create directory manager class
dir_manager = DirectoryManager()
# Crete keyboard reader class
keyboard_reader = KeyboardReader()
# Create LED class
led = SingleLED(GPIO)
# Create Car class
car = Car(GPIO, 45)
# Create Distance sensor class
distance_sensor = DistanceSensor(GPIO)
# Create car camera class
car_camera = CarCamera(autopilot=False, record_stops=False, video_output=True)
# Set initial values
created_dir = ''
start_rec = ''
try:
# Start mqtt
mqtt.start()
# Led startup
led.onStartCarLEDs()
# Publish init values to relevant topics
def test_check_refill_exception():
point = Point(4, 4)
car = Car(30, 90, 10, point, "MAzda")
with pytest.raises(ToMuchFuel):
car.refill(100)
def __init__(self):
# Load Configuration
self.utility_config = utility.utility_config
self.controller_config = controller.controller_config
self.sensor_config = sensor.sensor_config
self.pilot_config = pilot.pilot_config
# Initialize objects
"""
We can initialize objects from each active module based on configuration files
"""
# Initialize non parameterized objects
"""
First Initialize non parameterized objects, and add parameterized objects into dictionary
for later Initialization
"""
self.non_tp_objects = {
} # Dictionary of non threaded non parameterized objects
self.non_p_objects = {
} # Dictionary of threaded non parameterized objects
self.parameterized_objects = {
} # Dictionary of all parameterized objects
self.sensor_objects = {}
self.car = Car()
self.non_p_objects['car'] = self.car
self.non_tp_objects['logger'] = Main.logger
# Initialize utility module objects
self.initialize_utility()
# Initialize controller module objects
self.initialize_controller()
# Initialize sensor module objects
self.initialize_sensor()
# Initialize pilot module objects
self.initialize_pilot()
# Initialize parameterized objects
"""
parameterized_objects structure:
Type Dictionary => key : value
Key is the name of objects' class to be initialized.
Value is array of 3 elements:
Value[0]: un-initialized object
Value[1]: List of the name of parameters
Value[2]: is threaded?
"""
for key in list(self.parameterized_objects):
# [key] will return array, [0] will return the un-initialized object
# After it return the un-initialized object it will initialize it using the parameters from get_parameters
if key not in self.parameterized_objects:
continue
obj = self.parameterized_objects[key][0](self.get_parameters(
self.parameterized_objects[key]))
if self.parameterized_objects[key][2]:
self.non_p_objects[key] = obj
else:
self.non_tp_objects[key] = obj
del self.parameterized_objects[key]
# Separate sensor objects
for k in list(self.non_p_objects):
if k in self.sensor_config.modules:
self.sensor_objects[k] = self.non_p_objects[k]
del self.non_p_objects[k]
# Initialize car object
self.car.initialize_objects(self.non_tp_objects, self.non_p_objects,
self.sensor_objects)
def test_car_drive_to_point_exception(value, exception_type):
car = Car()
with pytest.raises(exception_type):
car.drive_to_point(value)
def test_car_refill_exception(value, exception_type):
car = Car()
car.refill(30)
with pytest.raises(exception_type):
car.refill(value)
def test_check_drive_exception():
point1 = Point(4, 4)
point2 = Point(555, 555)
car1 = Car(30, 90, 10, point1, "MAzda")
with pytest.raises(OutOfFuel):
car1.drive(point2)
def test_fill():
point1 = Point(4, 4)
car1 = Car(30, 90, 10, point1, "MAzda")
car1.refill(10)
assert car1.fuel_amount == 40
def test_car_to_string():
point1 = Point(4, 4)
car1 = Car(30, 90, 10, point1, "MAzda")
assert str(
car1) == 'Mazda: fuel - 30/90, consumption - 10, location - (4.0, 4.0)'
import time
from car.car import Car
if __name__ == '__main__':
car = Car(17, 18, 22, 23, 5, 6, 12, 13, 1920, 1080, 270)
for i in range(5):
car.move_forward()
car.stop()
car.take_picture('img_' + str(i) + '.png')
time.sleep(1)
class Main(metaclass=Singleton):
logger = Logger()
def __init__(self):
# Load Configuration
self.utility_config = utility.utility_config
self.controller_config = controller.controller_config
self.sensor_config = sensor.sensor_config
self.pilot_config = pilot.pilot_config
# Initialize objects
"""
We can initialize objects from each active module based on configuration files
"""
# Initialize non parameterized objects
"""
First Initialize non parameterized objects, and add parameterized objects into dictionary
for later Initialization
"""
self.non_tp_objects = {
} # Dictionary of non threaded non parameterized objects
self.non_p_objects = {
} # Dictionary of threaded non parameterized objects
self.parameterized_objects = {
} # Dictionary of all parameterized objects
self.sensor_objects = {}
self.car = Car()
self.non_p_objects['car'] = self.car
self.non_tp_objects['logger'] = Main.logger
# Initialize utility module objects
self.initialize_utility()
# Initialize controller module objects
self.initialize_controller()
# Initialize sensor module objects
self.initialize_sensor()
# Initialize pilot module objects
self.initialize_pilot()
# Initialize parameterized objects
"""
parameterized_objects structure:
Type Dictionary => key : value
Key is the name of objects' class to be initialized.
Value is array of 3 elements:
Value[0]: un-initialized object
Value[1]: List of the name of parameters
Value[2]: is threaded?
"""
for key in list(self.parameterized_objects):
# [key] will return array, [0] will return the un-initialized object
# After it return the un-initialized object it will initialize it using the parameters from get_parameters
if key not in self.parameterized_objects:
continue
obj = self.parameterized_objects[key][0](self.get_parameters(
self.parameterized_objects[key]))
if self.parameterized_objects[key][2]:
self.non_p_objects[key] = obj
else:
self.non_tp_objects[key] = obj
del self.parameterized_objects[key]
# Separate sensor objects
for k in list(self.non_p_objects):
if k in self.sensor_config.modules:
self.sensor_objects[k] = self.non_p_objects[k]
del self.non_p_objects[k]
# Initialize car object
self.car.initialize_objects(self.non_tp_objects, self.non_p_objects,
self.sensor_objects)
def initialize_utility(self):
for name, obj in inspect.getmembers(sys.modules['utility']):
if inspect.isclass(obj) and name in self.utility_config.modules and \
self.utility_config.modules[name].is_active:
if self.utility_config.modules[name].parameterized:
# append to parameterized objects dictionary for later Initialization
self.parameterized_objects[name] = [
obj, self.utility_config.modules[name].parameters,
self.utility_config.modules[name].threaded
]
else:
if self.utility_config.modules[name].threaded:
self.non_p_objects[name] = obj(
) # Initialize object and append to threaded non parameterized
else:
# Initialize object and append to non threaded non parameterized
self.non_tp_objects[name] = obj()
elif name in self.utility_config.modules and inspect.ismodule(obj) \
and self.utility_config.modules[name].is_active:
print(name)
obj = getattr(obj,
self.utility_config.modules[name].class_name)
if self.utility_config.modules[name].parameterized:
# append to parameterized objects dictionary for later Initialization
self.parameterized_objects[name] = [
obj, self.utility_config.modules[name].parameters,
self.utility_config.modules[name].threaded
]
else:
if self.utility_config.modules[name].threaded:
self.non_p_objects[name] = obj(
) # Initialize object and append to threaded non parameterized
else:
# Initialize object and append to non threaded non parameterized
self.non_tp_objects[name] = obj()
def initialize_controller(self):
for name, obj in inspect.getmembers(sys.modules['car.controller']):
if inspect.isclass(obj) and name in self.controller_config.modules \
and self.controller_config.modules[name].is_active:
if self.controller_config.modules[name].parameterized:
# append to parameterized objects dictionary for later Initialization
self.parameterized_objects[name] = [
obj, self.controller_config.modules[name].parameters,
self.controller_config.modules[name].threaded
]
else:
if self.controller_config.modules[name].threaded:
# Initialize object and append to threaded non parameterized
self.non_p_objects[name] = obj()
else:
# Initialize object and append to non threaded non parameterized
self.non_tp_objects[name] = obj()
elif name in self.controller_config.modules and inspect.ismodule(obj) \
and self.controller_config.modules[name].is_active:
obj = getattr(obj,
self.controller_config.modules[name].class_name)
if self.controller_config.modules[name].parameterized:
# append to parameterized objects dictionary for later Initialization
self.parameterized_objects[name] = [
obj, self.controller_config.modules[name].parameters,
self.controller_config.modules[name].threaded
]
else:
if self.controller_config.modules[name].threaded:
# Initialize object and append to threaded non parameterized
self.non_p_objects[name] = obj()
else:
self.non_tp_objects[name] = obj()
def initialize_sensor(self):
for name, obj in inspect.getmembers(sys.modules['car.sensor']):
if inspect.isclass(obj) and name in self.sensor_config.modules \
and self.sensor_config.modules[name].is_active:
if self.sensor_config.modules[name].parameterized:
# append to parameterized objects list for later Initialization
self.parameterized_objects[name] = [
obj, self.sensor_config.modules[name].parameters,
self.sensor_config.modules[name].threaded
]
else:
if self.sensor_config.modules[name].threaded:
self.non_p_objects[name] = obj()
else:
self.non_tp_objects[name] = obj(
) # Initialize object and append
elif name in self.sensor_config.modules and inspect.ismodule(obj) \
and self.sensor_config.modules[name].is_active:
obj = getattr(obj, self.sensor_config.modules[name].class_name)
if self.sensor_config.modules[name].parameterized:
# append to parameterized objects dictionary for later Initialization
self.parameterized_objects[name] = [
obj, self.sensor_config.modules[name].parameters,
self.sensor_config.modules[name].threaded
]
else:
if self.sensor_config.modules[name].threaded:
# Initialize object and append to threaded non parameterized
self.non_p_objects[name] = obj()
else:
self.non_tp_objects[name] = obj() #
def initialize_pilot(self):
for name, obj in inspect.getmembers(sys.modules['pilot.agent']):
if inspect.isclass(obj) and name in self.pilot_config.modules \
and self.pilot_config.modules[name].is_active:
if self.pilot_config.modules[name].parameterized:
# append to parameterized objects list for later Initialization
self.parameterized_objects[name] = [
obj, self.pilot_config.modules[name].parameters,
self.pilot_config.modules[name].threaded
]
else:
if self.pilot_config.modules[name].threaded:
# Initialize object and append to threaded non parameterized
self.non_p_objects[name] = obj()
else:
# Initialize object and append to non threaded non parameterized
self.non_tp_objects[name] = obj()
elif name in self.pilot_config.modules and inspect.ismodule(obj) \
and self.pilot_config.modules[name].is_active:
obj = getattr(obj, self.pilot_config.modules[name].class_name)
if self.pilot_config.modules[name].parameterized:
# append to parameterized objects dictionary for later Initialization
self.parameterized_objects[name] = [
obj, self.pilot_config.modules[name].parameters,
self.pilot_config.modules[name].threaded
]
else:
if self.pilot_config.modules[name].threaded:
# Initialize object and append to threaded non parameterized
self.non_p_objects[name] = obj()
else:
self.non_tp_objects[name] = obj()
def get_parameters(self, parameterized_object):
p_param = {} # dictionary of parameters to be passed to the object
for param in parameterized_object[1]:
if param in self.non_tp_objects:
p_param[param] = self.non_tp_objects[param]
elif param in self.non_p_objects:
p_param[param] = self.non_p_objects[param]
elif param in self.parameterized_objects:
# Remove it from parameterized_objects dictionary and return it
p_object = self.parameterized_objects.pop(param)
p_object[0] = p_object[0](self.get_parameters(p_object))
p_param[param] = p_object[0]
if p_object[
2]: # if threaded add to threaded non parameterized dictionary
self.non_p_objects[param] = p_object[0]
else:
self.non_tp_objects[param] = p_object[0]
return p_param
def test_drive():
point1 = Point(4, 4)
point2 = Point(5, 5)
car1 = Car(30, 90, 10, point1, "MAzda")
car1.drive(point2)
assert car1.location == point2
#!usr/bin/python
# coding:utf-8
from car.car import Car
'''
class Car:
price=10000
def __init__(self,c):
self.color = c
'''
car1 = Car("red")
car2 = Car("write")
print(car1.color,Car.price)
Car.price = 120000
Car.name = 'QQ'
car1.color = 'yellow'
print(car2.color,Car.price,Car.name)
