Python第五周学习笔记

Python第五周学习笔记

目录

Python常用内置函数

1. range()函数

2. zip（）函数

3. 变量相关函数

4. 数学相关函数

5. 进制相关函数

6. sorted()函数

7. map（）函数

8. reduce（）函数

9. filter（）函数

---

Python常用内置函数 1. range()函数

"""
range（）函数
功能：能够生成一个指定的数字序列
参数（必须为整数）：
    start : 开始的值,默认值为0
    stop : 结束的值
    [, step] : 可选，步进值，默认值为1
返回值: 可迭代的对象，数字序列
"""
for i in range(1, 11):  # 打印1-10的数字
    print(i, end=" ")
print()
for i in range(1, 15, 5):  # 打印从1-15，间隔5的数字
    print(i, end=" ")
print()
for i in range(7):  # 打印从0-6的数字
    print(i, end=" ")
print()
for i in range(10, 1, -1):  # 打印从10-2的数字，间隔为1的数字，-1表示顺序
    print(i, end=" ")

# 结果
1 2 3 4 5 6 7 8 9 10 
1 6 11 
0 1 2 3 4 5 6 
10 8 6 4 2 

2. zip（）函数

"""
zip（）函数
功能 : zip函数可以接收多个可迭代对象，然后把每个可迭代对象中的第i个元素组合在一起，形成一个新的迭代器
参数 : *iterables, 任意个的 可迭代对象
返回值 : 返回一个元组的迭代器
"""
# 如果有一个元素是最短的，那么zip函数只会生成 “最短的那个对象的元素个数“ 个元组迭代器
var1 = '1234'
var2 = ['a', 'b', 'c', 'd']
var3 = ('A', 'B', "abc", "ABC")
res = zip(var1, var2, var3)  # 调用zip函数组成新的元组迭代器
print(res, type(res))
# 提取迭代器数据的方法，next（），list（），for循环
for i in res:
    print(i)

# 结果
('1', 'a', 'A')
('2', 'b', 'B')
('3', 'c', 'abc')
('4', 'd', 'ABC')

# zip（）与 * 运算符相结合可以用来拆解一个列表：
x = [1, 2, 3]
y = [4, 5, 6]
zipped = zip(x, y)
print(list(zipped))

print(zip(x, y))  # 迭代器对象
print(*zip(x, y))  # 组合好的多个元组数据

x2, y2 = zip(*zip(x, y))  # 反向解析，回到原来的列表
print(x2, y2)

# 结果
[(1, 4), (2, 5), (3, 6)]

(1, 4) (2, 5) (3, 6)
(1, 2, 3) (4, 5, 6)

3. 变量相关函数

id（）获取当前数据的ID标示

type（）获取当前数据的类型字符串

print（）数据的打印

input（）获取输入的数据

isinstance（）检测是否为指定的数据类型

4. 数学相关函数

abs（）返回一个数的绝对值

sum（iterable，/，start = 0）从 start 开始自左向右对 iterable 的项求和并返回总计值。

max（iterable, *[, key, default])  /  max(arg1, arg2, *args[, key]) 求取最大值

min（iterable, *[, key, default])  /  min(arg1, arg2, *args[, key]) 求取最小值

其他可查阅python文档进行查看https://docs.python.org/zh-cn/3.10/library/functions.html

# 数学相关函数

print(abs(-99.99))  # 获取一个数的绝对值
print(sum(range(1, 5)))  # 求和
print(max(range(1, 6)))  # 求最大值
print(min(range(1, 6)))  # 求最小值

# 结果
99.99
10
5
1

5. 进制相关函数

bin() 将数值类型转为二进制

int() 将数值类型转为整形

oct() 将数值类型转为八进制

hex() 将数值类型转为十六进制

ord() 给定字符值，获取数字值，它接受一个字符并返回一个整数

6. sorted()函数

"""
sorted()
原理：把可迭代的数据里面的元素一个一个的取出来放到key这个函数中进行处理，并按照函数中return的结果进行排序，并返回一个新的列表
功能：排序
参数：
    iterable 可迭代的数据（容器类型数据，range数字序列，迭代器）
    reverse 可选，是否反转，默认为False不反转，True反转
    key 可选，函数，可以是自定义函数，也可以是内置函数
返回值：排序后的结果
"""
arr = [3, 8, -1, 9, 10]
res = sorted(arr)
print(res)  # （默认）从小到大排序
res = sorted(arr, reverse=True)
print(res)  # 从大到小排序

arr2 = [-2, -5, 5, -3, 3]
res = sorted(arr2, key=abs, reverse=True)
print(res)  # 先计算每个数字的绝对值，然后根据绝对值从小到大或从大到小进行排序


# def func(num):
#     return num - 1


arr3 = (-10, 6, 9, 4, 5)
res = sorted(arr3, key=lambda x: x - 1)  # 使用自定义函数
# res = sorted(arr3, key=func)  # 使用自定义函数
print('自定义函数：', res)

# 结果
[-1, 3, 8, 9, 10]
[10, 9, 8, 3, -1]
[-5, 5, -3, 3, -2]
自定义函数： [-10, 4, 5, 6, 9]

7. map（）函数

"""
map() 函数
功能：对传入的可迭代数据中的每个元素进行处理，返回一个新的迭代器
参数：
    func 函数 自定义函数|内置函数
    iterable： 可迭代的数据
返回值：一个新的迭代器
"""
var1 = ['1', '2', '3', '4']  # ==> [1, 2, 3, 4]
print("原数据：", var1)
res = map(int, var1)
print("新数据：", list(res))

var2 = [1, 2, 3, 4]
print("原数据：", var2)
res = map(lambda x: x**2, var2)  # 求每个数的平方
print("新数据：", list(res))

# 结果
原数据： ['1', '2', '3', '4']
新数据： [1, 2, 3, 4]
原数据： [1, 2, 3, 4]
新数据： [1, 4, 9, 16]

8. reduce（）函数

"""
reduce(func, *iterable) 函数
功能：每一次从iterable拿出两个函数，放入到func函数中进行处理，得出计算结果然后把计算结果
     和iterable中的第三个元素放入到func函数中继续运算，得出的结果继续与后面的元素继续运算，以此类推
参数：
    func： 内置函数|自定义函数
    iterable： 可迭代的数据
返回值：最终的运算处理结果
注意：使用reduce函数时，需要导入，输入 from functools import reduce
"""

from functools import reduce
"""
5 2 1 1
5 * 10 + 2 = 52
52 * 10 + 1 = 521
521 * 10 + 1 = 5211
"""


def func(x, y):
    return x*10+y


var = [5, 2, 1, 1]
res = reduce(func, var)
print(res, type(res))  # 实现四个数字的拼接

# 运行结果
5211 

9. filter（）函数

"""
filter(func, iterable)
功能： 过滤数据，把iterable中的每个元素拿到func函数中进行处理，如果返回True，则保留该数据，返回False则丢弃这个数据
参数: func  自定义函数
     iterable: 可迭代的数据
返回值：保留下来的数据组成的 迭代器
"""

# 要求保留所有的偶数，丢弃奇数
var = [1, 2, 3, 4, 5, 6, 7, 8, 9]

res = filter(lambda x: True if x % 2 == 0 else False, var)  # 如果能被2整除，则保留
print(list(res))

# 结果
[2, 4, 6, 8]