数据类型

计算机顾名思义就是可以做数学计算的机器，因此，计算机程序理所当然地可以处理各种数值。但是，计算机能处理的远不止数值，还可以处理文本、图形、音频、视频、网页等各种各样的数据，不同的数据，需要定义不同的数据类型。在Python中，能够直接处理的数据类型有以下几种：

Python 基本的数据类型包括:

• Numbers(数字)

• String(字符串)

• Boolean (布尔)

• List(列表)

• Tuple(元组)

• Dictionary(字典)

• None (空值)

Python 支持四种不同的数字类型:

• int(有符号整型)

• long（长整型[也可以代表八进制和十六进制]）

• float(浮点型)

• complex(复数)

在计算机中，变量用于保存数据。我们用 = 进行变量赋值，左边是变量名称，右边是数 据对象。对于 x = 'Hello World'，我们称将字符串’Hello World’ 赋值给了变量 x，也可以理解为变量 x 指向了该字符串。量变量在程序中用一个变量名表示了，变量名必须是大 小写英文、数字和 _ 的组合，且不能用数字开头。Python 中变量是没有类型的，变量指向的数据对象是有类型的。

>>> x=1
>>> type(x)
<class 'int'>
>>> y=1.0
>>> type(y)
<class 'float'>
>>> s="Hello"
>>> type(s)
<class 'str'>
>>> s=x+y
>>> type(s)
<class 'float'>
>>> print(x)
1
>>> print(y)
1.0
>>> print(s)
2.0
>>> b=s>x
>>> print(b)
True
>>> type(b)
<class 'bool'>
>>>

不同之间的类型可以通过内置函数进行转换，比如 int() 可将给定数据转为整形，float() 可转为浮点型，str() 可转为字符串。但是前提，是给定的数据可以转为该种类型，否则会报错。

一些数值类型的实例：

长整型也可以使用小写"L"，但是还是建议您使用大写"L"，避免与数字"1"混淆。Python使用"L"来显示长整型。

Python还支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型

整数

Python可以处理任意大小的整数，当然包括负整数，在程序中的表示方法和数学上的写法一模一样，例如：1，100，-8080，0，等等。

计算机由于使用二进制，所以，有时候用十六进制表示整数比较方便，十六进制用0x前缀和0-9，a-f表示，例如：0xff00，0xa5b4c3d2，等等。

浮点数

浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x109和12.3x108是完全相等的。浮点数可以用数学写法，如1.23，3.14，-9.01，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x109就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等。

整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是的！），而浮点数运算则可能会有四舍五入的误差。

布尔值

布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值（请注意大小写），也可以通过布尔运算计算出来：

>>> True
True
>>> False
False
>>> 3 > 2
True
>>> 3 > 5
False

布尔值可以用and、or和not运算。

and运算是与运算，只有所有都为True，and运算结果才是True：

>>> True and True
True
>>> True and False
False
>>> False and False
False
>>> 5 > 3 and 3 > 1
True

or运算是或运算，只要其中有一个为True，or运算结果就是True：

>>> True or True
True
>>> True or False
True
>>> False or False
False
>>> 5 > 3 or 1 > 3
True

not运算是非运算，它是一个单目运算符，把True变成False，False变成True：

>>> not True
False
>>> not False
True
>>> not 1 > 2
True

布尔值经常用在条件判断中，比如：

if age >= 18:
    print('adult')
else:
    print('teenager')

空值

空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

此外，Python还提供了列表、字典等多种数据类型，还允许创建自定义数据类型，我们后面会继续讲到。

字符串

字符串是以单引号'或双引号"括起来的任意文本，比如'abc'，"xyz"等等。请注意，''或""本身只是一种表示方式，不是字符串的一部分，因此，字符串'abc'只有a，b，c这3个字符。如果'本身也是一个字符，那就可以用""括起来，比如"I'm OK"包含的字符是I，'，m，空格，O，K这6个字符。

如果字符串内部既包含'又包含"怎么办？可以用转义字符\来标识，比如：

'I\'m \"OK\"!'

表示的字符串内容是：

I'm "OK"!

转义字符\可以转义很多字符，比如\n表示换行，\t表示制表符，字符\本身也要转义，所以\\表示的字符就是\，可以在Python的交互式命令行用print()打印字符串看看：

>>> print('I\'m ok.')
I'm ok.
>>> print('I\'m learning\nPython.')
I'm learning
Python.
>>> print('\\\n\\')
\
\

如果字符串里面有很多字符都需要转义，就需要加很多\，为了简化，Python还允许用r''表示''内部的字符串默认不转义，可以自己试试：

>>> print('\\\t\\')
\       \
>>> print(r'\\\t\\')
\\\t\\

如果字符串内部有很多换行，用\n写在一行里不好阅读，为了简化，Python允许用'''...'''的格式表示多行内容，可以自己试试：

