Python复习笔记

复习 同时被 2 个专栏收录
18 篇文章 0 订阅
2 篇文章 0 订阅

1 前言

 
  CQU大一上学期自行选择模块1或2来学习专业课,其中选择模块1即学习Python,2即学习C。博主自身考虑到有C++的基础,所以选择了Python的学习,也即模块1。
  但是对于Python这门语言,自己本身并没有多大的兴趣,并且自认为之后的学习与实践中用到Python并不多(结合博主之后的学习情况,更多会用到C++、Java),因此并未多么用心去学习Python这门语言(勿喷),只是为了考试。平时上课并没有怎么学Python,只是跟随布置的作业和实验现做现学而已,但是到了期末考试,总得认真将“所学”与“所考”梳理一遍,故有了此篇博客。
  复习Python的时间跨度大概会持续三周,也就差不多12月底才会完完整整复习完。博客随时可能更新。
  1.7考前更新
  由于后来觉得太简单就没更新了,1.8考试。

2 包含

 

  • 《Python编程基础及应用》(陈波 刘慧君 主编)章节知识点(个人相关)
  • 其他一些语法、函数命令
  • 部分习题

3 复习笔记

3.1 第1章 学习准备

 
  记一句乔布斯的话(英文原句还在搜索):

 
  我觉得每个人都应该学习一门编程语言。学习编程教你如何思考,就像学习法律一样。学习法律并不一定是为了称为律师,而是教你一种思考方式。学习编程也是一样,我把计算机科学看作基础教育,每个人都应该花至少一年的时间学习编程。——Steve Jobs[1]
 
  I think everybody in this country should learn how to program a computer, should learn a computer language, because it teaches you how to think, it’s like going to law school, I don’t think anybody should be a lawyer, but I think going to law school may actually be useful coz it teaches you how to think in a certain way. In the same way the computer programming teaches you in a slightly different way how to think… And so… I view computer science as a liberal art. It should be something everybody takes in a year in their life, one of the courses they take is, you know learnining how to program.——Steve Jobs[2]
 

 
  教材推荐的IDE是V.S,但是因为博主当时安装出错最后选择了PyCharm,我个人本身也是比较喜欢JetBrains,PyCharm用起来我觉得相当舒服。
   

3.2 第2章 变量及简单的数据类型

 
  打印Python全部关键字

import keyword
print(keyword.kwlist)

 
  浮点数的存储,一般按照IEEE 754执行,其表示为:

±M×2 E
  在实际执行中,计算机用4个字节(Byte)共32个比特(bit)来存储一个单精度浮点数。其中,最高的1位(第31位)用作符号位,紧接的8位(第23~30位)是指数E,剩下的23位(第0~22位)是有效数字M。 [3]

 
  字符串都可用单引号、双引号,效果相同。配合使用可体现在字符串内部。
 
  常用的转义字符

转义字符作用
\续行符
\’单引号
\’’双引号
\b退格(backspace)
\n换行(new line)
\v纵向制表符
\t横线制表符
\f换页

 
  大小写转换函数:

my_str="Test"
print(my_str.upper())
print(my_str.lower())
>>> TEST
>>> test

 
  去除空格函数:

函数作用
tstrip()去除字符串右端空格,保留其内部的空格,并返回新的字符串对象
lstrip()去除字符串左端空格,保留其内部的空格,并返回新的字符串对象
strip()去除字符串两端空格,保留其内部的空格,并返回新的字符串对象

 
  类型转换

# int(x) 将x转换为一个整数
# int(x[, base]) 将x转换为一个整数,base为进制,默认十进制
# long(x[, base] ) 将x转换为一个长整数,含义同上
# float(x) 将x转换到一个浮点数
# complex(real[, imag])  创建一个复数
# str(x) 将对象 x 转换为字符串
# repr(x) 将对象 x 转换为表达式字符串
# eval(str)  用来计算在字符串中的有效Python表达式, 并返回一个对象
# list(s) 将序列 s 转换为一个列表
# set(s) 转换为可变集合
# dict(d) 创建一个字典。d 必须是一个序列(key, value) 元组。
# chr(x) 将ASCII码转化为对应字符
# ord(x) 将字符转换为对于ASCII码
# unichr(x) 将一个整数转换为Unicode字符
# hex(x) 将一个整数转换为一个十六进制字符串
# oct(x)  将一个整数转换为一个八进制字符串

