shu‘s python学习笔记(5):元组 列表 字典 集合

元组

元组与字符串很相似，虽然是个容器类型，但也是不能修改的对象，使用（）括起来
应用：数据确定下来后不想在发生变化就可以使用元组类型

元组的格式：（值,…）

元祖的类型：tuple

# 定义一个空元组
t1 = ()
print(t1) # ()
print(type(t1)) # <class 'tuple'>

#定义包含元素的元组
t2 = (1,2,3,4,5)
print(t2) # (1, 2, 3, 4, 5)
print(type(t2)) # <class 'tuple'>

# 定义包含其他数据类型的元组
t3 = ('a','b','hello','world')

# 元组的复杂定义形式
t4 = (1, 3.14, 'hello', True, t3)
print(t4) # (1, 3.14, 'hello', True, ('a', 'b', 'hello', 'world'))

# 定义具有一个元素的元组，特殊，注意，重点

t5 = (1) # 解释器认为这是一个元素表达式
print(t5) # 1
print(type(t5)) # <class 'int'>

t5 = (1，)
print(t5) # 1，
print(type(t5)) # <class 'tuple'>

# 使用类型名定义元组
t6 = tuple()
print(t6)

t7 = tuple('hello')
print(t7)

元组的下标访问：

t8 = (1,2,3,4,5,6,7,8)
print(t8[0]) # 1
print(t8[1]) # 2
print(t8[2]) # 3
print(t8[70]) # IndexError: tuple index out of range

# 元组类型不支持元素赋值
t8[0] = 1111
print(t8) # TypeError: 'tuple' object does not support item assignment

元组的遍历

三种遍历方式：
for - in
下标
for -in +下标

for-in

t = (1,2,3,4,5,'hello')
for v in t:
	print(v)

输出结果 :
1
2
3
4
5
hello

循环配合下标方式1：

t = (1,2,3,4,5,'hello')
for i in range(len(t)):
	print(t[i])

循环配合下标的方式2：

t = (1,2,3,4,5,'hello')
i = 0
while i < len(t):
	print(t[i])
	i += 1

应用:随机起名程序

last_name = ('张','王')
first_name = ('博','三','四')

元组的嵌套及遍历

# 定义一个嵌套元组
t = (1,2,3,(4,5,6),(7,8,9))
# 遍历
for v in t：
	print(v)

1
2
3
(4, 5, 6)
(7, 8, 9)

t = (1,2,3,(4,5,6),(7,8,9))
# 嵌套内遍历
for v in t：
	# isinstance（o,t）判断参数1是否是参数2的类型对象
	# 通过isinstance判断遍历的元素是否是一个元组
	#如果是就继续遍历 不是就直接输出
	if isinstance(v,tuple):
		for v2 in v :
			print (v2)
	else:
		print (v) 		

1
2
3
4
5
6
7
8
9

元组的常用方法

可以参考字符串的方法
count（）：用来统计元素个数
index（）：用来查找元素的位置
注意：如果元组中只有一个元素那么在定义时需要加一个逗号

t = (1,2,3,4,55,6,7,2,3,2)
# 提示中方法名前面的m表示是一个方法 method
print(t.count(2))
print(t.index(2))
print(t.index(2,3,5)) # ValueError: tuple.index(x): x not in tuple

---

列表

定义和下标访问

定义格式：
变量名 = [值,...]
变量名 = list(值)
特性：数据可以修改

 # 定义一个空列表
custom_list1 = [] # 空列表类型
print(custom_list1)
print(type(custom_list1))

[]
<class ‘list’>

 # 定义只有一个元素的列表
custom_list2 = [1] # 加上逗号也没有影响
print(custom_list2)
print(type(custom_list2))

[1]
<class ‘list’>

# 定义具有多个元素的列表
custom_list3 = [1,2,3,'hello',(4,5,6),['a','b','c']] # 加上逗号也没有影响
print(custom_list3)
print(type(custom_list3))

# 遍历
for v in custom_list3:
	if isinstance(v,tuple) or isinstance(v,list):
		for i in v:
			print(i)
	else:
		print(v)

运行结果：
1, 2, 3, ‘hello’, (4, 5, 6), [‘a’, ‘b’, ‘c’]]
<class ‘list’>
1
2
3
hello
4
5
6
a
b
c

list（）

# 使用list创建列表对象
cl4 = list()
print(cl4)
print(type(cl4))

下标

# 通过下标访问列表中的元素
cl5 = [1,2,3,4,5]
print(cl5[0])
print(cl5[3])
print(cl5[4])
print(cl5[10]) # IndexError: list index out of range

重点：列表的特性-可以通过下标修改对应位置上的数据
练习：字符串逆序

