Python基础知识整理（值得收藏）

近年来，python语言非常流行，很多开发者都会学习一些python相关的知识。本文为大家整理了一些python的基础知识，希望对大家有所帮助。

注：下文Python代指Python3。

基本信息

• 和Javascript一样，面向对象、解释型、动态数据类型

• 一切皆为对象（
  <br /> Object<br />
  ），包含原始数据类型也由内置构造函数创建，高阶对象为
  <br /> Object<br />

• 单行注释使用#标识，多行注释同多行字符串

• 靠缩进约束逻辑分支，无大括号等多余运算符

• 支持多行单语句、单行多语句

• 变量无需声明，必须赋值才会正式声明

• 有自己的模块系统

• 文件以.py结尾。

基本构成

Python 中的一切都是对象。数字、字符串、元组、列表、字典、函数、方法、类、模块等都是对象。

不同的编程语言以不同的方式定义“对象”。在某些语言中，这意味着所有对象都必须具有属性和方法；在其他情况下，这意味着所有对象都可以被子类化。

在Python中，定义是松散的，某些对象既没有属性也没有方法，而且不是所有的对象都可以子类化。 简单可以解释为：

Python 中的一切都可以赋值给变量或者作为参数传递给函数。

所有对象都有三个共同特征：

• 
  身份
  
  ：即对象数据（非变量）在内存中的唯一id，可以通过函数
  <br /> id(obj)<br />
  得到

• 
  类型
  
  ：对象的类型决定了对象可以保存什么类型的值，有哪些属性和方法，可以进行哪些操作，遵循怎样的规则。可以使用内建函数
  <br /> type()<br />
  来查看对象的类型

• 
  值
  
  ：对象所表示的数据

大多数 Python 对象都有属性、值或方法，并且使用句点访问属性。符号。最常见的属性是函数和方法，有些Python对象也有数据属性，比如：类、模块、文件等。

数据存储

字符串和数值数据都是内存中的引用类型，即栈内存自己保存数据，堆内存维护一个变量池，如下例所示：

# 开辟内存存储数据'hello'，并创建变量a，并将a的指针指向此数据
a = 'hello'
# 开辟内存存储数据'world'，并更改变量a的指针，销毁数据'hello'
a = 'world'
# 开辟内存存储数据"hello world!"，并同时创建三个变量，将三个变量的指针同时指向此数据
b = c = d = "hello world!"
# 多个变量赋值，同上，分别先后对应
e, f, g = 1, 2, 'python'

实际上变量
<br /> a<br />
在首次声明并赋值时，栈区开辟内存存储
<br /> 'hello'<br />
字符串，
<br /> a<br />
再次赋值时，栈区重新开辟内存存储数据
<br /> 'world'<br />
字符串，同时将变量
<br /> a<br />
的指针指向数据
<br /> 'world'<br />
，销毁数据
<br /> 'hello'<br />
。

其他数据类型，类似；如列表、字典：

a = [1,2,3,4]
# 变量a的指针不改变
a[0] = 5
# 变量a的指针改变
a = [2,3,4,5]

变量
<br /> a<br />
更改列表子数据时，列表本身的指针和位置不会改变，但将
<br /> a<br />
本身重新赋值时，则同上：原列表数据销毁、指针指向新列表数据。

Python中支持删除变量对对象的引用，使用
<br /> del<br />
语句，如下：

a = 10
b = 20
c = 30
d = [1,2,3,4]
del a
del b, c
del d[0]

对象比较

• <br /> ==<br />
  操作符用于测试两个被引用的对象的值是否相等

• <br /> is<br />
  用于比较两个被引用的对象是否是同一个对象

类型比较

• <br /> type(obj)<br />
  判断数据类型

• <br /> isinstance(object, classinfo)<br />
  判断实例是否属于某类

缓存和内存回收机制

缓存机制

Python 缓存某些不可变对象以供重用，而不是每次都创建新对象。在 Python 中，变量都是对对象的引用。当多个变量引用同一个对象时，称为共享引用。

如下代码：

# 由于变量仅是对对象数据的一个引用，因此改变 a 并不会导致 b 的变化
a = 1
b = a
a = 0
print(a) # 0
print(b) # 1

# 对
a = [1, 2, 3]
b = a
a[0] = 0
print(a) # [0, 2, 3]
print(b) # [0, 2, 3]

内存回收机制

每一个对象有两个标准的头部信息：

• 类型标识符：标识对象数据类型

• 引用计数器：用于决定对象是否需要回收

计数器记录了当前指向该对象引用的数目，一旦对象的计数器为
<br /> 0<br />
，即不存在对该对象的引用，则这个对象的内存空间会被回收，和Javascript中基本一致， 可以通过sys模块中的
<br /> getrefcount()<br />
函数查询一个对象计数器的值。

import sys
sys.getrefcount(1)
# 实测python的编译过程和打印乃至getrefcount这个函数本身都会对目标对象造成多余的引用计数

