python 列表与元组

1、序列

1.1 什么是序列

　　数据的存储方式

　　　　java 或 c 语言中的序列指：数组

　　　　python 中的序列指：列表、元组、字典、集合和字符串

1.2 序列定义

　　序列是一块用于存放多个值的连续内存空间，并且按照一定顺序排列，可以通过索引取值。

（1）索引

　　索引从0开始计数，也可以为负数

 

 

# 实例：
# -*- coding:utf-8 -*-
# version：python3.7

string = "原来没有那么多应该"
print(string[1])    #获取从左到右第二个数
print(string[-2])   #获取从右向左第二个数

执行结果：
来
应

（2）切片(分片)：通过索引区间访问线性结构的一段数据

语法：sname[start : stop : step]
    sname：序列名
    start：起始值(包括)
    stop：结束值(不包括)
    step：步长

#注意：
step为步长，可以正、负整数，默认是1，step要和start:stop同向，否则返回空序列）
支持负索引
start为0，可以省略；stop为末尾，可以省略
超过上界(右边界)，就取到末尾；超过下界(左边界)，取到开头
start一定要在stop的左边
[:]表示从头至尾，全部元素被取出，等效于copy()方法（浅copy）

# 实例：
# -*- coding:utf-8 -*-
# version：python3.7

course = ["python","english","化学","汉语","操作系统","体育","口语","java","前端","后端"]    #定义列表
print(course[1:5])      #获取第二个到第五个元素
print(course[0:5:2])    #获取第1个、第三、第五个元素
print(course[5])        #获取索引值为5的元素
print(course[:5])       #获取从第一个值开始到索引值为4的元素
print(course[:])        #复制整个列表
print(course[5:])       #获取索引值为5到最后的元素

执行结果：
['english', '化学', '汉语', '操作系统']
['python', '化学', '操作系统']
体育
['python', 'english', '化学', '汉语', '操作系统']
['python', 'english', '化学', '汉语', '操作系统', '体育', '口语', 'java', '前端', '后端']
['体育', '口语', 'java', '前端', '后端']

　　切片赋值

　　　　切片操作写在等号左边，被插入值可迭代对象写在等号右边

# -*- coding:utf-8 -*-
# version：python3.7

l1 = [1,2,3]
l1[2:] = (9,)
print(l1)

执行结果：
[1, 2, 9]

（3）序列相加

　　只能是同类型的序列相加：列表+列表，元祖+元祖，字符串+字符串

# 实例：
# -*- coding:utf-8 -*-
# version：python3.7

course1 = ["python","english","化学","汉语","操作系统"]     #定义列表1
course2 = ["python","english","体育","java","linux"]      #定义列表2
course = course1 + course2    #将两个列表合二为一
print(course)

执行结果：
['python', 'english', '化学', '汉语', '操作系统', 'python', 'english', '体育', 'java', 'linux']

（4）乘法

　　功能：输出n个重复的序列；初始化长度列表

 

# 实例：
# -*- coding:utf-8 -*-
# version：python3.7

phone = ["HuaWei","Vivo"]
print(phone*3)          #重要的事情说三遍
number = [1,2,3]
print(number*3)
emptylist = [None]*5    #初始化一个包含5个元素的列表
print(emptylist)
print("*"*10)

执行结果：
['HuaWei', 'Vivo', 'HuaWei', 'Vivo', 'HuaWei', 'Vivo']
[1, 2, 3, 1, 2, 3, 1, 2, 3]
[None, None, None, None, None]
**********

（5）检查某个元素是否是序列的成员

　　语法：value in sequence

　　　　value:要检查的元素，sequence:序列

# 实例：
# -*- coding:utf-8 -*-
# version：python3.7

phone = ["HuaWei","Vivo","SanXing","iphone","XiaoMi"]
print("HuaWei" in phone)      #结果为True，表明HuaWei在该列表中
print("ChuiZi" in phone)      #结果为False，表明ChuiZi不在该列表中
print("ChuiZi" not in phone)  #判断ChuiZi不在该列表中，结果应为True

执行结果：
True
False
True

