本篇文章主要是对python学习时的一些总结，作为学习笔记记录。

在程序设计和编程中，会涉及到各种各样的数据类型，而不同的数据类型变量之间可以进行的运算是不同的。在python中，变量的定义虽然不需要声明数据类型，但是并不意味着数据的存储方式是相同的，python中的数据类型是指变量在内存中的对象的类型。

数据类型

python中主要的数据类型有：

  • number
  • string
  • list
  • tuple
  • set
  • dict
  • class

其中class为自定义数据类型，除此之外是标准数据类型。

在标准数据类型中，number，string，tuple为不可变类型，list，dict，set为可变数据。

number

number是一种统称，主要包括int，float，complex，bool。

需要注意的是，在C/C++等语言中，会把int分为short，int，long等类型，但是在python中，只有一种int，此时的int相当于C/C++中的长整型。int类型的最大值可以利用sys得到，float类型的最大值可以则可以通过float函数得到：

import sys

print(sys.maxsize)
print(float('inf'))

结果为：

9223372036854775807
inf

上面的结果inf并不是一个字符串，而是一个float类型，可以使用之前提到过的type函数进行验证：

type(float('inf'))

结果为：

float

除了type函数可以查看数据类型之外，还可以使用isinstance函数进行验证：

isinstance(float('inf'),float)

结果为：

True

内建函数isinstance的函数签名为：

isinstance(obj, class_or_tuple, /)

该函数返回值为bool，说明obj是否是类或者子类的一个实例。如果第二个参数是元组的形式，则是判断是否是元组内几种类型的一个，相当于对多个结果进行逻辑或运算。

函数type和isinstance都能够判断对象的类型，但是两者还是有些区别的，主要体现在对类对象的判定上。

class A:
    pass

class B(A):
    pass

print(type(A()) == A)
print(type(B()) == B)
print(type(B()) == A)

print(isinstance(A(),A))
print(isinstance(B(),A))
print(isinstance(B(),B))

结果为：

True
True
False
True
True
True

从上面的结果可以看出：

  • type()不会认为子类是一种父类类型
  • isinstance()会认为子类是一种父类类型

运算和运算符

number类型之间的所涉及到的运算主要是一些数值计算，分别为：

