Quels sont les types de données Python ?

Il existe huit types de données Python, à savoir : le type numérique (int et long), le type float, le type complexe (complexe), le type chaîne, le type liste, le type tuple, le type dictionnaire, le type booléen (Vrai et Faux ).

Les types de données Python ont les huit types suivants

Type de numéro

int et long

La raison pour laquelle int et long doivent être assemblés est qu'après python3.x, int et long ne sont plus distingués et int est utilisé uniformément. python2.x est toujours différent. Permettez-moi de prendre Python2.7 comme exemple :

>>> i = 10  
>>> type(i)  
<type &#39;int&#39;>

>>> i=10000000000  
>>> type(i)  
<type &#39;long&#39;>

Alors pourquoi 10 est un int et 10000000000 est long. Bien sûr, cela est lié à la valeur maximale de int. La valeur maximale du type int est 231-1. , qui est 2147483647 , vous pouvez également utiliser sys.maxint.

>>> 2**31-1  
2147483647L  
>>> sys.maxint  
2147483647

Pourquoi la valeur calculée à l'aide de la méthode ci-dessus est-elle un type long (l'ajout de « L » après le nombre indique un type long), car la valeur de 2**31 est 2147483648, qui est un type long. Soustrayez 1 d'un type long, et le résultat est toujours long, mais en fait la valeur maximale du type int est 2147483647

>>> type(2147483647)  
<type &#39;int&#39;>  
>>> type(2147483648)  
<type &#39;long&#39;>

type float

type float et d'autres langages Float est fondamentalement le même. Les nombres à virgule flottante, pour le dire franchement, sont des nombres avec une virgule décimale. La précision est liée à la machine. Par exemple :

>>> i = 10000.1212  
>>> type(i)  
<type &#39;float&#39;>

complexe : type pluriel, veuillez consulter les documents pertinents pour connaître la signification et l'utilisation spécifiques de .

Type de chaîne

Il existe trois façons de déclarer des chaînes : les guillemets simples, les guillemets doubles et les guillemets triples (dont trois guillemets simples ou trois guillemets doubles). Par exemple :

>>> str1 = 'hello world'  
>>> str2 = "hello world"  
>>> str3 = '''hello world'''  
>>> str4 = """hello world"""  
>>> print str1  
hello world  
>>> print str2  
hello world  
>>> print str3  
hello world  
>>> print str4  
hello world

Les chaînes en Python ont deux types de données : le type str et le type unicode. Le type str utilise le codage ASCII, ce qui signifie qu'il ne peut pas représenter le chinois.

Le type Unicode utilise le codage Unicode et peut représenter n'importe quel caractère, y compris le chinois et d'autres langues.

Et il n'y a pas de type char en Python comme en langage C, même un seul caractère est un type chaîne. Le codage ASCII utilisé par défaut par la chaîne. Si vous souhaitez la déclarer comme type Unicode, vous devez ajouter « u » ou « U » devant la chaîne. Par exemple :

>>> str1 = "hello"  
>>> print str1  
hello  
>>> str2 = u"中国"  
>>> print str2  
中国

Étant donné que les opérations sur les chaînes se produisent souvent dans les projets et qu'il existe de nombreux problèmes dus à des problèmes d'encodage de chaînes, parlons des problèmes d'encodage de chaînes.

Dans le processus de traitement de python, nous rencontrons souvent trois encodages : ASCII, Unicode et UTF-8. Veuillez consulter cet article pour une introduction détaillée.

Je comprends simplement que le codage ASCII convient aux caractères anglais, Unicode convient aux caractères non anglais (tels que le chinois, le coréen, etc.) et utf-8 est un format de stockage et de transmission pour Uncode. caractères. Réencodage (codé en unités de 8 bits). Par exemple :

u = u'汉'  
print repr(u) # u'\u6c49'  
s = u.encode('UTF-8')  
print repr(s) # '\xe6\xb1\x89'  
u2 = s.decode('UTF-8')  
print repr(u2) # u'\u6c49'  
解释：声明unicode字符串”汉“，它的unicode编码为”\u6c49“，经过utf-8编码转换后，它的编码变成”\xe6\xb1\x89“。

Résumé de l'expérience de codage :

1 Déclarez le format d'encodage dans l'en-tête du fichier python

#-*- coding: utf-8 -*-

2. chaînes Déclaré comme type Unicode, c'est-à-dire ajouter u ou U avant la chaîne

3. Pour les opérations de lecture et d'écriture de fichiers, il est recommandé d'utiliser codecs.open() au lieu du open( intégré). ). Suivez un principe, lequel utiliser Écrivez dans n'importe quel format, utilisez quel format lire

Supposons qu'il y ait plusieurs mots « caractères chinois » dans un fichier texte enregistré au format ANSI ; suivant directement le code et que vous souhaitez l'afficher sur l'interface graphique ou dans l'IDE. Lors de l'impression dans un IDE (par exemple, en texte sublime ou en pydev), des caractères tronqués ou des exceptions apparaîtront, car les codecs liront le contenu en fonction de l'encodage. format du texte lui-même :

f = codecs.open("d:/test.txt")  
content = f.read()  
f.close()  
print content

