+列表和元组

列表相关操作和相关函数

 

 

列表

定义

列表〔list]是包含0个或多个元素的有序序列，属于序列类型。

列表的长度和内容都是可变的，可自由对列表中的元素进行增加、删除或替换。

列表没有长度限制，元素类型可以不同，可以同时包含整数、实数、字符串等根本类型，也可以是列表、元组、字典、集合以及其他自定义类型的对象，使用非常灵活。与字符串的索引一样，列表索引从0开始。列表可以进行截取、组合等。

列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

list1 = ['physics', 'chemistry', 1997, 2000]

list2 = [1, 2, 3, 4, 5 ]

 list3 = ["a", "b", "c", "d"]

Python列表与c语言数组的比较

Python是一门动态语言，在Python列表的创建中，不需要指定数据结构，也不需要指定列表的长度，因为Python中的列表是通过链表的形式实现的。
相对应的，数组必须在创建的时候声明它的数据类型，也必须指定数组的长度。

列表中的所有元素的内存地址可以不是连续的，它是通过每个元素记录它的上一个元素的内存地址和下一个元素的内存地址来排列的。

数组是一个连续的内存空间，每个元素都按照先后顺序排列在内存中

实际应用中

1.     列表的合并和重复

①     组合列表（使用运算符“+”）

列表1 + 列表2

（将这两个列表合并成一个新的列表）

 

举例 ：

输入：list1 = [10,20,30]

list2 = [100,200]

result = list1 + list2

print(result)                      输出结果： [10,20,30,100,200]

     

②     重复列表（使用运算符“*”）

列表 * N

  （将列表中的元素重复N产生一个新的列表；N为整数）

 

   举例：

输入：list1 = [10,20,30]

print(list1*2)                         输出结果：[10, 20, 30, 10, 20, 30]

 

2列表的比较

①     比较相等： == 、!=

（比较是否相等或不相等）

 

举例：

输入：list1 = [10,20,30]

print(list1 == [10,20,30])                 输出结果：True

print(list1 == [10,200,30])           输出结果：False

“==”只有成员、成员位置都相同时才返回True

举例：

输入：list1 = [10,20,30]

print(list1 == [10,30,20])                 输出结果：False

 

      ② 比较大小：>、<、>=、<=

        （两个列表比较大小，比较的是第一对不相等元素的大小）

 

         举例：

             输入： list1 = [10,20,30]

list2 = [1,1000,30000,40000]

list3 = [10,1000,30000,40000]

print(list1>list2)                      输出结果：True

print(list1>list3)                     输出结果：False

 

②      in 和 not in

          （元素 in 列表 —— 判断指定列表中是否存在指定元素）

​          （ 元素 not in 列表 —— 判断指定列表中是否不存在指定元素）

 

           举例：

               输入：   print(10 in [10,2,3])                             输出结果：True

print([10,2] in [10,2,3])                       输出结果：False

print([10,2] in [[10,2,3]])                     输出结果：True

 

2.     相关函数（系统函数）sum、max、min、len、sorted、list

sum(列表)                                 求列表中所有元素的和（列表必须是数字列表）

max(列表)                                 求列表中所有元素的最大值

min(列表)                                  求列表中所有元素的最小值

len(列表)                                   求列表中元素的个数

sorted(列表)                              将列表中的元从小到大排序，产生一个新的列表

sorted(列表,reverse=True)         将列表中的元从大到小排序,产生一个新的列表

 

 

list                                                 将其他数据转换成列表

list (数据)                                      将指定数据转换成列表；（所有的序列都可以转换成列表：字符串，range ；将其他序列转换成列表的时候直接将序列的元素作为列表的元素）

 

举例：result = list('abc')

result1 = list(range(5))

print(result)                                   输出结果 ：['a','b','c']

print(result1)                                输出结果 ：[0,1,2,3,4]

 

列表相关方法

列表.append（x）                    把x元素添加到列表末尾

#list.append(x)

list=[1,2,3,4]

list.append(5)

print("更新后的列表:",list)

#输出结果

更新后的列表: [1, 2, 3, 4, 5]

列表.clear(x)                           清空列表

#list.clear()

>>> list=[1,2,3,4]

>>> list.clear()

>>> print("删除后的列：",list)

#输出结果为

删除后的列表：[]

列表.pop（[i]）      删除并返回列表中索引为i的元素，如果没有，则删除并返回列表中最后一个元素

#list.pop([i])

>>> list=[1,2,3]

>>> list.pop(1)

>>> print("删除后的列表",list)

>>> list.pop()

>>> print("删除的项",list)

#输出结果

删除后的列表 [1, 3]

删除的项 [1]

列表.remove（x）                        删除列表中第一个值为x的元素，如果没有，则返回一个错误

#list.remove(x)

list=[1,2,3,4]

list.remove(1)

>>>print("删除元素1之后的列",list)

#输出结果

删除元素1之后的列表 [2, 3, 4]

列表.copy(x)                           复制指定列表产生一个一样的新列表，将新的列表返回

（直接用一个变量给另一个变量赋值，赋的是地址，赋值后会导致两个变量同时指向同一块内存区域）

#list.copy

>>> list1=[1,2,3,4]

>>> list2=list1.copy()

>>> printf("复制后的列表为:",list2)

#输出结果为

