friendships=[(0,1),(0,2),(1,2),(1,3),(2,3),(3,4),
             (4,5),(5,6),(5,7),(6,8),(7,8),(8,9)]
friendships[1][1]

 
For i in friendships:
       for  j in range (1,3):
           print(friendships [i][j])

 
>>> def mon_entier-au_hasard () :
...    import random
...    mon_entier_au_hasard = random.randint (0, 1000000)
...    print (mon_entier_au_hasard)
...

>>> mon_entier_au_hasard
 < function mon_entier_au_hasard at 0x00720858>    # apparemment, une simlple adresse où ma variable loge

>>> type (mon_entier_au_hasard)
<class 'function'>

>>> import random
>>> r = random.randint (0, 1000000)
>>> print (r)
14790

 
(.env) pip3 install mysqlclient

buildozer init
buildozer android debug deploy run

 
ind = [2,2,3,6]
for i in range(1, ind[0]+1):
    for j in range(i, ind[1]+1):
        for k in range(j, ind[2]+1):
            for l in range(k, ind[3]+1):
                 ...

 
Traceback (most recent call last):
  File "C:\Nicolas\dev\python\sklearn.py", line 11, in <module>
    from sklearn.model_selection import train_test_split
  File "C:\Nicolas\dev\python\sklearn.py", line 11, in <module>
    from sklearn.model_selection import train_test_split
ModuleNotFoundError: No module named 'sklearn.model_selection'; 'sklearn' is not a package

nb_player = int(input("combien de joueur"))
for i in range(0,nb_player):
    name= input("non du joueur{}".format(i+1))

 
…
 
    N = len(sys.argv)
    #print ('N  :',N, sys.argv[0])# C:\...\main_ML.py
    if N > 1:
        A=sys.argv[1]
        #print ('A  :',A)# C:\...\main_ML.py
        if A == 'NICO_BAT_Mode':  # first choosed argument in batch file
            General_ML.From_BAT_File =  True # in that case don't install libreries in main python area
 
 
    if not General_ML.From_BAT_File:
        from    pip_version_checker   import  main_PIP_CHECK
        from    requirements_checker  import check_and_install_requirements
        print('main_PIP_CHECK')
        main_PIP_CHECK()
        print('Done')
 
        print('check_and_install_requirements')
        check_and_install_requirements()
        print('Done')

 
# pip_version_checker.py (Fixed)
"""
Pip Version Checker - Utility to check and update pip to latest version
"""
#=> inform you must run this script with python 3 or above
#!/usr/bin/python3
#=> inform we are usige an UTF-8 code ( otherwhise some chars such as é, è, .. could be wrongly displayed) 
# -*- coding: utf-8 -*-
 
import subprocess
import sys
import re
import General_ML
 
def PR(st):
    General_ML.Preliminary_info.append(st)
    print(st)
 
class PipVersionChecker:
    def __init__(self):
        self.current_version = None
        self.latest_version = None
 
    def get_current_pip_version(self):
        """Get currently installed pip version"""
        try:
            result = subprocess.run([sys.executable, "-m", "pip", "--version"], 
                                  capture_output=True, text=True, check=True)
 
            # Extract version from output like "pip 21.3.1 from ..."
            match = re.search(r'pip\s+([\d.]+)', result.stdout)
            if match:
                self.current_version = match.group(1)
                return self.current_version
            else:
                return None
 
        except (subprocess.CalledProcessError, FileNotFoundError):
            return None
 
    def get_latest_pip_version(self):
        """Get latest available pip version from PyPI"""
        try:
            # Use pip index versions to get available versions
            result = subprocess.run([sys.executable, "-m", "pip", "index", "versions", "pip"], 
                                  capture_output=True, text=True)
 
            if result.returncode == 0:
                # Parse output to find latest version
                for line in result.stdout.split('\n'):
                    if 'LATEST:' in line:
                        match = re.search(r'LATEST:\s+([\d.]+)', line)
                        if match:
                            self.latest_version = match.group(1)
                            return self.latest_version
 
            # Fallback: try the old method
            result = subprocess.run([sys.executable, "-m", "pip", "install", "pip==999.0.0"], 
                                  capture_output=True, text=True)
 
            # Extract latest version from error message
            for line in result.stderr.split('\n'):
                if 'from versions:' in line:
                    versions_text = line.split('from versions:')[-1].split(')')[0]
                    versions = [v.strip() for v in versions_text.split(',')]
                    if versions:
                        self.latest_version = versions[-1]  # Last version is usually latest
                        return self.latest_version
 
            return None
 
        except subprocess.CalledProcessError:
            return None
 
    def compare_versions(self, v1, v2):
        """Simple version comparison without external dependencies"""
        def parse_version(v):
            return [int(x) for x in v.split('.')]
 
        try:
            v1_parts = parse_version(v1)
            v2_parts = parse_version(v2)
 
            # Pad with zeros if different length
            max_len = max(len(v1_parts), len(v2_parts))
            v1_parts.extend([0] * (max_len - len(v1_parts)))
            v2_parts.extend([0] * (max_len - len(v2_parts)))
 
            return v1_parts < v2_parts
        except:
            return False
 
    def is_update_needed(self):
        """Check if pip update is needed"""
        current = self.get_current_pip_version()
        latest = self.get_latest_pip_version()
 
        if not current or not latest:
            return False, latest
 
        return self.compare_versions(current, latest), latest
 
    def update_pip(self):
        """Update pip to latest version"""
        try:
            PR("Updating pip to latest version...")
            subprocess.run([sys.executable, "-m", "pip", "install", "--upgrade", "pip"], 
                         check=True, capture_output=True)
            PR("pip updated successfully!")
            return True
        except subprocess.CalledProcessError as e:
            PR(f"Failed to update pip: {e}")
            return False
 
    def check_and_update(self):
        """Main method to check and update pip if needed"""
        PR("Checking pip version...")
 
        current = self.get_current_pip_version()
        if not current:
            PR("Could not determine current pip version")
            return False
 
        PR(f"Current pip version: {current}")
 
        '''
        
        latest = self.get_latest_pip_version()
        if not latest:
            PR("Could not determine latest pip version")
            return False
            
        PR(f"Latest pip version: {latest}")
        '''
        OK, latest = self.is_update_needed()
        if OK:
            PR(f"Update available: {current} -> {latest}")
            return self.update_pip()
        else:
            PR(f"Latest pip version: {latest}")
            PR("Your pip is already up to date!")
            return True
 
