Python+大数据学习笔记|Day 9:五大容器与函数进阶

五大容器

---

一.五大容器的特点对比

        我们已经学过五个用来存储多个元素的数据容器（列表、元祖、字符串、集合与字典），这五个容器的共同点是它们都能存储多个元素，都可以用for循环遍历容器内的元素。五大容器既有相似之处，也有很多不同的地方。

        在存储元素类型上，字符串只能存储字符串类型的元素，集合与字典的key值都只能够存储不可变数据类型，而五大容器中的不可变数据类型仅有元祖和字符串。

        由于列表、元祖与字符串同为序列，因此它们都是有序的，可重复的，且都支持序列切片操作。集合与字典则因为无序，不能重复，且因其没有下标，所以集合与字典不支持利用下标索引使用while循环进行遍历。

        将五大容器的异同汇聚在一张表上，可以看到：

五大容器对比

	是否能存储多个元素	是否支持for循环	是否支持下标索引（是否有序）	是否可存储不同数据类型	是否支持修改	是否支持重复	是否支持while循环	是否支持序列切片
列表	是	是	是	是	是	是	是	是
元祖	是	是	是	是	否	是	是	是
字符串	是	是	是	仅能存储字符类型	否	是	是	是
集合	是	是	否	只能存储不可变数据类型	是	否	否	否
字典	是	是	否	key只能存储不可变数据类型，value可以存储任意类型	是	key值不可重复，value值可重复	否	否

 

---

二.五大容器通用操作

 一.通用for循环:

        for循环又叫遍历循环（数据集需要提前存在）

# 定义列表
list1 = ['d', 'a', 'b', 'c', 'e']
# 定义元组
tuple1 = ('d', 'a', 'b', 'c', 'e')
# 定义字符串
str1 = 'dabce'
# 定义集合
set1 = {'d', 'a', 'b', 'c', 'e'}
# 定义字典
dict1 = {'d': 1, 'a': 1, 'b': 1, 'c': 1, 'e': 1}

# 列表for循环
for e in list1:
    print(e)
print('-------------------')
# 元组for循环
for e in tuple1:
    print(e)
print('-------------------')
# 字符串for循环\
for e in str1:
    print(e)
print('-------------------')
# 集合for循环
for e in set1:
    print(e)
print('-------------------')
# 字典for循环
for e in dict1:
    print(e)
print('-------------------')

---

 

 二.通用len功能:

     求容器中元素的个数(字典中默认一对键值对为一个元素)

# 定义列表
list1 = ['d', 'a', 'b', 'c', 'e']
# 定义元组
tuple1 = ('d', 'a', 'b', 'c', 'e')
# 定义字符串
str1 = 'dabce'
# 定义集合
set1 = {'d', 'a', 'b', 'c', 'e'}
# 定义字典
dict1 = {'d': 1, 'a': 1, 'b': 1, 'c': 1, 'e': 1}

# 通用len():求元素个数
print(len(list1))
print(len(tuple1))
print(len(str1))
print(len(set1))
print(len(dict1))

---

 

三.通用max功能:

        求容器中元素最大值(字典默认操作的是键key)

四.通用min功能:

        求容器中元素最小值(字典默认操作的都是键key)

# 定义列表
list1 = ['d', 'a', 'b', 'c', 'e']
# 定义元组
tuple1 = ('d', 'a', 'b', 'c', 'e')
# 定义字符串
str1 = 'dabce'
# 定义集合
set1 = {'d', 'a', 'b', 'c', 'e'}
# 定义字典
dict1 = {'d': 1, 'a': 1, 'b': 1, 'c': 1, 'e': 1}

# 通用max():求最大值
print(max(list1))
print(max(tuple1))
print(max(str1))
print(max(set1))
print(max(dict1))

print('-----------------')

# 通用min():求最小值
print(min(list1))
print(min(tuple1))
print(min(str1))
print(min(set1))
print(min(dict1))

---

 

五.通用排序功能:

        sorted(容器,[revserse=True]) 默认把指定容器中元素放到列表中排序,revserse=True排序后反转。

# 定义列表
list1 = ['d', 'a', 'b', 'c', 'e']
# 定义元组
tuple1 = ('d', 'a', 'b', 'c', 'e')
# 定义字符串
str1 = 'dabce'
# 定义集合
set1 = {'d', 'a', 'b', 'c', 'e'}
# 定义字典
dict1 = {'d': 1, 'a': 1, 'b': 1, 'c': 1, 'e': 1}

# 通用sorted():默认从小到大升序排序,默认都放到列表中返回
print(sorted(list1))
print(sorted(tuple1))
print(sorted(str1))
print(sorted(set1))
print(sorted(dict1))
print('-----------------')
# 通用sorted(reverse=True):默认从小到大升序排序,默认都放到列表中返回
print(sorted(list1, reverse=True))
print(sorted(tuple1, reverse=True))
print(sorted(str1, reverse=True))
print(sorted(set1, reverse=True))
print(sorted(dict1, reverse=True))

