day5Python

一、不定长参数

也就是传入的参数的个数不固定

(1)以元组的形式去接收 *参数名(任意数量的实参)

主体结构:
def 函数名(*args)：(args可以随意取)
pass
实例:

def demo(*args)：
  print(args)
  print(type(args)) #都为tuple
#demo(1,2,3,4) #(1,2,3,4)
demo(1)# (1,)
demo() #（）空元组

(2)以字典的形式去接收不确定实参 **kwargs（任意数量的关键实参）

主体结构:
def 函数名(**kwargs):
pass
函数名（x=1,y=2,z=3）
实例:

def demo(**kwargs):
    print(kwargs)  #{'x': 1, 'y': 2, 'z': 3, 'a': 4}
    print(type(kwargs))  #<class 'dict'>
demo(x=1,y=2,z=3,a=4)

(3)将参数为字典的值变为关键字参数传入函数 **实参名

主体结构:
def 函数名（kwargs）：
pass
myDict = {'x':1,'y':2}
函数名（myDict）
实例

def func(**kwargs):
  print(kwargs)
myDict = {'x':1,'y':2}
func(**myDict)

(4)*args 和 **kwargs的组合

主体结构:
def 函数名（args,kwargs）:
pass
注意：
1.args和kwargs的实参可传可不传 不传的话为空元组 空字典
2.args 和*kwargs的实参 可以对某个不进行传参 某个不传参数的为空元组或空字典
实例:

def func(*args,**kwargs):
  print(args)
  print(kwargs)
func(x=1,y=2) # () {'x':1,'y':2}

二、可变类型和不可变类型

可变类型（可以修改,删除）:如：列表，字典 在函数内修改变量的值，外部也会发生改变。
不可变类型:如:整数,字符串,元组 在函数内部进行修改的时候，其实是创建一个一个同名的局部变量。
可变类型实例

myDict = {'name':'张三','age':18} #全局变量
def updateType():
    print(myDict)
    x = 1       #局部变量
    myDict['name'] = '哈利波特' #修改全局变量 只是在其内部的一部分值被修改，并没有对name对应的值进行整体赋值。
    print(myDict)
updateType() #{'name': '张三', 'age': 18} {'name': '哈利波特', 'age': 18}
# print(x) #error 获取不到函数内部的局部变量
print(myDict) #{'name': '哈利波特', 'age': 18}

myDict = {'name':'张三','age':18}
def updateType():
    # print(myDict)  #error 获取不到
    myDict = {'name':'李四'} #创建了局部变量，函数外部获取不到
    print(myDict) #{'name': '李四'}
updateType()
print(myDict) #{'name': '张三', 'age': 18}

不可变类型实例

myStr = 'abcd'
def demo():
    print(myStr) #abcd
    print(id(myStr)) #37499072
    # myStr = 'a' #创建一个局部变量myStr
    # print(id(myStr)) #4855808 打印局部变量myStr的存储地址
demo()
print(id(myStr))#37499072 打印全局变量myStr的存储地址

myStr = 'abcd'
def demo():
    myStr = 'a'
    print(myStr)  #a
    print(id(myStr)) #8656896 局部变量的myStr存储地址
demo()
print(myStr) #abcd
print(id(myStr)) #35139776 全局变量的myStr的存储地址

三、变量的作用域

全局变量：在函数外部定义的变量称为全局变量。
局部变量:在函数内部定义的变量称为局部变量
注意:
1.在函数内部可以获取到函数外部定义的全局变量
2.在函数外部不可以获取到函数内部定义的局部变量
3.我们所学过的if else while for 定义的变量都为全局变量

(1)在函数外部定义的全局变量函数内外部都可以获取

myStr = 'abcd'
def demo():
  print(myStr) #abcd
demo()

(2)在函数内部定义的变量称为局部变量，函数外部不能获取到

def demo():
  myStr = 'a'
  print(myStr) #a
demo()
print(myStr) #nameError

