python学习笔记 - （2）函数

定义函数
格式：
def 函数名(参数)：
代码1
代码2
...

调用函数
格式：
函数名(参数)

/// python中，函数必须是先定义后使用

函数说明文档：作用查看函数的说明文档

定义函数的说明文档
格式
def 函数名(参数)：
  ''' 说明文档的位置 '''
 代码
  ...

查看函数说明文档的方法
help(函数名)

全局变量修改

/// 全局变量
a = 100

def testA():
  print(a)

def testB():
  /// 如果直接修改a=200，此时的a是局部变量
  /// a = 200
  /// 修改全局变量a的正确做法
  global a 
  a = 200
  print(a)


testA()
testB()

一个函数有多个返回值

def return_num():
    /// 结果：(1, 2, 3)
    /// 是一个元组
    return 1,2,3

函数参数

* 位置参数
  调用函数时根据函数定义的参数位置来传递参数

/// 传递和定义参数的顺序及个数必须一致
def user_info(name,age,gender):
    print(f'我的名字{name},年龄{age},性别{gender}')

user_info('Liven',18,'man')


* 关键字参数
  函数调用，通过'键=值'形式加以指定。可以让函数更加清晰、容易适应，同时也清除了参数的顺序需求

/// 函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序
def user_info(name,age,gender):
    print(f'我的名字{name},年龄{age},性别{gender}')

user_info('Liven',age=18,gender='man')


* 缺省参数
  也叫做默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注意：所有位置参数必须要出现默认参数前，包括函数定义和调用）

def user_info(name,age,gender='max'):
    print(f'我的名字{name},年龄{age},性别{gender}')

user_info('Liven',age=18)


* �不定长参数
  也叫做可变参数，用于不确定调用的时候回传递多少个参数（不传参也可以）的场景，此时，可用包裹位置参数，或者包裹关键字参数，来进行参数传递，会显得非常方便。
 
 a 包裹位置传递
def user_info(*args):
    print(args)

user_info('Tom',19)
/// 注意：传进的所有参数都会被args变量收集i，它会根据传进的位置合并为一个元组，args是元组类型，这就是包裹位置传递


b 包裹关键字传递
def user_info(**kwargs):
    print(kwargs)

user_info(age=10,name='liven')

/// 综上：无论是包裹位置传递还是包裹关键字传递，都是一个组包的过程

拆包和交换变量值

* 拆包：元组
def return_num():
    return  100,200

/// return_num()函数返回的是一个元组
/// 而这个元组是有两个数据，那么可以通过两个变量的方式拆包元组
num1 , num2 = return_num()

print(num1)
print(num2)


* 拆包：字典
dict1 = {'name':'liven','age':12}

# 对字典拆包，取出来的是字典的key
a,b = dict1

print(a)
print(b)

print(dict1[a])
print(dict1[b])

交换两个变量的值

a = 10
b = 20
a,b = b,a
print(a)
print(b)

可变和不可变类型

* 可变类型
  列表
  字典
  集合

* 不可变类型
  整型
  浮点型
  字符串
  元组

lambda

应用场景：如果一个函数有一个返回值，并且只有一句代码，可以使用lambda简化

格式：
lambda 参数列表：表达式
/// lambda表达式的参数可有可无，函数的参数在lambda表达式中完全适用
/// lambda表达式能接收任何数量的参数但只能返回一个表达式的值


lambda 无参数
/// 结果是返回100
(lambda:100)()

lambda 一个参数
/// 返回的是字符串'hello world'
(lambda a:a)('hello world')

lambda默认参数
/// 返回结果：130
(lambda a,b,c=100:a+b+c)(10,20)

lambda可变参数 *args
/// 返回结果：（10，20，30）
(lambda *args:args)(10,20,30)

lambda可变参数：**kwargs
/// 返回结果：{'name':'python','age':10}
(lambda **kwargs:kwargs)(name='python',age=10)

/// lambda的应用
1、带判断的lambda
/// 打印两个数中比较大的一个
/// 结果：1000
print(lambda a,b:a if a>b else b)(1000,500))

2、列表数据按字典key的值排序
students = [
    {'name':'luck','age':20},
    {'name':'jack','age':20},
    {'name':'lilei','age':20},
    {'name':'rose','age':20},
]

students.sort(key=lambda x:x['name'])
print(students)

