Python基础

Snake8859 2/17/2021

# Python介绍

Python是由Guido van Rossum在1989年圣诞节期间，打发无聊时间时编写的一个编程语言。目前就人工智能领域来说，Python是首选的语言，有许多优秀的人工智能框架都是基于Python语言实现的，所以这几年Python感觉特别火。其次Python本身就是一个很简洁的高级语言，能大大加速开发的效率，简单来说就是通俗易懂，应该让应用开发者投入更多精力于功能开发，版本迭代，而不是专注于底层，这样来说的话，Pyhon也是适合互联网开发和一些日常小工具开发。

Guido

关于Python的执行流程，可以在这里 (opens new window)先看看。

大体上，一类编译型语言和一类解释型语言。他们根据程序不同执行过程而定。编译型语言，最典型是C语言，它们主要要经历编译，源代码转为计算机可识别的机器语言，然后再放在计算上运行。解释型语言，JavaScript 应该是这一种，它们没有这个编译过程，主要通过解释器对程序逐行解释，然后直接运行。

后来随着虚拟机概念出现，以Java为首这类语言，连通编译和解释，实现跨平台，比如Java就是首先通过编译器将源代码编译成字节码，然后运行时解释器负责将字节码文件解释为机器语言，同类还有C#。

那么Python算哪一种呢，我觉得初步来看像解释型语言，但是如果有深入了解的话，就和Java，C#这类语言划分到一块，属于先编译后解释的语言。至于这点到底是不是，待以后深入了解后，再来思考。

# Pyhon环境搭建

我理解的python的环境搭建，主要分两种，第一是Python官网 (opens new window)的安装包搭建Python环境，第二是使用Anaconda (opens new window)或者Miniconda (opens new window)搭建Python环境。接下对这两种方式进行说明。

# Python官方

首先看一下Python官方提供的安装包文件，分别是什么

macOS 64-bit/32-bit installer：Mac OS的64和32位安装包

macOS 64-bit installer：Mac OS的64位安装包

Windows help file：Python的帮助文档

x86-64：64位Windows操作系统

x86：32位Windows操作系统

web-based installer：是需要通过联网完成安装的

executable installer ：是可执行文件(*.exe)方式安装

embeddable zip file ：嵌入式版本，可以集成到其它应用中。

具体安装参考传送门 (opens new window)

# Anaconda or Miniconda

那么为什么已经有了Python官网的安装包环境搭建，还有介绍这个东西呢。主要是为了解决两个问题，第一环境管理，如果有多个Python并存，切换使用等问题；第二包管理问题，一些第三方包安装失败等问题。Anaconda或者Miniconda就是为了方便Python开发者更好管理开发环境。

具体安装参考传送门 (opens new window)

【可以类比成Java里Maven的存在类似的，方便与依赖环境管理】

# Python交互式

python在安装完成后，在cmd中输入Python即可进入iPython的交互式界面，进入交互式即命令行成为>>>，在这个里面可以输入Python的命令，输入exit()即可退出。交互式界面主要功能，我觉得可以当做一些简单的测试或者查询相应库的函数说明等。

除了iPython之外，还有一个基于网页的用于交互计算的Jupyter Notebook (opens new window)。以网页的形式打开，然后再网页中直接编写代码和运行代码，代码的运行结果会显示在下方。这个未来可以了解使用一下，还是挺有作用的。

jupyter

# Python集成开发环境（IDE)

实际开发过程中，主要还是使用集成开发环境，目前个人常用的集成开发环境主要有两种，第一是Visual Studio Code (opens new window)，第二是PyCharm (opens new window)。第一个适合初学者使用，第二个适合实际应用开发生产过程中使用。集成开发环境有很多种，没有最好和最坏之分，只有适合和不适合之分，每个人都是根据自己的开发习惯，尽量让自己保持舒适的开发状态即可。

# Python基础语法

# 基本结构

Python的一大结构特点，就是缩进方式。比如以下

a = 100
for i in range(10):
    print(i)
print(a)

1
2
3
4

一般来说以Tab键的距离(4个)为缩进单位。而且一般的集成开发环境，会自动给你缩进的，平时多注意点就行。

然后一行语句结束可以不需要 ； 分号，建议书写的时候统一，要么都写，要么都不写。

# 注释

Python的单行注释以# 单行注释为主

Python的多行注释以''' 多行注释 '''为主

# 数据类型

Python的主要数据类型有以下几种

Numbers（数字）

Numbers数字类型主要存储数值，按照数值的类型，可分为int整型，long长整型，float浮点型，complex复数。
- int为带符号整型，Python会根据你定义的数值范围自动处理。我们知道在C/C++中int占4个字节，Java中也是4个字节，但在Python中，我们利用sys库中sys.getsizeof，可以获取对应数字所占用的大小。
```
print(sys.getsizeof(0)) # 24字节
print(sys.getsizeof(1)) # 28字节
print(sys.getsizeof(2)) # 28字节
print(sys.getsizeof(2**15)) # 28字节
print(sys.getsizeof(2**30)) # 32字节
print(sys.getsizeof(2**128)) # 44字节
```
  1
  2
  3
  4
  5
  6
  从中我们可以看到，Python会自动根据你的数字大小分配对应的内存空间。至于为什么整型要比C/C++和Java大了许多字节，这里涉及到Python的底层实现，大体上简单理解应该是其结构体有关吧，这么多字节，存储数值的可能只是其中一部分，具体理解的话，可以参考传送门 (opens new window)。
- long为长整型，也可以代表八进制和十六进制，在Python2中有Long类型，但是在Python3中，只有一种整数类型int。
- float为浮点型。个人理解在Python中处理应该也是与int类型的。Java中float是4个字节，double的话，就是8字节。同样也可以利用sys.getsizeof获取对应数字所占用的大小。
- complex复数型，平时用的少，就不多了解了，有接触后再补充。
布尔类型

主要是两个值，True代表真，False代表假，一般在用于条件判断。
String（字符串）

Python中用单引号 ‘ 或者双引号"括起来的内容（数字，字母，下划线等）为字符串。同时也有反斜杠 \转义特殊字符。字符串也是一个重要的内容，有许多字符串的操作，之后再开辟一个专门记录字符串操作的版块。
```
 str1 = 'abc123_-|中南长沙'
 str2 = "abc123_-|中南长沙"
```
1
2
List（列表）

列表是写在方括号[]之间，用逗号分隔开的元素列表。列表内的元素可以是各种数据类型，比如整型int，浮点型float，字符串String等。可以把它理解成Java的集合List类型。列表也是一个重要的内容，具体详见版块。
```
list1 = [1,1.1,'abc123_-|中南长沙']
```
1
Dictionary（字典）

字典是一种映射关系，字典用{}来表示，它是一个无序的键(key):值(value)的集合。键(key)必须使用不可变类型（数字，字符串，元组）。在同一个字典中，键(key)必须是唯一的。类似于Java的Map类型。字典也是一个重要内容，具体详见版块。
```
dict = {}
dict = {'name': 'snake8859','age':22, 'site': 'www.snake8859.top'}
```
1
2
Set（集合）

集合是写在大括号{}或者set()函数创建，创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。集合用于保存不重复元素的，所以其最常用的地方是去掉重复元素，因为集合中的每个元素都是唯一的。也可以把它理解成Java的集合Set类型。具体详见版块。
```
student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
```
1
Tuple（元组）

元组也列表类似，不同之处在于元组的元素不能修改，元组使用小括号()。具体详见版块。
```
tuple1 = (1, 1.1, 'abc123_-|中南长沙')
```
1

列表、元组、字典和集合的区别

数据结构	是否可变	是否重复	是否有序	定义符号
列表(list)	可变	可重复	有序	[]
元组(tuple)	不可变	可重复	有序	()
字典(dictionary)	可变	可重复	无序	{key:value}
集合(set)	可变	不可重复	无序	{}

最后也可以看看菜鸟上的关于Python的数据类型介绍传送门 (opens new window)

# 变量，运算符，标识符和关键字

变量就是容器，容器内存储各种数据类型。注意：在Python中变量是无需声明数据类型，Python和根据你变量的值来确定其数据类型，你也可以用type()函数来判断，这点与Java，C#和C还是不一样，这些在定义变量前需要先声明其数据类型，但是和JavaScript类似。

num1 = 100 #num1就是一个变量
num2 = 87  #num2也是一个变量
result = num1 + num2 #把num1和num2累加，然后放到result变量中

1
2
3

运算符就是按数学里的运算符和计算机常用的运算符理解。

Python常用运算符如下

算术运算符：以下假设变量a为10，变量b为21

