数值类型(BOOL,int,运算符号,分数,三角函数,列表,元组)

数值类型

BOOL:

由于 Python 2 的一些遗留问题，布尔值可以当做数值对待。True 为 1；False 为 0 。
1.非零浮点数为真； 0.0 为假。请千万小心这一点！如果有轻微的四舍五入偏差（正如在前面小节中看到的那样，这并非不可能的事情），那么 Python 将测试 0.0000000000001 而不是 0 ，并将返回一个 True 值。
2.分数也可在布尔类型上下文环境中使用。无论 n 为何值，Fraction(0, n) 为假。所有其它分数为真。

INT:

int() 将进行取整，而不是四舍五入。
>>int(2.5)

Python 2 对于int［整型］ 和 long［长整型］ 采用不同的数据类型。int 数据类型受到 sys.maxint 的限制，因平台该限制也会有所不同，但通常是 232-1 。Python 3 只有一种整数类型，其行为方式很有点像 Python 2 的旧 long［长整数］ 类型。

运算符号：

>>> 11 / 2      ①
5.5
>>> 11 // 2     ②
5
>>> −11 // 2    ③
−6
>>> 11.0 // 2   ④
5.0
>>> 11 ** 2     ⑤
121

1./ 运算符执行浮点除法。即便分子和分母都是 int，它也返回一个 float 浮点数。
2. // 运算符执行古怪的整数除法。如果结果为正数，可将其视为朝向小数位取整（不是四舍五入），但是要小心这一点。
当整数除以负数， // 运算符将结果朝着最近的整数“向上”四舍五入。从数学角度来说，由于 −6 比 −5 要小，它是“向下”四舍五入，如果期望将结果取整为 −5，它将会误导你。
// 运算符并非总是返回整数结果。如果分子或者分母是 float，它仍将朝着最近的整数进行四舍五入，但实际返回的值将会是 float 类型。
3. ** 运算符的意思是“计算幂”，112 结果为 121 。

分数

为启用 fractions 模块，必先引入 fractions 模块。
为定义一个分数，创建一个 Fraction 对象并传入分子和分母。
可对分数进行所有的常规数学计算。运算返回一个新的 Fraction 对象。
2 * (1/3) = (2/3)

>>> import fractions             
>>> x = fractions.Fraction(1, 3) 
>>> x
Fraction(1, 3)
>>> x * 2     

三角函数运算。

>>> import math
>>> math.pi                ①
3.1415926535897931
>>> math.sin(math.pi / 2)  ②
1.0

math 模块中有一个代表 π 的常量
然而要注意的是 Python 并不支持无限精度。tan(π / 4) 将返回 1.0，而不是 0.99999999999999989。

列表：

Python 中的列表更像 Java 中的数组（尽管可以把列表当做生命中所需要的一切来使用)。一个更好的比喻可能是 ArrayList 类，该类可以容纳任何对象，并可在添加新元素时进行动态拓展。

>>> a_list = ['a', 'b', 'mpilgrim', 'z', 'example']  ①
>>> a_list
['a', 'b', 'mpilgrim', 'z', 'example']
>>> a_list[0]                                        ②
'a'

与C基本一致。

列表切片

定义列表后，可从其中获取任何部分作为新列表。该技术称为对列表进行 切片 。

>>> a_list
['a', 'b', 'mpilgrim', 'z', 'example']
>>> a_list[1:3]            ①
['b', 'mpilgrim']
>>> a_list[1:-1]           ②
['b', 'mpilgrim', 'z']
>>> a_list[0:3]            ③
['a', 'b', 'mpilgrim']
>>> a_list[:3]             ④
['a', 'b', 'mpilgrim']
>>> a_list[3:]             ⑤
['z', 'example']
>>> a_list[:]              ⑥
['a', 'b', 'mpilgrim', 'z', 'example']

左向右读取列表，第一个切片索引指明了想要的第一个元素，第二个切片索引指明了第一个不想要的元素。返回值是两者之间的任何值。

向列表中新增项

有四种方法可用于向列表中增加元素。

>>> a_list = ['a']
>>> a_list = a_list + [2.0, 3]    ①
>>> a_list                        ②
['a', 2.0, 3]
>>> a_list.append(True)           ③
>>> a_list
['a', 2.0, 3, True]
>>> a_list.extend(['four', 'Ω'])  ④
>>> a_list
['a', 2.0, 3, True, 'four', 'Ω']
>>> a_list.insert(0, 'Ω')         ⑤
>>> a_list
['Ω', 'a', 2.0, 3, True, 'four', 'Ω']

