Python 中的一些内置方法

enumerate()

enumerate 意为枚举、列举。对于一个可迭代的对象，enumerate 将它变成一个索引序列，返回一个枚举类型的对象。

seq = ['one', 'two', 'three', 127]
s1 = list(enumerate(seq))
s2 = list(enumerate(seq, start=1))
print(s1)
print(s2)

# 输出结果
[(0, 'one'), (1, 'two'), (2, 'three'), (3, 127)]
[(1, 'one'), (2, 'two'), (3, 'three'), (4, 127)]

filter()

用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。

filter(function, iterable)

# function -- 判断函数。
# iterable -- 可迭代对象。

该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

def is_odd(n):
    return n % 2 == 1
 
newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(newlist)

[1, 3, 5, 7, 9]

lambda

匿名函数 lambda 可以接收任意多个参数 (包括可选参数) ，并且返回单个表达式的值。

1. 将lambda函数赋值给一个变量，通过这个变量间接调用该lambda函数。

sum = lambda x, y: x + y
print(sum(1, 2))

3

2. 将lambda函数作为参数传递给其他函数，部分Python内置函数接收函数作为参数。

s = list(filter(lambda x: x%2,range(10)))
print(s)
# 此时lambda函数用于指定过滤列表元素的条件。

[1, 3, 5, 7, 9]

3. 将lambda函数作为其他函数的返回值，返回给调用者。

return lambda x, y: x+y

4. 将 lambda 函数赋值给其他函数，从而将其他函数用该 lambda 函数替换。

例如，为了把标准库time中的函数sleep的功能屏蔽(Mock)，我们可以在程序初始化时调用：time.sleep=lambda x:None。这样，在后续代码中调用time库的sleep函数将不会执行原有的功能。例如，执行time.sleep(3)时，程序不会休眠3秒钟，而是什么都不做。

5. 将if…else语句缩减为单一的条件表达式。

s = lambda x: "yes" if x == 1 else "no"

print(s(0))

print(s(1))

no
yes

列表推导式（List Comprehension)

列表推导式（List Comprehension）是一种在一行代码中创建列表的简洁而强大的方式。它允许你通过在一个表达式中对可迭代对象进行迭代，并根据条件生成新的列表。

基本的列表推导式的语法如下：

Copy code
new_list = [expression for item in iterable if condition]

其中：

• expression: 是一个表达式，用于定义列表中的每个元素。
• item: 是可迭代对象中的每个元素。
• iterable: 是一个可迭代对象，例如列表、元组、字符串等。
• condition（可选）: 是一个条件，用于过滤要包含在新列表中的元素。

1. 列表解析式

l1 = [i * 2 for i in range(10)]
print(l1)

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

2. 筛选条件

l1 = [i * 2 for i in range(10) if i*2 > 10]
print(l1)

[12, 14, 16, 18]

3. 嵌套循环

l1 = ['A', 'B', 'C']
l2 = ['1', '2', '3']
l3 = [(m, n) for m in l1 for n in l2]
print(l3)

[('A', '1'), ('A', '2'), ('A', '3'), ('B', '1'), ('B', '2'), ('B', '3'), ('C', '1'), ('C', '2'), ('C', '3')]

4. 字典解析式

a = {'language1': 'python', 'language2': 'java', 'language3': 'c'}
b = {key: value for key, value in a.items() if key == 'language1'}
print(b)

{'language1': 'python'}

5. 集合解析式

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
b = {i for i in a if i > 5}
print(b)

{6, 7, 8, 9, 10}

去掉列表中的空字符内容

parts = [p for p in parts if p]

.join()

join 是字符串对象的一个方法，用于将序列（通常是字符串序列）中的元素连接成一个字符串。它的基本语法是：

separator.join(iterable)

其中：

• separator 是用于连接元素的字符串，也就是每个元素之间的分隔符。
• iterable 是一个可迭代对象，其中包含需要连接的元素。
• join 方法返回一个新的字符串，其中包含了通过指定的分隔符连接起来的元素。

例如，考虑以下示例：

words = ["apple", "banana", "orange"]
result = ", ".join(words)
print(result)

输出结果

