Python 3 - 내 장 된 데이터 구조: list, tuple

내 장 된 데이터 구조 (변수 형식)

list

set (python - 데이터 형식 참조)

dict (python - 데이터 형식 참조)

tuple

순서 가 있 는 숫자의 조합

목록 만 들 기

빈 목록

l1=[]   #         
print(type(l1))
print(l1)
l2=[100]  #         
print(type(l2))
print(l2)
l3=[2,5,5,8,1,3]   #         
print(type(l3))
print(l3)
l4=list()   #       
print(type(l4))
print(l4)



    ：
<class 'list'>
[]
<class 'list'>
[100]
<class 'list'>
[2, 5, 5, 8, 1, 3]
<class 'list'>
[]
Process finished with exit code 0

목록 상용 동작 1

방문

아래 표 시 된 동작 사용 (색인)

리스트 의 위 치 는 0 에서 시 작 됩 니 다. (규정 리스트 의 마지막 아래 표 시 는 - 1)

블록 조작

목록 을 임의로 캡 처 합 니 다

list [:]

list [:] (두 번 째 사칭 은 성장 폭 을 나타 내 고 기본 적 인 성장 폭 은 1, 즉 하나의 성장 이다. 이 수가 마이너스 라면 오른쪽 에서 왼쪽으로 순 서 를 나타 낸다)

#      
l=[2,3,5,4,1,6]
print(l)
print(l[4])  #      
print(l[2:4])   #          
print(l[ :5])  #          
print(l[2:])  #           
print(l[ : :2])  #            2
print(l[-2:-5])  #                    ，                  
print(l[-5:-2])
print(l[-2:-5:-1])  #       ，          ，            



    ：
[2, 3, 5, 4, 1, 6]
1    #      
[5, 4]    #          
[2, 3, 5, 4, 1]    #          
[5, 4, 1, 6]   #           
[2, 5, 1]    #            2
[]
[3, 5, 4]
[1, 4, 5]
Process finished with exit code 0

조각 나 누 기 동작 은 새로운 list 를 만 드 는 것 입 니 다.

함수 id 를 내장 하여 변수 나 데 이 터 를 표시 하 는 유일한 확정 번호

l=[2,5,3,8,4,6]
ll=l[:]
l[1]=100
#l   ll        
print(id(l))
print(id(ll))
print(l)
print(ll)



    ：
287737405960
287737406024
[2, 100, 3, 8, 4, 6]
[2, 5, 3, 8, 4, 6]
Process finished with exit code 0

list (목록) 동작 2

del 삭제 명령

del 한 변 수 를 사용 하면 이 변 수 는 사용 할 수 없습니다

#del  
l=[2,5,3,8,4,6]
print(id(l))
del l[2]
print(id(l))
print(l)



    ：
770037604872
770037604872    #  del           list，       
[2, 5, 8, 4, 6]
Process finished with exit code 0

리스트 더하기

두 목록 을 플러스 로 연결 합 니 다

#      
a=[1,2,3,4]
b=[5,6,8]
c=['a', 'b', 'c']
d=a+b+c
print(d)



    ：
[1, 2, 3, 4, 5, 6, 8, 'a', 'b', 'c']
Process finished with exit code 0

리스트 곱 하기

리스트 는 정수 와 직접 곱 하여 n 개의 리스트 를 연결 하 는 것 과 같다

#      
a=[1,2,3,4]
b=a*3
print(b)



    ：
[1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]
Process finished with exit code 0

구성원 자격 연산

한 요소 가 list 에 있 는 지 판단 하 는 것 이다

a=[1,2,3,4]
b=3
c=b in a
print(c)



    ：
True

목록 의 옮 겨 다 니 기

for

while (일반적으로 while 방문 목록 을 사용 하지 않 음)

#      ：
a=[1,2,3,4]
for i in a:
    print(i)
b=['i love sunyue']
for i in b:
    print(i)
print("#"*20)


#   while  
l=len(a)
n=0  #n       
while n<l:
    print(a[n])
    n += 1



    ：
1
2
3
4
i love sunyue
####################
1
2
3
4
Process finished with exit code 0

이중 목록 순환

#a     ，      
a=[["one",1],["two",2],["three",3]]
for k,v in a:
    print(k,"---",v)



    ：
one --- 1
two --- 2
three --- 3
Process finished with exit code 0

목록 내용: list content

간단 한 방법 으로 목록 만 들 기

# for  
a=[x for x in range(1,6 )]
b=[i for i in a]  #  a       ，     b 
print(b)
c=[i*10 for i in a]   # a        10 ，      c 
print(c)
d=[m for m in a if m % 2 ==0]   #  ： a          d 
print(d)
f=[m+n for m in a for n in b]   #     for    ，            
print(f)



    ：