3.3 第3章 语法初步

 
  x**y表示求幂,求 x y x^y xy,**运算符的优先级高于乘除
  
  获取当前时间
  法一:

import time 
curTime=time.time()#获取当前时间,从1970年1曰1日零时起经过的秒数,类型为float

 
  法二

import datetime
curTime=datetime.datetime.now()
print(curtime.year,'-',curtime.month,'-',curtime.day)
print(curtime.hour,':',curtime.minute,':',curtime.second)

 
  内置数学函数

函数作用
abs(x)、fabs(x)绝对值
sqrt(x)平方根
ceil(x)上取整
floor(x)下取整
cmp(x, y)比较函数:如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
exp(x) e x e^x ex
log(x0) ln ⁡ x \ln x lnx
log10(x) lg ⁡ x \lg x lgx
max(x)、min(x)取大、取小函数
modf(x)返回x的整数部分与小数部分,两部分的数值符号与x相同,整数部分以浮点型表示。
pow(x,y) x y x^y xy
round(x [,n])返回浮点数x的四舍五入值,如给出n值,则代表舍入到小数点后的位数。
cos(x)余弦值
sin(x)正弦值
tan(x)正切值
acos(x)反余弦
asin(x)反正弦
atan(x)反正切
degrees(x)将弧度转换为角度
radians(x)将角度转换为弧度
e自然底数
pi圆周率

 
  占位符及其说明

占位符说明
%c输出单个字符
%s输出字符串、整数、小数
%d输出整数、小数(如果输出小数直接抹去小数部分仅保留整数)
%f输出小数、整数(如果输出整数默认保留6位小数)
%.nf输出保留了n位的小数
%xd先输出x个空格,再输出对应的数值
%x将数字以十六进制表示

 
  进制
0x表示十六进制
0b表示二进制
hex()函数用于将数字转换成十六进制的字符串
bin()函数用于将数字转换成二进制的字符串

3.4 第4章 列表

3.4.1 列表元素的访问

 
  len()函数可以获取列表中的元素个数。
  lst[-1]表示列表倒数第一个元素,list[-2]表示列表导数第二个元素,以此类推,那么第一个元素就有以下两种表示方式:

lst[0]
lst[-len(lst)]

3.4.2 列表元素的插入

 
  append()函数用于向列表尾部添加元素。
  insert()函数用于在列表的指定位置插入元素,如:

lst.insert(4,'newnum')
#表示在下标4的后面插入元素'newnum'

3.4.3 列表元素的删除

操作说明
del语句删除特定位置的元素,如del lst[2]表示删除lst列表里下标为2的元素
pop(x)函数删除列表中下标为x的元素,并返回该值,若没有x,表示删除最后一个值并返回
remove(val)函数删除列表中从左到右第一个值为val的元素

举例:

lst_1=[1,2,3,4,1]
del lst_1[2]
print(lst_1)

lst_2=[1,2,3,4,1]
print(lst_2.pop())
print(lst_2)

lst_3=[1,2,3,4,1]
lst_3.remove(1)
print(lst_3)

#输出:
[1, 2, 4, 1]
1
[1, 2, 3, 4]
[2, 3, 4, 1]

3.4.4 列表的嵌套

 
  创建n×m空列表如下两种方法:
  方法一:用循环嵌套

lst=[[0 for i in range()] for j in range ()]

 
  方法二:用numpy包里的函数
  注意,要先下载包numpy,下载方法参见4.2 安装包

lst=numpy.zeros((n,m))

