전공 수업을 듣다가 나는 혼동이 왔다. 그 이유는? JavaScript랑 JSP를 교수님께서 계속 언급하시는데 둘을 같은 것으로 인지했기 때문! 이름도 비슷한 둘을 알아보자.

정의부터 살펴보자.

JAVASCRIPT

: HTML 문서에서 동적으로 변하는 콘텐츠를 표현하기 위해 이벤트 처리를 하거나 서버와 연결하여 데이터를 가지고 오는 등의 역할을 하는 프로그램 언어.

다시 정리하자면?

HTML 문서에서 이벤트(버튼 클릭 등)를 서버 연결 없이 동적으로 처리할 수 있는 기술 -> 서버에 새로 접속하지 않고도 화면 정보가 변함

HOW?

스마트폰의 비중이 높아지고 새로운 서버 구현 기법이 확산되면서 가능해짐

종류

앵글러(Angular), 뷰(Vue), 리액트(React)등

JSP

: 서블릿에서 HTML과 데이터 결함을 손쉽게 처리하기 위해 만들어졌다.

서블릿?

자바 기반의 웹 프로그램 개발을 위해 만들어진 기술. 자바로 작성된 프로그램을 실행할 수 있는 서버 소프트웨어(EX.톰캣)를 통해 관리된다.

자바 중심의 서블릿과 달리 JSP는 HTML을 중심으로 데이터를 처리하는 특징을 가지는데, 쉽게 말해 HTML에서 자바 코드를 사용할 수 있는 구조다.

• JSP 문법 자체는 page 지시어 선언 부분을 제외하면 HTML 파일 구조와 동일하다.
• CSS, 자바스크립트 사용 형식 또한 동일하다.
• <%=%>란 JSP 출력문으로 사칙연산, 간단한 변수의 출력 등에 사용된다.

결론

JavaScript : 클라이언트 차원에서 사용하는 언어 JSP : 서버 차원에서 사용하는 언어

이 글을 쓰기 전까지

2022년 내 목표는 대외활동을 최소 2개 하는 것이었다. 무작정 대외활동이라고 하면 의문이 있을 수도 있을 것 같지만, 스스로 하기에는 의지가 부족고 우물 안에서 나가고 싶은 마음이었다. 협업의 방식을 배우고 싶었고 조직이 어떻게 이루어져 있는지, 다른 파트 사람들은 어떻게 일하는지.. 등등 어떤 단체에 투입되고 싶었다.

나는 프로젝트 경험이 거의 없는 상황이었기에 합격 허들이 무조건 낮은 곳에 지원을 해야 승산이 있었다. 그러던 중에 '컴공 선배'가 운영하는 챌린저스 단체 'UMC'가 우리 학교에도 있는 것을 발견했다. 원래 겨울 즈음에 '라이징 캠프'를 지원하려고 했는데 학기 중에 스터디를 진행하며 운영된다고 해서 바로 준비했다.

구글에 동덕 UMC 검색하면 딱 하나의 글만 나오고.. 전부 유니클로에 관한 이야기여서 많이 당황했다. 그 하나의 글을 많이 참조했는데 나도 그 은혜를 갚고자 몇 자 적어본다.

서류 지원

지원은 google forms로 받았다. 꽤나 여러가지의 질문이 있었다. 주변 이야기를 들어보니 열심히 서류를 작성한 사람만이 합격한 것 같다. 크게 3가지 카테고리가 있다고 느꼈고, 그에 해당한 질문들을 말해보겠다.

당신은 누구인가

1. 🎤UMC 지원 동기와 UMC 활동을 통해 기대하는 바를 알려주세요! (500자 이내)

2. 🎤2학기 계획을 알려주세요! (ex. 알바 요일 및 시간, 이수 예정 학점, 복수전공 연계전공 교직이수 사항, 타 대외활동 관련)

개발 경험 (또는 협업 경험)

1. 🎤살면서 열정적으로 무엇을 해 본 경험 or 힘들거나 어려웠던 일을 극복한 경험을 알려주세요! (개발 관련 경험이 아니어도 됩니다.) (500자 이내)

2. 🎤진행했던 프로젝트나 개발 관련 경험을 알려주세요!

3. 🎤프로젝트가 어떤 식으로 진행되었는지와 자신이 맡은 역할에 대해 알려주세요!(300자 이내)

4. 🎤프로젝트 진행 시에 있었던 협업, 소통, 갈등 해결 관련 에피소드를 알려주세요!(500자 이내)

비전

1. 🎤UMC는 학기 중에 배운 것을 바탕으로, 방학(8주)동안 팀을 구성하여 앱 런칭을 진행해야 합니다! 실제로 개발하고 싶은 앱이 있다면, 어떤 앱을 만들고 싶으신가요?(500자 이내)

2. 🎤UMC에 임하는 나의 각오를 알려주세요! (글자수 제한 없음)

면접 진행

모든 질문이 자세히 기억은 나지 않는다. Android 파트를 지원했지만 그에 관한 것은 묻지 않으셨다. 이건 모집폼처럼 공개적인 내용이 아니기 때문에 자세한 것은 생략한다! 기본적인 면접 질문을 준비하면 될 것 같다. (2022년 9월 기준)

어떤 식으로 작성(답변)했나요?

1. 무조건 두괄식으로 답변하라.
2. 개발 경험이 없어도 상관이 없다! 그 활동으로 무엇을 '배웠는지'에 초점을 두라.
3. 한 질문당 최소 5번 '왜?'를 외쳐라.

합격 문자

꽤나 열심히 지원서를 작성했기 때문에 떨리는 마음으로 기다렸다.

느낀점

소통문화가 중요한 만큼, 들어가자마자 디스코드와 노션에 초대되었다. 앞으로 이곳에서 많은 것을 배워서 좋은 개발자로 성장하고 싶다. 앞으로 공부한 것을 velog에 올리는 것이 하반기 목표! 아자아자

사실 카뉴를 지속적으로 만들어야 하므로... 인스타 꾸미기는 디자이너의 몫이 크다. 하지만 개발자들의 모임에서 사실 귀한 인력인 디자이너를 구하는 것은 무척 어렵다...

우리 팀은 한 달에 적어도 2~3개는 올리자고 다짐했고 크게 카테고리는 5가지이다.

1. 인공지능 카드뉴스
2. 수업관련 카드뉴스
3. 이달의 소놀 카드뉴스
4. V-DAY 카드뉴스
5. 팀 관련 카드뉴스
6. 그외

인공지능 카드뉴스

주기적으로 ai의 개념을 쉽게 전달하는 반가워요 인공지능! 시리즈를 제작하고 있다.

수업관련 카드뉴스

사전답사부터 시작해서 수업 후기 (수업에 집중, 학생에 집중 2가지)를 작성했다. 멘티들을 위해 준비한 굿즈 소개 카드뉴스도 제작했다.

이달의 소놀 카드뉴스

매달 달라지는 주제에 따라 자체적으로 컨텐츠를 작성했다!

V-DAY 카드뉴스

이것 또한 소프트웨어야놀자에서 제공되는 주제에 따라 자체적으로 컨텐츠를 제작했다.

팀 관련 카드뉴스

팀을 알리기 위해서는 팀원을 소개하는 것이 우선되어야 한다고 생각해서 스피드 문답을 진행했다.

그외

초반에는 어떤 것을 제작하고 인스타에 올려야 할지 몰라서 아래와 같이 제작했다.

더 많은 내용을 알고 싶다면 아래에 insta 링크로 들어오면 된다. 업무 분담은 대본 -> 카뉴 디자인 -> 소개글 작성으로 진행되었다. CODEFIVE INSTA

-끝-

길다면 길었고, 짧다면 짧았던 6주간의 여정이 끝났습니다. 7/17~8/25 동안 이루어졌던 스터디를 통해 파이썬의 기본을 훑어보는 시간을 가졌다는 점이 가장 뿌듯합니다. 혼자라면 작심삼일이나 갔을까요? 기본 자료구조까지도 절대 못 갔을 것이라 생각합니다.

과제를 제출하기 위해서는 매주 제공되는 스터디 미션을 풀기 위해서는! 꼭 강의와 퀴즈 그리고 라이브 코칭을 들어야 했습니다. 그리고 이 루틴은 일주일마다 다시 시작됩니다.

