Python学习（一）：数据类型和变量

数据类型

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

整数

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

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

浮点数

浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，和是完全相等的。浮点数可以用数学写法，如1.23，3.14，-9.01等。也可以用科学计数法表示，把10用e替代，就是，或者，0.000012可以写成，等等。

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

字符串

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

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

>>> print('I\'m \"OK\"!')
I'm "OK"!

转义字符\可以转义很多字符，比如\n表示换行，\t表示制表符，字符\本身也要转义，所以\\表示的字符就是\：

>>> 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

布尔值

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

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

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

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

空值

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

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

列表

Python内置的一种数据类型。list是一种有序的集合，可以随时添加和删除其中的元素。

比如，列出班里所有同学的名字，就可以用一个list表示：

>>> classmates = ['Michael', 'Bob', 'Tracy']  # 数据类型相同
>>> classmates
['Michael', 'Bob', 'Tracy']

>>> L = ['Apple', 123, True]                  # 数据类型不同

>>> N = []                                    # 空list

用len()函数获得list元素的个数：

>>> len(classmates)
3

用索引来访问list中每一个位置的元素，索引从0 开始，最后一个元素的索引是len(classmates) - 1：

>>> classmates[0]    # 取第一个元素
'Michael'
>>> classmates[1]    # 取第一个元素
'Bob'
>>> classmates[2]    # 取第一个元素
'Tracy'
>>> classmates[0:2]  # 不包括索引2的元素
'Michael', 'Bob'
>>> classmates[-1]   # 取倒数第一个元素
'Tracy'
>>> classmates[-2]   # 取倒数第二个元素
'Bob'
>>> classmates[-3]   # 取倒数第三个元素
'Michael'

list是一个可变的有序表，所以，可以修改其中的元素：

>>> classmates.append('Adam')          # 追加元素到末尾
>>> classmates
['Michael', 'Bob', 'Tracy', 'Adam']

>>> classmates.insert(1, 'Jack')       # 把元素插入到指定的位置
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']

>>> classmates.pop()                   # 删除列表末尾的元素
'Adam'
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy']

>>> classmates.pop(1)                  # 删除指定位置的元素
'Jack'
>>> classmates
['Michael', 'Bob', 'Tracy']     

>>> classmates[1] = 'Sarah'            # 替换元素
>>> classmates
['Michael', 'Sarah', 'Tracy']   

list元素也可以是另一个list，比如：

>>> s = ['python', 'java', ['asp', 'php'], 'scheme']
>>> len(s)
4

要拿到 'pop' 可以写s[2][1]，因此s可以看成是一个二维数组，类似的还有三维、四维……数组，不过很少用到。

tuple

另一种有序集合叫元组tuple。tuple和list非常类似，但tuple一旦初始化就不能修改，比如同样是列出同学的名字：

>>> classmates = ('Michael', 'Bob', 'Tracy')

没有append()，insert()这样的方法，不能赋值成另外的元素。可以正常地使用classmates[0]，classmates[-1]获取元素。

tuple的陷阱：当你定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来，比如：

>>> t = (1, 2)   # 有两个元素的元组
>>> t
(1, 2)

>>> t = ()    # 空元组
>>> t
()

但是，要定义一个只有1个元素的tuple，如果你这么定义：

>>> t = (1)
>>> t
1

定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，为了避免歧义，因此Python规定，这种情况下，按小括号进行计算。

所以，只有1个元素的tuple定义时必须加一个逗号,，来消除歧义：

>>> t = (1,)
>>> t
(1,)

Python在显示只有1个元素的tuple时，也会加一个逗号,，以免你误解成数学计算意义上的括号。

最后来看一个“可变的”tuple：

>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])

这个tuple定义的时候有3个元素，分别是'a'，'b'和一个list。不是说tuple一旦定义后就不可变了吗？怎么后来又变了？

表面上看，tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向'a'，就不能改成指向'b'，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！

变量

在计算机程序中，变量不仅可以是数字，还可以是任意数据类型。变量在程序中就是用一个变量名表示，变量名必须是大小写英文、数字和_的组合，且不能用数字开头，比如：

a = 1             # 变量a是一个整数
t_007 = 'T007'    # 变量t_007是一个字符串
Answer = True     #变量Answer是一个布尔值True

常量

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

 

 

资料来自：廖雪峰的官方网站