Python基础知识总结期末复习精简版.docx

Python基础知识总结期末复习精简版.docx

《Python基础知识总结期末复习精简版.docx》由会员分享，可在线阅读，更多相关《Python基础知识总结期末复习精简版.docx（28页珍藏版）》请在冰豆网上搜索。

Python基础知识总结期末复习精简版

Python基础知识总结（期末复习精简版）

前言

本文针对《Python语言程序设计基础（第2版）》——嵩天礼欣黄天羽，此书进行简单知识总结。

本文总结了华农python期末部分常见考点，对信息学院的同学帮助不大，适合其他学院同学参考。

本人只是单纯的想进行分享，并没有炫耀自己的意思，如果让您心情不悦我感到很抱歉。

本文可能对编程编写有所帮助，但是理论知识还需要大家多刷题，多看定义。

因本人精力、能力有限，文章不足之处还请指正。

此外，大家可以将需求、遗漏的地方或疑问写在评论区，后期会及时进行补充，解答疑问。

码字不易，大家如果本文感觉有帮助的话，不胜感激！

复习要点

-缩进、注释、命名、变量、保留字

-数据类型、字符串、整数、浮点数、列表、字典

-赋值语句、分支语句、函数

-input（）、print（）、eval（）、print（）及其格式化

组合数据类型

注：

详细内容请看后面几段

序列类型通用操作符和函数

注：

序列类型是可迭代对象，可以直接使用for循环操作。

a=[1,2,3,4,5]

foriina:

print（i,end='**'）#end是可选参数，不写默认为换行符'\n'

#得到1**2**3**4**5**

集合类型

类似数学上的集合概念元素具有单一性，集合并没有自动升序排列的性质，可能是元素少的时候碰巧，可以使用sorted（）函数来排序哦!

（集合是具有确定性、互异性、无序性的，不要混淆了）

常用于：

去除列表中的相同元素

list1=[5,1,3,7,9,9,2]

list1=list（set（list1））

print（list1）#得到[1,2,3,5,7,9]

#大家看呀，这个自动升序了，但仅仅是碰巧。

print（set（[1,3,8,-2,99,98,77,1,5,3,77,12]））#得到{1,98,3,99,5,8,12,77,-2}

#大家看这个，就不会自动给你升序了，一定要注意，集合并没有自动升序排列的性质

映射类型

需要了解：

①怎样增删键值对

②怎样得到字典中键，值，键值对应的元组

③一个键只能对应一个值

注：

键（key）就是冒号左侧的值。

值（value）就是冒号右面的数值。

数值操作

运算符

字符串操作

字符串切片

基本切片操作

格式：

<需要处理的字符串>[M:

N]。

M缺失表示至开头，N缺失表示至结尾。

注意：

①两种索引方式可以混用；②切片得到的结果不包含N索引的值。

a='〇一二三四五六七八九'

print（a[1:

3]）#得到一二

print（a[1:

-1]）#得到一二三四五六七八

print（a[-3:

-1]）#得到七八

print（a[:

3]）#得到〇一二

print（a[4:

]）#得到四五六七八九

高级切片操作

格式：

<需要处理的字符串>[M:

N:

K]。

根据步长K对字符串切片。

不写K时默认为1，与[M:

N]等价。

a='〇一二三四五六七八九'

print（a[1:

8:

2]）#得到一三五七

#分析过程：

在一~七中，索引从1开始，依次加2，即a[1]，a[3]，a[5]，a[7]，将其拼接在一起得到一三五七

'''—————————————————————————————————美丽的分隔线——————————————————————————————————————'''

print（a[:

:

-1]）#得到九八七六五四三二一〇

#得到逆序字符串，格式固定。

可简单理解为从右至左操作选定的字符串片段[M:

N]。

'''—————————————————————————————————美丽的分隔线——————————————————————————————————————'''

操作、相关函数、相关使用方法

a=1.666

print（'{0:

