AskPython-博客中文翻译-八-
AskPython 博客中文翻译（八）
Python 字典(Dict)教程
原文：https://www.askpython.com/python/dictionary/python-dictionary-dict-tutorial
Python 字典是一组键值对。字典是类别字典的对象。这是一个无序的集合，意味着在迭代时，检索的顺序是不确定的。字典键和值可以是任何类型。他们也可以是None。键及其值用冒号分隔。字典记录使用关键字进行索引。
Python 字典项目
键值对也称为字典的项目或元素。我们可以使用 dict.items()方法让 iterable 循环遍历字典项。对字典条目的值没有限制。
Python 字典键
关键字在字典中是唯一的。它用于从字典中检索记录。使用一对大括号创建字典。键值对用逗号分隔。
字典键必须是不可变的。所以我们可以使用字符串、数字和元组作为字典键。如果元组包含任何可变对象，我们就不能把它用作字典键。
我们可以使用列表作为字典键吗？
我们不能使用一个列表作为字典键，因为它可以被修改。如果我们尝试使用列表作为键，它将抛出“type error:unhable type:list”。
创建字典
字典条目用逗号分隔，键值对用冒号分隔。花括号用于定义包含所有条目的字典。让我们看一个简单的例子来创建一个字典并打印它。
>>> fruits_dict = {"1": "Apple", "2": "Banana", 3: "Orange", None: "NA"}
>>> print(fruits_dict)
{'1': 'Apple', '2': 'Banana', 3: 'Orange', None: 'NA'}
>>> type(fruits_dict)
<class 'dict'>
注意字典类的类型是dict，键值也是不同的类型。
Creating a Dictionary
访问字典值
我们可以使用方括号中的键名来访问字典值。
>>> fruits_dict["1"]
'Apple'
>>> fruits_dict["2"]
'Banana'
>>> fruits_dict[3]
'Orange'
>>> fruits_dict[None]
'NA'
Accessing Dictionary Values
如果键不存在，这种访问 dictionary 元素的方式将会引发 KeyError。如果键不存在，最好使用返回None的get()方法。
添加/更新字典值
我们可以使用赋值操作符来添加或更新字典元素。如果字典中不存在该键，则键-值对被添加到字典中。否则，将使用新值更新该值。
fruits_dict = {"1": "Apple", "2": "Banana"}
print(f'Original Dictionary = {fruits_dict}')
# insert
fruits_dict["3"] = "Orange"
# update
fruits_dict["1"] = "Kiwi"
print(f'Updated Dictionary = {fruits_dict}')
Adding Updating Dictionary Items
删除字典项目
我们可以使用 del 关键字删除一个字典键值对。如果我们将 del 关键字与字典一起使用，那么完整的字典将被删除，这不同于删除字典的所有元素。
>>> my_dict = {1:"1", 2:"2"}
>>> del my_dict[1]
>>> print(my_dict)
{2: '2'}
>>> del my_dict
>>> print(my_dict)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'my_dict' is not defined
>>>
使用 for 循环迭代字典
我们可以使用循环的来迭代字典。有许多方法可以将 for 循环与字典一起使用。
1.Dictionary items()函数
items()函数返回一个 dict_items 的对象，该对象是可迭代的。我们可以在 for 循环中使用它，并将它的元素解包为 key 和值，然后在 for 循环中使用它们。
fruits_dict = {"1": "Apple", "2": "Banana", "3": "Orange"}
print(fruits_dict.items())
for key, value in fruits_dict.items():
print(f'{key}={value}')
输出:
dict_items([('1', 'Apple'), ('2', 'Banana'), ('3', 'Orange')])
1=Apple
2=Banana
3=Orange
2.遍历字典键
如果我们在 for 循环中使用 dictionary 对象，它会逐个返回键。因为字典是无序的，所以返回的键可以是任意顺序的。
fruits_dict = {"1": "Apple", "2": "Banana", "3": "Orange"}
for key in fruits_dict:
print(key)
输出:
1
2
3
3.Python 字典值()
我们可以使用 values() 函数来获取字典值，然后对它们进行迭代。values()函数返回一个 dict_values 的对象，它是 dict 中的值列表。
fruits_dict = {"1": "Apple", "2": "Banana", "3": "Orange"}
print(fruits_dict.values())
for value in fruits_dict.values():
print(value)
输出:
dict_values(['Apple', 'Banana', 'Orange'])
Apple
Banana
Orange
检查字典中是否存在该关键字
我们可以使用“in”关键字来检查字典中是否存在该键。同样，我们可以使用“not in”关键字来检查该键是否丢失。
fruits_dict = {"1": "Apple", "2": "Banana", "3": "Orange"}
if "3" in fruits_dict:
print(f'Key "3" is present in the dictionary and its value is {fruits_dict["3"]}')
if "10" not in fruits_dict:
print("Key '10' doesn't exists in the dictionary")
字典长度
我们可以使用 len()函数来找出字典的长度或大小。
>>> fruits_dict = {"1": "Apple", "2": "Banana", "3": "Orange"}
>>> print(f'Dictionary length is {len(fruits_dict)}')
Dictionary length is 3
>>>
Python dict()构造函数
我们可以使用内置的 dict()构造函数创建一个 dictionary 对象。
>>> empty_dict = dict()
>>>
>>> empty_dict
{}
>>> my_dict = dict(id=1, name="Pankaj", skill="Python")
>>>
>>> my_dict
{'id': 1, 'name': 'Pankaj', 'skill': 'Python'}
>>>
Python 字典方法
Python dict 类有很多方法。让我们来看看 dict 类的一些重要方法。
1.值()
此方法返回一个包含字典中的值的对象。返回对象的类型是‘dict _ values ’,我们可以迭代它来对字典值执行一些操作。
num_dict = {1: "one", 2: "two", 3: "three"}
values = num_dict.values()
print(f'Dictionary values are {values} and its type is {type(values)}')
for v in values:
print(v, end=" ")
2.项目()
这个方法提供了一个类似集合的字典条目视图。它主要用于将字典键值对解包为不同的值，然后对它们进行迭代。
num_dict = {1: "one", 2: "two", 3: "three"}
items = num_dict.items()
print(items)
print(type(items))
for k, v in items: # unpacking
print(k, v)
输出:
dict_items([(1, 'one'), (2, 'two'), (3, 'three')])
<class 'dict_items'>
1 one
2 two
3 three
3.pop(键[，默认])
此方法从字典中移除指定的键，并返回相应的值。如果找不到该键，则返回可选的默认值。如果没有找到键，并且没有给出默认值，则引发 KeyError 。
num_dict = {1: "one", 2: "two", 3: "three"}
value = num_dict.pop(1)
print(f'Updated Dictionary = {num_dict} and the removed value = {value}')
value = num_dict.pop(1, "NA")
print(f'Updated Dictionary = {num_dict} and the removed value = {value}')
try:
value = num_dict.pop(1)
except KeyError as ke:
print("Key Not Found: 1")
我们使用一个 try-except 块来捕获 KeyError 并打印错误消息。
4.复制()
这个函数返回字典的浅层副本。如果底层对象是可变的和变化的，那么这种变化也会反映在使用 copy()方法返回的 dict 中。
num_dict = {1: "one", 2: "two", 3: "three"}
num_dict_copy = num_dict.copy()
print(num_dict)
print(num_dict_copy)
num_dict[4] = "four"
num_dict_copy[5] = "five"
print(num_dict)
print(num_dict_copy)
输出:
{1: 'one', 2: 'two', 3: 'three'}
{1: 'one', 2: 'two', 3: 'three'}
{1: 'one', 2: 'two', 3: 'three', 4: 'four'}
{1: 'one', 2: 'two', 3: 'three', 5: 'five'}
5.清除()
这个方法从字典中删除所有的条目。这类似于将变量赋给一个空字典。
num_dict = {1: "one", 2: "two", 3: "three"}
num_dict.clear() # same as num_dict = {}
print(num_dict)
6.fromKeys(iterable，value)
这个静态方法使用 iterable 中的键和设置为所提供值的值创建一个新字典。如果未给出该值，则这些值将被设置为 None。
seq = (1, 3)
sub_dict = dict.fromkeys(seq)
print(sub_dict)
sub_dict = dict.fromkeys([1, 2], "NA")
print(sub_dict)
sub_dict = dict.fromkeys("15", "Hello")
print(sub_dict)
输出:
{1: None, 3: None}
{1: 'NA', 2: 'NA'}
{'1': 'Hello', '5': 'Hello'}
7.get(键[，默认值])
此方法返回键的值。如果找不到该键，则返回可选的默认值。如果找不到该键并且没有提供默认值，则不返回任何值。
>>> num_dict = {1: "one", 2: "two", 3: "three"}
>>>
>>> num_dict.get(1)
'one'
>>> num_dict.get(10, "ten")
'ten'
>>> num_dict.get(10)
>>> print(num_dict.get(10))
None
>>>
8.按键()
这个函数返回 dict_keys 对象中的键列表。我们可以遍历这个列表来处理字典值。
num_dict = {1: "one", 2: "two", 3: "three"}
keys = num_dict.keys()
print(keys)
print(type(keys))
for k in keys:
print(k, num_dict[k])
输出:
dict_keys([1, 2, 3])
<class 'dict_keys'>
1 one
2 two
3 three
9.popitem()
该方法以键值元组的形式移除并返回一些字典项。如果字典为空，将引发 KeyError。我们可以使用这个函数和一个 while 循环来随机处理字典条目。
num_dict = {1: "one", 2: "two", 3: "three", 0: "zero"}
while len(num_dict) != 0:
item = num_dict.popitem()
print(item)
输出:
(0, 'zero')
(3, 'three')
(2, 'two')
(1, 'one')
10. setdefault(key[,default])
当且仅当一个键不在字典中时，该方法用于将该键添加到字典中。此方法将键值设置为所提供的默认值，否则为 None。
如果字典中有键值，则该方法返回键值，否则返回默认值。
num_dict = {1: "one", 2: "two", 3: "three"}
# new key
value = num_dict.setdefault(4, "NA")
print(f'Updated Dictionary = {num_dict} and the returned value = {value}')
# new key with no default
value = num_dict.setdefault(5)
print(f'Updated Dictionary = {num_dict} and the returned value = {value}')
# existing key, no effect on the dict
value = num_dict.setdefault(1, "ONE")
print(f'Updated Dictionary = {num_dict} and the returned value = {value}')
输出:
Updated Dictionary = {1: 'one', 2: 'two', 3: 'three', 4: 'NA'} and the returned value = NA
Updated Dictionary = {1: 'one', 2: 'two', 3: 'three', 4: 'NA', 5: None} and the returned value = None
Updated Dictionary = {1: 'one', 2: 'two', 3: 'three', 4: 'NA', 5: None} and the returned value = one
11.更新(字典)
此方法用于更新给定字典中的字典项。如果没有找到给定的字典键，它将被添加到字典中。如果找到了这个键，这个值就会被更新。
num_dict = {1: "one", 2: "two", 3: "three"}
dict1 = {1: "ONE", 2: "TWO", 5: "FIVE"}
# update from another dict
num_dict.update(dict1)
print(num_dict)
输出: {1: 'ONE', 2: 'TWO', 3: 'three', 5: 'FIVE'}
摘要
Dictionary 是一个类似地图的集合，用于存储键值对。字典中的条目通过基于键的索引来访问。我们可以更新、添加和删除字典条目。有多种方法可以使用 for 循环来迭代字典键、值或项。
下一步是什么？
参考资料:
Python dir()方法的快速概述
原文：https://www.askpython.com/python/built-in-methods/python-dir-method
今天我们将讨论 Python dir()方法。
所以让我们开始吧。
Python dir()方法基础
Python 中的dir()方法被广泛用于以按字母顺序排序的方式获取被传递的object的属性名称列表。
dir([object])
这里，object是可选参数。当任何 Python 对象被传递给dir()方法时，它返回一个包含该对象的所有属性的列表。当没有传递任何东西时，该方法返回所有局部属性的列表。
对于定义了__dir__()方法的对象，dict()会导致对它的调用，因此应该返回与对象相关的属性列表。
Python dir()示例
现在我们对dir()方法有了一个基本的概念，让我们看一个例子来更好地理解。
#empty dir()
print("dir() :", dir())
#list initialisation
list1 = ['name', 'class', 'roll']
#dictionary initialisation
dict1 = {0: 'bad', 5: 'fair', 10: 'good'}
print("\ndir(list1) :", dir(list1))
print("\ndir(dict1) :", dir(dict1))
输出:
dir() : ['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__']
dir(list1) : ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
dir(dict1) : ['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
正如你所看到的，这里我们首先没有传递任何东西，然后是一个列表对象，最后是一个字典对象给dir()方法，并打印出返回的列表。
从上面的输出中，我们可以清楚地看到列表和字典对象的不同属性。对于什么都没有传递给函数的情况，我们得到了局部作用域中所有方法或属性的名称。
在 Python 中使用 dir()方法
现在让我们尝试更多的例子，在这些例子中，我们试着在用户定义的类的对象上使用dir()函数，以及使用定义的__dir__()方法的对象。
1.使用自定义对象
既然我们已经为列表和字典这样的内置类应用了dir()方法。让我们试着找出一个未定义__dir__()的自定义类的自定义对象的结果。
#class
class shape:
name = "rectangle"
sides = 4
obj = shape()
print(dir(obj)) #dir for our custom object
输出:
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name', 'sides']
这里，obj是一个名为矩形、边= 4** 的shape类的对象。将这个 obj 对象传递给dir()方法，我们得到了上面的属性集。**
注意，这个列表也包括了name和sides变量。
2.带有已定义的 dir()
正如本文前面提到的，对于定义了__dir__()方法的对象，dir()方法调用相应的__dir__()方法，该方法必须再次返回属性的列表。
让我们试着用一个例子来理解这一点。
#class
class shape:
name = "rectangle"
sides = 4
def __dir__(self):
return ['Square','Circle']
obj = shape()
print(dir(obj)) #dir for our custom object
输出:
Python dir() method output
可以看到，对于 shape 类的对象obj，调用了__dir__()方法，上面的属性列表在dir(obj)调用的位置返回。
结论
所以在本教程中，我们学习了 Python dir()方法，它是如何工作的，以及我们如何在不同的情况下使用它。
关于这个话题的任何进一步的问题，请在下面随意评论。
参考
- Python dir()函数–期刊开发文章，
- 为什么 python 中的' dir()'被命名为' dir '？–stack overflow 问题，
- Python dir()–官方文档。
Python 目录列表
原文：https://www.askpython.com/python/examples/python-directory-listing
在本文中，我们将了解如何执行 Python 目录列表。这将允许我们列出当前工作位置的所有文件和目录。
经常。我们可能希望使用 Python 快速查看文件名并获取信息。
让我们来看看如何快速轻松地做到这一点！
1.使用 os.listdir()的 Python 目录列表
这是一个从你的当前目录中执行 Python 目录列表的简单而有趣的方法！
真的只是一句台词。不相信我？这里有一个例子。这适用于任何操作系统，无论是 Windows / Linux / MacOS。
import os
print(os.listdir())
示例输出
>>> import os
>>> os.listdir()
['.bashrc', '.git', '.nvimrc', '.vimrc', '.xinitrc', '.zshrc', 'Autumn.jpg', 'README.md', 'config']
这将从当前目录返回所有文件和嵌套文件夹的列表。
如果您想指定一个确切的路径，您可以简单地将它作为一个参数传递给os.listdir(path)！
>>> os.listdir(r'/home/vijay/manjaro-dotfiles')
['.bashrc', '.git', '.nvimrc', '.vimrc', '.xinitrc', '.zshrc', 'Autumn.jpg', 'README.md', 'config']
在处理路径时使用原始字符串(前缀为r的字符串)，因为你不需要转义任何反斜杠(对于 Windows 路径)。
2.将 os.path.join()与 os.listdir()一起使用
如果您想打印当前目录中所有文件的绝对路径，只需在os.listdir()函数中添加一个os.path.join()！
我们将为此创建一个函数，它简单地获取完整路径，并返回所有此类名称的列表。
import os
def list_full_paths(directory):
return [os.path.join(directory, file) for file in os.listdir(directory)]
print(list_full_paths(r'/home/accornition/manjaro-dotfiles'))
输出
['/home/vijay/manjaro-dotfiles/.bashrc', '/home/vijay/manjaro-dotfiles/.git', '/home/vijay/manjaro-dotfiles/.nvimrc' , '/home/vijay/manjaro-dotfiles/.vimrc', '/home/vijay/manjaro-dotfiles/.xinitrc', '/home/vijay/manjaro-dotfiles/.zsh rc', '/home/vijay/manjaro-dotfiles/Autumn.jpg', '/home/vijay/manjaro-dotfiles/README.md', '/home/vijay/manjaro-dotfiles/config']
的确，这给了我们从根目录开始的绝对路径！
3.使用 os.walk()的 Python 目录列表
我们还可以使用os.walk()函数遍历目录树。
然后，我们可以分别打印目录和文件。
for top, dirs, files in os.walk(os.getcwd()):
print("Printing directories...")
for dir in dirs:
print(os.path.join(top, dir))
print("Printing files....")
for file in files:
print(os.path.join(top, file))
输出
Printing directories...
/home/vijay/manjaro-dotfiles/config/cmus /home/vijay/manjaro-dotfiles/config/compton /home/vijay/manjaro-dotfiles/config/termite Printing files....
Printing directories...
Printing files.... /home/vijay/manjaro-dotfiles/config/cmus/my.theme Printing directories...
Printing files....
/home/vijay/manjaro-dotfiles/config/compton/compton.conf Printing directories...
Printing files....
/home/vijay/manjaro-dotfiles/config/termite/config
根据您的用例场景，您可以使用以上三种方法中的任何一种。
第一种方法是最简单的，也是推荐的方法，但是如果您想要完整的路径，并且想要递归地遍历，那么使用os.walk()。
结论
在本文中，我们学习了如何使用不同的方法在 Python 中列出文件和目录。
参考
- 关于从目录中列出内容的 StackOverflow 问题
Python 目录操作
原文：https://www.askpython.com/python/python-directory-operations
**Directory**基本上是一个包含所有相应文档、文件和文件夹的结构。
Python 的 os 模块包含多个用于目录管理的函数。
Python 目录函数
| os.access(path，mode)
它使用uid来检查路径的访问。 |
| 【OS . chdir(path)
它将 CWD 更改为用户指定的路径。 |
| os.chflags(path，flags)
它用于将标志设置为数字标志。 |
| os.chmod(路径，模式)
用于将路径的模式改为数值模式。 |
| os.chown(path，uid，gid)
它将路径的组 id 和所有者更改为数字uid和gid。 |
| OS . ch root(path)
用于将当前正在执行的进程的根目录更改为用户指定的路径。 |
| OS . fch dir(FD)
用于将 CWD 更改为文件描述符fd中表示的目录。 |
| os.getcwd()
它返回当前工作目录(cwd)。 |
| os.getcwdu()
它返回 Unicode 对象作为输出，用 CWD 表示。 |
| os.lchmod(路径，模式)
用于将路径的模式改为数值模式。 |
| OS . listdir(path)
返回一个包含由 path 给定的目录中的条目名称的列表。 |
| os.lstat(路径)
|
| os.makedirs(path[，mode])
用于以递归方式创建目录。 |
| os.mkdir( )
它用来创建一个新的目录，并有一个命名的路径。 |
| os.mkfifo(路径[、模式])
|
| os.readlink(路径)
|
| OS . remove dirs(path)
它用于递归删除对应的目录。 |
| os.rename(src，dst)
它用于将 src 目录重命名为 dst。 |
| os.renames(old，new)
用于以递归方式用新目录重命名旧目录。 |
| 【OS . rmdir(路径)
它用于删除用户指定的目录。 |
| 操作系统状态(路径)
|
1.创建新目录
Python 的 os 模块提供了**mkdir()**函数来创建新的目录。
语法:
os.mkdir('name')
import os
os.mkdir('C:/python1') #create a direcotry abc in C:
输出:
Create Directory
2.获取当前工作目录
**getcwd()**函数用于获取 CWD 的位置。
import os
os.getcwd()
输出:
wdir='C:/Users/HP/PycharmProjects/Hello'
3.重命名目录
**rename()**功能用于重命名 CWD。
语法:
os.rename(old,new)
4.获取目录中的文件/目录列表
**listdir()**函数用于获取当前目录中所有目录和文件的列表。
import os
os.listdir('C:\\Users\\HP')
输出:
['.android', '.AndroidStudio3.5', '.crashlytics', '.eclipse', '.emulator_console_auth_token', '.gradle', '.idlerc', '.m2', '.nbi', '.netbeans-derby', '.p2', '.PyCharm2019.3', '.RapidMiner', '.tooling', '.vscode', '3D Objects', 'Anaconda3', 'Anaconda3_1', 'AndroidStudioProjects', 'AppData', 'Application Data', 'Contacts', 'Cookies', 'Desktop', 'Documents', 'Downloads', 'eclipse', 'eclipse-workspace', 'Favorites', 'get-pip.py', 'HP', 'IntelGraphicsProfiles', 'Links', 'Local Settings', 'MicrosoftEdgeBackups']
5.在 Python 中移除目录
**rmdir()**函数用于删除一个已经空了的目录。如果目录不为空，则不会被删除。
import os
os.rmdir('C:\\Users\\HP\\Pictures\\Screenshots\\python')
6.检查 Python 目录是否存在
**os.path.exists(path)**函数用于检查特定目录是否存在。
import os
os.path.exists('C:\\Users\\HP\\Pictures\\Screenshots')
输出:
True
结论
Python os 模块提供了多种处理目录的函数。我们学习了如何在 Python 程序中创建和删除目录。
参考
- Python 目录操作
- 目录文档
创建 Python Discord Bot——完整的分步指南
原文：https://www.askpython.com/python/examples/python-discord-bot
discord 是 21 世纪最受欢迎的社交媒体平台之一，制作 Discord 机器人可能是最酷的 python 项目之一。
使用 python 的 discord API 和一些其他模块，我们可以很容易地为 discord 中的文本通道编写自己的机器人。在本教程中，我们将编写一个机器人，它会在不和谐时向我们发送有趣的消息。
我们开始吧！
也可阅读:用 Python 构建聊天机器人使用 spaCy NLP 库
添加不和谐机器人的步骤
在我们开始用 python 编码之前，我们需要从 discord 开发者的门户创建一个 discord bot 帐户。点击此处直接进入网站。
- 点击左侧菜单中的“应用程序”。然后，单击“新建应用程序”按钮创建一个新的应用程序。
- 为您的机器人添加名称。比如，既然是我们的第一个 bot，我就把它命名为我们的第一个 Bot，点击“创建”。****
-
点击左侧菜单中的“机器人”选项，您将能够查看您新创建的机器人的基本详细信息！
-
暂时保留 bot 的默认设置，比如保持 bot 公开。
瞧吧！您已经成功创建了您的第一个机器人！
- 向下滚动到“授权流程”部分，在“特许网关意图”下打开所有三个框。
-
完成后，向上滚动到机器人部分。
-
单击重置令牌按钮旁边的“复制”。这是非常重要的一步，因为它将帮助我们以后将代码与机器人连接起来。
注意 :-不要与任何人共享令牌，它可以被任何人用来在没有监督的情况下操纵你的机器人。如果您不小心共享了令牌，请点击“重置令牌”，然后单击“复制”。
创建不和谐服务器
- 如果您没有现有的服务器来添加机器人，请打开 discord 并单击左侧菜单底部的“+”(添加服务器)按钮。
- 选择“创建我自己的”。
- 然后选择您需要的服务器用途。
- 接下来，命名您的服务器并点击创建。我选择了 机器人 python 服务器 这个名字，你想怎么命名都行！
- 您现在已经成功创建了一个新的 discord 服务器！
给你的不和谐机器人权限
- 从 discord 开发门户的菜单中点击 OAuth2 选项卡，并点击 URL 生成器。选中“范围”下的“bot”框，然后转到“bot 权限”部分。这将用于在您的服务器中为您的机器人提供各种权限。
- 例如，这里我们将检查所有的文本权限框，因为我们正在编写一个简单的文本通道机器人，但它可以根据您的使用进行定制。
**注意:在给机器人分配管理员权限之前，你应该小心。
授权你的机器人访问
- 现在，复制页面最末端的 URL，并在一个新标签中打开它。
- 它会要求您授权 bot，并要求您将它添加到特定的服务器。
- 选择所需的服务器，然后单击继续。我已经把它添加到一个名为“机器人 python 服务器”的服务器上，但是你可以把它添加到任何你想添加的服务器上。
- 检查所有权限是否正确。向下滚动并点击“授权”按钮。
整齐！现在，这个机器人已经被添加到您各自的服务器，可以做特定的任务。当你不和谐地打开你的服务器，你将能够看到机器人离线。
为机器人设置基于云的环境
- 我们将首先创建一个 Replit 帐户，它是一个用于编码的基于云的 IDE ，支持各种语言，比如 python、bash、C 等等。如果您已经有一个 Replit 帐户，那么您可以只使用那个帐户。点击此处访问官方网站并创建新账户。
- 注册或登录您的谷歌帐户，然后您将被带到主页仪表板，在那里您需要点击“+create”来创建一个新的 Repl。
- 然后，从左边的下拉菜单中选择 python，并随意命名您的 repl。我把它命名为【Ourfirstbot】。点击“创建副本”。
- 您的新回复将类似于下面给出的内容。
**注意:有了 replit，你不需要在你的电脑上安装任何额外的东西，这使得编写代码更加容易。当您在 replit 中导入模块并点击 run 时，这些依赖项会被自动安装和导入。
- 我们将在 main.py 文件中编写我们的机器人代码。
将机器人连接到我们自己的 Repl:
- 点击“工具”菜单左下方的“秘密”。
- 在将出现在面板右侧的密钥框中写入“token ”,并将您之前复制的令牌粘贴到下面的值框中。点击“添加新密码”添加环境变量。
**注意:我们可以在使用 bot 时将令牌粘贴到 main.py 文件中，但是由于 Replit 是一个公共平台，我们的整个 repl 都可以被其他人看到。因此，为了保护我们的 bot 免受不必要的和恶意的更改，非常重要的一点是，我们将密钥作为一个秘密的环境变量添加，这个变量只对我们可见，其他人不可见。
用 Python 编写不和谐机器人
- 下面给出的代码块是我们需要在 main.py 文件中编写的内容，以修改我们的 bot 并使其有用。这是通过向我们发送“hello！”来帮助我们测试我们的机器人是否正常工作的基本代码当别人先发消息时。
**#importing required modules
import os
import discord
import requests
import json
import random
intents = discord.Intents().all()
client = discord.Client(intents=intents)
#first event :logging in
@client.event
async def on_ready():
print("successful login as {0.user}".format(client))
#second event: sending message
@client.event
async def on_message(message):
#check who sent the message
if message.author == client.user:
return
msg = message.content
if msg.startswith('hello'):
await message.channel.send("hello!")
#getting the secret token
client.run(os.getenv('token'))**
- 写完上面的代码后点击“运行”。
- 在编辑器旁边的控制台中，您应该会看到类似这样的内容:
**2022-12-15 07:20:06 INFO discord.client logging in using static token
2022-12-15 07:20:07 INFO discord.gateway Shard ID None has connected to Gateway (Session ID: ed722695d1f7e5e06167fefa674cc768).
successful login as Our First bot.#5804**
-
上图是它在 repl 中的样子。
-
现在，如果您打开您的 discord 应用程序，并转到添加了机器人的服务器，在这种情况下:机器人 python 服务器，我们将观察到机器人在线！
- 现在，如果你发送一条 【你好】 的消息，机器人会发回一条，如下图所示。
给自己一个鼓励，因为你的机器人现在成功地做出了回应！
修改不和谐机器人变得有趣(笑话 API)
- 现在，我们必须修改这个机器人，以便它可以在用户要求笑话时发送有趣的文本。
- 以下是我们将如何通过添加一个名为“笑话”的函数来修改原始代码，该函数将从官方笑话 api 中检索随机笑话。
**#importing required modules
import os
import discord
import requests
import json
import random
intents = discord.Intents().all()
client = discord.Client(intents=intents)
#creating a function to retrieve jokes from the official joke api
def joke(j):
data = requests.get(j)
tt = json.loads(data.text)
return tt
j = r"https://official-joke-api.appspot.com/random_ten"
a = joke(j)
#formatting to only get the setup and punchline of joke
for i in (a):
Setup = (i["setup"])
Punchline = (i["punchline"])
#first event :logging in
@client.event
async def on_ready():
print("successful login as {0.user}".format(client))
#second event: sending message
@client.event
async def on_message(message):
#check who sent the message
if message.author == client.user:
return
#retrieving message to look for keywords
msg = message.content
#to check if above message has required keywords
if 'joke' in msg.lower() or 'funny' in msg.lower() or 'laugh' in msg.lower():
await message.channel.send(Setup)
await message.channel.send(Punchline)
#getting the secret token
client.run(os.getenv('token'))**
- 修改 main.py 文件中如上所示的代码，然后点击“run”。
- 现在，如果你像 一样在服务器的通用文本通道里发消息“逗我笑！” 或 【说点好笑的】 ，bot 会用一个笑话来回应那些消息。
万岁！你现在已经成功地创建了你自己的滑稽机器人！
注意: 只有当你通过浏览器运行 repl 中的代码时，bot 才会在线。一旦你关闭浏览器或者点击回复中的“停止”，这个机器人就会回到离线状态。
因此，最后一步是将你的机器人托管在服务器上，这样即使你关闭浏览器，它也能保持在线。
托管您的机器人:
我们必须为 discord bot 建立一个 web 服务器，这可以通过在 Replit 和 uptime robot 上创建一个 web 服务器来完成，这是一个免费的监控网站，用于 ping 我们的机器人，这样即使当我们的浏览器关闭时，它也会定期向我们的 discord bot 发送 ping，以保持它的运行。
- 点击“新建文件”，命名为“keep_up”。巴拉圭
- 现在，我们必须编写下面的函数来让我们的机器人想醒多久就醒多久。
**#importing required modules
from flask import Flask
from threading import Thread
app = Flask('')
@app.route('/')
def home():
return "Hello. I am awake!"
def run():
app.run(host='0.0.0.0', port=8080)
#function to keep the bot awake
def keep_awake():
t = Thread(target=run)
t.start()**
- 现在，您需要返回到 main.py 文件，通过添加两行来修改代码
**#imprting required modules
import os
import discord
import requests
import json
import random
#importing the keep_awake function from the newly created file
from Keep_up import keep_awake
intents = discord.Intents().all()
client = discord.Client(intents=intents)
#creating a function to retrieve jokes from the official joke api
def joke(j):
data = requests.get(j)
tt = json.loads(data.text)
return tt
j = r"https://official-joke-api.appspot.com/random_ten"
a = joke(j)
#formatting to only get the setup and punchline of joke
for i in (a):
Setup = (i["setup"])
Punchline = (i["punchline"])
#first event :logging in
@client.event
async def on_ready():
print("successful login as {0.user}".format(client))
#second event: sending message
@client.event
async def on_message(message):
#check who sent the message
if message.author == client.user:
return
#retrieving message to look for keywords
msg = message.content
#to check if above message has required keywords
if 'joke' in msg.lower() or 'funny' in msg.lower() or 'laugh' in msg.lower():
await message.channel.send(Setup)
await message.channel.send(Punchline)
#calling the awake function
keep_awake()
#getting the secret token
client.run(os.getenv('token'))**
- 现在，当您运行 main.py 文件时，您将能够看到一个显示在 repl 中右侧面板控制台正上方的网页，如下所示。“你好，我醒了！”消息也将显示在网页上。
-
接下来，我们将设置正常运行时间机器人 。
-
如果你已经有了 Uptime robot 帐户，请登录，或者使用你的 Google 帐户免费注册。
-
验证您的电子邮件，然后您将被重定向到如下所示的窗口，然后点击“添加新显示器”
- 选择监视器类型为“HTTPS”。然后添加您想给显示器起的任何名字。我把它命名为“我们的第一机器人”。
- 接下来复制你的 bot repl 的 URL，在那里你已经写了并且保存了所有的代码，然后把它粘贴到 URL 部分。
- 将监控间隔设置为“5 分钟”,其余时间保持不变。
- 向下滚动并点击“创建监视器”
- 太好了！您已经创建了您的第一个正常运行时间机器人监视器。
注意*:如果点击“创建监视器”后出现一个橙色按钮，按一下那个橙色按钮*，您的监视器就创建好了。****
- 现在，您可以在仪表板的左侧查看新创建的监视器。
- 现在，即使你从浏览器中关闭 replit 标签，你的机器人仍然会不和谐地出现在网上！
自己试试吧！
摘要
本教程是关于如何在 discord 中设置一个基本的文本机器人，关于如何使用 python 制作 discord 机器人的更多信息，请访问官方网站。
如何进行 Python 除法运算？
原文：https://www.askpython.com/python/examples/python-division-operation
嘿，伙计们！在本文中，我们将关注一个算术运算——Python除法运算。
Python 除法运算入门
Python 有各种内置的操作符和函数来执行算术运算。
'/' operator用于对两种数据类型的数据值进行除法运算，即:浮点型和整型。
Python“/”操作符的美妙之处在于，该操作符可以分别处理小数和负值。
语法:
number1 / number2
运算符对数值进行运算，并返回一个浮点值作为结果。除法运算的结果是所执行运算的商，表示为浮点值。
例 1:
a = input("Enter the value for a:")
b = input("Enter the value of b:")
res = int(a)/int(b)
print(res)
输出:
Enter the value for a:10
Enter the value of b:2
5.0
例 2:
a = -10
b = 20
res = a/b
print(res)
输出:
-0.5
元组上的 Python 除法运算
Python floordiv() method和map() function可以用来对存储在元组数据结构中的各种数据值进行除法运算。
Python floordiv() method用于对数据结构中存在的所有元素执行除法运算，即它执行元素式除法运算。此外，Python map() function对一组可重复项(如元组、列表等)应用任何传递/给定的函数或操作。
语法:
tuple(map(floordiv, tuple1, tuple2))
floordiv() method执行整数除法，即将元素相除，只返回商的整数部分，跳过小数部分。
举例:
from operator import floordiv
inp_tup1 = (10,16,9,-4)
inp_tup2 = (2,-8,4,4)
tup_div = tuple(map(floordiv, inp_tup1, inp_tup2))
print("Resultant tuple after performing division operation : " + str(tup_div))
输出:
Resultant tuple after performing division operation : (5, -2, 2, -1)
Dict 上的 Python 除法运算
可以使用 Counter()函数和“//”运算符对出现在字典中的元素执行 Python 除法运算。
Counter() function将字典键值数据存储为字典键值，并将字典元素的计数存储为关联值。
“//”运算符对数据元素执行整数级除法。
语法:
Counter({key : dict1[key] // dict2[key] for key in dict1})
举例:
from collections import Counter
inp_dict1 = {'Python': 100, 'Java': 40, 'C': 36}
inp_dict2 = {'Python': 20, 'Java': -10, 'C': 8}
inp_dict1 = Counter(inp_dict1)
inp_dict2 = Counter(inp_dict2)
dict_div = Counter({key : inp_dict1[key] // inp_dict2[key] for key in inp_dict1})
print("Resultant dict after performing division operation : " + str(dict(dict_div)))
在上面的例子中，我们使用 Counter()函数存储了输入 dict 的键-值对，输入 dict 现在包含作为 dict 元素的键和作为 dict 中存在的元素计数的值。
此外，我们已经将键传递给了“//”运算符来执行除法运算。
输出:
Resultant dict after performing division operation : {'Python': 5, 'Java': -4, 'C': 4}
Python“/”和 Python“//”除法运算符之间的区别
“/”和“//”除法运算符之间的基本区别，也可能是唯一的区别在于， '/' operator返回浮点值作为除法的结果，即它返回整个商(整数和小数部分)。
另一方面， '//' division operator返回整数值作为除法的结果，即只返回商值的整数部分。
举例:
print(10/3)
print(10//3)
输出:
3.3333333333333335
3
结论
因此，在本文中，我们已经了解了在 Python 中执行除法运算的方法。
参考
- Python 除法运算
如何使用 Python divmod()函数
原文：https://www.askpython.com/python/built-in-methods/python-divmod-function
在本文中，我们将详细介绍 Python divmod()函数的工作和使用。
1.Python divmod()函数
Python 内置了 divmod()函数，对两个输入值进行除法和模数运算。
divmod()函数以两个值作为自变量，并执行除法即 value1/value2 和模运算即 value1%value2 ，返回商和余数成对。
语法:
divmod(value1, value2)
- value1 被视为提名人
- 值 2 被当作分母
例 1:
x= 10
y= 2
res_div = divmod(x,y)
print(res_div)
在上面的例子中，我们将 10 和 2 传递给了 divmod()函数。此外，divmod()函数执行除法运算，即 10/2 和模运算，即 10%2 ，并从中返回商和余数。
输出:
(5, 0)
例 2:
x= int(input())
y= int(input())
res_div = divmod(x,y)
print(res_div)
输出:
(2, 0)
例 3:
x= 10
y= 3
res_div = divmod(x,y)
print(res_div)
输出:
(3, 1)
带浮点值的 Python divmod()函数
当 divmod()函数遇到作为参数的浮点值时，该函数以如上所示的类似方式计算商和余数。
但是，当一个浮点值作为参数传递给 divmod()函数时，它返回的商值只考虑所获得的值的整个部分，即它忽略了小数部分。
举例:
x= 10.5
y= 5
res_div = divmod(x,y)
print(res_div)
如上所示，divmod(10.5，5)将返回(2.0，0.5)，因为当遇到浮点值时，它会忽略结果中的小数部分，即 10.5/5 将是 2.0 而不是 2.1。因此，省略了小数部分。
输出:
(2.0, 0.5)
例 2:
x= 10
y= 2.4
res_div = divmod(x,y)
print(res_div)
输出:
(4.0, 0.40000000000000036)
Python divmod()函数-错误和异常
1。如果传递给 divmod()函数的第一个参数的值是零(0) ，那么该函数返回一对作为 (0，0) 。
例 1:
x= 0
y= 3
res_div = divmod(x,y)
print(res_div)
输出:
(0, 0)
2。如果传递给 divmod()函数的第二个参数的值似乎是零(0) ，那么该函数返回一个 ZeroDivisionError，即除以零错误。
例 2:
x= 5
y= 0
res_div = divmod(x,y)
print(res_div)
输出:
Traceback (most recent call last):
File "main.py", line 4, in <module>
res_div = divmod(x,y)
ZeroDivisionError: integer division or modulo by zero
3。如果 divmod()函数遇到一个复数作为参数，它会引发类型错误异常
例 3:
inp1 =10 + 5J
inp2 = 4
res_div = divmod(inp1, inp2)
print(res_div)
输出:
Traceback (most recent call last):
File "main.py", line 4, in <module>
res_div = divmod(inp1, inp2)
TypeError: can't take floor or mod of complex number.
摘要
- Python divmod()函数接受两个值作为参数列表，并对这两个值执行除法和求模运算。
- divmod()函数成对返回商和余数。
- 如果将一个浮点值传递给 divmod()函数，该函数将通过省略相应结果值中的小数部分来返回一对商和余数。
- 如果传递给 divmod()函数的第二个参数是零(0) ，则引发一个 ZeroDivisionError 。
- 如果将复数作为参数传递给该函数，该函数将引发 TypeError 异常。
结论
因此，在本文中，我们已经了解了 Python divmod()函数的工作原理。
参考
- python divmod()–journal ev
Python 文档字符串
Python Docstring(文档字符串)是一个字符串文字，是模块、函数、类或方法中的第一条语句。
如何写一个 Python Docstring？
Python docstring 由一对三重双引号(" ")包围。让我们看一些用 Python 写 docstrings 的例子。
1.Python 函数 Docstring 示例
def multiply(a, b):
"""This method multiplies the given two numbers.
Input Arguments: a, b must be numbers.
Returns: Multiplication of a and b.
"""
return a * b
2.Python 类 Docstring 示例
class Employee:
"""Employee class is used to hold employee object data.
Methods:
__init__(self, emp_id, emp_name)
print()
"""
def __init__(self, emp_id, emp_name):
"""Employee Class Constructor to initialize the object.
Input Arguments: emp_id must be int, emp_name must be str
"""
self.id = emp_id
self.name = emp_name
def print(self):
"""This method prints the employee information in a user friendly way."""
print(f'Employee[{self.id}, {self.name}]')
3.Python 模块 Docstring 示例
假设我们已经在docstrings.py文件中定义了上面的函数和类。每个 Python 脚本也是一个模块。我们可以将这个模块 docstring 定义为:
"""
This module shows some examples of Python Docstrings
Classes: Employee
Functions: multiply(a, b)
"""
如何访问 Python Docstrings？
我们可以从一个特殊的属性 doc 中访问 docstring 值。让我们看看如何访问上面定义的 docstring 值。
1.访问 Python 函数 Docstring
print(multiply.__doc__)
输出:
Python Docstring Example
2.访问 Python 类和方法文档字符串
print(Employee.__doc__)
print(Employee.__init__.__doc__)
print(Employee.print.__doc__)
输出:
Python Class and Methods Docstring Example
3.访问 Python 模块 Docstring
我们必须导入 docstrings 模块。然后我们可以使用 doc 属性访问它的 Docstring 值。在导入 docstrings 模块之前，我们已经在上面注释了 print 语句，以避免执行 print()语句。
$ python ls
docstrings.py
$ python
$ python python3.7
Python 3.7.3 (v3.7.3:ef4ec6ed12, Mar 25 2019, 16:52:21)
[Clang 6.0 (clang-600.0.57)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>
>>> import docstrings
>>>
>>> docstrings.__doc__
'\nThis module shows some examples of Python Docstrings\n\nClasses: Employee\nFunctions: multiply(a, b)\n'
>>>
>>> docstrings.Employee.__doc__
'Employee class is used to hold employee object data.\n\n Methods:\n __init__(self, emp_id, emp_name)\n print()\n '
>>>
>>>
>>> docstrings.multiply.__doc__
'This method multiplies the given two numbers.\n\n Input Arguments: a, b must be numbers.\n Returns: Multiplication of a and b.\n '
>>>
>>>
>>> docstrings.Employee.print.__doc__
'This method prints the employee information in a user friendly way.'
>>>
Python Module Docstring
Python 单行 Docstring
- 当 python docstring 在一行中定义时，它被称为单行 docstring。
- 开始引号和结束引号在同一行。
- docstring 值前后没有空行。
- 最佳实践是以句点结束 docstring。
- 它最适合于我们不需要指定很多东西的小效用函数。
- 提供有意义的 docstring 来指定函数细节和输出。例如:
def reverse_str(s):
"""Reverses the input string and returns it."""
pass
Python 多行文档字符串
- 当 docstring 值跨越多行时，它被称为多行 Docstring。
- 多行 docstring 的最佳实践是以一个摘要行开始，然后是一个空行，后面是更详细的解释。
- 摘要行可以与起始引号在同一行，也可以在下一行。
- 整个多行文档字符串的缩进与其第一行中的引号相同。
Python Docstring 最佳实践
- Python 脚本的 docstring 应该指定如何使用它。当脚本在缺少参数或参数错误的情况下执行时，它应该被打印出来。
- Python 模块 docstring 应该列出所有的类、函数、异常和对其他模块的依赖。
- Python 函数 docstring 应该指定行为、输入参数、返回类型和异常。如果在调用函数时有特定的限制，应该在函数 docstring 中指定。
- 一个类的 docstring 应该列出所有的方法和属性。如果它是从超类继承的，应该提供细节。
- 如果一个类方法覆盖了超类方法，应该指定它。
- Python 是区分大小写的。因此，保持函数参数名称与函数定义中的名称完全相同。
Python 文档字符串格式
没有与文档字符串格式相关联的规则。但是，遵循特定的风格会让你的代码看起来更好。有两种流行的 docstring 格式。
1. Epytext format
这非常类似于 javadoc 风格的注释。它包含方法描述、参数、返回以及有关引发的异常的详细信息。
def multiply(a, b):
"""This method multiplies the given two numbers.
@param a: this is the first param
@param b: this is the second param
@return: returns after multiplying a with b
@raise TypeError: raised when any of the params is not a number
"""
return a * b
2.重构文本 (reST)格式
这是新款式，在 PEP-287 中有推荐。Sphinx 使用这种风格来生成文档。
def multiply(a, b):
"""This method multiplies the given two numbers.
:param a: this is the first param
:param b: this is the second param
:return: returns after multiplying a with b
:raise TypeError: raised when any of the params is not a number
"""
return a * b
PyCharm 文档字符串快捷方式
PyCharm IDE 自动为方法生成 reST 格式的 docstring，只需在方法声明后键入三个双引号并按 enter 键。
因为 PyCharm IDE 支持 reST 风格的 docstring 的自动生成，而且 PEP-287 也推荐这样做，所以您应该以这种格式编写 docstring。
为什么您应该遵循 Python Docstring 指南？
Python 文档字符串可以通过 doc 属性来访问。构建一个系统来解析 docstring 并生成项目模块、类和函数的文档是非常容易的。这就是为什么您应该遵循 PEP-257 中列出的 docstring 指南。
我们可以使用 Docstring 进行多行注释吗？
我见过很多滥用 docstring 来提供多行注释的例子。Python 不支持多行注释。如果您希望注释扩展成多行，请以散列字符开始每一行。不要滥用 Python Docstrings。
摘要
Python docstring 提供了关于函数、类或模块的有用信息。我们可以用 doc 变量访问 docstring 值。我们应该使用 reST 格式为方法编写 docstring。
下一步是什么？
资源
Python 的 encode()和 decode()函数
原文：https://www.askpython.com/python/string/python-encode-and-decode-functions
Python 的encode和decode方法用于使用给定的编码对输入字符串进行编码和解码。让我们在本文中详细看看这两个函数。
给定字符串编码
我们对输入字符串使用encode()方法，每个字符串对象都有。
格式:
input_string.encode(encoding, errors)
这使用encoding对input_string进行编码，其中errors决定在字符串编码失败时要遵循的行为。
encode()将导致一系列的bytes。
inp_string = 'Hello'
bytes_encoded = inp_string.encode()
print(type(bytes_encoded))
正如所料，这将产生一个对象<class 'bytes'>:
<class 'bytes'>
要遵循的编码类型由 encoding参数显示。有各种类型的字符编码方案，其中方案 UTF-8 在 Python 中默认使用。
让我们用一个例子来看一下encoding参数。
a = 'This is a simple sentence.'
print('Original string:', a)
# Decodes to utf-8 by default
a_utf = a.encode()
print('Encoded string:', a_utf)
输出
Original string: This is a simple sentence.
Encoded string: b'This is a simple sentence.'
注意:正如您所看到的，我们已经将输入字符串编码为 UTF-8 格式。虽然没有太大的区别，但是您可以观察到该字符串带有前缀b。这意味着字符串被转换成字节流，这就是它在任何计算机上的存储方式。作为字节！
这实际上不是人类可读的，只是为了可读性，以原始字符串表示，加上前缀b，表示它不是一个字符串，而是一个字节序列。
处理错误
errors有多种类型，下面提到其中一些:
| 错误类型 | 行为 |
| strict | 默认行为，失败时引发UnicodeDecodeError。 |
| ignore | 从结果中忽略不可编码的 Unicode。 |
| replace | 用问号(?)替换 所有无法编码的 Unicode 字符 |
| backslashreplace | 插入一个反斜杠转义序列(\uNNNN)代替不可编码的 Unicode 字符。 |
让我们用一个简单的例子来看看上面的概念。我们将考虑并非所有字符都是可编码的输入字符串(例如ö)，
a = 'This is a bit möre cömplex sentence.'
print('Original string:', a)
print('Encoding with errors=ignore:', a.encode(encoding='ascii', errors='ignore'))
print('Encoding with errors=replace:', a.encode(encoding='ascii', errors='replace'))
输出
Original string: This is a möre cömplex sentence.
Encoding with errors=ignore: b'This is a bit mre cmplex sentence.'
Encoding with errors=replace: b'This is a bit m?re c?mplex sentence.'
解码字节流
类似于编码一个字符串，我们可以使用decode()函数将一个字节流解码成一个字符串对象。
格式:
encoded = input_string.encode()
# Using decode()
decoded = encoded.decode(decoding, errors)
因为encode()将一个字符串转换成字节，decode()只是做相反的事情。
byte_seq = b'Hello'
decoded_string = byte_seq.decode()
print(type(decoded_string))
print(decoded_string)
输出
<class 'str'>
Hello
这表明decode()将字节转换为 Python 字符串。
与encode()类似，decoding参数决定解码字节序列的编码类型。errors参数表示解码失败时的行为，与encode()的值相同。
编码的重要性
由于对输入字符串的编码和解码取决于格式，所以在编码/解码时我们必须小心。如果我们使用了错误的格式，它将导致错误的输出，并可能导致错误。
下面的片段显示了编码和解码的重要性。
第一次解码是不正确的，因为它试图解码以 UTF-8 格式编码的输入字符串。第二个是正确的，因为编码和解码格式是相同的。
a = 'This is a bit möre cömplex sentence.'
print('Original string:', a)
# Encoding in UTF-8
encoded_bytes = a.encode('utf-8', 'replace')
# Trying to decode via ASCII, which is incorrect
decoded_incorrect = encoded_bytes.decode('ascii', 'replace')
decoded_correct = encoded_bytes.decode('utf-8', 'replace')
print('Incorrectly Decoded string:', decoded_incorrect)
print('Correctly Decoded string:', decoded_correct)
输出
Original string: This is a bit möre cömplex sentence.
Incorrectly Decoded string: This is a bit m��re c��mplex sentence.
Correctly Decoded string: This is a bit möre cömplex sentence.
结论
在本文中，我们学习了如何使用encode()和decode()方法对输入字符串进行编码，并对编码的字节序列进行解码。
我们还学习了它如何通过errors参数处理编码/解码中的错误。这对于加密和解密非常有用，例如在本地缓存加密的密码并解码以备后用。
参考
- JournalDev 关于编码-解码的文章
了解 Python enumerate()方法
原文：https://www.askpython.com/python/built-in-methods/python-enumerate-method
介绍
今天在本教程中，我们将学习 Python enumerate()方法。
Python enumerate()方法
Python 内置的enumerate()方法将传递的序列转换成具有相同元素的元组形式的枚举对象。此外，该函数将索引添加到相应的元组元素。
使用 Python enumerate()方法的语法是，
enumerate( thing, start)
这里，
- thing 是我们需要添加单个元素索引的任意序列，
- start(可选)是索引开始的起始值。如果没有通过，默认值设置为 0。
使用 Python enumerate()方法
Python enumerate()方法可以将任何可迭代序列转换成添加了索引的枚举对象。这个序列可以是一个列表、字符串，或者是一个元组。但不允许是字典或集合，因为它们不是序列。
现在让我们看一些例子来更好地理解。
列举名单
当我们将一个列表传递给 Python enumerate()方法时，它会将基本索引作为第一个值添加到元组元素中。返回的 iterable 属于枚举类型。
要打印这个枚举对象，我们可以使用一个简单的for循环遍历它。注意，这次我们可以同时访问元素的索引和元素的值。
list1 = [ 11, 22, 33, 44]
enumerate_list = enumerate(list1)
print("Enumerated list now looks like: ", list(enumerate_list))
#print the index and corresponding value for enumerated list1
for i, item in enumerate(list1):
print("Index = ", i," : ","value = ",item)
输出:
Enumerated list now looks like: [(0, 11), (1, 22), (2, 33), (3, 44)]
Index = 0 : value = 11
Index = 1 : value = 22
Index = 2 : value = 33
Index = 3 : value = 44
这里，
- list1 是一个列表，里面有一些初始值。我们将它传递给 enumerate()方法，并将返回的对象存储在 enumerate_list 变量中，
- 当我们将这个对象类型化到一个列表中并尝试使用
print()方法打印它时，我们可以清楚地观察到列表中的每个元素现在都被转换成一个添加了索引的元组， - 我们使用带有两个变量 I 和 item 的 for 循环来遍历枚举对象。这样，我们可以同时访问索引 (i) 以及相应的元素 (item) 。
因此，输出是合理的。
对于元组来说，enumerate()也以同样的方式工作。
枚举字符串
类似地，我们也可以使用 Python enumerate()方法将一个字符串转换成一个添加了索引的枚举对象。
让我们看看如何。
string1 = "AskPython"
enumerate_string = enumerate(string1)
print("Enumerated list now looks like: ", list(enumerate_string))
#print the index and corresponding character for enumerated string
for i, item in enumerate(string1):
print("Index = ", i," : ","character = ",item)
输出:
Enumerated list now looks like: [(0, 'A'), (1, 's'), (2, 'k'), (3, 'P'), (4, 'y'), (5, 't'), (6, 'h'), (7, 'o'), (8, 'n')]
Index = 0 : character = A
Index = 1 : character = s
Index = 2 : character = k
Index = 3 : character = P
Index = 4 : character = y
Index = 5 : character = t
Index = 6 : character = h
Index = 7 : character = o
Index = 8 : character = n
这里，
- 我们初始化一个字符串 string1 并将它的
enumerate()输出存储在一个变量 enumerate_string 中， - 然后打印列表类型转换枚举字符串。正如我们所看到的，它是一个元组列表，包含各个字符元素及其各自的索引，
- 我们再次使用 for 循环遍历枚举对象，并打印出带有索引的元素。
带开始参数的 Python enumerate()
如前所述，start参数是一个可选参数，它确定索引将从由enumerate()方法返回的枚举对象的哪个值开始。
让我们看一个例子，其中我们试图将起始索引为 0 的列表的索引改为起始索引为 20 的列表。
list1 = [ 11, 22, 33, 44]
enumerate_list = enumerate(list1)
print("Enumerated list now looks like: ", list(enumerate_list))
#without start
print("Without Start:")
for i, item in enumerate(list1):
print("Index = ", i," : ","value = ",item)
#with start = 20
print("With Start:")
for i, item in enumerate(list1, 20):
print("Index = ", i," : ","value = ",item)
输出:
Enumerated list now looks like: [(0, 11), (1, 22), (2, 33), (3, 44)]
Without Start:
Index = 0 : value = 11
Index = 1 : value = 22
Index = 2 : value = 33
Index = 3 : value = 44
With Start:
Index = 20 : value = 11
Index = 21 : value = 22
Index = 22 : value = 33
Index = 23 : value = 44
这里，从输出可以清楚地看到，使用start=20，方法返回的枚举对象的起始索引是 20 。而没有 start(默认值 0 )索引从 0 开始。
结论
注意 Python enumerate()方法只适用于序列。因此，字典或集合不能被转换成 enumerate()对象。
因此，在本教程中，我们学习了 Python 中的enumerate()方法。如有任何问题，欢迎在评论中提问。
参考
- enumerate()–Python 文档，
- python enumerate()–Journal Dev Post。
Python eval()函数
原文：https://www.askpython.com/python/built-in-methods/python-eval
读者们，你们好。在本文中，我们将重点关注 Python eval()函数。
了解 Python eval()函数
Python eval()函数转换并计算传递给它的表达式。
注意:该方法仅用于测试目的。eval()函数不整理传递给它的表达式。如果恶意用户在这里执行 Python 代码，它很容易成为您的服务器的漏洞。
eval() function解析 python 表达式，并在 python 程序中运行作为参数传递给它的代码。
语法:
eval('expression', globals=None, locals=None)
expression:可以是用户想要在 python 代码本身内计算的任何 python 表达式(字符串参数)。globals:这是一个字典，指定了 eval()函数可以执行的表达式。locals:描述 eval()函数可以利用的局部方法和数据变量。
例 1: 传递表达式添加两个局部变量
a=20
b=30
res = eval('a+b')
print(res)
在上面的代码片段中，我们向 eval()函数传递了一个表达式“a+b ”,以便添加两个局部变量:a 和 b。
输出:
50
例 2: 用户输入的 Python eval()函数
num1 = int(input())
num2 = int(input())
mult = eval('num1*num2')
print('Multiplication:',mult)
在上面的例子中，我们接受了用户的输入，并将其赋给变量。此外，我们已经传递了这两个输入值相乘的表达式。
输出:
30
20
Multiplication: 600
带有熊猫模块的 Python eval()函数
Python eval 函数也可以和 Pandas 模块一起操作。pandas.eval()函数接受表达式，并在 python 程序中执行同样的操作。
语法:
DataFrame.eval('expression',inplace)
expression:包含在字符串引号中的 python 表达式，将在 python 程序中执行。inplace:默认值=真。如果 python 表达式被证明是赋值表达式，则 inplace 决定执行该操作并改变数据框对象。如果为 FALSE，则会创建一个新的 dataframe 并作为结果返回。
示例 1:传递 inplace = TRUE 的表达式
import pandas
data = pandas.DataFrame({"x":[1,2,3,4],"y":[1,3,5,7],"w":[2,4,6,8],"z":[1,1,1,1]})
print("Original data:\n")
print(data)
data.eval('z = x * y', inplace = True)
print("Data after executing eval():\n")
print(data)
在上面的示例中，我们创建了一个数据帧，并传递了一个要在 python 脚本中执行的表达式。
当 inplace 设置为 TRUE 时，从表达式中获得的数据值将存储在同一个 dataframe 对象“data”中。
输出:
Original data:
x y w z
0 1 1 2 1
1 2 3 4 1
2 3 5 6 1
3 4 7 8 1
Data after executing eval():
x y w z
0 1 1 2 1
1 2 3 4 6
2 3 5 6 15
3 4 7 8 28
示例 2:使用 inplace = FALSE 在 python 脚本中执行表达式
import pandas
data = pandas.DataFrame({"x":[1,2,3,4],"y":[1,3,5,7],"w":[2,4,6,8],"z":[1,1,1,1]})
print("Original data:\n")
print(data)
data1 = data.eval('z = x * y', inplace = False)
print("Data after executing eval():\n")
print(data1)
在上面的代码片段中，我们将 inplace = FALSE 传递给了 eval()函数。因此，python 表达式的结果将存储在新的 dataframe 对象“data1”中。
输出:
Original data:
x y w z
0 1 1 2 1
1 2 3 4 1
2 3 5 6 1
3 4 7 8 1
Data after executing eval():
x y w z
0 1 1 2 1
1 2 3 4 6
2 3 5 6 15
3 4 7 8 28
eval()函数的安全问题
- Python eval()函数更容易受到安全威胁。
- 通过 Python eval()函数可以很容易地获得敏感的用户输入数据。
- 因此，提供了参数 globals 和 locals 来限制对数据的直接访问。
摘要
- Python eval()函数用于直接在 Python 脚本中执行 python 表达式。
- eval()函数也可以以类似的方式用于 Pandas 模块。
- Python eval()函数更容易受到安全威胁。因此，在执行 eval()函数之前，有必要检查传递给它的信息。
结论
因此，在本文中，我们已经了解了 Python eval()函数的工作原理和漏洞。
参考
- Python eval()函数— JournalDev
Python 异常处理–Try，Except，Finally
原文：https://www.askpython.com/python/python-exception-handling
- 异常是改变程序正常执行流程的错误场景。
- 处理可能的异常的过程称为异常处理。
- 如果异常处理不当，程序可能会提前终止。这可能会导致数据损坏或不必要的结果。
- Python 异常处理是通过三个关键字块实现的——try、except 和 finally。
- try 块包含可能引发异常或错误的代码。
- except 块用于捕捉异常并处理它们。
- catch 块代码仅在引发相应的异常时执行。
- 可以有多个 catch 块。我们也可以在一个 catch 块中捕获多个异常。
- finally 块代码总是被执行，无论程序是否正确执行或是否引发异常。
- 我们也可以用 try-except 块创建一个" else "块。如果没有引发异常，则执行 else 块中的代码。
Python 中如何处理异常？
让我们看一个需要异常处理的例子。
def divide(x, y):
print(f'{x}/{y} is {x / y}')
divide(10, 2)
divide(10, 0)
divide(10, 4)
如果我们运行上面的程序，我们会得到下面的输出。
10/2 is 5.0
Traceback (most recent call last):
File "/Users/pankaj/Documents/PycharmProjects/PythonTutorialPro/hello-world/exception_handling.py", line 6, in <module>
divide(10, 0)
File "/Users/pankaj/Documents/PycharmProjects/PythonTutorialPro/hello-world/exception_handling.py", line 2, in divide
print(f'{x}/{y} is {x / y}')
ZeroDivisionError: division by zero
对 divide()函数的第二次调用引发了 ZeroDivisionError 异常，程序终止。
我们从未得到第三次调用 divide()方法的输出，因为我们没有在代码中进行异常处理。
让我们用适当的异常处理重写 divide()方法。如果有人试图除以 0，我们将捕捉异常并打印一条错误消息。这样，程序不会过早终止，输出也更有意义。
def divide(x, y):
try:
print(f'{x}/{y} is {x / y}')
except ZeroDivisionError as e:
print(e)
divide(10, 2)
divide(10, 0)
divide(10, 4)
输出:
10/2 is 5.0
division by zero
10/4 is 2.5
Python Exception Handling
什么是 BaseException 类？
BaseException 类是所有异常的基类。它有四个子类。
- 异常–这是所有非退出异常的基类。
- generator exit–请求发电机退出。
- 键盘中断–程序被用户中断。
- 系统退出–请求退出解释器。
一些内置的异常类
Python 中的一些内置异常类有:
- 算术错误–这是算术错误的基类。
- 断言错误–当断言失败时引发。
- 属性错误–找不到属性时。
- 缓冲器错误
- EOFError–文件结束后读取
- 导入错误–当导入的模块没有找到时。
- LookupError–查找错误的基本异常。
- 内存错误–出现内存不足时
- name error–未在全局范围内找到名称时。
- OSError–I/O 错误的基类
- 参考错误
- RuntimeError
- 停止迭代，停止迭代
- 语法错误–无效语法
- 系统错误–Python 解释器中的内部错误。
- 类型错误–无效的参数类型
- 值错误–无效的参数值
一些内置的警告类
警告类是所有警告的基类。它有以下子类。
- bytes warning–字节，以及与缓冲区相关的警告，主要与字符串转换和比较相关。
- 弃用警告–关于弃用功能的警告
- future warning–警告未来语义发生变化的结构的基类。
- import warning–关于模块导入错误的警告
- PendingDeprecationWarning–关于未来将被弃用的功能的警告。
- 资源警告–资源使用警告
- 运行时警告–关于可疑运行时行为的警告。
- 语法警告–关于可疑语法的警告
- Unicode warning–与 Unicode 转换相关的警告
- 用户警告–用户代码生成的警告
在单个 Except 块中处理多个异常
除了块，一个 try 块可以有多个。我们可以在每个 except 块中捕捉特定的异常。
def divide(x, y):
try:
print(f'{x}/{y} is {x / y}')
except ZeroDivisionError as e:
print(e)
except TypeError as e:
print(e)
except ValueError as e:
print(e)
每个 except 块中的代码都是相同的。在这个场景中，我们可以在一个 except 块中处理多个异常。我们可以向 except 块传递一组异常对象来捕捉多个异常。
def divide(x, y):
try:
print(f'{x}/{y} is {x / y}')
except (ZeroDivisionError, TypeError, ValueError) as e:
print(e)
在单个 Except 块中捕获所有异常
如果我们没有在 except 块中指定任何异常类，它将捕获 try 块引发的所有异常。当我们不知道 try 块可能引发的异常时，这样做是有益的。
空的 except 子句必须是异常处理链中的最后一个子句。
def divide(x, y):
try:
print(f'{x}/{y} is {x / y}')
except ZeroDivisionError as e:
print(e)
except:
print("unknown error occurred")
将 else 块与 try-except 一起使用
else 块代码是可选的。当 try 块没有引发异常时，就执行这个函数。
def divide(x, y):
try:
print(f'{x}/{y} is {x / y}')
except ZeroDivisionError as e:
print(e)
else:
print("divide() function worked fine.")
divide(10, 2)
divide(10, 0)
divide(10, 4)
输出:
Python Try Except Else Block
当 divide()函数 try 块正常工作时，else 块代码执行了两次。
使用带有 try-except 的 finally 块
无论是否有异常，finally 块代码在所有情况下都会被执行。finally 块用于关闭资源和执行清理活动。
def divide(x, y):
try:
print(f'{x}/{y} is {x / y}')
except ZeroDivisionError as e:
print(e)
else:
print("divide() function worked fine.")
finally:
print("close all the resources here")
divide(10, 2)
divide(10, 0)
divide(10, 4)
输出:
Python Try Except Else Finally Block
Python 异常处理语法
现在我们已经看到了 Python 中与异常处理相关的所有内容，最后的语法是:
try -> except 1...n -> else -> finally
对于一个 try 块，我们可以有许多 except 块。但是，我们只能有一个其他的，并最终阻止。
创建自定义异常类
我们可以通过扩展异常类来创建一个定制的异常类。最佳实践是创建一个基本异常，然后派生其他异常类。下面是一些创建用户定义的异常类的例子。
class EmployeeModuleError(Exception):
"""Base Exception Class for our Employee module"""
pass
class EmployeeNotFoundError(EmployeeModuleError):
"""Error raised when employee is not found in the database"""
def __init__(self, emp_id, msg):
self.employee_id = emp_id
self.error_message = msg
class EmployeeUpdateError(EmployeeModuleError):
"""Error raised when employee update fails"""
def __init__(self, emp_id, sql_error_code, sql_error_msg):
self.employee_id = emp_id
self.error_message = sql_error_msg
self.error_code = sql_error_code
命名约定是在异常类的名称后面加上“Error”。
引发异常
我们可以使用 raise 关键字从代码中抛出一个异常。一些可能的情况是:
- 函数输入参数验证失败
- 捕捉异常，然后引发自定义异常
class ValidationError(Exception):
pass
def divide(x, y):
try:
if type(x) is not int:
raise TypeError("Unsupported type")
if type(y) is not int:
raise TypeError("Unsupported type")
except TypeError as e:
print(e)
raise ValidationError("Invalid type of arguments")
if y is 0:
raise ValidationError("We can't divide by 0.")
try:
divide(10, 0)
except ValidationError as ve:
print(ve)
try:
divide(10, "5")
except ValidationError as ve:
print(ve)
输出:
We can't divide by 0.
Unsupported type
Invalid type of arguments
嵌套的 try-except 块示例
我们可以在 Python 中嵌套 try-except 块。在这种情况下，如果嵌套的 try 块中出现异常，将使用嵌套的 except 块来处理它。如果嵌套的 except 不能处理它，外部的 except 块将用于处理该异常。
x = 10
y = 0
try:
print("outer try block")
try:
print("nested try block")
print(x / y)
except TypeError as te:
print("nested except block")
print(te)
except ZeroDivisionError as ze:
print("outer except block")
print(ze)
输出:
outer try block
nested try block
outer except block
division by zero
Python 异常处理最佳实践
- 总是试图在代码中处理异常，以避免程序异常终止。
- 创建自定义异常类时，在其名称后面加上“Error”。
- 如果 except 子句具有相同的代码，请尝试在单个 except 块中捕获多个异常。
- 使用 finally 块关闭重资源并移除重对象。
- 使用 else 块记录代码的成功执行，发送通知等。
- 尽可能避免裸露的 except 子句。如果你不知道异常，那就只使用它。
- 为特定场景创建特定于模块的异常类。
- 您可以在 except 块中捕获异常，然后引发另一个更有意义的异常。
- 总是用有意义的消息引发异常。
- 避免嵌套的 try-except 块，因为这会降低代码的可读性。
参考资料:
了解 Python exec()方法
原文：https://www.askpython.com/python/built-in-methods/python-exec-method
所以今天在本教程中，我们来了解一下中的Python exec()方法。
Python exec()方法
基本上，Python exec()方法以字符串的形式执行传递的代码集。它非常有用，因为它实际上支持动态执行。下面给出了该方法的语法。
exec(object, globals, locals)
这里，object可以是一个字符串，一个打开的文件对象，或者一个代码对象。
- For string–该字符串被解析为一组 Python 语句，然后被执行(除非出现语法错误)。
- 对于一个打开的文件–文件被解析直到 EOF 并执行。
- 对于一个代码对象–它被简单地执行。
并且两个可选参数globals和locals必须是用于全局和局部变量的字典。
现在我们已经对exec()方法有了一个基本的概念，让我们通过一个例子来理解它的工作原理。
>>> exec("print('Hey!')")
Hey!
>>> exec("print(6+4)")
10
从上面的代码片段可以清楚地看到，print()语句被exec()方法成功地执行了，我们得到了想要的结果。
使用 Python exec()方法
现在让我们直接进入一些例子，探索在有和没有globals和locals参数的情况下exec()方法在 Python 中是如何工作的。
1.没有全局和局部参数
在前面的例子中，我们只是在 Python 中执行了一些指令集，将对象参数传递给了exec()方法。但是，我们在当前范围内没有看到这些名称。
现在让我们在调用exec()方法之前，使用 dir() 方法获得当前方法和名称的列表，其中包含了math模块。
from math import *
exec("print(pow(2, 5))")
exec("print(dir())")
输出:
32.0
['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc']
正如你所看到的，包括builtins在内的各种方法，以及来自math模块的方法，现在都在当前的作用域中，可供 Python exec()方法使用。
当考虑执行动态 Python 代码时，这提出了一个很大的安全问题。用户可能包含一些模块来访问系统命令，这些命令甚至会使您的计算机崩溃。使用globals和locals参数，我们可以限制exec()超越我们想要访问的方法。
2.使用全局参数
现在让我们看看如何使用带有全局参数的 Python exec()方法。Python 允许我们只传递和指定我们希望exec()方法从内置模块中访问(以字典的形式)的方法。
def squareNo(a):
return a*a
exec('print(squareit(10))',{"__builtins__":{"squareit": squareNo, "print": print}})
exec("print(dir())")
输出:
100
['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'squareNo']
在上面的代码中，我们传递了一个包含方法squareNo()(映射到一个自定义名称 squareit )和print()的字典。注意，使用内置方法中的任何其他方法都会引发一个TypeError。
3.带局部变量参数
当我们只传递local参数(字典)时，默认情况下，所有的内置方法也是可用的，除非我们显式排除它们。
看看下面的例子，这里虽然我们已经指定了locals字典，但是所有的内置和数学模块方法在当前作用域中都是可用的。
from math import *
def squareNo(a):
return a*a
#global And local parameters
exec('print(pow(4,3))', {"squareit": squareNo, "print": print})
exec("print(dir())")
输出:
64
['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'squareNo', 'tan', 'tanh', 'tau', 'trunc']
因此，现在明确排除了内置。
from math import *
def squareNo(a):
return a*a
#explicitly excluding built-ins
exec('print(pow(4,3))', {"__builtins__": None},{"squareit": squareNo, "print": print})
exec("print(dir())")
输出:
Traceback (most recent call last):
File "C:/Users/sneha/Desktop/test.py", line 7, in <module>
exec('print(pow(4,3))', {"__builtins__": None},{"squareit": squareNo, "print": print})
File "<string>", line 1, in <module>
TypeError: 'NoneType' object is not subscriptable
在上面的代码中，限制exec()方法只能使用传递的(局部变量)方法实际上使得pow()方法不可访问。因此，在运行它时，我们得到了TypeError。
Python 中的 exec()与 eval()
虽然eval()和exec()方法做的工作几乎相同，但是它们之间有两个主要的区别。
- eval() 只能执行一个表达式，而 exec() 可以用来执行动态创建的语句或程序，可以包括循环、
if-else语句、函数和class定义。 - eval() 在执行一个特定的表达式后返回值，而 exec() 基本上什么也不返回，只是忽略这个值。
结论
今天就到这里吧。希望你对 Python exec()方法的工作和使用有一个清晰的理解。
如有任何与 Python exec()相关的问题，欢迎在下面的评论中提问。
参考
- exec 语句–Python 文档，
- eval、exec 和 compile 有什么区别？–堆栈溢出问题，
- python exec()–journal dev Post。
了解 Python f 字符串
Python 中的字符串格式化可以用 f-string 实现。因此，在本文中，我们将关注 Python f-string 的实现。
Python 中 f-string 的必要性
Python f-string 基本上服务于字符串格式化的目的。在“f-strings”出现之前，我们有以下几种在 Python 中格式化字符串的方法:
1。****Python“%”运算符 —
缺点 : Python % operator不能和对象、属性一起使用。
2。 Python format()函数—
缺点:string.format() function可以克服“%”操作符的缺点，但是它被证明是一种冗长的格式。
因此， Python f-string 应运而生，其中可以用更简单和最少的语法对字符串进行插值和格式化。Python 解释器在运行时格式化字符串。
Python f-string 的使用示例
f 字符串也称为格式化字符串，用于文字字符串插值，即注入字符串并格式化特定字符串。
语法:
f'{string}'
例子: f-string 以 string 为可迭代
str1 = 'Python'
str4 = 'JournalDev'
res = f'{str4} provides tutorials on {str1}'
print(res)
如上所述，f-string 用于在字符串语句之间注入或插入输入字符串 str1 和 str4 。
输出:
JournalDev provides tutorials on Python
带有原始字符串的 Python f 字符串
Python 原始字符串基本上将被视为‘转义序列’的特殊字符视为文字字符。当我们希望转义序列，即 '\n' 或反斜杠() 作为字符的文字序列时，就使用它。
语法:Python 原始字符串
r'string'
Python f 字符串可以很好地与原始字符串同时工作。
语法:f 字符串和原始字符串
fr'string or {string}'
举例:
str1 = 'Python'
str4 = 'JournalDev'
res = fr'{str4} \n and AskPython provides tutorials on {str1}'
print(res)
在上面的示例中，' \n '被视为文字字符。
输出:
JournalDev \n and AskPython provides tutorials on Python
用 f 字符串调用函数
Python f-strings 使我们能够在其中调用函数。因此，在一定程度上优化了代码。同样的方法可以用于在 f 字符串分支中创建 lambda 函数。
语法:
f'{func()}'
举例:
def mult(a,b):
res = a*b
return res
mult_res = f'{mult(10,20)}'
print(mult_res)
输出:
200
带空白/空白的 Python f 字符串
Python f-strings 也可以处理空格或空白字符。它忽略了尾随和前导空格和文本字符串之间的空格不变和保留。
举例:
mult_res = f' Multiplication: { 10 * 10 } '
print(mult_res)
输出:
Multiplication: 100
带表达式的 Python f 字符串
Python f-string 可以处理表达式。因此，基本操作可以直接在 f 弦中执行。
语法:
f'{expression'}
举例:
x = 10
y = 5
print(f'Result: {x/y} ')
输出:
Result: 2.0
带有 Python 字典的 f 字符串
众所周知， Python 字典数据结构使用键值对。Python f-string 也可以和字典一起放入框架中。
语法:
f"{dict['key']}"
举例:
info = {'age':'21', 'city':'Pune'}
print(f"{info['city']}")
输出:
Pune
结论
因此，在本文中，我们已经理解了 f-string 使用各种可重复项和表达式的必要性和工作原理。
参考
- Python f 字符串— JournalDev
- 字符串插值— PEP 498
Python 阶乘示例
原文：https://www.askpython.com/python/examples/python-factorial-example
在本文中，我们将看看如何使用不同的方法计算 Python 阶乘。
Python 阶乘函数
Python 阶乘函数factorial(n)是为整数n定义的。这将计算从n到1的所有项的乘积。factorial(0)取为1。
所以，函数是:
factorial(n) = n * (n-1) * (n-2) * ... * 1, n >= 1
factorial(n) = 1, n = 0
因此，阶乘(4) = 4 * 3 * 2 * 1 = 24 。
我们来分析一下如何用 Python 写这个数学函数。
使用 math.factorial()
我们可以直接使用math模块的阶乘函数来完成使用:
import math
def factorial(x):
return math.factorial(x)
print(factorial(5))
输出
120
我们还会用其他方法来寻找这个函数:现在让我们用一个迭代的过程。
使用迭代程序
我们可以直接循环 1 到 n 的所有数字，然后直接乘以乘积。
def factorial(n):
if n == 0:
return 1
prod = 1
for i in range(1, n+1):
prod = prod * i
return prod
if __name__ == '__main__':
print(factorial(4))
print(factorial(7))
输出
24
5040
现在让我们来看看如何使用 Python 阶乘函数的递归方法。
使用递归过程
我们可以利用递归，来计算这个函数。基本上，我们把这个函数简化成一个更小的子问题。在我们计算完子问题后，我们可以将结果组合起来给出最终答案。
由于问题结构是一个递减的乘积，我们可以用以下方式对递归进行建模:
factorial(n) = n * factorial(n-1), n >= 1
factorial(0) = 1, n = 0
最后一行是基本情况。这是递归停止的点，当递归展开时，我们可以得到最终的乘积。
我们将为此编写相应的 Python 函数:
def factorial(n):
if n == 0:
# Base case n = 0
return 1
else:
# Use the definition of factorial function
return n * factorial(n-1)
if __name__ == '__main__':
print(factorial(4))
print(factorial(7))
输出
24
5040
那似乎是正确的。让我们分析一下递归调用中实际发生了什么。
无论何时使用递归调用，都有一个调用栈，它持续存储程序的状态，直到到达基本情况。当递归从n = 0展开时，在相应的块返回一个值之后，堆栈元素最终被逐个弹出。
为了找到fact(3)，整个过程解释如下图。整个过程的第一部分是堆栈的构建，其中每个递归调用都堆叠在彼此之上，直到函数返回 1。
一旦函数不能再递归调用，它就开始计算阶乘，如下所示。
Recursion Stack
当函数返回时，堆栈元素从顶部一个接一个地弹出。当它最终到达main()栈时，函数最终完成，我们有了自己的值，出来就是6。
尾部递归调用
虽然我们的程序运行良好，但递归函数的问题是堆栈大小与输入大小一样大。
因此，如果n是一个非常大的数字，我们的递归堆栈可能会非常大，这可能会导致堆栈溢出！为了避免这种情况，我们将使用另一种方法来编写递归函数，称为 尾递归过程 。
尾部过程调用旨在计算中间结果后执行递归调用。因此，程序可以在整个进程中使用同一个堆栈，而不是增加堆栈的大小！它只需要更新。
这意味着我们的递归调用必须总是在末尾。这就是为什么它是一个“尾叫”。
def fact_helper(accum, n):
if n == 0:
return accum
return fact_helper(accum*n, n-1)
def factorial(n):
return fact_helper(1, n)
if __name__ == '__main__':
print(factorial(4))
print(factorial(7))
由于我们不能在最后直接进行递归调用，我们用另一个帮助函数来做，它为我们做实际的计算。这个帮助器函数存储一个accumulator，它存储函数的当前值。
诀窍是将累加器作为参数传递给递归函数，并使用accum*n更新它。这样，我们将把中间状态存储在一个变量中，因此，只存储在一个堆栈帧中！
输出
24
5040
你得到和以前一样的输出！现在，您还确保了程序只使用一个堆栈帧，所以它本质上等同于迭代过程！这不是很好吗？
结论
在本文中，我们学习了如何使用 math 模块以及通过迭代和递归以不同的方式实现阶乘函数。
参考
Python 文件处理
什么是 Python 文件处理？
**File handling**基本上是管理文件系统上的文件。每个操作系统都有自己存储文件的方式。
Python 文件处理对于在我们的程序中处理文件很有用。我们不必担心底层操作系统及其文件系统规则和操作。
File Operations
1.open()函数
open()函数用于在特定模式下打开文件。
它基本上创建了一个可用于进一步操作的文件对象。
语法:
open(file_name, mode)
打开文件的不同模式:
- r :读取
- w :写
- a :追加
- r +:读写
最初，我们需要创建一个文件，并将其放在与脚本相同的目录中。
demo . txt
Welcome to the programming world!
Execute_file.py
demo_file = open('Demo.txt', 'r')
# This statement will print every line in the file
for x in demo_file:
print (x)
# close the file, very important
demo_file.close()
输出:
Welcome to the programming world!
在这里，Execute_file.py 脚本打开 Demo.txt 文件并逐行打印全部内容。
2.read()函数
read()函数用于读取文件的内容。为了达到同样的目的，我们需要以读模式打开一个文件。
demo_file = open("Demo.txt", "r")
print(demo_file.read())
demo_file.close()
输出:
Welcome to the programming world!
3.write()函数
write()函数用于写入文件并对其进行修改。
demo_file = open('Demo.txt','w')
demo_file.write("Hello Everyone!.\n")
demo_file.write("Engineering Discipline.")
demo_file.close()
输出:当我们打开 Demo.txt 文件时，可以看到这里反映的变化。
Hello Everyone!.
Engineering Discipline.
4.append()函数
demo_file = open('Demo.txt','a')
demo_file.write("\nStatement added to the end of the file..")
demo_file.close()
输出:
Hello Everyone!.
Engineering Discipline.
Statement added to the end of the file..
5.split()函数
函数的作用是:在一个文件中分割行。它一遇到脚本中的空格就会分裂。
demo . txt
Hello Everyone!.
Engineering Discipline.
Statement added to the end of the file..
Execute_file.py
with open("Demo.txt", "r") as demo_file:
demo_data = demo_file.readlines()
for line in demo_data:
result = line.split()
print(result)
输出:
['Hello', 'Everyone!.']
['Engineering', 'Discipline.']
['Statement', 'added', 'to', 'the', 'end', 'of', 'the', 'file..']
6.close()函数
**close()**函数用于关闭一个特定的文件，对它进行 post 操作。
写入文件后，如果我们不调用 close()方法，所有写入文件的数据都不会保存在其中。
在我们使用完文件以释放资源之后，关闭它总是一个好主意。
语法:
file-name.close()
7.重命名()函数
操作系统模块提供了**rename()**方法来改变特定文件的名称。
语法:
os.rename(current_name,new_name)
8.移除()方法
os 模块提供了**remove()**方法来删除作为输入给出的文件。
import os
os.remove('Demo.txt')
在执行 remove()方法之前..
Before remove()
输出: 执行 remove()方法后
After remove()
结论
因此，在本文中，我们已经理解了 Python 中的文件操作。
参考
- Python 文件处理
- 文件操作文档
Python how to–使用 Python 文件输入模块
原文：https://www.askpython.com/python-modules/python-fileinput-module
大家好！在本文中，我们将了解如何使用 Python fileinput 模块。这是一个非常方便的实用模块，可以快速浏览作为输入的文件列表。
让我们看看如何使用这个模块有效地遍历输入文件。
如何使用 Python 文件输入模块
这是 Python 标准库的一部分，所以不需要 pip 安装这个模块。
为了导入这个模块，我们可以使用下面的语句:
import fileinput
通常，如果你想对单个输入文件做一些 IO 操作(读/写)，我们一般使用 open()函数来实现。
但是，如果您需要传递多个文件，我们可以使用fileinput直接快速遍历所有文件。
现在我们来看一个例子。
1.读取多个文件
这个模块的主要用途是将fileinput.FileInput实例用作上下文管理器。
import fileinput
with fileinput.FileInput(files=('a.txt', 'b.txt'), mode='r') as input:
...
在这里，我们可以向关键字参数files传递任意多的文件。也允许使用单个文件。
要指定打开文件的模式，我们必须指定关键字参数mode。
假设我们的目录有以下两个文件a.txt和b.txt，内容如下:
$ cat a.txt
Hello from AskPython!
This is a.txt
$ cat b.txt
Hello from AskPython!
this is b.txt
现在，我们将把这两个文件作为输入传递给我们的示例程序:
import fileinput
with fileinput.FileInput(files=('a.txt', 'b.txt'), mode='r') as input:
for line in input:
print(line)
输出
Hello from AskPython!
This is a.txt
Hello from AskPython!
This is b.txt
事实上，我们能够打印这两个文件！每行之间的空格是由于print()在每个语句后添加了一个新行。由于我们的文件已经有了新的行，它将在中间打印一个额外的行。
2.验证第一行并读取文件名
现在，我们可以利用这个模块的其他方法。
如果您想查看当前正在读取的文件的名称，我们可以使用fileinput.filename()方法。
然而，如果没有行被读取，这将返回None！所以你只能在第一次阅读后使用。
如果我们想找出正在读取的文件的名称，我们可以再使用一个标志。
如果读取的行是第一行，fileinput.isfirstline()方法将返回True！因此，如果该标志为真，我们可以打印到控制台。
这里有一个简单的例子，对a.txt和b.txt使用相同的程序
import fileinput
with fileinput.FileInput(files=('a.txt', 'b.txt'), mode='r') as input:
for idx, line in enumerate(input):
if input.isfirstline() == True:
# We will indicate the file name being read if the first line is read
print(f'Reading file {input.filename()}...')
print(line)
输出
Reading file a.txt...
Hello from AskPython!
This is a.txt
Reading file b.txt...
Hello from AskPython!
This is b.txt
正如你所看到的，当第一行是 beign read 时，我们能够查看正在读取的文件的名称。
类似地，我们可以使用其他助手方法快速地在输入文件中迭代。
要了解更多，您可以查看文档。
结论
在本文中，我们学习了如何使用 Python 中的 fileinput 模块快速遍历来自stdin的输入文件。
参考
- 文件输入模块文档
[已解决]Python file not found error–快速指南
原文： https://www.askpython.com/python/examples/python-filenotfounderror
在本文中，我们将解决 Python 中一个非常常见的错误—filenotfounderror。如果你以前使用过 Python，你也会面临这种情况，你写所有的代码，在其中保持适当的缩进，放入注释行，仔细检查错误类型，在确保所有东西都是正确的并在它的位置上之后，你运行代码并最终在编译器行中得到“filenotfounderror”。
令人沮丧，不是吗？不要担心，我们将确保涵盖所有可能的方法来解决这个问题，这样您就不会再次遇到它。
What is filenotfounderror
当您试图执行一个命令，而该命令需要一个系统找不到的文件时，编译器会抛出一条系统消息。这可能是由于各种原因，如指定了错误的文件路径，文件存在于另一个目录中，或扩展名错误。我们将在本文中讨论这些要点。但是让我们首先重现我们系统中的问题。
我们将编写一个程序，将一个. csv 文件加载到 pandas 数据帧中，然后打印该数据帧。
import pandas as pd
df=pd.read_csv("nifty 2020 crash")
print(df)
Filenotfounderror
如何修复 Python filenotfounderror？
当您在终端中运行 python 代码时，它会在运行终端的根目录中搜索文件。人们有一个常见的误解，就是当你运行 python 代码读取一个文件时，终端会在整个计算机中搜索那个文件，这是不正确的。
程序所需的所有文件都应该存在于终端被激活的根目录中。
这个问题可以通过两种方式解决:
方法 1:指定完整的文件路径
当我们运行程序时，我们在程序中声明文件名。编译器在根目录中搜索它并抛出错误。这个问题的解决方案是在代码中指定完整的文件路径。
import pandas as pd
df = pd.read_csv(r"C:\Users\Win 10\Desktop\python_errorsolving\nifty 2020 crash.csv")
print(df)
注意:注意，在指定文件路径时，我们在写路径前加了一个 r，pd.read_csv(r"C:\.......)。它用于将简单字符串转换为原始字符串。如果我们在指定文件路径之前没有添加 r，系统会把那行代码当作普通的字符串输入，而不是文件路径。
方法 2:使用. txt 文件运行 Python 脚本
在这个方法中，我们使用了一个非常简单但有效的方法来解决这个问题。我们将代码写在一个. txt 文件中，并将其存储在我们需要的文件所在的目录中。当我们运行这个的时候。txt 文件，编译器仅在该目录中搜索该文件。这种方法不要求我们指定完整的文件路径，但是我们需要确保终端是从正确的目录运行的。
为了说明这个例子，我们在桌面上创建了一个名为‘python _ error solutioning’的目录。这个目录包含两个文件。包含 python 代码和。我们的代码需要 csv 文件。
要从终端运行这个文件，使用cd手动转到目录，然后使用语法python error_crt.txt或您的文件名运行这个文件。
如您所见，这种方法不需要我们指定完整的文件路径。当您必须处理多个文件时，这很有用，因为为每个特定文件指定完整的路径可能是一项繁琐的工作。
方法 filenotfounderror 的变通方法
这不是一个解决方案，而是这个问题的一个变通办法。假设您处于某种情况下，文件路径是相同的，但您必须加载连续的不同文件。在这种情况下，您可以将文件名和文件路径存储在两个不同的变量中，然后将它们连接到第三个变量中。通过这种方式，您可以将多个不同的文件组合起来，然后轻松地加载它们。
为了说明这个解决方案，我们将创建一个. txt 文件，代码如下:
import pandas as pd
filename = "nifty 2020 crash.csv"
filepath = "C:\\Users\\Win 10\\Desktop\\python_errorsolving\\"
file = filepath+filename
df = pd.read_csv(file)
print(df)
使用 IDE 修复 filenotfounderror
集成开发环境是管理文件和环境变量的好方法。这有助于为您的代码创建虚拟环境，以便所需的库和环境变量不会与我们的其他项目交互。在这一节中，我们将在 PyCharm IDE 中创建一个项目，看看我们可以多么轻松地存储文件并与之交互。
为了演示这个例子，我们创建了一个包含学校记录的. csv 文件，并将其命名为“book1.csv”。要将其导入 PyCharm，请按照以下步骤操作:
步骤 1: 转到文件>新建项目… >给一个文件名>创建。
第二步:复制你的。csv 文件并将其粘贴到项目中。
粘贴文件后，您可以用代码直接访问该文件，而不必指定完整的路径。您可以简单地使用文件名。
import pandas as pd
df = pd.read_csv('Book1.csv', sep='|')
print(df)
结果:
结论
在本文中，我们观察了系统找不到文件的不同情况。我们还研究了这些问题的不同解决方案，从手动指定路径，到使用 IDE 获得更好的结果。我希望这篇文章能解决你的问题
Python 过滤器()函数
原文：https://www.askpython.com/python/built-in-methods/python-filter-function
Python 的**filter**()函数用于在测试 iterable 上每个元素的谓词的帮助下过滤 iterable(序列)的元素。
谓词是一个总是返回**True**或**False**的函数。我们不能将通用函数与filter()一起使用，因为只有满足合适的条件时，它才返回所有元素。这意味着过滤函数必须总是返回一个布尔值，因此，过滤函数是一个谓词。
过滤器的基本格式()
因为这是一个在 Python iterable 上操作的函数，所以 iterable 是参数之一。因为它在每个元素上测试一个谓词，所以这个函数也是另一个需要的参数。
因为它从序列中过滤出元素，所以它还必须返回一个 iterable，该 iterable 只包含满足过滤函数的元素。
但是在这种情况下，由于我们使用的是对象，Python 返回给我们一个 过滤器对象 作为可迭代对象，这将证明使用类似list()和dict()的方法转换成其他类型是很方便的。
很简单，不是吗？让我们看看我们如何应用它，并使用filter()创建工作程序。
格式:filter_object = filter(predicate, iterable)
下面是一个非常简单的例子，用一个函数过滤一个列表，这个函数测试一个数字是奇数还是偶数。
a = [1, 2, 3, 4, 5]
# We filter using a lambda function predicate.
# This predicate returns true
# only if the number is even.
filter_obj_even = filter(lambda x: x%2 == 0, a)
print(type(filter_obj_even))
# Convert to a list using list()
print('Even numbers:', list(filter_obj_even))
# We can also use define the predicate using def()
def odd(num):
return (num % 2) != 0
filter_obj_odd = filter(odd, a)
print('Odd numbers:', list(filter_obj_odd))
输出
<class 'filter'>
Even numbers: [2, 4]
Odd numbers: [1, 3, 5]
请注意，我们可以通过迭代获得 filter 对象的单个元素，因为它是可迭代的:
for item in filter_obj_odd:
print(item)
输出
1
3
5
过滤器()和无
我们也可以用None和filter()做谓语。如果对象的布尔值为True，则None返回True，否则返回False。
这意味着像0、None、''、[]等对象都被None谓词过滤掉，因为它们是空元素对象。
a = [0, 1, 'Hello', '', [], [1,2,3], 0.1, 0.0]
print(list(filter(None, a)))
输出
[1, 'Hello', [1, 2, 3], 0.1]
结论
我们学习了 Python 为我们提供的用于在 iterable 上应用谓词的filter()函数。
filter的简洁性和可读性使其成为现代 Python 代码库开发人员中非常受欢迎的函数。
参考
- 关于 Python 过滤器的 JournalDev 文章
- Python.org API 文件
Python float()方法
原文：https://www.askpython.com/python/built-in-methods/python-float-method
介绍
所有 Python 特性都与对象相关联。Python float 在 Python 中创建浮点对象。它是 Python 编程的基本元素之一。
此外，所有种类的对象都被分为不同的类型。python 中的一些基本原生类型是字符串、整数、复数以及最后的浮点数。
重点关注浮点类型，本地 Python float()方法用于创建浮点类型对象，以及将任何其他类型类型强制转换为相应的浮点类型。
因此，在本教程中，我们将讨论 Python float()方法做什么，以及如何在我们的代码中相应地使用它。
Python float()基础知识
基本上，Python float()函数用于从其他类型转换一些数据，如整数、字符串等。，向式浮动。它还用于声明浮点类型变量。
现在让我们看看这个函数是怎样的，
f = float( )
在这里，f是类型为 float 的新对象。我们也可以从其他类型转换过来。让我们看看如何
f = float( Val )
这里，Val是某种其他类型的数据，它被类型转换为 float，然后存储在f变量中(float 类型)。
Python float()方法用法
看看下面的例子。这里我们试着计算一个用户自定义长宽的矩形的面积。
#taking the length and breadth of the rectangle as user inputs
len=input("Enter the length of the rectangle : ")
brdth=input("Enter the breadth of the rectangle : ")
#at this point both len and brdth are holding str values
area=float() #area declared as float() object
#len and brdth type-casted to float for * operation
area=float(len)*float(brdth)
#area is calculated
print("The area of the given rectangle is : ",area)
print("type of area= ",type(area))
输出:
float() Example
在上面的代码中，
- 首先，我们将矩形的长度以及宽度作为用户输入。默认情况下存储为字符串类型值
- 然后我们声明一个变量
area，一个 float 类型的对象，它将在将来存储矩形的面积 - 之后，我们使用
float()方法将字符串类型len和brdth参数显式转换为浮点类型。并进一步计算出面积，即长度*宽度，并打印出来 - 最后，我们打印区域的
type(),不出所料，结果是浮动类型本身
Python float()的各种用法
除了对象声明，float()方法也可以用于将其他数据类型转换为浮点类型，也可以和一些特殊的参数一起使用。让我们看看这个函数是如何根据我们传递的参数工作的。
1.使用 float()进行类型转换
我们已经看到，在上面的例子中，我们可以显式地将任何数据类型的任何变量转换成浮点类型。为了更好的理解，让我们看看这个方法是如何处理不同的数据类型的，比如字符串和整数。
s=100
print("s=",s)
print("Type before : ",type(s))
s=float(s)
print("s=",s)
print("Type after : ",type(s))
输出:
s= 100
Type before : <class 'int'>
s= 100.0
Type after : <class 'float'>
在这里，我们可以观察到，变量的类型从整型转换为浮点型。
之前我们在开始时看到了字符串到浮点的类型转换。在这种情况下，字符串len和brdth是数字。如果字符串不是任何数字呢？让我们看看，
s="AskPython"
print("s=",s)
print("Type before : ",type(s))
s=float(s)
print("s=",s)
print("Type after : ",type(s))
输出:
s= AskPython
Type before : <class 'str'>
Traceback (most recent call last):
File "C:/Users/sneha/Desktop/test.py", line 4, in <module>
s=float(s)
ValueError: could not convert string to float: 'AskPython'
由此，我们可以推断出float()方法只能将字符串类型的值转换为浮点数。如果字符串中包含任何字符，抛出一个值错误。
2.使用带有特殊参数的 float()
如果我们将 nothing 、 infinity 或 NaN (不是数字)作为参数传递给float()方法，会发生什么？它能把它们转换成浮点数吗？让我们看看下面的例子，
val1=float('inf')
val2=float('NaN')
val=float()
print("Default value of float()= ",val,";Type-",type(val))
print("float('inf') = ",val1,";Type-",type(val))
print("float('NaN')= ",val2,";Type-",type(val))
输出:
Special Parameters In Float
所以，在上面的例子中，我们可以看到，
- 不向
float()方法传递任何东西会给我们它的默认值，实际上是‘0.0’， - 对于 inf 或 infinity，返回值也是
inf，但是类型转换为 float ， - 同样，对于 NaN ，该函数返回类型为 float 的
nan。
结论
因此，在本教程中，我们学习了 Python 中的 float()方法，它是如何使用的，以及它的功能是什么。对于任何进一步的问题，随时欢迎评论。
参考
- https://docs.python.org/2/tutorial/floatingpoint.html
- https://www.journaldev.com/15178/python-float
- https://docs.python.org/2/library/stdtypes.html
python//operator–基于楼层的部门
原文：https://www.askpython.com/python/python-floor-based-division
Python 3 中的//操作符用于执行基于楼层的划分。
这意味着a // b首先将 a 除以 b 得到整数商，同时丢弃余数。这意味着a//b的结果总是一个整数。
Python //运算符示例
这里有几个例子来说明这一点:
>>> 2 // 3
0
>>> 1.3 // 2
0.0
>>> 1.3 // 1.0
1.0
>>> 3.4 // 1.1
3.0
>>> 3.4 // 1.2
2.0
>>> -1//2
-1
>>> -6 // 2
-3
>>> -6 // -3
2
这显示了//操作符如何通过只考虑除法的整数部分来执行基于底数的除法，即使对于浮点数也是如此。
对不支持的类型(比如列表和字符串)执行这个操作，将会产生一个TypeError，对于任何其他算术运算符来说都是一样的。
重载//运算符
//默认是指__floordiv__()运算符，所以你可以通过重写这个方法(operator.__floordiv__(a, b)来执行运算符重载
下面是一个重载具有相同长度的整数列表的//方法的例子，通过对每对元素执行单独的基于下限的除法。
所以两个整数列表[3, 4, 5]和[2, 2, 1]会给出[3//2, 4//2, 5//1]，简单来说就是列表[1, 2, 5]。
import operator
class MyClass():
def __init__(self, a):
self.a = a
def __floordiv__(self, b):
if isinstance(self.a, list) and isinstance(b.a, list) and len(self.a) == len(b.a):
result = []
# Overload // operator for Integer lists
for i, j in zip(self.a, b.a):
result.append(i // j)
return result
else:
# Perform Default // operation otherwise
return operator.__floordiv__(self.a, b.a)
m = MyClass([3, 4, 5])
n = MyClass([2, 2, 1])
print(m // n)
输出
[1, 2, 5]
结论
在本文中，我们学习了//地板除法运算符。我们还学习了通过实现operator.__floordiv__(a, b)来执行操作符重载。
参考
Python //运算符–Python 中的楼层划分
原文：https://www.askpython.com/python/python-floor-division-double-slash-operator
Python //运算符也叫地板除法运算符。它是 Python 中的算术运算符之一。它适用于 Python 中的数字。
Python //运算符
它类似于除法运算符，只是它返回除法运算的整数部分。所以，如果除法的输出是 3.999，这将返回 3。所以才叫楼分算子。
我们来看一些 Python 中的楼层划分的例子。
1.整数的地板除法
>>> 10//3
3
>>> 10//2
5
2.用彩车分隔地板
>>> 10.0//3
3.0
>>> 10//2.0
5.0
>>> 11.99//3.00
3.0
3.复数的楼层划分
复数不支持地板除法。如果我们尝试对复数使用//运算符，它将抛出 TypeError:不能对复数取整。
>>> x = 10 + 3j
>>> type(x)
<class 'complex'>
>>> x // 3
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: can't take floor of complex number.
>>>
重载//运算符
我们知道 Python 支持运算符重载。如果要支持对象的//操作符，需要重写 floordiv(self，other)方法。让我们看一个重载地板除法运算符的简单例子。
# Floor Division Operator overloading example
class Data:
id = 0
def __init__(self, i):
self.id = i
def __floordiv__(self, other):
print("overloading // operator")
return self.id // other.id
d1 = Data(10)
d2 = Data(3)
print(d1 // d2)
输出:
摘要
- Python //运算符处理数字–int 和 float。
- 基数除法运算符返回除法运算的整数部分。
- 如果被除数和除数都是整数，则地板除法也将返回 int。
- 如果被除数和除数中有一个是 float，则 floor 除法将返回一个 float。
- 我们不能对复数使用//运算符。
下一步是什么？
参考
Python for 循环
Python for 循环用于迭代 iterable。在 Python 中，任何逐个返回其元素以在 for 循环中迭代的对象都称为 Iterable。一些常见的可迭代的例子有列表、元组和字符串。for 循环是 python 编程的核心构建块。
在 Python 中实现 for 循环
Python 中的 for 循环是使用 保留关键字–for实现的。针对 iterable 的每个元素执行 for 循环代码块。
退出循环
我们可以使用 break 语句来退出 for 循环。这将终止 for 循环的执行，并且不会对 iterable 的剩余元素执行代码块。当我们找到了我们要找的东西，并且不需要处理 iterable 的其他元素时，这是很有用的。
跳过 for 循环的当前执行
我们可以使用 continue 语句来跳过 for 循环的当前执行。当我们只想对 iterable 的某些特定元素执行代码时，这很有用。
Python for loop 是迭代器？
Python 中的 for 循环不同于其他编程语言，因为它的行为更像一个迭代器。我们可以使用 for 循环来迭代元组、列表、集合，或者字符串。所有这些对象在 Python 中都是一个序列。我们可以让嵌套 for 循环来遍历一系列序列。
Python for 循环语法
for 循环语法非常简单。它使用“in”运算符 来迭代 iterable 中的元素。
for element in sequence:
# for statement code block
for 循环流程图
For Loop Flow Diagram
Python for 循环示例
让我们看一些带有不同类型可重复项的 for 循环的例子。
1.线
Python 字符串是一个字符序列。让我们看一个简单的程序来打印字符串中的索引和字符。
message = "Hello"
count = 0
for character in message:
print(f'Index:{count}, Character:{character}')
count += 1
输出:
2.元组
假设我们有一组字符串。我们想把所有的元素都转换成小写。我们可以为此编写一个实用程序 函数 ，并使用 for 循环迭代元组元素。
def to_lower_case(my_tuple):
temp_list = []
for item in my_tuple:
temp_list.append(str(item).lower())
return tuple(temp_list)
fruits = ("Apple", "Orange", "BANANA")
fruits_new = to_lower_case(fruits)
print(fruits_new)
输出 : ('apple', 'orange', 'banana')
注意:我们使用一个列表在 for 循环中添加元素，因为 Tuple 在 Python 中是不可变的。
3.目录
让我们来看一个例子，遍历整数列表并打印它是偶数还是奇数。
list_ints = [1, 2, 3, 4, 5]
for i in list_ints:
if i % 2 == 0:
print(f'{i} is even.')
else:
print(f'{i} is odd.')
输出:
4.一组
下面是一个使用 for 循环打印集合元素的简单示例。
set_cities = set()
set_cities.add("New York")
set_cities.add("New Delhi")
set_cities.add("Bangalore")
set_cities.add("London")
set_cities.add("Bangalore") # duplicate item, will be removed from set
for city in set_cities:
print(city)
输出:
注意 : Set 在 Python 中是一个无序序列。所以每次执行程序时，输出可能会有所不同。
5.词典
Python 字典不是序列。所以我们不能直接迭代它的元素。然而，它有一个方法items(),返回一个类似集合的元素序列。我们可以使用这个方法迭代字典元素。
my_dict = {"1": "Apple", "2": "Kiwi", "3": "Orange"}
for k, v in my_dict.items():
print(f'Key={k}, Value={v}')
输出:
使用 break 语句退出 for 循环
我们可以使用 break 语句在不迭代所有元素的情况下退出 for 循环。
假设我们有一个要处理的消息列表。如果我们遇到“退出”消息，那么处理应该停止。我们可以使用 break 语句来实现这个场景。
messages = ["Hi", "Hello", "Exit", "Adios", "Hola"]
for msg in messages:
if msg == "Exit":
break;
print(f'Processing {msg}')
输出:
带 continue 语句的 Python for 循环
有时我们想跳过序列中某些元素的处理。为此，我们可以使用一个 continue 语句。
ints = (1, 2, 3, 4, 5, 6)
# process only odd numbers
for i in ints:
if i % 2 == 0:
continue
print(f'Processing {i}')
输出:
带 range()函数的 Python for 循环
Python range()函数生成一个数字序列。我们可以使用 for 循环来执行代码块特定的次数。
让我们看看如何使用 range()函数和 for 循环来执行一个代码 5 次。
for i in range(5):
print("Processing for loop:", i)
输出:
带 else 语句的 Python for 循环
我们可以在 for 循环中使用 else 语句，以便在 for 循环结束时执行一些代码。
当序列处理成功完成时，它在记录或发送通知方面很有用。
databases = ("MySQL", "Oracle", "PostgreSQL", "SQL Server")
for db in databases:
print(f'Processing scripts for {db}')
else:
print("All the databases scripts executed successfully.")
输出:
else with for Loop in Python
注意:如果 for 循环产生任何错误，那么 else 块代码不会被执行。
databases = ("MySQL", "Oracle", "PostgreSQL", "SQL Server")
for db in databases:
print(f'Processing scripts for {db}')
raise TypeError
else:
print("All the databases scripts executed successfully.")
输出:
Processing scripts for MySQL
Traceback (most recent call last):
File "/Users/pankaj/Documents/PycharmProjects/PythonTutorialPro/hello-world/for-loop.py", line 65, in <module>
raise TypeError
TypeError
如果使用 break 语句终止 for 循环，则不执行 else 块。
Python 中嵌套的 for 循环
当一个循环出现在另一个循环中时，它被称为嵌套循环。Python for 循环可以嵌套。这在迭代嵌套的可迭代对象时很有用，例如，一个列表的列表。
list_tuples = [("Apple", "Banana"), ("Orange", "Kiwi", "Strawberry")]
for t_fruits in list_tuples:
for fruit in t_fruits:
print(fruit)
输出:
Nested for Loop In Python
使用 for 循环和 reversed()函数进行反向迭代
for 循环按照出现的顺序遍历序列元素。有时我们必须以相反的顺序遍历元素。我们可以在 for 循环中使用 reversed()函数来实现这一点。
numbers = (1, 2, 3, 4, 5)
for n in reversed(numbers):
print(n)
输出:
5
4
3
2
1
for 循环变量泄漏到全局范围
通常，在本地命名空间内部定义的变量在外部是不可访问的。一旦代码块完成了它的执行，本地命名空间就和它的所有变量一起被销毁。但是，对于 for 循环来说却不是这样。
for 循环中定义的变量在全局范围内。我们甚至可以在 for 循环中访问和更改全局名称空间变量值。让我们用一个简单的代码片段来检查这种行为。
global_var = "global"
for c in range(1,3):
x = 10
global_var = "for variable"
print(c) # variable is defined in the for loop
print(x) # variable is defined in the for loop
print(global_var) # global variable
Python for Loop Global Variables
推荐 : Python 命名空间
摘要
Python for 循环作为迭代器工作。我们可以用它来迭代可迭代的元素。我们可以嵌套 for 循环来迭代一个可迭代对象。还有一些额外的功能——range()和 reversed()使它更加强大。
下一步是什么？
参考资料:
python fork()–如何使用 fork()方法创建子流程？
在本文中，我们将讨论 Python fork()方法，该方法允许我们使用调用它的进程来创建子进程。让我们看看
什么是系统调用？
一个 系统调用 用于访问内核模式。它是一种程序与操作系统交互并请求其服务来执行特定任务的方式。
因此，所有系统调用都在内核(特权)模式下执行，当执行完成时，控制权返回到用户模式。有时系统调用也被简称为 syscall 。
在现代计算机系统中，一般有两种操作模式——用户模式和内核模式。
所有的用户程序和进程都运行在用户模式，它们不能直接访问内核模式。这样做是为了保护操作系统不被任何用户程序修改或更改。
任何用户程序如果需要执行特权工作，都需要操作系统的支持，只有通过 系统调用 才能获得。它是通过 API(应用程序接口)向用户程序和进程提供操作系统的各种服务的系统调用。
Python fork()是什么？
有多个系统调用来管理操作系统提供的不同类型的服务。此外，对于不同的操作系统，这些也是不同的。
系统调用大致分为五大类:
- 文件相关的系统调用
- 设备相关系统调用
- 过程相关系统调用
- 信息相关系统调用
- 与通信相关的系统调用
所以，Python fork() 就是一个流程相关或流程控制系统调用的例子。这是一种用于创建调用它的流程的子流程的方法，就像原始(调用)流程的克隆一样。使用fork()语句进行系统调用的进程被称为父进程。
导入操作系统模块
为了在 Python 中使用和实现fork()系统调用，我们需要 Python 的模块。Python 中的这个 os 模块允许我们使用各种依赖于操作系统的功能。它允许用户程序访问运行 Python 的操作系统功能。
我们不需要安装os模块，因为它属于 Python 的标准实用程序模块，并且在我们的系统中安装 Python 时就已经安装了。
它被导入到程序中，如下所示:
import os
Python fork()的工作原理
以下是fork()方法/语句的关键属性:
- 当它在任何程序中被调用时，它不带参数。
- 如果成功创建了子进程，那么父进程和子进程都将执行下一条语句/指令，然后执行
fork()语句。 - 子进程数=2^N–1；其中 N =主程序内部使用的
fork()语句的数量。
在执行 Python fork()语句时，它返回三种类型的整数值:
- 如果子进程创建成功，零 ( 0 )返回给子进程。
- 如果子进程创建成功，则向父进程返回一个正 ( +ve )值。这个正值通常是 PID ，即新创建的子进程的^(******) 进程 ID 。
- 如果由于某种原因在创建子进程时出现错误，则向父进程返回一个负的 ( -ve )值。
进程 ID 通常被称为 PID 是与计算机系统中存在的每个进程相关联的唯一标识符。可以使用另一个系统调用 getpid() 来访问任何进程的进程 ID，这是信息相关系统调用的一个示例。getpid()语句返回调用它的进程的进程 ID。
它在程序中的调用如下:
os.fork()
用 Python 中的 fork()方法创建子进程
例 1:
# Importing os module
import os
# Creating child processes using fork() method
os.fork()
os.fork()
# This will be executed by both parent & child processes
print("AskPython")
输出:
上面的 python 程序产生了正确的输出，因为程序中使用了两个fork()语句。因此，print()语句被三个子进程执行了四次(3 + 1)三次( 2² -1 = 3 )，被父进程执行了一次。
例 2:
# Importing os module
import os
# Creating a child process using fork() method
val = os.fork()
# Testing the values returned by fork() method
if val == 0:
pid = os.getpid()
print(f"Hi I am Child Process and my PID is {pid}.")
elif val > 0:
pid = os.getpid()
print(f"Hi I am Parent Process and my PID is {pid} and PID {val} is my Child Process.")
else:
print("Sorry!! Child Process creation has failed...")
输出:
上面的 python 程序产生了正确的输出，并清楚地展示了由fork()语句返回的值。
结论
在本教程中，我们学习了什么是系统调用，什么是 Python fork()方法，它的属性，以及如何使用 Python 中的fork()方法创建子进程。
注意: fork()方法/系统调用仅适用于 Linux/Unix 操作系统。如果您尝试在 Windows 系统上运行任何调用fork()方法的 Python 程序，将会产生以下错误:
Python format()函数
原文：https://www.askpython.com/python/string/python-format-function
你好！在本文中，我们将关注使用 Python format()函数格式化字符串和值。
Python format()函数入门
Python format()函数是一个内置的字符串函数，用于字符串的格式化。
Python format() function根据位置格式化字符串。因此，用户可以使用 format()函数改变字符串在输出中的位置。
语法:
"{}".format(value)
- 这些花括号充当了一个格式化程序，当函数被调用时，它们被替换为放置在定义位置的字符串。
value:该参数可以是字符串，也可以是数字，甚至可以是浮点整数。它表示输出中要由格式化程序替换的值。
举例:
s1 = 'Python'
s2 = 'with'
s4 = 'JournalDev'
s3 = "{} {} {}".format(s1, s2, s4)
print(s3)
输出:
Python with JournalDev
使用 Python 格式()进行索引格式化
format()函数还用于在用户定义的位置格式化字符串，也就是说，我们可以通过指定花括号内的索引值来更改要放入输出中的字符串或值的位置。
举例:
s1 = 'Python'
s2 = 'with'
s4 = 'Data Science'
res = "{2} {1} {0}".format(s1, s2, s4)
print(res)
在上面的代码片段中，format(s1，s2，s4)在内部将它们的索引值指定为 0，1，2，以此类推，指定给传递给函数的值。
也就是说，s1 被分配给索引 0，s2 被分配给索引 1，s4 被分配给索引 2。
因此，通过在{}中传递字符串的索引值，我们可以通过索引值改变字符串的位置。
输出:
Data Science with Python
向 format()函数中的参数传递值
使用 Python format()函数，我们可以给我们希望在函数本身的参数列表中显示的变量赋值。
语法:
"{var1}".format(var1='value')
举例:
res = "{s4} {s2} {s1}".format(s1 = 'Python',s2 = 'with',s4 = 'Data Science')
print(res)
输出:
Data Science with Python
用 Python format()函数填充格式化字符串
还可以使用 format()函数根据对齐方式和填充方式对字符串进行格式化。
语法:
#left padding
"{:>number}".format(value)
#right padding
"{:<number}".format(value)
#centre padding
"{:^number}".format(value)
通过传递一个特定的数字，它充当字符串周围要填充的字符数。
举例:
Padding using format() function
将 dict 作为参数传递给 Python format()函数
Python 字典也可以传递给 format()函数作为要格式化的值。
语法:
"{key}".format(**dict)
分别将键传递给 {} 和使用 format()函数用键的值替换键。
因为我们将 dict 键作为参数传递，为了用它们的值替换键，我们需要解包字典。于是，Python "**" operator被用来解包字典。
举例:
dict1 = {"Python":"A","Java":"B","Cpp":"D"}
res = "{Python} {Cpp}".format(**dict1)
print(res)
输出:
A D
将复数作为参数传递给 format()函数
Python format()函数可用于从一个复数中访问实数和虚数值。
语法:
"{0.real},{0.imag}".format(complex_number)
举例:
num = 20-3j
res = "Real-part:{0.real}, Imaginary-part:{0.imag}".format(num)
print(res)
输出:
Real-part:20.0, Imaginary-part:-3.0
Python format()函数使用逗号作为分隔符值
Python format()函数使我们能够使用"," as a separator来分隔数值。
语法:
"{:,}".format(number)
分隔符，即“，”被添加在三位数字之后，其方式适用于数字系统中的千位。
举例:
num = 10000000000
res = "{:,}".format(num)
print(res)
输出:
10,000,000,000
使用 format()函数格式化数字
Python format()函数也具有格式化数字的特性。
除了格式化数值，format()函数还可以用来根据不同的数制来表示数值，如二进制、八进制、十六进制等。
语法:
#Hexadecimal representation
"{0:x}".format(value)
#Octal representation
"{0:o}".format(value)
#Decimal representation
"{0:d}".format(value)
#Binary representation
"{0:b}".format(value)
例 1:
num = 10
binary = "{0:b}".format(num)
print("Binary representation:", binary)
hexadecimal = "{0:x}".format(num)
print("Hexadecimal representation:", hexadecimal)
octal = "{0:o}".format(num)
print("Octal Decimal representation:", octal)
decimal = "{0:d}".format(num)
print("Decimal representation:", decimal)
输出:
Binary representation: 1010
Hexadecimal representation: a
Octal Decimal representation: 12
Decimal representation: 10
结论
因此，在本文中，我们研究了 Python format()函数的工作方式，以及该函数在字符串、数字等方面的各种用法。
要了解更多关于字符串格式化的信息，我强烈建议读者学习一下 Python f-string 。
参考
- Python format()函数— JournalDev
Python 分数模块
原文：https://www.askpython.com/python-modules/python-fractions-module
Python 分数模块使用户能够以高效的方式管理分数相关的计算。这个模块使我们能够从整数、浮点数、小数和字符串中创建分数。
这个分数模块支持有理数算术运算。
分数基础模块
1。导入分数模块:
from fractions import Fraction
2。实例化分数类:
有许多方法可以实例化 fraction 类。以下是实例化 fraction 类的一些方法:
- 传递分子和分母
- 用 float 实例化
- 用小数实例化
- 用字符串实例化
示例:通过传递分子和分母进行实例化
from fractions import Fraction
Fraction(1, 2)
示例:用 float 实例化
from fractions import Fraction
Fraction(2.5)
举例:用小数实例化
from fractions import Fraction
from decimal import Decimal
Fraction(Decimal('1.1'))
示例:实例化字符串
from fractions import Fraction
Fraction('9/16')
创建分数
import fractions
for num, decimal in [(1, 2), (3, 6), (30, 7)]:
result = fractions.Fraction(num, decimal)
print('{}/{} = {}'.format(num, decimal, result))
输出:
1/2 = 1/2
3/6 = 1/2
30/7 = 30/7
对分数执行算术运算
下面的例子解释了分数的不同数学运算。
from fractions import Fraction
print(Fraction(100, 10) + Fraction(25, 5))
print(Fraction(18, 5) / Fraction(18, 10))
print(Fraction(18, 15) * Fraction(16, 25))
print(Fraction(17, 25) * Fraction(15, 25))
print(Fraction(12, 5) ** Fraction(12, 11))
输出:
Output-Arithmetic Operations On Fractions
分数实例
分数实例是从一对整数、有理数或字符串构建的分数。分数是可变的和不可变的，所以它们的值一旦被创建就不能被改变。
类分数。分数(分子=0，分母=1) : 它要求分子和分母都是数。一个分数值=(分子/分母)作为输出返回，缺省值为 0。如果分母= 0，则产生零除法误差。
举例:
from fractions import Fraction
print(Fraction(10, 35))
print(Fraction(10, 13))
print(Fraction()) # default value
输出:
2/7
10/13
0
将数学和分数结合起来
数学模块的功能可以与分数表示混合使用。下面的例子描述了一个这样的表示。
import math
from fractions import Fraction
print("Square root: {}".format(math.sqrt(Fraction(21, 4))))
print("Floored to: {}".format(math.floor(Fraction(4100, 1100))))
print("Sined Fraction: {}".format(Fraction(math.sin(math.pi/2))))
输出:
Square root: 2.29128784747792
Floored to: 3
Sined Fraction: 1
四舍五入分数
有可能根据用户想要的分母的位数来舍入分数。
举例:
import fractions
result = fractions.Fraction('21/8')
print('Rounded without limit : {}'.format(round(result)))
print('Rounded to 2 digits : {}'.format(round(result, 2)))
输出:
Rounded without limit : 3
Rounded to 2 digits : 131/50
结论
我们已经理解并实现了 Python 中分数模块的功能。
参考
- Python 分数
- Python 分数模块文档
2021 年深度学习的 5 个 Python 框架
原文：https://www.askpython.com/python/python-frameworks-for-deep-learning
深度学习是目前最热门的行业技能之一。深度学习现在正被用于许多领域，以解决以前被认为无法解决的问题，例如:自动驾驶汽车、人脸识别/增强等。
从头开始编写深度学习模型是一项乏味且令人困惑的任务。这需要大量的专业知识和时间。所以我们使用某些框架，这些框架为我们提供了创建模型的基线。
深度学习的 Python 框架
站在 2021 年，它们是 Python 深度学习的很多框架。这些框架在抽象、使用和可移植性方面是不同的。从这个列表中选择您需要的框架可能有点困难。因此，这里列出了 2021 年你可以考虑学习的前 5 个框架/库。
1. TensorFlow
TensorFlow 是 2021 年最流行的深度学习框架。TensorFlow 是由谷歌大脑团队在 2015 年开源之前开发的。TensorFlow 的当前版本将 Keras 作为一个高级 API，它抽象出大量底层代码，使创建和训练我们的模型变得更容易、更快。
TensorFlow 可与各种计算设备配合使用——CPU、GPU(包括 NVIDIA 和 AMD)，甚至 TPU。对于低计算边缘设备，TensorFlow Lite 可以帮您节省时间。
TensorFlow 广泛支持其他语言，如 C++、JavaScript、Swift 等。如果您正在考虑生产，此功能使 TensorFlow 成为首选。一旦您训练并保存了一个模型，这个模型就可以在您选择的语言中使用，从而缓解多语言依赖性的问题。
2. PyTorch
由脸书开发的 PyTorch 是流行度排名第二的框架。顾名思义就是 Python 版的 Torch(C++库)。PyTorch 与 Python 和 Numpy 无缝集成。PyTorch 在称为 Tensors 的多维数组上工作，它的 API 与 Numpy 非常相似。
PyTorch 提供了一个强大而灵活的 API 来处理 CPU 和 GPU。PyTorch 对 GPU 的出色支持使得分布式训练更加优化可行。PyTorch 非常具有可扩展性。由于这种可扩展性，许多其他框架和工具都建立在 PyTorch 之上，其中之一就是 HuggingFace TransFormers。
在 PyTorch 中，您必须定义自己的训练循环，手动更新权重。这有助于您获得对模型的更多控制。这是研究者倾向于 PyTorch 的主要原因。但是这种方法经常导致样板代码，这对软件部署是不利的。
3.法斯泰
FastAi 是杰瑞米·霍华德和雷切尔·托马斯创建的另一个深度学习库。它旨在为 DL 实践者提供高级组件，可以快速轻松地提供标准深度学习领域的最新成果，并为研究人员提供低级组件，可以混合和匹配以构建新方法。
它的目标是在不牺牲易用性、灵活性或性能的情况下做到这两点。FastAI 从两个世界——py torch 和 Keras 取长补短。FastAI 有定义良好的抽象层——高层、中层和低层。底层基于 PyTorch API。
FastAI 简化了生产过程，避免了样板代码和简单的语法，便于开发。
4.MxNet
Apache MxNet 可能是这个列表中最令人惊讶的标题之一。MxNet 由一个非常小的社区支持，不像这里列出的大多数其他框架那样受欢迎，但是它做了它承诺要做的事情。
MxNet 试图解决学习不同语言来进行机器学习的问题。MxNet 支持一系列语言，如 Scala、Python、R、Clojure、C++等。
MxNet API 与 PyTorch 非常相似。所以两者之间过渡不会很难。除了 PyTorch API 的好处之外，它还带来了部署方面的好处。它速度快，可伸缩，并且比其他框架占用更少的内存。
5. PyTorch Lightning
PyTorch 照明是一个相对较新的框架。Lighting 只是原始 PyTorch 库的一个包装。它增加了一个抽象的薄层，减少了样板代码的数量，同时又不影响 PyTorch 的功能和美观。
Lightning 使剖析、度量记录和可视化以及分布式培训变得更加容易。此外，从 GPU 到 TPU 的过渡不需要额外的代码行。所以它让 PyTorch 更接近我们所说的可部署。
结论
这就把我们带到了本文的结尾。没有所谓的“最佳”框架。每个框架都有一些比其他框架更好的特性。因此，如果您正在寻找一个框架，首先，您可以选择其中的任何一个。随着你的深入，你会明白什么样的框架最适合你或你的工作，并相应地改变它。
python frozenset()-您需要知道的一切
原文：https://www.askpython.com/python/built-in-methods/python-frozenset
你好。所以今天我们在这里讨论Python 的 frozenset()方法。
所以在我们进入这个方法之前，让我们知道什么是 frozenset 。
什么是冷冻人？
frozenset是一个无序的、无索引的、不可变的元素集合。它提供了一个集在 Python 中提供的所有功能，唯一的不同是一个事实，即一个 frozenset 是不可变的，即在它被创建之后不能被改变。
因此，简而言之，冻结集合是不可变集合。
Python frozenset()方法
Python frozenset()方法返回一个新的 frozenset 对象，其元素取自传递的iterable。如果没有指定iterable，则返回一个新的空集。
注意:元素必须是 hashable 。
fz = frozenset([iterable])
当没有指定任何内容时，frozenset()方法将一个空的 frozenset 对象返回给fz。
为了更好地理解该方法的工作原理，让我们看一个例子。
# List Initialisation
list1 = [0, 1, 2, 3, 4, 5, 6]
fz = frozenset(list1)
print(fz)
fz = frozenset() # empty frozenset
print(fz)
print("Type of fz: ", type(fz))
输出:
frozenset({0, 1, 2, 3, 4, 5, 6})
frozenset()
Type of fz: <class 'frozenset'>
这里，首先我们初始化了一个列表(list1)，然后将它作为iterable传递给frozenset()方法。作为回报，我们得到一个 frozenset 对象( fz )和列表中的元素。当没有传递任何东西时， fz 现在是一个空的 frozenset 对象。
冷冻集初始化
在下面给出的例子中，我们已经使用 Python frozenset()方法初始化了一个 frozenset，方法是传递不同的 iterables，如列表、元组、集合和字典。
# Initialisation
list1 = [1, 2, 3, 4, 5]
fz = frozenset(list1) # from list object
print(fz)
fz = frozenset([1, 2, 3, 4, 5]) # from list
print(fz)
fz = frozenset({5: 'a', 4: 'B', 3: 'C', 2: 'D', 1: 'E', 0: '0'})# from dict
print(fz)
fz = frozenset({'Python', 'Java', 'C', 'C++', 'Kotlin', 'R'})# from set
print(fz)
fz = frozenset((17, 55, 26, 90, 75, 34)) # from tuple
print(fz)
输出:
frozenset({1, 2, 3, 4, 5})
frozenset({1, 2, 3, 4, 5})
frozenset({0, 1, 2, 3, 4, 5})
frozenset({'Java', 'Kotlin', 'Python', 'C', 'R', 'C++'})
frozenset({34, 90, 75, 17, 55, 26})
对于每种情况，我们都得到一个 frozenset 对象，其中包含相应的 iterable 元素。但是请仔细注意，在字典的情况下，只考虑键。
Python frozenset 上的操作
我们可以使用 dir()方法获得与 frozenset 对象相关的所有方法的名称。
fo = frozenset([1, 2, 3, 4, 5])
print(dir(fo))
输出:
['__and__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'copy', 'difference', 'intersection', 'isdisjoint', 'issubset', 'issuperset', 'symmetric_difference', 'union']
从上面的输出可以看出，各种函数，如 add()、remove()、update()、pop()等。(用于改变/更新元素，可用于组)缺失。这也是因为一个冻结的集合是不可变的。
现在让我们看看冻结集合的可用方法，使用它们我们可以执行各种操作。
fs = frozenset([1, 12, 23, 45, 67, 89, 100])
print("Given Frozenset =", fs)
fs_len = len(fs)
print("Length of Frozenset =", fs_len)
print("23 in fs? ", 23 in fs)
print("23 not in fs? ", 23 not in fs)
print("Sets are disjoint? ", fs.isdisjoint(frozenset([10, 5])))
print("Set is Subset? ", fs.issubset(set([1, 2, 3, 4, 12, 23, 45, 67, 89, 100])))
print("fs is superset? ", fs.issuperset(frozenset({1, 100})))
print("Union of sets: ", fs.union(frozenset([-1, -12])))
print("Intersection: ", fs.intersection(set([1, 10, 100])))
print("Difference: ", fs.difference(frozenset([1, 10, 100])))
print("Symmetric difference: ", fs.symmetric_difference(frozenset([1, 10, 100])))
fs_copy = fs.copy()
print("Copy of fs: ", fs_copy)
输出:
Given Frozenset = frozenset({1, 67, 100, 12, 45, 23, 89})
Length of Frozenset = 7
23 in fs? True
23 not in fs? False
Sets are disjoint? True
Set is Subset? True
fs is superset? True
Union of sets: frozenset({1, 67, 100, 12, 45, -12, 23, 89, -1})
Intersection: frozenset({1, 100})
Difference: frozenset({67, 12, 45, 23, 89})
Symmetric difference: frozenset({67, 10, 12, 45, 23, 89})
Copy of fs: frozenset({1, 67, 100, 12, 45, 23, 89})
这里，
- len(s) :返回 frozenset s 的长度，
- s 中的 x:检查 x 是否存在于 frozenset s 中，
- x 不在 s 中:如果 x 不是 frozenset s 的元素则返回 True，否则返回 False，
- isdisjoint(other) :如果集合中没有与
other共有的元素，则返回 True。集合是不相交的当且仅当它们的交集是空集。 - issubset(other) :检查 other 是否包含 frozenset 的元素，
- issuperset(other) :检查 frozenset 是否包含
other的元素， - union(*others) :返回一个 frozenset，包含所提供的其他集合的并集，
- 交集(*others) :返回一个 frozenset，传递 fs 和所有其他元素共有的元素，
- difference(*others) :返回一个新的 frozenset，该 frozenset(fs)中的元素不在其他 frozenset 中，
- symmetric _ difference(other):返回一个新的 frozenset，其元素在 fs 或 other 中，但不在两者中。
总结
今天到此为止。希望你对 Python frozenset()方法有一个清晰的理解。
要了解更多信息，我们建议浏览参考资料部分提供的链接。
任何进一步的问题，请在下面随意评论。
参考
- Python frozenset–文档，
- Python 中 tuples 和 frozensets 的区别—堆栈溢出问题，
- Set 和 frozenset 在实现上的差异–堆栈溢出问题。
Python 函数
Python 中的函数是带有名称的代码块。我们可以通过名字调用一个函数，函数块中的代码将被执行。我们不能用 保留关键字 作为函数名。函数名必须遵循 Python 标识符 的定义规则。
功能参数
我们可以将一些数据传递给函数进行操作，它们被称为函数参数。函数参数由逗号分隔。一个函数中可以有任意数量的参数。
从函数返回数据
函数可以向调用程序返回数据。与其他流行的编程语言不同，Python 函数定义不指定返回类型。
使用 def 关键字在 Python 中定义函数
我们可以使用 def 关键字在 Python 中定义一个函数。让我们看几个 Python 中函数的例子。
def hello():
print('Hello World')
def add(x, y):
print(f'arguments are {x} and {y}')
return x + y
基于上面的例子，我们可以这样定义一个函数结构。
def function_name(arguments):
# code statements
Python Function Structure
在 Python 中调用函数
我们可以通过函数的名字来调用它。如果函数接受参数，我们必须在调用函数时传递它们。
hello()
sum = add(10, 5)
print(f'sum is {sum}')
我们正在调用自己定义的 hello()和 add()函数。我们还调用了 print()函数，它是 Python 中的内置函数之一。
Python 函数类型
Python 中有两种类型的函数。
Python 函数默认参数
Python 允许函数参数使用默认值。如果调用者没有传递参数，则使用默认值。
def hello(year=2019):
print(f'Hello World {year}')
hello(2020) # function parameter is passed
hello() # function parameter is not passed, so default value will be used
输出:
Hello World 2020
Hello World 2019
函数中的多个 return 语句
一个函数可以有多个 return 语句。但是，当到达其中一个 return 语句时，函数执行终止，值返回给调用者。
def odd_even_checker(i):
if i % 2 == 0:
return 'even'
else:
return 'odd'
print(odd_even_checker(20))
print(odd_even_checker(15))
使用 yield 关键字逐个返回多个值
Python 函数可以逐个返回多个值。它是使用 yield 关键字实现的。当您希望函数返回大量值并处理它们时，这很有用。我们可以使用 yield 语句将返回值分成多个块。这种功能也被称为发生器功能。
def return_odd_ints(i):
x = 1
while x <= i:
yield x
x += 2
output = return_odd_ints(10)
for out in output:
print(out)
输出:
1
3
5
7
9
Python 函数中的变量参数
Python 允许在函数定义中使用三种类型的参数。
- 形式参数:到目前为止我们在例子中看到的形式参数。
- 可变数量的非关键字参数:例如 def add(*args)
- 可变数量的关键字参数或命名参数:例如 def add(**kwargs)
Python 中变量参数的一些要点如下:
- 参数顺序应该是形式参数，*args 和**kwargs。
- 使用 args 和 kwargs 这样的变量参数名称并不是强制性的。然而，最好的做法是使用它们来提高代码的可读性。
- args 类型是元组。所以我们可以传递一个元组来映射*args 变量。
- kwargs 的类型是 dict 。所以我们可以传递一个字典来映射**kwargs 变量。
下面是一个在函数中使用变量参数的简单例子。
def add(x, y, *args, **kwargs):
sum = x + y
for a in args:
sum += a
for k, v in kwargs.items():
sum += v
return sum
total = add(1, 2, *(3, 4), **{"k1": 5, "k2": 6})
print(total) # 21
Python 中的递归函数
当一个函数调用它自己时，它被称为递归函数。这种情况在编程中被称为递归。
使用递归时应该非常小心，因为函数可能永远不会终止，并进入无限循环。下面是一个使用递归打印斐波那契数列的简单例子。
def fibonacci_numbers_at_index(count):
if count <= 1:
return count
else:
return fibonacci_numbers_at_index(count - 1) + fibonacci_numbers_at_index(count - 2)
count = 5
i = 1
while i <= count:
print(fibonacci_numbers_at_index(i))
i += 1
了解递归是很好的，但是大多数时候你在编程中并不需要它。您可以使用 for-loop 或 while-loop 执行相同的操作。
函数的数据类型
Python 函数是“函数”类的实例。我们可以使用 type()函数来检查这一点。
def foo():
pass
print(type(foo))
输出 : <类‘功能’>
Python 中的函数与方法
- Python 函数是定义它的 python 脚本文件的一部分，而方法是在类定义中定义的。
- 如果函数在同一个模块中，我们可以直接调用它。如果函数是在不同的模块中定义的，我们可以导入模块，然后直接调用函数。我们需要一个类或该类的一个对象来调用这些方法。
- Python 函数可以访问所有全局变量，而 Python 类方法可以访问全局变量以及类属性和函数。
- Python 函数的数据类型是“函数”，而 Python 方法的数据类型是“方法”。
让我们看一个 Python 中函数和方法的简单例子。
class Data:
def foo(self):
print('foo method')
def foo():
print('foo function')
# calling a function
foo()
# calling a method
d = Data()
d.foo()
# checking data types
print(type(foo))
print(type(d.foo))
输出:
foo function
foo method
<class 'function'>
<class 'method'>
Python 函数的优势
- 代码可重用性，因为我们可以多次调用同一个函数
- 模块化代码，因为我们可以为不同的任务定义不同的功能
- 提高代码的可维护性
- 抽象，因为调用者不需要知道函数的实现
Python 中的匿名函数
匿名函数没有名字。我们可以使用 lambda 关键字在 Python 中定义一个匿名函数。
def square(x):
return x * x
f_square = lambda x: x * x
print(square(10)) # 100
print(f_square(10)) # 100
结论
函数是编程语言的重要组成部分。使用 def 关键字定义 Python 函数。在一个 Python 函数中，我们可以有可变数量的参数。Python 也支持匿名函数。它们可以返回单个值，也可以一个接一个地产生多个值。
下一步是什么？
资源
使用 Python 地理编码模块反向查找邮政编码
原文：https://www.askpython.com/python-modules/python-geocode-module
在本文中，我们将使用地理编码模块对不同的邮政编码进行反向查找。整个代码非常简单，所以我们将快速浏览每一部分。
地理编码模块有什么帮助？
Python 地理编码模块旨在处理地理数据，并帮助我们将不同的数据配对和匹配在一起。通过 pgeocode 模块，我们可以获取并表示使用邮政编码信息的地区或区域相关信息。
因此，我们可以将该模块用于我们的目的。
在本文中，我们将讨论 pgeocode 模块的一些功能，如下所述:
- 通过邮政编码获得的国家/地区数据
- 邮政编码之间的差异
- 来自邮政编码的多区域数据
地理代码企业应用程序 API
如果您正在为商业应用程序寻找邮政编码地址查找 API，我会推荐您看一看 ZipCodeBase 。它们提供了 200 多个国家的邮政编码数据，如果您的应用程序能够满足全球用户的需求，这将是一件好事。他们有各种 API，邮政编码半径搜索 API 对于查找半径内的邮政编码非常有用。他们的文档是一流的，最好的部分是他们的免费计划，让我们快速开始并尝试这项服务。
1.从邮政编码获取地区数据
让我们看看如何从作为输入提供的不同邮政编码中获取地区数据。我们可以使用地理编码模块轻松获取国家代码、州名等。
地理编码语法:
pgeocode.Nominatim(country)
query_postal_code(postal code)
当 query_post_code()方法处理邮政编码时，names()方法允许我们查询国家名称。
举例:
让我们举一个例子，看看这在现实生活中是如何工作的。我们将查询国家代码“US”和一个随机的邮政编码，并查看地理编码模块显示的数据:
import pgeocode
data = pgeocode.Nominatim('US')
print(data.query_postal_code("95014"))
输出:
postal_code 95014
country_code US
place_name Cupertino
state_name California
state_code CA
county_name Santa Clara
county_code 85
community_name NaN
community_code NaN
latitude 37.318
longitude -122.045
accuracy 4
Name: 0, dtype: object
如您所见，我们收到了大量关于我们查询的国家和邮政编码输入的数据。
2.两个邮政编码之间的地理距离
地理编码模块提供的另一个很酷的特性是能够找到两个邮政编码之间的地理距离。借助 Geodistance()方法，我们也可以做到这一点。让我们首先用有问题的国家初始化这个方法，然后输入我们要查找的两个邮政编码之间的地理距离。
import pgeocode
data = pgeocode.GeoDistance('fr')
print(data.query_postal_code("75013", "69006"))
输出:
391.1242610965041
结论
许多程序确实需要我们处理地理位置和邮政编码，而地理编码库使得处理如此复杂的数据变得非常容易，否则就需要一个巨大的数据集。
我们希望您喜欢了解这个主题。我们已经介绍了另一个处理地理位置的模块，即地理位置模块。
参考资料: 官方文件
Python Geopy 用于查找地址的地理编码
原文：https://www.askpython.com/python/python-geopy-to-find-geocode-of-an-address
地球表面的每个点都可以用它的纬度和经度值来表示。
根据维基百科，“地理编码是将邮政地址描述转换为地球表面位置(以数字坐标表示的空间)的计算过程。”
如果简单放在一起，将文本地址表示为其在地球表面对应的经纬度的过程称为地理编码。
在本文中，我们将使用 Python 的 GeoPy 库检索地址的地理编码。
地质公园
GeoPy 不是一个地理编码服务，而只是几个流行的地理编码 web 服务的 python 客户端。它使用第三方地理编码器和其他数据源来查找地址的地理编码。
下图给出了 GeoPy 功能的一些概念。
Geopy
如上图所示，地理编码由多种不同的服务提供。这些服务提供 API，GeoPy 库在单个包中提供这些 API 的实现。有关 geopy 实现的地理编码服务提供商的完整列表，您可以参考本文档。
需要考虑的一些要点:
- 地理编码服务要么是付费的，要么是免费的，因此在选择服务之前，请仔细阅读其使用条款、配额、价格、地理数据库等。
- geopy 不对您的计算机和地理编码服务之间的任何网络问题负责。
了解了 GeoPy 的功能后，现在让我们看看如何使用它来检索地址的地理编码。
地理编码服务
有许多可用的地理编码服务，但我真的很喜欢 GeocodeAPI。它们有多个端点，可以从地址获取经纬度并进行反向地理编码。它们的高级特性之一是地址自动完成 API。
它们甚至可以从部分地址返回完整的地址。此外，他们每天提供 10，000 个免费请求，如果您刚刚开始构建您的应用程序，这是非常好的。你可以从他们的定价页面了解更多详情。
使用 GeoPy 进行地理编码
每个地理定位服务，即 nomim，在geopy.geocoders中都有自己的类，链接到服务的 API。地理编码器至少有一个geocode方法，用于从提供的字符串(我们想要进行地理编码的地址)中查找坐标。
这个类还有一个reverse方法的实现，与 geocode 方法相反。这里我们需要提供地球表面上一个点的坐标，该方法返回与所提供的纬度和经度相关联的地址。
1.查找地址的地理编码
在本教程中，我们将使用 nomim 地理编码服务。
#Importing the Nominatim geocoder class
from geopy.geocoders import Nominatim
#address we need to geocode
loc = 'Taj Mahal, Agra, Uttar Pradesh 282001'
#making an instance of Nominatim class
geolocator = Nominatim(user_agent="my_request")
#applying geocode method to get the location
location = geolocator.geocode(loc)
#printing address and coordinates
print(location.address)
print((location.latitude, location.longitude))
Output:
Taj Mahal, Taj Mahal Internal Path, Taj Ganj, Agra, Uttar Pradesh, 282001, India
(27.1750123, 78.04209683661315)
使用上面的代码，我们找到了印度阿格拉泰姬陵的坐标。
Nominatim 类有一个geocode方法，它接受一个地址字符串，并从服务提供商的数据库中返回它的坐标。使用 geocode 方法返回的对象有一个返回完整地址的address方法，一个检索该地址的纬度和经度的latitude，londitude方法。
Nominatim geocoder 类接受user_agent作为输入参数，作为向 geocoder API 发送请求的头。
2.使用 GeoPy 和 Pandas 数据框架
RateLimiter类充当了 geocoder 类的包装器，如果我们必须处理许多请求，我们可以用它来延迟向服务器发出请求的时间。
在发出多个请求时，需要考虑向地理编码服务提供商发出的请求的数量，否则会引发错误。
现在让我们把它应用到一个熊猫数据帧上，这个数据帧有印度一些美丽的自然景点的地址。
#Importing the required modules
import pandas as pd
from geopy.geocoders import Nominatim
from geopy.extra.rate_limiter import RateLimiter
#Creating a dataframe with address of locations we want to reterive
locat = ['Coorg, Karnataka' , 'Khajjiar, Himachal Pradesh',\
'Chail, Himachal Pradesh' , 'Pithoragarh, Uttarakhand','Munnar, Kerala']
df = pd.DataFrame({'add': locat})
#Creating an instance of Nominatim Class
geolocator = Nominatim(user_agent="my_request")
#applying the rate limiter wrapper
geocode = RateLimiter(geolocator.geocode, min_delay_seconds=1)
#Applying the method to pandas DataFrame
df['location'] = df['add'].apply(geocode)
df['Lat'] = df['location'].apply(lambda x: x.latitude if x else None)
df['Lon'] = df['location'].apply(lambda x: x.longitude if x else None)
df
DataFrame With Coordinates
RateLimiter类需要一个geocoder类对象和min_delay_seconds作为输入参数。此方法以指定的时间延迟向地理编码服务的服务器发出请求。如果没有找到字符串的位置，它会自动返回 None。
和熊猫一起。我们可以将包装器应用到数据帧上的指定列。
结论
在本文中，我们了解了什么是地理编码，以及 python 的 GeoPy 库如何为我们提供地理编码服务 API 的简单实现。我们还对一个文本格式的地址进行了地理编码，以获得其纬度和经度坐标，并将该方法应用于一个包含一列地址的熊猫数据帧。
快乐学习！
使用 Python getattr()函数
原文：https://www.askpython.com/python/built-in-methods/python-getattr-function
又见面了！在今天的文章中，我们将看看 Python 中的 Python getattr()函数。
这个函数试图获取 Python 对象的属性。这与 setattr()函数非常相似，但是它不修改对象。
让我们通过一些简单的例子来了解如何使用这个函数。
Python getattr()的基本语法
getattr()函数的基本语法如下:
value = getattr(object, attribute_name[, default_value])
在这里，我们将object传递给getattr()。它试图获取这个对象的attribute_name(必须是一个字符串)。如果属性存在，就会给我们对应的value。
这相当于以下语法:
value = object.attribute_name
否则，有两种情况:
- 如果提供了默认值(
default_value)，它将简单地使用它并返回这个默认值的值。 - 否则，它将简单地抛出一个
AttributeError异常，因为没有找到我们的属性。
getattr()的目的不仅仅是获取属性值，还要检查它是否存在！
现在让我们来看几个例子，以便更好地理解。
使用 getattr()–一些例子
让我们先举一个简单的例子，你有一个学生类，有name和roll_num属性。我们会用getattr()干掉他们。
class Student():
def __init__(self, name, roll_no):
self.name = name
self.roll_no = roll_no
student = Student('Amit', 8)
print(f"Name: {getattr(student, 'name')}")
print(f"Roll No: {getattr(student, 'roll_no')}")
输出
Name: Amit
Roll No: 8
事实上，我们确实设置了正确的属性，并且我们使用getattr()来取回它们！
现在，在这种情况下，因为两个属性都在那里，所以没有错误发生。然而，让我们试着得到一个没有放入类中的属性；比如——age。
class Student():
def __init__(self, name, roll_no):
self.name = name
self.roll_no = roll_no
student = Student('Amit', 8)
print(f"Name: {getattr(student, 'name')}")
print(f"Roll No: {getattr(student, 'roll_no')}")
# Will raise 'AttributeError' Exception since the attribute 'age' is not defined for our instance
print(f"Age: {getattr(student, 'age')}")
输出
Name: Amit
Roll No: 8
Traceback (most recent call last):
File "getattr_example.py", line 12, in <module>
print(f"Age: {getattr(student, 'age')}")
AttributeError: 'Student' object has no attribute 'age'
这里，我们试图检索一个未定义的属性。由于没有默认选项，Python 直接引发了一个异常。
如果我们想将默认选项设置为'100'，那么在这种情况下，尽管我们试图获取age，但由于它不在那里，它将返回100 。
让我们来测试一下。
class Student():
def __init__(self, name, roll_no):
self.name = name
self.roll_no = roll_no
student = Student('Amit', 8)
print(f"Name: {getattr(student, 'name')}")
print(f"Roll No: {getattr(student, 'roll_no')}")
# Will not raise AttributeError, since a default value is provided
print(f"Age: {getattr(student, 'age', 100)}")
输出
Name: Amit
Roll No: 8
Age: 100
为什么应该使用 getattr()？
既然我们前面提到这个函数相当于object.attribute_name，那么这个函数的意义是什么呢？
虽然上面使用点符号的语句是正确的，但它只有在调用时实际定义了属性名时才有效！
因此，如果你的类的对象结构不断变化，你可以使用getattr()来检查对象是否处于某种特定的状态！
它还为我们提供了一个非常好的方法来轻松处理异常，并提供后备默认值。如果出现问题，我们可以捕获AttributeError异常或者检查默认值。
希望这能让你更清楚地了解为什么这对你有用！
结论
我们学习了如何使用getattr()函数在运行时检索对象的属性。
参考
- getattr()上的 Python 官方文档
- 关于 Python getattr()的 JournalDev 文章
Python getpass 模块
原文：https://www.askpython.com/python-modules/python-getpass-module
Python **getpass**模块能够提示用户输入密码，而不在屏幕上显示。因此，它将定制用户的体验。
它提供了一种从命令提示符获取密码的安全且独立的方法。
Python getpass 模块示例
导入:
import getpass
语法:
getpass.getpass([prompt[, stream]])
简单的例子:
import getpass
try:
pass_word = getpass.getpass()
except Exception as E:
print('There is an Error : ', E)
else:
print('Password fetched from command prompt :', pass_word)
输出:
Password: Safa
Password fetched from command prompt : Safa
1.不带提示的 getpass 模块
Getpass Module
2.带有自定义提示的 getpass 模块
import getpass
place = getpass.getpass(prompt = 'Which is your favorite place to go?')
if place == 'Satara':
print('Ofcourse!')
else:
print('Where is that?')
输出:
Which is your favorite place to go?
Ofcourse!
Getpass Module With Custom Prompt
3.其他流的 getpass 模块
import getpass
import sys
pass_word = getpass.getpass(stream=sys.stderr)
print('Entered password:', pass_word)
输出:
Password:
Entered password: Safa
Getpass Module With Other Stream
4.getpass(参数)函数
**getpass(argument)**函数使我们能够在命令提示符下打印提示字符串。
如果省略该参数，它将打印“Password:”。
import getpass
user = getpass.getuser()
pass_word = getpass.getpass("User's password %s: " % user)
print(user, pass_word)
输出:
User's password HP:
HP safa
5.getuser()函数
**getuser()**函数基本返回用户/系统对应的登录名。
getpass.getuser()
输出:
HP
结论
因此，在本文中，我们研究并实现了 Python 中的 getpass 模块。
参考
- Python getpass 模块
- getpass 文档
使用 Python globals()函数
原文：https://www.askpython.com/python/built-in-methods/python-globals
嘿，伙计们！在本文中，我们将详细讨论 Python globals()函数。
那么，让我们开始吧。
什么是 Python globals()函数？
使我们能够在整个程序的特定代码中访问所有全局变量及其值的列表。
globals()函数表示一个包含当前全局符号表的 Python 字典。
你可能会想到一个问题..
什么是符号表？
符号表是表示关于不同符号的信息的表结构。符号可以是编程代码的任何属性，如变量、关键字、函数等。
此外，符号表指定了这些提到的符号的名称以及它们的对象类型、它们在整个程序中的作用范围等。
符号表可分为以下类型:
- 全局表:以字典的形式表示全局变量的信息。
- 局部表:以字典的形式表示局部变量的信息。
Python locals() function表示并返回当前局部符号表。要了解更多关于局部变量和局部变量()函数的信息，请访问 Python 局部变量()函数。
理解了 globals()函数的工作原理后，现在让我们来理解下一节中提到的 globals()函数的结构。
全局()函数的语法
globals() function不接受任何参数。它返回表示当前符号表值的字典。
语法:
globals()
现在，让我们通过下面的例子来理解 globals()函数的实现。
通过实例实现 Python globals()函数
在下面的示例中，我们调用了 be globals()函数来解释输出，如下所示:
举例:
print(globals())
globals()函数从全局符号表中返回一个值字典，它提供了关于模块、文件名等的详细信息。
输出:
{'__cached__': None, '__builtins__': <module 'builtins' (built-in)>, '__name__': '__main__', '__spec__': None, '__file__': 'main.py', '__doc__': None, '__loader__': <_frozen_importlib.SourceFileLoader object at 0x7f31606f4e80>, '__package__': None}
显示全局和局部范围变量
接下来，我们将在函数中定义一个全局和局部变量，并调用 globals()函数来了解结果。
举例:
varG = 20 # global variable
def var():
varL = 100 # local variable
print(globals())
Python globals()函数返回一个字典，该字典给出了关于全局变量(varG)及其值以及函数、文件名等的信息。
但是，如果您注意到，globals()函数并没有表示关于局部变量(varL)的信息。这项工作将由 locals()函数来完成。
输出:
{'__file__': 'main.py', 'varG': 20, '__loader__': <_frozen_importlib.SourceFileLoader object at 0x7f7ff13e7e48>, '__cached__': None, '__doc__': None, '__package__': None, '__name__': '__main__', '__spec__': None, '__builtins__': <module 'builtins' (built-in)>, 'var': <function var at 0x7f7ff1436bf8>}
修改和操作变量
我们甚至可以修改全局变量的值，如下所示:
举例:
var = 100
globals()['var'] = 12
print('var:', var)
print(globals())
这里，我们指定 var = 100。此外，如上所示，我们使用 globals()函数将变量“var”的值更改为 12。
如果我们分析输出，globals 函数返回全局符号表的 dict 和变量的更新值，即 var = 12
输出:
var: 12
{'__file__': 'main.py', '__builtins__': <module 'builtins' (built-in)>, '__doc__': None, '__spec__': None, '__name__': '__main__', '__package__': None, '__loader__': <_frozen_importlib.SourceFileLoader object at 0x7f3f83a1ae10>, '__cached__': None, 'var': 12}
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。在那之前，学习愉快！！
参考
- Python 全局变量— JournalDev
如何使用 Python hasattr()方法？
原文：https://www.askpython.com/python/built-in-methods/python-hasattr-method
嘿，读者们！在本文中，我们将详细介绍 Python hasattr()方法的行为。
需要 Python 的 hasattr()方法
在面向对象编程的世界中，我们处理现实生活场景到类和对象的表示或映射。对象可以被认为是一个描述属性及其行为的类的蓝图。
有时，我们可能会遇到这样的情况，我们需要检查某个类是否存在某个属性。同样可以通过 Python hasattr()方法实现。它有助于检查类中属性的存在。
既然我们已经理解了 Python hasattr()方法的必要性和起源，那么让我们来理解它的工作原理。
Python hasattr()方法的工作原理
Python 类通过对象表示属性及其行为。
hasattr() method用于检查一个类中属性的存在。
hasattr(Class, attribute)
hasattr()方法返回一个布尔值，即根据类中属性的存在，要么是真要么是假。
例 1:
class Info:
name = "JournalDev"
lang = "Python"
site = "Google"
print(hasattr(Info, 'lang'))
在上面的例子中，属性“lang”包含在类“Info”中。因此，hasattr()函数返回 True 。
输出:
True
例 2:
class Info:
name = "JournalDev"
lang = "Python"
site = "Google"
print(hasattr(Info, 'date'))
如上例所示，hasattr()函数返回 False，因为属性“date”未在该类中定义。
输出:
False
Python 2 的 hasattr()方法 v/s Python 3 的 hasattr()方法
在 Python 2 中，hasattr()压倒了所有的异常，并为某个条件返回 False。
例如，如果一个给定的属性“A”包含在一个类中，但是被一些异常占据。此时，hasattr()将忽略所有的异常，并返回 False，即使属性“A”恰好存在于类中。
另一方面，在 Python 3 中，如果属性涉及一些异常标准，hasattr()会引发异常。
例子: Python 2 带有 hasattr()函数
class Info(object):
@property
def hey(self):
raise SyntaxError
def say(self):
raise SyntaxError
obj = Info()
print(hasattr(obj,'hey'))
print(hasattr(obj,'say'))
在上面的代码中，尽管由于 decorator 导致了语法错误，hasattr()方法没有引发任何错误，忽略了异常并返回 False，即使该类恰好包含该特定属性。
输出:
False
True
例子: Python 3 带有 hasattr()函数
在下面的代码中，hasattr()函数使用属性“hey”引发语法错误原因的异常错误。
class Info(object):
@property
def hey(self):
raise SyntaxError
def say(self):
raise SyntaxError
obj = Info()
print(hasattr(obj,'hey'))
print(hasattr(obj,'say'))
输出:
Traceback (most recent call last):
File "c:\users\hp\appdata\local\programs\python\python36\lib\site-packages\IPython\core\interactiveshell.py", line 3319, in run_code
exec(code_obj, self.user_global_ns, self.user_ns)
File "<ipython-input-20-e14f6e57b66e>", line 9, in <module>
print(hasattr(obj,'hey'))
File "<ipython-input-20-e14f6e57b66e>", line 4, in hey
raise SyntaxError
File "<string>", line unknown
SyntaxError
结论
因此，在本文中，我们已经了解了 Python hasattr()在 Python 版本 2 和 3 中的工作方式。
参考
- Python 的 hasattr()方法— JournalDev
使用 Python hash()函数
原文：https://www.askpython.com/python/built-in-methods/python-hash-function
大家好！在今天的文章中，我们将关注 Python 的内置hash()函数。Python hash()函数计算 Python 对象的哈希值。但是语言在很大程度上使用了这一点。
让我们用一些例子来更多地了解这个函数！
Python hash()的基本语法
这个函数接受一个不可变的 Python 对象，并返回这个对象的哈希值。
value = hash(object)
请记住，哈希值依赖于一个哈希函数(来自__hash__()),它由hash()内部调用。这个散列函数需要足够好，以便给出几乎随机的分布。
那么，为什么我们想要一个散列函数在如此大的程度上随机化它的值呢？这是因为我们希望散列函数将几乎每个键映射到一个惟一的值。
如果你的值是随机分布的，那么两个不同的键被映射到同一个值的机会就非常小，这正是我们想要的！
现在，让我们看看正在使用的hash()函数，用于简单的对象，如整数、浮点数和字符串。
使用 hash()函数–一些例子
int_hash = hash(1020)
float_hash = hash(100.523)
string_hash = hash("Hello from AskPython")
print(f"For {1020}, Hash : {int_hash}")
print(f"For {100.523}, Hash: {float_hash}")
print(f"For {'Hello from AskPython'}, Hash: {string_hash}")
输出
For 1020, Hash : 1020
For 100.523, Hash: 1205955893818753124
For Hello from AskPython, Hash: 5997973717644023107
正如您所观察到的，整数的哈希值与它们的原始值相同。但是对于 float 和 string 对象，这些值显然是不同的。
现在，如果同一个对象(除了整数/浮点数)总是有相同的哈希值，那就不太安全了。因此，如果您再次运行上面的代码片段，您会注意到不同的值！
例如，这是我第二次运行同一个代码片段时的输出。
For 1020, Hash : 1020
For 100.523, Hash: 1205955893818753124
For Hello from AskPython, Hash: -7934882731642689997
如您所见，字符串的值发生了变化！这是一件好事，因为它防止了同一对象被其他人访问！哈希值仅在程序运行期间保持不变。
之后，每次再次运行程序时，它都会不断变化。
为什么我们不能在可变对象上使用 hash()。
现在，记住我们之前提到的hash()仅用于不可变的对象。这是什么意思？
这意味着我们不能在可变对象上使用hash(),比如列表、集合、字典等等。
print(hash([1, 2, 3]))
输出
TypeError: unhashable type: 'list'
为什么会这样？每次可变对象的值改变时，程序都要改变哈希值，这是很麻烦的。
这将使得再次更新哈希值非常耗时。如果你这样做，那么 Python 需要花很多时间来引用同一个对象，因为引用会不断变化！
因此，我们不能使用hash()散列可变对象，因为它们只有一个值，对我们来说是隐藏的，所以程序可以在内部保存对它的引用。
然而，我们可以在不可变元组上使用hash()。这是一个元组，仅由不可变的对象组成，如 int、floats 等。
>>> print(hash((1, 2, 3)))
2528502973977326415
>>> print(hash((1, 2, 3, "Hello")))
-4023403385585390982
>>> print(hash((1, 2, [1, 2])))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
在自定义对象上使用 hash()
因为默认的 Python hash()实现通过覆盖__hash__()方法来工作，所以我们可以通过覆盖__hash__()来为我们的定制对象创建我们自己的hash()方法，只要相关的属性是不可变的。
现在让我们创建一个类Student。
我们将覆盖__hash__()方法来调用相关属性的hash()。我们还将实现__eq__()方法，用于检查两个自定义对象之间的相等性。
class Student:
def __init__(self, name, id):
self.name = name
self.id = id
def __eq__(self, other):
# Equality Comparison between two objects
return self.name == other.name and self.id == other.id
def __hash__(self):
# hash(custom_object)
return hash((self.name, self.id))
student = Student('Amit', 12)
print("The hash is: %d" % hash(student))
# We'll check if two objects with the same attribute values have the same hash
student_copy = Student('Amit', 12)
print("The hash is: %d" % hash(student_copy))
输出
The hash is: 154630157590
The hash is: 154630157597
我们确实可以观察到自定义对象的散列。不仅如此；两个不同的对象即使有相同的属性值，也有不同的哈希值！
这确实是我们希望从散列函数中得到的，而hash()已经成功地给了我们！
结论
我们学习了如何使用 Python hash()函数。这对于程序使用特殊的整数值来维护对每个对象的引用非常有用。
我们还看到了如何让hash()在定制对象上工作，只要它的属性是不可变的。
参考
- 关于 Python hash()函数的 JournalDev 文章
Python hashlib 模块
原文：https://www.askpython.com/python-modules/python-hashlib-module
Python hashlib 模块是一个用于轻松散列消息的接口。它包含许多方法，可以处理加密格式的任何原始消息的散列。
这个模块的核心目的是在一个字符串上使用一个哈希函数，并对它进行加密，使它很难被解密。
通常，加密字符串足够长，以至于几乎不可能恢复原始字符串。
下面的框图显示了我们如何在我们的应用程序中安全地存储密码！
Hash Function
请注意，哈希函数确保哈希输出的长度保持不变，并且远大于输入字符串的长度。所以，这使得使用暴力破解这样的散列变得非常困难。
介绍完这个概念后，现在让我们来看看如何使用这个模块！
Python hashlib
我们需要导入这个模块，它直接来自 Python 安装。
import hashlib
有不同的散列算法可用，通过这些算法我们可以加密我们的字符串。让我们看看有哪些可用的。
import hashlib
print(hashlib.algorithms_available)
print(hashlib.algorithms_guaranteed)
algorithms_available属性打印系统中使用的每个算法，包括其他程序，如ssh和OpenSSL。
algorithms_guaranteed属性列出了模块中的所有算法。
所以对于我(Linux 系统)来说，我的输出看起来是这样的。如果您使用的是 Windows/macOS，您的输出可能会略有不同。
{'whirlpool', 'sha3-224', 'sha3-256', 'sha512-224', 'sha3-384', 'sha384', 'shake256', 'sha1', 'md5-sha1', 'md5', 'md4', 'mdc2', 'blake2b512', 'blake2s256', 'sha3_512', 'sha512-256', 'blake2s', 'ripemd160', 'sha3_384', 'shake128', 'shake_128', 'blake2b', 'sha512', 'sha3_224', 'shake_256', 'sha256', 'sha3_256', 'sha3-512', 'sha224', 'sm3'}
{'blake2b', 'md5', 'sha512', 'blake2s', 'sha3_224', 'shake_256', 'sha256', 'sha3_256', 'sha384', 'sha3_384', 'sha224', 'sha1', 'shake_128', 'sha3_512'}
现在让我们继续加密字符串！
使用 Python hashlib 加密字符串
我们不能直接将字符串传递给哈希函数。这是因为它只接受一个字节列表，所以我们必须把我们的字符串转换成一个字节的字符串 ，然后只传入一个哈希函数。
对于本文，我们将使用 SHA-256 算法，它给出 256 位的散列。
import hashlib
# Initialize the empty message using SHA-256
message = hashlib.sha256()
# Update the message using byte strings
message.update(b'Hello there,')
message.update(b'how are you?')
# Print the message digest
print(message.digest())
输出
b',\xe1\xff7\xe7\xa0\xe7\xb2\xb4\xf9E!\xf2\xd9\xb8;\xdf\x7f\x10\xa8\x1ad1\xc0\x7f=\xbb\xb1\xf7\xeb7\xcf'
我们使用message.digest()从消息对象中获取散列字符串。
对于非字节字符串，message.update()方法不能使用而不是，所以如果你没有直接传递它，你需要使用string.encode()对它进行编码。
import hashlib
def hash_string(input):
byte_input = input.encode()
hash_object = hashlib.sha256(byte_input)
return hash_object
def update_hash(hash_object, input_str):
# Adds the string to the hash string
hash_object.update(input_str.encode())
hash_object = hash_string('Hello from AskPython')
# Print the encrypted message
print(hash_object.hexdigest())
# Update the hash message
update_hash(hash_object, 'hello, how are you?')
# Print the encrypted message
print('After updating:', hash_object.hexdigest())
new_str = 'Hello from AskPythonhello, how are you?'
print(hash_string(new_str).hexdigest() == hash_object.hexdigest())
输出
e0a59a3889b1db4cc27f4fcc03353bf1db55114add1112f95532794fd392b202
After updating: 32f9cffab10b7bfef72892d5059de865914319a05bdf394b18d7b068fd806a0a
True
我们已经成功地将我们的字符串传递到 hash 函数中以获得一个加密的 hash，并相应地更新它！
您现在可以将其扩展到不同的哈希算法，这些算法在文档中给出。在不久的将来，我们将向您展示一步一步的过程来实现一个好的散列函数，使用这个模块作为构建块。收听更多更新！
结论
在本文中，我们学习了 Python hashlib模块，使用不同的散列函数加密字符串。
参考
- Python Hashlib 模块文档
- hashlib 上的 JournalDev 文章
Python heapq 模块:使用 heapq 在 Python 中构建优先级队列
原文：https://www.askpython.com/python-modules/python-heapq-module
大家好！在今天的文章中，我们将学习如何使用 Python heapq 模块。
这个模块为我们提供了一种快速简单的方法来为您的应用程序构建任何类型的优先级队列。
为了更好地了解这个模块，让我们仔细看看。
作为最小堆的优先级队列
优先级队列是这样一种队列，其中的元素具有另一个称为优先级的参数。基于元素的优先级，这些元素首先被推出/弹出队列。
该模块利用二进制最小堆来构建优先级队列。
这种堆队列数据结构的主要特性是总是首先弹出最小的元素！
此外，一旦任何元素被推/弹出，相同类型的结构被保持。
这种数据结构有大量的应用，包括排序。
让我们了解一下现在如何使用这个模块。
了解 Python heapq 模块
这个模块是标准库的一部分，所以没有必要使用 pip 单独安装它。
要导入 heapq 模块，我们可以执行以下操作:
import heapq
在heapq模块中，我们主要需要 3 种方法来构建和操作我们的优先级队列:
heappush(heap, item)- >将item推到heap上，保持最小堆属性。heappop(heap)- >弹出并返回堆中最小的项目。如果堆是空的，我们将得到一个IndexError异常。heapify(iterable)- >将 iterable(列表等)转换为最小堆。这将就地修改可迭代的
让我们举一个简单的例子，从一个普通的整数列表构建优先级队列。
import heapq
a = [1, 4, 3, 5, 2]
print("List =", a)
# Convert the iterable (list) into a min-heap in-place
heapq.heapify(a)
print("Min Heap =", a)
输出
List = [1, 4, 3, 5, 2]
Min Heap = [1, 2, 3, 5, 4]
如您所见，heapify()方法就地修改了列表，并将其转换为最小堆。
要观察它为什么是一个最小堆，只需画出这两个列表的树形表示。
Old List – Tree Representation
对于来自列表的最小堆表示，对于具有索引i的节点，其子节点具有索引2*i和2*i+1。
对于最小堆，父堆必须小于它的两个子堆！
Min Heap Flow
如您所见，第二个列表确实遵循了我们的 min-heap 属性！因此，我们已经验证了heapify()方法给了我们正确的最小堆。
我们现在将向/从我们的堆中推进和弹出。
import heapq
a = [1, 4, 3, 5, 2]
print("List =", a)
# Convert the iterable (list) into a min-heap in-place
heapq.heapify(a)
print("Min Heap =", a)
# Use heappush
heapq.heappush(a, 10)
print("After heappush(), Min Heap =", a)
# Use array indexing to get the smallest element
print(f"Smallest element in the heap queue = {a[0]}")
# Use heappop() and return the popped element
popped_element = heapq.heappop(a)
print(f"Popped element = {popped_element}, Min Heap = {a}")
输出
List = [1, 4, 3, 5, 2]
Min Heap = [1, 2, 3, 5, 4]
After heappush(), Min Heap = [1, 2, 3, 5, 4, 10]
Smallest element in the heap queue = 1
Popped element = 1, Min Heap = [2, 4, 3, 5, 10]
如您所见，我们能够轻松地在这个堆队列上执行我们想要的操作！现在让我们看看如何使用这个最小堆来使用 heapsort 对我们的列表进行排序。
import heapq
def heapsort(iterable):
h = []
for value in iterable:
# Push the elements onto the heap
heapq.heappush(h, value)
# Keep popping the smallest elements and appending them to our sorted list
return [heapq.heappop(h) for i in range(len(h))]
sorted_list = heapsort([1, 3, 5, 7, 9, 2, 4, 6, 8, 0])
print(sorted_list)
输出
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
太好了！事实上，我们已经使用堆队列属性对列表进行了排序！
结论
在本文中，我们学习了如何使用 Python heapq 模块，并了解了如何使用 min-heap 属性对无序列表进行排序。
参考
- heapq 模块上的 Python 文档
Python help()方法
原文：https://www.askpython.com/python/built-in-methods/python-help-method
嘿，伙计们！在本文中，我们将关注 Python 中一个重要的解释性函数— Python help()函数。
需要 help()方法
在用特定的编程语言编码时，了解框架语言的基本文档对我们来说是非常重要的。这就是 help()函数发挥作用的时候了。
这个函数为我们提供了 Python 语言的基本文档。它为我们提供了与特定方法或类相关的方法和实例的信息。
help()方法与关键字、类、函数和模块一起工作，帮助我们分别获得基本术语、实例和与之相关的工作。
通常help() method与 Python 解释器一起使用，以获得作为参数传递给它的 Python 对象的底层细节。
Python help()方法的工作原理
如上所述，help()方法提供关于传递给它的 Python 对象的信息。
如果在没有任何参数的情况下提及 help() function，它将启动解释器控制台，在这里我们可以提及任何模块、对象、类等到 利用文档 大致相同。
举例:
help()
输出:
help() function
带类的 Python help()函数
帮助功能可以提供定制或预定义的参数来使用。我们可以创建一个定制的类，并将其传递给 help()函数，以检查该函数提供的文档。
举例:
class Info:
lang = "Python"
name = "JournalDev"
obj = Info()
help(Info)
我们已经创建了一个用户定义的类，并将其传递给 help()函数。help()函数返回了类“Info”的必要文档。
输出:
Help on class Info in module __main__:
class Info(builtins.object)
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| lang = 'Python'
|
| name = 'JournalDev'
带函数的 Python help()函数
help()函数帮助我们访问语法、参数列表以及使用下面的命令传递给它的任何函数的描述。
语法:
help('function-name')
例 1:
help('getattr')
输出:
help() With Function getattr()
例 2:
help('map')
输出:
help() With Function map()
带模块的 Python help()函数
我们可以使用 help()函数获得关于模块的信息。当一个模块被传递给 help()函数时，它提供关于版本、文件位置、模块内容以及相关数据的文档。
语法:
help('module-name')
举例:
help('seaborn')
输出:
Help on Module Seaborn
带有关键字的 help()函数
在将 Python 关键字作为参数传递给 help()函数时，该函数根据关键字的类、与其相关联的方法等返回文档。
语法:
help('keyword-name')
例 1:
help(True)
输出:
help() function With Keyword True
例 2:
help(int)
输出:
help() Function With Keyword int
结论
这个话题到此结束。我们已经了解了 help()函数的需求和工作方式。我希望所有的读者都清楚这个概念。
如果你有任何疑问，请不吝赐教。
参考
- help()方法— JournalDev
- 关于 help()方法的文档
如何使用 Python hex()函数？
原文：https://www.askpython.com/python/built-in-methods/python-hex-function
在本文中，我们将介绍 Python hex() 函数。
如果你想把一个整数转换成十六进制的字符串，前缀为“0x”，这个函数很有用。
让我们看看如何使用这个函数。
使用 Python hex()函数
Python hex()函数有一个非常简单的语法:
hex_string = hex(val)
这里，val可以是整数、二进制、八进制或十六进制数。
让我们快速看一些例子。
print(hex(1000)) # decimal
print(hex(0b111)) # binary
print(hex(0o77)) # octal
print(hex(0XFF)) # hexadecimal
输出
0x3e8
0x7
0x3f
0xff
在自定义对象上使用 Python hex()
我们也可以在自定义对象上使用 hex()。但是，如果我们想成功地使用它，我们必须为我们的类定义 index() dunder 方法。
hex()方法会调用__index__()，所以一定要实现。这必须返回一个值，可以是十进制/二进制/八进制/十六进制数。
class MyClass:
def __init__(self, value):
self.value = value
def __index__(self):
print('__index__() dunder method called')
return self.value
my_obj = MyClass(255)
print(hex(my_obj))
输出
__index__() dunder method called
0xff
事实上，正如您所看到的，它返回了我们所期望的结果。
首先，hex()在我们的自定义类上调用 index 方法。
然后，它将返回值转换为十六进制字符串(255->“0x ff”)
结论
在本文中，我们学习了如何使用 hex() 函数，将数值转换成十六进制字符串。
参考
- 关于 Python hex()的 JournalDev 文章
使用 Python HttpServer 作为简单的 HTTP 服务器
原文：https://www.askpython.com/python-modules/python-httpserver
大家好！在今天的文章中，我们将看看如何使用 Python HttpServer。
这个模块是在您的网络上启动本地 Http 服务器的一个非常快速简单的方法。
此前，在 Python 2.7 中，这个模块被称为HttpServer。但是在 Python3 中，这个模块已经合并到了http.server模块中。
让我们开始吧，运行我们自己的 Http 服务器！
导入 Python httpserver 模块
这个模块是标准库的一部分，所以没有必要安装它！
要导入这个模块，只需使用下面的语句:
import http.server
现在您已经准备好运行服务器了。现在让我们编写一些代码来服务这些文件。
运行我们的 Http 服务器
如果您只是想与其他用户共享您的文件和目录，您可以使用 Python 直接运行服务器。
转到您希望共享的任何目录，并从那里运行服务器，使用:
python -m http.server 9000
这里，我们在端口 9000 启动本地 Http 服务器。
连接到 Http 服务器
现在，要连接到本地服务器，您必须执行以下步骤:
- 转到服务器，使用 Windows 上的
arp -a或 Linux 上的ip -a | grep inet找到服务器 IP 地址。 - 从远程客户端，只需在浏览器上输入
http://IP_ADDRESS:9000/就能看到神奇之处！
输出
Http Server Basic
请注意，您可以查看服务器文件，甚至可以将其下载到客户机上！
Python Http Server File
运行提供自定义 index.html 文件的 Python HttpServer
虽然默认服务器便于直接共享文件，但您可以通过运行单独的文件来自定义服务器的行为。
例如，我们将运行一个定制的 Http 服务器，它使用http.server和socketserver进行 TCP 通信。
MyHttpRequestHandler 调用 do_GET()方法来服务请求。要为请求提供定制文件，我们可以通过简单地定义另一个返回不同值的 do_GET()方法来覆盖函数。
# server.py
import http.server # Our http server handler for http requests
import socketserver # Establish the TCP Socket connections
PORT = 9000
class MyHttpRequestHandler(http.server.SimpleHTTPRequestHandler):
def do_GET(self):
self.path = 'index.html'
return http.server.SimpleHTTPRequestHandler.do_GET(self)
Handler = MyHttpRequestHandler
with socketserver.TCPServer(("", PORT), Handler) as httpd:
print("Http Server Serving at port", PORT)
httpd.serve_forever()
如果您将此称为server.py，您可以使用以下命令运行 http 服务器:
python server.py
Custom Homepage for Python http server
因为我们定义了自定义的 do_GET()函数，所以我们可以使用我们的服务器(在本例中是 index.html)来提供一个主页 HTML 文件。另外，如果服务器正在您的系统上运行，您可以使用localhost:<portnumber>直接访问服务器，而不是使用 IP。
结论
在本文中，我们学习了如何使用http.server模块在 Python 中建立一个简单的 Http 服务器。我们还学习了如何定义 do_GET()方法，以便在向服务器发出请求时提供定制文件。
参考
- Http 服务器上的 Python 文档
Python 标识符–规则、示例、最佳实践
原文：https://www.askpython.com/python/python-identifiers-rules-best-practices
Python 标识符是用户定义的名称。它们用于指定变量、函数、类、模块等的名称。
创建 Python 标识符的规则
创建 python 标识符必须遵循一些规则。
- 不能使用保留的 关键字 作为标识符名称。如果你尝试，它会抛出语法错误。
- Python 标识符可以包含小写字母(a-z)、大写字母(A-Z)、数字(0-9)和下划线(_)。
- 标识符名称不能以数字开头。例如，10test 将是一个无效的标识符。
- Python 标识符不能只包含数字。例如，888 可能是无效的标识符。
- Python 标识符名称可以以下划线开头。所以,_test 是一个有效的标识符。
- 标识符名称的长度没有限制。但是，不要试图保留一个超长的标识符，这只会伤害你作为程序员的信誉。
- Python 标识符名称区分大小写。所以，“abc”和“ABC”是两个不同的标识符。为了程序的一致性，最好使用小写的标识符。
Python 有效标识符示例
让我们看一些 Python 中有效标识符的例子。
- ab10c :仅包含字母和数字
- abc_DE :包含所有有效字符
- 令人惊讶的是，下划线是一个有效的标识符
- _abc :标识符可以以下划线开头
Python 无效标识符示例
- 99 :标识符不能只有数字
- 9abc :标识符不能以数字开头
- x+y :唯一允许的特殊字符是下划线
- 的:保留关键字
如何测试一个字符串是否是有效的标识符？
我们可以使用字符串isidentifier()函数来检查标识符名称是否有效。但是，这种方法不考虑保留的关键字。所以，我们可以使用这个函数和keyword.iskeyword()来检查名字是否有效。
print("abc".isidentifier()) # True
print("99a".isidentifier()) # False
print("_".isidentifier()) # True
print("for".isidentifier()) # True - wrong output
我们知道“for”是一个保留关键字。所以它不是一个有效的标识符。让我们定义一个函数来测试标识符名称是否有效。
def is_valid_identifier(s):
return s.isidentifier() and not keyword.iskeyword(s)
print(is_valid_identifier("for")) # False
Python Identifiers
Python 标识符命名最佳实践
- 类名应该以大写字母开头。比如
Person、Employee等。 - 如果类名有多个单词，每个单词的第一个字符使用大写。比如
EmployeeData、StringUtils等。 - 变量、函数和模块名应该用小写字母。比如
collections、foo()等。 - 如果变量、函数和模块名有多个单词，那么用下划线将它们分开。比如
is_empty()、employee_object等。 - 对于私有变量，可以用下划线开始它们的名字。
- 避免使用下划线作为标识符名称的第一个和最后一个字符。它由 python 内置类型使用。
- 如果标识符以两个下划线开始和结束，那么这意味着标识符是一个语言定义的特殊名称，比如 init。因此，您应该避免在标识符名称的开头和结尾使用两个下划线。
- 保持标识符名称有意义，以阐明其意图。比如 phone_number，is _ 大写等。
- 如果一个函数返回一个布尔值，它的名字最好以“is”开头。比如
isidentifier、iskeyword等。 - 标识符名称的长度没有限制。但是，保持它的短小精悍。例如，_ employee _ object _ first _ name可以更好地命名为 emp_first_name 。
摘要
Python 中的标识符是用户定义的名称。它们用于定义 python 程序中的实体。我们应该使用专有名词来暗示标识符的用法。遵循规则来“保持简单而有意义”。
下一步是什么？
参考资料:
Python if else elif 语句
原文：https://www.askpython.com/python/python-if-else-elif-statement
- Python if-elif-else 语句用于编写条件流代码。
- 语句的顺序是 if…elif…else。
- “elif”是“else if”语句的缩写。缩短是为了减少过多的 缩进 。
- else 和 elif 语句是可选的。
- 可以有多个 elif 语句。
- 一个 if 语句只能有一个 else 块。
- if、else、elif 是 Python 中的 保留关键字。
- Python 不像其他语言那样有 switch-case 语句。if-else 条件足以在 Python 脚本中实现控制流。
- 我们可以在 Python 中嵌套 if-else 块。
- Python 三元运算允许我们在一行中编写一个 if-else 语句。当 if-else 条件很简单并且我们想要减少代码长度时，这很有用。
Python if else 语法
Python 中 if-else 语句的一般语法是:
if condition:
# code
elif condition:
# code
... # multiple elif statements
else:
# default code
- 每个 if-elif 语句后面都有一个条件。
- 如果条件评估为真，则执行该块中的代码。
- 一旦执行了任何块中的代码，控制流就会移出 if-elif-else 块。
- 如果没有一个条件为真，则执行 else 块代码。
Python if-elif-else 示例
假设我们有一个 函数 ，它接受一个国家名称并返回其首都。我们可以使用 if-else 条件来实现这个逻辑。
def get_capital(country):
if country == 'India':
return 'New Delhi'
elif country == 'France':
return 'Paris'
elif country == 'UK':
return 'London'
else:
return None
Python if else elif Example
前面我们提到 elif 语句是可选的。让我们看另一个简单的例子，我们没有 elif 语句。
def is_positive(num):
if num >= 0:
return 'Positive'
else:
return 'Negative'
甚至 else 块也是可选的。让我们看另一个例子，我们只有如果条件。
def process_string(s):
if type(s) is not str:
print('not string')
return
# code to process the input string
如果你想知道空的 返回语句 是怎么回事，它会向调用者返回 None 。
Python if-else 在一行中
假设我们有这样一个简单的 if-else 条件:
x = 10
if x > 0:
is_positive = True
else:
is_positive = False
我们可以使用 Python 三元运算在一行中移动完整的 if-else 块。
三元运算的语法是:
value_true if condition else value_false
让我们用一行代码重写上面的 if-else 块。
is_positive = True if x > 0 else False
Python if else One Line
嵌套 if-else 条件
我们可以有多个嵌套的 if-else 条件。请小心缩进，否则可能会出现意想不到的结果。
让我们看一个长示例，它包含多个 if-else-elif 条件，并嵌套创建了一个智能数字处理脚本。
# accepting user input
x = input('Please enter an integer:\n')
# convert str to int
x = int(x)
print(f'You entered {x}')
if x > 0:
print("It's a positive number")
if x % 2 == 0:
print("It's also an even number")
if x >= 10:
print("The number has multiple digits")
else:
print("It's an odd number")
elif x == 0:
print("Lovely choice, 0 is the master of all digits.")
else:
print("It's a negative number")
if x % 3 == 0:
print("This number is divided by 3")
if x % 2 == 0:
print("And it's an even number")
else:
print("And it's an odd number")
以下是该代码多次迭代的示例输出。
Please enter an integer:
10
You entered 10
It's a positive number
It's also an even number
The number has multiple digits
Please enter an integer:
0
You entered 0
Lovely choice, 0 is the master of all digits.
Please enter an integer:
-10
You entered -10
It's a negative number
And it's an even number
结论
Python if-else 条件允许我们在程序中编写条件逻辑。语法简单易用。我们可以使用三元运算将简单的 if-else 条件转换成一行。当您有多个嵌套的 if-else 条件时，请小心缩进。
Python iloc()函数–您需要知道的一切！
原文：https://www.askpython.com/python/built-in-methods/python-iloc-function
大家好！在本文中，我们将重点关注 Python iloc()函数的工作原理。所以，让我们开始吧！
Python iloc()函数的工作原理
Python 为我们提供了各种模块和函数来处理数据。Pandas 模块为我们提供了更多的功能来处理大量的行和列的数据集。
Python iloc() function使我们能够选择数据集的特定单元格，也就是说，它帮助我们从数据框或数据集的一组值中选择属于特定行或列的值。
使用 iloc()函数，我们可以使用分配给它的索引值来检索属于行和列的特定值。
记住，iloc()函数只接受整型值作为要访问和显示的值的索引值。
语法:
dataframe.iloc[]
如上所述，我们不能传递布尔值作为检索记录的索引。必须向其传递整数值。
Python iloc()函数的示例
在本例中，我们试图访问数据集每一列的第三个索引的所有数据值，如图所示。
数据集–以下示例中使用的数据集
Dataset
例 1:
我们将使用 read_csv()函数将数据集从 csv 拉入一个变量。
import pandas as pd
import numpy as np
import os
data = pd.read_csv("bank-loan.csv") # dataset
print(data.iloc[3])
输出:
age 41.00000
ed 1.00000
employ 15.00000
address 14.00000
income 120.00000
debtinc 2.90000
creddebt 2.65872
othdebt 0.82128
default 0.00000
Name: 3, dtype: float64
现在，我们已经尝试访问第 1 行和第 2 行的数据值，相当于数据集的每一列，如下所示
例 2:
import pandas as pd
import numpy as np
import os
data = pd.read_csv("bank-loan.csv") # dataset
data.iloc[1:3]
函数iloc[1:3]将包括从 1 到 3，但不包括索引 3。
输出:
Python iloc() Example 2
这里，我们已经访问了列 1 和列 2 的所有数据值，如下所示
语法:
dataframe.iloc[:,start_col:end_col]
例 3:
import pandas as pd
import numpy as np
import os
data = pd.read_csv("bank-loan.csv") # dataset
data.iloc[:,1:3]
输出:
Python iloc() Example 3
摘要
因此，在本文中，我们已经了解了 Python iloc()函数的功能。
- 它可用于根据数据集的索引值提取记录。
- 使用索引的概念作为 iloc()函数的参数，可以提取多条记录。
- iloc()函数仅将整数索引视为参数。
结论
到此，我们就结束了这个话题。如果你有任何问题，欢迎在下面评论。
在那之前，请保持关注并继续学习！！
Python:影响效果图
原文：https://www.askpython.com/python/python-impact-effort-chart
嘿伙计们！在本教程结束时，您将最终学会如何使用 Python 编程语言实现影响效果图。我们将首先从理解什么是影响效果图以及它们为什么重要开始。
影响介绍-工作图
让我们快速了解一下影响效果图实际上是什么。在此基础上，用 python 创建一个代码来实现影响效果图。
注意:这是一个复杂的过程，需要专业技术知识。如果你正在寻找一个更简单的解决方案，使用一个客户反馈管理工具来执行这些计算和可视化，没有任何麻烦。
什么是影响-效果图？
影响-努力决策图 是一种工具，可以帮助团队确定要关注哪些方面的改进。该图表可以帮助人们根据任务的效果和达到每个目标所需的工作量对质量改进“待办事项”列表进行分类。
Effort Impact Chart Demo
高效可以归结为尽可能有效地管理你的时间。你可以过滤掉不相关的杂务，通过影响与努力分析来运行你的所有任务，将你的注意力集中在你每天的关键目标上。当您收到客户对您产品的反馈并希望创建任务来提高产品质量时，这非常有用。市场上有许多客户反馈管理软件，我个人使用过的其中一个是 UserWell ，它为 B2B 公司解决了所有与反馈相关的挑战。
影响效果图的重要性
影响效果图有很多好处。其中一些列举如下:
- 有助于优化有限的时间和资源
- 为日常待办事项列表甚至复杂的战略计划提供了视觉效果
- 根据对实现目标最有帮助的内容，帮助确定任务的优先顺序
- 帮助协调目标和优先事项
现在我们已经知道了什么是影响效果图，让我们转到相同的代码实现。
实施影响效果图
为了实施该图表，我们将遵循一些步骤。下图中列出了这些步骤。
ImpactEffortChart Implementation
步骤 1–导入模块/库
就像任何其他程序一样，第一步是将所有必要的模块/库导入到我们的代码中。对于这个实现，我们只需要两个模块，即 pandas 和 matplotlib。
import pandas as pd
import matplotlib.pyplot as plt
我希望你对他们两个都很熟悉。如果没有，那么看看下面提到的教程:
步骤 2–加载和清理数据
下一步是将定制的或随机的数据集加载到我们的程序中。下面显示了所用数据的快照。
TaskList Snap ImpactMatrix
在本教程中，我们将利用包含许多任务的数据集，包括每个任务的开始和结束日期以及优先级。有一些额外的属性，但我们不需要它们。
在加载的同时，我们需要确保删除nan值(如果有的话)。相同的代码如下所示。
data = pd.read_csv("Task_List.csv")
data =data.dropna()
data.head()
ImpactEffortChart Loaded Data
步骤 3–从数据中提取所需信息
下一步是从数据中获取必要的信息。为了实现这一目标，我们将编写一本字典，其中包含每项任务的优先级和分配天数。
我假设优先级定义了任务将产生的影响，而工作将由任务的天数决定。
这里的一个主要任务是计算每个任务的天数。为了达到同样的目的，我们需要datetime模块并得到date函数。
我们从分割每个任务的开始和结束日期并提取日期开始，创建两个date对象。最后，我们找出两者之间的差异，并根据差异返回天数。
同样的代码实现如下所示。如果你不知道 datetime 模块是如何工作的，可以看看这个教程。
from datetime import date
def get_time (start,end):
start = (start.split()[0]).split('-')
end = (end.split()[0]).split('-')
start = date(int(start[2]), int(start[1]),int(start[0]))
end = date(int(end[2]),int(end[1]),int(end[0]))
diff = end - start
return diff.days
现在我们有了计算天数的功能，也就是说，我们为每项任务所拥有的时间。我们将继续创建字典，它将存储相同的内容以及列表中每个任务的优先级。
all_tasks = data['Task']
final_data = {}
for i in range(len(all_tasks)):
l = list()
# priority
l.append(data['Priority'][i])
# get_no_days
l.append(get_time(data['Start Date'][i],data['End Date'][i]))
final_data[all_tasks[i]] = l
最终的字典具有如下所示形式的值。
Extracted Data ImpactEffortChart
第 4 步——给每项任务分配一个象限
现在，下一个任务是在我们将在下一阶段绘制的图中给每个任务分配一个象限。
象限是根据某些规则和假设定义的，如下表所示。
| 象限号 | 象限名称 | 天数 | 优先级 |
| one | 高影响力–低投入 | >10 | 高的 |
| Two | 高影响–高努力 | <10 | 高的 |
| three | 低影响–低工作量 | >10 | 低/中 |
| four | 低影响–高努力 | <10 | 低/中 |
为了给每个任务分配坐标点，我们需要一个特定的范围，以便使用random模块分配随机坐标。如果你不知道随机模块，在这里查看这个教程！
我们将确保我们的图保持在 22×22 的 x 和 y 值，因此我们将在[1，20]的范围内分配随机(x，y)值，以获得清晰的图。这些值是根据上面提到的表格分配的。
import random
first,second,third,fourth = 0,0,0,0
plot_data = {}
for i in final_data:
# 1st Quadrant
if(final_data[i][0] == 'High' and final_data[i][1] > 10):
first+=1
x = random.randint(1,10)
y = random.randint(12,20)
while((x,y) in plot_data.values()):
x = random.randint(1,10)
y = random.randint(12,20)
plot_data[i] = (x,y)
#2nd Quadrant
elif(final_data[i][0] == 'High' and final_data[i][1] < 10):
second+=1
x = random.randint(12,20)
y = random.randint(12,20)
while((x,y) in plot_data.values()):
x = random.randint(12,20)
y = random.randint(12,20)
plot_data[i] = (x,y)
# 3rd Quadrant
elif((final_data[i][0] == 'Low' and final_data[i][1] > 10) or (final_data[i][0]=='Medium' and final_data[i][1]>10)):
third+=1
x = random.randint(1,10)
y = random.randint(1,10)
while((x,y) in plot_data.values()):
x = random.randint(1,10)
y = random.randint(1,10)
plot_data[i] = (x,y)
else:
fourth+=1
x = random.randint(12,20)
y = random.randint(1,10)
while((x,y) in plot_data.values()):
x = random.randint(12,20)
y = random.randint(1,10)
plot_data[i] = (x,y)
print("Quadrant 1 - High Impact but Low Efforts -" , first)
print("Quadrant 2 - High Impact and High Efforts -", second)
print("Quadrant 3 - Low Impact and Low Efforts -", third)
print("Quadrant 4 - Low Impact and High Efforts -", fourth)
运行上面的代码片段后，我们可以看到分配给每个象限的任务数量，如下所示。
Quadrant 1 - High Impact but Low Efforts - 1
Quadrant 2 - High Impact and High Efforts - 7
Quadrant 3 - Low Impact and Low Efforts - 4
Quadrant 4 - Low Impact and High Efforts - 12
第 5 步——可视化最终结果
为了可视化最终结果，我们需要在单独的变量下有 x 和 y 坐标值，为了有注释，我们还需要标签。
为了避免情节中的长文本并获得清晰明了的情节，我们将只绘制字符串的前 12 个字符。
all_x = [plot_data[i][0] for i in plot_data]
all_y = [plot_data[i][1] for i in plot_data]
all_labels = [i[:12] for i in plot_data]
可视化部分非常简单，可以用一个基本的散点图来完成，以后还可以添加注释。除此之外，我们将添加文本以定义象限。
plt.style.use('seaborn')
plt.figure(figsize=(10,10))
plt.xlim((0,21))
plt.ylim((0,21))
plt.plot([11,11],[0,21], linewidth=2, color='red')
plt.plot([0,21],[11,11], linewidth=2, color='red' )
plt.scatter(all_x,all_y,marker='*')
plt.text(3,6, 'Low Impact \nLow Efforts', fontsize = 22,alpha = 0.1)
plt.text(3,15, 'High Impact \nLow Efforts', fontsize = 22,alpha = 0.1)
plt.text(15,15, 'High Impact \nHigh Efforts', fontsize = 22,alpha = 0.1)
plt.text(15,6, 'Low Impact \nHigh Efforts', fontsize = 22,alpha = 0.1)
plt.xticks([])
plt.yticks([])
for i in range(len(all_x)):
plt.annotate(all_labels[i], (all_x[i], all_y[i] + 0.2))
plt.title('Impact - Effort Chart',fontsize=30)
plt.xlabel('Effort',fontsize=30)
plt.ylabel('Impact',fontsize=30)
#plt.axis('off')
plt.show()
以下教程将有助于理解上述代码的某些部分:
Final Impact Effort Chart
结论
恭喜你！您刚刚学习了影响效果图，以及如何使用 Python 编程语言从头开始手动实现。😇
喜欢这个教程吗？无论如何，我建议你看一下下面提到的教程:
感谢您抽出时间！希望你学到了新的东西！！😄
Python 导入语句
Python **import**语句使用户能够在相应的程序中导入特定的模块。
它类似于 C/C++中的#include header_file。
一旦解释器遇到特定代码中的导入语句，它就在局部范围内搜索相同的语句并导入模块(如果在搜索路径中存在的话)。
它首先在其内置模块部分搜索一个特定的模块。如果没有找到，它会在当前目录中搜索这些模块。
模块在特定程序中只加载一次，不受模块导入次数的影响。
语法:
import module_name
举例:
import collections
1.从模块导入类/函数
我们可以使用以下语法从模块中导入类/函数:
from {module} import {class/function}
举例:
from collections import OrderedDict
from os import path
from math import pi
print(pi)
输出:
3.141592653589793
2.*导入** 语句
特定模块的所有方法和常量都可以使用 import *操作符导入。
from math import *
print(pi)
print(floor(3.15))
输出:
3.141592653589793
3
3.Python 的 import as 语句
**import as**语句帮助用户提供原始模块名的别名。
# python import as
import math as M
print(M.pi)
print(M.floor(3.18))
输出:
3.141592653589793
3
4.导入用户定义的模块
我们可以用一个程序的名字将它的功能导入到另一个程序中。
最初，我们需要创建一个 python 代码。
test.py
def sub(a, b):
return int(a) - int(b)
def lower_case(str1):
return str(str1).lower()
然后创建另一个 python 脚本，其中我们需要导入上面的 create test.py 脚本。
test2.py
import test
print(test.sub(5,4))
print(test.lower_case('SafA'))
输出:
1
safa
5.从另一个目录导入
**importlib**库用于从另一个目录导入脚本。
最初，我们需要创建一个 python 脚本并在其中定义函数。
test1.py
def sub(a, b):
return int(a) - int(b)
def lower_case(str1):
return str(str1).lower()
然后，我们将创建另一个 python 脚本，并将其保存到另一个目录中，然后从 test1.py(驻留在另一个目录中)导入功能。
design . py
import importlib, importlib.util
def module_directory(name_module, path):
P = importlib.util.spec_from_file_location(name_module, path)
import_module = importlib.util.module_from_spec(P)
P.loader.exec_module(import_module)
return import_module
result = module_directory("result", "../inspect_module/test1.py")
print(result.sub(3,2))
print(result.lower_case('SaFa'))
输出:
1
safa
另一种方法是将模块目录添加到 sys.path 列表中。
6.从另一个文件导入类
tests . py
class Employee:
designation = ""
def __init__(self, result):
self.designation = result
def show_designation(self):
print(self.designation)
class Details(Employee):
id = 0
def __init__(self, ID, name):
Employee.__init__(self, name)
self.id = name
def get_Id(self):
return self.id
design . py
import importlib, importlib.util
def module_directory(name_module, path):
P = importlib.util.spec_from_file_location(name_module, path)
import_module = importlib.util.module_from_spec(P)
P.loader.exec_module(import_module)
return import_module
result = module_directory("result", "../Hello/tests.py")
a = result.Employee('Project Manager')
a.show_designation()
x = result.Details(4001,'Safa')
x.show_designation()
print(x.get_Id())
输出:
Project Manager
Safa
Safa
结论
因此，在本文中，我们已经理解了 import 语句提供的功能。
参考
- Python 导入语句
- 进口声明文件
Python imread():使用 OpenCV.imread()方法加载图像的不同方式
原文：https://www.askpython.com/python-modules/python-imread-opencv
在本教程中，我们将详细学习如何使用 OpenCV-Python 的imread()方法，以及使用imread()方法加载图像的不同方式。
什么是 Python imread()？
imread()是 OpenCV-Python 库中最有用和最常用的方法之一。它用于从指定文件加载 Python 程序中的图像。它在成功加载图像后返回一个numpy.ndarray (NumPy N 维数组)。当加载的图像是彩色图像时，该numpy.ndarray是一个三维数组，当加载的图像是灰度图像时，该二维数组。
导入 OpenCV 以使用 Python imread()
为了使用 Python imread()方法，我们需要 opencv-python 库的cv2模块。为此，我们必须首先在虚拟环境或本地系统中安装opencv-python库，然后在 Python 程序中导入cv2模块。以下是安装和导入它的命令:
# Installing the opencv-python library
pip install opencv-python
# Importing the cv2 module
import cv2
Python imread()方法的语法
以下是 Python imread()方法的正确语法:
cv2.imread(filename, flag)
参数: cv2.imread()方法需要两个参数。这两个参数如下:
filename是第一个要传递的强制参数，它采用一个字符串值来表示图像文件(或带扩展名的图像名称)的路径。注意:如果不在工作目录中，我们必须传递图像文件的完整路径。flag是第二个要传递的可选参数，通常有三种类型的值:cv2.IMREAD_COLOR、cv2.IMREAD_GRAYSCALE和cv2.IMREAD_UNCHANGED。实际上，这个flag定义了读取图像的模式。注:默认情况下，该flag参数的值为cv2.IMREAD_COLOR或1。
返回值: cv2.imread()如果图片加载成功，方法返回一个numpy.ndarray (NumPy N 维数组)。注意:如果图像由于任何原因(如文件丢失、权限不当、不支持或格式无效)无法读取，则返回一个空矩阵(Mat::data==NULL)。
Python imread()方法支持的图像格式
以下是cv2.imread()方法支持的图像格式:
- 便携式网络显卡–
*.png - 便携图像格式–
*.pbm、*.pgm、*.ppm、*.pxm、*.pnm - Windows 位图–
*.bmp - JPEG 文件–
*.jpeg、*.jpg、*.jpe - JPEG 2000 文件–
*.jp2 - WebP–
*.webp - PFM 档案–
*.pfm - 太阳光栅–
*.sr、*.ras - OpenEXR 镜像文件–
*.exr - HDR 辐射——
*.hdr，*.pic - TIFF 文件–
*.tiff，*.tif
注意:对.JPEG格式图像的读取取决于系统、平台或环境(如 x86/ARM)上安装的 OpenCV 库的版本等。最重要的是图像的类型不是由图像文件的扩展名决定的，而是由cv2.imread()方法返回的numpy.ndarray的内容决定的。
让我们用 Python 代码实现一切**……
Sample Image
使用“flag = cv2”加载图像。IMREAD_COLOR"
当flag以值cv2.IMREAD_COLOR传递时，图像首先被转换为没有透明通道的三通道 BGR 彩色图像，然后被加载到程序中。
这是flag参数的默认值。cv2.IMREAD_COLOR对应的整数值是1。我们也可以用1来代替cv2.IMREAD_COLOR。注意:我们正在使用.shape方法来访问图像的形状。它返回一个行数、列数和通道数的元组。
img = cv2.imread('sample_image.png', cv2.IMREAD_COLOR)
print("Shape of the loaded image is", img.shape)
输出:
Shape of the loaded image is (512, 512, 3)
输出元组有三个值512是样本图像中的行数(图像的高度)512是列数(图像的宽度)3是通道数。
这里加载的图像只有三个通道蓝绿色&红色，因为标志值是cv2.IMREAD_COLOR。
第四个通道是透明或 alpha 通道，即使它出现在样本图像中，也会被忽略。
使用“flag = cv2”加载图像。im read _ gray
当用值cv2.IMREAD_GRAYSCALE传递flag 时，图像首先被转换成单通道灰度图像，然后加载到程序中。cv2.IMREAD_GRAYSCALE对应的整数值是0我们也可以用0代替cv2.IMREAD_GRAYSCALE。
img = cv2.imread('sample_image.png', cv2.IMREAD_GRAYSCALE)
print("Shape of the loaded image is", img.shape)
输出:
Shape of the loaded image is (512, 512)
输出元组只有两个值512是样本图像中的行数，512是列数。当flag值为0或cv2.IMREAD_GRAYSCALE时，无论传递给cv2.imread()方法的输入样本图像如何，图像都将被加载为灰度图像。
使用“flag = cv2”加载图像。IMREAD_UNCHANGED
当用值cv2.IMREAD_UNCHANGED传递flag 时，图像就和 alpha 或透明通道(如果有的话)一起加载到程序中。cv2.IMREAD_UNCHANGED对应的整数值是-1我们也可以用-1代替cv2.IMREAD_UNCHANGED。
img = cv2.imread('sample_image.png', cv2.IMREAD_UNCHANGED)
print("Shape of the loaded image is",img.shape)
输出:
Shape of the loaded image is (512, 512, 4)
输出元组有三个值512是样本图像中的行数(图像的高度)512是列数(图像的宽度)4是通道数。
这里加载的图像有四个通道蓝色、绿色、红色&透明度，因为标志值是cv2.IMREAD_UNCHANGED。第四个通道是透明或 alpha 通道，如果它出现在样本图像中，它将被包括在内。
结论
在本教程中，您已经学习了通过使用不同的flag参数值来加载图像的不同方法。请记住两件事:如果您当前的工作目录中没有示例图像文件，您必须传递它的完整路径；您还可以将整数值[1, 0, & -1]传递给对应于[cv2.IMREAD_COLOR, cv2.IMREAD_GRAYSCALE, & cv2.IMREAD_UNCHANGED]的flag参数。
希望您对使用您自己的示例图像更多地尝试 Python imread()方法和opencv-python库的其他方法感到兴奋！
Python 增量为 1
原文：https://www.askpython.com/python/examples/python-increment-by-1
在 Python 中，要将变量增加 1，可以使用增强的赋值操作符+=。该运算符将右操作数与左操作数相加，并将结果赋给左操作数。例如，如果您有一个值为 5 的变量x，您可以使用下面的代码将它递增 1:
x += 1
这段代码执行后，x的值将为 6。您还可以将+=操作符用于其他操作数，例如字符串、列表和字典。例如，如果您有一个值为“hello”的字符串s,您可以通过在它后面追加字符“a”来将它递增 1:
s = "hello"
s += "a"
这段代码执行后，s的值将是“helloa”。
随着列表增加 1
如果您有一个包含元素[1，2，3]的列表l,您可以通过向它追加元素 4 来将它递增 1:
l = [1, 2, 3]
l += [4]
这段代码执行后，l的值将是[1，2，3，4]。
字典增量为 1
让我们看另一个用字典递增 1 的例子。
d = {"a": 1, "b": 2}
d += {"c": 3}
print(d)
在这种情况下，+=操作符将字典d与字典{"c": 3}合并，得到字典{"a": 1，" b": 2，" c": 3}。
总的来说，在 Python 中，要将变量增加 1，可以使用增加的赋值操作符+=。该运算符将右操作数与左操作数相加，并将结果赋给左操作数，允许您将不同类型的变量递增 1。
Python 增量运算
原文：https://www.askpython.com/python/examples/python-increment-operation
如何执行 Python 增量操作？如果您来自 C++或 Java 之类的语言，您可能想尝试将类似的增量功能扩展到 Python。
但是，正如我们将在本文中看到的，这并不完全相同。让我们看看如何在 Python 中尝试使用 Increment ( ++)操作的类似功能。
Python 增量
在讨论确切的区别之前，我们先来看看如何在 Python 中增加一个变量。
下面的代码展示了几乎所有程序员如何在 Python 中递增整数或类似的变量。
>>> a = 10
>>> print(a)
10
>>> a += 1
>>> print(a)
11
>>> a += 100
>>> print(a)
111
>>> b = 'Hello'
>>> b += 1
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: can only concatenate str (not "int") to str
>>> b += ' from AskPython'
>>> b
'Hello from AskPython'
我们已经在连续的步骤中增加了整数变量a。此外，由于+ 操作符也代表字符串的连接，我们也可以在适当的位置追加到字符串中！
我们可以使用a++将a后加 1 吗？
>>> a++
File "<stdin>", line 1
a++
^
SyntaxError: invalid syntax
这里有一个问题。Python 的设计不允许使用++“操作符”。在 C++ / Java 中被称为增量运算符的++术语在 Python 中没有一席之地。
Python 中为什么没有++运算符？
如果你想更详细地理解这一点，你需要有一些编程语言设计的背景。
Python 中不包含++操作符的选项是一个设计决策。负责用 Python 语言创建要素的人认为没有必要引入 CPP 风格的增量运算符。
当 Python 解释器从我们的输入中解析a++符号时，它以如下方式被解释:
- 由于二元运算符
+是加法运算符，a++将被视为a、+和+。但是 Python 希望在第一个+操作符后有一个数字。因此，它会在a++上给出一个语法错误，因为第二个+不是一个数字。
类似地，预增量++a，将被这样处理:
- Python 中的一元
+运算符指的是 identity 运算符。这只是返回它后面的整数。这就是为什么它是整数上的一个恒等运算 - 比如
+5的值简单来说就是5，对于+-5来说就是-5。这是一个一元运算符，适用于实数 ++a将被解析为+和+a，但是第二个+a再次被处理为(+a)，也就是简单的a- 因此，
+(+(a))简单地计算为a。
因此，即使我们想将a的值增加 1，我们也不能使用++符号来实现，因为这种运算符并不存在。
因此，我们必须使用+=操作符来完成这种增量。
a += 1
a -= 1
同样的逻辑也适用于减量操作。
+=运算如何求值？
你可能认为既然有一个=符号，它可能是一个赋值语句。
但是，这不是一个常规的赋值语句。这被称为扩充赋值语句。
在常规赋值语句中，先计算右边，然后再把它赋给左边。
# 2 + 3 is evaluated to 5, before assigning to a
a = 2 + 3
但是，在这个扩充的赋值语句中，先计算左侧，然后再计算右侧。这样做是为了将更新后的值就地写入左侧。
*# Reads the value of a, before adding 3 to it in-place
a += 3*
这是增加变量的唯一方法，不需要使用像a = a + 1这样的重新赋值语句。但是在这里，总的来说，选项并不重要，因为解释器会在运行时优化代码。
结论
在本文中，我们了解了如何在 Python 中使用 increment 操作，以及为什么不支持++和--操作符。
参考
- 关于在 Python 上使用增量的 StackOverflow 问题
- Python 文档关于赋值语句
Python 中的缩进
Python 中缩进是用来创建一组语句的。很多流行的语言比如 C，Java 都用大括号({ })来定义代码块，Python 用缩进。
Python 中的缩进是什么？
Python 中的缩进指的是行首的空白。我们可以使用空格或制表符来创建缩进。在编写 Python 代码时，我们必须为函数和循环定义一组语句。这是通过适当缩进该块的语句来实现的。
行首的前导空格(空格和制表符)用于确定该行的缩进级别。我们必须增加缩进级别来对该代码块的语句进行分组。同样，减少缩进以关闭分组。
四个空格或一个制表符用于创建或增加代码的缩进级别。让我们看一个例子来理解代码缩进和语句分组。
def foo():
print("Hi")
if True:
print("true")
else:
print("false")
print("Done")
Python Indentation
Python 缩进规则
- 我们不能使用反斜杠将缩进分成多行。
- Python 代码第一行不能有缩进，会抛出
IndentationError。 - 你应该避免混合制表符和空格来创建缩进。这是因为非 Unix 系统中的文本编辑器行为不同，混合它们会导致错误的缩进。
- 最好使用空格进行缩进，而不是制表符。
- 最佳实践是在第一次缩进时使用 4 个空格，然后不断添加额外的 4 个空格来增加缩进。
Python 中缩进的好处
- 在大多数编程语言中，缩进被用来恰当地组织代码。在 Python 中，它用于分组，使代码自动变漂亮。
- Python 缩进规则非常简单。大多数 Python IDEs 会自动为您缩进代码，因此编写适当缩进的代码非常容易。
Python 中缩进的缺点
- 因为空格是用于缩进的，如果代码很大并且缩进被破坏了，那么修复它真的很繁琐。这主要是通过从在线资源、Word 文档或 PDF 文件中复制代码来实现的。
- 大多数流行的编程语言都使用大括号进行缩进，所以任何来自不同编程世界的人一开始都会发现很难适应使用空格进行缩进的想法。
Python for 循环中的缩进
我们必须增加 for 循环中的缩进量，以便将代码组合在一起。让我们看一个在 python for 循环中缩进的例子。
def print_numbers(x, y):
for i in range(x, y):
print(i)
IndentationError 错误示例
让我们看看 Python 代码中 IndentationError 的一些例子。
>>> x = 10
File "<stdin>", line 1
x = 10
^
IndentationError: unexpected indent
>>>
代码的第一行不能有缩进。这就是抛出 IndentationError 的原因。
if True:
print("true")
print("Hi")
else:
print("false")
Python IndentationError
if 块中的代码行具有不同的缩进级别，因此产生了 IndentationError。
if True:
print("true")
else:
print("false")
print("Done")
Python Indentation Level Error Unindent
这里，最后一个 print 语句有一些缩进，但是没有附加它的语句，因此抛出了缩进错误。
if True:
print("true")
else:
print("false")
输出:
File "/Users/pankaj/Documents/PycharmProjects/PythonTutorialPro/hello-world/indent.py", line 2
print("true")
^
IndentationError: expected an indented block
摘要
Python 缩进让我们的代码很漂亮。它还用于将语句分组到一个代码块中。这导致了总是编写漂亮代码的习惯，因为这不是一个必须具备的特性，而是代码必须具备的要求。
下一步是什么？
参考资料:
Python index()方法
原文：https://www.askpython.com/python/list/python-index-method
介绍
所以今天在本教程中，我们将讨论 Python index()方法。
为字符串、列表和元组类定义了index()方法。对于字符串，该方法返回给定子字符串出现的最小索引。而对于列表和元组，该方法返回给定对象所在位置的最小索引。
使用 Python index()方法
从上面的定义可以清楚地看出，Python index()方法只是为 iterables 定义的。因此，它不适用于字典或集合，因为它们不遵循索引顺序。
对于一个可迭代，使用 Python index()方法的语法如下所示。
iterable.index(sub, start, end)
这里，
- iterable 可以是任何对象，如列表、字符串或元组，
- sub 是 iterable 中要找到其最小索引的子字符串或项目，
- start 是搜索开始的起始索引。如果没有指定，它默认设置为 0，
- end 是搜索将进行到的最后一个索引。如果没有指定，它的值被认为等于 iterable 的长度。
请注意:如果在 start to end index 范围内没有找到 object sub，该方法会引发一个ValueError。
Python 中 index()方法的示例
现在我们知道了对任何可迭代使用index()方法的语法，让我们通过一些例子来尝试使用它。
1.列表索引()
index()方法是列表类的成员函数。并且广泛用于搜索列表中的值。
# initialisation of variables
list1 = [9, 2, 7, 6, 8, 2, 3, 5, 1]
#index() with list
print("Value 2 first found at index: ", list1.index(2))
print("Value 2 first found at index(within range 4-7) : ", list1.index(2,4,7))
输出:
Value 2 first found at index: 1
Value 2 first found at index(within range 4-7) : 5
在上面的例子中，我们首先初始化了一个列表list1。接下来，我们试图得到值 2 出现的最小索引。
当我们试图寻找没有指定开始和结束的值 2 时，程序返回一个索引 1 。因此，很明显，在整个列表中，index()方法返回的是存在 2 的最小索引。
接下来对于一个指定的范围( 4-7 ，该方法给我们一个值 5 。这是 2 在列表中第二次出现的索引。但在 4-7 的范围内，5 号指数是最小的。
注意:index()方法对元组也以同样的方式工作。
2.字符串 Python 索引()
到了字符串，成员函数 Python index()返回指定子字符串开始处的最小索引。
让我们看一个例子。
# initialisation of string
str1 = "Python Python"
#index() with string
print("sub-string 'Py' first found at index: ", str1.index('Py'))
print("sub-string 'Py' first found at index(within range 5-10) : ", str1.index('Py',5,10))
输出:
sub-string 'Py' first found at index: 0
sub-string 'Py' first found at index(within range 5-10) : 7
在这里，对于未指定范围的第一次搜索，Python index()方法在搜索子字符串“ Py 时返回 0。正如我们所见，这是字符串string1中出现“ Py 的最小索引。
当我们指定一个范围(此处为 5-10 )时，该方法相应地从第 5 到第 10 个索引搜索“Py”。从输出中可以清楚地看到，该函数在第 7 个位置找到了子字符串的开始。
结论
对于任何 iterable，值得注意的是，如果在给定的 iterable 中没有找到传递的 sub(object) ，则引发ValueError。
所以在本教程中，我们学习了 Python 中的index()方法的工作和使用。关于这个话题的任何进一步的问题，请在下面随意评论。
参考
- Python 列表–要知道的 15 件事，
- Python 字符串–教程，
- Python 字符串索引()–日志开发帖子，
- Python 中的数组索引——堆栈溢出问题。
Python 输入()函数
原文：https://www.askpython.com/python/built-in-methods/python-input-function
开发人员/程序员经常需要接受用户的输入来进一步处理应用程序。
Python 提供了一个内置的方法来接受用户的输入。
Python input()函数接受用户的输入。Python 的**builtins.py**包含了 Python input()函数。
语法:
input(prompt)
在 input()函数中，提示是可选的。提示基本上是一个字符串，即在输入前显示的消息。
无论哪个字符串作为参数放在输入函数中，都会在输出屏幕上打印出来。
1.Python input()函数的工作原理
-
一旦解释器遇到 input()函数，它就暂停/停止程序执行，直到用户向程序提供输入。
-
用户输入的输入被自动转换成一个字符串。无论用户输入的是整数还是浮点类型的数据，input()函数都会将其转换为字符串。
-
因此，需要在程序中使用类型转换将其显式转换为另一种数据类型。
2.示例 Python input()函数的基本工作原理
*x = input ()
print("The entered value is:", x)*
输出:
*`10
The entered value is: 10`*
3.将字符串作为参数的 Python input()函数
*name = input('Enter your name: ')
print("Name of the candidate is:", name)*
输出:
*`Enter your name: Safa Mulani
Name of the candidate is: Safa Mulani`*
4.通过接受用户的输入将两个数相乘
*x = input()
y = input()
z = x * y
print("Result is: ", z)*
输出:
*
Python input() Function*
上面的代码片段导致了一个错误，因为 python input()函数将来自用户的输入转换为一个字符串。因此，为了将它转换成整数，我们需要显式地对用户提供的输入进行类型转换。
*x = input("Enter the number1: ")
y = input("Enter the number2: ")
z = int(x) * int(y)
print("Result is: ", z)*
输出:
*`Enter the number1: 10
Enter the number2: 20
Result is: 200`*
结论
因此，在本文中，我们已经了解了 Python input()函数的工作原理。
参考
- Python 输入()函数
- 输入()功能文档
Python 检查模块
原文：https://www.askpython.com/python-modules/python-inspect-module
Python 的**inspect module**提供了活体对象的自省和相同的源代码。
inspect 模块为用户提供了利用其中的函数/方法来获取相同的源代码、提取和解析所需的库文档的功能。
这个模块用于获取关于特定用户程序中的函数、类和模块的信息。这是通过对模块的属性、模块的类/方法等进行检查来实现的。
Python 检查模块功能
**Introspection of a module****Introspection of classes in a module****Introspection of methods/functions in a class****Introspection of objects of a class****Retrieval of source of a class****Retrieval of source of a method/function****Fetching the method signature****Documentation of Strings for a class****Introspecting Class Hierarchies****Introspection of Frames and Stacks in the run-time environment**
1.模块的自省
最初，我们需要创建一个样本模块以及用于自省的类/函数，即 test.py
test.py
def funct(arg1, arg2 = 'default', *args):
#module-level function
x = arg1 * 1
return x
class P(object):
def __init__(self, city):
self.city = city
def get_city(self):
return self.city
obj_p = P('sample_instance')
class Q(P):
def country(self):
return ("Hello")
def get_country(self):
return 'Q(' + self.city + ')'
然后我们将使用 inspect.getmembers()函数对创建的模块进行自省。
注意:包含样本模块的 python 文件和包含自检代码的文件要放在同一个目录下。
模块自检代码:
import inspect
import test
for city, data in inspect.getmembers(test):
if city.startswith('__'):
continue
print('{} : {!r}'.format(city, data))
输出:
P : <class 'test.P'>
Q : <class 'test.Q'>
funct : <function funct at 0x000001ED62A2EAF0>
obj_p : <test.P object at 0x000001ED62A6A640>
2.模块中类的自省
**getmembers()**函数和**isclass**属性标识符用于检查模块中的类。
import inspect
import test
for key, data in inspect.getmembers(test, inspect.isclass):
print('{} : {!r}'.format(key, data))
输出:
P : <class 'test.P'>
Q : <class 'test.Q'>
3.类中方法/函数的自省
**getmembers()**函数和**isfunction**属性标识符用于检查模块中的类。
import inspect
from pprint import pprint
import test
pprint(inspect.getmembers(test.P, inspect.isfunction))
输出:
[('__init__', <function P.__init__ at 0x000001D519CA7CA0>),
('get_city', <function P.get_city at 0x000001D519CA7D30>)]
4.类对象的内省
import inspect
from pprint import pprint
import test
result = test.P(city='inspect_getmembers')
pprint(inspect.getmembers(result, inspect.ismethod))
输出:
[('__init__',
<bound method P.__init__ of <test.P object at 0x00000175A62C5250>>),
('get_city',
<bound method P.get_city of <test.P object at 0x00000175A62C5250>>)]
5.检索一个类的源代码
**getsource()**函数返回特定模块/类的源代码。
import inspect
import test
print(inspect.getsource(test.Q))
输出:
class Q(P):
def country(self):
return ("Hello")
def get_country(self):
return 'Q(' + self.city + ')'
6.检索方法/函数的源代码
import inspect
import test
print(inspect.getsource(test.Q.get_city))
输出:
def get_city(self):
return self.city
7.获取方法签名
**inspect.signature()** 方法返回该方法的签名，从而使用户容易理解传递给该方法的参数类型。
import inspect
import test
print(inspect.signature(test.funct))
输出:
(arg1, arg2='default', *args)
8.类的字符串文档
inspect 模块的**getdoc()**函数提取一个特定的类及其函数来表示给最终用户。
import inspect
import test
print('P.__doc__:')
print(test.P.__doc__)
print()
print('Documentation String(P):')
print(inspect.getdoc(test.P))
输出:
P.__doc__:
Implementation of class P
Documentation String(P):
Implementation of class P
9.反思类层次结构
**getclasstree()**方法返回类的层次结构及其依赖关系。它使用来自给定类的元组和列表创建一个树形结构。
import inspect
import test
class S(test.Q):
pass
class T(S, test.P):
pass
def print_class_tree(tree, indent=-1):
if isinstance(tree, list):
for node in tree:
print_class_tree(node, indent+1)
else:
print( ' ' * indent, tree[0].__name__ )
if __name__ == '__main__':
print( 'P, Q, S, T:')
print_class_tree(inspect.getclasstree([test.P, test.Q, S, T]))
输出:
P, Q, S, T:
object
P
T
Q
S
T
10.运行时环境中帧和堆栈的自检
inspect 模块还在函数执行期间检查程序的动态环境。这些函数主要处理调用堆栈和调用框架。
**currentframe()**描述当前正在执行的函数的堆栈顶部的帧。**getargvalues()**结果是一个元组，其中包含参数的名称，以及来自帧的局部值的字典。
import inspect
def recurse(threshold):
x = '.' * threshold
print (threshold, inspect.getargvalues(inspect.currentframe()))
if threshold <= 0:
return
recurse(threshold - 1)
return
if __name__ == '__main__':
recurse(4)
输出:
4 ArgInfo(args=['threshold'], varargs=None, keywords=None, locals={'threshold': 4, 'x': '....'})
3 ArgInfo(args=['threshold'], varargs=None, keywords=None, locals={'threshold': 3, 'x': '...'})
2 ArgInfo(args=['threshold'], varargs=None, keywords=None, locals={'threshold': 2, 'x': '..'})
1 ArgInfo(args=['threshold'], varargs=None, keywords=None, locals={'threshold': 1, 'x': '.'})
0 ArgInfo(args=['threshold'], varargs=None, keywords=None, locals={'threshold': 0, 'x': ''})
结论
因此，在本文中，我们已经理解了 Python 的 inspect 模块所提供的功能。
参考
- Python 检查模块
- 检查模块文件
Python IO 模块:完整的实用参考
原文：https://www.askpython.com/python-modules/python-io-module
大家好！在今天的文章中，我们将学习如何使用 Python IO 模块。
当你想执行与文件相关的 I/O 操作(如文件读/写)时，这个模块非常有用
虽然您可以使用普通的read()和write()方法来读/写文件，但是这个模块在这些操作方面给了我们更多的灵活性。
为了更好地理解这个模块，我们举几个例子。
Python IO 模块
这个模块是标准库的一部分，所以没有必要使用 pip 单独安装它。
要导入 io 模块，我们可以执行以下操作:
import io
在io模块中，有两个常用类对我们非常有用:
- 字节序 - >对字节数据的 I/O 操作
- StringIO - >对字符串数据的 I/O 操作
我们可以使用io.BytesIO和io.StringIO来访问这些类。
让我们一个一个来看看。
Python BytesIO 类
在这里，我们可以用字节(b'')的形式保存我们的数据。当我们使用io.BytesIO时，数据保存在内存缓冲区中。
我们可以使用构造函数获得字节流的实例:
import io
bytes_stream = io.BytesIO(b'Hello from Journaldev\x0AHow are you?')
请注意，我们正在传递一个字节字符串(以b为前缀)。
现在，bytes_stream只是一个字节流的句柄。
为了实际打印缓冲区内的数据，我们需要使用bytes_stream.getvalue()。
import io
bytes_stream = io.BytesIO(b'Hello from Journaldev\x0AHow are you?')
print(bytes_stream.getvalue())
这里，getvalue()从句柄获取字节串的值。
由于字节字符串\x0A是换行符(' \n ')的 ASCII 表示，我们得到以下输出:
输出
b'Hello from Journaldev\nHow are you?'
现在，每当我们完成工作时，关闭我们的缓冲句柄总是一个好习惯。
这也是为了确保我们释放了分配给缓冲区的所有内存。
要关闭缓冲区，请使用:
bytes_stream.close()
现在让我们看看 StringIO 类。
Python StringIO 类
与io.BytesIO类似，io.StringIO类可以从 StringIO 缓冲区读取与字符串相关的数据。
import io
string_stream = io.StringIO("Hello from Journaldev\nHow are you?")
我们可以使用string_stream.read()从字符串缓冲区读取，使用string_stream.write()写入。这非常类似于从文件中读取/写入！
我们可以使用getvalue()打印内容。
import io
string_stream = io.StringIO("Hello from Journaldev\nHow are you?")
# Print old content of buffer
print(f'Initially, buffer: {string_stream.getvalue()}')
# Write to the StringIO buffer
string_stream.write('This will overwrite the old content of the buffer if the length of this string exceeds the old content')
print(f'Finally, buffer: {string_stream.getvalue()}')
# Close the buffer
string_stream.close()
输出
Initially, buffer: Hello from Journaldev
How are you?
Finally, buffer: This will overwrite the old content of the buffer if the length of this string exceeds the old content
由于我们正在写入同一个缓冲区，新的内容显然会覆盖旧的内容！
从 StringIO 缓冲区读取
与写入类似，我们也可以使用buffer.read()从 StringIO 缓冲区读取。
import io
input = io.StringIO('This goes into the read buffer.')
print(input.read())
输出
This goes into the read buffer.
如您所见，内容现在在读缓冲区中，它是使用buffer.read()打印的。
使用 io 读取文件
我们也可以使用io.open()方法直接从文件中读取，类似于从文件对象中读取。
这里，该模块为我们提供了缓冲与非缓冲读取的选择。
例如，下面将通过设置buffering = SIZE使用缓冲读取来读取文件。如果SIZE = 0，这将意味着没有缓冲！
假设sample.txt有以下内容:
Hello from JournalDev!
How are you?
This is the last line.
import io
# Read from a text file in binary format using io.open()
# We read / write using a buffer size of 5 bytes
file = io.open("sample.txt", "rb", buffering = 5)
print(file.read())
# Close the file
file.close()
输出
b'Hello from JournalDev!\nHow are you?\nThis is the last line.\n'
如您所见，文件已被成功读取！这里，io将使用大约 5 个字节的缓冲区读取文件。
使用 io.open()与 os.open()
io.open()函数是执行 I/O 操作的首选方法，因为它是一个高级 Pythonic 接口。
相反，os.open()将执行对open()函数的系统调用。这将返回一个文件描述符，它不能像io句柄对象一样使用。
由于io.open()是os.open()的包装函数，使用这样的包装函数通常是个好习惯，因为它们会自动为您处理许多错误。
结论
在本文中，我们学习了如何使用 Python IO 模块，它有两个主要的类——io.BytesIO和io.StringIO,用于在缓冲区中读写字节和字符串数据。
参考
- IO 模块上的 Python 文档
- 关于 Python IO 模块的 JournalDev 文章
Python 的 isdecimal()方法
原文：https://www.askpython.com/python/built-in-methods/python-isdecimal-method
介绍
在本教程中，我们将介绍 python isdecimal()方法。如果用户想检查一个给定的字符串是否包含一个数字，或者更确切地说，是否包含一个十进制数字，该怎么办？当用户需要将字符串转换为任何其他数字类型，如整数或浮点数等时，就会出现这种情况..
作为这个问题的解决方案， Python 自带一个内置的检查方法，isdecimal()。让我们深入研究这种方法，从而理解这种方法是如何工作的，并据此加以运用。
Python isdecimal()方法基础
一般来说，Python isdecimal()方法直接检查指定字符串中的所有字符是否都是十进制字符。如果是，则该方法返回true，否则，返回false。
Python isdecimal()方法的语法
让我们看看 Python isdecimal()方法的语法，然后我们可以使用这个方法。
status = str.isdecimal( )
这里:
str是我们要检查其是否仅由十进制字符组成的字符串status存储由isdecimal()方法返回的值。对于所有十进制字符，为真，否则，为假。
注意:在这里，状态只有真或假，因此状态的类型是bool。
isdecimal()方法的基本示例
这里有一个小例子，解释了如何在 Python 中对字符串使用isdecimal()方法。
string1="1010"
print("String is: ",string1)
print("Result: ",string1.isdecimal())
string2="a10101"
print("String is: ",string2)
print("Result: ",string2.isdecimal())
输出:
String is: 1010
Result: True
String is: a10101
Result: False
这里:
- 字符串 1 全部由十进制字符组成。因此，
string1.isdecimal()语句返回一个True结果 - 鉴于，字符串 2 中有一个字符‘a’。由于字符串 2 并不全由十进制字符组成，所以在这种情况下，结果是
False。
注意:Python 中的isdecimal()方法不会将分数、下标、上标或任何其他 Unicode 实现的字符视为十进制或数字字符。因此，对于字符串中出现的任何数字字符，该方法返回False。
Python 是如何工作的
下面的代码片段说明了 Python 中用于字符串的isdecimal()方法是如何工作的，以及它返回什么。
# . is not considered as decimal character
string1="55.55"
print("String is: ",string1)
print("Result: ",string1.isdecimal())
#Pure character string
string2="AskPython"
print("String is: ",string2)
print("Result: ",string2.isdecimal())
#U+2082 unicode for subscript 2
string3="222\u2082"
print("String is: ",string3)
print("Result: ",string3.isdecimal())
#U+2074 unicode for superscript 4
string4="34\u2074"
print("String is: ",string4)
print("Result: ",string4.isdecimal())
#U+2152unicode for 1/10 fraction
string5="10\u2152"
print("String is: ",string5)
print("Result: ",string5.isdecimal())
#@ not considered as decimal character
string6="@1234"
print("String is: ",string6)
print("Result: ",string6.isdecimal())
输出:
isdecimal() Example Output
在上面的代码中:
- 对于字符串 1 ，
isdecimal()方法返回一个false值，因为点()。)出现在数字之间的字符。该方法认为它不是十进制字符 - 同样对于字符串 2 ，该字符串完全或纯粹由字符组成，因此该方法返回一个
false结果 - 对于所有的琴弦、琴弦 3 、琴弦 4 和琴弦 5 。
isdecimal()方法返回false,因为它们都包含对应于非数字字符的 Unicode 值 - 最后，对于字符串 6 ，该方法也返回一个
false，因为该字符串包含“ @ ”字符，这也是一个非十进制字符。
结论
因此，在本教程中，我们学习了 Python 中的内置字符串isdecimal()方法，它是如何使用以及如何工作的。如有任何问题，欢迎在下面评论。
参考
- https://www.journaldev.com/24032/python-string-isdecimal
- https://stack overflow . com/questions/22789392/str-is decimal-and-str-is digit-difference-example
- https://stack overflow . com/questions/47113787/difference-between-isnumeric-and-is decimal-in-python/47113836
Python isidentifier()方法
原文：https://www.askpython.com/python/string/python-isidentifier-method
因此，今天在本教程中，我们将介绍Python 的 isidentifier()方法。
介绍
基本上，标识符是用户给任何变量、类、对象、函数等的名字。这些名称对于唯一识别单个变量、类等非常重要。
因此，命名是任何变量、类、函数、对象等声明的重要部分。Python 对用户进行了限制，并为此命名过程提供了一些基本准则。
了解 Python isidentifier()方法
isidentifier()方法检查所提供的字符串是否有资格成为标识符，如果是，则相应地返回 true ，否则返回 false 。
下面给出了使用 Python isidentifier() 方法的语法。
result = str.isidentifier()
这里，
- result 存储方法返回的布尔值(真或假)，
- str 是我们需要检查它是否是标识符的字符串。
使用 Python isidentifier()方法
现在我们已经对标识符的概念和 Python isidentifier()方法有了基本的了解，让我们举一些例子来理解这个方法的工作原理。
string1 = "Askpython"
print(f"Is {string1} a valid identifier? ", string1.isidentifier())
string2 = "i" #an identifier may be of any length > 0
print(f"Is {string2} a valid identifier? ", string2.isidentifier())
string3 = "" #short length not allowed
print(f"Is {string3} a valid identifier? ", string3.isidentifier())
string4 = "_abcd1234" #an identifier may start with an underscore
print(f"Is {string4} a valid identifier? ", string4.isidentifier())
string5 = "1976" #strings starting with numbers are not identifiers
print(f"Is {string5} a valid identifier? ", string5.isidentifier())
输出:
Is Askpython a valid identifier? True
Is i a valid identifier? True
Is a valid identifier? False
Is _abcd1234 a valid identifier? True
Is 1976 a valid identifier? False
这里，
- 对于string 1–‘ask python’是一个有效的标识符，因为它以一个字符开头，并且不包含任何特殊字符，
- 对于string 2–‘I’是一个有效的标识符，因为它不包含任何特殊字符，并且有足够的长度，
- 对于string 3–该字符串不包含任何字符，因此长度为 0。字符串中应该至少有一个字符有资格作为标识符，
- 对于string 4–它是一个有效的标识符，因为它以下划线(' _ ')开头，并且包含字符和数字，
- 对于字符串 5–‘1976’不是有效的标识符，因为它以数字开头。
结论
这就是本教程的内容。我们学习了内置的 Python isidentifier()方法。我们强烈建议读者浏览下面的参考链接。isidentifier()方法是一个 Python 字符串方法。
如有任何其他问题，请使用下面的评论随时联系。
参考
- String is identifier()–Python 文档，
- 标识符和关键字–Python 文档，
- 支持非 ASCII 标识符-PEP-3131，
- python 化地检查变量名是否有效–stack overflow 问题。
Python isinstance()方法
原文：https://www.askpython.com/python/built-in-methods/python-isinstance
介绍
在本教程中，我们将学习 Python isinstance()方法。用户可能会遇到一些情况，需要判断一个对象是否是一个特定类的实例，主要是在 继承 中。Python 提供了一个内置的方法做同样的检查，名为isinstance()。
让我们开始理解这个方法。
Python isinstance()基础知识
顾名思义，Python isinstance()方法是一个内置方法，它检查一个对象是否是任何特定类的实例。现在，让我们看看使用isinstance()方法的语法，
语法，
isinstance( object_name , class_name)
这里，
- 是我们需要检查它是否是某个类的实例的对象，
class_name是我们需要检查对象所属的类，- 如果 object_name 是 class_name 的实例，则
isinstance()方法返回 true ，否则返回 false 。
Python isinstance()的示例
所以，现在我们已经完成了 Python isinstance()方法的基本定义和语法。让我们看一些例子来更好地理解这个方法是如何工作的。
1.在 Python 中使用 isinstance()和本机类
现在，让我们看看当我们对 python 中的本机类使用isinstance()方法时会发生什么，如 int 、 float 、 str 、 list 、 dict 和 tuple 。
i=10
f=55.55
s="AskPython"
l=[1,2,3,4,5]
d={0:"n", 1:"y"}
t=(1,2,3,4)
print("isinstance(i,int)=",isinstance(i,int))
print("isinstance(f,int)=",isinstance(f,float))
print("isinstance(s,int)=",isinstance(s,str))
print("isinstance(l,int)=",isinstance(l,list))
print("isinstance(d,int)=",isinstance(d,dict))
print("isinstance(t,int)=",isinstance(t,tuple))
输出:
Python isinstance() for Native classes
让我们理解这里发生了什么:
- 首先，我们已经用一些值初始化了不同类型的变量
- 之后，我们检查它们是否是相应类的实例。正如预期的那样，对于所有的检查，我们都得到正输出，也就是说， true 。
2.对用户定义的类使用 isinstance()
现在让我们创建一些类和它们的实例来检查我们是否得到了想要的输出，以及 isinstance 方法在这种情况下是如何工作的。
class dt:
dd=10
mm=2
yyyy=2002
class tm:
hr=12
min=56
sec=34
#instance creation
a=dt()
b=tm()
#check is a is instance of dt class
print("a is instance of dt?",isinstance(a,dt))
#check is a is instance of tm class
print("a is instance of tm?",isinstance(a,tm))
#check is b is instance of tm class
print("b is instance of tm?",isinstance(b,tm))
#check is b is instance of dt class
print("b is instance of dt?",isinstance(b,dt))
输出:
Example With User-Defined Classes
在这段代码中:
- 我们创建了两个分别代表日期和时间的类
dt和tm - 完成之后，我们创建两个类的两个对象，分别命名为 a 和 b
- 然后我们检查对象 a 和 b 是否是
dt和tm类的实例。使用不同的组合，我们试图解释如果对象不是指定类的实例会发生什么 - 正如我们所看到的，我们的代码确认 a 和 b 分别是类 dt 和 tm 的实例。
- 但是当我们试图检查 a 和 b 是否分别是 tm 和 dt 类的实例时，方法
instance()返回 false 。也就是相反。
3.对多个类使用 isinstance()
Python isinstance()方法还提供了一种方法，如果我们想检查一个对象是否是某个给定类中某个类的实例。
在这种情况下，我们需要传递一个必需类的元组。如果对象是任何类的实例，该方法将返回true，否则返回false。
class dt:
dd=10
mm=2
yyyy=2002
class tm:
hr=12
min=56
sec=34
#instance creation
a=dt()
b=tm()
#check is a is instance of dt or tm class
print("a is instance of dt or tm?",isinstance(a,(dt,tm)))
#check is b is instance of dt or tm class
print("b is instance of dt or tm?",isinstance(b,(dt,tm)))
输出:
a is instance of dt or tm? True
b is instance of dt or tm? True
在这里，我们使用与我们在前面的例子中使用的相同的类 dt 和 tm 。但是在这种情况下，我们将两个类的元组传递给isinstance()方法。
由于 a 和 b 是我们传递的元组中任何一个类的实例，我们可以在两个输出中看到true。
结论
因此，在本教程中，我们将学习 Python isinstance()方法及其用法和工作原理。希望本教程有助于理解实例的概念。
参考
熊猫的 Python isna()和 notna()函数
原文：https://www.askpython.com/python-modules/pandas/python-isna-notna-functions
读者朋友们，你们好！在本文中，我们将详细关注 Python isna()和 Python notna()函数。所以，让我们开始吧！
在数据科学和机器学习领域，数据分析和预处理起着非常重要的作用。在整个数据预处理过程中，缺失值分析是开发的关键一步。缺失值分析是指从源数据中检测和移除缺失值或 NA 值的过程。
同样，有许多方法可以检测数据集中是否存在缺失值。今天，我们将了解两个易于使用的函数来检测缺失值的存在
- Python isna()函数
- Python notna()函数
在本主题的课程中，我们将使用自行车租赁预测数据集。你可以在这里找到数据集！现在，让我们在下面的部分中逐一查看它们。
1。Python isna()函数
使用 Python isna()函数，我们可以轻松检测到空值或 na 值的存在，即数据集中缺失的值。它是一个布尔函数，查找丢失的值，并在检测到丢失值时返回 TRUE。
看看下面的语法！
dataframe.isna()
举例:
在本例中，我们使用了 isna()函数来检查是否存在缺失值。因为数据没有丢失值，所以返回 FALSE。
import pandas
import os
#Changing the current working directory
os.chdir("D:/Ediwsor_Project - Bike_Rental_Count")
BIKE = pandas.read_csv("day.csv")
BIKE.isna()
输出:
Python isna() function
2.Python notna()函数
利用 Python notna()函数，我们可以很容易地挑出不占缺失值或 na 值的数据。notna()函数返回 TRUE，如果数据没有丢失值，则返回 FALSE(如果遇到 na 值)。
语法:
dataframe.notna()
举例:
如上所述，数据集没有 NA 值。因此，notna()函数返回 TRUE。
import pandas
import os
#Changing the current working directory
os.chdir("D:/Ediwsor_Project - Bike_Rental_Count")
BIKE = pandas.read_csv("day.csv")
BIKE.notna()
输出:
Python notna() function
结论
如果你遇到任何问题，请随时在下面评论。总的来说，使用 Python isna()和 notna()函数，我们可以快速检查缺失值的存在，特别是对于大型数据集。我们可以很容易地计划必要的补救措施来处理缺失的价值观。
更多与 Python 编程相关的帖子，请继续关注我们。在那之前，学习愉快！！🙂
Python issubclass()方法是如何工作的？
原文：https://www.askpython.com/python/built-in-methods/python-issubclass-method
嘿伙计们！今天我们在这里讨论另一个主题为 Python issubclass()方法的教程。
所以让我们直接进入主题。
什么是 Python issubclass()？
Python issubclass()方法是一个内置的方法，它检查传递的类是否是指定classinfo的子类(可能是一个类或类对象的元组)。如果该类是 classinfo 的子类(直接、间接或虚拟),则返回True。否则，返回False。在任何其他情况下，都会引发一个TypeError异常。
issubclass(class, classinfo)
class是我们要确认是否是classinfo的子类的类的名称。如果 classinfo 是一个类元组，该函数对其中的每个类都进行相同的检查。
所以，现在我们对issubclass()有了一个基本的概念，让我们看一些例子来更好地理解。
使用 Python issubclass()方法
在这一节中，我们将讨论使用 Python issubclass()方法的不同方式。对于我们将classinfo作为类名以及类对象的元组传递的两种情况。
1.Python 继承中的 issubclass()
当我们在讨论继承的时候，父类和子类的概念是非常关键的。当一个子从一个父类继承时，它派生或扩展它的属性。此时，子被认为是父类的子类。
因此，当我们想要获得一个类的继承信息时，issubclass()方法就变得很方便。或者检查它是否继承自另一个类。
让我们举个例子。
class Animals:
pass
class Humans(Animals):
pass
class Men(Humans):
pass
class Women(Humans):
pass
print("issubclass(Women, Humans) :", issubclass(Women, Humans))
print("issubclass(Men, Humans) :", issubclass(Men, Humans))
print("issubclass(Women, Men) :", issubclass(Women, Men)) #both are child of the same Humans Class
print("issubclass(Humans, Animals) :", issubclass(Humans, Animals))
print("issubclass(Animals, Humans) :", issubclass(Animals, Humans)) #not the opposite
print("issubclass(Women, Animals) :", issubclass(Women, Animals)) #multi-level inheritance
print("issubclass(Animals, object) :", issubclass(Animals, object)) #object is the baseclass of all classes
输出:
issubclass() with Inheritance – Output
这里的Animals是父类，有一个子类Humans。两个类，Men和Women再次继承自Humans类(多级继承)。因此Men和Women类都是Humans和Animals的子类。而Humans是Animals的子类。
这解释了前 6 的结果。
对于最后一种情况，我们得到了True。这是因为 Python 中的所有类都是object类的子类。
2.Python 是带有类元组的 issubclass()
现在让我们试着把classinfo看作一组类。仔细看下面的例子。
class Animals:
pass
class Humans(Animals):
pass
class Men(Humans):
pass
class Women(Humans):
pass
print("issubclass(Men, (str, list, tuple)) :", issubclass(Men, (str, list, tuple)))
print("issubclass(Men, (str, list, Humans)) :", issubclass(Men, (str, list, Humans)))
print("issubclass(Women, (str, list, Women)) :", issubclass(Women, (str, dict, Women)))
#A class is a subclass of itself in Python
输出:
issubclass() with Tuple Of Classes – Output
这里我们再次举了同一个继承的例子。如前所述，这个时间classinfo是作为一个类对象元组传递的。在这种情况下，该函数检查传递的类是否是 classinfo 元组中任何一个类对象的子类。
对于第一个结果，Men显然不是任何 str 、 list 或 tuple 类的子类。所以我们得到了一个False。
在下一个例子中，男人也不是 str 或 list 的子类，而是人类的子类。因此，我们得到真实的结果。
最后，对于最后一种情况，我们得到 True ，因为Women是它自身的子类。这是因为在 Python 中，每个类都是自身的子类。
结论
今天就到这里吧。我们学习了 Python issubclass()方法。
如果你还有其他问题，请写在下面的评论里。
参考
- Pythonissubclass()–Python 2 文档，
- issubclass()–Python 3 文档，
- Python 历史与设计:为什么 issubclass()而不是 rich comparisons？–stack overflow 问题。
如何使用 Python iter()方法？
在本文中，我们将看看如何使用 Python iter()函数。
通常，我们可能想要使用迭代器，它是一个本身加载 Python 对象的对象。但是，与数组或列表不同，迭代器只是在需要时加载对象。
这被称为延迟加载，或者基于流的加载。这是非常有用的，如果你想节省内存，而不是一次加载整个对象，如果你的对象非常大！
Python iter()的基本语法
我们可以使用iter()函数生成一个可迭代对象的迭代器，比如字典、列表、集合等。
使用 Python iter()函数的基本语法如下:
iterator = iter(iterable)
这将从iterable对象生成一个iterator。
我们可以简单地使用next(iterator)一个接一个地加载对象，直到我们得到StopIteration异常。
另外，注意我们不能使用同一个迭代器再次遍历 iterable。我们必须在迭代之前使用 Python iter()生成另一个迭代器！
使用 Python ITER()——一个简单的例子
下面是一个使用iter()的简单例子。我们将获取一个包含 10 个元素的列表，并逐个加载它们。
a = [i for i in range(10)]
iterator = iter(a)
while True:
try:
out = next(iterator) # Load the next element
print(f"Iterator loaded {out}")
except StopIteration:
# End of loading. Break out of the while loop
print("End of iterator loading!")
break
输出
Iterator loaded 0
Iterator loaded 1
Iterator loaded 2
Iterator loaded 3
Iterator loaded 4
Iterator loaded 5
Iterator loaded 6
Iterator loaded 7
Iterator loaded 8
Iterator loaded 9
End of iterator loading!
正如你所看到的，事实上，它从列表中一个接一个地加载元素，直到我们捕捉到StopIteration异常！
将 Python iter()用于自定义对象
正如我前面提到的，我们可以在任何对象上使用 Python iter()，只要它是可迭代的。
这也适用于自定义对象，只要它满足一些条件。
但是 Python 中任何对象成为 iterable 的条件是什么呢？
- 该对象的类必须有
__iter__()方法。 - 对象的类必须有
__next__()方法。另外，如果达到终止条件，建议您也引发一个StopIteration异常。
现在，Python iter()方法将构造迭代器并调用__iter__()方法。类似地，next(iterator)将在幕后调用__next__()方法。
注意:如果这个类没有没有这些方法，那么它必须至少有__getitem()__方法，整数参数从 0 开始。否则，我们会得到一个TypeError异常。
现在让我们为一个自定义对象写一个类，它生成整数直到一个极限。
class MyClass():
def __init__(self, max_val):
# Set the maximum limit (condition)
# max_val must be a natural number
assert isinstance(max_val, int) and max_val >= 0
self.max_val = max_val
def __iter__(self):
# Called when the iterator is generated
# Initialise the value to 0
self.value = 0
return self
def __next__(self):
# Called when we do next(iterator)
if self.value >= self.max_val:
# Terminating condition
raise StopIteration
self.value += 1
# Return the previously current value
return self.value - 1
# Set the limit to 10
my_obj = MyClass(10)
# An iterator to the object
my_iterator = iter(my_obj)
while True:
try:
val = next(my_obj)
print(f"Iterator Loaded {val}")
except StopIteration:
print("Iterator loading ended!")
break
输出
Iterator Loaded 0
Iterator Loaded 1
Iterator Loaded 2
Iterator Loaded 3
Iterator Loaded 4
Iterator Loaded 5
Iterator Loaded 6
Iterator Loaded 7
Iterator Loaded 8
Iterator Loaded 9
Iterator loading ended!
如您所见，我们确实能够在自定义对象上使用iter()函数。__iter__()方法创建迭代器对象，然后我们使用__next__()更新它。
终止条件是当当前值大于最大值时，此时我们引发一个StopIteration异常。
用 iter()生成值直到一个 sentinel 值
我们可以再传递一个参数给 Python iter()。第二个参数称为sentinel元素。
如果我们传递这个 sentinel 元素，迭代器将继续生成值，直到生成的值等于这个 sentinel 值，之后StopIteration将被引发。
在此之后，迭代器生成将自动停止！
如果您有来自函数的顺序数据，这将非常有用。函数也是必要的，因为如果我们使用 sentinel 参数，第一个参数必须是可调用的。
iterator = iter(callable_object, sentinel)
这里，iterator是一个迭代器，它会一直调用callable_object，直到返回值等于sentinel。
在这里，callable_object可以是函数，方法，甚至是 Lambda！
让我们举一个简单的例子，使用 Lambda 作为可调用函数。
我们将接受一个字符串作为输入，并将其传递给 lambda 函数，并一直生成值，直到出现一个换行符 sentinel 元素(' \n ')。
a = "This is a long string consisting of two lines.\nThis is the second line.\nThis is the third line."
start = 0
size = 1
def func(a):
return a[start: start+size]
iterator = iter(lambda: func(a), '\n')
# Will generate values until '\n'
for out in iterator:
print(f"Iterator loaded {out}")
start += size
print("Encountered Newline!")
输出
Iterator loaded T
Iterator loaded h
Iterator loaded i
Iterator loaded s
Iterator loaded
Iterator loaded i
Iterator loaded s
Iterator loaded
Iterator loaded a
Iterator loaded
Iterator loaded l
Iterator loaded o
Iterator loaded n
Iterator loaded g
Iterator loaded
Iterator loaded s
Iterator loaded t
Iterator loaded r
Iterator loaded i
Iterator loaded n
Iterator loaded g
Iterator loaded
Iterator loaded c
Iterator loaded o
Iterator loaded n
Iterator loaded s
Iterator loaded i
Iterator loaded s
Iterator loaded t
Iterator loaded i
Iterator loaded n
Iterator loaded g
Iterator loaded
Iterator loaded o
Iterator loaded f
Iterator loaded
Iterator loaded t
Iterator loaded w
Iterator loaded o
Iterator loaded
Iterator loaded l
Iterator loaded i
Iterator loaded n
Iterator loaded e
Iterator loaded s
Iterator loaded .
Encountered Newline!
正如您所看到的，迭代器一直生成值，直到遇到换行符！您也可以使用一个while循环并捕获StopIteration异常来完成相同的程序。
如果您想处理函数返回的输出块，这实际上非常有用，所以一定要注意iter()的 sentinel 参数！
结论
在本文中，我们研究了如何使用 Python 中的iter()函数为各种对象生成可迭代对象。
参考
- iter()上的 Python 官方文档
- 关于迭代器的 AskPython 文章
Python 迭代器
原文：https://www.askpython.com/python/built-in-methods/python-iterator
Python 迭代器是一个可以被迭代的对象。任何支持这种迭代的对象都被称为迭代器。
现在，你可能会感到困惑。存在另一个名为 iterable 的对象。那是什么？让我们来看看。
迭代器和可迭代对象
任何 iterable 都是可以被迭代的对象。也就是说，我们可以使用迭代器遍历这个对象。
可迭代对象的例子有元组、列表、字符串、数组等。
为了从一个可迭代的构造一个迭代器，我们可以使用iter()方法。
iterable_list = [1, 2, 3]
iterable_string = "Hello"
iterator_1 = iter(iterable_list)
iterator_2 = iter(iterable_string)
print(iterator_1, type(iterator_1))
print(iterator_2, type(iterator_2))
输出
<list_iterator object at 0x7f887b01aed0> <class 'list_iterator'>
<str_iterator object at 0x7f887b01af50> <class 'str_iterator'>
输出显示我们已经创建了两个迭代器；一个用于列表，一个用于字符串。
现在让我们看看迭代器对象支持的方法。
Python 迭代器方法
迭代器对象有两个特殊的方法可以使用，称为 iter() 和 next() 。
前面使用了iter()方法，从 iterable 中获取 Python 迭代器对象。
现在，为了遍历迭代器，我们可以使用next()方法来获取 iterable 中的下一个元素。
格式:
next_iterable_object = next(iterator)
当没有更多的元素可去时，这将终止并引发一个StopIteration 异常。
为了说明这一切，让我们打印列表迭代器的所有元素。
>>> iterable_list = [1, 2, 3]
>>> iterator_1 = iter(iterable_list)
>>> next(iterator_1)
1
>>> next(iterator_1)
2
>>> next(iterator_1)
3
>>> next(iterator_1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
如您所见，当您超出 iterable 的长度时，这确实会引发StopIteration异常。
现在，让我们进入下一步:制作我们自己的迭代器！
用 Python 构建我们自己的迭代器
任何迭代器对象都有可数的元素，可以被遍历。但是怎么才能做出自己的迭代器呢？我们需要创建自己的类。
在 Python 中，构建任何迭代器都涉及到一个叫做迭代器协议的协议。
这个协议包含两个特定的方法，称为__iter__()和__next__()，类似于一般的迭代器方法，但是因为它们在一个类中，所以用这个符号作为前缀和后缀，以示区别。
iter()和next()方法在内部调用这些方法，因此，为了生成迭代器，我们需要在我们的类中定义我们自己的__iter__()和__next__()方法。
让我们创建一个简单的迭代器，它只遍历一个列表，如果元素数大于 5，就会引发一个 StopIteration 异常。
在我们的next()方法中，我们还将打印到目前为止迭代的元素数量。
class MyClass():
def __init__(self):
self.counter = 0
# Set the limit
self.limit = 5
def __iter__(self):
# The iter() method internally calls this
print('Call to __iter__()')
return self
def __next__(self):
print('Call to __next__()')
if self.counter > self.limit:
raise StopIteration
else:
# Increment counter and return it
self.counter += 1
return self.counter
# Create the iterable
my_obj = MyClass()
# Create the iterator object from the iterable
my_it = iter(my_obj)
for i in range(7):
print(next(my_it))
输出
Call to __iter__()
Call to __next__()
1
Call to __next__()
2
Call to __next__()
3
Call to __next__()
4
Call to __next__()
5
Call to __next__()
6
Call to __next__()
Traceback (most recent call last):
File "iter.py", line 29, in <module>
print(next(my_it))
File "iter.py", line 15, in __next__
raise StopIteration
StopIteration
这里，它打印从 1 到 6 的数字，下一个调用将触发StopIteration异常，因为我们已经超出了限制。
我们已经制作了自己的迭代器！
结论
我希望你现在对迭代器有了很好的理解，并且在阅读完这篇文章后，关于这个概念的任何疑问都被清除了。如果没有，请在下面的评论区问他们！
参考
- 关于迭代器的 JournalDev 文章
Python Itertools 模块使用指南
原文：https://www.askpython.com/python-modules/python-itertools-module
在本文中，我们将看看如何使用 Python itertools 模块。
如果您想创建适合各种任务的不同类型的迭代器，这个模块非常有用。
如果你能学会这个模块的一些方法，这将是你工具箱中非常有用的一个补充！让我们从现在开始，通过一些有用的方法。
python ITER tools–有用的方法
在这一节，我们将看看一些有用的生成迭代器的方法。
要使用这个模块，我们必须首先导入它。这个在标准库中已经有了，所以是预装的！
import itertools
使用 Python itertools.chain()将 iterables 链接在一起
Python itertools.chain()方法从多个可迭代对象中生成一个迭代器。
这只是将所有的 iterables 链接到一个序列中，并向该组合序列返回一个迭代器。
此方法的语法如下
iterator = itertools.chain(*sequence)
让我们看一个简单的例子，来理解这一点。
import itertools
list1 = ['hello', 'from', 'AskPython']
list2 = [10, 20, 30, 40, 50]
dict1 = {'site': 'AskPython', 'url': 'https://askpython.com'}
# We can combine lists and dicts (iterables) into a single chain
for item in itertools.chain(list1, list2, dict1):
print(item)
这里，我们直接使用迭代器，通过使用for item in ...遍历它
输出
hello
from
AskPython
10
20
30
40
50
site
url
在这里，虽然我们正确地获得了列表的内容，但是没有显示字典值。
为了解决这个问题，我们可以使用dict.items()来获得一组(key, value)对。
import itertools
list1 = ['hello', 'from', 'AskPython']
list2 = [10, 20, 30, 40, 50]
dict1 = {'site': 'AskPython', 'url': 'https://askpython.com'}
# We can combine lists and dicts (iterables) into a single chain
for item in itertools.chain(list1, list2, dict1.items()):
print(item)
输出
hello
from
AskPython
10
20
30
40
50
('site', 'AskPython')
('url', 'https://askpython.com')
事实上，我们现在也打印了值，使用dict1.items()作为 iterable！
使用 Python itertools.count()生成基于计数器的序列
我们可以使用函数 Python itertools.count()来制作对应于一个计数的迭代器。
iterator = itertools.count(start=0, step=1)
这里，这是一个迭代器，从 0 开始无限计数。
这使得计数持续增加step=1。我们也可以将其设置为十进制/负数。
例如，如果你想证明你有一个无限循环，你可以运行下面的代码片段，但它是而不是推荐的。
只要确保你能理解itertools.count()是无限计数的。
for num in itertools.count(start=0, step=1):
# Infinite loop!
print(num)
现在，虽然您可能不会立即发现这个函数的用途，但是您可以将它与其他函数结合使用，例如 zip 方法来构造序列。
考虑下面的例子:
import itertools
numbers = [100, 200, 300, 400]
data = list(zip(itertools.count(0, 10), numbers))
print(data)
在这里，您现在可以看到迭代器的威力了！由于迭代器只在需要时产生输出，我们可以用另一个有限的可迭代对象来zip()它，比如一个列表！
现在，它被用来为列表中的条目构建索引，您可以使用输出来验证这一点！
[(0, 100), (10, 200), (20, 300), (30, 400)]
现在，如果您想使用 Python itertools.count()获得迭代器序列的子集，那么您也可以使用itertools.islice()只构建迭代器的一部分。
import itertools
for num in itertools.islice(itertools.count(start=0, step=10), 4):
print(num)
for num in itertools.islice(itertools.count(), 0, 50, 10):
print(num)
输出
0
10
20
30
0
10
20
30
40
正如你所观察到的，两个序列是相同的。这表明您可以有多种方法来生成序列！
根据要解决的问题，使用你认为合适的方法！
使用 itertools.repeat()重复一个值
假设您想要重复一个特定的值，您可以使用itertools.repeat(value)为重复的值构造一个迭代器。
例如，如果你想构造一个形式为(i, 5)的序列，其中 I 的范围是从 0 到 10，你可以使用这个函数！
import itertools
data = list(zip(range(10), itertools.repeat(5)))
print(data)
输出
[(0, 5),
(1, 5),
(2, 5),
(3, 5),
(4, 5),
(5, 5),
(6, 5),
(7, 5),
(8, 5),
(9, 5)]
事实上，我们能够轻松地制作这个序列！
该函数有用的另一个例子是，如果您试图使用 Python 中的 map()构建正方形。
squares = list(map(pow, range(10), itertools.repeat(2)))
print(squares)
输出
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
看看我们用map()构建它有多容易？
使用 itertools.tee()克隆序列
还有一个有用的函数叫做tee()，它克隆一个序列，并产生两个序列。
cloned1, cloned2 = itertools.tee(original_sequence)
这基于 Linux tee 命令，该命令克隆其输出。
这里，当您使用tee()克隆一个序列时，您不能再次使用同一个迭代器。因此，使用该功能时必须非常小心！
import itertools
single_iterator = itertools.islice(itertools.count(), 3)
cloned1, cloned2 = itertools.tee(single_iterator)
for num in cloned1:
print('cloned1: {}'.format(num))
for num in cloned2:
print('cloned2: {}'.format(num))
输出
cloned1: 0
cloned1: 1
cloned1: 2
cloned2: 0
cloned2: 1
cloned2: 2
事实上，我们可以看到两个克隆序列，具有相同的输出！
使用 itertools.cycle()遍历序列
函数提供了一个我们可以无限循环的迭代器！
如果您希望在应用程序中不断切换状态，这将非常有用。
考虑灯泡的两种状态:“开”和“关”。
你可以构造一个迭代器，每当开关被按下时，迭代器就在两种状态之间循环。
import itertools
# Initially, bulb is switched off, so off is the first element in the list
bulb_states = itertools.cycle(["off", "on"])
for _ in range(5):
# Use next(iterator) to get the current state
curr_state = next(bulb_states)
print(f"Bulb state currently {curr_state}")
输出
Bulb state currently off
Bulb state currently on
Bulb state currently off
Bulb state currently on
Bulb state currently off
事实上，正如你所看到的，灯泡的状态一直在“开”和“关”这两个值之间循环！
使用 takewhile()和 dropwhile()筛选项目
我们可以使用 Python itertools.takewhile()函数来过滤序列项，只要条件是True。如果条件变为False，则停止过滤。
iterator = itertools.takewhile(condition, *sequence)
这里有一个简单的例子，它过滤数字，只要数字是正数。
import itertools
sequence = itertools.takewhile(lambda x: x > 0, [1, 2, 3, -1, 10])
for item in sequence:
print(item)
输出
1
2
3
这里，序列在 3 之后停止，因为下一个元素是-1。
类似地，itertools.dropwhile()只要条件为False就过滤元素，并返回第一个非 false 值之后的所有元素。
import itertools
data = itertools.dropwhile(lambda x: x < 5, [3, 12, 7, 1, -5])
for item in data:
print(item)
输出
12
7
1
-5
使用组合()构造组合
我们还可以使用 Python itertools.combinations()构建组合序列。
iterator = itertools.combinations(*sequence, r)
这里有一个简单的例子:
import itertools
words = ['hello', 'from', 'AskPython', 'how']
results = itertools.combinations(words, 2)
for item in results:
print(item)
输出
('hello', 'from')
('hello', 'AskPython')
('hello', 'how')
('from', 'AskPython')
('from', 'how')
('AskPython', 'how')
如果你想在组合中有连续元素的重复，你可以使用combinations_with_replacement()。
results = itertools.combinations_with_replacement(words, 3)
for item in results:
print(item)
输出
('hello', 'hello', 'hello')
('hello', 'hello', 'from')
('hello', 'hello', 'AskPython')
('hello', 'hello', 'how')
('hello', 'from', 'from')
('hello', 'from', 'AskPython')
('hello', 'from', 'how')
('hello', 'AskPython', 'AskPython')
('hello', 'AskPython', 'how')
('hello', 'how', 'how')
('from', 'from', 'from')
('from', 'from', 'AskPython')
('from', 'from', 'how')
('from', 'AskPython', 'AskPython')
('from', 'AskPython', 'how')
('from', 'how', 'how')
('AskPython', 'AskPython', 'AskPython')
('AskPython', 'AskPython', 'how')
('AskPython', 'how', 'how')
('how', 'how', 'how')
类似地，您可以使用permutations()和permutations_with_replacement()列出排列。
这就结束了这个模块的一些重要功能。更多功能可以咨询官方文档。
结论
在本文中，我们查看了 Python itertools模块中的各种函数。根据您的问题，您可以使用多种方法中的一种来快速构建序列！
参考
- Itertools 模块文档
- 关于 itertools 模块的 JournalDev 文章
Python json 模块
原文：https://www.askpython.com/python-modules/python-json-module
在深入 Python JSON 模块之前，让我们了解一下 JSON 是什么。JSON(JavaScript 对象符号)是一种标准化的格式，允许在互联网上交换数据。
由于这已经成为通过互联网进行信息交换的标准，任何 Python 应用程序使用这种格式发送和接收数据都是有意义的。
Python 内置的 json 模块是将 Python 对象转换成 json 对象的接口。
在本教程中，我们来看看 json 模块中一些最常用的方法。
JSON 对象的格式
在进入模块细节之前，让我们理解 JSON 对象是由什么组成的。
这实际上非常类似于 Python 字典，其中有一组 {Key: value} 对。唯一的小区别是 JSON 对象有一个左花括号和右花括号。
下面是一个简单的 JSON 对象的例子
{
"name": "John",
"age": 42,
"married": True,
"qualifications": ["High School Diploma", "Bachelors"]
}
JSON 对象可以由各种属性组成，包括字符串、整数甚至列表。
现在我们知道了 JSON 对象是由什么组成的，让我们看看 Python json 模块的方法。
导入 Python json 模块
Python 已经准备好了 json 模块，所以不需要使用 pip 进行安装。
要导入这个模块，只需输入
import json
json . dumps()–构造一个 JSON 对象
我们可以使用json.dumps()方法将 Python 对象编码成 JSON 对象。
你可以把dumps()想象成将 Python 对象序列化成 Python JSON 对象并返回一个字符串。如果您希望通过互联网传输数据，这是必需的。
下表列出了不同 Python 对象的编码数据。
| 计算机编程语言 | JSON |
|---|---|
| 格言 | 目标 |
| 列表，元组 | 排列 |
| str | 线 |
| int ， float ，int–&float派生枚举 | 数字 |
| 真 | 真实的 |
| 假 | 错误的 |
| 无 | 空 |
它将任何可以序列化的 Python 对象作为参数，并返回一个字符串。
格式:
json_object = json.dumps(serializable_object)
这里，serializable_object是一个 Python 对象，如列表、字符串等，可以序列化。它不能是函数/lambda 等。
import json
python_object = ['Hello', 'from', 'AskPython', 42]
json_object = json.dumps(python_object)
print(type(json_object), json_object)
输出
<class 'str'> ["Hello", "from", "AskPython", 42]
如果对象不可序列化，该方法将引发一个TypeError。
>>> import json
>>> a = lambda x : x * 2
>>> a(2)
4
>>> json.dumps(a)
Traceback (most recent call last):
raise TypeError(f'Object of type {o.__class__.__name__}
TypeError: Object of type function is not JSON serializable
字典的分类关键字
如果我们将一个 Python 字典传递给json.dumps()，我们可以指定另一个参数sort_keys，这将使 Python json 对象拥有排序的键。
import json
dict_obj = {1:"one", 20: "twenty", 5:"five"}
json_obj = json.dumps(dict_obj, sort_keys = True)
print(json_obj)
输出
{"1": "one", "5": "five", "20": "twenty"}
我们的输出确实有排序的键。
注:由于数字被编码成 JSON，所以被转换成字符串。使用适当的方法，它将被正确地反序列化回整数。
漂亮地打印 Python JSON 对象
我们可以使用json.dumps()的indent参数来指定缩进级别。通常，indent = 4会让输出看起来很不错。
import json
dict_obj = {1:"one", 20: "twenty", 5:"five"}
json_obj = json.dumps(dict_obj, sort_keys = True, indent = 4)
print(json_obj)
输出
{
"1": "one",
"5": "five",
"20": "twenty"
}
JSON . Dump()–转储到文件中
我们也可以将一个对象转储到一个文件中，如果你希望以后使用它，使用另一种方法json.dump()。
格式:
json.dump(data, file_object)
json.dump()方法接收数据并将其写入一个文件对象。
因此您可以打开一个新文件，并使用json.dump()写入该文件对象
import json
python_object = ['Hello', 'from', 'AskPython', 42]
with open("sample.json", "w") as wf:
json.dump(python_object, wf)
输出
[email protected] $ cat sample.json
["Hello", "from", "AskPython", 42]
如您所见，Python 对象确实被转储到文件中。
现在，让我们把第一个例子中显示的 JSON 对象存储到一个文件中。
import json
json_object = {
"name": "John",
"age": 42,
"married": True,
"qualifications": ["High School Diploma", "Bachelors"]
}
with open("sample.json", "w") as wf:
json.dump(json_object, wf)
输出
[email protected] $ cat sample.json
{"name": "John", "age": 42, "married": true, "qualifications": ["High School Diploma", "Bachelors"]}
反序列化 JSON 对象
类似于将 Python 对象编码成 JSON 对象，我们也可以反过来，将 JSON 对象转换成 Python 对象。这被称为反序列化。
我们可以使用方法json.loads()和json.load()来做到这一点，类似于json.dumps()和json.dump()。
json.loads()
这将使用json.dumps()编码的 json 对象转换回 Python 对象。
import json
python_object = ['Hello', 'from', 'AskPython', 42]
encoded_object = json.dumps(python_object)
decoded_object = json.loads(encoded_object)
print(type(decoded_object), decoded_object)
输出
<class 'list'> ['Hello', 'from', 'AskPython', 42]
我们已经成功地获得了我们的旧列表对象！
JSON . load()–从文件反序列化
这执行了与json.dump()相反的操作，将 json 对象从文件转换回 Python 对象。
让我们拿我们的sample.json文件，用这个方法取回数据。
import json
with open("sample.json", "r") as rf:
decoded_data = json.load(rf)
print(decoded_data)
输出
{'name': 'John', 'age': 42, 'married': True, 'qualifications': ['High School Diploma', 'Bachelors']}
事实上，我们再次获得了我们存储在文件中的旧的 JSON 对象！
现在我们已经介绍了这个模块最常用的方法，让我们进入下一步:创建我们自己的 JSON 编码器！
创建我们自己的 JSON 编码器
json模块使用一个名为json.JSONEncoder的编码器，它使用上表中的规则对 Python 对象进行编码。
然而，它并不编码所有的 Python 对象，根据我们面临的问题，我们可能需要编写自己的 JSON 编码器，以一种特殊的方式编码这些对象。
为此，我们必须编写自定义的编码器类。姑且称之为MyEncoder。这个必须扩展json.JSONEncoder类的，以增加它现有的特性。
在这个演示中，我们将使用 numpy 数组，并将它们转换成 Python JSON 对象。现在 json 模块默认情况下不能处理 numpy 数组，所以如果你试图在没有扩展类的情况下转换 numpy 数组，你会得到一个 TypeError:
TypeError: Object of type ndarray is not JSON serializable
让我们编写这个类，通过在我们的default()处理程序方法中将 numpy 数组转换成 Python 列表，将它序列化并编码成 json 对象。
import json
import numpy as np
class MyEncoder(json.JSONEncoder):
# Handles the default behavior of
# the encoder when it parses an object 'obj'
def default(self, obj):
# If the object is a numpy array
if isinstance(obj, np.ndarray):
# Convert to Python List
return obj.tolist()
else:
# Let the base class Encoder handle the object
return json.JSONEncoder.default(self, obj)
# Numpy array of floats
a = np.arange(1, 10, 0.5)
print(type(a), a)
# Pass our encoder to json.dumps()
b = json.dumps(a, cls=MyEncoder)
print(b)
最后，我们通过将类名传递给json.dumps()的cls参数对其进行编码。
因此，编码调用将是:
json_object = json.dumps(python_object, cls=MyEncoder)
输出
<class 'numpy.ndarray'> [1\. 1.5 2\. 2.5 3\. 3.5 4\. 4.5 5\. 5.5 6\. 6.5 7\. 7.5 8\. 8.5 9\. 9.5]
[1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0, 5.5, 6.0, 6.5, 7.0, 7.5, 8.0, 8.5, 9.0, 9.5]
事实上，我们的自定义编码器现在可以将 numpy 数组转换成 JSON 对象！我们现在已经完成了第一个复合编码器。
您可以扩展这个功能，为您的特定用例编写不同的编码器！
结论
在本文中，我们学习了如何使用 Python 的json模块来进行各种涉及 JSON 对象的操作。
参考
- JSON 模块上的官方 Python 文档
Python 关键字
Python 关键字是保留字。python 解释器使用它们来理解程序。关键字定义了程序的结构。我们不能用关键字来命名程序实体，如变量、类和函数。
Python 中有多少个关键字？
Python 有很多关键词。随着 python 中新特性的出现，这个数字还在继续增长。
在撰写本教程时，Python 3.10.5 是当前的稳定版本。Python 3.10.5 版本中有 35 个关键字。
我们可以使用 python 解释器帮助实用程序获得关键字的完整列表。
$ python3.10
>>> help()
help> keywords
Here is a list of the Python keywords. Enter any keyword to get more help.
False class from or
None continue global pass
True def if raise
and del import return
as elif in try
assert else is while
async except lambda with
await finally nonlocal yield
break for not
Python Keywords List
Python 关键字列表
我们可以使用“关键字”模块来获取关键字列表。
% python3
Python 3.10.5 (v3.10.5:f377153967, Jun 6 2022, 12:36:10) [Clang 13.0.0 (clang-1300.0.29.30)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import keyword
>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
>>> len(keyword.kwlist)
35
>>>
Python 软关键字
Python 3.9 引入了软关键字的概念。我们可以使用软关键字作为变量名，它们只在程序的上下文中得到特殊处理。截至目前，有两个软关键词——合并和案件。我们可以使用关键字模块来确认这一点。
>>> keyword.softkwlist
['_', 'case', 'match']
>>>
为什么我们需要软文关键词？
我认为引入软关键字的想法是为了避免破坏现有代码，以防它们被用作标识符。这将给开发人员足够的时间对他们的代码进行适当的修改。
如何检查一个字符串是不是关键词？
我们可以使用 keyword.iskeyword() 函数来检查一个字符串是否是保留关键字。
比如 print 在 python 中是关键字吗？
>>> keyword.iskeyword('print')
False
>>>
所以，print 在 python 中不是关键字。
Python 关键字简介
我们将在以后的教程中介绍所有的 python 关键字。让我们了解一下这些关键词的用途和用法。
| 序列号 | 关键字 | 描述 | 例子 |
| one | 错误的 | bool 类的实例。 | x =假 |
| Two | 班级 | 关键字来定义类。 | Foo 类:通过 |
| three | 从 | 子句从模块导入类 | 从集合导入订单直接 |
| four | 或者 | 逻辑算子 | x =真或假 |
| five | 没有人 | 非类型对象的实例 | x =无 |
| six | 继续 | continue 语句，用于嵌套的 for 和 while 循环中。它继续最近的封闭循环的下一个循环。 | numbers = numbers 中数字的范围(1，11):如果 number == 7:继续 |
| seven | 全球的 | 全局语句允许我们修改当前范围之外的变量。 | x = 0 def add():全局 x x = x + 10 add() print(x) # 10 |
| eight | 及格 | Python pass 语句用于不做任何事情。当我们需要一些语句但不想执行任何代码时，这是很有用的。 | def foo():通过 |
| nine | 真实的 | 布尔类的实例。 | x =真 |
| Ten | 极好的 | 用于定义函数的关键字。 | def bar(): print("Hello ") |
| Eleven | 如果 | if 语句用于编写条件代码块。 | x = 10 如果 x%2 == 0: print("x 是偶数")#打印" x 是偶数" |
| Twelve | 上升 | raise 语句用于在程序中引发异常。 | def square(x):如果 type(x)不是 int:raise type error(" Require int argument ")print(x * x) |
| Thirteen | 和 | 用于 and 运算的布尔运算符。 | x = True y = Falseprint(x 和 y) # False |
| Fourteen | 是吗 | del 关键字用于删除变量、列表、对象等对象。 | s1 = " Hello " print(S1)# Hello del S1 print(S1)# name 错误:未定义名称' S1 ' |
| Fifteen | 进口 | import 语句用于将模块和类导入我们的程序。 | #从集合中的模块导入类导入顺序直接#导入模块导入数学 |
| Sixteen | 返回 | return 语句在函数中用于返回值。 | def add(x，y):返回 x+y |
| Seventeen | 如同 | Python as 关键字用于为 import、except 和 with 语句提供名称。 | 从集合导入顺序直接作为 od 导入数学作为 m 打开(' data.csv ')作为文件:pass #对文件进行一些处理 try: pass 除了 TypeError 作为 e: pass |
| Eighteen | 艾列弗 | 对于“else if”运算，elif 语句总是与 if 语句一起使用。 | x = 10 如果 x > 10: print('x 大于 10') elif x > 100: print('x 大于 100') elif x == 10: print('x 等于 10') else: print('x 小于 10 ') |
| Nineteen | 在 | Python in 关键字用于测试成员资格。 | l1 = [1，2，3，4，5]if 2 in L1:print(' list contains 2 ')s = ' ABCD ' if ' a in s:print(' string contains a ') |
| Twenty | 尝试 | Python try 语句用于编写异常处理代码。 | x = " try:I = int(x)except value error as AE:print(AE)#以 10 为基数的 int()的无效文字: " |
| Twenty-one | 维护 | assert 语句允许我们在程序中插入调试断言。如果断言为真，程序继续运行。否则抛出 AssertionError。 | def divide(a，b):断言 b！= 0 返回 a / b |
| Twenty-two | 其他 | else 语句与 if-elif 条件一起使用。它用于在前面的条件都不为真时执行语句。 | 如果为假:传递 else: print('这将总是打印') |
| Twenty-three | 是 | Python is 关键字用于测试两个变量是否引用同一个对象。这与使用==运算符相同。 | fruits =[' apple ']fruits 1 =[' apple ']f = fruits print(f 是水果)# True print(fruits1 是水果)# False |
| Twenty-four | 在…期间 | while 语句用于运行一组语句，直到表达式为真。 | i = 0，而 i < 3:打印(i) i+=1#输出# 0 # 1 # 2 |
| Twenty-five | 异步ˌ非同步(asynchronous) | Python 3.5 中引入的新关键字。这个关键字总是在 couroutine 函数体中使用。它与 asyncio 模块和 await 关键字一起使用。 | import async io import Time async def Ping(URL):print(f ' Ping Started for { URL } ')await async io . sleep(1)print(f ' Ping Finished for { URL } ')async io . gather(Ping(' ask python . com ')，ping('python.org '))，if _ _ name _ _ = ' _ _ main _ _ ':then = Time . Time()loop = async io . get _ event _ loop()loop . run _ until _ complete(main())now = Time . Time()print(f ' |
| Twenty-six | 等待 | Python 3.5 中用于异步处理的新关键字。 | 上面的例子演示了 async 和 await 关键字的使用。 |
| Twenty-seven | 希腊字母的第 11 个 | lambda 关键字用于创建 lambda 表达式。 | multiply = lambda a，b: a * b print(multiply(8，6)) # 48 |
| Twenty-eight | 随着 | Python with 语句用于用上下文管理器定义的方法包装块的执行。该对象必须实现 enter()和 exit()函数。 | 用 open('data.csv ')作为 file: file.read() |
| Twenty-nine | 除...之外 | Python except 关键字用于捕获 try 块中抛出的异常，并对其进行处理。 | 请查看 try 关键字示例。 |
| Thirty | 最后 | finally 语句与 try-except 语句一起使用。finally 块中的代码总是被执行。主要用于关闭资源。 | def division(x，y): try:返回除 ZeroDivisionError 之外的 x / y 作为 e: print(e) return -1 最后:print('这将始终执行')print(division(10，2)) print(division(10，0))# Output 这将始终执行 5.0 除以零这将始终执行-1 |
| Thirty-one | 非局部的 | nonlocal 关键字用于访问在块范围之外定义的变量。这在嵌套函数中总是用来访问外部定义的变量。 | def outer(): v = 'outer'def inner():非本地 v v = 'inner'inner() print(v)outer() |
| Thirty-two | 产量 | Python yield 关键字是 return 关键字的替代。这用于从函数中逐个返回值。 | def multiplyByTen(* kwargs):for I in kwargs:yield I * 10a = multiplyByTen(4，5，)# a 是生成器对象，一个迭代器#显示 a 中 I 的值:print(i)# Output 40 50 |
| Thirty-three | 破裂 | break 语句与嵌套的“for”和“while”循环一起使用。它停止当前循环的执行，并将控制传递到循环的开始处。 | number = 1，而 True: print(number) number += 2，如果 number > 5: break print(number) #从不执行# Output 1 3 5 |
| Thirty-four | 为 | Python for 关键字用于迭代序列或可迭代对象的元素。 | S1 = ' Hello ' for c in S1:print(c)# Output H e l l o |
| Thirty-five | 不 | not 关键字用于布尔 not 运算。 | x = 20 如果 x 不是 10: print('x 不等于 10')x = True print(不是 x) # False |
摘要
Python 关键字有特定的功能。python 解释器使用它们来理解代码并执行它们。Python 中有 35 个关键字。随着新功能的出现，这个数字还会继续增长。
下一步是什么？
你对 python 中的关键字有了一个简单的概念。现在，您应该通过下面的教程来了解 Python 编程的基础。
资源
python lambda–匿名函数
原文：https://www.askpython.com/python/python-lambda-anonymous-function
- Python lambda 函数或 Python 匿名函数没有名称。
- 我们可以使用λ保留关键字定义一个匿名函数。
- 匿名函数的作用域限于定义它的当前作用域。
- 一个 lambda 函数可以有一个或多个参数，但是它只能有一个表达式。
- 计算表达式，结果从 lambda 函数返回。
- lambda 函数通常与 map()、filter()和 reduce()操作一起使用。
Python lambda 函数语法
lambda 函数的语法是:
lambda arguments : expression
Python 匿名函数示例
假设我们有一个函数来计算一个矩形的面积。
def area_of_rectangle(l, w):
return l * w
print(f'Area of Rectangle (4, 5) is {area_of_rectangle(4, 5)}')
让我们使用 lambda 关键字创建一个匿名函数来获取矩形的面积。
rectangle_area = lambda x, y: x * y
print(f'Area of Rectangle (4, 5) is {rectangle_area(4, 5)}')
什么时候使用匿名功能？
- 对于不太复杂的小而琐碎的任务。
- 当函数只有一个表达式时。
- 用于临时性的重复性任务。
- 当您希望函数范围仅限于当前范围时。
- 当函数参数是另一个函数(如 map()、filter()和 reduce()函数)时，这很有用。
带有 map()的 Lambda 函数
map()函数接受一个函数和一个 iterable 作为参数。该函数应用于 iterable 中的每个元素，并返回更新后的 iterable。
假设我们有一个整数列表。我们必须通过将每个元素乘以 10 来创建一个新的列表。我们可以在这里使用 lambda 函数，而不是为这个用例创建一个函数。
list_numbers = [1, 2, 3, 4]
list_numbers = map(lambda x: x * 10, list_numbers)
for num in list_numbers:
print(num, end=" ")
输出:
Python lambda Function with map()
带过滤器的 Lambda 函数()
内置的 filter()函数接受一个函数和一个 iterable 作为参数。该函数应用于 iterable 的每个元素。如果函数返回 True，则元素被添加到返回的 iterable 中。
假设我们有一个整数列表，我们想删除所有的奇数。最终的列表应该只有偶数。我们可以在 lambda 函数中使用 filter()函数。
list_numbers = [1, 2, 3, 4, 5, 6]
list_numbers = filter(lambda x: x % 2 == 0, list_numbers)
for num in list_numbers:
print(num, end=" ")
Python lambda Function with filter()
带 reduce()的 Lambda 函数
reduce()函数存在于 functools 模块中。这个函数以一个函数和一个序列作为参数。该函数应该接受两个参数。序列中的元素与累积值一起传递给函数。最终结果是一个单一的值。
假设我们有一个整数列表，我们想得到所有元素的和。我们可以在 lambda 函数中使用 reduce()函数。
from functools import reduce
list_ints = [1, 2, 3, 4, 5, 6]
total = reduce(lambda x, y: x + y, list_ints)
print(f'Sum of list_ints elements is {total}')
Python lambda Function with reduce()
没有参数的 Python lambda 函数
有人问我我们能不能有一个没有任何自变量的 lambda 函数？
是的，我们可以定义一个没有任何参数的 lambda 函数。但是，这将是无用的，因为将没有什么可操作的。让我们看一个简单的例子。
get_5 = lambda: 5
print(get_5()) # 5
因为 lambda 函数总是返回相同的值，所以我们可以给它赋一个变量。不带任何参数地使用 lambda 函数显然是对这个特性的滥用。
结论
Python 匿名函数是使用 lambda 关键字创建的。当函数参数是另一个函数时，它们很有用。它主要用于创建一次性使用的简单实用函数。
参考资料:
在 Python 中使用列表理解
原文：https://www.askpython.com/python/list/python-list-comprehension
大家好！今天，我们将讨论如何在 Python 中使用列表理解。
列表理解通常是一种语法糖，使代码更容易阅读和编写。
通常，当我们处理涉及创建列表的代码时，反复编写嵌套循环是很麻烦的。
Python 通过引入这一特性使我们的工作变得更加容易。
现在让我们通过合适的例子来了解如何在我们的程序中使用它！
列表理解的基本结构
让我们考虑以下正常编写的代码:
word = "Hello from AskPython"
letters = []
for letter in word:
letters.append(letter)
print(letters)
输出
['H', 'e', 'l', 'l', 'o', ' ', 'f', 'r', 'o', 'm', ' ', 'A', 's', 'k', 'P', 'y', 't', 'h', 'o', 'n']
上面的代码片段打印了单词中的字母列表。
我们可以使用列表理解来缩短这段代码，因为列表的元素有一个共同的属性:它们是字母，并且它们将被追加到列表中。
现在让我们使用列表理解来使它更简短和易读:
word = "Hello from AskPython"
letters = [letter for letter in word]
print(letters)
输出
['H', 'e', 'l', 'l', 'o', ' ', 'f', 'r', 'o', 'm', ' ', 'A', 's', 'k', 'P', 'y', 't', 'h', 'o', 'n']
看到有多简单了吗？代码的意图很清楚:我们选取单词的字母，并直接将其添加到我们的列表中！
现在，我们也可以用列表理解其他的可重复项了！
再举一个例子，我们可以生成 1 到 10 的数字的平方。
正常的方法如下:
squares = []
for i in range(1, 11):
squares.append(i * i)
print(squares)
输出
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
虽然这已经足够小了，但是我们可以使用列表理解做得更好。我们可以把它减少到只有两行代码！
squares = [i * i for i in range(1, 11)]
print(squares)
我们现在向您展示了理解列表的能力！现在让我们通过处理像if和else这样的条件句来给它添加一些趣味吧！
在列表理解中使用条件
在我们的列表理解中，我们可以使用if和else 条件句。
让我们考虑第一种情况，这里我们只有一个if条件。
这种列表理解的一般结构如下:
list = [item for item in iterable if condition]
所以在这里，list将只由item组成，其中condition成立。
让我们以之前构建正方形的例子为例，使用if将其限制为偶数。
squares = [i * i for i in range(1, 11) if i % 2 == 0]
print(squares)
输出
[4, 16, 36, 64, 100]
事实上，我们在这里只能得到偶数个元素方块，因为只有当 I 是偶数时。
现在让我们看看第二种情况，我们也有一个else条件。该结构现在将如下所示:
list = [value1 if condition else value2 for item in iterable]
这里，如果condition == True，列表将包含value1的元素，如果condition == False，则包含value2的元素。
现在让我们举一个例子，我们一直打印整数方块，直到i<=5。如果我> 5，我们将打印 0。
我们的列表理解现在看起来像这样:
my_list = [i * i if i <= 5 else 0 for i in range(10)]
print(my_list)
输出
[0, 1, 4, 9, 16, 25, 0, 0, 0, 0]
如您所见，该列表仅包含所有< = 5 的数字的平方。其余元素设置为 0！
我们也可以使用其他条件，甚至 lambda 函数，如果我们愿意的话！
这里有一个稍微有点做作的例子，它使用一个lambda从 0 开始计算连续的对和。(0, 1 + 2, 2 + 3, 3 + 4..)
pair_sums = [(lambda x, y: x + y)(i, j) if i > 1 else 0 for i, j in zip(range(1, 11), range(0, 10))]
print(pair_sums)
输出
[0, 3, 5, 7, 9, 11, 13, 15, 17, 19]
如您所见，这段代码可读性不是很好，如果使用其他代码可能会更好！
所以，如果你想一次做太多事情，小心不要使用列表理解。当您想要运行简单的循环条件语句来构建列表时，最好坚持使用这种方法，而不是当您想要对每个元素单独执行数学计算时。
结论
在本文中，我们学习了使用 Python 的列表理解语义。这使得使用迭代循环来减少重复编写代码变得更加容易！
参考
- Python 列表上的 AskPython 文章
Python 元组列表的 5 个示例
原文：https://www.askpython.com/python/list/python-list-of-tuples
嘿，读者们！在本文中，我们将关注元组的 Python 列表。
什么是 Python 列表和元组？
Python List 是维护可变数据元素有序集合的数据结构。
list-name = [ item1, item2, ....., itemN]
列表中的元素包含在方括号[] 中。
Python Tuple 是一种不可变的数据结构，其元素被括在括号()中。
tuple-name = (item1, item2, ...., itemN)
Python 元组列表
我们可以创建元组的列表，即元组的元素可以包含在列表中，从而以与 Python 列表相似的方式遵循特征。因为 Python 元组使用较少的空间，所以创建元组列表在各个方面都更有用。
举例:
LT_data = [(1,2,3),('S','P','Q')]
print("List of Tuples:\n",LT_data)
输出:
List of Tuples:
[(1, 2, 3), ('S', 'P', 'Q')]
使用 zip()函数的 Python 元组列表
Python zip()函数可用于映射所有列表，使用以下命令创建元组列表:
list(zip(list))
zip() function根据传递给它的值返回元组的 iterable。此外，list() function将创建这些元组的列表，作为 zip()函数的输出。
举例:
lst1 = [10,20,30]
lst2 = [50,"Python","JournalDev"]
lst_tuple = list(zip(lst1,lst2))
print(lst_tuple)
输出:
[(10, 50), (20, 'Python'), (30, 'JournalDev')]
定制的元素分组，同时形成元组列表
在形成元组列表时，我们可以根据列表/元组中的元素数量来提供定制的元素分组。
[element for element in zip(*[iter(list)]*number)]
列表理解和zip() function一起用于将元组转换成列表并创建元组列表。Python iter() function用于一次迭代一个对象的元素。“号将指定要加入单个元组以形成列表的元素的数量。
例 1:
lst = [50,"Python","JournalDev",100]
lst_tuple = [x for x in zip(*[iter(lst)])]
print(lst_tuple)
在上面的例子中，我们已经使用 iter()方法形成了一个元组列表，其中一个元素包含在一个元组中。
输出:
[(50,), ('Python',), ('JournalDev',), (100,)]
例 2:
lst = [50,"Python","JournalDev",100]
lst_tuple = [x for x in zip(*[iter(lst)]*2)]
print(lst_tuple)
在这个例子中，两个元素包含在一个元组中，以形成一个元组列表。
输出:
[(50, 'Python'), ('JournalDev', 100)]
使用 map()函数的 Python 元组列表
Python map 函数可用于创建元组列表。map() function将函数映射并应用到传递给该函数的 iterable。
map(function, iterable)
举例:
lst = [[50],["Python"],["JournalDev"],[100]]
lst_tuple =list(map(tuple, lst))
print(lst_tuple)
在这个例子中，我们使用 map()函数将输入列表映射到 tuple 函数。此后，list()函数用于创建映射元组值的列表。
输出:
[(50,), ('Python',), ('JournalDev',), (100,)]
使用列表理解和 tuple()方法的 Python 元组列表
Python tuple()方法与 List Comprehension 一起可用于形成元组列表。
tuple() function帮助从传递给它的元素集中创建元组。
举例:
lst = [[50],["Python"],["JournalDev"],[100]]
lst_tuple =[tuple(ele) for ele in lst]
print(lst_tuple)
输出:
[(50,), ('Python',), ('JournalDev',), (100,)]
结论
到此，我们已经到了文章的结尾。我希望你们都喜欢学习 Python 元组列表这个有趣的概念。
如果你有任何疑问，欢迎在下面评论。
参考
如何使用 Python List pop()方法
Python list pop()方法用于从 Python 列表中弹出项目。在本文中，我们将快速看一下如何使用pop()从列表中弹出元素。
Python 列表 pop()的基本语法
这是一个列表对象类型的方法，所以每个列表对象都有这个方法。
您可以通过使用:来调用它
my_list.pop()
这是默认的调用，只是从列表中弹出最后一项。
如果您想从索引中弹出一个元素，我们也可以传递索引。
last_element = my_list.pop(index)
这将在index弹出元素，并相应地更新我们的列表。它将返回弹出的元素，但在大多数情况下，您可以选择忽略返回值。
现在我们已经讨论了语法，让我们看看如何使用它。
使用 Python list.pop()
让我们来看一下默认情况，您只需要弹出最后一个元素。
# Create a list from 0 to 10
my_list = [i for i in range(11)]
# Pop the last element
print("Popping the last element...")
my_list.pop()
# Print the modified list
print("List after popping:", my_list)
# Again Pop the last element
print("Popping the last element...")
my_list.pop()
# Print the modified list
print("List after popping:", my_list)
输出
Popping the last element...
List after popping: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Popping the last element...
List after popping: [0, 1, 2, 3, 4, 5, 6, 7, 8]
如您所见，最后一个元素确实从我们的列表中弹出。
现在，让我们考虑第二种类型，您希望在特定索引处弹出元素。
# Create a list from 0 to 10
my_list = [i for i in range(11)]
# Pop the last element
print("Popping the element at index 5...")
my_list.pop(5)
# Print the modified list
print("List after popping:", my_list)
# Again Pop the last element
print("Popping the element at index 2...")
my_list.pop(2)
# Print the modified list
print("List after popping:", my_list)
输出
Popping the element at index 5...
List after popping: [0, 1, 2, 3, 4, 6, 7, 8, 9, 10]
Popping the element at index 2...
List after popping: [0, 1, 3, 4, 6, 7, 8, 9, 10]
在这里，由于我们的原始列表是[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]，索引 5 处的元素是list[5]，也就是5。所以，这个被删除了，我们的列表现在没有了 5。类似地，在新列表中，我们再次删除第二个索引处的元素，即2。因此，我们的最终名单是[0, 1, 3, 4, 6, 7, 8, 9, 10]。
处理异常
如果违反了某些条件，list.pop()方法将引发一些异常。
列表为空时出现 IndexError 异常
当使用 Python list pop()方法时，如果我们的列表为空，我们就不能再从中弹出。这将引发一个IndexError异常。
my_list = []
# Will raise an exception, since the list is empty
my_list.pop()
输出
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: pop from empty list
因为我们试图从一个空列表中弹出，所以引发了这个异常，并显示了相应的错误消息。
索引时出现索引错误异常
如果传递给pop(index)方法的索引超出了列表的大小，就会引发这个异常。
例如，试图删除包含 11 个元素的列表中的第 12 个索引元素将引发此异常。
my_list = [i for i in range(10)]
# Will raise an exception, as len(my_list) = 11
my_list.pop(12)
输出
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
IndexError: pop index out of range
正如所料，我们确实得到了 IndexError 异常，因为my_list[12不存在。
结论
在本文中，我们学习了如何使用list.pop()方法从列表中弹出元素。
参考
- 关于 Python List pop()方法的 JournalDev 文章
Python 列表——你必须知道的 15 件事
- Python 列表是一个可变序列。
- 我们可以通过将元素放在方括号中来创建一个列表。
- 列表元素用逗号分隔。
- 我们可以创建嵌套列表。
- 该列表是有序的集合。因此它保持了添加元素的顺序。
- 我们可以使用索引来访问列表元素。它还支持负索引来引用从头到尾的元素。
- 我们可以将列表元素解包为逗号分隔的变量。
- Python 列表可以有重复的元素。他们也允许无。
- List 支持两个操作符 : +用于连接，而*用于重复元素。
- 我们可以分割一个列表，从它的元素中创建另一个列表。
- 我们可以使用循环的遍历列表元素。
- 我们可以使用“in”操作符来检查一个条目是否在列表中。我们也可以在列表中使用“not in”操作符。
- 列表用于存储我们想要添加/更新/删除元素的同类元素。
创建 Python 列表
Python 列表是通过将元素放在方括号中创建的，用逗号分隔。
fruits_list = ["Apple", "Banana", "Orange"]
我们可以在一个列表中保存不同类型的元素。
random_list = [1, "A", object(), 10.55, True, (1, 2)]
我们也可以有嵌套列表。
nested_list = [1, [2, 3], [4, 5, 6], 7]
我们可以通过在方括号中没有元素来创建一个空列表。
empty_list = []
Creating a List in Python
访问列表元素
我们可以使用索引来访问列表元素。索引值从 0 开始。
>>> vowels_list = ["a", "e", "i", "o", "u"]
>>> vowels_list[0]
'a'
>>> vowels_list[4]
'u'
如果索引不在范围内，将引发 IndexError。
>>> vowels_list[40]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
>>>
Accessing Python List Elements
我们也可以传递一个负的索引值。在这种情况下，元素从结尾返回到开始。有效的索引值范围是从-1 到-(列表长度)。
当我们需要一个特定的元素时，例如最后一个元素、倒数第二个元素等，这是很有用的。
>>> vowels_list = ["a", "e", "i", "o", "u"]
>>> vowels_list[-1] # last element
'u'
>>> vowels_list[-2] # second last element
'e'
>>> vowels_list[-5]
'a'
访问嵌套列表元素
我们可以使用嵌套索引来访问嵌套列表元素。让我们用一些简单的例子来理解这一点。
nested_list = [1, [2, 3], [4, 5, 6], 7]
# first element in the nested sequence at index 1
print(nested_list[1][0])
# second element in the nested sequence at index 1
print(nested_list[1][1])
# third element in the nested sequence at index 2
print(nested_list[2][2])
嵌套元素也可以是支持基于索引的访问的任何其他序列。例如，对于嵌套列表[1，(2，3)，(4，5，6)，7]，结果将是相同的。
我们也可以在嵌套列表中使用负索引。上面的代码片段可以重写如下。
nested_list = [1, (2, 3), (4, 5, 6), 7]
# first element in the nested sequence at third last index
print(nested_list[-3][0])
# last element in the nested sequence at third last index
print(nested_list[-3][-1])
# last element in the nested sequence at second last index
print(nested_list[-2][-1])
Python List Index Values
更新列表
我们可以使用赋值操作符来改变指定索引处的列表值。
>>> my_list = [1, 2, 3]
>>> my_list[1] = 10
>>> my_list
[1, 10, 3]
>>>
遍历列表
我们可以使用 for 循环来遍历列表中的元素。
>>> my_list = [1, 2, 3]
>>> for x in my_list:
... print(x)
...
1
2
3
>>>
如果想以相反的顺序遍历列表元素，可以使用 reversed()内置函数。
>>> my_list = [1, 2, 3]
>>> for x in reversed(my_list):
... print(x)
...
3
2
1
>>>
检查列表中是否存在某个项目
我们可以使用“in”操作符来检查一个条目是否在列表中。同样，我们也可以在列表中使用“not in”运算符。
>>> my_list = [1, 2, 3]
>>>
>>> 1 in my_list
True
>>> 10 in my_list
False
>>> 10 not in my_list
True
>>> 1 not in my_list
False
>>>
删除列表
我们可以使用“del”关键字来删除一个列表索引或整个列表本身。
>>> my_list = [1, 2, 3]
>>> del my_list[1]
>>> my_list
[1, 3]
>>>
>>> del my_list
>>> my_list
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'my_list' is not defined
>>>
分割列表
我们可以使用切片从列表的元素中创建一个新的列表。这在从源列表创建新列表时很有用。
切片技术包含两个用冒号分隔的索引。结果中包括左索引，不包括右索引。
list_numbers = [1, 2, 3, 4, 5, 6, 7, 8]
print(list_numbers[1:3])
print(list_numbers[:4])
print(list_numbers[5:])
print(list_numbers[:-5])
Python List Slicing
列表连接(+运算符)
我们可以使用+操作符连接多个元素列表来创建一个新列表。
>>> l1 = [1]
>>> l2 = [2, 3]
>>> l3 = [4, "5", (6, 7)]
>>>
>>> l1 + l2 + l3
[1, 2, 3, 4, '5', (6, 7)]
>>>
重复列表元素(*运算符)
Python List 还支持*操作符创建一个新的列表，其中的元素重复指定的次数。
>>> l1 = [1, 2]
>>>
>>> l1 * 3
[1, 2, 1, 2, 1, 2]
>>>
Python 列表长度
我们可以使用内置的 len()函数来获取列表的长度或大小。
>>> list_numbers = [1, 2, 3, 4]
>>> len(list_numbers)
4
内置的 list()构造函数
我们可以使用内置的 list()构造函数从 iterable 创建一个列表。这个函数接受一个 iterable 参数，所以我们可以传递字符串、元组等。
>>> l1 = list("ABC")
>>> l1
['A', 'B', 'C']
>>>
>>> l1 = list((1, 2, 3))
>>>
>>> l1
[1, 2, 3]
>>>
Python 列表函数
让我们看看 list 对象中的一些函数。
1.追加(对象)
这个函数用于将一个元素追加到列表的末尾。
>>> list_numbers = [1, 2, 3, 4]
>>> list_numbers.append(5)
>>> print(list_numbers)
[1, 2, 3, 4, 5]
2.索引(对象，开始，结束)
这个函数返回列表中对象的第一个索引。如果没有找到对象，那么ValueError被引发。
start 和 end 是可选参数，用于指定开始和结束对象搜索的索引。
>>> list_numbers = [1, 2, 1, 2, 1, 2]
>>>
>>> list_numbers.index(1)
0
>>> list_numbers.index(1, 1)
2
>>> list_numbers.index(1, 3, 10)
4
>>> list_numbers.index(10)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: 10 is not in list
>>>
3.计数(对象)
这个函数返回对象在列表中出现的次数。
>>> list_numbers = [1, 2, 1, 2, 1, 2]
>>> list_numbers.count(2)
3
>>> list_numbers.count(1)
3
4.反向()
这个函数反转列表元素。
>>> list_numbers = [1, 2, 3]
>>> list_numbers.reverse()
>>> print(list_numbers)
[3, 2, 1]
5.清除()
这个函数从列表中删除所有的元素。
>>> list_numbers = [1, 2, 5]
>>> list_numbers.clear()
>>> print(list_numbers)
[]
6.复制()
这个函数返回列表的一个浅层副本。
>>> list_items = [1, 2, 3]
>>> tmp_list = list_items.copy()
>>> print(tmp_list)
[1, 2, 3]
7.扩展(可迭代)
这个函数将 iterable 中的所有元素追加到这个列表的末尾。Python 中一些已知的可迭代对象是元组、列表和字符串。
>>> list_num = []
>>> list_num.extend([1, 2]) # list iterable argument
>>> print(list_num)
[1, 2]
>>> list_num.extend((3, 4)) # tuple iterable argument
>>> print(list_num)
[1, 2, 3, 4]
>>> list_num.extend("ABC") # string iterable argument
>>> print(list_num)
[1, 2, 3, 4, 'A', 'B', 'C']
>>>
8.插入(索引，对象)
此方法在给定索引之前插入对象。
如果索引值大于列表的长度，则对象被添加到列表的末尾。
如果索引值为负且不在范围内，则对象被添加到列表的开头。
>>> my_list = [1, 2, 3]
>>>
>>> my_list.insert(1, 'X') # insert just before index 1
>>> print(my_list)
[1, 'X', 2, 3]
>>>
>>> my_list.insert(100, 'Y') # insert at the end of the list
>>> print(my_list)
[1, 'X', 2, 3, 'Y']
>>>
>>> my_list.insert(-100, 'Z') # negative and not in range, so insert at the start
>>> print(my_list)
['Z', 1, 'X', 2, 3, 'Y']
>>> my_list.insert(-2, 'A') # negative and in the range, so insert before second last element
>>> print(my_list)
['Z', 1, 'X', 2, 'A', 3, 'Y']
>>>
9.流行指数
这个函数移除给定索引处的元素并返回它。如果没有提供索引，则删除并返回最后一个元素。
如果列表为空或索引超出范围，此函数将引发 IndexError 。
>>> my_list = [1, 2, 3, 4]
>>>
>>> my_list.pop()
4
>>> my_list
[1, 2, 3]
>>> my_list.pop(1)
2
>>> my_list
[1, 3]
>>> my_list.pop(-1)
3
>>> my_list
[1]
>>> my_list.pop(100)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: pop index out of range
>>>
10.移除(对象)
这个函数从列表中删除给定对象的第一个匹配项。如果在列表中没有找到该对象，则引发 ValueError 。
>>> my_list = [1,2,3,1,2,3]
>>> my_list.remove(2)
>>> my_list
[1, 3, 1, 2, 3]
>>> my_list.remove(20)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list
>>>
11.排序(键，反向)
该函数用于对列表元素进行排序。列表元素必须实现 lt(self，other) 函数。
我们可以指定一个 函数 名作为键用于排序。这样，我们可以定义自己的自定义函数来对列表元素进行排序。
反之则接受布尔值。如果为真，那么列表以相反的顺序排序。reversed 的默认值是 False ，元素按自然顺序排序。
>>> list_num = [1, 0, 3, 4, -1, 5, 2]
>>> list_num.sort()
>>> list_num
[-1, 0, 1, 2, 3, 4, 5]
>>> list_num.sort(reverse=True)
>>> list_num
[5, 4, 3, 2, 1, 0, -1]
>>>
列表与元组
- 列表是可变序列，而元组是不可变的。
- 该列表优先存储相同类型的数据类型，我们需要添加/更新它们。
- 列表比元组需要更多的内存，因为它支持动态长度。
- 遍历一个列表比遍历一个元组花费的时间稍微多一点，因为它的元素不需要存储在连续的内存位置。
结论
Python 列表是一个可变序列。它提供了各种功能来添加、插入、更新、删除它的元素。我们可以使用内置的 list()构造函数从其他可迭代元素创建一个列表。
参考资料:
Python loc()函数–从数据集中提取值
原文：https://www.askpython.com/python-modules/pandas/python-loc-function
嘿读者们！在本文中，我们将详细关注 Python loc()函数的功能。所以，让我们开始吧！！
Python loc()函数的工作原理
Python 由各种模块组成，这些模块具有处理和操作数据值的内置函数。
一个这样的模块是熊猫模块。
Pandas 模块使我们能够处理包含大量数据的大型数据集。
这就是Python loc() function出现的时候。loc()函数帮助我们轻松地从数据集中检索数据值。
使用 loc()函数，我们可以根据传递给该函数的索引值来访问适合特定行或列的数据值。
语法:
pandas.DataFrame.loc[index label]
我们需要提供索引值，以便在输出中表示整个数据。
索引标签可能是下列值之一:
- 单一标签–示例:字符串
- 字符串列表
- 带标签的切片对象
- 标签的数组的列表等。
因此，我们可以使用 loc()函数基于索引标签从数据集中检索特定的记录。
注意:如果传递的索引没有作为标签出现，它返回 KeyError 。
现在让我们使用下面的例子来关注相同的实现。
Python loc()函数示例
让我们首先使用 Pandas 模块中的数据框创建一个包含一组数据值的数据框，如下所示:
import pandas as pd
data = pd.DataFrame([[1,1,1], [4,4,4], [7,7,7], [10,10,10]],
index=['Python', 'Java', 'C','Kotlin'],
columns=['RATE','EE','AA'])
print(data)
数据帧:
RATE EE AA
Python 1 1 1
Java 4 4 4
C 7 7 7
Kotlin 10 10 10
创建了具有一组定义值的数据框后，现在让我们尝试检索一组包含特定索引的数据值的行或列，如下所示:
从数据帧中提取一行
print(data.loc['Python'])
因此，使用上面的命令，我们已经提取了与索引标签‘Python’相关联的所有数据值。
输出:
RATE 1
EE 1
AA 1
Name: Python, dtype: int64
从一个数据帧中提取多行
现在让我们尝试使用下面的命令同时提取与多个索引相关联的数据行和数据列。
print(data.loc[['Python','C']])
输出:
RATE EE AA
Python 1 1 1
C 7 7 7
使用 Python loc()提取一系列行
print(data.loc['Python':'C'])
这里，我们将 slice 对象与标签一起使用，以显示与从‘Python’到‘C’的标签相关联的行和列。
输出:
RATE EE AA
Python 1 1 1
Java 4 4 4
C 7 7 7
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
更多与 Python 相关的帖子，敬请关注，祝你学习愉快！！
参考
使用 Python locals()函数
原文：https://www.askpython.com/python/built-in-methods/python-locals-function
今天，我们将学习使用 Python locals()函数。这是另一个实用函数，对于调试程序非常有用。
locals()函数给出了当前的局部符号表，作为字典。
现在，如果您不确定局部符号表到底是什么，请继续阅读。让我们一步步来，从符号表的定义开始。
什么是符号表？
符号表是由关于不同符号的信息组成的表。在这里，符号可以表示任何东西——变量名、关键字、函数名等。
它们代表程序中所有变量、类和函数的名称。
通常，符号表不仅包括这些对象的名称，还包括其他有用的信息，如对象的类型、范围等。
现在你知道了符号表的意思，让我们来看看符号表的类别。
对于 Python 程序，有两种类型的符号表:
- 全局符号表->存储与程序的全局范围相关的信息
- 局部符号表->存储与程序的局部(当前)范围相关的信息
这是基于全局范围和局部(当前)范围定义的两个符号表。
当我们引用一个局部符号表时，当解释器逐行执行我们的代码时，我们引用我们的当前范围内的所有信息。
Python locals()函数到底是做什么的？
现在，locals()函数所做的就是简单地将本地符号表信息粘贴到控制台上，粘贴到调用locals()的作用域上！
所以这自然意味着 Python locals()的输出将是所有变量名称和属性、范围等的字典。
例如，如果您有一个名为main.py的文件。让我们把locals()作为我们唯一的语句，看看会发生什么。我们应该在main范围内获得所有相关信息(在这种情况下，它与全局范围相同)
# main.py
print(locals())
可能的输出
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x12ba85542>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/Users/askpython/home/locals_example.py', '__cached__': None}
嗯，我们可以看到main模块(全局范围)的一些属性，其中也包括一些包的细节！
正如你们中的一些人可能马上意识到的，这和这里的globals()是一样的，因为两者都指向同一个全局范围。
从局部范围调用局部变量()
现在，让我们考虑从一个函数调用局部范围内的locals()。
在函数内部调用局部变量()
让我们考虑一个简单的函数fun(a, b)，它有两个参数a和b，并返回总和。我们将在函数返回之前调用locals()。
# Global variable
global_var = 1234
def fun(a, b):
global global_var
temp = 100
print(f"locals() inside fun(a, b) = {locals()}")
return a + b
if __name__ == '__main__':
print(f"locals() outside fun(a, b) = {locals()}")
print(fun(10, 20))
输出
locals() outside fun(a, b) = {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x7f7023e1ff60>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'locals_example.py', '__cached__': None, 'global_var': 1234, 'fun': <function fun at 0x7f7023e5b1e0>}
locals() inside fun(a, b) = {'a': 10, 'b': 20, 'temp': 100}
30
这里，从fun(a, b)内部有一个明显的变化。这里，局部符号表仅由与该函数相关的名称组成。
因为局部作用域不是包的一部分，所以没有包信息，它只包含与函数相关的变量和参数。
还要注意，全局变量global_var是全局符号表的一部分，因此不存在于局部符号表中！
在类内部调用局部变量()
这类似于从函数中调用，但是这将包含所有的类方法和相关的属性。
让我们用一个例子快速看一下。
class Student():
def __init__(self, name):
self.name = name
def get_name(self):
return self.name
print(f"Calling locals() from inside a class => {locals()}")
print(f"Calling globals() from inside a class => {globals()}")
if __name__ == '__main__':
s = Student('Amit')
print(s.get_name())
在这里，我们将在定义了所有的类方法之后在类内部调用locals()。所以这些类方法也必须是局部符号表的一部分。
输出
Calling locals() from inside a class => {'__module__': '__main__', '__qualname__': 'Student', '__init__': <function Student.__init__ at 0x7fe2672f0c80>, 'get_name': <function Student.get_name at 0x7fe2672f0d08>}
Calling globals() from inside a class => {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x7fe2673cff28>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'locals_class.py', '__cached__': None}
Amit
的确，如你所见，locals()确实给出了相关方法！
当我们从类体内调用locals()时，我们将获得模块名、类名和类变量。
正如预期的那样，全局符号表中没有这种类型的内容。
结论
在本文中，我们学习了如何使用locals()函数从本地范围获取信息。这将从局部符号表中返回所有有用名称和属性的字典，对于调试非常有用。
参考
- Python locals()函数上的 StackOverflow 问题
- Python 官方文档关于 Python locals()
- 关于 Python locals()的 JournalDev 文章
Python 日志模块
原文：https://www.askpython.com/python-modules/python-logging-module
Python Logging 模块用于实现一个灵活的事件驱动日志系统，为应用存储日志事件或消息提供了一种便捷的方式。
Python 日志模块–记录器
Logger 对象是这个模块的对象，我们可以操纵它来完成所有需要的日志记录。
要实例化 Logger 对象，我们必须始终指定:
log_object = logging.getLogger(name)
对同名的getLogger(name)的多次调用总是引用同一个对象。
现在我们有了 logger 对象，我们可以对它使用多个函数。
将消息写入控制台
每当需要报告事件时，我们发出 logger 对象的内容，以便主运行程序得到状态变化的通知。
为此，我们对要发出的消息的严重程度进行了划分，称为LEVEL。
| 水平 | 当使用它时 |
| 调试 | 用于调试目的的详细信息 |
| 信息 | 确认一切正常 |
| 警告 | 意外发生的迹象 |
| 错误 | 更严重的问题是，当软件不能执行某些功能时 |
| 批评的 | 最严重的严重错误 |
这用于写入相应的日志文件或控制台。默认级别为WARNING，表示只跟踪该级别及以上的事件(即默认跟踪WARNING、ERROR、CRITICAL)
这使得程序员可以根据所选的严重程度控制如何显示这些状态消息。
格式:logging.info(message)将消息显示到控制台/文件上。
以下示例说明了这种方法
import logging
# This message will be printed to the console
logging.warning('Warning message')
# Will not be printed to the console
logging.info('Works as expected')
输出
WARNING:root:Warning message
记录到文件中
我们使用logging.basicConfig()来创建一个日志文件处理程序。
格式:logging.basicConfig(filename, level)
import logging
# Create the logfile
logging.basicConfig(filename='sample.log', level=logging.DEBUG)
logging.debug('Debug message')
logging.info('info message')
logging.warning('Warning message')
输出
[email protected] # cat sample.log
DEBUG:root:Debug message
INFO:root:info message
WARNING:root:Warning message
注意:对basicConfig()的调用必须在对debug()、info()等的任何调用之前。
还有另一个参数filemode，用于basicConfig()函数，它指定了日志文件的模式。
下面的例子使sample.log具有只写模式，这意味着写入其中的任何消息都将覆盖文件的先前内容。
logging.basicConfig(filename='sample.log', filemode='w', level=logging.DEBUG)
从多个模块记录日志
因为日志文件对象和处理程序在多个模块中提供了相同的上下文，所以我们可以在其他模块中直接使用它们。
下面显示了一个示例
# main.py
import logging
import sample_module
def main():
logging.basicConfig(filename='application.log', level=logging.INFO)
logging.info('main module started')
sample_module.sample_function()
logging.info('completed')
main()
# sample_module.py
import logging
def sample_function():
logging.info('Sample module doing work')
在这里，同一个日志对象可以由多个模块共享，因此非常适合模块化代码。
消息的格式
默认情况下，输出消息有一个包含节点名称和消息级别的消息头。要更改显示消息的格式，必须指定合适的格式。
import logging
logging.basicConfig(format='%(levelname)s:%(message)s', level=logging.DEBUG)
logging.debug('sample message')
输出
DEBUG:sample message
在邮件中显示日期和时间
添加%(asctime)s格式说明符来表示消息中的时间。
import logging
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p')
logging.warning('Sample message')
输出
12/26/2019 12:50:38 PM Sample message
记录器对象名称
默认情况下，日志消息的第一部分包含所使用的 logger 对象的级别和名称。(例如:DEBUG:ROOT:sample message)
通常，如果没有指定name参数，它默认为根节点的名称ROOT。
否则，最好使用__name__变量，因为它是 Python 包名称空间中模块的名称。
import logging
logger = logging.getLogger(__name__)
修改消息的级别
Logger 对象为我们提供了一种修改显示消息的阈值级别的方法。setLevel(level)方法用于设置记录器对象的级别。
格式:logger.setLevel(level)
import logging
logger = logging.getLogger(__name__)
# Set the log level as DEBUG
logger.setLevel(logging.DEBUG)
# The DEBUG level message is displayed
logger.debug('Debug message')
输出
No handlers could be found for logger "__main__"
这不是我们所期望的。为什么没有显示消息，什么是处理程序？
日志处理程序
日志处理程序是一个完成日志/控制台写入工作的组件。logger 对象调用日志处理程序来显示消息的内容。
与记录器的情况不同，处理程序从不直接实例化。有不同类型的处理程序，每一种都有自己的实例化方法。
处理程序的类型
日志模块中有各种各样的处理程序，但我们主要关注 3 个最常用的处理程序，即:
- StreamHandler
- 文件处理程序
- NullHandler
StreamHandler
StreamHandler 用于将日志输出发送到流，如stdout、stderr，或任何支持write()和flush()方法的类似文件的对象，如管道、FIFOs 等。
我们可以使用StreamHandler()来初始化一个 StreamHandler 对象，它可以在控制台上显示来自我们的 Logger 对象的消息。
前面的代码片段现在可以通过调用StreamHandler()和handler.setLevel()来完成。
import logging
# Instantiate the logger object
logger = logging.getLogger(name='hi')
# Set the level of the logger
logger.setLevel(logging.DEBUG)
# Initialise the handler object for writing
handler = logging.StreamHandler()
# The handler also needs to have a level
handler.setLevel(logging.DEBUG)
# Add the handler to the logger object
logger.addHandler(handler)
# Now, the message is ready to be printed by the handler
logger.debug('sample message')
输出
sample message
文件处理程序
为了记录到文件中，我们可以使用 FileHandler 对象。它也类似于 StreamHandler 对象，但是这里引用了一个文件描述符，以便对文件进行日志记录。
在实例化日志处理程序时，可以修改上面的代码片段。通过将类型更改为 FileHandler，可以将消息记录到文件中。
handler_name = logging.FileHandler(filename='sample.log', mode='a')
NullHandler
这个处理程序本质上不写任何东西(相当于将输出管道化到/dev/null)，因此被认为是一个无操作处理程序，对库开发人员很有用。
结论
我们学习了如何使用日志模块 API 根据消息的严重程度将消息记录到控制台和文件中。我们还学习了如何使用格式说明符来指定消息的显示方式，以及如何使用日志处理程序来控制和修改记录的消息的级别。
参考
日志模块的 Python 官方文档:https://docs . python . org/3/how to/Logging . html # Logging-basic-tutorial
Python 逻辑运算符
原文：https://www.askpython.com/python/python-logical-operators
Python 操作符是告诉 Python 解释器执行某些操作任务的符号/单词。逻辑运算符用于组合多个布尔语句。
Python 中有三个逻辑运算符。
- 和
- 或者
- 不
Python Logical Operators
Python 逻辑运算符流程图
下图描述了逻辑运算符的流程图。
Python Logical Operators Flowchart
Python 中的逻辑 AND 运算符
当两个语句/条件都为真时，语句返回为真。
示例:
a=20
b=10
if a > 0 and b > 0
print("Both a and b are positive numbers.")
输出:a 和 b 都是正数。
Python 中的逻辑 OR 运算符
当任一语句/条件为真时，语句返回真。
示例:
a=20
b= -10
if a > 0 or b > 0
print("True")
输出:真
Python 中的逻辑 NOT 运算符
该运算符处理单个值。它反转结果，即如果语句为真，not 运算符会将语句转换为假，反之亦然。
示例:
a=50
print(not(a % 4 or a > 0))
输出:假
在上面的例子中，条件a % 4 or a > 0 评估为真。但是，由于我们使用了 not 语句，它会反转结果，即它提供的结果为 False 。
Python 循环——关于 Python 中的循环你必须知道的事情
- 我们可以在 Python 中使用创建循环，使用创建循环。
- for 循环用于迭代一组条目，如元组、列表、集合、字典、字符串等。
- Python for 循环总是与“in”操作符一起使用。
- while 循环用于执行一个代码块，直到指定的条件变为
False。 - Python 有两个循环控制语句——break 和 continue。
- Python 也支持嵌套循环。
- 如果循环自然终止，我们可以将“else”块与 for 循环和 while 循环一起使用来执行代码块。
Python 循环语法
1.for 循环语法
for element in sequence:
# for statement code block
else: # optional
# else block code
2.while 循环语法
while condition:
# while block code
else: # optional
# else block code
Python for 循环示例
让我们看一个简单的 for 循环示例，它遍历序列、集合和字典项。
1.在字符串字符上循环
>>> str = "Python"
>>> for c in str:
... print(c)
...
P
y
t
h
o
n
>>>
2.在元组元素上循环
>>> t = (1,2,3)
>>> for i in t:
... print(i)
...
1
2
3
>>>
3.循环遍历列表元素
>>> fruits = ["Apple", "Banana", "Grapes"]
>>>
>>> for fruit in fruits:
... print(fruit)
...
Apple
Banana
Grapes
>>>
4.循环遍历一组元素
>>> my_set = set("ABCBA")
>>>
>>> for c in my_set:
... print(c)
...
C
B
A
>>>
请注意，该集合是一个无序序列，因此如果您运行相同的代码片段，输出可能会有所不同。
5.循环遍历字典条目
我们可以使用 dictionary items()方法来获取字典项的视图。然后在 for 循环中将它们解包为逗号分隔的值。
>>> num_dict = {1: "one", 2: "two", 3: "three"}
>>>
>>> for k, v in num_dict.items():
... print(f'{k}={v}')
...
1=one
2=two
3=three
>>>
Python while 循环示例
让我们看一些在 Python 中使用 while 循环的例子。
1.循环固定次数
假设我们必须运行一个代码块 5 次。我们可以用 while 循环来写这个循环。
>>> count = 5
>>>
>>> while count > 0:
... print("run this code")
... count -=1
...
run this code
run this code
run this code
run this code
run this code
>>>
2.循环随机次数
from random import Random
def change_count():
global count
r = Random()
count = r.randint(0, 12)
count = 0
while count < 10:
print("print this random times")
change_count()
这里我们使用 Random class 来改变 count 的值。因此 while 循环将随机运行多次。
将 else 语句与循环一起使用
我们可以在 for-loop 和 while-loop 中使用 else 语句。
1.else with for 循环
for i in (1, 2):
pass
else:
print("1\. for loop executed successfully")
for i in (1, 2):
try:
raise ValueError
except ValueError as ve:
pass
else:
print("2\. for loop executed successfully")
try:
for i in (1, 2):
raise ValueError
else:
print("3\. for loop executed successfully")
except ValueError as ve:
print("4\. ValueError Raised.")
Loops In Python
请注意，当异常在 for 循环中引发并且没有被处理时，else 块代码不会被执行。这种行为在 while 循环中也是一样的。
2.else 与 while 循环
count = 0
while count < 5:
pass
count += 1
else:
print("1\. else block code")
count = 0
try:
while count < 5:
raise ValueError
count += 1
else:
print("2\. else block code")
except ValueError as ve:
print("3\. except block")
输出:
Python while loop with else block
Python 循环控制语句
Python 有两个循环控制语句。
1.循环中的中断语句
ints = [1, 2, 3, 5, 4, 2]
for i in ints:
if i > 4:
break
print(i)
Python Loop Control Statement – break
2.循环中的 continue 语句
def process_even_ints(ints_list):
for i in ints_list:
if i % 2 != 0:
continue
print("Processing", i)
process_even_ints([1, 2, 3, 4, 5])
输出:
Python Loop Control Statement – continue
Python 中的嵌套循环
在 Python 中，我们可以有任何层次的嵌套循环。我们可以使用 for-loop 和 while loop 来创建嵌套循环。
下面是一个使用嵌套循环打印嵌套列表元素的简单例子。
nested_sequence = ["01", (2, 3), [4, 5, 6]]
for x in nested_sequence:
for y in x:
print(y)
Nested Loops In Python
结论
Python for 循环和 while 循环足以创建任何类型的循环。我们可以使用 break 和 continue 语句来控制循环执行流程。您还可以使用“else”块来记录循环的成功执行。
参考资料:
图像处理用 Mahotas 简介
原文：https://www.askpython.com/python-modules/python-mahotas-for-image-processing
嘿程序员们！我相信你已经实现了多个图像处理库。但是你知道蟒蛇的口袋里总有一些小把戏吗？！它还有另一个名为Mahotas的计算机视觉和图像处理库。
这个库是在C++ and operates on NumPy arrays中实现的，这使得它更快。目前，它包含around 100计算机视觉和图像处理功能。
在本教程中，我们将从使用 Mahotas 库进行一些简单的图像操作开始。在我们继续之前，我们将从使用pip命令安装库开始。使用下面显示的命令也可以做到这一点。
pip install mahotas
安装完库之后，我们将继续将库导入到程序中。我们将为图像显示相关的功能导入pylab。
import mahotas
from pylab import imshow, show
您可以使用任何图像进行图像处理。对于本教程，我们将使用来自互联网的随机图像。我们将使用mahotas.imread加载图像，使用imshow函数显示图像。
img = mahotas.imread('sample.jpg')
imshow(img)
show()
Mahotas Output 1
mean of an image用于多种目的，包括图像处理中的降噪。Mahotas 能够计算图像的平均值，但一次仅限于一个通道，因为我们的图像是彩色的，所以我们将一次减少到一个通道。
img0 = img[:,:,0]
img1 = img[:,:,1]
img2 = img[:,:,2]
mean0 = img0.mean()
mean1 = img1.mean()
mean2 = img2.mean()
print("Mean Value for the channel 1 is ", mean0)
print("Mean Value for the channel 2 is ", mean1)
print("Mean Value for the channel 3 is ", mean2)
我正在使用的图像总共有 3 个通道。因此，我分别计算 3 个通道的 3 个平均值。
Mean Value for the channel 1 is 195.63318904447684
Mean Value for the channel 2 is 172.86992779952305
Mean Value for the channel 3 is 172.8701535539508
使用该库，我们还可以使用下面的代码片段来裁剪图像。您可以将起始像素和结束像素指定为您想要的任何像素值。
我将首先尝试获得灯泡和手的焦点，它位于 x 轴上 1000 和 3000 像素值之间。
img2 = img[:, 1000:3000]
imshow(img2)
show()
Mahotas Output 2
让我们不要试图沿着 y 轴进一步裁剪图像，而只是聚焦在灯泡上。请看下面的代码片段。我们已经像之前一样从完整图像的绘图中的 x 轴和 y 轴选择了值。
img2 = img[1000:2500, 1300:2300]
imshow(img2)
show()
Mahotas Output 3
roundness是图像中的物体与形成一个完美的圆形有多相似/接近的量度。让我们来看两个不同的值，一个是完整的图像，另一个是有灯泡聚焦的图像。价值观的差异非常明显。
img1 = img[::,1]
r1 = mahotas.features.roundness(img1)
r2 = mahotas.features.roundness(img2)
print("Roundness of the full image : ", r1)
print("Roundness of the bulb focused image : ", r2)
代码的输出如下所示:
Roundness of the full image : 0.0
Roundness of the bulb focused image : 0.0009273648133338048
图像的local maxima是图像中被识别为local peaks的区域。可以使用下面的代码行显示它们。
img2 = img.max(1)
lmaxim = mahotas.locmax(img)
imshow(lmaxim)
show()
Mahotas Output 4
在下面代码片段中的Overlay image的帮助下，我们可以得到图像的灰度版本。
img = img[:, :, ]
ol = mahotas.overlay(img)
imshow(ol)
show()
Mahotas Output 5
结论
在本教程中，我们了解并学习了开发人员如何在一些基本函数的帮助下使用 mahotas 进行图像处理。图书馆里还有更多可用的功能。敬请关注更多内容！
也读作:Python 中的图像处理——边缘检测、大小调整、腐蚀、膨胀
Python 主函数示例
Python main function 的思想是只有在直接执行 Python 脚本时才执行一些代码。当同一个脚本作为 Python 模块导入到另一个程序中时，该函数不应执行。
如何写一个 Python 主函数？
当我们运行一个 python 程序时，它会执行其中的所有语句。因此，如果我们有一个 main()函数，并在程序中直接调用它，它将一直被执行，即使脚本是作为一个模块导入的。
但是，我们希望只在脚本被直接执行时才执行主函数。我们必须使用另一种方法来实现 Python 的 main 函数。
每当我们执行一个 Python 脚本时，它的作用域被设置为__main__，并且它可以被__name__变量检索。
但是，当脚本作为模块导入时，范围值被设置为 python 脚本的名称。我们可以在 if 语句中使用作用域名称来调用 main()方法。
让我们用一个简单的例子来研究它。Python 脚本名为main_function.py。
print("Start main_function.py")
print(f'__name__ value is {__name__}')
# main function
def main():
print('The main function')
if __name__ == '__main__':
main()
让我们使用 Python 解释器直接运行这个脚本。
$ python3.7 main_function.py
Start main_function.py
__name__ value is __main__
The main function
$
我们正在打印 name 变量值，它是 main。这就是 if 条件返回 True 并执行 main()函数的原因。
Python Main Function
当 Python 脚本作为模块导入时
现在，让我们看看当我们在另一个程序中将脚本作为 Python 模块导入时会发生什么。我正在创建另一个名为other_script.py的 Python 脚本。
import main_function
print('Hello World')
让我们看看当我们用 Python 解释器运行这个脚本时会发生什么。
$ python3.7 other_script.py
Start main_function.py
__name__ value is main_function
Hello World
$
main_function 模块的作用域名称是 main_function。这会导致 if 条件返回 False，并且不执行 main()方法。
Python 主函数最佳实践
- 习惯上保持主函数名为 main()。我们也可以保留任何其他名称，但是最好遵循命名约定。
- 最好将所有可直接执行的脚本代码放在 main()函数中。因为大多数时候我们不希望它们在脚本作为模块导入时执行。
参考资料:
Python 数学模块
原文：https://www.askpython.com/python-modules/python-math-module
Python 数学模块帮助用户直接访问程序中的数学函数。因此，它有助于解决和减少复杂的计算。
为了利用数学模块的功能，我们需要使用**import math**语句将其导入到我们的代码中。
数学模块不支持复杂的数据类型。cmath模块为复杂数据类型提供功能。
Python 数学模块中的函数列表
| 数学模块中的函数 | 功能描述 |
| 阶乘 | 返回 x 的阶乘 |
| 复制符号(x，y) | 返回带有 y 符号的 x |
| 晶圆厂(十) | 返回 x 的绝对值 |
| 上限(x) | 返回大于或等于 x 的最小整数。 |
| 楼层(x) | 返回小于或等于 x 的最大整数 |
| fmod(x, y) | 返回 x 除以 y 的余数 |
| frexp(x) | 返回 x 的尾数和指数对(m，e) |
| fsum(可迭代) | 返回 iterable 中值的精确浮点和 |
| isfinite(x) | 如果 x 既不是无穷大也不是 NaN(不是数字)，则返回 True |
| isinf(x) | 如果 x 是正无穷大或负无穷大，则返回 True |
| isnan(x) | 如果 x 是 NaN，则返回 True |
| ldexp(x，I) | 返回 x * (2i) |
| modf(x) | 返回 x 的小数和整数部分 |
| trunc(x) | 返回 x 的截断整数值 |
| exp(x) | 返回 ex |
| expm1(x) | 返回 e * * x–1 |
| log(x[，base]) | 返回以 x 为底的对数(默认为 e) |
| log1p(x) | 返回 1+x 的自然对数 |
| 对数 2(x) | 返回 x 的以 2 为底的对数 |
| log10(x) | 返回 x 的以 10 为底的对数 |
| 功率(x，y) | 返回 x 的 y 次幂 |
| sqrt(x) | 返回 x 的平方根 |
| 助理文书主任(十) | 返回 x 的反余弦值 |
| 阿辛(x) | 返回 x 的反正弦 |
| 阿坦(x) | 返回 x 的反正切值 |
| atan2(y，x) | 返回 atan(y / x) |
| cos(x) | 返回 x 的余弦值 |
| 海波(x，y) | 返回欧几里得范数 sqrt(xx + yy) |
| 罪恶(x) | 返回 x 的正弦值 |
| 谭(x) | 返回 x 的正切值 |
| 度(x) | 将角度 x 从弧度转换为角度 |
| radians(x) | 将角度 x 从度转换为弧度 |
| acosh(x) | 返回 x 的反双曲余弦值 |
| 阿西卡(x) | 返回 x 的反双曲正弦值 |
| 阿坦赫(x) | 返回 x 的反双曲正切值 |
| cosh(x) | 返回 x 的双曲余弦值 |
| 辛赫(x) | 返回 x 的双曲余弦值 |
| tanh(x) | 返回 x 的双曲正切值 |
| 电流变流体(x) | 返回 x 处的误差函数 |
| erfc(x) | 返回 x 处的互补误差函数 |
| 伽玛(x) | 返回 x 点的伽玛函数 |
| 真(x) | 返回伽玛函数在 x 点的绝对值的自然对数 |
| 圆周率 | 数学常数，圆的周长与直径之比(3.14159…) |
| e | 数学常数 e (2.71828…) |
Python 数学三角函数
下面的代码代表了数学模块的一些三角函数。
举例:
import math
angle_degree = 60
angle_radian = math.radians(angle_degree)
print('The input angle: ', angle_radian)
print('sin(x): ', math.sin(angle_radian))
print('cos(x): ', math.cos(angle_radian))
print('tan(x): ', math.tan(angle_radian))
输出:
Output-Trigonometric Functions
Python 数学幂和对数函数
下面的代码代表了数学模块的一些对数函数。
举例:
import math
print('The value of 2^2: ' + str(math.pow(2, 2)))
print('Square root of 121: ' + str(math.sqrt(121)))
print('The value of 8^e: ' + str(math.exp(8)))
print('The value of Log(625) with base 5: ' + str(math.log(625, 5)))
print('The value of Log(444) with base 2: ' + str(math.log2(444)))
print('The value of Log(1000) with base 10: ' + str(math.log10(1000)))
输出:
Output-Logarithmic Functions
Python 数学数值表示函数
下面的代码代表了数学模块的一些数值函数。
举例:
import math
input = 12.35
print('The Floor value of the given input: ' + str(math.floor(input)))
print('The Ceil value of the given input: ' + str(math.ceil(input)))
a = 20
b = -10
print('The value of a after copying the sign from b: ' + str(math.copysign(a, b)))
s1 = -25
s2 = 25
print('Absolute value of s1 and s2: ' + str(math.fabs(s1)) + ', ' + str(math.fabs(s2)))
my_input = [0,1,2,3,4,5,6,7,8,9,-1]
print('Sum of the elements of the list: ' + str(math.fsum(my_input)))
p = float('nan')
if math.isnan(p):
print('It is not a number')
q = float('inf')
y = 10
if math.isinf(q):
print('It is Infinity')
print(math.isfinite(q)) #q is not a finite number
print(math.isfinite(y)) #y is a finite number
输出:
Output-Numeric Functions
Python 数学 PI
Python 数学模块提供了一个称为 pi 的常数，可用于数学计算，例如:圆的面积。
举例:
import math
print('Value of pi: ', math.pi)
radius = 2
print('Area of Circle: ', math.pi * (radius ** 2))
输出:
Value of pi: 3.141592653589793 Area of Circle: 12.566370614359172
结论
因此，在本文中，我们已经用 Python 实现了数学模块提供的大部分功能。
参考
- Python 数学模块
- Python 数学函数文档
Python Matplotlib 教程
原文:# t0]https://www . aspython . com/python-modules/matplotlib/python-matplotlib
Python Matplotlib 是一个基本服务于数据可视化目的的库。Matplotlib 库的构建块是二维 NumPy 数组。
因此，使用 Python Matplotlib 可以通过图形、图表等来处理和表示相对大量的信息/数据。
Python Matplotlib 入门
为了使用 Matplotlib 库进行数据可视化，我们需要通过pip命令安装它。
pip install matplotlib
接下来，每当我们希望使用它的内置函数时，我们都需要导入这个库。
from matplotlib import pyplot
matplotlib.pyplot基本上是一个接口，用于向使用 Matplotlib 包创建的图形、图表等添加样式函数。
使用 Python Matplotlib 绘图
Python Matplotlib 提供了各种类型的图表来表示和可视化数据。
使用 Python Matplotlib，可以使用以下类型的图形/图表来可视化数据:
- 线图
- 散点图
- 直方图
- 条形图
- 饼状图
1.线形图
from matplotlib import pyplot
# x-axis values
roll_num = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# y-axis values
marks = [55,75,96,75,36,45,87,99,100]
pyplot.plot(roll_num, marks)
pyplot.show()
在上面的代码片段中，我们使用了两个 Python 列表 (roll_num，marks)作为输入数据点。
pyplot.plot()功能用于绘制代表数据的直线。它接受 x 轴和 y 轴值作为参数。
pyplot.show()函数用于显示****py plot . plot()函数绘制的值。
输出:
Line Plot
2.散点图
from matplotlib import pyplot
# x-axis values
roll_num = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# y-axis values
marks = [55,75,96,75,36,45,87,99,100]
pyplot.scatter(roll_num, marks)
pyplot.show()
pyplot.scatter(x-axis, y-axis)用于以分散的方式绘制数据。
输出:
Scatter Plot
3.柱状图
from matplotlib import pyplot
marks = [55,75,96,75,36,45,87,99,100]
pyplot.hist(marks, bins = 7)
pyplot.show()
pyplot.hist()函数用于通过直方图来表示数据点。它接受两个参数:
- 要绘制的数据列表
- 划分和显示数据的范围(箱)数量。
在上面的代码片段中，pyplot.hist()接受一个参数 bin，该参数 bin 基本上表示分配和显示输入列表值(数据)的分段数。
输出:
Histogram
4.条形图
import numpy as np
import matplotlib.pyplot
city = ('Pune', 'Satara', 'Mumbai', 'Kanpur', 'Bhopal', 'Assam')
y_val = np.arange(len(city))
rank = [4, 7, 1, 3, 2, 5]
pyplot.bar(y_val, rank, align='center')
pyplot.xticks(y_val, city)
pyplot.ylabel('Rank')
pyplot.title('City')
pyplot.show()
pyplot.bar()函数以矩形条的形式表示数据。该函数接受一个参数y-val，它是代表 x 坐标的标量值。参数align用于将柱状图数值设置为左/右/中。
pyplot.xticks()用于设置 x 轴的刻度位置。
pyplot.ylabel()用于给 y 轴的数据设置一个标签文本值。
pyplot.title()设置条形图的标题值。
输出:
Bar Plot
5.饼图
import numpy as np
import matplotlib.pyplot
city = ('Pune', 'Satara', 'Mumbai', 'Kanpur', 'Bhopal', 'Assam')
rank = [4, 7, 1, 3, 2, 5]
explode = (0.2, 0, 0, 0, 0, 0)
colors = ['yellowgreen', 'pink', 'purple', 'grey', 'red', 'orange']
pyplot.pie(rank, explode=explode, labels=city, colors=colors,
autopct='%1.1f%%', shadow=True, startangle=120)
pyplot.axis('equal')
pyplot.show()
pyplot.pie()功能用来以饼状图的形式表示数据。
pyplot.pie()的这些参数提供以下功能:
explode:提供一个标量值来设置饼图的一部分。labels:提供文本值来表示图表的各个部分。colors:提供图表各部分的颜色设置。autopct:用数值标注图表的楔形或分数。shadow:接受布尔值。如果设置为 TRUE，它会在饼图的分数下方创建阴影。startangle:将图表的起点从 x 轴旋转特定角度。
pyplot.axis('equal')功能可实现等比例缩放，并创建缩放的圆形图表。
输出:
Pie Chart
向 Matplotlib 中的图表添加要素
from matplotlib import pyplot
# x-axis values
roll_num = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# y-axis values
marks = [55,75,96,75,36,45,87,99,100]
attendance = [25, 75, 86, 74, 85, 25, 35, 63, 29]
pyplot.plot(roll_num, marks, color = 'green', label = 'Marks')
pyplot.plot(roll_num, attendance, color = 'blue', label = 'Attendance')
pyplot.legend(loc='upper left', frameon=True)
pyplot.show()
在上面的代码片段中，我们添加了属性，如颜色和标签。
label属性设置文本，以非常简化的方式表示绘制的值。
pyplot.legend()将标签和信息放置在绘制的图表上。
参数loc用于设置要显示的标签的位置。
参数frameon接受布尔值。如果设置为 true，它会在通过 loc 参数设置的位置放置的标签周围创建一个类似矩形框的边框。
输出:
Line Plot with attributes
在 Matplotlib 中使用面向对象的 API 绘图
Python 中的数据可视化也可以使用面向对象的 API 来完成。
语法:
Class_Name, Object_Name = matplotlib.pyplot.subplots(‘rows’, ‘columns’)
举例:
# importing the matplotlib library
import matplotlib.pyplot as plt
# x-axis values
roll_num = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# y-axis values
marks = [55,75,96,75,36,45,87,99,100]
# creating the graph with class 'img'
# and it's object 'obj' with '1' row
# and '1' column
img, obj = plt.subplots(1, 1)
# plotting the values
obj.plot(roll_num, marks)
# assigning the layout to the values
img.tight_layout()
img 表示类的名称， obj 表示对象的名称。
pyplot.subplots(no of rows, no of columns)函数允许在一次函数调用中创建通用和多个布局/图形。
它接受行数和列数作为强制参数，以创建用于绘制值的子部分。默认值是 pyplot.subplots(1，1) ，它只创建输入数据的一种布局。
class_name.tight.layout()调整 pyplot.subplots()的参数以适合图表的图形区域。
输出:
Object Oriented API With Matplotlib
用 Matplotlib 处理 PNG 图像
Python Matplotlib 也提供了处理 PNG 图像文件的函数。
我们借助一个例子来理解一下。
举例:
# importing pyplot and image from matplotlib
import matplotlib.pyplot as plt
import matplotlib.image as img
# reading png image file
img = img.imread('C:\\Users\\HP\\Desktop\\Pie Chart.png')
color_img = img[:, :, 0] #applying default colormap
# show image
plt.imshow(color_img)
在上面的代码片段中，matplotlib.image.imread(image path)用于读取输入图像。
color_img = img[:，:，0] 用于设置图像的默认色彩映射表，使其高亮显示。
pyplot.imshow()用于显示图像。
原始图像:
Input Image
输出 图像:
Working With Images In Matplotlib
用熊猫和 Matplotlib 绘图
Python Matplotlib 也可以使用 Pandas 模块通过生动的绘图技术来表示数据。
为此，我们需要安装并导入 Python Pandas 模块。我们可以进一步创建数据框架来绘制数据。
以下是使用 Pandas 模块在 Matplotlib 中绘制数据时使用的不同类型的图形/图表:
- 直方图
- 箱线图
- 密度图
- 六边形面元图
- 散点图
- 面积图
- 饼状图
1.柱状图
import matplotlib.pyplot as p
import pandas as pd
import numpy as np
val = pd.DataFrame({'v1': np.random.randn(500) + 1,
'v2': np.random.randn(500),
'v3': np.random.randn(500) - 1},
columns =['v1', 'v2', 'v3'])
p.figure()
val.plot.hist(alpha = 0.5)
p.show()
plot.hist()功能用于绘制数据值。参数alpha基本上是一个浮点值，用于混合绘制图形的色阶。
pyplot.figure()功能是创建出输入值的图。
在上面的代码片段中，我们使用 Python NumPy 模块的 numpy.random.randn()函数为输入值生成了随机数据。
输出:
Matplotlib With Pandas Histogram
2.箱形图
from matplotlib import pyplot
import pandas as pd
import numpy as np
val = pd.DataFrame(np.random.randn(500,6),
columns =['P', 'Q', 'R', 'S', 'T', 'W'])
val.plot.box()
pyplot.show()
plot.box()函数用于通过四分位数表示一组标量数据。
此外，我们通过向它传递六列值绘制了六个四分位数。
输出:
Matplotlib With Pandas Box Plot
3.密度图
这基本上是一个内核密度估计(KDE)图。它提供输入值的概率密度函数。
from matplotlib import pyplot
import pandas as pd
import numpy as np
val = pd.DataFrame(np.random.randn(500,2),
columns =['P', 'Q',])
val.plot.kde()
pyplot.show()
plot.kde()函数用于绘制随机生成值的概率密度。
输出:
Matplotlib With Pandas Density Plot
4.六边形箱线图
六边形二进制图用于估计一大组数据值中两个标量值之间的关系。
from matplotlib import pyplot
import matplotlib.pyplot
import pandas as pd
import numpy as np
val = pd.DataFrame(np.random.randn(500,2),
columns =['Temperature', 'Fire-Intensity',])
val.plot.hexbin(x ='Temperature', y ='Fire-Intensity', gridsize = 30)
pyplot.show()
plot.hexbin()函数绘制了传递值(即温度和火灾强度)之间的数值关系。
参数gridsize用于设置 x 方向上六边形的数量，表示传递值之间的关系。
输出:
Matplotlib With Pandas Hexagonal Bin Plot
5.散点图
import matplotlib.pyplot
import pandas as pd
import numpy as np
val = pd.DataFrame(np.random.randn(300,5),
columns =['A', 'Z', 'W', 'Y', 'S'])
val.plot.scatter(x='Z', y='Y')
pyplot.show()
输出:
Matplotlib With Pandas -Scatter Plot
6.面积图
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
val = pd.DataFrame(np.random.rand(9, 5), columns =['A', 'B', 'C', 'D', 'E'])
val.plot.area()
plt.show()
plot.area()用于绘制相应的输入数据。通过此函数，作为输入传递到 DataFrame 的所有列都被绘制为图表中区域的一部分。
输出:
Matplotlib With Pandas Area Plot
7.饼图
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
val = pd.Series(np.random.rand(5),
index =['w','f', 'e', 'b', 'a'], name ='Pie-Chart')
val.plot.pie(figsize =(5, 5))
plt.show()
plot.pie()功能用来以饼状图的形式表示输入的数据。
参数figsize用于设置绘制图形的宽度和高度。
输出:
Matplotlib With Pandas Pie Chart
结论
因此，在本文中，我们已经理解了 Python 的 Matplotlib 库所提供的功能。
参考
- Python Matplotlib 教程
- Python Matplotlib 文档
Python 矩阵教程
我们可以用一个二维列表或者一个二维数组的形式实现一个 Python 矩阵。要对 Python 矩阵执行操作，我们需要导入 Python NumPy 模块。
Python 矩阵在统计学、数据处理、图像处理等领域是必不可少的。
创建 Python 矩阵
Python 矩阵可使用以下技术之一创建:
- 通过使用列表
- 通过使用 arange()方法
- 利用矩阵()方法
1.使用列表创建矩阵
使用列表作为的输入，函数numpy.array()可以用来创建一个数组。
举例:
import numpy
input_arr = numpy.array([[ 10, 20, 30],[ 40, 50, 60]])
print(input_arr)
输出:
[[10 20 30]
[40 50 60]]
如上所述，输出以列表的形式表示一个带有给定输入集的二维矩阵。
2.使用“numpy.arange()”函数创建矩阵
在 Python 中，numpy.arange()函数和列表输入可以用来创建一个矩阵。
举例:
import numpy
print(numpy.array([numpy.arange(10,15), numpy.arange(15,20)]))
输出:
[[10 11 12 13 14]
[15 16 17 18 19]]
3.使用“numpy.matrix()函数”创建矩阵
numpy.matrix()函数使我们能够用 Python 创建一个矩阵。
语法:
numpy.matrix(input,dtype)
- 输入:将元素输入形成矩阵。
- dtype:对应输出的数据类型。
举例:
import numpy as p
matA = p.matrix([[10, 20], [30, 40]])
print('MatrixA:\n', matA)
matB = p.matrix('[10,20;30,40]', dtype=p.int32) # Setting the data-type to int
print('\nMatrixB:\n', matB)
输出:
MatrixA:
[[10 20]
[30 40]]
MatrixB:
[[10 20]
[30 40]]
Python 中矩阵的添加
矩阵的加法运算可以通过以下方式执行:
- 传统方法
- 通过使用'+'运算符
1.传统方法
在这种传统方法中，我们基本上从用户那里获取输入，然后使用循环的(遍历矩阵的元素)和 '+'操作符执行加法操作。
举例:
import numpy as p
ar1 = p.matrix([[11, 22], [33, 44]])
ar2 = p.matrix([[55, 66], [77, 88]])
res = p.matrix(p.zeros((2,2)))
print('Matrix ar1 :\n', ar1)
print('\nMatrix ar2 :\n', ar2)
# traditional code
for x in range(ar1.shape[1]):
for y in range(ar2.shape[0]):
res[x, y] = ar1[x, y] + ar2[x, y]
print('\nResult :\n', res)
注意 : Matrix.shape返回特定矩阵的维数。
输出:
Matrix ar1 :
[[11 22]
[33 44]]
Matrix ar2 :
[[55 66]
[77 88]]
Result :
[[ 66\. 88.]
[ 110\. 132.]]
2.使用“+”运算符
这种方法为代码提供了更好的效率，因为它减少了 LOC(代码行),从而优化了代码。
举例:
import numpy as p
ar1 = p.matrix([[11, 22], [33, 44]])
ar2 = p.matrix([[55, 66], [77, 88]])
res = p.matrix(p.zeros((2,2)))
print('Matrix ar1 :\n', ar1)
print('\nMatrix ar2 :\n', ar2)
res = ar1 + ar2 # using '+' operator
print('\nResult :\n', res)
输出:
Matrix ar1 :
[[11 22]
[33 44]]
Matrix ar2 :
[[55 66]
[77 88]]
Result :
[[ 66 88]
[110 132]]
Python 中的矩阵乘法
Python 中的矩阵乘法可通过以下方式实现:
- 标量积
- 矩阵乘积
数积
在标量积中，标量/常数值乘以矩阵的每个元素。
***' '运算符用于将标量值乘以输入矩阵元素。
举例:
import numpy as p
matA = p.matrix([[11, 22], [33, 44]])
print("Matrix A:\n", matA)
print("Scalar Product of Matrix A:\n", matA * 10)
输出:
Matrix A:
[[11 22]
[33 44]]
Scalar Product of Matrix A:
[[110 220]
[330 440]]
矩阵积
如上所述，我们可以使用“*”操作符仅用于标量乘法。为了进行矩阵乘法，我们需要使用numpy.dot()函数。
numpy.dot()函数以 NumPy 数组作为参数值，根据矩阵乘法的基本规则进行乘法运算。
举例:
import numpy as p
matA = p.matrix([[11, 22], [33, 44]])
matB = p.matrix([[2,2], [2,2]])
print("Matrix A:\n", matA)
print("Matrix B:\n", matB)
print("Dot Product of Matrix A and Matrix B:\n", p.dot(matA, matB))
输出:
Matrix A:
[[11 22]
[33 44]]
Matrix B:
[[2 2]
[2 2]]
Dot Product of Matrix A and Matrix B:
[[ 66 66]
[154 154]]
Python 矩阵的减法
****'-'运算符用于对 Python 矩阵进行减法运算。
举例:
import numpy as p
matA = p.matrix([[11, 22], [33, 44]])
matB = p.matrix([[2,2], [2,2]])
print("Matrix A:\n", matA)
print("Matrix B:\n", matB)
print("Subtraction of Matrix A and Matrix B:\n",(matA - matB))
输出:
Matrix A:
[[11 22]
[33 44]]
Matrix B:
[[2 2]
[2 2]]
Subtraction of Matrix A and Matrix B:
[[ 9 20]
[31 42]]
Python 矩阵的除法
****在 Python 中可以使用 '/'运算符对矩阵的元素进行标量除法。
“/”运算符用标量/常数值除矩阵的每个元素。
****举例:
import numpy as p
matB = p.matrix([[2,2], [2,2]])
print("Matrix B:\n", matB)
print("Matrix B after Scalar Division operation:\n",(matB/2))
输出:
Matrix B:
[[2 2]
[2 2]]
Matrix B after Scalar Division operation:
[[ 1\. 1.]
[ 1\. 1.]]
Python 矩阵的转置
矩阵的转置基本上包括在相应对角线上矩阵的翻转，即交换输入矩阵的行和列。行变成列，反之亦然。****
例如:让我们考虑一个维数为 3×2 的矩阵 A，即 3 行 2 列。在执行转置操作之后，矩阵 A 的维数将是 2×3，即 2 行 3 列。
Matrix.T基本上执行输入矩阵的转置，并产生一个新矩阵作为转置操作的结果。
举例:
import numpy
matA = numpy.array([numpy.arange(10,15), numpy.arange(15,20)])
print("Original Matrix A:\n")
print(matA)
print('\nDimensions of the original MatrixA: ',matA.shape)
print("\nTranspose of Matrix A:\n ")
res = matA.T
print(res)
print('\nDimensions of the Matrix A after performing the Transpose Operation: ',res.shape)
输出:
Original Matrix A:
[[10 11 12 13 14]
[15 16 17 18 19]]
Dimensions of the original MatrixA: (2, 5)
Transpose of Matrix A:
[[10 15]
[11 16]
[12 17]
[13 18]
[14 19]]
Dimensions of the Matrix A after performing the Transpose Operation: (5, 2)
在上面的代码片段中，我创建了一个 2×5 的矩阵，即 2 行 5 列。
在执行转置操作之后，结果矩阵的维数是 5×2，即 5 行 2 列。
Python 矩阵的指数
矩阵的指数是按元素计算的，即每个元素的指数是通过将元素提升到输入标量/常数值的幂来计算的。****
举例:
**import numpy
matA = numpy.array([numpy.arange(0,2), numpy.arange(2,4)])
print("Original Matrix A:\n")
print(matA)
print("Exponent of the input matrix:\n")
print(matA ** 2) # finding the exponent of every element of the matrix**
输出:
**Original Matrix A:
[[0 1]
[2 3]]
Exponent of the input matrix:
[[0 1]
[4 9]]**
在上面的代码片段中，我们通过将输入矩阵的每个元素的指数提升到 2 的幂，找到了它的指数。
使用 NumPy 方法的矩阵乘法运算
以下技术可用于执行 NumPy 矩阵乘法:
- 使用乘法()方法
- 使用 matmul()方法
- 使用 dot()方法——本文已经介绍过了
方法 1:使用 multiply()方法
numpy.multiply()方法对输入矩阵执行逐元素乘法。
举例:
**import numpy as p
matA = p.matrix([[10, 20], [30, 40]])
print('MatrixA:\n', matA)
matB = p.matrix('[10,20;30,40]', dtype=p.int32) # Setting the data-type to int
print('\nMatrixB:\n', matB)
print("Matrix multplication using numpy.matrix() method")
res = p.multiply(matA,matB)
print(res)**
输出:
**MatrixA:
[[10 20]
[30 40]]
MatrixB:
[[10 20]
[30 40]]
Matrix multplication using numpy.matrix() method
[[ 100 400]
[ 900 1600]]**
方法 2:使用 matmul()方法
numpy.matmul()方法对输入矩阵执行矩阵乘积。
举例:
**import numpy as p
matA = p.matrix([[10, 20], [30, 40]])
print('MatrixA:\n', matA)
matB = p.matrix('[10,20;30,40]', dtype=p.int32) # Setting the data-type to int
print('\nMatrixB:\n', matB)
print("Matrix multplication using numpy.matmul() method")
res = p.matmul(matA,matB)
print(res)**
输出:
**MatrixA:
[[10 20]
[30 40]]
MatrixB:
[[10 20]
[30 40]]
Matrix multplication using numpy.matmul() method
[[ 700 1000]
[1500 2200]]**
我强烈推荐所有的读者阅读下面的教程，以彻底理解 NumPy 矩阵乘法:NumPy 矩阵乘法
NumPy 矩阵转置
numpy.transpose()函数对输入矩阵进行转置，产生一个新矩阵。
举例:
**import numpy
matA = numpy.array([numpy.arange(10,15), numpy.arange(15,20)])
print("Original Matrix A:\n")
print(matA)
print('\nDimensions of the original MatrixA: ',matA.shape)
print("\nTranspose of Matrix A:\n ")
res = matA.transpose()
print(res)
print('\nDimensions of the Matrix A after performing the Transpose Operation: ',res.shape)**
输出:
**Original Matrix A:
[[10 11 12 13 14]
[15 16 17 18 19]]
Dimensions of the original MatrixA: (2, 5)
Transpose of Matrix A:
[[10 15]
[11 16]
[12 17]
[13 18]
[14 19]]
Dimensions of the Matrix A after performing the Transpose Operation: (5, 2)**
推荐阅读:NumPy 矩阵转置()函数
结论
因此，在本文中，我们已经理解了在 Python Matrix 上执行的操作，并且还了解了 NumPy Matrix 操作。
参考
- Python 矩阵
- NumPy 文档
- Python NumPy
Python max()方法
原文：https://www.askpython.com/python/built-in-methods/python-max-method
介绍
在本教程中，我们将了解如何使用Python max()方法。基本上，Python max()方法返回一组被传递的值或被传递的 iterable 的元素中的最大值。
使用 Python max()方法
下面是使用 Python max()方法在可迭代中寻找最大值的语法，
max(iterable, *[, key, default])
这里，
- iterable 是包含最大值的对象，
- 键指定单参数排序函数，
- 而 default 是方法在传递的 iterable 为空的情况下返回的默认值。
为了找到作为参数传递的两个或多个值中的最大值，
max(arg1, arg2, *args[, key])
这里，
- arg1，arg2 ，…。 argn 是 n 个值，其中
max()方法将返回最大值， - 关键还是排序功能。
使用 Python max()方法
我们可以以各种方式使用max()方法来寻找给定 iterable 或两个或更多参数的最大值。
让我们看看这个方法是如何处理一个 iterable 对象，两个或更多的值，指定的键函数，以及作为参数传递的多个 iterable 对象。
使用可迭代对象
对于下面的例子，我们考虑一个列表,其中有一些值，我们要找到最大的元素。仔细看下面给出的代码。
#initialisation of list
list1 = [ 1,3,4,7,0,4,8,2 ]
#finding max element
print("max value is : ", max(list1,default=0))
输出:
max value is : 8
正如我们所看到的，对于上面的代码，我们初始化了一个列表，list1并直接将其传递给max()方法，默认值设置为 0 。该函数返回 8 ，因为它是最大值。
如果列表为空，该函数将传递默认值，即 0 。
向 Python max()方法传递两个或多个值
当两个或更多的值被传递给max()方法时，它返回所有值中的最大值。这些参数可以是整数、浮点值、字符甚至字符串。
让我们举一个例子，
print("max value is : ", max(6,1,73,6,38))
输出:
max value is : 73
如我们所愿，我们得到了最大值， 73。
带按键功能
正如我们前面提到的，这个键是一个单行排序函数，在这个函数的基础上可以找到一组值中的最大值。
例如，如果我们想从元组列表的中找到一个元组，该元组具有第二个元素的最大值。让我们看看如何做到这一点。
#initialisation of variables
list1 = [(9,2,7), (6,8,4), (3,5,1)]
def f(tuple_1):
return tuple_1[1]
print("max : ", max(list1, key=f))
输出:
max : (6, 8, 4)
这里，f()是一个用户自定义函数，返回传递的元组的第第 2 个元素。将这个函数作为一个键传递给max()方法可以确保返回一个具有最大的第二个元素的元组。对于我们的例子，它是 ( 6，8，4)。
将多个可重复项作为参数传递
如前所述，Python max()方法也可以返回多个可迭代元素中最大的一个作为参数。这些参数可以是可迭代的，如字符串、字符、元组、列表等..
默认为，max()方法返回列表、元组等最大第 0th】元素的对象。对于字符串，它比较传递的每个字符串的第一个字符。****
下面我们以元组为例。仔细看代码。
#initialisation of variables
tuple1 = (5,23,7)
tuple2 = (4,1,7)
tuple3 = (7,37,1)
print("max : ", max(tuple1,tuple2,tuple3))
输出:
max : (7, 37, 1)
在这个例子中，个带有一些初始值的元组被直接传递给了max()方法。其返回具有最大第一元素的元组，即 (7，37，1) 。
结论
所以在本教程中，我们学习了 Python max()方法，它的用法和工作原理。
请记住，如果没有设置默认的值，并且将一个空的 iterable 作为参数传递给max()函数，就会产生一个值错误。
关于这个话题的任何进一步的问题，请随意使用下面的评论。
参考
- python max()–日志开发帖子，
- max()–Python 文档，
- 使用‘key’和 lambda 表达式的 python max 函数–堆栈溢出问题。
Python min()方法
原文：https://www.askpython.com/python/built-in-methods/python-min-method
介绍
在本教程中，我们将了解 Python min()方法的用法。
基本上，Python min()方法返回一组被传递的值或被传递的 iterable 的元素中的最小值。
了解 Python min()方法
下面给出了在 Python 中使用min()方法的一般语法。使用这个我们可以在一个可迭代的元素(列表、元组、字符串等)中找到最小值。).
min(iterable, *[, key, default])
为了找到一组项目中的最小值，我们可以直接将它们传递给用逗号分隔的min()函数(“，”)。
min(arg1, arg2, *args[, key])
这里，
- iterable 包含需要寻找最小值的值，
- 键是单行订购功能，
- default 是函数返回的默认值，如果传递的 iterable 为空，
- arg1，arg2，… argn 是 min()函数将返回最小值的一组值。
现在我们已经理解了使用min()方法的语法，让我们看一些例子来更好地理解它的工作原理。
使用 Python min()方法
如前所述，我们可以使用 Python min()函数在作为参数传递的一组值中或者在传递的 iterable 的元素中找到最小值。
现在，为了理解工作原理，我们举几个例子。
1.使用可迭代对象
min()函数广泛用于查找出现在可迭代中的最小值，如列表、元组、列表列表、元组列表等。在简单列表和元组的情况下，它返回 iterable 中存在的最小值。
看看下面给出的例子。
# initialisation of list
list1 = [23,45,67,89]
# finding min element
print("Min value is : ", min(list1, default=0))
输出:
Min value is : 23
在这里，将列表 list1 直接传递给min()方法会给出列表中所有元素的最小值，即 23 。将default值设置为 0 ，这样如果传递的 iterable 为空，该方法将返回默认值 (0) 。
对于字符的列表，min()方法返回具有最小 ASCII 值的元素。
2.有多个参数
当我们向min()方法传递多个参数时，它返回所有参数中最小的一个。
注意，我们可以向min()方法传递多个值以及多个可迭代对象。对于多个 iterabless，该方法返回第一个元素最小的 iterable(值在第个索引处)。
下面的例子很容易解释这一点:
# initialisation of lists
list1 = [23,45,67]
list2 = [89,65,34]
list3 = [19,90,31]
# finding min element
print("Min among set of values is : ", min(765,876,434))
print("Min list among the given lists is : ", min(list1,list2,list3))
输出:
Min among set of values is : 434
Min list among the given lists is : [19, 90, 31]
对于上面的例子，当我们将多个值作为参数传递给min()方法时，它只是返回给我们最小值( 434
然而，对于 list1、list2 和 list3，它返回 list3 ，因为它具有最小的第 0索引值( 19 )。
3.带按键功能
正如我们前面提到的，键函数是一个单行排序函数，它根据哪个参数来确定要返回的最小值。
让我们举个例子来理解这个关键概念。
# initialisation of variables
list_of_tuples = [(9, 2, 7), (6, 8, 4), (3, 5, 1)]
list1 = [23,45]
list2 = [89,65,34]
list3 = [19,90,31,67]
def ret_2nd_ele(tuple_1):
return tuple_1[1]
#find Min from a list of tuples with key on the basis of the 2nd element
print("Min in list of tuples : ", min(list_of_tuples, key=ret_2nd_ele))
#find min from a bunch of lists on the basis of their length
print("List with min length : ", min(list1,list2,list3,key=len))
输出:
Min in list of tuples : (9, 2, 7)
List with min length : [23, 45]
- 我们首先初始化元组列表以及其他三个不同长度的整数列表，
- 然后我们定义一个函数
ret_2nd_ele(),它返回传递的元组的第 2 个元素或第 1 个索引项， - 之后，我们将 list_of_tuples 传递给以
ret_2nd_ele()函数为键的min()方法， - 我们再次将三个列表列表 1 、列表 2 和列表 3 作为参数传递给
min()方法，并将一个键设置为内置的len()方法。
这样，我们得到了元组列表中具有最小第 2 个元素(第 1 项)的元组。以及三个列表中长度最小的列表(使用len())，即list1。
结论
请记住，传递一个没有为min()方法设置默认值的空 iterable 会引发一个ValueError。
这就是关于 Python 中的min()方法的教程。如有任何进一步的问题，欢迎使用下面的评论。
参考
- python min()–journal dev Post
- min()–Python 文档
- python min 函数如何工作–堆栈溢出问题
Python 模块与 Python 包
原文：https://www.askpython.com/python/python-modules-vs-python-packages
在这篇关于 Python 模块和 Python 包的教程中，我们将讨论它们是什么，并理解两者之间的区别。
我们开始吧！
什么是 Python 模块？
Python 中的模块被定义为包含特定 Python 语句和定义的文件。它们有助于以更简单的方式处理复杂的操作。该模块还提供代码可重用性。
python 模块包含函数和全局变量的集合，以及.py扩展文件中的函数。它可以是定义和实现的一组函数、类或变量的集合。
一个模块可以定义函数、类和变量。模块也可以包含可运行的代码。Python 模块的例子包括 math、numpy、random 等等。
什么是 Python 包？
Python 包是将子包和模块放在一起的目录。它们是内部包含几个包和模块的名称空间。因此，基本上，它们被定义为简单的目录，但有一个转折！
每一个包必须包含一个名为__init__.py的特殊文件。这个初始文件可以是空的，或者包含一些关于导入模块的信息或数据。
包是一个分层的文件目录结构，其中包含子包和模块。python 包的一个例子包括游戏。Level.start 和更多这样的包。
Python 模块与 Python 包
抛开上下文不谈，让我们来看看 Python 模块和 Python 包之间的主要区别。
模块
- 包含 python 代码
- inti。py 不是必需的
- 支持*从模块中导入所有功能
包装
- 包含子包和模块
- init。如果是包，py 文件是必须的
- *在包的情况下不存在
结论
现在您已经了解了 python 模块和包。我们也知道两者的区别。希望你喜欢这个教程！
感谢您的阅读！
Python 模块简介
模块是预定义的文件，包含描述类、方法、变量等基本功能的 python 代码。它由不同的函数、类和目录中的一组文件组成。模块也可以称为库。这些基本上是预定义的方法，可用于提高代码效率和减少冗余。
模块绑定代码，减少代码中频繁使用的函数的重复。因此，它使代码更加清晰易懂。
例子:
- 操作系统（Operating System）
- 时间
- 数学
- MatPlotlib
Python 模块的机制
Python Module Mechanism
通过程序导入模块时，Python 解释器会从以下任一位置获取模块:
- 程序目录
- PYTHONPATH 变量中的目录
- 缺省目录
模块列表
通过在命令提示符(解释器 shell)中执行以下命令，可以找到 Python 中可用模块的列表。
帮助(“模块”)
Python Module List
从 Python 标准路径导入模块
语法:
导入模块名称
举例:
导入数学
从其他来源导入模块
为了从其他和新的来源获取和使用模块，我们需要安装 Python PIP。
Python pip 是一个从 index 安装 Python 模块或者使用 Anaconda 这样的管理器的软件。
运行以下命令，使用 python pip 从新的源代码安装模块:
python -m pip3 安装模块名称
运行以下命令，使用 Ananconda 从新的源代码安装模块:
conda 安装模块 _ 名称
示例:安装 numpy 的步骤
python -m pip3 安装 numpy
conda 安装 numpy
sudo 安装 python3-numpy
示例:内置模块
import math
print (math.sqrt(121))
print (math.pi)
print (dir(math))
输出:
11.0
3.1415926535893
[‘doc’、‘loader’、‘name’、‘package’、‘spec’、‘acos’、‘acosh’、‘asin’、‘asinh’、‘atan’、‘atan2’、‘atan’、‘ceil’、‘copy sign’、‘T2’、‘cos’、‘cosh’、‘degrees’、‘e’、‘ERF’、‘exp’、‘expm 1’、‘fabs’、‘factor’、‘floor’、‘fmod’、‘frexp’、‘fsum’、‘gamma’、‘hypf’
在上面的例子中，dir()方法给出了数学模块中的函数名、变量等。
模块中的变量
除了方法和类，模块还可以包含变量。
举例:
Fruit = {
"name": "Apple",
"color": "Green"
}
将上述代码片段保存在文件 Module1.py 中
import Module1
x = Module1.Fruit["name"]
print(x)
输出:
苹果
在上面这段代码中，Module1 被导入并在其上执行功能。
Python 中模块和包的区别
Python 模块:这些是一组预定义的文件，包含描述类、方法、变量等基本功能的 Python 代码。
Python 包:它是一个保存并包含模块和子包的目录。
参考
- Python 模块
- Python 模块-文档
python Modulo –%运算符，math.fmod()示例
原文：https://www.askpython.com/python/python-modulo-operator-math-fmod
Python 模运算符(%)用于获得除法的余数。整数和浮点数支持模运算。
模运算符的语法是a % b。这里“a”是被除数，“b”是除数。输出是 a 除以 b 的余数。
如果“a”和“b”都是整数，那么余数也是整数。如果其中一个是 float，结果也是浮点数。
Python 模块运算符示例
让我们看一些模运算符的例子。
1.整数取模
>>> 10 % 3
1
>>> 2 % 2
0
>>>
2.浮点取模
>>> 9 % 3.0
0.0
>>> 10 % 3.0
1.0
>>>
3.用户输入的模数
x = input("Please enter first number:\n")
fx = float(x)
y = input("Please enter first number:\n")
fy = float(y)
print(f'{x} % {y} = {fx % fy}')
Python Modulo Operator
当我们得到用户输入的数据时，它是字符串形式的。我们使用 float()内置函数将它们转换成浮点数。这就是为什么余数是 1.0 而不是 1。
推荐阅读 : Python 输入()函数
4.ZeroDivisionError 示例
如果除数为 0，模运算符将抛出ZeroDivisionError。我们可以使用 try-except 块来捕捉错误。
a = 10.5
b = 0
try:
print(f'{a} % {b} = {a % b}')
except ZeroDivisionError as zde:
print("We cannot divide by 0")
Python Modulo ZeroDivisionError
5.负数取模
Python 模运算符总是返回与除数符号相同的余数。这可能会导致输出混乱。
>>> -5 % 3
1
>>> 5 % -3
-1
>>> -10 % 3
2
>>>
- -5 % 3 = (1 -2*3) % 3 = 1
- 5 % -3 = (-1 * -2*-3) % 3 = -1
- -10 % 3 = (2 -4*3) % 3 = 2
6. Python Modulo math.fmod()
带有负数的%运算符的行为不同于平台 C 库。如果你想让模运算表现得像 C 编程一样，你应该使用数学模块 fmod()函数。这是获取浮点数模的推荐函数。
>>> import math
>>> math.fmod(-5, 3)
-2.0
>>> math.fmod(5, -3)
2.0
>>> math.fmod(-10, 3)
-1.0
>>>
- fmod(-5, 3) = fmod(-2 -1*3, 3) = -2.0
- fmod(5, -3) = fmod(2 -1*-3, -3) = 2.0
- fmod(-10, 3) = fmod(-1 -3*3, 3) = -1.0
重载模算子
我们可以通过在类定义中实现__mod__()函数来重载模操作符。
class Data:
def __init__(self, i):
self.id = i
def __mod__(self, other):
print('modulo function called')
return self.id % other.id
def __str__(self):
return f'Data[{self.id}]'
d1 = Data(10)
d2 = Data(3)
print(f'{d1} % {d2} = {d1%d2}')
输出:
modulo function called
Data[10] % Data[3] = 1
关于浮点运算问题的快速说明
我们用二进制格式在计算机中存储数值。说到分数，大部分时候我们都不能把它们精确的表示成二进制分数。例如，1/3 不能用精确的二进制格式表示，它总是一个近似值。
这就是为什么用浮点数进行算术运算时会得到意想不到的结果。从下面模运算的输出可以清楚地看出。
>>> 9.6 % 3.2
3.1999999999999993
输出应该是 0，因为 3.2*3 是 9.6。但是，浮点小数值并没有精确地表示出来，这种近似导致了这种误差。这个例子也很清楚。
>>> 9.6 == 3.2 * 3
False
>>>
因此，在处理浮点数时，您应该格外小心。建议先进行舍入，然后只比较两个浮点数。
>>> round(9.6, 3) == round(3.2 * 3, 3)
True
参考资料:
python MongoDB——完整概述
MongoDB 是最流行的非关系数据库(也称为 NoSQL 数据库)之一。非关系或 NoSQL 数据库没有固定的表结构或模式可遵循，这使得数据库非常灵活和可伸缩。NoSQL 数据库中的数据以类似 JSON 的格式存储，称为 RSON。在处理大型和非结构化数据时，MongoDB 使用起来非常方便，因此它是数据分析中使用最广泛的数据库。它提供了高速度和高可用性。在本文中，让我们看看如何将 python 脚本连接到 MongoDB 并执行所需的操作。
Python MongoDB 驱动程序
PyMongo 是连接 MongoDB 和 python 的原生驱动。PyMongo 拥有从 python 代码执行数据库操作的所有库。由于 pymongo 是一个低级驱动程序，所以它速度快、直观，并且提供了更多的控制。要安装 PyMongo，请打开命令行并键入以下命令
C:\Users\Your Name\AppData\Local\Programs\Python\Python36-32\Scripts>python -m pip install pymongo
这个命令将安装 PyMongo。我们可以在脚本中安装 PyMongo，并开始访问 MongoDB 资源。
MongoDB 数据库
现在让我们在 MongoDB 中创建一个数据库。我们将使用 PyMongo 的 MongoClient()类来创建数据库。我们将传递正确的本地主机 IP 地址和 post 来创建数据库。并使用客户端为数据库指定一个所需的名称。
from pymongo import MongoClient
#Creating a pymongo client
client = MongoClient('localhost', 27017)
#Getting the database instance
db = client['mongodb1']
print("Database created.")
#Verify the database
print("List of existing databases")
print(client.list_database_names())
输出
Database created.
List of existing databases:
['admin', 'config', 'local', 'mongodb1']
创建收藏
在数据库内部，我们可以创建多个集合，集合可以与传统数据库的表进行比较，我们可以在集合中存储多个记录。现在，让我们看看如何在数据库中创建集合。另外，请注意，当至少有一个文档插入到集合中时，就会创建我们的集合。
#create a collection named "students"
mycol = mydb["students"]
插入收藏
在 MongoDB 中，记录被称为文档。要将文档插入到集合中，我们应该使用 insert_one()方法。我们可以在 insert_one 方法中将创建的文档作为参数传递。让我们用一个例子来了解如何插入一个文档。
#create a document
test = { "name": "Ripun", "class": "Seventh" }
#insert a document to the collection
x = mycol.insert_one(test)
插入多条记录
要将多条记录插入到一个集合中，我们可以使用 insert_many()方法。为了实现这一点，我们将首先创建一个包含多个文档的列表，并将它们传递给 insert_many()方法。
mylist = [
{ "name": "Amy "，" class": "Seventh"}，
{ "name": "Hannah "，" class": "Sixth"}，
{ "name": "Viola "，" class ":" Sixth " }]x = mycol . insert _ many(my list)
我们也可以插入他们的 id。
mylist = [ { "_id":1,"name": "Amy", "class": "Seventh"},
{ "_id":2,"name": "Hannah", "class": "Sixth"},
{ "_id":3,"name": "Viola", "class": "Sixth"}]
x = mycol.insert_many(mylist)
print(x.inserted_ids)
从集合中访问文档
现在，一旦集合被结构化并加载了数据，我们就会希望根据我们的需求来访问它们。要访问数据，我们可以使用 find()方法。
find_one()方法返回集合中的第一个匹配项。
find()方法返回集合中的所有匹配项。当不带任何参数使用 find()方法时，其行为与 SQL 中的 Select all 相同。
输出
x = mycol.find_one()
# This prints the first document
print(x)
for x in mycol.find():
print(x)
有时，我们希望只检索文档的特定字段。要在结果中包含该字段，传递的参数值应为 1，如果该值为 0，则它将从结果中排除。
for x in mycol.find({},{ "_id": 0, "name": 1, "class": 1 }):
print(x)
上面的代码将只从我们的集合中返回 name 和 class 字段，而不包括 id 字段。
查询 MongoDB 数据库
通过使用查询对象，我们可以使用 find()以更精确的方式检索结果。
经营者
下面是 MongoDB 查询中使用的操作符列表。
| 操作 | 句法 | 例子 |
| 平等 | {"key" : "value"} | db.mycol.find({"by ":"教程点" }) |
| 不到 | {"key" :{$lt:"value"}} | db . mycol . find({ " likes ":{ $ lt:50 } }) |
| 小于等于 | {"key" :{$lte:"value"}} | db . mycol . find({ " likes ":{ $ LTE:50 } }) |
| 大于 | {"key" :{$gt:"value"}} | db . mycol . find({ " likes ":{ $ gt:50 } }) |
| 大于等于 | {"key" {$gte:"value"}} | db . mycol . find({ " likes ":{ $ GTE:50 } }) |
| 不等于 | {"key":{$ne: "value"}} | db . mycol . find({ " likes ":{ $ ne:50 } }) |
示例代码:
以下代码检索名称字段为 Sathish 的文档。
from pymongo import MongoClient
#Creating a pymongo client
client = MongoClient('localhost', 27017)
#Getting the database instance
db = client['sdsegf']
#Creating a collection
coll = db['example']
#Inserting document into a collection
data = [
{"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
{"_id": "1002", "name": "Mukesh", "age": "27", "city": "Bangalore"},
{"_id": "1003", "name": "Vel", "age": "28", "city": "Mumbai"},
{"_id": "1004", "name": "Sathish", "age": "25", "city": "Pune"},
{"_id": "1005", "name": "Rashiga", "age": "23", "city": "Delhi"},
{"_id": "1006", "name": "Priya", "age": "26", "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")
#Retrieving data
print("Documents in the collection: ")
for doc1 in coll.find({"name":"Sathish"}):
print(doc1)
输出
Data inserted ......
Documents in the collection:
{'_id': '1004', 'name': 'Sathish', 'age': '25', 'city': 'Pune'}
现在让我们检索年龄大于 25 岁的人的记录。我们将使用$gt 操作符来实现它。
for doc in coll.find({"age":{"$gt":"25"}}):
print(doc)
输出
{"_id": "1002 "，"姓名": "穆克什"，"年龄": " 27 "，"城市": "班加罗尔" }
以类似的方式，我们可以使用\(lt 来过滤值小于我们指定值的记录。我们也可以在字符串上使用这些操作符。例如，当我们使用" name":{"\)gt":"J"}来检索名称以' J '开头或其后有字母的所有记录时。
Python MongoDB 中的删除操作
我们可以使用 delete_one()方法删除一个文档。
delete_one()方法的第一个参数是一个查询对象，表示要删除的文档。
myquery = {"name" : "Mukesh"}
coll.delete_one(myquery)
要删除多个文档，我们可以使用 delete_many()方法。
myquery = { "name": {"$regex": "^S"} }
x = coll.delete_many(myquery)
上面的代码将删除人名以“S”开头或以字母顺序放在 S 后面的所有记录。
要删除集合中的所有文档，我们可以向delete_many()方法传递一个空的查询对象。下面的代码将删除集合中的所有文档。
x = coll.delete_many({})
如果我们想要删除整个集合本身，我们可以使用 drop()方法。
coll.drop()
结论
在本文中，我们已经了解了如何将 MongoDB 连接到 python，并在其上执行各种必需的基本操作。强烈建议读者获得一些使用 MongoDB 的实践经验，并熟悉语法和各种查询。
参考
https://www.mongodb.com/languages/python
https://docs.mongodb.com/drivers/python/
创建 Python 多行字符串的 4 种技术
原文：https://www.askpython.com/python/string/python-multiline-strings
Python 有不同的方式来表示字符串。一个 Python 多行字符串是以格式化和优化的方式呈现多个字符串语句的最有效方式。
在本文中，我们将重点关注可用于创建 Python 多行字符串的不同技术。
技巧 1:用三重引号在 Python 中创建多行字符串
triple quotes可用于一起显示多个字符串，即 Python 中的多行字符串。
语法:
variable = """ strings """
- 如果我们的输入包含带有太多字符的字符串语句，那么三重引号可以满足我们以格式化的方式显示它的需要。
- 三重引号下的所有内容都被视为字符串本身。
举例:
inp_str = """You can find the entire set of tutorials for Python and R on JournalDev.
Adding to it, AskPython has got a very detailed version of Python understanding through its easy to understand articles."""
print(inp_str)
输出:
You can find the entire set of tutorials for Python and R on JournalDev.
Adding to it, AskPython has got a very detailed version of Python understanding through its easy to understand articles.
技术 2:使用反斜杠()创建多行字符串
转义序列— backslash ('\')用于在 Python 中创建多行字符串。
语法:
variable = "string1"\"string2"\"stringN"
- 当使用反斜杠()创建多行字符串时，用户需要明确地提到字符串之间的空格。
举例:
inp_str = "You can find the entire set of tutorials for Python and R on JournalDev."\
"Adding to it, AskPython has got a very detailed version of Python understanding through its easy to understand articles."\
"Welcome to AskPython!!"
print(inp_str)
从下面可以清楚地看到，它不管理语句之间的空格。用户必须在声明多行字符串时提及它。
输出:
You can find the entire set of tutorials for Python and R on JournalDev.Adding to it, AskPython has got a very detailed version of Python understanding through its easy to understand articles.Welcome to AskPython!!
技巧 3:构建 Python 多行字符串的 string.join()方法
Python string.join()方法被证明是创建 Python 多行字符串的有效技术。
string.join() method处理和操纵字符串之间的所有空间，用户不需要担心同样的问题。
语法:
string.join(("string1","string2","stringN"))
举例:
inp_str =' '.join(("You can find the entire set of tutorials for Python and R on JournalDev.",
"Adding to it",
"AskPython has got a very detailed version",
"of Python understanding through its easy to understand articles.",
"Welcome to AskPython!!"))
print(inp_str)
输出:
You can find the entire set of tutorials for Python and R on JournalDev. Adding to it AskPython has got a very detailed version of Python understanding through its easy to understand articles. Welcome to AskPython!!
技术 4: Python 圆括号()创建多行字符串
Python brackets可用于创建多行字符串并将字符串拆分在一起。
这种技术的唯一缺点是，用户需要明确地指出多行字符串之间的空格。
语法:
variable = ("string1""string2""stringN")
举例:
inp_str =("You can find the entire set of tutorials for Python and R on JournalDev."
"Adding to it "
"AskPython has got a very detailed version "
"of Python understanding through its easy to understand articles."
"Welcome to AskPython!!")
print(inp_str)
输出:
You can find the entire set of tutorials for Python and R on JournalDev.Adding to it AskPython has got a very detailed version of Python understanding through its easy to understand articles.Welcome to AskPython!!
摘要
- Python 多行字符串是分成多行的字符串，以增强代码对用户的可读性。
- Python 括号、反斜杠和三重引号可以用来创建多行字符串，但是在这里，用户需要提到字符串之间空格的使用。
- Python string.join()方法被认为是构建多行字符串的非常有效的方法，而且字符串之间的空格由该方法隐式处理。
- Python 缩进规则不适用于多行字符串。
- 如果使用三重引号创建多行字符串，则所有转义序列(如换行符(\n)、制表符(\t)都被视为字符串的一部分。
结论
因此，在本文中，我们已经了解了创建 Python 多行字符串的各种方法。
参考
- Python 多行字符串— JournalDev
Python 多重继承
原文：https://www.askpython.com/python/oops/python-multiple-inheritance
当一个类从一个以上的类继承时，它被称为多重继承。Python 支持多重继承，而 Java 不支持。所有超/基类的属性都被继承到派生/子类中。
Python Multiple Inheritance
Python 多重继承语法
多重继承的语法也与单一继承相似。顺便说一下，派生类声明了所有基类的属性和方法。
class Base1:
pass
class Base2:
pass
class MultiDerived(Base1, Base2):
pass
Python 多重继承示例
# first parent class
class Manager(object):
def __init__(self, name, idnumber):
self.name = name
self.idnumber = idnumber
# second parent class
class Employee(object):
def __init__(self, salary, post):
self.salary = salary
self.post = post
# inheritance from both the parent classes
class Person(Manager, Employee):
def __init__(self, name, idnumber, salary, post, points):
self.points = points
Manager.__init__(self, name, idnumber)
Employee.__init__(self, salary, post)
print(self.salary)
ins = Person('Rahul', 882016, 75000, 'Assistant Manager', 560)
输出 : 75000
多重分辨率顺序
方法解析顺序(MRO)是一种解析类的变量或函数的方法。
- 在多重继承用例中，首先在当前类中查找属性。如果失败，那么下一个要搜索的地方是父类。
- 如果有多个父类，那么优先顺序是深度优先，然后是左右路径。
- MRO 确保一个类总是在它的父类之前，对于多个父类，保持基类元组的顺序并避免歧义。
解释 MRO 的例子
class Agile:
def create(self):
print(" Forming class Agile")
class Dev(Agile):
def create(self):
print(" Forming class Dev")
class QA(Agile):
def create(self):
print(" Forming class QA")
# Ordering of classes
class Sprint(Dev, QA):
pass
sprint = Sprint()
sprint.create()
输出:成型类开发
方法解析顺序的方法(MRO)
Python 提供了一个 mro 属性和 mro() 方法。有了这些，你就可以得到解析顺序了。
class Material:
def create(self):
print(" Creating class Appliance")
class Pencil:
def create(self):
print(" Creating class Pencil")
# Order of classes
class Pen(Material, Pencil):
def __init__(self):
print("Constructing Pen")
appl = Pen()
# Display the lookup order
print(Pen.__mro__)
print(Pen.mro())
输出:
Constructing Pen
(<class '__main__.Pen'>, <class '__main__.Material'>, <class '__main__.Pencil'>, <class 'object'>)
[<class '__main__.Pen'>, <class '__main__.Material'>, <class '__main__.Pencil'>, <class 'object'>]
参考资料:
Python MySQL 教程-完整指南
原文：https://www.askpython.com/python-modules/python-mysql-tutorial
今天在本教程中，我们将讨论如何开发和集成 Python MySQL 数据库。
什么是 MySQL
MySQL 是一个开源的关系数据库管理系统，可以用来以表的形式存储数据。此外，表是相关数据的集合，由列和行组成。
MySQL 是一个广泛使用的免费数据库软件，它运行在服务器上，并提供一系列可以在其上执行的操作。当然，我们可以将 MySQL 集成到我们的 Python 程序中，通过 MySQL 服务器上的数据库执行数据事务。
在 Python 上安装 MySQL
我们可以使用已经提供的各种模块或技术来使用 Python MySQL 。有些是，
上述所有技术都使用相同的语法和方法来连接 MySQL 数据库并按照 PEP 249 执行操作。
因此，我们可以使用上面的任何一个模块访问一个 MySQL 数据库服务器。此外，只安装其中一个是有意义的。我们可以在 shell 中使用简单的 PIP 命令来安装它们，如下所示。
pip install pymysql
这里，我们以 PyMySQL 为例。
在开始之前，请确保您的系统中已经设置了一个 MySQL 数据库，并且它工作正常。您拥有数据库启动连接的登录名和密码。
Python MySQL 中的基本方法
现在我们已经安装了pymysql，让我们来看看我们今天将要使用的一些基本方法。
1.MySQL 连接()
pymysql.connect()方法从 Python 建立到 MySQL 数据库的连接，并返回一个MySQLConnection对象。然后，这个对象可以用来访问整个数据库并执行其他操作。它接受主机、用户、密码和数据库等参数作为你要连接的数据库的规格。
user–对于本地服务器，用户应该被称为“根用户”，否则您可以通过此链接创建一个用户。password–这取决于您在创建用户时使用的密码。数据库也可以是无密码的(对于我们的例子)，host–对于使用 xampp 的本地服务器，我们可以使用localhost来访问数据库。我们也可以使用服务器的 IP 地址或名称来访问主机，database–这是您设置要使用的数据库名称。如果你已经创建了一个数据库，你可以在这里输入名称。
2. MySQL cursor()
cursor()方法创建一个光标对象，该对象可以进一步用于对数据库执行 CRUD (创建、检索、更新和删除)操作。
3.MySQL execute()
execute()方法使用先前创建的游标执行传递给它的 SQL 查询。
4.MySQL 关闭()
游标和 MySQLConnection 类中定义的close()方法用于关闭各自的对象。
5.MySQL 提交()
commit()方法向 MySQL 服务器发送一条COMMIT语句，从而提交当前的数据事务。
6.MySQL fetchall()
fetchall()方法获取查询结果集的所有行，并使用游标对象返回元组的列表。
7.MySQL 是 _connected()
这个方法检查到 MySQL 服务器的连接是否可用。如果是，则返回True，如果不是，则返回False。
Python MySQL 入门
在本教程中，我们将使用 Xampp 控制面板连接到本地服务器并创建我们的数据库。在 Xampp 中启动 Apache 和 MySQL 就可以完成这项工作。
此外，我们可以直接点击https://localhost/phpmyadmin/来查看我们的本地服务器界面，如下所示。
Initial phpMyAdmin
这里， mydatabase 和studentdb是我之前创建的一些数据库。
用 Python 创建 MySQL 数据库
如果您之前没有创建数据库，您可以通过使用cursor.execute()方法执行 CREATE 查询来轻松创建一个。与服务器建立连接后。看看下面的代码。
import pymysql
#server connection
mydb = pymysql.connect(
host="localhost",
user="root",
passwd=""
)
mycursor = mydb.cursor() #cursor created
#creating database with name classdb
mycursor.execute("CREATE DATABASE classdb;")
Create New Database
执行上述代码后，使用 phpMyAdmin 可以在数据库中看到上述变化。在这里，新数据库classdb被成功创建。
如果已经有了一个数据库，只需在connect()方法中指定名称，就可以轻松地连接到它。如下图。
import pymysql
#server connection
mydb = pymysql.connect(
host="localhost",
user="root",
database="classdb", #database created before
passwd=""
)
mycursor = mydb.cursor() #cursor created
#work with the cursor here like printing initial database data
#closing the cursor
mycursor.close()
Python MySQL 数据库上的操作
在本节中，我们将重点关注我们可以在 MySQL 数据库上执行的各种操作( CRUD )。
1.python MySQL–创建表格
在我们连接到想要使用的数据库，并创建了一个光标对象后，我们可以使用execute()方法和创建表来轻松执行查询。
import pymysql
#server connection
mydb = pymysql.connect(
host="localhost",
user="root",
database="classdb", #database
passwd=""
)
mycursor = mydb.cursor() #cursor created
#work with the cursor
query = "CREATE TABLE Students(StudentID int PRIMARY KEY AUTO_INCREMENT, Name CHAR(20), Lastname CHAR(20),Standard int);"
mycursor.execute(query)
#closing the cursor
mycursor.close()
Table students is created
我们可以看到，创建了一个包含列学生 ID 、姓名、姓氏和标准的表。
2.Python MySQL 插入
现在我们已经创建了一个表，我们可以通过再次使用 cursor 对象执行查询来将行插入其中。
import pymysql
#server connection
mydb = pymysql.connect(
host="localhost",
user="root",
database="classdb", #database
passwd=""
)
mycursor = mydb.cursor() #cursor created
#work with the cursor
query1 = "INSERT INTO students(Name, Lastname, Standard) VALUES('Anik', 'Das', 6);"
query2 = "INSERT INTO students(Name, Lastname, Standard) VALUES('Subhash', 'Neel', 8);"
query3 = "INSERT INTO students(Name, Lastname, Standard) VALUES('Prateek', 'Neel', 8);"
query4 = "INSERT INTO students(Name, Lastname, Standard) VALUES('Prem', 'Dutta', 9);"
mycursor.execute(query1)
mycursor.execute(query2)
mycursor.execute(query3)
mycursor.execute(query4)
#closing the db
mydb.commit()
mydb.close()
After Insertion
这些行已成功插入数据库。
3.Python 选择 MySQL
正如我们前面提到的，fetchall()方法获取查询结果集的所有行，并使用 cursor 对象返回元组列表。
因此，通过应用一个查询来从数据库中选择一些独特的或想要的数据，我们可以使用游标的fetchall()方法和一个for-loop来显示它们。
import pymysql
#server connection
mydb = pymysql.connect(
host="localhost",
user="root",
database="classdb", #database
passwd=""
)
mycursor = mydb.cursor() #cursor
#work with the cursor
res = "Select * from students;"
#executing the query
mycursor.execute(res)
rows = mycursor.fetchall()
#showing the rows
for row in rows:
print(row)
#closing the db
mydb.commit()
mydb.close()
输出:
(1, 'Anik', 'Das', 6)
(2, 'Subhash', 'Neel', 8)
(3, 'Prateek', 'Neel', 8)
(4, 'Prem', 'Dutta', 9)
4.Python MySQL 更新
此外，如果我们想要更新任何一组数据，我们可以使用如下所示的 UPDATE 查询。这里，我们尝试用 StudentID = 2 来更新学生的Lastname(即 Subhash)。
import pymysql
#server connection
mydb = pymysql.connect(
host="localhost",
user="root",
database="classdb", #database
passwd=""
)
mycursor = mydb.cursor() #cursor
#query to update database data
update_query = "UPDATE students set Lastname = 'Seth' WHERE StudentID = 2"
#executing the query
mycursor.execute(update_query)
#showing the rows
res = "Select * from students;"
mycursor.execute(res)
rows = mycursor.fetchall()
for row in rows:
print(row)
#closing the db
mydb.commit()
mydb.close()
输出:
Update Output
可以看出，更新是成功的。
5.Python MySQL 删除
现在让我们尝试使用游标查询来删除一组数据。这里，我们尝试删除带有Standard > 8的条目。在本例中，只有一个(StudentID 4 和标准的 9)。
import pymysql
#server connection
mydb = pymysql.connect(
host="localhost",
user="root",
database="classdb", #database
passwd=""
)
mycursor = mydb.cursor() #cursor
#query to delete database data
delete_query = "DELETE FROM students WHERE Standard > 8"
#executing the query
mycursor.execute(delete_query)
#showing the rows
res = "Select * from students;"
mycursor.execute(res)
rows = mycursor.fetchall()
for row in rows:
print(row)
#closing the db
mydb.commit()
mydb.close()
输出:
(1, 'Anik', 'Das', 6)
(2, 'Subhash', 'Seth', 8)
(3, 'Prateek', 'Neel', 8)
Delete Output
很明显，删除成功完成。
6.Python 在 MySQL 中删除了一个表
我们还可以在 MySQL 中使用 DROP 查询删除或删除一个表。这可以用来删除一个表，以便我们可以重用该名称，或者避免表名冲突。
#query to drop table
drop_query = "DROP TABLE IF EXISTS students;"
#executing the query
mycursor.execute(drop_query)
上面的代码片段删除了我们之前创建的表students。
Python MySQL 的优势
- MySQL 是来自甲骨文的免费且维护良好的软件。因此，它是完全可信和可靠的。
- 它很容易使用，既快又免费。
- 只需要结构化查询语言的基础知识。
- 它是独立于平台的，因此使用 Python 创建的数据库也可以使用其他平台来访问。
- 有各种模块可供选择，使用这些模块我们可以连接到 MySQL 服务器。
结论
所以在本教程中，我们理解了 MySQL 在 Python 中的用法。我们还举了一个例子来详细说明数据库上的 CRUD 操作。
今天就到这里，希望这篇文章有助于理解 Python MySQL 的基础知识。如有任何与 MySQL 相关的问题，欢迎使用下面的评论。
参考
- PEP 249 — Python 数据库 API ，
- MySQL 示例——日志开发帖子，
- MySQL 连接器/Python 编码示例–文档。
Python 命名元组
不可变对象的序列是一个**[Tuple](https://www.askpython.com/python/tuple/python-tuple)**。
**Namedtuple**允许用户为元组中的元素提供名称。因此，它为用户提供了通过索引或指定名称访问元素的选项。
因此，它增加了代码的可读性。
语法:
collections.namedtuple(typename, field_names, *, rename=False, defaults=None, module=None)
typename :描述分配给 nametuple 对象的名称。
字段名:用于定义命名元组的字段名。
rename :通过将 rename 变量值设置为 True，用户可以将无效字段重命名为其对应的索引名。
默认值:用户可以定义可选参数的默认值。
模块 : __module__命名元组的属性被设置为特定值，只要定义了模块。
举例:
from collections import namedtuple
Information = namedtuple('Information', ['city', 'state', 'pin_code'])
# below are also valid ways to namedtuple
# Employee = namedtuple('Employee', 'name age role')
# Employee = namedtuple('Employee', 'name,age,role')
info1 = Information('Pune', 'Maharashtra', 411027)
info2 = Information('Satara', 'Maharashtra', 411587)
for x in [info1, info2]:
print(x)
print('\n')
print("Accessing the attributes via index values....")
# accessing via index value
for x in [info1, info2]:
print(x)
print("Accessing the attributes via field name....")
# accessing via name of the field
for x in [info1, info2]:
print(x.city, 'is in',x.state, 'with', x.pin_code)
输出:
Information(city='Pune', state='Maharashtra', pin_code=411027)
Information(city='Satara', state='Maharashtra', pin_code=411587)
Accessing the attributes via index values....
Information(city='Pune', state='Maharashtra', pin_code=411027)
Information(city='Satara', state='Maharashtra', pin_code=411587)
Accessing the attributes via field name....
Pune is in Maharashtra with 411027
Satara is in Maharashtra with 411587
Python 命名的双重功能
- T0
- T2
Python Namedtuple with invalid keys - T2
rename variable - T2
Namedtuple module - T2
_make(iterable) function - T2
_asdict() function - T2
_replace(**kwargs) function - T2
Namedtuple attributes - T2
“**” (double star) operator
1.使用 getattr()函数访问属性
**getattr()**函数用于访问命名元组的属性。
from collections import namedtuple
Information = namedtuple('Information', ['city', 'state', 'pin_code'])
info1 = Information('Pune', 'Maharashtra', 411027)
info2 = Information('Satara', 'Maharashtra', 411587)
print (getattr(info1,'city'))
输出:
Pune
2.Python 命名了带有无效密钥的元组
如果用户使用无效的名称作为字段值/键，则生成**ValueError**。
from collections import namedtuple
Information = namedtuple('Information', ['city', 'state', 'pin_code'])
try:
Information = namedtuple('Information', ['city', 'state', 'if '])
except ValueError as error:
print(error)
输出:
Type names and field names must be valid identifiers: 'if '
3.重命名变量
如果用户使用了无效的键，我们可以将重命名变量设置为真。
这样，键就被它们的索引值代替了。
from collections import namedtuple
Information = namedtuple('Information', 'if', rename=True)
try:
info1 = Information('Pune' )
for x in [info1]:
print(x)
except ValueError as error:
print(error)
输出:
Information(_0='Pune')
4.命名的双重模块
from collections import namedtuple
Information = namedtuple('Information', 'city', rename=True, module='Simple1')
print(Information.__module__)
输出:
Simple1
5._make(iterable)函数
from collections import namedtuple
Information = namedtuple('Information', ['city', 'state', 'pin_code'])
x = ('Pune', 'Maharashtra', 411027)
info1 = Information._make(x)
print(info1)
输出:
Information(city='Pune', state='Maharashtra', pin_code=411027)
6. _asdict()函数
**_asdict()**函数帮助从 Namedtuple 创建 OrderedDict 的实例。
from collections import namedtuple
Information = namedtuple('Information', ['city', 'state', 'pin_code'])
x = ('Pune', 'Maharashtra', 411027)
info1 = Information._make(x)
ordered_output = info1._asdict()
print(ordered_output)
输出:
{'city': 'Pune', 'state': 'Maharashtra', 'pin_code': 411027}
7._ 替换(kwargs)功能**
因为 namedtuple 是不可变的，所以值不能改变。它通过用一组新值替换相应的键来返回一个新实例。
from collections import namedtuple
Information = namedtuple('Information', ['city', 'state', 'pin_code'])
x = ('Pune', 'Maharashtra', 411027)
info1 = Information._make(x)
info2 = info1._replace(city='Satara', state='Maharashtra', pin_code=411031)
print(info2)
输出:
Information(city='Satara', state='Maharashtra', pin_code=411031)
8.命名的双重属性
- _fields :提供字段的信息。
- _fields_defaults :提供用户设置的字段的默认值信息。
例 1: _fields 属性
from collections import namedtuple
Information = namedtuple('Information', ['city', 'state', 'pin_code'])
print("Fields: ")
print (Information._fields)
输出:
Fields:
('city', 'state', 'pin_code')
例 2: _fields_defaults 属性
from collections import namedtuple
Information = namedtuple('Information', ['city', 'state', 'pin_code'], defaults=['Pune', 'Maharashtra'])
print("Default Fields: ")
print (Information._fields_defaults)
输出:'
Default Fields:
{'state': 'Pune', 'pin_code': 'Maharashtra'}
9。“”(双星)符**
该运算符用于将字典转换为命名元组。
from collections import namedtuple
Information = namedtuple('Information', ['city', 'state', 'pin_code'])
dict = { 'city' : "Pune", 'state':'Gujarat', 'pin_code' : '411027' }
print(Information(**dict))
输出:
Information(city='Pune', state='Gujarat', pin_code='411027')
结论
因此，在本文中，我们已经理解了 Python 的集合 Namedtuple object 提供的功能。
参考
- Python 命名元组
- 已命名的双重文档
Python 命名空间和变量范围解析(LEGB)
原文：https://www.askpython.com/python/python-namespace-variable-scope-resolution-legb
在本教程中，我们将学习 Python 命名空间、变量的作用域以及变量作用域解析的规则。
什么是 Python 命名空间？
Python 名称空间是将名称映射到对象的容器。在 Python 中，一切都是一个对象，我们给对象指定一个名称，这样我们以后就可以访问它。
您可以将名称空间看作是一个键-值对的字典，其中键是变量名，值是与之关联的对象。
namespace = {"name1":object1, "name2":object2}
在 Python 中，可以同时存在多个独立的名称空间。变量名可以在这些名称空间中重用。
function_namespace = {"name1":object1, "name2":object2}
for_loop_namespace = {"name1":object3, "name2":object4}
让我们看一个简单的例子，其中我们有多个名称空间。
Python Namespace Example
Python 命名空间类型和生命周期
Python 名称空间可以分为四种类型。
- 本地名称空间:函数、for-loop、try-except 块是本地名称空间的一些例子。当函数或代码块完成执行时，本地命名空间被删除。
- 封闭的名称空间:当一个函数被定义在一个函数内部时，它会创建一个封闭的名称空间。它的生命周期与本地名称空间相同。
- 全局命名空间:属于 python 脚本或者当前模块。模块的全局命名空间是在读取模块定义时创建的。通常，模块名称空间也会持续到解释器退出。
- 内置名称空间:内置名称空间是在 Python 解释器启动时创建的，永远不会被删除。
Python 变量范围
Python 变量作用域定义了我们搜索变量的层次结构。例如，在上面的程序中，变量存在于不同的名称空间中。当我们想通过变量名访问变量值时，就在名称空间层次结构中进行搜索。
python NONE——关于 NONE 对象你需要知道的一切
嘿，伙计们！在本文中，我们将重点关注 Python NONE 关键字。
Python NONE 对象的工作
Python NONE是 Python 世界中的一个对象——面向对象编程。在 PHP、JAVA 等其他编程语言中，你可以把它看作“空”值。
NONE 对象的数据类型为‘NoneType’，因此，它不能被视为某些原始数据类型的值或布尔值。
因此，我们可以将 NONE 赋值给任何正在使用的变量。让我们用例子来理解没有人的需要。
考虑一个登录表单，用 Python 这样的后端语言连接到数据库。如果我们希望检查是否已经建立了到指定数据库的连接，我们可以为数据库连接对象指定 NONE，并验证连接是否安全。
现在，让我们理解 Python NONE 对象的结构。
Python NONE 对象的语法
NONE 对象不遵循普通数据类型的注意事项。
语法:
variable = NONE
此外，通过将变量赋值为 NONE，它描述了特定变量表示无值或空值。
现在让我们通过下面的例子来实现 Python NONE 对象。
通过示例实现无
让我们看看下面的例子。这里，我们给变量“var”赋值为 NONE。
示例 1:将 NONE 对象赋给 Python 变量
var = None
print("Value of var: ",var)
当我们试图打印存储在变量中的值时，它显示了下面的输出。从而清楚地表明 NONE 对象表示可以被认为是空值的 NONE 值。
输出:
Value of var: None
在下面的例子中，我们试图检查 Python NONE 对象是否表示一个等价的布尔值。
示例:针对 NONE 对象的布尔检查
var = None
print("Boolean Check on NONE keyword:\n")
if var:
print("TRUE")
else:
print("FALSE")
如下所示，结果是错误的。因此，这个例子清楚地表明，Python NONE 对象与布尔或其他原始类型的对象值不同。
输出:
Boolean Check on NONE keyword:
FALSE
现在，让我们尝试将原始类型和非类型值加入到 Python 数据结构中，例如集合、列表等。
示例:Python NONE with Set
当我们将其他原始类型值和 NONE 一起传递给数据结构(如集合、列表等)时，我们会发现 NONE 值在打印它们时返回“NONE”值。
var_set = {10,None,30,40,50}
for x in var_set:
print(x)
输出:
40
50
10
30
None
示例:Python NONE with List
var_lst = [10,None,30,40,50]
for x in var_lst:
print(str(x))
输出:
10
None
30
40
50
结论
到此，我们就结束了这个话题。如果您遇到任何疑问，请随时在下面发表评论。
快乐学习！！
参考
Python 不等于运算符
原文：https://www.askpython.com/python/python-not-equal-operator
比较运算符确定操作数之间的关系，并将结果放入True或False。
Python 中的一个基本但重要的操作符是 not equal 操作符。
它返回真**if the values on either side of the operator are unequal**，即当**two variables of same type have different values**时返回真，否则返回假。
| 操作员 | 描述 |
| ！= | 不等于运算符，在 Python 2 和 Python 3 中都适用和可用。 |
| <> | Python 2 中的 Not equal 运算符，在 Python 3 及更高版本中已弃用。 |
Python 不等于运算符语法
operand1 != operand2
例 1 :
在下面的代码片段中，10 <> 20 导致了一个语法错误，因为它在 Python 版本 3 及更高版本中已被弃用。
Python Not Equal Operator
例二:
Python Not Equal Operator
输出:
Output Not Equal Operator
Python 不等于带有自定义对象的运算符
每当我们使用不等于操作符时，它就调用**__ne__(self, other)**函数。因此，用户可以为对象定义他们自己的定制实现，并操纵自然的或默认的结果/输出。
Not Equal Custom Object
输出:
Output Not Equal Custom Object
参考
- Python 不等于运算符
- Python 比较运算符
- Python 运算符
Python NULL–如何在 Python 中识别 NULL 值？
我们先来了解一下 Python null 是什么意思，什么是 NONE 类型。在许多编程语言中， null 被用来表示一个空变量，或者一个不指向任何东西的指针。“null”基本上等于 0。而在 Python 中，没有“null”关键字可用。取而代之的是，'' None'用于此目的，它是一个对象。
什么是 Python null？
每当一个函数没有任何要返回的东西，也就是说，它不包含 return 语句，那么输出将是 None。
简而言之，这里的 None 关键字用于定义空变量或对象。None 是一个对象，数据类型为 NoneType 类。
def func_no_return()
a = 5
b = 7
print(func_no_return())
None
注:
每当我们给一个变量赋值 None 时，所有赋给它的变量都指向同一个对象。不会创建新的实例。
在 Python 中，与其他语言不同，null 不仅仅是 0 的同义词，它本身就是一个对象。
type(None)
<class 'NoneType'>
在 Python 中声明空变量
默认情况下，python 中的空变量是不声明的。也就是说，未定义的变量不同于空变量。为了理解，python 中的所有变量都是通过赋值产生的。看看下面的代码:
上面的代码显示了未定义变量和 None 变量之间的区别。
如何在 Python 中检查变量是否为 none？
您可以使用' is '运算符或' == '运算符检查变量是否为 None，如下所示
- 使用‘是’运算符
#declaring a None variable
a = None
if a is None : #checking if variable is None
print("None")
else :
print("Not None")
上面的代码将给出 None 作为输出。
- 使用 '== '运算符
#declaring a None variable
a = None
if (a == None) : #checking if variable is None
print("The value of the variable is None")
else :
print("The value of variable is Not None")
上面的代码给变量的值是 None 作为输出。
结论
总之，要记住的要点是:
- None 关键字用于定义空变量。
- 无与 0 不同。
- 没有一个是不可变类型的。
- 和 None 可用于标记缺失值以及默认参数。
Python 数字–int、float 和 complex
- 数字用于存储程序中的数值。
- Python 支持三种类型的数字——int、float 和 complex。
- Python 2 也支持“long ”,但在 Python 3 中不支持。
- 在 Python 中，数字也是一个对象。它们的数据类型是–int、float 和 complex。
- 有内置的函数来创建数字——int()、float()和 complex()。
- 我们也可以通过直接将值赋给变量来创建一个数字。
- 复数主要用于几何、微积分和科学计算。
- 我们可以通过实现 int() 、 float() 和 complex() 方法来定义对象的数值表示。
如何在 Python 中创建一个数字变量？
x = 10
y = 10.55
z = 1 + 2j
复数有两部分——实数和虚数。虚部用后缀“j”表示。
如何求一个数的类型？
我们可以使用 type()函数找到数字的类型。
print(type(x))
print(type(y))
print(type(z))
输出:
Python Numbers
1.整数
整数是整数。它们可以是积极的，也可以是消极的。它们必须没有十进制值。
我们可以使用 int()函数来获取一个对象的整数表示。该对象必须实现返回整数的 int()方法。
让我们看一些用 Python 创建整数的例子。
x = 10
print(type(x))
x = int("10")
print(type(x))
class Data:
id = 0
def __init__(self, i):
self.id = i
def __int__(self):
return self.id
d = Data(10)
x = int(d)
print(x)
print(type(x))
输出:
<class 'int'>
<class 'int'>
10
<class 'int'>
String 类提供了 int()方法，这就是为什么我们可以使用 int()方法轻松地将字符串转换为 int。
如果对象没有实现 int()方法，int()函数抛出 TypeError。
Python Int TypeError
一般来说，整数是以 10 为基数定义的。但是，我们也可以用二进制、八进制和十六进制格式来定义它们。
i = 0b1010
print(i) # 10
i = 0xFF
print(i) # 255
i = 0o153
print(i) # 107
2.浮动
浮点数包含小数点。它可以是积极的，也可以是消极的。
我们可以使用 float()函数来获取对象的浮点表示。对象必须实现 float()方法，该方法返回一个浮点数。
x = 10.50
print(x)
print(type(x))
x = float("10.50")
print(x)
print(type(x))
class Data:
id = 0.0
def __init__(self, i):
self.id = i
def __float__(self):
return float(self.id)
d = Data(10.50)
x = float(d)
print(x)
print(type(x))
d = Data(10)
x = float(d)
print(x)
print(type(x))
输出:
10.5
<class 'float'>
10.5
<class 'float'>
10.5
<class 'float'>
10.0
<class 'float'>
String 提供 float()方法实现。这就是为什么我们可以很容易地将一个字符串转换成浮点数。
如果对象没有实现 float()方法，我们会得到如下错误消息:
TypeError: float() argument must be a string or a number, not 'Data'
如果 object float()方法不返回浮点数，我们会得到如下错误消息:
TypeError: Data.__float__ returned non-float (type int)
我们也可以用“E”或“E”来定义科学记数法中的浮点数。这里“E”后面的数字表示 10 的幂。
x = 10.5e2
print(x)
x = 10.5E2
print(x)
输出:
1050.0
1050.0
解释 : 10.5E2 = 10.5 * pow(10，2) = 10.5 * 100 = 1050.0
3.复杂的
一个复数包含两部分——实部和虚部。虚数部分写的是“j”后缀。
我们还可以使用 complex()函数创建一个复数。我们可以向 complex()函数传递两个 int 或 float 参数。第一个参数是实数部分，第二个参数是复数部分。
x = 1 + 2j
print(x)
print(type(x))
x = -1 - 4j
print(x)
print(type(x))
x = complex(1, 2)
print(x)
print(type(x))
x = complex(1)
print(x)
print(type(x))
x = complex(-1, -2.5)
print(x)
print(type(x))
输出:
(1+2j)
<class 'complex'>
(-1-4j)
<class 'complex'>
(1+2j)
<class 'complex'>
(1+0j)
<class 'complex'>
(-1-2.5j)
<class 'complex'>
我们还可以通过定义 complex()方法得到一个对象复数表示。此方法必须返回一个复数。
class Data:
def __init__(self, r, i):
self.real = r
self.imaginary = i
def __complex__(self):
return complex(self.real, self.imaginary)
d = Data(10, 20)
c = complex(d)
print(c)
print(type(c))
输出:
Python Complex Number
我们也可以将字符串转换成复数。实部和虚部之间不应有任何空白。
c = complex("1+2j") # works fine
c = complex("1 + 2j") # ValueError: complex() arg is a malformed string
我们可以使用“实数”属性获得复数的实数部分。我们可以使用“imag”属性获得复数的虚部。
c = 10 + 20j
print(c.real) # real part
print(c.imag) # imaginary part
其他一些复数方法有:
- conjugate():返回复共轭数。虚部的符号颠倒了。
- abs():返回复数的幅度。
c = 1 + 2j
print(c.conjugate()) # (1-2j)
print(abs(c)) # 2.23606797749979
Python 数字类型转换
我们可以使用 float()函数将 int 转换成 float。同样，我们可以使用 int()函数将 float 转换为 int。
我们可以用 complex()函数把一个 int 或 float 转换成复数，虚部会是 0j。
我们不能将一个复数转换成 int 或 float。
i = 10
f = 10.55
# int to float conversion
f1 = float(i)
print(f1)
print(type(f1))
# float to int conversion
i1 = int(f)
print(i1)
print(type(i1))
# int and float to complex number conversion
c = complex(i)
print(c)
print(type(c))
c = complex(f)
print(c)
print(type(c))
输出:
10.0
<class 'float'>
10
<class 'int'>
(10+0j)
<class 'complex'>
(10.55+0j)
<class 'complex'>
结论
数字是任何编程语言不可或缺的一部分。Python 支持三种类型的数字——int、float 和 complex。python 中的数字也是 int、float 和 complex 类型的对象。我们可以使用 int()、float()和 complex()函数将对象转换成数字。复数主要用于几何和科学计算。
参考资料:
python——NumPy 数组简介
原文：https://www.askpython.com/python-modules/numpy/python-numpy-arrays
NumPy 是最常用的科学计算 Python 库。它提供了一个快速的 Pythonic 接口，同时仍然使用更快的 C++进行计算。这确保了高级可读性和 Python 特性仍然存在，同时使实际计算比纯 Python 代码快得多。
这里，我们看看 NumPy 完成所有工作背后的数据结构，以及我们如何以不同的方式转换它，就像我们如何操作其他类似数组的数据结构一样。
NumPy 数组对象
为了声明一个 numpy 数组对象，我们首先导入numpy库，然后使用np.array()库函数实例化我们新创建的数组。
下面的代码片段声明了一个简单的一维 numpy 数组:
>>> import numpy as np
>>> a = np.array([1, 2, 3, 4])
>>> print(a)
[1 2 3 4]
每个数组都有以下属性:
ndim(维数)shape(每个尺寸的大小)size(数组的总大小)dtype(数组的数据类型)
NumPy 数组元素有相同的数据类型，不像 Python 列表。因此，我们不能让单个 numpy 数组保存多种不同的数据类型。
要声明一个更高维的数组，类似于用任何其他语言声明一个更高维的数组，使用适当的矩阵来表示整个数组。
# Declare a 2-Dimensional numpy array
b = np.array([[1, 2, 3], [4, 5, 6]])
print("b -> ndim:", b.ndim)
print("b -> shape:", b.shape)
print("b -> size:", b.size)
print("b -> dtype:", b.dtype)
输出:
b -> ndim: 2
b -> shape: (2, 3)
b -> size: 6
b -> dtype: dtype('int64')
访问 NumPy 数组元素
与 Python 中访问列表元素和数组元素类似，numpy 数组的访问方式也是一样的。
为了访问多维数组中的单个元素，我们对每个维度使用逗号分隔的索引。
>>> b[0]
array([1, 2, 3])
>>> b[1]
array([4, 5, 6])
>>> b[-1]
array([4, 5, 6])
>>> b[1, 1]
5
NumPy 数组切片
再次，类似于 Python 标准库，numpy 也为我们提供了对 NumPy 数组的切片操作，使用它我们可以访问元素的数组切片，给我们一个对应的子数组。
>>> b[:]
array([[1, 2, 3],
[4, 5, 6]])
>>> b[:1]
array([1, 2, 3])
事实上，由于 numpy 操作的高度优化特性，这是广泛推荐的使用 NumPy 数组的方式。因为相比之下，原生 python 方法非常慢，所以我们应该只使用 numpy 方法来操作 numpy 数组。结果，纯 Python 迭代循环和其他列表理解不能与 numpy 一起使用。
生成 numpy 数组的其他方法
我们可以使用 numpy 内置的arange(n)方法来构造一个由数字0到n-1组成的一维数组。
>>> c = np.arange(12)
>>> print(c)
[0 1 2 3 4 5 6 7 8 9 10 11]
>>> c.shape
(12,)
使用random.randint(limit, size=N)生成一个随机整数数组，所有元素在 0 和limit之间，大小为N，指定为关键字参数。
>>> d = np.random.randint(10, size=6)
>>> d
array([7, 7, 8, 8, 3, 3])
>>> e = np.random.randint(10, size=(3,4))
>>> e
array([[2, 2, 0, 5],
[8, 9, 7, 3],
[5, 7, 7, 0]])
操作 NumPy 数组
numpy 提供了一个方法reshape()，可以用来改变 NumPy 数组的维度，并就地修改原来的数组。这里，我们展示了一个使用reshape()将c的形状改变为(4, 3)的例子
>>> c
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
>>> c.shape
(12,)
>>> c.reshape(4, 3)
array([[ 0, 1, 2],
[ 3, 4, 5],
[ 6, 7, 8],
[ 9, 10, 11]])
因为 numpy 操作被设计为高度优化的，所以从数组创建的任何子数组仍然保存对原始数组的引用。这意味着如果子数组被就地修改，原始数组也会被修改。
>>> f = e[:3, :2]
>>> f
array([[2, 2],
[8, 9],
[5, 7]])
>>> f[0,0] *= 3
>>> f
array([[6, 2],
[8, 9],
[5, 7]])
>>> e
array([[6, 2, 0, 5],
[8, 9, 7, 3],
[5, 7, 7, 0]])
这里，原始数组e也随着子数组片f的任何变化而被修改。这是因为 numpy 切片只返回原始数组的一个视图。
为了确保原始数组不随子数组片的任何变化而修改，我们使用 numpy copy()方法创建数组的副本并修改克隆对象，而不是处理对原始对象的引用。
下面的片段展示了copy如何处理这个问题。
>>> e
array([[6, 2, 0, 5],
[8, 9, 7, 3],
[5, 7, 7, 0]])
>>> f = e[:3, :2].copy()
>>> f
array([[6, 2],
[8, 9],
[5, 7]])
>>> f[0,0] = 100
>>> f
array([[100, 2],
[ 8, 9],
[ 5, 7]])
>>> e
# No change is reflected in the original array
# We are safe!
array([[6, 2, 0, 5],
[8, 9, 7, 3],
[5, 7, 7, 0]])
结论
在本文中，我们学习了 numpy 数组和一些涉及它们的基本操作，包括它们的属性、数组切片、整形和复制。
参考
了解 Python Numpy 日志
原文：https://www.askpython.com/python-modules/numpy/python-numpy-log
嘿，伙计们！在本文中，我们将重点关注 Python Numpy 对数函数。
Python NumPy 日志入门
Python NumPy 模块处理数组数据元素的创建和操作。
numpy.log() method是用来计算一个元素的数据值/数组值的自然对数值。
语法:
numpy.log(element/array)
例 1:
import numpy as np
data = 12.2
log_val = np.log(data)
print(log_val)
输出:
2.501435951739211
例 2:
import numpy as np
data = np.e
log_val = np.log(data)
print(log_val)
输出:
1.0
以 2 为底的对数
除了默认的log() method功能，我们可以使用下面的命令计算一个 NumPy 数组或一个带有base 2的元素的日志值:
numpy.log2(element)
举例:
import numpy as np
data = 4
log_val = np.log2(data)
print(log_val)
输出:
2.0
以 10 为底的 NumPy 对数
numpy.log10() function用于计算一个元素以 10 为底的自然对数值。
语法:
numpy.log10(data)
举例:
import numpy as np
data = 1000
log_val = np.log10(data)
print(log_val)
输出:
3.0
带自定义底数的 NumPy 对数
NumPy log()函数提供了根据用户定义的基数寻找对数值的可能性。
语法:
numpy.log(data)/numpy.log(base)
举例:
import numpy as np
data = 1000
base = 40
log_val = np.log(data)/np.log(base)
print(log_val)
在上面的例子中，我们计算了以 40 为基数的对数值 1000。
众所周知，
Log Value With Custom Base
因此，上述数学概念用于计算数据值对自定义基值的对数值。
输出:
1.8725890517453545
在二维阵列上执行 NumPy 日志
numpy.log()方法可应用于二维 numpy 数组，以计算所有数组元素的对数值。
语法:
numpy.log(array)
举例:
import numpy as np
arr = np.arange(1,5).reshape(2,2)
print("Original Array:\n")
print(arr)
print("\Logarithmic value of array elements:\n")
log_val=np.log(arr)
print(log_val)
在上面的例子中，我们使用numpy.reshape() function创建了一个 2×2 的数组，并使用随机数通过numpy.arange() method创建数据值。
此外，numpy.log()方法用于查找数组中每个元素的对数值。
输出:
Original Array:
[[1 2]
[3 4]]
Logarithmic value of array elements:
[[0\. 0.69314718]
[1.09861229 1.38629436]]
在 NumPy 阵列上应用 NumPy 日志
举例:
import numpy as np
arr = np.array([10,20,30,4,5])
print("Original Array:\n")
print(arr)
print("\nLogarithm value of array elements:\n")
log_val=np.log(arr)
print(log_val)
我们使用 numpy.array() function创建了一个 NumPy 数组，并使用 numpy.log()方法计算一维数组中所有数据项的对数值。
输出:
Original Array:
[10 20 30 4 5]
Logarithm value of array elements:
[2.30258509 2.99573227 3.40119738 1.38629436 1.60943791]
数字日志的图形表示
为了更好地理解计算出的日志值，我们可以使用 Python Matplotlib 模块绘制原始值的日志值。
举例:
import numpy as np
import matplotlib.pyplot as plt
arr = np.array([10,20,30,40,50])
log_val=np.log(arr)
plt.plot(log_val,arr,marker='*',color='green')
在上面的例子中，我们使用了pyplot.plot() method来绘制原始数组值的对数值。
输出:
Graphical Representation Of Numpy Log
结论
因此，在本文中，我们已经了解了 Python NumPy log 方法的工作原理以及不同的情况。
参考
Python NumPy 模块–需要了解的 4 种重要函数类型
原文：https://www.askpython.com/python-modules/numpy/python-numpy-module
嘿，伙计们！希望你们都过得好。在本文中，我们将关注于 Python NumPy 模块的重要功能。
所以，让我们开始吧！
Python NumPy 模块简介
Python NumPy 模块集成了多种函数，轻松执行不同的科学和数学运算。
因此，NumPy 模块可以被认为是一个所有程序员都可以方便地执行所有数学和复杂计算任务的模块。
现在，让我们了解并实现 NumPy 模块的一些重要功能。
1.NumPy 数组操作函数
NumPy 模块的数组操作功能帮助我们对数组元素进行修改。
看看下面的功能——
- numpy . shape():这个函数允许我们在不影响数组值的情况下改变数组的维数。
- numpy.concatenate():以行或列的方式连接两个相同形状的数组。
现在让我们把注意力集中在上述功能的实现上。
举例:
import numpy
arr1 = numpy.arange(4)
print('Elements of an array1:\n',arr1)
arr2 = numpy.arange(4,8)
print('Elements of an array2:\n',arr2)
res1 = arr1.reshape(2,2)
print('Reshaped array with 2x2 dimensions:\n',res1)
res2 = arr2.reshape(2,2)
print('Reshaped array with 2x2 dimensions:\n',res2)
print("Concatenation two arrays:\n")
concat = numpy.concatenate((arr1,arr2),axis=1)
print(concat)
理解形状很重要，即阵列的尺寸需要相同才能执行上述功能。
输出:
Elements of an array1:
[0 1 2 3]
Elements of an array2:
[4 5 6 7]
Reshaped array with 2x2 dimensions:
[[0 1]
[2 3]]
Reshaped array with 2x2 dimensions:
[[4 5]
[6 7]]
Concatenation two arrays:
[0 1 2 3 4 5 6 7]
2.NumPy 字符串函数
使用 NumPy 字符串函数，我们可以操作数组中包含的字符串值。下面提到了一些最常用的字符串函数:
numpy.char.add() function:连接两个数组的数据值，合并它们，并作为结果表示一个新的数组。numpy.char.capitalize() function:将整个单词/字符串的第一个字符大写。numpy.char.lower() function:将字符串字符的大小写转换为小写字符串。numpy.char.upper() function:将字符串字符的大小写转换为大写字符串。numpy.char.replace() function:用另一个字符串值替换一个字符串或字符串的一部分。
举例:
import numpy
res = numpy.char.add(['Python'],[' JournalDev'])
print("Concatenating two strings:\n",res)
print("Capitalizing the string: ",numpy.char.capitalize('python data'))
print("Converting to lower case: ",numpy.char.lower('PYTHON'))
print("Converting to UPPER case: ",numpy.char.upper('python'))
print("Replacing string within a string: ",numpy.char.replace ('Python Tutorials with AA', 'AA', 'JournalDev'))
输出:
Concatenating two strings:
['Python JournalDev']
Capitalizing the string: Python data
Converting to lower case: python
Converting to UPPER case: PYTHON
Replacing string within a string: Python Tutorials with JournalDev
3.NumPy 算术函数
下面提到的 NumPy 函数用于对数组的数据值执行基本的算术运算
numpy.add() function:将两个数组相加，返回结果。numpy.subtract() function:从 array1 中减去 array2 的元素，返回结果。numpy.multiply() function:将两个数组的元素相乘并返回乘积。numpy.divide() function:用 array1 除以 array2，返回数组值的商。numpy.mod() function:执行取模运算，返回余数数组。numpy.power() function:返回数组 1 ^数组 2 的指数值。
举例:
import numpy as np
x = np.arange(4)
print("Elements of array 'x':\n",x)
y = np.arange(4,8)
print("Elements of array 'y':\n",y)
add = np.add(x,y)
print("Addition of x and y:\n",add)
subtract = np.subtract(x,y)
print("Subtraction of x and y:\n",subtract)
mul = np.multiply(x,y)
print("Multiplication of x and y:\n",mul)
div = np.divide(x,y)
print("Division of x and y:\n",div)
mod = np.mod(x,y)
print("Remainder array of x and y:\n",mod)
pwr = np.power(x,y)
print("Power value of x^y:\n",pwr)
输出:
Elements of array 'x':
[0 1 2 3]
Elements of array 'y':
[4 5 6 7]
Addition of x and y:
[ 4 6 8 10]
Subtraction of x and y:
[-4 -4 -4 -4]
Multiplication of x and y:
[ 0 5 12 21]
Division of x and y:
[ 0\. 0.2 0.33333333 0.42857143]
Remainder array of x and y:
[0 1 2 3]
Power value of x^y:
[ 0 1 64 2187]
4.NumPy 统计函数
NumPy 统计函数在数据挖掘和分析数据中的大量特征方面非常有用。
让我们来看看一些常用的函数
numpy.median():计算传递数组的中值。numpy.mean():返回数组数据值的平均值。numpy.average():返回所传递数组的所有数据值的平均值。numpy.std():计算并返回数组数据值的标准差。
举例:
import numpy as np
x = np.array([10,20,30,4,50,60])
med = np.median(x)
print("Median value of array: \n",med)
mean = np.mean(x)
print("Mean value of array: \n",mean)
avg = np.average(x)
print("Average value of array: \n",avg)
std = np.std(x)
print("Standard deviation value of array: \n",std)
输出:
Median value of array:
25.0
Mean value of array:
29.0
Average value of array:
29.0
Standard deviation value of array:
20.2895703914
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
在那之前，学习愉快！！
参考文献
- Python NumPy 模块— JournalDev
Python numpy.reshape()函数
原文：https://www.askpython.com/python-modules/numpy/python-numpy-reshape-function
嘿，伙计们！希望你们都过得好。在本文中，我们将了解Python numpy . shape()函数的工作原理。
众所周知， Python NumPy 模块为我们提供了海量的函数来操作和处理数学数据。在这里，我们将揭示 Numpy reshape()函数的功能。
所以，让我们开始吧！
Python numpy.reshape()函数的工作原理
Python numpy.reshape() function使我们能够改变数组的形状，即改变数组元素的尺寸。重塑一个数组将有助于我们改变驻留在特定维度中的数据值的数量。
需要注意的重要一点是， reshape()函数保留了数组的大小，也就是说，它没有改变数组元素的数量。
现在让我们在下一节中了解 numpy.reshape()函数的结构。
Python numpy.reshape()函数的语法
array-name.reshape(shape)
shape:是整数值的元组，根据这个元组对元素进行整形。
让我们考虑一个例子来理解将形状传递给 shape()函数的过程。
如果输入数组中有 16 个元素，那么我们需要将这些整数值作为元组传递给 shape 参数，这些元组值的乘积等于元素的数量，即 16。
形状参数可能有以下几种情况:
- [2,8]
- [8,2]
- [4,4]
- [16,1]
- [1,16]
- [4,2,2]
现在让我们通过下面的例子来更好地理解 numpy.reshape()函数。
用示例实现 Python numpy.reshape()
在下面的例子中，我们使用 numpy.arange()函数创建了一个包含 16 个元素的一维数组。
此外，我们使用 shape()函数将数组的维度重新调整为一个二维数组，每个维度有 4 个元素。
import numpy as np
arr = np.arange(16)
print("Array elements: \n", arr)
res = np.arange(16).reshape(4, 4)
print("\nArray reshaped as 4 rows and 4 columns: \n", res)
输出:
Array elements:
[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15]
Array reshaped as 4 rows and 4 columns:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
现在，我们已经改变了 1 维数组的形状，并将其转换为每维 2 个元素的数组。
import numpy as np
arr = np.arange(16)
print("Array elements: \n", arr)
res = np.arange(16).reshape(4,2,2)
print("\nArray reshaped: \n", res)
输出:
Array elements:
[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15]
Array reshaped:
[[[ 0 1]
[ 2 3]]
[[ 4 5]
[ 6 7]]
[[ 8 9]
[10 11]]
[[12 13]
[14 15]]]
在下面的示例中，我们通过将值-1 传递给 shape()函数，将二维数组转换为一维数组。
import numpy as np
arr = np.array([[1, 2, 3,4], [10, 11, 12,13],[5,6,7,8]])
print("Array elements: \n", arr)
res = arr.reshape(-1)
print("\nArray reshaped as 1-D Array: \n", res)
输出:
Array elements:
[[ 1 2 3 4]
[10 11 12 13]
[ 5 6 7 8]]
Array reshaped as 1-D Array:
[ 1 2 3 4 10 11 12 13 5 6 7 8]
结论
到此，我们就结束了这个话题。如果你有任何疑问，欢迎在下面评论。快乐学习！
参考
Python numpy.where()方法的最终指南
原文：https://www.askpython.com/python-modules/numpy/python-numpy-where
嘿，伙计们！在本文中，我们将关注 Python numpy.where()方法的工作方式。
numpy.where()函数的工作原理
Python NumPy 模块包含许多内置函数来创建和操作数组元素。
numpy.where() function用于根据某个条件返回数组元素
语法:
numpy.where(condition,a,b)
condition:需要提及对阵列应用的操作条件。a:如果满足条件，即条件为真，则函数产生一个。b:如果不满足条件，函数返回该值。
例 1:
import numpy as np
data = np.array([[10,20,30], [40,50,60], [0,1,2]])
print(np.where(data<20,True,False))
在上面的例子中，对于所有数据值为 < 20 的数组元素，这些数据值都被替换为 True 。并且，对于数据值为 > 20 的所有数组元素，即不满足条件的值被替换为假。
输出:
[[ True False False]
[False False False]
[ True True True]]
例 2:
import numpy as np
data = np.array([[10,20,30], [40,50,60], [0,1,2]])
data_set = np.where(data<20)
print("Data elements less than 20:\n")
print(data[data_set])
在上面的例子中，我们已经显示了所有小于 20 的数组元素。
输出:
Data elements less than 20:
[10 0 1 2]
具有多个条件的 Python numpy.where()函数
多个条件可以与numpy.where() function一起应用，以针对多个条件操作数组元素。
语法:
numpy.where((condition1)&(condition2))
OR
numpy.where((condition1)|(condition2))
例 1:
import numpy as np
data = np.array([[10,20,30], [40,50,60], [0,1,2]])
data_set = np.where((data!=20)&(data<40))
print(data[data_set])
在本例中，我们显示了所有数据值小于 40 且不等于 20 的数组元素。
输出:
[10 30 0 1 2]
例 2:
import numpy as np
data = np.array([[10,20,30], [40,50,60], [0,1,2]])
data_set = np.where((data<20)|(data>40))
print(data[data_set])
在上面这段代码中，满足上述任一条件的所有数据值都会显示出来，即小于 20 的数组元素和大于 40 的数组元素都会显示出来。
输出:
[10 50 60 0 1 2]
使用 numpy.where()函数替换数组值
使用 numpy.where()函数，我们可以根据特定条件的满足情况替换这些值。
语法:
numpy.where(condition,element1,element2)
举例:
import numpy as np
data = np.random.randn(2,3)
print("Data before manipulation:\n")
print(data)
data_set = np.where((data>0),data,0)
print("\nData after manipulation:\n")
print(data_set)
在本例中，我们用 0 替换了所有数据值小于 0 的数组元素，即不满足上述条件。
输出:
Data before manipulation:
[[ 0.47544941 -0.35892873 -0.28972221]
[-0.9772084 1.04305061 1.84890316]]
Data after manipulation:
[[0.47544941 0\. 0\. ]
[0\. 1.04305061 1.84890316]]
结论
因此，在本文中，我们已经理解了 Python numpy.where()函数跨各种输入的工作方式。
参考
- Python numpy.where()函数— JournalDev
- Python numpy.where()函数—文档
Python object()方法是什么？
原文：https://www.askpython.com/python/built-in-methods/python-object-method
欢迎各位！今天在本教程中，我们将讨论 Python object()方法和类。
所以让我们从 Python object()方法的基本定义和语法开始。
Python 对象()方法
Python object()方法在被调用时，返回一个新的object类的无特征对象。这个方法需要没有的参数。下面给出了使用 object()方法的语法。
obj = object()
在这里，obj现在是一个无特色的对象，它拥有所有类的默认内置属性和方法。
通常，Python object类充当所有类的基类，包括用户定义的类。因此所有的类都从 Python 中的对象类继承了。这是 Python 3.x 版本的默认情况。但是对于 Python 2.x 版本来说，为了定义一个新样式的类，需要显式地让这个类继承 object 类，如下所示。
class my_class(object):
...
Python object()方法–示例程序
现在我们已经收集了关于对象类和object()方法的相当多的知识，让我们跳到一个例子中来获得一个更清晰的画面。
#object() object
obj = object()
print("obj = ", obj)
print("Type of obj = ", type(obj))
print(dir(obj)) #attributes of obj
输出:
obj = <object object at 0x01374040>
Type of obj = <class 'object'>
['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
简单地说，我们已经使用object()方法创建了一个新对象obj，并分别使用 type() 和 dir() 方法确定了它的类型以及它的所有属性。
从上面的输出中，我们可以清楚地看到obj属于对象类。注意，obj 没有一个__dict__属性。因此，我们不能给object类的实例分配任意的属性。
Python 对象()方法的属性
在这一部分，我们将看看一些object属性，探索它的用途，并尝试使用它。
class demo():
a = 10
b = 20
#declaring object of user-defined class
d1 = demo()
#featureless objects
d2 = object()
d3 = object()
print("d2 == d3? ", d2 == d3)
print("issubclass(demo, object)? ", issubclass(demo, object)) #demo inherites from object class
print("isinstance(d1, object)? ", isinstance(d1, object))
print("Type of d2 = ", type(d2))
print(d2)
输出:
Output
在上面的代码中，demo是一个用户定义的类，有一些值 a 和 b 。d1是来自演示类的一个对象。鉴于，d2和d3是使用object()方法创建的对象类中的空对象。
从上面的输出可以看出，即使 d2 和 d3 是同类型的两个空对象，d2==d3条件也不满足。再次分别对demo类和d1对象使用 issubclass() 和 isinstance() 方法，我们可以推断出以下语句。
demo类是object类的子类，因此继承自它，- 并且， d1 (演示对象)也是
object类(基类)的一个实例。
你也可以看到我们不能直接打印一个空对象，所以我们得到<object object at 0x007C4040>。
总结
这个题目到此为止。要了解更多信息，我们强烈建议浏览参考资料部分的以下链接。
关于这个话题的任何进一步的问题，请随意使用下面的评论。
快乐学习。
参考
- Python 类继承对象–堆栈溢出问题，
- Python 对象类–Python 文档。
Python oct()函数是什么？
原文：https://www.askpython.com/python/built-in-methods/python-oct-function
嘿，伙计们！在本文中，我们将关注使用 Python oct()函数的整数值的八进制表示。
Python oct()函数入门
Python 有各种内置函数来操纵和操作数据值。Python oct() method用于将表示整数值转换成八进制格式的表示法。
语法:
oct(number)
number:必须传递给函数的整数值。它可以是一个十进制、二进制或十六进制的值。
举例:
dec_num = 2
print("Octal representation of decimal number:", oct(dec_num))
bin_num = 0b10
print("Octal representation of binary number:", oct(bin_num))
hex_num = 0x17
print("Octal representation of decimal number:", oct(hex_num))
输出:
Octal representation of decimal number: 0o2
Octal representation of binary number: 0o2
Octal representation of decimal number: 0o27
Python oct()函数的错误和异常
如果将一个浮点类型值传递给 Python oct()函数，它会引发一个TypeError异常，即 oct()函数只接受整数值作为参数。
举例:
dec_num = 2.4
print("Octal representation of decimal number:", oct(dec_num))
输出:
TypeError Traceback (most recent call last)
<ipython-input-3-75c901e342e0> in <module>
1 dec_num = 2.4
----> 2 print("Octal representation of decimal number:", oct(dec_num))
TypeError: 'float' object cannot be interpreted as an integer
NumPy 模块中数组元素的八进制表示
使用 NumPy 的内置函数，可以将数据结构中包含的元素(如 NumPy 数组、列表等)转换为其八进制格式。
numpy.base_repr() function用于以元素方式将数组的每个元素转换成八进制形式。
语法:
numpy.base_repr(number, base, padding)
number:需要表示八进制格式的数组元素。base:表示要转换的值的合成数字系统的值。对于八进制表示，我们需要放置 base = 8 。padding:要加到结果数左轴的零的个数。
举例:
import numpy as N
arr = [23,15,36,20]
res_arr = N.base_repr(arr[0],base = 8)
print("The Octal representation of",arr[0],":",res_arr)
输出:
The Octal representation of 23 : 27
使用 Pandas 模块的数据值的八进制表示
Python Pandas 模块用于以数据帧的形式构建元素，并对数据集进行操作。Python apply(oct) function可用于将数据集的整数数据值表示成八进制格式。
语法:
DataFrame.apply(oct)
举例:
import pandas as pd
dec_data=pd.DataFrame({ 'Decimal-values':[20,32,7,23] })
oct_data=dec_data['Decimal-values'].apply(oct)
print(oct_data)
输出:
0 0o24
1 0o40
2 0o7
3 0o27
Name: Decimal-values, dtype: object
结论
因此，在本文中，我们已经理解了使用 Python oct()函数将整数值表示为八进制格式的方法。
参考
- Python oct()函数— JournalDev
Docker 上的 Python:如何在 Docker 容器中托管 Python 应用程序？
嘿！让我们来看看如何在 Docker 上托管 Python。在本教程结束时，您将知道如何创建 docker 容器，将您的应用程序添加到容器中，并在不干扰系统进程的情况下保持其运行。
如果你是 Python 的初学者，通过跟随整个课程地图来浏览这个 Python 视频课程。
一旦你都设置好了，你就可以开始了！
什么是 Docker 容器？
在理解容器的概念之前，让我们先讨论和理解容器的出现。
回到虚拟机大行其道的时代，所有的应用程序都托管在虚拟机上。应用程序所有者不得不为资源付出巨大的代价，这些资源未得到充分利用，但被他们阻止了通向应用程序的流量。这并没有持续很长时间，因为它不适合装在口袋里。此外，所有与应用相关的配置文件都需要存储在该虚拟机上。
这就是集装箱出现的时候。
有了容器，就有了按使用付费的概念。
基本上，Docker 向我们介绍了容器的概念。容器将应用程序及其所有相关的配置文件打包到一个独立的环境中。它将所有与系统相关的软件需求、代码和库放在一个单独的空间中。
使用容器，我们只为在应用程序运行时使用的资源付费。也就是说，我们不需要阻塞资源，因为容器会根据您的应用程序调整资源使用。
了解了容器之后，现在让我们尝试在 Docker 容器上托管一个简单的 Python 应用程序。
在 Docker 上运行 Python 的步骤
将应用托管到容器中的整个过程贯穿以下场景——
- 创建 Dockerfile 文件
- 建立形象
- 将应用程序作为容器运行
步骤 1–创建 Dockerfile 文件
docker 文件是与计划托管的应用程序相关的配置需求的实际蓝图。我们可以包括所有需要执行的系统级命令，以便为您的最终应用蓝图做好处理准备。它可能包括应用程序所需的一些插件或库。
此外，我们将把下面的简单 python 应用程序作为一个容器来运行——
demo.py
data = list()
data = ['JournalDev','AskPython']
for x in lst:
print(x)
docker file-
FROM python:3
ADD demo.py /
CMD [ "python", "./demo.py" ]
Dockerfile 提供了几个指令，如下所示
- FROM–它为即将执行的指令设置基础图像。对于本例，Python 版本已设置为 3 作为基础影像图层。当执行指令时，Dockerfile 从 Docker Hub 获取基本图像，Docker Hub 是开源图像的存储库。
- ADD–使用 ADD 指令，我们可以以文件、目录甚至基本 docker 文件的 URL 的形式灌输指令。
- CMD–这个指令使我们能够声明一个位置，让我们拥有一个命令来运行特定的 python 或任何 bash/sh 脚本。
第二步——建立 Docker 形象
建立了 Dockerfile 之后，为生产做好准备对我们来说很重要。也就是说，我们需要为 docker 文件中定义的所有命令创建一个基础层，以使容器运行良好。同样，我们使用下面的命令格式创建一个 Docker 映像。
语法—
docker build -t image-name:tag .
示例—
docker build -t python-image:1.0 .
输出—
[+] Building 5.4s (7/7) FINISHED
=> [internal] load build definition from Dockerfile 0.1s
=> => transferring dockerfile: 31B 0.0s
=> [internal] load .dockerignore 0.1s
=> => transferring context: 2B 0.0s
=> [internal] load metadata for docker.io/library/python:3 5.0s
=> [internal] load build context 0.1s
=> => transferring context: 31B 0.0s
=> [1/2] FROM docker.io/library/python:[email protected]:b6a9702c4b2f9ceeff807557a63a710ad49ce737ed85c46174a059a299b580 0.0s
=> CACHED [2/2] ADD demo.py / 0.0s
=> exporting to image 0.1s
=> => exporting layers 0.0s
=> => writing image sha256:8b2da808b361bc5112e2afa087b9eb4e305304bcc53c18925d04fe8003f92975 0.0s
=> => naming to docker.io/library/python-image:1.0
步骤 3–运行映像(将应用程序托管在容器中)
这些图像(上面创建的)实际上独立于任何底层配置。另一方面，容器需要一个图像作为基本配置来运行应用程序的实例。同样，我们需要启动运行容器的进程，应用程序的实例将通过该容器运行。
我们使用 docker run 命令来实际启动一个容器并运行 docker 文件中提到的配置。
举例:
docker run python-image:1.0
输出:
JournalDev
AskPython
我们甚至可以通过安装如下所示的 Docker 社区版应用程序来检查桌面上是否存在这个正在运行的容器(出于示例目的):
Docker Community Edition
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
更多与 Python 编程相关的帖子，请继续关注我们。
在那之前，学习愉快！！🙂
在 Python 中使用 open()方法打开文件
原文：https://www.askpython.com/python/built-in-methods/python-open-method
介绍
我们已经遇到了使用 Python 可以对文件执行的各种操作，比如读取、写入，或者复制。在执行任何提到的文件处理操作时，很明显打开文件是第一步。
所以今天在本教程中，我们将重点讨论使用Python open()方法打开文件的部分。
Python 中的 open()方法
open()方法以指定的模式打开一个特定的文件，并返回一个文件对象。然后，该文件对象可以进一步用于执行各种文件操作。下面给出了使用该方法的语法。
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
这里，
- 文件是指文件名/描述符，
mode是文件打开的模式。这些是打开文件所需的基本参数。 - 缓冲是一个可选的整数，用于设置缓冲策略。默认情况下，它被设置为(-1)，
- 编码是用于解码或编码文件的编码名称，
- errors 是一个可选字符串，指定如何处理编码和解码错误。注意，这不能在二进制模式下使用。
- 换行符控制通用换行符模式的工作方式(仅适用于文本模式)。可以是
None(默认)''``'\n'``'\r'``'\r\n'。 - closefd 表示传递的文件参数是文件名还是文件描述符。当提到文件描述符时，它应该是假的。否则为真(默认)。否则，将会出现错误，
- 开启器是一个可调用的定制开启器。通过用(file，flags)调用这个
opener来获得文件对象的指定文件描述符。opener 必须返回一个打开的文件描述符(传递os.open作为 opener 产生类似于传递None的功能)。
Python 中 open()的打开模式
下面给出了不同的文件打开模式及其含义。
| 模式 | 描述 |
| 'r' | 打开以供阅读(默认) |
| 'w' | 打开进行写入，首先截断文件 |
| 'x' | 以独占方式打开，如果文件已经存在，则失败 |
| 'a' | 打开以供写入，追加到文件的末尾(如果存在) |
| 'b' | 二进制 |
| 't' | 文本模式(默认) |
| '+' | 打开以进行更新(读取和写入) |
Table for file opening modes
Python open()示例
既然我们已经完成了 Python 中open()方法的基础，让我们直接进入一些例子。
我们将使用open()方法打开一个名为 file.txt 的文件，内容如下图所示。
File Contents
仔细看看下面给出的代码片段。
# opening a file
f = open('file.txt', 'r') # file object
print("Type of f: ", type(f))
print("File contents:")
for i in f:
print(i)
f.close() # closing file after successful operation
输出:
Type of f: <class '_io.TextIOWrapper'>
File contents:
Python
Java
Go
C
C++
Kotlin
在这里，我们以只读(' r ')模式打开了文件 file.txt 。方法将一个文件对象返回给 T2。然后，我们使用循环的遍历这个对象，以访问文件的内容。
之后，我们使用 close() 方法关闭了文件。在对一个文件执行任何操作后，最后关闭它是很重要的，以避免错误。再次打开同一文件时可能会出现这些错误。
打开多个文件
在 Python 中，我们可以通过组合使用with语句、open()方法和逗号(' , ')操作符来同时打开两个或多个文件。让我们举一个例子来更好地理解。
这里，我们尝试了打开两个独立的文件 file1.txt 和 file2.txt 并打印它们对应的内容。
# opening multiple files
try:
with open('file1.txt', 'r+') as a, open('file2.txt', 'r+') as b:
print("File 1:")
for i in a:
print(i)
print("File 2:")
for j in b:
print(j)
except IOError as e:
print(f"An Error occured: {e}")
# file closing is not required
输出:
File 1:
John Alex Leo Mary Jim
File 2:
Sil Rantoff Pard Kim Parsons
注:本次使用后我们没有关闭文件。因为我们不需要这样做，with语句通过调用close()方法确保打开的文件自动关闭。
结论
今天就到这里吧。希望你有清楚的了解。对于任何进一步的相关问题，请随时使用下面的评论。
我们建议浏览参考资料部分提到的链接以获取更多信息。
参考
Python 运算符
Python 中的运算符用于对变量和值执行特定操作。Python 有很多操作符，要么是关键字，要么是特殊字符。这些运算符处理的值或变量被称为操作数。
Python 运算符的类型
Python 运算符可以分为以下几类。
- 算术运算符
- 逻辑运算符
- 比较运算符
- 按位运算符
- 赋值运算符
- 成员运算符
- 标识运算符
1.算术运算符
Python 中的算术运算符通常处理数字。有用于加、减、乘、除、模和指数运算的运算符。这些操作符中的一些也为字符串工作。所有算术运算符都是特殊字符。
- +:加法运算符
- -:减法运算符
- *:乘法运算符
- /:除法运算符
- **:指数运算符
- //:楼层除法运算符
让我们看一个 Python 中算术运算符的例子。
x = 15
y = 7
sum = x + y
print("addition =", sum)
subtraction = x - y
print("subtraction =", subtraction)
multiplication = x * y
print("multiplication =", multiplication)
division = x / y
print("division =", division)
modulus = x % y
print("modulus =", modulus)
exponent = x ** 2
print("exponent =", exponent)
floor_division = x // y
print("division =", floor_division) # 2
输出:
Python Arithmetic Operators
Python 支持字符串的加法和乘法运算符。
print("addition of strings =", ("Python" + " " + "Operators"))
print("multiplication of strings =", ("Python" * 2))
输出:
addition of strings = Python Operators
multiplication of strings = PythonPython
2.比较运算符
Python 比较运算符用于比较两个值。结果总是一个布尔值—True或False。
Python 中的比较运算符列表如下:
- ==:如果两个值相等，则返回 True。
- ！=:如果两个操作数不相等，则返回 True。
-
:如果左操作数大于右操作数，则返回 True。
- :如果左操作数小于右操作数，则返回 True。
-
=:如果左值大于或等于右值，则返回 True。
- < =:如果左值小于或等于右值，则返回 True。
让我们看一个在 Python 中使用比较运算符的例子。
x = 10
y = 20
print(f'equals = {x == y}')
print(f'not equals = {x != y}')
print(f'greater than = {x > y}')
print(f'less than = {x < y}')
print(f'greater than or equal to = {x >= y}')
print(f'less than or equal to = {x <= y}')
输出:
Python Comparison Operators
这些运算符也适用于字符串。如果一个字符串按字典顺序排在另一个字符串之后，则认为它比另一个字符串大。比如字典式比较中“Hi”大于“Hello”。
3.按位运算符
它们也被称为二元运算符，只适用于整数。操作数值被转换成二进制，然后对每一位进行运算。最后，该值被转换回十进制并返回。
Python 中有 6 个按位运算符。
- &:按位 AND 运算符
- |:按位 OR 运算符
- ^:按位异或运算符
- ~:二进制一的补码运算符
- <<:/>
-
:二进制右移运算符
x = 10 # 1010
y = 4 # 0100
print(f'Binary AND = {x & y}')
print(f'Binary OR = {x | y}')
print(f'Binary XOR = {x ^ y}')
print(f'Binary Ones Complement = {~x}')
print(f'Binary Left Shift by 2 = {x << 2}')
print(f'Binary Right Shift by 3 = {x >> 3}')
输出:
Binary AND = 0
Binary OR = 14
Binary XOR = 14
Binary Ones Complement = -11
Binary Left Shift by 2 = 40
Binary Right Shift by 3 = 1
4.Python 逻辑运算符
Python 中有三个逻辑运算符。它们处理布尔操作数并返回一个布尔值。它们由 Python 中的 保留关键字 组成。
- and:逻辑 AND 运算符
- or:逻辑 OR 运算符
- not:逻辑 NOT 运算符
b1 = True
b2 = False
print(f'{b1} and {b2} = {b1 and b2}')
print(f'{b1} and {b2} = {b1 or b2}')
print(f'not {b1} = {not b1}')
输出:
Python Logical Operators
5.赋值运算符
赋值运算符(=)用于将左操作数值赋给右操作数。
有一些复合赋值运算符在两个操作数之间执行一些算术运算，然后将值赋给左边的操作数。
- =:简单赋值运算符
- +=:将两个操作数相加，然后将值赋给右操作数
- -=:从左操作数中减去右操作数，然后将值赋给左操作数
- *=:将两个操作数相乘，然后将它们向左赋值
- /=:将左操作数除以右操作数，然后将值赋给左操作数
- %=:左右操作数的模，然后赋给左操作数
- **=:从左到右操作数的指数，然后赋给左操作数
- //=:左操作数和右操作数的除法运算，然后将值赋给左操作数
a = 10 # simple assignment operator
b = 5
a += b # same as a=a+b
print(a) # 15
a -= b # same as a=a-b
print(a) # 10
a *= b # same as a = a*b
print(a) # 50
a /= b # same as a = a/b
print(a) # 10.0
a %= b # same as a = a%b
print(a) # 0.0
a = 2
b = 4
a **= b # same as a = a**b
print(a) # 16
a //= b # same as a = a // b (floor division)
print(a) # 4
6.成员运算符
Python 中的成员运算符用于检查序列中是否存在值。Python 中有两个成员运算符。
- 在
- 不在
这些运算符通常与 if-else 条件一起使用。
x = 3
my_tuple = (1, 2, 3, 4)
my_list = [1, 2, 3, 4]
my_str = "Hello"
print(f'{x} is present in {my_tuple} = {x in my_tuple}')
if x in my_list:
print(f'{x} is present in {my_list}')
if 'a' not in my_str:
print(f'a is not present in {my_str}')
Python Membership Operators
7.标识运算符
Python 标识操作符用于检查两个变量是否指向同一个内存位置。有两个标识运算符。
- is:如果两个变量指向同一个内存位置，则返回 True
- is not:如果两个变量都指向不同的内存位置，则返回 True
s1 = [1, 2]
s2 = [1, 2]
s3 = s1
print(s1 is s2) # False
print(s1 is s3) # True
print(s1 is not s2) # True
print(s1 is not s3) # False
Python 中的运算符优先级
有时一个表达式包含多个运算符。在这种情况下，运算符优先级用于确定执行顺序。
- 我们可以用括号创建一组表达式。括号中的表达式首先被求值，然后才能参与进一步的计算。
- 一些运算符具有相同的优先级。在这种情况下，表达式从左到右计算。
下表按降序列出了运算符的优先级。
| 运算符优先级(降序) |
| **(指数) |
| ~(一的补码) |
| 、/、//、%(乘法、除法、地板除法、模数运算符) |
| +、–(加法、减法) |
| <>(左右移位运算符) |
| &(按位与) |
| |，^(按位或，异或) |
| ==, !=，>， =，< =(比较运算符) |
| =，+=，-=，=，/=，//=，%=(赋值运算符) |
| 是，不是(标识运算符) |
| in，not in(成员运算符) |
| 非、与、或(逻辑运算符) |
Python 运算符重载
Python 支持运算符重载。为对象重载运算符有一些特定的方法。
让我们看看当一个类不支持一个操作符时会发生什么。
class Data:
id = 0
def __init__(self, i):
self.id = i
d1 = Data(10)
d2 = Data(20)
d3 = d1 + d2
print(d3.id)
输出:
Traceback (most recent call last):
File "/Users/pankaj/Documents/PycharmProjects/PythonTutorialPro/hello-world/operators_examples.py", line 9, in <module>
d3 = d1 + d2
TypeError: unsupported operand type(s) for +: 'Data' and 'Data'
如果我们必须支持数据类的+运算符，我们必须为它定义 add()方法。让我们看看更新后的代码和输出。
class Data:
id = 0
def __init__(self, i):
self.id = i
def __add__(self, other):
return Data(self.id + other.id)
d1 = Data(10)
d2 = Data(20)
d3 = d1 + d2
print(d3.id)
输出: 30
下表提供了在 Python 中重载运算符时要重写的方法。
| 操作员 | 描述 | 方法 |
| + | 添加 | __ 添加 _ _(自己，其他) |
| – | 减法 | sub(自己，其他) |
| * | 增加 | mul(自己，其他) |
| / | 真正的分裂 | truediv(自己，其他) |
| // | 楼层划分 | floordiv(自己，其他) |
| % | 剩余物 | mod(自己，其他) |
| ** | 力量 | pow(自己，其他) |
| & | 按位 AND | __ 和 _ _(自己，其他) |
| | | 按位或 | __ 或 _ _(自己，其他) |
| ^ | 按位异或 | xor(自身，其他) |
| > | 大于 | gt(自己，其他) |
| >= | 大于或等于 | ge(自己，其他) |
| < | 不到 | lt(自己，其他) |
| <= | 小于或等于 | le(自己，其他) |
| == | 等于 | eq(自己，他人) |
| ！= | 不等于 | ne(自己，其他) |
Python 运算符模块
python 运算符模块提供了一组与 Python 中的运算符相对应的函数。这些函数名与特殊方法相同，没有双下划线。
让我们看一个支持运算符–+、>和*的自定义类的例子。我们将使用运算符模块函数来调用该类的对象上的这些方法。
import operator
class Data:
id = 0
def __init__(self, i):
self.id = i
def __add__(self, other):
return Data(self.id + other.id)
def __gt__(self, other):
return self.id > other.id
def __mul__(self, other):
return Data(self.id * other.id)
d1 = Data(10)
d2 = Data(20)
d3 = operator.add(d1, d2)
print(d3.id)
d3 = operator.mul(d1, d2)
print(d3.id)
flag = operator.gt(d1, d2)
print(flag)
摘要
Python 支持许多操作符来帮助我们进行常见的算术、比较、赋值、二进制或逻辑运算。最好的一点是，通过在我们的类中定义特殊的方法，可以重载这些操作符。如果您希望您的程序看起来更面向对象，您可以使用运算符模块，该模块提供与这些运算符相对应的函数。
下一步是什么？
参考资料:
