python语法

Python 是一种 解释型 语言，但它也包含编译的步骤。这种特性通常被称为 解释型/编译型混合 或 半编译型。解释型语言的特点逐行执行：解释型语言在执行时，解释器会逐行读取代码，将其转换为机器码（或某种中间表示形式），然后执行。这意味着代码的执行是实时的，不需要事先编译成独立的可执行文件。易于调试：由于代码是逐行执行的，因此错误可以立即被捕获和调试。跨平台：解释型语言通常更容易在不同操作系统上运行，因为解释器会处理底层系统的差异。Python 的执行过程Python 的执行过程虽然包含了解释的步骤，但它也使用了编译的概念。具体来说：编译：当你运行 Python 程序时，Python 解释器首先会读取源代码（.py 文件），并将其编译成字节码（.pyc 文件，如果启用了字节码缓存）。这个字节码不是特定于任何平台的机器码，而是一种中间表示形式，由 Python 虚拟机（PyVM）执行。解释：Python 虚拟机（PyVM）读取字节码，并将其转换成机器码（或直接在解释器中执行，取决于实现），然后执行。这个过程是逐条指令进行的，类似于传统解释型语言的执行方式。为什么说 Python 是解释型语言虽然 Python 使用了编译步骤来生成字节码，但这个步骤主要是为了提高执行效率，减少重复编译相同代码的需要。从用户的角度来看，Python 程序仍然是以解释的方式执行的，即逐行读取和执行，无需事先编译成可执行文件。因此，Python 通常被归类为解释型语言。总结Python 是一种解释型语言，它通过编译源代码到字节码来提高执行效率，但最终的执行仍然是通过解释器逐行进行的。这种混合型的执行方式使得 Python 既具有解释型语言的灵活性和易调试性，又能在一定程度上提高执行效率。

是解释型语言还是编译型语言？

Python使用缩进来定义代码块，而不是括号。标准的Python缩进是4个空格，尽管制表符和任何其他空格大小都可以工作，只要它是一致的。请注意，代码块不需要任何终止。

独特之处：是一种使用空格缩进语法的语言

背景

集合是没有重复条目的列表

是什么

