반응형


+클래스 

class 클래스명:
     def __init__(self, 파라미터,...):
          ...
     def 메서드1(self, 파라미터,...):
          ...
__init__ ; 생성자

__del__ ; 소멸자


class Man:
     def __init__(self, name):
          self.params={}
          self.name=name
          print("aa")
    
     def hi(self):
          print("hi "+self.name+"!")
     
     def setAge(self, a):
          self.params['age']=a

    def __del__(self):
          pass

m=Man("jj")          # 생성자 호출!  
m.hi()
del m          # m객체 소멸. 소멸자 호출!
-------------------------------------------------------------------------

class SumClass:
     def __init__(self, name):     // constructor
          self.name=name 
     def sum(self, a, b ):     // 첫번째 인자는 self로 해야 한다.
          result=a+b
a = SumClass("jane')
a.sum(1,2)

-------------------------------------------------------------------------------

class Fib:
     '''iterator that yields numbers in the fibonacci sequence'''

     def __int__(self, max):
          self.max = max          #     instance에서의 global 변수. self.*
     def __iter__(self):
          self.a=0
          self.b=1
          return self
     def __next__(self):
          fib = self.a
          if fib > self.max:
               raise StopIteration
          self.a, self.b = self.b, self.a+self.b
          return fib

빈 클래스 정의시, 문법적 오류를 피하기 위해 내용에 pass 라고 쓴다. 나중에 작업할 때 사용.

class PapayaWhip:
     pass


+클래스의 객체 생성 ; 클래스명(constructor)으로 함수 호출처럼 한다.

f = Fib(100)
for i in f :
    print( i, end=“ “)
에러없이 마지막까지 출력된다.




+ 클래스 상속  ; 클래스 선언시 뒤에 (parent) 를 추가한다.

class B(A):
    pass

A클래스로부터 상속받는다.

ex)
class Person:
    def __init__(self, name, age, gender):
          self.Name = name
          self.Age= age
          self.Gender = gender
    def aboutme(self):
          pass
class Employee(Person):
     def __init__(self, name, age, gender, salary):
          super().__init__(self, name, age, gender)     # Person._init__(..)을 사용해도 되나, 다중상속시 중복실행되는 것을 막기위해 super를 사용한다.
         self.Salary=salary
    def work(self):
          pass

   
+ 다중 상속도 지원한다.
class Child(ParentOne, ParentTwo):
..




+ 연산자 오버로딩

아래와 같이 미리 정의된 함수를 중복 정의하여 사용한다.

__add__(self, other)
__mul__(self, other)
__sub__(self, other)
...

피연산자의 순서가 뒤바뀐 경우도 지원하려면?
함수이름에 r을 붙인 것을 정의한다.
__add__=__radd__
__sub__=__rsub__
__mul__=__rmul__

n=numbox(100)
n+100
100+n



+ 클래스 메소드 class method   ; 첫 번째 인자가 cls 로 클래스를 의미.
@classmethod
def change_raise_amount(cls, rate):
     cls.raise_rate=rate
     

+static method     ; cls 객체가 없다.
@staticmethod
def is_work_day(day):
     return True



'Python' 카테고리의 다른 글

Python JSON 사용하기  (0) 2018.04.10
Python 외부 모듈사용.time,string,random, try except  (0) 2018.04.09
Python 강좌6 tuple, set, dictionary  (0) 2018.03.21
Python 강좌5 List  (0) 2018.03.20
Python 강좌4 정규식 regular expression  (0) 2018.03.19
반응형


+ 튜플 (tuple)    ; immutable! 리스트와 같으나 변경불가.

() 를 사용한다. 리스트와 비슷하나, 튜플은 값을 변경할 수 없다.
t1=()
t2=(1,)             # 주의!!! 원소가 한 개인 경우 반드시 뒤에 ,를 써줘야 한다. 쓰지 않으면 () 연산자로 인식.
a,b = 10,20          # 이것도 튜플을 통한 복수 데이터 할당의 응용이다. 
b,a = a,b          # 이렇게 값을 동시에 변경할 수도 있다. swap이 쉽다.
t3=(1,2,3)
t4=1,2,3,4
위와 같이 사용

