1、注释的作用

单行注释： #

多行注释：三对单引号（’’’注释内容’’’）

增加程序的可读性

提高团队开发效率

作为调试使用

2、Python变量标识符

由字母、数字、下划线组成。只能以字母和下划线开头

建议使用驼峰命名法

不能与关键字重名，查看Python预置的关键字可以用：

import keyword

print(keyword.kwlist)

3、Python的数据类型包括

数字：整数int、浮点数float

布尔类型

字符串

字典

列表

元祖

集合set

4、运算符

逻辑运算符

赋值运算符

算术运算符

比较运算符

位运算符

5、编码

ASCLL编码：由大小写英文字母、数字和一些符号组成，共127个，这个编码表被称为ASCII编码。大写字母A的编码是65，小写字母z的编码是122

字符串会存在编码问题，ASCLL是不支持中文的。所以出现了Unicode编码。ASCII编码是1个字节，而Unicode编码通常是2个字节

在计算机内存中，统一使用Unicode编码，当需要保存到硬盘或者需要传输的时候，就转换为UTF-8编码。

【注】计算机中8bit作为一个字节

6、字符串处理

输入：input函数

输出：print函数

格式化输出

字符串的下标和切片

字符串的下标是从0开始

切片的语法：[起始:结束:步长]     包左不包右

 【例】    name = 'abcdef'

                print(name[0:3]) # 取 下标0~2 的字符

                结果：abc

字符串常用函数【重点】

【注】split函数经常会用到，经常用于把字符串分割。返回一个列表

【注】上诉函数都经常使用，find函数和index函数作用基本相同。find函数找不到返回-1，二index函数找不到会抛异常。根据实际情况选择

【注】strip常用于去掉特殊字符，如空格等

7、列表详解

列表创建：

列表可以包括各种类型的数据

访问列表：

一般是通过索引来访问，列表的索引值也是从0开始

列表操作

更新元素

student[0]=‘tom’    #直接重新赋值即可

添加元素

student.append(‘篮球’)   #添加到列表尾部

student.insert(4,‘音乐’)  #指定索引值添加

删除元素

查找元素

in 【存在】，存在则返回True

not in 【不存在】

列表函数

【注】最常用的当然是len方法啦，比如循环遍历得到列表中所有元素，循环的次数就是列表长度

【注】这j几个函数都用过，index函数用的更多点

8、元祖

元祖：元祖也是个容器，可以存放元素。它与列表的区别是元祖创建好了就不能更改了【不可变特性】

元祖名=(元素1,元素2,元素n…….)

元祖操作

访问元祖：通过索引值students[1]

删除元祖

tuple1=('abcd',123,3.33,'hello')

  print("删除之前的元祖为：",tuple1)

  del tuple1

  print("删除之后的元祖为：",tuple1)

元祖截取、切片

students=['jack','tom','john','amy','kim','sunny'] 

print("截取元素0:3",students[0:3])

元祖函数

9、字典

一种可变容器类型，且可以存储任意类型对象

创建

字典名={key1:value1,key2:value2}

访问

根据键值访问如：

students['name']        # 字典 students={'name':'tom','age':18,'sex‘:’男'}   

修改

直接重新给元素赋值即可

students['age']=20

添加元素

动态的向字典中添加元素的时候，只要添加的键在字典中不存在，就会新增这个元素。在以下字典中添加一个住址信息

students['address']='上海'

删除字典元素

del  字典名[key]  #删除字典中指定键值的元素

字典名.clear()         #  删除字典中所有元素，得到结果是空字典 {}

删除字典

del  字典名

字典方法【重点】

这三个函数都经常使用

第一个方法可以生成一个字典，第二个方法获取指定键值的value值，不存在也不会抛异常。在项目中也经常使用

通过这两个方法，掌握如何遍历一个字典

for  key in dict.keys()     #遍历key值

【注】第一个方法经常用来设置默认值

10、可变类型和不可变类型

 Python中string、tuple和number是不可变对象，而dict、list等是可变对象；不可变对象在进行重新赋值的时候，实际上是将原始值丢弃，将变量指向一个新值；可变对象的可变性实质上是指更改可变对象中的子对象，比如list中的item元素的更改。