얼핏보면 '아.. 너무 빡센데?'라고 생각할 수 있지만, 조금만 부지런히 움직이면 됩니다. 그렇게 일주일에 2회 2시간씩 시간을 투자한다면! 양질의 강의와 퀴즈를 누릴 수 있다는 것이 저는 매우 마음에 들었습니다.

좋았던 점

• 함께 공부하는 스터디원이 생긴다.
  • 저희 팀 같은 경우에는 6명이 한 팀이었습니다. 물론 실제로 활동하는 사람은 저 포함 딱 3명이었습니다. 그들과 제출 기한에 맞추어 회의 날짜를 정했습니다. 그러면 그 날짜까지 무조건!! 스터디 미션 (보통 4문제)을 다 풀어서 와야하기 때문합니다. 모여서 서로의 코드를 피드백하는 시간이 있었기에 더욱 뜻 깊었습니다.
• 수료증을 발급해준다.
  • 6주라는 짧은 시간이지만 그 기간동안 온전히 잘 참여하는 것은 쉽지 않은 일이라고 생각합니다. 저는 처음에는 수료증이 어딘가에 단순히 인증 할 수 있는 수단이라고 느꼈는데요. 점점 종료 시간이 지나오니 '아, 수료증은 나의 완주를 축하해주는 문서구나'를 느낄 수 있었던 것 같습니다.
• 소통할 수 있는 공간이 마련되어 있다.
  • 나도 리더를 해본 적이 있어서 알지만, 구성원들 간의 소통이 정말 중요하다. 궁금한 점은 으레 생기는 것이 당연한다. 그리고 그것을 '어떻게' 더 좋은 아이디어로 발전시키고 활발하게 토론이 일어나게 할 수 있는 환경을 만드는 것이 포인트이다. 그리고 이 스터디의 플랫폼인 Slack에서 그 장면들을 많이 목격할 수 있었다. 아래는 스터디 내 실제 사례들이다.
    1. 팀에 배정된 코치에게 스터디 미션(코딩)에 대해 질문
    2. 운영진에게 스터디 운영과 관련해서 질문
    3. 다른 스터디 참여자들과 개발을 주제로 토론 다들 자유로운 분위기에서 질문을 하고 답을 하기 때문에 이 점 또한 좋았다.

아쉬웠던 점

• 모집 대상에 비해 문제 난이도가 높다.
  • 스터디의 본질이 '성장'이기 때문에 미션에 대한 난이도 언급은 굉장히 조심스러운 부분이다. 하지만 전공자인 나도 후반부로 갈수록 미션 해결에 많은 시간을 쏟았기 때문에, 파이썬을 아예 처음 공부하는 사람들은 코딩하다 좌절할 수도 있겠다는 생각이 들었다.

성장한 점

• 영어 강의에 대한 두려움이 줄었다.
  • 구글링을 해도 영어가 나오면 바로 마우스 오른쪽을 눌러 한국어로 번역했다. 영어만 보아도 머리가 아팠기 때문에... 하지만 이번 스터디는 영어 베이스 + 한글 자막이기 때문에 강의 자료를 따라 적으면서 다시금 내용을 학습할 수 있었다.

배운 점

• 에러는 나를 겁먹이게 하는 존재가 아니다.
  • 에러는 컴퓨터가 '나 여기가 안 돌아가~' 하고 친절하게 알려주는 것이다. 지레짐작으로 겁을 먹고 에러가 나오면.. 머리부터 아파오는데, 이 스터디를 통해 '차근차근' 에러를 해결해 보는 경험을 가졌다.

더 발전시키고 싶은 점

• 백준은 필수다.
  • 난 알고리즘에 정말 약하다. 근데 게을러서... 문제도 많이 풀지 않았다. 하지만 코딩 능력 향상을 위해서는 이제 피할 수도 없다. 스터디가 끝났더라도 지속해서 알고리즘 공부에 힘쓰자!

마지막 한 줄

이 기록물이 훗날 든든한 지식 배경이 되기를 바란다!

-끝-

안녕하세요! 2편으로 돌아온 '소프트웨어야 놀자' 멘토링 후기입니다. 1편에서는 이 활동이 어떤 활동인지에 대해서 알아보았습니다. 오늘은 '수업'에 초점을 맞추어서 더 자세히 알려드리겠습니다.

삐빅- 멘토가 되었습니다.

중고등학생 때를 돌이켜보면 나는 누군가를 가르친 경험이 없다. 공부도 나 혼자 독박공부를 하는 편이었고, 친구도 별로 없었다. 가끔가다 들어오는 질문에 대해 대답을 할 때도 상대와 내가 이해한 것이 달라 몇 차례 더 확인해야했던 것 같다.

그래서 이 교육봉사를 시작할 때 조금 걱정이 앞섰다. 다수 앞에서 발표를 하는 것에는 자신이 있는 나였지만, 누군가를 교육하는 것은... '감히 내가?'라는 생각이 먼저 들었다.

하지만 정신을 차리고 보니, 다른 친구들과 함께 지원서를 작성하고 있었다. 으쌰으쌰! 몇 차례의 새벽 회의를 거치고 우린 지원서와 학업 계획서를 완성했다.

수업 계획서를 작성해 봅시다.

지원을 할 때 직접 category를 선택할 수 있다. 분류는 크게 '인공지능'과 '데이터 과학'으로 이루어지는데 이는 또 세부로 분류된다. 아래 그림과 같이 이중 하나를 선택하면 되고, 우리는 이중 '나를 찾아봐'를 착안하여 이미지 인식에 대한 수업을 진행하기로 했다.

이렇게 큰 카테고리를 정한 후 우리는 자체적인 컨텐츠를 만들어야 했다. 이미지 인식 기술로 할 수 있는 것은 무궁무진하지만, 우리는 수업 대상으로 삼았던 중학생들이 좋아할 만한 활동을 찾는 것에 몰입했다.

아마 어떤 활동을 해야하지?가 예비 멘토들의 큰 어려움이라고 생각한다. 그래서 우리의 것을 예시로 들면서 계획서를 쉽게 쓸 수 있는 프로세스를 공유하고자 한다.

1. 팀의 Main이 될 수 있는 프로그램 정하기 -우리 팀은 '디비디비딥' 게임을 중심에 두었다. 2. Main 활동을 위해 빌드업 할 수 있는 활동을 생각한다. ** - 이미지 인식이 큰 주제이므로 인공지능이 이미지를 인식하는 원리에 대해 알려주고자 했다. (인공지능 이론) [1교시 수업] - 아이들의 흥미를 높이고자 이미지 인식을 활용한 게임을 찾아보았고 그 결과 퀵드로우와 오토드로우를 발견했다. (인공지능 실습) [2교시 수업] - 인공지능에 대해 배웠으니 당연히 윤리에 대해서도 다뤄야 겠다고 생각했다. (인공지능 윤리) [4교시 수업] 이렇게 큰 갈래를 짜서 2차시 (디비디비딥 실습 포함하여 - 총 4교시) 교육 내용을 정리할 수 있었다. *3. 수업 진행시 어떤 도구를 사용할 것인지 정한다. * - 학습지, ppt, 휴대폰, 엔트리 등 다양한 자료들을 준비한다. **4. 예상되는 돌발 상황에 대해서 생각해 본다. - 이를 유의점에 작성한다.

내 인생의 첫 멘티

나는 팀내에서 팀장을 맡았기 때문에 업무 분담 및 수행 뿐만 아니라 학교들과 컨택하는 업무도 진행했다. 대면 멘토링은 대개 2 학교를 맡는다. 미리 연락하여 자기 소개를 하고 멘토링 수업 일자 그리고 학교 답사 일정을 잡았다. 수업 당일에 일어날 변수를 최소화하고 싶었기에 사전 답사를 진행했다.

우리 팀의 경우 아주 lucky하게도 두 주에 걸쳐 모든 학교의 수업을 끝낼 수 있었다. 한 학교의 1차시 수업이 끝나면 바로 그 다음날 다른 학교의 2차시 교육을 하러 갔다. 지금 생각해도 참 잘 선택한 일정이었다.

학교에 가기 전에 해야할 일이 있어서 학교에서 팀원 모두가 모였다. 그러고 같이 점심을 먹고 출발하고자 했는데.. 떨려서 밥을 어떻게 먹었는지 기억도 안 난다.

