一 python 解释器
Python解释器同一时间只能运行一个程序的一条语句。
如何适用：
win + r
cmd
要退出Python解释器返回终端，可以输入 exit() 或 Ctrl-D。
假设创建了一个 hello_world.py 文件，它的内容是：
可以用下面的命令运行它（ hello_world.py 文件必须位于终端的工作目录）：
从事数据分析和科学计算的人却会使用IPython，一个强化的Python解释器，或Jupyter notebooks，一个网页代码笔记本。
%run 命令，IPython会同样执行指定文件中的代码，结束之后，还可以与结果交互：
二 IPython Shell
1.运行 IPython Shell
用 ipython 在命令行打开IPython Shell，就像打开普通的Python解释器：
输入代码并按Return（或Enter），运行任意Python语句。
当只输入一个变量，会显示代表的对象：
2.运行Jupyter Notebook
notebook是一个代码、文本（有标记或无标记）、数据可视化或其它输出的交互式文档。Jupyter Notebook需要与内核互动，内核是Jupyter与其它编程语言的交互编程协议。
什么意思：Jupyter Notebook需要与内核互动，内核是Jupyter与其它编程语言的交互编程协议。
Jupyter Notebook：是一个开源的、基于Web的应用程序，允许你创建和共享包含代码、方程、可视化和文本的文档。它被广泛用于数据科学、机器学习、科学计算和教育等领域。
内核：内核是执行你编写的代码的程序。每个内核都支持一种或多种编程语言，如 Python、R、Julia 等。当你运行一个代码单元时，Jupyter Notebook 会将该代码发送到相应的内核进行执行，然后内核将执行结果返回给 Notebook。
交互编程协议：内核与 Jupyter Notebook 之间的通信遵循一种特定的协议。这个协议定义了如何发送代码到内核、如何从内核接收结果、如何处理错误和输出等。所以 Jupyter Notebook 能够与多种不同的内核和编程语言进行交互。
Python的Jupyter内核是使用IPython。要启动Jupyter，在命令行中输入 jupyter notebook :
在多数平台上，Jupyter会自动打开默认的浏览器（除非指定了 --no-browser ）。或者可以在启动notebook之后，手动打开网页 http://localhost:8888/ 。
新建一个notebook，点击按钮New，选择“Python3”或“conda[默认项]”。
3.Tab补全
从外观上，IPython shell和标准的Python解释器只是看起来不同。IPython shell的进步之一是具备
其它IDE和交互计算分析环境都有的tab补全功能。
使用方法：在shell中输入表达式，按下Tab。
默认情况下，IPython会隐藏下划线开头的方法和属性，比如魔术方法和内部的“私有”方法和属性，以避免混乱的显示，这些也可以tab补全，但是必须先输入一个下划线才能看到它们。如果你喜欢总是在tab补全中看到这样的方法，你可以IPython配置中进行设置。
4.自省
1.在变量前后使用问号 ？，可以显示对象的信息：
2.用在函数：
3. 像Unix或Windows命令行一样搜索IPython的命名空间，字符与通配符结合可以匹配所有的名字
5. %run命令
可以用 %run 命令运行所有的Python程序。
假设有一个文件 ipython_script_test.py：
这段脚本运行在空的命名空间（没有import和其它定义的变量），因此结果和普通的运行方式 python script.py 相同。文件中所有定义的变量（import、函数和全局变量，除非抛出异常），都可以在IPython shell中随后访问，
6.中断运行的代码
7.魔术命令
IPython 中特殊的命令（Python中没有）被称作“魔术”命令。
魔术命令是在指令前添加百分号%前缀。例如，可以用 %timeit 测量任何Python语句，例如矩阵乘法，的执行时间：
一些魔术函数与Python函数很像，它的结果可以赋值给一个变量：
常用的 IPython 指令：
jupyter note里面可以用ipython的魔术命令吗：
Jupyter Notebook里面可以使用IPython的魔术命令。Jupyter Notebook是一个交互式计算环境，它允许用户使用IPython作为其内核来运行Python代码。IPython是一个增强版的Python解释器，提供了许多有用的功能，其中就包括所谓的“魔术命令”（magic commands），这些命令以%或%%开头，用于执行特定的操作。
魔术命令在Jupyter Notebook中使用时，需要在单元格的代码开头使用，并且一些魔术命令可能需要在Jupyter Notebook的配置中启用或安装相应的库。
%matplotlib 魔术函数配置了IPython shell和Jupyter notebook中的matplotlib。这点很重要，其它创建的图不会出现（notebook）或获取session的控制，直到结束（shell）。
什么意思：%matplotlib 魔术函数配置了IPython shell和Jupyter notebook中的matplotlib。这点很重要，其它创建的图不会出现（notebook）或获取session的控制，直到结束（shell）。
%matplotlib魔术函数：这是IPython提供的一个特殊命令，用于配置matplotlib的行为。
在Jupyter notebook中，使用
%matplotlib inline可以使得matplotlib绘制的图形直接嵌入到notebook的页面中，而不是在新窗口中打开。在Jupyter notebook中的影响：如果不使用
%matplotlib inline，那么在notebook中创建的图形可能不会直接显示，而是会尝试在新窗口中打开，这通常不是我们想要的效果。使用
%matplotlib inline后，图形会嵌入到notebook的页面中，方便我们查看和与代码进行交互。在IPython shell中的影响：在IPython shell中，如果不进行配置，matplotlib绘制的图形可能会显示在一个单独的窗口中，并且会话的控制权可能不会在图形显示后立即返回给shell。
通过配置
%matplotlib（例如使用%matplotlib qt来选择Qt5后端），我们可以控制图形的显示方式和会话的行为。
在IPython shell中，运行 %matplotlib 可以进行设置，可以创建多个绘图窗口，而不会干扰控制台
session：
在JUpyter中，命令有所不同：
三 python 语法规则
仅作为补充，详细在在python学习笔记中。
1.万物皆对象
每个数字、字符串、数据结构、函数、类、模块等等，都被认为是Python对象。每个对象都有类型（例如，字符串或函数）和内部数据。
什么意思：每个数字、字符串、数据结构、函数、类、模块等等，都被认为是Python对象。每个对象都有类型（例如，字符串或函数）和内部数据。
在Python中，无论是基本的数据类型（如数字、字符串）还是更复杂的数据结构（如列表、字典）、函数、类、模块等，都被视为“对象”。每个对象都有其特定的“类型”以及与之关联的“内部数据”。
举例：
（数字对象）：
类型：
intfloat内部数据：数值本身
例子：
num = 10，这里num是一个整数对象，其类型为int，内部数据为10。（字符串对象）：
类型：
str内部数据：字符序列
例子：
text = "Hello, World!"，这里text是一个字符串对象，其类型为str，内部数据为字符序列"Hello, World!"。（列表对象）：
类型：
list内部数据：元素的有序集合
例子：
my_list = [1, 2, 3, "a", "b"]，这里my_list是一个列表对象，其类型为list，内部数据为包含整数和字符串的有序集合。（函数对象）：
类型：通常是
function（对于普通函数）或method（对于类的方法）内部数据：函数的实现代码
例子：
def add(a, b): return a + b，这里add是一个函数对象，其类型为function，内部数据是执行加法的代码。（类对象）：
类型：
type（在Python中，类本身也是对象，并且它们的类型是type）内部数据：类属性、方法定义等
例子：
class Person: name = "" age = 0，这里Person是一个类对象，其类型为type，内部数据包括类属性name和age，以及可能定义的方法。
2.变量和参数传递
当在Python中创建变量，你就在等号右边创建了一个对这个变量的引用。
举例：
赋值也被称作绑定，我们是把一个名字绑定给一个对象。变量名有时可能被称为绑定变量。
Python中的对象引用不包含附属的类型。
什么意思：Python中的对象引用不包含附属的类型。
实际上是在讨论对象引用（即变量）和对象本身之间的区别，以及类型信息是如何与对象相关联的，而不是与变量（引用）直接相关联的。
对象引用（变量）：在Python中，变量是存储对象引用的容器。变量本身不存储数据，而是存储对存储在内存中的对象的引用。
变量本身并不存储值，而是存储了对对象的引用（即对象的内存地址）。变量可以被重新赋值，以指向不同的对象。
比喻：
仓库里存放着各种各样的物品（比如书籍、玩具、电子产品等），这些物品就相当于Python中的“对象”。每个物品都有一个唯一的位置（比如货架上的某个格子），这个位置信息就相当于Python中变量所存储的“对象引用”。现在，仓库管理员给了你一个便签，上面写着玩具的位置信息（“A区3排5格”），这个便签就相当于Python中的一个“变量”。你拿着这个便签，就可以去仓库里找到对应的物品。但是，便签本身并不包含物品的数据（比如书籍的内容、玩具的形状等），它只是告诉你物品在哪里。
当使用变量时，Python会根据变量上存储的地址信息（对象引用），去内存中找到对应的对象，并对其进行操作。因此，变量本身并不存储数据，它只是存储了一个指向数据的引用（地址）。
对象：
对象是Python中数据的基本单元，可以是数字、字符串、列表、字典、函数、类等。每个对象都有一些属性（即数据）和一些方法（即函数，用于操作这些数据）。
对象是内存中存储数据的实体，具有明确的类型。对象包含了数据和操作数据的函数（方法）
比喻：
对象（比如一个整数
42或一个字符串"Hello"）就像是仓库里的物品，它包含了实际的数据。变量和对象的区别：
你手上有一个便签（变量），上面写着某个房间的地址（对象的内存地址）。现在你想去另一个房间，于是你撕下这个便签，写上新房间的地址，然后贴在手上。
类型信息：当你创建一个对象时，Python会自动为其分配一个类型，这个类型定义了对象的结构和行为。
3.鸭子类型
可能不关心对象的类型，只关心对象是否有某些方法或用途。这通常被称为“鸭子类型”，来自“走起来像鸭子、叫起来像鸭子，那么它就是鸭子”的说法。
什么意思：鸭子类型
在Python中，这种类型机制不关注对象的类型，而是关注对象的行为。只要对象实现了特定的方法或属性，就可以认为它是鸭子类型，而不需要显式地继承或实现某个类或接口。
举例：
class Duck: def quack(self): print("Quack!") def fly(self): print("I'm flying!") class Person: def quack(self): print("I'm quacking like a duck!") def fly(self): print("I'm flapping my arms like a duck!") def make_it_quack_and_fly(obj): obj.quack() obj.fly() duck = Duck() person = Person() make_it_quack_and_fly(duck) # Output: Quack! I'm flying! make_it_quack_and_fly(person) # Output: I'm quacking like a duck! I'm flapping my arms like a duck!
Duck类和Person类都没有相互关联，也没有共同的父类或接口。然而，它们都具有quack()和fly()方法，并且这些方法的行为相似。因此，我们可以通过鸭子类型的判断方式，将duck和person对象都传递给make_it_quack_and_fly()函数，并成功执行相应的操作。比喻：
在日常生活中，我们看到一个物体能够在水中漂浮、有羽毛、并且会发出“嘎嘎”的叫声，我们就会认为它是鸭子，而不会去深究它到底是哪种鸭子，或者它是不是由其他动物伪装而成的。
好处：
（灵活性）不需要关心对象的实际类型，只需要关心它是否具有你需要的行为（方法）。
def process_duck_like(duck_like): duck_like.quack() duck_like.fly() class Duck: def quack(self): print("Quack!") def fly(self): print("Flying!") class RobotDuck: def quack(self): print("Electronic Quack!") def fly(self): print("Using propellers to fly!") duck = Duck() robot_duck = RobotDuck() process_duck_like(duck) # Outputs: Quack! Flying! process_duck_like(robot_duck) # Outputs: Electronic Quack! Using propellers to fly!在这个例子中，
process_duck_like函数可以处理任何具有quack和fly方法的对象，无论它们是Duck还是RobotDuck。使用场景：
1.插件系统
在插件系统中，不同的插件可能需要实现相同的功能接口，但它们的实现方式和底层技术可能完全不同。使用鸭子类型，可以避免对插件的严格类型限制，只要插件对象能够表现出所需的行为即可。
# 定义一个插件接口（非强制性的，仅用于说明） class PluginInterface: def execute(self): pass # 插件A的实现 class PluginA: def execute(self): print("Plugin A is executing...") # 插件B的实现 class PluginB: def execute(self): print("Plugin B is executing...") # 插件管理器，使用鸭子类型来加载和执行插件 class PluginManager: def load_plugin(self, plugin): if hasattr(plugin, 'execute'): plugin.execute() else: print("Invalid plugin: No execute method found.") # 使用插件管理器加载和执行插件 pm = PluginManager() pm.load_plugin(PluginA()) # 输出: Plugin A is executing... pm.load_plugin(PluginB()) # 输出: Plugin B is executing...2.单元测试中的模拟对象
在编写单元测试时，有时需要模拟外部依赖（如数据库、网络服务等）。使用鸭子类型，可以创建仅实现被测试代码所期望方法的模拟对象，从而避免对外部依赖的依赖。
# 被测试的代码 def send_email(email_service): email_service.send("Test Email Subject", "Test Email Body") # 模拟的EmailService对象 class MockEmailService: def send(self, subject, body): print(f"Email sent with subject: {subject}, body: {body}") # 单元测试 def test_send_email(): mock_service = MockEmailService() send_email(mock_service) # 输出: Email sent with subject: Test Email Subject, body: Test Email Body3.动态数据结构处理
在处理动态数据结构（如JSON对象、字典等）时，对象的类型和结构可能在运行时发生变化。使用鸭子类型，可以根据对象当前的状态和行为来处理它，而不是根据它的静态类型。
# 动态数据结构（JSON对象） data = { "type": "user", "name": "John Doe", "age": 30 } # 处理动态数据结构的函数 def process_data(data): if 'name' in data and 'age' in data: print(f"Name: {data['name']}, Age: {data['age']}") else: print("Invalid data structure.") # 使用函数处理数据 process_data(data) # 输出: Name: John Doe, Age: 304.多态性实现
虽然鸭子类型不是传统面向对象编程中的多态性（通过继承实现的），但它提供了一种类似的多态性机制。只要对象具有相同的行为（方法），就可以将它们视为可互换的类型。
# 定义一个基类（非强制性的，仅用于说明） class Animal: pass # 具体的动物类 class Dog: def make_sound(self): return "Woof!" class Cat: def make_sound(self): return "Meow!" # 使用鸭子类型来处理不同类型的动物 def animal_sound(animal): if hasattr(animal, 'make_sound'): print(animal.make_sound()) else: print("This animal doesn't make any sound.") # 使用函数处理不同类型的动物对象 dog = Dog() cat = Cat() animal_sound(dog) # 输出: Woof! animal_sound(cat) # 输出: Meow!
例如，你可以通过验证一个对象是否遵循迭代协议，判断它是可迭代的。对于许多对象，这意味着它有一个 __iter__ 魔术方法，其它更好的判断方法是使用 iter 函数：
可以用这个功能编写可以接受多种输入类型的函数。常见的例子是编写一个函数可以接受任意类
型的序列（list、tuple、ndarray）或是迭代器。你可先检验对象是否是列表（或是NUmPy数
组），如果不是的话，将其转变成列表：
4.is方法
1.使用场景
1.要判断两个引用是否指向同一个对象，可以使用 is 方法。
list 是创建一个新的Python列表（即复制）。
2.is 和 is not 常用来判断一个变量是否为 None
2.is 和 == 的区别：
3.其他的二元运算符和比较运算符
5.可变与不可变对象
Python中的大多数对象，比如列表、字典、NumPy数组，和用户定义的类型（类），都是可变的。意味着这些对象或包含的值可以被修改：
字符串和元组，是不可变的对象：
6.布尔值
布尔值可以与and和or结合使用：
7.类型转换
str、bool、int和float也是函数，可以用来转换类型：
8.日期和时间
Python内建的 datetime 模块提供了 datetime 、 date 和 time 类型。 datetime 类型结合了 date 和 time ，是最常使用的：
当你聚类或对时间序列进行分组，替换datetimes的time字段有时会很有用。例如，用0替换分和秒：因为 datetime.datetime 是不可变类型，下面的方法会产生新的对象。
两个datetime对象的差会产生一个 datetime.timedelta 类型：
结果 timedelta(17, 7179) 指明了 timedelta 将17天、7179秒的编码方式。
将 timedelta 添加到 datetime ，会产生一个新的偏移 datetime ：
9.控制语句中的 or 和 and
1.or运算符
如果至少有一个条件为真，则整个表达式的结果为真；如果所有条件都为假，则整个表达式的结果为假。
对于 or 运算符，如果第一个条件为真，则不会计算后续的条件。
2.and 运算符
如果所有条件都为真，则整个表达式的结果为真；如果任何一个条件为假，则整个表达式的结果为假。
对于 and 运算符，如果第一个条件为假，则不会计算后续的条件。
3.示例代码
def func1():
print("func1 is called")
return False
def func2():
print("func2 is called")
return True
# and 短路求值
if func1() and func2():
print("Both func1 and func2 returned True")
else:
print("Either func1 or func2 returned False") # 输出这一行
# 输出:
# func1 is called
# Either func1 or func2 returned False
# or 短路求值
if func1() or func2():
print("At least one of func1 or func2 returned True") # 输出这一行
# 输出:
# func1 is called
# At least one of func1 or func2 returned True
4.注意点
and 运算符的优先级高于 or 运算符。