print('''line1
... line2
... line3''')

输出
line1
... line2
... line3

上面是在交互式命令行内输入，注意在输入多行内容时，提示符由>>>变为...，提示你可以接着上一行输入。如果写成程序，就是：

print('''line1
line2
line3''')

输出
line1
line2
line3

多行字符串'''...'''还可以在前面加上r使用，请自行测试。

List（列表）

List（列表） 是 Python 中使用最频繁的数据类型。

列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

列表是写在方括号[ ]之间、用逗号分隔开的元素列表。

和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

列表截取的语法格式：变量[头下标 : 尾下标]

索引值以 0 为开始值，-1 为从末尾的开始位置。

加号（+）是列表连接运算符，星号（*）是重复操作。

list = [ 'abcd', 786 , 2.23, '程序喵', 70.2 ]
tinylist = [123, '程序喵']
 
print(list)            # 输出完整列表
print(list[0])         # 输出列表第一个元素
print(list[1:3])       # 从第二个开始输出到第三个元素
print(list[2:])        # 输出从第三个元素开始的所有元素
print(tinylist * 2)    # 输出两次列表
print(list + tinylist) # 连接列表

输出
['abcd', 786, 2.23, '程序喵', 70.2]
abcd
[786, 2.23]
[2.23, '程序喵', 70.2]
[123, '程序喵', 123, '程序喵']
['abcd', 786, 2.23, '程序喵', 70.2, 123, '程序喵']

列表中的元素是可以改变的。

>>> x=[1,2,3,4]
>>> x[1]
2
>>> x[1]="Anson"
>>> x[1]
'Anson'
>>> x
[1, 'Anson', 3, 4]
>>>

List内置了有很多方法，例如append()、pop()等等，这在后面会讲到。

Python元组

元组是另一个数据类型，类似于List（列表）

元组用"()"标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。

示例

tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
tinytuple = (123, 'john')
 
print(tuple)                # 输出完整元组
print(tuple[0])             # 输出元组的第一个元素
print(tuple[1:3])           # 输出第二个至第三个的元素 
print(tuple[2:])            # 输出从第三个开始至列表末尾的所有元素
print(tinytuple * 2)        # 输出元组两次
print(tuple + tinytuple)    # 打印组合的元组

输出
('runoob', 786, 2.23, 'john', 70.2)
runoob
(786, 2.23)
(2.23, 'john', 70.2)
(123, 'john', 123, 'john')
('runoob', 786, 2.23, 'john', 70.2, 123, 'john')

Set（集合）

集合（set）是一个无序不重复元素的序列。

基本功能是进行成员关系测试和删除重复元素。

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}

print(student)   # 输出集合，重复的元素被自动去掉

# 成员测试
if('Rose' in student) :
    print('Rose 在集合中')
else :
    print('Rose 不在集合中')

# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')

print("a：", a)
print("b：", b)
print("a和b的差集：", a - b)     # a和b的差集
print("a和b的并集：", a | b)     # a和b的并集
print("a和b的交集：", a & b)     # a和b的交集
print("a和b中不同时存在的元：", a ^ b)     # a和b中不同时存在的元

输出
{'Jim', 'Jack', 'Tom', 'Mary', 'Rose'}
Rose 在集合中
a： {'b', 'a', 'd', 'r', 'c'}
b： {'a', 'z', 'l', 'c', 'm'}
a和b的差集： {'b', 'r', 'd'}
a和b的并集： {'b', 'a', 'z', 'l', 'd', 'r', 'c', 'm'}
a和b的交集： {'a', 'c'}
a和b中不同时存在的元： {'r', 'b', 'm', 'z', 'l', 'd'}

Dictionary（字典）

字典（dictionary）是Python中另一个非常有用的内置数据类型。

列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典是一种映射类型，字典用"{ }"标识，它是一个无序的键(key) : 值(value)对集合。

键(key)必须使用不可变类型。在同一个字典中，键(key)必须是唯一的。

dict = {}
dict['one'] = "程序喵"
dict[2]     = "chengxumiao"
 
tinydict = {'name': 'ibloger','code':1, 'site': 'www.ibloger.com'}
 
print(dict)
print(dict['one'])       # 输出键为 'one' 的值
print(dict[2])           # 输出键为 2 的值
print(tinydict)          # 输出完整的字典
print(tinydict.keys())   # 输出所有键
print(tinydict.values()) # 输出所有值

输出
{'one': '程序喵', 2: 'chengxumiao'}
程序喵
chengxumiao
{'name': 'ibloger', 'code': 1, 'site': 'www.ibloger.com'}
dict_keys(['name', 'code', 'site'])
dict_values(['ibloger', 1, 'www.ibloger.com'])

构造函数 dict() 可以直接从键值对序列中构建字典如下：