高阶函数：把函数作为参数传入，高阶函数是函数式编程的体现

python中，常用的函数

* abs() 获取数字的绝对值
/// 结果： 10 
print(abs(-10))

* round() 对数字的四舍五入的计算
/// 结果：2
print(round(1.9))
/// 结果：1
print(round(1.1))


例子
def sum_num(a,b,f):
    return f(a) + f(b)

resutl = sum_num(10,-10,abs)
print(resutl)

内置高阶函数

* map(func,lst)，将传入的函数变量func作用到lst变量的每个元素中，并将结果组成新的列表(Python2)/迭代器(Python3)返回

例子
计算list1序列中各个数字的2次方
list1 = [1,2,3,4,5]

def func(x):
    return  x**2

result = map(func,list1)
print(result)
print(list(result))


* reduce()
reduce(func,lst)，其中func必须有两个参数。每次func计算的结果继续和序列的下一个元素做累计计算

例子
计算list1序列中各个数字的累积加

import functools
list1 = [1,2,3,4,5]
def func(a,b):
    return a + b
result = functools.reduce(func,list1)
/// 结果：15
print(result)


* filter()
filter(func,lst) 函数用于过滤序列，过滤掉不符合条件的元素，返回一个filter对象。如果要转换为列表，可以使用list()来转换
list1 = [1,2,3,4,5]

def func(x):
    return x%2==0

resutl = filter(func,list1)
/// 结果：[2,4]
print(list(resutl))

文件基本操作

1. 打开文件
2. 读写等操作
3. 关闭文件

• 打开
  使用open函数，可以打开一个已经存在的文件，或者创建一个新文件，格式如下：
  f = open(name,mode)
  /// f:此时的f是open函数的文件对象
  /// name:是要打开的目标文件名字符串(可以包含文件所在的具体路径)
  /// mode:设置打开文件的模式(访问模式)：只读、写入、追加

  例子
  # 1.0 打开文件
  f = open('test.txt','w')
  # 2.0 写入文件
  f.write('数据写入')
  # 关闭文件
  f.close()
  

  文件操作模式：(文件操作模式默认是：r)
    
    r : 以只读方式打开文件，如果文件不存在，则会报错  
    rb: 以二进制格式打开一个文件用于只读
    r+: 打开一个文件用于读写
    rb+:以二进制格式打开一个文件用于读写
    
    w : 打开一个文件只用于写入，如果文件不存在，则会自动新建文件，如果文件存在，则会覆盖原有的内容
    wb: 以二进制格式打开一个文件只用于写入
    w+: 打开一个文件用于读写
    wb+: 以二进制格式打开一个文件用于读写
    
    a : 打开一个文件用于追加，如果文件不存在，则会新建文件，如果文件存在，则会在原有的内容，追加新内容
    ab: 以二进制格式打开一个文件用于追加
    a+: 打开一个文件用于读写
    ab+ : 以二进制格式打开一个文件用于追加
  
  

- read()

    格式：文件对象.read(num)
    /// num表示要从文件中读取的数据的长度(单位是字节)，如果没传入num，那么就表示读取文件中所有的数据



- readlines()

    格式：文件对象.readlines()
    /// readlines可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素



- readline()

    /// 一次读取一行内容
    f = open('test.txt')
    
    content = f.readline()
    print(f'第一行：{content}')
    
    content = f.readline()
    print(f'第二行：{content}')
    
    f.close()



- seek()

    格式：
    文件对象.seek(偏移量，起始位置)
    /// 用来移动文件指针
    /// 起始位置
    /// 0: 文件开头
    /// 1: 当前位置
    /// 2: 文件结尾 

文件和文件夹的操作

在python中需要借助os模块里的相关功能
/// 导入os模块
import os

/// 使用os模块相关功能
os.函数名()


* 文件重命名
os.rename('文件名或文件具体路径','新名称')

* 删除文件
os.remove('文件名或文件具体路径')

* 创建文件夹
os.mkdir('文件夹名字')

* 获取当前目录
os.getcwd()

* 改变默认目录
os.chdir('目录')

* 获取目录列表
os.listdir('目录')

例子
把code文件夹所有文件重命名Python_xxx

import os
# 1. 找到所有文件，获取code文件的目录列表 -- listidir()
file_list = os.listdir()

# 2. 构造名字
for j in  file_list:
  new_name = 'Python_' + a
  os.renames(a,new_name)