Simple_

이 문서는 파이썬 2점대를 기준으로 작성되었습니다.

10장 정규식

1-1 반복 메타 문자

1-2 매칭 메타 문자

. : - 줄바꿈 문자를 제외한 모든 문자와 매치 (re.DOTALL모드 사용하면 줄바꿈 문자 매치)

^ : - 문자열의 시작과 매치

- [] 메타 기호 안에서 반대의 문자열의 취함 [^5]는 5가 아닌 문자

$ : - 문자열의 마지막과 매치

- [] 메타 기호안에서는 메타 기호로 사용되지 않고 순수한 $문자로 매치된다.

[] : - 문자 집합을 나타낸다. ( [abc]는 ‘a’, ‘b’, ‘c’중 한 문자를 의미. == [a-c])

- [a-zA-Z0-9]는 영문자 숫자를 의미

| : - a|b는 a 또는(or) b의 의미

() : - 정규식을 그룹으로 묶는다.

[이스케이프 기호]

\\ : 역슬래쉬 문자 자체를 의미한다.

\d : 모든 숫자와 매치된다. [0-9]

\D : 숫자가 아닌 문자와 매치된다. [^0-9]

\s : 화이트 스페이스 문자와 매치된다. [\t\n\r\f\v]

\S : 화이트 스페이스 문자가 아닌 것과 매치된다. [^\t\n\r\f\v]

\w : 숫자 또는 문자와 매치된다. [a-zA-Z0-9_]

\W : 숫자 또는 문자가 아닌 것과 매치된다. [^a-zA-Z0-9_]

\b : 단어의 경계를 나타낸다. 단어는 영문자 혹은 숫자의 연속 문자열로 가정한다.

\B : \b의 반대로 단어의 경계가 아님을 나타낸다.

※출처 : 프리렉 파이썬_이강성 저 

[ 참고 ] 파이썬 정리 포스팅들 

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

[파이썬] python 문자열 함수정리

[파이썬] python 리스트 함수정리

[파이썬] python 튜플 함수정리

[파이썬] python 정규식 정리

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

이 문서는 파이썬 2점대를 기준으로 작성되었습니다.

10장 함수

[람다함수]

lambda 콤마로 구분된 인수들 : 식 #labmda x, y : x + y

[함수적 프로그래밍 - map 내장함수, 순서쌍 만들기]

map(f, X) #f:사상함수 X: 입력집합

X = [1,2,3,4,5]

Y = map(labda a:a*a, X)

map(None, [1,2,3], [4,5,6,7,8]) #순서쌍. 첫 인수 None

                            #[(1,4), (2,5), (3,5),(None, 7), (None,8)]

cf)zip([1,2,3], [4,5,6,7,8]) #[(1,4), (2,5), (3,5)]

[함수적 프로그래밍 - filter 내장함수, 시퀀스 자료중 필터링하여 참인 요소만 출력]

filter(lambda x:x>2, [1,2,3,34]) #[3, 34]

[함수적 프로그래밍 - reduce 내장함수]

reduce( 함수, 시퀀스형[, 초기값] )

reduce(lambdz x, y : x+y, [1,2,3,4,5]) #15

[함수객체의 속성]

def f():

pass

f.__doc__ #문서 문자열

f.func_doc

f.__name__ #함수의 이름

f.func_name

f.func_defaults #기본 인수 값들

f.func_code #함수의 코드 객체

f.func_globals #전역 영역

[함수의 코드객체 func_code]

code = func_code

code.co_name #함수의 이름

code.co_argcount #필수적인 인수의 개수

code.co_nlocals #전체 지역 변수의 수

code.co_varnames #지역 변수의 이름들

code.co_code #코드 객체의 바이트 코드 명령어

code.co_names #바이트 코드가 사용하는 이름들

code.co_filename #코드 객체를 포함하는 파일 이름

code.co_flags #코드객체가 가변 인수(*args, 0x04)와 키워드 인수(**kw, 0x08)를 갖는지 검사

#(하위 두개의 비트는 내부적으로 사용)

※출처 : 프리렉 파이썬_이강성 저

[ 참고 ] 파이썬 정리 포스팅들 

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

[파이썬] python 문자열 함수정리

[파이썬] python 리스트 함수정리

[파이썬] python 튜플 함수정리

