PythonGuides-博客中文翻译-三-
PythonGuides 博客中文翻译（三）
Django 从 POST 请求中获取所有数据
原文：https://pythonguides.com/django-get-all-data-from-post-request/
在这个 Python Django 教程中，我将解释如何通过各种方式从 Python Django 中的 POST 请求中获取数据。我将借助一些例子来说明这一点。
- 如何在 Django 中获取 POST 请求数据
- Django 将发布数据传递给视图
- Django post 请求示例
- Django 获取发布数据列表
- Django 将 POST 数据作为字典获取
- Django 将数据发布到数据库
目录
- 如何在 Django 中获取 POST 请求数据
- Django 将发布数据传递给视图
- Django post 请求示例
- Django 获取帖子数据列表
- Django 以字典的形式获取 POST 数据
- Django 将数据发布到数据库
如何在 Django 中获取 POST 请求数据
当 Django 服务器收到 POST 请求时，可以使用 HTTPRequest 检索请求中的数据。贴字典。POST 请求主体的所有数据都存储在这个字典中。
例如，您可以在 view.py 文件中使用以下代码片段。
def index(request):
if request.method == 'POST'
var = request.POST[<parameter name>]
假设上面的索引函数处理 POST 请求，一个参数值被存储在名为 var 的变量中。
之后，您可以在任何代码或模板中使用该值，或者将它存储在数据库中。
Django 将发布数据传递给视图
创建 HTML 表单时，需要发送 POST 请求时，可以指定要发布的方法类型。
表单中定义的输入字段将数据传递给重定向的 URL。您可以在 urls.py 文件中定义此 URL。在这个 URLs 文件中，您可以定义在视图中创建的函数，并按照上面的方法访问 POST 数据。
你只需要使用 HTTPRequest。获取发布数据的发布对象。让我们借助一个例子来理解这一点。
阅读使用 Python 中的 Django 将 HTML 页面转换为 PDF
Django post 请求示例
我创建了一个名为index.html的 Django 模板，包含两个输入字段。我将在这些输入字段中输入数据，并在另一个 Django 模板中呈现它。名为 index.html的 Django 模板的源代码是:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Demo</title>
</head>
<body>
<form action="validate" method="post">
{% csrf_token %}
Username : <input type="text" name="user" ><br><br>
Password : <input type="text" name = "pass"><br><br>
<input type="submit" value="Submit">
</form>
</body>
</html>
正如您在上面的代码中看到的，表单被重定向到一个名为 validate 的 URL 端点。我们必须在 urls.py 文件中定义这个 URL 端点。在我的例子中，urls.py 文件是:
from django.contrib import admin
from django.urls import path
from . import views
urlpatterns = [
path('admin/', admin.site.urls),
path('', views.index, name = 'index'),
path('validate', views.validate, name = 'validate')
]
使用上面定义的路径，当向指定的 URL 端点发出请求时， views.py 文件中名为 validate 的函数将被执行。让我们来看看的观点. py 文件:
# importing the necessary libraries
from django.http import HttpResponse
from django.shortcuts import render
def index(request):
return render(request, 'index.html')
def validate(request):
if request.method == 'POST':
username= request.POST["user"]
password = request.POST["pass"]
dict = {
'username': username,
'password': password
}
return render(request, 'validate.html', dict)
在 validate 函数中，首先我们验证请求方法是否是 POST。然后我们获取 POST 请求值。之后，我们在另一个名为 validate.html的 Django 模板中呈现这些值。
在validate.html文件中，我们将访问这些值并将其呈现为:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Login</title>
</head>
<body>
<p>Username is :{{username}}</p>
<p>Password is: {{password}}</p>
</body>
</html>
现在让我们打开第一个网页，即 index.html，并在文本框中输入一些值。
Submitting the values and sending a POST request
点击提交会将我们重定向到 validate.html页面，在那里我们可以看到我们的渲染值。
Rendering the POST request parameters in another template
因此，您可能已经理解了如何在 Django 中传递和检索 POST 请求参数。
阅读如何从 Django 中的 get 请求获取数据
Django 获取帖子数据列表
有时，您可能希望将参数作为列表从 HTML 表单传递到服务器。例如，您可能希望通过 HTML 页面中的复选框传递一组值。
在这种情况下，您必须为所有复选框指定相同的名称，并使用 HTTPRequest 检索这些控件的列表。POST.getlist() 函数。例如，看看下面的 HTML 页面:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Demo</title>
</head>
<body>
<form action="validate" method="post">
{% csrf_token %}
<input type="checkbox" id="hobby1" name="hobby" value="swimming">
<label for="hobby1"> I like swimming</label><br>
<input type="checkbox" id="hobby2" name="hobby" value="running">
<label for="vehicle2"> I like running</label><br>
<input type="checkbox" id="hobby3" name="hobby" value="Cycling">
<label for="vehicle3"> I like Cycling</label><br>
<input type="submit" value="Submit">
</form>
</body>
</html>
上面的 HTML 页面使用 POST 请求通过一个表单向 Django 服务器提交一个爱好列表。
当用户点击提交按钮时，会向端点' /validate '发出一个请求。现在，我们必须将这个端点与我们的 urls.py 文件中的函数进行映射，如下所示:
from django.contrib import admin
from django.urls import path
from . import views
urlpatterns = [
path('admin/', admin.site.urls),
path('', views.index, name = 'index'),
path('validate', views.validate, name = 'validate')
在 views.py 文件中，我们将使用 HTTPRequest。POST.getlist() 函数从 POST 请求中检索值列表。
记住在这个函数中指定 HTML 控件的名称作为列表。例如，我在我的 HTML 页面中为所有复选框使用了名称 hobby 。在检索值列表时，我将在 getlist()函数中指定名称为 hobby[] ，如下所示:
# importing the necessary libraries
from django.http import HttpResponse
from django.shortcuts import render
def index(request):
return render(request, 'index.html')
def validate(request):
if request.method == 'POST':
hobbies = request.POST.getlist('hobby[]')
return render(request, 'validate.html', {'hobbies':hobbies})
我在名为validate.html的 Django 模板中使用了一个循环来呈现值列表，如下所示:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Login</title>
</head>
<body>
<ol><p style="font-size: x-large;">Your hobbies are:<p>
{%for hobby in hobbies %}
<li style="font-size: large;">{{hobby}}</li>
{% endfor %}
</ol>
</body>
</html>
现在让我们看看输出。让我们启动我们的服务器:
Submitting values as a list
点击提交将把我们重定向到下一页。
Retrieved the parameters as a list
您可以看到输出中呈现了值列表。
这样，您可以从 HTML 页面传递一个值列表，并在 Django 应用程序中检索它。
Django 以字典的形式获取 POST 数据
当您通过 POST 请求向 Django 应用程序提交数据或参数时，这些参数以类 QueryDict 的类似字典的对象的形式存储。
这个对象是一个类似字典的对象，也就是说，你可以使用字典对象的几乎所有功能。有关 QueryDict 类的更多信息，可以阅读 Django 官方文档。
让我给你看一个例子，在这里我将演示这个对象如何是一个类似字典的对象。我已经创建了一个示例注册页面，其源代码是:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Login Page</title>
</head>
<body>
<form action="registered" method="post">
{% csrf_token %}
First Name <input type="text" name ="fn" placeholder="Enter Your First Name" ><br><br>
Last Name <input type="text" name ="ln" placeholder="Enter Your Last Name" ><br><br>
Email <input type="email" name ="email"placeholder="Enter Your Email address" ><br><br>
Password <input type="password" name ="password" placeholder="Enter Your Password" ><br><br>
<input type="submit" value="Submit">
</form>
</body>
</html>
单击 submit 按钮会将用户重定向到名为“registered”的端点。我已经用我的 urls.py 文件中的函数映射了这个端点，如下所示:
from django.contrib import admin
from django.urls import path
from . import views
urlpatterns = [
path('admin/', admin.site.urls),
path('', views.index, name = 'index'),
path('registered', views.registered, name= 'registered')
]
现在让我们来看看将在 views.py 文件中执行的函数:
# importing the necessary libraries
from django.shortcuts import render
def index(request):
return render(request, 'index.html')
def registered(request):
data = request.POST.items()
return render(request, 'registered.html', {'data':data})
在这里，您可以看到我正在检索参数，并将它们呈现在另一个 Django 模板中。我们将使用 for 循环在模板中检索 QueryDict 对象:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Login</title>
</head>
<body>
{% for keys, values in data %}
<li>{{keys}} : {{values}}</li>
{% endfor %}
</body>
</html>
现在让我们看看输出。让我们启动服务器并访问根目录。
Passing the POST parameters
现在让我们点击提交按钮，看看结果。
Rendering the parameter values
在这里，您可以看到所有参数值都已呈现，包括我们从注册表单发送的 CSRF 令牌。
由读取 Python Django 组
Django 将数据发布到数据库
在本节中，您将学习如何将来自 POST 请求的数据存储到数据库中。对于本教程，我将使用 SQLite 数据库，即 Django 提供的默认数据库。
要在 Django 中与数据库交互，您必须创建模型。要了解更多关于模型和如何创建模型的信息，你可以阅读我们关于如何在 Django 中创建模型的文章。
- 首先，我们将创建一个 HTML 表单，从这里我们将发送我们的 POST 数据到 Django 应用程序，比如文件名
index.html。我们将把这个文件存储在 Django 项目的模板文件夹中。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Login Page</title>
</head>
<body>
<form action="registered" method="post">
{% csrf_token %}
First Name <input type="text" name ="fn" placeholder="Enter Your First Name" ><br><br>
Last Name <input type="text" name ="ln" placeholder="Enter Your Last Name" ><br><br>
Email <input type="email" name ="email"placeholder="Enter Your Email address" ><br><br>
Password <input type="password" name ="password" placeholder="Enter Your Password" ><br><br>
<input type="submit" value="Submit">
</form>
</body>
</html>
- 表单的动作属性会将我们重定向到一个名为的 URL 端点，该端点在 Django 应用程序中注册了。我们需要在我们的
urls.py文件中为这个端点创建一个映射，如下所示:
from django.contrib import admin
from django.urls import path
from . import views
urlpatterns = [
path('admin/', admin.site.urls),
path('', views.index, name = 'index'),
path('registered', views.registered, name= 'registered')
]
- 在我们的
views.py文件中，我们已经用一个名为registered()的函数映射了这个 URL 端点。在这个函数中，我们将编写逻辑来将 POST 请求数据存储在数据库中。 - 但是在此之前，我们需要在应用程序中创建一个模型。要创建一个模型，打开 Django 应用程序的
model.py文件。在我的例子中， models.py 文件看起来像这样:
from django.db import models
class Registration(models.Model):
first_name = models.CharField(max_length= 20)
last_name = models.CharField(max_length= 20)
email = models.EmailField(max_length= 40)
password = models.CharField(max_length= 50)
您可以看到，我们已经创建了一个带有一些字段的模型类。这个模型类将在数据库中创建一个名为 app1_registration 的表，其中 app1 是我的 Django 应用程序名， registration 是模型类的名称。
表格的结构将等同于:
CREATE TABLE app1_registration (
id INTEGER NOT NULL
PRIMARY KEY AUTOINCREMENT,
first_name VARCHAR (20) NOT NULL,
last_name VARCHAR (20) NOT NULL,
email VARCHAR (40) NOT NULL,
password VARCHAR (50) NOT NULL
);
为了最终创建表，您需要运行两个命令。
python manage.py makemigrations
定义数据库中的更改。
python manage.py migrate
提交数据库中的更改。
一旦您迁移了数据库中的更改，您需要创建一个逻辑来将数据输入到这个数据库中。这将在 views.py 文件中完成。
# importing the necessary libraries
from django.shortcuts import render
from app1.models import Registration
def index(request):
return render(request, 'index.html')
def registered(request):
first_name = request.POST['fn']
last_name = request.POST['ln']
email = request.POST['email']
password = request.POST['password']
person = Registration(first_name=first_name, last_name= last_name, email= email, password = password)
person.save()
return render(request, 'registered.html', {'fn':first_name})
- 在视图文件中，首先我将从 POST 请求中检索数据。
- 然后，我将创建一个模型类的对象，并指定将存储在数据库中的值。
save()函数将数据永久保存在数据库中。- 之后，用户将被重定向到另一个 Django 模板 namd
registered.html，在那里将显示一条欢迎消息。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Login</title>
</head>
<body>
<h1>Welcome {{fn}}. You have successfully registered your account</h1>
</body>
</html>
现在让我们测试我们的 Django 应用程序。运行 Django 服务器并打开根 URL。
Submitting the form values
我们将在表单输入字段中输入一些数据，然后单击提交。
The Welcome Page
您可以看到我们被成功重定向到欢迎页面。现在让我们看看这些值是否存储在数据库中。
我将使用 SQLite Studio 打开我的 SQLite 数据库文件。
Form data successfully stored in the database
您可以看到表单数据已成功存储在数据库中。
相关 Python Django 教程:
- Django for loop
- Python Django get
- Python Django 过滤器
- Django 模板中的 If 语句
- Django 的应用程序和项目之间的差异
- Python Django 获取管理员密码
这样，您可以将 POST 请求的数据存储在 Django 应用程序的数据库中。
- 如何在 Django 中获取 POST 请求数据
- Django 将发布数据传递给视图
- Django post 请求示例
- Django 获取发布数据列表
- Django 将 POST 数据作为字典获取
- Django 将数据发布到数据库
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Python Django 随机数
在这个 Django 教程中，我们将学习 Python Django 随机数。我们还会在 Django 中看到与随机数相关的不同例子。我们将在本教程中讨论以下主题:
- 随机数是什么
- 生成随机数的函数
- Django 随机数在视图中
- 模板中的 Django 随机数
目录
随机数是什么
在这一节中，我们将学习什么是随机数，以及如何在 Django 中使用随机概念。
随机数是从一组没有明确模式可预测的有限或无限数字中随机选择的数字。池中几乎所有的数字都互不相关。另一方面，数字的集合可以遵循特定的分布。
例如，学校里孩子的体重分布倾向于遵循体重中位数的正态分布。如果一个学生的体重是随机选择的，它更有可能接近体重中位数，而不是被归类为超重或体重不足。
随机数生成器假定生成的数字彼此独立，并且它们将在整个可能值的大范围内均匀分布。
随机数用于各种 Django 应用，包括密码学、密码生成、彩票号码生成、故事的随机生成、统计采样、完全随机化设计、计算机模拟以及任何其他需要不可预测随机数的应用。
生成随机数的函数
在这一节中，我们将介绍一些最常用的生成随机数的 Python 函数。Python 中的随机模块定义了一组用于生成和操作随机整数的函数。
- choice()函数:Python 编程语言有一个名为 choose()的内置方法，它从列表、元组或字符串中返回一个随机项。
- randrange(start，end，step):random 模块有一个名为 randrange 的函数，可以从特定的范围产生随机整数，同时也允许特定的空间范围。
- random(): 该函数生成一个小于 1 且大于等于 0 的浮点随机整数。
- uniform(下限，上限):该函数在输入中指定的值之间生成一个浮点随机数。它有两个参数:包含在层代中的下限和不包含在层代中的上限。
- randint(start，stop): 该方法返回从指定范围中选择的整数元素。它包括起止号码。
Django 视图中的随机数
在这一节中，我们将学习使用 Django 中的视图生成随机数。因此，我们通过使用各种例子来阐明我们的概念。
在开始演示之前，我将向您展示项目的 urls.py 文件。因为它在所有的例子中保持不变。
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path('', include('home.urls'))
]
这意味着当您在浏览器中打开项目时，它会将您带到 home.urls。
现在，请看主页的 urls.py 文件:
from django.urls import path, include
from home import views
urlpatterns = [
path('', views.home, name='home')
]
它会移动到 home 应用程序的 views.py 文件。
例#1
views.py 文件:
from django.http import HttpResponse
import random
# Create your views here.
def home(request):
my_list = [1, 2, 3, 4, 5, 6]
rand_num = random.choice(my_list)
html = "<html><body><b>Random Number:</b> %s</body></html>" % rand_num
return HttpResponse(html)
- 在上面的例子中，我们已经导入了随机方法。接下来，我们创建了一个名为
home的视图。 - 在这个视图中，我们使用
random.choice()方法从列表中获取随机数，并将该值存储在一个rand_num变量中。然后，我们使用变量将随机数值作为 HTTP 响应返回。
现在，如果我们运行开发服务器，我们将得到以下输出。每次我们刷新浏览器页面，都会得到一个不同的数字。
Random Number
Random Number
例 2
views.py 文件:
from django.http import HttpResponse
import random
# Create your views here.
def home(request):
rand_num = random.randrange(1, 100)
html = "<html><body><b>Random Number:</b> %s</body></html>" % rand_num
return HttpResponse(html)
- 在这个例子中，我们已经导入了随机方法。接下来，我们创建了一个名为 home 的视图。
- 在这个视图中，我们使用
randrange()方法从指定的范围中获取随机数，并将该值存储在一个变量中。然后，我们使用变量将随机数值作为 HTTP 响应返回。
输出如下所示:
Random Number
例 3
views.py 文件:
from django.http import HttpResponse
import random
# Create your views here.
def home(request):
rand_num = random.random()
html = "<html><body><b>Random Number:</b> %s</body></html>" % rand_num
return HttpResponse(html)
在这个视图中，我们使用了 random() 方法来获取随机数并将值存储在一个变量中。然后，我们使用变量将随机数值作为 HTTP 响应返回。
输出如下所示:
Random Number
模板中的 Django 随机数
在这一节中，我们将学习使用 Django 中的模板生成随机数。我们可以通过两种方式使用模板标签生成随机数:
- 使用内置模板过滤器
- 使用自定义标签
使用内置模板过滤器
在 Django 中，我们有一个内置的过滤器引用 random ，它从给定的系列中返回一个随机项。它的工作原理与 python 的 choice() 方法相同。
模板过滤随机:
{{ value | random }}
所以，我们用不同的例子来阐明我们的概念。
在我开始演示之前，我会给你看一下项目的 urls.py 和应用的 urls.py 文件。因为它在所有的例子中保持不变。
项目的 urls.py 文件:
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path('', include('myapp.urls'))
]
这意味着当你在浏览器中打开你的项目时，它会带你到你的 myapp.urls.
现在，请看 myapp urls.py 文件:
from django.urls import path, include
from myapp import views
urlpatterns = [
path('', views.myapp, name='myapp')
它移动到 myapp 应用程序的 views.py 文件。
例#1
views.py 文件:
from django.shortcuts import render
# Create your views here.
my_list = ['abc','def','ghi','abcd','as$25l6']
def myapp(request):
return render(request, 'home.html', {'my_list':my_list})
首先，我们将创建一个重定向到 HTML 页面的视图。在 views.py 文件中，我们定义列表并将列表值重定向到home.html页面。
home.html文件:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>PythonGuides</title>
</head>
<body>
<p>
<b> Random Generator : </b> {{my_list|random}}
</p>
</body>
</html>
接下来，我们将把【随机】过滤器添加到【home.html】文件中，以获得结果。
Random Generator
Random Generator
例 2
views.py 文件:
from django.shortcuts import render
# Create your views here.
my_series = ['124dsvb@#','def%^569$#','ghi496o)%@5','897563214','as$25l6']
def myapp(request):
return render(request, 'home.html', {'my_series':my_series})
首先，我们将创建一个重定向到 HTML 页面的视图。在 views.py 文件中，我们定义列表并将列表值重定向到home.html页面。
home.html文件:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>PythonGuides</title>
</head>
<body>
<p>
<b> Random Generator : </b> {{my_series|random}}
</p>
</body>
</html>
接下来，我们将把【随机】过滤器添加到【home.html】文件中，以获得结果。
Random Number
使用自定义标签
现在，我们将学习使用自定义标签生成一个随机数。因此，首先我们必须创建一个自定义标签。所以，让我们从不同的例子来学习这个概念。
例#1
这里我在 app 的目录下的 templatetags 目录下创建一个 custom_tag.py 文件。
custom_tag.py 文件:
import random
from django import template
register = template.Library()
@register.simple_tag
def random_int(start, stop):
return random.randint(start, stop)
这里我创建了一个名为 random_number 的标签。而在这之后， random.randint() 方法被用来生成一个开始和停止之间的随机数。
views.py 文件:
from django.shortcuts import render
# Create your views here.
def myapp(request):
return render(request, 'home.html')
首先，我们将创建一个重定向到 HTML 页面的视图。在 views.py 文件中，我们将定义一个代码来重定向到home.html页面。
home.html文件:
<!Load Custom Tag>
{%load custom_tag%}
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>PythonGuides</title>
</head>
<body>
<p>
<b> Random Generator : </b> {% random_number 100 1000%}
</p>
</body>
</html>
现在，在 home.html 文件中，我将首先加载标记名 custom_tag。
加载标签命令:
{% load <tag_name> %}
接下来，我使用之前创建的 random_number 标记。这里我传递 100 和 1000 作为开始和停止值。
现在，如果我们运行开发服务器，我们将得到以下输出。
Random Number
Random Number
例 2
这里我在 app 的目录下的 templatetags 目录下创建一个 random_tag.py 文件。
random_tag.py 文件:
import random
from django import template
register = template.Library()
@register.simple_tag
def rand_num(lower_limit, upper_limit):
return random.uniform(lower_limit, upper_limit)
这里我创建了一个名为 rand_num 的标签。而在这之后，【random . uniform()】的方法被用来生成一个介于下限和上限之间的随机数。
views.py 文件:
from django.shortcuts import render
# Create your views here.
def myapp(request):
return render(request, 'random.html')
首先，我们将创建一个重定向到 HTML 页面的视图。在 views.py 文件中，我们将定义一个代码来重定向到random.html页面。
random.html文件:
<!Load Custom Tag>
{%load random_tag%}
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>PythonGuides</title>
</head>
<body>
<p>
<b> Random Generator : </b> {% rand_num 10 20%}
</p>
</body>
</html>
现在，在 random.html 文件中，我将首先加载标记名 random_tag。接下来，我使用前面创建的 rand_num 标记。这里我传递 10 和 20 作为下限和上限。
现在，如果我们运行开发服务器，我们将得到以下输出。
Random Number
你可能也喜欢阅读下面的 Django 教程。
- Python Django 长度过滤器
- Python Django vs ReactJS
- Python Django group by
- 使用 PostgreSQL 的 Django CRUD 示例
- 将 Python 输出到 html Django
在本 Django 教程中，我们讨论了 Python Django 随机数。此外，我们还讨论了以下主题列表:
- 随机数是什么
- 生成随机数的函数
- Django 随机数在视图中
- 模板中的 Django 随机数
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Python Django 四舍五入到两位小数
原文：https://pythonguides.com/django-round-to-two-decimal-places/
在这个 Python Django 教程中，我们将学习如何在 Django 中四舍五入到两位小数。我们还会看到与此相关的例子。这些是我们将在本教程中讨论的以下主题。
- Python Django 四舍五入到两位小数
- Python Django 四舍五入到两位小数基本命令
- Python Django 四舍五入到两位小数 view- round()函数
- Python Django 四舍五入到两位小数 view- format()函数
- Python Django 四舍五入到两位小数视图- %格式
- Python Django 四舍五入到两位小数 view- ceil()函数
- Python Django 四舍五入到两位小数 view- floor()函数
- Python Django 四舍五入到两位小数视图-十进制模块
目录
- Python Django 四舍五入到两位小数
- Python Django 四舍五入到小数点后两位基本命令
- Python Django 四舍五入到两位小数 view- round()函数
- Python Django 四舍五入到两位小数 view- format()函数
- Python Django 四舍五入到两位小数视图- %格式化
- Python Django 四舍五入到小数点后两位 view- ceil()函数
- Python Django 四舍五入到小数点后两位 view- floor()函数
- Python Django 四舍五入到两位小数视图-十进制模块
Python Django 四舍五入到两位小数
在本节中，我们将学习四舍五入到两位小数的基本知识。
浮点数分为两部分:整数部分和小数部分。它们用小数点分开。
举例: 12.36，459.65，885.3 等为浮动值。
四舍五入小数位的规则:
如果给出了小数点后的数字
- 大于等于 5: 然后最终值加 1。
- 小于 5: 那么将返回最终数字，因为它达到了指定的小数位。
四舍五入小数位的方法:
以下是四舍五入小数位数的不同方法。
- round()函数
- format()函数
- ceil()函数
- floor()函数
- 十进制模块
阅读 Python Django 在哪里保存所有应用的基础模板
Python Django 四舍五入到小数点后两位基本命令
在本节中，我们将学习四舍五入两位小数的基本命令。
创建项目: 首先，我们需要创建一个 Django 项目。为此，请在终端中键入以下命令。
django-admin startproject Employee
- 这里，雇员是 Django 项目的名称。
创建 APP: 然后，我们来创建一个 Django App。为此，请在终端中键入以下命令。
python manage.py startapp Salary
- 这里，工资是 Django App 的名字。
安装 APP: 现在，将上面创建的 APP 包含在 settings.py 文件中。
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'Salary',
]
创建模板: 然后创建名为 TEMPLATES 的文件夹。并且，在文件夹中添加 HTML 文件。
Python Django round to two decimal places
添加模板: 现在，将这个文件夹添加到 settings.py 文件中的 TEMPLATES 文件夹中。
DIRS : ['Templates']
项目 URL:在 Employee 的 urls.py 文件中添加以下代码。
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path('', include('Salary.urls'))
]
APP 网址: 在工资的 urls.py 文件中添加以下代码。
from django.urls import path
from . import views
urlpatterns = [
path('', views.EmpSalary, name='EmpSalary'),
]
创建表单: 现在，将下面的代码添加到薪资 app 的 forms.py 文件中，创建表单。
from django import forms
class EmpSalaryForm(forms.Form):
Name = forms.CharField()
Designation = forms.CharField()
Salary = forms.IntegerField()
Tax = forms.FloatField()
- 这里，我们创建一个
EmpSalaryForm表单类，它有两个字符字段、一个整数字段和一个浮点值字段。
【form.html】:将以下代码添加到 form.html 文件中以创建一个表单。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Index</title>
</head>
<body>
<form method="POST" class="post-form" enctype="multipart/form-data">
{% csrf_token %}
{{ form.as_p }}
<button type="submit" class="save btn btn-default">Submit</button>
</form>
</body>
</html>
- 这里，我们使用
form.as_p标签将 Django 表单呈现为一个段落。
salary.html: 将下面的代码添加到【salary.html】的文件中。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<p>
<b>Tax amount round to two decimal : </b> {{RoundTax}}
</p>
</body>
</html>
阅读:使用 PostgreSQL 的 Django CRUD 示例
Python Django 四舍五入到两位小数 view- round()函数
在这一节中，我们将学习使用 round()方法四舍五入到两位小数。
例:使用 round() 函数。
创建视图: 在 views.py 文件中添加以下代码。
from django.shortcuts import render
from Salary.forms import EmpSalaryForm
def EmpSalary(request):
if request.method == "POST":
form = EmpSalaryForm(request.POST)
if form.is_valid():
Name = form.cleaned_data['Name']
Designation = form.cleaned_data['Designation']
Salary = form.cleaned_data['Salary']
Tax = form.cleaned_data['Tax']
RoundTax = round(Tax,2)
return render(request, 'salary.html', {'RoundTax':RoundTax})
else:
form = EmpSalaryForm()
return render(request,'form.html',{'form':form})
round()函数是一个内置的 python 函数。- 它用于返回一个已舍入到所提供的小数位数的浮点值。
- Synatx:
- 四舍五入(数字，数位)
- 如果省略 digit 参数，则返回与给定数字最接近的整数；否则，该数字将被舍入到给定的数字值。
Python Django round to two decimal places views
Django round to two decimal places views-round()
Python Django 四舍五入到两位小数 view- format()函数
在这一节中，我们将学习使用 format()方法四舍五入到两位小数。
例:使用格式()函数。
创建视图: 在 views.py 文件中添加以下代码。
from django.shortcuts import render
from Salary.forms import EmpSalaryForm
def EmpSalary(request):
if request.method == "POST":
form = EmpSalaryForm(request.POST)
if form.is_valid():
Name = form.cleaned_data['Name']
Designation = form.cleaned_data['Designation']
Salary = form.cleaned_data['Salary']
Tax = form.cleaned_data['Tax']
RoundTax =("{:0.2f}".format(Tax))
return render(request, 'salary.html', {'RoundTax':RoundTax})
else:
form = EmpSalaryForm()
return render(request,'form.html',{'form':form})
- 我们使用
format()函数将数字向上舍入，给出的字符串格式为。2f。 - 此格式中的
f表示浮点值，.2指定该值必须有两位小数。 - 句法
"{:0.2f}".format(number)
Python Django round to two decimal places view-format() function
Django round to two decimal places view-format() function
Python Django 四舍五入到两位小数视图- %格式化
在这一节中，我们将学习使用%格式四舍五入到两位小数。
例:使用 % 格式。
创建视图: 在 views.py 文件中添加以下代码。
from django.shortcuts import render
from Salary.forms import EmpSalaryForm
def EmpSalary(request):
if request.method == "POST":
form = EmpSalaryForm(request.POST)
if form.is_valid():
Name = form.cleaned_data['Name']
Designation = form.cleaned_data['Designation']
Salary = form.cleaned_data['Salary']
Tax = form.cleaned_data['Tax']
RoundTax =("%.2f" %Tax)
return render(request, 'salary.html', {'RoundTax':RoundTax})
else:
form = EmpSalaryForm()
return render(request,'form.html',{'form':form})
- 为了得到格式化的输出，我们可以使用 % 来代替
format()函数。 - 它类似于 print 函数中的格式说明符。
- 只需使用带有 %.2f 的格式向下舍入到两位小数。
- 语法:
"%.2f" % number
Python Django round to two decimal places view % formatting
Django round to two decimal places view % formatting
Python Django 四舍五入到小数点后两位 view- ceil()函数
在这一节中，我们将学习使用 ceil()函数四舍五入到两位小数。
例:使用 ceil() 方法。
创建视图: 在 views.py 文件中添加以下代码。
from math import ceil
from django.shortcuts import render
from Salary.forms import EmpSalaryForm
def EmpSalary(request):
if request.method == "POST":
form = EmpSalaryForm(request.POST)
if form.is_valid():
Name = form.cleaned_data['Name']
Designation = form.cleaned_data['Designation']
Salary = form.cleaned_data['Salary']
Tax = form.cleaned_data['Tax']
RoundTax = ceil(Tax*100)/100
return render(request, 'salary.html', {'RoundTax':RoundTax})
else:
form = EmpSalaryForm()
return render(request,'form.html',{'form':form})
- Python 数学模块中的
ceil()函数可以对任何值进行舍入。 - 此模块中的
ceil()函数返回大于或等于传递给它的值的最小整数。 - 要使用它们的两位小数，先将数字乘以
100来移动小数点，然后除以100来补偿。 - 最终结果将用
ceil()函数取整。 - 语法:
from math import ceil
ceil(number*100)/100
Python Django round to two decimal places view ceil function
Django round to two decimal places view ceil function
Python Django 四舍五入到小数点后两位 view- floor()函数
在本节中，我们将学习使用 floor 函数四舍五入到两位小数。
例:使用 floor() 法。
创建视图: 在 views.py 文件中添加以下代码。
from math import floor
from django.shortcuts import render
from Salary.forms import EmpSalaryForm
def EmpSalary(request):
if request.method == "POST":
form = EmpSalaryForm(request.POST)
if form.is_valid():
Name = form.cleaned_data['Name']
Designation = form.cleaned_data['Designation']
Salary = form.cleaned_data['Salary']
Tax = form.cleaned_data['Tax']
RoundTax = floor(Tax*100)/100
return render(request, 'salary.html', {'RoundTax':RoundTax})
else:
form = EmpSalaryForm()
return render(request,'form.html',{'form':form})
floor()函数返回小于或等于指定值的最大数字。- 如果我们使用
floor()函数，最终结果将被四舍五入。 - 语法:
from math import floor
floor(number*100)/100
Python Django round to two decimal places view floor function
Django round to two decimal places view floor function
Python Django 四舍五入到两位小数视图-十进制模块
在本节中，我们将学习使用 decimal 模块四舍五入到两位小数。
例:用小数()法。
创建视图: 在 views.py 文件中添加以下代码。
from decimal import ROUND_HALF_DOWN, Decimal
from django.shortcuts import render
from Salary.forms import EmpSalaryForm
def EmpSalary(request):
if request.method == "POST":
form = EmpSalaryForm(request.POST)
if form.is_valid():
Name = form.cleaned_data['Name']
Designation = form.cleaned_data['Designation']
Salary = form.cleaned_data['Salary']
Tax = form.cleaned_data['Tax']
RoundTax = Decimal(Tax.quantize(Decimal('.01'), rounding = ROUND_HALF_DOWN))
return render(request, 'salary.html', {'RoundTax':RoundTax})
else:
form = EmpSalaryForm()
return render(request,'form.html',{'form':form})
- Python 有一个 decimal 模块，它有几个处理十进制值的函数。
- 它可用于将浮点值四舍五入到两位小数。
- “四舍五入”方法通过四舍五入到最接近的数字来达到所需的精度。
注:
如果要执行精度计算，请将该字段设置为 decimal 否则，将会产生错误。
举例:
Tax=form.DecimalField()
Python Django round to two decimal places view decimal module
Django round to two decimal places view decimal module
另外，看看更多的 Python Django 教程。
在本教程中，我们已经讨论了“ Python Django** 四舍五入到两位小数**”，我们还讨论了本教程中的以下主题。
- Python Django 四舍五入到两位小数
- Python Django 四舍五入到两位小数基本命令
- Python Django 四舍五入到两位小数 view- round()函数
- Python Django 四舍五入到两位小数 view- format()函数
- Python Django 四舍五入到两位小数视图- %格式
- Python Django 四舍五入到两位小数 view- ceil()函数
- Python Django 四舍五入到两位小数 view- floor()函数
- Python Django 四舍五入到两位小数视图-十进制模块
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Python Django vs ReactJS
Django 是一个用于创建 Web 应用程序的 Python 框架，专注于快速开发和架构清晰。 React 则称其为“用 JavaScript 编写的用户界面库”。在姜戈语中，大多数人用反应来代表 MVT 中的“V。
所以在本文中，我们将讨论 Django 和 React 之间的一些关键区别。我们也会试着找出何时选择哪一个。以下是本文所涵盖主题的完整概述。
- Django 简介
- ReactJS 简介
- ReactJS 的优势
- 反应堆的缺点
- 与 Django 联系的优势
- 与 Django 联系的缺点
- Django vs ReactJS
- 结论
Django vs ReactJS
目录
- Django 简介
- react js 简介
- 反应堆的优点
- 反应堆的缺点
- 与 Django 合作的优势
- 与 Django 进行交易的劣势
- Django vs ReactJS
- 结论
Django 简介
Django 是一个高级 Python web 框架，它允许程序员使用模块来加速开发。开发者可以使用 Django 的模块直接从现有资源创建应用和网站。
为了大大加快开发过程，Django 消除了从头开始的需要。当您使用 Django 创建后端 web 应用程序时，您可以使用它的表述性状态转移(REST)架构来创建定制的 API。
现在如果想深入了解 Django，还可以参考下面这篇文章“ 什么是 Python Django，用于 ”。
react js 简介
React 是顶级的基于 JavaScript 的 UI 开发库之一。它用最少的编码和工作创建现代 web 应用程序。因为 React 是一个库而不是一门语言，所以它被绝大多数 web 开发者所使用。
它通过将每个页面分成许多部分来简化用户界面的创建。这些部分是组件。它主要由我们在前端看到的元素组成。它现在是使用最广泛的前端库之一。
反应堆的优点
在这一节中，我们将讨论使用 ReactJs 库的一些主要优点。
- 与其他库相比，ReactJs 是一个很容易理解的库。这使我们能够在规定的时间内完成各种项目。
- 在 ReactJS 中，一个网页通常被分成不同的组件。这里，每个组件定义一个视图。
- 它还具有单向数据绑定特性。这个设施的整个应用程序向一个方向流动。它将为您提供所需的一切，例如，对应用程序的更多控制。
- ReactJs 还允许您重用组件。开发者可以使用这种能力来重新分发相同的数字对象。因此，我们可以得出结论，它提高了开发人员的生产力。
反应堆的缺点
在这一节中，我们将讨论使用 ReactJs 库的一些主要缺点。
- 文件不足。
- ReactJs 不能用于创建功能完整的应用程序。
- ReactJS 只涉及应用程序的 UI 层，没有其他内容。为了完成项目的开发，我们需要更多的技术。
- ReactJs 允许快速应用程序开发。因此，开发人员可能会承受很大的压力。
- ReactJS 利用了 JSX。它是一种语法扩展，允许你混合 HTML 和 JavaScript。然而，开发社区的一些成员认为 JSX 是一个主要的障碍，特别是对于新手开发者。
与 Django 合作的优势
在这一节中，我们将了解在 Django 中使用 ReactJs 的优势。
- 它使得管理后端和前端的代码变得轻而易举。
- 使用静态文件，Django 可以很容易地与 ReactJs 连接。
- Django 的前端和后端是分开开发的，更容易测试、发现和修复错误。
- 由于使用了变量的状态，ReactJs 的开发方法不够简洁。
- 由于前端和后端的分离，加载时间将大大降低。
- 通过结合 ReactJs 和 Django 可以实现高级定制。
与 Django 进行交易的劣势
在这一节中，我们将了解在 Django 中使用 ReactJs 的缺点。
- 由于 Django 版本繁多，对于某些程序员来说，在本地工作站上安装它可能需要很长时间。
Django vs ReactJS
在这一节中，我们将讨论 ReactJs 库和 Django 框架之间的一些关键区别。
- Django 于 2005 年首次发布，而 ReactJs 于 2013 年发布。
- Django 是用 Python 创建的，而 ReactJs 是用 JavaScript 编写的。
- Django 是一个 web 开发框架，而 ReactJs 是一个 JavaScript 库。
- Django 提供较高的安全性，而 ReactJs 提供较低的安全性。
- 大多数人觉得 Django 很难学习和理解，然而，ReactJs 比 Django 更容易学习，因为它的学习难度很低。
- Django 不太适合小型应用程序，而 ReactJs 适合小型和大型应用程序。
- Django 并不是非常有名和受欢迎，然而，React 更有名。
- 为了快速开发应用程序，Django 提供了现成的工具、标准、模板和策略，而 ReactJs 为我们的代码提供了可重用的功能。
- Django 框架控制代码何时何地调用 ReactJs 库，而代码控制何时何地调用 ReactJs。
- Django 框架用于构建和发布应用程序，而 ReactJs 使程序绑定更容易。
结论
前端要用 Django 和 Reactjs 搭建。使用 Django Rest 框架，我们将前端(Reactjs)连接到后端(Django)。在你做出选择之前，确保你知道 Python 和 JavaScript 哪个更适合你。
另外，看看更多关于 Django 的教程。
- Python 过滤器不在 Django
- 如何在 Django 中创建模型
- 如何设置 Django 项目
- 获取 Django 中的 URL 参数
- 模型 Django 上的联合操作
- 如何获取 Django 的当前时间
到目前为止，在本教程中，我们已经讨论了 Django 和 ReactJs 之间的主要区别。我们还讨论了以下主题。
- Django 简介
- ReactJS 简介
- ReactJS 的优势
- 反应堆的缺点
- 与 Django 联系的优势
- 与 Django 联系的缺点
- Django vs ReactJS
- 结论
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Python Django 在哪里保存所有应用程序的基础模板
原文：https://pythonguides.com/django-where-to-save-base-template-for-all-apps/
在这个 Python Django 教程中，我们将学习在哪里保存 Django 中 所有应用的基础模板。这些是我们将在本教程中讨论的主题。
- Python Django 项目设置
- Python Django 在哪里保存所有应用程序的基础模板
目录
Python Django 项目设置
在本节中，我们将学习建立一个 Django 项目。
创建项目: 首先，我们创建一个 Django 项目。为此，在终端中键入下面提到的命令。
django-admin startproject BookStore
- 在这里，我们创建了一个名为书店的 Django 项目。
创建应用: 接下来，作为项目的一部分，我们将构建一个应用。在终端中运行以下命令来创建它。
python manage.py startapp Books
安装 APP: 以上创建的图书 APP 必须包含在 settings.py 文件中。
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'Books'
]
创建模板: Django 模板保持 Django 应用的设计。template 文件夹包含您在各种 Django 应用程序中需要的所有模板。
在大多数情况下，templates 文件夹被创建并保留在 sample 目录中，该目录还包含 manage.py。
Python Django project setup
或者，您可以为每个应用程序创建不同的模板文件夹。
Django project setup
添加模板: 要配置 Django 模板系统，进入 settings.py 文件，将 DIRS 更改为 TEMPLATES 文件夹的路径。
- 创建单个模板文件夹时:
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': ['Templates'],
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]
- 当你创建一个独特的
如果你单独维护每个应用的模板，你不需要更新设置中的 DIRS 。确保你的应用包含在设置. py 的 已安装应用中。
项目 URL:在书店 urls.py 文件中添加以下代码。
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path('', include('Books.urls')),
]
APP 网址: 在 Books urls.py 文件中添加以下代码。
from django.urls import path
from . import views
urlpatterns = [
path('', views.BookForm, name='BookForm'),
]
创建表单: 现在，我们创建一个表单。以及下面的代码片段到图书 app 的 forms.py 文件中。
from django import forms
class BookRecord(forms.Form):
Book_Name = forms.CharField(label='Book Name')
Author_Name = forms.CharField(label='Author Name')
- 这里，我们用两个
CharField创建一个BookRecordform 类。
创建视图: 将下面的代码添加到 views.py 文件中。
from django.shortcuts import render
from Books.forms import BookRecord
def BookForm(request):
if request.method == "POST":
form = BookRecord(request.POST)
if form.is_valid():
BookName = form.cleaned_data['Book_Name']
AuthorName = form.cleaned_data['Author_Name']
context ={
'BookName':BookName,
'AuthorName':AuthorName
}
return render(request, 'index.html',context)
else:
form = BookRecord()
return render(request,'home.html',{'form':form})
Python Django 保存所有应用程序基础模板的位置
在本节中，我们将了解所有应用程序的基础模板的保存位置。
创建基础模板: 现在，创建一个 HTML 文件【base.html】的并添加下面的代码。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>PythonGuides</title>
</head>
<body>
<center>Welcome to PythonGuides Book Store</center>
{% block body %}
{% endblock %}
</body>
</html>
- 块标签用于描述可以被子模板覆盖的块。
- 换句话说，在基础模板中指定块意味着该区域的内容将源自子模板文件。
- 看一下这个
base.html模板，它有一个用于主体的模块。
创建主页模板: 现在，创建一个 HTML 文件【home.html并添加以下代码。
{% extends 'base.html' %}
{% block body %}
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Index</title>
</head>
<body>
<form method="POST" class="post-form" enctype="multipart/form-data">
{% csrf_token %}
{{ form.as_p }}
<button type="submit" class="save btn btn-default">Submit</button>
</form>
{% endblock %}
</body>
</html>
- 在您创建了您的基础模板之后，您可以向它添加子模板。
- 扩展了关键字，可以用来执行这个操作。
- 所以我们可以把那个标签放在 index.html 文件的最顶端。
创建索引模板: 现在，创建一个 HTML 文件【index.html】的并添加下面的代码。
{% extends 'base.html' %}
{% block body %}
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<p>
The book <b>{{BookName}}</b> written by <b>{{AuthorName}}</b> successfully recorded.
</p>
</body>
{% endblock %}
</html>
- 在
index.html文件中，我们只是使用变量来获取书名值和作者名值。
运行服务器 :启动服务器，通过定义 URL 为 http://127.0.0.1:8000 访问表单。
Python Django where to save base template for all apps
Django where to save base template for all apps
你可能也喜欢阅读下面的 Django 教程。
- Python Django 连接字符串
- Python Django MySQL CRUD
- Python Django app 上传文件
- Python Django 随机数
- Python 改 Django 版本
- Python Django 四舍五入到两位小数
- Python 列表追加 Django
在这个 Python Django 教程中，我们已经讨论了所有应用程序的基础 模板的保存位置 Django，我们还讨论了本教程中的以下主题。
- Python Django 项目设置
- Python Django 在哪里保存所有应用程序的基础模板
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
用 Python 从 URL 下载 zip 文件
原文：https://pythonguides.com/download-zip-file-from-url-using-python/
使用 Python，由于其丰富的库，你可以编程许多任务。使用 Python 程序可以完成的任务之一是从 URL 下载 zip 文件。
在这篇 Python 文章中，您将看到多个关于如何使用 python 从 URL 下载 zip 文件的例子。
- Python wget 下载 zip 文件
- Python 请求模块下载 zip 文件
- Python 从 URL 下载 zip 文件并解压缩
- Python 从 URL 下载多个 zip 文件
- Python 从 Github 下载 zip 文件
- 从 Azure blob storage python 下载 zip 文件
目录
- Python wget 下载 zip 文件
- Python 请求模块下载 zip 文件
- Python 从 URL 下载 zip 文件并解压
- Python 从 URL 下载多个 zip 文件
- Python 从 Github 下载 zip 文件
- 从 Azure blob storage python 下载 zip 文件
Python wget 下载 zip 文件
用 Python 从 URL 下载 zip 文件的一种方法是使用 wget()函数。但是您需要首先使用 pip 命令行实用程序安装 wget 库。
在命令提示符下，执行以下代码来安装 wget 库:
pip install wget
安装后，您将看到如下屏幕所示的输出:
Installing the wget library
现在您可以使用 wget 库下载一个 zip 文件。下面是使用 wget 函数的语法。
wget('URL of the zip file')
比如下载 golang 的 zip 源文件的链接是“https://golang . org/dl/go 1 . 17 . 3 . windows-amd64 . zip”。我可以执行下面的 Python 代码片段来下载这个 zip 文件:
import wget
url='https://golang.org/dl/go1.17.3.windows-amd64.zip'
wget.download(url)
您将在输出控制台中看到进度。
Downloading a zip file using wget
您可以在保存 Python 源代码文件的同一文件夹中看到您的 zip 文件。
您还可以以另一种方式使用 wget 选项。通过在命令行中执行以下代码，可以下载相同的 zip 文件:
python -m wget 'https://golang.org/dl/go1.17.3.windows-amd64.zip' -o 'C:\Users\Blades\Downloads'
使用 -o 标志，您可以指定 zip 文件的下载路径。
因此，通过这种方式，您可以使用 Python 中的 wget 库从 URL 下载一个 zip 文件。
阅读: Python 返回函数
Python 请求模块下载 zip 文件
您还可以使用请求模块从 URL 下载一个 zip 文件。我们必须向 zip 文件 URL 发送一个请求，并将结果存储在一个变量中。然后，我们可以将这个 zip 内容写入本地文件系统。
酪首先，您必须使用 pip 命令将这个模块安装到您的 Python 编译器中:
pip install requests
Installing the requests module
现在，您可以在代码中导入该模块并开始使用它。
例如，如果我必须从 URL“https://golang . org/dl/go 1 . 17 . 3 . windows-amd64 . zip”下载一个 zip 文件，我可以编写下面的 Python 代码片段:
# importing the requests module
import requests
print('Downloading started')
url = 'https://golang.org/dl/go1.17.3.windows-amd64.zip'
# Downloading the file by sending the request to the URL
req = requests.get(url)
# Split URL to get the file name
filename = url.split('/')[-1]
# Writing the file to the local file system
with open(filename,'wb') as output_file:
output_file.write(req.content)
print('Downloading Completed')
在上面的代码中，我们向指定的 URL 发送一个 GET 请求，并返回 zip 文件内容作为响应。之后，我们将 zip 文件内容写入本地文件系统中的一个文件。
Downloading a zip file using the requests module
您可以在 Python 源代码文件的位置验证下载。因此，您可能已经学会了如何使用请求模块从 Python 中的 URL 下载 zip 文件。
Python 从 URL 下载 zip 文件并解压
在本节中，您将学习如何下载一个 zip 文件并将其解压缩到本地文件系统中。
我们需要三个模块:
- 请求:下载 zip 文件
- BytesIO:从缓冲区读取文件
- zipfile:读取并解压缩 zip 文件
例如，下面的 python 代码片段将从指定的 URL 下载一个 zip 文件，并将该 zip 文件提取到本地文件系统中。
# importing necessary modules
import requests, zipfile
from io import BytesIO
print('Downloading started')
#Defining the zip file URL
url = 'https://www.learningcontainer.com/wp-content/uploads/2020/05/sample-zip-file.zip'
# Split URL to get the file name
filename = url.split('/')[-1]
# Downloading the file by sending the request to the URL
req = requests.get(url)
print('Downloading Completed')
# extracting the zip file contents
zipfile= zipfile.ZipFile(BytesIO(req.content))
zipfile.extractall('C:/Users/Blades/Downloads/NewFolder')
Downloading and extracting a zip file using python
在上面的代码中，首先我们下载 zip 文件并将它的内容存储到一个变量中。
然后，我们使用 BytesIO 函数读取 zip 文件内容，并将它们存储在 zip 格式的变量中。
最后，我们使用 extractall() 函数将 zip 文件数据提取到本地文件系统中。
注意:在 extractall()函数中定义文件路径时，用正斜杠(/)代替反斜杠()。否则，您将面临一个错误。
或者，您也可以在路径前附加 r，使其成为原始字符串。例如:
zipfile.extractall(r'C:\Users\Blades\Downloads\NewFolder')
因此，您可能已经学会了如何用 python 从 URL 下载和提取 zip 文件。
阅读: Python 在字符串中查找数字
Python 从 URL 下载多个 zip 文件
在这一节中，我将解释如何从一个 URL 下载多个 zip 文件。
当您希望借助 Python 从一个 web 页面下载所有 zip 文件时，您可能会遇到这种情况。在这种情况下，您可以使用以下技术下载所有 zip 文件:
- 我们已经使用了请求模块来执行这个任务。你可以用 python 中的
pip命令安装这个模块。 - 其次，我们使用了 BeautifulSoup 库来清理网页的响应内容。
- 第一步是获取显示所有 zip 文件链接的网页。
- 然后，我使用
BeautifulSoup库清理了请求的响应。 - 之后，我获取了所有 zip 文件的 URL，并将它们存储在一个文本文件中。
- 一旦所有链接都存储在文本文件中，我就通过从文本文件中读取 URL 并向该 URL 发送一个
GET请求来下载每个 zip 文件。 - 因此，在响应中会下载一个文件。
- 我在本地文件系统中创建了一个新的 zip 文件，并写入了上一步下载的 zip 文件内容。
# importing the necessary modules
import requests
from bs4 import BeautifulSoup
# Creating a new file to store the zip file links
newfile = open('zipfiles.txt','w')
#Set variable for page to be opened and url to be concatenated
page =requests.get('https://sample-videos.com/download-sample-zip.php')
baseurl= 'https://sample-videos.com/'
#Use BeautifulSoup to clean up the page
soup = BeautifulSoup(page.content)
soup.prettify()
#Find all the links on the page that end in .zip and write them into the text file
for anchor in soup.findAll('a', href=True):
links = anchor['href']
if links.endswith('.zip'):
newfile.write(links + '\n')
newfile.close()
#Fetching the links for the zip file and downloading the files
with open('zipfiles.txt', 'r') as links:
for link in links:
if link:
filename1= link.split('/')[-1]
filename= filename1[:-1]
link = baseurl + link
print(filename + ' file started to download')
response = requests.get(link[:-1])
# Writing the zip file into local file system
with open(filename,'wb') as output_file:
output_file.write(response.content)
print(filename + 'file is downloaded')
Multiple Zip Files Download
一旦程序成功执行，您将看到所有的 zip 文件都下载到了您的 Python 源代码位置。
替代方法:
还有另一种方法，即使用 wget() 函数。
你必须使用 pip 命令安装 wget 库。
之后，您可以执行下面的代码从一个 URL 下载所有的 zip 文件:
# importing the necessary modules
import requests
from bs4 import BeautifulSoup
import wget
# Creating a new file to store the zip file links
newfile = open('zipfiles.txt','w')
#Set variable for page to be opened and url to be concatenated
page =requests.get('https://sample-videos.com/download-sample-zip.php')
baseurl= 'https://sample-videos.com/'
#Use BeautifulSoup to clean up the page
soup = BeautifulSoup(page.content)
soup.prettify()
#Find all the links on the page that end in .zip and write them into the text file
for anchor in soup.findAll('a', href=True):
links = anchor['href']
if links.endswith('.zip'):
newfile.write(links + '\n')
newfile.close()
#Fetching the links for the zip file and downloading the files
with open('zipfiles.txt', 'r') as links:
for link in links:
if link:
link = baseurl + link
wget.download(link[:-1])
方法与上述方法几乎相同。唯一的区别是我们使用了 wget 库来下载文件，而不是 requests 库。
使用 wget 库的好处是，您还可以看到下载的进度条，如下图所示:
Download all the zip files from a URL
因此，您可能已经学会了如何使用 python 从单个 web 页面下载所有 zip 文件。
Python 从 Github 下载 zip 文件
在这一节中，我将解释如何使用 python 从 Github 下载 zip 文件。
在任何 Github 存储库中，您都可以选择以 zip 文件的形式下载源代码。请看下图以供参考:
Download zip file link in Github
您可以在 Python 程序中使用这个链接来下载这个 zip 文件。您可以使用上述章节中介绍的任何方法。例如，您可以使用下面的 Python 代码使用 wget() 下载 zip 文件:
import wget
url='https://github.com/Blades007/android_weather/archive/refs/heads/main.zip'
wget.download(url)
代码成功执行后，您可以看到文件创建在存储 python 源代码文件的文件夹中。
这样，你就可以用 Python 从 Github 下载一个 zip 文件了。
从 Azure blob storage python 下载 zip 文件
要在 Python 中使用 Azure blob 存储，需要安装一个名为 azure-storage-blob 的库。要在 Python 编译器中安装此库，请在命令提示符下执行以下命令:
pip install azure-storage-blob
Downloading the Azure storage library
一旦你安装了这个库，你就可以编写代码从 Azure blob 容器下载一个 zip 文件。该过程解释如下:
- 首先，我们将使用连接字符串与 Azure 存储容器中存储的文件建立连接。
- 然后，我们将从存储器中下载文件。
- 最后，我们将文件保存在本地文件系统中。
要获取 Azure 存储容器的连接字符串:
- 导航到你的 Azure 存储容器，点击安全+网络标签中的访问密钥。
- 您将看到一个密钥列表。但它们都将被隐藏。
- 点击显示密钥查看密钥。
- 键的连接字符串与它们一起列出。您可以使用任何连接字符串。
Azure storage access keys
现在，您可以执行下面的 Python 代码来下载存储在 Azure 容器中的 zip 文件。
# importing the necessary module
from azure.storage.blob import BlobClient
# making a connection with the file in Azure blob storage container
blob = BlobClient.from_connection_string(conn_str="<your connection string", container_name="<your azure storage container name>", blob_name="your zip file name")
# writing the zip file to the local file system
print("Download Started")
with open("./sample-zip-file.zip", "wb") as my_blob:
blob_data = blob.download_blob()
my_blob.write(blob_data.content_as_bytes())
print("Download is complete")
在上面的代码中替换您的凭据。
注:数据正在以字节的形式下载，并写入一个新文件。您可以给新的 zip 文件取任何名称。
Download zip file from Azure blob storage python
您可以看到 zip 文件下载到了指定的路径中。
这样，您可以从 Azure 存储容器下载一个 zip 文件到您的本地文件系统。
另外，看看更多关于 Python 的教程。
因此，您可能已经学会了使用 Python 从 URL 下载 zip 文件的各种方法。
- Python wget 下载 zip 文件
- Python 请求模块下载 zip 文件
- Python 从 URL 下载 zip 文件并解压缩
- Python 从 URL 下载多个 zip 文件
- Python 从 Github 下载 zip 文件
- 从 Azure blob storage python 下载 zip 文件
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
使用 Python Turtle 绘制彩色填充形状
原文：https://pythonguides.com/draw-colored-filled-shapes-using-python-turtle/
在这个 Python 教程中，我们将通过几个例子学习如何使用 Python turtle 绘制彩色填充的形状，我们还将涉及以下主题:
- 如何使用 Python turtle 绘制彩色填充形状？
- 如何使用 Python turtle 改变屏幕颜色？
- 如何在蟒蛇龟中绘制彩色填充半圆
- 使用蟒蛇龟绘制彩色填充圆
- 如何在 python 海龟中绘制彩色填充椭圆
- 使用蟒蛇龟绘制彩色填充正方形
- 使用 Python turtle 绘制彩色填充矩形
- 使用蟒蛇龟绘制彩色填充三角形
- 使用蟒蛇龟绘制彩色填充的星星
- 使用蟒蛇龟绘制彩色填充六边形
- 使用 Python turtle 绘制不同颜色的实心圆
- 使用 Python turtle 绘制棋盘的程序
- 使用蟒蛇龟绘制井字游戏棋盘
- 使用 Python 和 turtle 绘制汽车的程序
- 蟒蛇龟画字母
- 用巨蟒龟画彩虹苯
- 如何在 python turtle 中创建砖墙
如果你是 Python turtle 的新手，那么看看 Python 中的 Turtle 编程吧。
目录
- 如何在蟒蛇龟中绘制彩色填充形状？
- 如何使用 Python turtle 改变屏幕颜色？
- 如何在蟒蛇龟中绘制彩色填充半圆
- 在蟒蛇龟身上画彩色填充圆
- 如何在蟒蛇龟中绘制彩色填充椭圆
- 在蟒蛇龟身上画彩色填充方块
- 在蟒蛇龟中绘制彩色填充矩形
- 在蟒蛇龟中绘制彩色填充三角形
- 使用蟒蛇龟绘制彩色填充的星星
- 在蟒蛇龟中绘制彩色填充的六边形
- 用蟒蛇龟画一个不同颜色的实心圆
- 用 python 画棋盘的程序龟
- 用蟒蛇龟画一个井字游戏棋盘
- 用 python 画汽车龟的程序
- 蟒龟画字母
- 如何在 python turtle 中写文本
- 用蟒龟画彩虹苯
- 如何在 python 龟中创建砖墙
如何在蟒蛇龟中绘制彩色填充形状？
让我们来理解下面的步骤如何使用 Python turtle 用想要的颜色绘制彩色填充的形状
- 正如我们所知，turtle 是 python 中的内置模块，它使用屏幕和 turtle(笔)提供绘图。
- 为了在乌龟画的形状中填充想要的颜色，我们有一些函数。
- 我们将使用名为
fillcolor()的函数，并且要传递颜色名称或者是 #RRGGBB 格式的颜色。r、G 和 B 是十六进制数(0、1、2、3、4、5、6、7、8、9、A、B、C、D、E、F) - 现在，我们要调用函数
begin_fill()这个函数告诉乌龟，所有即将闭合的对象都需要用给定的颜色填充。 - 一旦我们完成了绘图，调用
end_fill()函数。这个函数告诉海龟停止填充即将到来的对象。
读取 Python 龟写函数
如何使用 Python turtle 改变屏幕颜色？
- 我们已经看到，默认情况下 turtle 总是以白色背景打开屏幕。但是让我们看看如何在 Python 中使用 turtle 改变屏幕颜色。
- 要想随时改变屏幕的颜色，首先我们需要导入 turtle ，然后我们可以使用命令
"turtle.bgcolor(*args)"。 - 以上方法用于设置龟屏的背景色。
举例:
import turtle
turtle.bgcolor("green")
turtle.done()
在下面的输出中，我们可以看到在新的绘图板中，屏幕颜色被更改为所需的绿色。
How to change the screen color in python turtle?
如何在蟒蛇龟中绘制彩色填充半圆
- 首先，我们需要导入海龟，然后我们可以通过声明创建海龟围栏。龟()。
- 我们将使用名为
tr.color()的函数，然后我们可以使用“tr . color(' black ')来设置颜色。 - 现在，我们要调用函数
tr.begin_fill()这个函数将开始填充半圆内部的颜色。另外，圆的半径为 130 像素，半–圆 180 度。 - 一旦我们完成了绘图，调用
tr.end_fill()函数。这个函数告诉乌龟结束颜色的填充。
举例:
import turtle
tr = turtle.Turtle()
tr.color("black")
tr.begin_fill()
tr.circle(130,180)
tr.end_fill()
tr.hideturtle()
turtle.done()
在这个输出中，我们可以看到在新的绘图板上绘制了彩色填充的半圆。它绘制了半径 130 像素的圆和一半–圆 180 度，内部填充黑色。你可以参考下面的截图。
How to draw colored filled half-circle in python turtle
在蟒蛇龟身上画彩色填充圆
让我们用 python 中的 turtle在 Python 中画一个彩色填充圆。
- 首先，我们需要导入海龟，然后我们可以通过声明创建海龟围栏。龟()。
- 我们将使用名为
fillcolor()的函数，然后我们可以使用 "tr.fillcolor('black') 来设置颜色。 - 现在，我们要调用函数
tr.begin_fill()这个函数将开始填充圆圈内部的颜色。 - 一旦我们完成了绘图，调用
tr.end_fill()函数。这个函数告诉乌龟结束颜色的填充。
举例:
import turtle
tr = turtle.Turtle()
tr.fillcolor('black')
tr.begin_fill()
tr.circle(100)
tr.end_fill()
turtle.done()
在这个输出中，我们可以看到彩色填充圆被绘制在新的绘图板上。画出半径为 100 个单位的圆，内部填充黑色。你可以参考下面的截图。
Draw colored filled circle in python turtle
如何在蟒蛇龟中绘制彩色填充椭圆
- 首先，我们需要导入海龟，然后我们可以通过声明“tr =海龟”来创建海龟笔。乌龟()。
tr.color()用于返回或填充颜色，tr.shape()用于设置给定形状的乌龟形状。- 现在，我们要调用函数
tr.begin_fill()这个函数将开始填充圆圈内部的颜色。 - 一旦我们完成了绘图，调用
tr.end_fill()函数。这个函数告诉乌龟结束颜色的填充。
举例:
import turtle
tr = turtle.Turtle()
tr.color("black")
tr.shape("circle")
tr.begin_fill()
tr.shapesize(10,5,2)
tr.end_fill()
turtle.done()
在这个输出中，我们可以看到在新的绘图板上绘制了彩色填充的椭圆形。 tr.shapesize(10，5，2) 用于绘制椭圆，10 是宽度，5 是长度，2 是椭圆的轮廓。
How to draw a colored filled oval in python turtle
在蟒蛇龟身上画彩色填充方块
让我们来讨论一下，如何用蟒龟画出彩色填充的 正方形。
- 首先，我们需要导入海龟，然后我们可以通过声明创建海龟围栏。龟()。
- 在这里，我们将使用
fillcolor()函数，然后我们可以使用 "tr.fillcolor('red') 来设置颜色。 - 现在，我们将调用函数
tr.begin_fill()这个函数将开始填充正方形内部的颜色。 - 为了绘制正方形，我们使用了向前()和向右()的方法。
- 一旦我们完成了颜色的填充，调用
tr.end_fill()函数。这个函数告诉乌龟结束颜色的填充。
举例:
import turtle
tr = turtle.Turtle()
tr.fillcolor('Red')
tr.begin_fill()
for i in range(4):
tr.forward(150)
tr.right(90)
tr.end_fill()
turtle.done()
在这个输出中，我们可以看到颜色被填充在新画板的正方形内。你可以参考下面的截图。
Draw colored filled square in python turtle
在蟒蛇龟中绘制彩色填充矩形
现在，我们将看到如何使用蟒蛇龟****绘制一个彩色填充矩形。
- 首先，导入 turtle 模块，然后我们可以通过声明创建 turtle pen。龟()。
- 这里，我们将使用
fillcolor()函数，然后我们可以使用 "tr.fillcolor('orange') 来设置颜色。 - 现在，我们将调用函数
tr.begin_fill()这个函数将开始填充矩形内的颜色。 - 为了绘制矩形，我们使用了循环，以及向前()和向右()的方法。
- 一旦我们完成了颜色的填充，调用
tr.end_fill()函数。这个函数告诉乌龟结束颜色的填充。
举例:
import turtle
tr = turtle.Turtle()
tr.fillcolor('orange')
tr.begin_fill()
for i in range(2):
tr.forward(250)
tr.right(90)
tr.forward(150)
tr.right(90)
tr.end_fill()
turtle.done()
在这个输出中，我们可以看到橙色填充了新窗口中的矩形。你可以参考下面的截图。
Draw colored filled rectangle in python turtle
在蟒蛇龟中绘制彩色填充三角形
让我们看看如何使用 Python turtle 绘制彩色填充三角形。
- 首先，导入 turtle 模块，然后我们可以通过声明创建 turtle pen。龟()。
- 这里，我们将使用
fillcolor()函数，然后我们可以使用 "tr.fillcolor('green') 来设置颜色。 - 现在，我们将调用函数
tr.begin_fill()这个函数将开始填充三角形内部的颜色。 - 我们使用了来循环，并且使用了
forward()和left()的方法来绘制一个三角形。 - 一旦我们完成了颜色的填充，调用
tr.end_fill()函数。这个函数告诉乌龟结束颜色的填充。
举例:
import turtle
tr = turtle.Turtle()
tr.fillcolor('green')
tr.begin_fill()
for i in range(3):
tr.forward(200)
tr.left(120)
tr.end_fill()
turtle.done()
在这个输出中，我们可以看到绿色填充在三角形内部，它将出现在新窗口中。你可以参考下面的截图。
Draw colored filled triangle in python turtle
使用蟒蛇龟绘制彩色填充的星星
让我们看看如何用 Turtle 在 Python 中绘制彩色填充的星星。
- 首先，导入 turtle 模块，然后我们可以通过声明创建 turtle pen。龟()。
- 这里，我们将使用
fillcolor()函数，然后我们可以使用 "tr.fillcolor('紫色')来设置颜色。 - 现在，我们将调用函数
tr.begin_fill()这个函数将开始填充星内部的颜色。 - 我们使用了来循环，并且还使用了向前()和向左()的方法来绘制星。
- 一旦我们完成了颜色的填充，调用
tr.end_fill()函数。这个函数告诉乌龟结束颜色的填充。
举例:
import turtle
tr = turtle.Turtle()
tr.fillcolor('purple')
tr.begin_fill()
for i in range(5):
tr.forward(250)
tr.left(144)
tr.end_fill()
turtle.done()
在这个输出中，我们可以看到紫色填充在星星内部，它将出现在新窗口中。
Draw colored filled star in python turtle
在蟒蛇龟中绘制彩色填充的六边形
让我们看看如何使用 Python 龟绘制彩色填充的六边形。
- 首先，导入 turtle 模块，然后我们可以通过声明创建 turtle pen。龟()。
- 这里，我们将使用
fillcolor()函数，然后我们可以使用 "tr.fillcolor('violet') 来设置颜色。 - 现在，我们将调用函数
tr.begin_fill()这个函数将开始填充六边形内部的颜色。 - 我们用来画循环，也用向前()和向左()的方法来画六边形。
- 一旦我们完成了颜色的填充，调用
tr.end_fill()函数。这个函数告诉乌龟结束颜色的填充。
举例:
import turtle
tr = turtle.Turtle()
tr.fillcolor('violet')
tr.begin_fill()
for i in range(6):
tr.forward(120)
tr.left(60)
tr.end_fill()
turtle.done()
在这个输出中，我们可以看到紫色填充了新窗口中的六边形。你可以参考下面的截图。
Draw colored filled hexagon in python turtle
用蟒蛇龟画一个不同颜色的实心圆
在这里，我们将看到如何使用 Python turtle 在圆形中填充不同的颜色。
- 首先，导入 turtle 模块，然后我们可以通过声明创建 turtle pen。龟()。
- 在这里，我们创建了一个不同颜色的列表，即 "list = ["violet "，" blue "，" red "，" green"]"。
- 同样，我们使用了
goto()方法来移动一段距离。 - for 循环将迭代 4 次以绘制一个 4 的圆。
- 现在，我们要调用函数
tr.begin_fill()这个函数将开始填充圆圈内部的颜色。 - 为了绘制半径为 50 的圆，我们使用了
tr.circle()函数。
举例:
import turtle
tr = turtle.Turtle()
list = ["violet","blue","red","green"]
tr.up()
tr.goto(200,0)
for i in range(4):
tr.down()
tr.begin_fill()
tr.fillcolor(list[i])
tr.circle(50)
tr.end_fill()
tr.up()
tr.backward(100)
tr.hideturtle()
turtle.done()
在这个输出中，我们可以看到不同的颜色被填充在新窗口的圆圈内。你可以参考下面的截图。
Draw filled circle with a different color using python turtle
用 python 画棋盘的程序龟
对于使用乌龟在 Python 中绘制棋盘的，我们将使用以下步骤:
- 首先我们要导入
turtle模块，然后我们会用SCR = turtle 创建一个屏幕对象。屏幕()"。 - 为了创建一个 turtle 对象，我们使用了 "tr = turtle。龟()"。
- 现在，我们将定义一个方法，使用 for 循环在给定范围内迭代来绘制一个正方形。
tr.forward(20)用于将乌龟向前移动 20 个单位，tr.left(90)用于将乌龟转动 90 度秒。该语句将重复 3 次以获得棋盘的剩余边界。 - 为了设置屏幕，我们使用了
**SCR . setup()方法，其中widht=600和height=600。tr.speed(100)是乌龟物体的速度，你也可以相应地改变速度。** - 然后另一个 for 循环将控制一行中一个正方形的绘制。因此，我们使用“tr . setpos(0，20 * I)”为每一行设置了位置。
- 同样，我们已经使用了 8 次 for 循环和可选颜色的 if 条件，可选颜色是【黑色】和【白色】。另外，
tr.fillcolor(col)将开始填充给定的颜色，tr.end_fill()将停止填充。**** - 最后，我们已经使用了
tr.hideturtle()来隐藏乌龟。
**举例:
import turtle
scr = turtle.Screen()
tr = turtle.Turtle()
def draw():
for i in range(4):
tr.forward(20)
tr.left(90)
tr.forward(20)
if __name__ == "__main__":
scr.setup(600, 600)
tr.speed(100)
for i in range(8):
tr.up()
tr.setpos(0, 20*i)
tr.down()
for j in range(8):
if(i + j)%2 == 0:
col = 'black'
else:
col = 'white'
tr.fillcolor(col)
tr.begin_fill()
draw()
tr.end_fill()
tr.hideturtle()
turtle.done()
在这个输出中，我们可以看到棋盘是在新窗口中绘制的。你可以参考下面的截图。
Program to draw a chessboard in python turtle
用蟒蛇龟画一个井字游戏棋盘
让我们看看如何在蟒蛇龟中画井字棋盘。
- 首先我们要导入
turtle模块，然后我们会用SCR = turtle 创建一个屏幕对象。屏幕()"。 - 为了创建一个 turtle 对象，我们使用了 "tr = turtle。龟()"。
- 然后设置乌龟颜色为【蓝色】，宽度为【3】。
- 在这里，我已经手动将乌龟的速度设置为“2”。
- 所以，为了画井字游戏棋盘，我们首先要画一个外部正方形，for 循环用于迭代。“tr . forward(300)”用于将乌龟向前移动 300 个单位，“tr . left(90)”用于将乌龟在中转动 90 度。
- 对于正方形的内部线条，我使用了
penup()、goto()和pendown()的方法。
举例:
import turtle
scr = turtle.Screen()
tr = turtle.Turtle()
tr.color("blue")
tr.width("3")
tr.speed(2)
for i in range(4):
tr.forward(300)
tr.left(90)
tr.penup()
tr.goto(0,100)
tr.pendown()
tr.forward(300)
tr.penup()
tr.goto(0,200)
tr.pendown()
tr.forward(300)
tr.penup()
tr.goto(100,0)
tr.pendown()
tr.left(90)
tr.forward(300)
tr.penup()
tr.goto(200,0)
tr.pendown()
tr.forward(300)
tr.hideturtle()
turtle.done()
在这个输出中，我们可以在新窗口中看到井字游戏棋盘。你可以参考下面的截图。
Draw a tic tac toe board in python turtle
用 python 画汽车龟的程序
让我们看看如何用 turtle 在 Python 中画一辆汽车
- 为了在巨蟒龟中画汽车，我们必须考虑汽车的形状和结构。汽车的上部将是一个长方形，轮胎可以画成圆形，车窗和车顶类似于梯形。
- 首先，我们必须导入
turtle模块，然后我们将创建一个 turtle 对象 "tr = turtle。龟()"。 - 现在，我们将使用“tr . color(# f62b 35 ')”、“tr . fill color(# f62b 35 ')”绘制一辆汽车的矩形上部车身，用于填充汽车中的颜色。
- 此外，我们还使用了
penup()、goto()、pendown()、setheading()方法来绘制汽车。 - 为了绘制轮胎，我们使用了
"tr.circle(20)"函数，为了在轮胎中填充颜色，我们使用了" tr . color(# 000000))"和" tr . fill color(# 000000 ')"。
举例:
import turtle
tr = turtle.Turtle()
tr.color('#f62b35')
tr.fillcolor('#f62b35')
tr.penup()
tr.goto(0,0)
tr.pendown()
tr.begin_fill()
tr.forward(370)
tr.left(90)
tr.forward(50)
tr.left(90)
tr.forward(370)
tr.left(90)
tr.forward(50)
tr.left(90)
tr.end_fill()
tr.penup()
tr.goto(100,50)
tr.pendown()
tr.setheading(45)
tr.forward(70)
tr.setheading(0)
tr.forward(100)
tr.setheading(-45)
tr.forward(70)
tr.setheading(90)
tr.penup()
tr.goto(200, 50)
tr.pendown()
tr.forward(49.50)
tr.penup()
tr.goto(100, -10)
tr.pendown()
tr.color('#000000')
tr.fillcolor('#000000')
tr.begin_fill()
tr.circle(20)
tr.end_fill()
tr.penup()
tr.goto(300, -10)
tr.pendown()
tr.color('#000000')
tr.fillcolor(#000000')
tr.begin_fill()
tr.circle(20)
tr.end_fill()
tr.hideturtle()
turtle.done()
在这个输出中，我们可以在新窗口中看到彩色填充的汽车。你可以参考下面的截图。
Program to draw a car in python turtle
蟒龟画字母
在这个例子中，我们将看到如何在 python turtle 中绘制字母
- 首先，导入 turtle 模块，然后我们可以通过声明创建 turtle pen。龟()。
- 在这里，我们使用了
. tr . color(" Blue ")和. tr . width(3)用于线条粗细。 - 为了打印字母“G”我们必须使用 for loop 来画一个半圆。向后()用于将笔向后移动 x 单位。
- 左侧()用于将笔向防抱死方向旋转 x 角度。
举例:
import turtle
ws = turtle.Screen()
tr = turtle.Turtle()
tr.color("Blue")
tr.width(3)
for x in range(180):
tr.backward(1)
tr.left(1)
tr.right(90)
tr.forward(50)
tr.right(90)
tr.forward(30)
tr.right(90)
tr.forward(50)
turtle.done()
在这个输出中，我们可以看到字母“G”被绘制在新窗口中。你可以参考下面的截图。
Python turtle draw letters
如何在 python turtle 中写文本
- 首先，导入 turtle 模块，然后我们可以通过声明创建 turtle pen。龟()。
- 这里，我们使用了tr . color(‘红色’)。 style=(fontname，fontsize，fonttype) 用于以给定的方式设置文本。
turtle.write()函数用于在当前 turtle 位置写入文本。- 为了隐藏海龟，我们使用了
" tr . hideturt()"
举例:
import turtle
tr = turtle.Turtle()
tr.color('red')
style = ('courier',30,'italic')
tr.write('Welcome to Python Turtle',font=style,align='center')
tr.hideturtle()
turtle.done()
在这个输出中，我们可以看到文本是如何在新窗口中书写的。你可以参考下面的截图。
How to write text in python turtle
用蟒龟画彩虹苯
- 首先，导入 turtle 模块，然后我们可以通过声明
tr = turtle . pen()来创建 turtle 对象。 - 我们设置屏幕背景色为‘黑色’，乌龟的速度为‘0’最快。
- 之后用于循环，范围为
180。 - tr.pencolor(colors[x%6]) 用于每一步的颜色。
- 这里，
tr.width(x/100 + 1)用于增加宽度，向左旋转 59 度。
举例:
import turtle
colors = ['purple', 'indigo', 'blue', 'green', 'yellow', 'orange']
tr = turtle.pen()
turtle.bgcolor('black')
tr.speed(0)
for x in range(180):
tr.pencolor(colors[x%6])
tr.width(x/100 + 1)
tr.forward(x)
tr.left(59)
turtle.done()
在这个输出中，我们可以在新窗口中看到彩虹苯。你可以参考下面的截图。
Draw rainbow benzene using python turtle
如何在 python 龟中创建砖墙
让我们看看如何在 python turtle 中创建砖墙
- 要在 python turtle 中创建一堵砖墙，我们必须先导入乌龟和屏幕。
- 这里，
Cursor_Size = 20用于画砖。 scr.setup(600，600) 用于设置屏幕尺寸。 - scr.setworldcoordinates(0，0，12，24) 用于设置基于砖块的用户自定义坐标。
- turtle . shapesize(25/Cursor _ Size，50 / Cursor_Size，5) 用来把光标变成砖块。
举例:
from turtle import Screen, Turtle
Cursor_Size = 20
scr = Screen()
scr.setup(600, 600)
scr.setworldcoordinates(0, 0, 12, 24)
scr.bgcolor('black')
turtle = Turtle('square', visible=False)
turtle.penup()
turtle.speed(10)
turtle.color('black', 'red')
turtle.shapesize(25 / Cursor_Size, 50 / Cursor_Size, 5)
for y in range(24):
turtle.setposition(-0.5 * (y % 2), y + 0.3)
for x in range(13):
turtle.stamp()
turtle.forward(1)
scr.mainloop()
在这个输出中，我们可以看到砖墙是在新窗口中创建的。你可以参考下面的截图。
How to create a brick wall in python turtle
您可能会喜欢以下 Python 教程:
- 使用 if-else 理解 Python 列表
- 蟒龟速度举例
- Python Tkinter Stopwatch
- Python 读取二进制文件
- 蟒蛇龟的颜色
- Python 要求用户输入
- 如何在蟒龟里做出笑脸
- 如何将 Python 字符串转换成字节数组并举例
- Python 通过引用或值传递示例
- Python 从列表中选择
- Python 复制文件
- Python 文件方法
在本教程中，我们已经学习了如何使用 turtle 在 python 中绘制彩色填充的形状，我们还看到了用 Python 编程的Turtle，我们还讨论了以下主题:
- 如何在 python turtle 中绘制彩色填充的形状？
- 如何在 python turtle 中改变屏幕颜色？
- 如何在蟒蛇龟中绘制彩色填充半圆
- 在蟒蛇龟中绘制彩色填充圆
- 如何在 python 海龟中绘制彩色填充椭圆
- 在蟒蛇龟中绘制彩色填充正方形
- 在蟒蛇龟中绘制彩色填充矩形
- 在蟒蛇龟中绘制彩色填充三角形
- 在蟒蛇龟中绘制彩色填充星
- 在蟒蛇皮海龟上绘制彩色填充六边形
- 使用 python turtle 绘制不同颜色的实心圆
- 用 python 画棋盘的程序龟
- 在蟒蛇龟中绘制井字游戏棋盘
- 用 python 画汽车的程序
- 蟒蛇龟画字母
- 如何在 python turtle 中编写文本
- 用巨蟒龟画彩虹苯
- 如何在 python turtle 中创建砖墙
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何在蟒蛇龟中画花
我们正在建立一个项目，在这个项目中，我们将在一只巨蟒龟的帮助下学习如何画一朵花。在这里，我们将拆分代码，解释如何使用函数和方法来绘制美丽的花朵。
在前进之前，我们应该有一些关于花的知识。
花是植物的一部分，也称为开花。这种花有令人愉快的气味和鲜艳的颜色。花由花瓣组成，它们生长在茎的顶端。
画花在蟒蛇龟上
现在我们正在向前推进，开始这个项目。这里我们只是导入下面两个 Python turtle 库。
from turtle import *
import turtle as tur
现在我们正在为这只乌龟创建一个对象。
tur = tur.Turtle()
在 python turtle 中，我们通过使用 turtle() 函数来设置花的初始位置。要设置位置，我们必须使用以下函数。
tur.penup()用于拿起笔，停止绘图。tur.left (90)用于向左移动乌龟。tur.fd (200)用于向前移动乌龟。tur.pendown()用于开始绘图。tur.right (90)用于向右移动乌龟。
tur.penup ()
tur.left (90)
tur.fd (200)
tur.pendown ()
tur.right (90)
现在我们正在用龟()函数制作一个花基。为了制作一朵花的美丽基底，我们使用了下面的函数。
tur.fillcolor ("red")用于填充花基部内部的颜色。tur.begin_fill ()用于开始填充颜色。- tur.circle (10，180) 用于绘制圆的形状。
tur.left (50)用于向左移动乌龟。tur.right (24)用于向右移动乌龟。tur.fd (30)用于向前移动乌龟。tur.end_fill ()用于停止填充颜色。
tur.fillcolor ("red")
tur.begin_fill ()
tur.circle (10,180)
tur.circle (25,110)
tur.left (50)
tur.circle (60,45)
tur.circle (20,170)
tur.right (24)
tur.fd (30)
tur.left (10)
tur.circle (30,110)
tur.fd (20)
tur.left (40)
tur.circle (90,70)
tur.circle (30,150)
tur.right (30)
tur.fd (15)
tur.circle (80,90)
tur.left (15)
tur.fd (45)
tur.right (165)
tur.fd (20)
tur.left (155)
tur.circle (150,80)
tur.left (50)
tur.circle (150,90)
tur.end_fill ()
在蟒蛇龟中，我们使用龟()功能来制作花朵的花瓣 1 。为了制作花瓣，我们使用了下面的函数。
tur.left (150)用于向左移动乌龟，使花瓣呈现完美的形状。- tur.circle (-90，70) 用于画圆。
tur.setheading (60)用于将乌龟的方位设置为角度。
tur.left (150)
tur.circle (-90,70)
tur.left (20)
tur.circle (75,105)
tur.setheading (60)
tur.circle (80,98)
tur.circle (-90,40)
现在我们使用 turtle() 函数来制作一朵花的花瓣 2 。为了制作一个花瓣，我们使用下面的函数。
tur.left (180)用于向左移动乌龟。- tur.circle (90，40) 用于绘制圆的形状。
tur.setheading (-83)用于将乌龟的方位设置为角度。
tur.left (180)
tur.circle (90,40)
tur.circle (-80,98)
tur.setheading (-83)
在 python turtle 中，我们使用了 turtle() 函数来制作一朵花的叶子 1 。为了制作一片叶子，我们使用下面的函数。
tur.fd (30)用于向前移动乌龟。tur.left (90)用于向左移动乌龟。- tur.fillcolor("深绿色")用于填充形状中的颜色。
tur.begin_fill ()用于开始填充颜色。- tur.circle (-80，90) 用于绘制圆形。
tur.right (90)用于向右移动乌龟。
tur.fd (30)
tur.left (90)
tur.fd (25)
tur.left (45)
tur.fillcolor ("dark green")
tur.begin_fill ()
tur.circle (-80,90)
tur.right (90)
tur.circle (-80,90)
tur.end_fill ()
tur.right (135)
tur.fd (60)
tur.left (180)
tur.fd (85)
tur.left (90)
tur.fd (80)
现在我们使用 turtle() 函数来制作一朵花的叶子 2 。为了制作一片叶子，我们使用下面的函数。
- t
ur.right (90)用于向右移动乌龟。 - tur.fillcolor("深绿色")用于填充形状中的颜色。
tur.begin_fill ()用于开始填充颜色。- tur.circle (80，90) 用于绘制圆形。
tur.left (90)用于向左移动乌龟。tur.end_fill ()用于结束填充颜色。
tur.fd (60) 用于向前移动乌龟。
tur.right (90)
tur.right (45)
tur.fillcolor ("dark green")
tur.begin_fill ()
tur.circle (80,90)
tur.left (90)
tur.circle (80,90)
tur.end_fill ()
tur.left (135)
tur.fd (60)
tur.left (180)
tur.fd (60)
tur.right (90)
tur.circle (200,60)
tur.done()
在这里，在拆分代码并解释我们如何使用 python turtle 制作一朵花之后，我们将看到运行整个代码后的输出是什么样子。
from turtle import *
import turtle as tur
tur = tur.Turtle()
tur.penup ()
tur.left (90)
tur.fd (200)
tur.pendown ()
tur.right (90)
tur.fillcolor ("red")
tur.begin_fill ()
tur.circle (10,180)
tur.circle (25,110)
tur.left (50)
tur.circle (60,45)
tur.circle (20,170)
tur.right (24)
tur.fd (30)
tur.left (10)
tur.circle (30,110)
tur.fd (20)
tur.left (40)
tur.circle (90,70)
tur.circle (30,150)
tur.right (30)
tur.fd (15)
tur.circle (80,90)
tur.left (15)
tur.fd (45)
tur.right (165)
tur.fd (20)
tur.left (155)
tur.circle (150,80)
tur.left (50)
tur.circle (150,90)
tur.end_fill ()
tur.left (150)
tur.circle (-90,70)
tur.left (20)
tur.circle (75,105)
tur.setheading (60)
tur.circle (80,98)
tur.circle (-90,40)
tur.left (180)
tur.circle (90,40)
tur.circle (-80,98)
tur.setheading (-83)
tur.fd (30)
tur.left (90)
tur.fd (25)
tur.left (45)
tur.fillcolor ("dark green")
tur.begin_fill ()
tur.circle (-80,90)
tur.right (90)
tur.circle (-80,90)
tur.end_fill ()
tur.right (135)
tur.fd (60)
tur.left (180)
tur.fd (85)
tur.left (90)
tur.fd (80)
tur.right (90)
tur.right (45)
tur.fillcolor ("dark green")
tur.begin_fill ()
tur.circle (80,90)
tur.left (90)
tur.circle (80,90)
tur.end_fill ()
tur.left (135)
tur.fd (60)
tur.left (180)
tur.fd (60)
tur.right (90)
tur.circle (200,60)
tur.done()
运行上面的代码后，我们得到下面的输出，我们可以看到屏幕上画了一朵美丽的花。
Draw a flower in python turtle
所以在这个项目中，我们展示了如何在巨蟒龟身上画一朵花。此外，我们还讨论了这个项目中使用的整个代码，这是非常有用的。
相关 Python 海龟教程:
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
绘制垂直线 matplotlib
在本 Python 教程中，我们将讨论在 Python 中画竖线matplotlibT5。在这里，我们将介绍使用 matplotlib 与垂直线相关的不同示例。我们还将讨论以下主题:
- 绘制垂直线 matplotlib
- 绘制垂直虚线 matplotlib
- Matplotlib 绘制带标签的垂直线
- Matplotlib 绘制多条垂直线
- 绘制垂直线 matplotlib 日期时间
- Matplotlib 在两点之间画垂直线
- 绘制垂直线段 matplotlib
- 在直方图 matplotlib 上绘制垂直线
目录
- 画垂直线 matplotlib
- 画垂直虚线 matplotlib
- Matplotlib 用标签画垂直线
- Matplotlib 绘制多条垂直线
- 绘制垂直线 matplotlib 日期时间
- Matplotlib 在两点之间画垂直线
- 绘制垂直线段 matplotlib
- 在直方图 matplotlib 上绘制垂直线
画垂直线 matplotlib
在本节中，我们将学习如何在 Python 的 matplotlib 中绘制垂直线。在开始这个话题之前，我们首先要了解什么是垂直线或者它看起来怎么样。
一般来说，垂直线是从上到下的直线，反之亦然。或者如果我们在坐标平面中说，一条平行于 Y 轴的线称为垂直线。
” Standing Line “
在 Python 中，matplotlib 是一个用于绘图的流行库。它提供了绘制垂直线的不同方法，我们将在下面讨论。
- 使用绘图()
- 使用 vlines()
- 使用 axvline()
通过使用 plot()方法
在 matplotlib 中， plot() 方法用于绘制 2D 图。
plot()方法的语法如下:
matplotlib.pyplot.plot(x_points, y_points)
上面使用的参数概述如下:
- x_points: 指定要绘图的 x 坐标点。
- y_points: 指定要绘图的 y 坐标点。
让我们看一个例子来清楚地理解这个概念:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data**
X = [0, 0]
Y = [5, 10]
**# Plot vertical line**
plt.plot(X,Y)
**# Show**
plt.show()
- 在上面的例子中，我们导入了
matplotlib.pyplot库。 - 之后，我们定义数据点进行绘图。这里我们指定 x 轴到
0，因为我们要画一条垂直线。 - 接下来，我们使用
plt.plot()方法绘制一条线，并使用plt.show()方法在用户屏幕上可视化绘图。
plt.plot()
通过使用 vlines()
在 matplotlib 中， vlines() 方法用于绘制穿过轴的垂直线。这里 vlines 代表垂直线。
vlines()方法的语法如下:
matplotlib.pyplot.vlines(x, ymin, ymax, colors, linestyles)
以上使用的参数为 ，描述如下:
- x: 指定 x 轴上绘制直线的位置。
- ymin 和 ymax: 指定每行的开始和结束。这些属性是强制性的。
- 颜色:指定线条的颜色。
- 线条样式:指定线条的样式或类型。
让我们看一个使用 vlines()方法创建的垂直线的例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Plot vertical line**
plt.vlines(9, 2, 3, color='red')
**# Show**
plt.show()
- 在上面的例子中，我们导入了
matplotlib.pyplot库。 - 通过使用
plt.vlines()方法我们绘制垂直线。这里我们传递x、ymin、ymax、color作为参数，并分别将其值设置为9、2、3、red。
plt.vlines()
通过使用 axvline()
在 matplotlib 中， axvline() 方法用于向绘图添加垂直线。
ax vline()方法的语法如下:
matplotlib.pyplot.axvline(x, ymin, ymax, color, linestyle)
上述使用的参数描述如下:
- x: 指定 x 轴上绘制直线的位置。
- ymin 和 ymax: 指定行的开始和结束范围。
- 颜色:指定线条的颜色。
- 线条样式:指定线条的样式或类型。
axv line()方法示例:
**# Import Library**
import matplotlib.pyplot as plt
**# Plot vertical line**
plt.axvline(x=3, ymin=0.25, ymax=0.75)
**# Show**
plt.show()
这里我们用 axvline() 的方法画一条垂直线，并将 x 、 ymin 、 ymax 作为参数，分别设置其值为 3 、 0.25 、 0.75 。
plt.axvline()
画垂直虚线 matplotlib
在这里我们将学习如何在 python 的 matplotlib 中绘制垂直虚线。我们必须改变线条的线条样式，使它们在样式上有点点。
Matplotlib.pyplot 库提供了参数 linestyle 来设置线的类型。
让我们来看一个垂直虚线的例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Plot vertical dotted line**
plt.axvline(x=5, ymin=0.25, color='red', linestyle='dotted', linewidth=5)
**# Show**
plt.show()
- 这里我们用
axvline()的方法画一条虚竖线。我们通过参数x、ymin、颜色、线型和线宽。 - 我们的主要目的是绘制一条本质上是虚线的垂直线，所以我们将线型设置为虚线，并通过使用线宽参数来增加线条的宽度。
” Dotted vertical line “
同样，阅读: Matplotlib 绘制一条线
Matplotlib 用标签画垂直线
在这一节，我们将学习如何用标签画垂直线。这里我们使用 axvline() 方法画一条垂直线，并将标签作为参数传递。
绘制 竖线的语法带标签:
matplotlib.pyplot.axvline(x, ymin, ymax, color, label)
举例:
**# Import Library**
import matplotlib.pyplot as plt
**# Plot vertical line**
plt.axvline(x=10, linewidth=5, label= 'vertical-line')
**# Add label**
plt.legend(loc = 'upper left')
**# Show**
plt.show()
- 通过使用
plt.axvline()方法我们画一条垂直线并传递参数标签。 - 然后通过使用
plt.legend()方法，我们将标签的位置设置为左上角的。
” Vertical line with label “
阅读: Python 使用 Matplotlib 绘制多条线
Matplotlib 绘制多条垂直线
这里我们要用 python 在 matplotlib 中创建多条竖线。用于创建多条垂直线的方法有:
- 使用 axvline()
- 使用 vlines()
通过使用 axvline()
在 matplotlib 中，通过使用 axvline() 方法，我们可以在绘图中创建多条垂直线。
我们来看一个与此相关的例子:
**# Import library**
import matplotlib.pyplot as plt
**# Vertical line 1**
plt.axvline(x = 5, color = 'b')
**# Vertical line 2**
**# We also set range of the line**
plt.axvline(x = 3, ymin = 0.2, ymax = 2, color='red')
**# Display**
plt.show()
” Multiple vertical lines “
通过使用 vlines()
在 matplotlib 中，通过使用 vlines() 方法，我们可以在绘图中创建多条垂直线。
举例:
**# Import library**
import matplotlib.pyplot as plt
**# Vertical line 1**
plt.vlines(x = 5, ymin = 1, ymax = 2, color = 'black')
**# Vertical line 2**
plt.vlines (x = 3, ymin = 1.98, ymax = 1.5, color='red')
**# Vertical line 3**
plt.vlines (x = [1, 2, 3] , ymin = 0.2, ymax = 0.6, color = 'orange')
**# Vertical line 4**
plt.vlines (x = 10, ymin = 0.2, ymax = 2, color='yellow')
**# Display**
plt.show()
plt.vlines()
阅读: Matplotlib 绘图条形图
绘制垂直线 matplotlib 日期时间
这里我们用 python 在 matplotlib 的 datetime plot 上画一条垂直线。
为此，首先你必须导入 datetime 库，然后通过使用 axvline() 或 vlines() 方法你可以画一条垂直线。
我们来看一个例子:
**# Import Library**
import matplotlib.pyplot as plt
import datetime
**# Vertical line**
plt.axvline(datetime.datetime.now())
**# Print date and time**
print(datetime.datetime.now())
**# Format date**
plt.gcf().autofmt_xdate()
**# Show**
plt.show()
在上面的例子中，我们使用:
- datetime.datetime.now() : 指定今天的日期和时间
- autofmt_xdate() : 自动合成 x 轴的日期。
” Vertical line on datetime plot “
阅读: Matplotlib 最佳拟合线
Matplotlib 在两点之间画垂直线
这里我们将学习如何在两个点或数据标记之间画一条垂直线。
让我们看一个用垂直线连接两点的例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Define data**
x = [2, 3, 4, 5]
y = [(2, 5), (1, 3), (6, 4), (2, 7)]
**# Plot**
plt.plot(x, [i for (i,j) in y], 'co', markersize = 7)
plt.plot(x, [j for (i,j) in y], 'mo', markersize = 7)
**# Vertical line**
plt.plot((x,x),([i for (i,j) in y], [j for (i,j) in y]),c='red')
**# Display**
plt.show()
- 首先，我们导入
matplotlib.pyplot库。之后，我们在 x 轴和 y 轴上定义数据。 - 然后我们使用
plt.plot()方法来绘制标记或点，这里我们传递x数据点，并使用进行循环来定义y数据点。 - 现在为了连接两个点，我们传递
x、y、颜色作为参数。这里我们设置 (x，x) 为 x 轴点，使用为循环连接 y 轴点。
plt.plot()
绘制垂直线段 matplotlib
在这里，我们将看到一个例子，我们在 matplotlib 的绘图中绘制了一个垂直线段。
举例:
**# Import Library**
import matplotlib.pyplot as plt
import numpy as np
**# Define Data**
x = np.arange(0, 15, 0.2)
y = np.sin(x)
**# Plot figure**
plt.plot(x, y)
**# Vertical line**
plt.axvline(x=7.9,color='red')
**# Title**
plt.title("Sine Function", fontsize= 15, fontweight='bold')
**# Generate Plot**
plt.show()
- 在上面的例子中，我们首先导入
matplotlib.pyplot和numpy库。 - 之后，我们使用
arange()和sin()方法定义数据。 - 通过使用
plt.plot()方法，我们绘制了一个图形。 - 然后用
axvline()方法画一条垂直线。这里我们将x和颜色作为参数传递。 plt.title()用于给情节添加标题，plt.show()方法用于在用户屏幕上显示情节。
” Vertical line segment in Sine Plot “
读取: Matplotlib 日志日志图
在直方图 matplotlib 上绘制垂直线
有时程序员想找到直方图条或函数的平均值。在这种情况下，我们需要直方图中的一条竖线来表示每个柱或函数的平均值。
首先，你必须知道如何创建一个直方图。让我们看看创建直方图的语法。
matplotlib.pyplot.hist(x, bins, color, edgecolor, ....)
让我们看一个在 直方图上画一条垂直线的例子:
**# Import Library**
import numpy as np
import matplotlib.pyplot as plt
**# Define data**
np.random.random()
x = np.random.gamma(15, 1.5, 50)
**# Plot histogram**
plt.hist(x, bins=10, color='m', edgecolor='k')
**# Vertical line**
plt.axvline(x.mean(), color='k', linestyle='dotted', linewidth=5)
**# Display**
plt.show()
- 在上面的例子中，我们导入了
matplotlib.pyplot和numpy包。 - 接下来，我们使用
random gamma()方法定义数据，这里我们将形状、比例和大小作为参数传递。 - 然后我们使用
plt.hist()方法为创建的样本数据绘制直方图。 - 通过使用
plt.axvline()方法，我们在定义的样本数据的平均值处画一条垂直线。
plt.hist()
另外，看看更多的 Matplotlib 教程。
- Matplotlib 虚线
- Matplotlib plot_date
- Matplotlib set _ yticklabels
- Matplotlib 3D scatter
- Matplotlib 散点图标记
- Matplotlib 移除刻度标签
- Matplotlib 旋转刻度标签
- Matplotlib 目前正在使用 agg 非 gui 后端
在本 Python 教程中，我们已经讨论了“绘制垂直线 matplotlib”，并且我们还涵盖了一些与之相关的例子。这些是我们在本教程中讨论过的以下主题。
- 绘制垂直线 matplotlib
- 绘制垂直虚线 matplotlib
- Matplotlib 绘制带标签的垂直线
- Matplotlib 绘制多条垂直线
- 绘制垂直线 matplotlib 日期时间
- Matplotlib 在两点之间画垂直线
- 绘制垂直线段 matplotlib
- 在直方图 matplotlib 上绘制垂直线
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何在 Django 中加密和解密密码
原文：https://pythonguides.com/encrypt-and-decrypt-password-in-django/
在本 Python Django 教程中，我们将学习 Django 中的加密和解密密码 。我们还会看到与此相关的例子。这些是我们将在本教程中讨论的以下主题
- 如何在 Django 中加密和解密密码
- 使用内置库在 Django 中加密和解密密码
- 不使用内置库在 Django 中加密和解密密码
目录
如何在 Django 中加密和解密密码
在学习如何在 Django 中加密和解密密码之前，我们先来了解一下什么是加密和解密。
加密:
- 将原始版本的数据转换成被称为密文的编码形式的方法被称为加密。
- 一旦完成，只有接收者可以将密文解密回原始形式。
- 这是将数据转换成不容易被未经授权的个人破译的格式的过程，对于保持系统安全至关重要。
- 这是一种安全和防欺诈技术，在信息通过互联网传输之前，它会自动分解并重新排序信息。
解密:
- 解密是将加密数据恢复到原始状态的过程。
- 这是加密过程的逆转。
- 它允许您解密加密数据，以便拥有正确密钥的授权用户可以访问它。
密码术:
- 加密和解密都包含在术语密码术中。
- 它是对数据进行加密和解密的过程，只有指定的接收者才能读取数据。
- 示例:考虑一个用户，他希望从 web 应用程序的前端将他们的密码保存在数据库中。虽然数据存储在数据库中，但有被非预期用户访问的危险。因此，它被加密，然后根据需要被解码。
Cryptography
在 Django 中，有两种加密和解密密码的方法。
- 使用图书馆
- 不使用图书馆
使用库
你所要做的就是导入 Django 内置的 django_cryptography 库来加密和解密你的密码。
不使用库
你所要做的就是创建加密和解密函数来加密和解密你的密码。
使用内置库在 Django 中加密和解密密码
在这一节中，我们将学习使用内置的加密库来加密和解密密码。
我们来看一个例子:
创建项目: 首先，我们需要构建一个 Django 项目。为此，请打开终端并键入以下命令。
django-admin startproject PythonGuides
- 这里的
PythonGuides是项目的名称。
Create Project
创建 App: 然后，我们需要构建一个 Django App 。为此，请打开终端并键入以下命令。
python manage.py startapp CryptoApp
Create App
创建模板: 在此之后，在项目根目录下，创建一个模板文件夹。并且我们在文件夹中制作 HTML 文件。
Templates
添加模板: 我们还需要在 settings.py 文件中添加模板目录。
'DIRS' = ['Templates']
Add Templates
安装 App: 以上创建的 App 必须包含在 settings.py 文件中。
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'CryptoApp',
]
- 这里，我们将
CryptoApp添加到Installed_Apps列表中。
创建模型: 在 models.py 文件中添加以下代码。
from django.db import models
class Login(models.Model):
email = models.EmailField()
password = models.CharField(max_length=10)
class Meta:
db_table="Login"
- 我们创建了具有两个字段的登录模型。
- 各自的字段是电子邮件和密码。
注册 型号:在 admin.py 文件中添加以下代码。
from django.contrib import admin
from .models import Login
admin.site.register(Login)
- 我们在管理站点上注册了登录模型。
加密密码: 在 Django 中加密一个密码，我们使用内置函数 make_password 。该方法将纯文本密码转换为可以存储在数据库中的哈希。
语法:
**# Import**
from django.contrib.auth.hashers import make_password
**# make_password function**
make_password(password)
# OR
make_password(password, None, hasher)
# OR
make_password(password, 'qwertyuiop', hasher)
哈希器:加密哈希函数是一种哈希算法。这是一个将任意大小的数据转换成固定大小的散列的数学过程。算法名称如下。
- sha1
- 讯息摘要 5
- 无盐 _sha1
- 无盐 _md5
- 地窖
- pbkdf2_sha256
- pbkdf2_sha1
- 氩气 2
默认情况下，PBKDF2 hasher 用于加密密码。
添加设置:在 settings.py 文件中添加以下密码哈希。
PASSWORD_HASHERS = [
'django.contrib.auth.hashers.PBKDF2PasswordHasher',
'django.contrib.auth.hashers.PBKDF2SHA1PasswordHasher',
'django.contrib.auth.hashers.Argon2PasswordHasher',
'django.contrib.auth.hashers.BCryptSHA256PasswordHasher',
'django.contrib.auth.hashers.BCryptPasswordHasher',
'django.contrib.auth.hashers.SHA1PasswordHasher',
'django.contrib.auth.hashers.MD5PasswordHasher',
'django.contrib.auth.hashers.UnsaltedSHA1PasswordHasher',
'django.contrib.auth.hashers.UnsaltedMD5PasswordHasher',
'django.contrib.auth.hashers.CryptPasswordHasher',
]
解密密码: Django 不提供任何内置的库或函数来解密加密的密码。因为解密密码从来都不是一个好主意。
我们不是解密哈希密码，而是将哈希密码与明文密码进行比较，并检查它们是否与哈希密码等效。用来检查的函数是 check_password。
语法:
from django.contrib.auth.hashers import check_password
check_password(password, hash password)
加密和解密密码的示例如下:
创建视图: 在 views.py 文件中添加以下代码。
from django.shortcuts import render, HttpResponse
from .models import Login
from django.contrib.auth.hashers import make_password, check_password
def login(request):
if request.method == 'POST':
email = request.POST['email']
encryptedpassword=make_password(request.POST['password'])
print(encryptedpassword)
checkpassword=check_password(request.POST['password'], encryptedpassword)
print(decryptedpassword)
data=Login(email=email, password=encryptedpassword)
data.save()
return HttpResponse('Done')
else:
return render(request, 'index.html')
- 这里导入
Django . contrib . auth . hashers的 Django 内置make_password和check_password函数。 - 然后，我们使用
make_password函数对密码进行加密，并在终端上打印出来。 - 之后，我们通过使用
check_password来检查加密密码和原始密码是否相同。
创建 HTML 模板:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Enter Employee</title>
</head>
<style>
table {
border: 8px outset;
border-radius: 10px;
border-spacing: 10px;
padding: 20px;
margin-left: auto;
margin-right: auto;
}
th,
td {
padding: 5px;
}
</style>
<body>
<h2 style="text-align:center"> Login Employee </h2>
<form method="POST">
{% csrf_token %}
<table style="width:50%" align="center">
<tr>
<td>Email</td>
<td><input type="email" placeholder="Enter Employee Email" name="email" </td>
</tr>
<tr>
<td>Password</td>
<td><input type="password" placeholder="Enter Employee Password" name="password" </td>
</tr>
<tr>
<td colspan="2" align="center"><input type="submit" class="btn btn-success"> </td>
</tr>
</table>
</form>
</body>
</html>
- 这里，我们创建一个 HTML 登录表单。
命令: 在终端上运行以下命令进行迁移。
# Make Migrations
python manage.py makemigrations
# Migrate
python manage.py migrate
运行服务器: 在终端中键入以下命令。
python manage.py runserver
绕过浏览器地址栏中的 http://127.0.0.1:8000/login 运行开发服务器。
- 输入您的电子邮件和密码。
Login Form
当我们点击提交按钮时，HttpResponse 打印出来。
HTTP Response
查看密码如何保存在管理员的网站。
Admin Site
散列密钥和 check_function 的结果打印在终端上。
Terminal
阅读: Python Django 与 Flask–主要区别
不使用内置库在 Django 中加密和解密密码
在这一节中，我们将学习在不使用内置加密库的情况下加密和解密密码。
我们来看一个例子:
创建项目: 首先，我们需要构建一个 Django 项目。打开终端并键入以下命令。
djnago-admin startproject PythonGuides
这里，PythonGuides 是项目名称。
创建 App: 在此之后，我们需要建立一个 Django App 。打开终端并键入以下命令。
python manage.py startapp home
这里，home 是 app 名称。
创建模板: 之后，模板文件夹被创建。并且我们在文件夹中添加 HTML 文件。
添加模板: 然后，在 settings.py 文件中添加上面创建的模板目录。
'DIRS' = ['Templates']
安装 APP: 上面创建的 app 【首页】必须包含在 settings.py 文件中。
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'home',
]
项目 URL: 在项目的 urls.py 文件中，添加下面的代码来包含 home.urls 的路径
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path('',include('home.urls')),
]
App URL: 首先，我们必须在 App 目录下创建一个名为 urls.py 的文件来定义各个视图的路径。
from django.urls import path
from . import views
urlpatterns = [
path('', views.register, name='register'),
]
安装依赖: 使用以下命令安装 Python 加密模块。
pip install cryptography
加密密钥: 必须生成加密密钥，为此打开终端并键入以下命令。
from cryptography.fernet import Fernet
Fernet.generate_key()
- 首先，我们导入
Fernet。 - 然后，使用
generate_key()函数生成密钥。
Encryption Key
添加密钥: 将上面生成的密钥添加到 settings.py 文件中。
ENCRYPT_KEY = b'tmzHcYuvLUhxjcxZ4k_iqfCx-HUq6PCvdbXr4vOC5B4='
创建模型: 在 models.py 文件中添加以下代码。
from django.db import models
class EmpLogin(models.Model):
name = models.CharField(max_length=200)
email = models.EmailField()
password = models.CharField(max_length=8)
class Meta:
db_table="EmpLogin"
- 我们用五个字段创建了
EmpLogin模型。 - 各自的字段是姓名、电子邮件和密码。
注册型号: 在 admin.py 文件中添加以下代码。
from django.contrib import admin
from .models import EmpLogin
admin.site.register(EmpLogin)
- 为了在管理站点上注册
EmpLogin模型，我们使用带有模型名称的admin.site.register()函数。
创建加解密函数: 在 home app 中创建一个 encrypt_util.py 文件。
from cryptography.fernet import Fernet
import base64
import logging
import traceback
from django.conf import settings
def encrypt(pas):
try:
pas = str(pas)
cipher_pass = Fernet(settings.ENCRYPT_KEY)
encrypt_pass = cipher_pass.encrypt(pas.encode('ascii'))
encrypt_pass = base64.urlsafe_b64encode(encrypt_pass).decode("ascii")
return encrypt_pass
except Exception as e:
logging.getLogger("error_logger").error(traceback.format_exc())
return None
def decrypt(pas):
try:
pas = base64.urlsafe_b64decode(pas)
cipher_pass = Fernet(settings.ENCRYPT_KEY)
decod_pass = cipher_pass.decrypt(pas).decode("ascii")
return decod_pass
except Exception as e:
logging.getLogger("error_logger").error(traceback.format_exc())
return None
- 我们创建一个加密和解密函数来加密和解密密码。
- 我们使用
urlsafe，base64来转换加密的数据。 - 如果在加密和解密时出现错误，记录它并返回 null。
创建视图: 在 views.py 文件中添加以下代码。
from django.shortcuts import render
from django.http import HttpResponse
from. models import EmpLogin
from home.encrypt_util import *
def register(request):
if request.method == 'POST':
name = request.POST['name']
email = request.POST['email']
password = request.POST['password']
print('Original Password:', request.POST['password'])
encryptpass= encrypt(request.POST['password'])
print('Encrypt Password:',encryptpass)
decryptpass= decrypt(encryptpass)
print('Decrypt Password:',decryptpass)
data=EmpLogin(name=name, email=email, password=password)
data.save()
return HttpResponse('Done')
else:
return render(request, 'index.html')
- 在这里，我们创建一个注册视图。
- 视图接收用户输入的名称、电子邮件和密码。
- 然后，我们打印出原始密码、加密密码和解密密码。
- 它还显示成功输入数据后的 HttpResponse Done。
创建 HTML 文件: 将下面的代码添加到 index.html 文件中。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Enter Employee</title>
</head>
<style>
table {
border: 8px outset;
border-radius: 10px;
border-spacing: 10px;
padding: 20px;
margin-left: auto;
margin-right: auto;
}
th,
td {
padding: 5px;
}
</style>
<body>
<h2 style="text-align:center"> Enter Details of Employee </h2>
<form method="POST">
{% csrf_token %}
<table style="width:50%" align="center">
<tr>
<td>Employee Name</td>
<td><input type="text" placeholder="Enter Employee Name" name="name" </td>
</tr>
<tr>
<td>Email</td>
<td><input type="email" placeholder="Enter Employee Email" name="email" </td>
</tr>
<tr>
<td>Password</td>
<td><input type="password" placeholder="Enter Employee Password" name="password" </td>
</tr>
<tr>
<td colspan="2" align="center"><input type="submit" class="btn btn-success"> </td>
</tr>
</table>
</form>
</body>
</html>
- 这里，我们创建一个表单来接收用户的输入。
基本命令: 在终端上运行以下基本命令。
# Make Migrations
python manage.py makemigrations
# Migrate
python manage.py migrate
# Run Server
python manage.py runserver
输出: 绕过浏览器地址栏的 http://127.0.0.1:8000/运行开发服务器。
Enter Details
Details
输入详细信息后，点击提交按钮。
HTTP Response
现在，打开终端，看到原始密码，加密解密密码。
Password Encryption and Decryption
您可能也喜欢阅读下面的 Python Django 教程。
- 如何从 Django 的 get 请求中获取数据
- Python Django 中网站的简单联系方式
- Python Django 连接字符串
- 如何删除 Django 中的会话属性
- Django 从 POST 请求中获取所有数据
- 如何获取 Django 的当前时间
- 如何在 Django 中创建模型
在本教程中，我们已经讨论了 Django 中的“如何加密和解密密码 ”，我们还讨论了本教程中的以下主题。
- 如何在 Django 中加密和解密密码
- 使用内置库在 Django 中加密和解密密码
- 不使用内置库在 Django 中加密和解密密码
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Python 中的转义序列
在本 python 教程中，我们将讨论 Python 中的转义序列。我们还将检查:
- 转义序列是什么？
- 如何在 python 中转义单引号
- Python 转义序列 n
- Python 转义序列反斜杠
- Python 空间转义序列
- 用于退格的 Python 转义序列
- 六进制值的 Python 转义序列
- 八进制值的 Python 转义序列
- 从一个字符串列表中删除所有转义序列
- 空间 python 的转义字符
- Python 转义序列忽略
- Python 转义序列删除
目录
- 转义序列是什么？
- 如何在 Python 中转义单引号
- Python 转义序列 n
- Python 转义序列反斜杠
- Python 空间转义序列
- Python 转义序列退格
- 六进制值的 Python 转义序列
- 八进制值的 Python 转义序列
- 从列表中删除所有转义序列
- 空间 python 的转义符
- Python 转义序列忽略
- Python 转义序列删除
转义序列是什么？
- 转义序列是一个特殊的字符，以反斜杠() 的形式使用，后跟一个必需的字符。
- 这些字符用于表示空白。
- 空白给出了像空格、制表符、换页符、垂直制表符这样的字符。
| 转义序列 | 意为 |
| ' | 这代表一个单引号 |
| \n | 这代表换行符 |
| \r | 这表示回车 |
| \t | 这代表一个选项卡 |
| \b | 这表示退格 |
| \f | 这代表一个换页 |
| \ooo | 这代表一个八进制值 |
| \xhh | 这表示一个十六进制值 |
| \ | 这代表一个反斜杠 |
| \uxxxx | 这代表 16 位十六进制值 |
| \uxxxxxxxx | 这代表 32 位十六进制值 |
Escape sequence in python
如何在 Python 中转义单引号
让我们来看一个在 Python 中对单引号进行转义的例子，我们可以看到如何在 Python 中的字符串中使用 ' 单引号。
示例:
string = 'That\'s my bag.'
print(string)
下面的截图显示单引号用于单词，即。
escape single quotes in Python
Python 转义序列 n
让我们看一个 Python 转义序列 n 的例子，我使用了一个 "\n" 换行符。换行符用于将单词写在新的单独一行中。
示例:
string = "python\n guides"
print(string)
你可以参考下面的输出截图，你可以看到在新的单独一行的话。
Python escape sequence n
Python 转义序列反斜杠
让我们来看一个 Python 转义序列反斜杠的例子。反斜杠是一个转义序列， \ 用来打印一个反斜杠。
示例:
string = "python\\ guides"
print(string)
您可以参考下面的输出截图:
Python escape sequence backslash
Python 空间转义序列
在这个例子中，我使用了 "\t" 字符来获取单词之间的空格。
示例:
string = "python\tguides"
print(string)
你可以参考下面的输出截图，我们可以看到单词 python 和 guides 之间的空间。
Python escape sequence for space
Python 转义序列退格
在这个例子中，我使用了 "\b" 来删除 Python 中单词之间的空格。
示例:
string = "python \bguides"
print(string)
您可以在下面的截图中看到输出。
Python escape sequence backspace
六进制值的 Python 转义序列
让我们来看一个关于 hexa 值的 Python 转义序列的例子，我已经使用了 \x hh 将 Hexa 值转换成一个字符串。
示例:
string = "\x50\x59\x54\x48\x4f\x4E \x47\x55\x49\x44\x45\x53"
print(string)
在下面的屏幕截图中，我们可以看到转换后的字符串。
八进制值的 Python 转义序列
让我们检查一个八进制值的 Python 转义序列的例子，我已经使用了 \ooo 将八进制值转换成一个普通的字符串。
示例:
string = "\120\131\124\110\117\116 \107\125\111\104\105\123"
print(string)
您可以参考下面的输出截图:
Octal value
从列表中删除所有转义序列
在这个例子中，我使用了 '\x50' ,通过将十六进制值转换为字符串来删除所有转义序列，并且' \x20 '表示空格。
示例:
x = ['welcome','\x50', 'to' '\x20','python','guides']
print(x)
在下面的截图中，我们可以看到 Hexa 值 '\x50' 转换为 'p' ， '\x20' 转换为空间的输出。
Remove all escape sequence from all a list in a string
空间 python 的转义符
在这个例子中，我在单词之间使用了 \t 来获得空格。
示例:
string = "python\tguides"
print(string)
在这个输出中，我们可以看到单词之间的空格。
Escape character for space python
Python 转义序列忽略
为了忽略字符串中的转义序列，我们必须将 r 放在字符串前面，使字符串成为原始字符串。
示例:
string = r'python guides'
print(string)
你可以参考下面的输出截图。在这个输出中，我们可以看到原始语句被忽略了。
Python escape sequence ignore
Python 转义序列删除
在这个例子中，我使用了 string.split() 来删除参数左边和右边的字符。
string = '\r\r\b pythonguides \r\r\n\b '
string.strip
print(string)
您可以参考下面的输出截图:
Python escape sequence remove
您可能会喜欢以下 Python 教程:
- Python 列表理解λ
- Python 线程和多线程
- 如何将 Python 角度转换为弧度
- Python 比较运算符
- Python 命名空间教程
- Python Tkinter 帧
- 如何用 Python 制作矩阵
- Python 中的链表
- Python 要求用户输入
在本 Python 教程中，我们学习了 python 中的转义序列。此外，我们还讨论了以下主题:
- 转义序列是什么？
- 如何在 python 中转义单引号
- Python 转义序列 n
- Python 转义序列反斜杠
- Python 空间转义序列
- 用于退格的 Python 转义序列
- 六进制值的 Python 转义序列
- 八进制值的 Python 转义序列
- 从一个字符串列表中删除所有转义序列
- 空间 python 的转义字符
- Python 转义序列忽略
- Python 转义序列删除
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
使用 Python Tkinter 的费用跟踪应用程序
原文：https://pythonguides.com/expense-tracking-application-using-python-tkinter/
最近，我们需要创建一个桌面应用程序来跟踪个人的支出。因此，我们使用带有 sqlite3 数据库的 python tkinter 创建了这个费用跟踪应用程序。
SQLite3 是 python 自带的免费数据库软件。以下命令显示了如何导入 SQLite3 模块:
import sqlite3
目录
使用 Python 的费用跟踪应用程序
在本节中，我们解释了如何使用 python tkinter 创建应用程序的接口。整个代码分为 12 个部分，对于每个部分，我们都在粗体注释中提到了描述。
1。导入模块
创建应用程序的第一步是导入必要的模块。这里我们已经导入了 tkinter (*)中所有可用的模块。TTK 是 tkinter 家族的新成员，需要单独导入。最后我们导入了一个消息框模块来显示提示。
2。创建对象、标题和窗口大小
下一步是为 tkinter 模块创建一个对象。在代码中， ws 是分配给对象的名称。使用这个对象名，我们进一步为 python tkinter 窗口分配了一个标题和大小。
了解更多关于 Python Tkinter Title
3。无限循环
代码最后一行中使用的主循环为用户保留屏幕。由于主循环，用户可以看到窗口并与之交互。在后台，一个窗口出现，然后在几微秒内消失。Mainloop 无限期重复该过程，因此会出现一个包含更新更改的新屏幕。
4。全局变量
我们将它们命名为全局变量，因为我们将在程序的不同部分使用这些变量。我们意识到在一个程序中为所有的部件放置相同的字体，这就是为什么字体名称和大小的值存储在一个简单的字母中。后来用这个字母给申请文本分配字体。
amtvar = IntVar()
dopvar = StringVar()
这两个是文本变量，一个是整数数据类型，用于存储购买金额，另一个是字符串，用于记录购买日期。
5。框架部件
python tkinter 中的 frame 小部件用于存放其他小部件，通过移动容器小部件(frame ),可以方便地移动一组小部件。
创建了两个名为 、f1 和 f2 的帧，这两个帧都是使用 pack geometry manager 定位的。在 python tkinter 中， f1 框架包含除 Treeview 和 scrollbar 小部件之外的所有小部件。这两个小部件放置在 f2 框架上。
6。标签小工具，7。入口小部件，8 个入口网格位置
python tkinter 中的标签小部件用于在应用程序窗口上显示文本。商品名称、商品价格和购买日期是该应用程序中使用的标签。
python tkinter 中的入口小部件允许用户通过在矩形框中键入来提供输入。我们已经使用网格几何管理器将所有小部件放置在 f1 框架小部件中。
9。动作按钮，10 个按钮网格放置
动作按钮用在应用程序窗口中，每次在应用程序窗口中单击它们时，都会执行或触发一个功能。到目前为止，我们已经在应用程序中创建了 6 种类型的按钮。
- 保存记录
- 清除输入
- 出口
- 总余额
- 更新
- 删除
11。Treeview 查看记录
Treeview 用于以有组织的表格格式显示记录的输出。树形视图的创建有三个部分。首先，我们创建了一个 Treeview，然后添加了一个标题或列，在使用样式后，我们改进了它的外观和感觉。
12. Scrollbar widget
垂直滚动条被添加到 Treeview 小部件中，这样，如果数据超出了屏幕的大小，用户仍然可以通过上下滚动来查看数据。
**#1 import modules**
from tkinter import *
from tkinter import ttk
from tkinter import messagebox
**#2 create object, title and window size**
ws = Tk()
ws.title('Office Expense')
# ws.geometry('600x400')
**#4 global variables**
f = ('Times new roman', 14)
amtvar = IntVar()
dopvar = StringVar()
**#5 frame** `widgets`
f2 = Frame(ws)
f2.pack()
f1 = Frame(
ws,
padx=10,
pady=10,
)
f1.pack(expand=True, fill=BOTH)
**#6 Label Widget**
Label(f1, text='ITEM NAME', font=f).grid(row=0, column=0, sticky=W)
Label(f1, text='ITEM PRICE', font=f).grid(row=1, column=0, sticky=W)
Label(f1, text='PURCHASE DATE', font=f).grid(row=2, column=0, sticky=W)
**#7 Entry Widgets**
item_name = Entry(f1, font=f)
item_amt = Entry(f1, font=f, textvariable=amtvar)
transaction_date = Entry(f1, font=f, textvariable=dopvar)
**#8 Entry grid** `placement`
item_name.grid(row=0, column=1, sticky=EW, padx=(10, 0))
item_amt.grid(row=1, column=1, sticky=EW, padx=(10, 0))
transaction_date.grid(row=2, column=1, sticky=EW, padx=(10, 0))
**#9 Action buttons**
cur_date = Button(
f1,
text='Current Date',
font=f,
bg='#04C4D9',
command=None,
width=15
)
submit_btn = Button(
f1,
text='Save Record',
font=f,
command=None,
bg='#42602D',
fg='white'
)
clr_btn = Button(
f1,
text='Clear Entry',
font=f,
command=None,
bg='#D9B036',
fg='white'
)
quit_btn = Button(
f1,
text='Exit',
font=f,
command=None,
bg='#D33532',
fg='white'
)
total_bal = Button(
f1,
text='Total Balance',
font=f,
command=None
)
total_bal = Button(
f1,
text='Total Balance',
font=f,
bg='#486966',
fg='white',
command=None
)
total_spent = Button(
f1,
text='Total Spent',
font=f,
fg='white',
command=None
)
update_btn = Button(
f1,
text='Update',
bg='#C2BB00',
command=None,
fg='white',
font=f
)
del_btn = Button(
f1,
text='Delete',
bg='#BD2A2E',
fg='white',
command=None,
font=f
)
**#10 Button grid placement**
cur_date.grid(row=3, column=1, sticky=EW, padx=(10, 0))
submit_btn.grid(row=0, column=2, sticky=EW, padx=(10, 0))
clr_btn.grid(row=1, column=2, sticky=EW, padx=(10, 0))
quit_btn.grid(row=2, column=2, sticky=EW, padx=(10, 0))
total_bal.grid(row=0, column=3, sticky=EW, padx=(10, 0))
update_btn.grid(row=1, column=3, sticky=EW, padx=(10, 0))
del_btn.grid(row=2, column=3, sticky=EW, padx=(10, 0))
**#11 treeview to view the record**
tv = ttk.Treeview(f2, selectmode='browse', columns=(1, 2, 3, 4), show='headings', height=8, )
tv.pack(side="left")
tv.column(1, anchor=CENTER, stretch=NO, width=70)
tv.column(2, anchor=CENTER)
tv.column(3, anchor=CENTER)
tv.column(4, anchor=CENTER)
tv.heading(1, text="Serial no")
tv.heading(2, text="Item Name", )
tv.heading(3, text="Item Price")
tv.heading(4, text="Purchase Date")
style = ttk.Style()
style.theme_use("default")
style.map("Treeview")
**#12 scrollbar widget**
scrollbar = Scrollbar(f2, orient='vertical')
scrollbar.configure(command=tv.yview)
scrollbar.pack(side="right", fill="y")
tv.config(yscrollcommand=scrollbar.set)
**#3 infinite loop**
ws.mainloop()
另外，查看: Python Tkinter Canvas 教程
应用程序的后端解释
在本节中，我们将向您解释与使用 python tkinter 和 sqlite3 数据库创建的 expense manager 应用程序中的数据库相关的所有源代码。
我们已经创建了一个具有必要方法的类来执行 CRUD 操作，稍后该类将在程序中使用 python tkinter 查看、插入、更新和删除 sqlite3 数据库中的数据。
1 模块
已经导入了 SQLite3 模块来执行与数据库相关的所有活动。
2。类、构造函数和方法
我们创建了一个名为 数据库 的类，这个类有执行 CRUD 操作的方法。def __init__(self, db)之后的代码是一个构造函数，它接受一个数据库名作为参数，如果还不存在，它还创建一个名为 expense_record 的表。
fetchRecord()方法允许用户编写一个 SQL 查询来获取信息。insertRecord()方法在数据库中添加数据。removeRecord()方法从数据库中删除现有数据。updateRecord()方法允许更新数据库中的更改。
我们将它创建为一个单独的模块，名为 mydb.py ，这样用户就可以将这个模块导入到主程序中，如下一节所示。
**#1 module**
import sqlite3
**#2 class, constructor and methods**
class Database:
def __init__(self, db):
self.conn = sqlite3.connect(db)
self.cur = self.conn.cursor()
self.cur.execute(
"CREATE TABLE IF NOT EXISTS expense_record (item_name text, item_price float, purchase_date date)")
self.conn.commit()
def fetchRecord(self, query):
self.cur.execute(query)
rows = self.cur.fetchall()
return rows
def insertRecord(self, item_name, item_price, purchase_date):
self.cur.execute("INSERT INTO expense_record VALUES (?, ?, ?)",
(item_name, item_price, purchase_date))
self.conn.commit()
def removeRecord(self, rwid):
self.cur.execute("DELETE FROM expense_record WHERE rowid=?", (rwid,))
self.conn.commit()
def updateRecord(self, item_name, item_price, purchase_date, rid):
self.cur.execute("UPDATE expense_record SET item_name = ?, item_price = ?, purchase_date = ? WHERE rowid = ?",
(item_name, item_price, purchase_date, rid))
self.conn.commit()
def __del__(self):
self.conn.close()
功能及其他操作说明
在本节中，我们将讨论除 GUI 和数据库之外的源代码部分。我们将讨论以下事情:
1。模块
在上一节中，我们已经创建了一个名为 mydb.py 的模块，这里已经导入了那个模块及其所有的函数。使用其中的方法，我们可以在 python tkinter 中插入、更新、查看和删除数据库中的数据。
2。数据库的对象
我们为类数据库创建了一个对象，并将该对象命名为 数据 。此外，该对象接受一个参数，该参数将是数据库的名称。我们已经提供了 myexpense.db ，但是您提供的任何名称都带有扩展名 db 。
请注意，您通过在此处提供名称来加载现有数据库，但是该数据库必须具有相同的列。
3。全局变量
在函数内创建的变量只在该函数内有作用域。全局变量可以通过程序访问，它们的值会受到任何点上所做的更改的影响。
*count=0*在程序稍后向树形视图中插入数据时使用。在这里，我们增加了计数的值，这样 iid 每次都可以有一个唯一的值。- SQLite3 的一个特性是自动维护名为 row id 的惟一行 id，在从数据库中获取数据时需要提到这个行 id
select rowid, * from expense_record;
这个 rowid 在应用程序的 GUI 界面中显示为一个序列号。我们在全局变量 selected_rowid 中存储了用户在界面上选择的行的序号。
现在，由于我们有一个用户选择的行的，我们已经把它放在更新和删除函数的 where 子句中。
*4。功能
让我们讨论一下这个应用程序中使用的函数。请注意，这些函数不是数据库类函数。这些主要集中在使用那些方法上。
saveRecord() 是使用数据库类的 insertRecord() 方法来存储数据库中的数据。我们已经传递了从入口小部件获取的所需参数。该功能由 python tkinter 中的 submit_btn 按钮触发。
setDate()函数使用系统中的日期，并以日、月和年的格式将其设置在入口小部件上。- 函数的作用是:清除所有的入口部件。它使用 delete 方法并提供开始和结束值来移除它。该功能由
clr_btn按钮触发。 fetch_records()函数使用数据库类中的*fetchRecord* ()方法从数据库中检索 rowid 和其他信息。获取数据后，它以表格格式在 Treeview 小部件上发布数据。select_record()函数与树形视图上的行选择相关。每当用户单击任何一行时，这个函数都会被触发，因为它是与鼠标单击绑定的。这个函数负责将 rowid 存储在全局变量中。
这个方法在入口小部件上打印选中的行，这些小部件可以进一步更新。update_record()函数更新数据库中的现有信息。它使用数据库类中的 updaRecord()方法。total_balance()函数显示弹出消息，显示总消费金额和剩余金额。默认情况下，提供 5000 英镑作为基数，您可以根据自己的预算进行更改。refreshData()是另一个重要的方法，因为它允许用户实时查看更新。在插入、更新和删除数据时，我们必须在最后执行刷新操作，以便实时显示变化。
如果我们不使用这个功能，我们每次都必须重启应用程序来查看更改。deleteRow()函数从数据库中删除选中的行，刷新函数立即显示更改。假设用户选择了一行，然后点击了删除按钮。
该函数将从数据库中删除该条目，由于该条目已从数据库中删除，该行将在自动刷新后消失。
**#1\. module**
from mydb import *
**#2\. object for database**
data = Database(db='myexpense.db')
**#3\. global variables**
count = 0
selected_rowid = 0
**#4\. functions**
def saveRecord():
global data
data.insertRecord(item_name=item_name.get(), item_price=item_amt.get(), purchase_date=transaction_date.get())
def setDate():
date = dt.datetime.now()
dopvar.set(f'{date:%d %B %Y}')
def clearEntries():
item_name.delete(0, 'end')
item_amt.delete(0, 'end')
transaction_date.delete(0, 'end')
def fetch_records():
f = data.fetchRecord('select rowid, * from expense_record')
global count
for rec in f:
tv.insert(parent='', index='0', iid=count, values=(rec[0], rec[1], rec[2], rec[3]))
count += 1
tv.after(400, refreshData)
def select_record(event):
global selected_rowid
selected = tv.focus()
val = tv.item(selected, 'values')
try:
selected_rowid = val[0]
d = val[3]
namevar.set(val[1])
amtvar.set(val[2])
dopvar.set(str(d))
except Exception as ep:
pass
def update_record():
global selected_rowid
selected = tv.focus()
# Update record
try:
data.updateRecord(namevar.get(), amtvar.get(), dopvar.get(), selected_rowid)
tv.item(selected, text="", values=(namevar.get(), amtvar.get(), dopvar.get()))
except Exception as ep:
messagebox.showerror('Error', ep)
# Clear entry boxes
item_name.delete(0, END)
item_amt.delete(0, END)
transaction_date.delete(0, END)
tv.after(400, refreshData)
def totalBalance():
f = data.fetchRecord(query="Select sum(item_price) from expense_record")
for i in f:
for j in i:
messagebox.showinfo('Current Balance: ', f"Total Expense: ' {j} \nBalance Remaining: {5000 - j}")
def refreshData():
for item in tv.get_children():
tv.delete(item)
fetch_records()
def deleteRow():
global selected_rowid
data.removeRecord(selected_rowid)
refreshData()
main . py 的完整源代码
下面的源代码是使用 python tkinter 创建的应用程序。以 main.py 的名称保存这个文件，并执行它来运行这个完整的应用程序。
**# import modules**
from tkinter import *
from tkinter import ttk
import datetime as dt
from mydb import *
from tkinter import messagebox
**# object for database**
data = Database(db='test.db')
**# global variables**
count = 0
selected_rowid = 0
**# functions**
def saveRecord():
global data
data.insertRecord(item_name=item_name.get(), item_price=item_amt.get(), purchase_date=transaction_date.get())
def setDate():
date = dt.datetime.now()
dopvar.set(f'{date:%d %B %Y}')
def clearEntries():
item_name.delete(0, 'end')
item_amt.delete(0, 'end')
transaction_date.delete(0, 'end')
def fetch_records():
f = data.fetchRecord('select rowid, * from expense_record')
global count
for rec in f:
tv.insert(parent='', index='0', iid=count, values=(rec[0], rec[1], rec[2], rec[3]))
count += 1
tv.after(400, refreshData)
def select_record(event):
global selected_rowid
selected = tv.focus()
val = tv.item(selected, 'values')
try:
selected_rowid = val[0]
d = val[3]
namevar.set(val[1])
amtvar.set(val[2])
dopvar.set(str(d))
except Exception as ep:
pass
def update_record():
global selected_rowid
selected = tv.focus()
# Update record
try:
data.updateRecord(namevar.get(), amtvar.get(), dopvar.get(), selected_rowid)
tv.item(selected, text="", values=(namevar.get(), amtvar.get(), dopvar.get()))
except Exception as ep:
messagebox.showerror('Error', ep)
# Clear entry boxes
item_name.delete(0, END)
item_amt.delete(0, END)
transaction_date.delete(0, END)
tv.after(400, refreshData)
def totalBalance():
f = data.fetchRecord(query="Select sum(item_price) from expense_record")
for i in f:
for j in i:
messagebox.showinfo('Current Balance: ', f"Total Expense: ' {j} \nBalance Remaining: {5000 - j}")
def refreshData():
for item in tv.get_children():
tv.delete(item)
fetch_records()
def deleteRow():
global selected_rowid
data.removeRecord(selected_rowid)
refreshData()
**# create tkinter object**
ws = Tk()
ws.title('Daily Expenses')
**# variables**
f = ('Times new roman', 14)
namevar = StringVar()
amtvar = IntVar()
dopvar = StringVar()
**# Frame widget** f2 = Frame(ws)
f2.pack()
f1 = Frame(
ws,
padx=10,
pady=10,
)
f1.pack(expand=True, fill=BOTH)
**# Label widget** Label(f1, text='ITEM NAME', font=f).grid(row=0, column=0, sticky=W)
Label(f1, text='ITEM PRICE', font=f).grid(row=1, column=0, sticky=W)
Label(f1, text='PURCHASE DATE', font=f).grid(row=2, column=0, sticky=W)
**# Entry widgets** item_name = Entry(f1, font=f, textvariable=namevar)
item_amt = Entry(f1, font=f, textvariable=amtvar)
transaction_date = Entry(f1, font=f, textvariable=dopvar)
**# Entry grid placement** item_name.grid(row=0, column=1, sticky=EW, padx=(10, 0))
item_amt.grid(row=1, column=1, sticky=EW, padx=(10, 0))
transaction_date.grid(row=2, column=1, sticky=EW, padx=(10, 0))
**# Action buttons** cur_date = Button(
f1,
text='Current Date',
font=f,
bg='#04C4D9',
command=setDate,
width=15
)
submit_btn = Button(
f1,
text='Save Record',
font=f,
command=saveRecord,
bg='#42602D',
fg='white'
)
clr_btn = Button(
f1,
text='Clear Entry',
font=f,
command=clearEntries,
bg='#D9B036',
fg='white'
)
quit_btn = Button(
f1,
text='Exit',
font=f,
command=lambda:ws.destroy(),
bg='#D33532',
fg='white'
)
total_bal = Button(
f1,
text='Total Balance',
font=f,
bg='#486966',
command=totalBalance
)
total_spent = Button(
f1,
text='Total Spent',
font=f,
command=lambda:data.fetchRecord('select sum(ite)')
)
update_btn = Button(
f1,
text='Update',
bg='#C2BB00',
command=update_record,
font=f
)
del_btn = Button(
f1,
text='Delete',
bg='#BD2A2E',
command=deleteRow,
font=f
)
**# grid placement** cur_date.grid(row=3, column=1, sticky=EW, padx=(10, 0))
submit_btn.grid(row=0, column=2, sticky=EW, padx=(10, 0))
clr_btn.grid(row=1, column=2, sticky=EW, padx=(10, 0))
quit_btn.grid(row=2, column=2, sticky=EW, padx=(10, 0))
total_bal.grid(row=0, column=3, sticky=EW, padx=(10, 0))
update_btn.grid(row=1, column=3, sticky=EW, padx=(10, 0))
del_btn.grid(row=2, column=3, sticky=EW, padx=(10, 0))
**# Treeview widget**
tv = ttk.Treeview(f2, columns=(1, 2, 3, 4), show='headings', height=8)
tv.pack(side="left")
**# add heading to treeview** tv.column(1, anchor=CENTER, stretch=NO, width=70)
tv.column(2, anchor=CENTER)
tv.column(3, anchor=CENTER)
tv.column(4, anchor=CENTER)
tv.heading(1, text="Serial no")
tv.heading(2, text="Item Name", )
tv.heading(3, text="Item Price")
tv.heading(4, text="Purchase Date")
**# binding treeview** tv.bind("<ButtonRelease-1>", select_record)
**# style for treeview** style = ttk.Style()
style.theme_use("default")
style.map("Treeview")
**# Vertical scrollbar** scrollbar = Scrollbar(f2, orient='vertical')
scrollbar.configure(command=tv.yview)
scrollbar.pack(side="right", fill="y")
tv.config(yscrollcommand=scrollbar.set)
**# calling function** fetch_records()
**# infinite loop** ws.mainloop()
下面的输出显示了费用管理应用程序的界面。您可以提供购买项目名称和项目价格，然后单击当前日期按钮获取当前日期。
如果需要，可以更改日期，然后单击保存记录按钮将数据存储在数据库中，相应的数据将显示在屏幕上的树形视图小部件中。
clear 按钮将清除入口小部件，exit 将关闭应用程序。总余额按钮将显示总花费金额和输入程序的剩余金额。
单击任意一行，数据将开始出现在相应的入口小部件中。在数据中进行更改，然后单击“更新”按钮，记录将相应更新。如果您要删除该行，请单击“删除”按钮。
Expense Tracking Application Using Python Tkinter Example
完整的源代码数据库 mydb.py
下面的源代码是使用 python tkinter 在 sqlite3 中创建一个数据库。将名为 mydb.py 的文件保存在保存主程序的同一目录中。
import sqlite3
class Database:
def __init__(self, db):
self.conn = sqlite3.connect(db)
self.cur = self.conn.cursor()
self.cur.execute(
"CREATE TABLE IF NOT EXISTS expense_record (item_name text, item_price float, purchase_date date)")
self.conn.commit()
def fetchRecord(self, query):
self.cur.execute(query)
rows = self.cur.fetchall()
return rows
def insertRecord(self, item_name, item_price, purchase_date):
self.cur.execute("INSERT INTO expense_record VALUES (?, ?, ?)",
(item_name, item_price, purchase_date))
self.conn.commit()
def removeRecord(self, rwid):
self.cur.execute("DELETE FROM expense_record WHERE rowid=?", (rwid,))
self.conn.commit()
def updateRecord(self, item_name, item_price, purchase_date, rid):
self.cur.execute("UPDATE expense_record SET item_name = ?, item_price = ?, purchase_date = ? WHERE rowid = ?",
(item_name, item_price, purchase_date, rid))
self.conn.commit()
def __del__(self):
self.conn.close()
下图显示了 SQLite3 数据库中的数据。我们正在使用数据库浏览器(SQLite) 软件查看这些数据。
Expense Tracking Application Using Python Tkinter
另外，看看更多的 Python Tkinter 教程。
因此，在这个 Python 教程中，我们了解了如何使用 Python Tkinter 构建一个费用跟踪应用程序。在这里，我们借助 Python 中的一个例子来介绍每个步骤。
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
从 PDF Python +有用的例子中提取文本
本 Python 教程解释，从 PDF Python 中提取文本。我们将看到如何使用 Python Tkinter 从 Python 的 PDF 文件中提取文本。我还将展示一个我们用 Python 开发的 pdf 到 word 转换器。
此外，我们将检查:
- 用 Python 从 pdf 文件中复制文本
- 如何使用 Python Tkinter 从 pdf 文件中提取文本
- 用 Python 删除 pdf 文件中的文本
- 如何用 Python 从 pdf 文件图像中复制文本
- 不能从 pdf 拷贝文本
- 如何在 Python 中将文本从 pdf 复制到 word
- 从 pdf 在线复制文本
- 从 pdf online 中删除文本
- 如何在 Python 中从 pdf 中选择文本
在做下面的例子之前，先看看下面的三篇文章:
目录
- Python 从 pdf 文件中复制文本
- 从 pdf Python 中提取文本
- 用 Python 从 pdf 文件中删除文本
- Python 从图像中提取文本
- 无法在 Python 中从 pdf 复制文本
- 如何用 Python 将文本从 pdf 复制到 word
- 如何在 Python 中从 pdf 文件中选择文本
- 如何将 Pdf 转换成 word Python pypdf2
Python 从 pdf 文件中复制文本
- 在这一节中，我们将学习如何使用 Python 从 PDF 文件中复制文本。此外，我们将使用 Python Tkinter 演示一切。我们假设您已经在各自的系统中安装了 PyPDF2 和 Tkinter 模块。
- 在 Python Tkinter 中复制文本的过程分为两个部分:
- 在第一部分中，我们将使用 Python 中的 PyPDF2 模块从 pdf 中提取文本。
- 第二步，我们将使用 Python Tkinter 中可用的
clipboard()函数复制文本。
下面是使用 Python 中的 PyPDF2 模块从 PDF 中读取和提取数据的代码。
reader = PdfFileReader(filename)
pageObj = reader.getNumPages()
for page_count in range(pageObj):
page = reader.getPage(page_count)
page_data = page.extractText()
- 在第一行中， 我们创建了一个保存 PDF 文件路径的“reader”变量。这里的 filename 是指带有路径的文件的名称。
- 在第二行中，我们获取了 PDF 文件中的总页数。
- 在第三行中，循环开始，它将遍历 PDF 文件中的总页数。
- 每次循环运行时，它都会显示 PDF 文件中的文本信息。
- 这样，我们可以使用 Python 中的
PyPDF2模块从 PDF 中提取文本。
下面是使用 Python Tkinter 复制文本的代码。
ws.withdraw()
ws.clipboard_clear()
ws.clipboard_append(content)
ws.update()
ws.destroy()
- 这里，
ws是主窗口。 - 第一行代码用于在不破坏窗口的情况下将其从屏幕上移除。
- 在第二行代码中，我们删除了任何已经复制的文本。
- 第三行代码是复制内容的操作。这里的内容可以替换为您想要复制的文本。
- 重要的是，即使在窗口关闭后，文本仍保持复制状态。为此，我们使用了更新功能。
- 在最后一行代码中，我们简单地销毁了窗口。这是一个选项，如果您不想关闭窗口，可以删除此代码。
代码片段:
这是一个小项目的代码，包含了我们到目前为止学到的所有东西。这个项目是使用 Python Tkinter 创建的基于 GUI 的程序，用于实现从 PDF 复制文本。
from PyPDF2 import PdfFileReader
from tkinter import *
from tkinter import filedialog
ws = Tk()
ws.title('PythonGuides')
ws.geometry('400x300')
ws.config(bg='#D9653B')
def choose_pdf():
filename = filedialog.askopenfilename(
initialdir = "/", # for Linux and Mac users
# initialdir = "C:/", for windows users
title = "Select a File",
filetypes = (("PDF files","*.pdf*"),("all files","*.*")))
if filename:
return filename
def read_pdf():
filename = choose_pdf()
reader = PdfFileReader(filename)
pageObj = reader.getNumPages()
for page_count in range(pageObj):
page = reader.getPage(page_count)
page_data = page.extractText()
textbox.insert(END, page_data)
def copy_pdf_text():
content = textbox.get(1.0, "end-1c")
ws.withdraw()
ws.clipboard_clear()
ws.clipboard_append(content)
ws.update()
ws.destroy()
textbox = Text(
ws,
height=13,
width=40,
wrap='word',
bg='#D9BDAD'
)
textbox.pack(expand=True)
Button(
ws,
text='Choose Pdf File',
padx=20,
pady=10,
bg='#262626',
fg='white',
command=read_pdf
).pack(expand=True, side=LEFT, pady=10)
Button(
ws,
text="Copy Text",
padx=20,
pady=10,
bg='#262626',
fg='white',
command=copy_pdf_text
).pack(expand=True, side=LEFT, pady=10)
ws.mainloop()
输出:
在这个输出中，我们使用了 Python Tkinter 文本框来显示 PDF 文件的文本。用户将点击选择 PDF 文件按钮。使用 Python Tkinter 中的文件对话框，他/她可以从计算机中导航并选择 PDF 文件。
文本将立即显示在文本框中，从这里用户只需点击复制文本按钮即可复制文本。文本将被复制，并可以像我们通常所做的那样粘贴到任何地方。
Python copy text from pdf file
这就是如何用 Python 从 PDF 文件中复制文本。
从 pdf Python 中提取文本
- 在本节中，我们将学习如何使用 Python Tkinter 从 PDF 中提取文本。Python 中的 PyPDF2 模块提供了一个方法
extractText()，使用该方法我们可以从 Python 中的 PDF 中提取文本。 - 在上一节中，我们已经演示了如何在 Python Tkinter 中复制文本。这里我们使用了
**extract text()方法在屏幕上显示文本。** - 下面是上一节中使用 Python Tkinter 中的 PyPDF 模块从 PDF 中提取文本的代码。
reader = PdfFileReader(filename)
pageObj = reader.getNumPages()
for page_count in range(pageObj):
page = reader.getPage(page_count)
page_data = page.extractText()
- 在第一行代码中，我们创建了一个 PdfFileReader 对象。这里 filename 是 PDF 文件的名称和完整路径。
- 在第二行代码中，我们收集了 PDF 文件中可用的总页数。该信息将在循环中进一步使用。
- 在第三行代码中，我们为 循环启动了一个，它将对 PDF 文件中的页面进行汇总。例如，如果 PDF 有 10 页，那么循环将运行 10 次。
- 每次循环运行时，它都将每页的信息添加到一个“page”变量中。这意味着可变页面在 PDF 中的每个页面上都有信息。
- 现在，通过在变量“page”上应用
extractText()方法，我们能够以人类可读的格式提取和显示 PDF 的所有文本。 - 这里显示的所有文本都是使用 Python 中
PyPDF2模块的extractText()方法。有关源代码，请参考上一节。
extract text from pdf python
这就是如何从 pdf python 中提取文本。
用 Python 从 pdf 文件中删除文本
下面是用 Python 从 PDF 文件中删除文本的完整代码。
from PyPDF2 import PdfFileReader
from tkinter import *
from tkinter import filedialog
ws = Tk()
ws.title('PythonGuides')
ws.geometry('400x300')
ws.config(bg='#D9653B')
path = []
def save_pdf():
content = textbox.get(1.0, "end-1c")
content.output(path[0])
def saveas_pdf():
pass
def choose_pdf():
global path
filename = filedialog.askopenfilename(
initialdir = "/", # for Linux and Mac users
# initialdir = "C:/", for windows users
title = "Select a File",
filetypes = (("PDF files","*.pdf*"),("all files","*.*")))
if filename:
path.append(filename)
return filename
def read_pdf():
filename = choose_pdf()
reader = PdfFileReader(filename)
pageObj = reader.getNumPages()
for page_count in range(pageObj):
page = reader.getPage(page_count)
page_data = page.extractText()
textbox.insert(END, page_data)
def copy_pdf_text():
content = textbox.get(1.0, "end-1c")
ws.withdraw()
ws.clipboard_clear()
ws.clipboard_append(content)
ws.update()
ws.destroy()
fmenu = Menu(
master=ws,
bg='#D9653B',
relief=GROOVE
)
ws.config(menu=fmenu)
file_menu = Menu(
fmenu,
tearoff=False
)
fmenu.add_cascade(
label="File", menu=file_menu
)
file_menu.add_command(
label="Open",
command=read_pdf
)
file_menu.add_command(
label="Save",
command=save_pdf
)
file_menu.add_command(
label="Save as",
command=None # ToDo
)
file_menu.add_separator()
file_menu.add_command(
label="Exit",
command=ws.destroy
)
textbox = Text(
ws,
height=13,
width=40,
wrap='word',
bg='#D9BDAD'
)
textbox.pack(expand=True)
Button(
ws,
text='Choose Pdf File',
padx=20,
pady=10,
bg='#262626',
fg='white',
command=read_pdf
).pack(expand=True, side=LEFT, pady=10)
Button(
ws,
text="Copy Text",
padx=20,
pady=10,
bg='#262626',
fg='white',
command=copy_pdf_text
).pack(expand=True, side=LEFT, pady=10)
ws.mainloop()
阅读:使用 Tkinter 中 pyqrcode 的 Python QR 码生成器
Python 从图像中提取文本
- 从图像中读取或复制文本是一个高级过程，需要机器学习算法。
- 每种语言都有不同的书写字母的模式。因此，它需要一个由字母和单词组成的数据集，这些字母和单词以特定的语言书写在图像上。
- 当这个数据集被传入机器学习算法时，它开始通过匹配字母模式来识别图像上的文本。
OCR(光学字符识别)是运行机器学习算法从图像中识别字符的 Python 库。- Python 从图像中提取文本主题将在我们的机器学习部分讨论。
无法在 Python 中从 pdf 复制文本
在本节中，我们将分享使用 Python Tkinter 阅读 PDF 时出现的常见问题。所以，如果你不能用 Python 从 pdf 复制文本，那么检查以下几点。
- 如果另一个进程正在使用 PDF，则您不能从 PDF 中拷贝文本。
- 如果您看到不能从 PDF 拷贝文本的消息，请仔细检查 PDF 文件
这些是用户不能从 PDF 复制文本的常见现象。如果你面临任何其他问题，请在下面的评论中留下。
如何用 Python 将文本从 pdf 复制到 word
- 为了使用 Python 将文本从 PDF 复制到 Word 文件，我们使用了 Python 中的模块 pdf2docs。
- pdf2docx 允许使用 Python 将任何 pdf 文档转换为 Word 文件。这个 word 文件可以用第三方应用程序进一步打开，如 Microsoft Word、Libre Office 和 WPS。
- 这个过程的第一步是安装
pdf2docs模块。使用pip你可以在任何操作系统的设备上安装该模块。
pip install pdf2docx
代码片段:
这段代码展示了如何使用 Python Tkinter 将 PDF 转换成 Word 文件。
from tkinter import *
from tkinter import filedialog
import pdf2docx
path = []
def convert_toword():
global path
data = []
file = filedialog.asksaveasfile(
defaultextension = data,
filetypes = (("WORD files","*.docx*"),("all files","*.*")),
)
pdf2docx.parse(
pdf_file=path[0],
docx_file= file.name,
start=0,
end=None,
)
def choose_file():
global path
path.clear()
filename = filedialog.askopenfilename(
initialdir = "/", # for Linux and Mac users
# initialdir = "C:/", for windows users
title = "Select a File",
filetypes = (("PDF files","*.pdf*"),("all files","*.*")))
path.append(filename)
ws = Tk()
ws.title('PythonGuides')
ws.geometry('400x300')
ws.config(bg='#F2E750')
choose_btn = Button(
ws,
text='Choose File',
padx=20,
pady=10,
bg='#344973',
fg='white',
command=choose_file
)
choose_btn.pack(expand=True, side=LEFT)
convert_btn = Button(
ws,
text='Convert to Word',
padx=20,
pady=10,
bg='#344973',
fg='white',
command=convert_toword
)
convert_btn.pack(expand=True, side=LEFT)
ws.mainloop()
输出:
这是应用程序主屏幕的输出。用户可以通过点击选择文件按钮选择 PDF 文件。一旦选中，他就可以点击转换成 word PDF。word 文件将在选择 PDF 文件的同一目录下创建。
fig 1: main screen of the application
图 2 显示了当用户点击选择文件按钮时，文件对话窗口的外观。所以用户选择了 Grades.pdf 的
**
fig 2: selecting PDF
图 3 显示保存文件对话框外观。用户正在用保存文件。docx 扩展名。
Fig 3: converting to word
图 4 显示了 PDF 到 Word 文件的转换。在这种情况下，您可以看到 word 文档是以名称 updatedGrades.docx 创建的。该名称由用户在图 3 中提供。
fig 4: file converted to word document
这是如何用 Python 将文本从 pdf 复制到 word。
如何在 Python 中从 pdf 文件中选择文本
- 在本节中，我们将学习如何使用 Python 从 PDF 中选择文本。此外，我们将使用 Python Tkinter 演示所有内容。我们假设您已经在各自的系统中安装了 PyPDF2 和 Tkinter 模块。
- Python Tkinter 中选择文本的过程分为两部分:
- 在第一部分中，我们将使用 Python 中的 PyPDF2 模块从 pdf 中提取文本。
- 在第二步中，我们将从提取的文本中选择文本。
下面是使用 Python 中的 PyPDF2 模块从 PDF 中读取和提取数据的代码
reader = PdfFileReader(filename)
pageObj = reader.getNumPages()
for page_count in range(pageObj):
page = reader.getPage(page_count)
page_data = page.extractText()
- 在第一行中， 我们创建了一个保存 PDF 文件路径的“reader”变量。这里的 filename 是指带有路径的文件的名称。
- 在第二行中，我们获取了 PDF 文件中的总页数。
- 在第三行中，循环开始，它将遍历 PDF 文件中的总页数。
- 每次循环运行时，它都会显示 PDF 文件中的文本信息。
- 这样，我们可以使用 Python 中的
PyPDF2模块从 PDF 中提取文本。 - 一旦你提取了文本，现在你可以简单地通过点击右键并拖动鼠标来选择文本
代码片段:
下面是一个小项目的代码，展示了从 PDF 中提取文本..这个项目是一个基于 GUI 的程序，使用 Python Tkinter 创建，实现从 PDF 中选择文本。
from PyPDF2 import PdfFileReader
from tkinter import *
from tkinter import filedialog
ws = Tk()
ws.title('PythonGuides')
ws.geometry('400x300')
ws.config(bg='#D9653B')
def choose_pdf():
filename = filedialog.askopenfilename(
initialdir = "/", # for Linux and Mac users
# initialdir = "C:/", for windows users
title = "Select a File",
filetypes = (("PDF files","*.pdf*"),("all files","*.*")))
if filename:
return filename
def read_pdf():
filename = choose_pdf()
reader = PdfFileReader(filename)
pageObj = reader.getNumPages()
for page_count in range(pageObj):
page = reader.getPage(page_count)
page_data = page.extractText()
textbox.insert(END, page_data)
def copy_pdf_text():
content = textbox.get(1.0, "end-1c")
ws.withdraw()
ws.clipboard_clear()
ws.clipboard_append(content)
ws.update()
ws.destroy()
textbox = Text(
ws,
height=13,
width=40,
wrap='word',
bg='#D9BDAD'
)
textbox.pack(expand=True)
Button(
ws,
text='Choose Pdf File',
padx=20,
pady=10,
bg='#262626',
fg='white',
command=read_pdf
).pack(expand=True, side=LEFT, pady=10)
Button(
ws,
text="Copy Text",
padx=20,
pady=10,
bg='#262626',
fg='white',
command=copy_pdf_text
).pack(expand=True, side=LEFT, pady=10)
ws.mainloop()
输出:
在这个输出中，我们使用 Python Tkinter 文本框来显示 PDF 文件的文本。用户将点击选择 PDF 文件按钮。使用 Python Tkinter 中的文件对话框，他/她可以从计算机中导航并选择 PDF 文件。
文本将立即显示在文本框中，从这里用户只需点击复制文本按钮即可复制文本。文本将被复制，并可以像我们通常所做的那样粘贴到任何地方。现在，用户可以选择文本的任何部分，并使用它来解决他/她的目的。
Select text from pdf file in Python
如何将 Pdf 转换成 word Python pypdf2
现在，是时候使用 Python 开发一个工具了， pdf 到 word 的转换器。
在本节中，我们已经创建了软件来将 pdf 转换为 word python pypdf2 。这是一个完整的软件，可以作为一个小项目使用 Python Tkinter。
from PyPDF2 import PdfFileReader
from tkinter import *
from tkinter import filedialog
import pdf2docx
f = ("Times", "15", "bold")
def export_toword():
pdf2docx.convert = browseFiles.filename
def browseFiles():
filename = filedialog.askopenfilename(
initialdir = "/",
title = "Select a File",
filetypes = (("PDF files","*.pdf*"),("all files","*.*")))
fname = filename.split('/')
upload_confirmation_lbl.configure(text=fname[-1])
process(filename)
return filename
def process(filename):
with open(filename, 'rb') as f:
pdf = PdfFileReader(f)
information = pdf.getDocumentInfo()
number_of_pages = pdf.getNumPages()
fname = filename.split('/')
right2.config(text=f'{information.author}')
right3.config(text=f'{information.producer}')
right1.config(text=f'{fname[-1]}:')
right4.config(text=f'{information.subject}')
right5.config(text=f'{information.title}')
right6.config(text=f'{number_of_pages}')
ws = Tk()
ws.title('PythonGuides')
ws.geometry('800x800')
upload_frame = Frame(
ws,
padx=5,
pady=5
)
upload_frame.pack(pady=10)
upload_btn = Button(
upload_frame,
text='UPLOAD PDF FILE',
padx=20,
pady=20,
bg='#f74231',
fg='white',
command=browseFiles
)
upload_btn.pack(expand=True)
upload_confirmation_lbl = Label(
upload_frame,
pady=10,
fg='green'
)
upload_confirmation_lbl.pack()
description_frame = Frame(
ws,
padx=10,
pady=10
)
description_frame.pack()
right1 = Label(
description_frame,
)
right2 = Label(
description_frame,
)
right3 = Label(
description_frame,
)
right4 = Label(
description_frame,
)
right5 = Label(
description_frame,
)
right6 = Label(
description_frame
)
left1 = Label(
description_frame,
text='Author: ',
padx=5,
pady=5,
font=f
)
left2 = Label(
description_frame,
text='Producer: ',
padx=5,
pady=5,
font=f
)
left3 = Label(
description_frame,
text='Information about: ',
padx=5,
pady=5,
font=f
)
left4 = Label(
description_frame,
text='Subject: ',
padx=5,
pady=5,
font=f
)
left5 = Label(
description_frame,
text='Title: ',
padx=5,
pady=5,
font=f
)
left6 = Label(
description_frame,
text='Number of pages: ',
padx=5,
pady=5,
font=f
)
left1.grid(row=1, column=0, sticky=W)
left2.grid(row=2, column=0, sticky=W)
left3.grid(row=3, column=0, sticky=W)
left4.grid(row=4, column=0, sticky=W)
left5.grid(row=5, column=0, sticky=W)
left6.grid(row=6, column=0, sticky=W)
right1.grid(row=1, column=1)
right2.grid(row=2, column=1)
right3.grid(row=3, column=1)
right4.grid(row=4, column=1)
right5.grid(row=5, column=1)
right6.grid(row=6, column=1)
export_frame = LabelFrame(
ws,
text="Export File As",
padx=10,
pady=10,
font=f
)
export_frame.pack(expand=True, fill=X)
to_text_btn = Button(
export_frame,
text="TEXT FILE",
command=None,
pady=20,
font=f,
bg='#00ad8b',
fg='white'
)
to_text_btn.pack(side=LEFT, expand=True, fill=BOTH)
to_word_btn = Button(
export_frame,
text="WORD FILE",
command=export_toword,
pady=20,
font=f,
bg='#00609f',
fg='white'
)
to_word_btn.pack(side=LEFT, expand=True, fill=BOTH)
ws.mainloop()
输出:
这是一个多用途的软件。它可以将 PDF 文件转换成文本文件和 Word 文件。此外，它还显示有关所选 PDF 的简要信息。
convert pdf to word python pypdf2
这是用 Python 开发的 pdf 到 word 的转换器。
上述代码将有助于解决以下问题:
- pypdf2 将 pdf 转换为 word
- pypdf2 将 pdf 转换为 docx
- 将 pdf 转换为 python 中的 docx
- 使用 python 将 pdf 转换为 docx
- 使用 python 将 pdf 转换为文本文件
- 如何用 python 把 pdf 转换成 word
- 如何用 python 把 pdf 转换成 word 文件
这是如何用 pypdf2 在 Python 中将 pdf 转换成 word。
您可能会喜欢以下 Python 文章:
- 如何用 Python 制作计算器
- 使用 Python Tkinter 的身体质量指数计算器
- Python Tkinter Menu bar
- Python Tkinter check button–如何使用
- Python Tkinter 单选按钮–如何使用
- 如何使用 Python Tkinter 创建倒计时定时器
在本教程中，我们已经学习了如何用 Python 从 PDF 中提取文本。此外，我们还讨论了以下主题:
- Python 从 pdf 文件复制文本
- 从 pdf Python 中提取文本
- 用 Python 删除 pdf 文件中的文本
- Python 从图像中提取文本
- 无法在 Python 中从 pdf 复制文本
- 如何在 Python 中将文本从 pdf 复制到 word
- 如何在 Python 中从 pdf 文件中选择文本
- 如何将 Pdf 转换成 word Python pypdf2
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何用 Python 打印一个数的阶乘
原文：https://pythonguides.com/factorial-of-a-number-in-python/
在这个 python 教程中，你将学习如何在 Python 中**打印一个数的阶乘，以及 Python 程序打印一个数的阶乘，我们还将检查 :**
- Python 程序打印一个数的阶乘
- 使用函数打印数字阶乘的 Python 程序
- 使用 for 循环打印数字阶乘的 Python 程序
- Python 程序使用递归查找数字的阶乘
- Python 程序，通过获取用户输入来打印数字的阶乘
- Python 程序使用 while 循环查找数字的阶乘
- Python 程序打印一个数字的阶乘，无需递归
- python 中使用 if-else 的阶乘程序
- Python 程序打印数字 4 的阶乘
- Python 程序打印数字 10 的阶乘
目录
- 用 Python 打印一个数的阶乘
- Python 程序使用函数打印一个数的阶乘
- Python 程序使用 for 循环打印一个数的阶乘
- Python 程序使用递归寻找一个数的阶乘
- Python 程序通过获取用户输入来打印数字的阶乘
- Python 程序使用 while 循环寻找一个数的阶乘
- Python 程序打印一个数的阶乘，无需递归
- python 中使用 if-else 的阶乘程序
- Python 程序打印数字 4 的阶乘
- Python 程序打印数字 10 的阶乘
用 Python 打印一个数的阶乘
让我们看看 python 程序打印一个数的阶乘。
- 首先，要求其阶乘的数存储在
Num中。 - 声明并初始化阶乘变量为 1。
- 我们将使用一个
if-else语句来检查数字是负、零还是正。 - 如果数字为正数，则使用循环和范围()函数的来计算数字的阶乘。
- 最后用
print得到一个数的阶乘。
举例:
Num = 5
Factorial = 1
if Num < 0:
print("Factorial does not exist for negative numbers")
elif Num == 0:
print("The factorial of 0 is 1")
else:
for i in range(1, Num + 1):
Factorial = Factorial * i
print("The factorial of",Num,"is",Factorial)
我们可以看到输出中一个数的阶乘是 120 。您可以参考下面的输出截图。
Python program to print factorial of a number
上面的代码，我们可以用 Python 中的来打印一个数的阶乘。
你可能喜欢， Python zip()函数。
Python 程序使用函数打印一个数的阶乘
现在，我们将看到 python 程序使用函数打印一个数的阶乘。
- 在本例中，我们将函数定义为阶乘(数字)。
- 为了找到的阶乘，我们使用了单行的
if-else语句，并且我们将的数字指定为 6 来计算阶乘。 - 最后用
print得到一个数的阶乘。
举例:
def factorial(num):
return 1 if (num==1 or num==0) else num * factorial(num-1);
number = 6
print("The factorial of",number,"is",factorial(number))
我们可以看到输出中一个数的阶乘是 720 。您可以参考下面的输出截图。
Python program to print factorial of a number using function
这就是如何使用 Python 中的函数打印一个数的阶乘。
Python 程序使用 for 循环打印一个数的阶乘
这里，我们将看到 python 程序使用 for 循环打印一个数的阶乘
- 首先，我们将从要计算阶乘的用户那里获取输入。
- 将事实变量声明并初始化为 1。
- for 循环和
range()函数用于计算一个数的阶乘。 - 最后用
print得到一个数的阶乘。
举例:
num = int(input("Enter a number:"))
Fact = 1
for i in range(1, num + 1):
Fact = Fact * i
print("The Factorial of",num,"is",Fact)
我们可以看到输出中一个数的阶乘是 24 。您可以参考下面的输出截图。
Python program to print factorial of a number using for loop
上面的代码，我们可以使用 Python 中的 for 循环来打印一个数的阶乘。
Python 程序使用递归寻找一个数的阶乘
现在，我们将看到 python 程序使用递归来寻找一个数的阶乘。
- 这里，我们将使用递归来求一个数的阶乘。
- 在本例中，我们将函数定义为
recursion_factorial(n) - 我们将把该值存储在号中。我们将使用一个
if-else语句来检查数字是 负 、 零 还是 正 。 - 将数字传递给递归 _ 阶乘()函数，以计算该数字的阶乘。
举例:
def recursion_factorial(n):
if n == 1:
return n
else:
return n*recursion_factorial(n-1)
number = 8
if number < 0:
print("Factorial does not exist for negative numbers")
elif number == 0:
print("The factorial of 0 is 1")
else:
print("The factorial of", number, "is", recursion_factorial(number))
我们可以看到输出中一个数的阶乘是 40320 。您可以参考下面的输出截图。
Python program to find factorial of a number using recursion
上面的代码是用 Python 中的递归来求一个数的阶乘。
Python 程序通过获取用户输入来打印数字的阶乘
让我们来看看 python 程序通过从用户那里获得输入来打印一个数的阶乘
- 首先，我们将从要计算阶乘的用户那里获取输入。
- 将事实变量声明并初始化为
1。 - 我们将使用一个
if-else语句来检查数字是负、零还是正。 - 如果数字为正数，则使用循环和范围()函数的来计算数字的阶乘。
- 最后用
print得到一个数的阶乘。
举例:
num = int(input("Enter a number:"))
fact = 1
if num < 0:
print("Factorial does not exist for negative numbers")
elif num == 0:
print("The factorial of 0 is 1")
else:
for i in range(1,num+1):
fact = fact * i
print("The Factorial of",num,"is",fact)
我们可以看到输出中一个数的阶乘是 5040 。您可以参考下面的输出截图。
Python program to print factorial of a number by getting input from a user
这是一个 Python 程序，通过获取用户输入来打印一个数字的阶乘。
Python 程序使用 while 循环寻找一个数的阶乘
在这里，我们将看到 python 程序使用 while 循环寻找一个数的阶乘。
- 首先，我们将从要计算阶乘的用户那里获取输入。
- 将事实变量声明并初始化为
1。 - 我们将使用一个
if-else语句来检查数字是负、零还是正。 - 一个 while 循环被用来在一个连续的过程中把数字相乘以得到阶乘。
- 该过程继续，直到数字的值大于零。
- 最后用
print得到一个数的阶乘。
举例:
num=int(input("Enter a number to find factorial: "))
fact=1;
if num<0:
print("Factorial does not defined for negative integer");
elif(num==0):
print("The factorial of 0 is 1");
else:
while(num>0):
fact = fact*num
num=num-1
print("Factorial of the given number is: ",fact)
我们可以看到输出中一个数的阶乘是 120 。您可以参考下面的输出截图。
Python program to find factorial of a number using while loop
上面的代码，我们可以用 Python 中的 while 循环来求一个数的阶乘。
Python 程序打印一个数的阶乘，无需递归
在这里，我们将看到 python 程序在没有递归的情况下打印一个数的阶乘。
- 首先，我们将从要计算阶乘的用户那里获取输入。
- 将事实变量声明并初始化为
1。 - 一个 while 循环被用来在一个连续的过程中把数字相乘以得到阶乘。
- 该过程继续，直到数字的值大于零。
- 最后用
print得到一个数的阶乘。
举例:
num = int(input("Enter number:"))
Factorial = 1
while(num>0):
Factorial=Factorial*num
num=num-1
print("The factorial of entered number is:",Factorial)
我们可以看到输出中一个数的阶乘是 3628800 。您可以参考下面的输出截图。
Python program to print factorial of a number without recursion
上面的代码是为了打印一个数字的阶乘而不用 Python 中的递归。
python 中使用 if-else 的阶乘程序
现在，我们将看到 python 中使用 if-else 的阶乘程序
- 首先，我们将从要计算阶乘的用户那里获取输入。
- 声明并初始化事实变量为 1。
- 我们将使用一个
if-else语句来检查数字是负、零还是正。 - 如果数字为正数，则使用循环和范围()函数的来计算数字的阶乘。
- 最后用
print得到一个数的阶乘。
举例:
number = int(input("Enter a number: "))
fact = 1
if number < 0:
print("Factorial does not exist for negative numbers")
elif number == 0:
print("The factorial of 0 is 1")
else:
for i in range(1,number + 1):
fact = fact*i
print("The factorial of",number,"is",fact)
我们可以看到输出中一个数的阶乘是 40320 。您可以参考下面的输出截图。
Factorial program in python using if-else
这是 python 中使用 if-else 的阶乘程序。
Python 程序打印数字 4 的阶乘
让我们看看 python 程序打印数字 4 的阶乘。
- 首先，我们将从要计算阶乘的用户那里获取输入。
- 将事实变量声明并初始化为
1。 - for 循环和
range()函数用于计算一个数的阶乘。 - 最后用
print得到一个数的阶乘。
举例:
number = int(input(" Please enter any Number to find factorial : "))
fact = 1
for i in range(1, number + 1):
fact = fact * i
print("The factorial of",number,"is",fact)
我们可以看到输出中一个数的阶乘是 24 。您可以参考下面的输出截图
Python program to print factorial of number 4
这是用 Python 打印数字 4 的阶乘的代码。
Python 程序打印数字 10 的阶乘
现在，我们将看到 python 程序打印数字 10 的阶乘。
- 首先，我们将从要计算阶乘的用户那里获取输入。
- 将事实变量声明并初始化为
1。 - for 循环和
range()函数用于计算一个数的阶乘。 - 最后用
print得到一个数的阶乘。
举例:
number = 10
fact = 1
for i in range(1, number + 1):
fact = fact * i
print("The factorial of",number,"is",fact)
我们可以看到输出中一个数的阶乘是 3628800 。您可以参考下面的输出截图
Python program to print factorial of number 10
这是打印数字 10 的阶乘的 Python 代码。
您可能会喜欢以下 Python 教程:
在这篇 Python 教程中，我们学习了打印数字的阶乘的 Python 程序。此外，我们还讨论了以下主题:
- Python 程序打印一个数的阶乘
- 使用函数打印数字阶乘的 Python 程序
- 使用 for 循环打印数字阶乘的 Python 程序
- Python 程序使用递归查找数字的阶乘
- Python 程序，通过获取用户输入来打印数字的阶乘
- Python 程序使用 while 循环查找数字的阶乘
- Python 程序打印一个数字的阶乘，无需递归
- python 中使用 if-else 的阶乘程序
- Python 程序打印数字 4 的阶乘
- Python 程序打印数字 10 的阶乘
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
文件不存在 Python
在本 python 教程中，我们将讨论文件不存在的 python，我们还将涉及以下主题:
- 文件不存在 python
- 文件不存在 python 读取 CSV
- Python 检查文件是否不存在并创建
- 文件不存在 python 异常
- Python 检查文件是否存在
- 如果文件不存在 python
- Python 文件不存在错误
- python 中不存在 ioerror 文件
- Python 如果文件不存在跳过
- Python 引发文件不存在
目录
- 文件不存在 python
- 文件不存在 python 读取 CSV
- Python 检查文件是否不存在并创建
- 文件不存在 python 异常
- Python 检查文件是否存在
- 如果文件不存在 python
- Python 文件不存在错误
- IOError 文件不存在 python
- Python 如果文件不存在跳过
- Python raise 文件不存在
文件不存在 python
在这里，我们可以看到如何在 python 中检查文件是否存在。
- 在这个例子中，我导入了一个名为
os.path的模块。os.path模块用于处理来自系统不同地方的文件。 os.path.exists用于检查指定路径是否存在。- 文件的路径被指定为 r'C:\Users\Administrator。SharePoint sky \ Desktop \ Work \ mobile . txt '。mobile.txt 是文件的名称。
示例:
import os.path
print(os.path.exists( r'C:\Users\Administrator.SHAREPOINTSKY\Desktop\Work\mobile.txt'))
因为文件不存在，所以输出返回 False。您可以参考下面的输出截图。
File does not exist python
这就是如何修复文件不存在错误 python 。
读取， Python 程序打印图案。
文件不存在 python 读取 CSV
在这里，我们可以看到检查文件如何在 python 中读取 CSV 不存在。
- 在这个例子中，我使用了异常，所以我使用了 try 块来检查文件是否存在。
- 我已经用打开了文件。csv 扩展名，如果条件为真，它应该打印文件呈现作为输出。
- 如果找不到文件，则使用 except is
FileNotFoundError。因为文件是当前的，所以不会引发异常。
示例:
try:
with open("student.csv") as f:
print("File present")
except FileNotFoundError:
print('File is not present')
由于没有引发文件存在异常，我们可以看到文件存在时的输出。下面的屏幕截图显示了输出。
file does not exist python read CSV
这是如何修复错误，文件不存在错误，在 Python 中读取 CSV 文件。
Python 检查文件是否不存在并创建
现在，我们可以看到如何检查文件是否不存在并在 python 中创建。
- 在这个例子中，我导入了一个名为
os的模块。读取文件的路径。 - if 条件用作
os.path.exists(x)，os.path.isfile(x)。 - 如果文件存在，则条件返回 true 作为输出。
- 如果文件不存在，则执行 else 条件，并使用 f = open("pic.txt "，" w") 创建文件。
pic.txt是文件的名称，“w”是文件的模式。 f.close()用于关闭文件。
示例:
import os
x=r'C:\Users\Administrator.SHAREPOINTSKY\photo.txt'
if os.path.exists(x):
if os.path.isfile(x):
print("file is present")
else:
print("file is not present and creating a new file")
f = open("pic.txt","w")
f.close()
由于文件不存在，执行 else 条件并创建新文件。您可以参考下面的输出截图。
Python check if file does not exists and create
这就是如何检查文件是否不存在并在 Python 中创建它。
文件不存在 python 异常
在这里，我们可以看到文件不存在 python 中的异常。
- 在这个例子中，我使用了异常。
- 这里，我使用了一个 try 块来检查文件是否存在。所以我用 open("bottle.py ")作为 f 打开了文件，如果条件为真，它应该打印(“文件存在”)。****
- 如果找不到文件，则使用 except
FileNotFoundError。由于文件不存在，执行异常。
示例:
try:
with open("bottle.py") as f:
print("File present")
except FileNotFoundError:
print('File is not present')
您可以参考下面的输出截图。
File does not exist python exception
Python 检查文件是否存在
现在，我们可以看到检查一个文件在 python 中是否存在。
- 在这个例子中，我从操作系统中导入了一个名为
os.path的模块和一个路径。模块路径检查指定路径是否存在。 - 我用过一个叫 main 的函数作为
def main()。 path.exists()用于检查指定的路径是否存在。因为两个文件都不存在。- 因为只有一个文件存在，我们可以看到输出为真，而另一个文件
925.txt没有找到，所以它返回假作为输出。 - 每个模块都有一个名为
__name__的属性。，属性的值被设置为“main”。
示例:
import os.path
from os import path
def main():
print (str(path.exists('pic.txt')))
print (str(path.exists('925.txt')))
if __name__== "__main__":
main()
由于文件 925.txt 不存在，我们可以看到输出中返回了 false。下面的截图显示了输出。
Python check If file exists
这就是如何在 Python 中检查一个文件是否存在。
如果文件不存在 python
现在，如果文件在 python 中不存在，我们可以看到。
- 在这个例子中，我导入了一个名为
pathlib的模块。模块pathlib用于处理文件和目录。 pathlib.path用于连接两个目录的路径。path.exists()用于检查文件是否存在。path.is_file用于查找文件的结果。
示例:
import pathlib
path = pathlib.Path('laptop.txt')
path.exists()
print(path.is_file())
因为文件不存在，所以输出返回 false。您可以参考下面的输出截图。
If the file does not exist python
Python 文件不存在错误
在这里，我们可以看到文件在 python 中不存在错误。
在本例中，我将一个文件作为 mobile.txt 来读取该文件，因为该文件不存在，所以发现了错误。
示例:
myfile = open("mobile.txt")
print(myfile.read())
myfile.close()
我们可以看到 FileNotFoundError 作为输出。您可以参考下面的输出截图。为了解决这个错误，我们必须给出系统中存在的文件名。
Python file does not exist error
IOError 文件不存在 python
在这里，我们可以看到 IOError 文件在 python 中不存在。
- 在这个例子中，我使用了异常，所以我使用了 try 块和来检查文件是否存在。
- 我已经用 open("mobile.txt ")作为 f 打开了文件，如果条件为真，它应该打印(“文件存在”)。mobile . txt 是文件的名称。
- 如果找不到文件，则使用 except
IOError。由于文件不存在，执行异常。
示例:
try:
with open("mobile.txt") as f:
print("File present")
except IOError:
print('File is not present')
因为文件不存在，所以执行 except。文件不存在打印在输出中。您可以参考下面的输出截图。
IOError file does not exist python
Python 如果文件不存在跳过
- 在这个例子中，我使用了异常，所以我使用了 try 块和来检查文件是否存在。
- 我已经用 f 打开了文件，如果条件为真，它应该打印(“文件存在”)。****
- 如果找不到文件，则使用 except
FileNotFoundError。由于文件不存在，异常被执行并跳到打印(‘文件不存在’)。
示例:
try:
with open("bike.txt") as f:
print("File present")
except FileNotFoundError:
print('File is not present')
except 被执行，因此输出将是文件不存在。您可以参考下面的输出截图。
Python if the file does not exists skip
Python raise 文件不存在
在这里，我们可以看到如何提升 python 中不存在的文件。
- 在这个例子中，我导入了一个名为
os的模块。os 模块在用户和操作系统之间建立连接。 - 如果文件不存在，它应该产生一个错误
FileNotFoundError。 - 关键字
raise用于引发异常。
示例:
import os
if not os.path.isfile("text.txt"):
raise FileNotFoundError
由于文件不存在，输出中会出现一个错误。您可以参考下面的输出截图。
Python raise file does not exists
您可能会喜欢以下 Python 教程:
- 如何在 Python 中读取视频帧
- Python 逐行读取文件示例
- 用 Python 创建和修改 PDF 文件
- Python 将图像保存到文件
- 如何使用 Python Tkinter 读取文本文件
- Python 程序打印质数
在本教程中，我们已经了解了不存在 python 的文件，并且我们也已经涵盖了这些主题:
- 文件不存在 python
- 文件不存在 python 读取 CSV
- Python 检查文件是否不存在并创建
- 文件不存在 python 异常
- Python 检查文件是否存在
- 如果文件不存在 python
- python 中不存在 IOError 文件
- Python 如果文件不存在跳过
- Python 引发文件不存在
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何在 Python 中使用过滤函数
在本 Python 教程中，我们将讨论几种在 Python 中使用过滤函数的方法。此外，我们将查看在 Python 中使用过滤函数的各种示例。
最近，我一直在做一个机器学习项目，我发现它需要一个过滤功能。
在这里我们将学习
- 如何在 Python 中使用过滤函数
- 如何使用 lambda 函数在 Python 中使用过滤函数
- 如何使用列表理解在 Python 中使用过滤函数
- 如何使用 re.match()在 Python 中使用过滤函数
- 如何使用 for 循环在 Python 中使用过滤函数
- 如何使用 reduce()在 Python 中使用过滤函数
目录
- 如何在 Python 中使用过滤函数
- 如何使用 lambda 函数在 Python 中使用过滤函数
- 如何使用列表理解在 Python 中使用过滤函数
- 如何使用 re.match() 在 Python 中使用过滤函数
- 如何使用 for 循环过滤 Python 中的值
- 如何使用 Python 中的 filter 函数使用无作为函数参数的 Filter
- 如何使用 reduce()在 Python 中使用过滤函数
如何在 Python 中使用过滤函数
- 在本节中，我们将讨论如何在 Python 中使用过滤函数。
filter()方法让 Python 中的函数式编程变得更加容易。它接受一个 iterable 和一个函数作为参数，并应用提供给 iterable 的每个元素的函数。完成后，将返回一个 iterable。- 例如，您可以使用
filter()函数将一组数字的奇数和偶数部分分成两个独立的集合。它甚至可以用来根据字典列表中的关键字选择字典。
语法:
让我们看一下语法，了解一下 Python 中 filter() 函数的工作原理。
filter(function, iterable)
- 它由几个参数组成
- 函数:用于判断该函数的每个可迭代元素是否为真。
- iterable: 集合、列表、元组以及其他要进行过滤的 iterable。
举例:
让我们举个例子，看看如何在 Python 中使用过滤函数。
源代码:
new_val = [67, 93, 28, 17, 48]
# Creating a function
def filtered_val(val):
if val >= 29 :
return True
new_result = filter( filtered_val, new_val)
print(list(new_result))
在下面给出的代码中，我们首先声明了一个列表‘new _ val’，然后定义了一个函数‘filtered _ val’，并设置了条件，如果值大于 29 ，那么它将过滤所有的值并返回【67，93，48】。
下面是以下代码的截图
Use of filter function in Python
这是如何使用 Python 中的过滤函数。
如何使用 lambda 函数在 Python 中使用过滤函数
- 现在让我们了解如何使用 lambda 在 Python 中使用过滤函数
- 通过使用 lambda 函数，过程四(filter()方法)可以简化为一行。
- 我们可以使用 lambda 将条件写在 'filter()' 函数内部，而不是单独构造一个新的值函数。
- 在这个实例中，过滤新值将被 6 除的变量已经完成，过滤后的迭代器将被转换为一个列表。
举例:
new_values = [18, 54, 26, 36, 12, 1]
# Returns the elements which are multiples of 6
new_result = list(filter(lambda n : n%6 == 0, new_values))
print(new_result)
在上面的代码中，我们首先创建了一个列表“new_values ”,然后在这个函数中使用了 list 函数，我们使用了 lambda 并设置了一个条件，如果数字被 6 除，那么它会将值存储在新列表中。
你可以参考下面的截图。
How to use a filter function in Python using lambda function
正如你在截图中看到的，我们已经讨论了如何使用 lambda 函数在 Python 中使用过滤函数。
如何使用列表理解在 Python 中使用过滤函数
- 现在让我们讨论如何使用列表理解在 Python 中使用过滤函数。
- 在列表上使用 for 循环和 if-else 条件是一种创造性的技术。一行代码可以用来实现方法一。
- 在这种情况下，我们在循环中遍历所有列表项，并选择大于或等于
1800的分数。 - 它很容易编写，您可以轻松地包含几个 if-else 语句。
举例:
让我们举一个例子，并检查如何使用列表理解在 Python 中使用过滤函数。
源代码:
Zip_code_USA = [6723, 9212, 14562, 9546, 1845, 9456]
new_output = [i for i in Zip_code_USA if i >= 1800]
print(new_output)
在下面的代码中，我们首先声明了一个列表‘Zip _ code _ USA’，然后使用列表理解在循环中迭代所有列表项，并选择大于或等于 1800 的分数。
下面是以下给定代码的实现
Using list comprehension along with filter function
在这个例子中，我们已经理解了如何使用列表理解在 Python 中使用过滤函数。
如何使用 re.match() 在 Python 中使用过滤函数
- 在本节中，我们将讨论如何使用
re.match()在 Python 中使用过滤函数。 - Python 中的
re.match()方法定位并返回正则表达式模式的第一个实例。Python 中的 Regex Match 函数只在被搜索文本的开头查找匹配字符串。 - 如果在第一行中发现一个匹配，则创建相应的对象。如果在后续行中找到匹配项，Python Regex Match 方法将返回 null。
- 在这个实例中，通过将一个正则表达式模式“N . *”传递给re . match()’，列表理解被用来过滤掉以“N”开头的名字。
举例:
这里我们将举一个例子，并检查如何使用 re.match() 在 Python 中使用过滤函数。
源代码:
import re
Country_name = ["USA", "Germany", "Australia", "China"]
# regex pattern
new_patt = "A.*"
# Match the above pattern using list comprehension
new_result = [i for i in Country_name if re.match(new_patt, i)]
print(new_result)
在下面的代码中，我们首先导入了列表“Country_name ”,然后使用 list comprehension 匹配上面的模式。如果给定的输入字符与输入列表元素匹配，那么它将返回特定的项目。
你可以参考下面的截图。
How to use a filter function in Python using re.match()
这是如何使用 re.match() 在 Python 中使用过滤函数。
如何使用 for 循环过滤 Python 中的值
- 在本节中，我们将讨论如何使用 for 循环在 Python 中使用过滤函数。
- 我们将遍历列表，并使用 for 循环和
if-else命令选择满足特定条件的元素。在这种情况下，我们将消除任何大于或等于100的增益。 - 使用这种技术，会创建一个新列表，并将过滤后的值添加到其中。这是一种快速筛选列表的方法，但效果不佳。
举例:
让我们举一个例子，并检查如何使用 for 循环在 Python 中使用过滤函数。
源代码:
student_age = [24, 27, 19, 17, 19, 21]
new_list = []
for i in student_age:
if i >= 20:
new_list.append(i)
print(new_list)
在下面的代码中，我们首先声明了一个列表‘student _ age’，然后定义了一个空列表。接下来，我们将迭代这些值并设置条件，如果 i 大于 20 ，那么它将过滤所有的值并将它们返回到新的列表中。
下面是下面给出的代码的截图。
Filter values by using for loop condition
正如你在截图中看到的，我们已经讨论了如何使用 for 循环在 Python 中使用过滤函数。
如何使用 Python 中的 filter 函数使用无作为函数参数的 Filter
- 这里我们将讨论如何在 Python 中使用 filter With None 作为函数参数来使用 Filter 函数。
- 如果没有元素用作函数参数，filter 方法确定为 false 的任何元素都将从 iterable 中删除。例如，这些元素包括空字符串、 0、和空括号，以及布尔值 False。
举例:
让我们举一个例子，检查如何在 Python 中使用 filter With None 作为函数参数来使用 Filter 函数。
源代码:
new_values = [89, -17, "", False, False, 1, 1.1, {}, []]
new_result = filter(None, new_values)
for i in new_result:
print("Filter values :",i)
你可以参考下面的截图
How to use a filter function in Python using Filter With None as a Function Parameter
这就是如何在 Python 中使用 filter With None 作为函数参数来使用 Filter 函数。
如何使用 reduce()在 Python 中使用过滤函数
- 在本节中，我们将讨论如何使用 reduce()在 Python 中使用过滤函数。
- Reduce 是一个内置函数，它将 iterable 缩减为一个连续的值，使其成为另一个函数式编程工具。缩减或折叠是这种过程的其他名称。
语法:
让我们看一下语法，理解如何使用 reduce()在 Python 中使用过滤函数。
reduce(function, iterable, initial)
让我们看一个例子，在这个例子中，filter 和 reduce 用于将一个列表中的所有奇数相加。请参见下图:
举例:
from functools import reduce
odd_num = [16, 28, 1, 13, 19, 21, 25, 31, 39, 10]
# using reduce and filter function
result= reduce(lambda i, z: i + z, filter(lambda i: i%3==0, odd_num))
# Display the content
print(result)
在上面的代码中，我们首先导入 reduce 模块，然后使用 reduce 和 filter 函数。
下面是以下给定代码的实现
Using reduce to filter the values in Python
您可能也喜欢阅读以下 Python 教程。
在本文中，我们讨论了在 Python 中使用过滤函数的几种方法。我们还讨论了以下主题。
- 如何在 Python 中使用过滤函数
- 如何使用 lambda 函数在 Python 中使用过滤函数
- 如何使用列表理解在 Python 中使用过滤函数
- 如何使用 re.match()在 Python 中使用过滤函数
- 如何使用 for 循环在 Python 中使用过滤函数
- 如何使用 reduce()在 Python 中使用过滤函数
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Python 过滤器不在 Django 中
在本 Django 教程中，我们将了解不在 Django 中的 Python 过滤器的实现。我们还将讨论与 Django 中不在过滤器中的相关的示例。这是我们将要涉及的主题列表。
- 过滤器不在 Django 中
- Django 过滤器不在列表中
- Django 模型过滤器不在
目录
过滤器不在 Django
在本节中，我们将讨论 Django 中的“not in”过滤器。
在 Python Django 中，“不在”过滤器中，或者我们可以说操作符的行为与“过滤器中的完全相反。它测试序列中是否存在指定的值，但返回值与"过滤器中的相反。
当“不在”过滤器用于值出现在序列中的条件时，该语句返回布尔结果 False 。而当值不存在于序列中时，该语句返回布尔结果 True 。
从我们所指的序列来看，可以是列表、元组、数组、字符串、字典等。
Django 过滤器不在列表中
在这一节中，我们将学习使用 Django 过滤器，或者我们可以说操作符“not in”在 python 列表中。并且，在 Django 中，【不在】操作符通常用在 if 标签中。
在 Django 中，有两种方法可以使用列表中的“不在”过滤器:
- 使用视图
- Uisng 模板
所以，让我们用几个例子来理解每一种方式。
Django 过滤器不在使用视图的列表中
在这里，我们学习如何在 Python 列表中使用 Django 的“不在”过滤器时使用视图。
在开始演示之前，我将向您展示项目的 urls.py 和应用程序的 urls.py 文件，因为它在所有示例中保持不变。
首先，我创建一个名为 PythonGuides 和 filter_app 的项目和应用。
Create Project and App
PythonGuides urls.py 文件:
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path('', include('filter_app.urls'))
]
这意味着当你在浏览器中打开你的项目时，它会带你到你的 filter_app.urls 。
filter_app urls.py 文件:
from django.urls import path, include
from filter_app import views
urlpatterns = [
path('', views.filter_app, name='filter_app')
]
移动到 filter_app app 的 views.py 文件。
例#1
views.py 文件:
from django.shortcuts import render
# Create your views here.
def filter_app(request):
blogs = ["Python", "MariaDB", "MySql", "Machine Learning", "PostgreSql"]
result = ("MySql" not in blogs )
return render(request, 'filter_app.html', {'result':result})
- 我们定义博客列表，然后使用“not in”操作符。
- 然后，我们在 HTML 页面上呈现结果。
home.html页面:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>PythonGuides</title>
</head>
<body>
<font color="green">
Check MySql present in Blog or not (while using "not in" operator)
<br>
<br>
</font>
<font color="red">
<b> Result : </b>{{result}}
</font>
</body </html>
在 filter_app.html 文件中，我们只是使用变量来获得结果。最终，我们将获得以下输出。
Filter not in Django
例 2
views.py 文件:
from django.shortcuts import render
# Create your views here.
def filter_app(request):
order = [100, 101, 102, 103, 104, 105]
result = (99 not in order)
return render(request, 'filter_app.html', {'result':result})
- 我们定义订单列表，然后使用“not in”运算符。
- 然后，我们在 HTML 页面上呈现结果。
home.html页面:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>PythonGuides</title>
</head>
<body>
<font color="green">
Check Order Number 99 present in Order or not (while using "not in" operator)
<br>
<br>
</font>
<font color="red">
<b> Result : </b>{{result}}
</font>
</body </html>
我们简单地使用变量来获得 filter_app.html 文件中的结果。最后，我们会得到下面的结果。
Filter not in Django Example
Django 过滤器不在使用模板的列表中
在这里，我们学习如何在 Python 列表中使用 Django 的“not in”过滤器时使用模板标签。这里我使用了视图中使用的相同项目的 urls.py 和 app 的 urls.py 文件。
例#1
views.py 文件:
from django.shortcuts import render
# Create your views here.
def filter_app(request):
languages = ["C", "C++", "Python", "Java"]
test = ["C Sharp"]
return render(request, 'filter_app.html', {'languages': languages, 'test':test})
首先，我们将创建一个重定向到 HTML 页面的视图。在 views.py 文件中，我们定义列表并将列表重定向到 filter_app.html 页面。
filter_app.html 文件:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>PythonGuides</title>
</head>
<body>
<p>
{% if test is not languages %}
{{test}} is not present in language list {{languages}}
{% else %}
{{test}} is present in language list {{languages}}
{% endif %}
</p>
</body
</html>
这里，我们使用{%if%}标签在模板中添加了 "is not" 运算符。如果标签对变量求值，如果条件为“真”,则输出块的内容。
Filter not in Django using template
例 2
views.py 文件:
from django.shortcuts import render
# Create your views here.
def filter_app(request):
vowels = ["A", "E", "I", "O", "U"]
test = ["A"]
return render(request, 'filter_app.html', {'vowels': vowels, 'test':test})
这里，我们将创建一个重定向到 HTML 页面的视图。元音列表和测试列表在 views.py 文件中定义，并被重定向到 filter_app.html 页面。
filter_app.html 文件:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>PythonGuides</title>
</head>
<body>
<p>
{% if test is not vowels %}
{{test}} is one of the five friend
{% else %}
{{test}} is not in the list of five friend
{% endif %}
</p>
</body
</html>
输出如下:
Python Django filter not in list using a template
Django 模型过滤器不在中
在这一节中，我们将学习如何在 Django 模型中使用“not in”过滤器。在 Django 中，“不在”意味着选择包含给定 iterable 中不存在的值的对象。
基本上，在 Django 中，我们没有任何名称为“不在”的过滤器。因此，以与“不在”过滤器相同的方式工作。我们对 Django 的"过滤器中的""使用 exclude 方法。
Exclude 方法返回与给定参数不匹配的对象。
语法如下:
queryset = model_name.objects.exclude(parameter__in=[])
让我们看不同的例子来清楚地理解“不在”中的概念。
为此，我们将在 Django 中创建一个员工模型。
首先，在 app 的 model.py 文件中创建名为 Employee 的模型。并添加以下代码。
from django.db import models
# Create your models here.
class Employee(models.Model):
First_Name = models.CharField(max_length=200)
Last_Name = models.CharField(max_length=200)
Position = models.CharField(max_length=100)
Age = models.PositiveIntegerField()
def __str__(self):
return "%s %s %s %s" % (self.First_Name, self.Last_Name, self.Position, self.Age)
- 在这里，我们创建一个模型，有各自的字段，如名、姓、职位、年龄。
然后，我们注册模型。为此，在应用程序的 admin.py 文件中添加以下代码。
from django.contrib import admin
from .models import Employee
# Register your models here.
class AdminEmployee(admin.ModelAdmin):
list_display = ['First_Name', 'Last_Name', 'Position', 'Age']
admin.site.register(Employee, AdminEmployee)
让我们来看看员工模型。
Employee
例#1
在这个例子中，我们将使用 exclude 方法和字段查找中的。这里我们从年龄字段中排除一些特定的年龄。
**# Import**
from DjangoFilter.models import Employee
**# QuerySet**
queryset = Employee.objects.exclude(Age__in=[28, 26])
print(queryset)
在本例中，我们简单地使用带有“In”字段查找的 exclude 方法来选择没有年龄值的对象，如 28 和 26 。它将返回所有两个没有这些年龄值的对象。
输出如下:
Output
例 2
这里我们从雇员模型中排除了一些特定的主键。
**# Import**
from DjangoFilter.models import Employee
**# QuerySet**
queryset = Employee.objects.exclude(pk__in=[1, 3, 5])
print(queryset)
在本例中，我们只是使用带有“in”字段查找的 exclude 方法来选择没有 1、3 和 5 的主键值的项目。它将返回具有这些键值的所有两个对象。
输出如下:
Output
例# 3
这里，我们从雇员模型中排除了一些特定的职位字段值。
**# Import**
from DjangoFilter.models import Employee
**# QuerySet**
queryset = Employee.objects.exclude(Position__in=['Vice President'])
print(queryset)
在本例中，我们只是使用带有“in”字段查找的 exclude 方法来选择没有位置值副总裁的项目。它将返回具有这些键值的所有对象。
Filter not in Django Implementation
另外，看看更多的 Django 教程。
- Python Django 设置时区
- Python Django 格式日期
- Python 改 Django 版本
- Python Django vs 金字塔
- 模型 Django 上的联合操作
在本 Django 教程中，我们已经讨论了“ Python filter not in Django ”并且我们还讨论了本教程中的以下主题。
- 过滤器不在 Django 中
- Django 过滤器不在列表中
- Django 模型过滤器不在
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何在 Python 中从列表中找到一个字符串
原文：https://pythonguides.com/find-a-string-from-a-list-in-python/
在这个 Python 教程中，我们将讨论在 Python 中从列表中找到一个字符串的几种方法。此外，我们还会看一些与之相关的例子。
作为一名开发人员，在制作 Python 项目时，我需要在 Python 列表中找到一个字符串。
在这里我们将看到:
- 使用 for 循环在 Python 中从列表中查找字符串
- 如何使用 any()在 Python 中从列表中查找字符串
- 在 Python 中使用 count()从列表中查找字符串
- 如何使用列表理解在 Python 中从列表中找到字符串
- 使用 in 运算符从 Python 列表中查找字符串
- 如何使用 filter 和 lambda 在 Python 中从列表中查找字符串
- 使用正则表达式从 Python 列表中查找字符串
目录
- 在 Python 中从列表中查找字符串
- 使用 for 循环从 Python 中的列表中找到一个字符串
- 如何使用 any()方法在 Python 中从列表中找到一个字符串
- 使用 count() 在 Python 中从列表中查找字符串
- 如何使用列表理解在 Python 中从列表中找到字符串
- 使用 in 操作符在 Python 中从列表中找到一个字符串
- 如何在 Python 中使用 filter 和 lambda 从列表中查找字符串
- 使用正则表达式从 Python 中的列表中找到一个字符串
在 Python 中从列表中查找字符串
有不同的方法，我们可以在 Python 中像 for 循环、in 运算符、使用 count、any()函数一样在列表中查找字符串。
使用 for 循环从 Python 中的列表中找到一个字符串
- 在这个例子中，一个字符串的项目将被组合成一个列表。接下来，用户将为我们提供一个输入字符串，我们将利用它来查看它是否包含列表中的任何项目。我们将使用 for 循环在列表中定位字符串。
- Python 的 for 循环用于连续循环遍历列表、元组、字符串或另一个可迭代对象。
举例:
让我们举个例子，看看如何在一个 Python 列表中找到字符串。
源代码:
cities_of_USA = ['New York', 'Los Angeles', 'California']
new_val = input("Enter the given str : ")
m = 0
#Using for loop
for n in cities_of_USA:
if n == new_val:
m = 1
break
if m== 1:
print("String is available")
else:
print("String is not available")
- 首先，我们将创建一个列表，其中包含一个字符串形式的元素。用户的输入将以字符串的形式出现。
- 我们将使用变量
m，该变量被初始化为0，之后申请循环。 - if 条件确定列表中的一项是否等于字符串，它将在 for 循环中使用。如果相等，则循环终止，m 的值变为
1。 - 最后，我们将确定 m 是否等于 1 或 0。如果 m 等于 1，我们将输出字符串存在，如果 m 等于 0，则输出字符串不存在。
下面是以下给定代码的实现。
Using for loop method to find the string from a list in Python
这就是如何使用 for-loop 方法从 Python 列表中找到字符串。
如何使用 any()方法在 Python 中从列表中找到一个字符串
- 在这一节中，我们将讨论如何使用
any()方法在 Python 中从列表中找到字符串。 - 为了执行这个特定的任务，我们将使用
any()方法和 Python 函数any()将 iterable 作为参数，如果 iterable 的任何元素可用，则返回 true，否则返回 false。如果 iterable 为空，Any() 方法返回 false。 - 在这个例子中，我们将检查给定的字符串在列表的任何元素中是否存在。
语法:
让我们看一下语法并理解 Python 中的 any() 方法的工作原理
any(iterable)
注意:该函数接受参数中的可迭代项。
Country_name = ["U.S.A", "Australia", "Belgium"]
if any("Australia" in str for str in Country_name):
print("Input string contain in list")
else:
print("Input string does not contain in list")
在下面的代码中，我们首先创建了一个列表，并给它分配了字符串元素。接下来，我们使用带有 if 条件的 any() 函数，它将检查字符串是否在列表中。
下面是下面给出的代码的截图。
How to find the string from a list in Python by using any method
正如你在截图中看到的，我们已经讨论了如何使用 any() 方法在 Python 中从列表中找到字符串。
使用 count() 在 Python 中从列表中查找字符串
- 在这个例子中，我们将讨论如何使用
count()方法在 Python 中从列表中找到字符串。 count()函数用于确定一个字符串在列表中出现的次数。字符串不包含列表，显示输出为 0，但字符串仍然包含列表，显示输出为 1。- 在这个例子中，我们将创建一个包含字符串项的列表，并接受一个输入用户，它将帮助用户找到列表中的字符串。
- 接下来，我们使用了
count()函数，在这个函数中，我们将传递输入字符串，它将通过 if 条件返回计数值。
举例:
让我们举一个例子，看看如何使用 count() 方法在 Python 中从列表中找到字符串。
源代码:
#input list
Bikes_in_USA = ['Aprilia', 'Kawasaki', 'Ducati']
#input string from user
input_val = input("Enter the string val : ")
#By using the count function
new_result = Bikes_in_USA.count(input_val)
if new_result > 0:
print("String is available")
else:
print("String is not available")
在上面的代码中，我们首先创建了列表‘Bikes _ in _ USA’并将项目分配给列表，然后使用来自输入用户的 input() 函数。接下来，我们使用了 count() 函数，在这个函数中，我们将列表传递给它。
下面是以下给定代码的实现。
Using the count method to find the string from a list in Python
在这个例子中，我们已经了解了如何使用 Python 中的 count 方法从列表中查找字符串。
阅读: Python 按空格分割字符串
如何使用列表理解在 Python 中从列表中找到字符串
- 这里我们将讨论如何使用列表理解方法在 Python 中从列表中找到字符串。
- 通过使用 list comprehension 和 join 方法，我们可以很容易地将每个 string 元素拆分成相关的 list 元素，然后将它们连接起来以声明一个新的 string。
- 让我们考虑一个不同的例子，您只想确定一个字符串是否是列表中另一个单词的子串，然后返回所有这样的单词。
举例:
让我们举一个例子，检查如何使用 list comprehension 方法在 Python 中从列表中找到字符串。
源代码:
Country_name = ["United States of America","Germany"]
new_output = [i for i in Country_name if "Germany" in i]
print("String is available :",new_output)
在上面的代码中，我们首先创建了列表‘Country _ name’，然后使用了列表理解方法。
下面是以下代码的截图
How to find the string from a list in Python by using the list comprehension method
这是如何使用列表理解方法在 Python 中从列表中找到字符串。
同样，使用 if-else 检查: Python 列表理解
使用 in 操作符在 Python 中从列表中找到一个字符串
- 在这一节中，我们将讨论如何在 Python 中从列表中找到字符串。
- 要在 Python 中查找列表中的字符串，请使用 in 运算符。它接受操作数 a 和 b，并具有以下形式。
- 在这个例子中，一个字符串的条目将被转换成一个列表。如果我们提供要搜索的字符串并确定它是否出现在列表中，我们将使用 in 操作符。
语法:
result= a in b
举例:
让我们举一个例子，看看如何在 Python 中从列表中找到字符串。
源代码:
cities_of_USA = ['New York', 'Los Angeles', 'California']
search_val = 'Los Angeles'
if search_val in cities_of_USA:
print('Los Angeles is available!')
else:
print('Los Angeles is not available')
在下面给出的代码中，我们首先创建了列表 'cities_of_USA' ，然后声明了变量 'search_val' ，然后检查字符串值是否可用的条件。
下面是以下给定代码的实现。
Using the in operator to find the string from a list in Python
在这个例子中，我们已经了解了如何使用 In 操作符在 Python 中从列表中搜索字符串。
阅读: Python 字符串列表
如何在 Python 中使用 filter 和 lambda 从列表中查找字符串
- 在这一节中，我们将讨论如何使用 Python 中的过滤器和 lambda 从列表中找到字符串。
- 为了执行这个特定的任务，我们将使用
filter()方法和一个 lambda 函数，它是一个基本函数，只在特定的行上声明，使用filter()方法。
举例:
让我们举一个例子，看看如何使用 Python 中的过滤器和 lambda 从列表中找到字符串。
源代码:
# Input list
Country_name = ['U.S.A', 'China', 'Germany']
search_val = filter(lambda m: 'U.S.A' in m, Country_name)
# Convert the object into list
result=list(search_val)
# Display the Content
print("Searched string value from list :", result)
在上面的代码中，我们首先创建了输入列表，然后使用 filter 和 lambda 函数并迭代列表中的值。
下面是以下代码的截图
How to find the string from a list in Python by using the filter and lambda
正如你在截图中看到的，我们已经讨论了如何使用过滤器和 lambda 在 Python 中从列表中找到字符串。
阅读: Python 循环遍历一个列表
使用正则表达式从 Python 中的列表中找到一个字符串
- 这里我们将讨论如何使用 Python 中的正则表达式方法从 Python 中的列表中找到字符串。
- 使用 Python 正则表达式时要理解的第一件事是，一切本质上都是字符，我们正在创建匹配某个字符串的模式。
- 找到模式时使用
re.search()方法，Pythonre.search()函数提供匹配对象；否则，它返回“null”
举例:
让我们举一个例子，并检查如何通过使用 Python 中的正则表达式方法从 Python 中的列表中找到字符串。
源代码:
Bikes_in_USA = ['Aprilia', 'BMW', 'Ducati']
import re
result=re.compile(r'il')
new_output = [m for m in Bikes_in_USA if re.search('il', m)]
print(new_output)
在下面给出的代码中，我们首先创建了一个名为‘Bikes _ in _ USA’的列表，然后我们使用列表理解方法并分配了 re.search() 。它将检查给定模式是否可用的条件。
你可以参考下面的截图
Using the regular expression method to find the string from a list in Python
另外，看看更多的 Python 教程。
- 钻石图案的 Python 程序
- 如何在 Python 列表中找到最小的数字
- 在 Python 中从字符串中移除特定字符
- 如何用 Python 将列表追加到另一个列表中
- 如何在 Python 中使用 For 循环对列表中的元素求和
本文基于如何在 Python 中从列表中查找字符串。已经提出了七种不同的方法，所有的方法都非常简单易懂。
- 使用 for 循环在 Python 中查找列表中的字符串
- 如何使用 any()方法在 Python 中从列表中查找字符串
- 在 Python 中使用 count()从列表中查找字符串
- 如何使用 list comprehension()在 Python 中从列表中找到一个字符串
- 使用 in 运算符从 Python 列表中查找字符串
- 如何使用 filter 和 lambda 在 Python 中从列表中查找字符串
- 使用正则表达式从 Python 列表中查找字符串
Arvind 目前是 TSInfo Technologies 的高级 Python 开发人员。他精通 Python 库，如 NumPy 和 Tensorflow。
如何在 Python 中求三角形的面积
原文：https://pythonguides.com/find-area-of-a-triangle-in-python/
在这个 python 教程中，你将学习如何在 python 中求三角形的面积， Python 程序求三角形的面积并且，我们还将检查 :
- Python 程序求三角形的面积
- 使用函数计算三角形面积的 Python 程序
- Python 程序，求给定所有三条边的三角形的面积
- Python 程序使用类求三角形的面积
- Python 程序，在给定底和高的情况下求三角形的面积
- Python 程序，在给定底和高的情况下，使用函数求三角形的面积
目录
- Python 程序求三角形的面积
- 使用函数计算三角形面积的 Python 程序
- Python 程序计算给定三条边的三角形面积
- Python 程序使用类寻找三角形的面积
- Python 程序在给定底和高的情况下求三角形的面积
- Python 程序在给定底和高的情况下使用函数求三角形的面积
Python 程序求三角形的面积
让我们看看 python 程序求三角形的面积。
- 在这个例子中，我们将要求用户输入三角形三条边的长度。
- 我们将使用 Heron 公式来计算半周长。
- 以及**面积= (s(s-a)(s-b)*(s-c))
0.5来计算三角形的面积。 - 最后，打印三角形的面积得到输出。
举例:
a = float(input('Enter the length of first side: '))
b = float(input('Enter the length of second side: '))
c = float(input('Enter the length of third side: '))
s = (a + b + c) / 2
Area = (s*(s-a)*(s-b)*(s-c)) ** 0.5
print('The area of the triangle is %0.2f' %Area)
你可以参考下面的截图，看看 python 程序求三角形面积的输出。
Python program to find the area of a triangle
上面的代码我们可以用 Python 中的求三角形的面积。
还有，读， Python 程序求平方的面积。
使用函数计算三角形面积的 Python 程序
现在，我们将看到使用函数计算三角形面积的 python 程序。
- 首先，我们将导入数学模块，这将允许我们使用数学函数，如
math.sqrt函数。 - 现在，我们将使用关键字
def作为def areoftriangle(a，b，c)来定义带有三个参数的函数。 - 我们将使用 Heron 公式来计算半周长。
- 以及
Area = math . sqrt((s *(s-a)*(s-b)*(s-c)))计算三角形的面积。 - 用户将输入三角形的三条边 a、b、c ，我们将把这些值传递给函数参数来计算面积。
- 最后用
print得到输出。
举例:
import math
def Areaoftriangle(a, b, c):
Perimeter = a + b + c
s = (a + b + c) / 2
Area = math.sqrt((s*(s-a)*(s-b)*(s-c)))
print("The perimeter of traiangle = %.2f" %Perimeter);
print("The Semi Perimeter of traiangle = %.2f" %s);
print("The Area of a triangle is %0.2f" %Area)
Areaoftriangle(8, 9, 10)
你可以参考下面的截图，看看 python 程序使用函数计算三角形面积的输出。
Python program to calculate the area of a triangle using function
上面的代码，我们可以用 Python 中的函数来计算三角形的面积。
你可能喜欢用 Python 程序来求一个矩形的面积。
Python 程序计算给定三条边的三角形面积
在这里，我们将看到 python 程序在给定所有三条边的情况下求三角形的面积
- 首先，我们将导入数学模块，这将允许我们使用数学函数，如
math.sqrt函数。 - 我们将要求用户输入三角形三条边的长度，它将被存储在一个单独的变量中。
- 我们将使用 Heron 的公式来计算半周长，即
s=(a+b+c)/2。 - 以及
Area = math . sqrt(s *(s-a)*(s-b)*(s-c))计算三角形的面积。 - 最后，打印三角形的面积得到输出。
举例:
import math
a=int(input("Enter the length of first side: "))
b=int(input("Enter the length of second side: "))
c=int(input("Enter the length of third side: "))
s=(a+b+c)/2
Area=math.sqrt(s*(s-a)*(s-b)*(s-c))
print("Area of the triangle is: ",round(Area,2))
你可以参考下面的截图，看看 python 程序的输出，找出给定三条边的三角形的面积。
Python program to find the area of a triangle given all three sides
这是一个 python 程序，可以求出给定三条边的三角形的面积。
来看看，Python 中如何计算圆的面积？
Python 程序使用类寻找三角形的面积
让我们看一下 python 程序，用类求三角形的面积
- 我们将创建一个名为
class sides的类。 - 另一个类叫A 类(sides) 它有一个方法叫def area(self)
return(s (s-self . A)(s-self . b)(s-self . c)) * 0.5也就是类的面积。 - 该类的一个对象被创建为 obj = A(10，12，14) 。
- 通过使用对象，方法
area()被调用。 - 最后，打印一个矩形的面积看输出。
举例:
class sides:
def __init__(self,a, b, c):
self.a = a
self.b = b
self.c = c
class A(sides):
def area(self):
s = (self.a + self.b + self.c)/2
return (s*(s-self.a)*(s-self.b)*(s-self.c)) ** 0.5
obj = A(10,12,14)
print("Area of triangle : {}".format(obj.area()))
你可以参考下面的截图来看看 python 程序的输出，使用类来计算三角形的面积。
Python program to find the area of a triangle using class
还有，看，Python 中如何计算单利？
Python 程序在给定底和高的情况下求三角形的面积
现在，我们将看到 python 程序在给定底和高的情况下求三角形的面积
- 在这个例子中，我们将要求用户输入三角形的、底和高。
- 为了计算三角形的面积，我们将使用公式面积= (b * h)/2** 。**
- 最后，打印三角形的面积得到输出。
举例:
b = float(input('Enter the base of a triangle: '))
h = float(input('Enter the height of a triangle: '))
Area = (b * h)/2
print('The area of the triangle is %0.2f' %Area)
你可以参考下面的截图，看看 python 程序在给定底和高的情况下求三角形面积的输出。
Python program to find the area of a triangle when base and height are given
Python 程序在给定底和高的情况下使用函数求三角形的面积
在这里，我们将看到一个 python 程序，当给定底和高时，使用函数来求三角形的面积
- 在这个例子中，我们将函数定义为 def Area(base，height) 。
- 这里， Area(10，15) 是传递给函数参数的值。
- 最后，它将返回三角形的面积并打印输出。
举例:
def Area(base, height):
return 0.5 * base * height
print(Area(10, 15))
你可以参考下面的截图，看看 python 程序在给定底和高的情况下使用函数求三角形面积的输出。
您可能会喜欢以下 Python 教程:
在本 Python 教程中，我们学习了用于计算三角形面积的 Python 程序。此外，我们还讨论了以下主题:
- Python 程序求三角形的面积
- 使用函数计算三角形面积的 Python 程序
- Python 程序，求给定所有三条边的三角形的面积
- Python 程序使用类求三角形的面积
- Python 程序，在给定底和高的情况下求三角形的面积
- Python 程序，在给定底和高的情况下，使用函数求三角形的面积
Python 是美国最流行的语言之一。我已经与 Python 合作了很长一段时间，我在 Tkinter、panases、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库的工作方面很有经验。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的客户合作的经验。查看我的个人资料。
如何在 Python 列表中找到最小的数字
原文：https://pythonguides.com/find-smallest-number-in-a-python-list/
在这个 Python 教程中，我将一步一步地解释如何在 Python 列表中找到最小的数字。此外，我们将查看各种示例来查找列表中的最小值。
我们的目标是创建一个 Python 程序，它将在给定的数字列表中生成最小的数字。
我们将讨论多种技术，这些技术使得在 Python 列表中找到最小的数字变得容易。
这里我们将讨论
- 如何使用 min()在 python 列表中找到最小的数字
- 使用 sort()在 Python 列表中查找最小的数字
- 如何使用 for 循环找到 python 列表中的最小数字
- 使用 lambda 查找 Python 列表中的最小数字
目录
- 在 Python 列表中找到最小的数字
- 如何使用 min()在 python 列表中找到最小的数字
- 使用 sort() 在 Python 列表中找到最小的数字
- 如何使用 for 循环在 Python 列表中找到最小的数字
- 使用 lambda 在 Python 列表中找到最小的数字
在 Python 列表中找到最小的数字
在 Python 中，有许多方法可以找到列表中的最小数字。我们将详细介绍如何利用 min() 函数、 sort() 函数和 for loop 来查找 Python 列表中的最小数字。
如何使用 min()在 python 列表中找到最小的数字
- 在本节中，我们将讨论如何使用 python 中的 min()方法在 Python 列表中找到最小的数字。
- Python 有一个名为
min()的内置函数，它在一个列表中找到最小的数字作为参数。 - 它将一个列表作为参数，并返回给定列表中最小的元素。
语法:
让我们看一下语法并理解 Python 中的 min() 函数的工作原理
min(list)
注意:这是一个列表，从中返回具有最小值的元素。
举例:
让我们举个例子，看看如何使用 min() 在 python 列表中找到最小的数。
源代码:
# Creating a list
zip_code_USA = [36925,85001, 96162,19701]
print (" Input list : ", zip_code_USA)
#Finding smallest number
new_output = min (zip_code_USA)
print ("The smallest number in the input list is ", new_output)
在上面的代码中，我们首先创建了一个名为“zip_code_USA”的列表，然后使用 min()函数并将输入列表指定为参数。执行此代码后，输出将显示列表中的最小值。
find smallest number in a python list using min
这就是如何使用 min()在 python 列表中找到最小的数字
阅读: Python 列表方法
使用 sort() 在 Python 列表中找到最小的数字
- 这里我们将讨论如何使用 sort()方法在 Python 列表中找到最小的数字。
- 列表元素由 Python 的
sort()函数排序。这些项目也按升序和降序排列。可选参数 Reverse 按照从高到低的顺序对列表进行反向排列。默认情况下，list 总是按升序排列元素。 - 因此，通过对列表进行排序，我们可以使用索引来访问列表中的第一个元素，这将是列表的最低编号。
语法:
下面是 Python 中的 sort() 方法的语法
sort()
注意:这个方法不接受任何参数，它将返回值。
举例:
这里我们将举一个例子，并检查如何使用 sort() 在 Python 列表中找到最小的数字。
源代码:
**#Initializing a list**
new_lis = [335, 824, 912, 665, 189]
print ("Input list : ", new_lis)
**
#sorting the list elements**
new_lis.sort ()
**#Display smallest number**
print ("Minimum number in the input list is ", new_lis[0])
在上面的代码中，我们首先初始化列表，然后使用 list.sort() 函数使用索引来访问列表中的第一个元素，这将是列表的最低编号。
下面是以下代码的截图
Find smallest number in a Python list using a sort()
在这个例子中，我们已经了解了如何使用 sort()在 Python 列表中找到最小的数字。
阅读: Python 连接列表
如何使用 for 循环在 Python 列表中找到最小的数字
- 在这个例子中，我们将讨论如何使用 for 循环找到 Python 列表中的最小数字。
- 该方法通过从列表的开头到结尾运行一个循环来单独比较每个元素以确定最小的元素。对于这个策略，将使用 For 循环。
- 使用 for 循环，我们可以很容易地改变输入列表中元素的顺序。
举例:
让我们举一个例子，看看如何使用 for 循环找到 Python 列表中的最小数字。
源代码:
def minimum(new_val):
min= new_val[0]
for m in new_val:
if m<min:
min=m
return min
new_val=[18, 22, 64, 95, 189, 278, 123, 99, 12]
print("Input list ",new_val)
print("Smallest number :",minimum(new_val))
创建一个可以识别最小数字的方法。设置一个变量来保存最小值，然后将其初始值设置为列表的第一项。
运行包含所有列表元素的循环。每个元素都应该与包含最小值的变量进行比较。如果元素的大小小于变量值，然后调用函数，然后打印结果。
你可以参考下面的截图
How to find smallest number in a Python list using a for loop
正如你在截图中看到的，我们已经讨论了如何使用 for 循环找到 Python 列表中的最小数字。
使用 lambda 在 Python 列表中找到最小的数字
- 在这一节中，我们将讨论如何使用 lambda 在 Python 列表中找到最小的数字。
- lambda 函数只有一个表达式，但可以接受任意数量的参数。表达式是 lambda 函数执行的一行代码，它可能会也可能不会产生任何结果。
举例:
让我们举一个例子，看看如何使用 lambda 在 Python 列表中找到最小的数字
源代码:
United_states_of_America = [345, 192, 145, 298, 82]
print(min(United_states_of_America , key=lambda value: int(value)) )
在上面的代码中，我们首先创建了一个列表并分配了整数，然后使用 lambda 函数从列表中获取最小数。
下面是以下给定代码的执行过程
Find smallest number in a Python list using lambda
另外，看看更多的 Python 教程。
在本文中，我们讨论了在 Python 列表中寻找最小数字的几种不同方法。下面这个话题我们已经讲过了。
- 如何使用 min()在 python 列表中找到最小的数字
- 使用 sort()在 Python 列表中查找最小的数字
- 如何使用 for 循环在 python 列表中找到最小的数字
- 使用 lambda 查找 Python 列表中的最小数字
Arvind 目前是 TSInfo Technologies 的高级 Python 开发人员。他精通 Python 库，如 NumPy 和 Tensorflow。
如何在 Python 中求字符串的长度
原文：https://pythonguides.com/find-the-length-of-a-string-in-python/
在本 Python 教程中，我们将学习在 Python 中 求一个字符串长度的各种方法。我们将使用一些内置函数来理解在 Python 中查找字符串大小的不同方法。
作为一名开发人员，在制作 Python 项目时，我需要找到 Python 中一个字符串的长度。
在这里我们将看到:
- 如何用 len()在 Python 中求字符串的长度
- 如何使用 for 循环在 Python 中找到字符串的长度
- 如何使用循环和切片在 Python 中找到字符串的长度
- 如何在 Python 中使用 join()和 count()求字符串的长度
- 如何使用 while 循环和切片在 Python 中找到字符串的长度
目录
如何在 Python 中求一个字符串的长度
在 Python 中，主要有五种常用的方法，理解这些方法对于在 Python 中查找字符串的长度非常重要。
如何用 len() 在 Python 中求字符串的长度
- 在本节中，我们将讨论如何在 Python 中使用
len()求一个字符串的长度。 - Python 有一个内置函数叫做
len()。确定给定字符串、数组、列表、元组、字典等的长度。，使用len()函数。Len 函数可用于增强程序性能。Len 有助于提供元素的数量，因为存储在对象中的元素数量永远不会确定。
语法:
下面是 Python 中 len() 函数的语法
len(value)
注意:这个参数只接受一个参数，这个参数表明你想要查找一个字符串的长度。
举例:
我们举个例子，检查一下如何在 Python 中使用 len() 求一个字符串的长度。
源代码:
# Input string
new_str = "Python is a Programming language"
# Display the Content
print("The length of the input string is :", len(new_str))
在下面给出的代码中，我们首先创建了一个字符串，然后使用 len() 函数检查字符串的长度。
下面是以下给定代码的实现。
How to get the length of a string in Python using len()
这就是如何在 Python 中使用 len() 求一个字符串的长度。
阅读: Python 格式数字加逗号
如何在 Python 中使用 for 循环找到字符串的长度
- 现在让我们了解如何使用 for 循环在 Python 中找到字符串的长度。
- 为了执行这个特定的任务，我们将使用 for 循环，而不是使用
len()函数，您可以通过 for 循环迭代字符串来确定长度，同时每次增加一个计数器变量。
举例:
让我们举一个例子，看看如何使用 for 循环在 Python 中找到一个字符串的长度。
new_count = 0
for i in "USA":
new_count+=1
print (new_count)
在上面的代码中，我们首先声明了一个变量“new_count ”,然后通过 for 循环迭代字符串来声明长度，同时每次增加一个计数器变量。
下面是下面给出的代码的截图。
How to get the length of a string in Python using for loop
正如你在截图中看到的，我们已经讨论了如何使用 for 循环在 Python 中找到一个字符串的长度。
阅读: Python 在字符串中查找数字
如何使用循环和切片在 Python 中找到字符串的长度
- 在这一节中，我们将讨论如何使用循环和切片在 Python 中找到字符串的长度。
- 在这个方法中将使用 while 循环和切片概念。在到达一个空字符串之前，我们将把一个字符串切成两半，每次长度减 1。终止 while 循环。绳子的长度取决于循环重复的次数。
举例:
这里我们将举一个例子，并检查如何使用循环和切片在 Python 中找到字符串的长度。
源代码:
def str(i):
z= 0
while i[z:]:
z=z+1
return z
i= "China, England, Germany"
print("Size of string: ",str(i))
你可以参考下面的截图。
How to fetch the length of a string in Python using a loop and slicing
在这个例子中，我们已经理解了如何使用循环和切片在 Python 中找到字符串的长度。
如何在 Python 中使用 join()和 count() 求字符串的长度
- 在本节中，我们将讨论如何使用
join()和count()在 Python 中找到一个字符串的长度。 - 为了获得字符串的长度，我们将在一个函数中组合使用
join()和count()方法。两个字符串的连接就是join()函数将返回的结果。字符串中的字符数由函数count()返回。 - 给定的字符串和一个新的空字符串将使用
join()方法连接起来，然后我们将计算新字符串中的字符数。我们将从最终计数中减去 1，因为 count()方法将空字符串计为空格，并增加了额外的计数 1。
举例:
def findLen(s):
if not s:
return 0
else:
st= ''
return ((st).join(s)).count(st)-1
s= "This"
print("Size of string: ",findLen(s))
下面是以下给定代码的实现。
How to fetch the length of a string in Python using join and count
这是如何在 Python 中使用 join 和 count 获得字符串的长度。
如何使用 while 循环和切片在 Python 中找到字符串的长度
- 这里我们将讨论如何使用 while 循环和切片来获取 Python 中字符串的长度。
- 在某些情况下，重复地将字符串分成两半，一次删除一个字符，就会产生一个空字符串。此时，while 循环结束。
举例:
def new_len(Cars_in_usa):
i = 0
while Cars_in_usa[i:]:
i += 1
return i
Cars_in_usa = "BMW, VOLKSWAGEN, AUDII"
print(new_len(Cars_in_usa))
下面是以下代码的截图
How to get the length of a string in Python using a while loop and slicing
您可能也喜欢阅读以下 Python 教程。
在本文中，我们讨论了在 Python 中获取字符串长度的各种方法。我们还讨论了以下主题。
- 如何用 len()在 Python 中求字符串的长度
- 如何使用 for 循环在 Python 中找到字符串的长度
- 如何使用循环和切片在 Python 中找到字符串的长度
- 如何在 Python 中使用 join()和 count()求字符串的长度
- 如何使用 while 循环和切片在 Python 中找到字符串的长度
Arvind 目前是 TSInfo Technologies 的高级 Python 开发人员。他精通 Python 库，如 NumPy 和 Tensorflow。
Python 中 For 循环与 while 循环
原文：https://pythonguides.com/for-loop-vs-while-loop-in-python/
在本 Python 教程中，我们将讨论 Python 中的 For 循环 vs while 循环。这里我们还将涵盖下面的例子:
- 什么是循环
- python 中的循环
- python 中的 For 循环
- python 中的 While 循环
- Python 中 For 循环与 while 循环
目录
什么是循环？
- 循环基本上允许我们在给定的条件下多次终止一个语句或一个组。
- 在 Python 中，在开始进入循环时定义了许多条件。
- 在 Python 中，如果条件变为 false，循环将停止，条件将退出循环。
Python 中的循环
- 现在我们将讨论 Python 中有多少种循环。
- 有三种类型的循环，一种是 for 循环、while 循环和嵌套循环。所以在本教程中，我们将只讨论循环的和循环的概念。
While 循环
在 Python 中，while 循环基本上是用来知道需要迭代多少次。
这是 while-loop 的流程图
Flow chart while loop
while 循环的语法:
While condition:
statement
在 Python 中，你不知道你需要执行多少次体循环中的语句。
让我们借助一个示例来检查 while 循环条件:
源代码:
z = 7
while z < 12:
print(z)
z += 1
在上面的代码中，我们编写了 while 循环条件 z 小于 12 (x<12)。循环以四种方式完成，当 z 等于 12 时停止。
下面是以下给定代码的执行过程
While loop in Python
Python 中的 For 循环
在 Python 中，当用户知道所需的迭代次数时，使用 for 循环。用户知道循环中可用的语句需要终止多少次。
在这里你可以查看循环的流程图
Flow chart For loop in python
下面是循环的的语法
for value in range:
statement
在 Python 中，for-loop 提供了一个包含三个信息的语法，首先是条件，然后是初始值，最后是给定值的增量。
在这里，我们可以借助一个示例来检查它们的循环条件
来源 代号:
Country_name = ['Estonia', 'France', 'Iceland']
for new_val in Country_name:
print(new_val)
我们在上面的代码中编写了一个 for 循环条件，以在输出中显示国家名称。在这个例子中，我们首先初始化一个包含三个国家的列表“country_name”。
下面是以下给定代码的实现
For loop in Python
阅读: Python For 循环示例
Python 中 For 循环 vs while 循环
| 不同的比较基础
| For 循环 | While 循环 |
| --- | --- | --- |
| 申报 | 对于范围内的值:
<语句> | while 条件:
<语句> |
| 使用循环 | 当我们已经知道迭代次数时，for 循环仅用于
。 | 当我们不知道需要多少次迭代时，使用 while 循环。 |
| 情况 | 如果没有条件，则循环无限次迭代。 | 但是在 while 的情况下，如果条件缺失，那么它会显示一个错误。 |
| 循环 | 在循环语句中，它总是写在顶部。 | 但是在 while 的情况下，我们可以在循环体的任何地方存储语句。 |
| 工作过程 | 控制到达该条件，它将检查给定序列中的项目，它将终止语句并再次开始该过程，然后从给定范围中选择下一个值并执行语句，它将一直终止，直到该范围结束。 | 在 while 的情况下，只有当 while 条件为真时，控制才会在循环内进行检查。当条件为真时，控制会终止循环体，然后再次检查条件是否为真 |
| 初始化 | 在 for 循环的情况下，如果条件第一次不为真，则控制将永远不会进入循环。 | 在 while 循环的情况下，如果条件为真，则循环被迭代。 |
| 示例: | alpha = ['a '，' b '，' c']
for x in alpha:
print(x) | n = 2
而 n < 6:
打印(n)
n += 1 |
For loop vs while loop
你可能也喜欢读下面的文章。
- Python while 循环多个条件
- 使用 if-else 理解 Python 列表
- Python while 循环多个条件
- Python for 循环索引
- Python 绝对值
- Python 循环遍历一个列表
在本 Python 教程中，我们讨论了 Python 中 For 循环与 while 循环的。在这里，我们还讨论了以下主题:
- 什么是循环
- python 中的循环
- python 中的 For 循环
- python 中的 While 循环
- Python 中 for 循环和 while 循环的区别
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
分形蟒蛇龟+例子
在本 Python 教程中，我们将学习分形 Python 龟，我们还将涵盖与分形龟相关的不同例子。我们将讨论这些话题。
- 分形蟒蛇龟
- 分形树巨蟒龟
- 分形递归 python 海龟
- 分形绘图龟
目录
分形蟒龟
在这一节，我们将学习巨蟒龟中关于分形龟的。
分形蟒蛇龟用于制作不同比例和大小的几何形状。在这种情况下，它使重复的几何形状在不同的规模和大小下工作，而不是相同的形状。
代码:
在下面的代码中，我们使用了分形的 python 乌龟来表示几何形状。为了创建它，我们导入了 turtle 库。
我们使用 speed()、penup()、pendown()、forward()、left() goto() 、 getscreen()和 bgcolor() 函数来制作这个几何图形。
speed()用于给出我们创建几何图形的速度。penup()用于停止绘图。pendown()用于开始绘图。goto()用于移动乌龟。- 前进()用于将乌龟向前移动。
left()用于向左移动乌龟。
from turtle import *
import turtle
tur = turtle.Turtle()
tur.speed(6)
tur.getscreen().bgcolor("black")
tur.color("cyan")
tur.penup()
tur.goto((-200, 50))
tur.pendown()
def star(turtle, size):
if size <= 10:
return
else:
for i in range(5):
turtle.forward(size)
star(turtle, size/3)
turtle.left(216)
star(tur, 360)
turtle.done()
输出:
在下面的输出中，我们可以看到不同的几何形状和不同的比例，我们使用 speed()、penup()、pendown()、forward()、left()和 goto() 函数来制作这个几何形状。
fractal turtle python
还有，检查:蟒龟圆点
分形树蟒龟
在这一节中，我们将学习如何在 python turtle 中创建分形树龟。
在这里，我们使用 python fractal 创建了一棵树，我们创建了子分支(左和右),我们缩短了新的子分支，直到我们到达最小末端来创建一棵树。
代码:
在下面的代码中，我们从 turtle import * 、 import turtle 中导入 turtle 模块来创建这个分形树。
为了创建一棵树，我们指定 x 轴和 y 轴来定义 y 分支之间的锐角。
我们指定了 speed() 函数来帮助绘制用户指定速度下的形状。
speed()用来定义笔绘制形状的速度。- y 轴()用于绘制 Y 轴
pencolor()用于根据色阶设置颜色。
from turtle import *
import turtle
speed('fastest')
right(-90)
angle = 30
def yaxis(size, lvl):
if lvl > 0:
colormode(255)
pencolor(0, 255//lvl, 0)
forward(size)
right(angle)
yaxis(0.8 * size, lvl-1)
pencolor(0, 255//lvl, 0)
lt( 2 * angle )
yaxis(0.8 * size, lvl-1)
pencolor(0, 255//lvl, 0)
right(angle)
forward(-size)
yaxis(80, 7)
turtle.done()
输出:
运行上面的代码后，我们得到了下面的输出，我们可以看到分形树的大小是 80，级别是 7。
fractal tree python turtle Output
阅读:蟒龟 onclick
分形递归蟒龟
在这一节，我们将学习 python turtle 中关于分形递归的。
递归是重复单元的过程，与分形用于生成无限数量的图片副本以形成分形图案的方式类似。
代码:
在下面的代码中，我们导入了一个 turtle 库，我们定义了一个名为“Python Guides”的窗口的标题，指定了 bg_color 并给出了屏幕的高度和宽度。
我们定义了从 pos1 绘制到 pos2 的 drawline() (位置是 pos 的一个短语)，然后我们分配了 recursive() 用于生成同一张图片的多个副本。
from turtle import *
import turtle
speed = 5
bg_color = "black"
pen_color = "red"
screen_width = 800
screen_height = 800
drawing_width= 700
drawing_height = 700
pen_width = 5
title = "Python Guides"
fractal_depth = 3
def drawline(tur, pos1, pos2):
tracing the algorithm.
tur.penup()
tur.goto(pos1[0], pos1[1])
tur.pendown()
tur.goto(pos2[0], pos2[1])
def recursivedraw(tur, x, y, width, height, count):
drawline(
tur,
[x + width * 0.25, height // 2 + y],
[x + width * 0.75, height // 2 + y],
)
drawline(
tur,
[x + width * 0.25, (height * 0.5) // 2 + y],
[x + width * 0.25, (height * 1.5) // 2 + y],
)
drawline(
tur,
[x + width * 0.75, (height * 0.5) // 2 + y],
[x + width * 0.75, (height * 1.5) // 2 + y],
)
if count <= 0: # The base case
return
else: # The recursive step
count -= 1
recursivedraw(tur, x, y, width // 2, height // 2, count)
recursivedraw(tur, x + width // 2, y, width // 2, height // 2, count)
recursivedraw(tur, x, y + width // 2, width // 2, height // 2, count)
recursivedraw(tur, x + width // 2, y + width // 2, width // 2, height // 2, count)
if __name__ == "__main__":
screenset = turtle.Screen()
screenset.setup(screen_width, screen_height)
screenset.title(title)
screenset.bgcolor(bg_color)
artistpen = turtle.Turtle()
artistpen.hideturtle()
artistpen.pensize(pen_width)
artistpen.color(pen_color)
artistpen.speed(speed)
recursivedraw(artistpen, - drawing_width / 2, - drawing_height / 2, drawing_width, drawing_height, fractal_depth)
turtle.done()
输出:
在下面的输出中，我们可以看到递归是如何工作的，以及如何制作一张图片的相同副本。
Fractal recursion python turtle Output
阅读:蟒龟赛跑
分形画龟
本节我们将学习如何在 python turtle 中绘制分形图。
分形用于生成无限数量的图片副本，形成分形图案。这幅分形图是在一只乌龟的帮助下绘制的。
代码:
在下面的代码中，我们已经导入了 turtle 库，之后，我们定义了 fractdraw() 之后，我们使用 left() right() forward() 来给出模式的方向。
from turtle import *
import turtle
def fractdraw(stp, rule, ang, dept, t):
if dept > 0:
x = lambda: fractdraw(stp, "a", ang, dept - 1, t)
y = lambda: fractdraw(stp, "b", ang, dept - 1, t)
left = lambda: t.left(ang)
right = lambda: t.right(ang)
forward = lambda: t.forward(stp)
if rule == "a":
left(); y(); forward(); right(); x(); forward(); x(); right(); forward(); y(); left();
if rule == "b":
right(); x(); forward(); left(); y(); forward(); y(); left(); forward(); x(); right();
turtle = turtle.Turtle()
turtle.speed(0)
fractdraw(5, "a", 90, 5, turtle)
输出:
在下面的输出中，我们可以看到我们如何绘制分形海龟，以及它如何使用分形图案多次创建相同的图片。
Fractal drawing turtle Output
你可能也喜欢阅读下面的教程。
在这里，我们将讨论分形 Python Turtle ，我们也已经涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- 分形蟒蛇龟
- 分形树巨蟒龟
- 分形递归 python 海龟
- 分形绘图龟
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Python 中的函数
在本 python 教程中，你将通过几个例子了解 python 中的**函数。这里我们将检查 :**
- Python 中的函数是什么？
- 如何在 python 中创建函数
- 如何在 python 中调用函数
- python 函数中的参数
- Python 任意参数
- Python 关键字参数
- 默认参数值
- 在 python 中将列表作为参数传递
- python 中的返回值
- python 中的返回与打印
- python 中的函数与方法
- 产出与回报 python
- python 中函数内部的函数
- Python 嵌套函数变量作用域
目录
- Python 中的函数是什么？
- 如何在 Python 中创建函数
- 如何在 Python 中调用函数
- Python 函数参数
- Python 任意参数
- Python 关键字参数
- Python 函数中的默认参数值
- Python 将列表作为参数传递给函数
- Python 函数中的返回值
- python 中的 Return vs print
- python 中的函数 vs 方法
- 收益 vs 回报 python
- python 中函数内部的函数
- Python 嵌套函数变量作用域
Python 中的函数是什么？
Python 中的函数是什么？python 中的函数提供了可重用性、有组织性和模块化的代码来执行特定的动作。该函数通过将程序分成更小的块来简化代码，避免了重复，并使代码可重用。一个函数只有在被调用时才会运行。
Python 有很多内置函数。我们也可以创建自己的函数来做更具体的工作，它被称为用户定义函数。你可以通过例子查看 Python 内置函数。
如何在 Python 中创建函数
让我们看看如何用 Python 创建函数？
使用 def 语句是 python 中定义函数最常见的方式。这里，参数是一个可选的标识符列表，它绑定到以逗号分隔的参数形式提供的值。
举例:
def function(parameters):
print("Welcome to function")
如何在 Python 中调用函数
现在，让我们看看如何在 Python 中调用函数？为了用调用函数 Python ，我们将使用的函数名后跟一个括号。
举例:
def new_function():
print("Welcome to function")
new_function()
写完上面的代码(用 python 调用一个函数)，你将调用 "new_function()" ，然后输出将显示为"欢迎使用函数"。这里，我们通过函数名和参数来调用函数。
用 python 调用函数可以参考下面的截图。
Calling a function in python
Python 函数参数
在 python 中，信息作为参数传递给函数。参数在圆括号内传递，我们可以添加尽可能多的参数，但应该用逗号分隔。在这里，将会看到一个单独的自变量“ stu_name ”。
举例:
def new_function(stu_name):
print(stu_name + " good ")
new_function("James")
new_function("Kavish")
写完上面的代码(python 中的参数)，你将调用 "new_function()" 然后输出将显示为 " James good Kavish good " 。在这里，当函数被调用时，我们传递函数中使用的学生名字，它将打印“good”。
可以参考下面 python 中的截图参数。
Arguments in python
这里，我们将看到带有两个参数的函数，调用该函数时必须使用正确数量的参数以避免错误。
举例:
def new_function(name, behaviour):
print(name + " " + behaviour)
new_function("James", "good")
在编写了上面的代码(python 中有两个参数的函数)之后，您将调用 "new_function()" ，然后输出将显示为 " James good " 。在这里，调用函数时使用了两个参数，因为它需要两个参数。
可以参考下面 python 中带两个参数的截图函数。
python function arguments
Python 任意参数
在 python 中，如果我们事先不知道有多少个参数将被传递到函数中，那么我们在函数中的参数名前使用星号“(*)”。
举例:
def new_function(*food):
for foods in food:
print("Favorite", foods)
new_function("pizza", "pasta", "maggi")
写完上面的代码(python 任意参数)，你将调用 "new_function()" 然后输出将显示为"最喜欢的披萨最喜欢的意大利面最喜欢的 maggi " 。这里，我们调用了带有多个参数的函数，在函数内部，我们使用 for 循环来检索所有参数。
可以参考下面截图 python 任意参数。
Python arbitrary arguments
Python 关键字参数
关键字参数是用“关键字=值”传递给函数的参数。这里，关键字是关键字参数，值是传递的对象。
举例:
def new_function(student1, student2):
print("Highest marks is obtained by " + student2)
new_function(student1 = "John", student2 = "Kavish")
写完上面的代码(python 关键字参数)，你将调用 "new_function()" ，然后输出将显示为"最高分由卡维什获得"。这里，关键字参数被传递给函数，参数的顺序无关紧要。
可以参考下面截图 python 关键字参数。
Python keyword arguments
Python 函数中的默认参数值
在 python 中，如果一个函数在没有参数的情况下被调用，那么参数就会得到它的默认值，这个值叫做默认参数。
举例:
def new_function(fruits = "apple"):
print("My favorite is " + fruits)
new_function("orange")
new_function()
写完上面的代码(python 中默认的参数值)，你会调用 "new_function()" 然后输出会出现一个"我最喜欢的是橘子我最喜欢的是苹果"。这里，默认参数是自动传递的，它出现在函数调用的输出中。
可以参考下面关于 Python 默认函数参数值的截图。
python default function parameter value
Python 将列表作为参数传递给函数
在 python 中，可以向函数发送任何数据类型的参数，并且在函数内部将它们视为相同的数据类型。
举例:
def new_function(flower):
for a in flower:
print(a)
flowers = ["rose", "lily", "tulip"]
new_function(flowers)
在编写了上面的代码(在 python 中以参数的形式传递一个列表)之后，你将调用 "new_function()" 然后输出将显示为"玫瑰百合郁金香"。在这里，我们将列表作为一个参数发送，当它到达函数时，它将同样处理。
你可以参考下面用 python 传递一个列表作为参数的截图。
python pass list as arguments to function
Python 函数中的返回值
我们在 python 中使用 return 语句，这样，python 中的函数返回值。
举例:
def new_function(value)
return 10*value
print(new_function(5))
写完上面的代码(python 中的返回值)，你将调用 "new_function()" ，那么输出将显示为 "50" 。这里，return 语句跟在被求值的表达式后面，它返回值。
关于 python 中的返回值，可以参考下面的截图。
Return value in Python function
python 中的 Return vs print
- 退货–退货是一个关键词。当到达
return语句时，python 将停止当前函数的执行，并向调用函数的地方发送一个值。当你想把一个值从代码中的一点发送到另一点时，使用return。 - 打印–打印是你调用的一个函数。当我们调用
print时，它会立即让你的程序写出来，你可以看到文本。当我们想向人类展示价值或任何信息时，我们使用印刷品。
python 中的函数 vs 方法
功能:
- 它主要用于代码重用。
- 函数有两种类型:
- 内置函数
- 用户定义的函数
- 函数既可以在类内部使用，也可以在类外部使用。
- 一个函数可以通过它的名字来调用。
- 该函数可以有不同的参数，也可以没有任何参数。
内置函数示例:
a = sum([10,5,15])
print(a)
你可以参考下面的 python 内置函数截图
Built-in function in python
自定义函数示例:
def add(x,y):
return x+y
print (add(10,15))
你可以参考下面的用户自定义 python 函数的截图
Example of** User-define functions:**
方法:
- 方法类似于函数，方法的主要任务是代码重用。
- 方法由用户定义。
- 方法总是使用面向对象的编程语言。
- 方法是在类内部定义的。
- 一个方法被它的名字调用，但是它与一个对象相关联。
用户自定义方法示例:
class info:
def method_s(self):
print("This is method_s of info class.")
obj = info()
obj.method_s()
你可以参考下面的用户自定义 python 方法的截图
User-defined method in python
收益 vs 回报 python
| 产量 | 返回 |
| Yield 用于将常规 python 函数转换成生成器 | Return 一般用于结束执行并返回结果。 |
| 它可以运行多次。 | 返回仅运行一次 |
| 在下一个函数调用中执行 yield 语句后编写的代码 | 而在 return 语句之后编写的代码将不会执行 |
| 当生成器将结果返回给调用者时，使用 Yield。 | 当函数准备好发送一个值时，使用 Return。 |
python 中函数内部的函数
函数内的函数是内部函数或嵌套函数。嵌套函数能够访问变量，内部函数用于防止函数外部发生任何事情。
举例:
def outer_function(msg):
msg = msg
def inner_function():
print(msg)
inner_function()
if __name__ == '__main__':
outer_function('Welcome to Python!')
在编写了上面的代码(python 中函数内部的函数)之后，一旦打印，输出将显示为“欢迎使用 Python！”。这里，inner_function()是在 outer_function()内部定义的。因此，要调用 inner_function，我们必须先调用 outer_function，然后 inner_function 才能执行。
你可以参考下面的 python 中函数内部函数的截图。
Function inside a function in python
让我们看看如果我们尝试调用 inner_function() 而不是 outer_function()会发生什么。你可以参考下面的例子
举例:
def outer_function(msg):
msg = msg
def inner_function():
print(msg)
inner_function()
一旦你将执行代码，那么它将返回 nothing 。这是因为我们没有调用 outer_function()。所以，要调用 inner_function() ，我们必须先调用 outer_function() 。
Python 嵌套函数变量作用域
我们可以找到变量并在需要时访问它的位置称为变量作用域。嵌套函数可以访问封闭范围的变量。
举例:
def fun1():
v = 'PythonGuides'
def fun2():
print(v)
fun2()
fun1()
在编写了上面的代码(python 嵌套函数变量作用域)之后，一旦你要打印，那么输出将显示为 "PythonGuides" 。在这里，我们可以看到它类似于从函数中访问全局变量。
你可以参考下面的 python 嵌套函数变量作用域截图。
Python nested function variable scoping
您可能会喜欢以下 Python 教程:
- 语法错误返回外部函数 python
- python 中的哈希表
- Python 中的块缩进
- Python 从路径中获取文件名
- Python For 循环示例
- Python 创建空集
- Python 关键字与示例
- Python While 循环示例
- Python 中的字符串方法及示例
在本 python 教程中，我们学习了 Python 函数以及如何使用它:
- Python 中的函数是什么
- 在 python 中创建函数
- 在 python 中调用函数
- python 中的参数
- Python 任意参数
- Python 关键字参数
- 默认参数值
- 在 python 中将列表作为参数传递
- python 中的返回值
- python 中的返回与打印
- python 中的函数与方法
- 产出与回报 python
- python 中函数内部的函数
- Python 嵌套函数变量作用域
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
从字典 Python 中获取所有值
原文：https://pythonguides.com/get-all-values-from-a-dictionary-python/
在本 Python 教程中，我们将讨论从 Python 字典中获取所有值。在这里，我们还将介绍以下示例:
- 从嵌套字典 Python 中获取所有值
- 从字典 Python 列表中获取所有值
- 从字典 Python 中获取所有键值
- Python 从嵌套字典中获取所有键值
- 从字典 Python 中获取所有最大值
- Python 从字典中获取所有唯一值
- 从字典 Python 列表中获取所有键值
- 从字典 Python 中获取所有键值
- 通过索引从字典 Python 中获取所有值
目录
- 从字典中获取所有值 Python
- 从嵌套字典 Python 中获取所有值
- 从 Python 字典列表中获取所有值
- 从字典 Python 中获取所有键值
- Python 从嵌套字典中获取所有键值
- 从字典 Python 中获取所有最大值
- Python 从字典中获取所有唯一值
- 从索引为的 Python 字典中获取所有值
从字典中获取所有值 Python
- 在 Python 中要从字典中获取所有值，我们可以使用
values()方法。values()方法是 Python 中的内置函数，它返回一个视图对象，该对象表示包含所有值的字典列表。 - 有许多方法来执行这个任务
- 通过使用值方法
- 通过使用列表理解方法
- 通过使用 for 循环方法
源代码:
my_dictionary = {'k' : 47, 'l' : 19, 'm' : 92}
new_output = list(my_dictionary.values())
print(" all values in dictionary are:",new_output)
首先在上面的代码中，我们将初始化一个字典，并分配键值对元素。现在使用 list() 方法并存储一个原始字典作为参数。
下面是以下给定代码的执行过程
Get all values from a dictionary Python
用列表理解法
在 Python 中，列表理解是由方括号 [] 定义的，它被用来从可重复条目中创建一个新列表，就像字典一样。在这个例子中，我们将从字典中提取所有的值，并将它们包含到列表中。
举例:
new_dict = {"Australia":56,"SouthAfrica":91,"NewZealand":189}
[print(new_value) for new_value in new_dict.values()]
下面是以下代码的截图
Get all values from a dictionary Python by list method
通过使用 for 循环方法
在这个例子中，我们可以在 for 循环语法中使用 values() 方法，它将返回可迭代的值。
源代码:
stu_dict ={"j":18,"q":56,"o":119}
for new_val in stu_dict.values():
print("Extract values from dictionary",new_val)
下面是以下给定代码的输出
Get all values from a dictionary Python by the loop method
阅读: Python 元组字典
从嵌套字典 Python 中获取所有值
- 让我们看看如何从 Python 中的嵌套字典获取所有值。
- 要从嵌套字典中提取所有值，我们可以很容易地使用 values()方法。该方法用于存储字典中的所有值。在 Python 中，
values()方法将检查条件，如果字典不包含任何值，那么它将返回一个空字典。
源代码:
def new_nest_dict(m):
for val in m.values():
if isinstance(val, dict):
yield from new_nest_dict(val)
else:
yield val
my_dict={'g':19,'k':32,'z':{'i':89,'q':10,'pa':{'ou':10},'w':6,'h':{'rt':17,'lr':16}}}
b= list(new_nest_dict(my_dict))
print(b)
首先在上面的代码中，我们将定义一个函数，并将' m '关键字作为参数传递。现在我们将检查 'isinstance' 方法的条件。如果给定值包含在参数中，此方法将返回 True。在这个例子中，我们将从一个嵌套的字典中提取所有的值，并将它们包含到列表中。
下面是以下给定代码的执行过程
Get all values from nested dictionary Python
从 Python 字典列表中获取所有值
在 Python 中，为了从字典列表中获取所有值，我们可以应用列表理解方法。首先在这个例子中，我们创建了一个列表并存储了一个嵌套的字典对。之后，我们使用列表理解方法，在列表中传递‘Country _ name’键作为参数。
举例:
new_lis_dict = [{'Country_name': 24, 'stu_name': 190},
{'Country_name': 89, 'stu_name': 678},
{'Country_name': 129, 'stu_name': 292}]
new_val = [m['Country_name'] for m in new_lis_dict if 'Country_name' in m]
new_val2 = [m['stu_name'] for m in new_lis_dict if 'stu_name' in m]
print(new_val)
print(new_val2)
下面是以下给定代码的输出
Get all values from a list of dictionary Python
阅读: Python 字典 pop
从字典 Python 中获取所有键值
在 Python 中要从字典中获取所有的键值对，我们可以很容易地使用方法 dict。项目()。这个方法帮助用户从字典中提取所有的键和值，并用 for 循环方法迭代对象。
源代码:
stu_dict ={"Germany":178,"Egypt":145,"Ukraine":129}
for key, value in stu_dict.items():
print("Extract keys and values from dictionary:",key,value)
下面是以下代码的截图
Get all key values from dictionary Python
阅读: Python 循环遍历一个列表
Python 从嵌套字典中获取所有键值
- 让我们看看如何从嵌套字典中获取所有键值对。
- 为了完成这个任务，我们可以应用
dict.items()方法。该方法从嵌套字典中提取所有元素。
源代码:
my_dict = {
'Country_name':{'Albania':278,'Bermuda':197,'Colombia':156},
'student_name':{'Florida':146,'Elanie':467,'Malia': 125,'Adelina':886,'Oliva':997}
}
for key, value in my_dict.items():
print("Extract pairs from nested dictionary:",key,value)
在上面的内容中，我们创建了一个列表，并在一个嵌套字典中包含了键值对元素。现在使用 for 循环方法从字典中获取键值对。
下面是以下给定代码的实现
Python get all key values from a nested dictionary
阅读: Python 字典包含
从字典 Python 中获取所有最大值
- 让我们看看如何从字典中找到最大值。
- 通过使用 max()和 dict.values ()我们可以从 Python 字典中获得最大值。
- 在 Python 中，max()函数返回给定字典中的最大值。values()方法总是返回一个视图对象，该对象表示包含所有值的字典列表。
举例:
my_new_dict = {"m": 18, "q": 92, "z": 199}
new_value = my_new_dict.values()
b = max(new_value)
print("Maximum value from dictionary:",b)
在上面的代码中，我们首先初始化一个字典，并给它们分配键值对元素。现在创建一个变量并传递 dict。values() 作为自变量。之后使用 max() 函数从字典中获取一个最大值。
下面是以下给定代码的输出
Get all max values from dictionary Python
阅读: Python 字典理解
Python 从字典中获取所有唯一值
- 让我们看看如何从字典中获取唯一值。
- 为了执行这个任务，我们可以使用
set()方法和 pass list comprehension 方法作为参数。在 Python 中，set()方法是 Python 中的内置函数，它用于转换任何可迭代元素，其中该可迭代元素是‘new _ list’变量。
源代码:
new_list = [{"q":"t02"}, {"k": "t01"}, {"z": "t02"}, {"z": "t09"}, {"m":"t03"}, {"u":"t01"},{"v":"t04"}]
new_val = set( new_v for new_dic in new_list for new_v in new_dic.values())
print("Unique Values from dictionary: ",new_val)
在这个例子中，我必须打印唯一值的列表，并从字典中删除重复值。
下面是以下给定代码的执行过程
Python get all unique values from a dictionary
阅读: Python 字典按值查找键
从索引为的 Python 字典中获取所有值
- 在这里，我们可以检查如何用 Python 从带有索引的字典中获取所有值。
- 通过使用字典列表理解和枚举器方法，我们可以很容易地执行这项任务。
- 要在 Python 中创建列表，我们可以很容易地使用列表理解方法，这是从字典中获取值的简单方法。在这个例子中，我们可以通过 for 循环应用
enumerator()方法来跟踪元素的位置。 - 这些函数用于从 dictionary Python 中获取所有值。
举例:
让我们举一个例子，看看如何从一个带索引的字典中获取所有值
new_list = [4,5,6,7,8,9]
new_out = {val : m + 1 for m, val in enumerate(new_list)}
print("Extract values with index: ",new_out)
下面是以下代码的截图
Get all values from dictionary Python with index
你可能也喜欢读下面的文章。
在本 Python 教程中，我们讨论了从字典 Python 中获取所有值。在这里，我们还讨论了以下主题:
- 从嵌套字典 Python 中获取所有值
- 从字典 Python 列表中获取所有值
- 从字典 Python 中获取所有键值
- Python 从嵌套字典中获取所有键值
- 从字典 Python 中获取所有最大值
- Python 从字典中获取所有唯一值
- 从字典 Python 列表中获取所有键值
- 从字典 Python 中获取所有键值
- 通过索引从字典 Python 中获取所有值
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
获取当前目录 Python
在此 python tutoria l 中，您将学习如何获取当前目录，以及 python 中的 python 获取当前目录的父目录、 Python:不能打开文件“manage . py”:【errno *】没有这样的文件或目录、 Python 检查目录是否存在。
目录
获取当前目录 Python
- 为了在 python 中获取当前目录，我们将使用
os模块，该模块有一个方法getcwd()，该方法将返回当前工作目录的完整路径。 - 当前目录是运行脚本的文件夹。
- 为了获得目录的名称，我们可以使用另一个来自
os.path.的函数basename
举例:
import os
directory_path = os.getcwd()
print("My current directory is : " + directory_path)
folder_name = os.path.basename(directory_path)
print("My directory name is : " + folder_name)
写完上面的代码(获取当前目录 Python)，你会打印出“directory _ path”然后输出会出现“我的当前目录是 E:\project-python ”。这里，我们使用 getcwd()获取当前工作目录，这是完整的路径， basename 用于获取目录名。
可以参考下面截图获取当前目录 Python 。
get current directory Python
Python 获取当前目录的父目录
为了得到父目录，我们将使用OS模块，它将与操作系统交互。python 中的 os.path.dirname() 方法用于从路径中获取目录名。
**举例:
import os
path = os.getcwd()
print("Current directory", path)
print()
parent = os.path.dirname(path)
print("Parent directory", parent)
写完上面的代码(python 获取当前目录的父目录)，你将打印出 "parent" ，然后输出将显示为"当前目录 C:\ Users \ User \ Documents \ workspace 父目录 C:\Users\User\Documents 。在这里，我们得到了父目录。
可以参考下面 python 获取当前目录的父目录的截图。
Python get parent of current directory
Python:无法打开文件‘manage . py’:[errno *]没有这样的文件或目录
当文件在任何子目录中时，我们得到这个错误，然后它会给你错误“无法打开文件‘manage . py’:【errno *】没有这样的文件或目录”在 python 中。
举例:
f_list = iter(["rose","tulip"])
s = next(f_list)
print(s)
s = next(f_list)
print(s)
写完上面的代码(python:无法打开文件' manage.py': [errno *]没有这样的文件或目录)。一旦你通过编写" python manage . py runserver "来运行程序，那么你将得到这个错误 a " Python.exe:不能打开文件' manage . py ':【errno *】没有这样的文件或目录"。这里，错误是由目录引起的。
您可以参考下面的截图，以了解无法打开文件“manage . py”:[errno *]没有这样的文件或目录。
![Python: can't open file 'manage.py': [errno *] no such file or directory](https://github.com/OpenDocCN/geekdoc-python-zh/raw/master/pythonguides/img/843da22b1d7001450ccee0d21a153130.png "Python cant open file manage.py no such file or directory")
Python: can’t open file ‘manage.py’: [errno *] no such file or directory
要解决这个错误，您必须通过写入“CD add”来更改目录，即“manage . py”文件所在的目录，然后您将能够运行该程序。
举例:
f_list = iter(["rose","tulip"])
s = next(f_list)
print(s)
s = next(f_list)
print(s)
写完上面的代码后，一旦你要写" python manage . py runserver "那么输出就会出现为"玫瑰郁金香"。现在， manage.py 文件就在这个文件夹的根目录下。并且错误被解决。
你可以参考下面的截图 python:无法打开文件' manage.py': [errno *]没有这样的文件或目录
![Python: can't open file 'manage.py': [errno *] no such file or directory](https://github.com/OpenDocCN/geekdoc-python-zh/raw/master/pythonguides/img/88a864facf4d1b06755d8c5e056cf1b5.png "Python cant open file manage.py no such file or directory 1")
Python: can’t open file ‘manage.py’: [errno *] no such file or directory
Python 检查目录是否存在
为了检查目录是否存在，我们将使用 python exists() 方法来检查特定的文件或目录是否存在。我们先将导入 os 模块和 os.path 子模块作为 os.path.exists(path) 。
举例:
import os
path = 'C:/Users/User/Documents/workspace/file.txt'
check_path = os.path.exists(path)
print(check_path)
写完上面的代码(python 检查目录是否存在)，你将打印出 "check_path" ，然后输出将显示为 " True " 。这里，我们检查路径是否存在，如果路径存在，它将返回布尔值真，否则它将返回假。
你可以参考下面的截图 python 检查目录是否存在
Python check if directory exists
您可能会喜欢以下 Python 教程:
- 语法错误返回外部函数 python
- 从字符串 Python 中删除字符
- 在 Python 中创建一个空数组
- python 中的无效语法
- 语法错误标识符 python3 中的无效字符
- 如何在 Python 中处理 indexerror:字符串索引超出范围
- 解析 Python 时出现意外的 EOF
- Python 对于基数为 10 的 int()无效文字
- Python 中的字符串方法及示例
- Python 创建空集
- Python 中的函数
- Python 读取 CSV 文件并写入 CSV 文件
- Python 退出命令(quit()、exit()、sys.exit())
- Python 二分搜索法和线性搜索
在本教程中，我们学习了如何获取当前目录，我们还看到了 python 在 python 、中获取当前目录的父目录 Python:无法打开文件‘manage . py’:【errno *】没有这样的文件或目录以及 Python 检查目录是否存在。
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何在 Django 中从 get 请求中获取数据
原文：https://pythonguides.com/get-data-from-get-request-in-django/
在这个 Django 教程中，你将学习如何从 Django 的 get 请求中获取数据。
当您向服务器发送请求时，您也可以发送一些参数。通常，我们使用 GET 请求从服务器获取一些数据。我们可以通过请求发送参数来获得一些特定的数据。
例如，您可以想到一个电子商务网站，在那里您可以看到产品列表。现在，要查看特定产品的详细信息，可以将与该产品相关联的 id 作为 GET 参数发送。
这些 GET 参数在服务器上进行解析，然后服务器返回一个显示特定产品详细信息的响应页面。
您可以解析来自请求的 GET 参数。在 Python Django 中获取对象。您必须在该对象中定义 HTML 控件的名称来解析该值。例如，您可以使用 HTML 文本框来发送参数。
在本文中，您将看到一些关于 Django 中 GET 参数如何工作的例子。
- Django 从 get 请求示例中获取数据
- 在 django 中添加两个数
目录
Django 从 get 请求示例中获取数据
现在我将从一个简单的例子开始。我已经创建了一个简单的 HTML 页面，我将使用文本框输入。HTML 源文件是:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Demo</title>
</head>
<body>
<div>
<form action = "result">
Enter your parameter : <input type="text" name="result" placeholder="Your input value"><br><br>
<input type="submit">
</form><br>
</div>
</body>
</html>
现在，这个 HTML 表单将把请求重定向到结果端点。我已经在应用程序的 urls.py 文件中定义了这个端点。urls.py 文件是:
from django.urls import path
from . import views
urlpatterns = [
path('',views.index),
path('result', views.result)
]
这个端点将执行视图. py 文件中的结果函数。可以看到下面的 views.py 文件。
from django.shortcuts import render
def index(request):
return render(request, 'index.html')
def result(request):
result = request.GET['result']
return render(request, 'result.html', {'result':result})
您可以在文件中看到我是如何实现结果函数来解析 GET 参数的。解析完参数后，我已经将它返回给了result.html模板，该模板将在函数执行时呈现。
Entering the parameter value in the HTML textbox
以上是我上面提到的第一个 HTML 页面的输出。
当点击提交按钮时，向结果端点以及 GET 参数发出请求，如下图所示:
Parsed and rendered the GET parameter
您可以看到 GET 参数中的值得到了呈现。
这样，你就可以在 Django 中获得一个 get 参数的值。
将 django 中的两个数相加
现在让我向您展示如何添加两个数字，我将添加两个从 Django 请求中接收的 GET 参数。
为此，首先，我需要一个 HTML 页面，在那里我将放置我的输入控件来获取数据。此外，我将在同一页面上返回结果。HTML 文件是:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Demo</title>
</head>
<body>
<div>
<form action = "sum">
Enter First Number: <input type="text" name="first" placeholder="First Number"><br><br>
Enter Second Number: <input type="text" name="second" placeholder="Second Number"><br><br>
<input type="submit">
</form><br>
</div>
</body>
</html>
您可以看到，我已经将这个页面重定向到了 sum 端点。现在我需要配置 urls.py 文件来定义路径和函数映射。
from django.urls import path
from . import views
urlpatterns = [
path('',views.index),
path('sum', views.sum1)
]
在上面的文件中可以看到，当向 sum 端点发出请求时，将执行 views.py 文件中的 sum1() 函数。
现在 views.py 文件看起来像这样:
from django.shortcuts import render
def index(request):
return render(request, 'index.html')
def sum1(request):
num1 = int(request.GET['first'])
num2 = int(request.GET['second'])
result = num1 + num2
return render(request, 'sum.html', {'result':result})
在这里，您可以看到我是如何解析 GET 参数并使用 sum1() 函数将它们的总和返回给sum.html模板的。
您可以解析来自请求的 GET 参数。获取对象。您必须在该对象中定义输入控件的名称来解析该值。
现在让我们看看这个应用程序的执行。
- 首先，我将向根端点发出请求:
Requested the root endpoint
- 然后我会输入两个数字，点击提交。
- 点击提交按钮将发送一个 GET 请求到
sum端点以及两个参数。您可以在 URL 中看到 GET 参数。 - 应用程序将返回如下图所示的结果:
Request to the sum endpoint along with parameters
因此，通过这个例子，您可能已经了解了 GET 参数如何在 Django 应用程序中工作。
你可能会喜欢下面的 Django 教程:
- Python Django 长度过滤器
- Python Django 设置时区
- Python Django 格式日期
- Python 改 Django 版本
- Django 模板中的 If 语句
- 获取 Django 中的 URL 参数
- 如何获取 Django 的当前时间
- Python Django vs 金字塔
因此，您可能已经了解了如何从 get 请求中获取数据作为参数。
- Django 从 get 请求示例中获取数据
- 在 django 中添加两个数
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
获取字典 Python 中的第一个键
原文：https://pythonguides.com/get-first-key-in-dictionary-python/
在这个 Python 教程中，我们将讨论如何在 Python 中获得字典中的第一个键。在这里，我们还将介绍以下示例:
- 获取字典 Python 中的第一个键
- 获取字典 Python 中第一个键的值
- 获取字典 Python 中第一个元素的键
- Python 获取字典中第一项的键
- 获取字典 Python 中的第一个键值对
目录
- 获取字典式 Python 中的第一个密钥
- 获取字典 Python 中第一个键的值
- 获取字典 Python 中第一个元素的键
- Python 获取字典中第一项的关键字
- 获取字典 Python 中的第一个键值对
获取字典式 Python 中的第一个密钥
- 在本期节目中，我们将讨论如何获取 Python 字典中的第一个键。
- 这里我们将讨论如何获取字典的第一个键。在 Python 中，字典包含键值对形式的元素。
- 有各种方法来执行这个特定任务
- 通过使用 keys()方法
- 通过使用 next()+iter()方法
- 通过使用 forloop 方法
- 通过使用 N 键方法
让我们了解并检查如何使用 keys()方法从字典中获取第一个键
Python 提供了函数 keys() ，该函数总是返回字典中可用的所有给定键的可迭代序列，并且该方法不带任何参数。
语法:
下面是 dict.keys() 方法的语法
dict.keys()
注意:这个函数不传递任何参数，总是返回一个显示所有键的对象。
源代码:
my_new_dict ={'George':192,'Micheal':269,'James':159,'Potter':432}
new_k = list(my_new_dict.keys())[0]
print("Get first key from dictionary:",new_k)
在上面的代码中，我们首先创建了一个包含键值对元素的字典‘my _ new _ dict’。现在，我们必须使用 dict.keys() 方法将键序列转换为一个列表。一旦您将打印‘new _ k’，那么输出将显示字典中的第一个关键元素。
下面是以下给定代码的执行过程
Get the first key in dictionary Python
使用 next()+iter() 方法从字典中获取第一个密钥的另一种方法
在 Python 中， next() 和 iter() 方法用于获得字典元素的可迭代序列。迭代器对象是通过使用 iter() 创建的，而 next() 方法用于从类似字典的对象中返回下一个值。当我们到达最后一个元素，并且没有更多的数据返回时，它将显示‘stop iteration’。
举例:
让我们举一个例子，了解如何获得 Python 字典中的第一个键
employee_dictionary = {'Oliva' : 145, 'William' : 389, 'Elijah' : 921}
new_output = next(iter(employee_dictionary))
print(new_output)
下面是以下给定代码的输出
Get First Key in dictionary Python using iter
通过使用 for 循环方法
这是另一种通过使用 for 循环方法从字典中获取初始密钥的方法。在 Python for 循环中运行一个代码块，在这个例子中，当我们获得初始密钥时，循环将中断并显示结果。
源代码:
fruit_name = { 'Apple': 48, 'Oranges': 289, 'Banana': 192, 'Cherry': 158}
for new_k, new_val in fruit_name.items():
print(new_k)
break
在这个程序中，在获得字典的初始键后，使用 break 语句停止循环。一旦你将打印‘new _ k’，那么输出将显示第一个键‘苹果’。
你可以参考下面的截图从字典中获取第一个密钥
Get First Key in dictionary Python by using for loop
用 N 键法
在这个程序中，我们首先从字典中选择‘I’个键，然后使用 list() 方法将字典中的键转换成一个列表。在下面的例子中，我们选择了第一个 I 条目，即‘I = 1’。
源代码:
Country_name = { 'Germany': 378, 'Australia': 167, 'Newyork': 556, 'China': 443}
i = 1
new_ini_ke = list(Country_name.keys())[:i]
print("Initial key from dictionary:",new_ini_ke)
在上面的程序中，我们首先初始化了一个包含键值对的字典。一旦您将打印 'new_ini_ke' ，那么输出将显示'德国'。
下面是以下代码的截图
Get First Key in dictionary Python using keys method
阅读: Python 字典增量值
获取字典 Python 中第一个键的值
- 让我们看看如何从 Python 字典中获取第一个键的值。
- 要从字典中获取第一个值，有各种方法和关键字来解决这个问题。
- 通过使用 dict.values()方法
- 通过使用 item()方法
- 通过使用 N 值方法
让我们了解并检查如何使用 dict.values() 方法从字典中获取初始键的值。
在 Python 中，字典提供了一个 dict.values() 方法，并返回一个对象，该对象显示一个包含字典中所有值的列表。在这个方法中，如果字典没有值，那么它将返回一个空字典。
语法:
下面是 dict.values()方法的语法
dict.values()
注意:这个函数不接受任何参数，以列表的形式返回字典值。
举例:
Country_name = { 'Newzealand': 490, 'Switerland': 380, 'Russia': 117, 'France': 190}
new_val = list(Country_name.values())[0]
print('Get value from first key:', new_val)
在上面的程序中，我们首先创建了一个包含键值对元素的字典‘Country _ name’。现在我们必须使用 dict.values() 方法将值序列转换成一个列表。一旦您将打印‘new _ val’，那么输出将显示字典中的初始键值。
下面是以下给定代码的实现
Get the value of the first key in dict Python
通过使用 item()方法
- 这是检查如何从字典中获取初始键值的另一种方法。
- 为了执行这个特定的任务，我们可以应用
dict.items()方法的概念。在 Python 中，此方法用于返回一个对象，该对象显示一个列表，其中包含所有带值的字典键。
语法:
下面是 dict.items()方法的语法
dict.items()
注意:这个函数不接受任何参数，总是返回一个对象。
源代码:
Flower_name = { 'Rose': 623, 'Tulip': 168, 'Lilly': 251, 'Jasmine': 390}
get_val = list(Flower_name.items())[0][1]
print("Initial val from dictionary:", get_val)
在上面的程序中，我们已经初始化了一个字典，然后创建了一个变量' get_val '。现在我们必须使用 list() 方法并分配一个键值对索引 [0][1] 。
你可以参考下面的截图
Get the value of the first key in dict Python by using the item
采用 N 值法
在这个例子中，我们首先从字典中选择‘m’个键-值对，然后使用 list() 方法将字典中的值转换成一个列表。
源代码:
Student_name = { 'George': 45, 'Aris': 23, 'Elijah': 69, 'William': 109}
m = 1
new_get_val = list(Student_name.values())[:m]
print("Get selected value from dictionary:",new_get_val)
下面是以下代码的截图
Get the value of the first key in dict Python
这就是如何从字典中获取初始键的值。
阅读: Python 列表字典
获取字典 Python 中第一个元素的键
- 这里我们可以看到如何从 Python 字典中获取第一个 key 元素。
- 通过使用
next()和iter()方法，我们可以执行这个特定的任务，这些方法用于获得可迭代序列。
源代码:
Country_name = { 'Bangladesh': 647, 'Japan': 810, 'Turkey': 942, 'China': 280}
new_result = next(iter(Country_name))
print("Initial first key element:", new_result)
在上面的例子中，我们首先创建了一个字典，然后使用 next()+iter() 方法从字典中获取第一个 key 元素。
下面是以下给定代码的输出
Get key of the first element in dictionary Python
阅读: Python 字典扩展
Python 获取字典中第一项的关键字
- 在本期节目中，我们将讨论如何从字典中获取第一个关键条目。
- 通过使用列表理解方法，我们可以解决这个任务，这个构造函数用于从另一个可迭代序列(如字典)创建一个新的。在这个例子中，如果给定的值在字典中不存在，那么它将返回一个空数组。
源代码:
new_dictionary= { 'Chinese': '256', 'Italian': '180', 'Mexican': 632, 'Thai': 189}
new_output = [new_key for new_key, new_val in new_dictionary.items() if new_val == '256']
print(new_output)
在上面的代码中，我们应用了列表理解方法[]的概念来迭代字典的键和值。在这个方法中，它将检查条件new _ val = = ' 256′是否存在于字典中。如果可用，它将显示第一个关键元素。
你可以参考下面的截图
Python get the key of the first item in a dictionary
阅读: Python 字典复制
获取字典 Python 中的第一个键值对
- 这里我们可以看到如何从 Python 字典中获取第一个键值元素。
- 通过使用
iter()和next()方法，我们可以迭代字典中所有的键值对。在 Python 中,iter()函数创建一个可迭代的对象，它可以一次迭代一个元素。为了获得这个序列的第一个元素，我们可以使用next()函数，在这个函数中，我们将iter()和items()函数作为参数传递。
源代码:
new_my_dict= { 'b': 167, 'z': 119, 'p': 108, 'w': 167}
initial_ele = next(iter((new_my_dict.items())) )
print( initial_ele[0])
print(initial_ele[1])
print("Initial key-value pair element:",initial_ele)
下面是以下给定代码的执行过程
Get first key-value pair in dictionary Python
检查如何从 Python 字典获得第一个键值对的另一种方法
通过使用列表和切片方法，我们从列表[:m] 中选择了‘m’个条目。在这个例子中，我们从字典中选择了第一个键值对。
源代码:
student_name= { 'Chris': 541, 'Hemsworth': 930, 'James': 162, 'Oliva': 108}
m = 1
result= list(student_name.items())[:m]
for new_k,new_val in result:
print("Get key-value pair from dictionary:",new_k, ':', new_val)
你可以参考下面的截图
Get first key-value pair in dictionary Python
你可能会喜欢读一些我们关于 Python 的教程。
- Python 字典多键
- Python 字典到 CSV
- Python 在字符串中查找数字
- Python 中的 Case 语句
- 如果不是 python 中的条件
- 在 python 中反转一个列表
- Python 元组字典
- Python 字典流行
- Python 将数据帧转换为列表
- 从字典中获取所有值 Python
在这个 Python 教程中，我们已经讨论了如何在 Python 中获得字典中的第一个键。在这里，我们还介绍了以下示例:
- 获取字典 Python 中的第一个键
- 获取字典 Python 中第一个键的值
- 获取字典 Python 中第一个元素的键
- Python 获取字典中第一项的键
- 获取字典 Python 中的第一个键值对
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何在 Python 中获得熊猫数据帧的前 N 行
原文：https://pythonguides.com/get-first-n-rows-of-pandas-dataframe/
在这个 Python 熊猫教程中，将学习如何使用 Python 中的熊猫获取数据帧的前 N 行。此外，我们将涵盖这些主题。
- 获取熊猫数据帧的前 10 行
- 获取熊猫数据帧的前 N 行列表
- 获取熊猫数据帧的前 N 行作为字典
- 获取熊猫数据帧的前 N 行作为标题
- 获取熊猫数据帧的前 N 行作为列名
- 获取熊猫数据帧所有列的前 N 行
目录
- 获取前 N 行熊猫数据帧
- 获取 Python 熊猫数据帧的前 N 行
- 获取前 10 行熊猫数据帧
- 获取熊猫数据帧的前 N 行作为列表
- 获取熊猫数据帧的前 N 行作为字典
- 获取熊猫数据帧的前 N 行作为标题
- 获取熊猫数据帧的前 N 行作为列名
- 获取熊猫数据帧所有列的前 N 行
获取前 N 行熊猫数据帧
- 在本期节目中，我们将讨论如何获得熊猫数据帧的前 N 行。
- 在 Python 中，Pandas head()方法用于从 Pandas DataFrame 中检索前 N 行数据。该函数总是返回除最后 n 行之外的所有行。
- 这个方法只包含一个参数 n，如果你没有在函数中传递任何数字，那么默认情况下，它将返回前 5 行元素。
语法:
下面是 DataFrame.head() 方法的语法
DataFrame.head
(
n=5
)
- 它只包含一个参数
- n:该参数指示输出中要返回的行数。默认情况下，这被设置为
n=5，它将返回前 5 行数据。
- n:该参数指示输出中要返回的行数。默认情况下，这被设置为
举例:
让我们举个例子，看看如何获得熊猫数据帧的前 N 行。
源代码:
import pandas as pd
df = pd.DataFrame(
[[692,128, 992],
[139, 459, 167],
[132, 907, 107],
[2209, 552, 129],
[3389, 719, 4038],
[389, 154, 645],
[378, 298, 114],
[1, 2,6]],
columns=['Germany', 'Newzealand', 'China'])
new_val = df.head()
print(new_val)
在上面的代码中，我们首先创建了一个包含列表中的值的 DataFrame。现在我们只想提取 5 行数据。为了完成这个任务，我们将使用 head() 函数，它将返回前 5 行。
下面是以下给定代码的执行过程
Get the first N rows of Pandas DataFrame
获取 Python 熊猫数据帧的前 N 行
- 通过使用
iloc()方法，我们还可以获得前 N 行熊猫数据帧。 - 在 Python 中，
iloc()方法使我们能够选择数据帧的特定单元格，并且我们还可以检索属于列和行的特定值。 - 这个函数只接受整数类型的值，还访问所有的数据值。
语法:
下面是 iloc()方法的语法
Pandas.DataFrame.iloc()
源代码:
import pandas as pd
student_info = [('Micheal', 12, 'Japan', 223),
('George', 23, 'China' , 129),
('John', 31, 'U.S.A' , 458),
('Brenda', 18, 'France' , 875),
('William', 27, 'Paris', 569),
('Olijah', 29, 'Uganda' , 809)]
df = pd.DataFrame( student_info,
columns=['Student_name', 'Stu_age', 'Stu_city', 'Student_id'])
N = 2
new_result = df.iloc[:N]
print("N rows of Pandas DataFrame: ")
print(new_result)
在上面的程序中，我们首先创建了一个元组列表，其中我们已经分配了 N 行。现在使用 iloc() 方法，选择 dataframe 的前 2 行作为 Pandas Dataframe 对象。
下面是以下给定代码的输出
Get the first N rows of Pandas DataFrame
在 Python 中读取熊猫缺失数据
获取前 10 行熊猫数据帧
- 这里我们可以看到如何获得熊猫数据帧的前 10 行。
- 在这个程序中，我们在
df.head()函数中传递了‘10’作为参数。要返回前 10 行，我们可以使用DataFrame.head()。 - 此方法用于返回给定数据帧或系列的 10 行。您也可以更改括号之间的值来更改行数。
举例:
import pandas as pd
df = pd.DataFrame(
[[692,128, 992],
[139, 459, 167],
[132, 907, 107],
[2209, 552, 129],
[3389, 719, 4038],
[389, 154, 645],
[378, 298, 114],
[1, 2,6],
[231,178,190],
[134,298,115],
[219,884,721],
[745,240,558]],
columns=['Micheal', 'Oliva', 'Elijah'])
new_val = df.head(10)
print(new_val)
在上面的代码中，我们首先创建了一个包含列表中的值的 DataFrame。现在我们只想提取 10 行的数据。为了执行这个任务，我们将使用 head() 函数，它将返回前 10 行。
下面是以下代码的截图
Get the first 10 rows of Pandas DataFrame
阅读 Python 熊猫中的交叉表
获取熊猫数据帧的前 N 行作为列表
- 让我们看看如何获得熊猫数据帧的前 N 行作为列表。
- 在这个程序中，我们创建了一个元组列表，并给它赋值。现在创建一个 DataFrame 并传递列名和索引。
源代码:
import pandas as pd
employee_info = [('Potter', 12, 'Australia', 223),
('George', 23, 'China' , 339),
('John', 31, 'Germany' , 992),
('Brenda', 18, 'Bangladesh' , 129),
('William', 27, 'France', 569),
('Olijah', 29, 'Uganda' , 809)]
empDfObj = pd.DataFrame(employee_info, columns=['employee_name', 'emp_age', 'emp_city', 'emp_id'], index=['1', 'm', 'n', '2', '5', 'p'])
new_val = empDfObj.head(2)
print("First 2 rows of the Pandas Dataframe : ")
print(new_val)
在上面的代码中，我们使用了 df。head() 函数并获取输出中要返回的行数。一旦您打印了‘new _ val’，那么输出将只显示列表中可用的 2 行。
你可以参考下面的截图
Get the first N row of Pandas DataFrame as a list
获取熊猫数据帧的前 N 行作为字典
- 在这个程序中，我们将获取熊猫数据帧的前 N 行作为字典。
- 在 Python 中，为了首先执行这个特定的任务，我们将创建一个字典并分配给键值对元素。在这个例子中，key 元素被认为是列名，相似的值被认为是列表。
源代码:
import pandas as pd
my_new_dict = {'Student_name' : ['Liah', 'Oliva',
'Elijah', 'Micheal',
'George'],
'Student_age':[34,12,24,34,25],
'Student_id':[167, 823, 456, 782, 912]}
df = pd.DataFrame(my_new_dict)
new_val = df.head(2)
print(new_val)
在上面的程序中，我们创建了一个 DataFrame 对象，并传递了一个字典作为参数。之后，使用 DataFrame.head() 函数并分配一个整数值，这意味着一旦您打印了‘new _ val’，那么输出将只显示两行给定的数据帧。
下面是以下给定代码的实现
Get the first N row of Pandas DataFrame as a dictionary
获取熊猫数据帧的前 N 行作为标题
- 让我们看看如何获得前 N 行熊猫数据帧作为标题。
- 通过使用
DataFrame.iloc()方法，我们可以解决这个问题，该方法帮助用户选择数据帧的特定单元格，我们还可以检索属于列和行的特定值。
举例:
import pandas as pd
student_info = [('James', 17, 'Japan', 223),
('George', 18, 'China' , 129),
('Adam', 23, 'U.S.A' , 458),
('Hayden', 18, 'France' , 875),
('Gilchrist', 27, 'Paris', 569),
('Olijah', 29, 'Uganda' , 809)]
df = pd.DataFrame( student_info,
columns=['Student_name', 'Stu_age', 'Stu_city', 'Student_id'])
N = 3
new_result = df.iloc[:N]
print("N rows of Pandas DataFrame with header: ")
print(new_result)
在上面的代码中，我们创建了一个包含列名的 DataFrame 对象。现在使用 iloc() 方法和切片方法 [:] 并选择数据帧的前 2 行作为熊猫数据帧对象。
下面是以下代码的截图
Get the first N row of Pandas DataFrame as header
获取熊猫数据帧的前 N 行作为列名
- 在本期节目中，我们将讨论如何获取 Pandas DataFrame 的前 N 行作为列名。
- 通过使用一个
dataframe.head()方法，我们可以很容易地获得列名为 Pandas 的数据帧的 N 行。
源代码:
import pandas as pd
df = pd.DataFrame(
[[321,462, 198],
[923, 210, 875],
[132, 907, 107],
[2209, 552, 129],
[3389, 719, 4038],
[389, 154, 645],
[378, 298, 114],
[211, 32,689]],
columns=['Newyork', 'England', 'U.S.A'])
new_val = df.head(3)
print(new_val)
在这个例子中，我们创建了一个列名列表，然后使用一个 dataframe.head() 方法来获取 dataframe 的特定行。
下面是以下给定代码的实现
Get the first N row of Pandas DataFrame as column name
获取熊猫数据帧所有列的前 N 行
- 在本期节目中，我们将讨论如何获得熊猫数据帧的前 N 行列。
- 为了执行这个任务，我们可以应用方法
DataFrame.head()并使用列表中的所有列。
源代码:
import pandas as pd
employee_info = [('c', 34, 'Newyork', 223),
('G', 26, 'C' , 339),
('h', 11, 'china' , 992),
('l', 18, 'Bangladesh' , 129),
('n', 25, 'France', 569),
('O', 21, 'Uganda' , 809)]
result = pd.DataFrame(employee_info, columns=['alphabet', 'emp_age', 'emp_city', 'emp_id'])
new_val = result.head(3)
print("First 2 rows of the Pandas Dataframe : ")
print(new_val)
你可以参考下面的截图
Get the first N row of Pandas DataFrame all columns
你可能会喜欢下面的 Python 熊猫教程:
- 如何将熊猫数据帧转换成字典
- Python 熊猫掉行例子
- 如何在 Python Pandas 中使用 drop_duplicates()函数删除重复项
- 如何在 Python 中使用 Pandas drop()函数
- Python 熊猫中的 group by
- 熊猫用 0 换下南
在这个 Python 熊猫教程中，我们将学习如何使用熊猫获取数据帧的前 N 行。此外，我们将涵盖这些主题。
- 获取熊猫数据帧的前 10 行
- 获取熊猫数据帧的前 N 行列表
- 获取熊猫数据帧的前 N 行作为字典
- 获取熊猫数据帧的前 N 行作为标题
- 获取熊猫数据帧的前 N 行作为列名
- 获取熊猫数据帧所有列的前 N 行
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
获取熊猫 Python 索引
在这个熊猫教程中，我们将学习如何使用 Python 获得熊猫数据帧中的索引。此外，我们将涵盖这些主题。
- 查找索引熊猫数据框
- 获取行索引熊猫数据帧
- 获取熊猫数据框的索引值
- 获取熊猫数据框的索引列
- Python 熊猫在哪里获得索引
- 获取最大值熊猫 Python 的索引
目录
获取索引熊猫 Python
- 在本期节目中，我们将讨论如何在 Python 中获取熊猫数据帧的索引。
- 通过使用
DataFrame.index方法，我们可以很容易地得到给定数据帧的索引值。这个方法允许你访问熊猫数据帧的索引，它总是返回一个 index 类型的对象。
语法:
以下是数据帧的语法。索引()方法
DataFrame.index
注意:该方法不采用任何参数，默认返回一个索引值，索引值从
0开始。
举例:
让我们创建一个例子，并检查如何获得数据帧中的索引
import pandas as pd
Student_info = [('Potter', 278),
('George', 163),
('Oliva', 129),
('John', 145),
('Adam', 834),
('Hayden',745),
('Chris', 981)
]
df = pd.DataFrame(Student_info, columns=['Student_name','Student_id'])
new_val = df.index
for x in new_val:
print(x)
在上面的程序中，我们有一个带有默认索引的数据帧，因为没有指定索引值，所以默认范围从 0 开始。
在本例中，我们首先创建了一个元组列表，然后声明了一个 DataFrame 对象，其中我们指定了列名‘学生姓名’和‘学生 id’。
一旦您将打印‘x’,那么输出将显示数据帧的索引值。
你可以参考下面的截图来获取索引值
Get index Pandas Python
另一个获取数据帧中行索引的例子
在本例中，我们将讨论如何获取数据帧中特定行的索引。
为了完成这个任务，假设我们有一个列【中国】，它在索引 0 处有【23】，并且没有其他位置，则存储【23】的所有行的索引列表是【0】。
源代码:
import pandas as pd
df = pd.read_csv("test1.csv")
print(df)
index = df.index
new_val = df["China"] == 23
b = index[new_val]
new_output = b.tolist()
print("Get only rows with china:",new_output)
在上面给出的代码中，我们首先导入了一个 pandas 模块，然后创建了一个 DataFrame，我们必须在其中分配一个 CSV 文件。一旦您将打印‘df’，那么输出将显示 CSV 文件的内容。
现在使用 DataFrame.index 方法获取 Pandas 数据帧中特定行的索引。
下面是以下给定代码的执行过程
Get index Pandas Python
阅读:计算熊猫数据帧中的行数
查找索引熊猫数据帧
- 在这里，我们可以看到如何找到熊猫数据帧中元素的索引。
- 在这个例子中，我们创建了一个 numpy 随机函数，其中我们指定了一个起始值和结束值。创建 DataFrame 对象时，它返回一个索引位置列表。
源代码:
import pandas as pd
import numpy as np
new_dt = pd.DataFrame(np.random.randint(2,10,size=(10, 3)), columns=list('ZXY'))
print ("Get index of DataFrame")
print(new_dt)
下面是以下给定代码的实现
Find index Pandas DataFrame
阅读:如何删除熊猫中的一个栏目
如何找到熊猫数据帧的索引
通过使用熊猫。Index.get_loc 方法我们可以执行这个特定的任务并返回一个索引位置列表。
语法:
下面是熊猫的句法。Index.get_loc 方法
Index.get_loc(key, method=None, tolerance=None
- 它由几个参数组成
- 键:该参数指定标签
- 方法:这是一个可选参数，默认情况下它的值是 None。
- 容差:不精确匹配与索引值的最大距离将是整数或浮点数。
举例:
import pandas as pd
selected_index = pd.Index(list('uqw'))
new_output =selected_index.get_loc('q')
print(new_output)
在上面的代码中，我们首先导入了一个 pandas 库，然后创建了一个 dataframe，并在其中分配了一个字符串值‘uqw’。现在我们要显示【q】的具体指标值。
为了完成这个任务，我们使用了 Pandas.index.get_loc() 方法的概念。这种方法将帮助用户找到数据帧的特定索引值。
下面是以下代码的截图
Find index Pandas DataFrame
获取行索引熊猫数据帧
- 这里我们可以看到如何从 Pandas DataFrame 中获取行索引值。
- 让我们创建一个简单的数据帧，其中我们已经分配了字符串值，它可以在两个方法上匹配。
- 在这个程序中，我们创建了一个简单的数据框架，在其中我们分配了一个列和值列表。一旦您将打印‘new _ dt’，那么输出将显示【雇员姓名】和【雇员 id】的索引值。
源代码:
import pandas as pd
new_dt = pd.DataFrame({"Employee_name": ["George",
"John",
"Micheal",
"Potter",
"Oliva"],
"Employe_id": ["289",
"118",
"725",
"963",
"1789"]
})
print(new_dt)
下面是以下给定代码的实现
Get row index Pandas DataFrame
获取熊猫数据帧的行索引
通过迭代列，我们可以执行这个特定的任务。在这种方法中，我们将分析真实数据集 "test1.csv" 。现在我们需要得到熊猫数据帧的索引。
让我们了解并讨论如何获得行索引值
举例:
import pandas as pd
new_val = pd.read_csv("test1.csv")
result = new_val.head()
for new_row in result.index:
print(new_row, end = " ")
下面是以下给定代码的输出
Get row index Pandas DataFrame
获取指数值熊猫数据帧
- 让我们看看如何从 Pandas 数据帧中获取索引值。
- 现在让我们举一个例子，通过迭代列名来解决这个问题。为了完成这项任务，我们首先创建了一个 DataFrame 对象‘df’，在其中我们分配了一个特定的列名‘数字’。一旦你打印了t‘df’，那么输出将显示一个数据帧的‘Numbers’值索引。
源代码:
import pandas as pd
empoyees = [(89),
(367),
(921),
(178),
(632),
(156),
(176)
]
df = pd.DataFrame(empoyees, columns=['Numbers'])
print(df)
你可以参考下面的截图来获取指数值
Get index values Pandas DataFrame
阅读: Python 将数据帧转换为列表
获取索引栏熊猫数据框
- 在这个程序中，我们将讨论如何获得索引列熊猫数据帧。
- 通过使用熊猫。Index.get_loc 方法我们可以执行这个特定的任务并返回一个索引位置列表。
- 在 Python 中，Pandas.index.get_loc 方法返回整数位置，该方法适用于已排序和未排序的索引。如果该值不存在，它将检查条件，然后只有在索引值已排序的情况下，它才会将下一个值返回到传递的值。
语法:
下面是熊猫的句法。index.get_loc()方法
Index.get_loc(key, method=None, tolerance=None)
源代码:
import pandas as pd
new_dict = {'Mangoes': [74, 118, 924,
918, 802],
'Cherry': [145, 689, 378,
18, 16],
'Banana': [133, 521, 489,
349, 589]}
df = pd.DataFrame(new_dict)
new_column_name = "Cherry"
new_val = df.columns.get_loc(new_column_name)
print("Index of {} column in given dataframe is : {}".format(new_column_name, new_val))
在上面的例子中，我们已经导入了 Pandas 库，然后创建了一个字典，我们必须在其中分配键值对元素。
现在在这个例子中，我们将把一个关键元素看作一个列名，然后声明一个 DataFrame 对象。
现在，我想显示特定列的索引值。首先，我创建了一个变量‘new _ column _ name’，并指定一个列名“Cherry”。
下面是以下代码的截图
Get index column Pandas DataFrame
阅读:熊猫删除栏目
Python 熊猫在哪里得到索引
- 让我们看看如何使用 where 函数获得熊猫的索引值。
- 在 Python Pandas 中，
where()方法用于检查 Pandas 数据帧，它接受一个条件作为参数。它将检查熊猫数据帧中每个值的条件，如果它不存在于数据帧中，那么它将被替换为 nan 值。
语法:
下面是 DataFrame.where() 方法的语法
DataFrame.where
(
cond,
other=nan,
inplace=False,
axis=None,
level=None,
errors='raise',
try_cast=Nodefault.no_default
)
源代码:
import pandas as pd
import numpy as np
Country_name=['Australia', 'Russia', 'Moscow', 'Newzealand','Switzerland','France']
new_val=[780,521,450,320,800,900]
df = pd.DataFrame({'country':Country_name ,
'VALUE':new_val})
new_output = list(np.where(df["VALUE"] >= 800))
print(new_output)
在上面的例子中，我们创建了两个列表‘Country _ name’和‘new _ val’，同时我们声明了一个 DataFrame 对象‘df’，我们在其中指定了列名。
现在我们必须在函数中使用它们来获得小于 800 的索引值。
下面是以下给定代码的执行过程
Python Pandas get index where
获取最大值熊猫 Python 的索引
- 在本期节目中，我们将讨论如何在熊猫 Python 中获取最大值的索引。
- 在 Python 中，Pandas
DataFrame.idmax()方法用于获取给定轴上第一次出现的最大值的索引，该方法将始终返回最大值的索引，如果 Pandas 数据帧中的列或行为空，则它将引发值错误。
语法:
下面是 DataF rame.idmax() 方法的语法
DataFrame.idxmax
(
axis=0,
skipna=True
)
- 它由几个参数组成
- 轴:如果轴的值是 1，那么它将代表列的方向。如果轴=0，那么它将代表行。
- skipna: 默认情况下，其值为“真”，该参数代表布尔值(真或假)，不包括所有缺失值和 nan 值。
举例:
import pandas as pd
df = pd.DataFrame({"value1": [82, 91, 78], "value2": [88,77,33]})
col_name = df["value1"]
new_output = col_name.idxmax()
print("Get index for mmax value:",new_output)
在上面的例子中，我们考虑了一个数据帧，并通过使用 DataFrame.idxmax() 方法获得每一列中最大值的索引。
在这个程序中，我们指定了列名“value 1”，它将获得最大值的索引。
下面是以下给定代码的输出。
Get the index of max value Pandas Python
你可能也喜欢读下面的文章。
- 蟒蛇熊猫掉行
- Python 熊猫中的 group by
- Python 熊猫中的交叉表
- Python 数据帧到 CSV
- 检查 Python Pandas 中的数据帧是否为空
- 如何使用熊猫 drop()函数
在这个 Python Pandas 教程中，我们已经学习了如何使用 Python 获得 Pandas 数据帧中的索引。此外，我们已经讨论了这些主题。
- 查找索引熊猫数据框
- 获取行索引熊猫数据帧
- 获取熊猫数据框的索引值
- 获取熊猫数据框的索引列
- Python 熊猫在哪里获得索引
- 获取最大值熊猫 Python 的索引
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何在 Python 中从列表中获取唯一值
原文：https://pythonguides.com/get-unique-values-from-list-python/
在这个 Python 教程中，我们将学习如何在 Python 中从列表中获取唯一值。此外，我们将涵盖这些主题。
- 从 Python 熊猫列表中获取唯一值
- 从列表 Python 中获取唯一值
- 从嵌套列表 Python 中获取唯一值
- 从字典 Python 列表中获取唯一值
- Python 从对象列表中获取唯一值
- 从列表 Python 中移除唯一值
- 从两个列表 Python 中获取唯一值
- 使用索引从列表 Python 中获取唯一值
- 从列表列表中获取唯一值 Python
- 从字符串列表中获取唯一值 Python
目录
- Python 从列表中获取唯一值
- 通过使用 set()方法
- 通过使用有序字典()
- 通过使用 enumerator()方法
- 从 Python 熊猫列表中获取唯一值
- 从列表 Python 中获取唯一值
- 从嵌套列表 Python 中获取唯一值
- 从 Python 字典列表中获取唯一值
- Python 从对象列表中获取唯一值
- 从列表 Python 中移除唯一值
- 从两个列表中获取唯一值 Python
- 使用索引从列表 Python 中获取唯一值
- 从列表列表中获取唯一值 Python
- 从字符串列表中获取唯一值 Python
Python 从列表中获取唯一值
- 在这一节中，我们将讨论如何使用 Python 从列表中获取唯一值。
- 在 Python 中，列表是一些元素，存储在 [] 括号中。当我们在列表中插入元素时，列表中必须有重复的值。所以现在我们的任务是找到给定列表中的唯一值。
- 例如，假设我们有一个包含整数【5，6，4，5】的 Python 列表。现在我们必须找到唯一的值，正如你在给定列表中看到的那样‘5’出现了两次。
- 通过使用 Python，有多种方法可用于从列表中获取唯一值。
- 通过使用 set()方法
- 通过使用有序字典()
- 通过使用 enumerator()方法
例子:
通过使用 set()方法
- 在 Python 中，set 方法只存储唯一值，当我们应用函数 'set()' 时，它会自动从列表中删除重复值。在 python 中，集合是一个无序的元素集合，我们可以很容易地从中删除或更新值。
new_lis = [14,25,87,14,78,25,25]
new_val = set(new_lis)
z=list(new_val)
print("Unique values:",z)
在上面的例子中，我们创建了一个列表‘new _ lis’，并为其分配整数值。然后，我们通过应用 set() 函数从列表中提取唯一值。
现在声明一个变量‘z’并使用 list() 函数。一旦您将打印‘z’，那么输出将显示唯一的值。
下面是以下给定代码的实现
Python Get unique values from a list
通过使用有序字典()
- 在这里，我们可以通过使用 Python 轻松地使用集合模块中的
ordered.dict()方法。在本例中，我们必须创建一个列表‘新值’，然后使用带有 fromkeys()函数的OrderedDict.fromkeys()方法。
举例:
from collections import OrderedDict
new_values = [16, 11, 11, 10, 45, 98, 52, 41]
new_result = list(OrderedDict.fromkeys(new_values))
print("Unique values:",new_result)
下面是以下给定代码的输出
Python Get unique values from a list
读取 Python 查找列表中元素的索引
通过使用 enumerator()方法
在 Python 中， enumerator() 方法用于迭代对象和插入计数器项。这是 Python 中的一个内置函数，对象可以在循环中使用并转换成列表。
源代码:
new_val = [24,89,75,89,24,189,75,178]
output = [i for z,i in enumerate(new_val) if i not in new_val[:z]]
print("Unique value:",output)
在上面的程序中，我们初始化了包含整数值和重复值的列表。现在使用 enumerator() 函数，并在该方法中将列表理解作为参数传递，该参数将返回唯一值列表。
下面是以下给定代码的实现
Python Get unique values from a list
从 Python 熊猫列表中获取唯一值
- 在这个程序中，我们将讨论如何使用 Python 熊猫从列表中获取唯一值。
- 通过使用
pd.drop_duplicates()函数我们可以解决这个问题。为了完成这项任务，我们将导入 Pandas 库，然后应用能够存储各种数据类型的 pd.series()。我们也可以通过使用‘序列’方法将列表转换成序列。 - 在 Python Pandas 中，
drop_duplicate()函数用于从序列中删除重复值并返回唯一值。
语法:
下面是 drop_duplicate()函数的语法
Dataframe.drop_duplicates
(
subset=None,
keep='first',
inplace='False',
ignore_index=False
)
举例:
import pandas as pd
new_lis = [14, 67, 23, 67, 164, 754, 943, 14]
result= pd.Series(new_lis).drop_duplicates().tolist()
print("Unique values:",result)
你可以参考下面的截图
Get unique values from list Python Pandas
正如您在屏幕截图中看到的，输出显示了给定列表中的唯一值。
从列表 Python 中获取唯一值
- 在本节中，我们将讨论如何使用 Python 从列表中找到唯一值。
- 为了执行这个特定的任务，我们将使用
dict.fromkeys()方法的概念。在 Python 中，dict.fromkeys()方法用于根据给定值声明一个新字典。现在，我们必须从列表中删除重复值，并将唯一值存储到列表中。 - 通过使用
list()方法，我们可以很容易地得到新的列表，并将‘new _ result’指定为参数。
语法:
下面是 dict.fromkeys() 方法的语法
dictionary.fromkeys
(
sequence
[,
value
]
)
- 它由几个参数组成
- 序列:该参数表示将要使用的元素列表。
- value: 可选参数，指定字典的各个值。
举例:
让我们举一个例子，看看如何从 Python 列表中获取唯一值
new_values = [45,67,15,67,23,15]
new_result = dict.fromkeys(new_values)
b= list(new_result)
print("Unique values:",b)
下面是以下代码的截图
Get unique values from list Python
阅读 Python 列表字典
从嵌套列表 Python 中获取唯一值
- 这里我们可以看到如何使用 Python 从嵌套列表中获取唯一值。
- 通过使用
frozenset()方法，我们可以很容易地从嵌套列表中获得唯一值。在 Python 中，frozenset()用于返回一个不可变的对象。集合的元素可以随时修改，如果提供了参数，它将检查条件，然后创建 frozenset。
语法:
下面是 frozenset() 方法的语法
frozenset
(
[
iterable
]
)
- 它只包含一个参数
- iterable: 该参数表示类似列表的可迭代对象。
举例:
让我们举个例子来理解一下 frozenset() 方法的工作原理
new_list=[[43,14],[784,821],[77,65],[65,77],[145,765],[43,14]]
new_val = set(frozenset(i) for i in new_list)
result = [list(i) for i in new_val]
print("Unique values from list:",result)
下面是以下代码的截图
Get unique values from nested list Python
从 Python 字典列表中获取唯一值
- 在本节中，我们将讨论如何使用 Python 从字典列表中获取唯一值。
- 为了执行这个特定的任务，我们将使用 list 函数，在这个方法中，我们将应用 list comprehension 方法作为参数。
源代码:
new_dict = [{'Micheal' : 432, 'George' : 675}, {'William' : 432, 'John' : 178}, {'William' : 432, 'Smith':105}]
final_output = list(set(value for dic in new_dict for value in dic.values()))
print("Unique values:",final_output)
在上面的代码中，我们创建了一个字典列表，然后初始化了一个变量‘final _ output’,在这个变量中，我们为列表赋值，它可以迭代字典值。
现在通过使用 dic.values() 方法转换成一个列表。打印“最终输出”后，结果将显示唯一值。
下面是以下给定代码的实现
Get unique values from a list of dictionary Python
Python 从对象列表中获取唯一值
- 在本节中，我们将讨论如何使用 Python 从对象列表中获取唯一值。
- 通过使用 Python
set()方法，我们可以轻松地执行这个特定的任务。在 Python 中，set 方法只存储唯一值，它会自动从列表中删除重复值。 - 首先，我们将创建一个列表，并为其分配整数和字符串值。然后声明一个变量‘result’，我们将在其中应用
set()方法，在这个函数中，我们将传递 list‘new _ values’作为参数。
举例:
new_values = [67,117,67,'b','z','b',25]
result = set(new_values)
z=list(result)
print("Unique values:",z)
你可以参考下面的截图
Python get unique values from a list of objects
正如您在屏幕截图中看到的，输出显示了列表对象的唯一值
通过列表读取 Python 循环
从列表 Python 中移除唯一值
- 在本期节目中，我们将讨论如何使用 Python 从列表中移除唯一值。
- 在这个例子中，我们将使用列表理解和计数方法的概念。在 Python 中，
count()方法用于返回对象在列表中出现的次数。
语法:
下面是 Python List count()方法的语法
list.count
(
obj
)
源代码:
new_list=[46,21,69,69,14,76,13,13,66,19,10,10]
final_output=[i for i in new_list if new_list.count(i)>1]
print("Remove unique values from list:",final_output)
下面是以下给定代码的执行过程
Remove unique values from list Python
正如您在屏幕截图中看到的，输出显示了更新后的列表
也可阅读， Python 将字典转换为列表
从两个列表中获取唯一值 Python
- 这里我们可以看到如何使用 Python 从两个列表中获取唯一值。
- 为了解决这个问题，我们将应用
set()函数。在 Python 中，set()函数用于从给定列表中获取唯一值。 - 在这个程序中，我们将创建两个列表‘lis 1’和‘lis 2’。之后，我们将声明一个变量‘z’和‘m’，在其中我们分配了一个列表并设置了一个函数来获取唯一值。
举例:
lis1 = [23,41,23,78,94,41]
lis2 = [78,109,78,56,234,109]
z=list(set(lis1) - set(lis2))
m=list(set(lis2) - set(lis1))
print("Unique values from two lists:",z,m)
下面是以下代码的截图
Get unique values from two lists Python
正如您在屏幕截图中看到的，输出显示了两个列表中的唯一值
使用索引从列表 Python 中获取唯一值
- 为了从带有索引号的列表中获得唯一值，我们可以很容易地使用 Python
list.index()方法的概念。 - 为了首先执行这个特定的任务，我们将创建一个列表并为其分配整数值。之后，我们将使用列表理解方法，它将迭代列表值。
举例:
new_list = [2,6,9,2,9,4]
final_output = [new_list.index(i) for i in set(new_list)]
print("Unique values get index from list:",final_output)
下面是以下给定代码的执行过程
Get unique value from list Python using index
正如您在屏幕截图中看到的，输出显示了唯一值的索引号
从列表列表中获取唯一值 Python
- 在本节中，我们将讨论如何使用 Python 从列表列表中获取唯一值。
- 通过使用列表理解方法，我们可以解决这个问题。在本例中，我们必须通过列出对象并获取唯一值来迭代值。在 Python 中，列表理解是从给定列表声明新列表的最简单方法。
举例:
让我们举一个例子，看看如何在 Python 中从列表列表中获取唯一值
list_values = [[74,35,74], [189,74,55], [35,74,128]]
new_output = {z for i in list_values for z in i}
print("Unique values from list of lists:",new_output)
在上面的代码中，我们创建了一个列表‘list _ values’，然后在‘list _ values’上迭代‘I’变量。一旦您将打印‘new _ output’，那么结果将显示来自列表列表的唯一值。
你可以参考下面的截图
Get unique values from a list of lists Python
请查看， Python NumPy 列举示例
从字符串列表中获取唯一值 Python
- 在这个程序中，我们将讨论如何使用 Python 从字符串列表中获取唯一值。
- 为了执行这个特定的任务，我们可以通过使用 Python 轻松地使用集合模块中的
ordered.dict()方法。之后，我们将创建一个列表，并为其分配字符串值。 - 现在声明一个变量‘Final _ output’，在这个变量中使用 list 函数并传递
OrderedDict.fromkeys()方法。它将帮助用户从 Python 列表中获取唯一值。
举例:
from collections import OrderedDict
list_values = ['John', 'Micheal', 'Smith', 'John', 'George', 'Micheal','William' , 'Smith']
Final_output= list(OrderedDict.fromkeys(list_values))
print("Unique values from list of strings:",Final_output)
下面是以下给定代码的实现
Get unique values from a list of strings Python
相关 Python 教程:
在这个 Python 教程中，我们学习了如何使用 Python 从列表中获取唯一值。此外，我们将涵盖这些主题。
- 从 Python 熊猫列表中获取唯一值
- 从列表 Python 中获取唯一值
- 从嵌套列表 Python 中获取唯一值
- 从字典 Python 列表中获取唯一值
- Python 从对象列表中获取唯一值
- 从列表 Python 中移除唯一值
- 从两个列表 Python 中获取唯一值
- 使用索引从列表 Python 中获取唯一值
- 从列表列表中获取唯一值 Python
- 从字符串列表中获取唯一值 Python
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
获取 Django 中的 URL 参数
在 Django 中，您还可以将参数作为 URL 的一部分进行传递。在这个 Django 教程中，您将学习如何在 Django 中获取 URL 参数。
在各种 web 应用程序中，您可能会看到一些以参数结尾的 URL。例如，看看下面的 URL:
https://www.shop.tsinfo.com/products/12
上述 URL 获取对应于产品 id(即 12)的产品页面。这意味着 12 是一个 URL 参数，结果根据这个值显示。
现在让我们学习一下如何在姜戈制作柠檬。
- 如何在 Django 中从 URL 获取参数
- 要查看的 Django URL 传递参数
- 模板中的 Django URL 参数
- 从 Django 示例中的 URL 获取参数
- Django 路径转换器
- Django URL 参数字符串
- Django URL slug 参数
目录
- 如何在 Django 中从 URL 获取参数
- Django URL 传递参数查看
- 模板中的 Django URL 参数
- 从 Django 示例中的 URL 获取参数
- 路径转换器 Django
- Django URL 参数字符串
- Django URL slug 参数
如何在 Django 中从 URL 获取参数
要从 URL 获取参数，您必须执行下面解释的步骤:
- 在应用程序的 URLs 文件中创建一个路径并映射到视图，然后将参数传递给视图
- 在视图中定义一个函数，该函数将接受参数并将参数传递给 Django 模板。
- 设计 Django 模板来显示与传递的参数相对应的结果。
让我们在接下来的章节中简要讨论这些步骤。
Django URL 传递参数查看
您可以使用路径转换器将 URL 参数从 URL 传递给视图。
但是，首先您必须创建一个路径并将其映射到一个视图。为此，您必须编辑应用程序的 urls.py 文件。示例 urls.py 文件如下所示:
from django.urls import path
from . import views
urlpatterns = [
path("URL endpoint">/<path converter: URL parmeter name>, view_name.function_name, name = "path name")
]
例如，如果请求的 URL 是:
https://www.shop.tsinfo.com/products/12
- 那么“产品”将成为 URL 端点。
- 一个路径转换器定义了一个参数将存储哪种类型的数据。您可以将路径转换器与数据类型进行比较。在上面的例子中，路径转换器将是
int。 - 在接下来的章节中，您将了解更多关于各种路径转换器的信息。
- URL 参数名称将是您用来引用参数的名称。
view_name将是处理请求的视图，function_name 是向指定的 URL 端点发出请求时将执行的函数。- 名称将是您将要创建的路径的名称。
下一步是在 Django 模板中传递参数。
另外，请查看:如何设置 Django 项目
模板中的 Django URL 参数
首先，您必须创建一个 Django 模板，您将在其中呈现您的结果。要将 URL 参数传递给 Django 模板，必须在 Django 中编辑 views.py 文件。示例 view.py 文件如下所示:
from django.shortcuts import render
def function_name(request, url_parameter):
return render(request, 'Django Template', {url_parameter})
这是命中指定 URL 端点时将执行的函数。这个函数接受 URL 参数，并将其作为字典传递给 Django 模板。
在 Django 模板中，您可以接收参数并相应地显示结果。例如，您可以在下面的 Django 模板示例中看到如何获取参数。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Products</title>
</head>
<body>
<h2>Your parameter value is : {{URL parameter}}</h2>
</body>
</html>
通过这种方式，您可以从 URL 获取参数，并将其传递给 Django 模板。
您已经看到了在 Django 中获取 URL 参数的步骤，现在是时候看一个例子了。通过一个例子来理解它，你会对这个过程有一个更清晰的印象。
从 Django 示例中的 URL 获取参数
在本节中，出于演示目的，我将使用我的本地主机地址。你可以用你网站的基本网址来改变它。
例如，如果 URL 是:
http://localhost:8000/products/125
那么产品将是 URL 端点，而 125 将是 URL 参数。
首先，我必须编辑我的 URL 文件，如下所示:
from django.urls import path
from . import views
urlpatterns = [
path('',views.index),
path('products/<int:id>', views.viewpara, name = 'view_products')
]
我已经创建了一个到产品端点的路径。我已经将路径转换器定义为 int ，以指定 URL 参数将是一个整数。
不要与名为索引的路径混淆。它只是一个指向我的基本 URL 的路径。
views.viewpara 是在 views.py 文件中定义的函数，当发出请求时将被执行。views.py 文件将是:
from django.shortcuts import render
def index(request):
return render(request, 'index.html')
def viewpara(request, para):
return render(request, 'result.html', {'para' : para})
上述函数将从请求中接收参数。我已经将这个参数作为字典对象传递给了一个名为result.html的 Django 模板。
Django 模板如下所示:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Products</title>
</head>
<body>
<h2>Your parameter value is : {{id}}</h2>
</body>
</html>
这个 Django 模板将在发出请求时呈现。现在让我们看看输出:
Get URL parameters in Django
您可以看到传递给 URL 的参数值显示在 Django 模板中。如果我改变参数的值，结果也会改变:
How to get parameter from URL in Django
因此，您可能已经对在 Django 的 URL 中传递参数有了基本的了解。我将在接下来的章节中解释更多的例子。但在此之前，让我们了解一下 Django 的路径转换器。
路径转换器 Django
Django 中的路径转换器指定了您试图通过 URL 作为参数发送的数据类型。在上面的例子中，我使用了 int path 转换器来传递整数值作为 URL 参数。
但是，您也可以使用其他内置路径转换器。下面是一些内置的路径转换器，您可以在定义 URL 参数时使用:
int: 可用于提供包括 0 在内的正整数值作为 URL 参数。例如，传递产品 id。
str:str 路径转换器可用于定义字符串参数，不包括“/”符号，并验证字符串是否为非空。例如，传递用户名或令牌。
slug: 由包含 ASCII 值的 slug 字符串组成，包括连字符和下划线运算符。你可能在博客或文章网站上看到过 slug 参数。
例如，URL【https://pythonguides.com/python-django-get/】将在 slug 参数的帮助下重定向到特定的文章。在这个 URL 中， python-django-get 是 slug 参数。
uuid: 一个格式化的 uuid。如果要将 UUID 作为参数传递，可以使用这个路径转换器。一个 UUID 的例子是:T3 123 e4567-e89b-12 D3-a456-426614174023。
path: 这个路径转换器由一个非空字符串组成，包括“/”符号，定义为传递一个路径作为参数。
str 和 path 的区别在于，如果你传递一个 path 参数给 str 转换器，它将在“/”符号处终止，你将无法发送完整的路径。
另一方面，在路径的情况下，包含“/”符号，并且成功传递整个路径值。
这些是 Django 的一些内置路径转换器。您还可以定义自定义路径转换器。关于自定义路径转换器的更多信息，你可以阅读 Django 官方文档。
Django URL 参数字符串
现在让我们看一个 URL 的例子，它将一个字符串作为 URL 参数。
我将使用下面的 URL 端点来定义 URL 参数:
http://localhost:8000/showmessage/<message>
在上面的 URL 中，
现在，我将在我的 urls.py 文件中定义这个 URL。urls.py 文件将如下所示:
from django.urls import path
from . import views
urlpatterns = [
path('showmessage/<str:msg>', views.showmessage, name = 'showmessage')
]
你可以看到我已经定义了 str 路径转换器，并且 msg 是参数的名称。
现在让我们更改 views.py 文件:
from django.shortcuts import render
def showmessage(request, msg):
return render(request, 'result.html', {'msg' : msg})
我已经使用了result.html模板来呈现消息:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Products</title>
</head>
<body>
<h2>The message is : {{msg}}</h2>
</body>
</html>
现在，如果您想发送一个字符串参数，假设“Hello World”，您可以在 URL 中将该字符串定义为:
http://127.0.0.1:8000/showmessage/Hello%20World
这里的空格字符需要进行 URL 编码。指定 URL 编码的空格字符。可以在下图中看到响应:
Rendered the supplied string parameter
您可以看到传递的字符串参数呈现在 Django 模板中。
另外，请阅读:Django 中的应用程序和项目之间的差异
Django URL slug 参数
slug 通常用于获取特定的网页。以这样一种方式创建一个 slug，使得仅仅通过阅读 slug 就很容易理解网页的相关性。
使用 slug 作为 URL 参数的 URL 的一个例子是。
在上面的 URL 中， how-to-install-django 部分是一个 slug。
一般来说，这个 slug 是从网页标题创建的。所有单词都转换成小写，并用连字符分隔。
在本节中，我将使用 slug 路径转换器接受 slug 作为 Dajngo 中的 URL 参数。
假设我已经为我的博客网站创建了一个主题端点，我想使用下面的 URL 来显示一篇特定的博客文章:
http://localhost:8000/topics/<blog post slug>
首先，我必须在 urls.py 文件中创建一个路径。在我的例子中，urls.py 文件将是:
from django.urls import path
from . import views
urlpatterns = [
path('topics/<slug:msg>', views.showarticle, name = 'showarticle')
]
这里你可以看到我已经将路径转换器类型定义为 slug ，URL 参数的名称为 msg 。
其次，我必须在 views.py 文件中定义一个名为 showarticle 的函数，如下所示:
from django.shortcuts import render
def showarticle(request, msg):
return render(request, 'result.html', {'msg' : msg})
现在我将在一个名为result.html的 Django 模板中渲染这个 slug。在 Django 模板中，我将接收如下 slug 参数:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Welcome to Python Guides</title>
</head>
<body>
<h2>The blog post slug is : {{msg}}</h2>
</body>
</html>
现在让我们在浏览器中向以下 URL 发送一个请求:
http://127.0.0.1:8000/topics/get-data-from-get-request-in-django
在上面的 URL 中，get-data-from-get-request-in-django是我们作为 URL 参数传递的 slug。
Slug as a URL parameter in Django
因此，通过这种方式，您可以在 Django 应用程序中将 slug 作为 URL 参数传递。
你可能也喜欢阅读以下关于 Python Django 的教程。
- 如何获取 Django 的当前时间
- 如何在 Django 中创建模型
- Python 改 Django 版本
- Python Django get
- Python Django 过滤器
- Python Django group by
因此，您可能已经学会了如何在 Django 应用程序中传递和获取各种类型的 URL 参数。
我们还在 Django 中创建了一篇关于如何从 get 请求中获取数据的文章。您可以阅读这篇文章，了解 Django 应用程序中 GET 参数的用法。
- 如何在 Django 中从 URL 获取参数
- 要查看的 Django URL 传递参数
- 模板中的 Django URL 参数
- 从 Django 示例中的 URL 获取参数
- Django 路径转换器
- Django URL 参数字符串
- Django URL slug 参数
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何在 Django 中获取用户 IP 地址
在这个 Python Django 教程中，我会用简单的步骤解释如何在 Django 中获取用户 IP 地址。
我最近使用 Django web 框架开发了一个项目，其中我需要用户的 IP 地址。因此，这里我们将介绍在 Django 中获取用户 IP 地址的步骤。
在这里我们将看到:
- IP 地址及其用途
- 建立 Django 项目
- 获取 Django 中的用户 IP 地址
- 在 Django 中返回 HttpResponse
在本文的最后，您还可以下载代码来获取 Django 中的用户 IP 地址。
目录
如何获取 Django 中的用户 IP 地址
现在，我们先来了解一下什么是 IP 地址，一步一步的学习在 Django 中获取用户的 IP 地址。
IP 地址
IP 地址代表 【互联网协议地址】
一般来说， IP 地址是分配给网络设备的号码，用于该设备的识别和定位。基本上，计算机使用 IP 地址在不同的网络和互联网上相互连接。
所有类型的网络设备都会收到一个 IP 地址。它可能是一个网站、照相机、笔记本电脑、桌面设备，甚至是可以连接到互联网的儿童玩具。
获取 Django 中的用户 IP 地址
现在，我们将看到一个在 Django 中获取用户 IP 地址的例子。
建立 Django 项目
打开终端，键入以下命令开始一个 Django 项目。本例中的 Django 项目名为 UserIpProject 。
django-admin startproject UserIpProject
它将创建一个名为 UserIpProject 的文件夹，并在终端中键入以下命令来访问该项目。
cd UserIpProject
通过在终端中输入以下命令，我们可以在这个项目文件夹中创建一个名为 MyApp 的 Django 应用程序。
python manage.py startapp MyApp
Set up Project in Django
将应用名称添加到位于 settings.py 文件中的 INSTALLED_APP 列表中，以激活该应用。
Settings.py
Django 自动将一个 urls.py 文件包含在项目目录中，以便将新创建的应用程序映射到其中。为此，请将下面的代码添加到其中。
from django.contrib import admin
from django.urls import path,include
urlpatterns = [
path('admin/', admin.site.urls),
path('',include('MyApp.urls')),
]
查看获取 Django 中的用户 IP 地址
要定义应用程序的主要逻辑，打开 views.py 文件并添加下面给出的代码。
from django.shortcuts import HttpResponse
# Create Viewe
def ipaddress(request):
user_ip = request.META.get('HTTP_X_FORWARDED_FOR')
if user_ip:
ip = user_ip.split(',')[0]
else:
ip = request.META.get('REMOTE_ADDR')
return HttpResponse("Welcome User!<br>You are visiting from: {}".format(ip))
创建一个名为 ipaddress 的视图，它将获取用户的 IP 地址。然后，要获得客户端的 IP 地址，使用 HTTP_X_FORWARDED_FOR 变量。
当用户通过代理或负载平衡器时，它存储 IP 地址。为了获得本地客户端的 IP 地址，它将使用 REMOTE_ADDR 并返回 127.0.0.1 。
现在，为了调用视图，我们必须将视图映射到 URL，因此我们必须在 app 目录中创建一个名为 urls.py 的文件。在其中包含以下代码。
from django.urls import path
from . import views
urlpatterns = [
path('', views.ipaddress, name='ipaddress'),
]
执行 Django 应用程序
要启动开发服务器，请在终端中键入下面给出的命令。
python manage.py runserver
它将打开，页面有用户的 IP 地址。
User’s IP Address
太好了！！！！我们现在可以看到我们正在使用 localhost。
这就是我们如何获得 Django 用户的 IP 地址。
下载 Python Django 的完整代码获取 IP 地址
代码如下:
结论
这样，我们就成功地创建了一个 Django 项目来获取用户的 IP 地址。我们还学习了 IP 地址的含义及其用法。
此外，我们还讨论了以下主题。
- IP 地址及其用途
- 建立 Django 项目
- 获取 Django 中的用户 IP 地址
- 在 Django 中返回 HttpResponse
您可能也喜欢阅读下面的 Python Django 教程。
拥有丰富 Django 和 Matplotlib 经验的 Python 开发人员，目前在 TSInfo Technologies 工作。我正在成为专业程序员、博客写手和 YouTuber 的路上。
如何在 Python Tkinter 程序中转至下一页
原文：https://pythonguides.com/go-to-next-page-in-python-tkinter/
多页面应用程序需要一个选项，用户可以在不同的页面之间切换。所以在本教程中，我们将学习如何在 Python Tkinter 程序中进入下一页。
当在一个特定的部件上添加了对下一个页面的引用时，用户点击那个部件，然后移动到下一个页面。同时发生的还有一件事，就是前一页被关闭或者销毁。
不熟悉 Python Tkinter？查看 Python GUI 编程
在 Python Tkinter 中转至下一页
每。py 文件可以被视为一个模块，我们可以在需要时导入它们。另一方面，我们可以使用内置方法销毁前一页。让我们在这个小程序中看看实际情况。
代码片段:
- 在这段代码中，我们创建了 3 个页面，每个页面都有两个按钮。
- 第一个按钮将导航到下一页&另一个按钮将转到上一页。点击任一页面将触发一个功能，当前页面将被销毁，一个新页面将被导入。
- 页面命名为第一页、第二页、和第三页
- 所有的页面都有几乎相似的代码。最需要注意的是导入页面。每个页面都导入不同的页面。
def nextPage():
ws.destroy()
import page2
nextPage():是一个函数名ws.destroy():关闭当前页面- 导入第二页:第二页开始显示。
第 1 页
这是创建 page1.py 的源代码。创建一个名为 page1.py 的新文件，然后复制并粘贴以下代码。
from tkinter import *
ws = Tk()
ws.geometry('400x300')
ws.title('PythonGuides')
ws['bg']='#5d8a82'
f = ("Times bold", 14)
def nextPage():
ws.destroy()
import page2
def prevPage():
ws.destroy()
import page3
Label(
ws,
text="This is First page",
padx=20,
pady=20,
bg='#5d8a82',
font=f
).pack(expand=True, fill=BOTH)
Button(
ws,
text="Previous Page",
font=f,
command=nextPage
).pack(fill=X, expand=TRUE, side=LEFT)
Button(
ws,
text="Next Page",
font=f,
command=prevPage
).pack(fill=X, expand=TRUE, side=LEFT)
ws.mainloop()
使用 Tkinter 阅读 Python 中的注册表
第 2 页
这是创建 page2.py 的源代码。创建一个名为 page2.py 的新文件，然后复制并粘贴以下代码。
from tkinter import *
ws = Tk()
ws.geometry('400x300')
ws.title('PythonGuides')
ws['bg']='#ffbf00'
f = ("Times bold", 14)
def nextPage():
ws.destroy()
import page3
def prevPage():
ws.destroy()
import page1
Label(
ws,
text="This is Second page",
padx=20,
pady=20,
bg='#ffbf00',
font=f
).pack(expand=True, fill=BOTH)
Button(
ws,
text="Previous Page",
font=f,
command=nextPage
).pack(fill=X, expand=TRUE, side=LEFT)
Button(
ws,
text="Next Page",
font=f,
command=prevPage
).pack(fill=X, expand=TRUE, side=LEFT)
ws.mainloop()
第 3 页
这是创建 page3.py 的源代码。创建一个名为 page3.py 的新文件，然后复制并粘贴下面的代码。
from tkinter import *
ws = Tk()
ws.geometry('400x300')
ws.title('PythonGuides')
ws['bg']='#ffbf00'
f = ("Times bold", 14)
def nextPage():
ws.destroy()
import page1
def prevPage():
ws.destroy()
import page2
Label(
ws,
text="This is Third page",
font = f,
padx=20,
pady=20,
bg='#bfff00'
).pack(expand=True, fill=BOTH)
Button(
ws,
text="Previous Page",
font=f,
command=nextPage
).pack(fill=X, expand=TRUE, side=LEFT)
Button(
ws,
text="Next Page",
font = f,
command=prevPage
).pack(fill=X, expand=TRUE, side=LEFT)
ws.mainloop()
输出:
在这个输出中，您可以看到三页。每个页面都有一个标签和两个按钮。这些按钮将用户带到上一页或下一页。
go to next page in Python Tkinter
您可能会喜欢以下教程:
- Python Tkinter 帧
- 如何用 Python 制作计算器
- Python Tkinter 列表框
- Python Tkinter Stopwatch
- Python Tkinter 进度条
- 使用 Python Pygame 创建游戏
- Python Tkinter 选项菜单
所以在本教程中，我们已经学习了如何在 Python Tkinter 程序中进入下一页。如果你有任何疑问或者你有更好的方法，请写在下面的评论里。
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
梯度下降优化器张量流
原文：https://pythonguides.com/gradient-descent-optimizer-tensorflow/
在这个 Python 教程中，我们将学习如何在 Python TensorFlow 中使用梯度下降优化器。此外，我们将涵盖以下主题。
- 梯度下降优化器张量流
- 随机梯度下降优化器张量流
- 张量流使用梯度下降优化器
- TensorFlow 成本最小化的梯度下降优化函数
目录
梯度下降优化器张量流
- 在本节中，我们将讨论如何在 Python TensorFlow 中使用梯度下降优化器。
- 如果我们想要找到模型的输入，使其输出最小化，那么这种技术将帮助用户计算梯度下降优化器。输入是模型的参数，输出是损失函数。
- 为了执行这个特定的任务，我们将使用
TF . compat . v1 . train . gradientdescentoptimizer()函数，这个函数将执行梯度下降算法。
语法:
我们先来看看语法，了解一下TF . compat . v1 . train . gradientdescentoptimizer()函数在 Python TensorFlow 中的工作原理。
tf.compat.v1.train.GradientDescentOptimizer(
learning_rate, use_locking=False, name='GradientDescent'
)
- 它由几个参数组成
- learning_rate: 该参数指定了我们想要使用的学习率，它是一个输入张量。
- use_locking: 默认情况下，它采用 false 值，如果为 true，那么它使用锁进行更新操作。
- 名称:默认取“梯度下降名称，该参数指定操作的名称。
举例:
让我们举个例子，检查一下如何在 Python TensorFlow 中使用梯度下降优化器。
源代码:
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
from pylab import figure, cm
new_val = np.arange(-20,20,0.4)
result = new_val**4
new_img = figure(num=None, figsize=(16, 14), dpi=60, facecolor='w', edgecolor='k')
plt.plot(new_val,result)
plt.title('Gradient TensorFlow descent')
plt.xlabel('new_val')
plt.ylabel('result')
plt.savefig("gradient_descent_tensorflow_01.png", bbox_inches='tight')
plt.show()
def loss_function(new_val):
return new_val ** 4.0
def loss_function_minimzie():
return new_val ** 4.0
def reset():
new_val = tf.Variable(20.0)
return new_val
new_val = reset()
new_out = tf.keras.optimizers.SGD(learning_rate=0.1)
for i in range(20):
print ('y = {:.1f}, x = {:.1f}'.format(loss_function(new_val).numpy(), new_val.numpy()))
new_out.minimize(loss_function_minimzie, var_list=[new_val])
下面是下面给出的代码的截图。
Figure show gradient descent`
Gradient descent optimizer TensorFlow
阅读:张量流乘法-有用指南
随机梯度下降优化器张量流
- 在本节中，我们将讨论如何在 Python TensorFlow 中使用随机梯度下降优化器。
- 为了执行这个特定的任务，我们将使用
TF . keras . optimizer . SGD()算法，并且这个函数被用来寻找主导神经网络的模型参数。
语法:
下面是 Python TensorFlow 中TF . keras . optimizer . SGD()函数的语法。
tf.keras.optimizers.SGD(
learning_rate=0.01,
momentum=0.0,
nesterov=False,
name='SGD',
**kwargs
)
- 它由几个参数组成。
- learning_rate: 该参数表示输入张量，它不接受任何参数，并返回要使用的真实值，默认情况下，它接受 0.01 的值。
- momentum: 默认情况下，它取 0.0 值，并指定
举例:
import tensorflow as tf
opt = tf.keras.optimizers.SGD(learning_rate=4.0)
new_val = tf.Variable(6.0)
result = lambda: (new_val ** 6)/2.0
new_count = opt.minimize(result, [new_val]).numpy()
new_val.numpy()
在下面给定的代码中，我们已经导入了 TensorFlow 库，然后使用了TF . keras . optimizer s . SGD()函数，在这个函数中，我们指定了学习率=4.0。
之后，我们创建了一个张量并分配了张量值，并优化了给定值。一旦执行了这段代码，输出将显示一个梯度下降值。
下面是以下给定代码的执行。
stochastic gradient descent optimizer TensorFlow
阅读:张量流均方误差
TensorFlow 使用梯度下降优化器
- 在本期节目中，我们将讨论如何在 Python TensorFlow 中使用梯度下降优化器。
- 为了执行这个特定的任务，我们将使用
tf.variable()函数通过使用tf.variable()函数来创建一个张量。 - 然后使用
TF . train . gradienddescentoptimizer()函数优化梯度下降值。
语法:
下面是 Python TensorFlow 中TF . train . gradient optimizer()函数的语法。
tf.compat.v1.train.GradientDescentOptimizer(
learning_rate, use_locking=False, name='GradientDescent'
)
举例:
让我们举个例子，看看如何在 Python TensorFlow 中使用梯度下降优化器。
源代码:
import tensorflow as tf
new_tens = tf.Variable(2, name = 'x', dtype = tf.float32)
new_val = tf.log(new_tens)
new_log = tf.square(new_val)
optimizer = tf.train.GradientDescentOptimizer(0.5)
train = optimizer.minimize(new_log )
init = tf.initialize_all_variables()
def optimize():
with tf.Session() as session:
session.run(init)
print("x:", session.run(new_tens), session.run(new_log ))
for step in range(10):
session.run(train)
print("step", step, "x:", session.run(new_tens), session.run(new_log ))
optimize()
在下面给定的代码中，我们定义了 optimize()函数，然后使用 tf.session() 函数创建会话，并初始化它的日志值。
注意:这个例子只适用于 TensorFlow 1.x 版本，因为 tf.session()函数只适用于 1.x 版本
你可以参考下面的截图。
TensorFlow uses a gradient descent optimizer
TensorFlow 的梯度下降优化函数，成本最小
- 在本节中，我们将讨论如何最小化 Python TensorFlow 中梯度下降优化器函数的成本。
- 为了完成这项任务，我们将使用
TF . compat . v1 . train . gradienddescentoptimizer()函数来获取最小值。 - 接下来，我们将导入
TF . compat . v1 . disable _ eager _ execution()来创建会话，同时我们将使用TF . compat . v1 . set _ random _ seed()函数来生成随机值。
举例:
import tensorflow as tf
tf.compat.v1.disable_eager_execution()
tf.compat.v1.set_random_seed(777)
tens1 = [4, 5, 6]
tens2 = [4, 5, 6]
tens3 = tf.Variable(5.)
new_hypto = tens1 * tens3
gradient = tf.reduce_mean((tens3 * tens1 - tens2) * tens1) * 2
cost = tf.reduce_mean(tf.square(new_hypto - tens2))
new_opt = tf.compat.v1.train.GradientDescentOptimizer(learning_rate=0.01)
train = new_opt.minimize(cost)
new_result = new_opt.compute_gradients(cost, [tens3])
apply_gradients = new_opt.apply_gradients(new_result)
with tf.compat.v1.Session() as val:
val.run(tf.compat.v1.global_variables_initializer())
print(step, val.run([gradient, tens3, new_result]))
在下面给出的代码中，我们使用了 tf.reduce_mean() 函数，并将 new_hypto 值指定为参数，然后使用 new_opt.minimize() 参数来最小化成本值。
下面是下面给出的代码的截图。
TensorFlow’s gradient descent optimizer function with minimize cost
还有，多看看一些 TensorFlow 教程。
- Python TensorFlow 截断法线
- Python tensor flow expand _ dims
- 熊猫数据帧到张量流数据集
- 张量流自定义损失函数
- tensor flow next _ batch+Examples
- 张量流交叉熵损失
- Python TensorFlow 随机均匀
- Python tensor flow reduce _ sum
因此，在本教程中，我们已经学习了如何在 Python TensorFlow 中使用梯度下降优化器。此外，我们还讨论了以下主题。
- 梯度下降优化器张量流
- 随机梯度下降优化器张量流
- 张量流使用梯度下降优化器
- TensorFlow 成本最小化的梯度下降优化函数
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Python 熊猫中的 Groupby
在本 python 教程中，我们将学习 python 熊猫中关于 Groupby 的一切。
- Python 熊猫中的 Groupby 介绍
- Python 熊猫中的 Groupby
- 按熊猫分组示例
- 熊猫计数分组
- 分组依据熊猫多列
- 按熊猫总数分组
- 无聚集的熊猫群
- 熊猫总和
- 熊猫两列
- 分组依据熊猫排序
- 熊猫团体申请
- 熊猫 agg
- 熊猫的意思是
- Python 迭代熊猫群
如果你是 Python 熊猫的新手，请查看 Python 中的熊猫。
我们将使用从这个 URL 下载的食物数据集。
目录
- Python 中的熊猫群简介
- 按熊猫分组数据帧
- 熊猫分组示例
- 按熊猫数量分组
- Groupby 熊猫多栏目
- 一群熊猫聚集在一起
- 无聚集的熊猫群
- 分组通过熊猫求和
- 组靠熊猫两列
- 分组按熊猫排序
- 小组通过熊猫申请
- 熊猫 agg
- 熊猫的意思是
- Python 迭代熊猫群
Python 中的熊猫群简介
- groupby 操作涉及拆分对象、应用函数和组合结果的某种组合。这可用于对大量数据进行分组，并对这些组进行计算操作。
- 假设你想知道所有国家的开发者平均工资。在这种情况下，groupby 可用于显示各个国家的平均工资。
- Python 熊猫中的 Groupby 类似于 SQL 中的
Group by。
Groupby in Python Pandas
语法:
dataframe.groupby(
by=None,
axis=0,
level=None,
as_index=True,
sort=True,
group_keys=True,
squeeze=<object object>,
observed=False,
dropna=True
)
参数:
| 由 | –映射、功能、标签或标签列表
–用于确定 groupby 的组。
–如果 by 是一个函数，它在对象的
索引的每个值上被调用。
–如果by是字典或系列，系列或字典值将用于确定组。
–默认情况下by=None |
| 轴 | –{ 0 或' index '，1 或' columns'}，默认为 0
–按行(0)或列(1)拆分。
–例如:轴=0 或轴=1 |
| 级别 | –int、级别名称或类似的序列，默认为 None。
–如果轴是多索引(层次)，则按特定级别分组。 |
| as_index | –bool，默认 True
–对于聚合输出，返回一个以组标签为索引的对象。
–仅与数据帧输入相关。
–as_index=False 是有效的“SQL 式”分组输出。 |
| 排序 | –bool，默认为真
–对组键进行排序。
–关闭此选项可获得更好的性能。请注意，这不会影响每组内的观察顺序。
–group by 保留每个组中行的顺序。
–例如: sort=False |
| 组 _ 键 | –bool，default True
–调用 apply 时，将组键添加到索引中以标识片段。
——例如: group_keys = False |
| 挤压 | –bool，default False
–如果可能，减少返回类型的维数，否则返回一致的类型。
——例如: squeeze=True |
| 观察到的 | –bool，default False
–这仅适用于任何 groupers 是类别的情况。
–如果为真:仅显示分类群组的观察值。
–如果为假:显示分类分组的所有值。
–例如: observed=True |
| dropna | –bool，默认为真
–如果为真，并且如果组键包含 NA 值，NA 值连同行/列将被删除。
–如果为假，NA 值也将被视为分组中的键
–例如: dropna=True |
你可能也会喜欢 Python 熊猫 CSV 教程。
按熊猫分组数据帧
- 在本节中，我们将学习在 DataFrame 上创建和实现
Python pandas groupby。 - groupby 操作包括一些组合:分割对象的、应用函数的和组合结果的。****
- 这可用于对大量数据进行分组，并对这些组进行计算操作。
语法:
下面是在 Python 的 dataframe 上用 Pandas 实现 groupby 的语法。这个博客的介绍部分解释了这些参数。
DataFrame.groupby(
by=None,
axis=0,
level=None,
as_index=True,
sort=True,
group_keys=True,
squeeze=<object object>,
observed=False,
dropna=True
)
在 jupyter 笔记本上实现:
Python 编码指南
很少有编程语言像 Python 一样受到青睐和推崇。Python 是一种非常流行的编程语言，由著名的荷兰程序员吉多·范·罗苏姆创建，最初发布于 1991 年。
coding with python
近年来，由于其易于使用的语法和对初学者友好的操作，Python 已经成为世界上最伟大和使用最广泛的通用编程语言之一。
此外，它比其他可用的编程语言快得多。
Python 不仅是一种非常容易理解的语言，在非开发人员和开发人员中都很受欢迎，而且你通常可以在各种过程中找到这种类型的编程，例如软件测试、系统脚本编写或构建网站。
但是在开始使用这种编码语言之前，您需要知道哪些重要的事情呢？它真的适合初学者吗？
无论您是编程新手，还是只是想了解更多关于如何开始使用 Python 的信息，本指南都将为您提供您可能需要的所有基本工具和知识！
让我们直接开始吧。
目录
- Python 编码
- Python 是
- Python 在不同平台上工作
- Python 语言类似于英语
- 基础知识
- Python 使用
- 总结
Python 编码
Python Coding
Python 编码是一种通用语言，可用于创建各种程序，而不是专门针对单一问题。
它的初学者友好的应用和这种多功能性使 Python 成为当今世界上最突出和最广泛使用的编程语言之一。
巨蟒是
Python Is
解释: Python 编码可以在运行时执行，任何程序更改都很容易被发现。用技术术语来说，Python 编码有一个编译器，可以将一种编程语言编写的代码翻译成另一种语言。
与 Java 或 C++相比，这两种软件之间的差异非常明显。例如， Python 编码远比这些其他类型的软件透明和自动化。
然而，使用 Python，不需要担心编译步骤，因为这是实时发生的。
不幸的是，解释语言通常比编译语言慢得多，因为它们每次只输入一行指令或代码。
语义动态: Python 使用动态语义，这意味着它的变量是动态对象。这些是存在于运行时级别的值的实例，在代码中被设置为构造。
面向对象:Python 编码中的一切都是对象。这意味着您有办法构建程序来保证属性和行为被捆绑到不同的对象中。
然而，您可以选择以过程化的、面向对象的或函数式的方式编写代码。我们将在下面详细讨论这一点。
Python 是一种高级编程语言，因为它与英语非常相似。这意味着 Python 不需要你掌握处理任何底层机器细节的知识。
Python 在不同平台上工作
Python Works On Different Platforms
Python 最伟大的一点是它是一种跨平台的语言。它足够灵活，可以跨各种系统工作，这加快了构建应用程序的过程，同时也使它更加方便。
这意味着任何在苹果电脑上编写的程序也可以在 Linux 系统上运行，反之亦然。如果计算机安装了正确的 Python 解释器，Python 程序也可以在 Windows 计算机上运行。
其他操作系统如 Raspberry Pi 也为编写 Python 代码提供了不同的选项。但是选择什么平台或者操作平台，大多是个人喜好的问题。
允许开发者编写比其他语言更短的程序
Python 有一种语法，使开发人员能够用比其他编程语言少得多的代码行编写程序。“语法”一词用于描述一组规则，这些规则积极地定义了 Python 将如何被编写和解释。
由于 Python 运行在解释器系统上，它允许代码一写出来就被快速执行，这意味着原型制作通常会非常快。
将一个想法或概念转化为任何类型的短软件原型的代码可以在几天或几周内完成，而不是几个月。
可以作为功能性的、面向对象的、程序性的方式
尽管普遍认为 Python 是一种面向对象的编程语言，而不是过程化编程，但事实并非如此。Python 编码可以支持面向对象和过程化编程。
然而，以函数式风格编写 Python 是很重要的——尤其是当你试图编写需要大量数学计算的程序时。
Python 语言类似于英语
Python Language Is Similar To English
Python 是一种高级语言，它几乎被设计成程序员必须学习的第二语言。由于其语法，这种编码语言非常类似于英语，这意味着它对人类来说有很大的可读性，但对计算机来说可读性差得多。
相对容易学，学习曲线低。如果程序员愿意付出努力和奉献来发展他们对 Python 语言的理解，理论上这应该不会太难。
基础知识
Python Basics
基本面
语法
正如我们已经建立的，语法指的是编程语言的结构。这些是用于定义人类读者和计算机如何编写和解释 Python 程序的既定规则。
就像我们必须学习语法才能理解英语一样，你也必须学习 Python 语言。一旦掌握了 Python 优雅的语法结构，python 编码和编程应该是一种易读的语言。
理解什么是语法以及它做什么仍然是程序员用任何编程语言编码时必须知道的最简单的要求之一。
变量
当你开发一个程序时，你要负责管理许多不同的价值。为了有效地存储所有值，必须使用变量。
Python 支持各种类型的变量，包括浮点数、文本和整数。只要你能给它赋值，任何东西都可以被标记为变量。
琴弦
不，这些不像吉他上的弦。相反，字符串是一系列字符。在 Python 中，单引号或双引号内的任何内容都被视为字符串。
需要注意的一点是，字符串是不可变的，这意味着它们不能被改变。您可以使用索引来访问字符串元素，第一个字符的索引为零。
数字
Python numbers 向您介绍了浮点数、复数和整数等数字类型。这些也是不可变的，这意味着如果你改变了数据的值，那么你最终会得到一个完全新的对象。
这些数字对象是在被赋值后创建的。
布尔
在任何编程中，你都需要经常检查一个条件是否为真，然后采取最合适的行动。为了表示不同类型数据的真实值，Python 为您提供了布尔值。
当您比较两个数字或两个字符串时，Python 将以布尔值的形式返回结果。
常数
顾名思义，这些是常量变量，它们的值不能改变。将这些视为保存大量不可更改信息的容器可能会有所帮助。
Python 中很少使用常量，因为没有等价的常量。程序员通常很有见识，不会去管他们想保持不变的值。
评论
您还需要学习如何在代码中做笔记，以跟踪您所在的位置，或者简单地记录您正在编写的代码类型。
一旦掌握了 Python 编码语言的一般规则，添加注释(包括行内注释、块注释，甚至文档字符串)将成为你的第二天性。
式对话
类型转换是对象从一种数据类型到另一种数据类型的直接转换，这在竞争和日常编程中很有用。
Python 中有两种类型的类型转换:隐式类型转换，在没有用户参与的情况下转换数据类型；显式类型转换，需要手动输入来转换数据类型。
作战
Python Operations
比较运算符
这些运算符将向您介绍比较运算符，以及如何使用它们来比较两个不同的值。从本质上讲，它们就像名字所暗示的那样:比较。
然而，它们也被称为关系运算符，因为它们可以用来查找操作数之间的关系，然后生成一个布尔值。
有六种比较运算符:
- 小于(
- 小于或等于(< =)
- 大于(>)
- 大于或等于(> =)
- 等于(==)
- 不等于(！=)
逻辑运算符
如果您希望在任何给定的时间检查多个条件，您必须使用逻辑运算符。Python 编码中有三个逻辑运算符:
- And 运算符–同时检查两个条件是否为真。
- Or 运算符–检查多个条件，但当其中一个或两个条件都为真时，返回“真”。
- Not 运算符–这只适用于一个条件，然后将其反转。例如，如果条件为真，该运算符将返回 false。
控制流量
If… Else 语句
“if-else”语句通常用于执行条件的真和假部分。如果条件被认为是真的，则执行块代码。
如果条件为假，将执行 else 块代码(这将是不同的代码块)。
三元运算符
三元运算符是在 Python 编程中编写条件语句的一种很好的方式，允许您控制程序的流程。
它可以被认为是一个简单的单行版本的“if…else”语句，用来测试一个条件并确定它是真还是假。
顾名思义，Python 运算符由三个独立的操作数组成:
- True Value–如果表达式被评估为 True，则可以分配该值。
- False 值–如果表达式为 false，则可以指定该值。
- condition–一个布尔表达式，计算结果为 True 或 false。
为循环带范围()
在任何类型的编程中，您经常需要多次执行一个代码块。这时你需要使用一个带有 range() 函数的 for 循环。
For 循环可以降低代码重复的风险，因为您可以根据需要多次重复相同的操作。
而
Python 中的“while”循环语句有助于重复执行代码块——前提是给定的条件为真。
这个 while 循环属于不确定迭代的范畴，这意味着它通常在预先迭代的次数未知或事先没有明确说明的情况下使用。
破
Python 中的 break 是一个控制语句，用于保持对整个循环序列的控制。Python 编程中的 break 语句终止当前循环，然后在下一条可用语句处继续执行。
break 函数的一个常见用途是，当外部条件被触发时，您需要完全退出循环，或者您想要跳过循环的一部分。
继续
处理 Python 编码时你需要知道的另一个关键词是‘continue’。该函数用于结束包含它的当前循环迭代。
然后，程序的总控制权直接流向循环体之后的语句。当循环时，可以在中为和使用“继续”语句。
过关
在处理 Python 编码时,“pass”语句充当了未来代码的占位符。当这个语句被执行时，什么也不会发生，但是当不允许空代码时，你可以避免收到一个错误。
函数定义、循环、语句中不允许有空代码，也不允许将空代码作为类定义的一部分。
功能
Python 函数
一个 Python 函数有两个主要部分:函数体和定义。函数体由缩进的行组成，而定义以“def”关键字和函数名“greet”开始。
函数用于将较大的程序分成可管理的部分，使得开始开发、阅读、测试和维护程序变得更加容易。
关键词参数
与其他编程语言相比，关键字参数是 Python 的一个有点奇怪的特性。也称为命名参数，这些值在传递给函数时可以通过特定的参数名称来标识。
默认参数
当您调用一个函数，然后将一个参数传递给一个具有默认值的参数时，该函数将使用该值而不是默认值。
要使用默认参数，您必须将参数放在其他参数之后的默认值中，否则，您会以语法错误而告终。
递归函数
递归函数可以定义为直接或间接调用自身的例程。一些主要的例子包括阶乘，其中一个整数在被降低的同时与自身相乘。
λ表达式
Lambda 表达式是 Python 的高级构造。它们是接受参数并返回值的短代码块。通过了解这些，您可以了解如何定义一些匿名函数。
docstring
docstring 是一个文字字符串，用于记录 Python 类、模块、方法或函数，使程序员无需了解实现细节就能理解它做了什么。它帮助程序员识别和记录特定的代码段。
列出了
列表
顾名思义，列表中的项目是有序的，所以你可以根据需要多次添加相同的项目。列表也是可变的，这意味着你可以在创建后通过添加或删除条目或者简单地改变值来改变列表。
元组
类似于一个列表，一个元组帮助程序员保持事物有序，也允许项目的重复。然而，有一个关键的区别:元组是不可变的，这意味着它在创建后不能更改。如果你试图做一些改变，Python 解释器会显示有一个错误。
在列表中排序
方法对原始列表进行排序，并修改列表中元素的顺序。它在项目之间使用默认的<比较运算符，以升序或降序排列这些项目。
排序列表
任何 Python 编码程序员都必须学会如何使用 sorted() 函数从原始列表中恢复一个新的排序列表。它不修改原始列表，而是使用小于运算符(<)将元素从最低到最高排序。
切片列表
除了对列表进行排序，学习如何对列表进行切片也很重要。它是任何地方的程序员解决问题最广泛使用的技术之一。
start是切片开始的列表的索引。- 停止点是切片结束的位置。
- 步骤帮助您选择开始到- 停止范围内的第第 n项。
解包列表
这个基本函数帮助你通过列表解包将列表元素和值分配给不同的变量。通常使用*来正式解包列表，这样每个元素都可以作为不同的参数传递。
迭代列表
列表用于存储编程中的数据序列，因为我们经常想要对列表中的每个元素执行相同的操作。这可以包括以数学方式操纵每个元素或显示所述元素。必须使用循环来迭代列表中的每个元素，对每个元素重复相同的代码。
某个元素的索引
在 Python 和其他编程语言中，索引从 0 开始，而不是从 1 开始。如果您想在 Python 中查找列表的索引，您必须使用内置的 index() 函数，该函数在列表的开头搜索给定的元素，并返回该元素出现的最低索引数字。
**Python 中的 iterable 是包含零个、一个或几个元素的对象。它可以一次返回一个元素。由于这个特性，您可以使用 for 循环来迭代 iterable。
用 Map()变换列表元素
内置的 Python map() 函数遍历 iterable 中的所有元素，然后返回 map 对象。iterable 包括元组、列表、字典和集合。然后对每个元素应用一个特定的函数，并返回一个新的元素迭代器。
用过滤器过滤列表元素()
Python 有一个名为 filter() 的内置函数，它遍历列表中的元素，并对每个元素应用 fn() 函数。
这将为元素返回一个迭代器，其中的项通过一个函数进行过滤，以测试该项是否被接受。
用 Reduce () 将列表元素还原成一个值
reduce() 函数的工作方式与 map() 和 filter() 不同。它不返回基于函数和已传递的 iterable 的新列表，而是返回单个值。简单地说，它将一个 iterable 的所有值缩减为一个值。
列表理解
这是一个可以在许多情况下使用的单一工具。在 Python 中，如果您想基于现有列表的值创建一个新列表，list comprehension 提供了更短的语法。
字典
字典
Python 中的字典是可变的，但不能保证程序中元素的顺序。Python 字典允许您为每个元素设置访问键。
字典释义
对 Python 编码的字典理解有助于您准确地在字典上运行 for 循环。从这里，您可以转换或过滤每个项目。总的来说，如果使用正确，词典释义会提供更简洁、更有表现力的语法。
集
设定
集合是一种无序、无索引、不可更改的数据类型，没有重复的元素。它用于在单个变量中存储多个项目，并具有高度优化的方式来检查特定元素是否包含在集合中。不能使用索引访问项目。
设定领悟
Python 中的集合理解是一个很少被提及的工具。它的工作原理是返回一个集合，这意味着集合中的元素将被无序且无重复地返回。剩下的遵循类似于列表理解的操作。
集合的联合
两个或多个集合的并集从两个集合中返回不同的值。简单地说， union() 方法返回一个包含原始集合和指定集合中所有项目的集合。
集合的交集
内置的 intersection() 方法找到至少两个或更多集合的交集，然后返回包含两个或更多集合之间相似性的集合。
套差
在 Python 中，集合之间的差异等于两个集合中元素数量的总差异。 difference() 函数返回一个集合，该集合标记两个集合之间的差异。
对称差集
集合中的对称差是属于任何一个可用集合但不存在于交集中的元素。要在 Python 中获得两个或多个集合之间的对称差，可以使用 symmetric_difference() 函数。
子集
subset() 函数返回由当前实例表示的子集。假设你有两套:A 和 b。
如果集合 A 的所有元素对 B 来说都相同，则称集合 A 是集合 B 的超集。如果两个集合的值不相等，则 A 是 B 的正式子集。
超集
您可以使用内置的 Python 比较运算符在程序中查找超集。例如，可以使用小于或等于函数(<=) or the issuperset() 方法。只有当集合 A 是 b 的超集时，才会返回 True。
不相交的集合
当集合没有公共元素并且有一个空交集时，它们被认为是不相交的。Python 有一个内置的 isdisjoint() 特性，可以识别两个集合是否不相交。
如果一个集合中没有元素是另一个指定集合的成员，则返回 True。
异常处理
试试……除了
如果你想在 Python 中处理异常(可能导致代码崩溃的错误)，那么你必须使用‘try/except’语句。
将可能导致异常的代码块放在“try”中。如果一切顺利，您就不需要担心调用‘except’块。
如果出现异常，将执行内部的代码块，这意味着程序不会崩溃。
试…除…最后
“finally”块的执行通常与异常是否被引发无关。它们通常用于允许程序清理包括内存、文件甚至网络连接在内的资源。
试…除…别的
完全可以在末尾添加一个“else”命令。但是，只有在程序中没有异常的情况下才会运行。
Python 使用
Python Uses
系统脚本
Python 中的脚本是一个包含命令的文件，这些命令也像程序一样执行。在 Python 中，脚本是一种优秀的高级语言工具，可用于自动化那些很快就会感觉重复的日常实际任务。
但是，它也可以在应用程序、网站、游戏和其他命令行应用程序中执行。
数据分析
Python 在数据科学中变得极其重要。该语言继续在实验中用于进行复杂的计算，构建机器学习算法，授权与数据相关的任务，以及创建数据可视化。
Python 可以创建各种数据可视化，包括 3D 绘图、线形图和条形图，甚至饼状图。
网页开发
Python 通常用于开发应用程序或网站的后端，或者用户通常不会与之交互或看到的一侧。
Python 在 web 开发中的一般作用可能包括处理数据和与相关数据库通信、从服务器发送和接收数据、保证安全性以及 URL 路由。
机器学习
机器学习是计算机科学的一个领域，它利用统计方法为计算机程序提供从过去的经验中学习的能力，然后找出如何提高特定任务的性能。简单地说，它是一种人工智能 (AI)，赋予计算机学习的能力，而不是程序。
数学
Python 附带了一组内置的数学函数，允许您对多种类型的运算执行数学任务。
数学模块执行在数论和表示理论中非常有用的功能。它帮助您在应用程序中执行常见的数学计算。
软件开发
Python 拥有广泛的功能，这使得它适合于多种类型的软件开发，能够随着业务需求的发展而扩展。
例如，它通常用于音频或视频应用、游戏开发、科学计算，甚至数据分析和可视化。
创建工作流
Python 中的工作流模块定义了许多可用于完成特定任务的函数。创建、开发和执行 Python 代码通常遵循两种不同的工作流模式:
- 在文本文件中创建新代码，并使用 Python 执行它。
- 在文本文件中创建代码，并将其导入 Python REPL。
汇总
Python 编码最初看起来似乎是一种不可能学习的语言，因为新事物无处不在。
然而，如果你花时间致力于理解它的所有语法和不同函数的工作方式，你很快就会踏上编程之路。
事实上，它是最棒的初学者友好编程语言之一。这得益于易于理解的语法和可消化的代码。
除此之外，Python 还可以在多个平台上使用，无需修改。这使得它可以被普遍访问——这是许多其他类似的编程语言所不具备的。
毫无疑问，尽管它已经有近 30 年的历史，但它仍被全世界的企业和商业界视为顶级编程语言。
即使是现在，由于如此广泛的应用程序、充满活力的用户社区和普遍的易用性，它仍然非常重要。难怪这么多人继续重视和使用 Python 编码！
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
python 中的哈希表
在这个 Python 教程中，我们将会看到什么是散列表，我们还将会看到散列表在 Python 中的使用。
目录
python 中的哈希表是什么？
在 python 中，哈希表是一种将键映射到其值对的数据结构。它使得访问数据更快，因为索引值相当于数据值的一个键。
它是通过内置的字典数据类型实现的。
用 python 创建字典
python 中的字典用花括号表示。因此，为了创建一个字典，我们可以使用花括号，也可以使用 dict() 函数来传递键值对作为参数。
举例:
my_dictionary = {'avinan': '111', 'john': '222', 'nick': '223'}
print(my_dictionary)
写完上面的代码(用 python 创建字典)，你将打印出“my _ dictionary”然后输出将显示为“{ ' avinav ':' 111 '，' john': '222 '，' nick': '223'} ”。这里，我的带有键值的字典已经打印出来了。
你可以参考下面用 python 创建字典的截图。
Creating Dictionaries in python
此外，我们将看到如何使用 dict() 函数在 python 中创建字典。
举例:
my_dict = dict(avinav = '111', john = '222')
print(my_dict)
写完上面的代码(使用 dict()函数在 python 中创建字典)，你将打印出“my _ dict”然后输出将显示为“{ ' avinav ':' 111 '，' john': '222'} ”。这里，我们通过传递参数来使用 dict()函数，我的字典就是由这些参数创建的。
可以参考下面的截图使用 dict()函数在 python 中创建字典。
Creating Dictionaries in python
访问字典中的值
在 python 中，可以通过使用 key 获取值来访问字典值。
举例:
my_dictionary = {'avinan': '111', 'john': '222'}
print(my_dictionary['john'])
编写上述代码(访问字典中的值)后，您将打印出 "my_dictionary['john']" ，然后输出将显示为 "222 。这里，我们获得了指定键的值。
您可以参考下面的截图在字典中访问值
Accessing values in the dictionary
更新字典中的值
在 python 中，我们可以在需要的时候更新字典，因为字典是可变的数据类型。
举例:
my_dictionary = {'avinav': '111', 'john': '222'}
my_dictionary['john'] = '221'
print(my_dictionary)
写完上面的代码(更新字典中的值)，你将打印出 "my_dictionary" ，然后输出将显示为 **"{'avinav': '111 '，' john': '221'} "。**这里，我们更新了键的值，现在“john”的值是 221。
您可以参考下面的截图更新字典中的值
Updating values in a dictionary
从字典中删除条目
在 python 中，我们可以使用 del() 函数从字典中删除任何条目。
举例:
my_dictionary = {'avinav': '111', 'john': '222'}
del my_dictionary['avinav']
print(my_dictionary)
写完上面的代码(从字典中删除条目)，你将打印出 "my_dictionary" ，然后输出将显示为 **"{'john': '221'} "。**这里，我们使用 del()函数从字典中删除‘avinav’。
你可以参考下面的截图从字典中删除条目
Deleting items from the dictionary
这就是我们如何在 python 中使用散列表。
您可能会喜欢以下 Python 教程:
- Python Hello World 程序(使用 Pycharm)
- 11 Python 列表方法
- Python 回文程序
- 如何在 Python 中创建列表
- Python 中的块缩进
- Python For 循环示例
- Python 读取 excel 文件并在 Python 中写入 Excel
- 在 Python 中创建一个元组
- Python 创建空集
- Python 通过引用或值传递示例
- Python 从列表中选择+示例
在本教程中，我们讨论了 python 中的哈希表，，我们也看到了如何使用字典创建它。
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
水平线 matplotlib
在本 Python 教程中，我们将讨论 Python 中的水平线 matplotlib 。在这里，我们将使用 matplotlib 涵盖与水平线相关的不同示例。我们还将讨论以下主题:
- 水平线 matplotlib
- 虚线水平线 matplotlib
- 带标签的水平线 matplotlib
- 多水平线 matplotlib
- Matplotlib 水平线粗细
- Matplotlib 水平线颜色
- Matplotlib 水平线在数值处
- Matplotlib 水平线位于 0
- 水平线 matplotlib 子图
- Matplotlib 水平线全宽
- Matplotlib 误差线水平线
- 水平网格线 matplotlib
- 带文本的 Matplotlib 水平线
- 注释水平线 matplotlib
- Matplotlib 删除水平线
- Matplotlib 向条形图添加水平线
目录
- 水平线 matplotlib
- 虚线水平线 matplotlib
- 带标签的水平线 matplotlib】
- 多条水平线 matplotlib
- Matplotlib 水平线粗细
- Matplotlib 水平线颜色
- Matplotlib 水平线在数值
- Matplotlib 水平线在 0 处
- 水平线 matplotlib 子图
- Matplotlib 水平线全宽
- Matplotlib 误差线水平线
- 水平网格线 matplotlib
- 带文本的 Matplotlib 水平线
- 标注水平线 matplotlib
- Matplotlib 删除水平线
- Matplotlib 向条形图添加水平线
水平线 matplotlib
在本节中，我们将学习如何在 Python 的 matplotlib 中绘制水平线。在开始这个话题之前，我们首先要了解什么是水平线或者它看起来是什么样子。
一般来说，水平线是从右到左或者从左到右的直线。或者如果我们在坐标平面中说，一条平行于 X 轴的线称为水平线。
” Sleeping Line “
在 Python 中，matplotlib 是一个用于绘图的流行库。它提供了绘制水平线的不同方法，我们将在下面讨论。
- 使用绘图()
- 使用 hlines()
- 使用 axhline()
通过使用 plot()函数
在 matplotlib 中， plot() 方法用于生成 2D 图。
plot()方法的语法如下:
matplotlib.pyplot.plot(x_points, y_points)
上面使用的参数是:
- x_points: x 轴指向绘图。
- y_points: y 轴指向绘图。
我们来看一个用 plot()方法画水平线的例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data**
X = [2, 4, 6, 8]
Y = [0, 0, 0, 0]
**# Plot horizontal line**
plt.plot(X,Y)
**# Show**
plt.show()
- 在上面的例子中，我们导入了
matplotlib.pyplot库。 - 之后，我们定义数据点进行绘图。这里我们指定 y 轴指向
0，因为我们要绘制一条水平线。 - 接下来，通过使用
plt.plot()方法，我们绘制一条线，并通过使用plt.show()方法，用户可视化该图。
plt.plot()
通过使用 hlines()函数
在 matplotlib 中， hlines() 方法用于绘制穿过轴的水平线。这里 hlines 代表水平线。
hlines()方法的语法如下:
matplotlib.pyplot.hlines(y, xmin, xmax, colors, linestyles)
上面使用的参数描述如下:
- y: 指定 y 轴上绘制直线的位置。
- xmin 和 xmax: 指定每行的开始和结束。这些属性是必需的。
- 颜色:指定线条的颜色。
- 线条样式:指定线条的样式或类型
让我们看一个使用 hlines()方法创建的水平线的例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Plot horizontal line**
plt.hlines(5, 4, 8, color='red')
**# Show**
plt.show()
- 在上面的例子中，我们导入了
matplotlib.pyplot库。 - 通过使用
plt.hlines()方法我们绘制水平线。这里我们传递y、xmin、xmax、color作为参数，并将其设置为5、4、8和red。
plt.hlines()
通过使用 axhline()函数
在 matplotlib 中， axhline() 方法用于绘制到绘图的水平线。
axh line()方法的语法如下:
matplotlib.pyplot.axhline(y, xmin, xmax, color, linestyle)
上述使用的参数描述如下:
- y: 指定 y 轴上绘制直线的位置。
- xmin 和 xmax: 指定行的开始和结束范围。
- 颜色:指定线条的颜色。
- 线条样式:指定线条的样式。
axh line()方法示例:
**# Import Library**
import matplotlib.pyplot as plt
**# Plot horizontal line**
plt.axhline(y=1.5, xmin=0.1, xmax= 0.8)
**# Show**
plt.show()
这里我们用 axhline() 的方法画一条水平线，并将 y 、 xmin 、 xmax 作为参数，分别设置其值为 1.5 、 0.1 、 0.8 。
plt.axhline()
阅读: Matplotlib 绘制一条线
虚线水平线 matplotlib
这里我们要学习如何用 python 在 matplotlib 中画水平虚线。我们必须改变线条的线条样式，使它们在风格上有点点。
Matplotlib.pyplot 库提供了参数 linestyle 来设置线条的类型。
让我们来看一个水平虚线的例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Plot horizontal dotted line**
plt.axhline(y=5, xmin=0.25, color='red', linestyle='dotted', linewidth=5)
**# Show**
plt.show()
- 这里我们用
axhline()方法画一条水平虚线。我们通过参数y、 xmin、 - 我们的主要目标是绘制一条本质上是虚线的水平线，因此我们将线型设置为虚线，并通过使用线宽参数来增加线条的宽度。
” Dotted horizontal line “
阅读: Python 使用 Matplotlib 绘制多条线
带标签的水平线 matplotlib】
在这一节，我们将学习如何用标签画一条水平线。这里我们使用 axhline() 方法画一条水平线，并将标签作为参数传递。
带标签画水平线的语法:
matplotlib.pyplot.axhline(y, xmin, xmax, color, label)
举例:
**# Import Library**
import matplotlib.pyplot as plt
**# Plot horizontal line**
plt.axhline(y=10, linewidth=5, label= 'horizontal-line')
**# Add label**
plt.legend(loc = 'upper left')
**# Show**
plt.show()
- 通过使用
plt.axhline()方法我们画一条水平线并传递参数标签。 - 然后通过使用
plt.legend()方法我们将标签的位置设置为左上角的。
**
” Horizontal line with label “
多条水平线 matplotlib
这里我们要用 python 在 matplotlib 中绘制多条水平线。绘制多条水平线的方法有:
- 使用 axhline()
- 使用 hlines()
通过使用 axhline()
在 matplotlib 中，通过使用 axhline() 方法，我们可以在绘图中绘制多条水平线。
我们来看一个与此相关的例子:
**# Import library**
import matplotlib.pyplot as plt
**# Horizontal line 1**
plt.axhline (y = 10, color = 'b')
**# Horizontal line 2
# We also set range of the line**
plt.axhline (y = 6, xmin =0.1, xmax =0.5, color='red')
**# Horizontal line 3**
plt.axhline (y = 2, color = 'm')
**# Horizontal line 4
# We also set range of the line**
plt.axhline (y = 4, xmin =0.6, xmax =0.8, color='c')
**# Display**
plt.show()
plt.axhline()
使用 hline()
在 matplotlib 中，通过使用 hlines() 方法，我们可以在绘图中绘制多条水平线。
举例:
**# Import library**
import matplotlib.pyplot as plt
**# Horizontal line 1**
plt.hlines (y= 2, xmin= 0.1, xmax= 0.5, color='c', linewidth = 2 )
**# Horizontal line 2**
plt.hlines (y= 6, xmin = 0.4, xmax = 0.9, color='m', linestyle = 'dotted', linewidth = 3)
**# Horizontal line 3**
plt.hlines (y = 8, xmin = 0.5, xmax = 0.9, color='orange', linestyle = 'dashed', linewidth = 5)
**# Horizontal line 4**
plt.hlines (y = 10, xmin =0.6, xmax =0.8, color='red', linewidth = 8 )
**# Display**
plt.show()
plt.hlines()
另外，请阅读: Matplotlib 绘图条形图
Matplotlib 水平线粗细
在 matplotlib 中，要调整水平线的粗细，我们必须传递参数 linewidth 。通过使用线宽作为参数，我们可以很容易地增加或减少线条的宽度或厚度。
调整厚度的语法如下:
matplotlib.pyplot.axhine(y, xmin, xmax, linewidth )
让我们看一个调整水平线粗细的例子:
**# Import library**
import matplotlib.pyplot as plt
**# Thickness increased**
plt.axhline (y = 5, color = 'red', linewidth = 8)
**# Thickness decreased**
plt.axhline (y = 2, linewidth = 0.5)
**# Display**
plt.show()
- 在上面的例子中，我们使用
plt.axhline()方法绘制一条水平线。 - 这里我们将线宽作为参数传递，在不同情况下将其值设置为
8和0.5。
plt.axhline(linewidth = )
读取: Matplotlib 绘图误差线
Matplotlib 水平线颜色
在 matplotlib 中，要改变水平线的颜色，我们必须将参数 color 传递给方法 axhilne() 或 hlines() 。默认情况下，线条的颜色是蓝色。
改变线条颜色的语法如下:
**# Using axhline()**
matplotlib.pyplot.axhline(y, color= None)
**# Using hlines()**
matplotlib.pyployt,hlines(y, xmin, xmax, color= None)
让我们看一个与水平线颜色变化相关的例子:
**# Import library**
import matplotlib.pyplot as plt
**# Change color by using hlines()**
plt.hlines (y = 8, xmin = 0.5, xmax = 0.9, color='orange', linestyle = 'dashed', linewidth = 5)
**# OR**
**# Change color by using axhline()**
plt.axhline (y = 10, xmin =0.6, xmax =0.8, color='red', linewidth = 8 )
**# Display**
plt.show()
- 在上面的例子中，我们使用
plt.hlines()方法，并将颜色作为参数传递，并将其值设置为橙色。 - 在下一个案例中，我们使用
plt.axhline()方法绘制一条水平线，这里我们将颜色作为参数来更改线条的颜色，并将其值设置为红色。
plt.hlines (color = None)
plt.axhline(color = None)
Matplotlib 水平线在数值
在这里，我们将学习如何在绘制的图表上的特定值处绘制一条水平线。
我们来看一个例子:
**# Import Library**
import matplotlib.pyplot as plt
import numpy as np
**# Define Data**
x = np.arange(0,25, 0.1)
y = np.sin(x)
**# Plot figure**
plt.plot(x, y)
**# Horizontal line**
plt.axhline(y= -0.5,color='red', linestyle ='dashed')
**# Title**
plt.title("Sine Function", fontsize= 15, fontweight='bold')
**# Generate Plot**
plt.show()
- 在上面的例子中，我们导入了
matplotlib和numpy库。 - 在此之后，我们使用
np.arange()方法和np.sin()方法定义数据来绘制图形。 - 通过使用
plt.plot()方法，我们绘制了一个正弦图。 - 然后在特定值处画一条水平线，我们使用
plt.axhline()方法并传递参数y = -0.5。 plt.title方法用于在情节上添加标题，plt.show()方法用于情节可视化。
” Horizontal line at value “
Matplotlib 水平线在 0 处
在 matplotlib 中，要在 0 处画一条水平线，我们必须将 y 坐标的值设置为 0。
在 0 处画水平线的语法:
**# By using axhline**
matplotlib.pyplot.axhline(y = 0)
# `By using hlines` matplotlib.pyplot.lines(y=0, xmin, xmax)
示例(通过使用 hlines() ) :
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data**
x = [1, 2, 3.5, 4, 5, 6.5]
y = [0, 2, 4, 15, 8, 10]
**# Plot figure**
plt.plot(x, y)
**# Horizontal line at 0**
plt.hlines(y= 0, xmin= 1.5, xmax= 5.5, color='red', linestyle ='dashed', linewidth = 5)
**# Generate Plot**
plt.show()
- 这里我们使用
hlines()方法，将y、xmin、xmax、color、linestyle和linewidth作为参数进行传递。 - 我们分别将它们的值设置为
0、1.5、5.5、虚线和5。
” Horizontal line at 0 “
水平线 matplotlib 子图
这里我们将讨论如果我们在图形区域中绘制支线剧情，如何在特定支线剧情中绘制水平线。
我们将使用 axhline() 方法在特定支线剧情处画一条水平线。
让我们借助一个例子来理解这个概念:
**# Importing Libraries**
import numpy as np
import matplotlib.pyplot as plt
**# Define Data**
x1= [0.2, 0.4, 0.6, 0.8, 1]
y1= [0.3, 0.6, 0.8, 0.9, 1.5]
x2= [2, 6, 7, 9, 10]
y2= [3, 4, 6, 9, 12]
x3= [5, 8, 12]
y3= [3, 6, 9]
x4= [7, 8, 15]
y4= [6, 12, 18]
fig, ax = plt.subplots(2, 2)
**# Plot graph
# Set horizontal line at specfic subplot**
ax[0, 0].plot(x1, y1)
ax[0, 1].axhline(y=4)
ax[1, 0].plot(x3, y3)
ax[1, 1].axhline(y=2.5)
**# Display Graph**
fig.tight_layout()
plt.show()
- 在上面的例子中，我们在一个图形区域中绘制了多个图。而我们要在具体的地块画一条水平线。
- 这里我们用
axhline()的方法画一条水平线。
ax.axhline()
阅读: Matplotlib 散点图标记
Matplotlib 水平线全宽
在 matplotlib 中，如果你想画一条全宽的水平线，只需使用 axhline() 方法。
您也可以使用 hlines() 方法来绘制全角水平线，但是在这个方法中，您必须将 xmin 和 xmax 设置为全角。
举例:
**# Import Library** import matplotlib.pyplot as plt
**# Plot vertical line**
plt.axhline(y=1.5)
**# Show**
plt.show()
在上面的例子中，我们使用 axhline() 方法绘制一条全幅的水平线。
plt.axhline()
阅读: Matplotlib 虚线
Matplotlib 误差线水平线
为了在误差栏上画一条水平线，我们必须在 ax.errorbar() 中传递一个参数 xerr 。
误差线水平线的语法如下:
matplotlib.pyplot.errorbar(x, y, yerr, capsize)
上述使用的参数如下:
- x: 指定水平坐标。
- y: 指定垂直坐标。
- xerr: 定义水平误差线尺寸。
为了更好地理解，我们来看一个例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data**
x= [1, 2, 3, 5]
y= [9, 15, 5, 25]
**# Plot horizontal error bar**
plt.errorbar(x, y, xerr = 1.2)
**# Display graph**
plt.show()
- 在上面的例子中，我们导入了
matplotlib.pyplot库。 - 然后我们定义 x 轴和 y 轴数据点。
plt.errorbar()方法用于绘制误差线，我们传递参数 x，y，和xerr，并设置 xerr =1.2的值。- 然后我们使用
plt.show()方法显示误差棒图。
plt.errorbar(xerr= )
读取: Matplotlib 日志日志图
水平网格线 matplotlib
在 matplotlib 中， grid() 方法用于创建网格线。
创建水平网格线的语法:
matplotlib.axis.YAxis.grid()
此方法仅用于绘制水平线。
我们来看一个例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Current axes**
axes = plt.gca()
**# Horizontal grid lines**
axes.yaxis.grid()
**# Display**
plt.show()
这里我们使用 plt.gca() 方法获取图形的当前轴，使用 axes.yaxis.grid() 方法绘制水平网格线。
axes.yaxis.grid()
阅读: Matplotlib 最佳拟合线
带文本的 Matplotlib 水平线
要在水平行上添加文本，我们必须使用 text() 方法。
语法如下:
**# Horizontal line**
matplotlib.pyplot.axhline(y)
**# Text**
matplotlib.pyplot.text(x,y,text)
让我们看一个带有文本的水平线的例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Plot horizontal line**
plt.axhline(y=1.5)
**# Add text**
plt.text(0.4,1.51,'Horizontal Line',rotation=360)
**# Show**
plt.show()
” Horizontal line with text “
标注水平线 matplotlib
在 matplotlib 中， annotate() 方法用于用文本标注点。
annotate() 方法的工作原理与 text() 方法相同，但是 annotate() 方法有更多的特性。就像你可以添加箭头来突出某些东西。
annotate 函数的语法如下:
matplotlib.pyplot.annotate(s, xy, xytext, arrowprops ....)
使用的参数描述如下:
- s: 用于标注的文本。
- xy: 指定要标注的点(x，y)。
- xytext: 指定放置文本的位置(x，y)。
- arrowprops: 包含 dict 类型。
我们来看一个例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Plot Horizontal line**
plt.axhline(y=1.47)
**# Annotate**
plt.annotate('Horizontal Line',
xy = (0.4,1.48),
xytext =(0.6,1.52),
color='red',
fontweight='bold',
fontsize = 15,
arrowprops = dict(facecolor = 'yellow'))
**# Show**
plt.show()
这里我们使用 plt.annotate() 方法，并传递 text 、 xy 、 xytext 、 color 、 fontweight 、 fontsize 和 arrowprops 作为参数。
” Annotate horizontal line “
Matplotlib 删除水平线
在 matplotlib 中，我们可以很容易地删除使用 plt.plot() 方法绘制的水平线。
remove() 方法用于删除水平线。
举例:
**# Import Library**
import matplotlib.pyplot as plt
**# Define Data**
x = [2, 4, 6, 8]
y = [0, 0, 0, 0]
y1 = [2, 2, 2, 2]
y2 = [3, 3, 3, 3]
**# Plot Horizontal lines**
line_1 = plt.plot(x,y)
line_2 = plt.plot(x,y1)
line_3 = plt.plot(x,y2)
**# Remove horizontal line**
r = line_2.pop(0)
r.remove()
**# Show**
plt.show()
” Plot before removal of the horizontal line “
” Plot after removal of the horizontal line “
这里我们使用 remove() 方法删除水平线 2。
Matplotlib 向条形图添加水平线
如果你想在 matplotlib 中创建一个横线条形图，你必须知道如何创建一个条形图。让我们看看创建条形图的语法。
matplotlib.pyplot.bar(x, height)
让我们看一个在条形图上画一条水平线的例子:
**# Import Library**
import matplotlib.pyplot as plt
**# Define data**
x =[2, 4, 8, 5, 6]
y = [8, 16, 15, 2, 4]
**# Creating the bar plot**
plt.bar(x, y, color ='maroon')
**# Horizontal Line**
plt.axhline(y=9.5,linewidth= 3, color='k', linestyle= 'dotted')
**# Display**
plt.show()
- 在上面的例子中，我们导入
matplotlib.pyplot库进行数据可视化。 - 接下来我们定义数据，并通过使用
plt.bar()方法绘制条形图。 plt.axhline()方法在y=9.5处的条形图上画水平线。
” Horizontal line on bar chart “
在本 Python 教程中，我们已经讨论了"水平线 matplotlib" ，并且我们也涵盖了一些与之相关的例子。这些是我们在本教程中讨论过的以下主题。
- 水平线 matplotlib
- 虚线水平线 matplotlib
- 带标签的水平线 matplotlib
- 多水平线 matplotlib
- Matplotlib 水平线粗细
- Matplotlib 水平线颜色
- Matplotlib 水平线在数值处
- Matplotlib 水平线位于 0
- 水平线 matplotlib 子图
- Matplotlib 水平线全宽
- Matplotlib 误差线水平线
- 水平网格线 matplotlib
- 带文本的 Matplotlib 水平线
- 注释水平线 matplotlib
- Matplotlib 删除水平线
- Matplotlib 向条形图添加水平线
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何在 Python 中将字典转换成字符串
原文：https://pythonguides.com/how-to-convert-a-dictionary-into-a-string-in-python/
在本 Python 教程中，我们将学习如何将 Python 字典转换成字符串。为了理解各种方法，我们将使用一些内置函数将 Python 字典转换为字符串。
作为一名开发人员，在制作 Python 项目时，我需要将 Python 字典转换成字符串。
在这里我们将看到:
- 如何在 Python 中使用 str()将字典转换成字符串
- 如何使用 json.dumps()在 Python 中将字典转换成字符串
- 如何在 Python 中使用 items()和 str.join()将字典转换为字符串
- 如何使用常规方法在 Python 中将字典转换成字符串
目录
- 用 Python 把字典转换成字符串
- 如何在 Python 中使用 str() 将字典转换成字符串
- 如何使用 json.dumps() 在 Python 中将字典转换成字符串
- 如何在 Python 中使用 items()和 str.join() 将字典转换成字符串
- 如何使用传统方式将 Python 中的字典转换成字符串
用 Python 把字典转换成字符串
在 Python 中，有许多方法可以将字典转换成字符串。我们将详细介绍如何使用 str() 方法和 json.dumps() 方法将字典转换成 Python 中的字符串。
如何在 Python 中使用 str() 将字典转换成字符串
- 在本节中，我们将讨论如何使用
str()在 Python 中将字典转换成字符串。 - dictionary 对象将以这种字典到字符串的转换方式简单地传递给
str()函数。 - Python 的 str 函数返回所提供对象或整数的字符串变量。如果没有提供参数，该方法将返回一个空字符串。
举例:
我们举个例子，检查一下如何在 Python 中使用 str() 将字典转换成字符串。
源代码:
# Create a Python dictionary
Country_name = {'U.S.A': 8965, 'Germany': 4562, 'China': 9234, 'Australia': 8562}
print("Input dictionary :",Country_name )
print(type(Country_name))
# By using the str() function
new_result = str(Country_name)
print("Converted dictionary into string :",new_result)
print(type(new_result))
在下面给出的代码中，我们将首先创建一个字典，然后使用 type() 函数来检查对象。接下来，我们使用了 str() 函数，在这个函数中，我们将输入字典作为参数传递。
下面是下面给出的代码的截图。
Converting a dictionary into a string in Python using str
这是如何在 Python 中使用 str 将字典转换成字符串。
如何使用 json.dumps() 在 Python 中将字典转换成字符串
- 这里我们将讨论如何使用
json.dump()在 Python 中将字典转换成字符串。 json.dump()方法使我们能够将一个 Python 对象转换成一个等效的 json 对象，并将结果保存为一个文件。- 使用
json.dumps()方法将 Python 字典转换成字符串，而json.loads()技术以完全相反的方式工作。
举例:
我们举个例子，检查一下如何使用 json.dump() 在 Python 中将字典转换成字符串。
源代码:
import json
Cars_in_USA = {'BMW': 7345,'Harley Davidson':4352}
new_val = json.dumps(Cars_in_USA )
print("Converted dictionary into string :",new_val )
print(type(new_val))
在上面的代码中，我们首先导入 JSON 模块，然后创建名为“Cars _ in _ USA”的输入字典。接下来，我们使用了 json.dumps() 函数，它将把字典转换成一个字符串。
你可以参考下面的截图。
Converting a dictionary into a string in Python using json.dumps_
正如你在截图中看到的，我们已经讨论了如何使用 json.dumps() 在 Python 中将字典转换成字符串。
如何在 Python 中使用 items()和 str.join() 将字典转换成字符串
- 现在让我们了解如何使用
items()和str.join()在 Python 中将字典转换成字符串。 - 使用 for 循环，我们将遍历 dictionary 对象，并以将 dictionary 转换为 string 的方式添加键及其值。然后使用
str.join()函数将键:值对组合成一个字符串。
举例:
这里我们将举一个例子，检查如何使用 items() 和 str.join() 在 Python 中将字典转换成字符串。
源代码:
# Input Dictionary
Cities_in_USA = {'NewYork': '7862', 'LosAngeles': '4253', 'Chicago': '2987'}
print("Input dictionary :", Cities_in_USA)
# By using the str.join() and items() function
new_result = ', '.join(key + value for key, value in Cities_in_USA.items())
print(new_result)
print(type(new_result))
下面是以下给定代码的执行。
Converting a dictionary into a string in Python using items and str.join()
在这个例子中，我们已经理解了如何在 Python 中使用项和 str.join() 将字典转换成字符串。
如何使用传统方式将 Python 中的字典转换成字符串
- 在这一节中，我们将讨论如何使用传统的方法在 Python 中将字典转换成字符串。
- 在 Python 中，除了利用内置函数之外，我们还可以通过使用传统的过程将 dict 转换为字符串。传统的方法是通过使用 for 循环遍历字典来连接新创建的字符串。
- 在这个例子中，我们将首先使用两个主要操作，我们将使用 for 循环遍历字典，然后连接字符串。
举例:
让我们举一个例子，并检查如何使用常规方法在 Python 中将字典转换为字符串。
源代码:
cars_in_USA = {"Volkswagen": "8927", "Audi": "5632", "BMW": "1782"}
print("Input Dictionary: ", cars_in_USA)
# Empty string
new_convt = str()
# iterating over dictionary using a for loop
for new_key in cars_in_USA:
new_convt += new_key + ": " + cars_in_USA[new_key] + ", "
print("Output string: " + new_convt + " type: ", type(new_convt))
下面是以下给定代码的执行。
Converting a dictionary into a string in Python using a conventional way
您可能也喜欢阅读以下 Python 教程。
在本文中，我们学习了如何将 Python 字典转换成字符串。我们还讨论了以下主题。
- 如何在 Python 中使用 str()将字典转换成字符串
- 如何使用 json.dumps()在 Python 中将字典转换成字符串
- 如何在 Python 中使用 items()和 str.join()将字典转换为字符串
- 如何使用常规方法在 Python 中将字典转换成字符串
Arvind 目前是 TSInfo Technologies 的高级 Python 开发人员。他精通 Python 库，如 NumPy 和 Tensorflow。
如何将字典转换为张量张量流
原文：https://pythonguides.com/how-to-convert-dictionary-to-tensor-tensorflow/
本教程将说明如何使用 Python 将字典转换为张量张量流。我们还会看一些例子，看看如何在 TensorFlow 中使用 tf.convert_to_tensor() 函数。我们将讨论这些话题。
- 如何将字典转换为张量张量流
- 如何将数组转换为张量 Pytorch
- 如何将张量转换为浮点张量流
- 如何将图像转换为张量张量流
- 张量流空张量
目录
如何将字典转换成张量张量流
- 本节将讨论如何将字典转换为张量 TensorFlow 。
- 为了完成这项任务，我们将使用 for-loop 方法，在本例中，我们首先初始化一个字典，并以键值对元素的形式分配一个元素。
- 接下来，我们要将给定的字典转换成张量，为此，我们将使用 for 循环并设置条件，如果 n > m，那么它将存储在结果中。
举例:
我们举个例子，检查一下如何在 Python TensorFlow 中把字典转换成张量。
源代码:
City_name_USA = {'New York': {'3': 17, '2': 17, '2': 18},
'Los Angeles': {'3': 45, '1': 78, '2': 78}}
num = 0
for m, new_val in City_name_USA.items():
for n in new_val.keys():
if int(n) > int(num):
num = int(n)
result = []
for new_val in City_name_USA.values():
lst = [0] * (num+1)
for n, val2 in sorted(new_val.items()):
lst[int(n)] = val2
result.append(lst)
print(result)
你可以参考下面的截图。
Convert dictionary to tensor tensorflow
这就是如何在 Python TensorFlow 中把字典转换成张量。
如何将数组转换为张量 Pytorch
- 这里我们将讨论如何在 Python 中将数组转换成 Pytorch 张量。
- 类似于
numpy.ndarray是 PyTorch 张量。这两者的区别在于张量利用 GPU 来加速涉及数字的计算。 - 用于将
numpy.ndarray转换为 PyTorch 张量()。而numpy()方法将张量转换为*numpy . ndarray*。 - 首先，我们需要 torch 和 Numpy 库，然后使用
*torch . from _ Numpy()*将数组转换为 Pytorch 张量。
*语法:
让我们看看语法并理解一个*torch . from _ numpy()*函数的工作原理。
torch.from_numpy(ndarray)
注意:这个函数只有一个参数 ndarray，它指定了我们要用张量转换的输入数组。
示例:
import torch
import numpy as np
Population_in_USA = np.array([13,45,7,78,90])
# Convert Numpy array to torch.Tensor
result = torch.from_numpy(Population_in_USA)
print(result)
在下面给出的代码中，我们使用 np.array() 函数创建了一个数组，在这个函数中，我们将整数值作为一个参数进行赋值。接下来，我们将使用*torch . from _ numpy()*函数，在这个函数中，我们将字典指定为一个参数。
下面是以下给定代码的实现。
Convert array to tensor Pytorch
正如你在截图中看到的，我们将 NumPy 数组转换成 Pytorch 张量。
阅读:模块“tensorflow”没有属性“sparse _ placeholder”
如何将张量转换为浮点张量流
- 本节将讨论如何在 Python 中将 tensorflow 张量转换为 float。
- 为了执行这项任务，我们将使用
tf.cast()函数。该函数用于将给定的输入张量转换为新的数据类型。该函数采用两个主要参数，即正在转换的输入张量。
语法:
下面是 Python TensorFlow 中 tf.cast() 函数的语法
tf.cast(
x, dtype, name=None
)
- 它由几个参数组成
x:该参数定义输入张量和数值型张量、稀疏张量或索引切片。可能是int8、int16、int32、int64、float16、float32、float64、complex64、complex128或bfloat16。它也可能是一个 uint8、int8、int16、int32 或 int64 。dtype:该参数指定输入张量的数据类型。name:默认情况下，取 none 值，指定操作的名称。
举例:
import tensorflow as tf
input_tens = tf.constant([23,45,67,8])
result=tf.cast(input_tens, tf.float32)
print(result)
在上面的代码中，我们使用了 tf.constant() 函数来创建输入张量。然后我们使用 tf.cast() 将整数数据类型转换为浮点数据类型。
下面是以下给定代码的实现。
Convert tensor to float tensorflow
这就是如何使用 TensorFlow 将输入张量转换为浮点值。
如何将图像转换为张量张量流
- 在本节中，我们将讨论如何将图像转换为张量，以及图像张量的典型轴顺序。
- 该图像必须是 PIL 图像或数字图像。ndarray (HxWxC)在[0，255]范围内。这里，H、W 和 C 代表图像的高度、宽度和通道数。
- 在给定的例子中，h 是高度，w 是宽度图像，c 是通道图像。
举例:
import tensorflow as tf
image = tf.io.read_file("tiger.png")
input_tensor = tf.io.decode_image(image, channels=3, dtype=tf.dtypes.float32)
tensor = tf.image.resize(input_tensor, [224, 224])
result = tf.expand_dims(tensor, axis=0)
print(result)
下面是以下给定代码的执行。
Convert image to tensor tensorflow
在这个例子中，我们已经将图像转换为张量。
阅读:模块“tensorflow”没有属性“truncated _ normal”
TensorFlow 空张量
- 让我们讨论一下如何在 Python TensorFlow 中创建一个空张量。
- 为了执行这个任务，我们将使用
TF . experimental . numpy . empty()函数，这个函数改变空值。
语法:
下面是 Python TensorFlow 中TF . experimental . numpy . empty()函数的语法
tf.experimental.numpy.empty(
shape, dtype=float
)
- 它由几个参数组成
- 形状:该参数定义了空张量的形状。
- dtype: 默认情况下，它取浮点值，指定输入张量的数据类型。
举例:
import tensorflow as tf
result= tf.experimental.numpy.empty(shape=(2,2),dtype=float)
print(result)
下面是以下代码的截图
TensorFlow empty tensor
还有，多看看一些 Python TensorFlow 教程。
在本教程中，我们已经了解了如何使用 Python TensorFlow 将字典转换为张量。我们还会看一些例子，看看如何在 TensorFlow 中使用 tf.convert_to_tensor() 函数。我们将讨论这些话题。
- 将字典转换为张量张量流
- 将数组转换为张量 Pytorch
- 将张量转换为浮点张量流
- 将图像转换为张量张量流
- 张量流空张量
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何将熊猫数据帧转换成字典
原文：https://pythonguides.com/how-to-convert-pandas-dataframe-to-a-dictionary/
在这个 Python 教程中，我们将学习如何将 Pandas DataFrame 转换成 Python 中的字典。此外，我们将涵盖这些主题。
- 将熊猫数据帧转换为字典
- 将 Pandas 数据帧转换为不带索引的字典
- 将熊猫数据帧转换为字典列表
- 将熊猫数据帧转换为嵌套字典
- 将熊猫系列转换为字典
- 将熊猫列转换为词典
- Python Pandas 将数据帧转换为具有多个值的字典。
- 将 Pandas 数据帧转换为以一列为键的字典
- 将熊猫行转换为字典
我们已经用 Kaggle 上的美国房屋销售预测数据集展示了例子。
目录
- 将熊猫数据帧转换成字典
- 将熊猫数据帧转换成不带索引的字典
- 将熊猫数据帧转换为字典列表
- 将熊猫数据帧转换为嵌套字典
- 将熊猫系列转换成字典
- 将熊猫列转换为字典
- Python 熊猫将数据帧转换成具有多个值的字典。
- 将熊猫数据帧转换为字典，其中一列为关键字
- 将熊猫行转换成字典
将熊猫数据帧转换成字典
在这一节中，我们将学习如何用 Python 将熊猫数据帧转换成字典。
- DataFrame 是表格形式的数据表示，即行和列。
- 字典是键值对。每个键都是唯一的，值可以是任何数据类型。
- 字典的另一个名字是字典，所以如果你正在寻找如何将熊猫数据帧转换成字典。然后，您可以遵循本节中介绍的解决方案。
- 在 Python Pandas 中使用
*data frame . to _ dict()*我们可以将数据帧转换成字典。2 - 在我们的例子中，我们使用了从 kaggle 下载的美国房屋销售预测数据集。
- 在这段代码中，我们只将数据帧的前 5 行转换为字典。
- 所有的数据都被转换成键值对，它们的数据类型现在是 dictionary。
如何将 Python 数据帧转换成 JSON
原文：https://pythonguides.com/how-to-convert-python-dataframe-to-json/
在本 Python 教程中，我们将学习如何将 Python 数据帧转换为 JSON 文件。此外，我们将涵盖这些主题。
- Python 数据帧到 JSON
- Python 数据帧到 JSON 对象
- Python 数据帧到不带索引的 JSON
- Python 数据帧到 JSON 数组
- Python 数据帧到 JSON 字符串
- Python 数据帧到 JSON 格式
- Python 数据帧到 JSON 列表
- Python 数据帧 to_json Orient
- 带索引的 JSON 的 Python 数据帧
目录
- Python 数据帧到 JSON
- Python 数据帧到 JSON 对象
- Python 数据帧到不带索引的 JSON】
- Python 数据帧到 JSON 数组
- Python 数据帧到 JSON 字符串
- Python 数据帧到 JSON 格式
- Python 数据帧到 JSON 列表
- Python data frame to _ JSON Orient
- Python 数据帧到索引为的 JSON
Python 数据帧到 JSON
在这一节中，我们将学习如何将 Python 数据帧转换成 JSON 文件。熊猫数据帧可以使用 dataframe.to_json() 方法转换成 JSON 文件。
DataFrame.to_json(
path_or_buf=None,
orient=None,
date_format=None,
double_precision=10,
force_ascii=True,
date_unit='ms',
default_handler=None,
lines=False,
compression='infer',
index=True,
indent=None,
storage_options=None
)
Python Pandas 中 dataframe.to_json()方法的参数
| 参数 | 描述 |
|---|---|
| 路径缓冲区 | 提供要保存文件的文件路径和文件名。 |
| 东方 | –它接受一个字符串，您可以从给定的选项 |
| 中选择–对于系列，有 4 个选项是 | |
| –在这些选项中，“index”是默认值。 | |
| –对于 DataFrame，选项有 6 个选项 | |
| –在这些选项中，“columns”是默认选项。 | |
| 日期格式 | 日期转换的类型。可用选项有 |
| –纪元' =纪元毫秒，' iso' = ISO8601。 | |
| –默认取决于方向。 | |
| –对于 orient='table '，默认为' iso '。 | |
| –对于所有其他方向，默认为“纪元”。 | |
| 双精度 | 接受 int，默认值为 10。对浮点值进行编码时使用的小数位数。 |
| force_ascii | 接受布尔值，默认值为 True。强制编码字符串为 ASCII。 |
| 日期单位 | –默认值为“ms”(毫秒) |
| –编码的时间单位决定时间戳和 ISO8601 精度。分别代表秒、毫秒、微秒和纳秒的' s '、' ms '、' us '、' ns '之一。 | |
| 默认处理程序 | –默认值为 None |
| –如果对象无法转换为适合 JSON 的格式时要调用的处理程序。应该接收一个参数，该参数是要转换的对象，并返回一个可序列化的对象。 | |
| 线 | –接受布尔值，默认为 False |
| –如果‘orient’是‘records ’,则写出行分隔的 JSON 格式。–如果不正确的“orient ”,它将抛出 ValueError，因为其他的不像列表。 | |
| 压缩 | –可用选项有 |
| –表示要在输出文件中使用的压缩的字符串，仅在第一个参数是文件名时使用。默认情况下，压缩是从文件名推断出来的。 | |
| 指数 | –接受布尔值，默认值为 True |
| –如果不想在 JSON 字符串中包含索引值，请设置 index=False。 | |
| –请注意，仅当 orient 为“分割”或“表格”时，才支持 index=False | |
| 缩进 | –接受整数值 |
| –用于缩进每条记录的空白长度。 | |
| 存储选项 | –接受字典 |
| –该选项用于存储主机、端口、用户名、密码等的连接。 | |
| –该选项主要用于 AWS S3 等云服务提供商。键值对被转发给 sffpec。 |
Parameters of df.to_json() method
- 在我们在 Jupyter Notebook 上的实现中，我们演示了必要参数的使用。
- 虽然我们已经展示了几乎所有参数的用法，但只有
path_or_buf和orient是必需的，其余都是可选的。 - 这是 Jupyter 笔记本上的实现，请阅读行内注释以理解每个步骤。
如何创建空的 Python 字典
原文：https://pythonguides.com/how-to-create-an-empty-python-dictionary/
在本 Python 教程中，我们将讨论如何创建一个空的 Python 字典,这里我们还将介绍下面的例子:
- 如何用 Python 创建一个带键的空字典
- 如何创建空嵌套字典 Python
- 如何检查 Python 字典是否为空
目录
如何创建一个空的 Python 字典
- 在 Python 中创建一个空字典，我们可以在花括号 {}中不赋任何元素。
- 我们也可以通过使用
dict()方法创建一个空字典，这是 Python 中的一个内置函数，没有参数。
举例:
让我们举一个例子，看看如何用 Python 创建一个空字典
my_new_dict = {}
print("Created empty dictionary:",my_new_dict)
print(type(my_new_dict))
所以，用上面的代码，我们创建了一个空字典，它是‘my _ new _ dict’，它等于花括号{}。现在，如果您想在输出中看到一个空字典，那么您必须使用 print 语句。它将显示一个空字典和字典类型。
下面是以下给定代码的输出。
How to create an empty Python dictionary
另一个使用 dict() 内置函数创建空字典的例子
在 Python 中，空字典意味着它不包含键值对元素。在这个例子中，为了创建一个空字典，我们可以使用一个 dict 构造函数，这个方法没有参数。如果没有传递参数，那么它将创建一个空字典。
源代码:
emp_num = dict()
print("Empty dictionary:",emp_num)
print(type(emp_num))
How to create an empty Python dictionary dict method
这就是如何用 Python 创建一个空字典。
阅读: Python 字典转 CSV
如何用 Python 创建一个空字典，带键
在 Python 中创建一个带键的空字典，我们可以使用组合 zip()和 len() 的方法。该方法将初始化一个键字典，并且在字典中不返回任何值。
源代码:
new_key_lis = [18,23,45]
b= dict([(23,18)])
c = dict(zip(new_key_lis, [None]*len(new_key_lis)))
print(c)
下面是以下给定代码的实现
How to create an empty dictionary in Python with Keys
阅读: Python 将字典转换为数组
如何创建空的嵌套字典
- 这里我们可以看到如何用 Python 创建一个空的嵌套字典。
- 在这个例子中，我们使用了
dict()方法的概念来创建一个空的嵌套字典。dict()方法是 Python 中的内置函数，它没有参数。
举例:
new_dict = { '': { },
'': { }}
print("Empty Nested dictionary:",new_dict)
下面是以下给定代码的执行过程
How to create an empty nested dictionary
如何检查 Python 字典是否为空
- 为了检查 Python 字典是否为空，我们可以使用 if 条件。它将检查字典中是否包含元素。如果字典为空，if 条件将返回 true，否则将返回 false。
- 有各种方法来解决这个任务
- 通过使用 if 条件
- 通过使用 not 运算符
- 通过使用 bool(dict)方法
- 通过使用 len()方法
通过使用 if 条件
在 Python 中， 'if' 条件验证字典是否包含元素。所以在下面的代码中，我们将检查条件。
源代码:
my_dictionary = {18:"h",19:"a",25:"o"}
new_dictionary = {}
if my_dictionary:
print("my_dictionary is not empty")
else:
print("my_dictionary is empty")
if new_dictionary:
print("new_dictionary is not empty")
else:
print("new_dictionary is empty")
首先在上面的代码中，我们将初始化两个字典。第一个字典包含键值对，第二个字典创建一个空字典。现在使用 if 条件并检查哪个字典是空的。为此，我们使用了 if-else 条件，如果字典包含一个元素，那么它将显示字典不为空。
下面是以下代码的截图
How to check if Python dictionary is empty
阅读: Python 元组字典
通过使用 not 运算符
在 Python 中，要在字典中应用 not 操作符，我们将首先初始化一个空字典，并使用‘not’操作符来检查字典是否为空。
举例:
让我们举一个例子，检查 Python 字典是否为空
my_emp_dict = {}
new_out = not my_emp_dict
print("Dictionary is epty or not?:",new_out)
输出:
How to check if Python dictionary is empty by using not operator
通过使用 bool()字典方法
为了检查字典是否不为空，它将使用 bool() 方法返回 true。此方法用于返回一个布尔值，这意味着它将在输出中显示 True 或 False，并且它只接受一个参数。
源代码:
my_new_dict = {}
emp_val = bool(my_new_dict)
print(emp_val)
下面是以下给定代码的执行过程
how to check if Python dictionary is empty by using bool method
通过使用 len()方法
Python 中检查字典是否为空的另一种方法是使用 len() 方法。
源代码:
you_dictionary = {}
new_emp_dict = len(you_dictionary)
if new_emp_dict == 0:
print ("Empty dictionary")
else:
print ("Dictionary is not empty")
首先在上面的代码中，我们将初始化一个空字典‘you _ dictionary’。之后，我们使用 len() 函数计算字典的长度并包含在变量 'new_emp_dict' 中，使用 if 语句条件检查字典是否为空。
下面是以下给定代码的实现
How to check if Python dictionary is empty by using len method
你可能也喜欢阅读下面的教程。
在本 Python 教程中，我们已经讨论了如何创建一个空的 Python 字典，这里我们还讨论了以下主题:
- 如何用 Python 创建一个带键的空字典
- 如何创建空嵌套字典 Python
- 如何检查 Python 字典是否为空
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何从 Python Django 中删除模式
原文：https://pythonguides.com/how-to-delete-schema-from-python-django/
在这个 Python Django 教程中，我将一步一步解释如何从 Python Django 中删除模式。
最近，我一直在做一个 Django e-cart 项目，我错误地构建了一个部门模式。所以现在，我决定从您的 Django 项目中删除这个模式。
在这里我们将看到:
- 什么是图式
- 不同类型的模式
- 如何从 Python Django 项目中删除模式
我发现解决方案简单明了，我们将完全删除模型的模式，或者我们可以说我们从您的 Django 项目中删除了模型。
目录
如何从 Python Django 中删除模式
什么是模式
在我们开始学习从 Django 项目数据库中删除模式的过程之前。我们需要对这个计划有一点了解。
数据库模式的框架结构是整个数据库的逻辑表示。它概述了数据的结构和连接它们的关系。
它描述了可以用模式图来说明的数据库。数据库设计人员创建模式是为了让程序员更容易理解和使用数据库。
模式的类型
数据库模式可以大致分为两种类型:
- 物理数据库模式:这个模式处理数据如何保存在存储器中。
- 逻辑数据库模式:这概述了必须对存储的数据施加的所有逻辑限制。
从 Python Django 项目中删除模式
理解了模式之后，下一个任务是理解如何从 Django 项目中删除一个方案。
现在，我们所要做的就是删除应用程序的 models.py 文件中不必要定义的模型类。
让我们借助一个例子来理解这件事，在这个例子中，我们将删除部门模型类。
这里，我们将有一个名为 EShopProject 的 Django 项目和一个名为 EShopApp 的应用程序。
另外，该 app 有两种模式:部门和产品，如下图所示。
from django.db import models
# Create your models here.
class Product(models.Model):
product_id = models.IntegerField()
name = models.CharField(max_length=150)
description = models.TextField(max_length=2000)
def __str__(self):
return self.name
class Department(models.Model):
department_id = models.IntegerField()
name = models.CharField(max_length=250)
def __str__(self):
return self.name
Models in ESHOPAPP
因为我们的目标是删除部门模型。我们必须打开 models.py 文件，并从那里删除部门模型类。
这就是 models.py 文件现在的样子。
from django.db import models
# Create your models here.
class Product(models.Model):
id = models.IntegerField()
name = models.CharField(max_length=150)
description = models.TextField(max_length=2000)
def __str__(self):
return self.name
在上面的代码中，我们指定了一个名为 Product 的模型。这个产品模型包含 3 个属性，代表 Django 中产品表的 3 个表字段。此外，我们还指定了产品名称 Model 的字符串表示。
现在要影响数据库中的更改，使用下面给出的make migrations和 migrate 命令。
python manage.py makemigrations
makemigrations
在 Django 中执行 makemigrations 命令后，我们需要执行 migrate 命令。Django 中的 migrate 命令如下所示。
python manage.py migrate
migrating Database
在 Django 中执行了上面指定的两个命令之后，我们已经成功地从 Python Django 项目中删除了模式。
这就是我们如何从 Python Django 中删除数据库模式。
结论
这样，我们已经成功地从 Django 中删除了模式，并且获得了模式的概述。此外，我们还讨论了以下主题。
- 什么是计划
- 不同类型的模式
- 如何从 Python Django 项目中删除方案
您可能也喜欢阅读下面的 Python Django 教程。
拥有丰富 Django 和 Matplotlib 经验的 Python 开发人员，目前在 TSInfo Technologies 工作。我正在成为专业程序员、博客写手和 YouTuber 的路上。
如何在 Python 数据帧中查找重复项
原文：https://pythonguides.com/how-to-find-duplicates-in-python-dataframe/
在这个 Python Pandas 教程中，我们将学习如何使用 Pandas在 Python 数据帧中找到副本。此外，我们将涵盖这些主题。
- 如何识别 Python 数据帧中的重复项
- 如何在 Python 数据帧中查找重复值
- 如何在 Python DataFrame 中查找列中的重复项
- 如何计算 Pandas 数据帧中的重复行
目录
- 如何在 Python 数据帧中找到重复项
- 如何识别 Python 数据帧中的重复项
- 如何在 Python 数据帧中找到重复值
- 如何在 Python DataFrame 中查找列中的重复项
- 如何计算熊猫数据帧中的重复行
如何在 Python 数据帧中找到重复项
- 在本期节目中，我们将讨论如何在熊猫数据帧中找到重复项。
- 为了完成这项任务，我们可以使用 Python 中的内置函数，如
DataFrame.duplicate()来查找 Pandas DataFrame 中的重复值。 - 在 Python 中，DataFrame.duplicated() 方法将帮助用户分析重复值，并且它将始终返回一个仅对于特定元素为真的布尔值。
语法:
下面是 DataFrame.duplicated()方法的语法
DataFrame.duplicated
(
subset=None,
keep='first'
)
- 它由几个参数组成
- Subset: 该参数采用一列标签，应该用于重复检查，默认情况下，其值为 None。
- keep: 该参数指定需要标记为重复的值的出现。它有三个不同的值‘First’，‘last’，‘False’，默认情况下，它将‘First’值作为参数。
举例:
让我们基于这些函数来理解几个例子
源代码:
import pandas as pd
new_list = [('Australia', 9, 'Germany'),
('China', 14, 'France'), ('Paris', 77, 'switzerland'),
('Australia',9, 'Germany'), ('China', 88, 'Russia'),
('Germany', 77, 'Bangladesh')]
result= pd.DataFrame(new_list, columns=['Country_name', 'Value', 'new_count'])
new_output = result[result.duplicated()]
print("Duplicated values",new_output)
在上面的代码中，我们选择了基于所有列的重复值。现在我们已经创建了一个 DataFrame 对象，在其中我们分配了一个 list‘new _ list’和列作为参数。之后，为了在 Pandas 数据帧中找到重复的值，我们使用了 df。复制的()函数。
How to Find Duplicates in Python DataFrame
另一个在 Python 数据帧中寻找重复的例子
在本例中，我们希望根据所选的列选择重复的行值。为了执行这个任务，我们可以使用 DataFrame.duplicated() 方法。现在，在这个程序中，我们将首先创建一个列表并在其中赋值，然后创建一个数据帧，在这个数据帧中，我们必须将 subset 中的列名列表作为参数传递。
源代码:
import pandas as pd
student_info = [('George', 78, 'Australia'),
('Micheal', 189, 'Germany'),
('Oliva', 140, 'Malaysia'),
('James', 95, 'Uganda'),
('James', 95, 'Uganda'),
('Oliva', 140, 'Malaysia'),
('Elijah', 391, 'Japan'),
('Chris', 167, 'China')
]
df = pd.DataFrame(student_info,
columns = ['Student_name', 'Student_id', 'Student_city'])
new_duplicate = df[df.duplicated('Student_city')]
print("Duplicate values in City :")
print(new_duplicate)
在上面的代码中，一旦打印出 'new_duplicate' ，输出将显示给定列表中的重复行值。
下面是以下给定代码的输出
How to Find Duplicates in Python DataFrame
还有，阅读: Python 熊猫 CSV 教程
如何识别 Python 数据帧中的重复项
- 在这里，我们可以看到如何使用 Python 来识别 Pandas 数据帧中的重复值。
- 在 Pandas 库中，DataFrame 类提供了一个函数来识别基于列的重复行值，该函数是
DataFrame.duplicated()方法，它总是返回一个表示具有真值的重复行的布尔序列。
举例:
让我们举一个例子，看看如何在 Python 数据帧中识别重复的行值
import pandas as pd
df = pd.DataFrame({'Employee_name': ['George','John', 'Micheal', 'Potter','James','Oliva'],'Languages': ['Ruby','Sql','Mongodb','Ruby','Sql','Python']})
print("Existing DataFrame")
print(df)
print("Identify duplicate values:")
print(df.duplicated())
在上面的例子中，我们在 Pandas 数据帧中设置了重复的值，然后应用了方法 df。duplicated() 它将检查数据帧中是否存在重复值，然后显示“真”。如果 DataFrame 中不存在重复值，则它将显示“False”布尔值。
你可以参考下面的截图
How to identify duplicates in Python DataFrame
另一个识别熊猫数据帧中重复行值的例子
在本例中，我们将基于所有列选择重复的行。为了完成这个任务，我们将传递 keep= 'last' 作为参数，这个参数指定除了最后一次出现之外的所有重复项，它将被标记为' True '。
源代码:
import pandas as pd
employee_name = [('Chris', 178, 'Australia'),
('Hemsworth', 987, 'Newzealand'),
('George', 145, 'Switzerland'),
('Micheal',668, 'Malaysia'),
('Elijah', 402, 'England'),
('Elijah',402, 'England'),
('William',389, 'Russia'),
('Hayden', 995, 'France')
]
df = pd.DataFrame(employee_name,
columns = ['emp_name', 'emp_id', 'emp_city'])
new_val = df[df.duplicated(keep = 'last')]
print("Duplicate Rows :")
print(new_val)
在上面的代码中，我们首先导入了 Pandas 库，然后创建了一个元组列表，我们在其中分配了行的值，并创建了一个 dataframe 对象，并将 keep='last' 作为参数传递。一旦您打印了‘new _ val’，那么输出将显示熊猫数据帧中出现的重复行。
下面是以下给定代码的执行过程
How to identify duplicates in Python DataFrame
如何在 Python 数据帧中找到重复值
- 让我们看看如何在 Python 数据帧中找到重复值。
- 现在我们要检查这个数据帧是否包含任何重复的元素。为了完成这个任务，我们可以结合使用
df.loc()和df.duplicated()方法。 - 在 Python 中，
loc()方法用于检索一组行和列，它只接受索引标签，而DataFrame.duplicated()方法将帮助用户分析 Pandas DataFrame 中的重复值。
源代码:
import pandas as pd
df=pd.DataFrame(data=[[6,9],[18,77],[6,9],[26,51],[119,783]],columns=['val1','val2'])
new_val = df.duplicated(subset=['val1','val2'], keep='first')
new_output = df.loc[new_val == True]
print(new_output)
在上面的代码中，我们首先创建了一个 dataframe 对象，并在其中分配了列值。现在我们想使用 df 替换给定数据帧中的重复值。方法复制()。
下面是以下给定代码的实现
How to find duplicate values in Python DataFrame
如何在 Python DataFrame 中查找列中的重复项
- 在本期节目中，我们将讨论如何使用 Pandas DataFrame 在特定列中查找重复项。
- 通过使用 DataFrame.duplicate()方法，我们可以在 Python DataFrame 中找到重复值。
举例:
让我们举一个例子，看看如何在一列中找到重复的值
源代码:
import pandas as pd
Country_name = [('Uganda', 318),
('Newzealand', 113),
('France',189),
('Australia', 788),
('Australia', 788),
('Russia', 467),
('France', 189),
('Paris', 654)
]
df = pd.DataFrame(Country_name,
columns = ['Count_name', 'Count_id'])
new_val = df[df.duplicated('Count_id')]
print("Duplicate Values")
print(new_val)
下面是以下给定代码的输出
How to find duplicates in a column in Python DataFrame
阅读: Python 熊猫掉行
如何计算熊猫数据帧中的重复行
- 让我们看看如何计算 Pandas 数据帧中的重复行。
- 通过使用
df.pivot_table我们可以执行这个任务。在 Python 中,pivot()函数用于根据给定的列值重塑 Pandas 数据帧，该方法可以处理一个旋转对的重复值。 - 在 Python 中，
pivot_table()用于计算一列中的重复数。
源代码:
import pandas as pd
df = pd.DataFrame({'Student_name' : ['James', 'Potter', 'James',
'William', 'Oliva'],
'Student_desgination' : ['Python developer', 'Tester', 'Tester', 'Q.a assurance', 'Coder'],
'City' : ['Germany', 'Australia', 'Germany',
'Russia', 'France']})
new_val = df.pivot_table(index = ['Student_desgination'], aggfunc ='size')
print(new_val)
在上面的代码中，我们将首先导入一个 Pandas 模块，然后创建一个 DataFrame 对象，在该对象中我们分配了键值对元素，并将它们视为列值。
您可以参考下面的屏幕截图来计算数据帧中的重复行
How to Count duplicate rows in Pandas DataFrame
你可能也喜欢阅读以下关于熊猫的教程。
- 如何将熊猫数据帧转换成字典
- 在熊猫中把整数转换成日期时间
- 检查 Python Pandas 中的数据帧是否为空
- Python 熊猫写数据帧到 Excel
- 如何在 Python Pandas 中向数据帧添加列
- 将 Pandas 数据帧转换为 NumPy 数组
- 如何在 Python Pandas 中设置列为索引
- 向数据帧添加行 Python 熊猫
在这个 Python Pandas 教程中，我们已经学习了如何使用 Pandas 在 Python 数据帧中找到副本。此外，我们已经讨论了这些主题。
- 如何识别 Python 数据帧中的重复项
- 如何在 Python 数据帧中查找重复值
- 如何在 Python DataFrame 中查找列中的重复项
- 如何计算 Pandas 数据帧中的重复行
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何使用 Python Tkinter +视频教程生成工资条
原文：https://pythonguides.com/how-to-generate-payslip-using-python-tkinter/
在本 Python 教程中，您将学习如何使用 Python 控制台和图形用户界面(GUI)创建工资单生成器。在这篇博客结束时，你将拥有完整的知识和源代码使用 python Tkinter 在 Python 中创建工资单生成器。
目录
业务需求
最近，我们收到了用 python 创建工资单应用程序的要求。这是一个简单的控制台应用程序，接受输入，如员工姓名、工作时间、小时工资等。
应用程序使用这些信息生成一个输出，其中员工信息和扣除额显示在 python 控制台上。
尽管应用程序的需求是基于控制台的，但我们已经使用控制台和基于 GUI 的方式创建了它。对于图形用户界面(GUI ),我们使用了 python 库——Tkinter。
如果您是 Python Tkinter 的新手，请查看 Python GUI 编程(Python Tkinter)
下面是我们收到的要求的图像:
payslip console application
- 使用 python 控制台的简单工资单应用程序
- 使用 python tkinter 的简单工资单应用程序
另外，请查看，如何使用 Pyinstaller 将 Python 文件转换为 exe 文件
使用 python 控制台的简单工资单应用程序
工资单应用程序接受员工的详细信息，如姓名、工作时间、每小时工资、sss 缴款、Phil health 和住房贷款。
使用这些信息，可以生成一个工资条，工资条中包含所有扣除额的员工信息，最后显示净工资。
源代码:
在下面的源代码中，python input() 方法用于获取用户输入。默认情况下，用户提供的输入是字符串数据类型。
- 通过在 input()方法前添加数据类型名称，我们可以将用户输入转换为首选的数据类型。如下面的代码所示，我们将用户输入转换为浮点数据类型。
- 值班天数乘以每小时工资率将得出员工的总工资。
- 税是总工资的 10%
- 将社会保障系统缴款、健康保险、房屋贷款和税收相加，将得出总扣除额
- 从总薪资中减去总扣除额以获得净薪资信息。
**# User inputs**
emp_name = input('Employee Name: ')
rph = float(input('Rate per hour: '))
duty = float(input('Duty (No. of hours): '))
s3_contrib = float(input('SSS Contribution: '))
phealth = float(input('PhilHealth: '))
hloan = float(input('Housing loan: '))
print('')
print('-'*3+'EMPLOYEE INFORMATION'+'-'*3)
print('')
**# Net salary calculation**
gross_sal = rph * duty
tax = gross_sal * 0.1
total_deduction = s3_contrib + phealth + hloan + tax
net_sal = gross_sal - total_deduction
**# display information using formatted string**
print(f'''
Name: {emp_name}
Rendered Hours: {duty}
Rate per hour: {rph}
Gross Salary: {gross_sal}
''')
print('')
print('-'*5+'DEDUCTIONS'+'-'*5)
print('')
print(f'''
SSS: {s3_contrib}
PhilHealth: {phealth}
Other Loan: {hloan}
Tax: {tax}
Total Deductions: {total_deduction}
Net Salary: {net_sal}
''')
输出:
在下面的输出中，用户提供了前 6 个输入，其余的由应用程序生成。该信息分为两个部分-员工信息和扣减。并且最后计算出手里的净工资。
payslip console application using python
阅读在 Python Tkinter 中创建 Word 文档
使用 python tkinter 的简单工资单应用程序
Python Tkinter 允许 Python 开发者编写基于 GUI 的软件。各种各样的小部件允许创建一个用户友好的界面，允许轻松访问应用程序。
在本节中，我们创建了一个基于 GUI 的应用程序，它通过入口小部件接受用户输入，并在交互式窗口中显示结果。该程序是使用 Tkinter 模块用 python 编写的。
代码分为两部分。在第一部分中，我们使用 Python Tkinter 创建了一个交互式表单。填写交互式表单，然后单击“计算”按钮以生成工资单。另一部分在新窗口中显示输出。
源代码:
在下面的代码中，Tkinter 模块是导入的，calsal 模块是我们创建的，我们将在下一部分讨论它。
- 用名称
main.py保存这段代码 - ws 是在 python 中为 tkinter 对象创建的实例。
- 当按下清除按钮时，清除功能清除所有的入口部件。
**<entry_widget_name>.delete(0, 'end')**。这里，0 表示起点，end 表示 python tkinter entry 小部件中的最后一个字符。 - 退出按钮将终止程序的所有实例。使用匿名函数(lambda ),我们在一行中创建了退出函数-
lambda: ws.destroy()这里，ws 是当前窗口实例的名称。 - Python 函数名–
Main()包含将在基于 tkinter 的 GUI 中生成工资单详细信息的算法。 - 以下公式用于计算员工的净工资:
gross_sal = r * d
tax = gross_sal * 0.1
total_deduction = contri + ph + hl + tax
net_sal = gross_sal - total_deduction
- Grid geomertry 方法用于在 tkinter 窗口上放置小部件。了解更多关于t 内部网格几何方法的信息。
- 入口小部件用于接收用户输入。String 是入口小部件的默认数据类型。使用
<entry>.get()方法，可以从入口小部件中获取信息。了解关于 python tkinter 中的入口小部件的更多信息。
calsal.payslip(ename, d, r, gross_sal, contri, ph, hl, tax, total_deduction, net_sal, ws, f)
- 上面的代码显示了 calsal 函数的调用。我们在本模块中创建了一个功能工资单。工资单功能接受上述参数。
- 这个函数负责生成交互式输出窗口。
**# modules**
from tkinter import *
import calsal
**# tkinter object**
ws = Tk()
ws.title('PythonGuides - PaySlip Generator')
ws.geometry('400x300')
f = 'sans-serif, 12'
**# functions**
def clearbtn():
emp_name.delete(0, 'end')
rph.delete(0, 'end')
duty.delete(0, 'end')
s3_contrib.delete(0, 'end')
phealth.delete(0, 'end')
hloan.delete(0, 'end')
def main():
ename = emp_name.get()
r = rph.get()
d = duty.get()
contri = s3_contrib.get()
ph = phealth.get()
hl = hloan.get()
r = float(r)
d = float(d)
contri = float(contri)
ph = float(ph)
hl = float(hl)
gross_sal = r * d
tax = gross_sal * 0.1
total_deduction = contri + ph + hl + tax
net_sal = gross_sal - total_deduction
**# calling function**
calsal.payslip(ename, d, r, gross_sal, contri, ph, hl, tax, total_deduction, net_sal, ws, f)
Label(
ws,
text="EMPLOYEE PAYSLIP",
font=('sans-serif, 14'),
relief=SOLID,
padx=10,
pady=5
).pack()
**# frame widget**
mainframe = Frame(ws, padx=5, pady=5)
mainframe.pack(expand=True)
**# label widget**
Label(
mainframe,
text='Employee Name',
font=f
).grid(row=2, column=0, sticky='e')
Label(
mainframe,
text='Rate per hour',
font=f
).grid(row=3, column=0, sticky='e')
Label(
mainframe,
text='Duty (No. of hours)',
font=f
).grid(row=4, column=0, sticky='e')
Label(
mainframe,
text='SSS Contribution',
font=f
).grid(row=5, column=0, sticky='e')
Label(
mainframe,
text='PhilHealth',
font=f
).grid(row=6, column=0, sticky='e')
Label(
mainframe,
text='House loan',
font=f
).grid(row=7, column=0, sticky='e')
**# Entry widgets**
emp_name = Entry(mainframe, font=f)
rph = Entry(mainframe, font=f)
duty = Entry(mainframe, font=f)
s3_contrib = Entry(mainframe, font=f)
phealth = Entry(mainframe, font=f)
hloan = Entry(mainframe, font=f)
**# geometry method - Grid**
emp_name.grid(row=2, column=1, padx=5)
rph.grid(row=3, column=1, padx=5, sticky='w')
duty.grid(row=4, column=1, padx=5, sticky='w')
s3_contrib.grid(row=5, column=1, padx=5, sticky='w')
phealth.grid(row=6, column=1, padx=5, sticky='w')
hloan.grid(row=7, column=1, padx=5, sticky='w')
**# default values in the entry widget**
emp_name.insert('0', 'Noel B. Atazar')
rph.insert('0', 150)
duty.insert('0', 9)
s3_contrib.insert('0', 200)
phealth.insert('0', 150)
hloan.insert('0', 100)
**# frame for buttons**
frame = Frame(mainframe)
frame.grid(row=8, columnspan=3, pady=(30, 0))
**# button widget**
Button(
frame,
text='Calculate',
width=10,
command=main,
font=f,
bg='#91BF2C'
).pack(side=LEFT, expand=True, padx=(0, 5))
Button(
frame,
text='Clear',
width=5,
font=f,
bg='#E6D92A',
command=clearbtn
).pack(side=LEFT, expand=True, padx=(0, 5))
Button(
frame,
text='Exit',
width=5,
font=f,
bg='#FF614F',
command=lambda:ws.destroy()
).pack(side=LEFT, expand=True, padx=(0, 5))
**# infinite loop**
ws.mainloop()
输出:
这是上述代码的输出，这是一个交互式的表单，一旦要求被满足，单击计算按钮产生工资单。清除按钮将清除输入框，退出按钮将终止程序。
Payslip GUI application using Python Tkinter
源代码:
用名称 calsal.py 保存该文件。main.py 文件将使用这个模块来显示输出。
**# module**
from tkinter import *
**# function**
def payslip(ename, d, r, gross_sal, contri, ph, hl, tax, total_deduction, net_sal, ws, f):
cf = ('sans-serif 12 bold')
win = Toplevel(ws)
win.geometry('500x450+500+200')
Label(
win,
text='EMPLOYEES INFORMATION',
font='sans-serif 14',
relief=SOLID, padx=5,
pady=10
).place(x=110 , y=10)
Label(
win,
text='Name: ',
font=cf
).place(x=10, y=70)
Label(
win,
text=f'{ename}',
font=f
).place(x=65, y=70)
Label(
win,
text='Rendered Hours: ',
font=cf
).place(x=250, y=70)
Label(
win,
text=f'{d}',
font=f
).place(x=390, y=70)
Label(
win,
text='Rate per hour: ',
font=cf
).place(x=10, y=110)
Label(
win,
text=f'{r}',
font=f
).place(x=125, y=110)
Label(
win,
text='Gross Salary: ',
font=cf
).place(x=250, y=110)
Label(
win,
text=f'{gross_sal}',
font=f
).place(x=390, y=110)
Label(
win,
text='DEDUCTIONS',
font='sans-serif 14', relief=SOLID,
pady=5, padx=10
).place(x=170, y=180)
Label(
win,
text='SSS: ',
font=cf
).place(x=10, y=240)
Label(
win,
text=f'{contri}',
font=f
).place(x=65, y=240)
Label(
win,
text='PhilHealth: ',
font=cf
).place(x=250, y=240)
Label(
win,
text=f'{ph}',
font=f
).place(x=390, y=240)
Label(
win,
text='Other Loan:',
font=cf
).place(x=10, y=280)
Label(
win,
text=f'{hl}',
font=f
).place(x=105, y=280)
Label(
win,
text='Tax: ',
font=cf
).place(x=250, y=280)
Label(
win,
text=f'{tax}',
font=f
).place(x=390, y=280)
Label(
win,
text='Total Deductions: ',
font=cf
).place(x=10, y=320)
Label(
win,
text=f'{total_deduction}',
font=f
).place(x=150, y=320)
Label(
win,
text='Net Salary:',
font=cf
).place(x=250, y=320)
Label(
win,
text=f'{net_sal}',
font=f
).place(x=390, y=320)
Button(
win,
text='Close',
padx=10,
pady=5,
font=f,
bg='#FF614F',
command=lambda:win.destroy()
).place(x=220, y=390)
输出:
在此输出中，该窗口共享员工信息和薪资中的扣减额。净工资是员工将收到的手头金额。底部的关闭按钮将关闭此窗口。
Payslip GUI application using Python Tkinter
在本教程中，我们学习了如何使用控制台创建工资单应用程序，以及如何使用 Python Tkinter 生成工资单。如果您有任何疑问或建议，请写信给我们。
- 使用 python 控制台的简单工资单应用程序
- 使用 python Tkinter 的简单工资单应用程序
相关 Python Tkinter 教程:
- Python 数字猜谜游戏
- Python Tkinter 过滤函数()
- Python Tkinter 面板
- Python Tkinter add 函数示例
- Python Tkinter 保存文本到文件
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何在 Django 获取当前时间
原文：https://pythonguides.com/how-to-get-current-time-in-django/
在本 Django 教程中，我们将了解如何在 Django 获取当前时间。我们还将了解如何获得当前日期以及日期时间值。另外，讨论如何在 Django 中使用它们。这是我们将要涉及的主题列表。
- 获取 django 中的当前日期时间
- 获取 django 的当前时间
- 获取 django 的当前日期
- 获取 django 模板中的当前时间
- 获取 django 模板中的当前日期
- 获取 django 模板中的当前日期时间
目录
- 获取 Django 中的当前日期时间
- 获取姜戈的当前时间
- 获取 Django 的当前日期
- 获取 django 模板中的当前时间
- 获取 django 模板中的当前日期
- 获取 django 模板中的当前日期时间
获取 Django 中的当前日期时间
在 Django 中获取当前日期时间值的最简单方法是使用 python 的日期时间模块。这个 datetime 模块包含许多不同的类，可以用来操作日期和时间值。
我们可以通过在 Django 应用程序的 views.py 文件中导入 datetime 模块来轻松使用这些类。
现在，为了获取当前的日期时间值，我们将使用日期时间模块中可用的日期时间类。让我们按照给定的步骤来理解实现。
- 首先，打开 Django 应用程序的
views.py文件，导入datetime模块。 - 接下来，使用
datetime.now()方法获取当前日期和时间值。 - 现在，我们可以将这个方法赋给一个变量，也可以在需要日期时间值的地方直接使用这个方法。
现在，让我们基于这些步骤执行一个示例，并理解实现。为此，我们在我们的 views.py 文件中添加了以下代码。
from django.http import HttpResponse
import `datetime`
def index(request):
current_datetime = `datetime`.datetime.now()
html = "<html><body><b>Current Date and Time Value:</b> %s</body></html>" % current_datetime
return HttpResponse(html)
在示例中，我们导入了 datetime 模块，并使用其 datetime.now() 方法将日期时间值存储在变量中。然后，我们在一个 HttpResponse 中使用这个变量。
现在，如果我们启动开发服务器并移动到映射的 URL，我们将得到以下结果。
Get Current time in Django
获取姜戈的当前时间
现在，如果我们只想要 Django 应用程序中的当前时间值，该怎么办呢？因此，在本节中，我们将了解如何获取 Django 中的当前时间。
有多种方法可以在应用程序中获取和使用当前时间值。在这一节中，我们将尝试理解其中的大部分。
- 使用日期时间类
- 使用时间模块
使用日期时间类
现在，在这个方法中，我们将使用 datetime 类，它在 datetime 类中。有两种方法可以使用它来获得当前时间。
在第一个方法中，我们将使用 datetime.strftime() 方法创建一个表示当前时间的字符串。下面是一个在 views.py 文件中使用 strftime() 方法的例子。
from django.http import HttpResponse
from datetime import datetime
def index(request):
current_time = datetime.now().strftime('%H:%M:%S')
html = "<html><body><b>Current Time Value:</b> %s</body></html>" % current_time
return HttpResponse(html)
在上面的例子中，我们从日期时间模块中导入了日期时间类。接下来，我们创建了一个名为索引的视图。在这个视图中，我们使用 datetime.strftime() 方法将当前时间值存储在一个变量中。然后，我们使用变量返回当前时间值作为 HTTP 响应。
现在，如果我们运行开发服务器并移动到映射的 URL，我们将得到以下输出。
Get Current time in Django
在第二种方法中，我们将创建一个 time 对象来获取当前时间。为此，我们将使用 datetime.now()。time() 方法，它会将日期时间值更改为唯一的时间值。下面是我们如何在 views.py 文件中创建一个时间对象。
from django.http import HttpResponse
from datetime import datetime
def index(request):
current_time = datetime.now().time()
html = "<html><body><b>Current Time Value:</b> %s</body></html>" % current_time
return HttpResponse(html)
现在，如果我们启动开发服务器并打开 URL，我们将得到以下结果。
Output
使用时间模块
现在，在这一节中，我们将了解如何使用时间模块来获取 Django 中的当前时间值。
时间模块是一个 python 模块，包含各种与时间相关的函数。让我们借助下面的例子来理解如何使用它。
from django.http import HttpResponse
import time
def index(request):
t = time.localtime()
current_time = time.strftime("%H:%M:%S", t)
html = "<html><body><b>Current Time Value:</b> %s</body></html>" % current_time
return HttpResponse(html)
在上面的例子中，首先，我们已经导入了时间模块，然后，我们正在创建一个视图。在视图中，我们定义了一个变量" t "来获取当前时间。
之后，我们使用 strftime() 方法来格式化时间值。最后，我们将使用 HTTP 响应返回时间值。下面是上面例子的结果。
Result
阅读:如何安装 Django
获取 Django 的当前日期
到目前为止，我们已经讨论了如何获取当前日期时间和时间值。现在，在这一节中，我们将讨论如何在 Django 获取当前日期。
现在，在 python 中有很多方法可以获得当前日期，我们也可以使用同样的方法在 Django 中获得当前日期。
获取当前日期最简单的方法是使用 datetime 模块。使用日期时间模块获取当前日期有两种方法。
第一种方法是使用 date.today() 方法，该方法返回当前日期。下面是一个在 views.py 文件中使用 date.today() 方法的例子。
from django.http import HttpResponse
import datetime
def index(request):
current_date = datetime.date.today()
html = "<html><body><b>Today\'s Date:</b> %s</body></html>" % current_date
return HttpResponse(html)
在本例中，首先，我们导入了 datetime 模块。之后，我们使用 date.today() 方法将当前日期存储在名为 current_date 的变量中。最后，我们将日期作为 HTTP 响应返回。
现在，如果我们启动开发服务器并打开 URL，我们将得到以下结果。
Result
第二种方法是使用来自日期时间模块的日期时间类。在此，我们必须使用 datetime.now()。date() 方法获取当前日期。下面是一个使用 datetime.now()的例子。日期()【方法】在姜戈。
from django.http import HttpResponse
from datetime import datetime
def index(request):
current_date = datetime.now().date()
html = "<html><body><b>Today\'s Date:</b> %s</body></html>" % current_date
return HttpResponse(html)
在示例中，我们从日期时间模块中导入了日期时间类。接下来，我们使用 datetime.now()。date()【方法】将当前日期值存储在一个变量中。
最后，我们返回变量作为响应。这个例子也将返回如上所示的相同结果。
获取 django 模板中的当前时间
到目前为止，我们只讨论了获取视图文件中的当前日期和时间。现在，我们将了解如何在 Django 模板中获取当前日期和时间。
在 Django 中，有两种方法可以获取模板中的当前时间。第一种方法是获取 views.py 文件中的当前时间，并将其发送到模板页面。
然后，在模板中使用它来获得输出。第二种方法是使用 Django 模板标签获取当前时间。
在本节中，我们将通过举例来讨论这两种方法。
使用视图文件
在第一个方法中，我们将使用 views.py 获取当前时间，然后将其发送到模板。为此，我们在我们的 views.py 文件中添加了以下代码。
from django.shortcuts import render
from datetime import datetime
def index(request):
current_time = datetime.now().time()
return render(request, 'index.html', {'current_time':current_time})
在上面的代码中，我们创建了一个名为 index 的基于函数的视图。在这个视图中，我们使用 datetime.now()定义了一个变量来存储当前时间的值。时间()法。然后，我们将变量发送到 index.html 的页面。
现在，为了使用变量显示当前时间，我们必须将以下代码添加到index.html页面。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Python Guides</title>
</head>
<body>
<b>Current Time: </b>{{current_time}}
</body>
</html>
现在，如果我们启动开发服务器并打开 URL，我们将得到以下结果。
Output
使用模板标签
在这种方法中，我们将简单地创建一个将重定向到 HTML 页面的视图。之后，在模板中，我们将使用“ now 标签来获取当前时间。首先， views.py 文件的代码如下。
from django.shortcuts import render
def index(request):
return render(request, 'index.html')
接下来，我们将把下面的代码添加到index.html文件中以获得结果。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Python Guides</title>
</head>
<body>
<b>Current Time: </b>{% now "P" %}
</body>
</html>
在上面的代码中， {% now "P" %} 标签会返回当前的时间值。下面是上述示例的输出。
Output
获取 django 模板中的当前日期
因此，与上一节类似，我们可以使用两种不同的方法来获取 Django 模板中的当前日期。在本节中，我们还将讨论当前日期情况下的两种方法。
使用视图文件
对于第一种方法，我们将使用 views.py 获取当前日期值，然后将日期值发送到模板。对于这个实现，我们必须在 views.py 文件中添加以下代码。
from django.shortcuts import render
from datetime import datetime
def index(request):
current_date = datetime.now().date()
return render(request, 'index.html', {'current_date':current_date})
在上面的代码中，我们创建了一个基于函数的视图，在这个视图中，我们定义了一个变量。现在，这个变量将使用 datetime.now()存储当前日期的值。日期()方法。
然后，我们使用 return 语句将变量发送到index.html页面。
接下来，为了显示当前日期，我们必须向index.html页面添加以下代码。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Python Guides</title>
</head>
<body>
<b>Today's Date: </b>{{current_date}}
</body>
</html>
在上面的示例中，“{ {当前日期}} ”变量将返回当前日期。这是上面页面的输出。
Output
使用模板标签
在这个方法中，首先，我们将创建一个重定向到 HTML 页面的视图。在此之后，在模板中，我们将使用“ now 标签来获取当前日期。首先， views.py 文件的代码如下。
from django.shortcuts import render
def index(request):
return render(request, 'index.html')
接下来，我们将把“ now 标签添加到【index.html】文件中，以获得结果。此外，我们可以使用这个标签以不同的格式显示当前日期。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Python Guides</title>
</head>
<body>
<p><b>Today's Date: </b>{% now "d-m-Y" %}</p>
<p><b>Today's Date: </b>{% now "d/m/Y" %}</p>
<p><b>Today's Date: </b>{% now "l, j F Y" %}</p>
</body>
</html>
现在，启动开发服务器并在浏览器中打开映射的 URL。我们将得到以下结果。
Output
获取 django 模板中的当前日期时间
在这一节中，我们将讨论如何在 Django 模板中获得当前的日期时间值。
对于这个实现，我们将讨论获取当前日期时间值并在模板中使用它的两种不同方法。这两种方法如下。
- 首先，使用
view.py文件获取日期时间值并将其发送到 html 页面。之后，使用 HTML 页面中的 datetime 值获得结果。 - 其次，创建一个重定向到 HTML 页面的视图，然后在 HTML 页面中使用模板标记来获取日期时间值。
使用视图文件
让我们通过在 Django 中执行一个例子来理解这种方法。对于这个例子，首先，我们将在 views.py 文件中添加以下代码。
from django.shortcuts import render
from datetime import datetime
def index(request):
current_datetime = datetime.now()
return render(request, 'index.html', {'current_datetime':current_datetime})
在 views.py 文件中，我们创建了一个简单的视图，将当前日期时间值提取到一个变量中。它还将变量返回到 index.html 的页面。
现在，对于index.html页面，我们将添加以下代码。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Python Guides</title>
</head>
<body>
<p><b>Current Date-Time: </b>{{current_datetime}}</p>
</body>
</html>
在index.html页面中，我们只是使用变量来获取当前的日期时间值。最终，我们将获得以下输出。
Output
使用模板标签
在这种方法中，我们只需要创建一个重定向到 HTML 页面的视图。这是视图的代码。
from django.shortcuts import render
def index(request):
return render(request, 'index.html')
现在，通过使用模板标签，我们可以获得不同格式的当前日期时间值。下面的示例显示了一些常见的格式。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Python Guides</title>
</head>
<body>
<p><b>Current Date-Time: </b>{% now "SHORT_DATETIME_FORMAT" %}</p>
<p><b>Current Date-Time: </b>{% now "jS F Y, H:i A" %}</p>
<p><b>Current Date-Time: </b>{% now "c" %}</p>
<p><b>Current Date-Time: </b>{% now "r" %}</p>
</body>
</html>
这是我们运行开发服务器时，上述示例的输出。
Output
另外，请阅读以下 Django 教程:
- Django 从 POST 请求中获取所有数据
- 如何在 Django 中创建模型
- Python Django 过滤器
- Python Django group by
- 在 Python + PDF 发票中使用 Django 将 HTML 页面转换为 PDF
在这个 Django 教程中，我们讨论了如何在 Django 中获取当前时间，如何获取当前日期以及日期时间值。此外，我们还讨论了以下主题列表。
- 获取 django 中的当前日期时间
- 获取 django 的当前时间
- 获取 django 的当前日期
- 获取 django 模板中的当前时间
- 获取 django 模板中的当前日期
- 获取 django 模板中的当前日期时间
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何在 Python 中从列表中获取字符串值
原文：https://pythonguides.com/how-to-get-string-values-from-list-in-python/
在这个 Python 教程中，我们将讨论在 Python 中从列表中获取字符串值的不同方法。对于这个主题，让我们来理解下面的场景
目录
如何在 Python 中从列表中获取字符串值:场景
Python Excel sheets columns
- 在这个场景中，我们创建了一个包含 A 列和 b 列两列的 excel 表。在这些列中，有两个主要属性'逐字的和'关键字'。在逐字(列)我们已经指定了一些短语)和其他方面，我们已经选择了关键字属性中的一些单词。
- 第一个场景:我们必须在 A 列中找到 b 列的常用词。例如，假设您有两个给定的数组，数组 1 包含“逐字”(A 列)元素，数组 2 包含“关键字”元素。现在我们必须找到两个数组之间的共同单词
- 第二种场景:A 列的一个词必须附加 B 列关键词。
在 b 列中求 A 列的值有各种方法，我们来看看方法。
- 通过使用 regex 方法
- 使用 Numpy 方法
- 通过使用 for 循环方法
通过使用 NumPy 方法
- 在这个程序中，我们将学习如何使用 NumPy 方法从输入数组中找到公共值。
- 为了执行这个特定的任务，我们将使用 np.intersect1d()函数。在 Python 中，此函数用于查找两个输入数组之间的交集，此方法将两个数组作为参数，它将检查数组 1 的值是否存在于数组 2 中。简而言之，交集被定义为从两个输入数组中获取唯一值或公共值。
语法:
下面是 Python np.intersect1d()函数的语法。
numpy.intersect1d
(
ar1,
ar2,
assume_unique=False,
return_indices=False
)
举例:
import numpy as np
x = np.array(['Books','open','doors','in','our','minds'])
y= np.array(['open','doors','minds'])
result = np.intersect1d(x,y)
print(result)
在下面的代码中，我们导入了 NumPy 库，然后使用 np.array()函数创建了一个数组，在这个函数中，我们指定了字符串字符。
在创建一个数组后，我们声明了一个变量“result”并使用了 np.intersect1d()函数，在这个函数中，我们将输入数组指定为一个参数。
下面是以下给定代码的实现。
How to find common values in NumPy Python
通过使用 regex 方法
- 在本节中，我们将学习如何使用 Python regex 方法从 list 中获取字符串值。
- 在 Python 中，regex 方法用于描述给定输入文本中的搜索模式，为了创建 regex 对象，我们将导入“re”模块。
- 导入模块后，我们将使用 re.search()方法，在该函数中，我们将分配输入文本，该函数将帮助用户编译正则表达式并搜索模式。
举例:
import re
input = re.compile(r'(Books|teach|us|about|love|heartbreak)')
result = input.search('emotions heartbreak')
print('love and '+result.group())
在上面的代码中，我们使用了 re.compile() 方法，该函数将输入作为正则表达式输入，并将检查文本中的相同模式。之后，我们使用了 re.search() 方法，这个方法将帮助用户在给定的字符串中找到模式的出现。
下面是下面给出的代码的截图。
how to get string values from input text in Python
通过使用 for 循环方法
在本节中，我们将学习如何使用 for-loop 方法在 B 列中找到 A 列的值。
举例:
column_A = "A lesson for life from one lion to another"
column_B = ['lesson']
for i in column_B:
if i in column_A:
print(i)
在上面的代码中，我们创建了一个输入字符串“column_A ”,同时我们还创建了一个列表，在该列表中我们指定了要对输入字符串进行操作的单词。
在给定的示例中，我们必须在 column_A 元素中找到 column_B 元素的值。为了完成这项任务，我们将使用 for-loop 方法并迭代这些值。
下面是以下给定代码的输出。
在这个 Python 教程中，我们已经学习了如何从 Python 的列表中获取字符串值。
相关 Python 教程:
- Python 查找列表中元素的索引
- 使用 For 循环在 Python 中添加列表元素
- Python 在字符串中查找数字
- Python NumPy 中值
- Python 复制 NumPy 数组
- Python NumPy genfromtxt()
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何安装 Django
在这个 Python Django 教程中，我们将学习如何安装 Django，我们还将了解如何在 Windows、Linux 或 Mac 上安装 Django。下面给出了本文涉及的主题列表。
- 如何在 Windows 中安装 Django
- 如何在 Linux 中安装 Django
- 如何在 Mac 上安装 Django
- 如何检查 Django 版本
- 如何在 pycharm 中安装 Django
- 如何在 visual studio 代码中安装 Django
- 如何安装 Django rest 框架
目录
- 如何安装 Django
- 如何检查 Django 版本
- 如何在 visual studio 代码中安装 Django
- 如何在 pycharm 中安装 Django
- 如何安装 Django rest 框架
如何安装 Django
由于 Django 是一个基于 python 的 web 框架，所以安装 Django 的第一个要求是安装 python。所以，不管什么操作系统，首先我们需要安装 python。
现在，安装 python 非常容易，你可以从下面的官网轻松下载 python。
或者可以按照下面这篇文章“ Python 下载安装步骤”。本文给出了在不同操作系统中安装 python 的所有步骤。
安装 python 后，我们可以使用 PIP 轻松安装 Django 框架。PIP 代表“首选安装程序”或“ Pip 安装包”是它的递归缩写。
它是 python 的一个包管理器，主要用于安装、更新、卸载包。默认情况下，python 版或更高版本会提供该功能。
但是在使用 PIP 安装 Django 之前，推荐的最佳实践是为每个 Django 项目提供一个单独的环境。我们可以使用 python 中的" venv "模块轻松管理环境。
“ venv ”模块用于创建一个轻量级的虚拟环境，它有自己的站点目录。现在，这些目录将与系统站点目录分开。
虚拟环境是一个独立的环境，有自己的 Python 二进制文件。因此，我们可以使用它在它的站点目录中独立安装 python 包。
接下来，让我们了解如何创建一个虚拟环境，并在不同的操作系统中安装 Django。让我们从 windows 操作系统开始。
如何在 Windows 中安装 Django
在这一节中，我们将学习如何在 windows 中创建一个虚拟环境，并使用它来安装 Django。
现在，让我们首先使用 python venv 模块创建一个虚拟环境。对于这个实现，首先，我们打开一个命令提示符，然后我们需要导航到我们想要创建项目的位置。
现在，要创建一个虚拟环境，我们可以遵循给定的语法。
python -m venv environment_name
在语法中，我们需要提供环境的名称来代替 environment_name。该命令将设置虚拟环境，并在我们指定的位置创建一个目录。建议为您的环境提供一个合适的项目名。下面是执行该命令的一个示例。
python -m venv mysite-env
这将在给定位置创建一个名为“ mysite-env 的目录。我们还可以在命令提示符下使用“ dir 命令来检查目录。这个实现如下面的屏幕截图所示。
Creating a virtual environment for Django
接下来，我们需要通过运行位于脚本目录中的 activate.bat 文件来激活虚拟环境。为此，我们需要遵循以下语法。
environment_name\Scripts\activate.bat
让我们使用这个语法来激活我们的" mysite-env "环境。
mysite-env\Scripts\activate.bat
这将激活虚拟环境，我们可以很容易地识别出这一点，因为环境名称将出现在命令提示符的旁边。下面是这个的截图。
Activating the virtual environment
现在，我们准备安装 Django，为此，我们将使用 PIP。下面是使用 PIP 安装 Django 的命令。
python -m pip install Django
执行上述命令后，将下载并安装最新的 Django 版本。在我们的例子中，将安装 Django-3.2.6。
Installing Django in Windows
如何在 Linux / Mac 中安装 Django
现在，在 Linux 和 Mac 上安装 Django 的步骤和在 Windows 上是一样的。微小的区别在于激活虚拟环境的命令。因此，在这一节中，我们将了解如何创建一个虚拟环境，并使用它在 Linux 和 Mac 操作系统中安装 Django。
现在，要在 Linux 或 Mac 中创建虚拟环境，我们可以遵循相同的语法。
python3 -m venv environment_name
创建虚拟环境后，我们需要激活它。为此，我们必须对 Linux 和 Mac 使用相同的命令。
source environment_name/bin/activate
通过激活虚拟环境，shell 提示符将显示我们已经激活的环境的名称。而且，它将从系统的 python 版本转移到虚拟环境 python。
在这之后，我们可以很容易地使用同一个 pip 模块为 Linux 和 Mac 安装 Django。
python3 -m pip install Django
这将成功下载并安装最新的 Django 版本。
Read: ModuleNotFoundError:没有名为 Django 的模块
如何查看 Django 版
在我们的虚拟环境中安装 Django 之后，我们可以很容易地检查它的版本。为此，我们必须使用以下命令。
python -m django --version
如果我们没有指定 Django 的版本，那么 python 会自动下载并安装最新的 Django 版本。而最新的 Django 版本是 3.2.6 。
如果我们执行上面的命令，我们将以下面的方式得到结果。
Output
阅读: Python Tkinter
如何在 visual studio 中安装 Django 代码
我们也可以使用 visual studio 代码来安装 Django 模块，对于这个实现，我们必须遵循下面给出的步骤。
- 首先，我们需要在我们的系统中安装 python。
- 接下来，启动 visual studio 代码，单击 extensions 选项并安装 python 扩展。
Installing python extension in vs code
- 接下来，在您的文件系统中，创建一个文件夹来存储虚拟环境和项目文件。
- 现在，回到 visual studio 代码，从菜单栏中选择“终端”>”新终端，或者使用 Ctrl+Shift+` 快捷键在 VS 代码中打开一个终端。
- 之后，使用终端移动到项目位置。然后执行以下命令之一来创建虚拟环境。
# Linux | macOS
python3 -m venv env_name
# Windows
python -m venv env_name
Example
- 接下来，从菜单栏中选择“文件”>”打开文件夹选项，打开 VS 代码中的项目文件夹。或者，我们也可以使用
Ctrl+Oshortchut。 - 现在，在菜单栏中选择“视图”>”命令面板选项，打开命令面板。或者使用
Ctrl+Shift+P快捷键。然后，选择Python:Select Interpreter命令。
Python interpreter option in vs code
- 它将打开一个 visual studio 可以定位的 python 解释器列表。从列表中选择位于您创建的虚拟环境中的解释器。
Selecting python interpreter
- 现在，如果我们用 VS 代码打开终端，那么虚拟环境将被自动激活。
注意:–如果您使用的是 Windows，那么您必须将默认终端从 Powershell 更改为 VS 代码中的命令提示符。然后用 VS 代码启动终端。为此，在设置中查找“终端>集成>默认配置文件，设置为“命令提示”。
- 最后，只需在终端中运行以下命令，就可以在您的虚拟环境中安装 Django 模块。
python -m pip install django
Installing Django using visual studio code
如何在 pycharm 中安装 Django
类似于 visual studio 代码，我们也可以使用 pycharm 来安装 Django 模块，并创建一个 Django 项目。
现在，如果我们正在使用 Pycharm Professional，那么我们不需要单独安装 Django。Django 项目可以直接在 Pycharm 专业版中创建。因此，在本文中，我们将讨论如何在 Pycharm 社区版中安装 Django。为此，我们必须遵循以下步骤。
- 首先，启动 Pycharm 社区版并创建一个新项目，使用选项选择“新环境”为“
Virtualenv”。并点击创建。
Creating a new project in pycharm
- 现在，如果您使用的是 Windows，那么您必须将终端从 PowerShell 更改为 pycharm 中的命令提示符。为此，进入文件>设置，在工具下查找端子设置。现在，选择从
powershell.exe到cmd.exe的外壳路径。
Terminal settings
- 现在，只需在 pycharm 中打开终端并运行以下命令来安装 Django。
python -m pip install django
- 它会在虚拟环境中自动下载并安装最新的 Django 版本。
Installing Django in Pycharm
如何安装 Django rest 框架
Django rest 框架是一个灵活而强大的库，用于在 Django 中构建 web APIs。所以，在安装 Django rest 框架之前，我们必须先安装 python 和 Django。
成功安装 python 和 Django 后，安装 Django rest 框架就超级容易了。我们可以使用 python 中的 PIP 很容易地安装它。这一步对于所有的操作系统都是一样的。所以，这是我们可以用来安装 Django rest 框架的 pip 命令。
pip install djangorestframework
执行该命令后，Dango rest 框架库将自动下载并安装在系统中。
Example
你可能也喜欢阅读下面的文章列表。
所以在本教程中，我们已经讨论了如何安装 Django ，如何在 Windows、Linux 或 Mac 中安装 Django。我们还讨论了以下主题。
- 如何在 Windows 中安装 Django
- 如何在 Linux 中安装 Django
- 如何在 Mac 上安装 Django
- 如何检查 Django 版本
- 如何在 pycharm 中安装 Django
- 如何在 visual studio 代码中安装 Django
- 如何安装 Django rest 框架
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何安装 matplotlib python
原文：https://pythonguides.com/how-to-install-matplotlib-python/
在本 Python 教程中，我们将讨论如何安装 matplotlib python ，以及在 Python 中使用数据可视化所需的所有依赖项，我们还将涵盖以下主题:
- 如何安装 matplotlib python
- 如何安装 matplotlib python ubuntu
- 如何安装 matplotlib python 窗口
- 如何安装 matplotlib python mac
- 如何安装 matplotlib python conda
- 如何安装 matplotlib python pip
- 如何安装 matplotlib python venv
- 如何安装 matplotlib python3
- 如何安装 matplotlib python2
目录
- 如何安装 matplotlib python
- 如何安装 matplotlib python ubuntu
- 如何安装 matplotlib python windows
- 如何安装 matplotlib python mac
- 如何安装 matplotlib python conda
- 如何安装 matplotlib python3
- 如何安装 matplotlib python2
如何安装 matplotlib python
可以安装 matplotlib 库在所有常用的三大操作系统中用 python 使用:
- Linux (Ubuntu，redhat 等。,)
- Windows 操作系统
- 马科斯
您可以在这些操作系统中安装 matplotlib，方法是使用 pip 命令(使用 python 包管理器)来安装已发布的轮包，或者从 python 和 matplotlib 的其他安装中为 matplotlib 创建一个单独的虚拟环境，或者使用另一个环境，如 anaconda ，它提供 conda 作为包管理器来安装包。
注—
Wheel Package是 python 的内置包格式，具有。whl 文件扩展名。它包含与 python 安装包及其元数据相关的所有文件。- 虚拟环境在 python 中只是一个命名的开发目录，包含所有必需的依赖项和安装在该目录中的包。
- Anaconda 是 python 的一个发行版，它提供了一个基于科学研究开发 python 项目的环境。
Read: modulenotfounderror:没有名为“matplotlib”的模块
如何安装 matplotlib python ubuntu
如何在 Linux (Ubuntu)中使用 pip 安装 matplotlib python
你可以在任何一个 Linux 发行版中安装 matplotlib for python，包括 Ubuntu ，通过使用 python 包管理器，它提供了 pip 命令来安装任何为 python 发布的轮子包。首先，确保您已经在系统中安装了 python 和 pip。如果你没有安装 pip，首先你必须安装它，然后使用 pip 安装 matplotlib。在终端中执行以下命令:
python -m pip install -U pip
python -m pip install -U matplotlib [--prefer-binary]
在上述命令中，
- 第一个命令更新 pip python 包管理器。
- 在第二个命令中，–prefere-binary是可选的，如果不包括–prefere-binary 选项的命令无法安装或更新 matplotlib 包。然后添加这个选项，它会根据你安装的操作系统和 python 的预编译轮选择最新的版本。
您可以通过在终端中执行以下命令来检查 matplotlib 是否已成功安装在您的系统上:
import matplotlib
matplotlib.__version__
如何安装 matplotlib python Linux 包管理器
在 Linux 中，python 预装在 OS 发行版中，如果您使用的是该版本，那么您可以通过使用 Linux 包管理器来安装 matplotlib，不同的发行版有不同的包管理器:
- 对于 Debian / Ubuntu，您可以使用以下命令:
sudo apt-get install python3-matplotlib
- 对于 Red Hat，您可以使用以下命令:
sudo yum install python3-matplotlib
- 对于 Fedora，您可以使用以下命令:
sudo dnf install python3-matplotlib
- 对于 Arch，您可以使用以下命令:
sudo pacman -S python-matplotlib
如何在 Linux 上安装 matplotlib python venv
可以在 Linux 的虚拟开发环境中安装 matplotlib，通过使用 Python 的虚拟环境 venv 创建一个虚拟环境。下面给出了执行此操作的步骤:
- 创建虚拟环境:
python -m venv <directory_path>
上面的命令在位置 <目录 _ 路径> 创建了一个虚拟环境(专用目录)。
- 激活创建的环境:
source <directory_path>/bin/activate
上面的命令激活了开发环境。无论何时开始使用 matplotlib，都必须首先在 shell 中激活开发环境。
- 从位于https://github.com/matplotlib/matplotlib.git的 git 获取 matplotlib 的最新版本。以下命令将 matplotlib 的最新源代码检索到当前工作目录中:
git clone https://github.com/matplotlib/matplotlib.git
- 现在，在可编辑(开发)模式下安装 matplotlib，因为开发模式允许 python 从您的开发环境源目录导入 matplotlib，即从 git 源导入，这允许您在源发生任何更改后导入最新版本的 matplotlib，而无需重新安装。以下命令允许您这样做:
python -m pip install -ve
现在，您可以导入 matplotlib 包并在您的开发环境中使用它。
如何安装 matplotlib python windows
如何在 Windows 中安装 matplotlib python pip
您可以在 Windows OS 中安装 matplotlib for python，方法是使用 python 包管理器，它提供了 pip 命令来安装为 python 发布的任何 wheel 包。
首先，确保您已经在系统中安装了 python 和 pip。如果你没有安装 pip，首先你必须安装它，然后使用 pip 安装 matplotlib。在 cmd 中执行以下命令:
python -m pip install -U pip # Update the pip package manager
python -m pip install -U matplotlib [--prefer-binary]
上面的命令与我们在上面的主题中在 Linux 发行版中所做的一样。
您可以通过在 cmd 中执行以下命令来检查 matplotlib 是否已成功安装在您的系统上:
import matplotlib
matplotlib.__version__
如何在 Windows 中安装 matplotlib python venv
您可以在 python 中创建一个虚拟环境,并按照给定的步骤对其进行配置，以便在 Windows 中开发 matplotlib:
- 创建虚拟环境:
python -m venv <directory_path>
上面的命令在位置 <目录 _ 路径> 创建了一个虚拟环境(专用目录)。
- 激活创建的环境:
source <directory_path>/bin/activate.bat
# Note that, this command was different for Linux distribution
上面的命令激活了开发环境。无论何时开始使用 matplotlib，都必须首先在 shell 中激活开发环境。
- 所有步骤都与 Linux 发行版相同:
# Retrieve the latest version of matplotlib from the git source
git clone https://github.com/matplotlib/matplotlib.git
# Install matplotlib in the editable mode
python -m pip install -ve
前面的主题已经讨论了上述命令。
如何安装 matplotlib python mac
如何在 macOS 中安装 matplotlib python pip
你可以在一个 macOS 中安装 python 的 matplotlib，通过使用 python 包管理器，它提供了 pip 命令来安装任何为 python 发布的轮子包。首先，确保您已经在系统中安装了 python 和 pip。如果你没有安装 pip，首先你必须安装它，然后使用 pip 安装 matplotlib。在 cmd 中执行以下命令:
python -m pip install -U pip # Update the pip package manager
python -m pip install -U matplotlib [--prefer-binary]
上面的命令也与我们为 Linux 发行版所做的和讨论的一样。
您可以通过在终端中执行以下命令来检查 matplotlib 是否已成功安装在您的系统上:
import matplotlib
matplotlib.__version__
如何在 macOS 中安装 matplotlib python venv
在 macOS 中为 matplotlib python 创建专用开发环境的步骤与我们为 Linux 发行版所做和讨论的步骤相同。
# You can see that all the steps are same, as done for the Linux
# Creating a development environment
python -m venv <directory_path>
# Activate the created environment
source <directory_path>/bin/activate
# Retrieve the latest version of matplotlib from the git source
git clone https://github.com/matplotlib/matplotlib.git
# Install matplotlib in the editable mode
python -m pip install -ve
如何安装 matplotlib python conda
Matplotlib 也是一些主要 Python 发行版的一部分，比如 anaconda。因此，您可以在 python 的这个发行版中安装 matplotlib，它为 matplotlib 提供了环境。Anaconda 适用于所有三大操作系统，Linux、Windows、macOS。您可以使用 anaconda 提供的包管理器 conda 来安装 matplotlib。您必须在系统中安装了 anaconda，然后才能在 cmd /conda 提示符/终端中执行以下命令:
conda install matplotlib
上面的命令将从 anaconda 主通道在 anaconda 开发环境中安装 matplotlib。
您也可以通过执行下面的命令从 anaconda 社区通道安装 matplotlib。
conda install -c conda-forge matplotlib
如何安装 matplotlib python3
如果你使用 python3，那么使用 pip3 代替 pip 来安装 matplotlib。所有安装过程与上述主题中给出的相同，只是使用 pip3 代替。
如何安装 matplotlib python2
如果你使用 python2，那么使用 pip 来安装 matplotlib。所有安装过程与上述主题中给出的相同。
你可能也喜欢读下面的文章。
在本 Python 教程中，我们讨论了如何安装 matplotlib python ，以及在 Python 中使用数据可视化所需的所有依赖项，我们还讨论了以下主题:
- 如何安装 matplotlib python
- 如何安装 matplotlib python ubuntu
- 如何安装 matplotlib python 窗口
- 如何安装 matplotlib python mac
- 如何安装 matplotlib python conda
- 如何安装 matplotlib python pip
- 如何安装 matplotlib python venv
- 如何安装 matplotlib python3
- 如何安装 matplotlib python2
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何在蟒蛇龟中做出笑脸
原文：https://pythonguides.com/how-to-make-a-smiling-face-in-python-turtle/
我们正在建立一个项目，在这个项目中，我们将在 蟒蛇龟 库中学习如何制作笑脸。在这里，我们将拆分代码，解释如何使用函数和方法制作笑脸。
如何在蟒蛇龟中做出笑脸
现在我们正在向前推进，开始这个项目。这里我们只是导入库。
from turtle import *
import turtle
现在我们正在为这只乌龟创建一个对象。
tur = turtle.Turtle()
现在我们使用函数来创建一只眼睛。为了创建一只眼睛，我们必须使用以下函数。
tur.down()用于在乌龟的帮助下在屏幕上开始绘图。tur.fillcolor(color)用于填充我们在屏幕上绘制的形状的颜色。tur.begin_fill()用于开始填充形状中的颜色。- tur.circle(半径)用来画圆的形状。
tur.end_fill()用于停止填充颜色。tur.up()用于停止绘图。
def eyes(color, radius):
tur.down()
tur.fillcolor(color)
tur.begin_fill()
tur.circle(radius)
tur.end_fill()
tur.up()
现在我们使用函数来制作一个脸的形状。为了做一个面，我们使用下面的函数。
- tur.fillcolor('青色')用于填充圆形人脸形状内部的颜色。
tur.begin_fill()用于开始填充形状。tur.circle(100)用来画圆的形状。tur.end_fill()用于停止填充颜色。tur.up()用于停止绘图。
tur.fillcolor('cyan')
tur.begin_fill()
tur.circle(100)
tur.end_fill()
tur.up()
现在我们正在使用函数来制作眼睛的形状。为了画一只眼睛，我们使用下面的函数。
- tur.goto(-40，120) 用于将乌龟移动到准确的位置。
- 眼睛('白色'，15) 用来给眼睛的外部加上白色。
tur.goto(-40, 120)
eyes('white', 15)
tur.goto(-37, 125)
eyes('blue', 5)
tur.goto(40, 120)
eyes('white', 15)
tur.goto(40, 125)
eyes('blue', 5)
现在我们使用函数来制作鼻子的形状。为了画一个鼻子，我们使用下面的函数。
tur.goto(0，75) 用于将乌龟移动到其准确位置。
眼睛(‘红色’，8) 用来给眼睛赋予红色。
tur.goto(0, 75)
eyes('red', 8)
现在我们使用函数来制作嘴巴的形状。为了画一个嘴，我们使用下面的函数。
- tur.goto(0，75) 用于将乌龟移动到其准确位置。
tur.down()用于在乌龟的帮助下在屏幕上开始绘图。tur.right()用于向右侧改变位置。tur.circle()用来画圆的形状。tur.up()用于停止绘图。
tur.goto(-40, 85)
tur.down()
tur.right(90)
tur.circle(40, 180)
tur.up()
现在我们使用函数来制作舌头的形状。为了画舌头，我们使用了下面的函数。
- tur.goto(0，75) 用于将乌龟移动到其准确位置。
tur.down()用于在乌龟的帮助下在屏幕上开始绘图。tur.right()用于向右侧改变位置。- tur.fillcolor('red') 用于填充舌头内部的红色。
tur.circle(100)用来画圆的形状。tur.end_fill()用于停止填充颜色。tur.hideturtle()用于隐藏用来绘制形状的乌龟。
tur.goto(-10, 45)
tur.down()
tur.right(180)
tur.fillcolor('red')
tur.begin_fill()
tur.circle(10, 180)
tur.end_fill()
tur.hideturtle()
turtle.done()
此后分割代码，解释我们如何使用 python turtle 制作笑脸，我们将看到运行整个代码后的输出。
from turtle import *
import turtle
tur = turtle.Turtle()
def eyes(color, radius):
tur.down()
tur.fillcolor(color)
tur.begin_fill()
tur.circle(radius)
tur.end_fill()
tur.up()
tur.fillcolor('cyan')
tur.begin_fill()
tur.circle(100)
tur.end_fill()
tur.up()
tur.goto(-40, 120)
eyes('white', 15)
tur.goto(-37, 125)
eyes('blue', 5)
tur.goto(40, 120)
eyes('white', 15)
tur.goto(40, 125)
eyes('blue', 5)
tur.goto(0, 75)
eyes('red', 8)
tur.goto(-40, 85)
tur.down()
tur.right(90)
tur.circle(40, 180)
tur.up()
tur.goto(-10, 45)
tur.down()
tur.right(180)
tur.fillcolor('red')
tur.begin_fill()
tur.circle(10, 180)
tur.end_fill()
tur.hideturtle()
turtle.done()
运行上面的代码后，我们得到下面的输出，我们可以看到一张可爱的笑脸出现在屏幕上。
How to make a smiling face in python turtle
所以，在本教程中，我们已经举例说明了如何在 python turtle 中制作笑脸。此外，我们还讨论了本教程中使用的全部代码。
还有，多看看一些和 Python Turtle 相关的教程。
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何在 Python Pygame 中将屏幕放在特定位置
原文：https://pythonguides.com/how-to-put-screen-in-specific-spot-in-python-pygame/
在本 Python 教程中，我们将学习如何在 python pygame 中将屏幕放在特定的位置。为了在 python pygame 中控制对象在屏幕上的位置，我们使用了 python 中的 OS 模块。
- Pygame 使用 SDL (Simple DirectMedia Layer ),这是一个用于控制多媒体的跨平台库，广泛用于游戏。
- 在
os.environ字典中有一个键SDL_VIDEO_WINDOW_POS，我们可以给它分配 x 和 y 值。这将把屏幕放在 python pygame 中的特定位置。 - 分配给 X 的值将使屏幕向右或向左移动，而分配给 Y 的值将使屏幕上下移动。
- 下面是如何在 python pygame 中将屏幕放在特定位置的语法。在这个语法中，我们创建了一个函数，然后在 pygame 中调用这个函数。
def dynamicwinpos(x=500, y=100):
os.environ['SDL_VIDEO_WINDOW_POS'] = "%d,%d" % (x,y)
pygame.init()
# calling function
dynamicwinpos()
现在，我们知道了如何在 python pygame 中将屏幕放在特定的位置，让我们通过将这些知识放在一个例子中来进行更多的探索。
如何在 Python Pygame 中将屏幕放在特定位置
在这个项目中，我们使用了我们博客中创建的游戏使用 Python Pygame(井字游戏)创建一个游戏。这是一种很受欢迎的双人井字游戏，连续占据 3 个位置的玩家获胜。
dynamicwinpos()函数接受 x 和 y 位置作为参数。在我们的例子中，我们提供了默认值 x=500，y=100。os.environ['SDL_VIDEO_WINDOW_POS'] = "%d,%d" % (x,y)在这个代码中os.environ是一个字典SDL_VIDEO_WINDOW_POS是一个键。X&Y是键值。- 这个函数在初始化 pygame
pygame.init()后立即被调用。现在每次执行程序时，屏幕都被放到 python pygame 中的特定位置(x & y)。
import pygame, sys
import numpy as np
import os
#function to put the screen in specific spot in python pygame
def dynamicwinpos(x=500, y=100):
os.environ['SDL_VIDEO_WINDOW_POS'] = "%d,%d" % (x,y)
pygame.init()
#function calling
dynamicwinpos()
WIDTH = 600
HEIGHT = 600
LINE_WIDTH = 15
WIN_LINE_WIDTH = 15
BOARD_ROWS = 3
BOARD_COLS = 3
SQUARE_SIZE = 200
CIRCLE_RADIUS = 60
CIRCLE_WIDTH = 15
CROSS_WIDTH = 25
SPACE = 55
RED = (255, 0, 0)
BG_COLOR = (20, 200, 160)
LINE_COLOR = (23, 145, 135)
CIRCLE_COLOR = (239, 231, 200)
CROSS_COLOR = (66, 66, 66)
screen = pygame.display.set_mode( (WIDTH, HEIGHT))
pygame.display.set_caption( 'TIC TAC TOE' )
screen.fill( BG_COLOR)
board = np.zeros( (BOARD_ROWS, BOARD_COLS))
def draw_lines():
pygame.draw.line(screen, LINE_COLOR, (0, SQUARE_SIZE), (WIDTH, SQUARE_SIZE), LINE_WIDTH)
pygame.draw.line(screen, LINE_COLOR, (0, 2 * SQUARE_SIZE), (WIDTH, 2 * SQUARE_SIZE), LINE_WIDTH)
pygame.draw.line(screen, LINE_COLOR, (SQUARE_SIZE, 0), (SQUARE_SIZE, HEIGHT), LINE_WIDTH )
pygame.draw.line(screen, LINE_COLOR, (2 * SQUARE_SIZE, 0), (2 * SQUARE_SIZE, HEIGHT), LINE_WIDTH)
def draw_figures():
for row in range(BOARD_ROWS):
for col in range(BOARD_COLS):
if board[row][col] == 1:
pygame.draw.circle( screen, CIRCLE_COLOR, (int( col * SQUARE_SIZE + SQUARE_SIZE//2 ), int( row * SQUARE_SIZE + SQUARE_SIZE//2 )), CIRCLE_RADIUS, CIRCLE_WIDTH )
elif board[row][col] == 2:
pygame.draw.line( screen, CROSS_COLOR, (col * SQUARE_SIZE + SPACE, row * SQUARE_SIZE + SQUARE_SIZE - SPACE), (col * SQUARE_SIZE + SQUARE_SIZE - SPACE, row * SQUARE_SIZE + SPACE), CROSS_WIDTH )
pygame.draw.line( screen, CROSS_COLOR, (col * SQUARE_SIZE + SPACE, row * SQUARE_SIZE + SPACE), (col * SQUARE_SIZE + SQUARE_SIZE - SPACE, row * SQUARE_SIZE + SQUARE_SIZE - SPACE), CROSS_WIDTH )
def mark_square(row, col, player):
board[row][col] = player
def available_square(row, col):
return board[row][col] == 0
def is_board_full():
for row in range(BOARD_ROWS):
for col in range(BOARD_COLS):
if board[row][col] == 0:
return False
return True
def check_win(player):
for col in range(BOARD_COLS):
if board[0][col] == player and board[1][col] == player and board[2][col] == player:
draw_vertical_winning_line(col, player)
return True
for row in range(BOARD_ROWS):
if board[row][0] == player and board[row][1] == player and board[row][2] == player:
draw_horizontal_winning_line(row, player)
return True
if board[2][0] == player and board[1][1] == player and board[0][2] == player:
draw_asc_diagonal(player)
return True
if board[0][0] == player and board[1][1] == player and board[2][2] == player:
draw_desc_diagonal(player)
return True
return False
def draw_vertical_winning_line(col, player):
posX = col * SQUARE_SIZE + SQUARE_SIZE//2
if player == 1:
color = CIRCLE_COLOR
elif player == 2:
color = CROSS_COLOR
pygame.draw.line( screen, color, (posX, 15), (posX, HEIGHT - 15), LINE_WIDTH )
def draw_horizontal_winning_line(row, player):
posY = row * SQUARE_SIZE + SQUARE_SIZE//2
if player == 1:
color = CIRCLE_COLOR
elif player == 2:
color = CROSS_COLOR
pygame.draw.line( screen, color, (15, posY), (WIDTH - 15, posY), WIN_LINE_WIDTH )
def draw_asc_diagonal(player):
if player == 1:
color = CIRCLE_COLOR
elif player == 2:
color = CROSS_COLOR
pygame.draw.line( screen, color, (15, HEIGHT - 15), (WIDTH - 15, 15), WIN_LINE_WIDTH )
def draw_desc_diagonal(player):
if player == 1:
color = CIRCLE_COLOR
elif player == 2:
color = CROSS_COLOR
pygame.draw.line( screen, color, (15, 15), (WIDTH - 15, HEIGHT - 15), WIN_LINE_WIDTH )
def restart():
screen.fill( BG_COLOR )
draw_lines()
for row in range(BOARD_ROWS):
for col in range(BOARD_COLS):
board[row][col] = 0
draw_lines()
player = 1
game_over = False
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
if event.type == pygame.MOUSEBUTTONDOWN and not game_over:
mouseX = event.pos[0]
mouseY = event.pos[1]
clicked_row = int(mouseY // SQUARE_SIZE)
clicked_col = int(mouseX // SQUARE_SIZE)
if available_square( clicked_row, clicked_col ):
mark_square( clicked_row, clicked_col, player )
if check_win( player ):
game_over = True
player = player % 2 + 1
draw_figures()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_r:
restart()
player = 1
game_over = False
pygame.display.update()
输出:
在这个输出中，我们运行了这个程序 3 次，每次我们都在 python pygame 的 dynamicwinpos()函数中更改了 x 和 y 的值。结果屏幕改变了它的位置。
How to Put Screen in Specific Spot in Python Pygame
在本教程中，我们学习了如何在 python pygame 中将屏幕放置在特定位置。此外，我们已经涵盖了一个项目，以展示我们所学到的东西。
相关 Python 教程:
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何使用 Python Tkinter 获取用户输入并存储在变量中
原文：https://pythonguides.com/how-to-take-user-input-and-store-in-variable-using-python-tkinter/
在本节中，我们将学习如何使用 Python Tkinter 获取用户输入并将其存储在变量中。此外，我们将涵盖这些主题。
- Python Tkinter 中的变量是什么
- Python Tkinter 中的入口小部件
使用 Python Tkinter 中的入口小部件获取用户输入，并存储在一个变量中
在本节中，我们将学习变量，还将了解创建变量 Python 的规则。在我们学习将用户输入存储在变量中之前，理解变量是很重要的。
- 变量是为了存储值而创建的保留内存位置。
- 计算机会记住存储在变量中的任何东西，这些东西可以在程序中随时使用。但必须在范围内。
- 创建变量有一些规则:
- 蛇 _ 案要跟。这意味着单词应该用下划线分开。例如:player_name。
- 变量必须以 l
owercase或下划线开头。示例:_ 玩家姓名，玩家姓名 - 变量中只允许有字母、数字 &、下划线。不允许使用除下划线以外的特殊字符。
- 变量区分大小写。例子:
p层和P层是两个不同的变量。 - Python 有保留关键字像 class、int、str 等。不应使用保留关键字中的名称创建变量。
您可能还会喜欢以下 Python 变量教程:
Python Tkinter 中的入口小部件
Python 入口小部件是广泛使用的小部件，因为它用于接收用户的输入。因此，在存储输入之前，我们需要学习如何从用户那里获取输入。你可以在 Python Tkinter 中查看关于入口小部件的文章。
- 入口小部件用于接收用户输入。
- 填写表单时，您可以在条目小部件中输入详细信息的框。
- 命令创建入口小部件
Entry(master).pack() - 为了存储入口小部件的值，我们使用了变量。只需在创建小部件之前提供任何名称，该名称将存储输入的值。
- 确保所选择的名称遵循变量规则，如上面关于变量的部分所述。
- 稍后，可以使用
get()方法获取这个存储的值。 - 在下面的节目中，我们用到了目前为止所学的所有东西。我们已经使用了变量、入口小部件和 get 方法。
代码:
在这段代码中，我们创建了一个简单的应用程序，其中用户需要为玩家注册提供一个名字。他们将在入口小部件中提供输入。该值将存储在名为“player_name”的变量中。
点击按钮后，将调用一个函数，该函数将从入口小部件中提取值，并将其显示在标签小部件中。使用 get() 方法从入口小部件中提取信息。
from tkinter import *
ws = Tk()
ws.title("PythonGuides")
ws.geometry('400x300')
ws['bg'] = '#ffbf00'
def printValue():
pname = player_name.get()
Label(ws, text=f'{pname}, Registered!', pady=20, bg='#ffbf00').pack()
player_name = Entry(ws)
player_name.pack(pady=30)
Button(
ws,
text="Register Player",
padx=10,
pady=5,
command=printValue
).pack()
ws.mainloop()
输出:
在这个输出中，名称“nobita”被输入到条目小部件中，当单击按钮时，相同的名称与消息一起显示在标签小部件中。
Take User Input and Store in Variable using Python Tkinter
您可能会喜欢以下 Python 教程:
- 如何在 Python 中将 dictionary 转换成 JSON
- 如何在 Turtle Python 中附加图像
- 检查一个列表是否存在于另一个列表中 Python
- Python 向 CSV 写列表
- 如何使用 Python Tkinter 创建倒计时定时器
- 使用 Tkinter 的 Python 注册表
在这一节中，我们学习了接受用户输入并在变量中存储一个值，我们也讨论了这些主题。
- Python Tkinter 中的变量是什么
- Python Tkinter 中的入口小部件
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如果不是 Python 中的条件
在这篇 Python 博客中，您将看到 Python 中 if not 条件的许多用例。
您可以使用带有 if-else 语句的 not 运算符来比较各种条件。下面列出了一些例子。这些例子将帮助你理解如何在一个 if-else 语句中使用 not 操作符。
- Python if not 条件示例
- Python if 不等于 null
- Python 如果不是真的
- Python 如果不是字母表
- Python if 不等于 string
- Python if not 空字符串
- Python 如果不等于两个值
- Python if 不等于多个值
- Python if 不等于整数
- Python 如果不在列表中
- 如果不存在，则添加 Python 列表
- 如果不在列表中，Python 会引发错误
- Python 如果没有什么也不做
- Python 如果不是 startswith
- Python 如果不存在文件
- Python 如果文件不存在，则创建
目录
- Python if not 条件示例
- Python if 不等于 null
- Python if not true
- Python 如果不是字母表
- Python if 不等于 string
- Python 如果不是空字符串
- Python 如果不等于两个值
- Python if 不等于多个值
- Python if 不等于整数
- Python 如果不在列表中
- 如果不存在，添加 Python 列表
- 如果不在列表中，Python 会引发错误
- Python 如果不做什么也不做
- Python if not startswith
- Python 如果不存在文件
- Python 如果文件不存在，创建
Python if not 条件示例
让我们看一个 Python 中 if not 条件的简单例子。
variable = input('Enter a value:')
if not variable:
print('True')
else:
print('False')
If not condition example
在上面的例子中，如果变量为空，它将满足 If-not 语句，语句的 True 部分将被执行。
所以，当我执行上面的程序，没有给出任何输入的时候，if-else 语句的 True 部分起作用了。
当我用用户输入再次执行程序时，if-else 语句的错误部分起作用了。
另外，检查:使用 python 从 URL 下载 zip 文件
Python if 不等于 null
在 Python 中有 None 而不是 Null 。所以我们必须检查变量是否包含一个 None 值。有不同的方法来检查它。
例 1:
variable = None
if variable is not None:
print('Variable does not contain None')
else:
print('Variable contains None')
在上面的代码中，我们比较了变量和 None 值。我使用了不是来检查变量是否包含一个非值。
“ if 变量不是 None”语句等同于布尔型 False 。结果，if-else 语句的假部分被执行。
Output when variable contains a None value
例 2:
variable = None
if not variable:
print('Variable contains None')
else:
print('Variable does not contain None')
在上面的代码中，if-not 语句相当于 True ，因为变量不包含任何值，并且存储的是 None 。因此，如果执行语句，则的真块内的语句。
Python if-not statement
替代方法:
您也可以使用而不是 等于的运算符(！=)而不是 if-not 语句。例如:
variable = None
if variable != None:
print('Variable does not contain None')
else:
print('Variable contains None')
在上面的代码中，if 语句相当于 False 。
Python Not Equal to operator
另一种方法是使用 if 语句，而不使用 Not 运算符。看看下面的代码:
variable = None
if variable:
print('Variable does not contain None')
else:
print('Variable contains None')
if 语句只是检查变量对于任何值是否是强的。变量不存储任何值，即它等同于 None 。因此，if 语句返回假。
阅读: Python 返回函数
Python if not true
if not True 语句等价于 if False 。因此，应该使用 if False 而不是 if not True。但是，您可以使用 if not True 语句，如下面的代码所示:
variable = False
if variable is not True:
print('Variable stores False')
else:
print('Variable stores True')
Python if not True
替代方法:可以用 if False 代替 if Not True。结果会是一样的。
variable = False
if variable is False:
print('Variable stores False')
else:
print('Variable stores True')
Python if False
Python 如果不是字母表
在本节中，您将看到一个例子，在这个例子中，我使用了 if not 语句来验证一个变量是否存储了一个字母表。
在下面的例子中，如果用户输入 Y 作为输入，用户将被要求输入两个数字，两个数字的和将被打印出来。如果给定任何其他输入值，程序将终止。
choice = input('Enter Y to find the sum of numbers: ')
if choice != 'Y':
exit()
else:
num1 = float(input('Enter first number: '))
num2 = float(input('Enter second number: '))
print('Sum is: ', num1 + num2)
Validation of an alphabet using if not
这样，您可以使用 if not 语句来验证字母表。
阅读: Python 在字符串中查找数字
Python if 不等于 string
在本节中，您将学习如何在 Python 中比较 if-else 语句中的字符串。
如果要验证变量是否存储字符串数据类型值，可以使用 type()函数获取变量的数据类型。例如:
str1 = 'Hello'
if str1 != 'Hello':
print('invalid message')
else:
print('valid message')
Comparing a string using not equal to operator
使用不是:
您还可以将“ is not ”与 if-else 语句一起使用，而不是使用不等于运算符。例如，上面的代码可以重写为:
str1 = 'Hello'
if str1 is not 'Hello':
print('invalid message')
else:
print('valid message')
Python 如果不是空字符串
让我们看一个例子，在这个例子中，我们可以在 Python 中的 if-else 语句中使用 not 运算符来验证变量是否包含空字符串。
string = input('Enter a username:')
if not string:
print('Username cannot be empty! Try again')
else:
print('A valid username')
Python if not for validating an empty string
我已经执行了两个测试用例的代码。您可以看到两个测试用例的输出，即空字符串和非空字符串。
在这种情况下，也可以使用不等于运算符(！idspnonenote)。=).
这样，您可以在 if-else 语句中使用而不是操作符来验证空字符串。
阅读: Python 在字符串中查找数字
Python 如果不等于两个值
如果您想检查存储在变量中的值是否不等于两个指定值中的一个，您可以使用逻辑 和或逻辑或运算符，具体取决于您的需求。
例如:
username = input('Enter the username: ')
password = input('Enter password : ')
if username != 'admin' or password != 'admin123':
print('Username and password combination is wrong')
else:
print('Correct username and password combination')
在上面的代码中，我使用了带有不等于运算符(！idspnonenote)的 if 语句。=)来比较用户名和密码变量。
Python if not equal to two values
Python if 不等于多个值
在 Python 中，还可以使用 if not equal to 语句将变量与两个以上的值进行比较:
例如:
grade= input('Enter a grade: ')
if grade != 'A' and grade != 'B' and grade != 'C' and grade != 'D' and grade != 'E':
print('Fail')
else:
print('Pass')
在上面的代码中，我已经编写了 if not 语句，在逻辑和运算符的帮助下，将等级变量中的值与多个值进行比较。
Python if not equal to multiple values
阅读: Python 统计文件中的字数
Python if 不等于整数
您可以使用不等于运算符(！=)来比较两个整数。例如，下面的 Python 代码片段检查一个数字是偶数还是奇数。
number = int(input('Enter a number: '))
if number % 2 != 0:
print('The number is odd')
else:
print('The number is even')
Python if not equal to for integers
这样，您可以使用不等于运算符来比较整数。
如果您想在 if-else 中使用而不是操作符，则上面的内容变成:
number = int(input('Enter a number: '))
if number % 2 is not 0:
print('The number is odd')
else:
print('The number is even')
Python 如果不在列表中
在这一节中，我将解释如何检查一个条目是否存储在 Python 中的列表中。
您可以对列表使用“ not in ”运算符来检查列表中是否存在某个项目。
例如，看看下面的 Python 代码:
list1=['a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U']
letter = input('Enter an alphabet: ')
if letter not in list1:
print('The entered alphabet is a consonant')
else:
print('The entered alphabet is a vowel')
- 上面的程序将一个字母表作为输入，并返回输出，告诉输入的字母表是元音还是辅音。
- 我已经定义了一个存储所有元音的列表。将输入的字母表与列表中的元音进行比较，并相应地返回结果。
if not in list validation in python
这样，您可以在 python 中的 if-else 语句中使用“ not in 运算符来验证列表中的元素。
另外，检查 Python 中的 Case 语句
如果不存在，添加 Python 列表
现在让我们学习如何将一个项目添加到一个列表中，如果它还不在列表中的话。当您希望列表中只有唯一的元素时，可能需要此功能。
看看下面的代码:
list1 = ['1201', '1202', '1203', '1204', '1205', '1206', '1207']
element = input('Enter the employee ID: ')
if element not in list1:
list1.append(element)
print('Employee ID added')
else:
print('Employee ID already exists')
print(list1)
- 该列表包含一些独特的元素。
- 当从控制台读取新元素时，首先在列表中搜索它。
- 只有当它不在列表中时，它才被添加到列表中。
- 因此，列表将总是包含唯一的元素。
Add element in the list if not present
如果不在列表中，Python 会引发错误
在 Python 中使用 raise 关键字，也可以在列表中找不到元素时引发错误。看看下面的例子:
list1= ['Adams', 'Eva', 'Rose', 'Mary', 'John']
element = input('Enter a name to search in the list: ')
if element not in list1:
raise Exception('Element not found in the list')
else:
print('Element found in the list')
- 在上面的代码中，一个元素被当作用户输入，并在列表中进行搜索。
- 如果在列表中找不到该元素，则会引发一条自定义消息。否则，如果在列表中找到该元素，程序将执行而不会出现任何错误。
Raise an error if the element is not in list
正如您在输出中看到的，当在列表中找不到提供的值时，会引发一个异常。
Python 如果不做什么也不做
当您想使用 if-else 语句，但不想执行 if 或 else 块中的任何代码时，您可能会遇到这种情况。在这种情况下，您可以使用 pass 语句。
pass 语句为空语句。当解释器读取这个时，它不执行任何操作。
当您不想编写代码的任何部分时，通常使用此语句。例如，定义函数并在以后编写它的功能。
现在让我们看看如何将它与 if-else 语句一起使用。考虑我们在上一节中讨论的例子。我对它做了一点小小的改动。
list1 = ['1201', '1202', '1203', '1204', '1205', '1206', '1207']
element = input('Enter the employee ID: ')
if element not in list1:
if not element:
pass
else:
list1.append(element)
print('Employee ID added')
else:
print('Employee ID already exists')
print(list1)
第一个验证是检查元素是否已经存在于列表中。
现在我已经添加了第二个验证，它将检查新元素是否为空。如果新元素为空，则不应添加。因此，我使用了 pass 语句。
如果新元素为空，将执行 pass 语句，If 块的 True 部分将不执行任何操作，控制将移到下一行。
Execution of the pass statement
这样，你可以使用 pass 语句跳过任何代码块。
Python if not startswith
startwith() 函数是一个字符串函数，它检查一个字符串是否以指定的字符串值开始。
在这一节中，我将展示一个例子，说明如何在 if-else 语句中使用这个函数的 not 操作符。
string1= input('Enter a name that starts with "A": ')
if not string1.startswith('A'):
print('Invalid Name')
else:
print('The name is: ', string1)
在上面的例子中，名字只有以“A”开头才有效，否则名字不被接受。
Using the startswith() function
这样，您可以在 Python 程序中使用 startswith()函数进行字符串验证。
Python 如果不存在文件
要检查文件是否存在于本地文件系统中，需要使用 Python 中的 os 模块。该模块包含用于与本地操作系统交互的库。
您可以使用 os.path.isfile() 函数来检查文件是否存在于本地文件系统中。您只需要在函数中指定文件的路径。
例如，我在“C:\ Users \ Blades \ Documents \ zip files . txt”位置有一个名为 zipfiles.txt 的文本文件。我写了下面的 Python 代码片段，它将检查这个文件是否存在于指定的路径中。
import os
if not os.path.isfile(r'C:\Users\Blades\Documents\zipfiles.txt'):
print('The specified file does not exist')
else:
print('The specified file exists')
如果文件存在，将返回一个真值。
Check if the file is present in the local file system
现在，如果我指定一个不存在的文件，将返回一个假值。
import os
if not os.path.isfile(r'C:\Users\Blades\Documents\random.txt'):
print('The specified file does not exist')
else:
print('The specified file exists')
File not found in the local file system
因此，通过这种方式，您可以检查文件是否存在于本地文件系统中。
Python 如果文件不存在，创建
如果想用 Python 在本地文件系统创建一个文件，可以使用 open() 函数。
文件可以通过两种方式打开:
- 写入模式:覆盖之前的文件内容。
- 追加模式:向文件追加新数据，不丢失旧数据。
如果想要创建并打开一个尚不存在的文件，可以使用 open()函数中的两个选项之一:
w+:用于创建一个不存在的文件，并以写模式打开它。a+:用于创建一个不存在的文件，并以追加模式打开。
例如，要创建一个不存在的新文件并以写模式打开它，可以使用下面的代码片段:
# Opening the file in write mode
file = open(<file name>, 'w+')
# Writing data in the file
file.write(<data to be written in the file>)
# Closing the file after the contents are written
file.close()
如果你想在附加模式下打开你的文件，只需用“ a+ 替换“ w+ ”。
例如，下面的代码会将数据写入一个名为 new_file.txt 的文件(如果它存在的话)。如果文件不存在，它将被创建。
file_name = 'new_file.txt'
# Opening the file in write mode
file = open(file_name, 'w+')
# Writing data in the file
file.write('Sample file contents')
# Closing the file after the contents are written
file.close()
A new file is created
您可以看到在 Python 源文件位置创建了一个包含指定数据的新文件。这样，如果 Python 中不存在新文件，您可以创建一个新文件。
您可能会喜欢以下 Python 教程:
- Python 中的乘法与例题
- 如何在 Python 中处理 indexerror:字符串索引超出范围
- 解析 Python 时出现意外的 EOF
- Python 对于基数为 10 的 int()无效文字
- 删除 python 中的 Unicode 字符
- Python 中的注释行
- 在 Python 中检查列表是否为空
因此，在这个 Python 教程中，我们已经理解了 Python 中的 if not** 条件的许多用例。**此外，我们还讨论了以下主题。
- Python if not 条件示例
- Python if 不等于 null
- Python 如果不是真的
- Python 如果不是字母表
- Python if 不等于 string
- Python if not 空字符串
- Python 如果不等于两个值
- Python if 不等于多个值
- Python if 不等于整数
- Python 如果不在列表中
- 如果不存在，则添加 Python 列表
- 如果不在列表中，Python 会引发错误
- Python 如果没有什么也不做
- Python 如果不是 startswith
- Python 如果不存在文件
- Python 如果文件不存在，则创建
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Django 模板中的 If 语句
原文：https://pythonguides.com/if-statement-in-django-template/
在这个 Django 教程中，我将解释 if-else 语句在 Django 模板中的用法。我将展示 Django 模板中 if-else 语句的一些用例。
HTML 页面本质上是静态的。然而，Django 模板可以使用各种技术使页面动态化。例如，使用模板标签。
if 模板标记是 Django 中的模板标记之一，可用于呈现特定条件下的 HTML 内容。让我们看看如何在 Django 中使用 if 模板标签。
- 如何在 Django 模板中使用 if 语句
- Django 模板示例中的 If 标记
- Django 模板中的 If else 标签
- Django 模板示例中的 If else 标签
- Django 模板如果等于字符串
- 如果 Django 模板中没有条件
- Django 模板中嵌套的 if else
- Django 模板中的多个 if 条件
- Django 模板中带有 if 条件的 For 循环
目录
- 如何在 Django 模板中使用 if 语句
- Django 模板中的 If 标签示例
- Django 模板中的 If else 标签
- Django 模板中的 If else 标签示例
- Django 模板如果等于字符串
- 如果 Django 模板中没有条件
- 嵌套在 Django 模板中的 if else
- Django 模板中带有 if 条件的循环
如何在 Django 模板中使用 if 语句
在 Django 模板中，if 语句被称为 if 标记。您可以使用这个 if 标记根据特定条件呈现 HTML 内容。if 模板标记的语法是:
{% if <condition> %}
<statement to be executed if the condition returns true>
{% endif %}
在 Django 模板中，您必须关闭 if 模板标签。您可以在 if 模板标记中编写条件。在块内，您可以编写条件返回 True 值时要呈现的语句或 HTML 代码。
让我们借助一个例子来理解这一点。
Django 模板中的 If 标签示例
现在让我们看一个 if 标签的例子。我创建了一个例子，在这个例子中，我将输入两个数字，并在 Django 模板中比较它们。
下面是 Django 模板，我将在其中提交两个数字:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Login Page</title>
</head>
<body>
<form action="" method="get">
<h3> Enter First number: </h3><br>
<input type="text" name="number1" placeholder="Enter First number"><br>
<h3> Enter Second number: </h3><br>
<input type="text" name="number2" placeholder="Enter Second number">
<input type="submit" value="Check">
</form>
{% if number1 > number2 %}
<h4>{{number1}} is greater than {{number2}}</h4>
{% endif %}
</body>
</html>
此外，我在同一个模板中显示结果。你可以看到我的 urls.py 文件:
from django.contrib import admin
from django.urls import path
from . import views
urlpatterns = [
path('admin/', admin.site.urls),
path('', views.index, name = 'index'),
]
现在，在 views.py 文件中，我将接收参数并在同一个模板中呈现它们。这是我的 views.py 文件:
# importing the necessary libraries
from django.shortcuts import render
def index(request):
number1 = int(request.GET.get('number1', 0))
number2 = int(request.GET.get('number2', 0))
dict={
'number1' : number1,
'number2' : number2
}
return render(request, 'index.html', dict)
现在让我们看看输出。
Output when the first number is greater than the second number
当第一个数字大于第二个数字时，您可以看到输出。这样，您可以在 Django 模板中使用 if 标记。
另外，请阅读: Python Django vs Flask
Django 模板中的 If else 标签
同样，您也可以将 else 与 if 标记一起使用。if-else 模板标记的语法是:
{% if <condition> %}
<statements or HTML if the condition returned True>
{% else %}
<statements or HTML if the condition returned False>
{% endif %}
让我们看一个 if-else 模板标签的例子。
Django 模板中的 If else 标签示例
在这个例子中，我将提交一个数字，它将在 Django 模板中比较这个数字是偶数还是奇数。下面是我的 Django 模板，我将取一个数字并检查这个数字。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Login Page</title>
</head>
<body>
<form action="" method="get">
<h3> Enter a number: </h3><br>
<input type="text" name="number" placeholder="Enter a number">
<input type="submit" value="Check">
</form>
{% if number|divisibleby:"2" %}
<h4>The number is even</h4>
{% else %}
<h4>The number is odd</h4>
{% endif %}
</body>
</html>
但在此之前，我先给你看一下 views.py 文件。
# importing the necessary libraries
from django.shortcuts import render
def index(request):
number = int(request.GET.get('number', 0))
return render(request, 'index.html', {'number': number})
在 URLs 文件中，我已经定义了这个页面只重定向到它自己。
from django.contrib import admin
from django.urls import path
from . import views
urlpatterns = [
path('admin/', admin.site.urls),
path('', views.index, name = 'index'),
]
现在让我们看看输出。
Default page output
现在让我们输入一个数字，点击 Check 按钮检查输出。
Output when an odd number is entered
你可以在网址里看到这个数字。数字是奇数，我们相应地得到输出。
这样，您可以在 Django 模板中使用 if-else 标记。
Django 模板如果等于字符串
在这一节中，我将演示一个例子，在这个例子中，我将使用 if-else 模板标记来比较 Django 模板中的字符串。
您也可以使用 ifequal 模板标签，但在 3.1 版之后，该标签已被弃用。因此，不建议使用它。我将演示如何使用 if-else 标签代替 ifequal 标签。
在这个例子中，我将使用两个 Django 模板，即一个用于提交字符串输入，另一个用于呈现结果。第一个模板是index.html:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Login Page</title>
</head>
<body>
<form action="validate" method="get">
<h3> Enter the username: </h3><br>
<input type="text" name="user" placeholder="Enter the username"><br>
<input type="submit" value="Submit">
</form>
</body>
</html>
提交表单时，用户将被重定向到另一个 URL 端点。这个 URL 端点在 urls.py 文件中定义为:
from django.contrib import admin
from django.urls import path
from . import views
urlpatterns = [
path('admin/', admin.site.urls),
path('', views.index, name = 'index'),
path('validate', views.validate, name = 'validate')
]
在 views.py 文件中，我定义了一个名为 validate() 的函数，该函数将从表单中收集数据，并将其呈现在 Django 模板中。 views.py 文件是:
# importing the necessary libraries
from django.shortcuts import render
def index(request):
return render(request, 'index.html')
def validate(request):
username = request.GET['user']
return render(request, 'validate.html', {'username' : username})
最后，我将在名为validate.html的 Django 模板中使用 if-else 模板标记。在表格中输入的用户输入将与一个字符串进行比较，即“admin”，结果将相应地显示出来。Django 模板是:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Show Username</title>
</head>
<body>
{% if username == "admin" %}
<h3>The user is admin user</h3>
{% else %}
<h3>The user is not admin user</h3>
{% endif %}
</body>
</html>
现在让我们启动 Django 服务器并查看输出。
Entering the user input
第一次我会输入一个随机的字符串。让我们看看输出。
Output when the string is not matched
现在让我们在表单输入中输入字符串“admin”并查看输出。
Output when the string is not matched
你可以看到输出是不同的。这样，您可以使用 if-else 模板标签来比较 Django 模板中的字符串。
注意:在模板语言中，使用双引号来处理字符串。
如果 Django 模板中没有条件
让我们看一个例子，我们可以在 Django 中使用带有 if-else 模板标签的 not 操作符。
我将使用 if-else 标记来确定变量是否包含任何值，并相应地呈现输出。
我使用的设置与我在上一节中定义的相同，即所有文件，包括 views.py 、 urls.py 、【index.html】和在本例中也是相同的。这一次我将改变 Django 模板，在那里我将使用 if-else 标签，即validate.html。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Show Username</title>
</head>
<body>
{% if not username %}
<h3>No username is given</h3>
{% else %}
<h3>Username is: {{username}}</h3>
{% endif %}
</body>
</html>
现在让我们看看输出。首先，我不会输入用户名。
Output when no user input is given
我将再次返回上一页，这次将提交一个测试用户名。
Output when user input is given
您可以看到当变量中有一个值时，我得到了 Django 模板中 if-else 模板标签中指定的值。
这样，您可以在 Django 中使用带有 if-else 模板标记的 not 操作符。
嵌套在 Django 模板中的 if else
当我们学习不同编程语言中的 if-else 语句时，我们通常也会学习嵌套的 if-else 结构。类似地，在 Django 模板语言中，我们也可以使用嵌套的 if-else 结构。
在 Django 模板中，可以创建一个嵌套的 if-else 结构，如下所示:
{% if marks <condition 1> %}
<statements or HTML to be rendered>
{% elif <condition 2> %}
<statements or HTML to be rendered>
{% elif <condition N> %}
<statements or HTML to be rendered>
{% else %}
<statements or HTML to be rendered>
{% endif %}
现在让我们看一个例子。我将创建一个示例，其中我将在 Django 模板中创建一个嵌套的 if-else 结构。我将创建一个简单的评分系统的例子，其中的输出将根据给定的用户输入渲染，即标记。
首先，让我们设计提交用户输入的模板，比如说index.html。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Grades</title>
</head>
<body>
<form action="result" method="get">
<h3> Enter Student Name: </h3><br>
<input type="text" name="name" placeholder="Enter Student Name"><br>
<h3> Enter Marks: </h3><br>
<input type="text" name="marks" placeholder="Enter Marks"><br>
<input type="submit" value="Submit">
</form>
</body>
</html>
单击 submit 按钮后，表单会将用户重定向到一个名为 result 的 URL 端点。让我们在 urls.py 文件中定义这个 URL 映射:
from django.contrib import admin
from django.urls import path
from . import views
urlpatterns = [
path('admin/', admin.site.urls),
path('', views.index, name = 'index'),
path('result', views.results, name = 'results')
]
现在让我们定义处理请求的函数，并将参数传递给文件 views.py 中的下一个 Django 模板:
# importing the necessary libraries
from django.shortcuts import render
def index(request):
return render(request, 'index.html')
def results(request):
name = request.GET['name']
marks = float(request.GET['marks'])
data = {
'name': name,
'marks': marks
}
return render(request, 'validate.html', data)
最后，我们将在一个名为validate.html的 Django 模板中呈现这些数据，在这里我们将使用 if-else 模板标签来比较数据并显示结果。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Show Username</title>
</head>
<body>
{% if marks >= 90 %}
<h3>{{name}} got A grade</h3>
{% elif marks >= 75 %}
<h3>{{name}} got B grade</h3>
{% elif marks >= 60 %}
<h3>{{name}} got C grade</h3>
{% elif marks >= 45 %}
<h3>{{name}} got D grade</h3>
{% elif marks >= 35 %}
<h3>{{name}} got E grade</h3>
{% else %}
<h3>{{name}} got F grade</h3>
{% endif %}
</body>
</html>
现在让我们通过启动服务器并访问索引网页来查看输出。
Entering data into the form
让我们在表单中输入一些数据，然后点击提交按钮。
The output of the if-else logic used
您可以看到我们得到了 if-else 模板标记中指定的分数。
这样，您可以在 Django 模板中使用嵌套的 if-else 结构。
Django 模板中带有 if 条件的循环
在开发 Django 应用程序时，您可能需要在 Django 模板中呈现一个项目列表。在这种情况下，通常使用 for 循环。
但是，验证项目列表是否为空是一个很好的做法。只有当列表包含某些项目时，循环语句才应该执行。
在这种情况下，您可以使用 if-else 模板标记来验证列表是否包含某些项目。在这一节中，我将借助一个例子来演示这一点。
我已经创建了一个样本雇员数据库。我将在 Django 模板中呈现特定部门员工的姓名。
- 首先，我将创建一个 Django 模板，其中我将接受一个用户输入，即指定部门，比如名称 index.html:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Grades</title>
</head>
<body>
<form action="department" method="get">
<h3> Enter Department Name: </h3><br>
<input type="text" name="department" placeholder="Enter Department Name"><br>
<input type="submit" value="Submit">
</form>
</body>
</html>
- 该表单会将我们重定向到另一个名为
department的 URL enpoint。让我们将这个 URL enpoint 与我们的urls.py文件中的函数进行映射:
from django.contrib import admin
from django.urls import path
from . import views
urlpatterns = [
path('admin/', admin.site.urls),
path('', views.index, name = 'index'),
path('department', views.department, name = 'department')
]
- 现在我们将在我们的
views.py文件中创建一个函数来处理我们的请求。我们将从具有用户指定的特定部门的数据库中检索雇员的数据。views.py文件是:
# importing the necessary libraries
from django.shortcuts import render
from .models import Employees
def index(request):
return render(request, 'index.html')
def department(request):
dep = request.GET['department']
obj = Employees.objects.all().filter(department = dep)
data= {
'obj' : obj,
'dep' : dep
}
return render(request, 'department.html',data)
- 让我也向您展示一下
models.py文件，以便您可以看到我是如何创建数据库的:
from django.db import models
class Employees(models.Model):
emp_id = models.AutoField
name = models.CharField(max_length= 40)
department = models.CharField(max_length= 40)
salary = models.FloatField()
上面的模型类将在数据库中创建一个名为 Employees 的表。
- 我已经使用 SQLite studio 在数据库中填充了这个表，因为我使用的是默认的 SQLite 数据库。数据库中的数据如下:
Employees table in the database
- 现在让我们看看如何在一个名为 department.html的 Django 模板中呈现我们的
views.py文件获取的数据。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>List Employees by department</title>
</head>
<body>
{% if obj %}
<h3>List of Employees in {{dep}} department</h3>
<ol>
{% for emp in obj %}
<li>{{emp.name}}</li>
{% endfor %}
</ol>
{% else %}
<h3>Not a valid department</h3>
{% endif %}
</body>
</html>
- 在上面的模板中，我使用了 if-else 模板标签来检查名为
obj的变量是否包含一些数据。 - 如果它包含一些数据，数据中的雇员姓名将在模板中呈现为有序列表。否则，将呈现不同的消息。
- 现在让我们看看输出。我将启动 Django 服务器并访问我的 Djnago 应用程序的主页。
Django application homepage
- 首先，我将假定一个有效的雇员部门。
List of employees of a particular department
- 您可以看到，我们获得了属于我们指定部门的雇员的姓名。
- 现在让我们再次重复这个步骤，但是这次我将输入任何无效的字符串，即不是有效的部门。
Output when an invalid department is specified
您可以看到，我们得到了在 if-else 模板标记的 else 块中定义的消息。
你也可以阅读下面关于 Django 的教程。
这样，您可以在 for 循环之前使用 if-else 标记对变量进行验证检查。
- 如何在 Django 模板中使用 if 语句
- Django 模板示例中的 If 标记
- Django 模板中的 If else 标签
- Django 模板示例中的 If else 标签
- Django 模板如果等于字符串
- 如果 Django 模板中没有条件
- Django 模板中嵌套的 if else
- Django 模板中带有 if 条件的 For 循环
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
导入错误没有名为 TensorFlow 的模块
原文：https://pythonguides.com/import-error-no-module-named-tensorflow/
在本 Python 教程中，我们将讨论错误导入错误 没有命名为 tensor flow****的模块。在这里，我们将使用 Python 解释与此错误相关的原因。我们还将讨论以下主题:
- 导入错误没有名为 tensorflow.compat.v1 的模块
- 导入错误没有名为“tensorflow.contrib”的模块
- 导入错误没有名为 tensorflow_hub 的模块
- 导入错误，没有名为“tensorflow addons”的模块
- 导入错误没有名为“tensorflow.python.eager”的模块
目录
- 导入错误没有名为 TensorFlow 的模块
- 导入错误没有名为‘tensor flow . contrib’的模块
- 导入错误没有名为 tensorflow.compat.v1 的模块
- 导入错误没有名为‘tensor flow _ hub’的模块
- 导入错误，没有名为‘tensor flow addons’的模块
- 导入错误没有名为‘tensor flow . python . eager’的模块
导入错误没有名为 TensorFlow 的模块
- 在本节中，我们将讨论错误导入错误没有在 Python 中命名为 TensorFlow 的模块。
- 基本上，当我们没有导入 TensorFlow 库或者我们可以说 TensorFlow 库没有安装在我们的系统中时，就会出现这个错误消息。
- 如果您尚未在系统中安装 TensorFlow 库，但仍想尝试在程序中导入 TensorFlow 库，则会出现错误消息“没有名为 TensorFlow 的模块”。
举例:
import tensorflow as tf
tens1 = tf.Variable([[67, 89],[23, 45]])
tens2 = tf.Variable([[94, 117],[189, 210]])
new_output= tf.add(tens1,tens2)
print(new_output)
在上面的代码中，我们使用了 tf.add()函数，在这个函数中，我们将给定的张量“tens1”和“tens2”指定为参数。
下面是下面给出的代码的截图。
import error no module named TensorFlow
现在让我们看看这个错误的解决方案:
Visual Code Studio
如果您已经安装了 Visual code Studio，那么它将使用 pip 环境，如果您想要导入一些所需的库，那么您必须通过命令进行安装。
- 使用 pip 命令安装 TensorFlow
语法:
下面是 TensorFlow 库的安装语法
pip install TensorFlow
此语法将帮助您解决错误“没有名为 TensorFlow 的模块”
Jupyter
如果你已经安装了 Jupyter 笔记本，那么使用 Conda 环境。获取关于如何在 Conda 环境中安装 TensorFlow 库的详细信息。可以参考我们的详细文章Python 中的 tensor flow。
另外，检查: TensorFlow 稀疏张量
导入错误没有名为‘tensor flow . contrib’的模块
- 这里我们要讨论的错误导入错误没有模块名为' TensorFlow.contrib '。
- 基本上 TensorFlow 版没有 contrib 模块。这个模块包含贡献的代码，它也是一个易失性代码。
- 该错误背后的可能原因是解释器在库中找不到 contrib 'module'。
- TensorFlow 2.x 的最新版本从 TensorFlow 库中删除了 session 和 contrib 模块。
原因:模块“contrib”在版本 2.x 中不起作用
举例:
import tensorflow.contrib
下面是以下代码的截图
import error no module named ‘TensorFlow.contrib’
在以下给定代码中，我们刚刚导入了“TensorFlow.contrib”模块，但当我们执行此命令时，它显示没有名为“TensorFlow.contrib”的模块。可能的原因是该模块在最新版本的 TensorFlow 2.x 中不工作。
让我们讨论一下这个错误的解决方案
- 首先，卸载已经安装的版本，如果它是最新版本，然后用旧版本重新安装。要卸载 tensorflow 2.x，您可以轻松使用命令 pip uninstall TensorFlow。
- 现在，要安装 TensorFlow 1.x 的旧版本，您可以使用以下命令
pip install tensorflow==1.15.0
阅读:Python tensor flow reduce _ sum
导入错误没有名为 tensorflow.compat.v1 的模块
- 在本节中，我们将讨论名为 tensorflow.compat.v1 的错误号模块。
- 此错误背后的可能原因是，在 Tensorflow 版本 1.12.0 中，compat.v1 模块已被弃用。该模块将帮助用户编写两种 TensorFlow 版本的代码。
- 本模块不支持 1.12 版本，如果你想在你的系统上执行本模块，那么你必须安装最新的或 1.12 以上的版本。
举例:
import error no module named TensorFlow compat v1 in Python
现在，我们将使用 TensorFlow 的更新版本在 Python 中导入 TensorFlow.compat.v1 模块
要在 Conda 提示符下安装 TensorFlow 的新版本，您可以使用以下命令
conda install tensorflow==2.6
Solution of no module named TensorFlow compat v1 in Python
正如您在截图中看到的，我们已经检查了 TensorFlow 的版本，它显示的是 2.6 最新版本，并且还成功导入了 TensorFlow.compat.v1。
另外，检查:模块“TensorFlow”没有属性“session”
导入错误没有名为‘tensor flow _ hub’的模块
- 在这个程序中，我们将讨论 Python 中名为‘tensor flow _ hub’的错误 no 模块。
- 基本上，当模块“tensorflow_hub”在 tensorflow 库包中不可用时，会出现此错误消息。
举例:
Python import error no module named TensorFlow hub
正如你在截图中看到的，它没有显示模块名称“tensorflow_hub ”,这是因为我们使用的是 TensorFlow 1.14 的旧版本。在此版本中，tensorflow_hub 模块不起作用。
让我们来看看这个错误的解决方案
要解决此错误，您必须在系统中安装最新版本的 TensorFlow。默认情况下，2.7 是一个稳定版本，要安装 TensorFlow 的更新版本，您可以使用以下命令。该命令用于 conda 提示用户。
conda install tensorflow==2.7
屏幕上显示程序运行的图片
Solution of import error no module named TensorFlow hub
在这个截图中，你可以看到我们已经安装了最新版本的 TensorFlow 2.7，然后导入 tensorflow_hub 模块。
阅读: TensorFlow Tensor to numpy
导入错误，没有名为‘tensor flow addons’的模块
- 在本节中，我们将讨论 Python 中名为“tensorflow addons”的错误 no 模块。
- 基本上，插件模块在最新的 TensorFlow 版本 2.7 中可用，但我们必须更新“TensorFlow 插件”模块。该模块在 core Tensorflow 中不可用，它还支持优化器、度量和损失。
屏幕上显示程序运行的图片
import error no module named TensorFlow addons
正如您在输出中看到的，它显示没有模块名‘tensor flow _ addons’。而可能的原因是，tensorflow 最新版本 2.7 中有' tensorflow_addons '模块。但是我们必须更新‘tensor flow _ addons’模块。
让我们来看看这个错误的解决方案
要解决此错误，您必须在系统中安装旧版本的 TensorFlow。默认情况下，2.7 是一个稳定的版本，但这个模块只在最新版本 2.x 中不工作。
输出:
Solution of import error no module named TensorFlow addons
要升级“TensorFlow 插件”模块，您可以轻松使用以下命令
pip install tensorflow-addons
在上面的代码中，我们已经在升级模块后导入了 tensorflow_addons()模块。
阅读: TensorFlow 全球平均池
导入错误没有名为‘tensor flow . python . eager’的模块
- 这里我们要讨论的是 python 中名为‘tensor flow . Python . eager’的错误 no 模块。
- 当我试图导入“TensorFlow.python.eager”模块时，输出中出现了此错误。背后的原因是 TensorFlow 库的版本。
让我们来看看这个错误的解决方案
在本例中，我们刚刚导入了 TensorFlow 库，然后使用 tf 检查了版本。version 命令。之后，我们导入了‘tensor flow . python . eager’模块。执行这段代码后，输出会显示模块已成功导入。
举例:
import error no module named tensorflow python eager
还有，多看看一些 Python TensorFlow 教程。
- 二元交叉熵张量流
- 梯度下降优化器张量流
- Python TensorFlow 占位符
- 将列表转换为张量张量流
- 模块“tensorflow”没有属性“div”
- 模块“tensorflow”没有属性“sparse _ placeholder”
所以，在本教程中，我们已经解决了错误“导入错误没有名为 TensorFlow 的模块”。在这里，我们将使用 Python 来解释与此错误相关的原因。我们还将讨论以下主题:
- 导入错误没有名为 tensorflow.compat.v1 的模块
- 导入错误没有名为“tensorflow.contrib”的模块
- 导入错误没有名为 tensorflow_hub 的模块
- 导入错误，没有名为“tensorflow addons”的模块
- 导入错误没有名为“tensorflow.python.eager”的模块
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Python 中的递增和递减运算符
原文：https://pythonguides.com/increment-and-decrement-operators-in-python/
在这个 python 教程中，你将通过例子学习 python 中的**递增和递减操作符。这里我们将检查 :**
- Python 中的递增和递减运算符
- Python 增量运算符
- Python 减量运算符
- 循环 python 中的增量变量
- 如何在 python 中增加一个字符
- python for 循环中的减量运算符
- python for 循环中的增量运算符
目录
- Python 中的递增和递减运算符
- Python 增量运算符
- Python 减量运算符
- 循环 python 中的增量变量
- 如何在 python 中增加一个字符
- python for 循环中的减量运算符
- python for 循环中的增量运算符
Python 中的递增和递减运算符
让我们了解一下 Python 中的递增和递减运算符。
Python 不允许使用 "(++和-)"操作符。在 python 中，要增加或减少一个变量，我们可以简单地重新分配它。所以，“++”和“–”符号在 Python 中是不存在的。
Python 增量运算符
现在，让我们用一个例子来了解一下 Python 增量运算符。
在 python 中，如果你想用增加一个变量，我们可以使用 "+=" 或者我们可以简单地重新分配它 "x=x+1" 来增加一个变量值 1 。
举例:
x = 20
x = x+1
print(x)
写完上面的代码(python 增量操作符)，你将打印出 "x" ，然后输出将显示为 " 21 " 。这里，“x”的值增加了“1”。
你可以参考下面 python 中增量运算符的截图。
Python increment operator
在下面的代码中，我们将看到另一个使用"+= "**增加**变量的例子，它做同样的事情。
举例:
x = 21
x+=1
print(x)
写完上面的代码后，你将打印出 "x" ，然后输出将显示为 " 22 " 。这里，“x”的值增加了“1”。
你可以参考下面的截图。
Increment operator in python
Python 减量运算符
现在让我们来了解一下， Python 减量运算符的一个例子。
为了减少python 中的一个变量，我们可以使用 "-=" 或 "x=x-1" 运算符来减少一个变量的值 1 。
举例:
x = 21
x = x-1
print(x)
写完上面的代码(python 减量操作符)，你将打印出 "x" ，然后输出将显示为 " 20 " 。这里，“x”的值减少了“1”。
关于 python 中的减量运算符，可以参考下面的截图。
Python decrement operator
在下面的代码中，我们将看到另一个使用"-= "**减少**变量的例子，这也是一样的。
举例:
x = 20
x-=1
print(x)
写完上面的代码后，你将打印出 "x" ，然后输出将显示为 " 19 " 。这里，“x”的值减少了“1”。
你可以参考下面的截图。
Decrement operator in python
循环 python 中的增量变量
让我们看看如何在 Python 的循环中递增变量。
在 python 中，在循环中增加一个变量值，我们可以使用 while 循环直接增加或减少迭代值。
举例:
my_list = [11, 12, 13, 14, 15]
i = 0
while(i < len(my_list)):
print(my_list[i])
i += 2
写完上面的代码(循环 python 中的增量变量)，你将打印出 "my_list[i]" ，然后输出将显示为 " 11 13 15 " 。这里，该值在每次迭代中递增 2。
循环 python 中的增量变量可以参考下面的截图。
Increment variable in loop python
在下面的代码中，我们将通过使用范围函数来查看循环 python 中增量变量的另一个示例，因为该函数的第三个参数将指定递增其索引值的步骤。
举例:
my_list = [11, 12, 13, 14, 15]
for i in range(0, len(my_list), 2)
print(my_list[i])
- 写完上面的代码(循环 python 中的增量变量)，你将打印出 "my_list[i]" ，然后输出将显示为
" 11 13 15 "。 - 这里，范围函数用于返回数字序列，从“0”开始，指定停止位置，也指定增量 2。
关于循环 python 中的增量变量，可以参考下面的截图。
Increment variable in loop python
如何在 python 中增加一个字符
python 中如何递增一个字符？如果你试图在 Python 中用整数值增加一个字符，它会给出一个错误。
举例:
a = "N"
a = a + 2
print(a)
写完上面的代码(如何在 python 中增加一个字符)，你将打印出 "a" ，然后错误将显示为"类型错误:只能将 str(不是" int ")连接到 str " 。
你可以参考下面的截图。
How to increment a character in python
为了解决上面的类型错误，我们将使用 ord() 和 chr() 来避免错误。 ord() 返回字符对应的 ASCII 值，在加上整数后， chr() 再次将其转换为字符。
举例:
char = ord("N")
val = char + 2
increment = chr(val)
print(increment)
写完上面的代码(如何在 python 中增加一个字符)，你将打印出“increment”，然后输出将显示为“P”。这里，“chr”返回增加的字符。
你可以参考下面的截图如何在 python 中增加一个字符。
How to increment a character in python
python for 循环中的减量运算符
为了递减 Python 中循环的内的索引值，我们可以使用范围函数作为这个函数的第三个参数将负。通过使步长值为负，可以减少循环计数器。
举例:
for i in range(6, 0, -2):
print(i)
- 写完上面的代码(python 中循环的减量操作符)，你将打印出
"i"，然后输出将显示为" 6 4 2 "。 - 这里，范围函数用于返回数字序列，这里从“6”开始，并继续递减，直到 0 个位置，也指定了递减-2 的步长。
关于循环的 python 中的减量运算符，可以参考下面的截图。
Decrement operators in python for loop
python for 循环中的增量运算符
为了增加循环 python 中的操作符，我们将使用范围函数，因为该函数的第三个参数将指定增加其索引值的步骤。
举例:
for i in range(0, 6, 1)
print(i)
- 写完上面的代码(python 中 for 循环的增量操作符)，你将打印出
"i"，然后输出将显示为" 0 1 2 3 4 5 "。 - 这里， range 函数用于返回数字序列，从“0”开始，指定的停止范围是 6，递增的步长也是 1。
python for 循环中的增量运算符可以参考下面的截图。
Increment operators in python for loop
您可能会喜欢以下 Python 教程:
在本 Python 教程中，我们学习了 Python 增量和减量操作符。此外，我们还讨论了以下主题:
- Python 中的递增和递减运算符
- Python 增量运算符
- Python 减量运算符
- 循环 python 中的增量变量
- 如何在 python 中增加一个字符
- python for 循环中的减量运算符
- python for 循环中的增量运算符
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何在 Python 中处理 indexerror:字符串索引超出范围
原文：https://pythonguides.com/indexerror-string-index-out-of-range-python/
在本 Python 教程中，我们将讨论如何在 Python 中处理 indexerror: string index 越界。我们将检查如何修复超出 python 3 范围的错误索引错误字符串索引。
indexerror 字符串索引超出范围 python
在 python 中， indexerror 字符串索引超出范围 python 错误发生在字符被超出字符串值范围的索引检索时，并且字符串索引从 " 0 " 开始到字符串索引值的总数。
举例:
name = "Jack"
value = name[4]
print(value)
写完上面的代码(字符串索引超出范围)，你将打印出 " value" ，然后错误将显示为 " IndexError:字符串索引超出范围"。这里，名为【4】的索引不在范围内，所以出现这个错误是因为索引值不存在，并且超出了范围。
你可以参考下面的截图字符串索引超出范围
IndexError: string index out of range
这是索引错误:字符串索引超出范围。
为了解决这个索引错误:字符串索引超出范围我们需要给出范围内的字符串索引，以便可以解决这个错误。索引从 0 开始，以字符串中的字符数结束。
举例:
name = "Jack"
value = name[2]
print('The character is: ',value)
写完上面的代码IndexError:string index out of range这是通过给定范围内的字符串索引来解决的，这里，索引 name[2] 在范围内，它会给出输出为“字符是:c”，因为指定的索引值和字符在范围内。
可以参考下面截图如何求解IndexError: string index 超范围。
于是， IndexError 被解析字符串索引超出范围。
您可能会喜欢以下 Python 教程:
- 解析 Python 时出现意外的 EOF
- 删除 python 中的 Unicode 字符
- Python 中的注释行
- Python 字典追加示例
- 在 Python 中检查列表是否为空
- Python 字典方法+示例
- Python 列表方法
- Python 字符串函数
- 语法错误标识符 python3 中的无效字符
- 从字符串 Python 中删除字符
- python 中的百分号是什么意思
这是如何解决IndexError:python 中的字符串索引超出范围或 indexerror 字符串索引超出范围 python 3 。
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Python 中的索引和切片
在本 python 教程中，我们将通过几个例子讨论 Python 中的索引和切片，我们还将涉及以下主题:
- python 中的索引是什么？
- Python 中的正索引示例
- Python 中的负索引示例
- python 字符串中的索引
- python 列表中的索引
- python 数组中的索引
- python 元组中的索引
- python 字典中的索引
- python 中的切片是什么？
- Python 使用切片对象获取子串
- Python 使用负索引获取子串
- python 列表中的切片
- 在 python 字符串中切片
- python 元组中的切片
- python 数组切片
目录
- python 中什么是索引？
- Python 中的正索引示例
- Python 中的负索引示例
- python 字符串中的索引
- python 列表中的索引
- Python 数组中的索引
- python 元组中的索引
- python 字典中的索引
- python 中切片是什么？
- Python 使用切片对象获取子串
- Python 使用负索引获得子串
- 在 Python 列表中切片
- 在 python 字符串中切片
- 在 python 元组中切片
- Python 数组切片
python 中什么是索引？
- Python 中的索引是指通过 iterable 中的位置来引用 iterable 的元素。
- 每个字符都可以使用它们的索引号来访问。
- 要访问字符串中的字符，我们有两种方法:
- 正指数
- 负指数
Python 中的正索引示例
在 Python 正索引中，我们传递一个我们想要访问的正索引，放在方括号中。索引号从表示字符串的第一个字符的 0 开始。
举例:
my_str = "Python Guides"
print(my_str[0])
在这个输出中，我们可以看到 python 中的正索引示例。你可以参考下面的截图。
Positive indexing example in Python
你可能喜欢读， Python 程序求 n 个数之和和如何用 Python 把两个数相加。
Python 中的负索引示例
在 Python 的负索引中，我们用方括号传递我们想要访问的负索引。这里，索引号从索引号 -1 开始，表示字符串的最后一个字符。****
**举例:
my_str = "Python Guides"
print(my_str[-1])
在这个输出中，我们可以看到 python 中的一个负索引示例。你可以参考下面的截图。
Negative indexing example in Python
python 字符串中的索引
python 中的字符串索引允许你通过使用索引直接访问字符串中的单个字符。这里用(str[3])】来得到【c】。
举例:
str = 'Welcome'
print(str[3])
在这个输出中，我们可以看到 python 字符串中的索引。你可以参考下面的截图。
Indexing in python string
你可能喜欢用 Python 程序打印数组中的元素。
python 列表中的索引
Python 列表索引可以通过引用其索引号来访问列表值。这里，我们使用了(list[2])“，它返回“马”。
举例:
list = ['Dog', 'Cat', 'Horse', 'Bear']
print(list[2])
在这个输出中，我们可以看到 python 列表中的索引。你可以参考下面的截图。
Indexing in python list
Python 数组中的索引
python 中的数组索引和访问数组元素是一样的。通过引用数组元素的索引号来访问它。这里我们用了(my _ arr[1])】来访问【12】。
举例:
import numpy as np
my_arr = np.array([10, 12, 14, 16])
print(my_arr[1])
在这个输出中，我们可以看到 python 数组中的索引。你可以参考下面的截图。
Indexing in python array
查看以下 Python 数组教程:
- Python 串联数组
- 如何将 Python 数组写入 CSV
- Python 形状的一个数组
- 如何将 Python 字符串转换成字节数组并举例
- Python 数组与示例
- 在 Python 中创建一个空数组
python 元组中的索引
我们将使用索引操作符 "[]" 从 Python 元组中访问一个条目。其中索引从 0 开始。这里我们用了一个从右(my _ tuple[-2])】开始的负索引得到【8】。
举例:
my_tuple = (2, 4, 6, 8, 10)
print(my_tuple[-2])
在这个输出中，我们可以看到 python 元组中的索引。你可以参考下面的截图。
Indexing in python tuple
python 字典中的索引
在 Python 中索引一个字典就是访问该索引处的键或值。这里，我们将使用 list()来索引一个 Python 字典的键。为了获取列表中索引处的键，我们使用了 "m_list[1]" ，它将返回 "John" 。
举例:
my_dictionary = {"ani": 101, "John": 102}
m_list = list(my_dictionary)
k = m_list[1]
print(k)
在这个输出中，我们可以看到 python 字典中的索引。你可以参考下面的截图。
Indexing in a python dictionary
python 中切片是什么？
python 中的切片用于访问序列的部分。切片对象用于对给定的序列或任何对象进行切片。当我们需要字符串的一部分而不是完整的字符串时，我们使用切片。
语法:
string[start : end : step]
举例:
my_str = "Python Guides"
print(my_str[-1 : -10 : -2])
在这个输出中，我们可以看到 python 中的切片。此处，步长为-2 "，因此从相反方向开始，每隔一个值打印一次。你可以参考下面的截图。
What is slicing in python
Python 使用切片对象获取子串
为了在 python 中使用 slice 对象来获取子串，我们将使用“slice(5)”。这里，开始【0】，结束【5】，所以取值比结束值小 1。
举例:
my_str = 'Guides'
s_obj = slice(5)
print(my_str[s_obj])
在这个输出中，我们可以看到如何在 python 中使用 slice 对象获取子串。在这里，我们可以看到子串为【向导】。你可以参考下面的截图。
Python get substring using slice object
Python 使用负索引获得子串
为了在 python 中使用负索引获得子串，我们将使用“slice(-1，-4，-1)”。这里开始是-1 "，结束是-4 "，步是负-1 "。
举例:
my_str = 'Guides'
s_obj = slice(-1, -4, -1)
print(my_str[s_obj])
在这个输出中，我们可以看到如何在 python 中使用负索引获得子串。在这里，我们可以看到子串为“sed”。你可以参考下面的截图。
Python get substring using negative index
在 Python 列表中切片
让我们看看 python 列表中的切片。
在这个例子中，我们使用了(my _ list[-4::1])】对列表进行切片。因此，开始是-4 "，我们没有为结束指定任何值，因此，默认情况下，它将持续到最后， "1" 是步骤。
举例:
my_list = [10, 20, 30, 40, 50, 60]
print(my_list[-4::1])
在这个输出中，我们可以看到 python 列表中的切片。在这里，我们得到了输出中的列表。你可以参考下面的截图。
Slicing in python list
- 检查一个列表是否存在于另一个列表中 Python
- Python 向 CSV 写列表
- 使用 if-else 理解 Python 列表
- Python 从列表中选择
- Python 将元组转换为列表
- Python 元组排序列表
在 python 字符串中切片
python string 中的切片用于通过切片从给定的字符串中获取子串。我们将开始索引指定为“3”，结束索引指定为“6”，它将返回一个字符串。
举例:
str ='Python!'
print(str[3:6])
在这个输出中，我们可以看到在 python 字符串中切片。在这里，我们得到字符串作为输出。你可以参考下面的截图。
Slicing in python string
在 python 元组中切片
为了在 Python 中切片一个元组，我们将使用(my _ tuple[4])“。为了得到这个值，我们必须指定一个正整数，从从左数的元组中获取索引。在负索引的情况下，我们必须从右边获取索引。
举例:
my_tuple = ('v', 'w', 'x', 'y', 'z')
print(my_tuple[4])
print(my_tuple[-3])
在这个输出中，我们可以看到 python 元组中的切片。这里，我们得到两个输出。你可以参考下面的截图。
Slicing in python tuple
Python 数组切片
为了在 python 数组中进行切片，我们将把 numPy 作为 np 导入。我们将定义为“(my_arr[1:])”。这里，开始是“1”并且没有通过结束，所以，它将考虑直到一个数组的最后长度。
举例:
import numpy as np
my_arr = np.array([10, 11, 12, 13, 14])
print(my_arr[1:])
在这个输出中，我们可以看到 python 数组中的切片。在这里，我们以数组的形式获得输出。你可以参考下面的截图。
Slicing in python array
在本教程中，我们已经通过示例学习了 Python 中的索引和切片，并且我们已经涵盖了以下主题:
- python 中的索引是什么？
- Python 中的正索引示例
- Python 中的负索引示例
- python 字符串中的索引
- python 列表中的索引
- python 数组中的索引
- python 元组中的索引
- python 字典中的索引
- python 中的切片是什么？
- Python 使用切片对象获取子串
- Python 使用负索引获取子串
- python 列表中的切片
- 在 python 字符串中切片
- python 元组中的切片
- python 数组切片
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何在 Python 列表的末尾插入项目[4 种不同的方式]
原文：https://pythonguides.com/insert-item-at-end-of-python-list/
在这个 Python 教程中，我们将讨论如何在 Python 列表的末尾插入条目。我们将看到 4 种不同的方法来添加项目到列表的末尾 python 。
在整个课程中，我们将使用一个项目列表作为示例来重点介绍列表插入，因为无论列表包含何种类型的数据，列表插入技术都必须相同。让我们看看在 Python 列表的末尾插入项目的不同方法。
目录
在 Python 列表的末尾插入项目
在这里，让我们来看 4 种不同的方法来在 Python 列表的末尾插入项目。
方法 1:使用 Insert()函数 在 Python 列表末尾插入条目
Python 的 insert()函数，用于在指定索引处插入指定元素或项目的列表。下面给出了语法。
list_name.insert(index, value)
如果指定的索引大于或等于列表的长度，则在 Python 列表的末尾插入。
使用下面的代码创建一个项目列表，这些项目是美国前 4 个州的实际 GDP 百分比，如 Tennessee = 8.6、New Hemsphire = 8.5、California = 7.8和Nevada = 7.1 。
usa_st_gdp = [8.6, 8.5, 7.8, 7.1]
print(usa_st_gdp)
现在我们要添加新的州*Indiana*的实际 GDP 百分比，或者它将进入列表中的第 5 个州，我们将使用*insert()*方法。
usa_st_gdp.insert(len(usa_st_gdp), 6.9)
使用下面的代码检查列表。
print(usa_st_gdp)
To Insert Item At The End of The Python List
看看输出，我们是如何在 Python 中在列表的末尾插入浮动值的项的。
方法二:在 Python 中使用 append()函数 在列表末尾插入一个条目
使用下面的代码创建一个项目列表，这些项目是美国前 4 个州的实际 GDP 百分比，如 Tennessee = 8.6、New Hemsphire = 8.5、California = 7.8和Nevada = 7.1 。
usa_st_gdp = [8.6, 8.5, 7.8, 7.1]
print(usa_st_gdp)
我们现在将使用 append()方法添加新州*Indiana*的实际 GDP %,或者将成为列表中第五个州的州。
usa_st_gdp.append(6.9)
使用下面的代码查看列表。
print(usa_st_gdp)
To Insert Item At The End of-The-Python List Using Append
这是如何在 Python 中使用 append()函数在列表末尾插入一个项目。
方法-3:在 Python 中使用+和[]运算符 在列表末尾插入一个项目
使用下面的代码创建一个项目列表，这些项目是美国前 4 个州的实际 GDP 百分比，如 Tennessee = 8.6、New Hemsphire = 8.5、California = 7.8和Nevada = 7.1 。
usa_st_gdp = [8.6, 8.5, 7.8, 7.1]
print(usa_st_gdp)
我们现在将使用+和[]运算符来添加新州*Indiana*的实际 GDP %,或者将成为列表中第五个州的州。
usa_st_gdp = usa_st_gdp + [6.9]
使用下面的代码查看列表。
print(usa_st_gdp)
To Insert Item At The End of The Python List Example
这是如何在 Python 中使用+和[]运算符在列表末尾插入一个项目。
方法 4:在 Python 中，要在列表末尾插入一个条目，使用切片方法
使用下面的代码创建一个项目列表，这些项目是美国前 4 个州的实际 GDP 百分比，如 Tennessee = 8.6、New Hemsphire = 8.5、California = 7.8和Nevada = 7.1 。
usa_st_gdp = [8.6, 8.5, 7.8, 7.1]
print(usa_st_gdp)
现在使用切片方法添加新的州*Indiana*的实际 GDP %,或者将成为列表中第五个州的州。
usa_st_gdp[4:5] = [6.9]
使用下面的代码显示列表。
print(usa_st_gdp)
To Insert Item At The End of The Python List Using Slicing
我们已经学习了如何以不同的方式在 Python 中的列表末尾插入条目，比如使用切片、插入、(+和[])操作符和 append()方法。
您可能会喜欢以下 Python 教程:
我叫 Kumar Saurabh，是一名 Python 开发人员，在 TSInfo Technologies 工作。此外，像 Python 编程，SciPy，机器学习，人工智能等技术的专业知识。是我喜欢做的事情。
