python 知识点详解

https://en.wikipedia.org/wiki/Monty_Python%27s_Flying_Circus

https://google.github.io/styleguide/pyguide.html

谷歌 Python 风格指南

命令行神器

Click 是用 Python 写的一个第三方模块，用于快速创建命令行。我们知道，Python 内置了一个 Argparse 的标准库用于创建命令行，但使用起来有些繁琐，Click 相比于 Argparse，就好比 requests 相比于 urllib。
https://click.palletsprojects.com/en/8.0.x/
https://www.huaweicloud.com/articles/7a04947e36af482218c5be9fc40b3a02.html

Python Fire 是一个用于从绝对任何 Python 对象自动生成命令行界面 (CLI) 的库。
https://github.com/google/python-fire

https://pypi.org/project/emoji/

windows上不支持

python -m webbrowser -t "https://www.google.com"
python -m webbrowser -t "https://www.dylanroy.com"
python -m webbrowser -t "https://www.usesql.com"

https://github.com/Anorov/cloudflare-scrape

一个简单的 Python 模块，用于绕过 Cloudflare 的反机器人页面

使用newspaper3k框架快速抓取文章信息

https://pypi.org/project/newspaper3k/

它使您可以从一系列领先的国际出版物中检索新闻文章和相关的元数据。您可以检索图像、文本和作者姓名。

因此，如果您正在考虑在下一个项目中使用 BeautifulSoup 或其他一些 DIY 网页抓取库，请为自己节省时间和精力

但是报纸框架不适合实际工程新闻爬取，框架不稳定，爬取过程有各种bug，比如无法获取url、新闻信息，但是想获取一些新闻语料的朋友不妨一试，简单方便好用，不需要掌握太多爬虫知识。

$ pip install newspaper3k

https://github.com/codelucas/newspaper/
https://github.com/johnbumgarner/newspaper3_usage_overview

https://www.codestudyblog.com/cnb11/1124174732.html

wikipedia维基百科有一个很棒的 API，它允许用户以编程方式访问无与伦比的完全免费的知识和信息
https://wikipedia.readthedocs.io/en/latest/quickstart.html

import wikipedia

result = wikipedia.page('freeCodeCamp')

print(result.summary)

for link in result.links:

print(link)

YAML 代表“YAML 不是标记语言”。它是一种数据格式化语言，是 JSON 的超集

与 JSON 不同，它可以存储更复杂的对象并引用它自己的元素。您还可以编写注释，使其特别适合编写配置文件

PyYAML 允许您存储任何数据类型的 Python 对象，以及任何用户定义类的实例

https://pyyaml.org/wiki/PyYAMLDocumentation

在线编辑器

https://repl.it/languages/python

https://repl.it/languages/python3

http://codepad.org/

https://ideone.com/

https://ide.geeksforgeeks.org/

https://www.onlinegdb.com/online_python_compiler

https://www.geeksforgeeks.org/download-and-install-python-3-latest-version/

Python 源代码发布

https://www.python.org/downloads/source/

从 python.org 下载 Python 最新版本

https://www.python.org/downloads/windows/

# python2

import sys

print sys.getdefaultencoding()

>>> ascii

# python3

import sys

print(sys.getdefaultencoding())

>>> utf-8

# 打印导入模块的文件路径。

import os

import socket

print(os) # <module 'os' from 'C:\\Python38\\lib\\os.py'>

print(socket) # <module 'socket' from 'C:\\Python38\\lib\\socket.py'>

Some changes in Python 3.0:

Print is now a function
Views and iterators instead of lists
The rules for ordering comparisons have been simplified. E.g. a heterogeneous list cannot be sorted, because all the elements of a list must be comparable to each other.
There is only one integer type left, i.e. int. long is int as well.
The division of two integers returns a float instead of an integer. "//" can be used to have the "old" behaviour.
Text Vs. Data Instead Of Unicode Vs. 8-bit

最有用的 Python 库？

1. Requests . 由 kenneth reitz 编写的最著名的 http 库。它是每个 Python 开发人员的必备工具。

Requests允许您非常轻松地发送 HTTP/1.1 请求。无需手动向 URL 添加查询字符串，或对 POST 数据进行表单编码。多亏了urllib3，Keep-alive 和 HTTP 连接池是 100% 自动的。

2. Scrapy . 如果您参与网页抓取，那么这是您必备的库。使用此库后，您将不再使用任何其他库。

一个开源协作框架，用于从网站中提取您需要的数据。以一种快速、简单但可扩展的方式。

3. wxPython . python的gui工具包。我主要用它来代替 tkinter。你会真的很喜欢它。

它是 Python 语言的跨平台 GUI 工具包。使用 wxPython 软件开发人员可以为他们的 Python 应用程序创建真正的本机用户界面，这些界面在 Windows、Mac 和 Linux 或其他类 Unix 系统上几乎不需要修改即可运行。

4. Pillow . PIL（Python 成像库）的友好分支。它比 PIL 更用户友好，是任何处理图像的人的必备品。

PIL 是 Python 图像库

5. SQLAlchemy .一个数据库库。许多人喜欢它，也有许多人讨厌它。这是你的选择。

SQLAlchemy 是 Python SQL 工具包和对象关系映射器，可为应用程序开发人员提供 SQL 的全部功能和灵活性。

6. BeautifulSoup. 我知道它很慢但是这个 xml 和 html 解析库对初学者非常有用。

Beautiful Soup 是一个 Python 库，专为快速周转项目（如屏幕抓取）而设计。三大特点使其功能强大：

Beautiful Soup 提供了一些用于导航、搜索和修改解析树的简单方法和 Pythonic 习惯用法：一个用于剖析文档并提取所需内容的工具包。编写应用程序不需要太多代码
Beautiful Soup 自动将传入文档转换为 Unicode，将传出文档转换为 UTF-8。您不必考虑编码，除非文档未指定编码并且 Beautiful Soup 无法检测到编码。然后你只需要指定原始编码。
Beautiful Soup 位于流行的 Python 解析器（如lxml和html5lib ）之上，允许您尝试不同的解析策略或以速度换取灵活性。

Beautiful Soup 会解析您提供的任何内容，并为您执行树遍历操作。您可以告诉它“查找所有链接”，或“查找类externalLink 的所有链接”，或“查找所有 url 与“foo.com”匹配的链接，或“查找带有粗体文本的表标题，然后给出我那个文本。”

7. Twisted. 任何网络应用程序开发人员最重要的工具。它有一个非常漂亮的 api，被很多著名的 Python 开发人员使用。

Twisted是一个事件驱动的网络编程框架，它使用编程语言Python编写，并在MIT协议下开源。Twisted计划多方面的支持TCP、UDP、SSL/TLS、IP多播、Unix域套接字，很多协议（包括HTTP、XMPP、NNTP、IMAP、SSH、IRC、FTP等等）和很多其他东西。Twisted基于了事件驱动编程范型，这意味着Twisted的用户要书写由这个框架调用的短小回调函数

8. NumPy . 我们怎么能离开这个非常重要的库？它为 Python 提供了一些高级数学功能。

使用 Python 进行科学计算的基本包

9. SciPy . 当我们谈论 NumPy 时，我们必须谈论 scipy。它是一个用于 Python 的算法和数学工具库，并导致许多科学家从 ruby 转向 Python。

SciPy（发音为“Sigh Pie”）是一个基于 Python 的开源软件生态系统，用于数学、科学和工程

10. matplotlib . 一个数字绘图库。它对任何数据科学家或任何数据分析器都非常有用。

Matplotlib 是一个综合性的库，用于在 Python 中创建静态、动画和交互式可视化

11. Pygame .哪个开发者不喜欢玩游戏并开发它们？该库将帮助您实现 2d 游戏开发的目标。

Pygame是一组专为编写视频游戏而设计的Python模块。Pygame 在优秀的SDL库之上添加了功能。这允许您使用 python 语言创建功能齐全的游戏和多媒体程序。

12. Pyglet. 一个 3d 动画和游戏创建引擎。这是我的世界著名的python端口的引擎

pyglet是一个功能强大且易于使用的 Python 库，用于在 Windows、Mac OS X 和 Linux 上开发游戏和其他视觉丰富的应用程序。它支持窗口化、用户界面事件处理、操纵杆、OpenGL 图形、加载图像和视频以及播放声音和音乐。所有这一切都通过友好的 Pythonic API 实现，学习起来很简单，而且不会妨碍您。

13. pyQT. python的GUI工具包。这是我在 wxpython 之后为我的 Python 脚本开发 GUI 的第二选择。
PyQt 是Qt 公司Qt 应用程序框架的一组 Python 绑定，可在 Qt支持的所有平台上运行，包括 Windows、macOS、Linux、iOS 和 Android。PyQt6 支持 Qt v6，PyQt5 支持 Qt v5，PyQt4 支持 Qt v4。这些绑定是作为一组 Python 模块实现的，包含 1,000 多个类。

14. pyGtk. 另一个 python GUI 库。它是创建著名的 Bittorrent 客户端的同一个库。

PyGObject是一个 Python 包，它为基于GObject的库提供绑定，例如GTK、GStreamer、 WebKitGTK、GLib、GIO等等。

15. Scapy . 用python制作的python包嗅探器和分析器。

Scapy 是一个强大的交互式数据包操作程序。它能够伪造或解码多种协议的数据包，通过网络发送它们，捕获它们，匹配请求和回复等等。它可以轻松处理大多数经典任务，如扫描、跟踪路由、探测、单元测试、攻击或网络发现（它可以替代 hping、85% 的 nmap、arpspoof、arp-sk、arping、tcpdump、tshark、p0f 等）

16. pywin32 . 一个 python 库，它提供了一些有用的方法和类来与 windows 交互。

这是 Python for Win32 (pywin32) 扩展的自述文件，它提供对许多来自 Python 的 Windows API 的访问。

17. nltk . Natural Language Toolkit – 我意识到大多数人不会使用这个工具包，但它足够通用。如果你想操作字符串，它是一个非常有用的库。但它的容量远不止于此。

NLTK 是构建 Python 程序以处理人类语言数据的领先平台。它为超过 50 个语料库和词汇资源（如 WordNet）提供易于使用的接口，以及一套用于分类、标记化、词干提取、标记、解析和语义推理的文本处理库，工业强度 NLP 库的包装器，和一个活跃的讨论论坛。

18. nose. python的测试框架。它被数以百万计的 Python 开发人员使用。如果您进行测试驱动开发，这是必须的。

nose 扩展了单元测试，使测试更容易。

19. SymPy . SymPy 可以进行代数求值、微分、展开、复数等。它包含在纯 Python 发行版中。

SymPy 是一个用于符号数学的开源 Python 库。它旨在成为一个功能齐全的计算机代数系统（CAS），同时保持代码尽可能简单，以便于理解和易于扩展。SymPy 完全用 Python 编写，不需要任何外部库。

20. IPython. 这个工具有多么有用，我怎么强调都不为过。这是一个关于类固醇的python提示。它具有完成、历史、shell 功能等等。IPython是一种基于Python的交互式解释器。相较于本地的Python Shell，IPython提供了更为强大的编辑和交互功能。

Supervisor 是一个客户端/服务器系统，允许其用户控制类 UNIX 操作系统上的许多进程
http://supervisord.org/index.html

PyForest、Emot、Geemap、Dabl 和 Sweetviz 是值得了解的库，因为它将复杂的任务变成了简单的任务.

当您开始为项目键入代码时，您的第一步是什么？您可能会导入您需要的库，对吗？问题是你永远不知道你需要多少库，直到你需要它并得到一个错误。这就是为什么 PyForest 是我所知道的最方便的库之一。PyForest 只需一行代码即可将 40 个最流行的库导入您的笔记本

Emot 是一个很好的库，它有可能大大改进您的下一个 NLP 项目。它将表情符号和表情符号转换为描述性信息
Geemap 是一个 Python 库，它允许与 Google Earth Engine 进行交互式地图绘制
Sweetviz 是一个低代码 Python 库，可生成漂亮的可视化效果，用两行代码启动您的探索性数据分析。输出是一个交互式 HTML 文件

inspect模块

提供了几个有用的函数来帮助获取有关活动对象的信息，例如模块、类、方法、函数、回溯、框架对象和代码对象。例如，它可以帮助您检查类的内容、检索方法的源代码、提取和格式化函数的参数列表，或者获取显示详细回溯所需的所有信息。

