Python基础语法（二）：函数封装与核心数据结构

一.函数

编程中的函数是一段可以被重复利用的代码片段

1.1语法格式

创建函数语法格式:

def函数名(形参列表):函数体return返回值

调用函数

#不考虑返回值函数名(实参列表)# 考虑返回值返回值=函数名(实参列表)

1.2 函数参数

在函数定义的时候,可以在()中指定"形式参数",然后在调用的时候,由调用者把实际参数传递进去
示例1:

defcal(beg,end):sum=0foriinrange(beg,end+1):sum+=iprint(sum)cal(1,100)cal(300,400)

上面代码中beg,end就是函数的形参,(1, 100)和(300, 400)就是函数的实参
一个函数可以有一个形参,也可以有多个形参,也可以没有形参
一个函数的形参有几个,传递实参的时候也得传几个,个数要匹配上

1.3 函数返回值

函数的参数可以视为是函数的"输入",则函数的返回值,就可以视为是函数的"输出"
示例1

defcla(beg,end):sum=0foriinrange(beg,end+1):sum+=ireturnsumresult=cla(1,100)print(result)

示例2判定是否是奇数

defisOdd(num):ifnum%2==0:returnFalseelse:returnTrueresult=isOdd(10)print(result)

一个函数中可以有多个return语句

示例3

defgetPoint():x=10y=20returnx,y a,b=getPoint()print(a,b)

一个函数是可以一次返回多个返回值的,使用,来分割多个返回值
如果只想要其中的部分返回值,可以使用_来忽略不想要的返回值

1.4变量的作用域

• 1.变量只能在所在的函数内部生效
  示例1

defgetPoint():x=10y=20returnx,y getPoint()print(x,y)

所以这里函数内部的变量x,y并不能在超出函数范围外生效

• 2.在不同的作用域中,允许存在同名的变量
  示例1

x=10defgetPoint():x=20print(f'函数内部x ={x}')getPoint()

在函数内部的变量也称为"局部变量"
不在任何函数内部的变量,也称为"全局变量"

• 3.如果函数内部尝试访问的局部变量不存在,就会尝试去全局作用域中查找
  示例1

x=10defgetPoint():print(f'函数内部x ={x}')getPoint()print(f'函数外部x ={x}')

• 4.如果想在函数内部,修改全局变量的值,需要使用global关键字声明

x=10defgetPoint():globalx x=20print(f'函数内部x ={x}')getPoint()print(f'函数外部x ={x}')

1.5 函数递归

递归是嵌套调用的一种特殊情况,即一个函数嵌套调用自己
示例1递归计算5!

deffactor(n):ifn==1:return1returnn*factor(n-1)result=factor(5)print(result)

注意事项
存在递归结束条件,比如if n == 1就是结束条件,当n为1的时候,递归就结束了
每次递归的时候,要保证函数的实参是逐渐逼近结束条件的

1.6 参数默认值

Python中的函数,可以给形参指定默认值
带有默认值的参数,可以在调用的时候不传参

示例1计算两个数字的和

defadd(x,y,debug=False):ifdebug:print(f'调式信息: x ={x}, y ={y}')returnx+yprint(add(10,20))print(add(10,20,True))

此处debug=False即为参数的默认值
带有默认值的参数需要放到没有默认值的参数后面

1.7 关键字参数

在调用函数的时候,需要给函数指定实参,一般默认情况下是按照形参的顺序,来依次传递实参的,但是,我们也可以通过关键字参数,来调整这里的传参顺序,显示的指定当前实参传递给哪个形参
示例1

deftest(x,y):print(f'x ={x}')print(f'y ={y}')test(x=10,y=20)test(y=100,x=200)

二.列表

列表（list）是一种内置的、有序的、可变的序列容器，用来存放多个元素。元素可以是任意类型，也可以重复、嵌套

2.1创建列表

• 1.[]表示一个空的列表

alist=[]

• 2.用list方法创建

alist=list()

• 3.列表存放元素是允许存放不同的类型

a=[1,'hello',True]

2.2 访问下标

• 1.可以通过下标访问操作符[ ]来获取到列表中的任意元素
  示例1获取第一个元素

a=[1,2,3,4]print(a[0])

• 2.通过下标修改元素的值
  示例1

a=[1,2,3,4]a[0]='hello'print(a)

• 3.如果下标超出列表的有效范围,会抛出异常

a=[1,2,3,4]print(a[100])

• 4.下标可以取负数,表示"倒数第几个元素"

示例1取倒数第一个元素

a=[1,2,3,4]print(a[-1])

2.3 切片操作

通过刚刚上述的下标操作,是一次从列表里面取出一个元素
通过切片,则是一次取出一组连续的元素,相当于得到一个子列表

