To create a Python web application using Flask, you'll need to follow these steps:

1. Install the required packages
2. Set up the SQLite database and models
3. Create the authentication system with JWT tokens
4. Implement CRUD operations for notes
5. Develop RESTful API endpoints
6. Add Swagger/OpenAPI documentation

Here's an example implementation of this project:

Step 1: Install the required packages

Install the following packages using pip:

```
pip install flask flask-sqlalchemy flask-marshmallow marshmallow-sqlalchemy flask-jwt-extended
```

Step 2: Set up the SQLite database and models

Create a file called `app.py` and add the following code to set up the SQLite database and define the Note model:

```python
from flask import Flask, request, jsonify
from flask_sqlalchemy import SQLAlchemy
from flask_marshmallow import Marshmallow
import os

# Initialize app
app = Flask(__name__)
basedir = os.path.abspath(os.path.dirname(__file__))

# Database configuration
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + os.path.join(basedir, 'db.sqlite')
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

# Initialize database and Marshmallow
db = SQLAlchemy(app)
ma = Marshmallow(app)

# Note Model
class Note(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(100), nullable=False)
    content = db.Column(db.Text, nullable=False)
    user_id = db.Column(db.Integer, nullable=False)

    def __init__(self, title, content, user_id):
        self.title = title
        self.content = content
        self.user_id = user_id

# Note Schema
class NoteSchema(ma.SQLAlchemyAutoSchema):
    class Meta:
        model = Note

note_schema = NoteSchema()
notes_schema = NoteSchema(many=True)

# Create the database tables
db.create_all()

if __name__ == '__main__':
    app.run(debug=True)
```

Step 3: Create the authentication system with JWT tokens

Add the following code to `app.py` to set up the User model and configure JWT:

```python
from flask_jwt_extended import JWTManager, jwt_required, create_access_token, get_jwt_identity

# Add a secret key for JWT
app.config['JWT_SECRET_KEY'] = 'your-secret-key'
jwt = JWTManager(app)

# User Model
class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(50), unique=True, nullable=False)
    password = db.Column(db.String(100), nullable=False)

    def __init__(self, username, password):
        self.username = username
        self.password = password

# User Schema
class UserSchema(ma.SQLAlchemyAutoSchema):
    class Meta:
        model = User

user_schema = UserSchema()
users_schema = UserSchema(many=True)

# Register user
@app.route('/register', methods=['POST'])
def register():
    username = request.json['username']
    password = request.json['password']

    new_user = User(username=username, password=password)
    db.session.add(new_user)
    db.session.commit()

    return user_schema.jsonify(new_user)

# Login user
@app.route('/login', methods=['POST'])
def login():
    username = request.json['username']
    password = request.json['password']

    user = User.query.filter_by(username=username).first()

    if not user or user.password != password:
        return jsonify({'error': 'Invalid credentials'})

    access_token = create_access_token(identity=user.id)
    return jsonify(access_token=access_token)
```

Step 4: Implement CRUD operations for notes

Add the following code to `app.py` to implement the CRUD operations:

```python
# Create a note
@app.route('/notes', methods=['POST'])
@jwt_required()
def add_note():
    title = request.json['title']
    content = request.json['content']
    user_id = get_jwt_identity()

    new_note = Note(title=title, content=content, user_id=user_id)
    db.session.add(new_note)
    db.session.commit()

    return note_schema.jsonify(new_note)

# Get all notes
@app.route('/notes', methods=['GET'])
@jwt_required()
def get_notes():
    user_id = get_jwt_identity()
    notes = Note.query.filter_by(user_id=user_id).all()
    return notes_schema.jsonify(notes)

# Get single note
@app.route('/notes/<id>', methods=['GET'])
@jwt_required()
def get_note(id):
    user_id = get_jwt_identity()
    note = Note.query.get_or_404(id)

    if note.user_id != user_id:
        return jsonify({'error': 'Not authorized'})

    return note_schema.jsonify(note)

# Update a note
@app.route('/notes/<id>', methods=['PUT'])
@jwt_required()
def update_note(id):
    user_id = get_jwt_identity()
    note = Note.query.get_or_404(id)

    if note.user_id != user_id:
        return jsonify({'error': 'Not authorized'})

    note.title = request.json['title']
    note.content = request.json['content']

    db.session.commit()
    return note_schema.jsonify(note)

# Delete a note
@app.route('/notes/<id>', methods=['DELETE'])
@jwt_required()
def delete_note(id):
    user_id = get_jwt_identity()
    note = Note.query.get_or_404(id)

    if note.user_id != user_id:
        return jsonify({'error': 'Not authorized'})

    db.session.delete(note)
    db.session.commit()

    return note_schema.jsonify(note)
```

