AskPython-博客中文翻译-十-
AskPython 博客中文翻译（十）
Python 元组——不可变的序列
- Python 元组是不可变的序列。
- 元组是用逗号分隔的值创建的。
- 因为元组是不可变的，所以我们不能添加或删除它的元素。
- 如果元组元素不是不可变的，它们的属性可以被改变。但是，我们不能直接改变一个元组元素。
- 我们可以创建嵌套元组。
- 我们可以通过元组元素的索引来访问它们。它还支持从末尾到开始引用元素的负索引。
- 我们还可以将元组元素解包为逗号分隔的值。
- 创建元组通常是为了存储异构元素。他们也可以有无。
- 元组支持两个操作符 : +用于连接，而*用于重复元素。
- 元组支持切片以从源元组创建另一个元组。
- 我们可以对元组使用“in”和“not in”操作符来检查元组中是否存在该项目。
- 由于 tuple 是一个序列，我们可以使用循环中的遍历它的元素。
- Python tuple 类有两个函数–
count()和index()。
如何用 Python 创建一个 Tuple？
我们可以通过将元组的所有元素放在用逗号分隔的括号内来创建元组。
tuple_numbers = (1, 2, 3, 1)
我们可以在一个元组中保存不同类型的对象。
tup = 1, 2, 3, 1, None, "Hello"
让我们看一个嵌套元组的例子。
nested_tuple = ((1, 2), ("Hello", "Hi"), "Python")
我们可以通过在括号中不包含任何元素来创建空元组。
empty_tuple = ()
使用括号创建元组的边界是可选的。但是，使用它是最佳实践。如果打印元组，元素总是打印在括号内。
>>> tup = 1, 2, "Hello"
>>> print(tup)
(1, 2, 'Hello')
>>>
创建单个条目元组有点棘手。如果你把一个值放在括号里，它不会创建一个元组。它将创建值类型的对象。让我们用一个简单的例子来检验这种行为。
single_item_tuple = ("Hello")
print(type(single_item_tuple))
single_item_tuple = (10)
print(type(single_item_tuple))
输出:
我们可以在值后添加一个逗号来创建一个只有一个元素的元组。
single_item_tuple = "Hello",
print(type(single_item_tuple))
single_item_tuple = 10,
print(type(single_item_tuple))
Python Tuple With Single Element
如何访问元组元素？
我们可以通过元组元素的索引来访问它们。索引值从 0 开始到元组的长度–1。
tuple_numbers = (1, 2, 3, 4)
print(f'First element in tuple is {tuple_numbers[0]}')
print(f'Third element in tuple is {tuple_numbers[3]}')
如果元组大小小于指定的索引，则抛出“ IndexError:元组索引超出范围”。
>>> tuple_numbers = (1, 2, 3, 4)
>>> tuple_numbers[10]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: tuple index out of range
>>>
元组也支持负索引。在这种情况下，元组元素是从末尾到开头检索的。负索引从-1 开始到-(元组的长度)。
tuple_numbers = (1, 2, 3, 4)
print(f'Last element in tuple is {tuple_numbers[-1]}')
print(f'Second Last element in tuple is {tuple_numbers[-2]}')
print(f'First element in tuple is {tuple_numbers[-4]}')
如果我们有一个嵌套元组，我们可以通过嵌套索引访问它的元素。
>>> nested_tuple = (1, 2, (3, 4), (5, 6, 7))
>>> nested_tuple[2][0]
3
>>> nested_tuple[2][1]
4
>>> nested_tuple[3][0]
5
>>> nested_tuple[3][1]
6
>>> nested_tuple[3][2]
7
>>>
我们也可以对嵌套元组使用负索引。
>>> nested_tuple = (1, 2, (3, 4), (5, 6, 7))
>>>
>>> nested_tuple[-1][-1]
7
>>> nested_tuple[-2][1]
4
>>> nested_tuple[-2][-1]
4
>>> nested_tuple[3][-2]
6
>>>
下图显示了索引在元组中的工作方式。
Python Tuple Index
对元组切片
我们可以使用切片来创建元组的子集。这在从源元组创建新元组时很有用。切片技术包含两个用冒号分隔的索引。结果中包括左索引，不包括右索引。
tuple_numbers = (1, 2, 3, 4, 5, 6, 7, 8)
print(tuple_numbers[1:3])
print(tuple_numbers[:4])
print(tuple_numbers[5:])
print(tuple_numbers[:-5])
输出:
Slicing Tuple in Python
元组是不可变的
元组本质上是不可变的。所以我们不能添加、更新或删除它的元素。然而，如果元素是可变的，那么它的属性可以改变。
>>> tup = (1,2)
>>> tup[0] = 10
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
让我们看一个例子，其中元组元素是可变的，我们改变它们的属性。
list_fruits = ["Apple"]
tup = ("Hello", list_fruits)
print(tup)
list_fruits.append("Banana")
print(tup)
输出:
Python Tuple With Mutable Elements
删除元组
我们不能删除元组的元素。但是，我们可以使用 del 语句删除元组本身。
>>> tup = (1,2)
>>> print(tup)
(1, 2)
>>> del tup
>>> print(tup)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'tup' is not defined
>>>
元组串联(+运算符)
我们可以使用+运算符连接元组元素来创建一个新的元组。
>>> tuple1 = (1, 2)
>>> tuple2 = (3, 4)
>>> tuple3 = (5, 6, 7)
>>>
>>> tuple_all = tuple1 + tuple2 + tuple3
>>> print(tuple_all)
(1, 2, 3, 4, 5, 6, 7)
>>>
重复元组元素(*运算符)
Tuple 还支持*操作符创建一个新的 tuple，其中的元素重复给定的次数。
>>> tup = (1, 2, (3, 4))
>>>
>>> tup1 = tup * 3
>>>
>>> print(tup1)
(1, 2, (3, 4), 1, 2, (3, 4), 1, 2, (3, 4))
>>>
Python 元组函数
tuple 类有两个功能。
- count(x) :返回给定元素出现的次数。
- index(x，start，end) :返回值的第一个索引。我们可以指定开始和结束索引来查找元组中的值。如果没有找到该值，则引发 ValueError 。
>>> tup = (1, 2, 3, 1, 2, 1, 3, 2, 1)
>>>
>>> tup.count(1)
4
>>> tup.count(2)
3
>>> tup.index(2)
1
>>> tup.index(2, 2)
4
>>> tup.index(2, 2, 6)
4
>>> tup.index(20)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: tuple.index(x): x not in tuple
>>>
元组成员资格测试(in，not in 运算符)
我们可以使用“in”操作符检查元组是否包含元素。类似地，我们可以使用“not in”操作符来测试元素是否不在元组中。
>>> vowels = ("a", "e", "i", "o", "u")
>>>
>>> "a" in vowels
True
>>> "x" in vowels
False
>>>
>>> "a" not in vowels
False
>>> "x" not in vowels
True
遍历一个元组
我们可以使用 for 循环来遍历元组的元素。
vowels = ("a", "e", "i", "o", "u")
for v in vowels:
print(v)
如果想以逆序遍历元组，可以使用 reversed()函数。
for v in reversed(vowels):
print(v)
元组与列表
- 元组是不可变的，而列表是可变的。
- 元组优于列表，用于在序列中存储不同类型的数据类型。
- 因为元组是不可变的，所以遍历元组比遍历列表稍微快一点。
- 元组比列表更能优化内存和空间。
- 如果要添加，请从序列中删除元素，然后使用 List。
Python tuple()内置函数
我们还可以使用 tuple()函数来创建一个元组。它接受一个可迭代的参数，比如 List 和 String。这在将其他序列类型转换为元组时很有用。
1.Python 列表到元组
list_numbers = [1, 2, 3]
tuple_numbers = tuple(list_numbers)
print(tuple_numbers) # (1, 2, 3)
2.Python 字符串到元组
s = "ABCD"
tuple_str = tuple(s)
print(tuple_str) # ('A', 'B', 'C', 'D')
3.Python 范围到元组
r = range(1, 10)
tuple_range = tuple(r)
print(tuple_range)
结论
元组是 Python 中不可变的序列。当您想要一个只读序列时，请使用元组。
参考资料:
Python 海龟:向编码界的海龟问好！
你好，学习伙伴！今天，我们将向您介绍 Python Turtle，它是编码世界中的一只乌龟，只需一些简单的步骤，它就可以在您的屏幕上创建有趣的图形和形状。
我们开始吧！
Python 海龟库简介
Python Turtle 通过在虚拟画布上绘制各种东西，帮助用户更好地与编程语言进行交互。
它使用了一种虚拟笔，也就是众所周知的海龟 T1。
在 python turtle 库的帮助下，人们可以绘制和制作不同的形状和图片。大多数情况下，海龟库是用来绘制形状、创造设计和制作图像的。但它也有助于创建迷你游戏和动画。
Python Turtle 入门
您需要导入turtle库来使用它的方法和功能。它还附带了一个 Python 标准工具包，因此不需要额外安装。
下一步是创建虚拟画布，在上面绘制各种对象。我们可以根据我们的需要和兴趣来命名画布/屏幕并显示它。下面的代码为用户创建和显示屏幕。
#Importing Module
import turtle as tur
# Creating Screen
wind = tur.Screen()
# Displaying Screen
sc = tur.getscreen()
tur.mainloop()
上面提到的代码的输出会产生如下所示的屏幕:
Initial Turtle Window
人们可以在这个屏幕上看到代码的输出，屏幕中间的黑色小三角形被称为乌龟，它可以用来绘制所需的形状和对象。
首先，需要创建海龟，然后在海龟上使用定位功能。Turtle 支持四种基本运动，即向前、向后、向左和向右。向前和向后功能需要距离作为参数，另一方面，向左和向右功能需要旋转角度作为参数。下面的代码有助于显示海龟的基本运动操作。
import turtle
# Creating Screen
my_window = turtle.Screen()
# Creating turtle to draw
my_pen = turtle.Turtle()
# Moving Forward
my_pen.forward(150)
# Turning Right
my_pen.right(40)
# Moving Forward
my_pen.forward(150)
#Moving Left
my_pen.left(90)
#Moving Backward
my_pen.backward(30)
# Displaying Window
my_window.mainloop()
代码的输出显示在下图中。
Basic Turtle Movement Visualization
使用 Python Turtle 创建形状
利用海龟运动的基本功能，人们可以创造一些基本的形状，如三角形、正方形和长方形。人们也可以创造像星星一样的形状。
1.用乌龟创造五边形
下面的代码在一只蟒蛇龟的帮助下在屏幕上显示了一个五边形。对于正五边形，所有的边都等长，所有的角都等于 72 度。
import turtle
# Creating Screen
my_window = turtle.Screen()
# Creating turtle to draw
my_pen = turtle.Turtle()
#Creating a Pentagon
for i in range(5):
my_pen.forward(150)
my_pen.left(72)
# Displaying Window
my_window.mainloop()
下图显示了上面代码的输出结果，结果是一个五边形。
Making Pentagon Using Turtle
2.和乌龟一起造星
下面的代码在一只乌龟的帮助下在屏幕上显示一颗星星。对于规则的星形，所有的边都等长，所有的角都等于 144 度。
import turtle
# Creating Screen
my_window = turtle.Screen()
# Creating turtle to draw
my_pen = turtle.Turtle()
#Creating a Star Shape
for i in range(5):
my_pen.forward(200)
my_pen.right(144)
# Displaying Window
my_window.mainloop()
下面的图片显示了上面代码的输出结果，得到了一个星形。
Making Star Using Turtle
用蟒蛇龟改变颜色
人们可以改变屏幕、海龟和线条的颜色，使形状看起来更好。下面的代码用不同的颜色显示了一个矩形和一个星形。
import turtle
# Creating Screen
my_window = turtle.Screen()
turtle.bgcolor('black')
# Creating turtle to draw
my_pen = turtle.Turtle()
my_pen.color('yellow')
my_pen.forward(150)
my_pen.color('green')
my_pen.left(90)
my_pen.forward(200)
my_pen.color('orange')
my_pen.left(90)
my_pen.forward(150)
my_pen.color('pink')
my_pen.left(90)
my_pen.forward(200)
my_pen.right(90)
my_pen.color('black')
my_pen.forward(100)
colors = ['red','magenta','yellow','orange','green']
for i in range(5):
my_pen.color(colors[i])
my_pen.forward(200)
my_pen.right(144)
# Displaying Window
my_window.mainloop()
下图显示了代码的输出。
Making Colorful Turtle Shapes
结论
恭喜你！你现在知道蟒蛇龟了！这个海龟库还可以创建非常复杂的形状，并且有很多颜色。
编码快乐！
希望你学到了一些东西！
Python 类型()函数的变体
原文：https://www.askpython.com/python/built-in-methods/python-type-function
嘿，伙计们！在本文中，我们将从调试 — Python type()函数的角度来看一下 Python 的一个重要内置函数。
Python type()函数入门
Python type()函数的作用是调试整个程序。type()函数可用于调试代码中各种类和数据变量的数据类型。
type()函数可以用两种变体来表示
- 带一个参数的 type()函数
- 带三个参数的 type()函数
在下一节中，我们将了解 Python 中 type()函数的两种变体的功能。
1.带有一个参数的 Python 类型()
当将单个参数传递给 type()函数时，它将分别返回给定类/对象的数据类型。
语法:
type(object)
- 它只接受一个单参数。
- 带有单参数的 type()函数返回传递给它的对象的类类型。
举例:
dict_map = {"Python":'A',"Java":'B',"Kotlin":'C',"Ruby":'D'}
print("The variable dict_map is of type:",type(dict_map))
list_inp = [10,20,30,40]
print("The variable list_inp is of type:",type(list_inp))
str_inp = "Python with JournalDev"
print("The variable str_inp is of type:",type(str_inp))
tup_inp = ('Bajaj', 'Tata','Royce')
print("The variable tup_inp is of type:",type(tup_inp))
在上面的例子中，我们已经创建了不同数据结构的数据对象，如 dict、list 等。此外，我们将它传递给 type()函数来调试对象的类型。
输出:
The variable dict_map is of type: <class 'dict'>
The variable list_inp is of type: <class 'list'>
The variable str_inp is of type: <class 'str'>
The variable tup_inp is of type: <class 'tuple'>
2.具有三个参数的 Python 类型()
当三个参数被传递给type() function时，它创建并返回一个新类型的对象作为函数的输出。
语法:
type(name, bases, dict)
这三个参数如下
name:是一个字符串，基本上代表了这个类的名称。bases:指定主类的基类的元组。dict:是一个“字典，用于创建指定的类的主体。
因此，带有上述三个参数的 type()函数用于在运行时动态创建类。
举例:
var1 = type('ob', (object,), dict(A='Python', B='Cpp'))
print(type(var1))
print(vars(var1))
class apply:
A = 'Python'
B = 'Cpp'
var2 = type('oc', (apply,), dict(A = 'Python', B = 'Kotlin'))
print(type(var2))
print(vars(var2))
在上面的例子中，我们已经在动态运行时创建了类，一个有一个对象类，另一个有“应用”基类。 vars() function表示一个类/模块的 dict 参数。
输出:
<class 'type'>
{'A': 'Python', 'B': 'Cpp', '__module__': '__main__', '__dict__': <attribute '__dict__' of 'ob' objects>, '__weakref__': <attribute '__weakref__' of 'ob' objects>, '__doc__': None}
<class 'type'>
{'A': 'Python', 'B': 'Kotlin', '__module__': '__main__', '__doc__': None}
摘要
- 带有单个参数的 type()函数返回参数的类类型，广泛用于代码调试。
- type()函数和三个参数用于动态创建类，即在运行时创建。
结论
因此，在本文中，我们已经分别理解了 Python type()在不同参数下的工作方式。
参考
- Python type()函数— JournalDev
Python 单元测试模块
原文：https://www.askpython.com/python-modules/python-unittest-module
在本文中，我们将介绍 Python 单元测试模块及其一些常见用例。
但在此之前，我们先了解一下为什么我们需要这个模块。
为什么应该使用 unittest 模块？
当您处理大型代码库时，应用程序开发通常分为两个阶段。
- 发展阶段
- 测试阶段
第一阶段是你的开发阶段，在这里你将你的核心思想构建成一个基本的应用程序。
但是，如果你真的想经常使用它，这是不够的。可能有一些你可能没有注意到的情况，这实际上会导致你的程序意外地工作。
为了最大限度地减少这种错误，还有另一个阶段叫做测试阶段，它旨在测试应用程序的不同可能场景，并检查它是否正常工作。
通常，如果您没有为该阶段建立的框架，您可能需要手动验证所有场景，这很繁琐。
为了减少开发人员的麻烦，我们可以使用 Python unittest模块，通过使用自动化测试来解决这个问题。
测试类型
对于应用程序，有两种类型的测试:
- 综合测试
- 单元测试
集成测试是那些检查一个应用程序的模块是否能一起正常工作的测试。
单元测试是检查应用程序中的小组件。
虽然我们可以编写集成测试和单元测试，但是集成测试非常依赖于您的应用程序，并且可以组合多个单元测试。
至此，让我们来看看如何使用这个模块！
Python 单元测试模块
这个模块内置在你的 Python 3+ 安装中，所以没有必要使用 pip 来安装它。
您可以通过键入以下命令来导入该模块:
import unittest
Python 单元测试方法
这个模块有几个方法可以用来执行单元测试。
下表列出了最常见的方法。
| 方法 | 断言检查 |
| assertEqual(a，b) | a == b |
| assertNotEqual(a，b) | 答！= b |
| assertTrue(x) | bool(x) is True |
| assertFalse(x) | bool(x)为 False |
| 资产(a，b) | a 是 b |
| 断言 IsNot(a，b) | a 不是 b |
| 阿松酮(x) | x 是零 |
| assertinotone(x) | x 不是没有 |
| assertIn(a，b) | b 中的 a |
| assertNotIn(a，b) | a 不在 b |
| 资产实例(a，b) | isinstance(a，b) |
| assertNotIsInstance(a，b) | not isinstance(a，b) |
编写单元测试
我们需要一个程序来进行测试。所以我们写一个吧！
我将编写一个程序，简单地验证列表中元素的总和。我们将为此编写一个单元测试程序。
现在，为了编写一个单独的测试用例，我们需要继承unittest.TestCase类，然后使用一些特定的方法覆盖它。
我会叫我的班级MyTestClass。
import unittest
def list_sum(my_list):
# Sums the elements of the list
return sum(my_list)
class MyTestClass(unittest.TestCase):
def test_list(self):
# Checks if the sum of the below list is as expected
my_list = [1, 2, 3, 4, 5]
self.assertEqual(list_sum(my_list), 15, "Should be 15")
def test_string(self):
# Checks if the string is 'Hello from AskPython'
my_str = 'Hi'
self.assertEqual(my_str, 'Hello from AskPython', "Should be 'Hello from AskPython'")
if __name__ == '__main__':
# Main module
unittest.main()
注意:为了编写一个测试方法，我们必须在方法名前面加上test_。因此，任何测试方法都必须是test_xyz()的形式
我正在编写一个方法test_list()来检查列表中元素的总和是否等于 15，以及类似的另一个方法来检查给定的字符串。
我正在使用 unittest 的assertEqual()方法，它将运行 unittest 并检查这个断言是否成立。
现在让我们使用 Python 来执行这个文件。
[email protected] $ python my_test.py
.F
======================================================================
FAIL: test_string (__main__.MyTestClass)
----------------------------------------------------------------------
Traceback (most recent call last):
File "my_test.py", line 16, in test_string
self.assertEqual(my_str, 'Hello from AskPython', "Should be 'Hello from AskPython'")
AssertionError: 'Hi' != 'Hello from AskPython'
- Hi
+ Hello from AskPython
: Should be 'Hello from AskPython'
----------------------------------------------------------------------
Ran 2 tests in 0.000s
FAILED (failures=1)
如您所见，第一个测试通过了，而第二个测试失败了，因为字符串不匹配。
您现在已经编写了您的第一个单元测试方法！
对应用程序运行单元测试
现在让我们在另一个程序上运行单元测试，因为你不会在一个单元测试文件中编写整个应用程序！
让我们编写一个简单的应用程序，并对其进行单元测试。
我将编写一个程序，作为一个非常简单的数据库来存储学生的名字和分数。
将下面的文件另存为test_example.py，因为我们将在下一段代码中引用它。
class MyClass:
# Database of {'Name': 'Marks'} dict pairs
db = dict()
num_students = 0
def add_db(self, name, marks):
self.db[name] = marks
self.num_students += 1
def rm_db(self, name):
# Removes key value pair corresponding
# to student name
if name in self.db:
del self.db[name]
else:
return f'Student with Name:{name} not in Database'
def get_marks(self, name):
if name in self.db:
return self.db[name]
else:
return f'Student with Name:{name} not in Database'
if __name__ == '__main__':
my_class = MyClass()
my_class.add_db('John', 47)
my_class.add_db('Mary', 34)
print(my_class.get_marks('John'))
运行单元测试的推荐方法
将测试模块与核心应用程序分开是一种常见的做法。
所以我们将只在测试阶段导入unittest模块。
Python 允许我们这样做，通过指定-m MODULE_NAME选项。所以，我们的命令是:
python -m unittest -v my_test.py
我们将使用-v verbose 选项来显示所有有用的消息。
现在，你不需要在你的申请上写import unittest！
为了运行单元测试，我们必须为我们的程序编写一个测试文件，类似于我们之前所做的。我们还将通过引用我们之前保存的文件test_example.py来导入我们之前创建的MyClass。
import unittest
from test_example import MyClass
import random
class MyTest(unittest.TestCase):
# Init the MyClass class
my_class = MyClass()
# Database to verify test cases
database = dict()
def test_case_1(self):
print("\n\nRunning Test 1....\n\n")
name = 'John Doe'
marks = 50
self.database[name] = marks
self.my_class.add_db(name, marks)
self.assertEqual(self.database, self.my_class.db)
print(self.database)
print("\n\nFinished Test 1\n\n")
def test_case_2(self):
print("\n\nRunning Test 2....\n\n")
for i in range(5):
name = ''
for j in range(6):
name += chr(random.randint(97, 97+25))
marks = random.randint(0, 100)
self.database[name] = marks
# Insert to MyClass Database
self.my_class.add_db(name, marks)
# Now check if both databases have the same key:value pairs
self.assertEqual(self.database, self.my_class.db)
print(self.database)
print("\n\nFinished Test 2\n\n")
if __name__ == '__main__':
# Run the main unittest code
unittest.main()
现在我们已经分别编写了测试，让我们来验证它是否工作。
python -m unittest run_tests.py
Unittest Example
这确实有效，因为我们的测试都通过了！
请注意，我们的最终测试数据库包含来自 Test1 和 Test2 的记录，因此可以根据您的程序来操作测试机制！
结论
希望您现在理解了如何使用 Python 的unittest模块在测试阶段执行健全性检查。如果你有任何疑问，请在下面的评论区提出来！
参考
- 关于 Python 单元测试模块的 JournalDev 文章
- 关于 Python unittest 的文章
Python urllib:完整参考
大家好，欢迎来到另一篇 Python 3 教程文章。在这篇文章中，我们将讨论 Python urllib 库，它是标准库模块的一部分。
Python urllib 的想法是，它允许你通过简单的编程做互联网允许的各种令人惊奇的事情。
因此，让我们开始吧。
导入 Python urllib
你要做的第一件事是你需要导入 URLlib。
现在，如果你来自 python 2.7，你习惯于只导入 urllib，仅此而已。
import urllib
而在 Python 3 及更高版本中，您必须从 urllib 导入请求包。
import urllib.request
使用 Python urllib 模块访问网站
下面是一个访问网站的例子。
1.获取访问网站的请求
x = urllib.request.urlopen('https://www.google.com')
我们将定义一个变量 x 并调用 urlopen 方法，指定网站的 url。
现在，这将作为 HTTP GET 请求从 URL 获取数据。我们将使用 read()来获取数据。
print(x.read())
上面的代码片段返回了 google.com 页面的源代码。它返回页面的所有内容，比如 python 控制台上的 html 标记和样式属性。
但是，作为用户，您可能对获取页面的源代码不感兴趣，而只需要文本数据。
Output Get Request
作为普通用户，你会去python.org等网站的搜索栏，指定你要搜索的内容，点击提交按钮。
您会注意到地址栏中的 URL 变为如下所示的 URL。这个 URL 包含一些？和&是查询参数。
https://www.python.org/search/?q=urllib&submit=
为了让你进一步了解。和&是您在搜索栏中提供的搜索查询，这些查询会发布到 URL。您可以向该 URL 发出 POST 请求来检索内容。但是如果你必须从 python 发布呢？
2.发布访问网站的请求
除了请求模块，我们还将导入解析模块，因为这将帮助我们解析请求的值。
import urllib.request as rq
import urllib.parse as ps
为了更好地理解 post 请求，我们将使用 python.org 网站。我们将定义一个字典，其中的关键字是“搜索参数”，值是关键字。
url='https://www.python.org/search/'
dictionary = { 'q': 'urllib' }
data = ps.urlencode(dictionary)
data = data.encode('utf-8')
req = rq.Request(url,data)
res = rq.urlopen(req)
print(res.read())
在指定了 url 参数之后，理解使用 utf-8 标准编码的万维网是很重要的。因此，我们将把我们的 url 转换成编码内容。
然后，我们将把我们的 URL 和编码的数据传递到 req 对象中，并向该对象发出 urlopen 请求。urlopen 的响应存储在 res 对象中。
Output POST
这是因为我们在这里发布的网站不允许我们在不使用 API 的情况下访问他们的内容。我们可以使用 RESTFUL APIs 或某些其他头文件来检索数据。我们不会在本文中讨论这个问题。
我们仍然可以将包含所有 HTML 标签的整个网页放入 python 控制台。
结论
希望你已经理解了如何使用 python 向浏览器和站点发出 HTTP GET 和 HTTP POST 请求。请在评论区告诉我们您的反馈，并提及您希望阅读的任何其他主题。
Python 用户从键盘输入–Input()函数
原文：https://www.askpython.com/python/examples/python-user-input
- Python 用户从键盘输入的内容可以使用 input()内置函数读取。
- 用户的输入被读取为一个字符串，并可以赋给一个变量。
- 从键盘输入数值后，我们必须按“输入”按钮。然后，input()函数读取用户输入的值。
- 程序无限期地暂停，等待用户输入。没有提供超时值的选项。
- 如果我们输入 EOF (nix: Ctrl-D，Windows: Ctrl-Z+Return)* ，EOFError 被引发，程序终止。
输入()函数的语法
input()函数的语法是:
input(prompt)
提示字符串打印在控制台上，用户可以控制输入值。您应该打印一些有用的信息来指导用户输入期望值。
在 Python 中获取用户输入
下面是一个简单的例子，它获取用户输入并将其打印在控制台上。
value = input("Please enter a string:\n")
print(f'You entered {value}')
输出:
Python User Input
用户输入值的类型是什么？
用户输入的值总是被转换成字符串，然后赋给变量。让我们通过使用 type() 函数得到输入变量的类型来确认这一点。
value = input("Please enter a string:\n")
print(f'You entered {value} and its type is {type(value)}')
value = input("Please enter an integer:\n")
print(f'You entered {value} and its type is {type(value)}')
输出:
Please enter a string:
Python
You entered Python and its type is <class 'str'>
Please enter an integer:
123
You entered 123 and its type is <class 'str'>
如何获取一个整数作为用户输入？
没有办法将整数或任何其他类型作为用户输入。但是，我们可以使用内置函数将输入的字符串转换为整数。
value = input("Please enter an integer:\n")
value = int(value)
print(f'You entered {value} and its square is {value ** 2}')
输出:
Python User Input Integer
Python 用户输入和 EOFError 示例
当我们进入 EOF 时，input()引发 EOFError 并终止程序。让我们看一个使用 PyCharm IDE 的简单例子。
value = input("Please enter an integer:\n")
print(f'You entered {value}')
输出:
Please enter an integer:
^D
Traceback (most recent call last):
File "/Users/pankaj/Documents/PycharmProjects/PythonTutorialPro/hello-world/user_input.py", line 1, in <module>
value = input("Please enter an integer:\n")
EOFError: EOF when reading a line
Python User Input raises EOFError
Python 用户输入选择示例
我们可以通过给用户选择并接受用户的输入来进行选择，从而构建一个智能系统。
value1 = input("Please enter first integer:\n")
value2 = input("Please enter second integer:\n")
v1 = int(value1)
v2 = int(value2)
choice = input("Enter 1 for addition.\nEnter 2 for subtraction.\nEnter 3 for Multiplication.:\n")
choice = int(choice)
if choice == 1:
print(f'You entered {v1} and {v2} and their addition is {v1 + v2}')
elif choice == 2:
print(f'You entered {v1} and {v2} and their subtraction is {v1 - v2}')
elif choice == 3:
print(f'You entered {v1} and {v2} and their multiplication is {v1 * v2}')
else:
print("Wrong Choice, terminating the program.")
下面是执行上述程序的输出示例。
Python User Input Choice
Python raw_input()函数简介
在 Python 2.x 版本中，raw_input()函数用于获取用户输入。下面是 Python 2.7 命令行解释器的一个简单示例，展示了 raw_input()函数的用法。
~ python2.7
Python 2.7.10 (default, Feb 22 2019, 21:55:15)
[GCC 4.2.1 Compatible Apple LLVM 10.0.1 (clang-1001.0.37.14)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> value = raw_input("Please enter a string\n")
Please enter a string
Hello
>>> print value
Hello
该函数已被弃用，并从 Python 3 中移除。如果你还在 Python 2.x 版本，建议升级到 Python 3.x 版本。
结论
在 Python 中，从 input()函数中获取用户输入非常容易。它主要用于为用户提供操作选择，然后相应地改变程序的流程。
但是，程序会无限期地等待用户输入。如果能有一些超时和默认值就好了，以防用户没有及时输入值。
参考资料:
Python 变量
Python 中的变量是一个 标识符 来引用程序中的一个值。变量包含对象的内存位置。它们允许 python 程序访问其他对象，并调用它们的函数或执行其他操作。
在 Python 中定义变量的规则
定义 python 变量有一些规则。
- Python 变量名可以包含小写字母(a-z)、大写字母(A-Z)、数字(0-9)和下划线(_)。
- 变量名不能以数字开头。
- 我们不能使用保留的 关键字 作为变量名。
- Python 变量不能只包含数字。
- python 变量名可以以下划线或字母开头。
- 变量名区分大小写。
- 变量名的长度没有限制。
有效的 Python 变量示例
- abc
- _ :是的，我们可以创建一个下划线的变量名。
- __ :是的，多个下划线也是一个有效的变量名。
- x_yAB
- _abc
无效的 Python 变量示例
- 9abc :变量名不能以数字开头。
- 123 :变量名不能只包含数字。
- x-y :变量名中唯一允许的特殊字符是下划线。
- def :变量名无效，因为它是保留关键字。
如何在 Python 中声明变量？
Python 是一种动态类型语言。在声明变量时，我们不需要指定变量的类型。变量用等号定义。左边部分包含变量名，右边部分包含变量值。
让我们看一些用 Python 声明变量的例子。
x = 1 # number
s = "Hello" # string
t = (1, 2) # tuple
l = [1, 2, 3] # list
d = {"1": "A", "2": "B"} # dictionary
变量的多重赋值
Python 也支持多重赋值。我们可以使用多重赋值一次定义多个变量。
a = b = c = 100
print(a, b, c) # 100 100 100
我们也可以将一个序列赋给一个变量列表。在这种情况下，序列中元素的数量必须等于变量的数量。
a, b, c = 1, 2, "Hello"
print(a, b, c) # 1 2 Hello
a, b, c = (1, 2, 3)
print(a, b, c) # 1 2 3
a, b, c = [1, 2, 3]
print(a, b, c) # 1 2 3
a, b, c = "098"
print(a, b, c) # 0 9 8
让我们看看当变量的数量和序列中元素的数量不相等时会发生什么。
>>> a,b = (1,2,3)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: too many values to unpack (expected 2)
>>>
>>> a,b,c,d = (1,2,3)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: not enough values to unpack (expected 4, got 3)
>>>
如何在 Python 中打印一个变量值？
我们可以使用 python print()函数来打印变量值。让我们看一些用 Python 打印变量值的例子。
x = 1 # number
print(x)
s = "Hello" # string
print("s value is", s)
t = (1, 2) # tuple
print("tuple value is", t)
l = [1, 2, 3] # list
print(l)
d = {"1": "A", "2": "B"} # dictionary
print("dict value is", d)
How to Print Python Variable Value
Python 程序是顺序执行的。所以如果你试图在变量定义之前访问它，你会得到NameError。
print(count) # NameError: name 'count' is not defined
count = 100
print(count) # 100
Python 变量命名约定的最佳实践
如果你看看上面的代码片段，变量名是随机的。它们没有传达变量的含义。在 Python 中命名变量时，有一些最佳实践可以遵循。
- 变量名只能使用小写字母、数字和下划线。
- 如果变量名有多个单词，可以用下划线将它们分开。
- 如果变量作用域是私有的，那么你可以用下划线开始它的名字。
- 您应该避免变量名以下划线开头和结尾。它们通常由 Python 内置程序使用。
- 始终为变量使用有意义的名称。它应该传达数据的类型和变量的预期用途。
- 变量名长度没有限制。但是，有一个小而有意义的名字是好的。
基于上面的最佳实践，我们可以更改上面的代码片段，使其具有正确的变量名。
count = 1
str_message = "Hello"
tuple_ints = (1, 2)
list_of_numbers = [1, 2, 3]
numbers_letters_dict = {"1": "A", "2": "B"}
如何打印变量的类型？
我们不指定 Python 程序中变量的类型。我们可以用 type()函数来确定变量的类型。让我们看一些打印变量类型的例子。
count = 1 # number
print(type(count))
str_message = "Hello" # string
print("str_message type is", type(str_message))
tuple_ints = (1, 2) # tuple
print("tuple_ints type is", type(tuple_ints))
list_of_numbers = [1, 2, 3] # list
print(type(list_of_numbers))
numbers_letters_dict = {"1": "A", "2": "B"} # dictionary
print("numbers_letters_dict type is", type(numbers_letters_dict))
输出:
<class 'int'>
str_message type is <class 'str'>
tuple_ints type is <class 'tuple'>
<class 'list'>
numbers_letters_dict type is <class 'dict'>
Python 中有哪些不同类型的变量
变量的类型是其值的数据类型。Python 是一种面向对象的编程语言。Python 中的一切都是对象。因此，python 变量总是一个类的实例。
- x = 1 :这里变量‘x’的类型是‘int’。它引用了 int 类的一个实例。
- message = "Hello" :消息变量的类型为' str '。
Python 中的变量范围
变量作用域定义了程序中变量的可访问区域。Python 变量有两个范围。
- 局部范围
- 全球范围
Python 中的局部变量
当一个变量被定义在一个函数或类中时，它只能在函数或类中被访问。它们被称为局部变量，它们的作用域仅限于函数或类的边界。
如果我们试图访问一个超出其作用域的局部变量，我们会得到NameError这个变量没有被定义。
让我们用一些例子来理解 python 的局部变量的思想。
def foo():
foo_var = 1
print(foo_var)
foo()
print(foo_var)
Python Local Variable Scope
foo()函数内的print()能够访问foo_var,因为它在它的作用域内。foo()函数外的print()不能访问foo_var，因为它超出了变量的范围。
让我们看另一个在类内部定义局部变量的例子。变量 scope 是这个场景的类。
class Foo:
class_foo_var = 1
print(class_foo_var)
输出 : NameError: name 'class_foo_var' is not defined
Python 全局变量
当变量不在函数或类中时，可以从程序的任何地方访问它。这些变量被称为全局变量。让我们看看 Python 全局变量的例子。
global_msg = "Hello"
def foo():
print(global_msg) # global variables are accessible inside a function
class Foo:
print(global_msg) # global variables are accessible inside a class
if 5 < 10:
print(global_msg) # global variables are accessible inside a code block
代码块中定义的变量，如 if-else、for 循环、while 循环、try-except 等。被添加到全局范围，前提是声明该变量的代码已经执行。我们用一个简单的例子来理解这一点。
>>> if True:
... var_if = "if"
... else:
... var_else = "else"
...
>>>
>>> print(var_if)
if
>>> print(var_else)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'var_else' is not defined
>>>
未定义 var_else，因为 else 块中的代码未执行。
让我们来看看另一个带有 try-except 块的例子。
>>> try:
... var_try = "try"
... raise TypeError('explicitly throwing')
... except:
... var_except = "except"
...
>>> print(var_try)
try
>>> print(var_except)
except
>>>
我们能够访问 try-except 块中定义的变量，因为它们都被执行了。
在 Python 中删除变量
我们可以使用del语句删除一个变量。让我们看一个删除 python 变量的简单例子。
>>> count = 100
>>> print(count)
100
>>> del count
>>>
>>> print(count)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'count' is not defined
>>>
Python 静态变量
类中定义的变量可以用类名来访问。它们也被称为静态变量，因为它们属于类。
class Data:
id = 0
print(Data.id) # static access
这些变量也可以从类对象中访问。但是，建议使用类静态访问。
d1 = Data()
print(d1.id) # class variable accessed from object
Python 私有变量
Python 编程中没有私有变量的概念。所以，如果你希望一个变量被视为私有的，有一个惯例是以下划线开始名字。这向其他开发人员暗示，这个变量不应该被使用，它可以在将来的任何时候改变它的行为。
快速了解全局()和局部()函数
- 函数的作用是:返回当前作用域全局变量的字典。
- Python locals()函数返回当前作用域局部变量的字典。
我们可以在任何代码位置使用这些函数来检查一个变量在那个位置是否可访问。它们是 Python 中的内置函数。
让我们看看这些函数的一些快速示例。
global_var = "global"
def foo():
local_var = "local"
print('global variables inside foo(): ', globals())
print('local variables inside foo(): ', locals())
print('global variables: ', globals())
print('local variables: ', locals())
foo()
输出:
global variables: {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x1006305f8>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/Users/pankaj/Documents/PycharmProjects/PythonTutorialPro/hello-world/hello_world.py', '__cached__': None, 'global_var': 'global', 'foo': <function foo at 0x1006817b8>}
local variables: {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x1006305f8>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/Users/pankaj/Documents/PycharmProjects/PythonTutorialPro/hello-world/hello_world.py', '__cached__': None, 'global_var': 'global', 'foo': <function foo at 0x1006817b8>}
global variables inside foo(): {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x1006305f8>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/Users/pankaj/Documents/PycharmProjects/PythonTutorialPro/hello-world/hello_world.py', '__cached__': None, 'global_var': 'global', 'foo': <function foo at 0x1006817b8>}
local variables inside foo(): {'local_var': 'local'}
Python Global and Local Variables
Python 全局关键字
我们可以在函数内部访问一个全局变量。但是我们不能修改它。我们必须使用global关键字来改变函数内部的全局变量值。让我们用一个简单的例子来理解这种行为。
name = "Python"
def foo():
print(name)
foo()
print(name)
# Output
# Python
# Python
让我们看看当我们试图修改函数内部的全局变量值时会发生什么。
>>> name = "Python"
>>> def foo():
... print(name)
... name = "Java"
...
>>>
>>> foo()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 2, in foo
UnboundLocalError: local variable 'name' referenced before assignment
>>>
>>> print(name)
Python
>>>
原因很简单。当我们使用赋值操作符来改变“name”的值时，它开始被当作一个局部变量。所以在 print()函数中访问它会抛出一个错误，因为它当时没有被定义。
让我们使用 global 关键字来修改全局变量值。
>>> name = "Python"
>>>
>>> def foo():
... global name
... print(name)
... name = "Java"
...
>>> print(name)
Python
>>> foo()
Python
>>> print(name)
Java
>>>
Python 非本地关键字
nonlocal 关键字用于访问在块范围之外定义的变量。这在嵌套函数中总是用来访问外部定义的变量。变量总是在最近的封闭范围内搜索，不包括全局变量。
def outer_function():
scope = "local"
def inner_function():
nonlocal scope
scope = "nonlocal"
print(scope)
inner_function()
print(scope)
摘要
每个程序中都要用到变量。它们是一种标识符。我们学习了如何定义一个变量，与它相关的规则，以及如何访问和删除它们。我们还学习了变量作用域——全局和局部。
下一步是什么？
资源
python vars()–查找 dict 属性
原文：https://www.askpython.com/python/built-in-methods/python-vars-method
大家好！在本文中，我们将看看如何使用 Python vars() 函数，该函数返回对象的__dict__属性。
这是一个罕见的函数，但它有助于了解如何使用它，因为它在某些情况下很有用。现在让我们来看看这些情况，使用说明性的例子！
Python 变量的语法()
该函数接受一个对象obj，其形式如下:
vars([obj])
这将返回obj的__dict__属性，该属性包含对象的所有可写属性。
这里，obj可以是任何模块/类/类的实例等。
这里有几个例子，取决于参数的类型和数量。
- 如果你不提供任何参数，Python
vars()将像locals()方法一样，返回一个包含当前本地符号表的字典。 - 因为它返回
__dict__属性，如果对象没有这个属性，它将引发一个TypeError异常。
现在让我们看一些与不同对象相关的例子。
使用不带任何参数的 Python 变量()
如前所述，这将充当locals()方法，并返回本地符号表的字典。
print(vars())
输出
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x108508390>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/Users/vijay/home/python_vars_function.py', '__cached__': None, 'Data': <class '__main__.Data'>, 'd': <__main__.Data object at 0x108565048>, 'math': <module 'math' from '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/lib-dynload/math.cpython-36m-darwin.so'>}
在类对象上使用 Python vars()
如果obj是一个类类型，或者是该类的一个实例，让我们看看vars()在这种情况下做了什么。
让我们创建一个示例类MyClass并在它的__init__()方法上定义一些属性。
class MyClass:
def __init__(self, i, j):
self.a = i
self.b = j
m = MyClass(10, 20)
print(vars(m))
print(vars(MyClass))
输出
{'a': 10, 'b': 20}
{'__module__': '__main__', '__init__': <function MyClass.__init__ at 0x000001C24EA129D8>, '__dict__': <attribute '__dict__' of 'MyClass' objects>, '__weakref__': <attribute '__weakref__' of 'MyClass' objects>, '__doc__': None}
正如您所看到的，对于类实例，vars()返回了所有相关的属性a和b，以及它们的值。
而在类MyClass的情况下，它被封装在main模块下，具有__init__方法，以及类的__dict__属性。
vars()调用所有的邓德方法，如__repr__、__dict__等。
因此，如果您可以直接调用这个函数，而不是调用 dunder 方法，会更方便。(尽管没有任何区别)
类似地，你可以在其他对象和类上使用vars()，比如str和list。
print(vars(str))
print(vars(list))
这将显示两个类的所有相关属性和实例方法。
在模块上使用 vars()
我们也可以在一个模块上使用这个函数，找出它包含的所有方法，以及其他相关信息，甚至文档字符串！
比如你要看内置模块antigravity，(就是一个复活节彩蛋！)你确实导入了，看看vars(antigravity)
import antigravity
print(vars(antigravity))
样本输出(最后几行)
{'__name__': 'antigravity', '__doc__': None, '__package__': '', 'TimeoutError': <class 'TimeoutError'>, 'open': <built-in function open>, 'quit': Use quit() or Ctrl-Z plus Return to exit, 'exit': Use exit() or Ctrl-Z plus Return to exit, 'copyright': Copyright (c) 2001-2018 Python Software Foundation.
All Rights Reserved.
Copyright (c) 2000 BeOpen.com.
All Rights Reserved.
Copyright (c) 1995-2001 Corporation for National Research Initiatives.
All Rights Reserved.
}
如果你在一个没有__dict__属性的对象(比如int)上使用vars()，它将引发一个TypeError。
print(vars(12))
Traceback (most recent call last):
File "vars_example.py", line 12, in <module>
print(vars(12))
TypeError: vars() argument must have __dict__ attribute
结论
在本文中，我们研究了 Python vars()函数，如果您想快速获得任何类/模块/对象的属性和所有有代表性的方法，这个函数很有用。
参考
- 关于 Python vars()函数的 JournalDev 文章
python vs Julia——比较
在本文中，我们将比较 Python 和 Julia。由麻省理工学院开发的 Julia 编程已经成为从长远来看可能取代 Python 的顶级语言之一。尽管 Julia 的开发者坚信 Julia 和 Python 是携手并进的，但我们试图探究为什么 Julia 可能成为 Python 的潜在替代品。我们将探讨它们的特点和缺点。
python vs Julia–快速概述
Python 和 Julia 都是开源语言，它们是动态类型的，并且有一个与我们的自然语言高度相似的语法。目前稳定版的 Julia 是 1.5.4，python 是 3.9.2。
| | 计算机编程语言 | 朱莉娅 |
| 开发人 | Python 软件基金会 | 用它 |
| /
编译解释 | 解释 | 编辑 |
| 速度 | 慢的 | 快的 |
| 范例 | 面向对象、流行和功能 | 功能的 |
| 类型系统 | 动态类型化 | 动态类型化 |
| 图书馆支持 | 丰富成熟的图书馆支持 | 积极发展的图书馆 |
| 使用
语言的公司 | 谷歌、脸书、Spotify、Quora、
网飞、Reddit 等。 | 亚马逊，苹果，迪斯尼，
福特，谷歌，美国宇航局等。 |
| 发展 | 成熟(3.9.2 版) | 积极开发(v1.5.4) |
Comparison table of Python and Julia
速度
使这篇文章相关的一个非常重要的因素是 Julia 的速度。以下是展示 Julia 速度的基准:
这个速度的主要原因是基于 LLVM 的 Julia JIT 编译器。编译器进行了许多高级抽象和优化，以使 Julia 这么快。Julia 解决了两个程序问题，而且大部分的 Julia 和它的库都是用 Julia 本身写的。另一方面，Python 是解释型的，速度较慢，这使得它不适合大型计算。
python 中有一些库，比如 Numba 和 Jax，它们允许使用 JIT 编译器进行快速计算，但这些都是非常特定于应用的。
范式
Julia 支持函数式编程，对类型层次结构有现成的支持。Python 允许我们更加灵活地解决我们的程序。Python 支持函数式、面向对象和面向过程的编程。
代码可重用性
Julia 最重要的因素之一是代码的可重用性。代码重用也是面向对象编程的主要特征之一，但事实证明 Julia 的类型系统和多重调度对代码重用更有效。
图书馆支持
Python 有巨大的库支持。你想做的每件事都可以在图书馆里找到。从制造不和谐的机器人到近似的样条插值，一切都是可用的和开源的。Python 已经有 30 多年的历史了，所以这些库大部分都很成熟。python 中很少流行的库/框架有 SciPy 、 Django 、TensorFlow、 Pandas 等。
朱莉娅还提供巨大的图书馆支持，主要倾向于科学研究。这些库正在被快速开发，并且每天都有新的库被开发出来。他们中的大多数还没有达到 1.0 版本，所以这意味着你可能会遇到一些错误。但是这些图书馆做他们最擅长的事情，有些对 Julia 来说是非常独特的。一些非常流行的 Julia 库有 Flux、Pluto、微分方程、JuMP 等。
社区
Python 是非常流行的语言(2021 年前 3)。它拥有大量的社区支持，来自各种背景的人们想出各种方法来帮助和维护社区。Python 编程语言国际社区每年都会召开几次会议(PyCons)。PyCons 托管在世界各地，大部分是由当地 Python 社区的志愿者组织的。在这样的社区活动中，你可以看到从软件开发人员到研究人员到学生的各种人。
朱莉娅也是一个非常包容的社区，人们来自各种背景。Julia 仍然在爬受欢迎的阶梯，所以你不能指望 python 有这么大的社区，但肯定是一个支持者。
朱莉娅对其他语言的支持
Julia 允许用户调用用 C、python、R 等语言编写的代码。朱莉娅会直接打电话给你。这意味着你不需要把所有的代码都转换成 Julia，而是通过使用 Julia 库来调用它们。
结论
Python 和 Julia 各有优缺点。朱莉娅还很年轻，潜力巨大。相比之下，Python 是一种疯狂的流行语言，如果你遇到任何困难，你一定会找到以前解决过这个问题的人！选择永远是你的！如果你喜欢探索新的编程语言，Julia 可以成为你探索的对象。
Python vs R 编程语言
你好，初学者！今天我们将比较两种著名的编程语言:Python 和 r。我们将对这两种编程语言都有所了解，然后理解两者之间的区别。
推荐阅读: Python vs Scala 编程
Python 编程语言简介
Python是由 Guido Van Rossem 在 20 世纪 90 年代开发的，强调生产率和代码可读性。这种语言可以用来理解复杂的概念，如数据分析和统计问题。
与其他编程语言相比，这种语言非常灵活、简单、易读，并且更容易被用户理解。如今，Python 正被迅速用于数据科学、机器学习和深度学习。
R 编程语言介绍
这种编程语言是由 Ross Ihaka 和 Robert Gentleman 于 1995 年开发的，旨在开发一种专注于呈现更用户友好的方式来执行数据分析、统计和图形建模的语言。
如今，R 已经成为企业界发展最快、最常用的统计语言之一。r 提供了用户贡献的文档和一个非常活跃的堆栈溢出组。
Python 和 R 编程语言的区别
1.灵活性
Python: 为问题创建自己的函数和模型要容易得多
R: 使用已经可用的库要容易得多
2.赞成的意见
Python: 速度更快，用户更容易理解和阅读，易于实现
R: R 使图形可视化美观，更好地进行数据分析
3.骗局
Python: 库的数量比 R 编程语言
R: 少，一开始很难学习和理解
4.语言的主要使用者
Python: 大多数程序员和开发人员都喜欢 Python 编程语言
R: 大多数学者和研究人员都使用 R 编程语言
5.主要用途
Python: 主要用于开发和生产
R: 主要用于数据分析和统计建模
推荐阅读: Python vs Julia 编程
结论
您已到达文章结尾！干得好！所以现在的大问题是:用哪种编程语言:Python vs R？
答案是，这种用法完全取决于你的项目或程序的目标。它还取决于解决方案的时间限制。
R 和 Python 之间的差距一天比一天小，大多数事情都可以使用这两种编程语言来完成。但是有一点是肯定的，学习 Python 比学习 R 编程语言要容易得多。
最后你可以选择最适合你的！希望你喜欢这篇文章！
感谢您的阅读！
Python vs Scala 编程语言
你好，初学者！今天我们将比较两种编程语言，即 Python 和 Scala。首先，我们将分别理解这两种语言，然后将这两种语言进行相互比较。
Python 与 Scala——快速对比
| 属性 | Scala 编程语言 | Python 编程语言 |
|---|---|---|
| 在性能方面 | 比 Python 快 10 倍 | 慢的 |
| 就复杂程度而言 | Scala 可能比 Python 复杂一点 | 不太复杂 |
| 在重构方面 | 重构要容易得多 | 重构会导致 Python 中的错误 |
| 项目类型 | 大型项目。 | 小规模项目。 |
| 代码测试 | scala 中的测试要好得多 | 代码测试可能会变得复杂 |
| 双语社区 | 不错，但仍不及 Python | 大型社区 |
推荐阅读: Python 模块 vs Python 包——有什么区别？
Python 编程语言简介
Python 仍然是最流行的开源编程语言之一，并且作为脚本语言和自动化语言被广泛使用。Python 是一种强大、快速、易于学习和理解的语言。
Python 编程语言的优势
- 易于学习和理解
- 与许多其他编程语言相比，许多开发人员更喜欢 python
- 它附带了大量的库、模块和函数
- 它还支持许多内置函数、数据类型和模块。
- 它速度很快，是初学者开始开发的最佳语言之一。
Python 编程语言的缺点
- Python 是一种动态类型语言，与 C、C++或 Java 相比，它会让计算机消耗更多的时间。
- 除了时间消耗，Python 编程语言中的内存消耗也很高。
Scala 编程语言简介
Scala 编程语言是面向对象和函数式编程方法在一种小型高级语言中的结合。
这种语言最初是为 Java 虚拟机(JVM)而构建的，这使得支持 Java 变得更加容易，并且还允许开发人员构建高性能系统，并且可以轻松访问大量的库。
Scala 的优势
- 访问 JVM 库以支持 Java
- 共享其他流行语言(如 Ruby 和 Java)的几个可读语法方面
Scala 的缺点
- 编程语言的代码语言可以变得复杂，因为它既是面向对象的又是函数式编程语言。
- 很少有开发者使用 Scala 作为编程语言来开发应用和模型。
结论
就是这样！您已到达文章结尾！
我希望这篇文章对你了解 Python 和 Scala 编程语言有所帮助。本文还讨论了这两种语言之间的一些基本差异。
感谢您的阅读！
如何在 Python 中等待一个特定的时间？
原文：https://www.askpython.com/python/examples/python-wait-for-a-specific-time
大家好！在这篇文章中，我们将看看如何在 Python 中等待一个特定的时间。
当您将某些事件或任务安排在特定时间段之后时，这一点尤为重要。
Python 为我们提供了不同的方法来做到这一点。因此，让我们看看我们可以使用的所有方法:在单线程和多线程环境中！
python–在单线程环境中等待特定的时间
如果你的主程序只包含一个单独的线程/程序，那么 Python 让这变得非常容易。
在 Python 中让程序等待特定时间的一种可能方法是使用 时间 模块。
使用 time.sleep()等待
我们可以用time.sleep(n)来等待n秒。当然，我们可以将n设为十进制，这样我们的区间会更精确！
下面是一个简单的例子，它将两个函数调用安排在 3 秒钟之内。
import time
def fun1(a):
return 2 * a
def fun2(a):
return a * a
if __name__ == '__main__':
inp = 10
print(f"Input = {inp}")
print(f"Result of fun1 call: {fun1(inp)}")
time.sleep(3) # Wait for 3 seconds
print(f"After 3 milliseconds, Result of fun2 call: {fun2(inp)}")
输出
Input = 10
Result of fun1 call: 20
After 3 seconds, Result of fun2 call: 100
很简单，对吧？
在多线程环境中等待
如果你的程序中有多个线程，你仍然可以通过time.sleep()使用相同的逻辑让一个特定的线程在 Python 中等待特定的时间
下面是一个例子，它产生了 3 个线程，让它们交替休眠一秒钟，而其他线程继续打印从 1 开始的数字。
我们将使用concurrent.futures模块并使用ThreadPoolExecutor来共享和执行线程，同时使用as_completed()来获取结果。
使用线程生成和获取的基本结构如下:
from concurrent.futures import ThreadPoolExecutor, as_completed
# The threads will call this function
def callback():
pass
with ThreadPoolExecutor() as thread_executor:
# Await all results
await_results = [thread_executor.submit(callback) for i in range(1, tid+1)]
# Fetch them!
for f in as_completed([future for future in await_results]):
print(f.result())
现在，让我们编写主程序的代码。
from concurrent.futures import ThreadPoolExecutor, as_completed
import time
# Global Variable for the Thread ID Number
tid = 0
# Spawn 4 threads
NUM_THREADS = 4
def func(arg):
time.sleep(1)
return arg * arg
if __name__ == '__main__':
with ThreadPoolExecutor() as thread_executor:
start_time = time.time()
# Going to spawn threads
tid += NUM_THREADS
# Await all results
await_results = [thread_executor.submit(func, arg=i) for i in range(1, tid+1)]
for f in as_completed([future for future in await_results]):
print(f.result())
end_time = time.time()
print(f"Total Time taken for {NUM_THREADS} threads: {end_time - start_time}")
输出
1
4
9
16
Total Time taken for 4 threads: 1.0037879943847656
如您所见，我们产生了 4 个线程，它们在给出函数结果之前都等待了 1 秒钟。这非常接近 1 秒，所以我们的输出是有意义的！
使用线程。Timer()来调度函数调用
然而，如果你想让一个特定的函数在 Python 中等待特定的时间，我们可以使用来自threading模块的threading.Timer()方法。
我们将展示一个简单的例子，它每 5 秒调度一次函数调用。
from threading import Timer
import time
def func(a, b):
print("Called function")
return a * b
# Schedule a timer for 5 seconds
# We pass arguments 3 and 4
t = Timer(5.0, func, [3, 4])
start_time = time.time()
# Start the timer
t.start()
end_time = time.time()
if end_time - start_time < 5.0:
print("Timer will wait for sometime before calling the function")
else:
print("5 seconds already passed. Timer finished calling func()")
输出
Timer will wait for sometime before calling the function
Called function
这里，主程序在 5 秒钟之前到达了最后一行，所以 Timer 让程序等待，直到它调用func()。
在调用func(a, b)之后，它终止程序，因为没有其他东西可以运行。
还要注意，函数的返回值不能被主程序使用。
希望这给了你更多关于安排和等待间隔的想法。
结论
在本文中，我们学习了使用time.sleep()在 Python 中等待一段特定的时间。我们还看到了如何在多线程环境中使用它，以及调度函数调用。
参考
- 线程计时器上的 Python 文档
- StackOverflow 问题关于创建时间延迟
Python while 循环
- Python while 循环用于重复一段代码，直到指定的条件为假。
- 当我们不知道代码块必须执行的次数时，就使用 while 循环。
- 我们应该在编写 while 循环条件时小心谨慎。如果条件从不返回 False，while 循环将进入无限循环。
- Python 中的每个对象都有一个布尔值。如果值为 0 或无，则布尔值为假。否则，布尔值为真。
- 我们可以通过实现
__bool__()函数来定义一个对象布尔值。 - 我们使用保留关键字–while–来实现 Python 中的 while 循环。
- 我们可以使用 break 语句终止 while 循环。
- 我们可以在 while 循环中使用 continue 语句来跳过代码块的执行。
- Python 支持嵌套的 while 循环。
Python while 循环语法
while condition:
# while block code
while 循环的流程图
while Loop Flow Diagram
Python while 循环示例
假设我们必须打印给定次数的消息。我们可以使用 while 循环来编写这个实用程序 函数 。
def print_msg(count, msg):
while count > 0:
print(msg)
count -= 1
print_msg(3, "Hello World")
输出:
Python while Loop Example
带有 break 语句的 while 循环
有时我们明确地想要无限期地执行一个代码块，直到收到退出信号。我们可以使用“while True”block 和 break 语句来实现这个特性。
下面是一个实用程序脚本的例子，它接受用户输入(整数)并打印其平方值。当用户输入 0 时，程序终止。
while True:
i = input('Please enter an integer (0 to exit):\n')
i = int(i)
if i == 0:
print("Exiting the Program")
break
print(f'{i} square is {i ** 2}')
下面是这个程序的示例运行的输出。
Python while Loop with break Statement
使用 continue 语句的 Python while 循环
假设我们希望上面的脚本只处理正数。在这种情况下，当用户输入负数时，我们可以使用 continue 语句跳过执行。
while True:
i = input('Please enter an integer (0 to exit):\n')
i = int(i)
if i < 0:
print("The program works with Positive Integers only.")
continue
if i == 0:
print("Exiting the Program")
break
print(f'{i} square is {i ** 2}')
输出:
Please enter an integer (0 to exit):
5
5 square is 25
Please enter an integer (0 to exit):
-10
The program works with Positive Integers only.
Please enter an integer (0 to exit):
0
Exiting the Program
使用 else 语句的 Python while 循环
我们可以在 while 循环中使用 else 块。当 while 循环正常终止，即条件变为 False 时，else 块代码将被执行。
如果 while 循环由于 Error 或 break 语句而终止，则不会执行 else 块代码。
count = 5
while count > 0:
print("Welcome")
count -= 1
else:
print("Exiting the while Loop")
输出:
Python While Loop With Else Block
让我们看看当 while 循环由于错误而终止时会发生什么。
count = 5
while count > 0:
print("Welcome")
count -= 1
if count == 2:
raise ValueError
else:
print("Exiting the while Loop")
输出:
Welcome
Welcome
Welcome
Traceback (most recent call last):
File "/Users/pankaj/Documents/PycharmProjects/PythonTutorialPro/hello-world/while-loop.py", line 7, in <module>
raise ValueError
ValueError
While Loop Else with Error
让我们更改程序以跳出 while 循环。
count = 5
while count > 0:
print("Welcome")
count -= 1
if count == 2:
break
else:
print("Exiting the while Loop")
输出:
Welcome
Welcome
Welcome
嵌套 while 循环示例
我们也可以嵌套 while 循环。下面是一个使用嵌套 while 循环生成元组列表的示例。
i = 3
j = 3
list_tuples = []
while i > 0:
while j > 0:
t = (i, j)
list_tuples.append(t)
j -= 1
j = 3
i -= 1
print(list_tuples)
输出 : [(3, 3), (3, 2), (3, 1), (2, 3), (2, 2), (2, 1), (1, 3), (1, 2), (1, 1)]
结论
Python while 循环用于运行特定次数的代码块。我们可以在 while 循环中使用 break 和 continue 语句。当 while 循环正常终止时，将执行带有 while 循环的 else 块。while 循环在无限循环中无限期运行脚本时也很有用。
上下文管理器——理解 Python with 关键字
原文：https://www.askpython.com/python/python-with-context-managers
Python with语句是一个非常有用的。这从 Python 2.5 开始就有了，现在几乎每个 Python 应用程序都在使用它！
这个说法到底有什么用，以至于大家都用？
最有用的东西(事实上唯一的东西！)它所做的就是打开并释放资源。
基本上，它处理打开和关闭程序特定部分可能需要使用的任何资源，并在之后自动关闭它。
现在，让我们用一些例子来更详细地看看这个陈述。
为什么我们需要上下文管理器？
考虑您处理文件的场景。在其他语言中，比如 C，我们必须像这样手动打开和关闭文件:
# Open the file
file_obj = open('input.txt', 'r')
# File operations come here
...
# Manually close the file
file_obj.close()
现在,with语句会自动为您提取这些内容，这样就不需要每次都手动关闭文件了！
with语句有一个上下文(块)，在这个上下文中它起作用。这个这个作为声明的范围。
当程序从这个上下文中出来，with自动关闭你的文件！
因此，with通常被称为上下文管理器。
因此，可以像这样使用相同的文件处理过程，以及with语句:
with open('input.txt', 'r') as file_obj:
...
注意这是多么的直观。Python with语句将总是在最后关闭文件，即使程序在上下文/块中异常终止。
这个安全特性使它成为所有 Python 程序员接受的(也是推荐的)选择！
使用 Python with 语句
现在，虽然有很多类已经实现了使用with的工具，我们还是想看看它是如何工作的，这样我们就可以自己写一个了！
- 首先，
with语句在一个上下文对象中存储一个对象引用。
上下文对象是包含关于其状态的额外信息的对象，例如模块/范围等。这很有用，因为我们可以保存或恢复该对象的状态。
所以，保持对对象的引用是有意义的！
现在，让我们继续。一旦创建了上下文对象，它就调用对象上的__enter__ dunder 方法。
__enter__语句是真正为对象打开资源的语句，比如文件/套接字。通常，如果需要，我们可以实现它来保存上下文对象状态。
现在，还记得as关键字吗？这实际上返回了上下文对象。因为我们需要由 open() 返回的对象，所以我们使用as关键字来获取上下文对象。
使用as是可选的，特别是如果您在其他地方有对原始上下文对象的引用。
之后，我们进入嵌套语句块。
一旦嵌套块或结束，如果其中有异常，程序总是对上下文对象执行__exit__方法！
这就是我们之前谈到的安全第一的特性。所以不管发生什么，我们都会一直使用__exit__来释放资源，退出上下文。
最后，如果可行的话，__exit__可以被实现，以便恢复上下文对象状态，使得它回到它所属的任何状态。
好吧，那是一个相当长的解释。为了更清楚，让我们看一个为类创建我们自己的上下文管理器的例子。
为我们的类创建自己的上下文管理器
考虑下面的类，我们将有自己的上下文管理器来处理文件。
class MyFileHandler():
def __init__(self, filename, mode):
self.filename = filename
self.mode = mode
# Originally, context object is None
self.context_object = None
# The context manager executes this first
# Save the object state
def __enter__(self):
print("Entered the context!")
self.context_object = open(self.filename, self.mode)
return self.context_object
# The context manager finally executes this before exiting
# Information about any Exceptions encountered will go to
# the arguments (type, value, traceback)
def __exit__(self, type, value, traceback):
print("Exiting the context....")
print(f"Type: {type}, Value: {value}, Traceback: {traceback}")
# Close the file
self.context_manager.close()
# Finally, restore the context object to it's old state (None)
self.context_object = None
# We're simply reading the file using our context manager
with MyFileHandler('input.txt', 'r') as file_handle:
for line in file_handle:
print(line)
仔细观察类方法。我们的处理程序有__init__方法，它设置上下文对象和相关变量的初始状态。
现在，__enter__ dunder 方法保存对象状态并打开文件。现在，我们在街区里面。
在块执行之后，上下文管理器最后执行__exit__，在那里上下文对象的原始状态被恢复，并且文件被关闭。
好的，现在让我们检查一下我们的输出。这个应该管用！
输出
Entered the context!
Hello from AskPython
This is the second line
This is the last line!
Exiting the context....
Type: None, Value: None, Traceback: None
好的，看起来我们没有错误！我们刚刚为自定义类实现了自己的上下文管理器。
现在，有另一种创建上下文管理器的方法，它使用生成器。
然而，这有点不方便，一般不推荐，除非你确切地知道自己在做什么，因为你必须自己处理异常。
但是，为了完整起见，您可以在这里看一下使用这种方法。一旦你熟悉了基于类的方法，我会推荐你阅读这篇文章。
结论
在本文中，我们通过使用with语句学习了如何在 Python 中使用上下文管理器。
参考
Python 写文件
原文：https://www.askpython.com/python/built-in-methods/python-write-file
我们之前已经看到如何用 Python 从文件中读取 。类似的写文件也可以在 Python 编程中实现。但是，在我们开始写入文件之前，我们必须确保打开文件的模式允许这样做。让我们来看看使用哪些模式我们可以实际写入一个文件。
w–打开文件进行写入，如果文件不存在，则创建一个文件。w+–打开文件进行读写，a–打开文件进行追加。数据被附加到文件的末尾，x–以写入和读取模式创建新文件，r+–打开文件进行读写。
现在，让我们看看如何使用不同的方法在 Python 中写入文件。
1.Python 使用 Write()函数写文件
使用write()函数，我们实际上可以直接将一个字符串(作为参数传递)写到一个文件中。
file = open("new_file.txt", "w+")
file.write('Using the write() method')
file.seek(0)
print(file.read())
输出:
Using the write() method
Output: new_file.txt is created
2.在 Python 中使用 writelines()
writelines()是 Python 中另一个预定义的方法，用于将多行写入一个特定的文件，并以一个字符串元素的列表作为参数传递。
list1=['字符串 1 '，'字符串 2 '，……，'字符串 n ']
file _ open _ object . writelines(list 1)
list1=['Python\n','C\n','C++\n','Java']
file=open("new_file.txt", "w+")
file.writelines(list1)
file.seek(0)
print(file.read())
输出:
Python
C
C++
Java
参考文献:
Python XML 解析器
原文：https://www.askpython.com/python/examples/python-xml-parser
有没有遇到过令人讨厌的 XML 文件，需要解析它才能获得重要的值？让我们学习如何创建一个 Python XML 解析器。
<page>
<header>
<type heading="XML Parsing in Python"/>
<type text="Hello from AskPython. We'll be parsing XML"/>
</header>
</page>
我们将看看如何使用 Python 来解析这样的 XML 文件，以获得相关的属性和值。
我们开始吧！
方法 1:使用 ElementTree(推荐)
我们可以使用 ElementTree Python 库来实现这个任务。
这是构建 Python XML 解析器的最简单和推荐的选择，因为这个库在默认情况下与 Python 捆绑在一起。
它不仅提供了方便的访问，因为它已经安装，而且它也相当快。让我们看看如何从测试文件中提取属性。
<page>
<header>
<type heading="XML Parsing in Python"/>
<type text="Hello from AskPython. We'll be parsing XML"/>
</header>
</page>
我们将在核心xml包中使用xml.etree.ElementTree接口。
import xml.etree.ElementTree as ET
构建 Python XML 解析器树
让我们首先构造这个解析树的根节点。这是树的最顶层节点，是我们开始解析所必需的。
谢天谢地，这个 API 已经为我们提供了下面的方法:
import xml.etree.ElementTree as ET
root_node = ET.parse('sample.xml').getroot()
print(root_node)
这将自动读取 XML 输入文件，并为我们获取根节点。
输出
<Element 'page' at 0x7f885836b2f0>
好的，看起来它已经被解析了。但是我们还无法证实。因此，让我们解析其他属性，并尝试获取其值。
获取相关属性的值
所以现在，我们的任务是使用 Python XML 解析器获取<heading>属性中的值。
它在根节点<page>的位置是<header/type>，所以我们需要遍历树的该层的所有匹配。
我们可以使用root_node.findall(level)来实现，其中电平是期望的位置(在我们的例子中是<header/type>)。
for tag in root_node.find_all(level):
value = tag.get(attribute)
if value is not None: print(value)
在我们正在搜索的级别上，tag.get(attribute)将获得我们的<attribute>标签的值。所以，我们只需要在<header/type>做这件事，并获得<heading>和<text>属性的值。就是这样！
import xml.etree.ElementTree as ET
# We're at the root node (<page>)
root_node = ET.parse('sample.xml').getroot()
# We need to go one level below to get <header>
# and then one more level from that to go to <type>
for tag in root_node.findall('header/type'):
# Get the value of the heading attribute
h_value = tag.get('heading')
if h_value is not None:
print(h_value)
# Get the value of the text attribute
t_value = tag.get('text')
if t_value is not None:
print(t_value)
输出
XML Parsing in Python
Hello from AskPython. We'll be parsing XML
我们已经检索了 XML 解析树中该层的所有值！我们已经成功解析了 XML 文件。
再举一个例子，为了搞清楚一切。
现在，假设 XML 文件如下所示:
<data>
<items>
<item name="item1">10</item>
<item name="item2">20</item>
<item name="item3">30</item>
<item name="item4">40</item>
</items>
</data>
这里，我们不仅要获得name的属性值，还要获得该级别的每个元素的文本值 10、20、30 和 40。
要得到name的属性值，我们可以像之前一样。我们也可以使用tag.attrib[name]来获取值。这与tag.get(name)相同，除了它使用字典查找。
attr_value = tag.get(attr_name)
# Both methods are the same. You can
# choose any approach
attr_value = tag.attrib[attr_name]
要得到文本值，很简单！只需使用:
tag.text
因此，我们这个解析器的完整程序将是:
import xml.etree.ElementTree as ET
# We're at the root node (<page>)
root_node = ET.parse('sample.xml').getroot()
# We need to go one level below to get <items>
# and then one more level from that to go to <item>
for tag in root_node.findall('items/item'):
# Get the value from the attribute 'name'
value = tag.attrib['name']
print(value)
# Get the text of that tag
print(tag.text)
输出
item1
10
item2
20
item3
30
item4
40
对于任意长的 XML 文件，您也可以将这种逻辑扩展到任意级别！您还可以向另一个 XML 文件中写入一个新的解析树。
但是，我将让您从文档中找出答案，因为我已经为您提供了一个构建的起点！
方法 2:使用 BeautifulSoup(可靠)
如果由于某种原因，源 XML 的格式不正确，这也是另一个不错的选择。如果不对文件做一些预处理，XML 可能不能很好地工作。
事实证明， BeautifulSoup 对所有这些类型的文件都非常适用，所以如果您想解析任何类型的 XML 文件，请使用这种方法。
要安装它，使用pip并安装bs4模块:
pip3 install bs4
我将为您提供我们之前的 XML 文件的一个小片段:
<data>
<items>
<item name="item1">10</item>
<item name="item2">20</item>
<item name="item3">30</item>
<item name="item4">40</item>
</items>
</data>
我将传递这个文件，然后使用bs4解析它。
from bs4 import BeautifulSoup
fd = open('sample.xml', 'r')
xml_file = fd.read()
soup = BeautifulSoup(xml_file, 'lxml')
for tag in soup.findAll("item"):
# print(tag)
print(tag["name"])
print(tag.text)
fd.close()
语法类似于我们的xml模块，所以我们仍然使用value = tag['attribute_name']和text = tag.text来获取属性名。和以前一模一样！
输出
item1
10
item2
20
item3
30
item4
40
我们现在已经用bs4解析过了！如果您的源文件XML格式不正确，这种方法是可行的，因为 BeautifulSoup 有不同的规则来处理这样的文件。
结论
希望您现在已经很好地掌握了如何轻松构建 Python XML 解析器。我们向您展示了两种方法:一种使用xml模块，另一种使用 BeautifulSoup 。
参考
- 关于解析 XML 的 StackOverflow 问题
- XML 模块文档
了解 Python xrange()方法
原文：https://www.askpython.com/python/built-in-methods/python-xrange-method
今天在本教程中，我们将讨论 Python xrange()方法。
xrange()方法仅在 Python 2.x 版本中可用，并用于遍历或迭代序列的循环中。
Python xrange()方法的基础
Python xrange()方法返回一个xrange类型的对象，它是一个不可变的序列，通常用于循环。这些对象行为很少，只支持索引、迭代和len()功能。
xrange(start, stop[, step])
这里:
- start(可选)是序列生成的起始点。它被包括在序列中，并且如果没有被提及，则默认设置为 0 ，
- stop 是序列生成停止之前的数字(不含)，
- step(可选)是函数在序列生成或迭代时将采取的跳转步骤。默认情况下，它的值为 1 。
使用 Python xrange()方法
现在让我们看看实际使用 Python xrange()方法的各种方式。
1.只有停止参数
两个参数step和start是可选的，因为它们分别具有默认值 1 和 0 。因此，我们可以通过指定stop参数来使用 Python xrange()方法。
仅提及停止时，xrange()功能创建一个从 0 到(停止-1) 的序列，步长为 1 。看看下面的例子。
# xrange() with only stop parameter
x = xrange(4)
print "Type of returned object = ", type(x)
print "Sequence generated by xrange() 1 parameter: ", list(x)
输出:
Type of returned object = <type 'xrange'>
Sequence generated by xrange() 1 parameter: [0, 1, 2, 3]
这里，该方法生成的序列类型是前面提到的类型xrange。将xrange()输出类型转换成一个列表给我们一个包含值 0 到 3(4-1) 和步骤 1 的列表。
2.带有开始和停止参数
同样，我们也可以使用带有两个参数的 Python xrange()方法。在这种情况下，默认情况下，step的值为 1 。
# xrange() with start & stop parameters
x = xrange(2, 9)
print "Type of returned object = ", type(x)
print "Sequence generated by xrange() 2 parameters: ", list(x)
输出:
Type of returned object = <type 'xrange'>
Sequence generated by xrange() 2 parameters: [2, 3, 4, 5, 6, 7, 8]
从上面的输出中我们可以看到，Python xrange对象这次包含了从 2(开始)到 8(停止-1) 的值，默认步长为 1。
3.具有所有开始、停止和停止值
当提到所有的参数时，Python xrange()函数给我们一个xrange对象，其值的范围从开始到停止-1 ，就像前一个例子一样。但是这一次，从一个元素跳到另一个元素等于通过了step。
仔细看看下面的例子。这里我们考虑了步长为 5 ，开始=5 ，停止=40 。
# xrange() with 3 parameters
x = xrange(5, 40, 5) #positive step
y = xrange(9, 1, -1) #negative step
print "Sequences generated for 3 parameters by xrange"
print "x : ", list(x)
print "y : ", list(y)
输出:
Sequences generated for 3 parameters by xrange
x : [5, 10, 15, 20, 25, 30, 35]
y : [9, 8, 7, 6, 5, 4, 3, 2]
从输出可以清楚地看出，序列是用范围 5 到 39(40-1) 内的值生成的。对于最后一个元素，因为 40 超过了stop-1标记，所以不认为是。
在循环中使用 Python xrange()
如前所述，xrange()在 Python 2 中的for循环结构中被广泛使用。例如，在下面的代码中，我们尝试打印数字 10 的表格。
# using xrange in loops
print "Table of 10: "
for i in xrange(10, 101, 10):
print i
输出:
Table of 10:
10
20
30
40
50
60
70
80
90
100
这里，我们提到了start=10、stop=101和step=10。Stop 被认为是 101 ，因为我们希望序列包含 100(100-1) 元素。正如我们所看到的，我们得到了从 10 到 100 的所有 10 的倍数。
因此，输出是合理的。
Python xrange()与 range()
通常，xrange()只在用户希望他/她的代码只为 Python 2.x 版本设计时使用，因为它不适用于 Python 3.x 版本。对于 Python 3 ，range()方法代替了xrange()方法。
这两个函数的主要区别在于，它们都返回具有不同属性的不同对象。
xrange()方法返回一个xrange对象，它是一个不可变的序列，只支持前面提到的迭代、索引和 len 函数。
另一方面，range()方法返回一个支持主要函数的列表，如切片、 pop() 等。
# xrange() vs range()
x = xrange(1, 10)
y = range(1, 10)
print "Type(x) = ", type(x)
print "Type(y) = ", type(y)
输出:
Type(x) = <type 'xrange'>
Type(y) = <type 'list'>
此外，xrange对象在我们需要以最小的空间复杂度构建代码时更有用，因为它占用相当恒定的内存大小，与它存储的值的范围无关。
如果你想写一个可以在 Python 2 和 3 上运行或执行的程序，使用range()方法更有意义，因此推荐使用。
结论
所以在本教程中，我们了解了 Python xrange()方法的工作和使用。
如有任何问题，欢迎在下面的评论中提问。
参考
- Python range()方法，
- Python 2 中的 range 和 xrange 函数有什么区别？x？–stack overflow 问题。
Python Yagmail 模块——发送电子邮件的简单方法！
原文：https://www.askpython.com/python/examples/python-yagmail-module
读者朋友们，你们好！本文主要关注 Python Yagmail 的实现，以便从我们的应用程序发送电子邮件。
所以，让我们开始吧！！🙂
Python Yagmail 模块是什么？
在目前的情况下，几乎每个企业都有一个在线设置。也就是说，他们有一个更好的销售和市场接触的在线存在。
网站收集的常见数据参数之一是客户的电子邮件地址。我们经常被要求使用我们的电子邮件地址注册网站/门户。
我们的电子邮箱里会收到广告，甚至是促销信息。他们不需要手动输入并向所有客户发送电子邮件。这意味着，以某种自动化的方式，通过门户/应用程序发送电子邮件的过程发生了。
这就是 Python Yagmail 模块出现的原因。使用 Python Yagmail 模块，我们可以通过集成了电子邮件模块的应用程序向客户发送电子邮件。
它利用简单的 Gmail，即 SMTP 客户端，以自动化和用户友好的方式发送电子邮件。我们只需要提供更少的细节，如电子邮件地址、邮件正文等。
该模块可以集成为任何零售或在线应用程序/门户的一部分，这可能是该模块的最佳使用案例。🙂
现在让我们来关注一下实现 Yagmail 模块的步骤！
使用 Python Yagmail 模块发送电子邮件的步骤
首先，我们需要在我们的工作站上安装 Python Yagmail 模块。
使用 pip 命令安装 Yagmail 模块:
pip install yagmail
Python Yagmail module – Installation
安装后，我们必须将模块安装到我们当前的 python 环境中。
import yagmail
一旦导入，我们需要向 Yagmail 模块提供一个帐户，用于验证和发送电子邮件给接收者。也就是说，我们向模块注册了一个用户。通过注册一个电子邮件地址，它使得该模块可以很容易地访问 SMTP 服务器来发送电子邮件。
语法:
yagmail.register('username', 'password')
- 如果我们不希望将密码等敏感数据作为参数，我们也可以创建一个. yagmail 文件，将您的敏感数据放入该文件，而不是直接将其作为参数公开。
既然我们已经注册了用户，现在是时候与 SMTP 客户机建立安全连接了。
我们可以使用下面的自定义命令-
yagmail.SMTP('username', receiver1, receiver2, subject, body)
- 用户名:发件人的电子邮件地址
- receiver:这包含了接收者的电子邮件地址。我们可以在这里添加多个收件人电子邮件地址。
- 主题:电子邮件的简洁标题
- 正文:电子邮件的内容
如果我们没有指定收件人的电子邮件地址，它会将电子邮件发送到发件人的地址。
一旦内容准备好了，我们就继续将内容发送到收件人的电子邮件地址。
为此，Yagmail 为我们提供了 send()函数。在这里，我们将所有内容、收件人的详细信息以及主题和正文打包在一起。
yagmail.send(to = [receiver1, receiver2, etc], subject=subject, contents=body)
贴出这个，我们只需要看着代码为你工作！！
通过 Python Yagmail 发送电子邮件
下面是 Python yagmail 模块的完整实现。您可以复制粘贴以下代码，在您的系统上尝试一下。确保您为计划使用的任何电子邮件地址启用了 SMTP 访问。大多数电子邮件提供商默认情况下会阻止 SMTP 访问，以防止未经授权的应用程序滥用。
import yagmail
yag_mail = yagmail.SMTP(user='[email protected]', password='password', host='smtp.gmail.com')
to= "[email protected]"
subject = "Welcome to Journaldev!!"
body = ["World of infinite knowledge"]
yag_mail.send(to=to, subject=subject, contents=body)
print("Email has been sent successfully to the receiver's address.")
结论
到此为止，我们已经结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
更多与 Python 编程相关的帖子，请继续关注我们。
在那之前，学习愉快！！🙂
python yield–生成器函数真实例子
- Python yield 关键字用于创建一个生成器函数。
- yield 关键字只能在函数体内使用。
- 当函数包含 yield 表达式时，它会自动成为生成器函数。
- 生成器函数返回一个称为生成器的迭代器。
- 生成器控制生成器功能的执行。
- 当第一次调用 generator next()时，生成器函数开始执行。
- 当为生成器调用 next()方法时，它执行生成器函数来获取下一个值。该函数从它停止的地方执行，并且不执行完整的函数代码。
- 生成器在内部维护函数及其变量的当前状态，以便正确检索下一个值。
- 一般我们用 for-loop 从生成器函数中提取所有的值，然后逐个处理。
- 当函数返回大量数据时，生成器函数非常有用。我们可以用 yield 表达式只得到有限的一组数据，然后进行处理，再得到下一组数据。
Python 收益与回报
- 返回语句返回函数的值，然后函数终止。yield 表达式将函数转换成一个生成器，以逐个返回值。
- 当我们必须返回大量数据时，Python return 语句并不合适。在这种情况下，yield 表达式对于仅返回部分数据和节省内存非常有用。
Python yield 示例
假设我们有一个返回随机数列表的函数。
from random import randint
def get_random_ints(count, begin, end):
print("get_random_ints start")
list_numbers = []
for x in range(0, count):
list_numbers.append(randint(begin, end))
print("get_random_ints end")
return list_numbers
print(type(get_random_ints))
nums = get_random_ints(10, 0, 100)
print(nums)
输出:
<class 'function'>
get_random_ints start
get_random_ints end
[4, 84, 27, 95, 76, 82, 73, 97, 19, 90]
当“计数”值不太大时，它工作得很好。如果我们指定 count 为 100000，那么我们的函数将使用大量内存来存储列表中的那么多值。
在这种情况下，使用 yield 关键字创建一个生成器函数是有益的。让我们将函数转换为生成器函数，并使用生成器迭代器逐个检索值。
def get_random_ints(count, begin, end):
print("get_random_ints start")
for x in range(0, count):
yield randint(begin, end)
print("get_random_ints end")
nums_generator = get_random_ints(10, 0, 100)
print(type(nums_generator))
for i in nums_generator:
print(i)
输出:
<class 'generator'>
get_random_ints start
70
15
86
8
79
36
37
79
40
78
get_random_ints end
- 请注意，nums_generator 的类型是 generator。
- 当从生成器中检索第一个元素时，第一个 print 语句只执行一次。
- 一旦生成器函数生成了所有的项，就执行生成器函数中剩余的代码。这就是为什么第二个 print 语句只打印一次，而且是在 for 循环的末尾。
Python 生成器函数真实世界示例
使用生成器功能的一个最流行的例子是读取一个大的文本文件。对于这个例子，我创建了两个 python 脚本。
- 第一个脚本将所有文件行读入一个列表，然后返回它。然后，我们将所有行打印到控制台。
- 第二个脚本使用 yield 关键字一次读取一行，并将其返回给调用者。然后打印到控制台上。
我使用 Python 资源模块来打印两个脚本的内存和时间使用情况。
read_file.py
import resource
import sys
def read_file(file_name):
text_file = open(file_name, 'r')
line_list = text_file.readlines()
text_file.close()
return line_list
file_lines = read_file(sys.argv[1])
print(type(file_lines))
print(len(file_lines))
for line in file_lines:
print(line)
print('Peak Memory Usage =', resource.getrusage(resource.RUSAGE_SELF).ru_maxrss)
print('User Mode Time =', resource.getrusage(resource.RUSAGE_SELF).ru_utime)
print('System Mode Time =', resource.getrusage(resource.RUSAGE_SELF).ru_stime)
读取文件产量. py
import resource
import sys
def read_file_yield(file_name):
text_file = open(file_name, 'r')
while True:
line_data = text_file.readline()
if not line_data:
text_file.close()
break
yield line_data
file_data = read_file_yield(sys.argv[1])
print(type(file_data))
for l in file_data:
print(l)
print('Peak Memory Usage =', resource.getrusage(resource.RUSAGE_SELF).ru_maxrss)
print('User Mode Time =', resource.getrusage(resource.RUSAGE_SELF).ru_utime)
print('System Mode Time =', resource.getrusage(resource.RUSAGE_SELF).ru_stime)
我有四个不同大小的文本文件。
~ du -sh abc.txt abcd.txt abcde.txt abcdef.txt
4.0K abc.txt
324K abcd.txt
26M abcde.txt
263M abcdef.txt
~
以下是我为不同文件运行这两个脚本时的统计数据。
~ python3.7 read_file.py abc.txt
Peak Memory Usage = 5558272
User Mode Time = 0.014006
System Mode Time = 0.008631999999999999
~ python3.7 read_file.py abcd.txt
Peak Memory Usage = 10469376
User Mode Time = 0.202557
System Mode Time = 0.076196
~ python3.7 read_file.py abcde.txt
Peak Memory Usage = 411889664
User Mode Time = 19.722828
System Mode Time = 7.307018
~ python3.7 read_file.py abcdef.txt
Peak Memory Usage = 3917922304
User Mode Time = 200.776204
System Mode Time = 72.781552
~ python3.7 read_file_yield.py abc.txt
Peak Memory Usage = 5689344
User Mode Time = 0.01639
System Mode Time = 0.010232999999999999
~ python3.7 read_file_yield.py abcd.txt
Peak Memory Usage = 5648384
User Mode Time = 0.233267
System Mode Time = 0.082106
~ python3.7 read_file_yield.py abcde.txt
Peak Memory Usage = 5783552
User Mode Time = 22.149525
System Mode Time = 7.461281
~ python3.7 read_file_yield.py abcdef.txt
Peak Memory Usage = 5816320
User Mode Time = 218.961491
System Mode Time = 74.030242
下面是表格形式的数据，以便更好地理解。
| 文件大小 | 返回语句 | 发电机功能 |
| 4 KB | 内存:5.3 兆，时间:0.023 秒 | 内存:5.42 兆，时间:0.027 秒 |
| 324 KB | 内存:9.98 兆，时间:0.028 秒 | 内存:5.37 MB，时间:0.32 秒 |
| 26 兆字节 | 内存:392.8 兆，时间:27.03 秒 | 内存:5.52 兆，时间:29.61 秒 |
| 263 兆字节 | 内存:3.65 GB，时间:273.56 秒 | 内存:5.55 兆，时间:292.99 秒 |
所以生成器函数比 return 语句花费的时间稍微多一点。这很明显，因为它必须跟踪每次迭代器 next()调用中的函数状态。
但是，使用 yield 关键字对内存的好处是巨大的。使用 return 语句时，内存使用量与文件大小成正比。对于发生器函数，它几乎是常数。
注:这里的例子是为了说明当函数产生大量数据时使用 yield 关键字的好处。Python 文件已经有了一个内置的函数 readline()，用于逐行读取文件数据，这个函数内存效率高，速度快，使用简单。
Python yield 发送示例
在前面的例子中，生成器函数向调用者发送值。我们还可以使用 send()函数向生成器函数发送值。
当调用 send()函数来启动生成器时，必须使用 None 作为参数来调用它，因为没有 yield 表达式可以接收该值。否则，我们将得到 类型错误:不能发送非 None 值到一个刚刚启动的生成器 。
def processor():
while True:
value = yield
print(f'Processing {value}')
data_processor = processor()
print(type(data_processor))
data_processor.send(None)
for x in range(1, 5):
data_processor.send(x)
输出:
<class 'generator'>
Processing 1
Processing 2
Processing 3
Processing 4
Python 从示例中产生
“从表达式产生”用于从给定的表达式创建子迭代器。子迭代器产生的所有值都直接传递给调用程序。假设我们想为 get_random_ints()函数创建一个包装器。
def get_random_ints(count, begin, end):
print("get_random_ints start")
for x in range(0, count):
yield randint(begin, end)
print("get_random_ints end")
def generate_ints(gen):
for x in gen:
yield x
我们可以在 generate_ints()函数中使用“yield from”来创建调用程序和子迭代器之间的双向连接。
def generate_ints(gen):
yield from gen
当我们必须向生成器函数发送数据时,“yield from”的实际好处是显而易见的。让我们看一个例子，在这个例子中，生成器函数从调用者那里接收数据，并将其发送给子迭代器进行处理。
def printer():
while True:
data = yield
print("Processing", data)
def printer_wrapper(gen):
# Below code to avoid TypeError: can't send non-None value to a just-started generator
gen.send(None)
while True:
x = yield
gen.send(x)
pr = printer_wrapper(printer())
# Below code to avoid TypeError: can't send non-None value to a just-started generator
pr.send(None)
for x in range(1, 5):
pr.send(x)
输出:
Processing 1
Processing 2
Processing 3
Processing 4
创建包装函数需要很多代码。我们可以在这里简单地使用“yield from”来创建包装函数，结果将保持不变。
def printer_wrapper(gen):
yield from gen
结论
Python yield 关键字创建一个生成器函数。当函数通过将数据分成多个块来返回大量数据时，这很有用。我们还可以使用 send()函数向生成器发送值。“yield from”语句用于从生成器函数创建子迭代器。
参考资料:
Python zip()函数
原文：https://www.askpython.com/python/built-in-methods/python-zip-function
Python zip()函数在里面存储数据。该函数接受 iterable 元素作为输入，并返回 iterable 作为输出。
如果没有向 python zip 函数提供可迭代元素，它将返回一个空迭代器。
因此，它从 iterables 中聚合元素，并返回元组的 iterables。
Python Zip()函数语法:
zip(*iterators)
Python zip()函数参数:
zip()函数返回的值:
这个函数从相应的容器中返回一个 iterable 对象映射值。
举例:对 Python zip()函数的基本了解
# initializing the input list
city = [ "Pune", "Ajanta", "Aundh", "Kochi" ]
code = [ 124875, 74528, 452657, 142563 ]
# zip() to map values
result = zip(city, code)
result = set(result)
print ("The zipped outcome is : ",end="")
print (result)
输出:
The zipped outcome is : {('Ajanta', 74528), ('Kochi', 142563), ('Aundh', 452657), ('Pune', 124875)}
Python zip()函数具有多个可迭代项
如果用户将多个 iterable 传递给 python zip()函数，该函数将返回一个包含与 iterable 相对应的元素的元组的 iterable。
举例:
numbers = [23,33,43]
input_list = ['five', 'six', 'seven']
# No iterables being passed to zip() function
outcome = zip()
result = list(outcome)
print(result)
# Two iterables being passed to zip() function
outcome1 = zip(numbers, input_list)
result1 = set(outcome1)
print(result1)
输出:
[]
{(23, 'five'), (33, 'six'), (43, 'seven')}
Python zip()函数具有长度不等的可迭代元素
numbers = [23, 33, 43]
input_list = ['one', 'two']
input_tuple = ('YES', 'NO', 'RIGHT', 'LEFT')
# the size of numbers and input_tuple is different
outcome = zip(numbers, input_tuple)
result = set(outcome)
print(result)
result1 = zip(numbers, input_list, input_tuple)
outcome1 = set(result1)
print(outcome1)
输出:
{(33, 'NO'), (43, 'RIGHT'), (23, 'YES')}
{(23, 'one', 'YES'), (33, 'two', 'NO')}
zip()函数来解压缩这些值
**"*" operator**用于解压缩值，即将元素转换回独立的值。
alphabets = ['a', 'c', 'e']
number = [1, 7, 9]
result = zip(alphabets, number)
outcome = list(result)
print(outcome)
test, train = zip(*outcome)
print('test =', test)
print('train =', train)
输出:
[('a', 1), ('c', 7), ('e', 9)]
test = ('a', 'c', 'e')
train = (1, 7, 9)
结论
在本文中，我们已经了解了 Python 的 zip()函数的工作原理。
参考
- Python zip()函数
- zip()函数文档
Python2 与 python 3——简单比较
你好，初学者！你一定听说过 Python2 对 Python3，有些人用 2 版本，有些人用 3 版本。今天就让我们了解一下 Python 两个版本的区别。
Python2 和 Python3 的主要区别
让我们通过理解一些最常用的函数以及它们在两个版本中的不同之处，来了解 Python 2.x 和 Python 3.x 的区别。
1.print声明
| Python 版本 | 语法 |
| Python2 | 打印“我是 Python2 版” |
| Python3 | 打印(“我是 Python3 版”) |
通常，上述两种语法的输出是完全相同的。但是 Python3 中括号的使用使得用户更容易阅读。
2.input声明
所有程序都需要用户输入，只有在这里把它添加到列表中才有意义。让我们看看如何在 Python2 和 Python3 中使用输入法。
| Python 版本 | 语法 |
| Python2 | raw_input():用于字符串
input():用于整数 |
| Python3 | input():用于所有需要的输入 |
3.variables在打印报表时
我们如何在 Python2 和 Python3 之间使用格式字符串方法在打印语句中使用变量？
| Python 版本 | 语法 |
| Python2 | msg = "Hello"
print("输入的消息是% " % msg) |
| Python3 | msg = "Hello"
print("输入的消息是{0} ")。格式(消息)) |
4.错误处理
在 python3 中，程序员需要在 except块中添加as作为额外的关键字。
| Python 版本 | 语法 |
| Python2 | 尝试:
//代码
除<错误>，错误:
//代码 |
| Python3 | 试:
//代码
除<错误>为 err:
//代码 |
5.Python 中的除法运算
在 Python2 的情况下，除法运算产生一个整数。另一方面，Python3 在除法运算后返回一个浮点值。
6.迭代函数
在 Python2 中，[xrange()](https://www.askpython.com/python/built-in-methods/python-xrange-method)用于迭代，而在 Python3 中，新的高级函数range()用于迭代。
Python2 和 Python3 哪个好？
现在大多数开发者都在创建与 Python 3 严格兼容的库。它也比 Python2 更容易编码和理解
此外，在 Python3 中，字符串以 Unicode 的形式存储，这比 Python2 中使用的 ASCII 码更加通用。最后，Python3 消除了开发冲突，因为它允许输入 Python2 不支持的。
除此之外，Python 3 支持所有现代编程，如人工智能、机器学习和数据科学概念。
简单来说: Python2 是过去，Python3 是未来！
结论
谈到更喜欢哪个版本，Python2 还是 Python3，我们可以断定 Python 3 是直接的赢家。另外，如果你是一个新的程序员，我会建议你选择 Python3。
编写代码的 Pythonic 方式
原文：https://www.askpython.com/python/examples/pythonic-way-of-coding
在大多数编程语言中，我们经常遇到声称它是最强大的语言的说法。嗯，这个说法好像比较主观，为什么会这样呢？这是因为用一种语言编写的程序可以用另一种语言编写。
不同语言的语法可能不同，但不存在一种语言可以实现而另一种语言不能实现的算法。在本文中，我们将看到 Python 在最佳实践、简单性和可读性方面提供的一些方法，可以表述为Python 化的 。
Pythonic 代码的要点
就像任何其他语言一样，Python 中有各种各样的方法或设计模式。Python 本身使用的语法读起来非常接近英语，我们可以找到大量的文章或在线评论，大部分来自其他语言的人，Python 可以在几周内学会等等。这对于任何语言来说都是不正确的，对于 Python 来说更是如此。
Python 化 指的是 Python 特有的惯用编码做法，确实不仅仅是使用 Python 语法和使用标准库。
Python 也被称为习惯用法，这意味着基于 Python 代码与标准库提供的特性保持一致的想法来编写 Python 代码。对于不同的程序员来说，这种说法可能是不同的，它当然不是任何人的绝对指南。
这是像一个有经验的程序员一样用最佳实践和技术编写 Python 的想法，就像任何其他语言一样，它通常被一个巨大的社区所遵循。
我们到底为什么需要 Pythonic 代码？
每当我们编写一个程序时，它都是为了被正确执行。编写程序有多种方式，但有些方式可以被视为【更多】正确的方式。这对 Python 来说尤其如此，因为它使用极简语法，可读性很强。所以，如果我们用错了【少】的正确方式，往往很难被忽视。
用“更”正确的方式编写代码有很多好处。其中一些可以表述为:
- 我们正在利用数千名非常聪明的开发人员，他们拥有多年编写 Python 的经验，并对开源语言做出了贡献。利用他们长期使用该语言所获得的专业知识，实现使用 Python 的最佳实践和惯用方法，这当然是一个好主意。
- 具体谈到 CPython，它期望某种类型的代码实现以提高效率，因为它已经针对许多操作进行了调整。例如，我们可以通过使用 for 循环 从列表中创建子列表，或者我们可以使用 切片 来实现相同的目的。切片稍微好一点，因为它的工作方式与我们预期的完全一样。
- 一段代码应该是易于阅读和全面的。比方说，当我们看到常见的模式如 列表理解 时，我们甚至可以在解析所有符号之前更快地理解代码。相反，以非 pythonic 的方式，我们必须分析整个代码才能理解它是如何工作的。因此，以惯用的方式编写一段代码通常更干净、更简单。
作为 Python 开发者，这些对我们来说是显而易见的优势。然而，还有一些不太明显或更广泛的好处，例如:
- 当我们运行开源项目时，如果使用最佳实践，人们更容易做出贡献。为我们的项目做出贡献的人看到代码以聪明的方式编写会很兴奋。错过这个想法的项目之一是传统的 T2 PyPI。当我们 pip 安装 任何包时，我们运行的就是 PyPI 。它已经存在很多年了，但是很难找到开源的贡献者。嗯， PyPI 源代码缺乏惯用的实践。它由一个文件中的数千行代码和一个相似的代码库组成。所以，当人们试图让它变得更好时，他们很难读懂这些代码。
值得庆幸的是，它被重写并在 PyPI 的官方网站上发布，使用了最佳实践和现代习语，当然这次有更多的贡献者。
- 使用封闭的源代码工作，例如为一个组织或公司工作，只有最好的开发人员会被期望工作并被保留。因此，项目中的最佳编码实践和一致性为那些开发人员提供了在更习惯、更易理解和更可读的代码上工作的好处。
Pythonic 方式的代码示例
让我们试着通过一些例子来对我们在本文前面讨论过的 Pythonic 代码有一个大致的了解。
1。 命名约定
也被称为标识符名称的变量作为一个基本部分在所有编程语言中使用。通常，命名变量没有固定的准则，但是遵循一个模式会有所帮助。
PEP8 提供了一些遵循 Pythonic 方式命名变量的最佳实践或风格指南。即使只是简单地看一眼，也能很好地了解正在阅读的代码类型。下面提供了一些例子。
| 命名惯例 | 摘自人教版 8 风格指南 |
| 包装 | 公用事业 |
| 模块 | db_utils, dbutils, db_connect |
| 班级 | 客户详细信息 |
| 功能 | 创建订单 |
| 变量 | 订单 id |
| 常数 | 运输 _ 成本 |
PEP 8 Style Guide
2。 使用 f 字符串进行字符串格式化
使用字符串输出值或返回包含表达式的插值字符串的语句是 Python 中的一种常见模式。早些时候，字符串被连接或者使用 +操作符连接，这导致了一长串代码，看起来非常混乱，经常令人困惑。这个问题很快得到解决，语言提供了一些非常简洁的解决方案。
在 Python 3.6 中引入了 f 弦 ，为上述问题提供了更好的解决方案。f 字符串可以被认为是对用 Python 编写字符串的改进，因为用 f 字符串格式编写的代码不会向后兼容，但是实现它们符合 Python 的标准。让我们通过一些例子来获得一个概述。
first_name, age, job = "John", 33, "programmer"
# Method 1: String Concatenation
print(first_name + " " + "is a" + " " + str(age) + " " + "year old" + " " + job)
# Method 2: % Conversion specifier
print("%s is a %d year old %s" % (first_name, age, job))
# Method 3: Using format: Until Python 3.6
print("{0} is a {1} year old {2}".format(first_name, age, job))
# Method 4: The Pythonic Way: From Python 3.6 and above
print(f"{first_name} is a {age} year old {job}")
"""
Output:
John is a 33 year old programmer
John is a 33 year old programmer
John is a 33 year old programmer
John is a 33 year old programmer
"""
3。使用 enumerate()而不是 len()或 range()函数与 for-loops
通常，我们必须使用 for-loops 来迭代 Python 中的可迭代对象，例如列表、字符串或元组，并且还需要通过它们进行索引。有很多方法可以实现这一点。一些常见的模式使用 len() 或 range() 函数来访问那些可迭代对象的索引。Python 有一个内置的enumerate()函数来执行这个操作，这可以被认为是 python 提供了对索引的直接访问，而不是使用多个函数对其进行编码。
# ------------------------------
# Looping and Indexing through
# -----------------------------
# Method 1
greet = "hello"
i = 0
for eachChar in greet:
print(i, eachChar)
i += 1
"""
0 h
1 e
2 l
3 l
4 o
"""
# Method 2: A better way
greet = "there"
for idx in range(len(greet)):
print(idx, greet[idx])
"""
0 t
1 h
2 e
3 r
4 e
"""
# Method 3: The Pythonic way: enumerate()
greet = "hello"
for idx, eachChar in enumerate(greet):
print(idx, eachChar)
"""
0 h
1 e
2 l
3 l
4 o
"""
4。使用列表理解代替 for 循环
列表理解是 Python 特有的。这是我们用 Python 快速创建列表的一种方式，而不是循环和使用 append。它提供了一个更短的语法来基于原始列表中包含的条目创建一个全新的列表，或者更具体地说是基于 iterable 对象。下面是使用 append 函数和更多的python 式列表理解的例子。请注意，它不能被过度使用，因为我们不希望在一行代码中有太多的逻辑，但它在各种情况下都非常有用。它使我们的代码简洁易读。
# Using loops
my_list = []
for char in "hello":
my_list.append(char)
print(my_list) # ['h', 'e', 'l', 'l', 'o']
# The Pythonic Way: Using List Comprehensions
my_list1 = [char for char in "hello"]
print(my_list1) # ['h', 'e', 'l', 'l', 'o']
5。合并字典
Python 中到处都在使用字典。它们是最重要的数据结构之一，有多种用途。字典中的键|值对是构建块，在 Python 中对它们执行多重操作是很常见的。对于这个例子，我们将按照惯例或程序以及一些 Pythonic 方式来合并字典。
# Declaring two variables for dictionaries
customer_details = {"name": "john", "age": 34, "email": "[email protected]"}
order_items = {"item1": "apple", "item2": "orange"}
# Method 1: Not So Pythonic: Using Loops
order_details = {}
for i in customer_details:
order_details[i] = customer_details[i]
for i in order_items:
order_details[i] = order_items[i]
print(f"Result_one: {order_details}")
# The Pythonic way: Spreading out and merging using **kwargs
order_details = {**customer_details, **order_items}
print(f"Result_two: {order_details}")
# Python 3.10 Updated: Union Operator (with | pipe character)
# The Pythonic Way
order_details = customer_details | order_items
print(f"Result_three: {order_details}")
"""
Output:
Result_one: {'name': 'john', 'age': 34, 'email': '[email protected]', 'item1': 'apple', 'item2': 'orange'}
Result_two: {'name': 'john', 'age': 34, 'email': '[email protected]', 'item1': 'apple', 'item2': 'orange'}
Result_three: {'name': 'john', 'age': 34, 'email': '[email protected]', 'item1': 'apple', 'item2': 'orange'}
"""
结论
在所有编程语言中，都有特定于它们的最佳实践。作为最常用的语言之一，Python 也不例外。它有其久经考验的技术和写作风格。编写 Pythonic 代码不仅使我们的代码更简单易读，而且易于维护。
惯用的 Python 提供了一种易于识别的设计模式，这种模式使得编程成为一种无缝的体验，混淆最小。在本文中，我们浏览了其中的一些方法，以获得 Pythonic 方式的概述。
还有很多其他的例子，而且随着时间的推移，这种例子只会越来越多。Python 确实在 Python 开发人员社区中占有重要地位。
在 PyTorch 中创建自定义数据集
原文：https://www.askpython.com/python-modules/pytorch-custom-datasets
在本文中，我们将学习为 PyTorch 创建自定义数据集。
在机器学习中，模型和训练它的数据一样好。
有许多预先构建的标准数据集，如 MNIST 、CIFAR 和 ImageNet，用于初学者教学或基准测试。但是这些预定义的数据集并不多，如果你正在处理一个相对较新的问题，你可能没有预定义的数据集，你需要使用自己的数据集进行训练。
在本教程中，我们将了解一些使用 PyTorch 从自定义数据中提取的初级数据集。
了解 PyTorch 数据集和数据加载器类
用于处理数据样本的代码可能会变得混乱，难以维护；理想情况下，我们希望数据集代码与模型训练代码分离，以获得更好的可读性和模块化。
PyTorch 提供了两个数据原语:torch.utils.data.DataLoader 和torch.utils.data.Dataset，它们允许您使用预加载的数据集以及您自己的数据。Dataset存储样品及其相应的标签，DataLoader在Dataset周围包裹一个可重复标签，以便于获取样品。
因此，Dataset 是负责将数据从磁盘加载到计算机可读形式的类。它使用一种懒惰的方式来加载内存-它只在数据加载器或用户需要将数据从磁盘加载到内存时才加载内存。这是存储器有效的，因为所有的图像不是一次存储在存储器中，而是根据需要读取。
torch 数据集类是表示数据集的抽象类。为了创建自定义数据集，我们可以从这个抽象类继承。但是一定要定义两个非常重要的功能:
__len__以便len(dataset)返回数据集的大小。__getitem__支持索引，以便dataset[i]可用于获取第 i i 个样本。
数据加载器只是调用这些方法来加载内存。在本文中，我们将只关注自定义数据集的创建。数据加载器也可以进行很大程度的扩展，但这超出了本文的范围。
既然我们已经学习了DataLoader和Dataset的基本功能，我们将看看现实生活中的一些例子。
从未标记的图像加载自定义数据集
这是一个相对简单的例子，将一个文件夹中的所有图像加载到一个数据集中，用于 GAN 训练。所有的数据都来自同一个类，所以你现在不需要关心标签。
1.初始化自定义数据集类
# Imports
import os
from PIL import Image
from torch.utils.data import Dataset
from natsort import natsorted
from torchvision import datasets, transforms
# Define your own class LoadFromFolder
class LoadFromFolder(Dataset):
def __init__(self, main_dir, transform):
# Set the loading directory
self.main_dir = main_dir
self.transform = transform
# List all images in folder and count them
all_imgs = os.listdir(main_dir)
self.total_imgs = natsorted(all_imgs)
现在我们需要为自定义数据集定义两个专门的函数。
2.定义 len 函数
该函数将允许我们识别已经从我们的定制数据集中成功加载的项目的数量。
def __len__(self):
# Return the previously computed number of images
return len(self.total_imgs)
3.定义 getitem 函数
def __getitem__(self, idx):
img_loc = os.path.join(self.main_dir, self.total_imgs[idx])
# Use PIL for image loading
image = Image.open(img_loc).convert("RGB")
# Apply the transformations
tensor_image = self.transform(image)
return tensor_image
定义数据集后，您可以使用，
dataset = LoadFromFolder(main_dir="./data", transform=transform)
dataloader = DataLoader(dataset)
print(next(iter(dataloader)).shape) # prints shape of image with single batch
从带标签的图像加载自定义数据集
假设我们有一个更复杂的问题，比如猫狗分类器。我们现在必须标记数据集的图像。为此，我们有一个非常特殊的 PyTorch 数据集类 ImageFolder
假设我们有以下目录结构:
所有猫的图片都在猫文件夹里，所有狗的图片都在狗文件夹里。如果您碰巧有以下目录结构，您可以使用
from torchvision.datasets import ImageFolder
dataset = ImageFolder(root="./root", transform=transform)
dataloader = DataLoader(dataset)
print(next(iter(dataloader)).shape) # prints shape of image with single batch
你可以通过继承 ImageFolder 类来改变图片的标签和加载方式。
载入自定音频数据集
如果您正在处理音频，同样的技术也适用于音频。唯一改变的是数据集长度的测量方式和文件在内存中的加载方式。
from torch.utils.data import Dataset
class SpectrogramDataset(Dataset):
def __init__(self,file_label_ds, transform, audio_path=""):
self.ds= file_label_ds
self.transform = transform
self.audio_path=audio_path
# The length of the dataset
def __len__(self):
return len(self.ds)
# Load of item in folder
def __getitem__(self, index):
file,label=self.ds[index]
x=self.transform(self.audio_path+file)
return x, file, label
# file_label_ds is a dataset that gives you the file name and label.
dataset = SpectrogramDataset(file_label_ds, transform)
结论
这就把我们带到了文章的结尾。敬请关注更多关于深度学习和 PyTorch 的文章。
PyTorch Lightning:如何训练你的第一个模型？
在本文中，我们将使用 PyTorch Lightning 训练我们的第一个模型。自 2016 年成立以来，PyTorch 一直是许多研究人员的首选。它变得流行是因为它更 pythonic 化的方法和对 CUDA 非常强的支持。然而，它有一些样板代码的基本问题。一些功能，如使用多个 GPU 的分布式培训，是为高级用户准备的。
PyTorch lightning 是 PyTorch 的一个包装器，旨在给 PyTorch 一个类似 Keras 的界面，而不牺牲任何灵活性。如果你已经使用 PyTorch 作为你的日常驱动，PyTorch-lightning 可以成为你的工具集的一个很好的补充。
PyTorch Lightning 入门
我们将在这里以一种简单易懂的方式回顾创建我们的第一个模型的步骤。因此，没有任何进一步的麻烦，让我们马上开始吧！
1.安装 PyTorch 闪电
要安装 PyTorch-lightning，您可以运行简单的 pip 命令。如果你想从一些预定义的数据集开始，闪电模块也会派上用场。
pip install pytorch-lightning lightning-bolts
2.导入模块
首先，我们导入 pytorch 和 pytorch-lightning 模块。
import torch
from torch.nn import functional as F
from torch import nn
import pytorch_lightning as pl
可能会有一个常见的问题:“当我们已经在使用闪电时，为什么我们还需要火炬？”
嗯，闪电让 torch 的编码速度更快。lightning 建立在 torch 之上，可轻松扩展 torch 模块，允许用户在必要时进行关键的特定应用程序更改。
3.设置 MNIST 数据集
与 base PyTorch 不同，lightning 使数据库代码更易于用户访问和组织。
数据模块只是 train_dataloader、val_dataloader、test_dataloader 以及所需的匹配转换和数据处理/下载步骤的集合。
https://pytorch-lightning.readthedocs.io/en/stable/extensions/datamodules.html#what-is-a-datamodule
在 PyTorch 中， MNIST 数据模块通常定义如下:
from torchvision import datasets, transforms
# transforms
# prepare transforms standard to MNIST
transform=transforms.Compose([transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))])
mnist_train = MNIST(os.getcwd(), train=True, download=True, transform=transform)
mnist_train = DataLoader(mnist_train, batch_size=64)
正如您所看到的，数据模块并没有真正构造成一个块。如果您希望添加更多功能，如数据准备步骤或验证数据加载器，代码会变得更加混乱。Lightning 将代码组织成一个LightningDataModule类。
在 PyTorch-Lightning 中定义数据模块
1.设置数据集
让我们首先使用LightningDataModule加载并设置数据集。
from torchvision.datasets import MNIST
from torchvision import transforms
class MNISTDataModule(pl.LightningDataModule):
def __init__(self, data_dir: str = './'):
super().__init__()
self.data_dir = data_dir
self.transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
])
# self.dims is returned when you call dm.size()
# Setting default dims here because we know them.
# Could optionally be assigned dynamically in dm.setup()
self.dims = (1, 28, 28)
def prepare_data(self):
# download
MNIST(self.data_dir, train=True, download=True)
MNIST(self.data_dir, train=False, download=True)
def setup(self, stage = None):
# Assign train/val datasets for use in dataloaders
if stage == 'fit' or stage is None:
mnist_full = MNIST(self.data_dir, train=True, transform=self.transform)
self.mnist_train, self.mnist_val = random_split(mnist_full, [55000, 5000])
# Assign test dataset for use in dataloader(s)
if stage == 'test' or stage is None:
self.mnist_test = MNIST(self.data_dir, train=False, transform=self.transform)
preapre_data函数下载数据并以 torch 可读的形式保存。setup函数将数据集分为训练、测试和验证。这些函数可以任意复杂，这取决于数据需要多少预处理。
2.定义数据加载器
现在我们有了设置，我们可以添加数据加载器函数。
def train_dataloader(self):
return DataLoader(self.mnist_train, batch_size=32)
def val_dataloader(self):
return DataLoader(self.mnist_val, batch_size=32)
def test_dataloader(self):
return DataLoader(self.mnist_test, batch_size=32)
3.最后看一下 MNIST 数据模块
最后的LightningDataModule是这样的:
class MNISTDataModule(pl.LightningDataModule):
def __init__(self, data_dir: str = './'):
super().__init__()
self.data_dir = data_dir
self.transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
])
# self.dims is returned when you call dm.size()
# Setting default dims here because we know them.
# Could optionally be assigned dynamically in dm.setup()
self.dims = (1, 28, 28)
def prepare_data(self):
# download
MNIST(self.data_dir, train=True, download=True)
MNIST(self.data_dir, train=False, download=True)
def setup(self, stage = None):
# Assign train/val datasets for use in dataloaders
if stage == 'fit' or stage is None:
mnist_full = MNIST(self.data_dir, train=True, transform=self.transform)
self.mnist_train, self.mnist_val = random_split(mnist_full, [55000, 5000])
# Assign test dataset for use in dataloader(s)
if stage == 'test' or stage is None:
self.mnist_test = MNIST(self.data_dir, train=False, transform=self.transform)
def train_dataloader(self):
return DataLoader(self.mnist_train, batch_size=32)
def val_dataloader(self):
return DataLoader(self.mnist_val, batch_size=32)
def test_dataloader(self):
return DataLoader(self.mnist_test, batch_size=32)
MNIST 数据模块在 PyTorch-bolts 数据模块中预定义。如果您不想为自己编写整个代码而烦恼，您可以只导入数据模块并开始使用它。
from pl_bolts.datamodules import MNISTDataModule
# Create MNIST DataModule instance
data_module = MNISTDataModule()
现在我们已经有了现成的数据，我们需要模型来进行训练。
创建多感知器模型
照明模型非常类似于 PyTorch 模型的基础类，除了它有一些特殊的类函数来简化训练。__init__和forward方法与 PyTorch 完全相似。我们正在创建一个 3 层感知，每层感知的数量为(128，256，10)。还有一个大小为 28 * 28 (784)的输入图层，它采用展平的 28×28 MNIST 图像。
1.基本 PyTorch 型模型
class MyMNISTModel(nn.Module):
def __init__(self):
super().__init__()
# mnist images are (1, 28, 28) (channels, width, height)
self.layer_1 = nn.Linear(28 * 28, 128)
# The hidden layer of size 256
self.layer_2 = nn.Linear(128, 256)
# 3rd hidden layer of size 10.
# This the prediction layer
self.layer_3 = nn.Linear(256, 10)
def forward(self, x):
batch_size, channels, width, height = x.size()
# Flatten the image into a linear tensor
# (b, 1, 28, 28) -> (b, 1*28*28)
x = x.view(batch_size, -1)
# Pass the tensor through the layers
x = self.layer_1(x)
x = F.relu(x)
x = self.layer_2(x)
x = F.relu(x)
x = self.layer_3(x)
# Softmax the values to get a probability
x = F.log_softmax(x, dim=1)
return x
让我们使用一个随机的(28，28)值来检查这个模型是否有效。
net = MyMNISTModel()
x = torch.randn(1, 1, 28, 28)
print(net(x).shape)
输出:
torch.Size([1, 10])
1 表示批次，10 表示输出类的数量。所以我们的模型运行良好。
2.定义初始化和转发功能
PyTorch 数据模块看起来完全相似，除了它将从*pl*.*LightningModule*派生它的属性。闪电网络将会是这样的:
class MyMNISTModel(pl.LightningModule):
def __init__(self):
super().__init__()
...
def forward(self, x):
....
除了这些基本的 torch 功能，lighting 还提供了一些功能，允许我们定义在培训、测试和验证循环中发生了什么。
2.定义培训和验证循环
为模型的训练和验证步骤定义训练循环。
def training_step(self, batch, batch_idx):
x, y = batch
# Pass through the forward function of the network
logits = self(x)
loss = F.nll_loss(logits, y)
return loss
def validation_step(self, batch, batch_idx):
x, y = batch
logits = self(x)
loss = F.nll_loss(logits, y)
return loss
def test_step(self, batch, batch_idx):
x, y = batch
logits = self(x)
loss = F.nll_loss(logits, y)
y_hat = torch.argmax(logits, dim=1)
accuracy = torch.sum(y == y_hat).item() / (len(y) * 1.0)
output = dict({
'test_loss': loss,
'test_acc': torch.tensor(accuracy),
})
return output
3.优化者
lightning 模型允许我们在模型定义中为特定的模型定义优化器。
# We are using the ADAM optimizer for this tutorial
def configure_optimizers(self):
return torch.optim.Adam(self.parameters(), lr=1e-3)
4.最后看一下我们的模型
最终的闪电模型应该是这样的:
class MyMNISTModel(pl.LightningModule):
def __init__(self):
super().__init__()
# mnist images are (1, 28, 28) (channels, width, height)
self.layer_1 = nn.Linear(28 * 28, 128)
# The hidden layer of size 256
self.layer_2 = nn.Linear(128, 256)
# 3rd hidden layer of size 10.
# This the prediction layer
self.layer_3 = nn.Linear(256, 10)
def forward(self, x):
batch_size, channels, width, height = x.size()
# Flatten the image into a linear tensor
# (b, 1, 28, 28) -> (b, 1*28*28)
x = x.view(batch_size, -1)
# Pass the tensor through the layers
x = self.layer_1(x)
x = F.relu(x)
x = self.layer_2(x)
x = F.relu(x)
x = self.layer_3(x)
# Softmax the values to get a probability
x = F.log_softmax(x, dim=1)
return x
def training_step(self, batch, batch_idx):
x, y = batch
# Pass through the forward function of the network
logits = self(x)
loss = F.nll_loss(logits, y)
return loss
def validation_step(self, batch, batch_idx):
x, y = batch
logits = self(x)
loss = F.nll_loss(logits, y)
return loss
def test_step(self, batch, batch_idx):
x, y = batch
logits = self(x)
loss = F.nll_loss(logits, y)
y_hat = torch.argmax(logits, dim=1)
accuracy = torch.sum(y == y_hat).item() / (len(y) * 1.0)
output = dict({
'test_loss': loss,
'test_acc': torch.tensor(accuracy),
})
return output
def configure_optimizers(self):
return torch.optim.Adam(self.parameters(), lr=1e-3)
我们现在已经有了数据和模型。让我们继续用数据训练模型。
5.训练模型
与传统的样板循环寻找损失并进行反向传递不同，pytorch-lighting 模块中的培训师无需太多代码就能为我们完成这项工作。
首先，我们在 lightning 中用特定的参数初始化一个训练器。
from pytorch_lightning import Trainer
# Set gpus = 0 for training on cpu
# Set the max_epochs for maximum number of epochs you want
trainer = Trainer(gpus=1, max_epochs=20)
用 MNISTDataModule 拟合数据集
trainer.fit(net, data_module)
6.结果
让我们检查一下训练数据集的最终准确性，
trainer.test(test_dataloaders=data_module.train_dataloader())
输出:
--------------------------------------------------------------------------------
DATALOADER:0 TEST RESULTS
{'test_acc': tensor(.98), 'test_loss': tensor(0.0017, device='cuda:0')}
--------------------------------------------------------------------------------
在训练数据集中获得高精度可能表明过度拟合。因此，我们还需要在我们之前分离的测试数据集上测试我们的模型。让我们在验证数据集上检查模型的最终准确性。
trainer.test(test_dataloaders=data_module.test_dataloader())
输出:
--------------------------------------------------------------------------------
DATALOADER:0 TEST RESULTS
{'test_acc': tensor(.96), 'test_loss': tensor(0.0021, device='cuda:0')}
--------------------------------------------------------------------------------
因此，有了这些结果，我们就可以确认模型在数据上训练得很好。
结论
就这样，我们结束了关于 PyTorch-lightning 的教程。PyTorch-lightning 相对较新，发展很快，所以我们可以期待在不久的将来会有更多的功能。所以敬请关注更多关于机器学习和深度学习的此类文章。
py torch——简单的初学者参考
PyTorch 在短短四年前首次亮相，是风靡数据科学行业的模块之一。
它为用户提供了文档完整的代码、教程和示例，帮助他们开始使用 PyTorch，在数据科学家和研究人员看来，这是一个巨大的成功。
PyTorch 的创造者也是致力于 TorchVision 和 TorchText 的人，这两个模块被认为在计算机视觉和自然语言处理领域非常有用。
PyTorch 是一个主要基于使用 Python 中的张量和动态神经网络的模块，但是也可以扩展到使用不同的领域。
如果您想与 PyTorch 合作，我们可以帮助您从这里开始！
还建议使用 Anaconda 进行数据科学和机器学习，所以，你可能也想了解一下。
安装 PyTorch
PyTorch 官方网站为我们提供了一个简单的界面，我们可以根据您的发行版和操作系统来使用和检索所需的安装命令。
如果您希望将正常环境与数据科学环境分开，您应该考虑创建虚拟环境。
Pick your flavor of PyTorch
稍微摆弄一下，为您的本地 PyTorch 库选择一个合适的版本，然后我们就可以进去使用 PyTorch 了。
从 PyTorch 开始
如果你已经安装了 PyTorch，太好了！我们现在都准备好开始工作了。
1.0 张量？
如果你曾经在 Python 中处理过大型矩阵，你可能会使用 NumPy 。这是因为 NumPy 在处理多维数组时提供了强大的支持，允许在 n 维数组上处理各种不同的操作。
PyTorch 用张量技术给这个领域带来了竞争。
张量在某种意义上是多维数组，很像 NumPy 所提供的。然而，不同之处在于，在与 GPU 一起工作时，张量得到了很好的支持。
谷歌的 Tensorflow 也在张量上运行，以处理和处理数据。
那么，我们如何开始使用张量和 PyTorch 呢？让我们找出答案。
1.1.进口火炬
我们已经知道，使用任何模块都首先需要一个 导入 来将它包含在脚本中。因此，我们就这么做吧，
# Importing torch to use in the script.
import torch
1.2.创建张量
使用torch模块创建张量(本质上是矩阵)非常简单。这里有一些初始化/创建张量对象的方法。
# Creating tensors with strict numbers
ten1 = torch.tensor(5)
ten2 = torch.tensor(8)
print(ten1, ten2)
# Output : tensor(5) tensor(8)
# Creating a matrix of zeros using the zeros function
ten3 = torch.zeros((3, 3))
print(ten3)
# tensor([[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]])
# Creating a matrix of random numbers
ten4 = torch.randn(3, 3)
print(ten4)
# tensor([[-0.9685, 0.7256, 0.7601],
[-0.8853, 0.4048, -1.0896],
[0.6743, 1.5665, 0.2906]])
1.3.基本张量运算
张量在很多方面都可以使用，就像 NumPy 模块创建的矩阵一样。
我们可以进行基本的数字运算，
firstten = torch.tensor(3)
secondten = torch.tensor(6)
# Addition of tensors
print(firstten + secondten)
# Output : tensor(9)
# Subtraction of tensors
print(firstten - secondten)
# Output : tensor(-3)
# Multiplication of tensors
print(firstten * secondten)
# Output : tensor(18)
# Division of tensors
print(firstten / secondten)
# Output : tensor(0.5000)
1.4.与张量一起前进
张量不仅仅可以用于简单的运算，在 Python 中，简单的运算通常可以用变量来完成。
它们支持对它们执行多种操作，通常在 PyTorch 脚本的许多操作中用作变量。
用类似矩阵乘法 torch.mm的函数，创建等间距张量torch.linspace，用类似torch.sin(x)的数学函数处理数学函数。
毫不奇怪，所提供的功能允许嵌入数学方法的深度计算。
如果你希望通过例子来研究张量的工作，你可能希望看这里的。
下一步是什么？
除了使用通常的张量和默认提供的函数之外，研究 PyTorch 提供的另一个模块可能会有所帮助。
张量本身终究只是一个基础。真正的力量在于模块提供的使用这种媒介进行计算的应用程序用法。
PyTorch 为我们提供了为与神经网络一起工作而设计的模块，称为torch.nn。
torch.nn模块包含各种各样的功能来帮助它执行基于神经网络的操作，
- 集装箱
- 卷积层
- 汇集层
- 填充层
- 非线性激活(加权和，非线性)
- 非线性激活(其他)
- 归一化图层
- 轮回层
- 变压器层数
- 线性图层
- 脱落层
- 稀疏层
- 距离函数
- 损失函数
- 视觉层
- 数据并行层(多 GPU，分布式)
- 实用程序
- 量化函数
使用 PyTorch 作为数据科学模块的下一步就是处理这些问题。
结论
PyTorch 仍在开发中，但它提供的功能被广泛认为优于许多数据科学模块。
有大量的模块被创建来与 PyTorch 兼容，也有大量的资源帮助使用它们。
PyTorch 是一个开源项目，这意味着您可以参与该项目并为其未来版本做出贡献。
这里是 GitHub 链接，这里是为了开源！干杯！
查看我们的其他文章，这些文章将对您的数据科学项目有所帮助——Pandas和使用 sklearn 进行培训和测试。
参考
- 【PyTorch 官方文档
- 【PyTorch 入门教程
- 使用 PyTorch 的资源
Python 中 PyVista 的介绍
原文：https://www.askpython.com/python-modules/pyvista-in-python
PyVista(以前的“vtki ”)是一个适应性强的辅助模块和可视化工具包(VTK)的高级 API。它是 VTK 的简化界面，支持基于 Python 的网格分析和 3D 图形绘制。2019 年 5 月由 C. Bane Sullivan 和 Alexander A. Kaszynski(研究论文)提出。在深入研究 PyVista 的细节之前，让我们先快速了解一下 VTK。
VTK 介绍(可视化工具包)
VTK 是一个前沿的工具包，由 C++类库和解释接口层组成，如 Java、Python 和 Tcl/Tk。它融合了 C++的执行速度和 Python 的快速原型制作能力。
开源包 VTK 包括一个强大的处理和渲染管道，以及许多先进的可视化方法。VTK 的设计基于强大的管道概念。以下是这一概念的基本组成部分的总结:
VTK Pipeline
然而，当使用 VTK 时，简单的应用程序(如构建网格对象)需要很长的代码，但是 PyVista 只需几行 Pythonic 和简单的代码就可以完成相同的操作。
PyVista 通过 NumPy 库封装了 VTK，各种类和方法允许直接访问数组。它允许空间数据、快速原型和网格分析的可视化集成。
PyVista 的 Python 实现
本节将介绍 PyVista 实现，并显示各种 3D 形状和对象。我们将从使用下面的代码片段导入 PyVista 模块以及该模块下的示例开始。
import pyvista as pv
from pyvista import examples
我们将利用一个内置的示例文件，以网格的形式显示飞机。请看下面的代码片段。我们还将在下面的代码片段中读取平面文件的网格数据。
plane_file = examples.planefile
plane_mesh = pv.read(plane_file)
下一步是使用下面的代码在 3D 图上绘制平面及其网格。第三行代码将网格和平面结合在一起。
cpos = plane_mesh.plot()
plane_plotter = pv.Plotter()
plane_plotter.add_mesh(plane_mesh)
输出如下所示。
PyVista Plane Output
看起来很棒，对吧？让我们尝试一些其他形状和物体，看看惊人的结果。下面的代码片段将帮助我们得到一个门卫作为输出。
mesh = examples.download_doorman()
mesh.plot(cpos="xy")
PyVista Doorman Output
哇哦。多详细的模型啊？我相信你也对结果感到惊讶。我们再来看看最后一个对象！下面的代码片段将会产生一些令人惊奇的东西。只要试一试，你就会惊叹不已。
mesh = examples.download_bunny_coarse()
cpos = [(0.2, 0.3, 0.9), (0, 0, 0), (0, 1, 0)]
mesh.plot(cpos=cpos, show_edges=True, color=True)
PyVista Bunny Output
屏幕上的小兔子真可爱，对吧？
结论
我希望你喜欢 PyVista 上的教程，并在这个教程中学到一些新东西。如果你喜欢这个教程，我建议你也看看下面的教程:
感谢您的阅读！
使用 PyYAML 进行 Python YAML 处理
YAML 代表 YAML 标记语言。它广泛用于为许多不同的 DevOps 工具和应用程序编写和存储配置文件。它以文本文件的形式编写，易于人类阅读，易于阅读和理解。它使用。yaml 或。yml 作为扩展。它类似于其他数据序列化语言，如 JSON 和 XML。
数据序列化是通过网络执行配置文件传输和恢复的标准格式。
使用 YAML 用 Python 编写的数据序列化文件可以很容易地通过网络发送，然后可以使用另一种编程语言对其进行反序列化。它支持多种语言，如 Python、JavaScript、Java 等等。这些语言有 YAML 库，使它们能够解析和使用 YAML 文件。在本文中，我们将使用 Python 通过一些例子来回顾 YAML。它还支持列表、字典和数组等数据结构。
YAML vs XML vs JSON
让我们看一个配置文件的例子，看看三个版本，以获得概述和语法。
YAML——YAML 不是一种标记语言
configuration:
name: my-api-config
version: 1.0.0
about: "some description"
description: |
Lorem ipsum dolor sit amet,
consectetur adipiscing elit
scripts:
"start:dev": main.py
keywords: ["hello", "there"]
XML–可扩展标记语言
<configuration>
<name>my-api-config</name>
<version>1.0.0</version>
<about>some description</about>
<description>Lorem ipsum dolor sit amet, consectetur adipiscing elit</description>
<scripts>
<start:dev>main.py</start:dev>
</scripts>
<keywords>hello</keywords>
<keywords>there</keywords>
</configuration>
JSON–JavaScript 对象符号
{
"configuration": {
"name": "my-api-config",
"version": "1.0.0",
"about": "some description",
"description": "Lorem ipsum dolor sit amet, \nconsectetur adipiscing elit\n",
"scripts": {
"start:dev": "main.py"
},
"keywords": [
"hello",
"there"
]
}
}
破解一份 YAML 的文件
我们示例中的 YAML 文件显示了应用程序的一些配置设置。与其他两种配置文件格式相比，有一些明显的区别，它们甚至使用了更多的符号解析。YAML 的核心是使用键:值对在文件中存储数据。这些键应该是字符串，它们可以用引号或者不用引号来写。这些值可以接受多种数据类型，如整数、字符串、列表、布尔值等。
写入 YAML 文件时，需要正确的缩进。使用制表符是不允许的，所以我们需要小心，否则我们将有林挺错误在我们的文件中。所以，它真的很简单，也很易读。不像 XML 或 JSON 文件，我们不必在阅读时解析多个符号。
configuration:
name: my-api-config
version: 1.0.0
about: "some description"
# This is a comment
description: |
Lorem ipsum dolor sit amet,
consectetur adipiscing elit
scripts:
"start:dev": main.py
keywords: ["hello", "there"]
我们还可以像上面写的那样在文件中包含注释，以及使用 |管道字符的多行字符串，如示例代码所示。
用 PyYaml 处理 YAML 文件
在本节中，我们将使用 Python 的 PyYaml 模块对 YAML 文件执行一些基本操作，如读取、写入和修改数据。
- 安装
PyYaml
pip install pyyaml
读取一个yaml 文件
假设我们有一个带有一些配置的 yaml 文件，我们想用 Python 读取其中的内容。
文件名 : config_one.yml
configuration:
name: my-api-config
version: 1.0.0
about: some description
stack:
- python
- django
接下来，我们将创建一个新的 python 文件，并尝试读取 yml 文件。
文件名 : PyYaml.py
import yaml
with open("config_one.yml", "r") as first_file:
data = yaml.safe_load(first_file)
print(type(data))
print(data)
"""
Output:
<class 'dict'>
{'configuration': {'name': 'my-api-config', 'version': '1.0.0', 'about': 'some description', 'stack': ['python', 'django']}}
"""
说明:
我们正在使用 import yaml 导入**pyyaml** 模块。要读取一个 yaml 文件，我们首先必须以读取模式打开文件，然后使用 safe_load() 加载内容。由于不同的构造函数，比如load()函数，所以有多个加载器。使用load() 并不安全，因为它允许执行几乎任何脚本，包括恶意代码，这一点也不安全。因此，safe_load()是推荐的方式，它不会创建任何任意对象。
我们使用 Python 代码打印出 yaml 文件中的数据类型。控制台显示输出为 **<class dict>**，包含的数据格式化为字典，存储为 key: value 对。
修改我们的yaml 文件
要修改我们已经加载的文件，我们必须首先确定数据类型。如果键的值是一个字符串，我们必须在更新 **key: value**对之前将所有的附加值放在一个列表中。
import yaml
with open("config_one.yml", "r") as first_file:
data = yaml.safe_load(first_file)
print(type(data))
# Accessing our <class dict> and modifying value data using a key
data["configuration"]["stack"] = ["flask", "sql"]
# Appending data to the list
data["configuration"]["stack"].append("pillow")
print(data)
"""
Output:
<class 'dict'>
{'configuration': {'name': 'my-api-config', 'version': '1.0.0', 'about': 'some description', 'stack': ['flask', 'sql', 'pillow']}}
"""
说明:
我们在这里有一个嵌套字典，我们正在使用我们试图修改其值的键来访问数据。还有一个 append() 功能，用于向值列表添加另一个项目。请注意，这些修改仅在运行时执行。我们将把这些值写入新的 yaml 文件。
用修改后的数据写入一个yaml文件
只需几行代码，就可以将上述数据以及修改后的值写入一个新文件中。
import yaml
with open("config_one.yml", "r") as first_file:
data = yaml.safe_load(first_file)
print(type(data))
# Accessing our <class dict> and modifying value data using a key
data["configuration"]["stack"] = ["flask", "sql"]
# Appending data to the list
data["configuration"]["stack"].append("pillow")
print(data)
# Writing a new yaml file with the modifications
with open("new_config.yaml", "w") as new_file:
yaml.dump(data, new_file)
文件名 : new_config.yaml
configuration:
about: some description
name: my-api-config
stack:
- flask
- sql
- pillow
version: 1.0.0
解释:
我们必须使用下面的语法提供新的文件名，然后使用带有两个参数的 yaml.dump ，数据变量包含原始的 yaml 代码以及对它所做的更改，第二个参数作为声明用于执行 write 方法的**new_file**变量。我们可以看到，新文件保留了原始文件中的代码以及我们对其进行的更改。
摘要
在本文中，我们介绍了 yaml 文件的基本结构，并使用它来读取、修改和写入新文件的配置。我们还对同一个 YAML 文件使用了不同的语法，并将它与 JSON 和 XML 进行了比较。用于编写 YAML 文件的极简方法显然非常简单，易于阅读，这使得它成为各种技术栈使用的最流行的文本格式配置文件之一。
参考
pyzbar 模块:用 Python 解码条形码
你好，程序员朋友！在本教程中，我们将学习如何使用 Python 解码图像中的条形码。我们将同样使用pyzbar模块，并将其与枕形模块配对。
使用 pyzbar 模块从图像中解码条形码
pyzbar模块是一个负责轻松读取和解码一维条形码或 QR 码的模块，它需要PIL模块才能正常工作。在实现模块之前，我们首先需要导入这两个模块。
1.导入所需的模块
为了准确地操作函数，我们首先需要在代码中导入 pyzbar 模块和 PIL。使用下面的代码块导入解码条形码所需的模块和功能。
from pyzbar.pyzbar import decode
from PIL import Image
2.导入条形码图像
下一步是借助 PIL 模块图像子模块的打开功能，从我们的系统导入条形码图像。同样如下图所示。
img = Image.open("bar1.jpg")
对于本教程，我们已经采取了一个随机的条形码在网上找到。如果您想定制条形码/QR 码，您可以查看关于创建定制条形码/QR 码的教程。
我们选择的条形码如下所示。我们的目标是提取条形码下的信息。
Bar1
3.从条形码获取信息
为了从图像中提取信息，借助将图像对象作为参数的decode函数获得条形码。相同的代码如下所示。
all_info = decode(img)
但是存储在all_info变量中的信息显示在下面的块中。你可以看到获得的信息非常杂乱，从这些信息中无法解码出任何东西。
[Decoded(data=b'00123456789101112133', type='CODE128', rect=Rect(left=28, top=0, width=2114, height=885), polygon=[Point(x=28, y=1), Point(x=28, y=885), Point(x=2142, y=884), Point(x=2142, y=0)])]
4.显示条形码信息
为了只显示条形码图像中的数据，而忽略变量中其余不必要的信息，我们将使用下面的代码块。
for i in all_info:
print(i.data.decode("utf-8"))
该代码块将在屏幕上显示与条形码图像下的值相匹配的值 00123456789101112133 。您可以在其他条形码图像甚至 QR 码图像上测试相同的代码。
结论
所以，我希望你知道如何用 Python 编程语言解码条形码。感谢您阅读教程！
继续多看！快乐学习！
二维码模块:使用 Python 生成您自己的二维码！
你好。今天，我们将学习如何使用 Python 中的 qrcode 模块获得自己的 QR code。
似乎很有趣，对吗？我们开始吧！
QR(快速响应)码简介
二维码能够存储大量数据，当扫描时，用户可以立即获取信息。
它将所有数据存储为方形网格中的一系列像素。一般来说，我们将 QR 码用于以下目的:
- 链接应用程序下载链接
- 帐户登录详细信息
- 付款
标准 QR 码的主要组成部分是 QR 码外面的三个大方块。一旦 QR 阅读器识别出它们，它就知道方块中包含的全部信息。
使用二维码模块从头开始创建或代码
我们做的第一件事是导入qrcode模块，然后使用ORCode函数创建一个qr对象。
我们要编码的下一步是使用add_data函数将数据添加到 QR 码中。我们以字符串的形式传递我们想要的数据。
接下来，我们使用make函数来构建二维码。下一步是获取我们构建的二维码的图像。
为了以图像的形式创建和保存 QR 码，我们将分别使用make_image和save函数。
在同一个函数中，我们添加了图像的路径/名称。相同的代码如下所示。
import qrcode
qr = qrcode.QRCode()
qr.add_data('This is my first QR code.')
qr.make()
img = qr.make_image()
img.save('qr1.png')
生成的二维码显示如下。
First Qr Code Generated Python
下图显示了通过我的设备扫描保存的二维码的结果。
First Qr Python Phone Output 1
定制二维码
我们还可以通过在前面使用QRCode函数创建的 qr 对象中添加一些属性来定制 QR 码的设计和结构。
我们将要添加到对象中的一些属性如下:
version:决定了二维码的大小，取值范围从 1 到 40 ( 1 显然是最小的)box_size:这决定了 QR 框中需要有多少像素
我们还在make_image函数中添加了一些属性，分别使用back_color和fill_color属性来改变背景和 QR 码的颜色。
生成此类 QR 码的代码如下所示:
qr1 = qrcode.QRCode(version=1,box_size=10)
qr1.add_data('My first customized QR code')
qr1.make()
img1 = qr1.make_image(fill_color="red", back_color="lightblue")
img1.save('qr2.png')
输出的自定义二维码如下图所示:
Second Qr Code Generated Python
从我自己的设备上扫描时，结果是准确的，如下所示:
Customized Qr Python
结论
恭喜你！现在你可以自己为任何你想要的东西建立二维码。扫描二维码时，您还可以为二维码添加链接，而不是简单的文本，以访问某个网站。
希望你学到了一些东西！编码快乐！
四分位数偏差——在 Python 中实现
原文：https://www.askpython.com/python/examples/quartile-deviation
嘿伙计们！在本教程中，我将向您展示如何使用 Python 编程语言计算四分位数偏差。
离差的绝对度量被称为四分位数偏差。它的计算方法是将上下四分位数之差除以一半。
四分位偏差介绍
四分位偏差是离差的绝对度量，其中离差是分布值与平均值之间的差异量。
即使数据中只有一个极高或极低的数字，该范围作为离差度量的效用也会降低。
为了计算四分位数偏差，我们必须将数据分成四个部分，每个部分包含 25%的值。
数据的四分位数偏差通过取最高(75%)和最低(25%)四分位数之差的一半来计算。
在 Python 中实现四分位数偏差
我希望你现在明白什么是四分位偏差。让我们看看如何使用 Python 来确定数据集的四分位数偏差。
为了在 Python 中计算它，我们将首先构建一个数据集，然后从数据中识别 quartile1、quartile2 和 quartile3，然后开发一个函数，该函数将用于返回 quartile3 和 quartile1 之差的一半的乘积。
看看下面提到的代码:
import numpy as np
data = list(range(20, 100, 5))
print("Initial Data : ", data)
Q1 = np.quantile(data, 0.25)
Q2 = np.quantile(data, 0.50)
Q3 = np.quantile(data, 0.75)
print("Quartile 1 : ", Q1)
print("Quartile 2 : ", Q2)
print("Quartile 3 : ", Q3)
def QuartileDeviation(a, b):
return (a - b)/2
print("Computed Result : ",QuartileDeviation(Q3, Q1))
代码的输出
上面提到的代码将给出以下输出:
Initial Data : [20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]
Quartile 1 : 38.75
Quartile 2 : 57.5
Quartile 3 : 76.25
Computed Result : 18.75
我希望你喜欢这篇关于用 Python 编程语言计算数据集的四分位数偏差的教程。
多看看这样的教程，永远不要停止学习！
DataFrame.query()函数:如何查询熊猫 DataFrame？
原文：https://www.askpython.com/python-modules/pandas/query-pandas-dataframe
在本 Python 教程中，我们将讨论如何使用 DataFrame.query()函数来查询熊猫数据帧。那么，我们开始讨论吧。
pandas 中 DataFrame.query()函数的语法
pandas.DataFrame.query(expr, inplace=False, **kwargs)
expr =包含逻辑表达式的字符串，根据该表达式选择熊猫数据帧的行(当 expr=True 时)。
原地 =这是一个布尔值(“True”或“False”)，它将决定是原地修改数据帧还是返回修改后的数据帧的新副本。
**kwargs =引用其他关键字参数(如果有)。
何时使用 DataFrame.query()函数？
Pandas 为我们提供了许多从 pandas DataFrame 对象中选择或过滤行的方式/方法。pandas 中的DataFrame.query()函数是过滤 pandas DataFrame 对象的行的健壮方法之一。
并且最好使用DataFrame.query()函数来选择或过滤熊猫数据帧对象的行，而不是传统的和常用的索引方法。这个DataFrame.query()函数也可以和其他 pandas 方法一起使用，使数据操作变得平滑和简单。
DataFrame.query()函数的示例
让我们创建一个示例 pandas DataFrame 对象，并借助几个例子来理解DataFrame.query()函数的功能。
创建一个示例 pandas DataFrame 对象
# Import pandas Python module
import pandas as pd
# Create a pandas DataFrame object
df = pd.DataFrame({'Dept': ['ECE', 'ICE', 'IT', 'CSE', 'CHE', 'EE', 'TE', 'ME', 'CSE', 'IPE', 'ECE'],
'GPA': [8.85, 9.03, 7.85, 8.85, 9.45, 7.45, 6.85, 9.35, 6.53,8.85, 7.83],
'Name': ['Mohan', 'Gautam', 'Tanya', 'Rashmi', 'Kirti', 'Ravi', 'Sanjay', 'Naveen', 'Gaurav', 'Ram', 'Tom'],
'RegNo': [111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121],
'City': ['Biharsharif','Ranchi','Patna','Patiala','Rajgir','Patna','Patna','Mysore','Patna','Mumbai','Patna']})
# Print the created pandas DataFrame
print('Sample pandas DataFrame:\n')
print(df)
输出:
Sample pandas DataFrame:
Dept GPA Name RegNo City
0 ECE 8.85 Mohan 111 Biharsharif
1 ICE 9.03 Gautam 112 Ranchi
2 IT 7.85 Tanya 113 Patna
3 CSE 8.85 Rashmi 114 Patiala
4 CHE 9.45 Kirti 115 Rajgir
5 EE 7.45 Ravi 116 Patna
6 TE 6.85 Sanjay 117 Patna
7 ME 9.35 Naveen 118 Mysore
8 CSE 6.53 Gaurav 119 Patna
9 IPE 8.85 Ram 120 Mumbai
10 ECE 7.83 Tom 121 Patna
示例#1
选择示例数据框中的行，其中(City = "Patna ")。
# Filter the rows of the sample DataFrame which has City = 'Patna'
# Using the DataFrame.query() function
df2 = df.query('City=="Patna"')
# Print the filtered sample pandas DataFrame
print('Filtered sample pandas DataFrame:\n')
print(df2)
输出:
Filtered sample pandas DataFrame:
Dept GPA Name RegNo City
2 IT 7.85 Tanya 113 Patna
5 EE 7.45 Ravi 116 Patna
6 TE 6.85 Sanjay 117 Patna
8 CSE 6.53 Gaurav 119 Patna
10 ECE 7.83 Tom 121 Patna
实施例 2
选择样本数据框的行，其中(GPA < 8)。
# Filter the rows of the sample DataFrame which has GPA < 8
# Using the DataFrame.query() function
df2 = df.query('GPA < 8' & City == "Patna")
# Print the filtered sample pandas DataFrame
print('Filtered sample pandas DataFrame:\n')
print(df2)
输出:
Filtered sample pandas DataFrame:
Dept GPA Name RegNo City
2 IT 7.85 Tanya 113 Patna
5 EE 7.45 Ravi 116 Patna
6 TE 6.85 Sanjay 117 Patna
8 CSE 6.53 Gaurav 119 Patna
10 ECE 7.83 Tom 121 Patna
实施例 3
选择示例数据框中的行，其中(GPA < 7 且 City = 'Patna ')。
# Filter the rows of the sample DataFrame which has GPA < 7 & City = 'Patna'
# Using the DataFrame.query() function
df2 = df.query('GPA < 7 & City == "Patna"')
# Print the filtered sample pandas DataFrame
print('Filtered sample pandas DataFrame:\n')
print(df2)
输出:
Filtered sample pandas DataFrame:
Dept GPA Name RegNo City
6 TE 6.85 Sanjay 117 Patna
8 CSE 6.53 Gaurav 119 Patna
实施例 4
选择在[ECE，CSE，IT]中有 Dept 的样本数据帧的行。
# Filter the rows of the sample DataFrame which has Dept in (ECE, CSE, IT)
# Using the DataFrame.query() function
df2 = df.query("Dept in ['CSE','ECE','IT']")
# Print the filtered sample pandas DataFrame
print('Filtered sample pandas DataFrame:\n')
print(df2)
输出:
Filtered sample pandas DataFrame:
Dept GPA Name RegNo City
0 ECE 8.85 Mohan 111 Biharsharif
2 IT 7.85 Tanya 113 Patna
3 CSE 8.85 Rashmi 114 Patiala
8 CSE 6.53 Gaurav 119 Patna
10 ECE 7.83 Tom 121 Patna
实施例 5
选择样本数据帧的行，其中(RegNo < 115 and GPA > 7)。
# Filter the rows of the sample DataFrame which has (RegNo < 115 & GPA > 7)
# Using the DataFrame.query() function
df2 = df.query("RegNo < 115 & GPA > 7")
# Print the filtered sample pandas DataFrame
print('Filtered sample pandas DataFrame:\n')
print(df2)
输出:
Filtered sample pandas DataFrame:
Dept GPA Name RegNo City
0 ECE 8.85 Mohan 111 Biharsharif
1 ICE 9.03 Gautam 112 Ranchi
2 IT 7.85 Tanya 113 Patna
3 CSE 8.85 Rashmi 114 Patiala
总结
在这个 Python 教程中，我们学习了如何使用 Pandas 中的DataFrame.query()函数来查询 pandas DataFrame 对象。希望您已经理解了上面讨论的概念和示例，并准备好使用它们来查询您自己的 pandas 数据框架。感谢阅读！请继续关注我们，了解更多关于 Python 编程的精彩学习内容。
如何用 Python 实现快速排序？
原文：https://www.askpython.com/python/examples/quicksort-algorithm
快速排序是一种排序算法，遵循分而治之的策略。它的工作原理是选择一个轴心元素，然后通过执行交换来围绕轴心排列元素。它递归地重复这个过程，直到数组被排序。
在本教程中，我们将学习快速排序是如何工作的，以及如何为其实现编写 python 代码。
了解快速排序算法
对数组执行快速排序的第一步是选择透视元素。有多种选择枢纽元素的方式。
你可以选择一个随机元素或者你可以选择数组的中值。为了简单起见，我们将选择数组的第一个元素作为我们的枢纽元素。
1.选择透视元素
如上所述，第一个元素被挑选为枢纽元素。
pivot = array[start]
选择一个枢纽元素后，我们需要重新排列它周围的元素。我们以这样的方式重新排列元素，所有小于枢轴的元素在左边，所有大于枢轴的元素在右边。
我们如何做到这一点？
让我们接下来讨论那个。
2.围绕轴心重新排列元素
为了围绕轴心重新排列元素，我们初始化两个变量。
让我们称这些变量为低和高。
我们用数组的第二个元素初始化低电平(旋转后一个)，用最后一个元素初始化高电平。
low = start + 1
high = end
为了重新排列元素，我们将低的向右移动，高的向左移动。在这样做的时候，我们的目的是确保所有大于中枢的值应该向右移动，而所有小于中枢的值应该向左移动。
当我们以这种方式排列值时，我们可以找到 pivot 元素在排序数组中的最终位置，因为所有比 pivot 小的元素都在它的左边，而所有在右边的元素都更大。
枢轴右侧和左侧的元素可能以排序方式排列，也可能不以排序方式排列。
3.如何移低移高？
我们向左移动 high，直到 high 指向小于 pivot 的值，或者直到 high 小于 low。
while low <= high and array[high] >= pivot:
high = high - 1
类似地，我们向右移动低位，直到它指向一个高于中枢的值，或者直到高位小于低位。
while low <= high and array[low] <= pivot:
low = low + 1
从循环中出来后，我们检查 low 是否小于或等于 high。如果是这种情况，那么我们需要交换高低值。
if low <= high:
array[low], array[high] = array[high], array[low]
如果 low 大于 high，我们将跳出循环，返回 high 作为 pivot 元素的位置。这意味着我们已经成功地围绕轴心排列了值。
4.到目前为止实现的代码
下面给出了负责选择 pivot 元素并重新排列元素的函数的完整代码:
def pivot(array, start, end):
#initializing
pivot = array[start]
low = start + 1
high = end
while True:
#moving high towards left
while low <= high and array[high] >= pivot:
high = high - 1
#moving low towards right
while low <= high and array[low] <= pivot:
low = low + 1
#checking if low and high have crossed
if low <= high:
#swapping values to rearrange
array[low], array[high] = array[high], array[low]
else:
#breaking out of the loop if low > high
break
#swapping pivot with high so that pivot is at its right # #position
array[start], array[high] = array[high], array[start]
#returning pivot position
return high
5.对数组的两半进行递归调用
在围绕轴心重新排列元素之后，我们需要对数组的两半进行递归调用。
这些调用会不断重复，直到数组的大小为 1。进行递归调用的函数代码如下所示:
def quick_sort(array, start, end):
if start >= end:
return
#call pivot
p = pivot(array, start, end)
#recursive call on left half
quick_sort(array, start, p-1)
#recursive call on right half
quick_sort(array, p+1, end)
最后两条语句分别在左半部分和右半部分进行递归调用。
对于左半部分和右半部分，重复相同的选择枢轴并重新排列其周围元素的过程。
当我们重复这样做时，我们确保每个元素都被放置在正确的位置。
在这里，“正确的位置”意味着所有较小的元素在左边，所有较大的元素在右边。当所有的元素都放在正确的位置时，我们得到一个排序后的数组。
快速排序数组的示例
让我们举一个测试代码的例子。
[5,1,3,9,8,2,7]
让我们添加一些代码，为每个递归调用打印 pivot 元素、数组的左半部分和右半部分。
def quick_sort(array, start, end):
if start >= end:
return
p = pivot(array, start, end)
print("Pivot",array[p])
print("left :", array[start:p])
print("right :",array[p+1:end+1])
print("\n")
quick_sort(array, start, p-1)
quick_sort(array, p+1, end)
让我们用上面的示例数组运行代码。
array = [5,1,3,9,8,2,7]
quick_sort(array, 0, len(array) - 1)
print(array)
输出结果如下:
Pivot 5
left : [2, 1, 3]
right : [8, 9, 7]
Pivot 2
left : [1]
right : [3]
Pivot 8
left : [7]
right : [9]
[1, 2, 3, 5, 7, 8, 9]
我们可以看到，对于每个 pivot 元素，左边的数组包含小于 pivot 的元素，右边的数组包含大于 pivot 的元素。
我们可以直观地将递归调用表示如下:
完全实现
快速排序的完整实现如下所示:
def pivot(array, start, end):
#initializing
pivot = array[start]
low = start + 1
high = end
while True:
#moving high towards left
while low <= high and array[high] >= pivot:
high = high - 1
#moving low towards right
while low <= high and array[low] <= pivot:
low = low + 1
#checking if low and high have crossed
if low <= high:
#swapping values to rearrange
array[low], array[high] = array[high], array[low]
else:
#breaking out of the loop if low > high
break
#swapping pivot with high so that pivot is at its right # #position
array[start], array[high] = array[high], array[start]
#returning pivot position
return high
def quick_sort(array, start, end):
if start >= end:
return
#call pivot
p = pivot(array, start, end)
#recursive call on left half
quick_sort(array, start, p-1)
#recursive call on right half
quick_sort(array, p+1, end)
array = [5,1,3,9,8,2,7]
quick_sort(array, 0, len(array) - 1)
print(array)
结论
本教程是关于在 Python 中实现快速排序的。快速排序的最坏情况时间复杂度为 O(n² ) ，平均情况时间复杂度为 O(n logn)。
Python 报价模块:如何生成随机报价？
大家好，今天我们来学习如何使用 python 中的 quote 模块获取不同作者的报价。所以让我们开始吧！
生成随机关键字
为了从各种背景中获取报价，我们每次都会生成一个随机关键字，该程序将围绕该关键字返回特定作者的报价。
为了获得任意的英语单词，我们使用了random_word模块。random_word 模块可用于生成单个随机单词或随机单词列表。
如果导入模块时出现错误，您可以使用pip命令安装模块。我们先来看下面几行代码。
from random_word import RandomWords
r = RandomWords()
w = r.get_random_word()
print(w)
这里我们从模块中导入了一个名为RandomWords的函数，并创建了一个相同的对象，这将有助于提取单词。
后来，我们对创建的对象应用了get_random_word函数来创建一个随机单词，并将其存储到一个变量中。
该代码从英语词典中随机生成一个单词。
使用 Python 中的报价模块获得随机报价
现在我们有了一个随机的关键字，下一步是使用quote库为该关键字生成一个报价。
如果导入库时出现错误，确保事先使用pip命令安装报价库。
让我们看看下面的代码。
from quote import quote
res = quote('family',limit=1)
print(res)
为了生成随机报价，我们将使用报价模块中的quote函数。quote 函数需要一个关键字来搜索报价。
我们还设置了限制值来限制生成的报价数量。但是在打印输出时，我们会得到这样的结果:
[{'author': 'J.R.R. Tolkien', 'book': 'The Fellowship of the Ring', 'quote': "I don't know half of you half as well as I should like; and I like less than half of you half as well as you deserve."}]
其背后的原因是 quote 函数返回一个字典列表，其中每个字典包含关于特定报价的信息。
因此，我们将从字典中提取报价值。为此，我们将使用下面几行代码。
for i in range(len(res)):
print(res[i]['quote'])
我们在这里做的是遍历列表，对于每个字典值，我们将只打印quote键旁边的值。
现在我们得到如下输出:
I don't know half of you half as well as I should like; and I like less than half of you half as well as you deserve.
用一个随机的词得到一个随机的报价
现在我们学习了如何使用不同的模块生成关键字和报价，让我们将它们结合起来，根据特定的关键字生成报价。
相同的代码如下所示。
from random_word import RandomWords
from quote import quote
r = RandomWords()
w = r.get_random_word()
print("Keyword Generated: ",w)
res = quote(w, limit=1)
for i in range(len(res)):
print("\nQuote Generated: ",res[i]['quote'])
结果如下:
Keyword Generated: fenman
Quote Generated: The fenman gazed at Wimsey with a slow pity for his bird-witted feebleness of mind.
结论
今天我们学习了使用 Python 编程语言生成随机关键字和关键字周围的引号。
您也可以通过在多个关键字上生成多个引号来进行尝试！编码快乐！
感谢您的阅读！
在 Python 中使用 R
让我们学习在 Python 中使用 R。纵观历史，在数据科学世界中，两种语言总是在数据分析方面竞争，以求超越自己。
这两个都是，R 和 Python。
这两种编程语言都有自己的粉丝群，而且各有各的优势。
R 为统计分析提供了更大的支持，并在其中实现了专门化，而 Python 提供了面向对象的方法以及与其他模块的大量集成。
Python 和 R 的优点和缺点结合在一起会成为一个强大的组合。因为 Python 缺乏的地方，R 压倒了，反之亦然。
因此，开发人员创建了rpy2库，这也是我们今天的主题。
这对需要两者结合的开发者意味着什么？一个机会。
安装 rpy2 模块
开始的先决条件是rpy2模块只有在您已经安装了所需的 R 版本的情况下才能工作。
和其他模块一样，rpy2模块需要通过 Python 发行版的 pip 包安装程序进行安装。
在 pip 中，安装 rpy2 的命令很简单，
pip install rpy2
这应该会自动安装所需的模块，我们可以继续在 Python 脚本中使用它！
如果你想在体验脚系统之前测试一下 rpy2 的功能，你可以先试着使用 docker 镜像，看看 rpy2 的 docker hub 。
在 Python 中使用 R 和 rpy2 模块
为了在 Python 中使用 R，我们首先将 rpy2 导入到代码中。
import rpy2
from rpy2 import robjects
现在，我们可以开始使用 Python 中的 R 了。但是，在您开始使用这两种语言之前，了解一下在本模块中 R 语言的使用上的细微差别会很有帮助。
1.通过 rpy2 导入包
使用 R 的大量工作都与导入包进行数据分析有关。而rpy2通过py2.robjects.packages.importr()函数给我们提供了这个。
这个函数作为一种方法，将为 R 设计的包导入 Python，我们可以使用它们来基本上拥有脚本中存在的两种语言的特性。
from rpy2.robjects.packages import importr
# imports the base module for R.
base = importr("base")
# imports the utils package for R.
utils = importr("utils")
我们现在可以使用通过这个方法导入的函数了。
2.在 Python 中使用 R
在脚本中使用 R 的方法是使用robjects.r实例，它允许我们本质上使用 R 控制台。
如果你想知道这到底是如何工作的，那是因为rpy2模块正在后台运行一个嵌入式 R。
# Essentially retrieving the value of pi in the R console
pi = robjects.r['pi']
print(pi[0])
# Output : 3.14159265358979
虽然这种方法可能适用于单行代码。值得一提的是，如果我们希望处理大量需要用 r 处理的代码，这不是一个可行的方法。
幸运的是，我们可以在三个引号中输入一整块代码。
robjects.r('''
# create a function `f`
f <- function(r, verbose=FALSE) {
if (verbose) {
cat("I am calling f().\n")
}
2 * pi * r
}
# call the function `f` with argument value 3
f(3)
''')
# The result of the function is returned to the Python Environment
函数本身仍然存在于 R 全局环境中，但是可以用命令robjects.globalenv['f']访问，其中 f 是我们的 R 环境中的变量。
rpy2模块为我们提供了很多功能，虽然一开始看起来有点难，但它主要只是提到 R 环境的语法。
这里有几个使用 R 中不同特性的例子！
# Working with different kinds of vectors
res1 = robjects.StrVector(['abc', 'def'])
res2 = robjects.IntVector([1, 2, 3])
res3 = robjects.FloatVector([1.1, 2.2, 3.3])
print(res1.r_repr())
# Output : c("abc", "def")
print(res2.r_repr())
# Output : 1:3
print(res3.r_repr())
# Output : c(1.1, 2.2, 3.3)
# Working with different functions of R
rsort = robjects.r['sort']
res4 = rsort(robjects.IntVector([1,2,3]), decreasing=True)
print(res4.r_repr())
# Working with matrices in R
v = robjects.FloatVector([1.1, 2.2, 3.3, 4.4, 5.5, 6.6])
m = robjects.r['matrix'](v, nrow = 2)
print(m)
# Output :
# [,1] [,2] [,3]
# [1,] 1.1 3.3 5.5
# [2,] 2.2 4.4 6.6
# Working with Graphics in R
r = robjects.r
x = robjects.IntVector(range(10))
y = r.rnorm(10)
r.X11()
r.layout(r.matrix(robjects.IntVector([1,2,3,2]), nrow=2, ncol=2))
r.plot(r.runif(10), y, xlab="runif", ylab="foo/bar", col="red")
3.走向
使用两种不同的语言来解决问题的实现打开了许多新发现的大门。
继续使用 Python 中的 R 将会使用 Python 提供的功能来处理各种不同的模块，并扩展数据科学和数学逻辑领域的功能。
将 Pandas 、 OpenCV 和 Scikit-Learn 集成到程序中是值得研究的，以便扩展和测试新的想法，而没有语言提供的任何障碍。
如果您发现自己不清楚某个特性是否可以在rpy2模块中使用，请随意浏览他们维护良好的文档！
rpy2 的替代品
虽然rpy2是一个很棒的模块，但你可能希望看看其他模块，以便找出哪一个最适合你。
因此，这里有一个列表来帮助你确定你需要哪个模块，而不是为rpy2中不存在或不适合你的特性寻找变通办法。
结论
现在您已经知道了rpy2模块提供了什么，以及如何设置它来开始处理您的代码，您可以开始计算，而不用担心 R 和 Python 之间的冲突。
毕竟，他们现在都站在你这边！
在你的数学和数据科学之旅中，看看我们关于熊猫和 matplotlib 的其他模块的其他作品。
参考
Python Tkinter 示例:随机事实机器
原文：https://www.askpython.com/python-modules/tkinter/random-facts-machine
你好，初学者！今天我们将使用 Python Tkinter 构建一个 GUI 应用程序，随机事实机器。让我们开始吧！
我们指的是什么样的事实？
世界各地的随机事件。可以是字面上的任何东西，只要该陈述是真实的，并且基于实际发生的事件。
事实回答“在哪里”、“何时”、“为什么”和“如何”的问题。事实总是有证据支持的，这就是为什么事实总是真实的。
阅读事实显然也有助于增加一个人的词汇量、阅读能力和知识。它还可以帮助释放一个人的压力和焦虑。
构建随机事实机器
让我们进入使用 Python 中的 Tkinter 模块构建随机事实机器的步骤。
1.设计界面
应用程序的设计包括以下步骤:
- 创建窗口
- 正在导入 Tkinter 模块
- 创建自定义的空白窗口
- 将 resizable 属性设置为 False 以保持尺寸不变
- 添加基本元素
- 标签
- 获取事实按钮
- 用于显示事实的文本框
- 按钮退出应用程序
相同的代码如下所示。您可以根据自己的喜好自定义窗口。
import tkinter as tk
window = tk.Tk()
window.geometry("700x250")
window.config(bg="#E67E22")
window.resizable(width=False,height=False)
window.title('FACT MACHINE')
l1 = tk.Label(window,text="Welcome to the Fact Machine!",font=("Arial", 25),fg="Black",bg="White")
l2= tk.Label(window,text="Click on the 'Get new Fact!' button to get a fact!",font=("Arial", 15,"bold"),fg="darkgreen",bg="#E67E22")
btn1 = tk.Button(window,text="Get new Fact!",font=("Arial", 15))
btn2 = tk.Button(window,text="Exit application",font=("Arial", 15))
t1 = tk.Text(window,width=60,height=2,font=("Arial",15),state='disabled',bg="lightgreen")
l1.pack()
l2.pack()
btn1.pack()
t1.pack()
btn2.pack()
创建的最终设计如下所示。
Initial Screen Fact Machine
向按钮添加功能
按钮 1:退出按钮
要添加退出按钮功能，我们需要做的就是创建一个破坏窗口的exit函数。然后给按钮添加command属性，设置为退出功能。
相同的代码如下所示:
def exit():
window.destroy()
按钮 2:获取事实按钮
现在，为了获得每次点击的随机事实，我们使用 Python 中的 randfacts 模块。如果该模块不存在，那么在系统的命令提示符下运行 pip install randfacts 。
为了获得新的事实，我们使用了getFact函数，并为随机有趣的事实添加了参数 False ！获得事实后，我们清除文本框，并将事实添加到文本框中。
在声明函数之后，command属性被添加到 get fact 按钮，并被设置为 get_fact 函数。相同的代码如下所示:
import randfacts
def get_fact():
t1.config(state='normal')
t1.delete('1.0', tk.END)
f = randfacts.getFact(False)
t1.insert(tk.END,f)
t1.config(state='disabled')
Tkinter 中随机事实机的完整代码
整个应用程序的最终代码如下所示:
import randfacts
def get_fact():
t1.config(state='normal')
t1.delete('1.0', tk.END)
f = randfacts.getFact(False)
t1.insert(tk.END,f)
t1.config(state='disabled')
def exit():
window.destroy()
import tkinter as tk
window = tk.Tk()
window.geometry("700x250")
window.config(bg="#E67E22")
window.resizable(width=False,height=False)
window.title('FACT MACHINE')
l1 = tk.Label(window,text="Welcome to the Fact Machine!",font=("Arial", 25),fg="Black",bg="White")
l2= tk.Label(window,text="Click on the 'Get new Fact!' button to get a fact!",font=("Arial", 15,"bold"),fg="darkgreen",bg="#E67E22")
btn1 = tk.Button(window,text="Get new Fact!",font=("Arial", 15),command=get_fact)
btn2 = tk.Button(window,text="Exit application",font=("Arial", 15),command=exit)
t1 = tk.Text(window,width=60,height=2,font=("Arial",15),state='disabled',bg="lightgreen")
l1.pack()
l2.pack()
btn1.pack()
t1.pack()
btn2.pack()
window.mainloop()
输出
正如您在下图中看到的那样，该应用程序运行良好:
Output1 Fact Machine
Output2 Fact Machine
结论
恭喜你！您已经成功地构建了自己事实机器。希望你喜欢它！快乐学习！
感谢您的阅读！
随机森林回归:完全参考
原文：https://www.askpython.com/python/examples/random-forest-regression
欢迎阅读这篇关于随机森林回归的文章。首先让我快速地向您介绍一下回归的含义。
什么是机器学习中的回归？
回归是一种机器学习技术，用于预测一定范围内的值。让我们用一个例子来理解这个概念，考虑雇员的工资和他们多年的经验。
此数据的回归模型有助于预测员工的工资，即使该年在数据集中没有相应的工资。
什么是随机森林回归？
随机森林回归是一种集成学习技术。但是什么是集成学习呢？
在集成学习中，你可以多次使用多个算法或同一个算法，然后组合成一个比原来更强大的模型。
基于树的预测更准确，因为它考虑了许多预测。这是因为使用了平均值。这些算法更稳定，因为数据集中的任何变化都会影响一棵树，但不会影响树的森林。
执行随机森林回归的步骤
这是一个四步流程，我们的步骤如下:
- 从训练集中随机选取 K 个数据点。
- 构建与这 K 个数据点相关的决策树。
- 选择你想要构建的 N 棵树，重复步骤 1 和 2。
- 对于新的数据点，让每个 Ntree 树预测问题中数据点的 Y 值，并将所有预测的 Y 值的平均值赋给新的数据点。
在 Python 中实现随机森林回归
我们的目标是建立一个决策树团队，每个决策树对因变量进行预测，随机森林的最终预测是所有树预测的平均值。
对于我们的示例，我们将使用 Salary-positions 数据集，该数据集将根据预测来预测工资。
使用的数据集可以在https://github . com/content-anu/dataset-polynomial-regression找到
1.导入数据集
我们将使用 numpy 、 pandas 和 matplotlib 库来实现我们的模型。
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
dataset = pd.read_csv('Position_Salaries.csv')
dataset.head()
数据集快照如下:
Output snapshot of dataset
2.数据预处理
我们不会有太多的数据预处理。我们只需识别特征矩阵和矢量化数组。
X = dataset.iloc[:,1:2].values
y = dataset.iloc[:,2].values
3.将随机森林回归拟合到数据集
我们将从 sklearn 的 ensemble 库中导入 RandomForestRegressor。我们使用 RFR 类构造函数创建一个回归对象。这些参数包括:
- n_estimators:森林中树木的数量。(默认值= 10)
- 标准:默认值为 mse，即均方误差。这也是决策树的一部分。
- 随机状态
from sklearn.ensemble import RandomForestRegressor
regressor = RandomForestRegressor(n_estimators = 10, random_state = 0)
regressor.fit(X,y)
回归直线如下:
Regressor line
我们将只做如下测试预测:
y_pred=regressor.predict([[6.5]])
y_pred
Output of the prediction
4.可视化结果
#higher resolution graph
X_grid = np.arange(min(X),max(X),0.01)
X_grid = X_grid.reshape(len(X_grid),1)
plt.scatter(X,y, color='red') #plotting real points
plt.plot(X_grid, regressor.predict(X_grid),color='blue') #plotting for predict points
plt.title("Truth or Bluff(Random Forest - Smooth)")
plt.xlabel('Position level')
plt.ylabel('Salary')
plt.show()
生成的图形如下所示:
Graph for 10 trees
5.上图的解释
在这个图中，我们得到了比一个决策树更多的步骤。我们有更多的音程和间隔。我们的楼梯有更多的台阶。
每一个预测都是基于 10 次投票(我们取了 10 棵决策树)。Random forest 为每个间隔计算许多平均值。
我们包含的树的数量越多，精确度就越高，因为许多树会收敛到相同的最终平均值。
6.为 100 棵树重建模型
from sklearn.ensemble import RandomForestRegressor
regressor = RandomForestRegressor(n_estimators = 100, random_state = 0)
regressor.fit(X,y)
上述 100 棵树形成的回归方程如下:
Regressor equation
7.创建 100 棵树的图形
#higher resolution graph
X_grid = np.arange(min(X),max(X),0.01)
X_grid = X_grid.reshape(len(X_grid),1)
plt.scatter(X,y, color='red')
plt.plot(X_grid, regressor.predict(X_grid),color='blue')
plt.title("Truth or Bluff(Random Forest - Smooth)")
plt.xlabel('Position level')
plt.ylabel('Salary')
plt.show()
Graph with 100 trees
图中的步数不会随着森林中树木的数量增加 10 倍。但是预测会更好。让我们预测同一个变量的结果。
y_pred=regressor.predict([[6.5]])
y_pred
Output prediction
8.为 300 棵树重建模型
from sklearn.ensemble import RandomForestRegressor
regressor = RandomForestRegressor(n_estimators = 300, random_state = 0)
regressor.fit(X,y)
上述代码片段的输出产生以下回归量:
Regressor for 300 trees
9.300 棵树的图形
#higher resolution graph
X_grid = np.arange(min(X),max(X),0.01)
X_grid = X_grid.reshape(len(X_grid),1)
plt.scatter(X,y, color='red') #plotting real points
plt.plot(X_grid, regressor.predict(X_grid),color='blue') #plotting for predict points
plt.title("Truth or Bluff(Random Forest - Smooth)")
plt.xlabel('Position level')
plt.ylabel('Salary')
plt.show()
上面的代码生成了下图:
Graph for 300 trees
现在，让我们做一个预测。
y_pred=regressor.predict([[6.5]])
y_pred
上述代码的输出如下:
Prediction using 300 trees
实现随机森林回归的完整 Python 代码
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
dataset = pd.read_csv('Position_Salaries.csv')
dataset.head()
X = dataset.iloc[:,1:2].values
y = dataset.iloc[:,2].values
# for 10 trees
from sklearn.ensemble import RandomForestRegressor
regressor = RandomForestRegressor(n_estimators = 10, random_state = 0)
regressor.fit(X,y)
y_pred=regressor.predict([[6.5]])
y_pred
#higher resolution graph
X_grid = np.arange(min(X),max(X),0.01)
X_grid = X_grid.reshape(len(X_grid),1)
plt.scatter(X,y, color='red') #plotting real points
plt.plot(X_grid, regressor.predict(X_grid),color='blue') #plotting for predict points
plt.title("Truth or Bluff(Random Forest - Smooth)")
plt.xlabel('Position level')
plt.ylabel('Salary')
plt.show()
# for 100 trees
from sklearn.ensemble import RandomForestRegressor
regressor = RandomForestRegressor(n_estimators = 100, random_state = 0)
regressor.fit(X,y)
#higher resolution graph
X_grid = np.arange(min(X),max(X),0.01)
X_grid = X_grid.reshape(len(X_grid),1)
plt.scatter(X,y, color='red')
plt.plot(X_grid, regressor.predict(X_grid),color='blue')
plt.title("Truth or Bluff(Random Forest - Smooth)")
plt.xlabel('Position level')
plt.ylabel('Salary')
plt.show()
y_pred=regressor.predict([[6.5]])
y_pred
# for 300 trees
from sklearn.ensemble import RandomForestRegressor
regressor = RandomForestRegressor(n_estimators = 300, random_state = 0)
regressor.fit(X,y)
#higher resolution graph
X_grid = np.arange(min(X),max(X),0.01)
X_grid = X_grid.reshape(len(X_grid),1)
plt.scatter(X,y, color='red') #plotting real points
plt.plot(X_grid, regressor.predict(X_grid),color='blue') #plotting for predict points
plt.title("Truth or Bluff(Random Forest - Smooth)")
plt.xlabel('Position level')
plt.ylabel('Salary')
plt.show()
y_pred=regressor.predict([[6.5]])
y_pred
上述代码的输出将是图形和预测值。以下是图表:
Output graphs
结论
正如你所观察到的，10 棵树模型预测 6.5 年工作经验的工资是 167，000 英镑。100 棵树模型预测为 158，300 棵，300 棵树模型预测为 160，333.33 棵。因此，树的数量越多，我们的结果就越准确。
Python Tkinter 项目:随机移动号码生成器
原文：https://www.askpython.com/python-modules/tkinter/random-mobile-number-generator
你好 Tkinter coders！今天我们将学习构建我们自己的随机手机号码生成器。该应用程序对于需要一些假数据的开发人员来说非常有用。
用 Python 创建随机移动号码生成器
让我们进入使用 Tkinter 创建随机数生成器的步骤。这是一个有趣的小应用程序，你会喜欢使用它，你也可以在你的初学者作品集里炫耀一下！
步骤 1:导入模块并创建 Tkinter 窗口
任何 Tkinter 项目的第一步都是导入tkinter和random模块，然后创建一个空白窗口。我们可以根据自己的喜好配置窗口。
我们将提供一个标题和背景颜色的窗口。与此同时，我们将窗口的 resize 属性设置为false。
import tkinter as tk
window = tk.Tk()
window.geometry("600x200")
window.config(bg="#F39C12")
window.resizable(width=False,height=False)
window.title('Random Mobile Number Generator')
window.mainloop()
Initial Black Screen Tkinter
步骤 2:在创建的窗口上添加小部件
这一步包括在我们刚刚创建的窗口上添加各种小部件，包括标签和按钮。我们还将创建一个空白标签，该标签将被设置为后面部分中生成的手机号码。
对于每个小部件，我们将创建小部件变量，然后在 place 函数的帮助下将它们放在屏幕上，place 函数需要小部件的 x 和 y 坐标。
import tkinter as tk
window = tk.Tk()
window.geometry("600x200")
window.config(bg="#F39C12")
window.resizable(width=False,height=False)
window.title('Random Mobile Number Generator')
l1 = tk.Label(text="Random Mobile Number Generator",font=("Arial",20),bg="Black",fg="White")
b1 = tk.Button(text="Click on me to generate a mobile number",font=("Arial",15),bg="#A3E4D7")
l2 = tk.Label(bg="#F39C12",font=("Arial",30),text="")
l1.place(x=100,y=20)
b1.place(x=110,y=70)
l2.place(x=165,y=130)
window.mainloop()
Design Screen Tkinter
步骤 3:创建一个函数来生成一个随机数
现在来创建一个函数来生成随机数，我们将利用 random模块，然后创建一个列表，其中包含以字符串形式存储在一起的 0-9 的所有数字。
我们将一个数字变量初始化为一个空字符串，从列表中选择 10 个随机数字，并不断地将它们追加到数字变量中。最后，我们将空字符串的文本设置为生成的数字。
之后，不要忘记在按钮声明中添加函数名作为command属性。你已经准备好了！
import random
def generate_number():
list = ["0","1","2","3","4","5","6","7","8","9"]
number = ""
for i in range(10):
number = number + random.choice(list)
l2.config(text = number)
最终代码
import random
def generate_number():
list = ["0","1","2","3","4","5","6","7","8","9"]
number = ""
for i in range(10):
number = number + random.choice(list)
l2.config(text = number)
import tkinter as tk
window = tk.Tk()
window.geometry("600x200")
window.config(bg="#F39C12")
window.resizable(width=False,height=False)
window.title('Random Mobile Number Generator')
l1 = tk.Label(text="Random Mobile Number Generator",font=("Arial",20),bg="Black",fg="White")
b1 = tk.Button(text="Click on me to generate a mobile number",font=("Arial",15),bg="#A3E4D7",command=generate_number)
l2 = tk.Label(bg="#F39C12",font=("Arial",30),text="")
l1.place(x=100,y=20)
b1.place(x=110,y=70)
l2.place(x=165,y=130)
window.mainloop()
一些示例输出
Random Number Output 1
Random Number Output 2
结论
恭喜你！今天我们学习了如何使用 python tkinter 技术生成手机号码！自己试试吧！
感谢您的阅读！敬请关注，了解更多信息！
Python Tkinter:随机电影建议
原文：https://www.askpython.com/python-modules/tkinter/random-movie-suggestions
嘿伙计们！今天在本教程中，我们将使用 Python tkinter 构建一个简单的 GUI 随机电影建议应用程序。
1.数据准备
为了获得包含大量电影名称的大型数据集，我们使用了kaggle。我们在项目中使用的数据集可以从这里的
1.1 导入模块
对于数据准备，我们需要两个模块，即numpy和pandas。除了这些模块，我们还将导入random和tkinter模块，我们将在后面的章节中用到它们。
导入模块的代码如下所示。
import numpy as np
import pandas as pd
import random
import tkinter as tk
1.2 数据加载
为了加载csv格式的数据文件，我们将使用熊猫模块的 read_csv函数，并将所有信息存储到一个变量中。
为了查看数据，我们将使用显示数据集前 5 行的head函数。
数据集包含 50602 个电影名称，这显然是一个巨大的数字。加载初始数据的代码如下所示。
data = pd.read_csv("indian movies.csv")
data.head()
1.3 数据准备
既然已经加载了全部数据，我们需要观察哪些列是需要的，哪些是不需要的。我们为这个项目需要的唯一的列是电影名称和上映的年份。
首先，我们使用 numpy 模块将整个数据转换成数组，以便更容易地遍历数据。然后，我们创建一个空列表来存储必要的信息。
下一步涉及按行遍历数据，只将电影名称和年份以元组的形式一起存储到一个公共列表中。
相同的代码如下所示。
data = np.array(data)
l_movies=[]
for i in data:
l_movies.append((i[1],i[2]))
print(l_movies[:5])
让我们使用列表切片打印前 5 部电影的名称和年份。其输出如下所示:
[('Dr. Shaitan', '1960'), ('Nadir Khan', '1968'), ('Apna Sapna Money Money', '2006'), ('Aag Aur Sholay', '1987'), ('Parivar', '1956')]
2.创建 Tkinter 应用程序窗口
整个窗口包含标签、输出文本框和按钮，全部放在一个屏幕上。我们还将使用不同的颜色和字体定制整个窗口。
整个设计过程的代码如下所示:
import tkinter as tk
window = tk.Tk()
window.geometry("600x200")
window.config(bg="#ABEBC6")
window.resizable(width=False,height=False)
window.title('Movie Name Suggestor')
l1 = tk.Label(window,text="Click on the button to suggest you a movie",font=("Arial",20),fg="Black",bg="White")
b1 = tk.Button(window,text="Suggest Movie",font=("Arial",15),bg="darkgreen",fg="white")
t1 = tk.Text(window,width=50,height=1,font=("Arial",15),state='disabled')
l1.place(x=30,y=10)
b1.place(x=200,y=60)
t1.place(x=15,y=120)
window.mainloop()
如果你在设计过程中有疑问，可以参考这里提到的教程。最终的输出屏幕如下所示。
Final Screen Movie Suggest App
3.向按钮添加功能
为了给“建议电影”按钮添加功能，我们将创建一个新的函数，从我们在步骤 1 中准备的列表中选择一个随机的电影数据。
所选的电影名称和上映年份将被添加到输出文本框中。该函数的代码如下所示:
def suggest():
t1.config(state='normal')
t1.delete('1.0', tk.END)
r = random.choice(l_movies)
name = r[0]
year = r[1]
msg = r[0] +"(" + r[1] + ")"
t1.insert(tk.END,msg)
t1.config(state='disabled')
创建函数后，我们需要做的就是将command属性添加到按钮声明中。这就对了。您的 GUI 应用程序现在已经完成了！
实现随机电影建议应用程序的完整代码
该应用程序的完整代码如下所示:
import numpy as np
import pandas as pd
import random
import tkinter as tk
data = pd.read_csv("indian movies.csv")
data = np.array(data)
l_movies=[]
for i in data:
l_movies.append((i[1],i[2]))
def suggest():
t1.config(state='normal')
t1.delete('1.0', tk.END)
r = random.choice(l_movies)
name = r[0]
year = r[1]
msg = r[0] +"(" + r[1] + ")"
t1.insert(tk.END,msg)
t1.config(state='disabled')
window = tk.Tk()
window.geometry("600x200")
window.config(bg="#ABEBC6")
window.resizable(width=False,height=False)
window.title('Movie Name Suggestor')
l1 = tk.Label(window,text="Click on the button to suggest you a movie",font=("Arial",20),fg="Black",bg="White")
b1 = tk.Button(window,text="Suggest Movie",font=("Arial",15),bg="darkgreen",fg="white",command=suggest)
t1 = tk.Text(window,width=50,height=1,font=("Arial",15),state='disabled')
l1.place(x=30,y=10)
b1.place(x=200,y=60)
t1.place(x=15,y=120)
window.mainloop()
样本输出
下图显示了当用户请求应用程序获取一部电影来观看时所生成的输出。
Output 1 Screen Movie Suggest App
Output 2 Screen Movie Suggest App
结论
就这样，伙计们！我们构建了一个令人惊叹的完美的 Tkinter GUI 应用程序。希望你明白一切。
自己也试试吧！编码快乐！
Python 中的随机密码生成器| GUI Tkinter
原文：https://www.askpython.com/python/examples/random-password-generator
在本文中，我们将学习如何用 Python 创建一个随机密码生成器。使用强密码是必要的，也是值得推荐的。根据网络安全专家的说法，密码必须是字母、数字和符号的组合，还要确保该组合不是一个可以使用社会工程方法轻易猜到的合理单词或组合。
另一方面，长度至少为 8 个字符的随机密码即使在应用了高级安全破坏方法(如暴力攻击)之后，也很难被破坏或破解，或者可能需要很长时间来破坏它。
随机密码生成器代码–GUI
生成建议长度的强随机密码是一项困难的任务，显然不会比记住它更困难。但是在这里，我们将编写一个 python 脚本来生成一个随机密码。
1.安装并导入所需的模块
我们从使用 pip 包管理器安装所需的库开始。在命令行或终端中输入以下命令来安装模块。
我们需要安装 Tkinter，使我们的密码生成器 GUI(图形用户界面)基于 pyperclip 库注入复制到剪贴板功能。
pip install tkinter
pip install pyperclip
pip install random
在从终端安装了所需的库之后，我们现在转移到 Python 文件来编码。我们首先将库导入为:
其中 random 用于从给定列表中生成随机字符，而字符串用于获取字符/文本。
import random, string
from tkinter import *
import pyperclip
2.初始化 Tkinter 窗口
下一步，我们使用 Tkinter 模块初始化我们的 GUI 窗口。
#Initialize Window
root =Tk()
root.geometry("400x400") #size of the window by default
#title of our window
root.title("Random Password Generator")
3.给元素编码
我们现在开始按照 GUI 对元素进行编码，包括标题、文本、标签、按钮等。
为了选择密码的长度，
- 我们使用 Label 方法来生成一个文本标签，以定义我们想要的密码长度的输入字段的用途。
- spinbox 方法用于根据值选择器获取输入，范围从 4 到 32，您可以根据需要更改，这定义了密码的最小和最大长度。
#get length of password
pass_head = Label(root, text = 'Password Length', font = 'arial 12 bold').pack(pady=10) #to generate label heading
pass_len = IntVar() #integer variable to store the input of length of the password wanted
length = Spinbox(root, from_ = 4, to_ = 32 , textvariable = pass_len , width = 24, font='arial 16').pack()
我们编写了一个生成密码按钮，点击它可以生成一个随机密码:
- 我们给我们的按钮一些样式，以及名称-生成密码。我们使用命令，它显示了单击(按键)按钮时将运行哪个函数(这里是 randPassGen 函数)。
Button(root, text = "Generate Password" , command = randPassGen, font="Arial 10", bg='lightblue', fg='black', activebackground="teal", padx=5, pady=5 ).pack(pady= 20)
在这一步，我们的窗口显示以下输出:
Password Length
添加 so 之后，我们现在在代码中添加输出元素。
- 我们再次添加了一个标签来显示正在显示的内容，我们添加了一个带有某种样式的“随机生成的密码”的标签。
- 同样，我们添加了一个条目小部件来创建一个输入字段，这是为了显示我们随机生成的密码
- textvariable 小部件用于显示 output_pass 变量的值，该变量保存随机生成的密码。
pass_label = Label(root, text = 'Random Generated Password', font = 'arial 12 bold').pack(pady="30 10")
Entry(root , textvariable = output_pass, width = 24, font='arial 16').pack()
- 我们现在在代码中添加 Add to Clipboard 按钮来显示，它的命令小部件显示 copyPass 函数将在单击该按钮时运行。
Button(root, text = 'Copy to Clipboard', command = copyPass, font="Arial 10", bg='lightblue', fg='black', activebackground="teal", padx=5, pady=5 ).pack(pady= 20)
在执行时，我们的 Tkinter 输出窗口如下所示:
Copy To Clipboard
4.随机密码功能
完成了前端(GUI)部分后，我们现在转到代码的后端，在这里我们向按钮添加功能
- 我们编写了这段代码中最重要的函数，用于随机生成密码，我们在代码中这样做:
#Random Password generator
output_pass = StringVar()
all_combi = [string.punctuation, string.ascii_uppercase, string.digits, string.ascii_lowercase] #list of all possible characters
def randPassGen():
password = "" # to store password
for y in range(pass_len.get()):
char_type = random.choice(all_combi) #to randomize the occurance of alphabet, digit or symbol
password = password + random.choice(char_type) #to generate random characters as per the input length from the occurance list
output_pass.set(password)
5.复制密码功能
最后一步，我们在代码中添加复制密码函数，如下所示:
- 我们使用 pyperclip 库的 copy 方法来保存复制到我们系统中的密码。我们使用 output_pass 变量的 get 方法获取密码。
#Copy to clipboard function
def copyPass():
pyperclip.copy(output_pass.get())
尽管在本教程的后面讨论过，随机密码生成器和复制到剪贴板功能并没有包含在代码的末尾，因为在这种情况下，如果没有找到，程序将抛出一个错误。
我们在窗口初始化之后(在步骤 2 的代码之后)声明我们的函数。如下面的最终代码所示:
GUI 随机密码生成器的完整 Python 代码
import random, string
from tkinter import *
import pyperclip
#Initialize Window
root =Tk()
root.geometry("400x400") #size of the window by default
#title of our window
root.title("Random Password Generator")
# ------------------- Random Password generator function
output_pass = StringVar()
all_combi = [string.punctuation, string.ascii_uppercase, string.digits, string.ascii_lowercase] #list of all possible characters
def randPassGen():
password = "" # to store password
for y in range(pass_len.get()):
char_type = random.choice(all_combi) #to randomize the occurance of alphabet, digit or symbol
password = password + random.choice(char_type)
output_pass.set(password)
# ----------- Copy to clipboard function
def copyPass():
pyperclip.copy(output_pass.get())
#-----------------------Front-end Designing (GUI)
pass_head = Label(root, text = 'Password Length', font = 'arial 12 bold').pack(pady=10) #to generate label heading
pass_len = IntVar() #integer variable to store the input of length of the password wanted
length = Spinbox(root, from_ = 4, to_ = 32 , textvariable = pass_len , width = 24, font='arial 16').pack()
#Generate password button
Button(root, command = randPassGen, text = "Generate Password", font="Arial 10", bg='lightblue', fg='black', activebackground="teal", padx=5, pady=5 ).pack(pady= 20)
pass_label = Label(root, text = 'Random Generated Password', font = 'arial 12 bold').pack(pady="30 10")
Entry(root , textvariable = output_pass, width = 24, font='arial 16').pack()
#Copy to clipboard button
Button(root, text = 'Copy to Clipboard', command = copyPass, font="Arial 10", bg='lightblue', fg='black', activebackground="teal", padx=5, pady=5 ).pack(pady= 20)
root.mainloop() #to bundle pack the code for tkinter
基于 GUI 的随机密码生成器的输出如下:
https://www.askpython.com/wp-content/uploads/2022/01/Ourput-to-random-password-generator.mp4
结论
教程到此为止。希望你已经很好地学习了如何用 Python 制作一个随机密码生成器，并且通过编写一个基于接口的脚本也有所提高。
在 NumPy 中执行随机采样的 4 种方法
原文：https://www.askpython.com/python/random-sampling-in-numpy
读者朋友们，你们好！在本文中，我们将关注在 Python NumPy 中执行随机采样的 4 种简单方法。
所以，让我们开始吧！🙂
概括地说，随机抽样实际上是从已定义的数据类型中选择随机值，并将其呈现以备将来使用。
在本主题的课程中，我们将了解以下功能
- NumPy random_sample()方法
- NumPy ranf()方法
- NumPy random_integers()方法
- NumPy randint()方法
1。用于随机抽样的 NumPy random_sample()方法
使用 random_sample()方法，我们可以对数据值进行采样，并轻松选择随机数据。它仅选择[0.0–1.0]之间的随机样本。我们可以基于随机值构建单个样本以及整个数组。
看看下面的语法！
random.random_sample()
举例:
在下面的例子中，首先，我们执行了随机采样并生成了一个随机值。此外，我们通过将 size 作为参数传递给 random_sample()函数，创建了一个包含随机值的二维数组。
请注意，随机值的范围仅为 0.0 到 1.0。另外，random_sample()函数生成浮点类型的随机值。
import numpy as np
ran_val = np.random.random_sample()
print ("Random value : ", ran_val)
ran_arr = np.random.random_sample(size =(2, 4))
print ("Array filled with random float values: ", ran_arr)
输出:
Random value : 0.3733413809567606
Array filled with random float values: [[0.45421908 0.34993556 0.79641287 0.56985183]
[0.88683577 0.91995939 0.16168328 0.35923753]]
2。random _ integers()函数
使用 random_integers()函数，我们可以生成随机值，甚至是整型随机值的多维数组。它会生成整型的随机值。此外，它给了我们选择整数值范围的自由，从中可以选择随机数。
语法:
random_integers(low, high, size)
- low :待选随机值的最低刻度/限值。随机值的值不会低于所提到的低值。
- 高:待选随机值的最高刻度/限值。随机值的值不会超过所提到的高值。
- size :要形成的数组的行数和列数。
举例:
在本例中，我们创建了一个一维随机值数组，其值仅在范围 5-10 之间。此外，我们使用相同的概念建立了一个多维数组。
import numpy as np
ran_val = np.random.random_integers(low = 5, high =10 , size = 3)
print ("Random value : ", ran_val)
ran_arr = np.random.random_integers(low = 5, high =10 , size = (2,4))
print ("Array filled with random float values: ", ran_arr)
输出:
Random value : [10 5 9]
Array filled with random float values: [[ 8 8 9 6]
[ 6 10 8 10]]
3.randint()函数
randint()函数 的工作方式与 random_integers()函数类似。它创建一个数组，其中包含指定整数范围内的随机值。
举例:
import numpy as np
ran_val = np.random.randint(low = 5, high =10 , size = 3)
print ("Random value : ", ran_val)
输出:
Random value : [5 8 9]
4.ranf()函数
同样， ranf()函数在功能上类似于 random_sample()方法。它只生成 0.0 到 1.0 之间的 float 类型的随机数。
举例:
import numpy as np
ran_val = np.random.ranf()
print ("Random value : ", ran_val)
输出:
Random value : 0.8328458165202546
结论
如果你遇到任何问题，欢迎在下面评论。更多与 Python 编程相关的帖子，敬请关注我们！在那之前，学习愉快！🙂
如何用 Python 读取 JSON 文件
原文：https://www.askpython.com/python/examples/read-a-json-file-in-python
在本文中，我们将看看如何用 Python 读取 JSON 文件。
通常，您可能希望轻松地从相关的 json 文件中读取和解析 json 数据。让我们找出一些方法，通过这些方法我们可以很容易地读取和提取出这些数据！
方法 1:使用 json.load()读取 Python 中的 json 文件
json 模块是 Python3 中的内置模块，使用json.load()为我们提供了 json 文件处理能力。
使用这种方法，我们可以在直接读取 Python 中的 JSON 文件后构造一个 Python 对象。
假设sample.json是一个 JSON 文件，内容如下:
{
"name": "AskPython",
"type": "website",
"language": "Python"
}
我们可以使用下面的程序将 json 对象加载到 Python 对象中。我们现在可以使用字典的 {key: value} 对映射轻松访问它！
import json
with open("sample.json", "r") as rf:
decoded_data = json.load(rf)
print(decoded_data)
# Check is the json object was loaded correctly
try:
print(decoded_data["name"])
except KeyError:
print("Oops! JSON Data not loaded correctly using json.loads()")
输出
{'name': 'AskPython', 'type': 'website', 'language': 'Python'}
AskPython
事实上，我们能够从文件中正确加载 JSON 对象！
方法 2:对大型 json 文件使用 ijson
如果您的 JSON 文件足够大，以至于将全部内容放入内存的成本很高，那么更好的方法是使用ijson将文件内容转换成流。
流是对象的集合(就像 JSON 对象一样),只有在需要时才会加载到内存中。这意味着我们的数据加载器“懒惰地”加载数据，也就是说，只在需要的时候加载。
在处理大文件时，这可以降低内存需求。流的内容存储在一个临时缓冲区中，这使得处理千兆字节的 JSON 文件成为可能！
要安装ijson，请使用 pip！
pip install ijson
现在，为了进行实验，我们将使用一个稍微小一点的 JSON 文件，因为下载千兆字节的数据非常耗时！
我将在这个链接上使用 COVID timeseries JSON 文件。下载该文件，并将其重命名为covid_timeseries.json。文件大小必须约为 2 MB。
import ijson
for prefix, type_of_object, value in ijson.parse(open("covid_timeseries.json")):
print(prefix, type_of_object, value)
样本输出(几行)
Yemen.item.date string 2020-4-13
Yemen.item map_key confirmed
Yemen.item.confirmed number 1
Yemen.item map_key deaths
Yemen.item.deaths number 0
Yemen.item map_key recovered
Yemen.item.recovered number 0
Yemen.item end_map None
Yemen.item start_map None
Yemen.item map_key date
Yemen.item.date string 2020-4-14
Yemen.item map_key confirmed
Yemen.item.confirmed number 1
Yemen.item map_key deaths
Yemen.item.deaths number 0
Yemen.item map_key recovered
Yemen.item.recovered number 0
Yemen.item end_map None
Yemen end_array None
这将打印巨大的 JSON 文件的内容，但是您可以保留一个计数器变量以避免打印整个文件。
虽然ijson可能很慢，但它似乎在较低的内存范围内运行。如果您正在处理大文件，可以尝试此模块。
结论
在本文中，我们学习了如何用 Python 读取 JSON 文件。我们还简要介绍了如何使用ijson处理大量数据。
参考
- 关于处理大型 json 文件的 StackOverflow 问题
熊猫 read_csv()带有自定义分隔符
原文：https://www.askpython.com/python-modules/pandas/read-csv-with-delimiters
在本文中，我们将了解如何使用带有自定义分隔符的 read_csv()函数。首先，让我们先了解一下基础知识。
如果你已经知道了基本知识，请跳到使用自定义分隔符与熊猫 read_csv()
熊猫是什么？
今天有许多类型的数据结构在使用，有些我们可能知道，有些可能不知道。Pandas 是一个非常流行的 Python 库，它主要允许我们创建两种类型的数据结构:
- 数据帧
- 系列
数据帧是行和列的矩阵，以类似表格的格式存储数据。数据帧中的项目数量需要相等地量化，即每一列必须具有相同数量的项目。
Series 是一维的数据结构，而且就像一个数组，可以存储不同数据类型的项目。它主要由构造者熊猫创造。
什么是 CSV 文件？
CSV 代表逗号分隔值。
例如，假设一个文件存在，其中填充了多个随机值，但当一起查看时，它没有任何意义。但是如果我们用逗号分隔所有的值，那么它就变成了一个学校记录，其中充满了学生的数据库，包括他们的姓名、编号、地址等等。
什么是分隔符？
分隔符是一种特殊字符或标点符号，用于分隔或显示两个单词或数字之间的差异。大多数情况下，逗号用作分隔符，但也可以使用其他字符。
正如我们在上面的例子中所观察到的，一旦使用逗号将一组没有特定含义的数据分隔开，这些数据就开始变得有意义，同样，在. csv 文本文件中，当逗号填充在数据之间时，它采用具有行和列的表格的形式。
所以，把一个有随机值的文件变成一个有意义的表的过程叫做定界。
定界通常由逗号完成，但在某些情况下，也可以用运算符、标点符号以及特殊字符来完成。
现在我们来了解一下什么是 read_csv()函数，它是如何工作的。
使用 Pandas read_csv()方法
这个熊猫函数用于读取(。csv)文件。但是您也可以识别逗号以外的分隔符。这个特性使得 read_csv 成为一个非常方便的工具，因为有了它，reading。带有任何分隔符的 csv 文件可以变得非常容易。
让我们看一个工作代码来理解如何调用 read_csv 函数来读取. csv 文件。我们已经准备好了。包含许多汽车公司的汽车数据的 csv 文件，命名为“Car_sales.csv”。
示例代码
import pandas as pd
CarData = pd.read_csv('Car_sales.csv')
在上面的代码中，我们初始化了一个名为“CarData”的变量，然后用它来存储“Car_sales.csv”中的所有值。中的值。csv 文件是逗号分隔的，所以我们不需要在编译器的 read_csv 参数中指定更多的迭代。
read_csv 函数允许从一个很大的参数列表中进行选择，然后在任何需要的时候或者临时使用它。只有一个参数是必须使用的，那就是指定文件名或文件路径。(注意:在重新创建上述代码时，需要提到文件路径，因为文件名只有在 Python。txt 文件和。csv 文件存在于同一目录中)。
对 read_csv()使用自定义分隔符
现在让我们学习如何在 read_csv()函数中使用自定义分隔符。我们将向您展示如何使用不同的常用分隔符来读取 CSV 文件。您可以根据所使用的文件类型，用任何自定义分隔符替换这些分隔符。
1.分号分隔符
正如我们所知，有许多特殊字符可以用作分隔符，read_csv 提供了一个参数' sep ',它指示编译器将逗号以外的字符作为分隔符。让我们了解如何使用它。
假设我们有一个包含内容的数据库，文件名为“Book1.csv”:
Name;Age;Grade
Jay;18;12
Shiv;18;12
Abin;16;10
Shweta;14;9
Shreya;10;5
现在，如果我们按照常规标准，那么使用:
import pandas as pd
df = pd.read_csv('Book1.csv')
print(df)
将产生一个输出:
但是，如果我们将' sep '添加到 read_csv 语法中，最终结果会发生变化:
代码:
import pandas as pd
df = pd.read_csv('Book1.csv', sep=';')
print(df)
输出:
2.竖线分隔符
如果文件用竖线而不是分号或逗号分隔，则可以使用以下语法读取该文件:
import pandas as pd
df = pd.read_csv('Book1.csv', sep='|')
print(df)
3.冒号分隔符
同样，如果文件是用冒号分隔的，那么我们将使用以下语法:
import pandas as pd
df = pd.read_csv('Book1.csv', sep=':')
print(df)
结论
定界是一个非常重要的功能。csv 文件，还有很多。csv 文件需要定界。本文解释了所有可能的定界方法，以使你掌握这些概念。
我们触及了最基本的内容，从解释熊猫和 CSV 开始，然后我们继续讨论划界以及如何划界。我们还学习了不同种类的分隔符，如分号、逗号、竖线和冒号。
我希望这篇文章能帮助你轻松地学习这些概念。
如何阅读？Python 中的数据文件？
原文：https://www.askpython.com/python/examples/read-data-files-in-python
在处理训练模型的数据输入和数据收集时，我们遇到了。数据文件。
这是一些软件用来存储数据的文件扩展名，其中一个例子是专门从事统计分析和数据挖掘的分析工作室。
与一起工作。data 文件扩展名非常简单，或多或少地识别数据的排序方式，然后使用 Python 命令相应地访问文件。
什么是. data 文件？
。数据文件是作为存储数据的一种手段而开发的。
很多时候，这种格式的数据要么是以逗号分隔值格式放置，要么是以制表符分隔值格式放置。
除此之外，该文件还可以是文本文件格式或二进制格式。在这种情况下，我们将需要以不同的方法访问它。
我们将和一起工作。csv 文件，但是让我们首先确定文件的内容是文本格式还是二进制格式。
识别里面的数据。数据文件
。数据文件有两种不同的形式，文件本身要么是文本形式，要么是二进制形式。
为了找出它属于哪一个，我们需要加载它并亲自测试。
我们开始吧！
1.测试:文本文件
。数据文件可能主要以文本文件的形式存在，在 Python 中访问文件非常简单。
作为 Python 中包含的一个特性，我们不需要导入任何模块来处理文件。
也就是说，在 Python 中打开、读取和写入文件的方式如下:
# reading from the file
file = open("biscuits.data", "r")
file.read()
file.close()
# writing to the file
file = open("biscuits.data", "w")
file.write("Chocolate Chip")
file.close()
2.测试:二进制文件
的。数据文件也可以是二进制文件的形式。这意味着我们访问文件的方式也需要改变。
我们将使用二进制模式读写文件，在这种情况下，模式是 rb ，或者读取二进制。
# reading from the file
file = open("biscuits.data", "rb")
file.read()
file.close()
# writing to the file
file = open("biscuits.data", "wb")
file.write("Oreos")
file.close()
在 Python 中，文件操作相对容易理解，如果您希望了解不同的文件访问模式和访问方法，这是值得研究的。
这两种方法中的任何一种都应该有效，并且应该为您提供一种方法来检索关于存储在中的内容的信息。数据文件。
现在我们知道了文件的格式，我们可以使用 pandas 为 csv 文件创建一个数据帧。
3.用熊猫来阅读。数据文件
在检查提供的内容类型后，从这些文件中提取信息的一个简单方法是简单地使用 Pandas 提供的 read_csv() 函数。
import pandas as pd
# reading csv files
data = pd.read_csv('file.data', sep=",")
print(data)
# reading tsv files
data = pd.read_csv('otherfile.data', sep="\t")
print(data)
该方法还自动将数据转换成数据帧。
下面使用的是一个样本 csv 文件，它被重新格式化为一个。数据文件，并使用上面给出的相同代码进行访问。
Series reference Description Period Previously published Revised
0 PPIQ.SQU900000 PPI output index - All industries 2020.06 1183 1184
1 PPIQ.SQU900001 PPI output index - All industries excl OOD 2020.06 1180 1181
2 PPIQ.SQUC76745 PPI published output commodity - Transport sup... 2020.06 1400 1603
3 PPIQ.SQUCC3100 PPI output index level 3 - Wood product manufa... 2020.06 1169 1170
4 PPIQ.SQUCC3110 PPI output index level 4 - Wood product manufa... 2020.06 1169 1170
.. ... ... ... ... ...
73 PPIQ.SQNMN2100 PPI input index level 3 - Administrative and s... 2020.06 1194 1195
74 PPIQ.SQNRS211X PPI input index level 4 - Repair & maintenance 2020.06 1126 1127
75 FPIQ.SEC14 Farm expenses price index - Dairy farms - Freight 2020.06 1102 1120
76 FPIQ.SEC99 Farm expenses price index - Dairy farms - All ... 2020.06 1067 1068
77 FPIQ.SEH14 Farm expenses price index - All farms - Freight 2020.06 1102 1110
[78 rows x 5 columns]
如你所见，它确实给了我们一个数据帧作为输出。
存储数据的其他格式有哪些？
有时候，存储数据的默认方法并不能解决问题。那么，使用文件存储的替代方法是什么呢？
1.JSON 文件
作为一种存储信息的方法， JSON 是一种非常好的数据结构，Python 对 JSON 模块的巨大支持让集成看起来完美无瑕。
然而，为了在 Python 中使用它，您需要在脚本中导入json模块。
import json
现在，在构建了一个 JSON 兼容结构之后，存储它的方法是一个简单的带有json dumps的文件操作。
# dumping the structure in the form of a JSON object in the file.
with open("file.json", "w") as f:
json.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}], f)
# you can also sort the keys, and pretty print the input using this module
with open("file.json", "w") as f:
json.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}], f, indent=4, sort_keys=True)
注意，我们使用变量 f 将数据转储到文件中。
从一个 JSON 文件中检索信息的等价函数叫做load。
with open('file.json') as f:
data = json.load(f)
这为我们提供了文件中的 JSON 对象的结构和信息。
2.泡菜
通常，当您存储信息时，信息以原始字符串格式存储，导致对象丢失其属性，我们需要通过 Python 从字符串重建对象。
pickle 模块是用来解决这个问题的，它是为序列化和反序列化 Python 对象结构而设计的，因此它可以存储在一个文件中。
这意味着您可以通过 pickle 存储一个列表，当下次 pickle 模块加载它时，您不会丢失 list 对象的任何属性。
为了使用它，我们需要导入pickle模块，没有必要安装它，因为它是标准 python 库的一部分。
import pickle
让我们创建一个字典来处理到目前为止所有的文件操作。
apple = {"name": "Apple", "price": 40}
banana = {"name": "Banana", "price": 60}
orange = {"name": "Orange", "price": 30}
fruitShop = {}
fruitShop["apple"] = apple
fruitShop["banana"] = banana
fruitShop["orange"] = orange
使用 pickle 模块就像使用 JSON 一样简单。
file = open('fruitPickles', 'ab')
# the 'ab' mode allows for us to append to the file
# in a binary format
# the dump method appends to the file
# in a secure serialized format.
pickle.dump(fruitShop, file)
file.close()
file = open('fruitPickles', 'rb')
# now, we can read from the file through the loads function.
fruitShop = pickle.load(file)
file.close()
结论
你现在知道什么了。数据文件是什么，以及如何使用它们。除此之外，您还知道可以测试的其他选项，以便存储和检索数据。
查看我们的其他文章，获得关于这些模块的深入教程——文件处理、泡菜、和 JSON 。
参考
- StackOverflow 对。数据文件扩展名
- 公文处理文档
- 官方 JSON 模块文档
在 Python 中以字符串形式读取文件
原文：https://www.askpython.com/python/examples/read-file-as-string-in-python
在本文中，我们将尝试理解如何使用 Python 中不同的内置函数和方法将文本文件作为不同格式的字符串读取。
使用 read()方法
我们可以使用 read()方法读取存储在文本文件中的数据。此方法将文本文件中的数据转换为字符串格式。但是首先，我们需要使用 open()函数打开文件。永远记住添加 replace()函数和 read()函数，用指定的字符替换新行字符，这样返回的数据看起来更均匀，可读性更好。
#without replace()
with open("AskPython.txt") as file:
data = f.read()
print(data)
输出:
AskPython Website is very useful
Python Programming language
How to read files as strings in python?
#using replace() everything is returned in one line.
with open("AskPython.txt") as file:
data = file.read().replace('\n',' ')
print(data)
输出:
AskPython 网站很有用。Python 编程语言。如何在 python 中将文件读取为字符串？
使用 pathlib 模块
pathlib 是 python 3.2 或更高版本中可用的 Python 模块。它使得文件和文件系统的整体工作更加有效。e 不需要使用 os 和 os.path 函数，有了 pathlib，一切都可以通过操作符、属性访问和方法调用轻松完成。我们使用 read.text()函数从文件中读取字符串格式的数据。如果需要，我们还可以添加 replace()方法和 read.text()，就像前面的示例中解释的那样。
from pathlib import Path
data = Path("AskPython.txt").read_text()
print(data)
输出:
AskPython Website is very useful
Python Programming language
How to read files as strings in python?
结论
在工作和开发不同的项目时，很多时候文件都要包含在编程中。为了使处理文件更容易，我们可以通过将数据提取为字符串格式来读取文件中的数据。本文讨论了在 Python 中将文件作为字符串读取的不同方法。
另外，了解如何通过 点击此处解决 Python filenotfounderror 错误。
使用 OpenCV 读取 Python 中的图像
原文：https://www.askpython.com/python-modules/read-images-in-python-opencv
Python 使得导入图像和摆弄图像变得很容易。了解如何在 Python 中读取图像将使您能够进行图像处理，并在图像数据上训练机器学习模型。
什么是图像处理？
图像处理涉及对图像执行一些操作，以获得增强的图像或从中提取一些有用的信息。
图像处理领域即将到来并迅速发展。它支持图像中的对象检测，其应用范围从自动驾驶汽车到医学领域的肿瘤检测。
什么是图像？
这是一个荒谬的问题。当然，你知道图像是什么。更好的问题应该是“什么是机器的图像”。
你看到的图像实际上是计算机的 2D 矩阵。
数字图像存储为像素的组合。每个像素还包含不同数量的通道。如果是灰度图像，它只有一个像素，而彩色图像包含三个通道:红色、绿色和蓝色。
每个像素的每个通道都有一个在 0 到 255 之间的值。通过不同比例的红、绿、蓝组合，我们可以创造出任何颜色。
用 OpenCV 读取 Python 中的图像
在本教程中，我们将学习如何使用 OpenCV 库读取 Python 中的图像。
OpenCV 是一个开源的计算机视觉和机器学习软件库，其编程功能主要针对实时计算机视觉。
1.安装 OpenCV 库
您可以使用 pip 命令安装软件包，如下所示:
pip install opencv-python
Install OpenCV
要在 Python 项目中使用 OpenCV，您需要导入它。要导入它，请使用下面一行:
import cv2
2.编程读取图像
要使用 OpenCV 读取图像，请使用下面的代码行。
img = cv2.imread('image_path')
现在变量 img 将是像素值的矩阵。我们可以打印出来，看看 RGB 值。
我们在此示例中使用的图像是:
Sample Image
要打印矩阵，请使用:
print(img)
3.使用 OpenCV 在 Python 中读取图像的完整实现
完整的代码如下:
import cv2
#read
img = cv2.imread('sample_image.jpg')
#show
print(img)
输出
使用 Python OpenCV 显示图像
要使用 OpenCV 显示图像，请使用以下代码行:
ccv2.imshow('image',img)
cv2.waitKey(0)
cv2.destroyAllWindows()
cv2.waitKey() 是一个键盘绑定函数。它的参数是以毫秒为单位的时间。
该函数为任何键盘事件等待指定的毫秒数。如果您在这段时间内按下任何键，程序将继续运行。如果传递 0，它将无限期等待击键。
Python 实现
显示图像的完整代码是:
import cv2
#read
img = cv2.imread('sample_image.jpg')
#show
cv2.imshow('image',img)
cv2.waitKey(0)
cv2.destroyAllWindows()
使用 Python OpenCV 处理图像
OpenCV 中有很多允许你操作图像的功能。我们将看看如何把图像变成灰度。
灰度图像意味着每个像素只有一个通道，其值在 0 到 255 之间。
做到这一点的代码是:
gray_image = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
实现 Python 代码
将图像转换为灰度的完整代码是:
#read
img = cv2.imread('sample_image.jpg')
#to grayscale
gray_image = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
#show
print(gray_image)
cv2.imshow('image',gray_image)
cv2.waitKey(0)
cv2.destroyAllWindows()
你可以看到这个矩阵的维数与彩色图像的维数不同。
保存处理过的图像文件
要在操作后保存图像，请使用以下代码行:
cv2.imwrite('sample_grayscale.jpg',gray_image)
这里，第一个参数是您要给文件起的名字，第二个参数是包含您要保存的图像的变量。我们正在保存上面创建的灰度图像。
完整的 Python 代码，用于转换彩色图像灰度
保存图像的完整代码是:
import cv2
#read
img = cv2.imread('sample_image.jpg')
#to grayscale
gray_image = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
#show
print(gray_image)
#save
cv2.imwrite('sample_grayscale.jpg',gray_image)
This is what the saved image looks like
结论
在本教程中，我们介绍了如何使用 OpenCV 在 Python 中读取和操作图像。要进一步了解 OpenCV，请阅读它的文档。
熊猫里的泡菜档案怎么看？
原文：https://www.askpython.com/python-modules/pandas/read-pickle-files-in-pandas
我们通常以 CSV、excel 或文本文件的形式使用或存储数据。但是我们也可以将数据保存为 Pickle 文件。Pickles 是在磁盘上表示 Python 对象的一种方式。它们以序列化格式存储对象，这种格式可用于以后重建对象。Pickles 对于存储需要快速方便地访问的数据很有用。在本文中，我们将学习如何从 pickle 文件中存储和读取 Pandas 中的数据。让我们开始吧！
使用熊猫读取泡菜文件
Pandas 提供了读写 pickle 文件的方法。读取 pickle 文件最基本的方法是使用 read_pickle()函数。该函数将 pickle 文件的名称作为参数，并返回一个 pandas 数据帧。
可以使用 read_pickle()函数在 Python 中读取 pickle 文件。
函数的语法:
pd.read_pickle(path, compression='infer')
类似于 read_csv()函数，这个函数也将返回一个 Pandas DataFrame 作为输出。
例如:
df = pd.read_pickle('data.pkl')
现在让我们看看如何在 python 中将数据保存到 pickle 文件中。我们将从创建数据帧开始。
import pandas as pd
data = {
'Name': ['Microsoft Corporation', 'Google, LLC', 'Tesla, Inc.',\
'Apple Inc.', 'Netflix, Inc.'],
'Icon': ['MSFT', 'GOOG', 'TSLA', 'AAPL', 'NFLX'],
'Field': ['Tech', 'Tech', 'Automotive', 'Tech', 'Entertainment'],
'Market Shares': [100, 50, 160, 300, 80]
}
df = pd.DataFrame(data)
# print dataframe
print(df)
输出
Name Icon Field Market Shares
0 Microsoft Corporation MSFT Tech 100
1 Google, LLC GOOG Tech 50
2 Tesla, Inc. TSLA Automotive 160
3 Apple Inc. AAPL Tech 300
4 Netflix, Inc. NFLX Entertainment 80
现在让我们将数据帧保存到 pickle 文件中。
df.to_pickle('company info.pkl')
现在让我们来读泡菜文件。
df2 = pd.read_pickle('company info.pkl')
# print the dataframe
print(df2)
输出
Name Icon Field Market Shares
0 Microsoft Corporation MSFT Tech 100
1 Google, LLC GOOG Tech 50
2 Tesla, Inc. TSLA Automotive 150
3 Apple Inc. AAPL Tech 200
4 Netflix, Inc. NFLX Entertainment 80
结论
总之，我们学习了如何在 Pandas 中使用 read_pickle()函数读取 pickle 文件。还可以使用 read_pickle()函数读取序列化为 pickle 对象的数据帧。Pickle 文件非常适合存储数据，但是如果您使用 pickle 文件中的数据，请确保它来自可靠的来源。
使用熊猫阅读文本文件——简要参考
原文：https://www.askpython.com/python-modules/pandas/read-text-file-pandas
这篇文章是一个简单的教程，关于我们如何使用 Python 中的 熊猫库读取文本文件。如今，文本文件有助于存储大量原始信息。它们是获取特定信息的最简单方式之一。他们可以持有以下物品:
- 密码
- Raw info
- 链接
- 信息和更多信息
因此，为了管理它，有一些工具和技术，通过它们我们可以很容易地提取我们需要的东西。其中之一是通过计算机编程。让我们更详细地看看它是如何工作的。
使用 Python Pandas 读取文本文件的步骤
计算机中的文件可以存储各种数量的文件和扩展名。一般来说，文件是用来存储任何信息的。所以，没有具体的定义。但是，它们的扩展说明了很多。每个扩展都定义了存储在其中的不同数据位。
例如，像 python 这样的特定编程语言的文件具有. py 的扩展名。扩展名只是为了表明它是什么类型的文件以及它代表什么数据。
在 windows 中创建 sample.txt 文件
在 windows 中创建文本文件的过程非常简单。请遵循以下步骤:
- 转到 windows 搜索栏，键入记事本。点击那个。
- 它会打开一个空白页。在那里我们可以放入任何我们想要的文本或信息，并随时对其进行修改。
- 完成工作后，按下 Ctrl+S 或转到左上角的文件选项，点击保存将文件保存到您想要的位置。
阅读熊猫的文本文件
Pandas 是 Python 中的一个库，包含了一些必要的数据。主要在数据科学和机器学习领域使用。这是一个开源项目，就像 Python 一样，任何人都可以参与开发。
前往此 链接 了解更多信息。以下是它的用途:
- 数据分析
- 数据预处理
- 数据清理
- 数据争论
- 从嵌入外部链接的文件中访问信息
- 从 JSON、SQL、Excel 文件格式中提取数据。
纯内置的 Python 和其他支持库为管理大量数据提供了最佳工作空间
Python Pandas 中的文本文件方法
在数据科学中，我们获取的信息量是巨大的，所以它们都包含在一个称为数据集的文件中。这个数据集可能有数千行和数千列，包含各种输入。熊猫为处理我们的数据提供了更多的功能和方法。
- read_excel() : 读取一个 excel 文件
- read_csv() : 读取逗号分隔值文件
- info() : 显示所有列的信息
- isna() : 检查缺少的值
- sum() : 各种数据类型的任意列的值的总和
- dropna() : 删除一列
- head() : 返回数据集的前 5 行。但是，可以根据我们给大括号里面的数字返回。
这些是主要功能。要提前了解更多关于该库的信息，请访问此链接获取入门指南。
安装熊猫
Python PIP 命令即‘Python 的包安装器’使得在任何系统中安装 Pandas 变得容易。但是，这有一些限制。但是首先，在命令提示符下输入
python --version
确保您拥有 Python 3.6 或更高版本。
下一个类型 pip 安装熊猫如下所示:
pandas installation
使用 Anaconda 安装熊猫
注意:为此你需要在你的系统上安装 Anaconda 。
Pandas 预装了 Anaconda，但是作为参考，我们应该知道如何通过 conda 提示符添加新的库。
因此，打开 Anaconda 提示符并输入以下命令
conda install pandas
因此，我们确认该库已经存在于 conda 环境中。
进口熊猫
所以，在安装并获得一些粗略的信息后，是时候更熟悉它了。首先要做的是导入库并检查它是否正确安装。
import pandas
如果安装后没有出现错误，那么就可以使用了。
在熊猫中读取文件
该教程是非常简单的关于读取一个文件。我们将在此阅读三种类型的文件。
- 彗形分离值文件
- Excel 文件
- 文本文件
读取每个文件都有特殊的函数。如前所述，它有 read_excel() 和 read_csv() 。环境—《朱庇特笔记本》
用 Python 读取 excel 文件:
使用的样本文件-" train . xlsx "
import pandas as pd
data = pd.read_excel('train.xlsx')
data.head()
输出:
读取 Python 中的文本文件:
使用的样本文件-" titanic . txt "
import pandas as pd
data_1 = read_csv('titanic.txt')
data_1.head()
输出:
结论
在这里，我们结束这个话题。所以，通过这种方式，我们可以通过熊猫读取一些文件，让我们的数据科学和机器学习之旅更加顺畅。我认为这是开始使用 pandas 并在系统中配置它的最相关的方式。
Python 中的红黑树——示例实现
原文：https://www.askpython.com/python/examples/red-black-tree-in-python
在这篇文章中，让我们试着去了解红黑树。红黑树是一种自平衡二叉查找树，由鲁道夫·拜尔于 1972 年发明，他称之为“对称二进制 B 树”。
尽管红黑树很复杂，但它的操作在最坏的情况下也有很好的运行时间，可以有效地用于搜索、插入和删除。这些都可以在 O(logN)时间内完成，其中 N 是树中节点的数量。
实际上，红黑树是一个二叉查找树，可以智能地插入和移除，以保持树的合理平衡。关于红黑树需要特别注意的一点是，在这种树中，没有数据存储在叶节点上。
红黑树的性质
红黑树是一个二叉查找树，其中每个节点的颜色不是红色就是黑色。除了二叉查找树的其他限制外，红黑树还有以下附加要求:
- 节点的颜色不是红色就是黑色。
- 根节点的颜色总是黑色。
- 所有叶节点都是黑色的。
- 每个红色节点都有两个黑色的子节点。
- 从一个给定节点到它的任何一个叶节点的每一条简单路径都有相同数量的黑色
下图是一棵红黑树的例子
EXAMPLE
这些约束强化了红黑树的一个关键属性。
从根节点到任何叶节点的最长路径不超过从根到该树中任何其它叶的最短路径的两倍。
这就产生了一个大致 平衡的树 。由于诸如插入、删除和搜索之类的操作需要与树的高度成比例的最坏情况时间，这种理论上的高度上限允许红黑树在最坏情况下是有效的，这与普通的二分搜索法树不同。
为了理解这些属性的重要性，注意到根据属性 4，没有路径可以在一行中有两个红色节点就足够了。最短的可能路径将具有所有黑色节点，而最长的可能路径将交替具有红色和黑色节点。因为所有最大路径都有相同数量的黑色节点(属性 5)，所以没有路径比任何其他路径长两倍以上。
对红黑树的不同操作
在红黑树上执行只读操作(比如遍历树中的节点)不需要对用于二分搜索法树的操作进行修改。记住每一棵红黑树都是二叉查找树的特例。但是，插入和删除操作可能会违反红黑树的属性。因此，这些操作可能需要恢复红-黑属性，这可能需要少量(O(log N)或摊销 O(1))颜色变化。
1.插入节点
插入操作的开始方式与我们在二叉查找树中添加新节点的方式相同。然而，在二叉查找树中，我们总是将新节点作为叶子添加，而在红黑树中，叶子节点不包含数据。因此，我们没有添加新节点作为叶节点，而是添加了一个红色的内部节点，它有两个黑色的叶节点。请注意，新节点的颜色是红色，其叶节点的颜色是黑色。一旦添加了新的节点，可能会违反红黑树的一些属性。因此，为了恢复它们的属性，我们检查某些案例，并根据插入后出现的案例来恢复属性。
当我们在红黑树中插入新节点时，请注意以下几点:
- 所有叶节点总是黑色的。所以属性 3 总是成立。
- 属性 4(每个红色节点的两个子节点都是黑色的)只有通过添加一个红色节点、重画一个黑色节点(红色)或旋转才会受到威胁。
- 属性 5(从任何给定节点到其叶节点的所有路径具有相等数量的黑色节点)仅通过添加黑色节点、将红色节点重绘为黑色或旋转而受到威胁。
案例 1:添加到根树的新节点
在这种情况下，N 被重绘为黑色，因为树根总是黑色的。因为 s 一次向每条路径添加一个黑节点，所以不违反属性 5。
情况 2:新节点的父节点(P)是黑色的
在这种情况下，每个红色节点的两个子节点都是黑色的，因此属性 4 不会失效。财产 5 也没有受到威胁。这是因为新节点 S 有两个黑色叶节点，但是因为是红色的，所以通过它的每个子节点的路径都有相同数量的黑色节点。
(下面的例子中，假设有一个祖父节点(父节点的父节点)–G，因为它的父节点 P 是红色的，如果是根节点，它就是黑色的。因此，N 也有一个叔叔节点(父节点的兄弟)–U(不管 U 是叶节点还是内部节点)。)
情况 3:父(P)和叔(U)节点都是红色的。
在这种情况下，违反了属性 5，即从任何给定节点到其叶节点的所有路径都具有相同数量的黑节点。第三种情况下的插入如下所示。
为了恢复属性 5，两个节点(P 和 U)都被重绘为黑色，而祖父 G 被重绘为红色。现在，新的红色节点 N 有一个黑色的父节点。由于通过父节点或叔节点的任何路径都必须通过祖父节点，因此这些路径上的黑色节点的数量没有变化。
然而，祖父 G 现在可能违反了属性 2，即根节点总是黑色的，或者违反了属性 4，即每个红色节点的两个孩子都是黑色的。
当 G 有一个红色的双亲时，性质 4 将被违反。为了解决这个问题，整个过程递归地在案例 1 中的 G 上执行。
INSERTION 3
情况 4:父母 P 是红色的，但是叔叔 U 是黑色的，N 是 P 的右孩子，P 是 G 的左孩子
为了解决这个问题，向左旋转以切换新节点 S 及其父节点的角色。在旋转之后，注意我们已经重新标记了 N 和 P，然后，调用 case 5 来处理新节点的父节点。这样做是因为仍然违反了规定每个红色节点的两个子节点都应该是黑色的属性 4。下图说明了情况 4 的插入。注意，在 N 是 G 的左子，P 是 G 的右子的情况下，我们要进行右旋转。
INSERTION 4
情况 5:父节点 P 是红色的但是叔节点 U 是黑色的并且新节点 N 是 P 的左子节点，P 是其父节点 g 的左子节点。
为了解决这个问题，对 G(N 的祖父母)执行右旋转。经过这次旋转，前父节点 P 现在既是新节点 N 的父节点，也是前祖父节点 G 的父节点，我们知道 G 的颜色是黑色的(因为否则，它的前子节点不可能是红色的)。现在，切换 P 和 G 的颜色，使生成的树满足属性 4，即红色节点的两个子节点都是黑色的。案例 5 的插入如下图所示。
INSERTION 5
2.删除节点
我们开始从红黑树中删除一个节点，就像我们在二叉查找树的情况下所做的一样。在二叉查找树中，当我们删除具有两个非叶子节点的节点时，我们在该节点的左子树中找到最大元素，或者在右子树中找到最小元素，并将其值移动到被删除的节点中。
之后，我们删除从中复制值的节点。请注意，该节点的非叶节点必须少于两个。因此，仅仅复制一个值并不违反任何红黑属性，只是把删除的问题简化为删除一个最多有一个非叶子节点的问题。
在本节中，我们将假设删除一个节点，该节点最多有一个非叶节点，我们称之为其子节点。如果这个节点有两个叶节点，那么让其中一个作为它的子节点。
在删除一个节点时，如果它的颜色是红色，那么我们可以简单地用它的子节点替换它，子节点必须是黑色的。通过已删除节点的所有路径将简单地通过少一个红色节点，并且已删除节点的父节点和子节点都必须是黑色的，因此不会违反任何属性。
另一个简单的例子是当我们删除一个有红色子节点的黑色节点时。在这种情况下，属性 4 和属性 5 可能会被违反，所以要恢复它们，只需用黑色重新绘制被删除节点的子节点。然而，当要删除的节点及其子节点都是黑色时，就会出现复杂的情况。在这种情况下，我们首先用子节点替换要删除的节点。
情况 1: N 是新节点。
在这种情况下，我们已经从每个路径中删除了一个黑色节点，新的根是黑色的，因此没有违反任何属性。
情况 2:兄弟姐妹 S 是红色的
在这种情况下，交换 P 和 S 的颜色，然后在 P 处向左旋转。在结果树中，S 将成为 N 的祖父母。下图说明了情况 2 的删除。
DELETION 2
案例三:P，S，S 的孩子是黑人
在这种情况下，简单地用红色重画 S。在结果树中，所有经过 S 的路径都将少一个黑色节点。因此，所有通过 P 的路径现在都比不通过 P 的路径少一个黑节点，所以仍然违反了性质 5。为了解决这个问题，我们在 P 上执行重新平衡过程，从情况 1 开始。案例 3 如下图所示
DELETION 3
案例 4: S 和 S 的孩子是黑色的，但是 P 是红色的
在这种情况下，我们交换 S 和 p 的颜色。虽然这不会影响经过 S 的路径上的黑色节点的数量，但它会向经过 N 的路径添加一个黑色节点，以弥补这些路径上被删除的黑色节点。下图说明了这种情况。
DELETION 4
案例五:N 是 P 的左子，S 是黑的，S 的左子是红的，S 的右子是黑的
在这种情况下，在 S 处执行右旋转，旋转后，S 的左子成为 S 的父，N 的新兄弟。此外，交换 S 和它的新父对象的颜色。请注意，现在所有路径仍然有相同数量的黑色节点，但是 N 有一个黑色兄弟，它的右子节点是红色的，因此我们陷入了情况 6。请参考下图。
DELETION 5
案例 6: S 是黑色的，S 的右子是红色的，N 是其父 P 的左子
在这种情况下，在 P 处进行一次左旋转，使 S 成为 P 的父，S 的右子。旋转后，P 和 S 的颜色互换，S 的右孩子被涂成黑色。一旦遵循了这些步骤，您将观察到属性 4 和属性 5 仍然有效。下图解释了情况 6
DELETION 6
用 Python 实现红绿树算法
import sys
class Node():
def __init__(self, item):
self.item = item
self.parent = None #parent node
self.left = None # left node
self.right = None # right node
self.color = 1 #1=red , 0 = black
class RedBlackTree():
def __init__(self):
self.TNULL = Node(0)
self.TNULL.color = 0
self.TNULL.left = None
self.TNULL.right = None
self.root = self.TNULL
# Preorder
def pre_order_helper(self, node):
if node != TNULL:
sys.stdout.write(node.item + " ")
self.pre_order_helper(node.left)
self.pre_order_helper(node.right)
# Balancing the tree after deletion
def delete_fix(self, x):
while x != self.root and x.color == 0:
if x == x.parent.left:
s = x.parent.right
if s.color == 1:
s.color = 0
x.parent.color = 1
self.left_rotate(x.parent)
s = x.parent.right
if s.left.color == 0 and s.right.color == 0:
s.color = 1
x = x.parent
else:
if s.right.color == 0:
s.left.color = 0
s.color = 1
self.right_rotate(s)
s = x.parent.right
s.color = x.parent.color
x.parent.color = 0
s.right.color = 0
self.left_rotate(x.parent)
x = self.root
else:
s = x.parent.left
if s.color == 1:
s.color = 0
x.parent.color = 1
self.right_rotate(x.parent)
s = x.parent.left
if s.right.color == 0 and s.right.color == 0:
s.color = 1
x = x.parent
else:
if s.left.color == 0:
s.right.color = 0
s.color = 1
self.left_rotate(s)
s = x.parent.left
s.color = x.parent.color
x.parent.color = 0
s.left.color = 0
self.right_rotate(x.parent)
x = self.root
x.color = 0
def __rb_transplant(self, u, v):
if u.parent == None:
self.root = v
elif u == u.parent.left:
u.parent.left = v
else:
u.parent.right = v
v.parent = u.parent
# Node deletion
def delete_node_helper(self, node, key):
z = self.TNULL
while node != self.TNULL:
if node.item == key:
z = node
if node.item <= key:
node = node.right
else:
node = node.left
if z == self.TNULL:
print("Cannot find key in the tree")
return
y = z
y_original_color = y.color
if z.left == self.TNULL:
x = z.right
self.__rb_transplant(z, z.right)
elif (z.right == self.TNULL):
x = z.left
self.__rb_transplant(z, z.left)
else:
y = self.minimum(z.right)
y_original_color = y.color
x = y.right
if y.parent == z:
x.parent = y
else:
self.__rb_transplant(y, y.right)
y.right = z.right
y.right.parent = y
self.__rb_transplant(z, y)
y.left = z.left
y.left.parent = y
y.color = z.color
if y_original_color == 0:
self.delete_fix(x)
# Balance the tree after insertion
def fix_insert(self, k):
while k.parent.color == 1:
if k.parent == k.parent.parent.right:
u = k.parent.parent.left
if u.color == 1:
u.color = 0
k.parent.color = 0
k.parent.parent.color = 1
k = k.parent.parent
else:
if k == k.parent.left:
k = k.parent
self.right_rotate(k)
k.parent.color = 0
k.parent.parent.color = 1
self.left_rotate(k.parent.parent)
else:
u = k.parent.parent.right
if u.color == 1:
u.color = 0
k.parent.color = 0
k.parent.parent.color = 1
k = k.parent.parent
else:
if k == k.parent.right:
k = k.parent
self.left_rotate(k)
k.parent.color = 0
k.parent.parent.color = 1
self.right_rotate(k.parent.parent)
if k == self.root:
break
self.root.color = 0
# Print
def __print_helper(self, node, indent, last):
if node != self.TNULL:
sys.stdout.write(indent)
if last:
sys.stdout.write("R----")
indent += " "
else:
sys.stdout.write("L----")
indent += "| "
s_color = "RED" if node.color == 1 else "BLACK"
print(str(node.item) + "(" + s_color + ")")
self.__print_helper(node.left, indent, False)
self.__print_helper(node.right, indent, True)
def preorder(self):
self.pre_order_helper(self.root)
def minimum(self, node):
while node.left != self.TNULL:
node = node.left
return node
def maximum(self, node):
while node.right != self.TNULL:
node = node.right
return node
def successor(self, x):
if x.right != self.TNULL:
return self.minimum(x.right)
y = x.parent
while y != self.TNULL and x == y.right:
x = y
y = y.parent
return y
def predecessor(self, x):
if (x.left != self.TNULL):
return self.maximum(x.left)
y = x.parent
while y != self.TNULL and x == y.left:
x = y
y = y.parent
return y
def left_rotate(self, x):
y = x.right
x.right = y.left
if y.left != self.TNULL:
y.left.parent = x
y.parent = x.parent
if x.parent == None:
self.root = y
elif x == x.parent.left:
x.parent.left = y
else:
x.parent.right = y
y.left = x
x.parent = y
def right_rotate(self, x):
y = x.left
x.left = y.right
if y.right != self.TNULL:
y.right.parent = x
y.parent = x.parent
if x.parent == None:
self.root = y
elif x == x.parent.right:
x.parent.right = y
else:
x.parent.left = y
y.right = x
x.parent = y
def insert(self, key):
node = Node(key)
node.parent = None
node.item = key
node.left = self.TNULL
node.right = self.TNULL
node.color = 1
y = None
x = self.root
while x != self.TNULL:
y = x
if node.item < x.item:
x = x.left
else:
x = x.right
node.parent = y
if y == None:
self.root = node
elif node.item < y.item:
y.left = node
else:
y.right = node
if node.parent == None:
node.color = 0
return
if node.parent.parent == None:
return
self.fix_insert(node)
def get_root(self):
return self.root
def delete_node(self, item):
self.delete_node_helper(self.root, item)
def print_tree(self):
self.__print_helper(self.root, "", True)
if __name__ == "__main__":
bst = RedBlackTree()
bst.insert(70)
bst.insert(60)
bst.insert(85)
bst.insert(80)
bst.insert(95)
bst.insert(65)
bst.print_tree()
print("\nAfter deleting an element")
bst.delete_node(80)
bst.print_tree()
输出
Output
红黑树的应用
红黑树是高效的二分搜索法树，因为它们为插入、删除和搜索操作提供了最坏情况下的时间保证。
红黑树不仅在诸如实时应用的时间敏感应用中有价值，而且在提供最坏情况保证的其他数据结构中优选用作构建块，AVL 树也支持 O(log n)搜索、插入和删除操作，但是它们比红黑树更加严格地平衡，从而导致较慢的插入和移除，但是更快的数据检索。
摘要
在本文中，我们深入研究了红黑树、它在 python 中的实现以及它的应用。最后，我们可以得出结论，红黑树是自平衡二叉查找树，也称为“对称二叉 B 树”。尽管红黑树很复杂，但它的操作有很好的最坏情况运行时间，并且使用起来很有效，因为搜索、插入和删除都可以在 O(log n)时间内完成。
用 Python 构建 Reddit Web Scraper
原文：https://www.askpython.com/python/examples/reddit-web-scraper-in-python
Reddit 是无数社区、无休止的讨论和真正的人类联系的家园。Reddit 有一个针对各种兴趣的社区，包括突发新闻、体育、电视迷理论，以及源源不断的互联网上最可爱的动物。
使用 Python 的 PRAW (Python Reddit API Wrapper)包，本教程将演示如何从 Reddit 抓取数据。PRAW 是 Reddit API 的 Python 包装器，允许你从子编辑中抓取数据，开发机器人，等等。
在本教程结束时，我们将尝试从 subreddit 中收集尽可能多的 Python 相关数据，并了解 reddit 用户对 Python 的真实看法。让我们开始开心吧！
介绍
顾名思义，它是一种从在线页面中“抓取”或提取数据的技术。使用网络浏览器可以在互联网上看到的所有内容，包括本指南，都可以擦除到本地硬盘上。网络抓取有许多应用。数据捕获是任何数据分析的第一阶段。互联网是所有人类历史和知识的巨大宝库，你有能力提取你想要的任何信息，并以你认为合适的方式使用它。
尽管有各种各样的技术可以从 Reddit 上抓取数据，但 PRAW 简化了这个过程。它符合所有 Reddit API 要求，并消除了开发人员代码中对睡眠调用的需求。在安装刮刀之前，必须设置 Reddit 刮刀的认证。下面列出了各个步骤。
Reddit 刮刀的认证步骤
使用 PRAW 需要身份验证。为此，我们将采取以下步骤:
- 跟随此链接访问 Reddit 开发者账户。
- 滚动到页面底部，找到“您是开发人员吗？”按钮来开发应用程序。
- 下一步是构建一个应用程序，填写表单，并开发应用程序。
- 这将带您到一个页面，其中包含刮刀所需的所有信息。
001 Scraper Step 1
对于重定向 URL，您应该选择 http://localhost:8080 。完成后，点击创建应用程序按钮。
001 Scraper Step 2
既然身份验证阶段已经完成，我们将在下一步中继续实现 Reddit scraper。
刮刀的实现
这一部分将解释你必须做的一切，以获得本教程旨在获得的数据。我们首先将所有需要的模块和库导入到程序文件中。在导入 PRAW 库之前，我们必须通过在命令提示符下执行以下行来安装 PRAW:
pip install praw
既然 PRAW 已经成功安装，下面的代码片段可以用来导入 PRAW 和其他需要的库。
import praw
import pandas as pd
from praw.models import MoreComments
我们刚刚完成的认证程序将立即生效。在利用 PRAW 抓取任何数据之前，我们必须在软件中进行认证。这可以通过创建 Reddit 实例或授权实例来实现。
在本指南中，我们将创建一个授权实例，允许我们对我们的 Reddit 帐户执行任何操作。您只需要向实例提供客户机 id、客户机密码、用户代理、用户名和密码。检查下面的代码片段(填写您的密钥，而不是空白字符串)。
reddit_authorized = praw.Reddit(client_id=" ",
client_secret=" ",
user_agent=" ",
username=" ",
password=" ")
我们的目标是找到 redditors 在平台上谈论 Python 的内容，但如果你改变主意，想了解其他内容，我们将从用户那里收集关于该主题的信息。请看下面的代码片段。
name_subreddit = input("Enter the name of Sub-reddit : ")
使用下面的代码，我们接下来将尝试使用我们之前生成的实例对象来访问 subreddit。此外，我们将提供一些关于 subreddit 的基本信息，以检查我们是否拥有访问权限。
subreddit = reddit_authorized.subreddit(name_subreddit)
print("Display Name:", subreddit.display_name)
print("Title:", subreddit.title)
print("Description:", subreddit.description)
我们将尝试在接下来的代码片段中提取每周、每月和每年的热门帖子，以了解该主题的热门帖子是什么。我们将在提取的 post 对象上的 for 循环的帮助下提取帖子的标题、评论数量和帖子的 URL。
为了使分析更容易，我们将把数据转换成数据帧。下面的代码将提取本周关于该主题的热门帖子。
posts = subreddit.top("week")
posts_dict = {"Title": [],
"Total Comments": [],
"Post URL": []}
for post in posts:
posts_dict["Title"].append(post.title)
posts_dict["Total Comments"].append(post.num_comments)
posts_dict["Post URL"].append(post.url)
top_posts_week = pd.DataFrame(posts_dict)
print("Number of posts extracted : ",top_posts_week.shape[0])
top_posts_week.head()
输出看起来有点像下图，您可以看到我们能够提取 100 个帖子的数据。
002 Top Weekly Posts Reddit
下一个代码片段将获得本月关于该主题的热门帖子。你需要改变的只是subreddit.top函数的参数。
posts = subreddit.top("month")
posts_dict = {"Title": [],
"Total Comments": [],
"Post URL": []}
for post in posts:
posts_dict["Title"].append(post.title)
posts_dict["Total Comments"].append(post.num_comments)
posts_dict["Post URL"].append(post.url)
top_posts_month = pd.DataFrame(posts_dict)
print("Number of posts extracted : ",top_posts_month.shape[0])
top_posts_month.head()
看看通过代码提取的月度热门帖子。
003 Top Monthly Posts Reddit
最后，下面的代码片段将获得该主题的年度热门帖子。同样，您需要更改的只是subreddit.top函数的参数。
posts = subreddit.top("year")
posts_dict = {"Title": [],
"Total Comments": [],
"Post URL": []}
for post in posts:
posts_dict["Title"].append(post.title)
posts_dict["Total Comments"].append(post.num_comments)
posts_dict["Post URL"].append(post.url)
top_posts_year = pd.DataFrame(posts_dict)
print("Number of posts extracted : ",top_posts_year.shape[0])
top_posts_year.head()
看看通过上面的代码提取的年度热门帖子。
004 Top Yearly Posts Reddit
最后，让我们使用下面的代码片段，在帖子 URL 的帮助下，尝试提取帖子的所有评论。这将有助于了解人们对 Python 上的帖子的反应。
我们将从每月发布的最受欢迎的 Python 文章的初始帖子中提取最佳评论。要实现这一点，将需要 praw 模块下的更多注释。
url = top_posts_month['Post URL'][0]
submission = reddit_authorized.submission(url=url)
post_comments = []
for comment in submission.comments:
if type(comment) == MoreComments:
continue
post_comments.append(comment.body)
comments_df = pd.DataFrame(post_comments, columns=['comment'])
print("Number of Comments : ",comments_df.shape[0])
comments_df.head()
看看下图中这篇文章的 44 条评论。
005 Comments Reddit Output
结论
Praw 是 Reddit API 的 Python 包装器，允许我们通过简单的 Python 接口使用 Reddit API。该 API 可用于网络抓取、机器人创建和其他目的。本教程讨论了身份验证，从子编辑中检索最受欢迎的每周、每月和每年的帖子，并提取帖子的评论。
我希望你喜欢这篇文章，如果你喜欢，我建议你也看看下面的教程:
Python 中的 reduce()函数
在本文中，我们将会看到 python 中一个非常重要的函数，叫做 reduce()。
当我们编写某种程序时，我们会遇到各种各样的场景，当我们需要得到某种数学上的总数或累计值来使用那个结果并做一些事情。
假设我们有一个电子商务网站，我们的购物车中有商品和商品价格，我们想计算总金额，以便客户可以下订单。嗯， reduce()函数帮助我们计算总数，从而将一个值列表简化为一个值。
需要记住的另一件重要事情是, reduce()函数不是 Python 内置函数的一部分。当我们下载 python 解释器和 Python 包时， functools 是我们称之为工具带的东西，我们可以将它用于 Python 安装中附带的功能工具，从那里我们希望将 reduce 函数作为一个模块导入。
functools 模块用于处理或返回其他函数的高阶函数，在我们的例子中，它为我们提供了 reduce 函数。
要了解高阶函数，请参考文档
让我们通过一些代码示例来更好地理解 reduce()函数。
在 Python 中实现 Reduce 函数
首先，我们需要从 functools 模块中导入 reduce 函数
from functools import reduce
声明一个数字列表，用它来执行计算
my_prices = [40, 50, 60]
让我们为计算定义一个函数
def calc_total(acc, eachItem):
return acc + eachItem
解释:我们为我们的函数提供了两个参数， acc 或累加值，以及 eachItem ，当我们遍历列表时，它们被用作变量。不要担心，我们将回到累积值来更好地了解它的使用。
实现 reduce() 函数:
total = reduce(calc_total, my_prices, 0)
reduce 函数总共有 3 个参数。
- 第一个是我们之前在代码中定义的函数。
- 第二个是值的列表或我们的序列，我们希望使用它来执行我们的操作，也是前面定义的。
- 第三个参数 0 是初始值累计值，从技术上讲，它的默认值为 0，在我们的示例中这很好，但在更复杂的运算中，如果我们想要初始值为 1，那么必须将其定义为第三个参数，计算会将 1 作为运算的初始值。
解释:reduce()函数从初始的累积值(0) 开始，接受我们的函数 (calc_total) ，通过迭代所有的条目使用数字列表 (my_prices) ，并保留所执行函数每次迭代的累积值，并返回最终结果。
现在，我们已经有了代码，让我们打印出结果
print(f"The summation for the list is {total}")
输出:
The summation for the list is **150**
完整的代码
# Import reduce
from functools import reduce
# Declare a list
my_prices = [40, 50, 60]
# Define our function
def calc_total(acc, eachItem):
return acc + eachItem
# Use reduce(function_name, data, initial_value)
total = reduce(calc_total, my_prices, 0)
# Print the result
print(f"The summation for the list is {total}")
结论
我们看到我们的代码如我们预期的那样工作。我们得到的总数是 150 英镑。这就是 Python 中 reduce()函数的工作方式。它不仅在 Python 中，而且在大多数其他编程语言中都是一个非常重要的函数。reduce 函数的基本概念和用例在所有语言中几乎都是相同的，这使得很好地理解它们变得很有价值。
参考
请查看官方文档了解更多信息。
Python 中的回归样条——初学者入门
原文：https://www.askpython.com/python/examples/regression-splines
这篇文章是对 Python 中回归样条的介绍。它应该可以帮助你开始，并为进一步的学习和研究奠定基础。
嘿编码器！我相信你已经听说过线性回归，这是最简单的算法之一，它教授了很多关于因变量和非因变量之间关系的知识。
结果通常是一条直线。问题是在实际场景中，直线并不总是可行的。
为了克服这一点，我们有了多项式曲线(平滑曲线)。但是多项式曲线会变得非常复杂，因此需要避免。
为了克服这个缺点，在本教程中，我将向您介绍 Python 中可用的回归样条。
也读作:逻辑回归——简单实用实现
为了创建样条回归，整个数据集被分成更小的箱。并且为每个箱预测回归线，并且单独的线通过结连接在一起。
既然我们已经清楚了回归样条是如何工作的，那么让我们转到 Python 编程语言中的代码实现。
在 Python 中实现回归样条
让我们首先下载教程的数据集。数据集可以从这里下载。该数据集是关于人们的工资以及关于人们获得报酬的大量信息。
1.加载数据集
我们将使用 Python 中 pandas 模块的read_csv函数加载数据集。
import pandas as pd
df = pd.read_csv('Wage.csv')
df
让我们看看下图中数据集的样子。
Wage Dataset
2.创建 X 和 Y 值
为了更好地理解样条曲线，我们将看一下两个没有任何直接关系的列。让我们来看看一个人的年龄和工资之间的关系。
年龄不会直接影响一个人的工资，因此会帮助我们更好地理解它的实施。
X = df[['age']]
y = df[['wage']]
3.将数据分为训练和测试数据
下一步是使用 80:20 规则将数据分为训练和测试数据集，其中 80%的数据用于训练，其余 20%用于测试模型。
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state = 1)
4.数据可视化
在这一步中，让我们用下面的代码可视化我们刚刚创建的初始数据集。我们将可视化测试和训练数据集。
import matplotlib.pyplot as plt
import seaborn as sns
sns.set_theme(style="ticks", rc={"axes.spines.right": False, "axes.spines.top": False})
plt.figure(figsize=(10,8))
sns.scatterplot(x=X_train['age'], y=y_train['wage'], color="red",alpha=0.2)
plt.title("Age vs Wage Training Dataset")
plt.figure(figsize=(10,8))
sns.scatterplot(x=X_test['age'], y=y_test['wage'], color="green",alpha=0.4)
plt.title("Age vs Wage Testing Dataset")
plt.show()
结果图如下所示。
Wage And Age Train Visualization
Wage And Age Test Visualization
5.对数据集应用线性回归
如果您以前实现过线性回归，那么对数据集应用线性回归就很简单。我们还将使用训练数据集计算模型的均方误差。
from sklearn.linear_model import LinearRegression
lm = LinearRegression()
lm.fit(X_train,y_train)
print("Slope of the Regression Line is : ", lm.coef_)
print("Intercept of Regression Line is : ",lm.intercept_)
from sklearn.metrics import mean_squared_error
pred_test = lm.predict(X_test)
rmse_test =mean_squared_error(y_test, pred_test, squared=False)
print("Accuracy of Linear Regression on testing data is : ",rmse_test)
模型的结果如下。
Slope of the Regression Line is : [[0.68904221]]
Intercept of Regression Line is : [82.09009765]
Accuracy of Linear Regression on testing data is : 40.68927607250081
现在，让我们使用下面的代码绘制数据集的回归线。
plt.figure(figsize=(10,8))
sns.regplot(x=X_test['age'], y=y_test['wage'], ci=None, line_kws={"color": "red"})
plt.title("Regression Line for Testing Dataset")
plt.show()
Regression Line For Testing Dataset
6.应用多项式回归
让我们尝试使用下面的代码将多项式回归拟合到数据集中，看看我们是否可以在某种程度上提高精确度。
from sklearn.preprocessing import PolynomialFeatures
poly = PolynomialFeatures(2)
X_train_poly = poly.fit_transform(X_train)
X_test_poly = poly.fit_transform(X_test)
pm = LinearRegression()
pm.fit(X_train_poly,y_train)
pred_test = pm.predict(X_test_poly)
rmse_test =mean_squared_error(y_test,pred_test,squared=False)
print("Accuracy of Polynomial Regression on testing data is : ",rmse_test)
我们也可以使用下面的代码绘制多项式回归线。
plt.figure(figsize=(10,8))
sns.regplot(x=X_test['age'], y=y_test['wage'], ci=None, line_kws={"color": "red"},order=2)
plt.title("Polynomial Regression Line for Testing Dataset")
plt.show()
Polynomial Regression Line For Testing Dataset
7.三次样条的实现
三次样条的实现和绘制与前面的实现非常相似。理解下面的代码不会很难。
from patsy import dmatrix
transformed_x = dmatrix("bs(train, knots=(25,40,60), degree=3, include_intercept=False)",
{"train": X_train},return_type='dataframe')
import statsmodels.api as sm
cs = sm.GLM(y_train, transformed_x).fit()
pred_test = cs.predict(dmatrix("bs(test, knots=(25,40,60), include_intercept=False)",
{"test": X_test}, return_type='dataframe'))
rmse_test =mean_squared_error(y_test, pred_test, squared=False)
print("Accuracy for Cubic Spline on testing data is : ",rmse_test)
import numpy as np
plt.figure(figsize=(10,8))
xp = np.linspace(X_test.min(),X_test.max(), 100)
pred = cs.predict(dmatrix("bs(xp, knots=(25,40,60), include_intercept=False)",
{"xp": xp}, return_type='dataframe'))
sns.scatterplot(x=X_train['age'], y=y_train['wage'])
plt.plot(xp, pred, label='Cubic spline with degree=3 (3 knots)', color='red')
plt.legend()
plt.title("Cubic Spline Regression Line for Testing Dataset")
plt.show()
结果如下所示。
Cubic Spline Regression Line For Testing Dataset
恭喜你！您已经到达教程的末尾。如果你喜欢这个教程，我相信你也会喜欢下面的:
机器学习中的回归与分类
原文：https://www.askpython.com/python/regression-vs-classification
读者朋友们，你们好！在本文中，我们将详细讨论机器学习中的 回归 vs 分类。
所以，让我们开始吧！！🙂
机器学习中的回归与分类——简介
当我们想到数据科学和分析时，机器学习一直在为预测和分析数据建模方面发挥着重要作用。
机器学习为我们提供了各种算法，帮助我们在提供的训练和测试数据集上对数据进行建模。有两种机器学习算法:
- 监督机器学习算法:这些算法对带标签的数据进行处理，并从提供给它的历史数据中学习，在其上建立模型，然后该模型可以用于对测试数据的未来预测。
- 无监督机器学习算法 :这些算法与监督学习算法不同，不从历史数据中学习。相反，他们从实时数据中识别相似的模式/特征，并将它们归为一类。
具体谈到监督机器学习算法，它们进一步细分为以下类型的算法:
- ****回归:这些算法作用于数字数据值。它们对因变量或目标变量是数字数据变量的数据集进行预测。因此，预测的结果也是一个数字/连续数据变量。一些最常用的回归 ML 算法有线性回归、决策树回归器、支持向量回归器等。
- ****分类:这类算法作用于分类数据值，即拥有分类数据的数据变量。它对恰好有分类因变量/目标变量的数据集进行预测。最常用的分类最大似然算法有朴素贝叶斯、逻辑回归、KNN 等。
理解了监督 ML 中的回归和分类之后，现在将在下一节讨论它们之间的主要区别。
回归任务
如上所述，回归算法试图将连续的目标变量映射到数据集中的各种输入变量。它有助于我们预测围绕最佳拟合线的所需计算的连续综合得分/值。
当我们运行任何回归算法来评估模型时，拥有解决方案的变量是必不可少的，通过这些变量，我们可以评估连续预测数值的解决方案的可信度。
解决方案 01: 差异
通过回归，目标数据变量与独立变量建立了联系。方差使我们能够测试目标数据变量估计的变化，以及来自分区数据集的训练数据变量的任何种类的变化。
通常，对于任何训练数据值，模型的理想结果应该给出相同的结果。也就是说，它应该表现出最小的方差分数。因此，对于任何回归模型/算法，我们确保方差分数尽可能低。
解决方案 02: 偏差
用简单的语言来说，偏差表示回归算法在没有考虑所有数据的情况下适应和学习不正确数据值的可能性。对于任何具有更好结果的模型，具有低偏差分数是必不可少的。通常，当数据集中的数据有缺失值或异常值时，偏差值较高。
最后，当谈到回归算法时，整个场景都围绕着最佳拟合线的概念。是的，回归模型试图拟合预测和实际数据得分之间的直线。
分类任务
如上所述，分类类型算法使我们能够轻松地处理数据值的分类类型。我们从各种类别集合(数据变量)中预测类别标签。
关于分类，存在各种类型的分类任务，其中一些在下面提到
- ****二元分类–在这类场景中，数据集包含的因变量有两个标签。也就是说，分类模型根据两个分类标签进行测试。例如，检查电子邮件是否是垃圾邮件的推荐系统、检查具有特定 ID 的学生是否在场的门户等等。我们可以利用逻辑回归、决策树等来解决二元分类问题。
- ****多类分类–顾名思义，多类分类算法包含具有两个以上分类标签的数据集作为因变量。与二进制分类不同，这里的标签不是二进制的，而是属于预期的标签范围。例如动物或植物物种识别、基于两个以上属性的人脸分类等。
- ****不平衡分类–在这种类型的分类中，属于每个类别或类标签的实例数量分布不均。例如，考虑一个医疗诊断数据集，其中包含被诊断患有疟疾的人和未受其影响的人的数据。在这种情况下，考虑 80%以上的训练数据包含表明人们患有疟疾的元素。这种情况或分类问题称为不平衡分类问题。在这里，标签的类型之间存在着不平等的差异。我们可以利用 SMOTE 或随机过采样来解决这类问题。
区别 1:结果值的行为
一旦我们完成了预测，对于回归类型的数据，预测结果在本质上是连续的。也就是说，预测的数据值本质上是数值。
另一方面，在预测之后，分类算法的结果类型本质上是分类的。它们导致一些组或类别。
区别 2:模型的评估(误差估计)
预测之后，我们有必要应用某些指标来检查模型的准确性。
同样，在回归算法中，我们利用 MAPE、R-square 等来度量模型的误差估计。另一方面，对于分类算法，我们主要利用召回率、混淆矩阵、F-1 评分等来评估模型的准确性。
区别 3:预测方法
对于针对历史数据的数据值预测，回归算法利用最佳拟合线来估计和预测数据集的最接近的连续数据值。
分类算法使用判定边界来检测由具有相似特征的点的组合形成的聚类的边界。这有助于识别不同类别的输入数据。
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
更多与 Python 编程相关的帖子，请继续关注我们。
在那之前，学习愉快！！🙂
Python 中的正则表达式
原文：https://www.askpython.com/python/regular-expression-in-python
Python 中正则表达式用于匹配模式和字符串。从形式上讲，正则表达式是定义搜索模式的一系列字符。Python 正则表达式是匹配文本模式的强大方法。模块re，正则表达式的缩写，是为我们提供正则表达式所有特性的 Python 模块。
1.使用 Python 的 re 模块
让我们看看 Python re 模块的一些常见例子。是内置的 Python 模块，我们不需要安装。
1.1)重新搜索()
re.search(pattern, str)用于在str(搜索字符串)中搜索序列pattern，它是一个正则表达式，如果找到该模式，则返回一个匹配项。
让我们看一个同样的例子
import re
str = 'This is a sample text which we use to search a pattern within the text.'
pat = r'text'
match = re.search(pat, str)
if match is None:
print('Pattern not found')
else:
print('Pattern found!')
print('Match object', match)
输出
Pattern found!
Match object <re.Match object; span=(17, 21), match='text'>
如您所见，输出显示确实存在模式匹配，我们在str中搜索简单的单词text，span 表示匹配的索引。也就是说，str[17]到str[20]被匹配，对应的是子串text，和预期的一样。但这只给出了第一个匹配。
1.2)查找所有()
为了给出所有匹配字符串的列表，我们使用re.findall(pat, str)返回所有匹配字符串的列表(可以为空)。
>>> matches = re.findall(pat, str)
>>> print(matches)
['text', 'text']
re.findall()是一个提取模式的非常强大的特性，它可以用于任何东西，比如在文件中搜索。
import re
with open('text.txt', 'r') as f:
matches = re.findall(r'pattern', f.read())
print(matches)
2.Python 中正则表达式的规则
在我们进一步讨论之前，我们先来看看正则表达式遵循的某些规则，这些规则是创建模式字符串所必需的。
2.1)标识符
这些是模式标识符和每个标识符遵循的规则。
| 图案 | 规则 |
| \d | 匹配任何数字 |
| \D | 匹配除数字以外的任何内容 |
| \s | 匹配单个空格 |
| \S | 匹配除空格以外的任何内容 |
| \w | 匹配任何字母 |
| \W | 匹配除字母以外的任何内容 |
| 。 | 匹配除换行符(\n)以外的任何字符 |
| . | 匹配句号 |
| \b | 单词周围的空间(单词边界) |
2.2)修改器
除了标识符之外，正则表达式还需要遵循某些操作符/修饰符。
| 修改 | 规则 |
| * | 匹配前面的字符/标识符的零次或多次出现 |
| + | 匹配一个或多个事件 |
| ？ | 匹配 0 或 1 次重复/出现 |
| $ | 在字符串末尾执行匹配 |
| ^ | 在字符串开头执行匹配 |
| {1,3} | 如果重复次数在 1 到 3 次之间，则匹配 |
| {3} | 如果重复次数正好是 3 次，则匹配 |
| {3,} | 匹配 3 次或更多次 |
| [a-z] | 匹配从 a 到 z 的任何单个字符 |
下面是一个使用上述规则的例子。
以下模式匹配一个或多个are单词，后跟一个空格，其后必须有一个或多个任何字母数字字符、逗号或空格的匹配。下面的匹配在最近的句号处停止，因为它不包括在组中。
import re
str = 'There are 10,000 to 20000 students in the college. This can mean anything.\n'
pat = r'are{1,}\s[a-z0-9,\s]+'
match = re.search(pat, str)
matches = re.findall(pat, str)
if match is None:
print('Pattern not found')
else:
print('Pattern found!')
print('Match object', match)
print('Listing all matches:', matches)
输出
Pattern found!
Match object <re.Match object; span=(6, 49), match='are 10,000 to 20000 students in the college'>
Listing all matches: ['are 10,000 to 20000 students in the college']
3.结论
我们学习了正则表达式的基础知识，以及如何使用 Python 的re模块来实现这一功能，使用正则表达式规则来匹配模式。
4.参考
-
关于正则表达式的 pythonprogramming.net 文章:https://python programming . net/Regular-Expressions-regex-tutorial-python-3/
Python ReLu 函数–您需要知道的一切！
读者朋友们，你们好！在本文中，我们将详细关注 Python ReLu 函数。所以，让我们开始吧！！🙂
也读作:用 Python 构建神经网络
ReLu 函数是什么？—简明概述
Python 在临时构建基于卷积图像的学习模型以及机器学习模型方面发挥了重要作用。这些深度学习模型受益匪浅，就像通过 Python 提供的内置模块和功能，构建它们的过程变得很容易。
为了提高深度学习模型的计算效率，Python 为我们引入了 ReLu 函数，也称为修正线性激活函数。
ReLu 函数使我们能够检测和呈现模型结果的状态，并且模型的计算效率也随之提高。
ReLu 激活函数声明，如果输入为负，返回 0。否则，返回 1 。
ReLu function
了解了 ReLu 函数之后，现在让我们使用 Python 来实现它。
Python 中 ReLu 函数的基本实现
首先，我们将创建一个定制的 ReLu 函数，如下所示。
举例:
这里，我们创建了一个定制的用户定义函数，它将利用 max()函数，并将传递的元素与 0.0 进行比较，从而得出它是正还是负的结论。
因为 val 是正数，所以它返回 1.0。变量 val1 是一个负数，因此它返回 0.0
def ReLu(val):
return max(0.0,val)
val = 1.0
print(ReLu(val))
val1 = -1.0
print(ReLu(val1))
输出:
1.0
0.0
ReLu 函数的梯度值
在用于挖掘和处理的数据处理中，当我们试图计算 ReLu 函数的导数时，对于小于零的值，即负值，发现梯度为 0。这意味着学习函数的权重和偏差没有相应地更新。这可能会给模型的训练带来问题。
为了克服 ReLu 函数的这个限制，我们将讨论泄漏 ReLu 函数。
泄漏 ReLu 函数
如上所述，为了克服通过 ReLu 函数的负值的梯度问题， Leaky ReLu 函数基本上将常数的微小线性分量添加到负输入分数。
f(num)= 0.001num, num<0
= num, num>=0
如上所述，在我们的例子中，我们将负数乘以常数(0.001)。
现在，当我们查看上述泄漏 ReLu 函数的梯度时，负数的梯度分数现在将显示为非零，这表明学习函数的权重现在被正确更新。
举例:
def ReLu(a):
if a>0 :
return a
else :
return 0.001*a
a = -1.0
print(ReLu(a))
输出:
-0.001
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
更多与 Python 编程相关的帖子，请继续关注我们。
在那之前，学习愉快！！🙂
在 Python 中从字符串中删除字符的 5 种方法
原文：https://www.askpython.com/python/string/remove-character-from-string-python
以下方法用于在 Python 中移除字符串中的特定字符。
- 通过使用
Naive方法 - 通过使用
replace()功能 - 通过使用
slice和concatenation - 通过使用
join()和list comprehension - 通过使用
translate()方法
注意，这个字符串在 Python 中是不可变的。因此原始字符串保持不变，这些方法返回一个新的字符串。
1.使用 Naive 方法从字符串中移除字符
在这个方法中，我们必须运行一个循环，追加字符，并从现有的字符构建一个新的字符串，除非索引是 n(其中 n 是要删除的字符的索引)
input_str = "DivasDwivedi"
# Printing original string
print ("Original string: " + input_str)
result_str = ""
for i in range(0, len(input_str)):
if i != 3:
result_str = result_str + input_str[i]
# Printing string after removal
print ("String after removal of i'th character : " + result_str)
输出:
原始字符串:DivasDwivedi
删除第 I 个字符后的字符串:DivsDwivedi
2.使用 replace()方法从字符串中删除字符
str = "Engineering"
print ("Original string: " + str)
res_str = str.replace('e', '')
# removes all occurrences of 'e'
print ("The string after removal of character: " + res_str)
# Removing 1st occurrence of e
res_str = str.replace('e', '', 1)
print ("The string after removal of character: " + res_str)
输出:
原始字符串:工程
删除字符后的字符串:工程
删除字符后的字符串:工程
3.使用切分和连接从字符串中删除字符
str = "Engineering"
print ("Original string: " + str)
# Removing char at pos 3
# using slice + concatenation
res_str = str[:2] + str[3:]
print ("String after removal of character: " + res_str)
输出:
原始字符串:删除字符后的工程
字符串:工程
4.使用 join()方法和列表理解从字符串中删除字符
在这种技术中，字符串中的每一个元素都被转换成一个等价的列表元素，之后它们中的每一个都被连接起来形成一个字符串，其中不包括要删除的特定字符。
str = "Engineering"
print ("Original string: " + str)
# Removing char at index 2
# using join() + list comprehension
res_str = ''.join([str[i] for i in range(len(str)) if i != 2])
print ("String after removal of character: " + res_str)
输出:
原始字符串:删除字符后的工程
字符串:工程
5.使用 translate()方法从字符串中删除字符
str = 'Engineer123Discipline'
print(str.translate({ord(i): None for i in '123'}))
输出:
工程学科
参考
- Python 字符串
- Python 从字符串中删除字符
从 Python 数据帧中删除列的 3 种简单方法
原文：https://www.askpython.com/python-modules/pandas/remove-column-from-python-dataframe
读者朋友们，你们好！在本文中，我们将关注从 Python 数据帧中移除列的方法。那么，让我们开始吧。
首先，什么是数据帧？
所以，伙计们！最终在走向解决方案之前，我们非常有必要理解和回忆一个数据框架的意义和存在。
一个数据帧是由 Python 熊猫模块提供的数据结构。它以行和列的形式存储值。因此，我们可以用矩阵的形式将数据表示为行和列。
数据帧类似于现实世界中的 Excel 或 CSV 文件。
如何从 Python 数据帧中删除列？
因此，了解了数据帧之后，现在让我们来关注一下从数据帧中完全删除列的技术。
1.Python dataframe.pop()方法
我们可以使用pandas.dataframe.pop()方法从数据框中移除或删除一列，只需提供列名作为参数。
语法:
pandas.dataframe.pop('column-name')
举例:
import pandas as pd
data = {"Roll-num": [10,20,30,40,50,60,70], "Age":[12,14,13,12,14,13,15], "NAME":['John','Camili','Rheana','Joseph','Amanti','Alexa','Siri']}
block = pd.DataFrame(data)
print("Original Data frame:\n")
print(block)
block.pop('NAME')
print("\nData frame after deleting the column 'NAME':\n")
print(block)
这里，我们创建了一个 Python 字典作为‘数据’,并使用pandas.DataFrame()方法将其进一步转换成数据帧。
此外，我们应用了pop()方法来删除该列。
输出:
Original Data frame:
Roll-num Age NAME
0 10 12 John
1 20 14 Camili
2 30 13 Rheana
3 40 12 Joseph
4 50 14 Amanti
5 60 13 Alexa
6 70 15 Siri
Data frame after deleting the column 'NAME':
Roll-num Age
0 10 12
1 20 14
2 30 13
3 40 12
4 50 14
5 60 13
6 70 15
2.Python del 关键字删除该列
Python del 关键字也可以用来直接从数据框中刷新列。del keyword通常用于删除或清除 Python 中的对象。
看看下面的语法！
语法:
del dataframe['column-name']
举例:
import pandas as pd
data = {"Roll-num": [10,20,30,40,50,60,70], "Age":[12,14,13,12,14,13,15], "NAME":['John','Camili','Rheana','Joseph','Amanti','Alexa','Siri']}
block = pd.DataFrame(data)
print("Original Data frame:\n")
print(block)
del block["NAME"]
print("\nData frame after deleting the column 'NAME':\n")
print(block)
输出:
Original Data frame:
Roll-num Age NAME
0 10 12 John
1 20 14 Camili
2 30 13 Rheana
3 40 12 Joseph
4 50 14 Amanti
5 60 13 Alexa
6 70 15 Siri
Data frame after deleting the column 'NAME':
Roll-num Age
0 10 12
1 20 14
2 30 13
3 40 12
4 50 14
5 60 13
6 70 15
3.Python drop()函数删除列
pandas.dataframe.drop() function使我们能够从数据帧中删除值。这些值可以是面向行的，也可以是面向列的。
看看下面的语法！
dataframe.drop('column-name', inplace=True, axis=1)
inplace:通过将它设置为真，改变被存储到一个新的被创建的对象中，并且它不改变原始的数据帧。axis: 1 用于列操作， 0 用于行操作。
举例:
import pandas as pd
data = {"Roll-num": [10,20,30,40,50,60,70], "Age":[12,14,13,12,14,13,15], "NAME":['John','Camili','Rheana','Joseph','Amanti','Alexa','Siri']}
block = pd.DataFrame(data)
print("Original Data frame:\n")
print(block)
block.drop('NAME', inplace=True, axis=1)
print("\nData frame after deleting the column 'NAME':\n")
print(block)
输出:
Original Data frame:
Roll-num Age NAME
0 10 12 John
1 20 14 Camili
2 30 13 Rheana
3 40 12 Joseph
4 50 14 Amanti
5 60 13 Alexa
6 70 15 Siri
Data frame after deleting the column 'NAME':
Roll-num Age
0 10 12
1 20 14
2 30 13
3 40 12
4 50 14
5 60 13
6 70 15
结论
到此，我们就到了本文的结尾。希望这篇文章能更好地洞察你的兴趣。
如果你遇到任何问题，欢迎在下面评论。在那之前，学习愉快！！🙂
参考
在 Python 中移除列表中的重复元素
原文：https://www.askpython.com/python/remove-duplicate-elements-from-list-python
在本文中，我们将看看如何在 Python 中从列表中删除重复的元素。解决这个问题有多种方法，我们将向您展示其中的一些。
从列表中移除重复元素的方法–Python
1.使用迭代
在 Python 中，要从列表中删除重复的元素，我们可以手动遍历列表，并在新列表中添加一个不存在的元素。否则，我们跳过该元素。
代码如下所示:
a = [2, 3, 3, 2, 5, 4, 4, 6]
b = []
for i in a:
# Add to the new list
# only if not present
if i not in b:
b.append(i)
print(b)
输出
[2, 3, 5, 4, 6]
同样的代码可以使用 List Comprehension 来编写，以减少代码行数，尽管它本质上与前面的一样。
a = [2 3, 4, 2, 5, 4, 4, 6]
b = []
[b.append(i) for i in a if i not in b]
print(b)
这种方法的问题是它有点慢，因为在遍历原始列表的同时，对新列表中的每个元素都进行了比较。
这在计算上很昂贵，我们有其他方法来处理这个问题。只有当列表不是很大时，才应该使用这个选项。否则，请参考其他方法。
2.使用 set()
在 Python 中，从列表中删除重复元素的一个简单而快速的方法是使用 Python 的内置set()方法将列表元素转换成一个唯一的集合，然后我们可以将它转换成一个删除了所有重复元素的列表。
first_list = [1, 2, 2, 3, 3, 3, 4, 5, 5, 6]
# Convert to a set first
set_list = set(first_list)
# Now convert the set into a List
print(list(set_list))
second_list = [2, 3, 3, 2, 5, 4, 4, 6]
# Does the same as above, in a single line
print(list(set(second_list)))
输出
[1, 2, 3, 4, 5, 6]
[2, 3, 4, 5, 6]
这种方法的问题是，由于我们是从一个无序的集合中创建新的列表，所以原始列表的顺序没有像第二个列表那样得到维护。因此，如果您希望仍然保持相对顺序，您必须避免这种方法。
3.保持顺序:使用 OrderedDict
如果您想在 Python 中删除列表中的重复元素时保留顺序，可以使用来自集合模块的 OrderedDict 类。
更具体地说，我们可以使用OrderedDict.fromkeys(list)来获得删除了重复元素的字典，同时仍然保持顺序。然后我们可以使用list()方法很容易地将其转换成一个列表。
from collections import OrderedDict
a = [2, 3, 3, 2, 5, 4, 4, 6]
b = list(OrderedDict.fromkeys(a))
print(b)
输出
[2, 3, 5, 4, 6]
注意:如果你有 Python 3.7 或者更高版本，我们可以用内置的dict.fromkeys(list)代替。这样也会保证秩序。
正如您所观察到的，顺序确实得到了维护，因此我们得到了与第一种方法相同的输出。但是这样快多了！这是解决此问题的推荐方案。但是为了便于说明，我们将向您展示用 Python 从列表中删除重复元素的另外两种方法。
4.使用 list.count()
list.count()方法返回该值出现的次数。我们可以将它与remove()方法一起使用来消除任何重复的元素。但是同样，这并不是而不是维护了秩序。
请注意，该方法就地修改输入列表，因此更改会反映在列表中。
a = [0, 1, 2, 3, 4, 1, 2, 3, 5]
for i in a:
if a.count(i) > 1:
a.remove(i)
print(a)
输出
[0, 4, 1, 2, 3, 5]
一切似乎都很好，不是吗？
但是，上面的代码有一个小问题。
当我们使用 for 循环遍历列表并同时删除元素时，迭代器会跳过一个元素。所以，代码输出依赖于列表元素，如果你幸运的话，你永远不会遇到这个问题。让我们用一个简单的代码来理解这个场景。
a = [1, 2, 3, 2, 5]
for i in a:
if a.count(i) > 1:
a.remove(i)
print(a, i)
print(a)
输出:
[1, 2, 3, 2, 5] 1
[1, 3, 2, 5] 2
[1, 3, 2, 5] 2
[1, 3, 2, 5] 5
[1, 3, 2, 5]
您可以看到 for 循环只执行了四次，并且跳过了 remove()调用后的下一个元素 3。如果您将输入列表作为[1，1，1，1]传递，那么最终的列表将是[1，1]。
那么，有什么变通方法吗？
当然有变通办法。在 for 循环中使用列表的副本，但从主列表中移除元素。创建列表副本的一个简单方法是通过切片。下面是在所有情况下都能正常工作的更新代码。
a = [1, 1, 1, 1]
for i in a[:]: # using list copy for iteration
if a.count(i) > 1:
a.remove(i)
print(a, i)
print(a)
输出:
[1, 1, 1] 1
[1, 1] 1
[1] 1
[1] 1
[1]
5.使用排序()
我们可以使用sort()方法对我们在方法 2 中获得的集合进行排序。这也将删除任何重复，同时保持顺序，但比dict.fromkeys()方法慢。
a = [0, 1, 2, 3, 4, 1, 2, 3, 5]
b = list(set(a))
b.sort(key=a.index)
print(b)
输出
[0, 1, 2, 3, 4, 5]
6.使用熊猫模块
如果我们正在使用 Pandas 模块，我们可以使用pandas.drop_duplicates()方法删除重复项，然后将其转换为一个列表，同时还保留顺序。
import pandas as pd
a = [0, 1, 2, 3, 4, 1, 2, 3, 5]
pd.Series(a).drop_duplicates().tolist()
输出
[0, 1, 2, 3, 4, 5]
参考
- JournalDev 关于删除重复列表元素的文章
- StackOverflow 问题
如何在 Python 中从列表中移除元素？
原文：https://www.askpython.com/python/list/remove-elements-from-a-list
在本文中，我们将介绍 Python 中从列表中移除元素的所有方法。
Python 列表是日常编程中使用的最基本的数据结构。我们会遇到需要从列表中移除元素的情况，在本文中，我们将讨论这一点。
1.根据值从列表中删除元素
Python 是一种著名的编程语言的原因之一是存在大量的内置函数。这些内置的函数非常方便，因此使得 Python 的编写非常方便。
移除()函数
Python 有一个内置的函数，remove()可以帮助我们根据值删除元素。
# List of integers
lis = [3, 1, 4, 1, 5, 9, 2, 6, 5]
# Remove element with value = 1
lis.remove(1)
# Printing the list
print(lis)
# Remove element with value = 9
lis.remove(9)
# Printing the list
print(lis)
输出:
[3, 4, 1, 5, 9, 2, 6, 5]
[3, 4, 1, 5, 2, 6, 5]
这里需要注意的关键点是:
remove()函数接受一个参数——要删除的值。- 如果给定值出现多次，则删除第一个。
- 移除一个元素不会在该位置留下空白，它只是将后面的元素向左移动。
- 如果列表中没有这样的元素，那么脚本会产生一个错误。
remove()函数的无错误用法
有一种简单的方法可以在删除一个元素时绕过错误，以防程序员不知道它在列表中。我们将使用条件中的来实现这一点。
# List of integers
lis = [1, 4, 2, 6, 1, 9, 10]
# Value to be removed
val = 6
# Check if the list contains the value
if val in lis:
# Remove the value from the list
lis.remove(val)
# Printing the list
print(lis)
输出:
[3, 1, 4, 1, 5, 9, 2, 5]
在上面的代码片段中，我们在移除之前首先检查列表中的值是否存在。
删除列表中出现的所有值
正如我们前面提到的，remove()函数只删除第一次出现的值。为了取出所述值的所有实例，我们将使用 while 循环。
# List of integers
lis = [1, 4, 2, 6, 1, 9, 10]
# Value to be removed
val = 1
# Run until the list containes the value
while val in lis:
# Remove the value from the list
lis.remove(val)
# Printing the list
print(lis)
输出:
[3, 4, 5, 9, 2, 6, 5]
以上总结了remove()功能的用法。
2.基于索引删除元素
有几种方法可以根据索引删除元素。让我们快速浏览一下每一条。
的关键字
是 Python 中一个强大的工具，用来移除整个对象。它还可以用来从给定的列表中移除元素。
# List of integers
lis = [3, 1, 4, 1, 5, 9, 2, 6, 5]
# Removing element from the start (index = 0)
del lis[0]
# Printing the list
print(lis)
# Removing element from the last (index = -1)
del lis[-1]
# Printing the list
print(lis)
输出:
[1, 4, 1, 5, 9, 2, 6, 5]
[1, 4, 1, 5, 9, 2, 6]
从上述脚本中得出的一些观察结果如下:
del不是方法。这是一个删除放在它后面的项的语句。- 从特定索引中移除元素会将下一个值移动到该特定索引，如果它不是最后一个索引的话。
- 提供大于(或等于)列表长度的索引将引发“超出范围”错误。
pop()函数
顾名思义，pop()函数从指定的索引中弹出一个元素。
# List of integers
lis = [3, 1, 4, 1, 5, 9, 2, 6, 5]
# Removing the fourth element (index = 3)
lis.pop(3)
# Printing the list
print(lis)
# Removing the second last element (index = -2)
lis.pop(-2)
# Printing the list
print(lis)
输出:
[3, 1, 4, 5, 9, 2, 6, 5]
[3, 1, 4, 5, 9, 2, 5]
我们在这里了解到的pop()方法是:
- 它有一个参数——列表的索引
- 它根据给定的索引从列表中移除元素。下列元素向左移动。
- 它支持反向索引。
- 如果索引不在列表中，它将引发一个“超出范围”错误。
我们有一篇关于使用 pop()方法的完整文章。
3.从列表中移除一定范围的元素
Python 提供了从列表中删除一系列元素的功能。这可以通过del语句来完成。
# List of integers
lis = [3, 1, 4, 1, 5, 9, 2, 6, 5]
# Removing first and second element
del lis[0:2]
# Printing the list
print(lis)
# Removing last two elements
del lis[-2:]
# Printing the list
print(lis)
输出:
[4, 1, 5, 9, 2, 6, 5]
[4, 1, 5, 9, 2]
让我们试着理解这个过程:
- 要从一个序列的列表中删除多个元素，我们需要向
del语句提供一系列元素。 - 一系列元素采用开始索引和/或结束索引，由冒号
':'分隔。 - 要删除的值包括起始索引，但不包括结束索引处的值。
- 如果缺少结束索引，则范围包括列表末尾之前的所有元素。
4.从列表中删除所有元素
Python 提供了一种在一行中清空整个列表的方法。
# List of integers
lis = [3, 1, 4, 1, 5, 9, 2, 6, 5]
# Removing all elements
lis.clear()
# Printing the list
print(lis)
输出:
[ ]
如果该函数应用于空列表，它不会引发任何错误。
结论
使用从列表中移除元素的方式取决于您的判断，是通过值还是索引。不同的环境需要不同的方法，因此 Python 提供了各种从 Python 列表中删除元素的方法。
我们希望读者阅读这篇文章没有困难。如有任何疑问，欢迎在下方评论。
如何使用 NLTK 去除 Python 中的停用词？
原文：https://www.askpython.com/python/examples/remove-stop-words-nltk
在本教程中，我们将学习如何在 Python 中删除一段文本中的停用词。在使用机器学习模型之前，从文本中删除停用词属于数据预处理。
什么是停用词？
停用词是自然语言中没有什么意义的词。这些是像' is '，' the '，' and 之类的词。
当从文本中提取信息时，这些词并不提供任何有意义的东西。因此，在使用文本训练机器学习模型之前，从文本中删除停用词是一个好的做法。
移除停用字词的另一个优点是，它减少了数据集的大小和训练模型所需的时间。
删除停用词的做法在搜索引擎中也很常见。像谷歌这样的搜索引擎从搜索查询中删除停用词，以获得更快的响应。
在本教程中，我们将使用 NLTK 模块来删除停用词。
NLTK 模块是自然语言处理中最受欢迎的模块。
首先，我们将从 NLTK 模块下载带有停用词的语料库。
从 NLTK 下载带有停用词的语料库
要下载语料库，请使用:
import nltk
nltk.download('stopwords')
输出:
Download
现在我们可以开始使用语料库了。
打印语料库中的停用词列表
让我们打印出语料库中的停用词列表。为此，请使用:
from nltk.corpus import stopwords
print(stopwords.words('english'))
输出:
['i', 'me', 'my', 'myself', 'we', 'our', 'ours', 'ourselves', 'you', "you're", "you've", "you'll", "you'd", 'your', 'yours', 'yourself', 'yourselves', 'he', 'him', 'his', 'himself', 'she', "she's", 'her', 'hers', 'herself', 'it', "it's", 'its', 'itself', 'they', 'them', 'their', 'theirs', 'themselves', 'what', 'which', 'who', 'whom', 'this', 'that', "that'll", 'these', 'those', 'am', 'is', 'are', 'was', 'were', 'be', 'been', 'being', 'have', 'has', 'had', 'having', 'do', 'does', 'did', 'doing', 'a', 'an', 'the', 'and', 'but', 'if', 'or', 'because', 'as', 'until', 'while', 'of', 'at', 'by', 'for', 'with', 'about', 'against', 'between', 'into', 'through', 'during', 'before', 'after', 'above', 'below', 'to', 'from', 'up', 'down', 'in', 'out', 'on', 'off', 'over', 'under', 'again', 'further', 'then', 'once', 'here', 'there', 'when', 'where', 'why', 'how', 'all', 'any', 'both', 'each', 'few', 'more', 'most', 'other', 'some', 'such', 'no', 'nor', 'not', 'only', 'own', 'same', 'so', 'than', 'too', 'very', 's', 't', 'can', 'will', 'just', 'don', "don't", 'should', "should've", 'now', 'd', 'll', 'm', 'o', 're', 've', 'y', 'ain', 'aren', "aren't", 'couldn', "couldn't", 'didn', "didn't", 'doesn', "doesn't", 'hadn', "hadn't", 'hasn', "hasn't", 'haven', "haven't", 'isn', "isn't", 'ma', 'mightn', "mightn't", 'mustn', "mustn't", 'needn', "needn't", 'shan', "shan't", 'shouldn', "shouldn't", 'wasn', "wasn't", 'weren', "weren't", 'won', "won't", 'wouldn', "wouldn't"]
这是英语的停用词列表。也有其他语言可用。
要打印可用语言列表，请使用:
from nltk.corpus import stopwords
print(stopwords.fileids())
输出:
['arabic', 'azerbaijani', 'danish', 'dutch', 'english', 'finnish', 'french', 'german', 'greek', 'hungarian', 'indonesian', 'italian', 'kazakh', 'nepali', 'norwegian', 'portuguese', 'romanian', 'russian', 'slovene', 'spanish', 'swedish', 'tajik', 'turkish']
这些语言的停用词在 NLTK ' 停用词语料库中可用。
如何在语料库中添加自己的停用词？
要将您自己的停用字词添加到列表中，请使用:
new_stopwords = stopwords.words('english')
new_stopwords.append('SampleWord')
现在你可以使用' new_stopwords 作为新的语料库。让我们学习如何使用这个语料库从句子中删除停用词。
如何删除文本中的停用词？
在这一节中，我们将学习如何从一段文本中删除停用词。在我们继续之前，您应该阅读这篇关于标记化的教程。
标记化是将一段文本分解成称为标记的更小单元的过程。这些令牌构成了 NLP 的构造块。
我们将使用标记化将一个句子转换成一个单词列表。然后我们将从那个 Python 列表中移除停用词。
nltk.download('punkt')
from nltk.tokenize import word_tokenize
text = "This is a sentence in English that contains the SampleWord"
text_tokens = word_tokenize(text)
remove_sw = [word for word in text_tokens if not word in stopwords.words()]
print(remove_sw)
输出:
['This', 'sentence', 'English', 'contains', 'SampleWord']
您可以看到输出包含' SampleWord '，这是因为我们使用了默认语料库来删除停用词。让我们使用我们创建的语料库。同样，我们将使用列表理解。
nltk.download('punkt')
from nltk.tokenize import word_tokenize
text = "This is a sentence in English that contains the SampleWord"
text_tokens = word_tokenize(text)
remove_sw = [word for word in text_tokens if not word in new_stopwords]
print(remove_sw)
输出:
['This', 'sentence', 'English', 'contains']
结论
本教程是关于在 python 中从文本中删除停用词的。我们使用 NLTK 模块从文本中删除停用词。我们希望你和我们一起学习愉快！
如何在 Python 中重命名文件/目录？
原文：https://www.askpython.com/python/examples/rename-a-file-directory-python
你好，希望你过得好！在本文中，我们将用 Python 重命名文件或目录。
使用操作系统模块在 Python 中重命名文件/目录
Python 操作系统模块提供各种功能来处理特定设备的底层操作系统并与之交互。
Python os.rename() function使我们能够直接从命令提示符或 IDE 中重命名文件或目录。函数的作用是:将源/输入/当前目录或文件的名称改为一个指定的/用户定义的名称。
因此，通过 Python os 模块，可以执行所有系统级交互。
现在，让我们来看看 Python os.rename()函数的语法。
Python os.rename()函数的语法
看看下面的语法:
import os
os.rename(source,destination)
为了使用 rename()函数，我们需要导入 Python os 模块。
此外，需要向 rename()函数提供以下参数:
source:文件或目录的当前名称。destination:替换当前文件/目录名称的名称。
os.rename()函数不返回任何值。它只重命名指定的文件/目录。
理解了 rename()函数的工作原理和语法之后，现在让我们通过下一节中的例子来实现它。
通过实例实现 Python os.rename()函数
让我们尝试使用 os.rename 函数对目录进行重命名
举例:
import os
os.chdir(r"C:/Users/HP/OneDrive/Desktop/")
os.rename("Programming","PRACTICE")
print("The Directory has been successfully renamed!")
os.chdir() function用于改变当前工作目录。
输出:
The Directory has been successfully renamed!
更新名称后的目录:
Directory Renamed As PRACTICE
这里，我们使用 rename()函数将目录“Programming”重命名为“PRACTICE”。
现在，让我们尝试使用 Python os.rename()函数对文件进行重命名。
举例:
import os
os.rename("C:/Users/HP/OneDrive/Desktop/New.txt","C:/Users/HP/OneDrive/Desktop/ss.txt")
print("The File has been successfully renamed!")
输出:
The File has been successfully renamed!
更新名称后的文件—
Python Rename File
这里，我们使用 rename()函数将一个文件更新/重命名为 ss.txt 。
结论
到此，我们就结束了这个话题。如果你有任何疑问，请随时在下面评论。
更多关于 Python 的文章，请访问 【电子邮件保护】 。
参考
- Python 重命名目录— JournalDev
重命名 Pandas 数据框架中的单个列
原文：https://www.askpython.com/python-modules/pandas/rename-single-column
在本文中，您将学习如何重命名 pandas 数据帧中的单个列。
使用 rename()函数
要重命名列，我们使用 pandas DataFrame 的 rename()方法:
rename()函数的参数
rename()函数支持以下参数:
- Mapper :改变列名的函数字典。
- 索引:改变索引名称的字典或函数。
- 列:重命名列的字典或函数。
- 轴:定义目标轴，配合映射器使用。
- 原地:改变源数据帧。
- Errors :如果发现任何错误的参数，则引发 KeyError。
rename()函数要点:
- 甚至可以重命名多个列，以及单个列。
- 用于明确说明意图。
如何重命名单个列？
让我们快速创建一个简单的数据框架，其中有几个名字和两列。您可以复制这个演示代码片段，或者使用您正在处理的 dataframe 来重命名单列。
Import pandas as pd
d = {‘Name’ : [‘Raj’, ‘Neha’, ‘Virat’, ‘Deepika’], ‘Profession’ : [‘Artist’, ‘Singer’, ‘Cricketer’, ‘Actress’]}
df = pd.DataFrame(d)
print(df)
#Output:
Name Profession
0 Raj Artist
1 Neha Singer
2 Virat Cricketer
3 Deepika Actress
现在，让我们使用我们的 rename()函数来更改单个列的名称，而不编辑其中的数据。
# rename single columns
df1 = df.rename(columns={‘Name’ : ‘PersonName’})
print(df1)
#output:
PersonName Profession
0 Raj Artist
1 Neha Singer
2 Virat Cricketer
3 Deepika Actress
同样，我们可以更改另一个剩余列的名称:
df2 = df1.rename(columns={‘Profession’ : ‘Prof’})
print(df2)
#output:
PersonName Prof
0 Raj Artist
1 Neha Singer
2 Virat Cricketer
3 Deepika Actress
结论
我们希望这些解释和示例对您有所帮助，并且您可以在自己的项目中轻松使用它们。
如何解决 Python 中的替换和删除问题？
原文：https://www.askpython.com/python/examples/replace-and-remove-problem
你好编码器！所以在本教程中，我们将理解一个简单的问题。问题的名称是Replace and Remove Problem,我们将用不同的字符串替换一个特定的字符，并从用户输入中删除一个特定的字符。
因此，我们知道需要用不同的字符串或字符组替换一个字符，并从输入中删除一个字符。我们要遵循的两条规则如下:
- 用双 d (
dd)替换a - 删除任何出现的
b
解决方案实施
我们将遵循下面提到的一些步骤:
- 步骤 1:输入“N”(初始字符串的输入)
- 步骤 2:将字符串转换成字符列表(字符数组)
- 步骤 3:遍历字符数组
- 步骤 3.1:如果“a”出现在图片中，则将其更改为“dd”
- 步骤 3.2:如果“b”出现在图片中，则将其从字符数组中移除
- 步骤 4:将更新后的字符数组加入到原始字符串中，并打印输出
现在我们已经理解了解决问题的方法，让我们一步一步地进入实现部分。
步骤 1 和 2:取 N 的输入，并将其转换为字符数组
使用input函数在 Python 中获取输入，然后使用 list函数创建字符数组，该函数将输入字符串作为参数。
# 1\. Taking input
n = input()
# 2\. Convert into a list of characters
l= list(n)
步骤 3:遍历数组，按照规则替换和删除字符
现在我们有了我们的字符数组，我们将遍历列表，每当获得字符a时，我们用 dd 替换它，每当遇到b时，我们将从字符数组中删除该字符。
为了替换字符，我们将直接改变数组中的字符位置，为了从数组中删除一个字符，我们使用了remove函数。
# Rule 1 : Replace 'a' with 'dd'
# Rule 2 : Remove each 'b'
# Iterate over each character
i = len(l)-1
while(i!=-1):
# Rule 1
if(l[i] == 'a'):
l[i] = 'dd'
# Rule 2
elif(l[i] == 'b'):
l.remove(l[i])
i = i-1
步骤 4:加入新的更新的字符数组
最后一步是将更新后的字符数组的所有元素连接成一个字符串。更好的选择是改变作为输入的原始字符串。我们用来实现的函数是join函数。
# Join the updated list
n = ''.join(l)
print("New string is: ",n)
我们走吧！您的解决方案已经完成！现在让我们看看一些随机样本输出。
最终代码
# 1\. Taking input
n = input()
# 2\. Convert into a list of characters
l= list(n)
print("String entered by user is: ",n)
# Rule 1 : Replace 'a' with 'dd'
# Rule 2 : Remove each 'b'
# Iterate over each character
i = len(l)-1
while(i!=-1):
# Rule 1
if(l[i] == 'a'):
l[i] = 'dd'
# Rule 2
elif(l[i] == 'b'):
l.remove(l[i])
i = i-1
# Join the updated list
n = ''.join(l)
print("New string is: ",n)
输出
String entered by user is: abccba
New string is: ddccdd
String entered by user is: abccbabdgsea
New string is: ddccdddgsedd
结论
我希望您理解了问题和解决方案以及代码实现。你可以自己完成所有的事情！感谢您的阅读！编码快乐！
使用熊猫替换数据集中的多个值
原文：https://www.askpython.com/python-modules/pandas/replace-multiple-values-dataframe
在本教程中，我们将了解如何使用 pandas replace()方法更改数据集中的多个值。Pandas 是一个用于数据操作和分析的 python 库，它提供了广泛的特性以使数据集可用。
替换数据集中的多个值
按照下面的分步教程，使用 pandas 库替换数据集中的多个值。
1.进口熊猫
从在代码中导入熊猫开始。
import pandas as pd
2.抽样资料
我们将使用下面的数据集作为示例，并在 Pandas 数据帧中实现它，其中“列”表示数据集的列标题，如数据帧中所定义的。
import pandas as pd
data = pd.DataFrame([
['Jack',25,'USA'],
['Rohan',20,'India'],
['Sam',23,'France'],
['Rini',19,'UK'],
['Tywin',16,'Ireland']],
columns=['Name','Age', 'Country'])
当程序执行时，使用 print 方法打印数据帧，上述代码会产生以下输出——包含 3 列“姓名”、“年龄”、“国家”。
print (data)
Sample Data To Replace Multiple Values
3.使用 replace()方法替换值
在 pandas 中使用 replace()方法将一个指定值替换为另一个指定值。在我们创建的样本数据集中，我们希望将****【国家】列中的美国改为印度:
new_data = data.replace({'Country':{'USA':'India'}})
print (new_data)
**
Replacing Single Value In Dataframe**
现在，如果我们尝试在一个数据帧中一次替换多个值，例如 25 到 23，年龄列中的 16 到 18，以及姓名列中的“Tywin”到“Stark ”,代码看起来会是这样的:
updated_data = new_data.replace({'Age': {25:23, 16:18}, 'Name':{'Tywin':'Stark'}})
print(updated_data)
改变期望值后的最终输出:
**
Replacing Multiple Value In Dataframe**
替换数据帧中多个值的完整代码
尝试下面的代码，看看 Python 中的 replace()方法是如何工作的。
import pandas as pd
data = pd.DataFrame([
['Jack',25,'USA'],
['Rohan',20,'India'],
['Sam',23,'France'],
['Rini',19,'UK'],
['Tywin',16,'Ireland']],
columns=['Name','Age', 'Country'])
print (data)
print('\n')
new_data = data.replace({'Country':{'USA':'India'}})
print (new_data)
updated_data = new_data.replace({'Age': {25:23, 16:18}, 'Name':{'Tywin':'Stark'}})
print('\n')
print(updated_data)
结论
就是这样！对于本教程。希望你已经很好地学习了如何用 Python 替换熊猫数据帧中的多个值。请继续关注 AskPython 以获得更多这样的教程。
如何用熊猫替换多个值？
原文：https://www.askpython.com/python-modules/pandas/replace-multiple-values-pandas
当一个人可以使用 Python 分析数据时，它是否可以灵活地处理用于分析的输入数据？这就是本文要探讨的问题。我们将构建数据，并演示如何利用 Pandas 库的功能替换其中的多个值。
设置 Pandas 数据框架以替换多个值
让我们首先通过输入以下命令将 Pandas 库导入到活动的 Python 窗口中，
import pandas as pd
现在让我们使用索引选项创建一个数据框。索引的作用是在创建数据时为每列数据提供一个标题。在这个例子中，我们将列出一些小吃的名称以及它们相应的价格。为此，需要构建以下代码。
Data={'Snacks':('kamarkattu','then mittai','mysore pak','murukku'),'Price(INR)':[2,1,5,2]}
请记住，在上面的代码中使用花括号{}作为主括号，因为只有这样才能让 Python 明白我们是在提供数据集进行分析。
df=pd.DataFrame(Data)
需要注意的是，在上面的代码中键入 DataFrame 时,“D”和“F”应该保持大写，否则可能会出现以下错误。
Data Frame Error
完成后，使用 print()命令查看输入的数据，如下所示。
print (df)
Viewing The Dataset
替换熊猫数据帧中的多个值
现在让我们假设一个人似乎不喜欢上面列出的零食&想要在相同的价格范围内购买一些替代品来代替它们。这可以通过使用 vals_to_replace 函数来完成，其语法如下所示。
vals_to_replace = {‘old value_1’:’new value_1’, ‘old value_2’:’new value_2’, ……..}
一旦输入了代码，再次点击 ENTER &查看通过 print()命令输入的数据，看看修改是如何完成的。
Values Not Replaced, but why?
通过要求 Python 用代码中给出的新值替换前面列出的每个值，已经完成了值替换&下一行中出现三个箭头的事实也告诉我们，在使用 print()命令查看数据之前没有错误。
但是，没有做的是，被替代的值从来没有映射到数据帧上！使用下面的语法可以很好地做到这一点，
df[‘column header’]=df[‘column header’].map(vals_to_replace)
其中，列标题–索引期间给定的列的名称
将上述语法应用于所使用的数据集，很明显，要替换条目的列是“小吃”列。因此，相同的内容将被更新以构建如下所示的代码。
df['Snacks']=df['Snacks'].map(vals_to_replace)
现在，点击 ENTER 键，使用 print()命令查看替换的值，如下图所示。
Multiple Values Replaced
摘要
既然我们已经到了本文的结尾，希望它已经详细阐述了如何在 Python 中使用 Pandas 替换多个值。这里有另一篇文章详细介绍了熊猫中 read_csv()中分隔符的用法。在 AskPython 中还有许多其他有趣的&文章，这些文章可能对那些想提高 Python 水平的人有很大帮助。欢呼！
如何用空字符串替换熊猫中的 NAN 值？
原文：https://www.askpython.com/python-modules/pandas/replace-nan-values-with-empty-string
数据分析过程的一个重要部分是去除 NAN 值。在本文中，如何用空字符串替换一列或多列中的 NAN 值。我们开始吧！
我们将从创建数据帧开始。让我们用学生们在不同科目的分数数据创建一个数据框架。这些列是“姓名”、“分数”和“年龄”
import pandas as pd
import numpy as np
scoresheet = {
'Name' :['Linda','Tommy','Justin','Gary',np.nan],
'Score':['60',np.nan,'50','70','80'],
'Age':['18','19',np.nan,'20','22'],
}
df = pd.DataFrame(scoresheet)
print(df)
输出
Name Score Age
0 Linda 60 18
1 Tommy NaN 19
2 Justin 50 NaN
3 Gary 70 20
4 NaN 80 22
用空字符串替换 NAN 的 4 种方法
现在让我们学习如何在 Pandas 中用空字符串替换整个数据帧中的 NaN 值
1.使用 df.replace(np.nan，' '，regex=true)方法
此方法用于用空字符串替换数据帧中的所有 NAN 值。
df2 = df.replace(np.nan, '', regex=True)
print(df2)
输出
Name Score Age
0 Linda 60 18
1 Tommy 19
2 Justin 50
3 Gary 70 20
4 80 22
2.使用 df [['列 1 '，'列 2']] = df [['列 1 '，'列 2']]。fillna(")方法
在此方法中，我们将只替换指定列中的 NAN 值。
df2 = df[['Age','Score' ]] = df[['Age','Score' ]].fillna('')
print(df2)
输出
Age Score
0 18 60
1 19
2 50
3 20 70
4 22 80
3.使用 fillna()方法
fillna()方法可用于替换 DataFrame 中的所有 NAN 值。
df2 = df.fillna("")
print(df2)
输出
Name Score Age
0 Linda 60 18
1 Tommy 19
2 Justin 50
3 Gary 70 20
4 80 22
4.对特定列使用 fillna()方法
在这个方法中，我们将对 DataFrame 中的特定列使用 fillna()方法。
df2 = df.Age.fillna('')
print(df2)
输出
0 18
1 19
2
3 20
4 22
Name: Age, dtype: object
结论
总之，我们研究了用空字符串填充数据帧中 NAN 值的各种不同方法。这是数据分析中非常重要的一步，你必须知道如何去除 NAN 值。
如何用 0 替换熊猫数据帧中的 NaN 值？
原文：https://www.askpython.com/python-modules/pandas/replace-nan-values-with-zero
在 Python 中，NaN 的意思是而不是数字。这表示具有 NaN 值的条目要么未定义，要么在数据集中缺失。它是浮点值，不能转换为任何其他数据类型。
NaN 值是不可取的，尤其是在机器学习模型中，因为它们可能导致训练不准确的模型。这些值可以由计算项代替，如平均值、中值或基于数据集的任何其他合适的值。
本教程将着眼于我们如何在 Pandas 数据帧中用 0 替换 NaN 值。让我们首先创建一个数据框。
创建熊猫数据框架
import pandas as pd
import numpy as np
data = {
'Mobile Model Number': [6, np.nan, 2, np.nan, 7, 3, 5,
np.nan, 21, 12, np.nan],
'Price': [30000, 5200, 6000, np.nan, np.nan, 15000, 36000,
np.nan, 4500, np.nan, 2300],
'Rating': [3.1, 3.0, np.nan, 4.6, np.nan, np.nan, 2.8, 4.7,
np.nan, 3.0, np.nan]
}
df = pd.DataFrame(data)
df
Data Frame
上面是一个由 3 列组成的数据框:手机型号、价格和评级。到目前为止，所有这些列都包含一些 NaN 值。
Python 函数替换 NaN 值
Python 中主要有两个函数可以用来替换 NaN 值:
1。replace()
2。fillna()
关于 replace() 函数可以参考这篇了解更多，关于 fillna() 函数可以参考这篇文章了解更多。
用 0 替换 NaN 值的示例
让我们从几个替换 NaN 值的例子开始，并理解这在代码中是如何工作的。
使用 replace()函数:
a.使用 replace()将单个列中的 NaN 值替换为 0
data = {
'Mobile Model Number': [6, np.nan, 2, np.nan, 7, 3, 5,
np.nan, 21, 12, np.nan],
'Price': [30000, 5200, 6000, np.nan, np.nan, 15000, 36000,
np.nan, 4500, np.nan, 2300],
'Rating': [3.1, 3.0, np.nan, 4.6, np.nan, np.nan, 2.8, 4.7,
np.nan, 3.0, np.nan]
}
# applying the replace method on a single column
df['Rating'] = df['Rating'].replace(np.nan, 0)
df
replace(): Replace NaN in a Single Column With 0
在上面的代码中，我们应用了replace()函数，将 dataframe 的“Rating”列中的 NaN 值替换为 0。因此，该列现在用 0 代替了以前的 NaN 值。
b.使用 replace()将整个数据框中的 NaN 值替换为 0
data = {
'Mobile Model Number': [6, np.nan, 2, np.nan, 7, 3, 5,
np.nan, 21, 12, np.nan],
'Price': [30000, 5200, 6000, np.nan, np.nan, 15000, 36000,
np.nan, 4500, np.nan, 2300],
'Rating': [3.1, 3.0, np.nan, 4.6, np.nan, np.nan, 2.8, 4.7,
np.nan, 3.0, np.nan]
}
# applying the replace method on the entire dataframe
df = df.replace(np.nan, 0)
df
replace(): Replace NaN In the Entire Dataframe With 0
在这种情况下，我们将整个数据帧中的所有 NaN 值一次全部替换为 0。
使用 fillna()函数:
这个例子将使用我们之前探索过的 fillna()函数。
a.使用 fillna()将单个列中的 NaN 值替换为 0
data = {
'Mobile Model Number': [6, np.nan, 2, np.nan, 7, 3, 5,
np.nan, 21, 12, np.nan],
'Price': [30000, 5200, 6000, np.nan, np.nan, 15000, 36000,
np.nan, 4500, np.nan, 2300],
'Rating': [3.1, 3.0, np.nan, 4.6, np.nan, np.nan, 2.8, 4.7,
np.nan, 3.0, np.nan]
}
# applying the fillna method on a single column
df['Mobile Model Number'] = df['Mobile Model Number'].fillna(0)
df
fillna(): Replace NaN in a Single Column With 0
这里，我们将“评级”列中的所有 NaN 值替换为 0。
b.使用 fillna()将整个数据帧中的 NaN 值替换为 0
data = {
'Mobile Model Number': [6, np.nan, 2, np.nan, 7, 3, 5,
np.nan, 21, 12, np.nan],
'Price': [30000, 5200, 6000, np.nan, np.nan, 15000, 36000,
np.nan, 4500, np.nan, 2300],
'Rating': [3.1, 3.0, np.nan, 4.6, np.nan, np.nan, 2.8, 4.7,
np.nan, 3.0, np.nan]
}
# applying the fillna method on the entire dataframe
df.fillna(0)
df
fillna(): Replace NaN in the Entire Dataframe With 0
在这种情况下，我们使用fillna()函数将数据帧中的所有 NaN 值一次全部替换为 0。
摘要
因此，我们已经看到了如何在数据帧中用 0 替换 NaN 值。要了解更多关于熊猫和其他 Python 相关概念的信息，也请查看我们的其他博客！
参考
Python 中的请求–使用 Python 请求网页
原文：https://www.askpython.com/python-modules/requests-in-python
Python 中的 Requests 是一个优雅的库，允许您通过 Python 向网页发送 HTTP/1.1 请求。
Python 2.7 和 3.5+都正式支持它。诸如保持活动、连接池、具有持久 cookies 的会话、浏览器风格的 SSL 验证等高级功能使其成为开发人员的首选。
在本文中，我们将学习更多关于这些特性的知识，以及如何开始使用 Python 请求模块创建 web 请求。
如何在 Python 中安装请求？
在 Python 中安装请求很容易，也很容易理解。在 Python 中安装模块有几种方法。但是在本文中，我们将向您展示如何使用 pip 模块。
打开您的终端或命令提示符(如果您是 windows 用户)并键入以下命令。
pip install requests
#Or (if the first command doesn't work) use:
pip3 install requests
它应该成功地在您的设备中安装请求模块。
在 Python 中使用请求
为了理解请求模块是如何工作的，我们需要知道当我们浏览网页时发生了什么的基本原理，以及它如何立即向你显示你希望看到的内容。
每当你点击一个链接，我们就向请求页面的服务器发送一个 HTTP(超文本传输协议)请求。
收到请求后，服务器会向我们发回我们请求的正确内容。我们将要学习的两个最有用的 HTTP 请求是 GET 和 POST 请求。
在下一节中，我们将学习如何在请求库中使用这些方法。但是首先，我们需要将它导入到您的脚本或解释器中。
import requests
1.获取请求
这个方法用于指示我们正在从服务器请求我们选择的 URL 的内容。所以，假设我们想使用 HTTP 请求获得 google 的主页。
输入下面一行。
r = requests.get("http://google.com")
下面是这一行代码的作用:它通过 GET()方法向 Google 主页发送一个 HTTP GET 请求，其中 URL 作为参数提供。响应对象存储在我们的“r”变量中。
我们的响应对象的实例进一步对保留的数据进行分类，并将它们存储在适当的属性中。下面是一个例子
print(r.status_code)
#The output provides the status code for the url. For a success full attempt, the result is 200
print(r.headers)
#The following attribute returns a python dictionary containing key-value pair of the headers
print(r.text)
#This command prints out the response content from the server or Static Source Code.
print(r.encoding)
r.encoding = 'utf-8'
#Requests library also allows you to see or change the encoding of the response content.
2.使用 GET 方法传递参数
通常一个 get 方法不能让我们找到我们需要访问的所有信息，所以我们需要在最初的 GET 请求中传递额外的参数。
参数主要是封装在一个元组或列表中的数据的键值对。我们可以使用 get()方法的 params 参数来发送它。
见语法跟随。
import requests
payload = {'key1': 'value1', 'key2': 'value2'}
r = requests.get('http://httpbin.org/get', params=payload)
print(r.text)
输出:
{
"args": {
"key1": "value1",
"key2": "value2"
},
"headers": {
"Accept": "*/*",
"Accept-Encoding": "gzip, deflate",
"Host": "httpbin.org",
"User-Agent": "python-requests/2.22.0",
"X-Amzn-Trace-Id": "Root=1-5f9a64d1-2abfc74b2725386140a897e3"
},
"origin": 0.0.0.0,
"url": "http://httpbin.org/get?key1=value1&key2=value2"
}
3.发布请求
与 Python 中的 GET 请求不同，HTTP 中的 POST 方法需要用它来发布有效负载。此方法用于向服务器发送数据，而不是直接检索数据。在我们的请求库中，我们可以使用 post()方法访问 POST。
快速浏览一下语法:
import requests
payload = {'key1': 'value1', 'key2': 'value2'}
r = requests.post("https://httpbin.org/post", data=payload)
print(r.text)
输出:
{
"args": {},
"data": "",
"files": {},
"form": {
"key1": "value1",
"key2": "value2"
},
"headers": {
"Accept": "*/*",
"Accept-Encoding": "gzip, deflate",
"Content-Length": "23",
"Content-Type": "application/x-www-form-urlencoded",
"Host": "httpbin.org",
"User-Agent": "python-requests/2.22.0",
"X-Amzn-Trace-Id": "Root=1-5f9a6726-276da087230912e01dd5dcd7"
},
"json": null,
"origin": [REDACTED],
"url": "https://httpbin.org/post"
}
Python 中请求的一些高级特性
我们的文章主要关注两个最基本但非常重要的 HTTP 方法。但是请求模块支持许多这样的方法，比如 PUT、PATCH、DELETE 等。
“请求”模块在开发人员中如此出名的一个主要原因是它的高级功能，如:
- Sessions 对象:它主要用于在不同的请求之间存储相同的 cookies，从而提供更快的响应。
- 对 SOCKS 代理的支持:虽然你需要安装一个独立的依赖项(称为“requests[socks]”)，但它可以极大地帮助你处理多个请求的性能，尤其是当服务器速率限制了你的 IP 时。
- SSL 验证:您可以通过在 get()方法中提供一个额外的参数“verify=True”来强制检查网站是否正确支持 SSL 使用请求。如果网站未能显示对 SSL 的适当支持，脚本将抛出一个错误。
结论
无论是 web 抓取还是其他与 HTTP 相关的工作，请求模块都是最受欢迎的选项。
requests 模块唯一不足的地方是处理页面源代码中的动态变化，因为该模块不是为执行 javascript 命令而设计的。
希望这篇文章能让你对这个模块有一个基本的了解。
资源
你可以在他们的官方文档网站上了解更多关于这个模块的信息:https://requests.readthedocs.io/en/latest/
他们的官方 Github 回购:https://github.com/psf/requests
如何在 Python 中重置数据帧的索引？
原文：https://www.askpython.com/python-modules/pandas/reset-index-of-a-dataframe
读者你好！在本教程中，我们将讨论如何使用 reset_index()和 concat()函数重置 DataFrame 对象的索引。我们还将讨论需要重置熊猫数据帧索引的不同场景。
也读作:用 Python 索引一个数据帧
pandas 中 reset_index()函数的语法
在 Python 中，我们可以使用 pandas DataFrame 类的reset_index()函数来重置 pandas DataFrame 对象的索引。默认情况下，reset_index()函数将熊猫数据帧的索引重置为熊猫默认索引，并返回带有新索引或None值的熊猫数据帧对象。如果 Pandas 数据帧有不止一级的索引，那么这个函数可以删除一级或多级。让我们快速了解一下**reset_index()**函数的语法。
# Syntax of the reset_index() function in pandas
DataFrame.reset_index(level=None, drop=False, inplace=False, col_level=0, col_fill='')
大多数情况下，我们将只使用两个参数 drop 和 inplace ，其余参数使用频率较低。
- drop :尝试不将索引插入 DataFrame 列。它将相关熊猫数据帧的索引重置为默认的整数索引。它采用布尔值，即 True 或 False，默认情况下为 False。
- 就地:它不创建新的 pandas DataFrame 对象，而是进行修改，即就地重置 DataFrame 的索引。它还接收一个布尔值，该值默认为 False。
使用 reset_index()函数重置数据帧的索引
在 Python 中，我们需要在以下场景中重置 pandas DataFrame 对象的索引:
1.当在数据帧中插入行时
如果我们在原始 DataFrame 对象中添加几行，新的行索引从 0 开始。这里，我们可以应用reset_index()函数来重置数据帧的索引。看看下面的演示
# Case-1
# When some rows are inserted in the DataFrame
# Import pandas
import pandas as pd
# Create a DataFrame object
# Using DataFrame() function
df1 = pd.DataFrame({"Date": ['11/05/21', '15/06/21', '17/07/21'],
"Item": ['Television', 'Speaker', 'Monitor'],
"Sales": [200, 300, 115]})
print("Original DataFrame:\n")
print(df1)
# Create an another DataFrame
df2 = pd.DataFrame({"Date": ['04/05/20', '29/07/20', '30/08/20'],
"Item": ['Mixer', 'Bulb', 'Cooler'],
"Sales": [803, 178, 157]})
# Add the rows of DataFrame (df2) to the DataFrame (df1)
# Using the concat() function
df = pd.concat([df1, df2])
print("\nDataFrame after inserting some rows:\n")
print(df)
# Reset the index of the final DataFrame
# Using reset_index() function
df.reset_index(drop = True, inplace = True)
print("\nDataFrame after the resetting the index:\n")
print(df)
输出:
Original DataFrame:
Date Item Sales
0 11/05/21 Television 200
1 15/06/21 Speaker 300
2 17/07/21 Monitor 115
DataFrame after inserting some rows:
Date Item Sales
0 11/05/21 Television 200
1 15/06/21 Speaker 300
2 17/07/21 Monitor 115
0 04/05/20 Mixer 803
1 29/07/20 Bulb 178
2 30/08/20 Cooler 157
DataFrame after the resetting the index:
Date Item Sales
0 11/05/21 Television 200
1 15/06/21 Speaker 300
2 17/07/21 Monitor 115
3 04/05/20 Mixer 803
4 29/07/20 Bulb 178
5 30/08/20 Cooler 157
2.当数据帧中的行被删除时
在这种情况下，我们首先从原始 DataFrame 对象中删除一些被选中的行，在那里索引变得混乱。然后我们在最终的数据帧上应用reset_index()函数来重新计算这些值。让我们看看实现这种情况的 Python 代码。
# Case-2
# When few rows from DataFrame are deleted
# Import pandas Python module
import pandas as pd
# Create a DataFrame object
# Using DataFrame() function
df = pd.DataFrame({"Date": ['11/05/21', '15/06/21', '17/07/21', '19/11/20', '21/12/20'],
"Item": ['Television', 'Speaker', 'Desktop', 'Dish-Washer', 'Mobile'],
"Sales": [200, 300, 115, 303, 130]})
print("Original DataFrame:\n")
print(df)
# Delete few rows of the DataFrame (df)
# Using drop() function
df = df.drop(labels = [0, 3], axis = 0)
print("\nDataFrame after deleting few rows:\n")
print(df)
# Reset the index of the final DataFrame
# Using reset_index() function
df.reset_index(drop = True, inplace = True)
print("\nDataFrame after the resetting the index:\n")
print(df)
输出:
Original DataFrame:
Date Item Sales
0 11/05/21 Television 200
1 15/06/21 Speaker 300
2 17/07/21 Desktop 115
3 19/11/20 Dish-Washer 303
4 21/12/20 Mobile 130
DataFrame after deleting few rows:
Date Item Sales
1 15/06/21 Speaker 300
2 17/07/21 Desktop 115
4 21/12/20 Mobile 130
DataFrame after the resetting the index:
Date Item Sales
0 15/06/21 Speaker 300
1 17/07/21 Desktop 115
2 21/12/20 Mobile 130
3.当在数据帧中对行进行排序时
在这种情况下，我们首先根据一列或多列对原始 DataFrame 对象的行进行排序，然后对最终的 DataFrame 对象应用reset_index()函数。让我们看看如何通过 Python 代码实现这个案例。
# Case-3
# When rows of the DataFrame are sorted
# Import pandas Python module
import pandas as pd
# Create a DataFrame object
# Using DataFrame() function
df = pd.DataFrame({"Date": ['11/05/21', '15/06/21', '17/07/21', '19/11/20', '21/12/20'],
"Item": ['Television', 'Speaker', 'Desktop', 'Dish-Washer', 'Mobile'],
"Sales": [200, 300, 115, 303, 130]})
print("Original DataFrame:\n")
print(df)
# Sort the rows of the DataFrame (df)
# Using sort_values() function
df.sort_values(by = "Sales", inplace = True)
print("\nDataFrame after sorting the rows by Sales:\n")
print(df)
# Reset the index of the final DataFrame
# Using reset_index() function
df.reset_index(drop = True, inplace = True)
print("\nDataFrame after the resetting the index:\n")
print(df)
输出:
Original DataFrame:
Date Item Sales
0 11/05/21 Television 200
1 15/06/21 Speaker 300
2 17/07/21 Desktop 115
3 19/11/20 Dish-Washer 303
4 21/12/20 Mobile 130
DataFrame after sorting the rows by Sales:
Date Item Sales
2 17/07/21 Desktop 115
4 21/12/20 Mobile 130
0 11/05/21 Television 200
1 15/06/21 Speaker 300
3 19/11/20 Dish-Washer 303
DataFrame after the resetting the index:
Date Item Sales
0 17/07/21 Desktop 115
1 21/12/20 Mobile 130
2 11/05/21 Television 200
3 15/06/21 Speaker 300
4 19/11/20 Dish-Washer 303
4.当附加两个数据帧时
同样，这是一种常用的情况，我们必须重置 pandas DataFrame 对象的索引。在这种情况下，我们首先将另一个 DataFrame 对象附加到我们的原始 DataFrame 对象，然后在最终组合的 DataFrame 对象上应用reset_index()函数。让我们编写 Python 代码来实现这种情况。
# Case-4
# When two DataFrames are appended
# Import pandas Python module
import pandas as pd
# Create a DataFrame object
# Using DataFrame() function
df1 = pd.DataFrame({"Date": ['11/05/21', '15/06/21', '17/07/21'],
"Item": ['Television', 'Speaker', 'Desktop'],
"Sales": [200, 300, 115]})
print("Original DataFrame:\n")
print(df1)
# Create a new DataFrame
df2 = pd.DataFrame({"Date": ['19/11/20', '21/12/20'],
"Item": ['Dish-Washer', 'Mobile'],
"Sales": [403, 130]})
# Append the new DataFrame (df1) to the previous one (df2)
df = df1.append(df2)
print("\nDataFrame after appending the new DataFrame:\n")
print(df)
# Reset the index of the final DataFrame
# Using reset_index() function
df.reset_index(drop = True, inplace = True)
print("\nDataFrame after the resetting the index:\n")
print(df)
输出:
Original DataFrame:
Date Item Sales
0 11/05/21 Television 200
1 15/06/21 Speaker 300
2 17/07/21 Desktop 115
DataFrame after appending the new DataFrame:
Date Item Sales
0 11/05/21 Television 200
1 15/06/21 Speaker 300
2 17/07/21 Desktop 115
0 19/11/20 Dish-Washer 403
1 21/12/20 Mobile 130
DataFrame after the resetting the index:
Date Item Sales
0 11/05/21 Television 200
1 15/06/21 Speaker 300
2 17/07/21 Desktop 115
3 19/11/20 Dish-Washer 403
4 21/12/20 Mobile 130
使用 concat()函数重置数据帧的索引
在 Python 中，我们还可以使用 pandas concat()函数和ignor_index参数来重置 pandas DataFrame 对象的索引。默认情况下，ignore_index参数的值为假。为了重置数据帧的索引，我们必须将其值设置为真。让我们通过 Python 代码来实现这一点。
# Reset the index of DataFrame using concat() function
# Import pandas Python module
import pandas as pd
# Create a DataFrame object
# Using DataFrame() function
df1 = pd.DataFrame({"Date": ['11/05/21', '15/06/21', '17/07/21'],
"Item": ['Television', 'Speaker', 'Desktop'],
"Sales": [200, 300, 115]})
print("Original DataFrame:\n")
print(df1)
# Create a new DataFrame
df2 = pd.DataFrame({"Date": ['14/10/20', '19/11/20', '21/12/20'],
"Item": ['Oven', 'Toaster', 'Fan'],
"Sales": [803, 178, 157]})
# Concat the new DataFrame (df2) with the prevous one (df1)
# And reset the index of the DataFrame
# Using the concat() function with ignor_index parameter
df = pd.concat([df1, df2], ignore_index = True)
print("\nDataFrame after concatenation and index reset:\n")
print(df)
输出:
Original DataFrame:
Date Item Sales
0 11/05/21 Television 200
1 15/06/21 Speaker 300
2 17/07/21 Desktop 115
DataFrame after concatenation and index reset:
Date Item Sales
0 11/05/21 Television 200
1 15/06/21 Speaker 300
2 17/07/21 Desktop 115
3 14/10/20 Oven 803
4 19/11/20 Toaster 178
5 21/12/20 Fan 157
结论
在本教程中，我们学习了如何以及何时使用 pandas reset_index()函数来重置修改后的 pandas DataFrame 对象的索引。希望您已经理解了上面讨论的内容，并对自己执行这些数据帧操作感到兴奋。感谢阅读，请继续关注我们，获取更多与 Python 相关的足智多谋的文章。
使用 Python Pillow 调整图像大小(PIL)
原文：https://www.askpython.com/python-modules/resize-image-pillow-pil
调整图像大小可能很棘手，但幸运的是 Python 为我们提供了 Pillow ，这是 Python 图像库(PIL)的一个分支。Python Pillow 支持以下文件格式:JPEG、PNG、TIFF、PPM、GIF 和 BMP。
Pillow 是一个用于图像操作和处理的开源 Python 库。它旨在改进 PIL，并提供一种快速简单的方法来开发 Python 图像应用程序。
太好了，我们快到了！让我们开始学习如何使用 pillow 库在 python 中调整图像大小。
如何使用枕头调整图像大小(PIL)
首先，我们使用 PIL 库中的 resize 方法
语法: Image.resize(size，resample=0)
方法参数:
- Size: 应以像素为单位，作为一个元组(宽度，高度)。
- 重采样:可选。可以成为 PIL 的一员。图像。双线性(线性插值)，PIL。图像。最近的(使用最近的邻居)，PIL。Image.LANCZOS(高质量下采样滤镜)，或 PIL。双三次(三次样条插值)。
- 返回值:输入图像大小调整后的副本。
1.安装枕头
pip install Pillow
虽然对您来说可能不太常见，但是枕头库是使用“导入 PIL”导入的。
2.导入模块
我们从导入枕头模块开始，使用代码:
from PIL import Image
3.选择并打开图像
现在我们需要传递图像，我们想在 PIL 模块的 Image.open 对象中调整它的大小。
这里,“img_sample.jpg”使用的图像样本存储在 python 代码文件的相同位置，如果不是，那么您需要指定文件名及其位置，如img/sample . jpg '
这一步为我们的图像创建一个对象，并将它加载到 Pillow 库中。
# Creating Image Object
img = Image.open('img_sample.jpg')
作为一个可选部分，我们使用 show()方法显示我们刚刚传递给 open 方法的图像，如下所示:
# Display original image
img.show()
我们代码中 show 方法的结果产生了下面的示例图像(原始图像)–
Original Image
4.调整图像大小
我们对上一步中创建的图像对象使用 resize()方法，并根据–width x height 传递图像的所需尺寸(大小)。宽度和高度的值可以是用户选择的任何值。
res_img = img.resize((400,300))
为了查看调整后的图像，我们再次使用 show()方法，如下所示:
# Display resized image
res_img.show()
为了保存我们调整过大小的图像，我们对调整过大小的图像对象使用 save()方法。
为此，我们还需要将重新调整大小的图像文件的新名称作为参数传递给 save()方法。
res_img.save('resized_img.jpg')
使用 show 方法为调整大小后的图像显示的最终输出图像是
Resized Image
使用 PIL 调整图像大小的完整代码
from PIL import Image
# Creating Image Object
img = Image.open('img_sample.png')
# Display original image
img.show()
res_img = img.resize((400,300)) #size can be anything of our choice
# Display resized image
res_img.show()
# To save the resized image
res_img.save('resized_img.png')
5.作物图像
如果你想裁剪一个图像，那么你可以使用 PIL 库的 crop()方法，它以同样的顺序接受 4 个参数:左、上、右、下。
cropped_img = img_sample.crop((left, top, right, bottom))
用此处的图像坐标替换放样、顶部、右侧、底部占位符。
结论
教程到此为止！希望你已经很好地学习了如何使用 pillow (PIL)库在 python 中调整图像的大小，并且可以很容易地在你的代码中实现它来调整图像的大小。
使用 figsize 调整 Matplotlib 中的情节和支线情节的大小
原文：https://www.askpython.com/python-modules/matplotlib/resize-plots-and-subplots
今天在这篇文章中，我们将学习使用 Matplotlib 调整剧情和支线剧情的大小。我们都知道对于数据可视化的目的，Python 是最好的选择。它有一组可以在几乎所有系统上运行的模块。所以，在这个小教程中，我们的任务是温习这方面的知识。我们开始吧！
绘图基础
绘图基本上意味着为给定的数据框形成各种图形可视化。里面有各种类型:
- 条形图:相对于 x-y 坐标上的某个实体，每个数据项的 2D 表示。
- 散点图:代表 x-y 轴上的数据点的小点的绘图。
- 柱状图
- 饼图等
数据科学和计算任务中还使用了各种其他技术。
要了解更多关于绘图的信息，请查看 Matplotlib 中关于绘图的教程。
什么是支线剧情？
子绘图是一种数据可视化的分布式技术，其中在一个图中包含几个图。这使得我们的展示更加美观，并且易于理解各种数据点以及不同实体的分布。
阅读 Matplotlib 中关于支线剧情的更多内容。
用于绘图的 Python 设置
- 编程环境:Python 3.8.5
- IDE: Jupyter 笔记型电脑
- 库/包:Matplotlib，Numpy
在 Matplotlib 中创建要调整大小的地块
让我们跳转到创建几个地块，我们可以稍后调整大小。
代码:
from matplotlib import pyplot as plt
import numpy as np
x = np.linspace(0, 10, 100)
y = 4 + 2*np.sin(2*x)
fig, axs = plt.subplots()
plt.xlabel("time")
plt.ylabel("amplitude")
plt.title("y = sin(x)")
axs.plot(x, y, linewidth = 3.0)
axs.set(xlim=(0, 8), xticks=np.arange(1, 8),
ylim=(0, 8), yticks=np.arange(1, 8))
plt.show()
输出:
Sine Wave Plot
这只是一个简单的正弦波图，显示了时间线性增加时的幅度变化。现在，我们将看到使事情变得更简单的支线剧情。
为了练习，我留下 cos(x)和 tan(x)的代码。看看代码是否有效。
cos(x)的代码:
from matplotlib import pyplot as plt
import numpy as np
x = np.linspace(0, 10, 100)
y = 4 + 2*np.cos(2*x)
fig, axs = plt.subplots()
plt.xlabel("time")
plt.ylabel("amplitude")
plt.title("y = cos(x)")
axs.plot(x, y, linewidth = 3.0)
axs.set(xlim=(0, 8), xticks=np.arange(1, 8),
ylim=(0, 8), yticks=np.arange(1, 8))
plt.show()
输出:
Plot for cos(x)
tan(x)的代码:
from matplotlib import pyplot as plt
import numpy as np
x = np.linspace(0, 10, 100)
y = 4 + 2*np.tan(2*x)
fig, axs = plt.subplots()
plt.xlabel("time")
plt.ylabel("amplitude")
plt.title("y = tan(x)")
axs.plot(x, y, linewidth = 3.0)
axs.set(xlim=(0, 8), xticks=np.arange(1, 8),
ylim=(0, 8), yticks=np.arange(1, 8))
plt.show()
输出:
Plot for tan(x)
Matplotlib 中的图形具有预定义的大小布局。所以，当我们需要改变它们的尺寸时，那么 plot 类有一个 figure 函数。该功能负责使视图与屏幕更加相关。用户完全有权编辑图的尺寸。我们将通过一个例子来理解这一点:
代码:
import random
from matplotlib import pyplot as plt
plt.figure(figsize = (5, 5))
x = []
y = []
plt.xlabel("X values")
plt.ylabel("Y values")
plt.title("A simple graph")
N = 50
for i in range(N):
x.append(random.randint(0, 10))
y.append(random.randint(0, 10))
plt.bar(x, y, color = "pink")
plt.show()
输出:
A Simple Bar Plot
说明:
- 在这段代码中，前两行代码导入 pyplot 和 random 库。
- 在第二行代码中，我们使用了 figure()函数。在这种情况下，figsize 参数接受绘图布局的高度和宽度的元组。
- 这有助于我们决定自己的身高。
- random 函数在两个列表 x，y 的每一个中插入范围从 1 到 10 的随机值。
- 然后调用 bar()函数来创建条形图。
在 Matplotlib 中调整绘图大小
这个库是用来在单轴或多轴上创建支线剧情的。我们可以在上面实现各种条形图。它有助于创建统计数据显示的通用布局。
使用 figsize
代码示例:
from matplotlib import pyplot as plt
import numpy as np
N = 5
menMeans = (20, 35, 30, 35, -27)
womenMeans = (25, 32, 34, 20, -25)
menStd = (2, 3, 4, 1, 2)
womenStd = (3, 5, 2, 3, 3)
ind = np.arange(N) # the x locations for the groups
width = 0.35 # the width of the bars: can also be len(x) sequence
fig, ax = plt.subplots(figsize = (6, 6))
p1 = ax.bar(ind, menMeans, width, yerr=menStd, label='Men')
p2 = ax.bar(ind, womenMeans, width,
bottom=menMeans, yerr=womenStd, label='Women')
ax.axhline(0, color='grey', linewidth=0.8)
ax.set_ylabel('Scores')
ax.set_title('Scores by group and gender')
ax.legend()
# Label with label_type 'center' instead of the default 'edge'
ax.bar_label(p1, label_type='center')
ax.bar_label(p2, label_type='center')
ax.bar_label(p2)
plt.show()
输出:
A bar subplot
说明:
- 前两行是模块的导入语句。
- 然后我们为男性和女性分布值定义两个元组。
- 划分图表的标准划分是男性和女性。
- 那么每个条的宽度被设置为 0.35。
- 我们创建 plt.subplot()函数的两个对象 fig 和 ax 。
- 该函数有一个参数 figsize 。它采用两个元素的元组来描述显示图像的分辨率(宽度，高度)。
- 然后我们分配两个变量 p1 和 p2，并使用 ax 实例调用 bar()方法。
- 最后，只需将标签分配到 x-y 轴，最后绘制它们。
使用支线剧情的分类绘图
使用 matplotlib 的子图也可以绘制分类数据——带标签的信息。我们可以使用这里的 figsize 参数将地块分成许多部分。
举例:
from matplotlib import pyplot as plt
data = {'tiger': 10, 'giraffe': 15, 'lion': 5, 'deers': 20}
names = list(data.keys())
values = list(data.values())
fig, axs = plt.subplots(1, 3, figsize=(9, 3), sharey=True)
axs[0].bar(names, values)
axs[1].scatter(names, values)
axs[2].plot(names, values)
fig.suptitle('Categorical Plotting of presence of all the animals in a zoo')
输出:
Subplots of various types
说明:
- 首先，我们创建一个包含所有键值对的字典。
- 然后我们创建一个所有键的列表和一个单独的所有值的列表。
- 之后，创建 subplots()类的一个简单实例。
- 为了编写必要的参数，我们首先给出 1 来声明行数。3 .申报列数。因此，在一列中有三个图
- 在这里，figsize 等于(9，3)。
- 然后我们把每个图放在坐标轴上。使用列表功能，
- ax[0] =条形图
- ax[1] =散点图
- ax[2] =一个简单的线图
- 这些显示了动物园中所有动物的存在。
结论
所以，在这里我们学习了如何使用支线剧情让事情变得简单。使用 figsize 参数可以节省数据可视化的空间和时间。所以，希望这有帮助。更多关于这个话题。在那之前继续编码。
Python 中的资源模块——初学者入门
在开始阅读本文之前，需要注意的是resource模块是一个特定于 UNIX 的包，不能在 POSIX(即 Windows 操作系统)中工作。
资源模块简介
在使用系统监控和资源的过程中，我们发现自己想知道是否有更好的方法来监控系统信息，而不是手动浏览控制面板中的所有系统日志。
沿着形成一个与这个概念相关的想法的轨迹再走一点，我们会稍微理解这可能是可能的，并且以脚本的形式完全可行。
嗯，再往这个思路看一点，这是个很棒的主意！
使用python-crontab、sched和 dateutil 模块自动执行脚本，将提供每天特定时间间隔的自动更新日志，因此，您不必在特定时间手动接收信息。
但是，在尝试将其自动化之前，我们需要一些可以首先为您提供这些信息的东西，这就是resource模块发挥作用的地方。
用于提供关于系统资源的基本信息，以及控制系统资源的功能，resource模块正是我们要找的。
所以，让我们切入正题，开始学习这个模块吧！
使用 Python 中的资源模块
作为 Python 标准库的一部分，resource模块不需要单独安装，这意味着在安装了 Python 的全新服务器或客户机上使用该模块应该会自动完成，不会有任何问题。
然而，据报道，python 的某些版本似乎确实面临资源模块的任何问题，因此，建议使用 pip 命令安装资源模块。
pip install python-resources
现在我们已经完成了，我们仍然需要使用它的组件来检索所需的信息，所以，让我们开始导入吧！
1.0 建立生态系统
在我们开始使用由resource模块提供的功能之前，我们需要首先导入该模块。
# Importing functions from the resource module
from resource import *
import time
既然我们已经导入了模块，现在我们可以开始检索系统资源的信息了。
1.1 底层参数用法
模块的功能主要取决于提供给返回所需信息的函数的参数。
这些参数的几个例子是，
resource.RUSAGE_SELF–调用进程消耗的资源。resource.RUSAGE_CHILDREN–子进程消耗的资源。resource.RUSAGE_BOTH–当前进程和子进程消耗的资源。resource.RUSAGE_THREAD–当前线程消耗的资源。
所有这些 RUSAGE_*符号都被传递给getrusage()函数，以指定请求哪个进程信息。
1.2 演示
# Function used to retrieve information regarding
## Resources consumed by the current process or it's children
### Non CPU bound task
time.sleep(3)
# Calling for the resources consumed by the current process.
print(getrusage(RUSAGE_SELF))
### CPU bound task
for i in range(10**8):
_ = 1+1
# Calling for the resources consumed by the current process.
print(getrusage(RUSAGE_SELF))
# Output
# resource.struct_rusage(ru_utime=0.016, ru_stime=0.004, ru_maxrss=5216, ru_ixrss=0, ru_idrss=0, ru_isrss=0, ru_minflt=732, ru_majflt=1, ru_nswap=0, ru_inblock=80, ru_oublock=0, ru_msgsnd=0, ru_msgrcv=0, ru_nsignals=0, ru_nvcsw=6, ru_nivcsw=9)
# resource.struct_rusage(ru_utime=14.176, ru_stime=0.02, ru_maxrss=5140, ru_ixrss=0, ru_idrss=0, ru_isrss=0, ru_minflt=730, ru_majflt=0, ru_nswap=0, ru_inblock=0, ru_oublock=0, ru_msgsnd=0, ru_msgrcv=0, ru_nsignals=0, ru_nvcsw=1, ru_nivcsw=177)
我们接收到的输出是资源类对象的形式，在对象的结构中包含了所有必需的信息。
结构中的每个输出值都是浮点值，分别表示在用户和系统模式下执行所花费的时间。
如果您希望了解每个参数的更多信息，或者希望了解整个模块，您可能有兴趣访问文档页面的getrusage()部分。
1.3 向前迈进
使用这个模块应该已经为您提供了一个关于可以由resource模块检索的资源的概念。
扩展这个模块并在脚本中实现它将会监视系统进程并定期检查资源消耗。
如果您希望使用这样的想法，明智的做法是查看各种其他模块，如用于系统进程的psutil、sys和os模块。
为了安排自动检查，您可能希望使用dateutil、sched和python-crontab模块。
结论
此模块的用例主要涉及创建脚本，这些脚本往往会监控系统的功能和过程。
如果您希望使用系统进程、测试和监控，如前一节所述，您应该研究的文章是 psutil 、 sys 、 os 和 dateutil 模块。
参考
在 Python 中反转数组——10 个例子
原文：https://www.askpython.com/python/array/reverse-an-array-in-python
介绍
在本教程中，我们将回顾 Python 中反转数组的不同方法。 Python 语言没有附带数组数据结构支持。相反，它有易于使用的内置列表结构，并提供了一些执行操作的方法。
我们可以通过导入像 Array 或 NumPy 这样的模块来继续使用 Python 中的典型数组。我们的教程将分为三个部分，每个部分都处理 Python 中的单个数组类型的反转。他们是，
- 在 Python 中反转数组列表，
- 在 Python 中反转数组模块的数组，
- 在 Python 中反转 NumPy 数组。
现在让我们进入正题。
在 Python 中反转列表数组
正如我们已经讨论过的，Python 中的列表和数组是相似的。两者的主要区别在于数组只允许相同数据类型的项，而列表允许它们不同。
因为 Python 不支持传统的数组，所以我们可以用列表来描述它们，并尝试反转它们。让我们看看完成这项任务的不同方法，
1.在 Python 中使用列表切片反转数组
我们可以使用切片方法反转一个列表数组。这样，我们实际上以与原始列表相反的顺序创建了一个新列表。让我们看看如何:
#The original array
arr = [11, 22, 33, 44, 55]
print("Array is :",arr)
res = arr[::-1] #reversing using list slicing
print("Resultant new reversed array:",res)
输出:
Array is : [1, 2, 3, 4, 5]
Resultant new reversed array: [5, 4, 3, 2, 1]
2.使用 reverse()方法
Python 还提供了一个内置的方法reverse(),直接在原来的地方颠倒列表项的顺序。
注:这样，我们就改变了实际列表的顺序。因此，原始订单丢失。
#The original array
arr = [11, 22, 33, 44, 55]
print("Before reversal Array is :",arr)
arr.reverse() #reversing using reverse()
print("After reversing Array:",arr)
输出:
Before reversal Array is : [11, 22, 33, 44, 55]
After reversing Array: [55, 44, 33, 22, 11]
3.使用 reversed()方法
我们还有另一个方法，reversed(),当它与一个列表一起传递时，返回一个 iterable，它只包含列表中逆序的项。如果我们在这个 iterable 对象上使用list()方法，我们会得到一个新的列表，其中包含我们的反转数组。
#The original array
arr = [12, 34, 56, 78]
print("Original Array is :",arr)
#reversing using reversed()
result=list(reversed(arr))
print("Resultant new reversed Array:",result)
输出:
Original Array is : [12, 34, 56, 78]
Resultant new reversed Array: [78, 56, 34, 12]
在 Python 中反转数组模块的数组
即使 Python 不支持数组，我们也可以使用数组模块来创建不同数据类型的类似数组的对象。尽管这个模块对数组的数据类型有很多限制，但它在 Python 中被广泛用于处理数组数据结构。
现在，让我们看看如何在 Python 中反转用 array 模块创建的数组。
1.使用 reverse()方法
与列表类似，reverse()方法也可以用于直接反转数组模块的 Python 中的数组。它在原始位置反转数组，因此不需要额外的空间来存储结果。
import array
#The original array
new_arr=array.array('i',[2,4,6,8,10,12])
print("Original Array is :",new_arr)
#reversing using reverse()
new_arr.reverse()
print("Reversed Array:",new_arr)
输出:
Original Array is : array('i', [2, 4, 6, 8, 10, 12])
Resultant new reversed Array: array('i', [12, 10, 8, 6, 4, 2])
2.使用 reversed()方法
同样，reversed()方法在通过数组传递时，返回一个元素顺序相反的 iterable。看看下面的例子，它展示了我们如何使用这个方法来反转一个数组。
import array
#The original array
new_arr=array.array('i',[10,20,30,40])
print("Original Array is :",new_arr)
#reversing using reversed()
res_arr=array.array('i',reversed(new_arr))
print("Resultant Reversed Array:",res_arr)
输出:
Original Array is : array('i', [10, 20, 30, 40])
Resultant Reversed Array: array('i', [40, 30, 20, 10])
在 Python 中反转 NumPy 数组
Numpy模块允许我们在 Python 中使用数组数据结构，这些数据结构真的快，并且只允许相同的数据类型数组。
这里，我们将反转用 NumPy 模块构建的 Python 中的数组。
1.使用 flip()方法
NumPy 模块中的flip()方法反转 NumPy 数组的顺序并返回 NumPy 数组对象。
import numpy as np
#The original NumPy array
new_arr=np.array(['A','s','k','P','y','t','h','o','n'])
print("Original Array is :",new_arr)
#reversing using flip() Method
res_arr=np.flip(new_arr)
print("Resultant Reversed Array:",res_arr)
输出:
Original Array is : ['A' 's' 'k' 'P' 'y' 't' 'h' 'o' 'n']
Resultant Reversed Array: ['n' 'o' 'h' 't' 'y' 'P' 'k' 's' 'A']
2.使用 flipud()方法
flipud()方法是 NumPy 模块中的另一个方法，它上下翻转一个数组。它还可以用于在 Python 中反转 NumPy 数组。让我们看看如何在一个小例子中使用它。
import numpy as np
#The original NumPy array
new_arr=np.array(['A','s','k','P','y','t','h','o','n'])
print("Original Array is :",new_arr)
#reversing using flipud() Method
res_arr=np.flipud(new_arr)
print("Resultant Reversed Array:",res_arr)
输出:
Original Array is : ['A' 's' 'k' 'P' 'y' 't' 'h' 'o' 'n']
Resultant Reversed Array: ['n' 'o' 'h' 't' 'y' 'P' 'k' 's' 'A']
3.使用简单切片
正如我们之前对列表所做的那样，我们可以使用切片来反转用 Numpy 构建的 Python 中的数组。我们创建一个新的 NumPy 数组对象，它以相反的顺序保存条目。
import numpy as np
#The original NumPy array
new_arr=np.array([1,3,5,7,9])
print("Original Array is :",new_arr)
#reversing using array slicing
res_arr=new_arr[::-1]
print("Resultant Reversed Array:",res_arr)
输出:
Original Array is : [1 3 5 7 9]
Resultant Reversed Array: [9 7 5 3 1]
结论
因此，在本教程中，我们学习了如何使用各种方法或技术在 Python 中反转数组。希望能给大家一个清晰的认识。
参考
- https://www.askpython.com/python/python-numpy-arrays
- https://www . ask python . com/python/array/python-array-examples
RMSE——Python 中的均方根误差
原文：https://www.askpython.com/python/examples/rmse-root-mean-square-error
读者们好。在本文中，我们将重点关注如何在 Python 中实现 RMSE–均方根误差。所以，让我们开始吧！！
Python 中的均方根误差(RMSE)是什么？
在深入研究 RMSE 的概念之前，让我们先了解一下 Python 中的错误度量。
误差指标使我们能够通过各种指标跟踪效率和准确性，如下所示——
- 均方误差(MSE)
- 均方根误差(RMSE)
- R 平方
- 精度
- MAPE 等。
均方差是一种这样的误差度量，用于判断回归问题的任何机器学习算法的精度和误差率。
因此， MSE 是一个风险函数，它帮助我们确定某个特性或变量的预测值和实际值之间的均方差。
RMSE 是均方根误差的首字母缩写，是从均方误差函数获得的值的平方根。
使用 RMSE，我们可以很容易地绘制出模型参数的估计值和实际值之间的差异。
由此，我们可以清楚地判断模型的效率。
通常，小于 180 的 RMSE 分数被认为是中等或工作良好的算法的好分数。如果 RMSE 值超过 180，我们需要对模型的参数进行特征选择和超参数调整。
现在，让我们在下一节中重点关注相同内容的实现。
NumPy 模块的均方根误差
让我们看看下面的公式——
RMSE
因此，如上所述，均方根误差是变量/特征的估计值和实际值之间的平均平方差的平方根。
在下面的例子中，我们使用下面提到的 NumPy 模块的函数实现了 RMSE 的概念
- 使用
numpy.subtract()功能计算估计值和实际值之间的差值。 - 进一步，使用
numpy.square()函数计算上述结果的平方。 - 最后，使用
numpy.mean()函数计算平方值的平均值。输出是 MSE 分数。 - 最后，使用
math.sqrt()函数计算 MSE 的平方根，得到 RMSE 值。
举例:
import math
y_actual = [1,2,3,4,5]
y_predicted = [1.6,2.5,2.9,3,4.1]
MSE = np.square(np.subtract(y_actual,y_predicted)).mean()
RMSE = math.sqrt(MSE)
print("Root Mean Square Error:\n")
print(RMSE)
输出:
Root Mean Square Error:
0.6971370023173351
RMSE 用 Python scikit 学习库
在这个例子中，我们使用来自 sklearn.metrics 库的mean_square_error()函数计算了 MSE 分数。
此外，通过 MSE 的平方根计算了 RMSE 分数，如下所示:
举例:
from sklearn.metrics import mean_squared_error
import math
y_actual = [1,2,3,4,5]
y_predicted = [1.6,2.5,2.9,3,4.1]
MSE = mean_squared_error(y_actual, y_predicted)
RMSE = math.sqrt(MSE)
print("Root Mean Square Error:\n")
print(RMSE)
输出:
Root Mean Square Error:
0.6971370023173351
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
更多与 Python 相关的帖子，敬请关注，在此之前，祝你学习愉快！！🙂
机器学习中的 ROC 曲线
原文：https://www.askpython.com/python/examples/roc-curves-machine-learning
ROC 曲线代表接收机工作特性曲线。ROC 曲线显示了分类模型的性能。
ROC 告诉我们，根据预测的概率，该模型在区分给定类别方面有多好。
在本文中，我们将了解 ROC 曲线，什么是 AUC，并实现一个二元分类问题，以了解如何绘制模型的 ROC 曲线。
ROC 曲线介绍
假设我们有一个逻辑回归模型，它将一个事件分类为真或假。我们知道，在逻辑回归中，将一个点分类为真或假的默认阈值是 0.5，但是我们可以根据需要改变该阈值来匹配。
因此，ROC 曲线是对于 0.0 和 1.0 之间的多个不同候选阈值，假阳性率(FPR) (x 轴)对真阳性率(TPR) (y 轴)的图。
了解 TPR 和 FPR
如前所述，ROC 曲线取决于真阳性率和假阳性率，让我们看看它们是什么。
真阳性率:真阳性率的计算方法为真阳性数除以真阳性数和假阴性数之和。
True Positive Rate = True Positives / (True Positives + False Negatives)
假阳性率:假阳性率的计算方法是假阳性数除以假阳性数和真阴性数之和。
False Positive Rate = False Positives / (False Positives + True Negatives)
对于不同的阈值，我们将得到不同的 TPR 和 FPR。
ROC Curve
我们为什么要用 ROC 曲线？
ROC 曲线因以下原因而有用:
- 曲线下的【AUC】面积可以作为模型性能的指标。
- 不同的模型可以根据它们的 ROC 曲线相互比较。
为了获得最佳模型，我们希望提高我们的真阳性率，降低我们的假阳性率(TPR = 1，FPR = 0)。
这意味着我们的模型将能够正确地分离这些类。这样的模型被称为熟练模型。在现实生活中，这是永远达不到的。
在每个阈值没有技能的模型由从图的左下角到右上角的对角线(上图中的蓝线)表示。此类模型的 AUC 为 0.5。这种模型对于每个阈值都具有相等的 TPR 和 FPR。
用 Python 绘制 ROC 曲线
现在让我们构建一个二元分类器，并绘制它的 ROC 曲线，以便更好地理解这个过程。
对于这个例子，我们将使用逻辑回归模型。我们在这里与三个重要的库合作——Matplotlib、 Numpy 和 sklearn。
#Importing Required Modules
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import roc_curve
##Creating a Dataset
X, label = make_classification(n_samples=500, n_classes=2, weights=[1,1], random_state=100)
#Splitting the data into train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, label, test_size=0.3, random_state=1)
#Creating the class object and
model = LogisticRegression()
model.fit(X_train, y_train)
#predict probabilities
probs = model.predict_proba(testX)
#Keeping only positive class
probs = probs[:, 1]
#Calculating the FPR and TPR
fpr, tpr, thresholds = roc_curve(testy, probs)
#Plotting the figure
plt.figure(figsize = (10,6))
plt.plot(fpr, tpr, color='red', label='ROC')
plt.plot([0, 1], [0, 1], color='darkblue', linestyle='--')
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver Operating Characteristic Curve')
plt.legend()
plt.show()
ROC Curve Of Logistic Regression Model
sklearn 模块为我们提供了roc_curve函数，返回误报率和真报率作为输出。
该函数接受两个类的实际概率和使用LogisticRegression类的.predict_proba( )方法计算的预测正概率数组。
好了，现在我们知道如何绘制二元分类模型的 ROC 曲线。
结论
在本文中，我们获得了一些关于 ROC 曲线的信息，以及为什么它很重要。我们还对真阳性率和假阳性率以及 ROC 曲线如何依赖于它们有了一些了解。最后，我们研究了为逻辑回归模型绘制 ROC 曲线的代码。
快乐学习！
用 Python 构建石头剪刀布游戏！
原文：https://www.askpython.com/python/examples/rock-paper-scissors-in-python-with-ascii-hand
哦，你好，游戏程序员！今天，我将指导你如何自己制作一个简单的石头剪刀布游戏。
你准备好了吗？让我们开始吧！
石头剪刀布游戏介绍
在构建任何新游戏之前，你需要了解游戏的所有内容，包括它的规则、输入和输出，以及所有必要的东西。
游戏怎么玩？
石头剪子布是我们从小就玩的经典手游之一。它通常在两个玩家之间进行(也可以由两个以上的玩家进行)，每个人用一只手同时形成三种形状(石头、布、剪刀)中的一种。
如何为选项形成手势？
摇滚用握紧的拳头代表；纸由一只扁平的手代表，剪刀由一个 V 形(流行的和平信号)代表。下图展示了这些手势。
Rock Paper Scissors Shape
游戏规则
虽然游戏的编码部分可能有点复杂，但游戏规则很简单，如下所示:
- 石头赢了剪刀。
- 剪刀赢在纸上。
- 纸赢了石头。
用 Python 制作石头剪刀布
我们会把整个游戏建筑分成几个部分，让你觉得简单！我们制作游戏的所有步骤如下:
- 导入所有必需的模块
- 打印问候消息并询问玩家想要如何玩游戏。
- 为以下目的创建单独的函数:
- 画手绘图
- 玩电脑！
- 和朋友一起玩！
步骤 1–导入必要的模块。
我们在构建游戏时使用了一些模块。让我把你一个一个介绍给他们。
- 随机模块:内置模块，用于生成随机对象，可以是整数、浮点数，也可以是其他对象。
- Getpass 模块 : Getpass 模块通常用于从用户处获取密码，但在游戏中，它也用于向玩家 2 隐藏玩家 1 的输入，以实现公平游戏。
为了导入模块，我们使用以下代码:
import random
import getpass
第二步-打印问候信息，并询问玩家想如何玩游戏。
游戏制作者在游戏开始前问候玩家是明智的。更好的问候信息会让你的游戏比同一个游戏的其他开发者更好。问候之后，玩家会被询问是想和电脑或朋友一起玩，还是想简单地退出游戏。
在我们的例子中，我们将定义一个存储所有问候信息的函数。相同的代码如下所示:
def Info ():
print ("\tHELLO THERE! WELCOME TO ROCK PAPER SCISSORS GAME!")
print ("INSTRUCTIONS:\nBoth the players have three choices namely rock, paper and scissors.")
print ("\nGAME RULES:")
print ("\tSCISSORS beats PAPER")
print ("\tPAPER beats ROCK")
print ("\tROCK beats SCISSORS")
print ("--------------------------------------------------------------------------")
print ("Choose between the two options: ")
print ("\t 1\. Play with the computer")
print ("\t 2\. Play with a friend")
print ("\t 3\. Exit Game")
当调用“Info”函数时，它以如下所示的模式打印信息:
Info Rock Paper Scissors
在选择了游戏方法后，玩家会被询问想要和电脑还是朋友玩几局。必须考虑的一些事情是回合数应该是整数，玩家选择的游戏方法也应该是有效的。
游戏相同的整个启动过程的代码如下所示。
Info ()
choices = ["rock","paper","scissors"]
wrong = True
while wrong:
try:
n= int (input ("Enter your choice of Gameplay: "))
if(n==1):
wrong = False
x = int (input ("Enter number of rounds you want to play: "))
begin_game_computer(x)
elif(n==2):
wrong = False
x = int (input ("Enter number of rounds you want to play: "))
begin_game_friend(x)
elif(n==3):
wrong=False
print ("\nThank you for playing! \nBye!")
else:
print ("Choose Again!")
except (ValueError):
print ("INVALID INPUT! Choose Again!")
wrong=True
让我们明白这里到底发生了什么。首先，我们调用 Info 函数来问候玩家，然后我们利用 Python 异常来处理必要的事情。
如果玩家选择玩电脑，则调用“begin_game_computer”函数，同样，如果玩家选择与朋友玩，则调用“begin_game_friend”函数。
步骤 3-为不同的目的创建不同的函数。
现在，构建游戏的主要步骤是定义游戏正常运行所需的功能。让我们从头开始构建所有项目。
1.定义绘制手形图的函数。
为了使游戏对玩家来说更具互动性，我们将定义一个函数来打印对应于所选正确选项的手型图。
相同的代码如下:
def draw_diagrams(ch):
if(ch=="rock"):
print("""
_______
---' ____)
(_____)
(_____)
(____)
---.__(___)
""")
elif(ch=="paper"):
print("""
_______
---' ____)____
______)
_______)
_______)
---.__________)
""")
elif(ch=="scissors"):
print("""
_______
---' ____)____
______)
__________)
(____)
---.__(___)
""")
else:
print("WRONG INPUT! CHOOSE AGAIN PLEASE!\n")
2.定义在电脑上玩的功能。
在解释任何东西之前，让我先展示一下代码，解释妥当。
def begin_game_computer(n):
score1=0
score2=0
for i in range(n):
print("---------------------------------------------------------------------------")
print("ROUND NUMBER: ",i+1)
check = True
while check:
p_ch = input("Choose your option: ")
if(p_ch.lower() in choices):
check=False
else:
print("Wrong Input! Enter Again!")
c_ch = choices[random.randint(0,2)]
print("\nYOUR CHOICE: ")
draw_diagrams(p_ch.lower())
print("\nCOMPUTER's CHOICE: ")
draw_diagrams(c_ch.lower())
winner = check_win(p_ch,c_ch)
if(winner==1):
print("YOU WIN THE ROUND HURRAY!\n")
score1+=1
elif(winner==2):
print("Oh no! Computer wins the round!\n")
score2+=1
else:
print("DRAW ROUND!\n")
print("---------------------------------------------------------------------------")
print("FINAL SCORES ARE AS FOLLOWS: ")
print("YOUR SCORE: ",score1)
print("COMPUTER's SCORE: ",score2)
if(score1>score2):
print("---------------------------------------------------------------------------")
print("HURRAY YOU WIN! Congratulations!")
print("---------------------------------------------------------------------------")
elif(score1<score2):
print("---------------------------------------------------------------------------")
print("Computer wins this time! Better Luck next time!")
print("---------------------------------------------------------------------------")
else:
print("---------------------------------------------------------------------------")
print("It's a draw game!")
print("---------------------------------------------------------------------------")
现在让我们仔细了解整个信息。这个函数在游戏中起着重要的作用，所以试着正确理解这个函数。
我们用两个变量score1和score2来存储两个玩家的分数(在这个例子中，玩家 2 是计算机)。现在运行一个循环来计算总回合数，对于每一回合，我们确保包括三件事:
- 两个玩家的输入:对于计算机，我们定义了一个包含所有三个选项的列表，并使用随机库，计算机从三个选项中随机选择一个。
- 检查谁赢了这轮:为了检查谁赢了这轮，我们使用了一个单独的函数，该函数将两个输入都作为参数，并返回哪个玩家赢了(1 或 2)。赢家检查功能的代码如下所示:
def check_win(c1,c2):
if(c1=='rock' and c2=='paper'):
return 2
elif(c1=='paper' and c2=='rock'):
return 1
elif(c1=='paper' and c2=='scissors'):
return 2
elif(c1=='scissors' and c2=='paper'):
return 1
elif(c1=='rock' and c2=='scissors'):
return 1
elif(c1=='scissors' and c2=='rock'):
return 2
elif(c1==c2):
return 0
- 更新得分值:下一步是增加第一个和第二个玩家的得分，如果他们中的任何一个赢了，并且如果有平局，什么也没有发生。
对于玩家提到的回合数，重复相同的过程。然后我们显示电脑和玩家的最终分数，并比较分数，让玩家知道谁赢了游戏！
3.定义和朋友一起玩的功能。
和朋友玩游戏就像和电脑玩游戏一样。唯一的区别是，在这种情况下，我们将采用两个输入，而不是随机采用第二个输入。
这里我们做的另一个小改变是，在第二个玩家选择之前，我们隐藏了第一个玩家的回答。同样，我们使用getpass方法。
让我向您展示与朋友一起玩的代码是什么样子的:
def begin_game_friend(n):
score1=0
score2=0
for i in range(n):
print("---------------------------------------------------------------------------")
print("ROUND NUMBER: ",i+1)
check = True
while check:
p1_ch = getpass.getpass(prompt="Choose your option player 1: ",stream=None)
if(p1_ch.lower() in choices):
check=False
else:
print("Wrong Input! Enter Again!")
check = True
while check:
p2_ch = input("Choose your option player 2: ")
if(p2_ch.lower() in choices):
check=False
else:
print("Wrong Input! Enter Again!")
print("\nPLAYER 1 CHOICE: ")
draw_diagrams(p1_ch.lower())
print("PLAYER 2 CHOICE: ")
draw_diagrams(p2_ch.lower())
winner = check_win(p1_ch,p2_ch)
if(winner==1):
print("Player 1 wins the round!\n")
score1+=1
elif(winner==2):
print("Player 2 wins the round!\n")
score2+=1
else:
print("DRAW ROUND!\n")
print("---------------------------------------------------------------------------")
print("FINAL SCORES ARE AS FOLLOWS: ")
print("PLAYER 1 SCORE: ",score1)
print("PLAYER 2 SCORE: ",score2)
if(score1>score2):
print("---------------------------------------------------------------------------")
print("PLAYER 1 WINS! Congratulations!")
print("---------------------------------------------------------------------------")
elif(score1<score2):
print("---------------------------------------------------------------------------")
print("PLAYER 2 WINS! Congratulations")
print("---------------------------------------------------------------------------")
else:
print("---------------------------------------------------------------------------")
print("It's a draw game!")
print("---------------------------------------------------------------------------")
最终输出
恭喜你！我们现在都准备好运行游戏了！让我给你看一个用电脑和和一个朋友两轮的结果样本。
Test RPS Round With Computer
Test RPS Round With Friend
结论
我希望你能够成功地建立和理解整个游戏建设！恭喜你！现在你知道了如何为石头剪子布游戏创建逻辑，你可以自己创建一些其他的游戏！
感谢您的阅读！编码快乐！
Python 中的石头剪刀布——完整的分步指南
原文：https://www.askpython.com/python/examples/rock-paper-scissors-in-python
在本文中，我们将通过 Python 语言创建我们自己的石头剪刀布游戏的步骤。
关于石头剪刀布
传统的石头剪刀布是一个双人游戏，每个人同时选择石头、布或剪刀，假设石头压剪刀，剪刀剪布，布盖石头。根据规则，决定谁是赢家。
如果你熟悉流行电视剧《生活大爆炸》，你可能知道这个游戏的另一个版本，叫做石头剪刀布蜥蜴史波克。下面的信息图可能会帮助你理解。
Rock-Paper-Scissors-Lizard-Spock
箭头的方向决定了胜利者。一个实体的箭头意味着，这个实体在特定的比赛中的优势。
游戏演示
在 Python 中创建石头剪刀布
我们今天要创建的游戏支持两种版本的石头剪刀布。不是每个人都热衷于玩新版本的游戏，因此我们需要一个游戏菜单来区分粉丝群。菜单是这样的。
Game Menu
创建数据结构
游戏的完整运行需要两种特定的数据结构。
# The mapping between moves and numbers
game_map = {0:"rock", 1:"paper", 2:"scissors", 3:"lizard", 4:"Spock"}
# Win-lose matrix for traditional game
rps_table = [[-1, 1, 0], [1, -1, 2], [0, 2, -1]]
# Win-lose matrix for new version of the game
rpsls_table = [[-1, 1, 0, 0, 4],[1, -1, 2, 3, 1], [0, 2, -1, 2, 4], [0, 3, 2, -1, 3], [4, 1, 4, 3, -1]]
映射游戏移动
为了决定赢家和输家，我们需要在可能的移动和数字之间建立某种映射。为此，我们使用了 python 字典。
输赢矩阵
在 Python 中检查石头剪子布的获胜者的最简单的方法是参考对应于每个玩家输入的单元格。下面是传统游戏的矩阵:
Win-Lose Matrix
矩阵的非负值表示相应输入的获胜者。让我们举一个例子，来完整地理解这个矩阵。
假设，在某个博弈中，参与人 1 选择剪刀(指数= 2)，参与人 2 选择布(指数= 1)。矩阵中的单元(2，1)和(1，2)表示剪刀和纸之间的匹配。这些单元格包含剪刀的索引，因为剪刀会剪纸。
包含'-1'的单元格表示平局游戏。
以下是新版本的矩阵:
Win-Lose Matrix
上面解释的数据结构总结了创建我们的石头剪子布游戏所需的完整游戏逻辑。剩下的两件事是管理玩家输入和计算机移动。
构建游戏循环
Python 中石头剪刀布最关键的部分之一是游戏循环。在这个游戏的上下文中，游戏循环负责维护玩家之间的一串匹配。
# The GAME LOOP
while True:
# The Game Menu
print()
print("Let's Play!!!")
print("Which version of Rock-Paper-Scissors?")
print("Enter 1 to play Rock-Paper-Scissors")
print("Enter 2 to play Rock-Paper-Scissors-Lizard-Spock")
print("Enter 3 to quit")
print()
# Try block to handle the player choice
try:
choice = int(input("Enter your choice = "))
except ValueError:
clear()
print("Wrong Choice")
continue
# Play the traditional version of the game
if choice == 1:
rps()
# Play the new version of the game
elif choice == 2:
rpsls()
# Quit the GAME LOOP
elif choice == 3:
break
# Other wrong input
else:
clear()
print("Wrong choice. Read instructions carefully.")
'rps()'和'rpsls()'函数有一个内部游戏循环来处理各自版本的一系列游戏。
'clear()''功能负责清除终端，以防止输出拥挤。
Python 中石头剪刀布的游戏说明
在期望玩家采取行动之前，程序员有责任向玩家提供一组指令。我们需要创建两个独立的函数来为这两种游戏提供指令。
# Set of instructions for Rock-Paper-Scissors
def rps_instructions():
print()
print("Instructions for Rock-Paper-Scissors : ")
print()
print("Rock crushes Scissors")
print("Scissors cuts Paper")
print("Paper covers Rock")
print()
# Set of instructions for Rock-Paper-Scissors-Lizard-Spock
def rpsls_instructions():
print()
print("Instructions for Rock-Paper-Scissors-Lizard-Spock : ")
print()
print("Scissors cuts Paper")
print("Paper covers Rock")
print("Rock crushes Lizard")
print("Lizard poisons Spock")
print("Spock smashes Scissors")
print("Scissors decapitates Lizard")
print("Lizard eats Paper")
print("Paper disproves Spock")
print("Spock vaporizes Rock")
print("Rock crushes Scissors")
print()
显示指令后，我们要求玩家输入。
处理玩家输入
因为我们的游戏支持玩家对战电脑的场景，所以我们必须在 Python 中的石头剪刀布游戏中注意每一步棋
输入菜单
我们需要给玩家一种控制游戏的感觉。我们可以通过提供“寻求帮助”、“可能的移动”和“退出游戏”的选项来做到这一点。下面的输入菜单会解决这个问题:
Input Menu
玩家的移动
处理玩家输入的主要焦点是将字符串输入转换成数字映射。对于 Python 中的传统游戏石头剪子布，我们接受以下输入招式。
# Player Input
inp = input("Enter your move : ")
if inp.lower() == "help":
clear()
rps_instructions()
continue
elif inp.lower() == "exit":
clear()
break
elif inp.lower() == "rock":
player_move = 0
elif inp.lower() == "paper":
player_move = 1
elif inp.lower() == "scissors":
player_move = 2
else:
clear()
print("Wrong Input!!")
rps_instructions()
continue
我们可以使用 if-elif-else 语句有条件地执行检查。
管理计算机移动
为了管理公正的计算机移动，我们需要借助 Python 的'random'库。我们从可能的选项中选择一个随机的移动。
# Get the computer move randomly
comp_move = random.randint(0, 2)
# Print the computer move
print("Computer chooses ", game_map[comp_move].upper())
使用随机库的'randint()'功能，我们为计算机选择一个随机移动。
决定并宣布获胜者
利用输赢矩阵，我们可以很容易地选出赢家。
# Find the winner of the match
winner = rps_table[player_move][comp_move]
# Declare the winner
if winner == player_move:
print(name, "WINS!!!")
elif winner == comp_move:
print("COMPUTER WINS!!!")
else:
print("TIE GAME")
print()
time.sleep(2)
clear()
我们使用'sleep()'函数来暂停 Python 脚本的执行。在上面的例子中，脚本等待了 2 秒钟。
这总结了运行石头剪子布游戏的 Python 脚本的解释。
Python 中石头剪刀布的完整代码
下面是我们用 Python 写的石头剪刀布游戏的完整代码。
import random
import os
import time
def clear():
os.system("clear")
# Set of instructions for Rock-Paper-Scissors
def rps_instructions():
print()
print("Instructions for Rock-Paper-Scissors : ")
print()
print("Rock crushes Scissors")
print("Scissors cuts Paper")
print("Paper covers Rock")
print()
# Set of instructions for Rock-Paper-Scissors-Lizard-Spock
def rpsls_instructions():
print()
print("Instructions for Rock-Paper-Scissors-Lizard-Spock : ")
print()
print("Scissors cuts Paper")
print("Paper covers Rock")
print("Rock crushes Lizard")
print("Lizard poisons Spock")
print("Spock smashes Scissors")
print("Scissors decapitates Lizard")
print("Lizard eats Paper")
print("Paper disproves Spock")
print("Spock vaporizes Rock")
print("Rock crushes Scissors")
print()
def rps():
global rps_table
global game_map
global name
# Game Loop for each game of Rock-Paper-Scissors
while True:
print("--------------------------------------")
print("\t\tMenu")
print("--------------------------------------")
print("Enter \"help\" for instructions")
print("Enter \"Rock\",\"Paper\",\"Scissors\" to play")
print("Enter \"exit\" to quit")
print("--------------------------------------")
print()
# Player Input
inp = input("Enter your move : ")
if inp.lower() == "help":
clear()
rps_instructions()
continue
elif inp.lower() == "exit":
clear()
break
elif inp.lower() == "rock":
player_move = 0
elif inp.lower() == "paper":
player_move = 1
elif inp.lower() == "scissors":
player_move = 2
else:
clear()
print("Wrong Input!!")
rps_instructions()
continue
print("Computer making a move....")
print()
time.sleep(2)
# Get the computer move randomly
comp_move = random.randint(0, 2)
# Print the computer move
print("Computer chooses ", game_map[comp_move].upper())
# Find the winner of the match
winner = rps_table[player_move][comp_move]
# Declare the winner
if winner == player_move:
print(name, "WINS!!!")
elif winner == comp_move:
print("COMPUTER WINS!!!")
else:
print("TIE GAME")
print()
time.sleep(2)
clear()
def rpsls():
global rpsls_table
global game_map
global name
# Game Loop for each game of Rock-Paper-Scissors-Lizard-Spock
while True:
print("--------------------------------------")
print("\t\tMenu")
print("--------------------------------------")
print("Enter \"help\" for instructions")
print("Enter \"Rock\",\"Paper\",\"Scissors\",\"Lizard\",\"Spock\" to play")
print("Enter \"exit\" to quit")
print("--------------------------------------")
print()
# Player Input
inp = input("Enter your move : ")
if inp.lower() == "help":
clear()
rpsls_instructions()
continue
elif inp.lower() == "exit":
clear()
break
elif inp.lower() == "rock":
player_move = 0
elif inp.lower() == "paper":
player_move = 1
elif inp.lower() == "scissors":
player_move = 2
elif inp.lower() == "lizard":
player_move = 3
elif inp.lower() == "spock":
player_move = 4
else:
clear()
print("Wrong Input!!")
rps_instructions()
continue
print("Computer making a move....")
comp_move = random.randint(0, 4)
print()
time.sleep(2)
print("Computer chooses ", game_map[comp_move].upper())
winner = rpsls_table[player_move][comp_move]
print()
if winner == player_move:
print(name, "WINS!!!")
elif winner == comp_move:
print("COMPUTER WINS!!!")
else:
print("TIE GAME")
print()
time.sleep(2)
clear()
# The main function
if __name__ == '__main__':
# The mapping between moves and numbers
game_map = {0:"rock", 1:"paper", 2:"scissors", 3:"lizard", 4:"Spock"}
# Win-lose matrix for traditional game
rps_table = [[-1, 1, 0], [1, -1, 2], [0, 2, -1]]
# Win-lose matrix for new version of the game
rpsls_table = [[-1, 1, 0, 0, 4],[1, -1, 2, 3, 1], [0, 2, -1, 2, 4], [0, 3, 2, -1, 3], [4, 1, 4, 3, -1]]
name = input("Enter your name: ")
# The GAME LOOP
while True:
# The Game Menu
print()
print("Let's Play!!!")
print("Which version of Rock-Paper-Scissors?")
print("Enter 1 to play Rock-Paper-Scissors")
print("Enter 2 to play Rock-Paper-Scissors-Lizard-Spock")
print("Enter 3 to quit")
print()
# Try block to handle the player choice
try:
choice = int(input("Enter your choice = "))
except ValueError:
clear()
print("Wrong Choice")
continue
# Play the traditional version of the game
if choice == 1:
rps()
# Play the new version of the game
elif choice == 2:
rpsls()
# Quit the GAME LOOP
elif choice == 3:
break
# Other wrong input
else:
clear()
print("Wrong choice. Read instructions carefully.")
结论
如果程序员知道游戏逻辑和设计的基本原理，创建一个游戏并不是一个困难的过程。我们希望这篇文章能让读者意识到开发一个简单的基于终端的游戏的上述原则。工作代码也在我的 Github 账户里。
感谢您的阅读。如有任何疑问，欢迎在评论区联系我们。
Python 中按角度旋转图像的两种方法
原文：https://www.askpython.com/python/examples/rotate-an-image-by-an-angle-in-python
嘿，伙计们！在这篇文章中，我们将揭示用 Python 将图像旋转一个角度的方法。
通过旋转图像，我们的意思是图像被其中心旋转到指定的角度。
技术 1: Python 图像库(PIL)
PIL -- Python Image Library是一个包含内置函数的模块，用于操作和处理作为函数输入的图像。
在 Python 中，PIL 提供了内置的image.rotate(angle) function来将图像旋转一个角度。
语法:
image.rotate(angle)
为了加载图像或将图像传递给 rotate()函数，我们需要使用下面的代码片段:
Image.open(r"URL of the image")
我们需要使用下面的代码片段来显示图像:
image.show()
例 1:
from PIL import Image
img = Image.open(r"C:\Users\HP\OneDrive\Desktop\Penskull Education.png")
rotate_img= img.rotate(125)
rotate_img.show()
在上面的代码片段中，我们将输入图像旋转了 125 度。
输入图像:
Input Image
输出:
125 degree – rotation
例 2:
from PIL import Image
img = Image.open(r"C:\Users\HP\OneDrive\Desktop\Penskull Education -- 01.png")
rotate_img= img.rotate(45)
rotate_img.show()
在本例中，图像旋转了 45 度。
输出:
45 degree – rotation
技术 2: OpenCV 在 Python 中将图像旋转一个角度
Python OpenCV是一个处理与计算机视觉相关的实时应用的模块。它包含大量的内置函数来处理用户输入的图像。
OpenCV 与另一个名为“imutils”的图像处理库配合得很好，可以操作和处理图像。
在 Python 中,imutils.rotate() function用于将图像旋转一个角度
语法:
imutils.rotate(image, angle=angle)
语法:使用 OpenCV 读取图像作为输入
cv2.imread(r"image path/URL")
语法:使用 OpenCV 显示图像
cv2.imshow("output--msg",image)
举例:
import cv2
import imutils
image = cv2.imread(r"C:\Users\HP\OneDrive\Desktop\Penskull Education.png")
rot = imutils.rotate(image, angle=45)
cv2.imshow("Rotated", rot)
cv2.waitKey(0)
输出:
Rotation Using OpenCV
结论
因此，在本文中，我们讨论了使用不同的库在 Python 中将输入图像旋转一个角度的各种方法。
我强烈建议读者在 Python 中浏览裁剪图像，以了解更多关于 Python 中可用于操作图像的功能。
参考
Python 中旋转列表的 4 种简单方法
原文：https://www.askpython.com/python/examples/rotate-lists-in-python
嘿伙计们！在今天的教程中，我们将学习如何使用 python 编程语言旋转列表。列表旋转是一种简单的方法，对程序员很有帮助。让我们回顾一下实现旋转的各种选择。
Python 中的旋转列表
现在让我们来理解如何在 Python 中旋转列表。我们将在下面看看多种不同的方法。
方法 1:切片操作
旋转列表的另一种方法是切片。这个 len()方法就是用来做这个的。在下面的示例中，列表被切片。
在这种情况下，n_splits的值为 1，表示切片的数量。因此，列表以相同的方式循环。
# Define the list
list_1 = [1,2,3,4,5]
print("Original list:", list_1)
# Set the number of splits
n_splits = 1
# Rotate The List
list_1 = (list_1[len(list_1) - n_splits:len(list_1)] + list_1[0:len(list_1) - n_splits])
print("Rotated list:", list_1)
Original list: [1, 2, 3, 4, 5]
Rotated list: [5, 1, 2, 3, 4]
方法 2:遍历操作
这是在 Python 中旋转列表最简单的方法。顾名思义，我们逐一查看列表。然后将元素放置在其正确的位置。
下面的示例演示了这种策略。在这种情况下，我们将列表旋转整数 n，即 1。
def ROTATE (lists, n):
output_list = []
x= len(lists)
for item in range(x - n, x):
output_list.append(lists[item])
for item in range(0, x - n):
output_list.append(lists[item])
return output_list
rotate_num = 1
list_1 = [1, 2, 3, 4, 5]
print("Original List:", list_1)
print("Rotated list: ",ROTATE(list_1, rotate_num))
Original List: [1, 2, 3, 4, 5]
Rotated list: [5, 1, 2, 3, 4]
方法三:列出理解
在这种方法中，我们通过在旋转后给每个元素重新分配一个新的索引来修改列表的索引。在下面的示例中，列表旋转一次，并分配新的索引值。
list_1 = [1, 2, 3, 4, 5]
print ("Original List : " + str(list_1))
list_1 = [list_1[(i + 4) % len(list_1)] for i, x in enumerate(list_1)]
print ("Rotated list : " + str(list_1))
Original List : [1, 2, 3, 4, 5]
Rotated list : [5, 1, 2, 3, 4]
方法 4:使用集合模块
Python 中有一个collection模块，它有一个deque类。这个类包含一个 rotate()方法。
在下面的例子中，我们利用了内置函数rotate()。
from collections import deque
list_1 = [1, 2, 3, 4, 5]
print ("Original List : " + str(list_1))
list_1 = deque(list_1)
list_1.rotate(-4)
list_1 = list(list_1)
print ("Rotated List: " + str(list_1))
Original List : [1, 2, 3, 4, 5]
Rotated List: [5, 1, 2, 3, 4]
结论
恭喜你！您刚刚学习了如何使用多种方法对列表执行旋转。希望你喜欢它！😇
喜欢这个教程吗？无论如何，我建议你看一下下面提到的教程:
感谢您抽出时间！希望你学到了新的东西！！😄
在 Python Matplotlib 中旋转刻度标注
原文：https://www.askpython.com/python-modules/matplotlib/rotate-tick-labels
嘿伙计们！本文将向您展示如何在 Python 中旋转 Matplotlib 图中的刻度标签。
刻度是代表轴上的数据点的值。Matplotlib 自动标记轴上的数据点，但它也允许我们用自己的刻度和刻度标签创建自己的轴。
旋转 Matplotlib 中的刻度标签
我们首先创建一个法线图，在本教程中，我们将使用一些随机的 x 角度构建正弦图，并将 x 值的正弦值绘制为 y 值。
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('seaborn')
x = [0, 90, 180, 270, 360]
y = np.sin(x)
plt.plot(x,y)
plt.show()
Normal Plot Rotate Ticks Matplotlib
将刻度旋转 45 度
让我们看看如何旋转 x 轴和 y 轴。为了修改图表中的轴水平，我们使用了xticks()和yticks()。在这种情况下，两者都用于独立调整轴。
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('seaborn')
x = [0, 90, 180, 270, 360]
y = np.sin(x)
plt.plot(x,y)
plt.xticks(rotation = 45)
plt.yticks(rotation = 45)
plt.show()
Rotated Ticks Plot Matplotlib
正如您在上面可能注意到的，两个轴上的刻度标签(数字)现在倾斜到 45 度。你可以摆弄这个数字，让它们更倾斜。
将门票旋转 90 度
旋转刻度的另一种方法是使用gca()和tick params()同时旋转两个轴，而不使用单独的语句。
x = [0, 90, 180, 270, 360]
y = num.sin(x)
plt.plot(x,y)
ln = plt.gca()
ln.tick_params(axis='both', labelrotation = 90)
plt.show()
Rotated Ticks Plot Method2 Matplotlib
结论
恭喜你！您刚刚学习了如何使用两种不同的方法旋转 matplotlib 图中的刻度标签。希望你喜欢它！😇
喜欢这个教程吗？无论如何，我建议你看一下下面提到的教程:
感谢您抽出时间！希望你学到了新的东西！！😄
Python 中数据结构的运行时复杂性
原文：https://www.askpython.com/python/examples/runtime-complexities-of-data-structures
在本文中，我们将探讨与编程算法相关的不同类型的运行时复杂性。我们将着眼于时间和空间的复杂性，不同的案例场景，以及特定的时间复杂性。我们还将研究不同 python 操作的时间复杂性。
编程中的运行时复杂性是什么意思？
当应用算法时，每个数据结构执行各种各样的动作。像遍历一组元素、在组中的某个位置添加一个项目、删除、更新或生成一个元素或整个组的克隆等操作。这些操作只是一些基本的常规操作。我们在编程中使用的所有类型的数据结构都对应用程序的性能有重大影响。这是因为数据结构操作过程具有不同的时间和空间复杂性。
1.空间的复杂性
术语“空间复杂度”表示一个算法可以占用的大小或存储空间的数量。它包括辅助空间以及由作为输入提供的数据占用的空间。算法需要的额外空间或非永久空间称为辅助空间。
关于输入大小的算法所消耗的总空间称为其空间复杂度。
2.时间的复杂性
当操作占用的时间可以通过测量来知道完成期望的过程需要多长时间时，就被称为时间复杂度。它通常被表示为“O”或 Big-O 符号化，用于量化时间复杂度。计算流程能力的方法依赖于输入的大小，称为“O”或 Big-O 符号。
根据输入的大小计算运算效率的方法称为 Big-O 表示法。
类型:
在这里，我们将讨论不同类型的运行时复杂性:
常数时间或 O(1)
我们要研究的第一个复杂性是这个。在算法占用与输入元素无关的时间的点上，该算法被表示为 O(1)或常数时间(n)。
这里，完成一个动作所花费的时间是一致的，与输入集合的大小无关。这意味着不管处理多少个输入分量，算法的操作程序都将持续花费相等的时间。例如，读取一个序列的第一个成员总是 O(1)，不管这个序列有多大。
对数时间或 O(log n)
我们要研究的第二个复杂性是这种类型的过程，其中作为输入提供的数据随着过程的每个阶段而减少，这里讨论的算法具有对数时间复杂性。一般来说，O(log n)过程涉及像二叉树和二分搜索法这样的算法。
线性时间或 O(n)
我们将评估的第三个过程是，当算法所用的时间与作为输入提供的数据量之间存在直接的线性关系时，它具有线性时间复杂度。在这个特定的场景中，算法需要评估输入数据中的所有对象，这是最合适的时间复杂度。
准线性时间或(n log n)
在这种情况下，输入元素也具有对数时间复杂度，但是各个过程被分成几个部分。像合并排序、tim 排序或堆排序这样的排序操作是最佳排序算法的几个例子。作为输入提供的数据被分成许多子列表，直到单个元素留在每个子列表中，然后这些子列表被合并成一个有组织的列表。结果时间复杂度为 O (nlogn)。
二次时间或 O(n^2)
第五个和第六个过程在性质上相似，但在程度上非常不同。这里操作所花费的时间与作为组中存在的输入而提供的数据的平方相当，因此该过程的时间复杂度是二次的。当算法需要对输入数据的每个元素执行线性时间运算时，时间复杂度依赖于元素的平方。例如，O(n2)发生在冒泡排序中。
【指数时间】或【o(2^n】
当算法的扩展随着对输入数据集的每一次添加而加倍时，它被认为具有指数时间复杂度。在第六个过程中，算法的扩展随着对输入数据组的每次累加而加倍，并且其时间复杂度被表示为指数。众所周知，强力方法具有这种程度的时间复杂度。例如，我们可以在斐波纳契数的递归计算中找到 O(2 n)时间复杂度。
阶乘时间(n！)
我们要查看的最后一个过程是计算一个操作中每个可能的变化所花费的时间，它是输入集合中对象大小的阶乘，因此这个过程被表示为 an (n！)复杂。例如，堆的算法计算 n 个对象的所有可能的变化。所有的算法在性能上都非常慢，具有 O(n！)时间复杂度。
Runtime Complexities
数据结构时间复杂性中的事例类型:
最佳情况场景: 最佳情况场景:我们在最佳情况研究中确定算法执行时间的下一圈。当组中的数据结构和对象(除了参数之外)处于最佳水平时，最佳情况就会发生。因此，只进行小规模操作。在线性搜索中，例如，最好的情况可能是 x(被搜索的对象)出现在列表的顶部。在最好的情况下，动作的数量保持不变(不依赖于输入元素的数量)。因此，在这种情况下，它的时间复杂度为 O(1)。
一般情况场景:当我们将复杂性描述为依赖于作为输入提供的数据以及它的分布有多均匀时，就会出现这种情况。我们考虑所有潜在的输入，并计算在平均情况分析中计算所有输入所需的时间。要找出答案，只需将输入数除以所有计算值的乘积。
最坏情况:涉及定位一个项目的过程，该项目被定位为一个大尺寸组中的最后一个项目，例如一个列表，算法从第一个项目开始在整个组中迭代。例如，当 x 不在列表中时，类似线性搜索的算法，迭代将 x 与所有条目进行比较。这将导致运行时间为 O(n)。
python 中不同数据结构的时间复杂度:
Complexity Of Sets
Most dictionary operations are O(1)
结论
希望这篇文章能帮助你理解不同的时间复杂度，以及哪种 python 数据结构占用什么时间复杂度。理解了复杂性的基本概念后，现在你可以发现数据结构的时间复杂性，并观察一系列操作中的复杂性。
使用谷歌地球引擎和 Python 的卫星图像
原文：https://www.askpython.com/python/examples/satellite-imagery-google-earth
在本文中，我们将学习如何使用 Python 来处理卫星影像并使其可视化。本教程是对地理空间分析世界的粗略介绍。它是为至少对 python 有初级知识的人准备的。
使用 Python 中的 Google Earth 引擎的卫星图像
谷歌地球引擎是卫星图像和计算的最佳来源之一。这是一个科学分析和地理空间数据集可视化的平台，面向学术、非营利、商业和政府用户。Earth Engine 托管卫星图像，并将其存储在公共数据档案中，其中包括四十多年前的历史地球图像。
谷歌提供了一个 API，通过很少的代码就可以很容易地与地球引擎通信，这很好。该 API 被创建为与 JavaScript API 有相似之处，并且不是很 pythonic 化。因此，在第一次浏览 API 时，您可能会遇到一些小困难。
1.安装 ee 库
注意:Google earthengine-api 已经安装在 Colab 环境中。因此，如果您使用 Google Colab 平台运行 python，您可以安全地跳过这一步。
如果您在本地机器上运行，您需要首先在本地机器上安装 earthengine-api。安装 earthengine-api 的 pip 命令是:
pip install earthengine-api --upgrade
2.导入和验证您自己
# Import the earth-engine module
import ee
目前只有注册用户可以访问谷歌地球引擎。所以你需要注册谷歌地球引擎来使用这项服务。
此外，当您第一次在本地机器上使用 Google earth-engine 时，您需要验证自己是注册用户。
ee.Authenticate()
一般来说，本地安装的身份验证是一次性步骤，它会生成一个持久授权令牌，而 Colab 等 VM 服务会限制令牌的生命周期。
最后，您需要初始化 API。
ee.Initialize()
我们现在已经准备好使用地球引擎 API 了。
3.加载影像数据集
如前所述，地球引擎中有大量的数据集可用。为我们的任务选择正确的数据集非常重要。每个数据集都涵盖了地球的不同方面。例如树木覆盖、水体等。在本教程中，我们将使用 DMSP OLS:夜间灯光时间序列数据集，其中包含不同国家的夜间灯光时间序列数据。
每个数据集都是图像的集合。因此数据集的命名约定是 ImageCollection，我们将在本文的其余部分使用这个命名约定。
# Load the Nighttime Image Collection
collection = ee.ImageCollection('NOAA/DMSP-OLS/NIGHTTIME_LIGHTS')
4.使用图像集合
区别普通照片和卫星图像的最重要的方面是图像的光谱远远超出了正常的 0-255 范围。这些图像具有不同的波段，可以与正常图像的通道(RGB)进行比较。每个波段捕捉不同的电磁波谱。
现在我们来看看图像集合中的每幅图像都有哪些波段:
# Extract the first image
first_image = collection.first()
# Display band information about the image
first_image.bandNames().getInfo()
输出:
['avg_vis', 'stable_lights', 'cf_cvg', 'avg_lights_x_pct']
我们需要stable_lights波段进行可视化。从图像集中的每幅图像中选择一个波段非常耗时，但幸运的是 earth-engine 提供了一种从图像集中选择一个波段的方法。
collection = collection.select('stable_lights')
现在，图像集合中的每个图像都有一个单独的波段。为了可视化随时间的变化，将需要另一个波段来代表时间。
first_image = collection.first()
# Get number of years after 1991 from the first image
year = ee.Date(first_image.get('system:time_start')).get('year').subtract(1991)
# Turn it into a band
img1 = ee.Image(year).byte().addBands(first_image)
# A new band appears in the new image
img1.bandNames().getInfo()
输出:
['constant', 'stable_lights']
我们需要对集合中的每张图片都这样做。因此，我们创建一个函数，并将其映射到集合上。
def createTimeBand(img):
year = ee.Date(img.get('system:time_start')).get('year').subtract(1991)
return ee.Image(year).byte().addBands(img)
# Map it to the collection to create a new collection
collection = collection.map(createTimeBand)
5.想象夜晚的灯光
现在我们已经准备好显示我们的 ImageCollection，我们需要一个 UI 来显示图像。有很多用户界面选项可用，如叶，matplotlib，PIL 等。
在本教程中，我们选择了叶。Folium 是一个基于leafle . js(用于移动友好交互式地图的开源 JavaScript 库)的 python 库，你可以用它来制作交互式地图。Folium 支持 WMS、GeoJSON 图层、矢量图层和切片图层，这使得我们可以非常方便和直接地可视化使用 python 处理的数据。
如果您没有安装 lyum，可以使用以下 pip 命令进行安装:
pip install folium --upgrade
# Import the folium library
import folium
现在我们需要定义如何在 follow 中显示 google earth 图像。这里有一个函数，使用起来非常方便。
# Define a method for displaying Earth Engine image tiles to folium map.
def add_ee_layer(self, ee_image_object, vis_params, name):
map_id_dict = ee.Image(ee_image_object).getMapId(vis_params)
folium.raster_layers.TileLayer(
tiles = map_id_dict['tile_fetcher'].url_format,
attr = 'Map Data © <a href="https://earthengine.google.com/">Google Earth Engine</a>',
name = name,
overlay = True,
control = True
).add_to(self)
# Add EE drawing method to folium.
folium.Map.add_ee_layer = add_ee_layer
现在我们可以创建一个地图，给出初始坐标和缩放因子。如果你理解错了一点也不要担心。Folium 是交互式的，这意味着您可以在可视化地图的同时更改位置和缩放。
# Create the night map
night_map = folium.Map(location=[37.5010, -102.1899], zoom_start=4.5)
我们需要为显示图像设置一些参数，例如每个图像的波段和颜色偏好。这是您可能喜欢的默认设置。
# visualize the y-intercept in green, and positive/negative slopes as red/blue.
params = {
'bands' : ['scale', 'offset', 'scale'],
'min' : 0,
'max' : [0.18, 20, -0.18],
}
在我们观想之前，我们还有最后一步。我们需要使用线性拟合方法来减少图像，该方法计算带有常数项的一元线性函数的最小二乘估计。
night_light = collection.reduce(ee.Reducer.linearFit())
将图像和参数添加到地图并显示地图。
# Add the image layer to the night_map
night_map.add_ee_layer(night_light, params, 'test')
# Display the map
display(map)
Fig 1: Here is a beautiful representation of change of America night light from 1991
Fig 2: Here is a representation of change of night light in India and parts of south Asia since 1991
Fig 3: Change of night lights in the European countries
结论
关于使用谷歌地球引擎可视化夜间光线变化的文章，我们已经到了最后。下一步，您可以尝试使用不同的波段，甚至不同的数据集。如果你看得更远，谷歌已经推出了许多其他教程，如检测哨兵 1 号图像的变化，让你开始更深入的地理空间分析方法。
用 Python 保存数据的最佳方式
原文：https://www.askpython.com/python/examples/save-data-in-python
读者你好！在本教程中，我们将讨论如何在 Python 中有效地保存数据。
如何在 Python 中保存数据？
当我们开发 Python 应用程序时，我们将直接处理 Python 对象，因为在 Python 中，一切都是一个对象。让我们看看一些可以轻松存放它们的方法吧！
1.使用 Pickle 存储 Python 对象
如果我们想让事情变得简单，我们可以使用 pickle 模块，它是 Python 中保存数据的标准库的一部分。
我们可以将 Python 对象“pickle”成 pickle 文件，我们可以用它来保存/加载数据。
因此，如果您有一个可能需要存储/检索的自定义对象，您可以使用以下格式:
import pickle
class MyClass():
def __init__(self, param):
self.param = param
def save_object(obj):
try:
with open("data.pickle", "wb") as f:
pickle.dump(obj, f, protocol=pickle.HIGHEST_PROTOCOL)
except Exception as ex:
print("Error during pickling object (Possibly unsupported):", ex)
obj = MyClass(10)
save_object(obj)
如果您运行这个脚本，您会注意到一个名为data.pickle的文件，其中包含保存的数据。
为了再次加载相同的对象，我们可以使用类似的逻辑使用pickle.load()。
import pickle
class MyClass():
def __init__(self, param):
self.param = param
def load_object(filename):
try:
with open(filename, "rb") as f:
return pickle.load(f)
except Exception as ex:
print("Error during unpickling object (Possibly unsupported):", ex)
obj = load_object("data.pickle")
print(obj.param)
print(isinstance(obj, MyClass))
输出
10
True
我们刚刚成功检索了我们的旧数据！
2.使用 Sqlite3 在 Python 中持久保存数据
如果您想使用持久性数据库来保存 Python 中的数据，您可以使用sqlite3库，它为您提供了使用 Sqlite 数据库的 API。
再说一次，这是标准库的一部分，所以不需要 pip 安装任何东西！
但是，由于这是一个关系数据库，所以不能像在pickle中那样直接转储 Python 对象。
您必须将它们序列化和反序列化为适当的数据库类型。
要看一些例子，你可以参考这篇关于在 Python 中使用 sqlite 的文章。
3.使用 SqliteDict 作为持久缓存
如果你觉得使用sqlite3太乏味，有一个更好的解决方案！您可以使用sqlitedict来存储持久数据，这在内部使用了一个sqlite3数据库来处理存储。
您必须使用 pip 安装这个软件包:
pip install sqlitedict
您唯一需要记住的是，您需要使用key:value映射来存储/检索数据，就像字典一样！
这里有一个非常简单的使用MyClass实例的例子。
from sqlitedict import SqliteDict
class MyClass():
def __init__(self, param):
self.param = param
def save(key, value, cache_file="cache.sqlite3"):
try:
with SqliteDict(cache_file) as mydict:
mydict[key] = value # Using dict[key] to store
mydict.commit() # Need to commit() to actually flush the data
except Exception as ex:
print("Error during storing data (Possibly unsupported):", ex)
def load(key, cache_file="cache.sqlite3"):
try:
with SqliteDict(cache_file) as mydict:
value = mydict[key] # No need to use commit(), since we are only loading data!
return value
except Exception as ex:
print("Error during loading data:", ex)
obj1 = MyClass(10)
save("MyClass_key", obj1)
obj2 = load("MyClass_key")
print(obj1.param, obj2.param)
print(isinstance(obj1, MyClass), isinstance(obj2, MyClass))
输出
10 10
True True
事实上，我们刚刚成功地加载了 Python 对象！如果你注意到了，sqlitedict会自动创建一个数据库cache.sqlite3，如果它不存在，然后用它来存储/加载数据。
结论
在本文中，我们研究了如何使用 Python 以不同的方式存储数据。
如何在 Python 中将一个数据帧保存为 csv 文件？
原文：https://www.askpython.com/python-modules/pandas/save-dataframe-as-csv-file
大家好！在本文中，我们将关注于将数据帧保存为 CSV(逗号分隔值)文件的技术。
让我们开始吧！
什么是 Python 熊猫模块？
Python 有许多来处理数据并提供不同的功能。
Python Pandas 模块帮助我们处理数据集方面的大量数据。因此，通过使用 Pandas 模块，我们可以操纵和处理大型数据集的数据值。
Pandas 以数据帧的形式处理数据值和元素。一个DataFrame 由可以改变和突出显示的行和列组成。
所以，现在让我们来关注在 Pandas 模块中创建一个数据帧。
用 Python 创建数据帧
看看下面的代码吧！
import os
import pandas
Domain = ["IT", "DATA_SCIENCE", "NETWORKING"]
domain_dict = {'Domain': Domain}
data_frame = pandas.DataFrame(domain_dict)
因此，我们使用pandas.DataFrame() function从传递的数据值中以字典的形式创建一个数据帧，如上所示。
输出:
Domain
0 IT
1 DATA_SCIENCE
2 NETWORKING
创建数据帧后，现在是将数据帧保存为 CSV 文件的时候了。看看下面的部分。
将数据帧保存为 CSV 文件
我们经常会遇到这样的情况，我们需要以一种简单、易读、可共享的形式保存废弃或分析产生的大量数据。
现在，我们可以将数据帧保存到一个 csv 文件中，如下所述。
语法:
dataframe.to_csv('file.csv')
pandas.to_csv() function使我们能够将数据帧保存为 CSV 文件。我们需要将文件名作为参数传递给函数。
让我们看看下面的例子。
import pandas
Domain = ["IT", "DATA_SCIENCE", "NEYWORKING"]
domain_dict = {'Domain': Domain}
data_frame = pandas.DataFrame(domain_dict)
data_frame.to_csv('DEMO.csv')
输出:
DEMO -csv File
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
在那之前，学习愉快！！
如何存进去？npy 格式？
原文：https://www.askpython.com/python-modules/numpy/save-in-npy-format
遇到过. npy 文件吗？在这篇文章中，我们将回顾保存为 npy 格式的步骤。NPY 是 Numpy 的二进制数据存储格式。
Numpy 是高效执行数据科学操作的必备模块。数据的导入、保存和处理占据了数据科学领域的大部分时间。在导入和导出数据时，CSV 文件是一个不错的选择。
但是，有时您需要保存数据，以便在 Python 中再次使用。对于这种情况，Numpy 提供了。npy 格式。
导入和导出数据。与其他选项相比，npy 文件更有效。
Numpy 提供了 numpy.save() 方法，允许您将文件保存到。npy 格式。它只允许您保存数组格式的数据。它在保存之前将数组转换为二进制文件。最终保存的是这个二进制文件。
在本教程中，我们将使用 numpy 数组并保存在。npy 格式。接下来我们还将导入该文件。
让我们开始吧。
使用 Numpy save()以 npy 格式保存
让我们从创建一个示例数组开始。
import numpy as np
arr = np.arange(10)
print("arr :)
print(arr)
将此数组保存到。npy 文件，我们将使用。Numpy 中的 save()方法。
np.save('ask_python', arr)
print("Your array has been saved to ask_python.npy")
运行这行代码会将数组保存到一个名为 'ask_python.npy' 的二进制文件中。
输出:
arr:
[0 1 2 3 4 5 6 7 8 9 10]
Your array has been saved to ask_python.npy
进口。Python 中的 npy 文件
为了将数据加载回 python，我们将使用。Numpy 下的 load()方法。
data = np.load('ask_python.npy')
print("The data is:")
print(data)
输出结果如下:
The data is:
[0 1 2 3 4 5 6 7 8 9 10]
结论
本教程是关于将 Python 中数组的数据保存到. npy 二进制文件中，并将其加载回 Python。希望你和我们一起学习愉快！
使用 TensorFlow 2.0+保存和加载模型
原文：https://www.askpython.com/python-modules/saving-loading-models-tensorflow
在本文中，我们将讨论使用 TensorFlow 2.0+保存加载模型。这是一篇初级到中级水平的文章，面向刚刚开始使用 TensorFlow 进行深度学习项目的人。
为什么需要保存模型？
作为深度学习的初学者，人们最常犯的一个错误是不保存他们的模型。
在训练期间和训练之后保存深度学习模型是一个很好的做法。它可以节省您的时间，并提高模型的可重复性。以下是您可能会考虑保存模型的几个原因:
- 用数百万个参数和庞大的数据集训练现代深度学习模型在计算和时间方面可能是昂贵的。而且，在不同的训练过程中，你可以得到不同的结果/准确度。因此，使用保存的模型来展示您的结果总是一个好主意，而不是在现场进行培训。
- 保存同一个模型的不同版本可以让你检查和理解模型的工作。
- 您可以在支持 TensorFlow 的不同语言和平台中使用相同的编译模型，例如:TensorFlow Lite 和 TensorFlow JS，而无需转换任何代码。
TensorFlow 恰好提供了许多保存模型的方法。我们将在接下来的几节中详细讨论它们。
培训时如何保存模型？
有时在模型训练期间保存模型权重是很重要的。如果在某个时期后结果出现异常，使用检查点可以更容易地检查模型以前的状态，甚至恢复它们。
使用Model.train()函数训练张量流模型。我们需要使用tf.keras.callbacks.ModelCheckpoint()定义一个模型检查点回调，告诉编译器在特定的时期间隔保存模型权重。
回调听起来很难，但就用法而言并不难。这里有一个使用它的例子。
# This is the initialization block of code
# Not important for understanding the saving
# But to execute the next cells containing the code
# for saving and loading
import tensorflow as tf
from tensorflow import keras
# We define a dummy sequential model.
# This function to create a model will be used throughout the article
def create_model():
model = tf.keras.models.Sequential([
keras.layers.Dense(512, activation='relu', input_shape=(784,)),
keras.layers.Dropout(0.2),
keras.layers.Dense(10)
])
model.compile(optimizer='adam',
loss=tf.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=[tf.metrics.SparseCategoricalAccuracy()])
return model
# Create a basic model instance
model = create_model()
# Get the dataset
(train_images, train_labels), (test_images, test_labels) = tf.keras.datasets.mnist.load_data()
train_labels = train_labels[:1000]
test_labels = test_labels[:1000]
train_images = train_images[:1000].reshape(-1, 28 * 28) / 255.0
test_images = test_images[:1000].reshape(-1, 28 * 28) / 255.0
# Create a new model using the function
model = create_model()
# Specify the checkpoint file
# We use the str.format() for naming files according to epoch
checkpoint_path = "training_2/cp-{epoch:04d}.ckpt"
# Get the directory of checkpoint
checkpoint_dir = os.path.dirname(checkpoint_path)
# Define the batch size
batch_size = 32
# Create a callback that saves the model's weights every 5 epochs
cp_callback = tf.keras.callbacks.ModelCheckpoint(
filepath=checkpoint_path,
verbose=1,
save_weights_only=True,
save_freq=5*batch_size)
# Save the weights using the `checkpoint_path` format
model.save_weights(checkpoint_path.format(epoch=0))
# Train the model with the the checkpoint callback
model.fit(train_images, train_labels,
epochs=50,
batch_size=batch_size,
callbacks=[cp_callback],
verbose=0)
从检查点加载
如果您想要恢复您创建的检查点，您可以使用模型，您可以使用model.load_weights()功能。
下面是加载权重的语法和示例。
# Syntax
model.load_weights("<path the checkpoint file(*.cpt)>")
# Example
# Finds the latest checkpoint
latest = tf.train.latest_checkpoint(checkpoint_dir)
# Create a new model
model = create_model()
# Load the weights of the latest checkpoint
model.load_weights(latest)
保存已训练模型的权重
模型也可以在训练后保存。该过程相对来说比训练期间的检查点简单得多。
为了在模型被训练之后保存权重文件，我们使用 Model.save_weights()函数。使用它的示例如下:
# Save the weights
model.save_weights('./checkpoints/my_checkpoint')
# Create a new model instance
model = create_model()
# Restore the weights
model.load_weights('./checkpoints/my_checkpoint')
加载已训练模型的权重
要从权重加载模型，我们可以像加载检查点权重一样使用Model.load_weights()。事实上，权重存储为一个检查点文件。
# Restore the weights
model.load_weights('./checkpoints/my_checkpoint')
保存和加载整个模型
在上一节中，我们看到了如何保存模型的权重。这有一定的问题。在将模型权重加载到模型之前，必须定义模型。实际模型和要加载权重的模型之间的任何结构差异都会导致错误。
此外，当我们想要跨不同平台使用模型时，这种节省权重的方法变得很困难。例如，您希望在使用 TensorFlow JS 的浏览器中使用 python 中训练的模型。
在这种情况下，您可能需要保存整个模型，即结构和重量。TensorFlow 允许您使用函数Model.save()保存模型。这里有一个这样做的例子。
# Save the whole model in SaveModel format
model.save('my_model')
TensorFlow 还允许用户使用 HDF5 格式保存模型。要以 HDF5 格式保存模型，只需使用 hdf5 扩展名提及文件名。
# Save the model in hdf5 format
# The .h5 extension indicates that the model is to be saved in the hdf5 extension.
model.save('my_model.h5')
注:HDF5 在 TensorFlow 中成为主流之前，最初由 Keras 使用。TensorFlow 使用 SaveModel 格式，并且总是建议使用推荐的较新格式。
您可以使用tf.keras.models.load_model()加载这些保存的模型。该函数自动截取模型是以 SaveModel 格式保存还是以 hdf5 格式保存。下面是一个这样做的示例:
# For both hdf5 format and SaveModel format use the appropriate path to the file
# SaveModel Format
loaded_model = tf.keras.models.load_model('my_model')
# HDF5 format
loaded_model = tf.keras.models.load_model('my_model.h5')
结论
这就把我们带到了教程的结尾。希望您现在可以在培训过程中保存和加载模型。敬请关注，了解更多关于深度学习框架的信息，如 PyTorch、TensorFlow 和 JAX。
Python Tkinter:简单的节省计算器
原文：https://www.askpython.com/python-modules/tkinter/savings-calculator
你好，初学者！今天让我们使用 Python Tkinter 模块来构建一个简单的 GUI 节省计算器。
该应用程序接受一个人的工资以及一些支出，如旅行、食品和杂项。该应用程序将确定节省了我的人。
要创建一个应用程序，我们需要做以下事情:
- 导入必要的库，在我们的例子中是
tkinter库 - 创建主窗口
- 向主窗口添加任意数量的小部件(按钮、条目和标签)
- 将事件功能应用于按钮
用 Python 设计节约计算器
应用程序的设计包括创建和配置主窗口。它还包括在屏幕上添加所有必要的小部件。
相同的代码如下所示。
import tkinter as tk
window = tk.Tk()
window.geometry("300x400")
window.config(bg="#F39C12")
window.resizable(width=False,height=False)
window.title('Savings Calculator')
l1 = tk.Label(window,text="Enter the Values",font=("Arial",20),fg="Black",bg="White")
l2 = tk.Label(window,text="Total Salary:",font=("Arial",10),fg="Black",bg="White")
e1 = tk.Entry(window,font=("Arial",11))
l3 = tk.Label(window,text="Travel:",font=("Arial",10),fg="Black",bg="White")
e2 = tk.Entry(window,font=("Arial",11))
l4 = tk.Label(window,text="Food:",font=("Arial",10),fg="Black",bg="White")
e3 = tk.Entry(window,font=("Arial",11))
l5 = tk.Label(window,text="Miscellaneous:",font=("Arial",10),fg="Black",bg="White")
e4 = tk.Entry(window,font=("Arial",11))
b1 = tk.Button(window,text="Calculate Savings",font=("Arial",15))
l6 = tk.Label(window,text="Your Savings:",font=("Arial",10),fg="Black",bg="White")
e5 = tk.Entry(window,font=("Arial",11),state='disabled')
b2 = tk.Button(window,text="Clear Values",font=("Arial",15))
b3 = tk.Button(window,text="Exit Application",font=("Arial",15))
l1.place(x=50,y=20)
l2.place(x=20,y=70)
e1.place(x=120,y=70)
l3.place(x=20,y=100)
e2.place(x=120,y=100)
l4.place(x=20,y=130)
e3.place(x=120,y=130)
l5.place(x=20,y=160)
e4.place(x=120,y=160)
b1.place(x=60,y=200)
l6.place(x=20,y=260)
e5.place(x=120,y=260)
b2.place(x=70,y=300)
b3.place(x=60,y=350)
window.mainloop()
如果您对我们使用的任何小工具有任何问题或疑问，您可以参考这里的教程。应用程序的最终设计如下所示。
Final Design Savings Calculator
向应用程序添加功能
为了增加功能，我们需要同时考虑entry和button小部件。
入口盒的工作
对于每个输入框，我们创建变量来存储输入框的值。为了创建一个变量来存储整数值，我们使用了StringVar函数。
在为每个输入框分配一个唯一的变量后，我们给输入框声明添加一个textvariable属性来连接变量和输入框。
相同的代码如下所示。代码中所做的更改已经为您突出显示。
import tkinter as tk
window = tk.Tk()
window.geometry("300x400")
window.config(bg="#F39C12")
window.resizable(width=False,height=False)
window.title('Savings Calculator')
v1 = tk.StringVar()
v2 = tk.StringVar()
v3 = tk.StringVar()
v4 = tk.StringVar()
v5 = tk.StringVar()
l1 = tk.Label(window,text="Enter the Values",font=("Arial",20),fg="Black",bg="White")
l2 = tk.Label(window,text="Total Salary:",font=("Arial",10),fg="Black",bg="White")
e1 = tk.Entry(window,font=("Arial",11),textvariable=v1)
l3 = tk.Label(window,text="Travel:",font=("Arial",10),fg="Black",bg="White")
e2 = tk.Entry(window,font=("Arial",11),textvariable=v2)
l4 = tk.Label(window,text="Food:",font=("Arial",10),fg="Black",bg="White")
e3 = tk.Entry(window,font=("Arial",11),textvariable=v3)
l5 = tk.Label(window,text="Miscellaneous:",font=("Arial",10),fg="Black",bg="White")
e4 = tk.Entry(window,font=("Arial",11),textvariable=v4)
b1 = tk.Button(window,text="Calculate Savings",font=("Arial",15))
l6 = tk.Label(window,text="Your Savings:",font=("Arial",10),fg="Black",bg="White")
e5 = tk.Entry(window,font=("Arial",11),state='disabled',textvariable=v5)
b2 = tk.Button(window,text="Clear Values",font=("Arial",15))
b3 = tk.Button(window,text="Exit Application",font=("Arial",15))
l1.place(x=50,y=20)
l2.place(x=20,y=70)
e1.place(x=120,y=70)
l3.place(x=20,y=100)
e2.place(x=120,y=100)
l4.place(x=20,y=130)
e3.place(x=120,y=130)
l5.place(x=20,y=160)
e4.place(x=120,y=160)
b1.place(x=60,y=200)
l6.place(x=20,y=260)
e5.place(x=120,y=260)
b2.place(x=70,y=300)
b3.place(x=60,y=350)
window.mainloop()
按钮的工作
在我们的应用程序中，我们有三个按钮。因此，我们将为按钮定义三种不同的功能。所有三种功能的代码定义如下。
def exit():
window.destroy()
def clear_all():
e1.delete(0,tk.END)
e2.delete(0,tk.END)
e3.delete(0,tk.END)
e4.delete(0,tk.END)
e5.config(state='normal')
e5.delete(0,tk.END)
e5.config(state='disabled')
def cal_savings():
e5.config(state='normal')
e5.delete(0,tk.END)
e5.config(state='disabled')
salary = int(e1.get())
total_expenditure = int(e2.get())+int(e3.get())+int(e4.get())
savings = salary - total_expenditure
e5.config(state='normal')
e5.insert(0,savings)
e5.config(state='disabled')
对于第一个函数，我们只需销毁我们创建的窗口。对于第二个功能，我们删除所有输入框的内容。
对于第三个函数，我们将所有支出值相加，并取总工资和支出之间的差值。但在此之前，我们将清除输出输入框，为新值腾出空间。
然后，我们将计算出的值放入输出输入框中。创建函数后，我们将参数command添加到按钮声明中。
这就对了。你都准备好了！
在 Tkinter 中实现节省计算器
下面给出了该应用程序的完整代码。
def exit():
window.destroy()
def clear_all():
e1.delete(0,tk.END)
e2.delete(0,tk.END)
e3.delete(0,tk.END)
e4.delete(0,tk.END)
e5.config(state='normal')
e5.delete(0,tk.END)
e5.config(state='disabled')
def cal_savings():
e5.config(state='normal')
e5.delete(0,tk.END)
e5.config(state='disabled')
salary = int(e1.get())
total_expenditure = int(e2.get())+int(e3.get())+int(e4.get())
savings = salary - total_expenditure
e5.config(state='normal')
e5.insert(0,savings)
e5.config(state='disabled')
import tkinter as tk
window = tk.Tk()
window.geometry("300x400")
window.config(bg="#F39C12")
window.resizable(width=False,height=False)
window.title('Savings Calculator')
v1 = tk.StringVar()
v2 = tk.StringVar()
v3 = tk.StringVar()
v4 = tk.StringVar()
v5 = tk.StringVar()
l1 = tk.Label(window,text="Enter the Values",font=("Arial",20),fg="Black",bg="White")
l2 = tk.Label(window,text="Total Salary:",font=("Arial",10),fg="Black",bg="White")
e1 = tk.Entry(window,font=("Arial",11),textvariable=v1)
l3 = tk.Label(window,text="Travel:",font=("Arial",10),fg="Black",bg="White")
e2 = tk.Entry(window,font=("Arial",11),textvariable=v2)
l4 = tk.Label(window,text="Food:",font=("Arial",10),fg="Black",bg="White")
e3 = tk.Entry(window,font=("Arial",11),textvariable=v3)
l5 = tk.Label(window,text="Miscellaneous:",font=("Arial",10),fg="Black",bg="White")
e4 = tk.Entry(window,font=("Arial",11),textvariable=v4)
b1 = tk.Button(window,text="Calculate Savings",font=("Arial",15),command=cal_savings)
l6 = tk.Label(window,text="Your Savings:",font=("Arial",10),fg="Black",bg="White")
e5 = tk.Entry(window,font=("Arial",11),state='disabled',textvariable=v5)
b2 = tk.Button(window,text="Clear Values",font=("Arial",15),command=clear_all)
b3 = tk.Button(window,text="Exit Application",font=("Arial",15),command=exit)
l1.place(x=50,y=20)
l2.place(x=20,y=70)
e1.place(x=120,y=70)
l3.place(x=20,y=100)
e2.place(x=120,y=100)
l4.place(x=20,y=130)
e3.place(x=120,y=130)
l5.place(x=20,y=160)
e4.place(x=120,y=160)
b1.place(x=60,y=200)
l6.place(x=20,y=260)
e5.place(x=120,y=260)
b2.place(x=70,y=300)
b3.place(x=60,y=350)
window.mainloop()
输出:对应用程序的各种数值进行了测试。其中一些如下所示。
Output1 Salary Calculator
Output2 Salary Calculator
结论
恭喜你！你成功地学会了如何建立自己的工资计算器。希望你喜欢它！
感谢您的阅读！编码快乐！
使用 sched 模块在 Python 中进行调度
先说 Python 中的 sched 模块。在使用 Python 中的 datetime模块时，你一定碰到过一个你希望自己能在 Python 中拥有并使用的特性，那就是调度。
事件调度，一个有目的的调度任务，可用于根据时间或日期的输入来提醒或执行事件。
过去也考虑过调度，因此，我们现在有了可以使用的sched模块。
在本文中，我们将探索该模块的各种用途和用例，但是，为了简单起见，我们将使用time模块。
如果您在使用自己版本的sched模块时发现任何令人困惑的地方，您可能想看看我们关于使用日期时间模块的文章，快速回顾一下日期时间对象。
在 Python 中安装 sched 模块
听到这个消息您可能会感到惊讶，但是，这个模块不需要安装或包管理器，因为它默认出现在 Python 的标准库中。
甚至在文档中也是如此！如果您希望访问它，以便更清楚地了解这些论点和关键词，您可以在本文底部的参考资料中找到链接。
如何使用 sched 模块？
使用 sched 模块的先决条件是对 datetime/time 对象有基本的了解。
如果你以前使用过datetime模块或者只使用过time模块，你可能会很高兴知道sched模块是 datetime 的扩展，很像另一个模块 dateutil 。
1.0 调度程序–导入 sched 模块
作为一个整体，sched模块只包含一个类，如果你想亲自验证一下，这里有源代码。
那么，这对我们意味着什么呢？
简而言之，只有一个类，因此，我们将只创建一个对象，它可以利用 scheduler 类的所有特性。
这个类被称为scheduler。我们可以马上开始，但是在开始之前，我们想先导入模块来使用它。
import sched, time
1.1 如何创建调度程序对象
创建 scheduler 对象非常简单，在导入sched模块后，您只需要写一行代码就可以使用它。
# Intializing s as the scheduler object
s = sched.scheduler(time.time, time.sleep)
这一行代码为您提供了使用时间的time模块的功能，甚至提供了延迟，支持多线程操作。
这实际上创建了一个变量s，它是作为 sched 模块的类scheduler的对象创建的。
1.2 使用调度程序对象
接下来，我们将使用所提供的功能打印出一组时间对象，以及操作本身执行的时间。
在这个小小的片段中，我们正在处理sched模块的核心，创建和输入事件。
就像我们使用线程一样，在sched模块中，我们使用 run 方法来运行所有计划运行的任务。
# Creating a method to print time
def print_time(a="default"):
print("From print_time", time.time(), a)
# Method to print a few times pre-decided
def print_some_times():
print("This is the current time : ", time.time())
# default command to print time
s.enter(10, 1, print_time)
# passing an argument to be printed after the time
s.enter(10, 1, print_time, argument=('positional',))
# passing a keyword argument to print after the time
s.enter(10, 1, print_time, kwargs={'a': 'keyword'})
# runs the scheduler object
s.run()
print("Time at which the program comes to an end: ", time.time())
# Output
# This is the current time : 1609002547.484134
# From print_time 1609002557.4923606 default
# From print_time 1609002557.4923606 positional
# From print_time 1609002557.4923606 keyword
# Time at which the program comes to an end : 1609002557.4923606
需要注意的是调度程序对象使用的run方法。这是一个运行所有预定事件的函数，并且还将根据 delayfunc 参数提供的时间等待。
这更深入地研究了并发和多线程的概念，其中有启动、运行、等待和通知的概念，如果你感兴趣的话，这本书非常有趣。
除此之外，您可能还注意到了一些参数，这些参数是为了展示 print 语句之间的区别而添加的。
1.3 附加功能
确实存在一些我们在这个例子中没有必要研究的函数，包括取消、清空和队列函数。
- cancel 功能用于从队列中删除特定的事件。
- empty 函数用于返回关于队列状态的布尔响应，以及队列是否为空。
- 队列功能按照事件运行的顺序为我们提供了一个可用/即将到来的事件列表。每个事件都有一个由事件细节组成的名为元组的。
结论
正如您所看到的，Python 提供的这个标准模块的门道是相当明显的，并且有可能帮助您开发更多好的特性，作为您代码的补充或框架！
如果您希望将来使用这个模块，那么在编写代码时，请不要犹豫打开这篇文章作为参考。
浏览文档可能是一项令人望而生畏的任务，这就是为什么我们试图用用户友好的文章来帮助你浏览它们。
查看我们关于我们已经介绍过的不同模块的其他文章， datetime ， dateutil ， psutil ，以及我们一直最喜欢的数据科学工具 pandas ！
参考
用 Python 刮 ArXiv 最新论文
原文：https://www.askpython.com/python/examples/scrape-arxiv-papers-python
你好研究员！！你一定听说过研究和收集 ArXiv 文件的任务有多乏味。你猜怎么着？！我们可以在 Python 编程语言的帮助下自动完成任务，并快速轻松地获得相关论文。
今天在本教程中，我们的目标是构建这样一个 python 代码，只需几行代码，我们就可以在几分钟内获得所需的研究论文！我们还在等什么？让我们开始吧！
也读: Python 硒介绍及设置
代码刮 ArXiv 最新论文
任何程序的第一步都是安装并导入所有必要的模块/库到我们的程序中。
为了抓取 ArXiv 研究论文，我们需要安装ArXiv python 库。使用下面的 python pip命令也可以做到这一点。
pip install arxiv
接下来，让我们导入程序所需的两个模块，即pandas和ArXiv模块。pandas 模块将需要以数据帧的形式保存最终数据集。我们还会询问用户关于研究者需要使用input功能的论文的话题。
import pandas as pd
import arxiv
topic = input("Enter the topic you need to search for : ")
一旦我们安装并导入了所有必要的库，我们也有了需要研究的主题。我们将利用Search函数来获取所需的论文以及论文的所有细节。
search = arxiv.Search(
query = topic,
max_results = 300,
sort_by = arxiv.SortCriterion.SubmittedDate,
sort_order = arxiv.SortOrder.Descending
)
该函数将接受许多参数。让我们理解一下我们在上面的代码中使用的那些。
query用于指定要搜索的主题。max_results用于指定结果数(默认值:10，最大值:30，000)。sort_by用于指定将用于对输出进行排序的因子(提交日期、最后更新日期或相关性)。sort_order用于设置提交文件的顺序(升序或降序)。
但是这段代码不会导致文件或任何信息显示出来。为此，我们需要一个循环。我们在这里要做的是浏览我们收到的所有 300 篇论文，然后将所有论文的一些信息保存在一个列表中，该列表稍后将使用pandas库传输到dataframe。
我们可以收集关于某篇论文的以下信息:论文 id、论文标题、论文摘要、论文涉及的作者、论文的 URL 以及论文所属的类别。
all_data = []
for result in search.results():
temp = ["","","","",""]
temp[0] = result.title
temp[1] = result.published
temp[2] = result.entry_id
temp[3] = result.summary
temp[4] = result.pdf_url
all_data.append(temp)
column_names = ['Title','Date','Id','Summary','URL']
df = pd.DataFrame(all_data, columns=column_names)
print("Number of papers extracted : ",df.shape[0])
df.head()
代码片段执行后，结果将是一个数据帧中的 300 篇研究论文数据。
ArXiv Scraped Data
使用 Python 抓取 ArXiv 最新论文的完整代码
让我们看看下面的刮刀的完整代码。
import pandas as pd
import arxiv
topic = input("Enter the topic you need to search for : ")
search = arxiv.Search(
query = topic,
max_results = 300,
sort_by = arxiv.SortCriterion.SubmittedDate,
sort_order = arxiv.SortOrder.Descending
)
all_data = []
for result in search.results():
temp = ["","","","",""]
temp[0] = result.title
temp[1] = result.published
temp[2] = result.entry_id
temp[3] = result.summary
temp[4] = result.pdf_url
all_data.append(temp)
column_names = ['Title','Date','Id','Summary','URL']
df = pd.DataFrame(all_data, columns=column_names)
print("Number of papers extracted : ",df.shape[0])
df.head()
让我们看看我们刚刚开发的同一铲运机的另一个输出。
ArXiv Scraped Data 2
也读:如何用 Scrapy 用 Python 刮雅虎财经数据
如何使用 Python Scrapy 抓取谷歌搜索结果
原文：https://www.askpython.com/python-modules/scrape-google-search-results-python-scrapy
你有没有遇到过这样的情况:第二天你有一场考试，或者一场演讲，你在谷歌搜索页面上一页一页地浏览，试图寻找对你有帮助的文章？
在这篇文章中，我们将探讨如何将这个单调的过程自动化，这样您就可以将精力投入到更好的任务中。
在这个练习中，我们将使用 Google collaboratory 并在其中使用 Scrapy。当然，你也可以将 Scrapy 直接安装到你的本地环境中，过程是一样的。
寻找批量搜索或 API？
下面的程序是实验性的，向你展示了我们如何用 Python 抓取搜索结果。但是，如果你批量运行，谷歌防火墙可能会屏蔽你。如果你正在寻找批量搜索或围绕它建立一些服务，你可以看看 Zenserp 。
Zenserp 是一个 google 搜索 API，它解决了抓取搜索引擎结果页面所涉及的问题。当抓取搜索引擎结果页面时，你会很快遇到代理管理问题。Zenserp 会自动轮换代理，并确保您只收到有效的响应。
它还支持图片搜索、购物搜索、图片反向搜索、趋势等，让您的工作变得更加轻松。您可以在这里尝试一下，只需打开任何搜索结果并查看 JSON 响应。
正在初始化 Google 协作室
前往https://colab.research.google.com/，用您的谷歌账户登录。转到文件>创建新笔记本。然后点击这个图标。点击确认按钮:
Mount Drive In Colab
这需要几秒钟时间。然后在代码区域中，键入:
!pip install scrapy
这将在 Google colab 中安装 Scrapy，因为它不是内置的。接下来，我们导入我们的包:
import scrapy
import pandas
还记得你是如何安装硬盘的吗？是的，现在进入名为“drive”的文件夹，导航到您的 Colab 笔记本。点击右键，选择复制路径。
现在，在代码编辑器中，输入:
%cd "/content/drive/My Drive/Colab Notebooks/"
现在我们准备初始化我们的 scrapy 项目，它将保存在我们的 Google Drive 中以供将来参考。
进入代码编辑器:
!scrapy startproject google_crawler
这将在您的 colab 笔记本中创建一个零碎的项目回购。如果您不能跟随，或者在某个地方出现了失误，项目被存储在其他地方，也不用担心。我们可以简单地移动它:
!mv google_crawler "/content/drive/My Drive/Colab Notebooks/"
一旦完成，我们将开始建造我们的蜘蛛。
构建 Python Scrapy 蜘蛛
打开 google_crawler repo。你会发现一个“蜘蛛”的文件夹在里面。这是我们放置新蜘蛛代码的地方。
因此，在这里单击文件夹创建一个新文件，并将其命名为。我们从包导入开始:
import scrapy
from scrapy.linkextractors import LinkExtractor
import pandas as pd
您现在不需要更改类名。让我们稍微整理一下。
删除 allowed_domains 行，因为我们不需要它。换个名字。
下面是文件系统的样子(供参考):
File System For Scrapy
这是我们蜘蛛的名字，你可以用各种参数存储任意多的蜘蛛。在 start_urls 列表中，我们可以添加我们的 google 搜索:
class firstSpider(scrapy.Spider):
name = "basic"
start_urls = [
"https://www.google.com/search?q=journal+dev"
]
现在，让我们创建我们的解析函数，并使用我们的链接提取器来获取链接:
def parse(self, response):
xlink = LinkExtractor()
for link in xlink.extract_links(response):
print(link)
在代码编辑器中，使用以下命令运行它:
!scrapy crawl basic
我们看到这里有很多链接，其中许多主要是 Google.com 搜索，所以我们可以用一个 if 条件过滤掉它们:
def parse(self, response):
xlink = LinkExtractor()
for link in xlink.extract_links(response):
if len(str(link))>200 or 'Journal' in link.text:
print(len(str(link)),link.text,link,"\n")
瞧啊。在这里，我们再次运行蜘蛛，我们只得到与我们的网站相关的链接以及文本描述。
Google Search Results Scraped Successfully
我们到此为止。
将其放入数据帧中
然而，一个终端输出大部分是无用的。如果你想用它做更多的事情(比如浏览列表中的每个网站，或者把它们给某人)，那么你需要把它输出到一个文件中。为此，我们将使用 熊猫 :
def parse(self, response):
df = pd.DataFrame()
xlink = LinkExtractor()
link_list=[]
link_text=[]
for link in xlink.extract_links(response):
if len(str(link))>200 or 'Journal' in link.text:
print(len(str(link)),link.text,link,"\n")
link_list.append(link)
link_text.append(link.text)
df['links']=link_list
df['link_text']=link_text
df.to_csv('output.csv')
现在，如果我们运行这个，我们会得到一个名为" output.csv "的输出文件:
Spider Output For Google Search Of Journal Dev
提取元描述
我们可以更进一步，也可以访问文本下面的描述:
Description Below Search Links
所以我们将修改解析函数。我们使用 response.xpath(//div/text())来获取出现在 div 标签中的所有文本。然后通过简单的观察，我在终端上打印了每篇文章的长度，发现超过 100 的很可能是描述。因为它们的获取顺序与链接的顺序相同，所以我们可以将它们排列起来:
def parse(self, response):
df = pd.DataFrame()
xlink = LinkExtractor()
link_list=[]
link_text=[]
divs = response.xpath('//div')
text_list=[]
for span in divs.xpath('text()'):
if len(str(span.get()))>100:
text_list.append(span.get())
for link in xlink.extract_links(response):
if len(str(link))>200 or 'Journal'in link.text:
#print(len(str(link)),link.text,link,"\n")'''
link_list.append(link)
link_text.append(link.text)
for i in range(len(link_text)-len(text_list)):
text_list.append(" ")
df['links']=link_list
df['link_text']=link_text
df['text_meta'] = text_list
df.to_csv('output.csv')
所以现在如果我们运行代码，我们会得到第四列:
Descriptions Extraction – Metadata Div/Span From Css
就是这样！
感谢您的阅读。查看其他文章，继续编程。干杯。
如何使用 Scrapy 在 Python 中抓取雅虎财经数据
原文：https://www.askpython.com/python/scrape-yahoo-finance-python-scrapy
Yahoo Finance 是一个成熟的网站，包含各种领域的金融数据，如股票价格、金融新闻和报告。它有自己的 Yahoo Finance API 来提取历史股票价格和市场摘要。
在本文中，我们将删除原始的雅虎财经网站，而不是依赖 API。网页抓取是通过一个名为 Scrapy 的开源网页抓取框架实现的。
批量刮擦要求？
大多数流行的网站使用防火墙来阻止流量过大的 IP。在这种情况下，你可以使用 Zenscrape ，这是一个网页抓取 API，可以解决大规模抓取的问题。除了 web 抓取 API 之外，它还提供了一个常驻代理服务，可以访问代理本身，并为您的用例提供最大的灵活性。
卷筒纸刮刀要求
在我们进入细节之前，我们必须满足某些技术要求:
- Python–我们将在这个特定的项目中使用 Python。它庞大的库和简单的脚本使它成为网络抓取的最佳选择。
- 这个由 Python 支持的网络爬行框架是从网站中提取数据的最有用的技术之一。
- HTML 基础知识——抓取包括处理 HTML 标签和属性。然而，如果读者不了解 HTML 基础知识，这个网站会有所帮助。
- web 浏览器–常用的 Web 浏览器，如 Google Chrome 和 Mozilla Firefox，都有检查底层 HTML 数据的规定。
Scrapy 的安装和设置
我们将回顾 Scrapy 的快速安装过程。首先，与其他 Python 库类似，Scrapy 是使用 pip 安装的。
pip install Scrapy
安装完成后，我们需要为 Web Scraper 创建一个项目。我们输入希望存储项目的目录，然后运行:
scrapy startproject <PROJECT_NAME>
Project Structure using Scrapy
从上面的终端片段中可以看出，Scrapy 创建了几个文件来支持这个项目。我们不会深入讨论目录中每个文件的本质细节。相反，我们将致力于学习使用 Scrapy 创建我们的第一个刮刀。
如果读者有与安装相关的问题，详细过程在此解释。
使用 Scrapy 创建我们的第一个刮刀
我们在 Scrapy 项目的spiders目录中创建一个 python 文件。必须记住的一点是，Python 类必须继承Scrapy.Spider类。
import scrapy
class yahooSpider(scrapy.Spider):
....
....
这将遵循我们将要创建的爬虫的名称和 URL。
class yahooSpider(scrapy.Spider):
# Name of the crawler
name = "yahoo"
# The URLs we will scrape one by one
start_urls = ["https://in.finance.yahoo.com/quote/MSFT?p=MSFT",
"https://in.finance.yahoo.com/quote/MSFT/key-statistics?p=MSFT",
"https://in.finance.yahoo.com/quote/MSFT/holders?p=MSFT"]
考虑中的股票是微软(MSFT)的股票。我们设计的 scraper 将从以下三个网页中检索重要信息:
- 微软股票的股票摘要
- 库存统计
- 微软金融
start_urls列表包含上述每个网页的 URL。
解析抓取的内容
提供的 URL 被一个一个地抓取，HTML 文档被发送到parse()函数。
import scrapy
import csv
class yahooSpider(scrapy.Spider):
# Name of the crawler
name = "yahoo"
# The URLs we will scrape one by one
start_urls = ["https://in.finance.yahoo.com/quote/MSFT?p=MSFT",
"https://in.finance.yahoo.com/quote/MSFT/key-statistics?p=MSFT",
"https://in.finance.yahoo.com/quote/MSFT/holders?p=MSFT"]
# Parsing function
def parse(self, response):
....
....
parse()函数将包含从雅虎财经网页提取数据背后的逻辑。
发现用于提取相关数据的标签
从 HTML 内容中发现标签是通过使用 Web 浏览器检查网页来完成的。
Inspecting the Yahoo Finance Webpage
在我们按下Inspect按钮后，一个包含大量 HTML 的面板出现在屏幕的右侧。我们的工作是搜索标签的名称及其包含我们想要提取的数据的属性。
例如，如果我们想从包含“Previous Close”的表中提取值，我们需要存储数据的标签的名称和属性。
HTML document behind the Webpage
一旦我们掌握了存储我们感兴趣的信息的 HTML 标签背后的知识，我们就可以使用 Scrapy 定义的函数提取它们。
用于数据提取的 Scrapy 选择器
我们将在这个项目中使用的两个选择器函数是xpath()和css()。
XPATH 独立来说，是一种从 XML 或 HTML 文档中选择数据的查询语言。XPATH 代表 XML 路径语言。
CSS ，独立来说，是 HTML 语言的一种样式语言。
关于这些选择器功能的更多信息可以从他们的官方网站获得。
# Parsing function
def parse(self, response):
# Using xpath to extract all the table rows
data = response.xpath('//div[@id="quote-summary"]/div/table/tbody/tr')
# If data is not empty
if data:
# Extracting all the text within HTML tags
values = data.css('*::text').getall()
作为参数接收的response值包含网站内的全部数据。正如在 HTML 文档中看到的，该表存储在一个具有作为quote-summary的id属性的div标签中。
我们将上述信息转换成一个xpath函数，并提取指定的div标签中的所有tr标签。然后，我们从所有标签中获取文本，不考虑它们的名字(*)，放入一个名为values的列表中。
该组值如下所示:
['Previous close', '217.30', 'Open', '215.10', 'Bid', '213.50 x 1000', 'Ask', '213.60 x 800' ... 'Forward dividend & yield', '2.04 (0.88%)', 'Ex-dividend date', '19-Aug-2020', '1y target est', '228.22']
必须注意的一点是，标签的名称和属性可能会随着时间的推移而改变，从而使上述代码变得毫无价值。因此，读者必须了解提取这些信息的方法。
我们可能会从 HTML 文档中获得不相关的信息。因此，程序员必须实现适当的健全性检查来纠正这种异常。
本文后面提供的完整代码包含了另外两个从大量 HTML 行话中获取重要信息的例子。
将检索到的数据写入 CSV 文件
该项目的最终任务是将检索到的数据存储到某种持久存储中，如 CSV 文件。Python 有一个csv库，可以更容易地实现对. csv 文件的写入。
# Parsing function
def parse(self, response):
# Using xpath to extract all the table rows
data = response.xpath('//div[@id="quote-summary"]/div/table/tbody/tr')
# If data is not empty
if data:
# Extracting all the text within HTML tags
values = data.css('*::text').getall()
# CSV Filename
filename = 'quote.csv'
# If data to be written is not empty
if len(values) != 0:
# Open the CSV File
with open(filename, 'a+', newline='') as file:
# Writing in the CSV file
f = csv.writer(file)
for i in range(0, len(values[:24]), 2):
f.writerow([values[i], values[i+1]])
上面的代码打开一个quote.csv文件，并使用 Python 的csv库写入 scraper 获得的值。
注意:
csv库不是内置的 Python 库，因此需要安装。用户可以通过运行-pip install csv来安装。
管理整个 Scrapy 项目
保存所有进度后，我们移到最初创建的项目的最顶层目录，并运行:
scrapy crawler <CRAWLER-NAME>
在我们的例子中，我们运行scrapy crawler yahoo，Python 脚本将所有指定的信息抓取并存储到一个 CSV 文件中。
刮刀的完整代码
import scrapy
import csv
class yahooSpider(scrapy.Spider):
# Name of the crawler
name = "yahoo"
# The URLs we will scrape one by one
start_urls = ["https://in.finance.yahoo.com/quote/MSFT?p=MSFT",
"https://in.finance.yahoo.com/quote/MSFT/key-statistics?p=MSFT",
"https://in.finance.yahoo.com/quote/MSFT/holders?p=MSFT"]
# Parsing function
def parse(self, response):
# Using xpath to extract all the table rows
data = response.xpath('//div[@id="quote-summary"]/div/table/tbody/tr')
# If data is not empty
if data:
# Extracting all the text within HTML tags
values = data.css('*::text').getall()
# CSV Filename
filename = 'quote.csv'
# If data to be written is not empty
if len(values) != 0:
# Open the CSV File
with open(filename, 'a+', newline='') as file:
# Writing in the CSV file
f = csv.writer(file)
for i in range(0, len(values[:24]), 2):
f.writerow([values[i], values[i+1]])
# Using xpath to extract all the table rows
data = response.xpath('//section[@data-test="qsp-statistics"]//table/tbody/tr')
if data:
# Extracting all the table names
values = data.css('span::text').getall()
# Extracting all the table values
values1 = data.css('td::text').getall()
# Cleaning the received vales
values1 = [value for value in values1 if value != ' ' and (value[0] != '(' or value[-1] != ')')]
# Opening and writing in a CSV file
filename = 'stats.csv'
if len(values) != 0:
with open(filename, 'a+', newline='') as file:
f = csv.writer(file)
for i in range(9):
f.writerow([values[i], values1[i]])
# Using xpath to extract all the table rows
data = response.xpath('//div[@data-test="holder-summary"]//table')
if data:
# Extracting all the table names
values = data.css('span::text').getall()
# Extracting all the table values
values1 = data.css('td::text').getall()
# Opening and writing in a CSV file
filename = 'holders.csv'
if len(values) != 0:
with open(filename, 'a+', newline='') as file:
f = csv.writer(file)
for i in range(len(values)):
f.writerow([values[i], values1[i]])
结论
与其他抓取库相比，Scrapy 框架可能看起来不直观，但对 Scrapy 的深入学习证明了它的优势。
我们希望这篇文章能帮助读者理解使用 Scrapy 的网络抓取。您可以查看我们的另一篇网络抓取文章，该文章涉及使用 Beautiful Soup 提取亚马逊产品细节。
感谢阅读。如有疑问或建议，欢迎在下面发表评论。
Python 中的 Seaborn stripplot()方法——快速指南
原文：https://www.askpython.com/python-modules/seaborn-stripplot-method
嘿程序员们！在今天的教程中，我们将探索 Python 中的 Seaborn stripplot()方法。我们开始吧！
Seaborn stripplot 简介()
Seaborn 是一个非常棒的统计图形可视化工具。它有很好的默认样式和调色板，使统计图表更有吸引力。它是在 matplotlib 软件之上设计的，并与 pandas 数据结构紧密相连。
带状图是完全独立创建的。在所有数据都与基本分布的一些表示一起给出的情况下，它是箱线图或紫线图的一个很好的补充。它用于根据类别生成散点图。
在 Python 中使用 Seaborn stripplot()方法
现在让我们进入编码部分。我将在下面用一个非常简单的例子来演示这个方法，这样你就能理解了。您可以从那里进一步探索该方法，并从官方文档中了解更多高级用例。
导入必要的模块/库
import seaborn
import matplotlib.pyplot as plt
plt.style.use("seaborn")
加载数据集
Tips 数据集是 seaborn 包中包含的示例数据集之一，它用于 seaborn 包的文档中。使用 seaborn load dataset 命令可以很容易地导入它。
tips = seaborn.load_dataset("tips")
基本可视化
让我们用小费数据集画一个带状图，比较他们支付的性别和总账单。
plt.figure(figsize=(10,10))
seaborn.stripplot(x="sex", y="total_bill", data=tip)
plt.show()
Basic Visualization Stripplot
围绕数据点绘制轮廓
灰色线条的宽度构成了绘图部分的框架。当我们增加线宽时，点也自动增加。
plt.figure(figsize=(10,10))
seaborn.stripplot(y="total_bill", x="sex", data=tips,linewidth=2,size=10)
plt.show()
Border Around Points Stripplot
使用色调参数
虽然这些点是用两种颜色绘制的，但是可以使用第三个变量通过给这些点着色来为绘图提供额外的维度。
plt.figure(figsize=(10,10))
seaborn.stripplot(x="sex", y="total_bill", hue="day", data=tips,size=10)
plt.show()
Hue Parameter Stripplot
使用标记和 alpha 参数
我们将使用 alpha 来控制数据点的透明度，并使用标记来修改它。
plt.figure(figsize=(10,10))
seaborn.stripplot(x="sex", y="total_bill", hue="smoker", data=tips,size=15,marker="*",alpha=0.5)
plt.show()
Marker N Alpha Stripplot
结论
恭喜你！您刚刚学习了如何使用 seaborn 库在 Python 中绘制带状图。希望你喜欢它！😇
喜欢这个教程吗？无论如何，我建议你看一下下面提到的教程:
感谢您抽出时间！希望你学到了新的东西！！😄
搜索数组的 5 个技巧
读者朋友们，你们好！在本文中，我们将详细讨论 5 种使用条件搜索 NumPy 数组的技术。
所以，让我们开始吧！🙂
一个 NumPy 数组在一个连续的结构中存储相似类型的元素。我们经常遇到需要在动态运行时查看数组的最大和最小元素的情况。NumPy 为我们提供了一组函数，使我们能够搜索应用了特定条件的特定元素。
如何在 NumPy 数组中搜索特定的元素？
让我们详细看看用于搜索 NumPy 数组的 5 个函数:
- arg max()函数
- nanargmax()函数
- arg min()函数
- nargmin()函数
- 使用 where()函数搜索
1。NumPy argmax()函数
使用 NumPy argmax()函数，我们可以轻松地获取并显示数组结构中最大元素的索引。
这样，最大元素的索引就是 argmax()函数的结果值。
语法:
numpy.argmax() function
举例:
import numpy as np
data = np.array([[66, 99, 22,11,-1,0,10],[1,2,3,4,5,0,-1]])
res = np.argmax(data)
print(data)
print("Max element's index:", res)
输出:
在上面的例子中，我们创建了两个相同数据类型的数组。此外，应用 argmax()函数从所有元素中获取 max 元素的索引。因为 99 是最大的元素，所以结果索引值显示为 1。
[[66 99 22 11 -1 0 10]
[ 1 2 3 4 5 0 -1]]
Max element's index: 1
2。NumPy nanargmax()函数
使用 nanargmax()函数，我们可以轻松处理数组中出现的 NAN 或 NULL 值。也就是说，它不会被区别对待。NAN 值对搜索值的功能没有影响。
语法:
numpy.nanargmax()
举例:
在下面的示例中，数组元素包含使用 numpy.nan 函数传递的空值。此外，我们现在使用 nanargmax()函数来搜索 NumPy 数组，并从数组元素中找到最大值，而不让 NAN 元素影响搜索。
import numpy as np
data = np.array([[66, 99, 22,np.nan,-1,0,10],[1,2,3,4,np.nan,0,-1]])
res = np.nanargmax(data)
print(data)
print("Max element's index:", res)
输出:
[[66\. 99\. 22\. nan -1\. 0\. 10.]
[ 1\. 2\. 3\. 4\. nan 0\. -1.]]
Max element's index: 1
3。NumPy argmin()函数
使用 argmin()函数，我们可以搜索 NumPy 数组，并在更大范围内获取数组中最小元素的索引。它搜索数组结构中的最小值，并返回该值的索引。因此，通过索引，我们可以很容易地获得数组中的最小元素。
语法:
numpy.argmin() function
举例:
import numpy as np
data = np.array([[66, 99, 22,11,-1,0,10],[1,2,3,4,5,0,-1]])
res = np.argmin(data)
print(data)
print("Min element's index:", res)
输出:
如下所示，有两个索引占据了最低的元素，即[-1]。但是，argmin()函数返回数组值中最小元素的第一个匹配项的索引。
[[66 99 22 11 -1 0 10]
[ 1 2 3 4 5 0 -1]]
Min element's index: 4
4。NumPy where()函数
使用 where()函数，我们可以轻松地在 NumPy 数组中搜索任何元素的索引值，这些元素匹配作为参数传递给函数的条件。
语法:
numpy.where(condition)
举例:
import numpy as np
data = np.array([[66, 99, 22,11,-1,0,10],[1,2,3,4,5,0,-1]])
res = np.where(data == 2)
print(data)
print("Searched element's index:", res)
输出:
在这个例子中，我们从数组中搜索了一个值等于 2 的元素。此外，where()函数返回数组索引及其数据类型。
[[66 99 22 11 -1 0 10]
[ 1 2 3 4 5 0 -1]]
Searched element's index: (array([1], dtype=int64))
5。NumPy nanargmin()函数
使用 nanargmin()函数，我们可以轻松地搜索 NumPy 数组，找到数组元素中最小值的索引，而不必担心数组元素中的 NAN 值。空值对元素的搜索没有影响。
语法:
numpy.nanargmin()
举例:
import numpy as np
data = np.array([[66, 99, np.nan,11,-1,0,10],[1,2,3,4,5,0,-1]])
res = np.nanargmin(data)
print(data)
print("Searched element's index:", res)
输出:
[[66\. 99\. nan 11\. -1\. 0\. 10.]
[ 1\. 2\. 3\. 4\. 5\. 0\. -1.]]
Searched element's index: 4
结论
如果你遇到任何问题，请随时在下面评论。更多与 Python 编程相关的帖子，请继续关注我们。
在那之前，学习愉快！！🙂
在 Python 数组中查找对象–查找数组中对象的第一个、最后一个和所有出现的位置
原文：https://www.askpython.com/python/array/search-objects-in-a-python-array
今天在本教程中，我们将借助递归查找数组中某个元素的第一个、最后一个和所有出现的位置。
在进入任何问题陈述之前，让我们首先理解什么是递归。如果你想了解递归，这里提供了一个了解递归的链接。
了解一下递归这里: Python 递归
查找元素的第一个匹配项
让我们从寻找元素在一个 Python 数组中的第一次出现开始。我们的目标是找到元素在元素列表(数组)中出现的第一个位置。
例如: 数组给定= =>【1，2，3，4，2】
第一次出现== > 2
为了找到问题的解决方案，我们将采取以下步骤:
Step 1 : Check if list is empty then return that list is empty
Step 2 : Check if there is only one element then check the first element with X and return the answer if found
Step 3 : For more than one element, we will check if the first element is equal to X if found then return
Step 4 : Otherwise recursively go by slicing the array and incrementing and decremementing the itrerator and n value (size of array ) respectively
Step 5 : Repeat until the element is found or not
上述步骤的代码实现如下所示:
def find_first(arr,n,x,itr):
# check if list is empty
if(n==0):
print("List empty!")
return
# Only one element
elif(n==1):
if(arr[0]==x):
print("Element present at position 1")
else:
print("Element not found")
return
# More than one element
else:
if(arr[0] == x):
print("Found at position: ", itr+1)
else:
find_first(arr[1:],n-1,x,itr+1)
return
arr = [1,2,3,4,5,2,10,10]
n = len(arr)
x = 10
itr = 0
find_first(arr,n,x,itr)
输出:
Found at position: 7
查找对象的最后一次出现
接下来，我们将尝试使用 Python 查找该元素的最后一次出现。我们的目标是找到元素在元素列表(数组)中出现的最后一个位置。
例如:
数组给定= =>【1，2，3，4，2】
最后一次出现== > 5
为了找到问题的解决方案，我们将采取以下步骤:
Step 1 : Check if list is empty then return that list is empty
Step 2 : Check if there is only one element then check the first element with X and return the answer if found
Step 3 : For more than one element, we will check if the last element is equal to X if found then return
Step 4 : Otherwise recursively go by slicing the array and decremementing both the iterator and n value (size of array )
Step 5 : Repeat until the element is found or not
用 Python 实现上述步骤
def find_first(arr,n,x,itr):
# check if list is empty
if(n==0):
print("List empty!")
return
# Only one element
elif(n==1):
if(arr[0]==x):
print("Element present at position 1")
else:
print("Element not found")
return
# More than one element
else:
if(arr[n-1] == x):
print("Found at position: ", itr+1)
else:
find_first(arr[:-1],n-1,x,itr-1)
return
arr = [1,2,3,4,5,2,3,2,3,2,10,10]
n = len(arr)
x = 2
itr = n - 1
find_first(arr,n,x,itr)
输出:
Found at position: 10
查找对象的所有出现
这里我们的目标是找到元素在元素列表(数组)中出现的所有位置。出现的位置包括数组中元素的第一个、最后一个和任何中间位置。
例如:
数组给定= =>【1，2，3，4，2】
所有出现次数== > 2 5
为了找到问题的解决方案，我们将采取以下步骤:
Step 1 : Check if list is empty then return that list is empty
Step 2 : Check if there is only one element then print the position of the element and return
Step 3 : For more than one element, we will check if the first element is equal to X if found then print and keep on recursively calling the function again by slicing the array and decremementing n value (size of array ) and incrementing the value of iterator
Step 5 : Repeat until all the elements are encountered.
用 Python 实现上述步骤
def find_first(arr,n,x,itr):
# check if list is empty
if(n==0):
print("List empty!")
return
# Only one element
elif(n==1):
if(arr[0]==x):
print(itr+1,end=" ")
else:
print("Element not found")
# More than one element
else:
if(arr[0] == x):
print(itr+1,end=" ")
find_first(arr[1:],n-1,x,itr+1)
arr = [1,2,10,3,4,10,5,2,10,2,3,10]
n = len(arr)
x = 10
itr = 0
print("Found at position: ",end="")
find_first(arr,n,x,itr)
输出:
Found at position: 3 6 9 12
结论
到本教程结束时，我们已经熟悉了在给定的数组中查找元素的第一个、最后一个和所有出现的位置。希望你明白其中的逻辑！
感谢您的阅读！快乐学习！😇
Python 中的选择排序
原文：https://www.askpython.com/python/selection-sort-in-python
今天我们将学习一个简单且易于可视化的排序算法，在 Python 中称为选择排序。让我们开始吧。
选择排序算法
类似于插入排序，插入排序算法将列表分为两部分。列表开头的第一部分是已排序的部分，列表末尾的第二部分是未排序的部分。
最初，整个列表是未排序的，但是随着每次迭代，列表中最小的项目被搜索(对于升序列表)并被添加到排序的部分。
这是如何发生的，我们一个接一个地找到未排序部分中最小的项目，并将其与正确位置上的项目交换。
所以在第一次迭代中，最小的项与第一个位置的项交换。在第二次迭代中，第二小的项与第二个位置的项交换。诸如此类…
在 Python 中实现选择排序
下面是 Python 中选择排序的一个简单实现。
def selection_sort(lst):
n = len(lst)
for i in range(n - 1):
min = i
for j in range(i + 1, n):
if(lst[j] < lst[min]):
min = j
lst[i], lst[min] = lst[min], lst[i]
请注意，该函数接收一个列表并就地执行排序，修改算法以返回一个排序列表相当简单。
解释选择排序算法的步骤
这个算法将列表按升序排序，让我们看看它是如何工作的。
- 变量
n是列表中的项目数。 - 现在，
i从0到n - 2，也就是说i从第一项指向倒数第二项。i的作用是它会一直指向下一个最小的项会去哪里，所以我们会找到从i到列表末尾的最小项，它会被放在i。 - 我们现在认为
i处的项目是最小的，因为如果我们在i之后找不到更小的元素，那么i就拥有正确的项目。 - 在里面，
j从i + 1到n - 1，也就是说j会指向i之后的所有项目，它会负责找到那个范围内最小的项目。 - 现在我们将
j处的物品与我们已经找到的最小物品进行比较，如果j处的物品更小，那么它将成为我们已经找到的最小物品。 - 在内部循环之后，我们已经找到了从
i到n - 1的最小项目，并且它与在i的项目交换，以便它到达它的正确位置。 - 外部循环将继续选择并一个接一个地放置下一个最小的项目，直到整个列表被排序。
现在我们将试着在一个例子上运行这个算法，看看它如何影响序列。
让我们把顺序想成 12，16，11，10，14，13。
给出列表的大小(n): 6
12，16，11， 10 ，14，13
10，16， 11 ，12，14，13
10， 11 ，16， 12 ，14，13
15， 11 ， 16
10 ， 11 ， 12 ， 13 ， 14 ， 16
- 绿色的数字是已经排序的数字。
- 蓝色的数字是没有排序的数字中最小的。
- 未着色的要分类。
可以看出，该算法找到最小的项目，然后将它们与正确位置的项目交换。
输出
对算法运行相同的列表将产生以下结果:
Selection Sort in action
结论
在本教程中，我们看到了选择排序是如何工作的，我们用 Python 实现了该算法，并使用代码的实际输出验证了一个示例的模拟运行。
选择排序，类似于冒泡和插入排序，复杂度为 O(n² )。这意味着，如果输入大小加倍，执行该算法所需的时间将增加四倍，因此，这是一种低效的排序算法。
它的效率通常不如插入排序，但理解和实现起来要简单得多。我希望你喜欢学习选择排序，下一课再见。
Python Selenium 简介和设置
原文：https://www.askpython.com/python-modules/selenium-introduction-and-setup
本教程的目的是向您介绍 selenium，并展示安装 Selenium 和 webdriver 以实现浏览器自动化的过程。在本文中，我们假设您的机器上已经安装了 python。
需要注意的重要一点是，浏览器自动化和 web 废弃在他们的方法中完全是白帽子，Web 浏览器本身正式支持它，为自动化和测试提供 Web 驱动程序，只是使用代码打开的浏览器窗口被标记为“该浏览器由自动化测试软件控制”
硒是什么？
Selenium 是一个开源项目，它提供了一系列工具来自动化网络浏览器。它还用于创建 web scrapers，以从网页中获取(抓取)所需的数据。
使用 Python Selenium 可以完成的一些任务有:
- 自动化浏览器任务，如登录、加入会议、滚动、网上冲浪等。
- 从网站/网页获取文本、excel 文件、代码等形式的数据。
浏览器自动化的一个关键组件是 web 驱动程序。Webdriver 是一个 API 的集合，它使得与浏览器的交互变得容易。将 Selenium 和 webdriver 结合在一起，可以非常容易地将枯燥的 web 任务自动化。
安装 Selenium
要开始为浏览器自动化和 web 抓取设置我们的计算机，我们需要从安装一些工具和库开始。
1.安装 Selenium
首先，我们将使用 pip 安装 selenium 包。使用 pip install package_name 命令可以很容易地安装任何 python 包。
打开计算机的命令提示符，输入以下命令。您也可以在系统或 IDE 的终端中运行该命令。
pip install selenium
它将在我们的机器上安装最新版本的 selenium。
2.安装 Selenium 驱动程序
在设置过程中，我们的第二个任务是按照我们的浏览器安装 webdriver，我们打算用它来实现自动化。
安装网络驱动程序时，我们需要确保它与我们的网络浏览器有相同的版本。每个浏览器都有自己的网络驱动程序，由母公司维护。
下面是下载流行浏览器的驱动程序的链接，分别是 Mozilla Firefox、Google Chrome 和 Microsoft Edge。
下载 Mozilla Firefox Webdriver: 此处
下载谷歌 Chrome Webdriver: 此处下载微软 Webdriver: 此处
下载 selenium 和所需的 web 驱动程序后，您就可以编写 python 脚本来自动化 web 浏览器了。
3.在 Python 中导入硒
由于我们已经下载了所需的工具和库，最后一步我们需要导入所需的，如下所示:
注意:我们需要将安装的 web 驱动文件的位置(保存在我们的计算机上)传递给 web driver 方法。
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
driver = webdriver.Chrome('C://software/chromedriver.exe')
提示:在每段代码中，我们可以聪明地跳过这一步，将下载的 web 驱动文件的位置声明(保存)为环境变量，而不是每次都将位置作为参数传递。
硒的推荐读物
最后，我们完成了设置，您可以按照我们关于 Python Selenium 的教程开始抓取网页并自动化您的网页浏览器任务
Python 中的分号
原文：https://www.askpython.com/python/examples/semicolon-in-python
先说一下 Python 中分号的用法。分号(；)是结束或中断当前语句。
在像 C、C++和 Java 这样的编程语言中，使用分号是终止代码行所必需的。然而，Python 的情况并非如此。那么在 Python 编程中使用分号有什么不同吗？让我们找出答案。
Python 中为什么允许分号？
Python 不需要分号来终止语句。如果您希望将多个语句放在同一行中，可以使用分号来分隔语句。
在 Python 中的一个分号表示分离，而不是终止。它允许你在同一行写多条语句。这种语法也使得在一条语句的末尾加上一个分号成为合法的。所以，实际上是两个语句，第二个是空的。
如何用 Python 打印分号？
让我们看看当我们试图在 Python 中将分号打印为常规字符串时会发生什么
>>> print(";")
输出:
;
它不加区别地对待分号并打印出来。
用分号分隔语句
现在，让我们看看如何使用分号来拆分 Python 中的语句。在这种情况下，我们将尝试在同一行中使用分号放置两个以上的语句。
语法:
statement1; statement2
例如:
下面是 Python 中没有分号的三个语句
>>> print('Hi')
>>> print('Hello')
>>> print('Hola!')
现在让我们使用同样的带有分号的三个语句
print('Hi'); print('Hello'); print('Hola!')
输出:
Hi
Hello
Hola!
正如您所看到的，在我们用分号将它们分开之后，Python 分别执行这三个语句。如果不使用它，解释器会给出一个 err.r
在 Python 中使用分号和循环
在像' For loop 这样的循环中，如果整个语句以循环开始，并且您使用分号来形成像循环体一样的连贯语句，则可以使用分号。
示例:
for i in range (4): print ('Hi') ; print('Hello')
输出:
Hi
Hello
Hi
Hello
Hi
Hello
Hi
Hello
如果你使用分号来分隔一个普通表达式和一个块语句，比如循环，Python 会抛出一个错误。
示例:
print('Hi') ; for i in range (4): print ('Hello')
输出:
Invalid Syntax
结论
这就把我们带到了这个关于在 Python 中使用分号的简短模块的结尾。让我们用两点来总结本教程:
- Python 中的分号主要用于分隔写在一行上的多个语句。
- 分号用于书写次要语句并保留一点空间——如 name = Marie 年龄= 23；打印(姓名、年龄)
使用分号是非常“非 pythonic 化”的，除非绝对必须使用，否则最好避免使用。
使用 Django 发送电子邮件
原文：https://www.askpython.com/django/send-emails-using-django
在本文中，我们将学习使用 Django 通过 Django 邮件库自动向用户发送电子邮件，Django 邮件库是 Python 的 smtplib 模块的扩展。
什么是 SMTP？
SMTP 服务器代表简单邮件传输协议，这是一个用于电子邮件传输的社区协议。SMTP 由一组允许软件在互联网上传输邮件的社区准则组成。这是一个使用电子邮件地址向其他用户发送邮件的程序。
SMTP 服务器:是从一个客户端向另一个客户端发送/接收或转发邮件的应用程序。
例如，谷歌的 SMTP 服务器地址是smtp.gmail.com。同样，苹果的 SMT 服务器有【smtp.apple.com】、等。
如何使用 Django 发送电子邮件？
既然我们知道了 SMTP 服务器以及电子邮件是如何生成的，现在让我们制作一个应用程序来使用 Python Django 发送电子邮件。
1.Settings.py 的新增内容
在 settings.py 文件中，我们需要添加下面的 email 字典变量:
EMAILS = [
{
EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend',
EMAIL_HOST = 'smtp.gmail.com',
EMAIL_PORT = 8000,
EMAIL_HOST_USER = '[email protected]',
EMAIL_HOST_PASSWORD = 'xyz',
EMAIL_USE_TLS = True,
EMAIL_USE_SSL = False,
}
]
确保使用提供商提供的 SMTP 服务器更改 SMTP_HOST。此外，使用您的凭据更改电子邮件和密码。
2.TLS 和 SSL 的区别
TLS 和 SSL 的功能是相同的；它们用于加密服务器/客户端或系统之间的数据和信息。 TLS(传输层安全)是 SSL(安全套接字层)的后继协议。
TLS 或 SSL 取决于你使用的服务器，在 Gmail 的情况下，是 TLS 。
在本文中，我将使用 Gmail 本身，因此将选择 TLS。根据您的服务器，您可以使用这两者中的任何一种。
编写发送电子邮件的代码
现在我们已经设置好了，让我们来编写发送电子邮件的代码。
1.使用 send_mail()单独发送电子邮件
教程的这一部分讲述了给你的收件人发送个人邮件的方法。我们将通过 send_mail()函数来实现这一点。send_mail 的语法是:
send_mail(
subject = 'This is Subject Message',
message = 'This is email Message',
from_email = 'Sender Email ID',
recipient_list = 'Recipient's Email',
fail_silently = False,
html_messages = 'HTML messages',
)
在 Views.py 中，添加代码:
from django.core.mail import send_mail
send_mail(
subject = 'Test Mail',
message = 'Kindly Ignore',
from_email = '[email protected]',
recipient_list = ['[email protected]',],
fail_silently = False,
)
2.使用 send_mass_mail()发送多封电子邮件
在本节中，我们将回顾发送批量电子邮件的步骤。这里我们将使用 send_mass_mail()方法。发送大量邮件的语法:
send_mass_mail(
(datatuple),
fail_silently = False,
)
这里的数据元组是包含关于个人电子邮件信息的元组。
message1 = (subject, message, from_email, recipient_list)
message2 = (subject, message, from_email, recipient_list)
message3 = (subject, message, from_email, recipient_list)
send_mass_mail((message1,message2,message),fail_silently =False)
在 views.py 中，代码如下所示:
from django.core.mail import send_mail
message1 = ('Subject Here', 'This is Message','[email protected]',['[email protected]','[email protected]'])
message2 = ('Subject Here', 'This is Message','[email protected]',['[email protected]','[email protected]'])
send_mass_mail(
(message1,message2),
fail_silently = False,
)
3。使用 Django Email Message()方法发送电子邮件
此方法用于发送高级邮件，具有密件抄送、抄送或附件等功能。这个 Django 方法由电子邮件后端处理。
电子邮件后端类需要三个步骤:
- connection.open ():确保发送邮件的长期连接。
- connection.close() :停止已建立的连接
- send _ message():发送邮件；如果连接尚未打开，那么它会临时打开连接来发送邮件。
占位符语法是:
email1 = EmailMessage(
subject = 'This is subject',
message = 'This is message',
from_email = '[email protected]',
to = ['[email protected]',],
bcc = ['[email protected]'],
cc = ['[email protected]'],
)
因此，在 view.py 中添加以下代码:
from django.core import mail
connection = mail.get.connection()
connection.open()
email = mail.EmailMessage(
subject = 'Test Mail',
message = 'Kindly Ignore',
from_email = '[email protected]',
to = ['[email protected]',],
bcc = ['[email protected]'],
)
connection.send_messages(email)
connection.close()
文件附件:
EmailMessages()方法提供。attach _ file(‘文件路径’)随电子邮件发送附件的方法。您可以添加以下代码来附加文件:
email1.attach_file('home/Desktop/books.jpg')
实施准则
现在我们已经讨论了代码的各个部分，让我们把它们放在一起，看看它是如何工作的。因此，在您的 views.py 中添加一个示例脚本(结合上一节中的所有代码):
from django.core.mail import send_mail
#Sending mails individualy
send_mail(
subject = 'Test Send Mail #1',
message = 'Kindly Ignore',
from_email = '[email protected]',
recipient_list = ['[email protected]',],
fail_silently = False,
)
#Sending mass mails
message1 = ('Test Subject message1 #2', 'This is Message','[email protected]',['[email protected]','[email protected]'])
message2 = ('Test Subject message2 #2', 'This is Message','[email protected]',['[email protected]','[email protected]'])
send_mass_mail(
(message1,message2),
fail_silently = False,
)
#Sending mails using EmailMessage along with attachments
from django.core import mail
connection = mail.get.connection()
connection.open()
email = mail.EmailMessage(
subject = 'Test Mail',
message = 'Kindly Ignore',
from_email = '[email protected]',
to = ['[email protected]',],
bcc = ['[email protected]'],
)
email.attach_file('home/Desktop/books.jpg')
connection.send_messages(email)
connection.close()
第一次使用 Gmail 发送电子邮件时请注意；由于默认的安全设置，您可能会收到 SMTP 错误。
为此，请转到发件人 gmail 帐户中的管理您的帐户
Manage You Account Edited
然后转到顶部面板上的安全，打开低安全访问。
Less Secure Your Account
就这样，现在试着运行你的代码！它将开始发送电子邮件。在终端中运行服务器:
python manage.py runserver
就这样，现在所有的邮件都发出去了！电子邮件将如下所示:
Attachment Email
结论
就这样，编码员们！我们现在可以使用 Django 从我们的 Web 应用程序成功发送电子邮件了。
你可以试着实现上面的代码作为练习。下一篇文章再见！！继续练习！！
Python how to–使用 Python 发送电子邮件
原文：https://www.askpython.com/python/examples/sending-emails-using-python
大家好！在今天的文章中，我们将看看如何使用 Python 发送电子邮件。
发送电子邮件–简要概述
通常，发送电子邮件的任务是使用 MTP(邮件传输协议)完成的。目前，有一种称为 SMTP(简单邮件传输协议)的独立协议，它是广泛使用的发送电子邮件的协议。
与其他协议类似，该协议基于客户端-服务器工作。当我们想要发送电子邮件到目标机器时，我们(客户端)需要发送邮件内容到 SMTP 服务器。服务器现在会将其路由到所需的目标机器。
因此，为了发送电子邮件，你需要使用 SMTP 服务器。虽然您可能有一个自定义的 SMTP 服务器，但我们将使用 Gmail 的免费 SMTP 服务器通过 Gmail 发送电子邮件！
使用 Python 发送电子邮件的先决条件设置
在阅读本教程的其余部分之前，我建议你建立一个虚拟的 gmail 帐户，你可以用它来测试发送电子邮件。
设置好帐户后，您还需要做一件事。
默认情况下，您的 Gmail 帐户未配置为允许来自安全性较低的应用程序(如 SMTP)的访问。我们需要为我们的帐户启用此访问权限。
您可以进入您的 gmail 帐户配置页面，从您的谷歌帐户启用访问。
Less Secure Access Gmail
现在，您已经准备好使用 Python 发送电子邮件了！我们继续吧。
使用 Python SMTP 发送电子邮件
Python 有一个 SMTP 客户端库(smtplib)，它将使用这个库向 SMTP 服务器(Gmail)发送电子邮件。
这是标准库的一部分，可以直接导入！
import smtplib
好了，现在让我们试着写一个发送测试邮件的脚本。
任何使用 SMTP 的电子邮件必须包含以下内容:
- 发件人地址
- 接收者地址
- 主题(可选)
- 邮件的正文
让我们把它们都写下来。
import smtplib
sender_address = "[email protected]" # Replace this with your Gmail address
receiver_address = "[email protected]" # Replace this with any valid email address
account_password = "xxxxxxxxxx" # Replace this with your Gmail account password
subject = "Test Email using Python"
body = "Hello from AskPython!\n\nHappy to hear from you!\nWith regards,\n\tDeveloper"
# Endpoint for the SMTP Gmail server (Don't change this!)
smtp_server = smtplib.SMTP_SSL("smtp.gmail.com", 465)
# Login with your Gmail account using SMTP
smtp_server.login(sender_address, account_password)
# Let's combine the subject and the body onto a single message
message = f"Subject: {subject}\n\n{body}"
# We'll be sending this message in the above format (Subject:...\n\nBody)
smtp_server.sendmail(sender_address, receiver_address, message)
# Close our endpoint
smtp_server.close()
确保用您的 Gmail 帐户信息替换sender_address、receiver_address和account_password！
我们正在做的是使用 SMTP 服务器访问我们的 Gmail 帐户，使用安全的 SMTP ( SMTP_SSL)。我们登录后，可以直接发送消息给接收者，使用smtp_server.sendmail()！
现在，如果你输入相同的发件人和收件人帐户，你会收到一封类似我的电子邮件。
Python Test Email
让我们检查一下里面的东西。
Python Test Email Result
事实上，我们刚刚使用 Python 发送了一封合适的电子邮件！
您可以改进代码，使用上下文管理器来确保资源总是关闭的。
import smtplib
sender_address = "[email protected]" # Replace this with your Gmail address
receiver_address = "[email protected]" # Replace this with any valid email address
account_password = "xxxxxxxxxx" # Replace this with your Gmail account password
subject = "Test Email using Python"
body = "Hello from AskPython!\n\nHappy to hear from you!\nWith regards,\n\tDeveloper"
# We can use a context manager
with smtplib.SMTP_SSL("smtp.gmail.com", 465) as smtp_server:
# Login with your Gmail account using SMTP
smtp_server.login(sender_address, account_password)
# Let's combine the subject and the body onto a single message
message = f"Subject: {subject}\n\n{body}"
# We'll be sending this message in the above format (Subject:...\n\nBody)
smtp_server.sendmail(sender_address, receiver_address, message)
这将给出与之前相同的结果-另一封电子邮件！
结论
在这篇文章中，我们看了如何使用 Python 通过 gmail 的 SMTP 服务器轻松发送电子邮件。
参考
- Python SMTP 文档
使用 Python 进行情感分析
原文：https://www.askpython.com/python/sentiment-analysis-using-python
欢迎来到使用 Python 进行情感分析的教程。众所周知，人类的情感经常以面部表情、语言交流甚至书面方言或评论的形式表现出来。让我们看看如何使用 Python 来预测这一点。
使用 Python 进行情感分析简介
随着机器学习的趋势，不同的技术被应用于数据，以做出类似于人脑的预测。
人工智能对这些任务的阐述，将我们带入了深度学习和自然语言处理的深处。
情感分析是一种自然语言处理技术。
什么是自然语言处理？
自然语言处理(NLP)是人工智能的一个子集，机器被训练来分析文本数据。情感分析是一种预测作者情感的 NLP 技术。对于情绪，我们通常指的是积极的、消极的或中性的。
NLP 是一个广阔的领域，情感检测的任务可以使用内置的库来完成，例如 NLTK(自然语言工具包)和各种其他的库。
清理文本以进行解析和处理
任何原始形式的文本数据都不能被 NLP 库分析。需要使用各种数据处理技术来清理这些数据，例如:
- 消除 HTML 标签:非结构化的文本包含了大量的噪音，因此我们需要移除 HTML 标签。
- 消除重音字符:由于 NLP 主要适用于英语，重音字符的存在毫无意义，因此需要删除。
- 扩展缩写:音节在英语口语中经常使用，因此有必要将其扩展为原始形式。
- 去除特殊字符:文本中任何非字母数字字符都需要去除。
- 词汇化/词干化:需要得出单词的基础形式，即游泳的基础形式是 swim。
- 去掉停用词:冠词、连词、介词等停用词需要去掉。
在所有上述过程之后，我们的文本(在 NLP 术语中通常称为语料库)被传递到我们的情感分析模型。
我放了一些经过上述过程转换的例句。
Before:
Terrible airport with arrogant staff and poor signage.
After:
terrible airport arrogant staff poor signage
Before:
The airport is huge and has almost all the facilities making the transit smooth.
After:
airport huge almost facility make transit smooth
Before:
The display told me that desks 59-62 were for Silkair, but in reality it was from 52-55.
After:
display tell desk 59 62 silkair reality 52 55
我们将在下面的情感分析模型中使用上面经过预处理的句子。
使用 Python 执行情感分析
我们将首先使用 Python 对其进行编码，然后传递示例来检查结果。我们将使用 TextBlob 库来执行情感分析。
在下面定义的函数中，文本语料库被传递到函数中，然后 TextBlob 对象被创建并存储到分析对象中。
文本通过TextBlob()后获得了一些属性，比如包含极性的情感。然后检查这些极性值。
如果极性大于 0，情感为positive，如果极性等于 0，情感为neutral，如果极性小于 0，情感为negative。
from textblob import TextBlob
def get_tweet_sentiment(text):
analysis = TextBlob(textt)
if analysis.sentiment.polarity > 0:
return 'positive'
elif analysis.sentiment.polarity == 0:
return 'neutral'
else:
return 'negative'
我们的示例语句的输出如下:
Input corpus:
terrible airport arrogant staff poor signage
Sentiment:
negative
Input corpus:
display tell desk 59 62 silkair reality 52 55
Sentiment:
neutral
Input corpus:
airport huge almost facility make transit smooth
Sentiment:
positive
完全码
from textblob import TextBlob
def get_tweet_sentiment(text):
analysis = TextBlob(textt)
if analysis.sentiment.polarity > 0:
return 'positive'
elif analysis.sentiment.polarity == 0:
return 'neutral'
else:
return 'negative'
print(get_tweet_sentiment(<your text>))
我们模型的缺点
我们的情感分析模型无法预测任何讽刺评论的情感。事实上，预测讽刺性的推文不在 NLP 的范围内(截至今天)。
结论
我希望这篇文章对使用自然语言处理进行文本情感分析有所启发。请尝试你自己的陈述，并在评论区告诉我们你的反馈。
Python 中的 Sentinel 搜索–简单解释
原文：https://www.askpython.com/python/examples/sentinel-search
Sentinel Search 是一种搜索算法，用于搜索以顺序方式存储的项目列表。在本教程中，我们将研究该算法如何工作，我们将把它与线性搜索进行比较，我们将使用该算法来看看它是否有效。
先决条件:线性搜索
在我们继续进行哨兵搜索之前，我们需要了解它为什么存在，为此我们需要首先了解 线性搜索 。
在线性搜索中，我们线性地遍历列表中的每一项，并将其与目标进行比较，最后，我们要么找到所需的项，要么找不到。
在这个过程中，我们在每次迭代中进行两次比较。第一个比较是列表是否结束，第二个比较是当前条目是否匹配目标。但是，如果有一种方法可以减少这些比较，使搜索速度更快呢？这就是哨兵搜索打算做的。
什么是哨兵搜索？
类似于线性搜索，哨兵搜索是一种顺序搜索算法。这意味着我们要逐一比较列表中的每一项。但是这个算法比线性搜索更快，因为它减少了我们必须做的比较次数。
在 sentinel search 中，我们首先在列表的末尾插入目标，然后比较列表中的每一项，直到找到所需的项。要么所需的项目在列表中，在这种情况下，它将在我们到达列表末尾之前被找到。或者列表没有目标，所以算法会到达列表的末尾，找到我们插入的目标项。
在这里，我们只需要检查项目是否与目标匹配，不需要检查列表是否为空。这是因为我们无论如何都要找到目标，跳出这个循环。
最后，我们可以检查我们找到的项目是否已经存在或者是我们添加的。这种检查将只发生一次，算法的整个运行时间将大大减少，因为我们在循环的每次迭代中少做一次比较。
在 Python 中实现哨兵搜索
让我们看看用 python 写的 sentinel search:
def sentinel(lst, target):
size = len(lst)
lst.append(target)
i = 0
while(lst[i] != target):
i += 1
if(i == size):
return None
else:
return i
在上面的代码中，我们从获取列表的大小开始，然后在列表的末尾追加目标。
之后，我们启动一个 while-loop 来检查当前项目是否与目标相同。既然我们已经把目标放在了最后，循环肯定会结束。
最后，我们检查它是否在最后一个元素结束。如果是，那么目标不在列表中，否则，它在列表中。我们相应地返回适当的值。
输出
让我们试着运行代码，看看它是如何工作的:
Sentinel Search Output
结论
在本教程中，我们看到了什么是 sentinel search，我们为什么使用它，它与线性搜索有何不同，它在 python 中的实现，最后是它的输出。
希望你学得愉快，下次教程再见。
将 JSON 序列化和反序列化为 Python 中的对象
原文：https://www.askpython.com/python/examples/serialize-deserialize-json
读者朋友们，你们好！在本文中，我们将关注 Python 中 JSON 到对象的序列化和反序列化的概念。
所以，让我们开始吧！！🙂
在处理数据和 API 时，我们会遇到字典或 JSON 格式的数据。有时，我们需要一些函数来实现它们之间的相互转换。我们将了解一些序列化和反序列化数据的方法。
也读作: Python JSON 模块
Python 中 JSON 数据的序列化
序列化是将原始数据的数据类型转换成 JSON 格式的过程。因此，我们的意思是说，原始数据通常是一个字典现在将遵循 Javascript 对象符号格式。
同样，Python 为我们提供了下面的函数来轻松地将我们的数据公式化为 JSON——
- json.dump()函数
- json.dumps()函数
json.dump()函数
在 json.dump()函数中，它接受原始数据作为输入，将数据转换成 json 格式，然后存储到 JSON 文件中。
语法:
json.dump(data, file-object)
- 数据:需要转换成 JSON 格式的实际数据。
- file-object:它是指向存储转换后的数据的 JSON 文件的对象。如果文件不存在，则在对象指向的位置创建一个新文件。
举例:
import json
data= {
"details": {
"name": "YZ",
"subject": "Engineering",
"City": "Pune"
}
}
with open( "info.json" , "w" ) as x:
json.dump( data, x )
json.dumps()函数
与 dump()函数不同，json.dumps()函数确实将原始数据转换为 json 格式，但将其存储为字符串，而不是指向文件对象。
语法:
json.dumps(data)
举例:
import json
data= {
"details": {
"name": "YZ",
"subject": "Engineering",
"City": "Pune"
}
}
res = json.dumps(data)
print(res)
输出—
{"details": {"name": "YZ","subject": "Engineering","City": "Pune"}}
JSON 数据的反序列化
理解了反序列化之后，现在让我们颠倒一下这个过程。
也就是说，通过反序列化，我们可以很容易地将 JSON 数据转换成默认/本地数据类型，通常是一个字典。
同样，Python 为我们提供了以下函数来实现反序列化的概念
- json.load()函数
- json.loads()函数
json.load()函数
这里，load()函数使我们能够将 JSON 数据转换成本地字典格式。
语法:
json.load(data)
举例:
在这个例子中，我们首先使用 open()函数加载 JSON 文件。之后，我们将引用 JSON 文件的对象传递给 load()函数，并将其反序列化为字典的形式。
import json
data = open('info.json',)
op = json.load(data)
print(op)
print("Datatype after de-serialization : " + str(type(op)))
输出:
{"details": {"name": "YZ","subject": "Engineering","City": "Pune"}}
Datatype after de-serialization : <class 'dict'>
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
更多与 Python 编程相关的帖子，请继续关注我们。
在那之前，学习愉快！🙂
Python 中的浅层拷贝与深层拷贝
原文：https://www.askpython.com/python-modules/shallow-copy-vs-deep-copy
在本文中，我们将看看浅层拷贝和深层拷贝之间的区别。我们不时需要在程序中创建各种变量的副本/克隆。这可以通过使用浅层复制或深层复制来完成。
浅拷贝 vs 深拷贝
在本教程中，我们将学习浅拷贝和深拷贝之间的区别。所以让我们开始吧！
浅层复制
让我们看看下面这段代码。
l1 = [[10,20,30],[40,50,60],[70,80,90]]
l2 = list(l1)
print("list 1: ",l1)
print("list 2: ",l2)
l1.append(['I am new element'])
print("new list 1: ",l1)
print("new list 2: ",l2)
代码的输出如下所示。
list 1: [[10, 20, 30], [40, 50, 60], [70, 80, 90]]
list 2: [[10, 20, 30], [40, 50, 60], [70, 80, 90]]
new list 1: [[10, 20, 30], [40, 50, 60], [70, 80, 90], ['I am new element']]
new list 2: [[10, 20, 30], [40, 50, 60], [70, 80, 90]]
现在我们可以看到,l2是使用l1列表创建的。 l2 列表是一个新的独立列表，稍后可以看到。当一个新元素被添加到 l1 时，l2 保持不变！
这就是所谓的浅抄！但是现在让我们看看下面给出的代码。
l1 = [[10,20,30],[40,50,60],[70,80,90]]
l2 = list(l1)
print("list 1: ",l1)
print("list 2: ",l2)
l1[2][1] = 'I am changed'
print("new list 1: ",l1)
print("new list 2: ",l2)
你认为输出会是什么？在阅读输出之前，请亲自尝试一下！发现什么奇怪的事了吗？是啊！这次 l2 也变了。
代码的输出如下所示。
list 1: [[10, 20, 30], [40, 50, 60], [70, 80, 90]]
list 2: [[10, 20, 30], [40, 50, 60], [70, 80, 90]]
new list 1: [[10, 20, 30], [40, 50, 60], [70, 'I am changed', 90]]
new list 2: [[10, 20, 30], [40, 50, 60], [70, 'I am changed', 90]]
这背后的原因是，即使 l2 是 l1 的浅拷贝，l1 和 l2 的元素仍然引用同一个内存位置。因此，对一个列表的初始元素进行任何修改都会改变第二个列表。
您还可以使用copy模块的 copy函数创建浅层副本，如下面的代码所示。您可以看到输出看起来完全一样。
import copy
l1 = [[10,20,30],[40,50,60],[70,80,90]]
l2 = copy.copy(l1)
print("list 1: ",l1)
print("list 2: ",l2)
print()
l1.append(['new'])
print("new list 1: ",l1)
print("new list 2: ",l2)
print()
l1[2][1] = 'change'
print("new list 1: ",l1)
print("new list 2: ",l2)
代码的输出如下所示。您可以看到输出与前面的方法相同。
list 1: [[10, 20, 30], [40, 50, 60], [70, 80, 90]]
list 2: [[10, 20, 30], [40, 50, 60], [70, 80, 90]]
new list 1: [[10, 20, 30], [40, 50, 60], [70, 80, 90], ['new']]
new list 2: [[10, 20, 30], [40, 50, 60], [70, 80, 90]]
new list 1: [[10, 20, 30], [40, 50, 60], [70, 'change', 90], ['new']]
new list 2: [[10, 20, 30], [40, 50, 60], [70, 'change', 90]]
深度复制
现在让我们运行下面的代码，看看输出的不同。
import copy
l1 = [[10,20,30],[40,50,60],[70,80,90]]
l2 = copy.deepcopy(l1)
print("list 1: ",l1)
print("list 2: ",l2)
l1[2][1] = 'change'
print("new list 1: ",l1)
print("new list 2: ",l2)
这次看到输出很惊讶吧？通过使用同一个模块的copy模块和deepcopy函数，两个列表在所有方面都变得完全相互独立。
深度复制代码的输出如下所示。
list 1: [[10, 20, 30], [40, 50, 60], [70, 80, 90]]
list 2: [[10, 20, 30], [40, 50, 60], [70, 80, 90]]
new list 1: [[10, 20, 30], [40, 50, 60], [70, 'change', 90]]
new list 2: [[10, 20, 30], [40, 50, 60], [70, 80, 90]]
结论
所以今天我们学习了 Python 中的浅层拷贝和深层拷贝。我们还了解到，浅层拷贝对象只是部分独立于原始对象。而在深度复制中，对象彼此完全独立。
深度复制的缺点之一是比实现浅层复制要慢。两者都可以使用复制模块来实现。
感谢您的阅读！希望你学到了一些东西！
Python shape 方法:识别 Python 对象的维度
原文：https://www.askpython.com/python-modules/pandas/shape-method
Python shape 方法返回一个[tuple](https://www.askpython.com/python/tuple/python-tuple),表示应用它的 Python 对象的尺寸。这些应用了shape方法的 Python 对象通常是一个numpy.array或一个pandas.DataFrame。由shape方法返回的元组中的元素数量等于 Python 对象中的维数。每个tuple元素代表对应于 Python 对象的维度的元素数量。
熊猫:形状方法
熊猫 中的shape方法返回一个代表DataFrame维度的tuple，即(行&列)。
1.检查数据框的尺寸
# Import Pandas Python module
import pandas as pd
# Create a Python list
ls =[['A','B','C','D'], ['e' ,'f' ,'g' ,'h'], [11, 22, 33, 44]]
# Create a Pandas DataFrame from the above list
df = pd.DataFrame(ls)
# Print the DataFrame
print(df)
# Check the dimensions of the DataFrame
print(df.shape)
输出:
0 1 2 3
0 A B C D
1 e f g h
2 11 22 33 44
(3, 4)
shape方法返回了一个元组 (3，4) ，其中有两个元素描述了 DataFrame 具有三行四列的两个维度。
2.检查空数据框的尺寸
# Import Pandas Python module
import pandas as pd
# Create an empty Pandas DataFrame
df = pd.DataFrame()
# Print the DataFrame
print(df)
# Check the dimensions of the empty DataFrame
print(df.shape)
输出:
Empty DataFrame
Columns: []
Index: []
(0, 0)
shape方法返回了一个元组 (0，0) ，其中包含两个元素，描述了 DataFrame 具有零行零列的两个维度。
NumPy:形状方法
NumPy 中的shape方法返回一个代表numpy array尺寸的tuple。
1.检查 numpy 数组的维数
# Import Python NumPy module
import numpy as np
# Define a numpy array with zero dimensions
arr = np.array([[[1,2] ,[3,5]], [[2,3] ,[4,7]], [[3,4] ,[5,8]]])
# Print the numpy array
print(arr)
# Check the dimensions of arr
print(arr.shape)
输出:
[[[1 2 3]
[3 5 6]]]
(1, 2, 3)
shape方法返回了一个元组 (1，2，3) ，它有三个元素，表示数组有三个维度，每个维度分别有一个、两个和三个元素。
2.检查零维 numpy 数组的维数
# Import Python NumPy module
import numpy as np
# Define a numpy array with zero dimensions
arr = np.array(0)
# Print the numpy array
print(arr)
# Check the dimensions of arr
print(arr.shape)
输出:
0
()
shape方法返回了一个空元组 () ，其中包含零个元素，表示数组的维数为零。
3.检查一个一维但没有元素的 numpy 数组的维数
# Import Python NumPy module
import numpy as np
# Define a numpy array from an empty list
arr = np.array([])
# Print the numpy array
print(arr)
# Check the dimensions of arr
print(arr.shape)
输出:
[]
(0,)
shape方法返回了一个元组 (0，)，其中一个元素表示数组只有一个包含零个元素的维度。
总结
在本教程中，我们学习了如何使用 Python 中的shape方法来找出 Python 对象的维度(NumPy 数组或 Pandas DataFrame)。
Python 中的 Shutil 模块
嘿！在本教程中，我们将学习 Python 的 shutil 模块中的函数。那么，我们开始吧。
Python 的 shutil 模块为我们提供了许多对文件的高级操作。我们可以复制和删除文件和目录。让我们从模块开始，详细了解每个文件的实际实现。
如何用 shutil 模块复制文件？
shutil 模块中有多种方法可以将一个文件的内容复制到另一个文件中。
1.shutil.copyfileobj(src，dst)
假设，我们想将文件 data.txt 的内容复制到 data1.txt 中，我们可以使用下面这段代码:
import shutil
f=open('data.txt','r')
f1=open('data1.txt','w')
# Syntax: shutil.copyfileobj(src,dst)
shutil.copyfileobj(f,f1)
f.close()
f1.close()
2. shutil.copy(src,dst)
将一个文件的数据复制到另一个文件的另一种方法可以是不创建文件对象。这里，我们传递文件的相对路径。
import shutil
#shutil.copy(src.dst)
shutil.copy('data.txt','data1.txt')
3. shutil.copy2(src,dst)
copy (src，dst)copy 2(src，dst) 功能几乎相同，但 copy2(src，dst) 也复制源文件的元数据。
元数据包括关于文件何时被创建、访问或修改的信息。
import shutil
#shutil.copy2(src,dst)
shutil.copy2('data.txt','data1.txt')
4. shutil.copyfile(src,dst)
这里，源和目标可以是相对路径或绝对路径。假设，我们想将一个文件复制到一个文件夹中，我们可以使用下面的代码片段:
import shutil
import os
path='D:\DSCracker\DS Cracker\Python'
print("Before copying file:")
print(os.listdir(path))
shutil.copyfile('data.txt','Python/data3.txt')
print("After copying file:")
print(os.listdir(path))
输出:
Before copying file:
['hey.py']
After copying file:
['data3.txt', 'hey.py']
5. shutil.move(src,dst)
假设，我们想从一个位置删除一个文件，并将其移动到另一个位置。这里，让我们将 shutil.py 从源文件移动到另一个位置:
import shutil
import os
path='D:\DSCracker\DS Cracker'
print("Source folder:")
print(os.listdir(path))
path1='D:\DSCracker\DS Cracker\Python'
shutil.move('shutil.py','Python')
print("After moving file shutil.py to destination folder, destination contains:")
print(os.listdir(path1))
输出:
Source folder:
['cs', 'data.txt', 'Python', 'ReverseArray', 'ReverseArray.cpp', 'shutil.py']
After moving file shutill.py to destination folder, destination contains:
['data1.txt', 'data3.txt', 'hey.py', 'nsawk.py', 'shutil.py']
6. shutil.copytree(src,dst)
如果我们想将一个包含所有文件的完整文件夹复制到一个新位置，我们可以使用 copytree(src，dst )函数。
它递归地将以 src 为根的整个目录树复制到名为 dst 的目录中，并返回目标目录。
让我们将文件夹 Python 复制到文件夹 Newfolder 中。
注意:我们必须在目标文件夹中创建一个新文件夹，因为该功能不允许将内容复制到现有文件夹中。
所以在这里，我们在文件夹 Newfolder 中创建了文件夹 python1 。
import os
import shutil
path='D:\DSCracker\DS Cracker\Python'
print("Source folder:")
print(os.listdir(path))
shutil.copytree('Python','NewPython/python1')
path1='D:\DSCracker\DS Cracker\NewPython\python1'
print("Destination folder:")
print(os.listdir(path1))
输出:
Source folder:
['data1.txt', 'data3.txt', 'hey.py', 'nsawk.py', 'shutill.py']
Destination folder:
['data1.txt', 'data3.txt', 'hey.py', 'nsawk.py', 'shutill.py']
如何用 shutil 模块移除/删除文件？
既然我们已经学习了如何移动和复制文件，那么让我们学习从 Python 脚本中的特定位置移除或删除文件。
通过使用 shutil.rmtree() ，我们可以删除任何文件夹、文件或目录。让我们删除文件夹 Python 。
import os
import shutil
path='D:\DSCracker\DS Cracker'
print("Before deleting:")
print(os.listdir(path))
shutil.rmtree('Python')
print("After deleting:")
print(os.listdir(path))
输出:
Before deleting:
['cs', 'data.txt', 'NewPython', 'program.py', 'Python', 'ReverseArray', 'ReverseArray.cpp']
After deleting:
['cs', 'data.txt', 'NewPython', 'program.py', 'ReverseArray', 'ReverseArray.cpp']
如何将一个文件的权限位复制到另一个文件？
复制文件是一部分。如果您只想将一个文件的相同权限复制到所有其他文件，该怎么办？让我们在这里使用 shutil 模块来学习如何做这件事。
1.shutil.copymode(夏令时，夏令时)
此方法将权限位从 src 复制到 dst。让我们将 Python 目录的权限位复制到 Python1 目录。
import shutil
import os
src= 'D:\\DSCracker\\DS Cracker\\Python'
dest='D:\\DSCracker\\DS Cracker\\Python1'
print("Before using shutil.copymode(), Permission bits of destination:")
print(oct(os.stat(dest).st_mode)[-3:])
shutil.copymode(src, dest)
print("After using shutil.copymode(), Permission bit of destination:")
print(oct(os.stat(dest).st_mode)[-3:])
输出:
Before using shutil.copymode(), Permission bits of source:
677
After using shutil.copymode(), Permission bit of destination:
777
2. shutil.copystat(src、dst)
shutil.copystat(src.dst)将权限位与元数据一起复制。
import shutil
import os
import time
src= 'D:\\DSCracker\\DS Cracker\\Python'
dest='D:\\DSCracker\\DS Cracker\\Python1'
print("Before using shutil.copystat():")
print("Permission bits:",oct(os.stat(src).st_mode)[-3:])
print("Last modification time:", time.ctime(os.stat(src).st_mtime))
print("Modification time:",time.ctime(os.stat(src).st_mtime))
shutil.copystat(src, dest)
print("After using shutil.copystat():")
print("Permission bits:",oct(os.stat(dest).st_mode)[-3:])
print("Last modification time:", time.ctime(os.stat(dest).st_mtime))
print("Modification time:",time.ctime(os.stat(dest).st_mtime))
输出:
Before using shutil.copystat():
Permission bits: 777
Last modification time: Mon Dec 7 02:20:37 2020
Modification time: Mon Dec 7 02:20:37 2020
After using shutil.copystat():
Permission bits: 777
Last modification time: Mon Dec 7 03:43:47 2020
Modification time: Mon Dec 7 03:43:47 2020
shutil 模块中的其他功能
现在让我们来看看 shutil 模块的其他函数。
1.shutil.disk_usage(路径)
shutil.disk_usage(path) 函数以元组的形式返回给定路径名的磁盘使用统计信息，其属性为 total 即内存总量， used 即已用空间， free 即可用空间(以字节为单位)。
import shutil
import os
path = 'D:\\DSCracker\\DS Cracker\\NewPython\\python1'
statistics=shutil.disk_usage(path)
print(statistics)
输出:
usage(total=1000203087872, used=9557639168, free=990645448704)
2.shutil.which()
shutil.which() 函数返回可执行应用程序的路径，如果调用给定命令 cmd，该应用程序将运行。
import shutil
import os
cmd='Python'
locate = shutil.which(cmd)
print(locate)
输出:
C:\Users\AskPython\AppData\Local\Microsoft\WindowsApps\Python.EXE
结论
在本教程中，我们介绍了如何使用 python 中的 shutil 模块来复制、删除和处理文件和文件夹的其他操作。希望你们都喜欢。敬请期待！
参考
Python 中的 sigmoid 激活函数
原文：https://www.askpython.com/python/examples/sigmoid-activation-function
如果你正在学习神经网络，很有可能你已经遇到了术语激活功能。在神经网络中，激活函数决定特定神经元是否会被激活。激活函数将节点的加权和作为输入，并根据激活函数执行一些数学计算，并输出决定神经元是否将被激活的值。
它们有许多激活功能，如
在本教程中，我们将学习乙状结肠激活功能。所以让我们开始吧！
什么是 sigmoid 函数——它背后的数学
Sigmoid 是一个非线性激活函数。它主要用于我们需要预测某件事的概率的模型中。由于概率存在于 0 到 1 的取值范围内，因此乙状结肠的范围也是从 0 到 1 ，包括 0 和 1。让我们来看看 sigmoid 函数的方程。
Sigmoid Equation
Sigmoid 通常用希腊符号 sigma 来表示。所以，我们也可以写
Sigmoid Equation 1
上式中， e 为欧拉数。其值约为 2.718 。同样的，
Sigmoid -x Equation 1
事实上，我们可以推导出上述两个方程之间的关系如下
Sigmoid x And -x Relation
我们也可以证明这种关系，如下所示:
LHS:
LHS Equation 1
它也可以写成
LHS Equation 2
RHS:
RHS Equation 1
RHS Equation 2
因此，LHS=RHS
Sigmoid x And -x Relation Equation 2
因此，我们证明了这种关系。
sigmoid 激活函数的另一个性质是它是可微的。让我们看看如何区分它。
微分 sigmoid 方程 1 我们得到
Sigmoid Differentiation Equation 1
Sigmoid Differentiation Equation 2
所以，从的 Sigmoid 方程 1 、的 Sigmoid x 和-x 关系方程 2 和的 Sigmoid 微分方程 2 ，我们可以写出
Sigmoid And Its Differentiation Equation 1
或者，
Sigmoid And Its Differentiation Equation 2
唷！那是一大堆数学！现在，让我们看看 sigmoid 函数的图形。
使用 Python Matplotlib 的 Sigmoid 图
#importing the required libraries
from math import exp
from matplotlib import pyplot as plt
#defining the sigmoid function
def sigmoid(x):
return 1/(1+exp(-x))
#input
input = []
for x in range(-5, 5):
input.append(x)
#output
output = []
for ip in input:
output.append(sigmoid(ip))
#plotting the graph
plt.plot(input, output)
plt.title("Sigmoid activation function")
plt.grid()
#adding labels to the axes
plt.xlabel("x")
plt.ylabel("sigmoid(x)")
plt.scatter([0], [0.5], color="red", zorder=5)
plt.show()
输出:
Sigmoid Plot
上面的图让我们了解了 sigmoid 函数的一些性质。它们是:
- S 形:
sigmoid的图形和tanh激活函数的图形一样是 S 形的。 - 域:
sigmoid的域为(-∞，+∞)。 - 连续:
sigmoid函数处处连续。 sigmoid函数是单调递增的。- sigmoid(0)= 0.5
乙状结肠与 tanh 的关系
我们之前在教程中讨论过 tanh 激活功能。
双曲正切的公式是:
tanh Equation
而且，
Sigmoid(2x) Equation
这两个功能是相关的:
Tanh Sigmoid Relation Equation
摘要
让我们快速回顾一下:sigmoid 激活函数是非线性的、单调的、S 形的、可微分的和连续的。仅此而已！我们已经了解了 sigmoid 激活函数及其性质。
希望这篇教程对你有所帮助。请点击查看更多与 Python 相关的教程。
构建单一感知器神经网络
原文：https://www.askpython.com/python/examples/single-perceptron-neural-network
欢迎光临。今天，我们将讨论如何构建一个基本的单感知器神经网络。
我想让这成为我们深入探究一切的系列文章的第一篇——CNN、迁移学习等等。因此，请务必将该网站加入书签，并经常查看。此外，这将包括一些数学，所以系好安全带。
什么是感知器？
它是神经网络(NN)的最基本单元。在一个复杂的神经网络中，所有的数据都要经过其中的几个环节，这些环节通常同时进行，并扮演不同的角色。但我们稍后会谈到这一点。
目前，什么是感知机？
在监督学习中，感知器是一种线性分类器。因此，任何可以被一条直线分割的数据集都可以使用感知器进行分类，即任何看起来像这样的数据集:
Linearly Separable Dataset Examples
最后一条不能被认为是线性可分的，因为它不是一条可以近似分离数据库的直线。
Perceptron
构建单一感知器神经网络
今天让我们继续构建我们的第一个单感知器神经网络。为此，我们将从创建数据开始。
1.创建我们的数据集
首先，我们需要数据集，在我们的例子中是一个 2D 数组。打开你的代码编辑器，Jupyter 笔记本，或者 Google Colab。
import pandas as pd
import numpy as np
import random
让我们制作数据。我在这个例子中考虑一个 20*20 的平面，以保持我们的结果小而简洁。
#Dataset
df = pd.DataFrame()
df['x'] = [random.randint(1,20) for x in range(10)]
df['y'] = [random.randint(1,20) for x in range(10)]
df.head()
现在，我们需要给这些贴上标签。所以我们会根据一条线过滤掉(我考虑的是 y=x)。所以线下面的每个点都是 y<x。
label=[]
for i in range(df.shape[0]):
if df.iloc[i,0] < df.iloc[i,1]:
label.append(1)
else:
label.append(-1)
df['label'] = label
df
Dataset With Labels For Neural Nets Perceptron Model
2.初始化值的权重
现在我们可以初始化权重。我们不能使用零值，所以我们将对权重采用随机均匀分布:
#weights and bias
weights = [np.round(random.uniform(-0.99,0.99),2) for i in range(2)]
然后，我们将权重乘以输入数据点并求和:
w = weights.copy()
X = [[df.iloc[i,0],df.iloc[i,1]] for i in range(df.shape[0])]
wx = [X[i][0]*w[0]+X[i][1]*w[1] for i in range(df.shape[0])]
现在，我们有了每个点的权重和输入的总和。
那么程序是什么，我们将把所有这些值一次一个地插入到激活函数中，然后基于输出我们将修改权重。
3.创建激活函数
现在我们来看激活函数。感知器处理总和，给我们一个标签，我们与原始标签进行比较，确定是否正确。如果不正确，则找到错误并调整权重，使得我们的解* 在原始方向上移动 *。
我们将使用 signum 函数:
如果 wx <=0，则输出为 0。否则，输出为 1。
for i in range(df.shape[0]):
if wx[i]<=0:
pred = 0
else:
pred = 1
记住，我们只有两个输入:x 和 y，而不是整个数据帧。因此，我们将扩展这个激活函数，一次接收一个数据点，然后找出误差并调整误差:
for i in range(df.shape[0]):
if wx[i]<=0:
pred = -1
else:
pred = 1
if pred != df['label'][i] :
err = df['label'][i] - pred
w[0] = w[0] + err
w[1] = w[1] + err
这个现在工作得很好。为了清楚地看到输出，我们将输入一组打印语句:
for i in range(df.shape[0]):
print('wx : ',wx[i])
if wx[i]<=0:
pred = -1
else:
pred = 1
print('label=',df['label'][i])
print('pred = ',pred)
if pred != df['label'][i] :
err = df['label'][i] - pred
print('err',err)
print('before', w[0],w[1])
w[0] = w[0] + err
w[1] = w[1] + err
print('after',w[0],w[1])
else:
print('w_i', w[0],w[1])
现在如果我们运行这个:
Updating Weights Single Perceptron Neural Network
一个简单的打印格式语句给出了最终的重量。
Final Weights Single Perceptron Neural Network
4.在另一个数据库上测试我们的模型
类似于我们如何进行训练-测试-分割，我们将在这里使用不同的数据库进行测试。
#Test Dataset
new_df = pd.DataFrame()
new_df['x'] = [random.randint(1,20) for x in range(100)]
new_df['y'] = [random.randint(1,20) for x in range(100)]
new_df.head()
然后，我们基于 y=x 线和权重之和*输入生成标签:
label_text = []
for i in range(new_df.shape[0]):
if new_df.iloc[i,0] < new_df.iloc[i,1]:
label_text.append(1)
else:
label_text.append(-1)
new_wX = w[0]*new_df['x']+w[1]*new_df['y']
这是我的:
New Weight Sums Neural Net
那么，现在是关键时刻，我们应用我们的激活函数，然后我们可以比较给定的标签和预测的标签:
new_df['given label'] = label_text
pred_label_text = []
for i in range(new_df.shape[0]):
if new_wX[i]>=0:
pred_label_text.append(-1)
else:
pred_label_text.append(1)
new_df['predicted labels'] = pred_label_text
Predicted Labels For New Dataset
如你所见，我们自己做得很好🙂
结论
祝贺您完成本教程。我希望这能让你对“感知机”有更多的了解。与我们保持联系，阅读我们未来的教程。
Python 中的奇异值分解
原文：https://www.askpython.com/python/examples/singular-value-decomposition
奇异值分解(SVD)是广泛使用的降维方法之一。SVD 将一个矩阵分解成另外三个矩阵。
如果我们将矩阵视为在空间中引起线性变换的东西，那么通过奇异值分解，我们将单个变换分解为三个运动。
在本文中，我们将看到实现 SVD 的不同方法。
奇异值分解基础
SVD 将一个单矩阵分别分解成矩阵 U，D，V*。
SVD
其中，
- u 和 V*是正交矩阵。
- d 是奇异值的对角矩阵。
SVD 也可以看作是将一个复杂的变换分解成 3 个简单的变换(旋转、缩放和旋转)。
就变换而言
- 矩阵 U 和 V*导致旋转
- 对角矩阵 D 导致缩放。
所以基本上它允许我们将原始矩阵表示为低秩矩阵的线性组合。只有前几个，奇异值大。
除了前几项之外的其他项可以忽略，而不会丢失太多信息，这就是 SVD 被称为降维技术的原因。
SVD 在 Python 中的实现
让我们从 Python 中 SVD 的实现开始。我们将使用多个库来演示实现将如何进行。
1.使用 Numpy
Python Numpy 具有实现大多数线性代数方法的能力，这使得 SVD 的实现非常容易。
我们将使用具有svd类的numpy.linalg模块在矩阵上执行 SVD。
import numpy as np
#Creating a matrix A
A = np.array([[3,4,3],[1,2,3],[4,2,1]])
#Performing SVD
U, D, VT = np.linalg.svd(A)
#Checking if we can remake the original matrix using U,D,VT
A_remake = (U @ np.diag(D) @ VT)
print(A_remake)
Restored Matrix
d 是 1D 数组而不是 2D 数组。d 是一个大部分值最终为零的对角矩阵，这样的矩阵称为稀疏矩阵。为了节省空间，它以 1D 数组的形式返回。
2.使用 scikit-learn
我们将使用来自sklearn.decomposition模块的TruncatedSVD类。
在TruncatedSVD中，我们需要指定输出中需要的组件数量，因此我们不需要计算整个分解，只需要计算所需的奇异值，并修整其余部分。
#Importing required modules
import numpy as np
from sklearn.decomposition import TruncatedSVD
#Creating array
A = np.array([[3,4,3],[1,2,3],[4,2,1]])
#Fitting the SVD class
trun_svd = TruncatedSVD(n_components = 2)
A_transformed = svd.fit_transform(A)
#Printing the transformed matrix
print("Transformed Matrix:")
print(A_transf)
Transformed Matrix
结论
在本文中，我们看到了如何使用像 Numpy 和 scikit-learn 这样的库来实现奇异值分解(SVD)。
快乐学习！
使用网络摄像头和 Python OpenCV 进行实时素描[简易指南]
原文：https://www.askpython.com/python/examples/sketch-using-webcam
在今天的教程中，你将学习 OpenCV 的一个应用，这将让你意识到 OpenCV 有多强大。
在该项目中，我们将采用一个实时网络摄像头，并在 numpy 和 OpenCV 库的帮助下将其转换为一个实时草图。
让我们从这个惊人的项目开始吧！
步骤 1:导入模块
首先，我们需要导入OpenCV和[Numpy](https://www.askpython.com/python/numpy-trigonometric-functions)(假设您已经安装了库)。我们在代码中定义 OpenCV 和 Numpy 如下:
import cv2
import numpy as np
步骤 2:定义一个函数将框架转换为草图
为了将一个框架转换成草图，我们将遵循下面列出的一些步骤:
- 将图像转换成
gray图像 - 对获得的灰度图像应用
Gaussian Blur - 将
Canny Edge Detection应用到高斯图像 - 最后，反转图像，得到
Binary Inverted Image
该函数的代码如下所示。
def sketch(image):
img_gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
img_gray_blur = cv2.GaussianBlur(img_gray, (5,5), 0)
canny_edges = cv2.Canny(img_gray_blur, 10, 70)
ret, mask = cv2.threshold(canny_edges, 70, 255, cv2.THRESH_BINARY_INV)
return mask
步骤 3:打开网络摄像头并应用功能
我们需要使用网络摄像头，并从视频中提取图像帧。为了达到同样的效果，我们将使用VideoCapture和read函数一个接一个地提取帧。
现在使用imshow功能显示实时网络摄像头，并应用上一步创建的草图功能。
最后一步是为窗口创建一个退出条件。这里我们保留了键Enter Key作为窗口的退出键。最后，摧毁程序中所有打开的和将要关闭的窗口。
cap = cv2.VideoCapture(0)
while True:
ret, frame = cap.read()
cv2.imshow('Our Live Sketcher', sketch(frame))
if cv2.waitKey(1) == 13: #13 is the Enter Key
break
cap.release()
cv2.destroyAllWindows()
完整的代码
import cv2
import numpy as np
def sketch(image):
img_gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
img_gray_blur = cv2.GaussianBlur(img_gray, (5,5), 0)
canny_edges = cv2.Canny(img_gray_blur, 10, 70)
ret, mask = cv2.threshold(canny_edges, 70, 255, cv2.THRESH_BINARY_INV)
return mask
cap = cv2.VideoCapture(0)
while True:
ret, frame = cap.read()
cv2.imshow('Our Live Sketcher', sketch(frame))
if cv2.waitKey(1) == 13: #13 is the Enter Key
break
cap.release()
cv2.destroyAllWindows()
最终输出
下面的小视频显示了运行上一节提到的全部代码后得到的最终输出。
结论
我希望你理解的概念，并喜欢输出。自己尝试简单的代码，并观察 OpenCV 库的强大功能。
编码快乐！😇
想了解更多？查看下面提到的教程:
Python 中如何切片字符串？
原文：https://www.askpython.com/python/string/slice-strings-in-python
介绍
在本教程中，我们将学习如何在 Python 中分割字符串。
Python 支持字符串切片。它是根据用户定义的起始和结束索引，从给定的字符串创建一个新的子字符串。
Python 中分割字符串的方法
如果你想在 Python 中分割字符串，就像下面这一行一样简单。
res_s = s[ start_pos:end_pos:step ]
这里，
- res_s 存储返回的子串，
- s 是给定的字符串，
- start_pos 是我们需要对字符串 s 进行切片的起始索引，
- end_pos 是结束索引，在此之前切片操作将结束，
- 步骤是切片过程从开始位置到结束位置的步骤。
注意:以上三个参数都是可选的。默认情况下，start_pos设置为 0 ，end_pos被认为等于字符串的长度，step设置为 1 。
现在让我们举一些例子来理解如何更好地在 Python 中切分字符串。
Python 中的切片字符串–示例
可以用不同的方式对 Python 字符串进行切片。
通常，我们使用简单的索引来访问字符串元素(字符)，从 0 到 n-1 (n 是字符串的长度)。因此，为了访问字符串string1的第个元素，我们可以简单地使用下面的代码。
s1 = String1[0]
还是那句话，访问这些字符还有另外一种方法，就是使用负索引。负分度从 -1 到 -n 开始(n 为给定字符串的长度)。注意，反向索引是从字符串的另一端开始的。因此，这次要访问第一个字符，我们需要遵循下面给出的代码。
s1 = String1[-n]
现在让我们来看看使用上述概念分割字符串的一些方法。
1.Python 中带开始和结束的切片字符串
我们可以通过提及我们正在寻找的期望子串的开始和结束索引来容易地分割给定的串。看下面给出的例子，它解释了使用开始和结束索引的字符串切片，包括通常的和负的索引方法。
#string slicing with two parameters
s = "Hello World!"
res1 = s[2:8]
res2 = s[-4:-1] #using negative indexing
print("Result1 = ",res1)
print("Result2 = ",res2)
输出:
Result1 = llo Wo
Result2 = rld
这里，
- 我们初始化一个字符串，
s为“Hello World！”， - 首先，我们用起始索引 2 和结束索引 8 对给定的字符串进行切片。这意味着得到的子串将包含从 s[2] 到 s[8-1] 的字符，
- 类似地，对于下一个，结果子字符串应该包含从 s[-4] 到 s[(-1)-1] 的字符。
因此，我们的产出是合理的。
2.仅使用开头或结尾分割字符串
如前所述，字符串切片的三个参数都是可选的。因此，我们可以使用一个参数轻松完成我们的任务。看看下面的代码就清楚了。
#string slicing with one parameter
s1= "Charlie"
s2="Jordan"
res1 = s1[2:] #default value of ending position is set to the length of string
res2 = s2[:4] #default value of starting position is set to 0
print("Result1 = ",res1)
print("Result2 = ",res2)
输出:
Result1 = arlie
Result2 = Jord
这里，
- 我们首先初始化两个字符串， s1 和 s2 ，
- 为了对它们进行切片，我们只对 s1 提到了 start_pos ，对 s2 只提到了 end_pos ，
- 因此，对于 res1 ，它包含从索引 2(如前所述)到最后一个(默认设置为 n-1)的 s1 的子串。而对于 res2，指数的范围从 0 到 4(已提及)。
3.Python 中带步长参数的切片字符串
step值决定切片操作从一个索引到另一个索引的跳转。仔细看下面的例子。
#string slicing with step parameter
s= "Python"
s1="Kotlin"
res = s[0:5:2]
res1 = s1[-1:-4:-2] #using negative parameters
print("Resultant sliced string = ",res)
print("Resultant sliced string(negative parameters) = ",res1)
输出:
Resultant sliced string = Pto
Resultant sliced string(negative parameters) = nl
在上面的代码中，
- 我们初始化两个字符串 s 和 s1 ，并尝试按照给定的起始和结束索引对它们进行切片，就像我们对第一个示例所做的那样，
- 但是这次我们提到了一个步骤值，在前面的例子中它被默认设置为 1，
- 对于 res，步长为 2 意味着，当遍历从索引 0 到 4 的子串时，每次索引都会增加值 2。即第一个字符是s[0](‘P’)，子串中的下一个字符将是 s[0+2] 和 s[2+2] ，直到索引刚好小于 5。
- 对于下一个，即 res1 ，提到的步骤是(-2)。因此，与前面的情况类似，子字符串中的字符将是 s1[-1] ，然后是 s1[(-1)+(-2)] 或 s1[-3] ，直到索引刚好小于(-4)。
4.在 Python 中使用切片反转字符串
通过使用 Python 中的负索引字符串切片，我们还可以反转字符串并将其存储在另一个变量中。为此，我们只需要提到一个大小为 (-1) 的step。
让我们看看下面的例子是如何工作的。
#reversing string using string slicing
s= "AskPython"
rev_s = s[::-1] #reverse string stored into rev_s
print(rev_s)
输出:
nohtyPksA
我们可以看到，字符串 s 被反转并存储到rev_s中。注意:在这种情况下，原来的弦也保持完好无损。
结论
因此，在本教程中，我们学习了字符串切片方法及其不同的形式。希望，读者对这个话题有一个清楚的了解。
关于这个话题的任何进一步的问题，请随意使用下面的评论。
参考
- Python 切片字符串——日志开发帖子，
- 分割字符串的方法？–stack overflow 问题。
在 Python 中寻找最小数字的 3 种简单方法
原文：https://www.askpython.com/python/examples/smallest-number-in-python
你好。这篇文章是为希望理解用 Python 寻找最小数的基本代码的初学者而写的。让我们开始吧。
如何在 Python 中求最小的数？
我们的目标是在 Python 中找到列表中给定的所有数字中最小的数字。
说如果列表是:[32，54，67，21]
输出应该是:21
在本文中，我们将了解 3 种不同的方法来做到这一点。
1.使用 Python min()
Min() 是 python 中的内置函数，它以一个列表作为参数，返回列表中最小的数字。下面给出一个例子
#declaring a list
list1 = [-1, 65, 49, 13, -27]
print ("list = ", list1)
#finding smallest number
s_num = min (list1)
print ("The smallest number in the given list is ", s_num)
输出:
list = [-1, 65, 49, 13, -27]
The smallest number in the given list is -27
这是求最小数的最简单的方法之一。您需要做的就是将列表作为参数传递给 min()。
2.使用 Python 排序()
Sort() 是 python 中的另一个内置方法，它不返回列表中最小的 号。相反，它按升序对列表进行排序。
所以通过对列表排序，我们可以使用索引来访问列表的第一个元素，这将是列表中最小的数字。让我们看看代码:
#declaring a list
list1 = [17, 53, 46, 8, 71]
print ("list = ", list1)
#sorting the list
list1.sort ()
#printing smallest number
print ("The smallest number in the given list is ", list1[0])
输出:
list = [17, 53, 46, 8, 71]
The smallest number in the given list is 8
3.使用“for”循环
ls1 = []
total_ele = int (input (" How many elements you want to enter? "))
#getting list from the user
for i in range (total_ele):
n =int (input ("Enter a number:"))
ls1.append(n)
print (ls1)
min = ls1[0]
#finding smallest number
for i in range (len (ls1)):
if ls1[i] < min:
min = ls1[i]
print ("The smallest element is ", min)
在上面的代码中，我们使用两个 用于循环，一个用于从用户处获取列表元素，另一个用于从列表中找到最小的数字。
从用户那里获得元素后，我们将列表的第一个元素(索引为 0)定义为最小的数(min)。然后使用 for 循环，我们将列表中的每个元素与最小的进行比较，如果任何元素小于最小的，它将成为新的最小的。
这就是我们如何从用户给定的列表中得到最小的数字。
上述代码的输出为:
How many elements you want to enter? 4
Enter a number: 15
Enter a number: 47
Enter a number: 23
Enter a number: 6
[15, 47, 23, 6]
The smallest number is 6
结论
这是一些在 python 中从给定列表中寻找最小数字的方法。希望你明白这一点！如果有任何问题，请随时提问。谢谢大家！🙂
Python:绘制平滑曲线
原文：https://www.askpython.com/python-modules/matplotlib/smooth-curves
嘿，同学们！今天我们将学习如何使用 matplotlib 和 SciPy 模块构建平滑曲线。
有时，您希望为数据可视化获得平滑曲线，以使绘图看起来更好、更优雅。幸运的是，在 matplotlib 和 SciPy 模块的帮助下，同样可以实现。
推荐阅读:用 Python 创作动画剧情
1。导入模块
第一步是将所需的模块导入我们的程序。我们将要实现目标的模块**numpy**、**matplotlib** 和、SciPy、模块，其中 numpy 用于数据准备，matplotlib 用于绘制简单曲线，SciPy 用于帮助绘制平滑曲线。
import numpy as np
from scipy.interpolate import make_interp_spline
import matplotlib.pyplot as plt
2。数据准备
为了准备数据，我们将使用 numpy 数组，因为它们更容易处理。我们将绘制一个正弦波，其中 x 坐标是 x 轴值，y 坐标是 x 的正弦值。
x = np.array([i for i in range(50)])
y = np.array([np.sin(i) for i in x])
3。制作 B 样条曲线
为了得到一条平滑的曲线，我们利用make_interp_spline函数通过传递 x 和 y 数组得到一条 B 样条曲线。它一起返回曲线的 x 和 y 系数。
我们需要做的下一件事是把系数彼此分开。下面的代码为您做了同样的事情。
B_spline_coeff = make_interp_spline(x, y)
X_Final = np.linspace(x.min(), x.max(), 500)
Y_Final = B_spline_coeff(X_Final)
4.绘制数据集
现在，最后一步是使用 matplotlib 库和必要的函数和配置来绘制图形，以使图形看起来更好。
plt.style.use('seaborn')
plt.plot(X_Final,Y_Final,color="red")
plt.title("Smooth Sine Wave")
plt.xlabel("x values")
plt.ylabel("y values")
plt.show()
最终输出图如下所示。
Smooth B Spline Curve
另一个例子
下面的代码在 matplotlib 的subplot函数的帮助下绘制了一些更平滑的曲线。
plt.figure(figsize=(15,15))
plt.subplot(3, 3, 1)
x = np.array([i for i in range(30)])
y = np.array([np.tan(i) for i in x])
B_spline_coeff = make_interp_spline(x, y)
X_Final = np.linspace(x.min(), x.max(), 500)
Y_Final = B_spline_coeff(X_Final)
plt.style.use('seaborn')
plt.plot(X_Final,Y_Final,color="red")
plt.title("Smooth Tan Wave")
plt.xlabel("x values")
plt.ylabel("y values")
plt.subplot(3, 3, 2)
x = np.array([i for i in range(30)])
y = np.array([np.exp(i) for i in x])
B_spline_coeff = make_interp_spline(x, y)
X_Final = np.linspace(x.min(), x.max(), 500)
Y_Final = B_spline_coeff(X_Final)
plt.style.use('seaborn')
plt.plot(X_Final,Y_Final,color="green")
plt.title("Smooth e^x Wave")
plt.xlabel("x values")
plt.ylabel("y values")
plt.subplot(3, 3, 3)
x = np.array([i for i in range(10)])
y = np.array([np.sqrt(i) for i in x])
B_spline_coeff = make_interp_spline(x, y)
X_Final = np.linspace(x.min(), x.max(), 500)
Y_Final = B_spline_coeff(X_Final)
plt.style.use('seaborn')
plt.plot(X_Final,Y_Final,color="pink")
plt.title("Smooth sqrt Wave")
plt.xlabel("x values")
plt.ylabel("y values")
plt.subplot(3, 3, 4)
x = np.array([i for i in range(30)])
y = np.array([5**i for i in x])
B_spline_coeff = make_interp_spline(x, y)
X_Final = np.linspace(x.min(), x.max(), 500)
Y_Final = B_spline_coeff(X_Final)
plt.style.use('seaborn')
plt.plot(X_Final,Y_Final,color="black")
plt.title("Smooth 5^x Wave")
plt.xlabel("x values")
plt.ylabel("y values")
plt.subplot(3, 3, 5)
x = np.array([i for i in range(-10,10,1)])
y = np.array([i**2 -5 for i in x])
B_spline_coeff = make_interp_spline(x, y)
X_Final = np.linspace(x.min(), x.max(), 500)
Y_Final = B_spline_coeff(X_Final)
plt.style.use('seaborn')
plt.plot(X_Final,Y_Final,color="orange")
plt.title("Smooth X^2-5 Wave")
plt.xlabel("x values")
plt.ylabel("y values")
plt.subplot(3, 3, 6)
x = np.array([i for i in range(30)])
y = np.array([3**i + i for i in x])
B_spline_coeff = make_interp_spline(x, y)
X_Final = np.linspace(x.min(), x.max(), 500)
Y_Final = B_spline_coeff(X_Final)
plt.style.use('seaborn')
plt.plot(X_Final,Y_Final,color="magenta")
plt.title("Smooth 3^x+x Wave")
plt.xlabel("x values")
plt.ylabel("y values")
plt.show()
代码的输出如下所示。
Multiple B Spline Curve
结论
恭喜你！今天我们学习了使用 matplotlib 和 SciPy 模块绘制完美的平滑曲线。您也可以尝试各种其他示例。
编码快乐！
感谢您的阅读！
阻止赌博 Sites的软件
原文：https://www.askpython.com/python/software-that-blocks-gambling-sites
通过阻止软件程序可以限制对某些在线服务或网站的访问。该软件可以安装在所有设备上，无论在设备上创建了多少个帐户，都可以阻止对服务和网站的访问。这是一个非常方便的工具，当谈到打击赌博成瘾。
有两种主要类型的阻止软件。一种是专门用于阻止赌博活动的软件，另一种是更通用的软件。它可以用来阻止任何网站一般喜欢建立家长控制。有多个软件应用程序在限制对目标网站或应用程序或其他服务的访问方面表现出色。
gamestop
Gamstop 是最受赌徒们欢迎的自我屏蔽软件之一。一个人可以参加 Gamstop 的自我排除计划，Gamstop 是由非营利机构国家在线自我排除计划有限公司控制的。
Gamstop 在英国限制在线赌博，并且是免费的。Gamstop 延伸到北爱尔兰和英国。一旦用户在 Gamstop 注册，所有获得许可的英国赌场都有访问限制。然而，英国的 no GamStop 在线赌场可通过各种门户网站访问。因此，您可以找到一些额外的应用程序来弥补这一差距。
β受体阻滞剂
BetBlocker 最突出的特点是它不局限于任何特定的国家。它屏蔽了世界各地的赌博网站，并免费运营。它可以根据选择安装在任何设备上，并在一段特定的时间内自动关闭。要知道除非限制期结束，否则不能取消。
除了阻止赌博平台，这个软件还加入了家长控制。因此，它也可以用来阻止一般的软件。BetBlocker 与世界各地的国家自我排斥计划合作。这提供了一个强大的阻止工具，可以抵制赌博的诱惑，保持对自己的承诺。
甘比昂
如果一个赌客想在网上阻止多个赌场，Gamban 总是一个首选。2018 年，GambleAware 资助了一项研究，用于测量多种阻止软件的功效。Gamban 是所有游戏中最聪明、最有效的，可以通过任何 GamCare 网络免费获得。
Gamban 于 2015 年成立，团队由拥有处理赌博成瘾案件经验的专业人士组成。今天，这是最简单和最受欢迎的方法之一实现赌博阻止软件，它的想法非常简单。Gamban 是由一群聪明绝顶的技术专家组成的，他们让 Gamban 可以通过跨平台设备访问。软件的快速安装是可用的，也很容易访问。Gamban 还通过实时会议提供建议和支持，这有助于更好地应对这种情况。
网络保姆
当父母控制行使进入上下文时，NetNanny 是一个突出的阻止软件。它创建于 1993 年，至今已有 20 年历史，互联网过滤最早就是由这款软件实现的。
NetNanny 成立于温哥华，后来于 2000 年将总部迁至华盛顿的贝尔维尤。这主要解决了滥用互联网和不必要的内容弹出的问题。阻止不需要的应用程序和网站，检测孩子的位置，在线查看搜索历史，以及为某些应用程序和互联网的使用设置时间限制，这些都是对 NetNanny 的有效使用。
GamBlock
GamBlock 成立于 2000 年，最初是用来阻止未成年儿童赌博的软件。它阻止了工作场所和学校的各种在线赌博行为。Gamblock 目前一直在帮助赌徒应对赌博成瘾的后果。
它能迅速阻止新的博彩网站和服务，不像其他软件通常需要一定的时间。用户现在甚至可以获得多个许可证。GamBlock 目前正在修改其功能，以带来更强的安全性和诊断能力。
结论
阻止软件确实是阻止自己沉迷赌博或游戏的最佳策略。但在实现之前，你需要学习并理解它是如何工作的，最好的方法之一是通过在线课程，这些课程将帮助你理解他们的如何共享数据，使用技术，以及编程环境的许多其他功能。在赌博成瘾的情况下，赌客通常以紧张的关系和巨额债务告终。这些后果处理起来相当复杂，需要大量的时间。
所以，在这些顶尖程序的帮助下进行自我屏蔽，从长远来看，才是走出这种瘾的最好办法。它们在本质上是高效的，可以针对具体国家。然而，其他软件可以阻止全球各地的网站。英国以外的玩家和运营商不必遵守 Gamstop 或 UKGC 的限制。相反，他们在其管辖范围内使用自我排除要求和方案。另一方面，Betfilter、Gamblock 和上面提到的其他 Gamstop 替代品可以阻止对所有赌博材料的访问，无论是在英国还是在海外。
无法为 Numpy 构建轮子(已解决)
原文：https://www.askpython.com/python-modules/numpy/solved-could-not-build-wheels-for-numpy
对于许多人来说，Python 包的安装可能是一个令人困惑和沮丧的过程，尤其是在为 Numpy 构建轮子的时候。对于许多 Python 包来说，轮子是安装过程中的一个重要部分，如果不能构建轮子，包就可能无法安装。
在本文中，我们将讨论在尝试为 Numpy 构建轮子时可能出现的常见问题，以及如何解决这些问题。
什么是巨蟒轮？
Python Wheels 是 Python 环境中不可或缺的一部分，旨在简化 Python 包的安装。
它们通常与一个. whl 文件相关联，该文件是软件包的较小版本，因此安装起来更高效、更快速。这是因为它包含 Python 源代码和所有必需的元数据。
“wheel”这个名称是对 Python 存储库的原始名称“cheeseShop”的半开玩笑引用，cheeseShop 是一个奶酪轮子。
车轮和 Numpy 版本不兼容:
大多数时候，当你面对“无法为 NumPy 构建轮子”的错误时，通常是因为你的 NumPy 版本和你的 python 版本之间的版本不匹配。您要么需要更新您的 python 版本，要么显式设置您的 NumPy 版本以匹配您系统的 python 版本。
错误:无法为 NumPy 构建轮子
该错误主要出现在安装 numpy 包或与当前 python 版本不兼容的特定版本的 Numpy 包时，使用:
pip install numpy
或者
pip install numpy=1.24.0 #the latest version
给出输出:
ERROR: Failed building wheel for numpy
Failed to build numpy
ERROR: Could not build wheels for numpy
如何修复“无法为 NumPy 构建轮子”
有三种非常简单的方法可以解决这个错误，当你面对这个错误时，你不需要担心，因为它很容易解决。
1.从命令提示符或 python 终端升级 pip
通过在命令提示符下运行以下代码，在升级您的 pip 之前检查 python 版本:
python --version
接下来，建议使用命令提示符而不是 python IDE 终端来升级 pip。在命令提示符下运行以下命令:
python.exe -m pip install --upgrade pip
或者，如果使用 python IDE 终端，请使用:
pip install --upgrade pip
升级 pip 后，再次检查 python 版本。应该更新版本以匹配最新版本。
现在，通过运行以下命令尝试安装 numpy:
pip install numpy
现在，您应该会收到以下消息:
Successfully installed numpy- "latest version name"
2.根据 python 安装特定于版本的 NumPy
这是避免版本不匹配的轮子错误的另一个解决方案。在命令提示符下运行以下命令，首先检查 python 版本:
python --version
输出将给出您计算机上安装的 python 的具体版本。我的是最新版本，因此输出显示 python 3.11，如下所示:
Python 3.11.0
现在检查 numpy 的哪个版本与您计算机中的 python 版本兼容。点击此处访问官方网站，从所有版本中选择兼容版本。接下来，在命令提示符下运行以下命令:
pip install numpy == "required version number"
Numpy 应该安装成功。现在，您应该能够在所有项目中导入 numpy 了。
3.卸载 numpy 并重新安装 numpy
运行以下命令:
pip uninstall numpy
直到您收到一条消息:
no files available with numpy to uninstall
现在再次新鲜安装 numpy，你可以指定版本或不根据您的使用。
pip install numpy
这个问题现在应该已经解决了。
验证 numpy 版本
您可以在安装后通过运行以下命令来检查 numpy 版本:
pip show numpy
它将给出您已安装的 numpy 包的完整详细信息，如下所示:
Name: numpy
Version: 1.23.5
Summary: NumPy is the fundamental package for array computing with Python.
Home-page: https://www.numpy.org
Author: Travis E. Oliphant et al.
Author-email:
License: BSD
Location: C:\Users\AUTHOR\AppData\Local\Programs\Python\Python311\Lib\site-packages
Requires:
Required-by: contourpy, matplotlib, opencv-python
结论
“无法为 NumPy 构建轮子”这一错误可以通过几个简单的步骤来解决。升级 pip，按照 python 安装特定版本的 numpy，卸载并重新安装 NumPy 都是可能的解决方案。如果您仍然遇到问题，请确保检查您安装的 python 和 numpy 的版本，并确保它们是兼容的。
Python 中按值对字典排序的 3 种方法
原文：https://www.askpython.com/python/dictionary/sort-a-dictionary-by-value-in-python
嘿，伙计们！在本文中，我们将揭示用 Python 按值对字典进行排序的步骤。
技巧 1:在 Python 中使用 sorted()函数按值对字典进行排序
在 Python 中，sorted() method和 Python operator.itemgetter() method可以用来按值对字典进行排序。
Python 运算符模块具有各种内置函数来处理数据和值。operator.itemgetter(m)方法将输入对象视为 iterable，并从 iterable 中获取所有“m”值。
语法:Python operator . item getter(m)
operator.itemgetter(value)
Python sorted ()方法将 dict 按升序/降序排序。
语法:Python sorted()方法
sorted(iterable, key)
iterable:表示要排序的元素。key(可选):决定元素排序顺序的函数。
举例:
from operator import itemgetter
inp_dict = { 'a':3,'ab':2,'abc':1,'abcd':0 }
print("Dictionary: ", inp_dict)
sort_dict= dict(sorted(inp_dict.items(), key=operator.itemgetter(1)))
print("Sorted Dictionary by value: ", sort_dict)
在上面的函数中，我们设置了参数 key = operator.itemgetter(1 ),因为这里的“1”表示字典的值,“0”表示字典的键。因此，我们已经按照升序对字典进行了排序。
输出:
Dictionary: {'a': 3, 'ab': 2, 'abc': 1, 'abcd': 0}
Sorted Dictionary by value: {'abcd': 0, 'abc': 1, 'ab': 2, 'a': 3}
技术 2: Python lambda 函数和 sorted()方法
Python sorted()方法可以与 lambda 函数结合使用，按照 Python 中的值以预定义的顺序对字典进行排序。
Python lambda 函数创建匿名函数，即没有名称的函数。它有助于优化代码。
语法:Python lambda 函数
lambda arguments: expression
举例:
inp_dict = { 'a':3,'ab':2,'abc':1,'abcd':0 }
print("Dictionary: ", inp_dict)
sort_dict= dict(sorted(inp_dict.items(), key=lambda item: item[1]))
print("Sorted Dictionary by value: ", sort_dict)
在上面的代码片段中，我们创建了一个 lambda 函数，并通过按值遍历字典(即 item[1])将字典的值作为参数传递给它。
输出:
Dictionary: {'a': 3, 'ab': 2, 'abc': 1, 'abcd': 0}
Sorted Dictionary by value: {'abcd': 0, 'abc': 1, 'ab': 2, 'a': 3}
技巧 3: Python sorted()方法和 dict.items()
Python sorted()函数可用于在 Python 中按值对字典进行排序，方法是通过 dict.items()将值传递给方法。
dict.items() method从字典中获取键/值。
语法:
dict.items()
举例:
inp_dict = { 'a':3,'ab':2,'abc':1,'abcd':0 }
print("Dictionary: ", inp_dict)
sort_dict= dict(sorted((value, key) for (key,value) in inp_dict.items()))
print("Sorted Dictionary by value: ", sort_dict)
在上面的代码片段中，我们将(value，key)对传递给了排序函数，并使用 dict.items()方法获取了 dict 值。在这种情况下，我们将接收排序后的(值，键)对作为输出。
输出:
Dictionary: {'a': 3, 'ab': 2, 'abc': 1, 'abcd': 0}
Sorted Dictionary by value: {0: 'abcd', 1: 'abc', 2: 'ab', 3: 'a'}
结论
因此，在本文中，我们已经了解了 Python 中按值对字典进行排序的不同方式。
参考
- Python 按值排序字典— JournalDev
如何用 Python 对字典进行排序？
原文：https://www.askpython.com/python/dictionary/sort-a-dictionary-in-python
在 Python 中，我们可以通过不同的方式对字典进行排序。有很多种方法，取决于你是想按键排序还是按值排序。
让我们来看看文章中的一些吧！
按值对 Python 中的字典进行排序
如果我们想按值对 Python 中的字典进行排序，有几种方法可以实现。
方法 1:使用 lambda 使用 sorted()(Python 3.6+推荐)
在 Python 的新版本上( Python 3.6 和更高版本)，我们可以在sorted()方法上使用 lambda 来对 Python 中的字典进行排序。
我们将使用关键字作为 lambda 对dict.items()进行排序。
my_dict = {1: 2, 2: 10, "Hello": 1234}
print({key: value for key, value in sorted(my_dict.items(), key=lambda item: item[1])})
输出
{1: 2, 2: 10, 'Hello': 1234}
的确，我们可以看到我们的新字典已经根据值进行了排序！
这种方法在 Python 3.6+上有效的原因是 Python 新版本中的字典现在是有序的数据类型。
这意味着我们可以将字典枚举为条目列表，还可以执行改变顺序的操作，比如排序。
但是不要害怕。如果你有旧版本的 Python，请继续阅读。我们将向您展示另一种处理方法！
方法 2:在旧版本的 Python 上使用 sorted()
我们仍然可以使用sorted()对字典进行排序。但是我们需要把字典整理成一个有序的类型。operator模块有，使用operator.itemgetter(idx)。
下面的代码片段将根据值对我们的字典进行排序:
import operator
my_dict = {1: 2, 2: 10, "Hello": 1234}
sorted_dict = sorted(my_dict.items(), key=operator.itemgetter(1))
print(sorted_dict)
更具体地说，我们使用sorted(dict.items()形成一个排序列表，并将operator.itemgetter(1)传递给它(因为值在索引 1 处)。
这将构造一个 callable，从 items 列表中获取第一个元素。我们在每次迭代中都这样做，从而得到一个排序的字典！
按关键字对 Python 中的字典进行排序
方法 1:使用 operator.itemgetter()(旧版本 Python 的推荐方法)
现在，如果你想按键对字典排序，我们可以使用operator方法，就像上一节一样。我们必须做的唯一改变是现在根据键对列表进行排序，所以我们调用operator.itemgetter(0)。
import operator
my_dict = {2: 10, 1: 2, -3: 1234}
# Sort the Dict based on keys
sorted_dict = dict(sorted(my_dict.items(), key=operator.itemgetter(0)))
print(sorted_dict)
输出
{-3: 1234, 1: 2, 2: 10}
的确，字典现在已经根据键排序了！
方法 2:使用 sorted()和 lambda(Python 3.6+的推荐方法)
我们可以在新版本的 Python 上使用带有 lambda 的sorted()方法。
同样，这与之前相同，但我们现在将基于值进行排序。
my_dict = {2: 10, 1: 2, -3: 1234}
sorted_dict = dict(sorted(my_dict.items(), key=lambda item: item[0]))
输出
{-3: 1234, 1: 2, 2: 10}
同样，输出与之前相同。
结论
在本文中，我们学习了如何用 Python 对字典进行排序；通过键和值，使用不同的方法。
参考
- 关于按值排序字典的问题
使用第一个元素对元组列表进行排序
原文：https://www.askpython.com/python/tuple/sort-a-list-of-tuples
嘿皮托尼斯！今天我们将学习一些关于基本数据结构列表和元组的高级概念。在本文中，主要关注的是如何使用第一个元素对元组列表进行排序。所以让我们开始吧。
Python 中的列表是什么？
列表是一种基本的数据结构，在序列中保存不同数据类型的元素。序列不需要遵循顺序。python 中的列表跳过了编程时可能会出现问题的以下几点。
- 固定大小/非动态。
- 无法保存不同数据类型的对象/元素。
- 运行时需要一个循环来显示整个数组。
- 更长更复杂的代码操作。
相反，列表具有以下特征:
- 我们可以添加、删除、编辑列表中任何地方的元素。
- 排序很简单–使用内置的 sort()方法，我们可以对元素进行升序和降序排序。但是，为了排序，元素应该是相似的数据类型。
- 动态–当我们在列表中添加一个特定的元素时，Python 会为每次添加的下一个元素保留额外的内存空间。这使得它充满活力。
- 易于访问–通过调用列表变量，整个列表显示在屏幕上。
代码:
list_1 = [34, 4, 5, -4, 5] # list of integers
list_2 = ["one", "two", "three"] # list of strings
list_3 = [45.7, 4.9, 0.0, -8] # list of floating point numbers
list_4 = ['a', 'b', 'c', 'd'] # list of characters
list_5 = ["sam", 45, 90.0, 'a'] # a list of elements of different data types
当我们在一行中打印这些元素时，我们得到以下输出
输出:
>>> [34, 4, 5, -4, 5]
>>> ["one", "two", "three"]
>>> [45.7, 4.9, 0.0, -8]
>>> ['a', 'b', 'c', 'd']
>>> ["sam", 45, 90.0, 'a']
这是操纵数据最有利可图的方式之一。有一些内置的方法，其中某些操作如搜索、排序等是可能的。
Python 中的元组是什么？
Python 中的元组是一种列表式的 数据结构。只是语法和一些操作不同。元组只是帮助我们将不同数据类型的特定元素封装到一个封闭的不可编辑的容器中。
以下是元组的特征:
- 不可变:一旦声明，我们就不能编辑它。我们既不能添加也不能从中删除项目。
- 固定大小:我们不能对其进行任何大小更改。这是由于元组的不变性。
- 可以保存不同数据类型的元素。
语法:
有两种方法可以声明一个元组:
tup_1 = 1, 2, 3, 4
print(tup_1)
tup_2 = (1, 2, 3, 4)
print(tup_2)
输出:
>>> (1, 2, 3, 4)
>>> (1, 2, 3, 4)
当我们声明一个元组时，添加括号是一个基本的例程。但是，如果我们只是将多个值赋给一个变量，那么默认情况下，Python 解释器会将它视为一个元组。
解包元组
当我们使用 iterables 解包元组时。有两种技术。
- 使用简单变量
tup_1 = 1, 2, 3, 4
a, b, c, d = tup_1
print("Unpacking values from a tuple.....")
print("Value of a is: ", a)
print("Value of b is: ", b)
print("Value of c is: ", c)
print("Value of d is: ", d)
输出:
>>> Unpacking values from a tuple.....
>>> Value of a is: 1
>>> Value of b is: 2
>>> Value of c is: 3
>>> Value of d is: 4
- 使用通配符
a, b, *c, d = [11, 22, 33, 44, 55, 66, 77, 88, 99, 110]
print("Unpacking values from a tuple.....")
print("Value of a is: ", a)
print("Value of a is: ", b)
print("Value of a is: ", c)
print("Value of a is: ", d)
输出:
>>> Unpacking values from a tuple.....
>>> Value of a is: 11
>>> Value of b is: 22
>>> Value of c is: (33, 44, 55, 66, 77, 88, 99)
>>> Value of d is: 110
这里变量 c 的值是一个元组。这是因为通配符“*”帮助我们将一组值赋给一个变量。
在 Python 中轻松排序元组列表
众所周知，在 Python 中 tuple 是一种不可变类型的数据结构。因此，为了排序的目的，我们需要对它进行一些显式的操作。
做一个元组列表，然后排序。
代码:
tup_1 = (11, -5, -56, 9, 4)
tup_2 = (3, 43, -1, 90.0)
tup_3 = (4.5, 3.0, 9.0, 23.0)
tupleOfTuples = (tup_1, tup_2, tup_3)
print("Printing a tuple of tuples...")
print(tupleOfTuples )
输出:
>>> Printing a tuple of tuples...
>>> ((11, -5, -56, 9, 4), (3, 43, -1, 90.0), (4.5, 3.0, 9.0, 23.0))
Python 提供了创建嵌套元组(或元组的元组)的灵活性。所以，我们创建一个，即——tupleOfTuples，然后在屏幕上打印出来。然后让我们用一个内置的函数将它重组成一个列表，然后我们将实现排序。
listOfTuples = list(tupleOfTuples)
print(listOfTuples)
listOfTuples.sort()
print("Sorted list of tuples: ", listOfTuples)
输出:
>>> Raw list of tuples....
>>> [(11, -5, -56, 9, 4), (3, 43, -1, 90.0), (4.5, 3.0, 9.0, 23.0)]
>>> Sorted list of tuples...
>>> [(3, 43, -1, 90.0), (4.5, 3.0, 9.0, 23.0), (11, -5, -56, 9, 4)]
这样，我们创建了一个元组列表，并用每个元组的第一个元素对列表进行排序。
转换为字典并执行排序
Python 中的字典是无序的键值对的集合。当我们处理复杂的数据时，这使得它变得简单易用。
代码
nums = {4.0:5, 6.0:4, 90:3, 34:5}
a = nums.items()
for k,v in nums.items():
print(k, ":", v)
print(a)
输出:
4.0 : 5
6.0 : 4
90 : 3
34 : 5
dict_items([(4.0, 5), (6.0, 4), (90, 3), (34, 5)])
现在我们已经得到了元组形式的条目列表，让我们把它做成一个原始列表，然后对它进行排序。
a = list(a)
print("Items list:", a)
print("Sorting the list of items...")
a.sort()
print("Returning a sorted list...")
print(a)
输出:
Items list: [(4.0, 5), (6.0, 4), (90, 3), (34, 5)]
Sorting the list of items...
Returning a sorted lis...
[(4.0, 5), (6.0, 4), (34, 5), (90, 3)]
让我们反复检查我们是对还是错…
代码:
for i in a:
print(i)
这里创建一个 for 循环，遍历列表 a 的每个元素。如果每个元素的第一个元素大于另一个元素的前一个元素，那么我们可以说元组列表是排序的。
(4.0, 5)
(6.0, 4)
(34, 5)
(90, 3)
对元组列表进行排序的完整代码
代码 1:
tup_1 = (11, -5, -56, 9, 4)
tup_2 = (3, 43, -1, 90.0)
tup_3 = (4.5, 3.0, 9.0, 23.0)
tupleOfTuples = (tup_1, tup_2, tup_3)
print("Printing a tuple of tuples...")
print(tupleOfTuples )
listOfTuples = list(tupleOfTuples)
print(listOfTuples)
listOfTuples.sort()
print("Sorted list of tuples: ", listOfTuples)
代码 2:
nums = {4.0:5, 6.0:4, 90:3, 34:5}
a = nums.items()
for k,v in nums.items():
print(k, ":", v)
print(a)
a = list(a)
print("Items list:", a)
print("Sorting the list of items...")
a.sort()
print("Returning a sorted list...")
print(a)
for i in a:
print(i)
结论
这样，我们看到了如何通过两种方式使用第一个元素对元组列表进行排序。本文还介绍了如何声明列表和元组的基础知识。所有这些都增加了对 python 中这些数据结构的基本理解。所有最好的和快乐的编码。
