Python 数据类型

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