[1, 2, 3, 4, 5]
[10, 20, 30, 40, 50]
[2, 4]
[2, 3, 4, 5, 6, 3, 4, 5, 6, 7, 4, 5, 6, 7, 8, 5, 6, 7, 8, 9, 6, 7, 8, 9, 10]
Process finished with exit code 0

일부 주제 밖의 말

#        
#       ，      ，                   
#      ，         ，                ，              
def a(n):
    n[2]=300
    print (n)
    return None

def b(n):
    n += 100
    print (n)
    return None

an=[1,2,3,4,5,6,7]
bn=9

print(an)
a(an)  #  ，           
print(an)

print(bn)
b(bn)   #  ，          ，         
print (bn)



    ：
[1, 2, 3, 4, 5, 6, 7]
[1, 2, 300, 4, 5, 6, 7]
[1, 2, 300, 4, 5, 6, 7]
9
109
9

목록 에 대한 함수
len (): 목록 의 길 이 를 표시 합 니 다.
cmp (list 1, list 2): 두 목록 의 요 소 를 비교 합 니 다.
max (): 목록 의 최대 값 을 표시 합 니 다.
list (): 다른 형식의 데 이 터 를 list 로 변환 합 니 다 (전 제 는 변환 가능)
zip (): 서열 에 있 는 요 소 를 순서대로 조합 하여 하나의 원 조 를 구성 한 다음 에 이 원 조 를 새로운 서열 에 넣 습 니 다.

zip () 함 수 는 zip 형식 을 되 돌려 줍 니 다. list () 함수 로 변환 해 야 합 니 다

names = ['   ', '   ', '   ', '   ']
books = ['   ', '    ', '   ', '   ']
times = ['1501 -1582 ', '1330 —1400 ', '1296 —1370 ', '1715 -1763 ']
books_info = zip(names, books, times)
print(list(books_info))

#   ：[('   ', '   ', '1501 -1582 '), ('   ', '    ', '1330 —1400 '), ('   ', '   ', '1296 —1370 '), ('   ', '   ', '1715 -1763 ')]

append (): 내용 을 삽입 하고 끝 에 추가 하 는 것 을 의미 합 니 다.
sort (): 목록 요 소 를 정렬 합 니 다.
index (x): 처음으로 x 요소 가 나타 난 색인 값 을 되 돌려 줍 니 다.

a = [i for i in range(1,5)]
print(a)
a.append(100)
print(a)



    ：
[1,2,3,4]
[1,2,3,4,100]

insert (): 지정 한 위치 삽입 표시
괄호 안에 두 개의 값 을 정의 해 야 합 니 다. 하 나 는 위치 아래 표 시 를 표시 하고 하 나 는 삽입 값 insert (index, data) 가 삽 입 된 값 은 index 의 앞 입 니 다.

a = [i for i in range(1,5)]
print(a)
a.insert(2,50)
print(a)



    ：
[1, 2, 3, 4]
[1, 2, 50, 3, 4]

del 삭제: 색인 (요소 가 있 는 위치) 에 따라 삭제 합 니 다.

str=[1,2,3,4,5,2,6]
del str[1]	#     1   
print(str)
[1, 3, 4, 5, 2, 6]

str=[0,1,2,3,4,5,6]
del str[2:4] #    2     ，  4      (         )
print(str)
[0, 1, 4, 5, 6]

pop (): 팀 끝 에서 하나의 요 소 를 꺼 냅 니 다. 즉, 마지막 요 소 를 꺼 내 면 괄호 안에 지 정 된 아래 표 시 를 입력 할 수 있 습 니 다.
remove (x): 목록 에서 처음 나타 난 요소 x 를 삭제 합 니 다.
clear (): 지우 기

#       
a = [i for i in range(1,10)]
print(a)
print(id(a))

#pop    
last_del=a.pop()   #  pop    
print("       ：",last_del)
print(a)
print(id(a))   #id  ，        
b = a.pop(6)
print("       6   ：",b)
print(a)
print(id(a))

#remove    
a.remove(2)   #  a    2   
print(a)
print(id(a))   #id  ，        

#clear    
a.clear()   #      
print(a)
print(id(a))   #id  ，        



    ：
[1, 2, 3, 4, 5, 6, 7, 8, 9]
722993177096
       ： 9
[1, 2, 3, 4, 5, 6, 7, 8]
722993177096
       6   ： 7
[1, 2, 3, 4, 5, 6, 8]
722993177096
[1, 3, 4, 5, 6, 8]
722993177096
[]
722993177096

목록 내용 반전

#       
a = [i for i in range (1,10)]
print(a)
print(id(a))
a.reverse()
print(a)
print(id(a))    #id  ，        



    ：
[1, 2, 3, 4, 5, 6, 7, 8, 9]
292435288584
[9, 8, 7, 6, 5, 4, 3, 2, 1]
292435288584

