1. Pythons Unterstützung für chinesische Schriftzeichen

#!/usr/bin/python
#coding: UTF-8
print „Hallo, Welt“;

2. Python-Kennung

In Python bestehen Bezeichner aus Buchstaben, Zahlen und Unterstrichen.

In Python können alle Bezeichner Englisch, Zahlen und Unterstriche (_) enthalten, dürfen aber nicht mit Zahlen beginnen.

Bezeichner in Python unterscheiden zwischen Groß- und Kleinschreibung.

Bezeichner, die mit einem Unterstrich beginnen, haben eine besondere Bedeutung. Klassenattribute, die mit einem einzelnen Unterstrich (_foo) beginnen, stellen Klassenattribute dar, auf die nicht direkt zugegriffen werden kann. Sie müssen über die von der Klasse bereitgestellte Schnittstelle aufgerufen werden und können nicht mit „from xxx import *“ importiert werden 🎜>

(__foo), das mit einem doppelten Unterstrich beginnt, stellt die privaten Mitglieder der Klasse dar; (__foo__), das mit einem doppelten Unterstrich beginnt und endet, stellt einen speziellen methodenspezifischen Bezeichner in Python dar, wie zum Beispiel __init__ () repräsentiert den Konstruktor der Klasse.

3. Python-reservierte Schlüsselwörter

and	exec	not
assert	finally	or
break	for	pass
class	from	print
continue	global	raise
def	if	return
del	import	try
elif	in	while
else	is	with
except	lambda	yield

4. Python-String-Darstellung

