파이썬 훈련 다음 날 - 기초 2

'' '' '' 
'' ' 
리스팅 : 
    정의 : []의 값이 임의의 종류의 복수에 저장 될 수 
    콤마로 분리된다. 
    일반적으로 학생들 저장하는 데 사용 '등 흥미, 수업 기간, ... 
' '' 
#는, 학생들의 목록을 정의하는 하나 개 이상의 학생 저장할 수 있습니다 
# 목록 ([ '조 스미스', '홍길동', '다섯 왕' 조 여섯 ']) 
# 학생. ='홍길동 ','홍길동 ','왕 우 ','여섯 조 '] 
# 전단 (학생.. 1]) 홍길동 # 
# 
# student_info ='보 '84 'MALE'[ '버블 8', '9 음료'] 
## 보 모든 관심 학생 인출 
(student_info [3]) # 프린트 
제 취미 보 취할 # # 1 # 학생 
# 인쇄 (student_info [3 [1]) 
#의 
# # 1 우선 동작 제어 : 
# 1 #, 인덱스 값 (전방 + 액세스 접속을 역방향)에 액세스하여이 : 입금으로 이송 될 수있다 
(# 인쇄 [-2]) student_info # 보 
#의 
# # 2, 슬라이스 (상관없이 최종 처리 단계) 
# 전단 (student_info [0 :. 4 :



# 
## (4), 및하지의 조작 부재 
(student_info에서 '보') # 인쇄 # 트루 
# 전단 ( '보'없음 student_info에서) # 거짓 
#의 
##. 5, 별도로 
# student_info = '보', 84, '남성'] [ '거품 (8)', '9 마시는'] 
# 번호가 student_info의 끝에서 값 목록을 추가 
#의 student_info.append ( '안녕, 내 학교') 
# 인쇄 (student_info) 
#의 
# # 6, 삭제 
# #의 목록 인덱스 값을 삭제하려면 2 
# 델 student_info [2] 
# 인쇄 (student_info) 

# 7, 사이클 
student_info에서 학생에 대한 # : 
# 인쇄 (학생) 

# 알아야 : 
# student_info = [ '작은이' 95 '여성', 95] [ '당황 댄스', '마이클 쳤다'] 
# 번호는 색인 목록의 값을 구하는 1.index 
# 인쇄 (student_info.index (95)) # 1 
# 
# # 2.의 값을 얻을 목록의 수를 계산
인쇄 # (student_info.count (95)) # 2 
#의 
# 번호 3. 값, 기본 삭제, 목록에 유사한 마지막 값을 
팝업 () 괄호는 인덱스를 작성하는 경우 # 번호를 인덱스에 대응하는 값 소요 
#의 student_info을 .pop () 
# 전단 (student_info) 
# 번호 목록 2의 인덱스 값을 추출하고, 변수 이름 성별 할당 
#의 student_info.pop 성 = (2) 
# 전단 (성별) 
# 전단 (student_info) 

# student_info = ' 작은 두 ', 95,'여성 ', [' 95] 당황 춤 ','마이클 '소리 쳤다] 
#의 
# 번호 4. 제거, 제거 할 수있는 목록에서 첫 번째 값의 값 
#의 student_info.remove을 (95) 
# 인쇄 (student_info) #은 [ '작은 두', '여성', [ '당황 춤', '마이클 소리 쳤다', 95] 
#의 
# 이름 = student_info.remove ( '거의 2') 
# 인쇄 (이름 ) 없음 # 1 
# 전단 (student_info) # [ 'FEMALE'[ '당황 댄스'] 밀 호출 ', 95] 

# 5 인서트 값 
# student_info ='개의 작은 '95, '여성', 95 '당황 춤', '마이클 소리 쳤다']]
student_info의 ###에서 삽입 위치의 인덱스 3 "INSTITUTE" 
# # 1 student_info.insert (3 '대학') 
## 인쇄 (student_info) 

#에 6.extend 유착리스트 
#의 student_info1 = '개의 작은'95 'FEMALE'[ '당황 댄스 1', '통화 밀 (2'), (95)] 
# student_info2 = '작은 사', 94 ', 여성' [ ' 당황 댄스 1', '밀 2 호출'] 
## 모든 student_info2의 student_info1의 삽입 값 
#의 student_info1.extend (student_info2) 
# 전단 (student_info1) 

'' '튜플 데이터 유형' ' 

#DEFINE : 
# 튜플 ((1,2 ,. 3'오 ','. 여섯 ')) 
tuple1 = (1,2 ,. 3.'오 ','여섯 ') 
인쇄 (tuple1) # (1,2 ,. 3.'오 ','여섯 ') 
# 우선 제어 동작 :
# 1 인덱스 값에 따라 (정 + 후진 찍) 만 취 
인쇄 (tuple1 [2]) (3) #. 

# 2, 슬라이스 (상관없이 최종 처리 단계) 
# 0 슬라이스에서 시작 5-1 단계 3 
인쇄 (tuple1의 [0 :. 5 : 3]) # (1 '오'). 

# 3의 길이 
인쇄 (LEN (tuple1)) # 5

# 4의 작업의 회원들과하지에 
(tuple1 1) 인쇄 # 진정한 
인쇄 (1하지 tuple1에서) 거짓 # 

# 5, 순환 
tuple1의 라인 : 
    # 인쇄 (라인) 
    # 인쇄 기본 최종 매개 변수는 N- \되는 
    인쇄 ( 라인 엔드 = '_')가 

'' '' '' 
'' ' 
불변 : 
    수정 변수의 값을 상기 메모리 어드레스는 달라야한다. 
    디지털 형 
        INT 
        부동 소수점 

    문자열 유형 
#의 STR의 
#의      
# 튜플 
# 튜플 
#의          
# 변수 유형 : 
# 유형 목록 
# 목록 
#      
# 사전 
#의 DICT의 
#의          
# '' ' 
# # 불변 
# 번호의 INT의 
# 번호 = 100
# 전단 (ID (번호)) # 1434810944 
# 번호 = 111 
# 인쇄 (ID (번호)) # 1434811296 
#의 
# 번호 플로트 
# SAL = 1.0 
# 인쇄 (ID (SAL)) # 2,771,339,842,064 
# SAL = 2.0 
# 인쇄 (ID (SAL)) 2771339841896 # 
# 
# STR1 = '파이썬 안녕하세요!' 
# 인쇄 (ID (STR1)) # 1975751484528 
#의 STR2 = str1.replace ( '안녕하세요') '와 같은' 
# 인쇄 (ID (STR2)) # 1975751484400 


가변형 번호 : 
#리스트 

목록 1 =. 1,2 ,. 3] 

