使用 Matplotlib 在 Python 中绘制三维图形
原文：https://www.askpython.com/python-modules/matplotlib/3-dimensional-plots-in-python
就像二维绘图一样，你也可以使用 matplotlib 在 Python 中创建三维绘图。在本教程中，我们将学习如何使用 matplotlib 绘制三维图。
如何用 Python 绘制三维图形？
我们将使用 mplot3d 工具包和 **matpotlib 库。**mplot3d 工具包建立在 matplotlib 库的基础上，可以轻松创建三维绘图。
所以不要再拖延了，让我们开始吧！
1.导入必要的模块
首先，我们将导入 matplotlib 和 mplot3d 工具包。除了这两个，我们还将 导入 numpy 来创建样本数据。下面给出了导入这三个组件的代码。
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
2.创建三维轴
现在我们可以使用导入的模块创建三维轴。
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
#create 3d axes
fig = plt.figure()
ax = plt.axes(projection='3d')
plt.show()
输出:
Axes
现在我们有了轴，让我们试着画些东西。在绘图时，我们需要确保提供所有三个轴(x、y 和 z)的值。
在接下来的几节中，我们将学习如何使用正弦函数(正弦和余弦)制作螺旋。
在此之前，我们将学习如何为情节添加标题。
3.为情节添加标题
您可以使用 set_title()方法向绘图添加标题:
ax.set_title('Learning about 3D plots')
要查看上面的代码行，请运行以下命令:
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
#create 3d axes
fig = plt.figure()
ax = plt.axes(projection='3d')
#set title
ax.set_title('Learning about 3D plots')
plt.show()
输出:
Plot With Title
4.创建一个螺旋
为了创建一个螺旋，我们将沿着 x 轴使用正弦函数和沿着 y 轴使用余弦函数。
螺旋的数据点可以按如下方式生成:
z = np.linspace(0, 15, 1000)
x = np.sin(z)
y = np.cos(z)
这里函数 np.linespace 给出了 1000 个 0 到 15 之间的等距点。
完整的代码如下:
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
#create 3d axes
fig = plt.figure()
ax = plt.axes(projection='3d')
#cordiates for spiral
z = np.linspace(0, 15, 1000)
x = np.sin(z)
y = np.cos(z)
ax.plot3D(x, y, z, 'red')
plt.show()
输出:
Spiral
5.改变视角
根据视角的不同，三维图看起来会有所不同。您可以使用 view_init()方法更改三维绘图的视角:
ax.view_init(60, 50)
完整的代码如下所示:
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
#create 3d axes
fig = plt.figure()
ax = plt.axes(projection='3d')
#cordiates for spiral
z = np.linspace(0, 15, 1000)
x = np.sin(z)
y = np.cos(z)
ax.plot3D(x, y, z, 'red')
ax.view_init(60, 50)
plt.show()
输出:
Changing Viewing Angle
这里我们提到两个参数，轴的仰角和角度(以度为单位)。
我们换个角度试试。
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
#create 3d axes
fig = plt.figure()
ax = plt.axes(projection='3d')
#cordiates for spiral
z = np.linspace(0, 15, 1000)
x = np.sin(z)
y = np.cos(z)
ax.plot3D(x, y, z, 'red')
ax.view_init(120, 90)
plt.show()
输出:
Example 2
6.绘制线框
可使用 plot_wireframe()方法绘制三维线框，如下例所示:
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
#create 3d axes
fig = plt.figure()
ax = plt.axes(projection='3d')
#function for Z values
def f(x, y):
return np.cos(np.sqrt(x ** 2 + y ** 2))
# x and y values
x = np.linspace(1, 10, 10)
y = np.linspace(1, 10, 10)
X, Y = np.meshgrid(x, y)
Z = f(X, Y)
ax = plt.axes(projection ='3d')
ax.plot_wireframe(X, Y, Z, color ='red')
plt.show()
输出:
Wireframe
这里函数 np.meshgrid 从坐标向量创建坐标矩阵。
同样，您也可以创建曲面图。让我们在下一节学习如何做到这一点。
7.创建曲面图
我们可以用与上面相同的数据创建一个表面图。要创建三维表面图，我们将使用 plot_surface()方法。
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
#create 3d axes
fig = plt.figure()
ax = plt.axes(projection='3d')
#function for Z values
def f(x, y):
return np.cos(np.sqrt(x ** 2 + y ** 2))
# x and y values
x = np.linspace(1, 10, 10)
y = np.linspace(1, 10, 10)
X, Y = np.meshgrid(x, y)
Z = f(X, Y)
ax = plt.axes(projection ='3d')
ax.plot_surface(X, Y, Z, rstride=1, cstride=1,
cmap='viridis')
plt.show()
输出:
Surface-plot
在这里，以下自变量的含义如下:
| rstride | 数组行步距(步长) |
| cstride | 数组列跨距(步长) |
| 营地 | 曲面片的颜色图。 |
结论
本教程是关于 Python 中的三维绘图。我们学习了如何绘制三维轴和数据点。要了解更多 mplot3d 下的三维形状，请参考他们的官方文档。
Python 中的 3D 绘图:快速指南
原文：https://www.askpython.com/python-modules/matplotlib/3d-plot-in-python
我们将学习几种在 Python 中绘制 3D 图的方法及其适当的用法。我们将开发我们的 Google Colab 笔记本。我们进入正题。
绘图所需的方法
在开始我们的例子之前，让我们也理解一下方法。我们将进一步使用它们。
numpy.linespace()
这个方法用于在我们需要的轴上绘制数值。numpy.linespace()的语法如下。
numpy.linspace(start, stop, num = 50, endpoint = True, retstep = False, dtype = None)
该方法的参数是:
- **开始:**我们坐标轴坐标的开始。
- **停止:**坐标轴的终点。
- num: 要绘制的点样本数
- restep: 如果为真，返回(样本，步骤)。默认情况下，restep = False。(可选)
- dtype: 输出数组的类型。(可选)
我们可以通过下面的例子更好地理解。
import numpy as np
import pylab as p
# taking Start = 0, End = 2 and num=15 as parameters
x1 = np.linspace(0, 2, 15, endpoint = True)
y1 = np.zeros(15)
#taking x axis from -0.2 to 2.1 in our graph
p.xlim(-0.2, 2.1)
#plotting graph
p.plot(x1, y1, "*")
代码片段将给出如下结果。
numpy.linespace() method output
numpy.mgrid(数码相机)
返回多维度mesh grid的 NumPy 库的实例。一个mesh grid是一个具有相似值的 2d 数组。此方法调用 mesh grid 方法来初始化密集多维数组。输出数组的维数和数量等于索引维数。
numpy.mgrid 的语法如下。
numpy.mgrid = <numpy.lib.index_tricks.nd_grid object>
在我们的代码片段中，我们可以更好地理解下面的例子。
>>> import numpy as np
>>> new = np.mgrid[0:6, 0:4]
>>> print(new)
[[[0 0 0 0]
[1 1 1 1]
[2 2 2 2]
[3 3 3 3]
[4 4 4 4]
[5 5 5 5]]
[[0 1 2 3]
[0 1 2 3]
[0 1 2 3]
[0 1 2 3]
[0 1 2 3]
[0 1 2 3]]]
>>> new2 = np.mgrid[0:3, 0:5]
>>> print(new2)
[[[0 0 0 0 0]
[1 1 1 1 1]
[2 2 2 2 2]]
[[0 1 2 3 4]
[0 1 2 3 4]
[0 1 2 3 4]]]
让我们开始用不同的方法绘制 3D 模型。
使用. plot3D()方法绘制三维模型
用 python 绘制我们的第一个 3D 模型，我们将在 3D 图形中使用 Python 创建一个螺线管。让我们看看下面的代码片段。
#importing required modules for 3D plotting
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
#creating our 3D space using projection=3D parameter
ax = plt.axes(projection='3d')
#using linespace() method to assign plotting range of z-axis
zline = np.linspace(10, 200, 1000)
#taking x-intercept and y-intercept values as sin(zvalue) and cos(zvalue) respectively for different zvalue as radian.
xline = np.sin(zline)
yline = np.cos(zline)
#using plot3D() method by passing 3 axes values and plotting colour as "green"
ax.plot3D(xline, yline, zline, 'green')
按照上面的代码片段，我们可以得到如下输出。
Example 1 Output
您可以通过更改参数值来尝试上面的代码片段。你可以得到各种其他的结果，也可以更好地理解。让我们看另一个 3D 模型的例子。
使用. scatter3D()方法绘制 3D 模型
绘制第二个 3D 模型。我们将使用 python 在 3D 图形中创建一个分散的点状螺线管。让我们看看下面的代码片段。
#importing modules and creating a 3D as previous example
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
ax = plt.axes(projection='3d')
a = 500
# Data for three-dimensional scattered points
zdata = 50 * np.random.random(a)
xdata = np.sin(zdata) + 0.0 * np.random.random(a)
ydata = np.cos(zdata) + 0.0 * np.random.random(a)
#using the scatter3D() method by passing 3 co-ordinates
ax.scatter3D(xdata, ydata, zdata);
按照上面的代码片段，我们可以得到如下输出。
Example 2 Output
通过改变参数中相同代码片段的值，我们可以得到如下不同的图。
# Data for three-dimensional scattered points
a = 400
zdata = 20 * np.random.random(a)
xdata = np.sin(zdata) + 0.3 * np.random.random(a)
ydata = np.cos(zdata) + 0.1 * np.random.random(a)
ax.scatter3D(xdata, ydata, zdata);
Example 2 Output After Changing Parameter Values
从元组列表绘制表面
在这个方法中，我们将为一些元组绘制曲面(将元组视为坐标)。
import numpy as np
from matplotlib import pyplot as plt
ax = plt.axes(projection='3d')
# List of tuples
tuple_list = [(1, 0, 0), (0, 1, 0), (0, 0, 1)]
# Data points from the list of tuples
x, y, z = zip(tuple_list)
x, y = np.meshgrid(x, y)
Z = x ** 2 + y ** 2
# Surface plotting using .plot_surface() method
ax.plot_surface(x, y, Z)
plt.show()
按照上面的代码片段，我们可以得到如下输出。
Surface By Tuples
使用绘制 3D 模型。plot_surface()方法
在这个方法中，我们将使用 plot_surface() 在 Python 中绘制球体表面上的点。
import matplotlib.pyplot as plt
import numpy as np
ax = plt.axes(projection='3d')
getting the values for spherical points
u, v = np.mgrid[0:2 * np.pi:50j, 0:np.pi:50j]
x = np.cos(u) * np.sin(v)
y = np.sin(u) * np.sin(v)
z = np.cos(v)
#Plotting the surface using plot_surface() method
ax.plot_surface(x, y, z)
plt.show()
按照上面的代码片段，我们将得到如下输出。
Plot Surface Method
摘要
在本文中，我们介绍了如何使用 Python 绘制 3D 模型。我们绘制了一个螺线管、一个球体和一个法线平面。您可以使用不同的值作为参数来尝试相同的代码片段，以获得不同的输出。我们也可以学到更多。希望你一定喜欢它。
A*算法——算法介绍(带 Python 实现)
原文：https://www.askpython.com/python/examples/a-star-algorithm
在本文中，让我们试着理解 A*算法的概念及其重要性。它是一种启发式搜索算法，主要用于确定几个选项中哪一个对达到特定目标状态最有效。
什么是 A*算法？
a算法(读作 A-star)是“分支定界搜索算法”和“最佳搜索算法”与动态规划原理的结合。A算法是众所周知的，因为它用于定位路径和图形遍历。这种算法被用在许多在线地图和游戏中。它使用通常用 f(X)表示的启发式或评估函数来确定搜索访问树中节点的顺序。节点 N 的启发式函数定义如下:
f(N) = g(N)+h(N)
函数 g 是从起始节点到当前节点 N 的成本的度量，即，它是沿着到当前节点的最佳路径应用的规则的成本的总和。函数 h 是从当前节点 N 到目标节点的附加成本的估计。这是利用问题领域知识的地方。一般来说，A*算法被称为或图/树搜索算法。
A*算法从起始节点开始逐步搜索所有路由，直到找到到达目标的最短路径。从给定的节点开始，该算法扩展具有最低 f(x)值的节点。它维护一组部分解决方案。扩展节点的未扩展叶节点存储在具有相应 f 值的队列中。该队列可以作为优先级队列来维护。
例子
让我们再次考虑一个 8 字谜的例子，并通过使用 A*算法来解决它。简单评估函数 f(x)定义如下:
f(x) = g(x)+h(X),
在哪里
- h(X) =在给定状态 X 下，不在目标位置的瓷砖数量
- g(X) =搜索树中节点 X 的深度
考虑到
Initial State
让我们试着借助 g(x)和 h(x)计算 f(x)的值，为这个问题开发一个搜索树。
Search Tree
用 Python 实现
from copy import deepcopy
import numpy as np
import time
def bestsolution(state):
bestsol = np.array([], int).reshape(-1, 9)
count = len(state) - 1
while count != -1:
bestsol = np.insert(bestsol, 0, state[count]['puzzle'], 0)
count = (state[count]['parent'])
return bestsol.reshape(-1, 3, 3)
# checks for the uniqueness of the iteration(it).
def all(checkarray):
set=[]
for it in set:
for checkarray in it:
return 1
else:
return 0
# number of misplaced tiles
def misplaced_tiles(puzzle,goal):
mscost = np.sum(puzzle != goal) - 1
return mscost if mscost > 0 else 0
def coordinates(puzzle):
pos = np.array(range(9))
for p, q in enumerate(puzzle):
pos[q] = p
return pos
# start of 8 puzzle evaluvation, using Misplaced tiles heuristics
def evaluvate_misplaced(puzzle, goal):
steps = np.array([('up', [0, 1, 2], -3),('down', [6, 7, 8], 3),('left', [0, 3, 6], -1),('right', [2, 5, 8], 1)],
dtype = [('move', str, 1),('position', list),('head', int)])
dtstate = [('puzzle', list),('parent', int),('gn', int),('hn', int)]
costg = coordinates(goal)
# initializing the parent, gn and hn, where hn is misplaced_tiles function call
parent = -1
gn = 0
hn = misplaced_tiles(coordinates(puzzle), costg)
state = np.array([(puzzle, parent, gn, hn)], dtstate)
#priority queues with position as keys and fn as value.
dtpriority = [('position', int),('fn', int)]
priority = np.array([(0, hn)], dtpriority)
while 1:
priority = np.sort(priority, kind='mergesort', order=['fn', 'position'])
position, fn = priority[0]
# sort priority queue using merge sort,the first element is picked for exploring.
priority = np.delete(priority, 0, 0)
puzzle, parent, gn, hn = state[position]
puzzle = np.array(puzzle)
blank = int(np.where(puzzle == 0)[0])
gn = gn + 1
c = 1
start_time = time.time()
for s in steps:
c = c + 1
if blank not in s['position']:
openstates = deepcopy(puzzle)
openstates[blank], openstates[blank + s['head']] = openstates[blank + s['head']], openstates[blank]
if ~(np.all(list(state['puzzle']) == openstates, 1)).any():
end_time = time.time()
if (( end_time - start_time ) > 2):
print(" The 8 puzzle is unsolvable \n")
break
hn = misplaced_tiles(coordinates(openstates), costg)
# generate and add new state in the list
q = np.array([(openstates, position, gn, hn)], dtstate)
state = np.append(state, q, 0)
# f(n) is the sum of cost to reach node
fn = gn + hn
q = np.array([(len(state) - 1, fn)], dtpriority)
priority = np.append(priority, q, 0)
if np.array_equal(openstates, goal):
print(' The 8 puzzle is solvable \n')
return state, len(priority)
return state, len(priority)
# initial state
puzzle = []
puzzle.append(2)
puzzle.append(8)
puzzle.append(3)
puzzle.append(1)
puzzle.append(6)
puzzle.append(4)
puzzle.append(7)
puzzle.append(0)
puzzle.append(5)
#goal state
goal = []
goal.append(1)
goal.append(2)
goal.append(3)
goal.append(8)
goal.append(0)
goal.append(4)
goal.append(7)
goal.append(6)
goal.append(5)
state, visited = evaluvate_misplaced(puzzle, goal)
bestpath = bestsolution(state)
print(str(bestpath).replace('[', ' ').replace(']', ''))
totalmoves = len(bestpath) - 1
print('\nSteps to reach goal:',totalmoves)
visit = len(state) - visited
print('Total nodes visited: ',visit, "\n")
输出:
Implementation
A*的可受理性
对于任何一个图，如果从起始状态到目标状态的最优路径存在，那么搜索算法是可接受的。我们前面已经看到，如果试探函数“h”低估了从当前状态到目标状态的实际值，那么它必然给出最优解，因此被称为容许函数。因此，我们可以说，在 h 是一个可接受的启发函数的情况下，A*总是以最优路径终止。
限制
用于计算 h 的启发式技术的精度对执行 A*搜索(n)的速度有很大的影响。因此，具有复杂性的问题。
摘要
在本文中，我们学习了一种被称为 A*算法的最佳算法。这种搜索算法有助于解决许多常见的寻路问题，如 N 皇后问题、0-1 背包问题、旅行推销员问题等。这种算法以解决复杂问题而闻名，它也用于网络路由协议。它也有助于定义其他算法。它在人工智能领域有着广泛的应用。
Python 中的绝对导入与相对导入
原文：https://www.askpython.com/python-modules/absolute-vs-relative-importing
你好，学习伙伴！今天我们将学习 Python 中绝对导入和相对导入的区别。
每次你需要一个直接的函数来实现我们程序中的任何东西，我们可以直接从正确的库中导入它！现在让我们学习 Python 编程中的绝对和相对导入。
什么是绝对进口？
当我们通过绝对导入来导入模块时，我们需要在 import关键字后面包含模块的完整路径。
完整路径包括主模块/库以及程序中使用的子模块或函数。
绝对进口的优势
- 这种方法清晰、直截了当且易于理解
- 即使 import 语句的当前位置在以后发生了变化，absolute import 命令仍然有效。
绝对进口的缺点
让我们假设，我们必须导入一个存在于根模块更深层的函数。此类模块的绝对导入命令如下所示:
from package_1.sub_package_1.sub_package2.sub_package3.module1 import req_function
如果所需的功能存在于更深的层中，那么就会变得非常混乱和复杂。这时候相对进口来拯救！
什么是相对导入？
在相对方法中，我们可以相对于某个包或子包的位置来导入一个函数，这是一种更好的导入模块和函数的方法。
我们有两种类型的相对导入方法，即implicit和explicit方法，但是隐式方法不再支持 Python3.x 版本。
相对导入方法如下所示:
from .sub_package_x.module_5 import req_function
最初的.考虑了所有之前的主机模块/库，我们不需要像绝对导入那样写整个东西。
相对进口的优势
- 重要陈述简短明了。
- 降低导入语句的复杂性
相对进口的缺点
- 这种方法可读性不强，而且程序员不知道许多根模块。
- 程序员不知道我们正在导入的函数的来源
结论——绝对进口与相对进口
现在您知道了绝对和相对导入方法之间的基本区别。
我建议你作为初学者选择绝对方法，随着你编码经验的增加，你可以开始使用相对方法。
理解 Python 中的抽象
原文：https://www.askpython.com/python/oops/abstraction-in-python
导言
在今天的教程中，我们将讨论 Python 中面向对象编程方法的抽象概念。
如果你是第一次接触 OOP ，我们强烈推荐你阅读我们的Python 中的面向对象编程文章。
基本上，抽象关注于对用户隐藏过程或方法的内部实现。这样，用户知道他在做什么，但不知道工作是如何完成的。
让我们更深入地挖掘这个主题，以发现它在现实生活和编程中的重要性。
Python 中的抽象是什么？
在面向对象编程中，继承、多态和封装齐头并进。但是抽象也是 OOP 的基本元素。
例如，人们并不认为汽车是由成千上万个独立零件组成的。相反，他们认为它是一个定义明确的对象，有自己独特的行为。这种抽象允许人们在不知道组成汽车的部件的复杂性的情况下使用汽车来驾驶。他们可以忽略发动机传动系统和制动系统如何工作的细节。相反，他们可以自由地将对象作为一个整体来使用。
管理抽象的一个强有力的方法是通过使用层次分类。这允许我们将复杂系统的语义分层，将它们分成更易管理的部分。从外面看，汽车是一个单一的物体。一旦进入车内，你会看到汽车由几个子系统组成:转向、刹车、音响系统、安全带等。反过来，这些子系统又由更小的单元组成。
关键是我们通过使用层次抽象来管理汽车(或任何其他复杂系统)的复杂性。
这也可以应用于使用 OOP 概念的计算机程序。这是面向对象编程的精髓。
Python 中的抽象类和方法
要声明一个抽象类，我们首先需要导入abc模块。让我们看一个例子。
from abc import ABC
class abs_class(ABC):
#abstract methods
这里，abs_class是抽象类，在其中可以定义抽象方法或任何其他种类的方法。
作为一个属性，抽象类可以有任意数量的抽象方法与任意数量的其他方法共存。例如，我们可以在下面看到。
from abc import ABC, abstractmethod
class abs_class(ABC):
#normal method
def method(self):
#method definition
@abstractmethod
def Abs_method(self):
#Abs_method definition
这里，method()是普通方法，而Abs_method()是从 abc 模块实现@abstractmethod的抽象方法。
Python 抽象示例
现在我们知道了抽象类和方法，让我们看一个例子，它解释了 Python 中的抽象。
from abc import ABC, abstractmethod
class Absclass(ABC):
def print(self,x):
print("Passed value: ", x)
@abstractmethod
def task(self):
print("We are inside Absclass task")
class test_class(Absclass):
def task(self):
print("We are inside test_class task")
class example_class(Absclass):
def task(self):
print("We are inside example_class task")
#object of test_class created
test_obj = test_class()
test_obj.task()
test_obj.print(100)
#object of example_class created
example_obj = example_class()
example_obj.task()
example_obj.print(200)
print("test_obj is instance of Absclass? ", isinstance(test_obj, Absclass))
print("example_obj is instance of Absclass? ", isinstance(example_obj, Absclass))
输出:
Python Abstraction Example
这里，
Absclass是从 ABC 模块的 ABC 类继承而来的抽象类。它包含一个用户可见的抽象方法task()和一个print()方法。从这个抽象类继承的另外两个类是test_class和example_class。两者都有自己的task()方法(抽象方法的扩展)。
在用户从 test_class 和 example_class 两个类中创建对象并为它们调用task()方法后，两个类中task()方法的隐藏定义开始发挥作用。这些定义对用户来说是隐藏的。来自抽象类Absclass的抽象方法task()实际上从未被调用过。
但是当对 test_obj 和 example_obj 都调用print()方法时，就会调用 Absclass 的print()方法，因为它不是抽象方法。
注意:我们不能创建抽象类的实例。它引发了一个Error。
结论
所以今天在本教程中，我们理解了 Python 中抽象的概念。
对于任何进一步的相关问题，请随意使用下面的评论。
参考
Python 中的 4 个激活函数要知道！
原文：https://www.askpython.com/python/examples/activation-functions-python
读者朋友们，你们好！在本文中，我们将详细关注 Python 激活函数。
所以，让我们开始吧！！🙂
什么是激活函数？
在神经网络和卷积模型深度学习的世界中，Python 在数据建模和分析方面一直发挥着重要作用。
激活函数是数学基础模型，使我们能够控制神经网络模型的输出。也就是说，它帮助我们分析和估计对模型的实现做出贡献的神经元是被保留还是被移除(激发)。
一些突出的激活功能–
了解了激活函数之后，现在让我们在下一节看看上面的激活函数。
1.ReLu 函数
ReLu 函数是一种激活函数，它使我们能够即兴创作神经网络的卷积图。它根据模型结果检测神经网络的状态。
ReLu 函数声明当输入为负时，返回零。否则对于非负输入，它返回 1。
举例:
这里，我们使用 Python 中的 max()函数实现了一个用户定义的函数来灌输 ReLu 条件。
def ReLu(ar):
return max(0.0,ar)
ar = 1.0
print(ReLu(ar))
ar1= -1.0
print(ReLu(ar1))
输出—
1.0
0.0
2.泄漏 ReLu 函数
梯度分数，即传递给 ReLu 函数的非零输入的导数值，被发现为零。这基本上说明了权重没有被学习函数正确地更新。
为了克服 ReLu 函数的梯度问题，我们引入了泄漏 ReLu 函数。
Leaky ReLu 函数在传递给函数的负(非零)输入权重上附加一个小的线性分量(常数值)。这样，这些非零输入权重的梯度分数变成了非零值。
举例:
def ReLu(x):
if x>0 :
return x
else :
return 0.001*x
x = -1.0
print(ReLu(x))
输出 t:
-0.001
3.Sigmoid 函数
sigmoid 激活函数简单地基于以下 Sigmoid 数学公式
Sigmoid formula
由于分母总是大于 1，因此该激活函数的输出总是在 0 和 1 之间。
举例:
import numpy as np
def sigmoid(num):
return 1/(1 + np.exp(-num))
num = -1.0
print(sigmoid(num))
输出:
0.2689414213699951
4.Softmax 函数
softmax 激活函数可以被称为一个数学模型，它接受一个数字数据变量向量作为输入，然后对数据进行归一化。
也就是说，将(缩放数据值)归一化为概率分布，其中每个数据值的概率与向量中存在的每个值的比例成比例。
因此，所有数据值都将在 0–1 的范围内。此外，所有数据值的总和将等于 1，因为它们被解释为概率。
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
更多与 Python 编程相关的帖子，请继续关注我们。
在那之前，学习愉快！！🙂
用 Python 添加换行符——6 种简单的方法！
原文：https://www.askpython.com/python/examples/add-a-newline-character-in-python
嘿伙计们！希望你们都过得好。在本文中，我们将揭示在 Python 中添加换行符(\n)到要打印的数据输出的不同方法。
所以，让我们开始吧！
技巧 1:在多行字符串中添加换行符
Python 多行字符串提供了一种以对齐方式表示多个字符串的有效方式。换行符(\n)可以添加到多行字符串中，如下所示
语法:
string = '''str1\nstr2....\nstrN'''
在多行字符串中，我们可以很容易地在想要显示在新行上的每个字符串前使用’ \n '。
举例:
str='''Hello all!! \nI am Pythoner \nWelcome to the AskPython Tutorial'''
print(str)
输出:
Hello all!!
I am Pythoner
Welcome to the AskPython Tutorial
技术 2:在 Python 列表中添加新行
Python List 可以认为是一个动态数组，在动态运行时将异构元素存储到其中。
string.join()函数可用于在列表元素中添加新行，如下所示
语法:
'\n'.join(list)
举例:
lst = ['Python','Java','Kotlin','Cpp']
print("List before adding newline character to it:",lst)
lst = '\n'.join(lst)
print("List after adding newline character to it:\n",lst)
输出:
List before adding newline character to it: ['Python', 'Java', 'Kotlin', 'Cpp']
List after adding newline character to it:
Python
Java
Kotlin
Cpp
技术 3:在控制台上显示换行符
在最开始的阶段，了解控制台上功能的执行是很重要的。要在控制台上添加换行符，请使用以下代码
print("str1\nstr2")
举例:
Python newline with console
技巧 4:通过打印语句显示新行
换行符可以添加到 print()函数中，以便在新的一行上显示字符串，如下所示
语法:
print("str1\nstr2\n...\strN")
举例:
print("Hello Folks! Let us start learning.")
print("Statement after adding newline through print() function....")
print("Hello Folks!\nLet us start learning.")
输出:
Hello Folks! Let us start learning.
Statement after adding newline through print() function....
Hello Folks!
Let us start learning.
技巧 5:通过 Python f-string 添加一个换行符
Python f-string 也在控制台上以格式化的方式表示字符串语句。要通过 f 字符串添加换行符，请遵循以下语法:
newline = '\n'
string = f"str1{newline}str2"
举例:
newline = '\n'
str = f"Python{newline}Java{newline}Cpp"
print(str)
输出:
Python
Java
Cpp
技巧 6:向文件中写入新的一行
可以使用以下语法将换行符追加到 Python 文件中:
语法:
file_object.write("\n")
举例:
这里，我们使用了 Python.txt 文件，其中包含如下所示的预定义内容
Python Text-file
import os
file = "/Python.txt"
with open(file, 'a') as file:
file.write("\n")
输出:
如下所示，新的一行被添加到文件内容中。
Add newline To A Python File
结论
到此，我们就结束了这个话题。如果你遇到任何问题，请随时在下面评论。
在那之前，学习愉快！！
参考
如何在 Matplotlib 中添加网格线？
原文：https://www.askpython.com/python-modules/matplotlib/add-grid-lines
在本文中，我们将学习如何在 Matplotlib 绘图中添加网格线。Matplotlib 是一个 python 绘图库，它为创建科学绘图和图形提供了一个交互式环境。让我们直接进入主题。
向 Matplot 库图添加网格线的步骤
现在让我们回顾一下将网格线添加到 Matplotlib 图的步骤。
1.安装模块
Matplotlib–
pip install matplotlib
Pyplot –
pyplot 子模块包含 Matplotlib 的大部分功能
注意:编译器通常没有显示图形的能力，但是在 Python 中，我们可以通过添加几行代码使它们兼容:
import sys
import matplotlib
matplotlib.use('Agg')
# Matplotlib relies on a backend to render the plots and here ‘Agg’ is the default backend
import matplotlib.pyplot as pyt
# lines of code for plotting a graph
pyt.savefig(sys.stdout.buffer)
sys.stdout.flush()
# these two lines are used to avoid excess buffering and print the data without any delay and make sure the code works
示例:
import sys
import matplotlib
matplotlib.use('Agg')
# Matplotlib relies on a backend to render the plots and here ‘Agg’ is the default backend
import matplotlib.pyplot as pyt
import numpy as np
x = np.array([0, 10])
y = np.array([0, 200])
pyt.plot(x, y)
pyt.show()
pyt.savefig(sys.stdout.buffer)
sys.stdout.flush()
Plot A Graph
2.向地块添加网格线
我们可以在 Pyplot 中使用 grid() 函数来添加网格线。
示例:
x = np.array([0,10])
y = np.array([0,200])
pyt.title("Sales of Ice Cream")
# to represent the title on the plot
pyt.xlabel("Days") # to label the x-axis
pyt.ylabel("Customers") # to label the y-axis
pyt.plot(x, y)
pyt.grid()
pyt.show()
Plot
3.指定要显示的网格线
使用 grid()函数中的轴参数，我们可以指定显示哪些网格线。允许的值有:**‘x’，‘y’，**或‘两者’。但是缺省值是‘both ’,所以我们可以避免写它。
示例:
- 仅显示 x 轴网格线:
pyt.grid(axis = ‘y’)
Plot Only X Axis
- 仅显示 y 轴网格线:
pyt.grid(axis = ‘x’)
Plot Y Axis
4.设置网格的线条属性
我们可以用各种方式设置网格的属性，如颜色、样式等。
我们将样式定义为:color= 'specify_color '，linestyle='specify_linestyle '，linewidth= number，axis='specify_axis('x ‘，’ y ‘或’ both ‘)’
例如:
pyt.grid(color = 'red', linestyle = '--', linewidth = 0.75, axis='both')
Grid Property Changed Plot
结论
教程到此为止！希望你已经很好地学习了如何在 Python 中绘制网格线，以及使用 matplotlib 库可能得到的网格线的各种属性。请继续关注 Python，获取更多关于 Python 的教程。
如何给熊猫数据框添加一个新列？
原文：https://www.askpython.com/python-modules/pandas/add-new-column-to-dataframe
在本教程中，我们将讨论向 pandas 数据框添加新列的不同方法。
什么是熊猫数据框？
Pandas data frame 是一种二维异构数据结构，以表格形式存储数据，并带有标记索引，即行和列。
通常，当我们必须处理大型数据集时，会使用数据框，然后我们可以通过将该大型数据集加载到 pandas 数据框中来查看其摘要，并查看数据框的摘要。
在现实场景中，熊猫数据框是通过从现有的 CSV 文件、Excel 文件等加载数据集来创建的。
但是也可以从列表、字典、列表列表、字典列表、n 数组/列表字典等创建 pandas 数据帧。在我们开始讨论如何向现有数据框添加新列之前，我们需要一个 pandas 数据框。
安装和导入熊猫
我们需要 Python 的熊猫库来处理数据帧，所以我们必须首先安装熊猫库，然后将其导入 Python 程序。以下是安装和导入 pandas 的命令:
# Installing pandas Python library
pip install pandas
# Importing pandas into the program
import pandas as pd
在我们开始讨论如何向现有的 pandas 数据框添加新列之前，我们需要一个 pandas 数据框。
从列表字典创建数据框
# Creating a dictionary of lists
data = {'name': ['Sanjay', 'Ravi', 'Shreya', 'Abhishek', 'Shantanu'],
'roll': [55, 65, 75, 85, 95]}
# Creating a pandas data frame from the above data
df = pd.DataFrame(data)
print(df)
输出:
现在，让我们讨论向我们刚刚创建的现有数据框添加新列的不同方法。向现有数据框中添加新列有多种方法，但这里我们将只讨论三种主要的可靠且强大的方法。
使用数据帧索引添加新列
这是向现有 pandas 数据框添加新列的最简单方法，我们只需用新列的名称对现有数据框进行索引，并为相应的行分配一个要存储在列中的值列表:
# Adding a new column named 'cgpa' to the data frame
# Using DataFrame indexing
df['cgpa'] = [8.1, 9.3, 8.2, 7.9, 7.5]
print(df)
输出:
使用 assign() 向 pandas 数据框添加新列
这是使用 pandas 内置的assign()方法向现有数据框添加新列的第二种健壮方法。这将向现有数据框添加一个新列，然后返回一个包含添加列的新数据框。让我们看看使用它的 Python 代码:
# Adding a new column named 'address' to the data frame
# Using the assign() method
# And saving the new returned data frame
df2 = df.assign(address = ['Bihar', 'Bihar', 'Jharkhand', 'UP', 'UP'])
print(df2)
输出:
使用 insert()方法添加新列
这是向现有数据框添加新列的第三种有效方式。与以前向数据框添加列的方法不同，以前的方法只是将新列作为最后一列添加到数据框的末尾，而insert()方法允许我们在现有数据框中的任何指定位置添加新列。让我们看看使用它的 Python 代码:
# Adding a column named 'branch'to the data frame
# Using the insert() method
# First argument is the column position
# Second argument is the column name
# And third argument is the column value
df2.insert(3, 'branch', ['ECE', 'CSE', 'ECE', 'EE', 'ECE'])
print(df2)
输出:
在输出中，可以清楚地看到名为 分支 的新列被添加到 Python 代码中指定的第三列索引处。
结论
因此，在本教程中，我们学习了什么是 pandas 数据框架，如何从列表字典创建新的数据框架，以及向现有数据框架添加新列的三种可靠方法:DataFrame索引、assign()方法和insert()方法。
向熊猫数据框架添加行的 5 种简单方法
原文：https://www.askpython.com/python-modules/pandas/add-rows-to-dataframe
在本 Python 教程中，我们将讨论向 pandas DataFrame 对象添加或插入一行或多行的前五种方法。那么，我们开始讨论吧。
向 Pandas 数据帧添加行的方法
让我们首先创建一个示例 pandas DataFrame 对象，然后我们将使用以下方法向它添加一行或多行。
# Import pandas Python module
import pandas as pd
# Create a sample pandas DataFrame object
df = pd.DataFrame({'RegNo': [111, 112, 113, 114, 115],
'Name': ['Gautam', 'Tanya', 'Rashmi', 'Kirti', 'Ravi'],
'CGPA': [8.85, 9.03, 7.85, 8.85, 9.45],
'Dept': ['ECE', 'ICE', 'IT', 'CSE', 'CHE'],
'City': ['Jalandhar','Ranchi','Patna','Patiala','Rajgir']})
# Print the created pandas DataFrame
print('Sample pandas DataFrame:\n')
print(df)
输出:
Sample pandas DataFrame:
RegNo Name CGPA Dept City
0 111 Gautam 8.85 ECE Jalandhar
1 112 Tanya 9.03 ICE Ranchi
2 113 Rashmi 7.85 IT Patna
3 114 Kirti 8.85 CSE Patiala
4 115 Ravi 9.45 CHE Rajgir
方法 1
将 pandas 系列对象作为一行添加到现有的 pandas DataFrame 对象中。
# Create a pandas Series object with all the column values passed as a Python list
s_row = pd.Series([116,'Sanjay',8.15,'ECE','Biharsharif'], index=df.columns)
# Append the above pandas Series object as a row to the existing pandas DataFrame
# Using the DataFrame.append() function
df = df.append(s_row,ignore_index=True)
# Print the modified pandas DataFrame object after addition of a row
print('Modified Sample pandas DataFrame:\n')
print(df)
输出:
Modified Sample pandas DataFrame:
RegNo Name CGPA Dept City
0 111 Gautam 8.85 ECE Jalandhar
1 112 Tanya 9.03 ICE Ranchi
2 113 Rashmi 7.85 IT Patna
3 114 Kirti 8.85 CSE Patiala
4 115 Ravi 9.45 CHE Rajgir
5 116 Sanjay 8.15 ECE Biharsharif
方法 2
将一个 Python 字典作为一行添加到现有的 pandas DataFrame 对象中。
# Create a Python dictionary object with all the column values
d_row = {'RegNo':117,'Name':"Sarthak",'CGPA':8.88,'Dept':"ECE",'City':"Allahabad"}
# Append the above Python dictionary object as a row to the existing pandas DataFrame
# Using the DataFrame.append() function
df = df.append(d_row,ignore_index=True)
# Print the modified pandas DataFrame object after addition of a row
print('Modified Sample pandas DataFrame:\n')
print(df)
输出:
Modified Sample pandas DataFrame:
RegNo Name CGPA Dept City
0 111 Gautam 8.85 ECE Jalandhar
1 112 Tanya 9.03 ICE Ranchi
2 113 Rashmi 7.85 IT Patna
3 114 Kirti 8.85 CSE Patiala
4 115 Ravi 9.45 CHE Rajgir
5 116 Sanjay 8.15 ECE Biharsharif
6 117 Sarthak 8.88 ECE Allahabad
**注意:**在传递 Python 字典或熊猫系列时，请将DataFrame.append()函数的ignore_index参数设置为True，否则会抛出错误。
方法 3
使用DataFrame.loc[]方法将 Python 列表对象作为一行添加到现有的 pandas DataFrame 对象中。
# Create a Python list object with all the column values
l_row = [118,"Kanika",7.88,"EE","Varanasi"]
# Append the above Python list object as a row to the existing pandas DataFrame
# Using the DataFrame.loc[]
df.loc[7] = l_row
# Print the modified pandas DataFrame object after addition of a row
print('Modified Sample pandas DataFrame:\n')
print(df)
输出:
Modified Sample pandas DataFrame:
RegNo Name CGPA Dept City
0 111 Gautam 8.85 ECE Jalandhar
1 112 Tanya 9.03 ICE Ranchi
2 113 Rashmi 7.85 IT Patna
3 114 Kirti 8.85 CSE Patiala
4 115 Ravi 9.45 CHE Rajgir
5 116 Sanjay 8.15 ECE Biharsharif
6 117 Sarthak 8.88 ECE Allahabad
7 118 Kanika 7.88 EE Varanasi
方法 4
使用DataFrame.append()函数将一个 pandas DataFrame 对象的行添加到另一个 pandas DataFrame 对象中。
# Create a new pandas DataFrame object
df2 = pd.DataFrame({'RegNo': [119, 120, 121],
'Name': ['Gaurav', 'Thaman', 'Radha'],
'CGPA': [8.85, 9.03, 7.85],
'Dept': ['ECE', 'ICE', 'IT'],
'City': ['Jalandhar','Ranchi','Patna']})
# Print the newly created pandas DataFrame object
print('New pandas DataFrame:\n')
print(df2)
# Append the rows of the above pandas DataFrame to the existing pandas DataFrame
# Using the DataFrame.append()
df = df.append(df2,ignore_index=True)
# Print the modified pandas DataFrame object after addition of rows
print('\nModified Sample pandas DataFrame:\n')
print(df)
输出:
New pandas DataFrame:
RegNo Name CGPA Dept City
0 119 Gaurav 8.85 ECE Jalandhar
1 120 Thaman 9.03 ICE Ranchi
2 121 Radha 7.85 IT Patna
Modified Sample pandas DataFrame:
RegNo Name CGPA Dept City
0 111 Gautam 8.85 ECE Jalandhar
1 112 Tanya 9.03 ICE Ranchi
2 113 Rashmi 7.85 IT Patna
3 114 Kirti 8.85 CSE Patiala
4 115 Ravi 9.45 CHE Rajgir
5 116 Sanjay 8.15 ECE Biharsharif
6 116 Sanjay 8.15 ECE Biharsharif
7 118 Kanika 7.88 EE Varanasi
8 119 Gaurav 8.85 ECE Jalandhar
9 120 Thaman 9.03 ICE Ranchi
10 121 Radha 7.85 IT Patna
方法 5
使用DataFrame.iloc[]方法在现有 pandas DataFrame 对象的特定索引位置添加一行。
# Create a Python list object with all the column values
i_row = [122,"Zahir",6.88,"ME","Kolkata"]
# Append the above Python list object as a row to the existing pandas DataFrame
# At index 2 using the DataFrame.iloc[]
df.iloc[2] = i_row
# Print the modified pandas DataFrame object after addition of a row
print('Modified Sample pandas DataFrame:\n')
print(df)
输出:
Modified Sample pandas DataFrame:
RegNo Name CGPA Dept City
0 111 Gautam 8.85 ECE Jalandhar
1 112 Tanya 9.03 ICE Ranchi
2 122 Zahir 6.88 ME Kolkata
3 114 Kirti 8.85 CSE Patiala
4 115 Ravi 9.45 CHE Rajgir
5 116 Sanjay 8.15 ECE Biharsharif
6 116 Sanjay 8.15 ECE Biharsharif
7 118 Kanika 7.88 EE Varanasi
8 119 Gaurav 8.85 ECE Jalandhar
9 120 Thaman 9.03 ICE Ranchi
10 121 Radha 7.85 IT Patna
**注意:**使用DataFrame.iloc[]方法时请小心，因为它会用新行替换索引位置的现有行。
结论
在本教程中，我们已经学习了在现有的 pandas DataFrame 对象中添加或插入一行或多行的前五种方法。希望你已经很好地理解了上面讨论的东西，并准备在自己的数据分析项目中使用这些方法。感谢阅读！请继续关注我们，获取更多关于 Python 编程的精彩学习资源。
如何在 Python 中执行加法？
原文：https://www.askpython.com/python/examples/addition-in-python
在这篇文章中，我们将讨论一个最基本的话题。如果你是初学者，这对你有好处。但是如果你已经用 Python 写了代码，跳过这一步。
Python 中用户输入的两个数相加
我们将使用 input()方法接受用户输入，然后使用这些数字在 Python 中执行加法。python 中两个数相加的基本代码是:
def adding(x , y):
return x + y
a = int(input("Enter first number :" ))
b = int(input("Enter second number :"))
sum = adding(a , b)
print("addition of {} and {} is {}".format(a,b,sum))
输出是:
Enter first number : 6
Enter second number : 5
Addition of 6 and 5 is 11
在上面的代码中，我们使用 int()方法将字符串输入转换为整数，从而将输入类型转换为 int。
对列表中的元素进行加法运算
def add_list(l1) :
res = 0
for val in l1 :
res = res + val
return res
list = [1,3,5,7,9]
ans = add_list(list)
print("The sum of all elements within the given list is {}".format(ans))
这段代码的输出是:
The sum of all elements in the list is 25
在上面的代码中，我们定义了一个函数，在这个函数中，我们使用 for 循环来遍历列表中的所有元素，并在每次迭代后更新 res 的值。将我们的列表作为参数传递给 add_list 函数会给出我们的最终输出。
这是 python 中加法的基础。
高级 Python 概念
原文：https://www.askpython.com/python/advanced-python-concepts
今天让我们来看看一些更高级的 Python 概念。虽然我们已经在之前的教程中讨论了其中的一些概念，但本页将为您提供 Python 学习中常见高级概念的快速指南。
高级 Python 概念的简要列表
事不宜迟，让我们继续我们的第一个先进概念。
1.λ函数
在 Python 中， lambda 函数是一个声明为匿名的单行函数，即声明时没有名字，它可能有许多参数，但只有一个表达式。
语法:
lambda arguments: expression
- 如下面的语法所示，lambda 函数是通过使用关键字“lambda”来声明的。
- 然后我们写一个参数列表，lambda 函数可以带任意数量的参数，但不能是零。在冒号之后，我们编写一个表达式，将这些参数应用于任何实际操作。从语法上讲，lambda 函数仅限于单个表达式，即它只能包含一个表达式，不能超过一个。
举例:
remainder = lambda number: number%2
print (remainder (25))
说明:
在上面的代码中，lambda num: number%2是 lambda 函数。数字是参数，而数字% 2 是被计算并返回结果的表达式。
该表达式推导出输入 2 的输入模数。我们给 25 作为参数，除以 2，我们得到剩下的 1。
您应该注意到，上面脚本中的 lambda 函数没有被赋予任何名称。它只是将给定的项返回给标识符的其余部分。
然而，即使它是未知的，我们也有可能称它为正常函数。
这是 lambda 函数的另一个例子:
addition = lambda a, b: a+b
print (addition (19,55))
输出: 74
2.Python 中的理解
Python 中理解力为我们提供了一种压缩但简洁的方式来创造新的序列(如列表、集合、字典等)。)
Python 支持 4 种理解类型
- 列表理解
- 词典理解
- 一组
- 发电机
列表理解
列表是 Python 中基本的数据类型之一。每当您遇到一个变量名后跟一个方括号[ ]，或列表生成器，它是一个可以包含多个项目的列表，使其成为一种集成的数据类型。同样，宣布一个新的列表，然后向其中添加一个或多个项目也是一个好主意。
示例:
even_numbers = [2, 4, 6, 8, 10]
print (even_numbers)
输出:
[2,4,6,8,10]
什么是列表理解？
简单来说，列表理解就是从现有列表中构建新列表的过程。或者，你可以说这是 Python 独特的方式，将循环的添加到列表中。事实上，列表理解比传统列表有很多优势。
首先，代码不超过一行，易于声明和阅读。使用理解比使用 for 循环更便于理解列表。最后，这也是创建一个新的、更动态的列表的简单、快速和准确的方法。
语法:
[expression for item in list]
运筹学
[expression for item in list if conditional]
list comprehension 的语法与其他语法有点不同，因为表达式是在循环之前提到的，但这就是它的工作方式。
举例:
n_letter = [letter for letter in 'encyclopedia']
print(n_letter)
输出:
[‘e ‘，’ n ‘，’ c ‘，’ y ‘，’ c ‘，’ l ‘，’ o ‘，’ p ‘，’ e ‘，’ d ‘，’ I ‘，’ a’]
词典理解
字典是一种称为关联数组的数据结构的 Python 实现。字典包含一组键值。每对密钥将密钥设置为其对应的值。您可以通过用大括号({})括起逗号分隔的键值对列表来定义字典。冒号(:)将每个键与其关联的值分隔开:
举例:
thisdict = {"name": "Ford","age": 34, "last_name": "Mustang"}
print(thisdict)
输出:
{'name': 'Ford', 'age': 34, 'last_name': 'Mustang'}
什么是词典理解？
字典理解类似于列表理解，但需要定义一个关键字:
语法:
output_dict = {key:value for (key, value) in iterable if (key, value satisfy this condition)}
举例:
在这个例子中，我们将使用一个常规函数执行与理解相同的功能。
sq_dict = dict()
for number in range(1, 9):
sq_dict[number] = number*number
print(sq_dict)
现在，让我们使用字典理解来尝试相同的功能
square_dict = {num: num*num for num in range(1, 9)}
print(square_dict)
输出:
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64}
集合理解
集合用于在单个变量中存储多个项目。集合是 Python 内置的用于存储数据集合的 4 种数据类型之一。其他 3 个列表、元组和字典，都有不同的属性和用途。
举例:
brand_set = {"Mustang", "Ferrari", "Ford","Aston Martin"}
print(brand_set)
输出:
{'Aston Martin', 'Mustang', 'Ford', 'Ferrari'}
什么是集合理解？
集合理解类似于列表理解。它们之间唯一的区别是集合理解使用了花括号{}。我们看下面这个例子来理解集合理解。
语法:
{expr for variable in iterable}
运筹学
{expression for variable in iterable if condition}
举例:
s = [1,2,3,4,5,4,6,6,7,8,8,]
using_comp = {var for var in s if var % 2 ==0}
print(using_comp)
输出:
{8, 2, 4, 6}
生成器理解
一个生成器是一种特殊类型的迭代器，它维护着关于如何分别产生它的单个组件的指令，以及它的当前复制状态。它只在迭代请求时产生每个成员，一次一个。
语法:
(expression for var in iterable if condition)
什么是生成器理解？
生成器理解和列表理解非常相似。两者的一个区别是，生成器理解用圆括号，列表理解用方括号。
它们之间的主要区别是生成器不为整个列表设置内存。相反，它们单独产生每个值，这就是为什么它们在内存中工作得如此之好。
举例:
input_list = [1, 2, 3, 4, 4, 5, 6, 7, 7]
output_gen = (var for var in input_list if var % 2 == 0)
print("Output values using generator comprehensions:", end = ' ')
for var in output_gen:
print(var, end = ' ')
输出:
Output values using generator comprehensions: 2 4 4 6
3.装饰函数
装饰器是强大而足智多谋的工具，允许程序员在不影响基本功能的情况下改变功能的性能。
你可以想到其他活动，比如普通甜甜圈；在甜甜圈上涂涂料的装饰工艺。不管你怎么装饰它们，它们还是甜甜圈。
换句话说，decorators 允许程序员包装另一个函数，以便在不改变其内部算法的情况下提高包装函数的性能。
语法:
@dec2
@dec1
def func (arg1, arg2, ...):
pass
4.哈希能力
Hashability 是 Python objects 的一个特性，它告诉我们一个对象是否有哈希值。如果一个项目有一个散列值，它可以被用作一个字典键或一个预置项目。
如果一个对象在其整个生命周期中有一个固定的哈希值，那么它就是可哈希的。Python 有一个内置的 hash 方法(__hash __())，可以和其他对象进行比较。
比较需要 __eq __()或 __cmp __()方法，如果可散列项相等，则它们具有相同的散列值。
举例:
s1 = (2,4,6,8,10)
s2 = (1,3,5,7,9)
#shows the id of the object
print(id(s1))
print(id(s2))
输出:
1898434378944
1898436290656
在上面的例子中，两个项目是不同的，因为不可转换类型的哈希值依赖于存储的数据，而不是它们的 id。
使用散列的最大优点是从字典中获取条目的快速搜索时间(例如，O (1)复数时间)。类似地，检查某个东西是否是一个集合需要正常的时间。
换句话说，使用散列作为启动过程为各种标准操作提供了高性能，例如对象检测、对象安装和对象测试，使用了在引擎盖下具有散列表的头部。
结论
在本文中，我们回顾了 Python 中的五个高级概念。这里快速回顾一下最重要的信息。
- Lambda activities :使用 Lambda 函数执行一个简单的任务，通常是在另一个函数调用中，比如 filter()或 max()。
- 理解:这是一种简单有效的方法，可以从系统中制作列表、字典和收藏。
- 生成器:延迟求值的迭代器，仅在被请求时才提供条目，因此，它们在内存中工作得很好。当按顺序处理大数据时，应该使用它们。
- decorator:当你想寻找其他非算法变化和当前函数时，decorator 很有用。另外，装饰者可以重复使用。一旦定义好了，它们就可以随心所欲地修饰许多功能。
- Hashability : Strength 是 Python 对象的必备组件，可以作为字典键或者 set 对象使用。他们提供了一种方法来恢复和安装一些有效的东西，以及成员测试。
这是关于 python 中一些高级主题的简单介绍。
希望这有所帮助！
Python Tkinter: GUI 年龄计算器
原文：https://www.askpython.com/python-modules/tkinter/age-calculator
你好，初学者！今天我们将使用 Python Tkinter 构建一个 GUI 应用程序——年龄计算器。
让我们开始吧！
应用程序的名称说明了应用程序将要做的一切，所以让我们开始构建应用程序。
设计年龄计算器界面
任何项目的第一步都是设计应用程序窗口。设计包括两个步骤，即:
- 创建自定义窗口
- 向窗口应用程序添加元素
创建自定义窗口
创建空的自定义窗口。我们必须导入tkinter模块并创建一个窗口对象。然后我们添加窗口应用程序的背景颜色和标题。
我们还将可调整大小的功能设置为 False 以确保尺寸保持不变。相同的代码如下所示。
import tkinter as tk
window = tk.Tk()
window.geometry("400x300")
window.config(bg="#F7DC6F")
window.resizable(width=False,height=False)
window.title('Age Calculator!')
向窗口添加所有必需的元素
下一步包括在我们的应用程序中添加所有的标签、输入框、按钮和文本框。
1.标签
我们将使用多个标签，每个标签将服务于不同的目的。我们有介绍信息的标签，询问用户出生日期的输入框的标签。
2.输入框
我们将使用三个输入框来输入用户的出生日期。一个是日期，一个是月份，最后一个是出生年份。
3.小跟班
在我们的应用程序中，我们将使用两个按钮，一个用于计算年龄，另一个用于退出应用程序。
4.文本框
我们将只使用一个文本框来显示计算出的年龄。
整个设计代码如下所示。我们将根据自己的喜好定制元素。如果你愿意，你可以改变它。
l1 = tk.Label(window,text="The Age Calculator!",font=("Arial", 20),fg="black",bg="#F7DC6F")
l2 = tk.Label(window,font=("Arial",12),text="Enter your birthday which includes the day-month-year.",fg="black",bg="#F7DC6F")
l_d=tk.Label(window,text="Date: ",font=('Arial',12,"bold"),fg="darkgreen",bg="#F7DC6F")
l_m=tk.Label(window,text="Month: ",font=('Arial',12,"bold"),fg="darkgreen",bg="#F7DC6F")
l_y=tk.Label(window,text="Year: ",font=('Arial',12,"bold"),fg="darkgreen",bg="#F7DC6F")
e1=tk.Entry(window,width=5)
e2=tk.Entry(window,width=5)
e3=tk.Entry(window,width=5)
b1=tk.Button(window,text="Calculate Age!",font=("Arial",13),command=get_age)
l3 = tk.Label(window,text="The Calculated Age is: ",font=('Arial',12,"bold"),fg="darkgreen",bg="#F7DC6F")
t1=tk.Text(window,width=5,height=0,state="disabled")
b2=tk.Button(window,text="Exit Application!",font=("Arial",13),command=exit)
将元素放置在屏幕上
为了在屏幕上放置元素，我们使用了place函数，该函数需要元素的 x 和 y 坐标来将项目放置在正确的位置。
放置元素的代码如下所示:
l1.place(x=70,y=5)
l2.place(x=10,y=40)
l_d.place(x=100,y=70)
l_m.place(x=100,y=95)
l_y.place(x=100,y=120)
e1.place(x=180,y=70)
e2.place(x=180,y=95)
e3.place(x=180,y=120)
b1.place(x=100,y=150)
l3.place(x=50,y=200)
t1.place(x=240,y=203)
b2.place(x=100,y=230)
Tkinter 中年龄计算器的界面
应用程序的最终设计看起来像下面显示的窗口。
Initial State Age Calculator
向按钮添加功能
1.计算年龄按钮
为了计算年龄，我们首先必须从三个输入框中获得三个输入(数据-月-年)。现在，下一步涉及计算出生日期和当前日期之间的差异。
为了获得当前日期，我们从datetime模块导入date函数。我们还创建了一个存储今天整个日期的对象。相同的代码如下所示:
from datetime import date
today = date.today()
现在我们创建一个计算年龄的函数，并连接到计算年龄按钮。该函数获取三个条目，并找到年龄(当前和出生日期之间的差异)
在清除文本框中先前的信息后，计算的年龄将被插入到文本框中。相同的代码如下所示:
def get_age():
d= int(e1.get())
m=int(e2.get())
y=int(e3.get())
age = today.year-y-((today.month, today.day)<(m,d))
t1.config(state='normal')
t1.delete('1.0', tk.END)
t1.insert(tk.END,age)
t1.config(state='disabled')
突出显示的行是计算年龄的代码的主要语句。
2.退出应用程序按钮
对于退出应用程序按钮，我们简单地创建一个破坏窗口的函数，然后将commad属性添加到按钮声明中。
退出函数的代码如下所示:
def exit():
window.destroy()
Python 中年龄计算器的完整代码
下面提到了整个代码:
from datetime import date
today = date.today()
def exit():
window.destroy()
def get_age():
d= int(e1.get())
m=int(e2.get())
y=int(e3.get())
age =today.year-y-((today.month, today.day)<(m,d))
t1.config(state='normal')
t1.delete('1.0', tk.END)
t1.insert(tk.END,age)
t1.config(state='disabled')
import tkinter as tk
window = tk.Tk()
window.geometry("400x300")
window.config(bg="#F7DC6F")
window.resizable(width=False,height=False)
window.title('Age Calculator!')
l1 = tk.Label(window,text="The Age Calculator!",font=("Arial", 20),fg="black",bg="#F7DC6F")
l2 = tk.Label(window,font=("Arial",12),text="Enter your birthday which includes the day-month-year.",fg="black",bg="#F7DC6F")
l_d=tk.Label(window,text="Date: ",font=('Arial',12,"bold"),fg="darkgreen",bg="#F7DC6F")
l_m=tk.Label(window,text="Month: ",font=('Arial',12,"bold"),fg="darkgreen",bg="#F7DC6F")
l_y=tk.Label(window,text="Year: ",font=('Arial',12,"bold"),fg="darkgreen",bg="#F7DC6F")
e1=tk.Entry(window,width=5)
e2=tk.Entry(window,width=5)
e3=tk.Entry(window,width=5)
b1=tk.Button(window,text="Calculate Age!",font=("Arial",13),command=get_age)
l3 = tk.Label(window,text="The Calculated Age is: ",font=('Arial',12,"bold"),fg="darkgreen",bg="#F7DC6F")
t1=tk.Text(window,width=5,height=0,state="disabled")
b2=tk.Button(window,text="Exit Application!",font=("Arial",13),command=exit)
l1.place(x=70,y=5)
l2.place(x=10,y=40)
l_d.place(x=100,y=70)
l_m.place(x=100,y=95)
l_y.place(x=100,y=120)
e1.place(x=180,y=70)
e2.place(x=180,y=95)
e3.place(x=180,y=120)
b1.place(x=100,y=150)
l3.place(x=50,y=200)
t1.place(x=240,y=203)
b2.place(x=100,y=230)
window.mainloop()
输出:
现在我们已经完成了编码部分。让我们运行应用程序吧！它工作得很好，同样的情况可以在下面的输出中看到。
Output1 Age Calculator
Output2 Age Calculator
结论
恭喜你！今天你学会了如何建立你的年龄计算器！希望你玩得开心！
感谢您的阅读！
为什么交易员需要开始学习 Python？
原文：https://www.askpython.com/python/algorithmic-trading-with-python
作为交易者，你的主要目标可能是尽可能多的赚钱，尽可能快。手动交易很难实现这个目标。
这是因为手动下单会带来许多风险，包括基于情绪和心理偏见的错误，在价格不利时下单，以及错误的手动订单输入(如果这是一个大错误，可能会很糟糕)。
此外，人类无法与当今最先进的计算机程序的速度和处理能力相媲美，这些程序主宰着金融市场。这些计算机程序可以分析大量数据，比任何人类交易者更快地采取行动。
如果你想在当今高度竞争和技术驱动的金融市场中取得成功，你需要两样东西:算法交易和 Python ，一种用于算法交易的计算机编程语言。
但是算法交易和 Python 到底是什么，这两个工具如何帮助你在当今高度复杂的金融市场中取得成功？
这就是我们今天要学习的内容，所以请继续阅读，了解更多。
什么是算法交易？
算法交易也被称为算法交易、自动交易和黑箱交易，算法交易使用一个遵循预定义指令集(即算法)的计算机程序。预定义的指令集可以基于数学模型或 KPI，如时间、价格和数量。
世界各大银行和华尔街机构使用算法交易来交易传统资产(如股票)和较新的市场(如加密货币)。
交易者、投资者和程序员编写代码，一旦满足某些条件，这些代码就会执行交易。当正确执行时，交易算法可以以人工交易者无法比拟的速度和频率产生利润。
算法交易的一些优势包括:
- 实施自动化、基于规则的决策制定(消除了源于人为偏见的风险)。
- 即时准确地进行交易(这更有可能产生最佳和有利可图的结果)。
- 同时自动检查各种市场条件。
- 使用历史和实时数据进行回溯测试，以确定交易策略的可行性。
要更深入地了解算法交易及其利弊，请查看 Investopedia 的这篇好文章。
关于算法交易的最佳书籍，请看 Trality 的这个伟大列表。
Python 是什么？
Python 是一种开源的计算机编程语言，广泛应用于各种领域，包括算法交易。近年来，它已经成为算法交易的首选，因为它的所有软件包都可以免费用于商业用途。
它还被广泛应用于金融科技的其他领域，如数据分析、加密货币市场、风险管理和银行服务。
投资者和机构每天都在使用 Python 来执行各种功能，包括定量研究。它也用于原型，测试和执行交易算法。
Python 允许用户使用科学库(如 Pandas、NumPy、Scikit-learn 和 Zipline)构建复杂的统计模型。这些库的更新在开发人员社区中是经常发生的，这意味着它们每天都在改进。
虽然还有其他编程语言，但 Python 是金融科技领域最受欢迎的，尤其是在量化交易领域。由于如此多的算法交易都是使用 Python 进行的，如果你使用这种语言，合作、交换代码和众包也更容易。
似乎这些证明还不够有力，Python 也被一些世界上最大的公司使用，包括谷歌、脸书、Instagram、Stripe 和 Dropbox。
为什么要用 Python 做算法交易？
以下是交易者应该考虑学习 Python 的主要原因:
- 易用性和可访问性
Python 代码以其可读性和可访问性而闻名，这些品质使它成为那些从未使用过算法交易软件的人的理想选择。
由于其高度功能化的编程方法，在 Python 上编写和评估 algo 交易结构以及构建动态 Python 交易机器人通常要容易得多。
- 众多支持库
与其他编码语言不同，由于前面提到的扩展支持库，使用 Python 进行交易需要的代码行更少。这也意味着最常用的编程任务已经被脚本化，限制了需要编写的代码长度。
- 增加交易组合的可扩展性
并行化和 Python 强大的计算能力赋予了您的交易组合可伸缩性。与其他语言相比，给 Python 添加新模块并使其具有可扩展性也更容易。由于现有的模块，交易者可以更容易地在不同的程序之间共享功能。
- 调试无忧
Python 中的调试既全面又彻底，因为允许对代码和数据进行实时修改。这加快了调试过程，因为出现的是单个错误，而不是多个错误，并且可以解决。
使用 Python 的缺点
虽然使用 Python 进行在线交易有明显的好处，但也有一些缺点:
- 变量存储不必要的数据
因为在 Python 中每个变量都被认为是一个对象，所以每个变量都会存储不必要的数据，比如值、大小和引用指针。如果不同变量的内存管理效率不高，这可能会导致严重的性能瓶颈和内存泄漏。
- 移动计算效率更低
虽然 Python 非常适合桌面和服务器应用程序，但它的移动计算效率较低。Python 通常被视为移动计算的弱语言，这就是为什么很少有移动应用程序是用它构建的。
Python 与其他编程语言相比如何？
与其他主要的编程语言(如 C++ 和 R)相比，Python 被认为更容易掌握和操作。然而，注意到所有这些编程语言都有独特的特性和它们自己独特的优点和缺点是有帮助的。因此，在为您的应用程序选择正确的语言时，您需要考虑这些因素。
Python 与 C++
C++以难学而闻名，这使得 Python 成为想快速学习如何开发动态交易算法的菜鸟交易者的明显选择。另一方面，Python 比 C++慢，所以如果速度是你交易策略的重要部分，那么你可能会选择 C++。
另一个要考虑的主要因素是交易频率。通常，如果交易频率少于一秒，那么 C++将是更好的选择。但是在为回溯测试和研究环境选择语言时，最终的选择应该基于可用的库以及算法的需求。
Python 对 R
就在几年前，许多交易者认为 Python 和 R 不相上下，但从那以后，Python 几乎在各个方面都超过了它的对手。Python 现在拥有对现代软件开发工具和更好的包库的高级支持。
遗言
虽然为你的网上交易选择编程语言有很多因素，但 Python 通常是希望学习一门既容易理解又容易操作的语言的新手的最佳选择。这反过来会帮助你原型化、测试和执行更好的加密交易机器人和交易算法。
Python 编程中的 all()方法
原文：https://www.askpython.com/python/built-in-methods/all-method-in-python
Python 附带了许多有趣的预定义方法。其中之一就是 Python 中的all()方法。这个方法被广泛用于检查一个可迭代 Python 对象的所有元素是否都是真值。因此，让我们学习更多关于all()方法的知识，并看看如何在我们的代码中加入。
Python 中 all()方法的工作原理
理论上，Python 中的 all()方法检查一个 Python iterable 对象的所有元素，如列表、字典、数组等。T4 是真的还是假的。如果所有的元素都是可迭代的(或者对象是空的)，那么它返回True，如果至少有一个元素不是，那么它返回False。
你有没有注意到我们使用了术语**【真实】而不是【真实】**？这是因为这两个术语有不同的含义。
在 Python 中，all()检查所有元素，看bool(element)是否为真。这样，我们可以推断，这里的真与真是不同的。
all()函数用法和示例
现在让我们看一个例子，它可以说明 Python 中的all()方法的工作原理。
#python all() example
print("all() in Python:")
#Defining different type of variables
list1=['J','o','u','r','n','a','l','D','e','v']
list2=[0,1,1,1,0]
dictionary1={1:"True",2:"False"}
dictionary2={0:"False",1:"True"}
tpl1=(0,1,2,3)
#Evaluating the variables with the all() method.
print("list1=['J','o','u','r','n','a','l','D','e','v']:",all(list1))
print("list2=[0,1,1,1,0]:",all(list2))
print("tpl1=(0,1,2,3):",all(tpl1))
print("dictionary1:",all(dictionary1))
print("dictionary2:",all(dictionary2))
# Testing all() method's evaluation of empty objects
print("Now for empty objects:")
dict_empt={}
list_empt=[]
print("dict_empt:",all(list_empt))
print("list_empt:",all(dict_empt))
输出:
all() Output
- 对于列表 1 ，
all()返回True，因为它的所有元素都是非 falsy， - 然而，对于列表 2 ，我们得到了
False，因为它包含了计算结果为假的数字 0。 - 对于元组 tpl1 ，该方法也返回
False，因为第一个元素是 0 ，其评估为假。 - 对于字典 1 ，我们得到
True作为输出，因为没有一个键是 0 或假。出于演示的目的，我们添加了计算结果为 TRUE 的“false”字符串，因为 FALSE 字符串不是布尔 False。 - 我们为字典 2 得到一个
False，因为它的一个键是 0。 - 对于任何类型的空可迭代对象，无论是列表还是字典，
all()方法返回True。
扫一扫
1050
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