apple, banana, orange

在这个例子中，", " 是分隔符，它将列表 words 中的字符串元素连接起来，形成一个新的字符串。

sorted()

函数对所有可迭代的对象进行排序操作。

sort 与 sorted 的区别
sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

sorted(iterable, key=None, reverse=False)


# 参数说明
# iterable -- 可迭代对象。
# key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
# reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

常规

print(sorted([5, 7, 6, 3, 4, 1, 2]))

[1, 2, 3, 4, 5, 6, 7]

接收一个key函数来实现自定义的排序，例如按绝对值大小排序。

print(sorted([36, 5, -12, 9, -21], key=abs))

[5, 9, -12, -21, 36]

字符串排序

print(sorted(['bob', 'about', 'Zoo', 'Credit']))

['Credit', 'Zoo', 'about', 'bob']

# 默认情况下，对字符串排序，是按照ASCII的大小比较的，由于'Z' < 'a'，结果，大写字母Z会排在小写字母a的前面。

key函数把字符串映射为忽略大小写排序

# 实际上就是先把字符串都变成大写（或者都变成小写），再比较。
print(sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower))

['about', 'bob', 'Credit', 'Zoo']

map()

map()是python的内置函数，会根据提供的函数对指定序列做映射。
语法：

map(func, iter, ...)

其中func为一个功能函数,iter表示可迭代参数序列。map()将把func作用于参数列表的每个元素上，并返回一个新的list列表。

def square(item: int)->int:
    return item*item


a = [1, 2, 3, 4]
b = map(square, a)
print(list(b))

以上将输出[1, 4, 9, 16]

func不仅只接收函数，同样可接收lambda表达式:

a = [1, 2, 3, 4]
b = map(lambda x: x*x, a)
print(list(b))

以上代码同样会输出[1, 4, 9, 16]

当函数需要多个参数列表时，直接按顺序进行填充即可

a = [1, 2, 3, 4]
b = [1, 2, 3, 4]
c = map(lambda x, y: x+y, a, b)
print(list(c))

以上代码将输出：[2, 4, 6, 8]

当各个参数列表的参数个数不一致时，python会取最短的那个进行截断

a = [1, 2, 3, 4]
b = [2, 3, 4]
b = map(lambda x, y: x*y, a, b)
print(list(b))

以上代码将输出：[2, 6, 12]

zip()

将多个可迭代对象（如列表、元组等）的元素按位置打包成元组的迭代器

返回元组的迭代器，其中第 i 个元组包含来自每个参数序列或可迭代对象的第 i 个元素。 当最短的输入迭代用完时，迭代器停止。 使用单个可迭代参数，它返回一个 1 元组的迭代器。 没有参数，它返回一个空的迭代器。

>>> a = ['a', 'b', 'c', 'd']
>>> b = ['1', '2', '3', '4']
>>> list(zip(a, b))
[('a', '1'), ('b', '2'), ('c', '3'), ('d', '4')]

在这个列表中，每个元素是一个tuple；对于第i个元组，它其中的内容是(a[i-1], b[i-1])。这样的操作，与压缩软件的“压缩”十分接近。如果我们继续在zip()中加入更多的参数，比如zip(a, b, c, d)，那么在将它转换成list之后，结果当然就是[(a[0], b[0], c[0], d[0]), (a[1], b[1], c[1], d[1]), ..., (a[n-1], b[n-1], c[n-1], d[n-1])]。

如果我们想从得到的“压缩”后的结果，还原成“压缩”前的几个列表，应该怎么做呢？
zip(args)这个函数，Python提供了一种逆操作。

# 已有
result = zip(a, b)
# 只要调用
origin = zip(*result)  #前面加*号，事实上*号也是一个特殊的运算符，叫解包运算符

1.同时遍历多个字典

字典是一种有顺序的集合。利用这个特性和zip，我们可以同时遍历多个字典：

