问题

   # 获取指定符号的当前余额
symbols_to_check = ["USDT", "BNB", "BTC", "ETH"]
balances = get_current_balances(symbols_to_check)
print("当前余额:")
for symbol in symbols_to_check:
    balance_info = balances.get(symbol, {"free": 0.0})
    print(f"{symbol}: 可用 - {balance_info['free']}")

出现以下错误：

Traceback (most recent call last):
  File "main.py", line 83, in <module>
    print(f"{symbol}: 可用 - {balance_info['free']}")
TypeError: 'float' object is not subscriptable

对于任何对代码结构感兴趣，以提供可能导致错误或更好的实现预测的提示的人，都欢迎，我对Python相当新，也不是最好的开发人员。

<details>
<summary>英文:</summary>

Get the current balances for the specified symbols

symbols_to_check = ["USDT", "BNB", "BTC", "ETH"]
balances = get_current_balances(symbols_to_check)
print("Current Balances:")
for symbol in symbols_to_check:
balance_info = balances.get(symbol, {"free": 0.0})
print(f"{symbol}: Free - {balance_info['free']}")

Throws a following error:
Traceback (most recent call last):
File "main.py", line 83, in <module>
print(f"{symbol}: Free - {balance_info['free']}")
TypeError: 'float' object is not subscriptable
for anyone interested in the hole code structure to provide any tips that might lead to errors or better ideas to implement better predictions are welcome, i am pretty new to python and not the best developer overall. 
```
import pandas as pd
import numpy as np
import requests
from binance.client import BinanceAPIException, Client
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler
import tensorflow as tf
import schedule
import time
import itertools
tf.config.list_physical_devices('GPU')
# Define parameters
api_key = "YOUR_API_KEY"
api_secret = "YOUR_SECRET_KEY"
base_url = "https://api.binance.com"
symbols = ["BTCUSDT", "ETHUSDT", "BNBUSDT"]
interval = "1h"
limit = 1000
paper_trading = False
# Create a client object
client = Client(api_key, api_secret)
# Create an empty dictionary to store the profits and losses of each symbol
profit_loss_dict = {}
# Define a threshold for trading (can be adjusted)
threshold = {"BTCUSDT": 10, "ETHUSDT": 8, "BNBUSDT": 5}
# Define the tickSize for each symbol
tick_sizes = {"BTCUSDT": 0.01, "ETHUSDT": 0.01, "BNBUSDT":0.1}
# Define the minimum quantity for each symbol
min_quantity = {"BTCUSDT": 0.00036, "ETHUSDT": 0.0059 , "BNBUSDT": 0.045}
# Define a flag to hold after a buy order is executed
hold = False
# Define a function to get the minimum quantity allowed for each symbol
def get_min_quantity(symbol):
return min_quantity.get(symbol, 0.01)
# Modify the get_trimmed_price function to return a tuple (trimmed_price, min_qty)
def get_trimmed_price(target_value, symbol):
tick_size = tick_sizes.get(symbol, 0.01)
trimmed_price = round(target_value / tick_size) * tick_size
return trimmed_price, get_min_quantity(symbol)
# Modify the get_current_balances function to return a dictionary with the actual balances
def get_current_balances(symbols):
try:
# Use the Binance API to get the account information
account_info = client.get_account()
# Create an empty dictionary to store the balances for each symbol
balances = {}
# Find the balance for each specified symbol
for symbol in symbols:
# Find the balance for the specified symbol in the account_info list
balance = next((item for item in account_info['balances'] if item['asset'] == symbol), None)
# If the symbol is found, get the 'free' value, otherwise set it to 0
free_balance = float(balance['free']) if balance else 0.0
balances[symbol] = free_balance
return balances
except Exception as e:
print(f"Error fetching balances: {e}")
return {}  # Return an empty dictionary if there is an error
# Get the current balances for the specified symbols
symbols_to_check = ["USDT", "BNB", "BTC", "ETH"]
balances = get_current_balances(symbols_to_check)
print("Current Balances:")
for symbol in symbols_to_check:
balance_info = balances.get(symbol, {"free": 0.0})
print(f"{symbol}: Free - {balance_info['free']}")
# Define a function to get historical data for multiple symbols and save each one to a separate csv file
def get_historical_data(symbols, interval, limit):
# Create an empty list to store the dataframes
dfs = []
# Loop through the symbols
for symbol in symbols:
# Construct the url
url = base_url + "/api/v3/klines"
params = {"symbol": symbol, "interval": interval, "limit": limit}
# Send a get request and parse the response
response = requests.get(url, params=params)
data = response.json()
# Convert the data to a dataframe
df = pd.DataFrame(data, columns=["open_time", "open", "high", "low", "close", "volume", "close_time", "quote_volume","trades", "taker_base_volume", "taker_quote_volume", "ignore"])
# Convert the columns to numeric values
df = df.apply(pd.to_numeric)
# Convert the time columns to datetime format
df["open_time"] = pd.to_datetime(df["open_time"], unit="ms")
df["close_time"] = pd.to_datetime(df["close_time"], unit="ms")
# Add a column for the symbol name
df["symbol"] = symbol
# Add a column for the moving average
df["moving_average"] = np.nan
# Append the dataframe to the list
dfs.append(df)
# Concatenate all the dataframes in the list
df = pd.concat(dfs, ignore_index=True)
# Save the dataframe to a csv file
df.to_csv(f"historical_data_{interval}.csv", index=False)
# Return the dataframe
return df
# Define a function to fetch and update historical data
def update_historical_data():
global df  # Use the global df variable
# Get historical data for multiple symbols and save it to a csv file
df = get_historical_data(symbols, interval, limit)
# Schedule the update_historical_data function to run at the specified interval
update_interval_hours = 1  # Set the update interval (in hours)
schedule.every(update_interval_hours).hours.do(update_historical_data)
# Define a function to get real-time data for one symbol
def get_realtime_data(symbol):
# Construct the url
url = base_url + "/api/v3/ticker/price"
params = {"symbol": symbol}
# Send a get request and parse the response
response = requests.get(url, params=params)
data = response.json()
# Convert the data to a float value
price = float(data["price"])
# Return the price
return price
# Check the shape of the dataframe and make sure it has enough rows (at least 250)
# Create the MinMaxScaler in a global scope
scaler = MinMaxScaler()
# Define a function to create a neural network model for one symbol using historical data
def create_model(df, symbol):
global scaler  # Use the global scaler variable
# Filter the dataframe by the symbol name
df_symbol = df[df["symbol"] == symbol]
# Select the features and the target
X = df_symbol[["open", "high", "low", "volume"]].values
y = df_symbol["close"].values
# Scale the features to a range of (0, 1)
X = scaler.fit_transform(X)
# Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Create a neural network model using Sequential
model = tf.keras.Sequential([
tf.keras.layers.Dense(64, activation='relu', input_shape=(X_train.shape[1],)),
tf.keras.layers.Dense(32, activation='relu'),
tf.keras.layers.Dense(1)  # Output layer, predicting the closing price
])
# Compile the model
model.compile(optimizer='adam', loss='mean_squared_error')
# Train the model
epochs = 50
batch_size = 32
model.fit(X_train, y_train, epochs=epochs, batch_size=batch_size, validation_split=0.2, verbose=0)
# Evaluate the model
loss = model.evaluate(X_test, y_test, verbose=0)
print(f"Model evaluation for {symbol}: Test loss: {loss}")
# Return the model
return model
def update_model():
global df, models, mean_reversion_models
# Check if there is new data available (compare the number of rows with the previous number)
if df is not None and df.shape[0] >= 250:  # Assuming 250 rows are needed to create a model
# Loop through the symbols and update the models
for symbol in symbols:
if df[df["symbol"] == symbol].shape[0] >= 250:
model = create_model(df, symbol)
models[symbol] = model
else:
print(f"Not enough data to update the model for {symbol}")
else:
print("Not enough data to update models.")
# Schedule the update_model function to run every hour
schedule.every(1).hour.do(update_model)    
risk_tolerance_percentage = 30  # Set your desired risk tolerance percentage here
# Define a function to save the predicted prices with dates and times to a CSV file
def save_predictions(predictions, symbols, datetimes):
df = pd.DataFrame({"symbol": symbols, "predicted_price": predictions, "datetime": datetimes})
df.to_csv("predictions_main_py.csv", index=False)
trade_status = {}
# Create an empty dictionary to store the trimmed prices for each symbol
trimmed_prices = {}
def trade(model, symbol, paper_trading):
global scaler, hold, tick_sizes, min_quantity, trimmed_prices, trade_status, balances
# Get the current price
current_price = get_realtime_data(symbol)
# Add 'global balances' statement to specify the global scope
global balances
if paper_trading:
base_asset_balance = get_current_balances(["USDT"]).get("USDT", {}).get("free", 0.0)
trading_asset_balance = 0.0  # Since we are paper trading, set the trading asset balance to 0
else:
balances = get_current_balances([symbol, "USDT"])
base_asset_balance = balances.get("USDT", {}).get("free", 0.0)
trading_asset_balance = balances.get(symbol, {}).get("free", 0.0)
portfolio_value = base_asset_balance + trading_asset_balance * current_price
# Trim the current price based on tickSize and store in the trimmed_prices dictionary
trimmed_price, min_qty = get_trimmed_price((risk_tolerance_percentage / 100) * portfolio_value, symbol)
trimmed_prices[symbol] = trimmed_price
# Use the model to make predictions for the new data
df_symbol = df[df["symbol"] == symbol]
X_last_row = df_symbol[["open", "high", "low", "volume"]].iloc[-1:].values
X_last_row_scaled = scaler.transform(X_last_row)
prediction = model.predict(X_last_row_scaled)[0][0]
# Check if hold flag is True, and if yes, do not execute buy order
if hold:
_, trading_asset_balance = get_current_balances([symbol])[symbol]["free"]
if trading_asset_balance >= min_qty:
print(f"Holding {symbol} - waiting for sell order to be executed")
else:
print(f"Holding {symbol} - Insufficient quantity to trade. Waiting for sell order to be executed.")
return
if trade_status.get(symbol) == "BOUGHT":
# If the trade status is "BOUGHT", it means we already bought the asset and are waiting for a sell order.
# Check if we have the minimum quantity to sell.
_, trading_asset_balance = get_current_balances([symbol])[symbol]["free"]
if trading_asset_balance >= min_quantity[symbol]:
print(f"Holding {symbol} - Waiting for sell order to be executed.")
else:
print(f"Holding {symbol} - Insufficient quantity to sell. Waiting for sell order to be executed.")
else:
if not paper_trading:
# Calculate the trading quantity based on the position size and current price
quantity = (risk_tolerance_percentage / 100) * portfolio_value / current_price
# Round the quantity according to the tickSize for each symbol
decimals = int(-np.log10(tick_sizes[symbol]))
quantity = round(quantity, decimals)
# Check the available balance for the trading asset
_, trading_asset_balance = get_current_balances([symbol])[symbol]["free"]
# Compare the quantity with the trading asset balance
if quantity > trading_asset_balance:
# If the quantity exceeds the available balance, set it to the available balance
quantity = trading_asset_balance
# If the calculated quantity is less than the minimum quantity allowed, use the minimum allowed quantity
if quantity < min_quantity[symbol]:
quantity = min_quantity[symbol]
print(f"Quantity is less than the minimum allowed for {symbol}. Using the minimum allowed quantity for the trade.")
print(f"Trading {symbol}:")
print(f"  Quantity: {quantity}")
print(f"  Tick Size: {tick_sizes[symbol]}")
print(f"  Current Price: {current_price}")
print(f"  Portfolio Value: {portfolio_value}")
print(f"  Predicted Price for {symbol}: {prediction}, Current price: {current_price}")
try:
if prediction < trimmed_prices[symbol]:
# Place a market buy order using the client object
order_buy = client.order_market_buy(symbol=symbol, quantity=quantity)
print(order_buy)
print("Market buy order executed.")
# Set trade status to "BOUGHT" after executing the buy order
trade_status[symbol] = "BOUGHT"
# Set hold flag to True after executing the buy order to wait for the sell order
hold = True
else:
print(f"No Buy Signal for {symbol} at current price {current_price}")
except BinanceAPIException as e:
print(f"Error: {e}")
else:
# Use the model to make predictions for the new data
df_symbol = df[df["symbol"] == symbol]
X_last_row = df_symbol[["open", "high", "low", "volume"]].iloc[-1:].values
X_last_row_scaled = scaler.transform(X_last_row)
prediction = model.predict(X_last_row_scaled)[0][0]
print(f"Price prediction for {symbol}: {prediction}, Current price: {current_price}")
# Add the SELL logic here
if trade_status.get(symbol) == "BOUGHT" and prediction > trimmed_prices[symbol]:
try:
# Place a market sell order using the client object
order_sell = client.order_market_sell(symbol=symbol, quantity=min_quantity[symbol])
print(order_sell)
print("Market sell order executed.")
# Reset trade status and hold flag after executing the sell order
trade_status[symbol] = None
hold = False
except BinanceAPIException as e:
print(f"Error: {e}")
# Define a function to save the profits and losses of trade dates for each symbol
def save_profit_loss(profit_loss_dict):
# Convert the dictionary to a dataframe
df = pd.DataFrame.from_dict(profit_loss_dict, orient="index")
# Add a column for the net profit or loss
df["net"] = df["profit"] - df["loss"]
# Save the dataframe to a csv file
df.to_csv("profit_loss.csv", index=True)
# Return the dataframe
return df
# Initialize "profit" and "loss" keys in the profit_loss_dict for each symbol
for symbol in symbols:
profit_loss_dict[symbol] = {"profit": 0, "loss": 0}
# Get the current balances for the specified symbols
symbols_to_check = ["USDT", "BNB", "BTC", "ETH"]
balances = get_current_balances(symbols_to_check)
print("Current Balances:")
for symbol, balance_info in balances.items():
print(f"{symbol}: Free - {balance_info['free']}")
# Call the update_historical_data function to initialize the df variable before creating the models and starting the trading loop
update_historical_data()
# Loop through the symbols and create a model for each one
models = {}
#mean_reversion_models = {}  # Create a separate dictionary to store mean reversion models
for symbol in symbols:
# Create a neural network model using historical data
if df.shape[0] >= 250:
model = create_model(df, symbol)
models[symbol] = model
else:
print(f"Not enough data to create a model for {symbol}")
# Save the profit and loss to a csv file
save_profit_loss(profit_loss_dict)
print(df.shape)
# The main trading loop
while True:
schedule.run_pending()  # Check if the scheduled update_model function needs to run
if df is not None:  # Add this condition to avoid accessing shape of None
# Get the current balances for the specified symbols
balances = get_current_balances(["USDT", "BNB", "BTC", "ETH"])
print("Current Balances:")
for symbol in symbols:
trading_asset_balance = balances.get(symbol, 0.0)
print(f"{symbol}: Free - {trading_asset_balance}")
for symbol in symbols:
# Fetch the latest price data for the symbol
current_price = get_realtime_data(symbol)
# Fetch the portfolio value from the account for live or paper trading
if paper_trading:
base_asset_balance = balances.get("USDT", 0.0)
trading_asset_balance = balances.get(symbol, 0.0)
else:
base_asset_balance = balances.get("USDT", 0.0)
trading_asset_balance = balances.get(symbol, 0.0)
# Calculate the portfolio value
portfolio_value = base_asset_balance + trading_asset_balance * current_price
# Calculate the quantity
quantity = (risk_tolerance_percentage / 100) * portfolio_value / current_price
# Round the quantity according to the tickSize for each symbol
decimals = int(-np.log10(tick_sizes[symbol]))
quantity = round(quantity, decimals)
# Perform trading using updated models
trade(models[symbol], symbol, paper_trading=False)  # Set paper_trading=False for live trading
# Delay between consecutive API requests to avoid rate limiting
time.sleep(1)
```
</details>
# 答案1
**得分**: -1
```python
balance_info = balances.get(symbol, {"free": 0.0})
print(f"{symbol}: Free - {balance_info['free']}")
```
`balances`是一个字典，所以如果`symbol`在这个字典中，`balance_info`是这个符号下的余额**值**，因此在您当前的代码中是一个浮点数。在下一行中，您将`balance_info`视为字典，这会导致错误。您可能想要执行以下操作：
```python
free_balance = float(balance['free']) if balance else 0.0
balances[symbol] = {'free': free_balance} # 而不是 ... = free_balance
```
在您的获取当前余额函数中，这样在[symbol]键下实际上仍然有一个字典（而不是一个浮点数）。
<details>
<summary>英文:</summary>
```
balance_info = balances.get(symbol, {&quot;free&quot;: 0.0})
print(f&quot;{symbol}: Free - {balance_info[&#39;free&#39;]}&quot;)
```
`balances` is a dictionary, so if `symbol` is inside this dictionary, `balance_info` is a **value** of the balance under this symbol, and thus in your current code - a float. In the next line you treat balance_info as a dictionary, which causes an error. You probably meant to do
```
free_balance = float(balance[&#39;free&#39;]) if balance else 0.0
balances[symbol] = {&#39;free&#39;: free_balance} # instead of ... = free_balance
```
inside your get current balance function, so that under [symbol] key you actually still have a dictionary (rather than a float).
</details>