<jupyter_start><jupyter_text>**Python 01: Basic Syntax**파이썬의 기본적인 문법 복습 내용입니다.  다루는 내용- 기본(comment, print)- 식별자- 변수- 데이터 타입- 데이터 형변화- 연산자  1. Comment & Print  1.1 comment - 프로그래밍에서 comment(주석)이란 코드가 실행되지 않는 라인을 의미- 코드에 대한 설명을 적거나 잠시 실행시키고 싶지 않은 코드에 주석처리  - ``를 문장 앞에 붙여주거나 문장 내에 포인터를 둔 채로 `ctrl + /`를 눌러 사용<jupyter_code># a와 b변수를 선언
a = 1
b = 2
a, b<jupyter_output><empty_output><jupyter_text>1.2 print print 명령어를 사용해 화면에 괄호 안의 내용을 출력<jupyter_code>print("python")<jupyter_output>python<jupyter_text>end 인수를 지정해주면 줄바꿈 등을 설정 가능  디폴트는 줄바꿈(개행)인 `end="\n"`<jupyter_code># 줄바꿈
print("python", end="\n")  
print("python")

# tab: "\t"
print("python\tbasic\tsyntax")
print("python", end="\t"), print("programming")

# 구분하기
print("subject", end=" : "), print("python")
print("python", end=", "), print("python")<jupyter_output>python
python
python	basic	syntax
python	programming
subject : python
python, python<jupyter_text>Format`%-format`과 `str.format()`을 사용해서 print문의 형태를 쉽게 꾸밀 수 있음  (개인적으로 `.format()`이 좀 더 편리)<jupyter_code>s = "data"
n = 1
print("{}. {} science".format(n, s))
print("{number}. {st} science".format(number=n, st=s))
print('%s %s' % ('one', 'two'))
print("{} {}".format('one', 'two'))
print('%d %d' % (1, 2))
print('{} {}'.format(1, 2))
print("I eat %d apples" % 3)
print("I eat %s apples" % 'three')

number = 3; day = "three"
print("I ate %d apples. I was sick for %s days." % (number, day))
print("Product: %s, Price per unit: %f" % ("apple", 5.243))
print("Art: %5d\nPrice per unit: %8.2f" % (453, 59.058))
# %5d: 다섯자리 digit
# %8.2f: 총 여덟자리. 소수점 두자리 float
print("-----------------------------------")
print("Product: %5s, Price per unit: %.5f" % ("Apple", 5.243))
print("Product: {0:5s}, Price per unit: {1:.5f}".format("Apple", 5.243))

print("-----------------------------------")
# %-10s -> 좌측정렬 (default는 우측정렬)
print("Product: %10s, Price per unit: %10.3f" % ("Apple", 5.243))
print("Product: %-10s, Price per unit: %10.3f" % ("Apple", 5.243))     

