Python 3：详细介绍LIST的概念

最新推荐文章于 2022-09-14 09:22:53 发布

dfsgwe1231

最新推荐文章于 2022-09-14 09:22:53 发布

阅读量682

点赞数

文章标签：列表字符串 python java 大数据

原文链接：https://hackernoon.com/python-3-concept-of-list-in-details-pzq3u9n

版权

LIST的字典含义是多个连续写或打印的连接项或名称，通常一个接一个。

在现实世界中，列表的考虑方式很多，例如歌曲的播放列表，收藏的视频，用户数据库的列表等等。但是，如果为您提供了处理用户列表并在特定条件下过滤掉特定用户的任务，那么通过遍历每个用户来过滤列表将变得很繁琐。在这种情况下，可以进行编程以简化工作。

因此，现在让我们了解“什么是列表？” 在python编程中。在python中，列表是可变的或可变的有序元素序列，其中列表内部的每个元素或值称为item 。

在字符串中，如何在列表中类似地将每个值/元素表示为字符，每个值/元素由逗号分隔，其中每个元素可以是[]括号内的字符串，变量或常量。

List的语法：

['LetsUpgrade' , 'Batch1' , B2, B3] Nested List: [ 'LetsUpgrade' , [ 'java' , 'python' , 'c++' ], 1 , 2 , [ 'B1' , 'B2' ], 'Exam' ]

LIST中涵盖的主题如下：

索引清单
列表是可变的
更新和切片列表
在列表中使用运算符
列表中使用的方法
列表中的内置功能
从列表中删除元素
用清单项目构造清单
列表和字符串
解析行
对象和价值
混叠
列出参数
清单理解
将条件与列表理解结合使用
列表理解中的嵌套循环
调试

我们将通过示例而不是理论来理解上述主题。

＃索引列表 ：

列表中的每个项目都对应一个索引号，它是一个整数值，从索引号0开始。

对于列表COURSES，索引细分如下所示：

第一项是字符串“ Java”，从索引0开始，列表以索引4结束，索引为“ Javascript”。

print(COURSES[3 ])
OUTPUT:
R

如果我们将索引编号大于4的列表称为COURSES列表，则将超出范围，因为它将无效：

print(COURSES[5 ])
Output:
IndexError: list index out of range

上面是正索引，现在让我们看一下负索引，如下所示：

对于相同的列表COURSES，负索引细分如下所示

print(COURSES[-3 ])
1
2
	
Output
Python

＃列表是可变的 ：

例：-

>>>  numbers = [ 17 , 123 ]
>>>  numbers[ 1 ] = 5
>>>  print(numbers)
[ 17 , 5 ]

因此，按照上述示例，列表是可变的，即可变的。

＃更新和切片列表 ：

更新中

通过将索引号设置为不同的值，我们可以使用索引来更改列表中的项目。这使我们能够更好地控制列表，因为我们能够修改和更新列表中包含的项目。

如果要将索引1处的项目的字符串值从'C ++'更改为'SQL'，我们可以这样做：

COURSES[1] = 'SQL'

现在，当我们打印COURSES时，列表将有所不同：

print(COURSES)1
2
	
Output
[ 'Java' , 'SQL' , 'Python' , 'R' , 'Javascript' ]

同样，它适用于负索引。

切片列表

我们还可以从列表中调出一些项目。假设我们只想打印sea_creatures的中间项目，我们可以通过创建slice来实现 。对于切片，我们可以通过创建一系列用冒号[x：y]分隔的索引号来调用多个值：

print(COURSES[1 : 4 ])
1
2
	
Output
[ 'SQL' , 'Python' , 'R' ]

在创建切片时，如[1：4]中所示，第一个索引号是切片开始的位置（包括），第二个索引号是切片结束的位置（不包括），因此在我们的示例中，项目位于位置1、2和3是打印出来的项目。

如果要包括列表的任一端，则可以省略list [x：y]语法中的数字之一。

print(COURSES[:3 ])
1
2
	