>>> dict([('Anson',1),('X-rapido',2),("Miao",3)])
{'Anson': 1, 'X-rapido': 2, 'Miao': 3}
>>> {x: x**2 for x in (2,4,6)}
{2: 4, 4: 16, 6: 36}
>>> dict(Anson=1,Rapido=2,Miao=3)
{'Anson': 1, 'Rapido': 2, 'Miao': 3}
>>>

另外，字典类型也有一些内置的函数，例如clear()、keys()、values()等

注意：

1、字典是一种映射类型，它的元素是键值对

2、字典的关键字必须为不可变类型，且不能重复

3、创建空字典使用 { }

变量

变量的概念基本上和初中代数的方程变量是一致的，只是在计算机程序中，变量不仅可以是数字，还可以是任意数据类型。

变量在程序中就是用一个变量名表示了，变量名必须是大小写英文、数字和_的组合，且不能用数字开头，比如：

a = 1

变量a是一个整数。

t_007 = 'T007'

变量t_007是一个字符串。

Answer = True

变量Answer是一个布尔值True。

在Python中，等号=是赋值语句，可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以是不同类型的变量，例如：

a = 123 # a是整数
print(a)
a = 'ABC' # a变为字符串
print(a)

这种变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言。静态语言在定义变量时必须指定变量类型，如果赋值的时候类型不匹配，就会报错。例如Java是静态语言，赋值语句如下（// 表示注释）：

int a = 123; // a是整数类型变量
a = "ABC"; // 错误：不能把字符串赋给整型变量

和静态语言相比，动态语言更灵活，就是这个原因。

请不要把赋值语句的等号等同于数学的等号。比如下面的代码：

x = 10x = x + 2

如果从数学上理解x = x + 2那无论如何是不成立的，在程序中，赋值语句先计算右侧的表达式x + 2，得到结果12，再赋给变量x。由于x之前的值是10，重新赋值后，x的值变成12。

最后，理解变量在计算机内存中的表示也非常重要。当我们写：

a = 'ABC'

时，Python解释器干了两件事情：

1. 在内存中创建了一个'ABC'的字符串；

2. 在内存中创建了一个名为a的变量，并把它指向'ABC'。

也可以把一个变量a赋值给另一个变量b，这个操作实际上是把变量b指向变量a所指向的数据，例如下面的代码：

a = 'ABC'b = a
a = 'XYZ'print(b)

最后一行打印出变量b的内容到底是'ABC'呢还是'XYZ'？如果从数学意义上理解，就会错误地得出b和a相同，也应该是'XYZ'，但实际上b的值是'ABC'，让我们一行一行地执行代码，就可以看到到底发生了什么事：

执行a = 'ABC'，解释器创建了字符串'ABC'和变量a，并把a指向'ABC'：

执行b = a，解释器创建了变量b，并把b指向a指向的字符串'ABC'：

执行a = 'XYZ'，解释器创建了字符串'XYZ'，并把a的指向改为'XYZ'，但b并没有更改：

所以，最后打印变量b的结果自然是'ABC'了。

多个变量赋值

Python允许你同时为多个变量赋值。例如：

a = b = c = 1

以上实例，创建一个整型对象，值为1，三个变量被分配到相同的内存空间上。

您也可以为多个对象指定多个变量。例如：

a, b, c = 1, 2, "john"

以上实例，两个整型对象1和2的分配给变量 a 和 b，字符串对象 "john" 分配给变量 c。

常量

所谓常量就是不能变的变量，比如常用的数学常数π就是一个常量。在Python中，通常用全部大写的变量名表示常量：

PI = 3.14159265359

但事实上PI仍然是一个变量，Python根本没有任何机制保证PI不会被改变，所以，用全部大写的变量名表示常量只是一个习惯上的用法，如果你一定要改变变量PI的值，也没人能拦住你。

del() 函数删除变量

del语句删除一些对象的引用。

del语句的语法是：del var1[,var2[,var3[....,varN]]]]

您可以通过使用del语句删除单个或多个对象的引用。例如：

del var
del var_a, var_b

>>> del a
>>> a
Traceback (most recent call last):
  File "<pyshell#13>", line 1, in <module>
    a
NameError: name 'a' is not defined
>>> a="Anson"
>>> a
'Anson'
>>> del a
>>> a
Traceback (most recent call last):
  File "<pyshell#17>", line 1, in <module>
    a
NameError: name 'a' is not defined
>>> x={"Anson","Miao"}
>>> x
{'Anson', 'Miao'}
>>> type(x)
<class 'set'>
>>> del x
>>> x
Traceback (most recent call last):
  File "<pyshell#27>", line 1, in <module>
    x
NameError: name 'x' is not defined

Python数据类型转换

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。

以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。

未经允许请勿转载：程序喵 » Python3 开发入门 —— 第二讲（基本数据类型和变量）