A학교

첫 학교는 20명이나 되는 멘티님들이었다. 근데 분위기가.. 너무 열정이 넘쳤다. 조금만 여유를 주어도 바로 옆에 있는 친구와 장난을 쳤다. 수업이 끝나고 나서는 다들 녹초가 되었다.

B학교

코딩에 관심이 있는 친구들이 모인 동아리가 우리의 멘티님들이었다. A학교에서 워낙 요즘(?) 중학생들을 겪고 왔었기에 긴장을 많이 했는데, 이 학교는 그와 정반대로 사담이 전혀 없어서 놀랐다. (물론 갈수록 분위기가 좋아졌다!)

릴레이 수업

대면으로 진행했던 수업을 단축시켜서 90분 동안 온라인 멘티들을 위하여 수업을 해야 한다. 진행 n 개월 전에 8월 어떤 날 어떤 시간에 수업을 진행할지 선착순으로 신청할 수 있다.

핵심 수업만 진행하기 위하여 참여 멘토들도 따로 정했고, 릴레이 수업용 ppt도 따로 만들었다. 사정이 있는 한 친구 빼고 모두 한 장소에 모여서 진행했다.

많은 친구들이 적극적으로 참여해 주었다. 코로나로 인해 zoom 환경이 익숙한 멘티들과 멘토들이어서 수업이 한결 수월했던 것 같다.

좋았던 점

1. 중학생들의 AI 수업 환경과 수준에 대해 알 수 있었다.
   • 항상 궁금했다. 요즘 친구들은 초등학교 때부터 코딩을 배운다고 하던데... 서울 출신이 아닌 나는 특히 서울 안에 있는 학교들의 코딩 교육 실태가 궁금했다. 생각했던 것의 배는 좋은 실습실 환경을 보면서 '대한민국 IT의 미래는 밝다..⭐'고 생각했다.
2. 수업을 준비하면서 나 또한 성장할 수 있었다.
   • 지도학습, 비지도학습, 강화학습.. 은 대학에 들어와서 단 한 번도 들어보지 못한 단어이다. (고등학교 때 책 보다가 알았음.) 이와 같이 기본 AI 개념들에 대해서 내가 먼저 알아야 남에게 설명할 수 있다.를 명심하고 열심히 공부하며 준비했다.

아쉬웠던 점

1. 팀플은 처음이라서요.
   • 내가... 내가 처음이었다. 팀원들이랑 어떻게 소통을 해야하는지, 역할 분담은 어떻게 해야 이상적인지, 다들 불만은 없는지 등 '내가 잘 하고 있는 걸까?'에 대한 고민을 많이 했다.
2. 할 일이 꽤나 많다.
   • 물론 우리가 열정적으로 참여한 축에 속하기 때문도 있다. 하지만 수업 멘토링 + 컨텐츠 제작 + 대본 작성 등등 업로드할 것들이 계속 생겨서 (업로드하려면 소개글도 작성해야 하니까) 일을 어떻게 조절할지에 대해서도 생각하게 되었다.

     배울 점

3. 팀장은 확인 또 확인을 해야 한다.
   • 한 학교의 선생님들이 너무 바쁘셨는지 자꾸 놓치시는 것이 많았다. 나는 reminder를 한 번이면 족하다고 생각했는데, 전혀 그렇지 않았다. 그렇게 수업을 하기 위해 다시 학교에 방문했을 때 들었던 생각은 '그냥 내가 한 번 더 check 할 걸...' 이었다.
   • 여러 변수가 일어날 것을 미리 생각해야 한다.
4. 팀 내의 혼란성을 최소화 해야 한다.
   • 팀원들에게 정확한 업무와 데드라인을 공지해야 한다.
   • 최대한 구체적으로 내가 구상하는 것에 대해 이야기한다.
   • 팀원들의 사기를 올리기 위해 말투에 신경 쓴다.

한 줄 : 역량을 키울 수 있었다.

원래는 쓸 생각이었는데.. 어찌하다 보니... 이렇게나 길어졌다. 1편에는 이 활동이 무슨 활동인지에 대해 다루었고, 2편에서는 수업을 준비와 진행 그리고 느낀 점에 대해서 공유했다. 다음 편인 3편에서는 우리의 발자취(컨텐츠)를 공유하면서 마무리해 볼까 한다.

끝!

Tuples are another king of sequence that functions much like a list - they have elements which are indexed starting at 0

>>> x = ('Glenn', 'Sally', 'Joseph')
>>> print(x[2])
Joseph
>>> y = (1, 9, 2)
>>> print(y)
(1, 9, 2)
>>> print(max(y))
9 

but.. Tuples are “immutable”

Unlike a list, once you create a tuple, you cannot alter its contents - similar to a string

A Tale fo Two sequences

