5.千峰教育元组&字符串&字典---自制随堂笔记

创建空的元组

tuple1 = ()
print(tuple1)

创建带有元素的元组

元组中的元素的类型可以不同

tuple2 = (1,2,3,"good", "True")
print(tuple2)

定义只有一个元素的元组

tuple3 = (1, ) # 元组中只有元素时注意加逗号
print(tuple3)
print(type(tuple3))

元组元素的访问
格式：
元组名[下标]
下标从0开始
取值

tuple4 = (1,2,3,4,5)
print(tuple4[0])
print(tuple4[1])
print(tuple4[2])
print(tuple4[3])
#### print(tuple4[5]) # 下表超过范围（越界）

获取最后一个元素

print(tuple4[-1])
print(tuple4[-2])
print(tuple4[-5])
# print(tuple4[-6]) 越界

修改元组

tuple5 = (1,2,3,4,[5,6,7])

# tuple[0] = 100  # 报错，元组不能变
# tuple5[-5] = [7,8,9]

tuple5[-1][0] = 500
print(tuple5)

删除元组

tuple6 = (1,2,3)
del tuple6
#### print(tuple6)

元组的操作

t7 = (1,2,3)
t8 = (4,5,6)
t9 = t7 + t8
print(t9)
print(t7, t8)

元组重复

t10 = (1,2,3)
print(t10 * 3)

判断元素是否在元组

t11 = (1,2,3)
print(1 in t11)

元素的截取

格式:元组名[开始下标：结束下标]

从开始下标开始截取，截取到结束下标之前

t12 = (1,2,3,4,5,6,7,8,9)
print(t12[3:7])
print(t12[3:])
print(t12[:7])
```python


#### 二维元组：元素为一维元组的元组
```python
t13 = ((1,2,3),(4,5,6),(7,8,9))
print(t13[1][1])

元组的方法

len() 返回元组中元素的个数

t14 = (1,2,3,4,5)
print(len(t14))

max() 返回元组中的最大值

min()

print(max((5,6,7,8,9)))
print(min((5,6,7,8,9)))

将列表转成元组

list = [1,2,3]
t15 = tuple(list)
print(t15)

元组的遍历

for i in (1,2,3,4,5):
	print(i)

字典

概述：
使用键-值(key-value)储存，具有极快的查找速度

注意：
字典是无序的

key的特性：
1、字典中的key必须唯一
2、key必须是不可变对象
3、字符串、整数等都是不可变的，可以作为key
4、list是可变的，不能作为key

思考：保存多位学生的姓名与成绩

使用字典，学生姓名为key，学生成绩作为值

dict1 = {"tom":60, "lilei":70}

元素的访问

获取：字典名[key]

print(dict1["lilei"])
# print(dict1["sunck"])  # 没有
print(dict1.get("sunck"))
ret = dict1.get("sunck")
if ret == None:
	print("没有")
else:
	print("有")

添加

dict1["hansome"] = 99

因为一个key对应一个value，所以多次对一个key的value赋值，其实就是修改值

dict1["lilei"] = 80

print(dict1)

删除

dict1.pop("tom")
print(dict1)

遍历

for key in dict1:
	print(key, dict1[key])
# print(dict1.values())
for value in dict1.values():
	print(value)

print(dict1.items())

for k, v in dict1.items():
	print(k,v)



for i, v2 in enumerate(dict1):
	print(i, v2)

和list比较

1、查找和插入的速度极快，不会随着key-value的增加而变慢

2、需要占用大量的内存 ，内存浪费多

list

1、查找和插入的速度随着数据量的增多而减慢

2、占用空间小，浪费内存少

w = "good"

str = "sunck is a nice man! sunck is a handsome man! sunck is a good man! sunck is a good man!"

print(str.count(w))

练习

w = input()
d = {}    # word:次数

str = "sunck is a nice man! sunck is a handsome man! sunck is a good man! sunck is a good man!"


l = str.split(" ")

for v in l:
	c = d.get(v)
	if c == None:
		d[v] = 1
	else:
		d[v] += 1

print(d[w])

'''
1、以空格切割字符串
2、循环处理列表中的每个元素
3、以元素当做key去一个字典中提取数据
4、如果没有提取到，就以该元素作为key,1作为value存进自带你
5、如果提取到，将对应的key的value修改，值加1
6、根据输入的字符串当做key再去字典取值
'''

时间下一秒

timeStr = input()
# 12:23:23

timeList = tiemStr.split(":")

h = int(timeList[0])
m = int(timeList[1])
s = int(timeList[2])

s += 1

if s == 60:
	m += 1
	s = 0
	if m == 60:
		h += 1
		m == 0
		if h == 24:
			h = 0


print("%.2d:%.2d:%.2d" % (h, m, s))

歌词解析

