Python基础学习笔记

一、基础

python语言的主要特点是可读性强、代码简单、代码量少，相比于C like语言，代码量可大大减少，但是python的执行效率相比于C、C++等较低。因此，python主要适用于数据处理、数据分析、人工智能等方面。
python语言在语法上与C like语言有很大的不同，（1）python语言是以缩进而不是{}表示代码块 （2）python一行结尾不用加“；” （3）python变量无需声明类型
python中一切皆对象，由标识（identity）、类型（type）、value（值）组成 。变量在python中也可称为对象的引用。
注：python中变量虽然没有指定类型，但引用的对象有类型，在操作时仍需注意操作数据的类型。
python中变量的地址也有所不同，在C、C++中两个变量的地址不同。但python中有可能会相同

原因：Python 仅仅对比较小的整数对象进行缓存（范围为[-5,256]）缓存起来，而并非是所有整数对象。需要注意的是，这仅仅是在命令行中执行，而在 Pycharm 或者保存为文件执行，结果是不一样的，这是因为解释器做了一部分优化(范围是[-5,任意正整数])。

python中对变量位数没有进行限制，因此适用于数据计算和分析

标识符：用于变量、函数、类、模块等的名称。标识符有如下特定的规则：1. 区分大小写。如：sxt 和 SXT 是不同的 2. 第一个字符必须是字母、下划线。其后的字符是：字母、数字、下划线 3. 不能使用关键字。比如：if、or、while 等。 4. （不同之处）以双下划线开头和结尾的名称通常有特殊含义，尽量避免这种写法。比如__init__是类的构造函数
python中另外一个不同的地方，有删除变量和垃圾回收机制

python运算符与C不同之处：
/ 浮点数除法 例：5/2 = 2.5
// 整数除法 例：5/2 = 2

python中进制表示
0b 或 0B，二进制
0o 或 0O，八进制
0x 或 0X，十六进制

python中类型转换
格式： 类型（value）
注：转换时需注意int（“123”）通过，但int（“123abc”）报错，需注意
自动类型转换： 两个不同类型数据操作，结果自动转换为高精度类型 例：1 + 2.0 = 3.0
round(value)可以返回四舍五入的值
注：python中没有常量，不像C中常量不可更改，Python中常量可以改，不过我们一般不会去改

python 中可以通过 time.time() 获得当前时刻，返回的值是以秒为单位

python逻辑运算符：or and not
注：（1）or：a or b a为true，直接返回a，不看b
（2）and：a and b a、b都为true，返回b；a为false，直接返回false，不看b

同一运算符：is—is 是判断两个标识符是不是引用同一个对象
is not—is not 是判断两个标识符是不是引用不同对象

运算符：**—幂运算
注：，Python 不支持自增(++)和自减(–)

二、字符串

Python 的字符串是不可变的，我们无法对原字符串做任何修改。但，可以将字符串的一部分复制到新创建的字符串，达到“看起来修改”的效果。注：单字符也是作为一个字符串使用的。
ord()可以把字符转换成对应的 Unicode 码；
chr()可以把十进制数字转换成对应的字符。

连续三个单引号或三个双引号，可创建多行字符串
注：若直接使用三个引号，是多行注释
len（）—用于得到字符串长度
转义字符：格式—“+特殊字符”

print：调用 print 时，会自动打印一个换行符。自己设置方法：通过参数 end = “任意字符串”。实现末尾添加任何内容
input()：可以使用 input()从控制台读取键盘输入的内容

我们可以通过在字符串后面添加[]，在[]里面指定偏移量，可以提取该位置的单个字符。注：python中[]可以为负数
replace()实现字符串替换 注：该过程会创建一个新对象
切片 slice 操作可以让我们快速的提取子字符串。格式为：[起始偏移量 start：终止偏移量 end：步长 step]（注：左闭右开）

split()分割字符串、 join()合并字符串 注：join()效率要远高于+