리스트 2 = List1이 
list1.append. (4) 

# 목록 1과리스트 2 지점이 동일한 메모리 어드레스 인 
프린트 (ID (목록 1)) 
프린트 (ID (리스트 2)) 
인쇄 (List1입니다) 
인쇄 (목록 2) 

"" "" "" 
'' ' 
사전 : 
    조치 :
        인은 {}, 쉼표로 구분하여 복수의 값에 저장할 수있는 
        키 - 값의 높은 속도 값을 액세스 할. 

    정의 : 
        키, 값은 모든 종류의 수 있습니다 불변의 유형을해야합니다 
'' ' 

# dict1 = DICT ({'나이 : ':'탱크 이름 '(18),이다' '}) 
# dict1 = {'나이 '(18)는,'이름 ':'탱크 '} 
# 인쇄 (dict1) {#'나이 : ':'탱크 '} 이름'18 인 ' 
# 인쇄 (유형 (dict1)) # <클래스'DICT '> 

# 값, 사전 이름 +를 [ , 키 괄호에 기재된 값에 대응하는 
# 전단 (dict1 [연령 ']) 

# 우선 제어 운전 : 
1 액세스 키 입력 값 : 바람직하게 저장 될 수있다 
# 입금 레벨 : dict1 사전은 9 값 
# . dict1 [ '레벨'] = 9 
# 인쇄 (dict1) {# '나이': '탱크', '레벨': (18)는 '이름'이다}. 9 
# 인쇄 (dict1 [ '이름'