11、浅拷贝和深拷贝

浅拷贝：不拷贝子对象(针对子对象中的item)，当子对象进行更改的时候，原始对象也会改变。常见操作：列表的切片[:]操作、list()操作，字典的copy()函数、copy模块的copy()函数（两个一模一样的双胞胎）

深拷贝：会拷贝子对象，当对原始对象子对象进行更改的时候，原始对象不会改变。常见操作是copy模块的deepcopy()函数

import copy

list_0 = ["A", "B",["C", "D"], "E"]

list_1 = copy.copy(list_0)

list_2 = list_0.copy()

list_3 = list_0[:]

list_4 = list(list_0)

# --- 深拷贝的拷贝方式 ---

list_d = copy.deepcopy(list_0)

# --- 深浅拷贝的区别 ---

# 1. 对第一层数据进行赋值

list_0[0] = "X0"

list_1[0] = "X1"

list_2[0] = "X2"

list_3[0] = "X3"

list_4[0] = "X4"

list_d[0] = "Xd"

# 打印结果: 理所当然,所有列表都发生了变化

# list_0: ['X0', 'B', ['C', 'D'], E]

# list_1: ['X1', 'B', ['C', 'D'], E]

# list_2: ['X2', 'B', ['C', 'D'], E]

# list_3: ['X3', 'B', ['C', 'D'], E]

# list_4: ['X4', 'B', ['C', 'D'], E]

# list_d: ['Xd', 'B', ['C', 'D'], E]

# 2. 对第二层的list引用进行赋值

list_0[2][0] = "Y0"

list_1[2][0] = "Y1"

list_2[2][0] = "Y2"

list_3[2][0] = "Y3"

list_4[2][0] = "Y4"

list_d[2][0] = "Yd"

# 打印结果:

0-1都被改成了同一个值,这说明浅拷贝只拷贝了第二层list的引用;而深拷贝则拷贝了数据结构

# list_0: ['X0', 'B', ['Y4', 'D'], E]

# list_1: ['X1', 'B', ['Y4', 'D'], E]

# list_2: ['X2', 'B', ['Y4', 'D'], E]

# list_3: ['X3', 'B', ['Y4', 'D'], E]

# list_4: ['X4', 'B', ['Y4', 'D'], E]

# list_d: ['Xd', 'B', ['Yd', 'D'], E]

# 3. 对第三层的Ls对象引用进行赋值

list_0[3]= "Z0"

list_1[3]= "Z1"

list_2[3]= "Z2"

list_3[3]= "Z3"

list_4[3]= "Z4"

list_d[3]= "Zd"

# 执行结果: 继续验证了上方论点

# list_0: ['X0', 'B', ['Y4', 'D'], Z4]

# list_1: ['X1', 'B', ['Y4', 'D'], Z4]

# list_2: ['X2', 'B', ['Y4', 'D'], Z4]

# list_3: ['X3', 'B', ['Y4', 'D'], Z4]

# list_4: ['X4', 'B', ['Y4', 'D'], Z4]

# list_d: ['Xd', 'B', ['Yd', 'D'], Zd]

print(list_0)

print(list_1)

print(list_2)

print(list_3)

print(list_4)

print(list_d)

思路一：利用切片操作和list方法拷贝等就叫浅拷贝，只是拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。

思路二：利用copy中的deepcopy方法进行拷贝就叫做深拷贝，外围和内部元素都进行了拷贝对象本身，而不是引用。

    但是对于数字，字符串和元组类型对象，没有被拷贝的说法，即便是用深拷贝，查看id的话也是一样的，如果对其重新赋值，也只是新创建一个对象，替换掉旧的而已

12、流程控制

条件控制语句

if条件

if条件：

      条件成立，执行代码块

if_else

if 条件:

  满足条件执行的代码块1

else:

  没有满足if条件执行的代码块2

if-elif-else

if 条件:

  满足if条件执行的代码块1

elif 条件1:

  满足条件1执行的代码块2

elif 条件2:

  满足条件2执行的代码块3

else:

  不满足以上条件执行的代码块4

循环语句

