大牛程序员总结了Python入门所需要掌握的知识点！史上超全的总结

1.3.2 Python引号

Python接受单引号（'），双引号（“）和三（''或”“”）引用，以表示字符串常量，只要是同一类型的引号开始和结束的字符串。

三重引号可以用于跨越多个行的字符串。

里面有各种学习资料和我整理的一份2018最新0基础入门视频，都无偿提供给大家，还有各种资料和开发工具包满足大家，希望搭建一个好的学习环境，每天里面更新最新Python市场行情。

1.4.Python的变量和集合

Python有五个标准的数据类型：

a) 数字

b) 字符串

c) 列表

d) 元组

e) 字典

f) set

python中定义变量时不需要显示指定变量类型，以下为python中变量使用的典型语法：

1.4.5字典

Python字典是一种哈希表型。由“键-值”对组成。

键可以是任何Python类型，但通常是数字或字符串。

值可以是任意Python的对象。

字典是由花括号括号{}，可分配值，并用方括号[]访问。例如：

1.4.6 set

定义一个set：

a=

print a

a.remove(3)

a.add(6)

a.union(b)

例如：

a=int(‘A’,16)

print(a)

结果为: 10

a=tuple(range(1,10,2))

print(a)

b=tuple("hello")

print b

c=complex(1,2)

print c

x=1

e=eval('x+1')

print e

f=dict([(1,2),(3,4),('a',100)])

print f

结果为：

(1, 3, 5, 7, 9)

('h', 'e', 'l', 'l', 'o')

(1+2j)

2

{'a': 100, 1: 2, 3: 4}

if else

1.5.2 while循环

1.5.3 for循环

1.6.Python函数

1.6.1 基本形式

默认参数和可变参数

1.6.2 匿名函数

² 可以使用lambda关键字来创建小的匿名函数。这些函数被称为匿名，因为它们不是以标准方式通过使用def关键字声明。

² Lambda形式可以采取任何数量的参数，但在表现形式上只返回一个值。它们不能包含命令或多个表达式。

² 匿名函数不能直接调用打印，因为需要lambda表达式。

² lambda函数都有自己的命名空间，并且不能访问变量高于在其参数列表和那些在全局命名空间的变量。

利用lambda可以实现类似于scala中的高阶函数效果：

print_func("Zara")

1.7.2 模块和包

在python中一个文件可以被看成一个独立模块，而包对应着文件夹，模块把python代码分成一些有组织的代码段，通过导入的方式实现代码重用。

1.7.1 模块搜索路径

导入模块时，是按照sys.path变量的值搜索模块，sys.path的值是包含每一个独立路径的列表，包含当前目录、python安装目录、PYTHONPATH环境变量，搜索顺序按照路径在列表中的顺序（一般当前目录优先级最高）。

1.7.2.2 使用from-import语句导入模块的属性

单行导入

from module import name1,name2,name3

多行导入

from module import name1,name2,

name3

导入全部属性（由于容易覆盖当前名称空间中现有的名字，所以一般不推荐使用，适合模块中变量名很长并且变量很多的情况）

from module import *

如果你不想某个模块的属性被以上方法导入，可以给该属性名称前加一个下划线(_test)，如果需要取消隐藏，可以显示的导入该属性（from module import _test）

1.7.2.3 扩展的import语句

使用自定义的名称替换模块的原始名称

import simplejson as json

模块被导入时，加载的时候模块顶层代码会被执行，如：设定全局变量、类和函数的声明等，所以应该把代码尽量封装到类和函数中。一个模块无论被导入多少次，只加载一次，可以防止多次导入时代码被多次执行。

1.7.2.4 重新导入模块

reload(module)

内建函数reload可以重新导入一个已经存在的模块

1.7.3.包结构

1.包定义结构

包将有联系的模块组织在一起，有效避免模块名称冲突问题，让应用组织结构更加清晰。

一个普通的python应用程序目录结构：

app/

__init__.py

a/

__init__.py

a.py

b/

__init__.py

b.py

app是最顶层的包，a和b是它的子包，可以这样导入：

from app.a import a

from app.b.b import test

a.test()

test()

上面代码表示：导入app包的子包a和子包b的属性test，然后分别调用test方法。

2. __init__.py的作用

每个目录下都有__init__.py文件，这个是初始化模块，from-import语句导入子包时需要它，可以在里面做一些初始化工作，也可以是空文件。

ps：__init__.py定义的属性直接使用 顶层包.子包 的方式导入，如在目录a的__init__.py文件中定义init_db()方法，调用如下：

from app import a

a.init_db()

b.py

在这里a尝试导入b，而b也尝试导入a，导入一个先前没有完全导入的模块，会导致导入失败。解决办法：移除一个导入语句，把导入语句放到函数内部，在需要的时候导入。

b.py

操作文件对象方法

例2:其他文件IO函数的使用

例3:用file(...)替换open(...)

例4:文件的写操作

指示你正在使用的平台：os.name 对于Windows，它是'nt'，而对于Linux/Unix用户，它是'posix'

重命名：os.rename（old， new）

创建多级目录：os.makedirs（r“c：pythonest”）

创建单个目录：os.mkdir（“test”）

获取文件属性：os.stat（file）

修改文件权限与时间戳：os.chmod（file）

终止当前进程：os.exit（）

1.9 Python多线程

Python中的多线程是伪线程；不能充分利用cpu中的多核，但是在io等待型的场景下多线程还是可以提高效率

