Python 목록을 배우는 데 도움이 되는 기사

이 기사의 내용은 Python 목록을 배우는 데 도움이 되는 기사입니다. 도움이 필요한 친구들이 참고할 수 있기를 바랍니다.

천 리 길도 한 걸음부터 시작됩니다. 모든 것을 볼 수 있는 눈을 키우려면 먼저 기본 기술을 현실적으로 배워야 합니다. 오늘은 Python 목록을 주의 깊게 검토하도록 안내하겠습니다. 과거를 복습함으로써 새로운 것을 배울 수 있기 때문입니다.

물론 검토하는 동안에도 다양한 생각을 해야 합니다. 왜냐하면 배열 인덱스가 0부터 시작하는 이유와 같이 사소해 보이는 일부 관습적인 언어 습관에는 많은 역사가 있을 수 있기 때문입니다. 무슨 일이 일어나고 있는지 알려면 왜 그런 일이 일어나는지도 알아야 합니다. 야옹야옹~~

마지막으로 기본 지식 위에 발전기 표현 학습과 같은 고급 기술도 탐구해야 합니다. 기본을 더욱 확실하게 익힐 수 있을 뿐만 아니라 모든 것을 통합하고 보다 포괄적인 인지적 업그레이드를 얻을 수 있습니다.

파이썬의 목록은 무엇인가요?

목록은 언제든지 요소를 추가, 검색 및 삭제할 수 있는 정렬된 컬렉션입니다.

List는 숫자, 문자열, 목록, 튜플 등 다양한 데이터 유형의 요소 추가를 지원합니다.

목록은 순서가 지정된 인덱스를 통해 모든 요소를 ​​순회할 수 있습니다. 인덱스는 뒤에서 앞으로 계산하면 [0, n-1]입니다. 여기서 n은 목록.

목록은 요소가 없는 빈 목록이거나 너무 많은 요소를 포함할 수 있습니다(메모리 크기가 지원하는 경우).

list_a = []   # 空列表，即len(list_a) == 0
list_b = [2018, 10, '2018-10-1', ['hi', 1, 2], (33, 44)]
# list_b 长度为5，包含2个数字元素、1个字符串元素、1个列表元素和1个元组元素
len(list_b) == 5
list_b[0] == list_b[-5] == 2018
lits_b[3] == list_b[-2] == ['hi', 1, 2] 
lits_b[4] == list_b[-1] == (33, 44)

Python에서 목록을 어떻게 작동하나요?

1) 목록 만들기:

요소를 대괄호 []로 묶고 요소를 쉼표로 구분합니다.

list() 메소드를 사용하여 목록을 생성하려면 변환하세요.

목록 생성/목록 분석/목록 이해를 통해 목록을 생성합니다.

list_a = [1, 2, 3]
list_b = list("abc") # list_b == ['a', 'b', 'c']
list_c = list((4, 5, 6)) # list_c == [4, 5, 6]
list_d = [i for i in list_a]  # list_d == [1, 2, 3]
list_e = [i*j for i in list_a for j in list_c] # list_e == [4,5,6,10,12,12,15,18]
list_f = [i*j for i,j in zip(list_a,list_c)] # list_f == [4, 10, 18]
list_g = [i for i in list_a if i%2 == 0] # list_g == [2]

# 结合range()函数，range(start, stop[, step])
list_h = list(range(3)) # list_h == [0, 1, 2]
list_i = list(range(3,7)) # list_i == [3, 4, 5, 6]
list_j = list(range(3,9,2)) # list_j == [3, 5, 7]

# 找出100以内的能够被3整除的正整数
list_k = list(range(3,100,3)) # list_k == [3, 6, 9, ..., 96, 99]

2) 목록 확장:

append() 메서드를 사용하여 목록 끝에 새 요소 하나를 추가합니다.

목록의 지정된 위치에 요소를 추가하려면 insert() 메서드를 사용하세요.

두 목록을 새 목록으로 연결하려면 "+" 연산자를 사용하세요.

하나의 목록을 다른 목록으로 연결하려면 확장() 메서드를 사용하세요.

