PythonBasics-中文系列教程-一-
PythonBasics 中文系列教程(一)
介绍
学习 python 的 7 个理由
为了完成多项任务,计算机需要了解我们。 或者至少是了解我们需要他们做什么。 出现了编程语言。
人类在不同的地方使用不同的语言,计算机在不同的任务上使用不同的语言。
在这种情况下,我们将讨论 Python。 它是由名为 Guido Van Rossum 的开发人员于 1991 年创建的。
如果您是第一次编程,那么 Python 是一个不错的选择。 开始使用后,您会发现 Python 友好且易于学习,具有大量的应用程序并且是开源的。
它具有多种编程示例和面向对象编程。
Python 被描述为一种解释型和动态编程语言,重点在于代码的可读性。 比 Java 或 C++ 具有更少的编码步骤。
知道这一点,这是学习 Python 的 7 个理由。
为什么学习 Python
数据科学 & 机器学习
数据是该主题的基础,无论您要进入哪个领域,它都将存在。 Python 是数据科学和机器学习的常用编程语言之一。 考虑到机器学习的发展,您应该尝试一下。
主要应用 & 更多
数据科学(包括机器学习,数据分析和数据可视化),Web 开发和脚本是 Python 的三个主要应用。 如果这还不够,那么软件开发公司中的应用程序已经多样化,例如游戏,框架和 Web 应用程序,语言开发,原型设计,图形设计应用程序等等。
扩展库 & 框架
Python 提供的库包括字符串操作,Internet,Web 服务工具,操作系统接口和协议等领域。 Python Package Index 包含超过 85,000 个要使用的模块和脚本。
开源
20 多年来,Python 一直是跨平台和开源的。 您可以在 Linux,Windows 和 Mac OS 上进行编码。
可以结合其他编程语言
CPython 与 C 编程语言一起使用,Jython 与 Java 集成,IronPython 与.NET 和 C# 兼容,PyObjc 是由 ObjectiveC 工具包编写的 Python,而 RubyPython 是与 Ruby 结合的版本。
提高产能
Python 使您可以用更少的代码来构建更多的功能,例如,您可以在两天内构建一个基本的游戏。
广泛的支持库和干净的面向对象设计将程序员的生产率提高了两到十倍。
它强大的过程集成功能,单元测试框架和增强的控制功能为应用程序的速度提高做出了贡献。
工作 & 职业
您作为程序员的职业可以与 Python 一起成长。
首先,Python 正成为主要的编程语言,因此使用 Python 是一种好处。
其次,从事数据科学,机器学习和网络开发的开发人员是收入最高的人员之一。
为什么 Python 很棒
Python 由 Guido van Rossum 创建并于 1991 年发布,现在是一种高级的通用编程语言。
它旨在通过利用大量的空白和简单性来强调代码的可读性,因为与 C++ 或 Java 之类的其他语言相比,它允许程序员使用更少的代码行来编写模型和概念。
这使 python 成为一种非常流行的编程语言,用于桌面独立应用程序或在线/ Web 应用程序以及小型或大型开发项目。
为什么使用 Python?
Python 可以用来做什么?
在最近几年中,随着 Web 应用程序开发过程的急剧发展,这就是使 Python 成为软件开发人员中领先的竞争者或选择的原因。 它几乎可以构建任何东西。
作为一种通用语言,Python 是开发几乎任何东西都可能需要的单一语言。
它可用于与用户进行交互的前端(客户端)和网站的后端(服务器端)数据库的编程。 它可以用于科学研究和研究的数值和数据分析。 它可以用于开发人工智能。 它可用于通过生产力工具,游戏和您可以考虑的其他类型的应用程序开发在线和离线应用程序。
简而言之,Python 是编程语言的万事通。 掌握它可能会使软件开发人员成为所有类型编程的专家。 它既有趣又易于使用。
初学者友好
Python 的主要设计宗旨是易于理解和愉快使用。 它的名字来自有趣的英国超现实喜剧团 Monty Python。
它具有许多可供参考的初学者教程,其令人愉悦的特性使其受到越来越多的人欢迎。
Python 使新手程序员能够迅速构建原型和工具,从而使他们立即感到满意。 由于易于使用,该语言正迅速成为初学者的入门语言。 很容易理解。
尽管 Python 是一种高级语言,但由于它易于理解,因此它是一种初学者友好的语言。 它不会给难以理解的机器等语言的人带来压力。 取而代之的是,它通过处理详细而又繁琐的语法和命令来像英语一样读起来,这使编程不那么吸引人。
您可以更深入地掌握编程的概念,而不会陷入学习语言的困境。 您会得到社区的支持。 如果您开始编程,那么您将不可避免地成为程序员社区的一部分,您将在编程项目中遇到的任何问题或疑虑都可以咨询并获得帮助。
社区
Python 社区是 stackoverflow,拥有大量聚会活动的最大社区之一,在那里,您不仅获得成功的支持,而且最重要的是,您还获得了终生可以拥有的朋友。 它提供了前景广阔的职业机会 Python 属于全球排名前五位的最受欢迎的编程语言,也是收入最高的编程语言。
职业
从事 python 的职业可以确保您在编程领域拥有巨大的就业机会和可赚钱的职业。 而且,由于该语言是灵活的,因此它还为您提供了要追求的编程领域的灵活性。 这些反映在越来越多的对学习 Python 感兴趣的人中。
学习 Python
入门
Python 是一种编程语言,语法简单易学。 Python 程序可以在所有台式计算机上运行。
它用于许多应用程序领域,包括:Web 和 Internet 开发,科学应用程序,桌面应用程序,教育和通用软件应用程序。
Python 解释器
要运行 Python 程序,您将需要 Python 解释器和可能的图形编辑器。Python 解释器执行 Python 代码(有时称为程序)。
一个程序可以是一个或多个 Python 文件。 代码文件可以包括其他文件或模块。 要运行程序,需要在执行 Python 时指定一个参数。
运行 Python 代码
您可以在此处下载 Python 解释器: https://www.python.org/downloads/ 一旦安装了 Python 解释器,请继续本教程。
要运行代码,请打开一个终端并启动:
python file.py
该站点包含有关 Python 编程语言的练习。 如果您不熟悉编程,请先运行 Python 代码。
Python IDE
IDE 是开发环境。 如果您不想在终端上工作,则可以使用 IDE。 这是一个图形编辑器,您可以在其中键入代码,使用多个文件,运行代码等。
在上面的 PyCharm IDE 中,您可以看到 1)文件菜单,2)代码,3)主菜单,4)行号,5)滚动条,6)文件和程序输出以及 7)其他信息。 大多数 IDE 具有这样的结构。
除非您是终端专家,否则 IDE 可以节省大量开发时间。 您可以快速处理多个文件,在项目之间切换以及在一个项目中与多个人一起工作。
一些流行的 Python IDE 是 PyCharm , PyDev 和 Wing IDE 。
执行 Python 脚本
在终端或 IDE 中执行 Python 脚本。 Python 文件具有.py
扩展名。 每当您制作 Python 脚本时,都将其另存为name.py
下面显示了一个简单程序(hello.py
)。 第一行表明我们要使用 Python 解释器。 第三行在屏幕上输出一行文本"hello world"
。
可以将以下文本复制到文本编辑器中,并另存为hello.py
。Python 使用以.py
结尾的文件。
#!/usr/bin/env python3
print('hello world')
您可以使用任何文本编辑器来创建 Python 程序。 我建议使用支持语法高亮显示(文本着色)和行号的文本编辑器。
运行 Python
从终端运行
您可以使用终端或命令行启动 Python 程序。 这适用于所有平台(Mac OS,Windows,Linux)。
要在 Windows 上打开终端:按 Windows 键+ R 键(运行程序),键入cmd
或command
,然后按Enter
键。
在 Mac OS 上,使用 finder 启动终端。 您可以按Command +
空格键并键入terminal
,然后按Enter
。
启动程序
要启动程序,我们必须打开命令行并键入:
python hello.py
为此,您需要位于正确的目录中。 也就是说,您的 python 程序所在的目录。
在 Mac OS 和 Linux 上,您可以使用命令pwd
查看当前目录。
如果使用 Windows,则目录显示在命令行标题栏中。
要更改目录,请使用cd
命令,例如cd /home/user/pythonprojects
或cd C:\Projects\
。
从 IDE 运行
要从 IDE 运行 Python 脚本,请先启动一个项目。 创建项目后,添加您的.py
文件(或在 IDE 中创建它们),然后按运行。
在 PyCharm IDE 中:
- 开始项目
- 欢迎屏幕打开,单击“创建新项目”。
- 在主菜单上,选择“文件 -> 其他 -> 新项目”。
- 选择 Python 解释器
- 从列表中选择 Python 版本,使用 3.x。
- 点击“创建”
- 添加新的 Python 文件(新文件)并添加
hello.py
- 单击绿色三角形以启动程序。 另一个选择是在 Python 文件上单击鼠标右键,然后选择“运行”。
其他 IDE 具有运行 Python 程序的类似过程(启动项目,添加文件,运行按钮)。
输出
您应该看到一行显示"hello world"
的文本。
练习
请尝试以下练习:
- 制作一个可以打印您的姓名的 Python 程序。
- 制作一个显示歌曲歌词的程序。
完成这些步骤后,继续下一个练习。
变量
Python 支持不同类型的变量(数据类型),例如整数,浮点数和文本。
您无需指定变量的数据类型,只需将任何值分配给变量即可。 在下面键入程序并启动它。
数据类型
变量可以是几种数据类型。 Python 支持整数(数字),浮点数,布尔值(对或错)和字符串(文本)。
Python 将根据您分配给变量的值来确定数据类型。 如果创建变量x
,x = 3
,则 Python 假定其为整数。 但是,如果您指定x = 1.5
,则 Python 知道其不是整数,而是浮点数。
示例
下面的示例向您展示了几个变量。 这些可以根据需要分配。 定义后,您可以打印它们或使用算术。
#!/usr/bin/python
x = 3 # a whole number
f = 3.1415926 # a floating point number
name = "Python" # a string
print(x)
print(f)
print(name)
combination = name + " " + name
print(combination)
sum = f + f
print(sum)
从终端或使用 IDE 运行程序。
python example.py
在示例中,我们有几个变量(x
,f
,name
),它们具有不同的数据类型。 在程序的后面,我们创建更多的变量(combination
,sum
)。
可以在程序中的任何位置定义变量。 变量名可以是 1 到 n 个字母。
您应该看到几行包含数字和文本的行:
命名
变量名必须以字母(大写或小写)或下划线开头。 变量不能以数字开头,并且区分大小写。
如果创建两个变量x
和X
,则它们是不同的变量。
Python 3.5.3 (default, Jan 19 2017, 14:11:04)
[GCC 6.3.0 20170118] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> x = 3
>>> X = 4
>>> print(x)
3
>>> print(X)
4
>>>
驼峰大小写
按照惯例,变量通常用驼峰大小写,这意味着第一个字母较小,接下来的单词全为大写。
一些使用驼峰大小写的示例变量
daysInYear = 365
daysInMonth = 30
numberFiles = 5
这比拥有一个长变量(dayinyear
)更容易阅读。 但这不是 Python 的严格要求。
练习
试试下面的练习
- 制作一个显示几个数字的程序。
- 编写一个程序来解决并显示
64 + 32
的总和。 - 进行与 2 中相同的操作,但将其计算
x + y
。
完成这些步骤后,继续下一个练习。
字符串
每当您想在 Python 中使用文本时,都在使用字符串。 如果您使用双引号,Python 会理解您要使用字符串。
创建字符串后,您可以直接直接打印字符串变量。 您可以使用方括号访问字符。
字符串
定义字符串
变量可以是字符串数据类型。 它们可以容纳字符或文本。如果创建字符串变量x
。 您可以使用print()
函数在屏幕上显示它。
x = "Hello"
print(x)
字符串索引
可以使用方括号访问各个字符,计数从零开始。
print(x[0])
print(x[1])
第一个字符从零开始。 这可能有点反常,但有历史原因。
子字符串
通过使用冒号,您可以创建一个子字符串。 如果没有写开始或结束编号,Python 会假定您是第一个字符或最后一个字符。
请尝试以下示例:
x = "hello world"
s = x[0:3]
print(s)
s = x[:3]
print(s)
完整的示例
这个例子做了很多字符串操作,例如打印文本,数字,组合字符串,切片和访问元素。
请尝试以下程序:
x = "Nancy"
print(x)
# Combine numbers and text
s = "My lucky number is %d, what is yours?" % 7
print(s)
# alternative method of combining numbers and text
s = "My lucky number is " + str(7) + ", what is yours?"
print(s)
# print character by index
print(x[0])
# print piece of string
print(x[0:3])
您应该看到以下输出:
练习
试试下面的练习
- 制作一个显示您喜欢的演员的程序。
- 尝试在
s
中打印"lucky"
一词。 - 尝试以“今天是 2/2/2016”的格式打印日,月,年。
字符串替换
Python 内置了对字符串替换的支持。 字符串是包含文本数据的变量。 如果您不了解字符串,则可以在本文中阅读有关字符串的更多信息。
可以使用字符串对象调用str.replace(old, new)
方法。 本文演示了替换方法。
并非所有的编程语言都具有标准的字符串替换函数。 Python 具有许多现成的函数。
示例
替换方法
定义一个字符串并调用replace()
方法。 第一个参数是要搜索的单词,第二个参数指定新值。
输出需要保存在字符串中。 如果您不保存输出,则字符串变量将包含相同的内容。 使用以下命令完成输出保存:s = function()
请尝试以下程序:
s = "Hello World"
s = s.replace("World","Universe")
print(s)
将程序另存为app.py
,然后在终端(或 IDE)中运行
python app.py
这将输出字符串变量s
的新输出:
要替换的单词数
可选参数是将要替换的项目数。 默认情况下是全部。下面的程序仅替换第一项:
s = "Hello World World World"
s = s.replace("World","Universe",1)
print(s)
参数(1
)表示该字符串仅应替换一次。
练习
下面的练习
- 尝试更换程序
- 字符串可以替换两次吗?
- 是否仅用单词或短语替换?
字符串连接
join(sequence)
方法连接元素并返回组合的字符串。 连接方法组合序列的每个元素。
合并单词列表?
使用join(sequence)
方法将它们组合成一个句子。 在分隔符字符串上调用该方法,该字符串可以是任何字符,从空格到破折号。
这比对每个单词使用加号运算符要容易,因为每个单词的列表很快就会变得很乏味。
示例
join
方法将序列作为参数。 序列被写为单个参数:您需要在序列周围添加方括号。
如果需要,您可以传递一个将序列作为参数的变量。 这使其更易于阅读。 在下面的示例中,我们将使用空格分隔符字符串。
请尝试以下程序:
# define strings
firstname = "Bugs"
lastname = "Bunny"
# define our sequence
sequence = (firstname,lastname)
# join into new string
name = " ".join(sequence)
print(name)
您应该看到以下输出:
它还可以加入单词列表:
words = ["How","are","you","doing","?"]
sentence = ' '.join(words)
print(sentence)
练习
试试下面的练习
- 像上面的示例一样,创建单词列表并将其连接起来。
- 尝试将分隔符字符串从空格更改为下划线。
字符串查找
find(query)
方法内置于标准 python。 只需在字符串对象上调用方法以搜索字符串,例如:obj.find("search")
。
find()
方法搜索查询字符串并返回找到的字符位置。 如果找不到该字符串,则返回 -1。
用简单的英语来说:找出一个字符串是否包含另一个字符串。
示例
查找方法
如果找到一个单词,find 方法将返回索引。 如果找不到,则返回 -1。 您可以添加开始索引和结束索引:find(query, start, end)
,但是这些参数是可选的。
请尝试以下程序:
s = "That I ever did see. Dusty as the handle on the door"
index = s.find("Dusty")
print(index)
将程序另存为search.py
,可从终端或 IDE 运行。
您应该看到以下输出:
in
关键字
您也可以使用关键字in
。 下面的示例向您展示如何使用 Python in
关键字。
s = "That I ever did see. Dusty as the handle on the door"
if "Dusty" in s:
print("query found")
区别在于in
关键字如果字符串包含单词则返回,而find
返回字符位置。
练习
试试下面的练习
- 找出字符串查找是否区分大小写
- 如果查询字符串在字符串中出现两次,该怎么办?
- 编写一个要求控制台输入并搜索查询的程序。
分割
可以使用split(param)
方法将字符串拆分为子字符串。 此方法是字符串对象的一部分。 该参数是可选的,但是您可以分割特定的字符串或字符。
给定一个句子,可以将字符串拆分为单词。 如果您有一个段落,则可以按短语拆分。 如果您有一个单词,可以将其拆分为单个字符。
在大多数情况下,split()
方法可以。 对于字符,可以使用列表方法。
字符串分割
如果您有一个字符串,则可以将其细分为几个字符串。 该字符串需要至少有一个分隔符,可以是一个空格。
默认情况下,split
方法将使用空格作为分隔符。 调用该方法将返回所有子字符串的列表。
字符串到单词
下面的演示将字符串拆分为字符。
s = "Its to easy"
words = s.split()
print(words)
len()
方法将为您提供字符数和单词数:
print(len(words))
print(len(s))
输出应类似于下图:
字符串到字符
如果要将单词拆分为字符,请改用list()
方法:
word = "Easy"
x = list(word)
print(x)
可以使用join
方法重构字符串,该方法将序列组合为新字符串。
练习
- 字符串可以拆分为多个字符吗?
- 您可以将一个字符串拆分为这个字符串吗?:世界,地球,美国,加拿大
- 给定一篇文章,您可以根据短语拆分它吗?
随机数
名为random
的模块可用于在 Python 中生成随机数。 要使用模块,您需要输入import module
。 这会将所有函数加载到模块内部。
请记住,带有随机模块的随机数是伪随机数。 对于大多数程序来说,这很好。
随机
随机模块
要使用 Python 代码创建随机数,您可以使用random
模块。 要使用它,只需键入:
import random
这个模块有几个函数,最重要的一个就是命名为random()
。random()
函数生成介于 0 和 1 之间的浮点数 [0.0, 1.0]
。
随机模块具有伪随机数生成器,这意味着它们并不是真正的随机数。
生成随机数
本示例创建几个随机数。键入下面显示的程序并运行它:
import random
# Create a random floating point number and print it.
print(random.random())
# pick a random whole number between 0 and 10.
print(random.randrange(0,10))
# pick a random floating point number between 0 and 10.
print(random.uniform(0,10))
在所有情况下,我们都使用随机模块。 生成几个随机数。
如果要在 1 到 10 之间的随机浮点,可以使用以下技巧:
import random
x = random.uniform(1, 10)
print(x)
对于随机整数,将其设置为整数或使用randrange
函数。
练习
试试下面的练习
- 编写一个创建随机数并将其存储到
x
的程序。 - 制作一个打印 3 个随机数的程序。
- 创建一个程序,该程序生成 100 个随机数并找到每个数字的频率。
完成这些步骤后,继续下一个练习。
键盘输入
在 Python 和许多其他编程语言中,您可以获取用户输入。 不用担心,您不需要编写键盘驱动程序。
input()
函数将要求用户输入键盘。 如果您仍在使用 Python 2,则可以使用raw_input()
函数。
示例
如果指定了参数,则输入函数会提示文本。 该函数从键盘读取输入,将其转换为字符串并删除换行符(Enter
)。
输入以下脚本并进行尝试(另存为key.py
)
#!/usr/bin/env python3
name = input('What is your name? ')
print('Hello ' + name)
job = input('What is your job? ')
print('Your job is ' + job)
num = input('Give me a number? ')
print('You said: ' + str(num))
输出应该是这样的,具体取决于您的终端:
在阅读本文时,也许您已经习惯了语音输入或其他类型的人机交互。 无论哪种键盘输入对于编码仍然非常有用。
练习
试试这些练习:
- 编写一个询问电话号码的程序。
- 编写一个程序,询问用户首选的编程语言。
完成这些步骤后,继续下一个练习。
控制结构
if
语句
程序有时可能不得不做出选择。 这些选择可以根据特定条件执行不同的代码。 在 Python 中, if
语句用于条件执行。
if
语句可以与某些运算符组合,例如等于(==
),大于(>=
),小于(<=
)且不等于(!=
)。 可以使用关键字or
以及and
组合条件。
示例
在下面的示例中,我们显示了if
语句的用法。复制以下程序并运行。
#!/usr/bin/env python3
gender = input("Gender? ")
if gender == "male" or gender == "Male":
print("Your cat is male")
else:
print("Your cat is female")
age = int(input("Age of your cat? "))
if age < 5:
print("Your cat is young.")
else:
print("Your cat is adult.")
if
语句的直观示例(单击放大):
练习
做这些练习:
-
编写一个程序,请求 1 到 10 之间的数字。如果该数字超出范围,则程序应显示“无效数字”。
-
制作一个请求密码的程序。
完成后,继续下一个练习。
for
循环
程序有时需要重复操作。 为了重复动作,我们可以使用for
循环。在代码内部编写了一个for
循环。for
循环可以具有 1 个或多个指令。
for
循环将重复一个代码块。 重复进行直到满足停止条件为止。 如果不满足停止条件,它将无限循环。
重复(循环)这些指令,直到满足条件为止。
示例
在下面的练习中,我们将对列表的每个项目重复执行操作。
第一个循环将为列表的每个项目重复打印函数。
第二个循环将对列表num
的每个元素进行计算并打印结果。
在下面输入代码并运行程序。
#!/usr/bin/env python3
city = ['Tokyo','New York','Toronto','Hong Kong']
print('Cities loop:')
for x in city:
print('City: ' + x)
print('\n') # newline
num = [1,2,3,4,5,6,7,8,9]
print('x^2 loop:')
for x in num:
y = x * x
print(str(x) + '*' + str(x) + '=' + str(y))
将文件另存为loopexample.py
,然后使用以下命令运行代码:
python loopexample.py
示意地,for
循环可以做到这一点:
练习
请尝试以下练习:
-
制作一个列出列表中的国家/地区的程序
clist = ['Canada','USA','Mexico','Australia']
-
创建一个从 0 到 100 的循环
-
使用一个循环制作一个乘法表。
-
使用一个循环向后输出数字 1 至 10。
-
创建一个
for
循环,对直到 10 的所有偶数进行计数 -
创建一个循环,将 100 和 200 之间的数字相加
while
循环
while
循环重复执行代码,直到不满足条件为止。 与for
循环不同,其中的迭代次数可能是未知的。while
循环始终由条件和代码块组成。
与总是具有有限可数步数的for
循环相反,while
循环仅在条件为false
时才结束。
示例
While
循环示例
下面的while
循环定义了条件(x < 10
),并重复指令直到该条件不成立。 输入此代码:
#!/usr/bin/python
x = 3
while x < 10:
print(x)
x = x + 1
执行以下代码,直到不满足x < 10
。与for
循环不同,迭代器i在循环中增加。
保存然后使用您的 Python IDE 或从终端运行。
您也可以创建无限循环,这是条件永远不变的时候。
while True:
print('Forever')
在正常情况下,您希望程序在某个时候退出while
循环。 如果条件发生变化,程序将自动退出while
循环。 大多数情况下,这是通过迭代器完成的,但也可以通过布尔值(开关)来完成。
控制流程图
示意性地,while
循环如下图所示。 这称为控制流程图(cfg
)。 进入while
循环时发生情况的直观方式。
应该注意的是,while
循环中可以有多个语句。 如果代码变得很长,您还可以从循环内部调用函数。
练习
请尝试以下练习:
-
编写一个程序,使用
while
循环列出下面的国家/地区。clist = ["Canada","USA","Mexico"]
-
while
循环和for
循环有什么区别? -
您可以在
while
循环中对数字求和吗? -
可以在
while
循环内使用for
循环吗?
数据与操作
函数
要对代码集进行分组,可以使用函数。 函数是可重复代码的一小部分。一个函数接受参数。
没有函数,我们只有一长串指令。 函数可以帮助您组织代码。 函数也可以重用,通常它们包含在模块中。
示例
函数
函数可以看作是可执行代码块。 一个函数可以使用一次或多次。
一个简单的函数示例是:
def currentYear():
print('2018')
currentYear()
在此示例中,将立即调用该函数。 函数定义始终以def
关键字开头。
函数可以重用,一旦创建一个函数就可以在多个程序中使用。 打印函数就是一个例子。
具有参数的函数
在下面的示例中,我们有参数x
和y
。 输入此程序并将其另存为summation.py
#!/usr/bin/env python3
def f(x,y):
return x*y
print(f(3,4))
在此示例中,我们有两个函数:f(x, y)
和print()
。 函数f(x, y)
使用return
关键字将其输出传递给print
函数。
返回变量
函数可以返回变量。 有时一个函数进行计算或有一些输出,可以将其提供给带有返回变量的程序。
在许多情况下,输出存储在变量中:
result = f(3,4)
print(result)
在这种情况下,程序将使用参数 3 和 4 调用函数f
,然后将输出保存到变量result
中。
练习
试试下面的练习
1.创建一个将列表mylist = [1,2,3,4,5]
求和的函数
2.是否可以在函数内部调用函数?
3.函数可以调用自身吗? (提示:递归)
4.在一个函数中定义的变量可以在另一个函数中使用吗? (提示:作用域)
完成这些步骤后,继续下一个练习。
列表
列表可以看作是一个集合:它们可以包含许多变量。 列表类似于物理列表,它们可以包含许多项目。
列表可以包含任意数量的元素。 它们类似于其他编程语言中的数组。 列表可以容纳各种变量:整数(整数),浮点数,字符,文本等。
示例
空列表
让我们创建一个空列表。 要定义一个空列表,您应该使用方括号。括号告诉 Python 该对象是一个列表。
list = []
列表可以同时包含数字和文本。 无论内容如何,都可以相同的方式访问它们。
要访问列表,请在方括号之间添加下标,例如list [0]
,list [1]
等。
定义列表
上面定义了一个空列表。 列表可以包含各种数据。您可以创建如下的数字列表:
ratings = [ 3,4,6,3,4,6,5 ]
列表可以包含字符串或字符:
ratings = [ 'A','A','B','A','C','A' ]
要输出简单打印它们
print(ratings)
您可以使用for
循环逐项进行交互。
访问列表项
您可以使用方括号及其索引来访问列表项。 Python 开始从零开始计数,这意味着第一个元素为零。
为什么从零开始计数?
用于从零开始计数的计算机语言。 在首次创建编程语言时,从零开始计数是有意义的。 如今,改变这一传统真是奇怪。
要获得第一项,只需在列表名称后添加方括号和零。
print(rating[0])
增量编号可以访问所有其他元素,以打印您要使用的第二项(1),以打印您要使用的第三项(2)。
print(rating[1])
列表示例
输入以下代码并运行:
#!/usr/bin/python
list = [ "New York", "Los Angles", "Boston", "Denver" ]
print(list) # prints all elements
print(list[0]) # print first element
list2 = [1,3,4,6,4,7,8,2,3]
print(sum(list2))
print(min(list2))
print(max(list2))
print(list2[0])
print(list2[-1])
这应该输出:
练习
-
制作一个显示美国各州的程序。
states = [ 'Alabama','Alaska','Arizona','Arkansas','California','Colorado','Connecticut','Delaware','Florida','Georgia','Hawaii','Idaho','Illinois','Indiana','Iowa','Kansas','Kentucky','Louisiana','Maine','Maryland','Massachusetts','Michigan','Minnesota','Mississippi','Missouri','Montana','Nebraska','Nevada','New Hampshire','New Jersey','New Mexico','New York','North Carolina','North Dakota','Ohio','Oklahoma','Oregon','Pennsylvania','Rhode Island','South Carolina','South Dakota','Tennessee','Texas','Utah','Vermont','Virginia','Washington','West Virginia','Wisconsin','Wyoming' ]
-
显示所有以字母
M
开头的州
列表操作
列表可以用几种方法更改。 这些方法是什么?
要将项目添加到列表中,可以使用append()
方法。 调用列表中的方法,该参数包含要添加的项目。 调用append(3)
会将 3 加到列表中。 要从列表末尾删除项目,可以使用pop()
方法。
列表可以像传统数组一样进行访问,可以使用方括号和索引来获取项目。
示例
列表可以使用其方法进行修改。在下面的示例中,我们创建一个列表,并使用方法更改列表内容。
追加并弹出
输入如下所示的程序并运行:
x = [3,4,5]
x.append(6)
print(x)
x.append(7)
print(x)
x.pop()
print(x)
访问项目
要访问项目,只需使用方括号:
x = [3,4,5]
print(x[0])
print(x[1])
print(x[-1])
练习
试试下面的练习
- 给定列表
y = [6,4,2]
,添加项目 12,8 和 4。 - 将列表的第二项更改为 3。
完成这些步骤后,继续下一个练习。
排序列表
对列表进行排序非常简单:Python 内置了对列表进行排序的支持。
从一些数据开始:创建一个数字列表,然后调用sort()
方法。 直接在列表对象上调用此方法。 这将适用于任何列表,包括成对列表。
排序示例
排序列表
我们用一串数字定义一个列表(x
)。 然后在列表对象上调用sort
方法。 我们不需要保存返回变量,只需调用该方法就足够了。
x = [3,6,21,1,5,98,4,23,1,6]
x.sort()
print(x)
保存程序(sort1.py
)并运行。 这将以从低到高的顺序输出所有数字。
您有字符串列表吗? 字符串也可以排序。
words = ["Be","Car","Always","Door","Eat" ]
words.sort()
print(words)
通过简单地调用.sort()
方法,可以对包含多个项目的列表进行排序。
在执行此操作时,您不需要使用返回变量,因为列表是对象(有关 OOP 的更多信息,请参见 OOP 部分)。 现在,请记住您可以在列表上调用.sort()
。
倒序
要以相反的顺序排序,请将其与方法reverse()
组合
x = [3,6,21,1,5,98,4,23,1,6]
x.sort()
x = list(reversed(x))
print(x)
所有数字将以相反的顺序显示。
那这是怎么回事?
首先,列表使用x.sort()
排序。
然后将其提供给函数reversed()
,该函数以列表作为参数。 但是,该函数不会返回列表对象,而是返回迭代器。 方法list()
转换reversed()
的输出,并将其转换为列表对象。
最佳反向排序方式
您可以使用更优雅的方式对列表进行排序:
words = words[::-1]
这是什么骗术?
切片技术已在列表中使用。 这意味着切片列表,从第一个字符开始,最后一个字符结束,步长为 -1(反向)。
练习
-
给定一个成对的列表,对第一个元素进行排序
x = [ (3,6),(4,7),(5,9),(8,4),(3,1)]
-
现在排序第二个元素
range
函数
range()
构造函数生成数字。 这在创建新列表或使用for
循环时非常有用:它可以同时用于两者。
实际上,您很少自己定义列表,您可以从数据库,Web 或使用range()
生成列表。
示例
假设您要创建一个包含 100 个数字的列表。 手工写出来非常耗时,而要使用range
函数:
x = list(range(100))
print(x)
Python 从零开始计数。 现在,如果您想从 1 数到 100,该怎么办?
x = list(range(1,101))
print(x)
第三个参数定义步长,默认情况下为步长。 范围可以在for
循环中使用:
for i in range(1,11):
print(i)
练习
试试下面的练习
- 创建一千个数字的列表
- 从该列表中获取最大和最小的数字
- 创建两个列表,一个偶数和奇数。
字典
Python 字典是另一个集合。 实词词典是理解它们的一个很好的类比:它们包含一个项目列表,每个项目都有一个键和一个值。
在传统字典中,关键是单词,值是其解释或描述。 在 Python 中,您可以执行类似的操作。
示例
简介
用更严格的说法(数学上),字典是一对一的映射。 字典中的每个键都有一个值。 此值已分配给密钥。
字典:一组包含(键,值)对的集合
对于字典中的每个键,都有一个值。 与列表不同,字典没有特定的顺序。
这意味着如果您要定义一个字典并在其上循环,则每次输出都可能不同,因为 Python 忽略了顺序。
定义
让我们输入一些代码! 您可以使用一个衬纸创建字典。 使用这些括号{}
定义字典。
words = {}
当心:这只是一个与列表不同的两个字符。 在此处输入错误,会将其与列表混在一起。
然后,您可以创建一个映射。 映射定义为键值对。 首先定义键,然后定义值:
words[key] = value
您可以将字符串用作键。 一个关键的定义可以是:words["PRONTO"]
字典示例
在下面的示例中,我们定义了一些键,值对,然后使用其唯一键打印它们。键入以下代码,保存并运行:
#!/usr/bin/python
words = {}
words["BMP"] = "Bitmap"
words["BTW"] = "By The Way"
words["BRB"] = "Be Right Back"
print words["BMP"]
print words["BRB"]
练习
- 绘制国家到国家的短代码
- 打印每个项目(键和值)
读取文件
读取文件是 Python 标准库的一部分。 这意味着您不必包括任何模块。
有两种读取文件的方式:
- 逐行
- 读取一块
在本文中,我们将向您展示这两种方法。
您使用的解决方案取决于您要解决的问题。
示例
逐行
要读取文件,可以使用readlines()
函数。 这将逐行读取文件并将其存储到列表中:
输入以下代码,将其另存为file.py
并运行。
#!/usr/bin/env python
filename = "file.py"
with open(filename) as f:
content = f.readlines()
print(content)
读取块
您可能并不总是希望逐行读取文件。 例如,如果您的文件没有换行符或为二进制文件。 要读取文件并存储为字符串,请改用read()
函数:
#!/usr/bin/env python
filename = "file.py"
infile = open(filename, 'r')
data = infile.read()
infile.close()
print(data)
练习
- 读取文件并每行编号
- 找出文件不存在时程序的功能。
- 如果与其他用户创建文件并尝试打开它会发生什么?
写入文件
写入文件功能是标准模块的一部分,您无需包含任何模块。
写入和附加到文件在 Python 语言中是不同的。您可以使用这行打开要写入的文件:
f = open("test.txt","w")
附加到文件中使用:
f = open("test.txt","a")
如果指定了错误的参数,则文件可能被清空!
示例
创建新文件
要创建新文件,可以使用以下代码:
#!/usr/bin/env python
# create and open file
f = open("test.txt","w")
# write data to file
f.write("Hello World, \n")
f.write("This data will be written to the file.")
# close file
f.close()
"\n"
字符添加新行。 如果文件已经存在,则将其替换。 如果使用"w"
参数,则文件的现有内容将被删除。
附加到文件
要将文本添加到文件末尾,请使用"a"
参数。
#!/usr/bin/env python
# create and open file
f = open("test.txt","a")
# write data to file
f.write("Don't delete existing data \n")
f.write("Add this to the existing file.")
# close file
f.close()
练习
- 将文本“轻松”写到文件中
- 将
open("text.txt")
行写入文件
嵌套循环
一个循环可以包含一个或多个其他循环:您可以在一个循环内创建一个循环。此原理称为嵌套循环。 嵌套循环遍历两个或多个循环。
程序员通常嵌套 2 或 3 层深度。 高于此的数字只会造成混乱。
示例
让我们做一个简单的例子。 我们创建两个列表:
persons = [ "John", "Marissa", "Pete", "Dayton" ]
restaurants = [ "Japanese", "American", "Mexican", "French" ]
如果我们有一个喜欢在餐厅吃饭的人的列表,我们可以让他们每个人都在某个餐厅吃饭吗?
#!/usr/bin/python
persons = [ "John", "Marissa", "Pete", "Dayton" ]
restaurants = [ "Japanese", "American", "Mexican", "French" ]
for person in persons:
for restaurant in restaurants:
print(person + " eats " + restaurant)
这遍历了两个循环:
练习
试试下面的练习
-
给定一个 3x3 的井字游戏板,请打印每个位置
-
创建一个程序,让每个人都与其他人见面
persons = [ “John”, “Marissa”, “Pete”, “Dayton” ]
-
如果正常的
for
循环在 n 步O(n)
中完成,则嵌套循环有多少步?
完成这些步骤后,继续下一个练习。
切片
可以从字符串或列表中获取切片,就像从比萨中获取切片一样。如果要包含一部分变量,可以是列表或字符串,则无需重新定义。
您可以获取变量的副本,该副本是原始变量的全部或子集。 此概念称为切片。
示例
切片
要拍摄前两个切片,请使用:
slice = pizza[0:2]
可变切片现在将包含一份比萨饼,但仅一部分。 这用方括号表示,第一个数字是开始,而冒号之后的数字是结束。
为什么从零开始?
Python 从零开始而不是从 1 开始对字符串和列表元素编号。
在这种情况下,我们从比萨饼列表中获取了一个切片,将输出存储到新变量中。如果需要,可以将其直接传递给打印函数。
列表切片
创建人员列表。 我们将使用切片技术来获取列表中的前两个人。
#!/usr/bin/python
persons = [ "John", "Marissa", "Pete", "Dayton" ]
slice = persons[0:2]
print(slice)
这将输出切片:
字符串切片
字符串也可以切片。 这样做的方式完全相同,但主要区别在于它不会返回很多项目,而只是返回一个新字符串。
destination = "summer holiday at beach"
mySlice = destination[0:6]
print(mySlice)
练习
试试下面的练习
-
请从下面的列表中获取切片:
pizzas = ["Hawai","Pepperoni","Fromaggi","Napolitana","Diavoli"]
-
给定文本
"Hello World"
,请截取"World"
多个返回值
Python 函数可以返回多个变量。 这些变量可以直接存储在变量中。 一个函数不需要返回一个变量,它可以返回零个,一个,两个或多个变量。
这是 Python 的唯一属性,默认情况下,其他编程语言(例如 C++ 或 Java)不支持此属性。
示例
简介
函数中定义的变量仅在函数中已知。 那是因为变量的范围。 通常,除非您要在程序中使用函数输出,否则这不是问题。
在这种情况下,您可以从函数中返回变量。 在最简单的情况下,您可以返回一个变量:
def complexfunction(a,b):
sum = a +b
return sum
用complexfunction(2, 3)
调用该函数,并且可以使用或保存其输出。
但是,如果要访问的函数中有多个变量怎么办?
多个返回值
创建一个函数getPerson()
。 如您所知,一个函数可以返回一个变量,但也可以返回多个变量。
我们将直接从函数调用中存储所有这些变量。
#!/usr/bin/env python3
def getPerson():
name = "Leona"
age = 35
country = "UK"
return name,age,country
name,age,country = getPerson()
print(name)
print(age)
print(country)
这将输出:
练习
请尝试以下练习:
- 创建一个返回
a
,b
和a + b
的函数 - 创建一个返回 5 个变量的函数
完成这些步骤后,继续下一个练习。
作用域
变量在程序中具有一定的作用。 全局变量可以在程序中的任何位置使用,但是局部变量仅在特定区域(函数,循环)中已知
有时在项目中使用“作用域”一词:“其不在项目作用域之内”,表示不包括在内。 同样,变量可以在函数作用域之外。
示例:
简介
作用域与可以使用变量的位置有关。 如果定义了变量,则不一定在代码中的任何地方都可用。 函数中定义的变量只有在函数中才知道,除非您将其返回。
def something():
localVar = 1
# this will crash because localVar is a local variable
print(localVar)
这意味着除非您从函数返回变量,否则只能在其中使用它们。 这与全局变量形成了鲜明的对比:全局变量可以在任何地方使用,包括在多个函数和主代码中。 全局变量通常在程序顶部定义。
全局变量和局部变量
在下面的程序中,balance
是一个全局变量。 它可以在代码中的任何地方使用。 但是变量x
只能在addAmount
内部使用。
#!/usr/bin/env python3
balance = 0
def addAmount(x):
global balance
balance = balance + x
addAmount(5)
print(balance)
在视觉上是:
我们有两个变量:balance
,一个可以在任何地方使用的全局变量。x
,只能在函数内部使用(在局部作用域之外未知)。
练习
请尝试以下练习:
- 添加函数
subAmount
以更改变量余额 - 创建带有局部变量的函数
时间和日期
Python 可以使用模块time
获得系统时间。time
属于标准库。 您可以通过输入import time
加载此模块。
时间模块具有各种与时间相关的函数。 并非所有函数都存在于所有操作系统上。
时间模块从 1970 年 1 月 1 日开始。
示例
当前时间
在下面的示例中,我们输出日,月和年,后跟当前时间。
第一行返回所有必需的变量(年,月,日,小时,分钟)。
timenow = time.localtime(time.time())
函数time.time()
返回时间戳。 时间戳是每台计算机持有的系统时间戳。
timenow = time.localtime(time.time())
作为人类,我们不阅读系统时间戳,因此需要将其转换为实际人类时间。函数localtime()
将这些转换为实际的人类可读值。
year,month,day,hour,minute = timenow[0:5]
转换为:
timenow = time.localtime(time.time())
键入下面显示的程序并运行它:
import time
timenow = time.localtime(time.time())
year,month,day,hour,minute = timenow[0:5]
print(str(day) + "/" + str(month) + "/" + str(year))
print(str(hour) + ":" + str(minute))
纪元时间
您如何获得自纪元以来的秒数?time()
方法将为您提供:
>>> import time
>>> time.time()
1563018526.7016013
>>> time.time()
1563018527.5820937
>>>
要获取时间序列,请调用time.gmtime()
。
>>> time.gmtime()
time.struct_time(tm_year=2019, tm_mon=7, tm_mday=13, tm_hour=11, tm_min=49, tm_sec=39, tm_wday=5, tm_yday=194, tm_isdst=0)
字符串时间
方法asctime()
和ctime()
返回 24 个字符串。 没有参数,它将获取当前时间。
>>> time.asctime()
'Sat Jul 13 13:53:00 2019'
>>> time.ctime()
'Sat Jul 13 13:53:01 2019'
>>>
睡眠
您可以使程序等待。 该程序只会等待,不会执行任何操作。 睡眠函数使您可以执行此操作。
import time
print("Hello")
time.sleep(1)
print("World")
time.sleep(1)
练习
试试下面的练习
- 以“年-月-日”格式打印日期
完成这些步骤后,继续下一个练习。
try except
try except
语句可以处理异常。 当您运行程序时,可能会发生异常。
异常是在程序执行期间发生的错误。 Python 不会告诉您诸如语法错误(语法错误)之类的错误,而是会突然停止。
突然退出对最终用户和开发人员都是不利的。
除了紧急停止,您可以使用try except
语句正确处理问题。 如果您没有正确处理异常,将会紧急停止。
示例
让我们采用这种情况:程序要求输入数字用户。 而是用户在输入框中键入字符。 该程序通常会崩溃。
try except
try except
语句可防止程序崩溃并对其进行正确处理。
try:
x = input("Enter number: ")
x = x + 1
print(x)
except:
print("Invalid input")
输入无效的输入,使程序正常运行:
finally
可以使用finally
关键字扩展try except
语句,如果不引发异常,则将执行此语句:
finally:
print("Valid input.")
如果没有引发异常,程序将继续执行。
有不同种类的异常:ZeroDivisionError
,NameError
,TypeError
等。 有时,模块定义自己的异常。
练习
- 可以使用
try-except
来捕获无效的键盘输入吗? - 如果无法打开文件,
try-except
能否捕获错误? - 什么时候不使用
try-except
?
如何使用pip
和 pypi
pip
是 Python 的软件包管理器。 您可以使用它来安装模块。 有时系统在商店中有两个版本的pip
,您需要版本 3(最新版本)。
模块就是代码:以函数或对象的形式。 您可以将此包含在程序中并以此为基础。 您可以将其视为用于构建项目的预制部件。
PyPI 是 Python 软件包的索引,用于存储 Python 的所有正式模块。
pip
安装pip
pip
的安装很容易。 您可以使用系统软件包管理器进行安装。 如果您使用 Linux,则通常已经安装了。
在 Linux 上,您可以使用以下命令进行安装:
# debian and ubuntu linux
sudo apt-get install python3-pip
# fedora linux
sudo yum install python3-pip
在 Mac OS X 上,使用easy_install
进行安装。
sudo easy install pip
安装模块
是否安装了pip
? 它可以从 PyPi 仓库安装软件包。 它是 python 模块的官方存储库。
从 PyPi 仓库下载并安装了通过pip
安装的软件。
要安装模块,只需键入:
pip install modulename
这可以是 PyPi 索引中的任何模块,让我们播放:
pip install playsound
virtualenv
您总是希望在虚拟环境中安装,而不是在系统上全局安装。
virtualenv
创建一个隔离的环境,因此您安装的软件包不会影响其他 python 项目。 您可以通过以下方式进行操作:
virtualenv name
cd name
source bin/activate
然后,您的环境处于活动状态,并且可以使用pip
安装模块
pip install package
如果要结束使用项目,请禁用类型。
搜索
您可以在线或在命令行中在 PyPi 索引中找到软件包。
要在命令行中键入以下命令,其中topic
是您要搜索的单词。
pip search topic
这将显示可用软件模块的列表。
面向对象
类
Python 类是“面向对象编程”的概念。 Python 是一种面向对象的编程语言(OOP)。 OOP 是一种构建软件的方法。
使用 OOP,您可以使程序更有条理,可伸缩性,可重用性和可扩展性。 OOP 概念可能有点奇怪。 掌握起来可能很困难,但这是一个非常强大的概念。
示例
对象
在 Python 中,您可以定义对象。 对象是方法和变量的集合。 对象驻留在计算机内存中的某个位置。 它们可以在运行时进行操作。
让我们创建一个理论示例,我们创建一个对象狗。 创建对象只是一行代码:
obj1 = dog()
每个对象可以具有变量。 这些变量的值对于对象是唯一的。 我们设置对象变量(名称,年龄)
obj1.name = "Woof"
obj1.age = 5
如果对象存在方法,则可以调用它们。 对象的唯一变量可以在这些方法中使用。这些方法可以多次使用:
obj1.bark()
obj1.bark()
在您的程序中,您可以有多个对象。 这些对象可以是相同类型或不同类型。
obj1 = dog()
obj2 = dog()
obj3 = dog()
obj4 = bird()
那么 Python 如何知道对象的类型呢? 如何知道某个类型存在哪些方法和变量? 它们在一个类中定义。
类
对象总是从类创建的。 一个类定义对象中存在的每个方法和变量。 您可以将类视为对象的蓝图。
还记得前面的示例中的dog
类型的对象吗?
该对象具有变量(name
,age
)和方法(bark
)。 它们在狗类中定义。这是该类的定义方式:
class dog:
name = ""
age = 0
def bark(self):
print('Bark')
首先,我们定义类本身:class dog
。 然后定义变量(name
,age
)。 最后,我们定义方法。 如果仔细观察,就会发现该方法中包含self
一词。self
一词指的是对象(您可以从一个类中创建多个对象。)
详细示例
类不仅用于有趣的示例(狗,鸟)。 它们已在所有计算机软件中使用。
如果您承担制作网络浏览器的任务,则需要在某个时候显示一个网站。可以说程序将是面向对象的。 然后可以用这种方式定义一个类:
#!/usr/bin/python
class Website:
def __init__(self,title):
self.title = title
def showTitle(self):
print(self.title)
等等..什么是__init__
?
如果创建了对象,则调用方法__init__
。 这始终是创建新对象时调用的第一个方法。 该方法称为构造函数。
然后,您可以创建 Web 浏览器对象。
#!/usr/bin/python
class Website:
def __init__(self,title):
self.title = title
def showTitle(self):
print(self.title)
obj = Website('pythonbasics.org')
obj.showTitle()
在本示例中,我们有一个从类Website
创建的对象(obj
)。 该类有两种方法:__init__
和showTitle()
。
练习
试试下面的练习
- 文件中可以有多个类吗?
- 可以从同一个类中创建多个对象吗?
- 对象可以创建类吗?
- 使用上面的代码,创建另一个对象
- 在类中添加一个方法:
location()
完成这些步骤后,继续下一个练习。
构造函数
构造函数是在创建对象时调用的方法。 此方法在类中定义,可用于初始化基本变量。
如果创建四个对象,则类构造函数将被调用四次。 每个类都有一个构造函数,但是不需要显式定义它。
示例
构造函数
每次创建对象时,都会调用一个方法。 该方法称为构造函数。
构造函数是使用函数__init__
创建的。 作为参数,我们编写了self
关键字,它引用了自身(对象)。 从视觉上看,该过程是:
在构造函数内部,我们初始化两个变量:腿和手臂。 有时,在面向对象编程的上下文中,变量被称为属性。 我们创建一个对象(bob
),仅通过创建它,即可初始化其变量。
class Human:
def __init__(self):
self.legs = 2
self.arms = 2
bob = Human()
print(bob.legs)
现在,新创建的对象已设置了变量,而无需手动定义它们。 您可以创建数十或数百个对象,而不必每次都设置值。
python __init__
函数__init__(self)
将构建您的对象。 它不仅是您可以在此处设置的变量,还可以调用类方法。 初始化对象所需的一切。
假设您有一个“飞机”类,该飞机一经创建便应开始飞行。 起飞涉及许多步骤:加速,更换襟翼,关闭车轮等。
可以在方法中定义默认操作。 这些方法可以在构造函数中调用。
class Plane:
def __init__(self):
self.wings = 2
# fly
self.drive()
self.flaps()
self.wheels()
def drive(self):
print('Accelerating')
def flaps(self):
print('Changing flaps')
def wheels(self):
print('Closing wheels')
ba = Plane()
总结一下:如果创建对象,则会调用构造函数。 在构造函数中,您可以设置变量和调用方法。
默认值
一个类的构造函数是唯一的:从不同的类初始化对象将调用不同的构造函数。
可以在构造函数中设置新创建对象的默认值。
下面的示例显示了两个带有构造函数的类。 然后创建两个对象,但调用不同的构造函数。
class Bug:
def __init__(self):
self.wings = 4
class Human:
def __init__(self):
self.legs = 2
self.arms = 2
bob = Human()
tom = Bug()
print(tom.wings)
print(bob.arms)
但是从一个类创建多个对象将调用相同的构造函数。
练习
请尝试以下练习:
- 制作两个其他对象
- 添加另一个变量并将其初始化
获取器和设置器
一类可以再有一个变量(有时称为属性)。 创建对象时,这些对象中的每个对象对于这些变量都有唯一的值。
类变量不需要直接设置:可以使用类方法进行设置。 这是面向对象的方式,可帮助您避免错误。
示例
我们创建一个带有属性的类。 从该类中,我们创建几个对象。
class Friend:
def __init__(self):
self.job = "None"
Alice = Friend()
Bob = Friend()
这些对象没有设置属性(作业)。 要进行设置,我们可以直接进行设置,但这是一个不好的做法。 相反,我们创建两个方法:getJob()
和setJob()
。
class Friend:
def __init__(self):
self.job = "None"
def getJob(self):
return self.job
def setJob(self, job):
self.job = job
Alice = Friend()
Bob = Friend()
Alice.setJob("Carpenter")
Bob.setJob("Builder")
print(Bob.job)
print(Alice.job)
创建了两个对象,这两个对象对于属性作业均具有唯一的值:
练习
试试下面的练习
- 添加变量年龄并创建获取器和设置器
- 为什么要使用获取器和设置器方法?
完成这些步骤后,继续下一个练习。
模块
模块可以具有一个或多个函数。 他们可以帮助您组织代码。 您可以有多个文件(模块),而不是一个长的 Python 文件。
模块是具有函数或类的 Python 文件。 Python 程序可以使用一个或多个模块。
示例
什么是模块?
有许多可用于 Python 的模块(有时称为库)。 通过使用这些模块,您可以更快地进行编码。
将它们视为构建基块,它们包含大量为您提供其他函数的函数(有时是类)。
导入模块
您可以使用import
关键字加载模块。
在下面的示例中,我们加载os
模块。 这是操作系统的缩写,因此您可以执行系统任务。
import os
os.system("dir")
使用该模块,我们调用其名为系统的函数之一(运行命令)。
在这种情况下,它将仅列出目录中的文件(dir
命令)。
Python 有许多可用的模块。
从模块获取特定函数
要在模块中导入特定函数,可以使用以下行:
from module import function
有一个名为time
的模块,该模块具有各种时间函数:获取日期,小时,分钟,秒等。 有很多函数。
假设您希望程序等待 2 秒。 如果需要,可以导入特定函数而不是整个模块。
#!/usr/bin/python
from time import sleep
sleep(2)
从模块导入所有函数
您可以从模块导入所有函数,但是不建议这样做。下面的示例导入整个时间模块(所有函数),然后可以使用。
#!/usr/bin/python
from time
time.sleep(2)
列出模块中的函数
要查看模块中的所有函数,请启动 Python 解释器并输入
python
import os
dir(os)
这将显示模块中的所有函数和类:
制作模块
要制作模块,请创建一个 Python 文件。 然后像导入其他模块一样将其导入。创建您的模块(fruit.py
)
def lemon():
print('Lemonade')
然后创建您的程序(example.py
)并调用该函数:
import fruit
fruit.lemon()
找不到 python 模块
如果收到错误“ImportError
:没有名为<name>
的模块”,则表示未安装该模块。您可以使用pip
软件包管理器安装模块。 为此,最好也设置一个virtualenv
。
virtualenv projectname
cd projectname
source bin/activate
pip install module
练习
试试下面的练习
- 导入数学模块并调用
sin
函数 - 使用函数
snake()
创建自己的模块
继承
继承:一个类可以获取另一个类的属性和变量。 该类称为超类或父类。
继承使您不必重复自己(在编码中:不要重复自己),您可以定义一次方法并将其用于一个或多个子类中。
示例
简介
您至少需要两个类才能使继承起作用。 就像现实生活一样,一个人会继承另一个。从超类继承的类将获得所有内容。
对于面向对象的编程,这意味着它将从超类获取方法和变量。
多个类可以从同一父类继承。 在这种情况下,所有子类都将获得超类的所有属性和方法。
工作原理
定义两个类,一个超类(App
)和一个子类(Android
)。 子类(Android
)继承自App
类。
首先,我们定义超类。 超类的编写方式与普通类一样,没有什么特别之处,只不过其他人可以继承。 您可以根据需要提供方法和变量。
class App:
def start(self):
print('starting')
我们在超类(App
)中定义了方法和变量,一旦继承,我们就可以在子类中使用它们。 让我们创建一个继承自超类的类(Android
)。
在超类中,我们创建方法start()
。 这只是出于演示目的,该方法在使用Android
类创建对象时将可用。
Python 如何知道类要继承? 类名后的花括号。
class Android(App):
首先定义普通的类名,然后定义超类。
代码示例
下面的示例演示了 Python 中的继承。 Python 支持多种继承,但是在此示例中,我们仅从一个超类继承。
以下是完整的示例:
#!/usr/bin/python
class App:
def start(self):
print('starting')
class Android(App):
def getVersion(self):
print('Android version')
app = Android()
app.start()
app.getVersion()
练习
请尝试以下练习:
- 创建一个继承自
App
类的新类 - 尝试创建一个从两个超类继承的类(多重继承)
静态方法
可以在不创建对象或实例的情况下调用静态方法。 只需创建方法并直接调用即可。 从某种意义上说,这与面向对象的编程正交:我们在不创建对象的情况下调用方法。
这直接与面向对象编程的概念背道而驰,可能会被反对,但是有时使用静态方法可能会很有用。
示例
静态方法
通常,您可能想进行函数调用,或者创建一个对象来调用其方法。 但是,您可以执行其他操作:在类中调用方法而不创建对象。
下面演示静态方法。 用方法定义一个类。 在其上方添加关键字@staticmethod
以使其变为静态。
class Music:
@staticmethod
def play():
print("*playing music*")
Music.play()
类中的静态方法
一个类可以同时包含静态和非静态方法。 如果要调用非静态方法,则必须创建一个对象。 下面的代码不起作用,因为未创建对象:
class Music:
@staticmethod
def play():
print("*playing music*")
def stop(self):
print("stop playing")
Music.play()
Music.stop()
调用静态方法
普通类方法和静态方法可以混合使用(因为为什么不这样?)。
这可能会非常令人困惑:我们将面向对象的概念和函数式编程都混合在一个类中。
如果创建对象,则可以调用非静态方法。 但是您也可以在不创建对象的情况下调用静态方法。
class Music:
@staticmethod
def play():
print("*playing music*")
def stop(self):
print("stop playing")
Music.play()
obj = Music()
obj.stop()
总体而言,静态方法是一个有趣的概念,但实际上,您很少使用它们。 有时使用静态方法可能表明设计不好。
练习
试试下面的练习
- 是否可以在类中调用方法而无需创建对象?
- 为什么每个人都不喜欢静态方法?
完成这些步骤后,继续下一个练习。
可迭代对象
可迭代对象是可以用作序列的 Python 对象。 您可以使用next()
方法转到序列的下一项。
您可以遍历可迭代对象,但不能直接访问单个元素。这是一个容器对象:当时只能返回其元素之一。
示例
创建可迭代对象
定义一个字典和一个可迭代对象的代码,如下面的代码:
#!/usr/bin/python
d = { "one": 1, "two": 2, "three": 3, "four": 4, "five": 5 }
iterable = d.keys()
print(iterable)
您可以像这样遍历项目:
for item in iterable:
print(item)
next
方法
创建一个迭代器以使用下一个方法:
#!/usr/bin/python
d = { "one": 1, "two": 2, "three": 3, "four": 4, "five": 5 }
iterable = d.keys()
iterator = iter(iterable)
print( next(iterator) )
print( next(iterator) )
可迭代类型
您不能使用索引访问元素,这将引发异常。可迭代对象类型包括列表,字符串,字典和集合。
下面的演示将迭代器应用于列表:
items = [ "one","two","three","four" ]
iterator = iter(items)
x = next(iterator)
print(x)
练习
试试下面的练习
- 什么是可迭代对象?
- 可迭代对象使用哪些类型的数据?
您可以下载以下答案:
Python 类方法
类方法是一种在所有对象之间共享的方法。 要调用类方法,请将类作为第一个参数。
可以从实例和类本身中调用类方法。 所有这些都使用相同的方法。 该方法可以使用类变量和方法。
示例
类方法示例
要将方法转换为类方法,请在方法定义之前添加@classmethod
。 该方法始终将类作为参数。
下面的示例定义了一个类方法。 然后,类本身可以使用该类方法。 在此示例中,类方法使用类属性名称。
class Fruit:
name = 'Fruitas'
@classmethod
def printName(cls):
print('The name is:', cls.name)
Fruit.printName()
您可以同时使用对象和类的类方法:
apple = Fruit()
berry = Fruit()
Fruit.printName()
apple.printName()
berry.printName()
现在,参数名称属于该类,如果您要通过使用对象来更改名称,它将忽略该参数。 但是,如果您要按班级进行操作,则它会更改,例如以下示例:
apple.name="Apple"
Fruit.printName()
apple.printName()
berry.printName()
Fruit.name="Apple"
Fruit.printName()
apple.printName()
berry.printName()
替代表示法
通常使用 pythonic 表示法,但这并不是严格要求的。
您也可以使用这样的类方法:
class Fruit:
name = 'Fruitas'
def printName(cls):
print('The name is:', cls.name)
Fruit.printAge = classmethod(Fruit.printName)
Fruit.printAge()
类方法与静态方法
类似于静态方法,类方法不需要实例化对象。
类方法与静态方法的不同之处在于,静态方法不了解类本身。 在类方法中,参数始终是类本身。
静态方法对类或实例一无所知。 您也可以使用函数调用。
类方法在调用该方法时获取该类。 它了解类的属性和方法。
练习
类方法文章的练习:
- 什么是类方法?
- 类方法与静态方法有何不同?
多重继承
一个类可以从多个超类继承。 多重继承是标准或单一继承的扩展。 原理保持不变:一个类从另一个类继承。
多重继承是从更多父类继承的想法。 一个类可以继承 2,3 或多个类。
示例
简介
一个类可以从 Python 中的多个类继承(其他编程语言并非总是如此)。如果创建一个类,则可以让它从父类(有时称为超类)继承。
该类本身可以命名为子类,因为它有多个父类。
如果一个类继承自超类,它将获得其所有属性和方法。 如果您有 4 个超类,它将仅继承所有它们。
通用格式为:
class Subclass(SuperClass1, SuperClass2, SuperClass3, ..):
您可以直观地看到:
多重继承
在下面的程序中,定义了两个超类:Human
和Coder
。 通过使用以下代码行,Pythonista
类从这两个类继承:
class Pythonista(Human, Coder):
该程序通过创建一个对象继续进行。 该对象具有来自所有 3 个类的属性:超类及其本身。 如果在超类或类中定义方法,则对象将具有所有方法。
class Human:
name = ""
class Coder:
skills = 3
class Pythonista(Human, Coder):
version = 3
obj = Pythonista()
obj.name = "Alice"
print(obj.name)
print(obj.version)
print(obj.skills)
批评
多重继承的批评者指出,它增加了复杂性,并使代码难以重用。 在这一点上,如果要将一个类复制到新程序,则也必须复制所有超类。
对于一个类来说,这可能很好,但是如果您的代码到处都有多重继承,则很难将部件用作其他程序的可重用组件。
实际上,向程序添加多个继承会在类之间创建强大的内聚力。 但这并不意味着它不是有用的工具。
练习
试试这些练习:
- 所有编程语言都支持多重继承吗?
- 为什么不使用多重继承?
- 可以继承的类的数量是否有限制?
在上面的练习部分中下载答案。
高级
虚拟环境
virtualenv
可以创建隔离的 Python 环境。
Python 默认情况下在系统范围内安装模块。 如果程序需要同一模块的不同版本,则可能会成为问题。
这与其他未在系统范围内安装模块的编程语言不同。想象两个 Python 应用程序,其中一个需要 libBar 1.0,另一个需要 libBar 2.0。
virtualenv
通过创建隔离的环境巧妙地解决了这个问题。 模块将仅安装在虚拟环境中。 在您的环境内部,您可以安装任何模块而不会影响系统范围的配置。
设置
程序virtualenv
可以解决。 它使您可以创建虚拟环境。要创建虚拟环境,请使用以下命令:
virtualenv -p python3 envname
其中envname
是您的项目名称。 如果将项目命名为testproject
,则会得到以下一行:
virtualenv -p python3 testproject
这将使用以下子目录创建文件夹virtualenv
:bin
,include
,lib
和share
。
加载虚拟环境类型
cd testproject
bin/activate
现在,您的虚拟环境已激活。Shell 将显示当前已加载的虚拟环境。
要返回正常环境,请键入
deactivate
您可以根据需要创建任意数量的虚拟环境。 每个项目都应该有自己的virtualenv
,因为它需要不需要在系统范围内安装的特定模块。
练习
请尝试以下练习:
- 为项目设置一个新的虚拟环境并激活它。 使用
pip
安装模块。
枚举
枚举是一个内置函数,它返回一个枚举对象。
调用是enumerate(sequence, start=0)
输出对象包括一个计数器,如下所示:(0, thing [0]), (1, thing [1]), (2, thing [2])
,依此类推。
作为输入,它需要一个类似于列表,元组或迭代器的序列。start
参数是可选的。
如果起始参数设置为 1,则计数将从 1 开始而不是从 0 开始
枚举对象
创建一个序列并将其提供给枚举函数。 这可以是任何类型的序列,在此示例中,我们使用列表。 然后我们输出对象。
请尝试以下程序:
# create a sequence
browsers = ['Chrome','Firefox','Opera','Vivaldi']
# create an enumeratable and convert to list
x = list(enumerate(browsers))
print(x)
您应该看到以下输出:
返回的对象可以像迭代器一样对待:下一个方法调用将起作用:
browsers = ['Chrome','Firefox','Opera','Vivaldi']
eObj = enumerate(browsers)
x = next(eObj)
print(x)
x = next(eObj)
print(x)
练习
试试下面的练习
- 将
for
循环与enumerate
相结合。
Pickle
Pickle 可用于序列化和反序列化对象。 可以将已序列化的对象保存并从磁盘加载。 Pickle 是一种将对象(列表,字典等)转换为文件,反之亦然的方法。
这个想法是在一个脚本中保存一个或多个对象,然后在另一个脚本中加载它们。 您也可以使用它来保存程序或游戏状态。
我们将使用二进制文件进行保存和加载,因为这样可以节省磁盘空间。
序列化对象
要使用 Pickle,请导入pickle
模块。创建一个对象并将其序列化。 然后使用文件对象将其写入文件。
import pickle
exampleObj = {'Python':3,'KDE':5,'Windows':10}
fileObj = open('data.obj', 'wb')
pickle.dump(exampleObj,fileObj)
fileObj.close()
反序列化对象
现在,该对象已保存到文件中,您可以加载它(解开它)。 在下面的示例中,我们从文件中加载对象。
加载pickle
模块,打开然后读取文件,然后使用pickle.load()
加载数据。 您可以将其加载到所需的任何变量中,但是为了方便起见,我使用了相同的名称(exampleObj
)。
import pickle
fileObj = open('data.obj', 'rb')
exampleObj = pickle.load(fileObj)
fileObj.close()
print(exampleObj)
这将向您显示以前保存的对象:
练习
请尝试以下练习:
- 从文件保存和加载对象
- 尝试从文件加载多个对象
正则表达式
re
模块处理 Python 中的正则表达式
正则表达式可用于查找字符串中的所有匹配项,或仅测试匹配项是否存在。
正则表达式可以帮助您快速地从大量数据中收集一些项目,只需定义一些语法规则即可。
示例
创建一个字符串以运行正则表达式。 作为示例短语,我们将使用美国著名的绕口令"wouldchuck"
。
使用正则表达式查找字符串的所有匹配项。 使用正则表达式和搜索空间作为参数调用方法findall()
。
请尝试以下程序:
import re
string = "How much wood would a woodchuck chuck if a woodchuck could chuck wood?"
matches = re.findall(r'woo\w*', string)
print(matches)
它返回正则表达式的匹配项。我们定义起始字母"woo"
,后跟匹配零次或多次(*
)的单词字符\w
。
要测试数据是否匹配正则表达式,请使用搜索方法。 返回true
或false
,可以与if
语句匹配:
if re.search(r'woo\w*', string):
print('woo\w* foud!')
else:
print('not found')
如果要编写自己的正则表达式,请检查此备忘单。
练习
- 找出正则表达式是否区分大小写
- 为电话号码创建正则表达式
JSON 和 python
了解如何使用 python 解析 JSON 对象。
JavaScript Object Notation(JSON)是一种数据交换格式。 虽然最初是为 JavaScript 设计的,但如今,许多计算机程序都与 Web 交互并使用 JSON。
与网络的交互通常是通过 JSON 格式的 API(应用程序可编程接口)完成的。
python JSON 示例
解析 JSON
您可以使用 python 解析 JSON 对象。 然后,该对象将转换为 python 对象。
首先创建一个 json 对象
{
"gold": 1271,
"silver": 1284,
"platinum": 1270
}
之后像这样解析 JSON 对象:
import json
obj = json.loads('{"gold": 1271,"silver": 1284,"platinum": 1270}')
print(obj['gold'])
从 URL 解析 JSON
您可以直接从网络上获取 JSON 对象,并将其转换为 python 对象。 这是通过 API 端点完成的
import json
import urllib.request
# download raw json object
url = "https://api.gdax.com/products/BTC-EUR/ticker"
data = urllib.request.urlopen(url).read().decode()
# parse json object
obj = json.loads(data)
# output some object attributes
print('$ ' + obj['price'])
print('$ ' + obj['volume'])
python 读取 json 文件
在 python 中读取 json 文件非常容易。 在本文中,我们将说明如何从磁盘读取 JSON 文件并在 python 中使用它。
什么是 JSON?JSON 是一种在整个 Internet 上使用的数据交换格式。 JSON (JavaScript 对象表示法)可用于所有高级编程语言。
如何在 python 中使用 JSON?这种工作方式是首先在磁盘上放置一个 json 文件。然后,程序将加载文件进行解析,解析,然后即可使用它。
python 读取 json
JSON 文件
在磁盘上创建一个文件(命名为:example.json
)。 下面的 python 程序读取 json 文件并直接使用值。
该文件可以包含一个衬纸。example.json
的文件内容为:
{"usd":1,"eur":1.2,"gbp": 1.2}
将文件保存为example.json
。
python 示例
然后在下面创建程序并运行:
import json
# read file
with open('example.json', 'r') as myfile:
data=myfile.read()
# parse file
obj = json.loads(data)
# show values
print("usd: " + str(obj['usd']))
print("eur: " + str(obj['eur']))
print("gbp: " + str(obj['gbp']))
上面的程序将打开文件example.json
并进行解析。 您可以像访问任何变量一样访问 JSON 数据。
装饰器
在本教程中学习 Python 装饰器。
使用装饰器向现有函数添加功能。 这称为元编程。
一个函数可以将一个函数作为参数(要修饰的函数),并返回带或不带扩展名的相同函数。
扩展函数有时非常有用,我们将在本文稍后展示真实的示例。
函数是对象
在 Python 中,一切都是对象,包括函数。 这意味着函数可以传递并返回。 当您看到它时,乍一看可能很奇怪:
def hello():
print("Hello")
# even functions are objects
message = hello
# call new function
message()
调用message()
或hello()
方法,它们具有相同的输出。 那是因为他们指的是同一个对象。
现在让我们继续装饰。
装饰器
示例
装饰器接受一个函数,对其进行扩展并返回。 是的,函数可以返回函数。
def hello(func):
def inner():
print("Hello ")
func()
return inner
def name():
print("Alice")
obj = hello(name)
obj()
在上面的示例中,hello()
是装饰器。
在
语句中
obj = hello(name)
函数name()
由函数hello()
装饰。
它将函数包装在另一个函数中。
示例 2
可以通过包装函数来扩展它们。
def who():
print("Alice")
def display(func):
def inner():
print("The current user is : ", end="")
func()
return inner
if __name__ == "__main__":
myobj = display(who)
myobj()
who()
函数由display()
装饰。
语法糖
装饰器是常见的,可以简化。 尽管功能完全相同,但代码更简洁。
Python 可以使用@
符号简化装饰器的使用。
@hello
def name():
print("Alice")
if __name__ == "__main__":
name()
这将输出完全相同的内容,但是是编写代码的更简洁的方法。
跟我在一起。调用:
@hello
def name():
只是一种更简单的书写方式:
obj = hello(name)
在这两种情况下,我们都将装饰器应用于函数。
参数
参数可以与装饰器一起使用。 如果您有一个打印总和a + b
的函数,例如
def sumab(a,b):
summed = a + b
print(summed)
您可以将其包装在装饰器函数中。以下示例显示了如何执行此操作:
def pretty_sumab(func):
def inner(a,b):
print(str(a) + " + " + str(b) + " is ", end="")
return func(a,b)
return inner
@pretty_sumab
def sumab(a,b):
summed = a + b
print(summed)
if __name__ == "__main__":
sumab(5,3)
函数sumab
由函数pretty_sumab
包装。 这用其上方的@
符号表示。
调用函数sumab
,并查看带有参数的函数sumab
和pretty_sumab
的逻辑都已运行。
真实示例
用例:时间测量
装饰器可用于测量函数执行所需的时间。
如果您定义了一个休眠的简单函数,则
def myFunction(n):
time.sleep(n)
然后,您只需添加@measure_time
行即可测量所需的时间
下面的例子:
import time
def measure_time(func):
def wrapper(*arg):
t = time.time()
res = func(*arg)
print("Function took " + str(time.time()-t) + " seconds to run")
return res
return wrapper
@measure_time
def myFunction(n):
time.sleep(n)
if __name__ == "__main__":
myFunction(2)
这将输出执行函数myFunction()
所花费的时间。 很酷的事情是,通过添加一行代码@measure_time
,我们现在可以测量程序执行时间。
用例:Web 应用程序
让我们以 Web 应用程序的使用案例为例。 在 Flask 中构建 Web 应用程序时,您始终会编写网址路由。
每个路由都是 Web 应用程序中的特定页面。打开页面/about
可以调用about_page()
方法。
@app.route("/about")
def about_page():
return "Website about nachos"
在这种情况下,它使用@
符号进行装饰。
网络服务器
Python 中的网络服务器可以通过两种方式设置。 Python 开箱即用地支持 Web 服务器。 您可以使用一个衬垫启动 Web 服务器。
但是,您也可以创建具有独特功能的自定义 Web 服务器。 在本文中,您将学习如何做到这一点。
此示例中的 Web 服务器只能在本地网络上访问。 它可以是localhost
或其他网络主机。 您可以使用 VPN 跨位置投放。
示例
内置网络服务器
要启动网络服务器,请运行以下命令:
python3 -m http.server
这将在端口 8080 上打开 Web 服务器。然后,您可以在 http://127.0.0.1:8080/ 中打开浏览器。
也可以使用您的192.168.*.*
地址通过网络访问 Web 服务器。
这是默认服务器,可用于从计算机下载文件。
Web 服务器
运行以下代码以启动自定义 Web 服务器。 要创建自定义 Web 服务器,我们需要使用 HTTP 协议。
通过设计,http 协议有一个“获取”请求,该请求返回服务器上的文件。 如果找到该文件,它将返回 200。
服务器将从端口 8080 开始,并接受默认的 Web 浏览器请求。
# Python 3 server example
from http.server import BaseHTTPRequestHandler, HTTPServer
import time
hostName = "localhost"
serverPort = 8080
class MyServer(BaseHTTPRequestHandler):
def do_GET(self):
self.send_response(200)
self.send_header("Content-type", "text/html")
self.end_headers()
self.wfile.write(bytes("<html><head><title>https://pythonbasics.org</title></head>", "utf-8"))
self.wfile.write(bytes("<p>Request: %s</p>" % self.path, "utf-8"))
self.wfile.write(bytes("<body>", "utf-8"))
self.wfile.write(bytes("<p>This is an example web server.</p>", "utf-8"))
self.wfile.write(bytes("</body></html>", "utf-8"))
if __name__ == "__main__":
webServer = HTTPServer((hostName, serverPort), MyServer)
print("Server started http://%s:%s" % (hostName, serverPort))
try:
webServer.serve_forever()
except KeyboardInterrupt:
pass
webServer.server_close()
print("Server stopped.")
如果打开类似 http://127.0.0.1/example 的网址,则会调用do_GET()
方法。 我们通过这种方法手动发送网页。
变量self.path
返回所请求的 Web 浏览器 URL。 在这种情况下,它将是/example
音频
用 Python 播放声音
在 Python 上播放声音很容易。 有几个模块可以播放声音文件(.wav
)。
这些解决方案是跨平台的(Windows,Mac,Linux)。
主要区别在于易用性和受支持的文件格式。 所有这些都应与 Python 3 一起使用。除非您指定路径,否则音频文件应与 python 程序位于同一目录中。
让我们探讨一下选项!
用 Python 播放声音
playsound
模块
playsound
模块是可以播放音频文件的跨平台模块。 它没有任何依赖性,只需在您的virtualenv
中使用pip
安装并运行即可!
from playsound import playsound
playsound('audio.mp3')
在平台上的实现是不同的。 它在 Windows 上使用windll.winm
,在 Apple OS X 上使用AppKit.NSSound
,在 Linux 上使用GStreamer
。
我已经使用 Python 3.5.3。进行了测试。 这对 WAV 和 MP3 文件均适用。
pydub
您可以使用pydub
模块播放声音文件。 可以在 PyPI 储存库中(随pip
一起安装)。此模块可以在下面使用 PyAudio 和ffmpeg
。
from pydub import AudioSegment
from pydub.playback import play
song = AudioSegment.from_wav("sound.wav")
play(song)
tksnack
tksnack
模块声音套件可以播放多个音频文件:WAV,AU,AIFF,MP3,CSL,SD,SMP 和 NIST/Sphere。
您可以使用包管理器进行安装:apt install python3-tksnack
。 对于旧版本,有python-tksnack
。
该模块取决于 Tkinter。 这意味着要使用此模块播放声音,您还必须导入 gui 模块 Tkinter。 该模块似乎暂时没有更新。
from Tkinter import *
import tkSnack
root = Tk()
tkSnack.initializeSnack(root)
snd = tkSnack.Sound()
snd.read('sound.wav')
snd.play(blocking=1)
本机播放器
您还可以在系统上本地播放声音。 这要求您在终端上安装某种音频播放器。 在 Linux 上,您可以使用mpg123
。
这只是通过外部播放器播放 mp3 文件。
# apt install mpg123
import os
file = "file.mp3"
os.system("mpg123 " + file)
python 文字转语音
文字转语音(TTS)是将书面文字转换为语音的方式。您可以使用 python 创建 TTS 程序。 语音的质量取决于您的语音引擎。
在本文中,您将学习如何创建自己的 TTS 程序。
python 中的文字转语音
espeak 示例
程序“espeak”是一个简单的语音合成器,可以将书面文本转换为语音。 espeak 程序听起来确实有点机器人化,但是它足够简单,可以构建一个基本程序。
import subprocess
def execute_unix(inputcommand):
p = subprocess.Popen(inputcommand, stdout=subprocess.PIPE, shell=True)
(output, err) = p.communicate()
return output
a = "Say something in natural language."
# create wav file
# w = 'espeak -w temp.wav "%s" 2>>/dev/null' % a
# execute_unix(w)
# tts using espeak
c = 'espeak -ven+f3 -k5 -s150 --punct="<characters>" "%s" 2>>/dev/null' % a
execute_unix(c)
TTS 与 Google
Google 听起来很自然。 您可以将其 TTS 引擎与以下代码一起使用。
对于此程序,您需要安装模块 gTTS 以及程序 mpg123。
# need gTTS and mpg123
# pip install gTTS
# apt install mpg123
from gtts import gTTS
import os
# define variables
s = "escape with plane"
file = "file.mp3"
# initialize tts, create mp3 and play
tts = gTTS(s, 'en')
tts.save(file)
os.system("mpg123 " + file)
这将输出语音/ mp3 文件。
将 MP3 转换为 WAV
您可以在 Python 中将 MP3 直接转换为 WAV。 在本文中,我们将使用 Python 3 进行转换。 对于本教程,任何文件都可以使用。
首先,请先安装ffmpeg
。 ffmpeg
是用于音频,视频和多媒体处理的免费程序。 该程序具有控制台界面,但是除了安装它外,没有什么必要。
示例
pydub
安装模块pydub
。 这是 Python 的音频处理模块。 该模块可以打开许多多媒体音频和视频格式。 您可以使用pip
安装此模块。
pip install pydub
如果尚未安装ffmpeg
,请安装它。 您可以使用包管理器来执行此操作。
对于 Ubuntu/Debian Linux:
apt-get install ffmpeg
MP3 到 WAV 的转换
您可以通过更改变量名称将 mp3 文件(源)转换为 wav 文件(目标)。
mp3 文件必须与程序(.py
)位于同一目录中。 如果要使用自定义目录,请在文件名中添加路径。
from os import path
from pydub import AudioSegment
# files
src = "transcript.mp3"
dst = "test.wav"
# convert wav to mp3
sound = AudioSegment.from_mp3(src)
sound.export(dst, format="wav")
上面的程序使用pydub
模块进行转换。 该模块本身使用ffmpeg
,这意味着必须安装ffmpeg
才能成功。
运行:
python3 convert.py
等待程序完成。
您的目录中应该有另一个文件:
转录音频
您可以使用 Python 自动转录音频文件。
如果您有一个带有口语单词的音频文件,则程序将完全自动输出该音频文件的转录本。
本示例使用英语作为音频文件的输入语言,但是从技术上讲,只要语音识别引擎支持,就可以使用任何语言。
示例
首先创建带有语音的音频文件。 这可以是任何带有英语单词的音频文件。 将文件另存为transcript.mp3
如果不确定从哪里获得语音音频文件,则可以使用 Bluemix 生成一个语音文件。
安装必备组件
要运行该应用程序,您需要安装以下几项:
- Python 3
- pydub 模块
- 程序 ffmpeg
- 模块语音识别
您可以使用 pip 安装 Python 模块。ffmpeg
可以与您的软件包管理器一起安装(apt-get
,emerge
,yum
,pacman
)
转录
音频转录可以通过几个步骤进行:
- mp3 到 WAV 转换,
- 加载音频文件,
- 将音频文件提供给特定的识别系统。
复制下面的程序,并将其另存为transcribe.py
import speech_recognition as sr
from os import path
from pydub import AudioSegment
# convert mp3 file to wav
sound = AudioSegment.from_mp3("transcript.mp3")
sound.export("transcript.wav", format="wav")
# transcribe audio file
AUDIO_FILE = "transcript.wav"
# use the audio file as the audio source
r = sr.Recognizer()
with sr.AudioFile(AUDIO_FILE) as source:
audio = r.record(source) # read the entire audio file
print("Transcription: " + r.recognize_google(audio))
使用以下程序运行程序:
python3 transcribe.py
它将输出原始音频文件的转录。
Tkinter
Tkinter
Tkinter 是 Python 的图形用户界面(GUI)模块,您可以使用 Python 制作桌面应用程序。 您可以制作窗口,按钮,显示文字和图像等。
Tk 和 Tkinter 应用程序可以在大多数 Unix 平台上运行。 这也适用于 Windows 和 Mac OSX。
模块 Tkinter 是 Tk GUI 工具包的接口。
示例
Tkinter 模块
本示例打开一个空白的桌面窗口。 Tkinter 模块是标准库的一部分。
要使用 Tkinter,请导入 Tkinter 模块。
from tkinter import *
这是带有下划线t
的 Tkinter,在 Python 3 中已重命名。
设置窗口
启动 TK 并创建一个窗口。
root = Tk()
app = Window(root)
Window
类不是标准的,我们创建一个Window
。 此类本身非常基础。
class Window(Frame):
def __init__(self, master=None):
Frame.__init__(self, master)
self.master = master
然后设置窗口标题并显示该窗口:
# set window title
root.wm_title("Tkinter window")
# show window
root.mainloop()
Tkinter 窗口示例
下面的程序显示了一个空的 Tkinter 窗口。
使用以下程序运行:
from tkinter import *
class Window(Frame):
def __init__(self, master=None):
Frame.__init__(self, master)
self.master = master
# initialize tkinter
root = Tk()
app = Window(root)
# set window title
root.wm_title("Tkinter window")
# show window
root.mainloop()
Tkinter 按钮
按钮是 GUI 中的标准小部件。 它们带有默认的 Tkinter 模块,您可以将它们放在窗口中。
Python 函数或方法可以与按钮关联。 该函数或方法称为回调函数。 如果单击该按钮,则会调用回调函数。
关于按钮的注释:tkinter 按钮只能显示单一字体的文本。 按钮文字可以是多行。 这意味着此小部件不会在文本旁边显示图标,因为您需要另一个小部件。
示例
简介
您可以使用以下几行创建并放置按钮:
exitButton = Button(self, text="Exit", command=self.clickExitButton)
exitButton.place(x=0, y=0)
回调方法是clickExitButton
,该方法在上一行(command =
)中分配。这是一种简单的方法:
def clickExitButton(self):
exit()
如果没有回调方法,则会显示一个按钮,但是单击该按钮不会执行任何操作。
该窗口应显示:
按钮示例
要运行该示例,请将其另存为button.py
并使用 python 解释器运行它。
此示例打开一个窗口,显示一个按钮,您可以单击该按钮。
from tkinter import *
class Window(Frame):
def __init__(self, master=None):
Frame.__init__(self, master)
self.master = master
# widget can take all window
self.pack(fill=BOTH, expand=1)
# create button, link it to clickExitButton()
exitButton = Button(self, text="Exit", command=self.clickExitButton)
# place button at (0,0)
exitButton.place(x=0, y=0)
def clickExitButton(self):
exit()
root = Tk()
app = Window(root)
root.wm_title("Tkinter button")
root.geometry("320x200")
root.mainloop()
Tkinter 菜单
Tkinter 菜单是顶级下拉菜单。 正如您希望传统 gui 应用程序所期望的那样,它们显示在标题栏下方。
该菜单可以具有多个子菜单,并且每个子菜单都可以包含项目。 菜单项可以与回调方法相关联,这意味着单击它们时将调用 Python 方法。
示例
简介
添加菜单非常简单,但是如果您是第一次使用它,可能会有些混乱。 首先使用以下几行创建顶部菜单:
self.master = master
menu = Menu(self.master)
self.master.config(menu=menu)
然后,您可以将菜单添加到此菜单:
fileMenu = Menu(menu)
menu.add_cascade(label="File", menu=fileMenu)
editMenu = Menu(menu)
menu.add_cascade(label="Edit", menu=editMenu)
这些子菜单中的每个子菜单都可以包含以下项目:
fileMenu.add_command(label="Item")
fileMenu.add_command(label="Exit", command=self.exitProgram)
editMenu.add_command(label="Undo")
editMenu.add_command(label="Redo")
菜单项可以单击,您可以按与按钮(command =
)相同的方式指定回调方法。 单击后将调用 Python 方法。
Tkinter 菜单示例
下面的菜单示例将菜单添加到基本的 tkinter 窗口。 它具有一个可单击的菜单项,但显示完整的菜单。
from tkinter import *
class Window(Frame):
def __init__(self, master=None):
Frame.__init__(self, master)
self.master = master
menu = Menu(self.master)
self.master.config(menu=menu)
fileMenu = Menu(menu)
fileMenu.add_command(label="Item")
fileMenu.add_command(label="Exit", command=self.exitProgram)
menu.add_cascade(label="File", menu=fileMenu)
editMenu = Menu(menu)
editMenu.add_command(label="Undo")
editMenu.add_command(label="Redo")
menu.add_cascade(label="Edit", menu=editMenu)
def exitProgram(self):
exit()
root = Tk()
app = Window(root)
root.wm_title("Tkinter window")
root.mainloop()
Tkinter 标签
Tkinter 标签窗口小部件可用于在屏幕上显示文本或图像。 标签只能显示单一字体的文本。 文本可以跨越多行。
您可以在标签中放置任何文本,并且在窗口中可以具有多个标签(就像在窗口中可以多次放置任何小部件一样)。
示例
简介
只需两行代码即可添加标签。 第一行定义标签和文本。 第二行设置二维位置:
text = Label(self, text="Just do it")
text.place(x=70,y=90)
您可以更改字体颜色或标签大小:
label1 = Label(master, text="Tkinter", fg="red")
label1 = Label(master, text="Helvetica", font=("Helvetica", 18))
Tkinter 标签示例
本示例在屏幕上显示一个标签。 这是 Tkinter 著名的“hello world”程序,但是我们决定更改文本。
如果您没有为标签窗口小部件指定大小,则将其大小设置为足以适合文本的大小。
from tkinter import *
class Window(Frame):
def __init__(self, master=None):
Frame.__init__(self, master)
self.master = master
self.pack(fill=BOTH, expand=1)
text = Label(self, text="Just do it")
text.place(x=70,y=90)
#text.pack()
root = Tk()
app = Window(root)
root.wm_title("Tkinter window")
root.geometry("200x200")
root.mainloop()
Tkinter 时钟
Tkinter 标签正在使用双缓冲技术。 此技术可防止在更新屏幕时轻拂屏幕。
您可以说一个时钟每秒更新一次,但不会看到任何闪烁。 该技术目前非常标准,我们不希望在 GUI 窗口中有任何滑动。
时钟可以简单地添加一个计时器功能,如下所示:
from tkinter import *
import time
class App(Frame):
def __init__(self,master=None):
Frame.__init__(self, master)
self.master = master
self.label = Label(text="", fg="Red", font=("Helvetica", 18))
self.label.place(x=50,y=80)
self.update_clock()
def update_clock(self):
now = time.strftime("%H:%M:%S")
self.label.configure(text=now)
self.after(1000, self.update_clock)
root = Tk()
app=App(root)
root.wm_title("Tkinter clock")
root.geometry("200x200")
root.after(1000, app.update_clock)
root.mainloop()
那将显示此时钟自动更新:
Tkinter 图片
图像可以用 Tkinter 显示。 图像可以采用多种格式,包括 jpeg 图像。 有点违反直觉,但是您可以使用标签显示图像。
要打开图像,请使用Image.open(filename)
方法。 这将在程序目录中查找图像,对于其他目录,将路径添加到文件名。
示例
简介
本示例加载并在标签上显示图像。 就像在 Tkinter 窗口上显示文本一样简单,但是我们显示的是图像而不是文本。
您应该安装 Python 图像库(PIL)来加载图像。 这是必需的,并且该模块在 PyPi 中可用。 使用 pip 软件包管理器安装该模块。
它可以打开各种图像格式,包括 PPM,PNG,JPEG,GIF,TIFF 和 BMP。
加载图像:
load = Image.open("parrot.jpg")
render = ImageTk.PhotoImage(load)
然后将其与标签关联:
img = Label(self, image=render)
img.image = render
img.place(x=0, y=0)
Tkinter 图像示例
您可以打开一个窗口,添加标签并将图像与之关联。 在此示例中,我们加载 jpeg 图像,但是您可以加载任何图像。
下面是一个完整的示例:
from tkinter import *
# pip install pillow
from PIL import Image, ImageTk
class Window(Frame):
def __init__(self, master=None):
Frame.__init__(self, master)
self.master = master
self.pack(fill=BOTH, expand=1)
load = Image.open("parrot.jpg")
render = ImageTk.PhotoImage(load)
img = Label(self, image=render)
img.image = render
img.place(x=0, y=0)
root = Tk()
app = Window(root)
root.wm_title("Tkinter window")
root.geometry("200x120")
root.mainloop()
Tkinter 画布
Tkinter 画布可用于在窗口中绘制。 使用此小部件可以绘制图形或绘图。 您甚至可以使用它来创建图形编辑器。
您可以在画布上绘制几个小部件:弧形,图像,直线,矩形,文本,切片,椭圆形,多边形,椭圆形,多边形和矩形。 矩形可以是轮廓,也可以是内部。
画布具有两个坐标系:窗口系统(左上角x = 0
,y = 0
)和定义项目绘制位置的画布坐标系。
示例
简介
画布是一个通用的小部件:您可以使用它来制作任何类型的图形,包括绘图,绘图,图表,显示图像等等。
画布添加了一行代码:
myCanvas = tkinter.Canvas(root, bg="white", height=300, width=300)
这定义了添加位置,背景和大小。 创建后,您可以在其顶部进行绘制。
如果要绘制弧,只需调用其方法create_arc()
:
arc = myCanvas.create_arc(coord, start=0, extent=150, fill="red")
Tkinter 画布
将画布添加到 TK 窗口并在其中进行绘制非常容易。此示例打开一个窗口,添加一个画布并在其中绘制两个弧线。 该程序将绘制两个弧,一个绿色的弧和一个红色的弧,它们共同构成一个圆。
import tkinter
# init tk
root = tkinter.Tk()
# create canvas
myCanvas = tkinter.Canvas(root, bg="white", height=300, width=300)
# draw arcs
coord = 10, 10, 300, 300
arc = myCanvas.create_arc(coord, start=0, extent=150, fill="red")
arv2 = myCanvas.create_arc(coord, start=150, extent=215, fill="green")
# add to window and show
myCanvas.pack()
root.mainloop()
Tkinter 复选框
复选框小部件非常明显,您根本无需考虑它们。 它们就像开/关开关,您可以有多个开关。 它是 Tkinter 中包含的小部件之一。
如果您希望单击零个或多个选项,则可以使用一个复选框。 否则,您将使用单选按钮或其他类型的按钮。
复选框
Tkinter 复选框
Tkinter 复选框小部件是一个非常基本的开关。 Tkinter 中的复选框称为CheckButton
。 您可以添加两个复选框,如下所示:
c1 = tk.Checkbutton(window, text='Python',variable=var1, onvalue=1, offvalue=0, command=print_selection)
c1.pack()
c2 = tk.Checkbutton(window, text='C++',variable=var2, onvalue=1, offvalue=0, command=print_selection)
c2.pack()
示例
下面的程序在窗口中添加了几个检查按钮。 如果单击复选框,则上面的文本会更改。
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import tkinter as tk
window = tk.Tk()
window.title('My Window')
window.geometry('100x100')
l = tk.Label(window, bg='white', width=20, text='empty')
l.pack()
def print_selection():
if (var1.get() == 1) & (var2.get() == 0):
l.config(text='I love Python ')
elif (var1.get() == 0) & (var2.get() == 1):
l.config(text='I love C++')
elif (var1.get() == 0) & (var2.get() == 0):
l.config(text='I do not anything')
else:
l.config(text='I love both')
var1 = tk.IntVar()
var2 = tk.IntVar()
c1 = tk.Checkbutton(window, text='Python',variable=var1, onvalue=1, offvalue=0, command=print_selection)
c1.pack()
c2 = tk.Checkbutton(window, text='C++',variable=var2, onvalue=1, offvalue=0, command=print_selection)
c2.pack()
window.mainloop()
Tkinter 输入框
使用 Tkinter 输入框,您可以在桌面软件中输入文本。 通常,输入框(输入字段)会带有标签,这是因为如果没有标签,则不清楚用户应该在此处键入什么内容。
您可以添加多个输入字段。 输入字段可以显示拉丁字符,但也可以显示其他类型的输入(例如密码)
输入框
Tkinter 输入框
使用 Tkinter 输入框可以输入 GUI。 下面的代码将一个输入框添加到 GUI。 第一个参数是要添加的内容,文本参数定义了要放置在其旁边的内容。
#!/usr/bin/python
# -*- coding: UTF-8 -*-
from tkinter import *
top = Tk()
L1 = Label(top, text="Label")
L1.pack(side=LEFT)
E1 = Entry(top, bd=5)
E1.pack(side=RIGHT)
top.mainloop()
Tkinter 密码输入
Tkinter 条目可以是纯文本,但也支持密码输入。 通过更改参数show
,可以使其看起来像您想要的任何东西。
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import tkinter as tk
window = tk.Tk()
window.title('My Window')
window.geometry('500x300')
e1 = tk.Entry(window, show=None, font=('Arial', 14))
e2 = tk.Entry(window, show='*', font=('Arial', 14))
e1.pack()
e2.pack()
window.mainloop()
Tkinter 文件对话框
文件对话框可帮助您打开,保存文件或目录。 这是单击文件后打开的对话框的类型。 该对话框来自模块,无需手动编写所有代码。
Tkinter 没有本机外观的文件对话框,而是具有客户 TK 样式。 您可以在下面看到这些。
文件对话框将在所有桌面平台上运行。
文件对话框
Tkinter 文件对话框
Tkinter 文件对话框有几种类型。 您真正需要哪种类型取决于您的应用程序需求。 它们都是方法调用。
您可以打开一个文件,一个目录,另存为文件等等。
import tkinter.filedialog
tkinter.filedialog.asksaveasfilename()
tkinter.filedialog.asksaveasfile()
tkinter.filedialog.askopenfilename()
tkinter.filedialog.askopenfile()
tkinter.filedialog.askdirectory()
tkinter.filedialog.askopenfilenames()
tkinter.filedialog.askopenfiles()
Tkinter 框架
Tk 中的框架可让您组织和分组小部件。 它像一个容器一样工作。 它是可以放置遗物的矩形区域。
如果您制作的是 GUI 应用,则将使用其他小部件。 这些小部件需要以某种方式进行组织,这就是框架的来源。
Tkinter 框架按钮
下面的 Tkinter 程序演示了框架的使用。 它包括带有回调函数的按钮。 框架可以有填充。
from tkinter import *
def say_hi():
print("hello ~ !")
root = Tk()
frame1 = Frame(root)
frame2 = Frame(root)
root.title("tkinter frame")
label= Label(frame1,text="Label",justify=LEFT)
label.pack(side=LEFT)
hi_there = Button(frame2,text="say hi~",command=say_hi)
hi_there.pack()
frame1.pack(padx=1,pady=1)
frame2.pack(padx=10,pady=10)
root.mainloop()
Tkinter 框架照片
可以添加不同类型的小部件。 该示例具有 Tkinter 框架照片。 它还有一个标签。 您可以向框架添加任何类型的小部件。
from tkinter import *
root = Tk()
textLabel = Label(root,
text="Label",
justify=LEFT,
padx=10)
textLabel.pack(side=LEFT)
photo = PhotoImage(file="cat.png")
imgLabel = Label(root, image=photo)
imgLabel.pack(side=RIGHT)
mainloop()
Tkinter 框架
下面的 Tkinter 程序添加了不同颜色的多个框架。 它们都具有相同的宽度和高度。 换句话说,您可以更改框架的样式。
from tkinter import *
root = Tk()
for fm in ['blue','red','yellow','green','white','black']:
Frame(height = 20,width = 640,bg = fm).pack()
root.mainloop()
Tkinter 列表框
列表框显示选项列表。 然后,您可以单击任何这些选项。 默认情况下,它不会执行任何操作,但是您可以将其链接到回调函数或单击按钮。
要添加新项目,可以使用insert()
方法。 这接受单个参数或项目列表。
Tkinter 列表框
如果您有多个项目,则可以使用列表框。 下面的 Tkinter 列表框示例显示了不同的项目。 这是一个交互式程序,您可以单击并更改值。
这不是组合框,请参见下面的屏幕截图。
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import tkinter as tk
window = tk.Tk()
window.title('My Window')
window.geometry('500x300')
var1 = tk.StringVar()
l = tk.Label(window, bg='green', fg='yellow',font=('Arial', 12), width=10, textvariable=var1)
l.pack()
def print_selection():
value = lb.get(lb.curselection())
var1.set(value)
b1 = tk.Button(window, text='print selection', width=15, height=2, command=print_selection)
b1.pack()
var2 = tk.StringVar()
var2.set((1,2,3,4))
lb = tk.Listbox(window, listvariable=var2)
list_items = [11,22,33,44]
for item in list_items:
lb.insert('end', item)
lb.insert(1, 'first')
lb.insert(2, 'second')
lb.delete(2)
lb.pack()
window.mainloop()
Tkinter 消息框
消息框是一个显示消息的小弹出窗口。 有时它伴随着一个图标。 几乎所有时间,它都会中断用户的操作。
下面的示例向您展示如何使用 Tkinter 创建和使用消息框。 此处显示的代码适用于 Python 3.x 和更高版本。 较旧的 Python 导入和使用 Tkinter 的方式有所不同。
消息框
消息框
消息框有很多变体。 您可以有一条信息消息,警告消息或错误消息。 所有这些消息框都有标题和消息。
#!/usr/bin/python3
import tkinter
import tkinter.messagebox
tkinter.messagebox.showinfo('title','message')
tkinter.messagebox.showwarning('title','message')
tkinter.messagebox.showerror('title','message')
点击和消息框
下面的示例仅在单击按钮时显示一个消息框。 这类似于现实世界中出现问题时显示消息框的情况。
import tkinter
import tkinter.messagebox
def buttonClick():
tkinter.messagebox.showinfo('title', 'message')
#tkinter.messagebox.showwarning('title', 'message')
#tkinter.messagebox.showerror('title', 'message')
root=tkinter.Tk()
root.title('GUI')
root.geometry('100x100')
root.resizable(False, False)
tkinter.Button(root, text='hello button',command=buttonClick).pack()
root.mainloop()
Tkinter 单选按钮
单选按钮使您可以从各种项目中进行选择。 它们是默认 TK 模块的一部分。 与复选框不同,Tkinter 仅允许您选择一个选项。
您可以通过为单选按钮添加与参数相同的变量来实现。 如果单击单选按钮,则可以调用回调函数。
单选按钮
Tkinter 单选按钮
下面的程序使用方法Radiobutton
创建 3 个单选按钮。 它添加了一个窗口作为参数,文本,与之连接的变量以及回调函数。
为了使它起作用,所有单选按钮都需要链接到相同的变量,在此示例中为var
。
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import tkinter as tk
window = tk.Tk()
window.title('My Window')
window.geometry('500x300')
var = tk.StringVar()
l = tk.Label(window, bg='white', width=20, text='empty')
l.pack()
def print_selection():
l.config(text='you have selected ' + var.get())
r1 = tk.Radiobutton(window, text='Option A', variable=var, value='A', command=print_selection)
r1.pack()
r2 = tk.Radiobutton(window, text='Option B', variable=var, value='B', command=print_selection)
r2.pack()
r3 = tk.Radiobutton(window, text='Option C', variable=var, value='C', command=print_selection)
r3.pack()
window.mainloop()
Tkinter 刻度
您可以在窗口中添加刻度或滑块。 您可能通过音量控制对此很熟悉。 它可以是水平滑块或垂直滑块。
刻度具有您可以定义的最小值和最大值。 您可以设置移动滑块时调用的回调函数。
刻度
Tkinter 刻度
下面的 Tkinter 程序将创建一个刻度。 您可以定义最小值(from_
)和最大值(to
)。 要更改其方向,请更改orient
参数。
tickinterval
是您要设置的(如果不同于)。 您还可以设置其长度。
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import tkinter as tk
window = tk.Tk()
window.title('My Window')
window.geometry('500x300')
l = tk.Label(window, bg='white', fg='black', width=20, text='empty')
l.pack()
def print_selection(v):
l.config(text='you have selected ' + v)
s = tk.Scale(window, label='try me', from_=0, to=10, orient=tk.HORIZONTAL, length=200, showvalue=0,tickinterval=2, resolution=0.01, command=print_selection)
s.pack()
window.mainloop()
绘图
Matplotlib 条形图
条形图可以使用 Matplotlib 制作。 您可以创建各种颜色,位置,方向等变化的变体。 那么什么是 Matplotlib?
Matplotlib 是一个 Python 模块,可让您绘制各种图表。 条形图是可以绘制的图表类型之一。 条形图有许多不同的变体。
示例
条形图
bar()
方法创建一个条形图。 那么您如何使用它呢?下面的程序创建一个条形图。 我们向它提供水平和垂直(数据)数据。
#!/usr/bin/python3
import numpy as np
import pandas as pd
from pandas import Series, DataFrame
import matplotlib.pyplot as plt
data = [23, 45, 56, 78, 213]
plt.bar([1,2,3,4,5], data)
plt.show()
绘图颜色
您可以更改条形图的颜色。 为此,只需添加color
参数。可以将参数设置为英语颜色定义,例如'red'
。
例:
import numpy as np
import pandas as pd
from pandas import Series, DataFrame
import matplotlib.pyplot as plt
data = [23, 45, 56, 78, 213]
plt.bar(range(len(data)), data, color='red')
plt.show()
网格线
如果需要网格线,则可以这样做。 函数.grid()
具有颜色,线型,宽度和轴。 (可选)您可以添加一个alpha
值。
像这样的代码:
import numpy as np
import pandas as pd
from pandas import Series, DataFrame
import matplotlib.pyplot as plt
data = [23, 45, 56, 78, 213]
plt.bar(range(len(data)), data, color='royalblue', alpha=0.7)
plt.grid(color='#95a5a6', linestyle='--', linewidth=2, axis='y', alpha=0.7)
plt.show()
Matplotlib 标签
绘图需要描述。 如果观看者不知道数字代表什么,那么绘图的用途是什么。 您要添加标签吗?
下面的代码将标签添加到绘图中。
import numpy as np
import pandas as pd
from pandas import Series, DataFrame
import matplotlib.pyplot as plt
data = [23,85, 72, 43, 52]
labels = ['A', 'B', 'C', 'D', 'E']
plt.xticks(range(len(data)), labels)
plt.xlabel('Class')
plt.ylabel('Amounts')
plt.title('I am title')
plt.bar(range(len(data)), data)
plt.show()
多个图表
您可以在一个图中绘制多个条形图。 需要多个条形图?
下面的代码通过两次调用该方法来添加两个bar
绘图。 指定了宽度参数。
import numpy as np
import pandas as pd
from pandas import Series, DataFrame
import matplotlib.pyplot as plt
data1 = [23,85, 72, 43, 52]
data2 = [42, 35, 21, 16, 9]
width =0.3
plt.bar(np.arange(len(data1)), data1, width=width)
plt.bar(np.arange(len(data2))+ width, data2, width=width)
plt.show()
堆叠图
您可以将条形图彼此堆叠。 当您将多个值组合成更大的值时,这特别有用。
import numpy as np
import pandas as pd
from pandas import Series, DataFrame
import matplotlib.pyplot as plt
data1 = [23,85, 72, 43, 52]
data2 = [42, 35, 21, 16, 9]
plt.bar(range(len(data1)), data1)
plt.bar(range(len(data2)), data2, bottom=data1)
plt.show()
Matplotlib 折线图
折线图使用 Matplotlib 开箱即用。 折线图中可以包含多条折线,更改颜色,更改折线类型等等。
Matplotlib 是用于绘图的 Python 模块。 折线图是它可以创建的多种图表类型之一。
折线图示例
折线图
首先导入matplotlib
和numpy
,它们对于制图非常有用。
您可以使用plot(x, y)
方法创建折线图。
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-1, 1, 50)
print(x)
y = 2*x + 1
plt.plot(x, y)
plt.show()
曲线
plot()
方法也适用于其他类型的折线图。 不需要是直线,y
可以具有任何类型的值。
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-1, 1, 50)
y = 2**x + 1
plt.plot(x, y)
plt.show()
带有标签的直线
要知道您在看什么,您需要元数据。 标签是一种元数据。 它们显示图表的内容。 图表具有x
标签,y
标签和标题。
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-1, 1, 50)
y1 = 2*x + 1
y2 = 2**x + 1
plt.figure()
plt.plot(x, y1)
plt.xlabel("I am x")
plt.ylabel("I am y")
plt.title("With Labels")
plt.show()
多个直线
绘图中可以有多条线。 要添加另一行,只需再次调用plot(x, y)
函数。 在下面的示例中,我们在图表上绘制了y(y1, y2)
的两个不同值。
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-1, 1, 50)
y1 = 2*x + 1
y2 = 2**x + 1
plt.figure(num = 3, figsize=(8, 5))
plt.plot(x, y2)
plt.plot(x, y1,
color='red',
linewidth=1.0,
linestyle='--'
)
plt.show()
虚线
线可以是点的形式,如下图所示。 调用scatter(x, y)
方法而不是调用plot(x, y)
。scatter(x, y)
方法还可以用于(随机)将点绘制到图表上。
import matplotlib.pyplot as plt
import numpy as np
n = 1024
X = np.random.normal(0, 1, n)
Y = np.random.normal(0, 1, n)
T = np.arctan2(X, Y)
plt.scatter(np.arange(5), np.arange(5))
plt.xticks(())
plt.yticks(())
plt.show()
直线刻度
您可以更改绘图上的刻度。 将它们设置在x
轴,y
轴上,甚至更改其颜色。 这条线可以更粗并且具有alpha
值。
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-1, 1, 50)
y = 2*x - 1
plt.figure(figsize=(12, 8))
plt.plot(x, y, color='r', linewidth=10.0, alpha=0.5)
ax = plt.gca()
ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none')
ax.xaxis.set_ticks_position('bottom')
ax.yaxis.set_ticks_position('left')
ax.spines['bottom'].set_position(('data', 0))
ax.spines['left'].set_position(('data', 0))
for label in ax.get_xticklabels() + ax.get_yticklabels():
label.set_fontsize(12)
label.set_bbox(dict(facecolor='y', edgecolor='None', alpha=0.7))
plt.show()
渐近线
可以将渐近线添加到该图。 为此,请使用plt.annotate()
。 在下面的图中还有一条虚线。 您可以试一下代码以查看其工作原理。
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-1, 1, 50)
y1 = 2*x + 1
y2 = 2**x + 1
plt.figure(figsize=(12, 8))
plt.plot(x, y2)
plt.plot(x, y1, color='red', linewidth=1.0, linestyle='--')
ax = plt.gca()
ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none')
ax.xaxis.set_ticks_position('bottom')
ax.yaxis.set_ticks_position('left')
ax.spines['bottom'].set_position(('data', 0))
ax.spines['left'].set_position(('data', 0))
x0 = 1
y0 = 2*x0 + 1
plt.scatter(x0, y0, s = 66, color = 'b')
plt.plot([x0, x0], [y0, 0], 'k-.', lw= 2.5)
plt.annotate(r'$2x+1=%s$' %
y0,
xy=(x0, y0),
xycoords='data',
xytext=(+30, -30),
textcoords='offset points',
fontsize=16,
arrowprops=dict(arrowstyle='->',connectionstyle='arc3,rad=.2')
)
plt.text(0, 3,
r'$This\ is\ a\ good\ idea.\ \mu\ \sigma_i\ \alpha_t$',
fontdict={'size':16,'color':'r'})
plt.show()
带有文字刻度的直线
不一定是数字刻度。 秤也可以包含文字,例如以下示例。 在plt.yticks()
中,我们只传递一个带有文本值的列表。 然后将这些值显示在y
轴上。
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-1, 1, 50)
y1 = 2*x + 1
y2 = 2**x + 1
plt.figure(num = 3, figsize=(8, 5))
plt.plot(x, y2)
plt.plot(x, y1,
color='red',
linewidth=1.0,
linestyle='--'
)
plt.xlim((-1, 2))
plt.ylim((1, 3))
new_ticks = np.linspace(-1, 2, 5)
plt.xticks(new_ticks)
plt.yticks([-2, -1.8, -1, 1.22, 3],
[r'$really\ bad$', r'$bad$', r'$normal$', r'$good$', r'$readly\ good$'])
ax = plt.gca()
ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none')
ax.xaxis.set_ticks_position('bottom')
ax.yaxis.set_ticks_position('left')
ax.spines['bottom'].set_position(('data', 0))
ax.spines['left'].set_position(('data', 0))
plt.show()
Seaborn 分布图
通过 Seaborn 分布图,您可以显示带有线条的直方图。 这可以以各种变化形式显示。 我们将 Seaborn 与 Python 绘图模块 Matplotlib 结合使用。
分布图绘制观测值的单变量分布。 distplot()
函数将 Matplotlib hist
函数与 Seaborn kdeplot()
和rugplot()
函数结合在一起。
示例
分布图示例
下图显示了一个简单的分布。 它使用random.randn()
创建随机值。如果您也手动定义值,它将起作用。
import matplotlib.pyplot as plt
import seaborn as sns, numpy as np
sns.set(rc={"figure.figsize": (8, 4)}); np.random.seed(0)
x = np.random.randn(100)
ax = sns.distplot(x)
plt.show()
分布图示例
您可以显示分布图的各种变化。 我们使用pylab
模块中的subplot()
方法来一次显示 4 种变化。
通过更改distplot()
方法中的参数,您可以创建完全不同的视图。 您可以使用这些参数来更改颜色,方向等。
import matplotlib.pyplot as plt
import seaborn as sns, numpy as np
from pylab import *
sns.set(rc={"figure.figsize": (8, 4)}); np.random.seed(0)
x = np.random.randn(100)
subplot(2,2,1)
ax = sns.distplot(x)
subplot(2,2,2)
ax = sns.distplot(x, rug=False, hist=False)
subplot(2,2,3)
ax = sns.distplot(x, vertical=True)
subplot(2,2,4)
ax = sns.kdeplot(x, shade=True, color="r")
plt.show()
Seaborn 分布
您也可以在直方图中显示 Seaborn 的标准数据集。这是一个很大的数据集,因此仅占用一列。
import matplotlib.pyplot as plt
import seaborn as sns
titanic=sns.load_dataset('titanic')
age1=titanic['age'].dropna()
sns.distplot(age1)
plt.show()
分布图容器
如果您想更改桶的数量或隐藏行,也可以。当调用方法distplot()
时,您可以传递箱数并告诉直线(kde)不可见。
import matplotlib.pyplot as plt
import seaborn as sns
titanic=sns.load_dataset('titanic')
age1=titanic['age'].dropna()
sns.distplot(age1,bins=30,kde=False)
plt.show()
Seaborn 不同的绘图
下面的示例显示了其他一些分布图示例。 您通过grid(True)
方法调用激活了一个网格。
import matplotlib.pyplot as plt
import seaborn as sns
titanic=sns.load_dataset('titanic')
age1=titanic['age'].dropna()
fig,axes=plt.subplots(1,2)
sns.distplot(age1,ax=axes[0])
plt.grid(True)
sns.distplot(age1,rug=True,ax=axes[1])
plt.show()
Seaborn 绘图
Seaborn 支持多种类型的条形图。 我们将 Seaborn 与 Matplotlib 结合起来演示了几个绘图。
Seaborn 包含几个数据集(titanic 和其他),但这只是一个演示。 您可以将任何类型的数据传递到绘图。
条形图示例
条形图
用barplot()
方法创建一个条形图。 下面的条形图根据类别显示了泰坦尼克号撞车事故的幸存者。 您会看到这些条形图随着船沉没而下降:)
调色板参数定义了要使用的颜色,当前使用的是"hls"
,但可以使用任何调色板。
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
sns.set_context('paper')
# load dataset
titanic = sns.load_dataset('titanic')
print(titanic.head())
# create plot
sns.barplot(x = 'sex', y = 'survived', hue = 'class', data = titanic,
palette = 'hls',
order = ['male', 'female'],
capsize = 0.05,
saturation = 8,
errcolor = 'gray', errwidth = 2,
ci = 'sd'
)
print(titanic.groupby(['sex', 'class']).mean()['survived'])
print(titanic.groupby(['sex', 'class']).std()['survived'])
plt.show()
水平条形图
该条形图可以是使用barplot()
方法的水平图。 在下面的示例中,两个条形图是重叠的,显示了百分比作为总崩溃的一部分。
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
sns.set_context('paper')
crashes = sns.load_dataset('car_crashes').sort_values('total', ascending = False)
f, ax = plt.subplots(figsize = (6,15))
sns.set_color_codes('pastel')
sns.barplot(x = 'total', y = 'abbrev', data = crashes,
label = 'Total', color = 'b', edgecolor = 'w')
sns.set_color_codes('muted')
sns.barplot(x = 'alcohol', y = 'abbrev', data = crashes,
label = 'Alcohol-involved', color = 'b', edgecolor = 'w')
ax.legend(ncol = 2, loc = 'lower right')
sns.despine(left = True, bottom = True)
plt.show()
条形图提示
下面的条形图提示图使用提示数据集。 它显示了根据性别收到的提示数量。 它使用蓝调调色板,该调色板具有蓝色的变体。
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
sns.set_context('paper')
tips = sns.load_dataset('tips')
sns.barplot(x = 'day', y = 'total_bill', hue = 'sex', data = tips,
palette = 'Blues', edgecolor = 'w')
tips.groupby(['day','sex']).mean()
plt.show()
计数图
可以将计数图视为跨类别变量的直方图。下面的示例演示了计数图。
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
sns.set_context('paper')
# load dataset
titanic = sns.load_dataset('titanic')
print(titanic.head())
# create plot
sns.countplot(x = 'class', hue = 'who', data = titanic, palette = 'magma')
plt.title('Survivors')
plt.show()
Seaborn 箱形图
Seaborn 箱形图是一个非常基本的图,箱形图用于可视化分布。
当您要比较两组之间的数据时,这很有用。
有时将箱形图称为箱须图。 任何框均显示数据集的四分位数,而晶须延伸以显示其余分布。
箱形图示例
箱形图
箱形图用boxplot()
方法处理。 下面的示例加载鸢尾花数据集。 然后,所显示的箱形图显示了最小,最大,第一四分位数和第三四分位数。
import seaborn as sns
import matplotlib.pyplot as plt
df = sns.load_dataset('iris')
df.head()
sns.boxplot( y=df["sepal_length"] );
plt.show()
水平箱形图
箱形图可以是水平图。 下例显示了水平方向的箱形图。我们再次使用鸢尾花数据集。 显示的颜色是默认颜色,但是它们是可配置的。
import seaborn as sns
import matplotlib.pyplot as plt
df = sns.load_dataset('iris')
df.head()
sns.boxplot( y=df["species"], x=df["sepal_length"] );
plt.show()
箱形图颜色
箱形图颜色图颜色是可配置的。 您可以通过传递调色板参数来实现。 有各种各样的调色板,调色板"Blues"
是各种各样的蓝色。
import seaborn as sns
import matplotlib.pyplot as plt
df = sns.load_dataset('iris')
df.head()
sns.boxplot( x=df["species"], y=df["sepal_length"], palette="Blues");
plt.show()
多重箱形图
箱形图多重绘图以默认颜色显示法线方向上的集合。
import seaborn as sns
import matplotlib.pyplot as plt
df = sns.load_dataset('iris')
df.head()
sns.boxplot( x=df["species"], y=df["sepal_length"] );
plt.show()
箱形图的大小
各个箱形图的大小可以通过width
参数进行更改。 默认宽度为 1,因此任何较小的值都会为框创建较小的宽度。
import seaborn as sns
import matplotlib.pyplot as plt
df = sns.load_dataset('iris')
df.head()
sns.boxplot( x=df["species"], y=df["sepal_length"], width=0.3);
plt.show()
Seaborn 热力图
热力图是矩形数据作为颜色编码矩阵的曲线图。 作为参数,它采用 2D 数据集。 该数据集可以被强制为一个ndarray
。
这是可视化数据的好方法,因为它可以显示包括时间在内的各种变量之间的关系。 例如,历年来的频率。
热力图示例
热力图
下面的热力图图基于 numpy 生成的随机值。 许多参数都是可能的,这只是显示了最基本的图。
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
np.random.seed(0)
sns.set()
uniform_data = np.random.rand(10, 12)
ax = sns.heatmap(uniform_data, vmin=0, vmax=1)
plt.show()
热力图颜色
下面的热力图颜色图再次使用了随机数据。 这次,它使用了不同的颜色图(cmap
),带有“蓝色”调板,但仅是蓝色。 它还使用正方形块。
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
df = pd.DataFrame(np.random.randn(50).reshape(10,5))
corr = df.corr()
ax1 = sns.heatmap(corr, cbar=0, linewidths=2,vmax=1, vmin=0, square=True, cmap='Blues')
plt.show()
热力图数据
热力图数据图类似,但是使用不同的调色板。 它使用 Seaborn 中包含的航空公司或航班数据集。
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
sns.set()
flights = sns.load_dataset("flights")
flights = flights.pivot("month", "year", "passengers")
ax = sns.heatmap(flights)
plt.title("Heatmap Flight Data")
plt.show()
Seaborn 直线图
直线图(lmplot
)是最基本的图之一。 它在二维平面上显示一条线。 您可以根据自己的喜好使用 Seaborn 或 Matlotlib 进行绘制。
下面的示例使用 Seaborn 创建图,但使用 Matplotlib 进行显示。 默认情况下,Seaborn 包括各种数据集,我们使用它们来绘制数据。
直线图
lmplot
lmplot
图显示了该线以及 2d 空间上的数据点。 通过指定x
和y
,可以分别设置水平和垂直标签。
import seaborn as sns
import matplotlib.pyplot as plt
data=sns.load_dataset("tips")
data.head(5)
sns.set(font_scale=1.5,style="white")
sns.lmplot(x="total_bill",y="tip",data=data)
plt.show()
直线图
下图显示了不同类型的直线图。 它们可以是您想要的任何颜色。 我们使用了 Seaborn 中包含的数据集,但这可以用于任何类型的数据。
import seaborn as sns
import matplotlib.pyplot as plt
sns.set(style="ticks")
# Load the example dataset for Anscombe's quartet
df = sns.load_dataset("anscombe")
# Show the results of a linear regression within each dataset
sns.lmplot(x="x", y="y", col="dataset", hue="dataset", data=df,
col_wrap=2, ci=None, palette="muted", height=4,
scatter_kws={"s": 50, "alpha": 1})
plt.show()
Seaborn 成对图
pairplot
函数创建一个Axes
网格,以便数据中的每个变量在单行的y
轴和单列的x
轴上共享。 如下所示创建图。
成对图
成对图
成对图显示在下方。 它使用鸢尾花数据集。 数据集有 4 个测量值:萼片宽度,萼片长度,花瓣长度和花瓣宽度。 数据映射在下面的网格中。 由于有 4 个测量值,因此会创建一个 4x4 的图。
#!/usr/bin/python3
import seaborn as sns
sns.set(style="ticks", color_codes=True)
iris = sns.load_dataset("iris")
g = sns.pairplot(iris)
import matplotlib.pyplot as plt
plt.show()
如果您希望使用较小的绘图,请使用较少的变量。 例如,如果只需要sepal_width
和sepal_length
,则它将创建 2x2 的图。
g = sns.pairplot(iris, vars=["sepal_width", "sepal_length"])
您可以更改分布的形状。
g = sns.pairplot(iris, diag_kind="kde")
Seaborn 调色板
Seaborn 绘图可以使用不同的调色板。 这些调色板决定要在图中使用的颜色。 不论使用哪个数据集,对于任何数据集,您都可以更改调色板。
调色板具有不同的名称,例如"hls"
,"Blues"
等等。 这些是您拥有的某些调色板选择。 其他调色板包括"deep"
,"vlag"
和"rocket"
。
调色板
调色板示例
下面的示例显示了调色板图。 函数palplot()
为调色板的颜色创建图形。 它针对不同的调色板执行此操作。 为了简单起见,我们仅显示所有创建的调色板中的一个。
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
sns.set_context('paper')
# create plot
sns.palplot(sns.color_palette("hls", 8))
sns.palplot(sns.color_palette("Paired",10))
sns.palplot(sns.color_palette("Blues"))
sns.palplot(sns.color_palette("Blues_r"))
sns.palplot(sns.color_palette("BrBG", 7))
sns.palplot(sns.diverging_palette(10, 220, sep=90, n=7))
sns.palplot(sns.diverging_palette(255, 133, l=60, n=7, center="dark"))
plt.show()
Seaborn Pandas
Pandas 是一个数据分析和处理模块,可帮助您加载和解析数据。 这是您在创建绘图时可能会使用的模块。
在 Pandas 中,数据存储在数据帧中。 例如,如果您从 Excel 加载数据。 当然,在处理数据时,您不必使用 Pandas,就像在旅行时不必使用汽车一样。 但这使处理数据变得更加容易。
示例
Pandas
从 Pandas 数据帧创建 Seaborn Pandas 图。 数据帧使用随机数据,但实际上,这些数据通常来自数据库,Excel 或其他来源。
该程序会创建不同的图,但为简单起见,仅显示一个结果。
import numpy as np
import pandas as pd
from scipy import stats
import matplotlib.pyplot as plt
import seaborn as sns
df_obj1 = pd.DataFrame({"x": np.random.randn(500),
"y": np.random.randn(500)})
df_obj2 = pd.DataFrame({"x": np.random.randn(500),
"y": np.random.randint(0, 100, 500)})
sns.jointplot(x="x", y="y", data=df_obj2)
sns.jointplot(x="x", y="y", data=df_obj2, kind="hex");
sns.jointplot(x="x", y="y", data=df_obj1, kind="kde");
dataset = sns.load_dataset("tips")
sns.pairplot(dataset);
#titanic = sns.load_dataset('titanic')
#planets = sns.load_dataset('planets')
#flights = sns.load_dataset('flights')
#iris = sns.load_dataset('iris')
exercise = sns.load_dataset('exercise')
sns.stripplot(x="diet", y="pulse", data=exercise)
sns.swarmplot(x="diet", y="pulse", data=exercise, hue='kind')
sns.boxplot(x="diet", y="pulse", data=exercise)
sns.boxplot(x="diet", y="pulse", data=exercise, hue='kind')
sns.violinplot(x="diet", y="pulse", data=exercise, hue='kind')
sns.barplot(x="diet", y="pulse", data=exercise, hue='kind')
sns.pointplot(x="diet", y="pulse", data=exercise, hue='kind');
plt.show()
Seaborn 散点图
散点图是具有许多数据点的图。 这是 Seaborn 可以创造的众多土地之一。 Seaborn 是用于统计数据可视化的 Python 模块。
Seaborn 可以使用scatterplot()
方法创建该图。 数据点与参数数据一起传递。 参数x
和y
是图的标签。
散点图
基本散点图
散点图基本图使用提示数据集。 这是有关基于总账单收到的提示的数据集。 您可以将所需的任何数据集用于散点图,这仅作为基本示例。
import numpy as np
import pandas as pd
import matplotlib as mpl
import matplotlib.pyplot as plt
import seaborn as sns
tips = sns.load_dataset("tips")
sns.set(color_codes=True)
ax = sns.scatterplot(x="total_bill", y="tip", data=tips)
plt.show()
散点图
散点图也可以包含一条线。 为此,请改用lmplot
。 这很好地显示了数据点之间的关系。
import numpy as np
import pandas as pd
import matplotlib as mpl
import matplotlib.pyplot as plt
import seaborn as sns
sns.set(color_codes=True)
np.random.seed(sum(map(ord, "regression")))
tips = sns.load_dataset("tips")
tips.head()
sns.lmplot(x="total_bill", y="tip", data=tips)
plt.show()
Plotly
Plotly 是 Python 的制图模块。 它可以创建出版物质量的图表。 它支持多种类型的图表/图表,包括折线图,条形图,气泡图等。
该库是免费的开放源代码。 在本教程中,您将学习如何使用 plotly 创建折线图。 可以将其视为 Matplotlib 的更广泛的替代方案。
示例
简介
从 PyPi 仓库中安装。 在新安装的虚拟环境中,您可以使用程序pip
进行安装。
pip install plotly
Plotly 提供了用于绘制图表的 Web 服务。 图形将保存在您的在线 Plotly 帐户中。 这是可选的,Plotly 可以脱机使用。
离线绘图有两个选项:
-
使用
plotly.offline.plot()
创建和独立的 HTML。 可以在浏览器中打开该文件 -
在 Jupyter Notebook 中脱机工作时,请使用
plotly.offline.iplot()
。
在线绘图
在线绘图需要在 plot.ly 上进行计费。
更改为您的用户名和 API 密钥
打开文件~/.plotly/.credentials
并更新您的 API 密钥。
然后创建此程序:
import plotly.plotly as py
import plotly.graph_objs as go
import numpy as np
py.sign_in(username='voorbeeld', api_key='L0McCrDpID71OLCEgRtK')
mx = [1, 2, 3, 4]
my = [1, 2, 3, 4]
trace = go.Scatter(
x = mx,
y = my
)
data = [trace]
py.plot(data)
从终端运行程序。 然后打开 URL https://plot.ly/organize/home/#/ ,您的图表将在其中显示。
独立 HTML(plotly.offline.plot
)
下面的代码创建一个新的 HTML 文件。 使用浏览器(Firefox,Chrome)打开时,此 HTML 文件将显示图表。
import plotly
import plotly.graph_objs as go
plotly.offline.plot({
"data": [go.Scatter(x=[1, 2, 3, 4], y=[1, 2, 3, 4])],
"layout": go.Layout(title="line chart")
}, auto_open=True)
jupyter 笔记本
另一种方法是使用 jupyter 笔记本(ipython)。 ipython 是一个功能强大的交互式外壳。
您可以使用以下命令安装
python3 -m pip install jupyter
jupyter notebook
这将启动 Web 服务器。从/tree
页面单击“新建 -> 笔记本 -> python3”。
在代码框中,粘贴以下代码:
import plotly
import plotly.graph_objs as go
plotly.offline.init_notebook_mode(connected=True)
plotly.offline.iplot({
"data": [go.Scatter(x=[1, 2, 3, 4], y=[4, 3, 2, 1])],
"layout": go.Layout(title="hello world")
})
然后单击“运行”,该图表将显示在代码下方。
PyQt
PyQt
PyQt 是使用 Python 制作桌面软件的模块。 这适用于所有台式机系统,包括 Mac OS X,Windows 和 Linux。
如果要使用 Python 制作桌面应用程序,PyQt 是制作它们的模块。 创建应用程序后,您可以使用 fbs 创建安装程序。
教程
什么是 PyQt?
PyQt 是 Qt 库(C++)的端口。 Qt 是一个非常强大的 GUI 库。 PyQt 不是单个模块,而是模块的集合。
这些模块包括:QtCore
,QtGui
,QtWidgets
,QtMultimedia
,QtBluetooth
,QtNetwork
,QtPositioning
,Enginio
,QtWebSockets
,QtWebKit
,QtWebKitWidgets
,QtXml
,QtSvg
,QtSql
和 QtTest
。
那么这些模块中有什么?
-
QtCore
:包含核心非 GUI 代码。 -
QtGui
:具有用于窗口管理的所有内容,例如事件处理和图形。 -
QtWidgets
:具有许多 UI 窗口小部件,例如按钮,标签,文本输入以及您在桌面窗口中看到的其他内容。 -
QtMultimedia
:用于多媒体内容和摄像机。 -
QtBluetooth
:扫描蓝牙设备并连接。 -
QtNetwork
:一种用于网络编程的跨平台解决方案。 设置可在所有桌面系统上运行的套接字服务器或客户端。 同时支持 TCP/IP 栈和 UDP。 -
QtPositioning
:通过使用位置(WiFi,卫星)确定位置 -
QtWebSockets
:Websocket 协议的实现。 -
QtWebKit
:Web 浏览器实现。 您可以使用它来呈现网页。 这是基于 WebKit2 的。 在 Safari 浏览器中,KDE 和其他人使用 WebKit。 -
QtWebKitWidgets
:已弃用。 WebKit1 版本的 Web 浏览器实现 -
QtXml
:使用 XML 文件,读/写等。 -
QtSvg
:可缩放矢量图形(SVG)。一种图像格式。 -
QtSql
:与数据库一起使用。 -
QtTest
:单元测试
安装 PyQt
您可以使用 PyQt 轻松制作桌面软件。 有两种安装 PyQt 的方法:使用安装程序和来自代码。
从源代码编译 PyQt 可能是一个繁琐的过程,建议您使用安装程序或软件包管理器进行安装。 (最终用户只需运行安装程序即可安装软件)
您可以查看有关 PyQt 安装的教程。
创建应用
安装 PyQt 之后,您可以创建各种桌面软件。 PyQt 有许多小部件,包括按钮,输入字段,组合框,Web 视图和其他许多小部件。
这很简单,您将在接下来的教程中学习如何做到这一点。
安装 PyQt
默认情况下,通常不安装 PyQt。 在本文中,您将学习如何安装 PyQt 模块。
您可以使用 PyQt 制作桌面应用程序。 它是跨平台的,可以在 Windows,Mac OS X 和 Linux 上运行。
如何在 Windows 上安装 PyQt5?
使用 QT 中的安装程序安装 PyQt 。
安装 python 3.3,然后检查添加所有 PyQt5 附加功能。 无需编译所有内容,您可以使用安装程序安装软件包。
在 Python >= 3.6 上,您也可以尝试安装 PyQt5
它应该可以正常工作。
如何在 Mac OS X 上安装 PyQt5?
安装 Mac OS X 二进制文件。
然后,您可以使用brew
安装pyqt
(在终端中):brew install pyqt
。
如何在 Linux 上安装 PyQt5?
通常在 Linux 上默认安装 Python。 确保使用 Python3。您可以使用
python --version
然后,您可以安装 PyQt 软件包管理器。
在 Ubuntu Linux/Debian Linux 上,您可以使用以下命令:
sudo apt-get install python3-pyqt5
对于 CentOS 7,使用以下命令:
yum install qt5-qtbase-devel
对于基于 RPM 的系统
yum install PyQt5
PyQt Hello World
带有 PyQT 的“Hello World”程序是一个用于创建桌面应用程序的模块。 在本文中,您将学习如何在 PyQt 中创建“hello world”应用。
如果您想制作桌面应用程序或图形用户界面,PyQT 就是一个很好的模块。
在开始本教程之前,请确保已安装 PyQt5。
PyQt Hello World
示例
下面的程序创建“hello world”窗口。
import sys
from PyQt5.QtWidgets import QApplication, QWidget, QLabel
from PyQt5.QtGui import QIcon
from PyQt5.QtCore import pyqtSlot
def window():
app = QApplication(sys.argv)
widget = QWidget()
textLabel = QLabel(widget)
textLabel.setText("Hello World!")
textLabel.move(110,85)
widget.setGeometry(50,50,320,200)
widget.setWindowTitle("PyQt5 Example")
widget.show()
sys.exit(app.exec_())
if __name__ == '__main__':
window()
工作原理
PyQT 使用以下代码初始化:
app = QApplication(sys.argv)
widget = QWidget()
文本不能立即添加到窗口中。 必须将其添加到标签。
标签是可以显示文本或图像的小部件。 这些行创建一个QLabel
,设置标签的文本和位置(水平,垂直)。
textLabel = QLabel(widget)
textLabel.setText("Hello World!")
textLabel.move(110,85)
现在您应该显示该窗口。
使用setGeometry()
方法设置起始位置(50, 50
)和窗口大小(320, 200
)。
widget.setGeometry(50,50,320,200)
然后您要显示窗口! 用setWindowTitle()
给它一个标题,并用show()
显示它。
widget.setWindowTitle("PyQt5 Example")
widget.show()
PyQt 按钮
按钮(QPushButton
)可以添加到任何窗口。QPushButton
类具有用于标签的setText()
方法和用于位置的move(x, y)
方法。
在本文中,您可以看到如何将按钮添加到窗口以及如何将方法连接到窗口。
PyQt 按钮示例
信号和槽
您可以使用几行代码创建一个按钮:
button1 = QPushButton(widget)
button1.setText("Button1")
button1.move(64,32)
然后将其连接到以下方法:
button1.clicked.connect(button1_clicked)
接收方法称为槽,clicked.connect
(如果单击了按钮)称为信号。
def button1_clicked():
print("Button 1 clicked")
按钮示例
运行下面的代码以查看一个窗口中的 2 个按钮。 您可以单击任意一个按钮,它们的连接方法将被调用。
import sys
from PyQt5.QtWidgets import QApplication, QWidget, QPushButton
from PyQt5.QtGui import QIcon
from PyQt5.QtCore import pyqtSlot
def window():
app = QApplication(sys.argv)
widget = QWidget()
button1 = QPushButton(widget)
button1.setText("Button1")
button1.move(64,32)
button1.clicked.connect(button1_clicked)
button2 = QPushButton(widget)
button2.setText("Button2")
button2.move(64,64)
button2.clicked.connect(button2_clicked)
widget.setGeometry(50,50,320,200)
widget.setWindowTitle("PyQt5 Button Click Example")
widget.show()
sys.exit(app.exec_())
def button1_clicked():
print("Button 1 clicked")
def button2_clicked():
print("Button 2 clicked")
if __name__ == '__main__':
window()
PyQt QMessageBox
PyQt QMessageBox
,您可以用来创建对话框。 这是一个经常在桌面上看到的弹出窗口。
它可能是单行消息,“确定要保存吗?”消息或更高级的消息。
该消息框支持各种变体和按钮。 在本课程中,您将学习如何创建信息对话框窗口。
对话框
初始窗口
创建一个带有按钮的窗口。 如果单击按钮,将弹出对话框。
(这也是 PyQt 初始化的地方。)
def window():
app = QApplication(sys.argv)
win = QWidget()
button1 = QPushButton(win)
button1.setText("Show dialog!")
button1.move(50,50)
button1.clicked.connect(showDialog)
win.setWindowTitle("Click button")
win.show()
sys.exit(app.exec_())
因此,让我们看一下showDialog()
。
创建一个对话框
使用QMessageBox()
创建一个对话框。 不要忘记从 PyQt5 导入它。
from PyQt5.QtWidgets import QPushButton
然后使用方法setIcon()
,setText()
,setWindowTitle()
设置窗口装饰。
您可以使用setStandardButtons()
配置对话框按钮。
def showDialog():
msgBox = QMessageBox()
msgBox.setIcon(QMessageBox.Information)
msgBox.setText("Message box pop up window")
msgBox.setWindowTitle("QMessageBox Example")
msgBox.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)
msgBox.buttonClicked.connect(msgButtonClick)
returnValue = msgBox.exec()
if returnValue == QMessageBox.Ok:
print('OK clicked')
可下载的代码
您可以将以下代码复制并粘贴到自己的计算机上,以测试其工作方式。
import sys
from PyQt5.QtWidgets import QApplication, QWidget, QPushButton, QMessageBox
from PyQt5.QtGui import QIcon
from PyQt5.QtCore import pyqtSlot
def window():
app = QApplication(sys.argv)
win = QWidget()
button1 = QPushButton(win)
button1.setText("Show dialog!")
button1.move(50,50)
button1.clicked.connect(showDialog)
win.setWindowTitle("Click button")
win.show()
sys.exit(app.exec_())
def showDialog():
msgBox = QMessageBox()
msgBox.setIcon(QMessageBox.Information)
msgBox.setText("Message box pop up window")
msgBox.setWindowTitle("QMessageBox Example")
msgBox.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)
msgBox.buttonClicked.connect(msgButtonClick)
returnValue = msgBox.exec()
if returnValue == QMessageBox.Ok:
print('OK clicked')
def msgButtonClick(i):
print("Button clicked is:",i.text())
if __name__ == '__main__':
window()
PyQt 网格
PyQt QGridLayout
是另一种布局。通常,您可以使用.move(x, y)
来定位小部件(按钮,标签等)。 网格不是这样。
它以 AxB 形式放置小部件。 其中,A 是列数,B 是行数。 与您在 Excel 中看到的类似。
QGridLayout
是PyQt5.QtWidgets
的一部分。
示例
QGridLayout
您可以使用单行代码创建QGridLayout
或网格:
grid = QGridLayout()
告诉窗口使用网格:
win.setLayout(grid)
可以使用以下工具将小部件添加到网格:
grid.addWidget(widget,col,row)
网格示例
下面的代码创建一个包含一组按钮的布局。 它通过使用嵌套的 for 循环添加一组按钮。
创建网格的关键部分是:
grid = QGridLayout()
for i in range(0,5):
for j in range(0,5):
grid.addWidget(QPushButton(str(i)+str(j)),i,j)
win.setLayout(grid)
其余代码仅创建窗口。 但是复制和粘贴很容易。
import sys
from PyQt5.QtWidgets import QApplication, QWidget, QLabel, QGridLayout, QPushButton
from PyQt5.QtGui import QIcon
from PyQt5.QtCore import pyqtSlot
def window():
app = QApplication(sys.argv)
win = QWidget()
grid = QGridLayout()
for i in range(0,5):
for j in range(0,5):
grid.addWidget(QPushButton(str(i)+str(j)),i,j)
win.setLayout(grid)
win.setWindowTitle("PyQt Grid Example")
win.setGeometry(50,50,200,200)
win.show()
sys.exit(app.exec_())
if __name__ == '__main__':
window()
QLineEdit
您可以使用QLineEdit
小部件获得用户输入。 在本课程中,您将进行行编辑,以在运行时更改标签文本。
一个窗口可以包含一个或多个QLineEdit
小部件。 它们本身不包含标签,出于 UX 的目的,您可能希望向QLineEdit
添加标签以告诉用户在框中键入什么内容。
QLineEdit
添加输入框
下面的面向对象的代码使用构造函数创建一个窗口。 将输入框或行编辑添加到窗口,这称为QLineEdit
。
然后添加标签和行编辑:
self.lineEntry = QLineEdit(self)
self.lineEntry.move(16,16)
self.lineEntry.resize(200,40)
self.qlabel = QLabel(self)
self.qlabel.move(16,64)
您可以使用方法调用连接输入框中的每个按键(QLineEdit
)。
self.lineEntry.textChanged.connect(self.onChanged)
在该方法中,设置标签文本并调整标签大小。
def onChanged(self, text):
self.qlabel.setText(text)
self.qlabel.adjustSize()
示例
复制并粘贴以下示例代码,自己尝试:
import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QLabel, QLineEdit, QPushButton
class Example(QMainWindow):
def __init__(self):
super().__init__()
self.lineEntry = QLineEdit(self)
self.lineEntry.move(16,16)
self.lineEntry.resize(200,40)
self.qlabel = QLabel(self)
self.qlabel.move(16,64)
self.lineEntry.textChanged.connect(self.onChanged)
self.setGeometry(50,50,320,200)
self.setWindowTitle("QLineEdit Example")
self.show()
def onChanged(self, text):
self.qlabel.setText(text)
self.qlabel.adjustSize()
if __name__ == '__main__':
app = QApplication(sys.argv)
ex = Example()
sys.exit(app.exec_())
PyQT QPixmap
QPixmap
可用于在 PyQT 窗口中显示图像。QPixmap()
可以加载图像,因为它具有文件名作为参数。 要显示图像,请将QPixmap
添加到QLabel
。
QPixmap
支持所有主要的图像格式:BMP,GIF,JPG,JPEG,PNG,PBM,PGM,PPM,XBM 和 XPM。
PyQT 图片
QPixmap
首先创建一个QPixmap
和一个QLabel
。 然后,您可以像这样组合它们:
self.im = QPixmap("./image.jpg")
self.label = QLabel()
self.label.setPixmap(self.im)
然后将整个内容添加到布局中,例如QGridLayout
self.grid = QGridLayout()
self.grid.addWidget(self.label,1,1)
self.setLayout(self.grid)
示例
复制并粘贴下面的代码,以从本地计算机加载图像。 该图像将以网格布局显示。
import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QLabel, QGridLayout, QWidget
from PyQt5.QtGui import QPixmap
class Example(QWidget):
def __init__(self):
super().__init__()
self.im = QPixmap("./image.jpg")
self.label = QLabel()
self.label.setPixmap(self.im)
self.grid = QGridLayout()
self.grid.addWidget(self.label,1,1)
self.setLayout(self.grid)
self.setGeometry(50,50,320,200)
self.setWindowTitle("PyQT show image")
self.show()
if __name__ == '__main__':
app = QApplication(sys.argv)
ex = Example()
sys.exit(app.exec_())
PyQt 组合框
您可以具有QComboBox
的组合框,选择框或组合框。 要使用此小部件,请从PyQt5.QtWidgets
导入QComboBox
。
通常,当用户需要从选定数量的项目(例如国家/地区或合同)中进行选择时,您会看到此小部件。
QComboBox
创建一个组合框
您可以使用以下几行创建一个组合框:
combo = QComboBox(self)
combo.addItem("Apple")
方法addItem
将一个选项添加到组合框中。 您可以根据需要使用不同的选项多次呼叫。
要将组合框更改与方法联系起来,可以使用以下方法:
combo.activated[str].connect(self.onChanged)
示例
下面的代码将组合框添加到窗口。 选择组合框中显示的选项之一后,标签值将更改。
import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QLabel, QComboBox, QPushButton
class Example(QMainWindow):
def __init__(self):
super().__init__()
combo = QComboBox(self)
combo.addItem("Apple")
combo.addItem("Pear")
combo.addItem("Lemon")
combo.move(50, 50)
self.qlabel = QLabel(self)
self.qlabel.move(50,16)
combo.activated[str].connect(self.onChanged)
self.setGeometry(50,50,320,200)
self.setWindowTitle("QLineEdit Example")
self.show()
def onChanged(self, text):
self.qlabel.setText(text)
self.qlabel.adjustSize()
if __name__ == '__main__':
app = QApplication(sys.argv)
ex = Example()
sys.exit(app.exec_())
QCheckBox
复选框(QCheckbox
)是默认的 QT 小部件,可以使用方法setChecked(true)
进行检查。 它是PyQt5.QtWidgets
的一部分。
您可以使用.toggled.connect()
添加点击回调/信号。 然后,接收槽可以处理事件。
QCheckBox
PyQt 复选框示例
下面的示例在 PyQt 窗口中创建一个复选框。 如果单击复选框,它将调用方法onClicked()
。 方法.isChecked()
可用于获取复选框状态。
from PyQt5.QtWidgets import *
import sys
class Window(QWidget):
def __init__(self):
QWidget.__init__(self)
layout = QGridLayout()
self.setLayout(layout)
radiobutton = QCheckBox("I have a Cat")
radiobutton.setChecked(True)
radiobutton.animal = "Cat"
radiobutton.toggled.connect(self.onClicked)
layout.addWidget(radiobutton, 0, 0)
def onClicked(self):
radioButton = self.sender()
print("Animal " + (radioButton.animal) + " is " + str(radioButton.isChecked()))
app = QApplication(sys.argv)
screen = Window()
screen.show()
sys.exit(app.exec_())
QSlider
PyQt 带有滑块QSlider
。 您可以使用此滑块选择一个值。 滑块可以作为音量的绝佳输入控件。
与数字计数器相比,它允许用户快速更改小部件范围上的值。QSlider
的范围是 0 到 100,其中 100 是 100% 。
QSlider
创建滑块
滑块可以是水平或垂直的。 创建滑块时,可以选择一种类型。Qt.Horizontal
或Qt.Vertical
。
首先导入QSlider
和Qt
。
from PyQt5.QtCore import Qt
from PyQt5.QtWidgets import QSlider
然后创建一个滑块:
mySlider = QSlider(Qt.Horizontal, self)
然后设置其几何形状(位置和大小):
mySlider.setGeometry(30, 40, 200, 30)
并连接一个在更改其值时调用的方法:
mySlider.valueChanged[int].connect(self.changeValue)
示例
下面的程序创建一个带有水平滑块的空窗口。 如果您想使用垂直滑块,请不要忘记更改几何形状。
复制并粘贴以下代码以尝试使用滑块:
import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QSlider
from PyQt5.QtCore import Qt
class Example(QMainWindow):
def __init__(self):
super().__init__()
mySlider = QSlider(Qt.Horizontal, self)
mySlider.setGeometry(30, 40, 200, 30)
mySlider.valueChanged[int].connect(self.changeValue)
self.setGeometry(50,50,320,200)
self.setWindowTitle("Checkbox Example")
self.show()
def changeValue(self, value):
print(value)
if __name__ == '__main__':
app = QApplication(sys.argv)
ex = Example()
sys.exit(app.exec_())
进度条
QProgressBar
是显示过程的小部件。 您可能在安装过程中多次看到它。
小部件显示一个条,您可以看到完成的百分比。 您可以使用方法setValue()
设置其值。 如果将 50 设置为 50%。
QProgressBar
进度条
使用下面的代码创建进度条:
self.pbar = QProgressBar(self)
self.pbar.setGeometry(30, 40, 200, 25)
您可以使用以下方法设置值:
self.pbar.setValue(50)
这就是创建进度条所需的全部。
要更新其值,您可以使用QTimer
。
from PyQt5.QtCore import QBasicTimer
每秒用以下几行调用一个方法:
self.timer = QTimer() self.timer.timeout.connect(self.handleTimer)
self.timer.start(1000)
然后更新进度条值:
def handleTimer(self):
value = self.pbar.value()
if value < 100:
value = value + 1
self.pbar.setValue(value)
else:
self.timer.stop()
示例
复制下面的代码以查看进度条从 50% 到 100% 的计数。使用handleTimer()
和QTimer()
方法更新进度条。
import sys
from PyQt5.QtCore import QTimer
from PyQt5.QtWidgets import QApplication, QMainWindow, QProgressBar
from PyQt5.QtCore import Qt
class Example(QMainWindow):
def __init__(self):
super().__init__()
self.pbar = QProgressBar(self)
self.pbar.setGeometry(30, 40, 200, 25)
self.pbar.setValue(50)
self.setWindowTitle("QT Progressbar Example")
self.setGeometry(32,32,320,200)
self.show()
self.timer = QTimer()
self.timer.timeout.connect(self.handleTimer)
self.timer.start(1000)
def handleTimer(self):
value = self.pbar.value()
if value < 100:
value = value + 1
self.pbar.setValue(value)
else:
self.timer.stop()
if __name__ == '__main__':
app = QApplication(sys.argv)
ex = Example()
sys.exit(app.exec_())
PyQt 表格
可以使用QTableWidget
创建表。 它是基于项目的表视图,类似于您在 Excel 中看到的视图。
您可以将表格窗口小部件作为 gui 的一部分,或弹出带有表格之类的 Excel 的窗口。
在此示例(PyQt5)中,它将显示带有表的窗口,但是您可以通过 Designer 将其作为窗口 GUI 的一部分。
表格
QTableWidget
QTableWidget
是具有行和列的表小部件。
该对象具有方法.setRowCount(x)
和.setColumnCount(y)
,其中x
是行数,y
是列数。 您可以将其用作self.setRowCount(5)
。
内容由self.setItem(m, n, newitem)
设置,其中m
和n
是表格内的坐标。
变量newitem
的类型为QTableWidgetItem
,可以将文本值作为字符串。 例如:.setItem(1,2, QTableWidgetItem("Table Cell"))
PyQT 中的表格
该表由变量数据定义。
data = {'col1':['1','2','3','4'],
'col2':['1','2','1','3'],
'col3':['1','1','2','1']}
下面的示例创建一个包含 3 列和若干行的表。
from PyQt5.QtWidgets import QMainWindow, QApplication, QWidget, QAction, QTableWidget,QTableWidgetItem,QVBoxLayout
from PyQt5.QtGui import QIcon
from PyQt5.QtCore import pyqtSlot
import sys
data = {'col1':['1','2','3','4'],
'col2':['1','2','1','3'],
'col3':['1','1','2','1']}
class TableView(QTableWidget):
def __init__(self, data, *args):
QTableWidget.__init__(self, *args)
self.data = data
self.setData()
self.resizeColumnsToContents()
self.resizeRowsToContents()
def setData(self):
horHeaders = []
for n, key in enumerate(sorted(self.data.keys())):
horHeaders.append(key)
for m, item in enumerate(self.data[key]):
newitem = QTableWidgetItem(item)
self.setItem(m, n, newitem)
self.setHorizontalHeaderLabels(horHeaders)
def main(args):
app = QApplication(args)
table = TableView(data, 4, 3)
table.show()
sys.exit(app.exec_())
if __name__=="__main__":
main(sys.argv)
QVBoxLayout
QVBoxLayout
在窗口中垂直组织窗口小部件。
除了让您自己组织所有小部件(指定地理位置)之外,您还可以让 PyQt 来处理它。
使用.addWidget()
添加的每个新窗口小部件都是垂直添加的。 基本上,您可以获得小部件的垂直列表。 每个新的小部件都将添加到列表的底部。
从PyQt5.QtWidgets
导入QVBoxLayout
。
垂直布局
QVboxLayout
示例
下面的简单示例创建一个QVboxLayout
。 然后使用addWidget
方法,在垂直方向上添加新创建的按钮。
from PyQt5.QtWidgets import QApplication, QWidget, QPushButton, QVBoxLayout
app = QApplication([])
window = QWidget()
layout = QVBoxLayout()
layout.addWidget(QPushButton('1'))
layout.addWidget(QPushButton('2'))
layout.addWidget(QPushButton('3'))
window.setLayout(layout)
window.show()
app.exec_()
这将创建此应用程序:
addWidget()
中的参数接受PyQt5.QtWidgets
中的任何小部件,例如QPushButton
和所有其他可用的小部件。
不要忘记使用window.setLayout(layout)
将QVBoxLayout
添加到窗口中。
PyQt 样式
可以配置 PyQt 样式。 PyQt 的默认样式称为“融合”。 但这不是唯一的样式。 您可能需要在多个操作系统上分发您的应用程序,并具有本机外观。
如果您使用 Windows,则可能需要 Windows 外观。 在 Mac 上,您可能需要 Mac OS X 样式。 所有这些都可以配置。 Mac 样式仅在 Mac OS X 上可用。
PyQt 样式
可用样式
可用样式可能因系统而异。 您可以使用 Python 解释器获取可用样式的列表,如下所示:
$ python3
Python 3.6.7 (default, Oct 22 2018, 11:32:17)
[GCC 8.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import PyQt5.QtWidgets
>>> print(PyQt5.QtWidgets.QStyleFactory.keys())
['Breeze', 'Oxygen', 'QtCurve', 'Windows', 'Fusion']
微风风格如下:
配置样式
您可以使用app.setStyle('Fusion')
行设置样式。
像这样:
app = QApplication([])
app.setStyle('Windows')
然后窗口显示如下(旧的 Win 9x 样式):
编译 PyQt 到 EXE
要分发您的应用程序,您需要有一个可执行程序而不是源代码。 这比给用户提供许多 Python 文件要容易。
为什么? 用户只需单击一下即可启动您的应用程序。 在 Windows 上,它是.exe
。 在 Mac OS X 上,它是.dmg
构建 EXE
安装工具链
您可以使用fbs
创建可以运行的程序。
sudo apt3 install python3-venv
python3 -m venv venv
source bin/activate
pip3 install fbs PyQt5==5.9.2 PyInstaller==3.4
fbs startproject
然后,系统会要求您输入应用程序的名称和作者
App name [MyApp] : hello
Author [Linux] : boss
Mac bundle identifier (eg. com.boss.hello, optional):
Created the src/ directory.
看一下文件/venv/src/main/python/main.py
。 这就是您的程序的源代码。
键入fbs run
启动程序。
创建可执行文件
您从二进制文件启动应用程序。 在 Windows 上是.exe
,在 Mac 上是.dmg
制作独立的可执行文件类型
fbs freeze
。
然后在target/
中创建程序。 如果您将应用命名为hello
,则为target/hello/hello
。
设置
始终使用安装程序来安装软件。 您可以使用命令fbs installer
创建自己的安装程序。
在 Windows 和 Mac 上,这将创建一个图形安装程序(安装向导)。
在 Linux 上,它会创建一个软件包文件(.deb
,.rpm
),可以与软件包管理器一起安装。
QDial
PyQT 中包含一个拨号小部件(QDial
)。它看起来像是您经常在混合面板上看到的音量控件。 它是PyQt5.QtWidgets
的一部分。
QDial
小部件的外观可能会在操作系统上发生变化。 但是逻辑在所有平台上都是相同的。
QDial
拨号小部件示例
它具有最小值和最大值,可以使用方法setMinimum()
和setMaximum()
进行设置。
您可以使用setValue()
设置默认值。 如果更改了值,则可以调用方法(.valueChanged.connect(self.sliderMoved)
)。
当前值为.value()
。
示例
下面的示例创建一个拨号小部件窗口。 您可以复制并粘贴程序进行测试。 必须安装 PyQt5 才能运行该程序。
from PyQt5.QtWidgets import *
import sys
class Window(QWidget):
def __init__(self):
QWidget.__init__(self)
layout = QGridLayout()
self.setLayout(layout)
self.dial = QDial()
self.dial.setMinimum(0)
self.dial.setMaximum(100)
self.dial.setValue(40)
self.dial.valueChanged.connect(self.sliderMoved)
layout.addWidget(self.dial)
def sliderMoved(self):
print("Dial value = %i" % (self.dial.value()))
app = QApplication(sys.argv)
screen = Window()
screen.show()
sys.exit(app.exec_())
QCheckBox
复选框(QCheckbox
)是默认的 QT 小部件,可以使用方法setChecked(true)
进行检查。 它是PyQt5.QtWidgets
的一部分。
您可以使用.toggled.connect()
添加点击回调/信号。 然后,接收槽可以处理事件。
QCheckBox
PyQt 复选框示例
下面的示例在 PyQt 窗口中创建一个复选框。 如果单击复选框,它将调用方法onClicked()
。 方法.isChecked()
可用于获取复选框状态。
from PyQt5.QtWidgets import *
import sys
class Window(QWidget):
def __init__(self):
QWidget.__init__(self)
layout = QGridLayout()
self.setLayout(layout)
radiobutton = QCheckBox("I have a Cat")
radiobutton.setChecked(True)
radiobutton.animal = "Cat"
radiobutton.toggled.connect(self.onClicked)
layout.addWidget(radiobutton, 0, 0)
def onClicked(self):
radioButton = self.sender()
print("Animal " + (radioButton.animal) + " is " + str(radioButton.isChecked()))
app = QApplication(sys.argv)
screen = Window()
screen.show()
sys.exit(app.exec_())
PyQt 单选按钮
PyQT QRadioButton
是一个简单的单选按钮。 通常,当只有一个选项(而不是复选框)时才使用。
在 qt 中,复选框始终具有圆形按钮和QRadioButton("Australia")
之类的标签。
单选按钮
PyQT 单选按钮示例
下面的代码创建 3 个单选按钮。 它将 3 个单选按钮添加到网格中。
如果单击任何单选按钮,它将调用方法onClicked()
。 使用radiobutton.toggled.connect(self.onClicked)
将单选按钮连接到该方法。
from PyQt5.QtWidgets import *
import sys
class Window(QWidget):
def __init__(self):
QWidget.__init__(self)
layout = QGridLayout()
self.setLayout(layout)
radiobutton = QRadioButton("Australia")
radiobutton.setChecked(True)
radiobutton.country = "Australia"
radiobutton.toggled.connect(self.onClicked)
layout.addWidget(radiobutton, 0, 0)
radiobutton = QRadioButton("China")
radiobutton.country = "China"
radiobutton.toggled.connect(self.onClicked)
layout.addWidget(radiobutton, 0, 1)
radiobutton = QRadioButton("Japan")
radiobutton.country = "Japan"
radiobutton.toggled.connect(self.onClicked)
layout.addWidget(radiobutton, 0, 2)
def onClicked(self):
radioButton = self.sender()
if radioButton.isChecked():
print("Country is %s" % (radioButton.country))
app = QApplication(sys.argv)
screen = Window()
screen.show()
sys.exit(app.exec_())
PyQt 分组框
分组框QGroupBox
可以对小部件进行分组。 它通常具有标题和边框。 任何小部件都可以添加到分组框中。 这可以进一步用于将 UI/UX 与用户进行通信。
本示例演示如何创建分组框,如下所示:
QGroupBox
PyQt 分组框
用QGroupBox("title")
初始化分组框。 然后将布局添加到分组框。 小部件将添加到布局中。
from PyQt5.QtWidgets import *
import sys
class GroupBox(QWidget):
def __init__(self):
QWidget.__init__(self)
self.setWindowTitle("GroupBox")
layout = QGridLayout()
self.setLayout(layout)
groupbox = QGroupBox("GroupBox Example")
groupbox.setCheckable(True)
layout.addWidget(groupbox)
vbox = QVBoxLayout()
groupbox.setLayout(vbox)
radiobutton = QRadioButton("RadioButton 1")
vbox.addWidget(radiobutton)
radiobutton = QRadioButton("RadioButton 2")
vbox.addWidget(radiobutton)
radiobutton = QRadioButton("RadioButton 3")
vbox.addWidget(radiobutton)
radiobutton = QRadioButton("RadioButton 4")
vbox.addWidget(radiobutton)
app = QApplication(sys.argv)
screen = GroupBox()
screen.show()
sys.exit(app.exec_())
PyQt 工具提示
工具提示是将鼠标悬停在小部件上时显示的消息。
这可以是纯文本消息或格式消息(HTML)。 您可以通过在小部件上调用.setToolTip("text")
来添加工具提示。 这通常用于协助用户。
工具提示示例
PyQt 工具提示示例
下面的程序将工具提示消息添加到按钮。 它可以是纯文本或 HTML 格式的标签(标签为粗体和斜体)。
您可以在工具提示消息中设置所需的任何消息。
from PyQt5.QtWidgets import *
import sys
class Window(QWidget):
def __init__(self):
QWidget.__init__(self)
layout = QGridLayout()
self.setLayout(layout)
button = QPushButton("Button")
button.setToolTip("This is a text")
layout.addWidget(button, 0, 0)
button = QPushButton("Button")
button.setToolTip("<b>HTML</b> <i>can</i> be shown too..")
layout.addWidget(button, 1, 0)
app = QApplication(sys.argv)
screen = Window()
screen.show()
sys.exit(app.exec_())
PyQt 工具箱
工具箱是一个容器。 它可以显示由选项卡分隔的项目组。 如果工具栏有很多项目,则可能需要一个工具箱。
工具箱QToolBox
的屏幕截图如下所示。
工具箱示例
QToolBox
下面的代码创建一个包含 3 个项目的工具箱。 工具箱QToolBox
具有方法.addItem()
。
工具箱本身必须添加到布局中,例如layout.addWidget(toolbox, 0, 0)
。
from PyQt5.QtWidgets import *
import sys
class Window(QWidget):
def __init__(self):
QWidget.__init__(self)
layout = QGridLayout()
self.setLayout(layout)
# Add toolbar and items
toolbox = QToolBox()
layout.addWidget(toolbox, 0, 0)
label = QLabel()
toolbox.addItem(label, "Students")
label = QLabel()
toolbox.addItem(label, "Teachers")
label = QLabel()
toolbox.addItem(label, "Directors")
app = QApplication(sys.argv)
screen = Window()
screen.show()
sys.exit(app.exec_())
PyQt 工具栏
PyQt 窗口除了文件菜单外,通常还具有工具栏QToolBar
。 工具栏包含一些按钮。 在网络浏览器中,这些按钮可以是后退,前进,刷新,主页。 在文本编辑器中,打开,保存等等。
在本文中,您将学习如何在窗口中添加工具栏。
工具栏
QToolBar
示例
下面的程序创建一个带有工具栏QToolBar
和按钮QToolButton
的窗口。 您可以将工具栏添加到任何 PyQt 窗口。 它还添加了文本框。
工具栏添加到布局QGridLayout
,按钮QToolButton
添加到QToolBar
。
from PyQt5.QtWidgets import *
import sys
class Window(QWidget):
def __init__(self):
QWidget.__init__(self)
layout = QGridLayout()
self.setLayout(layout)
# Create pyqt toolbar
toolBar = QToolBar()
layout.addWidget(toolBar)
# Add buttons to toolbar
toolButton = QToolButton()
toolButton.setText("Apple")
toolButton.setCheckable(True)
toolButton.setAutoExclusive(True)
toolBar.addWidget(toolButton)
toolButton = QToolButton()
toolButton.setText("Orange")
toolButton.setCheckable(True)
toolButton.setAutoExclusive(True)
toolBar.addWidget(toolButton)
# Add textfield to window
tbox = QPlainTextEdit()
layout.addWidget(tbox)
app = QApplication(sys.argv)
screen = Window()
screen.show()
sys.exit(app.exec_())
PyQt 菜单栏
菜单栏可以添加到 PyQt 窗口中。 它是带有按钮项的水平条,通常是文件菜单等。
本示例向 PyQt 窗口添加菜单栏和文本框。 如下面的屏幕截图所示。
PyQt 菜单栏
菜单栏示例
可以使用QMenuBar()
来构建菜单栏。 您可以像这样添加菜单.addMenu("File")
。 然后将操作添加到菜单,使.addAction("Open")
成为可能。
菜单栏必须添加到布局中,可通过此行layout.addWidget(menubar, 0, 0)
完成。
from PyQt5.QtCore import *
from PyQt5.QtWidgets import *
import sys
class Window(QWidget):
def __init__(self):
QWidget.__init__(self)
layout = QGridLayout()
self.setLayout(layout)
# create menu
menubar = QMenuBar()
layout.addWidget(menubar, 0, 0)
actionFile = menubar.addMenu("File")
actionFile.addAction("New")
actionFile.addAction("Open")
actionFile.addAction("Save")
actionFile.addSeparator()
actionFile.addAction("Quit")
menubar.addMenu("Edit")
menubar.addMenu("View")
menubar.addMenu("Help")
# add textbox
tbox = QPlainTextEdit()
layout.addWidget(tbox, 1, 0)
app = QApplication(sys.argv)
screen = Window()
screen.show()
sys.exit(app.exec_())
PyQt 标签小部件
标签可以添加到QTabWidget
中。 QTabWidget
可以添加到布局中,也可以添加到窗口中。
可以有任意数量的标签。 下例显示了添加标签的窗口。
图片:在 PyQt 窗口中显示的标签。
标签示例
PyQt 标签示例
运行以下代码,以在 PyQt 窗口中查看选项卡小部件。 在选项卡之间导航会显示添加到选项卡的小部件。
要将选项卡添加到QTabWidget
,请调用方法.addTab()
。
from PyQt5.QtCore import *
from PyQt5.QtWidgets import *
import sys
class Window(QWidget):
def __init__(self):
QWidget.__init__(self)
layout = QGridLayout()
self.setLayout(layout)
label1 = QLabel("Widget in Tab 1.")
label2 = QLabel("Widget in Tab 2.")
tabwidget = QTabWidget()
tabwidget.addTab(label1, "Tab 1")
tabwidget.addTab(label2, "Tab 2")
layout.addWidget(tabwidget, 0, 0)
app = QApplication(sys.argv)
screen = Window()
screen.show()
sys.exit(app.exec_())
PyQt 自动补全
PyQt 支持自动补全。 如果输入文本框(QLineEdit
),它可以提出建议。 从列表中推荐这些建议。
本示例将自动补全功能添加到QLineEdit
文本框中。
图片:在 PyQt 窗口中显示的标签。
自动补全
QLineEdit
自动补全示例
首先创建选项(名称)列表,然后创建completer = QCompleter(names)
。
使用行self.lineedit = QLineEdit()
创建行编辑。 否则,行编辑将正常进行。
这些建议已添加到self.lineedit.setCompleter(completer)
中。
如果忘记了最后一行,则QCompleter
和QLineEdit
未连接,这意味着没有自动补全。
from PyQt5.QtWidgets import *
import sys
class Window(QWidget):
def __init__(self):
QWidget.__init__(self)
layout = QGridLayout()
self.setLayout(layout)
# auto complete options
names = ["Apple", "Alps", "Berry", "Cherry" ]
completer = QCompleter(names)
# create line edit and add auto complete
self.lineedit = QLineEdit()
self.lineedit.setCompleter(completer)
layout.addWidget(self.lineedit, 0, 0)
app = QApplication(sys.argv)
screen = Window()
screen.show()
sys.exit(app.exec_())
PyQt 列表框
列表框(QListWidget
)提供了多个选项。 您可以单击一个项目。 想一想歌曲播放列表。 与组合框不同,它显示所有可能的选项。
下面的屏幕截图在一个窗口中显示了一个 PyQt 列表框。
PyQt 列表框示例
QListWidget
使用QListWidget()
创建一个列表框小部件。 然后添加带有self.listwidget.insertItem(0, "Red")
的项目,其中第一个参数是索引。
点击事件会添加点击的方法self.listwidget.clicked.connect(self.clicked)
from PyQt5.QtWidgets import *
import sys
class Window(QWidget):
def __init__(self):
QWidget.__init__(self)
layout = QGridLayout()
self.setLayout(layout)
self.listwidget = QListWidget()
self.listwidget.insertItem(0, "Red")
self.listwidget.insertItem(1, "Orange")
self.listwidget.insertItem(2, "Blue")
self.listwidget.insertItem(3, "White")
self.listwidget.insertItem(4, "Green")
self.listwidget.clicked.connect(self.clicked)
layout.addWidget(self.listwidget)
def clicked(self, qmodelindex):
item = self.listwidget.currentItem()
print(item.text())
app = QApplication(sys.argv)
screen = Window()
screen.show()
sys.exit(app.exec_())
PyQt 输入对话框
开箱即用地支持 PyQt 中的输入对话框(QInputDialog
)。 它具有输入文本,确定和取消按钮。
在本文中,您将看到它在 PyQt 中有效。 如屏幕截图所示
输入对话框
示例
下面的代码创建一个 PyQt 输入对话框。 单击按钮后,您可以输入一些文本。 文本显示为标签。
该对话框是使用showDialog
方法创建的,仅几行。 输入方言是PyQt5.QtWidgets
的一部分。
from PyQt5.QtWidgets import (QWidget, QPushButton, QLineEdit, QInputDialog, QApplication, QLabel)
import sys
class Example(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
# Add button
self.btn = QPushButton('Show Input Dialog', self)
self.btn.move(30, 20)
self.btn.clicked.connect(self.showDialog)
# Add label
self.le = QLabel(self)
self.le.move(30, 62)
self.le.resize(400,22)
self.setGeometry(300, 300, 290, 150)
self.setWindowTitle('Input dialog')
self.show()
def showDialog(self):
text, ok = QInputDialog.getText(self, 'Input Dialog', 'Enter text:')
if ok:
self.le.setText(str(text))
if __name__ == '__main__':
app = QApplication(sys.argv)
ex = Example()
sys.exit(app.exec_())
Qt Designer Python
Qt Designer 可以帮助您构建 GUI(图形用户界面)。 您可以从 Python 加载 GUI。 在本教程中,我们将逐步向您展示。
它涵盖了一个非常基本的示例,说明如何将 Qt Designer 与 PyQt 和 Python 一起使用。 有关更多详细信息,请参见下面的链接。
Qt Designer Python
先决条件
要开始本教程,您需要安装以下内容:
- Python
- PyQt
- Qt Designer
您将需要 Python 3 或更高版本,因为其他版本已过时。
如果您没有 PyQt,请安装 PyQt。
您可以使用以下工具安装 Designer(Ubuntu Linux):
sudo apt-get install qttools5-dev-tools
sudo apt-get install qttools5-dev
在其他平台上,它包含在设置中。
如何启动 Designer
通过在命令行中输入designer
来启动设计器。 QT Creator 是另一个程序。
在 Ubuntu Linux 上:
cd /usr/lib/x86_64-linux-gnu/qt5/bin/
./designer
基础
出现一个弹出窗口。 您可以选择要设计的东西。
选择“主窗口”,然后单击“创建”。
然后,您可以调整表单的大小并拖放小部件。 设计这样的图形界面非常简单。
如果单击窗口小部件(例如按钮),则可以设置其属性,例如名称。
将设计导出到 UI
您可以将设计导出到 UI 文件。 单击“文件 -> 另存为 -> yourname.ui
”
然后,您可以将 ui 代码转换为 python 文件。像这样:
pyuic5 /home/linux/helloworld.ui -o helloworld.py
然后,Python 文件包含 gui 定义。创建另一个加载 ui 文件的文件:
from PyQt5 import QtCore, QtGui, QtWidgets
from PyQt5.QtWidgets import QApplication
import sys
import helloworld
class ExampleApp(QtWidgets.QMainWindow, helloworld.Ui_MainWindow):
def __init__(self, parent=None):
super(ExampleApp, self).__init__(parent)
self.setupUi(self)
def main():
app = QApplication(sys.argv)
form = ExampleApp()
form.show()
app.exec_()
if __name__ == '__main__':
main()
一旦运行它,GUI 就会出现。
机器学习
数据科学
数据科学是科学地从各种结构化和非结构化数据中提取知识的过程。 它是一个多学科领域,使用不同种类的算法和技术来识别数据的真实目的和含义。
数据科学家需要具备高超的技术才能解释数据并提取含义。 数据科学家需要成为各种数据科学工具的专家,例如分析工具,数据可视化工具,数据库工具和其他工具。 数据科学包括以下组件,数据分析&:
数据科学
探索数据
数据科学主要从探索和分析开始。 数据科学家探索数据并将其处理到微观层次。
在开始数据分析之前,将识别具有不同数据集的常见数据并进行分类。 KNIME,OpenRefin,Orange,RapidMiner,Pentaho,Talend 是用于此类工作的一些数据探索和数据分析工具。
数据可视化
数据科学中的可视化意味着通过各种可视内容以更容易理解的方式呈现数据。
这主要是针对不了解数据技术表示形式的普通读者完成的。 数据的可视化对于将数据呈现给最终用户非常有效。
一些数据可视化工具是 Tableau,Infogram,ChartBlocks,Datawrapper,Plotly,RAW,Visual.ly 等。
经典机器学习
在数据科学中,计算机本身学习如何使用不同的算法和统计信息来计算不同的数据。
该技术非常耗时且复杂。 但是随着时间的流逝,它现在变得越来越快。
这些类型的计算称为机器学习或人工智能。
它无需程序员的帮助即可自动从工作和系统中学习。 这些类型的软件应用程序根据其计算经验进行学习。
一些机器学习工具包括 Google ML Kit,OpenNN,Apache Mahout,HPE Haven OnDemand,HPE Haven OnDemand 等。
深度学习
深度学习或深度学习实际上是机器学习的一部分。 它基于数据表示和算法。
这种深度学习技术对于数据科学至关重要。 ylearn2,Theano,Caffe,Torch,Cuda-convent,Deeplearning4j 这些是用于数据科学中深度学习的一些工具。
数据存储和大数据框架
数据是数据科学过程的核心和主要组成部分。 公司将数据存储在大型基础架构中,并为存储的数据设置不同的框架。
所有数据都以井井有条的方式存储,因此用户可以轻松访问和处理数据。 它使数据科学家可以轻松地分析,探索,访问和处理海量数据。
总结
如今,对数据科学的最初威胁是难以阅读某些自然语言,数据处理和图像处理。
尽管开发了各种应用程序和软件来限制这些威胁,但仍出现了新问题。
数据科学是计算机科学中的下一件大事。 对新数据科学家的需求正在迅速扩展,并且该行业正在迅速发展。
如何从机器学习和 AI 认真地起步
原文: https://pythonbasics.org/how-to-seriously-start-with-machine-learning-and-ai/
计算机科学是一个很大的领域,但是我们将专注于人工智能和机器学习。
机器学习和 AI 用于医疗保健,汽车,政府,军事,金融和经济学,视频游戏,广告,艺术等领域。 每个有兴趣的人都可以达到的目标。
机器学习算法可以做出预测或决策。 他们使用训练数据来训练模型,他们“从数据中学习”。
因此,您了解所有这一切,并且可能想知道“我如何开始?”
从机器学习开始
课程
课堂课程或在线课程。 报名参加课程之前,了解基本知识很重要。 您并没有那么快或太慢的解释,所以确保您能赶上进度是最好的。
书籍
书籍既经典又安全。 真正的文档是下一步。 从人工智能到最简单的编程语言,都有关于这一切的书籍。
互联网
今天,当您考虑学习某事时,首先想到的就是 Google。
在互联网上搜索信息很有用,请不要小看自我学习。
在线教程非常适合开始练习。 如果您有计算机并且有时间去做,那么教程可能会让您了解 AI 和 ML 的工作方式。
大学
学院。 取决于您已经学习的内容和可能性; 大学是知识专业化的最佳途径。
有时大学提供一些短期课程,您可以尝试; 在进行金融投资之前,要真正了解您是否有这种想法。
无论您做什么学习,都不要忘记科学是试错法。
为什么要使用 Python 进行机器学习?
原文: https://pythonbasics.org/why-python-for-machine-learning/
机器学习(ML)是一种编程类型,它使计算机能够自动从提供给他们的数据中学习,并从经验中进行改进,而无需刻意进行编程。
它基于解析数据,学习和分析数据并以自主方式做出预测或智能决策的算法。
借助机器学习的这种巧妙表征,它通常可以与人工智能(AI)互换。
但是,准确地说,机器学习只是人工智能的一个子集。 机器学习是简单地应用的 AI,其基于这样的思想,即需要授予机器访问数据的权限,以便他们自己学习和分析数据。
为什么使用 Python 进行机器学习?
您可能会问:用于机器学习的最佳编程语言是什么?
如果继续阅读,您将了解为什么将 Python 用于机器学习是您的首选。
1. Python 易于理解
重申一下,机器学习只是在识别数据中的模式,从而能够自己进行改进和做出明智的决策。
Python 是最合适的编程语言,因为它易于理解,您可以自己阅读。
它的可读性,非复杂性以及快速原型制作的能力使其成为全球开发人员和程序员中的流行语言。
2. Python 附带了大量库
这些内置库中有许多是用于机器学习和人工智能的,可以很容易地直接使用。
一些库是:
- scikit-learn 用于数据挖掘,分析和机器学习;
- Tensorflow 是高级神经网络库;
- pylearn2 也是数据挖掘和机器学习的理想选择,但比 scikit-learn 更灵活。
3. Python 允许简单而强大的实现
使得 Python 成为机器学习的最佳选择之一的原因是它的简单而强大的实现。
对于其他编程语言,编码初学者或学生需要首先熟悉该语言,然后才能将其用于 ML 或 AI。
Python 并非如此。 即使您仅具有 Python 语言的基本知识,由于拥有大量可用的库,资源和工具,因此您可以将它用于机器学习。
此外,与使用 Java 或 C++ 相比,在 Python 上编写代码和调试错误的时间更少。
一般来说,ML 和 AI 程序员宁愿花时间构建算法和启发式算法,也不愿为语法错误而调试代码。
4. 友好的语法和人类可读性
Python 是一种使用现代脚本和友好语法的面向对象的编程语言。
Python 的脚本设计具有几乎与人类一样的可读性,使脚本编写人员和程序员能够测试其假设并非常快速地运行其算法。
这就是为什么像 Java,Perl 和 C++ 这样需要硬编码的结构化编程语言通常不被机器学习所青睐的原因。
总之,无论您是经验丰富的程序员还是编码初学者,都可以使用 Python 做很多事情,这对于执行一组复杂的机器学习任务非常理想。
上面提到的所有原因都使 Python 成为 IT 界首选的且广受欢迎的语言技能。
5. 社区
最后,Python 提供了广泛的支持。 由于许多人(无论是程序员还是普通用户)都将 Python 视为标准,因此它的支持社区非常庞大,从而极大地提高了 Python 的知名度。
机器学习库
每个程序员都应该了解 Python 机器学习的库。
如果开发人员需要从事统计技术或数据分析工作,那么他或她将(可能)考虑使用 Python。
该编程语言以友好,易学而著称,并且具有用于机器学习的大量库。
在机器学习方面,Python 绝对是最受欢迎的选择之一。
可是等等! 首先,让我们弄清楚什么是机器学习以及什么是库。
什么是机器学习?
机器学习实际上是对算法的研究,该算法允许人工智能通过机器从数据中学习。
那不是令人难以置信吗? 总有一天,技术将能够以我们人类无法实现的方式为我们学习和理解信息。
另一方面,库是用诸如 Python 之类的编程语言编写的例程和函数集。 这样,开发人员可以避免编写多行代码。
它背后的魔力是数学,统计学和概率。
机器学习库
那么,哪些是 python 机器学习的基本库?
Pandas
熊猫是数据科学的基础。 这是用于数据集的强制性库,用于数据提取和准备。
熊猫提供了用于分组,合并和过滤数据以及执行时间序列分析的方法。
它有两个主要结构:一维(系列)和二维(数据帧)。
熊猫的关键字是标签和关系数据。
Matplotlib
当开发人员考虑可视化库时,首先想到的就是这种方法。
Matplotlib 通常用于创建 2D 绘图和图形。 开发人员还可以绘制图表,直方图和散点图。
一方面有一个很低的层次,因为程序员需要知道更多的命令,但是…另一方面,有了权限和足够的命令,您就可以制作所需的图形。
Seaborn
Seaborn 是“另一个”可视化库。 它建立在 Matplotlib 的基础上,不仅取决于它,而且还可以将其发展到更高的层次。
Seaborn 使生成某些类型的图,热图,时间序列和小提琴图更容易。
Scikit-learn
Scikit-learn 管理两个基本术语:数据挖掘和数据分析。
是使用经典 ML 算法的理想选择。
Scikit-learn 的设计能够与 SciPy 和 NumPy 等其他 Python 库进行互操作。
Tensorflow
TensorFlow 是用于数据流和差异化编程的最受欢迎的开源软件库之一。
有时不一定需要深度学习算法,但有用吗? 您永远不要怀疑,这就是 TensorFlow 的目的。
TensorFlow 非常适合在以下两种平台上运行和编译:中央处理器和图形处理器。
Theano
Theano 与 TensorFlow 有很多共同点:也用于深度学习,并且可以在 CPU 和 GPU 上使用。
这是一个多维数组,具有数学表达式和运算,两者都与 NumPy 相似。
考虑到 Theano 是最繁重的库之一,Theano 可根据需要进行评估,优化和定义。
在有监督或无监督的机器学习人工智能是改善编程和开发所必需的工具。
什么是机器学习?
机器学习是人工智能的一个子领域。
科学家一直在尝试制造智能机器。 这台机器擅长于一件事,除了编程要完成的任务外,只有一件事无能为力。
机器学习
历史
1997 年,一台名为“深蓝”的计算机击败了世界象棋世界象棋锦标赛的冠军。聪明? 不,这是这台计算机所能做的:它无能为力。
因此,如果您遇到新问题,计算机将无法解决。 这意味着用新的逻辑和规则创建一个新程序。
您可以使用从示例和经验中学习的算法,而不必依赖硬编码规则。 这称为机器学习。
示例
机器学习算法可以解决许多问题,例如:
- 垃圾邮件分类:电子邮件是否是垃圾邮件。
- 文档分类:它是什么类型的文档。
- 人脸检测:是不是人脸?
- 价格预测:预期价格是多少?。
还有很多。
机器学习算法有不同类型,它们可以分为:
- 监督学习算法
- 无监督学习算法
分类
监督学习问题的一种类型是分类。 假设算法必须确定电子邮件是否为垃圾邮件。 您可以编写许多逻辑规则,但这很难维护并且很难更改。
您可以做的是创建一个程序,该程序使用应为输入生成的带有标签的输出示例。 该程序使用交易数据。 用训练数据对算法进行训练后,您可以进行预测。
给定一个新的示例电子邮件,该算法可以预测/分类,无论新电子邮件是垃圾邮件还是垃圾邮件。 由于使用了训练数据,因此我们将其称为监督学习算法。
区分机器学习,深度学习和 AI?
原文: https://pythonbasics.org/difference-machine-learning-deep-learning-ai/
人工智能,机器学习和深度学习之间有什么区别?
人工智能(AI),机器学习和深度学习是流行的术语。
但是名字叫什么?
这些短语混合起来就好像它们是可互换的,因为它们都围绕着几种使用数据解释来解决问题的技术。
这些术语背后的关键概念非常不同。 这是对这些技术的一般描述。
人工智能
人工智能是指机器执行复杂任务的能力,这是一个通用术语。 通常,这些是基于能够进行认知计算的算法的软件。
这包括机器人技术,自然语言处理,机器学习和深度学习。
计算能力的指数级增长已导致 AI 应用程序的爆炸式增长。您现在在科幻小说中看到的东西已经成为日常生活的一部分。
机器现在可以执行复杂的任务,而无需人工干预。这种最著名的两种形式是机器学习和深度学习。
机器学习
机器学习的思想可以追溯到 1950 年代后期。 他从斯坦福大学的一位计算机科学家开始,他认为:机器可以自己学习,而不是由人类教计算机。
学习过程需要数据,并且在线生成了大量数据,这才开始。
机器学习由可分析数据并从中学习的算法组成。这些算法使软件能够进行预测和关联。
这不同于传统编程,在传统编程中,软件依赖于手动编码的软件例程。
真实世界示例:为防止欺诈,机器学习有助于识别模式,行为和风险趋势并对之做出反应。 它使用训练数据来这样做。
深度学习
深度学习是指一类特定的机器学习和人工智能。深度学习基于神经网络。
神经网络创建于 1950 年代,其灵感来自人脑生物学模型。
如果我们说机器学习是人工智能的一个分支,那么深度学习就是机器学习的一个分支。
深度学习是一组机器学习算法,它们使用能够从经验中学习的复杂神经网络。 这些系统必须根据现有示例进行训练。
它如何工作?
在神经网络中,人工神经元被分为几层。 信息是单向流动的。 一层中的每个神经元都与其余的神经元进行通信,直到到达网络的尽头。 结果是深度学习能够使用大量数据为复杂的决策提供计算机系统。
机器学习
在想学习 Python 的人当中,Scikit 是目前最热门的名称之一。 它是最有效的机器学习库。 scikit 最好的部分是初学者可以发现它有效。
使用 Python 进行机器学习
Scikit-Learn 简介
首先,该工具以前称为 scikit-learn,主要是一个免费的工具机器学习平台,专门用于 Python 编码语言。 该软件带有一系列分类,回归以及一堆算法,其中还包括支持向量机。
也有梯度增强,随机森林,DBSCAN,k-means。 其开发的主要目的是沿着编程编号以及 NumPy 和 Scipy 之类的技术库交换和使用数据。 如上所述,由 David Cournapeau 编写的 Google Summer of Code 项目以 scikit-learn 的形式引入了该机器学习平台。
该名称来源于基本概念,即该产品是“SciKit”或 SciPy Toolkit,这是 SciPy 的独特制造和提供的外部组件。 然后,其他编码人员再次编写了本机代码平台。 据说 scikit-learn 仍处于开发阶段。
Scikit 入门
开始执行时,该工具主要是使用 Python 准备的。 但是,某些核心算法是用 Cython 编码的,其主要目的是提高性能。 LIBSVM 上的 Cython 封面执行支持向量机。 另一方面,逻辑回归以及线性支持向量机是通过围绕 LIBLINEAR 的等效覆盖完成的。
最终,机器学习平台简单易用,使数据挖掘和分析变得简单。 每个人都可以使用该工具。 它可以在各个方面重复使用。 这个开源工具也可以用于商业目的。 它所需要的只是拥有 BSD 许可证。 在将本机数据集应用于机器学习后,就可以立即开始一个项目。
pip install sklearn
应用
初级或初学者的 Python 机器学习过去很难。 但是,用户友好的机器学习平台 Scikit-learn 确实使事情变得更简单。 使用 scikit-learn 学习,以及进行任何类型的定制产品开发或用于 R&D 用途。 Scikit 附带了一系列模块和库,供初学者选择,从而提供了处理特定任务的多种方式。 在学习的同时,可以处理一个完整的项目。
作为工具的 Scikit 非常易于使用。 您可以简单地安装该工具并在初始阶段开始使用 Python 解释器。 特别是,该工具对于寻找小型端到端项目的初学者可能很有用。
尽管有各种版本的 Scikits 软件,但 Scikit-Learn 确实是用于机器学习 Python 的最先进且配备最完善的工具。 Scikit-Image 被认为是同等丰富的工具。
机器学习算法比较
原文: https://pythonbasics.org/machine-learning-algorithms-comparison/
人工智能(特别是机器学习)的创建是为了简化开发人员和程序员的工作。
不必编写很多代码,您必须在机器学习算法之间进行选择,然后再决定一种编程语言。 那可能很棘手。
为什么? 首先,有四种类型的机器学习算法。
机器学习算法
监督学习
监督学习基于标记的训练数据。
监督学习的基础是称为训练数据的数据和一组训练示例。
带标签的训练集具有预测其他对象上未知标签的特征。
它有两种类型:
- 回归(如果标签是实数)
- 分类(如果标签是有限且无序的)。
无监督学习
无监督学习是无标签数据。
无监督学习的基础是关于对象的信息较少。 这些测试数据没有标签,分类或分类。
无监督学习可以在群集中创建具有相似性的对象组,并将所有群集中的不同对象(假定这些对象为异常)分离。
半监督学习
半监督学习被标记和未被标记。
收集有监督和无监督的利弊,半监督学习尤其适合那些无法标记其数据的人。
训练集具有标记和未标记两种,以提高准确性。
强化学习
强化学习正在采取行动。
它与之前的有所不同,因为没有用于强化学习的数据集。
强化学习是软件代理应采取的措施以最大化回报。 这是训练以最有效的方式行事。
算法
因此,知道了这一点,就可以快速恢复六种机器学习算法。
- 线性回归 & 线性分类器:如果有最简单的算法,应该使用这些算法。 当您具有成千上万的特征并需要提供不错的质量时,可以使用它。
比这些更好的算法可能会过拟合,而回归和分类器将确保大量特征。
-
Logistic 回归:执行二进制分类,因此标签输出为二进制。 它采用特征的线性组合,并对其应用非线性函数。 这是非线性分类器最简单的算法。
-
决策树:树枝和树叶可以挽救生命。 该算法是从观察到结论的预测模型。 真实的人可以使用决策树来做出决策,这使得它很容易理解。 最容易解释的通常用于组成随机森林或渐变增强。
-
K-均值:如果您的目标是根据对象的特征分配标签,但是您没有任何标签,则称为聚类任务,该算法可以实现这一任务。 但是,有多种聚类方法具有不同的优缺点,应该首先考虑一下。
-
主成分分析(PCA):当您具有广泛的特征,彼此之间高度相关并且模型很容易适合大量数据时,可以应用它。 该算法在减少信息损失最小的情况下很好地减少了维数。
-
神经网络:每个特定任务都有许多不同的体系结构或一系列层/组件。 在处理图像时,神经网络是理想的选择。 他们的训练需要巨大的计算复杂性,但却提出了算法的新时代。
为什么要使用 Scikit-Learn?
为什么要使用 Scikit-learn 进行机器学习?
在讨论“为什么要被用作或推荐为 python 编程语言的最佳免费软件机器学习库之前,我们对 scikit-learn(sklearn)了解甚少,这一点很重要。
Scikit-Learn
什么是 Scikit-Learn
Sсіkіt-lеаrn(sklearn)是一种免费使用的机器学习模块。 这是用于数据分析和机器学习的简有效的工具。 因为它在 BSD 协议下发布,所以无论是出于商业目的还是出于商业目的,都可以使用它。
在 scikit-learn 中,用户可以执行不同类别的多种任务,例如模型选择,聚类,预处理和更多。 该模块提供了实现完整的手段。
为什么要学习 Scikit?
基于以下原因,我建议使用 scikit-learn
1. 使用各种工具简单易学
Sсіkіt-lеаrn 提供了很多简单的,еаѕу到 lеаrnаlgоrіthmѕ是рrеttуmuсh 只有 rеԛuіrеуоurdаtа着 tоbеоrgаnіzеd 在 thеrіghtwауbеfоrе可以运行 whаtеvеrсlаѕѕіfісаtіоn,rеgrеѕѕіоn,оr 集群аlgоrіthm 你 nееd[HTG1。
该系统中的реретерие可使数据的传输过程更加轻松。
Scikit 学习有很多方法可以帮助您找到正确的变量和变量。 有了一项新的工作,一个新的数据科学家就可以在几分钟之内做出最准确的预测。
2、. 解决不同类型问题的能力
Scikit-learn 可以用于机器学习中三种不同的问题,即监督学习,无监督学习和强化学习(AlрhаGо)。
无监督学习的情况下,其数据集中就没有“您”的踪影。降维和聚类是两个例子。
Scikit-learn 具有主成分分析的不同实现(例如SparsePCA
,KerrnlPCA
和IncrementalPCA
等)。
监督学习涵盖的问题包括垃圾邮件检测,租金预测等等,在这些问题中,数据集展示了 y 标签。例如线性回归,随机森林,adaboost 等的模型已在 Sklearn 中实现。
3. 主动和开源
Sklearn 是一种非常活跃的解决方案,它可以极大地简化您的工作。 通常是通过 Sроtіfу,booking.com 和其他网站来进行搜索。
这是因为,任何人都可以确保自己的完整性,但是从我合并后的经验中,我可以告诉您很多。让我们告诉您-
所有的原因都至少有两个方面引起了争议。 每个代码都经过多次验证。 尽管这可以解决所有问题,但必须确保 Sklearn 在所有情况下都具有其过时的标准。
您不必一夜之间就建立起了一个“最原始的来源”之类的链接!
4. 有助于高度不平衡的疾病的检测
Scikit-learn 还可以通过诸如 EllipticEnvelope 和 OnSclsSVM 等多种工具在高度不平衡的数据中(99.9% 到 0.1% 的欺诈检测中)提供帮助。
在这方面,在较大的尺寸范围内,具有较大性能的 Riso 隔离森林算法尤其适用。
Scikit-learn 实际上是最好的选择。
如何在 Python 中加载机器学习数据
原文: https://pythonbasics.org/how-to-load-machine-learning-data-in-python/
为了使用 Python 启动您的机器学习项目,您需要能够正确加载数据。 如果您是 Python 的初学者,本文将帮助您学习如何使用三种不同的技术来加载机器学习数据。
加载机器学习数据
在深入探讨之前,您需要知道 CSV 或逗号分隔的值是呈现机器学习数据的最常用格式。 在机器学习数据的 CSV 文件中,您需要了解一些零件和功能。 这些包括:
- CSV 文件标题:CSV 文件中的标题用于将名称或标签自动分配给数据集的每一列。 如果您的文件没有标题,则必须手动命名属性。
- 注释:当一行以井号(
#
)开头时,您可以在 CSV 文件中标识注释。 根据您选择的加载机器学习数据的方法,您将不得不确定是否要显示这些注释,以及如何识别它们。 - 定界符:定界符分隔字段中的多个值,并用逗号(
,
)表示。 制表符(\t
)是可以使用的另一个定界符,但是必须明确指定它。 - 引号:如果文件中的字段值包含空格,则通常会用引号引起来,并且表示该值的符号为双引号。 如果选择使用字符,则需要在文件中指定。
在确定了数据文件的这些关键部分之后,让我们继续学习如何在 Python 中加载机器学习数据的不同方法。
使用 Python 标准库加载数据
使用 Python 标准库,您将使用模块 CSV 和函数reader()
加载 CSV 文件。 加载后,CSV 数据将自动转换为 NumPy 数组,可用于机器学习。
例如,下面是一个小代码,当您使用 Python API 运行时,它将加载没有标题且包含数字字段的该数据集。 它还将自动将其转换为 NumPy 数组。
# Load CSV (using python)
import csv
import numpy
filename = 'pima-indians-diabetes.data.csv'
raw_data = open(filename, 'rt')
reader = csv.reader(raw_data, delimiter=',', quoting=csv.QUOTE_NONE)
x = list(reader)
data = numpy.array(x).astype('float')
print(data.shape)
简而言之,该代码命令程序加载一个对象,该对象可以对数据的每一行进行迭代,并且可以轻松地转换为 NumPy 数组。 运行示例代码将产生以下形状的数组:
1 (768, 9)
用 NumPy 加载数据文件
在 Python 中加载机器学习数据的另一种方法是使用 NumPy 和numpy.loadtxt()
函数。
在下面的示例代码中,该函数假定您的文件没有标题行,并且所有数据都使用相同的格式。 它还假定文件pima-indians-diabetes.data.csv
存储在当前目录中。
# Load CSV
import numpy
filename = 'pima-indians-diabetes.data.csv'
raw_data = open(filename, 'rt')
data = numpy.loadtxt(raw_data, delimiter=",")
print(data.shape)
运行上面的示例代码会将文件加载为numpy.ndarray
并产生以下数据形状:
1 (768, 9)
如果可以使用 URL 检索文件,则可以将以上代码修改为以下代码,同时产生相同的数据集:
# Load CSV from URL using NumPy
from numpy import loadtxt
from urllib.request import urlopen
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indiansiabetes.data.csv'
raw_data = urlopen(url)
dataset = loadtxt(raw_data, delimiter=",")
print(dataset.shape)
运行代码将产生相同的结果数据形状:
1 (768, 9)
用 Pandas 加载数据文件
加载机器学习数据的第三种方法是使用 Pandas 和pandas.read_csv()
函数。
pandas.read_csv()
函数非常灵活,是加载机器学习数据的最理想方法。 它返回一个pandas.DataFrame
,使您可以立即开始汇总和绘图。
下面的示例代码假定pima-indians-diabetes.data.csv
文件存储在当前目录中。
1 # Load CSV using Pandas
2 import pandas
3 filename = 'pima-indians-diabetes.data.csv'
4 names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
5 data = pandas.read_csv(filename, names=names)
6 print(data.shape)
您将在此处注意到,我们已将每个属性的名称明确标识为DataFrame
。 当我们运行上面的示例代码时,将打印以下形状的数据:
1 (768, 9)
如果可以使用 URL 检索文件,则可以对以上代码进行以下修改,同时生成相同的数据集:
1 # Load CSV using Pandas from URL
2 Import pandas
3 url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv"
4 names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
5 data = pandas.read_csv(url, names=names)
6 print(data.shape)
运行上面的示例代码将下载一个 CSV 文件,对其进行解析,并生成以下形状的已加载DataFrame
:
1 (768, 9)
机器学习分类器
分类是机器学习任务之一。 那么什么是分类呢?
您一直都在对数据进行分类。
看看任何物体,您将立即知道它属于哪个类:它是杯子,桌子还是椅子。这是分类的任务,计算机可以执行此操作(基于数据)。
本文是面向初学者的机器学习。 让我们做第一个机器学习程序
监督机器学习
训练数据
导入机器学习模块sklearn
。 (受监督)机器学习算法使用示例或训练数据。 训练阶段是机器学习算法的第一步。
由于使用示例数据,因此请首先收集数据。像一组苹果和桔子的图像,并记下了特征。
特征可用于区分两个类别。特征是一种属性,例如颜色,形状或重量。 它可以表示为数值。
关键任务之一是从训练数据中获得良好的特征。 写下每个图像的类别。 类别是类,对于苹果,您可以选择 0 类,对于橘子,您可以采用 1 类。
您可以根据需要设置任意多个类,但是在此示例中,我们将使用 2 个类(苹果和橘子)。
水平写入特征,该线代表第一张图像。
因此,这称为特征向量。 这组数字代表图像。
分类器
在训练阶段之后,分类器可以做出预测。给定一个新的特征向量,该图像是苹果还是桔子?
分类算法有多种类型,其中一种是决策树。
如果您有新数据,则算法可以确定新数据属于哪个类。苹果的输出为[0]
,橙色的输出为[1]
。
所以这是新数据,然后我们简单地使算法进行预测。
from sklearn import tree
features = [[0,50],[0,60],[1,35],[1,36],[1,40]]
labels = [0,0,1,1,1]
algorithm = tree.DecisionTreeClassifier()
algorithm = algorithm.fit(features, labels)
newData = [[0,51]]
print(algorithm.predict(newData))
过拟合和欠拟合
通常,训练数据越多,分类器就越好。如果您的训练数据很少(不及),那么您将没有好的预测。
因此,总的来说,随着更多数据它变得更加准确。 但是有一个限制,那就是过拟合。
机器学习回归
线性回归算法可预测连续值(例如价格,温度)。这是针对初学者的机器学习算法系列中的另一篇文章。这是一种有监督的学习算法,您需要收集训练数据才能使其工作。
线性回归
简介
分类输出只能是离散值。 可以有[0]
,[1]
,[2]
等。如果要输出价格或其他连续值怎么办?
然后,您使用回归算法。
假设您要根据特征预测房价。 收集数据是
的第一步。 特征可能是房间数量,以 m^2 为单位的面积,邻里质量等。
示例
写下特征:#area_m2
。对于我们的示例代码,如下所示。
from sklearn.linear_model import LinearRegression
X = [[4], [8], [12], [16], [18]]
y = [[40000], [80000], [100000], [120000], [150000]]
model = LinearRegression()
model.fit(X,y)
# predict
rooms = 11
prediction = model.predict([[rooms]])
print('Price prediction: $%.2f' % prediction)
然后,您可以根据该数据创建绘图(如果需要)。您看到面积与价格之间存在相关性。
这是线性关系。您可以使用线性回归算法预测价格。
解释
首先,从学习的过程中导入线性回归算法,然后定义训练数据X
和Y
,其中x
是面积,y
是价格。
model = LinearRegression()
model.fit(X,y)
线性回归算法由于存在线性关系,因此我们使用训练数据来训练算法。
现在已经对算法进行了训练,您可以使用该区域进行预测了。一个新示例,可以为您预测价格。
rooms = 11
prediction = model.predict([[rooms]])
print('Price prediction: $%.2f' % prediction)
仅当数据集中存在线性关系时,算法LinearRegression
才有效。如果没有,则需要多项式算法。
绘图以确认存在线性关系。
Python 中的多项式回归
原文: https://pythonbasics.org/polynomial-regression-in-python/
多项式回归可能非常有用。 X 和 Y 之间并不总是存在线性关系。有时,该关系是指数级或 N 阶。
回归
多项式回归
您可以绘制 X 和 Y 之间的多项式关系。如果没有线性关系,则可能需要多项式。 与线性关系不同,多项式可以更好地拟合数据。
您只需一行代码即可创建此多项式行。
poly_fit = np.poly1d(np.polyfit(X,Y, 2))
那将训练算法并使用二阶多项式。
训练后,您可以使用一个新示例通过调用polyfit
来预测值。 然后它将输出一个连续值。
示例
下面的示例在收集到的数据上方绘制了一条多项式线。 它训练算法,然后预测连续值。
import numpy as np
import matplotlib.pyplot as plt
X = [1, 5, 8, 10, 14, 18]
Y = [1, 1, 10, 20, 45, 75]
# Train Algorithm (Polynomial)
degree = 2
poly_fit = np.poly1d(np.polyfit(X,Y, degree))
# Plot data
xx = np.linspace(0, 26, 100)
plt.plot(xx, poly_fit(xx), c='r',linestyle='-')
plt.title('Polynomial')
plt.xlabel('X')
plt.ylabel('Y')
plt.axis([0, 25, 0, 100])
plt.grid(True)
plt.scatter(X, Y)
plt.show()
# Predict price
print( poly_fit(12) )
过拟合和欠拟合
切勿过拟合或欠拟合,这是很重要的,您想抓住这种关系但又不能完全遵循这些要点。 线性关系会欠拟合,而过拟合会选择程度高到可以拟合点的程度。 相反,您想要捕获关系。
决策树
决策树是最流行的监督式机器学习算法之一。
是从观察到结论的预测模型。 观察结果以分支表示,结论以叶子表示。
如果模型的目标变量可以采用离散值集,则为分类树。
如果模型的目标变量可以采用连续值,则为回归树。
决策树在统计和数据挖掘中也很常见。 这是一个简单但有用的机器学习结构。
决策树
简介
如何理解决策树? 让我们举一个二进制的例子!
在计算机科学中,树木从上到下倒置生长。
最重要的问题是称为根节点的问题。 就像真正的树木一样,一切都从那里开始。
该问题有两个可能的答案,因此答案(在这种情况下)是从树中引出的两个分支节点。
所有不是根或分支的东西都是叶子。 叶子节点可以填充其他答案或条件。 离开也可以称为决策。
您可以重复此过程,直到“决策树”完成为止。 从理论上讲,就是这么简单。
算法
算法将其处理为:
决策树具有对象,而对象具有语句。
每个语句都有特征。
特征是对象的属性。
算法会研究此过程,直到完成每个语句和每个特征。
要以编程语言使用决策树,请执行以下步骤:
- 呈现数据集。
- 训练模型,从描述性特征和目标特征中学习。
- 继续树直到完成一个标准。
- 创建代表预测的叶节点。
- 显示实例并沿着树运行,直到到达叶节点。
做完了!
数据集
我们从一个数据集开始
下雨 | 决策 |
---|---|
否 | 不打伞 |
是 | 打伞 |
可以简化为:
下雨 | 决策 |
---|---|
0 | 0 |
1 | 1 |
因此,相应的X
(特征)和Y
(决策/标签)为:
X = [[0], [1]]
Y = [0, 1]
决策树代码
Sklearn 支持开箱即用的决策树。
然后,您可以运行以下代码:
from sklearn import tree
from sklearn.model_selection import train_test_split
import numpy as np
# Create Decision Tree
features = ['raining']
X = [[0], [1]]
Y = [0, 1]
clf = tree.DecisionTreeClassifier()
clf.fit(X,Y)
# Visualize Tree
dotfile = open("dtree.dot", 'w')
tree.export_graphviz(clf, out_file = dotfile, feature_names=features, filled=True, round\
ed=True, impurity=False, class_names=['No Umbrella','Umbrella'])
dotfile.close()
这将创建树并输出一个点文件。 您可以使用 Webgraphviz 通过在其中粘贴点代码来形象化树。
创建模型将能够对未知实例进行预测,因为它可以对已知描述性特征与已知目标特征之间的关系进行建模。
print( clf.predict([[0]]) )
重要概念
最后,快速回顾一下决策树和机器学习的 4 个重要概念。
-
期望值:表示随机变量的期望值。 对决策树进行了预期价值分析,以确定风险的严重性。 为此,我们必须以 0.0 到 1.0 之间的数字来衡量风险的可能性。
-
熵:测量信息。 是指定新实例是否应归为一个或另一个实例所需的预期信息量。 熵的思想是相对于可能的分类类别量化概率分布的不确定性。
-
准确性:是做出的正确预测数除以做出的预测总数。 我们要做的是检查机器学习模型的准确性。
-
过拟合:之所以发生,是因为训练模型试图尽可能地拟合训练数据。 为了防止这种情况,请尝试减少数据中的噪音。
这就是决策树和机器学习的基础知识!
k 最近邻
认识 K 最近邻,这是最简单的机器学习算法之一。
该算法用于分类和回归。 在这两种使用中,输入均包含特征空间中 k 个最接近的训练示例。 另一方面,输出取决于大小写。
- 在“K 最近邻分类”中,输出是类成员。
- 在“K 最近邻回归”中,输出是对象的属性值。
K 最近邻易于实现,并且能够执行复杂的分类任务。
KNN
k 最近邻
由于它没有专门的训练阶段,因此被称为惰性学习算法。
它是一种非参数学习算法,因此不会对基础数据做任何假设。 由于大多数数据都没有遵循理论上的假设,因此是一项有用的功能。
k 最近邻的最大优势在于,该算法无需进行训练即可进行预测,从而可以添加新数据。
最大的缺点是该算法难以计算高维数据的距离。
应用
K 最近邻有很多应用程序。
一些示例可以是:
-
收集财务特征以将具有相似财务特征的人与数据库进行比较,以进行信用评级。
-
将可能成为潜在选民的人分类为一个政党或另一党,以预测政治。
-
模式识别可检测手写,图像识别和视频识别。
k 最近邻算法
K 最近邻(knn)具有您应了解的理论。
-
首先,K 最近邻仅计算新数据点到所有其他训练数据点的距离。 它可以是任何类型的距离。
-
其次,选择 K 个最近的数据点,其中 K 可以是任何整数。
-
第三,它将数据点分配给大多数 K 个数据点所属的类。
理解实际的算法是一个更好的例子。 假设我们要使用的数据集有两个变量。
任务是将带有“X”的新数据点分类为“红色”类或“蓝色”类。
数据点的坐标值为x = 45
和y = 50
。
现在我们假设 K 的值为 2(两个簇)。
K 最近邻算法开始计算点 X 与所有点的距离。
它找到到点 X(黑点)的距离最近的点。
最后一步是为三个最近的点中的大多数都属于的类分配新点。
示例
Scikit-Learn k 最近邻
为了实现 K 最近邻,我们需要一种编程语言和一个库。
我们建议使用 Python 和 Scikit-Learn。
步骤很简单,程序员必须
导入库。
导入数据集。
进行预处理。
(可选)拆分训练/测试数据。
做出预测。
(可选)评估算法。
现在,我们可以使用 K 最近邻算法。
from sklearn.neighbors import NearestNeighbors
import numpy as np
X = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]])
K = 2
nbrs = NearestNeighbors(n_neighbors=K, algorithm='ball_tree').fit(X)
distances, indices = nbrs.kneighbors(X)
print(distances)
k 最近邻分类器
我们用x
和y
值创建一个二维空间。 目标包含可能的输出类(通常称为标签)。
knn 可用作分类器。 使用 scikit-learn KNeighborsClassifier
,其中参数n_neighbors
为K
。
然后可以对新值进行预测。
from sklearn import datasets
from sklearn import metrics
from sklearn.neighbors import KNeighborsClassifier
import numpy as np
# dataset
X = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]])
target = [0, 0, 0, 1, 1, 1]
# fit a k-nearest neighbor model to the data
K = 3
model = KNeighborsClassifier(n_neighbors = K)
model.fit(X, target)
print(model)
# make predictions
print( '(-2,-2) is class'),
print( model.predict([[-2,-2]]) )
print( '(1,3) is class'),
print( model.predict([[1,3]]) )
k 最近邻回归
knn 可用于回归问题。 在下面的示例中,每月租金价格基于平方米(m^2)进行预测。
它使用 sklearn 的KNeighborsRegressor
实现。 由于数据集很小,因此将 K 设置为 2 个最近的邻居。
from sklearn.neighbors import KNeighborsRegressor
# dataset (X=m^2, y=rental price)
X = [[40], [45], [60], [70]]
y = [1000, 1200, 2000, 2500]
# fit
neigh = KNeighborsRegressor(n_neighbors=2)
neigh.fit(X, y)
# predict
print('Monthly Rental Price for 65m^2 in $'),
print(neigh.predict([[65]]))
训练测试拆分
数据是无限的。 数据科学家每天都要处理!
有时我们有数据,我们有特征,我们想尝试预测会发生什么。
为此,数据科学家将这些数据放入机器学习中以创建模型。
让我们举个例子:
- 计算机必须确定照片中是否包含猫或狗。
- 计算机具有训练阶段和测试阶段以学习如何进行。
- 数据科学家收集了数千张猫和狗的照片。
- 该数据必须分为训练集和测试测试。
然后是拆分进来的时候。
训练测试拆分
拆分
知道我们无法对训练的相同数据进行测试,因为结果会令人怀疑……我们如何知道训练和测试使用的数据百分比?
容易,我们有两个数据集。
- 一个具有独立特征,称为(
x
)。 - 一个具有因变量,称为(
y
)。
为了拆分它,我们这样做:
x_train – x_test / y_train – y_test
这是一个简单的公式,对吧?
x_train
和y_train
成为机器学习的数据,能够创建模型。
创建模型后,输入x_test
,输出应等于y_test
。
模型输出与y_test
测试的距离越近:模型越精确。
>>> import numpy as np
>>> from sklearn.model_selection import train_test_split
>>> X, y = np.arange(10).reshape((5, 2)), range(5)
>>> X
array([[0, 1],
[2, 3],
[4, 5],
[6, 7],
[8, 9]])
>>> list(y)
[0, 1, 2, 3, 4]
然后拆分,让 33% 作为测试集(剩下的用于训练)。
>>> X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=42)
您可以验证自己有两组:
>>> X_train
array([[4, 5],
[0, 1],
[6, 7]])
>>> X_test
array([[2, 3],
[8, 9]])
>>> y_train
[2, 0, 3]
>>> y_test
[1, 4]
>>>
数据科学家可以将用于统计和机器学习的数据分为两个或三个子集。
- 两个子集将进行训练和测试。
- 三个子集将是训练,验证和测试。
无论如何,科学家都希望进行预测以创建模型并测试数据。
当他们这样做时,可能会发生两件事:过拟合和欠拟合。
过拟合
过拟合比欠拟合最常见,但是为了避免影响模型的可预测性,不应进行过拟合。
那么,那意味着什么呢?
当模型过于复杂时,可能会发生过拟合。
过拟合意味着我们训练的模型训练得“太好”,并且与训练数据集过于紧密。
但是,如果感觉太好,为什么会有问题呢? 问题在于,训练数据的准确性将无法对未训练或新数据进行准确性。
为避免这种情况,与观察数相比,数据不能包含许多特征/变量。
欠拟合
那衣服不足呢?
当模型太简单时,可能会导致欠拟合,这意味着模型不适合训练数据。
为了避免这种情况,数据需要足够的预测变量/独立变量。
之前,我们提到过验证。
验证
交叉验证是指科学家将数据分为(k)个子集,并在 k-1 上训练那些子集之一。
最后一个子集是用于测试的子集。
一些库最常用于训练和测试。
- Pandas:用于将数据文件作为 Pandas 数据帧加载并进行分析。
- Sklearn:用于导入数据集模块,加载样本数据集并运行线性回归。
- Matplotlib:使用
pyplot
绘制数据图。
最后,如果需要拆分数据库,请首先避免过拟合或欠拟合。
进行训练和测试阶段(并根据需要进行交叉验证)。
使用更适合所需工作的库。
机器学习可以为您提供帮助,但是您必须很好地使用它。
人脸检测
人脸检测系统是最常用的人工智能之一。
同时,安全性和机器人技术以不显眼的方式实现它,每次拍摄照片或将内容上传到社交媒体时,我们都会使用人脸检测。
它已经成为我们生活的一部分,而且大多数人甚至都没有注意到它的背后。
人脸检测看似简单,但事实并非如此。 是一项能够根据图像或视频帧识别和验证人员的技术。 在某种程度上类似于指纹或眼睛鸢尾花识别系统。
Python 人脸检测
简介
那么,我们想对所有这些说些什么? 每个知道如何编码的人都可以进行人脸检测。 开发人员和程序员都可以实现。
他们只需要一个库,例如 OpenCV。
他们还需要一种来自示例 Python 的编程语言。
而且,如果以前没有这样做,他们必须要有一点耐心。
您无法跳过所有步骤并立即采取行动,而不会出现一些错误。
为什么是 OpenCV?
OpenCV 意味着“开放源代码计算机视觉”,它是一个最初用 C++ 编写,后来又为 Python 编写的库,这是我们将要使用的编程语言。
该库具有提高计算效率的设计,并且非常注重实时应用程序。
听起来确实对人脸检测准确。 OpenCV 可以使用机器学习算法在图片中搜索人脸。
但是这个过程很棘手,因为面孔很复杂。 必须匹配成千上万的小图案和特征。
机器学习
机器学习算法具有称为分类器的任务。 分类器将面孔识别为成千上万个较小的,一口大小的任务,这样做更容易。
想象一下:一张脸可以有 6,000 个或更多的分类器,并且所有这些分类器都必须匹配才能被检测到。
算法从图片的左上方开始,然后向下移至小块数据。 这 6,000 个分类器必须对其进行测试,并且需要进行数百万次的计算。
很明显,您的计算机将停止运行。 如果您必须自己做这项工作,您会失去理智。
级联
OpenCV 使用级联来解决将面部检测到多个阶段的问题。
级联对每个块进行非常粗略和快速的测试。 如果该块通过,则进行更详细的测试,依此类推。
该算法可以具有 30 到 50 个级联,如果所有阶段都通过,则可以检测到人脸。
这使得实时进行面部识别成为可能。
级联是包含 OpenCV 数据的 XML 文件,用于检测对象。
示例
一旦安装了 OpenCV 并且您了解它之后,就该使用 Python 检查人脸检测的结果了。
import cv2
import sys
imagePath = sys.argv[1]
cascPath = sys.argv[2]
faceCascade = cv2.CascadeClassifier(cascPath)
# read and convert image
image = cv2.imread(imagePath)
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# detect faces in the image
faces = faceCascade.detectMultiScale(
gray,
scaleFactor=1.1,
minNeighbors=5,
minSize=(30, 30),
# flags = cv2.cv.CV_HAAR_SCALE_IMAGE
)
print("Found {0} faces!".format(len(faces)))
# show face detections
for (x, y, w, h) in faces:
cv2.rectangle(image, (x, y), (x+w, y+h), (255, 0, 0), 2)
cv2.imshow("Faces found", image)
cv2.waitKey(0)
使用以下命令运行程序:
python3 face.py workplace-1245776_960_720.jpg haarcascade_frontalface_default.xml
您可以在此处下载级联
可能会导致两件事:
当用高质量的相机拍摄并靠近脸部时,对面部识别更可能是准确的。
当图片分辨率不高且离人脸较远时,可能会出现误报的情况。
如何为 scikit-learn 机器学习准备数据
原文: https://pythonbasics.org/how-to-prepare-your-data-for-machine-learning-with-scikit-learn/
如何通过 Scikit-Learn 准备要学习的数据。
如果要使用 scikit-learn 实现学习算法,则要做的第一件事就是准备数据。
这将向您决定使用的学习算法展示问题的结构。
唯一的障碍是需要一种不同的算法来启动有关要处理数据的不同假设,这有时可能需要进行不同的转换。
在准备数据以使用 scikit-learn 进行学习时,有四个经过验证的步骤。 它们包括:
- 重新缩放数据
- 数据标准化
- 规范化数据
- 将数据转换为二元
数据准备
重新缩放数据
重新缩放数据的属性,特别是当数据的属性由不同的比例组成时,这使多种学习算法可以从数据的重新缩放过程中受益,以确保数据以相同的比例出现。
此过程可称为标称化,其属性的重标范围为 0 和 1。它确保存在构成梯度下降核心的优化算法-学习算法的检查。
import pandas
import scipy
import numpy
from sklearn.preprocessing import MinMaxScaler
# data values
X = [ [110, 200], [120, 800], [310, 400], [140, 900], [510, 200], [653, 400] ,[310, 880] ]
# transofrm data
scaler = MinMaxScaler(feature_range=(0, 1))
rescaledX = scaler.fit_transform(X)
# summarize transformed data
numpy.set_printoptions(precision=2)
print(rescaledX[0:6,:])
重新缩放的值将在 0 到 1 之间:
[[0\. 0\. ]
[0.02 0.86]
[0.37 0.29]
[0.06 1\. ]
[0.74 0\. ]
[1\. 0.29]]
在考虑中性网络权重,回归以及所有涉及距离测量的算法(例如 K 最近邻)的算法中,它也很有价值。
标准化数据
此技术在使用高斯分布的属性转换中有效。
高斯分布使用平均值为 0 且标准偏差设置为 1 的情况。逻辑回归,线性回归和线性判别分析最适合以高斯分布为输入变量,从而更好地利用了重新定标的数据。
# Standardize data (0 mean, 1 stdev)
from sklearn.preprocessing import StandardScaler
import pandas
import numpy
# data values
X = [ [110, 200], [120, 800], [310, 400], [140, 900], [510, 200], [653, 400] ,[310, 880] ]
# scaler
scaler = StandardScaler().fit(X)
rescaledX = scaler.transform(X)
# summarize transformed data
numpy.set_printoptions(precision=3)
print(rescaledX[0:6,:])
标定值:
[[-1.02 -1.178]
[-0.968 0.901]
[ 0.013 -0.485]
[-0.865 1.247]
[ 1.045 -1.178]
[ 1.783 -0.485]]
规范化数据
为了规范 Scikit 学习中的数据,它涉及将每个观察值重新缩放为 1 的长度-线性代数的单位形式。
使用 Scikit-learn 在 Python 中标准化数据时,最好使用 Normalizer 类软件。
# Normalize values
from sklearn.preprocessing import Normalizer
import pandas
import numpy
# data values
X = [ [110, 200], [120, 800], [310, 400], [140, 900], [510, 200], [653, 400] ,[310, 880] ]
# normalize values
scaler = Normalizer().fit(X)
normalizedX = scaler.transform(X)
# summarize transformed data
numpy.set_printoptions(precision=2)
print(normalizedX[0:6,:])
规范化的值是:
[[0.48 0.88]
[0.15 0.99]
[0.61 0.79]
[0.15 0.99]
[0.93 0.37]
[0.85 0.52]]
规模可变的稀疏数据集特别受益于使用距离度量(例如 K 最近邻)的算法预处理。 一个典型的例子是中性网络。 用数据制作二元
二元数据转换
可以通过将二元阈值标记为小于或等于 0 的 1 来实现。在具有清晰值的概率中很有用。
# Binary values
from sklearn.preprocessing import Binarizer
import pandas
import numpy
# data values
X = [ [110, 200], [120, 800], [310, 400], [140, 900], [510, 200], [653, 400] ,[310, 880] ]
# binarize data
binarizer = Binarizer(threshold=500).fit(X)
binaryX = binarizer.transform(X)
# summarize transformed data
numpy.set_printoptions(precision=1)
print(binaryX[0:6,:])
阈值非常重要,因为它将决定哪些值变为零或一。
[[0 0]
[0 1]
[0 0]
[0 1]
[1 0]
[1 0]]
另外,在为特征工程添加特征方面,它具有巨大的意义。 到目前为止,您必须熟悉使用 Scikit-learn 进行机器学习的数据准备所涉及的步骤。
请记住,涉及的四个步骤是:
- 重新缩放数据
- 数据标准化
- 规范化数据
- 使数据二元化。
Selenium
Selenium 浏览器
Selenium 使您可以自动化 Web 浏览器。 Selenium 是一个 Python 模块。 除了 Python 模块之外,您还需要 Web 驱动程序。
通过 Python,您可以控制 Firefox,Chrome,Internet Explorer,Edge 和许多其他浏览器。 您可以打开一个新的 URL,单击按钮等等。
网络浏览器
Selenium 浏览器
下面的 Selenium 浏览器代码启动了多个 Web 浏览器。 他们打开一个网站,然后关闭浏览器。 必须安装 Web 驱动程序才能起作用。
#-*- coding:utf-8 -*-
from selenium import webdriver
import time
from tomorrow import threads
def startBrowser(name):
"""
browsers,"firefox"、"chrome"、"ie"、"phantomjs"
"""
try:
if name == "firefox" or name == "Firefox" or name == "ff":
print("start browser name :Firefox")
driver = webdriver.Firefox()
return driver
elif name == "chrome" or name == "Chrome":
print("start browser name :Chrome")
driver = webdriver.Chrome()
return driver
elif name == "ie" or name == "Ie":
print("start browser name :Ie")
driver = webdriver.Ie()
return driver
elif name == "phantomjs" or name == "Phantomjs":
print("start browser name :phantomjs")
driver = webdriver.PhantomJS()
return driver
else:
print("Not found this browser,You can use ‘firefox‘, ‘chrome‘, ‘ie‘ or ‘phantomjs‘")
except Exception as msg:
print("message: %s" % str(msg))
@threads(5)
def run_case(name):
driver = startBrowser(name)
driver.get("https://news.ycombinator.com/")
time.sleep(3)
print(driver.title)
driver.close()
driver.quit()
if __name__ == "__main__":
names = ["chrome", "ff", "ie"]
for i in names:
run_case(i)
Selenium Cookie
Cookie 是 Web 服务器提供给 Web 浏览器的消息。 这使您的 Web 浏览器可以存储登录信息,用户名,购物车等信息。 网站需要在不同页面之间记住这一点,有时会使用 cookie。
在 Selenium 中,您可以使用get_cookies()
和add_cookie()
方法获取并设置 cookie。
Selenium Cookie
下面的 Selenium cookie 代码获取站点 reddit 设置的所有 cookie。
# -*- coding: utf-8 -*-
from selenium import webdriver
import time
browser=webdriver.Firefox()
browser.get("https://reddit.com")
cookies = browser.get_cookies()
for cookie in cookies:
print(cookie)
browser.quit()
Selenium 添加删除 cookie
下面的 Selenium 代码获取 cookie,然后添加一个新 cookie,再次获取它们(显示),最后将其删除。
# -*- coding: utf-8 -*-
from selenium import webdriver
import time
browser=webdriver.Firefox()
browser.get("https://reddit.com")
print(browser.get_cookies())
browser.add_cookie({"name":"python","domain":"reddit.com","value":"python"})
print(browser.get_cookies())
browser.delete_all_cookies()
print(browser.get_cookies())
browser.close()
Selenium 执行 JavaScript
Selenium Webdriver 可以执行 Javascript。 加载页面后,您可以执行所需的任何 JavaScript。 必须安装 Web 驱动程序,Selenium 才能工作。
只需调用方法execute_script(js)
,其中 js 是您的 JavaScript 代码。
javascript
Selenium 执行 javascript
加载页面后,下面的程序将运行一行 javascript 命令。 这将在网页中显示警报框。
from selenium import webdriver
driver=webdriver.Firefox()
driver.implicitly_wait(3)
driver.get("https://pythonbasics.org")
js = 'alert("Hello World")'
driver.execute_script(js)
Selenium 按 ID 查找元素
网页元素可以通过其 ID 来实现。 这是在带有 Selenium 的网页上选择元素的方法之一。
您必须具有可通过开发人员工具获得的元素 ID。 您也可以使用 id 或 css 选择网页元素。
查找元素
Selenium 按 ID 查找元素
Selenium 代码使用find_element
和 ID 来选择搜索框。 然后,它在搜索框中键入一条消息。
#_*_coding: utf-8_*_
from selenium import webdriver
from selenium.webdriver.common.by import By
import time
browser=webdriver.Firefox()
browser.get("https://wiki.ubuntu.com")
element=browser.find_element(By.ID,"searchinput")
element.send_keys("typing")
print(element)
time.sleep(3)
browser.close()
Selenium 查找列表项目
下面的 Python 代码使用 selenium 在网页上查找列表项li
。
from selenium import webdriver
from selenium.webdriver.common.by import By
driver = webdriver.Firefox()
driver.get("https://selenium-python.readthedocs.io/locating-elements.html")
items = driver.find_elements(By.XPATH, '//li')
for item in items:
print(item.text)
Selenium 按名称查找元素
Selenium 可以按名称而不是代码查找元素。 这样完成:
#_*_coding: utf-8_*_
from selenium import webdriver
from selenium.webdriver.common.by import By
import time
browser=webdriver.Firefox()
browser.get("https://stackoverflow.com")
element = browser.find_element_by_name("q")
element.send_keys("typing")
print(element)
time.sleep(3)
browser.close()
Selenium 无头 Firefox
无头浏览器是没有用户界面的 Web 浏览器。 如果您想启动网络浏览器来执行任务,但又不想或不需要查看它,那就很好了。
您可以使用 Firefox 或 Chrome 之类的 GUI 浏览器。 然后将其设置为无头模式。 无论如何,都需要安装 Web 驱动程序。
Selenium
Selenium 无头 Firefox
下面的代码启动 Firefox,但处于无头模式。 它可以执行 Firefox 可以执行的任何操作,但是在屏幕上将不可见。 下面的屏幕截图输出了网页的 html 代码,但这是可选的。
from selenium import webdriver
try:
fireFoxOptions = webdriver.FirefoxOptions()
fireFoxOptions.set_headless()
brower = webdriver.Firefox(firefox_options=fireFoxOptions)
brower.get('https://pythonbasics.org')
print(brower.page_source)
finally:
try:
brower.close()
except:
pass
Selenium Firefox
Firefox 可以由 Python 控制。 为此,您需要 Selenium 模块和 Web 驱动程序。 Python 代码启动 Web 浏览器,然后完全控制它。
然后,该代码可以执行您在网络浏览器中可以执行的任何操作,例如打开页面,发送按键或单击按钮。
firefox
Selenium Firefox
看一下 Selenium Firefox 代码。 首先导入 webdriver,然后使其启动 firefox。
打开并获取页面,并可以选择“发送”按钮。
# coding=utf-8
from selenium import webdriver
driver = webdriver.Firefox()
driver.get("https://dev.to")
driver.find_element_by_id("nav-search").send_keys("Selenium")
Selenium 获取 HTML
Selenium 是用于浏览器自动化的 Python 模块。 您可以使用它来抓取 html 代码,该网页由什么构成:超文本标记语言(HTML)。
要获取它,首先启动 Web 浏览器并加载页面。 然后,您可以获取它。 为此,必须安装 Web 驱动程序。
获取 html
Selenium 获取 html
下面的代码启动 Firefox Web rbowser,使用get()
方法打开一个网页,最后使用browser.page_source
存储该网页 html。
#_*_coding: utf-8_*_
from selenium import webdriver
import time
# start web browser
browser=webdriver.Firefox()
# get source code
browser.get("https://en.wikipedia.org")
html = browser.page_source
time.sleep(2)
print(html)
# close web browser
browser.close()
Selenium 键盘
Selenium Webdriver 可以在任何网页上输入按键或键入内容。 Selenium 是使网络浏览器自动化的 Python 模块。
Selenium Webdriver 启动浏览器,浏览器加载网页,选择文本框和类型。
键盘
Selenium 键盘
下面的 Selenium 键盘代码示例可以完成所有这些操作。 在此示例中,它在 Wikipedia 上进行了自动搜索,但是该原理可在任何站点上使用。
# -*- coding: utf-8 -*-
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.wait import WebDriverWait
import time
browser=webdriver.Firefox()
try:
browser.get("https://en.wikipedia.org")
print(browser.title)
input=browser.find_element_by_id("searchInput")
input.send_keys("Python")
input.send_keys(Keys.ENTER)
wait=WebDriverWait(browser,10)
wait.until(EC.presence_of_element_located((By.ID,"content")))
print(browser.title)
#print(browser.get_cookies())
#print(browser.page_source)
time.sleep(10)
finally:
browser.close()
Selenium 最大化
通过 Python Selenium 最大化 Web 浏览器非常容易。 简而言之,您要做的就是启动浏览器并调用maximum_window()
。
(Selenium 是一个 Python 模块,使用 Web 驱动程序来为您控制 Web 浏览器)
Selenium
Selenium 最大化
首先导入 webdriver 和时间模块。 您需要安装 Selenium Web 驱动程序。 然后使用webdriver.Firefox()
打开 firefox,并使用maximize_window().
调用最大化窗口
from selenium import webdriver
import time
driver = webdriver.Firefox()
driver.maximize_window()
time.sleep(5)
driver.get("https://www.python.org")
Selenium 截图
网页截图可以使用 Python Selenium 自动获取。 首先加载 Selenium 模块和时间模块。 您需要时间模块来等待页面加载完成。
然后,一旦页面加载完毕,请截屏。 这可以是 png 文件或其他图像格式。 然后关闭网络浏览器,否则它将保持打开状态。
Selenium 截图
示例
您可以使用get_screenshot_as_file()
方法拍摄网页的屏幕快照,并以文件名作为参数。
下面的程序使用 firefox 加载网页并截图,但是任何 Web 浏览器都可以。
from selenium import webdriver
from time import sleep
driver = webdriver.Firefox()
driver.get('https://www.python.org')
sleep(1)
driver.get_screenshot_as_file("screenshot.png")
driver.quit()
print("end...")
屏幕快照图像将与 Python 脚本存储在同一目录中。 除非您明确定义必须存储屏幕快照的路径。
Selenium 向下滚动
您是否希望 Selenium 浏览器滚动到页面末尾? 您可以使用代码,确切地说是 javascript 代码。
加载网页后,您可能需要向下滚动。您可以向下滚动特定数量或一直向下滚动到底部。
Selenium 向下滚动
示例
Selenium 向下滚动代码如下所示。 它使用 javascript 校准方法execute_script()
,以滚动到网页的末尾。
#_*_coding: utf-8_*_
from selenium import webdriver
import time
browser=webdriver.Firefox()
browser.get("https://en.wikipedia.org")
browser.execute_script("window.scrollTo(0,document.body.scrollHeight)")
time.sleep(3)
browser.close()
Selenium 切换到窗口
也可以从 Python 代码切换窗口或选项卡。 下面的示例使用 selenium 模块和 Web 驱动程序。
这应该适用于所有受支持的 Web 浏览器,包括 Chrome,Firefox,IE 和所有其他浏览器。
切换到窗口
Selenium 切换到窗口
Selenium 切换到如下所示的窗口代码。 它会启动 Firefox,打开一个网页,然后打开一个包含不同网站的新标签页和窗口。
# -*- coding: utf-8 -*-
from selenium import webdriver
import time
browser=webdriver.Firefox()
browser.get("https://www.reddit.com")
browser.execute_script("window.open()")
print(browser.window_handles)
browser.switch_to_window(browser.window_handles[1])
browser.get("https://www.youtube.com")
time.sleep(1)
browser.switch_to_window(browser.window_handles[0])
browser.get("https://python.org")
#browser.close()
Selenium 等待页面加载
原文: https://pythonbasics.org/selenium_wait_for_page_to_load/
等待页面加载 Python Selenium。 在本文中,您将学习如何做到这一点。 这有点违反直觉。
Selenium 可让您自动执行浏览器,但不需要time.sleep
即可等待页面加载完成。 实际上,它的工作方式与您预期的不同。
示例
Selenium 等待页面加载
下面的代码块向您展示了如何等待页面加载完成。 它使用超时。 它等待元素显示在页面上(您需要一个元素 ID)。
然后,如果页面已加载,则显示页面已加载。 如果超过了超时时间(以秒为单位),它将显示超时错误。
from selenium import webdriver
from selenium.common.exceptions import TimeoutException
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By
driver = webdriver.Firefox()
driver.get('https://pythonbasics.org')
timeout = 3
try:
element_present = EC.presence_of_element_located((By.ID, 'main'))
WebDriverWait(driver, timeout).until(element_present)
except TimeoutException:
print("Timed out waiting for page to load")
finally:
print("Page loaded")
Flask 教程
Flask 教程:Hello World
欢迎! 在本教程中,您将学习如何使用 Python Flask 创建第一个 Web 应用程序。 如果您喜欢学习视频课程,建议您参考以下课程:
设置项目
Python 项目位于虚拟环境中。 每个项目都位于不同的虚拟环境中。 这样可以防止程序包冲突。Python 软件包不应在系统范围内安装。
考虑一下:
- 项目 A 需要 Flask 版本 0.2
- 项目 B 需要 Flask 版本 0.3
- 项目 C 需要 Flask 版本 0.1
由于存在软件包冲突,因此无法在系统范围内安装软件包。
创建虚拟环境
打开终端(请参阅下面的如何快速打开终端)。 然后安装python3-venv
。
在 Ubuntu Linux 上,您可以运行以下命令:
sudo apt-get install python3-venv
首先使用命令创建项目目录
$ mkdir flaskexample
cd flaskexample
然后,您可以使用以下命令创建新的虚拟环境:
$ python3 -m venv venv
激活虚拟环境
虚拟环境已创建,但尚未激活。在 Linux 上激活虚拟环境,请使用以下命令:
source venv/bin/activate
在 Microsoft Windows 上,请改用以下命令:
$ venv\Scripts\activate
您应该看到:
(venv) ➜ flaskexample
安装 Flask
第一步是安装 Flask。 Python 附带了一个名为pip
的软件包管理器。 它使用名为 PyPI 的官方 Python 软件包存储库。
要安装 Python 软件包,您需要打开一个终端。 这因操作系统而异。
- 在 Linux 上,您可以按组合键
Ctrl+Alt+T
打开终端。 - 在 Mac OS X 上,按
CMD + Space
键打开 Spotlight 搜索,然后键入terminal
并按回车键。 - 在 Windows 上,按
Super + R
键并键入cmd
,然后按Enter
键。
您可以使用以下命令安装 Python 软件包:
pip install <package-name>
在这种情况下,您要键入命令:
pip install flask
然后确认其安装正确。 输入命令
(venv) ➜ flaskexample python3
输出应为:
>>> import flask
>>>
如果您在下面看到输出,则表明 Flask 未安装在虚拟环境中。
Python 3.7.3 (default, Aug 20 2019, 17:04:43)
[GCC 8.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import flask
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ModuleNotFoundError: No module named 'flask'
>>>
HelloWorld
大! 现在已经安装了所有内容,您可以创建第一个 Flask 应用程序。
使用下面的行在 Python 中导入 Flask。
from flask import Flask
创建托管应用程序的应用程序
app = Flask(__name__)
然后,您需要一个路由来调用 Python 函数。 路由会将您在浏览器中键入的内容(URL)映射到 Python 函数。
@app.route('/')
def index():
该函数应将某些内容返回到 Web 浏览器,
return 'Web App with Python Flask!'
差不多完成了,服务器需要启动。 这将在端口 81 上启动 Web 应用程序。
app.run(host='0.0.0.0', port=81)
在网络浏览器中输入网址 http://localhost:81/。
代码摘要:
from flask import Flask
app = Flask(__name__)
@app.route('/')
def index():
return 'Web App with Python Flask!'
app.run(host='0.0.0.0', port=81)
{% raw %}
Flask 教程:模板
模板可帮助您重用视觉效果。 在所有 Web 应用程序中,视觉效果都可以重复使用。 这可以帮助您划分业务和表示逻辑。 您不希望您的应用程序代码与图形设计代码混合在一起。
想象一下一个分析应用程序。 您希望每个页面上都有相同的导航和页脚。 内容可能有所不同,但总体设计保持不变。 这是通过模板完成的。
模板示例
您要做的第一件事是为模板创建目录。 您可以使用以下命令从终端执行此操作。 如果尚未这样做,请创建一个应用。 假设您的项目目录名为app
,
(venv) $ mkdir app/templates
单个模板只是一个文件。 每个模板都包含 HTML 代码,这是 Web 的标准语言。
Flask 模板变量
让我们创建文件index.html
<html>
<head>
<title>{{ title }}</title>
</head>
<body>
<h1>Hello {{ username }}</h1>
</body>
</html>
其中大多数是 HTML 标记(在<
和>
符号之间),这是网络上的标准标记。
那么,那些 {{
和 }}
符号是什么?
这是在网页上显示 Python 变量的方式。 它们是要显示的变量的占位符。
在此模板中,可以传递两个变量:标题和用户名。
模板渲染
要知道的关键事情之一是,模板用于将业务逻辑与表示逻辑分开。 这样可以提高软件的可维护性,可扩展性和可移植性。
可以从您的 Python 代码中传递变量。 Python 需要渲染模板,因此需要导入模板。
from flask import render_template
更改原始代码:
@app.route('/')
def index():
return 'Web App with Python Flask!'
进入渲染模板并传递变量的代码:
@app.route('/')
@app.route('/index')
def index():
name = 'Rosalia'
return render_template('index.html', title='Welcome', username=name)
然后启动应用程序:
sudo python3 app.py
然后它将在终端中显示一些文本:
* Serving Flask app "app" (lazy loading)
* Environment: production
WARNING: This is a development server. Do not use it in a production deployment.
Use a production WSGI server instead.
* Debug mode: off
* Running on http://0.0.0.0:81/ (Press CTRL+C to quit)
并在 Web 浏览器中打开终端中显示的 URL。
render_template
在上面的示例中,您调用了函数render_template()
。 为什么要调用此方法而不立即返回 html 数据?
Flask 与一种名为 Jinja2 的语言捆绑在一起。 这使您能够直接在模板中包含变量,创建循环和添加if
语句。
在上面的示例中,您已经了解了如何包含title
和username
之类的变量。 那么,如何包含循环和if
语句?
Flask 模板if
您可以在模板中包含if
语句。 可以使用与 Python 中相同的运算符(==
,>
,<
,>=
,<=
)。 也可以使用else
或elif
之类的子句。
在此代码中,输出将根据输入变量用户名而有所不同。 用户名通过 Python 代码(业务逻辑)传递到模板(表示逻辑)。
<html>
<head>
<title>{{ title }}</title>
</head>
<body>
{% if username == "Rosalia": %}
<h1>Hello my love</h1>
{% else %}
<h1>Hello {{ username }}</h1>
{% endif %}
</body>
</html>
Flask 模板for
循环
如果您有大量数据(例如用户列表),则希望使用for
循环对其进行迭代。 将 Python 代码更改为此:
@app.route('/')
@app.route('/index')
def index():
users = [ 'Rosalia','Adrianna','Victoria' ]
return render_template('index.html', title='Welcome', members=users)
该代码包括一个列表(用户)。 该列表将传递给render_template
函数。 在模板中,可以使用for
循环遍历列表。
<html>
<head>
<title>{{ title }}</title>
</head>
<body>
<ul>
{% for member in members: %}
<li>{{ member }}</li>
{% endfor %}
</ul>
</body>
</html>
对于代码,使用标签 {%
和 %}
。
要显示变量,请写入标签 {{
和 }}
。
{% endraw %}
Flask 教程:路由
现代的 Web 应用程序使用一种称为路由的技术。 这可以帮助用户记住 URL。 例如,他们看到的不是/booking.php
,而是/booking/
。 他们会看到/account/1234/
,而不是/account.asp?id=1234/
。
路由
Flask 路由示例
Flask 中的路由映射到 Python 函数。 您已经创建了一条路由,即/
路由:
@app.route('/')
def index():
route()
装饰器@app.route()
将 URL 绑定到函数。
如果需要路由/hello
,可以将其绑定到hello_world()
函数,如下所示:
@app.route('/hello')
def hello_world():
return "hello world"
函数hello_world()
的输出显示在浏览器中。
Flask 路径参数
创建路由时可以使用参数。 参数可以是这样的字符串(文本):/product/cookie
。
这将具有以下路由和函数:
@app.route('/product/<name>')
def get_product(name):
return "The product is " + str(name)
因此,您可以将参数传递给 Flask 路由,可以传递数字吗?
此处的示例创建路由/sale/<transaction_id>
,其中transaction_id
是数字。
@app.route('/sale/<transaction_id>')
def get_sale(transaction_id=0):
return "The transaction is "+str(transaction_id)
Flask 多参数路由
如果您希望 Flask 路由具有多个参数,则可以这样做。 对于路由/create/<first_name>/<last_name>
,您可以执行以下操作:
@app.route('/create/<first_name>/<last_name>')
def create(first_name=None, last_name=None):
return 'Hello ' + first_name + ',' + last_name
Flask POST 路由
Flask 支持 HTTP POST 请求。 如果您对此不熟悉,我建议您学习此课程:使用 Flask 创建应用。
创建一个名为login.html
的模板
<html>
<body>
<form action = "http://localhost:5000/login" method = "post">
<p>Username:</p>
<p><input type = "text" name = "name" /></p>
<p><input type = "submit" value = "submit" /></p>
</form>
</body>
</html>
下面的代码支持两种类型的 HTTP 请求。
from flask import Flask
from flask import render_template
from flask import request
from flask import Flask, redirect, url_for, request
app = Flask(__name__)
@app.route('/dashboard/<name>')
def dashboard(name):
return 'welcome %s' % name
@app.route('/login',methods = ['POST', 'GET'])
def login():
if request.method == 'POST':
user = request.form['name']
return redirect(url_for('dashboard',name = user))
else:
user = request.args.get('name')
return render_template('login.html')
if __name__ == '__main__':
app.run(debug = True)
如果收到这样的错误,则路由错误:
werkzeug.routing.BuildError
werkzeug.routing.BuildError: Could not build url for endpoint 'dashboard'. Did you forget to specify values ['name']?
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】凌霞软件回馈社区,博客园 & 1Panel & Halo 联合会员上线
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】博客园社区专享云产品让利特惠,阿里云新客6.5折上折
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步
· 【.NET】调用本地 Deepseek 模型
· CSnakes vs Python.NET:高效嵌入与灵活互通的跨语言方案对比
· DeepSeek “源神”启动!「GitHub 热点速览」
· 我与微信审核的“相爱相杀”看个人小程序副业
· Plotly.NET 一个为 .NET 打造的强大开源交互式图表库
2022-11-02 ApacheCN 编程/大数据/数据科学/人工智能学习资源 2019.6