Day47 Django基础部分、路由配置、空间名称

最新推荐文章于 2025-09-08 09:22:18 发布
最新推荐文章于 2025-09-08 09:22:18 发布
阅读量87 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： python 开发工具
原文链接：http://www.cnblogs.com/longerandergou/p/11128027.html
本文详细解析了Django中的路由配置原理，包括基本路由、正则路由、分组路由、反向解析、命名空间和视图层的request对象。通过实例讲解如何配置路由，处理不同类型的URL参数，以及如何使用反向解析和命名空间避免路由冲突。

1.最简单的路由配置

URL配置(URLconf)就像Django 所支撑网站的目录。它的本质是URL与要为该URL调用的视图函数之间的映射表；你就是以这种方式告诉Django，对于客户端发来的某个URL调用哪一段逻辑代码对应执行。

 1.1

例1：

 

第一步：在

urls.py中写入

urlpatterns = [
    path('admin/',  admin.site.urls),
    path('articles/', views.articles),
]

 

在views.py中写入给请求返回的response对象

def articles(request):
    print("文章页")
    return HttpResponse("文章页")

 

 小结：上面这种是最基本的，不带url后面不带任何参数的。

1.2 path方法把url写死了

urls.py中写入

path("articles/2009/", views.articles),

 

访问变成了：

原来的articles/没有用了，路由信息的改变。

 

 1.3re_path

#  为了解决path上面把url写死，用re_path

目的：减少代码冗余，用正则来写

# articles中需要一个接受参数
# 在urls.py文件中写，其中artcles函数需要一个接受参数
re_path("^articles/([0-9]{4})/$", views.articles1), # 无名分组 
　小结；需要在views函数中写一个形参，才能接受
([0-9]{4})/$匹配出来的参数
 # 于是在views中加入一个参数。
def articles(request, y):
   print("文章页")
   return HttpResponse("文章页")
 运行结果如下：

小结：这样就可以实现的多个url的输入，满足正则即可。
# articles中需要2个接受参数
# urls中的代码：
 re_path(r"^articles/([0-9]{4})/([0-9]{2})/$", views.articles), # 无名分组按位置传参数，articles后面的参数依次传给views 中的articles函数
# views中的代码：
def articles(request, y,m):
   print("文章页", y, m)
   return HttpResponse("文章页")

 pycharm中控制台打印出的代码：

# 即是获取到了/articles/后面的 /2019/12/等2个参数

 

## 注意^ 和$ 的使用

 1.4 URl和re_path如果要匹配正则规则都需要使用^和$来卡，path内部限制死了的(必须完全匹配)

 1.5

1. path 内部封装好了,自动限制首尾的规则
2. url   没有封装,需要自己手动添加正则规则(同re_path方法)
# 在url前后加上参数都是可以访问的 /dsdarticles/ 可以访问  /articles/sdad 可以访问 如果要卡的话 需要自己写上正则来匹配
# path内部前后都卡死了的，
其中re_path 和url是一样的

urls中的代码：

url('articles/', views.articles_url),
views中的代码：（上面的2种情况都是没有参数的 哈哈）
def articles_url(request):
   print("文章页")
   return HttpResponse("文章页")

 

1.6无名分组见上面

按位置传参

1.7 有名分组(按关键字传参)

##（1）传入一个参数给views中函数/2019

url.py代码：

re_path("^articles/(?P<year>[0-9]{4})/$", views.articles1),  # 有名分组
views中的函数：
处理接受到的url的函数：articles1：
def articles1(request, year):
   print("文章页111", year)
   return HttpResponse("文章页1111")

##（1）处理客户端url中的参数是2个的，参数传参是关键字传参。

urls.py文件中代码：

re_path(r"^articles/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/$", views.articles),
#得出url传给articles中的参数是2个 都是关键字传参 在函数articles中必须写上month和year才行。
views中代码：
def articles(request, month, year):
   print("文章页面", year, month)
   return HttpResponse("文章页")

 1.8