数据类型

数字 Numbers

三种类型：

• <br /> int<br />
  ：整型 int(num)

• <br /> float<br />
  ：浮点型 float(num)

• <br /> complex<br />
  ：复数型 complex(a, b)

运算相关：

• 数学常量...

• 数学函数...

• 随机数函数...

• 三角函数...

字符串 String

方法：str()包含一堆内建函数

三种符号表示方式（三引号保持原有格式）：

• '
  <br /> str<br />
  '

• "
  <br /> str<br />
  "

• '''
  <br /> str<br />
  '''

• """
  <br /> str<br />
  """

两种操作/读取方式：

• 下标：str[0]

• 中括号：str[:]

示例：

var1 = 'Hello World!'
print ("已更新字符串 : ", var1[:6] + 'Surmon!')
# 已更新字符串 :  Hello Surmon!

列表 List

简单说：类似数组，可嵌套，可作为堆栈使用

基本格式：
<br /> ['str', 1, ['hello']]<br />
，拥有各种类似数组操作的方法，访问方式可使用下标、中括号
<br /> [index:index]<br />
。

元组 Tuple

简单说：类似列表，但只读。

基本格式：
<br /> ('', '')<br />
，和列表类似，拥有只读特性，可拼接，拥有基本操作方法。

集合 Sets

简单说：是一个无序不重复元素的序列

基本格式：
<br /> { }<br />
字面量 或
<br /> set()<br />
方法，创建一个空集合必须用
<br /> set()<br />
而不是
<br /> { }<br />
字面量，因为
<br /> { }<br />
字面量是用来创建一个空字典。

复杂性：类似于数学中的集合，可以进行成员检验（交集、差集、并集、补集），也可以用来去除重复项。

BTW：类似于Jvascript中的Set数据结构。

字典 Dictionary

简单说：就是对象

与Javascript并无太大异样，多了一些方法，和一些方法名称的不同，仅可通过
<br /> obj[key]<br />
访问成员。

迭代器和生成器

它是 Javascript 中的生成器和产量。一句话就是：交出函数（操作）的执行权，即暂停执行。

两个参考链接：

#

#

函数

普通功能基本没有区别。不同的是：可以在函数参数上加一个*，将函数的所有可变参数组合成一个元组。如果参数为空，则返回一个空元组。

类

和Jvascript比的话，就是ES5中的构造函数，ES6中的class。

它用于描述具有相同属性和方法的对象的集合。它定义了集合中每个对象共有的属性和方法。

对象是类的实例。就是面向对象啦，上下文不再是
<br /> this<br />
，而是类函数中的首参（一般定义为
<br /> self<br />
）。

类的专有方法：

• <br /> __init__<br />
  : 构造函数，在生成对象时调用（对应ES6中的constructor）

• <br /> __del__<br />
  : 析构函数，释放对象时使用

• <br /> __repr__<br />
  : 打印，转换

• <br /> __setitem__<br />
  : 按照索引赋值

• <br /> __getitem__<br />
  : 按照索引获取值

• <br /> __len__<br />
  : 获得长度

• <br /> __cmp__<br />
  : 比较运算

• <br /> __call__<br />
  : 函数调用

• <br /> __add__<br />
  : 加运算

• <br /> __sub__<br />
  : 减运算

• <br /> __mul__<br />
  : 乘运算

• <br /> __div__<br />
  : 除运算

• <br /> __mod__<br />
  : 求余运算

• <br /> __pow__<br />
  : 称方

包和模块

在 Python 中，包是一个内聚单元。当然，这只是抽象的。它可能是一个文件夹或其他任何东西。其意义在于更好地管理模块的命名空间。

假设现在有个模块的名称是A.B， 那么他表示一个包A中的子模块B。 就好像使用模块的时候，你不用担心不同模块之间的全局变量相互影响一样，采用
<br /> package.moduleName<br />
这种形式也不用担心不同库之间的模块重名的情况。

在 Python 中，文件被用作模块，模块可以区分不同的类、方法、对象或任何其他数据，这与 Node.js 中的模块类似。

核心语句：

• <br /> import ...<br />

• <br /> from ... import ...<br />

核心对象和模块

• <br /> File<br />
  ：对文件的操作

• <br /> OS<br />
  ：处理文件和目录

• <br /> json<br />
  ：对
  <br /> json<br />
  数据的处理

• 时间：
  <br /> time<br />
  、
  <br /> calendar<br />

多线程

多线程类似于同时执行多个不同的程序，运行多个线程有很多优点。

线程分为：

• 内核线程：由操作系统内核创建和撤销

• 用户线程：在不需要内核支持的用户程序中实现的线程

Python3中线程相关的两个模块：

• <br /> _thread<br />
  （原thread，已废弃）

• <br /> threading<br />

一般可以使用函数或者用类来包装线程对象。

本文转自：https://surmon.me/article/39