wile循环：

while 条件:

  代码块

while-else

while 条件:

  满足条件执行代码块

else:

  不满足条件执行代码块

break和continue

continue：退出当前循环，再继续执行下一次循环

break：退出循环

【注】代码块内一般有语句可以影响条件，这样当条件不满足时候才会跳出循环。在循环语句中使用break的作用是，在循环体内遇到break则会跳出循环，终止循环，并且不论循环的条件是否为真，都不再继续循环下去

for循环

for     <variable>     in <sequence>:

         statements

else:

        statements

【注】sequence可以是列表元组集合，如果是字典只能遍历keys，无法遍历values

for循环也可以用break和continue

13、pass语句

 pass语句的使用表示不希望任何代码或者命令的执行；

 pass语句是一个空操作，在执行的时候不会产生任何反应；

 pass语句常出现在if、while、for等各种判断或者循环语句中；

pass语句也可以出现在函数中

14、range函数

Python中range() 函数返回的是一个整数序列的对象，一般用在for 循环中。比如说获取1000个随机数。for i in range(1000)

函数语法

 range(start, stop[, step])

参数说明：

start: 计数从start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;

end: 计数到end 结束，但不包括 end。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5

step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)

15、推导式

列表推导式：列表推导式(list comprehension)是利用其它列表创建新列表的一种方式，工作原理类似for循环，即可对得到的元素进行转换变形 ，其基本格式如下（可以有多个for语句）

[expr for value in collection ifcondition]

例：sum=[ m[i][j]*n[i][j]for i in range(3) for j in range(3)]

        print(sum)

集合推导式：集合推导式跟列表推导式非常相似，唯一区别在于用{}代替[]。其基本格式如下:

{ expr for value in collection if    condition }

16、内置函数

常用的内置函数有：

iter返回一个迭代器，参数是一个可 迭代对象，比如说是list、dict

type ：用来获取对象类型或者构建一个类

id：用来获取对象的ID值，经常用来判断两个是否是同一个对象

len:获取序列的长度，比如列表、字典、元祖

dir:获取一个类或者模块公共的属性和方法

int、float、tuple、dict、str、list常用于格式转换，获取整形、浮点型、元祖、字典、字符串、列表类型的数据

input 获取输入值

super获取父类

17、函数

组织好的、可重复使用的、用户实现单一或者关联功能的代码段。函数能够提高应用的模块性和代码的重复利用率。

函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。

任何传入参数和自变量必须放在圆括号中间。

函数的第一行语句可以选择性地使用文档字符串---用于存放函数说明。

函数内容以冒号起始，并且缩进。

函数定义语法如下：

 def     函数名([参数列表]):      #参数列表可选项

          函数体

函数名其实就是指向一个函数对象的引用，完全可以把函数名赋值给一个变量，相当于给这个函数起了一个别名

函数调用

语法：函数名([参数列表])

函数参数

必备参数 （位置实参）

关键字参数

关键字实参是传递给函数的名称-值对。直接在实参中将名称和值关联起来，因此向函数传递实参时不会混淆。函数调用使用关键字参数来确定传入的值。使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为Python 解释器能够用参数名匹配参数值.

默认参数

函数定义的时候，设置的参数是形参。那么也可以给每个形参指定一个默认值。当调用函数时，如果没有传入实参，就使用形参的默认值。如果调用的时候传入了实参，那么程序将使用传入的实参

不定长参数

加了星号（*）的变量名会存放所有未命名的变量参数，变量用元祖来接受

加了(**)会存放所有命名的变量参数，变量用字典来接受

参数传递与数据类型

      不可变类型：如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改a 的值，只是修改另一个复制的对象，不会影响 a 本身。

      可变类型：如 列表，字典。如 fun（la），则是将la 真正的传过去，修改后fun外部的la也会受影响

函数返回值

使用return关键字。 函数并非总是将结果直接输出，相反，函数的调用者需要函数提供一些通过函数处理过后的一个或者一组数据，只有调用者拥有了这个数据，才能够做一些其他的操作。那么这个时候，就需要函数返回给调用者数据，这个就被称之为返回值，想要在函数中把结果返回给调用者