3.4.5 列表复制传址而非传参

 
  当我们将一个列表lst_1直接复制到lst_2时,实际上并不是将前一个列表复制了一份给后一个列表,而是让后一个列表与前一个列表有了相同的存储地址。这就意味着,当我们修改后一个列表(或前一个列表)的某一个元素时,前一个列表(或后一个列表)对应的元素也做了相同的修改。
  函数的参数传递也是一样的道理。

3.4.6 列表元素的排序与倒序

函数说明
sort()将列表内的元素按照Unicode码逐一比较非递减排序
sort(reverse=True)将列表内的元素按照Unicode码逐一比较非递增排序
sort(key=DEF)将列表内的元素按照函数DEF生成的键值进行大小排序
sorted()将列表排序后返回一个新列表,而不改变原列表
reverse()将列表元素顺序颠倒

3.4.7 列表运算、查找与切片

3.4.7.1 列表运算

列表+列表=两个列表的拼接
列表*n:表示生成一个新列表,其中原列表元素重复n次

3.4.7.2 列表查找

a in b

如果元素a在序列b中,那么返回True,否则返回False

>>> print('Hello' in 'HelloWorld')
>>> True
a not in b

如果元素a不在序列b中,那么返回True,否则返回False
注意:此处的序列包含字符串与列表

>>> lst=[1,4,9,16,25]
>>> print(24 not in lst)
>>> True

3.4.7.3 列表切片

 
  列表切片完整格式:lst[x:y:z],x为起始下标,y为终止下标(注意,终止下标对应的元素并不包含在切片中),z为步长。切片按照以下步骤进行:
  1.将给定的负数x,y转化为正数下标。如将-1转化为len(lst)-1,-2转化为len(lst)-2
  2.为缺省参数赋默认值
  (1)当z缺省时z=1
  (2)当z>0时,切片从前往后。若x缺省,则x=0,若y缺省,则y=len(lst)
  (3)当z<0时,切片从后往前。若x缺省,则x=len(lst)-1,若y缺省,则y=-1
  3.按照转换后的切片格式进行切片返回值
  字符串切片与列表切片相同

3.4.8 列表函数

函数说明
range(x)生成区间[0,x)内的整数列表
range(x,y)生成区间[x,y)内的整数列表
range(x,y,z)生成区间[x,y)内的整数列表,其中相邻元素间隔为z
max()求数值列表的最大值
min()求数值列表的最小值
sum()求数值列表的元素和
count(x)对元素x计数
clear()请空列表
extend(seq)在当前列表的末尾拼接列表seq
index(x,y,z)在列表下标[y,z]内查找元素x,如果有,返回第一个元素x下标,如果没有元素x,则显示异常,如果没有y,z,则在整个列表内查找元素x
copy()列表的复制,此处就是传值而不是传址了

3.5 第5章 数据类型及名字绑定

3.5.1 元组tuple

 
  元组的定义只需要在括号()中添加元素,并用逗号隔开即可。(注意:如果只有一个元素,我们需要在该元素的后面加一个逗号。如(4,),这样做是为了将由括号括起来的整数4作区分)
  元组是只读的列表,因此列表里的许多函数元组都可以类似使用,但是涉及修改的操作就不可以使用。
  其他数据类型如列表、字符串,或者生成者对象可以通过tuple()函数强制转换为元组:

lst=[1,2,3]
str="123"
print(tuple(lst))
print(tuple(str))
>>> (1, 2, 3)
>>> ('1', '2', '3')

 
  由这个例子我们可以发现,当把字符串强制转换为元组时,字符串的每个字符单独成为了元组中的一个元素。

3.5.2 集合set

3.5.2.1 集合的创建(博主有疑问,待办)

 
  集合的特点:①互异性②无序性③元素可哈希
  元素可哈希即哈希算法必须知道如何把元素的值转换成一个散列分布的整数。列表、集合、字典不是可哈希类型,整数、浮点数、字符串、元组和布尔值等是可哈希类型。(疑问?元组为什么是可哈希类型)
  非空集合可用大括号{}和函数set()实现。但是注意,函数set()创建集合时应放置一个字符串或者列表,集合会将字符串的单个字符、列表本来的元素当作集合的一个元素
  空集合只能用函数set()实现,格式为:set([])。不能用{}的原因是默认这是字典的创建方式。
  集合转换为列表可以通过list()函数实现,生成的列表的每个元素对应了集合的每个元素。