# 프린트 (dict1에서 '탱크') # 거짓 
# 인쇄 (안 dict1에서 '탱크') # 사실 
#의 
# # 4은 삭제합니다. 
# 델 dict1 [ '레벨'] 
# 인쇄 (dict1) # { '나이': 18이며, '이름': '탱크'} 
#의 
. # # 5, 버튼 키 (), 키 - 값 항목에 값 (), ()의 값 
# 번호 사전은 모든 주요 구하는 
# 인쇄 (dict1.keys ()) 
제공하는 # 번호 사전 모든 값은 값 
# 인쇄 (dict1.values ()) 
# # GET 사전의 모든 항목 
# 인쇄 (dict1.items ()) 

# 6, 루프 
모든 사전 키를 통해 # 루프 
:에 대한 dict1에서 # 키 
# 인쇄 (키 ) 
# 인쇄 (dict1 [키]) 

# GET 
dict1 = { '나이'18 '이름'입니다 : '탱크'} 
# 인쇄 (dict1.get ( '나이')) 

# [] 값 
# 인쇄 (dict1 [ '섹스']) #의 KeyError를 : '섹스'

#의 값을 얻을 
() dict1.get ( '섹스'인쇄 ) # 없음을
더 섹스, 디폴트 값을 설정하지하는 경우 # 
인쇄 (dict1.get ( '섹스', '남성')) 

'' '' '' 
'' '' '' 
'' ' 
: 결정 IF 
    : 구문 
        분석 경우 조건 : 
            # 조건이 성립되는 경우, 여기서 코드 실행 
            로직 코드 

        조건 분석 ELIF : 
            #를 조건 코드를 실행하는 경우, 생성되는 경우 
            로직 코드 

        다른 : 
            #이 판정은, 여기에 실행 코드를 만족하지 않는 경우 
            논리 코드 
'' 

# 두 숫자를 크기 분석 
X 10 = 
Y = 20 것은 
Z 30 = 

# 단축키를 후퇴 탭은 오른쪽 시프트 네 구역으로 이동 + 탭 네 구역 왼쪽으로 이동 
X> Y IF : 
    전단 (X) 

ELIF Z> Y : 
    인쇄 (Z) 

다른 : 
    인쇄 (Y) 

'' '
루프 동안 
    구문 : 
        조건부 동안 :
            # 여기 설립 실행 
            로직 코드 

BREAK 번호 알아 본 계층 순환이 
이주기의에 다음주기의 # 끝 계속 
'' ' 

#의 STR1 ='탱크 ' 
#의 
# 번호 while 루프의 
# 그동안 참 : 
# 이름 = 입력 ('입력 문자를 추측 ') .strip () 
#를 IF 이름 =='탱크 ': 
# 인쇄 ('탱크 성공 ')! 
# 휴식 
#를 
다시 입력') #! 인쇄 ( ' 


# 제한 사이클 
인 str1 ='탱크 ' 
# 초기 값 
NUM = 2. 3. 1 0 0 # 

# While 루프 
그동안 NUM <3 :. 
    이름 = 입력 ( '입력하세요 문자 추측') .strip () 
    이름 == '탱크'IF : 
        인쇄 ( '탱크 성공! ') 
        BREAK의 

    인쇄 ('다시 입력하세요! ') 
    A = 1 + 

'' ' 
' '' 

'' '
파일 : 
    열기 () 

    파일 작성하는 
        중량 : 텍스트 쓰기 

    파일을 읽을 
        RT를 : 텍스트 읽기 

    추가 쓰기 파일을 
        에서 : 텍스트 추가 

참고 : 당신이 작성하는 어떤 방법으로, 문자 인코딩을 지정해야 
    이 열린 것입니다. 예를 들면 : UTF-8 

실행 파이썬 파일 : 
    1. 파이썬 인터프리터 먼저 메모리에로드. 
    2.로드 인터프리터에 파이썬 파일을 작성합니다. 
    3. 검출 파이썬 구문이 코드를 실행한다. 
    구문 에러 : 구문 오류! 