【注】return后语句不再执行，返 回值是个元祖。   

 print是将结果输出到控制台，return语句结束函数的调用，并将结果返回给调用者，且返回的结果不能输出到控制台（也就是不能直接打印出来）需要通过print才能打印出来

return语句用于退出函数，并选择性的向调用者返回一个表达式。直接return的语句或者没有返回值的函数默认返回None。

18、生成器

概念：在 Python 中，使用了 yield 的函数被称为生成器（generator）。跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。

生成器创建有两种方式

方式1：使用yield关键字， yield 的作用就是把一个函数变成一个generator，带有 yield 的函数不再是一个普通函数，Python 解释器会将其视为一个生成器，如调用Xun函数,不会执行该函数，而是返回一个iterable迭代对象！ 在调用生成器运行的过程中，每次遇到 yield时函数会暂停并保存当前所有的运行信息，返回yield的值。并在下一次从当前位置继续运行

def test_gen():

    i, a, b =0, 0, 1

          while i <1000:

                a, b = b, a+b

                yield b

                i = i +1

区别:与return类似，都可以返回值，但不一样的地方，yield可以返回多次值，而return只能返回一次。跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。

方式2：可以使用列表生成式

generator_ex = (x*x for x in range(10))

for i in generator_ex:

      print(i)

我们创建一个generator后，基本上永远不会调用next()，而是通过for循环来迭代，并且不需要关心StopIteration的错误，generator非常强大，如果推算的算法比较复杂，用类似列表生成式的for循环无法实现的时候，还可以用函数来实现。比如著名的斐波那契数列

注意:可以通过for循环或者手动调用 Xun(5) 的 next() 方法

def Xun(max):

        n=0

        b=1

        while n < max:

                yield b

                # print(b)

                b+=1

                n = n + 1

一般的函数在执行完毕之后会返回一个值然后退出，但是生成器函数会自动挂起，然后重新拾起继续执行，他会利用yield关键字关起函数，给调用者返回一个值，同时保留了当前的足够多的状态，可以使函数继续执行

19、迭代器

迭代器：实现了两个方法 __iter__() 与 __next__() 。

__iter__() 方法返回一个特殊的迭代器对象

__next__() 方法会返回下一个迭代器对象。

迭代是Python最强大的功能之一，是访问集合元素的一种方式。迭代器是一个可以记住遍历的位置的对象。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。迭代器有两个基本的方法：iter() 和 next()。字符串，列表或元组,集合对象都可用于创建迭代器

生成器都是Iterator对象，但list、dict、str虽然是Iterable（可迭代对象），却不是Iterator（迭代器）。

>>>list=[1,2,3,4]

>>> it =iter(list) # 创建迭代器对象

>>> print(next(it)) # 输出迭代器的下一个元素 1

>>> print(next(it)) 2

小结：

凡是可作用于for循环的对象都是Iterable类型；

凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；

集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。

生成器一定是迭代器，但是迭代器不一定是生成器

20、变量作用域

局部变量：定义在函数内部的变量拥有一个局部作用域

不同的函数，可以定义相同的名字的局部变量，但是各用个的不会产生影响

全局变量：全局变量是声明在函数外部的变量，定义在函数外的拥有全局作用域

对于可变类型的全局变量来说，要在函数中修改可以不使用global声明，对于不可变类型的全局变量来说，要在函数中修改需要global声明

21、匿名函数

匿名函数：定义函数的过程中，没有给定名称的函数就叫做匿名函数；Python中使用lambda表达式来创建匿名函数。

lambda 来创建匿名函数规则。

 ●lambda只是一个表达式，函数体比def简单很多。

  ●lambda的主体是一个表达式，而不是一个代码块，所以不能写太多的逻辑进去。

 ●lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。

 ●lambda定义的函数的返回值就是表达式的返回值，不需要return语句块

 ●lambda表达式的主要应用场景就是赋值给变量、作为参数传入其它函数

lambda匿名函数的表达式规则是：lambda     参数列表: 表达式

22、递归函数

递归函数：递归就是子程序（或函数）直接调用自己或通过一系列调用语句间接调用自己，是一种描述问题和解决问题的基本方法。（一句话，自己调用自己）