>>> dict_one = {'name': 'Chen', 'last_name': 'Gong', 'school': 'CJLU'}
>>> dict_two = {'name': 'Fan', 'last_name': 'Gong', 'school': 'ZJLU'}
>>> for (k1, v1), (k2, v2) in zip(dict_one.items(), dict_two.items()):
...     print(k1, '->', v1)
...     print(k2, '->', v2)
...
name -> Chen
name -> Fan
last_name -> Gong
last_name -> Gong
school-> CJLU
school-> ZJLU

2.对多个元素同时进行排序

考虑一个场景：你正在处理一些学生的成绩，有这样两个列表：

names = ['Chen', 'Li', 'Fan']
scores = [98, 100, 85]  # 分数和名字是一一对应的

如果你想对它们进行排序，又不想破坏对应关系的话，就可以这样：

data = list(zip(names, scores))
data.sort()

print(data)

输出结果

[('Chen', 98), ('Fan', 85), ('Li', 100)]

如果要先对分数进行排序：

data = list(zip(scores, names))
data.sort()

print(data)

输出结果

[(85, 'Fan'), (98, 'Chen'), (100, 'Li')]

3.构建字典

回到上面处理学生成绩的场景：如果你想将两个列表合并起来，得到一个姓名-分数的字典，就可以：

stu = dict(zip(names, scores))

print(stu)

输出结果

{'Chen': 98, 'Li': 100, 'Fan': 85}

set()

python中，用set来表示一个无序不重复元素的序列。set的只要作用就是用来给数据去重。

可以使用大括号 { } 或者 set() 函数创建集合，但是注意如果创建一个空集合必须用 set() 而不是 { }，因为{}是用来表示空字典类型的

1.set集合的创建与使用

#1.用{}创建set集合
person ={"student","teacher","babe",123,321,123} #同样各种类型嵌套,可以赋值重复数据，但是存储会去重
print(len(person))  #存放了6个数据，长度显示是5，存储是自动去重.
print(person) #但是显示出来则是去重的
'''
5
{321, 'teacher', 'student', 'babe', 123}
'''
#空set集合用set()函数表示
person1 = set() #表示空set，不能用person1={}
print(len(person1))
print(person1)
'''
0
set()
'''
#3.用set()函数创建set集合
person2 = set(("hello","jerry",133,11,133,"jerru")) #只能传入一个参数，可以是list,tuple等 类型
print(len(person2))
print(person2)
'''
5
{133, 'jerry', 11, 'jerru', 'hello'}
'''

2.对字符串去重

#1.set对字符串也会去重，因为字符串属于序列。
str1 = set("abcdefgabcdefghi")
str2 = set("abcdefgabcdefgh")
print(str1,str2)
print(str1 - str2) #-号可以求差集
print(str2-str1)  #空值
#print(str1+str2)  #set里不能使用+号

输出结果

{'d', 'i', 'e', 'f', 'a', 'g', 'b', 'h', 'c'} {'d', 'e', 'f', 'a', 'g', 'b', 'h', 'c'}
{'i'}
set()

eval()

作用：将字符串转为python语句（就是去掉''），然后执行转化后的语句

1. 将字符串转换成表达式

a = 2
b = 1
print(eval('a+b'))

3

2. 字符串转换为列表

a = '[ [1, 2], [3, 4], [5, 6] ]'
print(type(a))
b = eval(a)
print(type(b))

<class ‘str’>
<class ‘list’>

还有字符串转换成元组，字符串转换成字典等，在此不展示。

星号（*）和双星号（**）的解包和打包

对函数传递的参数进行打包（成元组tuple或字典dictionary）和拆解（分解成单个元素），其中元组的打包和解包使用单星号‘*’，字典的打包和拆解使用’**’。

1. 函数的可变参数

打包，就是将传递给函数的任意多个（也可以是零个）非关键字参数/关键字参数打包成一个元组/字典（元组只能接收非关键字参数，字典只能接收关键字参数）。

当函数的参数前面有一个星号*的时候表示这是一个可变的位置参数，两个星号表示是可变的关键字参数。**

def foo(*args, **kwarg):
    for item in args:
        print(item)

    for k,v in kwarg.items():
        print(k, v)
    print(30*'=')


if __name__ == '__main__':
    foo(1, 2, 3, a=4, b=5)
    foo(2, 3, a=4, b=5, c=1)

