原文： http://zetcode.com/lang/python/datatypes/

在 Python 编程教程的这一部分中，我们讨论 Python 数据类型。

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

Python 数据类型定义

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

Python 有很多有用的数据类型。 Python 的数据类型构建在语言的核心中。 它们易于使用和直接。

Python 布尔值

我们的世界建立了双重性。 有天与地，水与火，阴与阳，男人与女人，爱与恨。 在 Python 编程语言中，布尔数据类型是具有以下两个值之一的原始数据类型：True或False。 这是基本的数据类型。 有趣的是，这种数据类型从一开始就不存在，但是后来才创建。

快乐的父母正在等待孩子的出生。 他们为两种可能性都选择了名称。 如果要成为男孩，他们可能选择了约翰。 如果要成为女孩，他们可能选择了维多利亚。

kid.py

  1. #!/usr/bin/env python
  3. # kid.py
  5. import random
  7. male = False
  8. male = bool(random.randint(0, 1))
  10. if male:
  11.    print("We will use name John")
  12. else:
  13.    print("We will use name Victoria")

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

  1. import random

在这里，我们导入用于计算随机数的随机模块。

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

在这里，我们使用两个函数。 randint()函数从给定的整数边界返回一个随机数。 在我们的情况下为 0 或 1。bool()函数将整数转换为布尔值。

  1. if male:
  2.     print("We will use name John")
  3. else:
  4.     print("We will use name Victoria")

我们打印名称。 if关键字适用于布尔值。 如果male为True，则在控制台上打印"We will use name John"。 如果它具有False值，我们将打印另一个字符串。

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

bool_fun.py

  1. #!/usr/bin/env python
  3. # bool_fun.py
  5. print(bool(True))
  6. print(bool(False))
  7. print(bool("text"))
  8. print(bool(""))
  9. print(bool(' '))
  10. print(bool(0))
  11. print(bool())
  12. print(bool(3))
  13. print(bool(None))

该示例打印九个布尔值。

  1. $ ./bool_fun.py 
  2. True
  3. False
  4. True
  5. False
  6. True
  7. False
  8. False
  9. True
  10. False

这是bool_fun.py脚本的输出。

Python None

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

none.py

  1. #!/usr/bin/env python
  3. # none.py
  5. def function():
  6.     pass
  8. print(function())

在我们的示例中，我们定义一个函数。 功能将在本教程的后面部分介绍。 该功能不执行任何操作。 它不会显式返回任何值。 这样的函数将隐式返回None。

  1. $ ./none.py 
  2. None

这是none.py脚本的输出。

Python 数字

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

如果我们使用整数，那么我们将处理离散实体。 我们将使用整数来计算苹果。

apples.py

  1. #!/usr/bin/env python
  3. # apples.py
  5. # number of baskets
  6. baskets = 16
  8. # number of apples in a basket
  9. apples_in_basket = 24
  11. # we get the total number of apples
  12. total = baskets * apples_in_basket
  14. print("There are total of", total, "apples")

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

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

这是脚本的输出。

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

sprinter.py

  1. #!/usr/bin/env python
  3. # sprinter.py
  5. # 100 m is 0.1 km
  7. distance = 0.1
  9. # 9.87 s is 9.87/60*60 h
  11. time = 9.87 / 3600
  13. speed = distance / time
  15. print("The average speed of a sprinter is {0} km/h".format(speed))

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

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

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

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

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

Python 字符串

字符串是代表计算机程序中文本数据的数据类型。

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

strings.py

  1. #!/usr/bin/env python
  3. # strings.py
  5. a = "proximity alert"
  6. b = 'evacuation'
  7. c = """
  8. requiem 
  9. for
  10. a 
  11. tower
  12. """
  14. print(a)
  15. print(b)
  16. print(c)

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

  1. $ ./strings.py 
  2. proximity alert
  3. evacuation
  5. requiem 
  6. for 
  7. a 
  8. tower

这是strings.py脚本的输出。

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

  1. print("   bbb\raaa") # prints aaabbb

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

strophe.py

  1. #!/usr/bin/env python
  3. # strophe.py
  5. print("Incompatible, it don't matter though\n'cos someone's bound to hear my cry")
  6. print("Speak out if you do\nYou're not easy to find")

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

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

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

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

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

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

水平选项卡在文本之间放置一个空格。

  1. "Johnie's dog"
  2. 'Johnie\'s dog'

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

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

我们可以使用len()函数来计算字符串的长度（以字符为单位）。

如果在字符串后附加r，则会得到原始字符串。 转义序列不被解释。

