Python全栈之路系列之数字数据类型

上篇文章中咱们简单的体验了Python语言基本概念与语法，那么在继续深刻下去的过程当中，不妨先学习几个常见的Python内置数据类型？这也是大部分Python教科书的学习目录，由浅至深，慢慢深刻。

Python经常使用的几种数据类型就是如下几种，其实Python内部的数据类型仍是不少的，多归多可是不多有咱们用到了，太多了也记不了，把经常使用的几个玩熟练了就OK了。

那么接下来咱们会学到那些内置的数据类型呢？

虽说咱们是在学习数据类型，但其实只是在学习每个类型所提供的API而已，你所须要的大部分功能，Python都已经帮咱们封装好了，不须要担忧任何效率的问题，当你熟悉了这些API以后，灵活的组合应用，由于这在开发的过程当中是必不可少的，那么接下来就让咱们开始漫长的数据类型API学习之旅吧。

全部的数据类型所具有的方法都存在相对应的类里面，当建立一个类型的对象时，该对象所具有的功能都保存在相应的类中。

数字

在Python3中，整型、长整型、浮点数、负数、布尔值等均可以称之为数字类型。

建立数字类型类型的对象

int类型一般都是数字，建立数字类型的方式有两种，且在建立的时候值两边不须要加双引号或单引号。

第一种建立整型的方式

>>> number = 9
>>> type(number)
<class 'int'>

第二种建立整型的方式

>>> number = int(9)
>>> type(number)
<class 'int'>

以上两种建立整型对象的方式均可以建立的，可是他们也是有本质上的区别，第一种方式实际上会转换成第二种方式，而后第二种方式会把括号内的数据交给__init__这个构造方法，构造方法是int类的，而后构造方法会在内存中开辟一块空间用来存放数据，但实际上咱们在用时候是没有任何区别的。

构造方法每一个数据类型中都会有，这是Python内部所定义的，以下图所示：

__init__

def __init__(self, x, base=10): # known special case of int.__init__

能够从源码中看到，__init__的方法有两个参数，其中base=10是可选的参数，x是咱们对象的值，base=10其实就是说把咱们的值(默认二进制)以十进制的方式输出出来，经过下面的实例能够看到：

>>> var=int('0b100',base=2)
>>> var
4

经过int()能够将一个数字的字符串变成一个整数，而且若是你指定了第二个参数，还能够将值进制数转换为整数：

# 将数字字符串转换为整数，数字字符串经过进制转换为整数
>>> int('99'),int('100',8),int('40',16),int('10000000',2)
(99, 64, 64, 128)
# 讲进制数转换为整数
>>> int('0x40',16),int('0b1000000',2)
(64, 64)

把二进制的数字4经过十进制输出出来，4的二进制就是0b100，又有一个知识点就是在类的方法中，全部以__开头，而且以__结尾的方法都是Python内部本身去调用的，咱们在写代码的过程当中是不须要去调用的，最简单的例子就是__init__，经过上面的流程图咱们就能够很清楚的看到。

int内部优化机制

下图中咱们能够很清楚的看到int类型在建立对象时内存所分配空间的状况

首先咱们知道当咱们建立第一个对象var1的时候会在内存中开辟一块空间做为存放var1对象的值用的，当咱们建立第二个对象var2的时候也会在内存中开辟一块空间来做为var2对象的值，那若是这样说，那是否是说对象var1和var2的值内存是否会同时开辟两块呢？咱们经过下面的实例能够获得答案：