（6）计算序列的长度、最大值和最小值

　　计算序列长度：即统计序列中元素的个数，使用 len() 函数

# 实例：
# -*- coding:utf-8 -*-
# version：python3.7

number = [1,12,6554,224,11,90,4]
print("列表的长度：",len(number))
string = "你好我好大家好"
print("字符串的长度：",len(string))

执行结果：
列表的长度： 7
字符串的长度： 7

　　返回序列中的最大元素和最小元素：max() 函数、min() 函数

# 实例：
# -*- coding:utf-8 -*-
# version：python3.7

number = [1,12,6554,224,11,90,4]
print("number列表的最大值为：",max(number))
print("number列表的最小值为：",min(number))

执行结果：
number列表的最大值为： 6554
number列表的最小值为： 1

　　python提供的其他内置函数

list()函数：把序列转换为列表
str()函数：把序列转换为字符串
sum()函数：计算列表中元素和
sorted()函数：对元素进行排序
reversed()函数：反转序列中元素
enumerate()函数：把序列组合成为一个索引序列

　　注意：索引、切片、序列相加和乘法对于字典和集合不支持

 2、列表 list

　　一个队列，一个排列整齐的队伍，列表内的个体成为元素，由若干元素组成列表，元素可以是任意对象，如下：

　　列表内元素有顺序，可以使用索引，列表是一种线性的数据结构，使用 [ ] 表示，列表是可变的。

　　列表的优点：检索数据速度快；缺点：进行数据的增删，对列表影响很大，使性能下降

　　链表的优点：适用于频繁进行增删；缺点：检索速度慢

　　队列 queue：先进先出或后进先出，操作于队首和队尾

　　栈 stack：先进后出

 2.1 列表的创建和删除

（1）适用赋值运算符直接创建列表

　　语法：listname = [元素1,元素2,元素3,...,元素n]

# 实例：
# -*- coding:utf-8 -*-
# version：python3.7

number = [1,3,5,7,9]
verse = ["春眠不觉晓","python不得了"]
python = ['优雅',"明确",'''简单''']
untitle = ["python",666,["爬虫","web"]]

（2）创建空列表

emptylist = []    #创建空列表

（3）创建数值列表

# 实例：
# -*- coding:utf-8 -*-
# version：python3.7

list = list(range(2,21,2))    #从2开始，到20结束，每次+2
print(list)

执行结果：
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

（4）删除列表：

# 实例：
# -*- coding:utf-8 -*-
# version：python3.7

python = ["优雅","明确","简单"]
print(python)
del python
print(python)

执行结果：
['优雅', '明确', '简单']
NameError: name 'python' is not defined

　　注：python 自带垃圾回收机制会自动销毁不用的列表，所以即使我们不手动将其删除，python 也会自动将其回收。

 2.2 访问列表元素

（1）直接使用 print() 函数输出

（2）通过索引获取指定位置的元素

（3）通过切片获取元素

# 实例1：
# -*- coding:utf-8 -*-
# version：python3.7

python = ["python",666,"人生苦短，我用python",["爬虫","自动化运维"]]
print(python)       #直接使用print()函数输出
print(python[2])    #通过索引获取指定位置的元素
print(python[1:3])  #通过切片获取索引值为1到2的元素

执行结果：
['python', 666, '人生苦短，我用python', ['爬虫', '自动化运维']]
人生苦短，我用python
[666, '人生苦短，我用python']

# 实例2：
# -*- coding:utf-8 -*-
# version：python3.7

'''
   @ file  ：tips
   @ author：zhangyangyang
   @ create：2020/3/8
   @ remark：
'''

import datetime    #导入日期时间类
mot = ["今天星期一：\n",
       "今天星期二：\n",
       "今天星期三：\n",
       "今天星期四：\n",
       "今天星期五：\n",
       "今天星期六：\n",
       "今天星期天："]
day = datetime.datetime.now().weekday()    #获取当前星期，之所以可以直接把星期作为索引值是因为：weekday函数获取的是0-6的数值，所以可以直接当做索引值获取元素
print(mot[day])    #输出今日星期

