[Python知识库]python入门基础03——函数、文件、模块/包

函数

# 一般格式
def my_function():
    代码块
    return xxx # 不写，默认为return None
    代码块 # 注意,在return后面的语句不会执行
    
    
# 函数只有调用了才会执行
def function1():
    print('执行function1')
    def function2(): # 内部函数
        print('执行function2')
    print('function1执行结束')
    return function2
function1()()

执行function1
function1执行结束
执行function2

基本参数传递

# 不可变类型参数
a = 1
def func(b):  # b = a 这里是a的地址指向1，b的地址也指向了1，传的是地址
    print('在函数内部修改之前，形参b的内存地址为:%s'%id(b))
    b = 2
    print('在函数内部修改之前，形参b的内存地址为:%s'%id(b))
    print('函数内部的b为:%s'%b)

print('调用函数之前，变量a的内存地址为:%s',id(a))
func(a)
print('调用函数之后，函数外部的变量a为:',a)

调用函数之前，变量a的内存地址为:%s 140428503968048
在函数内部修改之前，形参b的内存地址为:140428503968048
在函数内部修改之前，形参b的内存地址为:140428503968080
函数内部的b为:2
调用函数之后，函数外部的变量a为: 1

# 可变类型参数
a = [1,2,3]
def func(b):
    print('在函数内部修改之前，变量b的内存地址为:',id(b))
    b.append(4)
    print('在函数内部修改之前，变量b的内存地址为:',id(b))
    print('函数内部的b为:',b)
print('调用函数之前，变量a的内存地址为:%s',id(a))
func(a)
print('调用函数之后，函数外部的变量a为:',a)

调用函数之前，变量a的内存地址为:%s 140427826459904
在函数内部修改之前，变量b的内存地址为: 140427826459904
在函数内部修改之前，变量b的内存地址为: 140427826459904
函数内部的b为: [1, 2, 3, 4]
调用函数之后，函数外部的变量a为: [1, 2, 3, 4]

参数类

# 位置参数
函数有几个参数就得传几个参数

# 默认参数,下面x就是位置参数，n就是默认参数
# 默认参数不可以写在位置参数前面，尽量指向不可变对象
函数的参数列表内已经指定该参数值为多少，比如 def function(x,n=2)

def func(a=[]): # 可变类型参数作为默认参数的默认值
    a.append('A')
    return a

print(func())
print(func())
print(func())
def func(a=[]): # 可变类型参数作为默认参数的默认值
    a.append('A')
    return a

['A']
['A', 'A']
['A', 'A', 'A']

# 动态参数
def func(*args):
    print(args)
    for param in args:
        print(param)
        
func(1,2,3)
t = (1,2,3)   
func(*t)

结果：(1, 2, 3)
1
2
3
(1, 2, 3)
1
2
3
# **接受键值对的动态参数，调用的时候会将实际参数打包成字典
def func(**kwargs):
    print(kwargs)
    
dic = {
    'name':'xiao',
    'age':22
}
func(**dic)
func(d=dic)

结果：{'name': 'xiao', 'age': 22}
{'d': {'name': 'xiao', 'age': 22}}

def func(*args,**kwargs):
    pass
func(1,2,3,name='xiao',age=22)

变量的作用域

在函数内部可以访问函数外部的变量(外部变量)

在函数外部不能访问函数内部的变量(局部变量)

age = 10
def Age(arg1,arg2):
    global age # 引用了外部变量，不加就是局部
    age = arg1+arg2
    print(age)
    print(id(age))
    return age
Age(10,20)
print(age)
print(id(age))

结果：30
139690303171792
30
139690303171792

代表函数

Rang

for item in range(5):
    print(item)
    
# 给一个数字类型的参数，range会从0到参数减一的数字，也就是[0,num)
# 左闭右开，python中常用规则就是如此，切片也是
# 也可以指定区间和步长
for item in range(1,11,3):
    print(item)

匿名函数

result = lambda x:1 if x > 0 else 0 # x就是匿名的参数，0和1是返回值
result(1)

递归函数

# 有效的递归，不做无效的死循环，要防止深度溢出
def sum_number(n):
    if n == 1:
        return 1
    return n + sum_number(n-1)
sum_number(5)

结果：15

文件操作

open(
    file,
    mode='r',
    buffering=-1,
    encoding=None,
    errors=None,
    newline=None,
    closefd=True,
    opener=None,
)

# 打开文件，写数据，w模式会清空数据再写入
fp = open('./xiao.txt','w')
fp.write('xiao youpei')
fp.close()