字符串驻留：仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串驻留池中。
Python 支持字符串驻留机制，对于符合标识符规则的字符串（仅包含下划线（_）、字母和数字）会启用字符串驻留机制驻留机制。

format()函数—可以通过{索引}/{参数名}，直接映射参数值，实现对字符串的格式化

可变字符串：使用 io.StringIO 对象或 array 模块。

三、序列

序列是一种数据存储方式，用来存储一系列的数据。在内存中，序列就是一块用来存放 多个值的连续的内存空间
注：序列中存储的是整数对象的地址，而不是整数对象的值

常用的序列结构有： 字符串、列表、元组、字典、集合

1.列表

列表：用于存储任意数目、任意类型的数据集合。
列表的创建：[]创建 和 list()创建
range()创建整数列表：语法格式为： range([start,] end [,step])
start 参数：可选，表示起始数字。默认是 0 end 参数：必选，表示结尾数字。 step 参数：可选，表示步长，默认为 1
注：append（）追加元素直接在原列表添加，效率高；+运算符会创建一个新的列表，效率低
extend()方法 将目标列表的所有元素添加到本列表的尾部，不创建新的列表对象

排序： sort排序修改原列表，不建新列表的排序； sorted()进行排序，这个方法返回新列表，不对原列表做修改
reversed()也支持进行逆序排列，与列表对象 reverse()方法不同的是，内置函数 reversed()不对原列表做任何修改，只是返回一个逆序排列的迭代器对象（注：迭代器只能使用一次）

推导式生成列表

2.元组 tuple

元组的创建：1、通过()创建元组。小括号可以省略； 2、通过 tuple()创建元组

元组的特性：元组的元素不能修改

zip：zip(列表 1，列表 2，…)将多个列表对应位置的元素组合成为元组，并返回这个 zip 对象

生成器推导式生成的不是列表也不是元组，而是一个生成器对象。 我们可以通过生成器对象，转化成列表或者元组。也可以使用生成器对象的__next__() 方法进行遍历，或者直接作为迭代器对象来使用。（注：元素访问结束后，如果需要重新访问其中的元素，必须重新创建该生成器对象。）

3.字典

字典是“键值对”的无序可变序列，字典中的每个元素都是一个“键值对”，包含：“键 对象”和“值对象”。可以通过“键对象”实现快速获取、删除、更新对应的“值对象”。

字典的创建：1、{}创建； 2、dict（）创建； 3、zip（）创建 4、使用fromkeys 创建值为空的字典

字典的访问：1、 通过 [键] 获得“值”。若键不存在，则抛出异常； 2、通过 get()方法获得“值”。推荐使用。优点是：指定键不存在，返回 None；也可以设定指定键不存在时默认返回的对象
列出所有的键值对：items 列出所有的键：keys 列出所有的值：values

字典的增加、删除、修改：1、给字典新增“键值对”。如果“键”已经存在，则覆盖旧的键值对；如果“键”不存在， 则新增“键值对”； 2、使用 update()将新字典中所有键值对全部添加到旧字典对象上。如果 key 有重复，则直接覆盖； 3、字典中元素的删除，可以使用 del()方法；或者 clear()删除所有键值对；pop()删除指定 键值对，并返回对应的“值对象”； 4、popitem() ：随机删除和返回该键值对。字典是“无序可变序列”，因此没有第一个元素、最后一个元素的概念；popitem 弹出随机的项，因为字典并没有"最后的元素"或者其他有关顺序的概念。若想一个接一个地移除并处理项，这个方法就非常有效（因为不用首先获取键的列表）

序列解包可以用于元组、列表、字典。序列解包可以让我们方便的对多个变量赋值。
序列解包用于字典时，默认是对“键”进行操作； 如果需要对键值对操作，则需要使用 items()；如果需要对“值”进行操作，则需要使用 values()；