>>> l = list()
>>> dir(l)
['append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

>>> t = tuple()
>>> dir(t)
['count', 'index'] 

Tuples are more efficient

• Since Python does not have to build tuple structures to be modifiable, they are simpler and more efficient in terms of memory use and performance than lists
• So in our program when we are making “temporary variables” we prefer tuples over lists

Tuples and Assignment

• We can also put a tuple on the left-hand side of an assignment statement
• We can even omit the parentheses

>>> (x, y) = (4, 'fred')
>>> print(y)
fred
>>> (a, b) = (99, 98)
>>> print(a)
99

Tuples and Dictionaries

The items() method in dictionaries returns a list of (key, value) tuples

>>> d = dict()
>>> d['csev'] = 2
>>> d['cwen'] = 4
>>> for (k, v) in d.items() : 
                print(k, v)
...
...
csev 2
cwen 4
>>> tups = d.items()
>>> print(tups)
dict_items([('csev', 2), ('cwen', 4)])

Tuples are Comparable

The comparison operators work with tuples and other sequences. If the first item is equl, Python goes on to the next element, and so on, until it finds elements that differ.

(0, 1, 2) < (5, 1, 2)
# True 값을 가집니다.
 (0, 1, 2000000) < (0, 3, 4)
# True 값을 가집니다.
 ( 'Jones', 'Sally' ) < ('Jones', 'Sam')
# True 값을 가집니다.
 ( 'Jones', 'Sally') > ('Adams', 'Sam')
# True 값을 가집니다.

Sorting Lists of Tuples

• We can take advantage of the ability to sort a list of
• tuples* to get a sorted version of a dictionary
• First we sort the dictionary by the key using the items() method and
• sorted()* function

>>> d = {'a':10, 'b':1, 'c':22}
>>> d.items()
dict_items([('a', 10), ('c', 22), ('b', 1)])
>>> sorted(d.items())
[('a', 10), ('b', 1), ('c', 22)]

Using sorted()

We can do this even more directly using the built-in function sorted that takes a sequence as a parameter and returns a sorted sequence

>>> d = {'a':10, 'b':1, 'c':22}
>>> t = sorted(d.items())
>>> t
[('a', 10), ('b', 1), ('c', 22)]
>>> for k, v in sorted(d.items()):
                print(k, v)
...
...
a 10
b 1
c 22

Sort by values instead of key

• If we could construct a list of tuples of the form (value, key) we could sort by value
• We do this with a for loop that creates a list of tuples

>>> c = {'a':10, 'b':1, 'c':22}
>>> tmp = list()
>>> for k, v in c.items() :
    tmp.append( (v, k) )
...
...
>>> print(tmp)
# [(10, 'a'), (1, 'b'), (22, 'c')]
>>> tmp = sorted(tmp)
>>> print(tmp)
# [(1, 'b'), (10, 'a'), (22, 'c')]

The top 10 most common words

fhand = open('romeo.txt')
counts = {}
for line in fhand:
    words = line.split()
    for word in words:
        counts[word] = counts.get(word, 0 ) + 1

lst = []
for key, val in counts.items():
    newtup = (val, key) 
    lst.append(newtup)

lst = sorted(lst, reverse=True)

for val, key in lst[:10] :
    print(key, val)

Even Shorter Vwesion

List comprehension creates a dynamic list. In this case, we make a list of reversed tuples and then sort it.

c = {'a':10, 'b':1, 'c':22}
print( sorted( [ (v,k) for k,v in c.items() ] ) )
# [(1, 'b'), (10, 'a'), (22, 'c')]

Summary

• Tuple syntax
• Immutability
• Comparability
• Sorting
• Tuples in assignment statements
• Sorting dictionaries by either key or value

One common use of dictionaries is counting how often we “see” something

>>> ccc = dict()
>>> ccc['csev'] = 1
>>> ccc['cwen'] = 1
>>> print(ccc)
{'csev': 1, 'cwen': 1}
>>> ccc['cwen'] = ccc['cwen'] + 1
>>> print(ccc)
{'csev': 1, 'cwen': 2}

Dictionary Tracebacks

• It is an error to reference a key which is not in the dictionary
• We can use the in operator to see if a key is in the dictionary

>>> ccc = dict()
>>> print(ccc['csev'])
KeyError: 'csev'

When we see a new name

When we encounter a new name, we need to add a new entry in the dictionary and if this the second or later time we have seen the name, we simply add one to the count in the dictionary under that name

counts = dict()
names = ['csev', 'cwen', 'csev', 'zqian', 'cwen']
for name in names:
    if name not in counts :
            counts[name] = 1
    else : 
            counts[name] = counts[name] + 1
print(counts) 

The get method for dictionaries

The pattern of checking to see if a key is already in a dictionary and assuming a default value if the key is not there is so common that there is a method called get() that does this for us

Default value if they does not exist (and no Traceback).

if name in counts:
        x = counts[name]
else :
        x = 0

x = counts.get(name, 0)

{'csev': 2, 'zqian': 1, 'cwen': 2}

Simplified counting with get()

We can use get() and provide a default value of zero when the key is not yet in the dictionary - and then just add one

counts = dict()
names = ['csev', 'cwen', 'csev', 'zqian', 'cwen']
for name in names:
        counts[name] = counts.get(name, 0) + 1
print(counts) 

Counting Pattern

The general pattern to count the words in a line of text is to split the line into words, then loop through the words and use a dictionary to track the count of each word independently.

counts = dict()
print('Enter a line of text: ')
line = input('')

words = line.split()

print('Words:', words)

print('Counting...')
for word in words:
        counts[word] = counts.get(word, 0) + 1
print('Counts', counts) 

Definite Loops and Dictionaries

Even though dictionaries are not stored in order, we can write a for loop that goes through all the entries in a dictionary - actually it goes through all of the keys in the dictionary and looks up the values

You can get a list of keys, values, or items(both) from a dictionary

Bonus: Two Iteration Variables!

• We loop through the key-value pairs in a dictionary using “two” iteration variables
• Each iteration, the first variable is the key and the second variable is the corresponding value for the key

jjj = {'chuck' : 1, 'fred' : 42, 'jan' : 100}
for aaa.bbb in jjj.items() :
        print(aaa, bbb) 

name = input('Enter file:')
handle = open(name)

counts = dict()
for line in handle:
    words = line.split()
    for word in words:
        counts[word] = counts.get(word,0) + 1

bigcount = None
bigword = None
for word,count in counts.items():
    if bigcount is None or count > bigcount:
        bigword = word
        bigcount = count

print(bigword, bigcount)

Summary

• What is a collection?
• Lists versus Dictionaries
• Dictionary constants
• The most common word
• Using the get() method
• Hashing, and lack of order
• Writing dictionary loops
• Sneak peek: tuples
• Sorting dictionaries

• A collection is nice because we can put more than one value in it and carry them all around in one convenient package
• We have a bunch of values in a single “variable”
• We do this by having more than one place “in” the variable
• We have ways of finding the different places in the variable

What is not a “Collection”?

• Most of our variables have one value in them - when we put a new value in the variable - the old value is overwritten

$ python
>>> x = 2
>>> x = 4
>>> print(x)
4

A Story of Two Collections..

• List
  • A linear collection of values that stay in order
• Dictionary
  • A “bag” of values, each with its own label

Dictionaries

• Dictionaries are Python’s most powerful data collection
• Dictionaries allow us to do fast database-like operations in Python
• Dictionaries have different names in different languages
  • Associative Arrays - Perl / PHP
  • Properties or Map or HashMap - Java
  • Property Bag - C# / .Net
• Lists index their entries based on the position in the list
• Dictionaries are like bags - no order
• So we index the things we put in the dictionary with a “lookup tag”

>>> purse = dict()
>>> purse['money'] = 12
>>> purse['candy'] = 3
>>> purse['tissues'] = 75
>>> print(purse)
('money': 12, 'tissues': 75, 'candy': 3)
>>> print(purse['candy'])
3
>>> purse['candy'] = purse['candy'] +2
>>> print(purse)
('money': 12, 'tissues': 75, 'candy': 5) 

Comparing Lists and Dictionaries

Dictionaries are like lists except that they use keys instead of numbers to look up values

>>> 1st = list()
>>> 1st.append(21)
>>> 1st.append(183)
>>> print(1st)
[21, 183]
>>> 1st[0] = 23
>>> print(1st)
[23, 183]

Dictionary Lieterals (Constants)

• Dictionary literals use curly braces and have a list of key: value pairs
• You can make an empty dictionary using empty curly braces

python
>>> jjj = {'chuck' : 1, 'fred' : 42, 'jan': 100}
>>> print(jjj)
{'jan': 100, 'chuck': 1, 'fred': 42}
>>> ooo = { }
>>> print(ooo)
{}
>>> 

안녕하세요:) 오늘은 저의 첫 대외활동인 '소프트웨어야 놀자'에 대해 포스팅을 해보려고 합니다. 이 활동의 키워드는 바로 #교육 입니다.

소프트웨어야 놀자란?

전국의 대학생 멘토들이 초·중학생들에게 SW/AI 수업을 통해 AI&DATA 지식과 경험을 함께 나누는 교육 봉사 프로그램입니다.

무슨 활동을 하나요?

큰 카테고리로는 '수업'이라고 생각하시면 됩니다. 자체적인 수업을 준비해서 총 2학교(추가로 에 대면 멘토링을 나가야 합니다. (불가피한 상황에서는 비대면으로 진행!) 추가로 온라인으로 이루어지는 릴레이 수업도 필수로 참여해야 합니다. 팀의 홍보를 위해서 SNS 홍보를 위한 게시글도 꾸준히 올려야 합니다.

얼마나 활동하나요?

모집 기간은 대략 매년 5월 초에 마감됩니다. 활동은 5월~12월로 총 8개월 정도로 꽤나 긴 장기 프로젝트입니다.

각 달마다 무엇을 하나요?

대면 멘토링은 각 팀마다 다릅니다. 5월 : 지원서 제출, 발대식, 세부 역할 분담, 수업 및 예산 계획서 수정 후 재제출. 6월 : 전문가 피드백, 교육기관 컨택, 최종 활동 계획서 마감, 학교 답사. 7월 : 피어그룹과 회의 및 미션, 대면 멘토링 진행, 팀 소개 컨텐츠 제작. 8월 : 릴레이 수업, 여름 맞이 컨텐츠 제작.

+) 파란색으로 표시된 것은 소놀에서 진행하는 '이달의 소놀'이라는 미션을 수행한 것입니다. ++) 작성 날짜가 8월이기 때문에 12월 활동이 끝난 후 내용 추가하도록 하겠습니다.

We can create a new list by adding two existing lists together

>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> c = a + b
>>> print(c)
[1, 2, 3, 4, 5, 6]
>>> print(a)
[1, 2, 3]

Lists can be sliced using:

>>> t = [9, 41, 12, 3, 74, 15]
>>> t[1:3]
[41, 12]
>>> t[:4]
[9, 41, 12, 3]
>>> t[3:]
[3, 74, 15]
>>> t[:]
[9, 41, 12, 3, 74, 15]

Remember: Just like in strings, the second number is “up to but not including”

List Methods

>>> x = list()
>>> type(x)
<type 'list'>
>>> dir(x)
['append', 'count', 'extend', 'index', 'inser', 'pop', 'remove', 
'reverse', 'sor']

Data Structures - Python 3.10.6 documentation

https://docs.python.org/3/tutorial/datastructures.html

Building a List from Scratch

• We can create an empty list and then add elements using the append method
• The list stays in order and new elements are added at the end of the list

