Python 强制类型转换

最新推荐文章于 2025-10-21 09:55:06 发布

转载最新推荐文章于 2025-10-21 09:55:06 发布 · 1.8w 阅读

CC 4.0 BY-SA版权

原文链接：https://www.cnblogs.com/alexstraze/p/9267401.html

本文深入讲解了Python中的数据类型转换，包括从非字符串到字符串、非整数到整数、非浮点数到浮点数以及序列到列表或元组的转换方法。详细介绍了str(), repr(), eval(), int(), float(), list(), tuple()等函数的用法，以及类型转换过程中的注意事项。

参考链接：https://www.cnblogs.com/alexstraze/p/9267401.html

学习过程中遇到了强转问题，这里整理一下。

前言

本篇主要介绍Python的强制类型转换。

软件环境

系统
- UbuntuKylin 14.04
软件
- Python 2.7.3
- IPython 4.0.0

Python数据类型的显式转换

数据类型的显示转换，也称为数据类型的强制类型转换，是通过Python的内建函数来实现的类型转换。

显式转换的多种类型

int(x [,base]) ⇒ 将x转换为一个十进制的整数
long(x [,base]) ⇒ 将x转换为一个十进制的长整数
float(x) ⇒ 将x转换为一个浮点数
str(object) ⇒ 转换为字符串
repr(object) ⇒ 转换为表达式字符串
eval(str) ⇒ 用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(seq) ⇒ 将序列seq转换为一个元组
list(seq) ⇒ 将序列seq转换为一个列表
chr(x ) ⇒ 将一个整数转换为一个字符
unichr(x ) ⇒ 将一个整数转换为Unicode字符
ord(x ) ⇒ 将一个字符转换为它的整数值
hex(x ) ⇒ 将一个整数转换为一个十六进制字符串
oct(x ) ⇒ 将一个整数转换为一个八进制字符串

下面详细介绍一些常用的类型转换。

Non-String转换为String

str()函数

str(object=”) -> string
Return a nice string representation of the object.
If the argument is a string, the return value is the same object.
str()是最常用的转换为String的内建函数，可以接受任意对象，并将其转换为String类型。若object为String类型，则返回一个同类型的对象。
将List对象转换为String：

In [13]: li
Out[13]: ['My', 'Name', 'Is', 'Jmilk']

In [14]: strLi = str(li)