[파이썬] python 정규식 정리

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

이 문서는 파이썬 2점대를 기준으로 작성되었습니다.

9장 파일

[파일쓰기]

f = file('t.txt', 'w') # f = open('t.txt', 'w')

f.write(s) #문자열 파일에 기록

f.close()

[파일읽기]

f = file('t.txt') # f = open('t.txt')

s = f.read()

[라인단위로 파일읽기]

line = f.readline() #한 번에 한 줄씩 읽는다.

list = f.readlines() #파일 전체를 라인 단위로 끊어서 리스트에 저장

f.readlines() #readlines와 유사하지만 파일 전체를 한꺼번에 읽기 않고,

필요할 때문 읽어서 공급

[라인단위로 파일 쓰기]

f.writelines(lines) #리스트 안에 잇는 문자열을 연속해서 출력(list에 '\n'있는경우)

f.write(''.join(lines))

f.write('\n'.join(lines))(list에 '\n' 없는경우)

[파일에서 원하는 만큼의 문자읽기]

f.read(10) #f.read(num)

[파일 처리 모드]

f = open('f.txt', 'a') #파일 추가 모드로 오픈

[임의 접근 파일]

f.seek(n) #파일의 n번째 바이트로 이동

f.seek(n, 1) #현재 위치에서 n바이트 이동(n이 양수면 뒤쪽으로, 음수면 앞쪽)

f.seek(n, 2) #맨 마지막에서 n바이트 이동(n은 보통 음수)

f.tell() #현재의 파일 포인터 위치 돌려줌

[파일 객체 method 요약]

file.close() #파일을 닫는다. 더 이상 입출력 할 수 없게 됨

file.read([size]) #원하는 바이트 수만큼 파일에서 읽어온다. 인수를 지정하지 않으면 전체 파일 read

file.readline() #라인 하나를 읽어들인다. size가 지정되면 읽을 수 있는 최대 바이트 수가 됨

file.readlines() #전체 라인을 readline()을 이용하여 읽어들인 라인을 리스트에 넣어서 리턴

file.write(str) #문자열 str을 파일에 쓴다.

file.writelines(list) #문자열 리스트를 파일에 쓴다. 줄바꾸기가 자동으로 삽입되지는 않음

file.seek(offset[,whence]) #whence의 기본값은 0. (0: 시작기준, 1:현재위치, 2:끝기준)

#offset만큼 떨어진 위치에 파일 포인터 위치

file.tell() #파일의 현재 위치를 리턴

file.flush() #버퍼가 다 채워지지 않았어도 내부 버퍼의 내용을 파일에 보낸다.

file.fileno() #file객체의 파일 기술자(File Descriptor)(정수)를 리턴

file.isatty() #만일 file객체가 tty와 같은 장치이면 1 아니면 0을 리턴

file.truncate([size]) #파일 크기를 지정된 크기로 잘라 버림. 인수를 주지 않으면 현재 위치에서 자름

[파일 객체 속성]

file.closed #file이 close 되었으면 1, 아니면 0

file.mode #파일이 오픈된 모드

file.name #open() 할 때 사용된 파일 이름

file.softspace #1이면 print문을 사용할 때 값 출력 사이에 자동적으로 스페이스 출력됨.

#0이면 스페이스가 자동으로 삽입되지 않음

[표준 입.출력 방향 전환]

import stys

sys.stdout #표준 출력

sys.stderr #표준 에러

sys.stdin #표준 입력

sys.stdout = f = StringIO.StringIO() #출력 파일 방향 전환

s = f.getvalue() #내부 문자열 가져오기

f = StringIO.StringIO(s) #문자열 객체에서 파일 객체 얻어내기

[지속모듈 -DBM]

#사전 자료형과 사용법 유사

#키와 값은 반드시 문자열이어야

import anydbm

f = anydbm.open('music', 'c') #'c'는 파일이 없으면 생성하고 읽기로 오픈

[지속모듈-피클링] #임의의 파이선 객체 저장

import pickle

pickle.dump(출력할 객체, 파일 객체) #객체를 파일로 출력

object = pickle.laod(파일 객체) #객체에서 파일 읽어 들임

#문자열로 객체를 출력, 문자열에서 객체 읽어들이려면.. dumps, loads

s = pickle.dumps(출력할 객체) #출력할 객체 피클링