>>> stuff = list()
>>> stuff.append('book')
>>> studd.append(99)
>>> print(stuff)
['book', 99]
>>> stuff.append('cookies')
>>> print(stuff)
['book', 99, 'cookie']

Is Something in a List?

• Python provides two operators that let you check if an item is in a list
• These are logical operators that return True or False
• They do not modify the list

>>> some = [1, 9, 21, 10, 16]
>>> 9 in some
True
>>> 15 in some
False
>>> 20 not in some
True

Lists are in Order

• A list can hold many items and keeps those items in the order until we do something to change the order
• A list can be sorted (i.e., change its order)
• The sort method (unlike in strings) means “sort yourself”

>>> friends = ['Joseph', 'Glenn', 'Sally']
>>> friends.sort()
>>> print(friends)
['Glenn', 'Joseph', 'Sally'] 
Joseph 

Strings are immutable and lists are mutable.

Built-in Fuctions and Lists

• There are a number of functions built into Python that take lists as parameters.
• Remember the loops we built? These are much simpler.

>>> nums = [3, 41, 12, 9, 74, 15]
>>> print(len(nums))
6
>>> print(max(nums))
74
>>> print(min(nums))
3
>>> print(sum(nums)) 
154
>>> print(sum(nums)/len(nums)) 
25.6

Getting Average using Lists

numlist = list()
while True:
        inp = input('Enter a number: ')
        if inp == 'done' : break
        value = float(inp)
        numlist.append(value)

average = sum(numlist) / len(numlist)
print('Average:', average)

It uses more memory than using 'Total'.

Best Friends: Strings and Lists

>>> abc = 'With three words'
>>> stuff = abc.split()
>>> print(stuff)
['With', 'three', 'words']
>>> print(len(stuff))
3
>>> print(stuff[0])
With 

Split breaks a string into parts and produces a list of strings. We think of these as words. We can access a particular word or loop through all the words.

>>> line = 'A lot                of spaces'
>>> etc = line.split()
>>> print(etc)
['A', 'lot', 'of', 'spaces']
>>> 
>>> line = 'first;second;third'
>>> thing = line.split()
>>> print(thing)
['first;second;third']
>>> print(len(thing))
1
>>> thing = line.split(';')
>>> print(thing)
['first', 'second', 'third']
>>> print(len(thing))
3

• When you do not specify a delimiter, multiple spaces are treated like one delimiter
• You can specify what delimiter character to use in the splitting

Day Paring

From stephen.marquard@uct.ac.za Sat Jan 5:09:14:16 2008

fhand = open('mbox-short.txt')
for line in fhand:
        line = line.rstrip()
        if not line.startswitch('From ') : continue
        words = line.split()
        print(words[2])

The Double Split Pattern

• Sometimes we split a line one way, and then grab one of the pieces of the line and split that piece again

From stephen.marquard@uct.ac.za Sat Jan 5:09:14:16 2008

words = line.split()
email = words[1]
pieces = email.split('@')
print(pieces[1]) 

>>> stephen.marquard@uct.ac.za
>>> ['stephen.marquard', 'uct.ac.za']
>>> 'uct.ac.za'

List Summary

• Concept of a collection
• Lists and definite loops
• Indexing and lookup
• List mutability
• Functions: len, min, max, sum
• Slicing lists
• List methods: append, remove
• Sorting lists
• Splitting strings into lists of words
• Using split to parse strings

Programming

Algorithms

• A set of rules or steps used to solve a problem

Data Structures

• A particular way of organizing data in a computer

Lists are simple data structures

What is not a “Collection”

Most of our variables have one value in them - when we put a new value in the variable, the old value is overwritten

>>> x = 2
>>> x = 4
>>> print(x)
4

A List is a kind of Collection

• A collection allows us to put many values in a single “variable”
• A collection is nice because we can carry all many values aroud in one convenient package

friends = ['Joseph', 'Glenn', 'Sally']
carryon = ['socks', 'shirt', 'perfume'] 

List Constants

• List constants are surrounded by square brackets and the elements in the list are separated by commas
• A list element can be any Python object - even another list
• A list can be empty

>>> print([1, 24, 76])
[1, 24, 76]
>>> print(['red', 'yellow', 'blue'])
['red', 'yellow', 'blue']
>>> print(['red', 24, 98.6])
['red', 24, 98.6]
>>> print([1, [5, 6], 7])
[1, [5, 6], 7]
>>> print([])
[]

We already use lists!

for i in [5, 4, 3, 2, 1]:
        print(i) 
print('Blastoff!')

>>>5
4
3
2
1
Blastoff!

Lists and definite loops - best pals

friends = ['Joseph', 'Glenn', 'Sally']
for friend in friends :
        print('Happy New Year:', friend)
print('Done!')

>>> Happy New Year: Joseph
Happy New Year: Glenn
Happy New Year: Sally
Done!

Looking Inside Lists

Just like strings, we can get at any single element in a list using an index specified in square brackets.

It starts at 0, like in European elevators.

Lists are Mutable

• Strings are “immutable” - we cannot change the contents of a string - we must make a new string to make any change
• Lists are “mutable” - we can change an element of a list using the index operator

>>> fruit = 'Banana'
>>> fruit[0] = 'b'
Traceback
TypeError: 'str' object does not support item assignment
>>> x = fruit.lower()
>>> print(x)
banana
>>> lotto = [2, 14, 26, 41, 63]
>>> print(lotto)
[2, 14, 26, 41, 63]
>>> lotto[2] = 28
>>> print(lotto)
[2, 14, 28, 41, 63]

How Long is a List?

• The len() function takes a list as a parameter and returns the number of elements in the list
• Actually len() tells us the number of elements of any set or sequence (such as a string…)

>>> greet = 'Hello Bob'
>>> print(len(greet))
9
>>> x = [1, 2, 'joe', 99]
>>> print(len(x))
4

Using the range function

• The range function returns a list of numbers that range from zero to one less than the parameter
• We can construct an index loop using for and an integer iterator

