Pwner's Blog

能全力以赴不尽力而为

0%

Python 基础知识提纲

关于 Python 基础的种种。

Python 开发环境安装

  • Python 解释器
    • 解释器的作用
    • 解释器的种类
      • CPython:C 语言开发的解释器,应用最为广泛。
      • IPython:基于 CPython 的一种交互式解释器。
      • 其他解释器
        • PyPy:基于 Python 语言开发的解释器。
        • JPython:运行在 Java 平台的解释器,直接把 Python 代码编译成 Java 字节码执行。
        • IronPython:运行在微软 dotnet 平台上的 Python 解释器,可以直接把 Python 代码编译成 dotnet 字节码执行。
  • Python 常用 IDE:
    • Pycharm
      • 修改外观
        1. 字体,字号,行距,配色(主题)
        2. 开启 Ctrl+滚轮方所编辑器字体
        3. 关闭弱警告等提示(可选)
      • 修改解释器
      • 项目管理
    • VS Code

Python 基础知识

  • 注释
  • 变量
    • 命名规范:
      • 数字字母下划线;
      • 非数字开头;
      • 非内置关键字;
      • 大小写敏感。
    • 命名习惯:
      • 见名知义
      • 大驼峰:MyName
      • 小驼峰:myName
      • 下划线:my_name
  • 调试
    • 断点
    • Debug

Python 数据类型和常用操作

数据类型

输出

格式化符号

格式符号 转换
==%s== 字符串
==%d== 有符号的十进制整数
==%f== 浮点数
%c 字符
%u 无符号十进制整数
%o 八进制整数
%x 十六进制整数(小写 ox)
%X 十六进制整数(大写 OX)
%e 科学计数法(小写’e’)
%E 科学计数法(大写’E’)
%g % f 和 % e 的简写
%G % f 和 % E 的简写

技巧

  • %06d,表示输出的整数显示位数,不足以 0 补全,超出当前位数则原样输出
  • %.2f,表示小数点后显示的小数位数。
实例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
age = 18 
name = 'TOM'
weight = 75.5
student_id = 1

# 我的名字是TOM
print('我的名字是%s' % name)

# 我的学号是0001
print('我的学号是%4d' % student_id)

# 我的体重是75.50公斤
print('我的体重是%.2f公斤' % weight)

# 我的名字是TOM,今年18岁了
print('我的名字是%s,今年%d岁了' % (name, age))

# 我的名字是TOM,明年19岁了
print('我的名字是%s,明年%d岁了' % (name, age + 1))

# 我的名字是TOM,明年19岁了
print(f'我的名字是{name}, 明年{age + 1}岁了')

f 表达式

f - 格式化字符串是 Python3.6 新增的格式化方法,简单易读。

1
f'{表达式}'

转义字符

  • \n:换行。
  • \t:制表符,一个 tab 键(4 个空格)的距离。

结束符

想一想,为什么两个 print 会换行输出?

1
print('输出的内容', end="\n")

在 Python 中,print (), 默认自带 end="\n" 这个换行结束符,所以导致每两个 print 直接会换行展示,用户可以按需求更改结束符。

输入

注意

  • 当程序执行到 input,等待用户输入,输入完成之后才继续向下执行。
  • 在 Python 中,input 接收用户输入后,一般存储到变量,方便使用。
  • 在 Python 中,input 会把接收到的任意用户输入的数据都当做字符串处理。
1
input('请输入您的密码:')

数据类型转换

函数 说明
int(x [,base ]) 将 x 转换为一个整数
float(x ) 将 x 转换为一个浮点数
complex(real [,imag ]) 创建一个复数,real 为实部,imag 为虚部
str(x) 将对象 x 转换为字符串
repr(x) 将对象 x 转换为表达式字符串
eval(str) 用来计算在字符串中的有效 Python 表达式,并返回一个对象
tuple(s) 将序列 s 转换为一个元组
list(s) 将序列 s 转换为一个列表
chr(x) 将一个整数转换为一个 Unicode 字符
ord(x) 将一个字符转换为它的 ASCII 整数值
hex(x) 将一个整数转换为一个十六进制字符串
oct(x) 将一个整数转换为一个八进制字符串
bin(x) 将一个整数转换为一个二进制字符串

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# str() -- 转换成字符串类型
num2 = 10
print(type(str(num2)))