运算符	描述	实例
+	加 - 两个对象相加	a + b 输出结果 31
-	减 - 得到负数或是一个数减去另一个数	a - b 输出结果 -11
*	乘 - 两个数相乘或是返回一个被重复若干次的字符串	a * b 输出结果 210
/	除 - x 除以 y	b / a 输出结果 2.1
%	取模 - 返回除法的余数	b % a 输出结果 1
**	幂 - 返回x的y次幂	a**b 为10的21次方
//	取整除 - 向下取接近除数的整数	9//2 4 >>> -9//2 -5

比较运算符：以下假设变量a为10，变量b为20

运算符	描述	实例
==	等于 - 比较对象是否相等	(a == b) 返回 False。
!=	不等于 - 比较两个对象是否不相等	(a != b) 返回 True。
>	大于 - 返回x是否大于y	(a > b) 返回 False。
<	小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。	(a < b) 返回 True。
>=	大于等于 - 返回x是否大于等于y。	(a >= b) 返回 False。
<=	小于等于 - 返回x是否小于等于y。	(a <= b) 返回 True。

赋值运算符：以下假设变量a为10，变量b为20

运算符	描述	实例
=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c = a 等效于 c = c a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c = a 等效于 c = c a
//=	取整除赋值运算符	c //= a 等效于 c = c // a
:=	海象运算符，可在表达式内部为变量赋值。Python3.8 版本新增运算符。	在这个示例中，赋值表达式可以避免调用 len() 两次: `if (n := len(a)) > 10: print(f"List is too long ({n} elements, expected <= 10)")`

逻辑运算符：以下假设变量 a 为 10, b为 20

运算符	逻辑表达式	描述	实例
and	x and y	布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。	(a and b) 返回 20。
or	x or y	布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。	(a or b) 返回 10。
not	not x	布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	not(a and b) 返回 False

成员运算符：

运算符	描述	实例
in	如果在指定的序列中找到值返回 True，否则返回 False。	x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in	如果在指定的序列中没有找到值返回 True，否则返回 False。	x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

身份运算符：身份运算符用于比较两个对象的存储单元

运算符	描述	实例
is	is 是判断两个标识符是不是引用自一个对象	x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not	is not 是判断两个标识符是不是引用自不同对象	x is not y ，类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

位运算符：按位运算符是把数字看作二进制来进行计算的，以下假设变量a为60，变量b为13。二进制解释为

a = 0011 1100

b = 0000 1101

运算符	描述	实例
&	按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0	(a & b) 输出结果 12 ，二进制解释： 0000 1100
\|	按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。	(a \| b) 输出结果 61 ，二进制解释： 0011 1101
^	按位异或运算符：当两对应的二进位相异时，结果为1	(a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~	按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1	(~a ) 输出结果 -61 ，二进制解释： 1100 0011，在一个有符号二进制数的补码形式。
<<	左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。	a << 2 输出结果 240 ，二进制解释： 1111 0000
>>	右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数	a >> 2 输出结果 15 ，二进制解释： 0000 1111

具体也可以参考传送门 (opens new window)

# 输出输入

输出：Python的主要两种输出方式。第一种控制台输出，利用print()函数。第二种持久化输出，利用文件流，日志等多种形式表现。

输入：Python的主要两种输入方式。第一种控制台输入，利用input()函数。第二种持久化文件输入，利用文件流，序列化等多种形式表现。

# 函数

# 函数定义

函数定义语法：

def 函数名（参数列表）:
    函数体

1
2

函数定义规则：

def开头，后接函数名，圆括号()和参数列表，：结束
函数体是函数核心，函数功能实现细节
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None
函数第一行一般写入注释，用于对函数进行说明

实例：

def hello(parameter) :
   print("Hello World!")

1
2

# 函数调用

在了解函数名，函数参数和函数返回值以及函数的作用后，即可调用函数。

可调用自定义函数，Python本身内置函数以及第三方开源函数。

实例：

# 定义函数
def printme( str ):
   # 打印任何传入的字符串
   print (str)
   return
 
# 调用函数
printme("我要调用用户自定义函数!")
printme("再次调用同一函数")

1
2
3
4
5
6
7
8
9

>>> abs(100)
100
>>> abs(-20)
20
>>> abs(12.34)
12.34

1
2
3
4
5
6

# 函数参数和返回值

函数参数大体上可分为必需参数（位置参数），关键字参数，默认参数和可变参数。

必需参数（位置参数）

必需参数（位置参数）即必须以正确的参数顺序传递参数，声明和调用参数数量和顺序一致。

# 定义函数
def printme( str ):
   # 打印任何传入的字符串
   print (str)
   return
 
# 调用函数
printme("我要调用用户自定义函数!")

1
2
3
4
5
6
7
8

关键字参数

使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

# 定义函数
def printinfo( name, age ):
  # 打印任何传入的字符串
   print ("名字: ", name)
   print ("年龄: ", age)
   return

#调用printinfo函数
printinfo( age=50, name="snake8859" )

1
2
3
4
5
6
7
8
9

默认参数

调用函数时，如果没有传递参数，则会使用默认参数。

# 定义函数
def printinfo( name, age = 35 ):
  # 打印任何传入的字符串
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="snake8859" )
print ("------------------------")
printinfo( name="snake8859" )

1
2
3
4
5
6
7
8
9
10
11

可变参数

顾名思义，可变参数就是传入的参数个数是可变的。可变参数就是在参数前面加一个*号，参数会以元组的形式传入。

# 定义函数
def printinfo( arg1, *vartuple ):
  # 打印任何传入的字符串
   print ("输出: ")
   print (arg1)
   print (vartuple)
 
# 调用printinfo 函数
printinfo( 70, 60, 50 )

1
2
3
4
5
6
7
8
9

还有一种是加两个星号**在参数前面，参数会以字典的形式传入。

# 可写函数说明
def printinfo( arg1, **vardict ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vardict)
 
# 调用printinfo 函数
printinfo(1, a=2,b=3)

1
2
3
4
5
6
7
8
9

参数传递

可更改(mutable)与不可更改(immutable)对象

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python 函数的参数传递：

不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

举个生活中例子打比方，你手上有三个蛋糕，想要通过一扇门把蛋糕给门里的朋友，现在你通过两种方式把蛋糕传递给朋友，第一种方式你出去买了三个蛋糕，然后把买的三个蛋糕传递给朋友，你朋友吃完买完的三个蛋糕，你发现你手上的三个蛋糕并没有任何变化。第二种方式你把手上三个蛋糕给门里的朋友，朋友吃完后，你发现你手上三个蛋糕已经发生了变化。第一种方式，就是值传递，第二种方式就是引用传递。

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

python传递不可变对象实例：

def ChangeInt( a ):
    a = 10
b = 2
ChangeInt(b)
print( b ) # 结果是 2

1
2
3
4
5

python传递可变对象实例：

# 可写函数说明
def changeme( mylist ):
   "修改传入的列表"
   mylist.append([1,2,3,4])
   print ("函数内取值: ", mylist)
   return
 
# 调用changeme函数
mylist = [10,20,30]
changeme( mylist )
print ("函数外取值: ", mylist)

1
2
3
4
5
6
7
8
9
10
11

返回值

一个函数执行完后，会返回相应结果。利用return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。

实例：

# 可写函数说明
def sum( arg1, arg2 ):
   # 返回2个参数的和
   total = arg1 + arg2
   print ("函数内 : ", total)
   return total

# 调用sum函数
total = sum( 10, 20 )
print ("函数外 : ", total)

1
2
3
4
5
6
7
8
9
10

# 函数高级应用

查看函数帮助

可以在交互式中通过**help(函数名)**查看函数的帮助信息。这个对要了解陌生函数的时候，是非常有用的。
空函数

如果定义一个函数，但却什么都不想做，可以用pass语句
```
def fun():
    pass
```
1
2
pass语句什么都不做，那有什么用？实际上pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个pass，让代码能运行起来。

匿名函数

顾名思义，匿名函数就是没有函数名的函数，也就不能再用常规的def去定义这个函数。在python中使用lambda来创建匿名函数。

匿名函数定义语法：

lambda [arg1 [,arg2,.....argn]]:expression

实例：

# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2
 
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))

1
2
3
4
5
6

嵌套定义函数

这点不同于Java，C#不允许函数嵌套定义，在python中运行在函数内定义函数。

实例：
```
def get_length(text):
    def clean(t):           # 2
        return t[1:]
    new_text = clean(text)  # 1
    return len(new_text)

get_length("python")
```
1
2
3
4
5
6
7
这个函数的目的是去除字符串的第一个字符后再计算它的长度，尽管函数本身的意义不大，但能足够说明嵌套定义函数。get_length 调用时，先执行1处代码，发现有调用 clean 函数，于是接着执行2中的代码，把返回值赋值给了 new_text ，再继续执行后续代码。

注意：函数中里面嵌套的函数不能在函数外面访问，只能是在函数内部使用，超出了外部函数的做用域就无效了。
递归函数

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

