一、变量及数据类型

1.1、变量

表1-变量的具体描述.png

• 变量的赋值操作

# 变量赋值
a = 100 # 赋值100给变量a
# 多变量同时赋值
a=b=c=1 
e,f,g=1,2,'abc'
print(a,b,c,e,f,g)
# 动态变量
# 变量的值是可更改的，可随时指向任意值
var=10
print(var)
var=20
print(var)

输出结果：

1 1 1 1 2 abc
10
20

1.2数据类型(结构)

数据结构：通过某种方式组织在一起的数据元素的集合。这些数据元素可以说数字或者字符，甚至可以是其他数据结构。

在python中，python的标准数据类型有numbers数字，string字符串，list列表，tuple元祖，dict字典，bool布尔型。

其中在python中，列表、元组、字符串、也是python的内建序列，在python中，序列也是最基本的数据结构。

表2-数据类型及描述.png

• numbers数字

numbers数字分为：int整型，long长整型，float浮点型，complex复数。此处只举例int、float。

#int整型
a=10
#float浮点型
b=10.0
print(type(a),type(b)) #输出a、b的数据类型
#函数print()，用于输出/打印内容
#函数type()，用于查看数据类型

输出结果：

<class 'int'> <class 'float'>

• string字符串

String字符串由数字、字母、下划线组成的一串字符，用于表示文本的数据类型。可以用单引号，双引号，三引号表示，用单引号和双引号是一样的，三引号可表示多行字符串。

st1='abc'
print(st1,type(st1))
st2="abc"
print(st2)
st3='''你好
大家好'''
print(st3)

输出结果：

abc <class 'str'> 
abc
你好
大家好

• list列表

list列表，用[]标识，是可变的有序对象。list支持字符，数字，字符串以包含列表（即嵌套）。

lst=[1,2,3,4,5,[1,2,3],'abc','efg']
print(lst,type(lst))

输出结果：

[1,2,3,4,5,[1,2,3],'abc','efg'] <class 'list'>

• tuple元祖

Tuple元祖，用()标识，是不可变的有序对象。不能二次赋值，可以理解成不可变的列表（只读列表）。

a=(1,2,3,'hello')
print(a,type(a))

输出结果：

(1,2,3,'hello') <class 'tuple'>

• dict字典

Dict字典，用{}标识，是无序对象。由索引(key)和它对应的值value组成，key-value是成对出现的。

dic={'a':1,'b':2,'c':3}
print(dic,type(dic))

输出结果：

{'a':1,'b':2,'c':3} <class 'dict'>

• bool布尔型

做bool布尔型的时候，输出结果为True，False，是用于做判断的。

a=True
print(a,type(a))
print(True == 1) 
#表示True是否等于1
print(False == 0) 
#表示False是否等于0
print(True * 10)
# 【注意】True实际值是1，False实际值是0

输出结果：

True <class 'bool'>
True
True
10

1.3数据类型的转换

int，float，str三者之间的转换。分别用函数int(x),float(x),str(x)，对变量进行转换。

# 整型转为浮点型
a=12
b=float(a)
print(a,type(a))
print(b,type(b))
print('---------------------------')
# a是整型，通过函数float()将a转换为浮点型

# 浮点型转为整型
a=12.8
b=int(a)
print(a,type(a))
print(b,type(b))
#a是浮点型，通过函数int()将a转换为整型
#注意：用int()将浮点型转为整型，是不会进行四舍五入的，也就是输出结果是12，而非13
#若要四舍五入就使用函数round()
c=round(a)
print(c,type(c))

输出结果：

12 <class 'int'>
12.0 <class 'float'>
---------------------------
12.8 <class 'float'>
12 <class 'int'>
13 <class 'int'>

若变量要转换为字符串也是一样的使用方法。

1.4运算符

表3-运算符及描述.png

• 算数运算符

# 加减乘除
a,b,c=1,2,3
print(a+b)
print(a-b)
print(a*b)
print(a/b)

# 取模，即系返回除数的余数
a,b=21,10
print(a%b)

# 取幂
a, b, = 2, 3
c = a**b   # 幂
print(c)
# 也就是求a的b次方

# 取整除数 
a, b = 10, 4
c = a//b  
print(c)
# 取整除数，也就是求10/4的整除数

输出结果：

3
-1
2
0.5
1
8
2

• 比较运算符

a, b = 21, 10
print(a == b)  # 等于
print(a != b)  # 不等于
print(a > b)  # 大于
print(a < b)  # 小于
print(a >= 21)  # 大于等于
print(a <= 2)  # 小于等于

• 逻辑运算符

and、or、not

print(True and False)  # and：且
print(True or False)  # or：或
print(not True)  # not：非
# 布尔型的本质：True的值等于1，False的值等于0
print(True>0)

输出结果：

False
True
False
True

【注意】将值转换为布尔型时，只有以下这几种情况布尔返回False，其余均返回True——

print(bool(0),bool(3),bool(-1),bool([1,2,3]),bool(0))
# 以上情况bool()返回False：0, 0.0, None，'', [] , {}

输出结果：

False True True True False

• 成员运算符

# in和not in
lst = [1,2,3,4,5,6]
a,b = 1,10
print(a in lst)  
#判断a是否在lst 序列中，若为真返回True
print(b not in lst)  
#判断b是否不在lst序列中，若为真返回True

输出结果：

True
True

1.5注释#

注释是用来说明代码。程序运行的时候，Python解释器会直接忽略掉注释，即系有没有注释不影响程序的执行结果，但是影响到别人能不能看懂你的代码。但“#”不只代表注释,还代表某些文件的特殊格式，写在脚本开头，因此要注意——注释只在脚本中起作用。

二、序列及其通用操作

序列分类：可变序列list，不可变序列tuple、str。在python中，内建了6中序列：列表、元组、字符串、unicode字符串、buffer对象、xrange对象。

2.1序列的通用操作

表4-序列的通用操作及描述.png

• 序列通用功能

# 序列通用功能
print('a' in 'abc')  # in/not in ：判断是否存在
print('我很帅' + "没错")  # 文本连接
print('handsome '*4)  # 文本复制

输出结果：

True
我很帅没错
handsome handsome handsome handsome

• 序列基本的内置函数