# {>10s} -> 우측정렬 (default는 좌측정렬)
print("Product: {0:10s}, Price per unit: {1:10.3f}".format("Apple", 5.243))
print("Product: {0:>10s}, Price per unit: {1:10.3f}".format("Apple", 5.243))    
print("Product: %(name)10s, Price per unit: %(price)10.5f" % {"name":"Apple", "price":5.243})
print("Product: {name:>10s}, Price per unit: {price:10.5f}".format(name="Apple", price=5.243))<jupyter_output>-----------------------------------
Product: Apple, Price per unit: 5.24300
Product: Apple, Price per unit: 5.24300
-----------------------------------
Product:      Apple, Price per unit:      5.243
Product: Apple     , Price per unit:      5.243
Product: Apple     , Price per unit:      5.243
Product:      Apple, Price per unit:      5.243
Product:      Apple, Price per unit:    5.24300
Product:      Apple, Price per unit:    5.24300<jupyter_text>참고로 코드를 작성하다가 한 줄이 너무 길어져 보기 좋게 다음줄로 이어서 작성하고 싶을 때는 `\`를 이용  이 때 `\` 다음에 공백이 들어가지 않도록 주의<jupyter_code>print("this is good data science school!\
 this is good data science school!\
 this is good data science school!")
print("---------------------------------")
print('''this is good data science school!
this is good data science school!
this is good data science school!''')<jupyter_output>this is good data science school! this is good data science school! this is good data science school!
---------------------------------
this is good data science school!
this is good data science school!
this is good data science school!<jupyter_text>2. 식별자(Identifiers) - 변수, 함수, 클래스, 모듈, 패키지 등을 구분하기 위해서 사용되는 이름 - 규칙     - 대소문자 구분     - 사용가능 문자: 소문자(a~z)/대문자(A~Z)/숫자/특수기호(_)      - 맨 앞에 `__` 사용 지양     - 맨 앞에 숫자 사용불가     - 예약어 사용불가: print, def, class, True, False...<jupyter_code>A = 1
a = 2
A, a<jupyter_output><empty_output><jupyter_text>3. 변수 - Variable  3.1 변수 선언<jupyter_code>a = 1
b = "python"
a, b<jupyter_output><empty_output><jupyter_text>3.2 식별자의 규칙에 맞지 않는 변수 할당 식별자의 규칙에 맞지 않는 변수를 할당하여 에러가 발생하는 코드 예시<jupyter_code>abc~1 = 1  
1abc = 2    
class = 2<jupyter_output><empty_output><jupyter_text>3.3 다중할당 아래와 같이 여러 개의 변수를 한 번에 할당할 수 있음<jupyter_code>c, d = 5, "dss"
c, d
c = d = e = 3
d, c, e<jupyter_output><empty_output><jupyter_text>이 때 c, d, e는 그 값만 같은 변수들로 c를 5로 바꾸더라도 e의 값은 변하지 않음<jupyter_code>c = 5
e<jupyter_output><empty_output><jupyter_text>4. 자료형 (Data type)- number: int, float, complex(복소수)- boolean: True, False - string: str- collection    - List    - Tuple    - Dictionary    - Set  4.1 Number  4.1.1 int - 정수인 숫자 데이터 타입  - 파이썬의 버전에 따라 가능한 범위에 차이가 있음    - python 2.x: `-2**31-1 ~ 2**31`    - python 3.x: (무제한)<jupyter_code># 선언
a, b, c, d = 0, 1234, -3, +2345
a, b, c, d
type(a), type(b), type(c), type(d)<jupyter_output><empty_output><jupyter_text>4.1.2 float (실수)<jupyter_code># 선언
a, b, c, d = 0.0, 123.45, -692.66, +7921.4
print(a, b, c, d)
print(type(a), type(b), type(c), type(d))<jupyter_output>0.0 123.45 -692.66 7921.4
<class 'float'> <class 'float'> <class 'float'> <class 'float'><jupyter_text>4.1.3 complex (복소수)<jupyter_code># 선언
a = 2+ 3j
b = complex(5, -2)
type(a), a, type(b), b
a.real, a.imag, type(a.real), type(a.imag)
a + b, a * b, a / b
# 켤레복소수
a.conjugate(), b.conjugate()
abs(a), abs(b)<jupyter_output><empty_output><jupyter_text>4.2 Boolean True & False의 값을 갖는 데이터타입<jupyter_code>a, b = True, False
a, type(a), b, type(b)<jupyter_output><empty_output><jupyter_text>4.3 String  4.3.1 문자열 선언<jupyter_code>a, b = 'data', 'science'
a, b
# multiline
ms = """data
science
school"""

print(ms)
# docstring을 작성할 때 많이 사용
def test(a, b, c):
    """
    a: flaot
    b: string
    c: integer
    """
# 연산자 이용 - 문자열 반복
a = "data " * 10
a<jupyter_output><empty_output><jupyter_text>4.3.2 문자열 offset<jupyter_code>s = "abcdef"
d = "2018-04-24"
s[3], s[-2], s[1:3], d[:4], d[5:7]
# step - reverse가 가능
s[::2], s[::-1], s[::-2]<jupyter_output><empty_output><jupyter_text>4.3.3 String Method<jupyter_code>s = "data science"
s<jupyter_output><empty_output><jupyter_text>대소문자 바꾸기 (저장 x)<jupyter_code>s1 = s.upper()
s2 = s.lower()
s1, s2, s<jupyter_output><empty_output><jupyter_text>String의 첫 단어의 첫 글자만 대문자로 바꾸는 경우 - `str.capitalize()`  String의 각 단어의 첫글자만 대문자로 바꾸는 경우 - `title()` → 더 보완된 것이 `string.capwords()`<jupyter_code>s3 = "John. They're Bill's Friends From The Uk"
print(s3.capitalize())
print(s3.title())

import string
print(string.capwords(s3))<jupyter_output>John. they're bill's friends from the uk
John. They'Re Bill'S Friends From The Uk
John. They're Bill's Friends From The Uk<jupyter_text>문자열의 길이<jupyter_code>len(s)
s[:len(s)], s[:]<jupyter_output><empty_output><jupyter_text>함수 chaining<jupyter_code>s.upper().lower()
s.find("a"), s.find("test")
s.index("a")
s.index("test")
# find는 찾는 문자열이 없으면 -1을 반환하고, index는 error 메세지 출력
s.count("a"), s.count("A"), s.count("data")<jupyter_output><empty_output><jupyter_text>replace (대체하고 나서 저장되지는 않음)<jupyter_code>s.replace("a", "e")
s.split(" ")
s.split()
s = "data, science"
k = "data,science"
s.split(","), k.split(",")<jupyter_output><empty_output><jupyter_text>4.4 List  4.4.1 List 선언<jupyter_code>a = ['data', 'science', 'python', 'programming']
b = [1, 2, [3, 4]]      # 2중 리스트
c = [1, "python", True]
print(type(a), type(b), type(c))<jupyter_output><class 'list'> <class 'list'> <class 'list'><jupyter_text>4.4.2 List offset<jupyter_code>a[1], a[-2], a[:], a[::-1]<jupyter_output><empty_output><jupyter_text>4.4.3 List Mehtod<jupyter_code>a.append("jupyter notebook")
a
a.sort()
a
a[::-1]
a.reverse()
a
a.index("data")
a.remove("jupyter notebook")
a
a.insert(1, "basic syntax")
a
a.pop(), a<jupyter_output><empty_output><jupyter_text>4.4.5 List Copy- list와 dictionary에서는 copy를 통해 복사해야 함- 숫자, 문자열 데이터는 b=a로 복사해도 값만 복사<jupyter_code>a = [1, 2, 3]
b = a
a, b
a[2] = 10
a, b
c = a.copy()
a, b, c
b[2] = 100
a, b, c
d = e = [1,2,3]
d, e
d[1] = 10
d, e<jupyter_output><empty_output><jupyter_text>4.5 Tuple - 리스트와 같이 순서가 있는 데이터 타입. 하지만 변경이 불가능 - 리스트보다 메모리를 적게 사용함  4.5.1 선언<jupyter_code>a = 1,2,3,4
a
b = (1, 2, 3, 4)
b, type(b)
# tuple data는 수정이 불가능
b[1] = 5
import sys

ls = [1, 2, 3, 4, 5]
tu = (1, 2, 3, 4, 5)

print(sys.getsizeof(ls), sys.getsizeof(tu))   # byte 단위<jupyter_output>104 88<jupyter_text>4.6 Dictionary- 데이터의 순서가 없음- 여러 개의 (key: value) 쌍으로 이루어진 데이터 타입- value에 list나 dictionary가 들어갈 수도 있음  4.6.1 선언<jupyter_code>dic = {
    1:"one", 
    2:"two",
    "A":["data", "science"], 
    "숫자":1234,
}
type(dic), dic<jupyter_output><empty_output><jupyter_text>4.6.2 데이터 수정<jupyter_code>dic[1] = "하나"
dic
dic["A"]
# dic element delete
del dic[1]
dic<jupyter_output><empty_output><jupyter_text>4.6.3 Dictionary Method- keys, values, items, clear, get, copy, update<jupyter_code>dic, dic.keys(), dic.values()
dic.items()
for key, value in dic.items():
    print(key, value)
dic.clear()
dic
# 다시 dic을 만든 후에
print(dic)
print(dic.get(1))
print(dic.get(2))
dic.get(3, "no data")    # 값이 없을 때 "no data"를 출력
dic2 = dic
dic, dic2
dic[1] = "하나"
dic, dic2
dic3 = dic.copy()
dic, dic2, dic3
dic[1] = "one"
dic, dic3
# update: 존재하는 key값은 value 수정, 없는 키 값은 key & value 추가
a = {1:"a", 2:"b"}
b = {2:"c", 3:"d"}
a, b
a.update(b)
a<jupyter_output><empty_output><jupyter_text>4.7 Set- 중복되는 데이터가 없는 형태의 데이터 타입- 교집합, 합집합, 차집합과 같은 연산 가능- list data에서 중복을 제거할 때 많이 사용- 순서가 있는 데이터 타입은 아님   4.7.1 선언<jupyter_code>s = set([1, 2, 3, 4, 5, 1, 3, 5])
s, type(s)<jupyter_output><empty_output><jupyter_text>4.7.2 연산<jupyter_code>s1 = set([1, 2, 3, 4])
s2 = set([3, 4, 5, 6])

# 교집합
print(s1 & s2)
print(s1.intersection(s2))
# 합집합
print(s1 | s2)
print(s1.union(s2))
# 차집합
print(s1 - s2)
print(s1.difference(s2))<jupyter_output>{1, 2}
{1, 2}<jupyter_text>4.7.3 수정<jupyter_code># list로 바꾼 후에 수정하고 set
s = list(s)
s[0] = 10
s = set(s)
s<jupyter_output><empty_output><jupyter_text>5. 데이터 형변환- 데이터 타입을 다른 데이터 타입으로 바꾸는 것- 바꾸려는 데이터 타입에 따라서 형변환 가능 여부가 다름  5.1 문자열과 숫자<jupyter_code>s = "1234"
n = int(s)
type(s), type(n)
int(s) + 1
"1234" + "5"
s + str(n)<jupyter_output><empty_output><jupyter_text>5.2 boolean 형변환<jupyter_code>bool([]), bool([1, 2, 3])
bool(-1), bool(0)
bool(""), bool("asdf")
a, b = "", "a"
print(bool(a), bool(b))
if a:
    print("a is data")
if b:
    print("b is data")<jupyter_output>False True
b is data<jupyter_text>5.3 문자열의 리스트 형변환<jupyter_code>s = "data"
list(s)<jupyter_output><empty_output><jupyter_text>5.4 튜플과 딕셔너리 형변환  5.4.1 튜플의 딕셔너리 형변환 - 튜플은 key value 형태로 되어 있는 딕셔너리로 형변환이 가능<jupyter_code>t = (("1", "one"), (2, "둘"))
d = dict(t)
d, d.items()
tuple(d.items())
tu = ((2, "a"), (3, "b"))
tu2 = dict(tu)
tu, tu2<jupyter_output><empty_output><jupyter_text>6. 연산자- 산술연산자, 비교연산자, 할당연산자, 비트연산자, 논리연산자, 멤버연산자, 식별연산자  6.1 산술연산자: `, -, *, /, //(몫), %(나머지), **(제곱)`<jupyter_code>print(2 + 4)
print(2 - 4)
print(2 * 4)
print(5 / 2)
print(10 // 3)    # 몫
print(10 % 3)     # 나머지
print(3 ** 4)
print(2 ** 0.5)<jupyter_output>3
1
81
1.4142135623730951<jupyter_text>6.2 비교연산자: `==, !=, >, >, =>, =<`<jupyter_code>a, b = 10, 20
print(a == b) 
print(a != b)
print(a > b)
print(a < b)
print(a >= b)
print(a <= b)<jupyter_output>False
True
False
True
False
True<jupyter_text>6.3 할당연산자: `=, +=, -=, *=, /=, %=, //=, **=`<jupyter_code>a = 5
print(a)

a += 10    # a = a+ 10과 같음
print(a)

a -= 5
print(a)
a = 0
for _ in range(5):
    a += 1        
a
a *= 10
print(a)

a /= 5
print(a)

a %= 6
print(a)

a //= 2        # 몫
print(a)

a **= 3
print(a)
a = 0
for num in range(1, 6):
    a += num
print(a)<jupyter_output>15<jupyter_text>6.4 비트연산자:  `&, |, ^, ~, >`- 사용할 일은 거의 없음<jupyter_code>a = 3    # 011
b = 5    # 101

print(a & b, bin(a & b))    # 결과 1: 둘다 1이어야 1 (자릿수별로) / 0b: 2진수라는 표시
print(a | b, bin(a | b))    # 결과 7 / 0b111: 둘 중 하나가 1이면 1
print(a^b, bin(a^b))        # 결과 6: XOR 연산 - 둘다 1이면 0 / OR의 반대
# 보수연산: 보수는 0 기준으로 반대되는 수 (-1과 0 사이)
print(~a, bin(~a))      # 보수 연산 : 3의 보수는 -4
print(~b, bin(~b))      # 보수 연산 : 5의 보수는 -6
# shift 연산
print(a<<2, bin(a<<2)) # (* 2**n) . 두 자리를 왼쪽으로 이동
print(b>>1, bin(b>>1)) # (/ 2**n)   두 자리를 오른쪽으로 이동<jupyter_output>12 0b1100
2 0b10<jupyter_text>6.5 논리 연산자 (Logical Operators)- `and, or, not`<jupyter_code>print( True and True )         # 결과: True 둘다 True이므로
print( True and False )        # 결과: False - 둘다 True가 아니므로
print( True or True )          # 결과: True - True가 둘 중에 있으므로
print( True or False )         # 결과: True - True가 둘 중에 있으므로
# 이런 식으로 비교연산자와 많이 사용
print(a < b or c > d)
print(not(True and True)) 
print(not(True and False))<jupyter_output>False
True<jupyter_text>6.6 멤버 연산자 (Membership Operators) - `in, not in`<jupyter_code>a = [1,2,3,4]
print(1 in a)
print(5 in a)
print(1 not in a)<jupyter_output>True
False
False<jupyter_text>6.7 식별 연산자 (Identity Operators) `is, is not`- 숫자나 문자열의 경우는 값을 비교- 컬렉션 데이터의 경우에는 주소값을 비교<jupyter_code>a = "a"
b = a
print( a is b )
c = "a"
print( a is c )
print( a is not c )
a = [1,2,3]
b = a
print( a is b )       # 데이터가 저장되어 있는 주소가 같은지 확인

a = [1,2,3]
c = a.copy()
print( a is c )
print( a is not c )
# 리스트의 값을 비교하려면? '==' 사용
lst = [1, 2, 3, 4]
lst1 = [1, 2, 3, 4]
lst == lst1, lst is lst1<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.19874184529356942, 'fraction_numerical': 0.04799627213420317, 'mean_word_length': 3.7941176470588234, 'pattern_counts': {'":': 4, '<': 176, '<?xml version=': 0, '>': 184, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 1, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '44', 'dir': 'jupyter-structured-clean-dedup', 'id': '534517', 'license': 'MIT', 'n_tokens_mistral': 7231, 'n_tokens_neox': 7832, 'n_words': 1581, 'path': 'python_01_basic_syntax.ipynb', 'repo_name': 'hyeshinoh/Python_Study', 'size': '12876'}