字典核心底层原理： 字典对象的核心是散列表。散列表是一个稀疏数组（总是有空白元素的数组），数组的每个单元叫做 bucket。每个 bucket 有两部分：一个是键对象的引用，一个是值对象的引用。

字典的特点：内存消耗大、以空间换时间；键查询速度很快
注：往字典里面添加新建可能导致扩容，导致散列表中键的次序变化。因此，不要在遍历字 典的同时进行字典的修改。

4、集合

集合是无序可变，元素不能重复。实际上，集合底层是字典实现，集合的所有元素都是字典 中的“键对象”，因此是不能重复的且唯一的

集合的创建和删除：1、使用{}创建集合对象，并使用 add()方法添加元素； 2、使用 set()，将列表、元组等可迭代对象转成集合。如果原来数据存在重复数据，则只保 留一个； 3、remove()删除指定元素；clear()清空整个集合

集合相关操作：交集、并集、差集

四、控制语句

if 条件表达式:
语句/语句块
注：在 Python 中，条件表达式不能出现赋值操作符“=”

if 条件表达式 :
语句 1/语句块 1
else:
语句 2/语句块 2

三元条件运算符：条件为真时的值 if (条件表达式) else 条件为假时的值

if 条件表达式 1 :
语句 1/语句块 1
elif 条件表达式 2:
语句 2/语句块 2
…
elif 条件表达式 n :
语句 n/语句块 n
[else:
语句 n+1/语句块 n+1 ]

while 条件表达式：
循环体语句

for 变量 in 可迭代对象：
循环体语句
可迭代对象： 1. 序列。包含：字符串、列表、元组 2. 字典 3. 迭代器对象（iterator） 4. 生成器函数（generator） 5. 文件对象
for循环中可以使用range，range 对象是一个迭代器对象，用来产生指定范围的数字序列。格式为： range(start, end [,step]) 生成的数值序列从 start 开始到 end 结束（不包含 end）。若没有填写 start，则默认从 0 开始。step 是可选的步长，默认为 1

循环代码优化：1. 尽量减少循环内部不必要的计算 2. 嵌套循环中，尽量减少内层循环的计算，尽可能向外提。 3. 局部变量查询较快，尽量使用局部变量

使用 zip()并行迭代：可使用 zip()函数对多个序列进行并行迭代，zip()函数在最短序列“用完”时就会停止。

列表推导式生成列表对象，语法如下： [表达式 for item in 可迭代对象 ] 或者：[表达式 for item in 可迭代对象 if 条件判断]

字典的推导式生成字典对象，格式如下： {key_expression : value_expression for 表达式 in 可迭代对象}

集合推导式生成集合： {表达式 for item in 可迭代对象 } 或者：{表达式 for item in 可迭代对象 if 条件判断}

注：元组没有推导式

五、函数

Python 中，定义函数的语法如下：
def 函数名 ([参数列表]) :
‘’‘文档字符串’’’
函数体/若干语句

一般建议在函数体开始的部分附上函数定义说明，这就是“文档字符串”，也有人成为“函数的注释”。我们通过三个单引号或者三个双引号来实现，中间可以加入多行文字进行说明。
可通过调用 help(函数名.doc)可以打印输出函数的文档字符串

局部变量的查询和访问速度比全局变量快，优先考虑使用，尤其是在循环的时候

Python 中参数的传递都是“引用传递”，不是“值传递”。具体操作时分为两类： 1. 对“可变对象”进行“写操作”，直接作用于原对象本身。 2. 对“不可变对象”进行“写操作”，会产生一个新的“对象空间”，并用新的值填充这块空间。（起到其他语言的“值传递”效果，但不是“值传递”）
可变对象有： 字典、列表、集合、自定义的对象等
不可变对象有： 数字、字符串、元组、function 等
传递参数是可变对象（例如：列表、字典、自定义的其他可变对象等），实际传递的还是对 象的引用。在函数体中不创建新的对象拷贝，而是可以直接修改所传递的对象
传递参数是不可变对象（例如：int、float、字符串、元组、布尔值），实际传递的还是对 象的引用。在”赋值操作”时，由于不可变对象无法修改，系统会新创建一个对象