执行结果：
今天星期天：

　　列表索引：效率最高，时间复杂度=O(1)

　　索引，也叫下标：

　　　　正索引：从左至右，从0开始，为列表中每一个元素编号

　　　　负索引：从右至左，从-1开始

　　　　正负索引不可以超界，否则引发异常 IndexError

　　　　为了理解方便，可以认为列表是从左至右排列的，左边是头部，右边是尾部，左边是下界，右边是上界

　　列表通过索引访问
　　　　list[index] ，index就是索引，使用中括号访问

# -*- coding:utf-8 -*-
# version：python3.7

lit = [1,2,3,4]
print(lit[0])
print(lit[3])
print(lit[-2])

执行结果：
1
4
3

 2.3 遍历列表

把列表当中的所有元素都访问一遍，效率随列表元素增多而降低，时间复杂度=O(n)

（1）直接使用 for 循环实现

　　语法：for item in listname:

　　　　item：获取到的元素值

（2）使用 for 循环和 enumerate() 函数实现

　　语法：for item in enumerate(listname):

　　　　enumerate()函数：把一个可循环的序列对象(主要指列表)组合成为一个索引序列

　　　　通过item输出元素内容，通过index输出元素索引

# 实例1：
# -*- coding:utf-8 -*-
# version：python3.7

print("成绩排名：")
grade = ["第一名","第二名","第三名"]    #定义一个列表
#直接使用for循环实现遍历元素列表
for item in grade:
    print(item)    #输出成绩排名

#使用for循环和enumerate()函数实现
for index,item in enumerate(grade):
    print(index+1,item)    #输出索引值和排名

执行结果：
成绩排名：
第一名
第二名
第三名
1 第一名
2 第二名
3 第三名

# 实例2：
# -*- coding:utf-8 -*-
# version：python3.7

print("2019~2020年成绩排名：\n")
grade = ["第一名：张三","第二名：李四","第三名：王五","第四名：赵六"]
for index,item in enumerate(grade):
    if index % 2 == 0:    #分两列输出，判断是否能被2整除
        print(item+"\t\t",end='')
    else:
        print(item+"\n")

执行结果：
第一名：张三        第二名：李四

第三名：王五        第四名：赵六

2.4 列表查询

（1）index(value,[start,[stop]])

　　通过值value，从指定区间查找列表内的元素是否匹配

　　匹配第一个就立即返回索引，匹配不到，抛出异常ValueError

# -*- coding:utf-8 -*-
# version：python3.7

lit = [1,2,3,4]
print(lit.index(4))

执行结果：
3    #返回索引

（2）count(value)

　　返回列表中匹配value的次数

# -*- coding:utf-8 -*-
# version：python3.7

lit = [1,2,2,1,2,3]
print(lit.count(1))

执行结果：
2

（3）时间复杂度

　　index和count方法都是O(n)

　　随着列表数据规模的增大，而效率下降

（4）如何返回列表元素的个数?如何遍历?如何设计高效?

　　len()

# -*- coding:utf-8 -*-
# version：python3.7

lit = [1,2,2,1,2,3]
print(len(lit))    #len是内建函数。list有长度属性，加元素+1，减元素-1，所以len()的时间复杂度为O(1)

执行结果：
6

2.5 添加、修改和删除列表元素

（1）使用 append() 方法添加元素和提供 insert() 方法向列表指定位置插入元素

　　1> append(object) → None

　　　　列表尾部追加元素，返回None

　　　　返回None就意味着没有新的列表产生，就地修改

　　　　时间复杂度是O(1)

　　2> insert(index,object) → None

　　　　在指定的索引index处插入元素object

　　　　返回None就意味着没有新的列表产生，就地修改

　　　　时间复杂度是O(n)

　　　　索引能超上下界吗?

       　　　　超越上界，尾部追加

       　　　　超越下界，头部追加

# 实例：
# -*- coding:utf-8 -*-
# version：python3.7