import inspect

print(inspect.getsource(inspect.getsource))

print(inspect.getmodule(inspect.getmodule))

print(inspect.currentframe().f_lineno)

该模块提供四种主要服务：类型检查、获取源代码、检查类和函数以及检查解释器堆栈。

https://www.geeksforgeeks.org/inspect-module-in-python/

Jedi 库是一个自动完成和代码分析库。它使编写代码更快、更高效

https://www.masteringemacs.org/article/jedi-completion-library-python

sh

是 Python 2.6 - 3.8、PyPy 和 PyPy3 的成熟子进程替代品，它允许您像调用函数一样调用任何程序，windows上不可用

https://github.com/amoffat/sh

Python 是一种动态类型语言。定义变量、函数、类等时不需要指定数据类型

从 Python 3.5 开始，您可以选择在定义函数时提供类型提示

https://docs.python.org/3/library/typing.html

def greeting(name: str) -> str:

return 'Hello ' + name

print(greeting('world'))

尽管不是强制性的，但类型注释可以使您的代码更易于理解。

uuid

A quick and easy way to generate Universally Unique IDs (or ‘UUIDs’) is through the Python Standard Library’s uuid module.

生成通用唯一 ID（或“UUID”）的一种快速简便的方法是通过 Python 标准库的 uuid 模块。

https://docs.python.org/3/library/uuid.html

import uuid

user_id = uuid.uuid4()

print(user_id)

词汇表

https://docs.python.org/zh-cn/3.8/glossary.html#term-decorator

github和Ohloh
通过提供足够的信息来判断一个库是否有维护站仍然在工作

确定python安装路径
在cmd中输入where python

>>> import datetime

>>> now = datetime.datetime.now()

>>> now

datetime.datetime(2021, 9, 11, 20, 10, 23, 212113)

>>> now.__str__()

'2021-09-11 20:10:23.212113'

>>> str(now)

'2021-09-11 20:10:23.212113'

>>> now.__repr__()

'datetime.datetime(2021, 9, 11, 20, 10, 23, 212113)'

>>> repr(now)

'datetime.datetime(2021, 9, 11, 20, 10, 23, 212113)'

>>> eval(repr(now))

datetime.datetime(2021, 9, 11, 20, 10, 23, 212113)

str 和 repr 函数都返回对象的字符串表示。str 字符串表示应该是人性化的，主要用于记录目的，而 repr 表示应该包含有关对象的信息，以便可以再次构造它。

您永远不应该直接使用这些函数，而应始终使用 str() 和 repr() 函数。

repr

在 Python 中定义类或对象时，提供一种将该对象表示为字符串的“官方”方式很有用

class someClass:

def __repr__(self):

return "<some description here>"

someInstance = someClass()

# prints <some description here>

print(someInstance)

>>> "repr() shows quotes: {!r}; str() doesn't: {!s}".format('test1', 'test2')

"repr() shows quotes: 'test1'; str() doesn't: test2"

class Person:

def __init__(self, person_name, person_age):

self.name = person_name

self.age = person_age

def __str__(self):

return f'Person name is {self.name} and age is {self.age}'

def __repr__(self):

return f'Person(name={self.name}, age={self.age})'

p = Person('Pankaj', 34)

print(p.__str__())

print(p.__repr__())

输出：

Person name is Pankaj and age is 34

Person(name=Pankaj, age=34)

前面我们提到，如果我们不实现 __str__ 函数，则调用 __repr__ 函数。

只需注释 Person 类中的 __str__ 函数实现，print(p)就会打印{name:Pankaj, age:34}.

>>> '{:<30}'.format('left aligned')
'left aligned                  '
>>> '{:>30}'.format('right aligned')
'                 right aligned'
>>> '{:^30}'.format('centered')
'           centered           '
>>> '{:*^30}'.format('centered')  # use '*' as a fill char
'***********centered***********'

https://docs.python.org/zh-cn/3.8/library/string.html#format-specification-mini-language
>>> "{!s:<25}".format('Hello,World!')
'Hello,World! '
>>> "{!r:^25}".format('Hello,World!')
" 'Hello,World!' "
>>> "{!a:>25}".format('Hello,World!')
" 'Hello,World!'"
'!s' 会对值调用 str()，'!r' 调用 repr() 而 '!a' 则调用 ascii()

<左对齐，^居中对齐，>右对齐

# 将对齐应用于输出

name = '{:^20}'.format('journaldev')

print(name)

# 打印带有符号值的数字

print('{:+d}'.format(42))

# 格式化python 字典值

stark = {'first': 'Ned', 'second': 'Brandon', 'third': 'Rob'}

print('{first} {third}'.format(**stark))

# 可以将 Decimal 值格式化为精确点

value = '{:{width}.{prec}f}'.format(3.1428, width=5, prec=2)

print(value)

# 格式化日期时间值

from datetime import datetime

print('{:%Y-%m-%d %H:%M}'.format(datetime(2017, 12, 7, 13, 22)))

myDate = datetime(2017, 12, 7, 13, 22)

# now = datetime.now()

print('{:{dfmt} {tfmt}}'.format(myDate, dfmt='%Y-%m-%d', tfmt='%H:%M'))

在Python软件包索引（PyPI）https://pypi.org/ 上可以找到大多数流行的软件包。您还会在github，bitbucket和Google代码上找到很多Python软件包

easy_install

一旦安装了setuptools，就可以使用easy_install。您可以在Python安装的Scripts文件夹中找到安装的文件。确保将Scripts文件夹添加到系统路径，以便您可以在命令行上调用easy_install而不指定其完整路径

easy_install -h
easy_install package_name
easy_install -U SQLAlchemy

easy_install http://example.com/path/to/MyPackage-1.2.3.tgz

easy_install /path/to/downloaded/package

https://python101.pythonlibrary.org/chapter29_pip.html

You may want to call pip -h to get a full listing of everything pip can do. One thing that pip can install that easy_install cannot is the Python wheel format. A wheel is a ZIP-format archive with a specially formatted filename and the .whl extension. You can also install wheels via its own command line utility. On the other hand, pip cannot install an egg. If you need to install an egg, you will want to use easy_install.

您可能想要调用 pip -h 来获取 pip 可以执行的所有操作的完整列表。 pip 可以安装而 easy_install 不能安装的一件事是 Python Wheel格式。 wheel是 ZIP 格式的档案，具有特殊格式的文件名和 .whl 扩展名。您还可以通过其自己的命令行实用程序安装轮子。另一方面，pip 不能安装egg。如果您需要安装一个 egg，您将需要使用 easy_install。

Pip
https://hyperskill.org/learn/step/6230

pip(Pip Installs Packages)
查看版本
pip --version

查看帮助
pip --help

pip -h

安装wheel文件

pip install project_name # 在线安装discover, download and install

pip install wheel_file.whl # 离线安装directly install the wheel

pip install some_package

安装指定版本

pip install some_package==1.1.2

安装一个最低版本

pip install "some_package>=1.1.2"

show 命令显示有关已安装软件包的信息，例如，它们的版本，作者，许可证，位置或要求

pip show some_package

list 命令按字母顺序列出了您在计算机上安装的所有软件包

pip list

outdated 命令获得过时软件包的列表以及可用的最新版本和最新版本

pip list -o

pip list --outdated

upgrade 命令更新软件包到最新的可用版本

pip install --upgrade some_package

pip install -U PackageName

uninstall 命令删除软件包

pip uninstall some_package

freeze 命令是用于以需求格式获取所有已安装软件包

以下命令是列出所有必要软件包名称并存入文件

pip freeze > requirements.txt

直接从特殊文件requirements.txt（需修改下）中安装软件包

pip install -r requirements.txt

Poetry

https://python-poetry.org/

PYTHON打包和依赖管理变得容易

一个Python安装可能无法满足每个应用程序的要求，解决方案是创建一个 virtual environment
https://www.thepythoncorner.com/2016/11/using-virtual-environments-with-python/

https://docs.python.org/3/library/venv.html
当前，有两种用于创建Python虚拟环境的常用工具：

venv在Python 3.3和更高版本中默认可用，并在Python 3.4和更高版本中将pip和setuptools安装到创建的虚拟环境中（虚拟环境中输入pip list）

virtualenv需要单独安装，但支持Python 2.7+和Python 3.3+，并且 pip， setuptools和 wheel默认情况下始终安装到创建的虚拟环境中（无论Python版本如何）。

要创建虚拟环境，您只需选择要使用virtualenv还是venv模块。
virtualenv适用于Python 2.7和Python 3.x，venv模块仅适用于Python 3.3或更高版本。

用于创建和管理虚拟环境的模块称为 venv

python -m venv my-project

source my-project/bin/activate

pip install all-the-modules

win10 添加用户环境变量

在Windows上，venv按如下所示调用命令：
c:\>c:\Python35\python -m venv c:\path\to\myenv
另外，如果您为Python安装配置了PATH和PATHEXT变量，则：
c:\>python -m venv c:\path\to\myenv

在Windows上python已添加环境变量，运行:
C:\>python -m venv tutorial-env
如果它不存在，这将在命令所在路径创建 tutorial-env 目录，并在其中创建包含Python解释器，标准库和各种支持文件的副本的目录

# 当前目录创建虚拟环境
C:\Users\DZL>python -m venv 123

# 指定目录创建虚拟环境
C:\Users\DZL>python -m venv C:\456

在Windows上激活
C:\Users\DZL>C:\456\Scripts\activate.bat

退出
(456) C:\Users\DZL>deactivate
退出并关掉窗口
(456) C:\Users\DZL>exit

删除文件夹 del

删除文件 rmdir /s .

查看文件夹中的文件 dir

创建虚拟环境后，可以使用虚拟环境的二进制目录中的脚本“激活”它。该脚本的调用是特定于平台的（<venv>必须替换为包含虚拟环境的目录的路径）：

Packages包

该目录需要包含名为“__init__.py”的文件。此文件可以为空，也可以包含有效的Python代码。此代码将在导入包时执行，因此可用于初始化包，例如，以确保导入某些其他模块或设置某些值

Python附带了许多预制的代码。这些代码段称为模块和包。一个模块是一个可导入的Python文件，而一个包则由两个或多个模块组成。可以像导入模块一样导入软件包

Python还提供了一种从模块导入所有函数和值的方法。这实际上是一个坏主意，因为它会污染您的命名空间。命名空间是在程序生命周期中所有变量都存在的地方

pep8限制所有行最多79个字符

https://www.python.org/dev/peps/pep-0008/

检测代码规范有pep8 flake8和pylint

pep8 main.py

代码分析

代码概要分析是尝试在代码中查找瓶颈。分析应该查找代码中哪些部分花费的时间最长。一旦知道了这一点，便可以查看代码的这些部分，并尝试找到优化它的方法

使用cProfile分析代码确实非常容易。您需要做的就是导入模块并调用其运行功能

Python 3.7
>>> import types    
>>> print(len([i for i in dir(types) if not i.startswith('__')]))
27

Python有3种方法来找出运行什么操作系统os.name、sys.platform、platform.system()

>>> import platform
>>> platform.system() == 'Windows' and platform.release() == '7'
True
>>> 'Windows-7' in platform.platform()
True

import os
a = 'c:' # removed slash
b = 'myFirstDirectory' # removed slash
c = 'mySecondDirectory'
d = 'myThirdDirectory'
e = 'myExecutable.exe'
print(os.path.join(a + os.sep, b, c, d, e))
print(os.sep)
print(os.path.join(a+ os.sep, b, c, d, e).replace("\\","/"))
>>> %Run 11.py
c:\myFirstDirectory\mySecondDirectory\myThirdDirectory\myExecutable.exe
\
c:/myFirstDirectory/mySecondDirectory/myThirdDirectory/myExecutable.exe

密码生成

import string
from secrets import choice
# 字母表加数字
alphabet = string.ascii_letters + string.digits
print(alphabet)
while True:
# str.join(sequence) 方法用于将序列中的元素以指定的字符连接生成一个新的字符串
password = ''.join(choice(alphabet) for i in range(10))
print(password)
# 密码要求有小写字母、大写字母且数字大于等于3
if (any(c.islower() for c in password)
and any(c.isupper() for c in password)
and sum(c.isdigit() for c in password) >= 3):
break
print(password)