Output
[ 'Java' , 'SQL' , 'Python' ]

这将打印列表的开头，在索引3之前停止。

为了将所有项目包括在列表的末尾，我们将颠倒语法：

print(COURSES[2 :])
1
2
	
Output
[ 'Python' , 'R' , 'Javascript' ]

切片列表时，我们也可以使用负索引号，就像正索引号一样：

print(COURSES[-4 : -2 ])
print(COURSES[ -3 :])
1
2
3
	
Output
[ 'SQL' , 'Python' ]
[ 'Python' , 'R' , 'Javascript' ]

我们可以与切片一起使用的最后一个参数称为stride ，它是指从列表中检索到第一个项目后要前进的项目数。到目前为止，我们已经省略了stride参数，Python默认将stride设置为1，以便检索两个索引号之间的每个项目。

此构造的语法为list [x：y：z]，其中z表示步幅。让我们做一个更大的列表，然后对其进行切片，并将步幅的值设置为2：

numbers = [0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 , 11 , 12 ]
 
print(numbers[ 1 : 11 : 2 ])
1
2
	
Output
[ 1 , 3 , 5 , 7 , 9 ]

我们的构造数[1：11：2]打印索引编号（包括1和11）之间的值，然后跨度值为2告诉程序仅打印其他所有项目。

我们可以省略前两个参数，并单独使用stride作为语法列表[:: z]的参数：

print(numbers[::3 ])
1
2
	
Output
[ 0 , 3 , 6 , 9 , 12 ]

通过将跨度设置为3的列表编号打印出来，仅每三项打印一次：

0，1，2，3，4，5，6，7，8，9，10，11，12

对具有正负索引号的列表进行切片并指示步幅可为我们提供控制列表的控件，以操纵列表并接收我们试图实现的输出。

＃ 使用List中的运算符 ：

运算符用于列表中的修改。我们将使用+和*运算符及其复合形式+ =和* =。

+运算符可用于将两个或多个列表连接在一起：

LetsUpgrade_Courses = ['Java' , 'ML' , 'AI' , 'Data Science' , 'Javascript' ]
prizes= [ 'Hp Laptop' , 'LED TV' , 'Iphone' ]
 
print (LetsUpgrade_Courses + prizes)

Output
[ 'Java' , 'ML' , 'AI' , 'Data Science' , 'Javascript' , 'Hp Laptop' , 'LED TV' , 'Iphone' ]

现在，让我们看一下*运算符：

print (LetsUpgrade_Courses * 2 )
print (prizes* 3 )
Output
[ 'Java' , 'ML' , 'AI' , 'Data Science' , 'Javascript' , 'Java' , 'ML' , 'AI' , 'Data Science' , 'Javascript' ]
[ 'Hp Laptop' , 'LED TV' , 'Iphone' , 'Hp Laptop' , 'LED TV' , 'Iphone' , 'Hp Laptop' , 'LED TV' , 'Iphone' ]

复合形式'+ ='＆'* ='：

forx in  range( 1,4):
    LetsUpgrade_Courses += [ 'AI' ]
    p rint( LetsUpgrade_Courses)

Output
[ 'Java' , 'ML' , 'AI' , 'Data Science' , 'Javascript' , 'AI' ]
[ 'Java' , 'ML' , 'AI' , 'Data Science' , 'Javascript' , 'AI' , 'AI' ]
[ 'Java' , 'ML' , 'AI' , 'Data Science' , 'Javascript' , 'AI' , 'AI' , 'AI' ]

prizes = ['bike' ]
 
for x in range( 1 , 4 ):
    prizes *= 2
    print(prizes)
	
Output
[ 'bike' , 'bike' ]
[ 'bike' , 'bike' , 'bike' , 'bike' ]
[ 'bike' , 'bike' , 'bike' , 'bike' , 'bike' , 'bike' , 'bike' , 'bike' ]

#List中使用的方法 ：

现在，您的工作是向GOOGLE提供以下功能，并了解它们在Python编程中的工作方式。（行使）

