OpenClaw 智能code生成

import pandas as pd
import os

def process_csv(input_path, output_path, date_columns=None, sort_column=None, stats_columns=None):
    """
    processingCSVfile, 执行data清洗, 转换, sort and statisticsanalysis
    
    parameter:
        input_path (str): 输入CSVfilepath
        output_path (str): 输出CSVfilepath
        date_columns (list, optional): 需要转换 for datetime格式 列名list
        sort_column (str, optional): 用于sort 列名
        stats_columns (list, optional): 需要计算statisticsinformation 列名list
    
    返回:
        tuple: (processing after  DataFrame, statisticsinformationdictionary)
    
    exception:
        FileNotFoundError: such as果输入file不存 in 
        ValueError: such as果指定 列名不存 in 
    """
    # check输入file is 否存 in 
    if not os.path.exists(input_path):
        raise FileNotFoundError(f"输入file不存 in : {input_path}")
    
    try:
        # 读取CSVfile
        df = pd.read_csv(input_path)
        
        # 移除package含缺失值 行
        initial_rows = len(df)
        df = df.dropna()
        removed_rows = initial_rows - len(df)
        print(f"移除了 {removed_rows} 行package含缺失值 data")
        
        # 转换日期列
        if date_columns:
            for col in date_columns:
                if col in df.columns:
                    df[col] = pd.to_datetime(df[col])
                    print(f"已将列 '{col}' 转换 for datetime格式")
                else:
                    raise ValueError(f"列 '{col}'  in datain不存 in ")
        
        # 按指定列sort
        if sort_column:
            if sort_column in df.columns:
                df = df.sort_values(by=sort_column)
                print(f"已按列 '{sort_column}' sort")
            else:
                raise ValueError(f"列 '{sort_column}'  in datain不存 in ")
        
        # 计算statisticsinformation
        stats = {}
        if stats_columns:
            for col in stats_columns:
                if col in df.columns:
                    col_stats = {
                        'mean': df[col].mean(),
                        'median': df[col].median(),
                        'std': df[col].std(),
                        'min': df[col].min(),
                        'max': df[col].max()
                    }
                    stats[col] = col_stats
                    print(f"已计算列 '{col}'  statisticsinformation")
                else:
                    raise ValueError(f"列 '{col}'  in datain不存 in ")
        
        # 保存processing after  data
        df.to_csv(output_path, index=False)
        print(f"processing after  data已保存 to : {output_path}")
        
        return df, stats
        
    except Exception as e:
        print(f"processing过程in出现error: {str(e)}")
        raise

# example用法
def example_using():
    input_file = "data.csv"
    output_file = "processed_data.csv"
    
    try:
        df, stats = process_csv(
            input_path=input_file,
            output_path=output_file,
            date_columns=["date"],
            sort_column="value",
            stats_columns=["value", "quantity"]
        )
        
        print("\nprocessing after   before 5行data:")
        print(df.head())
        
        print("\nstatisticsinformation:")
        for col, col_stats in stats.items():
            print(f"\n{col}:")
            for stat_name, value in col_stats.items():
                print(f"  {stat_name}: {value}")
                
    except Exception as e:
        print(f"error: {str(e)}")

if __name__ == "__main__":
    example_using()

import React, { useState, useEffect } from 'react';
import styled from 'styled-components';

// 样式component
const ProductListContainer = styled.div`
  max-width: 1200px;
  margin: 0 auto;
  padding: 20px;
`;

const FilterSection = styled.div`
  background-color: #f5f5f5;
  padding: 20px;
  border-radius: 8px;
  margin-bottom: 20px;
`;

const SearchBox = styled.input`
  width: 100%;
  padding: 10px;
  margin-bottom: 15px;
  border: 1px solid #ddd;
  border-radius: 4px;
`;

const FilterRow = styled.div`
  display: flex;
  gap: 20px;
  margin-bottom: 15px;
  
  @media (max-width: 768px) {
    flex-direction: column;
  }
`;

const FilterColumn = styled.div`
  flex: 1;
`;

const Label = styled.label`
  display: block;
  margin-bottom: 5px;
  font-weight: bold;
`;

const Select = styled.select`
  width: 100%;
  padding: 8px;
  border: 1px solid #ddd;
  border-radius: 4px;
`;

const PriceRange = styled.input`
  width: 100%;
`;

const PriceValue = styled.div`
  margin-top: 5px;
  font-size: 0.9rem;
  color: #666;
`;

const ProductsGrid = styled.div`
  display: grid;
  grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
  gap: 20px;
`;

const ProductCard = styled.div`
  background-color: white;
  border: 1px solid #ddd;
  border-radius: 8px;
  padding: 15px;
  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
`;

const ProductName = styled.h3`
  margin-top: 0;
  margin-bottom: 10px;
  color: #333;
`;

const ProductPrice = styled.p`
  font-weight: bold;
  color: #e53935;
  margin-bottom: 10px;
`;

const ProductCategory = styled.p`
  color: #666;
  margin-bottom: 0;
`;

const NoProductsMessage = styled.div`
  text-align: center;
  padding: 40px;
  color: #666;
`;

// 产品data
const initialProducts = [
  { id: 1, name: 'Smartphone X', price: 999, category: 'Electronics' },
  { id: 2, name: 'Laptop Pro', price: 1499, category: 'Electronics' },
  { id: 3, name: 'Wireless Headphones', price: 199, category: 'Accessories' },
  { id: 4, name: 'Smartwatch', price: 299, category: 'Wearables' },
  { id: 5, name: 'Bluetooth Speaker', price: 149, category: 'Audio' },
  { id: 6, name: 'Camera Lens', price: 599, category: 'Photography' },
];

const ProductList = () => {
  // statusmanagement
  const [products, setProducts] = useState(initialProducts);
  const [filteredProducts, setFilteredProducts] = useState(initialProducts);
  const [searchTerm, setSearchTerm] = useState('');
  const [categoryFilter, setCategoryFilter] = useState('all');
  const [maxPrice, setMaxPrice] = useState(2000);
  
  // 获取所 has 唯一class别
  const categories = ['all', ...new Set(products.map(product => product.category))];
  
  // filter产品
  useEffect(() => {
    let result = products;
    
    // 按名称filter
    if (searchTerm) {
      result = result.filter(product => 
        product.name.toLowerCase().includes(searchTerm.toLowerCase())
      );
    }
    
    // 按class别filter
    if (categoryFilter !== 'all') {
      result = result.filter(product => product.category === categoryFilter);
    }
    
    // 按价格filter
    result = result.filter(product => product.price <= maxPrice);
    
    setFilteredProducts(result);
  }, [products, searchTerm, categoryFilter, maxPrice]);
  
  return (
    
      
产品list
      
      
        
filter器
        
         setSearchTerm(e.target.value)}
        />
        
        
          
            class别
             setCategoryFilter(e.target.value)}
            >
              {categories.map(category => (
                
                  {category === 'all' ? '所 has class别' : category}
                
              ))}
            
          
          
          
            最 big 价格: ${maxPrice}
             setMaxPrice(parseInt(e.target.value))}
            />
            ${maxPrice}
          
        
      
      
      {filteredProducts.length > 0 ? (
        
          {filteredProducts.map(product => (
            
              {product.name}
              ${product.price}
              class别: {product.category}
            
          ))}
        
      ) : (
        
          没 has 找 to 符合条件 产品
        
      )}
    
  );
};

export default ProductList;