-^20.1f}'.format（a））#得到--------1.7---------

0表示索引

:

是引导符号

-是填充字符

^表示居中

20是输出总长度

.1表示保留一位小数

%格式化

a=1.555

print（'%10.2f'%a）#得到1.55

%表示引导符号

10表示宽度

.2表示保留两位小数

f表示转为浮点型

列表

一些要注意的地方

列表中可以存放任意数据类型，但是不建议将其它数据类型强转为列表，而应该使用ls.append（）的方法

print（list（'我爱阿龙'））#得到['我','爱','阿','龙']

ls=[]

ls.append（'我爱阿龙'）

print（ls）#得到['我爱阿龙']

将列表排序和反转，实际上是调用了sort（）方法和reverse（）方法，它是没有返回值的，如果输入会得到None。

a=[1,3,2,6]

print（a.sort（））#得到None

a.sort（）

print（a）#得到[1,2,3,6]

#reverse同理

列表推导式：

（有能力就掌握一下）

ls=[iforiinrange（11）]#得到[0,1,2,3,4,5,6,7,8,9,10]

ls=[iforiinrange（11）ifi%5==0]#得到[5,10]

ls=[（i,j）foriinrange（3）forjinrange（11,13）]

#得到[（0,11）,（0,12）,（1,11）,（1,12）,（2,11）,（2,12）]

字典

dict1={'张瑞龙':

'帅','刘浩':

'丑'}

如上所示，冒号左边的为键，冒号右边的是键所对应的值。

例如，张瑞龙对应的是帅，刘浩对应丑。

注意：

①键的存在是单一的，即一个字典一个键只能出现一次。

②键和值的类型可以是任意类型，但通常为字符型

③在字典中添加元素时，键与值出现是成对出现的。

一些要注意的地方

字典作为可迭代对象，其实是它的键值

dict1={'张瑞龙':

'帅','刘浩':

'丑'}

foriindict1:

print（i）

#得到：

张瑞龙，刘浩

统计出现次数并从大到小输出

可以说是最经典的一种考题了，下面分块操作。

①统计出现次数

法一

list1=[1,1,1,2,5,3,3,10,5,6,8,9,9,11]

dict1={}#创建一个空字典

foriinlist1:

dict1[i]=dict1.get（i,0）+1#dict1.get（i,0）表示如果有键为i则返回对应的值，否则返回0

print（dict1）

法二

list1=[1,1,1,2,5,3,3,10,5,6,8,9,9,11]

dict1={}#创建一个空字典

foriinlist1:

ifiindict1:

#如果字典中有键为i

dict1[i]+=1#对应的值加一

else:

#如果字典中没有键为i

dict1[i]=1#创建键值对，值为1，因为这是第一次出现

print（dict1）

②lambda表达式排序

mylist=list（dict1.items（））

mylist.sort（key=lambdax:

（-x[1],x[0]））

#当写成mylist.sort（key=lambdax:

（x[1],x[0]））是根据值从小到大排序

#当写成mylist.sort（）是根据键从小到大排序

print（mylist）#在此处可以直接根据需求进行其他操作，而不一定要转为字典

dict1=dict（mylist）#将列表转为字典

print（dict1）

mylist.sort（key=lambdax:

（-x[1],x[0]）），这里为什么要加一个负号呢？

因为sort函数是从小到大排序的，当最大的正数加了负号就会变成最小的负数，可以使用这个特性来达到我们的需求

其实，sort里面有个可选参数reverse，默认为Forse，可以尝试一下在sort里面添加参数reverse=True看看效果。

当你写成mylist.sort（key=lambdax:

（x[1],x[0]）,reverse=True）这样也能达到根据次数从大到小输出的。

因为介绍起来很繁琐，大家记住这个格式就好了，有问题建议直接连麦滴滴我，Q3181314768。

③综上,代码汇总

list1=[1,1,1,2,5,3,3,10,5,6,8,9,9,11]