Python akzeptiert einfache Anführungszeichen (' ), doppelte Anführungszeichen (" ), dreifache Anführungszeichen (' '' """) werden zur Darstellung von Zeichenfolgen verwendet. Der Anfang und das Ende der Anführungszeichen müssen vom gleichen Typ sein.

Die dreifachen Anführungszeichen können aus mehreren Zeilen bestehen. Dies ist eine Abkürzungssyntax zum Schreiben von mehrzeiligem Text. Häufig verwendete Dokumentzeichenfolgen werden als Kommentare an bestimmten Stellen in der Datei verwendet.

word = 'word'sentence = "这是一个句子。"paragraph = """这是一个段落。
包含了多个语句"""

Nach dem Login kopieren

5. Die wichtigsten Python-Anmerkungen sind

# oder ''' ''' oder "" ""

6. Python-Datentypen:

Zahlen (Zahlen)
｛
｝

int (signed integer)
long (long [kann auch oktal und hexadezimal darstellen])
float (float)
komplex (Plural)

String (Zeichenfolge) {
Das Pluszeichen (+) ist der String-Verkettungsoperator und das Sternchen (*) ist der Wiederholungsvorgang. Das folgende Beispiel:

#!/usr/. bin/python
# -*- programming: UTF-8 -*-

str = 'Hello World!'

print str # Output Complete string
print str[0 ] # Das erste Zeichen in der Zeichenfolge ausgeben
print str[2:5] # Das dritte bis fünfte Zeichen in der Zeichenfolge ausgeben
print str[2:] # Die Zeichenfolge ab dem dritten Zeichen ausgeben
print str * 2 # Geben Sie die Zeichenfolge zweimal aus
print str + "TEST" # Geben Sie die verkettete Zeichenfolge aus
}
Liste
{
#!/usr/bin/python
# -*- Codierung: UTF-8 -*-

list = [ 'abcd', 786 , 2.23, ' john', 70.2 ]
tinylist = [123, 'john']

print list # Komplette Liste ausgeben
Liste drucken[0] # Das erste Element der Liste ausgeben
Liste drucken [1:3] # Das zweite bis dritte Element ausgeben
Liste drucken[2:] # Alle Elemente ausgeben vom dritten bis zum Ende der Liste
print tinylist * 2 # Die Liste zweimal ausgeben
print list + tinylist # Die kombinierte Liste drucken

Ausgabeergebnis des obigen Beispiels:

['abcd', 786, 2.23, 'john', 70.2]
abcd
[786, 2.23]
[2.23, 'john', 70.2]
[123, 'john', 123, 'john']
['abcd', 786, 2.23 , ' john', 70.2, 123, 'john']
}
Tupel (Tupel)
{
Tupel sind mit „()“ gekennzeichnet. Interne Elemente werden durch Kommas getrennt. Aber ist ein Tupel, das nicht zweimal zugewiesen werden kann, was einer schreibgeschützten Liste entspricht.

#!/usr/bin/python
# -*- Kodierung: UTF-8 -*-

tuple = ( 'abcd', 786 , 2.23, 'john', 70.2 )
tinytuple = (123, 'john')

print tuple # Gibt das vollständige Tupel aus
print tuple[0] # Gibt das aus tuple Das erste Element der Gruppe
print tuple[1:3] # Gibt das zweite bis dritte Element aus
print tuple[2:] # Gibt alle Elemente vom dritten bis zum Ende der Liste aus
print tinytuple * 2 # Das Tupel zweimal ausgeben
print tuple + tinytuple # Das kombinierte Tupel drucken

Das Ausgabeergebnis des obigen Beispiels:

('abcd', 786, 2.23, 'john', 70.2)
abcd
(786, 2.23)
(2.23, 'john', 70.2)
(123, ' john ', 123, 'john')
('abcd', 786, 2.23, 'john', 70.2, 123, 'john')

Das Folgende ist ein ungültiges Tupel, weil Tupel es sind darf nicht aktualisiert werden. Die Liste darf aktualisiert werden:

#!/usr/bin/python
# -*- Kodierung: UTF-8 -*-

tuple = ( 'abcd', 786 , 2.23, 'john', 70.2 )
list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]
tuple[2] = 1000 # Tupel Illegale Anwendungen in der Liste[2] = 1000 # Legale Anwendungen in der Liste
}
Wörterbuch
{
Wörterbücher sind mit „{ }“ gekennzeichnet. Ein Wörterbuch besteht aus einem Index (Schlüssel) und seinem entsprechenden Wert.

#!/usr/bin/python
# -*- Kodierung: UTF-8 -*-

dict = {}
dict['one'] = "Das ist einer "
dict[2] = "Das sind zwei"

tinydict = {'name': 'john','code':6734, 'dept': 'sales'}

print dict['one'] # Den Wert mit der Taste „one“ ausgeben
print dict[2] # Den Wert mit der Taste 2 ausgeben
print tinydict # Das komplette Wörterbuch ausgeben
print tinydict .keys() # Alle Schlüssel ausgeben
print tinydict.values() # Alle Werte ausgeben

Das Ausgabeergebnis ist:

Dies ist eins. Das sind zwei {'dept': 'sales', 'code': 6734, 'name': 'john'} ['dept', 'code', 'name'] ['sales', 6734 , 'john ']
}

7. Python-Datentypkonvertierung

Funktion	Beschreibung
int( x [ ,base])	Konvertieren Sie x in eine ganze Zahl
long(x [,base] )	Konvertieren Sie x in eine lange Ganzzahl
float(x)	X in einen Float umwandeln
complex(real [,imag])	Erstellen Sie eine komplexe Zahl
str(x)	Objekt x in String konvertieren
repr(x )	Objekt x in Ausdruckszeichenfolge konvertieren
eval(str)	wird verwendet, um einen gültigen Python-Ausdruck in einer Zeichenfolge auszuwerten und ein Objekt
Tupel(s)	Sequenz s in ein Tupel umwandeln
Liste(n)	Sequenz s wird in eine Liste umgewandelt
Satz(e)	In veränderlichen Satz konvertieren
dict(d)	Erstellt ein Wörterbuch. d muss eine Folge von (Schlüssel-, Wert-)Tupeln sein.
eingefrorene Menge(n)	In unveränderliche Menge konvertieren
chr(x)	Eine Ganzzahl in ein Zeichen umwandeln
unichr( x)	Eine Ganzzahl in ein Unicode-Zeichen konvertieren
ord(x)	Konvertieren Sie ein Zeichen in seinen ganzzahligen Wert
hex(x)	Konvertieren Sie eine Ganzzahl in eine hexadezimale Zeichenfolge
oct(x)	Konvertieren Sie eine Ganzzahl in eine Oktalzeichenfolge

8. Pythons Operatoren

Pythons arithmetische Operatoren

+	加 - 两个对象相加	a + b 输出结果 30
-	减 - 得到负数或是一个数减去另一个数	a - b 输出结果 -10
*	乘 - 两个数相乘或是返回一个被重复若干次的字符串	a * b 输出结果 200
/	除 - x除以y	b / a 输出结果 2
%	取模 - 返回除法的余数	b % a 输出结果 0
**	幂 - 返回x的y次幂	a**b 为10的20次方，输出结果 100000000000000000000
//	取整除 - 返回商的整数部分	9//2 输出结果 4 , 9.0//2.0 输出结果 4.0

Python-Vergleichsoperatoren

运算符	描述	实例
==	等于 - 比较对象是否相等	(a == b) 返回 False。
!=	不等于 - 比较两个对象是否不相等	(a != b) 返回 true.
<>	不等于 - 比较两个对象是否不相等	(a <> b) 返回 true。这个运算符类似 != 。
>	大于 - 返回x是否大于y	(a > b) 返回 False。
<	小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。	(a < b) 返回 true。
>=	大于等于 - 返回x是否大于等于y。	(a >= b) 返回 False。
<=	小于等于 - 返回x是否小于等于y。	(a <= b) 返回 true。

Pythons Zuweisungsoperator

运算符	描述	实例
=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c = a 等效于 c = c a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c = a 等效于 c = c a
//=	取整除赋值运算符	c //= a 等效于 c = c // a

bitweise Python-Operatoren

算符	描述	实例
&	按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0	(a & b) 输出结果 12 ，二进制解释： 0000 1100
\|	按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。	(a \| b) 输出结果 61 ，二进制解释： 0011 1101
^	按位异或运算符：当两对应的二进位相异时，结果为1	(a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~	按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1	(~a ) 输出结果 -61 ，二进制解释： 1100 0011，在一个有符号二进制数的补码形式。
<<	左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。	a << 2 输出结果 240 ，二进制解释： 1111 0000
>>	右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数	a >> 2 输出结果 15 ，二进制解释： 0000 1111

Logische Python-Operatoren

运算符	逻辑表达式	描述	实例
and	x and y	布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。	(a and b) 返回 20。
or	x or y	布尔"或" - 如果 x 是 True，它返回 True，否则它返回 y 的计算值。	(a or b) 返回 10。
not	not x	布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	not(a and b) 返回 False

Python-Mitgliedsoperatoren

运算符	描述	实例
in	如果在指定的序列中找到值返回 True，否则返回 False。	x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in	如果在指定的序列中没有找到值返回 True，否则返回 False。	x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

Priorität von Python

**	指数 (最高优先级)
~ + -	按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % //	乘，除，取模和取整除
+ -	加法减法
>> <<	右移，左移运算符
&	位 'AND'
^ \|	位运算符
<= < > >=	比较运算符
<> == !=	等于运算符
= %= /= //= -= += = *=	赋值运算符
is is not	身份运算符
in not in	成员运算符
not or and	逻辑运算符

Pythons mathematische Funktionen

fabs(x) zurückGibt die gerundete Ganzzahl der Zahl zurück, beispielsweise gibt math.floor(4.9) zurück 4Zum Beispiel gibt math.log(math.e ) 1,0 zurück, math.log(100,10) gibt 2,0 zurück gibt den Logarithmus von x zur Basis 10 zurück, beispielsweise gibt log10(100) 2,0 zurückGibt den Maximalwert des angegebenen Parameters zurück, der eine Sequenz sein kann. Gibt den Mindestwert des angegebenen Parameters zurück, der eine Sequenz sein kann. Gibt den ganzzahligen Teil und den Dezimalteil von x zurück. Die numerischen Vorzeichen der beiden Teile sind die gleichen wie bei x, und der ganzzahlige Teil ist ausgedrückt im Gleitkommatyp.

Funktion	Rückgabewert (Beschreibung)
abs(x)	gibt den absoluten Wert zurück eines Zahlenwerts, z. B. abs(-10) gibt 10 zurück 4.1) gibt 5 zurück
cmp(x, y)	Wenn x < y, gib -1 zurück, wenn x == y, gib 0 zurück, wenn x > return 1
exp(x)	Gibt die
Gibt den absoluten Wert der Zahl zurück, beispielsweise gibt math.fabs(-10) 10,0 zurück	floor(x)
	log(x)
	log10(x)
	max(x1, x2,...)
	min(x1, x2,...)
	modf(x)
pow(x, y)	x**y-Wert nach dem Betrieb.
round(x [,n])	Gibt den gerundeten Wert der Gleitkommazahl x zurück. Wenn der n-Wert angegeben ist, stellt er die Anzahl der Ziffern dar auf den Dezimalpunkt gerundet.
sqrt(x)	Gibt die Quadratwurzel der Zahl x zurück. Der Rückgabetyp ist beispielsweise eine reelle Zahl (4) gibt 2+0j

zurück

Python-Zufallsfunktion

Zufallszahlen können in Mathematik, Spielen, Sicherheit und anderen Bereichen verwendet werden und sind häufig darin eingebettet Algorithmen, um die Algorithmuseffizienz und die Programmsicherheit zu verbessern.

Python enthält die folgenden häufig verwendeten Zufallszahlenfunktionen:

函数	描述
choice(seq)	从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
randrange ([start,] stop [,step])	从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1
random()	随机生成下一个实数，它在[0,1)范围内。
seed([x])	改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
shuffle(lst)	将序列的所有元素随机排序
uniform(x, y)	随机生成下一个实数，它在[x,y]范围内。

Pythons trigonometrische Funktionen

Nummer	Beschreibung
acos(x)	Gibt den Arkuskosinus von x im Bogenmaß zurück.
asin(x)	Gibt den Arkussinus von x im Bogenmaß zurück.
atan(x)	Gibt den Arcustangens von x im Bogenmaß zurück.
atan2(y, x)	Gibt den Arkustangens der angegebenen X- und Y-Koordinatenwerte zurück.
cos(x)	Gibt den Kosinus von x im Bogenmaß zurück.
hypot(x, y)	Gibt die euklidische Norm sqrt(xx + yy) zurück.
sin(x)	Gibt den Sinus von x im Bogenmaß zurück.
tan(x)	Gibt den Tangens von x im Bogenmaß zurück.
Grad(x)	Bogenmaß in Winkel umwandeln, z. B. Grad(math.pi/2), Rückgabe 90,0
Bogenmaß (x)	Winkel in Bogenmaß umrechnen

Pythons integrierte Zeichenfolgenfunktionen

string.index(str, beg=0, end=len(string))

Methoden	Beschreibung
string.capitalize()	Fügen Sie die erste Zeichenfolge in Großbuchstaben ein
string.center(width)	gibt eine ursprüngliche Zeichenfolge zentriert und mit Leerzeichen aufgefüllt zurück. Neue Zeichenfolge auf Längenbreite
string.count(str, beg=0, end=len(string))	Gibt die Häufigkeit zurück, mit der str im String erscheint. Wenn beg oder end angegeben ist, wird die Häufigkeit zurückgegeben, mit der str im angegebenen Bereich erscheint.
String .decode(encoding='UTF-8',errors='strict')	String im durch Encoding angegebenen Codierungsformat decodieren. Wenn ein Fehler auftritt, wird eine ValueError-Ausnahme gemeldet standardmäßig, es sei denn, Fehler geben „ignorieren“ oder „ersetzen“ an
string.encode(encoding='UTF-8',errors='strict')	Die durch Encoding angegebene Codierung Formatcodierungszeichenfolge. Wenn ein Fehler auftritt, wird standardmäßig eine ValueError-Ausnahme gemeldet, es sei denn, Fehler geben „ignorieren“ oder „ersetzen“ an
Zeichenfolge .endswith( obj, beg=0, end=len(string))	Überprüfen Sie, ob die Zeichenfolge mit obj endet. Überprüfen Sie, ob das angegebene ist Bereich endet mit obj. Ende, wenn ja, geben Sie True zurück, andernfalls geben Sie False zurück.
string.expandtabs(tabsize=8)	Wandeln Sie das Tabulatorsymbol in der Zeichenfolge in Leerzeichen um. Die Standardanzahl der Leerzeichen für das Tabulatorsymbol beträgt 8.
string.find(str, beg=0, end=len(string))	Überprüfen Sie, ob str im String enthalten ist. Wenn beg und end den Bereich angeben, prüfen Sie, ob er im angegebenen Bereich enthalten ist. Wenn ja, geben Sie den Startindexwert zurück, andernfalls geben Sie -1 zurück 🎜>
Das Gleiche wie Nur die find()-Methode. Wenn str jedoch nicht in der Zeichenfolge enthalten ist, wird eine Ausnahme gemeldet
string.isalnum()	Gibt True zurückgeben, andernfalls False zurückgeben
string.isalpha()	Wenn string mindestens einen hat Zeichen und alle Zeichen sind Buchstaben geben True zurück, andernfalls False
string.isdecimal()	Gibt True zurück, wenn die Zeichenfolge nur Dezimalziffern enthält, andernfalls wird False zurückgegeben.
string.isdigit()	Gibt True zurück, wenn die Zeichenfolge nur Zahlen enthält, andernfalls wird False zurückgegeben.
string.islower()	Gibt True zurück wenn string mindestens ein Zeichen enthält, bei dem die Groß-/Kleinschreibung beachtet wird, und alle diese Zeichen (bei denen die Groß-/Kleinschreibung beachtet wird) Kleinbuchstaben sind, andernfalls False
string.isnumeric()	Wenn die Zeichenfolge nur numerische Zeichen enthält, geben Sie True zurück, andernfalls geben Sie False zurück
string.isspace()	Wenn die Zeichenfolge nur Leerzeichen enthält, geben Sie True zurück, andernfalls geben Sie False zurück.
string.istitle()	Gibt True zurück, wenn die Zeichenfolge einen Titel hat (siehe title()), andernfalls wird False zurückgegeben
string.isupper( )	Gibt „True“ zurück, wenn die Zeichenfolge mindestens ein Zeichen enthält, bei dem die Groß-/Kleinschreibung beachtet wird, und alle diese Zeichen (bei denen die Groß-/Kleinschreibung beachtet wird) Großbuchstaben sind, andernfalls „Falsch“
string.join(seq)	Verwenden Sie einen String als Trennzeichen, um alle Elemente in seq (String-Darstellung) zu einem neuen String zusammenzuführen
string.ljust(width)	gibt eine neue Zeichenfolge zurück, die die ursprüngliche Zeichenfolge links ausrichtet und mit Leerzeichen auffüllt Länge Breite
string.lower()	Alle Großbuchstaben im String in Kleinbuchstaben umwandeln.
string.lstrip()	Leerzeichen links von der Zeichenfolge abschneiden
string.maketrans(intab, outtab])	Mit der Methode maketrans() wird eine Konvertierungstabelle für die Zeichenzuordnung erstellt. Bei der einfachsten Aufrufmethode, die zwei Parameter akzeptiert, ist der erste Parameter eine Zeichenfolge, die das Zeichen darstellt, das konvertiert werden muss, und der zweite Parameter ist ebenfalls eine Zeichenfolge, die das Zeichen darstellt Ziel der Konvertierung.
max(str)	Gibt den größten Buchstaben in der Zeichenfolge str zurück.
min(str)	Gibt den kleinsten Buchstaben in der Zeichenfolge zurück str.
string.partition(str)	Ein bisschen wie find() und split ( ), beginnend mit der ersten Position, an der str erscheint, teilen Sie den String string in ein 3-Element-Tupel (string_pre_str, str, string_post_str). Wenn string nicht str enthält, dann string_pre_str == string.
string.replace(str1, str2, num=string.count(str1))	Ersetzen Sie str1 in string durch str2. Wenn num angegeben ist, wird die Ersetzung num mal
string.rfind(str, beg=0,end=) betragen len(string) )	ähnelt der Funktion find(), sucht jedoch von rechts.
string .rindex( str, beg=0,end=len(string))	Ähnlich wie index(), aber von rechts beginnend.
string.rjust(width)	Gibt eine neue Zeichenfolge zurück, wobei die ursprüngliche Zeichenfolge rechtsbündig ausgerichtet und mit Leerzeichen auf die Länge der Breite aufgefüllt ist
string.rpartition(str)	Ähnlich der Funktion partition(), aber von rechts beginnend.
string.rstrip()	Entfernen Sie die Leerzeichen am Ende der Zeichenfolge string.
string.split(str="", num=string.count(str))	Slice-String mit str als Trennzeichen. Wenn num einen angegebenen Wert hat, werden nur num-Teilzeichenfolgen getrennt
string.splitlines(num=string.count( ' n'))	Getrennt durch Zeilen, gibt eine Liste zurück, die jede Zeile als Element enthält. Wenn num angegeben ist, werden nur num Zeilen segmentiert.
string.startswith(obj, beg=0,end=len(string))	Überprüfen Sie, ob der String mit obj beginnt, wenn ja, Gibt True zurück, andernfalls wird False zurückgegeben. Wenn beg und end Werte angeben, prüfen Sie, ob sie innerhalb des angegebenen Bereichs liegen.
string.strip([obj])	Lstrip() und rstrip() für String ausführen
string.swapcase()	Groß-/Kleinschreibung im String umkehren
string.title()	Gibt eine „titled“-Zeichenfolge zurück, d. h. alle Wörter beginnen mit Großbuchstaben und die restlichen Buchstaben sind Kleinbuchstaben (siehe istitle())
string.translate(str, del="")	Konvertieren Sie die Zeichenfolge gemäß der durch str angegebenen Tabelle (mit 256 Zeichen). , Geben Sie die herauszufilternden Zeichen in den del-Parameter ein
string.upper()	Konvertieren Sie die Kleinbuchstaben im String in Großbuchstaben
string.zfill(width)	Die Rückgabelänge ist die Zeichenfolge mit der Breite, die ursprüngliche Zeichenfolge ist rechtsbündig und wird vorne mit 0 aufgefüllt
string.isdecimal()	Die Methode isdecimal() prüft, ob ein String nur Dezimalzeichen enthält. Diese Methode existiert nur für Unicode-Objekte.

Pythons Listenfunktion

序号	函数
1	cmp(list1, list2) 比较两个列表的元素
2	len(list) 列表元素个数
3	max(list) 返回列表元素最大值
4	min(list) 返回列表元素最小值
5	list(seq) 将元组转换为列表

Python enthält die folgenden Methoden:

序号	方法
1	list.append(obj) 在列表末尾添加新的对象
2	list.count(obj) 统计某个元素在列表中出现的次数
3	list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4	list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
5	list.insert(index, obj) 将对象插入列表
6	list.pop(obj=list[-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7	list.remove(obj) 移除列表中某个值的第一个匹配项
8	list.reverse() 反向列表中元素
9	list.sort([func]) 对原列表进行排序

Eingebaute Funktionen von Python-Tupeln

Python-Tupel enthalten die folgenden integrierten Funktionen

序号	方法及描述
1	cmp(tuple1, tuple2) 比较两个元组元素。
2	len(tuple) 计算元组元素个数。
3	max(tuple) 返回元组中元素最大值。
4	min(tuple) 返回元组中元素最小值。
5	tuple(seq) 将列表转换为元组。

In das Wörterbuch integrierte Funktionen und Methoden

Das Python-Wörterbuch enthält die folgenden integrierten Funktionen:

序号	函数及描述
1	cmp(dict1, dict2) 比较两个字典元素。
2	len(dict) 计算字典元素个数，即键的总数。
3	str(dict) 输出字典可打印的字符串表示。
4	type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。

Das Python-Wörterbuch enthält die folgenden integrierten Methoden:

序号	函数及描述
1	radiansdict.clear() 删除字典内所有元素
2	radiansdict.copy() 返回一个字典的浅复制
3	radiansdict.fromkeys() 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
4	radiansdict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值
5	radiansdict.has_key(key) 如果键在字典dict里返回true，否则返回false
6	radiansdict.items() 以列表返回可遍历的(键, 值) 元组数组
7	radiansdict.keys() 以列表返回一个字典所有的键
8	radiansdict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9	radiansdict.update(dict2) 把字典dict2的键/值对更新到dict里
10	radiansdict.values() 以列表返回字典中的所有值

Python 日期和时间

thon 程序能用很多方式处理日期和时间，转换日期格式是一个常见的功能。

Python 提供了一个 time 和 calendar 模块可以用于格式化日期和时间。

时间间隔是以秒为单位的浮点小数。

每个时间戳都以自从1970年1月1日午夜（历元）经过了多长时间来表示。

Python 的 time 模块下有很多函数可以转换常见日期格式。如函数time.time()用于获取当前时间戳, 如下实例:

#!/usr/bin/python# -*- coding: UTF-8 -*-import time;  # 引入time模块ticks = time.time()print "当前时间戳为:", ticks

Nach dem Login kopieren

以上实例输出结果：

当前时间戳为: 1459994552.51

Nach dem Login kopieren

时间戳单位最适于做日期运算。但是1970年之前的日期就无法以此表示了。太遥远的日期也不行，UNIX和Windows只支持到2038年。

什么是时间元组？

很多Python函数用一个元组装起来的9组数字处理时间:

序号	字段	值
0	4位数年	2008
1	月	1 到 12
2	日	1到31
3	小时	0到23
4	分钟	0到59
5	秒	0到61 (60或61 是闰秒)
6	一周的第几日	0到6 (0是周一)
7	一年的第几日	1到366 (儒略历)
8	夏令时	-1, 0, 1, -1是决定是否为夏令时的旗帜

Das Obige ist das struct_time-Tupel. Diese Struktur hat die folgenden Eigenschaften:

序号	属性	值
0	tm_year	2008
1	tm_mon	1 到 12
2	tm_mday	1 到 31
3	tm_hour	0 到 23
4	tm_min	0 到 59
5	tm_sec	0 到 61 (60或61 是闰秒)
6	tm_wday	0到6 (0是周一)
7	tm_yday	1 到 366(儒略历)
8	tm_isdst	-1, 0, 1, -1是决定是否为夏令时的旗帜

获取当前时间

从返回浮点数的时间辍方式向时间元组转换，只要将浮点数传递给如localtime之类的函数。

#!/usr/bin/python# -*- coding: UTF-8 -*-import time

localtime = time.localtime(time.time())print "本地时间为 :", localtime

Nach dem Login kopieren

以上实例输出结果：

本地时间为 : time.struct_time(tm_year=2016, tm_mon=4, tm_mday=7, tm_hour=10, tm_min=3, tm_sec=27, tm_wday=3, tm_yday=98, tm_isdst=0)

Nach dem Login kopieren

获取格式化的时间

你可以根据需求选取各种格式，但是最简单的获取可读的时间模式的函数是asctime():

#!/usr/bin/python# -*- coding: UTF-8 -*-import time

localtime = time.asctime( time.localtime(time.time()) )print "本地时间为 :", localtime

Nach dem Login kopieren

以上实例输出结果：

本地时间为 : Thu Apr  7 10:05:21 2016

Nach dem Login kopieren

格式化日期

我们可以使用 time 模块的 strftime 方法来格式化日期，：

time.strftime(format[, t])

Nach dem Login kopieren

#!/usr/bin/python# -*- coding: UTF-8 -*-import time# 格式化成2016-03-20 11:45:39形式print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) # 格式化成Sat Mar 28 22:24:24 2016形式print time.strftime("%a %b %d %H:%M:%S %Y", time.localtime()) 
  # 将格式字符串转换为时间戳a = "Sat Mar 28 22:24:24 2016"print time.mktime(time.strptime(a,"%a %b %d %H:%M:%S %Y"))

Nach dem Login kopieren

以上实例输出结果：

2016-04-07 10:25:09Thu Apr 07 10:25:09 20161459175064.0

Nach dem Login kopieren

python中时间日期格式化符号：

%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%M 分钟数（00=59）
%S 秒（00-59）
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身

获取某月日历

Calendar模块有很广泛的方法用来处理年历和月历，例如打印某月的月历：

#!/usr/bin/python# -*- coding: UTF-8 -*-import calendar

cal = calendar.month(2016, 1)print "以下输出2016年1月份的日历:"print cal;

Nach dem Login kopieren

以上实例输出结果：

以下输出2016年1月份的日历:
    January 2016Mo Tu We Th Fr Sa Su
             1  2  3
 4  5  6  7  8  9 1011 12 13 14 15 16 1718 19 20 21 22 23 2425 26 27 28 29 30 31

Nach dem Login kopieren

Time 模块

Time 模块包含了以下内置函数，既有时间处理相的，也有转换时间格式的：

Seriennummer	Funktion und Beschreibung
1	time.altzone Zurück zu Greenway Der Offset in Sekunden für die westliche Sommerzeitzone. Negative Werte werden zurückgegeben, wenn das Gebiet östlich von Greenwich liegt (z. B. Westeuropa, einschließlich Großbritannien). Nur in Regionen verfügbar, in denen die Sommerzeit aktiviert ist.
2	time.asctime([tupletime]) Akzeptiert ein Zeittupel und gibt eine lesbare Form von „Tue Dec 11 18:07: 14 2008“ zurück " (Dienstag, 11. Dezember 2008 18:07:14) ist eine 24-stellige Zeichenfolge.
3	time.clock( ) Gibt die aktuelle CPU-Zeit in Sekunden als Gleitkommazahl zurück. Es dient zur Messung des Zeitverbrauchs verschiedener Programme und ist nützlicher als time.time().
4	time.ctime([secs]) Die Funktion entspricht asctime(localtime(secs)), was bedeutet, dass keine Parameter angegeben sind entspricht asctime()
5	time.gmtime([secs]) Erhält das Timeout (die Anzahl der seit der Epoche 1970 verstrichenen Gleitkommasekunden). ) und gibt die astronomische Greenwich-Zeit zurück. Das Zeittupel unter t. Hinweis: t.tm_isdst ist immer 0. und gibt das Zeittupel t in Ortszeit zurück (t.tm_isdst kann 0 oder 1 sein, je nachdem, ob die Ortszeit Sommerzeit ist).
7	time.mktime(tupletime) Akzeptiert ein Zeittupel und gibt die Zeit zurück (die Anzahl der seit Epoche 1970 verstrichenen Gleitkommasekunden).
8	time.sleep(secs) Verzögern Sie die Ausführung des aufrufenden Threads, sek. bezieht sich auf die Anzahl der Sekunden.
9	time.strftime(fmt[,tupletime]) Empfängt ein Zeittupel und gibt die Ortszeit als lesbaren String in einem von fmt bestimmten Format zurück.
10	time.strptime(str,fmt='%a %b %d %H:%M:%S %Y') gemäß to Das Format von fmt analysiert eine Zeitzeichenfolge in ein Zeittupel.
11	time.time( ) Gibt den Zeitstempel der aktuellen Zeit zurück (die Anzahl der seit Epoche 1970 verstrichenen Gleitkommasekunden).
12	time.tzset() Zeitbezogene Einstellungen gemäß der Umgebungsvariablen TZ neu initialisieren.

Das Zeitmodul enthält die folgenden 2 sehr wichtigen Attribute:

Seriennummer	Attribute und Beschreibung

序号	属性及描述
1	time.timezone 属性time.timezone是当地时区（未启动夏令时）距离格林威治的偏移秒数（>0，美洲;<=0大部分欧洲，亚洲，非洲）。
2	time.tzname 属性time.tzname包含一对根据情况的不同而不同的字符串，分别是带夏令时的本地时区名称，和不带的。

<🎜><🎜>1<🎜>< 🎜>time.timezone<🎜>Die Eigenschaft time.timezone ist der Offset der lokalen Zeitzone (ohne Sommerzeit) von Greenwich in Sekunden (>0, Amerika;<=0die meisten Europas). , Asien, Afrika). 2time.tznameDas Attribut time.tzname enthält ein Paar Zeichenfolgen, die je nach Situation variieren Es ist der Name der lokalen Zeitzone mit und ohne Sommerzeit.

Kalendermodul

Die Funktionen dieses Moduls sind alle kalenderbezogen, wie zum Beispiel das Drucken des Charakterkalenders eines bestimmten Monats.

Montag ist der standardmäßige erste Tag der Woche und Sonntag ist der standardmäßige letzte Tag. Um die Einstellungen zu ändern, müssen Sie die Funktion Calendar.setfirstweekday() aufrufen. Das Modul enthält die folgenden integrierten Funktionen:

Seriennummer	Funktion und Beschreibung
1	Kalender.Kalender(Jahr , w=2,l=1,c=6) Gibt einen Jahreskalender im mehrzeiligen Zeichenfolgenformat mit 3 Monaten pro Zeile und einem Intervall von c zurück. Das tägliche Breitenintervall beträgt w Zeichen. Die Länge jeder Linie beträgt 21* W+18+2* C. l ist die Anzahl der Zeilen pro Woche.
2	calendar.firstweekday( ) Gibt die aktuelle Einstellung für den wöchentlichen Starttag zurück. Standardmäßig wird 0 zurückgegeben, wenn das Kalendermodul zum ersten Mal geladen wird, also am Montag.
3	calendar.isleap(year) gibt True zurück, wenn es ein Schaltjahr ist, andernfalls ist es false.
4	calendar.leapdays(y1,y2) Gibt die Gesamtzahl der Schaltjahre zwischen Y1 und Y2 zurück.
5	calendar.month(year,month,w=2,l=1) Gibt eine mehrzeilige Zeichenfolge zurück Das Kalenderformat ist Jahr und Monat, mit zwei Titelzeilen und einer Zeile für jede Woche. Das tägliche Breitenintervall beträgt w Zeichen. Die Länge jeder Zeile beträgt 7* w+6. l ist die Anzahl der Zeilen pro Woche.
6	calendar.monthcalendar(year,month) Gibt eine einstufige verschachtelte Liste von Ganzzahlen zurück. Jede Unterliste enthält eine Ganzzahl, die eine Woche darstellt. Daten außerhalb von „Jahr“, „Monat“ und „Monat“ werden alle auf 0 gesetzt; Tage innerhalb des Bereichs werden durch den Tag des Monats, beginnend bei 1, dargestellt.
7	calendar.monthrange(year,month) Gibt zwei Ganzzahlen zurück. Der erste ist der Datumscode des Wochentags des Monats und der zweite ist der Tagescode des Monats. Die Tage reichen von 0 (Montag) bis 6 (Sonntag); die Monate reichen von 1 bis 12.
8	calendar.prcal(year,w=2,l=1,c=6) entspricht print Calendar .calendar(year,w,l,c).
9	calendar.prmonth(year,month,w=2,l=1 ) Entspricht print Calendar.calendar(year, w, l, c).
10	calendar.setfirstweekday(weekday) Legen Sie den Starttagscode der Woche fest. 0 (Montag) bis 18 (Sonntag).
11	calendar.timegm(tupletime) Das Gegenteil von time.gmtime: akzeptiert eine Zeittupelform und gibt die Zeit zurück Die Tageszeit (die Anzahl der seit der Epoche 1970 verstrichenen Gleitkommasekunden).
12	calendar.weekday(year,month,day) Gibt den Datumscode für das angegebene Datum zurück. 0 (Montag) bis 18 (Sonntag). Die Monate reichen von 1 (Januar) bis 12 (Dezember).

Andere verwandte Module und Funktionen

In Python sind weitere Module zur Verarbeitung von Datums- und Uhrzeitangaben:

Datetime-Modul
Pytz-Modul
Dateutil-Modul

Das obige ist der detaillierte Inhalt vonEnzyklopädie der grundlegenden Python-Syntax. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!