In [15]: print strLi[0]
[

将Tuple对象转换为String：

In [19]: tup = ('my','name','is','jmilk')

In [20]: str(tup)
Out[20]: "('my', 'name', 'is', 'jmilk')"

In [22]: str(tup)[3]
Out[22]: 'y'

将Dictionary对象转换为String：

In [23]: dic = {'name':'Jmilk','age':23}

In [24]: str(dic)
Out[24]: "{'age': 23, 'name': 'Jmilk'}"

In [25]: str(dic)[3]
Out[25]: 'g'

上面3个例子可以发现，在转换为String后无论是原来的特殊符号还是空格符都会成为String的元素之一。

repr()

repr(object) -> string
Return the canonical string representation of the object.
For most object types, eval(repr(object)) == object.
repr()函数的使用方法于str()函数类似，都是传入一个任意对象，再返回一个String类型对象，但两者却有着本质的区别。

str()和repr()的区别

主要的区别就在repr()支持eval(repr(object)) == object。str()函数的目标是一般用户的可读性，返回一个更适合人阅读的nice string。而repr()则返回一个更适合python解析器阅读的canonical strng，同时会返回Python解析器能够识别的数据细节，但这些细节对一般用户来说是多余的。而且repr()转换后的String对象可以通过求值运算eval()来还原到转换之前的对象，相比之下str()通常不需要eval()去处理。

In [61]: name = ('My name is Jmilk\n')

In [62]: print str(name)
My name is Jmilk


In [63]: print repr(name)
'My name is Jmilk\n'

上面例子可以看出str()打印出来的字符串会更符合人的阅读习惯。

eval()

eval()函数，能够结合repr()函数将一个经过转换为Strng类型后的对象还原为转换之前的对象类型。同时eval()也被称为求值运算，可以将字符串str当成有效的表达式来求值并返回计算结果。

In [64]: name = ('My name is Jmilk\n')

In [65]: name1 = str(name)

In [66]: name1
Out[66]: 'My name is Jmilk\n'

In [67]: name2 = repr(name)

In [68]: name2
Out[68]: "'My name is Jmilk\\n'"

In [69]: eval(name1)
  File "<string>", line 1
    My name is Jmilk
          ^
SyntaxError: invalid syntax


In [70]: eval(name2)
Out[70]: 'My name is Jmilk\n'

eval(str(Object))可能会报错，无法还原为原来的对象型。而eval(repr(object))却可以还原，下面例子：

In [81]: name = ('My','name','is','Jmilk\n')

In [82]: repr(name)
Out[82]: "('My', 'name', 'is', 'Jmilk\\n')"

In [83]: eval(repr(name))
Out[83]: ('My', 'name', 'is', 'Jmilk\n')

In [84]: type(eval(repr(name)))
Out[84]: tuple

总结：这是因为str()函数主要是为了让人能够更好的阅读其内容，而rper()除了转换为String类型外，还能够被Python解析器识别其数据细节，从而repr()转换后的字符串能够被当作有效表达式来处理。
注意：eval()函数最主要的功能是能够将字符串中有效的表达式进行计算并返回一个对象。如下：

In [141]: sum = '100+10'

In [142]: eval(sum)
Out[142]: 110

Non-int转换为int

Int型的最大值仅与系统位数有关，32位：maxInt == 2**(32-1)-1 ; 64位：maxInt == 2**(64-1)-1。可以通过sys.maxint
来查看：

In [42]: sys.maxint
Out[42]: 9223372036854775807

In [43]: 2**63-1
Out[43]: 9223372036854775807L

在Python2.4x版本之后为Int增加了Long的隐式转换来防止数据范围溢出。
int(x[, base=10]) -> int or long
base：指定进制
x：通常为一个String
base指定了x的进制

Long转换为Int，使用自定义函数

当一个Long > sys.maxint(2**63-1)时，Long类型对象是无法转换为Int的。
Example：

In [79]: int(2**63)
Out[79]: 9223372036854775808L     #仍为Long类型

下面使用一个自建的函数来实现当Long > sys.maxint时的Long到Int的强制类型转换。需要实现两个方面，一个是转换数值(不能超过maxint)，另一个是转换类型为int。
转换数值：

In [130]: %pycat longToInt.py
import sys
def longToInt(value):
    if value > sys.maxint:
        return (value & sys.maxint)
    else:
        return value

if __name__ == '__main__':
    number = 2**63
    result = longToInt(number)
    print 'number - sys.maxint = %s - %s = %s' % (number,sys.maxint,result)
    print 'result is %s,result type is %s;number type is %s' % (result,type(result),type(number))

In [131]: run longToInt.py
number - sys.maxint = 9223372036854775808 - 9223372036854775807 = 1
result is 0,result type is <type 'long'>;number type is <type 'long'>

上例：当number-sys.maxint=1时，将Long型number的数值转化为0输出。即当一个int类型的数值超过sys.maxint时，再将多余于的数值环回计数。以此类推，当number-sys.maxint=101时，Long型的number的环回计数为100。
需要注意的是：尽管数值是大于maxint，但是其数据类型仍然为long，可以使用int()函数将环回的数值转化为Int型，且只能在转换数值后才能成功额转换类型。
转换类型：

In [136]: %pycat longToInt.py
import sys
def longToInt(value):
    if value > sys.maxint:
        return (value & sys.maxint)
    else:
        return value

if __name__ == '__main__':
    number = 2**63+100
    result = longToInt(number)
    print 'number - sys.maxint = %s - %s = %s' % (number,sys.maxint,result+1)
    print 'result is %s,result type is %s;number type is %s' % (result,type(int(result)),type(number))

In [137]: run longToInt.py
number - sys.maxint = 9223372036854775908 - 9223372036854775807 = 101
result is 100,result type is <type 'int'>;number type is <type 'long'>

Float转换为Int

浮点型转为整型会进行向下取整。

In [130]: int(10.9)
Out[130]: 10

String转换为Int

In [131]: int('0xa',16)
Out[131]: 10

In [132]: int('1010',2)
Out[132]: 10

参数16表示’0xa’为16进制数，int()转换以后获得10进制数，若不指明’0xa’的进制，则会报错。

In [133]: int('0xa')

ValueError: invalid literal for int() with base 10: '0xa'

Non-long转化为long类型

long(x=0) -> long
long(x, base=10) -> long
生成一个long对象：

In [24]: long(10)
Out[24]: 10L

也可以简单的实现：

In [138]: num = 10L

In [139]: type(num)
Out[139]: long

Int转化为Long

int型转换为long型不需要强制类型转换，这就是相对的隐式类型转换，系统会在后台完成。在后面的博文中再作介绍。

Float转换为Long

向下取整

In [27]: long(10.9)
Out[27]: 10L

String转换为Long

In [33]: long('0xa',16)
Out[33]: 10L

In [34]: long('1010',2)
Out[34]: 10L

可以看出，Int与Long类型的数据非常类似，唯一的区别在于，Long类型的数据范围更加大。(Int)

Non-float转换为float

float(x) -> floating point number
Convert a string or number to a floating point number, if possible.
可以接收Int和String类型参数，float()函数在连接数据库操作会被经常使用。当参数为String时，只能出现数字和一个点额任意组合，若出现多个点号，则会出现异常。

In [194]: float(10)
Out[194]: 10.0

In [195]: float('100')
Out[195]: 100.0

In [199]: float('.1111')
Out[199]: 0.1111

In [204]: float('.98.')
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-204-70a1a06c7ce5> in <module>()
----> 1 float('.98.')

ValueError: invalid literal for float(): .98.

Sequence转换为List

list(iterable) -> new list initialized from iterable’s items
使用迭代器中的元素生成一个新的列表

String转换为List

将字符串中的每一个字母作为列表中的一个元素，空格也算是一个元素。

In [137]: name = 'My name is Jmilk'

In [138]: list(name)
Out[138]: 
['M',
 'y',
 ' ',
 'n',
 'a',
 'm',
 'e',
 ' ',
 'i',
 's',
 ' ',
 'J',
 'm',
 'i',
 'l',
 'k']

Tuple转换为List

Tuple转换为List与String其实大同小异：

In [1]: tup = ('My','name','is','Jmilk')

In [2]: list(tup)
Out[2]: ['My', 'name', 'is', 'Jmilk']

将Tuple对象中的每一个元素转换为List中的每个元素。

Sequence转换为Tuple

tuple(iterable) -> tuple initialized from iterable’s items
利用迭代器中的元素生成新的元组

String转换为Tuple

In [5]: str = 'My name is Jmilk!'

In [6]: tuple(str)
Out[6]: 
('M',
 'y',
 ' ',
 'n',
 'a',
 'm',
 'e',
 ' ',
 'i',
 's',
 ' ',
 'J',
 'm',
 'i',
 'l',
 'k',
 '!')

类似String转换为List，空格任然算一个元素。

List转换为Tuple

In [9]: li
Out[9]: ['My', 'name', 'is', 'Jmilk']

In [10]: tuple(li)
Out[10]: ('My', 'name', 'is', 'Jmilk')

将List和Tuple复合数据类型转换为Dictionary

格式：dict([(key1,value1),..])

In [144]: li = ['name','age','city']

In [145]: tup = ('jmilk',23,'BJ')

In [146]: zip(li,tup)
Out[146]: [('name', 'jmilk'), ('age', 23), ('city', 'BJ')]

In [148]: dict(zip(li,tup))
Out[148]: {'age': 23, 'city': 'BJ', 'name': 'jmilk'}

Dictionary转换为List

相对的，Dictionary的键值对也能够转换为List和Tuple的复合数据类型。
D.items() -> list of D’s (key, value) pairs, as 2-tuples

In [159]: dic
Out[159]: {'age': 23, 'city': 'BJ', 'name': 'jmilk'}

In [160]: dic.items()
Out[160]: [('city', 'BJ'), ('age', 23), ('name', 'jmilk')]

Int转换为字符char

chr(i) -> character
Return a string of one character with ordinal i; 0 <= i < 256.
以整数所对应的ASCII码来转换为Char，i属于[0,256)。

In [174]: chr(65)
Out[174]: 'A'

In [175]: chr(97)
Out[175]: 'a'