dict1={}#创建一个空字典

foriinlist1:

dict1[i]=dict1.get（i,0）+1#dict1.get（i,0）表示如果有键为i则返回对应的值，否则返回0

mylist=list（dict1.items（））

mylist.sort（key=lambdax:

（-x[1],x[0]））

dict1=dict（mylist）#将列表转为字典

print（dict1）

元组、集合

不是重点，但是需要简单了解。

元组：

可以被列表所代替，操作与列表操作相似，唯一不同的是元组不能修改，即不能增删元素，但可以使用切片和加法进行更新。

集合：

常用于清除相同元素，但是不具备自动排序的功能。

（但是集合是具有确定性、互异性、无序性的，不要混淆了）

list1=[5,1,3,7,9,9,2]

list1=list（set（list1））

print（list1）#得到[1,2,3,5,7,9]

#大家看呀，这个自动升序了，但仅仅是碰巧。

print（set（[1,3,8,-2,99,98,77,1,5,3,77,12]））#得到{1,98,3,99,5,8,12,77,-2}

#大家看这个，就不会自动给你升序了，一定要注意，集合并没有自动升序排列的性质

选择结构

运行过程

这个判断到底是怎么个流程呢？

我来简单说一下。

其实判断的标准是布尔值，即是False还是True，例如下面这个程序。

if'龙'in'帅帅龙':

print（'good'）

#运行结果是good

print（'龙'in'帅帅龙'）#输出的结果是True

程序执行过程中，会先判断后面的条件代表的是True还是False

‘龙’in'帅帅龙’会返回True，因此执行下面的程序

在python中，一些其他的东西也可以等价为布尔值

if1:

print（'帅帅龙'）

#运行结果是帅帅龙

if-elif-else分支

编译器从上往下寻找符合条件的分支，当进入此分支后便不会再进入其他分支。

多个判断条件是，要写if-elif-else分支语句，if和elif后面要加条件，else后面不需要加条件。

如果不写成多分支而写成多个if，有时会出错，如下：

a=1

ifa==1:

print（'a是1'）

a+=1

ifa==2:

print（'a是2'）

#运行结果是a是1a是2

a=1

ifa==1:

print（'a是1'）

a+=1

elifa==2:

print（'a是2'）

#运行结果是a是1

大家可以思考一下问题出在哪里

逻辑运算符

循环结构

continue与break

continue：

终止本层循环，继续下一层循环

break：

终止循环，直接退出

foriinrange（3）:

ifi==1:

continue

print（i）

#结果为02

###########################

foriinrange（3）:

ifi==1:

break

print（i）

#结果为0

for循环：

常用于已知循环次数

①foriinrange（x）:

for循环其实是while循环的简化形式，for循环可以做到的while也能做到。

range是一个迭代器，可以得到可迭代对象，大家可以输出这句话看看print（list（range（10）））

foriinrange（10）:

#循环10次

print（i）

mylist=[0,1,2,3,4]

foriinrange（len（mylist））:

print（mylist[i]）

②foriinx:

mystr='我爱帅帅龙'

foriinmystr:

print（i）

while循环：

常用于满足某个条件

形式为while+条件判断语句。

当条件返回True，则继续循环，否则结束循环。

与if语句判断过程相似。

while1:

和whileTrue:

可以表示死循环，需要用break跳出循环

x=0

whilex<=5:

print（x）

x+=1

#结果为012345

while-else语句（了解一下就行）

当while语句执行完没有被中断，则会进入else语句。

如果while语句中途被中断了，则不会进入else语句。

x=0

whilex<=5:

print（x）

x+=1

else:

print（'进入else啦'）

#输出结果为012345进入else啦

###########################

x=0

whilex<=5:

ifx==1:

print（i）

break

print（x）

x+=1

else:

print（'进入else啦'）

#输出结果为01

函数

函数就是把代码放在一起了，提高了代码可读性，让代码可以复用，其实很简单，不要有畏难情绪。

