Compétences python-performance-optimization
📩

python-performance-optimization

Sûr

Optimize Python code performance and profiling

Également disponible depuis: wshobson,ActiveInferenceInstitute

Slow Python code wastes resources and frustrates users. This skill provides systematic profiling and optimization techniques to identify bottlenecks and improve performance.

Prend en charge: Claude Codex Code(CC)
đŸ„‰ 75 Bronze
1

Télécharger le ZIP du skill

2

Importer dans Claude

Allez dans ParamĂštres → CapacitĂ©s → Skills → Importer un skill

3

Activez et commencez Ă  utiliser

Tester

Utilisation de "python-performance-optimization". Profile a function that processes a large list

RĂ©sultat attendu:

Timing report showing process_data() consumed 2.3s (85% of total time), with 90% spent in nested loops. Recommendation: Replace O(nÂČ) algorithm with dictionary lookup for O(n) performance.

Utilisation de "python-performance-optimization". Analyze memory usage pattern

RĂ©sultat attendu:

Memory profile shows 500MB allocation in data_cache dictionary that grows unbounded. Recommendation: Implement LRU cache with maxsize parameter or use WeakValueDictionary for automatic cleanup.

Audit de sécurité

Sûr
v1 ‱ 2/24/2026

Static analysis flagged 68 patterns but all are false positives. The backtick detections are markdown code formatting, not shell execution. Network and URL findings are educational examples using test endpoints. SQLite references are documentation examples. System reconnaissance patterns are legitimate profiling tool demonstrations. This is a documentation-only skill with no executable code or security risks.

2
Fichiers analysés
908
Lignes analysées
0
résultats
1
Total des audits
Aucun problÚme de sécurité trouvé
Audité par: claude

Score de qualité

38
Architecture
100
Maintenabilité
87
Contenu
50
Communauté
100
Sécurité
100
Conformité aux spécifications

Ce que vous pouvez construire

Debug slow API endpoints

Profile a web application to identify slow database queries and optimize response times.

Optimize data processing pipelines

Analyze memory usage and execution time of ETL workflows to reduce resource consumption.

Improve algorithm efficiency

Profile computational code to identify inefficient patterns and apply appropriate optimizations.

Essayez ces prompts

Basic profiling setup 
Help me profile this Python function to identify performance bottlenecks. Here is my code: [paste code]. Show me how to use cProfile to measure execution time and find slow functions.
Memory leak investigation 
My Python application uses increasing memory over time. Help me use memory_profiler and tracemalloc to identify memory leaks in this code: [paste code]. Explain what the output means.
Optimization recommendations 
I have profiled my code and found these bottlenecks: [paste profiling output]. Recommend specific optimization techniques and show before/after code examples for each suggestion.
Advanced production profiling 
Guide me through setting up py-spy to profile a running Python production service without stopping it. Explain how to generate flame graphs and interpret the results to find hot paths.

Bonnes pratiques

  • Always profile before optimizing to identify actual bottlenecks, not assumed ones
  • Use appropriate data structures: dictionaries for lookups, sets for membership tests, generators for large sequences
  • Cache expensive computations with functools.lru_cache and batch I/O operations to reduce system call overhead

Éviter

  • Optimizing code without profiling data leads to wasted effort on non-bottlenecks
  • String concatenation in loops using + operator instead of join() causes quadratic time complexity
  • Loading entire files or datasets into memory when iterator-based processing would suffice

Foire aux questions

Which profiler should I use first?
Start with cProfile for overall CPU profiling. It is built into Python and shows which functions consume the most time. Use line_profiler for detailed line-by-line analysis of specific hot functions.
How do I profile production code without impacting performance?
Use py-spy, a sampling profiler that attaches to running processes with minimal overhead. It can generate flame graphs and does not require code changes or restarts.
Why is my optimized code slower than the original?
Common causes include premature optimization of cold paths, added complexity causing cache misses, or micro-optimizations that interfere with Python's internal optimizations. Always benchmark changes.
When should I use multiprocessing versus threading?
Use multiprocessing for CPU-bound tasks to bypass the GIL and utilize multiple cores. Use threading or asyncio for I/O-bound tasks where the GIL is released during I/O operations.
How can I reduce memory usage in my Python application?
Use generators instead of lists for large sequences, implement __slots__ in classes with many instances, avoid keeping unnecessary references, and use weak references for caches.
Is NumPy always faster than pure Python?
NumPy excels at vectorized numerical operations on large arrays due to C implementation. For small datasets or non-numerical tasks, pure Python may be simpler and equally fast.

Détails du développeur

Auteur

sickn33

Licence

MIT

DĂ©pĂŽt

https://github.com/sickn33/antigravity-awesome-skills/tree/main/skills/python-performance-optimization

RĂ©f

main

Structure de fichiers

📁 resources/

📄 implementation-playbook.md

📄 SKILL.md