Python编程基础

Posted 2021-08-30 雨宙

Python编程基础（二）

打卡第二天啦！！！

函数

初识函数

1. 什么是函数：函数是一系列Python语句的组合，可以在程序中运行一次或多次，一般是完成具体的独立的功能
2. 为什么要使用函数：代码复用最大化
3. 函数定义：
   def 函数名（参数列表）：
     函数体
4. 函数的调用：本质上是去执行函数定义里面的代码块，在调用函数之前必须先定义

# 函数的定义
'''
打印个人信息
'''
def person_info(name,age):
    # 函数代码块
    print('姓名：{}'.format(name))
    print('年龄：{}'.format(age))
    pass
# 函数的调用
person_info('潘小雷',20)
person_info('鲸鱼',20)
# 姓名：潘小雷
# 年龄：20
# 姓名：鲸鱼
# 年龄：20

函数参数

1. 参数分类：必选参数、默认参数[缺省参数]、可选参数、关键字参数
2. 参数：函数为了实现某项特定的功能，进而为了得到实现功能所需要的数据
3. 必选参数：

def sum(a,b): #a和b为形式参数，知识意义上的参数，在定义的时候不占内存地址
    sum=a+b
    print(sum)
    pass
# 函数调用，必选参数在调用的时候必选参数是必须要赋值的
sum(1,2) #实际参数，是实际占用内存地址的

4. 默认参数：
   注：默认参数始终存在于参数列表的尾部

# 默认参数始终存在于参数列表的尾部
def sum1(a=20,b=30):
    print('sum={}'.format(a+b))
    pass
# 默认参数调用 在调用的时候如果未赋值，就会用定义函数时给定的默认值
sum1()
sum1(10)
sum1(10,10)
# sum=50
# sum=40
# sum=20

5. 可选参数：
   （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

6. 关键字参数：
   （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'}

函数返回值

1. 概念：函数执行完会返回一个对象，如果在函数内部有return，就可以返回实际的值，否则返回None
2. 类型：可以返回任意类型，返回值类型应该取决于return后面的类型
3. 用途：给调用方返回数据
4. 在一个函数体内可以出现多个return，但是肯定只能返回一个return
5. 如果在一个函数体内，执行了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. 根据函数的返回值和函数的参数可以将函数进行分类：
   （1）有参数无返回值的
   （2）有参数有返回值的
   （3）无参数有返回值的
   （4）无参数无返回值的

全局变量和局部变量

局部变量

1. 在函数内部定义的变量，作用域仅仅局限在函数的内部
2. 不同的函数可以定义相同的局部变量，之间不会产生影响
3. 作用：为了临时地保存数据，需要在函数中定义来进行存储

全局变量

1. 当全局变量和局部变量出现重复时，程序会优先执行使用函数内部定义的变量
2. 使用global关键字在函数内部修改全局变量

函数参数引用传值

1. 在函数调用时，实参传递的是对象的引用
2. 参数传递是通过对象引用来完成的，注意可变类型和不可变类型的区别

# 不可变类型
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]]

匿名函数

1. 语法：lambda 参数1、参数2…：表达式
2. 特点：使用lambda关键字创建函数，没有名字，匿名函数冒号后面的表达式有且只有一个，注意：是表达式而不是语句
3. 匿名函数自带return，而这个return结果就是表达式计算后的结果
4. 通过变量调用匿名函数
5. 缺点：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

递归函数

1. 如果一个函数在内部不调用其他的函数，而是自己本身的话，这个函数就是递归函数
2. 满足的条件：自己调自己、必须有递归出口
3. 缺点：容易导致栈溢出
4. 优点：逻辑简单、定义简单

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内置函数

内置函数简介

1. 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'

序列操作

1. 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

2. any()函数用于判断给定的可迭代参数iterable是否全部为False，则返回False，如果有一个为True，则返回True。
3. 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]

4. reverse()函数用于反向列表中的元素
5. range()函数可创建一个整数列表，一般用于for循环中
6. 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'}

7. 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

1. set集合也是Python中的一种数据类型，是一个无序且不重复的元素集合
2. 集合操作函数
   

# 创建
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}