[Python] 파이썬 변수와 표현식

# 1. 정수

i1 = 6
i2 = 8

# 2. 실수

i1 = 6
i2 = 8

# 3. 복소수

복소수일 경우 숫자 뒤에 j를 붙인다. 

i5 = 6j
i6 = 8j
 
print(i1 + i2)
print(i1 - i2)
print(i1 * i2)
print(i2 / i1)
print(i2 // i1)
print(i2 % i1)
 
print(i3 + i4)
print(i3 - i4)
print(i3 * i4)
print(i4 / i3)
print(i4 // i3)
print(i4 % i3)
 
print(i5 + i6)
print(i5 - i6)
print(i5 * i6)
print(i5 / i6)
# 복소수는 사칙연산만 가능함
# print(i5 // i6)
# print(i5 % i6)

# 4. 문자열

# 문자열은 한번 정의하면 바꿀 수 없다. (typeError)

s1 = "abcdefghijklmnopqrstuvwxyz"
 
print(s1[0])
print(s1[1])
print(s1[2])

#제일 마지막 문자열을 가져옴

python에서는 마이너스 인덱스가 존재한다. 

print(s1[-1])

#슬라이싱 : 특정 범위의 문자열을 가져온다.

print(s1[0:10])
print(s1[:10])
print(s1[:])
print(s1[0:10:2])
print(s1[-5:-1])

line 1:  0부터 9까지 문자열을 가져옴

line 2 : 0은 생략할 수 있다.

line 3 : 뒷부분을 생략하면 문자열 끝까지 가져온다.

line 4 : 한글자씩 건너 띄어서 문자열을 가져옴 (0부터 10까지 한글자씩 띄어서 문자열을 가져온다.)

line 5 : 거꾸로 가져온다. (뒤에서 첫번째부터 다섯번째 문자열을 가져온다.)

 * 맨 끝의 문자열까지 가져오려면 0이 아니라 반드시 생략해야한다.

결과 화면

abcdefghij
abcdefghij
abcdefghijklmnopqrstuvwxyz
acegi
vwxy

# 문자열을 바꾸고 싶으면 %s 를 붙인다.

(권장하지는 않는 방법 (?))

s2 = "Hello apple %s"
print(s2 % "development")
print(s2 % "project")
print(s2 % "changed string")
print(s2 % "security team")

결과 화면

Hello apple development
Hello apple project
Hello apple changed string
Hello apple security team

# 두개 이상의 문자를 넣을때는 괄호를 넣어야 한다.

s3= "%s apple %s"
print(s3 % ("Hello", "development"))

결과 화면

Hello apple development

# 중괄호를 넣는 방식으로 문자를 넣을때에는 .format이라는 메소드를 사용해서 문자를 넣는다. 

(권장하는 방법)

참고 : https://pyformat.info/

s4 = "{} apple"
print(s4.format("Hello"))

결과 화면

Hello apple

# 두개 이상의 중괄호일 때에는 매개변수를 추가해서 넣으면 됨

s5 = "{} apple {}"
print(s5.format("Hello", "Development"))

결과 화면

Hello apple Development

# {}에는 0과 1가 생략되어 있다. ({0} alticast {1}) 순서는 바꿀 수 있다.

s6 = "{1} apple {0}"
print(s6.format("Development","Hello"))

# Escaping (인용 기호 이중으로 넣을 경우)

s7 = "test"
s8 = 'exxam'
s9 = "It's "
s10 = 'It"s '

Python에서 문자열 기호는 ", 혹은 ' 가 사용된다.

"안에서는 '를, '안에서는 "기호 사용 가능하다. 

하지만 인용 기호를 이중으로 넣을땐? \를 붙여서 사용한다.

s11 = "Hello \"nice to meet you\""
print(s11);

# 코드에서 여러줄에 걸쳐서 입력할 경우는 뒤에 역슬래쉬를 넣으면 되는데, 실제적으로 출력되는 문자열은 한줄짜리임

s12 = "Hello" \
    "Python"\
    "Programming"
 
print(s12)

# 괄호를 넣으면 그냥 엔터를 쳐서 입력할 수 있음.

s13 = ("Hello"
       "Python"
       "Programming")
print(s13)

결과 화면

HelloPythonProgramming

# 실제로 개행을 출력하려면 \n 을 사용하면 됨. 

(참고 : window 에서는 \r\n을 사용함)

s14 = "Hello\nPython\nProgramming "
print(s14)

결과 화면

Hello
Python
Programming 

# 개행 문자(\n) 쓰지 않고 개행을 만드려면 " 기호 세개를 사용하면 알아서 개행으로 출력된다.

s15 = """Hello
Python
Programming!!"""
print(s15)

# capitalize 

첫번째 문자열을 대문자로 바꿔준다. 

s16 = "hello Python"
print(s16.capitalize())

결과 화면

Hello python

주의 : s16 문자열의 문자열이 대문자로 변경되어 저장되는 것이 아니라 새로운 문자로 출력만 해준다.

# center 

출력 시 중간에 문자열을 출력한다.

s16 = "hello Python"
print(s16.center(60))

line 60 60글자 사이에 문자열을 출력함

결과 화면

                        hello Python                        

# 60글자 사이에 문자열을 출력하는데, 양 사이드에 * 문자열을 채운다.

print(s16.center(60, '*'))

결과 화면

************************hello Python************************

# count

문자열 상에 어떤 문자가 몇개 사용되었는지 갯수를 새줌

s16 = "hello Python"
print(s16.count('l'))

# startswith 

첫번째 문자열이 해당 문자로 시작하는지 확인함 (true or false)

s16 = "hello Python"
print(s16.startswith('h'))
print(s16.startswith('H'))

결과 화면

True
False

# find

문자열이 몇번째부터 시작되는지 찾아줌

s16 = "hello Python"
print(s16.find("Python"))

# 못찾으면 -1을 반환함.

# 범위로 찾기

0부터 7까지 문자열에서 찾는다.

s16 = "hello Python"
print(s16.find("Python", 0, 7))

# r 을 붙이면 뒤에서부터 찾음

s16 = "hello Python"
print(s16.rfind("Python"))
print(s16.rindex("Python"))
print(s16.rfind("on"))

# index

index는 find와 같은 기능이긴 하나, 찾지 못하면 error를 반환한다.

s16 = "hello Python"
print(s16.index("python"))
print(s16.index("Python"))

결과 화면

Traceback (most recent call last):
  File "C:/Users/sy.yoon.CONIN/PycharmProjects/alticast_py/day1.py", line 2, in <module>
    print(s16.index("python"))
ValueError: substring not found
 

# isdecimal

숫자인지 아닌지 판단.

s16 = "hello Python"
print(s16.isdecimal())

# 참고 아라비아 숫자가 아닌 카로슈티 문자(?)로 숫자를 출력하고 싶을때 : \N{"[카로슈티문자]"}

i1 = 3
s2 = "\N{KHAROSHTHI DIGIT THREE}"
print(s2)
print(s2.isdigit())
print(s2.isdecimal())
s3 = "\N{WON SIGN}"
print(s3)
s3 = "\N{EURO SIGN}"
print(s3)
s3 = "\N{DOLLAR SIGN}"
print(s3)
s3 = "\u10A1C"
print(s3)

결과 화면

𐩂
True
False
₩
€
$
ႡC

line 1 : 카로슈티 문자로 3을 나타낸다.

line 4-6 : 특정 화폐단위를 출력할 수 있다.

# 알파벳 확인

s4 = "hello"
print(s4.isalnum())
s5 = "안녕하세요여러분"
print("안녕하세요여러분:", s5.isalnum())
print("안녕하세요여러분:", s5.isalpha())

모두 True 를 반환한다.

# islower, isupper 

소/대문자로 구성되어있는지 확인

s4 = "hello"
print(s4.islower())
print(s4.isupper())

# lower, upper

소/대문자로 출력

s4 = "hello"
print(s4.upper())
s6 = "HELLO"
print(s6.lower())

# isspace

공백인지 확인

s7 = "          "
print(s7.isspace())

# strip

공백 자르기

s8 = "  alpha"
print(s8.strip())
print(s8.lstrip())
print(s8.rstrip())

line 3, 4: l또는 r을 붙이면 왼쪽 또는 오른쪽 공백을 자른다.

결과 화면

alpha
alpha
  alpha

s9 = "  ******alpha*********      "
print("s9 : " , s9.lstrip())
print("s9 : " , s9.rstrip())

결과 화면

s9 :  ******alpha*********      
s9 :    ******alpha*********

# replace

문자열 바꾸기

s9 = "  ******alpha*********      "
print(s9.replace("alpha", "beta"))
s10 = "***alpha***alpha***alpha"
print(s10.replace("alpha", "beta", 2))

line 4 : 두번째 인자까지만 바꾸고 싶을때

결과 화면

  ******beta*********      
***beta***beta***alpha

# split

s11 = "11100"
print(s11.zfill(10))
print("{:*>10}".format(s11))
 
s12 = 1110000000000
print("{:#,}".format(s12))

line 2 : 10자리 0으로 채운다.

line 3 : 10자리 *으로 채운다

line 6 : 화폐자리수 쉼표로 나누기

결과 화면

0000011100
*****11100
1,110,000,000,000

# casefold

대소문자 구분 없애기

s13 = "NumberAlpha"
print(s13.casefold())

# split

문자열 자르기

문자열을 split으로 자르게 되면 해당 그분자로 리스트가 됨

a = ['a', 'b', 'c', 'd']
s1 = "a-b-c-d"
a1 = s1.split("-")
print(a1)
print(a == a1)

결과 화면

['a', 'b', 'c', 'd']
True

# rsplit

오른쪽에서 split

a = ['a', 'b', 'c', 'd']
s1 = "a-b-c-d"
a1 = s1.rsplit("-", 2)
print(a1)

결과 화면

['a-b', 'c', 'd']

# join

문자열 붙이기

a = ['a', 'b', 'c', 'd']
s1 = "a-b-c-d"
a1 = s1.rsplit("-", 2)
print(a1)
print("-".join(a1))

결과 화면

['a-b', 'c', 'd']
a-b-c-d

#5. 리스트 

파이선에는 배열이 없다

배열은 길이 수정이 불가하지만 파이선의 리스트는 사이즈를 제한하지 않으므로 유동성 있게 변동 가능하다.

l1 = []
l1.append("a")
l1.append("p")
l1.append("p")
l1.append("l")
l1.append("e")
print(l1)

결과 화면

['a', 'p', 'p', 'l', 'e']

# insert

앞에다 문자를 넣고싶으면 insert를 쓰는데, 첫번째 파라미터를 0으로 주면 insert 할때마다 요소가 뒤로 밀린다.

l1 = []
l1.append("a")
l1.append("p")
l1.append("p")
l1.append("l")
l1.append("e")
print(l1)
 
l1.insert(0, "o")
l1.insert(0, "l")
l1.insert(0, "l")
l1.insert(0, "e")
l1.insert(0, "h")
print(l1)

결과 화면

['h', 'e', 'l', 'l', 'o', 'a', 'p', 'p', 'l', 'e']

# pop

리스트의 요소 빼오기

l1 = []
l1.append("a")
l1.append("p")
l1.append("p")
l1.append("l")
l1.append("e")
l1[0] = 'Hello'
print(l1)
print(l1.pop())
print(l1)

결과 화면

['Hello', 'p', 'p', 'l', 'e']
e
['Hello', 'p', 'p', 'l']

# N번째 요소를 빼옴

print(l1.pop(2))
print(l1)

결과 화면

p
['Hello', 'p', 'l']

# copy 

문자열 복사

l1 = []
l1.append("a")
l1.append("p")
l1.append("p")
l1.append("l")
l1.append("e")
l1[0] = 'Hello'
print(l1)
l2 = l1.copy()
print(l2)

# 배열 요소[:]

copy 와 동일한 기능 ( 슬라이싱 개념)

l1 = []
l1.append("a")
l1.append("p")
l1.append("p")
l1.append("l")
l1.append("e")
l1[0] = 'Hello'
print(l1)
l2 = l1.copy()
print(l2)
l3 = l1[:]
print(l3)

# index

 list에 특정 요소가 몇번째 index 있는지 찾는다.

이때 찾으면 해당 문자열이 뒤에 있던 없던 찾고 끝낸다.

l4 = ['alpha', 'alpha', 'beta']
print(l4[0])
print(l4.index("alpha"))

결과 화면

alpha
0

# remove

리스트에 있는 요소를 지울때

l4 = ['alpha', 'alpha', 'beta']
l4.remove("alpha")
print(l4)

# count

요소가 몇개 있는지 확인

l4 = ['alpha', 'alpha', 'beta']
print(l4.count("alpha"))

# reverse

요소를 역순으로 바꿈

l4 = ['alpha', 'alpha', 'beta']
l4.reverse()
print(l4)

l5 = ['alpha', 'alpha', 'beta', 'po', 'ji', 'fffg']

l5.sort() # 역순 정렬 시 l5.sort(reverse=True)

print(l5)

l5.sort(reverse=True)

print(l5)

# 요소 합치기

l6 = [1, 2, 3, 4]
l7 = [5, 6, 7, 8]
print(l6 + l7)

# 새로운 요소에 합쳐서 넣음

l6 = [1, 2, 3, 4]
l7 = [5, 6, 7, 8]
l8 = l6 + l7
print(l8)

# extend

기존 요소에 합쳐서 넣음

l6 = [1, 2, 3, 4]
l7 = [5, 6, 7, 8]
l6.extend(l7)
print(l6)

# del

리스트 요소 지우기

l9 = [1, 2, 3, 4]
del l9[0]
print(l9)
del l9[0:2]
print(l9)

line 2 : 1번째 요소를 지운다.

line 4 : 1번째부터 2번째 요소를 지운다.

# 요소 바꾸기

l10 = [1, 2, 3, 4]
l10[0] = "Hello Apple"
print(l10)

결과 화면

['Hello Apple', 2, 3, 4]

첫번째 요소에 Hello Apple이라는 문자열 전체가 들어갔음.

H,e,l,l,o, A,p,p,l,e 각 문자열을 넣고싶을땐

l10 = [1, 2, 3, 4]
l10[: 1] = "Hello Apple"
print(l10)

결과 화면

['H', 'e', 'l', 'l', 'o', ' ', 'A', 'p', 'p', 'l', 'e', 2, 3, 4]

문자열을 특정 요소와 각각 바꾸고 싶을 땐

l10 = [1, 2, 3, 4]
l10[2:] = ["Hello", "Apple"]
print(l10)

결과 화면

[1, 2, 'Hello', 'Apple']

#특정 번째의 요소를 바꾸고 싶을때 (범위 지정)

l11 = [1,2,3,4]
l11[1:2] = [5,6,7,8]
print(l11)

결과 화면

[1, 5, 6, 7, 8, 3, 4]

# 6. 튜플 : 수정이 불가능한 리스트

리스트는 만들면 수정이 가능하다는 단점이 있음, 튜플은 수정이 불가

튜플에서 사용할 수 있는 메소드 : count, index

표현 방식

t1 = (1, 2, 3, 4)
t2 = 1, 2, 3, 4
t3 = (1,)
t4 = 1,
 
print(t1)
print(t2)
print(t3)
print(t4)

결과 화면

(1, 2, 3, 4)
(1, 2, 3, 4)
(1,)
(1,)

# 7. 사전

{'key' : 'value'} }key와 value값

# 사전적 의미를 리턴해줌

d1 = {'abc' : 'alphabet', 'banana':'fruit'}
print(d1['abc'])

결과 화면

alphabet

# key가 없으면 error 발생한다 (keyError)

d1 = {'abc' : 'alphabet', 'banana':'fruit'}
print(d1['apple'])

결과 화면

Traceback (most recent call last):
  File "C:/Users/sy.yoon.CONIN/PycharmProjects/alticast_py/day1.py", line 2, in <module>
    print(d1['apple'])
KeyError: 'apple'

# get

error 발생하지 않고 key가 없어도 찾을 수 있는 방법

d1 = {'abc' : 'alphabet', 'banana':'fruit'}
print(d1.get("apple"))

결과 화면

None

# 찾아서 없을때 출력 시키는 문구를 지정 가능하다.

d1 = {'abc' : 'alphabet', 'banana':'fruit'}
print(d1.get("abd", "default"))

결과 화면

default

# 없는 key를 만들어줌

d1 = {'abc' : 'alphabet', 'banana':'fruit'}
d1['apple'] = 'Computer Programming Network'
print(d1.get("apple"))

# 있는 key 만들면 update 됨

d1 = {'abc' : 'alphabet', 'banana':'fruit'}
print(d1.get("banana"))
d1['banana'] = "yellow"
print(d1.get("banana"))

결과 화면

fruit
yellow

# key만, value만 가져올때

d1 = {'abc' : 'alphabet', 'banana':'fruit'}
print(d1.keys())
print(d1.values())

# 둘다 가져올때

d1 = {'abc' : 'alphabet', 'banana':'fruit'}
print(d1.items())

# pop

사전의 pop은 빼낼때 인자가 반드시 있어야 함.

d1 = {'abc' : 'alphabet', 'banana':'fruit'}
print(d1.pop('abc'))
print(d1.popitem())

결과 화면

alphabet
('banana', 'fruit')

# del

d1 = {'abc' : 'alphabet', 'banana':'fruit'}
del d1['abc']
print(d1)

결과 화면

{'banana': 'fruit'}

# 사전 합치기

d1 = {'abc' : 'alphabet', 'banana':'fruit'}
# 사전 합치기
d2 = {'아무개' : 'SW개발'}
d1.update(d2)
print(d1)

결과 화면

{'abc': 'alphabet', 'banana': 'fruit', '아무개': 'SW개발'}

# 숫자로 key 넣기

d1 = {'abc' : 'alphabet', 'banana':'fruit'}
# 숫자로 key 넣기
d1[34] = 36
print(d1)

결과 화면

{'abc': 'alphabet', 'banana': 'fruit', 34: 36}

# 튜플로 사전 요소 넣기

d1 = {'abc' : 'alphabet', 'banana':'fruit'}
# 튜플로 사전 요소 넣기
d1[(1, 2)] = (1, 2)
print(d1)

결과 화면

{'abc': 'alphabet', 'banana': 'fruit', (1, 2): (1, 2)}

# 8. 집합

7 사전처럼 중괄호를 쓰지만 ":"를 사용하지 않는다.

s1 = {3, 4, 5, 6}
s2 = { 3, 4, 7, 8}
s3 = { 5, 6}
print(s1)
print(s2)
print(s3)

# update

요소 추가

s1 = {3, 4, 5, 6}
print(s1)
s1.update([10])
print(s1)

결과 화면

{3, 4, 5, 6}
{3, 4, 5, 6, 10}

# intersection

교집합

s1 = {3, 4, 5, 6}
s2 = { 3, 4, 7, 8}
print(s1.intersection(s2)) # = (s1 & s2)
print(s1 & s2)

결과 화면

{3, 4}
{3, 4}

# union

 합칩합

s1 = {3, 4, 5, 6}
s2 = { 3, 4, 7, 8}
print(s1.union(s2)) # = (s1 | s2)
print(s1 | s2)

결과 화면

{3, 4, 5, 6, 7, 8}
{3, 4, 5, 6, 7, 8}

# 차집합

s1 = {3, 4, 5, 6}
s2 = { 3, 4, 7, 8}
s3 = { 5, 6}
print(s1.difference(s2)) # = (s1 - s2)
print(s1 - s2)

결과 화면

{5, 6}
{5, 6}

# issubset

부분 집합

s1 = {3, 4, 5, 6}
s2 = { 3, 4, 7, 8}
s3 = { 5, 6}
print(s3.issubset(s1))
print(s3.issubset(s2))

line 4: s3은 s1의 교집합인가?

line 5: s3은 s2의 교집합인가?

결과 화면

True
False

# issuperset

초집합

s1 = {3, 4, 5, 6}
s2 = { 3, 4, 7, 8}
s3 = { 5, 6}
print(s1.issuperset(s3))
print(s2.issuperset(s3))

line 4 : s1은 s3의 초집합인가?

line 5 : s2는 s3의 초집합인가?

결과 화면

True
False

# 9. Bool

# 아래 변수의 타입을 메소드로 표현했다.

# 매개변수가 없기때문에 모두 거짓, false를 리턴한다.

i1 = int()
f1 = float()
j1 = complex()
s1 = str()
l1 = list()
t1 = tuple()
d1 = dict()
ss1 = set()
b1 = bool()
 
print(bool(i1));
print(bool(f1));
print(bool(j1));
print(bool(s1));
print(bool(l1));
print(bool(t1));
print(bool(d1));
print(bool(ss1));
print(bool(b1));

# 10. Byte

# 문자열 인코딩

a = "한글" .encode("utf-8")
print(a)

# 다른 서버에 데이터를 전송할때 깨지지 않고 utf-8로 전달한다.

(참고 : utf-8 포맷이 생기기전에 한국어로 ecu-kr, cpu949,  ksc5601, iso-2022-kr(국제표준)도 있었음.)

결과 화면

b'\xed\x95\x9c\xea\xb8\x80'

 b 가 의미하는 것 :Byte

a = "한글" .encode("utf-8")
b = "한글".encode("euc-kr")
#c = "한글".encode("cpu949")
d = "한글".encode("ksc5601")
e = "한글".encode("iso-2022-kr")
 
print(a)
print(b)
#print(c)
print(d)
print(e)

# encode 에서 인코딩한 방식과 동일하게 decode 해야한다.

# utf-8로 인코딩 했으면 utf-8로 디코딩 해야함

a = "한글" .encode("utf-8")
b = "한글".encode("euc-kr")
print(a.decode('utf-8'))
print(b.decode('euc-kr'))

# find

문자열 찾을때 byte로 찾아야함.

a = "한글" .encode("utf-8")
print(a.find(b"\xea"))

결과 화면

3

# 한국어로 찾을때에는

a = "한글" .encode("utf-8")
print(a.find("한".encode("utf-8")))

# 11. 데이터 타입 연산

# in & not in

데이터가 있는지 없는지 확인

s1 = "Hello World"
# 있는지 확인
print("World" in s1)
# 없는지 확인
print("world" not in s1)

# *

문자를 누적해서 출력시켜줌

s1 = "*"
print("*" * 60)
print(60 * "*")

결과 화면

************************************************************
************************************************************

# len

길이찾기 (문자열, 튜플, 사전, 집합, 리스트)

숫자에는 불가능

print(len("dsjlkdjflksjlksdjlfsjdlfksjflksjf;lskflsakjflkjsldk"))

결과 화면

51

# min & max

print(min([4, 6, 7, 3, 1, 2]))
print(max([4, 6, 7, 3, 1, 2]))

결과 화면

1
7

# 사칙연산

참고 ptrhon에는 ++가 없음

a = 1
a += 1
print(a)
a == 1
print(a)
a *= 1
print(a)
a /= 1
print(a)
a /= 1
print(a)
a %= 1
print(a)

결과 화면

2
2
2
2.0
2.0
0.0

# 비교 연산자

a = 3
b = 4
print(a < b)
a = 4
print(a <= b)

결과 화면

True
True

# 리스트의 비교 연산

a = [1, 2]
b = [1, 2]
print(a==b)

결과 화면

True

# java에서는 a와 b의 메모리 주소로 비교하기 때문에 false를 리턴하지만, 

# python에서는 리스트의 값을 비교하기 대문에 true를 리턴함