3.5.2.2 集合运算与函数

 

  • 集合的运算

 
  数学定义:如果集合s2的每个元素都是集合s1的元素,那么称集合s2是集合s1的子集、集合s1是集合s2的超集。

 
  子集超集、交集、并集、差集、补集的运算

运算说明
s1.issubset(s2)判断s2是不是s1的子集
s1.issuperset(s2)判断s2是不是s1的超集
s1&s2求s1和s2的交集
s1.intersection(s2)求s1和s2的交集
s1|s2求s1和s2的并集
s1.union(s2)求s1和s2的并集
s1-s2求s1和s2的差集
s1.difference(s2)求s1和s2的差集
s1^s2求s2在s1的补集
s1.symmetric_difference(s2)求s2在s1的补集
s1==s2判断集合相等(只需要判断元素是否相同)

 

  • 集合的函数
函数说明
add(x)加入元素x
remove(x)移除值为x的元素,如果不存在则报错
len()求集合元素个数
max()求数值集合的最大值
min()求数值集合的最小值
sum()求数值集合的和
in/not in判断元素存在与否
pop()删除任意一个元素,如果是空集合则报错
for x in myset无序枚举集合的每一个元素

3.5.3 bytes与bytearray

 
  由于博主觉得这两个数据类型有很大的学习价值,因此决定脱离于教材学习这两个数据类型以加深理解熟练运用。学习完之后会另开一个博文来介绍这两个数据类型
  博主认为这两个数据类型,在期末的应试考试中绝非重点,建议直接阅读教材。
  在工业应用中,比如用Python语言编写工业机器人的控制程序时,我们经常需要与硬件直接通信。在数字电路中,数据永远是以二进制形式存储和传输的,当我们与硬件或其他计算机通信时,常常需要将其他类型的数据转换成明确的二进制形式,这种转换可以用bytes来实现,bytes表示只读的“字符串”类型。[4]
  ……

3.5.4 位运算

  • and运算(与运算)
    二进制位都为1则为1,否则为0。
    如:5&28,即(00101)2&(11100)2
    按照与运算法则得到结果的二进制:(00100)2,十进制对应的数即为4
  • or运算(或运算)
    二进制位有1则1,否则为0。
    如:5|28,即(00101)2|(11100)2
    按照或运算法则得到结果的二进制:(11101)2,十进制对应的数即为29
  • xor运算(异或运算)
    二进制位不同为1,相同为0
    如:5^28,即(00101)2^(11100)2
    按照或运算法则得到结果的二进制:(11001)2,十进制对应的数即为25
  • not运算(取反)
    取反即将二进制位的0和1全部取反。使用取反运算时要格外小心,你需要注意整数类型有没有符号。如果取反的对象是无符号整数(不能表示负数),那么得到的值就是它与该类型上界的差,因为无符号类型的数是用00到$FFFF依次表示的。
  • 右移
    将二进制位整体右移x位,左边用0补上,右边溢出则舍去。
    如25>>2,即(11001)2>>2
    按照右移法则得到结果的二进制:(00110)2,十进制对应的数即为6
  • 左移
    将二进制位整体左移x位,右边用0补上,左边溢出则舍去。
    如25<<2,即(11001)2<<2
    按照右移法则得到结果的二进制:(1100100)2,十进制对应的数即为100
    小性质:将十进制数 x x x左移 y y y位后的十进制为: x × 2 y x×2^y x×2y,右移 y y y位后的十进制为: x 2 y \frac{x}{2^y} 2yx,取整数

3.5.5 序列

 
  列表、字符串、元组、bytes、bytearray都可视作序列类型,它们有如下共同点[6]

  1. 可以通过下标或者索引访问其元素(只读类型只可获取,不得修改)。
  2. 可以通过切片操作获取其子序列。