# 序列基本的内置全局函数
lst=list(range(5))
tup=(33,56,89,100)
st='abcdef'
print(lst,tup,st)
# 求长度的函数len()
print(len(lst),len(tup),len(st))
# 求最大值和最小值的函数，max(),min()
print(max(lst),max(tup),max(st))
print(min(lst),min(tup),min(st))
#求和的函数sum()
print(sum(lst),sum(tup)) # 字符串str没有求和的功能
#求索引的位置用方法.index()
print(lst.index(2)) #求lst序列中值为2的索引
print(tup.index(33)) #求tup序列中值为33的索引
print(st.index('d'))
print('-----------')
#求计数的方法.count()
lst=[1,2,3,3,3,3]
tup=(33,33,33,44,6)
st='aabbeeee'
print(lst.count(3)) # 计算lst序列中的3有几个
print(tup.count(33))
print(st.count('e'))

输出结果：

[0, 1, 2, 3, 4] (33, 56, 89, 100) abcdef
5 4 6
4 100 f
0 33 a
10 278
2
0
3
-----------
4
3
4

2.2可变序列：list列表常用操作

表5-list列表常用操作及描述.png

• list列表的特征及创建

# 创建列表
lst1 = [1,2,3,'a','b','c',[1,2,3]]
print(lst1)

# 列表原位改变
lst5 = [100,101,102]
lst5[0] = 10
print(lst5)
#lst5的索引为0的值原本为100，后面重新赋值给索引为0的位置，变为了10
#也是因为list是有序可变对象，所以list的原位改变

# 列表的索引访问元素
lst2 = [143,56,894,67,43]
print(lst2[0],lst2[4],lst2[-1])
# 正因为list列表是有序的对象，顺序不能变，因此通过索引来定位列表的元素

输出结果：

[1, 2, 3, 'a', 'b', 'c', [1, 2, 3]]
[10, 101, 102]
143 43 43

• list列表的下标索引、切片、步长

# 下标索引
lst=[1,2,3,4,5,6,7,8,9]
print(lst[0],lst[5],lst[8])
# 表示分别指向索引为0、索引为5、索引为8的值
print(lst[-1],lst[-2])
print('--------------------------')
# 索引为-1代表列表的最后一个值,-2代表列表倒数第二个值，带符号的以此类推
# lst此列表最大索引为8，不能定位超过最大索引

# 切片
lst=[1,2,3,4,5,6,7,8,9]
print(lst[0:3])
#因为左闭右开区间，索引表示索引0-2的值
print(lst[:5])
#左边无索引数，表示指向从索引0开始到索引4的值
print(lst[2:])
#右边无索引数，表示指向从索引2开始到最后一个索引的值
print(lst[5:-1])
#表示指向从索引5的值到倒数第二个值的区间

# 步长
lst = [1,2,3,4,5,6,7,8,9,0]
print(lst[0:5:2])  # List[i:j:n]代表：索引i - 索引j，以n为步长
print(lst[::2])  # 按照2为步长，从第一个值开始截取lst数据
print(lst[1::2])  # 按照2为步长，从第二个值开始截取lst数据

输出结果：

1 6 9
9 8
--------------------------
[1, 2, 3]
[1, 2, 3, 4, 5]
[3, 4, 5, 6, 7, 8, 9]
[6, 7, 8]
[1, 3, 5]
[1, 3, 5, 7, 9]
[2, 4, 6, 8, 0]

• list列表添加元素

• 方法1：链接法给list列表添加元素，链接符号是“+”，并且链接的对象必须类型一致

lst1=[1,2,3,4,5]
lst2=['abc',1,3,5]
print(lst1+lst2)

输出结果：

[1,2,3,4,5,'abc',1,3,5]

• 方法2：方法.append()给list列表尾部添加元素，将添加的对象作为一个整体对象添加到原列表list中，所以是会改变了原列表list的

lst1=[2,4,6,8,0]
lst1.append(['a','b','c'])
print(lst1)

输出结果：

[2, 4, 6, 8, 0, ['a', 'b', 'c']]

• 方法3：方法.extend()给list列表尾部添加元素，是将添加的对象中的每一个元素，一个个添加在原始列表中，所以同样会改变原列表list的

lst1=[2,4,6,8,0]
lst1.extend(['a','b','c'])
print(lst1)

输出结果：

[2, 4, 6, 8, 0, 'a', 'b', 'c']

• list列表插入元素

# 列表插入元素，用方法.insert(索引，值)
# 元素会被插入到指定索引的位置，原本位置的值依次后退
lst=['a','n','c']
lst.insert(1,100) # 在索引为1的地方插入值为100
print(lst)

输出结果：

['a', 100, 'n', 'c']

• list列表删除元素

• 方法1：方法.remove(值)，移除列表中的某个值

lst=[22,43,123,100]
lst.remove(100) 
#将列表中的值100移除
print(lst)

输出结果：

[22, 43, 123]

• 方法2：方法.pop(索引)，移除列表中某个索引对应的值

lst=[1,2,3,4,5]
lst.pop(1) # 将索引为1的值移除
print(lst)

输出结果：

[1, 3, 4, 5]

• 方法3：方法.clear()，可清除列表的所有值

lst=[1,2,3,4,5,6,7,89]
lst.clear()
print(lst)

输出结果：

[] #所有值都清除了，所以返回为空列表

• 方法4：用del语句，删除列表的某个值或某个范围的值，或整个列表

lst=['a','b','c','d','f','g','h','i']
del lst[0] # 删除索引为0的值
print(lst)
del lst[0:4] # 删除索引为0-3的值
print(lst)
del lst #删除整个列表
#print(lst) # 因为整个删除了整个列表list所以不能返回
#返回就会报错：NameError: name 'lst' is not defined

输出结果：

['b', 'c', 'd', 'f', 'g', 'h', 'i']
['g', 'h', 'i']

• list列表复制

假如需要对列表进行某种操作，如添加或删除元素，或其他操作，但希望原始列表保持不变，可以通过复制一个列表，对副本操作而保持原始列表不变。

• 方法1：使用[:]复制一个列表

lst1=list('abcde')
print('我是原始列表',lst1)
# 使用[:]复制一个列表
# 在原始列表名称后添加[:]，将其赋给要给新变量即可
lst2=lst1[:]
print('我是复制的列表副本',lst2)
lst2[0]=100
print(lst2)
print('原始列表不变：',lst1)

输出结果：

lst1=list('abcde')
print('我是原始列表',lst1)
# 使用[:]复制一个列表
# 在原始列表名称后添加[:]，将其赋给要给新变量即可
lst2=lst1[:]
print('我是复制的列表副本',lst2)
lst2[0]=100
print(lst2)
print('原始列表不变：',lst1)