1
2
3
a 4
b 5
==============================
2
3
a 4
b 5
c 1
==============================

这样我们可以传入任意个数的参数。

2. 解包/打散（unpack）参数

拆解，就是将传递给函数的一个列表、元组或字典拆分成独立的多个元素然后赋值给函数中的参变量（包括普通的位置参数，关键字参数，元组也即*非关键字参数，字典也即**关键字参数）。

在解字典时会有两种解法，一种使用*解，解出来传给函数的只有键值（.key）另一种是用**解，解出来的是字典的每一项。

星号*把序列/集合解包（unpack）成位置参数，两个星号**把字典解包成关键字参数。

def foo(*args, **kwarg):
    for item in args:
        print(item)
    for k, v in kwarg.items():
        print(k, v)
    print('*' * 50)


if __name__ == '__main__':
    v = (1, 2, 4)
    v2 = [11, 15, 23]
    d = {'a': 1, 'b': 12}
    foo(v, d)
    foo(*v, **d)
    foo(v2, d)
    foo(*v2, *d)

(1, 2, 4)
{‘a’: 1, ‘b’: 12}

---

1
2
4
a 1
b 12

---

[11, 15, 23]
{‘a’: 1, ‘b’: 12}

---

11
15
23
a
b

---

上面的示例中如果v、v2、d没有加星号那么就当成了一个参数传递给了函数，如果加了星号那么就会解包后传递给函数。

foo(*d, **d)等价于foo(1, 2, 4, a=1, b=12)。

3. 几个注意点

可变位置参数*args是一个元组，是不可修改的。

def foo(*args): 
	args[0] = 5
	
 foo(1, 2, 3)

Traceback (most recent call last):
File “C:/Users/chenh/Desktop/Opencv/learning/learning_cv.py”, line 53, in
foo(1, 2, 3)
File “C:/Users/chenh/Desktop/Opencv/learning/learning_cv.py”, line 50, in foo
args[0] = 5
TypeError: ‘tuple’ object does not support item assignment

def foo(*args):
    args[0] = 5


l = [1, 2, 3]
foo(*l)

Traceback (most recent call last):
File “C:/Users/chenh/Desktop/Opencv/learning/learning_cv.py”, line 54, in
foo(*l)
File “C:/Users/chenh/Desktop/Opencv/learning/learning_cv.py”, line 50, in foo
args[0] = 5
TypeError: ‘tuple’ object does not support item assignment

无论我们怎么传入参数，args都是一个tuple类型，不能进行修改。
对于字典类型的如果只使用一个型号*那么传入的只是字典的键。

>>> def foo2(*args, **kwarg):
...     print args, kwarg
...
>>> 
>>> d = {'a':1, 'b':2, 'c':3}
>>> foo2(*d)
('a', 'c', 'b') {}
>>> foo2(**d)
() {'a': 1, 'c': 3, 'b': 2}

instance()

isinstance() 是 Python 内建函数之一，用于检查一个对象是否是指定类或类型的实例。其基本语法如下：

isinstance(object, classinfo)

其中：

• object 是要检查的对象。
• classinfo 是一个类或类型，或者是一个包含类或类型的元组。如果 object 是 classinfo 的实例，isinstance() 返回 True；否则返回 False。

例如，下面的代码演示了 isinstance() 的使用：

x = 5
y = "hello"
z = [1, 2, 3]

print(isinstance(x, int))    # True，x是int类型的实例
print(isinstance(y, str))    # True，y是str类型的实例
print(isinstance(z, list))   # True，z是list类型的实例

print(isinstance(x, (int, float)))  # True，x是int或float类型的实例
print(isinstance(y, (int, float)))  # False，y不是int或float类型的实例

在类继承的情况下，isinstance() 还可以检查一个对象是否是某个基类或其派生类的实例。例如：

class Animal:
    pass

class Dog(Animal):
    pass

dog_instance = Dog()

print(isinstance(dog_instance, Dog))    # True，dog_instance是Dog类型的实例
print(isinstance(dog_instance, Animal)) # True，dog_instance是Animal类型的实例

这对于在编写代码时进行类型检查或执行多态操作非常有用。