Learning Python

In [15]: f=open('bdata.bin','wb')

In [16]: data=struct.pack('>i5sh',50,b'email',4)

In [17]: f.write(data)

Out[17]: 11

In [18]: f.close()

In [19]: f=open('bdata.bin','rb')

In [20]: data2=f.read()

In [21]: data2

Out[21]: b'\x00\x00\x002email\x00\x04'

In [22]: orgdata=struct.unpack('>i5sh',data2)

In [23]: orgdata

Out[23]: (50, b'email', 4)

{fieldname component ! conversionflag : format_spec} 와 같은 형태를 가진다.

fieldname : 0,1,2와 같은 번호나 surname, givenname과 같은 키워드를 사용할 수 있다.

component : [index]와 같이 리스트 콤포넌트를 사용하거나 .attr 와 같이 attributes가 있다면 사용할 수 있다.

conversion flag : ! 다음에 r,s 가 오거나 repr, str ascii func등을 부를 수 있다.

format_spec

[[fill]align] [sign] {#] [0] [width] [,] [.prec] [typecode] 형태로 이루어진다.

[fill] : *** --- 등 좌우 여백을 채울 문자를 넣는다.

[align] : <,>,^,= 등을 넣는다

[sign] : +,-, space

[,] : thousands separator

In [127]: import re

...:

...: def findall(SearchKey,Sentence):

...: rtn=[[m.group(),m.start(),m.end()] for m in re.finditer(SearchKey,Sentence)]

...: return rtn

In [128]: res2="abc aa bb ddd dhfksa kdafja kdasfjal qoqrfj"

In [123]: a=findall('(\w)\1+',res2)

In [124]: a

Out[124]: []

In [125]: a=findall(r'(\w)\1+',res2)

In [126]: a

Out[126]: [['aa', 4, 6], ['bb', 7, 9], ['ddd', 10, 13]]

\1은 앞에서 그룹화 했던 부분과 완전히 동일한 것을 말한다.

단순히 \w{2,} 와 같이 하면 동일 문자 반복이 아닌 문자 반복이 된다.

따라서 aa bb와 같이 앞에 나온 것과 동일한 문자를 반복할 때는 그룹화를 시켜준 다음 \1 \2와 같이 그룹의 번호를 사용하면 된다.

r' '와 같이 raw string을 사용하는 것이 편리하다.

일반적으로 함수의 반환 값은 return으로 정해진다.

함수의 부분에 return 이 나타나면 return 다음에 나오는 변수를 반환하고 함수는 종료된다.

return 대신에 yield 가나타나면, python은 그 함수를 generator로 인식하며 next 함수가 작동할수 있게 된다.

예제)

In [31]: def G():

...: n=0

...: while True:

..........: input = yield 'output'

..........: n=n+1

..........: print(n)

...:

In [39]: g=G()

In [40]: next(g) # 함수 4번째 줄까지만 실행됨

Out[40]: 'output'

In [41]: next(g) #함수 5,6 줄이 실행되고 다시 while loop 처음으로 돌아가 두번째 yield까지 실행됨

1

Out[41]: 'output'

In [42]: next(g)

2

Out[42]: 'output'

In [43]: next(g)

3

Out[43]: 'output'

위 예제에서 yield 식의 값은 항상 None이다.

함수 안에 yield 가 존재하면 python은 generator로 인식하고, next함수에 의하여 call되면,

1. 최초에는 함수의 처음부터 yield가 나타나는 지점까지만 시행되고 yield 가 반환한 값을 반환하면서 종료된다.

2. 종료된 지점과 값은 그대로 메모리에 남아 있다가

3. 다음 next가 시행되면 기억된 지점과 변수를 사용하여 아까 중단된 시점부터 다음 yield가 작동될때 까지 함수가 실행된다.

4. 위 예제에선 while loop 안에 yield가 있으므로 무한히 작동되고 첫줄의 n=0는 한번만 시행된다.

5. while loop 안에 없거나 함수의 끝에 도달되면 generator 끝에 도달하는 것과 같이 에러를 내며 종료한다.

예제2)

In [62]: def G2():

...: n=0

...: yield 'output'

...: n=n+1

...: print(n)

...: yield n

...:

In [63]: g=G2()

In [64]: next(g) # 함수 3번째 줄까지만 실행됨

Out[64]: 'output'

In [65]: next(g) # 함수 4,5,6번째 줄이 실행됨

1

Out[65]: 1