extend 확장 목록, 두 목록 중 하 나 를 다른 목록 뒤에 직접 연결 합 니 다.

#       
a = [i for i in range (1,10)]
b = [i for i in range (10,15)]
print(a)
print(id(a))
a.extend(b)
print(a)
print(id(a))



    ：
[1, 2, 3, 4, 5, 6, 7, 8, 9]
62002192904
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
62002192904

count 목록 에서 지정 한 값 이나 요소 의 개 수 를 찾 습 니 다.

#   count  
a = [1,2,5,3,5,4,5,1,2,1]
print(a)
print(id(a))
n= int(input("     ："))   #input      ，     int  
b = a.count(n)
print("   {}    ：".format(n),b)



    ：
[1, 2, 5, 3, 5, 4, 5, 1, 2, 1]
637753188872
     ：5
   5    ： 3

복사

a = [1,2,3,4,5]
print(a)
b = a   #list  ，      ，    
b[3] = 77
print("  b   a   ：",a)
print("a ID   ：",id(a))
print("  b   b   ：",b)
print("b ID   ：",id(b))
print("*"*20)
#    
b = a.copy()
print("a   ：",a)
print("a ID   ：",id(a))
print("b   ：",b)
print("b ID   ：",id(b))  #copy  ID      
print("*"*20)
b[3] = 88
print("  b   a   ：",a)
print("  b   b   ：",b)



    ：
[1, 2, 3, 4, 5]
  b   a   ： [1, 2, 3, 77, 5]
a ID   ： 33841672
  b   b   ： [1, 2, 3, 77, 5]
b ID   ： 33841672
********************
a   ： [1, 2, 3, 77, 5]
a ID   ： 33841672
b   ： [1, 2, 3, 77, 5]
b ID   ： 34328264
********************
  b   a   ： [1, 2, 3, 77, 5]
  b   b   ： [1, 2, 3, 88, 5]

깊 은 복사 와 얕 은 복사 의 차이

깊이 복사 하려 면 특정한 도구

가 필요 하 다.

a0 = [10,20,30]
a = [1,2,3,a0]
b = a.copy()
print(id(a[3]))
print(id(b[3]))  #    b a0         
a[3][2] = 666
#   ，       
#    ，b    a， b  a0       ，    b a0   ，a a0       
print(a)
print(b)



    ：
4809224
4809224
[1, 2, 3, [10, 20, 666]]
[1, 2, 3, [10, 20, 666]]

모듈 - tuple

원 조 는 변경 할 수 없 는 list

로 볼 수 있 습 니 다.

tuple 은 작은 괄호 에 쓰 고 요소 사 이 를 쉼표 로 구분 합 니 다.

원 그룹의 요 소 는 가 변 적 이지 않 지만 가 변 적 인 대상 을 포함 할 수 있 습 니 다.

원 조 는 사전 의 키 로 도 사용 할 수 있 고 집합 요소 로 도 사용 할 수 있 지만 목록 은 안 되 고 목록 을 포함 한 원 조 는 안 됩 니 다.

원본 그룹 생 성

#     
t = ()
print(type(t))
<class 'tuple'>
#            
t = (1,)
print(type(t))
print(t)
<class 'tuple'>
(1,)

t = 1,
print(type(t))
print(t)
<class 'tuple'>
(1,)

#         
t = 1,2,3,4,5
print(type(t))
print(t)
<class 'tuple'>
(1, 2, 3, 4, 5)

#        
l = [1,2,3,4]
t = tuple(l)
print(type(t))
print(t)
<class 'tuple'>
(1, 2, 3, 4)

원 그룹의 특성

서열 표, 질서

모듈 데이터 값 은 접근 할 수 있 고 수정 할 수 없습니다

모듈 데 이 터 는 임의의 유형

일 수 있 습 니 다.

한 마디 로 하면 list 의 모든 특성 은 수정 할 수 있 는 것 을 제외 하고 원 조 는 모두 가지 고 있다. 즉, list 가 가지 고 있 는 일부 조작, 예 를 들 어 색인, 분 편, 서열 더하기, 상승, 구성원 자격 조작 등 이 모두 똑같다 는 것 을 의미한다

.
생 성기 식

gen = (2**i for i in range(8))  #         
#            ，          
print(gen)
print((gen)) #     
print(tuple(gen))


gen = (2**i for i in range(8))
print(next(gen))    #  next（）         
print(next(gen))
for item in gen:    #  for           
    print(item,end = ' ')


gen      ： <generator object <genexpr> at 0x000001D43FF88E48>
list(gen)      ： [1, 2, 4, 8, 16, 32, 64, 128]
tuple(gen)      ： ()
      ： 1
      ： 2
       ：
4 8 16 32 64 128

Python 3 - 내 장 된 데이터 구조: list, tuple

좋은 웹페이지 즐겨찾기