title: How can I run a project in a local server using Pycharm?
body: <p>when I try to run a project in a local server using Pycharm, I can't do that with these errors.</p>
  
  <p>So would you mind telling me how should I solve this problem?</p>
  
  <p>Thank you in advance.</p>
  
  <hr>
  
  <p><strong>updated:</strong> 
  I found that global_settings.py doesn't exist in the directory of conf, and I made another question to solve the newest issue.
  Thank you.
  <a href="https://stackoverflow.com/questions/60800842/how-should-i-do-when-conf-folder-doesnt-have-global-setteings-py">How should I do when conf folder doesn't have global_setteings.py</a> </p>
  
  <hr>
  
  <pre><code>Traceback (most recent call last):
    File "/Users/apple/GoogleDrive/project_django/project/manage.py", line 10, in main
      from django.core.management import execute_from_command_line
    File "/Users/apple/GoogleDrive/project_django/venv/lib/python3.7/site-packages/django/core/management/__init__.py", line 11, in &lt;module&gt;
      from django.conf import settings
    File "/Users/apple/GoogleDrive/project_django/venv/lib/python3.7/site-packages/django/conf/__init__.py", line 17, in &lt;module&gt;
      from django.conf import global_settings
  ImportError: cannot import name 'global_settings' from 'django.conf' (/Users/apple/GoogleDrive/project_django/venv/lib/python3.7/site-packages/django/conf/__init__.py)
  
  The above exception was the direct cause of the following exception:
  
  Traceback (most recent call last):
    File "/Users/apple/GoogleDrive/project_django/project/manage.py", line 21, in &lt;module&gt;
      main()
    File "/Users/apple/GoogleDrive/project_django/project/manage.py", line 16, in main
      ) from exc
  ImportError: Couldn't import Django. Are you sure it's installed and available on your PYTHONPATH environment variable? Did you forget to activate a virtual environment?
  </code></pre>
  
  <p><strong>init</strong>.py</p>
  
  <pre><code>"""
  Settings and configuration for Django.
  
  Read values from the module specified by the DJANGO_SETTINGS_MODULE environment
  variable, and then from django.conf.global_settings; see the global_settings.py
  for a list of all possible variables.
  """
  
  import importlib
  import os
  import time
  import traceback
  import warnings
  from pathlib import Path
  
  import django
  from django.conf import settings
  from django.core.exceptions import ImproperlyConfigured
  from django.utils.deprecation import (
      RemovedInDjango30Warning, RemovedInDjango31Warning,
  )
  from django.utils.functional import LazyObject, empty
  
  ENVIRONMENT_VARIABLE = "DJANGO_SETTINGS_MODULE"
  
  DEFAULT_CONTENT_TYPE_DEPRECATED_MSG = 'The DEFAULT_CONTENT_TYPE setting is deprecated.'
  FILE_CHARSET_DEPRECATED_MSG = (
      'The FILE_CHARSET setting is deprecated. Starting with Django 3.1, all '
      'files read from disk must be UTF-8 encoded.'
  )
  
  
  class SettingsReference(str):
      """
      String subclass which references a current settings value. It's treated as
      the value in memory but serializes to a settings.NAME attribute reference.
      """
      def __new__(self, value, setting_name):
          return str.__new__(self, value)
  
      def __init__(self, value, setting_name):
          self.setting_name = setting_name
  
  
  class LazySettings(LazyObject):
      """
      A lazy proxy for either global Django settings or a custom settings object.
      The user can manually configure settings prior to using them. Otherwise,
      Django uses the settings module pointed to by DJANGO_SETTINGS_MODULE.
      """
      def _setup(self, name=None):
          """
          Load the settings module pointed to by the environment variable. This
          is used the first time settings are needed, if the user hasn't
          configured settings manually.
          """
          settings_module = os.environ.get(ENVIRONMENT_VARIABLE)
          if not settings_module:
              desc = ("setting %s" % name) if name else "settings"
              raise ImproperlyConfigured(
                  "Requested %s, but settings are not configured. "
                  "You must either define the environment variable %s "
                  "or call settings.configure() before accessing settings."
                  % (desc, ENVIRONMENT_VARIABLE))
  
          self._wrapped = Settings(settings_module)
  
      def __repr__(self):
          # Hardcode the class name as otherwise it yields 'Settings'.
          if self._wrapped is empty:
              return '&lt;LazySettings [Unevaluated]&gt;'
          return '&lt;LazySettings "%(settings_module)s"&gt;' % {
              'settings_module': self._wrapped.SETTINGS_MODULE,
          }
  
      def __getattr__(self, name):
          """Return the value of a setting and cache it in self.__dict__."""
          if self._wrapped is empty:
              self._setup(name)
          val = getattr(self._wrapped, name)
          self.__dict__[name] = val
          return val
  
      def __setattr__(self, name, value):
          """
          Set the value of setting. Clear all cached values if _wrapped changes
          (@override_settings does this) or clear single values when set.
          """
          if name == '_wrapped':
              self.__dict__.clear()
          else:
              self.__dict__.pop(name, None)
          super().__setattr__(name, value)
  
      def __delattr__(self, name):
          """Delete a setting and clear it from cache if needed."""
          super().__delattr__(name)
          self.__dict__.pop(name, None)
  
      def configure(self, default_settings=global_settings, **options):
          """
          Called to manually configure the settings. The 'default_settings'
          parameter sets where to retrieve any unspecified values from (its
          argument must support attribute access (__getattr__)).
          """
          if self._wrapped is not empty:
              raise RuntimeError('Settings already configured.')
          holder = UserSettingsHolder(default_settings)
          for name, value in options.items():
              setattr(holder, name, value)
          self._wrapped = holder
  
      @property
      def configured(self):
          """Return True if the settings have already been configured."""
          return self._wrapped is not empty
  
      @property
      def DEFAULT_CONTENT_TYPE(self):
          stack = traceback.extract_stack()
          # Show a warning if the setting is used outside of Django.
          # Stack index: -1 this line, -2 the caller.
          filename, _line_number, _function_name, _text = stack[-2]
          if not filename.startswith(os.path.dirname(django.__file__)):
              warnings.warn(
                  DEFAULT_CONTENT_TYPE_DEPRECATED_MSG,
                  RemovedInDjango30Warning,
                  stacklevel=2,
              )
          return self.__getattr__('DEFAULT_CONTENT_TYPE')
  
      @property
      def FILE_CHARSET(self):
          stack = traceback.extract_stack()
          # Show a warning if the setting is used outside of Django.
          # Stack index: -1 this line, -2 the caller.
          filename, _line_number, _function_name, _text = stack[-2]
          if not filename.startswith(os.path.dirname(django.__file__)):
              warnings.warn(
                  FILE_CHARSET_DEPRECATED_MSG,
                  RemovedInDjango31Warning,
                  stacklevel=2,
              )
          return self.__getattr__('FILE_CHARSET')
  
  
  class Settings:
      def __init__(self, settings_module):
          # update this dict from global settings (but only for ALL_CAPS settings)
          for setting in dir(global_settings):
              if setting.isupper():
                  setattr(self, setting, getattr(global_settings, setting))
  
          # store the settings module in case someone later cares
          self.SETTINGS_MODULE = settings_module
  
          mod = importlib.import_module(self.SETTINGS_MODULE)
  
          tuple_settings = (
              "INSTALLED_APPS",
              "TEMPLATE_DIRS",
              "LOCALE_PATHS",
          )
          self._explicit_settings = set()
          for setting in dir(mod):
              if setting.isupper():
                  setting_value = getattr(mod, setting)
  
                  if (setting in tuple_settings and
                          not isinstance(setting_value, (list, tuple))):
                      raise ImproperlyConfigured("The %s setting must be a list or a tuple. " % setting)
                  setattr(self, setting, setting_value)
                  self._explicit_settings.add(setting)
  
          if not self.SECRET_KEY:
              raise ImproperlyConfigured("The SECRET_KEY setting must not be empty.")
  
          if self.is_overridden('DEFAULT_CONTENT_TYPE'):
              warnings.warn(DEFAULT_CONTENT_TYPE_DEPRECATED_MSG, RemovedInDjango30Warning)
          if self.is_overridden('FILE_CHARSET'):
              warnings.warn(FILE_CHARSET_DEPRECATED_MSG, RemovedInDjango31Warning)
  
          if hasattr(time, 'tzset') and self.TIME_ZONE:
              # When we can, attempt to validate the timezone. If we can't find
              # this file, no check happens and it's harmless.
              zoneinfo_root = Path('/usr/share/zoneinfo')
              zone_info_file = zoneinfo_root.joinpath(*self.TIME_ZONE.split('/'))
              if zoneinfo_root.exists() and not zone_info_file.exists():
                  raise ValueError("Incorrect timezone setting: %s" % self.TIME_ZONE)
              # Move the time zone info into os.environ. See ticket #2315 for why
              # we don't do this unconditionally (breaks Windows).
              os.environ['TZ'] = self.TIME_ZONE
              time.tzset()
  
      def is_overridden(self, setting):
          return setting in self._explicit_settings
  
      def __repr__(self):
          return '&lt;%(cls)s "%(settings_module)s"&gt;' % {
              'cls': self.__class__.__name__,
              'settings_module': self.SETTINGS_MODULE,
          }
  
  
  class UserSettingsHolder:
      """Holder for user configured settings."""
      # SETTINGS_MODULE doesn't make much sense in the manually configured
      # (standalone) case.
      SETTINGS_MODULE = None
  
      def __init__(self, default_settings):
          """
          Requests for configuration variables not in this class are satisfied
          from the module specified in default_settings (if possible).
          """
          self.__dict__['_deleted'] = set()
          self.default_settings = default_settings
  
      def __getattr__(self, name):
          if name in self._deleted:
              raise AttributeError
          return getattr(self.default_settings, name)
  
      def __setattr__(self, name, value):
          self._deleted.discard(name)
          if name == 'DEFAULT_CONTENT_TYPE':
              warnings.warn(DEFAULT_CONTENT_TYPE_DEPRECATED_MSG, RemovedInDjango30Warning)
          elif name == 'FILE_CHARSET':
              warnings.warn(FILE_CHARSET_DEPRECATED_MSG, RemovedInDjango31Warning)
          super().__setattr__(name, value)
  
      def __delattr__(self, name):
          self._deleted.add(name)
          if hasattr(self, name):
              super().__delattr__(name)
  
      def __dir__(self):
          return sorted(
              s for s in [*self.__dict__, *dir(self.default_settings)]
              if s not in self._deleted
          )
  
      def is_overridden(self, setting):
          deleted = (setting in self._deleted)
          set_locally = (setting in self.__dict__)
          set_on_default = getattr(self.default_settings, 'is_overridden', lambda s: False)(setting)
          return deleted or set_locally or set_on_default
  
      def __repr__(self):
          return '&lt;%(cls)s&gt;' % {
              'cls': self.__class__.__name__,
          }
  
  
  settings = LazySettings()
  </code></pre>
  
  <p>Python Console</p>
  
  <pre><code>import sys;
  ...
  ...print(sys.path)
  ['/Applications/PyCharm CE.app/Contents/plugins/python-ce/helpers/pydev', '/Applications/PyCharm CE.app/Contents/plugins/python-ce/helpers/third_party/thriftpy', '/Applications/PyCharm CE.app/Contents/plugins/python-ce/helpers/pydev', '/Library/Frameworks/Python.framework/Versions/3.7/lib/python37.zip', '/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7', '/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/lib-dynload', '/Users/apple/GoogleDrive/project_django/venv/lib/python3.7/site-packages', '/Users/apple/GoogleDrive/project_django']
  </code></pre>
  
  <p>Run/Debug Configurations in Pycharm</p>
  
  <pre><code>[ Script path ]: /Users/apple/GoogleDrive/project_django/project/manage.py
  
  [ Parameters ]:runserver
  
  [ Environment ] variables:PYTHONUNBUFFERED=1;DJANGO_SETTINGS_MODULE=project.settings_dev
  
  [ Python interpreter ]:Python 3.7(project_django) ~/GoogleDrive/project_django/venv/bin/python
  
  [ Working directory ]:/Users/apple/GoogleDrive/project_django/project
  </code></pre>
  
  <p>Development environment</p>
  
  <ul>
  <li>Mac: mojave 10.14.6</li>
  <li>Python: 3.7.5</li>
  <li>Django: 2.2.2</li>
  <li>Pycharm: 2019.3.1 (community edition)</li>
  </ul>