• 1.使用[ : ]的方式来进行切片操作
  示例1

a=[1,2,3,4]# 1:3表示[1,3),前闭后开print(a[1:3])

• 2.切片操作中可以省略前后边界
  示例1

a=[1,2,3,4]print(a[1:])print(a[:2])print(a[:])

• 3.切片操作中还可以指定步长,也就是每访问一个元素后,下标自增几步
  示例1

a=[1,2,3,4,5,6,7,8,9]print(a[::2])print(a[::3])

• 4.切片操作的步长也可以是负数,此后是从后往前进行取元素,表示"每访问一个元素之后,下标自减几步"
  示例1

a=[1,2,3,4,5,6,7,8,9]print(a[::-2])print(a[::-3])

• 5.如果切片中填写的数字越界了,不会有负面效果,只会尽可能把满足条件条件的元素切进去
  示例1

a=[1,2,3,4,5,6,7,8,9]print(a[100:200])

2.4 遍历列表元素

• 1.最简单的办法就是使用for循环

a=[1,2,3,4]forelemina:print(elem)

• 2.用for循环按下标访问

a=[1,2,3,4]foriinrange(0,len(a)):print(a[i])

• 3.可以使用while循环,手动控制下标变化

a=[1,2,3,4]i=0whilei<len(a):print(a[i])i+=1

2.5 新增元素

• 使用append方法,向列表末尾插入一个元素(尾插)

a=[1,2,3,4]a.append('hello')print(a)

• 使用insert方法,在任意位置插入一个元素

a=[1,2,3,4]a.insert(1,'hello')print(a)

2.6 查找元素

• 1. 使用in操作符,判定元素是否在列表中存在,返回值是布尔类型

a=[1,2,3,4]print(2ina)print(7ina)

• 2.使用index方法,查找元素在列表中的下标,返回值是一个整数,如果元素不在会抛异常

a=[1,2,3,4]print(a.index(2))

返回2这个元素在列表中的下标

2.7 删除元素

• 1.使用pop方法删除最末尾元素

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

• 2.pop方法也能按照下标来删除元素

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

• 3.使用remove方法,按照值删除元素

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

2.8 连接列表

• 1.使用extend方法,相当于把一个列表拼接到另一个列表后面

alist=[1,2,3,4]blist=[5,6,7]alist.extend(blist)print(alist)print(blist)

三.元组

元组的功能和列表相比,基本是一致的

• 1.元组使用()来表示

atuple=()atuple=tuple()

• 2.元组不能修改里面的元素,列表可以修改里面的元素
  像读操作,比如访问下标,切片,遍历,in,index,+等,元组也是支持的
  像写操作,比如新增元素,修改元素,删除元素,extend,元组不能支持
• 3.元组在python中很多时候是默认的集合类型
  示例1

defgetPoint():return10,20result=getPoint()print(type(result))

四.字典

字典是一种存储键值对的结构

4.1 创建字典

• 1.创建一个空字典,使用{}表示字典

a={}b=dict()print(type(a))print(type(b))

• 2.键值对之间使用逗号分割,键和值之间使用**😗*(冒号)分割
  示例1

student={'id':1,'name':'zhangsan'}print(student)

最后一个键值对的逗号可以不用写

4.2 查找字典

• 1.使用in可以判定key是否在字典中存在,返回布尔值

student={'id':1,'name':'zhangsan'}print('id'instudent)print('calss'instudent)

• 2.使用[ ]通过类似于取下标的方式,获取到元素的值,只不过此处的"下标"是key

student={'id':1,'name':'zhangsan'}print(student['id'])print(student['name'])

如果key在字典中不存在会抛出异常

示例1

student={'id':1,'name':'zhangsan'}print(student['class'])

4.3 新增/修改元素

使用[ ]可以根据key来新增和修改value

• 1.如果key不存在,对取下标操作赋值,即为新增键值对

student={'id':1,'name':'lisi'}student['score']=90print(student)

• 2.1.如果key已经存在,对取下标操作赋值,即为修改键值对的值

student={'id':1,'name':'lisi','score':80}student['score']=90print(student)

4.4 删除元素

• 使用pop方法根据key删除对应的键值对

student={'id':1,'name':'lisi','score':80}student.pop('score')print(student)

4.5 遍历字典元素

• 1. 直接使用for循环能够获取到字典重点所有的key,进一步就可以取出每一个值

示例1

student={'id':1,'name':'lisi','score':80}forkeyinstudent:print(key,student[key])

• 2.使用keys方法取出字典中的所有key

student={'id':1,'name':'lisi','score':80}print(student.keys())

• 3.使用values方法可以获取到字典中的所有value