23、内置函数

常用内置函数

常用高阶函数【面试会问】

24、面对对象

面向过程：根据业务逻辑从上到下写代码

函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可

面向对象：对函数进行分类和封装，让开发“更快更好更强…”

类是对象的类型，具有相同属性和行为事物的统称。类是抽象的。万物皆对象，对象拥有自己的特征和行为。类是对象的类型，对象是类的实例。类是抽象的概念，而对象是一个你能够摸得着，看得到的实体。二者相辅相成，谁也离不开谁。

25、类的介绍

类定义：

class 类名：

      属性列表

      方法列表

类属性

类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。如果需要用在函数中使用类名.类属性.。在__init__()里初始化，在内部用classname.类属性名调用，外部既可以用classname.类属性名又可以用instancename.类属性名来调用

实例变量：定义在方法中的变量，只作用于当前实例的类。在__init__(self,...)中初始化，内部调用时都需要加上self.属性名，外部调用时用“对象名.属性名”调用

私有属性：双下划线__开头：外部不可通过“对象名.属性名”来访问或者更改实际将其转化为了“_类名__属性名”。只能在本类里面使用

【注】我们把需要用户传入的属性作为实例属性，而把同类都一样的属性作为类属性。实例属性在每创造一个类是都会初始化一遍，不同的实例的实例属性可能不同，不同实例的类属性都相同

属性操作

属性访问【常用方式】：实例化对象名+.来访问对象的属性

getattr(obj, name[, default]) : 访问对象的属性

hasattr(obj,name) : 检查是否存在一个属性

setattr(obj,name,value) : 设置一个属性。如果属性不存在，会创建一个新属性

delattr(obj, name) : 删除属性

注意:name需要加单引号,obj为实例化对象名称

类方法与静态方法

（1）：普通方法：外部用实例调用

def     fun_name(self,...):

　　　pass

（2）静态方法

通过装饰器 @staticmethod  装饰， 不能访问实例属性 ， 参数不能传入self，与类相关但是不依赖类与实例的方法。通过类或者实例调用

（3）类方法

通过@classmethod装饰，类方法不能访问实例属性，第一个参数必须传入cls参数（即代表了此类对象-----区别------self代表实例对象），并且用此来调用类属性：cls.类属性名

【注】静态方法与类方法都可以通过类或者实例来调用。其两个的特点都是不能够调用实例属性

静态方法不需要接收参数,使用类名.类属性

常用概念

实例化：创建一个类的实例，类的具体对象。

方法：类中定义的函数。

对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

26、面向对象的三个重要概念

继承

程序中当我们定义一个class的时候，可以从某个现有的class继承，新的class称之为子类（Subclass），而被继承的class称之为基类、父类或超类。子类继承了其父类的所有属性和方法，同时还可以定义自己的属性和方法。

【注】在子类中调用父类时候用super（）表示父类

多继承

语法格式

class     DerivedClassName(Base1, Base2，Base3):

【注】圆括号中父类的顺序，如果继承的父类中有相同的方法名，而在子类中使用时未指定，python将从左至右查找父类中是否包含方法。

重写

指的是子类重写父类方法。方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。

27、__init__（）方法介绍

__init__（）是一个特殊的方法属于类的专有方法，被称为类的构造函数或初始化方法,方法的前面和后面都有两个下划线。这是为了避免Python默认方法和普通方法发生名称的冲突。一般方法需要显式调用才能执行，当时初始化方法不同。每当创建类的实例化对象的时候，__init__()方法都会默认被运行。作用就是初始化已实例化后的对象。

28、self参数

在实例方法定义中，第一个参数self是必不可少的。类的方法和普通的函数的区别就是self，self并不是Python的关键字，你完全可以用其他单词取代他，只是按照惯例和标准的规定，推荐使用self。self代表的是类实例

29、内置类属性

__dict__ : 类的属性（包含一个字典，由类的属性名:值组成） 实例化类名.__dict__

__doc__ :类的文档字符串  (类名.)实例化类名.__doc__

__name__: 类名,实现方式 类名.__name__

