数据类型，就是用于指定数据在计算机是如何进行存储的。毕竟不同的数据类型存储所占的字节都大不相同。就好比现在的excel表格，word，ppt，聊天软件，都是由数据组成的。那这些数据表明上看上去都没啥区别，但是计算机在存储和表示这些数据在计算机内部是通过不同的存储结构来进行存储的，比如整数占多少比特位，字符串占多少比特位。再者不同的数据类型可以进行不同的操作。就好比要比较两个值的大小，2>1,这种是数值比较。2.0>1.0,这是double类型或者float类型的比较。所以说不同的数据类型能进行不同的操作。因此在开发过程中要结合实际情况来定义数据类型的变量。光有数据类型是不行的，就好比现在给你一个整数100，光有这么一个值你能知道是啥东西不，肯定不知道，你只知道是数字100，如果我把这个100指定给菜的价格，那就是100元，如果指定给菜的重量就是100克或者100斤。那这时候在python中是如何指定的呢？
int price = 100.00;int wight = 100;1、布尔值
在我们的世界里有一种二元性。有天有地，有水有火，有男有女，有爱有恨。在Python编程语言中，布尔数据类型是一种基本数据类型，它有两个值:True或False。这是一种基本数据类型。有趣的是，该数据类型从一开始就不存在，但后来才创建。
举个例子来看一下这个布尔值能够干嘛，就好比今天心情不错，扔个硬币来看一下是否需要去买彩票。再或者你去饭店吃饭，平时你最爱吃的红烧肉饭，然后饭店有个新规定，周一到周五五折，周末全额。这时候布尔值用起来就很不错。
coin.py#!/usr/bin/env python# coin.py
import random
isHead= False
isHead = bool(random.randint(0, 1))
if isHead:
print("买几注彩票")
else:
print("不是人头，运气不好，不买彩票了")上面的脚本使用一个随机整数生成器来模拟我们的情况。
import random在这里，我们导入用于计算随机数的random模块。
isHead = bool(random.randint(0, 1))这里我们使用两个函数。
函数的作用是:从给定的整数边界返回一个随机数。这里是0或1。函数的作用是:将整数转换为布尔值。
if isHead:
print("买几注彩票")
else:
print("不是人头，运气不好，不买彩票了")在这里，我们根据了硬币是否是正面反面来进行买彩票，如果是人头咋就买彩票，不是人头就不买了。
接下来看一看，不同类型的值转换为布尔值的结果。
bool_fun.py
#!/usr/bin/env 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
2、None
python有另一种特殊的数据类型——None。此数据类型表示不存在、未知或为空。
none.py
#!/usr/bin/env python
# none.py
def function():
pass
print(function())在我们的示例中，我们定义了一个函数。函数后面的教程中再进行详细讲解。这个函数什么都不做。它不显式返回任何值。这样的函数将隐式返回None。
$ ./none.py
None执行这个脚本，将打印出None；
3、数值
在Python编程语言中，我们有整数、浮点数和复数。
(1),整数，我们可以用来处理离散实体，可以用整数来数苹果。
apples.py
#!/usr/bin/env 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浮点数在计算中代表实数。实数度量连续的量。假设一个百米短跑运动员跑了9。87秒。他的速度是多少公里/小时?
sprinter.py
#!/usr/bin/env 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))为了得到速度，我们用距离除以时间。
speed = distance / time我们使用format()函数构建消息并将其打印到控制台。
print("The average speed of a sprinter is {0} km/h".format(speed))这是springter.py脚本的输出。值36.4741641337是一个浮点数。
4、字符串
字符串是计算机程序中表示文本数据的数据类型。
Python中的字符串可以使用单引号、双引号和三引号创建。当我们使用三重引号时，字符串可以跨越几行而不使用转义字符。
strings.py
#!/usr/bin/env python
# strings.py
a = "proximity alert"
b = 'evacuation'
c = """
requiem
for
a
tower
"""
print(a)
print(b)
print(c)以下是上面脚本的执行输出结果。
$ ./strings.py
proximity alert
evacuation
requiem
for
a
tower当我们处理字符串时，我们可以使用转义序列。转义序列是在字符串中使用时具有特定用途的特殊字符。
print(" bbb\raaa")打印出来的结果是：aaabbb回车\r是用于从行尾返回行首的控制字符。
strophe.py
#!/usr/bin/env 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")"\n"是一个回车换行控制字符，它从新文本行开始。
上面示例执行的结果是：
$ ./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")这段代码执行的结果是：Pytooo退格控制字符\b将光标移回一个字符。刚才的示例中，我们使用三个退格字符删除三个字母，并用三个o字符替换它们。print("Towering\tinferno")打印结果是：Towering inferno"\t"水平选项卡在文本之间留出空格。单引号和双引号可以嵌套。或者，如果我们只使用单引号，我们可以使用反斜杠来转义单引号的默认含义。如下示例："Johnie's dog"
'Johnie\'s dog'我们可以使用len()函数来计算字符串的字符长度，如下示例：print("eagle has", len("eagle"), "characters")那我们要怎么才能字符串不能被转义呢？可以通加个r在转义字符串的前面即可，这样转义字符串就不会被解释了。以下脚本就是转义字符串不被解释的示例：raw.py
#!/usr/bin/env python
# raw.py
print(r"Another world\n")打印的结果是：$ ./raw.py
Another world\n在Python中，字符串有一些可用的函数来对字符串进行操作，比如字符串的连接操作等。strings2.py
#!/usr/bin/python
# strings2.py
print("eagle " * 5)
print("eagle " "falcon")
print("eagle " + "and " + "falcon")操作符*将字符串重复n次。在我们的例子中是5次。
相邻的两个字符串文字会自动连接起来。
还可以使用+操作符显式连接字符串。
以下是上面示例执行的结果：
$ ./strings2.py
eagle eagle eagle eagle eagle
eagle falcon
eagle and falcon
Python有几种用于处理值集合的内置数据类型: 数组、列表、集合和字典。
5、数组
数组是一种不可变的序列数据类型。数组可以包含混合数据类型。
数组主要用于存储多个数据，可以是一类数据也可以是多类数据，数组使用()来进行创建，就比如下面我们来创建一个水果的数组，水果里有橘子，苹果，香蕉等。
fruits = ("oranges", "apples", "bananas")这个括号可以是不强制的，也可以去掉括号。比如下面这种方式fruits = "apples", "oranges", "bananas"print(fruits)结果是：('apples', 'oranges', 'bananas')数组通过len函数可以获取该数组的长度，也可以通过max，min函数来找到这个数组中的最大值，最小值，数组使用+号直接进行连接，数组使用*次数进行复制该数组多次。也可以通过in或者not in 检查该数据是否在数组中。下面是具体的示例：tuples.py
#!/usr/bin/env 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)这个示例输出的结果是$ ./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接下来，我们来看一下如何获取数组中的值，获取数组中的值我们可以通过数组的下标来进行获取。数组第一个元素的下标默认是0，获取数组元素就从0开始。就比如一个数组长度是5，那么这个数组的下标是0，1，2，3，4.总共五个元素的下标，我们要获取数组的元素可以指定数组名加上下标来获取，Python也可以倒序来遍历数组，这个时侯数组的顺序就从后往前遍历，下标是数组正序遍历的下标减去数组的长度。这个时候遍历数组可以使用-5，-4，-3，-2，-1.这样的方式来进行遍历。Python的数组也可以进行分片，可以通过分片来指定范围获取数组中的数据。就比如[0:4],这个分片指定的数据是0到4下标的数据，但不包含4下标的数据。如果分片开始是从0开始的话，可以省去0这个下标。下面来看一下示例：tuples2.py
#!/usr/bin/env 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])执行结果是：$ ./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)数组可以包含几种混合数据类型。tuples_mix.py
#!/usr/bin/env 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编程语言的创建者决定使用逗号来表示我们使用的是数组。下面通过以下示例来进行讲解。tuple_one.py
#!/usr/bin/env python
# tuple_one.py
print((3 + 7))
print((3 + 7, ))在第一种情况下，我们有表达式。我们将编号10打印到控制台。在第二种情况下，我们处理一个数组。我们打印一个包含数字10的数组。下面是执行结果：$ ./tuple_one.py
10
(10,)
6、列表
列表是一种可变的序列数据类型。它可以包含混合数据类型。列表和数组有许多共同的特性。因为列表是可修改的数据类型，所以它有一些额外的操作。后面的教程中我们会单独来讲解列表。数组是()，列表是[]
fruits = ["oranges", "apples", "bananas"]print(fruits)结果是：['oranges', 'apples', 'bananas']如前所述，我们可以对列表和数组使用相同的操作。通过以下例子可以看出：list_simple.py
#!/usr/bin/env 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]接下来我们来看一下如何对列表进行排序。我们可以通过列变的排序函数来进行list_sorting.py
#!/usr/bin/env python
# list_sorting.py
numbers = [4, 3, 6, 1, 2, 0, 5]
print(numbers)
numbers.sort()
print(numbers)执行结果是：$ ./list_sorting.py
[4, 3, 6, 1, 2, 0, 5]
[0, 1, 2, 3, 4, 5, 6]使用reverse()函数，对列表中的元素进行反向排序。
numbers.reverse()
结果：
[6,5, 4, 3, 2, 1, 0]
使用count()方法对列表中的元素进行计数.
list_counting_elements.py
#!/usr/bin/env 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接下来，我们将从列表中插入和删除项
list_modify.py
#!/usr/bin/env 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()函数向列表追加新项。元素以连续的方式被追加。函数的作用是:在给定位置插入新元素。现有的元素不会被删除，而是被重新定位。函数的作用是:从列表中删除特定的项。如果我们想根据索引删除一个项，我们使用del关键字。
$ ./list_modify.py
['Frank', 'Alexis', 'Erika', 'Ludmila']
['Adriana', 'Frank', 'Alexis', 'Erika', 'Ludmila']
['Adriana', 'Ludmila']
['Ludmila']这是list_modify.py脚本的输出。下面的程序给出了另外两个函数。
list_modify2.py
#!/usr/bin/env 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]在下面的示例中，我们将找到元素的索引。
list_index.py
#!/usr/bin/env 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这是list_index.py脚本的输出。
接下来我们将做一些转换。
list_transform.py
#!/usr/bin/env 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)
7、SET集合
SET是没有重复元素的无序数据集合。集合支持像并集、交集或差集这样的操作;类似于数学。
sets.py
#!/usr/bin/env 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中的元素。union操作返回两个集合中的所有元素。差值返回在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'])接下来我们介绍一些其他的集合操作。
set2.py
#!/usr/bin/env 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()方法向集合中添加一个项，remove()方法从集合中删除一个项，clear()方法从集合中删除所有项。如果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'])这一行从列表中创建一个冻结的集合。
8、字典
Python字典是一组键-值对。字典中的元素按键索引。字典中的键必须是唯一的。由于字典数据类型的重要性，后面教程会详细讲解这个字典数据类型。
dictionary_simple.py
#!/usr/bin/env 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)第一个示例展示了dictionary数据类型的一些基本用法。我们打印字典的特定值、键和值。
items()方法的作用是:将字典(键、值)对作为数组返回。$ ./dictionary_simple.py
Haus
['house', 'girl', 'death']
['Haus', 'Maedchen', 'Tod']
[('house', 'Haus'), ('girl', 'Maedchen'), ('death', 'Tod')]
Maedchen
{'house': 'Haus', 'death': 'Tod'}
{}