• 方法2：用方法.copy()，复制列表

lst1=[1,2,3,4,5]
lst2=lst1
lst1[4]=100 # 原位改变lst1索引为4的值，改为100
print(lst1,lst2) # 这时候lst2也会受影响改变，因为lst2=lst1
# 这时候若使用方法.copy()就可以杜绝以上情况
lst1=[1,2,3,4,5]
lst2=lst1.copy() # lst2就等于lst1的复制
lst1[4]=100
print(lst1,lst2)

输出结果：

[1, 2, 3, 4, 100] [1, 2, 3, 4, 100]
[1, 2, 3, 4, 100] [1, 2, 3, 4, 5]

• list列表元素排序

• 方法1：方法.sort()排序，默认升序排列

lst=[33,44,1,56,123,0,546]
lst.sort() # 默认升序排列
print(lst) 
lst.sort(reverse=True) # 参数reverse=True 按照降序排列
print(lst)

输出结果：

[0, 1, 33, 44, 56, 123, 546]
[546, 123, 56, 44, 33, 1, 0]

• 方法2：用函数sorted()排序，默认升序排列，且不改变原列表，是复制一个原列表作为新列表进行排序

lst=[44,67,2,4,1,98,156,0]
lst2=sorted(lst)
print(lst) # 没有改变原序列
print(lst2)
lst3=[333,42,6,11,0]
lst4=sorted(lst3,reverse=True) # 参数reverse=True 按照降序排列
print(lst3,lst4)

输出结果：

[44, 67, 2, 4, 1, 98, 156, 0]
[0, 1, 2, 4, 44, 67, 98, 156]
[333, 42, 6, 11, 0] [333, 42, 11, 6, 0]

• list列表与生成器range()

range()是生成器，指向一个范围。range()的数据类型是一个视图，虽然生成的是一个视图不是列表，但是有可以做索引、切片、步长。range()生成器用list()函数将指向的范围变为列表list

range()的切片、步长与list的切片、步长有区别：
list的切片表示lst[0:3]、步长表示lst[0:6:2]
range的切片表示range(0,3)、步长表示range(0,10,2)

b=range(5)
print(range(5),type(range(5)))
print(range(5))
#代表指向了0,1,2,3,4这几个值
print(range(2,5))
#代表指向了2,3,4这几个值
print(range(0,10,2))
#代表指向了0,2,4,6,8这几个值，最后的2代表步长
a=list(range(10))
#用函数list()将生成器指向的0-9范围变为列表list
print(a,type(a))

输出结果：

range(0, 5) <class 'range'>
range(0, 5)
range(2, 5)
range(0, 10, 2)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] <class 'list'>

2.3不可变序列：tuple元祖常用操作

表6-元祖常用操作及描述.png

• tuple元祖的特征及创建

# 创建元祖
tup1=(1,2,3,4)
print(tup1,type(tup1))
tup2=(1,2,3,('a','b'),10)
print(tup2,type(tup2))
tup3=(1,2,3,['a','b'],(22,45))
print(tup3,type(tup3))
print('-----------------------')

# tuple元祖可以不加括号（了解就好，一般不建议使用此写法）
tup3 = "a", "b", "c", "d"
print(tup3)
print('-----------------------')

# tuple元组中只包含一个元素时，需要在元素后面添加逗号
tup4 = (50,)
print(tup4)

输出结果：

(1, 2, 3, 4) <class 'tuple'>
(1, 2, 3, ('a', 'b'), 10) <class 'tuple'>
(1, 2, 3, ['a', 'b'], (22, 45)) <class 'tuple'>
-----------------------
('a', 'b', 'c', 'd')
-----------------------
(50,)

• tuple元祖的下标索引、切片、步长

tuple元祖是有序的不可变序列，所以下标索引、切片、步长的使用与list一样。但是因为是不可变序列，所以tuple元祖是不可以做原位改变元素的，也不能添加元素、插入元素、删除元素、对元素进行排序。

tup=(2,31,45,90,100,23,56,'abc')
print(tup)
print(tup[1]) #定位索引为1的值
print(tup[0:4]) # 定位索引为0-3的值
print(tup[::2]) # 定位从头到尾的索引的值且步长为2

输出结果：

(2, 31, 45, 90, 100, 23, 56, 'abc')
31
(2, 31, 45, 90)
(2, 45, 100, 56)

• 删除tuple元祖

因为tuple元祖是不可变序列，所以不可以单独删除内部元素，但是可以用def语句删除整个元祖。

tup1 = (1,2,3,4,5)
print(tup1)
del tup1
#print(tup1) #删除整个元祖了，所以返回时会报错的

输出结果：

(1, 2, 3, 4, 5)

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-60-8a01d172e139> in <module>()
      2 print(tup1)
      3 del tup1
----> 4 print(tup1)

NameError: name 'tup1' is not defined

2.4不可变序列：str字符串常用操作