raw.py

  1. #!/usr/bin/env python
  3. # raw.py
  5. print(r"Another world\n")
  1. $ ./raw.py 
  2. Another world\n

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

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

strings2.py

  1. #!/usr/bin/python
  3. # strings2.py
  5. print("eagle " * 5)
  7. print("eagle " "falcon")
  9. print("eagle " + "and " + "falcon")

*运算符将字符串重复 n 次。 在我们的情况下是五次。 彼此相邻的两个字符串字面值会自动连接在一起。 我们还可以使用+运算符显式连接字符串。

  1. $ ./strings2.py 
  2. eagle eagle eagle eagle eagle 
  3. eagle falcon
  4. eagle and falcon

这是strings.py脚本的输出。

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

Python 元组

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

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

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

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

括号不是必须的。 我们可以省略它们。

tuples.py

  1. #!/usr/bin/env python
  3. # tuples.py
  5. first = (1, 2, 3)
  6. second = (4, 5, 6)
  8. print("len(first) : ", len(first))
  9. print("max(first) : ", max(first))
  10. print("min(first) : ", min(first))
  11. print("first + second :", first + second)
  12. print("first * 3 : ", first * 3)
  13. print("1 in first : ", 1 in first)
  14. print("5 not in second : ", 5 not in second)

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

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

这是脚本的输出。

接下来，我们将进行一些索引编制。

tuples2.py

  1. #!/usr/bin/env python
  3. # tuples2.py
  5. five = (1, 2, 3, 4, 5)
  7. print("five[0] : ", five[0])
  8. print("five[-1] : ", five[-1])
  9. print("five[-2] : ", five[-2])
  10. print("five[:] : ", five[:])
  11. print("five[0:4] : ", five[0:4])
  12. print("five[1:2] : ", five[1:2])
  13. print("five[:2] : ", five[:2])
  14. print("five[:-1] : ", five[:-1])
  15. print("five[:9] : ", five[:9])

为了从元组中获取值，我们使用方括号[]。 请注意，我们从 0 开始计算索引。如果一个元组中有五个对象，则索引为0...4。 如果使用负索引，则从元组的末尾获得一个值。 因此，索引-1 获得最后一个元素，-2 获得最后一个但只有一个元素。 Python 支持从元组创建切片。 为此，我们使用:分隔符。 例如，[0:4]给出(1, 2, 3, 4)。 请注意，不包括最后一个元素。

我们可以省略切片中的一个或两个索引。 [:4]给出(1, 2, 3, 4)。 它来自第一个元素。 [0:]给出（1,2,3,4,5）。 这次，包含了最后一个元素。 如果超出范围，我们只需将所有元素都包含在元组中。

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

这是输出。

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

tuples_mix.py

  1. #!/usr/bin/env python
  3. # tuples_mix.py
  5. mix = (1, 2, "solaris", (1, 2, 3))
  7. print("mix[1] :", mix[1])
  8. print("mix[2] :", mix[2])
  9. print("mix[3] :", mix[3])
  10. print("mix[3][0] :", mix[3][0])
  11. print("mix[3][1] :", mix[3][1])
  12. print("mix[3][2] :", mix[3][2])

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

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

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

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

tuple_one.py

  1. #!/usr/bin/env python
  3. # tuple_one.py
  5. print((3 + 7))
  6. print((3 + 7, ))

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

  1. $ ./tuple_one.py 
  2. 10
  3. (10,)

这是输出。

Python 列表

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

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

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

list_simple.py

  1. #!/usr/bin/env python
  3. # simple_list.py
  5. num = [0, 2, 5, 4, 6, 7]
  7. print(num[0])
  8. print(num[2:])
  9. print(len(num))
  10. print(num + [8, 9])

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

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

这是输出。

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

list_sorting.py

  1. #!/usr/bin/env python
  3. # list_sorting.py
  5. numbers = [4, 3, 6, 1, 2, 0, 5]
  7. print(numbers)
  8. numbers.sort()
  9. print(numbers)

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

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

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

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

使用count()方法对列表中的元素进行计数。

list_counting_elements.py

  1. #!/usr/bin/env python
  3. # list_counting_elements.py
  5. numbers = [0, 0, 2, 3, 3, 3, 3]
  7. print("zero is here",  numbers.count(0), "times")
  8. print("one is here",   numbers.count(1), "times") 
  9. print("two is here",   numbers.count(2), "time") 
  10. print("three is here", numbers.count(3), "times")

该脚本对列表中出现的次数进行计数。

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

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

