Python의 객체 지향 및 기본 I/O 작업(1)
- 巴扎黑원래의
- 2017-04-01 13:33:391282검색
1. I/O 작업:
open(name[,mode])는 file(name[,mode])
과 동일합니다. 모드 설명:
r은 반드시 존재해야 하는 읽기 전용 파일을 엽니다.
r+는 읽고 쓸 수 있는 파일을 엽니다. 파일이 존재해야 합니다.
w는 쓰기 전용 파일을 엽니다. 파일이 존재하면 파일 길이가 0으로 지워집니다. 즉, 파일 내용이 사라집니다. 파일이 존재하지 않으면 파일을 생성하십시오.
w+는 읽기 및 쓰기 가능한 파일을 엽니다. 파일이 존재하면 파일 길이가 0으로 지워집니다. 즉, 파일 내용이 사라집니다. 파일이 존재하지 않으면 파일을 생성하십시오.
a 추가 모드에서 쓰기 전용 파일을 엽니다. 파일이 없으면 파일이 생성됩니다. 파일이 있으면 작성된 데이터가 파일 끝에 추가됩니다. 즉, 파일의 원래 내용이 유지됩니다.
a+ 추가 모드에서 읽기-쓰기 파일을 엽니다. 파일이 없으면 파일이 생성됩니다. 파일이 있으면 작성된 데이터가 파일 끝에 추가됩니다. 즉, 파일의 원래 내용이 유지됩니다.
위의 형태학적 문자열은 b 문자(예: rb, w+b 또는 ab+ 및 기타 조합)를 추가하여 열려는 파일이 a가 아닌 바이너리 파일임을 함수 라이브러리에 알리기 위해 추가될 수 있습니다. 일반 텍스트 파일. 그러나 Linux를 포함한 POSIX 시스템에서는 이 문자가 무시됩니다.
In [1]: f = open('/tmp/test','w'） In [2]: f.write('okokokok') In [3]: f.close()
는 Linux에서 다음과 같이 표시됩니다.
#cat /tmp/test okokokok
는 Python 대화형 인터프리터에서도 사용할 수 있습니다. 다음과 같이 보기:
In [4]: f = open('/tmp/test','r') In [5]: f.read() Out[5]: 'okokokok' In [6]: f.close()
Append 모드 작동:
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()
조합 모드:
In [13]: f = open('/tmp/test','r+') In [14]: f = open('/tmp/test','w+') In [15]: f = open('/tmp/test','a+')
파일을 연 후(모드 선택 가능) 파일을 조작할 수 있습니다. 다음은 일반적으로 사용되는 몇 가지 방법입니다.
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
ipython에서 탭 완성을 사용하여 볼 수 있습니다.
read()는 파일 내용을 읽는 것입니다.
In [22]: f.read() Out[22]: 'okokokok\n'
write()는 파일 내용을 쓰는 것입니다. , 추가 모드로 열고 나중에 추가하고, 쓰기 전용 모드로 열면 이전 파일 내용은 지워지고, 이번에 쓴 내용만 유지됩니다
In [22]: f.write('hello')
readline()은 한 줄씩 읽습니다
In [29]: f.readline() Out[29]: 'okokokok\n' In [30]: f.readline() Out[30]: 'hello'
readlines()는 모두 읽고 목록으로 출력합니다. 각 줄은 목록의 요소입니다
In [32]: f.readlines() Out[32]: ['okokokok\n', 'hello']
tell() 및eek():
tell()은 포인터가 지금 가리키는 위치를 나타냅니다.
seek()는 포인터가 가리키는 위치를 설정합니다.
In [35]: f.tell() Out[35]: 9 In [36]: f.seek(0) In [37]: f.tell() Out[37]: 0
flush()는 실행된 내용을 새로 고치는 것입니다
In [39]: f.flush()
next()는 한 줄을 읽는 것입니다. 한 번에 한 줄만 읽습니다
In [41]: f.next() Out[41]: 'okokokok\n' In [42]: f.next() Out[42]: 'hello'
close()는 열려 있는 파일을 닫습니다
In [44]: f.close()
몇 가지 간단한 기본 연산:
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. 객체 지향 프로그래밍:
세 가지 주요 기능: 상속, 다형성 , 캡슐화
인스턴스 메소드, 인스턴스 변수, 클래스 메소드, 클래스 변수, 속성, 초기화 메소드, 프라이빗 변수, 프라이빗 메소드
클래스 클래스 정의 방법:
클래식 클래스(시도하지 않음) 사용):
class Name(): pass
객체는 Python의 모든 클래스의 기본 클래스입니다.
새로운 스타일의 클래스 정의 방법:
class Name(object): defmethod(self): pass
초기화 방법:
def __init__(self,name): self.nane = name
인스턴스 메소드:
def print_info(self): self.b = 200 print ‘test’,self.b
인스턴스화
test = Name(tom) print test.name
프라이빗 메소드 정의, 형식: 두 개의 밑줄로 시작, 금지 밑줄로 끝남
def __test2(self): pass
다음은 객체 지향 프로그래밍에 대한 몇 가지 예입니다. Python 프로그래밍에 대한 일부 내용과 배포는 연습 예에서 설명됩니다. 🎜>
#!/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() 위 프로그램에서는 Cat 클래스가 정의되어 있는데, 여기서 __init__() 메서드가 가장 먼저 실행됩니다. 이는 클래스를 인스턴스화할 때 인터프리터가 수행하는 초기화 메서드입니다. 이 메소드는 일반적으로 외부에서 전달된 매개변수를 수신하는 데 사용되며 여러 함수 메소드도 정의되어 를 호출하는 데 사용됩니다. 인스턴스화하려면 먼저 클래스를 객체로 인스턴스화한 다음 클래스를 호출할 수 있습니다. 메소드의 반환 값은 나중에 사용할 수 있으므로 주의하세요. print 문은 인쇄에 사용됩니다.
결과는 다음과 같습니다.
tom tom is eating...... okok
다음 예에서는 프라이빗 메서드와 프라이빗 변수가 클래스에 도입되었으며 사용법이 약간 다릅니다. 함수 메서드는 약간 다릅니다.
#!/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()위 프로그램에서는 개인 변수와 개인 메서드의 이름 지정 형식이 이중 밑줄로 시작하므로 호출되는 것은 클래스에 비공개입니다. 프로그램에서 비공개 변수와 비공개 메소드가 클래스의 다른 메소드에 의해 호출될 수 있으므로 다른 메소드의 연산을 통해 유용한 정보가 전달될 수 있음을 알 수 있습니다.
결과는 다음과 같습니다.
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
위 내용은 Python의 객체 지향 및 기본 I/O 작업(1)의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!