object = pickle.load(s) #언픽클링

※출처 : 프리렉 파이썬_이강성 저 

이 문서는 파이썬 2점대를 기준으로 작성되었습니다.

8장 객체의 복사 및 형 변환

[copy 모듈을 이용한 객체 복사]

import copy

y = copy.copy(x) #얕은 복사

y = copy.deepcopy(x) #깊은 복사

[수치형변환 - 1)정수형 변환]

int(1.1) #1 #내장함수 int()

rount(1.1) #1.0 #반올림하여 정수형의 실수취함

import math

math.floor(1.1) #1.0 #내림연산

math.ceil(1.1) #2.0 #올림 연산

[수치형변환 - 2)실수, 롱형으로의 형 변환]

float(10) #10.0 #실수형으로 변환

long('1234') #1234 #롱형 정수로 변환

complex(1, 3) #(1+3j) #복소수 형으로 변환

[시퀀스 자료형 변환]

list('abcd') #list() 리스트로 변환

tuple('abcd') #tuple() 튜플로 변환

[문자열로의 형 변환]

str([1,2,]) #비형식적인 문자열 변환

repr([1,2]) #형식적인 문자열 변환

eval('[1, 2]') #[1,2] #문자열 '[1,2]' 로부터 역으로 리스트 생성

#eval은 문자열로 된 표현식을 실행하는 내장함ㅅ

[문자열 요소를 가지는 리스트나 튜플을 문자열로 변환]

L = ['Pyton', 'is', 'the', 'first', 'language']

' '.join(L) #문자열로 합침

[리스트, 튜플, 사전의 변환]

사전 -> 리스트

D = {1:'one', 2:'two'}

D.key() #키값 리스트로

D.value() #value값 리스트로

D.items() #[(key, value) ...]

리스트 ->사전

key = ['a', 'b']

value = [1,2]

D =dict( zip(key, values))

[문자변환]

chr(97) #ascii ->문자

ord('a') #문자->ascii

[진수변환]

int('64', 16) #16진수 '64'를 10진수로

int('144', 8) #8진수 '144'를 10진수로

int('101111', 2) #2진수 '101111'을 10진수로

int('14', 5) #5진수 '14'를 10진수로

hex(100) #10진수를 16진수로

oct(100) #10진수를 8진수로

[정수를 콤마가 있는 문자열로 변환]

import locale

locale.setlocale(locale.LC_ALL, "") #사용자 기본환경으로 설정

print locale.format("%d", 10030405, 1) #'10,030,405’

※출처 : 프리렉 파이썬_이강성 저 

[ 참고 ] 파이썬 정리 포스팅들 

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

[파이썬] python 문자열 함수정리

[파이썬] python 리스트 함수정리

[파이썬] python 튜플 함수정리

[파이썬] python 정규식 정리

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

이 문서는 파이썬 2점대를 기준으로 작성되었습니다.

7장 사전 및 집합

[사전 객체 생성 방법 - zip사용]

key = ['one', 'two', 'three'] #시퀀스 자료형이면 ok

values = (1,2,3)

zip(keys, values) #zip은 자료를 순서대로 묶어준다. 사전의 items()출력과 동일

dict(zip(keys, values)) #{'three':3, 'two':2, 'one':1}

[사전 객체의 메소드]

D.keys() #사전에서 키들을 리스트로 리턴

D.values() #값들을 리스트로 리턴

D.items() #(key, value)리스트 리턴

key in D #멤버십 테스트. D가 key를 가지고 잇으면 True

D.clear( ) #사전 D의 모든 아이템 삭제

D.copy() #사전 복사(Shallow copy)

D.get(key [,x]) #값이 존재하면 D[key], 아니면 x 리턴

D.setdefault(key [,x]) #get과 같으나 값이 존재하지 않을 때 값을 설정(D[key] = x)

D.update(b) #for k in b.keys(): D[k] = b[k]

D.popitem() # (키, 값) 튜플을 리턴하고 사전에서 항목을 제거한다.

D.pop(key) #key항목의 값을 리턴하고 사전에서 제거한다.

[집합자료형_set, frozenset 공통함수]t #순서 없는 자료형

len(s) #원소의 수

x in s #x가 집합 s의 원소인가?

x not in s #x가 집합 s의 원소가 아닌가?