In [66]: next(g) # 다음 yield는 없으므로 에러를 내며 종료됨

Traceback (most recent call last):

File "", line 1, in

next(g)

StopIteration

In [19]: s='\xebmail'

In [20]: s

Out[20]: 'ëmail'

In [28]: file=open('unicode.txt','w',encoding='utf-8')

In [29]: file.write(s)

Out[29]: 5

In [30]: file.close()

In [31]: file=open('unicode16.txt','w',encoding='utf-16')

In [32]: file.write(s)

Out[32]: 5

In [33]: file.close()

In [34]: raw=open('unicode.txt','rb').read()

In [35]: raw

Out[35]: b'\xc3\xabmail'

In [36]: len(raw)

Out[36]: 6

In [37]: raw2=open('unicode16.txt','rb').read()

In [38]: raw2

Out[38]: b'\xff\xfe\xeb\x00m\x00a\x00i\x00l\x00'

In [39]: len(raw2)

Out[39]: 12

In [40]: raw.decode('utf-8')

Out[40]: 'ëmail'

In [41]: raw2.decode('utf-16')

Out[41]: 'ëmail'

In [42]: raw.decode('utf-16')

Out[42]: 'ꯃ慭汩'

1. Byte Order, Size, and Alignment

2. Format Characters

Reference

https://docs.python.org/3.7/library/struct.html

In [19]: c=['a','b','c','a','b','a','d']

In [20]: c.count(1)

Out[20]: 0

In [21]: c.count('a')

Out[21]: 3

In [22]: c.count('b')

Out[22]: 2

In [23]: c.index('b')

Out[23]: 1

In [28]: c.insert(2,0)

In [29]: c

Out[29]: ['a', 'b', 0, 'c', 'a', 'b', 'a', 'd']

In [31]: c.remove(0)

In [32]: c

Out[32]: ['a', 'b', 'c', 'a', 'b', 'a', 'd']

In [33]: c.pop()

Out[33]: 'd'

In [34]: c

Out[34]: ['a', 'b', 'c', 'a', 'b', 'a']

In [35]: c.pop(1)

Out[35]: 'b'

In [36]: c

Out[36]: ['a', 'c', 'a', 'b', 'a']

In [37]: c.extend([1,2])

In [38]: c

Out[38]: ['a', 'c', 'a', 'b', 'a', 1, 2]

#
In [1]: import timeit as ti
 
In [8]: a="""\
   ...: a1=[x**3 for x in [1,2,3,4,5,6,7,8,9,10]]
   ...: a1"""

In [9]: b="""\
   ...: b1=[]
   ...: for x in [1,2,3,4,5,6,7,8,9,10]:
   ...: b1.append(x**3)
   ...: b1"""

In [10]: ti.timeit(a, number=100000)
Out[10]: 0.4964596600000277

In [11]: ti.timeit(b, number=100000)
Out[11]: 0.5405233050000788 
 
결론
즉 큰 차이는 아니지만  동일한 결과를 내는 식이라면 for loop를 사용하는 것보다는 list comprehension을 사용하는 것이 대게 더 빠르다.
 
간단한 벤치마크는 timeit.timeit 함수를 사용하면 된다.
timeit(a, number=b) 에서 a는 벤치마크를 하려는 문자열이고, b는 이것을 몇번 반복하는지 지정하는 것이다.
 

PYTHON/Types
#
딕셔너리에서는 인덱스가 아닌 키값으로 값을 참조한다.
In [18]: d
Out[18]: {'a': 1, 'b': 2, 'c': 3, 'f': 50}
 
In [20]: d[1]='e'

In [21]: d
Out[21]: {'a': 1, 'b': 2, 'c': 3, 'f': 50, 1: 'e'}

In [22]: del d[1]

In [23]: d
Out[23]: {'a': 1, 'b': 2, 'c': 3, 'f': 50}
 
즉 del d[1]에서 1은 인덱스 1이 아니라 키값 1을 말한다. 
 
In [23]: d
Out[23]: {'a': 1, 'b': 2, 'c': 3, 'f': 50}

In [24]: d.keys()
Out[24]: dict_keys(['a', 'b', 'c', 'f'])

In [25]: d.items()
Out[25]: dict_items([('a', 1), ('b', 2), ('c', 3), ('f', 50)])

In [26]: d.get('a')
Out[26]: 1

In [27]: d.get('x',8) # 두번째 인자는 'x'라는 키값이 존재하지 않을 때 반환하는 디폴트값을 지정한다
Out[27]: 8

