序列总结与函数进阶

一、序列总结

对之前学习到的序列类型与相关操作做个简单总结：

序列总结
1.列表:list = [, , , ,]  可混装、可修改、可重复、有序
索引
list[下标]
查询
list.index(元素) → 返回下标
修改
list[下标] = 元素 → 修改索引元素
插入
list.insert(下标, 元素) → 原下标及后面的元素右移
追加
list.append(元素) → 指定元素追加至列表末尾
list.extend(序列) → 序列里的元素追加至列表末尾
删除
del list[下标] → 删除索引元素
list.pop(下标) → 删除指定下标的元素
list.remove(元素) → 删除首次匹配的指定元素
统计
list.count(元素) → 统计指定元素的数量
len(list) → 统计指定列表含有多少元素
清空
list.clear() → 将指定列表的元素全部删除

2.元组:tuple = (, , , ,)  可混装、不可修改、可重复、有序
索引
tuple[下标] 
查询
tuple.index(元素) → 返回下标
统计
tuple.count(元素) → 统计指定元素的数量
len(tuple) → 统计指定元组含有多少元素

3.字符串:string = "      "   不可混装、不可修改、可重复、有序
查询
string.index(字符) → 返回首次匹配到该字符对应的下标
替换
(此方法不能修改字符串本身，只能通过它得到一个新的字符串)
new_str = string.replace(被替字符, 新字符)
分割
(此方法同样无法改变字符串本身，而是得到了一个列表对象。)
new_str = string.split(分隔符) → 将字符串划分为多个字符串并存入列表中
规整
string.strip(空白符) → 按照传入的单个字符对字符串两端进行去除
统计
string.count(字符) → 统计指定字符的数量
len(string) → 统计指定元组含有多少元素

4.集合:set = {, , , ,}  部分混装、可修改、不重复、无序
增加
set.add(元素) → 将指定元素乱序添加至集合中
删除
set.remove(待删元素) → 删除指定元素
随机取元素
set.pop(元素) → 在集合中随机取出一个元素
清空
set.clear() → 得到空集
取差集
set1.difference(set2) → 得到两集合的差集
消除差集
set1.difference_update(set2) → 删除集合1内和集合2相同的元素，集合1被修改，集合2不变
合并集合
set1.union(set2）→ 得到合并的新集合，集合1和集合2不变
统计
len(set) → 统计集合内元素数量

5.字典dict = {: , : , : , : , }   部分混装、可修改、不重复、无序
增加
dict[新键] = 值 → 字典被修改，新增了元素
更新
dict[原键] = 值 → 字典被修改，元素被更新
删除
dict.pop(键) → 字典被修改，指定Key的数据被删除
清空
dict.clear() → 字典被修改，元素被清空
获取全部key
dict.keys() → 得到字典中的全部Key
统计
len(dict) → 得到字典内键值对的数量

性质概括：

一些通用功能：

★★★切片:从一个序列中，取出一个子序列
切片方式：序列[起始下标:结束下标:步长]  
①区间左闭右开
②[:]下标为空表示默认从头取到尾
③步长N表示，每次跳过N-1个元素
④步长为1可以省略不写

补充：字符串比较

根据ASCII码表，字符串是按位比较，也就是一位位进行对比，只要有一位大，那么整体就大

二、函数进阶

1.多返回值

如果一个函数如些两个return，那么运行时只会执行第一个return，原因是因为return可以退出当前函数， 导致return下方的代码不执行。

而如果需要通过一个函数得到多个返回值，则按照返回值的顺序，对应顺序的多个变量接收即可：

# 多个返回值
def more_return():
    return 1, 2


x, y = more_return()
print(x, y)

# 输出：1 2

2.多种传参方式

①位置参数：调用函数时根据函数定义的参数位置来传递参数

# 位置参数
def user_info(name, age, gender):
    print(f"您的信息是{name}, {age}, {gender}")


user_info('Frank', 23, 'male')

#输出：您的信息是Frank, 23, male

其中，传递的参数和定义的参数的顺序及个数必须一致。

②关键字参数：函数调用时通过“键=值”形式传递参数

（让函数更加清晰、容易使用，同时也清除了参数的顺序需求）

# 关键字参数
def user2_info(name, age, gender):
    print(f"您的信息是{name}, {age}, {gender}")


user2_info(name="frank", age=23, gender="male")
user2_info(age=23, gender="male", name="frank")
user2_info("frank", age=23, gender="male")


"""
输出：
您的信息是Frank, 23, male
您的信息是frank, 23, male
您的信息是frank, 23, male
您的信息是frank, 23, male
"""

函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序

③缺省参数:缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值。

当调用函数时没有传递参数, 就会使用默认是用缺省参数对应的值。

（注意：所有位置参数必须出现在默认参数前，包括函数定义和调用）

# 缺省参数
def user3_info(name, age, gender='male'):
    print(f"您的信息是{name}, {age}, {gender}")


user3_info('tom', 20)
user3_info('rose', 18, 'female')

"""
输出：
您的信息是tom, 20, male
您的信息是rose, 18, female
"""

函数调用时，如果为缺省参数传值则修改默认参数值， 否则使用这个默认值

④不定长参数：不定长参数也叫可变参数.

用于不确定调用的时候会传递多少个参数(不传参也可以)的场景。

不定长参数的类型: 位置传递和关键字传递

位置传递

# 不定长参数
def user4_info(*args):
    print(args)


user4_info('tom')
user4_info('tom', 18)

"""
输出：
('tom',)
('tom', 18)
"""

传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple)，args是元组类型，这就是位置传递

关键字传递

def user5_info(**kwargs):
    print(kwargs)


user5_info(name='tom', age=18, id=60)

# 输出：{'name': 'tom', 'age': 18, 'id': 60}

参数是“键=值”形式的形式的情况下, 所有的“键=值”都会被kwargs接受, 同时会根据“键=值”组成字典。

3.匿名函数

①函数作为参数传递

函数本身是可以作为参数传入另一个函数中进行使用的，其作用在于传入计算逻辑，而非传入数据。

# 函数作为参数
def compute(x, y):
    return x + y


def fun(compute):
    result = compute(1, 2)
    print(result)


fun(compute)


# 输出： 3

②lambda匿名函数

函数的定义中，def关键字可以定义带有名称的函数，lambda关键字可以定义无名称的匿名函数；有名称的函数，可以基于名称重复使用。 无名称的匿名函数，只可临时使用一次。

方式如下：

lambda 传入参数：函数体（一行代码）

# lambda匿名函数
numbers = [1, 2, 3, 4, 5]
doubled_numbers = list(map(lambda n: n * 2, numbers))
print(doubled_numbers)  

# 输出: [2, 4, 6, 8, 10]

（使用def和使用lambda，定义的函数功能完全一致，只是lambda关键字定义的函数是匿名的，无法二次使用。）