How do I install Python on my computer?
Go to: https://www.python.org/downloads/

There should be some big yellow text in the center of the page that says "Download the latest version for X" where X is your operating system.
Underneath that is a yellow button. Click it. That will download the latest Python installer.
Go to your downloads folder and double click the installed file. If there's a security warning pop up, click the Run button.
The installer will launch. It should walk you through the rest of the process.
How to setup authorization and authentication fastapi with explaination ? Setting up authorization and authentication in FastAPI involves several steps:

1. Install necessary packages: First, you'll need to install two packages: fastapi-users and fastapi-jwt-auth. fastapi-users provides the user authentication and management functionality, while fastapi-jwt-auth provides JWT (JSON Web Token) authentication.
``` 
pip install fastapi-users fastapi-jwt-auth[bcrypt]
``` 
2. Define your User model: You'll need to create a model that defines the properties of a user, such as their email and password.
``` 
class User(BaseModel, UserManagerMixin):
    email: EmailStr
    password: str
    is_active: bool = True
    is_superuser: bool = False
``` 
3. Create a user database: You'll need to create a database of user objects, which can be done using any database framework, such as SQLAlchemy or Tortoise-ORM.

4. Configure the authentication system: You'll need to configure the authentication system to use JWT tokens for authentication. This involves defining a secret key for encoding and decoding the tokens.
``` 
from fastapi_jwt_auth import AuthJWT

authjwt_secret_key = "secret"
authjwt_algorithm = "HS256"
``` 
5. Create authentication routes: You'll need to create routes for registering, logging in, and logging out users.

``` 
from fastapi_users import FastAPIUsers, LoginCredentials
from fastapi_users.authentication import JWTAuthentication

users = FastAPIUsers(
    User,
    [JWTAuthentication(secret=authjwt_secret_key, lifetime_seconds=3600)],
    UserCreate,
    UserUpdate,
    UserDB,
)

@app.post("/auth/jwt/login")
async def login(credentials: LoginCredentials):
    user = await fastapi_users.get_user(credentials.username)
    if not user or not await fastapi_users.verify_password(credentials.password, user.password):
        raise HTTPException(status_code=HTTP_401_UNAUTHORIZED, detail="Incorrect username or password")
    access_token = AuthJWT.create_access_token(subject=user.email)
    return {"access_token": access_token}
``` 

6. Secure your routes: You'll need to use the Depends function from FastAPI to add authentication and authorization to your routes.
``` 
from fastapi import Depends
from fastapi_jwt_auth import AuthJWT

async def get_current_user(authjwt: AuthJWT = Depends()):
    try:
        authjwt.jwt_required()
        user_email = authjwt.get_jwt_subject()
        user = await fastapi_users.get_user(user_email)
        return user
    except Exception as e:
        raise HTTPException(status_code=HTTP_401_UNAUTHORIZED, detail=str(e))
``` 
This function can then be added as a dependency to your routes that require authentication.

Overall, setting up authentication and authorization in FastAPI involves creating a user model, configuring authentication and authorization routes, and securing your routes using the Depends function.