Python数据类型

在本文中，我们介绍了Python数据类型。

电子表格、文本编辑器、计算器或聊天客户端等计算机程序处理数据。处理各种数据类型的工具是现代计算机语言的重要组成部分。

Python数据类型定义

数据类型是一组值和对这些值的允许操作。

Python有很多有用的数据类型。Python的数据类型构建在语言的核心中。它们易于使用且简单明了。

Python布尔值

在Python编程语言中，布尔数据类型是一种原始数据类型，具有以下两个值之一：True或False。这是一种基本数据类型。

幸福的父母正在等待孩子的出生。他们为这两种可能性都选择了一个名字。如果是男孩，他们可能会选择约翰。如果是女孩，他们可能会选择维多利亚。

#!/usr/bin/python

# kid.py

import random

male = False
male = bool(random.randint(0, 1))

if male:
   print("We will use name John")
else:
   print("We will use name Victoria")

该脚本使用随机整数生成器来模拟我们的案例。

import random

这里我们引入了用于计算随机数的random模块。

male = bool(random.randint(0, 1))

这里我们使用了两个函数。randint函数从给定的整数边界返回一个随机数。在我们的例子中是0或1。bool函数将整数转换为布尔值。

if male:
    print("We will use name John")
else:
    print("We will use name Victoria")

我们打印名称。if关键字与布尔值一起使用。如果male为True，我们将在控制台打印“WewillusenameJohn”。如果它有一个False值，我们打印另一个字符串。

以下脚本显示了一些被认为是True或False的常见值。

#!/usr/bin/python

# bool_fun.py

print(bool(True))
print(bool(False))
print(bool("text"))
print(bool(""))
print(bool(' '))
print(bool(0))
print(bool())
print(bool(3))
print(bool(None))

该示例打印九个布尔值。

$ ./bool_fun.py
True
False
True
False
True
False
False
True
False

Python无

还有另一种特殊的数据类型——None。此数据类型表示不存在、未知或为空。

#!/usr/bin/python

# none.py

def function():
    pass

print(function())

在我们的示例中，我们定义了一个函数。函数将在本教程的后面部分介绍。该函数什么也不做。它不会显式返回任何值。这样的函数将隐式返回None。

$ ./none.py
None

Python数字

在Python编程语言中，我们有整数、浮点数和复数。

如果我们处理整数，我们处理的是离散实体。我们会用整数来数苹果。

#!/usr/bin/python

# apples.py

# number of baskets
baskets = 16

# number of apples in a basket
apples_in_basket = 24

# we get the total number of apples
total = baskets * apples_in_basket

print("There are total of", total, "apples")

在我们的脚本中，我们计算了苹果的总数。我们使用乘法运算。

$ ./apples.py
There are total of 384 apples

浮点数在计算中代表实数。实数测量连续量。假设一名100米的短跑运动员跑了9.87秒。他的速度是多少公里/小时？

#!/usr/bin/python

# sprinter.py

# 100 m is 0.1 km

distance = 0.1

# 9.87 s is 9.87/60*60 h

time = 9.87 / 3600

speed = distance / time

print("The average speed of a sprinter is {0} km/h".format(speed))

为了获得速度，我们将距离除以时间。

print("The average speed of a sprinter is {0} km/h".format(speed))

我们使用format函数构建消息并将其打印到控制台。

$ ./sprinter.py
The average speed of a sprinter is  36.4741641337 km/h

这是sprinter.py脚本的输出。值36.4741641337是一个浮点数。

Python字符串

String是一种在计算机程序中表示文本数据的数据类型。

Python中的字符串可以使用单引号、双引号和三引号创建。当我们使用三引号时，字符串可以跨越多行而不使用转义字符。

#!/usr/bin/python

# strings.py

a = "proximity alert"
b = 'evacuation'
c = """
requiem
for
a
tower
"""

print(a)
print(b)
print(c)

在我们的示例中，我们将三个字符串文字分配给a、b和c变量。然后我们将它们打印到控制台。

$ ./strings.py
proximity alert
evacuation

requiem
for
a
tower

当我们处理字符串时，我们可以使用转义序列。转义序列是在字符串中使用时具有特定用途的特殊字符。

print("   bbb\raaa") # prints aaabbb

回车\r是行尾返回行首的控制字符。

#!/usr/bin/python

# strophe.py

