字符串列表

一、列表是何等

  • 列表是1密密麻麻按一定顺序排列的成分构成的,能够将其余东西出席列表中,当中的因素之间能够未有其余关联。鉴于列表经常包涵三个成分,给列表制定二个意味着复数的称号(如names)是个不错的主见。
  • 用方括号[ ] 表示列表,并用逗号来分隔在那之中的因素。

bicycles = ['trek','cannondale','redline']
print(bicycles)
  • 做客列表(遵照目录)

bicycles = ['trek','cannondale','redline']
print(bicycles[0])

目录是从0初阶的,-2回去最后一个列表成分,-1遍去尾数第三个列表成分就那样类推(常常可用在不晓得列表长度的图景下访问最终的因素)。

一、列表简单介绍

说明:

列表也就是任何语言的数组。能够用以下二种艺术定义列表:

name = ['honda', 'yamaha', 'suzuki']
bicycles = list('trek', 'cannondale', 'redline', 'specialized')

列表的目录从0初始,用-一意味着最后一项,而-二表示倒数第二项,就那样类推比方:

print(name[0])    # 'honda'
print(name[-1])   # 'suzuki'

2、修改、增多和删除成分

 

措施和函数:

1、修改列表成分

bicycles = ['trek','cannondale','redline']
print(bicycles)
#修改元素值
bicycles[0] = 'handa'
print(bicycles)

一.一 列表是如何?

方法:

必发88官网 1必发88官网 2

    def append(self, p_object): # 无返回值,添加一个对象到最后
        """ L.append(object) -> None -- append object to end """
        pass

    def clear(self): # 无返回值,删除列表中所有项
        """ L.clear() -> None -- remove all items from L """
        pass

    def copy(self): # 返回一个浅复制列表
        """ L.copy() -> list -- a shallow copy of L """
        return []

    def count(self, value): # 返回整数——参数value在列表中的个数
        """ L.count(value) -> integer -- return number of occurrences of value """
        return 0

    def extend(self, iterable): # 无返回值,将参数iterable扩展到原列表中
        """ L.extend(iterable) -> None -- extend list by appending elements from the iterable """
        pass

    def index(self, value, start=None, stop=None): # 返回整数——参数value的第一个索引,如果不存在返回错误ValueError
        """
        L.index(value, [start, [stop]]) -> integer -- return first index of value.
        Raises ValueError if the value is not present.
        """
        return 0

    def insert(self, index, p_object): # 在索引index处,插入值p_object
        """ L.insert(index, object) -- insert object before index """
        pass

    def pop(self, index=None): # 返回索引index的值,默认index取值为列表最后一个索引
        """
        L.pop([index]) -> item -- remove and return item at index (default last).
        Raises IndexError if list is empty or index is out of range.
        """
        pass

    def remove(self, value): # 无返回值,删除列表中第一个值为value的项
        """
        L.remove(value) -> None -- remove first occurrence of value.
        Raises ValueError if the value is not present.
        """
        pass

    def reverse(self): # 反转列表中元素的排序
        """ L.reverse() -- reverse *IN PLACE* """
        pass

    def sort(self, key=None, reverse=False): # 排序列表,reverse=True时,返转排序结果
        """ L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE* """
        pass

View Code

贰、添港币素

  • 在列表末尾添美金素 append(value)

bicycles = ['trek','cannondale','redline']
print(bicycles)
#末尾添加元素
bicycles.append('handa')
print(bicycles)

方法append()让动态地创立列表易如反掌,可以先创建三个空驶列车表,再使用一层层的append()语句添比索素。

  • 在列表中插入元素 insert(index,value)

bicycles = ['trek','cannondale','redline']
print(bicycles)
#在开头添加元素
bicycles.insert( 0 ,'handa')
print(bicycles)

 

函数:

  • del:要是知道要刨除的元素的目录,能够用del语言删除该因素,与List方法pop(index)的区分在于del语句未有重返值,而pop(index)重回被剔除的项

    numbers = list((1, 2, 3, 4, 5, 6))
    del numbers[2]
    print(numbers)
    
    # 输出
    # [1, 2, 4, 5, 6]
    
    numbers = list((1, 2, 3, 4, 5, 6))
    number = numbers.pop(2)
    print(numbers)
    print(number)
    
    # 输出
    # [1, 2, 4, 5, 6]
    # 3
    

     

  • 函数sorted()排序,sorted(reverse=True)反向排序,与List方法sort()的界别在于,函数sorted()重返二个排体系表,原列表成分仍然,而艺术sort()排序的是原列表,无重回值

    cars = ['bmw', 'audi', 'toyota', 'subaru']
    print(sorted(cars, reverse=True))
    print(cars)
    cars.sort()
    print(cars)
    
    # 输出
    # ['toyota', 'subaru', 'bmw', 'audi']
    # ['bmw', 'audi', 'toyota', 'subaru']
    # ['audi', 'bmw', 'subaru', 'toyota']
    

     

  • 函数len()重回列表的长度