# tuple() -- 将一个序列转换成元组
list1 = [10, 20, 30]
print(tuple(list1))
print(type(tuple(list1)))


# list() -- 将一个序列转换成列表
t1 = (100, 200, 300)
print(list(t1))
print(type(list(t1)))

# eval() -- 将字符串中的数据转换成Python表达式原本类型
str1 = '10'
str2 = '[1, 2, 3]'
str3 = '(1000, 2000, 3000)'
print(type(eval(str1)))
print(type(eval(str2)))
print(type(eval(str3)))

运算符

《Python 运算符》

Python 基本语句

条件语句

  • if 语句语法
1
2
if 条件:
条件成立执行的代码
  • if…else…
1
2
3
4
if 条件:
条件成立执行的代码
else:
条件不成立执行的代码
  • 多重判断
1
2
3
4
5
6
if 条件1:
条件1成立执行的代码
elif 条件2:
条件2成立执行的代码
else:
以上条件都不成立执行的代码
  • if 嵌套
1
2
3
4
5
if 条件1:
条件1成立执行的代码
if 条件2:
条件2成立执行的代码
....

循环语句

  • 循环的作用:控制代码重复执行
  • while 语法
1
2
3
4
while 条件:
条件成立重复执行的代码1
条件成立重复执行的代码2
......
  • while 循环嵌套语法
1
2
3
4
5
6
while 条件1:
条件1成立执行的代码
......
while 条件2:
条件2成立执行的代码
......
  • for 循环语法
1
2
3
4
for 临时变量 in 序列:
重复执行的代码1
重复执行的代码2
......
  • break 退出整个循环
  • continue 退出本次循环,继续执行下一次重复执行的代码
  • else
    • while 和 for 都可以配合 else 使用
    • else 下方缩进的代码含义:当循环正常结束后执行的代码
    • break 终止循环不会执行 else 下方缩进的代码
    • continue 退出循环的方式执行 else 下方缩进的代码

循环实例

1
2
3
4
5
6
7
8
str1 = 'itheima'
for i in str1:
if i == 'e':
print('遇到e不打印')
break ###退出整个for循环
print(i)
else:
print('循环正常结束之后执行的代码')
1
2
3
4
5
6
7
8
str1 = 'itheima'
for i in str1:
if i == 'e':
print('遇到e不打印')
continue ###退出if循环
print(i)
else:
print('循环正常结束之后执行的代码')

Python 数据序列

集合(set)

无序的不重复元素序列

🔔建

创建集合使用 {}set(), 但是如果要创建空集合只能使用 set(),因为 {} 用来创建空字典。

方法 作用 举例
{xx,xx,xx,xx} 创建非空集合 s1 = {10, 20, 30, 40, 50}
set() 创建集合 s3 = set(‘abcdefg’)
s4 = set()
{} 创建空字典 s5 = {}
print(type(s5)) # dict

🔔增

集合天然有去重功能

s1 = {10, 20, 30, 40, 50}

函数 作用 举例
add() 追加一个元素 s1.add(300)
update() 追加一个序列 s1.update([100,500])

🔔删

s1 = {10, 20, 30, 40, 50}

函数 作用 举例
remove() 删除数据,如果被删除数据不存在则报错 s1.remove(10)
discard() 删除数据,如果数据不存在也不报错 s1.discard()
pop() 随机删除集合中的某个数据,并返回被删除数据 del_num = s1.pop()
print(del_num)
print(s1)

🔔其他函数

s1 = {10, 20, 30, 40, 50}

Python 表达式 作用 举例
in / not in 判断某个元素是否在集合中,返回真假 10 in s1
len() 取集合长度 len(s1)

列表(list)

Python 中最基本的数据结构

🔔建

  • list = []

🔔访问元素

根据下标访问
  • list[index]