实例：
```
def fact(n):
    if n==1:
        return 1
    return n * fact(n - 1)
```
1
2
3
4
递归函数的优点是逻辑简单清晰，缺点是过深的调用会导致栈溢出。

具体可参考传送门1 (opens new window)，传送门2 (opens new window)

# 模块

简单的理解就是在Python中一个.py文件就是一个模块。模块的好处主要是提高的代码的利用率，方便代码的维护。在平日的使用中，我们常常引入其他模块来辅助。

# 使用模块

在Python中使用本身内置模块或者导入已经安装好第三方模块后，可以使用以下三种方式使用模块。

import语句

当要全局导入时，使用import语句，Python就会根据搜索路径去找对应的模块。一个模块只会被导入一次，不管你执行了多少次import。这样可以防止导入模块被一遍又一遍地执行。

语法：
```
import module1[, module2[,... moduleN]
```
1
实例：
```
import sys
 
print('命令行参数如下:')
for i in sys.argv:
   print(i)
 
print('\n\nPython 路径为：', sys.path, '\n')
```
1
2
3
4
5
6
7

from...import语句

当仅要局部导入模块时，使用from...import语句用于导入模块中部分内容。

语法：

from modname import name1[, name2[, ... nameN]]

实例：

from sys import argv
from sys import path

print('命令行参数如下:')

for i in argv:
   print(i)
 
print('\n\nPython 路径为：', path, '\n')

1
2
3
4
5
6
7
8
9

from...import * 语句

把一个模块中所用内容导入，与import类似，但是导入后不需要带上模块名，直接写模块中函数即可。

语法：
```
from modname import *
```
1
实例：
```
from sys import *

print('命令行参数如下:')

for i in argv:
   print(i)
 
print('\n\nPython 路径为：', path, '\n')
```
1
2
3
4
5
6
7
8

# 制作模块

除了使用第三方的模块之外，我们也可以制作自己的模块并使用。

比如，我们写了一个test.py文件，在test.py文件中定义了函数add()

def add(a,b):
    return a+b

1
2

那么，如何在其他模块中调用该模块呢，首先在注意其文件位置，最简单的方式就是把两者放在一个文件夹下。这样在import test 或者 from test import add 来使用该模块中的函数

import test

result = test.add(11,22)

print(result)

1
2
3
4
5

# name属性

我们偶尔在某个模块中，进行测试，比如test.py中加入测试部分。

def add(a,b):
    return a+b
# 用来进行测试
ret = add(12,22)
print('int test.py file,,,,12+22=%d'%ret)

1
2
3
4
5

但是在其他py文件中引入该test.py的话，就会发现，这个测试部分的代码，在引入的时候也执行了，这个效果并不是我们所期望的。于是为了避免这种现象，python文件有许多内置变量存在，其中之一是__name__属性，至于其他的属性，我们将在面向对象的部分时再仔细记录。

每一个模块都有一个__name__属性，当这个值是'__main__'时，表明该模块自身在运行，而不是引入的，即可用于区分当前主模块和引入模块。比如我们修改test.py文件，使用__name__属性

def add(a,b):
    return a+b
if __name__ == '__main__':
    # 用来进行测试
    ret = add(12,22)
    print('int test.py file,,,,12+22=%d'%ret)

1
2
3
4
5
6

在其他py文件中再引入该test.py文件的话，就不会再出现该测试的内容，因为此时__name__不会为'__main__'值。因为test.py作为被调用模块，这个值是模块名。

只有当为主模块时，这个__name__属性才会是'__main__'值。

要是对比理解的话，可以把其当做在Java，C#，C/C++中的main函数，作为代码的入口而存在。

# Python的流程控制

# 顺序结构

顺序结构是程序由上至下执行，一般所编写的就是常规的顺序结构。

顺序结构

# 选择结构

选择结构是由条件判断是否成立，来决定程序执行哪个分支。常见的选择结构有单分支，双分支，多分支。

选择结构

单分支 if

语法：
```
if 表达式:
    语句块
```
1
2
使用if语句时，表达式可以是一个单纯的布尔值或变量，也可以是比较表达式或逻辑表达式（例如：a>b and a ! = c），如果表达式为真，则执行“语句块”；如果表达式的值为假，就跳过“语句块”，继续执行后面的语句。

实例：
```
a = -9
if a > 0:
    print('a为正数')
```
1
2
3
双分支 if...else

语法：
```
if 表达式:
    语句块1
else:
    语句块2
```
1
2
3
4
使用 if...else 语句时，表达式可以是一个单纯的布尔值或变量，也可以是比较表达式或逻辑表达式（例如：a>b and a ! = c），如果满足条件，则执行 if 后面的语句块，否则，执行 else 后面的语句块。

实例：
```
a = -9
if a > 0:
    print('a为正数')
else:
    print('a为负数')
```
1
2
3
4
5
多分支 if...elif..else

语法：
```
if 表达式1:
    语句块1
elif 表达式2:
    语句块2
elif 表达式3:
    语句块3
...
else:
    语句块n
```
1
2
3
4
5
6
7
8
9
使用if..elif..else语句时，表达式可以是一个单纯的布尔值或变量，也可以是比较表达式或逻辑表达式（例如：a>b and a ! = c），如果满足某种条件，就会进行某种处理，否则，满足另一条件，则执行另一条件处理。

实例：
```
a = -9
if a > 0:
    print('a为正数')
elif a < 0:
    print('a为负数')
else:
    print('a为0')
```
1
2
3
4
5
6
7

if语句嵌套

单分支，双分支和多分支，这三种形式的选择语句之间都可以相互嵌套。

比如在单分支中嵌套双分支

if 表达式1:
    if 表达式2:
        语句块1
    else:
        语句块2

1
2
3
4
5

比如在双分支中嵌套双分支

if 表达式1:
    if 表达式2:
        语句块1
    else:
        语句块2
else:
    if 表达式3:
        语句块3
    else:
        语句块4

1
2
3
4
5
6
7
8
9
10

# 循环结构

循环结构是程序中需要反复执行某个功能，由循环条件来决定继续执行某个功能或者退出循环。循环主要分为两种for循环和while循环。

循环结构

while循环

while循环是通过一个条件来控制是否要继续反复执行循环中的语句。

语法：
```
while 条件表达式:
    循环体
```
1
2
当条件表达式的返回值为真时，则执行循环体中的语句，执行完毕后，重新判断条件表达式的返回值，直到表达式返回的结果为假时，退出循环。

实例：
```
a = -9
while a<0:
    print(a)
    a=a+1
```
1
2
3
4
for循环

for循环是一个依次重复执行的循环。通常适用于枚举或遍历序列，以及迭代对象中的元素。

语法：
```
for 迭代变量 in 对象、
    循环体
```
1
2
其中，迭代变量用于保存读取出的值；对象为要遍历或迭代的对象，该对象可以是任何有序的序列对象，如字符串、列表和元组等。

实例：
```
# 遍历list列表
for i in list(range(10)):
    print(i)

#遍历字符串
strs = 'abc123_-|中南长沙'
for ch in strs:
    print(ch)
```
1
2
3
4
5
6
7
8

循环嵌套

类似于条件嵌套，循环嵌套就是在一个循环体中嵌套另一个循环体。for循环和while循环都可以进行循环嵌套。

比如while嵌套while

while 条件表达式1:
    while 条件表达式2:
        循环体2
    循环体1

1
2
3
4

比如for嵌套for

for 迭代变量1 in 对象1:
    for 迭代变量2 in 对象2:
        循环体2
    循环体1

1
2
3
4

比如while嵌套for

while 条件表达式:
    for 迭代变量 in 对象:
        循环体2
    循环体1

1
2
3
4

比如for嵌套while

for 迭代变量 in 对象
    while 条件表达式:
        循环体2
    循环体1

1
2
3
4

其中比较常用的是for嵌套for

# 跳转和空语句

跳转语句是常用在循环结构中，当需要中断循环或者跳过某一次循环时使用，跳转语句分为两种，continue和break

continue语句

continue语句用于终止本次循环。

语法：
```
while 条件表达式1:
    执行代码
    if 条件表达式2:
        continue
        
for 迭代变量 in 对象:
    if 条件表达式:
        continue
```
1
2
3
4
5
6
7
8
说明：continue 语句一般会与 if 语句搭配使用，表示在某种条件下，跳过当前循环的剩余语句，然后继续进行下一轮循环。如果使用嵌套循环，continue 语句将只跳过最内层循环中的剩余语句。
break语句

break语句用于终止当前的循环。

语法：
```
while 条件表达式1:
    执行代码
    if 条件表达式2:
        break
        
for 迭代变量 in 对象:
    if 条件表达式:
        break
```
1
2
3
4
5
6
7
8
说明：break 语句一般会结合 if 语句进行搭配使用，表示在某种条件下，跳出循环。如果使用嵌套循环，break 语句将跳出最内层的循环。