3.5.6 名字绑定

3.5.6.1 名字绑定

 
  id(x)函数作用:查看变量x在内存中的地址(可以这样理解)。
  
  对于“赋值”语句a=1,我们一直的理解是对于变量a,我们让这个变量x具有一个值,这个值为1。但是在这个小节里,我们将打破这种理解。
  事实上,a这个变量的“a”只是一个“名字”,值1是一个“对象”,语句a=1,其实并不代表将变量a赋值为1,而是将a这个变量的“名字”,与值为1的这个“对象”绑定在了一起,让他们在内存中有了相同的地址。而如果再使用语句a=2,我们就是让a这个名字与值为2的对象绑定在了一起,而不再与值为1的对象绑定在一起。
  当一个对象没有名字与之绑定时,此时该对象的引用计数值为0,Python解释器会在恰当的时候从内存中销毁这个对象,这个机制称为“垃圾回收”。(即Java中的gc,garbage collection)。
  b=a、a=a+1等的理解类似。
  需要注意的是,Python解释器考虑到执行速度的优化,而倾向于将名字尽可能绑定在系统已有的对象上,而不是创建新对象,如下例:

a=3
b=int((a**2)/3)
print(a,b)
print(id(a),id(b))
>>> 3 3
>>> 3031791987056 3031791987056#不同机器或内存得到的id值很可能不相同

3.5.6.2 is和==

 
  a == b比较a和b两个数的值是否相同。
  a is b是比较a和b是否完全相同,而两个变量完全相同就是判断两个变量是否在内存中指向同一地址,因此a is b是比较a和b的地址是否相同。如下例:

a=3
b=(a**2)/3
print(a==b)
print(a is b)
print(id(a),id(b))
>>> True
>>> False
>>> 2033327630704 2033328260592

3.5.6.3 只读数据类型与可修改数据类型

已讨论过的数据类型

--
只读数据类型int,float,str,bool,bytes,tuple
可修改数据类型list,bytearray,set
  • 只读数据类型
      对于只读数据类型,忽略名字绑定这回事,与我们的正常使用完全一致。
  • 可修改数据类型
      举例大家参考教材P73-P74,我在此处介绍一下copy()和deepcopy()的区别。
      我们先来看两端代码:
import copy
lst=[1,2,3,4,5]
lst_1=copy.copy(lst)
lst_2=copy.deepcopy(lst)
lst_2[0]=6
print("新列表:",lst_2,"原列表:",lst)
lst_1[0]=6
print("新列表:",lst_1,"原列表:",lst)
>>> 新列表: [6, 2, 3, 4, 5] 原列表: [1, 2, 3, 4, 5]
>>> 新列表: [6, 2, 3, 4, 5] 原列表: [1, 2, 3, 4, 5]

 
  从第一段代码中,我们看到,copy()函数与deepcopy()函数没有区别,得到的新的可修改数据变量(这里就是列表)与原来的可修改数据变量相同下标下的元素对应的内存不一样。也就是说,我们修改新的列表元素,原列表的对应元素并不发生改变。

import copy
lst=[1,2,3,4,[1,2,3,4]]
lst_1=copy.copy(lst)
lst_2=copy.deepcopy(lst)
lst_2[0]=6
print("新列表:",lst_2,"原列表:",lst)
lst_1[0]=6
print("新列表:",lst_1,"原列表:",lst)
lst_2[4][0]=6
print("新列表:",lst_2,"原列表:",lst)
lst_1[4][0]=6
print("新列表:",lst_1,"原列表:",lst)
>>> 新列表: [6, 2, 3, 4, [1, 2, 3, 4]] 原列表: [1, 2, 3, 4, [1, 2, 3, 4]]
>>> 新列表: [6, 2, 3, 4, [1, 2, 3, 4]] 原列表: [1, 2, 3, 4, [1, 2, 3, 4]]
>>> 新列表: [6, 2, 3, 4, [6, 2, 3, 4]] 原列表: [1, 2, 3, 4, [1, 2, 3, 4]]
>>> 新列表: [6, 2, 3, 4, [6, 2, 3, 4]] 原列表: [1, 2, 3, 4, [6, 2, 3, 4]]

 
  从这一段代码中,我们发现,修改通过deepcopy()得到的新列表中的非列表元素,原列表中的元素无论怎样都不改变;而修改通过copy()得到的新列表中的嵌套内的元素,原列表中的元素要对应发生改变。
  事实上,copy()复制了列表本身,当出现嵌套时,对应元素依然可能绑定在相同对象上,而deepcopy()就可以避免这个问题。
  
  注意:尽管我们知晓了“赋值”的真相是名字绑定,但是出于习惯,我们仍然使用变量、赋值术语。

