一、函数
1.为什么要使用函数？
减少代码的冗余
2.函数先定义后使用（相当于变量一样先定义后使用）
3.函数的分类：
内置函数：python解释器自带的，直接拿来用就行了
自定义函数：根据自己的需求自己定义的函数
def func(): #函数名打印出来的是内存地址
'''注释'''
函数体
4.函数定义都干了些什么事？
只检测语法，不执行代码
5.函数就是一段功能，尽量把函数名定义的有意义
6.定义函数的三种方式：
有参数的函数：就是接受外部传进来的值，进行一系列的运算，最后吧结果返回出来
无参数的函数：通常只是做一下操作而已
空函数：什么事情都不做就是一个空函数（即便是一个空函数，他也会有如下属性）
7.函数的返回值：可返回任意类型的值
什么时候需要有返回值：具体情况具体分析
什么时候没有返回值：具体情况具体分析
8.yield和return的区别
yield 停在那呢，挂起了
yield 能返回多次值;return 返回一次值
yield 保存函数状态
9.函数的调用：函数名加()
10.函数参数
形参：定义函数时括号内写的参数
形参在定义阶段是不占内存空间的，在调用的时候才占用内存空间
实参:在调用函数时括号内传进来的值
函数参数的具体用法
1.位置参数：
1.按照位置传参
按位置定义的形参必须要传值
按位置定义的实参按照位置与形参一一对应的传
2.按照关键字传数：按照key=value的形式定义的实参，传的时候与位置没有关系
def foo(x,y):
pass
foo(1,2) #与形参一一对应
foo(y=2,x=1) #关键字参数，指名道姓的传
foo(1,y=2) #混用位置实参和关键字实参
#混着用时：注意：1.不能给同一个形参重复赋值
2.位置实参必须在关键字实参的前面
2.默认参数：在定义阶段就已经为形参赋值了，意味着在调用阶段就可以不为默认参数传值
如果给默认参数传值了，就把一开始设置的给替换了。
默认参数定义的场景：大多数都是男性，女性很少时就可以设置个默认，当然还有其他场景
注意：1.默认参数必须在位置形参后面
2.默认参数的值只在函数定义阶段生效一次，定义之后的修改不会影响它的值
3.默认参数不要弄成可变类型的，就像是列表，就是一个坑
3.动态参数
可变长度的参数（长度指的是参数的个数）:参数*,**
1.*会把多出来的值传给z,并且以元组的形式返回
2.**会把多出来的值传给z,并且以字典的形式返回
3.在实参中只要碰到*()，就是打散了
只要是可迭代的就可以用*
*就相当于for循环的操作，遇到*先打散
*args,**kwargs（可传任意值）
可变长度的参数：从实参的角度推算出形参对应的形式*和**
针对按照位置定义的实参多出来的那部分，会被形参中的*处理，并且保存成元组的形式复制给args
针对按照关键字定义的实参多出来的那部分，会被形参中的**处理，并且保存成字典的形式复制给kwargs
1 # 1.举例一、
2 def foo(x,y,*args):
3 print(x,y)
4 print(args)#args相当于(3, 4, 5, 6, 7, 8, 9)，那么*args相当于*(3, 4, 5, 6, 7, 8, 9)
5 print(args[0])
6 print(*args) # 加个*就是把上面的元组给打散了，就还是和原来传实参的时候的形式一样了
7
8 foo(1,2,3,4,5,6,7,8,9)
9 foo(1,2,3,*(4,5,6,7,8,9)) #也可以这样传 就相当于foo(1,2,3,4,5,6,7,8,9)
10
11 # 2.举例二、
12 def bar(x,y,z):
13 print(x,y,z)
14 bar(1,2,3)
15 bar(*['b','a','c']) #bar('b','a','c')
16 bar(*'hel') #bar('h','e','l')
17 bar(*{'a':1,'b':2,'c':3}) #bar('b','a','c')
18 # 强调：如果实参中出现了*和**，第一时间打散了去看
19
20 # 3.举例三、
21 def foo(x,y,**kwargs):
22 print(x,y)
23 print(kwargs) #{'c': 3, 'd': 4, 'f': 6} 吧多余的元素以字典的形式返回了
24 print(*kwargs) #输出c d f ，就是把字典打散了
25 #
26 # foo(1,y=2,c=3,d=4,f=6)
27
28 # 4.举例四、
29 def index(x,y,z=1):
30 print(x,y,z)
31 def wrapper(*args,**kwargs):
32 index(args,kwargs)
33 index(*args, **kwargs) #就是打散了
34 wrapper(1,2,3)
35 wrapper(1,2)
36 wrapper(x=1,y=2)
37 wrapper(1,y=2)
38 '''可变长度的参数：从实参的角度推算出形参对应的形式 * 和 **
39 针对按照位置定义的实参冗余的部分，会被形参中的 * 保存成元组的形式赋值给args
40 针对按照关键定义的实参冗余的部分，会被形参中的 ** 保存成字典的形式赋值给kwargs
41 强调：
42 如果实参中出现了 * 和 **，第一时间打散了去看。
43 '''
强调：
如果实参中出现了*和**，第一时间打散了去看
11.命名关键字参数（了解）:在定义阶段，在*之后定义的形参称为命名关键字参数
特点是：在调用阶段，该参数必须以关键字的形式被传值
def foo(x,y,*,a,b):
print(x)
print(y)
print(a)
print(b)
foo(1,2,b=20,a=10)
控制函数调用的时候必须以关键字传参的时候就用命名关键字传参。
一、函数和方法的区别
1、函数要手动传self，方法不用传
2、如果是一个函数，用类名去调用，如果是一个额方法，用对象去调用
举例说明：
class Foo(object):
def __init__(self):
self.name="haiyan"
def func(self):
print(self.name)
obj = Foo()
obj.func()
Foo.func(obj)
判断函数和方法的方式
from types import FunctionType,MethodType obj = Foo() print(isinstance(obj.func,FunctionType)) #False print(isinstance(obj.func,MethodType)) #True #说明这是一个方法 print(isinstance(Foo.func,FunctionType)) #True #说明这是一个函数。 print(isinstance(Foo.func,MethodType)) #False
二、js和jquery绑定事件的几种方式
三、创建表的一个limit_choices_to参数
limit_choices_to：屏蔽某些选项，只显示某些指定的选项。例如下面的，只让显示部门id是1001的
consultant = models.ForeignKey(verbose_name="课程顾问", to='UserInfo', related_name='consultant',limit_choices_to={'depart_id':1001})
四、include和inclusion_tag的区别
这两个都是处理代码冗余的，由于其他的页面也会有这样的功能，也要用到，我们可以吧它摘出来，在创建个文件夹写进去。导入进来
如果用include，这里面的数据得从后端传， 如果用inclusion_tag，你返回啥就会帮我们传啥，它既有自己的功能，也有include的功能，又可以处理数据
include的使用
<body>
<h3>添加页面</h3>
{% include "stark/form.html" %}
{#<form action="">#}
{# {{ form }}#}
{#</form>#}
#include导入的相当于下面注释的form表单的内容
inclusion_tag的使用
1、创建一个templatetags的文件夹，在里面创建一个change_form.py的文件，在里面写代码，需要加上
@register.inclusion_tag这个装饰器
#!usr/bin/env python
# -*- coding:utf-8 -*-
from django.template import Library
from django.urls import reverse
from stark.service.v1 import site
register = Library()
@register.inclusion_tag("stark/form.html")
def form(model_form_obj):
from django.forms import ModelChoiceField
from django.forms.boundfield import BoundField # 数据都封装在这个类了
new_form = []
for bfield in model_form_obj:
dic = {"is_popup": False, "item": bfield} # 每一个bfield就是Form的字段，是一个对象
if isinstance(bfield.field, ModelChoiceField):
# print(bfield.field,"popup按钮")
print(bfield, type(bfield)) # <class 'django.forms.boundfield.BoundField'>
releated_model_name = bfield.field.queryset.model # 找到关联的类名
app_model_name = releated_model_name._meta.app_label, releated_model_name._meta.model_name # 找到应用名和类名（目的是拼接url）
base_url = reverse("stark:%s_%s_add" % (app_model_name))
popup_url = "%s?_popupbackid=%s" % (base_url, bfield.auto_id) #每一个input框的id
print(bfield.auto_id,"111111")
dic["is_popup"] = True
dic["popup_url"] = popup_url
new_form.append(dic)
return {"form":new_form} #返回的这个form是给了"stark/form.html"它里面的form,然后循环遍历
3、使用
{% load change_form %}
<body>
<h3>编辑页面</h3>
{% form form %}
</body>
4、stark/form.html
<form method="post" class="form-horizontal" novalidate>
{% csrf_token %}
{% for dic in form %}
<div class="col-sm-6">
<div class="form-group">
<label for="inputEmail3" class="col-sm-2 control-label">{{ dic.item.label }}</label>
<div class="col-sm-10" style="position: relative">
{{ dic.item }}
{% if dic.is_popup %}
<div style="position: absolute;right: -5px;top: 8px;z-index: 9999">
<a onclick="popUp('{{ dic.popup_url }}')" class="glyphicon glyphicon-plus"></a> <!--注意要加引号，不然就会被当成变量了-->
</div>
{# 判断如果是MOdelChoicesField是Fk#}
{# 判断如果是MOdelChoicesField是Fk#}
{% endif %}
{{ dic.item.errors.0 }}
</div>
</div>
</div>
{% endfor %}
<div class="col-sm-offset-11 col-sm-1">
<input type="submit" class="btn btn-primary" value="提交">
</div>
</form>
<script>
function popupCallback(data) {
var op = document.createElement("option");
op.value = data.id;
op.text = data.text;
op.setAttribute("selected","selected");
document.getElementById(data.popupbackid).appendChild(op)
}
function popUp(url) {
var popupPage = window.open(url, url, "status=1, height:500, 600, toolbar=0, resizeable=0");
}
</script>