---

 

六.通用枚举功能:

        enumerate(容器) 自动根据容器元素生成从0开始的编号。

# 定义列表
list1 = ['d', 'a', 'b', 'c', 'e']
# 定义元组
tuple1 = ('d', 'a', 'b', 'c', 'e')
# 定义字符串
str1 = 'dabce'
# 定义集合
set1 = {'d', 'a', 'b', 'c', 'e'}
# 定义字典
dict1 = {'d': 1, 'a': 1, 'b': 1, 'c': 1, 'e': 1}

# 列表for循环
for i, e in enumerate(list1):
    print(i, e)

print('-------------------')

# 元组for循环
for i, e in enumerate(tuple1):
    print(i, e)
print('-------------------')
# 字符串for循环
for i, e in enumerate(str1):
    print(i, e)
print('-------------------')
# 集合for循环
for i, e in enumerate(set1):
    print(i, e)
print('-------------------')
# 字典for循环
for i, e in enumerate(dict1):
    print(i, e)

---

 

 七.通用拆包功能：

        把容器中元素依次取出赋值给对应变量的过程

# 定义列表
list1 = [1, 2, 3]
# 定义元组
tuple1 = (1, 2, 3)
# 定义字符串
str1 = '123'
# 定义集合
set1 = {1, 2, 3}
# 定义字典
dict1 = {1: 1, 2: 1, 3: 1}

# 拆包: 把容器中元素依次取出赋值给对应变量的过程
# 注意: 拆包应用场景一般用于容器中有几个元素的情况
a, b, c = list1
print(a, b, c)
a, b, c = tuple1
print(a, b, c)
a, b, c = str1
print(a, b, c)
a, b, c = set1
print(a, b, c)
a, b, c = dict1
print(a, b, c)

"""
两个变量交换值
已知a记录10,b记录20,要求把a和b的值交换
"""
# 已知数据
a = 10
b = 20
print(a, b)
# 方式1: 借助临时变量
# temp = a
# a = b
# b = temp
# print(a, b)
# 方式2: 先打包再拆包
b, a = a, b
print(a, b)

---

三.五大容器的类型转换

str(x):

        其他数据转为字符串类型

list(x):

        其他数据转为列表类型

set(x):

        其他数据转为集合类型

tuple(x):

        其他数据转为元组类型

注：以上四大容器均不能转为字典dict，因为字典存储的是键值对。

eval(字符串):

        去除字符串两端引号，如：“[1,2]”去除后是[1,2]

        注意:eval不能随便使用，只有在去除引号后格式为其余几大数据类型时才需要使用，如果随便使用，很容易报错。

# 需求1:定义字符串"abcde"
str1 = "abcdeabc"
# 需求2:字符串每个字符用列表存储起来
list1 = list(str1)
print(list1)  # ['a', 'b', 'c', 'd', 'e', 'a', 'b', 'c']
# 需求3: 去除列表中重复数据
set1 = set(list1)
print(set1)  # {'e', 'b', 'd', 'c', 'a'}
new_list1 = list(set1)
print(new_list1)  # ['e', 'b', 'd', 'c', 'a']
# 需求4: 要求数据不能修改
tuple1 = tuple(new_list1)
print(tuple1)  # ('e', 'b', 'a', 'd', 'c')

print('------------------------------------------------')

# 定义列表
list1 = ['d', 'a', 'b', 'c', 'e']
# 定义元组
tuple1 = ('d', 'a', 'b', 'c', 'e')
# 定义集合
set1 = {'d', 'a', 'b', 'c', 'e'}
# 定义字典
dict1 = {'d': 1, 'a': 1, 'b': 1, 'c': 1, 'e': 1}

# 注意: 任意类型都能转换为字符串类型,本质就是用引号包裹起来
# 列表转字符串
s1 = str(list1)
print(s1, type(s1))  # "['d', 'a', 'b', 'c', 'e']"
s2 = str(tuple1)
print(s2, type(s2))  # "('d', 'a', 'b', 'c', 'e')"
s3 = str(set1)
print(s3, type(s3))  # "{'d', 'a', 'b', 'c', 'e'}"

# 能不能直接去除引号,回归本身内容? eval去除字符串两端引号
# "['d', 'a', 'b', 'c', 'e']"转换为列表
list2 = eval(s1)
print(list2, type(list2))
tuple2 = eval(s2)
print(tuple2, type(tuple2))
set2 = eval(s3)
print(set2, type(set2))