s.issubset(t) #s가 t의 부분집합?

s.issuperset(t) #s가 t의 포함집합?

s.union(t) s | t #새로운 s와 t의 합집합

s.intersection(t) #새로운 s와 t의 교집합 s & t

s.difference(t) #새로운 s와 t의 차집합 s - t

s.symmetric_difference(t) #새로운 s와 t의 배타집합 s ^ t

s.copy() #집합 s를 얕은 복사

list(a) #시퀀스 (리스트 형으로 변환)

tuple(a) #튜플으로 변환

[집합자료형_set 자료형만 가능한 연산]

s.update(t) #s와 t의 합집합을 s에 저장

s.intersection_update(t) #s와 t의 교집합을 s에 저장

s.difference_update(t) #s와 t의 차집합을 s에 저장

s.symmetric_difference_update(t) #s와 t의 배타집합을 s에 저장

s.add(x) #원소 x를 s에 추가

s.remove(x) #원소 x를 s에서 제거: 없으면 Key Error 예외 발생

s.discard(x) #원소 x가 있다면 s에서 제거

s.pop() #s에서 임의의 원소를 하나 리턴하고 집합에서는 제거; 빈 집합이면 KeyError 예외 발생

s.clear() #집합 s의 모든 원소 삭제

 ※출처 : 프리렉 파이썬_이강성 저 

[ 참고 ] 파이썬 정리 포스팅들 

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

[파이썬] python 문자열 함수정리

[파이썬] python 리스트 함수정리

[파이썬] python 튜플 함수정리

[파이썬] python 정규식 정리

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

이 문서는 파이썬 2점대를 기준으로 작성되었습니다.

6장 튜플 

L = list(T) #tuple->list

T = tuple(L) #list->tuple

[경로명 다루기 - os.path]

>>>import os

p = os.path.abspath('t.py') #상대 경로 -> 절대경로

os.path.exists(p) #파일의 존재여부

os.path.getsize(p) #파일 크기

os.path.split(p) #(head, tail)로 분리. (디렉토리명, 파일명)

os.path.join('c:\\work', 't.hwp') #디렉토리와 파일명 결합

os.path.normpath('c:\\work\\.\\t.hwp') #파일명 정규화

os.path.splitext('c:\\work\\t.hwp') #('c:\\work\\t', '.hwp')

os.linesep #파일의 라인분리문자 ( 윈도우:'\r\n', 유닉스:'\n', 맥킨토시 : '\r')

os.sep #경로명에서 각 요소 분리 (윈도우 :'\', 유닉스:'/', 매킨토시 : ':')

os.pathsep #경로명과 경로명을 구분해 주는 문자 (윈도우 ';' 유닉스 ':')

os.curdir #현재 디렉토리를 나타내는 문자, (윈도우, 유닉스 : '.' , 매킨토시 : ':')

os.pardir #부모 디렉토리를 나타내는 문자 (윈도우 유닉스 : '..", 매킨토시 '::')

[URL 다루기]

import urlparse

urlparse(urlstring[, default_scheme[, allow_fragments]]) #url을 분리하여 튜플 리턴

u = urlparse.urlparse(a)

#(addressing scheme, network location, path, parameters, query, fragment identifier)

urlparse.unurlparse(u) #튜플로 된 성분들을 하나의 url로 역변환

urljoin(base, url[, allow_fragments]) #기본 URL과 상대 URL을 연결하여 절대 URL 생성

※출처 : 프리렉 파이썬_이강성 저 

[ 참고 ] 파이썬 정리 포스팅들 

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

[파이썬] python 문자열 함수정리

[파이썬] python 리스트 함수정리

[파이썬] python 튜플 함수정리

[파이썬] python 정규식 정리

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

이 문서는 파이썬 2점대를 기준으로 작성되었습니다.

5장 리스트

del a[0] #리스트 삭제

[리스트 메소드]

[스택]

s.append(60) #push

s.pop() #pop

[큐]

s.append(60) #inqueue

s.pop(0) #dequeue

cmp : 내장함수를 이용하여 정렬할 순서를 결정한다.

cmp(a, b)

[역순정렬]

L.sort(reverse=True)

L.sort() #리턴되는 값은 없다. L 자체가 sorting

