3 Python 내장 함수

1. type
    type 함수 가 임의의 대상 의 데이터 형식 을 되 돌려 줍 니 다.

#-------------------------------------------------------------------------------
# coding:        utf-8
# Name:            
# Purpose:
#
# Author:      zdk
#
# Created:     18/02/2013
# Copyright:   (c) zdk 2013
#-------------------------------------------------------------------------------
import types
import TupleTest

if __name__ == '__main__':
    print(type(1))          #<class 'int'>
    print(type([]))         #<class 'list'>
    print(type("abc"))      #<class 'str'>
    print(type(TupleTest))  #<class 'module'>
    print(type(TupleTest) == types.ModuleType)  #True

    (1) type 은 모든 것 을 매개 변수 로 받 아들 일 수 있 습 니 다. 
    (2) type 수신 변 수 를 매개 변수 로 하고 데이터 형식 을 되 돌려 줍 니 다.
    (3) type 은 모듈 에 도 작용 할 수 있다.
    (4) types 모듈 의 상수 류 를 사용 하여 대상 유형 을 비교 할 수 있 습 니 다.
2.str
    str 는 데 이 터 를 문자열 로 강제로 변환 합 니 다. 모든 유형 이 가능 합 니 다.    

print(str(1))               # 1
    print(str(['noe','two']))   # ['noe','two']
    print(str(TupleTest))       # <module 'TupleTest' from 'D:\  \python\codes\TupleTest.py'>
    print(str(None))            # None

    (1) 비교적 간단 한 데이터 유형, 예 를 들 어 성형 에 작용 할 수 있다.
    (2) 목록 과 같은 모든 데이터 형식의 대상 에 작용 할 수 있 습 니 다.
    (3) str 는 하나의 모듈 에 도 작용 할 수 있다.
    (4) str 는 None, None 은 Python 의 null 로 문자열 형식의 None 을 되 돌려 줍 니 다. 
3.dir
    모듈 대상, 함수 대상, 문자열 대상, 목록 대상, 사전 대상 등 임의의 대상 의 속성 과 방법 목록 을 되 돌려 줍 니 다.   

print(dir([]))  #['__add__', '__class__', ……, 'remove', 'reverse', 'sort']
    print(dir({}))  #['__class__', '__contains__', '__delattr__',……, 'update', 'values']
    print(dir(TupleTest))#['__builtins__', '__cached__', '__doc__', '__file__', '__name__', '__package__', 'main']

    (1) dir ([]) 는 모든 목록 방법 을 포함 하 는 목록 을 되 돌려 줍 니 다.방법 자체 가 아 닌 문자열 형식의 방법 이름 만 되 돌려 줍 니 다.
    (2) dir ({}) 사전 방법의 이름 목록 을 되 돌려 줍 니 다.
    (3) dir (TupleTest) 모듈 에 정 의 된 모든 위 젯 의 목록 을 되 돌려 줍 니 다. 내 장 된 속성 포함:name__、__doc__ 。
4.callable
    모든 대상 을 매개 변수 로 받 습 니 다. 매개 변수 대상 이 호출 가능 하 다 면 True 로 돌아 갑 니 다.그렇지 않 으 면 false 로 돌아 갑 니 다.    

import string

if __name__ == '__main__':
    print(string.punctuation)           # !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
    print(callable(string.punctuation)) # False
    print(callable(string.Formatter))   # True
    print(callable("".join))            # True

    (1) string 모듈 은 사용 에 찬성 하지 않 지만 이 모듈 에는 유용 한 변수, string. punctuation 이 많이 포함 되 어 있 습 니 다. 이것 은 모든 표준 문장 부 호 를 포함 합 니 다.
    (2) string. punctuaction 은 호출 할 수 없 는 대상 입 니 다.그것 은 문자열 이다.
    (3) string. Formatter 는 호출 이 가능 합 니 다.
    (4) ". join 은 호출 가능 한 것 입 니 다.이 함 수 는 두 개의 인 자 를 받는다.
5.getattr
    getattr 를 통 해 대상 참조 가 져 오기  

li = ["one","two"]
    print(li.pop)            #<built-in method pop of list object at 0x01E8A490>
    print(getattr(li,"pop")) #<built-in method pop of list object at 0x01E8A490>
    getattr(li,"append")("three")
    print(li)       #['one', 'two', 'three']
    print(type(getattr(TupleTest,"main")) == types.FunctionType) #True
    print(getattr(li,"abc","defaultValue"))   #defaultValue

   (1) li. pop 에서 목록 의 pop 방법 을 가 져 오 는 인용, getattr (li, pop) 도 목록 pop 방법 을 가 져 오 는 인용 입 니 다.
   (2) getattr (li, "append") ("three") 는 목록 의 append 방법 을 참조 하고 append 는 three 에서 li 에 있 습 니 다.
   (3) getattr (li, "abc", "defaultValue") 목록 에 abc 속성 이 없 기 때문에 기본 defaultValue 를 되 돌려 줍 니 다. 
6. 필터 링 목록
    목록 의 문법: [mapping - expression for element in source - list if filter - expression]
    if 로 시작 하 는 것 은 필터 표현 식 입 니 다. 필터 표현 식 의 반환 값 은 진짜 또는 가짜 입 니 다. 필터 표현 식 에서 실제 요소 로 되 돌아 오 면 맵 에 포함 할 수 있 습 니 다. 

li = ['a','mpilgrim','foo','b','a','b','d','d']
    print([e for e in li if len(e)>1])       #['mpilgrim', 'foo']
    print([e for e in li if e!='d'])         #['a', 'mpilgrim', 'foo', 'b', 'a', 'b']
    print([e for e in li if li.count(e)==1]) #['mpilgrim', 'foo']

    (1) 원소 의 길이 가 1 보다 큰 것 을 선별한다.
    (2) d 를 걸 러 낸다.
    (3) 목록 에 1 번 나타 나 는 요 소 를 선별 합 니 다. 
7. and 와 or 의 특수성
    Python 에서 and 와 or 는 논리 연산 을 실행 하지만 불 값 을 되 돌려 주지 않 고 실제 비교 한 값 중 하 나 를 되 돌려 줍 니 다.  

print('a' and 'b')          #b
    print('' and 'b')           #''
    print('a' and 'b' and 'c')  #c
    print('a' or 'b')           #a
    print('' or 'b')            #b
    print('' or [] or {})       #{}

    (1) and 를 사용 할 때 왼쪽 에서 오른쪽으로 연산 하고 0, ', [], (), {}, None 은 불 환경 에서 가짜 이 며 다른 값 은 모두 사실 입 니 다.
    (2) 불 환경 에서 값 을 가짜 로 만 지면 and 는 첫 번 째 가짜 값 을 되 돌려 줍 니 다.
    (3) 모든 값 이 사실 이 라면 and 는 마지막 정 치 를 되 돌려 줍 니 다.
    (4) or 역시 왼쪽 에서 오른쪽으로 연산 합 니 다. 만약 에 하나의 값 이 진실 이 라면 or 는 즉시 이 값 을 되 돌려 줍 니 다.
    (5) 모든 값 이 가짜 입 니 다. or 마지막 값 을 되 돌려 줍 니 다.