经管之家App
让优质教育人人可得
立即打开
Python是一种高级编程语言，具备解释性、交互性和面向对象的特性。作为一种解释型语言，Python在开发过程中无需编译步骤，代码由解释器逐行执行，提升了调试效率。
该语言具有良好的可嵌入能力，对于性能敏感或无法直接实现的功能，可以通过C或C++编写扩展模块，并在Python程序中调用。此外，Python还支持数据库连接操作以及图形用户界面（GUI）开发，应用范围广泛。
Python的核心是其解释器，只要系统中安装了Python解释器，即可运行相应的脚本文件，跨平台兼容性强。
Python默认采用Unicode编码处理所有字符串内容，这意味着每个字符串都以unicode形式存在。
标识符命名需遵循以下规范：
全部版块
我的主页
收藏
myVar与myvar被视为两个不同的变量。utf-8标识符Python包含一系列预定义的保留字，这些关键字不能用作变量名或标识符。可通过以下命令查看完整列表：
>>> import keyword
>>> keyword.kwlist
['False', 'None', 'True', '__peg_parser__', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
Python支持多种注释格式：
#这是单行注释"""
这是多行注释
这是多行注释
"""'''
也可以用三个单引号来进行多行注释
'''Python通过缩进来组织代码块结构，而非依赖大括号或其他符号。虽然空格数量没有固定要求，但同一代码块内的语句必须保持一致的缩进层级，否则会引发语法错误。
Python 提供了六种标准的数据类型：
根据是否可变，可分为两类：
这里的“可变”与“不可变”指的是对象本身在修改数据时是否生成新引用地址，而不是指能否更改其内容。
与其他编程语言类似，Python使用括号来进行表达式分组，控制运算优先级。
+,-,* ,/ ,%()除法运算中，普通除法会保留小数部分，而整除则只返回商的整数部分。
///幂运算通过特定运算符实现，用于计算乘方；更复杂的数学函数需要引入外部数学库来完成。
**字符串可以用单引号或双引号包围定义，两者功能相同。
'...'"..."反斜杠“\”可用于转义特殊字符。若希望字符串按原始形式输出，避免任何转义处理，可在引号前添加字母“r”，构造原始字符串（raw string），此时内容将完全原样呈现。
\r若要提取子串，可使用索引切片语法：变量[头下标:尾下标]，从而获取指定范围内的字符序列。
str = "qwertyuiop"
print(str[0:5]) # 输出结果为：qwert
Python提供内置函数type()用于判断变量的数据类型，例如：
type(name)
列表是Python中最常用的复合数据结构之一，能够存储多种类型的元素，包括字符、数字、字符串，甚至嵌套其他列表。
列表使用方括号 [] 标识，支持动态增删改查操作。
list = ['abcd', 786, 2.23, 'john', 70.2]
tinylist = [123, 'john']
print(list) # 输出完整列表
print(list[0]) # 输出第一个元素
print(list[1:3]) # 输出第二个到第三个元素
print(list[2:]) # 输出从第三个元素开始的所有元素
print(tinylist * 2) # 输出列表重复两次
print(list + tinylist) # 合并并输出两个列表
元组是另一种序列类型，与列表相似，但使用圆括号 () 表示，元素之间用逗号分隔。
关键区别在于：元组一旦创建，其元素不可修改，属于只读类型，适用于不希望被意外更改的数据集合。
tuple = ('abcd', 786, 2.23, 'john', 70.2)
tinytuple = (123, 'john')
print(tuple) # 输出完整元组
print(tuple[0]) # 输出第一个元素
print(tuple[1:3]) # 输出第二个到第三个元素
print(tuple[2:]) # 输出从第三个元素开始的所有元素
变量是存储在内存中的值，相当于指针不关联具体的数据类型，解释器会根据赋值内容自动分配相应大小的内存空间。 # 使用等号（=）进行变量赋值 counter = 100 # 整型变量 miles = 1000.0 # 浮点型变量 name = "John" # 字符串变量 # 同时为多个变量指定不同的对象 a, b, c = 1, 2, "john"
元组操作示例： print tinytuple * 2 # 将元组内容重复输出两次 print tuple + tinytuple # 输出两个元组拼接后的结果
字典（dictionary）是 Python 中除列表外最灵活的内置数据结构之一。与列表不同的是，列表是一个有序的对象集合，而字典属于无序的对象集合。
两者的核心区别在于：字典中的元素通过“键”（key）来访问，而不是像列表那样通过索引偏移量获取。
字典使用大括号 "{ }" 标识，由若干个键值对组成，每个键（key）对应一个值（value）。
dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"
tinydict = {'name': 'john', 'code': 6734, 'dept': 'sales'}
print dict['one'] # 输出键为 'one' 的值
print dict[2] # 输出键为 2 的值
print tinydict # 输出完整的字典
print tinydict.keys() # 返回所有键名
print tinydict.values() # 返回所有对应的值
在 Python 中，若需将数据从一种类型转换为另一种类型，只需将目标类型作为函数调用即可完成转换。
Python 中可通过特定函数处理标准输入和输出流。
例如，使用 input() 函数读取用户输入：
print()name = input() print(name)
input()在代码中如果需要将一个字符串跨多行书写，可以使用反斜杠 \ 实现行连接。
+ \
data = "this " + \
"is " + \
"Tuesday"
print(data)
# 输出结果：this is Tuesday
# 注意：空格也会被当作普通字符处理
Python 提供了多种用于数学运算的内置模块：
import math
在 Python 中定义函数需要使用 def 关键字，其基本语法格式如下：
def
def 函数名(参数列表):
// 实现特定功能的多行代码
[return [返回值]]
例如定义一个简单的加法函数：
def func(a, b):
return a + b
func(1, 2)
# 输出结果：3
Python 支持在函数内部再定义函数，这类函数被称为局部函数或嵌套函数。
# 全局函数
def outdef():
# 局部函数定义
def indef():
print("http://c.biancheng.net/python/")
# 在外部函数内调用局部函数
indef()
# 调用全局函数以执行整个流程
outdef()
与局部变量类似，局部函数默认只能在其所处的外层函数作用域内被调用和使用。
对于仅包含一行表达式的简单函数，Python 提供了一种简洁的定义方式——lambda 表达式，也称为匿名函数。
当某个函数体只有一行表达式时，就可以用 lambda 来替代常规的 def 定义。
name = lambda [list] : 表达式
# 等价于：
def name(list):
return expresion
name(list)
这两个函数都可用于执行以字符串形式提供的 Python 代码，类似于动态解释器的功能。
它们的主要区别在于：
Python 是一门支持面向对象特性的编程语言。类和对象是其核心组成部分，相较于其他语言，Python 创建类和对象的过程更加简便直观。
同时，它完整支持面向对象的三大基本特征：封装、继承和多态。
在 Python 中，所有的数据类型本质上都是对象，例如整型（int）、浮点型（float）、字符串（str）、列表（list）、元组（tuple）、字典（dict）以及集合（set）等。以字典为例，它内置了多个可调用的方法，比如使用 keys() 来获取所有键，values() 获取所有值，items() 获取所有的键值对。
类中的函数通常被称为“方法”。与普通函数不同的是，类中的方法至少需要包含一个 self 参数（具体作用后文会详细说明）。例如，在一个名为 tortoise 的类中，crawl()、eat()、sleep() 和 protect() 都是该类所定义的方法。这些方法不能独立调用，必须通过类的实例对象来使用。
在 Python 中，定义一个类使用 class 关键字，其基本语法结构如下：
class 类名：
多个（≥0）类属性...
多个（≥0）类方法...
当我们创建一个类时，可以手动添加一个特殊的方法：
__init__()这个方法叫做构造方法（也称构造函数），其定义格式为：
def __init__(self, ...):
代码块
注意，该方法名前后各有两个下划线，且中间不能有空格。Python 中许多以双下划线开头并结尾的方法都具有特殊含义。
构造方法至少要有一个 self 参数，它代表当前被调用的对象实例。无论是构造方法还是其他实例方法，哪个对象调用了该方法，self 就指向哪个对象，这一点类似于 Java 中的 this 关键字。
将类转换为具体对象的过程称为类的实例化。
类名(参数)只有经过实例化之后，类才能真正被使用。实例化后的对象支持以下操作：
根据变量在类体中的位置和定义方式的不同，类属性可分为三种：
self.变量名 的形式定义，属于特定对象，只能通过对象访问，不能通过类名直接访问；变量名 = 值 定义，仅在当前方法内有效，方法执行结束后即被销毁。类中的方法可以根据修饰符进一步分为三类：类方法、实例方法和静态方法。
@classmethod 装饰的方法称为类方法；@staticmethod 装饰的方法称为静态方法；实例方法最少需要一个 self 参数，用于绑定调用它的实例对象，Python 会自动完成这一绑定过程。通常我们通过类的对象来调用实例方法。
类方法则至少包含一个参数，习惯上命名为 cls，Python 会自动将类本身传入该参数（不是类的实例）。因此在调用类方法时，无需手动为 cls 传参。cls 并非关键字，也可使用其他名称，但为了可读性建议保持惯例。
推荐使用类名来调用类方法，虽然也可以通过实例对象调用，但并不推荐。
class CLanguage:
# 类的构造方法，属于实例方法
def __init__(self):
self.name = "C语言中文网"
self.add = "http://c.biancheng.net"
@classmethod
def info(cls):
print("正在调用类方法", cls)
静态方法无法访问类中的任何属性或方法，完全独立于类和实例存在。
class CLanguage:
@staticmethod
def info(name, add):
print(name, add)
在 Python 中，通过描述符机制，可以在访问某个对象属性时自定义其行为。
class revealAccess:
def __init__(self, initval=None, name='var'):
self.val = initval
self.name = name
def __get__(self, obj, objtype):
print("Retrieving", self.name)
return self.val
def __set__(self, obj, val):
print("updating", self.name)
self.val = val
在面向对象编程中，属性的封装是一个重要的设计原则。直接通过“类对象.属性”的方式访问或修改类中的属性会破坏类的封装性。理想情况下，类的内部属性应当对外部隐藏，仅能通过类提供的公共方法来间接操作这些属性，从而确保数据的安全性和程序的可维护性。
为了实现对属性的安全访问与修改，通常会在类中定义对应的 getter、setter 和 deleter 方法。例如：
class CLanguage:
# 构造函数
def __init__(self, name):
self.name = name
# 设置 name 属性
def setname(self, name):
self.name = name
# 获取 name 属性
def getname(self):
return self.name
# 删除 name 属性
def delname(self):
self.name = "xxx"
虽然上述方法符合封装规范，但调用时需要使用“类对象.方法()”的形式，不如直接使用点号访问属性直观。为此，Python 提供了 property() 函数，允许开发者在不违背封装原则的前提下，继续使用“类对象.属性”的语法来操作属性。
class CLanguage:
def __init__(self, n):
self.__name = n
def setname(self, n):
self.__name = n
def getname(self):
return self.__name
def delname(self):
self.__name = "xxx"
# 使用 property 将 name 属性包装起来
name = property(getname, setname, delname, '指明出处')
通过这种方式，既保护了属性的私密性（使用双下划线表示私有），又实现了以简洁语法访问和设置属性值。
封装能够有效保障类内部数据结构的完整性。外部用户无法直接查看或修改类的内部状态，只能通过公开的方法进行交互，这避免了非法操作对数据造成的影响，增强了程序的健壮性和可维护性。
此外，Python 中还可以通过命名约定来标识私有成员：以单下划线 "_" 开头的属性或方法被视为受保护成员，提示外部代码不应随意访问；而以双下划线 "__" 开头的则会被解释器进行名称重整，进一步增强私有性。
继承是面向对象的重要特性之一，常用于创建功能上与现有类相似的新类，或者在原有基础上扩展新的属性和方法，而无需复制整个类的代码。这样可以提高代码复用率，降低冗余。
在 Python 中定义子类时，只需在类名后的圆括号中列出一个或多个父类即可：
class 类名(父类1, 父类2, ...):
# 类定义内容
如果未显式指定父类，默认继承自 object 类 —— 这是所有 Python 类的根类，无论是直接还是间接继承。值得注意的是，Python 支持多继承机制（类似于 C++），即一个子类可以同时继承多个父类。
当多个父类中存在同名方法时，Python 会根据继承列表中的顺序进行解析，优先使用排在前面的父类中的方法版本，后面的同名方法将被覆盖。
子类在继承父类后，通常会保留原有的属性和方法，并在此基础上进行扩展。若需更改某个继承来的方法行为，可以在子类中重新定义一个同名、同参数的方法，这一过程称为方法重写（override）。
在重写过程中，有时仍需调用父类中的对应方法，此时可使用 super() 函数获取父类的引用。例如，在构造函数中调用父类初始化逻辑：
super().__init__(self, ...)
super()需要注意的是，在涉及多继承的情况下，super() 函数只会调用方法解析顺序（MRO）中第一个直接父类的相应方法，而非所有父类。
Python 是一种动态弱类型语言，变量在使用时无需声明具体类型。这种灵活性使得同一个操作可以在不同类型的对象上产生不同的行为，这就是多态的核心思想。通过继承和方法重写，不同类的对象可以对同一消息做出各自特有的响应，提升了程序的扩展性和通用性。
Python 类中包含一系列以双下划线开头和结尾的特殊方法，它们在特定场景下由解释器自动调用。
__new__()__new__() 是一个静态方法，负责创建类的实例，无需使用 staticmethod 装饰器修饰。它在 __init__ 初始化方法之前被调用，控制对象的生成过程。
__init__()默认情况下，打印一个实例对象只会输出类似“类名 + object at + 内存地址”的信息，缺乏实际意义。通过重写 __str__() 方法，可以自定义对象的字符串表示形式，使输出更具可读性。
__repr__()当我们输出某个实例化对象时，实际上调用的就是该对象的 __str__() 方法，显示其返回值。
与对象创建相对的是销毁过程。__del__() 方法用于在对象被垃圾回收前执行清理工作，如释放资源等。
__del__()当一个对象不再被引用时，Python 的垃圾回收机制会自动将其销毁并释放内存空间，这个过程也被称为 GC（Garbage Collection）。开发者可在适当位置手动删除引用以触发此流程。
要查看某个对象拥有的所有属性和方法名称，可以使用内置的 dir() 函数。
__dir()__该函数返回一个有序列表，包含该对象所有可用的属性名和方法名，便于调试和反射操作。
另一个重要属性是 __dict__，它以字典形式存储对象的属性及其值。该属性既可以通过类名访问类级别的属性，也可以通过实例对象访问实例级别的属性。
__dict__在 Python 中，调用类属性相关的内置函数时，行为会根据调用对象的不同而有所区别。当通过类本身调用时，返回的是该类中所有类属性构成的字典；而如果使用类的实例对象进行调用，则输出由该实例所拥有的所有实例属性组成的字典。
__dict__hasattr(obj, name) 函数用于判断某个类的实例对象是否包含指定名称的属性或方法。它接收两个参数：目标对象 obj 和待检测的属性名 name，返回值为布尔类型。
hasattr()getattr(obj, name[, default]) 函数的作用是获取指定对象中某属性的值。若该属性不存在，且提供了默认值 default，则返回 default；否则将抛出 AttributeError 异常。
getattr()setattr(obj, name, value) 函数功能较为丰富。其最基本用途是修改类实例对象中某一属性的值。此外，它还支持在运行时为对象动态添加新的属性或方法，从而实现灵活的对象扩展。
setattr()像列表（list）、元组（tuple）、字典（dict）和集合（set）这类容器类型都具备一个共同特征：它们都可以通过 for 循环逐个访问内部元素，因此被称为“可迭代对象”。这些对象也常被统称为迭代器。
要使一个对象成为可迭代对象，需实现以下两个方法：
__next__(self)__iter__(self)Python 提供了几个常用的内置装饰器函数，如 @staticmethod、@classmethod 和 @property。其中 staticmethod()、classmethod() 和 property() 均为语言内置函数，用于修饰类中的方法以改变其调用方式或行为。
当使用一个函数装饰器 A() 来装饰另一个函数 B() 时，底层实际上执行了两个步骤：
函数装饰器的核心优势在于：可以在不改动原函数代码的前提下，合理地扩展其功能。
在 Python 中，通常使用 try except 语句块来捕获并处理程序运行过程中可能出现的异常情况。其基本语法结构如下：
try:
可能产生异常的代码块
except [ (Error1, Error2, … ) [as e] ]:
处理异常的代码块1
except [ (Error3, Error4, … ) [as e] ]:
处理异常的代码块2
except [Exception]:
处理其它异常
在标准的 try except 结构基础上，Python 还支持添加 else 子句，形成 try except else 的结构。else 块中的代码仅在 try 块未触发任何异常时才会执行。一旦发生异常并被相应的 except 捕获处理，即使处理完毕，else 块也不会运行。
示例代码：
try:
result = 20 / int(input('请输入除数:'))
print(result)
except ValueError:
print('必须输入整数')
except ArithmeticError:
print('算术错误，除数不能为 0')
else:
print('没有出现异常')
print("继续执行")
此外，Python 异常机制还提供了 finally 语句块，主要用于执行清理工作或释放资源等收尾操作。无论 try 块是否抛出异常，finally 块中的代码都会被执行。
示例：
try:
a = int(input("请输入 a 的值:"))
print(20/a)
except:
print("发生异常！")
else:
print("执行 else 块中的代码")
finally :
print("执行 finally 块中的代码")
需要注意的是，finally 语句只需要与 try 配合使用即可，不需要强制存在 except 或 else 块；而 else 则必须与 try 和至少一个 except 共同出现才有效。
raise在开发者还可以在程序中手动抛出异常，使用的是 raise [exceptionName [(reason)]] 语句。其中括号内的内容为可选参数，用于指定异常类型及具体的错误描述信息。
如果省略所有可选参数，raise 将重新抛出当前上下文中正在处理的异常；若只省略 reason，则抛出异常时不附带详细说明。
为了获取更详细的异常信息，可以使用 sys 模块中的 exc_info() 方法，该方法返回一个包含异常类型、异常值和 traceback 对象的元组，便于调试和日志记录。
Python 具备强大的模块化支持能力。这体现在多个方面：标准库中包含了大量实用的标准模块，社区提供了丰富的第三方模块，同时开发者也可以创建自定义模块。利用这些模块，能够显著提升开发效率，促进代码复用。
导入模块的基本语法如下：
importimport 模块名1 [as 别名1], 模块名2 [as 别名2]，…导入指定模块中的所有成员时，可以使用特定语法格式的 import 语句。该方式会将模块内的全部内容（如变量、函数、类等）引入当前程序。但在实际调用这些成员时，必须以模块名或其别名为前缀进行访问，否则 Python 解释器将抛出错误。
from 模块名 import 成员名1 [as 别名1]，成员名2 [as 别名2]，…另一种 import 语句的写法则仅导入模块中明确指定的部分成员，而非整个模块的所有内容。这种方式在使用被导入的成员时更加便捷——无需添加模块名前缀，可直接通过成员名或其设定的别名进行调用。
上述两种语法中，用 [] 括起的内容属于可选项，可以根据需要决定是否使用。
在 Python 中，包本质上是一个包含特殊文件 __init__.py 的目录。创建一个自定义包的过程非常简单，只需完成以下两个步骤：首先新建一个文件夹，并将其命名为所需的包名；然后在该文件夹内创建相应的 .py 文件即可。
py导入包或模块的操作支持多种语法形式，常见的主要有以下三种：
import 包名[.模块名 [as 别名]]from 包名 import 模块名 [as 别名]from 包名.模块名 import 成员名 [as 别名]其中，被 [] 包裹的部分依然表示可选内容，可根据具体需求选择是否包含。
要查看某一模块所包含的成员列表，可以使用内置的 dir() 函数。例如：
import string
dir(string)此函数返回的结果不仅包括可供外部使用的普通成员，还会列出许多名称以双下划线开头和结尾的“特殊”成员。这些特殊成员通常用于内部机制，对一般开发者而言参考价值有限。
dir()除了 dir() 函数外，还可以借助 __all__ 变量来查看模块中的成员。该变量常用于定义模块对外公开的接口，因此它不会显示那些特殊的内置成员，更适合用于了解模块的实际可用功能。
__all__此外，__doc__ 属性可用于查看模块（或包）的具体功能说明，帮助理解其用途。
__doc__若需查找某个模块或包对应的物理存储路径，可通过 __file__ 属性获取其所在位置，进而直接查阅源代码文件。
__file__Python 提供了内置的文件对象以及一系列用于操作文件和目录的模块，使得数据持久化（如保存到文本文件）变得十分简便。
不同操作系统对路径分隔符的处理有所不同：Windows 使用反斜杠 “\” 作为目录分隔符，而 OS X 和 Linux 则采用正斜杠 “/”。在编写跨平台程序时需要注意这一点，尤其是在使用反斜杠时，应考虑转义问题。
对于系统级别的文件操作（如删除文件），功能较为基础且易于实现，通常可通过引入 os 等标准库模块并调用其提供的函数来完成。例如：
import os
os.remove("a.txt")应用级别的文件操作一般遵循三个基本步骤，每个步骤都依赖于特定的函数支持：
open() 函数实现，该函数会返回一个文件对象，供后续操作使用。open()read()、readline() 或 readlines() 等函数；read()、readline() 以及 readlines()write() 函数。write()close() 函数关闭文件，释放资源。close()调用 open() 函数创建文件对象的基本语法如下：
file = open(file_name [, mode='r' [ , buffering=-1 [ , encoding = None ]]])open()Python 提供了多个函数用于从文件中读取数据：
read()：按字节或字符逐个读取文件内容；readline()：每次读取一行内容；readlines()：一次性读取所有行并返回一个列表。
文件对象的 write() 方法可用于向文件写入指定字符串内容。示例如下：
file.write(string)而 close() 方法专门用于关闭已打开的文件，确保资源正确释放：
file.close()为了实现对文件指针位置的控制，Python 文件对象提供了 tell() 和 seek() 两个方法：
tell() 用于获取当前文件指针的位置；file.tell()seek() 用于将文件指针移动到指定偏移位置。file.seek(offset[, whence])推荐使用 with as 语句来操作已打开的文件对象（因其本身是上下文管理器）。这种方式能够保证无论代码块中是否发生异常，文件都会在执行结束后自动关闭。
with 表达式 [as target]:
代码块
扫码加好友，拉您进群