newList = sorted(L) #L은 변경내용이 없고, 새로운 리스트가 리턴

L.reverse() #순서 뒤집기

[명령행 인수 얻기]

import sys

print sys.argv #인수들의 리스트

[명령행 옵션 처리]

import getopt

optlist, args = getopt.getopt(인수리스트, 옵션문자) # optlist('-a', '') # args # ['spam', 'and', 'ham']

옵션문자에 : 가 사용되면 옵션에 추가 인수 받아들임

[array 모듈] #표준모듈

배열만들기 함수 사용

array(typecode [, initializer]) # 새 배열 생성

[디렉토리 파일 목록 얻기]

? : 임의의 문자 1개와 매칭

* : 임의 개수(0개 포함)의 모든 문자와 매칭

[...] : 괄호 안의 임의의 1개 문자와 매칭

>>> import glob

>>> glob.glob('./[0-9].*')

>>> glob.glob('*.gif')

[파일의 추가 정보 알아내기]

isfile(path) - path가 일반파일이면 True 리턴

isdir(path) - path가 디렉토리(폴더)이면 True 리턴

islink(path) - path가 심볼릭 링크이면 True 리턴

ismount(path) - path 가 마운트 포인트이면 True 리턴(unix)

axists(path) - path가 존재하면 True 리턴

>>> import glob

>>> import os

>>> os.path.getsize('t.py') #파일의 크기를 얻는다.

>>> import time

>>> t = os.path.getatime('t.py') #파일의 최근 접근 시간을 얻음

>>> t #리턴되는 숫자는, 기준 시간(1970년 1월 1일 자정)부터 현재까지 경과한 초.

>>> time.ctime(t) # 문자열 시간으로 변환

>>> time.ctime(os.path.getmtime('t.py')) #파일의 수정(modified)시간

※출처 : 프리렉 파이썬_이강성 저 

[ 참고 ] 파이썬 정리 포스팅들 

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

[파이썬] python 문자열 함수정리

[파이썬] python 리스트 함수정리

[파이썬] python 튜플 함수정리

[파이썬] python 정규식 정리

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

이 문서는 파이썬 2점대를 기준으로 작성되었습니다.

4장 문자열

[문자열 대치 기능]

>>>import string

t = string.Template('$page: $title')

t.substitute({'page':2, 'title' : 'The Best of Times'})

t.safe_substitute({'page':2}) #누락된 key에 대해 Error 없음.

[문자열 메소드 - 1)대. 소문자의 변환]

s.upper() #대문자로 변환

s.upper().lower() #소문자로 변환

s.swapcase() # 대문자 -> 소문자, 소문자 -> 대문자

s.capitalize() # 첫문자를 대문자로

s.title() #단어의 첫문자를을 대문자로

[문자열 메소드 - 2)검색]

s.count('like') #문자열 s에서 'like'라는 부 문자열이 발생한 횟수 리턴

s.find('like') #문자열 s에서 'like'의 옵셋 리턴.(검색), 찾는 문자열 없을 경우 -1리턴

s.find('like', 3) #문자열 3번 위치부터 검색

s.rfind('like') #find와 같지만 문자열 s의 뒤족부터 탐색

s.index('like') #문자열 s에서 'like'의 옵셋 리턴.(검색), 찾는 문자열 없을 경우 예외발생

s.rindex('like') #index와 같지만 문자열 s의 뒤족부터 탐색

s.startswitch('i like') #i like로 시작하는 문자열인가? 리턴 : True, false값

s.endwith('swimming') #swimming으로 끝나는 문자열인가? 리턴 : True, false값

s.startswitch('i like', 7) #7번째 문자열이 i like로 시작하는 문자열인가? 리턴 : True, false값

s.endwith('swimming', 0, 26) #0부터 26번째 위치 사이의 문자열이 swimming으로 끝나는가?리턴 : True, false값

[문자열 메소드 - 3)편집, 치환]

s.strip() #좌우 공백을 없앰

s.rstrip() #오른쪽 공백을 없앰

s.lstrip() #왼쪽 공백을 없앰

s.strip('<>') #'<>' 없앰

s.replace('spam', 'spam and egg') #'spam'을 'spam and egg'로 바꿈

[문자열 메소드 - 4)분리, 결합]

s.split() #공백으로 분리

s.split('and') #'and' 기준으로 분리