# 以下分别添加2个元素
list_a = []
list_a.append('happy')  # list_a == ['happy']
list_a.insert(0, 'very') # list_a == ['very', 'happy']

# 以下两种扩充列表方式
list_1 = ['I', 'am']
list_2 = ['very', 'happy']
list_3 = list_1 + list_2  # 新列表 list_3 == ['I', 'am', 'very', 'happy']
list_1.extend(list_2)  # 原列表1扩充，list_1 == ['I', 'am', 'very', 'happy']

3) 목록 삭제 및 목록 삭제:

del list[m] 문을 사용하여 지정된 인덱스 m에 있는 요소를 삭제합니다.

remove() 메서드를 사용하여 지정된 값(첫 번째로 일치하는 항목)을 가진 요소를 삭제합니다.

목록 끝에 있는 단일 요소를 꺼내고 삭제하려면 pop() 메서드를 사용하세요.

pop(m) 메서드를 사용하여 인덱스가 m인 요소를 제거하고 삭제합니다.

목록의 요소를 지우려면 clear() 메서드를 사용하세요. (컵은 그대로 있는데 물은 비어있습니다.)

전체 목록을 삭제하려면 del list 문을 사용하세요. (컵과 물이 모두 사라짐)

# 以下4种删除列表元素方式
list_1 = list_2 = list_3 = list_4 = ['I', 'am', 'very', 'happy']
del list_1[0]  # list_1 == ['am', 'very', 'happy']
list_2.remove('I') # list_2 == ['am', 'very', 'happy']
list_3.pop()  # list_3 == ['I', 'am', 'very']
list_4.pop(0)  # list_4 == ['am', 'very', 'happy']

# 清空与销毁
list_a = [1, 2, 3]
list_b = [1, 2, 3]
list_b.clear()   # list_b == []
del list_a  # 没有list_a了，再使用则会报错

4) 리스트 슬라이싱:

기본 의미: i번째 인덱스에서 시작하여 마지막 n개 요소까지 오른쪽으로 이동하고 m 간격으로 필터링

기본 형식: [i : i+n : m] ; i는 슬라이스의 시작 인덱스 값으로, 목록의 첫 번째 위치인 경우 생략할 수 있습니다. i+n은 슬라이스의 끝 위치입니다. 목록의 마지막 위치인 경우 생략됩니다. m을 제공할 필요가 없으며 기본값은 1입니다. 0은 허용되지 않으며 m이 음수인 경우 목록이 뒤집힙니다. 참고: 이러한 값은 목록 길이보다 클 수 있으며 범위를 벗어난 것으로 보고되지 않습니다.

li = [1, 4, 5, 6, 7, 9, 11, 14, 16]

# 以下写法都可以表示整个列表，其中 X >= len(li)
li[0:X] == li[0:] == li[:X] == li[:] == li[::] == li[-X:X] == li[-X:]

li[1:5] == [4,5,6,7] # 从1起，取5-1位元素
li[1:5:2] == [4,6] # 从1起，取5-1位元素，按2间隔过滤
li[-1:] == [16] # 取倒数第一个元素
li[-4:-2] == [9, 11] # 从倒数第四起，取-2-(-4)=2位元素
li[:-2] == li[-len(li):-2] == [1,4,5,6,7,9,11] # 从头开始，取-2-(-len(li))=7位元素

# 注意列表先翻转，再截取
li[::-1] == [16,14,11,9,7,6,5,4,1] # 翻转整个列表
li[::-2] == [16,11,7,5,1] # 翻转整个列表，再按2间隔过滤
li[:-5:-1] == [16,14,11,9] # 翻转整个列表，取-5-(-len(li))=4位元素
li[:-5:-3] == [16,9] # 翻转整个列表，取-5-(-len(li))=4位元素，再按3间隔过滤

li[::0]  # 报错（ValueError: slice step cannot be zero）

5) 기타 작업:

모든 요소의 수를 계산하려면 len() 메서드를 사용하세요.

count() 메서드를 사용하여 지정된 값을 가진 요소의 개수를 계산합니다.