叁、从列表中删除元素

  • 采用del语句删除成分

bicycles = ['trek','cannondale','redline']
print(bicycles)
#删除开头元素
del bicycles[0]
print(bicycles)

利用del可去除任何地方处的列表成分,条件是理解其索引。

  • 行使pop(index)删除成分

bicycles = ['trek','cannondale','redline']
print(bicycles)
#删除末尾元素,保存被删除的值
popped_bicycle = bicycles.pop()
print(bicycles)
print(popped_bicycle)

注:index省略时表示删除末尾

  • 弹出列表中任何职责处的成分
    假若要从列表中剔除三个因素,且不再以任何措施选用它,就应用del语句;若是要在剔除成分后仍是能够承继采用它,就选取pop()。
  • 听他们讲值删除元素 remove(value)

bicycles = ['trek','cannondale','redline']
print(bicycles)
#删除特定值
bicycles.remove('redline')
print(bicycles)

使用remove(
)从列表中去除成分时,也足以随着使用它的值,用变量储存起来。然而,方法remove(
)只删除第三个钦定的值,如若要刨除的值或许在列表中出现数十次,就必要运用循环来推断是不是删除了具备那样的值。

列表由1多级特定 顺序排列  的 成分 组成。列表类似于C语言的数组,可是比数组高档,列表中的类型没有限制。能够分包各体系型。

数值列表

可以使用for循环遍历列表

cars = ['bmw', 'audi', 'toyota', 'subaru']
for car in cars:
    print(car.title())

运用函数range()能够生成一层层的数字,比如range(壹,
10)将生成一到九以内的数字,注意该类别数字不包蕴range()最终3个参数所钦命的数值。由上能够,C语言中的for(int i = 0; i < 10; i++)能够改成python中的for index in range(0, 10):

动用range()时,还能创设步长,比方创设3个以二始发,步长为二的列表

even_numbers = list(range(2,11,2))
print(even_numbers)        # [2, 4, 6, 8, 10]

对数值列表能够选择mix,max,sum等函数来计量该列表的细微值、最大值和总的数量

>>> digits = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
>>> min(digits)
0
>>> max(digits)
9
>>> sum(digits)
4

三、协会列表

 

列表分析

能够经过列表深入分析急迅的创建一个亟需通过总结而产生的列表,举个例子包涵一~10的平方列表

squares = [value**2 for value in range(1, 11)]   # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

小心:for语句前边不要加冒号(:)

一、使用sort()对列表实行长久性排序

bicycles = ['trek','cannondale','redline']
print(bicycles)
#排序
bicycles.sort()
print(bicycles)

上述是依附字母逐壹排序,也得以服从字母顺序相反的顺序排序。

bicycles = ['trek','cannondale','redline']
print(bicycles)
#排序
bicycles.sort( reverse = True)
print(bicycles)

例如:

切片

要创设切块,可钦点要使用的首先个因素和结尾二个因素的目录。举例:

players = ['charles', 'martina', 'michael', 'florence', 'eli']
    print(players[0:3])  # ['charles', 'martina', 'michael']

和range()函数同样,切条管理的成分包罗第多个参数内定的目录,不包蕴第一个参数钦定的目录。若是简单第叁个参数,表示开首切成片,上例也足以代表为players[:3],借使轻松首个参数,表示从第3个参数钦命索引开头提抽取到列表末尾的有所因素。

也得以动用负数表示从后切成条,举个例子:

players = ['charles', 'martina', 'michael', 'florence', 'eli']
print(players[-3:])  # ['michael', 'florence', 'eli']

2、使用sorted()对列表举办不经常排序

bicycles = ['trek','cannondale','redline']
print("Here is the original list:")
print(bicycles)

#排序
print("\nHere is the sorted list:")
print(sorted(bicycles))

print("\nHere is the original list again:")
print(bicycles)

若要按字母顺序相反排序,向函数sorted()传递参数reverse = True就能够。

>>> list = [1,'hello']
>>> list
[1, 'hello']

复制列表

利用同时省略伊始索引和得了索引的切成条来复制列表。那样将复制出两份独立的列表,借使直接将原列表赋值给新的列表,七个变量将对准同四个列表

my_foods = ['pizza', 'falafel', 'carrot cake']
friend_foods = my_foods[:]
my_foods.append('cannoil')
friend_foods.append('ice sream')
print("My favorite foods are:")
print(my_foods)
print("\nMy friend's favorite foods are:")
print(friend_foods)

# 输出
# My favorite foods are:
# ['pizza', 'falafel', 'carrot cake', 'cannoil']

# My friend's favorite foods are:
# ['pizza', 'falafel', 'carrot cake', 'ice sream']

my_foods = ['pizza', 'falafel', 'carrot cake']
friend_foods = my_foods
my_foods.append("cannoil")
print(my_foods)
print(friend_foods)

# 输出
# ['pizza', 'falafel', 'carrot cake', 'cannoil']
# ['pizza', 'falafel', 'carrot cake', 'cannoil']

三、倒着打印列表

bicycles = ['trek','cannondale','redline']
print(bicycles)
#倒序
bicycles.reverse()
print(bicycles)

办法reverse()长久性地修改列表成分的排序依次,但可随时过来到原来的排列顺序,对列表在调用3回reverse()即可。

 

 元组

元组能够当作是只读的列表,元组中的成分1经定义其值将不可能改动。元组的定义与列表类似,将中括号改为小括号就能够定义元组。

可以动用list将元组调换来列表,使用tuple将列表转形成元组

必发88官网 3必发88官网 4

四、分明列表的尺寸 len(list)

bicycles = ['trek','cannondale','redline']
print(len(bicycles))

1.2 访问列表成分

四、使用列表时幸免索引错误

IndexError:list index out of range
使用列表发生索引错误时,可尝试将列表或其长度打字与印刷出来。

 

5、遍历整个列表

names = ['Tom','Alice','Nancy']
for name in names:
    print(name)

注:

  • for循环中的临时变量能够选取任何变量,一般取为列表的单数情势。
  • 拍卖好for循环中的缩进难题。循环实行的要缩进,循环结束后施行的2回性操作不缩进。
  • 小心不要漏掉了冒号 :

列表是一个稳步的多少集合。访问时只需提出列表的称谓,然后将某些要拜访成分的职位或索引告诉
Python 就能够。

6、创造数值列表

 

1、使用函数range()

for value in range( 1 , 4 ):
    print(value)

函数range
()从内定的第二个初叶数,并在达到钦点的第贰个值后结束,由此输出不会含有第3个值。
注:使用range()时,若是出口不适合预期,请尝试将点名的值加一 也许减壹。

例如:

2、使用range() 创立数字列表

numbers = list(range(start,step,end))
print(numbers)

注:步长step能够省略,默以为①。

 

三、对数字列表实行轻松的总括测算

digits = [1,2,3,4,5,6,7,8]
print( min(digits) )
print( max(digits) )
print( sum(digits) )
>>> list[0]
1

四、列表分析

列表深入分析便是讲for循环和创建新因素的代码合并成1行,并机关叠加新成分。

squares = [ ]
for value in range(1,11):
    square =value**2
    squares.append(square)
print(squares)

#列表解析
squares = [value**2 for value in range(1,11)]
print(squares)

留神列表成分的目录时从 0 开首的而不是 壹 开首(这一点倒是和C语言数组类似)

七、使用列表的壹有的

 

1、切片

names = ['Tom','Alice','Nancy']
print(names[0:3])

注:

  • 切开和range()一样,在到达内定的第1个目录后边的要素就终止了。
  • 未曾点名第五个目录,Python将自行从列表开首初步。
  • 从未有过点名第贰个目录,Python将活动到列表末尾甘休。
  • 要出口最后多少个,可应用负数,eg:names[-2:]从尾数第3个一贯截取到初阶。

一.3 列表的增加和删除改

二、遍历切成丝

假使要遍历列表的片段因素,可在for循环中运用切成片。

names = ['Tom','Alice','Nancy']
for name in names[0:2]:
    print(name)

 

叁、复制列表

names = ['Tom','Alice','Nancy']
another_names = names[:]
print(another_names)

修改:

八、元组

列表适合用来存款和储蓄在程序运转时期可能转换的数据集,是能够修改的。元组是不可变的列表。看起来就如列表,但使用圆括号而不是方括号来标志。使用方法和列表同样。
就算不可能修改元组的因素,但足以给存储元组的变量赋值(重新定义整个元组)。

dimensions = (200,100)
print("Original dimensions:")
for dimension in dimensions:
    print(dimension)

#修改元组变量
dimensions = (400,50)
print("\nModified dimensions:")
for dimension in dimensions:
    print(dimension)

比较之下于列表,元组是更简便易行的数据结构。借使须求仓库储存的一组值在程序的全部生命周期内都不改变,可应用元组。

>>> list[0] = 300
>>> list[0]
300

 

增加:

在列表末尾添日成分 append()

>>> list.append("world")
>>> list
[300, 'hello', 'world']

 

在列表中插入元素

>>> list.insert(0,'Just insert')
>>> list
['Just insert', 300, 'hello', 'world']

 

删除:

1.利用 del 语句删除成分,使用 del
能够去除任何岗位的列表成分,条件是领略其索引。

 

>>> del list[1]
>>> list
['Just insert', 'hello', 'world']

 

2.用到 pop() 方法 删除元素,pop()
可去除列表末尾的因素,并令你能够接着使用它(正是能够将去除的列表成分交给其余1个变量)。

 

>>> pop_list = list.pop()
>>> list
['Just insert', 'hello']
>>> pop_list
'world'

 

3.运用pop() 来删除列表中其余地点的因素。

 

>>> list.pop(0)
'Just insert'
>>> list
['hello']

 

肆.根据值来删除成分。若是您只掌握要刨除的要素的值,你能够利用格局remove() 来兑现您的删除成分成效。

 

>>> list.remove('hello')
>>> list
[]
>>>

 

一.四 协会列表/列表的排序

 

一.用到格局 sort() 对列表进行恒久性排序

>>> cars = ['bmw', 'audi' ,'toyota' , 'subaru']
>>> cars
['bmw', 'audi', 'toyota', 'subaru']
>>> cars.sort()
>>> print(cars)
['audi', 'bmw', 'subaru', 'toyota']

 

如上所示,sort() 私下认可是遵照字符顺序排序的。假如要倒序排列,可加参数
reverse = True

 

>>> cars = ['bmw','audi','toyota','subaru']
>>> cars
['bmw', 'audi', 'toyota', 'subaru']
>>> cars.sort(reverse = True)
>>> cars
['toyota', 'subaru', 'bmw', 'audi']

 

二.行使函数 sorted() 对列表进行临时排序

 

万壹你想保留原有的列表排列顺序,不过又想规行矩步某种顺序展现它们,你能够选取sorted()。

 

>>> cars = ['bmw','audi','toyota','subaru']
>>> cars
['bmw', 'audi', 'toyota', 'subaru']
>>> sorted(cars)
['audi', 'bmw', 'subaru', 'toyota']

 

如出1辙假如要倒序加参数 reverse = True 就能够。

 

三.倒着打字与印刷列表(未有排序,只是调节前后输出,反转列表成分,此输出会永远修改列表顺序)

>>> cars
['bmw', 'audi', 'toyota', 'subaru']
>>> cars.reverse()
>>> print(cars)
['subaru', 'toyota', 'audi', 'bmw']

 

四.拿走列表的尺寸 len()

 

>>> cars
['subaru', 'toyota', 'audi', 'bmw']
>>> len(cars)
4

 

一.5 列表访问的失实

 

一.列表访问时注意列表索引是从 0 开端的,不要超越可访问的目录上限。

 

2.列表访问最终三个成分得以应用索引 -一,不过要留意列表一定不可能是空的,不然报错。

 

 

2、操作列表

 

二.一.遍历整个列表

 

借使您想对列表中的元素实行某些一样大概差别的操作,你就只怕会用到循环。这里先介绍for循环:

 

>>> magicians = ['alice', 'david', 'carolina']
>>> for magician in magicians:
         print(magician)

alice
david
carolina

 

注:python是分别轻重缓急写的,所以最主要字 for 和 in 必须确定保证小写。

 

循环是计算机自动完结重复专门的工作的宽广方法之壹。举个例子上述 for
循环示例,首先会将列表 magicians 中的第四个因素赋给变量
magician,然后施行打字与印刷操作,将magician的值打字与印刷出来。紧接着会接二连三将第贰个因素一贯到末了三个因素将
magicians 全部因素全部每种赋值给变量 magician 然后打印出来。

 

PS:这里变量的命名使用单数和复数情势是1个毋庸置疑的习于旧贯。

 

瞩目:Python是多个运用缩进来决断代码行关系的,所以编写时一定要留心行与行之间的缩进关系。缩进让代码更易读,它供给你选取缩进让代码整洁而构造清晰。

 

二.二.创办数值列表

 

2.2.1.使用 range() 函数

 

>>> for value in range(1, 5):
         print(value)

1
2
3
4

 

选拔 range()
可以轻松获得内定范围的整型(Integer)数字,不过范围并不包罗第2参数值。如上所示,range(一,
5) 只会取 壹~四 之间的多少,要想打字与印刷出 5 ,就不能够不是 range(一, 陆)

 