其他函数
  • index ()**:返回指定数据 ** 所在位置的下标。查询的数据不存在则报错。
1
列表序列.index(数据, 开始位置下标, 结束位置下标)
1
2
3
name_list = ['Tom', 'Lily', 'Rose']

print(name_list.index('Lily', 0, 2))
  • **count ()**:统计指定数据在当前列表中出现的次数。
1
2
3
name_list = ['Tom', 'Lily', 'Rose']

print(name_list.count('Lily'))

🔔其他函数

Python 表达式 结果 描述
3 in (1, 2, 3) True 元素是否存在
** 元组序列.index (** 数据,开始位置下标,结束位置下标) 下标或报错 查找元素的位置
len((1, 2, 3)) 3 计算元素个数
max(‘5’,’4’,’8’) 8 取最大值
min(‘5’,’4’,’8’) 4 取最小值
(1, 2, 3) + (4, 5, 6) (1, 2, 3, 4, 5, 6) 连接
(‘Hi!’,) *** 4** (‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’) 复制
for x in (1, 2, 3): print (x,) 1 2 3 迭代
tuple(**iterable)** tuple1=tuple(list1) 例如,将列表转换成元组

🔔增

  • **append ()**:可以追加元素或序列,当追加的是序列的时候,序列作为一个新的元素被追加到原来的列表中
1
2
3
4
5
6
name_list = ['Tom', 'Lily', 'Rose']

name_list.append(['xiaoming', 'xiaohong'])

# 结果:['Tom', 'Lily', 'Rose', ['xiaoming', 'xiaohong']]
print(name_list)
  • **extend ()**:列表追加数据,若数据时序列,则将序列拆分成元素逐一添加
1
2
3
4
5
6
name_list = ['Tom', 'Lily', 'Rose']

name_list.extend(['xiaoming', 'xiaohong'])

# 结果:['Tom', 'Lily', 'Rose', 'xiaoming', 'xiaohong']
print(name_list)
  • **insert ()**:指定位置新增数据
1
2
3
4
5
6
7
8
列表序列.insert(位置下标, 数据)

name_list = ['Tom', 'Lily', 'Rose']

name_list.insert(1, 'xiaoming')

# 结果:['Tom', 'xiaoming', 'Lily', 'Rose']
print(name_list)

🔔删

  • del
    • del 列表名 删除整个列表
    • del 列表名[index] 删除指定元素
  • pop()
    • list.pop(index) 删除指定下标的数据 (默认为最后一个),并返回该数据
1
2
3
4
5
6
7
8
9
name_list = ['Tom', 'Lily', 'Rose']

del_name = name_list.pop(1)

# 结果:Lily
print(del_name)

# 结果:['Tom', 'Rose']
print(name_list)
  • remove()
    • list.remove('元素') 删除列表中某个数据的第一匹配项
1
2
3
4
5
6
name_list = ['Tom', 'Lily', 'Rose']

name_list.remove('Rose')

# 结果:['Tom', 'Lily']
print(name_list)
  • **clear ()**:清空列表
1
2
3
4
name_list = ['Tom', 'Lily', 'Rose']

name_list.clear()
print(name_list) # 结果: []

元组(tuple)

元组与列表(list)类似,不同之处在于:

①元组的元素不能修改;

②组使用小括号 (),列表使用方括号 [].

🔔建

1
2
3
4
5
6
7
8
#新建一个空元组
tup1 = ()

#新建一个仅含一个元素的元组,逗号不能省,否则会被定义为原始的类型
tup2 = (46,)

#print结果为str
tup3 = ('hello')

🔔访问元素

与列表类似。

1
2
3
4
5
#访问多个元素,“左闭右开”
[左边界:右边界]

#某个值开始后面所有元素(右边界省略)
[左边界:]

🔔其他函数

