Python基础语法(三)

函数

1.什么是函数呢?

编程中的函数与数学上的函数有一定的相似之处

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

2.语法格式

创建函数/定义函数

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

函数的调用/使用函数

函数名(实参列表)

返回值 = 函数名(实参列表)

函数定义并不会执行函数体内容,必须要调用才能够执行,调用几次就执几次

3.函数参数

函数的调用是可以有多次的,同时每次调用的实参也可以是不同的

Python只对参数的个数有要求,对参数的类型无要求 但也不是传什么类型都能执行成功,得进行相应的操作

4.函数的返回值

函数的返回值可以视为函数的"输入",则函数的返回值就可以认为是函数的"输出"

一个通用的编程原则:一个函数只做一件事(进一步的好处:解耦合)

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

执行到return的时候就不再继续往下执行了,而是回到调用位置(函数结束了)

python中一个函数可以返回多个值 直接用,分割即可

如果返回多个值,但只想关注一部分,可以用_占位

def getPoint():
    x = 10
    y = 20
    return x,y


a,b = getPoint()

_,b = getPoint()

5.变量的作用域

函数里面的x,y和函数外面的xy不是同一组变量

def getPoint():
    x = 10
    y = 20
    return x,y

x,y = getPoint()

print(x,y)

一个变量名的有效范围是一定的,只在一个固定的范围内生效

函数内部和函数外部可以使用同名变量

全局变量在整个程序中都有效,而局部变量只是在函数内部有效

在函数读取全局变量是OK的

那么能在函数外读取函数内的变量吗?在一定条件时可以的

def test():
    global x
    x = 20

如果没有global此时就会把x=20当做函数内部的一个操作,如果加上了global之后,那么x就是一个全局变量,在函数外也可以使用x

6.函数的执行流程

1.调用函数的时候才会执行函数体代码,不调用则不会执行

2.函数体执行结束(或者遇到return语句),则回到函数调用的位置,继续往下执行

7.函数的链式调用和嵌套调用

链式调用:一个函数的返回值作为另一个函数的参数(先执行()里面的函数,后执行外面的函数)

链式调用的时候,也不要层次太深,否则会影响可读性

嵌套调用:在一个函数中调用另一个函数 (嵌套调用可以有多层)

8.局部变量和函数栈桢

函数之间的调用关系,在python中会使用一个特点的数据结构来表示,称为函数调用栈,每次函数调用都会往调用栈中新增一个元素,称之为栈桢

每个函数的局部变量都保存在栈桢中,当函数调用的时候,栈桢创建 每次函数调用结束的时候,栈桢销毁

9.递归

递归是嵌套调用中的一个特殊情况,即一个函数嵌套调用自己

实例:递归计算5!

def factor(n):
    if n == 1:
        return 1
    return n * factor(n-1)


result = factor(5)

print(result)

上述代码中,就属于典型的递归操作,在factor函数内部,又调用了factor自身

注意:递归代码务必要保证:1.存在递归结束条件 2.每次递归的时候 都要保证函数的实参是逐渐逼近结束条件的

递归的两个要素:1.递归的结束条件 2.递归的递推公式

递归的优缺点:

优点:代码非常简洁

缺点:1.执行过程比较复杂

2.递归代码容易出现"栈溢出"的风险

3.递归代码一般都可以转换成等价的循环代码

10.函数形参的默认值

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

带有默认值的参数需要放到没有默认值的参数的后面

11.关键词参数

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

def test(x,y):
    print(f'x = {x}')
    print(f'y = {y}')


test(x=19,y=23)
test(y=12,x=12)

列表和元组

1.列表和元组的概念

编程中,经常需要使用变量,来保存/表示数据

如果代码中需要表示的数据个数比较少,我们直接创建多个变量即可 但如果代码中需要表示的数据特别多,就需要用到列表

列表是一种在代码中批量表示/保存数据的方式

元组和列表相比,是非常相似的,只是列表中放哪些元素可以调整,元组中放的元素是在创建元组的时候就设定好的,不能修改调整(类似其他编程语言中的数组)

列表和元组大部分功能差不多,但是有一个非常明显的区别:列表是可变的,创建之后可以随时修改,元组是不可变的,创建好之后,改不了,要是想要修改,只能丢弃旧的,搞个新的

2.创建列表

1.创建列表主要有两种方式.\[\] 表示一个空的列表

alist =

alist = list()

print(type(alist))

2.如果需要往里面设置初始值,可以直接写在\[\] 当中

alist = 1,2,3,4

print(alist)

3.列表中存放的元素允许是不同的类型(这一点和C++和JAVA区别较大)

alist = 1,'hello',True

3.访问下标

1.可以通过下标访问操作符\[\]来获取到列表中的任意元素

下标是从0开始计数的

2.不仅可以通过下标读取元素内容,也可以修改元素的值

3.如果下标超出列表的有效范围会抛出异常 (可以使用内置函数len来获取到列表的长度(元素个数))

python中下标还可以写成负数,例如写成-1 等价与len(a)-1

4.切片操作

通过下标操作是一次取出里面的一个元素

通过切片操作,则是一次取出一组连续的元素,相当于得到一个子列表

使用 : 的方式进行切片操作

使用切片的时候,下标构成了前闭后开区间 使用的时候也可以省略边界

省略前边界,意味着从0开始取,省略后边界意味着一直到后边界

