반응형


자바는 객체 지향 프로그래밍 : 각각의 컴퓨터 부품을 만들고 그 부품들을 조립하여 컴퓨터를 만들 듯이 객체를 만들고 그 객체들을 

조립하여 소프트웨어를 만드는 기법이다.  


<특징>

-캡슐화 (encapsuation) : 관련된 데이터와 알고리즘(코드)이 하나의 묶음으로 정리 

-상속 : 이미 작성된 클래스(부모 클래스)를 이어 받아 새로운 클래스(자식 클래스)를 생성하며, 기존의 코드를 재사용할 수 있는 강력한 기법

-객체(Object) : 객체 지향 기술의 핵심 , 객체 안의 변수를 필드(field)라 부르고, 객체 안의 함수를 메소드(method)라 부른다

  하나의 객체는 필드와 메소드로 이루어진 SW묶음

-메세지(Message) : 객체는 메세지를 통해 다른 객체와 통신하고 상호 작용 / 매개변수(parameter)의 형태로 전달


Car.setSpeed(100);


Car : 메세지를 받는 객체

setSpeed : 매세지의 이름

(100) : 메세지의 매개변수


1.클래스(Class)

: 특정한 기능을 가진 객체를 생성하게 해주는 설계도

-클래스로 부터 만들어진 객체 : 해당 클래스의 인스턴스(instance) 


#예시

-자바에서는 일반적으로 하나의 소스 파일에는 하나의 클래스만을 담는 것이 원칙이다. 

 만일 하나의 파일에 여러 클래스가 있을 경우 클래스 중 main()이 들어있는 클래스의 이름과 소스 파일명이 같아야한다.


class Car{
    String color; //필드 정의
    int speed;
    int gear;
 
    void print(){ //메소드 정의
        System.out.println("<" + color + "," + speed + "," + gear + ">");
    }
}
 
class CarTest{
    public static void main(String[] args){
        Car myCar = new Car(); //객체 생성
 
        myCar.color = "red" ; //객체 필드 변경
        myCar.speed = 0;
        myCar.gear = 1;
 
        myCar.print(); //객체 메소드 
    }
}
cs


-클래스 구성요소

= 필드 : 객체의 데이터가 저장되는 곳, 데이터 선언 및 초기화 하는 공간(int fieldName;)

-객체의 고유 데이터, 상태 정보를 저장하는 곳

-생성자와 메소드 전체에서 사용되며 객체가 소멸되지 않는 한 객체와 함께 존재

-초기화 하지 않으면 각 자료형의 기본값으로 초기화 


<필드선언>

-생성자 선언과메소드 선언의 앞 뒤 어떤 곳에서도 필드 선언 가능

-단, 생성자와 메소드 내부에서는 선언될 수 없음(생성자, 메소드 내부의 변수 = 지역 변수)


<필드 선언>

-필드 값을 읽고 변경하는 작업

-클래스 내부에서는 단순히 필드 이름으로 읽고 변경

-클래스 외부에서는 클래스로부터 객체 생성 후 사용(일반적으로 직접 접근 못하게 캡슐화)


= 생성자 : 객체 생성 시 초기화 역할 담당, new 연산자(Car car = new Car;)

-new 연산자로 호출되는 특별한 중괄호 블록

-객체 생성 시 초기화 담당

-필드를 초기화하거나 메소드를 호출해서 객체를 사용할 준비

-클래스 이름으로 되어 있고 리턴 타입이 없음


<생성자 생성>

-생성자를 선언 안해도 기본적으로 컴파일시 디폴트 생성자가 생성됨

-생성자는 메소드와 비슷한 모양을 가지나, 리턴 타잆이 없고 클래스 이름과 동일

-클래스에 생성자가 명시적으로 선언되어 있을 경우 반드시 선언된 생성자를 호출해서 객체를 생성

-하나라도 인자값을 가진 다른 생성자를 호출할 경우 디폴트 생성자는 자동으로 생성되지 않으므로 디폴트 생성자를 호출하기 위해선 디폴트 생성자도 명시적으로 선언해줘야 함


<필드 초기화>

-필드를 선언할 때 초기값을 주면 동일한 클래스로부터 생성되는 객체들은 모두 같은 데이터를 가짐

-객체 생성 시점에 외부에서 제공되는 다양한 값들로 초기화 되어야 한다면 생성자에서 초기화 해야 함


<관례적으로 필드와 동일한 이름을 갖는 매개변수 사용>

-이 경우 필드와 매개변수 이름이 동일하므로 생성자 내부에서 해당 필드에 접근할 수 없다

-why? 동일한 이름의 매개 변수가 사용 우선순위가 높다. 따라서 this 를 사용한다.

-this는 객체 자신의 참조


<생성자 오버로딩>

-매개변수를 달리하는 생성자를 여러 개 선언하는 것

-오버로딩 시 주의점은 매개 변수의 타입과 개수 그리고 선언된 순서가 똑같을 경우 매개 변수 이름만 바꾸는 것은 오버로딩이라고 볼 수 없음


<다른 생성자 호출(this())>

-생성자 오버로딩이 많아질 경우 생성자 간의 중복된 코드 발생

-이 경우 필드 초기화한 내용은 한 생성자에만 집중적으로 작성하고 나머지 생성자는 초기화 내용을 가지고 있는 생성자를 호출하는 방법으로 개선

-생성자에서 다른 생성자 호출할 때 this() 코드 사용

-this()는 자신의 다른 생성자를 호출하는 코드, 반드시 생성자 첫줄에서만 허용


public Cat(String name, String breed){
    this.name = name;
    this.breed = breed;
}
public Cat(String name, String breed, int age){
    this(name,breed);
    this.age = age;
}
cs

= 메소드 : 객체의 동작에 해당하는 실행 블록 (void methodName(){..})


<클래스명 작성 규칙>

작성규칙

하나 이상의 문자로 이루어져야 한다

Car, SportsCar

첫 번째 글자는 숫자가 올 수 없다

Car, 3Car(x)

'$','_' 외의 특수 문자는 사용할 수 없다

$car, _Car, @Car(x), #Car(x)

자바 키워드(예약어)는 사용할 수 없다

int(x), for(x)

단일 단어 => 첫문자는 대문자 혼합 단어 => 각 단어 첫글자는 대문자


<메서드 선언>

[접근 제한자] [기타 제어자] 반환자료형 메서드명(매개변수){
    //return 리턴값;
}
cs

<메서드 선언부 = 메서드 시그너처>


<리턴 타입>

-메서드가 실행 후 리턴하는 값의 타입

-메서드 실행 후 결과를 호출한 곳에 넘겨줄 경우에는 리턴 값이 있어야 함

-리턴 값의 타입은 선언부의 반환자료형과 동일해야 함