C:\Users\anshe>c:\Python35\python.exe
# 注意我是用的是Python3.5.1
Python 3.5.1 (v3.5.1:37a07cee5969, Dec  6 2016, 01:54:25) [MSC v.1900 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
# 分别建立对象var1和var2
>>> var1=123
>>> var2=123
# 咱们能够看到他们的内存地址都是指向的`1502084720`
>>> id(var1)
1502084720
>>> id(var2)
1502084720

经过上面的结果咱们能够看到var1和var2的内存地址是相同的，就表明他们的值是使用的同一块空间，那么若是我把var2的值改成456呢？

>>> var2=456
>>> id(var1)
1502084720
>>> id(var2)
2452305956816

能够看到var2的内存地址已经改变了（废话），由于对象的值不同了，因此他才不会改变，OK，咱们能够获得一个结论就是：当两个或者多个对象的值都是同一个的时候，那么这些对象都会使用同一个内存地址，这里的值是是有范围的，默认范围是-5~257，获得这个结论以后咱们继续往下看。

这张图咱们一样建立了两个对象，可是惟一不一样的是我把第一个建立的对象的值做为第二个对象的值，这里他们确定使用的是同一个内存地址，可是若是我把第一个对象的值改动了呢？

>>> var1=123
>>> var2=var1
>>> id(var1)
1502084720
>>> id(var2)
1502084720
>>> var1=456
>>> id(var1)
2452305956816
>>> id(var2)
1502084720

请自行思考，这里很少作解释，而后下面咱们再来讲说刚才的话题，说在-5~257这个范围内对象的值都会引用同一块内存地址，咱们能够经过下面的实验来测试：

>>> var1=12345
>>> var2=12345
>>> id(var1)
2452305956816
>>> id(var2)
2452308384720

事实证实咱们的结论是彻底没有问题的，注意我上面的实例都是在Python3.5上面执行的哦，var1和var2两个对象的值一样是12345，可是他们的内存地址就是不同，这就是Python在内部作的优化，他把-5~257这个范围内咱们经常使用道德数字多对象可引用的，OK，到此结束这个话题。

数字类型的长度限制

数字类型在python2.7里面是分整型和长整型这个区别的，也就是说若是你的数字大到必定的范围，那么python会把它转换为长整形，一个数字类型包含32位，能够存储从-2147483648到214483647的整数。

一个长整(long)型会占用更多的空间，64位的能够存储-922372036854775808到922372036854775808的整数。

python3里long型已经不存在了，而int型能够存储到任意大小的整型，甚至超过64为。

Python内部对整数的处理分为普通整数和长整数，普通整数长度为机器位长，一般都是32位，超过这个范围的整数就自动当长整数处理，而长整数的范围几乎彻底没限制，以下：

• Python2.7.x

>>> var=123456
>>> var
123456
>>> var=10**20
>>> var
100000000000000000000L
>>> type(var)
# long就是长整型
<type 'long'>

• Python3.5.x

>>> var=123456789
>>> var
123456789
>>> var=10**20
>>> var
100000000000000000000
>>> type(var)
<class 'int'>

请自行补脑 - - 、

数字类型所具有的方法

bit_length

返回表示该数字时占用的最少位数

>>> num=20
>>> num.bit_length()
5

conjugate

返回该复数的共轭复数，复数，好比0+2j,其中num.real,num.imag分别返回其实部和虚部，num.conjugate()，返回其共扼复数对象

>>> num =-20
>>> num.conjugate()
-20
>>> num=0+2j
>>> num.real
0.0
>>> num.imag
2.0
>>> num.conjugate()
-2j

imag

返回复数的虚数

>>> number = 10
>>> number.imag
0
>>> number = 3.1415926
>>> number.imag
0.0

内置的方法还有denominator、from_bytes、numerator、real、to_bytes，实在搞不懂这有什么用，也不太理解，就不作介绍了，你能够经过help(int.numerator)查看该方法的帮助信息等。

混合类型

所谓混合类型就是浮点数和整数进行运算，以下所示：

>>> 3.14159 + 10
13.14159

结果和咱们想象中的同样，可是一个浮点数一个正整数它是怎么进行相加的呢？其实很简单，Python会把两个值转换为其中最复杂的那个对象的类型，而后再对相同类型运算。

好比上面的例子中，会先把10转换为10.0而后再与3.14159相加。

数字类型的复杂度

整数比浮点数简单、浮点数比复数简单。

布尔类型(bool)

布尔类型其实就是数字0和1的变种而来，即真（True/0）或假（False/1），实际上就是内置的数字类型的子类而已。

# 若是0不是真，那么就输出'0 is False.'
>>> if not 0: print('0 is False.')
... 
0 is False.
# 若是1是真，那么就输出'1 is True.'
>>> if 1: print('1 is True.')
... 
1 is True.

你还可使用布尔值进行加减法，虽然历来没在任何代码中见过这种形式：

>>> True + 1
# 1 + 1 = 2
2
>>> False + 1
# 0 + 1 = 1
1

集合(set)

集合的元素是不容许重复、不可变且无序的集合，集合就像是字典舍弃了值同样，集合中的元素只可以出现一切且不能重复。

建立set集合

>>> s = set([11,22,33])
>>> s
{33, 11, 22}
>>> type(s)
<class 'set'>

第二种不经常使用建立set集合的方式

# 这种的建立方式，集合中的元素至关于字典中的key
>>> s = {11,22,33}
>>> type(s)
<class 'set'>
>>> s
{33, 11, 22}

把其它可迭代的数据类型转换为set集合

>>> li = ["a","b","c"]
>>> seting = set(li)
>>> seting
{'b', 'a', 'c'}
>>> type(seting)
<class 'set'>

集合一样支持表达式操做符

# 首先建立两个集合
>>> x = set('abcde')
>>> y = set('bdxyz')
>>> x
{'a', 'd', 'b', 'c', 'e'}
>>> y
{'y', 'd', 'b', 'x', 'z'}
# 使用in进行成员检测
>>> 'a' in x
True
# 差集
>>> x - y
{'a', 'e', 'c'}
# 并集
>>> x | y
{'b', 'y', 'z', 'a', 'd', 'e', 'c', 'x'}
# 交集
>>> x & y
{'d', 'b'}
# 对称差
>>> x ^ y
{'y', 'z', 'a', 'e', 'c', 'x'}
# 比较
>>> x > y, x < y
(False, False)

集合解析

>>> {x for x in 'abc'}
{'a', 'b', 'c'}
>>> {x+'b' for x in 'abc'}
{'bb', 'cb', 'ab'}

集合所提供的方法

add

往集合内添加元素

>>> se = { 11, 22, 33 }
>>> se
{33, 11, 22}
# 元素写在小括号内
>>> se.add(44)
>>> se
{33, 11, 44, 22}

 
clear

清除集合内容

>>> se = { 11, 22, 33 }
>>> se
{33, 11, 22}
>>> se.clear()
>>> se
set()

 
copy浅拷贝

下文介绍
 
difference

寻找集合的元素var1中存在，var2中不存在的

>>> var1 = { 11, 22, 33 }
>>> var2 = { 22 ,55 }
>>> var1.difference(var2)
{33, 11}
>>> var2.difference(var1)
{55}

 
difference_update

寻找集合的元素var1中存在，var2中不存在的元素，并把查找出来的元素从新复制给var1

>>> var1 = { 11, 22, 33 }
>>> var2 = { 22 ,55 }
>>> var1.difference_update(var2)
>>> var1
{33, 11}

 
discard

移除指定元素，不存在不保错

>>> var1 = { 11, 22, 33 }
>>> var1.discard(11)
>>> var1
{33, 22}
>>> var1.discard(1123123)
>>> var1
{33, 22}

remove

移除指定元素，不存在保错

>>> var1 = { 11, 22, 33 }
>>> var1
{33, 11, 22}
>>> var1.remove(11)
>>> var1
{33, 22}
>>> var1.remove(asda)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'asda' is not defined

intersection

交集，查找元素中都存在的值

>>> var1 = { 11, 22, 33 }
>>> var2 = { 22, 55, "一二" }
>>> var1.intersection(var2)
{22}

 
intersection_update

取交集并更更新到A中

>>> var1 = { 11, 22, 33 }
>>> var2 = { 22, 55, "一二" }
>>> var1.intersection_update(var2)
>>> var1
{22}

 
isdisjoint

判断有没有交集，若是有返回False，不然返回True

>>> var1 = { 11, 22, 33 }
>>> var2 = { 22, 44, 55 }
>>> var1.isdisjoint(var2)
False
>>> var2 = { 66, 44, 55 }
>>> var1.isdisjoint(var2)
True

 
issubset

是不是子序列,也就是说若是var2的全部元素都被var1所包含了，那么var2就是var1的子序列

>>> var1 = {11,22,33,44}
>>> var2 = {11,22}
>>> var2.issubset(var1)
True

issuperset

是不是父序列

>>> var1 = { 11, 22, 33 }
>>> var2 = { 22, 44, 55 }
>>> var1.issuperset(var2)
True

pop

移除一个元素，并显示移除的元素，移除时是无序的

>>> var1 = {11,22,33,44}
>>> var1.pop()
33
>>> var1
{11, 44, 22}

symmetric_difference

对称交集，把var1存在且b不存在和var2存在且var1不存在的元素合在一块儿

>>> var1 = { 11, 22, 33, 44 }
>>> var2 = { 11, 22, 77, 55 }
>>> var1.symmetric_difference(var2)
{33, 44, 77, 55}

symmetric_difference_update

对称交集，并更新到var1中

>>> var1 = { 11, 22, 33, 44 }
>>> var2 = { 11, 22, 77, 55 }
>>> var1
{33, 11, 44, 22}
>>> var1.symmetric_difference_update(var2)
>>> var1
{33, 44, 77, 55}

union

并集，把两个集合中的全部元素放在一块儿，若是有重复的则只存放一个

>>> var1 = { 11, 22, 33, 44 }
>>> var2 = { 11, 22, 77, 55 }
>>> var1.union(var2)
{33, 11, 44, 77, 22, 55}

update

更新，把一个集合中的元素更新到另外一个集合中

>>> var1 = { 11, 22, 33, 44 }
>>> var2 = { 11, 22, 77, 55 }
>>> var1.update(var2)
>>> var1
{33, 11, 44, 77, 22, 55}

---

原文连接

Python全栈之路系列文章