说白了，就是客户，各种输入你内部就行，接受判断并返回。客户输入的形式/articles/参数/参数 我们需要在内部就行处理，接受参数（有名分组合(关键字传参必须是在url中定义的参数，

在views中对应的函数中的参数)无名分组(按形参顺序就行传参，对应在views中的函数中的参数，可以随便取名，接受就行)）  

小结：针对1.1-1.8的路由层面的

1.url和re_path差不多，内部没有限制，可以在前面加参数或者后面加参数就行访问，但是只能每次在项目下URls下添加路由，有点麻烦。

2.解决1的麻烦就是在url和re_path中使用正则表达式，可以在访问/articles/.... 前面不变的情况下 增加更多的参数的  上面介绍了加1中参数和2中参数到我们视图处理函数views中，对应接受就行。

 # 上面的URl中的路由信息全部写在了主项目中url中：

 3.不足的地方：每次都需要在主项目的urls中去写上路由的配置信息，有点繁琐，不利于维护。

解决办法：在每一个app中建立url，在主项目下的url创建分组，从主文件向下app的url中找即可。

 2.路由分发

 在上图的主项目的url中写上上面的路由分发。

然后对应在app01的url写上真的路由信息：

 

然后对应在app01的url写上真的路由信息：(同下)

 在app02的URls中写上真的路由信息：(只是在主项目的文件下url中就行查找，是哪个下对应的url路由信息，不至于不像之前没有分组的时候那么乱，全部写在一起，只需要在主文件的URl写上最上面的那个信息即可)

# 类似于在广东省下面去找深圳市是一样的道路

views中的代码：

def test(request):
   return HttpResponse('app02-test')

 

 3.反向解析

3.1例子：暂时还没有用反向解析

在app01 url.py中的代码是：

from django.urls import path, re_path
from app01 import views

urlpatterns = [
    path('test/', views.test),
    path('articles/', views.articles_url),
    path('login/', views.login, name="login"),
    path('index/', views.index) # 当登录成功 重定向跳转index 也必须配置在这个下面


]

 

app01中的views的代码是：

def login(request):
    if request.method == "GET":
        return render(request, "login.html")
    else:
        username = request.POST.get('username')
        pwd = request.POST.get('pwd')
        if username == "alex" and pwd == "123":
            return redirect("/app01/index/")
        else:
      
            return redirect('app01/login')


def index(request):
    return HttpResponse("<h2>index页面</h2>")

 

在主项目文件夹下的模板文件夹的文件是 login.html是：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h3>用户登录</h3>
<form action="/app01/login/" method="post">
    <p>用户名：<input type="text" name="username"></p>
    <p>密码: <input type="password" name="pwd"></p>
    <input type="submit">
</form>

</body>
</html>
运行结果：登录成功 成功跳转！

 

3.2 使用反向解析

 3.2.1 

 path('login/', views.login, name="login"), 个人觉得还是改的是设计login的地方 没啥卵用！
分析：首先我们将这个路由不改动的时候，
第一步：我们是先去解析出路由ulr，本句是没使用正则的，即是
第二步：我们是去在视图函数的login，处理一些用户需要的逻辑，首先，本句是登录，根据函数中的逻辑去调用temprate 中的登录模板的，然后，再次提交数据的时候，会调用index，完成本次访问。
也就是Django内部的一个执行流程。
小结：即是变动的时候，我们去改语句中对应的视图函数，和对应用到的模板2个地方即可。

 



当去修改'login/' 为'login2/'会导致很多地方都会修改！所以这个时候会利用到别名啦！
注意：用户实际登录的时候还是使用的是login2去登录，反向解析只是让内部少做变动。(1)模板中的文件login.html需要改动（2）视图函数中的login改动
在template下修改login.html文件为：
只需在上面的基础上修改第一行为：<form action="{% url 'login' %}" method="post">
其中一旦url中配置文件一改变，模板文件中的temptate下的login.html 和views视图下的文件也需要跟着去改：具体改法如下：
重点1：修改模板temprate中的文件 login.html