__bases__ : 类的所有父类构成元素（包含了以个由所有父类组成的元组）

30、__name__介绍

__name__:如果是放在Modules模块中，就表示是模块的名字； 如果是放在Classs类中，就表示类的名字；

__main__：模块，xxx.py文件本身.被直接执行时，对应的模块名就是__main__了可以在if    __name__ == “__main__”:中添加你自己想要的，用于测试模块，演示模块用法等代码。作为模块，被别的Python程序导入（import）时，模块名就是本身文件名xxx了。

31、单下划线、双下划线、头尾双下划线说明

私有属性【双下划线】：

为了保护属性不被随意修改和访问，可以将属性定义为私有属性。如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线__，在Python中，实例变量名如果以__开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问.

__foo__: 定义的是特殊方法，类似 __init__() 之类的。 

_foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问(创建的实例可以访问)，不能用于 from    module      import      *  

__foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。

32、Python模块的概念

       每一个 Python 脚本文件都可以被当成是一个模块，模块里的代码可以是一段直接执行的脚

本，也可以是一堆类似库函数的代码，从而可以被别的模块导入(import)调用。模块可以包含直

接运行的代码块、类定义、函数定义或这几者的组合

【注】模块导入顺序：Python标准库模块    Python第三方模块：    应用程序自定义模块：

模块导入语法：import module1

在调用模块中的函数时，必须加上模块名调用，因为可能存在多个模块中含有相同名称的函数，此时，如果只是通过函数名来调用，解释器无法知道到底要调用哪个函数。为了避免这样的情况，调用函数时，必须加上模块名.

语法：模块名.函数名

from…import

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中，可以是属性、类、方法，使用这种方式导入，不会整个模块导入到当前命名空间，它只会将import的内容导入。

from…import *

导入一个模块的所有内容也可以使用from…import*。

语法：from modname    import*

起别名之扩展import语句（as）

       有时候你导入的模块名称已经在你的程序中使用了, 或者你不想使用现有的名称。可以使用一个新的名称替换原始的名称

import     pandas    as   pd        #使用as重新命名

当你导入一个模块，Python解析器对模块位置的搜索顺序是：

【注】如果当前路径或 Pyth。onPATH中存在与标准module同样的module,则会覆盖标准module所以自己创建的模块命名的时候要注意

33、dir函数

dir()函数一个排好序的字符串列表，内容是一个模块里定义过的名字。

返回的列表容纳了在一个模块里定义的所有模块，变量和函数。

34、Python标准库

详细请见：http://www.cnblogs.com/ribavnu/p/4886472.html

常用：os  re  sys

35、包

包是一种管理 Python 模块命名空间的形式，采用"点模块名称"。比如一个模块的名称是 A.B， 那么他表示一个包 A中的子模块B

目录中只有包含一个叫做__init__.py的文件才会被认作是一个包，__init__.py控制着包的导入行为。如果__init__.py文件为空的话，仅仅是把这个包导入，不会导入包中的模块。__init__.py中的__all__变量，是用来控制from包名import * 时导入的模块，可以在__init__.py中编写其他内容，在导入时，这些编写的内容就会被执行。可以在__init__.py中向sys.path添加当前被调用模块路径

在导入包的时候，Python会从sys.path中的目录来寻找这个包中包含的子目录

有效避免模块名称冲突问题，让应用组织结构更加清晰

包将有联系的模块组织在一个，即放到同一个文件夹下

36、__all__属性

