StudyPython and CE

Python 기초 - 1

String

  • python에서 문자열은 변경이 불가능한 객체(immutable)

  1. Basic

    • python의 문자열은 ‘ ‘ 와 “ “ 모두 사용하며, 같이 사용할 수도 있다.
    1
    2
    3
    4
    5
    6
    7
    a = 'abcde'
    print(a)
    >> abcde

    a = "abcde"
    print(a)
    >> abcde
    • 문자열 안에 ‘와 ‘’를 같이 쓰고 싶은 경우, ‘\‘와 같이 쓰면 문자 취급을 할 수 있다.
    1
    2
    3
    4
    5
    6
    7
    b = "I said, 'I can do it!'"
    print(b)
    >> I said, 'I can do it!'

    b = "I said, \'I can do it!\'"
    print(b)
    >> I said, 'I can do it!'
    • “”” “”” 사이에 있는 모든 코드를 다 문자 취급할 수 있다(multi line).
    1
    2
    3
    4
    5
    6
    7
    8
    9
    a = """
    hello world!
    hello world!!
    hello world!!!
    """
    print(a)
    >> hello world!
       hello world!!
       hello world!!!
    • 문자열 연산도 가능하다.
    1
    2
    3
    4
    5
    6
    7
    a = 'abcd'
    b = 'efgh'
    print(a+b)
    >> abcdefgh

    print('*'*30)
    >> ******************************

    • 문자열 인덱싱 및 길이 출력이 가능하다.

    • 인덱싱 범위가 벗어난 경우, 에러가 발생한다.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    c = "abcde"
    c[0]
    >> 'a'

    c[1]
    >> 'b'

    c[10]
    >> IndexError: string index out of range

    a = "abcd"
    len(a)
    >> 4

  2. Slicing(슬라이싱)

    • [start(포함) : end(미포함)]
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    a = "abcdefghijklmnopqrstuvwxyz"
    a[1:10]
    >> 'bcdefghij'

    a[:10]
    >> 'abcdefghij'

    a[6:]
    >> 'ghijklmnopqrstuvwxyz'

    a = "I love python"
    a = a[:2] + "like" + a[6:]
    a
    >> I like python

  3. Format(포맷)

    • 형식
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    'I like the number %d and color %s' % (2, 'black') 
    >> 'I like the number 2 and color black'

    name1 = 'greg'
    name2 = 'john'
    'hi {1} my name is {0}'.format(name1, name2)
    >> 'hi john my name is greg'

    'hi {} my name is {}'.format(name1, name2)
    >> 'hi greg my name is john'

    # python3.6 이상에서만 지원되는 형식
    a = 10
    b = "abcde"
    f'value of a {a} and b is {b}'
    >> 'value of a 10 and b is abcde'
    • ‘{인덱스:<길이}’.format(값) : 부등호 방향으로 정렬 후, 공백으로 채우기
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    '{0:>10}'.format(7)
    >> '         7'

    '{0:>1}'.format(7)
    >> '7'

    '{0:<10}'.format(7)
    >> '7         '

    '{:<20}'.format(7)
    >> '7                   '

    f'{"koo":<20}'
    >> 'koo                 '
    • {인덱스:0의 개수.자릿수f}’.format(숫자): 자릿수 지정 가능
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    import math
    math.e
    >> 2.718281828459045

    '{:.2f}'.format(math.e)
    >> '2.72'

    '{:.5f}'.format(math.e)
    >> '2.71828'

    e = math.e
    f'{e:0.2f}'
    >> '2.72'

  4. 관련 함수들

    1
    2
    # 가지고 있는 함수 보기
    dir(str)

    • isdigit() : 문자열이 숫자인지 아닌지를 True 또는 False로 반환

      1
      2
      3
      a = '5'
      a.isdigit()
      >> True

    • isalpha() : 문자열이 문자인지 아닌지를 True 또는 False로 반환

    1
    2
    3
    a = '5'
    a.isalpha()
    >> False
    • count() : 해당 문자 개수 반환
    1
    2
    3
    b = 'abcbbcbbbbabbbcaaabbbbb'
    b.count('b')
    >> 15

    • strip() : 문자열 기준으로 양쪽 공백 지우기

    • lstrip() : 문자열 기준으로 왼쪽에 있는 공백 지우기

    • rstrip() : 문자열 기준으로 오른쪽에 있는 공백 지우기

    1
    2
    3
    4
    5
    6
    7
    c = '       abc'
    c.lstrip()
    >> 'abc'

    c = 'abc      '
    c.rstrip()
    >> 'abc'
    • replace() : 문자열 바꾸기
    1
    2
    3
    d = 'I like python'
    d.replace('python','C')
    >> 'I like C'

    • split() : 문자열 나누기

    • 괄호 안에 아무런 값도 넣지 않으면 공백(스페이스, 탭, 엔터 등) 기준으로 나눔

    1
    2
    3
    e = "koo_2019"
    e.split('_')
    >> ['koo', '2019']

    • join() : 문자열 삽입

    • 괄호 안에 아무런 값을 넣지 않아도 가능

    1
    2
    3
    4
    5
    6
    li = ['a', 'b', 'c', 'd', 'e']
    ''.join(li)
    >> 'abcde'

    ':'.join(li)
    >> 'a:b:c:d:e'