phone = ["三星","诺基亚","华为"]    #定义一个列表
print(len(phone))         #输出列表长度
print(phone)              #打印列表元素
phone.append("iphone")    #使用append()方法添加元素
print(len(phone))
print(phone)
phone.insert(0,"vivo")    #使用insert()方法向列表指定位置插入元素
print(len(phone))
print(phone)

执行结果：
3
['三星', '诺基亚', '华为']
4
['三星', '诺基亚', '华为', 'iphone']
5
['vivo', '三星', '诺基亚', '华为', 'iphone']

（2）使用extend()方法：把一个列表的全部元素添加至另一个列表

　　语法：listname.extend(new_list)

　　extend(iteratable) → None

　　　　将可迭代对象的元素追加进来，就地修改

# 实例：
# -*- coding:utf-8 -*-
# version：python3.7

oldclass = ["乔丹","张三","李四"]
newclass = ["希尔","王龙"]
oldclass.extend(newclass)    #向原有列表添加列表
print(oldclass)
print(newclass)

执行结果：
['乔丹', '张三', '李四', '希尔', '王龙']
['希尔', '王龙']

# -*- coding:utf-8 -*-
# version：python3.7

lit = [1,2,3]
lit.extend(range(4,7))
print(lit)

执行结果：
[1, 2, 3, 4, 5, 6]

（3）修改元素：通过索引获取到元素，重新赋值，时间复杂度=O(1)

# 实例：
# -*- coding:utf-8 -*-
# version：python3.7

list1 = ["语文","数学","英语"]
list1[2] = "化学"    #修改元素
print(list1)

执行结果：
['语文', '数学', '化学']

（4）删除元素：根据索引删除：del 语句；根据元素值删除：remove() 方法

　　1> remove(value) → None

　　　　从左至右查找第一个匹配 value 的值， 移除该元素，就地修改

　　　　效率极差：找到元素，如果该数据在中间，后面的数据还要移动，时间复杂度=O(n)

　　2> del() 根据索引删除 → None

　　　　根据索引找到元素， 删除该元素，就地修改

　　　　通过索引寻找元素效率高效，但是找到元素，如果该数据在中间，后面的数据还要向前移动，时间复杂度=O(n)

　　3> pop([index]) → item

　　　　不指定索引 index，就从列表尾部弹出一个元素

　　　　指定索引 index，就从索引处弹出一个元素，索引超界抛出 IndexError 错误

　　　　效率?指定索引弹出元素，如果在中间，后面的元素也要移动，低效；不指定索引从列表尾部弹出一个元素，高效

　　4> clear() → None

　　　　清除列表所有元素，剩下一个空列表，引用计数-1

# 实例：
# -*- coding:utf-8 -*-
# version：python3.7

number = [1,2,3,4,5]
print("原始列表：",number)
del number[4]    #根据索引删除
print("删除索引为4的元素：",number)
del number[-1]   #根据索引删除
print("删除最后一个元素：",number)
number.remove(1) #根据根据元素值删除
print("删除列表中为1的元素：",number)
if 1 in number:  #建议删除之前先判断在不在，否则删除不在的会报错
    number.remove(1)

执行结果：
原始列表： [1, 2, 3, 4, 5]
删除索引为4的元素： [1, 2, 3, 4]
删除最后一个元素： [1, 2, 3]
删除列表中为1的元素： [2, 3]

# -*- coding:utf-8 -*-
# version：python3.7

lit = [1,2,3,4,5]
lit.pop(0)    #弹出第一个元素，后面的元素都要移动
print(lit)
lit.pop()     #不指定索引弹出最后一个元素，推荐使用，高效
print(lit)

执行结果：
[2, 3, 4, 5]
[2, 3, 4]

2.6 对列表进行统计运算

python 提供以下三种内置函数，常用于列表统计计算：

　　count() 函数：获取指定元素出现的次数，时间复杂度=O(n)

　　　　语法：listname.count(obj)

　　index() 函数：获取指定元素首次出现的下标，时间复杂度=O(n)

　　　　语法：listname.index(obj)

# 实例：
# -*- coding:utf-8 -*-
# version：python3.7