-리턴 타입이 있다고 해서 반드시 리턴값을 변수에 저장할 필요 없음

-void 타입의 경우 리턴문 없이 사용 가능


<매개 변수의 수를 모를 경우>

-매개 변수를 배열 타입으로 선언

-… 으로 선언후 리스트 나열

public int sum(int ... args){
    return IntStream.of(args).sum();
}
cs



<메서드는 클래스 내/외부의 호출에 의해 실행>

-클래스 외부에서 호출할 경우 우선 클래스로부터 객체 생성
-클래스 참조변수 = new 클래스(매개값); * 참조변수.메서드(매개값); (리턴값 없거나, 받지 않을 경우) * 타입 변수 = 참조변수.메서드(매개값); (리턴값 받고 싶을 때)

<메서드 오버로딩>

-클래스 내에 같은 이름의 메서드를 여러 개 선언하는 것
-매개 변수의 타입, 개수, 순서 중 하나가 달라야 한다 (시그니처가 달라야 한다)


#예시

import java.util.Scanner;
 
public class InstanceMemberEx01 {
    int a, b; // 인스턴스 필드
    
    public InstanceMemberEx01(int c, int d) { // 생성자(필드 초기화)
        a = c; b = d;
    }
    
    public void add(){ // 인스턴스 메소드
        System.out.println(a+b); 
    }
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("2개의 정수를 입력");
        int num1 = sc.nextInt();
        int num2 = sc.nextInt();
        InstanceMemberEx01 im = new InstanceMemberEx01(num1, num2); // 인스턴스 생성 및 생성자 호출
        im.add(); // 인스턴스 메소드 호출
    }
}
 
cs


##여기 까지 요약

1. 인스턴스 멤버(메소드, 필드)는 인스턴스를 생성해야지만 사용이 가능하다.(클래스멤버와의 차이점)
2. this는 자기 자신을 의미하는 키워드이다.
3. this.은 필드와 매개변수가 동일할 때 주로 사용되며 인스턴스 멤버임을 명확하게 해준다.
4. this()는 자기 자신의 생성자를 호출할 때 사용하며 호출하는 곳의 첫 번째 문장에 작성해야 한다.


2. 정적 멤버와 static

-정적(static)멤버는 클래스에 소속된 멤버(필드, 메소드) 의미

-static이라는 키워드가 붙은 필드 or 메소드가 정적 멤버이다.


<정적 멤버 선언>

-정적 필드 선언

static 타입 필드 [=초기값]; //static int a;
cs

-정적 메소드 선언

static 리턴타입 메소드([매개변수]){...}//static void sum(){..}
cs


-static으로 생성된 필드(전역 변수)는 static이라는 메모리 영역에 저장되어 프로그램이 종료될 때 까지 메모리상 남음

=몇 개의 인스턴스를 생성하든 클래스 당 단 1개의 값 가짐


public class StaticMemberEx01{
    static int a; //정적 필드
    int b;          //인스턴스 필드
 
    StaticMemberEx01(int a, int b){
        this.a = a; //매개값 할당
        this.b = b; //매개값 할당
    }
    public String print(){
        String value = "a : " + a + ", b : " +b;
        return value;
    }
    
    public static void main(String[] args){
        StaticMemberEx01 sm = new StaticMemberEx01(1,2); 
        StaticMemberEx01 sm1 = new StaticMemberEx01(2,3);
        StaticMemberEx01 sm2 = new StaticMemberEx01(3,4);
        System.out.println(sm.print()); // a : 3, b : 2
        System.out.println(sm1.print()); // a : 3, b : 3
        System.out.println(sm2.print()); // a : 3, b : 4
    }
}
  //인스턴스를 여러 번 생성하여도 메모리에서 한 번만 공간 할당하여 메모리 아
cs


반응형

'Language Study > Java' 카테고리의 다른 글

제주에서 자바_Week2_1  (0) 2019.07.22
제주에서 자바_Week1  (0) 2019.07.20
3. 참조 타입  (0) 2019.05.28
2. 조건문 & 반복문  (0) 2019.05.27
1. 타입, 연산자  (0) 2019.05.27
반응형

1. 참조 타입(reference type)

- 종류 : 배열, 열거, 클래스, 인터페이스

- 참조 타입 변수 -> 스택 영역에 생성되어 힙 메모리 영역의 번지(주소) 값 갖음.

- 주소 통해 객체를 참조한다 


2. 참조 변수 == , != 연산

-> 힙 영역의 객체 주소 ; 주소 값을 비교하는 것이 됨 / 동일 주소 값 => 동일한 객체 참조


3. 참조 타입 변수 null

-> 힙 영역의 객체를 참조하지 않는다 

-> null 값을 가질 경우 참조할 객체가 없으므로 -> 객체는 힙 메모리 영역에 생성X / 변수만 스택에 생성되 NULL 값 가짐

-> null 값을 가진 참조 타입 변수 ==, != 연산은 기본 타입과 동일

-> 참조 타입 변수가 null 값 가진 상황에서 프로그램 실행 경우(프로그램 실행 중 참조 타입 변수가 null값 가진 경우)

=> NullPointerException 예외 발생


4. String 타입

-문자열 저장하는 참조 타입

- 문자열 리터럴이 동일한 경우 객체 공유(new 연산자로 새로운 객체 생성 X -> 대입 연산자로 같은 문자열 저장)

- String 객체의 equals() 메소드 사용해 객체 상관없이 문자열 비교 

String x; // 기본값은 null 
 
= "hello"// 선언한 x에 문자열 값을 대입, " " (쌍따옴표) 사용
 
String y = "hello"// 선언과 동시에 문자열 저장 x == y 는 true
 
String z = new String("hello"); // 새로운 객체 생성, y == z 는 false 
 
if ( y.equals(z) ) {
 System.out.println("true"); // true 출력
 }
cs


5. 배열 

- 같은 타입 데이터를 메모리상에 연속적으로 나열시키고, 각 데이터에 인덱스(index)를 부여해 놓은 자료구조

- 인덱스  :첨자값, [](대괄호) 사용

// 대괄호의 위치 차이
int[] intArray; //타입[] 변수(배열명);
int intArray[]; //타입 변수(배열명)[];
 
//null로 초기화
String[] stringArray = null;
 
//값 목록을 가진 배열 생성
String[] names = {"홍길동","전지현","지수","보람"};
int[] scores = {80909433};
 
//new 연산자로 바로 배열 객체 생성
double[] doubleArray = new double[5]; //배열의 길이 지정 [0-4]
 
//컴파일 에러 
String[] names = null;
 
//배열 변수 선언
names = new String[] {"홍길동","전지현","지수","보람"};
cs