运行代码：




 


根据视图函数login可以知道第一次确实是得到页面。


重点2：（反向解析改动的第二个地方，视图函数）
 




# view中的函数
def login(request):
    if request.method == "GET":
        return render(request, "login.html")
    else:
        username = request.POST.get('username')
        pwd = request.POST.get('pwd')
        if username == "alex" and pwd == "123":
            return redirect("/app01/index/")
        else:
        
            # return redirect('app01/login') 不改动的时候
            print(reverse('login'))
            return redirect(reverse('login'))### 改为这样，他会自己根据url中login的变动而变动
运行结果是：
把下面的视图函数中的


print(reverse('login'))打印出来的值是：





 再试一次：


先改url中的名字：






 哈哈 按照逻辑是不会打印的是：成功是：


index那个页面跳转成功！




 


登录失败看看：




 




 


 3.3 在反向解析的基础上就行传递参数


3.3.1 无名参数


第一：在app下的url中代码：




urlpatterns = [
    re_path(r'^login/([0-9]{2})/$', views.login, name="login"),
    path('index/', views.index)


]
小结：即是用户传递的进来的是2位数的参数。




 


第二：


temprate下的form表单就行修改，在反向解析的前提下：


感觉就是随意放一个参数在后面，不多深究




第三：


视图view中的加参数：


1.相关的login函数是必须加的“




2.在跳转的地方加上参数




def login(request, pk):
    if request.method == "GET":
        return render(request, "login.html")
    else:
        username = request.POST.get('username')
        pwd = request.POST.get('pwd')
        if username == "alex" and pwd == "123":
            return redirect("/app01/index/")
        else:
            print(reverse('login', args=(10,)))  # 无名分组

            return redirect(reverse('login', args=(10,)))  # 位置传参
运行代码：必然要输入错误的密码才会打印。


问题：个人觉得反向定位的这个地方 表单位置 根本不用加12 感觉就是乱加的没啥依据 后续看看！




 


3.3.2有名参数在方向解析的基础上


 第一：在app01下的url的代码是：




urlpatterns = [
    
    # path('login3/', views.login, name="login"),# 没有参数的时候
    # re_path(r'^login/([0-9]{2})/$', views.login, name="login"),无名分组 顺序传参
    # 有名分组 关键字传参
    re_path(r'^login/(?P<m>[0-9]{2})/$', views.login, name="login"),
    path('index/', views.index)


]




 


 


第二：


temprate下的form表单就行修改，在反向解析的前提下：


感觉就是随意放一个参数在后面，不多深究