list_modify.py

  1. #!/usr/bin/env python
  3. # list_modify.py
  5. names = []
  7. names.append("Frank")
  8. names.append("Alexis")
  9. names.append("Erika")
  10. names.append("Ludmila")
  12. print(names)
  14. names.insert(0, "Adriana")
  15. print(names)
  17. names.remove("Frank")
  18. names.remove("Alexis")
  19. del names[1]
  20. print(names)
  22. del names[0]
  23. print(names)

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

  1. $ ./list_modify.py 
  2. ['Frank', 'Alexis', 'Erika', 'Ludmila']
  3. ['Adriana', 'Frank', 'Alexis', 'Erika', 'Ludmila']
  4. ['Adriana', 'Ludmila']
  5. ['Ludmila']

这是list_modify.py脚本的输出。

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

list_modify2.py

  1. #!/usr/bin/env python
  3. # list_modify2.py
  5. first = [1, 2, 3]
  6. second = [4, 5, 6]
  8. first.extend(second)
  9. print(first)
  11. first[0] = 11
  12. first[1] = 22
  13. first[2] = 33
  14. print(first)
  16. print(first.pop(5))
  17. print(first)

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

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

这是输出。

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

list_index.py

  1. #!/usr/bin/env python
  3. # list_index.py
  5. numbers = [0, 1, 2, 3, 3, 4, 5]
  7. print(numbers.index(1))
  8. print(numbers.index(3))

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

  1. $ ./list_index.py 
  2. 1
  3. 3

这是list_index.py脚本的输出。

接下来，我们将进行一些转换。

list_transform.py

  1. #!/usr/bin/env python
  3. # list_transform.py
  5. first = [1, 2, 3]
  6. second = (4, 5, 6)
  8. print(tuple(first))
  9. print(list(second))
  11. print(first)
  12. print(second)

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

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

Python 集

set是无重复数据的无序数据集合。 集合支持诸如并集，相交或求差的运算； 与数学相似。

sets.py

  1. #!/usr/bin/env python
  3. set1 = set(['a', 'b', 'c', 'c', 'd'])
  4. set2 = set(['a', 'b', 'x', 'y', 'z'])
  6. print("set1: " , set1)
  7. print("set2: " , set2)
  8. print("intersection: ", set1 & set2)
  9. print("union: ", set1 | set2)
  10. print("difference: ", set1 - set2)
  11. print("symmetric difference: ", set1 ^ set2)

在我们的示例中，我们有两组。 我们使用set()函数创建集合。 相交操作返回都在set1和set2中的元素。 联合操作返回两个集合中的所有元素。 差异返回set1中的元素，但不是set2的元素。 最后，对称差返回set1或set2中的元素，但两者都不是。

  1. $ ./sets.py 
  2. set1: set(['a', 'c', 'b', 'd'])
  3. set2: set(['a', 'x', 'b', 'y', 'z'])
  4. intersection: set(['a', 'b'])
  5. union: set(['a', 'c', 'b', 'd', 'y', 'x', 'z'])
  6. difference: set(['c', 'd'])
  7. symmetric difference: set(['c', 'd', 'y', 'x', 'z'])

这是sets.py脚本的输出。

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

set2.py

  1. #!/usr/bin/env python
  3. # sets2.py
  5. set1 = set([1, 2])
  6. set1.add(3)
  7. set1.add(4)
  9. set2 = set([1, 2, 3, 4, 6, 7, 8])
  10. set2.remove(8)
  12. print(set1)
  13. print(set2)
  15. print("Is set1 subset of set2 ? :", set1.issubset(set2))
  16. print("Is set1 superset of set2 ? :", set1.issuperset(set2))
  18. set1.clear()
  19. print(set1)

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

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

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

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

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

Python 字典

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

dictionary_simple.py

  1. #!/usr/bin/env python
  3. # dictionary_simple.py
  5. words = { 'girl': 'Maedchen', 'house': 'Haus', 'death': 'Tod' }
  7. print(words['house'])
  9. print(words.keys())
  10. print(words.values())
  11. print(words.items())
  13. print(words.pop('girl'))
  14. print(words)
  16. words.clear()
  17. print(words)

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

  1. $ ./dictionary_simple.py 
  2. Haus
  3. ['house', 'girl', 'death']
  4. ['Haus', 'Maedchen', 'Tod']
  5. [('house', 'Haus'), ('girl', 'Maedchen'), ('death', 'Tod')]
  6. Maedchen
  7. {'house': 'Haus', 'death': 'Tod'}
  8. {}

在 Python 教程的这一部分中，我们描述了 Python 数据类型。