매크로 값 할당 처럼 사용 가능.
(MON, TUE, WED) = range(3)
MON=0
TUE=1
WED=2

-튜플 연산
+는 데이터 추가. *는 반복.
tuples=('a','b','c')
tuples+('d',e','f')     # a b c d e f 가 된다. 
tuples*3          # a b c a b c a b c가 된다.







+Set ; 집합.{}
노드들의 순서 없음. 중복은 추가되지 않음.
a_set = { 1 }

-list를 set으로 변환.
a_set=set(a_list)

a_set=set()        ; empty set
a_set.add(4)    ; item add
len(a_set)         ; item count
a_set.update( {4,5,6} )    ; items add (중복은 추가되지 않음.)
a_set.update( [10,20,30])    ; items add (중복은 추가되지 않음.)
a_set.discard( 10 )    ; 10을 삭제함. (없어도 에러 안남)
a_set.remove(10)    ; 10을 삭제함. (없으면 에러. KeyError)
a_set.clear()

30 in a_set    ; check (T/F) exist
a_set.union(b_set)    ; union set
a_set.intersection(b_set)    ; intersection
a_set.difference(b_set)    ; diff. A-B
a_set.symmetric_difference(b_set) ; diff.  (A+B)-(A intersect B)
a_set.issubset(b_set) ; T/F   check A<B
b_set.isupperset(a_set) ; T/F  check B>A











+ Dictionary
{key:value,...}를 사용.        json과 비슷.
unordered. key-value pairs.

dic={123:456, 3.14:11.2, (1,3):(3,1),  'abc':'def',  'list':{1,2,3}, 'dict':{1:2, 3:4}}

dic={'name':'pey', 'phone':'111111','birth':'1111'}
dic['name']
주의! 
a={1:'a',2:'b'}
a[1]='a' 이다.  Dictionary에서 a[1]에서 1은 인덱스가 아니고 Key다.!!

-사전에 추가 방법
a['name2']='test' ; 없으면 추가된다!!!.  있으면 업데이트된다. 
-삭제는 del을 사용!
del a['name2']
a.keys() ; key 명으로된 list
a.clear() ; 모두 삭제
a.get('name') ; 키로 값 얻기 ; a['name'] 과 동일하다.

-객체가 None 또는 empty이면 false로 취급.
-키가 없으면 KeyError 발생
a['akaka']

-사전 키 존재! 여부 검사 (in, has_key)
'name' in dic
True
'job' in dic
False

if 'keyname' in dic:
     use...
or
if dict.has_key('keyname')==1:
     use...
or
value=dic.get('keyname', 0)          # 키가 없으면 디폴트값으로 설정함.!! ( 널체크. null, None. )


+ dictionary 생성
import glob
import os
metadata_dict = { f:os.stat(f) for f in glob.glob('*test*.py') }

metadata_dict[0]
metadata_dict['atest01.py'].st_size
list(metadata_dict.keys())


+ key, value 뒤집기
{ value:key for key, value in a_dict.items() }


+ key, value 검색
for k, v in dictA.items():
     print(k,v)
for (k,v) in dictA.items(): 상동

for k in dictA:
     print(k, dictA[k])



'Python' 카테고리의 다른 글

Python 외부 모듈사용.time,string,random, try except  (0) 2018.04.09
Python 강좌7 클래스  (0) 2018.03.27
Python 강좌5 List  (0) 2018.03.20
Python 강좌4 정규식 regular expression  (0) 2018.03.19
Python 강좌3 자료형. 수/문자열  (1) 2018.03.16
반응형



+ 리스트  /  List

[]를 사용한다.   순서가 있는 자료. 아무타입이나 복수타입들도 지원.
odd=[1,3,5,7,9]
리스트 내에 또 리스트를 쓸 수 도 있다.

string은 immutable이지만 list는 mutable이다.
! 리스트도 +를 사용하면 합쳐진다. *를 사용하면 반복됨.

lst=[1,2,5,'a','b']
lst=['a', 4.12, 'abb', ['a','b','c']]


a=[1,2]
a+[3,4]     => [1,2,3,4]
a*3     => [1,2,1,2,1,2]
인덱스는 0부터 시작
a[:] = []          # 리스트 클리어


다른 타입들도 원소로 갖을 수 있다.
array 처럼 사용한다.
append로 가장 마지막에 추가.
메모리 사용량은 많다.

list1=[...,...,..,...]
인덱스는 0부터시작
len(list1) => array count ; 원소 개수
list1.remove('...') ; 아이템을 찾아 삭제
list1.append('xxx') ; 추가
list1.sort()
del list1[1]

-리스트 조회
a[0:2] ; 인덱스 0~1까지 가져옴  ; 주의! 마지막 인덱스2는 포함되지 않는다! 
a[1:] ; 인덱스 1~
a[:3] ; 인덱스 0~2   
a[:-2] ;  a 전체에서 마지막 2개 제외.
인덱스 -1은 마지막 인덱스 번호를 의미함.


-리스트 내부 원소 개수
x = [[0, 0],[0,1], [1,0], [1,1]]
len(x)
4
len(x[0])
2

-리스트 차원을 알려면??? (팁)
x=[[1,2],[3,4]]
isinstance(x, list)
true
isinstance(x[0], list)
true
isinstance(x[0][0], list)
false
def test_dim(testlist, dim=0):
   if isinstance(testlist, list):
      if testlist == []:
          return dim
      dim = dim + 1
      dim = test_dim(testlist[0], dim)
      return dim
   else:
      if dim == 0:
          return -1
      else:
          return dim

-리스트 요소 삭제 방법
a=[1,'a','b','c',4]
a[1:3]=[]     => [1, 4]
또는 
del a[1:3]



-리스트 관리. 기타

a.append(4)     ; 뒤에 추가
a.insert(a,b) ; a 인덱스 위치에 b를 삽입.

a.remove(value) ; value를 찾아서 삭제한다. (처음에 발견된 하나만 삭제됨)
a.pop()  ; 가장 뒤에 노드를 하나 빼서 리턴한다.  pop(index)로 하면 해당 인덱스의 값을 뺀다.

a.count(value) ; value가 몇 개 들어있는지 개수
a.index(value) ; value가 몇 번째 인덱스가 존재하는지 검색.  (처음 발생한 지점)
    존재하지 않으면, ValueError exception

a.sort()     ; 리스트의 값들을 오름차순 정리함. 내림차순 정렬은 a.sort(reverse=True)
a.reverse() ; 리스트의 순서를 역순으로 조회.    ; a값 자체가 바뀐다! 주의!!!


+여러 개를 한 번에 추가시, extend.
nums=[1,2,3]
nums.extend([4,5,6])
nums
[1,2,3,4,5,6]

+리스트 위치 확인 index
lst.index('blue')     ; 처음 발견된 blue의 위치.
lst.index('blue',2)     ; 2번째로 발견된 blue의 위치.
lst.index('blue', 2, 4)      ; 인덱스2~4 범위내에서 검색.



+ 리스트 원소별 작업
a_list=[1,9,8,4]
a_list2 = [elem *2 for elem in a_list ]


+ 리스트 재구성, 필터링. ; 조건에 따라 선택.

cond = mat1[:,2]>5
cond = [True, False, True, False]
list_filter = [ i for i, c in zip(list1, cond) if c ]





------sample
a=[1,2,3,4]
while a:
     a.pop()
=> 4 3 2 1 출력
-변수 대입
a='aaa'
(a,b) = ('aaa','bb')
a=3
b=5
a,b = b,a     ; 두 변수의 값이 swap
b is a ==> true


-리스트 복사 주의사항!!
a=[1,2,3]
b=a
a[1]=4
b[1]=? 마찬가지로 변경되어 있음. (reference?)
b는 영향을 안 받고 싶으면 복사
b=a[:]     이렇게 복사해서 받아야 함.          주의!!!
또는
b = copy(a)
b is a => false



'Python' 카테고리의 다른 글

Python 강좌7 클래스  (0) 2018.03.27
Python 강좌6 tuple, set, dictionary  (0) 2018.03.21
Python 강좌4 정규식 regular expression  (0) 2018.03.19
Python 강좌3 자료형. 수/문자열  (1) 2018.03.16
Python 강좌2 if/for/while/function  (0) 2018.03.15

+ Recent posts