-{ } : 주어진 값들을 가진 배열 객체를 힙 메모리 영역에 생성, 배열 객체의 번지(주소) 리턴

- 배열 변수는 리턴된 번지를 저장하여 참조

- names[0] = "홍길동"


- 배열의 값 바꾸기 

String[] names = {"홍길동""전지현","지수","보람"};
System.out.println("names[0] >" + names[0]); //홍길동
names[0= "혜원";
System.out.println("names[0] >" + names[0]); //혜원
 
//배열 값 바꾸기는 " = " 대입 연산자 
cs


-배열 길이 

-배열에 저장할 수 있는 전체 항목 수

-배열 객체의 length 필드 (field) 읽어야 한다

-필드(field) : 객체 내부의 데이터

- 배열의 마지막 요소의 인덱스 배열 길이 : -1

int[] intArray = { 100200300};
int len = intArray.length;
System.out.println("배열 intArray의 길이는 : " + len);
cs


-다차원 배열 

/*타입[][] 변수 = new 타입[][]*/
int[][] scores = new int[2][];
scores[0= new int[2]; //01
scores[1= new int[3]'    //012
cs


/*타입[][] 변수 = {{값1, 값2..}, {값1, 값2..}}*/
int[][] scores = { {9588}, {9320} };
int scores = scores[0][0]; //95
int scores = scores[1][1]; //93
cs


6.열거 타입 선언

public enum 열거타입이름//첫 문자는 대문자, 나머지는 소문자 {
    열거 상수 선언 //열거 타임의 값 사용, 관례적으로 모두 대문자 작성 / 여러 단어 구성될 경우 단어 사이 밑줄(_)
                  //열거 객체로 생성, 해당 열거 타입의 열거 상수 개수만큼 객체가 열거 타입 객체 생성
}
 
public enum Month {
    JANUARY,
    FEBRUARY,
    MARCH,
    APRIL,
    MAY,
    JUNE,
    JULY,
    ...  //Month의 경우 JANUARY부터 DECEMBER까지 12개의 열거 상수는 힙 영역에 Month 객체로 
}
cs


7. 열거 타입 변수 

//열거타입 변수 : null 값도 저장할 수 있다.
Month thisMonth;
Month birthMonth;
 
Month thisMonth = Month.JUNE;
cs

-열거 상수 Month.JUNE과 thisMonth 변수는 서로 같은 Month 객체를 참조 : true 가 된다.


Month month1 = Month.JUNE;
Month month2 = Month.MARCH;
 
//name() : 객체가 가지는 문자열 리턴
String month1 = thisMonth.name(); //month = "JUNE"
 
//ordinal() : 전체 열거 객체 중 몇 번째 열거 객체 인지 알려줌
int ordinal = thisMonth.ordinal(); // ordinal = 5
 
//compareTo() : 주어진 열거 객체 기준으로 전후 몇 번째 위치하는지 비교 
int result1 = month2.compareTo(month1); //-3(매개값이 열거객체보다 순번이 빠르다면)
int result2 = month1.compareTo(month2); //3
 
//valueOf() : 매개값으로 주어진 문자열과 동일한 문자열 가지는 열거 객체 리턴
Month thisMonth = Month.valueOf("JUNE");
 
//values() : 열거 타입의 모든 열거 객체들을 배열로 만들어 리턴
Month[] months = Months.values();
for(Month month : months){
    System.out.println(month);
}//January ... december
cs


## 각 학생들의 점수를 입력받아 최고 점수 , 평균점수 구하는 프로그램

package firstproject;
import java.util.Scanner;
 
public class HelloWorld {
    public static void main(String[] args) {
        boolean run = true;
        int studentNum = 0;
        int[] scores = null;
        Scanner scanner = new Scanner(System.in);
        
        while(run) {
            System.out.println("============");
            System.out.println("1.학생수 | 2.점수입력 | 3.점수리스트 | 4.분석 | 5.종료");
            System.out.println("============");
            System.out.println("선택>");
            
            int selectNo = scanner.nextInt();
            
            if(selectNo==1) {
                System.out.println("학생수>");
                studentNum=scanner.nextInt();
                scores = new int[studentNum];
            }
            else if(selectNo==2) {
                for(int i = 0; i <studentNum; i++) {
                    System.out.println("scores["+i+"]>");
                        int score = scanner.nextInt();
                        scores[i] = score;
                }
            }
            else if(selectNo==3) {
                for(int i =0; i<studentNum; i++) {
                    System.out.println("scores["+i+"]"+scores[i]);
                }
            }
            else if(selectNo==4) {
                int max = 0;
                int sum = 0;
                double avg = 0;
                for(int i=0;i<studentNum; i++) {
                    sum+=scores[i];
                    if(scores[i]>max)
                        max=scores[i];
                }
                avg=(double)sum/studentNum;
                System.out.println("최고 점수 :"+max);
                System.out.println("평균 점수 :"+avg);
            }
            else if(selectNo==5) {
                run = false;
                System.out.println("프로그램 종료");
            }
        }
    }
}
cs


반응형

'Language Study > Java' 카테고리의 다른 글

제주에서 자바_Week2_1  (0) 2019.07.22
제주에서 자바_Week1  (0) 2019.07.20
4. 클래스  (0) 2019.05.29
2. 조건문 & 반복문  (0) 2019.05.27
1. 타입, 연산자  (0) 2019.05.27
반응형


1. 제어문 : 프로그램의 흐름을 바꾸는 역할 


2. 조건문 : 조건에 따라 문장이 수행됨(if, switch)

   -if문

# if문

if(조건식//true, false값을 산출하는 연산식, boolean 변수) {
    실행문;
    실행문;
//조건식 true이면 블록 실행, false이면 블록 실행x
}
cs


#if - else 문

if(조건식//true, false값을 산출하는 연산식, boolean 변수) {
    실행문;
    //조건문이 true면 실행
}else{
    //조건문이 false이면 
cs


#if - else if문 : 처리할 경우의 수가 셋 이상인 경

if(조건식1){
    //조건식 1이 참일 경우 실행
}else if (조건식2){
    //조건식2가 참일 경우 실행
}else{
    //위의 어느 조건도 만족하지 못할 경우 실행
}
cs


EX)

package firstproject;
 
public class HelloWorld {
    public static void main(String[] args) {
         int score = 70;
         
         if (score >= 90) {
             System.out.println("A+");
         }else if(score >= 80) {
             System.out.println("B+");
         }else {
             System.out.println("C+");
         }
    }
}
 
cs


#중첩 if문

if(조건식1){
    //조건식1이 참일 경우 실행
    if(조건식2){
        //조건식1과 조건식2가 모두 참일 경우 실행
    }else{
        //조건식1은 참, 조건식2는 거짓일 경우 실행
    }
}else{
    //조건식1이 거짓일 경우 실행
}
cs


EX2) 중첩 if문 

package firstproject;
 
public class HelloWorld {
    public static void main(String[] args) {
         int score = (int)(Math.random()*20+ 81;
         //강제 형변환으로 random 함수 사용해 20사이의 숫자 뽑아냄
         System.out.println("점수 : " + score);
         
         String grade;
         
         if(score >= 90) {
             if(score >= 95) {
                 grade = "A+";
             }else {
                 grade = "A";
             }
         }else {
             if(score>=85) {
                 grade = "B+";
             }else {
                 grade = "B";
             }
         }
         System.out.println("학점: "+ grade );
    }
}
cs


  -switch문 : 조건식의 결과값은 반드시 정수, 문자열이여야함 -> case 값도 정수, 문자열이어야함 / case값은 중복될 수 없음

switch(조건식){
    case 값1: //조건식 결과와 값1이 같을 때 실행
    break//case 값1dl 실행될 경우 switch문을 빠져나감
    case 값2: //조건식 결과와 값2가 같을 때 실행
    break//case값2가 실행될 경우 switch문을 빠져나감
    default:
        //조건식과 일치하는 case없을 경우 실행
        //마지막에 작성되므로 break 없어도 됨
}
cs


#switch문 중첩 

switch(조건식){
    case 값1 : //조건식 결과와 값1이 같을 때 실행
        switch(조건식){
            case 값3:
            break;
            case 값4:
            break;
        }
    break//case값1이 실행될 경우 switch문을 빠져나감
 
    case 값2: //조건식 결과와 값2가 같을 때 실행
    break//case 값2가 실행될 경우 switch문을 빠져나감
 
    default:
        //조건식과 일치하는 case없을 경우 실행
        //마지막에 작성되므로 break 없어도 됨
}

cs


3. 반복문 : 특정 문장을 반복 수행

-for 문 (반복 횟수 알고 있을 때 적합)

for(초기화; 조건식; 증감식){
    // 조건이 참일 때 실행
}
//조건식의 세가지 모두 생략 가능
// 이 경우 조건식이 참으로 간주되어 무한반복, 특정조건을 만족하면 if문을 빠져나오게 해야함
cs


     #중첩 for 문

#향상된 for문

for(타입 변수명 : 배열or 컬렉션){
    //반복할 문장
}
//타입 = 배열 or 컬렉션 타입과 일치
//배열이나 컬렉션에 저장된 요소들을 읽어오는 용도로만 사용 
cs

#ex) 구구단 출력 

public class HelloWorld {
    public static void main(String[] args) {
         for(int m = 2; m <= 9; m++) {
             System.out.println("##"+m+"단##");
             for(int n =1; n<= 9; n++) {
                 System.out.println(m + " X" + n +"="+ (m*n));
             }
         }
    }
}
cs


-while문(조건식이 true이면 계속 반복)

while(조건식){
    //조건식이 true일 경우
    실행문;
    //false이면 while문 
}
cs


-do-while문(블럭{ } 을 먼저 수행한 후 조건식 평가/ 최소한 한번은 수행될 것 보장)

do{
    //조건식 결과가 참일 때 수행
}while(조건식);
cs


4.break문 

-for/ while/ do-while문 사용

-자신이 포함한 가장 가까운 반복문 벗어남

-주로 if문과 함께 사용, 특정 조건 만족 시 반복문 벗어남


5.continue문

-for/while/do-while문 사용

-만나면 반복문의 끝으로 이동하여 다음 반복으로 넘어감

-for문 : 증감식으로 이동 / do-while문 : 조건식으로 이동

-반복문 전체 벗어나는게 아니라 다음 반복 계속 수행 



#별 찍기 

public class HelloWorld {
    public static void main(String[] args) {
        for(int i=1;i<=5;i++){
            for(int j=0;j<i;j++){
                System.out.print("*");
            }
            System.out.println("");
        }
    }
}
 
>>
*
**
***
****
*****
cs


#키보드 입력 데이터로 예금, 출금, 조회, 종료 기능을 제공하는 코드 작성

package firstproject;
import java.util.Scanner;
 
public class HelloWorld {
    public static void main(String[] args) {
    boolean run = true;
    
    int balance = 0;
    
    Scanner scanner = new Scanner(System.in);
    
    while(run) {
        System.out.println("==========");
        System.out.println("1.예금| 2.출금| 3. 잔고| 4. 종료");
        System.out.println("==========");
        System.out.println("선택> ");
        
        int num = scanner.nextInt();
        
        if(num==1) {
            System.out.println("예금액> ");
            balance += scanner.nextInt();
        }
        else if(num==2) {
            System.out.println("출금액 > ");
            balance -= scanner.nextInt();
        }
        else if(num==3) {
            System.out.println("잔고> ");
            System.out.println(balance);
        }
        else if(num==4) {
            run = false;
        }
    }
    System.out.println("프로그램 종료");
}
}
cs


반응형

'Language Study > Java' 카테고리의 다른 글

제주에서 자바_Week2_1  (0) 2019.07.22
제주에서 자바_Week1  (0) 2019.07.20
4. 클래스  (0) 2019.05.29
3. 참조 타입  (0) 2019.05.28
1. 타입, 연산자  (0) 2019.05.27
반응형

1. type

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class javaVariableExample{
    public static void main(String[] args){
        //논리형
        boolean booleanType = true(false);
        //문자형
        char charType = 'b';
        //정수형(int, long byte(이진), short)
        byte byteType=127;
        short shortType=32743;
        int intType=21243532;
        long longType=3984029840920L;
        //실수형
        float floatType = 3.4542E42;
        double doubleType= 1.434342E;
        //자동 타입 변환(작은 크기 타입 -> 큰 크기 타입)
        intValue = byteValue;//(byte -> int)
        intValue = charValue;//(char -> int)
        //강제 타입 변환(작은 크기 타입 = (작은 크기 타입)큰 크기 타입
        byte byteValue = (byte) intValue;
    }
}
cs


2. operation (연산자)


#변수 선언 및 값 할당 : "="


#연산자 

-단항 연산자 : + ,-, ~, !(논리값 부정)


  =증감 연산자 : ++, --


- 증가 연산자(++) : 피연산자의 값을 1 증가

- 감소 연산자(--) : 피연산자의 값을 1 감소

 전위형

j = ++i;

++i;

j = i 

값이 참조되기 전에 증가시킵니다. 

 후위형

j = i++; 

j = i

i++; 

 값이 참조된 후에 증가시킵니다.



-이항 연산자 

= 산술 연산자 : +, - , *, /, %(나머지 반환)

= 시프트 연산자 : >> , <<, >>> 

-> 변수나 어떤 수의 비트를 이동시키는 연산자 

<< : 대상을 이진수로 바꾼 후 왼쪽으로 비트들을 옮김(빈 자리는 0으로 채움)

>> : 대상을 이진수로 바꾼 후 오른쪽으로 비트들을 옮김(빈 자리는 0으로 채움)

>>> : 원 데이터가 -(음수)일 경우에도 앞쪽 비트를 0의 값으로 채움(오로지 양수 값만 다룸)

= 비교 (관계 ) 연산자 : >(미만) , <(초과) , >=(이하) , <=(이상) , ==(두 피연산자 값 같음) , !=(두 피연산자 값 다름)

= 논리 연산자 : &&(두 피연산자의 값이 모두 true 인 경우 true, 하나라도 false이면 false)

   || (두 피연산자 중 하나라도 ture일 경우 true)


= 삼항 연산자 : 조건항 ? 항1: 항2 (조건항이 참 = 항1 값 반환/ 거짓 : 항2 값 반환)



3. 연산자 우선 순위 

반응형

'Language Study > Java' 카테고리의 다른 글

제주에서 자바_Week2_1  (0) 2019.07.22
제주에서 자바_Week1  (0) 2019.07.20
4. 클래스  (0) 2019.05.29
3. 참조 타입  (0) 2019.05.28
2. 조건문 & 반복문  (0) 2019.05.27
반응형

## 원하는 명령들을 한번만 써놓고 반복적으로 실행 가능 = 반복문


1. while 반복문(조건 부분이 true일 동안에 수행 부분이 계속 실행) -> loop( 반복문)

while 조건부분(결과값으로 불린(True, False)이 나오는 식):
    수행부분(반복적으로 실행하고 싶은 명령들)
 
=1
while i<=3:
    print("i can code too!")
    #무한루프는 좋지 않음
    i = i + 1 
    #i를 지정해줘야 함
cs


ex) while 문을 사용하여 100 이상의 자연수 중 가장 작은 23의 배수를 출력 해보세요

= 100
 
while i % 23 != 0:
    i = i + 1 
print(i)
cs


2. if문(조건 부분이 참일 때 수행 부분이 딱 한번만 실행)-> conditional(조건문)

ex) 

