파이썬 기초를 코드로 정리하는 커밋입니다. / It's a commit that cleans up the Python basics into code.

1. 지역변수: 함수 안에서만 유효한 변수입니다.
2. 전역변수: 코드 전체에서 유효한 변수입니다.

만약 함수 안에서 선언한 지역변수와 밖에서 선언한 전역변수가 이름이 같다면 어떤 방법을 써야할까요?

-함수 안에서 선언한 지역변수가 함수 밖에서 선언된 전역변수와 이름이 같다면 함수 내에서는 '지역변수'(함수 안에서 우선)이기때문에 지역변수로 취급이 됩니다.

-함수 안에서 밖에서 선언한 지역변수를 이용하려면 "global"키워드를 사용하면 됩니다.

1. Local variable: This is a variable that is only valid inside a function.
2. Global variable: This is a valid variable throughout the code.

If a local variable declared in a function and a global variable declared outside have the same name, what method should be used?

-If the local variable declared in the function has the same name as the global variable declared outside the function In a function, it is treated as a local variable because it is a'local variable' (priority in the function).

-If you want to use local variables declared outside of the function, you can use the keyword "global".

파이썬에서 CLass를 정의하는방법은 밑에와 같습니다

class Cat:
  def meow(self): #meow() 메소드 정의입니다
  print('야옹 야옹')
  
cat1 = Cat() #인스턴스 생성
cat1.meow() #메소드 호출 

위에처럼 하시면 출력값은 결국 '야옹 야옹' 으로 출력이 되는데요. Class는 두가지로 나눌수 있습니다.

#클래스 정의

Class ClassName:
  '''인스턴스 변수와 메소드 구현'''
  
  #인스턴스 생성과 메소드 호출
    cat1 = Cat() #Cat인스턴스 생성 cat1이 이것을 창조했습니다.
    cat1.meow() #Cat가 구현한 메소드 호출입니다.

위에처럼 파이썬 Class는 두가지로 나눠서 실행을 할수가 있구요. 가끔 이럴때가 있습니다. 같은 class를 두번 사용해야하는경우 그러면 어떻게 해야할까요? 단지 그냥 Class 를 두번 생성해서 메소드 호출을 두번이나 해야할까요? 정답은 아닙니다. 그러면 어떻게 두번을 출력시킬수 있느냐?

Class ClassName:
  '''인스턴스 변수와 메소드 구현'''
    cat1 = Cat() 
    cat1.meow()
    cat2 = Cat()
    cat2.meow()

위에 코드처럼 하시면 됩니다. 그러면 출력값은 제가 정해둔 메소드로 출력이 두개가 되구요.