a = set([\"Jake\

声明

交 intersection

子主题

并： S1.union(S2)、 S1 | S2

差 difference

对称差 symmetric difference

子集、超集

python 中集合的操作方法有哪些

集合有哪些操作，比如S1 和 S2 两个集合

详解

操作

集合 Set

myint = 7print(myint)

定义一个整数

整数 int

myfloat = 7.0print(myfloat)myfloat = float(7)print(myfloat)

定义浮点数

浮点 float

支持整数(整数)和浮点数(小数)两种

可以在数字上执行简单的操作符

特性

数字

使用双引号可以很容易地包含撇号 (而如果使用单引号，这些将终止字符串)。

字符串可以用单引号或双引号定义。

优缺点

包含回车

包含反斜杠

包含Unicode字符

扩展

one = 1two = 2three = one + twoprint(three)hello = \"hello\"world = \"world\"helloworld = hello + \" \" + worldprint(helloworld) //hello world

可以在字符串上执行简单的操作符

# This prints out \

一个变量：%单个变量

# This prints out \"John is 23 years old.\"name = \"John\"age = 23print(\"%s is %d years old.\

“%”操作符用于格式化包含在“元组”(固定大小的列表)中的一组变量，以及一个格式字符串，该字符串包含普通文本以及“参数说明符”，特殊符号如“%s”和“%d”。

%d

整数

％.<number of digits>f -圆点右边有固定位数的浮点数。

%f、%.2f、%.3f、等等

浮点数

字符串(或任何字符串表示的对象，如数字)

%s

字符串

任何非字符串的对象也可以使用%s操作符进行格式化。从该对象的“repr”方法返回的字符串被格式化为字符串。例如:

对象

%x/% x

十六进制表示的整数(小写/大写)

各类型占位符

字符串格式化

astring = \"Hello world!\"astring2 = 'Hello world!'

astring = \"Hello world!\"print(\"single quotes are ' '\")//single quotes are ' '

打印

输出结果为12，因为“Hello world!”有12个字符长，包括标点和空格。

astring = \"Hello world!\"print(len(astring))//12

取长度

识别到第一个就返回。这将输出4，因为字母“o”第一次出现的位置距离第一个字符有4个字符。注意这个短语中实际上有两个o——这个方法只识别第一个o。

astring = \"Hello world!\"print(astring.index(\"o\"))//4

取字符下标

astring = \"Hello world!\"print(astring.count(\"l\"))//3

获得字符出现的次数

astring = \"Hello world!\"print(astring[3:7])//\"lo w\

astring = \"Hello world!\"print(astring[3:7:2])//\"l \"

astring = \"Hello world!\"print(astring[3:7])//\"lo w\"等价于print(astring[3:7:1])//\"lo w\" 

步长截取

截取子字符串[[start:stop):step]

astring = \"Hello world!\"print(astring[::-1])// !dlrow olleH

反转字符串

astring = \"Hello world!\"print(astring.upper())//HELLO WORLD!print(astring.lower())//hello world!

大小写

astring = \"Hello world!\"print(astring.startswith(\"Hello\"))//Trueprint(astring.endswith(\"asdfasdfasdf\"))// False

确定字符串是否以某一字符串开始或以某一字符串结束

astring = \"Hello world!\"afewwords = astring.split(\" \

字符串分割成列表

不支持数字和字符串之间的混合操作符

不支持

字典是一种类似于数组的数据类型，但使用的是键和值，而不是索引。存储在字典中的每个值都可以使用键来访问，键是任何类型的对象(字符串、数字、列表等)，而不是使用索引来寻址。

phonebook = {    \"John\

phonebook = {}phonebook[\"John\"] = 938477566phonebook[\"Jack\"] = 938377264phonebook[\"Jill\"] = 947662781print(phonebook)

phonebook = {\"John\

遍历字典

phonebook = {   \"John\

删除元素

字典

长度：list.count()

它们可以包含任何类型的变量，并且可以包含任意多的变量。

定义

添加元素

遍历元素

Traceback (most recent call last):  File \"<stdin>\

访问不存在的索引会产生异常(错误)。：IndexError: list index out of range

异常

读取元素

列表 List

Numpy数组是Python列表的绝佳替代品。Numpy数组的一些关键优点是它们快速、易于使用，并且使用户有机会跨整个数组执行计算。

导入numpy包并从新创建的列表中创建numpy数组。

在Python中，\"数组\"一词通常不会直接指向Python内建的一个特定类型，因为Python标准库中并没有直接称为“数组”的类型，而是有列表（List）和NumPy库中的数组（Array）等数据结构。因此，当我们讨论Python中的“数组”时，我们往往是在指NumPy库中的ndarray对象，这是为了与Python的内置列表（List）进行对比。Python 列表（List）定义：Python的列表是一个内置的数据结构，用于存储元素的有序集合。列表是可变的，即你可以添加、删除或修改列表中的元素。优点：灵活性：列表可以存储不同类型的元素（异质性）。内置支持：Python标准库直接支持列表，无需额外安装。动态大小：列表的大小可以根据需要自动调整。缺点：性能：对于大规模数值计算，列表的操作（如迭代、索引等）可能不如NumPy数组高效。内存使用：由于列表的灵活性，它在存储数据时可能需要更多的内存。NumPy 数组（Array）定义：NumPy是Python的一个库，它提供了高性能的多维数组对象（ndarray）以及用于操作这些数组的工具。NumPy数组是同质性的，即数组中的所有元素必须具有相同的数据类型。优点：性能：NumPy数组是为大规模数值计算优化的，因此它们比Python列表在执行数值计算时更快。内存效率：NumPy数组在内存中存储数据的方式使得它们比列表更紧凑。支持广播：NumPy数组支持广播，这是一种强大的机制，允许NumPy在执行算术运算时自动扩展较小数组的形状以匹配较大数组。大量数学和科学函数：NumPy提供了大量的数学和科学计算函数，可以直接在数组上操作。缺点：依赖外部库：要使用NumPy数组，你需要先安装NumPy库。同质性：数组中的所有元素必须具有相同的数据类型，这限制了其灵活性。总结选择使用列表还是NumPy数组取决于你的具体需求。如果你正在处理的是小型数据集或需要存储不同类型的元素，那么列表可能是更好的选择。然而，如果你正在进行大规模数值计算或需要高性能的数组操作，那么NumPy数组将是更好的选择。

数组与列表的区别，以及各自的优缺点

数组

类型

Python是完全面向对象的，而不是“静态类型”的。在使用变量之前不需要声明它们，也不需要声明它们的类型。Python中的每个变量都是一个对象。

同一行“同时”对多个变量进行赋值

变量

number = 2+1-2 * 3 / 4.0print(number)

加减乘除 +-*/

remainder = 11 % 3print(remainder)

取模 %

squared = 7 ** 2cubed = 2 ** 3print(squared)print(cubed)

次方 **

对数字使用，算术运算符

helloworld = \"hello\" + \" \" + \"world\"print(helloworld)//hello world

Python支持使用加法运算符连接字符串:

lotsofhellos = \"hello\" * 10print(lotsofhellos)//hellohellohellohellohellohellohellohellohellohello

Python还支持将字符串相乘以形成具有重复序列的字符串:

对字符串使用

列表可以用加法操作符连接:

就像在字符串中一样，Python支持使用乘法运算符用重复序列形成新的列表:

对列表使用

x = 2print(x == 2) # prints out Trueprint(x == 3) # prints out Falseprint(x < 3) # prints out True

name = \"John\"age = 23if name == \"John\" and age == 23:    print(\

\"and\"和\"or\"布尔运算符允许构建复杂的布尔表达式，

布尔操作符

布尔条件

name = \"John\"if name in [\"John\

\"in\"操作符可用于检查指定对象是否存在于可迭代对象容器中，例如列表:

包含条件：In

phonebook = {      \"John\

不包含：not in

值是否相等：==

与双等于操作符“==”不同，“is”操作符不匹配变量的值，而是匹配实例本身。例如:

地址相等即是否是同一对象：is

print(not False) # Prints out Trueprint((not False) == (False)) # Prints out False

地址是否不相等即是否不是同一对象：not

条件运算符

条件

操作符

statement = Falseanother_statement = Trueif statement is False:    # do something    print('statement')    passelif another_statement is True:     # else if do something else    print('another_statement')    passelse:    # do another thing    print('else do')    pass

if A is True/False: elif B is True/False: else:

x = 2if x == 2:    print(\"x equals two!\")else:    print(\"x does not equal to two.\")

if true : else:

if条件语句

if语句

for循环

while循环

Break用于退出for循环或while循环，而continue用于跳过当前块，并返回“for”或“while”语句。举几个例子:

break和continue语句

我们可以使用else for循环。当“for”或“while”语句的循环条件失败时，执行“else”中的代码部分。如果break语句在for循环中执行，那么“else”部分将被跳过。注意，即使有continue语句，“else”部分也会执行。

else语句

辅助语句

Python中有两种类型的循环，for和while。

循环语句

控制流程语句

导入语句

异常处理语句

# Exercise: make a regular expression that will match an emailimport redef test_email(your_pattern):    pattern = re.compile(your_pattern)    emails = [\"john@example.com\

邮箱正则

举例

正则表达式

actor = {\"name\": \"John Cleese\

获取后名

异常表达式

语句

块是用下列格式书写的代码区域:block_head:    1st block line    2nd block line    ...

块

def my_function():    print(\"Hello From My Function!\")

my_function()

调用

上述例子中my_function函数是一个无参函数

无参函数

固定参数函数

定义、调用

分类

列表可变*therest

字典可变**therest

填入foo和bar函数，这样它们就可以接收可变数量的参数(3个或更多)。foo函数必须返回接收到的额外参数的数量。如果带有关键字magicnumber的参数值为7，则该工具条必须返回True，否则返回False。

按照参数的获取方式不同

不仅可以根据顺序，获取可变参数，而且还可以使用关键字获取可变参数

使用

不仅可以根据顺序，获取可变参数，而且还可以使用关键字获取可变参数。不过两种参数获取方式的定义方式不一样

特点

可变参数函数

根据参数个数分类

空函数：定义

经典函数：无参、固定参、可变参

定义：your_function_name = lambda inputs : output

求和函数

编写一个程序，使用lambda函数检查给定列表中的数字是否为奇数。对于每个元素，如果数字是奇数，则打印“True”;如果不是奇数，则打印“False”。

lambda函数

例子

Partial functions（偏函数）是一个来自函数式编程的强大工具，主要用于减少函数调用的复杂性。偏函数的概念是固定一个函数的一些参数，然后生成一个新的函数的行为。这种方式可以让我们复用已有的函数但不需要改变它们的实现，从而简化代码并提高复用性。

偏函数

def transmit_to_space(message):    \"This is the enclosing function\"    def data_transmitter():        \"The nested function\"        print(message)    data_transmitter()print(transmit_to_space(\"Test message\"))

def print_msg(number):    def printer():        \"Here we are using the nonlocal keyword\"        #nonlocal number        number=3        print(number)     printer()    print(number)print_msg(9)#3#9

未使用nonlocal修饰

def print_msg(number):    def printer():        \"Here we are using the nonlocal keyword\"        nonlocal number        number=3        print(number)     printer()    print(number)print_msg(9)#3#3

使用nonlocal修饰

如果没有nonlocal关键字，输出将是“3 9”，然而，使用它，我们得到“3 3”，这是“number”变量的值被修改。

结论

使用nonlocal修饰参数来修改外部参数的值

嵌套函数是定义在另一个函数内部的函数。需要注意的是，嵌套函数可以访问封闭作用域的变量。然而，至少在python中，它们只是只读的。但是，可以对这些变量显式地使用“nonlocal”关键字来修改它们。

嵌套函数

def transmit_to_space(message):  \"This is the enclosing function\"  def data_transmitter():      \"The nested function\"      print(message)  return data_transmitterfun2 = transmit_to_space(\"Burn the Sun!\")fun2()

def multiplier_of(factor):    def multiplier(number):        return number * factor    return multiplier    multiplywith5 = multiplier_of(5)print(multiplywith5(9))

定义一个乘以factor的乘法函数 

什么闭包：即使完成了“transmit_to_space()”的执行，消息也被保留了下来。这种将数据附加到某些代码的技术，甚至在其他原始函数结束之后，在python中称为闭包

优点：闭包可以避免使用全局变量，并提供某种形式的数据隐藏。当类中的方法很少时，请使用闭包)。

闭包

闭包：保留了函数及其执行上下文的对象。返回值返回函数对象的函数

函数也是对象

函数

对象是将变量和函数封装成一个实体。对象从类中获取变量和函数。类本质上是创建对象的模板。

// 声明一个类class MyClass:    variable = \"blah\"    def function(self):        print(\"This is a message inside the class.\")

声明类

class MyClass:    variable = \"blah\"    def function(self):        print(\"This is a message inside the class.\") // 创建一个对象myobjectx = MyClass()

创建对象

class MyClass:    variable = \"blah\"    def function(self):        print(\"This is a message inside the class.\")myobjectx = MyClass()// 访问对象变量 myobjectx.variable// 打印访问的变量的值 print(myobjectx.variable)

访问对象变量

class MyClass:    variable = \"blah\"    def function(self):        print(\"This is a message inside the class.\")myobjectx = MyClass()myobjectx.function()

访问对象函数

__init__()函数是在初始化类时调用的特殊函数。它用于在类中赋值。

初始化 init()

类、对象

Python中的模块只是扩展名为.py的Python文件。模块名与文件名一致。Python模块可以定义和实现一组函数、类或变量。上面的例子包括两个文件:mygame/mygame/game.pymygame/draw.py

使用import命令从其他模块导入模块。

# game.py# import the draw modulefrom draw import draw_gamedef main():    result = play_game()    draw_game(result)

将模块对象导入到当前命名空间

# game.py# import the draw modulefrom draw import *def main():    result = play_game()    draw_game(result)

从模块中导入所有对象

自定义导入名称

# draw.pydef draw_game():    # when clearing the screen we can use the main screen object initialized in this module    clear_screen(main_screen)    ...def clear_screen(screen):    ...class Screen():    ...# initialize main_screen as a singletonmain_screen = Screen()

单例

PYTHONPATH=/foo python game.py

除了默认的本地目录和内置模块外，还有几种方法可以告诉Python解释器在哪里查找模块。你可以使用环境变量PYTHONPATH来指定其他目录来查找像这样的模块:

扩展模块加载路径

sys.path.append(\"/foo\")

您也可以使用sys.path.append函数。执行import命令前请先执行:

# import the libraryimport urllib# use iturllib.urlopen(...)

引入内置模块

我们可以通过使用dir函数来查找每个模块中实现的函数:

help(urllib.urlopen)

Python解释器的help函数来阅读函数的更多信息

import foo.bar

from foo import bar

模块的两种导入方式

如果我们创建一个名为foo的目录，它标记了包的名称，那么我们就可以在该包中创建一个名为bar的模块。然后我们在foo目录中添加__init__.py文件。

__init__.py:__all__ = [\"bar\"]

__init__.py文件还可以通过覆盖__all__变量来决定包导出哪些模块作为API，同时保留其他模块为内部模块，如下所示:

__init__.py 文件

引入模块

模块

包

模块、包

if type(fib()) == types.GeneratorType:    print(\"The fib function is a generator.\")

生成器类型（types.GeneratorType）

通常指的是生成器方法

节省内存：生成器按需产生值，而不是一次性将所有值存储在内存中。这对于处理大量数据或无限序列特别有用。简化代码：生成器提供了一种简洁的方式来表示复杂的迭代逻辑。

用来做什么的

在Python中，一个函数中使用yield语句时，该函数自动变成一个生成器函数（generator function）。生成器函数是一种特殊的迭代器，它返回一个迭代器对象，这个对象在每次迭代时都会执行函数中的代码，直到遇到下一个yield语句或者函数结束。在你给出的lottery函数中，尽管函数本身没有显式的return语句，但使用了yield语句，这使得它成为一个生成器。当这个函数被调用时，它并不立即执行其体内的代码，而是返回一个生成器对象。随后，每当对返回的生成器对象使用迭代（例如通过next()函数或者在for循环中）时，函数中的代码会从上次停止的yield语句之后继续执行，直到遇到下一个yield语句或者函数执行完毕。具体到lottery函数：当第一次迭代（或调用next()）时，函数执行到第一个yield语句，生成一个1到40之间的随机数，然后暂停。再次迭代时，它从上一个yield语句之后继续执行，再次生成一个随机数，直到循环结束，总共生成6个1到40之间的随机数。循环结束后，执行到第二个yield语句，生成一个1到15之间的随机数，然后函数执行完毕。因此，尽管lottery函数没有显式的return语句，但它通过yield语句返回了一个生成器对象，这个对象能够按需生成一系列的值。这种机制使得生成器在处理大量数据或需要逐步生成数据时非常有用，因为它允许按需生成数据，而不是一次性将所有数据加载到内存中。这对于处理大型数据集或无限序列（如自然数序列）特别有用。

可以代替return

可以使用for in 遍历

yield

yield生成值

完整例子

生成器方法，返回生成器对象，定义生成器对象变量接收返回值，操作生成器对像

定义一个生成器方法

# 判断是否是生成器类型import typesif type(fib()) == types.GeneratorType:    print(\

判断是否是生成器类型

#声明一个生成器对象，生成器对象是由生成器方法生成gen = fib();

声明一个生成器对象

#生成器forin遍历    counter = 0    for n in fib():        print(n)        counter += 1        if counter == 10:            break

使用 for in 进行迭代

#声明一个生成器对象，生成器对象是由生成器方法生成gen = fib();print(next(gen))   print(next(gen))print(next(gen))print(next(gen))

next(gen)方法生成并获取下一个值

如何使用

生成器如何使用

详细

生成器(Generator)

遍历和迭代的区别是什么

思考

迭代器

遍历循环处理：sentence = \"the quick brown fox jumps over the lazy dog\"words = sentence.split()word_lengths = []for word in words:      if word != \"the\":          word_lengths.append(len(word))print(words)print(word_lengths)使用列表推导处理：sentence = \"the quick brown fox jumps over the lazy dog\"words = sentence.split()word_lengths = [len(word) for word in words if word != \"the\"]print(words)print(word_lengths)

已知一个由单词组成的列表，生成一个新的列表其中每个元素是对应元素单词的长度

使用列表推导式，从列表“numbers”中创建一个名为“newlist”的新列表，该列表仅包含列表中的正数作为整数。

列表推导(List Comprehensions)

要将数据结构编码为JSON，请使用“dumps”方法。这个方法接受一个对象并返回一个String对象:

encode to json string

import json print(json.loads(json_string))

要将JSON加载回数据结构，请使用“loads”方法。这个方法接受一个字符串并将其转换回json对象数据结构:

decode to struct

打印出添加了键值对“Me”:800的JSON字符串。

json

Python支持Python专有的数据序列化方法pickle(以及更快的替代方法cPickle)。你可以用同样的方法来使用它。

在Python中，pickle是一个标准模块，用于对象的序列化和反序列化。序列化是指将Python对象转换为字节流，以便可以将其存储在文件中或通过网络传输；反序列化则是将这些字节流转换回Python对象。pickle与JSON的区别特性pickleJSON数据类型支持支持Python中的几乎所有对象类型，包括自定义对象主要支持字符串、数字、布尔值、数组（列表）、字典（对象）等基本数据类型，对Python自定义对象支持有限数据格式二进制序列化格式文本序列化格式（通常为UTF-8编码）可读性不可读（二进制数据）可读（人类可读的文本格式）语言依赖性Python特有，非Python程序可能无法重建pickle对象跨语言，广泛用于多种编程语言中安全性加载不受信任的数据时可能执行恶意代码相对安全，因为数据是文本格式，难以隐藏恶意代码版本兼容性可能在不同Python版本间不兼容跨版本兼容性较好pickle的优势广泛的类型支持：pickle可以处理Python中的几乎所有对象类型，包括自定义类的实例，这为Python对象的持久化和传输提供了极大的便利。高效的序列化与反序列化：相较于手动将对象编码为字符串或数组再存储/传输，pickle的dump和load函数提供了更为高效和简便的序列化与反序列化方法。快速的读取与写入：在经常存取的场景下，pickle的读取和写入效率较高，特别是对于复杂的数据结构或大型对象。易于使用：pickle的API简单直观，使用dump和load函数即可轻松实现对象的序列化和反序列化。注意事项尽管pickle具有诸多优势，但由于其生成的字节流是Python特有的，并且可能包含对特定Python版本和环境的依赖，因此不建议用于不同Python版本或不同环境之间的对象交换。在加载来自不可信来源的pickle数据时，应格外小心，因为可能存在执行恶意代码的风险。综上所述，pickle是Python中一个强大的对象序列化模块，适用于Python对象的本地存储和传输。然而，在跨语言或跨版本的数据交换中，可能需要考虑使用其他更为通用的数据交换格式，如JSON。

与json相比有哪些优势

pickle

序列化

代码自省是检查类、函数和关键字以了解它们是什么、它们做什么以及它们知道什么的能力。

# Define the Vehicle classclass Vehicle:    name = \"\"    kind = \"car\"    color = \"\"    value = 100.00    def description(self):        desc_str = \"%s is a %s %s worth $%.2f.\

打印给定Vehicle对象的所有属性列表。

代码自省

闭包 Closures

在Python中，raise 关键字用于引发一个异常。当你想要在你的代码中明确地指示错误发生时，你可以使用 raise 关键字后跟一个异常类（或其实例）来抛出一个异常。这可以让调用者知道在代码的某个地方出现了问题，并可以根据异常的类型和内容来做出相应的处理。基本用法引发一个异常类：你可以直接引发一个异常类，Python会自动为这个异常类创建一个实例。这通常用于标准异常类型，如ValueError、TypeError等。python复制代码raise ValueError(\"这是一个值错误\")引发一个异常实例：你也可以先创建异常类的实例，然后使用raise来抛出它。这种方式允许你传递更多的信息给异常对象。python复制代码error = ValueError(\"这是一个值错误\")  raise error自定义异常Python允许你定义自己的异常类，这些类应该直接或间接地继承自Exception类（或其子类）。然后，你可以像使用标准异常一样使用这些自定义异常。python复制代码class MyCustomError(Exception):      \"\"\"一个简单的自定义异常\"\"\"      pass    # 引发自定义异常  raise MyCustomError(\"这是一个自定义错误\")捕获异常通常，你会在使用try块中编写可能引发异常的代码，并使用except块来捕获并处理这些异常。python复制代码try:      # 尝试执行的代码      result = 10 / 0  except ZeroDivisionError:      # 处理除以零的异常      print(\"不能除以零\")注意事项当一个异常被抛出时，Python会中断当前代码块的执行，并查找最近的except块来捕获这个异常。如果找不到相应的except块，异常将被传递到上一级调用者，直到被捕获或程序终止。谨慎使用异常来处理程序的控制流，因为它们会使代码更难理解和维护。异常应该用于处理异常情况，而不是正常的控制流逻辑。

rase关键字

Python的装饰器是什么？Python的装饰器（Decorator）是一种特殊的函数，它允许你在不修改原有函数代码的情况下，给函数增加新的功能。装饰器本质上是一个函数，它接收一个函数作为参数并返回一个新的函数。这个新函数是对原函数的一个增强或修改版本。如何使用装饰器？使用装饰器通常遵循以下步骤：定义装饰器函数：这个函数接收一个函数作为参数，并返回一个新的函数。在这个装饰器函数内部，你可以定义任何想要执行的代码，比如日志记录、性能测试、事务处理等。然后，在返回的新函数中调用原函数，并可以添加额外的功能。使用@符号应用装饰器：在Python中，你可以通过在函数定义之前添加@符号和装饰器名来应用装饰器。这样做会将原函数作为参数传递给装饰器函数，并将装饰器函数返回的新函数赋值给原函数名。示例python复制代码def my_decorator(func):      def wrapper():          print(\"Something is happening before the function is called.\")          func()          print(\"Something is happening after the function is called.\")      return wrapper    @my_decorator  def say_hello():      print(\"Hello!\

装饰器只是另一个函数，它接受一个函数并返回一个函数。类似注解。本质是一个函数。

假设你想把输出乘以一个变量。你可以定义这个装饰器，并像下面这样使用它:

入参类型检查

装饰器

函数变成的范例

传统方法

使用map()函数不仅更简单，而且更加灵活。我只是这样做:

函数式编程

已知宠物名字的的列表，使所有名字变成大写

如果两个列表长度不一样怎么办？按照短的来，不会报错

两个列表变成元组

把列表中的第一个元素四舍五入到小数点后一位，第二个元素四舍五入到小数点后两位，第三个元素四舍五入到小数点后三位，以此类推。使用map()，这是小菜一碟。让我们看看怎么做。

下面是10个学生在化学考试中的分数列表(可迭代)。让我们过滤出（找出）那些分数超过75分的人……使用过滤器。

# Python 3dromes = (\"demigod\

下一个示例是一个回文检测器。“回文”是一个单词、短语或序列，向后读和向前读是一样的。让我们从可疑的回文元组(iterable)中过滤出属于回文的单词。

通常，这都是关于迭代的:reduce接受数字中的第一个和第二个元素，并将它们分别传递给custom_sum。Custom_sum计算它们的和并返回给reduce。然后Reduce获取该结果并将其作为custom_sum的第一个元素，并将数字中的下一个元素(第三个)作为custom_sum的第二个元素。它连续地(累积地)这样做，直到耗尽数字。

创建自己版本的Python内置sum()函数。sum()函数返回传递给它的可迭代对象中所有项的和

上边的例子设置初始值10

归约操作 Reduce 

是什么：将对应的列表元素打包成元组

基础语法

learnpython

参考：https://www.learnpython.org

https://www.learnx.org

认证考试

其他

python