Step 5: Develop RESTful API endpoints

The code above already includes the RESTful API endpoints for CRUD operations and user authentication.

Step 6: Add Swagger/OpenAPI documentation

To add Swagger/OpenAPI documentation, you can use the `flask-swagger-ui` package. Install it using pip:

```
pip install flask-swagger-ui
```

Then, add the following code to `app.py` to set up Swagger UI:

```python
from flask_swagger_ui import get_swaggerui_blueprint

# Swagger UI configuration
SWAGGER_URL = '/api/docs'
API_URL = '/static/swagger.json'

swaggerui_blueprint = get_swaggerui_blueprint(
    SWAGGER_URL,
    API_URL,
    config={
        'app_name': "Flask Notes App"
    }
)

app.register_blueprint(swaggerui_blueprint, url_prefix=SWAGGER_URL)
```

Create a folder named `static` in your project directory and create a file called `swagger.json` inside it. You can now write your OpenAPI documentation in this JSON file. Here's an example of how to document the `/login` endpoint:

```json
{
  "openapi": "3.0.0",
  "info": {
    "title": "Flask Notes App",
    "version": "1.0.0"
  },
  "paths": {
    "/login": {
      "post": {
        "summary": "Login user",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "username": {
                    "type": "string"
                  },
                  "password": {
                    "type": "string"
                  }
                },
                "required": [
                  "username",
                  "password"
                ]
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful login",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "access_token": {
                      "type": "string"
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}
```

Now, you can run your Flask app using the following command:

```
python app.py
```

You should be able to access the Swagger UI at `http://localhost:5000/api/docs`.
Flask를 사용하여 Python 웹 애플리케이션을 생성하려면 다음 단계를 따라야 합니다.

1. 필요한 패키지를 설치합니다
2. SQLite 데이터베이스와 모델을 설정합니다
3. JWT 토큰으로 인증 시스템 생성
4. 노트에 대한 CRUD 작업 구현
5. RESTful API 엔드포인트 개발
6. Swagger/OpenAPI 문서 추가

다음은 이 프로젝트의 구현 예제입니다.

1단계: 필수 패키지 설치

다음 패키지를 pip를 사용하여 설치합니다:

```
pip install flask flask-sqlalchemy flask-marshmallow marshmallow-sqlalchemy flask-jwt-extended
```

2단계: SQLite 데이터베이스 및 모델 설정

`app.py`라는 파일을 만들고 다음 코드를 추가해 SQLite 데이터베이스를 설정하고 노트 모델을 정의합니다:

```python
from flask import Flask, request, jsonify
from flask_sqlalchemy import SQLAlchemy
from flask_marshmallow import Marshmallow
import os

# Initialize app
app = Flask(__name__)
basedir = os.path.abspath(os.path.dirname(__file__))

# Database configuration
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + os.path.join(basedir, 'db.sqlite')
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

# Initialize database and Marshmallow
db = SQLAlchemy(app)
ma = Marshmallow(app)

# Note Model
class Note(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(100), nullable=False)
    content = db.Column(db.Text, nullable=False)
    user_id = db.Column(db.Integer, nullable=False)

    def __init__(self, title, content, user_id):
        self.title = title
        self.content = content
        self.user_id = user_id

# Note Schema
class NoteSchema(ma.SQLAlchemyAutoSchema):
    class Meta:
        model = Note

note_schema = NoteSchema()
notes_schema = NoteSchema(many=True)

# Create the database tables
db.create_all()

if __name__ == '__main__':
    app.run(debug=True)
```

3단계: JWT 토큰으로 인증 시스템 만들기

`app.py`에 다음 코드를 추가하여 사용자 모델을 설정하고 JWT를 구성합니다:

```python
from flask_jwt_extended import JWTManager, jwt_required, create_access_token, get_jwt_identity

# Add a secret key for JWT
app.config['JWT_SECRET_KEY'] = 'your-secret-key'
jwt = JWTManager(app)

# User Model
class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(50), unique=True, nullable=False)
    password = db.Column(db.String(100), nullable=False)

    def __init__(self, username, password):
        self.username = username
        self.password = password

# User Schema
class UserSchema(ma.SQLAlchemyAutoSchema):
    class Meta:
        model = User

user_schema = UserSchema()
users_schema = UserSchema(many=True)

# Register user
@app.route('/register', methods=['POST'])
def register():
    username = request.json['username']
    password = request.json['password']

    new_user = User(username=username, password=password)
    db.session.add(new_user)
    db.session.commit()

    return user_schema.jsonify(new_user)

# Login user
@app.route('/login', methods=['POST'])
def login():
    username = request.json['username']
    password = request.json['password']

    user = User.query.filter_by(username=username).first()

    if not user or user.password != password:
        return jsonify({'error': 'Invalid credentials'})

    access_token = create_access_token(identity=user.id)
    return jsonify(access_token=access_token)
```

4단계: 노트에 대한 CRUD 작업 구현

다음 코드를 `app.py`에 추가하여 CRUD 작업을 구현합니다:

```python
# Create a note
@app.route('/notes', methods=['POST'])
@jwt_required()
def add_note():
    title = request.json['title']
    content = request.json['content']
    user_id = get_jwt_identity()

    new_note = Note(title=title, content=content, user_id=user_id)
    db.session.add(new_note)
    db.session.commit()

    return note_schema.jsonify(new_note)

# Get all notes
@app.route('/notes', methods=['GET'])
@jwt_required()
def get_notes():
    user_id = get_jwt_identity()
    notes = Note.query.filter_by(user_id=user_id).all()
    return notes_schema.jsonify(notes)

# Get single note
@app.route('/notes/<id>', methods=['GET'])
@jwt_required()
def get_note(id):
    user_id = get_jwt_identity()
    note = Note.query.get_or_404(id)

    if note.user_id != user_id:
        return jsonify({'error': 'Not authorized'})

    return note_schema.jsonify(note)

# Update a note
@app.route('/notes/<id>', methods=['PUT'])
@jwt_required()
def update_note(id):
    user_id = get_jwt_identity()
    note = Note.query.get_or_404(id)

    if note.user_id != user_id:
        return jsonify({'error': 'Not authorized'})

    note.title = request.json['title']
    note.content = request.json['content']

    db.session.commit()
    return note_schema.jsonify(note)

# Delete a note
@app.route('/notes/<id>', methods=['DELETE'])
@jwt_required()
def delete_note(id):
    user_id = get_jwt_identity()
    note = Note.query.get_or_404(id)

    if note.user_id != user_id:
        return jsonify({'error': 'Not authorized'})

    db.session.delete(note)
    db.session.commit()

    return note_schema.jsonify(note)
```

5단계: RESTful API 엔드포인트 개발

위 코드에는 CRUD 작업 및 사용자 인증을 위한 RESTful API 엔드포인트가 이미 포함되어 있습니다.

6단계: Swagger/OpenAPI 문서 추가

Swagger/OpenAPI 문서를 추가하려면 `flask-swagger-ui` 패키지를 사용할 수 있습니다. pip를 사용하여 설치합니다:

```
pip install flask-swagger-ui
```

그런 다음 `app.py`에 다음 코드를 추가하여 Swagger UI를 설정합니다:

```python
from flask_swagger_ui import get_swaggerui_blueprint

# Swagger UI configuration
SWAGGER_URL = '/api/docs'
API_URL = '/static/swagger.json'

swaggerui_blueprint = get_swaggerui_blueprint(
    SWAGGER_URL,
    API_URL,
    config={
        'app_name': "Flask Notes App"
    }
)

app.register_blueprint(swaggerui_blueprint, url_prefix=SWAGGER_URL)
```

프로젝트 디렉토리에 `static`이라는 폴더를 만들고 그 안에 `swagger.json`이라는 파일을 만듭니다. 이제 이 JSON 파일에 OpenAPI 문서를 작성할 수 있습니다. 다음은 `/login` 엔드포인트를 문서화하는 방법의 예시입니다:

```json
{
  "openapi": "3.0.0",
  "info": {
    "title": "Flask Notes App",
    "version": "1.0.0"
  },
  "paths": {
    "/login": {
      "post": {
        "summary": "Login user",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "username": {
                    "type": "string"
                  },
                  "password": {
                    "type": "string"
                  }
                },
                "required": [
                  "username",
                  "password"
                ]
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful login",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "access_token": {
                      "type": "string"
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}
```

이제 다음 명령을 사용하여 플라스크 앱을 실행할 수 있습니다:

```
python app.py
```

`http://localhost:5000/api/docs`에서 스웨거 UI에 액세스할 수 있어야 합니다.