from django.shortcuts import render
from django.views.generic import View


def addReport(View):
    form_class = EnteringForm()
    template_name = 'report_template.html'

    def post(self, request, *args, **kwargs):
        form = self.form_class(request.POST)
        if form.is_valid():
            report_tuple = ReportModel(
                user=request.user.username,
                school=form_context.cleaned_data['school'],
                grade=form_context.cleaned_data['grade'],
                home_location=form_context.cleaned_data['home_location'],
            )
            report_tuple.save()
            form = EnteringForm()
        else:
            return HttpResponse(form_context['user'].errors)
        return render(request, self.template_name, {'form': form})

class AccountItemForm(forms.Form):
    item_type_choice = ((1, "支出"), (0, "收入"),)
    datetime = forms.DateTimeField(label="帐目日期")
    detail = forms.CharField(widget=forms.Textarea, label="帐目明细", max_length=65535)
    money = forms.DecimalField(label="单位金额", min_value=0.01, max_digits=10, decimal_places=2)
    quantity = forms.IntegerField(label="数量", min_value=1)
    account_type = forms.ChoiceField(label="帐目类型", required=True, widget=forms.Select, choices=(),)
    item_type = forms.ChoiceField(
        label="帐目操作",
        required=True,
        widget=forms.RadioSelect(renderer=RadioCustomRenderer),
        choices=item_type_choice,
        initial='1')

    def set_item_type_choices(self, request):
       //blablabla

def account_create(request):
    next_path = '/accountbook'
    if not request.user.is_authenticated():// 提前判断用户是否合法
        return message_page(request, '访问错误', '未登录，不能新建帐目。', nextpath=next_path)
    items = Account_item.objects.filter(
        user=request.user).values('detail').distinct()
    if request.method == 'POST':
        item_form = AccountItemForm(request.POST)
        item_form.set_item_type_choices(request)
        if item_form.is_valid():
            account_type_id = int(item_form.cleaned_data['account_type'])
            account_type = None
            item_type = item_form.cleaned_data['item_type']
            money = Decimal(item_form.cleaned_data['money'])
            if int(item_type) is 1:
                money = -money
            if not account_type_id is 0:
                try:
                    account_type = Account_type.objects.get(id=account_type_id)
                    # if not account_type.owner and not account_type.owner is request.user:
                    #    account_type = None
                except Account_type.DoesNotExist:
                    account_type = None
            new_item = Account_item(
                user=request.user, //看这里，save的时候直接赋值进去了
                detail=item_form.cleaned_data['detail'],
                datetime=item_form.cleaned_data['datetime'],
                money=money,
                quantity=item_form.cleaned_data['quantity'],
                account_type=account_type)
            new_item.save()
            return HttpResponseRedirect(next_path)

def(request):
    result = []
    a_list = A.objects.all()
    for a in a_list:
        b_list = B.objects..filter(B2=a)
        result.append({'a':a, 'b_list':b_list})
    return render_to_response('1.html',{'result':result})

 {% for r in result}
        {{ r.a.A1 }}
        {{ r.a.A2 }}
        {% for b in r.b_list%}
            {{ b.B1 }}
            {{ b.B2 }}
        {% endfor%}
{% endfor %}

def(request):
    a_list = A.objects.all()
    b_list = B.objects.all()
    return render_to_response('1.html',{'a_list':a_list,'b_list':b_list})

SELECT * FROM test.job;

id  job
1   开发
2   测试
3   销售

SELECT * FROM test.staff;

id  name    job_id
1   张三      1
2   李四      2
3   王五      3
4   赵六      1
5   钱七      2
6   孙八      3
7   周九      1
8   吴十      2
9   郑零      1

SELECT s1.id, s1.name, s1.job_id, j.job
FROM test.staff s1
JOIN ( SELECT job_id, COUNT(*) AS cnt
       FROM test.staff
       GROUP BY job_id
     ) s2 ON ( s2.job_id = s1.job_id )
JOIN test.job j on(j.id = s1.job_id)
ORDER BY s2.cnt DESC ,s1.id;

id  name    job_id  job
1   张三      1       开发
4   赵六      1       开发
7   周九      1       开发
9   郑零      1       开发
2   李四      2       测试
5   钱七      2       测试
8   吴十      2       测试
3   王五      3       销售
6   孙八      3       销售

select * from (
    SELECT * FROM test.sleep_news order by -date)
as Subquery group by cat_id;

results = {}
    Categories = Category.objects.all()
    for category in Categories:
        news = News.objects.filter(cat=category).order_by('-date')[0]
        results[category] = news

results = News.objects.all().order_by('cat', '-date').annotate(Count('cat'))
    items = {}
    for result in results:
        print result.cat,result.title
        if not result.cat in items:
            items[result.cat] = result

STATICFILES_FINDERS = (
    'django.contrib.staticfiles.finders.FileSystemFinder',
    'django.contrib.staticfiles.finders.AppDirectoriesFinder',
)

import time
import random
import uuid

def QuickSort(list):
    result = list
    sort_list = [[0, len(result) - 1]]
    while sort_list:
        start, end = sort_list.pop()
        if start + 1 == end:
            if result[start] > result[end]:
                result[start], result[end] = result[end], result[start]
            continue
        pivot = result[start]
        start = start
        left_list = []
        right_list = []
        for i in range(start + 1, end + 1):
            if result[i] < pivot:
                left_list.append(result[i])
            else:
                right_list.append(result[i])
        left_start = start
        left_end = left_start + len(left_list) - 1
        if left_start < left_end:
            sort_list.append([left_start, left_end])
        right_start = start + len(left_list) + 1
        right_end = right_start + len(right_list) - 1
        if right_start < right_end:
            sort_list.append([right_start, right_end])
        result = result[:start] + left_list + \
            [pivot] + right_list + result[end + 1:]
    return result

def comp(list):
    t1 = time.time()
    a1 = QuickSort(list)
    t2 = time.time()
    a2 = sorted(list)
    t3 = time.time()
    list.sort()
    a3 = list
    t4 = time.time()
    print 'quick', t2 - t1, '\t',
    print 'sorted', t3 - t2, '\t',
    print 'sort', t4 - t3,
    print a1 == a2 == a3

comp([random.random() for i in range(100000)])
comp([uuid.uuid1() for i in range(100000)])
comp([100000 - i for i in range(100000)])

quick 0.973999977112    sorted 0.00300002098083     sort 0.00300002098083 True
quick 57.228000164  sorted 0.00699996948242     sort 0.00600004196167 True
quick 13.3680000305     sorted 0.000999927520752    sort 0.0 True
[Finished in 72.0s]