python之列表和元组

1、 定义序列：使用一对中括号将序列中的元素值括起来。

names = [“bill”,”30”,”12.5”,”True”]

names = ["Bill","Mike"]
numbers =[1,2,3,4,5,6]
salary=[3000.0,4000.0,5000.0]
flags=[True,False,True,True]
values=[names,numbers,salary,flags,[‘a‘,‘b‘]]
for value in values:
    print(value)

value序列共有五个元素值，每一个元素值都是一个序列，而且这些序列的元素个数都不相同。

2、序列的基本操作

序列支持很多特定的操作，这些操作所有类型的序列都可以使用。如通过索引引用序列元素（indexing)、分片（slicing）、加（adding）、乘（multiplying）以及检查某个元素是否属于序列的成员，除此之外，Python语言还可以计算序列的长度，找出最大的元素和最小的元素，以及对序列的迭代。

2.1通过索引操作序列元素

序列总所有元素都是有编号的，编号从0开始递增。序列中的所有元素都可以通过编号访问，这个编号被称为索引。访问并输出序列names中的第1个和第3个元素。

names = ["Bill","Mike","Jack"]
print(names[0])
print(names[2])

s="Hello World"
print("Apple"[2])
print(s[0])
print(s[3])

在上面代码中，通过索引2获取了字符串Apple的第三个字符。

通过input输入的字符串也可以通过索引引用其中的某个字符。

输入一个年份，如果只对年份的最后一个字符感兴趣，获取使用索截取年份的最后一位数字。

