Python 数据类型

2019-07-05 本文已影响12人 Down1

Python3 有六个标准的数据类型：

数字（Numbers）
字符串（String）
列表（List）
元组（Tuple）
字典（Dictionary）
集合（Set）

Python3 的六个标准数据类型中：

不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）。
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

序列（sequence）：

String（字符串）
List （列表）
Tuple（元组）

一、数字

Python 支持四种不同的数值类型：
- int（整型）
- float（浮点型）
- complex（复数）
- bool（布尔值0和1）
利用内置函数 type() 可以用来查询变量所指的对象类型：

>>>  a, b, c, d = 20, 5.5, True, 4+3j
>>>  print(type(a), type(b), type(c), type(d))
class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

此外还可以用 isinstance() 来判断变量类型：

>>> a = 111
>>> isinstance(a, int)
True

isinstance 和 type 的区别在于：
type()不会认为子类是一种父类类型。
isinstance()会认为子类是一种父类类型。

使用del语句删除单个或多个对象：

>>> var_a = 1, var_b = 2    
>>> del var_a,var_b

数值运算

>>> 5 + 4         # 加法
9
>>> 4.3 - 2      # 减法
2.3
>>> 3 * 7        # 乘法
21
>>> 2 / 4        # 除法，得到一个浮点数
0.5
>>> 2 // 4       # 除法，得到一个整数
0
>>> 17 % 3   # 取余 
2
>>> 2 ** 5     # 乘方
32

注意：
- Python3中，没有Long型。这里的int可表示为长整型。
- Python可同时为多个变量赋值，如a, b = 1, 2。
- 一个变量可以通过赋值指向不同类型的对象。
- 数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。
- 在混合计算时，Python会把整型转换成为浮点数。
- Python 的复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示，复数的实部a和虚部b都是浮点型。

二、字符串

字符串用单引号 ' 或双引号 " 括起来。
字符串数据不可改变。
字符串的截取（切片）的语法格式如下：

变量[头下标:尾下标]

Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。也就是说，索引值以 0 为开始值，-1 为从末尾的开始位置。

字符串切片实例

>>> str = 'Runoob' 
>>> print (str)          # 输出字符串
Runoob

>>> print (str[0:-1])    # 输出第一个到倒数第二个的所有字符
Runoo

>>> print (str[0])       # 输出字符串第一个字符
R

>>> print (str[2:5])     # 输出从第三个开始到第五个的字符
noo

>>> print (str[2:])      # 输出从第三个开始的后的所有字符
noob

>>> print (str * 2)      # *号后紧跟输出的次数，此语句输出字符串两次
RunoobRunoob

>>> print (str + "TEST") # +号用来连接字符串
RunoobTEST

反斜杠(\)可以用来转义，使用r可以让反斜杠不发生转义：

>>> print('Ru\noob')
Ru
oob
>>> print(r'Ru\noob')
Ru\noob

字符串常用内置方法

方法	说明
str.strip()	删除字符串前后空格
str.replace(old, new)	把将字符串中的 old 替换成 new
str.join(seq)	以指定字符串作为分隔符，将 seq 中所有的元素合并为一个新的字符串
str.split(obj)	以 obj 为分隔符切割字符串，生成一个列表
str.find(obj)	检测 obj 是否包含在字符串中 str中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
str.index(obj)	跟find()方法一样，只不过如果str不在字符串中会报一个异常
string.startswith(obj)	检查字符串是否是以 obj 开头。是则返回 True，否则返回 False
string.endswith(obj)	检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束。如果是，返回 True，否则返回 False
string.upper()	转换 string 中的小写字母为大写
string.lower()	转换 string 中所有大写字符为小写

三、列表

列表是写在方括号 []之间、用逗号分隔开的元素列表。
列表的数据元素可修改。
列表截取的语法格式与字符串语法格式一致，如下：

变量[头下标:尾下标]

列表切片的索引与字符串相似，实例如下：

>>> list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
>>> tinylist = [123, 'runoob']
>>> print (list)            # 输出完整列表
['abcd', 786, 2.23, 'runoob', 70.2]

>>> print (list[0])         # 输出列表第一个元素
abcd

>>> print (list[1:3])       # 从第二个开始输出到第三个元素
[786, 2.23]

>>> print (list[2:])        # 输出从第三个元素开始的所有元素
[2.23, 'runoob', 70.2]

>>> print (tinylist * 2)    # 输出两次列表
[123, 'runoob', 123, 'runoob']