魔术
开头和结尾的双下划线

Python注释

注释要与其下方的代码处于相同的缩进级别
＃用于Python中的单行注释，后跟一个空格

"""内容 """用于多行注释或块注释

文档字符串必须是对象（模块，函数，类和方法）定义中的第一条语句。否则为常规注释
Python解释器不会像注释一样忽略它们，可以使用特殊变量__doc__访问它们

def double(num):
"""Function to double the value"""
return 2*num

print(double.__doc__)
>>>Function to double the value

Python缩进

许多高级编程语言，例如C，C ++，C＃，都使用花括号{}标记代码块。Python通过缩进来实现。

代表函数或循环体的代码块以缩进开始，以第一条未缩进的行结束。

对于创建复合语句，缩进将是最必要的，在代码块中每行缩进四个空格（或相同数量）

Blocks 块

Indenting Code 缩进代码

Python structures by colons and indentation
Python结构是通过冒号和缩进

异常

查找所有异常

print(dir(locals()['__builtins__']))

该assert是条件错误处理的关键字，可以让你检查，以满足特定的标准。如果不满足条件，则会抛出 AssertionError。

def input_age(age):

   try:

       assert int(age) > 18

   except ValueError:

       return 'ValueError: Cannot convert into int'

   else:

       return 'Age is saved successfully'

print(input_age('23'))  # This will print

print(input_age(25))  # This will print

print(input_age('nothing'))  # This will raise ValueError which is handled

print(input_age('18'))  # This will raise AssertionError and the the program collapse

print(input_age(43))  # This will not print

使用raise关键字引发现有异常

def input_age(age):

try:

if(int(age)<=18):

raise ZeroDivisionError

except ValueError:

return 'ValueError: Cannot convert into int'

else:

return 'Age is saved successfully'

print(input_age('23')) # This will execute properly

print(input_age('18')) # This will not execute properly

自定义异常类

class UnderAge(Exception):
   pass
 
def verify_age(age):
   if int(age) < 18:
       raise UnderAge
   else:
       print('Age: '+str(age))
 
# main program
verify_age(23)  # won't raise exception
verify_age(17)  # will raise exception

# import module sys to get the type of exception
import sys
randomList = ['a', 0, 2]
for entry in randomList:
try:
print("The entry is", entry)
r = 1/int(entry)
break
except:
print("Oops!", sys.exc_info()[0], "occurred.")
print("Next entry.")
print()
print("The reciprocal of", entry, "is", r)
# import module sys to get the type of exception
import sys
randomList = ['a', 0, 2]
for entry in randomList:
try:
print("The entry is", entry)
r = 1/int(entry)
break
except Exception as e:
print("Oops!", e.__class__, "occurred.")
print("Next entry.")
print()
print("The reciprocal of", entry, "is", r)

# define Python user-defined exceptions
class Error(Exception):
"""Base class for other exceptions"""
pass
class ValueTooSmallError(Error):
"""Raised when the input value is too small"""
pass
class ValueTooLargeError(Error):
"""Raised when the input value is too large"""
pass
# you need to guess this number
number = 10
# user guesses a number until he/she gets it right
while True:
try:
i_num = int(input("Enter a number: "))
if i_num < number:
raise ValueTooSmallError
elif i_num > number:
raise ValueTooLargeError
break
except ValueTooSmallError:
print("This value is too small, try again!")
print()
except ValueTooLargeError:
print("This value is too large, try again!")
print()
print("Congratulations! You guessed it correctly.")

异常有层次结构，子类在父类前面

https://docs.python.org/3/library/exceptions.html#exception-hierarchy

# Handle exceptions with a try/except block
try:
# Use "raise" to raise an error
raise IndexError("This is an index error")
except IndexError as e:
pass # Pass is just a no-op. Usually you would do recovery here.
except (TypeError, NameError):
pass # Multiple exceptions can be handled together, if required.
else: # Optional clause to the try/except block. Must follow all except blocks
print("All good!") # Runs only if the code in try raises no exceptions
finally: # Execute under all circumstances
print("We can clean up resources here")
#
my_dict = {"a":1, "b":2, "c":3}
try:
value = my_dict["a"]
except KeyError:
print("A KeyError occurred!")
else:
print("No error occurred!")
finally:
print("The finally statement ran!")

Python中的多行语句

通常每个Python语句都以换行符结尾。但是，我们可以使用行连续字符（\）将其扩展到多行。

Python提供了两种在程序中启用多行语句的方法
显式行继续---立即使用换行符（\）将语句拆分为多行

隐式行连续---隐式行连续是当您使用括号（），方括号[]和花括号{}中的任何一个拆分语句时。您需要使用上述结构将目标语句括起来。

还可以使用分号将多个语句放在一行中，如：a = 1; b = 2; c = 3

Python模块属性：name,doc,file,dict

__name__属性返回模块的名称

默认情况下，脚本文件名（不包括扩展名.py）是__name__属性的值

>>> __name__

'__main__'

__doc__属性将返回在模块代码开头定义的字符串。

名称，文档，文件，字典

__file__ 是一个可选属性，其中包含从中加载模块文件的名称和路径

>>> import io

>>> io.__file__

'C:\\Python38\\lib\\io.py'

__dict__属性将返回包含模块属性，函数和其他定义及其各自值的字典对象

>>> import math

>>> math.__dict__