print("Incompatible, it don't matter though\n'cos someone's bound to hear my cry")
print("Speak out if you do\nYou're not easy to find")

新行是开始新一行文本的控制字符。

$ ./strophe.py
Incompatible, it don't matter though
'cos someone's bound to hear my cry
Speak out if you do
You're not easy to find

接下来我们检查退格控制字符。

print("Python\b\b\booo") # prints Pytooo

退格控制字符\b将光标向后移动一个字符。在我们的例子中，我们使用三个退格字符来删除三个字母并用三个o字符替换它们。

print("Towering\tinferno") # prints Towering        inferno

水平制表符在文本之间放置一个空格。

"Johnie's dog"
'Johnie\'s dog'

单引号和双引号可以嵌套。或者如果我们只使用单引号，我们可以使用反斜杠来转义单引号的默认含义。

print("eagle has", len("eagle"), "characters")

我们可以使用len函数来计算字符串的字符长度。

如果我们将r附加到字符串，我们将得到一个原始字符串。不解释转义序列。

#!/usr/bin/python

# raw.py

print(r"Another world\n")

$ ./raw.py
Another world\n

我们得到包含换行符的字符串。

在下一个示例中，我们将展示字符串乘法和连接。

#!/usr/bin/python

# strings2.py

print("eagle " * 5)

print("eagle " "falcon")

print("eagle " + "and " + "falcon")

*运算符将字符串重复n次。在我们的例子中是五次。两个相邻的字符串文字会自动连接起来。我们还可以使用+运算符来显式连接字符串。

$ ./strings2.py
eagle eagle eagle eagle eagle
eagle falcon
eagle and falcon

Python有几种用于处理值集合的内置数据类型：元组、列表、集合和字典。

Python元组

元组是一种不可变的序列数据类型。元组可以包含混合数据类型。

fruits = ("oranges", "apples", "bananas")

元组是使用圆括号创建的。这里我们有一个由三种水果类型组成的元组。

fruits = "apples", "oranges", "bananas"
print(fruits)  # prints  ('apples', 'oranges', 'bananas')

括号不是强制性的。我们可以省略它们。

#!/usr/bin/python

# tuples.py

first = (1, 2, 3)
second = (4, 5, 6)

print("len(first) : ", len(first))
print("max(first) : ", max(first))
print("min(first) : ", min(first))
print("first + second :", first + second)
print("first * 3 : ", first * 3)
print("1 in first : ", 1 in first)
print("5 not in second : ", 5 not in second)

这个例子展示了元组的几个基本操作。len函数返回第一个元组中的元素数。max函数返回最大值，min函数返回最小值。加法运算符将两个元组相加，乘法运算符将元组相乘。in运算符确定值是否在元组中。

$ ./tuples.py
len(first) :  3
max(first) :  3
min(first) :  1
first + second : (1, 2, 3, 4, 5, 6)
first * 3 :  (1, 2, 3, 1, 2, 3, 1, 2, 3)
1 in first :  True
5 not in second :  False

接下来我们做一些索引。

#!/usr/bin/python

# tuples2.py

five = (1, 2, 3, 4, 5)

print("five[0] : ", five[0])
print("five[-1] : ", five[-1])
print("five[-2] : ", five[-2])
print("five[:] : ", five[:])
print("five[0:4] : ", five[0:4])
print("five[1:2] : ", five[1:2])
print("five[:2] : ", five[:2])
print("five[:-1] : ", five[:-1])
print("five[:9] : ", five[:9])

要从元组中获取值，我们使用方括号[]。请注意，我们从0开始计算索引。如果一个元组中有五个对象，则索引为0…4。如果我们使用负索引，我们会从元组的末尾得到一个值。所以index-1获取最后一个元素，-2获取最后一个元素。

Python可以从元组创建切片。为此，我们使用:分隔符。例如，[0:4]给出(1,2,3,4)。请注意，不包括最后一个元素。

我们可以在切片中省略一个或两个索引。[:4]给出(1,2,3,4)。它从第一个元素开始。[0:]给出(1,2,3,4,5)。这次，包含了最后一个元素。如果我们越界，我们只需获取元组中的所有元素。

$ ./tuples2.py
five[0] :  1
five[-1] :  5
five[-2] :  4
five[:] :  (1, 2, 3, 4, 5)
five[0:4] :  (1, 2, 3, 4)
five[1:2] :  (2,)
five[:2] :  (1, 2)
five[:-1] :  (1, 2, 3, 4)
five[:9] :  (1, 2, 3, 4, 5)