贰.二.2.怎么样使用 range() 函数创设列表:

 

>>> numbers = list(range(1, 6))
>>> print(numbers)
[1, 2, 3, 4, 5]

 

如上所示,要运用 range() 函数来创造列表,用 list() 就能够。

 

必发88官网,range() 函数在选择时还足以加上步长

 

>>> numbers = list(range(1, 6, 2))
>>> print(numbers)
[1, 3, 5]

 

二.二.叁.对此数字类型的列表大家运用如下函数来找在这之中的最大值,最小值和总的数量:

 

>>> digits = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
>>> max(digits)
9
>>> min(digits)
0
>>> sum(digits)
45

 

二.二.4.列表深入分析

 

列表解析将 for 循环和开创成分的代码合并壹行,并机关叠合新成分。

 

>>> squares = [value ** 2 for value in range(1, 11)]
>>> print(squares)
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

 

注:“**二”表示平方值,“**三”表示立方值。

 

2.三.列表切成丝

 

只使用列表部分因素的措施。Python 称之为 切片

 

要创制切成条,可指定要使用的首先个因素和尾声一个要素的目录(列表的目录是从0初阶的)。与函数
range() 同样。Python
在达到您钦命的第二个因素前面包车型客车要素后终止。尽管你要出口列表前八个成分,你就必须钦命索引
0~三,那将出口分别为 0 、一、二 的要素。

 

>>> squares = [value ** 3 for value in range(1, 11)]
>>> print(squares[0:3])
[1, 8, 27]

 

切开的率先个参数暗许是列表初始的目录,第二个参数暗中认可是列表结尾的目录。第二个参数可以给负数(第3个参数给负值后,第贰个参数只可以为空)
,表示从最后开端取负数相对值个成分。第叁参数也可以给负数(第1个参数小于必须列表最大索引值减去从列表尾数第3个参数相对值处索引值),表示取从第二个参数索引开端到结尾处尾数第负数相对值索引范围内的要素。

>>> print(squares[:])
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]
>>> print(squares[-3:])
[512, 729, 1000]
>>> print(squares[:-3])
[1, 8, 27, 64, 125, 216, 343]
>>> print(squares[-3:5])
[]
>>> print(squares[-3:3])
[]
>>> print(squares[-3:1])
[]
>>> print(squares[-3:0])
[]
>>> print(squares[-3:])
[512, 729, 1000]
>>> print(squares[-3:-3])
[]
>>> print(squares[1:-3])
[8, 27, 64, 125, 216, 343]
>>> print(squares[10:-3])
[]
>>> print(squares[len(squares) - abs(-3) - 1:-3])
[343]
>>> print(squares[len(squares) - abs(-3):-3])
[]

 

运用切成丝复制列表,假诺您想利用已某些列表成分重新新建1个列表就非得用到切丝。普通的赋值是极度的,普通的赋值只是将近来列表的列表地址赋给了新扩展的列表,并未有新扩张四个怀有独立内部存款和储蓄器地址的列表。

 

>>> numbers = squares
>>> print(numbers)
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]
>>> squares.append(0)
>>> print(numbers)
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000, 0]
>>> print(squares)
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000, 0]
>>> numbers = squares[:]
>>> numbers.append(101)
>>> print(numbers)
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000, 0, 101]
>>> print(squares)
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000, 0]0

 

2.4.元组

 

列表非常适合用于存款和储蓄在程序运转时期大概变化的数码集。列表是足以修改的,那对管理网址的用户列表或娱乐中的剧中人物列表至关心重视要。但是,不时候你须求创制一多重不可修改的要素,元祖可以满意这种须求。Python
将无法改改的值称为 不可变的,而不可变的列表 被称为 元组

 

二.4.一.定义元组

 

元组看起来就像列表,但使用的是 圆括号 而不是
方括号来标记。定义元组后,就能够使用索引来访问其元素,就像是访问列表成分同样。

 

>>> tuple = (200, 50)
>>> print(tuple[1])
50
>>> tuple[1] = 60
Traceback (most recent call last):
  File "<pyshell#102>", line 1, in <module>
    tuple[1] = 60
TypeError: 'tuple' object does not support item assignment

 

二.4.二.元组的遍历

 

元组的遍历和列表同样也能够行使for。

 

>>> numbers = (200, 50)
>>> for number in numbers:
         print(number)
200
50

 

二.四.三.元组的退换

 

元组的要素就算不能够修改,可是大家能够因此退换元组变量来促成元组的改变。

 

>>> numbers = (200, 50)
>>> print(numbers)
(200, 50)
>>> numbers = (200, 60)
>>> print(numbers)
(200, 60)

 

 

相关文章