{'__name__': 'math', '__doc__': 'This module provides access to the mathematical ...}

dir（）是一个内置函数，它也返回模块中所有属性和函数的列表

Modules模块

'import'关键字用于将特定模块导入您的python代码

每个模块只能在每个解释器会话或程序或脚本中导入一次

from importlib import reload
reload(one_time)

如果你import一个模块，解释器会在以下位置按照给定的顺序搜索这个模块：

首先，Python解释器尝试在当前工作目录中定位模块。
如果未找到，则搜索PYTHONPATH环境变量中的目录。
如果仍然找不到，它将搜索安装默认目录。例如C:\Python38

Python内置模块用C编写，并与Python解释器集成
显示所有可用模块的列表
>>> help('modules')

可以获得这些模块的完整列表

import sys

print(sys.builtin_module_names)

所有其他以下划线开头的名称是与模块关联的默认Python属性

sys模块

提供用于操纵Python运行时环境不同部分的函数和变量。

sys.argv：返回传递给Python脚本的命令行参数列表。此列表中索引0处的项目始终是脚本的名称。其余参数存储在后续索引处。

sys.exit()：这将导致脚本退回到Python控制台或命令提示符。通常用于在发生异常的情况下安全地退出程序。

sys.maxsize：返回变量可以采用的最大整数。

sys.path：这是一个环境变量，是所有Python模块的搜索路径。

sys.version：此属性显示一个字符串，其中包含当前Python解释器的版本号。

打印python 格言
import this
详解
https://inventwithpython.com/blog/2018/08/17/the-zen-of-python-explained/

import __hello__将显示Hello World....
import antigravity浏览器会打开一个漫画！

python关键字

Python 3.8中有35个关键字。 3.9有36个关键字，只有三个是大写开头的
>>> import keyword
>>> len(keyword.kwlist)
35
>>> 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']

>>> 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是区分大小写的语言，始终命名有意义的标识符，可以使用下划线分隔多个单词this_is_a_long_variable

iterators, generators and decorators

迭代器，生成器和装饰器

https://pymbook.readthedocs.io/en/latest/igd.html#decorators

装饰器接受一个函数，添加一些功能并返回它

def star(func):
def inner(*args, **kwargs):
print("*" * 30)
func(*args, **kwargs)
print("*" * 30)
return inner
def percent(func):
def inner(*args, **kwargs):
print("%" * 30)
func(*args, **kwargs)
print("%" * 30)
return inner
@star
@percent
def printer(msg):
print(msg)
'''
相当于
def printer(msg):
print(msg)
printer = star(percent(printer))
'''
printer("Hello")

Generators 生成器

生成器功能非常有用。可以通过与常规函数相同的方式声明自定义生成器，只是有一个区别：return关键字被替换为yield。

生成器函数依次一次只生成一个值，仅在明确要求它们为新值时才生成，而不是一次全部给出。调用生成器不会立即执行它。相反，将返回一个可以迭代的生成器对象

yield实际上是保存了函数的状态

在每个时间点上，只有一个值才会产生并存储在内存中：上一个值在我们移至下一个值之后会被忘记，因此不会占用空间。但是请记住，正是由于在需要生成新值时忘记了先前的值，所以我们只能对这些值进行一次检查。

def generator():
for i in range(6):
yield i*i

g = generator()
for i in g:
print(i)

定义生成器的另一种方法是生成器表达式，其类似于列表推导。语法上的唯一区别是方括号：列表推导语句应使用方括号[]，定义生成器时应使用圆括号()

values = (-x for x in [1,2,3,4,5])
for x in values:
print(x, end='')
>>> -1-2-3-4-5

>>> values = (-x for x in [1,2,3,4,5])

>>> next(values)

-1

>>> next(values)

-2

>>> next(values)

-3

>>>

生成器允许声明一个行为类似于迭代器的函数。
生成器之所以懒惰，是因为它们仅在我们要求时才给我们带来新的值。
有两种创建生成器的方法：生成器函数和生成器表达式。
生成器具有存储效率，因为它们只需要为其生成的一个值存储即可。
生成器只能使用一次。

def my_generator():

i = 0

while True:

yield i

i = i+1

gen_1 = my_generator()

print(next(gen_1))

gen_2 = my_generator()

print(next(gen_2))

print(next(gen_1))

最新的输出值由解释器自动存储在名为“_”的特殊变量中,下划线变量仅在Python shell中可用。它在Python脚本或程序中不可用

>>> 1+2

>>> _

>>>

只做循环未使用的变量前面加_ 如：_i 要用关键字的变量后面加_ 如：str_

退出shell

exit() quit()

shell中没有括号的退出在Python2.x中起作用，但在Python3.x中不再起作用

Ctrl + Z 再EnterEnter

https://www.python-course.eu/python3_execute_script.php

您很可能已经在某处读到了Python语言是一种解释型程序设计或脚本语言。事实是：Python既是解释语言又是编译语言。但是将Python称为编译语言会产生误导。人们会认为编译器将Python代码转换为机器语言。Python代码被转换为中间代码，该代码必须由称为PVM（Python虚拟机）的虚拟机执行。这与Java采用的方法类似。甚至还有一种将Python程序转换为Java虚拟机（JVM）的Java字节码的方法。这可以通过Jython实现。

Python解释器将源代码转换为字节码，然后把编译好的字节码转发到Python虚拟机（PVM）中进行执行

问题是，是否必须编译我的Python脚本以使其更快，或者如何编译它们？答案很简单：通常，您不需要做任何事情，也不必打扰，因为“ Python”已经在为您做事，即自动采取必要的步骤。

无论出于何种原因，您都想手动编译python程序？没问题。可以使用py_compile模块，或者使用解释器shell来完成

import py_compile

py_compile.compile('my_first_simple_program.py')

或在shell提示下使用以下命令

python -m py_compile my_first_simple_program.py

无论哪种方式，您都可能注意到两件事：首先，将存在一个新的子目录“ __pycache__”（如果尚不存在）。您将在此子目录中找到文件“my_first_simple_script.cpython-34.pyc”。这是字节格式的文件的编译版本。

还可以使用compileall模块自动编译当前工作目录下所有Python文件

python -m compileall

但是正如我们所说，您不必也不应该为编译Python代码而烦恼。有充分的理由对用户隐藏了该编译。一些新手有时会怀疑这些带有.pyc后缀的不祥文件可能来自哪里。如果Python对Python程序所在的目录具有写访问权，则它将编译后的字节码存储在以.pyc后缀结尾的文件中。如果Python没有写访问权限，则该程序仍然可以运行。程序退出时，字节码将被产生但被丢弃。每当调用Python程序时，Python都会检查是否存在带有.pyc后缀的编译版本。该文件必须比带有.py后缀的文件新。如果存在这样的文件，Python将加载字节码，这将加快脚本的启动时间。如果没有字节码版本，Python将在开始执行程序之前创建字节码。执行Python程序意味着在Python上执行字节代码。

Compiler编译器

定义：编译器是一种计算机程序，它将一种编程语言（源语言）的源代码转换（翻译）成另一种计算机语言（目标语言）。在大多数情况下，编译器用于将源代码转换为可执行程序，即，它们将代码从高级编程语言转换为低级（或低级）语言，主要是汇编代码或机器代码。

Interpreter解释器

定义：解释器是一种计算机程序，可执行以编程语言编写的指令。它可以直接执行源代码，也可以在第一步中将源代码转换为更有效的表示形式并执行该代码。

函数作用域的LEGB顺序
L ： local 函数内部作用域
E : enclosing 函数内部与内嵌函数之间
G : global 全局作用域
B： build-in 内置作用

python在函数里面的查找分为4种，称之为LEGB，也正是按照这是顺序来查找的

Variables变量

注意：在Python中，我们实际上并未为变量分配值。相反，Python将对象（值）的引用提供给变量

全局变量global

Python中关键字global的基本规则是：

当我们在函数内部创建变量时，默认情况下它是局部的。
当我们在函数外部定义变量时，默认情况下它是全局的。您不必使用global关键字。
我们使用global关键字在函数内部读写全局变量。
global在函数外使用关键字无效

x = "global"
def foo():
global x
y = "local"
x = x * 2
print(x)
print(y)
foo()
print(x)

globalglobal

local

globalglobal

def foo():

x = 20

def bar():

global x

x = 25

print("Before calling bar: ", x)

print("Calling bar now")

bar()

print("After calling bar: ", x)

foo()

print("x in main : ", x)

>>>Before calling bar: 20
>>>Calling bar now
>>>After calling bar: 20
>>>x in main : 25

在函数体内创建了全局变量，则对f函数体内部所做的任何操作都是对f之外的全局变量s进行的

def f():
    global s
    print(s)
    s = "dog"
    print(s) 
s = "cat" 
f()
print(s)

在Python中变量您不需要声明。只需输入变量，当赋值给它时，它会自动知道给定的值是int，char，甚至是String

不仅变量的值可能在程序执行期间发生变化，而且类型也是如此
i=10 赋值中相等的“=”符号不应视为“等于”。它应该被“读取”或解释为“被设置为”

id()函数

用来确认内存地址
在以下两种情况下，Python还将分配相同的内存地址
字符串没有空格，并且少于20个字符
如果整数介于-5到+255之间
这个概念被称为Interning。Python这样做是为了节省内存

id(10)
每个实例（对象或变量）都具有标识，即在脚本或程序中唯一的整数
x is y 相当于id(x)==id(y)

dir（）内置函数

查看 Python 对象内部并查看它具有哪些属性

是Python3中强大的内置函数，它返回任何对象的属性和方法的列表（例如函数，模块，字符串，列表，字典等）

dir（）尝试返回被调用对象的有效属性列表。同样，dir（）函数在处理不同类型的对象时的行为也大不相同，因为它旨在生成最相关的对象，而不是完整的信息。

对于类对象，它还返回所有有效属性和基本属性的名称列表。
对于模块/库对象，它将尝试返回该模块中包含的所有属性的名称列表。
如果未传递任何参数，它将返回当前作用域中的名称列表。

[x for x in dir(moudel) if not x.startswith('__')]

通过导入builtins模块，可以获得内置函数，异常和其他对象的列表

import builtins

print(dir(builtins))

type()函数

my_list =[10,20,20.5,'Python',100]

print(type(my_list)) # class 'list'

print(type(my_list).__name__) # list

help()函数
用于显示模块，函数，类，关键字等的文档
>>> help()

您现在有一个“help>”提示，而不是“ >>>”。在帮助模式下，您可以浏览Python中找到的各种模块，关键字和主题。还要注意，当键入单词“ modules”时，由于Python搜索其库文件夹以获取列表，您会看到延迟。

未导入模块，需添加引号

>>>help("os.walk")

导入模块

>>>import os

>>>help(os.walk)

zip()函数

用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表

zip() 内置函数接受许多可迭代对象并返回一个元组列表。每个元组按位置索引对输入对象的元素进行分组。
在 Python 3.x 中为了减少内存，zip() 返回的是一个对象。如需展示列表，需手动 list() 转换

您还可以通过对它们调用 *zip() 来“解压缩”对象。

keys = ['a', 'b', 'c']

vals = [1, 2, 3]

zipped = dict(zip(keys, vals))

print(zipped)

join()函数

用于将序列中的元素以指定的任意字符串联生成一个新的字符串
>>>"*".join("love")
l*o*v*e

len()函数
返回对象的长度（元素个数）。实参可以是序列（如 string、bytes、tuple、list 或 range 等）或集合（如 dictionary、set 或 frozen set 等）

>>> print(10)

>>> print(0x10)

>>> print(0o10)

>>> print(0b10)

函数hex，bin，oct可用于将整数转换为整数的对应字符串表示形式

>>> hex(97)
'0x61'
>>> oct(97)
'0o141'
>>> bin(97)
'0b1100001'
>>> int(0X61)
97
>>> int(0o141)
97

x = "Hallo"

t = str(x)

u = t.encode("UTF-8")

print(u)

# Output: b'Hallo'

在Python中，正则表达式表示为RE（RE，regex或regex模式）通过re模块导入
资料
https://www.programiz.com/python-programming/regex
工具
https://regex101.com/

https://pymotw.com/3/re/index.html

正则表达式方法包括 re.match（），re.search（）和re.findall（）

Python数据类型

在Python中，我们不需要在显式提及数据类型的情况下声明变量，Python在运行时直接根据语法确定文字的类型。例如，引号标记着字符串值的声明，方括号代表列表，而大括号则代表字典。同样，非小数将被分配为Integer类型，而带小数点的将为浮点数。

Booleans布尔值

几乎每种编程语言都具有的数据类型，Python也是如此。Python中的布尔值可以有两个值– True（1）或False（0）

condition = False

if condition == True:

print("You can continue with the prpgram.")

else:

print("The program will end here.")

>>> A, B = True + 0, False + 0
>>> print(A, B)
1 0
>>> type(A), type(B)
(<class 'int'>, <class 'int'>)

Python 三元运算符语法

[when_true] if [condition] else [when_false]

Numbers数值

https://www.programiz.com/python-programming/numbers

在Python 2.x中，除（/）将返回整数商作为输出

在Python 3.x中，除（/）将返回浮点商作为输出
运算符（//）返回整数商，而mod（％）运算符给出余数。但是，您可以通过使用divmod（）函数来获得这两者

>>> divmod(7, 2) # -->(3, 1)

>>> 7 / 2 # -->3.5

>>> 7 // 2 # -->3

>>> -7 // 2 # -->-4

>>> -7.0 // 2 # -->-4.0

>>> 7 % 2 # -->1

>>> eval('2+3') # -->5

Python 2.x具有四种内置数据类型（int，long，float和complex）来表示数字。后来，Python 3.x删除了long类型，并将int类型扩展为无限长度

整数，浮点数和复数属于Python数字类别。在Python类它们被定义为int，float和complex

使用内置函数type（）来确定变量或值属于哪个类
内置函数isinstance（）用于检查对象是否属于特定类

>>> isinstance(2.2, float)

True

num = 2

print("The number (", num, ") is of type", type(num))

num = 3.0

print("The number (", num, ") is of type", type(num))

num = 3+5j

print("The number ", num, " is of type", type(num))

print("The number ", num, " is complex number?", isinstance(3+5j, complex))

#Output

The number ( 2 ) is of type <class 'int'>

The number ( 3.0 ) is of type <class 'float'>

The number (3+5j) is of type <class 'complex'>

The number (3+5j) is complex number? True

在Python中，我们可以在数字后添加“ j”或“ J”以使其复数

x = 3 + 4j
print(type(x))
# <class 'complex'>
print(x.real)
# 3.0
print(x.imag)
# 4.0

Bytes字节

是Python中的不可变类型。它可以存储从0到255的字节序列（每个8位）。类似于数组，我们可以使用索引来获取单个字节的值。但是我们不能修改该值

>>> # Make an empty bytes object (8-bit bytes)

>>> empty_object = bytes(16)

>>> print(type(empty_object))

>>> print(empty_object)

b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'

------------------------------------------------------------------------------------------ Strings字符串

数据类型之间的转换

隐式转换：Python总是将较小的数据类型转换为较大的数据类型，以避免数据丢失

显式类型转换也称为类型转换，对象的数据类型由用户使用预定义的函数int()，float()，str()，等进行转换，可能会发生数据丢失

>>> int('100', base=2)

>>> int('100', base=3)

>>> int('100', base=4)

>>> int('100', base=6)

>>> int('100', base=7)

>>> int('123', base=7) # 1*7*7 +2*7+3

strings = "This is Python"
char = "C"
multiline_str = """This is a multiline string with more than one line code."""
unicode = u"\u00dcnic\u00f6de"
raw_str = r"raw \n string"
>>> float(5)
5.0
# 从float到int的转换将截断该值（使其接近零）
>>> int(10.6)
10
>>> int(-10.6)
-10
# 字符串之间的转换必须包含兼容的值
>>> float('2.5')
2.5
>>> float(3)
3.0
>>> complex(4 + 7j)
(4+7j)
>>> str(25)
'25'
>>> int('1p')
ValueError: invalid literal for int() with base 10: '1p'
# 我们甚至可以将一个序列转换为另一序列
>>> set([1,2,3])
{1, 2, 3}
>>> tuple({5,6,7})
(5, 6, 7)
>>> list('hello')
['h', 'e', 'l', 'l', 'o']
# 要转换为字典，每个元素必须成对
>>> dict([[1,2],[3,4]])
{1: 2, 3: 4}
>>> dict([(3,26),(4,44)])
{3: 26, 4: 44}

Python有4种类型的内置数据结构，即List，Dictionary，Tuple和Set。

type({}) <class 'dict'>

type({1}) <class 'set'>

type((1)) <class 'int'>

type((1,)) <class 'tuple'>

0和空的List，Dictionary，Tuple和Set的布尔值为False

bool()

None为假且not None为真。

collections --- 容器数据类型

https://docs.python.org/3/library/collections.html

这个模块实现了特定目标的容器，以提供Python标准内建容器 dict , list , set , 和 tuple 的替代选择。.

https://www.geeksforgeeks.org/python-collections-module/

fruits = ["apple", "mango", "orange"] # list
numbers = (1, 2, 3) # tuple
alphabets = {'a':'apple', 'b':'ball', 'c':'cat'} # dictionary
vowels = {'a', 'e', 'i' , 'o', 'u'} # set

List列表
列表是可变数据结构，即可以在列表创建之后将项添加到列表中。单个列表可以包含字符串，整数以及对象。列表还可用于实现堆栈和队列。列表是可变的，即一旦声明它们就可以被改变,
列表是项目的有序序列。它是Python中最常用的数据类型之一，非常灵活。列表中的所有项目不必是同一类型。
Python列表是一个类似构造的数组，它以有序序列存储任意类型的对象。它非常灵活，没有固定大小。列表中的索引在Python中从零开始

[True, False, 1, 1.1, (1+2j), 'Learn', b'Python']

>>> for item in assorted_list:

print(type(item))

Dictionary字典

Python中的字典是键-值对的无序集合。这是Python中的内置映射类型，其中键映射到值。这些键值对提供了一种直观的数据存储方式

3.6的dict是有序的，在此版本之前皆是无序（写答案当前最新版为3.6）
为什么需要字典？
该词典解决了有效存储大量数据集的问题。Python已对字典对象进行了高度优化以检索数据。

用于创建字典的Python语法使用大括号{}，其中每个项目都是一对形式的key:value。键和值可以是任何Python数据类型

Python provides power data types like lists and associative arrays, called dict in Python
Python提供了功能数据类型如列表和关联数组，在Python中称为字典

可以使用方法items（），keys（）和values（）从字典创建列表。顾名思义，方法keys（）创建一个列表，该列表仅包含字典的键。values（）生成一个由值组成的列表。items（）可用于创建由2元组（键，值）组成的列表

列表和字典之间的区别是什么？
列表是有序的对象序列，而字典是无序集。但主要区别在于词典中的项目是通过键而不是通过其位置访问的
字典不支持序列数据类型（如字符串，元组和列表）的序列操作。字典属于内置映射类型，但到目前为止它们是这种类型的唯一代表！
key必须为不可变类型

不能通过数字访问字典的元素

我们可以在字典中使用任意类型作为值，但是对键有限制。只有不可变数据类型可以用作键，即不能使用列表或字典,可以使用元组

创建空字典

>>> my_dict  =  {} 
>>> another_dict  =  dict （）

my_dict = {'key': 'value'} # PEP8注意：后面有个空格
children = {'Emily': 'artist', 'Adam': 'astronaut', 'Nancy': 'programmer'}

dict(americano=8.0)，表达式的左侧被视为变量，因此它不能是整数，带引号的字符串，列表，多字表达式等。是的，以下几行将给您一个错误：

d1 = dict(888=8.0)
d2 = dict("americano"=8.0)
d3 = dict(["americano", "filter"]=8.0)
d4 = dict(the best americano=8.0)

将列表转换为词典

dict(list(zip(A,B)))

>>> sample_dict = {'key':'value', 'jan':31, 'feb':28, 'mar':31}

>>> type(sample_dict)

>>> sample_dict

{'mar': 31, 'key': 'value', 'jan': 31, 'feb': 28}

>>> sample_dict.keys()

dict_keys(['mar', 'key', 'jan', 'feb'])

>>> sample_dict.values()

dict_values([31, 'value', 31, 28])

>>> sample_dict.items()

dict_items([('mar', 31), ('key', 'value'), ('jan', 31), ('feb', 28)])

只能检查键是否存在词典“中”
"one" in filled_dict # => True

filled_dict.update({'one':4})

>>> {'a': 1, **{'b': 2}}
{'a': 1, 'b': 2}
>>> {'a': 1, **{'a': 2}}
{'a': 2}

>>> "name" in my_dict         # this is good
>>> "name" in my_dict.keys()  # this works too, but is slower

尽管这对您现在可能并不重要，但在实际工作情况下，几秒钟很重要。当您要处理数千个文件时，从长远来看，这些小技巧可以为您节省大量时间！

我们甚至可以将一个序列转换为另一序列。

>>> set([1,2,3])
{1, 2, 3}
>>> tuple({5,6,7})
(5, 6, 7)
>>> list('hello')
['h', 'e', 'l', 'l', 'o']

要转换为字典，每个元素必须成对：

>>> dict([[1,2],[3,4]])
{1: 2, 3: 4}
>>> dict([(3,26),(4,44)])
{3: 26, 4: 44}

Tuple元组
元组是与列表相同的项目的有序序列，唯一的区别是元组是不可变的。元组一旦创建就无法修改。元组用于写保护数据，通常比列表快，因为它不能动态更改。它在括号（）中定义，其中各项之间用逗号分隔。元组是一系列不可变的Python对象。元组就像列表一样，但一旦声明元组就无法更改，但可以使用关键字“del”完全删除元组。元组通常比列表更快
将元组用于异构（不同的）数据类型，将列表用于同质（相似）的数据类型

my_tuple = ("hello")
print(type(my_tuple)) # <class 'str'>

# Creating a tuple having one element
my_tuple = ("hello",)
print(type(my_tuple)) # <class 'tuple'>

# Parentheses is optional
my_tuple = "hello",
print(type(my_tuple)) # <class 'tuple'>

说元组是可变的在技术上是错误的，因为其值是可变的

>>> a = ('dogs', 'cats', [1, 2, 3])
>>> b = ('dogs', 'cats', [1, 2, 3])
>>> a == b
True
>>> a is b
False

>>> a[2].append(99)
>>> a
('dogs', 'cats', [1, 2, 3, 99])
>>> a == b
False

要写一个空元组，你需要写成两个不包含任何内容的括号
tup1 = ()

要为单个值编写元组，您需要包含逗号，即使只有一个值
tup2 = (1,)

元组打包和拆包

x = ("Guru99", 20, "Education")
# tuple packing
(company, emp, profile) = x
# tuple unpacking
print(company)
print(emp)
print(profile)

元组比较
a=(5,6)
b=(5,4)
if (a>b):
print("a is bigger")
else:
print ("b is bigger")

比较从每个元组的第一个元素开始。在这种情况下，5> 5是不确定的。所以它进入下一个元素。6> 4，所以输出a更大

元组切片
从元组中获取特定的子元素集

x = ("a","b","c","d","e")

print(x[1:3])

带有元组的内置功能
为了执行不同的任务，元组允许你使用许多内置函数，如all（），any（），enumerate（），max（），min（），sorted（），len（），tuple（）等。

x = [True, True, False]

if any(x):
print("At least one True")

if all(x):
print("Not one False")

if any(x) and not all(x):
print("At least one True and one False")

元组和字典

Dictionary可以通过调用items返回元组列表，其中每个元组都是一个键值对

a = {'x':100, 'y':200}

for i in a.items():

print(i)

#输出

#('x', 100)

#('y', 200)

b = list(a.items())

print(b)

#输出

#[('x', 100), ('y', 200)]

元组优于列表的优点
迭代通过元组比使用列表更快，因为元组是不可变的。
由不可变元素组成的元组可以用作字典的键，这对于列表是不可能的
如果您拥有不可变的数据，那么将其实现为元组将保证它保持写保护

sequence[start:stop:step]
start: 0
stop: len(sequence)
step: 1

Set集合
是唯一项的无序集合，用大括号{}内的逗号分隔的值定义。集合中的项目不排序。

我们可以在两个集合上执行集合操作，例如联合，相交。设置具有唯一值。他们消除重复
由于set是无序集合，因此索引没有意义。因此，切片运算符[]不起作用

Python集合具有以下特征

元素没有特定的顺序，并且它们的位置可能不一致

每个项目在集合中都是唯一的，因此不能重复。
元素是不可变的，因此一旦添加就不能接受更改。
集合本身是可变的，并允许添加或删除项目。

使用集合，我们可以执行一些数学运算，例如并集，相交，对称差和补数。

我们想要创建一个集合，我们可以使用序列或另一个可迭代对象调用内置的set函数：
集合有多个用例。例如，它们用于在列表中去重

在所有Python数据类型中，集合是一种支持数学运算（例如，并集，交集，对称差等）的集合。
集合是唯一且不可变的对象的无序集合。它的定义始于用大括号{}括起来的括号，其项之间用逗号分隔。
由于集合是从数学中的“集合”派生而来的，因此它不能多次出现同一元素

与列表相比，集合类型具有明显的优势。它实现了高度优化的方法，该方法检查容器是否承载特定元素。此处使用的机制基于称为哈希表的数据结构

要创建集合，请使用序列或任何可迭代对象调用内置的set（）函数，另一种更简单的方法是指定用大括号{}括起来的元素

fruits = ["apple", "mango", "orange"] # list
numbers = (1, 2, 3) # tuple
alphabets = {'a':'apple', 'b':'ball', 'c':'cat'} # dictionary
vowels = {'a', 'e', 'i' , 'o', 'u'} # set
print(fruits) # =>['apple', 'mango', 'orange']
print(numbers) # =>(1, 2, 3)
print(alphabets) # =>{'a': 'apple', 'b': 'ball', 'c': 'cat'}
print(vowels) # =>{'e', 'a', 'o', 'i', 'u'}
sample_set = set("Python data types")
type(sample_set) # =><class 'set'>
sample_set # =>{'e', 'y', 't', 'o', ' ', 'd', 's', 'P', 'p', 'n', 'h', 'a'}
another_set = {'red', 'green', 'black'}
type(another_set) # =><class 'set'>
another_set # =>{'red', 'green', 'black'}
# Set与字典的键类似，集合的元素必须是不变的
invalid_set = {[1], 1} # => Raises a TypeError: unhashable type: 'list'
valid_set = {(1,), 1}
{1, 2, 3, 4, 5} & {3, 4, 5, 6} # => {3, 4, 5}
{1, 2, 3, 4, 5} | {3, 4, 5, 6} # => {1, 2, 3, 4, 5, 6}
{1, 2, 3, 4} - {2, 3, 5} # => {1, 4}
{1, 2, 3, 4} ^ {2, 3, 5} # => {1, 4, 5}
{1, 2} >= {1, 2, 3} # => False
{1, 2} <= {1, 2, 3} # => True
# 可以构造集合和字典推导
{x for x in 'abcddeef' if x not in 'abc'} # => {'d', 'e', 'f'}
{x: x**2 for x in range(5)} # => {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
A = {'Peter', 'Raymond', 'Egon'}
B = {'Winston', 'Peter', 'Raymond'}
C = {'Janine','Raymond', 'Egon'}
# 求并集
# 生成新集合
# print(A | B)
# print(A.union(C))
# 更新集合
# A |= B
# A.update(B)
# print(A)
# 求交集
# print(A & B)
# A.intersection(B)
# A &= B
# A.intersection_update(B)
# print(A)
# 求差集
# print(A - B)
# A.difference(B)
# print(A.difference(B))
#
# A -= B
A.difference_update(B)
print(A)
'''
每个操作都有两个版本：一个返回一个新集合，另一个更新现有的集合，
调用每种操作有两种方式：按方法和按运算符。
注意语法不是使用set运算方法和运算符的唯一区别。更重要的是，set运算符要求将两个参数都设置为set，而该方法仅要求第一个参数为set，而第二个参数可以是任何可迭代的对象，例如列表或字符串。在这种情况下，该方法将隐式地从第二个参数中创建一个集合
'''
set.method(*list_of_sets)
# sets are within a container
languages = [{'c', 'c++', 'python'}, {'python', 'javascript'}, {'python', 'java'}]
the_best = set.intersection(*languages)
print(the_best)
# The output is {'python'}

Class

要创建一个类，我们需要使用Python的class关键字，后跟该类的名称。在Python中，惯例表示类名应首字母大写。类有一个称为__init__的特殊方法（用于初始化）。每当您基于此类创建（或实例化）对象时，都会调用此方法。该__init__方法仅被调用一次，而不会在程序中再次被调用。__init__的另一个术语是构造函数，尽管该术语在Python中使用不多。

您可能想知道为什么我总是说方法而不是函数。当函数在类中时，其名称会更改为“ method”。您还将注意到，每个方法都必须至少具有一个参数（即self），而对于常规函数而言，情况并非如此。

多重继承可以将类的方法解析顺序（MRO）视为__mro__属性或mro()方法。前者返回一个元组，而后者返回一个列表

# Python 3.x syntax
class Vehicle:
    """docstring"""

    def __init__(self):
        """Constructor"""
        pass

Looping循环

循环顾名思义，它一次又一次地重复着事，直到满足某个条件

Python仅限于两个循环“While循环”和“for循环”
Python中的for循环用于迭代序列（list，tuple，string）或其他可迭代对象。在序列上进行迭代称为遍历。
我们可以在for循环中使用range（）函数来迭代数字序列。它可以与len()函数结合使用索引来遍历序列

# Program to iterate through a list using indexing
genre = ['pop', 'rock', 'jazz']
# iterate over the list using index
for i in range(len(genre)):

print("I like", genre[i])

while循环是根据条件语句是true还是false执行的
For循环称为迭代器，它根据条件集迭代元素
Python For循环也可以用于一组各种其他东西（指定我们想要循环的元素集合）

break在For循环中用于在任何特定点断开或终止程序
如果break语句在嵌套循环（另一个循环内的循环）内，则break将终止最里面的循环

continue语句将继续打印语句，并根据条件设置打印出结果
Continue语句仅在当前迭代时用于跳过循环内的其余代码。循环不会终止，但会继续进行下一个迭代

for循环也可以具有可选的else块。如果用于循环的序列中的项目用尽，则执行else部分。

break关键字可用于停止for循环。在这种情况下，其他部分将被忽略。

因此，如果没有中断发生，则for循环的else部分将运行。

# program to display student's marks from record
student_name = 'Soyuj'

marks = {'James': 90, 'Jules': 55, 'Arthur': 77}

for student in marks:
    if student == student_name:
        print(marks[student])
        break
else:
    print('No entry with that name found.')

for循环中的枚举函数返回我们正在查看的索引号的集合成员

while循环

#Example file for working with loops
#
def main():
    x=0
    #define a while loop
    while(x <4):
        print(x)
        x = x+1

if __name__ == "__main__":
    main()

for循环

#Example file for working with loops
def main():
    x=0
    #Define a for loop 
    for x in range(2,7):
        print(x)
if __name__ == "__main__":
    main()

def main():
 #use a for loop over a collection
 Months = ["Jan","Feb","Mar","April","May","June"]
 for m in Months:
     print(m)
  
if __name__ == "__main__":
 main()

def main():
# use the break and continue statements
    for x in range (10,20):
        if (x == 15): break
 #if (x % 2 == 0) : continue
        print(x)

if __name__ == "__main__":
 main()

枚举

def main():     
    Months = ["Jan","Feb","Mar","April","May","June"]
    for i, m in enumerate (Months):
        print(i,m)
        
if __name__== "__main__":
  main()

Iteration 迭代

迭代可以通过'for'和'while'循环在python中执行。除了迭代特定条件之外，我们还可以迭代字符串，列表和元组


示例1：通过while循环对条件进行迭代
i = 1
while (i < 10): 
    i += 1
    print(i)

示例2：通过for循环对字符串进行迭代


s = "Hello World"
for i in s : 
    print(i)



示例3：通过列表上的for循环进行迭代

L = [1, 4, 5, 7, 8, 9] 
for i in L: 
    print(i)




示例4：针对范围的for循环的迭代

for i in range(0, 10): 
    print(i)

选择

Python中的选择使用两个关键字'if'和'elif'以及else（elseif）
Python中的条件语句由if语句处理

#
#Example file for working with conditional statement
#
def main():
 x,y =8,8
 
 if(x < y):
  st= "x is less than y"
 
 elif (x == y):
  st= "x is same as y"
 
 else:
  st="x is greater than y"
 print(st)
 
if __name__ == "__main__":
 main()

用最少的代码执行条件语句

A If B else C

def main():
 x,y = 10,8
 st = "x is less than y" if (x < y) else "x is greater than or equal to y"
 print(st)
 
if __name__ == "__main__":
 main()

嵌套if语句

total = 100
#country = "US"
country = "AU"
if country == "US":
    if total <= 50:
        print("Shipping Cost is  $50")
    elif total <= 100:
        print("Shipping Cost is $25")
    elif total <= 150:
     print("Shipping Costs $5")
    else:
        print("FREE")
if country == "AU": 
    if total <= 50:
        print("Shipping Cost is  $100")
    else:
 print("FREE")

switch语句是一个多路分支语句，用于将变量的值与case语句中指定的值进行比较。Python语言没有switch语句。Python使用字典映射在Python中实现switch语句

def SwitchExample(argument):
    switcher = {
        0: " This is Case Zero ",
        1: " This is Case One ",
        2: " This is Case Two ",
    }
    return switcher.get(argument, "nothing")


if __name__ == "__main__":
    argument = 1
    print (SwitchExample(argument))

Python运算符

算术运算符(+，-，*，/，//，%，**)

执行各种算术运算

比较运算符(>，<，==，!=，>=，<=)

使我们能够确定两个值是否相等或一个值是否大于另一个值，然后根据结果进行决策

赋值运算符(=)

复合运算(+=，-=，*=，/=，%=，**=，&=，|=，^=，>>=，<<=)

逻辑运算符(and，or，not)

此类操作的结果为true或false（即布尔值）

按位运算符($，|，~，^，>>，<<)

处理整数值的各个位，他们将它们视为二进制位序列

高级Python运算符，例如身份运算符或成员资格运算符

定义以自己的特定方式使用 Python 的标准运算符符号的对象

https://docs.python.org/3/reference/datamodel.html#special-method-names

class Thing:

def __init__(self, value):

self.__value = value

def __gt__(self, other):

return self.__value > other.__value

def __lt__(self, other):

return self.__value < other.__value

something = Thing(100)

nothing = Thing(0)

# True

print(something > nothing)

# False

print(something < nothing)

# Error

print(something + nothing)

身份运算符

这些运算符使我们能够比较两个Python对象/变量的内存位置。它们可以让我们找到对象是否共享相同的内存地址。保持相等值的变量不一定相同。
另外，我们可以使用这些运算符来确定一个值是特定的类还是类型。

Python中使用的两个身份运算符是（is，is not）

# Using 'is' identity operator Output: True
a = 7
if (type(a) is int):
print("true")
else:
print("false")
# Using 'is not' identity operator Output: True
b = 7.5
if (type(b) is not int):
print("true")
else:
print("false")
x1 = 5
y1 = 5
x2 = 'Hello!'
y2 = 'Hello!'
x3 = [1,2,3]
y3 = [1,2,3]
# Output: False
print(x1 is not y1)
# Output: True
print(x2 is y2)
# Output: False
print(x3 is y3)
'''
在shell中不相等
>>> x2 = 'Hello!'
>>> y2 = 'Hello!'
>>> x2 is y2
False
'''

成员资格运算符

成员资格运算符使我们能够测试值是否为其他Python对象（例如字符串，列表或元组）的成员。在C语言中，成员资格测试要求遍历序列并检查每个值。但是与C相比，Python使建立成员资格变得非常容易。另外，请注意，此运算符还可以针对字典进行测试，但只能针对键而不是值进行测试。

它们用于测试在序列（字符串，列表，元组，集合和字典）中是否找到值或变量。
在字典中，我们只能测试键的存在，而不是值

Python中使用了两个成员运算符（in，not in）

空字符串被视为任何字符串的子字符串

# Using Membership operator
str = 'Python operators'
dict = {6:'June',12:'Dec'}
 
print('P' in str) 
print('Python' in str)
print('python' not in str)
print(6 in dict) 
print('Dec' in dict)
 
 
x = 'Hello world'
y = {1:'a',2:'b'}
 
# Output: True
print('H' in x)
 
# Output: True
print('hello' not in x)
 
# Output: True
print(1 in y)
 
# Output: False
print('a' in y)
 

函数

函数是一个代码块，以Python关键字def开头，后跟函数的实际名称。函数可以接受零个或多个参数，关键字参数或两者的混合。函数总是返回一些东西。如果您未指定函数应返回的内容，则它将返回None

在类中就是方法

https://www.programiz.com/python-programming/methods/built-in
https://docs.python.org/3/library/functions.html

def function_name(parameters):
"""docstring"""
statement(s)

#如果您在与当前脚本相同的文件夹中有一个名为math.py的Python脚本，则将加载文件math.py 而不是内置的Python模块。之所以会这样，是因为本地文件夹的优先级高于Python的内置库。

import math

＃dir()可以找出在模块中定义了哪些功能和属性

dir(math)

Python中的函数是一段可重用的代码，用于执行单个相关操作。
def语句定义的函数
每个函数中的代码块以冒号（:)开头，并且应缩进（四个空格）
任何参数或输入参数都应放在这些括号内
在声明函数之后，应该在代码之前留下至少一个缩进
在def函数中的整个代码中应该保持相同的缩进样式
可选的文档字符串（docstring），用于描述函数的功能可以使用“return”命令将值返回给函数调用
该语句可以包含被求值并返回值的表达式。如果语句中没有表达式，或者return语句本身不存在于函数内，则该函数将返回None对象

当参数未提供给调用函数时，Python将打印一个随机值，如（0x021B2D30）

函数视为一堆代码，用于在整个Python脚本中执行特定任务。Python使用关键字'def'来定义函数。不需要在python中显式指定函数的返回类型。可以通过函数名称跟在括号中参数列表来调用该函数

函数体中的第一个语句通常是一个"""字符串"""，访问字符串可以使用function_name .__ doc__访问

该语句称为Docstring

无返回函数return，调用print将返回特殊值None

您还可以使用特殊语法将函数设置为接受任意数量的参数或关键字参数。要获取无限参数，请使用* args；对于无限关键字参数，请使用** kwargs。 “ args”和“ kwargs”两个词并不重要。那只是约定。您可以将它们称为* bill和** ted，它的工作方式相同。此处的关键是星号的数量。

>>> def many(*args, **kwargs):
        print(args)
        print(kwargs)

>>> many(1, 2, 3, name="Mike", job="programmer")
(1, 2, 3)
{'job': 'programmer', 'name': 'Mike'}

首先，我们使用新语法创建函数，然后使用三个常规参数和两个关键字参数进行调用。函数本身将打印出两种类型的参数。如您所见，args参数变成一个元组，kwargs变成一个字典

有时，我们并不预先知道将传递给函数的参数数量。Python允许我们通过带有任意数量参数的函数调用来处理这种情况。

def varargs(*args):
    return args
varargs(1, 2, 3)  # => (1, 2, 3)

def keyword_args(**kwargs):
    return kwargs
keyword_args(big="foot", loch="ness")  # => {'big': 'foot', 'loch': 'ness'}

def all_the_args(*args, **kwargs):
    print(args)
    print(kwargs)
"""
all_the_args(1, 2, a=3, b=4) prints:
    (1, 2)
    {'a': 3, 'b': 4}

"""
在函数定义中，我们在参数名称前使用星号（*）表示此类参数
def greet(*names):
   """This function greets all
   the person in the names tuple."""

   # names is a tuple with arguments
   for name in names:
       print("Hello",name)


greet("Monica","Luke","Steve","John")

https://docs.python.org/3/tutorial/controlflow.html#keyword-arguments

字典对象前面的双星号允许您将该字典的内容作为命名参数传递给函数

字典的键是参数名称，值是传递给函数的值

dictionary = {"a": 1, "b": 2}

def someFunction(a, b):

print(a + b)

return

# these do the same thing:

someFunction(**dictionary)

someFunction(a=1, b=2)

input()函数

返回作为用户输入给出的字符串，没有尾随换行符。

当input()语句被执行时，程序会暂停，直到用户提供输入并按下回车键。

input([prompt])--prompt提示是我们希望在屏幕上显示的字符串，它是可选的

>>> num = input('Enter a number: ')
Enter a number: 10
>>> num

'10'

print()函数

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
objects是要打印的值
sep 默认为空格字符
end默认为新行（\n），不换行的话是end=''
The file默认值为sys.stdout（屏幕）

print(1, 2, 3, 4) #1 2 3 4
print(1, 2, 3, 4, sep='*') #1 * 2 * 3 * 4
print(1, 2, 3, 4, sep='#', end='&') #1＃2＃3＃4＆

print(125 + 125) # "250"
print("125" + "125") # "125125"
print(125 * 4) # "500"
print("125" * 4) # "125125125125"
print("This is a number:", 125) # "This is a number: 125"
该示例还显示，如果在括号中用逗号分隔它们，则可以打印不同类型的值，并用空格分隔。
+ 连接字符串之间没有空格

，连接字符串之间有空格

在Python 2中，“print”语句不是函数，因此可以在没有括号的情况下调用。但是，在Python 3中，它是一个函数，必须用括号调用

#关键字参数“sep”分配任意字符串
print(192,168,178,42,sep=".")

#关键字参数“end”分配任意字符串，一行输出

for i in range(10):

print(i,end="")

# 输出存在data.txt中，不打印出来

with open("data.txt","w") as fh:

print("422 is the answer, but what is the question?", file=fh)

import sys
with open('output.txt','w') as f:
sys.stdout = f
print("first: Hello Python!")
print("first: We are printing to file.")

print("second: Hello Python!", file=open('output.txt','a'))
print("second: We are printing to file.", file=open('output.txt','a'))

import sys

print("Normal: 0", file=sys.stdout)

# output 字体为红颜色

print("Error: 1", file=sys.stderr)

Python 默认print函数尝试打印出任何大的嵌套对象，结果相当难看。
这是标准库的漂亮打印模块pprint介入的地方。它以易于阅读的格式打印出复杂的结构化对象。

https://docs.python.org/3/library/pprint.html

import requests

import pprint

url = 'https://randomuser.me/api/?results=1'
users = requests.get(url).json()

pprint.pprint(users)

lambda函数

也称为匿名函数，不需要名称（即标识符）
在Python中，匿名函数是没有名称定义的函数。虽然通常的功能是使用def关键字定义的，但在Python中，匿名函数是使用lambda关键字定义的。因此，匿名函数也称为lambda函数

lambda arguments: expression
lambda本身返回一个函数对象

lambda函数可以采取任何数目的由逗号分隔的参数，但它必须由一个的单个表达式。计算该表达式并返回结果。请注意，您在这里不需要return语句

调用lambda函数

Python语法允许我们通过将函数括在括号中并立即传递参数来做到这一点
(lambda x, y: (x + y) % 2)(1, 5)
# The output is 0

lambda可以有任意数量的参数（parameter），可以是由逗号分隔的参数列表组成；在其函数体中只能有1个表达式,表达式（expression）是使用这些参数的算术表达式，默认情况下返回该表达式，lambda函数不包含return语句

python中lambda和常规函数之间的区别
Lambda函数只能在其体内有一个表达式。
常规函数可以在其正文中包含多个表达式和语句。

Lambda没有与之关联的名称。这就是为什么它们也被称为匿名函数。
常规函数必须具有名称和签名。

Lambda不包含return语句，因为主体是自动返回的。
需要返回值的函数应包含return语句

adder = lambda x, y: x + y
print (adder (1, 2))
#What a lambda returns
string='some kind of a useless lambda'
print(lambda string : print(string))
#What a lambda returns #2
x="some kind of a useless lambda"
(lambda x : print(x))(x)
#A REGULAR FUNCTION
def guru( funct, *args ):
funct( *args )
def printer_one( arg ):
return print (arg)
def printer_two( arg ):
print(arg)
#CALL A REGULAR FUNCTION
guru( printer_one, 'printer 1 REGULAR CALL' )
guru( printer_two, 'printer 2 REGULAR CALL \n' )
#CALL A REGULAR FUNCTION THRU A LAMBDA
guru(lambda: printer_one('printer 1 LAMBDA CALL'))
guru(lambda: printer_two('printer 2 LAMBDA CALL'))

不要在生产环境中编写复杂的lambda函数，因为代码维护起来很难
如果你发现自己制作复杂的单行表达式，那么定义一个合适的函数将是一个非常优越的实践

import tkinter as tk
class App:
""""""
def __init__(self, parent):
"""Constructor"""
frame = tk.Frame(parent)
frame.pack()
btn22 = tk.Button(frame, text="22", command=lambda: self.printNum(22))
btn22.pack(side=tk.LEFT)
btn44 = tk.Button(frame, text="44", command=lambda: self.printNum(44))
btn44.pack(side=tk.LEFT)
quitBtn = tk.Button(frame, text="QUIT", fg="red", command=frame.quit)
quitBtn.pack(side=tk.LEFT)
def printNum(self, num):
""""""
print("You pressed the %s button" % num)
if __name__ == "__main__":
root = tk.Tk()
app = App(root)
root.mainloop()

range()函数

我们可以使用range()函数生成数字序列。range(10)会产生0到9之间的数字（10个数字）。
我们还可以将开始，停止和步长定义为range(start,stop,step size)。如果未提供，则步长默认为1。
此函数未将所有值存储在内存中，因此效率低下。因此它会记住开始，停止，步长并在旅途中生成下一个数字。
要强制此函数输出所有项目，可以使用函数list()

# Output: range(0, 10)
print(range(10))

# Output: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list(range(10)))

# Output: [2, 3, 4, 5, 6, 7]
print(list(range(2, 8)))

# Output: [2, 5, 8, 11, 14, 17]
print(list(range(2, 20, 3)))

main()函数

if __name__ == "__main__"

编写私有化部分，这句代码以上的部分，可以被其它的调用，以下的部分只有这个文件自己可以看见，如果文件被调用了，其他人是无法看见私有化部分的

print("Hello") print("__name__ value: ", __name__) def main(): print("python main function") if __name__ == '__main__': main()

# Hello

# __name__ value: __main__

# python main function

# file one.py
def func():
print("func() in one.py")
print("top-level in one.py")
if __name__ == "__main__":
print("one.py is being run directly")
else:
print("one.py is being imported into another module")
# file two.py
import one
print("top-level in two.py")
func()
if __name__ == "__main__":
print("two.py is being run directly")
else:
print("two.py is being imported into another module")

# Python program to illustrate
# math module
import math
def Main():
num = float(input("Enter a number: "))
# fabs is used to get the absolute value of a decimal
num = math.fabs(num)
print(num)
if __name__=="__main__":
Main()

Python中的递增和递减运算符

# A Sample Python program to show loop (unlike many
# other languages, it doesn't use ++)
for i in range(0, 5):
print(i)

break，continue，pass, else
break - 将你带出当前的循环。
continue - 结束循环中的当前迭代并移至下一次迭代。
pass - pass语句什么都不做。它可以在需要声明时使用。语法上但该程序不需要任何操作。它通常用于创建最小类。
else - while循环为False,或者for循环遍历完后才运行

如何读取文件的内容。该技能非常有用，因为有时使用Python读取文件比直接打开文件更容易或更方便。同样，这些是可用的方法：

以下是 Python 中允许您读取和写入文件的一些函数：

read() ：该函数读取整个文件并返回一个字符串
readline() ：此函数从该文件中读取行并作为字符串返回。一次读取文件一行，如果第 n 次被调用，它将获取第 n 行。

readlines() ：此函数返回一个列表，其中每个元素都是该文件的一行。读取文件为行列表

但是，最好的方法是使用for循环遍历文件的各行

write() ：此函数将固定的字符序列写入文件。
writelines() ：此函数写入字符串列表。
append() ：此函数将字符串附加到文件而不是覆盖文件。

filter函数用于从元素序列中选择一些特定元素。它接受一个返回True或False的函数并将其应用于序列，返回仅包含函数返回True的序列成员的列表
filter(function or None, iterable) --> filter object
filter(function, sequence) 需要2个参数：一个定义过滤约束的函数；一个序列（任何迭代器，如列表，元组等）

Filter: filter (lambda parameter: expression, iterable-sequence)

sequences = [10,2,8,7,5,4,3,11,0, 1]
filtered_result = filter (lambda x: x > 4, sequences) 
print(list(filtered_result))

map函数用于将特定操作应用于序列中的每个元素并返回一个迭代器。如果有多个参数，map（）将返回一个包含元组的列表，这些元组包含来自所有迭代的相应项
map(func, *iterables) --> map object

r = map（func，seq）
1、定义要对元素执行的操作的函数func
2、一个或多个序列seq

Map: map (lambda parameter: expression, iterable-sequences)

sequences = [10,2,8,7,5,4,3,11,0, 1]
filtered_result = map (lambda x: x*x, sequences) 
print(list(filtered_result))

x = [1, 2, 3]

y = map(lambda x : x + 1 , x)

# prints out [2,3,4]

print(list(y))

reduce函数对序列的前2个元素执行定义的操作，保存此结果，使用保存的结果和序列中的下一个元素执行操作，重复直到不再剩下任何元素

reduce(function, sequence[, initial]) -> value

#这是一个返回列表中所有元素的乘积的程序

reduce (lambda parameter1, parameter2: expression, iterable-sequence)

import functools
#由于该reduce方法已从Python3的内置函数中删除，因此请不要忘记functools在代码中导入
#定义一个名为sequence的列表
sequences = [1,2,3,4,5]
#我们声明一个名为product的变量，它将存储减少的值
#在列表的每个元素上运行的lambda函数。它将按照之前的结果返回该数字的乘积。
product = functools.reduce(lambda x, y: x*y, sequences)
print(product)
my_strings = ['a', 'b', 'c', 'd', 'e']
my_numbers = [1,2,3,4,5]
results = list(zip(my_strings, my_numbers))
print(results)
>>> [('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)]
results = list(map(lambda x, y: (x, y), my_strings, my_numbers))
print(results)
>>> [('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)]
scores = [66, 90, 68, 59, 76, 60, 88, 74, 81, 65]
def is_A_student(score):
return score > 75
over_75 = list(filter(is_A_student, scores))
print(over_75)
>>> [90, 76, 88, 81]
over_75 = list(filter(lambda x: int(x) > 75, scores))
print(over_75)
>>> [90, 76, 88, 81]
dromes = ("demigod", "rewire", "madam", "freer", "anutforajaroftuna", "kiosk")
palindromes = list(filter(lambda word: word == word[::-1], dromes))
print(palindromes)
>>> ['madam', 'anutforajaroftuna']
from functools import reduce
numbers = [3, 4, 6, 9, 34, 12]
def custom_sum(first, second):
return first + second
result = reduce(custom_sum, numbers)
print(result)
>>> 68
result = reduce(lambda x, y: x+y, numbers)
print(result)
>>> 68
circle_areas = [3.56773, 5.57668, 4.00914, 56.24241, 9.01344, 32.00013]
result = list(map(round, circle_areas, range(1,5)))
print(result)
>>> [3.6, 5.58, 4.009, 56.2424]
from functools import reduce
my_floats = [4.35, 6.09, 3.25, 9.77, 2.16, 8.88, 4.59]
my_names = ["olumide", "akinremi", "josiah", "temidayo", "omoseun"]
my_numbers = [4, 6, 9, 23, 5]
map_result = list(map(lambda x: x, my_floats))
print(map_result)
>>> [4.35, 6.09, 3.25, 9.77, 2.16, 8.88, 4.59]
filter_result = list(filter(lambda name: len(name) < 8, my_names))
print(filter_result)
>>> ['olumide', 'josiah', 'omoseun']
reduce_result = reduce(lambda num1, num2: num1 * num2, my_numbers)
print(reduce_result)
>>> 24840

List Comprehension列表推导

[表达式 for 变量 in 列表] 或者 [表达式 for 变量 in 列表 if 条件]

是一种在Python中定义和创建列表的优雅方式

[(x,y,z) for x in range(1,30) for y in range(x,30) for z in range(y,30) if x**2 + y**2 == z**2]

numbers = [1,2,3,4,5,6,7]

evens = [x for x in numbers if x % 2 is 0]

odds = [y for y in numbers if y not in evens]

cities = ['London', 'Dublin', 'Oslo']

def visit(city):

print("Welcome to "+city)

for city in cities:

visit(city)

# Declare a list
x = [2, 3, 4, 5, 6]

# Perform the same operation as in above post

print(list(map(lambda i:i*5,filter(lambda j:j%2,x))))

解包
解包是Python的另一个很棒的特性。可以分别使用*和**将列表或字典解压缩为函数参数

def point(x, y):
print(x,y)
foo_list = (3, 4)
bar_dict = {'y': 3, 'x': 2}
point(*foo_list) # Unpacking Lists 解包列表
point(**bar_dict) # Unpacking Dictionaries 解包字典

枚举

想在for循环中找到索引吗？使用enumerate换行迭代，它将生成项目及其索引

# Know the index faster
vowels=['a','e','i','o','u']
for i, letter in enumerate(vowels):
print (i, letter)

链式比较运算符

可以在Python中链式比较运算符answer = 1 <x <10在Python中是可执行的

Python文件处理：创建，打开，追加，读取，写入

如果您需要获取默认字符编码，请导入locale模块并调用locale.getpreferredencoding(). 在我的 Windows 笔记本电脑上，它返回'cp1252'，但在我楼上的 Linux 机器上，它返回'UTF8'。

# Writing to a file
contents = {"aa": 12, "bb": 21}
with open("myfile1.txt", "w+") as file:
file.write(str(contents)) # writes a string to a file
import json
with open("myfile2.txt", "w+") as file:
file.write(json.dumps(contents)) # writes an object to a file
# Reading from a file
with open('myfile1.txt', "r+") as file:
contents = file.read() # reads a string from a file
print(contents)
# print: {'aa': 12, 'bb': 21}
with open('myfile2.txt', "r+") as file:
contents = json.load(file) # reads a json object from a file
print(contents)
# print: {'aa': 12, 'bb': 21}

Python允许您读取，写入和删除文件

使用open（“filename”，“w +”）函数创建文件。如果文件不存在，+告诉python编译器创建一个文件

要将数据附加到现有文件，请使用命令open（“Filename”，“ a ”）

使用read函数读取文件的整个内容

使用readlines函数逐个读取文件的内容。

def main():
f= open("guru99.txt","w+")
#f=open("guru99.txt","a+")
for i in range(10):
f.write("This is line %d\r\n" % (i+1))
f.close()
#Open the file back and read the contents
#f=open("guru99.txt", "r")
#if f.mode == 'r':
# contents =f.read()
# print (contents)
#or, readlines reads the individual line into a list
#fl =f.readlines()
#for x in fl:
#print(x)
if __name__== "__main__":
main()

Python复制文件方法

person1 = ["Swen", ["Seestrasse", "Konstanz"]]

#深拷贝(deepcopy)： copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象。

from copy import deepcopy

person2 = deepcopy(person1)

person2[0] = "Sarah"

person2[1][0] = "Bücklestrasse"

print(person1, person2)

# ['Swen', ['Seestrasse', 'Konstanz']] ['Sarah', ['Bücklestrasse', 'Konstanz']]

# 浅拷贝(copy)：拷贝父对象，不会拷贝对象的内部的子对象。

person3 = person1.copy()

person3[0] = "Sarah"

person3[1][0] = "Bücklestrasse"

print(person1, person3)

# ['Swen', ['Bücklestrasse', 'Konstanz']] ['Sarah', ['Bücklestrasse', 'Konstanz']]

以下命令用于复制文件

shutil.copy（SRC，DST）

以下命令用于使用元数据信息复制文件
shutil.copystat（SRC，DST）

import os
import shutil
from os import path
def main():
# make a duplicate of an existing file
if path.exists("1.xlsx"):
# get the path to the file in the current directory
src = path.realpath("1.xlsx")
#seperate the path from the filter
head, tail = path.split(src)
print("path:" +head)
print("file:" +tail)
#let's make a backup copy by appending "bak" to the name
dst = src+".bak"
# nowuse the shell to make a copy of the file
# shutil.copy(src, dst)
#copy over the permissions,modification
shutil.copystat(src,dst)
if __name__=="__main__":
main()

您可以获取有关上次修改的文本文件的信息

import os
from os import path
import datetime
from datetime import date, time, timedelta
import time
def main():
# Get the modification time
t = time.ctime(path.getmtime("1.xlsx.bak"))
print(t)
print(datetime.datetime.fromtimestamp(path.getmtime("1.xlsx.bak")))
if __name__ == "__main__":
main()

https://www.techbeamers.com/python-copy-file/

import shutil
import os
source = "/home/career_karma/data"
destination = "/home/career_karma/old_data"
files = os.listdir(source)
for file in files:
new_path = shutil.move(f"{source}/{file}", destination)
print(new_path)
# -----------------------------
import os
import shutil
path = r'C:\1111'
print("Before moving file:")
print(os.listdir(path))
# Source path
source = r'C:\1111\444'
# Destination path
destination = r'C:\1111\1'
dest = shutil.move(source, destination)
# 如果源是目录， copytree()则会调用
# dest = shutil.move(source, destination, copy_function = shutil.copytree)
print("After moving file:")
print(os.listdir(path))
print("Destination path:", dest)
# 拷贝源文件夹中所有文件或文件夹到源文件夹中
from distutils.dir_util import copy_tree
# copy subdirectory example
fromDirectory = r"C:/111"
toDirectory = r"C:/222"
copy_tree(fromDirectory, toDirectory)

Python创建zip / tar存档

要压缩整个目录，请使用命令shutil.make_archive("name","zip", root_dir)

要选择要压缩的文件，请使用命令ZipFile.write(filename)

import os
import shutil
from zipfile import ZipFile
from os import path
from shutil import make_archive
# Check if file exists
if path.exists("123.txt"):
# get the path to the file in the current directory
src = path.realpath("123.txt");
# rename the original file
os.rename("career.123.txt","123.txt")
# now put things into a ZIP archive
root_dir,tail = path.split(src)
shutil.make_archive("123 archive","zip",root_dir)
# more fine-grained control over ZIP files
with ZipFile("test123.zip", "w") as newzip:
newzip.write("123.txt")
newzip.write("123.txt.bak")

要压缩整个目录，请使用命令shutil.make_archive("name","zip", root_dir)

要选择要压缩的文件，请使用命令ZipFile.write(filename)

pickle

Python中序列化过程的名称。通过pickle，我们可以将对象层次结构转换为可存储的二进制格式(通常人类可读)。要pickle一个对象，只需导入pickle模块并调用dumps()函数，该函数将被pickle的对象作为参数传递。并非每个对象都是可picklable的。无法对某些对象（例如数据库连接，打开的文件的句柄等）进行pickle

https://python3cookbook.readthedocs.io/zh_CN/latest/c05/p21_serializing_python_objects.html

https://www.thepythoncorner.com/2016/12/object-serialization-in-python/

https://morvanzhou.github.io/tutorials/python-basic/basic/13-08-pickle/

dump(object, file)
dumps(object) -> string
load(file) -> object
loads(string) -> object
>>> import pickle
>>> f = open('somedata', 'wb')
>>> pickle.dump([1, 2, 3, 4], f)
>>> pickle.dump('hello', f)
>>> pickle.dump({'Apple', 'Pear', 'Banana'}, f)
>>> f.close()
>>> f = open('somedata', 'rb')
>>> pickle.load(f)
[1, 2, 3, 4]
>>> pickle.load(f)
'hello'
>>> pickle.load(f)
{'Apple', 'Pear', 'Banana'}
--------------------------------------------------------------
import pickle
data = {'da': 111, 2: [23,1,4], '23': {1:2,'d':'sad'}}
# pickle a variable to a file
f = open('somefile.bin', 'wb')
pickle.dump(data, f)
f.close()
# reload a file to a variable
with open('somefile.bin', 'rb') as f:
data = pickle.load(f)
print(data)
------------------------
import pickle
class Animal:
def __init__(self, number_of_paws, color):
self.number_of_paws = number_of_paws
self.color = color
class Sheep(Animal):
def __init__(self, color):
Animal.__init__(self, 4, color)
# Step 1: Let's create the sheep Mary
mary = Sheep("white")
print(str.format("My sheep mary is {0} and has {1} paws", mary.color, mary.number_of_paws))
# Step 2: Let's pickle Mary
my_pickled_mary = pickle.dumps(mary)
print ("Would you like to see her pickled? Here she is!")
print (my_pickled_mary)
# Step 3: Now, let's unpickle our sheep Mary creating another instance, another sheep... Dolly!
dolly = pickle.loads(my_pickled_mary)
# Dolly and Mary are two different objects, in fact if we specify another color for dolly
# there are no conseguencies for Mary
dolly.color = "black"
print (str.format("Dolly is {0} ", dolly.color))
print (f'Mary is {mary.color}')
---------------------------------------------------------
# 异步生成器
import asyncio
async def ticker(delay, to):
"""Yield numbers from 0 to *to* every *delay* seconds."""
for i in range(to):
yield i
await asyncio.sleep(delay)
async def main():
mylist = []
async for x in ticker(1,10):
print(x)
mylist.append(x)
# mylist = [x async for x in ticker(1,10)]
print (mylist)
if __name__ == "__main__":
loop = asyncio.get_event_loop()
loop.run_until_complete(main())

logging

https://python101.pythonlibrary.org/chapter25_decorators.html

import logging
def log(func):
"""
Log what function is called
"""
def wrap_log(*args, **kwargs):
name = func.__name__
logger = logging.getLogger(name)
logger.setLevel(logging.INFO)
# add file handler
fh = logging.FileHandler("%s.log" % name)
fmt = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
formatter = logging.Formatter(fmt)
fh.setFormatter(formatter)
logger.addHandler(fh)
logger.info("Running function: %s" % name)
result = func(*args, **kwargs)
logger.info("Result: %s" % result)
return func
return wrap_log
@log
def double_function(a):
"""
Double the input parameter
"""
return a*2
if __name__ == "__main__":
value = double_function(2)

random模块

>>>import random
random.random()：生成一个介于0.0到1.0之间的随机浮点数，该函数不需要任何参数
>>> random.random()
0.8085615496267344
random.randint()：返回指定整数之间的随机整数。
>>> random.randint(1, 100)
87
>>> random.randint(1, 100)
56
random.randrange()：从start，stop和step参数创建的范围中返回一个随机选择的元素。缺省情况下，start的值为0。同样，step的值默认为1
>>>random.randrange(1, 10)
2
>>>random.randrange(1, 10, 2)
5
>>>random.randrange(0, 101, 10)
80
random.choice()：从非空序列返回随机选择的元素。空序列作为参数会引发IndexError
>>>random.choice('computer')
't'
>>>random.choice([12, 23, 45, 67, 65, 43])
45
>>>random.choice((12, 23, 45, 67, 65, 43))
67
random.shuffle()：此函数对列表中的元素进行随机重新排序。
>>>numbers=[12, 23, 45, 67, 65, 43]
>>>random.shuffle(numbers)
>>>numbers
[23, 12, 43, 65, 67, 45]
>>>random.shuffle(numbers)
>>>numbers
[23, 43, 65, 45, 12, 67]

查找哈希的源代码

# Python rogram to find the SHA-1 message digest of a file
# importing the hashlib module
import hashlib
def hash_file(filename):
""""This function returns the SHA-1 hash
of the file passed into it"""
# make a hash object
h = hashlib.sha1()
# open file for reading in binary mode
with open(filename,'rb') as file:
# loop till the end of the file
chunk = 0
while chunk != b'':
# read only 1024 bytes at a time
chunk = file.read(1024)
h.update(chunk)
# return the hex representation of digest
return h.hexdigest()
message = hash_file("track1.mp3")
print(message)

Time

# 时间比较
import time
n= 100000
start_time = time.time()
l = []
for i in range(n):
l = l + [i * 2]
print(time.time() - start_time)
start_time = time.time()
l = []
for i in range(n):
l += [i * 2]
print(time.time() - start_time)
start_time = time.time()
l = []
for i in range(n):
l.append(i * 2)
print(time.time() - start_time)
# 数字时钟
import time
while True:
localtime = time.localtime()
result = time.strftime("%I:%M:%S %p", localtime)
print(result, end="", flush=True)
print("\r", end="", flush=True)
time.sleep(1)

timestamp

# cookie: PHPSESSID=reo7db3r3e44l8rj78bnfs9765; _ga=GA1.3.882780060.1625415841; _gid=GA1.3.326836998.1625415841; _gat=1

from datetime import datetime
dt = datetime.today()  # Get timezone naive now
seconds = dt.timestamp()
print(int(seconds))


ts = int("1625415841")
# if you encounter a "year is out of range" error the timestamp
# may be in milliseconds, try `ts /= 1000` in that case
print(datetime.utcfromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S'))

unix 时间戳是什么？

https://www.unixtimestamp.com/zh/index.php
https://www.epochconverter.com/

unix 时间戳是以运行总秒数来跟踪时间的一种方法。这个计数从 1970 年 1 月 1 日 UTC 的 Unix Epoch 开始。因此，unix 时间戳只是特定日期和 Unix Epoch 之间的秒数。还应该指出（感谢本网站访问者的评论），无论你位于世界何处，这个时间点在技术上都不会改变。这对于计算机系统在线和客户端的动态和分布式应用程序中跟踪和分类过时的信息非常有用。cookie中的十位数字

socket

import socket
# working with a socket as a context manager
with socket.socket() as client_socket:
hostname = '127.0.0.1'
port = 9090
address = (hostname, port)
client_socket.connect(address)
data = 'Wake up, Neo'
data = data.encode()
client_socket.send(data)
response = client_socket.recv(1024)
response = response.decode()
print(response)

soloPython博客

python 知识点详解

命令行神器

但是报纸框架不适合实际工程新闻爬取，框架不稳定，爬取过程有各种bug，比如无法获取url、新闻信息，但是想获取一些新闻语料的朋友不妨一试，简单方便好用，不需要掌握太多爬虫知识。

从 python.org 下载 Python 最新版本

最有用的 Python 库？

inspect模块

sh

uuid

词汇表

__str__ 和 __repr__ 函数都返回对象的字符串表示。__str__ 字符串表示应该是人性化的，主要用于记录目的，而 __repr__ 表示应该包含有关对象的信息，以便可以再次构造它。

您永远不应该直接使用这些函数，而应始终使用 str() 和 repr() 函数。

__repr__

easy_install

pep8限制所有行最多79个字符

代码分析

密码生成

Python注释

Python缩进

异常

Python中的多行语句

python关键字

Generators 生成器

退出shell

Variables变量

Python数据类型

Booleans布尔值

Numbers数值

Bytes字节

数据类型之间的转换

Class

用最少的代码执行条件语句

身份运算符

成员资格运算符

lambda函数

range()函数

main()函数

Python文件处理：创建，打开，追加，读取，写入

Python复制文件方法

pickle

logging

查找哈希的源代码

Time

timestamp

unix 时间戳是什么？

socket

标签

评论

发表评论

此博客中的热门博文

自动发送消息

学习地址

mysql 入门

str 和 repr 函数都返回对象的字符串表示。str 字符串表示应该是人性化的，主要用于记录目的，而 repr 表示应该包含有关对象的信息，以便可以再次构造它。

repr