# 打开文件，读数据，readlines是全部读取，readline是一行行读取
fp = open('./xiao.txt','r')
#text1 = fp.readline()
#text2 = fp.readline()
text = fp.readlines()
#print(text1,text2)
print(text)

# 返回光标的位置，下方输出结果为9
fp = open('./xiao.txt','w')
fp.write('xiao xiao')
re = fp.tell() # 返回光标所处的位置
print(re)

# 从起始位置移动x个字节
# seek(x,0) 起始位置移动x
# seek(x,1) 当前位置往后移动x
# seek(-x,2) 从文件结尾往前移动x
fp = open('./xiao.txt','r')
fp.seek(5,0)
text = fp.read(4)
print(text)

# 加with即可不用文件执行末尾加close
with open('./xiao.txt','w') as fp: # fp=openO()+末尾有fp.close()
    fp.write('xiao')

模块和包

模块/包

import time as t # import导入模块，as起别名

# 两种方式导方法
import time
time.sleep(1)

from time import sleep
sleep(1)

# 自定义模块
# 直接py文件就可import

# 主函数入口，项目启动文件
if __name__ == '__main__':
# 如果在自定义模块中出现__name__，代表模块名

print('xxx', __name__)
if __name__ == '__main__':
    pass
结果：xxx __main__

# 如果文件夹下有__init__.py文件，那么这个文件夹就是python的包
# from后面可以跟包也就跟模块

常见模块

time

# time
# 时间戳，可用于计算运行程序耗时
import time
print(time.time())

# 时间格式
import time
time.strftime('%Y-%m-%d %X')
'2022-01-12 18:48:36'

# 程序暂停n秒
import time
time.sleep(2) 

random

# random
# 随机返回0到1数字
import random
random.random()

# 整数，1-10，包含1和10
import random
random.randint(1,10)

# 列表随机取n数组合
import random
list = [1,2,3,4,5]
random.sample(list,2)

# 将列表随机打乱
random.shuffle(list)

# 随机产生验证码
import random

def random_str():
    code = ""
    for i in range(5):
        num = random.randint(0, 9)  # 随机产生个位数
        alf = chr(random.randint(65, 90))  # 随机产生一个字母
        add = random.choice([num, alf])  # 列表随机选择
        code = ''.join([code, str(add)])
    return code

code = random_str()
print(code)

OS

# os，系统交互模块
# 创建多级目录
os.makedirs('./name/age/')
# 创建文件夹
os.mkdir('./name')
# 执行终端命令
os.system('ls')
# 绝对路径
os.path.abspath('./')
# 路径是否存在
os.path.exists('./xxx')
# 文件是否存在
os.path.isfile(path)
# 文件最后访问时间
os.path.getatime(path)
# 文件/文件夹大小
os.path。getsize(path)

序列化

# 序列化，将字典对象转换为字符串
import json
dic = {
    'name':['xiao','li'],
    'age':22
}
r = json.dumps(dic) # dumps
print(r)

# 反序列化
import json
str = '{"name": ["xiao", "li"], "age": 22}'
dic = json.loads(str) # loads
print(dic)

# 直接将字典存于文件
import json
dic = {
    'name':['xiao','li'],
    'age':22,
    'sex':'man'
}
with open('./xiao.txt','a') as fp:
    json.dump(dic,fp)
    
# 反序列化，将字符串转为字字典对象
import json
with open('./xiao.json','r+') as fp:
    dic = json.load(fp)
    print(dic)

正则

基于re模块进行正则匹配操作

# 常用正则
单字符:
    .:除换行外所有字符
    []:[aoe] [a-w] 匹配集合中任意一个字符
    \d:数字 [0-9]
数量修饰:
    *:任意多次 >=0
    +:至少一次 >=1
    ?:可有可无 0次或者一次
    {m}: 固定m次 hello{3,}
    {m,}:至少m次
    {m,n}:m-n次
边界:
    $:以某某开头
    ^:以某某开头
分组:
	(ab)
贪婪模式: .*
非贪婪模式: .*?

import re

str = 'http://www.baidu.com and https://xiaoyoupei.com'

result = re.findall(pattern=r'https*://', string=str)
print(result)

结果：
['http://', 'https://']

#------------
import re

str = 'xiao<html>hello</html>xiao'

result = re.findall(pattern=r'<html>(.*)</html>', string=str) # 匹配出hello
print(result)

结果：
['hello']

#------------
import re

str = 'xiao@xiao.edu.com'

result = re.findall(pattern='@(.*?)\.', string=str) # 匹配xiao
print(result)