{#<form action="/app01/login/" method="post">#}# 无名分组时候用的
<form action="{% url 'login' m=12 %}" method="post"># 有名分组时候用




 


第三： 


 


视图view中的加参数：


1.相关的login函数是必须加的（这次有名分组传递的是一个参数）




2.看下视图函数中的全部代码：




def login(request, m):
    if request.method == "GET":
        return render(request, "login.html")
    else:
        username = request.POST.get('username')
        pwd = request.POST.get('pwd')
        if username == "alex" and pwd == "123":
            return redirect("/app01/index/")
        else:
            # print(reverse('login', args=(10,)))  # 无名分组
            print(reverse('login', kwargs={"m":"07"}))   # 有名分组
            # return redirect(reverse('login', args=(10,)))  # 位置传参
            return redirect(reverse('login', kwargs={"m":"07"}))  # 关键字传参
            # return redirect(reverse('app01:login')) # 加上名称空间写法
            # return redirect('app01/login') 不改动的时候
            # 没有分组 即是没有参数的情况
            # print(reverse('login'))
            # 这个也也是没有使用分组的情况 但是设计login 反正url路由将其名字改掉使用反向解析
            # 也就是验证那句话 哪里需要用的到地方都需要改数据，只能说使用反向解析去改的话，可以一劳永益，改一次之后
            # 无论你在路由怎么改写login1到login 这里都是使用的路由对应url中的别名，嘿嘿！
            # return redirect(reverse('login'))




 


运行结果：以登录失败的方式进去：结果看样子就是对的！ 有名关键字传参成功




 


 总结：


上面的例子中只是在外面套了一层重定向即是再次就行一次跳转而已。


上面登录失败，再次登录页面出现。




## 上面的例子中 登录失败可以是
#return redirect(reverse('login')) # 防止url中访问的地址改名，反向解析，并跳转，至重新登录
 return redirect(reverse('login', kwargs={"m":"07"}))  # ，反向解析基础上加上关键字传参，最后重定向至重新登录
 # return redirect(reverse('login', args=(10,)))  # 反向解析加上位置传参，最后重定向至重新登录




 


登录成功：


  return redirect("/app01/index/")




反向解析大致：
1.定义name 别名
path('login1/', views.login, name="login"),
2.在视图中反向解析
from django.urls import reverse

reverse("login")

无名分组
re_path(r'^login1/([0-9]{2})/$', views.login, name="login"),
reverse("login", args=("12",))

有名分组
re_path(r'^login1/(?P<month>[0-9]{2})/$', views.login, name="login"),
reverse("login", kwargs={"month": "12"})
3.在模板中使用反向解析
path方法(url)# 不使用参数的时候
<form action="{% url 'login' %}" method="post">
    
re_path(无名分组)
<form action="{% url 'login' 12 %}" method="post">
    
re_path(有名分组)
<form action="{% url 'login' month=12 %}" method="post">




 4.名称空间


4.1 例子


1.新建一个app02


第一：app02中的url代码：




from django.urls import path, re_path
from app02 import views

urlpatterns = [
    path('test/', views.test),
    path('login/', views.login, name="login"),
]




 


第二：app02 中的视图(view中的代码)




def login(request):
    if request.method == "GET":
        return render(request, "login1.html")
    else:
        # print(request.POST)
        print(request.body)
        username = request.POST.get('username')
        pwd = request.POST.get('pwd')
        if username == "alex" and pwd == "123":
            return redirect("/app02/test/")
        else:
            # print(reverse('login', args=(10,)))  # 无名分组
            # print(reverse('login', kwargs={"m":"07"}))   # 有名分组
            # return redirect(reverse('login', args=(10,)))
            # return redirect(reverse('login', kwargs={"m":"07"}))
            return redirect(reverse('app02:login'))




 


第三：同时建立temprate中的模板代码：




运行：app01/login1/代码发现：串了，可以在总项目的URl的配置下可以看到：




如果是访问各个app下的相同的url 下的login1会发现后面把前面覆盖了。


运行结果：


如下 发现登录的是login1窗口弹出的是app02的确实app01的访问的url被覆盖了。




 解决办法：名称空间


 4.2 加命名空间


1.为了出现上面在各个不同的app应用取相同的名字的：


只有加上命名空间：


第一步：


在总项目的url下面加一个：




 path('app01/', include(("app01.urls", "app01"))),  # 加上名称空间app01
    # path('app02/', include("app02.urls")),  # 普通的路由分发
    path('app02/', include(("app02.urls", "app02"))),  # 加上名称空间app02
注意：include 里面是一个元祖不是一个字符串
注意普通的路由分发的写法是：


path('app01/', include("app01.urls"）),  # 普通的路由分发
path('app02/', include("app02.urls")),  # 普通的路由分发


 小结：即是上面的的写法是名称空间加上普通路由分发的结合写法。




 


 第二步：修改视图函数中login中的值：(在对应的app的login函数中，重定向返回函数的时候加上)




def login(request):
    if request.method == "GET":
        return render(request, "login1.html")
    else:
        # print(request.POST)
        print(request.body)
        username = request.POST.get('username')
        pwd = request.POST.get('pwd')
        if username == "alex" and pwd == "123":
            return redirect("/app02/test/")
        else:
            # print(reverse('login', args=(10,)))  # 无名分组
            # print(reverse('login', kwargs={"m":"07"}))   # 有名分组
            # return redirect(reverse('login', args=(10,)))
            # return redirect(reverse('login', kwargs={"m":"07"}))
            # return redirect(reverse('login')) 普通的反向解析
            # 在反向解析的基础上加上名称空间写法
            return redirect(reverse('app02:login'))




 


 


 第三步：在模板中修改一下：




在普通的反向解析版本的基础上加上，<form action="{% url 'app01:login' %}">这个，。妈妈再也不用担心，其他的app项目设置的访问rul和我重名啦！


这样的话，访问app01  中login1：




访问app02 中login1：






总结：
1.名称空间
 定义名称空间
path('app01/', include(("app01.urls", "app01"))),
path('app02/', include(("app02.urls", "app02"))),

在conf.py源码的44行 
namespace = namespace or app_name

2.使用名称空间
 在视图中
reverse('app01:login')
在模板中
<form action="{% url 'app01:login' %}" method="post">




 


5. 视图层


 1.request对象


1.1 reqeust对象的属性：


  • GET(***)


1. GET  QueryDict  响应头的内容(url后的参数)
2. 获取一个值  request.GET.get("name")
3. 获取多个值 request .GET.getlist("name")  # 返回值为list




 


  • POST(***)
  • QueryDict 响应体里的内容
  • body
  • 原生请求体的内容
  • path (***)
  • 返回当前请求的路径(url)
  • method(***)
  • 返回当前请求的请求方式
2.1reqeust对象的方法


  • get_full_path()
  • 获取当前请求的完整路径(包含参数,不包含锚点)
  • is_ajax()
  • 判断当前请求是否是ajax请求.返回值为布尔值
2.HTTPResponse对象(响应三剑客)


2.1HTTPResponse


直接返回字符串,响应体里面的内容


2.2 render




返回一个模板文件

第一个参数 request

第二个参数 模板文件(login.html)

第三个参数(可选) 模板需要渲染的值




 


2.3 redirect


　　重定向




 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


 


转载于:https://www.cnblogs.com/longerandergou/p/11128027.html

                

        




    

    
  



    



                



	

		

			

				
					
Django框架 - 路由配置全解

				
			

			

				

					qq_42694871的博客
				

				

					07-07
					
					873
					
				

			

		

		

			
				
Django框架：路由配置全解，包括路由分发、正则匹配、自定义path转换器、附加参数等。

			
		

	



                

            
              



	

		

			

				
					
Django之路由配置

				
			

			

				

					DD1852的博客
				

				

					08-15
					
					2034
					
				

			

		

		

			
				
Django

			
		

	



              


  
              

                


	

		

			

				
					
Django（5）-路由配置实例

				
			

			

				

					redrose2100的博客
				

				

					05-30
					
					7919
					
				

			

		

		

			
				
1、路由配置函数path详解

path（route，views，name=None）,path有三个参数含义如下：

route：字符串类型，匹配的请求路径
views：指定路径所对应的视图处理函数的名称
name：为地址起别名，在模板中地址反向解析时使用



2、path转换器

语法：<转换器类型:自定义名>
作用：若转换器类型匹配到对应类型的数据，则将数据按照关键字传参的方式传递视图函数
例子：patb(‘page/int:page’,views.xxx)，将page参数对应的值传递给

			
		

	





	

		

			

				
					
【Django5】路由的定义与使用

				
			

			

				

					sishihao的博客
				

				

					07-11
					
					1649
					
				

			

		

		

			
				
一个完整的路由包含:路由地址、视图函数（或者视图类)、可选变量和路由命名。路由称为URL (Uniform Resource Locator，统一资源定位符），也可以称为URLconf，是对可以从互联网上得到的资源位置和访问方法的一种简洁的表示，是互联网上标准资源的地址。互联网上的每个文件都有一个唯一的路由，用于指出网站文件的路径位置。简单地说，路由可视为我们常说的网址，每个网址代表不同的网页。

			
		

	



		

			
		



	

		

			

				
					
day02-djangoURL路由配置

				
			

			

				

					ajaonfpas的博客
				

				

					03-02
					
					808
					
				

			

		

		

			
				
Django如何处理一个请求
介绍：
一个干净优雅的URL方案是高质量Web应用程序中的一个重要细节。
Django可以让你自己设计URL，无论你想要什么，没有框架限制。
要为应用程序设计URL，您可以非正式的创建一个名为URLconf（URL配置）的Python模块。
这个模块是纯Python模块，是一个简单的python模式（简单的正则表达式）到Python函数（您的视图）之间的映射。
1.创建项目
在项目目录创建项目结构并启动
PS E:\Pycharm project> django-admi

			
		

	





	

		

			

				
					
Day 57 django 路由系统 反向解析

				
			

			

				

					Tao.的博客
				

				

					09-01
					
					583
					
				

			

		

		

			
				
django
路由匹配
反向解析

			
		

	





	

		

			

				
					
【python】Django系列Day02--Django项目配置文件和路由

				
			

			

				

					weixin_53000329的博客
				

				

					05-01
					
					1673
					
				

			

		

		

			
				
🙋作者：爱编程的小贤
⛳知识点:Django–配置和路由
🥇：每天学一点，早日成大佬

			
		

	





	

		

			

				
					
【Django基础03】_路由配置和App路由分发

				
			

			

				

					清平乐的技术专栏
				

				

					04-26
					
					688
					
				

			

		

		

			
				
django项目在创建成功后，默认在工程目录下会自带url.py文件，我们知道视图响应的过程包括：浏览器中发送请求 → urls路由匹配 → 视图响应 → 回馈到浏览器。
当存在多个APP应用时，这样的弊端就是当有多个app应用的时候都需要在项目工程目录中配置，并可能会影响到其他app。本节我们主要讲解对各个app的url进行单独配置的方法。
简言之：让app自己管理自己的路由，防止建立多个app...

			
		

	





	

		

			

				
					
day  53  Django基础二之URL路由系统

				
			

			

				

					deng6648的博客
				

				

					05-23
					
					88
					
				

			

		

		

			
				
Django基础二之URL路由系统





本节目录



一 URL配置
二 正则表达式详解
三 分组命名匹配
四 命名URL（别名）和URL反向解析
五 命名空间模式





一 URL配置

　　
Django 1.11版本 URLConf官方文档
　　URL配置(URLconf)就像Django ...

			
		

	





	

		

			

				
					
Day10Django后台.rar

				
			

			

				

					08-21
				

			

		

		

			
				
9. **URL路由**：Django使用URLconfs（URL配置）将URL映射到视图，这是构建Web应用的关键部分，包括后台系统的URL。  10. **表单和数据验证**：Django的表单系统允许你创建表单并进行数据验证，这对于后台管理系统中...

			
		

	





	

		

			

				
					
【TXT】用 Python 实现超漂亮的 HTML 两栏文本对比工具（支持行内差异高亮）

				
			

			

				

					采菊东篱下，Python满乾坤！
				

				

					09-05
					
					1319
					
				

			

		

		

			
				
这个小工具虽然只有 300 多行代码，但却融合了文本处理、算法匹配、前端渲染和用户体验设计。它不仅实用，还能作为学习difflib和 HTML/CSS 布局的优秀范例。✅一句话总结：让文本对比不再枯燥，让差异“看得见”！也欢迎在评论区提出你的优化想法 😊。

			
		

	





	

		

			

				
					
torch神经网络入门级设备测试

				
			

			

				

					m0_71002812的博客
				

				

					09-07
					
					1296
					
				

			

		

		

			
				
本文介绍了一个基于PyTorch的CPU与GPU性能评估系统，用于比较不同硬件在求解常微分方程(ODE)的神经网络模型中的计算效率。系统包含以下核心功能： 自动检测CUDA可用性及GPU配置 构建多层前馈神经网络模型求解二阶ODE 性能基准测试：分别在CPU/GPU上运行相同训练任务，计算加速比 内存使用分析：对比CPU/GPU张量的内存占用情况 梯度计算专项测试：评估反向传播耗时差异 评估结果显示，在处理大规模数据(≥5000个数据点)时，GPU凭借并行计算优势可获得显著加速效果。系统适用于科研人员优化物

			
		

	





	

		

			

				
					
AI驱动的软件测试：革命性的自动化、缺陷检测与实验优化

				
			

			

				

					zzywxc787的博客
				

				

					09-06
					
					703
					
				

			

		

		

			
				
人工智能（AI）和机器学习（ML）技术的融入，正在从根本上重塑软件测试的格局，将其从一种主要是手动的、重复性的任务转变为一种智能的、预测性的、且持续优化的过程。*说明：多臂老虎机算法（MAB）由于将更多流量分配给了更好的版本B，其累积回报（点击次数）的增长速度远快于传统A/B测试（固定50/50分流）。： 利用NLP技术（如文本分类）自动分析新提交的Bug报告的内容、标题和描述，将其自动分类（如“前端UI问题”、“后端API错误”），并推荐或分配给最合适的开发人员（基于谁修改了相关代码文件）。

			
		

	





	

		

			

				
					
LeetCode Hot 100 Python (71~80)

					
最新发布

				
			

			

				

					朝花夕拾。
				

				

					09-08
					
					700
					
				

			

		

		

			
				
LeetCode Hot 100 第71~80题的Python实现

			
		

	





	

		

			

				
					
Python实现生成矩形、三角形、六边形和圆形点云

				
			

			

				

					不枯石的学习笔记
				

				

					09-06
					
					844
					
				

			

		

		

			
				
本文介绍了使用Python生成规则几何形状点云的方法，包括矩形、三角形、六边形和圆形。主要内容包括：1）基本步骤概述，涵盖参数定义、采样、噪声添加和可视化；2）四种几何形状的具体生成算法和示例代码；3）应用场景分析，如工业检测、机器人导航和虚拟现实；4）综合程序实现，通过Tkinter界面实现点云生成与可视化。文中详细说明了每种形状的采样算法（如重心坐标法、极坐标采样）和实现细节，并提供了完整的Python代码示例。该内容为三维点云处理的基础技术，适用于计算机视觉、机器人学等领域的研究和开发。

			
		

	





	

		

			

				
					
Python爬虫实战：研究Animation模块，构建京东平台电商数据采集和分析系统

				
			

			

				

					ylfhpy的博客
				

				

					09-05
					
					250
					
				

			

		

		

			
				
matplotlib 作为 Python 生态中成熟的可视化库，其 Animation 模块支持动态图表生成，可实现数据的实时动态展示。将爬虫技术与动态可视化结合，构建 "数据获取 - 处理 - 动态展示" 的完整闭环，对提升数据分析效率具有重要实践价值。而动态可视化技术通过连续帧画面展示数据变化轨迹，能更直观地揭示数据背后的规律，如商品价格波动、用户行为趋势等。第三梯队：vivo（3000-3400 元）、小米（2700-3100 元）、荣耀（2500-2900 元）

			
		

	





	

		

			

				
					
字符串左旋-三种解法

				
			

			

				

					xnyxy2431366813的博客
				

				

					09-08
					
					351
					
				

			

		

		

			
				
实现一个函数，可以左旋字符串中的k个字符。例如：ABCD左旋一个字符得到BCDAABCD左旋两个字符得到CDAB先算出字符串str的长度len。左旋k次，k可能大于len，当左旋len * n（n为整数）次时，左旋后的字符串与原来的字符串相同。为避免重复左旋，可使k对len取余。

			
		

	





	

		

			

				
					
Django URL路由基础与处理机制详解

				
			

			

				

					
				

			

		

		

			
				
总结来说，Django路由控制是构建动态网站的重要部分，它通过定义URL模式、视图函数和错误处理机制，实现了高效且灵活的请求处理。理解和掌握路由规则对于开发高效、易于维护的Web应用至关重要。

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值