# 注意: eval函数不要随意使用
print(eval("10"), type(eval("10")))  # 自动转换为整数10
print(eval("3.14"), type(eval("3.14")))  # 自动转换为浮点数3.14
print(eval("abc"))  # 报错NameError: name 'abc' is not defined

---

四.三大序列通用符号

+ :

        通用拼接符号 ,产生新的序列

* :

        通用复制拼接符号,产生新的序列

# 定义列表
list1 = ['d', 'a', 'b', 'c', 'e']
# 定义元组
tuple1 = ('d', 'a', 'b', 'c', 'e')
# 定义字符串
str1 = 'dabce'


# 演示通用拼接符号:+  产生新的序列
print(list1 + ['f'])
print(tuple1 + ('f',))
print(str1 + 'f')

# 演示通用复制拼接符号: * 产生新的序列
print(list1 * 3)
print(tuple1 * 3)
print(str1 * 3)

 

---

函数进阶

---

函数的多个返回值：

        return 值1,值2...: return 后跟多个返回值,默认是放到元组中返回此元组

# 知识点: 函数返回多个值,核心思想放到容器中返回,默认用的元组
# 先定义函数
def show():
    return 1, 2, 3


# 再调用函数
# 方式1: 接收元组,再遍历
result = show()
print(result, type(result))
# 遍历元组
for i in result:
    print(i)

# 方式2: 直接拆包接收
a, b, c = show()
print(a, b, c)

---

函数的参数 ：

位置参数:

        顺序必须一致,个数必须一致

由于位置参数是直接将参数传到对应位置，因此位置不一致会导致传入的数据不是自己想要的。如果函数中需要的参数跟实际传入参数类型不一致会报错。

# 先定义函数
def show(name, age, height):
    print(f"姓名:{name},年龄:{age},身高:{height}cm")


# 再调用函数
# 演示位置传参 , 弊端: 实参和形参的个数和顺序都必须一致
show('张三', 18, 178.8)

---

关键字参数:

        顺序可以不一致，但是实参与形参个数必须一致

由于关键字参数是通过"形参名=实参值"的形式传递，我们传入的参数即使位置跟形参不一致也不影响接收，所以关键字参数可以顺序不一致。

关键字参数不需要形参与实参顺序一致，位置参数必须形参与实参顺序一致，如果关键字参数在传参时放在形参前会影响到位置参数，因此位置参数与关键字参数混用时，关键字参数需要放在后面。

# 先定义函数
def show(name, age, height):
    print(f"姓名:{name},年龄:{age},身高:{height}cm")


# 再调用函数
# 演示关键字参数, 优点: 实参和形参的顺序可以不一致  弊端: 实参和形参的个数必须一致
show(age=18, name='张三', height=178.8)
# 注意: 如果关键字参数和位置参数一起使用,关键字参数需要放到后面
show('张三', height=178.8, age=18)

---

 

缺省参数:

        个数可以不一致 

由于缺省参数在函数定义已经设置了默认值，所以缺省参数调用时可以省略，直接使用默认值，在调用时传入了缺省参数，实际参数值以调用时传入的为准。

位置参数与缺省参数一起配合使用时，缺省参数放在后面。

# 先定义函数
# 注意: 位置参数和缺省参数一起配合使用,缺省参数需要放到后面
def show( name='张三', age=18, height=188.8):
    print(f"姓名:{name},年龄:{age},身高:{height}cm")



# 再调用函数
# 演示缺省参数, 优点: 实参和形参的个数可以不一致
# 如果都设置了缺省参数,调用的时候可以都不传,使用默认值
show()
# 如果都设置了缺省参数,调用的时候传入了值,以传入的为主
show('李四')
show('李四', 19)
show('李四', 19, 199.9)
# 注意: 如果定义的时候都设置了缺省参数,调用的时候只想改变后面的某个数据,需要用关键字参数
show( name='张三', height=199.9)

---

可变参数（不定长参数）:

        传入的实参个数可以不定长, *args以元组形式接收数据,**kwargs以字典方式接收数据。 

"""
可变参数: 不定长参数
位置传参: 一个个数据,使用*args接收,默认把所有数据存储到了元组中,这个元组名叫args
关键字传参: 一对对数据,使用**kwargs,默认把所有数据存储到了字典中,这个字典名叫kwargs
"""


# 先定义函数
def show1(*args, **kwargs):
    print(args, type(args))
    print(kwargs, type(kwargs))


# 再调用函数
show1(1, 2, 3, a=4, b=5, c=6)

---

综合练习 

# 需求: 定义一个求和的函数
# 先定义函数
def get_sum(*args, **kwargs):
    print(args)
    print(kwargs)
    sum = 0
    # 遍历元组
    for i in args:
        sum += i
    # 遍历字典的所有值
    for i in kwargs.values():
        sum += i
    return sum


# 再调用函数
print(get_sum(10, 20, 30, a=40, b=50, c=60))