深浅拷贝：使用内置函数：copy(浅拷贝)、deepcopy(深拷贝)。
浅拷贝：不拷贝子对象的内容，只是拷贝子对象的引用。 深拷贝：会连子对象的内存也全部拷贝一份，对子对象的修改不会影响源对象

可变参数指的是“可变数量的参数”。分两种情况： 1. *param（一个星号），将多个参数收集到一个“元组”对象中。 2. **param（两个星号），将多个参数收集到一个“字典”对象中。
强制命名参数：在带星号的“可变参数”后面增加新的参数，必须在调用的时候“强制命名参数”。

lambda 表达式可以用来声明匿名函数。lambda 函数是一种简单的、在同一行中定义函数的方法。lambda 函数实际生成了一个函数对象。 lambda 表达式只允许包含一个表达式，不能包含复杂语句，该表达式的计算结果就是函数 的返回值。
lambda 表达式的基本语法如下：lambda arg1,arg2,arg3… : <表达式>
arg1/arg2/arg3 为函数的参数。<表达式>相当于函数体。运算结果是：表达式的运算结果。

eval()函数—功能：将字符串 str 当成有效的表达式来求值并返回计算结果。 语法： eval(source[, globals[, locals]]) -> value
参数：source：一个 Python 表达式或函数 compile()返回的代码对象； globals：可选。必须是 dictionary； locals：可选。任意映射对象

nonlocal 用来声明外层的局部变量。
global 用来声明全局变量。
Python 在查找“名称”时，是按照 LEGB 规则查找的： Local–>Enclosed–>Global–>Built in
Local 指的就是函数或者类的方法内部； Enclosed 指的是嵌套函数（一个函数包裹另一个函数，闭包；） Global 指的是模块中的全局变量； Built in 指的是 Python 为自己保留的特殊名称。

六、面向对象

定义类的语法格式如下：
class 类名：
类体

init()的要点如下：

1. 名称固定，必须为：init()
2. 第一个参数固定，必须为：self。 self 指的就是刚刚创建好的实例对象。
3. 构造函数通常用来初始化实例对象的实例属性
4. 通过“类名(参数列表)”来调用构造函数。调用后，将创建好的对象返回给相应的变量
5. init()方法：初始化创建好的对象，初始化指的是：“给实例属性赋值”
6. new()方法: 用于创建对象，但我们一般无需重定义该方法。
7. 如果我们不定义__init__方法，系统会提供一个默认的__init__方法。如果我们定义了带参 的__init__方法，系统不创建默认的__init__方法。

注：创建实例对象后，在python中可以给对象添加新属性

其它操作：1. dir(obj)可以获得对象的所有属性、方法
2. obj.dict 对象的属性字典
3. pass 空语句
4. isinstance（对象,类型） 判断“对象”是不是“指定类型

类属性是从属于“类对象”的属性，也称为“类变量”。由于，类属性从属于类对象，可以被所有实例对象共享。
类属性的定义方式：
class 类名：
类变量名= 初始值
在类中或者类的外面，我们可以通过：“类名.类变量名”来读写

类方法是从属于“类对象”的方法。类方法通过装饰器@classmethod 来定义，格式如下：
@classmethod
def 类方法名(cls [，形参列表]) ：
函数体
要点如下： 1. @classmethod 必须位于方法上面一行
2. 第一个 cls 必须有；cls 指的就是“类对象”本身；
3. 调用类方法格式：“类名.类方法名(参数列表)”。 参数列表中，不需要也不能给 cls 传 值。
4. 类方法中访问实例属性和实例方法会导致错误
5. 子类继承父类方法时，传入 cls 是子类对象，而非父类对象

