【Python学习】python中的数据类型与运算方法
目录
1. 内建原子数据类型
1.1.整数类型和浮点数类型（int 和 float）
表 1-1 关系运算符和逻辑运算符
2. 内建集合数据类型
2.1 列表类型（list）
表 1-2 可应用于任意 Python 序列的运算
表 1-3 Python 列表提供的方法
2.2 字符串类型（string）
表 1-4 Python 字符串提供的方法
2.3 元组类型（tuple）
2.4 集合类型（set）
表 1-5 Python 集支持的运算
表 1-6 Python 集提供的方法
2.5 字典类型（dict）
表 1-7 Python 字典支持的运算
1-8 Python 字典提供的方法
1. 内建原子数据类型
1.1.整数类型和浮点数类型（int 和 float）
标准的数学运算符，即+、-、*、/以及**（幂），可以和能够 改变运算优先级的括号一起使用。其他非常有用的运算符包括取余（取模）运算符%，以及整除运算符//。注意，当两个整数相除时，其结果是一个浮点数，而整除运算符截去小数部分，只返 回商的整数部分。
Python 通过 bool 类实现对表达真值非常有用的布尔数据类型。布尔对象可能的状态值是 True 或者 False，布尔运算符有 and、or 以及 not。
布尔对象也被用作相等（==）、大于（>）等比较运算符的计算结果。此外，结合使用关系 运算符与逻辑运算符可以表达复杂的逻辑问题。表 1-1 展示了关系运算符和逻辑运算符。
表 1-1 关系运算符和逻辑运算符
| 运 算 名 | 运 算 符 | 解 释 |
| 小于 | < | 小于运算符 |
| 大于 | > | 大于运算符 |
| 小于或等于 | <= | 小于或等于运算符 |
| 大于或等于 | >= | 大于或等于运算符 |
| 等于 | == | 相等运算符 |
| 不等于 | != | 不等于运算符 |
| 逻辑与 | and | 两个运算数都为 True 时结果为 True |
| 逻辑或 | or | 某一个运算数为 True 时结果为 True |
| 逻辑非 | not | 对真值取反，False 变为 True，True 变为 False |
2. 内建集合数据类型
2.1 列表类型（list）
列表是零个或多个指向 Python 数据对象的引用的有序集合，通过在方括号内以逗号分隔的一 系列值来表达。空列表就是[]。列表是异构的，这意味着其指向的数据对象不需要都是同一个类， 并且这一集合可以被赋值给一个变量。
注意，当 Python 计算一个列表时，这个列表自己会被返回。然而，为了记住该列表以便后 续处理，其引用需要被赋给一个变量。
由于列表是有序的，因此它支持一系列可应用于任意 Python 序列的运算，如表 1-2 所示。
表 1-2 可应用于任意 Python 序列的运算
| 运 算 名 | 运 算 符 | 解 释 |
| 索引 | [] | 取序列中的某个元素 |
| 连接 | + | 将序列连接在一起 |
| 重复 | * | 重复 N 次连接 |
| 成员 | in | 询问序列中是否有某元素 |
| 长度 | len | 询问序列的元素个数 |
| 切片 | [:] | 取出序列的一部分 |
列表支持一些用于构建数据结构的方法，如表 1-3 所示。
表 1-3 Python 列表提供的方法
| 方 法 名 | 用 法 | 解 释 |
| append | alist.append(item) | 在列表末尾添加一个新元素 |
| insert | alist.insert(i,item) | 在列表的第 i 个位置插入一个元素 |
| pop | alist.pop() | 删除并返回列表中最后一个元素 |
| pop | alist.pop(i) | 删除并返回列表中第 i 个位置的元素 |
| sort | alist.sort() | 将列表元素排序 |
| reverse | alist.reverse() | 将列表元素倒序排列 |
| del | del alist[i] | 删除列表中第 i 个位置的元素 |
| index | alist.index(item) | 返回 item 第一次出现时的下标 |
| count | alist.count(item) | 返回 item 在列表中出现的次数 |
| remove | alist.remove(item) | 从列表中移除第一次出现的 item |
>>> myList
[1024, 3, True, 6.5]
>>> myList.append(False)
>>> myList
[1024, 3, True, 6.5, False]
>>> myList.insert(2,4.5)
>>> myList
[1024, 3, 4.5, True, 6.5, False]
>>> myList.pop()
False
>>> myList
[1024, 3, 4.5, True, 6.5]
>>> myList.pop(1)
3
>>> myList
[1024, 4.5, True, 6.5]
>>> myList.pop(2)
True
>>> myList
[1024, 4.5, 6.5]
>>> myList.sort()
>>> myList
[4.5, 6.5, 1024]
>>> myList.reverse()
>>> myList
[1024, 6.5, 4.5]
>>> myList.count(6.5)
1
>>> myList.index(4.5)
2
>>> myList.remove(6.5)
>>> myList
[1024, 4.5]
>>> del myList[0]
>>> myList
[4.5] 2.2 字符串类型（string）
字符串是零个或多个字母、数字和其他符号的有序集合。这些字母、数字和其他符号被称为 字符。常量字符串值通过引号（单引号或者双引号均可）与标识符进行区分。
由于字符串是序列，因此之前提到的所有序列运算符都能用于字符串。此外，字符串还有一 些特有的方法，表 1-4 列举了其中一些。
表 1-4 Python 字符串提供的方法
| 方 法 名 | 用 法 | 解 释 |
| center | astring.center(w) | 返回一个字符串，原字符串居中，使用空格填充新字符串，使其长度为 w |
| count | astring.count(item) | 返回 item 出现的次数 |
| ljust | astring.ljust(w) | 返回一个字符串，将原字符串靠左放置并填充空格至长度 w |
| rjust | astring.rjust(w) | 返回一个字符串，将原字符串靠右放置并填充空格至长度 w |
| lower | astring.lower() | 返回均为小写字母的字符串 |
| upper | astring.upper() | 返回均为大写字母的字符串 |
| find | astring.find(item) | 返回 item 第一次出现时的下标 |
| split | astring.split(schar) | 在 schar 位置将字符串分割成子串 |
列表和字符串的主要区别在于，列表能够被修改，字符串则不能。列表的这一特性被称为可修改性。列表具有可修改性，字符串则不具有。
2.3 元组类型（tuple）
由于都是异构数据序列，因此元组与列表非常相似。它们的区别在于，元组和字符串一样是 不可修改的。元组通常写成由括号包含并且以逗号分隔的一系列值。与序列一样，元组允许之前 描述的任一操作。
>>> myTuple = (2,True,4.96)
>>> myTuple
(2, True, 4.96)
>>> len(myTuple)
3
>>> myTuple[0]
2
>>> myTuple * 3
(2, True, 4.96, 2, True, 4.96, 2, True, 4.96)
>>> myTuple[0:2]
(2, True) 然而，如果尝试改变元组中的一个元素，就会遇到错误。请注意，错误消息指明了问题的出 处及原因。
>>> myTuple[1]=False
Traceback (most recent call last):
File "", line 1, in -toplevel-
myTuple[1]=False
TypeError: object doesn't support item assignment 2.4 集合类型（set）
集（set）是由零个或多个不可修改的 Python 数据对象组成的无序集合。集不允许重复元素， 并且写成由花括号包含、以逗号分隔的一系列值。空集由 set()来表示。集是异构的，并且可以通过下面的方法赋给变量。
>>> {3, 6, "cat", 4.5, False}
{False, 4.5, 3, 6, 'cat'}
>>> mySet = {3, 6, "cat", 4.5, False}
>>> mySet
{False, 4.5, 3, 6, 'cat'} 尽管集是无序的，但它还是支持之前提到的一些运算，如表 1-5 所示。
表 1-5 Python 集支持的运算
| 运 算 名 | 运 算 符 | 解 释 |
| 成员 | in | 询问集中是否有某元素 |
| 长度 | len | 获取集的元素个数 |
| | | aset | otherset | 返回一个包含 aset 与 otherset 所有元素的新集 |
| & | aset & otherset | 返回一个包含 aset 与 otherset 共有元素的新集 |
| - | aset - otherset | 返回一个集，其中包含只出现在 aset 中的元素 |
| <= | aset <= otherset | 询问 aset 中的所有元素是否都在 otherset 中 |
集支持一系列方法，如表 1-6 所示。在数学中运用过集合概念的人应该对它们非常熟悉。注 意，union、intersection、issubset 和 difference 都有可用的运算符。
表 1-6 Python 集提供的方法
| 方 法 名 | 用 法 | 解 释 |
| union | aset.union(otherset) | 返回一个包含 aset 和 otherset 所有元素的集 |
| intersection | aset.intersection(otherset) | 返回一个仅包含两个集共有元素的集 |
| difference | aset.difference(otherset) | 返回一个集，其中仅包含只出现在 aset 中的元素 |
| issubset | aset.issubset(otherset) | 询问 aset 是否为 otherset 的子集 |
| add | aset.add(item) | 向 aset 添加一个元素 |
| remove | aset.remove(item) | 将 item 从 aset 中移除 |
| pop | aset.pop() | 随机移除 aset 中的一个元素 |
| clear | aset.clear() | 清除 aset 中的所有元素 |
>>> mySet
{False, 4.5, 3, 6, 'cat'}
>>> yourSet = {99,3,100}
>>> mySet.union(yourSet)
{False, 4.5, 3, 100, 6, 'cat', 99}
>>> mySet | yourSet
{False, 4.5, 3, 100, 6, 'cat', 99}
>>> mySet.intersection(yourSet)
{3}
>>> mySet & yourSet
{3}
>>> mySet.difference(yourSet)
{False, 4.5, 6, 'cat'}
>>> mySet - yourSet
{False, 4.5, 6, 'cat'}
>>> {3,100}.issubset(yourSet)
True
>>> {3,100}<=yourSet
True
>>> mySet.add("house")
>>> mySet
{False, 4.5, 3, 6, 'house', 'cat'}
>>> mySet.remove(4.5)
>>> mySet
{False, 3, 6, 'house', 'cat'}
>>> mySet.pop()
False
>>> mySet
{3, 6, 'house', 'cat'}
>>> mySet.clear()
>>> mySet
set() 2.5 字典类型（dict）
字典是无序结构，由相关的元素对构成，其中每对元素 都由一个键和一个值组成。这种键–值对通常写成键:值的形式。字典由花括号包含的一系列以逗 号分隔的键–值对表达，如下所示。
>>> capitals = {'Iowa':'DesMoines','Wisconsin':'Madison'}
>>> capitals
{'Wisconsin':'Madison', 'Iowa':'DesMoines'}可以通过键访问其对应的值，也可以向字典添加新的键–值对。访问字典的语法与访问序列 的语法十分相似，只不过是使用键来访问，而不是下标。添加新值也类似。
>>> capitals['Iowa']
'DesMoines'
>>> capitals['Utah']='SaltLakeCity'
>>> capitals
{'Utah':'SaltLakeCity', 'Wisconsin':'Madison', 'Iowa':'DesMoines'}
>>> capitals['California']='Sacramento'
>>> capitals
{'Utah':'SaltLakeCity', 'Wisconsin':'Madison', 'Iowa':'DesMoines',
'California':'Sacramento'}
>>> len(capitals)
4 需要谨记，字典并不是根据键来进行有序维护的。第一个添加的键–值对（'Utah':'SaltLakeCity'）被放在了字典的第一位，第二个添加的键–值对（'California':'Sacramento'） 则被放在了最后。键的位置是由散列来决定的。以上示例也说明，len 函数对字典的功能与对其他集合的功能相同。
字典既有运算符，又有方法。表 1-7 和表 1-8 分别展示了它们。keys、values 和 items 方 法均会返回包含相应值的对象。可以使用 list 函数将字典转换成列表。在表 1-8 中可以看到， get 方法有两种版本。如果键没有出现在字典中，get 会返回 None。然而，第二个可选参数可 以返回特定值。
表 1-7 Python 字典支持的运算
| 运 算 名 | 运 算 符 | 解 释 |
| [] | myDict[k] | 返回与 k 相关联的值，如果没有则报错 |
| in | key in adict | 如果 key 在字典中，返回 True，否则返回 False |
| del | del adict[key] | 从字典中删除 key 的键–值对 |
1-8 Python 字典提供的方法
| 方 法 名 | 用 法 | 解 释 |
| keys | adict.keys() | 返回包含字典中所有键的 dict_keys 对象 |
| values | adict.values() | 返回包含字典中所有值的 dict_values 对象 |
| items | adict.items() | 返回包含字典中所有键–值对的 dict_items 对象 |
| get | adict.get(k) | 返回 k 对应的值，如果没有则返回 None |
| get | adict.get(k, alt) | 返回 k 对应的值，如果没有则返回 alt |
>>> phoneext={'david':1410, 'brad':1137}
>>> phoneext
{'brad':1137, 'david':1410}
>>> phoneext.keys()
dict_keys(['brad', 'david'])
>>> list(phoneext.keys())
['brad', 'david']
>>> phoneext.values()
dict_values([1137, 1410])
>>> list(phoneext.values())
[1137, 1410]
>>> phoneext.items()
dict_items([('brad', 1137), ('david', 1410)])
>>> list(phoneext.items())
[('brad', 1137), ('david', 1410)]
>>> phoneext.get("kent")
>>> phoneext.get("kent", "NO ENTRY")
'NO ENTRY'