函数一般定义在调用之前，通常放在程序头顶

return与print

函数常常将结果通过return返回，当执行到函数的return语句后，函数其他部分将不会再执行。

但是函数可以没有return语句，可以直接执行输出语句，但如果想输出return的值需要用print，说的可能有点蒙了，看代码吧。

deftest（）:

return'我爱阿龙'

print（test（））#会输出我爱阿龙

test（）#啥也不会输出

###########################

deftest（）:

print（'我爱阿龙'）

print（test（））#会输出我爱阿龙和None#因为函数并没有传递值给函数外print，所以为None

test（）#会输出我爱阿龙

函数的参数

简单数据类型作为参数

deftest（x）:

x='我爱帅帅龙'

returnx

a='富婆'

a=test（a）

print（a）#输出为我爱帅帅龙

复杂数据类型作为参数

这里需要注意，因为复杂数据类型作为参数时是以地址进行传递的（就是C/C++的那个地址，没听说过没关系），对函数里的复杂数据类型进行操作，会直接影响原数据，应该使用ls.copy（）方法（详情见下文）

deftest（x）:

x.append（'帅哥'）

returnx

a=['富婆']

a=test（a）

print（a）#输出为['富婆','帅哥']

###########################也可以像下面一样

deftest（x）:

x.append（'帅哥'）

a=['富婆']

test（a）

print（a）#输出为['富婆','帅哥']

可缺省参数

参数分为形参与实参，形参就是在定义函数是括号内的参数，实参就是调用函数的参数。

但有时候实参是不定长的，这是因为在定义函数的时候对应的形参有默认值，当你调用函数的时候省略该参数，则执行过程中该参数为默认值，这就是传说的可缺省参数。

print（）中其实有end这个参数，当你不写则默认为’\n’，即输出完之后会自动输出一个换行。

deftest（x='帅哥',y='富婆'）:

foriin[x,y]:

print（i,end='---'）

test（）#得到结果为帅哥---富婆---，因为你不写，他就有默认值

test（'帅帅'）#得到结果为帅帅---富婆---

test（'帅帅','美美'）#得到结果为帅帅---美美---

test（y='帅帅',x='美美'）#得到结果为美美---帅帅---，可以指定对应参数

注：

可缺省参数应放在最右面，函数调用时，参数是从左往右调用的。

global语句（了解一下）

在函数中引入全局变量，可以直接对其进行修改。

全局变量：

在主程序中定义的变量，既能在一个函数中使用，也能在其他的函数中使用

局部变量：

只能在一部分代码中使用，例如foriinrange（3）的i就是局部变量

deftest（）:

globala

a='富婆'#将a变为'富婆'，这里的a，其实是主函数的a

a='我爱'#这里的a就是全局变量

test（）

print（a）#输出为富婆

###########################

deftest（）:

a='富婆'

a='我爱'

test（）

print（a）#输出为我爱

递归（了解一下）

递归其实就是重复调用函数的过程，递归需要可以设置结束递归的条件，有默认最大递归深度（自己可以重新设置），当你未设置时，超出最大深度会报错。

递归的作用可以使用循环来达到。

下面是一个求阶乘的递归

defjiecheng（n）:

ifn==1:

return1

else:

returnn*jiecheng（n-1）

print（jiecheng（5））#得到的结果为120

当你调用这个函数时，会进入这个函数，首先判断n的值是否为1，如果为1就返回1，

不是则返回n*jiecheng（n-1），即继续往下调用函数。

本次调试中，n为5，即结果为5*jiecheng（4），而jiecheng（4）代表的是4*jiecheng（3），

即此时返回的结果由5*jiecheng（4）变为5*4*jiecheng（3），同理依次往下调用，直到结束递归，即n==1，

最后结果为5*4*3*2*1

txt文件读写

文件操作我们没考编程题，大家还是最好弄清楚考试范围（虽然一般情况老师会说学的都考）

