문자열을 여러 개의 단어 경계 구분 기호를 사용하여 단어로 분할
내가 하고 싶은 일은 꽤 흔한 일이라고 생각하지만 웹에서 참고 자료를 찾지 못했다.구두점이 있는 텍스트가 있는데 단어 목록을 주세요.
"Hey, you - what are you doing here!?"
그래야 한다
['hey', 'you', 'what', 'are', 'you', 'doing', 'here']
의 Python은str.split()하나의 인수로만 작동하기 때문에 공백으로 분할한 후 구두점을 가진 단어가 모두 표시됩니다.은은생 각각?
re.pattern(패턴, 문자열[, maxsplit=0])
패턴을 기준으로 문자열을 분할합니다.캡처 괄호가 패턴에 사용되는 경우 패턴 내 모든 그룹의 텍스트도 결과 목록의 일부로 반환됩니다.maxsplit이 0이 아닌 경우 최대 maxsplit 분할이 발생하고 나머지 문자열이 목록의 마지막 요소로 반환됩니다.(비호환성 주의: 원래 Python 1.5 릴리스에서는 maxsplit은 무시되었습니다.이 문제는 이후 릴리스에서 수정되었습니다.)
>>> re.split('\W+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split('(\W+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split('\W+', 'Words, words, words.', 1)
['Words', 'words, words.']
정규 표현이 정당화된 경우:
import re
DATA = "Hey, you - what are you doing here!?"
print re.findall(r"[\w']+", DATA)
# Prints ['Hey', 'you', 'what', 'are', 'you', 'doing', 'here']
regexp를 사용하지 않고 이를 수행하는 또 다른 빠른 방법은 다음과 같이 먼저 문자를 바꾸는 것입니다.
>>> 'a;bcd,ef g'.replace(';',' ').replace(',',' ').split()
['a', 'bcd', 'ef', 'g']
이렇게 많은 답변이 있지만 질문 제목에서 요구하는 대로 효율적으로 수행할 수 있는 솔루션을 찾을 수 없습니다(대신 여러 개의 가능한 구분 기호로 분할됨). 대신, 많은 답변이 단어가 아닌 다른 것으로 분할됩니다).Python의 표준과 효율에 의존하는 제목의 질문에 대한 답변입니다.re★★★★
>>> import re # Will be splitting on: , <space> - ! ? :
>>> filter(None, re.split("[, \-!?:]+", "Hey, you - what are you doing here!?"))
['Hey', 'you', 'what', 'are', 'you', 'doing', 'here']
여기서:
[…]안에 나열된 분리기 중 하나와 일치합니다.\-은 '아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, !-로서(「문자 범위 인디케이터」(「 인디케이터로서(「문자 범위 인디케이터」와 같이)A-Z+1개 또는 복수의 딜리미터를 건너뜁니다(이것은,filter()의 구분자와 「1」의 사이에 빈 됩니다.filter(None, …)는 선두 구분자 및 후행 구분자에 의해 작성될 가능성이 있는 빈 문자열을 삭제합니다(빈 문자열에는 잘못된 부울 값이 있기 때문입니다).
★★★★★★★★★★★★★★★★★.re.split()질문 제목에서 요청한 대로 정확하게 "복수의 구분자로 구분"됩니다.
이 솔루션은 비 ASC의 문제에 더욱 면역성이 있습니다.일부 다른 솔루션에서 볼 수 있는 단어의 II 문자(ghostdog74의 답변에 대한 첫 번째 코멘트 참조).
re모듈은 Python 루프와 테스트를 "수작업으로" 수행하는 것보다 훨씬 더 효율적입니다.
다른 방법으로는 정규식을 사용하지 않고
import string
punc = string.punctuation
thestring = "Hey, you - what are you doing here!?"
s = list(thestring)
''.join([o for o in s if not o in punc]).split()
: : 사용방법string.translatePython이 가진 가장 빠른 문자열 작업입니다.
어떤 증거...
첫 번째, 느린 방법(죄송합니다 pprzemek):
>>> import timeit
>>> S = 'Hey, you - what are you doing here!?'
>>> def my_split(s, seps):
... res = [s]
... for sep in seps:
... s, res = res, []
... for seq in s:
... res += seq.split(sep)
... return res
...
>>> timeit.Timer('my_split(S, punctuation)', 'from __main__ import S,my_split; from string import punctuation').timeit()
54.65477919578552
다음, '먹다'를 사용해요.re.findall()（ ( ( ( ( ( ( ( ( 。「이것들」은 다음과 같습니다.
>>> timeit.Timer('findall(r"\w+", S)', 'from __main__ import S; from re import findall').timeit()
4.194725036621094
'마지막으로'를 사용합니다.translate:
>>> from string import translate,maketrans,punctuation
>>> T = maketrans(punctuation, ' '*len(punctuation))
>>> timeit.Timer('translate(S, T).split()', 'from __main__ import S,T,translate').timeit()
1.2835021018981934
설명:
string.translatePython의 C는 Python에 구현되어 있습니다.string.translate 는 새로운 문자열을 생성하지 않습니다.즉, 스트링 치환에 필요한 최대 속도입니다.
하지만 이 마술을 하기 위해서는 번역 테이블이 필요하기 때문에 조금 어색합니다. 수 있습니다.maketrans()편리한 기능여기서의 목적은 불필요한 모든 문자를 공백으로 변환하는 것입니다.1대 1로 대체하다.다시 말하지만 새로운 데이터는 생성되지 않습니다.정말 빠르네요!
굿 올드( old)를 합니다.split()split()기본적으로는 모든 공백 문자에 대해 작동하며 분할을 위해 함께 그룹화합니다.그 결과 원하는 단어 목록이 나타납니다. 이 은 4배 .re.findall()!
나도 비슷한 딜레마에 빠졌고 're' 모듈을 사용하고 싶지 않았다.
def my_split(s, seps):
res = [s]
for sep in seps:
s, res = res, []
for seq in s:
res += seq.split(sep)
return res
print my_split('1111 2222 3333;4444,5555;6666', [' ', ';', ','])
['1111', '', '2222', '3333', '4444', '5555', '6666']
나 regex, regex는 regex가 아니라 regex의 regex라는 다른 에 동의하고 .str.translate(...)가장 뛰어난 퍼포먼스를 발휘합니다.저의 활용 사례는 이 기능의 성능이 그다지 중요하지 않았기 때문에 그 기준에 따라 검토했던 아이디어를 추가하고 싶었습니다.
저의 주된 목표는 다른 답변의 아이디어를 하나의 솔루션으로 일반화하는 것이었습니다.이 솔루션은 정규식 단어 이상의 문자열을 포함하는 문자열에 사용할 수 있습니다(즉, 구두점 문자의 명시적 서브셋을 블랙리스트에 올립니다.화이트리스트에 올립니다).
어떤 식으로든, 어떤 식으로든, 어떤 식으로든, 어떤 식으로든, 어떤 식으로든, 어떤 식으로든 사용하는 을 고려할 수 점에 유의하십시오string.punctuation수동으로 정의된 목록 대신 사용할 수작업으로 정의된 목록.
옵션 1 - re.sub
지금까지 답이 없어서 놀랐습니다.re.sub (...)를 사용하고 있습니다.나는 그것이 이 문제에 대한 간단하고 자연스러운 접근법이라고 생각한다.
import re
my_str = "Hey, you - what are you doing here!?"
words = re.split(r'\s+', re.sub(r'[,\-!?]', ' ', my_str).strip())
솔루션에서는 을 ''로 했습니다.re.sub(...)에 inside inside inside re.split(...)퍼포먼스가 중요한 경우에는 regex를 외부에서 컴파일하는 것이 도움이 될 수 있습니다.저에게는 큰 차이가 없기 때문에 심플함과 가독성을 선호합니다.
옵션 2 - str.replace
이것은 몇 줄 더 있지만 정규식에서 특정 문자를 이스케이프할 필요가 있는지 여부를 확인할 필요 없이 확장할 수 있는 장점이 있습니다.
my_str = "Hey, you - what are you doing here!?"
replacements = (',', '-', '!', '?')
for r in replacements:
my_str = my_str.replace(r, ' ')
words = my_str.split()
str.replace를 대신 문자열에 매핑할 수 있으면 좋겠지만, 불변의 문자열로는 할 수 없다고 생각합니다.문자 리스트에 대한 매핑은 기능하지만, 모든 문자에 대해 치환을 실행하는 것은 무리인 것 같습니다.(편집:기능의 예에 대해서는, 다음의 옵션을 참조해 주세요).
옵션 3 - functools.reduce
의 경우, (Python 2의 경우),reduce할 수 functools Import는 Import를 사용합니다.
import functools
my_str = "Hey, you - what are you doing here!?"
replacements = (',', '-', '!', '?')
my_str = functools.reduce(lambda s, sep: s.replace(sep, ' '), replacements, my_str)
words = my_str.split()
join = lambda x: sum(x,[]) # a.k.a. flatten1([[1],[2,3],[4]]) -> [1,2,3,4]
# ...alternatively...
join = lambda lists: [x for l in lists for x in l]
그 후, 3개의 라이너가 됩니다.
fragments = [text]
for token in tokens:
fragments = join(f.split(token) for f in fragments)
설명.
이것이 하스켈에서 리스트 모나드로 알려진 것이다.모나드 뒤에 있는 생각은 일단 "모나드"에 들어가면 무언가가 당신을 꺼낼 때까지 모나드 안에 있다는 것입니다.예를 들어, Haskell에서 python을 매핑한다고 가정해 봅시다.range(n) -> [1,2,...,n]목록 위에 기능합니다.List일 List List in-place와 같은 .map(range, [3,4,1]) -> [0,1,2,0,1,2,3,0]이것은 맵어펜드(또는 맵펜드 등)라고 불립니다.여기서의 개념은 적용하는 작업이 있고(토큰에 분할), 적용할 때마다 결과를 목록에 참여시키는 것입니다.
하여 '이러다'를 가질 수 .tokens=string.punctuation폴트입입니니다
이 접근방식의 장점:
- 이 접근법은(순진한 regex 기반 접근법과는 달리) 임의 길이 토큰과 함께 사용할 수 있습니다(regex는 보다 고급 구문에서도 사용할 수 있습니다).
- 토큰에만 국한되지 않고 각 토큰 대신 임의의 논리를 사용할 수 있습니다.예를 들어, "토큰" 중 하나가 중첩된 괄호의 크기에 따라 분할되는 함수일 수 있습니다.
저는 re를 좋아하지만, re를 사용하지 않는 솔루션은 다음과 같습니다.
from itertools import groupby
sep = ' ,-!?'
s = "Hey, you - what are you doing here!?"
print [''.join(g) for k, g in groupby(s, sep.__contains__) if not k]
sept.__는 'in' 연산자가 사용하는 메서드입니다.기본적으로와 같다.
lambda ch: ch in sep
여기가 더 편해요.
groupby는 문자열과 함수를 가져옵니다.이 함수는 함수를 사용하여 그룹으로 문자열을 분할합니다.그래서, sept.__filen__이 바로 우리에게 필요한 것입니다.
groupby는 쌍의 시퀀스를 반환합니다.여기서 pair [0]는 함수의 결과이고 pair [1]는 그룹입니다.k가 아닌 경우'를 사용하여 구분자를 사용하여 그룹을 필터링합니다(sept의 결과).__contains__는 구분자로 True입니다).이제 각 그룹이 단어인 일련의 그룹이 있습니다(그룹은 실제로 반복 가능한 그룹이기 때문에 조인(join)을 사용하여 문자열로 변환합니다).
이 솔루션은 함수를 사용하여 문자열을 분리하기 때문에 매우 일반적입니다(필요에 따라 분할할 수 있습니다).또한 중간 문자열/목록은 생성되지 않습니다(각 그룹이 반복기이므로 조인을 제거할 수 있으며 식이 느려집니다).
두 번 교체 사용:
a = '11223FROM33344INTO33222FROM3344'
a.replace('FROM', ',,,').replace('INTO', ',,,').split(',,,')
결과는 다음과 같습니다.
['11223', '33344', '33222', '3344']
이것을 시험해 보세요.
import re
phrase = "Hey, you - what are you doing here!?"
matches = re.findall('\w+', phrase)
print matches
하면 인쇄가 .['Hey', 'you', 'what', 'are', 'you', 'doing', 'here']
Python 3에서는 PY4E - Python for Everyone 메서드를 사용할 수 있습니다.
두 가지 는 모두 방식을 할 수 .
lower,punctuation, , , , 입니다.translate. 。translate가장 미묘한 방법이라고 생각합니다.여기 의 문서가 있습니다.translate:
your_string.translate(your_string.maketrans(fromstr, tostr, deletestr))
replace replace replace replace replace replace의 replace replace replace 。
fromstr와 함께tostr지우다에 모든 .deletestr. 。fromstr★★★★★★★★★★★★★★★★★」tostr과 ""를 할 수 .deletestr파라미터는 생략할 수 있습니다.
「정지」가 표시됩니다.
In [10]: import string
In [11]: string.punctuation
Out[11]: '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'
예:
In [12]: your_str = "Hey, you - what are you doing here!?"
In [13]: line = your_str.translate(your_str.maketrans('', '', string.punctuation))
In [14]: line = line.lower()
In [15]: words = line.split()
In [16]: print(words)
['hey', 'you', 'what', 'are', 'you', 'doing', 'here']
상세한 것에 대하여는, 다음을 참조해 주세요.
re module 함수 re.split을 사용하는 대신 panda의 series.str.split 방법을 사용하여 동일한 결과를 얻을 수 있습니다.
먼저 위의 문자열로 영상 시리즈를 작성한 후 해당 영상 시리즈에 메서드를 적용합니다.
thestring = pd.Series("Hey, you - what are you doing here!?") thestring.str.split(pat = ',|-')
파라미터 pat은 딜리미터를 사용하여 분할 문자열을 배열로 반환합니다.여기에서는, 2개의 딜리미터는, |(또는 연산자)를 사용해 건네집니다.출력은 다음과 같습니다.
[Hey, you , what are you doing here!?]
Python으로 다시 배우고 있는데도 같은 것이 필요했어요.Findall 솔루션이 더 나을 수도 있지만, 제가 생각해낸 것은 다음과 같습니다.
tokens = [x.strip() for x in data.split(',')]
maketrans와 번역을 사용하면 쉽고 깔끔하게 할 수 있습니다.
import string
specials = ',.!?:;"()<>[]#$=-/'
trans = string.maketrans(specials, ' '*len(specials))
body = body.translate(trans)
words = body.strip().split()
우선, 실제로는 분할 함수에서 구두점을 구분자로 사용하는 것이 목적이라고는 생각하지 않습니다.설명에 따르면 단순히 결과 문자열에서 구두점을 제거하려고 합니다.
자주 접하는 일이지만, 통상적인 해결책에는 재검증이 필요 없습니다.
목록 이해 기능이 있는 원라이너 람다 기능:
(비밀(이행)import string
split_without_punc = lambda text : [word.strip(string.punctuation) for word in
text.split() if word.strip(string.punctuation) != '']
# Call function
split_without_punc("Hey, you -- what are you doing?!")
# returns ['Hey', 'you', 'what', 'are', 'you', 'doing']
기능(기존)
두.import string
def split_without_punctuation2(text):
# Split by whitespace
words = text.split()
# Strip punctuation from each word
return [word.strip(ignore) for word in words if word.strip(ignore) != '']
split_without_punctuation2("Hey, you -- what are you doing?!")
# returns ['Hey', 'you', 'what', 'are', 'you', 'doing']
그것은 또한 자연스럽게 수축과 하이픈으로 표시된 단어들을 그대로 남길 것이다.하실 수 있습니다.text.replace("-", " ")분할 전에 하이픈을 공백으로 변환합니다.
람다 또는 목록 이해 기능이 없는 일반 기능
보다 일반적인 솔루션(삭제할 문자를 지정할 수 있으며 목록 이해가 없는 경우)에는 다음과 같은 이점이 있습니다.
def split_without(text: str, ignore: str) -> list:
# Split by whitespace
split_string = text.split()
# Strip any characters in the ignore string, and ignore empty strings
words = []
for word in split_string:
word = word.strip(ignore)
if word != '':
words.append(word)
return words
# Situation-specific call to general function
import string
final_text = split_without("Hey, you - what are you doing?!", string.punctuation)
# returns ['Hey', 'you', 'what', 'are', 'you', 'doing']
물론 람다 함수를 지정된 문자열로 언제든지 일반화할 수도 있습니다.
지금까지 테스트한 모든 것이 어느 순간 실패했기 때문에 나는 나만의 해결책을 생각해 내야 했다.
>>> import re
>>> def split_words(text):
... rgx = re.compile(r"((?:(?<!'|\w)(?:\w-?'?)+(?<!-))|(?:(?<='|\w)(?:\w-?'?)+(?=')))")
... return rgx.findall(text)
적어도 아래의 예에서는 정상적으로 동작하고 있는 것 같습니다.
>>> split_words("The hill-tops gleam in morning's spring.")
['The', 'hill-tops', 'gleam', 'in', "morning's", 'spring']
>>> split_words("I'd say it's James' 'time'.")
["I'd", 'say', "it's", "James'", 'time']
>>> split_words("tic-tac-toe's tic-tac-toe'll tic-tac'tic-tac we'll--if tic-tac")
["tic-tac-toe's", "tic-tac-toe'll", "tic-tac'tic-tac", "we'll", 'if', 'tic-tac']
>>> split_words("google.com email@google.com split_words")
['google', 'com', 'email', 'google', 'com', 'split_words']
>>> split_words("Kurt Friedrich Gödel (/ˈɡɜːrdəl/;[2] German: [ˈkʊɐ̯t ˈɡøːdl̩] (listen);")
['Kurt', 'Friedrich', 'Gödel', 'ˈɡɜːrdəl', '2', 'German', 'ˈkʊɐ', 't', 'ˈɡøːdl', 'listen']
>>> split_words("April 28, 1906 – January 14, 1978) was an Austro-Hungarian-born Austrian...")
['April', '28', '1906', 'January', '14', '1978', 'was', 'an', 'Austro-Hungarian-born', 'Austrian']
이를 위한 또 다른 방법은 Natural Language Tool Kit(nltk)를 사용하는 것입니다.
import nltk
data= "Hey, you - what are you doing here!?"
word_tokens = nltk.tokenize.regexp_tokenize(data, r'\w+')
print word_tokens
다음의 출력이 있습니다.['Hey', 'you', 'what', 'are', 'you', 'doing', 'here']
이 방법의 가장 큰 단점은 nltk 패키지를 설치해야 한다는 것입니다.
장점은 토큰을 받으면 나머지 nltk 패키지로 많은 재미있는 일을 할 수 있다는 것입니다.
@ooboo와 같은 문제가 있어 이 주제를 발견하면 @sweakdog74는 나에게 영감을 주었다.누군가 나의 솔루션이 유용하다고 생각할지도 모른다.
str1='adj:sg:nom:m1.m2.m3:pos'
splitat=':.'
''.join([ s if s not in splitat else ' ' for s in str1]).split()
공백에 무언가를 입력하고 공백에서 분할하지 않으려면 동일한 문자를 사용하여 분할합니다.
우선, 루프내의 RegEx 조작을 실행하기 전에, 반드시 re.compile()을 사용해 주세요.이것은, 통상의 조작보다 고속으로 동작하기 때문입니다.
따라서 먼저 패턴을 컴파일한 후 작업을 수행합니다.
import re
DATA = "Hey, you - what are you doing here!?"
reg_tok = re.compile("[\w']+")
print reg_tok.findall(DATA)
여기 몇 가지 설명과 함께 정답이 있습니다.
st = "Hey, you - what are you doing here!?"
# replace all the non alpha-numeric with space and then join.
new_string = ''.join([x.replace(x, ' ') if not x.isalnum() else x for x in st])
# output of new_string
'Hey you what are you doing here '
# str.split() will remove all the empty string if separator is not provided
new_list = new_string.split()
# output of new_list
['Hey', 'you', 'what', 'are', 'you', 'doing', 'here']
# we can join it to get a complete string without any non alpha-numeric character
' '.join(new_list)
# output
'Hey you what are you doing'
또는 한 줄에 다음과 같이 할 수 있습니다.
(''.join([x.replace(x, ' ') if not x.isalnum() else x for x in st])).split()
# output
['Hey', 'you', 'what', 'are', 'you', 'doing', 'here']
갱신된 회답
2개의 문자열(분할되는 소스 문자열과 구분자의 분할 목록 문자열)을 입력으로 사용하여 분할 단어 목록을 출력하는 함수를 만듭니다.
def split_string(source, splitlist):
output = [] # output list of cleaned words
atsplit = True
for char in source:
if char in splitlist:
atsplit = True
else:
if atsplit:
output.append(char) # append new word after split
atsplit = False
else:
output[-1] = output[-1] + char # continue copying characters until next split
return output
pprzemek의 솔루션은 딜리미터가 단일 문자라고 가정하지 않고 regex를 활용하려고 하지 않기 때문에 마음에 듭니다(세퍼레이터 수가 길어지면 제대로 작동하지 않습니다).
다음은 알기 쉽게 하기 위해 위의 솔루션을 보다 읽기 쉬운 버전입니다.
def split_string_on_multiple_separators(input_string, separators):
buffer = [input_string]
for sep in separators:
strings = buffer
buffer = [] # reset the buffer
for s in strings:
buffer = buffer + s.split(sep)
return buffer
다음은 여러 개의 디미미네이터를 사용한 스플릿입니다.
def msplit( str, delims ):
w = ''
for z in str:
if z not in delims:
w += z
else:
if len(w) > 0 :
yield w
w = ''
if len(w) > 0 :
yield w
고객님의 요구에 부응하는 최선의 답변은 다음과 같습니다.
\W+이 경우에는 적합할 수 있지만 다른 경우에는 적합하지 않을 수 있습니다.
filter(None, re.compile('[ |,|\-|!|?]').split( "Hey, you - what are you doing here!?")
제 생각은 이렇습니다...
def split_string(source,splitlist):
splits = frozenset(splitlist)
l = []
s1 = ""
for c in source:
if c in splits:
if s1:
l.append(s1)
s1 = ""
else:
print s1
s1 = s1 + c
if s1:
l.append(s1)
return l
>>>out = split_string("First Name,Last Name,Street Address,City,State,Zip Code",",")
>>>print out
>>>['First Name', 'Last Name', 'Street Address', 'City', 'State', 'Zip Code']
는 음에들이 에 들어요.replace()다음 에서는 문자열에 를 모두 합니다.splitlist splitlist그 한 구분 기호 위에 있는 텍스트를 분할합니다. '아,아,아,아,아,아,아,아,아,아,아,아,아,아,아,아,아,아,아,아,아,아,아,아,아.splitlist빈 문자열인 것 같습니다.빈 문자열이 없는 단어 목록을 반환합니다.
def split_string(text, splitlist):
for sep in splitlist:
text = text.replace(sep, splitlist[0])
return filter(None, text.split(splitlist[0])) if splitlist else [text]
def get_words(s):
l = []
w = ''
for c in s.lower():
if c in '-!?,. ':
if w != '':
l.append(w)
w = ''
else:
w = w + c
if w != '':
l.append(w)
return l
사용방법은 다음과 같습니다.
>>> s = "Hey, you - what are you doing here!?"
>>> print get_words(s)
['hey', 'you', 'what', 'are', 'you', 'doing', 'here']
역방향 조작(디미터를 보관 유지)을 실시하는 경우는, 다음의 함수를 사용할 수 있습니다.
def tokenizeSentence_Reversible(sentence):
setOfDelimiters = ['.', ' ', ',', '*', ';', '!']
listOfTokens = [sentence]
for delimiter in setOfDelimiters:
newListOfTokens = []
for ind, token in enumerate(listOfTokens):
ll = [([delimiter, w] if ind > 0 else [w]) for ind, w in enumerate(token.split(delimiter))]
listOfTokens = [item for sublist in ll for item in sublist] # flattens.
listOfTokens = filter(None, listOfTokens) # Removes empty tokens: ''
newListOfTokens.extend(listOfTokens)
listOfTokens = newListOfTokens
return listOfTokens
언급URL : https://stackoverflow.com/questions/1059559/split-strings-into-words-with-multiple-word-boundary-delimiters
'source' 카테고리의 다른 글
| 어떻게 내 타입 힌트에 기능 형식을 지정할 수 있을까요? (0) | 2022.09.15 |
|---|---|
| static 키워드 inside 함수 (0) | 2022.09.15 |
| Windows: XAMPP vs WampServer vs EasyPHP vs 대체 (0) | 2022.09.15 |
| MySql TEXT 열을 인덱싱하시겠습니까? (0) | 2022.09.15 |
| MySQL로 대용량 SQL 파일 가져오기 (0) | 2022.09.14 |