name = ["赵","钱","孙","李","周","吴","郑","李","王","赵"]
number = name.count("赵")    #获取指定元素出现的次数
print("姓名赵，出现的次数为：",number)
if "李" in name:
    position = name.index("李")    #获取指定元素首次出现的下标
    print("姓名李，首次出现的下标为：",position)

执行结果：
姓名赵，出现的次数为： 2
姓名李，首次出现的下标为： 3

　　sum() 函数：统计数值列表中各元素的和，时间复杂度=O(n)

　　　　语法：sum(iterable[,start])

   　 　　　　start：将统计结果加上start所指定的数

# 实例：计算成绩平均分
# -*- coding:utf-8 -*-
# version：python3.7

grade = [77,56,82,88,46,99]
total = sum(grade)    #统计数值列表中各元素的和
print("总分数和为：",total)
number = len(grade)
print("总人数和为：",number)
average = total/number
print("平均成绩为：",average)

执行结果：
总分数和为： 448
总人数和为： 6
平均成绩为： 74.66666666666667

2.7 对列表进行排序

　　使用列表对象的 sort() 方法，使用 sort() 方法实现排序后，原列表中的元素顺序改变

　　　　语法：listname.sort(key=None,reverse=False)

　　　　key：指定一个从每个列表元素中提取一个比较键，例：key=str.lower    #排序中不区分大小写

　　　　reverse 指定按升序还是按降序排列，默认升序排列，指定 reverse=False 则降序排列

# 实例：对数值列表进行排列
# -*- coding:utf-8 -*-
# version：python3.7

grade = [77,56,82,88,46,99]    #保存成绩的列表
print("原列表：",grade)
grade.sort()    #使用列表对象的sort()方法，升序排列
print("升序排列：",grade)

执行结果：
原列表： [77, 56, 82, 88, 46, 99]
升序排列： [46, 56, 77, 82, 88, 99]

# 实例：对字符串排列
# -*- coding:utf-8 -*-
# version：python3.7

char = ["cat","Tom","Angela","pig"]
print("原列表：",char)
char.sort()    #对字符串进行升序排列
print("升序排列：",char)    #先大写排列，后小写排列
char.sort(key=str.lower)    #不区分大小写排列
print("不区分大小写排列：",char)

执行结果：
原列表： ['cat', 'Tom', 'Angela', 'pig']
升序排列： ['Angela', 'Tom', 'cat', 'pig']
不区分大小写排列： ['Angela', 'cat', 'pig', 'Tom']

　　使用内置的 sorted() 函数

　　　　使用 sorted() 函数实现排列后原列表的元素顺序不变

　　　　语法：sorted(iterable,key=None,reverse=False)

　　　　iterbale：迭代对象，表示要排列的列表名称

　　　　key：指定一个从每个列表元素中提取一个比较键，例：key=str.lower    #排序中不区分大小写

　　　　reverse指定按升序还是按降序排列，reverse=False表示按升序排列，不设置也是按升序排列，设置为True表示按降序排列

# 实例：
# -*- coding:utf-8 -*-
# version：python3.7

char = ["cat","Tom","Angela","pig"]
print("原列表：",char)
char1 = sorted(char)    #使用内置的sorted()函数，升序排列
print("升序排列：",char1)    #升序排列
char2 = sorted(char,reverse = True)    #降序排列
print("降序排列：",char2)
print("原列表：",char)

执行结果：
原列表： ['cat', 'Tom', 'Angela', 'pig']
升序排列： ['Angela', 'Tom', 'cat', 'pig']
降序排列： ['pig', 'cat', 'Tom', 'Angela']
原列表： ['cat', 'Tom', 'Angela', 'pig']

2.8 列表*重复的坑

　　* → list：重复操作，将本列表元素重复n次，返回新的列表

# -*- coding:utf-8 -*-
# version：python3.7

x = [[1,2,3]] * 3
print(x)
x[0][2] = 4
print(x)

执行结果：
[[1, 2, 3], [1, 2, 3], [1, 2, 3]]
[[1, 2, 4], [1, 2, 4], [1, 2, 4]]

2.9 列表推导式

