Résumé des méthodes de conversion de type Python

Comment saisir la conversion en python ?

Recommandations associées : "vidéo python"

int

Prise en charge de la conversion en type int, uniquement float, str, bytes, autres types Aucun sont pris en charge.

float -> int

supprimera le point décimal et les valeurs suivantes, ne laissant que la partie entière.

int(-12.94)     # -12

str -> int

S'il y a des caractères autres que des chiffres (0-9) et des signes (+/-) dans la chaîne, il sera signalé une erreur.

int('1209')     # 1209
int('-12')      # -12
int('+1008')    # 1008

bytes -> int

S'il y a des caractères autres que des chiffres (0-9) et des signes (+/-) dans les octets, une erreur sera rapporté.

int(b'1209')     # 1209
int(b'-12')      # -12
int(b'+1008')    # 1008

float

prend en charge la conversion en type float, seuls int, str, bytes, les autres types ne sont pas pris en charge.

int -> float

Lors de la conversion de int en float, une décimale sera ajoutée automatiquement.

float(-1209)     # -1209.0

str -> float

Si la chaîne contient des signes positifs et négatifs (+/-), des nombres (0-9) et des points décimaux (.) caractères, la conversion n’est pas prise en charge.

float('-1209')          # -1209.0
float('-0120.29023')    # -120.29023

bytes -> float

Si les octets contiennent autre chose que des signes positifs et négatifs (+/-), des nombres (0-9) et des points décimaux ( .) caractères, la conversion n'est pas prise en charge.

float(b'-1209')         # -1209.0
float(b'-0120.29023')   # -120.29023

complexe

Prend uniquement en charge la conversion int, float, str en type complexe.

int -> complexe

int Lors de la conversion de complexe, la partie imaginaire sera automatiquement ajoutée et représentée par 0j.

complex(12)         # (12+0j)

float -> complex

float Lors de la conversion de complexe, la partie imaginaire sera automatiquement ajoutée et représentée par 0j.

complex(-12.09)     # (-12.09+0j)

str -> complex

str Lors de la conversion de complexe, s'il peut être converti en int ou float, il sera converti puis converti en complexe. Si la chaîne est entièrement conforme aux règles d'expression complexe, elle peut également être convertie en valeur de type complexe. La fonction

complex('-12.09')       # (-12.09+0j)
complex('-12.0')       # (-12+0j)，去除了小数部分
complex('-12')          # (-12+0j)
complex('-12+9j')       # (-12+9j)
complex('(-12+9j)')     # (-12+9j)
complex('-12.0-2.0j')   # (-12-2j)，去除了小数部分
complex('-12.0-2.09j')  # (-12-2.09j)
complex(b'12')          # 报错，不支持 bytes 转换为 complex
complex('12 + 9j')      # 报错，加号两侧不可有空格

str

str() peut convertir n'importe quel objet en chaîne.

int -> str

int La conversion de str le convertira directement complètement.

str(12)     # 12

float -> str

float La conversion de str supprimera la partie décimale avec le dernier 0.

str(-12.90)     # -12.9

complex -> str

la conversion complexe en str convertira d'abord la valeur en une expression complexe standard, puis la convertira en chaîne.

str(complex(12 + 9j))   # (12+9j)
str(complex(12, 9))     # (12+9j)

bytes -> str

La conversion des octets et des str est spéciale Dans Python 3.x, les chaînes et les octets ne sont plus complètement différents. types de données.

Convertir en chaîne d'expression exécutable :

  str(b'hello world')        # b'hello world'

la fonction str() spécifie le paramètre d'encodage, ou utilisez la méthode bytes.decode() pour convertir les données réelles :

b'hello world'.decode()       # hello world
str(b'hello world', encoding='utf-8')     # hello world
str(b'\xe4\xb8\xad\xe5\x9b\xbd', encoding='utf-8')  # 中国

liste -> str

会先将值格式化为标准的 list 表达式，然后再转换为字符串。

str([])               # []
str([1, 2, 3])          # [1, 2, 3]
''.join(['a', 'b', 'c'])   # abc

tuple -> str

会先将值格式化为标准的 tuple 表达式，然后再转换为字符串。

str(())             # ()
str((1, 2, 3))         # (1, 2, 3)
''.join(('a', 'b', 'c'))   # abc

dict -> str

会先将值格式化为标准的 dict 表达式，然后再转换为字符串。

str({'name': 'hello', 'age': 18})    # {'name': 'hello', 'age': 18}
str({})                     # {}
''.join({'name': 'hello', 'age': 18}) # nameage

set -> str

会先将值格式化为标准的 set 表达式，然后再转换为字符串。

str(set({}))            # set()
str({1, 2, 3})           # {1, 2, 3}
''.join({'a', 'b', 'c'})    # abc

其他类型

转换内置对象：