Python中的切片是一个比较高效的操作,进行切片的时候只是取出了原有列表中的一个部分,并不涉及数据的拷贝

切片操作还可以指定步长(步长的长度可以为负数,从后往前)

当切片中的范围超出有效下标后,不会出现异常,而是尽可能的把符合要求的元素给获取到

5.遍历列表元素

"遍历"指的是把元素一个一个的取出来,再分别进行处理

1.最简单的方法就是for循环

alist = [1,2,3,4]

for elem in alist:
    print(elem)

2.也可以使用for按照范围生成下标,按照下标访问

alist = [1,2,3,4]


for i in range(0,len(alist)):
    print(alist[i])

3.还可以使用while循环通过下标遍历

alist = [1,2,3,4]

i = 0

while i < len(alist):
    print(alist[i])
    i+=1

6.新增元素

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

此处的append是搭配列表对象一起使用的,而不是作为一个独立的函数

这种要搭配对象来使用的函数也叫做方法

2.使用insert方法向任意位置插入一个元素(如果新增的位置大于列表的长度,会尾插)

7.查找元素

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

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

8.删除元素

1.使用pop方法 不带参数删除最末尾元素 带参数,删除任意位置的元素,pop参数传一个下标

2.使用remove方法按照值删除元素

9.连接列表

1.可以使用+针对两个列表进行拼接(不改变原来的字符)

2.使用extend把后一个内容拼接到前一个后面

a.extend(b)把b的内容拼接到a的后面,不会改变b,但会修改a

3.使用+=来进行拼接

10.关于元组

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

元组使用()来表示

atuple = ()

atuple = tuple()

元组不能修改里面的元素,列表则是可以修改里面的元素

因此,像读操作 元组也是一样支持的

但是像写操作 元组不支持

另外,元组在Python中很多时候是默认的集合类型

字典

1.字典是什么?

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

把key和value进行一个一对一的映射,然后根据键快速找到值

在python的字典中可以同时包含多个键值对,同时要求这些键值对,不能重复

字典对于key是啥类型有约束,对于value是啥类型没有约束

2.创建字典

创建一个空的字典,使用{}表示字典

也可以在创建的同时指定初始值

键值对之间使用,分割,键和值之间使用:分割

a = {}
b = dict()

print(type(a))
print(type(b))

student = {'id': 1,'name': 'july'}

最后一个键值对,后面可以写,也可以不写

3.查找key

1.使用in来判断key是否在字典中存在(in只是判断key是否存在,和value无关) 返回布尔值

2.使用\[\]来根据key获取到value

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

字典背后使用的是哈希表,对于字典来说这两种方式都是比较高效的操作

对于列表来说,使用in比较低效,使用\[\]比较高效

4.新增/修改元素

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

如果key存在,就相当于修改value

如果key不存在,就相当于新增键值对

5.删除元素

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

6.字典遍历

字典被设计出来的初衷是为了增删改查

字典是哈希表,进行增删改查的效率非常高,但进行遍历效率就要低一点

python中打印顺序和插入顺序是一样的

1.for循环

直接使用for循环能够获取到字典中的所有的key,进一步就可以获取到所有的value了

student = {
    'id': 1,
    'name': 'an'
}

for key in student:
    print(student[key])

2.字典中的一些方法

keys获取到字典中所有的key

values获取字典中所有的value

items获取到字典中所有的键值对

合法的key类型:不是所有的类型都可以作为字典的key

字典本质是一个哈希表,哈希表的key要求是可哈希的,也就是可以计算出一个哈希值

不可变的对象一般就是可哈希的,可变的对象一般就是不可哈希的(字典和列表是不可哈希的)

文件

1.文件是什么

变量是把数据存储到内存中,如果程序重启/设备重启,内存中的数据就会丢失

如果想要数据被持久化存储,就可以把数据存储到硬盘中,也就是在文件中保存

文件夹(目录)也是一种特殊的文件.目录文件

2.文件路径

文件路径分为两种:绝对路径/相对路径

3.文件操作

1.打开文件

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

f = open('d:/test/txt','r')

第一个参数是字符串,表示要打开的文件路径

第二个参数是一个字符串,表示打开方式,其中r表示按照读的方式打开,w表示按照写的方式打开,a表示按照追加的方式打开

如果打开文件成功会返回一个文件对象,如果失败,会抛出异常

此处的文件对象,就相当于一个'handler'

2.关闭文件

f.close()

文件打开完之后一定要关闭,打开文件实际上就是申请一些资源,不再使用这些文件的时候就应该及时释放

每个程序在启动的时候,都会默认打开三个文件:1.标准输入 2.标准输出 3.标准错误

python中有一个重要的机制:垃圾回收GC

3.写文件

使用write方法写入文件

如果使用'w':会清空原文件的内容

如果使用'a':会追加

4.读文件

1.需要使用'r'的方式打开文件

2.使用read()方法完成读操作,参数表示"读取几个字符"

如果是多行文本,可以使用for循环每次只读一行

使用readLines直接把文件全部内容读取出来,返回一个列表,每个元素即为一行

4.使用上下文管理器

打开文件之后,是容易忘记关闭的,python提供了上下文管理器,来帮助自动关闭文件

1.使用with打开文件

2.当with内部代码块执行完毕之后,会自动调用关闭方法