Python 表达式 结果 描述
3 in (1, 2, 3) True 元素是否存在
** 元组序列.index (** 数据,开始位置下标,结束位置下标) 下标或报错 查找元素的位置
len((1, 2, 3)) 3 计算元素个数
max(‘5’,’4’,’8’) 8 取最大值
min(‘5’,’4’,’8’) 4 取最小值
(1, 2, 3) + (4, 5, 6) (1, 2, 3, 4, 5, 6) 连接
(‘Hi!’,) *** 4** (‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’) 复制
for x in (1, 2, 3): print (x,) 1 2 3 迭代
tuple(**iterable)** tuple1=tuple(list1) 例如,将列表转换成元组

🔔拼接

1
2
3
4
5
6
7
8
9
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')

# 以下修改元组元素操作是非法的。
# tup1[0] = 100

# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)

🔔删

元组内的元素不可被删除

  • del
1
2
3
4
tup = ('Google', 'pwner', 1997, 2000)

del tup
#删除后tup对象未定义

⚠️关于元组不可变

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
tup = ('p', 'w', 'n', 'e', 'r')
tup[0] = 'g'

# 不支持修改元素
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

# 查看内存地址
id(tup)
4440687904
tup = (1,2,3)

# 内存地址不一样了
id(tup)
4441088800

字典(dict)

🔔建

1
2
3
4
5
6
7
# 有数据字典
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

# 空字典
dict2 = {}

dict3 = dict()

🔔访问

访问某个键值
1
2
3
4
5
6
7
d = {key1 : value1, key2 : value2, key3 : value3 }

#访问key1的值
value = d['key1']

#访问key1的值
value2 = dict1.get('key1')
访问所有键名
  • keys()
1
2
3
4
5
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

print(dict1.keys())

# dict_keys(['name', 'age', 'gender'])
访问所有键值
  • values()
1
2
3
4
5
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

print(dict1.values())

# dict_values(['Tom', 20, '男'])
访问所有键值对
1
2
3
4
5
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

print(dict1.items())

# dict_items([('name', 'Tom'), ('age', 20), ('gender', '男')])

🔔遍历

遍历键名
1
2
3
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for key in dict1.keys():
print(key)
遍历键值
1
2
3
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for value in dict1.values():
print(value)
遍历键值对
1
2
3
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for item in dict1.items():
print(item)
格式化遍历键值对
1
2
3
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for key, value in dict1.items():
print(f'{key} = {value}')

🔔改

1
d['key1'] = 新值

🔔删

1
2
3
4
5
6
7
dict = {'Name': 'Pwner', 'Age': 7, 'Class': 'First'}

del dict['Name'] # 删除键 'Name'

dict.clear() # 清空字典

del dict # 删除字典

⚠️注意

  • 字典中键不能重复,若重复只保留最后一个键值对
  • 字典可变,键不可变。(键不可为列表类型)

数据序列的公共操作

详见《Python 序列公共操作》

推导式

可以理解为数学中,给出通项公式,快速生成一个数列。

详见《推导式》

Python 函数

封装代码,高效的代码重用

函数使用步骤

  1. 定义函数
1
2
3
4
def 函数名():
代码1
代码2
...
  1. 调用函数
1
函数名()

函数的说明文档

保存函数解释说明的信息,便于在大型项目中方便直接调取说明文档。

  • 写法
1
2
3
4
5
6
7
8
9
def 函数名():
""" 函数说明文档 """

def sum_num(a, b):
""" 求和函数 """
return a + b

#调取sum_num()函数的说明文档
help(sum_num)

变量作用域

  • 局部变量
  • 全局变量(较少使用,一般传参实现变量的复用)

函数的参数

函数调用的时候可以传入真实数据,增大函数的使用的灵活性

  • 形参:函数定义时书写的参数 (非真实数据)
  • 实参:函数调用时书写的参数 (真实数据)
1
2
3
4
5
def sum_num(形参1, 形参2):
""" 求和函数 """
return a + b

sun_num(实参1,实参2)

位置参数

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

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

1
2
3
4
5
def user_info(name, age, gender):
print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')


user_info('TOM', 20, '男')

关键字参数

函数调用,通过 “键 = 值” 形式加以指定。可以让函数更加清晰、容易使用。

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

