Python进阶（更新中）

typing

Python的typing模块是Python 3.5版本引入的一个标准库，它提供了一种在Python代码中显式声明类型的方式，可以帮助开发人员更好地理解和使用Python的类型系统。
使用typing模块，您可以在函数、类、变量等地方添加类型注解，以声明您期望的类型。类型注解不仅可以提高代码的可读性和可维护性，还可以帮助开发人员使用类型检查工具发现潜在的错误和代码的不一致性。
下面是一些使用typing模块的示例：

from typing import List, Dict, Tuple

def greet(name: str) -> str:
    return 'Hello ' + name
    
class Person:
    def __init__(self, name: str, age: int) -> None:
        self.name = name
        self.age = age
    def say_hello(self, other_person: 'Person') -> None:
        print(f'Hello {other_person.name}! My name is {self.name} and I am {self.age} years old.')
        
people: Dict[str, Person] = {'Alice': Person('Alice', 25), 'Bob': Person('Bob', 30)}
names: List[str] = ['Alice', 'Bob']
tuples: Tuple[str, int] = ('Alice', 25)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

在上面的示例中，我们使用了typing模块中的List、Dict、Tuple等类型注解来声明变量类型。同时，我们还使用了str和int等内置类型注解来声明函数和类中的参数类型。通过这种方式，我们可以在类型检查工具中更好地了解代码的类型情况，并帮助发现潜在的错误。
需要注意的是，虽然Python的类型注解可以提高代码的可读性和可维护性，但它们并不会强制执行类型检查。因此，如果您在Python中使用了类型注解，最好使用类型检查工具来确保它们的正确性。

isinstance

isinstance是Python中的一个内建函数，用于检查一个对象是否是一个已知的类型，或者是这个类型的子类。这个函数返回一个布尔值，如果对象是指定类型或其子类的实例，那么结果为True，否则结果为False。
函数的基本格式是：

isinstance(object, type)
1

这里，object是你要检查的对象，而type可以是类型或类型元组。
下面是一些具体的例子：

print(isinstance('hello', str))  # 输出：True
print(isinstance(123, int))  # 输出：True
print(isinstance([1, 2, 3], list))  # 输出：True
print(isinstance((1, 2, 3), tuple))  # 输出：True
print(isinstance(123, float))  # 输出：False
1
2
3
4
5

如果你检查的object是None，那么isinstance函数会返回True，只要type不是type(None)。例如：

print(isinstance(None, int))  # 输出：False
print(isinstance(None, type(None)))  # 输出：True
1
2

此外，如果你传递一个类型元组给isinstance，它将检查object是否属于这个类型集合。例如：

print(isinstance((1, 2, 'hello'), (int, str)))  # 输出：True
1

这里，元组(1, 2, ‘hello’)是int和str的实例，所以对isinstance的返回是True。
总的来说，isinstance函数是一个非常有用的工具，可以帮助你编写更灵活的代码，特别是当你需要处理多种类型的数据时。

迭代器和生成器

迭代器和生成器是Python中非常重要的概念，是Python对迭代和生成序列的强大支持。

迭代器(Iterator)

迭代器是一种可以记住遍历的位置的对象。Python的很多内置类型，如列表、元组、字典等都支持迭代。我们也可以通过定义类来实现一个自定义的迭代器。
定义一个迭代器需要实现两个方法，iter() 和 next()。
iter() 方法返回迭代器对象本身。如果类中定义了这个方法，那么它就可以用在for…in…循环中。
next() 方法返回容器的下一个元素。在没有后续元素时，应该抛出 StopIteration 异常。
下面是一个简单的迭代器实现示例：

class MyIterator:
    def __init__(self, start, end):
        self.current = start
        self.end = end
    def __iter__(self):
        return self
    def __next__(self):
        if self.current > self.end:
            raise StopIteration
        else:
            self.current += 1
            return self.current - 1
my_iter = MyIterator(0, 5)
for i in my_iter:
    print(i)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

生成器(Generator)