student={'id':1,'name':'lisi','score':80}print(student.values())

• 4.使用items方法可以获取到字典中的所有键值对

student={'id':1,'name':'lisi','score':80}print(student.items())

4.6 合法的key类型

不是所有类型都可以作为字典的key,字典的本质是一个哈希表,哈希表的key要求是"可哈希的",也就是可以计算出一个哈希值

• 1.可以使用hash函数来计算某个对象的哈希值,能够计算出哈希值的类型,都可以作为字典的key
  示例1

print(hash('hello'))print(hash(True))print(hash(0))print(hash(()))

• 2.列表无法计算哈希值

print(hash([1,2,3]))

• 3.字典也无法计算哈希值

print(hash({'id':1}))

三.文件

3.1 文件路径

一个机器上会存很多文件,为了让这些文件更方便被组织,往往会使用很多文件夹(也叫目录)来整理文件
为了方便确定一个文件所在的位置,使用文件路径来描述
示例1: 文件的绝对路径:D:\CSDN\备用.txt

3.2 文件操作

要使用文件主要是通过文件来保存数据,并且在后续把保存的数据读取出来
想要读写文件,需要先"打开文件",读写完毕之后要"关闭文件"

• 1.打开文件
  使用内建函数open打开一个文件

f=open('D:/CSDN/备用.txt','r')

1.第一个参数是一个字符串,表示要打开文件的路径
2.第二个参数是一个字符串,表示打开方式,其中r表示按照读的方式打开,w表示按照写的方式打开,a表示按照追加的方式打开
3.如果打开文件成功,返回一个文件对象,后续的读文件操作都是围绕这个文件对象展开
4.如果打开文件失败(比如指定的文件不存在)就会抛出异常

• 2.关闭文件
  使用close方法关闭已经打开的文件

f.close()

使用完毕文件要及时关闭,一个程序能同时打开的文件个数,是存在上限的

示例1

flist=[]count=0whileTrue:f=open('D:/CSDN/备用.txt','r')flist.append(f)count+=1print(f'count={count}')

上述代码中,使用一个列表来保存了所有的文件对象,如果不进行保存,那么python中的内存的垃圾回收机制,会在文件对象销毁的时候自动关闭文件
但是由于垃圾回收操作不一定及时,所以我们写代码仍要考虑手动关闭,尽量避免依赖自动关闭

3.3 写文件

文件打开之后,就可以写文件了

• 1.写文件,要使用写的方式打开,open的第二个参数要为’w’,使用write的方法写入文件

f=open('D:\CSDN\备用.txt','w')f.write("hello csdn")f.close()

用记事本打开当前路径下的文本文件,可以看到文件刚写入进去的内容

注意:使用’w’一旦打开文件成功,就会清空文件原有的数据

示例:比如刚刚记事本中的文本内容是hello csdn,现在我重新使用’w’打开,来看之前的内容是否存在

f=open('D:\CSDN\备用.txt','w')f.close()

此时,记事本中的内容已被清空

• 3.使用’a’方式实现’追加写’,此时原有的内容不变,写入的内容会被追加到之前文件内容的末尾
  示例
  现在记事本中有这几个字
  

f=open('D:\CSDN\备用.txt','a')f.write("I love you")f.close()

• 4.针对已经关闭的文件对象进行写操作,也会抛出异常
  示例

f=open('D:\CSDN\备用.txt','a')f.write("I love you")f.close()f.write("hello")

3.4 读文件

• 1.读取文件使用’r’的方式打开文件,使用read方法完成读操作,参数表示读取几个字符
  示例
  目前记事本中的内容如下
  

f=open('D:\CSDN\备用.txt','r',encoding='utf-8')result=f.read(2)print(result)f.close()

• 2.如果是多行文本,可以使用for循环一次读取一行
  示例1

f=open('D:\CSDN\备用.txt','r',encoding='utf-8')forlineinf:print(line)f.close()

• 3.使用readlines直接把整个内容读取出来,返回一个列表,每个元素即为一行
  示例

f=open('D:\CSDN\备用.txt','r',encoding='utf-8')lines=f.readlines()print(lines)f.close()

3.5 使用上下文管理器

打开文件之后,是很容易忘记关闭的,Python提供了上下文管理器,帮助程序员自动关闭文件

• 使用with语句打开文件
• 当with内部的代码执行完毕后,就会自动调用关闭方法
  示例

withopen('D:\CSDN\备用.txt','r',encoding='utf-8')asf:lines=f.readlines()print(lines)

码字不易，如果觉得本文对你有所帮助，请点赞、收藏、加关注支持一下！
你的三连是我更新最大的动力。有任何问题欢迎评论区交流，我们一起进步。下期见！