1. +运算符连接列表以创建一个新列表。列表可包含任何数量的元素；没有大小限制（除了可用内存的限制）。然而，如果内存是个问题，那就必须知道在进行连接操作时，将在内存中创建第二个列表。在该情况下，新列表将会立即被赋值给已有变量 a_list 。因此，实际上该行代码包含两个步骤 — 连接然后赋值 ,当处理大型列表时，该操作可能（暂时）消耗大量内存。
2. append() 方法向列表的尾部添加一个新的元素。 append() 方法只接受一个参数，但可以是任何数据类型。
3. extend() 方法只接受一个列表作为参数，并将该参数的每个元素都添加到原有的列表中。
4. insert() 方法将单个元素插入到列表中。第一个参数是列表中将被顶离原位的第一个元素的位置索引。

 `>>> a_list = ['a', 'b', 'c']
>>> a_list.extend(['d', 'e', 'f'])  ①
>>> a_list
['a', 'b', 'c', 'd', 'e', 'f']
>>> len(a_list)                     ②
6
>>> a_list[-1]
'f'
>>> a_list.append(['g', 'h', 'i'])  ③
>>> a_list
['a', 'b', 'c', 'd', 'e', 'f', ['g', 'h', 'i']]
>>> len(a_list)                     ④
7
>>> a_list[-1]
['g', 'h', 'i']`

在列表中检索值

>>> a_list = ['a', 'b', 'new', 'mpilgrim', 'new']
>>> a_list.count('new')       ①
2
>>> 'new' in a_list           ②
True
>>> 'c' in a_list
False
>>> a_list.index('mpilgrim')  ③
3
>>> a_list.index('new')       ④
2
>>> a_list.index('c')         ⑤
Traceback (innermost last):
  File "<interactive input>", line 1, in ?ValueError: list.index(x): x not in list

如果没有在列表中找到该值， index() 方法将会引发一个例外。这是 Python 语言最显著不同之处，其它多数语言将会返回一些无效的索引值（像是 -1）。这意味着您的程序将会在问题的源头处崩溃，而不是之后奇怪地、默默地崩溃。
请记住， -1 是合法的列表索引值。

从列表中删除元素

列表永远不会有缝隙。
1.可使用 del 语句从列表中删除某个特定元素。

>>> a_list = ['a', 'b', 'new', 'mpilgrim', 'new']
>>> a_list[1]
'b'
>>> del a_list[1]         ①
>>> a_list
['a', 'new', 'mpilgrim', 'new']
>>> a_list[1]             ②
'new'

2.还可以通过 remove() 方法从列表中删除某个元素。remove() 方法接受一个 value 参数，并删除列表中该值的第一次出现。

.>>> a_list.remove('new')  ①
>>> a_list
['a', 'mpilgrim', 'new']
>>> a_list.remove('new')  ②
>>> a_list
['a', 'mpilgrim']
>>> a_list.remove('new')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list

3.pop() 方法是从列表删除元素的另一方法。它是从最后开始删除，并返回所删除的值。

>>> a_list = ['a', 'b', 'new', 'mpilgrim']
>>> a_list.pop()   ①
'mpilgrim'
>>> a_list
['a', 'b', 'new']
>>> a_list.pop(1)  ②
'b'
>>> a_list
['a', 'new']
>>> a_list.pop()
'new'
>>> a_list.pop()
'a'
>>> a_list.pop()   ③
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: pop from empty list

元组

元组是不可变的列表。一旦创建之后，用任何方法都不可以修改元素。

• 整个元素的集合都用圆括号，而不是方括号闭合。

• 和列表一样，元组也可以进行切片操作。对列表切片可以得到新的列表；对元组切片可以得到新的元组。

• 元组和列表的主要区别是元组不能进行修改。用技术术语来说，元组是 不可变更 的。从实践的角度来说，没有可用于修改元组的方法。可以对元组进行切片操作（因为该方法创建一个新的元组），可以检查元组是否包含了特定的值（因为该操作不修改元组），还可以……就那么多了。

 >>> a_tuple = ("a", "b", "mpilgrim", "z", "example") `

那么元组有什么好处呢？

• 元组的速度比列表更快。如果定义了一系列常量值，而所需做的仅是对它进行遍历，那么请使用元组替代列表。

• 对不需要改变的数据进行“写保护”将使得代码更加安全。使用元组替代列表就像是有一条隐含的 assert
  语句显示该数据是常量，特别的想法（及特别的功能）必须重写。（？？）

• 一些元组可用作字典键（特别是包含字符串、数值和其它元组这样的不可变数据的元组）。列表永远不能当做字典键使用，因为列表不是不可变的。
• 元组可转换成列表，反之亦然。 内建的 tuple() 函数接受一个列表参数，并返回一个包含同样元素的元组， 而 list()
  函数接受一个元组参数并返回一个列表。

另外

>>> type((False))              
<class 'bool'>
>>> type((False,))
<class 'tuple'>