>>> print(range(4))
[0, 1, 2, 3]
>>> friends = ['Joseph', 'Glenn', 'Sally']
>>> print(len(friends))
3
>>> print(range(len(firends))
[0, 1, 2]

A table of two loops…

frineds = ['Joseph', 'Glenn', 'Sally']

for friend in friends:
        print('Happy New Year:', friend)

for i in range(len(friends)):
        friend = friends[i]
        print('Happy New Year:', friend)

>>> Happy New Year: Joseph
Happy New Year: Glenn
Happy New Year: Sally 

>>> frineds = ['Joseph', 'Glenn', 'Sally']
>>> print(len(frineds))
3
>>> print(range(len(friends)))
[0, 1, 2]

• A text file can be thought of as a sequence of lines

Opening a File

• Before we can read the contents of the file, we must tell Python which file we are going to work with and what we will be doing with the file
• This is done with the open() function
• open() returns a “file handle” - a variable used to perform operations on the file
• Similar to “File → Open” in a Word Processor

Using open()

• handle = open(filename, mode)
• fhand = open(’mbox.txt’, ‘r’)
• returns a handle use to manupulate the file
• filename is a string
• mode is optional and should be ‘r’ if we are planning to read the file and ‘w’ if we are going to write to the file

What is a Handle?

>>> fhand = open('mbox.txt')
>>> print(fhand)
<_io.TextIOWrapper name = 'mbox.txt' mode='r' encoding='UTF-8'>

When Files are Missing

• Traceback Error

Then newline Character

• We use a special character called the “newline” to indicate when a line ends
• We present it as \n in strings
• Newline is still one character - not two

>>> stuff = 'Hello\nWorld'
>>> stuff
'Hello\nWorld'

>>> print(stuff)
Hello 
World!

>>> stuff = 'X\nY'
>>> print(stuff)
X
Y

>>> len(stuff)
3

‘\n’ is also considered as one character.

File Processing

• A text file can be thought of as a sequence of lines

File Handle as a Sequence

• A file handle open for read can be treated as a sequence of strings where each line in the file is a string in the sequence
• We can use the for statement to iterate through a sequence
• Remember - a sequence is an ordered set

xfile = open('mbox.txt')
for cheese in xfile:
        print(cheese)

Counting Lines in a File

• Open a file read-only
• Use a for loop to read each line
• Count the lines and print out the number of lines

fhand = open('mbox.txt')
count = 0
for line in fhand:
        count = count + 1
print('Line Count:', count)

$ Python open.py
Line Count: 132045

Reading the Whole File

We can read the while file (newlines and all) into a single string

>>> fhand = open('mbox-short.txt')
>>> inp = fhand.read()
>>> print(len(inp))
94626
>>> print(inpp[:20])
From stephen.marquar

Searching Through a File

We can put an if statement in our for loop to only print lines that meet some criteria

fhand = open('mbox-short.txt')
for line in fhand:
    if line.startswitch('From:') :
            print(line) 

OOPS!

What are all these blank lines doing here?

• Each line from the file has a newline at the end
• The print statement adds a newline to each line

Searching Through a File (fixed)

• We can strip the whitespace from the right-hand side of the string using rstrip() from the string library
• The newline is considered “white space” and is stripped

fhand = open('mbox-short.txt')
for line in fhand:
    line = line.rstrip()
    if line.startswitch('From:') :
            print(line) 

Skipping with continue

We can conveniently skip a line by using the continue statement

fhand = open('mbox-short.txt')
for line in fhand:
    line = line.rstrip()
    if not line.startswitch('From:') :
            continue
    print(line) 

Using in to select lines

We can look for a string anywhere in a line as our selection criteria

fhand = open('mbox-short.txt')
for line in fhand:
        line = line.rstrip()
        if not '@uct.ac.za' in line :
                continue
        print(line)

Prompt for File Name

fname = input('Enter the file name:  ')
try:
    fhand = open(fname)
except:
    print('File cannot be opened: ', fname)
    quit()

count = 0
for line in fhand:
    if line.startswith('Subject:') :
        count = count + 1
print('There were', count, 'subject lines in', fname)

• A string is a sequence of characters
• A string literal uses quotes ‘Hello’ or “Hello”
• For strings, + means “concatenate”
• When a string contains numbers, it is still a string
• We can convert numbers in a string into a number using int()

str1 = "Hello"
str2 = 'there'
bob = str1 + str2

print(bob)
>>>Hellothere

str3 = '123'
x = int(str3) + 1
print(x)
>>> 124

Reading and Converting

• We prefer to read data in using strings and then parse and convert the data as we need
• This gives us more control over error situations and/or bad user input
• Raw input numbers must be converted from strings

Looking Inside Strings

• We can get at any single character in a string using an index specified in square brackets
• The index value must be an integer and starts at zero
• The index value can be an expression that is computed

fruit = 'banana'
letter = fruit[1]
print(letter)
>>> a

x = 3
w = fruit[x-1]
print(w)
>>> n

A Character Too Far

• You will get a python error if you attempt to index beyond the end of a string.
• So be careful when constructing index values and slices

Strings Have Length

The built-in function len gives us the length of a string

fruit = 'banana'
print(len(fruit))
>>> 6

Len Function

A function is some stored code that we use. A function takes some input and produeces an output.

Looping Through Strings

Using a while statement and an iteration variable, and the len function, we can construct a loop to look at each of the letters in a string individually.

fruit = 'banana'
index = 0
while index < len(fruit):
        letter = fruit[index]
        print(index, letter)
        index = index + 1

>>> 0 b
        1 a 
        2 n
        3 a
    4 n
        5 a

• A definite loop using a for statement is much more elegant
• The iteration variable is completely taken care of by the for loop

fruit = 'banana'
for letter in fruit:
        print(letter)

Looping and Countring

This is a simple loop that loops through each letter in a string and counts the number of times the loop encounters the ‘a’ character.

word = 'banana'
count = 0
for letter in word:
        if letter == 'a':
                count = count + 1
print(count)

Looking deeper into in

• The iteration variable “iterates” through the sequence (oredered set)
• The block (body) of code is executed once for each value in the sequence
• The iteration variable moves through all of the values in the sequence

for letter in 'banana':
            print(letter)

Slicing Strings

• We can also look at any continuous section of a string using a colon operator
• The second number is one beyond the end of the slice - “up to but not including”
• If the second number is beyond the end of the string, it stops at the end

s = 'Monty Python'

>>>print(s[0:4])
Mont

>>>print(s[6:7])
P

>>>print(s[6:20])
Python

If we leave off the first number of the last number of the slice, it is assumed to be the beginning or end of the string respectively.

String Concatenation

When the + operator is applied to strings, it means “concatenation”

>>> a = 'Hello'
>>> b = a + 'There'
>>> print(b)
HelloThere

>>> c = a + ' ' + 'There'
>>> print(c)
Hello There

Using in as a logical Opearator

• The in keyword can also be used to check to see if one string is “in” another string
• The in expression is a logical expression that returns True or False and can be used in an if statement

String Library

• Python has a number of string functions which are in the string library
• These functions are already built into every string - we invoke them by appending the function to the string variable
• These functions do not modify the original string, instead they return a new string that has been altered

>>> greet = 'Hello Bob'
>>> zap = greet.lower()
>>> print(zap)
hello bob

>>>print(greet)
Hello Bob

>>>print('Hi There'.lower())
hi there

- Strings are also objects.

str.capitalize()
str.center(width[, fillchar])
str.endswitch(suffix[, start[, end]])
str.find(sub[, start[, end]])
str.lstrip([chars])
str.replace(old, new[, count])
str.lower()
str.rstrip([chars])
str.strip([cahrs])
str.upper()

Searching a String

• We use the find() function to search for a substring within another string
• find() finds the first occurrence of the substring
• If the substring is not found, find() returns -1

  Remember that string position starts at zero

>>> fruit = 'banana'
>>> pos = fruit.find('na')
>>> print(pos)
2

>>> aa = fruit.find('z)
>>> print(aa)
-1

Making everything UPPER CASE

• You can make a copy of a string in lower case or upper case
  • Often when we are searching for a string using find() we first convert the string to lower case so we can search a string regardless of case

Search and Replace

• The replace() function is like a “search and replace” operation in a word processor
• It replaces all occurrences of the search string with the ** replacement string**

>>> greet = 'Hello Bob'
>>> nstr = greet.replace('Bob', 'Jane')
>>> print(nstr)
Hello Jane

>>> nstr = greet.replace('o', 'X')
>>> print(nstr)
HellX BXb

Stripping Whitespace

• Sometimes we want to take a string and remove whitespace at the beginning and/or end
  • lstrip() and rstrip() remove whitespace at the left or right
  • strip() removes both beginning and ending whitespace

>>> greet = '   Hello Bob   '
>>> greet.lstrip()
'Hello Bob   '
>>> greet.rstrip()
'   Hello Bob'
>>> greet.strip()
'Hello Bob'

Prefixes

>>> line = 'Please have a nice day'
>>> line.startswitch('Please')
True
>>> line.startswith('p')
False

Parsing and Extracting

The trick is “knowing” something about the whole loop when you are stuck writing code that only sees one entry at a time

Set some variables to initial values
for thing in data:
        Look for something or do something to each entry separately, 
        updating a variable
Look at the variables

Finding the largest value

We make a variable that contains the largest value we have seen so far. If the current number we are looking at is larger, it is the new largest value we have seen so far.

largest_so_far = -1
print('Before', largest_so_far)

for the_num in [9, 41, 12, 3, 74, 15]:
    if the_num > largest_so_far:
            largest_so_far = the_num
    print(largest_so_far, the_num)

print('After', largest_so_far)

Counting in a Loop

zork = 0
print('Before', zork)

for thing in [9, 41, 12, 3, 74, 15]:
        zork = zork + 1
        print(zork, thing)

print('After', zork)

To count how many times we execute a loop, we introduce a counter variable that starts at 0 and we add one to it each time through the loop.

Summing in a Loop

zork = 0
print('Before', zork)

for thing in [9, 41, 12, 3, 74, 15]:
        zork = zork + thing
        print(zork, thing)

print('After', zork)

To add up a value we encounter in a loop, we introduce a sum variable that starts at 0 and we add the value to the sum each time through the loop.

Finding the Average in a Loop

count = 0
sum = 0
print('Before', count, sum)

for value in [9, 41, 12, 3, 74, 15]:
        count = count + 1
        sum = sum + value
        print(count, sum, value)

print('After', count, sum, sum/count)

An average just combines the counting and sum patterns and divides when the loop is done.

Filtering in a Loop

print('Before')
for value in [9, 41, 12, 3, 74, 15]:
        if value > 20:
                print('Large number', value)
print('After')

We use an if statement in the loop to catch/filter the values we are looking for.

Search Using a Boolean Variable

found = false
print('Before', found)

for value in [9, 41, 12, 3, 74, 15]:
        if value == 3:
                found = True
        print(found, True)

print('After', found)

If we just want to search and know if a value was found, we use a variable that starts at False and is set to True as soon as we find what we are looking for.

How to find the smallest value

How would we change this to make it find the smallest value in the list?

Finding the smallest value

smallest = None
print('Before')

for value in [9, 41, 12, 3, 74, 15]:
        if smallest is None:
                smallest = value
        elif value < smallest:
                smallest = value
        print(smallest, value)

print('After', smallest)

We still have a variable that is the smallest so far.

The first time through the loop smallest is None, so we take the first value to be the smallest.

None Types

• 단 하나의 값만 가지는 특별한 표식 (None)
• None을 저장했는지 확인할 수 있음
• 공백을 나타내기 위해 쓰임

The “is” and “is not” Operators

• Python has an is operator that can be used in logical expressions
• Implies “is the same as”
• Similar to, but stronger than ==
  • is not also is a logical operator

ex) 0 == 0.0 → True

0 is 0.0 → False [different data types]

Loops (repeated steps) have iteration variables that change each time through a loop. Often these iteration variables on through a sequence of numbers.

n = 5
while n > 0:
        print(n)
        n = n - 1
print('Blastoff!')
print(n)

/*Output
5
4
3
2
1
Blastoff!
0
*/

Breaking Out of a Loop

• The break statement ends the current loop and jumps to the statement immediately following the loop
• It is like a loop test that can happen anywhere in the body of the loop

while True:
        line = input('> ')
        if line == 'done':
                break;
        print(line)
print('Done!') 

> hello there
hello there
> finished
finished
> done
Done! 

Finishing an Iteration with continue

The continue statement ends the current iteration and jumps to the top of the loop and starts the next iteration

while True:
        line = raw_input('> ')
        if line[0] == '#':
                continue
        if line == 'done':
                break
        print(line)
print('Done!')

Indefinite Loops

• While loops are called “indefinite loops” because they keep going until a logical condition becomes False
• The loops we have seen so far are pretty easy to examine to see if they will terminate or if they will be “infinite loops”
• Sometimes it is a little harder to be sure if a loop will terminate

Definite Loops

• Quite often we have a list of items of the lines in a file - effectively a finite set of things
• We can write a loop to run the loop once for each of the items in a set using the Python for construct
• These loops are called “definite loops” because they execute an exact number of times
• We say that “definite loops iterate through the members of a set”

A Simple Definite Loop

for i in [5, 4, 3, 2, 1]:
        print(i)
print('Blastoff!')

/*Output
5
4
3
2
1
Blastoff!
*/

A Simple Definite Loop

Definite loops (for loops) have explicit iteration variables that change each time through a loop. These iteration variables move through the sequence or set.

Looking at In…

• The iteration variable “iterates” through the sequence (ordered set)
• The block (body) of code is executed once for each value in the sequence
• The iteration variable moves through all of the values in the sequence

Loop Idioms: What We Do in Loops

Note: Even though these examples are simple, the patterns apply to all kinds of loops

//Program
def thing():
        print('Hello')
        print('Fun')
thing()
print('Zip')
thing()

//Output
Hello
Fun
Zip
Hello
Fun

Python Functions

• There are two kinds of functiongs in Python.
• Built-in functions that are provided as part of Python - print(), input(), type(), float(), int() …
• Functions that we define ourselves and then use
• We treat the built-in function names as “new” reserved words (i.e., we avoid them as variable names)

Function Definition

• In Python a function is some reusable code that takes arguments(s) as input, does some computation, and then returns a result or results
• We define a function using the def reserved word
• We call/invoke the function by using the function name, parentheses, and arguments in an expression

In English, lowercase letters have a higher value than uppercase letters.

>>> big = max('Hello world')
>>> print(big)
w

>>> tiny = min('Hello world')
>>> print(tiny)
( ) 

Max Function

• A function is some stored code that we use. A function takes some input and produces an output.

Type Conversions

• When you put an integer and floating point in an expression, the integer is implicitly converted to a float
• You can control this with the built-in functions int() and float()

>>> print float(99)/100
0.99

>>> i = 42
>>> type(i)
<class 'int'>

>>> f = float(i)
>>> print(f)
42.0

>>> type(f)
<class 'float'>

>>> print(1 + 2 * float(3) / 4 - 5)
-2.5 

String Conversions

• You can also use int() and float() to convert between strings and integers
• You will get an error if the string does not contain numeric characters

Building our Own Functions

• We create a new function using the def keyword followed by optional parameters in parentheses
• We indent the body of the function
• This defines the function but does not execute the body of the function

def print_lyrics():
        print("I'm a lumberjack, and I'm okay.")
        print('I sleep all night and I work all day.') 

Definitions and Uses

• Once we have defined a function, we can call (or invoke) it as many times as we like
• This is the store and reuse pattern

Arguments

• An argument is a value we pass into the function as its input when we call the function
• We use arguments so we can direct the function to do different kinds of work when we call it at different times
• We put the arguments in parentheses after the name of the function

Parameters

A parameter is a variable which we use in the function definition. It is a “handle” that allows the code in the function to access the arguments for a particular function invocation.

Return Values

Often a function will take its arguments, do some computation, and return a value to be used as the value of the function call in the calling expression. The return keyword is used for this.

def greet():
        return "Hello"

print(greet(), "Gleen")
print(greet(), "Sally")

Reutrn Value

• A “fruitful” function is one that produces a result (or return value)
• The return statement ends the function execution and “sends back” the result of the function

>>> def greet(lang):
                if lang == 'es':
                        return 'Hola'
                elif lang == 'fr':
                        return 'Bonjour'
                else: 
                        return 'Hello'
>>> print(greet('en'), 'Glenn')
Hello Glenn
>>> print(greet('es'), 'Sally')
Hola Sally
>>> print(greet('fr'), 'Michael')
Bonjour Michael

Multiple Parameters/Arguments

• We can define more than one parameter in the function definition
• We simply add more arguments when we call the function
• We match the number and order of arguments and parameters

def addtwo(a, b):
        added = a + b
        return added

x = addtwo(3, 5)
print(x)

8

Void (non-fruitful) Functions

• When a function does not return a value, we call it a “void” function
• Functions that return values are “fruitful” functions
• Void functions are “not fruitful”

To function or not to function..

• Organize your code into “paragraphs” - capture a complete thought and “name it”
• Don’t repeat yourself - make it work once and then reuse it
• If something gets too long or complex, break it up into logical chunks and put those chunks in functions
• Make a library of common stuff that you do over and over - perhaps share this with your friends…

Summary

• Arguments
• Results (fruitful functions)
• Void (non-fruitful) functions
• Why use functions?
• Functions
• Built-In Functions
  • Type conversion (int, float)
  • String conversions
• Parameters

Comparison Operators

• Boolean expressions ask a question and produce a Yes or No result which we use to control program flow
• Boolean expressions using comparison operators evaluate to True / False or Yes / No
• Comparison operators look at variables but do not change the variables

Indentation

• Increase indent after an if statement or for statement or for statement [after : ]
• Maintain indent to indicate the scope of the block (which lines are affected by the if/for)
• Reduce indent back to the level of the if statement or for statement to indicate the end of the blcok
• Blank lines are ignored - they do not affect indentation
• Comments on a line by themselves are ignored with regard to indentation

Warning : Turn Off Tabs(4 spaces)!

• Atom automatically uses spaces for files with “.py” extension (nice!)
• Most text editors can turn tabs into spaces - make sure to enable this feature
  • NotePad++ : Settings → Preferences → Language Menu/Tab Settings
  • TextWragler : TextWrangler → Preferences → Editor Defaults
• Python cares a lot about how far a line is intended. If you mix tabs and spaces, you may get “indentation errors” even if everything looks fine

Two-way Decisions

• Sometimes we want to do one thing if a logical expression is true and something else if the expression is false
• It is like a fork in the road - we must choose one or the other path but not both

Multi-way Decision

The try/except Structure

• You surround a dangerous section of code with try and except
• If the code in the try works - the except is skipped
• If the code in the try fails - it jumps to the except section

astr = 'Hello Bob'
try:
        istr = int(astr)
except:
        istr = -1

print('First', istr)

astr = '123'
try:
        istr = int(astr)
except:
        istr = -1

print('Second', istr)

Sample try/except

rawstr = input('Enter a number:')
try:
        ival = int(rawstr)
except:
        ival = -1

if ival > 0 :
    print('Nice work')
else:
    print('Not a number')

Summary

• Comparison operator
  • ==, <=, >=, >, <, !, =
• Indentation
• One-way Decisions
• Two-way decisions: if: and else:
• Nested Decisions
• Multi-way decisions using elif
• try/except to compensate for errors

아키텍쳐/DB - "DB 뭐 쓰세요?"

만약 회사에 개발자가 100명이라고 한다면…

• 프론트엔드 개발자 : 10명

• 백엔드(서버) 개발자 : 90명

• 서버

  • 여러가지 역할들로 구성된 집합체

※ 서버와 클라이언트 구성

돈도 별로 없고 사용자도 별로 없을 때 (=스타트업 초창기) 심지어 한 컴퓨터 안에 웹서버와 DB를 다 둔다.

→ 사용료가 이렇게 하면 만 원 정도밖에 안 나온다.

쫌 잘된다. 유저가 많아져서 데이터 저장소를 따로 뺌.

규모가 더 커지면 웹서버를 늘린다. 데이터는 한 곳에 모아지는 것이 좋기 때문.

더 커지면 상태를 체크만 하는 서버도 따로 필요하다.

더 더 키지면 **클라우드 서비스**를 이용한다.

• 클라우드를 잘 이용해서 잘 구성하는 것이 스타트업이 탄탄하게 개발을 할 수 있는 핵심 역량이 되기도 한다.

• **데이터베이스**

  • 잘 찾기 위해서 존재하는 것.

    Ex) 경영 섹션 > 출판사 별 > 책 제목별로 정리되어 있을 때, 뭐가 쉬울까?

    1) ‘사랑’이 제목에 들어간 책 다 주세요

    2) ‘한국출판사’ 책 다 주세요

  • DB도 이렇게 정렬된 상태대로 찾아야 빠르게 찾아온다.

  • 정리된 항목을 인덱스 라고 한다.

    • 인덱스를 타야 빠르게 가져온다.

    • 인덱스를 잘못하면 쭉 보는 걸 풀스캔 떴다라고 표현한다.

      → 불려간다!

      
      