　　可以快速生成一个列表

　　　　语法：list = [Ecpression for var in range]

# 实例
# -*- coding:utf-8 -*-
# version：python3.7

import random    #导入生成随机数的模块
#通过循环实现定义一个10个数(0-100)的列表
list1 = []       #定义一个空列表
for i in range(10):
    list1.append(random.randint(0,100))    #向列表中添加随机数
print("list1=",list1)

#改进，使用列表推导式
list2 = [random.randint(0,100) for i in range(10)]
print("list2=",list2)

#生成一个1-10之间所有偶数平方的列表
list3 = [i*i for i in range(2,11,2)]
print("list3=",list3)

执行结果：
list1= [93, 4, 59, 78, 94, 38, 38, 54, 72, 5]
list2= [72, 47, 11, 53, 82, 84, 46, 76, 67, 23]
list3= [4, 16, 36, 64, 100]

　　根据某个列表生成满足指定需求的列表

　　　　newlist = [Ecpression for var in list]

　　从列表中选择符合条件的元素组成新的列表

　　　　newlist = [Ecpression for var in list if condition]

# -*- coding:utf-8 -*-
# version：python3.7

price = [166,334,684,192,568]
asle1 = [int(x*0.5) for x in price]
print("原价格:",price)
print("5折价格:",asle1)
asle2 = [x for x in price if x>500]
print("大于500的价格:",asle2)

执行结果：
原价格: [166, 334, 684, 192, 568]
5折价格: [83, 167, 342, 96, 284]
大于500的价格: [684, 568]

2.10 二维列表的使用

# 实例：定义酒店房间的二维列表
# -*- coding:utf-8 -*-
# version：python3.7

room1 = [[101,102,103],
        [201,202,203],
        [301,302,303],
        [401,402,403]
]    #定义二维列表
print("room1:",room1)

#使用for循环定义二维列表
room2 = []
for i in range(1,5):     #定义楼层：4楼
    room2.append([])     #添加一个空列表
    for j in range(1,4): #循环每层房间数
        room2[i-1].append(i*100+j)    #为每层列表添加元素
print("room2:",room2)

#使用列表推导式定义二维列表
room3 = [[i*100+j for j in range(1,4)] for i in range(1,5)]
print("room3:",room3)

执行结果：
room1: [[101, 102, 103], [201, 202, 203], [301, 302, 303], [401, 402, 403]]
room2: [[101, 102, 103], [201, 202, 203], [301, 302, 303], [401, 402, 403]]
room3: [[101, 102, 103], [201, 202, 203], [301, 302, 303], [401, 402, 403]]

# 实例：输出横版和竖版的古诗
# -*- coding:utf-8 -*-
# version：python3.7

str1 = "千山鸟飞绝"
str2 = "万径人踪灭"
str3 = "孤舟蓑笠翁"
str4 = "独钓寒江雪"
list1 = [list(str1),list(str2),list(str3),list(str4)]
print("\n--横版--")
for i in range(4):        #循环古诗的行
    for j in range(5):    #循环每一行的字
        if j == 4:        #每一行最后一个字换行
            print(list1[i][j])    #换行输出
        else:
            print(list1[i][j],end='')    #不换行输出

list1.reverse()    #进行逆序排列(第一行变最后一行，最后一行变第一行)
print("\n--竖版--")
for i in range(5):    #循环每一个字
    for j in range(4):    #每一行
        if j == 3:        #每一行最后一个字换行
            print(list1[j][i])    #换行输出
        else:
            print(list1[j][i],end='')    #不换行输出

执行结果：
--横版--
千山鸟飞绝
万径人踪灭
孤舟蓑笠翁
独钓寒江雪

--竖版--
独孤万千
钓舟径山
寒蓑人鸟
江笠踪飞
雪翁灭绝

 3、元组 tuple

　　一个有序元素的集合，不可变

　　语法：(元素1,元素2,...)

　　　　tuple() → empty tuple

　　　　tuple(iterable) → tuple initialized from iterable's items

3.1 元组的创建和删除

　　使用赋值运算符直接创建元组