复制后的列表为: [1, 2, 3, 4]

 

列表.count(元素)                  统计列表中指定元素的个数。

#list.count(x)

>>> list=[1,2,3,1,1,4]

>>> print("元素1出现的次数为:",list.count(1))

#输出结果为

元素1出现的次数为: 3

 

列表.extend(序列)                    将序列中所有的元素都添加到列表中。（类似于合并）

举例：list1 = [10,20,30]

list1.extend([100,200])

print(list1)                               输出结果：[10,20,30,100,200]

 

列表.index(元素)                     获取元素在列表中对应的下标(返回是0开始的那个下标)  如果元素不存在会报错，如果元素有多个，只返回最前面那个元素的下标。

#list.index()

>>> list=[1,2,3,4,5]

>>> print("2的索引为:",list.index(2))

#输出结果为

2的索引为: 1

 

列表.reverse()                           列表倒序

 

列表.sort()                                将列表元素从小到大排序，产生一个新列表

#list.sort()

>>> list=[5,4,3,2,1]

>>> list.sort()

>>> print("排序后的列表为:",list)

>>> list1=['e','d','B','C']

>>> list1.sort()

>>> print("排序后的列表为:",list1)

#输出结果为

排序后的列表为: [1, 2, 3, 4, 5]

排序后的列表为: ['B', 'C', 'd', 'e']

 

列表.sort(reverse=True)            将元素从大到小排序，产生一个新的列表。与函数sort（）同理。

list(seq)         将元组转换为列表

 

 

列表推导式

1、  列表推导式

（创建列表的表达式，主要用于对元素进行变换和筛选）

 

①    结构 1 ：[表达式 for 变量 in 序列]

原理：创建一个列表（ 让变量去序列中取值，一个一个的取，取一个值就计算一次表达式的结果并且将计算结果作为列表的元素 ）

作用：将原序列中的元素按照指定规则( 表达式 )进行统一变换得到一个列表

 

②    结构 2 ：[表达式 for 变量 in 序列 if 条件语句]

原理：让变量去序列中取值，一个一个的取，取一个值就判断一次条件语句是否成立，如果成立才计算表达式的结果，并且将结果作为列表的元素

举例：

        nums = [28,10,81,301,22]     

                    

print([x*2 for x in nums])                                                     （将nums中所有元素乘二 ）

print([x%10 for x in nums])                                                   （基于nums得到[8,0,1,1,2] ）

print([x%10+x//10%10+x//100 for x in nums])                      （基于nums得到[10,1,9,4,4] ）

print([x%2==0 for x in nums])                                              （基于nums得到[T,T,F,F,T] ）

print([x for x in nums if x % 2])                                             （基于nums得到[81,301] ）

 

元组

1认识元组

①     是容器；将()作为容器的标志里面多个元素用逗号隔开：(元素1,元素2,元素3)

 

当要创建的元组中只包含一个元素时，必须带逗号。如果不带逗号会将左右括号默认视为运算符。

举例：

t1 = ()                                     （空元组 ；无意义）

 

t2 = (20,)                                （单个元素的元组 ；必须在唯一的元素后加逗号）

      

②     不可变的（不支持增删改）

 

③     有序的

 

2元组就是不可变的列表

列表中和增删改无关的操作，元组都支持（合并和删除，以及一些不改变元组的函数）

合并两个元组，可以使用 + 将两个元组合并：

tuple10 = (1,2,3)

tuple11 = (4,5,6)

tuple12 = tuple10 + tuple11

print(tuple12)     #(1, 2, 3, 4, 5, 6)

删除元组，由于元组是不可变的，所有不能删除其中的元素，但可以使用 del 将整个元组删除

tuple9 = (1,2,3)

del tuple9

print(tuple9)  #这将会报错，因为tuple9这个元组已经被删除了

可以通过元组与列表的相互转化来改变元组

list转换为tuple:

list1=[1,2,3]

tuple=tuple(list1)

tuple转换为list：

list(tuple)   

 

3相关函数：sum、max、min、len、sorted、list、tuple

sum(元组)                                求元组中所有元素的和（元组必须是数字元组）

len(tuple)           元组元素个数

max(tuple)        返回元组元素最大值

min(tuple)         返回元组元素最小值

sorted(元组)                             将元组中的元从小到大排序，产生一个新的元组

sorted(元组,reverse=True)         将元组中的元从大到小排序,产生一个新的元组

list（元组）        list转换为tuple:

tuple（列表）                          tuple转换为list

4部分相关方法：count、index

count、index与列表部分同理

5元素不只是不可变的列表

 

①        单个元素的元组：(元素,)

 

②        在没有歧义的情况下，元组的（）可以省略。

 

③            获取元素的时候，可以让变量的个数和元组中元素的个数一致

 

 

举例：

names=(康纳,和泉纱雾 利露姆,古手川千纱,enn瞳d瞳me)

x,*y = names

print(x,y)                                输出结果：康纳 ['和泉纱雾', '利露姆', '古手川千纱', ' enn瞳d瞳me ']

 

*z,k = names

print(z,k)                                输出结果：['康娜', '和泉纱雾', '利露姆', '古手川千纱'] enn瞳d瞳me

标签：10,1145141919,元素,list,元组,print,列表
来源： https://www.cnblogs.com/saltrain/p/16696146.html