3.6 第6章 条件、循环及其他

3.6.1 序列解包

 
  简单的序列解包此处不再多言。
  下面我们介绍,用更少个数变量解包更多元素序列。
  此处我们引入*记号,我们通过以下例子来了解*的作用:

lst=[1,2,3,4,5]
a,*b,c=lst
print(a,b,c)
*a,b,c=lst
print(a,b,c)
a,b,*c=lst
print(a,b,c)
>>> 1 [2, 3, 4] 5
>>> [1, 2, 3] 4 5
>>> 1 2 [3, 4, 5]

 
  我们发现,带有*号的变量,总是对应了多个元素值。
  当带有*号的变量处于开头时,后面的变量以此对应了序列最后对应元素,剩下的元素打包给了最前面的带有*号的变量。
  当带有*号的变量处于中间时,两端的变量对应了序列两端的对应元素,剩下的元素打包给了中间的带有*号的变量。
  当带有*号的变量处于末位时,与前面类似。

3.6.2 “非空即真”的小测试

 
  我们都理解if语句以及for、while中的判断语句,我们知道程序按照非0则1(非False则True)的方式进行判断,这很常见。
  但是教材上的一个小例子倒是让我耳目一新:

input("get sth. or ...") or print("nothing")

 
  input()让我们输入,而一旦我们输入,则表明我们认为了input这个语句是True的,那就不会执行后面的print;而一旦在让我们输入的时候,我们选择了回车——也就是不输入——这个时候情况就不一样了,我们不输入,相当于否定了input这个语句,那么根据“非空即真”的原则,就会执行后面的print语句。
  现在想这个事实倒是觉得容易理解,但是“非空即真”原则在此处的一个小应用与之前出现在if、for里面的很不一样。

3.6.3 禅与断言

 
  assert expression语句
  如果expression为真,继续执行下一语句;如果expression为假,系统报错。
  
  执行代码,得到:

import this
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

3.6.4 序列缝合与循环解包

 
  zip()函数可以将多个序列“缝合”起来(注意“缝合”二字打引号,这并不是序列的“拼接”),并返回一个由元组构成的序列。zip)函数的返回值是一个可迭代对象,可以强制转换为列表查看元素,如:

list1=[1,2,3,4,5]
list2=['a','b','c','d','e']
zipped=zip(list1,list2)
print(zipped)
print(list(zipped))
>>> <zip object at 0x00000203B7638740>
>>> [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e')]

 
  序列缝合后,我们可以通过循环的方式进行解包:

list1=[1,2,3,4,5]
list2=['a','b','c','d','e']
list3=['A','B','C','D','E']
zipped=zip(list1,list2,list3)
for  x,*y in zipped:
    print("x:",x,"y:",*y)
>>> x: 1 y: a A
>>> x: 2 y: b B
>>> x: 3 y: c C
>>> x: 4 y: d D
>>> x: 5 y: e E

3.7 第7章 字典(12.18更新)

3.7.1 字典的创建

 
  类似于映射的关系,我们把一个键值对的具有“索引”作用的值称为“”,与整个“索引”相关的对象称为“”,一个键加上对应值称为键值对,也称为。(可以按照C++的map理解)
  注意到,由于键值对并不存在先后顺序这个概念,因此在字典中,我们并不能根据下标进行索引,字典不属于序列类型。
  可以通过以下几种方法定义字典(字典的嵌套与列表类似):

dic_1={}#创建空字典
print(dic_1)
dic_2={'a':3,3:'4',18:6}#创建含有键值对的字典
print(dic_2)
dic_2[6]=18#在已有字典中加入新的键值对
print(dic_2)
lst=[('a','b'),(1,2)]
dic_3=dict(lst)#将由元组键值对构成的元组或列表转换为字典
print(dic_3)
dic_4=dict(a='A',b='B')#dict()函数生成字典
print(dic_4)
>>> {}
>>> {'a': 3, 3: '4', 18: 6}
>>> {'a': 3, 3: '4', 18: 6, 6: 18}
>>> {'a': 'b', 1: 2}
>>> {'a': 'A', 'b': 'B'}

3.7.2 字典的成员函数

成员函数作用
len(dic)返回字典的键值对个数
del dic[name]删除字典中键为name的键值对
clear()清空字典
copy(),deepcopy()复制,与列表相同
fromkeys(seq,val)将序列seq的各个元素作为间,val作为默认值,生成字典
get(key,r)字典内查找键为key的键值对,如果查找到返回对应值,否则返回r,如果调用函数时省略了r这个参数,返回字符串"N/A"
pop(key)删除指定键的键值对,并返回该键值对的值
popitem()随机删除字典内的一个键值对
dic_1.update(dic_2)更新字典,将dic_2包含有dic_1没有的键值的键值对放到dic_1中,两者皆有的键值对的值更新为dic_2中的值

3.7.3 字典的遍历

 
  参看以下代码:

dic={'a':'A','b':"B",'c':'C','d':'D'}
lst_1=[]
for x in dic:#直接枚举实际上是枚举的字典的键
    lst_1.append(x)
print(lst_1)
lst_2=[]
for x in dic.keys():#指定枚举字典的键
    lst_2.append(x)
print(lst_2)
lst_3=[]
for x in dic.values():#指定枚举字典的值
    lst_3.append(x)
print(lst_3)
lst_keys=[]
lsy_values=[]
for x,y in dic.items():#items函数使得字典能够通过序列解包的方式调出键值对的键与值
    lst_keys.append(x),lsy_values.append(y)
print(lst_keys,lsy_values)
>>> ['a', 'b', 'c', 'd']
>>> ['a', 'b', 'c', 'd']
>>> ['A', 'B', 'C', 'D']
>>> ['a', 'b', 'c', 'd'] ['A', 'B', 'C', 'D']

3.8 第8章 函数与抽象(12.19待更)

4 其他

4.1 turtle画图

 
绘制图像,随机向右向上,到达终点

import math
import turtle
import random

#规定相邻坐标间距为5

def draw_xy():#绘制x,y坐标轴
    Pi=math.pi
    turtle.screensize(1000,1000)
    turtle.speed(4)
    turtle.forward(400)
    turtle.left(180)
    turtle.forward(800)
    turtle.left(180)
    turtle.forward(400)
    turtle.left(90)
    turtle.forward(400)
    turtle.left(180)
    turtle.forward(800)
    turtle.left(180)
    turtle.forward(400)

def draw_point(n,m):#描绘起点(0,0),终点(n,m),并使画布最终停留在起点
    turtle.up()
    turtle.goto(0,0)
    turtle.down()
    turtle.dot(20,'red')

    turtle.up()
    turtle.forward(5*m)
    turtle.right(90)
    turtle.forward(5*n)
    turtle.dot(20,'blue')

    turtle.right(90)
    turtle.forward(5*m)
    turtle.right(90)
    turtle.forward(5*n)
    turtle.right(180)
    turtle.down()

f=0#f表示是否到达了终点

def draw_route(x,y,n,m,d):#x,y表示当前在坐标(x,y),d表示当前乌龟朝向(0右1上)
    global f
    if(f==1):
        return
    if(x==n and y==m):
        f=1
        return
    if(x==n or y==m):
        turtle.goto(5*n,5*m)
        draw_route(n,m,n,m,d)
    dir=random.randint(0,1)#随机生成0或1,0右1上
    if(dir==0):
        if(dir==d):
            turtle.forward(5)
            draw_route(x+1,y,n,m,d)
        else:
            turtle.right(90)
            turtle.forward(5)
            draw_route(x+1,y,n,m,0)
    else:
        if(dir==d):
            turtle.forward(5)
            draw_route(x,y+1,n,m,d)
        else:
            turtle.left(90)
            turtle.forward(5)
            draw_route(x,y+1,n,m,1)

n=int(input("请输入终点横坐标:"))
m=int(input("请输入终点纵坐标:"))
draw_xy()
draw_point(n,m)
turtle.pencolor('purple')
draw_route(0,0,n,m,0)
turtle.done()#停留画布

4.2 安装包

 
  按键win+R,输入cmd,然后回车:
  在这里插入图片描述
在这里插入图片描述
   输入pip install 安装包的名字,如安装包numpy:
在这里插入图片描述
 
  下载好之后,会显示Successfully installed 安装包-版本
在这里插入图片描述
 
  接下来我们来查看安装包的列表看看我们是否真的安装好了我们要安装的包,输入pip list:
  在这里插入图片描述
  我们在list列表里面看到了我们要安装的包,说明是真的安装成功了。

4.3 eval函数与exec函数

 
  eval()作用:执行一个字符串表达式,并返回表达式的值。
  如:

x=6 
y="x^^2"
eval(y)
>>> 36

 
  语法上:调用形式为eval(expression,globals=None, locals=None)
  我们参看一下eval()的源代码怎么解释:
在这里插入图片描述
 
  于是我们了解到:
  expression – 表达式。
  globals – 变量作用域,全局命名空间,如果被提供,则必须是一个字典对象。
  locals – 变量作用域,局部命名空间,如果被提供,可以是任何映射对象。[5]
  
  当eval()计算要调用参数值时,有以下查找顺序

  1. 当前函数或类方法。如果当前函数或类方法定义了一个名为x的局部变量或参数,eval()计算将调用它,然后停止搜索。
  2. 当前模块。如果模块定义了一个名为x的变量,函数或类,eval()计算将调用它,然后停止搜索。
  3. 内置名字空间。eval()计算将假设x是内置函数或变量进行搜索。

4.4 format函数详解

单开了一个博文写format:点这里

4.5 split函数详解(待更)

5 习题

5.1 设计计数集合类,记录各元素加入集合的次数(高教社,《Python编程基础及应用》习题9-9)

在这里插入图片描述
题目大意:通过继承重载重写实现对set元素的计数。
 
  首先考虑到原set添加元素的函数add()会“自动”分别待添加元素与set内元素是否重合,如果重合就不添加,不重合就添加。所以我们就可以从add()函数做文章。
  由于我们重写函数后,CountedSet依然具有set()添加元素的功能,并且我们并不确定在重写add()函数后,原来的存储(不重复)是否仍然存在,因此我们在重写add()时选择使用super().add()。
  在保留了原set的功能后,现在我们就只需要人为实现对元素内计数即可。
参考代码:

class CountedSet(set):
    s=[]
    cnt=[]
    def add(self,v):
        super().add(v)
        if(v in self.s):
            ind=self.s.index(v)
            self.cnt[ind]+=1
        else:
            self.s.append(v)
            self.cnt.append(1)
    def getCount(self,v):
        if(v in self.s):
            ind=self.s.index(v)
            return self.cnt[ind]
        else:
            return 0

6 引用与参考资料

[1] 《Python编程基础及应用》P1
[2] 乔布斯:遗失的访谈(1995)
[3] 《Python编程基础及应用》P10
[4] 《Python编程基础及应用》P65
[5] 菜鸟教程. Python eval()函数. https://www.runoob.com/python/python-func-eval.html
[6] 《Python编程基础及应用》P68

  • 1
    点赞
  • 0
    评论
  • 3
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

相关推荐
©️2020 CSDN 皮肤主题: 游动-白 设计师:白松林 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值