๐ Python์์ ๋ ํ์ผ์ ์์ฉ์ด๋ฅผ ๋ณํฉํ์ฌ ํ์ผ ์ฒ๋ฆฌ๋ฅผ ์ฐ์ตํ๋ค
28041 ๋จ์ด algorithmsfilespythontutorial
์๋
ํ์ธ์.๐
์ด ๊ฐ์ข์์ ํ์ผ์์ ๋จ์ด๋ฅผ ์ ํํ๊ณ ๋น๊ตํ๋ฉฐ ์์ฃผ ์ฌ์ฉํ๋ ๋จ์ด๋ฅผ ์ ํ์ผ์ ํตํฉํ๋ ๊ฒ์ ๋ฐฐ์ธ ๊ฒ์
๋๋ค.
์ฐ์ต๐
์ฐ๋ฆฌ ์์ํ์.๐
์ฝ๋: ์ด ๊ฐ์ข์ ํ์๋ ๋ชจ๋ ์ฝ๋๊ฐgithub๋ก ์ ์ก๋๋ค๋ ๊ฒ์ ๊ธฐ์ตํ์ญ์์ค.
์๋ก ๋ฅผ ๊ฐ๋ฐํ๋ค / ๋ณํฉ
๋ ํ์ผ์ ๊ณตํต์ด๋ฅผ ๋ค๋ฅธ ํ์ผ์ ๋ณํฉํ๋ ํ๋ก๊ทธ๋จ
๋ณํฉ
๋ ํ์ผ์ ๊ณตํต์ด๋ฅผ ๋ค๋ฅธ ํ์ผ์ ๋ณํฉํ๋ ํ๋ก๊ทธ๋จ
View on GitHub
๋จผ์ Python ํ์ผ์ ๋ง๋ญ๋๋ค. ๊ธด ์ค๋ช
ํ์ผ ์ด๋ฆ์ ์ฌ์ฉํ ๊ฒ์
๋๋ค. merge.py
๐
ํฐ๋ฏธ๋์ ์ฌ์ฉํ์ฌ ๋ค์ ํ์ผ์ ๋ง๋ญ๋๋ค.
์ฃผ์: ๋ง์ฝ ์๋์ฐ์ฆ๋ฅผ ์ฌ์ฉํ๋ค๋ฉด ์ด ๋ช
๋ น๋ค์ ์คํ๋์ง ์์ ๊ฒ์
๋๋ค. ๋ฐ๋ผ์ ์ฝ๋ ํธ์ง๊ธฐ์ ํ์ผ ๊ด๋ฆฌ์์ ๊ฐ์ ๊ทธ๋ํฝ ์ธํฐํ์ด์ค๋ง ์ฌ์ฉํ๋ฉด ๋ชจ๋ ์์
์ ์์ฑํ ์ ์์ต๋๋ค.ํ๋ฉด, ๋ง์ฝ, ๋ง์ฝ...๐, ์๋๋ฉด Linux๐ง ๊ธด์ฅ์ ํ๊ณ ๊ฐ๋ฅํ ํ ๋จ๋ง๊ธฐ๋ฅผ ๋ฐฐ์ฐ์ธ์.
Python์ ์ฃผ๋ก CLI ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ด๊ธฐ ๋๋ฌธ์ ํฐ๋ฏธ๋์ ๋๋์ผ๋ก ์ฌ์ฉํ ๊ฒ์
๋๋ค. ๋ฐ๋ผ์ ๊ฐ๋ฅํ ํ ํฐ๋ฏธ๋์ ์ฌ์ฉํ๋ ๊ฒ์ด ์ข์ต๋๋ค.๐
touch merge.py
ํฐ์น ๋ช
๋ น์ ๋๋ ํฐ๋ฆฌ์ ๋น ํ์ผ์ ์์ฑํฉ๋๋ค. merge.py
์ด์ ํฐ๋ฏธ๋์์ ๋ํ ํธ์ง๊ธฐ๋ฅผ ํธ์ถํ๋ ค๊ณ ํฉ๋๋ค๐ฑ, ์ด ๊ฒฝ์ฐ, ๋๋ vscode๋ฅผ ์ฌ์ฉํ ๊ฒ์ด๋ค.
code ./
UNIX์์๋ (๋๋ ค์ํ์ง ๋ง์ญ์์ค. UNIX ๊ธฐ๋ฐ ์ด์์ฒด์ , ์๋ฅผ ๋ค์ด Linux์ Mac), ./
์ ์ ํ์ฌ ๋๋ ํฐ๋ฆฌ๋ฅผ ๊ฐ๋ฆฌํจ๋ค๋ ๊ฒ์ ๊ธฐ์ตํ์ญ์์ค.
์ด์ ์ฝ๋๋ถํฐ ์์ํ๋๋ก Vscode๋ฅผ ์ค์นํ์ต๋๋ค.
ํ์ดํค์ผ๋ก ํ์ผ ์ด๊ธฐ
์ฐ์ , ์ด ๊ฐ์ข์์ ์ผ๋ถ ํ
์คํธ ํ์ผ์ ์ฌ์ฉํ ๊ฒ์
๋๋ค.github์์ ์ฝ๊ฒ ๋ค์ด๋ก๋ํ ์ ์์ต๋๋ค. ๋ฐฉ๋ฒ์ ๋ฉ๋ชจ๋ฆฌ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ๋ณต์ ํ๊ฑฐ๋ ์๋ ๋งํฌ๋ฅผ ๋ฐ๋ผ๊ฐ๋ ๊ฒ์
๋๋ค.
text_one.txt
text_two.txt
Python์์ ํจ์open
๋ฅผ ์ฌ์ฉํ์ฌ ํ์ผ์ ๊ฒฝ๋ก๋ฅผ ๋งค๊ฐ ๋ณ์๋ก ํ๋ ํ์ผ์ ์ฝ๋๋ค.
ํ
์คํธ ํ์ผ์ด ๋ค์ด๋ก๋๋์๋์ง ํ์ธํ๊ณ merge.py
ํ์ผ์ ๋ค์ ์ฝ๋๋ฅผ ์
๋ ฅํฉ๋๋ค.
file1 = open("text_one.txt)
์ด๊ฒ์ ํ์ผ ๋์์ด๊ณ ๊ธฐ๋ณธ ๋ชจ๋๋ '์ฝ๊ธฐ' ์
๋๋ค.
๋ณ์๋ฅผ ์ธ์ํ๋ ค๊ณ ํ๋ฉด ๋ค์๊ณผ ๊ฐ์ ๊ฒฐ๊ณผ๊ฐ ๋ํ๋ฉ๋๋ค.
print(file1)
# Result
# <_io.TextIOWrapper name='text_one.txt' mode='r' encoding='UTF-8'>
์ด ๋ณ์๋ "text one.txt"๋ผ๋ ํ
์คํธ ํ์ผ์ ํ์ผ ๊ฐ์ฒด์ผ ๋ฟ์ด๊ธฐ ๋๋ฌธ์
๋๋ค.
๊ทธ๋ฌ๋ ํ์ผ์ด ์กด์ฌํ์ง ์์ผ๋ฉด ์ค๋ฅ๊ฐ ๋ฐ์ํ ์ ์์ผ๋ ์กฐ์ฌํด์ผ ํ๋ค๐ฑ.
file1 = open("text_oness.txt")
# FileNotFoundError: [Errno 2] No such file or directory: 'text_oness.txt'
๊ทธ๋์ ๋งค๋ฒ ํ์ผ์ ์ฒ๋ฆฌํ ๋, ์ฐ๋ฆฌ๋ ํ์ผ์ด ์กด์ฌํ์ง ์๋ ์ํฉ์์ ์ค๋ฅ๊ฐ ๋ฐ์ํ์ง ์๋๋ก ๋ฐฉ์ด ํ๋ก๊ทธ๋๋ฐ์ ์ฌ์ฉํด์ผ ํ๋ค
try:
file1 = open("text_oness.txt")
except FileNotFoundError:
print("Sorry that file doesn't exist")
exit()
์ฐ๋ฆฌ๊ฐ file1
ํจ์๋ฅผ ์ฌ์ฉํ๋ ์ด์ ๋ ํ์ผ์ด ์กด์ฌํ์ง ์์ผ๋ฉด ์ฌ์ฉํ ์ ์๋ ๋ณ์๊ฐ ์๊ธฐ ๋๋ฌธ์ ์ด ๊ฒฝ์ฐ ์คํ์ ์ค์งํ ๊ฒ์
๋๋ค.
ํ์ดํค์ผ๋ก ํ์ผ์ ๋ด์ฉ์ ๊ฐ์ ธ์ค๋ ค๋ฉด exit()
ํจ์๋ฅผ ์ฌ์ฉํ๋ฉด ์ด๋ฆ์ด ๋งํ ๋๋ก ํ์ผ์ ๋ด์ฉ์ ์ฝ์ ์ ์์ต๋๋ค.
print(file1.read())
# Results
# Why should you learn to write programs?
# Writing programs (or programming) is a very creative
# and rewarding activity. MORE TEXT .....
ํ์ผ์ ์ด๊ณ ์ฝ๋ ๋ฐฉ๋ฒ์ ์๊ณ ์๋ค๋ฉด ๋น๊ต ๊ธฐ๋ฅ์ ๋ง๋ค ์ ์์ ๊ฒ์
๋๋ค.
์ฐ์ ์ด ๋ ํ์ผ์ ์ด ์ ์๋์ง ํ์ธํ์ญ์์ค.
try:
file1 = open("text_one.txt")
file2 = open("text_two.txt")
except FileNotFoundError:
print("Sorry that file doesn't exist")
exit()
ํ์ฌ ์ฐ๋ฆฌ๋ ํ์ผ์ ๋ด์ฉ๊ณผ ์งํฉ ๋ฅ๋ ฅ์ ์ฌ์ฉํ์ฌ ๋ชจ๋ ํ์ผ์ ๋ชจ๋ ๋จ์ด๋ฅผ ์ป์ ๊ฒ์ด๋ค.
ํ์ดํค์ ์งํฉ
Python์ ์งํฉ์ ๋ฌด์ง์ํ ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ก ๋งค์ฐ ํน์ํ ํน์ฑ์ ๊ฐ์ง๊ณ ์์ผ๋ฉฐ, ์ค๋ณต ์์๋ฅผ ํ์ฉํ์ง ์๋๋ค๐คซ.
์ฐ๋ฆฌ๋ ๋ฐ๋ณต๋์ง ์๋ ์ํฉ์์ ๋จ์ด๋ฅผ ์ป์ ์ ์๋๋ก ๊ทธ๊ฒ๋ค์ ์ฌ์ฉํ ๊ฒ์ด๋ค.
Python์์ ์งํฉ ๋ง๋ค๊ธฐ
ํ์ดํค์ ์งํฉ์ ๋ง๋ค๊ธฐ ์ํด์ {file_object}.read()
ํจ์๋ฅผ ์ฌ์ฉํฉ๋๋ค.
empty_set = set()
์ปฌ๋ ์
๋ฐ ๋ชฉ๋ก:
mylist = list("122333")
myset = set("122333")
print(mylist)
print(myset)
# List:
# ['1', '2', '2', '3', '3', '3']
# Set
# {'3', '2', '1'}
๋ณด์๋ค์ํผ ๋ชฉ๋ก์ ๋ชจ๋ ์์๋ฅผ ์์๋๋ก ์ธ์ํ์ง๋ง ์งํฉ์ ์ค๋ณต๋์ง ์๊ณ ์์๊ฐ ์๋ ์์๋ง ์ธ์ํฉ๋๋ค.
ํ์ผ์ ํ
์คํธ ๊ฐ์ ธ์ค๊ธฐ
์ฐ๋ฆฌ๋ for๋ฅผ ์ฌ์ฉํ์ฌ ํ์ผ์ ๋จ์ด๋ฅผ ์ํํด์ ๋ชจ๋ ํ์ผ์ ์งํฉ์ ์ถ๊ฐํ ๊ฒ์
๋๋ค.
file1_words = set()
file2_words = set()
for word in file1.read().split():
file1_words.add(word.lower())
for word in file2.read().split():
file2_words.add(word.lower())
print(file1_words)
print(file2_words)
์์ ์ฝ๋๊ฐ ์ข ๊ณคํน์ค๋ฌ์ธ์ง ๋ชจ๋ฅด์ง๋ง, ๋นจ๋ฆฌ ๋ด
์๋ค.
์ฐ์ ์ฐ๋ฆฌ๋ ๋ ๊ฐ์ ์งํฉ์ ์ด๊ธฐํํ๋ค. ํ๋๋ ์ฒซ ๋ฒ์งธ ํ์ผ์ ์ฌ์ฉ๋๊ณ , ๋ค๋ฅธ ํ๋๋ ๋ ๋ฒ์งธ ํ์ผ์ ์ฌ์ฉ๋๋ค.
๊ทธ๋ฆฌ๊ณ ์ฐ๋ฆฌ๋ for ์ํ์ ์ฌ์ฉํ์ฌ ๊ต์ฒด๋ฅผ ํ๊ณ ํธ์ถset()
์ ํตํด ํ์ผ์ ๋ชจ๋ ๋จ์ด๋ฅผ ๊ต์ฒดํฉ๋๋ค.
์ด ๋ถ๋ถ์์ ์ฐ๋ฆฌ๋ ๋ฐฉ๋ฒfile1.read().split()
์ ์ฌ์ฉํ๋ค. ํ์ผ์ ๋ด์ฉ์ ๋ฌธ์์ด๋ก ์ ๊ณตํ ๋ค์์ ๋ฌธ์์ด ๋ฐฉ๋ฒread()
์ ์ฌ์ฉํ๋ค. ์ด๊ฒ์ ๋น์นธ๋ง๋ค ๋ฌธ์์ด์ ๋๋์ด ํ์ผ์ ๋จ์ด ๋ชฉ๋ก์ ์ ๊ณตํ๋ค.
๊ทธ๋์ ์ฐ๋ฆฌ๋ ๊ธฐ๋ณธ์ ์ผ๋ก ์ค๋ณตํ๋ค.
for word in list_of_words_of_the_file:
code...
๊ทธ๋ฆฌ๊ณ ์ฐ๋ฆฌ๋ ์ด ๋จ์ด๋ฅผ ๋ฐ์์ ๋จ์ด๊ฐ ์ค๋ณต๋์ง ์๋๋ก ์๋ฌธ์๋ก ์จ์ split()
์งํฉ์ ์ถ๊ฐํ๋ค.ํ ์งํฉ์ ์ค๋ณต๋ ์์๊ฐ ์์ ์ ์๋ค๋ ๊ฒ์ ๊ธฐ์ตํด๋ผ. ๋ง์ฝ ํ ๋จ์ด๊ฐ ์ด๋ฏธ ์งํฉ ์์ ์๋ค๋ฉด, ๊ทธ๊ฒ์ ์ถ๊ฐ๋์ง ์์ ๊ฒ์ด๋ค.
์ฐ๋ฆฌ๋ ์ด ๋ ์๋ฅ์ ๋ํด ๊ฐ์ ์ผ์ ํ๋ค.
์ด ์ฝ๋๋ฅผ ์คํํ๋ฉด ๋ ๊ฐ์ ์งํฉ์ ๋๋๋ ค์ค๋๋ค. ๋ ํ์ผ์ ๋ชจ๋ ๋จ์ด๋ฅผ ํฌํจํฉ๋๋ค.
๋์ ์
๊ทธ๋ฐ๋ฐ ํ ๊ฐ์ง ์ง๋ฌธ์ด ์์ด์. ๋์ ํ ๊ฒ์.๐ฅ ํด๊ฒฐํด.
์ด๋ค ๋จ์ด๋ค์ ํน์ํ ๋ฌธ์ฅ๋ถํธ๊ฐ ์๋ค. ์๋ฅผ ๋ค์ดfile1_words
์(on
๋์ ์๋ฌด๋ ๋ชจ๋ ๋ฌธ์ฅ๋ถํธ๋ฅผ ์ด๋ป๊ฒ ๋ฐ๊พธ๋์ง ์ฐพ์๋ด๋ ๊ฒ์ด๋ค. ๊ทธ๋ฌ๋ฉด ์ค๋ณต๋ ๋จ์ด๊ฐ ์๋๋ผ ํน์ํ ๋ฌธ์ฅ๋ถํธ๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด๋ค.
๋์๊ฒ ์ฐ๋ฝํ๊ฑฐ๋, ๋ค๊ฐ ํด๋ธ๋ค๋ฉด.
์งํฉ์ ์ฌ์ฉํ์ฌ ์์ฉ์ด์ ๊ต์ฐจํ๋ค
์ฐ๋ฆฌ๋ ์๋ก ๋ง๋ ์งํฉ์ ์์ฉ์ด๋ฅผ ์ฐพ๊ณ ์์ต๋๋ค. ์ด๋ฅผ ์ํด ๊ต์งํฉ์ ์ฌ์ฉํ ๊ฒ์
๋๋ค.
๋ค, ์ด ๋จ์ด๋ ๋ฌด์์ ๋ณด์ผ ์๋ ์์ด์. ์ํ์์ ๋ดค์ ์๋ ์์ผ๋๊น ๊ฑฑ์ ํ์ง ๋ง์ธ์.๊ต์งํฉ์ ๋จ์ง ๋ ์งํฉ์ ๊ณต๊ณต ๋ถ๋ถ์ผ ๋ฟ์ด๋ค.
๊ต์ฐจ ์์๊ฐ ์ง๋ฃจํ ์๋ ์์ด์.๐, ๋๋ถ๋ถ์ ๋ฐ์ดํฐ ๊ตฌ์กฐ์ ๋ํด ์์๋ฅผ ํฌํจํ๋ ๋ณ์๋ฅผ ๋๋ฃจ ํ์ด๋ณด๊ณ ๋น๊ตํ๊ณ ์ค๋ณต๋ ๋ณ์๋ฅผ ์ ํํ์ฌ ์๋ก์ด ๋ณ์์ ์ถ๊ฐํด์ผ ํ๊ธฐ ๋๋ฌธ์ด๋ค.
๊ทธ๋ฌ๋ ํ์ดํค์์ ์งํฉ์ด ์์ผ๋ฉด ์ฐ๋ฆฌ๋ ํน์ํ ํจ์๋ฅผ ๊ฐ์ง๊ณ ์ด ๋ชจ๋ ๊ฒ์ ์์ฑํ ์ ์๋คon
common_words = file1_words.intersection(file2_words)
print(common_words)
ํ์ฌ, ์ฐ๋ฆฌ๋ ํ ์ค์ ํ๋ก๊ทธ๋จ์์ ์ด ๋ ํ์ผ์ ์์ฉ์ด์ ์ ๊ทผํ ์ ์๋ค.
ํ์ดํค์ผ๋ก ํ์ผ ์์ฑ
ํ์ดํค์ผ๋ก ํ์ผ์ ์์ฑํ๋ ๊ฒ์ ์ด๋ ต์ง ์์ต๋๋ค.์ฐ๋ฆฌ๋ {set1}.intersection({set2})
์ฐ๊ธฐ ๋ชจ๋๋ก ํ์ผ์ ์ด์๋ค.
์ด๊ฒ์ ๊ธฐ์กด ํ์ผ์ ์ฐ๊ฑฐ๋ ํ์ผ์ด ์กด์ฌํ์ง ์๋ ์ํฉ์์ ํ์ผ ๊ฒฝ๋ก๋ฅผ ์ ํ๋ ์๋ก์ด ํ์ผ์ ๋ง๋ค ์ ์๋๋ก ํฉ๋๋ค.
๋ณํฉ ํ์ผ์ ์ฝ๋๋ค.
merge_file = open("merge.txt", mode = "w")
# code_here ....
merge_file.close()
ํ์ผ์ ์ฐ๊ธฐ ๋ชจ๋๋ก ์ด ๋๋ง๋ค ํ์ํ ์์
์ ํ ํ์ ๋ซ์์ผ ํ๋ค๋ ๊ฒ์ ๊ธฐ์ตํ์ญ์์ค.
ํ์ฌ ์ฐ๋ฆฌ๋ ๋ชจ๋ ์์ฉ์ด๋ฅผ ์ open("file/path", mode = "w")
ํ์ผ์ ์ธ ๊ฒ์ด๋ค.
merge_file = open("merge.txt", mode = "w")
for word in common_words:
word = word + ", "
merge_file.write(word)
merge_file.close()
ํ์ผ์ ๋จ์ด๋ฅผ ๊ตฌ๋ถํ๊ธฐ ์ํด ๋ชจ๋ ๋จ์ด์ ๋์ ์ผํ ๋ฌธ์์ด์ ์ถ๊ฐํด์ผ ํฉ๋๋ค.
์ด ์ฝ๋๋ฅผ ์คํํ๋ฉด ์ํ๋ ๊ฒฐ๊ณผ๋ฅผ ์ป์ ์ ์์ต๋๋ค.
try:
file1 = open("text_one.txt")
file2 = open("text_two.txt")
except FileNotFoundError:
print("Sorry that file doesn't exist")
exit()
file1_words = set()
file2_words = set()
for word in file1.read().split():
file1_words.add(word.lower())
for word in file2.read().split():
file2_words.add(word.lower())
common_words = file1_words.intersection(file2_words)
merge_file = open("merge.txt", mode="w")
for word in common_words:
word = word + ", "
merge_file.write(word)
merge_file.close()
์ merge.txt
ํ์ผ์ ๊ฒ์ฌํ๋ฉด, ํ์ผ "merge.txt"
๊ณผ text_one.txt
์ฌ์ด์ ๋ชจ๋ ์์ฉ์ด๋ฅผ ๋ณผ ์ ์์ต๋๋ค
์ถํํฉ๋๋ค.๐, ์ฝ๋ ํ์ผ์ ๋น๊ตํ๊ธฐ ์ํด ํตํฉ ์๊ณ ๋ฆฌ์ฆ์ ๋ง๋ค์์ต๋๋ค.
๊ทธ๋ฌ๋ ์ ๊น๋ง, ์ด ์ฝ๋๋ ๋งค์ฐ ๋ฌด๊ฑฐ์์ ์ฐ๋ฆฌ๋ ๋ง์ ๊ณณ์์ ๊ฐ์ ๊ณผ์ ์ ๋ฐ๋ณตํ๋ค.
๋ฐ๋ผ์ ํจ์์ ๊ฐ๋ ฅํ ๊ธฐ๋ฅ์ ์ด์ฉํ์ฌ ์ฝ๋๋ฅผ ๋ค์ ์ฌ์ฉํ ์ ์๊ณ ์ฝ๋๋ฅผ ํ์ฅํ๊ธฐ ์ฝ๋๋ก ํฉ๋๋ค.
์ฐ์ , ํ์ผ์ ์ด๊ณ ์ด์์ ์ฒ๋ฆฌํ ํจ์๋ฅผ ๋ง๋ญ๋๋ค.์ด ํจ์๋ ๋ ๊ฐ์ ๋งค๊ฐ ๋ณ์๋ฅผ ๋ฐ์๋ค์ผ ๊ฒ์
๋๋ค. ์ฒซ ๋ฒ์งธ ๋งค๊ฐ ๋ณ์๋ ํ์ผ ๊ฒฝ๋ก์ด๊ณ , ๋ ๋ฒ์งธ ๋งค๊ฐ ๋ณ์๋ ํ์ผ ์ด๊ธฐ ๋ชจ๋์ ์ ํํ ์ ์๋ ๋งค๊ฐ ๋ณ์์
๋๋ค.
# Python function that handle exception while opening files
def open_file(file_path, open_mode="r"):
try:
file_handler = open(file_path, mode=open_mode)
except FileNotFoundError:
print(f"Sorry the file {file_path} doesn't exist")
exit()
except ValueError:
print(f"Sorry the file {file_path} can't be opened with mode {open_mode}")
exit()
return file_handler
๊ทธ ๋ค์์ ํ์ผ์ ๋จ์ด๋ฅผ ํฌ์ฐฉํ๋ ํจ์์
๋๋ค.
def get_file_words(file_path):
file_words = set()
read_file = open_file(file_path)
for word in read_file.read().split():
file_words.add(word.lower())
return file_words
๋ณด์๋ค์ํผ ํ์ผ์ ๊ฒฝ๋ก๋ฅผ ๋งค๊ฐ ๋ณ์๋ก ํ๊ณ , ๋จ์ด๋ฅผ ๊ฐ์ ธ์ค๋ฉฐ, ๋ฐฉ๊ธ ๋ง๋ text_two.txt
ํจ์๋ฅผ ํตํด ํ์ผ ์ฒ๋ฆฌ ํ๋ก๊ทธ๋จ์ ๊ฐ์ ธ์ต๋๋ค.
๋ง์ง๋ง์ผ๋ก, ์์ฃผ ์ฌ์ฉํ๋ ๋จ์ด๋ฅผ ๊ฐ์ ธ์ค๊ณ ๊ต์ฐจํ๋ ๋์์ ์ํํ๊ณ , ์ด ๋จ์ด๋ค์ ํ์ผ์ ๊ธฐ๋กํ ํจ์ open_file()
๋ฅผ ๋ง๋ญ๋๋ค.
def merge(*filenames, merge_file="merge.txt"):
list_of_file_words = []
for filename in filenames:
file_words = get_file_words(filename)
list_of_file_words.append(file_words)
common_words = set.intersection(*list_of_file_words)
merge_write_file = open_file(merge_file, "w")
for word in common_words:
word = word + ", "
merge_write_file.write(word)
merge_write_file.close()
์ฌ๊ธฐ์python ํจ์์์ merge
๊ฐ๋ ฅํ ๊ธฐ๋ฅ์ ์ฌ์ฉํฉ๋๋ค. ๋ ๊ฐ ์ด์์ ํ์ผ์ ํฉ์น๋ ค๋ฉด ํจ์์ ์ฌ๋ฌ ๊ฐ์ ํ์ผ ์ด๋ฆ์ ์ ๋ฌํ ์ ์์ต๋๋ค.
๋ด๊ฐ for ์ํ์ ์ฌ์ฉํ์ฌ *args
์ธ์๋ฅผ ๊ต์ฒดํ๋ ๊ฒ์ ์ ์ ์์ต๋๋ค.์ด๊ฒ์ ์ฐ๋ฆฌ๊ฐ ํ์ฌ ์์์ ํ์ผ ์ด๋ฆ์ ๋ฐ์๋ค์ผ ์ ์๊ธฐ ๋๋ฌธ์, ์ฐ๋ฆฌ์ ํตํฉ ์๊ณ ๋ฆฌ์ฆ์ ํ์ฌ ๋์ฑ ๊ฐ๋ ฅํด์ก๋ค.
main () ํจ์์์ ์ฝ๋ ์์ถ
python์์ ๊ฐ์ฅ ์ข์ ์ค์ฒ์ผ๋ก *filename
ํจ์๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค. ์ด ํจ์๋ ์คํฌ๋ฆฝํธ๊ฐ ์คํํ๋ ๋ชจ๋ ๋์์ ํธ์ถํ๊ณ ์คํํ ์ ์์ต๋๋ค.
def main():
file1 = "text_one.txt"
file2 = "text_two.txt"
merge(file1, file2, merge_file = "main_merge.txt")
์ด ์ฃผ ํจ์๋merge ํจ์๋ฅผ ํธ์ถํ๊ณ file1๊ณผ file2 ๋ณ์๋ฅผ ๋งค๊ฐ ๋ณ์๋ก ์ ๋ฌํฉ๋๋ค.๊ทธ ๋ฐ์ ์ฐ๋ฆฌ๋ main()
๋งค๊ฐ ๋ณ์๋ฅผ ์ง์ ํ๋๋ฐ, ์ด ๋งค๊ฐ ๋ณ์๋ ํฉ๋ณ ํจ์์ ์ด๋ค ํ์ผ์ ์จ์ผ ํ๋์ง ์๋ ค ์ค๋ค.
๊ทธ๋ฌ๋ ๋น์ ์ด ์ ์ ์๋ ๋ฐ์ ๊ฐ์ด, ์ฐ๋ฆฌ๋ ์์ง ์ด๋ค ํจ์๋ ํธ์ถํ์ง ์์๊ธฐ ๋๋ฌธ์main ํจ์๋ฅผ ํธ์ถํฉ์๋ค.
if __name__ == "__main__":
main()
merge_file
๋ณ์๋ ๋ค๋ฅธ ๋ธ๋ก๊ทธ๋ฅผ ๋ฐํํ ๊ฐ์น๊ฐ ์์ง๋ง ์ฌ๊ธฐ๋python์ ๊ธฐ๋ณธ์ ์ผ๋ก ์๋ ค์ค๋ค.
touch merge.py
code ./
file1 = open("text_one.txt)
print(file1)
# Result
# <_io.TextIOWrapper name='text_one.txt' mode='r' encoding='UTF-8'>
file1 = open("text_oness.txt")
# FileNotFoundError: [Errno 2] No such file or directory: 'text_oness.txt'
try:
file1 = open("text_oness.txt")
except FileNotFoundError:
print("Sorry that file doesn't exist")
exit()
print(file1.read())
# Results
# Why should you learn to write programs?
# Writing programs (or programming) is a very creative
# and rewarding activity. MORE TEXT .....
try:
file1 = open("text_one.txt")
file2 = open("text_two.txt")
except FileNotFoundError:
print("Sorry that file doesn't exist")
exit()
empty_set = set()
mylist = list("122333")
myset = set("122333")
print(mylist)
print(myset)
# List:
# ['1', '2', '2', '3', '3', '3']
# Set
# {'3', '2', '1'}
file1_words = set()
file2_words = set()
for word in file1.read().split():
file1_words.add(word.lower())
for word in file2.read().split():
file2_words.add(word.lower())
print(file1_words)
print(file2_words)
for word in list_of_words_of_the_file:
code...
common_words = file1_words.intersection(file2_words)
print(common_words)
merge_file = open("merge.txt", mode = "w")
# code_here ....
merge_file.close()
merge_file = open("merge.txt", mode = "w")
for word in common_words:
word = word + ", "
merge_file.write(word)
merge_file.close()
try:
file1 = open("text_one.txt")
file2 = open("text_two.txt")
except FileNotFoundError:
print("Sorry that file doesn't exist")
exit()
file1_words = set()
file2_words = set()
for word in file1.read().split():
file1_words.add(word.lower())
for word in file2.read().split():
file2_words.add(word.lower())
common_words = file1_words.intersection(file2_words)
merge_file = open("merge.txt", mode="w")
for word in common_words:
word = word + ", "
merge_file.write(word)
merge_file.close()
# Python function that handle exception while opening files
def open_file(file_path, open_mode="r"):
try:
file_handler = open(file_path, mode=open_mode)
except FileNotFoundError:
print(f"Sorry the file {file_path} doesn't exist")
exit()
except ValueError:
print(f"Sorry the file {file_path} can't be opened with mode {open_mode}")
exit()
return file_handler
def get_file_words(file_path):
file_words = set()
read_file = open_file(file_path)
for word in read_file.read().split():
file_words.add(word.lower())
return file_words
def merge(*filenames, merge_file="merge.txt"):
list_of_file_words = []
for filename in filenames:
file_words = get_file_words(filename)
list_of_file_words.append(file_words)
common_words = set.intersection(*list_of_file_words)
merge_write_file = open_file(merge_file, "w")
for word in common_words:
word = word + ", "
merge_write_file.write(word)
merge_write_file.close()
def main():
file1 = "text_one.txt"
file2 = "text_two.txt"
merge(file1, file2, merge_file = "main_merge.txt")
if __name__ == "__main__":
main()
__name__
ํจ์๋ฅผ ์คํํ์ญ์์ค.def open_file(file_path, open_mode="r"):
try:
file_handler = open(file_path, mode=open_mode)
except FileNotFoundError:
print(f"Sorry the file {file_path} doesn't exist")
exit()
except ValueError:
print(f"Sorry the file {file_path} can't be opened with mode {open_mode}")
exit()
return file_handler
def get_file_words(file_path):
file_words = set()
read_file = open_file(file_path)
for word in read_file.read().split():
file_words.add(word.lower())
return file_words
def merge(*filenames, merge_file="merge.txt"):
list_of_file_words = []
for filename in filenames:
file_words = get_file_words(filename)
list_of_file_words.append(file_words)
common_words = set.intersection(*list_of_file_words)
merge_write_file = open_file(merge_file, "w")
for word in common_words:
word = word + ", "
merge_write_file.write(word)
merge_write_file.close()
def main():
file1 = "text_one.txt"
file2 = "text_two.txt"
merge(file1, file2, merge_file="merge_main.txt")
if __name__ == "__main__":
main()
๊ฒฐ๋ก :
์ด ์์ต์์์๋ ๋ค์์ ์ฐ์ตํ์ต๋๋ค.
Follow me in My blog,
to get more awesome tutorials like this one.
Please consider supporting me on Ko-fi you help me a lot to
continue building this tutorials!.
Reference
์ด ๋ฌธ์ ์ ๊ดํ์ฌ(๐ Python์์ ๋ ํ์ผ์ ์์ฉ์ด๋ฅผ ๋ณํฉํ์ฌ ํ์ผ ์ฒ๋ฆฌ๋ฅผ ์ฐ์ตํ๋ค), ์ฐ๋ฆฌ๋ ์ด๊ณณ์์ ๋ ๋ง์ ์๋ฃ๋ฅผ ๋ฐ๊ฒฌํ๊ณ ๋งํฌ๋ฅผ ํด๋ฆญํ์ฌ ๋ณด์๋ค https://dev.to/developerroad/merge-common-words-of-two-files-in-python-practice-file-handling-2oddํ ์คํธ๋ฅผ ์์ ๋กญ๊ฒ ๊ณต์ ํ๊ฑฐ๋ ๋ณต์ฌํ ์ ์์ต๋๋ค.ํ์ง๋ง ์ด ๋ฌธ์์ URL์ ์ฐธ์กฐ URL๋ก ๋จ๊ฒจ ๋์ญ์์ค.
์ฐ์ํ ๊ฐ๋ฐ์ ์ฝํ ์ธ ๋ฐ๊ฒฌ์ ์ ๋ (Collection and Share based on the CC Protocol.)
์ข์ ์นํ์ด์ง ์ฆ๊ฒจ์ฐพ๊ธฐ
๊ฐ๋ฐ์ ์ฐ์ ์ฌ์ดํธ ์์ง
๊ฐ๋ฐ์๊ฐ ์์์ผ ํ ํ์ ์ฌ์ดํธ 100์ ์ถ์ฒ ์ฐ๋ฆฌ๋ ๋น์ ์ ์ํด 100๊ฐ์ ์์ฃผ ์ฌ์ฉํ๋ ๊ฐ๋ฐ์ ํ์ต ์ฌ์ดํธ๋ฅผ ์ ๋ฆฌํ์ต๋๋ค