pass语句

空语句表示不作任何事，一般起到占位作用，用pass表示

实例：

for i in range(1,10):
    if i%2 == 0:                # 判断是否为偶数
        print(i,end = '')
    else:                       # 不是偶数
        pass                    # 占位数，不做任何事情

1
2
3
4
5

具体可参考传送门 (opens new window)

# Python综合应用

这个部分为综合应用，大体上暂时把平时比较常用的知识点，经验教训等琐碎的内容整理归纳。

# 字符串（String）常用操作

字符串格式化

基本用法是将一个对应值插入到一个有字符串格式符%的字符串中，也就是占位符的概念。

Python字符串格式化符号

符号	描述
%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%u	格式化无符号整型
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同%e，用科学计数法格式化浮点数
%g	%f和%e的简写
%G	%f 和 %E 的简写
%p	用十六进制数格式化变量的

实例：

print ("我叫 %s 今年 %d 岁!" % ('小明', 10))

str.format()

在Python2.6之后，新增了一种格式化字符串的函数str.format()。基本语法是通过 {} 和 :来代替以前的 % 。

实例：

>>>"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
'hello world'
 
>>> "{0} {1}".format("hello", "world")  # 设置指定位置
'hello world'
 
>>> "{1} {0} {1}".format("hello", "world")  # 设置指定位置
'world hello world'

1
2
3
4
5
6
7
8

也可以设置参数

print("姓名：{name}, 年龄 {age}".format(name="snake8859", age=22))
 
# 通过字典设置参数
person = {"name": "snake8859", "age":22}
print("姓名：{name}, 年龄 {age}".format(**site))
 
# 通过列表索引设置参数
my_list = ['snake8859', 22]
print("姓名：{0[0]}, 年龄 {0[1]}".format(my_list))  # "0" 是必须的

1
2
3
4
5
6
7
8
9

三引号和f-string

python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。

实例：
```
para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print (para_str)
```
1
2
3
4
5
6
常用语需要一块HTML或者SQL时，跨多行形式便于理解。

f-string 是 python3.6 之后版本添加的，称之为字面量格式化字符串，是新的格式化字符串的语法。

f-string 格式话字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号{}包起来，它会将变量或表达式计算后的值替换进去
```
>>> name = 'snake8859'
>>> f'Hello {name}'  # 替换变量

>>> f'{1+2}'         # 使用表达式
'3'

>>> w = {'name': 'snake8859', 'age': 22}
>>> f'{w["name"]}: {w["url"]}'
'snake8859: 22'
```
1
2
3
4
5
6
7
8
9
用了这种方式明显更简单了，不用再去判断使用 %s，还是 %d。

字符串灵活访问（下标和切片）
1. 下标
  
  下标即是索引，字符串实际上是字符的数组，支持下标索引。
  
  比如有字符串name = 'abcdef'，实际在内存中存储如下：
  
  想取出部分字符串，可以通过下标（注意从0开始）。
```
name = 'abcdef'

print(name[5],name[-1])
print(name[3],name[-3])
print(name[0],name[-6])
```
  1
  2
  3
  4
  5
2. 切片
  
  切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。
  
  # 切片的语法：[起始:结束:步长]
  
  注意：选取的区间属于左闭右开型，即从"起始"位开始，到"结束"位的前一位结束（不包含结束位本身)。
```
name = 'abcdef'

print(name[0:3]) # abc 下标0~2的字符
print(name[2:]) # cdef 下标为2开始到最后的字符
print(name[1:-1]) # bcde 下标为1开始到最后第2个之间的字符
print(name[1:5:2]) #bd 下标1~4的字符，步长为2
print(name[::2]) #ace 下标0~5的字符，步长为2
print(name[::-2]) #fdb 下标0~5的字符，步长为-2.倒着取
```
  1
  2
  3
  4
  5
  6
  7
  8
  切片是可以非常灵活的，需要多加练习和实际。
字符串常用函数
1. 字符串长度统计
  - len()
    
    len() 函数计算字符串的长度、
    
    语法：
```
len(string)
```
    1
    实例：
```
str1 = '人生苦短，我用Python！'  # 定义字符串
length = len(str1)  # 计算字符串的长度
print(length) # 14
```
    1
    2
    3
    在默认情况下，通过len()函数计算字符串的长度，不区分英文，数字和汉字，所有字符都按一个字符计算。
    
    在实际开发时，有时需要获取字符串实际所占的字节数，即如果采用UTF-8 编码，汉字占3 个字节，采用GBK 或者GB2312 时，汉字占2 个字节。这时，可以通过使用encode() 方法进行编码后再进行获取。
```
str1 = '人生苦短，我用Python！'   # 定义字符串
length = len(str1.encode ())     # 计算UTF-8编码的字符串的长度
print(length) #30

str1 = '人生苦短，我用Python！'     # 定义字符串
length = len(str1.encode ('gbk'))  # 计算gbk编码的字符串的长度
print(length) #22
```
    1
    2
    3
    4
    5
    6
    7
2. 字符串分割和合并
  - split()
    
    split() 方法可以实现字符串分割，也就是把一个字符串按照指定的分隔符切分为字符串列表。该列表的元素中，不包括分隔符。
    
    语法：
```
str.split(sep,maxsplit)
```
    1
    参数说明：
    - str：表示要进行分割的字符串。
    - sep：用于指定分隔符，可以包含多个字符，默认为None，即所有空字符（包括空格、换行“\n”、制表符“\t”等）。
    - maxsplit：可选参数，用于指定分割的次数，如果不指定或者为-1，则分割次数没有限制，否则返回结果列表的元素个数，个数最多为maxsplit+1。
    - 返回值：分隔后的字符串列表。
      
      说明：在split() 方法中，如果不指定sep 参数，那么也不能指定maxsplit 参数。
    实例：
```
str1 = 'www.snake8859.top'
print(str1.split('.'))  # 按 . 分隔符
# ['www', 'snake8859', 'top']
```
    1
    2
    3
  - join()
    
    join()方法可以将多个字符串采用固定的分隔符连接在一起。
    
    语法：
```
strnew = string.join(iterable)
```
    1
    参数说明：
    - strnew：表示合成后生成新的字符串。
    - string：字符串类型，用于指定合并时的分隔符。
    - iterable：可迭代对象，该迭代对象中的所有元素（字符串表示）将被合并为一个新的字符串。string 作为边界点分割出来。
    实例：
```
list_traffic = ['飞机','火车','汽车']
str_traffic = '|'.join(list_traffic) # 按 | 合并
print(str_traffic) 
# 飞机|火车|汽车
```
    1
    2
    3
    4
3. 字符串查找
  - count()
    
    count() 方法用于检索指定字符串在另一个字符串中出现的次数。如果检索的字符串不存在，则返回0，否则返回出现的次数。
    
    语法：
```
str.count(sub[, start[, end]])
```
    1
    参数说明：
    - str：表示原字符串。
    - sub：表示要检索的子字符串。
    - start：可选参数，表示检索范围的起始位置的索引，如果不指定，则从头开始检索。
    - end：可选参数，表示检索范围的结束位置的索引，如果不指定，则一直检索到结尾。
    案例：
```
str1 = '飞机|火车|汽车'
print(str1.count('|')) # 2
```
    1
    2
  - find()
    
    find()用于检索是否包含指定的子字符串。如果检索的字符串不存在，则返回-1，否则返回首次出现该子字符串时的索引。
    
    语法：
```
str.find(sub[, start[, end]])
```
    1
    参数说明：
    - str：表示原字符串。
    - sub：表示要检索的子字符串。
    - start：可选参数，表示检索范围的起始位置的索引，如果不指定，则从头开始检索。
    - end：可选参数，表示检索范围的结束位置的索引，如果不指定，则一直检索到结尾。
    案例：
```
str1 = '飞机|火车|汽车'
print(str1.find('|')) # 2
print(str1.find('@')) # -1
```
    1
    2
    3
    说明：Python的字符串对象还提供了rfind() 方法，其作用于find() 方法类似，只是从字符串右边开始查找。
  - index()
    
    index() 方法同find() 方法类似，也是用于检索是否包含指定的子字符串。只不过如果使用index() 方法，当指定的字符串不存在时会抛出异常。
    
    语法：
```
str.index(sub[, star[, end]])
```
    1
    - str：表示原字符串。
    - sub：表示要检索的子字符串。
    - start：可选参数，表示检索范围的起始位置的索引，如果不指定，则从头开始检索。
    - end：可选参数，表示检索范围的结束位置的索引，如果不指定，则一直检索到结尾。
    案例：