= 5
= 3
 
if a < b:
    print("a는 b보다 작습니다.")
elif a == b:
    print("a와 b는 같습니다.")
else:
    print("a는 b보다 큽니다.")
 
>>> a는 b보다 큽니다.
cs


- 규칙 

= 처음에는 if문 꼭

= 중간에는 elif문은 0번 이상, 원하는 횟수만큼 씀

= 마지막 else문은 0번 또는 1번 쓸 수 있습니다. 


ex2)

temp = 13
 
if temp < = 5:
    print("내복과 긴팔과 자켓을 입으세요")
elif temp < 10:
    print("긴팔과 자켓을 입으세요")
elif temp <= 15:
    print("긴팔을 입으세요")
else:
    print("반팔을 입으세요")
 
>> 긴팔을 입으세요 
cs


ex3) 학점 계산기

def print_grade(midterm, final):
    total = midterm + final
    if total >= 90:
        print("You get an A")
    elif total >= 80:
        print("You get a B")
    elif total >= 70:
        print("You get a C")
    elif total >= 60:
        print("You get a D")
    else:
        print("You fail")
    
# 테스트
print_grade(4045)
print_grade(2035)
print_grade(3032)
print_grade(5045)
 
>>
You get a B
You fail
You get a D
You get an A
cs