s = 'hello'
def revers_str(s):
	# 定义一个空字符串用来拼接
    ret_s = ''
    i = len(s) - 1
    while i >= 0:
        ret_s += s[i]
        i -= 1

    return ret_s

print(revers_str(s))

olleh

列表的排序和逆序

sort()

cl = [9,2,5,7,1,8,4,3,0,6]
cl.sort()
print(cl) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 默认从小到大排序
print(cl.sort()) # none 注意sort()函数没有返回值，直接在对象里操，默认返回none


cl = [9,2,5,7,1,8,4,3,0,6]
#降序排序（从大到小）
cl.sort(reverse=True) # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
print(cl) # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
#逆序
#逆序是直接将原列表中的顺序进行逆转（并不是排序）
cl.reverse()
print(cl) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

实现列表逆序的方法：

cl = [9,2,5,7,1,8,4,3,0,6]
def reverse_list(cl):
	# 定义一个空列表
	ret_l = []
	i = len(cl) - 1
	while i >= 0 :
		ret_l.append(cl[i]) # 相当于字符串中的 s += c
		i -= 1
	return ret_l # 注意需要返回

print(reverse_list(cl))
	

运行结果：[6, 0, 3, 4, 8, 1, 7, 5, 2, 9]

常用方法

增：
append()
extend()
insert()
修：
下标修改
查：
index()
count()
in()
not in()
删：
pop()
remove()
clear()
del 全没了

列表可变所以我们可以增删改查，元组不可变所以只能查

增：

# 增 append() extend() insert()
# append()追加数据 在最后面追加
cl = []
cl.append(1)
cl.append(2)
cl.append(3)
cl.append('hello')
print(cl) # [1, 2, 3, 'hello']
cl.append(['a','b'])
print(cl) # [1, 2, 3, 'hello', ['a', 'b']]

# extend() 扩展
# 可以将参数中的容器对象中的每一个元素添加到源列表中
# 遍历每一个往后顺序放
cl1 = [1,2,3]
cl2 = ['a','b','c']
cl1.append(cl2)
print(cl1) # [1, 2, 3, ['a', 'b', 'c']]

cl1 = [1,2,3]
cl2 = ['a','b','c']
cl1.extend(cl2)
print(cl1) # [1, 2, 3, 'a', 'b', 'c']

# insert() 插入
cl3 = [1,2,3,4,5]
cl3.insert(0,999)
print(cl3) # [999, 1, 2, 3, 4, 5]
cl3.insert(2,888)
print(cl3)  # [999, 1, 888, 2, 3, 4, 5]
cl3.insert(17,777) # 在插入数据室没有下标越界的问题
print(cl3) # [999, 1, 888, 2, 3, 4, 5, 777]

查：

# 列表操作-查找：
l = [1,2,3,4,5,6,6,6,6,6,2,3]
print(l.count(6)) # 5
print(l.count(66)) # 0
print(l.index(6)) # 5 出现的第一个6的下标
print(l.index(66)) # ValueError: 66 is not in list
# in - not in
print(2 in l) # True

删：

cl = [1,2,3,4,5,6,7,72,8,90,91,0]
# pop()其中index参数(元素的索引)可以不写，默认删除最后一个
cl.pop()
print(cl) # [1, 2, 3, 4, 5, 6, 7, 72, 8, 90, 91]
cl.pop(0)
print(cl) # [2, 3, 4, 5, 6, 7, 72, 8, 90, 91]

# remove()
cl = [1,2,3,4,5,6,7,72,8,90,7,91,0]
cl.remove(7) # 后面跟要删除的对象
print(cl) # [1, 2, 3, 4, 5, 6, 72, 8, 90, 7, 91, 0] 只删除了第一个7

# del() 有两种方式
del cl[1] # 注意格式 []中为索引号
print(cl) # [1, 3, 4, 5, 6, 72, 8, 90, 7, 91, 0]
del( cl[1] ) 
print(cl) # [1, 4, 5, 6, 72, 8, 90, 7, 91, 0]
# 将整个列表删除
del cl
print(cl) # NameError: name 'cl' is not defined

# clear()
cl = [1,2,3,4,5,6,7,72,8,90,91,0]
cl.clear()
print(cl) # []

注意：在使用列表时，不要在循环遍历时删除元素

cl = [2,5,6,3,7,8,90,91]
for o in cl:
	cl.remove(o)
print(cl) # [5, 3, 8, 91]

---

字典

字典定义格式(以键值对作为元素)：{key:value…,}

定义字典：

# 第一种形式定义
d = {} # dict
print(d) # {}
print(type(d)) # <class 'dict'>