※ SQL vs NoSQL (Not-only SQL)

정형화된 SQL

• 실수를 절대 하면 안 되는 대기업에서 주로 사용.

비정형화된 Not-only SQL

• 스타트업에서 주로 사용

굉장히 쉽고, 문법이 몇 개 없다.

한번 배워두면 요긴하게 직장생활에서 쓰일 수 있다.

데이터분석을 하기위해 SQL을 배운다 = SQL DB에서 데이터를 빼내는 방법을 배운다.

협업 - "git에 커밋했습니다"

• 깃업

  : 부분을 나눠서 작업하고, 합치는 방법.

1. 세이브 포인트
2. 업로드
3. 다운로드 (+자동/수동 충돌 해결)
4. 브랜치 따기
5. 머지하기(합치기)

서버-클라이언트 통신 - "저희가 API 열어드릴게요"

• 창구, 약속 (API)
  1. 아이디를 갖고와 - 주문내역을 알려줄게
  2. 주소를 갖고와 - 음식점을 알려줄게
  3. 주문번호를 갖고와 - 배달현황을 알려줄게

http://서버 위치/ API 주소?가져가기로 한 데이터

“김 책임님 이거 신규 피쳐라 API 하나만 따주세요”

= 새로운 기능 창구를 하나 만들어달라. 그 쪽으로 요청하겠음.

