Was sind die Python-Datentypen?

Es gibt acht Python-Datentypen, nämlich: numerischer Typ (int und long), Float-Typ, komplexer Typ (komplex), String-Typ, Listentyp, Tupeltyp, Wörterbuchtyp, boolescher Typ (True und False). ).

Python-Datentypen haben die folgenden acht Typen

Zahlentyp

int und long

Der Grund, warum int und long zusammengefügt werden sollten, besteht darin, dass int und long nach python3.x nicht mehr unterschieden werden und int einheitlich verwendet wird. Python2.x ist immer noch anders. Nehmen wir Python2.7 als Beispiel:

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

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

Warum also 10 int und 10000000000 lang ist, hängt natürlich mit dem Maximalwert des Typs int zusammen , also 2147483647 , können Sie auch sys.maxint verwenden.

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

Warum ist der mit der obigen Methode berechnete Wert ein langer Typ (das Hinzufügen von „L“ nach der Zahl weist auf einen langen Typ hin), weil der Wert von 2**31 2147483648 ist, was ein langer Typ ist? Subtrahieren Sie 1 von einem Long-Typ, und das Ergebnis ist immer noch ein Long-Typ, aber tatsächlich ist der Maximalwert des Int-Typs 2147483647

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

Float-Typ

Float-Typ und andere Sprachen Float sind im Grunde das Gleiche, um es ganz klar auszudrücken: Die Genauigkeit hängt von der Maschine ab. Zum Beispiel:

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

komplex: Pluraltyp, bitte überprüfen Sie die relevanten Dokumente für die spezifische Bedeutung und Verwendung von .

String-Typ

Es gibt drei Möglichkeiten, Zeichenfolgen zu deklarieren: einfache Anführungszeichen, doppelte Anführungszeichen und dreifache Anführungszeichen (einschließlich drei einfacher Anführungszeichen oder drei doppelter Anführungszeichen). Zum Beispiel:

>>> 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

Strings in Python haben zwei Datentypen: str-Typ und Unicode-Typ. Der Typ str verwendet ASCII-Codierung, was bedeutet, dass er kein Chinesisch darstellen kann.

Der Unicode-Typ verwendet Unicode-Codierung und kann beliebige Zeichen darstellen, einschließlich Chinesisch und anderen Sprachen.

Und es gibt in Python keinen char-Typ wie in der C-Sprache, selbst ein einzelnes Zeichen ist ein String-Typ. Die von der Zeichenfolge standardmäßig verwendete ASCII-Kodierung. Wenn Sie sie als Unicode-Typ deklarieren möchten, müssen Sie „u“ oder „U“ vor der Zeichenfolge hinzufügen. Zum Beispiel:

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

Da Operationen an Strings in Projekten häufig vorkommen und es aufgrund von Problemen bei der String-Kodierung viele Probleme gibt, sprechen wir über Probleme bei der String-Kodierung.

Im Umgang mit Python stoßen wir häufig auf drei Kodierungen: ASCII, Unicode und UTF-8. Eine ausführliche Einführung finden Sie in diesem Artikel.

Mein einfaches Verständnis ist, dass die ASCII-Codierung für englische Zeichen geeignet ist, Unicode für nicht-englische Zeichen (wie Chinesisch, Koreanisch usw.) und utf-8 ein Speicher- und Übertragungsformat für Uncode ist Neukodierung (kodiert in 8-Bit-Einheiten). Zum Beispiel:

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“。

Zusammenfassung der Codierungserfahrung:

1 Deklarieren Sie das Codierungsformat im Python-Dateiheader;

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

2 Zeichenfolgen werden als Unicode-Typ deklariert, d. ) Befolgen Sie ein Prinzip: Welches soll verwendet werden?

Gehen Sie davon aus, dass eine Textdatei mehrere Wörter im ANSI-Format enthält Sie können den folgenden Code direkt ausführen und möchten ihn auf der GUI oder in anzeigen. Beim Drucken in einer IDE (z. B. in Sublime Text oder in Pydev) werden verstümmelte Zeichen oder Ausnahmen angezeigt, da Codecs den Inhalt entsprechend lesen Kodierungsformat des Textes selbst:

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

Änderung Verwenden Sie einfach die folgende Methode (funktioniert nur für Chinesisch):

# -*- 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')

Listentyp

Eine Liste ist ein veränderbarer Sammlungstyp, und seine Elemente können Basistypen wie Zahlen und Zeichenfolgen oder Sammlungsobjekte wie Listen, Tupel und Wörterbücher oder sogar benutzerdefinierte Typen sein. Es ist wie folgt definiert:

>>> 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;]]

verwendet die Indizierung, um auf Listenelemente zuzugreifen. Der Index beginnt bei 0, unterstützt negative Indizes und -1 ist der letzte.

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

unterstützt Sharding-Vorgänge Zugriff auf eins. Elemente im Intervall unterstützen unterschiedliche Schrittgrößen, und Sharding kann für Dateneinfügungs- und Kopiervorgänge verwendet werden.

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']

Von der Liste unterstützte Methoden. Sie können die folgende Methode verwenden, um die von der Liste unterstützten öffentlichen Methoden anzuzeigen :

>>> [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]

Liste in Iterator konvertieren.

Der sogenannte Iterator ist ein Objekt mit einer nächsten Methode (diese Methode benötigt beim Aufruf keine Parameter). Wenn die nächste Methode aufgerufen wird, gibt der Iterator seinen nächsten Wert zurück. Wenn die nächste Methode aufgerufen wird, der Iterator jedoch keinen zurückzugebenden Wert hat, wird eine StopIteration-Ausnahme ausgelöst. Der Vorteil von Iteratoren gegenüber Listen besteht darin, dass die Verwendung von Iteratoren die Liste nicht auf einmal zum Speicher hinzufügen muss, sondern nacheinander auf die Daten der Liste zugreifen kann.

Verwenden Sie immer noch die obige Methode, um die öffentlichen Methoden des Iterators anzuzeigen:

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

Ja, als nächstes gibt es nur eine Methode:

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

Tupeltyp

Der Tupeltyp ist wie die Liste auch eine Sequenz. Im Gegensatz zur Liste kann der Tupeltyp nicht geändert werden. Die Deklaration des Tupels lautet wie folgt:

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;>

Wörterbuchtyp

Der Wörterbuchtyp ist eine Sammlung von Schlüssel-Wert-Paaren, ähnlich wie Dictionary oder JSON-Objekt in js. Die Initialisierungsmethode lautet wie folgt:

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教程》

Das obige ist der detaillierte Inhalt vonWas sind die Python-Datentypen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!