def main_PIP_CHECK():  # renomé. Main un peu dangereux. Il peut y avoir des risques de confusion
    """Standalone pip version checker"""
    checker = PipVersionChecker()
    checker.check_and_update()

 
# requirements_checker.py (New - Simple dependency checker)
"""
Simple requirements checker without external dependencies
"""
#=> inform you must run this script with python 3 or above
#!/usr/bin/python3
#=> inform we are usige an UTF-8 code ( otherwhise some chars such as é, è, .. could be wrongly displayed) 
# -*- coding: utf-8 -*-
 
import      subprocess
import      sys
import      os
import      General_ML
 
def check_and_install_requirements():
    """Check and install required packages"""
    requirements = {
        'yfinance': 'yfinance',
        'pandas': 'pandas', 
        'fpdf':'fpdf',
        'numpy': 'numpy',
        'scipy': 'scipy',
        'matplotlib': 'matplotlib',
        'sklearn': 'sklearn',
        #'scikit-learn': 'scikit-learn',
        'plotly': 'plotly',
        'seaborn': 'seaborn',# jamais Utilisé???
        'tkinter': 'tkinter'  # Usually comes with Python     pip install scikit-learn
 
    }
    '''
        Le module shutil fait partie de la bibliothèque standard de Python, 
        ce qui signifie qu'il est inclus par défaut lors de l'installation de Python . =>
        inutile de le mettre dans la liste ci-dessus
    '''
 
    General_ML.Preliminary_info.append("Checking dependencies...")
 
    General_ML.Preliminary_info.append("Checking dependencies...")
    SAP = os.getenv('SKLEARN_ALLOW_DEPRECATED_SKLEARN_PACKAGE_INSTALL')
 
    os.environ["SKLEARN_ALLOW_DEPRECATED_SKLEARN_PACKAGE_INSTALL"] = 'True'
 
 
    for package, install_name in requirements.items():
        try:
            if package == 'tkinter':
                # tkinter is usually bundled with Python
                #import tkinter
                General_ML.Preliminary_info.append(f"✓ {package} is available")
            else:
                __import__(package)
                General_ML.Preliminary_info.append(f"✓ {package} is available")
        except ImportError:
            if install_name:
                General_ML.Preliminary_info.append(f"✗ {package} not found. Installing...")
                try:
                    subprocess.check_call([sys.executable, "-m", "pip", "install",  install_name ])
                    General_ML.Preliminary_info.append(f"✓ {package} installed successfully")
                    General_ML.Must_Restart            =  True
                except subprocess.CalledProcessError:
                    General_ML.Preliminary_info.append(f"✗ Failed to install {package}")
                # end if install_name
            else:
                General_ML.Preliminary_info.append(f"✗ {package} is required but cannot be installed via pip")
            #end except ImportError:
        # end for package, install_name in requirements.items():
 
    #python -m pip show scikit-learn > scikitlearn.jpm123
    result = subprocess.run([sys.executable, "-m", "pip","show" ,"scikit-learn"], capture_output=True, text=True)
 
    a=len(result.stdout)
 
    if a < 1:
        subprocess.check_call([sys.executable, "-m", "pip", "install",  'scikit-learn' ])
        General_ML.Must_Restart            =  True
 
    if SAP==None:
        os.environ.pop('SKLEARN_ALLOW_DEPRECATED_SKLEARN_PACKAGE_INSTALL')
    else:
        os.environ["SKLEARN_ALLOW_DEPRECATED_SKLEARN_PACKAGE_INSTALL"] = SAP
    #end check_and_install_requirements

 
python -m venv Nicola__env
cd Nicola__env
cd scripts
call activate.bat
cd..
cd..
pip3 install scipy
pip3 install seaborn
pip3 install python-dateutil
pip3 install matplotlib
pip3 install scikit-learn
pip3 install fpdf
pip3 install pandas
pip3 install yfinance
pip3 install tk
pip3 install plotly
pip3 install seaborn
python main_ml.py NICO_BAT_Mode
cd Nicola__env
cd scripts
call deactivate.bat
cd..
cd..

 
#!/bin/bash
python3 -m venv Nicola__env
source Nicola__env/bin/activate
rem ou pip3 ?
pip install scipy seaborn python-dateutil matplotlib scikit-learn fpdf pandas yfinance tk plotly
python main_ml.py NICO_BAT_Mode
deactivate
rm -rf Nicola__env