```
str1 = '飞机|火车|汽车'
print(str1.index('|')) # 2
print(str1.index('@')) # 异常
```
    1
    2
    3
  - startswith()和endswith()
    
    starswith() 方法用于检索字符串是否以指定子字符串开头。如果是则返回True，否则返回False。
    
    语法：
```
str.startswith(prefix[, start[, end]])
```
    1
    参数说明：
    - str：表示原字符串。
    - prefix：表示要检索的子字符串。
    - start：可选参数，表示检索范围的起始位置的索引，如果不指定，则从头开始检索。
    - end：可选参数，表示检索范围的结束位置的索引，如果不指定，则一直检索到结尾。
    案例：
```
str1 = '飞机|火车|汽车'
print(str1.startswith('飞')) #True
print(str1.startswith('@'))  #False
```
    1
    2
    3
    endswinth() 方法用于检索字符串是否以指定的子字符串结尾。如果是则返回True，否则返回False。
    
    语法：
```
str.endswith(suffix[, start[, end]])
```
    1
    参数说明：
    - str：表示原字符串。
    - suffix：表示要检索的子字符串。
    - start：可选参数，表示检索范围的起始位置的索引，如果不指定，则从头开始检索。
    - end：可选参数，表示检索范围的结束位置的索引，如果不指定，则一直检索到结尾。
    案例：
```
str1 = '飞机|火车|汽车'
print(str1.endswith('车')) #True
print(str1.startswith('@'))  #False
```
    1
    2
    3
4. 字符串大小写转换
  - lower()
    
    lower() 方法用于将字符串中的大写字母转换为小写字母。
    
    语法：
```
str.lower()
```
    1
    实例：
```
str1 ='https://www.SNAKE8859.TOP'
print('旧字符串',str1)
print('新字符串',str1.lower())      # 全部转换为小写字母输出
```
    1
    2
    3
  - upper()
    
    upper() 方法用于将字符串中的小写字母转换为大写字母。
    
    语法：
```
str.upper()
```
    1
    实例：
```
str1 ='https://www.snake8859.top'
print('旧字符串',str1)
print('新字符串',str1.upper())      # 全部转换为大写字母输出
```
    1
    2
    3
5. 字符串空格和特殊字符处理
  - strip()
    
    strip() 方法用于去掉字符串左、右两侧的空格和特殊字符。
    
    语法：
```
str.strip([chars])
```
    1
    参数说明：
    - str：为要去除空格的字符串。
    - chars：为可选参数，用于指定要去除的字符，可以指定多个。
    案例：
```
str1 = '<飞机|火车|汽车>'
print(str1.strip('<')) # 飞机|火车|汽车>
print(str1.strip('<>')) # 飞机|火车|汽车
```
    1
    2
    3
  - lstrip()和rstrip()
    
    lstrip() 方法用于去掉字符串左侧的空格和特殊字符。
    
    rstrip() 方法用于去掉字符串左侧的空格和特殊字符。
    
    语法和案例与strip()差不多
6. 字符串编码转换
  - encode()
    
    encode() 方法用于将字符串转换为二进制数据（即bytes），也称为“编码”
    
    语法：
```
str.encode([encoding="utf-8"][,errors="strict"])
```
    1
    参数说明：
    - str：表示要进行转换的字符串。
    - encoding="utf-8" ：可选参数，用于指定进行转码时采用的字符编码，默认为UTF-8，如果想使用简体中文，也可以设置为gb2312。当只有这一个参数时，也可以省略前面的“encoding=”，直接写编码。
    - errors=“strict”：可选参数，用于指定错误处理方式，其可选择值可以是strict（遇到非法字符就抛出异常）、ignore（忽略非法字符）、replace（用“？”替换非法字符）或xmlcharrefreplace（使用XML 的字符引用）等，默认值为strict。
    案例：
```
str1 = '人生苦短，我用Python！'
print(str1.encode()) # 以utf-8编码
print(str1.encode('gbk')) #以gbk编码
#b'\xe4\xba\xba\xe7\x94\x9f\xe8\x8b\xa6\xe7\x9f\xad\xef\xbc\x8c\xe6\x88\x91\xe7\x94\xa8Python\xef\xbc\x81'
#b'\xc8\xcb\xc9\xfa\xbf\xe0\xb6\xcc\xa3\xac\xce\xd2\xd3\xc3Python\xa3\xa1'
```
    1
    2
    3
    4
    5
  - decode()
    
    decode() 方法为bytes 对象的方法用于将二进制数据转换为字符串，即将使用encode() 方法转换的结果再转换为字符串，也称为“解码”。
    
    语法：
```
bytes.decode([encoding="utf-8"][,errors="strict"])
```
    1
    参数说明：
    - bytes：表示要进行转换的二进制数据，通常是encode() 方法转换的结果。
    - encoding="utf-8" ：可选参数，用于指定进行解码时采用的字符编码，默认为UTF-8，如果想使用简体中文，也可以设置为gb2312。当只有这一个参数时，也可以省略前面的“encoding=”，直接写编码。
    注意：在设置解码采用的字符编码时，需要与编码时采用的字符编码一致。
    - errors=“strict”：可选参数，用于指定错误处理方式，其可选择值可以是strict（遇到非法字符就抛出异常）、ignore（忽略非法字符）、replace（用“？”替换非法字符）或xmlcharrefreplace（使用XML 的字符引用）等，默认值为strict。
    说明：在使用decode() 方法时，不会修改原字符串，如果需要修改原字符串，需要对其进行重新赋值。
    
    案例：
```
str1 = '人生苦短，我用Python！'
byte_str = str1.encode('gbk') #以gbk编码
print(byte_str.decode('gbk')) #以gbk解码
# 人生苦短，我用Python！
```
    1
    2
    3
    4

具体参考传送门1 (opens new window)，传送门2 (opens new window)

# 列表（List）常用操作

列表的创建，编辑和删除
1. 创建
  - 直接创建
    
    列表的直接创建很简单，主要表现为一对中括号[]，相邻元素使用逗号,分隔。
    
    语法：
```
listname = [element 1,element 2,element 3,...,element n]
```
    1
    实例：
```
list1 = [1,1.1,'abc123_-|中南长沙']
```
    1
    说明：在使用列表时，虽然可以将不同类型数据放入到同一个列表中，但是通常情况下，我们不这样做，而是在一个列表中只放入一种类型的数据。这样可以提高程序的可读性。
  - list()
    
    除了直接创建，python还提供了list()函数，来创建列表。
    
    语法：
```
list(data)
```
    1
    参数说明：
    - data 表示可以转换列表的数据，其类型可以是range 对象、字符串、元组或者其他可迭代类型的数据。
    实例：
```
list(range(1,10))
```
    1
  - 推导式
    
    推导式用于根据某个条件快速生成列表。
    
    语法：
```
list = [Expression for var in range] #生成指定范围的数值列表
newlist = [Expression for var in list] #根据列表生成指定需求的列表
newlist = [Expression for var in list if condition] #从列表中选择符合条件的元素组成新的列表
```
    1
    2
    3
    参数说明：
    - Expression：表达式，用于计算新列表的元素。
    - var：变量，值为后面列表的每个元素值。
    - condition：条件表达式，用于指定筛选条件。
    实例：
```
my_list = [i for i in range(10)]
print(my_list) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

my_list1 = [i+1 for i in my_list]
print(my_list1) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

my_list2 = [i for i in my_list1 if i>4]
print(my_list2) # [5, 6, 7, 8, 9, 10]
```
    1
    2
    3
    4
    5
    6
    7
    8
2. 编辑
  - 编辑-修改
    
    修改列表中元素，只需要找到对应元素的索引，然后重新赋值即可。
    
    实例：
```
my_list = ['Hello','World']
my_list[1] = 'World!!!'
print(my_list) # ['Hello','World!!!']
```
    1
    2
    3
  - 编辑-添加
    
    为列表中添加元素有四种方式。第一+号将两个序列连接，第二append()方法，第三insert()方法，第四extend()方法。
    - +
      
      利用+运算符，将两个列表相加，来添加列表中的元素。
      
      实例：
      my_list = ['Hello','World'] my_list1 = ['snake8859'] print(my_list+my_list1) # ['Hello','World','snake8859']
      
      1
      2
      3
    - append()
      
      虽然+能够添加列表元素，但是这种方法的执行速度比append()方法慢，一般添加列表元素推荐使用append()。列表对象的append() 方法用于在列表的末尾追加元素。
      
      语法：
      listname.append(obj)
      
      1
      参数说明：
      - listname为要添加元素的列表名称
      - obj 为要添加到列表末尾的对象
      实例：
      my_list = ['Hello','World'] my_list.append('snake8859') print(my_list) # ['Hello','World','snake8859']
      
      1
      2
      3
    - insert()
      
      insert()方法也可以向列表中添加元素，该方法主要用于向列表指定位置添加元素。但是执行效率依然没有append()高。
      
      语法：
      listname.insert(index, obj)
      
      1
      参数说明：
      - listname为要添加元素的列表名称
      - index为要添加元素的位置
      - obj 为要添加到列表末尾的对象
      实例：
      my_list = ['Hello','World'] my_list.insert(1,'snake8859') print(my_list) # ['Hello', 'snake8859', 'World']
      
      1
      2
      3
    - extend()
      
      extend()方法用于将一个列表中的全部内容添加到另一个列表中，用于追加。
      
      语法：
      listname.extend(seq)
      
      1
      参数说明：
      - listname为要添加元素的列表名称
      - seq 为要添加的列表
      实例：
      my_list = ['Hello','World'] str1 = '人生苦短，我用Python！' my_list1 = list(str1) my_list.extend(my_list1) print(my_list) # ['Hello', 'World', '人', '生', '苦', '短', '，', '我', '用', 'P', 'y', 't', 'h', 'o', 'n', '！']
      
      1
      2
      3
      4
      5
      6