fourth= input(‘请输入年份：‘)[3]
print(fourth

如果索引是0或正整数，那么Python语言会从序列左侧第一个元素开始取值；如果索引是负数，那么会从序列右侧第一个元素开始取值。序列最后一个元素的索引是-1，倒数第2个元素索引是-2，以此类推。

例题1

months = [
    ‘一月‘,
    ‘二月‘,
    ‘三月‘,
    ‘四月‘,
    ‘五月‘,
    ‘六月‘,
    ‘七月‘,
    ‘八月‘,
    ‘九月‘,
    ‘十月‘,
    ‘十一月‘,
    ‘十二月‘
]
year = input("年：")
month =input(‘月（1-12）：‘)
day = input(‘日（1-31）：‘)
monthNumber =int(month)#将字符串形式的月转换为数值形式的月
monthName = months[monthNumber - 1]#从序列中获取中文的月份
print(year + "年 " + monthName +" " + day + "日")#按指定格式输入年月日

3、分片

分片操作是从序列A中获取一个子序列B。序列A可以称为父序列。从A中获取B，需要指定B在A中的开始索引和结束索引，因此，分片操作需要指定两个索引。

通过分片操作获取一个URL的一级域名和完整的域名。

url =‘https://geekori.com‘
print(url[8:15])
print(url[8:19])

在指定子序列结束索引时，要指定子序列最后一个元素的下一个元素的索引。

通过将结束索引设为0，获取一个空序列。[-3:0]-----------[].如果要使用负数作为索引，并且获取的子序列的最后一个元素与父序列的最后一个元素相同，那么可以省略结束索引，或结束索引引用整数。

numbers =[1,2,3,4,5,6,7,8]
print(numbers[-3:0])
print(numbers[-3:])
print(numbers[-3:8])print(numbers[:3])print(numbers[:])

[1，2，3]

[1,2,3,4,5,6,7,8]

设置步长

在对序列分片时，默认步长是1，也就是说，获取子序列的元素都是相邻的。如果要获取不相邻的元素，就需要指定步长。

numbers =[1,2,3,4,5,6,7,8,9]
print(numbers[:7:2])
print(numbers[::2])
print(numbers[3::2])
print(numbers[8:2:-2])
print(numbers[8:2:-1])
#print(numbers[1:6:0])抛出异常，步长不能为0，但可以是负数，如果步长是负数，分片会从序列的右侧开始，这时开始索引要大于结束索引
print(numbers[:3:-2])#从序列最后一个元素开始，步长为-2，一直到索引为4的元素结束

str=input("请输入一个整数")
n=int(str);
numbers = range(1,n)#产生包含1到n的数值类型的序列
numbers1=numbers[0::2]#分片获取序列中的奇数
numbers2=numbers[1::2]#分片获取序列中的偶数
for number in numbers1:  #在第一行输出所有奇数
    print(number,end=" ")
print("")
print(" ",end="")
for number in numbers2:  #在第二行错位输出所有偶数
    print(number,end=" ")

4、序列相加

对应序列首位相接，由于字符串属于字符序列，所以字符串相加也可以看作序列相加。但一个字符串不能和一个序列相加，否则会抛出异常。

print([1,2,3]+[6,7,8])
print("Hello"+"world")
print([1,2,3]+["hello"])#把字符串作为序列的一个元素
print([1,2,3] +[‘h‘,‘e‘,‘l‘,‘l‘,‘o‘])
print([1,2,3] +"hello")#抛出异常

5、序列的乘法

#本例通过字符串与数字相乘，复制字符串；通过将序列与数字相乘，复制序列
print(‘hello‘*5)
print([20]*10)
print([None]*6)

spaceNum=5#表示*号每一侧最多的的空格数，本例是5
i =1
lineSpaceNum=spaceNum#表示当前行的前后空格数
triangle=[]#二维列表
#开始生成三角形
while lineSpaceNum>=0:
    #生成星号左侧空格序列
    leftSpaceList=[‘ ‘]*lineSpaceNum
    #生成星号列表
    starList=[‘*‘]*(2*i-1)
    # 生成星号右侧空格序列
    rightSpaceList = [‘ ‘] * lineSpaceNum
    #生成每一行的序列
    lineList=leftSpaceList +starList +rightSpaceList
    triangle.append(lineList)
    lineSpaceNum-=1
    i+=1
for line in triangle:
    print(line)

检查某一个值是否属于一个序列，可以使用in运算符（布尔运算符，也就是说，如果某个值属于一个序列，那么in运算符返回True,否则返回False）

例子：判断一个字符串是否属于另一个字符串，以及一个值是否属于一个序列

str ="I love you"
print("you" in str)
print("hello" in str)
names=["Bill","Mike","John"]
print("Mike" in names)
print("Mary" in names)

例题;

account= [                        #保存了多条用户记录的序列
    ["geekori","123456"],
    ["bill","54321"],
    ["superman","65432"],
    ["androidguy","6543"],
    ["mike435","65abcd"]
]
username=input("用户名：")
password = input("密码：")
#用in运算符判断一个序列是否属于account
if[username,password] in account:
    print("登陆成功")
else:
    print("登陆失败")

6、序列的长度、最大值和最小值

values=[10,40,5,76,33,2,-12]
print(len(values))
print(max(values))
print(min(values))
print(max(4,3,2,5))
print(min(6,5,4))
print(max("abc",5,4))#字符串和数字不能比较，将抛出异常
list=["x",5,4]
print(min(list))#字符串和数字不能比较，将抛出异常

7、列表的基本操作

列表可以使用所有适用于序列的标准操作，例如索引、分片、连接和乘法。但列表还有一些属于自己的操作，如修改列表本事的操作，这些操作包括元素赋值、删除、分片赋值以及下一节要讲的列表方法。

7.1列表元素的赋值

如果要修改列表中的某一个元素，可以像使用数组一样对列表中的特定元素赋值，也就是使用一对中括号指定元素在列表中的索引，然后使用赋值运算符（=）进行赋值

s=["Bill","Mike","John"]
s[0]="Mary"
s[1]=20
print(s)#输出[‘Mary‘, 20, ‘John‘]

7.2删除列表元素

numbers=[1,2,3,4,5,6,7,8]

del numbers[2]

7.3分片赋值

分片赋值和分片获取子列表一样，也需要使用分片操作，也就是需要指定要操作的列表的范围。

s=["hello","world","yeah"]
s[1:]=["a","b","c"]#将列表元素从第二个元素开始替换成一个新的列表
print(s)
name=list("Mike")#使用list函数将“Mike”转换成由字符组成的列表
print(name)
name[1:]=list("ary")#利用分片赋值操作将“Mike”替换成了Mary
print(name)

s=["hello","world","yeah"]
s[1:]=["a","b","c"]#将列表元素从第二个元素开始替换成一个新的列表
print(s)
name=list("Mike")#使用list函数将“Mike”转换成由字符组成的列表
print(name)
name[1:]=list("ary")#利用分片赋值操作将“Mike”替换成了Mary
print(name)

numbers =[1,6,7]
numbers[1:1]=[2,3,4,5] #(:)前面的数字表示要替换的子列表的第一个元素在父列表中的索引，而冒号后面的数字表示子列表下一个元素在父列表中的索引，所以冒号前后两个数字相等，表示不替换列表中任何元素
print(numbers)
numbers[1:4]=[]#使用分片赋值将第2、3、4个元素值替换成了空列表。
print(numbers)

7.4列表方法

方法：其实方法和函数非常类似，只是函数是全局的，而方法需要定义在类中，需要通过对象引用。

#使用sort方法排序，会直接修改原列表，如果要想对列表的副本进行排序，可以使用下面两种方法    #方法1：使用分片进行操作    x = [5,4,1,8,6]    y=x[:]    y.sort();    print(x)    print(y)    #方法2：使用sorted函数    x=[7,6,4,8,5]    y=sorted(x)    print(x)    print(y)

print("-----测试append方法-------")#在列表最后插入新的值
numbers =[1,2,3,4]
numbers.append(5)
print(numbers)
numbers.append([6,7])#将列表[6,7]作为一个值添加到numbers列表后面
print(numbers)
print("-----测试clear方法-------")#用于清除列表内容
names=["Mike","Mary","Jack"]
print(names)
names.clear();
print(names)
print("-----测试copy方法-------")#用于复制一个列表
a=[1,2,3]
b=a
b[1]=30
print(a)
aa=[1,2,3]
bb=aa.copy()#bb是aa的副本
bb[1]=30#修改bb中的元素值，aa中的元素值不会有任何变化
print(aa)
print("-----测试count方法-------")#用于统计某个元素在列表中出现的次数
search=["he","new","he","he","world","peter",[1,2,3],"ok",[1,2,3]]
print(search.count("he"))
print(search.count([1,2,3]))
print("-----测试extend方法-------")#
a=[1,2,3]
b=[4,5,6]
a.extend(b)#将b列表接在a列表的后面，extend方法并不返回值
print(a)
print("-----测试index方法-------")
s=["I","love","python"];
print(s.index("python"))#查询索引位置，如查询的不在会抛出异常
print("-----测试insert方法-------")
numbers=[1,2,3,4,5]
numbers.insert(3,"four")
print(numbers)
print("-----测试pop方法-------")
numbers=[1,2,3]
#pop方法返回删除的元素值
print(numbers.pop())#删除numbers列表中的最后一个元素值
print(numbers.pop(0))#删除numbers列表中第一个元素值
print(numbers)
print("-----测试remove方法-------")
words=["he","new","he","yes","bike"]
words.remove("he")
print(words)
print("-----测试reverse方法-------")
numbers=[1,2,3,4,5,6]
numbers.reverse()
print(numbers)
print("-----测试sort方法-------")
numbers=[5,4,1,7,4,2]
numbers.sort()#默认元素值按升序排序
print(numbers)

#sorted可以对任何序列进行排序
print(sorted("geekori"))

x=[5,4,1,7,5]
x.sort(reversed=True)
print(x)

E:\anaconda3\python.exe F:/pycharmtext/src/列表方法.py
-----测试append方法-------
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, [6, 7]]
Traceback (most recent call last):
-----测试clear方法-------
[‘Mike‘, ‘Mary‘, ‘Jack‘]
[]
-----测试copy方法-------
  File "F:/pycharmtext/src/列表方法.py", line 60, in <module>