Class Person:
  def info(self):
  self.name = "현준"
  self.age = 17 (int라서 따옴표 안붙입니다.)
  print('학생의 이름은' , self.name , '나이는' , self.age , '입니다.'> 

이런식으로 사용을 하면 됩니다.

1. 파이썬의 self는 클래스의 인스턴스를 지칭합니다. self키워드를 통하여 클래스의 메소드와 속성에 접근할수 있습니다.
2. 모든 메소드의 첫 번째 매개변수는 자기 자신을 가리키는 self 변수입니다. 즉 이 메소드는 호출한 현재 객체를 의미합니다.

한번 제가 self를 사용해서 조금 해석이 필요하지만 주석으로 설명드리겟습니다.

class Cat:
    def __init__(self, name = "나비" , color = "흰색"): #name은 나비로 정하고 , #color은 흰색으로 정했습니다
        self.name = name #그걸 self.name과 self.color에 대입을 시켜서 그러면 self.name과 self.color은 name과 color의 역활을 하는겁니다
        self.color = color  
    def info(self): #출력시키기 위함
        print('고양이 이름은' , self.name , '색깔은' , self.color)
cat1 = Cat("네로","흰색")
cat2 = Cat("미미" , "갈색")

cat1.info()
cat2.info()

위에 코드까지 해석을 완료했네요. class 정의와 self는 여기까지입니다.

Here's how to define CLass in Python:

class Cat:
  def meow(self): #meow() method definition
  print('meow meow')
  
cat1 = Cat() #create instance
cat1.meow() # method call

If you do as above, the output value will eventually be output as'Meow Meow'. Class can be divided into two.

#Class definition

Class ClassName:
  '''Instance variables and method implementations'''
  
  #Instance creation and method call
    cat1 = Cat() #Cat instance creation cat1 created this.
    cat1.meow() This is a method call implemented by #Cat.

As above, Python Class can be divided into two and executed. Sometimes this is the case. What if you need to use the same class twice? Should I just create a Class twice and call the method twice? Not the correct answer. So how can you print twice?

Class ClassName:
  '''Instance variables and method implementations'''
    cat1 = Cat()
    cat1.meow()
    cat2 = Cat()
    cat2.meow()

You can do it like the code above. Then, the output value is the method that I have set, and the output is two.

Class Person:
  def info(self):
  self.name = "Hyunjun"
  self.age = 17 (Because it is an int, it is not quoted.)
  print('Student's name is', self.name,'age is', self.age,'.'>

You can use it like this.

1. Python's self refers to an instance of a class. through the self keyword You can access the methods and properties of the class.
2. The first parameter of any method is the variable self, which points to itself. In other words, this method refers to the current object called.

Once I use self, it needs some interpretation, but I'll explain it with a comment.

class Cat:
    def __init__(self, name = "butterfly", color = "white"): #name is set to butterfly, #color is set to white
        self.name = name # By substituting it into self.name and self.color, then self.name and self.color play the role of name and color.
        self.color = color
    def info(self): #for printing
        print('The cat's name is', self.name,'the color is', self.color)
cat1 = Cat("Nero","White")
cat2 = Cat("Mimi", "Brown")

cat1.info()
cat2.info()

You have completed the interpretation of the code above. That's all for class definition and self.

클래스(class)란 무엇일까요? 우선 클래스는 '객체지향 프로그래밍 언어'에서 중요한 단어입니다. 클래스는 개발자가 정한 이름으로 만든 독립된 공간입니다. 그것을 클래스에서는 이름공간(name space) 라고 부릅니다.

클래스에서 가장 중요한 구성요소는 클래스의 '변수'의 역활을 해주는 클래스 멤버와 같은 역활을 하는 '클래스 메소드' 입니다 클래스 멤버나 클래스 메소드는 클래스 공간 내에서 정의(define)되는것 말고는 보통의 역활은 비슷합니다.

그러면 클래스는 어떻게 define할까요?

class 클래스 이름:
  클래스 멤버 정의
  클래스 메소드 정의

위에처럼 클래스를 정의하시면 됩니다.

한번 Myclass 라는 이름의 클래스를 define해보겟습니다. 그러면 밑에 코드처럼 작성을 할수 있는데요.

class MyClass:
  var = '안녕하세요'
  def sayHello(self):
    print(self.var)

obj = MyClass()
print(obj.var)
obj.sayHello()

#출처 : 파이썬 200J

What is a class? First of all, class is an important word in'object-oriented programming language'. A class is an independent space created with a name determined by the developer. It is called a namespace in a class.

The most important component of a class is a'class method' that acts like a class member that acts as a'variable' of the class. Class members or class methods usually play similar roles, except that they are defined within the class space.

So how do you define a class?

class class name:
  Class member definition
  Class method definition

Just define the class as above.

Let's define a class named Myclass. Then you can write it like the code below.

class MyClass:
  var ='Hello'
  def sayHello(self):
    print(self.var)

obj = MyClass()
print(obj.var)
obj.sayHello()

#Source: Python 200J

클래스 멤버는 클래스 메소드 내에서 정의되는 지역변수(함수내에서만 유효한 함수) 나 인스턴스 멤버와는 성질이 다릅니다.

클래스 메소드는 클래스 내에서 정의되는 함수입니다. 클래스 메소드는 첫번째 인자(Arguments)는 무조건 필수적으로 self입니다. self: 클래스의 인스턴스 객체를 가르키는 참조자 입니다.

6라인에서는 MyClass의 인스턴스객체를 obj로 지정합니다.

obj의 멤버 또는 메소드를 호출하는 방법

obj클래스 멤버 #MyClass의 클래스 멤버
obj.클래스 메소드 #MyClass의 클래스 메소드

이런식으로 쓰면됩니다 obj.var는 MyClass의 클래스 멤버 var을 나타냅니다. 밑에 코드에서 var을 나타내는것은 그러면 '안녕하세요' 가 됩니다.

class MyClass:
  var = '안녕하세요'
  def sayHello(self):
    print(self.var)

obj = MyClass()
print(obj.var)
obj.sayHello()

#출처 : 파이썬 200J

obj.sayHello()는 MyClass의 sayHello()를 호출합니다. 인스턴스객체에서 클래스메소드를 호출할 경우 첫번째 Arguments인 self는 생략 됩니다.

Class members have different properties from local variables (functions only valid within functions) or instance members defined within class methods.

Class methods are functions defined within a class. For class methods, the first Arguments is essentially self. self: A reference to an instance object of the class.

In line 6, the instance object of MyClass is designated as obj.

How to call a member or method of obj

obj class member #MyClass class member
obj.class method #MyClass's class method

You can write something like this: obj.var represents the class member var of MyClass. In the code below, var is then'Hello'.

class MyClass:
  var ='Hello'
  def sayHello(self):
    print(self.var)

obj = MyClass()
print(obj.var)
obj.sayHello()

#Source: Python 200J

obj.sayHello() calls sayHello() of MyClass. When calling a class method from an instance object, the first Arguments, self, are omitted.

전 대리는 사장님께서 말씀하신 '신입 채용 공고'를 올리게 되었는데요 , 전 대리가 다니는 회사는 매우매우 작은 회사라 공고를 올렸는데 결국 3명의 지원자가 있었습니다.

이름: 홍길동
나이: 30

이름:김철수
나이:28

이름:이영희
나이:25

이런식으로 지원자가 와서 전 대리는 이걸 파이썬으로 저장해두고 갑니다 그러면 전 대리는 아직 파이썬 초보니깐 단지 function으로 저장해두고 가겟죠 밑에 코드처럼

name_1 = 홍길동
age_1 = 30

name_2 = 김철수
age_2 = 28

name_3 = 이영희
age_3 = 25

이런식으로 정리를 해두고 갑니다. 그 다음날 지나가는 선배께서 그냥 class로 정리를 하면 편하겟다고 하십니다. class로 해두면 1,2,3 이런식으로 안해도 되서 인데요. 그래서 일단 전 대리는 class를 만들어봅니다

class JSS():
    def __init__(self):
        self.name = input("이름")
        self.age = input("나이")
        

이런식으로 class를 만들었는데요 여기서 전 대리는 의문점이 듭니다. 그러면 init이 뭐지? init는 class를 실행하는 순간 실행이 되는 함수입니다. 한마디로 a = JSS() 라는 함수를 만들어 놓고 , a에 할당하고나서 이 코드를 실행하게 된다면 init함수의 내용이 실행되는것입니다.

이렇게 말하니깐 어려우니 쉽게 예시를 보여드리자면

class JSS():
    def __init__(self):
        print("안녕")
    def show(self):
        print("show 실행!")
a = JSS()
a.show()    

이런 코드를 볼때 아마 class를 모르는 분들은 매우 어렵게 보이실텐데 저는 이 코드를 진짜 쉽게 해석해드릴께요 일단 제가 밑에 a = JSS()라고 쓴것은 init를 출력합니다 즉 "안녕"을 출력하죠 , 그러면 show()는? "당연히 show 실행!" 을 출력합니다. a. , a = 이라고 할때 a 는 self라고 보시면 편합니다.

class JSS():
    def __init__(self):
        self.name = input("이름")
        self.age = input("나이")
    def show(self):
        print("나의 이름은 {} , 나이는 {}살입니다.".format(self.name,self.age))
a = JSS()
a.show()      

self : 클래스를 저장할 변수 -> JSS class를 만들고 그 안에 show 라는 함수 괄호안에 self를 넣는다는것은 a라는 변수에 JSS Class를 할당했을때, a.show() 이러한 형태를 쓰겟다고 하는것이기 때문에 ()안에는 아무것도 안넣는것입니다.

self는 a. , a = 역활입니다

이럴때는 '상속' 을 사용하면 됩니다.

a = JSS()
a.name = "홍길동"
a.age = 30

#이랫던 코드에 상속을하면

a = JSS2()
a.name = "홍길동" 
a.age = 30
a.gender = "남"

이런식으로 써주시면 됩니다. 그러면 활용코드는 어떻게 쓸까요?

일단 밑에 코드에 주석과 코드를 봐주세요

class JSS2(JSS):
  def __init__(self): #여기서 init를 사용하면 기본 정보가 초기화되고 , 새로 덮어쓰게 되므로
      super().__init__(): #그 전 input을 유지함
      self.gender = input("성별") #새롭게 추가함
      

그러면 그냥 똑같은걸 만들고 싶다면 어떻게 해야 할까요? 바로 pass 입니다 밑에 코드처럼 활용하면 됩니다.

class JSS2(JSS):
  def __init__(self): 
      pass
a.JSS2() #init는 초기화됬으니 , 그냥 JSS가 똑같이 출력됨

The former assistant manager posted the'new recruitment announcement' that the boss said, but the company he works for is a very, very small company, and in the end there were 3 applicants.

Name: Hong Kil-dong
Age: 30

Name: Kim Chul-soo
Age: 28

Name: Lee Young-hee
Age: 25

In this way, the applicant comes and the former deputy saves this in Python. Then, since the former deputy is still a beginner in Python, I will just save it as a function. Like the code below

name_1 = Hong Kil-dong
age_1 = 30

name_2 = Kim Chulsoo
age_2 = 28

name_3 = Younghee Lee
age_3 = 25

I keep it organized in this way. The next day, a passing senior said that it would be more convenient if you just organized it into a class. If you make it as a class, it is because you don't have to do it like 1,2,3. So, first of all, I try to create a class

class JSS():
    def __init__(self):
        self.name = input("name")
        self.age = input("age")
        

I created a class like this, but here I have a question. So what is init? init is a function that is executed the moment the class is executed. In short, if you create a function called a = JSS(), assign it to a, then run this code The contents of the init function are executed.

It’s difficult to say this, so let’s easily show you an example

class JSS():
    def __init__(self):
        print("hello")
    def show(self):
        print("run show!")
a = JSS()
a.show()

When looking at a code like this, it may seem very difficult for those who do not know the class, but I will interpret this code really easily. Once I write a = JSS() at the bottom, it prints init, that is, it prints "hello", then show()? "Of course, run the show!" Output. a. When we say, a =, it is convenient to see that a is self.

class JSS():
    def __init__(self):
        self.name = input("name")
        self.age = input("age")
    def show(self):
        print("My name is {} and my age is {}.".format(self.name,self.age))
a = JSS()
a.show()

self: variable to store class -> Creating a JSS class and putting self in parentheses of a function called show in it means that when the JSS Class is assigned to a variable called a, a.show() has this form. Because it is said to be used, nothing is put in ().

self is a. , a = role

In this case, you can use'inheritance'.

a = JSS()
a.name = "Hong Gil Dong"
a.age = 30

#If you inherit this code

a = JSS2()
a.name = "Hong Gil Dong"
a.age = 30
a.gender = "male"

You can write it like this. Then, how do you write the utilization code?

First, look at the comments and code in the code below

class JSS2(JSS):
  def __init__(self): #If you use init here, the default information will be initialized and overwritten.
      super().__init__(): # keep the previous input
      self.gender = input("Gender") #Newly added
      

So what if you just want to make the same thing? It is pass. You can use it like the code below.

class JSS2(JSS):
  def __init__(self):
      pass
a.JSS2() #init has been initialized, so JSS is output the same