django.contrib.staticfiles 从你的应用（和其他你指定的地方）收集所有静态文件到同一个地方，这样产品就能很容易的被维护
看看这里
对于静态文件的应用和一些用法示例的介绍，请参阅管理静态文件（CSS，图像） . 如果你想知道如何部署静态文件, 请参阅 部署静态文件.
查看staticfiles settings了解更多设置细节
django.contrib.staticfiles 公开三个管理命令
搜集静态文件到 STATIC_ROOT.
Duplicate file names are by default resolved in a similar way to how template resolution works: the file that is first found in one of the specified locations will be used. If you’re confused, the findstatic command can help show you which files are found.
Files are searched by using the enabled finders. The default is to look in all locations defined in STATICFILES_DIRS and in the 'static' directory of apps specified by the INSTALLED_APPS setting.
The collectstatic management command calls the post_process() method of the STATICFILES_STORAGE after each run and passes a list of paths that have been found by the management command. It also receives all command line options of collectstatic. This is used by the CachedStaticFilesStorage by default.
By default, collected files receive permissions from FILE_UPLOAD_PERMISSIONS and collected directories receive permissions from FILE_UPLOAD_DIRECTORY_PERMISSIONS. If you would like different permissions for these files and/or directories, you can subclass either of the static files storage classes and specify the file_permissions_mode and/or directory_permissions_mode parameters, respectively. For example:
from django.contrib.staticfiles import storage
class MyStaticFilesStorage(storage.StaticFilesStorage):
def __init__(self, *args, **kwargs):
kwargs['file_permissions_mode'] = 0o640
kwargs['directory_permissions_mode'] = 0o760
super(MyStaticFilesStorage, self).__init__(*args, **kwargs)
Then set the STATICFILES_STORAGE setting to 'path.to.MyStaticFilesStorage'.
The ability to override file_permissions_mode and directory_permissions_mode is new in Django 1.7. Previously the file permissions always used FILE_UPLOAD_PERMISSIONS and the directory permissions always used FILE_UPLOAD_DIRECTORY_PERMISSIONS.
Some commonly used options are:
Do NOT prompt the user for input of any kind.
Ignore files or directories matching this glob-style pattern. Use multiple times to ignore more.
Do everything except modify the filesystem.
Clear the existing files before trying to copy or link the original file.
Create a symbolic link to each file instead of copying.
Don’t call the post_process() method of the configured STATICFILES_STORAGE storage backend.
Don’t ignore the common private glob-style patterns 'CVS', '.*' and '*~'.
For a full list of options, refer to the commands own help by running:
$ python manage.py collectstatic --help
Searches for one or more relative paths with the enabled finders.
For example:
$ python manage.py findstatic css/base.css admin/js/core.js
Found 'css/base.css' here:
/home/special.polls.com/core/static/css/base.css
/home/polls.com/core/static/css/base.css
Found 'admin/js/core.js' here:
/home/polls.com/src/django/contrib/admin/media/js/core.js
By default, all matching locations are found. To only return the first match for each relative path, use the --first option:
$ python manage.py findstatic css/base.css --first
Found 'css/base.css' here:
/home/special.polls.com/core/static/css/base.css
This is a debugging aid; it’ll show you exactly which static file will be collected for a given path.
By setting the --verbosity flag to 0, you can suppress the extra output and just get the path names:
$ python manage.py findstatic css/base.css --verbosity 0
/home/special.polls.com/core/static/css/base.css
/home/polls.com/core/static/css/base.css
On the other hand, by setting the --verbosity flag to 2, you can get all the directories which were searched:
$ python manage.py findstatic css/base.css --verbosity 2
Found 'css/base.css' here:
/home/special.polls.com/core/static/css/base.css
/home/polls.com/core/static/css/base.css
Looking in the following locations:
/home/special.polls.com/core/static
/home/polls.com/core/static
/some/other/path/static
The additional output of which directories were searched was added.
Overrides the core runserver command if the staticfiles app is installed and adds automatic serving of static files and the following new options.
Use the --nostatic option to disable serving of static files with the staticfiles app entirely. This option is only available if the staticfiles app is in your project’s INSTALLED_APPS setting.
Example usage:
django-admin runserver --nostatic
Use the --insecure option to force serving of static files with the staticfiles app even if the DEBUG setting is False. By using this you acknowledge the fact that it’s grossly inefficient and probably insecure. This is only intended for local development, should never be used in production and is only available if the staticfiles app is in your project’s INSTALLED_APPS setting. runserver --insecure doesn’t work with CachedStaticFilesStorage.
Example usage:
django-admin runserver --insecure
A subclass of the FileSystemStorage storage backend that uses the STATIC_ROOT setting as the base file system location and the STATIC_URL setting respectively as the base URL.
This method is called by the collectstatic management command after each run and gets passed the local storages and paths of found files as a dictionary, as well as the command line options.
The CachedStaticFilesStorage uses this behind the scenes to replace the paths with their hashed counterparts and update the cache appropriately.
A subclass of the StaticFilesStorage storage backend which stores the file names it handles by appending the MD5 hash of the file’s content to the filename. For example, the file css/styles.css would also be saved as css/styles.55e7cbb9ba48.css.
The purpose of this storage is to keep serving the old files in case some pages still refer to those files, e.g. because they are cached by you or a 3rd party proxy server. Additionally, it’s very helpful if you want to apply far future Expires headers to the deployed files to speed up the load time for subsequent page visits.
The storage backend automatically replaces the paths found in the saved files matching other saved files with the path of the cached copy (using the post_process() method). The regular expressions used to find those paths (django.contrib.staticfiles.storage.HashedFilesMixin.patterns) by default covers the @import rule and url() statement of Cascading Style Sheets. For example, the 'css/styles.css' file with the content
@import url("../admin/css/base.css");
would be replaced by calling the url() method of the ManifestStaticFilesStorage storage backend, ultimately saving a 'css/styles.55e7cbb9ba48.css' file with the following content:
@import url("../admin/css/base.27e20196a850.css");
To enable the ManifestStaticFilesStorage you have to make sure the following requirements are met:
Since creating the MD5 hash can be a performance burden to your website during runtime, staticfiles will automatically store the mapping with hashed names for all processed files in a file called staticfiles.json. This happens once when you run the collectstatic management command.
Due to the requirement of running collectstatic, this storage typically shouldn’t be used when running tests as collectstatic isn’t run as part of the normal test setup. During testing, ensure that the STATICFILES_STORAGE setting is set to something else like 'django.contrib.staticfiles.storage.StaticFilesStorage' (the default).
The method that is used when creating the hashed name of a file. Needs to return a hash for the given file name and content. By default it calculates a MD5 hash from the content’s chunks as mentioned above. Feel free to override this method to use your own hashing algorithm.
CachedStaticFilesStorage is a similar class like the ManifestStaticFilesStorage class but uses Django’s caching framework for storing the hashed names of processed files instead of a static manifest file called staticfiles.json. This is mostly useful for situations in which you don’t have access to the file system.
If you want to override certain options of the cache backend the storage uses, simply specify a custom entry in the CACHES setting named 'staticfiles'. It falls back to using the 'default' cache backend.
Uses the configured STATICFILES_STORAGE storage to create the full URL for the given relative path, e.g.:
{% load static from staticfiles %}
<img src="{% static "images/hi.jpg" %}" alt="Hi!" />
The previous example is equal to calling the url method of an instance of STATICFILES_STORAGE with "images/hi.jpg". This is especially useful when using a non-local storage backend to deploy files as documented in Serving static files from a cloud service or CDN.
If you’d like to retrieve a static URL without displaying it, you can use a slightly different call:
{% load static from staticfiles %}
{% static "images/hi.jpg" as myphoto %}
<img src="{{ myphoto }}" alt="Hi!" />
staticfiles finders has a searched_locations attribute which is a list of directory paths in which the finders searched. Example usage:
from django.contrib.staticfiles import finders
result = finders.find('css/base.css')
searched_locations = finders.searched_locations
The searched_locations attribute was added.
There are a few other helpers outside of the staticfiles app to work with static files:
The static files tools are mostly designed to help with getting static files successfully deployed into production. This usually means a separate, dedicated static file server, which is a lot of overhead to mess with when developing locally. Thus, the staticfiles app ships with a quick and dirty helper view that you can use to serve files locally in development.
This view function serves static files in development.
Warning
This view will only work if DEBUG is True.
That’s because this view is grossly inefficient and probably insecure. This is only intended for local development, and should never be used in production.
This view will now raise an Http404 exception instead of ImproperlyConfigured when DEBUG is False.
Note
To guess the served files’ content types, this view relies on the mimetypes module from the Python standard library, which itself relies on the underlying platform’s map files. If you find that this view doesn’t return proper content types for certain files, it is most likely that the platform’s map files need to be updated. This can be achieved, for example, by installing or updating the mailcap package on a Red Hat distribution, or mime-support on a Debian distribution.
This view is automatically enabled by runserver (with a DEBUG setting set to True). To use the view with a different local development server, add the following snippet to the end of your primary URL configuration:
from django.conf import settings
from django.contrib.staticfiles import views
if settings.DEBUG:
urlpatterns += [
url(r'^static/(?P<path>.*)$', views.serve),
]
注意，模式（r'^ static /'）的开头应该是你的STATIC_URL设置。
由于这有点麻烦，还有一个帮助函数，将为你做这个：
这将返回正确的URL模式，用于将静态文件提供给已定义的模式列表。Use it like this:
from django.contrib.staticfiles.urls import staticfiles_urlpatterns
# ... the rest of your URLconf here ...
urlpatterns += staticfiles_urlpatterns()
This will inspect your STATIC_URL setting and wire up the view to serve static files accordingly. Don’t forget to set the STATICFILES_DIRS setting appropriately to let django.contrib.staticfiles know where to look for files in addition to files in app directories.
警告
只有DEBUG 设置为 True ，并且 STATIC_URL 设置不为空和完整的URL路径，比如 http://static.example.com/，这个帮助功能才会工作。
这是因为该视图 效率不高 并且很可能 不安全. 该视图仅适用于本地开发 ，而不应该用于项目实际生产环境.
This unittest TestCase subclass extends django.test.LiveServerTestCase.
就像它的父类，你可以使用它来编写测试，涉及运行测试中的代码，并使用 HTTP测试工具（例如 Selenium，PhantomJS 等），因为它需要同时发布静态素材。
But given the fact that it makes use of the django.contrib.staticfiles.views.serve() view described above, it can transparently overlay at test execution-time the assets provided by the staticfiles finders. This means you don’t need to run collectstatic before or as a part of your tests setup.
StaticLiveServerTestCase is new in Django 1.7. Previously its functionality was provided by django.test.LiveServerTestCase.
May 13, 2015