3. 删除
  
  列表的删除，有两种，第一del，第二remove()方法。
  - del
    
    可以使用del语句，指定要删除的列表或者列表中某个元素。
    
    实例：
```
my_list = ['Hello', 'World', '人', '生', '苦', '短', '，', '我', '用', 'P', 'y', 't', 'h', 'o', 'n', '！']
del my_list[5]
print(my_list)
#['Hello', 'World', '人', '生', '苦', '，', '我', '用', 'P', 'y', 't', 'h', 'o', 'n', '！']
```
    1
    2
    3
    4
  - remove()
    
    可以使用remove()方法，来根据元素值删除列表中第一个匹配项。
    
    语法：
```
listname.remove(obj)
```
    1
    参数说明：
    - listname为列表名称
    - obj为要删除的元素值
    实例：
```
my_list = ['Hello', 'World', '人', '生', '苦', '短', '，', '我', '用', 'P', 'y', 't', 'h', 'o', 'n', '！']
my_list.remove('短')
print(my_list)
#['Hello', 'World', '人', '生', '苦', '，', '我', '用', 'P', 'y', 't', 'h', 'o', 'n', '！']
```
    1
    2
    3
    4
列表的访问

列表可以通过print()直接打印，也可以通过索引，切片方式访问列表某个部分，还可以使用for循环来遍历集合。索引和切片的方式与字符串类似，这里注重记录for循环遍历的方式。
1. 直接for循环遍历
  
  直接使用for循环，遍历列表中每一个元素
  
  语法：
```
for item in listname:
    # 输出item
```
  1
  2
  参数说明：
  - listname为列表名称
  - item 用于保存获取到的元素值
  实例：
```
for item in list(range(10)):
    print(item)
```
  1
  2
2. for循环和enumerate() 方法
  
  使用for 循环和enumerate() 函数可以实现同时输出索引值和元素内容。
  
  语法：
```
for index,item in enumerate(listname):
    # 输出index 和item
```
  1
  2
  参数说明：
  - index：用于保存元素的索引
  - item：用于保存获取到的元素值
  - listname：为列表名称
  实例：
```
for index,value in enumerate(my_list):
    print(index,value)
```
  1
  2
列表的操作
1. 列表检索
  - count()
    
    count()函数用于获取指定元素在列表中出现的次数
    
    语法：
```
listname.count(obj)
```
    1
    参数说明：
    - listname：表示列表的名称。
    - obj：表示要判断是否存在的对象，这里只能进行精确匹配，即不能是元素值的一部分。
    - 返回值：元素在列表中出现的次数
    实例：
```
my_list = ['Hello', 'World', '人', '生', '苦', '短', '，', '我', '用', 'P', 'y', 't', 'h', 'o', 'n', '！']
print(my_list.count('人')) # 1
```
    1
    2
  - index()
    
    index()函数用于获取指定元素在列表中首次出现的位置（索引）
    
    语法：
```
listname.index(obj)
```
    1
    参数说明
    - listname：表示列表的名称。
    - obj：表示要查找的对象，这里只能进行精确匹配。如果指定的对象不存在时，则抛出异常。
    - 返回值：首次出现的索引值。
    实例：
```
my_list = ['Hello', 'World', '人', '生', '苦', '短', '，', '我', '用', 'P', 'y', 't', 'h', 'o', 'n', '！']
print(my_list.index('人')) # 2
```
    1
    2
2. 列表聚合
  - sum()
    
    sum()函数用户统计列表中各数值元素的和
```
sum(iterable[,start])
```
    1
    参数说明：
    - iterable：表示要统计的列表。
    - start：表示统计结果是从哪个数开始（即将统计结果加上start 所指定的数），是可选参数，如果没有指定，默认值为0 。
    实例：
```
sum(list(range(0,101))) # 5050
```
    1
3. 列表排序
  - sort()
    
    sort()方法用于对列表中元素进行排序。排序后原列表中的元素顺序将发生改变。
    
    语法：
```
listname.sort(key = None,reverse = False)
```
    1
    参数说明：
    - listname：表示要进行排序的列表。
    - key：表示指定从每个元素中提取一个用于比较的键（例如，设置“key=str.lower”表示在排序时不区分字母大小写）。
    - reverse：可选参数，如果将其值指定为True，则表示降序排列；如果为False，则表示升序排列，默认为升序排列。
    实例：
```
grade = [95,98,97,99,100,88,95,82,91,97]        # 10名学生的语文成绩列表
print("原列表：",grade)
grade.sort()                                    # 进行升序排列
print("升  序：",grade)
grade.sort(reverse = True)                      # 进行降序排列
print("降  序：",grade)
```
    1
    2
    3
    4
    5
    6
  - sorted()
    
    sorted()为python的内置函数，可以对列表进行排序。。使用该函数进行排序后，原列表的元素顺序不变。
    
    语法：
```
sorted(iterable, key=None, reverse=False)
```
    1
    参数说明：
    - iterable：表示要进行排序的列表名称。
    - key：表示指定从每个元素中提取一个用于比较的键（例如，设置“key=str.lover”表示在排序时不区分字母大小写）。
    - reverse：可选参数，如果将其值指定为True，则表示降序排序；如果为False，则表示升序排列，默认为升序排列。
    实例：
```
grade = [95,98,97,99,100,88,95,82,91,97]        # 10名学生的语文成绩列表
grade_as = sorted(grade)                        # 进行升序排列
print("升  序：",grade_as)
grade_des = sorted(grade,reverse = True)   # 进行降序排列
print("降  序：",grade_des)
print("原列表：",grade)
```
    1
    2
    3
    4
    5
    6
4. 二维列表
  - 二维列表创建和遍历
    
    二维列表中的元素以行和列的方式组织，与矩阵类似。
    1. 创建
      
      二维列表三种创建方式，第一直接创建，第二嵌套for循环创建，第三推导式创建
      - 直接创建
        
        直接创建就是一个列表中的每一个元素又是一个列表，即列表中嵌套列表。
      - 嵌套for循环创建
        
        利用嵌套双层for循环创建列表。
        
        实例：
        
        arr = [] # 创建一个空列表 for i in range(4): arr.append([]) # 在空列表中再添加一个空列表 for j in range(5): arr[i].append(j) # 为内层列表添加元素 print(arr)
        
        1
        2
        3
        4
        5
        6
      - 推导式创建
        
        使用比较简洁的推导式创建二维列表，
        
        实例：
        
        arr = [[j for j in range(5)] for i in range(4)] print(arr)
        
        1
        2
    2. 访问
      
      访问二维列表有两种方式，第一索引访问，第二嵌套for循环访问。
      - 索引
        
        语法：
        
        listname[下标1][下标2]
        
        1
        参数说明：
        
        listname：列表名称。
        
        下标1：表示列表中第几行，下标值从0 开始，即第一行的小标为0 。
        
        下标2：表示列表中第几行，下标值从0 开始，即第一行的下标为0 。
      - 嵌套for循环访问
        
        语法：
        
        for i in range(len(listname)): for j in range(len(listname(i))): print(listname[i][j])
        
        1
        2
        3
        参数说明：
        
        listname：列表名称。
        
        i：表示列表中第几行，下标值从0 开始，即第一行的小标为0 。
        
        j：表示列表中第几行，下标值从0 开始，即第一行的下标为0 。
        
        实例：
        
        arr = [[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]] for i in range(len(arr)): for j in range(len(arr[i])): print(arr[i][j])
        
        1
        2
        3
        4

具体参考传送门1 (opens new window)，传送门2 (opens new window)

# 字典（Dictionary）常用操作

字典的创建，编辑和删除
1. 创建
  - 直接创建
    
    直接创建字典，利用一对大括号{}放置元素，每个元素都以键值对的形式。
    
    语法：
