Cet article vous apporte des connaissances pertinentes sur Python Il organise principalement le contenu pertinent pour démarrer avec Python, y compris les identifiants, les variables, les instructions conditionnelles, etc. . Utile.
【Recommandations associées : Tutoriel vidéo Python3】
En Python, tous les identifiants peuvent inclure l'anglais (sensible à la casse), des chiffres et des traits de soulignement (_), mais ne peuvent pas commencer par un chiffre.
Commencer par single underscore signifie que _foo ne peut pas accéder directement aux attributs de classe de . Il doit être accessible via l'interface fournie par la classe et ne peut pas être importé en utilisant from xxx import *.
__foo commençant par double underscore représente le membre privé de la classe,
__foo__ commençant et se terminant par double underscore représente l'identifiant spécial spécifique à la méthode en Python, comme __init__() représente le constructeur de classe .
Les blocs de code Python doivent utiliser le même nombre de nombre d'espaces d'indentation de première ligne
En Python, commentaires sur une seule ligne commencent par #.
Les commentaires multilignesen Python utilisent trois guillemets simples ("'') ou trois guillemets doubles (""").
# Python语句中一般以新行作为语句的结束符。但是我们可以使用【斜杠（ \）】将一行的语句分为多行显示，
# 语句中包含 [], {} 或 () 括号就不需要使用多行连接符。
# Python可以在同一行中使用多条语句，语句之间使用【分号(;)】分割
total = item_one + \
item_two + \
item_three
days = ['Monday', 'Tuesday', 'Wednesday',
'Thursday', 'Friday']
# Python可以在同一行中使用多条语句，语句之间使用【分号(;)】分割。
import sys; x = 'runoob'; sys.stdout.write(x + '\n')
# Python 可以使用【引号( ' )、双引号( " )、三引号( ''' 或 """ ) 】来表示字符串
word = 'word'
sentence = "这是一个句子。"
paragraph = """这是一个段落。
包含了多个语句"""
# print 默认输出是换行的，如果要实现【不换行需要在变量末尾加上逗号】 。
print x,ychaînes, tuples et nombres sont des objets immuables, les variables globales doivent être des variables d'initialisation ou définies avec self dans la fonction while list ; , dict, etc. sont des objets qui peuvent être modifiés, et les fonctions internes peuvent utiliser directement des variables locales dans la fonction
counter = 100 # 赋值整型变量
miles = 1000.0 # 浮点型
name = "John" # 字符串
二进制转换：
int('10',2)
> 2
bin(10)
> '0b1010'
bin(10)[2:]
ord(c) # c为字符
# 返回值：对应的十进制整数（ASCll数值）
int(c) # c为字符，转化为对应的数字
float('-inf') # 最小值
-inf
a = b = c = 1
a, b, c = 1, 2, "john"
all() # 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。
# 从左到右索引默认【0开始的】，最大范围是字符串【长度少1】
# 从右到左索引默认【-1开始的】，最大范围是【字符串开头】
# 第三个参数，参数作用是【截取的步长】
s = "a1a2···an" # n>=0
向上取整：math.ceil()
向下取整：math.floor()、整除"//"
四舍五入：round()——奇数向远离0取整，偶数去尾取整；或言之：奇数进位，偶数去尾
向0取整：int()tinylist = [123, 'john']
print list[0] # 输出列表的第一个元素
print list[1:3] # 输出第二个至第三个元素
print list[2:] # 输出从第三个开始至列表末尾的所有元素
# 二维数组
num_list = [ [0] * 5 for i in range(2)]
dp = [[1]*n] + [[1]+[0] * (n-1) for _ in range(m-1)]
clone_node.neighbors = [self.cloneGraph(n) for n in node.neighbors]
# 加号 + 是列表连接运算符，星号 * 是重复操作
print tinylist * 2 # 输出列表两次
print list + tinylist # 打印组合的列表
list.append('Google') # 使用 append() 添加元素
del list[2] # 可以使用 del 语句来删除列表的元素
list.pop(3) # 指定pop参数，将会删除该位置的元素；无参数时默认删除最后一个元素
list.append(sublist) # 引用传递
list.append([]+sublist) # 值传递
list.append(list(path))
len([1, 2, 3]) 3 #长度
[1, 2, 3] + [4, 5, 6] [1, 2, 3, 4, 5, 6] #组合
['Hi!'] * 4 ['Hi!', 'Hi!', 'Hi!', 'Hi!'] #重复
3 in [1, 2, 3] True #元素是否存在于列表中
for x in [1, 2, 3]: print x, 1 2 3 #迭代
[::-1] # 数组反转
max(list) # 求list的最大值
sum(sp[i] for i in range(n)) #求和
sum(s in jewelsSet for s in stones)
nums.sort() # 排序
score.sort(reverse=True)
list有一个sort方法，list.sort()将list进行排序，返回None
sort(*,key = None,reverse = False)
key是一个函数，这个函数的作用是从list的每个元素中提取用于当作排序依据的属性
默认是从小到大，即reserve为False的时候，如果reserve为True，排列顺序就是从大到小
def f(item):
return item[1]
list.sort(key = f)
list.sort(key = lambda item:item[0])
sorted(iterable,*,key=None,reverse=False) # 默认正序排列
sorted(dict.items(),key=lambda item:item[0])
res = sorted(hash,key = lambda word:(-hash[word],word)) # 第一个参数 -hash[word] 即单词出现次数的相反数
# 当词频相同时，用第二个参数 word 进行排序，即字母正序排列
列表解析 List Comprehensions
表达式：[expression for iter_val in iterable if cond_expr]
[expression]：最后执行的结果
[for iter_val in iterable]：这个可以是一个多层循环
[if cond_expr]：两个for间是不能有判断语句的，判断语句只能在最后；顺序不定，默认是左到右。
print[(x,y)for x in [1,2]for y in [3,4]]
for (k1, v1), (k2, v2) in zip(dict_one, dict_two): # 遍历两个list或者dict
for item in product([1,2],[10,20]): # 对矩阵做笛卡尔积
print(item)
for i, j in product(range(m), range(n)):
neighbors = [(1,0), (1,-1), (0,-1), (-1,-1), (-1,0), (-1,1), (0,1), (1,1)]
for neighbor in neighbors:
r = (row + neighbor[0])
c = (col + neighbor[1])
for u,v in neighbors:
s = [1, 2, 3, 4, 5]
# 从指定索引1开始
for index, value in enumerate(s, 1):
list(str(n)) # int转化为字符串，转化为list
next(word for word,f in freq.items() if f==maxFreq) # next()取list第一个值
map(max, grid) # 求每行的最大值
map(max, zip(*grid)) # 求每列的最大值
strs = map(str,nums) # 转换为list(str)
r1,m1 = map(int, num1[:-1].split('+')) # list(str)转化为list(int)
list(map(list,numSet))
>>> a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b) # 返回一个对象
>>> zipped
<zip object at 0x103abc288>
>>> list(zipped) # list() 转换为列表
[(1, 4), (2, 5), (3, 6)]
>>> list(zip(a,c)) # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> a1, a2 = zip(*zip(a,b)) # 与 zip 相反，zip(*) 可理解为解压，返回二维矩阵式
>>> list(a1)
[1, 2, 3]
>>> list(a2)
[4, 5, 6]# 元组用 () 标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。 tinytuple = (123, 'john')
# 字典用"{ }"标识。字典由索引(key)和它对应的值value组成。
dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"
# 值可以取任何数据类型，但键必须是不可变的，如字符串，数字或 元组 。 用列表就不行
dict[tuple(count)]
# 以列表返回字典中的所有值
dict.values()
list(dict.values())
for key in dict:
print (key)
tinydict = {'name': 'runoob','code':6734, 'dept': 'sales'}
print dict['one'] # 输出键为'one' 的值
print dict[2] # 输出键为 2 的值
print tinydict # 输出完整的字典
print tinydict.keys() # 输出所有键
print tinydict.values() # 输出所有值
maxFreq = max(freq.values()) # 求value的最大值
tinydict['Age'] = 8 # 更新
tinydict['School'] = "RUNOOB" # 添加
del tinydict['Name'] # 删除键是'Name'的条目
tinydict.clear() # 清空字典所有条目
del tinydict # 删除字典
defaultdict(list) defaultdict(int) # defaultdict类的初始化函数接受一个类型作为参数，当所访问的键不存在的时候，可以实例化一个值作为默认值：
count.get(c, 0) # 默认值为0
items():返回所有（key，value）元组的数组,类似于‘列表’
[s for s, c in cnt.items() if c == maxCnt] # 遍历dict
dict排序
sorted(dict.items(),key=lambda item:item[0])
items = [(-val, key) for key, val in count.items()] # 变更为tuple
for val, key in sorted(items): # 遍历排序后的tupleparame = {value01,value02,...}
或者
set(value)
s.add( x )
s.update( x ) # 参数可以是列表，元组，字典等
s.remove( x )
s.discard( x )
len(s)
s.clear()
x in s
for key in set:
print (key)/ Division - x divisé par y
% Modulo - Renvoie le reste de la division
** Puissance - Renvoie x élevé à la puissance y
// Division - Renvoie la partie entière du quotient (arrondie à l'inférieur)
et x et y Booléen" et "- Si x est Faux, x et y renvoie Faux, sinon il renvoie le calcul valeur de y
or x ou y booléen "ou" - si x est différent de zéro, il renvoie la valeur calculée de x, sinon il renvoie y La valeur calculée de
not not x booléen "not" - si x est vrai, renvoie Faux
est consiste à déterminer si les deux identifiants sont référencés à partir d'un objet
n'est pas ne consiste pas à déterminer si les deux identifiants font référence à des objets différents
La différence entre est et =. = : est utilisé pour déterminer si les objets référencés par deux variables sont identiques (le même espace mémoire), == est utilisé pour déterminer si la valeur de la variable de référence est égale
if num == 3: # 判断num的值
print 'boss' elif num == 2:
print 'user'elif num == 1:
print 'worker'elif num < 0: # 值小于零时输出
print 'error'else:
print 'roadman' # 条件均不成立时输出i = 1
while i < 10:
i += 1
if i%2 > 0: # 非双数时跳过输出
continue
print i # 输出双数2、4、6、8、10
i = 1
while 1: # 循环条件为1必定成立
print i # 输出1~10
i += 1
if i > 10: # 当i大于10时跳出循环
break
flag = 1
while (flag): print 'Given flag is really true!'
fruits = ['banana', 'apple', 'mango']
for fruit in fruits: # 第二个实例
print ('当前水果: %s'% fruit)
fruits = ['banana', 'apple', 'mango']
for index in range(len(fruits)):
print ('当前水果 : %s' % fruits[index])
for i in reversed(range(length - 1)): # 逆序
for letter in 'Python': # 第一个实例
if letter == 'h':
break
print '当前字母 :', letter
for i, ch in enumerate(s):
if frequency[ch] == 1:
return i
diff = [(a,b) for a,b in zip(s,goal) if a!=b]+ 字符串连接
>>>a + b
'HelloPython'
* 重复输出字符串
>>>a * 2
'HelloHello'
[] 通过索引获取字符串中字符
>>>a[1]
'e'
[ : ] 截取字符串中的一部分
>>>a[1:4]
'ell'
in 成员运算符 - 如果字符串中包含给定的字符返回 True
>>>"H" in a
True
not in 成员运算符 - 如果字符串中不包含给定的字符返回 True
>>>"M" not in a
True
r/R 原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母"r"（可以大小写）以外，与普通字符串有着几乎完全相同的语法。
>>>print r'\n'
\n
>>> print R'\n'
\n
strs = 'abcd'
for ch in strs:
print(ch)
strs = 'abcd'
for index in range(len(strs)):
print(strs[index], end=' ')
res += 'a'*3 # 'aaa'
s.split(" ") # 将字符串分割成单词列表
" ".join(list) # 将单词列表转换为字符串，以空格分隔
f'{bulls}A{cows}B' # {}计算格式化
a = list(str(n)) # int转成list
a[i-1] = str(int(a[i-1]) - 1) # 操作字符
int("".join(a)) # list转化为int
isdigit # 函数判断是否数字
isalpha # 判断是否字母print "My name is %s and weight is %d kg!" % ('Zara', 21)
%s 格式化字符串
%d 格式化整数
%f 格式化浮点数字，可指定小数点后的精度允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符 >>> hi = '''hi there''' >>> hi # repr() 'hi\nthere' >>> print hi # str() hi there
string.count(str, beg=0, end=len(string)) # 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 string.endswith(obj, beg=0, end=len(string)) # 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False. string.find(str, beg=0, end=len(string)) # 检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1 string.format() # 格式化字符串 string.index(str, beg=0, end=len(string)) # 跟find()方法一样，只不过如果str不在 string中会报一个异常. string.join(seq) # 以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 string.replace(str1, str2, num=string.count(str1)) # 把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次. string.split(str="", num=string.count(str)) # 以 str 为分隔符切片 string，如果 num 有指定值，则仅分隔 num+1 个子字符串
chaînes, tuples et nombres sont des objets immuables, tandis que list, dict, etc. sont des objets modifiables.
Type immuable : la variable reçoit a=5 puis a=10. Ici, un nouvel objet de valeur int 10 est effectivement généré, et a est pointé vers lui, tandis que 5 est ignoré. , ce qui équivaut à une nouvelle génération. Type de variable : attribuer la variable la=[1,2,3,4] puis attribuer la[2]=5 modifie la valeur du troisième élément de la liste la La elle-même n'est pas déplacée, mais n'est qu'une partie interne. de celui-ci. La valeur a été modifiée.
types d'objets immuables tels que les nombres, les caractères ou les tuples appartiennent au passage de valeur, tandis que les types d'objets immuables tels que dict ou list list appartiennent au passage de référence. Si vous souhaitez modifier la nouvelle affectation sans changer l'objet d'origine, vous devez utiliser le module de copie de python, qui est une copie d'objet.
copy.copy est une copie superficielle et copie la liste de premier niveau, tandis que copy.deepcopy est une copie profonde et copie en profondeur tous les sous-éléments de la liste.
#可写函数说明 def printinfo( name, age = 35 ): "打印任何传入的字符串" print "Name: ", name print "Age ", age return #调用printinfo函数 printinfo( age=50, name="miki" ) printinfo( name="miki" ) # 可写函数说明 def printinfo( arg1, *vartuple ): "打印任何传入的参数" print "输出: " print arg1 for var in vartuple: print var return # 调用printinfo 函数 printinfo( 10 ) printinfo( 70, 60, 50 ) import copy l1 = [[1, 2], 3] l2 = copy.copy(l1) l3 = copy.deepcopy(l1) l2.append(4) l2[0].append(5) l3[0].append(6) l1 = [[1, 2, 5], 3] l2 = [[1, 2, 5], 3, 4] l3 = [[1, 2, 6], 3]
# 可写函数说明 sum = lambda arg1, arg2: arg1 + arg2 # 调用sum函数 print "相加后的值为 : ", sum( 10, 20 ) print "相加后的值为 : ", sum( 20, 20 )
import support from fib import fibonacci from math import *
Chemin de recherche 1. Répertoire actuel
2. S'il ne se trouve pas dans le répertoire courant, Python recherche dans chaque répertoire sous la variable shell PYTHONPATH.
3. Si aucun des deux n'est trouvé, Python vérifiera le chemin par défaut. Sous UNIX, le chemin par défaut est généralement /usr/local/lib/python/.
Le chemin de recherche du module est stocké dans la variable sys.path du module système. Les variables contiennent le répertoire courant, PYTHONPATH et le répertoire par défaut déterminé par le processus d'installation.
Python中的包
包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的 Python 的应用环境。
简单来说，包就是文件夹，但该文件夹下必须存在 __init__.py 文件, 该文件的内容可以为空。 __init__.py 用于标识当前文件夹是一个包。
考虑一个在 package_runoob 目录下的 runoob1.py、runoob2.py、 __init__.py 文件，test.py 为测试调用包的代码，目录结构如下:
test.py
package_runoob
|-- __init__.py
|-- runoob1.py
|-- runoob2.py
# 导入 Phone 包from package_runoob.runoob1 import runoob1from package_runoob.runoob2 import runoob2 runoob1()runoob2()
str = input("请输入：")
print "你输入的内容是: ", str
fo = open("foo.txt", "w")
print "文件名: ", fo.name
print "是否已关闭 : ", fo.closed
print "访问模式 : ", fo.mode
print "末尾是否强制加空格 : ", fo.softspace
# 打开一个文件
fo = open("foo.txt", "w")
str = fo.read(10)
fo.write( "www.runoob.com!\nVery good site!\n")
# 关闭打开的文件
fo.close()import os
os.rename( "test1.txt", "test2.txt" )
os.remove("test2.txt")
os.mkdir("test")
# 将当前目录改为"/home/newdir"
os.chdir("/home/newdir")
# 给出当前的目录
print os.getcwd()
# 删除”/tmp/test”目录
os.rmdir( "/tmp/test" )try:
正常的操作
......................
except:
发生异常，执行这块代码
......................
else:
如果没有异常执行这块代码
try:
fh = open("testfile", "w")
fh.write("这是一个测试文件，用于测试异常!!")
except IOError:
print "Error: 没有找到文件或读取文件失败"
else:
print "内容写入文件成功"
fh.close()
try-finally 语句无论是否发生异常都将执行最后的代码。
try:
<语句>
finally:
<语句> #退出try时总会执行
raise
try:
fh = open("testfile", "w")
try:
fh.write("这是一个测试文件，用于测试异常!!")
finally:
print "关闭文件"
fh.close()
except IOError:
print "Error: 没有找到文件或读取文件失败"class Employee:
'所有员工的基类'
empCount = 0
def __init__(self, name, salary):
self.name = name
self.salary = salary
Employee.empCount += 1
def displayCount(self):
print "Total Employee %d" % Employee.empCount
def displayEmployee(self):
print "Name : ", self.name, ", Salary: ", self.salary
"创建 Employee 类的第一个对象"
emp1 = Employee("Zara", 2000)
"创建 Employee 类的第二个对象"
emp2 = Employee("Manni", 5000)
emp1.displayEmployee()
emp2.displayEmployee()
print "Total Employee %d" % Employee.empCountempCount 变量是一个类变量，它的值将在这个类的所有实例之间共享。你可以在内部类或外部类使用 Employee.empCount 访问。
第一种方法__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法
self 代表类的实例，self 在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。
class A: # 定义类 A ..... class B: # 定义类 B ..... class C(A, B): # 继承类 A 和 B .....
class Parent: # 定义父类 def myMethod(self): print '调用父类方法' class Child(Parent): # 定义子类 def myMethod(self): print '调用子类方法'
class Parent: # 定义父类 def myMethod(self): print '调用父类方法' class Child(Parent): # 定义子类 def myMethod(self): print '调用子类方法'
类的私有属性
__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。
类的方法
在类的内部，使用 def 关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数 self,且为第一个参数
类的私有方法
__private_method：两个下划线开头，声明该方法为私有方法，不能在类的外部调用。在类的内部调用 self.__private_methods
单下划线、双下划线、头尾双下划线说明：
__foo__: 定义的是特殊方法，一般是系统定义名字 ，类似 __init__() 之类的。
_foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import *
__foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。
【相关推荐：Python3视频教程 】
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)