':'.join(s) #':'문자로 결합.

print '\n'.join(t) #줄 바꾸기로 결합

lines.splitlines() #라인 단위로 분리

s.split(':', 2) #두번만 분리

s.rsplit(':', 1) #오른쪽부터, 한번만 분리

[문자열 메소드 - 5)정렬]

s.center(60) #전체 60 문자의 가운데에 맞춘다.

s.ljust(60) #왼쪽에 맞춘다.

s.rjust(60)          #오른쪽에 맞춘다.

             #center, ljust, rjust 메소드는 채워질 문자를 선택할 수 있다.

s.center(60,'-') #공백 대신 '-'문자를 채운다.

s.ljust(60,'-')

s.rjust(60,'-')    

'1\tand\t2'.expandtabs() #탭 문자 -> 8자 공백으로

'1\tand\t2'.expandtabs(4) #탭 문자 -> 4자 공백으로

[문자열 메소드 - 6)구성 문자열 판별]

s.isdigit() # 숫자여부 파악 , 리턴 : True, False

s.isalpha() # 영문자여부 파악 , 리턴 : True, False

s.isalnum() # 숫자 혹은 영문자 여부 파악 , 리턴 : True, False

s.islower() # 소문자여부 파악 , 리턴 : True, False

s.isupper() # 대문자여부 파악 , 리턴 : True, False

s.isspace() # 공백 문자 여부 파악, 리턴 : True, False

s.istitle() # 제문 문자열 여부 파악, 리턴 : True, False

[문자열 메소드 - 7)채우기 및 자리 맞추기 문자열]

s.zfill(5) # 0으로 채워진다.

# ex)

>>>s = '123'

>>>s.zfill(5)

'00123'

>>>'goofy'.zfill(6)

'0goofy'

[string 모듈]

# 상수 정의. 임의의 문자가 어떤 구룹에 속해있는지 판별할때 유용

string.digits #'0123456789'

string.octdigits #'01234567'

string.hexdigits #'0123456789abcdefABCDEF'

string.letters #'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'

string.lowercase #'abcdefghijklmnopqrstuvwxyz'

string.uppercase #'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

string.puctuation #'!"#$%\ .....'

string.printable #인쇄가능한 문자들 모두

string.whitespace #공백 문자 모두(8진수 표현)

#ex)

>>> x = 'a'

>>> x in string.uppercase

False

[유니코드]

u'String' #유니코드 표현 문자열

unicode('한글') #유니코드 문자열로 변환

[포맷 문자열]

※출처 : 프리렉 파이썬_이강성 저 

[ 참고 ] 파이썬 정리 포스팅들 

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

[파이썬] python 문자열 함수정리

[파이썬] python 리스트 함수정리

[파이썬] python 튜플 함수정리

[파이썬] python 정규식 정리

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

이클립스에서 하둡 예제파일을 돌려보자!

예제파일 : "시작하세요 하둡 프로그래밍" 책의 예제를 사용하였다!

* 하둡설치

 http://hadoop.apache.org/

* 이클립스 설치 

 http://www.eclipse.org

* 이클립스 환경설정

1. [New] - [Java Project]로 일반적인 자바 프로젝트 생성.

2. 생성한 프로젝트에 마우스 오른쪽 버튼 클릭 [Properties] - [Java Build Path] - [Add External JARs] 클릭

3. 설치한 하둡에서..

C:\hadoop-1.2.1\

C:\hadoop-1.2.1\lib

아래의 jar파일 모두 import !

4. 하둡 예제 소스 투입!

5. build.xml를 자신의 hadoop 버전에 따라 수정!

이부분 수정이 필요!

6. build.xml클릭 - [Run As] - [Ant Build] 클릭!

 jar파일이 \build 폴더 하에 생겼다!

HTML로 작성된 데이터를 보던 중

&#34;를 보고 당황하던 기억이 있다.

&#로 시작하는 것은 HTML Number를 표현하는 것을 구글링 한 결과 찾을 수 있었다.

&#34;는 HTML Number로   &quot;(HTML Name) 와 같고, 

이 뜻은 double quotes 즉 따옴표이다. 

이런 Chracters의 symbol를 보기 좋게 정리한 사이트가 있어 첨부한다.

http://www.ascii.cl/htmlcodes.htm