```
dictionary = {'key1':'value1','key2':'value2',...'keyn':'valuen',}
```
    1
    参数说明：
    - dictionary：表示字典名称。
    - key1、key2...valuen：表示元素的键，必须是唯一的，并且不可变，例如，可以是字符串、数字或者元组。
    - value1、value2...valuen：表示元素的值，可以是任何数据类型，不是必须唯一的。
    实例：
```
dict = {'name':'snake8859','age':22,'gender':'boy'}
```
    1
  - dict()
    
    除了直接创建，dict()函数也可以用于创建一个字典。
    
    语法：
```
dictionary = dict(zip(list1,list2))
```
    1
    参数说明：
    - dictionary：表示字典名称。
    - zip() 函数：用于将多个列表或元组对应位置的元素组合为元组，并返回包含着些内容的zip 对象。如果想获取元组，可以将zip 对象使用tuple() 函数转换为元组；如果想获取列表，则可以使用list() 函数将其转换为列表。
    实例：
```
key = ['name','age','gender']        # 作为键的列表
value = ['snake8859',22,'bod']       # 作为值的列表
dictionary = dict(zip(key,value))    # 转换为字典
print(dictionary)                    # 输出转换后字典
```
    1
    2
    3
    4
  - 字典推导式
    
    与列表推导式一样，字典也拥有其推导式，也是为了快速生成一个字典。
2. 编辑
  - 编辑-添加
    
    语法：
```
dictionary[key] = value
```
    1
    参数说明：
    - dictionary：表示字典名称。
    - key：表示要添加元素的键，必须是唯一的，并且不可变，例如可以是字符串、数字或者元组。
    - value：表示元素的值，可以是任何数据类型，不是必须唯一的。
    实例：
```
dict = {'name':'snake8859','age':22,'gender':'boy'}
dict['weight'] = '75kg'
```
    1
    2
  - 编辑-修改
    
    与添加类似，把key值换成已存在的key值即可。
3. 删除
  - del
    
    del等你删除单一元素，也能删除字典。
```
dict = {'name':'snake8859','age':22,'gender':'boy'}
del dict['name'] # 删除键 'name'
del dict         # 删除字典
```
    1
    2
    3
  - clear()
    
    clear()函数用于删除字典内所有元素
```
dict = {'name':'snake8859','age':22,'gender':'boy'}
dict.clear()
```
    1
    2
字典的访问
1. 键值对访问
  
  访问字典的元素，可以通过键的方式访问。
```
dict = {'name':'snake8859','age':22,'gender':'boy'}
print(dict['name']) #snake8859
```
  1
  2
  但是这种方式存在一个问题，我们需要了解字典的key都有哪一些，不然当我们访问不存在的key时，会出现异常。具体的解决办法，一方面可以通过if语句先做判断，另一方面可以利用get()函数（推荐）。
  
  使用字典对象的get() 方法获取指定键的值。
  
  语法：
```
dictionary.get(key[,default])
```
  1
  参数说明：
  - dictionary：为字典对象，即要从中获取值的字典。
  - key：为指定的键。
  - default：为可选项，用于指定当指定的“键”不存在时，返回一个默认值，如果省略，则返回None。
  由于有default参数，不存在的时候会返回对应内容，而不会报错。
```
dict = {'name':'snake8859','age':22,'gender':'boy'}
print(dict.get('name')) #snake8859
print(dict.get('xxx','该键不存在')) #该键不存在
```
  1
  2
  3
2. 遍历访问
  - items()
    
    items()函数可以获取键-值对的元组列表，并输出全部键-值对
```
dict = {'name':'snake8859','age':22,'gender':'boy'}
for item in dictionary.items():
    print(item)
```
    1
    2
    3
    也可以获取具体每个键和值
```
dict = {'name':'snake8859','age':22,'gender':'boy'}
for key,value in dictionary.items():
    print(key,value)
```
    1
    2
    3
  - values()
    
    类似于items()，获取字典的所有值。
  - keys()
    
    类似于items()，获取字典的所有键。
字典的操作

具体参考传送门1 (opens new window)，传送门2 (opens new window)

# 集合（Set）常用操作

集合的创建，编辑和删除
1. 创建
  - 直接创建
    
    集合可以直接通过{}创建。
    
    语法：
```
setname = {element 1,element 2,element 3,...,element n,}
```
    1
    - setname：表示集合的名称，可以是任何符合Python 命名跪着的标识符。
    - element 1，element 2，element 3，...，element n：表示集合中的元素，个数没有限制，只要是Python 支持的数据类型就可以。
    注意：在创建集合时，如果输入了重复的元素，Python 会自动只保留一个。
    
    实例：
```
set1 = {'cs','bj','jy','ay'}
print(set1)
```
    1
    2
    说明：由于Python中的set 集合是无序的，所以每次输出时元素的排列顺序可能都不相同。
  - set()
    
    除了直接创建，也可以通过set()函数创建集合或者将列表，元组等其他数据类型转换为集合。
    
    语法：
```
setname = set(iteration)
```
    1
    参数说明：
    - setname：表示集合名称。
    - iteration：表示要转换为集合的可迭代对象，可以是列表、元组、range 对象等，也可以是字符串。如果是字符串，返回的集合将是包含全部不重复字符的集合。
    实例：
```
set1 = set(['cs','bj','jy','ay'])
print(set1)
```
    1
    2
    注意：在创建空集合中，只能使用set() 实现，而不能使用对“{}”实现，这是因为在Python中，直接使用一对“{}”表示创建一个空字典。
2. 编辑
  - 编辑-添加
    
    使用add()函数可以为集合添加元素
    
    语法：
```
setname.add(element)
```
    1
    参数说明：
    - setname：表示要添加元素的集合。
    - element：表示要添加的元素内容，只能使用字符串、数字及布尔类型的True 或者 False 等，不能使用列表、元组等可迭代对象。
    实例：
```
set1 = set(['cs','bj','jy','ay'])
set1.add('wh')
print(set1)
```
    1
    2
    3
3. 删除
  
  使用del 命令删除整个集合，也可以使用集合的pop() 方法或者remove() 方法删除一个元素，或者使用集合对象的clear() 方法清空集合，即删除集合中的全部元素，使其变为空集合。
  - del
  - pop()
```
setname.pop() 
```
    1
    set 集合的 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。所以多次执行结果都会不一样
  - remove()
```
setname.remove( x )
```
    1
    将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。
  - discard()
```
setname.discard( x )
```
    1
    该方法也是移除集合中的元素，且如果元素不存在，不会发生错误
  - clear()
集合的访问

与列表(List)访问类似

集合的操作

集合最常用的操作就是进行交集、并集、差集和对称差集运算。进行交集运算时使用“&”符号，进行并集运算时使用“|” 符号，进行差集运算时使用“-”符号，进行对称差集运算时使用“^” 符号。

实例：

>>> # 下面展示两个集合间的运算.
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b                              # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b                              # 不同时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

具体参考传送门1 (opens new window)，传送门2 (opens new window)

# 元组（Tuple）常用操作

元组的创建，编辑和删除
1. 创建
  - 直接创建
  - tuple()
  - 元组推导式
    
    使用元组推导式可以快速生成一个元组，它的表现形式和列表推导式类似，只是将列表推导式中的“[]” 修改为“()”
```
tuple1 = ( i for i in range(10))
print(tuple1)  #<generator object <genexpr> at 0x00000000084B7F48>
tuple2 = tuple(tuple1)
print(tuple2) # (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
```
    1
    2
    3
    4
    注意：使用元组推导式生成的结果并不是一个元组或者列表，而是一个生成器对象。要使用该生成器对象可以将其转换为元组或者列表。其中，转换为元组使用tuple() 函数，而转换为列表则使用list() 函数。生成器对象，还可以直接通过for 循环遍历或者直接使用__next__() 方法进行遍历。
```
number = (i for i in range(4))          # 生成生成器对象
for i in number:                        # 遍历生成器对象
    print(i,end='')                     # 0 1 2
print(tuple(number))                    # ()
```
    1
    2
    3
    4
    可以发现，在遍历后，原生成器对象的内容已经不存在了，想要再次使用，需要重写创建一个新的生成器对象。
2. 编辑
  - 编辑-修改
    
    元组是不可变序列，所以我们不能对它的单个元素值进行修改。但是元组也不是完全不能修改。我们可以对元组进行重新赋值。
```
codename = ("pyhton","java","JavaScript","C#","C")            # 定义元组
codename = ("pyhton","java","JavaScript","C#","C/C++")            # 对元组进行重新赋值
print("新元组",codename)
```
    1
    2
    3
    还可以对元组进行连接组合。在进行元组连接时，连接的内容必须都是元组。不能将元组和字符串或者列表进行连接。
```
codename = ("pyhton","java")
print("原元组：",codename)
codename = codename + ("JavaScript","C#","C/C++")
print("组合后：",codename)
```
    1
    2
    3
    4
