Django之web本质
Django之web本质
Web的本质，是基于socket玩的。
在我们上网的过程中，一个访问请求是如何工作的。
Web的框架：
网络的连接都是基于Socket
在连接中有TCP/UDP 和HTTP协议
HTTP协议是：无状态，短连接。（HTTP协议的访问状态是发送请求连接一次，返回请求结果数据一次，就断开连接）
无状态体现在同样的请求者第二次发请求来，服务端不认识它。
TCP：不断开，安全，不丢包，慢
UDP：易丢包，快
Web的工作流程：
浏览器端（Socket客户端）
2、域名或DNS正反解析出的IP，在浏览器中输入。
在socket端创建Socket对象
Socket.socket()
在创建连接
Socket.connet(("IP",端口))
在发送连接请求
socket.send("我想请求数据") 5、接收响应的数据
6、连接断开，完成一个HTTP请求
网站服务端（Socket服务端）
1、监听自己网站的IP和域名，while 循环监听
while True:
等待用户连接
3、接收用户的连接请求("我想请求数据")
4、响应用户的连接，给用户返回响应的数据("好")
断开连接，等待下一个用户的连接请求
socket的服务端：
web的最本质最基本简化的流程。
import socket Socket = socket.socket()
# 创建Socket对象 Socket.bind(("127.0.0.1",8080))
# 绑定IP和端口 Socket.listen(5)
# 监听等待5个连接 while True:
conn, addr = Socket.accept()
# 在这hold住，等待用户发送的请求，有人来连接，获取用户的发送数据 data = conn.recv(8096)
# 获取数据 print(data)
# 打印一下data的获取数据的结果 conn.send(b'HTTP/1.1 200 OK \r\n\r\n')
# 响应头 conn.send(b'')
# 响应的返回数据，响应体 conn.close()
# 断开连接
HTTP协议：发送的数据和响应的数据是有相互的规则的，规则遵循HTTP协议。
发送（Request）：
GET请求：
GET请求头：
数据在请求头的url中。在GET / /HTTP1.1 的第一个/后，也就是请求体(请求体Request Bodys) GET / HTTP/1.1
Host: 127.0.0.1:8080
Connection: keep-alive
Cache-Control: max-age=0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.89 Safari/537.36
HTTPS: 1
Accept-Encoding: gzip, deflate, sdch
Accept-Language: zh-CN,zh;q=0.8
Cookie: csrftoken=hNmu2JOtntGMN0hSRSPmMQk2newEb3o8zb6pXW5Cc3m54IaA5VlTkUvqWsFezpni 请求体部分
GET请求体：数据在url中。
GET的请求体在GET / HTTP/1.1中的第一个 "/" 后。
例如：
GET /index?p=123 HTTP/1.1
其中，index是url，这没错，but，p=123就是请求体。
POST请求：
POST请求头：
POST /index HTTP/1.1
Host: 127.0.0.1:8080
Connection: keep-alive
Cache-Control: max-age=0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.89 Safari/537.36
HTTPS: 1
Accept-Encoding: gzip, deflate, sdch
Accept-Language: zh-CN,zh;q=0.8
Cookie: csrftoken=hNmu2JOtntGMN0hSRSPmMQk2newEb3o8zb6pXW5Cc3m54IaA5VlTkUvqWsFezpni 请求体部分
POST请求体：
POST /index HTTP/1.1
Host: 127.0.0.1:8080
Connection: keep-alive
Cache-Control: max-age=0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.89 Safari/537.36
HTTPS: 1
Accept-Encoding: gzip, deflate, sdch
Accept-Language: zh-CN,zh;q=0.8
Cookie: csrftoken=hNmu2JOtntGMN0hSRSPmMQk2newEb3o8zb6pXW5Cc3m54IaA5VlTkUvqWsFezpni p=123 #POST请求体内容
响应（Response）：
响应头：
在响应体中，要注意一个Status Code的状态码，应为200 OK 响应头是在Response Headers中。 响应头的数据：
Cache-Control:public, max-age=15
Connection:keep-alive
Content-Encoding:gzip
Content-Type:text/html; charset=utf-8
Date:Wed, 14 Jun 2017 01:21:17 GMT
Expires:Wed, 14 Jun 2017 01:21:33 GMT
Last-Modified:Wed, 14 Jun 2017 01:21:03 GMT
Transfer-Encoding:chunked
Vary:Accept-Encoding
X-Frame-Options:SAMEORIGIN
X-UA-Compatible:IE=10
响应体：就是看到的前端页面，页面效果是浏览器解析的而已的啦。
优化socket服务端流程，丰富功能：MK2
分化url，不同的url，显示不同的内容。
import socket Socket = socket.socket()
# 创建Socket对象
Socket.bind(("127.0.0.1",8080))
# 绑定IP和端口
Socket.listen(5)
# 监听的次数
while True:
#监听循环
conn, addr = Socket.accept()
# 在这hold住，等待用户发送的请求，有人来连接，获取用户的发送数据
data = conn.recv(8096)
# 获取数据
print(data)
#打印拿到的请求数据
data = str(data,encoding="utf-8")
#将data的数据类型，由byte类型转换成str类型。并编码为utf-8。
Headers,Bodys = data.split("\r\n\r\n")
#将data数据用split以"\r\n\r\n"分割成请求头和请求体
temp_list = Headers.split("\r\n")
#将请求头以“\r\n”分割，并且可以单独处理 [0] 的GET第一行，因为第一条的写法不同
method,url,protocal = temp_list[0].split(" ")
#将temp_list的 [0] 的内容分给请求方式，url和协议，以空格分开。url是请求的url
conn.send(b'HTTP/1.1 200 OK \r\n\r\n')
# 响应头
if url == "/XXX":
conn.send(b"asfafafas")
elif url == "/BBB":
conn.send(b"qqqqqq")
else:
conn.send(b"404 not found")
conn.close()
在获取的用户数据后，转换成数据类型，比如字符串，操作如下：
data拿到的一般都是字节byte类型的数据
data = str(data,encoding = "utf-8")
即可将byte的数据类型，直接转换成字符串str的数据类型。
在拿取请求头是，是根据\r\n 来分割开请求头和请求体的。
headers,bodys = data.split("\r\n\r\n")
#这样可以将请求头和请求体分来。
#在请求头中在进行分割：
headers.split("\r\n")
对请求头再进一步的分割，可以将headers放在列表里，进行操作。这个的url是请求的url
temp_list = Headers.split("\r\n")
#将Headers放进列表
#在对请求头的第一行数据进行单独的操作，因为第一行数据不同。
#GET / /HTTP1.1\n
#定义GET为method，/后的请求体为url，是请求的url，/HTTP是协议protocal
method,url,protocal = temp_list[0].split(" ")
#根据空格分割。
MK3，将url抽离出，可单独操作每一个url。
# Socket服务端
import socket def index(request):
return b'index' def func2(request):
return b'func2' # 定义一个列表，里面存有url和url对应的函数名
Routers = [
("/index",index), #url 为XXX时，执行func1函数
("/SSS",func2), #url 为SSS时，执行func2函数
] def run():
"""
Socket服务端响应
:return:
"""
Socket = socket.socket()
# 创建Socket对象
Socket.bind(("127.0.0.1",8080))
# 绑定IP和端口
Socket.listen(5)
# 监听的次数
while True:
#监听循环
conn, addr = Socket.accept()
# 在这hold住，等待用户发送的请求，有人来连接，获取用户的发送数据
data = conn.recv(8096)
# 获取数据
print(data)
#打印拿到的请求数据
data = str(data,encoding="utf-8")
#将data的数据类型，由byte类型转换成str类型。并编码为utf-8。
Headers,Bodys = data.split("\r\n\r\n")
#将data数据用split以"\r\n\r\n"分割成请求头和请求体
temp_list = Headers.split("\r\n")
#将请求头以“\r\n”分割，并且可以单独处理 [0] 的GET第一行，因为第一条的写法不同
method,url,protocal = temp_list[0].split(" ")
#将temp_list的 [0] 的内容分给请求方式，url和协议，以空格分开。url是请求的url
conn.send(b'HTTP/1.1 200 OK \r\n\r\n')
# 响应头
func_name = None
#定义一个func_name，用于赋值item的func函数
for item in Routers:
#循环遍历Routers列表里的url。
if item[0] == url:
#取出url进行判断
func_name = item[1]
#如果匹配到func指定的函数
break
if func_name:
#如果func_name=True，存在，就拿func_name 的值
response = func_name(data)
else:
response = b"404 Not Found"
conn.send(response)
#发送Response的值给作为响应体
conn.close() if __name__ == "__main__":
run()
结果：
--->
--->
MK4 优化函数的功能，丰富页面的内容：静态网站
index页面：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>index</title>
</head>
<body>
<h1>Login</h1>
<form>
<p><input type="text" placeholder="Username"></p>
<p><input type="password" placeholder="Password"></p>
</form>
</body>
</html>
func2页面：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>article</title>
</head>
<body>
<table border='1'>
<thead>
<tr>
<th>ID</th>
<th>Username</th>
<th>Email</th>
</tr>
</thead>
<tbody>
<tr>
<th>0001</th>
<th>George</th>
<th>George@G.com</th>
</tr>
</tbody>
</table>
</body>
</html>
socket端代码：
# Socket服务端
import socket def index(request):
"""
处理用户请求，并返回响应数据
:param request: 用户请求的所有信息
:return:
"""
f = open("index.html","rb")
data = f.read()
f.close()
return data def func2(request):
"""
处理用户请求，并返回响应数据
:param request: 用户请求的所有信息
:return:
"""
f = open("article.html","rb")
data = f.read()
f.close()
return data # 定义一个列表，里面存有url和url对应的函数名
Routers = [
("/index",index), #url 为XXX时，执行func1函数
("/SSS",func2), #url 为SSS时，执行func2函数
] def run():
"""
Socket服务端响应
:return:
"""
Socket = socket.socket()
# 创建Socket对象
Socket.bind(("127.0.0.1",8080))
# 绑定IP和端口
Socket.listen(5)
# 监听的次数
while True:
#监听循环
conn, addr = Socket.accept()
# 在这hold住，等待用户发送的请求，有人来连接，获取用户的发送数据
data = conn.recv(8096)
# 获取数据
print(data)
#打印拿到的请求数据
data = str(data,encoding="utf-8")
#将data的数据类型，由byte类型转换成str类型。并编码为utf-8。
Headers,Bodys = data.split("\r\n\r\n")
#将data数据用split以"\r\n\r\n"分割成请求头和请求体
temp_list = Headers.split("\r\n")
#将请求头以“\r\n”分割，并且可以单独处理 [0] 的GET第一行，因为第一条的写法不同
method,url,protocal = temp_list[0].split(" ")
#将temp_list的 [0] 的内容分给请求方式，url和协议，以空格分开。url是请求的url
conn.send(b'HTTP/1.1 200 OK \r\n\r\n')
# 响应头
func_name = None
#定义一个func_name，用于赋值item的func函数
for item in Routers:
#循环遍历Routers列表里的url。
if item[0] == url:
#取出url进行判断
func_name = item[1]
#如果匹配到func指定的函数
break
if func_name:
#如果func_name=True，存在，就拿func_name 的值
response = func_name(data)
else:
response = b"404 Not Found"
conn.send(response)
#发送Response的值给作为响应体
conn.close() if __name__ == "__main__":
run()
结果：
---》
-->
MK5 静态变动态。简单动态。
以func2函数演示，获取系统时间，以实现动态效果。
socket端，重点在func2函数：
# Socket服务端
import socket def index(request):
"""
处理用户请求，并返回响应数据
:param request: 用户请求的所有信息
:return:
"""
f = open("index.html","rb")
data = f.read()
f.close()
return data def func2(request):
"""
处理用户请求，并返回响应数据
:param request: 用户请求的所有信息
:return:
"""
f = open("article.html","r")
data = f.read()
f.close()
import time
#导入时间模块
ctime = time.time()
#获取当期时间
data = data.replace("@@sw@@",str(ctime))
#将当期时间与前端的标签位进行替换
return bytes(data,encoding="utf-8") # 定义一个列表，里面存有url和url对应的函数名
Routers = [
("/index",index), #url 为XXX时，执行func1函数
("/SSS",func2), #url 为SSS时，执行func2函数
] def run():
"""
Socket服务端响应
:return:
"""
Socket = socket.socket()
# 创建Socket对象
Socket.bind(("127.0.0.1",8080))
# 绑定IP和端口
Socket.listen(5)
# 监听的次数
while True:
#监听循环
conn, addr = Socket.accept()
# 在这hold住，等待用户发送的请求，有人来连接，获取用户的发送数据
data = conn.recv(8096)
# 获取数据
print(data)
#打印拿到的请求数据
data = str(data,encoding="utf-8")
#将data的数据类型，由byte类型转换成str类型。并编码为utf-8。
Headers,Bodys = data.split("\r\n\r\n")
#将data数据用split以"\r\n\r\n"分割成请求头和请求体
temp_list = Headers.split("\r\n")
#将请求头以“\r\n”分割，并且可以单独处理 [0] 的GET第一行，因为第一条的写法不同
method,url,protocal = temp_list[0].split(" ")
#将temp_list的 [0] 的内容分给请求方式，url和协议，以空格分开。url是请求的url
conn.send(b'HTTP/1.1 200 OK \r\n\r\n')
# 响应头
func_name = None
#定义一个func_name，用于赋值item的func函数
for item in Routers:
#循环遍历Routers列表里的url。
if item[0] == url:
#取出url进行判断
func_name = item[1]
#如果匹配到func指定的函数
break
if func_name:
#如果func_name=True，存在，就拿func_name 的值
response = func_name(data)
else:
response = b"404 Not Found"
conn.send(response)
#发送Response的值给作为响应体
conn.close() if __name__ == "__main__":
run()
func2的页面：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>article</title>
</head>
<body>
<table border="">
<thead>
<tr>
<th>ID</th>
<th>Username</th>
<th>Email</th>
</tr>
</thead>
<tbody>
<tr>
<th>0001</th>
<th>@@sw@@</th>
<th>George@G.com</th>
</tr>
</tbody>
</table>
</body>
</html>
结果：
MK6，动态获取数据改为数据库获取。
重点在func3函数，要链接数据库。
socket端：
# Socket服务端
import socket def index(request):
"""
处理用户请求，并返回响应数据
:param request: 用户请求的所有信息
:return:
"""
f = open("index.html","rb")
data = f.read()
f.close()
return data def func2(request):
"""
处理用户请求，并返回响应数据
:param request: 用户请求的所有信息
:return:
"""
f = open("article.html","r")
data = f.read()
f.close()
import time
#导入时间模块
ctime = time.time()
#获取当期时间
data = data.replace("@@sw@@",str(ctime))
#将当期时间与前端的标签位进行替换
return bytes(data,encoding="utf-8") def func3(request):
"""
处理用户请求，并返回响应数据
:param request: 用户请求的所有信息
:return:
"""
import pymysql
conn = pymysql.connect(host = '127.0.0.1',port=3306,user="root",password="密码",db="数据库名")
#创建连接
cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)
#创建游标
effect_row = cursor.execute("select id,name,password from user")
#执行SQL语句，并返回结果
userlist = cursor.fetchall()
#拿到的所有数据
cursor.close()
#关闭游标
conn.close()
#关闭连接
print(userlist)
#打印user_list字典
"""
将user_list拼接成如下的字符串,将字典的每一个值对应发给每一个标签
[
{id,name,password}
{id,...}
{id,...}
] <tr>
<td>%s</td> #id
<td>%s</td> #name
<td>%s</td> #password
</tr>
"""
content_list = []
for row in userlist:
#每一个row都是一行数据
tp = '<tr><td>%s</td><td>%s</td><td>%s</td></tr>' %(row['id'],row['name'],row['password'])
#字符串拼接
content_list.append(tp)
content = "".join(content_list)
f = open("user_list.html", "r",encoding='utf-8')
template = f.read()
f.close()
#模块的渲染，
data = template.replace('@@XXXXX@@',content)
return bytes(data, encoding="utf-8") # 定义一个列表，里面存有url和url对应的函数名
Routers = [
("/index",index), #url 为XXX时，执行func1函数
("/SSS",func2), #url 为SSS时，执行func2函数
("/hhh",func3), #url 为hhh时，执行func3函数
] def run():
"""
Socket服务端响应
:return:
"""
Socket = socket.socket()
# 创建Socket对象
Socket.bind(("127.0.0.1",8080))
# 绑定IP和端口
Socket.listen(5)
# 监听的次数
while True:
#监听循环
conn, addr = Socket.accept()
# 在这hold住，等待用户发送的请求，有人来连接，获取用户的发送数据
data = conn.recv(8096)
# 获取数据
print(data)
#打印拿到的请求数据
data = str(data,encoding="utf-8")
#将data的数据类型，由byte类型转换成str类型。并编码为utf-8。
Headers,Bodys = data.split("\r\n\r\n")
#将data数据用split以"\r\n\r\n"分割成请求头和请求体
temp_list = Headers.split("\r\n")
#将请求头以“\r\n”分割，并且可以单独处理 [0] 的GET第一行，因为第一条的写法不同
method,url,protocal = temp_list[0].split(" ")
#将temp_list的 [0] 的内容分给请求方式，url和协议，以空格分开。url是请求的url
conn.send(b'HTTP/1.1 200 OK \r\n\r\n')
# 响应头
func_name = None
#定义一个func_name，用于赋值item的func函数
for item in Routers:
#循环遍历Routers列表里的url。
if item[0] == url:
#取出url进行判断
func_name = item[1]
#如果匹配到func指定的函数
break
if func_name:
#如果func_name=True，存在，就拿func_name 的值
response = func_name(data)
else:
response = b"404 Not Found"
conn.send(response)
#发送Response的值给作为响应体
conn.close() if __name__ == "__main__":
run()
use_list.html 函数3的页面：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>user_list</title>
</head>
<body>
<table border="">
<thead>
<tr>
<th>ID</th>
<th>Username</th>
<th>Email</th>
</tr>
</thead>
<tbody>
@@XXXXX@@
</tbody>
</table>
</body>
</html>
结果： 更改数据库name栏数据，图中username栏的数据会跟随变化。
MK7 优化函数func3中处理的繁琐字符串 ：做模板渲染的 jinja2 模块。
重点func4函数：
func4函数的页面：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>func4</title>
</head>
<body>
<table border="">
<thead>
<tr>
<th>ID</th>
<th>用户名</th>
<th>邮箱</th>
</tr>
</thead>
<tbody>
{% for row in xxxxx %}
<tr>
<td>{{row.id}}</td>
<td>{{row.name}}</td>
<td>{{row.password}}</td>
</tr>
{% endfor %}
</tbody>
</table>
{{user}}
</body>
</html>
socket端：
# Socket服务端
import socket def index(request):
"""
处理用户请求，并返回响应数据
:param request: 用户请求的所有信息
:return:
"""
f = open("index.html","rb")
data = f.read()
f.close()
return data def func2(request):
"""
处理用户请求，并返回响应数据
:param request: 用户请求的所有信息
:return:
"""
f = open("article.html","r")
data = f.read()
f.close()
import time
#导入时间模块
ctime = time.time()
#获取当期时间
data = data.replace("@@sw@@",str(ctime))
#将当期时间与前端的标签位进行替换
return bytes(data,encoding="utf-8") def func3(request):
"""
处理用户请求，并返回响应数据
:param request: 用户请求的所有信息
:return:
"""
import pymysql
conn = pymysql.connect(host = '127.0.0.1',port=3306,user="root",password="密码",db="数据库名")
#创建连接
cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)
#创建游标
effect_row = cursor.execute("select id,name,password from user")
#执行SQL语句，并返回结果
userlist = cursor.fetchall()
#拿到的所有数据
cursor.close()
#关闭游标
conn.close()
#关闭连接
print(userlist)
#打印user_list字典
"""
将user_list拼接成如下的字符串,将字典的每一个值对应发给每一个标签
[
{id,name,password}
{id,...}
{id,...}
] <tr>
<td>%s</td> #id
<td>%s</td> #name
<td>%s</td> #password
</tr>
"""
content_list = []
for row in userlist:
#每一个row都是一行数据
tp = '<tr><td>%s</td><td>%s</td><td>%s</td></tr>' %(row['id'],row['name'],row['password'])
#字符串拼接
content_list.append(tp)
content = "".join(content_list)
f = open("user_list.html", "r",encoding='utf-8')
template = f.read()
f.close()
#模块的渲染，
data = template.replace('@@XXXXX@@',content)
return bytes(data, encoding="utf-8") def func4(request):
"""
处理用户请求，并返回响应数据
:param request: 用户请求的所有信息
:return:
"""
import pymysql
conn = pymysql.connect(host='127.0.0.1', port=3306, user="root", password="redhat", db="GeorgeTest")
# 创建连接
cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)
# 创建游标
effect_row = cursor.execute("select id,name,password from user")
# 执行SQL语句，并返回结果
userlist = cursor.fetchall()
# 拿到的所有数据
cursor.close()
# 关闭游标
conn.close()
# 关闭连接
f = open('func4.html','r',encoding='utf-8')
data = f.read()
f.close() # 基于第三方工具实现的模板渲染
from jinja2 import Template
template = Template(data)
data = template.render(xxxxx=userlist,name='fadfasdfa')
return data.encode('utf-8') # 定义一个列表，里面存有url和url对应的函数名
Routers = [
("/index",index), #url 为XXX时，执行func1函数
("/SSS",func2), #url 为SSS时，执行func2函数
("/hhh",func3), #url 为hhh时，执行func3函数
("/func4",func4), #url 为func4时，执行func4函数
] def run():
"""
Socket服务端响应
:return:
"""
Socket = socket.socket()
# 创建Socket对象
Socket.bind(("127.0.0.1",8080))
# 绑定IP和端口
Socket.listen(5)
# 监听的次数
while True:
#监听循环
conn, addr = Socket.accept()
# 在这hold住，等待用户发送的请求，有人来连接，获取用户的发送数据
data = conn.recv(8096)
# 获取数据
print(data)
#打印拿到的请求数据
data = str(data,encoding="utf-8")
#将data的数据类型，由byte类型转换成str类型。并编码为utf-8。
Headers,Bodys = data.split("\r\n\r\n")
#将data数据用split以"\r\n\r\n"分割成请求头和请求体
temp_list = Headers.split("\r\n")
#将请求头以“\r\n”分割，并且可以单独处理 [0] 的GET第一行，因为第一条的写法不同
method,url,protocal = temp_list[0].split(" ")
#将temp_list的 [0] 的内容分给请求方式，url和协议，以空格分开。url是请求的url
conn.send(b'HTTP/1.1 200 OK \r\n\r\n')
# 响应头
func_name = None
#定义一个func_name，用于赋值item的func函数
for item in Routers:
#循环遍历Routers列表里的url。
if item[0] == url:
#取出url进行判断
func_name = item[1]
#如果匹配到func指定的函数
break
if func_name:
#如果func_name=True，存在，就拿func_name 的值
response = func_name(data)
else:
response = b"404 Not Found"
conn.send(response)
#发送Response的值给作为响应体
conn.close() if __name__ == "__main__":
run()
结果：
------ END ------
Django之web本质的更多相关文章
- Web框架本质及第一个Django实例 Web框架
Web框架本质及第一个Django实例 Web框架本质 我们可以这样理解:所有的Web应用本质上就是一个socket服务端,而用户的浏览器就是一个socket客户端. 这样我们就可以自己实现Web ...
- [Python] 利用Django进行Web开发系列（一）
1 写在前面 在没有接触互联网这个行业的时候,我就一直很好奇网站是怎么构建的.现在虽然从事互联网相关的工作,但是也一直没有接触过Web开发之类的东西,但是兴趣终归还是要有的,而且是需要自己动手去实践的 ...
- [Python] 利用Django进行Web开发系列（二）
1 编写第一个静态页面——Hello world页面 在上一篇博客<[Python] 利用Django进行Web开发系列(一)>中,我们创建了自己的目录mysite. Step1:创建视图 ...
- 利用Django进行Web开发
Web就是用来表示Internet主机上供外界访问的资源的.网页也统称为web资源.Internet上供外界访问的Web资源主要分为如下两类: 静态web资源:指web页面中供人们浏览的数据始终是不变 ...
- Django学习---Web框架及基础知识
Django学习---Web框架 web框架的本质 我们在学socket,我们创建一个socketserver,然后运行起来,有一个client客户端要连接socket服务端,连接上之后,如果两边都没 ...
- Django之web框架和url路由
一.web框架 1.什么是web框架 Web框架是用来进行Web应用开发的一个软件架构,开发者在基于Web框架实现自己的业务逻辑.Web应用本质上就是一个socket服务端,而用户的浏览器就是一个so ...
- http协议和web本质
转载:http://www.cnblogs.com/dinglang/archive/2012/02/11/2346430.html http协议和web本质 当你在浏览器地址栏敲入“http://w ...
- http协言和web本质
http协议和web本质 作为一个开发者,尤其是web开发人员,我想你有必要去了解这一系列的处理流程,在这期间,浏览器和服务器到底是如何打交道的?服务器又是如何处理的?浏览器又是如何将网页显示给用户的 ...
- Nginx+Python+uwsgi+Django的web开发环境安装及配置
Nginx+Python+uwsgi+Django的web开发环境安装及配置 nginx安装 nginx的安装这里就略过了... python安装 通常系统已经自带了,这里也略过 uwsgi安装 官网 ...
随机推荐
- CentOS服务器下安装配置SSL
https是一个安全的访问方式,数据在传输过程中是加密的,https基于SSL. 一.安装apache和ssl模块 1.安装apache #yum install httpd 2.安装ssl模块 #y ...
- iOS NSUserDefaults [setValue:forKey:] [setObject:forKey:] <Objc> setValue(_,forKey:) set(_,forKey) <Swift 3>
前者其实是NSObject都可以调用的KVC方法,后者才是NSUserDefaults的实例方法: 这里参数的类型是nullable id,但是我建议你在传null的时候慎重考虑,否则你的应用就可能面 ...
- PHP常见的输出语句 echo()、print()、print_r()、var_dump()、pinrtf()之间的区别
echo().print().print_r().var_dump().pinrtf()之间的区别 1.print() :简单输出语句,可以输出字符串,变量.表达式等单项的值!(不能输出数组.对象等复 ...
- 当不知道基本数据类型的取值范围时，可以通过max_value等来查询
public class Demo03{ public static void main(String[] args){ System.out.println("int MAX " ...
- 转 python 将一个文件中内容添加到另一个文件指定位置
http://blog.csdn.net/huguangshanse00/article/details/14624601
- req.getParameter()无法获取参数（附前端json序列化）
问题:前端用Ajax的post方式想servlet传递参数,servlet的getParameter()方法无法获取参数. 前端代码: $.ajax({ url: '/TestWeb/addBook' ...
- qconbeijing2016
http://2016.qconbeijing.com/schedule 大会日程 2016年04月21日 星期四 09:15 开场致辞 地点 1号厅 主题演讲 工程效率提升 业务核心架构 容器集 ...
- Masonry自动布局与UIScrolView适配
Masonry介绍 Masonry是一个轻量级的布局框架 拥有自己的描述语法 采用更优雅的链式语法封装自动布局 简洁明了 并具有高可读性 而且同时支持 iOS 和 Max OS X.可以通过cocoa ...
- CF778A(round 402 div.2 D) String Game
题意: Little Nastya has a hobby, she likes to remove some letters from word, to obtain another word. B ...
- 日常博客----rem,em的恩怨相杀
基本知识: 使用 em 和 rem 单位可以让我们的设计更加灵活,能够控制元素整体放大缩小,而不是固定大小. 我们可以使用这种灵活性,使我们在开发期间,能更加快速灵活的调整,允许浏览器用户调整浏览器大 ...