>>> print (list + tinylist) # 连接列表
['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']

列表中的元素可修改：

>>> a = [1, 2, 3, 4, 5, 6]
>>> a[0] = 9
>>> a[2:5] = [13, 14, 15]
>>> a
[9, 2, 13, 14, 15, 6]

>>> a[2:5] = []   # 将对应的元素值设置为 [] 
>>> a
[9, 2, 6]

Python 列表截取可以接收第三个参数，参数作用是截取的步长，如果第三个参数为负数表示逆向读取。以下实例在索引 1 到索引 4 的位置并设置为步长为 2（间隔一个位置）来截取字符串：
列表常用内置方法

方法	说明
append(obj)	在列表末尾添加新的元素，最常用的方法
count(obj)	统计某个元素出现的次数
extend(seq)	在列表末尾追加另一个列表（或其他序列类型）
index(obj)	从列表中找到一个匹配元素的索引位置，注意只能匹配第一个
insert(index, obj)	在指定的索引位置插入元素
pop(index)	删除指定索引位置的元素，如果不传值则表示删除最后一个元素
remove(obj)	删除指定的元素；如果有多个同样的元素，删除第一个
reverse()	将列表中的元素按照索引反向排列（不是反向排序，只是按照现有的顺序反过来而已）
sort()	对原列表进行排序。注意是原列表，上面讲的 sorted() 函数是返回一个排序后的新列表
copy()	将列表拷贝生成一个新的列表
clear()	清空列表

列表常用函数

函数	说明
len	取列表长度，也就是列表中元素的个数
max	取列表中的最大值，要注意列表中的元素必须是能够进行比较运算的数据类型
min	取列表中的最小值，注意事项同 max
sorted	对列表排序，并返回一个排好序的新列表，注意事项同 max

四、元组

元组写在小括号 ()里，元素之间用逗号隔开。
元组的元素不能修改，但它可以包含可变的对象，比如list列表。
元组也可用索引切片，与以上类似。
实例

>>> tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2  )
>>> tinytuple = (123, 'runoob')
>>> print (tuple)             # 输出完整元组
('abcd', 786, 2.23, 'runoob', 70.2)

>>> print (tuple[0])          # 输出元组的第一个元素
abcd

>>> print (tuple[1:3])        # 输出从第二个元素开始到第三个元素
(786, 2.23)

>>> print (tuple[2:])         # 输出从第三个元素开始的所有元素
(2.23, 'runoob', 70.2)

>>> print (tinytuple * 2)     # 输出两次元组
(123, 'runoob', 123, 'runoob')

>>> print (tuple + tinytuple) # 连接元组
('abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob')

构造包含 0 个或 1 个元素的元组：

tup1 = ()    # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号

元组支持的方法只有 count ( ) 和 index ( )

>>> t = (5, 6, 7, 'x', 'y', 7)
>>> t.count(7)    # 统计元素 7 出现的次数
2
>>> t.index('x')    # 返回元素 'x' 所在的索引值
3

元组可以转换为列表：

>>> t = (5, 6, 7, 'x', 'y', 7)
>>> list(t)    # 注意，原来的元组并没有变化，是生成了一个新的列表
[5, 6, 7, 'x', 'y', 7]

五、字典

字典是一种映射类型，字典用{ } 标识，它是一个无序的键(key) : 值(value) 的集合。
键(key)必须使用不可变类型，且不同重复。
字典是无序的对象集合，列表是有序的对象集合。
两者之间的区别：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典常用内置方法

方法	说明
get(key, default)	按 key 取值，如果 key 不存在，则返回 default 的值
items()	以列表返回可遍历的(键, 值) 元组对
keys()	以列表返回字典所有的键
values()	以列表返回字典所有的值
pop(key)	删除并返回指定key的值
setdefault(key,default=None)	和get()类似,但如果键不存在于字典中，将会添加键并将值设为default
fromkeys(seq)	创建一个新字典，以序列seq中元素做字典的键
update(dict2)	把字典dict2的键/值对更新到dict里
clear()	删除字典内所有元素
copy()	返回一个字典的浅复制

实例

>>> dict = {}    #空字典
>>> dict['Hello'] = "Good Luck"
>>> dict[2]     = "Sakura"
>>> tinydict = {'name': 'Sakura','num':1, 'color': 'pink'}
 
>>> print (dict['Hello'])       # 输出键为 'Hello' 的值
Good Luck

>>> print (dict[2])           # 输出键为 2 的值
Sakura