ex4) 이상한 수학 문제 1

-100이하의 자연수 중 8의 배수 이지만, 12의 배수는 아닌 것을 모두 출력하세요

= 1
while i <= 100:
    if i % 8 == 0 and i % 12 != 0:
        print(i)
    i += 1
 
>>
8
16
32
40
56
64
80
88
cs


ex5) 이상한 수학 문제2

-1000보다 작은 자연수 중 2 또는 3의 배수의 합을 출력하는 프로그램을 써보세요.

= 1
sum = 0
while i < 999:
    i = i + 1
    if i % 2 == 0 or i % 3 == 0:
        sum = sum + i
print(sum)>> 333167
cs


ex6)약수 찾기

-자연수 중 120의 약수를 모두 출력하고, 총 몇 개의 약수가 있는지 출력하는 프로그램 작성

i=120
x=0
count=0
 
while x <= 120:
    x = x+1
    if i % x == 0:
        count = count +1
        print(x)
print("%d의 약수는 총 %d개 입니다." %(i,count))
cs


ex7)복리 계산

#상수 정의
INSERT_RATE = 0.12
APARTMENT_PRICE = 1100000000
 
#변수 정의
year = 1988
amount = 50000000
add = 0
 
while year < 2016:
    amount = amount * (1 + INSERT_RATE)
    year = year + 1
 
if amount > APARTMENT_PRICE:
    add = amount - APARTMENT_PRICE
    print("%d원 차이로 동일 아저씨의 말씀이 맞습니다."%(add))
else:
    add = APARTMENT_PRICE - amount
    print("%d원 차이로 미란 아주머니의 말씀이 맞습니다."%(add))
cs


ex8)피보나치 수열 계산

previous = 0
current = 1
= 0
 
while i < 20:
    print(current)
    temp = previous
    previous = current
    current = current + temp
    i += 1))
cs


ex9)구구단 출력

= 0 
while i < 9:
    i += 1
    j = 1
    while j <10:
        print("%d * %d = %d" %(i,j,i*j))
        j += 1
cs


3. break문 : while문 조건 부분과 상관 없이 반복문에서 나오고 싶을 때 사용

= 100
while True:
    # i가 23의 배수면 반복문을 끝냄
    if i % 23 == 0:
        break
    i = i + 1
 
print(i)
>>115
cs


4. continue문 : 현재 진행되고 있는 수행부분을 중단시키고 바로 조건 부분을 다시 확인하고 싶을 때 사용

= 0
while i < 15:
    i = i + 1
 
    # i가 홀수면 print(i) 안하고 바로 조건부분으로 돌아감
    if i % 2 == 1:
        continue
    print(i)
 
>>
2
4
6
8
10
12
14
cs


반응형

'Language Study > Python' 카테고리의 다른 글

swap  (0) 2020.01.04
6. 모듈  (0) 2019.07.15
4. 추상화 심화  (0) 2019.05.08
3. 추상화  (0) 2019.04.06
2. 자료형  (0) 2019.03.30
반응형

1. return문

- 함수 호출 부분(return call)을 return을 따르는 값으로 대체 

- 현재 함수 실행 멈추고 함수 호출 끝나는 지점부터 다시 진행