Python 中允许定义与“类对象”无关的方法，称为“静态方法”。
静态方法通过装饰器@staticmethod 来定义，格式如下：
@staticmethod
def 静态方法名([形参列表]) ：
函数体
要点如下： 1. @staticmethod 必须位于方法上面一行
6. 调用静态方法格式：“类名.静态方法名(参数列表)”。
7. 静态方法中访问实例属性和实例方法会导致错误

__del__方法称为“析构方法”，用于实现对象被销毁时所需的操作。比如：释放对象 占用的资源，例如：打开的文件资源、网络连接等。
Python 实现自动的垃圾回收，当对象没有被引用时（引用计数为 0），由垃圾回收器 调用__del__方法。 我们也可以通过 del 语句删除对象，从而保证调用__del__方法。
系统会自动提供__del__方法，一般不需要自定义析构方法。

定义了__call__方法的对象，称为“可调用对象”，即该对象可以像函数一样被调用

注：Python 中是没有方法的重载的。如果我们在类体中定义了多个重名的方法，只有最后一个方法有效。 建议：不要使用重名的方法！Python 中方法没有重载。

注：与C语言不同，Python 是动态语言，我们可以动态的为类添加新的方法，或者动态的修改类的已有的方法。

python 对于类的成员没有严格的访问控制限制，这与其他面向对象语言有区别。关于私有属性和私有方法，有如下要点：

1. 通常我们约定，两个下划线开头的属性是私有的(private)。其他为公共的(public)。
2. 类内部可以访问私有属性(方法)
3. 类外部不能直接访问私有属性(方法)
4. 类外部可以通过“_类名__私有属性(方法)名”访问私有属性(方法)

@property 可以将一个方法的调用方式变成“属性调用”，需要配合getter、setter 方法来使用

属性和方法命名总结：
_xxx：保护成员，不能用“from module import * ”导入，只有类对象和子类对象能访 问这些成员。
xxx：系统定义的特殊成员
__xxx： 类中的私有成员，只有类对象自己能访问，子类对象也不能访问。（但，在类外部可以通过“对象名. _类名__xxx”这种特殊方式访问。Python 不存在严格意义的私有成员）
注：方法和属性都遵循上面的规则。

继承

Python 支持多重继承，一个子类可以继承多个父类。继承的语法格式如下：
class 子类类名(父类 1[，父类 2，…])：
类体

1. 成员继承：子类继承了父类除构造方法之外的所有成员。
2. 方法重写：子类可以重新定义父类中的方法，这样就会覆盖父类的方法，也称为“重写”
   通过类的方法 mro()或者类的属性__mro__可以输出这个类的继承层次结构。
   内置函数 dir()，可以让我们看到指定对象所有的属性。

object 有一个__str__()方法，用于返回一个对于“对象的描述”，对应于内置函数 str() 经常用于 print()方法，帮助我们查看对象的信息。str()可以重写

Python 支持多继承，如果父类中有相同名字的方法，在子类没有指定父类名时，解释器将 “从左向右”按顺序搜索

在子类中，如果想要获得父类的方法时，我们可以通过 super()来做。
super()代表父类的定义，不是父类对象

多态：

1. 多态是方法的多态，属性没有多态。
2. 多态的存在有 2 个必要条件：继承、方法重写。

Python 的运算符实际上是通过调用对象的特殊方法实现的，可自己重新调用，实现运算符重载

特殊属性：Python 对象中包含了很多双下划线开始和结束的属性，这些是特殊属性，有特殊用法

对象的拷贝：
浅拷贝：Python 拷贝一般都是浅拷贝。拷贝时，对象包含的子对象内容不拷贝。因此，源对象-和拷贝对象会引用同一个子对象。
深拷贝：使用 copy 模块的 deepcopy 函数，递归拷贝对象中包含的子对象。源对象和拷贝对象所有的子对象也不同