str(int)    # <class &#39;int&#39;>，转换内置类
str(hex)    # <built-in function hex>，转换内置函数

转换类实例：

class Hello:
    pass
obj = Hello()
print(str(obj))
# <__main__.Hello object at 0x1071c6630>

转换函数：

def hello():
    pass
print(str(hello))
# <function hello at 0x104d5a048>

bytes

仅支持 str 转换为 bytes 类型。

'中国'.encode()                   
# b'\xe4\xb8\xad\xe5\x9b\xbd'bytes('中国', encoding='utf-8')   
# b'\xe4\xb8\xad\xe5\x9b\xbd'

list

支持转换为 list 的类型，只能是序列，比如：str、tuple、dict、set等。

str -> list

list('123abc')      
# ['1', '2', '3', 'a', 'b', 'c']

bytes -> list

bytes 转换列表，会取每个字节的 ASCII 十进制值并组合成列表

list(b'hello')      
# [104, 101, 108, 108, 111]

tuple -> list

tuple 转换为 list 比较简单。

list((1, 2, 3))     
# [1, 2, 3]

dict -> list

字典转换列表，会取键名作为列表的值。

list({'name': 'hello', 'age': 18})  
# ['name', 'age']

set -> list

集合转换列表，会先去重为标准的集合数值，然后再转换。

list({1, 2, 3, 3, 2, 1})    
# [1, 2, 3]

tuple

与列表一样，支持转换为 tuple 的类型，只能是序列。

str -> tuple

tuple('中国人')    
# ('中', '国', '人')

bytes -> tuple

bytes 转换元组，会取每个字节的 ASCII 十进制值并组合成列表。

tuple(b'hello')     
# (104, 101, 108, 108, 111)

list -> tuple

tuple([1, 2, 3])    
# (1, 2, 3)

dict -> tuple

tuple({'name': 'hello', 'age': 18})     
# ('name', 'age')

set -> tuple

tuple({1, 2, 3, 3, 2, 1})
# (1, 2, 3)

dict

str -> dict

使用 json 模块

使用 json 模块转换 JSON 字符串为字典时，需要求完全符合 JSON 规范，尤其注意键和值只能由单引号包裹，否则会报错。

import json
user_info = '{"name": "john", "gender": "male", "age": 28}'
print(json.loads(user_info))
# {'name': 'john', 'gender': 'male', 'age': 28}

使用 eval 函数

因为 eval 函数能执行任何符合语法的表达式字符串，所以存在严重的安全问题，不建议。

user_info = "{'name': 'john', 'gender': 'male', 'age': 28}"
print(eval(user_info))
# {'name': 'john', 'gender': 'male', 'age': 28}

使用 ast.literal_eval 方法

使用 ast.literal_eval 进行转换既不存在使用 json 进行转换的问题，也不存在使用 eval 进行转换的 安全性问题，因此推荐使用 ast.literal_eval。

import ast
user_info = "{'name': 'john', 'gender': 'male', 'age': 28}"
user_dict = ast.literal_eval(user_info)
print(user_dict)
# {'name': 'john', 'gender': 'male', 'age': 28}

list -> dict

通过 zip 将 2 个列表映射为字典：

list1 = [1, 2, 3, 4]
list2 = [1, 2, 3]
print(dict(zip(list1, list2)))
# {1: 1, 2: 2, 3: 3}

将嵌套的列表转换为字典：

li = [
[1, 111],
[2, 222],
[3, 333],
]
print(dict(li))
# {1: 111, 2: 222, 3: 333}

tuple -> dict

通过 zip 将 2 个元组映射为字典：

tp1 = (1, 2, 3)
tp2 = (1, 2, 3, 4)
print(dict(zip(tp1, tp2)))
# {1: 1, 2: 2, 3: 3}

将嵌套的元组转换为字典：

tp = (
(1, 111),
(2, 222),
(3, 333),
)
print(dict(tp))
# {1: 111, 2: 222, 3: 333}

set -> dict

通过 zip 将 2 个集合映射为字典：

set1 = {1, 2, 3}
set2 = {'a', 'b', 'c'}
print(dict(zip(set1, set2)))
# {1: 'c', 2: 'a', 3: 'b'}

set

str -> set

先将字符切割成元组，然后再去重转换为集合。

print(set('hello'))     # {'l', 'o', 'e', 'h'}

bytes -> set

会取每个字节的 ASCII 十进制值并组合成元组，再去重。

set(b'hello')           # {104, 108, 101, 111}

list -> set

先对列表去重，再转换。

 set([1, 2, 3, 2, 1])    # {1, 2, 3}

tuple -> set

先对列表去重，再转换。

 set((1, 2, 3, 2, 1))    # {1, 2, 3}

dict -> set

会取字典的键名组合成集合。

set({'name': 'hello', 'age': 18})
# {'age', 'name'}

    

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!