def f(x):
    print("F 시작")
    return x+1
    print("f 끝"//return x+1이 실행되고나서, f함수의 실행은 중단되고 함수가 
                    불러온 print(f(2))의 뒷부분부터 파이썬 다시 진행
                    -> dead code라고 함
 
 
def g(x):
    print("g 시작")
    return x*x-1
    print("g끝")
 
print(f(2)) // = print(3)
print(g(3// = print(8)
print(f(2+ g(3)) // print(3+8)
 
>>
f 시작
3
g시작
8
f시작
g시작
11
cs


2. return VS print

1) 사례 1

def print_square(x): //파라미터 제곱 출력, 리턴값 지정되어있지 않으므로 함수 리턴 값 = none
    print(x * x)
  
def get_square(x): //파라미터 제곱 리턴, 출력값 X
    return x * x
 
print_square(3)    // print(x*x)에 의해 9 출력
print("----------"
get_square(3)       // return 문에 의해 9로 대체, 그러나 대체된 값을 출력하라는 명령 x -> 아무것도 출력X
print("----------")
print(get_square(3)) //get_square 함수의 return 문에 의해 대체된 값을 출력하는 명령 -> 9 출력
print("----------")
print(print_square(3)) //print_square함수의 print(x*x)에 의해 9 출력 , 함수 호출 부분은 리턴값 대체
                       // 함수 리턴 값은 none -> none도 함께 
cs


2) 사례 2

def secret_number():
    print("우리의 비밀번호는 = ")
    return 486
 
print(secret_number())
 
>> 우리의 비밀번호는 =
486
 
//함수정의 건너뛰고 print문 도착 -> secret_number()라는 함수 호출 때문에, 다시 정의로 올라감
//첫번째 프린트문 출력 -> 486리턴 명령 O -> 
//1.함수 실행 중단 , 2. 함수 호출한 secret_number()라는 부분 486로 대체되어 출력
cs


3) 사례 3

//함수 내부에서 print문과 return문의 순서가 바뀌었다면?
 
def secret_number():
    return 486
    print("우리의 비밀 번호는: ">> dead code
 
print(secret_number())
 
>>486만 출력됨
>>왜? 486리턴되서 함수 실행이 종료 
cs


3. global vs local 변수

1) local 변수

-함수 안에서 사용하는 변수는 일반적으로 함수 내부에서만 유효하여 함수 밖에서는 쓸 수 없음

def x_is_one():
    x = 1
 
= 5 //x를 함수 바깥으로 빼면 함수 바깥에 정의된 5가 
x_is_one()
print(x)
 
>>5
cs


2) global 변수

-함수 안의 x와 함수 밖의 x가 통일하려면 

- 하나의 변수를 다른 여러 함수안에서 사용하고 싶을때, 함수 내 변수가 global 변수라고 표시해줘야함

def x_is_one():
    global x
    x =1
 
=5
x_is_one()
print(x)
 
>>1
cs


3) 사례 1

def next_number():
    global x
    x = x+1
 
=0 
next_number()
print(x) 
 
>>1
cs


## 여러 함수에서 통일된 global 변수를 쓰면 프로그램 전체에 영향을 줄 수도 있으니 주의!


4. 상수(global 변수의 좋은 예)

-프로그램 내내 변화하지 않는 변수 값 

-처음에 값을 정의하고 나서 끝날때 까지 계속 같은 값을 갖고 있는 것

/ 꼭 대문자로 정의 / 이름만 대문자로 쓴 변수 일 뿐, 함수 안에서 다시 정의해도 오류 X


PI = 3.14   # 원주율
 
def calculate_area(r):
    return PI * r * r
 
radius = 6    # 반지름
print("반지름이 %.2f면 원 넓이는 %.2f" % (radius, calculate_area(radius)))
 
 
radius = 12   # 반지름
print("반지름이 %.2f면 원 넓이는 %.2f" % (radius, calculate_area(radius)))
 
>>반지름이 6.00면 원 넓이는 113.04
반지름이 12.00면 원 넓이는 452.16
cs


5. 코드를 짤 때는 누구나 보기 쉽게 해야하는 스타일이 존재!

#이름 규칙 : 모든 변수, 함수 이름은 소문자 / 여러 단어일 경우 _로 나누기

#모든 상수 이름은 대문자/ 여러 단어일 경우 _로 나누기

#의미있는 변수 , 함수 이름 

# bad
= 2
= 3.14
print(b * a * a)
 
# good
radius = 2
pi = 3.14
print(pi * radius * radius)
cs

#화이트 스페이스 : 적당한 띄어 쓰기, 엔터키

#적당한 추상화, 적당한 코멘트 

# good(설명이 부족하거나 많지 않음)
PI = 3.14   # 원주율
 
# 반지름이 r인 원의 둘레 계산
def calculate_circumference(r):
    return 2 * PI * r
 
# 반지름이 r인 원의 넓이 계산
def calculate_area(r):
    return PI * r * r
 
# 반지름이 r인 구의 부피 계산
def calculate_volume(r):
    return 4 / 3 * PI * r * r * r
 
# 반지름이 4인 경우
radius = 4    # 반지름
print(calculate_circumference(radius))
print(calculate_area(radius))
print(calculate_volume(radius))
 
# 반지름이 8인 경우
radius = 8    # 반지름
print(calculate_circumference(radius))
print(calculate_area(radius))
print(calculate_volume(radius))
cs

#적당한 줄 길이 : 한 줄에 80자는 넘지 말자


##퀴즈 

짝수인지 홀수인지 판단해주는 is_evenly_divisible 함수를 쓰세요. 

is_evenly_divisible는 number(수)를 파라미터로 받습니다. 
짝수인 경우에는, 즉 number가 2로 나누어 떨어질 경우에는 True를 리턴해줍니다. 
홀수인 경우에는, 즉 number가 2로 나누어 떨어지지 않을 경우에는 False를 리턴해줍니다. 

함수 안에는 print문을 사용하시면 안 되고, return문을 사용하여야 합니다. 
'불린' 개념을 사용하면, 함수 단 '한 줄'로 쓸 수 있습니다!



def is_evenly_divisible(number):
  return(number % 2 == 0)
 
print(is_evenly_divisible(3))
print(is_evenly_divisible(7))
print(is_evenly_divisible(8))
cs


반응형

'Language Study > Python' 카테고리의 다른 글

6. 모듈  (0) 2019.07.15
5. 제어문  (0) 2019.05.22
3. 추상화  (0) 2019.04.06
2. 자료형  (0) 2019.03.30
1. Python 시작하기  (0) 2019.03.28
반응형

1. 개요 

- 추상화 (Abstraction) : 복잡한 세부사항을 숨기고, 주요한 기능에만 집중할 수 있게 해주는 개념