1
2
3
4
5
6
def user_info(name, age, gender):
print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')


user_info('Rose', age=20, gender='女')
user_info('小明', gender='男', age=16)

缺省参数

缺省参数也叫默认参数,用于定义函数,为参数提供默认值,调用函数时可不传该默认参数的值(注意:所有位置参数必须出现在默认参数前,包括函数定义和调用)。

1
2
3
4
5
6
def user_info(name, age, gender='男'):
print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')


user_info('TOM', 20)
user_info('Rose', 18, '女')

不定长参数

不定长参数也叫可变参数。用于不确定调用的时候会传递多少个参数 (不传参也可以) 的场景。此时,可用包裹 (packing) 位置参数,或者包裹关键字参数,来进行参数传递,会显得非常方便。可变参数传递就是一个组包的过程。

  • 包裹位置传递

收集所有位置参数,返回一个元组

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

1
2
3
4
5
6
7
8
def user_info(*args):
print(args)


# ('TOM',)
user_info('TOM')
# ('TOM', 18)
user_info('TOM', 18)
  • 包裹关键字传递

收集所有关键字参数,返回一个字典

1
2
3
4
5
6
def user_info(**kwargs):
print(kwargs)


# {'name': 'TOM', 'age': 18, 'id': 110}
user_info(name='TOM', age=18, id=110)

拆包

  • 拆包:元组
1
2
3
4
5
6
7
def return_num():
return 100, 200


num1, num2 = return_num()
print(num1) # 100
print(num2) # 200
  • 拆包:字典
1
2
3
4
5
6
7
8
9
dict1 = {'name': 'TOM', 'age': 18}
a, b = dict1

# 对字典进行拆包,取出来的是字典的key
print(a) # name
print(b) # age

print(dict1[a]) # TOM
print(dict1[b]) # 18

函数的返回值

1
2
3
4
def log():
print('hello')
return 1 #退出函数
return 2 #不执行此行

多个返回值

  1. return a, b 写法,返回多个数据的时候,默认是元组类型。
  2. return 后面可以连接列表、元组或字典,以返回多个值。
1
2
3
4
5
6
def return_num():
return 1, 2


result = return_num()
print(result) # (1, 2)

多函数程序执行流程

  • 共用全局变量
  • 返回值作为参数传递

引用

Python 中,数据的传递都是通过引用来实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# 1. int类型
a = 1
b = a

print(b) # 1

print(id(a)) # 140708464157520
print(id(b)) # 140708464157520

a = 2
print(b) # 1,说明int类型为不可变类型

print(id(a)) # 140708464157552,此时得到是的数据2的内存地址
print(id(b)) # 140708464157520


# 2. 列表
aa = [10, 20]
bb = aa

print(id(aa)) # 2325297783432
print(id(bb)) # 2325297783432


aa.append(30)
print(bb) # [10, 20, 30], 列表为可变类型

print(id(aa)) # 2325297783432
print(id(bb)) # 2325297783432
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def test1(a):
print(a)
print(id(a))

a += a

print(a)
print(id(a))


# int:计算前后id值不同
b = 100
test1(b)

# 列表:计算前后id值相同
c = [11, 22]
test1(c)

可变类型与不可变类型

所谓可变类型与不可变类型是指:数据能够直接进行修改,如果能直接修改那么就是可变,否则是不可变.

  • 可变类型
    • 列表
    • 字典
    • 集合
  • 不可变类型
    • Number(整型,浮点型)
    • 字符串
    • 元组

lambda 表达式

匿名函数。如果一个函数有一个返回值,并只有一句代码,那么可以使用 lambda 简化。

lambda 本质上还是一个函数,所以同样遵守函数的参数和返回值的规定,即可以拥有 0 个或者多个参数,只有一个返回值。

语法

1
lambda 参数:表达式

实例

1
2
3
4
5
6
7
8
9
10
11
12
#编写一个函数实现两数的相加
def add(a,b):
return a+b

print(add(2,3))



#使用lambda表达式来简化上述函数
fn1 = lambda a,b:a+b
print(fn1) #输出fn1的内存地址
print(fn1(1,2)) #调用lambda表达式,计算2+3