In [1]: m=[[1,2,3],[4,5,6],[7,8,9]]

In [2]: m
Out[2]: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

In [28]: a=map(sum,m)
#리스트 m의 원소들을 차례대로 입력 받아 함수에 넣고 값을 map object로 반환한다.

In [29]: a
Out[29]: <map at 0x278d2de6860>
 
 
In [31]: next(a)
Out[31]: 6
 
In [33]: next(a)
Out[33]: 15

In [34]: next(a)
Out[34]: 24 
 
 
In [36]: a=list(map(sum,m))

In [37]: a
Out[37]: [6, 15, 24]

In [38]: a=set(map(sum,m))

In [39]: a
Out[39]: {6, 15, 24}

In [40]: a=tuple(map(sum,m))

In [41]: a
Out[41]: (6, 15, 24) 

# 미리 만들어둔 테스트용 리스트
In [1]: m=[[1,2,3],[4,5,6],[7,8,9]]

In [2]: m
Out[2]: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# comprehension syntax를 사용하며 list 뿐만이 아니라 generator, dictionary, set등도 만들 수 있다.
 
1. 리스트
In [14]: [ row[2] for row in m]
Out[14]: [3, 6, 9]
 
2. 제너레이터
In [7]: g=(sum(row) for row in m)

In [8]: g
Out[8]: <generator object <genexpr> at 0x00000278D2D7A480>

In [9]: next(g)
Out[9]: 6

In [10]: next(g)
Out[10]: 15

In [11]: next(g)
Out[11]: 24

In [12]: next(g)
Traceback (most recent call last):

File "<ipython-input-12-e734f8aca5ac>", line 1, in <module>
next(g)

StopIteration
#제너레이터는 처음부터 한번씩 원소를 반환하며 끝에 도달하면 에러를 발생시킨다.
 
3. set
#세트는 괄호만 바꿔주면 된다
In [16]: g={sum(row) for row in m}

In [17]: g
Out[17]: {6, 15, 24}
 
4. dictionary
#딕셔너리 역시 괄호를 바꿔주고 키와 값을 지정해주고 그 사이를 콜론으로 마무리해주면 된다.
In [25]: g={m.index(row):sum(row) for row in m}

In [26]: g
Out[26]: {0: 6, 1: 15, 2: 24}
 
# 괄호를 사용하면 제너레이터를 생산하게 되므로 튜플은 만들 수가 없는 것 같다.

1. 간단 예제
In [1]: m=[[1,2,3],[4,5,6],[7,8,9]]

In [2]: m
Out[2]: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

In [3]: col2=[row[2] for row in m]

In [4]: col2
Out[4]: [3, 6, 9] 
 
 
2. 리스트 연산
In [6]: m2=[row+[1] for row in m]

In [7]: m2
Out[7]: [[1, 2, 3, 1], [4, 5, 6, 1], [7, 8, 9, 1]]
 
 
3. 각각의 원소에 1씩 더하기
In [9]: m3=[[row[0]+1,row[1]+1,row[2]+1] for row in m]

In [10]: m3
Out[10]: [[2, 3, 4], [5, 6, 7], [8, 9, 10]]
 

4. 튜플 형태로 변환
In [11]: m3=[(row[0]+1,row[1]+1,row[2]+1) for row in m]

In [12]: m3
Out[12]: [(2, 3, 4), (5, 6, 7), (8, 9, 10)]
 
 
5. 리스트 괄호에 유의
In [13]: m3=[[row[i]+1] for row in m for i in [0,1,2]]

In [14]: m3
Out[14]: [[2], [3], [4], [5], [6], [7], [8], [9], [10]]

In [15]: m3=[row[i]+1 for row in m for i in [0,1,2]]

In [16]: m3
Out[16]: [2, 3, 4, 5, 6, 7, 8, 9, 10] 
 
 
6. for-in-if 문
In [24]: l=[row[1] for row in m if row[1] % 2 == 0]

In [25]: l
Out[25]: [2, 8]

In [19]: l=[[1,2,3],[4,5,6],[7,8,9]]

In [20]: l
Out[20]: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

In [21]: l[1]
Out[21]: [4, 5, 6]

In [22]: l[1][2]
Out[22]: 6 

In [1]: l=['abc',123,'1.23','spam']

In [2]: l+[23]
Out[2]: ['abc', 123, '1.23', 'spam', 23]