=> 변수 (Variable) : 값을 저장

1
2
3
first_name = "지수"
last_namte = "오"
full_name = last_name + first_name
cs

=> 함수(Function) : 명령들을 저장

1
print(1)
cs

=> 객체(Class)


2. 변수 ( 왜 변수는 추상화의 한 종류일까? -> 한 번 변수를 정의하고 나서 이후에 그것을 사용할 시, 변수 이름만 알면 되고 , 그 값 알 필요 없음


(1) 지정 연산자 (Assignment Operator) : 오른쪽에 있는 값을 왼쪽에 있는 변수에 지정해주는 역할

1
2
3
4
5
= 2 + 1
print(x) //3
 
= x + 1
print(x) //4
cs


=> 문자열 포맷팅, 변수 사용하여 아래와 같이 출력

1
2
3
4
5
6
7
8
# Hi, my name is jisu. I'm from Korea.
# My phone number is 010-1234-5678.
 
name = "jisu"
nationallity = " korea"
phone_number = "010-1234-5678"
 
print("Hi, my name is %s . i'm form %s. \n my phone_number is %s" %(name, nationallity ,phone_number ))
cs



3. 함수 기초


 -> 기본 구조

1
2
3
4
5
def 함수이름(파라미터): #header
 
    실행할 문장 1 #body
    실행할 문장 2
    실행할 문장 3
cs

 


파라미터가 없을 때는 함수이름()의 형식으로 함수를 불러올 수 있다.  

반면, 파라미터가 있을 때는 함수이름(파라미터1, 파라미터2, ...)의 형식으로 함수를 불러올 수 있다.


(1) 내장 함Built-in Function) : print / int /str


(2) 문자열 출력 함수 

1
2
3
4
5
6
7
8
#정의 
#header 
def hello():
    #body : 들여쓰기 하고 써야함 
    print("Hello world")
    print("welcome")
 
hello() #hello 라는 함수 돌리기
cs


(3) 파라미터 ( 들여쓰기 정도가 같은 명령들의 집합 : block -> 잘못되면 오류 발생)

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
def hello(name):
    print("Hello, %s!" % (name))
    print("Welcome to Codeit!")
  
hello("유재석")
hello("김태희")
 
def print_sum(a, b): #6
    print(a + b)
 
def print_product(a, b): #12
    print(a * b)
  
def print_residue(a, b): #1
    print(a % b)
  
def print_average(x, y, z): #10.0
    print((x + y + z) / 3)
 
print_sum(42)
print_product(34)
print_residue(133)
print_average(51015)
 
# 프로필을 출력하는 함수
def print_profile(name, age):
    print(name)
    print(age)
 
my_name = "김연우"
my_age = 45                   
print_profile(my_name, my_age)     
cs


4. syntatic sugar

-> 자주 쓰이는 표현을 더 간략하게 쓸 수 있게 해주는 문법

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 다음 두 줄은 같습니다
= x + 1
+= 1
 
# 다음 두 줄은 같습니다
= x + 2
+= 2
 
# 다음 두 줄은 같습니다
= x * 2
*= 2
 
# 다음 두 줄은 같습니다
= x - 3
-= 3
 
# 다음 두 줄은 같습니다
= x / 2
/= 2
 
# 다음 두 줄은 같습니다
= x % 7
x %= 7
cs


5. Optional Parameter

-> 파라미터의 기본값을 설정해두면 함수 호출 할 때 파라미터에 해당되는 값을 넘겨주지 않을 경우, 파라미터가 기본값을 갖게 됨

1
2
3
4
5
6
7
8
9
10
11
12
13
def myself(name, age, nationality = "한국"): #optional parameter은 모두 마지막에 아니면 에러
    print("내 이름은 %s" % name)
    print("나이는 %d살" % age)
    print("국적은 %s" % nationality)
 
myself("오지수"1)            # 기본값이 설정된 파라미터를 바꾸지 않을 때
-> 내 이름은 오지수
   나이는 1살
   국적은 한국
myself("랄라"1"미국")     # 기본값이 설정된 파라미터를 바꾸었을 때
-> 내 이름은 랄라
   나이는 1살
   국적은 
cs


6. 파라미터 연습 문제

1
2
3
4
5
6
7
8
9
10
#파라미터 연습 
 
#문자열 first_name(이름)과 문자열 last_name(성)을 파라미터로 받는 함수 print_full_name 쓰세요
 
def print_full_name(first_name, last_name):
    print(last_name, first_name,)
 
>> print_full_name("윤수","이")
 
// 이 윤수
cs


7. 거스름돈 계산기

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
#거스롬돈 계산기 
# 33,000원짜리 물건을 사기 위해 100,000원을 냈다면
# 50,000원 1장, 10,000원 1장, 5,000원 1장, 1,000원 2장과 같이 '가장 적은 수'의 지폐를 거슬러 주는 방식입니다.
 
# payment(지불한 금액)와 cost(가격)라는 파라미터 두개를 필요로 하는 함수 calculate_change를 쓰세요. 
# 이 함수는 거스름돈을 위해 50,000원짜리와 10,000원짜리, 5,000원짜리, 1,000원짜리가 각각 몇 장 필요한지 
출력해주는 역할을 합니다.
 
def calculate_change(payment, cost):
    change = payment - cost
    fifty_thousand_count = int(change/50000)
    change = change % 50000
    ten_thousand_count = int(change/10000)
    change = change % 10000
    five_thousand_count = int(change/5000)
    change = change % 5000
    one_thousand_count = int(change/1000)
    print("50000원 지폐: %d장" % (fifty_thousand_count))
    print("10000원 지폐: %d장" % (ten_thousand_count))
    print("5000원 지폐: %d장" % (five_thousand_count))
    print("1000원 지폐: %d장" % (one_thousand_count))
 
>>calculate_change(500000378000)
50000원 지폐: 2장
10000원 지폐: 2장
5000원 지폐: 0장
1000원 지폐: 2장
cs


반응형

'Language Study > Python' 카테고리의 다른 글

6. 모듈  (0) 2019.07.15
5. 제어문  (0) 2019.05.22
4. 추상화 심화  (0) 2019.05.08
2. 자료형  (0) 2019.03.30
1. Python 시작하기  (0) 2019.03.28
반응형

<개요>

 

1. 자료형 (Data type)

 

     1) 숫자 : 정수 (integer : -3, -2, -1, 0 , 1, 2, 3 ...) / 소수(floating point: 3.14, -7.3, 2.0)

 

     2) 문자 : "Hello", "World", "2" / ex) "hello" + 'world' => "helloworld" / "2" + '5' => "25"(이오)

 

     3) Boolean : True / False

 

 

 

