一、基础
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()的要点如下:
- 名称固定,必须为:init()
- 第一个参数固定,必须为:self。 self 指的就是刚刚创建好的实例对象。
- 构造函数通常用来初始化实例对象的实例属性
- 通过“类名(参数列表)”来调用构造函数。调用后,将创建好的对象返回给相应的变量
- init()方法:初始化创建好的对象,初始化指的是:“给实例属性赋值”
- new()方法: 用于创建对象,但我们一般无需重定义该方法。
- 如果我们不定义__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 对于类的成员没有严格的访问控制限制,这与其他面向对象语言有区别。关于私有属性和私有方法,有如下要点:
- 通常我们约定,两个下划线开头的属性是私有的(private)。其他为公共的(public)。
- 类内部可以访问私有属性(方法)
- 类外部不能直接访问私有属性(方法)
- 类外部可以通过“_类名__私有属性(方法)名”访问私有属性(方法)
@property 可以将一个方法的调用方式变成“属性调用”,需要配合getter、setter 方法来使用
属性和方法命名总结:
_xxx:保护成员,不能用“from module import * ”导入,只有类对象和子类对象能访 问这些成员。
xxx:系统定义的特殊成员
__xxx: 类中的私有成员,只有类对象自己能访问,子类对象也不能访问。(但,在类外部可以通过“对象名. _类名__xxx”这种特殊方式访问。Python 不存在严格意义的私有成员)
注:方法和属性都遵循上面的规则。
继承
Python 支持多重继承,一个子类可以继承多个父类。继承的语法格式如下:
class 子类类名(父类 1[,父类 2,…]):
类体
- 成员继承:子类继承了父类除构造方法之外的所有成员。
- 方法重写:子类可以重新定义父类中的方法,这样就会覆盖父类的方法,也称为“重写”
通过类的方法 mro()或者类的属性__mro__可以输出这个类的继承层次结构。
内置函数 dir(),可以让我们看到指定对象所有的属性。
object 有一个__str__()方法,用于返回一个对于“对象的描述”,对应于内置函数 str() 经常用于 print()方法,帮助我们查看对象的信息。str()可以重写
Python 支持多继承,如果父类中有相同名字的方法,在子类没有指定父类名时,解释器将 “从左向右”按顺序搜索
在子类中,如果想要获得父类的方法时,我们可以通过 super()来做。
super()代表父类的定义,不是父类对象
多态:
- 多态是方法的多态,属性没有多态。
- 多态的存在有 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。方式如下: 、
- import a.aa.module_AA 在使用时,必须加完整名称来引用,比如:a.aa.module_AA.fun_AA()
- from a.aa import module_AA 在使用时,直接可以使用模块名。 比如:module_AA.fun_AA()
- 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