组合：“is-a”关系，我们可以使用“继承”。从而实现子类拥有的父类的方法和属性。“is-a” 关系指的是类似这样的关系：狗是动物，dog is animal。狗类就应该继承动物类。
“has-a”关系，我们可以使用“组合”，也能实现一个类拥有另一个类的方法和属性。” has-a”关系指的是这样的关系：手机拥有 CPU。 MobilePhone has a CPU。

单例模式（Singleton Pattern）的核心作用是确保一个类只有一个实例，并且提供一 个访问该实例的全局访问点。
单例模式只生成一个实例对象，减少了对系统资源的开销。当一个对象的产生需要比较 多的资源，如读取配置文件、产生其他依赖对象时，可以产生一个“单例对象”，然后永久驻留内存中，从而极大的降低开销。
单例模式有多种实现的方式，我们这里推荐重写__new__()的方法。

七、异常

所谓异常处理，就是指程序在出现问题时依然可以正确的执行剩余的程序，而不会因为异常而终止程序执行

try…except 是最常见的异常处理结构。结构如下：
try:
被监控的可能引发异常的语句块
except BaseException [as e]:
异常处理语句块
try 块包含着可能引发异常的代码，except 块则用来捕捉和处理发生的异常。执行的时候，如果 try 块中没有引发异常，则跳过 ecept 块继续执行后续代码；执行的时候，如果 try
块中发生了异常，则跳过 try 块中的后续代码，跳到相应的 except 块中处理异常；异常处理 完后，继续执行后续代码。

多个except结构：
try:
被监控的、可能引发异常的语句块
except Exception1:
处理 Exception1 的语句块
except Exception2:
处理 Exception2 的语句块
…
except BaseException：
处理可能遗漏的异常的语句块

try…except…else 结构增加了“else 块”。如果 try 块中没有抛出异常，则执行 else 块。如果 try 块中抛出异常，则执行 except 块，不执行 else 块

try…except…finally 结构中，finally 块无论是否发生异常都会被执行；通常用来释放 try 块中 申请的资源

finally 块由于是否发生异常都会执行，通常我们放释放资源的代码。其实，我们可以通 过 with 上下文管理，更方便的实现释放资源的操作。 with 上下文管理的语法结构如下：
with context_expr [ as var]：
语句块
with 上下文管理可以自动管理资源，在 with 代码块执行完毕后自动还原进入该代码之前的现场或上下文。不论何种原因跳出 with 块，不论是否有异常，总能保证资源正常释放。极大的简化了工作，在文件操作、网络通信相关的场合非常常用。

使用 Traceback 模块打印异常信息

程序开发中，有时候我们也需要自己定义异常类。自定义异常类一般都是运行时异常，通常 继承 Exception 或其子类即可。命名一般以 Error、Exception 为后缀。
自定义异常由 raise 语句主动抛出。

八、文件操作

open()函数用于创建文件对象，基本语法格式如下：
open(文件名[,打开方式])
write(a)：把字符串 a 写入到文件中
writelines(b)：把字符串列表写入文件中，不添加换行符

文件读取：1. read([size]) 从文件中读取 size 个字符，并作为结果返回。如果没有 size 参数，则读取整个文件。 读取到文件末尾，会返回空字符串。
2. readline() 读取一行内容作为结果返回。读取到文件末尾，会返回空字符串。
3. readlines() 文本文件中，每一行作为一个字符串存入列表中，返回该列表

序列化我们使用：
pickle.dump(obj, file) obj 就是要被序列化的对象，file 指的是存储的文件
pickle.load(file) 从 file 读取数据，反序列化成对象

CSV文件的操作：
csv.reader 对象于从 csv 文件读取数据
csv.writer 对象写一个 csv 文件

os 模块可以帮助我们直接对操作系统进行操作。我们可以直接调用操作系统的可执行 文件、命令，直接操作文件、目录等等。在系统运维的核心基础。
os.path 模块提供了目录相关（路径判断、路径切分、路径连接、文件夹遍历）的操作

