1. Prise en charge par Python des caractères chinois
#!/usr/bin/python
#coding : UTF-8
imprimer "Bonjour le monde" ;
2. Identifiant Python
En python, les identifiants sont composés de lettres, de chiffres et de traits de soulignement.
En python, tous les identifiants peuvent inclure l'anglais, des chiffres et des traits de soulignement (_), mais ne peuvent pas commencer par des chiffres.
Les identifiants en Python sont sensibles à la casse.
Les identifiants commençant par un trait de soulignement ont une signification particulière. Les attributs de classe commençant par un seul trait de soulignement (_foo) représentent des attributs de classe auxquels il n'est pas possible d'accéder directement. Ils doivent être accessibles via l'interface fournie par la classe et ne peuvent pas être importés à l'aide de "from xxx import *" ; 🎜>
(__foo) commençant par un double trait de soulignement représente les membres privés de la classe ; (__foo__) commençant et se terminant par un double trait de soulignement représente un identifiant spécial spécifique à une méthode en Python, tel que __init__ () représentant le constructeur de la classe.
3. Mots-clés réservés python
| 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. Représentation de chaîne Python
Python accepte les guillemets simples (' ), les guillemets doubles (" ), les guillemets triples (' '' """) sont utilisés pour représenter des chaînes. Le début et la fin des guillemets doivent être du même type.
Les guillemets triples peuvent être composés de plusieurs lignes, ce qui est une syntaxe de raccourci pour écrire du texte sur plusieurs lignes. Les chaînes de document couramment utilisées sont utilisées comme commentaires à des emplacements spécifiques du fichier.
word = 'word'sentence = "这是一个句子。"paragraph = """这是一个段落。
包含了多个语句"""
Copier après la connexion
5. Les principales annotations Python sont
# ou ''''' ou "" """
6. Types de données Python :
Nombres (nombres)
｛
-
｝
Chaîne (chaîne de caractères) {
-
Le signe plus (+) est l'opérateur de concaténation de chaîne et l'astérisque (*) est l'opération de répétition. L'exemple suivant :
#!/usr/. bin/python
# -*- codage : UTF-8 -*-
str = 'Bonjour tout le monde !'
print str # Sortie Chaîne complète
print str[0 ] # Afficher le premier caractère de la chaîne
print str[2:5] # Afficher le troisième au cinquième caractère de la chaîne
print str[2:] # Afficher la chaîne à partir du troisième caractère
print str * 2 # Afficher la chaîne deux fois
print str + "TEST" # Afficher la chaîne concaténée
}
Liste
{
-
#!/usr/bin/python
# -*- codage : UTF-8 -*-
list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']
imprimer la liste # Afficher la liste complète
imprimer la liste[0] # Afficher le premier élément de la liste
imprimer la liste [1:3] # Afficher le deuxième au troisième élément
imprimer la liste[2:] # Afficher tous les éléments du troisième à la fin de la liste
imprimer la liste minuscule * 2 # Afficher la liste deux fois
imprimer la liste + la liste minuscule # Imprimer la liste combinée
Résultat de sortie de l'exemple ci-dessus :
['abcd', 786, 2.23, 'john', 70.2]
abcd
[786, 2.23]
[2.23, 'jean', 70.2]
[123, 'jean', 123, 'jean']
['abcd', 786, 2.23 , 'john', 70.2, 123, 'john']
}
Tuple (tuple)
-
{
-
Les tuples sont marqués d'un "()". Les éléments internes sont séparés par des virgules. Mais est un tuple qui ne peut pas être attribué deux fois, ce qui équivaut à une liste en lecture seule.
#!/usr/bin/python
# -*- codage : UTF-8 -*-
tuple = ( 'abcd', 786 , 2.23, 'john', 70.2 )
tinytuple = (123, 'john')
print tuple # Afficher le tuple complet
print tuple[0] # Afficher le tuple Le premier élément du groupe
print tuple[1:3] # Afficher le deuxième au troisième élément
print tuple[2:] # Afficher tous les éléments du troisième à la fin de la liste
print tinytuple * 2 # Afficher le tuple deux fois
print tuple + tinytuple # Imprimer le tuple combiné
Le résultat de sortie de l'exemple ci-dessus :
('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')
Ce qui suit est un tuple non valide car les tuples sont pas autorisé à être mis à jour. La liste peut être mise à jour :
#!/usr/bin/python
# -*- codage : UTF-8 -*-
tuple = ( 'abcd', 786 , 2.23, 'john', 70.2 )
list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]
tuple[2] = 1000 # Tuple Applications illégales dans la liste[2] = 1000 #Applications légales dans la liste
- }
- Dictionnaire
- {
- Les dictionnaires sont marqués de "{ }". Un dictionnaire se compose d'un index (clé) et de sa valeur correspondante.
#!/usr/bin/python
# -*- codage : UTF-8 -*-
dict = {}
dict['one'] = "C'est un "
dict[2] = "C'est deux"
tinydict = {'name' : 'john','code':6734, 'dept' : 'sales'}
print dict['one'] # Afficher la valeur avec la clé 'one'
print dict[2] # Afficher la valeur avec la clé 2
imprimer tinydict # Afficher le dictionnaire complet
imprimer tinydict .keys() # Afficher toutes les clés
print tinydict.values() # Afficher toutes les valeurs
Le résultat de sortie est :
Ceci en est un Ceci est deux {'dept': 'sales', 'code': 6734, 'name': 'john'} ['dept', 'code', 'name'] ['sales', 6734 , 'john ']
}
7. Conversion du type de données Python
| Fonction |
Description |
int( x [ ,base]) |
Convertir x en un entier |
long(x [,base] ) |
Convertir x en un entier long |
float(x) |
Convertir x en flottant |
complexe (réel [,imag]) |
Créer un nombre complexe |
str(x) |
Convertir l'objet x en chaîne |
repr(x ) |
Convertir l'objet x en chaîne d'expression |
eval(str) | est utilisé pour évaluer une expression Python valide dans une chaîne et renvoyer un objet |
tuple(s) |
Convertir les séquences en tuple |
liste(s) |
la séquence s sera convertie en liste |
ensemble(s) |
Convertir en ensemble mutable |
| dict(d)
|
Crée un dictionnaire. d doit être une séquence de tuples (clé, valeur). |
ensemble(s) gelé(s) |
Convertir en ensemble immuable |
chr(x) |
Convertir un entier en caractère |
unichr( x) |
Convertir un entier en caractère Unicode |
ord(x) |
Convertir un caractère en sa valeur entière |
hex(x) |
Convertir un entier en chaîne hexadécimale |
oct(x) |
Convertir un entier en chaîne octale |
8. Les opérateurs arithmétiques de Python
Les opérateurs arithmétiques de Python
| + |
加 - 两个对象相加 |
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 |
Opérateurs de comparaison Python
| 运算符 |
描述 |
实例 |
| == |
等于 - 比较对象是否相等 |
(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。 |
Opérateur d'affectation de Python
| 运算符 | 描述 | 实例 |
|---|
| = | 简单的赋值运算符 | 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 |
Opérateurs au niveau du bit Python
| 算符 | 描述 | 实例 |
|---|
| & | 按位与运算符：参与运算的两个值,如果两个相应位都为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 |
opérateurs logiques python
| 运算符 |
逻辑表达式 |
描述 |
实例 |
| 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 |
Opérateurs membres de Python
| 运算符 |
描述 |
实例 |
| in |
如果在指定的序列中找到值返回 True，否则返回 False。 |
x 在 y 序列中 , 如果 x 在 y 序列中返回 True。 |
| not in |
如果在指定的序列中没有找到值返回 True，否则返回 False。 |
x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。 |
Priorité de python
| ** |
指数 (最高优先级) |
| ~ + - |
按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@) |
| * / % // |
乘，除，取模和取整除 |
| + - |
加法减法 |
| >> << | 右移，左移运算符 |
| & | 位 'AND' |
| ^ | | 位运算符 |
| <= < > >= |
比较运算符 |
| <> == != |
等于运算符 |
| = %= /= //= -= += *= **= |
赋值运算符 |
| is is not |
身份运算符 |
| in not in |
成员运算符 |
| not or and |
逻辑运算符 |
Fonctions mathématiques de Python
| Fonction |
valeur de retour (description) |
| abs(x) |
renvoie la valeur absolue d'un nombre Valeur, telle que abs(-10) renvoie 10 |
| ceil(x) |
renvoie l'entier ascendant du nombre, tel que math.ceil( 4.1) renvoie 5 |
| cmp(x, y) |
Si x < y renvoie -1, si x == y renvoie 0, si x > return 1 |
| exp(x) |
Renvoie le fabs(x) |
Renvoie la valeur absolue du nombre, tel que math.fabs(-10) renvoie 10,0
|
floor(x) |
Renvoie l'entier arrondi du nombre, tel que math.floor(4.9) renvoie 4
|
log(x) |
Par exemple, math.log(math.e ) renvoie 1,0, math.log(100,10) renvoie 2,0 |
log10(x) |
renvoie le logarithme de x en base 10, comme math log10(100) renvoie 2,0
|
. max(x1, x2,...) |
Renvoie la valeur maximale du paramètre donné, qui peut être une séquence.
|
min(x1, x2,...) |
Renvoie la valeur minimale du paramètre donné, qui peut être une séquence.
|
modf(x) |
Renvoie la partie entière et la partie décimale de x Les symboles numériques des deux parties sont les mêmes que x, et la partie entière est. exprimé en type à virgule flottante.
| pow(x, y) |
valeur x**y après opération. |
| round(x [,n]) |
Renvoie la valeur arrondie du nombre à virgule flottante x Si la valeur n est donnée, elle représente le nombre de chiffres. arrondi à la virgule décimale. |
| sqrt(x) |
Renvoie la racine carrée du nombre x Le nombre peut être négatif et le type de retour est un nombre réel Par exemple, math.sqrt. (4) renvoie 2+0j |
Fonction aléatoire Python
Les nombres aléatoires peuvent être utilisés dans les mathématiques, les jeux, la sécurité et d'autres domaines, et sont souvent intégrés dans algorithmes , pour améliorer l’efficacité des algorithmes et améliorer la sécurité du programme.
Python inclut les fonctions de nombres aléatoires suivantes, couramment utilisées :
| 函数 |
描述 |
| 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]范围内。 |
Fonctions trigonométriques de Python
| Numéro |
Description |
|
| acos(x) |
Renvoie l'arc cosinus de x en radians. |
|
| asin(x) |
Renvoie l'arc sinus de x en radians. |
|
| atan(x) |
Renvoie l'arc tangent de x en radians. |
|
| atan2(y, x) |
Renvoie l'arctangente des valeurs de coordonnées X et Y données. |
|
| cos(x) |
Renvoie le cosinus de x en radians. |
|
| hypot(x, y) |
Renvoie la norme euclidienne sqrt(x*x + y*y) . |
|
| sin(x) |
Renvoie le sinus de x en radians. |
|
| tan(x) |
Renvoie la tangente de x en radians. |
|
| degrés(x) |
Convertir les radians en angles, tels que les degrés (math.pi/2), renvoyer 90,0 |
|
| radians(x) |
Convertir les angles en radians |
|
Fonctions de chaîne intégrées de Python
| Méthodes |
Description |
string.capitalize() |
Mettre la première chaîne de caractères en majuscules |
string.center(width) |
renvoie une chaîne originale centrée et complétée par des espaces Nouvelle chaîne à longueur largeur |
string.count(str, beg=0, end=len(string)) |
Renvoie le nombre de fois que str apparaît dans la chaîne. Si beg ou end est spécifié, renvoie le nombre de fois que str apparaît dans la plage spécifiée
|
string. .decode(encoding='UTF-8', erreurs='strict') |
Décoder la chaîne dans le format d'encodage spécifié par encoding Si une erreur se produit, une exception ValueError sera signalée. par défaut, sauf si les erreurs spécifient « ignorer » ou « remplacer » |
string.encode(encoding='UTF-8', erreurs='strict') |
L'encodage spécifié par encoding Formater la chaîne d'encodage, si une erreur se produit, une exception ValueError sera signalée par défaut, sauf si les erreurs spécifient « ignorer » ou « remplacer » |
chaîne .endswith( obj, beg=0, end=len(string)) |
Vérifiez si la chaîne se termine par obj. Si beg ou end est spécifié, vérifiez si le spécifié. la plage se termine par obj. End, si oui, renvoie True, sinon renvoie False. |
string.expandtabs(tabsize=8) |
Convertissez le symbole de tabulation dans la chaîne en espaces. Le nombre d'espaces par défaut pour le symbole de tabulation est 8. |
string.find(str, beg=0, end=len(string)) |
Vérifiez si str est inclus dans la chaîne. Si beg et end spécifient la plage, vérifiez si elle est incluse dans la plage spécifiée. Si c'est le cas, renvoyez la valeur de l'index de départ, sinon renvoyez -1
|
<.>
string.index(str, beg=0, end=len(string)) |
Le même que le Méthode find(), uniquement. Cependant, si str n'est pas dans la chaîne, une exception sera signalée .
|
string.isalnum() |
Renvoie Renvoyer True, sinon renvoyer False
|
| string.isalpha()
|
Si la chaîne en a au moins un Les caractères et tous les caractères sont des lettres renvoient True, sinon renvoie False
|
| string.isdecimal()
| Renvoie True si la chaîne ne contient que des chiffres décimaux, sinon renvoie False.
|
| string.isdigit()
| Renvoie True si la chaîne ne contient que des nombres, sinon renvoie False.
|
| string.islower()
|
Renvoie True si la chaîne contient au moins un caractère sensible à la casse et que tous ces caractères (sensibles à la casse) sont en minuscules, sinon False
|
| string.isnumeric()
|
Si la chaîne ne contient que des caractères numériques, renvoie True, sinon renvoie False |
|
string.isspace() |
Si la chaîne ne contient que des espaces, renvoyez True, sinon renvoyez False. |
|
string.istitle() |
Renvoie True si la chaîne est intitulée (voir title()), sinon renvoie False |
string.isupper( ) |
Renvoie True si la chaîne contient au moins un caractère sensible à la casse et que tous ces caractères (sensibles à la casse) sont en majuscules, sinon False |
string.join(seq) |
Utilisez une chaîne comme séparateur pour joindre tous les éléments de la séquence (représentation de chaîne) fusionnés dans une nouvelle chaîne |
string.ljust(width) |
renvoie Une nouvelle chaîne qui aligne la chaîne d'origine à gauche et la remplit d'espaces pour longueur largeur |
string.lower() |
Convertissez tous les caractères majuscules de la chaîne en minuscules. |
string.lstrip() |
Tronquer l'espace à gauche de la chaîne
|
string.maketrans(intab, outtab]) |
La méthode maketrans() est utilisée pour créer une table de conversion pour le mappage de caractères. Pour la méthode d'appel la plus simple qui accepte deux paramètres, le premier paramètre est une chaîne représentant le caractère qui doit être converti, et le deuxième paramètre est également une chaîne représentant le caractère. cible de conversion. |
max(str) |
Renvoie la plus grande lettre de la chaîne str. |
min(str) |
Renvoie la plus petite lettre de la chaîne str. |
string.partition(str) |
Un peu comme find() et split ( ), à partir de la première position où str apparaît, divisez la chaîne string en un tuple à 3 éléments (string_pre_str, str, string_post_str, alors string_pre_str == string. ). |
string.replace(str1, str2, num=string.count(str1)) |
Remplacez str1 dans la chaîne par str2 Si num est spécifié, le remplacement ne dépassera pas num fois |
string.rfind(str, beg=0,end=. len(string) ) |
est similaire à la fonction find(), mais elle commence la recherche à partir de la droite. |
string .rindex(str, beg=0,end=len(string)) |
Similaire à index(), mais en partant de la droite. |
string.rjust(width) |
Renvoie une nouvelle chaîne avec la chaîne d'origine alignée à droite et complétée par des espaces jusqu'à la longueur largeur |
string.rpartition(str) |
Similaire à la fonction partition(), mais en commençant par la droite. |
string.rstrip() |
Supprimez les espaces à la fin de la chaîne. |
string.split(str="", num=string.count(str)) |
Tranchez la chaîne avec str comme délimiteur. Si num a une valeur spécifiée, seules les sous-chaînes num sont séparées |
string.splitlines(num=string.count( ' n')) |
Délimité par lignes, renvoie une liste contenant chaque ligne en tant qu'élément Si num est spécifié, seules nombre de lignes seront découpées. |
string.startswith(obj, beg=0,end=len(string)) |
Vérifiez si la chaîne commence par obj, si c'est le cas, renvoie True , sinon il renvoie False. Si le début et la fin spécifient des valeurs, vérifiez dans la plage spécifiée. |
string.strip([obj]) |
Exécuter lstrip() et rstrip() sur string |
string.swapcase() |
Cas inversé dans la chaîne |
string.title() |
Renvoie une chaîne "intitulé", c'est-à-dire que tous les mots commencent par des lettres majuscules et les lettres restantes sont en minuscules (voir istitle()) |
string.translate(str, del="") |
Convertir la chaîne selon le tableau donné par str (contenant 256 caractères) Caractères ,
mettre les caractères à filtrer dans le paramètre del
|
string.upper() |
Convertir les lettres minuscules de la chaîne en majuscules
|
string.zfill(width) |
La longueur de retour est la chaîne de largeur, la chaîne de chaîne d'origine est alignée à droite, complétée devant par 0 |
string.isdecimal() |
La méthode isdecimal() vérifie si une chaîne contient uniquement des caractères décimaux. Cette méthode n'existe que pour les objets Unicode. |
Fonction Liste de Python
| 序号 |
函数 |
| 1 |
cmp(list1, list2)
比较两个列表的元素 |
| 2 |
len(list)
列表元素个数 |
| 3 |
max(list)
返回列表元素最大值 |
| 4 |
min(list)
返回列表元素最小值 |
| 5 |
list(seq)
将元组转换为列表 |
Python contient les méthodes suivantes :
| 序号 |
方法 |
| 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])
对原列表进行排序 |
Fonctions intégrées des tuples Python
Les tuples Python contiennent les fonctions intégrées suivantes
| 序号 |
方法及描述 |
| 1 |
cmp(tuple1, tuple2)
比较两个元组元素。 |
| 2 |
len(tuple)
计算元组元素个数。 |
| 3 |
max(tuple)
返回元组中元素最大值。 |
| 4 |
min(tuple)
返回元组中元素最小值。 |
| 5 |
tuple(seq)
将列表转换为元组。 |
Fonctions et méthodes intégrées du dictionnaire
Le dictionnaire Python contient les fonctions intégrées suivantes :
| 序号 |
函数及描述 |
| 1 |
cmp(dict1, dict2)
比较两个字典元素。 |
| 2 |
len(dict)
计算字典元素个数，即键的总数。 |
| 3 |
str(dict)
输出字典可打印的字符串表示。 |
| 4 |
type(variable)
返回输入的变量类型，如果变量是字典就返回字典类型。 |
Le dictionnaire Python contient les méthodes intégrées suivantes :
| 序号 |
函数及描述 |
| 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
Copier après la connexion
以上实例输出结果：
当前时间戳为: 1459994552.51
Copier après la connexion
时间戳单位最适于做日期运算。但是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是决定是否为夏令时的旗帜 |
Ce qui précède est le tuple struct_time. Cette structure possède les propriétés suivantes :
| 序号 |
属性 |
值 |
| 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
Copier après la connexion
以上实例输出结果：
本地时间为 : 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)
Copier après la connexion
获取格式化的时间
你可以根据需求选取各种格式，但是最简单的获取可读的时间模式的函数是asctime():
#!/usr/bin/python# -*- coding: UTF-8 -*-import time
localtime = time.asctime( time.localtime(time.time()) )print "本地时间为 :", localtime
Copier après la connexion
以上实例输出结果：
本地时间为 : Thu Apr 7 10:05:21 2016
Copier après la connexion
格式化日期
我们可以使用 time 模块的 strftime 方法来格式化日期，：
time.strftime(format[, t])
Copier après la connexion
#!/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"))Copier après la connexion
以上实例输出结果：
2016-04-07 10:25:09Thu Apr 07 10:25:09 20161459175064.0
Copier après la connexion
python中时间日期格式化符号：
获取某月日历
Calendar模块有很广泛的方法用来处理年历和月历，例如打印某月的月历：
#!/usr/bin/python# -*- coding: UTF-8 -*-import calendar
cal = calendar.month(2016, 1)print "以下输出2016年1月份的日历:"print cal;
Copier après la connexion
以上实例输出结果：
以下输出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
Copier après la connexion
Time 模块
Time 模块包含了以下内置函数，既有时间处理相的，也有转换时间格式的：
| Numéro de série |
Fonction et description |
| 1 |
time.altzone
Retour à Greenway Le décalage en secondes pour le fuseau horaire d'été ouest. Des valeurs négatives sont renvoyées si la zone est à l'est de Greenwich (comme l'Europe occidentale, y compris le Royaume-Uni). Disponible uniquement dans les régions où l’heure d’été est activée. |
| 2 |
time.asctime([tupletime])
Accepte un tuple temporel et renvoie une forme lisible de "Tue Dec 11 18:07: 14 2008 " (mardi 11 décembre 2008 18:07:14) est une chaîne de 24 caractères. |
| 3 |
time.clock()
Renvoie le temps CPU actuel en secondes sous forme de nombre à virgule flottante. Il est utilisé pour mesurer la consommation de temps de différents programmes et est plus utile que time.time(). |
| 4 |
time.ctime([secs])
La fonction est équivalente à asctime(localtime(secs)). équivalent à asctime() |
| 5 |
time.gmtime([secs])
Reçoit le timeout (le nombre de secondes à virgule flottante écoulées depuis l'époque 1970 ) et renvoie l'heure astronomique de Greenwich Le tuple temporel sous t. Remarque : t.tm_isdst est toujours 0 |
| 6 |
time.localtime([secs])
heure de réception (secondes à virgule flottante écoulées après le numéro d'époque 1970) et renvoie le tuple temporel t en heure locale (t.tm_isdst peut être 0 ou 1, selon que l'heure locale est l'heure d'été). |
| 7 |
time.mktime(tupletime)
Accepte un tuple temporel et renvoie l'heure (le nombre de secondes à virgule flottante écoulées depuis l'époque 1970). |
| 8 |
time.sleep(secs)
Différer l'exécution du thread appelant, secs fait référence au nombre de secondes. |
| 9 |
time.strftime(fmt[,tupletime])
Reçoit un tuple d'heure et renvoie l'heure locale sous forme de chaîne lisible dans un format déterminé par fmt. |
| 10 |
time.strptime(str,fmt='%a %b %d %H:%M:%S %Y')
selon to Le format de fmt analyse une chaîne temporelle en un tuple temporel. |
| 11 |
time.time( )
Renvoie l'horodatage de l'heure actuelle (le nombre de secondes à virgule flottante écoulées depuis l'époque 1970). |
| 12 |
time.tzset()
Réinitialisez les paramètres liés au temps en fonction de la variable d'environnement TZ. |
Le module Time contient les 2 attributs très importants suivants :
| Numéro de série |
Attributs et description |
| 序号 |
属性及描述 |
| 1 |
time.timezone
属性time.timezone是当地时区（未启动夏令时）距离格林威治的偏移秒数（>0，美洲;<=0大部分欧洲，亚洲，非洲）。 |
| 2 | time.tzname
属性time.tzname包含一对根据情况的不同而不同的字符串，分别是带夏令时的本地时区名称，和不带的。 |
<🎜><🎜>1<🎜>< 🎜>time.timezone<🎜>La propriété time.timezone est le décalage du fuseau horaire local (sans heure d'été) par rapport à Greenwich en secondes (>0, Amériques;<=0 pour la plupart des pays d'Europe , Asie, Afrique). 2time.tznameL'attribut time.tzname contient une paire de chaînes qui varient respectivement en fonction de la situation Il s'agit du nom du fuseau horaire local avec et sans l'heure d'été.
Module Calendrier
Les fonctions de ce module sont toutes liées au calendrier, comme l'impression du calendrier des personnages d'un certain mois.
Le lundi est le premier jour par défaut de la semaine et le dimanche est le dernier jour par défaut. Pour modifier les paramètres, vous devez appeler la fonction calendrier.setfirstweekday(). Le module contient les fonctions intégrées suivantes :
| Numéro de série |
Fonction et description |
| 1 |
calendrier.calendrier(année , w=2,l=1,c=6)
Renvoie un calendrier annuel au format chaîne multiligne, avec 3 mois par ligne, et l'intervalle est c. L'intervalle de largeur quotidien est de w caractères. La longueur de chaque ligne est de 21* W+18+2* C. l est le nombre de lignes par semaine. |
| 2 |
calendar.firstweekday( )
Renvoie le paramètre actuel du jour de début hebdomadaire. Par défaut, 0 est renvoyé lors du premier chargement du module caendar, c'est-à-dire lundi. |
| 3 |
calendar.isleap(year)
renvoie True si c'est une année bissextile, sinon c'est faux. |
| 4 |
calendar.leapdays(y1,y2)
Renvoie le nombre total d'années bissextiles entre Y1 et Y2. |
| 5 |
calendar.month(year,month,w=2,l=1)
Renvoie une chaîne multiligne Le format du calendrier est l'année et le mois, avec deux lignes de titres et une ligne pour chaque semaine. L'intervalle de largeur quotidien est de w caractères. La longueur de chaque ligne est de 7* w+6. l est le nombre de lignes par semaine. |
| 6 |
calendar.monthcalendar(year,month)
Renvoie une liste imbriquée d'entiers à un seul niveau. Chaque sous-liste contient un entier représentant une semaine. Les dates en dehors de l'année, du mois et du mois sont toutes définies sur 0 ; les jours compris dans la plage sont représentés par le jour du mois, à partir de 1. |
| 7 |
calendar.monthrange(year,month)
Renvoie deux entiers. Le premier est le code de date du jour de la semaine du mois et le second est le code de jour du mois. Les jours vont de 0 (lundi) à 6 (dimanche) ; les mois vont de 1 à 12. |
| 8 |
calendar.prcal(year,w=2,l=1,c=6)
est équivalent à imprimer calendrier .calendar(année,w,l,c). |
| 9 |
calendar.prmonth(année,mois,w=2,l=1 )
Équivalent à imprimer calendrier.calendar(année, w, l, c). |
| 10 |
calendar.setfirstweekday(weekday)
Définissez le code du jour de début de la semaine. 0 (lundi) à 6 (dimanche). |
| 11 |
calendar.timegm(tupletime)
L'opposé de time.gmtime : accepte une forme de tuple temporel et renvoie l'heure L'heure de la journée (le nombre de secondes à virgule flottante écoulées depuis l'époque 1970). |
| 12 |
calendar.weekday(year,month,day)
Renvoie le code de date pour la date donnée. 0 (lundi) à 6 (dimanche). Les mois vont du 1 (janvier) au 12 (décembre). |
Autres modules et fonctions associés
En Python, les autres modules de traitement des dates et des heures sont :
-
module datetime
module pytz
module dateutil
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!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
