1. Opération d'E/S :
open(name[,mode]) est équivalent à file(name[,mode])
Description du mode :
r ouvre un fichier en lecture seule, qui doit exister.
r+ ouvre un fichier qui peut être lu et écrit. Le fichier doit exister.
w ouvre un fichier en écriture seule. Si le fichier existe, la longueur du fichier est ramenée à 0, c'est-à-dire que le contenu du fichier disparaîtra. Si le fichier n'existe pas, créez le fichier.
w+ ouvre un fichier lisible et inscriptible. Si le fichier existe, la longueur du fichier sera remise à zéro, c'est-à-dire que le contenu du fichier disparaîtra. Si le fichier n'existe pas, créez le fichier.
a Ouvrez un fichier en écriture seule en mode ajout. Si le fichier n'existe pas, le fichier sera créé. Si le fichier existe, les données écrites seront ajoutées à la fin du fichier, c'est-à-dire que le contenu original du fichier sera conservé.
a+ Ouvrir un fichier en lecture-écriture en mode ajout. Si le fichier n'existe pas, le fichier sera créé. Si le fichier existe, les données écrites seront ajoutées à la fin du fichier, c'est-à-dire que le contenu original du fichier sera conservé.
Les chaînes morphologiques ci-dessus peuvent être ajoutées avec un caractère b, tel que rb, w+b ou ab+ et d'autres combinaisons. Le caractère b est ajouté pour indiquer à la bibliothèque de fonctions que le fichier à ouvrir est un fichier binaire, pas un. fichier texte brut. Cependant, dans les systèmes POSIX, notamment Linux, ce caractère sera ignoré.
In [1]: f = open('/tmp/test','w'） In [2]: f.write('okokokok') In [3]: f.close()
Affichage comme suit sous Linux :
#cat /tmp/test okokokok
peut également interagir avec en python Affichez-le dans l'interpréteur de formule, comme indiqué ci-dessous :
In [4]: f = open('/tmp/test','r') In [5]: f.read() Out[5]: 'okokokok' In [6]: f.close()
Opération en mode ajout :
In [7]: f = open('/tmp/test','a') In [8]: f.write('hello') In [9]: f.close() In [10]: f = open('/tmp/test','r') In [11]: f.read() Out[11]: 'okokokokhello' In [12]: f.close()
Modes d'utilisation combinés :
In [13]: f = open('/tmp/test','r+') In [14]: f = open('/tmp/test','w+') In [15]: f = open('/tmp/test','a+')
Après avoir ouvert le fichier (vous pouvez sélectionner le mode), vous pouvez ensuite utiliser le fichier. Voici quelques méthodes couramment utilisées. :
In [21]: f = open('/tmp/test','a+') In [20]: f. f.close f.fileno f.name f.readinto f.softspace f.writelines f.closed f.flush f.newlines f.readline f.tell f.xreadlines f.encoding f.isatty f.next f.readlines f.truncate f.errors f.mode f.read f.seek f.write
Vous pouvez utiliser la complétion par tabulation pour l'afficher dans ipython :
read() sert à lire le contenu du fichier
In [22]: f.read() Out[22]: 'okokokok\n'
write() consiste à écrire le contenu du fichier. Ouvrez-le en mode ajout et ajoutez-le plus tard. Ouvrez-le en mode écriture seule, ce qui effacera le contenu du fichier précédent et. ne conserver que le contenu d'écriture actuel
In [22]: f.write('hello')
readline() lit ligne par ligne
In [29]: f.readline() Out[29]: 'okokokok\n' In [30]: f.readline() Out[30]: 'hello'
readlines () lit tout et l'affiche dans une liste, chaque ligne est un élément de la liste
In [32]: f.readlines() Out[32]: ['okokokok\n', 'hello']
tell() et seek() :
tell( ) indique la position pointée par le pointeur actuel
seek() doit placer le pointeur là où
In [35]: f.tell() Out[35]: 9 In [36]: f.seek(0) In [37]: f.tell() Out[37]: 0
flush() doit actualiser le contenu exploité
In [39]: f.flush()
next() lit une ligne dans l'ordre et ne lit qu'une seule ligne à la fois
In [41]: f.next() Out[41]: 'okokokok\n' In [42]: f.next() Out[42]: 'hello'
close() ferme le fichier ouvert
In [44]: f.close()
Quelques opérations de base simples :
In [1]: a = 'hello to everyone'
In [2]: a
Out[2]: 'hello to everyone'
In [3]: a.split()
Out[3]: ['hello', 'to', 'everyone']
In [4]: a
Out[4]: 'hello to everyone'
In [5]: a.spli
a.split a.splitlines
In [5]: a.split('t')
Out[5]: ['hello ', 'o everyone']
In [6]: a.split('o')
Out[6]: ['hell', ' t', ' every', 'ne']
In [7]: a.split('o',1)
Out[7]: ['hell', ' to everyone']
In [8]: list(a)
Out[8]:
['h',
'e',
'l',
'l',
'o',
' ',
't',
'o',
' ',
'e',
'v',
'e',
'r',
'y',
'o',
'n',
'e']
In [14]: li = ['hello','everyone','ok']
In [15]: ';'.join(li)
Out[15]: 'hello;everyone;ok'
In [16]: 'hello {}'.format('everyone')
Out[16]: 'hello everyone'
In [17]: 'hello{}{}'.format('everyone',1314)
Out[17]: 'hello everyone1314'
In [18]: 'it is {}'.format('ok')
Out[18]: 'it is ok'
2. Orientation Programmation objet :
Trois fonctionnalités majeures : héritage, polymorphisme, encapsulation
Méthodes d'instance, variables d'instance, méthodes de classe, variables de classe, propriétés, méthodes d'initialisation, variables privées, méthodes privées
Méthode de définition de classe de classe :
Classe classique (essayez de ne pas l'utiliser) :
class Name(): pass
l'objet est la classe de base de toutes les classes en python
Nouveau style de classe Méthode de définition :
class Name(object): defmethod(self): pass
Méthode d'initialisation :
def __init__(self,name): self.nane = name
Méthode d'instance :
def print_info(self): self.b = 200 print ‘test’,self.b
Instanciation
test = Name(tom) print test.name
Définir une méthode privée, format : commencer par deux traits de soulignement, ne pas terminer par un trait de soulignement
def __test2(self): pass
Vous trouverez ci-dessous quelques exemples de programmation orientée objet. Certains contenus et distributions sur la programmation Python seront expliqués dans les exemples pratiques :
#!/usr/bin/env python
class Cat(): #定义一个类，名字为Cat，一般类名第一个字要大写
def __init__(self,name,age,color): #初始化方法，self传递的是实例本身
self.name = name #绑定示例变量self.name
self.age = age #绑定示例变量self.age
self.color = color #绑定示例变量self.color
#定义一个函数方法，实例化后可以进行调用使用
def eat(self):
print self.name,"iseating......"
def sleep(self):
print "sleeping,pleasedon't call me"
def push(self):
print self.name,'is push threelaoshu'
mery = Cat('mery',2,'white') #实例化，将类示例化，此时类中的self为mery
tom = Cat('tom',4,'black') #实例化，将类示例化，此时类中的self为tom
print tom.name #打印实例变量
tom.eat() #调用实例方法
def test(): #在外部定义一个test函数
print 'okok'
tom.test = test
tom.test() Lors de l'instanciation, la classe est d'abord instanciée dans un objet, puis les méthodes de la classe peuvent être appelées, c'est-à-dire la méthode dite d'instance, faites attention à la valeur de retour de la méthode, qui peut être utilisée plus tard. Par souci d'affichage visuel, seule l'instruction print est utilisée pour. impression.
Les résultats sont les suivants :
tom tom is eating...... okok
Dans l'exemple suivant, les méthodes privées et les variables privées sont introduites dans la classe, et leur utilisation est légèrement similaire à celle de la classe Les méthodes de fonction générales dans Elle ne sera pas appelée en externe et est privée à la classe. On peut voir que dans le programme, les variables privées et les méthodes privées peuvent être appelées par d'autres méthodes de la classe, de sorte que. des informations utiles peuvent être transmises via les opérations d'autres méthodes
Les résultats sont les suivants :
#!/usr/bin/env python
class Tom(object): #定义一个新式类，object为python中所有类的基类
def __init__(self,name):
self.name = name
self.a = 100
self.b = None
self.__c = 300 #这是一个类的私有实例变量，在外面不能被调用，可以在类内进行调用处理
def test1(self):
print self.name
self.b = 200
print 'test1',self.b
def test2(self,age):
self.age = age
print 'test2',self.age
self.__test3() #在这里调用类的私有方法
def __test3(self): #这是一个私有方法，也是不能被外界调用，可以在类中被别的方法调用，也可以传递出去
print self.a
def print_c(self):
print self.__c #调用类的私有变量
t = Tom('jerry') #实例化
t.test1() #调用实例方法
t.test2(21)
def test4(num):
print 'test4',num
t.exam = test4
t.exam(225)
t.print_c()
Dans l'exemple suivant, la définition et l'utilisation des variables de classe et des paramètres de classe est principalement présentée dans le but de comprendre les différences entre les méthodes d'instance et les variables d'instance :
jerry test1 200 test2 21 100 test4 225 300
#!/usr/bin/env python
class Dog(object):
a = 100
def test(self):
self.b = 200
print 'test'
@classmethod #装饰器，在类中用classmethod来装饰的方法，将直接成为类方法，所传递的参数也将是类本身，一般都要有cls作为类参数
def test2(cls,name):
print name
cls.b = 300 #类变量值，下面调用时可以看出有何不同
print cls.a
print 'test2'
Dog.test2('tom')
print Dog.b
d = Dog()
d.test2('tom')
print d.b在上面的程序中，我们可以看到，test方法为实例方法，test2方法为类方法，定义的区别主要就是类方法使用装饰器classmethod装饰的，并且类方法传递的参数为cls，即类本身，实例方法传递的参数是self，即实例本身，这就是区别，至于在最后的调用，明显可以看出，实例方法首先要实例化，再用实例去调用方法与变量；类方法则是直接通过类来进行调用。
结果如下：
tom 100 test2 300 tom 100 test2 300
下面主要是练习类里面的类方法和静态方法：
#!/usr/bin/env python
class Dog(object):
a = 100
def __init__(self,name): #初始化方法
self.n = name
@classmethod
def cls_m(cls): #类方法
print 'cls_m'
@staticmethod
def static_m(a,b): #静态方法
print a,b
Dog.static_m(3,4)
d = Dog(200)
d.static_m(1,2)在上面的程序中，主要是区别了类方法和静态方法；静态方法由staticmethod装饰器装饰，类方法由classmethod装饰器装饰；静态方法没有cls或self，可被实例和类调用
输出结果如下：
3 4 1 2
逻辑上类方法应当只被类调用，实例方法实例调用，静态方法两者都能调用。主要区别在于参数传递上的区别，实例方法悄悄传递的是self引用作为参数，而类方法悄悄传递的是cls引用作为参数。
下面主要练习和说明了在面向对象编程中，一些类中的属性
#!/usr/bin/env python
#coding=utf-8
import datetime
class Dog(object): #新式类的定义
def __init__(self,n): #初始化方法
self.n = n
self.__a = None #私有变量
@property #装饰器，将方法作为属性使用
def open_f(self): #调用这个open_f属性将返回self_a和None比较的布尔值
return self.__a == None
@open_f.setter #setter是重新定义属性，在这里定义的属性名字要和上面的保持一致
def open_f(self,value):
self.__a = value
d = Dog(22)
print d.open_f
d.open_f = 'ok' #重新定义属性
print d.open_f
print "#######################"
class Timef(object):
def __init__(self):
self.__time =datetime.datetime.now() #获取当前时间
@property
def time(self):
returnself.__time.strftime('%Y-%m-%d %H:%M:%S') #打印事件，格式是%Y-%m-%d %H:%M:%S
@time.setter
def time(self,value):
self.__time =datetime.datetime.strptime(value,'%Y-%m-%d%H:%M:%S') #重新获取自定义的事件
t = Timef()
print t.time #<当有@property装饰器时，作为属性直接使用> 区别于printt.time()
#方法的调用和函数类似，方法就是讲函数绑定到实例化的实例上，属性是作为实例的属性直接进行调用的
t.time = '2016-06-17 00:00:00'
print t.time
print "######################"
#这是一个练习的小程序，参考上面理解练习
class Hello(object):
def __init__(self,num):
self.mon = num
self.rmb = 111
@property
def money(self):
print self.rmb
return self.mon
@money.setter
def money(self,value):
self.mon = value
m = Hello(50)
print m.money
m.money = 25
print m.money
在上面的程序中，主要是解释了属性在类中的定义，以及属性与方法的一些区别，并且简单说明了如何重定义属性的内容，其实@proerty装饰的函数就相当于get属性来使用，@method.setter就是作为set进行重定义使用的。
方法就是讲函数绑定到实例化的实例上，属性是作为实例的属性直接进行调用的
输出结果如下：
True False ####################### 2016-06-27 20:39:38 2016-06-17 00:00:00 ###################### 111 50 111 25
下面是一个练习示例：
#!/usr/bin/env python
class World(object):
def __init__(self,name,nation):
self.name = name
self.nation = nation
self.__money = 10000000000
def flag(self):
print self.__money
return self.name
@property
def action(self):
return self.nation
@action.setter
def action(self,num):
self.nation = num
f = World('Asia','China')
print f.flag()
print f.action
f.action = 'India'
print f.action
输出结果如下：
10000000000 Asia China India
本文出自 “ptallrights” 博客，请务必保留此出处http://ptallrights.blog.51cto.com/11151122/1793483
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)
