函数

代码示例 ：求数列的和，使用函数
 

#定义函数
def calcSum(beg, end):
    sum = 0
    for i in range(beg, end + 1):
        sum += i
    print(sum)

#调用函数
sum(1, 100)
sum(300, 400)
sum(1, 1000)

语法格式
创建函数/定义函数

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

调用函数/使用函数
函数名(实参列表)                        //不考虑返回值
返回值 = 函数名(实参列表)         //考虑返回值

函数必须先定义，再使用

注意：
一个函数可以有一个形参，也可以有多个形参，也可以没有形参
一个函数的形参有几个，那么传递实参的时候也得传几个，保证个数要匹配
和c++/Java不同，Python是动态类型的编程语言，函数的形参不必指定参数类型，换句话说，一个函数可以支持多种不同类型的参数。
 

def test(a):
    print(a)

test(10)
test('hello')
test(True)

一个函数是可以一次返回多个返回值的，使用，来分割多个返回值
如果只想关注其中的部分返回值，可以使用_来忽略不想要的返回值
_, b = getPoint()

在不同作用域中，允许存在同名的变量
如果函数内部尝试访问的变量在局部不存在，就会尝试去全局作用域中查找
如果是想在函数内部，修改全局变量的值，需要使用global关键字声明
if/while/for等语句块中定义的变量，在语句块外面也可以正常使用

链式调用

#判定是否是奇数
def isOdd(num):
    if num % 2 == 0:
        return False
    else:
        return True

result = isOdd(10)
print(result)

实际上可以简化写作：print(isOdd(10))

嵌套调用
函数之间的调用关系，在Python中会使用一个特定的数据结构来表示，称为函数调用栈。每次函数调用，都会在调用栈里新增一个元素，称为栈帧。
每个函数的局部变量，都包含在自己的栈帧中

函数递归
递归是嵌套调用中的一种情况，即一个函数嵌套调用自己
代码示例：递归计算5！
 

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

result = factor(5)
print(result)

注意：递归代码务必要保证
存在递归结束条件，比如：if n == 1 就是结束条件，当n为1的时候，递归就结束了
每次递归的时候，要保证函数的实参是逐渐逼近结束条件的
如果上述条件不能满足，就会出现“无限递归”

递归的优点：
递归类似于“数学归纳法”，明确初始条件，和递推公式，就可以解决一系列的问题
递归代码往往代码量非常少

递归的缺点：
递归代码往往难以理解，很容易超出掌控范围
递归代码容易出现栈溢出的情况
递归代码往往可以转换成等价的循环代码，并且通常来说循环版本的代码执行效率要略高于递归版本
实际开发的时候，使用递归要慎重

参数默认值
Python中的函数，可以给形参指定默认值
带有默认值的参数，可以在调用的时候不传参
带有默认值的参数需要放到没有默认值的参数的后面

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

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

test(x=10, y=20)
test(y=100, x=200)

形如上述test(x=10, y=20)这样的操作，即为关键字参数

列表和元组
列表是一种让程序猿在代码中批量表示/保存数据的方式
元组和列表相比，是非常相似的，只是列表中放哪些元素可以修改调整，元组中放的元素是创建元组的时候就设定好的，不能调整修改。

创建列表
创建列表主要有两种方式[]表示一个空的列表
如果需要往里面设置初始值，可以直接写在[]当中
alist = [1,2,3,4]
列表中存放的元素允许是不同的类型（这一点和C++Java差别较大）

访问下标
可以通过下标访问操作符[]来获取列表中的任意元素
print(alist[2])
注意：下标是从0开始计数的，因此下标为2，则对应3这个元素
通过下标不光能读取元素内容，还能修改元素的值
如果下标超出列表的有效范围，会抛出异常
因为下标是从0开始的，因此下标的有效范围是[0,列表长度-1]，使用len函数可以获取到列表的元素个数
下标可以取负数，表示“倒数第几个元素” alist[-1] 相当于alist[len(alist) - 1]

切片操作
通过下标操作是一次取出里面第一个元素
通过切片，则是一次取出一组连续的元素，相当于得到一个子列表
使用[ : ]的方式进行切片操作
print(alist[1 : 3]) 其中 1：3表示的是[1,3)这样由下标构成的前闭后开区间
切片操作中可以省略前后边界
 

alist = [1,2,3,4]
print(alist[1:])    #省略后边界，表示获取到列表末尾
print(alist[:-1])   #省略前边界，表示从列表开头获取
print(alist[:])     #省略两个边界，表示获取到整个列表

切片操作还可以指定“步长”，也就是“每访问一个元素后，下标自增几步”，步长还可以是负数，此时是从后往前进行取元素，表示“每访问一个元素之后，下标自减几步”
print(alist[::1])
print(alist[::2])
print(alist[::-1])
print(alist[::-2])
如果切片中填写的数字越界了，不会有负面效果，只会尽可能的把满足条件的元素过去到