In [3]: l*2
Out[3]: ['abc', 123, '1.23', 'spam', 'abc', 123, '1.23', 'spam']

In [4]: l
Out[4]: ['abc', 123, '1.23', 'spam']

In [5]: l.append('mem')

In [6]: l
Out[6]: ['abc', 123, '1.23', 'spam', 'mem']

In [7]: l.pop(2)
Out[7]: '1.23'

In [8]: l
Out[8]: ['abc', 123, 'spam', 'mem']
 
In [13]: m=['22','11','33']

In [14]: m
Out[14]: ['22', '11', '33']

In [15]: m.sort()

In [16]: m
Out[16]: ['11', '22', '33']

In [17]: m.reverse()

In [18]: m
Out[18]: ['33', '22', '11']

python에서 모든 기본적인 오브젝트는 mutable object와 immutable objects로 나눌 수 있다.
이것들을 구분하는 것은 매우 중요하며 모르면 프로그래밍 시 엉뚱한 결과를 나을 수도 있다.
​
mutable 이란 것은 'can be changed in place' 를 의미한다.
​
mutable
1. lists
2. dic
3. set
​
immutable
1. number
2. string
3. tuple
​
즉 immutable type인 string은 'cannot be changed in place'이다.
​
s='xyz'
​
s[0]=a
와 같은 식으로 일부를 변경할 수 없다.
​
s2='a'+s[1:] ; 과 같은 식으로 새로운 문자열을 만들어야 한다.
#

1. 역 슬래쉬 문자
\d : 숫자
\D : 숫자가 아닌 것
\s : 공백 문자 [\t\n\r\f\v]
\S : 공백 문자가 아닌 것
\w : 문자와 숫자 [a-zA-Z0-9]와 동일
\W : [^a-zA-Z0-9]와 동일
 
2. 메타 문자
. : '\n'을 제외한 모든 문자
? : 앞의 문자가 1회 있거나 말거나
* : 앞의 문자가 0회 이상 반복
+ : 앞의 문자가 1회 이상 반복
{m,n} :  앞의 문자가 m회 이상 n회 이하로 반복

문자클래스는 [와 ] 사이에 있는 표현식을 말한다.
[] 안의 의미와 밖의 의미가 다르므로 확실하게 구분되어야 한다.
 
[]의 전체 의미는 괄호 안에 있는 문자중의 하나를 뜻한다.
[abc] : a,b,c 3 문자중의 하나
[a-z] : 소문자 a부터 z까지중 하나의 문자를 가리킨다.
[A-Z] : 대문자 a부터 z까지중 하나의 문자를 가리킨다.
[0-9] : 숫자중의 하나의 글자를 가리킨다.
[a-zA-Z] :  알파벳 문자중의 하나
[a-zA-Z0-9] :  알파벳이나 숫자 중의 하나의 문자
 
[^] : 문자클래스 내에서 ^기호는 not을 뜻한다.
[^0-9] : 숫자가 아닌 문자
[^A-Z] : 대문자가 아닌 소문자나 숫자, 공백문자 중의 하나.
#

In [1]: import re

In [2]: m=re.match('[/:](.*)[/:](.*)[/:](.*)'.'/usr/home:robert')

In [7]: m.groups()
Out[7]: ('usr', 'home', 'robert')

In [8]: m.group()
Out[8]: '/usr/home:robert'

In [9]: re.split('[/:]', '/usr/home:robert')
Out[9]: ['', 'usr', 'home', 'robert']

In [9]: b='\xa3' ​

In [10]: b
Out[10]: '£' ​

In [11]: d='\u00a3'.encode('latin1') ​

In [12]: d
Out[12]: b'\xa3' ​
In [13]: d.decode('latin1')
Out[13]: '£'

1. 아스키 10진수
​
In [19]: chr(65)
Out[19]: 'A'
​
In [1]: ord('A')
Out[1]: 65
​
2. 아스키 헥사
\x()() 형태로 \x 다음 2자리
In [11]: s='\x41'
In [12]: s
Out[12]: 'A'
​
In [13]: s='\xc4'
In [14]: s
Out[14]: 'Ä'
​
3. unicode short
\u()()()() 형태로 \u 다음 4자리
​
In [15]: s='\u00c4'
In [16]: s
Out[16]: 'Ä'
​
4. unicode long
\U()()()()()()()() 형태로 \U 다음 8자리
​
In [17]: s='\U000000c4'
In [18]: s
Out[18]: 'Ä'
#