Append（）：将元素添加到列表的末尾
Extend（）：将列表的所有元素添加到另一个列表
Insert（）：在定义的索引处插入一个项目
Remove（）：从列表中删除一个项目
Pop（）：删除并返回给定索引处的元素
Clear（）：从列表中删除所有项目
Index（）：返回第一个匹配项的索引
Count（）：返回作为参数传递的项目数
Sort（）：按升序对列表中的项目进行排序
Reverse（）：反转列表中项目的顺序
copy（）：返回列表的副本

＃List中的内置函数 ：

reduce（）：将在其参数中传递的特定函数应用于所有列表
元素存储中间结果，仅返回最终结果
求和值
sum（）：汇总列表中的数字
ord（）：返回一个整数，该整数表示给定Unicode字符的Unicode代码点
cmp（）：如果第一个列表“大于”第二个列表，则此函数返回1
max（）：返回给定列表的最大元素
min（）：返回给定列表的最小元素
all（）：如果所有元素为true或list为空，则返回true
any（）：如果列表中的任何元素为true，则返回true。如果列表为空，则返回false
len（）：返回列表的长度或列表的大小
enumerate（）：返回列表的枚举对象
accumulate（）：将在其参数中传递的特定函数应用于所有列表元素，返回包含中间结果的列表
filter（）：测试列表中的每个元素是否正确
map（）：将给定函数应用于给定iterable的每个项目后，返回结果列表
lambda（）：此函数可以有任意数量的参数，但只有一个表达式可以计算并返回。

＃从列表中删除元素 ：

要删除该项目，我们将使用del语句，然后调用list变量和该项目的索引号：

LetsUpgrade_Courses =['Java' , 'ML' , 'AI' , 'Data Science' , 'Javascript' ]
 
del LetsUpgrade_Courses[ 2 ]
print (LetsUpgrade_Courses)

Output
[ 'Java' , 'ML' , 'Data Science' , 'Javascript' ]

要删除多个元素，可以将del与切片索引一起使用：

>> > t = [ 'a' , 'b' , 'c' , 'd' , 'e' , 'f' ]
>> > del t[ 1 : 5 ]
>> > print(t)
[ 'a' , 'f' ]

还有其他几种从列表中删除元素的方法。如果知道所需元素的索引，则可以使用pop和remove：

>> > t = [ 'a' , 'b' , 'c' ]
>> > x = t.pop( 1 )
>> > print(t)
[ 'a' , 'c' ]
>> > print(x)
b

pop修改列表并返回已删除的元素。如果不提供索引，它将删除并返回最后一个元素。

如果知道要删除的元素（但不知道索引），则可以使用remove：

>> > t = [ 'a' , 'b' , 'c' ]
>> > t.remove( 'b' )
>> > print(t)
[ 'a' , 'c' ]

＃ 使用列表项构建列表 ：

LetsUpgrade_Community = [[ 'Frontend' , 'Backend' ],[ 'Sai Sir' , 'Viral Sir' , 'Prasad Sawant' , 'Annirudha' , 'Yogesh Raghupati' ]]

列表中的列表称为嵌套列表 。

要访问此列表中的项目，我们将必须使用多个索引：

print(LetsUpgrade_Community[1 ][ 0 ])
print(LetsUpgrade_Community[ 0 ][ 0 ])
	
Output
Sai Sir
Frontend

#List和字符串 ：

假设现在您知道String和List之间的区别，让我们将STRING转换为CHARACTERS列表，如下所示–

>> > s = 'LetsUpgrade'
>> > t = list(s)
>> > print(t)
[ 'L' , 'e' , 't' , 's' , 'U' , 'p' , 'g' , 'r' , 'a' , 'd' , 'e' ]

要将字符串分解为单词，我们可以使用split方法–

>> > s = 'FREE CODING SCHOOL'
>> > t = s.split()
>> > print(t)
[ 'FREE' , 'CODING' , 'SCHOOL' ]
>> > print(t[ 2 ])
SCHOOL