lambda 的不同参数形式

1. 无参数
1
2
fn1 = lambda:100
print(fn1())
2. 一个参数
1
2
fn1 = lambda a:a
print(fn1('hello world'))
3. 默认参数
1
2
fn1 = lambda a, b, c=100:a + b + c
print(fn1(10, 20))
4. 可变参数:*args

不定长位置参数

注意:这里的可变参数传入到 lambda 之后,返回值为元组。

1
2
fn1 = lambda *args:args
print(fn1(10, 20, 30))
5. 可变参数:**kwargs

不定长关键字参数

1
2
fn1 = lambda **kwargs:kwargs
print(fn1(name='python', age=20))

lambda 的应用

1. 带判断的 lambda
1
2
fn1 = lambda a, b: a if a > b else b
print(fn1(1000, 500))
2. 列表数据按字典 key 的值排序
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
students = [
{'name': 'TOM', 'age': 20},
{'name': 'ROSE', 'age': 19},
{'name': 'Jack', 'age': 22}
]

# 按name值升序排列
students.sort(key=lambda x: x['name'])
print(students)

# 按name值降序排列
students.sort(key=lambda x: x['name'], reverse=True)
print(students)

# 按age值升序排列
students.sort(key=lambda x: x['age'])
print(students)

高阶函数

把函数作为参数传入,这样的函数称为高阶函数,高阶函数是函数式编程的体现。函数式编程就是指这种高度抽象的编程范式,所以具有开发速度快的特点。

实例

在 Python 中,abs() 函数可以完成对数字求绝对值计算。

1
abs(-10)  # 10

round() 函数可以完成对数字的四舍五入计算。

1
2
round(1.2)  # 1
round(1.9) # 2

需求:任意两个数字,按照指定要求整理数字后再进行求和计算。

  • 方法 1
1
2
3
4
5
6
def add_num(a, b):
return abs(a) + abs(b)


result = add_num(-1, 2)
print(result) # 3
  • 方法 2
1
2
3
4
5
6
def sum_num(a, b, f):
return f(a) + f(b)


result = sum_num(-1, 2, abs)
print(result) # 3

注意:两种方法对比之后,发现,方法 2 的代码会更加简洁,函数灵活性更高。

内置高阶函数

🔔map()

map(func, lst),将传入的函数变量 func 作用到 lst 变量的每个元素中,并将结果组成新的列表 (Python2)/ 迭代器 (Python3) 返回。

需求:计算 list1 序列中各个数字的 2 次方。

1
2
3
4
5
6
7
8
9
10
11
list1 = [1, 2, 3, 4, 5]


def func(x):
return x ** 2


result = map(func, list1)

print(result) # <map object at 0x0000013769653198>
print(list(result)) # [1, 4, 9, 16, 25]
🔔reduce()

reduce(func,lst),其中 func 必须有两个参数。每次 func 计算的结果继续和序列的下一个元素做累积计算。

注意:reduce () 传入的参数 func 必须接收 2 个参数。

需求:计算 list1 序列中各个数字的累加和。

1
2
3
4
5
6
7
8
9
10
11
12
import functools

list1 = [1, 2, 3, 4, 5]


def func(a, b):
return a + b


result = functools.reduce(func, list1)

print(result) # 15
🔔filter()

filter(func, lst) 函数用于过滤序列,过滤掉不符合条件的元素,返回一个 filter 对象。如果要转换为列表,可以使用 list() 来转换。

1
2
3
4
5
6
7
8
9
10
11
list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]


def func(x):
return x % 2 == 0


result = filter(func, list1)

print(result) # <filter object at 0x0000017AF9DC3198>
print(list(result)) # [2, 4, 6, 8, 10]
如果文章对你有用,可以请我喝杯咖啡~
  • 本文作者: Pwner
  • 本文链接: https://pwner.cn/posts/b89beed2.html
  • 版权声明: 本博客所有文章除特别声明外,均采用 BY-NC-SA 许可协议。转载请注明出处!