　　　　语法：tuplename = (元素1,元素2,元素3,...)

　　创建空元组

　　创建数值元组

# 实例：
# -*- coding:utf-8 -*-
# version：python3.7

#定义数值元组
tuple1 = tuple(range(2,11,2))    #定义10以内的偶数元组
print("tuple1=",tuple1)

#使用赋值运算符直接创建元组
number = (2,4,6,8,10)
print("number=",number)
string = ("周一","周二","周三","周四","周五")
print("string=",string)

#定义单个元组
name1 = ("张三")    #字符串而非单元组
print("name1=",name1,type(name1))
name2 = ("张三",)   #定义单个元组
print("name2=",name2)

#定义空元组
emptytuple = ()
print("emptytuple=",emptytuple)

执行结果：
tuple1= (2, 4, 6, 8, 10)
number= (2, 4, 6, 8, 10)
string= ('周一', '周二', '周三', '周四', '周五')
name1= 张三 <class 'str'>
name2= ('张三',)
emptytuple= ()

　　删除元组

　　　　语法：del tuplename

# 实例：
# -*- coding:utf-8 -*-
# version：python3.7

number = (1,2)
print(number)
del number
print(number)

执行结果：
(1, 2)
NameError: name 'number' is not defined

　　python 自带的垃圾回收机制会自动销毁不用的元组，自动回收

3.2 访问元组元素

　　方法：直接使用 print() 函数输出；通过索引输出；通过切片输出

　　正负索引不可以超界，否则引发异常 IndexError

# 实例：
# -*- coding:utf-8 -*-
# version：python3.7

name = ("赵","钱","孙","李")
print(name)      #直接使用print()函数输出
print(name[2])   #通过索引输出
print(name[1:3]) #通过切片输出

执行结果：
('赵', '钱', '孙', '李')
孙
('钱', '孙')

# 实例：通过for循环实现遍历元组
# -*- coding:utf-8 -*-
# version：python3.7

name = ("张三","李四","王五","孙六")
print("这是：")
for i in name:    #通过for循环遍历元组
    print(i)

print("\n这是：")
for index,item in enumerate(name):    #通过for循环和enumerate函数实现遍历
    if index%2 == 0:
        print(item + "\t\t",end='')
    else:
        print(item + "\n")

执行结果：
这是：
张三
李四
王五
孙六

这是：
张三        李四
王五        孙六

3.3 修改元组元素

# 实例：
# -*- coding:utf-8 -*-
# version：python3.7

class1 = ("明明","浩浩","三三","哈哈")
class1 = ("明明","浩浩","等等","哈哈")     #通过重新赋值对元组修改
print("class1=",class1)
class2 = ("巧巧","梅梅")
print("class2=",class2)
allclass = class1 + class2               #元组合并
print("allclass=",allclass)

执行结果：
class1= ('明明', '浩浩', '等等', '哈哈')
class2= ('巧巧', '梅梅')
allclass= ('明明', '浩浩', '等等', '哈哈', '巧巧', '梅梅')

 

3.4 元组查询

（1）index(value,[start,[stop]])

　　通过值 value，从指定区间查找列表内的元素是否匹配

　　　　匹配第一个就立即返回索引

　　　　匹配不到，抛出异常 ValueError

（2）count(value)

　　　　返回列表中匹配 value 的次数

（3）时间复杂度

　　index 和 count 方法都是 O(n)

　　随着列表数据规模的增大，而效率下降

（4）len(tuple)

　　　　返回元索的个数

3.5 元组推导式

　　作用：可以快速生成一个元组，或者根据某个元组生成满足指定需求的元组

　　元组推导式生成的是一个对象：生成器对象，可以使用tuple函数转换，也可以使用for循环遍历，还可以使用_next_()方法实现

# 实例：
# -*- coding:utf-8 -*-
# version：python3.7

# 方法一：
import random    #导入随机数模块
randomnumber = (random.randint(10,100) for i in range(10))
print(tuple(randomnumber))