分隔符： 分隔符是一个或多个字符的序列，用于指定纯文本或其他数据流中单独的独立区域之间的边界。

>> > s = 'spam-spam-spam'
>> > delimiter = '-'
>> > s.split(delimiter)
[ 'spam' , 'spam' , 'spam' ]

JOIN：这是split的反函数。

>> > t = [ 'I am' , 'a' , 'LetsUpgrade' , 'Student' ]
>> > delimiter = ' '
>> > delimiter.join(t)
'I am a LetsUpgrade Student'

＃ 解析行 ：

通常，当我们读取文件时，除了对整个行进行打印外，我们还希望对行进行某些操作。通常，我们想找到“有趣的线条”，然后解析该线条以找到该线条中一些有趣的部分。如果我们要从“发件人”开头的那几行中打印出星期几该怎么办？

来自stephen.marquard@uct.ac.za 2008年1月5日星期六09:14:16

面对这种问题，拆分方法非常有效。我们可以编写一个小程序来查找以“ From”开头的行，拆分这些行，然后打印出该行中的第三个单词：

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

该程序产生以下输出：

周六
周五
周五
周五
…

（ 参考：pythonlearn）

＃对象和值：

我们将使用' is '运算符检查给定的两个变量'a'和'b'是否引用同一对象：

>>>a = 'banana'
>>> b = 'banana'
>>> a is b
True
	
>>> a = [ 1 , 2 , 3 ]
>>> b = [ 1 , 2 , 3 ]
>>> a is b
False

在第一个示例中，Python仅创建了一个字符串对象，并且a和b都引用该对象。

在第二种情况下，我们可以说这两个列表是等效的，因为它们具有相同的元素，但是不相同，因为它们不是同一对象。如果两个对象相同，则它们也是等效的，但是如果它们相等，则不必相同。

#Aliasing ：

>>>a = [ 1 , 2 , 3 ]
>>> b = a
>>> b is a
True

变量与对象的关联称为引用。在此示例中，有两个对同一对象的引用。

具有多个引用的对象具有多个名称，那么我们说特定对象是别名的 ，如果别名对象是可变的，则使用一个别名进行的更改会影响另一个对象：

>>> b[1 ] = 25
>>> print(a)
[ 1 , 25 , 3 ]

上面的方法似乎很有用，但是容易出错，因此最好避免在可变对象（如list）上使用此方法，而对于不可变的对象（如string）则没有太大问题。

#List参数 ：

def delete (t) :
    del t[ 0 ]
     
S = [ 'a' , 'b' , 'c' ]
delete (S)
print (S)
[ 'b' , 'c' ]

在上面的示例中，当我们将列表传递给函数时，该函数将获得对该列表的引用。如果在函数中对list参数进行了任何修改，则调用者将看到更改，如上述delete将从列表中删除第一个元素。

> >> t1 = [1, 2]
> >> t2 = t1.append(3)
> >> print (t1)
[1, 2, 3]
> >> print (t2)
None
	
> >> t3 = t1 + [3]
> >> print (t3)
[1, 2, 3]
> >> t2 is t3
False

在以上两个示例中，第一个用于修改现有列表 ，第二个用于创建新列表。 因此，除非我们将其分配为“ t2 = t3”，否则“ t2为t3”的输出为假。

def tail (t) :
    t = t[ 2 :] 
    
letters = [ 'a' , 'b' , 'c' , 'f' , 'd' ]
rest = tail(letters)
print (rest)
None
	
def tail (t) :
    t = t[ 2 :]
    return t
         
letters = [ 'a' , 'b' , 'c' , 'f' , 'd' ]
rest = tail(letters)
print (rest)
[ 'c' , 'f' , 'd' ]

如果我们比较上面两个示例，则两个示例的输出都不同，原因很简单，slice运算符创建了一个新列表，赋值使t引用了它，但是这些都不会对作为一个争论。

因此，在第二种情况下，它创建并返回一个生成的新列表。