元组可以包含多种混合数据类型。

#!/usr/bin/python

# tuples_mix.py

mix = (1, 2, "solaris", (1, 2, 3))

print("mix[1] :", mix[1])
print("mix[2] :", mix[2])
print("mix[3] :", mix[3])
print("mix[3][0] :", mix[3][0])
print("mix[3][1] :", mix[3][1])
print("mix[3][2] :", mix[3][2])

在我们的示例中，我们将数字、字符串和元组放入混合元组中。

$ ./tuples_mix.py
mix[1] : 2
mix[2] : solaris
mix[3] : (1, 2, 3)
mix[3][0] : 1
mix[3][1] : 2
mix[3][2] : 3

要从嵌套元组中获取元素，我们使用两个方括号。

当我们处理包含一个元素的元组时，我们有一个例外。括号也用在表达式中。我们如何区分表达式和单元素元组？Python编程语言的创建者决定使用逗号来表示我们正在使用元组。

#!/usr/bin/python

# tuple_one.py

print((3 + 7))
print((3 + 7, ))

在第一种情况下，我们有and表达式。我们将数字10打印到控制台。在第二种情况下，我们处理一个元组。我们打印一个包含数字10的元组。

$ ./tuple_one.py
10
(10,)

Python列表

列表是一种可变的序列数据类型。它可以包含混合数据类型。列表和元组具有许多共同特征。因为列表是可修改的数据类型，所以它有一些额外的操作。有一整章专门介绍Python列表。

actors = ["Jack Nicholson", "Antony Hopkins", "Adrien Brody"]

列表是使用方括号[]创建的。

#!/usr/bin/python

# simple_list.py

num = [0, 2, 5, 4, 6, 7]

print(num[0])
print(num[2:])
print(len(num))
print(num + [8, 9])

如前所述，我们可以对列表使用与元组相同的操作。

$ ./list_simple.py
0
[5, 4, 6, 7]
6
[0, 2, 5, 4, 6, 7, 8, 9]

接下来我们对列表进行排序。

#!/usr/bin/python

# list_sorting.py

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

print(numbers)
numbers.sort()
print(numbers)

在我们的脚本中，我们有一个数字列表。为了对这些数字进行排序，我们使用内置的sort函数。

$ ./list_sorting.py
[4, 3, 6, 1, 2, 0, 5]
[0, 1, 2, 3, 4, 5, 6]

reverse函数将以相反的顺序对列表的元素进行排序。

numbers.reverse()   #  [5, 4, 3, 2, 1, 0]

对列表中的元素进行计数是使用count方法完成的。

#!/usr/bin/python

# list_counting_elements.py

numbers = [0, 0, 2, 3, 3, 3, 3]

print("zero is here",  numbers.count(0), "times")
print("one is here",   numbers.count(1), "times")
print("two is here",   numbers.count(2), "time")
print("three is here", numbers.count(3), "times")

脚本计算列表中出现的次数。

$ ./list_counting_elements.py
zero is here 2 times
one is here 0 times
two is here 1 time
three is here 4 times

接下来，我们处理从列表中插入和删除项目。

#!/usr/bin/python

# list_modify.py

names = []

names.append("Frank")
names.append("Alexis")
names.append("Erika")
names.append("Ludmila")

print(names)

names.insert(0, "Adriana")
print(names)

names.remove("Frank")
names.remove("Alexis")
del names[1]
print(names)

del names[0]
print(names)

在我们的示例中，我们首先创建一个空的名称列表。我们使用append函数将新项目追加到列表中。元素以连续的方式附加。insert函数在给定位置插入新元素。现有元素不会被删除，它们会被重新定位。remove函数从列表中删除特定项目。如果我们想根据索引删除一个项目，我们使用del关键字。

$ ./list_modify.py
['Frank', 'Alexis', 'Erika', 'Ludmila']
['Adriana', 'Frank', 'Alexis', 'Erika', 'Ludmila']
['Adriana', 'Ludmila']
['Ludmila']

下面的程序提供了另外两个功能。

#!/usr/bin/python

# list_modify2.py

first = [1, 2, 3]
second = [4, 5, 6]

first.extend(second)
print(first)

first[0] = 11
first[1] = 22
first[2] = 33
print(first)

print(first.pop(5))
print(first)