1.编写Python代码(不建议在__init__中写python模块，可以在包中在创建另外的模块来写，尽量保证__init__.py简单）

2.模块中不使用__all__属性，则导入模块内的所有公有属性，方法和类。 模块中使用__all__属性，则表示只导入__all__中指定的属性，因此，使用__all__可以隐藏不想被import的默认值。__all__变量是一个由string元素组成的list变量。它定义了当我们使用 from <module> import * 导入某个模块的时候能导出的符号（这里代表变量，函数，类等）。

3. from<module> import * 默认的行为是从给定的命名空间导出所有的符号（当然下划线开头的变量，方法和类除外）。 需要注意的是 __all__只影响到了from<module> import * 这种导入方式， 对于 from<module> import <member> 导入方式并没有影响，仍然可以从外部导入。

37、reload

默认情况下，模块在第一次被导入之后，其他的导入都不再有效。如果此时在另一个窗口中改变并保存了模块的源代码文件，也无法更新该模块。这样设计原因在于，导入是一个开销很大的操作（导入必须找到文件，将其编译成字节码，并且运行代码），以至于每个文件、每个程序运行不能够重复多于一次。当一个模块被导入到一个脚本，模块顶层部分的代码只会被执行一次。因此，如果你想重新执行模块里顶层部分的代码，可以用reload()函数。该函数会重新导入之前导入过的模块。语法如下： reload(module_name)

38、python文件操作

在python中，使用open函数，打开一个已经存在的文件，或者新建一个新文件。

函数语法     open(name[, mode[, buffering[,encoding]]])

name : 一个包含了你要访问的文件名称的字符串值(区分绝对路径和相对路径)。

mode : mode决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。

buffering : 如果 buffering 的值被设为 0，就不会有寄存。如果

buffering 的值取 1，访问文件时会寄存行。如果将 buffering 的值设为大于 1的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。

关闭文件：文件对象.close()

文件读写：文件对象. read(num)

read（num）可以读取文件里面的内容。num表示要从文件中读取的数据的长度（单位是字节），如果没有传入num，那么就表示读取文件中所有的数据

代码：        file1=open('Test.txt','rw')#创建文件对象

                   content = file1.read()  

                   file1.close()#关闭文件

逐行读取文件readlines：可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素

【注】读取文本文件时，Python将其中的所有文本都解读为字符串。如果你读取的是数字，并

要将其作为数值使用，就必须使用函数int()将其转换为整数，或使用函数float()将其转

换为浮点数

往文件写入write

with open(filename,'w') as file_object:

            file_object.write("I loveprogramming.")

如果你要写入的文件不存在，函数open()将自动创建它。

我们使用文件对象的方法write()将一个字符串写入文件.这个程序是没有终端输出

函数write()不会在你写入的文本末尾添加换行符,需要手动添加\n

【注】Python只能将字符串写入文本文件。要将数值数据存储到文本文件中，必须先使用函数

str()将其转换为字符串格式。

文件读写操作常用函数

上诉是读写操作常用函数

with…open

关键字with在不再需要访问文件后将其关闭。这可让Python去确定：你只管打开文件，并在需要时使用它，Python自会在合适的时候自动将其关闭。也可以调用open()和close()来打开和关闭文件,但这样做时，如果程序存在bug，导致close()语句未执行，文件将不会关闭

文件访问模式

39、异常处理

异常是指在程序执行过程中发生的一个事件，会影响程序的正常运行，所以一般需要进行捕获异常并处理。

异常的捕获使用try/except/finally语句进行捕获操作,并告诉python发生异常时怎么办.

try:

   <语句>

except <异常类型1>[, 异常参数名1]:

   <异常处理代码1>

except <异常类型2>[, 异常参数名2]:

   <异常处理代码2>

else:

   <没有异常时候的处理代码>

finally:

   <不管是否有异常，最终执行的代码块>

常见异常

【注】

try语句按照如下方式工作:

（1）首先，执行try子句（在关键字try和关键字except之间的语句）

（2）如果没有异常发生，忽略except子句，try子句执行后结束。

（3）如果在执行try子句的过程中发生了异常，那么try子句余下的部分将被忽略。如果异常的类型和except 之后的名称相符，那么对应的except子句将被执行。最后执行 try语句之后的代码。

（4）如果一个异常没有与任何的except匹配，那么这个异常将会传递给上层的try中。

（5）一个 try 语句可能包含多个except子句，分别来处理不同的特定的异常。

（6）多只有一个分支会被执行。处理程序将只针对对应的try子句中的异常进行处理，而不是其他的 try的处理程序中的异常。

（7）.一个except子句可以同时处理多个异常，这些异常将被放在一个括号里成为一个元组

40、OS模块

Python的os模块包含普遍的操作系统功能，并且与具体的平台无关。

常见函数与用法