[1, 30, 3]
[1, 2, 3]
    x.sort(reversed=True)
-----测试count方法-------
TypeError: ‘reversed‘ is an invalid keyword argument for sort()
3
2
-----测试extend方法-------
[1, 2, 3, 4, 5, 6]
-----测试index方法-------
2
-----测试insert方法-------
[1, 2, 3, ‘four‘, 4, 5]
-----测试pop方法-------
3
1
[2]
-----测试remove方法-------
[‘new‘, ‘he‘, ‘yes‘, ‘bike‘]
-----测试reverse方法-------
[6, 5, 4, 3, 2, 1]
-----测试sort方法-------
[1, 2, 4, 4, 5, 7]
[‘e‘, ‘e‘, ‘g‘, ‘i‘, ‘k‘, ‘o‘, ‘r‘]

Process finished with exit code 1

E:\anaconda3\python.exe F:/pycharmtext/src/列表方法.py
-----测试append方法-------
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, [6, 7]]
Traceback (most recent call last):
-----测试clear方法-------
[‘Mike‘, ‘Mary‘, ‘Jack‘]
[]
-----测试copy方法-------
  File "F:/pycharmtext/src/列表方法.py", line 60, in <module>
[1, 30, 3]
[1, 2, 3]
    x.sort(reversed=True)
-----测试count方法-------
TypeError: ‘reversed‘ is an invalid keyword argument for sort()
3
2
-----测试extend方法-------
[1, 2, 3, 4, 5, 6]
-----测试index方法-------
2
-----测试insert方法-------
[1, 2, 3, ‘four‘, 4, 5]
-----测试pop方法-------
3
1
[2]
-----测试remove方法-------
[‘new‘, ‘he‘, ‘yes‘, ‘bike‘]
-----测试reverse方法-------
[6, 5, 4, 3, 2, 1]
-----测试sort方法-------
[1, 2, 4, 4, 5, 7]
[‘e‘, ‘e‘, ‘g‘, ‘i‘, ‘k‘, ‘o‘, ‘r‘]

Process finished with exit code 1

8元组

元组与列表一样，也是一种序列。唯一不同的是元组不能修改，也就是说，元组是只读的。定义元组非常简单，只需要用逗号（,）分隔一些值即可。

numbers=1,2,3   #创建元组
print(numbers)
names=("Bill","Mike","Jack")
print(names)
values=40, #创建一个值的元组
print(values)
#生成5个同样值的元组
print(5*(12 + 4,))
#不是元组是一个数
print(5*(12+4))
#将一个序列转换位元组（tuple函数）
print(tuple([1,2,3]))
print(tuple("geekori"))

E:\anaconda3\python.exe F:/pycharmtext/src/元组.py
(1, 2, 3)
(‘Bill‘, ‘Mike‘, ‘Jack‘)
(40,)
(16, 16, 16, 16, 16)
80
(1, 2, 3)
(‘g‘, ‘e‘, ‘e‘, ‘k‘, ‘o‘, ‘r‘, ‘i‘)

Process finished with exit code 0

有两个重要原因必须要使用元组。

（1）元组可以在映射中作为键值使用，而列表不能这么用。

（2）很多内建函数和方法的返回值就是元组，也就是说，如果要使用这些内建的函数和方法的返回值，就必须使用元组。

原文地址：https://www.cnblogs.com/lcy1995/p/11619542.html