Python编程基础(二)
打卡第二天啦!!!
函数
初识函数
- 什么是函数:函数是一系列Python语句的组合,可以在程序中运行一次或多次,一般是完成具体的独立的功能
- 为什么要使用函数:代码复用最大化
- 函数定义:
def 函数名(参数列表):
函数体 - 函数的调用:本质上是去执行函数定义里面的代码块,在调用函数之前必须先定义
# 函数的定义
'''
打印个人信息
'''
def person_info(name,age):
# 函数代码块
print('姓名:{}'.format(name))
print('年龄:{}'.format(age))
pass
# 函数的调用
person_info('潘小雷',20)
person_info('鲸鱼',20)
# 姓名:潘小雷
# 年龄:20
# 姓名:鲸鱼
# 年龄:20
函数参数
- 参数分类:必选参数、默认参数[缺省参数]、可选参数、关键字参数
- 参数:函数为了实现某项特定的功能,进而为了得到实现功能所需要的数据
- 必选参数:
def sum(a,b): #a和b为形式参数,知识意义上的参数,在定义的时候不占内存地址
sum=a+b
print(sum)
pass
# 函数调用,必选参数在调用的时候必选参数是必须要赋值的
sum(1,2) #实际参数,是实际占用内存地址的
- 默认参数:
注:默认参数始终存在于参数列表的尾部
# 默认参数始终存在于参数列表的尾部
def sum1(a=20,b=30):
print('sum={}'.format(a+b))
pass
# 默认参数调用 在调用的时候如果未赋值,就会用定义函数时给定的默认值
sum1()
sum1(10)
sum1(10,10)
# sum=50
# sum=40
# sum=20
- 可选参数:
(1)接受的数据是元组类型
# 可选参数,当参数的个数不确定时使用
def getComputer(*args):
print(args)
pass
getComputer(1) # (1,)
getComputer(1,2,3) #(1, 2, 3)
def sum2(*args):
sum=0
for item in args:
sum+=item
pass
print(sum)
pass
sum2(1,2,3,4,5) #15
- 关键字参数:
(1)接受的数据是字典类型
注:可选参数必须放到关键字参数之前
# 关键字参数
# ** 来定义
# 函数体内 参数关键字是一个字典类型 key是一个字符串
def keyFunc(**kwargs):
print(kwargs)
print(*kwargs)
pass
# 函数调用
dictA={"name":'潘小雷',"age":'20'}
keyFunc(**dictA)
# {'name': '潘小雷', 'age': '20'}
# name age
keyFunc(name='潘小雷',age=20)
# {'name': '潘小雷', 'age': '20'}
# name age
# 可选参数必须放到关键字参数之前
def complexFunc(*args,**kwargs):
print(args)
print(kwargs)
pass
complexFunc(1,2,3)
# (1, 2, 3)
# {}
complexFunc(**dictA)
# ()
# {'name': '潘小雷', 'age': '20'}
函数返回值
- 概念:函数执行完会返回一个对象,如果在函数内部有return,就可以返回实际的值,否则返回None
- 类型:可以返回任意类型,返回值类型应该取决于return后面的类型
- 用途:给调用方返回数据
- 在一个函数体内可以出现多个return,但是肯定只能返回一个return
- 如果在一个函数体内,执行了return,意味着函数就退出了,return后面的代码语句将不会执行
# 返回一个值
def sum(a,b):
sum=a+b
return sum
res=sum(1,2)
print(res) #3
# 返回一个列表
def calComputer(num):
li=[]
result=0
i=1
while i<=num:
result+=i
i+=1
pass
li.append(result)
return li
value=calComputer(10)
print(value) #[55]
函数嵌套调用
def func1():
print('-------func1-----------')
pass
def func2():
print('-------func2-----------')
func1()
pass
func2()
# -------func2-----------
# -------func1-----------
函数的基本类型
- 根据函数的返回值和函数的参数可以将函数进行分类:
(1)有参数无返回值的
(2)有参数有返回值的
(3)无参数有返回值的
(4)无参数无返回值的
全局变量和局部变量
局部变量
- 在函数内部定义的变量,作用域仅仅局限在函数的内部
- 不同的函数可以定义相同的局部变量,之间不会产生影响
- 作用:为了临时地保存数据,需要在函数中定义来进行存储
全局变量
- 当全局变量和局部变量出现重复时,程序会优先执行使用函数内部定义的变量
- 使用global关键字在函数内部修改全局变量
函数参数引用传值
- 在函数调用时,实参传递的是对象的引用
- 参数传递是通过对象引用来完成的,注意可变类型和不可变类型的区别
# 不可变类型
a=1
def func(x):
print('x的地址{}'.format(id(x)))
x=2
print('修改后x的地址{}'.format(id(x)))
print(x)
pass
print('a的地址{}'.format(id(a)))
func(a)
print(a)
# a的地址140735484798752
# x的地址140735484798752
# 修改后x的地址140735484798784
# 2
# 1
# 可变类型
li=[]
def test(params):
params.append([1,2,3])
print('内部变量对象{}'.format(params))
pass
test(li)
print('外部变量对象{}'.format(li))
# 内部变量对象[[1, 2, 3]]
# 外部变量对象[[1, 2, 3]]
匿名函数
- 语法:lambda 参数1、参数2…:表达式
- 特点:使用lambda关键字创建函数,没有名字,匿名函数冒号后面的表达式有且只有一个,注意:是表达式而不是语句
- 匿名函数自带return,而这个return结果就是表达式计算后的结果
- 通过变量调用匿名函数
- 缺点:lambda只能是单个表达式,不是一个代码块,仅仅能封装有限逻辑,复杂逻辑实现不了
test=lambda x,y:x+y
test(1,2) #3
#可以替换传统双分支
age=17
print('可以参军'if age>18 else '继续上学') #继续上学
testA=lambda x,y:x if x>y else y
testA(1,4) #4
res=(lambda x,y:x if x>y else y)(16,12)
print(res) #16
递归函数
- 如果一个函数在内部不调用其他的函数,而是自己本身的话,这个函数就是递归函数
- 满足的条件:自己调自己、必须有递归出口
- 缺点:容易导致栈溢出
- 优点:逻辑简单、定义简单
def func(n):
if n==1:
return 1
return n*func(n-1)
func(5) #120
import os
def findFile(file_Path):
listRs=os.listdir(file_Path)
for fileItem in listRs:
full_path=os.path.join(file_Path,fileItem)
if os.path.isdir(full_path):
findFile(full_path)
pass
else:
print(fileItem)
pass
pass
else:
return
pass
findFile('C:\\Users\Rainy_Universe\Desktop\大二春季学期')
Python内置函数
内置函数简介
- Python语言自带函数
数学运算函数
# 绝对值
abs(-10) #10
# 近似值
round(3.66) #4
round(3.66,1) #3.7
# 求指数
pow(2,4) #16
# 求最大值最小值
max(1,2,3,4,5) #5
max([1,2,3,4,5]) #5
min(1,2,3,4,5) #1
# 求和
sum((1,2,3,4),5) #15
sum(range(6)) #15
# 动态执行表达式
a,b,c=1,2,3
eval('a+b+c') #6
def hello():
print('hello')
pass
eval('hello()') #hello
类型转换函数
# 数字转字符
chr(65) #'A'
# 转为二进制
bin(10) #'0b1010'
# 转为十六进制
hex(32) #'0x20'
# 元组转为列表
tup=(1,2,3,4)
print(list(tup)) #[1, 2, 3, 4]
# 创建字典
dic=dict(name='潘小雷',age='20')
print(dic)
#{'name': '潘小雷', 'age': '20'}
# 转换为字节数组
bytes('潘小雷',encoding='utf-8')
# b'\xe6\xbd\x98\xe5\xb0\x8f\xe9\x9b\xb7'
序列操作
- all函致用于判断给定的可迭代参数iterable中的所有元素是否都为TRUE,如果是返回True,否则返回False,元素除了是0、空、FALSE外都算 TRUE(可迭代参数理解为元组或列表)
li=[1,2,3]
all(li) #True
list=[1,2,3,0]
all(list) #False
all([]) #True
all(()) #True
all([1,2,False]) #False
- any()函数用于判断给定的可迭代参数iterable是否全部为False,则返回False,如果有一个为True,则返回True。
- sorted()函数对所有可迭代的对象进行排序操作
(1)sort是应用在list上的方法,sorted可以对所有可迭代的对象进行排序操作
(2)list的sort方法返回的是对已经存在的列表进行操作,二内建函数sorted方法返回的是一个新的list,而不是在原来的基础上进行的操作
li=[2,45,1,67]
li.sort() # list的排序方法,直接修改原始对象
print(li) #[1, 2, 45, 67]
list=[1,45,87,24]
varList=sorted(list)
print(list) #[1, 45, 87, 24]
print(varList) #[1, 24, 45, 87]
varListA=sorted(list,reverse=True)
print(varListA) #[87, 45, 24, 1]
tupArray=(1,45,87,24)
varTuple=sorted(tupArray)
print(varTuple) #[1, 24, 45, 87]
- reverse()函数用于反向列表中的元素
- range()函数可创建一个整数列表,一般用于for循环中
- zip()函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的列表,如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同,利用*操作符,可将元组解压为列表
s1=['a','b','c']
s2=['你','我','他']
s3=['1','2','3','4']
print(zip(s1)) #<zip object at 0x000002449D301980>
print(list(zip(s1))) #[('a',), ('b',), ('c',)]
zipList=zip(s1,s2) #<zip object at 0x000001F1F8B835C8>
print(list(zipList)) #[('a', '你'), ('b', '我'), ('c', '他')]
zipListA=zip(s1,s3)
print(list(zipListA)) #[('a', '1'), ('b', '2'), ('c', '3')]
def printBookInfo():
books=[] #存储所有图书信息
id=input("请输入图书编号:每个项以空格分割")
bookName=input("请输入书名:每个项以空格分割")
bookPos=input("请输入位置:每个项以空格分割")
idList=id.split(' ')
nameList=bookName.split(' ')
posList=bookPos.split(' ')
bookInfo=zip(idList,nameList,posList)
for bookItem in bookInfo:
dictInfo={"编号":bookItem[0],"书名":bookItem[1],"位置":bookItem[2]}
books.append(dictInfo)
pass
for item in books:
print(item)
pass
printBookInfo()
# 请输入图书编号:每个项以空格分割1 2
# 请输入书名:每个项以空格分割书1 书2
# 请输入位置:每个项以空格分割位置1 位置2
# {'编号': '1', '书名': '书1', '位置': '位置1'}
# {'编号': '2', '书名': '书2', '位置': '位置2'}
- enumerate()函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在for循环中
listObj=['a','b','c']
for item in enumerate(listObj):
print(item)
pass
# (0, 'a')
# (1, 'b')
# (2, 'c')
for index,item in enumerate(listObj):
print(index,item)
pass
# 0 a
# 1 b
# 2 c
for index,item in enumerate(listObj,5):
print(index,item)
pass
# 5 a
# 6 b
# 7 c
dictObj={}
dictObj['name']='潘小雷'
dictObj['age']='20'
for index,item in enumerate(dictObj):
print(index,item)
# 0 name
# 1 age
内置函数set
- set集合也是Python中的一种数据类型,是一个无序且不重复的元素集合
- 集合操作函数
# 创建
set1={1,2}
print(set1)
listA=[1,2,3]
set2=set(listA)
print(set2)
# {1, 2}
# {1, 2, 3}
# 添加
set1.add('Python')
print(set1)
# {1, 2, 'Python'}
# 清空
set2.clear()
print(set2)
# set()
# 取差集
a={1,2,3,4,5}
b={1,2,4,6,7}
c=a.difference(b)
print(c)
# {3, 5}
# 取交集
print(a.intersection(b))
# {1, 2, 4}
# 取并集
print(a.union(b))
# {1, 2, 3, 4, 5, 6, 7}
# 取出数据并删除
a.pop()
print(a)
# {2, 3, 4, 5}
# 移除指定数据
a.discard(3)
print(a)
# {2, 4, 5}
# 更新
a.update(b)
print(a)
# {2, 1, 4, 5, 6, 7}