(3)global 关键字 将变量声明为函数内外使用的同一个 可以在函数对变量的值进行整体修改

myInt = 10
def demo():
  global myInt
  myInt = 20
demo()
print(myInt) #20

将局部变量声明为全局变量
实例

#函数内部 是否可以声明 局部变量为全局变量  -----函数内外都可以拿到
def func():
  global age #将局部变量声明为全局变量
  age = 18
func()
print(age) #18

(4)nonlocal关键字 当函数发生多层嵌套时，将函数外层和里面的变量声明为同一个变量

要修改嵌套作用域(向上一层的外层，非全局作用域)中的变量则需要使用

name = '张三'
def a():
    name = '李四'
    def B():
        name = '王五'
        def c():
            nonlocal name #如果找不到nonlocal后面的变量名 报错
            name = '赵六'
            print('我是函数c',name) #我是函数c 赵六
            def d():
                print('我是函数d',name) #我是函数d 赵六
            d()
        c()
        print('我是函数B',name)  #我是函数B 赵六
    B()
    print('我是函数a',name)#我是函数a 李四
a()
print(name) #张三

四、lambda表达式(匿名函数)

关键字 lambda
注意:
1.lambda 为一个表达式，函数结构要比def定义的函数结构简单很多
2.lambda 的主体为表达式，不是代码块，只能封装有限的逻辑
主体结构:
变量名 = lambda[形参]:代码，其中变量名内容为函数地址(类似)

(1)没有任何参数的lambda的表达式

#没有任何参数的lambda的表达式
func = lambda:print('我是一个lambda表达式')
print(func) #func为函数地址 <function <lambda> at 0x02105150>
func() #我是一个lambda表达式 (调用函数)

(2)返回值

#值的返回
a = 10
func = lambda:a
print(func())  #10

(3)形参

func = lambda x,y :x+y  # x,y 为形参
print(func(1,2)) #3

(4)形参默认值

#形参默认值
func = lambda x = 1,y = 2: x+y #x,y 为形参
print(func()) #3
print(func(y=3,x=4)) #关键字参数 7

(5)定义并调用(自调用)

(lambda x,y:x+y) (1,2)

五、函数导入的方式

from 库名 import 包名
from 库名 import 包名 as 别名
from 库名.包名 import 方法1,方法2,... ...
import 包名 as 别名
name:系统属性 可以在包被引入的时候，可以判断当前程序执行是否在主文件里，在主文件里值为main
作用:在运行时检测该模块是被导入还是直接执行，如果模块是导入，name的值为模块名字；如果是被直接执行，name的值为"main"。
注意:
1.不要将包或者库的名字中存在数字，起一个规范的有意义的字母的名字
2.如果模块包含的属性和方法与你的某个模块同名，你必须使用import module 来避免名字冲突

六、装饰器(回调函数)

概念:在代码运行期间 动态地添加功能 称之为装饰器

l = input('请输入你的年龄')
def demo(arg):
    def inner(age):
        if age<=10:
            myStr = '儿童'
        elif age<= 20:
            myStr = '青年'
        elif age<=50:
            myStr = '中年'
        else:
            myStr = '老年'
        arg(myStr)
    return inner
@demo 
def mySpeak(person):
    print('你是一个{}年龄段的人'.format(person))
mySpeak(int(l))

七、列表推导式

概念:提供了快速生成列表的方式，列表推导式(生成式)总是返回一个列表

将
myList = [
    [1,2,3,4],
    [5,6,7,8],
    [9,10,11,12]
]
#变成
# myList = [
#     [1,5,9],
#     [2,6,10],
#     [3,7,11],
#     [4,8,12]
# ]
# #使用拆分的写法 变成 4*3 矩阵
newList = []
for i in range(4):
    # print(i)
    newList1= []
    for row in myList:
        # print(row[i])
        newList1.append(row[i])
    newList.append(newList1)
print(newList)
# #使用列表推导式变成  4*3 矩阵
 newList = [[row[i] for row in myList] for i in range(4)]
 print(newList)