3. 删除
  
  元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组。
  
  语法：
```
del tuplename
```
  1
  参数说明：
  - tuplename 为要删除元组的名称。
元组的访问

与列表(List)类似
元组的操作
元组和列表的区别

元组和列表都属于序列，而且它们又都可以按照特定顺序存放一组元素，类型又不受限制，只要是Python支持的类型都可以。那么它们之间有什么区别呢?

列表类似于我们用铅笔在纸上写下自己喜欢的歌词，写错了还可以擦掉:而元组则类似于用钢笔写下的歌词，写错了就擦不掉了，除非换一张纸重写。

列表和元组的区别主要体现在以下几个方面：
1. 列表属于可变序列，它的元素可以随时以修改或者删除；:元组属于不可变序列，其中的元素不可以修改，除非整体替换。
2. 列表可以使用 append()、 extend()、 Insert()、 remove()和pop()等方法实现添加和修改列表元素，而元组没有这几个方法，所以不能向元组中添加和修改元素。同样，元组也不能删除元素。
3. 列表可以使用切片访问和修改列表中的元素。元组也支持切片，但是它只支持通过切片访问元组中的元素，不支持修改。
4. 元组比列表的访问和处理速度快，所以当只是需要对其中的元素进行访问，而不进行任何修改时，建议使用元组。
5. 列表不能作为字典的键，而元组则可以。

具体参考传送门1 (opens new window)，传送门2 (opens new window)

# 输入输出拓展

控制台输入输出print()和input()
1. print()
  
  print()函数，用于控制台输出。如果想要更多的输出方式，可以结合字符串格式化的内容。
2. input()
  
  input()函数，用于从标准输入读入一行文本，默认的标准输入是键盘。
```
str = input("请输入：");
print ("你输入的内容是: ", str)

请输入：你好
你输入的内容是:  你好
```
  1
  2
  3
  4
  5

持久化输入输出

控制台输出是临时的，当程序退出后，内容就会消失。若要将内容保存，就需要持久化。持久化分为两种，第一文件操作，第二是序列化和反序列化。

文件操作

文件打开和关闭

在python里，文件的打开和关闭很简单。打开文件使用open()函数，将会返回一个file对象。关闭文件使用close()函数。

语法：

f = open(filename, mode) # 打开文件
f.close() # 关闭文件

1
2

参数说明：

filename：包含了你要访问的文件名称的字符串值。
mode：决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)
返回值：文件file对象f

不同模式打开文件的完全列表：

模式	描述
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

实例：

# 打开一个文件
f = open("/tmp/snake8859-ss.txt") # 默认只读(r)
# 关闭打开的文件
f.close()

1
2
3
4

当你处理完一个文件后, 调用 f.close() 来关闭文件并释放系统的资源，如果尝试再调用该文件，则会抛出异常。当处理一个文件对象时, 使用 with 关键字是非常好的方式，这种方式后期还会再细说。

>>> with open('/tmp/snake8859-ss.txt', 'r') as f:
    	...
>>> f.closed
True

1
2
3
4

文件读写等操作

在打开文件后，就需要对文件进行读写操作。

f.read()

read()方法用于读取一个文件内容。

语法：

data = f.read(size)

参数说明：

size为可选参数，为读取文件字节大小，当 size 被忽略了或者为负, 那么该文件的所有内容都将被读取并且返回。

实例：

# 打开一个文件
f = open("/tmp/snake8859.txt", "r")

str = f.read()
print(str)

# 关闭打开的文件
f.close()

#with方式
with open("/tmp/snake8859.txt", "r") as f:
    str = f.read()
    print(str)

1
2
3
4
5
6
7
8
9
10
11
12
13

f.readline()和f.readlines()

f.readline() 会从文件中读取单独的一行。换行符为 '\n'。f.readline() 如果返回一个空字符串, 说明已经已经读取到最后一行。

# 打开一个文件
f = open("/tmp/snake8859.txt", "r")

str = f.readline()
print(str)

# 关闭打开的文件
f.close()

#with方式
with open("/tmp/snake8859.txt", "r") as f:
    str = f.readline()
    print(str)

1
2
3
4
5
6
7
8
9
10
11
12
13

f.readlines() 将返回该文件中包含的所有行。

如果设置可选参数 sizehint, 则读取指定长度的字节, 并且将这些字节按行分割。

# 打开一个文件
f = open("/tmp/snake8859.txt", "r")

lines = f.readlines()
print(lines)

#遍历每一行
for line in lines:
    print(line)

# 关闭打开的文件
f.close()

#with方式
with open("/tmp/snake8859.txt", "r") as f:
    lines = f.readlines()
    print(lines)
	for line in lines:
    	print(line)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

f.write()

write()方法用于向文件写入内容。

语法：

f.write(string)

参数说明：

string为需要写入字符串
返回值：写入的字符数

实例：

# 打开一个文件
f = open("/tmp/snake8859.txt", "w")
num = f.write( "人生就是一列开往坟墓的列车，路途上会有很多站，很难有人可以自始至终陪着走完。当陪着你的人要下车时，即使不舍也该心存感激，然后挥手道别。\n是的，告别吧!!\n" )
print(num)
# 关闭打开的文件
f.close()

#with方式
with open("/tmp/snake8859.txt", "w") as f:
    num = f.write( "人生就是一列开往坟墓的列车，路途上会有很多站，很难有人可以自始至终陪着走完。当陪着你的人要下车时，即使不舍也该心存感激，然后挥手道别。\n是的，告别吧!!\n" )
    print(num)

1
2
3
4
5
6
7
8
9
10
11

注意：写入里没有writeline()方法，所以在需要换行时，需要使用换行符\n。

f.tell()

tell()方法用于返回文件对象当前所处的位置, 它是从文件开头开始算起的字节数。
f.seek()

seek()方法用于改变文件当前的位置。

语法：
```
 f.seek(offset, from_what)
```
1
参数说明：
- offset为移动的字符数
- from_what如果是 0 表示开头, 如果是 1 表示当前位置, 2 表示文件的结尾
  - seek(x,0) ：从起始位置即文件首行首字符开始移动 x 个字符
  - seek(x,1) ：表示从当前位置往后移动x个字符
  - seek(-x,2)：表示从文件的结尾往前移动x个字符
实例：
```
>>> f = open('/tmp/snake8859.txt', 'rb+')
>>> f.write(b'0123456789abcdef')
16
>>> f.seek(5)     # 移动到文件的第六个字节
5
>>> f.read(1)
b'5'
>>> f.seek(-3, 2) # 移动到文件的倒数第三字节
13
>>> f.read(1)
b'd'
```
1
2
3
4
5
6
7
8
9
10
11

序列化和反序列化

python的pickle模块实现了基本的数据序列和反序列化

序列化

pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储

语法：

pickle.dump(obj, file, [,protocol])

参数说明：

obj为对象信息
file为输出保存的文件

实例：

import pickle

# 使用pickle模块将数据对象保存到文件
data1 = {'a': [1, 2.0, 3, 4+6j],
         'b': ('string', u'Unicode string'),
         'c': None}

output = open('data.pkl', 'wb')

# Pickle dictionary using protocol 0.
pickle.dump(data1, output)

1
2
3
4
5
6
7
8
9
10
11

反序列化

pickle模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象

语法：

x = pickle.load(file)

实例：

import pprint, pickle

#使用pickle模块从文件中重构python对象
pkl_file = open('data.pkl', 'rb')

data1 = pickle.load(pkl_file)
pprint.pprint(data1)

data2 = pickle.load(pkl_file)
pprint.pprint(data2)

pkl_file.close()

1
2
3
4
5
6
7
8
9
10
11
12

除了该模块，还有很多方式进行序列化和反序列化，可参考传送门 (opens new window)

具体参考传送门1 (opens new window)，传送门2 (opens new window)

# 常用内置模块

将一些平日里常用的内置模块使用方式整理于此。

引言 Python面向对象

Snake8859

Python基础

Python基础

# Python介绍

# Pyhon环境搭建

# Python官方

# Anaconda or Miniconda

# Python交互式

# Python集成开发环境（IDE)

# Python基础语法

# 基本结构

# 注释

# 数据类型

# 变量，运算符，标识符和关键字

# 输出输入

# 函数

# 函数定义

# 函数调用

# 函数参数和返回值

# 函数高级应用

# 模块

# 使用模块

# 制作模块

# __name__属性

# Python的流程控制

# 顺序结构

# 选择结构

# 循环结构

# 跳转和空语句

# Python综合应用

# 字符串（String）常用操作

# 切片的语法：[起始:结束:步长]

# 列表（List）常用操作

# 字典（Dictionary）常用操作

# 集合（Set）常用操作

# 元组（Tuple）常用操作

# 输入输出拓展

# 常用内置模块

# name属性