요소의 최대값을 계산하려면 max() 메소드를 사용하세요. (요소 유형은 동일해야 합니다. 숫자 유형은 직접 비교되고 다른 유형은 ID와 비교됩니다.)

min() 메소드를 사용하여 요소의 최소값 계산(요소 유형은 동일해야 함; 숫자 유형은 직접 비교, 다른 유형은 ID와 비교)

index() 메소드를 사용하여 지정된 요소의 인덱스 위치를 찾습니다. 값(첫 번째로 일치하는 항목).

목록의 요소를 뒤집으려면 reverse() 메서드를 사용하세요.

새 목록을 얕게 복사하고 생성하려면 copy() 메서드를 사용하세요.

deepcopy() 메서드를 사용하여 딥 카피하고 새 목록을 생성하세요.

원래 목록을 기준으로 정렬하려면 sort() 메서드를 사용하세요.

새 목록을 기반으로 원본 목록의 요소를 정렬하려면 sorted() 메서드를 사용하세요.

list_1 = [2018, 10, '2018-10-1', ['hi', 1, 2], (33, 44)]
len(list_1) == 5
list_1.count(10) == 1 # 元素10的数量为1
list_1.index(10) == 1 # 元素10的索引为1
list_1.reverse() # list_1 == [(33, 44), ['hi', 1, 2], '2018-10-1', 10, 2018]


# 比较浅拷贝与深拷贝
import copy
list_a = [2018, 10, '2018-10-1', ['hi', 1, 2], (33, 44)]
list_b = ['hi', 1, 2]
list_c = list_a.copy() # list_c == [2018, 10, '2018-10-1', ['hi', 1, 2], (33, 44)]
list_d = copy.deepcopy(list_a) # list_d == [2018, 10, '2018-10-1', ['hi', 1, 2], (33, 44)]
# 改变原列表中的可变对象元素
list_a[3].append('new') # list_a == [2018, 10, '2018-10-1', ['hi', 1, 2, 'new'], (33, 44)]
# 浅拷贝中的可变对象会随原列表变化而变化
list_c == [2018, 10, '2018-10-1', ['hi', 1, 2, 'new'], (33, 44)]
# 深拷贝中的可变对象不会随原列表变化而变化
list_d == [2018, 10, '2018-10-1', ['hi', 1, 2], (33, 44)]
# 比较sort() 与 sorted()
list_1 = list_2 = [2,1,4,6,5,3]
list_1.sort() # 原列表变化：list_1 == [1,2,3,4,5,6]
list_3 = sorted(list_2) # 原列表不变：list_2 == [2,1,4,6,5,3]; list_3 == [1,2,3,4,5,6]

왜 Python 목록 색인은 0부터 시작하나요?

Python의 아버지인 Guido van Rossum의 블로그 게시물에서 권위 있는 설명이 나옵니다: "Python이 0 기반 인덱싱을 사용하는 이유"

한 문장으로 요약: 인덱스는 0부터 시작하며, 슬라이싱의 사용법은 다음과 같습니다. 매우 우아합니다.

번역의 핵심은 다음과 같습니다.

제가 Python에서 0 기반 인덱싱을 사용하기로 결정한 이유 중 하나는 슬라이스 표기법입니다.

슬라이스 사용법을 먼저 살펴보겠습니다. 아마도 가장 일반적인 사용법은 "처음 n개 요소를 가져옵니다" 또는 "i번째 위치에서 색인을 생성하고 마지막 n개 요소를 가져옵니다"입니다(이전 사용법은 실제로 i==시작 위치의 특별한 사용법입니다). 표현식에서 보기 흉한 +1이나 -1 없이 이 두 가지 사용법을 구현할 수 있다면 매우 우아할 것입니다.

0 기반 인덱싱, 반 개방 간격 슬라이싱 및 기본 일치 간격(Python이 마침내 이 방법을 채택함)을 사용하면 위의 두 상황에 대한 슬라이싱 구문이 매우 아름다워집니다: a[:n] 및 a[ i:i +n], 전자는 a[0:n]의 약어이다.