# 方法二：
import random    #导入随机数模块
randomnumber = (random.randint(10,100) for i in range(10))
for i in randomnumber:    #for循环遍历出来的是数，不是元组
    print(i,end=' ')

# 方法三：
import random    #导入随机数模块
randomnumber = (random.randint(10,100) for i in range(10))
print(randomnumber.__next__())    #输出第一个元素
print(randomnumber.__next__())    #输出第二个元素
print(randomnumber.__next__())    #输出第三个元素
......
到第十个元素

3.6 命名元组

　　帮助文档中，查阅 namedtuple，有使用例程

　　namedtuple(typename, field_ names,verbose=False,rename=False)

　　　　命名元组，返回一个元组的子类，并定义了字段

　　　　field_names可以是空白符或逗号分割的字段的字符串，可以是字段的列表

　　from collections import namedtuple

# -*- coding:utf-8 -*-
# version：python3.7

from collections import namedtuple
Point = namedtuple('P',['x','y'])    #Ponit:标识符，P:名字，xy:属性
print(type(Point))    #type => type class类
P1 = Point(2,3)
P2 = Point(4,5)
print(P1)
print(P2)

执行结果：
<class 'type'>
P(x=2, y=3)
P(x=4, y=5)

# -*- coding:utf-8 -*-
# version：python3.7

from collections import namedtuple
Student = namedtuple('S','name,age')
tom = Student('tom',18)
jerry = Student('jerry',20)
print(tom)
print(jerry)

执行结果：
S(name='tom', age=18)
S(name='jerry', age=20)

4、元组与列表的区别

 

5、随机数

　　random模块：

　　randint(a, b)返回[a, b]之间的整数

　　choice(seq)从非空序列的元素中随机挑选一个元素， 比如random.choice(range(10)), 从0到9中随机挑选一个整数，random.choice([1,3,5,7])

　　randrange ([start,] stop [step])从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1，random.randrange(1,7,2)

　　random.shufle(list) → None就地打乱列表元素

　　sample(population, k)从样本空间或总体(序列或者集合类型)中随机取出k个不同的元素，返回一个新的列表

# -*- coding:utf-8 -*-
# version：python3.7

import random
print(random.randint(1,3))    #[1,3]随机打印1,2,3
print(random.randrange(1,2))  #[1,2)只打印1

lst = list(range(10,20))
print(random.choice(lst))     #随机打印列表中的一个数，也可以加上for循环遍历打印10个随机数

print(random.shuffle(lst))    #洗牌，就地修改，效率？

random.sample([1,1],2)        #随机取两个值，不重复取值，索引不同

 

6、排序实例

依次接收用户输入的3个数，排序后打印

（1）转换为 int，判断大小排序，使用分支结构

# -*- coding:utf-8 -*-
# version：python3.7

num = []
#while len(nums) == 3:
for i in range(3):
    num.append(int(input(">>>")))

order = None
if num[0] > num[1]:
    if num [0] > num[2]:
        if num[1] > num[2]:
            order = [2,1,0]
        else:
            order = [1,2,0]
    else:  #0>1,0<2
        order = [1,0,2]
else:  #0<1
    if num[0] < num[2]:
        if num[1] < num[2]:
            order = [0,1,2]
        else:
            order = [0,2,1]
    else:  #0<1,0>2
        order = [2,0,1]

for i in order:
    print(num[i])

执行结果：
>>>9
>>>6
>>>3
3
6
9

（2）使用 min 函数

# -*- coding:utf-8 -*-
# version：python3.7

num = []
for i in range(3):
    num.append(int(input(">>>")))
newlist = []

index = 3
while num:
    m = min(num)
    newlist.append(m)
    num.remove(m)
    #i = num.index(m)
    #num.pop(i)
    if index == 2:
        newlist.append(num[0])
        break
    index -= 1

print(newlist)

执行结果：
>>>4
>>>3
>>>2
[2, 3, 4]

（3）使用列表的 sort 方法

# -*- coding:utf-8 -*-
# version：python3.7

nums = [7,4,6]
nums.sort()    #就地修改、立即修改
print(nums)

执行结果：
[4, 6, 7]