Python中的多线程有多种实现方式，利用threading包实现是比较普遍的做法

示例代码如下：

1.10面向对象

1.10.1 创建类

使用class语句来创建一个新类，class之后为类的名称并以冒号结尾，如下实例:

类的帮助信息可以通过ClassName.__doc__查看。

class_suite 由类成员，方法，数据属性组成。

1.10.2 实例

以下是一个简单的Python类实例:

empCount变量是一个类变量，它的值将在这个类的所有实例之间共享。你可以在内部类或外部类使用Employee.empCount访问。

第一个方法__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法

类的方法

使用def关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数self,且为第一个参数

1.10.3 创建实例对象

要创建一个类的实例，你可以使用类的名称，并通过__init__方法接受参数。

访问属性

可以使用点(.)来访问对象的属性。使用如下类的名称访问类变量:

完整实例：

执行以上代码输出结果如下：

你可以添加，删除，修改类的属性，如下所示：

1.10.4 Python内置类属性

Python内置类属性调用实例如下：

执行以上代码输出结果如下：

Employee.__doc__: 所有员工的基类

Employee.__name__: Employee

Employee.__module__: __main__

Employee.__bases__: ()

Employee.__dict__: {'__module__': '__main__', 'displayCount': , 'empCount': 0, 'displayEmployee': , '__doc__': '所有员工的基类', '__init__': }

1.10.5 私有属性

1、类的私有属性

__private_attrs：两个下划线开头，声明该属性为私有，不能在类地外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs

2、类的私有方法

__private_method：两个下划线开头，声明该方法为私有方法，不能在类地外部调用。在类的内部调用 self.__private_methods

3、实例

运行结果会报错：

Python不允许实例化的类访问私有数据，但你可以使用 object._className__attrName 访问属性，将如下代码替换以上代码的最后一行代码：

.........................

print counter._JustCounter__secretCount

执行以上代码，执行结果如下：

1.10.6 python对象销毁(垃圾回收)

同Java语言一样，Python使用了引用计数这一简单技术来追踪内存中的对象。

在Python内部记录着所有使用中的对象各有多少引用。

一个内部跟踪变量，称为一个引用计数器。

当对象被创建时， 就创建了一个引用计数， 当这个对象不再需要时， 也就是说， 这个对象的引用计数变为0 时， 它被垃圾回收。但是回收不是"立即"的， 由解释器在适当的时机，将垃圾对象占用的内存空间回收。

a = 40 # 创建对象

b = a # 增加引用， 的计数

c = [b] # 增加引用. 的计数

del a # 减少引用 的计数

b = 100 # 减少引用 的计数

c[0] = -1 # 减少引用 的计数

垃圾回收机制不仅针对引用计数为0的对象，同样也可以处理循环引用的情况。循环引用指的是，两个对象相互引用，但是没有其他变量引用他们。这种情况下，仅使用引用计数是不够的。Python 的垃圾收集器实际上是一个引用计数器和一个循环垃圾收集器。作为引用计数的补充， 垃圾收集器也会留心被分配的总量很大（及未通过引用计数销毁的那些）的对象。 在这种情况下，解释器会暂停下来，试图清理所有未引用的循环。

实例

析构函数 __del__

__del__在对象销毁的时候被调用，当对象不再被使用时，__del__方法运行：

以上实例运行结果如下：

Point 销毁

1.10.7 类的继承

面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。继承完全可以理解成类之间的类型和子类型关系。

1、语法：

派生类的声明，与他们的父类类似，继承的基类列表跟在类名之后，如下所示：

class SubClassName (ParentClass1[, ParentClass2, ...]):

'Optional class documentation string'

class_suite

2、实例：

以上代码执行结果如下：

调用子类构造方法

调用子类方法 child method

调用父类方法

父类属性 : 200

你可以继承多个类

class A: # 定义类 A

.....

class B: # 定义类 B

.....

class C(A, B): # 继承类 A 和 B

.....

可以使用issubclass()或者isinstance()方法来检测。

issubclass() - 布尔函数判断一个类是另一个类的子类或者子孙类，语法：issubclass(sub,sup)

isinstance(obj, Class) 布尔函数如果obj是Class类的实例对象或者是一个Class子类的实例对象则返回true。

3、方法重写

如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法：

实例：

执行以上代码输出结果如下：

4、基础重载方法

下表列出了一些通用的功能，你可以在自己的类重写：

1/ __init__ ( self [,args...] )

构造函数

简单的调用方法: obj = className(args)

2/ __del__( self )

析构方法, 删除一个对象

简单的调用方法 : dell obj

3/ __str__( self )

用于将值转化为适于人阅读的形式

简单的调用方法 : str(obj)

4/ __cmp__ ( self, x )

对象比较

简单的调用方法 : cmp(obj, x)

以上代码执行结果如下所示:

Vector(7,8)

Python2中，print是一个关键字

Python3中，print是一个函数，必须使用print(arg)

1) 函数块以关键字def后跟函数名为定义头

2) 任何输入参数或参数应该放在这些括号内。还可以定义这些括号内的参数。

3) 函数的第一个语句可以是一个可选的声明 - 该函数或文档字符串的文档字符串。

4) 每个函数中的代码块以冒号(:)开头并缩进。

5) 该语句返回[表达式]退出功能，可选地传递回一个表达式给调用者。不带参数return语句返回None。