이 자원을 가지고 할 파일을 엽니 다 
    1.python 프로그램을 
    2. 운영 체제를 파일 열 
'' ' 

# 쓰기 텍스트 파일 
A # 매개 변수 : 파일의 절대 경로 
# 매개 변수를 II : 파일의 동작 모드 모드 
# 세 가지 매개 변수 : 인코딩 지정된 문자 인코딩 
# F = 열기 ( 'file.txt를', MODE = '중량'인코딩 = "UTF-. 8 ') 
#의 f.write ('탱크 ') 
#의 f.close () # 운영체제 파일 리소스습니다 


텍스트 파일 # RT == R & 중위 판독 
# F = 열기 ( 'file.txt를', 'R & LT'을
인쇄 # (도달, f.read ()) 
#의 f.close () 
# 
#의 
# 번호가 기록의 첨부 텍스트 파일 
#의 A = 열기 ( 'file.txt를', 'A', 인코딩 = 'UTF-. 8') 
# a.write ( "\ n HEFEI ') 
#의 a.close () 


' '' 
문서 처리 관리의 상황. 
열기 ()와 AS F '핸들 
' ' 
# 기록 
'은 File2.txt 열기 (함께 # '를 'w 인코딩 = "UTF-8. ') F AS : 
#의 f.write ('머피의 법칙 ') 
#의 
# 판독 # 
오픈 ('은 File2.txt '와 #을 'R ', 인코딩 ="UTF-8 ") 등 F : 
# 도달 f.read의 RES = () 
# 전단 (RES) 
# 
## 별도로 
# 열기 F AS ( '은 File2.txt', 'A', 인코딩 = "UTF-8. ') : 
#의 f.write (' 공성전 ') 
# # F.닫기 () 


'' ' 
사진, 오디오, 비디오 쓰기 
RB 모드, 문자 인코딩을 지정할 필요가 바이너리하지 읽기 
' ''

    로직 코드를     반환 반환 값은 정의 : 정의 defind. 기능 이름 : 이름은 이탈리아어 알고 참조해야합니다. () : 외부 입력 파라미터를 수신하는 단계를 포함한다.






























주 : 액션 함수를 선언하는 데 사용됩니다. 
반환 : 반환 값을 호출자에게. 
'' ' 

' '' 
: 기능 정의 된 세 가지 형태 
    1. 기능 없음 매개 변수 
        들어오는 외부 매개 변수를받을 필요합니다. 

    2. 참조 기능은 
        들어오는 외부 파라미터를 수신 할 필요가있다. 

    3. 빈 함수 

        통과 


함수 호출 : 
    함수 이름 + ()를 호출 

'' ' 

# 번호 1. 기능 없음 매개 변수 
#의 DEF 로그인 () : 
# = INPUT 사용자가 .strip ('사용자 이름 '을 입력) () 
#의 PWD = INPUT .strip () ( '비밀번호를 입력하세요') 
#의 
: IF 사용자 == '탱크'및 PWD == '123'#을 
( '! 성공적인 로그인') # 인쇄 
# 
# 다른 사람 : 
'! 로그인 오류'# 인쇄 (











# 사용자 이름, 들어오는 외부 값을 받기위한 암호 
#의 DEF 로그인 (사용자 이름, 암호) : 
( '사용자 이름을 입력하십시오') .strip () # = INPUT 사용자를 
= #의 PWD INPUT을 ( '비밀번호를 입력하세요') .strip () 
#의 
# 사용자 PWD는 == == 사용자 이름과 암호 IF : 
( '! 로그인 성공')가 인쇄 번호는 
#의 
다른 # : 
# 인쇄 ( '! 로그인 오류') 
# 
# 
# # 함수 호출 
# #은 함수가 정의되어있는 경우 수신 매개 변수 필요는 발신자는 참조를 통과해야 
# 로그인 ( '탱크', '123') 


# 3. 널 (null) 기능 
'' ' 
: 현금 지급기 
    1. 로그인 
    2. 등록 
    3. 취소 
    4. 현금 
    5. 전송 
    (6). 상환 
'' ' 

# 번호 사인온 기능 
# 데프 로그인 () :
## 대표가 아무것도 할 
# 통행을 
# 
# 
# # 함수를 등록
등록 DEF 번호 () : 
# 번호의 아무것도를 대신하여 수행하는 
# 패스 
#의 
# 
# 번호 지불 기능 
) DEF (상환 # : 
# 통행 

#을 ... 


'' ' 
매개 변수 기능 : 
' '' 
정의 단계에서 #을 : X y는 변수라고. 
DEF FUNC 번호 (X, Y) : #의 X, Y의 
# 인쇄 (X, Y) 
# 
# # 호출 단계 : 10, 100 개 호 인수. 
FUNC 번호 (10, 100) 


# '' ' 
# 위치 파라미터 : 
위치 # 파라미터 
# 인자 위치 
#해야 매개 변수 전달 따른 열한 위치. 
# '' ' 
의 정의 단계에서 ## : 위치 파라미터 
# 데프 FUNC (X, Y) : #의 X, Y의 
# 전단 (X, Y) 
## 
### 호출 단계 : 10, 100 위치 인수했다. 
FUNC 번호 (10, 100) 10 100 # 
#의 
#의 '' ' 
# 키워드 매개 변수 :


# '' ' 
## 위치 파라미터 X, Y 
# DEF FUNC (X, Y) : 
# 전단 (X, Y) 
#의 
## 호 단, X = 10, Y = 100 통화 키 파라미터. 
#의 FUNC (Y = 111, X = 10) # 10 111 

#는하게 전송이다 
#의 FUNC (Y = 111) # 에러 형식 오류의 


# 더 이상 패스 
#의 FUNC (Y = 111, X = 222, Z = '333') # 형식 오류 주어진 


'' ' 
: 기본 매개 
    변수 설정 기본값과 같이 정의 위상을 
' '' 

# 데프 foo는 (X = 10, Y = 20 인) : 
# 전단 (X는, Y) 
#의 
# 번호 파라미터를 전달하지 않으며, 디폴트 파라미터 
# foo는 () 
#의 
전달 파라미터, # # 1 패스 변수 
#의 푸 (200, 300) 

'' '' '' 
'' ' 
중첩 함수가 정의된다 : 
    함수 정의 함수 내부. 

개체 기능 : 
    함수의 메모리 주소는 생성자 객체를했다. 

네임 스페이스 기능 : 
    내장 : 
        파이썬 파서 두라고되어 있습니다 "내장 된 네임 스페이스." 

    글로벌 :
        모든 변수, 함수를 작성하기 위해 머리를 입고 ... "이름 공간"이라고합니다. 

    부분 : 
        함수의 정의는 다음과 같이 언급되어 내부에 "로컬 이름 공간." 

    네임 스페이스로드 순서 : 
        내장 ---> --- 글로벌> 로컬 

    네임 스페이스의 조회 순서 :   
        지역 ---> --- 글로벌> 내장 
'' ' 


중첩 정의 기능 번호의 
DEF의에서 func1 () : 
    인쇄 ('에서 ... FUNC1 ') 

    DEF의 FUNC2 () : 
        인쇄 ( "... FUNC2에서') 


# 함수 오브젝트 
인쇄 (FUNC1) 


DEF F1 () : 
    패스 


DEF F2 () : 
    패스 


DIC1가 = { '1.'F1 ' 2 ': F2} 

선택 INPUT = ('숫자를 선택 ") 
IF == 선택을 '1.' 
    인쇄 (DIC1 [선택]) 
    DIC1 [선택 () 

ELIF 선택 == '2':







# 중첩 함수 데피니션 
DEF의 FUNC1을 () : 
    # = X (20)는 

    ( '... FUNC1에서') 인쇄 

    주어진 # 인쇄 (X) 

    X = 30 

    DEF의 FUNC2 () 
        ( 'FUNC2로부터 ...')를 인쇄 


FUNC1을 ()