Changer Utilisez simplement la méthode suivante (ne fonctionne que pour le chinois) :

# -*- coding: utf-8 -*-  
  
import codecs  
  
f = codecs.open("d:/test.txt")  
content = f.read()  
f.close()  
  
if isinstance(content,unicode):  
    print content.encode('utf-8')  
    print "utf-8"  
else:  
    print content.decode('gbk').encode('utf-8')

Type de liste

Une liste est un type de collection modifiable, et ses éléments peuvent être des types de base tels que des nombres et des chaînes, ou des objets de collection tels que des listes, des tuples et des dictionnaires, ou même des types personnalisés. Il est défini comme suit :

>>> nums = [1,2,3,4]  
>>> type(nums)  
<type &#39;list&#39;>  
>>> print nums  
[1, 2, 3, 4]  
>>> strs = ["hello","world"]  
>>> print strs  
[&#39;hello&#39;, &#39;world&#39;]  
>>> lst = [1,"hello",False,nums,strs]  
>>> type(lst)  
<type &#39;list&#39;>  
>>> print lst  
[1, &#39;hello&#39;, False, [1, 2, 3, 4], [&#39;hello&#39;, &#39;world&#39;]]

utilise l'indexation pour accéder aux éléments de la liste. L'index commence à 0, prend en charge les index négatifs et

>>> lst = [1,2,3,4,5]  
>>> print lst[0]  
>>> print lst[-1]  
 
>>> print lst[-2]

prend en charge les opérations de partitionnement et peut. accéder à un élément dans l'intervalle prend en charge différentes tailles de pas, et le partitionnement peut être utilisé pour les opérations d'insertion et de copie de données

nums = [1,2,3,4,5]  
print nums[0:3]  #[1, 2, 3] #前三个元素  
  
print nums[3:]   #[4, 5]    #后两个元素  
  
print nums[-3:]  #[3, 4, 5] #后三个元素 不支持nums[-3:0]  
  
numsclone = nums[:]    
  
print numsclone    #[1, 2, 3, 4, 5]  复制操作  
  
print nums[0:4:2]   #[1, 3]    步长为2  
  
nums[3:3] = ["three","four"]   #[1, 2, 3, 'three', 'four', 4, 5]  在3和4之间插入  
  
nums[3:5] = []    #[1, 2, 3, 4, 5] 将第4和第5个元素替换为[] 即删除["three","four"]  
支持加法和乘法操作
lst1 = ["hello","world"]  
lst2 = ['good','time']  
print lst1+lst2  #['hello', 'world', 'good', 'time']  
  
print lst1*5  #['hello', 'world', 'hello', 'world', 'hello', 'world', 'hello', 'world', 'hello', 'world']

Méthodes prises en charge par la liste, vous pouvez utiliser la méthode suivante pour afficher les méthodes publiques prises en charge par la liste :

>>> [x for x in dir([]) if not x.startswith("__")]  
['append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']  
def compare(x,y):  
    return 1 if x>y else -1  
  
  
#【append】  在列表末尾插入元素  
lst = [1,2,3,4,5]  
lst.append(6)   
print lst     #[1, 2, 3, 4, 5, 6]  
lst.append("hello")  
print lst     #[1, 2, 3, 4, 5, 6]  
  
#【pop】  删除一个元素，并返回此元素的值 支持索引 默认为最后一个  
x = lst.pop()  
print x,lst     #hello [1, 2, 3, 4, 5, 6]  #默认删除最后一个元素  
x = lst.pop(0)  
print x,lst     #1 [2, 3, 4, 5, 6]  删除第一个元素  
  
#【count】  返回一个元素出现的次数  
print lst.count(2)    #1     
  
#【extend】  扩展列表  此方法与“+”操作的不同在于此方法改变原有列表，而“+”操作会产生一个新列表  
lstextend = ["hello","world"]  
lst.extend(lstextend)  
print lst           #[2, 3, 4, 5, 6, 'hello', 'world']  在lst的基础上扩展了lstextend进来   
  
#【index】  返回某个值第一次出现的索引位置，如果未找到会抛出异常  
print lst.index("hello")  #5      
  
#print lst.index("kitty") #ValueError: 'kitty' is not in list  出现异常  
  
  
#【remove】 移除列表中的某个元素，如果待移除的项不存在，会抛出异常  无返回值  
lst.remove("hello")  
print lst     #[2, 3, 4, 5, 6, 'world']  "hello" 被移除  
  
#lst.remove("kitty")         #ValueError: list.remove(x): x not in list  
  
#【reverse】  意为反转 没错 就是将列表元素倒序排列,无返回值  
print lst        #[2, 3, 4, 5, 6, 'world']  
lst.reverse()   
print lst        #[2, 3, 4, 5, 6, 'world']  
  
  
#【sort】 排序  
print lst    #由于上面的反转 目前排序为 ['world', 6, 5, 4, 3, 2]  
lst.sort()    
print lst    #排序后  [2, 3, 4, 5, 6, 'world']  
  
nums = [10,5,4,2,3]  
print nums     #[10,5,4,2,3]  
nums.sort(compare)  
print nums     #[2, 3, 4, 5, 10]

Convertir la liste en itérateur.

Le soi-disant itérateur est un objet avec une méthode suivante (cette méthode ne nécessite aucun paramètre lors de son appel). Lorsque la méthode suivante est appelée, l'itérateur renvoie sa valeur suivante. Si la méthode suivante est appelée mais que l'itérateur n'a aucune valeur à renvoyer, une exception StopIteration est levée. L'avantage des itérateurs par rapport aux listes est que l'utilisation d'itérateurs ne nécessite pas d'ajouter la liste à la mémoire en une seule fois, mais peut accéder aux données de la liste de manière séquentielle.

Utilisez toujours la méthode ci-dessus pour afficher les méthodes publiques de l'itérateur :

lst = [1,2,3,4,5]  
lstiter = iter(lst)  
print [x for x in dir(numiter) if not x.startswith("__")]  
>>>['next']

Oui, il n'y a qu'une seule méthode ensuite Pour un itérateur, vous pouvez faire ceci :

lst = [1,2,3,4,5]  
lstiter = iter(lst)  
  
for i in range(len(lst)):  
    print lstiter.next()  #依次打印  
    1  
    2  
    3  
    4  
    5

<. 🎜>

Type de tuple

Le type de tuple est une séquence comme la liste Contrairement à la liste, le type de tuple ne peut pas être modifié. La déclaration du tuple est la suivante :

lst = (0,1,2,2,2)  
lst1=("hello",)  
lst2 = ("hello")  
print type(lst1)    #<type &#39;tuple&#39;>  只有一个元素的情况下后面要加逗号 否则就是str类型  
print type(lst2)    #<type &#39;str&#39;>

Type de dictionnaire

Le type de dictionnaire est une collection de paires clé-valeur, similaire à Dictionary ou un objet json dans js. Sa méthode d'initialisation est la suivante :

dict1 = {}  
print type(dict1)      #<type &#39;dict&#39;>  声明一个空字典  
  
dict2 = {"name":"kitty","age":18}   #直接声明字典类型  
  
dict3 = dict([("name","kitty"),("age",18)])  #利用dict函数将列表转换成字典  
  
dict4 = dict(name=&#39;kitty&#39;,age=18)           #利用dict函数通过关键字参数转换为字典  
  
dict5 = {}.fromkeys(["name","age"])      #利用fromkeys函数将key值列表生成字典，对应的值为None   {&#39;age&#39;: None, &#39;name&#39;: None}  
字典基本的操作方法：
#【添加元素】    
dict1 = {}  
dict1["mykey"] = "hello world"     #直接给一个不存在的键值对赋值 即时添加新元素  
  
dict1[(&#39;my&#39;,&#39;key&#39;)] = "this key is a tuple"   #字典的键可以是任何一中不可变类型，例如数字、字符串、元组等  
  
#【键值对个数】  
print len(dict1)  
  
#【检查是否含有键】  
print "mykey" in dict1         #True  检查是否含有键为mykey的键值对  
print "hello" in dict1         #False  
  
#【删除】  
del dict1["mykey"]           #删除键为mykey的键值对

继续利用上面的方法查看字典的所有公共方法：

>>> [x for x in dir({}) if not x.startswith("__")]  
['clear', 'copy', 'fromkeys', 'get', 'has_key', 'items', 'iteritems', 'iterkeys', 'itervalues',  
 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values', 'viewitems', 'viewkeys', 'viewvalues']  
dict.clear()                          删除字典中所有元素  
  
dict.copy()                          返回字典(浅复制)的一个副本  
  
dict.get(key,default=None)     对字典dict 中的键key,返回它对应的值value，如果字典中不存在此键，则返回default 的值(注意，参数default 的默认值为None)  
  
dict.has_key(key)                 如果键(key)在字典中存在，返回True，否则返回False. 在Python2.2版本引入in 和not in 后，此方法几乎已废弃不用了，但仍提供一个 可工作的接口。  
  
dict.items()                         返回一个包含字典中(键, 值)对元组的列表  
  
dict.keys()                          返回一个包含字典中键的列表  
  
dict.values()                        返回一个包含字典中所有值的列表  
  
dict.iter()                            方法iteritems(), iterkeys(), itervalues()与它们对应的非迭代方法一样，不同的是它们返回一个迭代器，而不是一个列表。  
  
dict.pop(key[, default])         和方法get()相似，如果字典中key 键存在，删除并返回dict[key]，如果key 键不存在，且没有给出default 的值，引发KeyError 异常。  
  
dict.setdefault(key,default=None)  和方法set()相似，如果字典中不存在key 键，由dict[key]=default 为它赋值。  
  
dict.setdefault(key,default=None)   和方法set()相似，如果字典中不存在key 键，由dict[key]=default 为它赋值。

布尔类型

布尔类型即True和False,和其它语言中的布尔类型基本一致。下面列出典型的布尔值

print bool(0)   #False  
print bool(1)   #True  
print bool(-1)  #True  
  
print bool([])  #False  
print bool(())  #False  
print bool({})  #False  
print bool('')  #False  
print bool(None) #False

推荐教程：《python教程》

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!