List

  • python에서 list는 변경 가능한 객체(mutable)

  • 자료형에 상관없이 만들 수 있다.

  1. Basic

    • C 언어에서의 정의
    1
    2
    // 같은 타입을 가진 변수들의 모임
    int arr[5] = {1, 2, 3, 4, 5}
    • python에서의 정의
    1
    2
    3
    4
    # 다양한 변수들의 모임
    # 타입이 다른 변수들을 묶을 수 있다.
    # 리스트는 대괄호로 선언한다.
    li = [1, 0.5, 'abc']

    • 인덱싱이 가능하다.

    • python에서는 음수 인덱싱이 가능하며, 뒤쪽부터 역순으로 접근한다.

    • 연산도 가능하다.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    li = [10, 20, 30, 'a', 'b', 'c']
    li[2]
    >> 30

    li[-1]
    >> 'c'

    li*2
    >> [10, 20, 30, 'a', 'b', 'c', 10, 20, 30, 'a', 'b', 'c']
    • 슬라이싱도 가능하다([start(포함):end(미포함)]).
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    li = [10, 20, 30, 'a', 'b', 'c']
    li[1:3]
    >> [20, 30]

    li[2:4] = [1]
    li
    >> [10, 20, 1, 'b', 'c']


    # 리스트 안에 리스트 넣기
    li[3] = [2]
    li
    >> [10, 20, 1, [2], 'c']

    li[2:3] = [3]
    li
    >> [10, 20, 3, [2], 'c']

    li[2] = [23]
    li
    >> [10, 20, [23], [2], 'c']

    li[2] = '23'
    li
    >> [10, 20, '23', [2], 'c']

    li[2] = 23
    li
    >> [10, 20, 23, [2], 'c']

    # 범위 안에 나누어서 넣기
    li[1:3] = '30'
    li
    >> [10, '3', '0', [2], 'c']

  2. 관련 함수들

    1
    dir(list)

    • 자료 구조는 크게 3가지로 나눈다.

      1) insert(삽입)

      2) search(검색)

      3) delete(삭제)

    1
    2
    # list 예시
    li = [10, 20, 1, 'b','c']

    1) insert 계열

    • append() : 리스트 끝에 요소 값 추가
    1
    2
    3
    li.append(100)
    li
    >> [10, 20, 1, 'b', 'c', 100]
    • insert() : 원하는 자리를 지정하여 요소 값 추가
    1
    2
    3
    li.insert(2,'a')
    li
    >> [10, 20, 'a', 1, 'b', 'c', 100]
    • extend() : 인자를 리스트로 받아 기존 리스트를 확장
    1
    2
    3
    li.extend([1, 2, 3])
    li
    >> [10, 20, 'a', 1, 'b', 'c', 100, 1, 2, 3]

    2) search 계열

    • 인덱싱
    1
    2
    li[2]
    >> 'a'
    • index() : 원하는 요소 값의 위치를 반환
    1
    2
    li.index('b')
    >> 4

    3) delete 계열

    • remove() : 원하는 요소 값 제거

      • 값이 중복될 경우, 첫번째 값만 제거

      • 반복해서 제거 가능

    1
    2
    3
    li.remove(1)
    li
    >> [10, 20, 'a', 'b', 'c', 100, 1, 2, 3]

    • pop() : 요소 값 가져오기

      • 인자를 넣지 않으면 요소 끝 자리에 있는 값을 가져옴

      • 리스트에서는 삭제

    1
    2
    3
    4
    5
    6
    7
    8
    li.pop()
    >> 3

    li.pop(2)
    >> 'a'

    li
    >> [10, 20, 'b', 'c', 100, 1, 2]

    • 정렬 함수

      • sort() : 오름차순 정렬

      • sort(reverse = True) : 내림차순 정렬

      • sorted(list) : 오름차순 정렬(기존 리스트 차순을 변경하고 싶지 않을 때 사용)

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    import random
    li = []
    for i in range(5):
       li.append(random.randint(1,10)) # 1부터 10 사이 임의의 정수
    li
    >> [4, 5, 8, 5, 9]

    li.sort()
    li
    >> [4, 5, 5, 8, 9]

    li.sort(reverse = True)
    li
    >> [9, 8, 5, 5, 4]

    li = []
    for i in range(5):
       li.append(random.randint(1,10))
    li
    >> [5, 8, 7, 10, 1]

    li_sorted = sorted(li)
    li_sorted 
    >> [1, 5, 7, 8, 10] # 변경된 리스트

    li
    >> [5, 8, 7, 10, 1] # 변경되지 않은 기존 리스트