歌词文件只有一部分，且有瞎打的字

import time
musicLrc = """[00:03.50]传奇
[00:20.60]演唱：王菲
[00:19.10]只是因为在人群中
[03:08.38]圣诞节回复开始打扫家里和但是考虑将阿喀琉斯
[04:40.75][02:39.90][00:36.25]只是因为在人群中多看了你一眼
"""
lrcDict = {}
musicLrcList = musicLrc.splitlines()
# print(musicLrcList)
for lrcLine in musicLrcList:
	lrcLineList = lrcLine.split("]")
	for index in range(len(lrcLineList) - 1):
		timeStr = lrcLineList[index][1:]
		# print(timeStr)
		# 00:03.50
		timeList = timeStr.split(":")
		time1 = float(timeList[0]) * 60 + float(timeList[1])
		# print(time)
		lrcDict[time1] = lrcLineList[-1]
print(lrcDict)
allTimeList = []
for t in lrcDict:
	allTimeList.append(t)
allTimeList.sort()
# print(allTimeList)
getTime = 0
while 1:
	for n in range(len(allTimeList)):
		tempTime = allTimeList[n]
		if getTime < tempTime:
			break
	lrc = lrcDict.get(allTimeList[n - 1])
	if lrc == None:
		pass
	else:
		print(lrc)
	time.sleep(1)
	getTime += 1

set:

类似dict，是一组key的集合，不存储value

本质：

无序和无重复元素的集合

创建：

创建set需要一个list或tuple或dict作为输入集合

重复元素在set中会自动被过滤

s1 = set([1,2,3,4,5,5,4])
print(s1)

s2 = set((1,2,3,3,2,1))
print(s2)

s3 = set({1:"good",2:"nice"})
print(s3)

添加

s4 = set([1,2,3,4,5])
s4.add(6)
s4.add(3)    # 可以添加重复的，但是不会有效果
# s4.add([7,8,9])      # []的list是可变的，set相当于存储的是字典里的key，key不能用可变的
s4.add((7,8,9))
# s4.aa({1:"a"})       # set的元素不能是字典，因为字典是可变的
print(s4)

插入整个list、tuple、字符串，打碎插入

s5 = set([1,2,3,4,5])
s5.update([6,7,8])
s5.update((9,10))
s5.update("sunck")
print(s5)

删除

s6 = set([1,2,3,4,5])
s6.remove(3)
print(s6)

遍历

s7 = set([1,2,3,4,5])
for i in s7:
	print(i)
# set没有索引的
# print(s7[3])

for index, data in enumerate(s7):
	print(index,data)

s8 = set([1,2,3])
s9 = set([2,3,4])

交集

a1 = s8 & s9
print(a1)
print(type(a1))

并集

a2 = s8 | s9
print(a2)
print(type(a2))

set–>list

s3 = {1,2,3,4}
l3 = list(s3)
print(13)

set–>tuple

s4 = {2,3,4,5}
t4 = tuple(s4)
print(t4)

list去重复

l = [1,2,3,4,3,4,5,6]
s = set(1)
l = list(s)
print(l)

迭代器

可迭代对象：可以直接作用于for循环的对象统称为可迭代对象(Iterable)

可以用isinstance()去判断一个对象是否是Iterable对象

可以直接作用于for的数据类型一般分两种

1、集合数据类型，如list、tuple、dict、set、string

2、generator,包括生成器和带yield的generator function

from collections import Iterable
from collections import Iterator
print(isinstance([], Iterable))
print(isinstance((), Iterable))
print(isinstance({}, Iterable))
print(isinstance("", Iterable))
print(isinstance((x for x in range(10)), Iterable))
print(isinstance(1, Iterable))
"""
迭代器：不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，
，直到最后抛出一个StopIteration错误表示无法继续返回下一个值

可以被next()函数调用并不断返回下一个值的对象称为迭代器（Iterator对象）

可以使用isinstance()函数判断一个对象是否是Iterator对象
"""
print(isinstance([], Iterator))
print(isinstance((), Iterator))
print(isinstance({}, Iterator))
print(isinstance("", Iterator))
print(isinstance((x for x in range(10)), Iterator))
print(isinstance(1, Iterator))

转成Iterator对象

a = iter([1,2,3,4,5])
print(next(a))
print(next(a))

print(isinstance(iter([]), Iterator))
print(isinstance(iter(()), Iterator))
print(isinstance(iter({}), Iterator))
print(isinstance(iter(""), Iterator))

l = (x for x in [23, 4, 5, 64, 3435])
print(next(l))
print(next(l))
print(next(l))
print(next(l))
print(next(l))
# print(next(l))      # 超出范围

案例

随意输入，碰到end之后结束程序

endstr = "end"
str = ""
for line in iter(input, endstr):
		str += line + "\n"
print(str)