2. 숫자형 (Numbers)

연산자
+덧셈 (addition)
-뺄셈 (subtraction)
*곱셈 (multiplication)
/나눗셈 (division)
%나머지 (modulo)
**거듭제곱 (exponentiation)


 
#덧셈
print(4.0 + 7.0->11.0
 
#뺄셈
print(2-4-> -2
 
#곱셈
print(5*3->15
 
#나머지
print(7%3->1
 
#거듭제곱
print(2**3.0->8.0
 
#나눗셈
print(7/2->3.5
print(6/3-> 2.0
print(7.0/2-> 3.5
print(6.0/2.0-> 3.0
 
#사칙연산 순서
print(2+3*2->8
print(2*(2+3)) ->10
 
#정수형 간의 연산 값은 정수로 나옴
#소수형 간의 연산 값은 소수로 나옴
#정수 + 소수 라면 = 소수 값
#나눗셈 기본 값은 소수값
 
 
cs


3. 문자열

1) 문자열 만드는 방법 : 

'do you want to take cs101?'
"do you want to learn python?"
'코드잇'
"오지수"
 
cs


2) 문자열을 만드는 방법 다양한 이유 -> 문자열 내에  ' 또는 " 를 포함시키고 싶을 때에는, 서로 다른 인용부호 사용

' "" '

" ' ' "


#틀린 예
print('i'm exited to learn python!')
#맞는 예
print("i'm exited to learn python!")
cs


$ python hello.py
i'm exited to learn python!
cs


3) 덧셈을 이용해 문자열 합치기 : 문자열에서 + 은 왼쪽 문자열과 오른쪽 문자열을 이어 연결하라는 의미

print("hello" + "world")
 
language = "파이썬"
print("우리가 배울 것은 " + language + "!")
 
print("3" + "5")
cs


$ python hello.py
helloworld
우리가 배울 것은 파이썬!
35
cs

4) 곱셈을 이용해 문자열 반복하기 : 문자열에서 *은 왼쪽문자열을 오른쪽의 수만큼 반복하라라는 의미

fly = "날아라"
print("떴다 떳다 비행기!")
 
print(fly * 2)
cs

$ python hello.py
떴다 떳다 비행기!
날아라날아라
cs


4. 형변환(type conversion/ type casting) : 논리적으로 가능한 경우에만 가능 진짜 순수 문자열은 숫자로 바뀔 수 없자나용?

#숫자형 -> 숫자형
print(int(3.8)) #int => integer(정수) =>>>3출력
print(float(3)) #float => floating point(소수) =>>>3.0출력
 
#문자열 -> 숫자형
print(int("2"+ int("5")) #print(2 + 5) =>>>7출력
print(float("1.1"+ float("2.5")) #print(1.1 + 2.5) =>>>3.6출력
 
#숫자형 -> 문자열 
#str => String( 문자열로 변형 시켜줌)
print(str(2+ str(5)) #print("2" + "5") =>>>25출력
print("제 나이는 " + str(7+ "살입니다."# =>>>제 나이는 7 살 입니다. 
cs


5. 문자열 포맷팅

코드자료형
%d정수(Integer)
%f소수(Floating point)
%s문자열(String)
year = 2016
month = 1
day = 16
day_of_week = "월"
 
print("오늘은" + str(year) + "년" + str(month) + str(day) + "일" + day_of_week + "요일입니다")
 
print("오늘은 %d년 %d월 %d일 %s요일입니다." % (year, month, day, day_of_week))
#오늘은 2016년 1월 17일 월요일입니다.
 
print(1.0 /3)
 
print("1나누기 3은 %.4f" % (1.0 / 3)) #1 나누기 3은 0.3333
print("1나누기 3은 %f" %(1.0 / 3)) #1 나누기 3은 0.3333333333333333
print("1나누기 3은 %.2f" % (1.0 / 3)) #1 나누기 3은 0.33
cs


6. 불린(boolean)

-명제 : 참 또는 거짓이 확실한 문장

-조건 연산 부호

연산자
>초과 (greater than)
<미만 (less than)
>=이상 (greater than or equal to)
<=이하 (less than or equal to)
==같다 (equal to)
!=같지 않다 (not equal to
  1. 식이 and => 왼쪽과 오른쪽 모두 True여야만 참이고, 나머지 경우에는 모두 False입니다.
  2. 식이 or => 왼쪽과 오른쪽 모두 False여야만 거짓이고, 나머지 경우에는 모두 True입니다.
  3. not True => False /  not False => True입니다.
  4. 괄호가 포함된 연산은, 괄호 안부터 값을 계산하고 그 후 괄호 밖과 연산
= 3
print(x > 4 or (x < 2 or x != 3)) #=> false
 
print((4 < 3 and 12 > 10or 7 == 7# => true
print(not 4 < 3# => true
print(not not True) # => true
cs


7. type함수 : 어떤 값이 무슨 자료형인지 기억나지 않을 때 -> type사용

#각 자료형 별 type 함수
print(type(1))
print(type(1.0))
print(type("1"))
print(type(2>4))
print()
 
#헷갈리는 두 자료형 비교
print(type("True"))
print(type(True))
print()
 
#print함수 type확인
print(type(print))
 
cs


$ python hello.py
<class 'int'>
<class 'float'>
<class 'str'>
<class 'bool'>
 
<class 'str'>
<class 'bool'>
 
<class 'builtin_function_or_method'>
cs


8. Floor Division

// : 나눗셈 연산 후 결과값을 내림 => 즉 소수 부분 버리고, 정수 부분만 남겨 둠 

print(7 / 4#1.75
print(int(7 / 4)) # 1
print(7 // 4# 1
 
#소수형 있을 경우 결과값이 소수형으로 나옴
print(5.0 // 2#2.0
print(5 // 2.0#2.0
print(5.0 // 2.0#2.0
cs


9. 반올림

round : 소수형 반올림

print(round(1.4211))      # 1.421을 소수점 1째 자리로 반올림 ->1.4
print(round(2.78622))     # 2.7562를 소수점 2째 자리로 반올림 -> 2.79
print(round(3.1415924))   # 3.141592를 소수점 4째 자리로 반올림 -> 3.1415
print(round(4.34))          # 4.34를 소수점 0번째 자리로 반올림 -> 4
cs


10. 줄바꿈 기호 (newline Character)

print("안녕하세요\n오지수입니다"
#안녕하세요
#오지수입니다
cs


반응형

'Language Study > Python' 카테고리의 다른 글

6. 모듈  (0) 2019.07.15
5. 제어문  (0) 2019.05.22
4. 추상화 심화  (0) 2019.05.08
3. 추상화  (0) 2019.04.06
1. Python 시작하기  (0) 2019.03.28

+ Recent posts