"API 개발은 끝났고, 클라이언트는 아직이에요”

= 창구는 다 만들었는데, 요청하는 쪽이 아직 작업 중.

• Open API
  • 누구나 요철할 수 있게 열어둔 AOP
  • 주로 공공데이터를 열람하는 사이트

• 서버는 요청이 어디서 오는 건지 상관 없다!

개발 언어/프레임워크 - "요새는 리액트로 개발해요"

• 프레임워크

  • 미리 만들어놓은 블록 세트.

    • Java로 만든 프레임워크 (제일 유명:Spring)
    • Node.js로 만든 프레임워크 (제일 유명:Express)
    • Python으로 만든 프레임워크 (제일 유명:Django, Flask)

    

• 모두 다 Javascript로 만든 프레임워크

HTML, CSS, Javascript를 더 잘 쓸 수 있게 하는 프레임워크. 체감상 리액트가 대세. 그런데 셋 중 하나 할 줄 알면 금방 배운다는 이야기.

• 대부분의 언어로 서버를 만들 수 있다고 봐도 무방.

  (HTML, CSS, JS를 제외하고)

  • 많이 쓰이는 것은 Java, Python, Node js.

서버

1. Java
   1. 어렵다.
   2. 형식이 많다.
   3. 큰 회사에서 많이 쓴다.
2. Python
   1. 쉽게 입문할 수 있다.
   2. 자유롭다.
   3. 데이터분석에도 쓸 수 있다.
3. Node js
   1. Javascript와 문법이 거의 같다.
   2. 스타트업에서 많이 쓴다.

앱

안드로이드 → Kotlin

아이폰 → Swift

한번에 개발

1. Flutter
2. React Native

요새는 C언어를 현업에서 많이 사용하지 않는다.

임베디드나 칩을 다루는 곳에서나 다룬다.

결론

서버를 처음부터 다 만들지 않는다. 누가 만들어 놓은 프레임 워크를 가져다가 잘 쓰는 것이 중요하다!

• 우린 사실 매일 기계를 제어하고 있는 것.
• 운영체제(OS)가 그 역할을 하고 있음.
  • 인간이 기계와 소통할 수 있게 만드는 기반 프로그램.
  • OS에게는 우리가 키보드나 마우스로 명령을 내린다.
  • 꼭 키보드나 마우스로? No!! Coding으로!!

서버마다 운영체제를 다 깔아야 하는데, Linux는 무료로 사용할 수 있다.

Linux = ‘오픈소스’. 회사에서 보통 ‘서버 컴퓨터다’라고 한다면, 아 Linux 사용하고 있다고 생각해도 무방하다.

• 코딩 (= 프로그래밍)
  • 컴퓨터에게 내릴 수 있는 모든 명령.
  • 각 언어마다 특성이 다르므로 여러 프로그래밍 언어를 사용.
• 프로그램
  • 미리 짜둬서 매번 똑같이 움직이는 것
  • ex) 파워포인트, 엑셀, 워드 등
• 인터넷
  • 컴퓨터끼리 서로 소통하는 것
  • 대화를 주고 받기 위해서 규칙이 필요하다.
  • 웹 통신
    • ex) http:// → 지금부터 웹의 규칙대로 이야기할 것이라는 암시.
    • https:// → 암구호 표를 서로 가져서 가운데서 엿듣지 못하도록 하는 것.

If, “잘 듣고 있다가 누가 http 요청하면 이 파일을 돌려줘” 라고 명령을 한다면?

그게 바로 “웹 서버”를 만들었다고 하는 것!

웹서비스 동작 방식 - "서버가 죽었네요"

• 서버

  • 가운데서 데이터를 저장하고, 주는 것.
  • 사실은 그냥 컴퓨터 껍데기 떼고 가로로 눕히는 것.
  • 즉, 서버란 “컴퓨터”라는 사람의 직업과 같은 것.
    • (DB, 웹서핑, ··· 투잡 쓰리잡 가능!

• 브라우저

  • 요청 + 그려주기의 역할 담당.

서버 → 브라우저

1. HTML : 뼈대

2. CSS : 예쁘게
   
3. Javascript : 움직이게

자동완성 기능을 사용할 수 있게 됨.

결론: 다 형식이 정해져 있다.

→ 제이슨방식

• ‘키 : 밸류’ 의 방식

• 웹은 다 받아서 다 다시 그리는 형태, 앱은 껍데기는 있고 데이터만 왔다갔다하는 형태.