python核心数据类型
❝
本系列文章是我个人学习《python学习手册（第五版）》的学习笔记，其中大部分内容为该书的总结和个人理解，小部分内容为相关知识点的扩展。
非商业用途转载请注明作者和出处；商业用途请联系本人（gaoyang1019@hotmail.com）获取许可。
❞
先来解决一个书上没搞懂的东西,「字面量」
百度百科给出的字面量的解释:"在计算机科学中，字面量（literal）是用于表达源代码中一个固定值的表示法（notation）。"
我表示没看懂,然后又查了一下.所谓字面量,就是那些赋值等号后面的数字啊字符串啊等等. 所以给出一个定性的解释吧.
var = 10 #这个"10"就是字面量
python的内置对象
| 对象类型 | 字面量/构造示例 |
|---|---|
| 数字 | 1234, 3.1415 |
| 字符串 | "hello" b'a\x01c' |
| 列表 | [1,2,"word"], list(range(10)) |
| 字典 | {"food":"tomato","price":6.66}, dict(hours=10) |
| 元组 | (1,2,"brady"),tuple('spam') |
| 文件 | open("egg.txt") |
| 集合 | set("abc"),{'a','b','c'} |
| 其他核心类型 | 类型,None,布尔型 |
| 程序单元类型 | 函数,模块,类 |
| Python实现相关类型 | 已编译代码,调用栈跟踪 |
数字类型
Python中的数字类型,除了支持常见的整数和浮点数之外,还有有虚部的附属,固定精度的十进制数字,带分子和分母的有理数等等. 支持常见的算数运算.
字符串
字符串是通过""或者''括起来的任意文本.在python中单引号和双引号的作用相同.
首先要明白字符串的两个特性:
python中的字符串是一个序列,也就是说它是遵循可迭代协议的 字符串是一个不可改变的量(这个理解起来有点困难,稍后会说,先承认这一特性)
字符串序列的操作
通过len()方法计算长度
In [2]: S = "spam"
In [3]: len(S)
Out[3]: 4
索引和切片
「字符串是一个序列,支持索引和for的遍历」
在字符串的索引中,负数表示逆向的索引,也就是从后往前.也就是说
S[-1]相当于S[len(S)-1]In [4]: S[0]
Out[4]: 's'
In [5]: S[-1]
Out[5]: 'm'
In [6]: for s in S:
...: print(s)
...:
s
p
a
m「字符串支持分片操作」
In [7]: S='hello'
# 取第三位到第五位之间的子串
In [8]: S[2:4]
Out[8]: 'll'
# 从第三位取到结尾
In [9]: S[2:]
Out[9]: 'llo'
# 取前三位
In [10]: S[:3]
Out[10]: 'hel'
# 从开始截取到倒数第二位之前
In [11]: S[:-2]
Out[11]: 'hel'注意,分片操作的时候,
X[I:J]表示的是从X[I]开始,到X[J]结束,但是不包括X[J]字符串的拼接和重复
字符串支持通过
+进行连接. 也可以通过*进行重复.但是注意,这不代表字符串是可以改变的. 比如以下代码3-4行中,
S+'xyz'.这并不是改变了原有字符串S,而是开辟新的内存空间,将原有字符串S和
'xyz'进行连接,生成一个新的量.In [12]: S = "spam"
In [13]: S+'xyz'
Out[13]: 'spamxyz'
In [14]: S*3
Out[14]: 'spamspamspam'这里,对于操作符
+对于不同的类型而言有着不同的作用. 比如在数字类型中表示算数运算中的加法,在字符串中表示字符串连接. 这一特性就是传说中的多态,也称之为运算符重载. 这是Python中的一个极其重要的设计思路.
不可变性
字符串在Python中是一个不可变的字面量. 在python核心类型中,字符串,数字,元组都是不可变的. 而列表,字典,集合是可变的.
当然,通过前面的学习,某些操作,仿佛可以改变字符串. 但是这里要说的是,这种所谓的"改变"字符串,实际上是生成新的字面量,而不是改变原有字面量.
特性类型的方法(内置方法)
Python对于不同的类型,内置了一些便捷的方法可以使用. 也就是我们所谓的内置方法. 相关的内置方法可以在python官网的文档进行查询.这也是后面我们要学习内容的一部分.
In [15]: S = "Spam"
# 字符串替换
In [17]: S.replace('pa','xz')
Out[17]: 'Sxzm'
In [18]: line = "aaa,bbb,ccc"
# 字符串分割
In [19]: line.split(',')
Out[19]: ['aaa', 'bbb', 'ccc']
在python中,我们可以通过dir()方法查看在其作用域内,该类型所支持的属性和方法.
In [20]: dir(S)
Out[20]:['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
转义字符和unicode字符串
python与其他语言一样,支持'\'的转义字符. 比如常见的\n和\t
另外python原生支持unicode字符串. (关于unicode字符串,后续会有相关文章介绍)
列表
列表是类似C语言中数组的一种东西. 但是相比C语言的数组,python的列表更加灵活:
python的列表不局限其内的数据类型. 同一个列表中可以存放不同类型的数据 python的列表是可变长的. python的列表支持推导表达式
# python的 列表中可以存放不同数据类型的数据
In [23]: L = [1,2,'egg']
In [24]: len(L)
Out[24]: 3
# 列表也支持拼接操作
In [25]: L + [4,5,6]
Out[25]: [1, 2, 'egg', 4, 5, 6]
# 列表同样支持重复操作
In [26]: L*2
Out[26]: [1, 2, 'egg', 1, 2, 'egg']
列表的边界检查
python的列表没有固定的大小,但是同样有边界检查,不允许引用不存在的元素. 也就是说,列表结尾之外的索引是不支持的.
In [27]: L = [1,2,3]
In [28]: L[3]
---------------------------------------------------------------------------
IndexError Traceback (most recent call last)
<ipython-input-28-28c5e42e8527> in <module>
----> 1 L[3]
IndexError: list index out of range
如果我们需要增加列表的元素,可以使用内置方法append
In [29]: L[3]=4
---------------------------------------------------------------------------
IndexError Traceback (most recent call last)
<ipython-input-29-3e20e34dcd62> in <module>
----> 1 L[3]=4
IndexError: list assignment index out of range
In [30]: L.append(4)
In [31]: L
Out[31]: [1, 2, 3, 4]
列表推导式
这就是python强大的地方了,列表中除了可以存放已知的,实际的数据外,还可以通过公式来生成一个列表. 这在矩阵处理中十分有用.
In [32]: M = [[1,2,3],[4,5,6],[7,8,9]]
In [33]: M
Out[33]: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
In [36]: diag=[M[i][i] for i in [0,1,2]]
In [37]: diag
Out[37]: [1, 5, 9]
# 传说中的列表生成式
In [38]: L = [[x,x/2,x*2] for x in range(-6,7,2) if x>0]
In [39]: L
Out[39]: [[2, 1.0, 4], [4, 2.0, 8], [6, 3.0, 12]]
字典
字典有很多的名字,字典,散列,哈希列表,映射等等. 字典不是一种序列,它是一种映射.是通过键-值对的形式来存储数据的.
它的存储原理和列表不同. 简答来说,字典的存储是将键(key)通过散列函数进行转换,得到一个地址,然后将值(value)放入该地址.
那也就是说,字典的查询速度和其大小无关. 所以对于搜索来说,字典比列表更合适.
字典的构造
这里列举出了字典的三种构造方式.
In [42]: bob = {'name':'bob','age':40,'job':'dev'}
In [43]: bob
Out[43]: {'name': 'bob', 'age': 40, 'job': 'dev'}
In [44]: bob2 = dict(name='bob',age=40,job='dev')
In [45]: bob2
Out[45]: {'name': 'bob', 'age': 40, 'job': 'dev'}
In [46]: bob3 = dict(zip(['name','job','age'],['bob','dev',40]))
In [47]: bob3
Out[47]: {'name': 'bob', 'job': 'dev', 'age': 40}
关于zip()方法的用法,后续的文章会讲到
字典中的值可以是简单的数值和字符串,也可以是其他类型,比如:
In [48]: bob4 = {'name':{"first":'bob','last':'Smith'},'job':['dev','test'],'age':40}
In [49]: bob4
Out[49]: {'name': {'first': 'bob', 'last': 'Smith'}, 'job': ['dev', 'test'], 'age': 40}
字典的键
字典的键是其索引,我们可以通过键来访问对应的数据,也可以通过键来增加新的数据. 但是对于不存在的键,同样是不支持访问的.
In [50]: abc = {'A':'a','B':'b','C':'c'}
In [51]: abc['B']
Out[51]: 'b'
In [52]: abc['D']='d'
In [53]: abc
Out[53]: {'A': 'a', 'B': 'b', 'C': 'c', 'D': 'd'}
In [54]: abc['E']
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
<ipython-input-54-15e1b0b37eaa> in <module>
----> 1 abc['E']
KeyError: 'E'
那么在访问字典数据之前,为了避免这种错误,我们可以检查一下我们要访问的键是否存在.
先说一个最容易理解的方式,通过if语句进行检查
In [57]: if 'D' in abc:
...: print('hit')
...: if not 'F' in abc:
...: print('miss')
...:
hit
miss
其次还可以使用get方法来进行检查,关于get方法,做一个简单的解释.
dict.get(key, default=None) get方法可以通过键来访问数据,如果访问不到则返回第二个参数.
In [58]: value = abc.get('D',0)
In [59]: value
Out[59]: 'd'
In [60]: value = abc.get('F',0)
In [61]: value
Out[61]: 0
另外,字典还支持通过keys方法返回一个包含所有键的可迭代对象.
In [67]: Ks = abc.keys()
In [71]: for key in Ks:
...: print(key)
...:
A
B
C
D
元组
python中的元组可以理解为是一种不可改变的列表. 用来表示确定的元素的集合. 语法很简单.如下:
In [72]: T1 = (1,2,3)
In [73]: type(T1)
Out[73]: tuple
In [74]: T1[1]
Out[74]: 2
In [77]: T1.count(2)
Out[77]: 1
In [78]: T1 +(4,5,6)
Out[78]: (1, 2, 3, 4, 5, 6)
元组同样像列表那样支持分片操作和索引. 但是元组不支持append等方法. 不准确的说,元组其实更像一个可以存放任意的类型的"字符"串.
那么,既然我们已经有了列表,为什么还需要元组呢?
元组和列表的主要区别在于,元组是不可改变的. 在一些特定的场景下,元组提供了一种完整性的约束.
文件
文件是一种比较特殊的类型,没有特定的字面量可以创建文件. 一般我们是通过open函数传递一个文件名和操作符来生成文件句柄.
In [79]: f = open('data.txt','wb')
In [81]: f.write(b'hello world')
Out[81]: 11
In [83]: f.close()
集合
python集合不是序列,也不是映射. 它是python中到目前为止,唯一一种不可变的对象的无序集合. 其实python中的集合其实就是数学上所谓的集合. 对,就是那个我们初中学习的交集,并集啥啥啥的玩意儿.
集合的创建有两种方法:
In [85]: X = {1,2,3,4}
In [87]: Y = set([3,4,5,6])
In [88]: X
Out[88]: {1, 2, 3, 4}
In [89]: Y
Out[89]: {3, 4, 5, 6}
# 交集
In [90]: X&Y
Out[90]: {3, 4}
# 并集
In [91]: X|Y
Out[91]: {1, 2, 3, 4, 5, 6}
# 差集
In [92]: X-Y
Out[92]: {1, 2}
# X是否为Y的超集
In [93]: X>Y
Out[93]: False
其他数据类型
除了以上介绍的核心类型之外,python中的数据类型还有:
类 代码块 布尔值 函数 模块
后续再详细讲解