Set

  • 집합을 표현하기 위해서 만들어진 자료구조

  • 중복의 데이터를 허용하지 않음(집합 표현)

  1. Basic

    • list는 중복의 데이터를 허용한다.
    1
    2
    3
    li = [1, 2, 3, 3, 4, 2, 4]
    li
    >> [1, 2, 3, 3, 4, 2, 4]
    • set은 중복의 데이터를 허용하지 않는다.
    1
    2
    3
    s = set([1, 2, 3, 3, 4, 2, 4])
    s
    >> {1, 2, 3, 4}
    • 문자열을 입력하여 만들 수도 있다.
    1
    2
    3
    string_set = set('abcde')
    string_set
    >> {'a', 'b', 'c', 'd', 'e'}

    • 집합 표현

      • union() : 합집합

        • ‘OR’ 연산자도 가능

      • intersection() : 교집합

        • ‘AND’ 연산자도 가능

      • difference() : 차집합

        • ‘-‘ 연산으로도 가능

      • symmetric_difference() : 대칭 차집합

        • 교집합을 뺀 나머지

        • ‘XOR’ 연산자도 가능

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    s1 = set([1, 2, 3, 4])
    s2 = set([3, 4, 5, 6])

    # 합집합
    s1.union(s2)
    >> {1, 2, 3, 4, 5, 6}

    s1 | s2 # OR 연산자
    >> {1, 2, 3, 4, 5, 6}

    # 교집합
    s1.intersection(s2)
    >> {3, 4}

    s1 & s2 # AND 연산
    >> {3, 4}

    # 차집합
    s1.difference(s2)
    >> {1, 2}

    s1 - s2
    >> {1, 2}

    s2 - s1
    >> {5, 6}

    # 대칭 차집합
    s1.symmetric_difference(s2)
    >> {1, 2, 5, 6}

    s2.symmetric_difference(s1)
    >> {1, 2, 5, 6}

    s1 ^ s2 # XOR 연산자
    >> {1, 2, 5, 6}

  2. 관련 함수들

    1
    dir(set)
    1
    2
    3
    4
    # set 예시
    s = {1, 2, 3, 4}
    s
    {1, 2, 3, 4}

    • add() : 요소 값 추가

      • 중복의 데이터를 추가하면 들어가지 않는다.
    1
    2
    3
    4
    5
    6
    7
    s.add(5)
    s
    >> {1, 2, 3, 4, 5}

    s.add(3)
    s
    >> {1, 2, 3, 4, 5}

    • update() : 요소 값 여러 개 추가

      • 중복의 데이터는 추가되지 않는다.
    1
    2
    3
    s.update([3, 4, 5, 6])
    s
    >> {1, 2, 3, 4, 5, 6}
    • remove() : 원하는 요소 값 제거
    1
    2
    3
    s.remove(6)
    s
    >> {1, 2, 3, 4, 5}
    • pop() : 임의의 요소 값을 반환한 후, 삭제
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    help(s.pop) # 임의(arbitrary)의 수 선택
    >> Help on built-in function pop:

       pop(...) method of builtins.set instance
       Remove and return an arbitrary set element.
       Raises KeyError if the set is empty.

    s.pop()
    >> 1

    s
    >> {2, 3, 4, 5}

    s = set([9, 3, 7 ,5, 4])
    for i in range(3):
       print(s.pop(), end = " ")
    >> 3 4 5

    • difference() vs difference_update()

      • difference()는 기존 리스트가 바뀌지 않음

      • difference_update()는 기존 리스트가 바뀜

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    s1 = {1, 2, 3, 4, 5}
    s2 = {3, 5}

    s1.difference(s2)
    >> {1, 2, 4} 

    s1
    >> {1, 2, 3, 4, 5} # 기존 리스트가 바뀌지 않음

    s1.difference_update(s2)
    s1
    >> {1, 2, 4} # 기존 리스트가 바뀜

Tuple

  • python에서 tuple은 변경 불가능한 객체(immutable)

  • 인덱싱으로 접근 가능

  • 요소 값 변경 불가능

  • list보다 속도가 빠름

  1. Basic

    • 튜플은 소괄호로 선언한다.
    1
    2
    3
    4
    5
    6
    7
    tu = (1, 2, 3, 4)
    tu
    >> (1, 2, 3, 4)

    tu2 = ()
    tu2
    >> ()
    • 인덱싱으로 접근 가능
    1
    2
    tu[2]
    >> 3
    • 요소 값 변경 불가능
    1
    2
    tu[2] = 5
    >> TypeError: 'tuple' object does not support item assignment

  2. 관련 함수들

    1
    dir(tu)
Share