遍历列表元素
 

alist = [1,2,3,4]

for elem in alist:
    print(elem)

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

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

新增元素
使用append方法，向列表末尾插入一个元素(尾插)
alist.append('hello')
使用insert方法，向任意位置插入一个元素 insert第一个参数表示要插入元素的下标
alist.insert(1,'hello')

查找元素
使用in操作符，判定元素是否在列表中真实存在，返回值是布尔类型
print(2 in alist)
使用index方法，查找元素在列表的下标，返回值是一个整数，如果元素不存在，则会抛出异常
print(alist.index(2))

删除元素
使用pop方法删除最末尾元素
alist.pop()
pop也能按照下标来删除元素
alist.pop(2)
使用remove方法，按照值删除元素
alist.remove(2)

连接列表
使用+能够把两个列表拼接在一起，此处的+结果会生成一个新的列表，而不会影响到旧列表的内容
print(alist + blist)
使用extend方法，相当于把一个列表拼接到另一个列表的后面
a.extend(b),是把b中的内容拼接到a的末尾，不会修改b，但是会修改a

关于元组
元组使用()来表示
atuple = ( )
atuple = tuple( )
元组不能修改里面的元素，列表可以修改里面的元素
读操作元组一样支持，写操作元组不能支持
元组在Python中很多时候是默认的集合类型，例如:当一个函数返回多个值的时候

字典
字典是一种存储键值对的结构
创建一个空的字典，使用{ }表示字典
a = { }
也可以在创建的同时指定初始值，键值对之间使用，分割，键和值之间使用:分割（冒号后面推荐加一个空格）
使用print打印字典内容
student = {'id': 1, 'name' : 'zhangsan'}
为了书写美观，在创建字典时往往会把多个键值对分成多行来书写
student = {
        'id' : 1,
        'name' : 'zhangsan'
}

查找key
使用in可以判定key是否在字典中存在，返回布尔值
print('id' in student)
使用[ ]通过类似于去下标的方式获取到元素的值，只不过此处的“下标”是key
print(student['id'])
如果key在字典中不存在，则会抛出异常

新增/修改元素
使用[ ]可以根据key来新增/修改value
student['score'] = 90
如果key不存在，对取下标操作赋值即为新增键值对
如果key已经存在，对取下标操作赋值即为修改键值对的值

删除元素
使用pop方法根据key删除对应的键值对
student.pop('score')

遍历字典元素
直接使用for循环能够获取到字典中的所有的key，进一步的就可以取出每一个值了

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

取出key和value
使用keys方法可以获取到字典中的所有key
print(student.keys())
dict_keys是一个特殊的类型，专门用来表示字典的所有key，大部分元组支持的操作对于dict_keys同样适用
使用values方法可以获取到字典中所有value
print(student.values())
dict_values也是一个特殊的类型
使用items方法可以获取到字典中所有的键值对
print(student.items())
dict_items也是一个特殊的类型

合法的key类型
字典本质上是一个哈希表，哈希表的key要求是可哈希的，也就是可以计算出一个哈希值
可以使用hash函数计算某个对象的哈希值
但凡能够计算出哈希值的类型都可以作为字典的key
列表无法计算哈希值，字典也无法计算哈希值

文件路径
D:表示盘符，以盘符开头的路径称为绝对路径
除了绝对路径外还有一种相对路径

文件操作
1.打开文件
使用内建函数open打开一个文件
f = open('d:/test.txt', 'r')
第一个参数是一个字符串表示要打开的文件路径
第二个参数是一个是字符串表示打开方式，r表示按照读的方式打开，w按照写方式打开，a表示追加写方式打开
如果打开成功，返回一个文件对象，后续的读写操作都是围绕这个文件对象展开
如果打开文件失败就会抛出异常

2.关闭文件
使用close方法关闭已经打开的文件
f.close()
一个程序能同时打开的文件个数是存在上限的，使用完毕的文件要记得关闭

3.写文件
文件打开之后就可以写文件了
写文件要使用写方式打开，open第二个参数设为'w'
使用write方法写入文件
f = open('d:/test.txt', 'r')
f.write('hello')
f.close()
使用'w'一旦打开文件成功，就会清空文件原有的数据
使用'a'实现“追加写”，此时原有内容不变，写入的内容会存在于之气那文件内容的末尾

4.读文件
使用read方法完成读操作，参数表示“读取几个字符”
result = f.read(2)
循环读多行文件
for line in f:
        print(f'line = {line}')
使用readlines直接把文件整个内容读取出来，返回一个列表，每个元素即为一行
lines = f.readllines()

使用上下文管理器
打开文件后容易忘记关闭文件，使用with语句打开文件 当with内部的代码块执行完毕后，就会自动调用关闭方法
 

with open('d:/test.txt', 'r', encoding='utf8') as f:
    lines = f.readlines()
    print(lines)