如果使用1-based的索引方式，那么，想让a[:n]表达“取前n个元素”的意思，你要么使用闭合区间切片语法，要么在切片语法中使用切片起始位和切片长度作为切片参数。半开区间切片语法如果和1-based的索引方式结合起来，则会变得不优雅。而使用闭合区间切片语法的话，为了从第i位索引开始取后n个元素，你就得把表达式写成a[i:i+n-1]。

……

特别是当两个切片操作位置邻接时，第一个切片操作的终点索引值是第二个切片的起点索引值时，太漂亮了，无法舍弃。例如，你想将一个字符串以i，j两个位置切成三部分，这三部分的表达式将会是a[:i]，a[i:j]和a[j:]。

其它编程语言的索引？

索引从0开始的编程语言：C、C++、Python、Java、PHP、Ruby、Javascript...

索引从1开始的编程语言：ABC、Matlab、VB、易语言、大部分shell语言...

索引从其它值开始的编程语言：Pascal、Lua...

还有像表示星期、月份等序列结构的数据，各种编程语言也划分成了不同阵营。

它们出于何种考虑？

C语言：索引从0开始，可以大大提升内存寻址计算的效率，详细分析参考《C语言数组元素下标为何从0开始》

大部分shell语言：大多数是从1开始，来源参考stackexchange这篇问答

Pascal、Lua：默认从1开始，但支持改变起始索引值，原因据说是对非专业的开发者更友好，来源参考这篇知乎问答

以上列举的原因是最审慎的、体面的解释，话题应该到此终结，因为“索引应该从几开始最好”这个问题的破坏性不亚于“哪种编程语言是最好的”......

优雅漂亮的结尾：生成器表达式

列表生成式是一种漂亮优雅的东西，然而它有一个致命的缺点：它一次性把所有元素加载到内存中，当列表过长的时候，便会占据过多的内存资源，而且，我们通常仅需要使用少数的元素，这样未使用的元素所占据的绝大部分的内存，就成了不必要的支出。

生成器是一种更高级更优雅的东西，它使用“懒加载”的原理，并不生成完整的列表，而是迭代地、即时地、按需地生成元素，这样不仅能极大地节省内存空间，而且，在理论上，它可以生成一个无穷大的列表！

大多数生成器是以函数来实现的，然而，它并不返回（return）一个值，而是生成（yield）一个值，并挂起程序。然后，通过next()方法生成并马上返回一个元素，或者通过for循环，逐一生成和返回全部元素。

next()效率太低，且调用次数越界时会抛出StopIteration的异常，而for循环会自动捕捉这个异常，并停止调用，所以使用更佳。

# 计算斐波那契数列的生成器
def fibon(n):
a = b = 1
for i in range(n):
yield a  # 使用yield
a, b = b, a + b

# 计算前1000000个数，通过next()函数，按顺序每次生成一个数
g = fibon(1000000)
next(g)  # 1
next(g)  # 1
next(g)  # 2
next(g)  # 3
next(g)  # 5
# 以此类推，但若调用超过1000000次，就会报异常StopIteration
# 计算前1000000个数，通过for循环逐一打印生成数
for x in fibon(1000000):
print(x)

生成器表达式与列表生成式极其形似，只是把[]改成了()，但背后的原理大不相同。

l = [x*2 for x in range(5)]  # 列表生成式，4以内整数的2倍数
g = (x*2 for x in range(5))  # 生成器表达式
type(l)   # 结果：<type &#39;list&#39;>
type(g)   # 结果：<type &#39;generator&#39;>

print(l)  # 结果：[0,2,4,6,8]
print(g)  # 结果：<generator object at 0x000002173F0EBC50>
next(g)   # 0
next(g)   # 2
next(g)   # 4
next(g)   # 6
next(g)   # 8
next(g)   # Traceback (most recent call last): ....StopIteration

for x in g:
print(x, end=' ')  # 结果：0 2 4 6 8

위 내용은 Python 목록을 배우는 데 도움이 되는 기사의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!