os.walk()方法：
返回一个 3 个元素的元组，(dirpath, dirnames, filenames), dirpath：要列出指定目录的路径
dirnames：目录下的所有文件夹
filenames：目录下的所有文件

shutil 模块是 python 标准库中提供的，主要用来做文件和文件夹的拷贝、移动、删除等；还可以做 文件和文件夹的压缩、解压缩操作。
os 模块提供了对目录或文件的一般操作。shutil 模块作为补充，提供了移动、复制、压缩、解压等操 作，这些 os 模块都没有提供。

九、模块

我们可以通过help(模块名)查看模块的API。一般使用时先导入模块 然后通过help函数查看

导入模块：
import 语句的基本语法格式如下：
import 模块名 #导入一个模块
import 模块 1，模块 2… #导入多个模块
import 模块名 as 模块别名 #导入模块并使用新名字
import 加载的模块分为四个通用类别： a.使用 python 编写的代码（.py 文件）；
b.已被编译为共享库或 DLL 的 C 或 C++扩展；
c.包好一组模块的包
d.使用 C 编写并链接到 python 解释器的内置模块；

Python 中可以使用 from…import 导入模块中的成员。基本语法格式如下：
from 模块名 import 成员 1，成员 2，…

import 语句和 from…import 语句的区别
import 导入的是模块。from…import 导入的是模块中的一个函数/一个类。 如果进行类比的话，import 导入的是“文件”，我们要使用该“文件”下的内容，必须前面加“文件名称”。from…import 导入的是文件下的“内容”，我们直接使用这 些“内容”即可，前面再也不需要加“文件名称”了。

如果需要动态导入可以使用 importlib 模块，例：
import importlib
a = importlib.import_module(“math”)

一个模块无论导入多少次，这个模块在整个解释器进程内有且仅有一个实例对象
有时候我们确实需要重新加载一个模块，这时候可以使用：importlib.reload()

当一个项目中有很多个模块时，需要再进行组织。我们将功能类似的模块放到一起， 形成了“包”。本质上，“包”就是一个必须有__init__.py 的文件夹
包下面可以包含“模块(module)”，也可以再包含“子包(subpackage)”

导入：例、我们需要导入 module_AA.py。方式如下： 、

1. import a.aa.module_AA 在使用时，必须加完整名称来引用，比如：a.aa.module_AA.fun_AA()
2. from a.aa import module_AA 在使用时，直接可以使用模块名。 比如：module_AA.fun_AA()
3. from a.aa.module_AA import fun_AA 直接导入函数在使用时，直接可以使用函数名。 比如：fun_AA()
   注：1. from package import item 这种语法中，item 可以是包、模块，也可以是函数、 类、变量。
   2.import item1.item2 这种语法中，item 必须是包或模块，不能是其他

init.py 的三个核心作用： 1. 作为包的标识，不能删除。
2. 用来实现模糊导入
3. 导入包实质是执行__init__.py 文件，可以在__init__.py 文件中做这个包的初始化、以及 需要统一执行代码、批量导入

当我们导入某个模块文件时， Python 解释器去哪里找这个文件呢？只有找到这个文件才能读取、装载运行该模块文件。它一般按照如下路径寻找模块文件（按照顺序寻找，找到即停不继续往下寻找）： 1. 内置模块 2. 当前目录 3. 程序的主目录 4. pythonpath 目录（如果已经设置了 pythonpath 环境变量） 5. 标准链接库目录 6. 第三方库目录（site-packages 目录） 7. .pth 文件的内容（如果存在的话） 8. sys.path.append()临时添加的目录

十、python中链表的实现

在python中，如何实现链表结构？
python与C like语言不同，python中的变量存的是地址
因此实现非常简单

class SingleNode(object):
    """单链表的结点"""
    def __init__(self,item):
        # _item存放数据元素
        self.item = item
        # _next是下一个节点的标识
        self.next = None