字符串string，有序的不可变对象。字符串是Python中最常用的数据类型。我们可以使用引号('或")来创建字符串，字符串也是序列——文本序列。

表7-字符串常用操作及描述.png

补充：
判断字符串是否含有空格：.isspace()
判断字符串是否含有数字：.isdigit()

• str字符串的特征及创建

# 字符串创建
str1 = "abc"
str2 = 'abc'
str3 = 'my name is "fatbird"'
# 双引号单引号无区别，但文本中有引号的时候要相互交替使用
# 需要多行字符串时候用三引号 ''' ''',""" """
str4 = '''hello! how are you?
          I`m fine, thank you.'''

输出结果：

abc
abc
my name is "fatbird"
hello! how are you?
          I`m fine, thank you.

• str字符串的转义字符\

# 换行符号 ‘\n'
print('尊敬的女士：\n 你好！')
print('\'', '\"')  
# \',\" ：分别输出单引号，双引号
print('hello\nhow do you do?')  
# \n：空行
print('\\')  
# 输出\，所以文件路径用“/”或者“\\

输出结果：

尊敬的女士：
 你好！
' "
hello
how do you do?
\

• str字符串的小标索引、切片、步长

str字符串的的索引、切片和步长的使用与list的使用类似。

# 创建字符串
s = 'abcdefghijklmn'
print(s,type(s))
print(s[0])
print(s[1:3])
print(s[::2])

输出结果：

abcdefghijklmn <class 'str'>
a
bc
acegikm

• 修改str字符串元素

# str.replace(old,new,count)：修改字符串
# old → 原字符串中要替换的字符串
# new → 新的字符串
# count → 更换几个
st = "i`m handsome!"
st2 = st.replace('handsome','ugly')
print(st)
print(st2)
# 'handsome'换为'ugly'
st = 'hahaha'
st2 = st.replace('ha','he',2)
print(st2)
# 'ha'换为'he',而且换2个

输出结果：

i`m handsome!
i`m ugly!
heheha

• 拆分str字符串

# 拆分字符串
# str.split(obj)：拆分字符串，生成列表
st = "poi01,116.446238,39.940166"
print(st)
print(type(st))
lst = st.split(',') # 将字符串按逗号拆分
print(lst)
print(type(lst))

输出结果：

poi01,116.446238,39.940166
<class 'str'>
['poi01', '116.446238', '39.940166']
<class 'list'>

• 连接str字符串

# 连接str字符串
# str.join()：连接字符串，对象为字符串序列
lst = ['poi01', '116.446238', '39.940166']
print(lst,type(lst))
m = '-'
st = m.join(lst) # 用m将lst的元素连接起来
print(st,type(st))

输出结果：

['poi01', '116.446238', '39.940166'] <class 'list'>
poi01-116.446238-39.940166 <class 'str'>

• 判断str字符串的开头/结尾

# 判断字符串的开头/结尾
st = 'abcdefg'
print(st.startswith('a'), st.endswith('f'))
# str.startswith(“str”)  判断是否以“str”开头；str.endswith (“str”)  判断是否以“str”结尾

输出结果：

True False

• str字符串字母大小写互换

# 字符串字母大小写互换
st = 'aBDEAjc kLM'
print(st.upper())  # 全部大写
print(st.lower())  # 全部小写
print(st.swapcase())  # 大小写互换
print(st.capitalize())  # 首字母大写

输出结果：

ABDEAJC KLM
abdeajc klm
AbdeaJC Klm
Abdeajc klm

• 删除str字符串末尾空格

st = 'avd   '
print(st.rstrip())  # 删除字符末尾的空格

输出结果：

avd

• 判断str字符串是否只包含数字

# 判断str字符串是否只包含数字
st = '1234567'
print(st.isnumeric())  
# 如果 string 只包含数字则返回 True,否则返回 False.

返回结果：

True

• 判断字符串是否至少有一个字符且所有字符都是字母

# 判断字符串是否至少有一个字符且所有字符都是字母
st = 'DNVAK'
print(st.isalpha())  
# 如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False

输出结果：

True

• 格式化字符——在字符串中插入变量

# 格式化字符——在字符串中插入变量
name = "FATBIRD"
truth = "%s is 好人" %name
print(truth)
# %s 表示我们这里要插入一个字符型的变，%name代表这里我们插入name变量 
# 所以，要两个%解决问题

x = 4   
y = "hehe"  
z = 4.2
print("this is %i" %x)
print("this is %s" %y)
print("this is %f" %z)
# %s %i %f都是格式化字符串，s/i/f分别代表插入字符串的源数据类型：字符型/整型/浮点型

输出结果：

FATBIRD is 好人
this is 4
this is hehe
this is 4.200000

• 格式化字符串——数字格式化

# 格式化字符：数字格式化的那些坑

# 输出2位小数
# %.2f，此处是四舍五入！
m = 3.1415926 
print("pi is %f"  %m)
print("pi is %.2f" %m)
print('---------------------------------')

# 注意：输出整数与输出整数型的区别
m = 10.6
print("pi is %.0f" %m)
# 10.6输出整数 → 11，此处四舍五入

print("pi is %i"  %m)
# 10.6输出整数型 → 10，此处不四舍五入，直接切掉小数部分
print('---------------------------------')

# 输出科学计数形式
# 科学计数法 %e  %E
m = 123.123123123 
print("have fun %.2e"  %m) # → 保留2位小数
print("have fun %.4E"  %m) # → 保留4位小数
print('---------------------------------')

# 输出数据显示正负号，根据数字直接显示
m = 100 
print("have fun %+i"  %m)
print("have fun %.2f"  % -0.01)
print('---------------------------------')

# 自动识别数据输出合适形式
m1 = 123.123123123
print("have fun %g"  %m1)  # → 数据复杂的时候自动识别用科学计数法
print("have fun %.2g"  %m1) # → 注意与科学计数区别 %.2e → 表示保留2位小数，这里%.2g表示保留2位有效数字

m2 = 1.2
print("have fun %g"  %m2) # → 小数位数少的时候自动识别用浮点数

输出结果：

pi is 3.141593
pi is 3.14
---------------------------------
pi is 11
pi is 10
---------------------------------
have fun 1.23e+02
have fun 1.2312E+02
---------------------------------
have fun +100
have fun -0.01
---------------------------------
have fun 123.123
have fun 1.2e+02
have fun 1.2

三、dict字典常用操作

dict字典，用{}标识，是无序对象。由索引(key)和它对应的值value组成，key-value是成对出现的。dict是另一种可变容器模型，且可存储任意类型对象。字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中，键必须是唯一的，但值则不必。

表8-字典常用操作及描述.png

• dict字典基本特征及创建

# 字典的创建

# 创建①直接手动书写创建
# 手动书写申明一个字典变量
dic = {'a':1,'b':2}
print(dic)
print('----------------------------')

# 创建②用函数dict()
dic = dict(m = 10 ,n = 'aa', h = [1,2,3])
print(dic)
print('----------------------------')

# 创建③生成序列再用dict()函数创建
# dict()由序列生成一个字典，嵌套序列，可以是list或者tuple
lst1=[("a","fff"),("b","ggg")]
lst2=[["c",1],["d",2]]
lst3=(("e",[1,2]),("f",[3,4]))
dic1 = dict(lst1)
dic2 = dict(lst2)
dic3 = dict(lst3)
print(dic1,dic2,dic3)
print('----------------------------')

# 创建④用dict.fromkeys()创建
# 只有key，直接生成一个字典
keys = ["a", "b", "c"]
dic1 = dict.fromkeys(keys) # →返回的dict的value为None
dic2 = dict.fromkeys(keys, 'hello') # →返回的dict的value均为hello，因为定义了value的值
print(dic1,dic2)

输出结果：

{'a': 1, 'b': 2}
----------------------------
{'h': [1, 2, 3], 'm': 10, 'n': 'aa'}
----------------------------
{'a': 'fff', 'b': 'ggg'} {'d': 2, 'c': 1} {'e': [1, 2], 'f': [3, 4]}
----------------------------
{'a': None, 'b': None, 'c': None} {'a': 'hello', 'b': 'hello', 'c': 'hello'}

• dict字典的添加、修改、删除元素

# dict字典的添加、修改、删除元素
# 直接索引key进行添加、修改、删除

# 创建dict字典
dic = dict(m=1,n=2,c=5)
print(dic)
# 任意添加元素
dic['f'] = '添加一个值'  
print(dic)

# 任意修改元素
dic['n'] = '任意修改其中一个值'
print(dic)

# 任意删除元素
del dic['m']  
print(dic)

输出结果：

{'m': 1, 'c': 5, 'n': 2}
{'m': 1, 'f': '添加一个值', 'c': 5, 'n': 2}
{'m': 1, 'f': '添加一个值', 'c': 5, 'n': '任意修改其中一个值'}
{'f': '添加一个值', 'c': 5, 'n': '任意修改其中一个值'}

• dict字典的删除与清除

# dict字典的删除与清除

# 创建dict字典
dic = dict(m=1,n=2,c=5)
print(dic)

# .clear()清除字典元素
dic.clear()  
print(dic)

# 用del语句删除整个字典
del dic  
#print(dic)  整个字典已删除，无返回值/若print直接报错

输出结果：

{'m': 1, 'c': 5, 'n': 2}
{}

• dict字典更新/合并

# 更新/合并字典
# dict.update()

dic1 = {"a":1, "b":2}
dic2 = {"c":3, "d":4}
print(dic1)
print(dic2)

dic1.update(dic2)
print(dic1,dic2)
# 把第二个字典dic2合并到第一个字典dic，改变了第一个字典
# 第二个字典不变

输出结果：

{'a': 1, 'b': 2}
{'d': 4, 'c': 3}
{'a': 1, 'b': 2, 'c': 3, 'd': 4} {'d': 4, 'c': 3}

• dict字典复制

# 复制字典
# .copy(),复制一个新字典
a = {'m':1 , 'n':2 , 'p':3}
b = a.copy()
a.update({'q':4})
print('修改后的a字典：',a)
print('b字典不受影响',b)

输出结果：

修改后的a字典： {'m': 1, 'q': 4, 'p': 3, 'n': 2}
b字典不受影响 {'m': 1, 'n': 2, 'p': 3}

• dict字典成员判断：in/not in

# 字典成员判断：in/not in
# 字典的判断是否包含，须用key作为判断对象
a = {'m':1 , 'n':2 , 'p':3}
print(a)
print('m' in a)
print(1 in a) # 这里判断1是否存在字典a中，但是1不是字典a的key，因此返回False

输出结果：

{'m': 1, 'p': 3, 'n': 2}
True
False

• dict字典的元素访问

# dict字典元素的访问

# dict字典单个元素访问——索引key访问
# 因字典没有顺序，以key来作为指向，所以指向的key必须存在
# 注意dict字典的索引与list的索引方式不同，字典是索引key
dic = {'a':1, "b":2, "c":3}
print(dic['a'])
print('--------------------------------------------')

# 嵌套字典的单个元素访问
# 对于嵌套字典，输出嵌套内容，通过重复指向来输出
poi = {'name':'shop', 'city':'shanghai', 'information':{'address':'somewhere', 'num':66663333}}
print(poi['information']['address']) 
# 索引key=information的元素，再访问这个元素key=address的元素值 → somewhere
print('--------------------------------------------')

# 用get直接访问字典单个元素
# .get(key)方法：直接查看key的value
# 如果没有相应key则返回None，添加print参数可以多返回一个值
print(poi.get('name'))
print(poi.get('information'))
print(poi.get('type',print('nothing')))
print('--------------------------------------------')

# .keys()方法，访问字典所有key
# 输出内容格式为视图，可以用list()得到key的列表，类似range()
print(poi.keys(),type(poi.keys()))
print(list(poi.keys()))
print('--------------------------------------------')

# .values()方法，访问字典所有value
# 输出内容格式为视图，可以用list()得到value的列表，类似range()
print(poi.values(),type(poi.values()))
print(list(poi.values()))
print('--------------------------------------------')

# .items()方法，访问字典所有items（元素）
# 输出内容格式为视图，可以用list()得到items的列表，类似range()
print(poi.items(),type(poi.items()))
print(list(poi.items()))

输出结果：

1
--------------------------------------------
somewhere
--------------------------------------------
shop
{'num': 66663333, 'address': 'somewhere'}
nothing
None
--------------------------------------------
dict_keys(['information', 'city', 'name']) <class 'dict_keys'>
['information', 'city', 'name']
--------------------------------------------
dict_values([{'num': 66663333, 'address': 'somewhere'}, 'shanghai', 'shop']) <class 'dict_values'>
[{'num': 66663333, 'address': 'somewhere'}, 'shanghai', 'shop']
--------------------------------------------
dict_items([('information', {'num': 66663333, 'address': 'somewhere'}), ('city', 'shanghai'), ('name', 'shop')]) <class 'dict_items'>
[('information', {'num': 66663333, 'address': 'somewhere'}), ('city', 'shanghai'), ('name', 'shop')]

• dict字典元素的遍历

# 字典的元素遍历
# 用 for ..in 语句遍历字典元素

poi = {'name':'shop', 'city':'shanghai', 'information':{'address':'somewhere', 'num':66663333}}
for key in poi.keys():  # 遍历key
    print(key)
print('-------')

for value in poi.values(): # 遍历values
    print(value)
print('-------')

for (k,v) in poi.items(): #遍历items（条目）
    print('key为 %s, value为 %s' %(k,v))

输出结果：

information
city
name
-------
{'num': 66663333, 'address': 'somewhere'}
shanghai
shop
-------
key为 information, value为 {'num': 66663333, 'address': 'somewhere'}
key为 city, value为 shanghai
key为 name, value为 shop

四、条件及循环语句

表9-条件及循环语句常用操作及描述.png

4.1条件语句if

Python条件语句是通过一条或多条语句的执行结果（True或者False）来决定执行的代码块。

• 基本判断语句 if

# 基本判断语句

age = 12
if age < 18:
    print('18岁以下不宜观看')
# if语句后面必须有 ： 
# 自动缩进
# if语句写完后，要退回原有缩进继续写
# Python代码的缩进规则：具有相同缩进的代码被视为代码块

输出结果：

18岁以下不宜观看

• 两种条件判断 if-else

# 两种条件判断:if-else

flag = False
name = 'luren'
if name == 'python':          # 判断变量否为'python'
    flag = True               # 条件成立时设置标志为真
    print( 'welcome boss')    # 并输出欢迎信息
else:
    print(name)               # 条件不成立时输出变量名称

输出结果：

luren

• 多种条件判断 if-elif-...-else

# 多种条件判断:if-elif-...-else

num = 2    
if num == 3:            # 判断num的值
    print('boss')       
elif num == 2:
    print('user')
elif num == 1:
    print('worker')
elif num < 0:           # 值小于零时输出
    print('error')
else:
    print('roadman')    # 条件均不成立时输出

输出结果：

user

• 单语句多条件判断 or与and

# 单语句多条件判断：or and

num = 5
if num >= 0 and num <= 10:    
    print( 'hello')
# 判断值是否在0~10之间
# 输出结果: hello
 
num = 10
if num < 0 or num > 10:    
    print( 'hello')
else:
    print( 'undefine')
# 判断值是否在小于0或大于10
# 输出结果: undefine
 
num = 8
if (num >= 0 and num <= 5) or (num >= 10 and num <= 15):    
    print( 'hello')
else:
    print( 'undefine')
# 判断值是否在0~5或者10~15之间
# 输出结果: undefine

输出结果：

hello
undefine
undefine

4.2循环语句

• 循环语句：for循环

for循环可以遍历任何序列的项目，如一个列表或者一个字符串。for循环再序列中迭代。

• for循环基本特征：

# 输出 hello world 5次
for i in range(5):
    print('hello world')

输出结果：

hello world
hello world
hello world
hello world
hello world

• for循环遍历序列、字典映射：

# 遍历序列
lst = list(range(10))
print(lst)
for i in lst: # 遍历整个lst
    print(i) 
print('----------------------------')
for i in lst[::2]: # 按步长为2遍历整个lst
    print(i) 
print('----------------------------')
print('----------------------------')

# 遍历字典
dic = dict(m=1,n=4,j=10)
print(dic)
for i in dic.keys(): # 遍历key
    print(i)
print('----------------------------')
for i in dic.values(): # 遍历value
    print(i)
print('----------------------------')
for (k,v) in dic.items(): # 遍历items
    print((k,v))

输出结果：

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0
1
2
3
4
5
6
7
8
9
----------------------------
0
2
4
6
8
----------------------------
----------------------------
{'m': 1, 'j': 10, 'n': 4}
m
j
n
----------------------------
1
10
4
----------------------------
('m', 1)
('j', 10)
('n', 4)

• 嵌套循环，尽量不要多于3个嵌套：

# 嵌套循环
for i in range(3):
    for j in range(4):
        print(i,j)

输出结果：

0 0
0 1
0 2
0 3
1 0
1 1
1 2
1 3
2 0
2 1
2 2
2 3

• 循环语句：while

执行语句可以是单个语句或语句块，判断条件可以是任何表达式，任何非零、或非空（null）的值均为true。当判断条件假false时，循环结束。

• 循环语句while的基本逻辑：

# 基本运行逻辑

count = 0
while count < 9:
    print( 'The count is:', count)
    count = count + 1
print( "Good bye!")
# 这里count<9是一个判断语句，当判断为True时，则继续运行

输出结果：

The count is: 0
The count is: 1
The count is: 2
The count is: 3
The count is: 4
The count is: 5
The count is: 6
The count is: 7
The count is: 8
Good bye!

• 使用while时须注意，要避免无限循环的出现：

# 关于无限循环：如果条件判断语句永远为 true，循环将会无限的执行下去

var = 1
while var == 1 :  
    num = input("Enter a number  :")
    print( "You entered: ", num)
print( "Good bye!")
# 该条件永远为true，循环将无限执行下去
# 一定要避免无限循环！！

• while-else语句，逻辑使用与if-else一样：

# while-else语句

count = 0
while count < 5:
    print(count, " is  less than 5")
    count = count + 1
else:
    print(count, " is not less than 5")
# 逻辑和 if-else 一样

输出结果：

0  is  less than 5
1  is  less than 5
2  is  less than 5
3  is  less than 5
4  is  less than 5
5  is not less than 5

• 循环控制语句

循环控制语句有：

→ break：在语句块执行过程中终止循环，并且跳出整个循环

→ continue：在语句块执行过程中跳出该次循环，执行下一次循环

→ pass：pass是空语句，是为了保持程序结构的完整性

• break语句：

# break语句

s = 0
n = 1
while n > 0:
    s = s + n
    n = n + 1
    if n == 20:
        break
print(s)
# break语句用来终止循环语句，即便循环条件没有False条件或者序列还没被完全递归完，也会停止执行循环语句。

s = 0
for i in range(10):
    for j in range(5):
        s = s + (i*j)
        print('第%i次计算' %(i+j))
    if s > 20:
        break
print('结果为%i' % s)
# 如果使用嵌套循环，break语句将停止执行最深层的循环，并开始执行下一行代码。

输出结果：

190
第0次计算
第1次计算
第2次计算
第3次计算
第4次计算
第1次计算
第2次计算
第3次计算
第4次计算
第5次计算
第2次计算
第3次计算
第4次计算
第5次计算
第6次计算
结果为30

• continue语句：

# continue语句

s = 0
for i in range(50):
    if i%2 == 0:
        s += i
    else:
        continue
    print('第%i次计算'%(i/2))
print('结果为%i' % s)
# continue 语句用来告诉Python跳过当前循环的剩余语句，然后继续进行下一轮循环。

输出结果：

第0次计算
第1次计算
第2次计算
第3次计算
第4次计算
第5次计算
第6次计算
第7次计算
第8次计算
第9次计算
第10次计算
第11次计算
第12次计算
第13次计算
第14次计算
第15次计算
第16次计算
第17次计算
第18次计算
第19次计算
第20次计算
第21次计算
第22次计算
第23次计算
第24次计算
结果为600

• pass语句：

# pass语句

for letter in 'Python':
    if letter == 'h':
        pass
        print( '当前字母 : h，但是我pass了')
    print( '当前字母 :', letter)
print( "Good bye!")
# pass是空语句，是为了保持程序结构的完整性。（不中断也不跳过）

输出结果：

当前字母 : P
当前字母 : y
当前字母 : t
当前字母 : h，但是我pass了
当前字母 : h
当前字母 : o
当前字母 : n
Good bye!

五、函数

在一些情况下，会发现自己编写函数比使用Python内置函数和安装别人开发的模块更方便有效。当一些情况需要不断重复看书写同样的代码片段，那么就应该考虑将这个代码片段转为函数。

表10-函数常用操作及描述.png

• 自定义函数

• 在pyhton中创建函数，使用def关键字：

# 定义函数

def f(x):
    if x < 5:
        print('输入值小于5')
    else:
        print('输入值大于等于5')  # 定义函数，其中x是参数（局部变量）
f(10)  # 运行函数

输出结果：

输入值大于等于5

• 函数运行后，最后需要返回一个或多个值，可以使用return关键字来返回函数结果供程序使用。

# 关于retuen
# return语句退出函数，并返回一个表达式。不带参数值的return语句返回None

def f1(x):
    y = 2**x  # 没有return
    
def f2(x):
    y = 2**x
    return y # 含有return

print(f1(2),f2(2))

输出结果：

None 4

• 默认参数与可变参数：

# 默认参数
def f(x,n = 2):
    return(x**n)
print(f(10))
print(f(10,3))
print('---------')
# n = 2,这里n的默认值为2，如果不输入则以默认值为主


# 可变参数
# 通过*来定义可变参数
def f(*x):
    print(x)
    return x
f(1)
f('a','b')
f(1,2,3,[44,33])
print(type(f('a','b')))
# 默认会把可变参数传入一个元祖

输出结果：

100
1000
---------
(1,)
('a', 'b')
(1, 2, 3, [44, 33])
('a', 'b')
<class 'tuple'>

• 输入函数 input()

input() 函数接受一个标准输入数据，返回为 string 类型。

# 输入函数 input()
# 注意：input()返回结果都为字符串，如果需要变为数字则用到int()/float()

score = input('请输入成绩：')
print('该学生成绩为：' + score)
print(type(score))

输出结果：

请输入成绩：90
该学生成绩为：90
<class 'str'>

• 局部变量及全局变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。

• 局部变量与全局变量的区别：

def f(m):
    m = '呵呵哒'  # 函数作用：把输入变量指向“呵呵哒”
    print("函数内为局部变量：%s" % m)    

a = input('请输入一个数字：')
f(a)
print("函数外为全局变量：%s" % a)
# f（m）中，m是函数的参数，f(x)是吧x的值赋予了m，但x值自己本身不受影响，所以执行函数后，是在函数局部“变化”了x
# 什么是局部变量？ → 当函数定义内声明变量的时候，它们与函数外具有相同名称的其他变量没有任何关系!
# 即变量名称对于函数来说是“局部”的。这称为变量的作用域。所有变量的作用域是它们被定义的块，从它们的名称被定义的那点开始。

输出结果：

请输入一个数字：8
函数内为局部变量：呵呵哒
函数外为全局变量：8

• 局部变量转化为全局变量：

# global语句 → 把局部变量变为全局变量

def f():
    global a
    a = '呵呵哒'  
    print("函数内转为全局变量：%s" % a)    

a = input('请输入一个数字：')
print("输入变量值：%s" % a)
f()
# 后一个f()应该是全局变量，可输出的结果是局部变量的
# 因使用了globa语句将局部变量变为全局变量

输出结果：

请输入一个数字：10
输入变量值：10
函数内转为全局变量：呵呵哒

• 匿名函数Lambda

# lambda 语句创建匿名函数

def fun(a,b,c):
    return a+b+c
print(fun(2,3,4))
# def创建自定义函数，求和

f = lambda a,b,c:a+b+c
print(f(2,3,4))
# lambda作为匿名函数，是不需要函数名的 → 需要一个函数，又不想动脑筋去想名字，这就是匿名函数
# lambda的主体是一个表达式，而不是一个代码块。
# lambda只有一行，仅仅能在lambda表达式中封装有限的逻辑进去。

输出结果：

9
9

六、模块与包

Python模块(Module)，是一个 Python文件，以.py 结尾，包含了Python对象定义和Python语句。

表11-模块和包常用操作及描述.png

• 调用模块语句

• 调用模块语句：import

# 调用模块语句：import

import numpy # 这里调用了numpy
a = numpy.random.rand(5)
print(a)

输出结果：

[ 0.28750147  0.12144201  0.03357802  0.04839461  0.04384718]

• 简化模块名：import...as...

为了方便书写，调用模块可以简化模块的名称。

# 简化模块名：import...as...
import numpy as np
a = np.random.rand(5)
print(a)
# 简化模块名

输出结果：

[ 0.2425978   0.73225087  0.73194903  0.93775474  0.61022389]

• 调用部分模块语句：from…import 语句

→ 单独导入模块的部分功能，但无法使用其他未导入模块功能

• 模块路径问题

# 模块路径问题

import pandas
print(pandas.__file__)
# 查看现有包所在路径，可以将自己创建的包存入改路径

#import sys
#sys.path.append(路径)
# 加载sys包，把新建的包所在路径添加上

• python标准模块

• random随机数

# python标准模块 —— random随机数

import random  # 调用random模块

x = random.random()
y = random.random()
print(x,y*10)
print('-----------------------')
# random.random()随机生成一个[0:1)的随机数

m = random.randint(0,10)
print(m)
print('-----------------------')
# random.randint()随机生成一个[0:10]的整数

st1 = random.choice(list(range(10)))
st2 = random.choice('abcdnehgjla')
print(st1,st2)
print('-----------------------')
# random.choice()随机获取()中的一个元素，()种必须是一个有序类型

lst = list(range(20))
sli = random.sample(lst,5)
print(sli)
print('-----------------------')
# random.sample(a,b)随机获取a中指定b长度的片段，不会改变原序列

lst = [1,3,5,7,9,11,13]
random.shuffle(lst)
print(lst)
# random.shuffle(list)将一个列表内的元素打乱

输出结果：

0.3599048616357652 1.564509077366436
-----------------------
7
-----------------------
7 l
-----------------------
[18, 16, 15, 14, 8]
-----------------------
[1, 9, 7, 11, 3, 13, 5]

• time时间模块

# python标准模块 —— time时间模块

import time  # 调用time模块

for i in range(2):
    print('hello')
    time.sleep(1)
print('-----------------------')
# time.sleep()程序休息()秒

print(time.ctime())
print(type(time.ctime()))
print('-----------------------')
# time.ctime(),将当前时间转换为一个字符串

print(time.localtime())
print(type(time.localtime()))
print('-----------------------')
# time.localtime(),将当前时间转为当前时区的struct_time
# wday 0-6表示周日到周六
# ydat 1-366 一年中的第几天
# isdst 是否为夏令时，默认为-1

print(time.strftime('%Y-%m-%d %H:%M:%S',time.localtime()))
# time.strftime(a,b)
# a为格式化字符串格式
# b为时间戳，一般用localtime()

输出结果：

hello
hello
-----------------------
Sun Nov 10 13:09:14 2019
<class 'str'>
-----------------------
time.struct_time(tm_year=2019, tm_mon=11, tm_mday=10, tm_hour=13, tm_min=9, tm_sec=14, tm_wday=6, tm_yday=314, tm_isdst=0)
<class 'time.struct_time'>
-----------------------
2019-11-10 13:09:14

七、数据读写

表12-数据读写常用操作及描述.png

• 文件对象声明及基本操作

• 路径书写格式：

# 路径书写格式
# 本地文件的界定：指向一个本地存储的文件，是一个链接或者一个映射

path1 = 'C:/Users/Hjx/Desktop/text.txt'  
# 单个反斜杠：/
path2 = 'C:\\Users\\Hjx\\Desktop\\text.txt'  
# 两个斜杠：\\（第一个\是转义符）
path3 = r'C:\Users\Hjx\Desktop\text.txt'  
# r用于防止字符转义
print(path1)
print(path2)
print(path3)

输出结果：

C:/Users/Hjx/Desktop/text.txt
C:\Users\Hjx\Desktop\text.txt
C:\Users\Hjx\Desktop\text.txt

• 读写文件语句：

# 读取文件：open语句
# open('路径', '模式', enconding = '编码' )
# 模式：r：读取文件，默认；w：写入；rw：读取+写入；a：追加
# 存储编码：'utf8';'gbk'
# .read() 读取文件内容，读取后，光标将会留在读取末尾
path2 = 'C:\\Users\\Hjx\\Desktop\\text.txt'
f = open(path2, 'r')  # 打开文件text.txt
print(type(f))
print(f)
print(f.read())
print('读取完毕')
# 因为用.read()读取文件内容后，光标留在读取末尾
# 所以现在用 f.seek(0) 来移动光标
f.seek(0)
print(f.read()) 
print('第二次读取')

# 用f.readline()按行读取
f.seek(0)
f.readline(10) # 读取一行中的前10个字符
# 利用for循环语句遍历按照行遍历文件
f.seek(0)
for line in f.readlines():
    print(line,type(line))
f.close()
# print(f.read())   # 关闭后无法读取
# 关闭文件链接  f.close()，养成一个好习惯

• os模块

OS模块属于系统模块，提供了非常丰富的方法用来处理文件和目录。

• os模块常用操作：

# os模块：系统模块 - 常用命令

import os  # 导入模块

# os.name,输出字符串指示正在使用的平台
# 如果是window 则用'nt'表示，Linux/Unix用户，它是'posix'
print(os.name)

# os.getcwd()，得到当前工作目录，即当前Python脚本工作的目录路径。
print(os.getcwd())  

# os.listdir()，返回指定目录下的所有文件和目录名。
print(os.listdir())  

#os.chdir(路径) → 切换到指定的目标路径
os.chdir('C:\\Users\\Hjx\\Desktop\\' )  

# os.remove(),删除()里的文件
os.remove('text2.txt')  

# os.path.split()，返回（）里路径的目录名和文件名
print(os.path.split('C:\\Users\\Hjx\\Desktop\\text.txt'))  

# os.path.exists(路径)
# 用来检验给出的路径是否真地存在
print(os.path.exists('C:\\Users\\Hjx\\Desktop\\heheh.txt'))
print(os.path.exists('C:\\Users\\Hjx\\Desktop\\'))
# 这里的hehe.txt文件不存，返回False，但是路径却是存在的，故返回True

*相对路径与绝对路径：

#【相对路径和绝对路径】
f=open(r'C:\Users\Yeung\Desktop\test.txt','r',encoding='utf8') # 这个是绝对路径
f.read()
f.seek(0)
f.close()

#相对路径
#os.chdir(r'E:\py') # os.chdir()切换至指定目录
#f2=open('test.txt','r',encoding='utf8') # os.chdir()已经申明指定目录，所以这里可以直接open文件名+模式+编码
#f2.read()
#f2.seek(0)
#f2.close()

• os模块下的文件读取与文件写入：

#【os模块下的文件读取】
os.chdir(r'C:\Users\Yeung\Desktop') # os.chdir()切换至指定目录
f=open('test.txt','r',encoding='utf8')
f.read(10) # 只读取前10个字符
f.readline() # 按行读取
f.seek(0)
f.readline(10) # 读取一行中的前10个字符

# 利用for循环语句遍历按照行遍历文件
f.seek(0)
for line in f.readlines():
    print(line,type(line))

print('------------------')
#【文件写入】
path=r'C:\Users\Yeung\Desktop\write.txt'
f = open(path,'w',encoding='utf8')
f.writelines('hello world')
f.close()

# 文件写入自动换行
f=open(path,'w',encoding='utf8')
lst=['a','b','c']

for i in range(len(lst)):
    lst[i]=lst[i]+'\n'
    print(lst[i])
f.writelines(lst)
f.close()

• pickle模块

→ pickle提供了一个简单的持久化功能。可以将对象以文件的形式存放在磁盘上。python的pickle模块实现了基本的数据序列和反序列化。

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

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

# pickle 模块
# 用pickle模块存储的文件不会改变数据结构

# 【将下来生成的字典存储为.pkl文件，即系序列化】
# 第一步 导入pickle模块
import pickle
# 第二步 创建一个字典
dic=dict(a=1,b=2,c=3,d=4,e=5)
print(dic)
# 第三步 打开一个.pkl文件
pic = open(r'C:\Users\Yeung\Desktop\data.pkl','wb') # 填写要存储的路径+文件名，存储模式：以二进制来存储：rb, wb, wrb, ab
# 第四步 用 pickle.dump() 将字典存储到data,pkl的文件中
pickle.dump(dic,pic) # 将字典dic存到路径pic目录下 （）中参数，第一个是写入的内容，第二是写入的格式
pic.close()

print('------------')
#【将存储的.plk文件读取出来，即系反序列化】
# 第一步 打开.plk文件
f=open(r'C:\Users\Yeung\Desktop\data.pkl','rb')
# 第二步 用pickle.load()读取.pkl文件
print(pickle.load(f))