这里其实并不难，只涉及文件的读和写，记得要用close（）方法释放文件的使用权（忘了也没啥事）

写的示范

f=open（'data.txt','w'）#别忘了写文件后缀名

#如果读入的数据和看到的数据不一样，那就这样写f=open（'data.txt','w',encoding='utf-8'）

data=['春眠不觉晓，','处处蚊子咬。

','夜来大狗熊，','看你往哪跑。

']

foriindata:

f.write（i+'\n'）#不加\n就全都写在一行了

f.close（）

读的示范

为了读取方便，我直接使用上方代码创建名为data.txt的文件

f=open（'data.txt','r'）#别忘了写文件后缀名

#如果读入的数据和看到的数据不一样，那就这样写f=open（'data.txt','r',encoding='utf-8'）

data=f.readlines（）

data=[i.strip（）foriindata]#使用列表推导式更新data的内容，目的是为了去除换行符

foriindata:

print（i）

f.close（）

#不使用f.read（）是因为返回的是一坨字符串，不方便操作

注：

文件读写主要是分析文本结构，记得把\n和\t放在写入的字符串内，否则可能不会达到你的预期效果。

一些函数

后期可以根据大家需求再添加，大家可以私戳我或者评论区留言。

.copy（）浅复制（可以不做了解）

deftest（x）:

y=x

y+='我爱帅帅龙'

a='富婆'

test（a）

print（a）#a仍然为'富婆'

将a变为复杂数据类型（列表、字典…）的话，结果就不一样了。

deftest（x）:

y=x

y+=['我爱帅帅龙']

a=['富婆']

test（a）

print（a）#a变成了['富婆','我爱帅帅龙']

这是为什么呢？

原因是编译器为了节省内存，当简单数据类型传递时，只是传递的数值。

但是复杂数据类型占用空间大，传递的是地址，这样节省了内存的使用，但是对复杂数据类型操作会直接改变原数据内容。

问题的解决就需要使用.copy（）函数。

它会将复杂数据类型的数据复制一份给对应变量，从而达到不改变原数据的目的。

deftest（x）:

x=x.copy（）

y=x

y+=['我爱帅帅龙']

a=['富婆']

test（a）

print（a）#a仍为['富婆']

字符串的replace方法

str.replace（old,new[,count]），返回副本，把old字符串替换为new字符串，count表示替换前几次，不写count默认为全部替换。

万能方法：

mystr=mystr.replace（old,new,1）

对后面内容感兴趣的同学可以看看，不感兴趣可以跳过了

mystr='112'

mystr.replace（'1','2'）

print（mysrt）#得到的结果仍为112

为什么失效了呢？

其实只是我们的使用方法不对，因为replace返回的是原字符串副本，

上面已经说过副本这个概念了，即不会对原数据造成影响，因此直接写mystr.replace并不会修改原字符串

修改后的代码如下：

mystr='112'

mystr=mystr.replace（'1','2'）

print（mysrt）#得到的结果为222

题目要求：

将字符串中字母替换为空格

a='df23A？

45cde0@a'#这个测试数据有没有感觉很熟悉？

？

没有当我没说哈。

foriina:

ifnot（'a'<=i<='z'or'A'<=i<='Z'）:

a=a.replace（i,''）

print（a）#结果为dfAcdea

直接傻用replace会不会把数据弄脏呢，会也不会，来看代码。

（强烈建议大家不要看，记住万能公式就好了）

#把2替换为1

a='21122'

foriina:

#因为字符串是简单数据类型，其实这里等价于foriin'21122':

print（i）

ifi=='2':

print（a）

a=a.replace（'2','1'）#因为我没写count，因此，他会把所有的2都替换掉

#i依次输出为21122

#a依次输出为211221111111111

#因为循环的时候，其实程序已经确定好i依次代表什么了，因此更新a，不会影响程序

isinstance（）判断数据格式

type判断一个变量是什么类型不太方便，于是就有了isinstan