extend方法将整个列表附加到另一个列表。要修改列表中的元素，我们可以使用赋值运算符。pop方法从列表中取出一个项目并将其返回。

$ ./list_modify2.py
[1, 2, 3, 4, 5, 6]
[11, 22, 33, 4, 5, 6]
6
[11, 22, 33, 4, 5]

在下面的例子中，我们找出元素的索引。

#!/usr/bin/python

# list_index.py

numbers = [0, 1, 2, 3, 3, 4, 5]

print(numbers.index(1))
print(numbers.index(3))

要在列表中查找索引，我们使用index方法。如果某个元素出现的次数更多，则该方法返回第一个元素的索引。

$ ./list_index.py
1
3

接下来我们做一些转换。

#!/usr/bin/python

# list_transform.py

first = [1, 2, 3]
second = (4, 5, 6)

print(tuple(first))
print(list(second))

print(first)
print(second)

我们可以使用tuple函数从列表创建元组，使用list函数从元组创建列表。请注意，原始对象没有被修改；这些函数只返回那些转换后的集合。

$ ./list_transform.py
(1, 2, 3)
[4, 5, 6]
[1, 2, 3]
(4, 5, 6)

Python集

集是没有重复元素的无序数据集合。集合支持并集、交集或差集等运算；类似于数学。

#!/usr/bin/python

set1 = set(['a', 'b', 'c', 'c', 'd'])
set2 = set(['a', 'b', 'x', 'y', 'z'])

print("set1: " , set1)
print("set2: " , set2)
print("intersection: ", set1 & set2)
print("union: ", set1 | set2)
print("difference: ", set1 - set2)
print("symmetric difference: ", set1 ^ set2)

在我们的示例中，我们有两组。我们使用set函数来创建集。交集运算返回同时位于set1和set2中的元素。并集运算返回两个集合中的所有元素。不同之处在于返回set1但不是set2中的元素。最后，对称差异返回set1或set2中的元素，但不在两者中。

$ ./sets.py
set1: set(['a', 'c', 'b', 'd'])
set2: set(['a', 'x', 'b', 'y', 'z'])
intersection: set(['a', 'b'])
union: set(['a', 'c', 'b', 'd', 'y', 'x', 'z'])
difference: set(['c', 'd'])
symmetric difference: set(['c', 'd', 'y', 'x', 'z'])

接下来我们介绍一些集合的其他操作。

#!/usr/bin/python

# sets2.py

set1 = set([1, 2])
set1.add(3)
set1.add(4)

set2 = set([1, 2, 3, 4, 6, 7, 8])
set2.remove(8)

print(set1)
print(set2)

print("Is set1 subset of set2 ? :", set1.issubset(set2))
print("Is set1 superset of set2 ? :", set1.issuperset(set2))

set1.clear()
print(set1)

add方法将一个项目添加到集合中。removeitem从集合中删除一个项目。clear方法从集合中删除所有项目。如果set2中的每个元素也在set1中，则set1是set2的超集。如果set1中的每个元素也在set2中，则set1是set2的子集。

$ ./sets2.py
set([1, 2, 3, 4])
set([1, 2, 3, 4, 6, 7])
Is set1 subset of set2 ? :  True
Is set1 superset of set2 ? :  False
set([])

如果我们需要一个不可变集，我们可以使用frozenset函数创建一个冻结集。

fs = frozenset(['a', 'b', 'c'])

此行从列表中创建一个冻结集。

Python字典

Python字典是一组键值对。adictionary中的元素由键索引。字典中的键必须是唯一的。由于字典数据类型的重要性，本Python教程中用一整章来介绍字典。

#!/usr/bin/python

# dictionary_simple.py

words = { 'girl': 'Maedchen', 'house': 'Haus', 'death': 'Tod' }

print(words['house'])

print(words.keys())
print(words.values())
print(words.items())

print(words.pop('girl'))
print(words)

words.clear()
print(words)

我们的第一个示例展示了字典数据类型的一些基本用法。我们打印字典的特定值、键和值。items方法以元组形式返回字典的（键，值）对列表。

$ ./dictionary_simple.py
Haus
['house', 'girl', 'death']
['Haus', 'Maedchen', 'Tod']
[('house', 'Haus'), ('girl', 'Maedchen'), ('death', 'Tod')]
Maedchen
{'house': 'Haus', 'death': 'Tod'}
{}

在本文中，我们描述了Python数据类型。

列出所有Python教程。