python列表与元组
我听过 人气:11、序列定义：数据存储方式
java或c语言中的序列指：数组
python中的序列指：列表、元祖、字典、集合和字符串
2、序列：序列是一块用于存放多个值的连续内存空间，并且按照一定顺序排列，可以通过索引取值。
1>索引
索引从0开始计数，也可以为负数
# 实例： # -*- coding:utf-8 -*- # version：python3.7 string = "原来没有那么多应该" print(string[1]) #获取从左到右第二个数 print(string[-2]) #获取从右向左第二个数 执行结果： 来 应
2>切片(分片)：获取序列中元素的一种方法
语法：sname[start : end : stop]
sname：序列名，start：起始值(包括)，end：结束值(不包括)，stop：步长
# 实例： # -*- 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', '前端', '后端']
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()函数：把序列组合成为一个索引序列
注意：索引、切片、序列相加和乘法对于字典和集合不支持
3、列表 list：一个队列，一个排列整齐的队伍，列表内的个体成为元素，由若干元素组成列表，元素可以是任意对象，如下：
列表内元素有顺序，可以使用索引，列表是一种线性的数据结构，使用 [ ] 表示，列表是可变的。
列表的优点：检索数据速度快；缺点：进行数据的增删，对列表影响很大，使性能下降
链表的优点：适用于频繁进行增删；缺点：检索速度慢
队列 queue：先进先出或后进先出，操作于队首和队尾
栈 stack：先进后出
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]
删除列表：
# 实例： # -*- coding:utf-8 -*- # version：python3.7 python = ["优雅","明确","简单"] print(python) del python print(python) 执行结果： ['优雅', '明确', '简单'] NameError: name 'python' is not defined
python自带垃圾回收机制会自动销毁不用的列表，所以即使我们不手动将其删除，python也会自动将其回收。
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
3>遍历列表：把列表当中的所有元素都访问一遍，效率随列表元素增多而降低，时间复杂度=O(n)
(1)直接使用for循环实现
语法：for item in listname:
item：获取到的元素值
(2)使用for循环和enumerate()函数实现
语法：for item in enumerate(listname):enumerate()函数：
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")
执行结果：
第一名：张三 第二名：李四
第三名：王五 第四名：赵六
列表查询：
(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
4>添加、修改和删除列表元素
使用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']
使用extend()方法：把一个列表的全部元素添加至另一个列表
语法：listname.extend(new_list)
extend(iteratable) → None
将可迭代对象的元素追加进来，返回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]
修改元素：通过索引获取到元素，重新赋值，时间复杂度=O(1)
# 实例： # -*- coding:utf-8 -*- # version：python3.7 list1 = ["语文","数学","英语"] list1[2] = "化学" #修改元素 print(list1) 执行结果： ['语文', '数学', '化学']
删除元素：根据索引删除：del语句；根据元素值删除：remove()方法
(1)remove(value) → None
从左至右查找第一个匹配value的值， 移除该元素，返回None
就地修改
效率极差：找到元素，如果该数据在中间，后面的数据还要移动，时间复杂度=O(n)
(2)del()根据索引删除 → None
根据索引找到元素， 删除该元素，返回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]
5>对列表进行统计运算：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
6>对列表进行排序：升序排列、降序排列 → None，就地修改
使用列表对象的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']
7>列表*重复的坑
* → 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]]
8>列表推导式
可以快速生成一个列表
语法：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]
9>二维列表的使用
# 实例：定义酒店房间的二维列表
# -*- 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='') #不换行输出
执行结果：
--横版--
千山鸟飞绝
万径人踪灭
孤舟蓑笠翁
独钓寒江雪
--竖版--
独孤万千
钓舟径山
寒蓑人鸟
江笠踪飞
雪翁灭绝
4、元组tuple：一个有序元素的集合，不可变
语法：(元素1,元素2,...)
tuple() → empty tuple
tuple(iterable) → tuple initialized from iterable's items
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自带的垃圾回收机制会自动销毁不用的元组，自动回收
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>修改元组元素
# 实例：
# -*- coding:utf-8 -*-
# version：python3.7
class1 = ("明明","浩浩","三三","哈哈")
class1 = ("明明","浩浩","等等","哈哈") #通过重新赋值对元组修改
print("class1=",class1)
class2 = ("巧巧","梅梅")
print("class2=",class2)
allclass = class1 + class2 #元组合并
print("allclass=",allclass)
执行结果：
class1= ('明明', '浩浩', '等等', '哈哈')
class2= ('巧巧', '梅梅')
allclass= ('明明', '浩浩', '等等', '哈哈', '巧巧', '梅梅')
4>元组查询：
index(value,[start,[stop]])
通过值value，从指定区间查找列表内的元素是否匹配
匹配第一个就立即返回索引
匹配不到，抛出异常ValueError
count(value)
返回列表中匹配value的次数
时间复杂度
index和count方法都是O(n)
随着列表数据规模的增大，而效率下降
len(tuple)
返回元索的个数
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__()) #输出第三个元素
......
到第十个元素
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)
7>元组与列表的区别
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]
加载全部内容