print(5 + 3)          # 加法
print(5 - 3)          # 减法
print(5 * 3)          # 乘法
print(5 / 3)          # 除法
print(5 // 3)         # 整除
print(5 % 3)          # 取余
print(5 ** 3)         # 乘方

string

python中的字符串可以用单引号，双引号或者三引号括起来进行定义，对于一些特殊字符可以使用转义字符进行转义。但是三引号和但双引号之间也存在一些差异：

a = 'hello world'
b = "hello world"
c = '''hello
world'''
d = """hello
world"""

print(a)
print(b)
print(c)
print(d)

结果为：

hello world
hello world
hello
world
hello
world

从上面的结果可以看出，使用三引号构建的字符串在打印时能够保持原有的格式，可以用来构建多行文本。

随机访问

与C/C++中字符串的随机访问类似，python中的字符串也可以利用[]进行随机访问，但与C/C++中的随机访问仍有区别：

s = 'abcdefghijklmnopqrstuvwxyz'
print(s[0])
print(s[25])
print(s[-1])
print(s[-26])
print(s[0:-1])
print(s[0:])
print(s[0::2])
print(s[-1::-1])

print(s + s)
print(s * 3)

结果为：

a
z
z
a
abcdefghijklmnopqrstuvwxy
abcdefghijklmnopqrstuvwxyz
acegikmoqsuwy
zyxwvutsrqponmlkjihgfedcba
abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz
abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz

从上边的结果可以看出：

  • 下标0表示起始字符
  • 下标-len也表示起始字符。
  • 下标len-1表示末尾字符
  • 下标-1也表示末尾字符
  • 0:-1不包含末尾字符
  • 0:包含末尾字符
  • a:b:c的形式中，a表示起始位置，空默认为0，b表示终止位置，空默认为末尾，c表示步长，默认为1，可以借用这种形式实现倒序输出
  • + 为字符串连接
  • * 为对字符串进行复制

而对于字符串中本身要包含的字符，如果与转义字符的定义发生冲突，则可以在字符串前加上r来消除可能引起的歧义：

a = 'age\name'
print(a)
a = r'age\name'
print(a)

结果为：

age
ame
age\name

在本篇文章的开始提到字符串是不能改变的类型，这一点与C/C++类似，在C/C++中，如果定义了字符指针指向一个字符串，那么不能通过下标值的形式进行改变，在python中这样的操作同样是不允许的。

a = 'hello'
a[1] = '2'

如上边通过[]来修改a的元素值就是不被允许的，因此说python中的字符串是不可变类型。

list

list类似于C/C++中的vector，但是相较于vector有所不同，主要体现在：

  • list中元素的数据类型可以不同
  • list中元素的类型可以是number，string或者list
  • list写在[]之间，元素之间使用逗号分隔
a = [10,'hello',[10,'hello'],(10,'hello'),{'hello':10,'world':20}]
print(a)

结果为：

[10, 'hello', [10, 'hello'], (10, 'hello'), {'hello': 10, 'world': 20}]

随机访问

list中数据的随机访问和string类型是一样的，包括字符串的 + 和 * 操作。

但与string不同，list是可变的类型：

a = [10,'hello',[10,'hello'],(10,'hello'),{'hello':10,'world':20}]
a[0] = 20
print(a)

结果为：

[20, 'hello', [10, 'hello'], (10, 'hello'), {'hello': 10, 'world': 20}]

tuple

tuple与元组类似，但也有所不同：

  • tuple写在()中，元素之间用逗号分隔
  • tuple中的元素是不可更改的

除此之外，tuple与list的使用方法大致无差。需要注意的是当tuple中只有一个元素时的定义形式：

a = (10,'hello')
b = (20)
c = (20,)

print(type(a))
print(type(b))
print(type(c))

结果为：

<class 'tuple'>
<class 'int'>
<class 'tuple'>

从上边的结果可以看出，当tuple中只存在一个元素时，需要在该元素后多加一个逗号，用来表明这是一个tuple，而不至于被解释成单个变量。

随机访问

tuple中数据的随机访问和string类型是一样的，包括字符串的 + 和 * 操作。

与string类似，tuple是不可变类型，但是这种不可变与string类型的不可变有些许区别：

a = (10,'hello',[10,'hello'],(10,'hello'),{'hello':10,'world':20})
a[2][0] = 20
print(a)

结果为：

(10, 'hello', [20, 'hello'], (10, 'hello'), {'hello': 10, 'world': 20})

从上面的结果可以看出，虽然tuple是不可变类型的，但当tuple中的元素是嵌套的可变数据类型时，又可以改变此嵌套元素的元素。

set

set是由一个或者多个不同的元素构成的，构成set的对象称为元素或成员。

由于set的特性，因此set的基本功能是用来进行成员关系测试或是删除重复元素。set类型的主要特点有：

  • set使用{}或者set()函数进行构建
  • 创建空set时必须使用set()而不是{}，空的{}创建的是dict
  • 创建set的元素可以是嵌套类型，但必须是不可变类型
a = set([1,2,3,4])
b = {1,2,3,4}
c = set()
d = {}
e = {1,'hello',(1,'hello')}

print(type(a))
print(type(b))
print(type(c))
print(type(d))
print(e)

结果为：

<class 'set'>
<class 'set'>
<class 'set'>
<class 'dict'>
{1, (1, 'hello'), 'hello'}

运算及运算符

对于set来说，更多的是关注要测试的元素是否在set内，或者是进行set之间的集合运算：

a = set([1,2,3,4])

print(1 in a)               # 在
print(5 not in a)           # 不在

b = {3,4,5,6}
print(a - b)                # 差集
print(a | b)                # 并集
print(a & b)                # 交集
print(a ^ b)                # 并集-交集

结果为：

True
True
{1, 2}
{1, 2, 3, 4, 5, 6}
{3, 4}
{1, 2, 5, 6}

dict

dict与set和list等有所类似，但也有所不同，主要在于：

  • list是有序的对象集合，dict则是无序的对象集合
  • dict中的元素存储是通过key-value对来存储的，而不是类似于线性存储中的偏移存取的
  • dict使用{}标识
  • key必须是不可变类型
  • key必须唯一
a = {}
a[1] = 'jack'
a['tom'] = 10
print(a)

a[1] = 'jane'
a['tom'] = 'jim'
print(a)

print(a.keys())
print(a.values())

结果为：

{1: 'jack', 'tom': 10}
{1: 'jane', 'tom': 'jim'}
dict_keys([1, 'tom'])
dict_values(['jane', 'jim'])

同时也可以通过dict()函数来进行dict类型的创建：

a = dict([[1,'hello'],['10',30]])
b = dict(tom = 'hello',jack = 30)

print(a)
print(b)

结果为：

{1: 'hello', '10': 30}
{'tom': 'hello', 'jack': 30}

只是如果要使用第二种类型构建dict类型的话，key类型不能为number，string等表达式，需要使用符合命名规范的变量名。

class

class类型此处不做介绍，在后期面向对象的时候会提到。

数据类型转换

既然提到数据类型，当然也会有数据类型的转换，python种内置了几种函数，用来进行各种数据类型之间的转换。

函数

描述

int(x,[,base])

将x转换为一个整数

float(x)

将x转换到一个浮点数

complex(real,[,image])

创建一个复数

str(x)

将对象 x 转换为字符串

repr(x)

将对象 x 转换为表达式字符串

eval（x)

用来计算在字符串中的有效Python表达式,并返回一个对象

tuple(s)

将序列 s 转换为一个元组

list(s)

将序列 s 转换为一个列表

set(s)

转换为可变集合

dict(d)

创建一个字典。d 必须是一个 (key, value)元组序列。

frozenset(s)

转换为不可变集合

chr(x)

将一个整数转换为一个字符

ord(x)

将一个字符转换为它的整数值

bin(x)

将一个整数转换为一个二进制字符串

hex(x)

将一个整数转换为一个十六进制字符串

oct(x)

将一个整数转换为一个八进制字符串