>>> print (tinydict)          # 输出完整的字典
{'name': 'Sakura','num':1, 'color': 'pink'}

>>> print (tinydict.keys())   # 输出所有键
dict_keys(['name', 'num', 'solor'])

>>> print (tinydict.values()) # 输出所有值
dict_values(['Sakura', 1, 'pink'])

构造函数 dict() 可以直接从键值对序列中构建字典如下：

>>> dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
{'Taobao': 3, 'Runoob': 1, 'Google': 2}
 
>>>  {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
 
>>>  dict(Runoob=1, Google=2, Taobao=3)
{'Runoob': 1, 'Google': 2, 'Taobao': 3}

六、集合

集合是一种可变，无序和不重复的序列.
集合可以使用大括号 { } 或者 set() 函数创建集合。
★ 注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
集合基本功能：进行成员关系测试和删除重复元素。
创建格式：

parame = {value1,value2,...}
或者
set(value)

创建空集合，使用s = set()方式。

>>> s = set()              
>>> s
# set()
>>> type(s)
# <class 'set'>

创建非空的集合,set()可以将任意一种序列变成集合

# 列表
>>> li = ['a', 'b', 'c']
>>> set(li)
# {'b', 'c', 'a'}

# 元组
>>> t = (1,2,3)
>>> set(t)
# {1, 2, 3}

# 字典
>>> d = {'x':1,'y':2}
>>> set(d)
# {'y', 'x'}

# 字符串
>>> set('python')
# {'y', 'p', 'n', 'h', 't', 'o'}

集合的测试，集合的交集、合集（并集）、差集，实例：

#!/usr/bin/python3 
student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
print(student)   # 输出集合，重复的元素被自动去掉
# 成员测试
if 'Rose' in student :
    print('Rose 在集合中')
else :
    print('Rose 不在集合中') 
# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')
print(a)
print(a - b)     # a 和 b 的差集
print(a | b)     # a 和 b 的并集
print(a & b)     # a 和 b 的交集
print(a ^ b)     # a 和 b 中不同时存在的元素

以上实例输出结果：

{'Mary', 'Jim', 'Rose', 'Jack', 'Tom'}
Rose 在集合中
{'b', 'a', 'c', 'r', 'd'}
{'b', 'd', 'r'}
{'l', 'r', 'a', 'c', 'z', 'm', 'b', 'd'}
{'a', 'c'}
{'l', 'r', 'z', 'm', 'b', 'd'}

集合元素的添加、删除（注意：集合中的元素不能是列表（list）、字典（dict))

集合元素的添加有两种常用方法，分别是add和update。

#add()
>>> s = {'b', 'c', 'a'}
>>> s.add('abc')     #这里会把'abc'当成一个字符串
>>> s
# {'b', 'c', 'abc', 'a'}

#update()
>>> s = {'b', 'c', 'a'}
>>> s.update('xyz')      #这里会把'xyz'当成序列来处理，'x','y','z'分别是三个元素
>>> s
# {'y', 'c', 'z', 'b', 'x', 'a'}

集合删除操作方法有两种：
s.remove('e')：删除匹配的元素；
s.pop()：删除第一个元素，无法指定index，因为集合没有index。

# remove()
>>> s = {'b', 'c', 'a'}
>>> s.remove('a')
>>> s
# {'b', 'c'}

# pop()
>>> s = {'b', 'c', 'a'}
>>> s.pop()
# 'b'
>>> s
# {'c', 'a'}

集合包含（in），不包含（not in），不等于（！=），等于测试（==）：

# 不等于 !=
>>> a != b
# True

# 等于 ==
>>> a == b
# False

# 包含 in
>>> a in b
# False

# 不包含 not in
>>> a not in b
# True

七、Python数据类型转换

函数	描述
int(x [,base])	将x转换为一个整数
float(x)	将x转换到一个浮点数
complex(real [,imag])	创建一个复数
str(x)	将对象 x 转换为字符串
repr(x)	将对象 x 转换为表达式字符串
eval(str)	用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s)	将序列 s 转换为一个元组
list(s)	将序列 s 转换为一个列表
set(s)	转换为可变集合
dict(d)	创建一个字典。d 必须是一个序列 (key,value)元组
frozenset(s)	转换为不可变集合
chr(x)	将一个整数转换为一个字符
ord(x)	将一个字符转换为它的整数值
hex(x)	将一个整数转换为一个十六进制字符串
oct(x)	将一个整数转换为一个八进制字符串

Life is going on. ——Sakura