# 第二种形式定义
# 理论上所有不可变的类型都可以作为key
# 只要是可以hash的对象都可以作为key
#key一般情况下使用字符串类型数据充当
d={1: 'one','2': 'two'} 
print(d) # {1: 'one', '2': 'two'}

#第三种形式定义
d={'one': '星期一'，'two': '星期二','three'}

字典元素的访问

d = {'one': '星期一', 'two': '星期二', 'three': '星期三','haha':'周末'}
print(d)

# 字典也是通过下标方式 来访问元素，但是字典中没有索引，也就是没有下标编号
# 字典通过下标的中括号中书写key的方式 来直接 访问key所对应的值
print(d['one'])
print(d['two'])
print(d['haha'])
# print(d['hahaha']) # KeyError: 'hahaha' 访问时，如果使用了不存在的key，会报错

# 字典也是一个可变类型
d['haha'] = '星期日'
print(d)

d = {'one': '星期一', 'two': '星期二', 'three': '星期三','haha':'周末'}

print(d['one'])
print(d.get('one'))

# print(d['onee'])
#  下标方式 在访问数据时，如果key不存在，会报错
# get方法方式 访问数据时，如果key不存在，返回None
print(d.get('onee'))

字典元素的遍历

# 方式 一

d = {'one': '星期一', 'two': '星期二', 'three': '星期三','haha':'周末'}

# 默认情况 下，使用for-in遍历时，会将所有的key遍历出来
for k in d:
    print(f'for-in:{k} --> {d[k]}')


# 方式二
# keys()方法
print(d.keys())
for k in d.keys():
    print(f'keys  :{k} --> {d[k]}')


# 方式三
# values() 方法
print(d.values())
for v in d.values():
    print(f'values: {v}')


# 方式 四
# items()
print(d.items())

for item in d.items():
    print(f'items: {item[0]}--》{item[1]}')

for k,v in d.items():
    print(f'item: {k}--> {v}')
    
    
# 解包
item = (1,2,3,4,5,6)
a,b,c,d,e = item

print(a)
print(e)

字典的增删改查

d = {}

# 增
# 如果在赋值时，使用的key在字典中不存在，那么就是向字典中添加 数据
d['a'] = 1
d['b'] = 2
d['c'] = 2
d['d'] = 2
d['e'] = 5
print(d)


# 改
# 如果在赋值 时，使用的key在字典中存在，那么就修改这个key所对应的值
# 注意：
# 字典中的key 具有唯一性
# 如果key不存在，那么就是添加数据
# key 是不能修改的

d['a'] = 11
print(d)


# 查
print(d['a'])
print(d.get('a'))


# 删除
# popitem 删除 最后一个键值对
# d.popitem()
# print(d)
# d.popitem()
# print(d)

#pop(key)
# pop 可以通过 指定 key来删除 任意位置的键值对
print(d)
d.pop('c')
print(d)


# 清空字典中的键值对
# d.clear()
# print(d)

# del
del d['e']
print(d)

del d
print(d)

字典练习：名片管理

# 定义字典的函数

def creat_card():
    # 使用字典来保存每张名片的数据
    # name,age,address
    card = {}
    card['name'] = input('请输入姓名：')
    card['age'] = input('请输入年龄：')
    card['address'] = input('请输入地址：')

    return card

# 显示 名片字典内容函数
def show_card(card):
    for k in card:
        print(f'{k} : {card.get(k)}')


# 测试
show_card(creat_card())

---

集合

集合的特性：定义像字典 储存数据像列表
重要特性：集合中的数据不允许重复
作用：利用集合的特性来对数据进行去重

集合的定义 set(可遍历的对象)

s = {1,2,3,4,5,6,7,7,7}
print(s) # {1, 2, 3, 4, 5, 6, 7}

# 定义一个空集合
s = {}
print(type{s}) # <class 'dict'> 这是定义空字典

s = set()
print(type{s}) # <class 'set'> 这才是定义了一个空集合

集合的遍历

s = {1,2,3,4,5,6,7,7,7}

for v in s:
    print(v)


# 注意： 集合是不支持下标的
print(s[0]) # TypeError: 'set' object is not subscriptable

集合的应用

找出单词出现的频次：思路—>将单词列表转成集合的形式，再将每一个元素在列表中遍历从而统计次数

set -list -tuple三者之间的类型转换

s = 'hello'
l = list(s)
print(l) # ['h', 'e', 'l', 'l', 'o']
print(set(l)) # {'h', 'l', 'o', 'e'} 集合在存储时是无需的

print(set(s)) # 字符串可以直接转成集合 {'h', 'l', 'o', 'e'}

l1 = str(l)
print(l1,'---',type(l1))  # ['h', 'e', 'l', 'l', 'o'] --- <class 'str'>