生成器是创建迭代器的简单而强大的工具。它们使用一个函数来定义一个迭代器，这个函数使用yield语句返回每个值，而不是使用return语句。每次从生成器中请求一个值时，函数会从之前停止的地方开始执行，直到遇到一个新的yield语句，然后返回该语句后面的值。如果函数执行完毕，生成器就结束了。
下面是一个简单的生成器实现示例：

def my_generator():
    for i in range(1, 6):
        yield i * 2
for num in my_generator():
    print(num)
1
2
3
4
5

在这个例子中，每次调用my_generator()函数时，它都会从开始处执行，直到遇到yield语句，然后返回该语句的值。在下一次调用时，它将从上一次yield语句后的下一个语句开始执行，直到再次遇到yield语句。它将一直这样做，直到函数结束并抛出StopIteration异常。

map

Python的map()函数是一个内置的高级别函数，它用于将一个函数应用于一个输入列表（或任何可迭代的输入）的所有元素。map()函数返回一个迭代器，包含所有函数调用的结果。
map()函数的基本语法如下：

map(function, iterable, ...)
1

这里的参数解释如下：
function：这是你希望应用于可迭代对象的每个元素的函数。这可以是一个内置的Python函数，例如str.upper，也可以是你自己定义的函数。
iterable：这是一个或多个你希望应用函数的可迭代对象。例如，列表、元组、字典等。
…（省略号）：这是可选的，表示你可以传入更多的可迭代对象。
下面是一些使用map()函数的例子：
例1：将列表中的每个元素都转化为大写字母

list1 = ['a', 'b', 'c', 'd']
result = map(str.upper, list1)
print(list(result))  # 输出：['A', 'B', 'C', 'D']
1
2
3

例2：将两个列表的元素配对并相加

def add(a,b):return a+b
list1 = [1, 2, 3]
list2 = [4, 5, 6]
result = map(add, list1, list2)
print(list(result))  # 输出：[5, 7, 9]
1
2
3
4
5

这里，add是内置的加法函数。
例3：将字典中的所有值转化为字符串

dict1 = {'a': 1, 'b': 2, 'c': 3}
result = map(str, dict1.values())
print(list(result))  # 输出：['1', '2', '3']
1
2
3

例4: lambda表达式

# lambda表达式
square = lambda x: x ** 2
numbers = [1, 2, 3, 4, 5]
# map函数计算每个元素的平方
squares = map(square, numbers)
print(list(squares)) # [1, 4, 9, 16, 25]
1
2
3
4
5
6

需要注意的是，map()函数并不直接修改输入的数据。如果你希望修改输入的数据，你需要使用其他的函数或方法。另外，虽然map()函数在大多数情况下都可以正常工作，但是如果函数或可迭代对象的__iter__()方法没有正确实现，或者在处理大数据集时内存限制，可能会出现一些问题。

lambda

Lambda表达式是Python语言中一个非常强大的特性，它允许你以一种简洁、快速的方式来定义匿名函数。Lambda表达式的语法非常简单，它由关键字lambda和一对括号组成，中间可以包含一个或多个参数，后面跟随一个冒号和一个表达式。
下面是一个简单的lambda表达式示例：

add = lambda x, y: x + y
1

上面的lambda表达式接受两个参数x和y，并返回它们的和。这个lambda表达式可以用来代替一个普通的函数定义。
Lambda表达式通常用于一些简单的、临时需要的函数，它们可以大大简化代码并提高代码可读性。
下面是一些使用lambda表达式的示例：

# 计算两个数的和
add = lambda x, y: x + y
result = add(3, 5)
print(result)  # 输出 8
# 将列表中的每个元素乘以2
numbers = [1, 2, 3, 4, 5]
doubled = list(map(lambda x: x * 2, numbers))
print(doubled)  # 输出 [2, 4, 6, 8, 10]
# 对一个列表进行排序
sorted_numbers = sorted(numbers, key=lambda x: x % 2)
print(sorted_numbers)  # 输出 [1, 3, 5]
1
2
3
4
5
6
7
8
9
10
11

Lambda表达式在Python中非常有用，它们可以简化代码并提高代码的可读性。你可以使用lambda表达式来定义简单的函数，特别是在需要一个临时函数的地方，而不需要去定义一个完整的函数。