[python学习手册-笔记]002.python核心数据类型

python核心数据类型

❝

本系列文章是我个人学习《python学习手册（第五版）》的学习笔记，其中大部分内容为该书的总结和个人理解，小部分内容为相关知识点的扩展。

非商业用途转载请注明作者和出处；商业用途请联系本人（[e-mail]）获取许可。

❞

先来解决一个书上没搞懂的东西,「字面量」

百度百科给出的字面量的解释:"在计算机科学中，字面量（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

索引和切片

1. 「字符串是一个序列,支持索引和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
   

2. 「字符串支持分片操作」

   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. 字符串的拼接和重复

   字符串支持通过+ 进行连接. 也可以通过*进行重复.

   但是注意,这不代表字符串是可以改变的. 比如以下代码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中的数据类型还有:

• 类
• 代码块
• 布尔值
• 函数
• 模块

后续再详细讲解