10.16学习日志

标签：函数 形参 学习 变量 print 日志 字典 def 10.16

一.Python函数

1. 定义一个函数

• 什么是函数

  • 函数是可以重复执行的语句块，可以重复调用

• 作用

  用于封装语句块, 提高代码的重用性。

• 函数是面向过程编程的最小单位

1.1 def 语句

• 作用

  用来定义（ 创建）函数

• 语法

• 说明

  1. 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()

  2. 函数名是一个变量，不要轻易对其赋值

  3. 函数有自己的名字空间，在函数外部不可以访问函数内部的变量，在函数内部可以访问函数外部的变量，但不能轻易对其改变

  4. 函数的形参列表如果不需要传入参数，形式参数列表可以为空

  5. 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。

  6. 函数内容以冒号 : 起始，并且缩进。

  7. return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。

"""
函数创建
"""
# 无参数

def ttk():
    print("mmkdsmcs")

ttk()

# 有参数

def count1(count):
    for i in range(count):
        print(i)

count1(2)

# return
def qiuhe(x,y):
    sum1 = x + y
    return sum1

1.2 函数的调用

• 语法

  函数名(实际调用传递参数)

• 说明

  • 函数调用是一个表达式

  • 如果函数内没有return 语句，函数执行完毕后返回 None 对象

1.3 return 语句

 语法

• return [表达式]
  ​​​​​​注: [] 代表 内部的内容可以省略

• 作用

  用于函数的内部，结束当前函数的执行，返回到调用此函数的地方，同时返回一个对象的引用关系

• 说明

  1. return 语句后面的表达式可以省略，省略后相当于 return None

  2. 如果函数内部没有 return 语句, 则函数执行完毕后返回None, 相当于在最后一条语句后有一条return None

"""
函数内return执行之后后面的语句都不会执行
"""
re = qiuhe(3,4)
print(re)

2. 函数参数

2.1 函数的调用传参

• 位置传参

  实际参数传递时，实参和形参按位置来依次对应

• 关键字传参

  实际参数传递时，实参和形参 按名称依次对应

• 注: 位置传参要先于关键字传参

  """
      函数参数
          实际参数（调用参数） 实参
              位置参数
                  序列实参：使用星号将序列拆分后，与形参进行对应
              关键字参数
                  字典实参
  
          形式参数
              默认形参
              位置形参
                  星号元组形参
              命名关键字形参
                  双星号字典形参    
  
  """
  def dayin(a,b,c):
      print(a)
      print(b)
      print(c)
  # 位置传参
  dayin(1,2,3)
  # 关键字传参
  dayin(a = 1,c = 3,b = 2)
  # 序列实参
  list1 = [2,1,3]
  dayin(*list1)
  # 字典实参：使用双星号将字典拆分后，依次与形参对应
  dict1 = {"c":3,"b":2,"a":1}
  dayin(**dict1)
  

2.2 函数的形式参数定义方法

函数的缺省参数（默认参数）

语法

def 函数名(形参名1=默认实参1, 形参名2=默认实参2, ... ):
     语句块

说明

缺省参数即默认实参，必须自右向左依次存在(即,如果一个参数有缺省参数，则其右侧的所有参数都必须有缺省参数)

形参的定义

• 位置形参

• 星号元组形参(*args)

• 命名关键字形参

• 双星号字典形参（**kwargs）

1）位置形参

• 语法:

  def 函数名(形参名1, 形参名2, ...):
      pass

2）星号元组形参

• 语法

  def 函数名(*元组形参名):
      pass

• 作用

  收集多余的位置实参

• 元组形参名一般命名为args

3）命名关键字形参

• 语法

  def 函数名(*, 命名关键字形参1, 命名关键字形参2, ...):
      pass
  # 或者
  def 函数名(*args, 命名关键字形参1, 命名关键字形参2, ...):
      pass

• 作用

  强制，所有的参数都必须用关键字传参

4）双星号字典形参

• 语法

  def 函数名(**kwargs):
      pass

• 作用

  收集多余的关键字传参

• 注意：
  字典形参名最多有一个，

  字典形参名 一般命名为 kwargs

函数的形参定义方法说明

• 位置形参，星号元组形参，命名关键字参数，双星号字典形参，缺省参数可以混合使用。

• 函数的形参定义自左至右的顺序为：位置形参，星号元组形参，命名关键字参数，双星号字典形参

  """
      形参
  """
  # 默认参数:不能放在前面，出现一个之后后面的全部都必须是默认参数
  
  def dayin1(a,b = None,c = 0):
      print(a)
      print(b)
      print(c)
  
  dayin1(1)
  
  # 星号元组形参：将位置实参合并为一个元组
  # 通用写法 *args
  
  def dayin2(*args):
      print(*args)
  
  dayin2(4,6,6,5,6)
  
  # 双星号字典形参:收集所有的传入参数，打包成字典的形式
  # 通用写法 **kwargs，输出时把kwargs当做字典
  
  def dayin3(**kwargs):
      print(kwargs)
  
  dayin3(a=1,b=2,c=3)
  
  def dayin4(*args,**kwargs):
      print(*args)
      print(kwargs)
  
  dayin4(1,3,a = 1,b = 4)
  
  # 命名关键字形参：强制，所有的参数都必须用关键字传参
  
  def myfunc4(a, b,*args, c, d):
      print(a, b, c, d)
  
  myfunc4(1, 2, d=4, c=3)   # 正确,c,d 必须关键字传参
  # myfunc4(1, 2, 3, 4)   # 错误
  

2.3 可变不可变

可更改(mutable)与不可更改(immutable)对象

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

• 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变 a 的值，相当于新生成了 a。

• 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python 函数的参数传递：

• 不可变类型：值传递: 如整数、字符串、元组。如 fun(a)，传递的只是 a 的值，没有影响 a 对象本身。如果在 fun(a) 内部修改 a 的值，则是新生成一个 a 的对象。

• 可变类型：引用传递: 如 列表，字典。如 fun(la)，则是将 la 真正的传过去，修改后 fun 外部的 la 也会受影响

python 中一切都是对象(后面会讲)，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

3. 返回值

函数可以使用return语句来返回一个或多个值。

如果没有明确的return语句，函数将默认返回None。

4. 匿名函数

在Python中，匿名函数通常使用lambda关键字来创建。匿名函数也被称为lambda函数，它是一种简单的、一行的函数，常用于临时需要一个小函数的地方。匿名函数的语法如下：

• 语法

  lambda  [函数的参数列表]: 表达式

• 作用

  • 创建一个匿名函数对象

  • lambda是关键字，表示你正在定义一个匿名函数。

  • 同 def 类似，但不提供函数名

  • [函数的参数列表]是函数的参数，可以有零个或多个参数，参数之间用逗号分隔。

  • : 表达式是函数的返回值，通常是一个表达式，匿名函数会计算这个表达式并返回结果。

• 说明

  lambda 表达式 的创建函数只能包含一个表达式

# 匿名函数：也被称为lambda函数，一种简单的、一行的函数，常用于临时需要一个小函数的地方。

chengji = lambda x,y: x*y
print(chengji(2,4))

re = lambda x,y:x+y
print(re(5,7))

5. 变量作用域

5.1 什么是变量作用域

一个变量声明以后,在哪里能够被访问使用,就是这个变量"起作用"的区域:也就是这个变量的作用域

一般来说,变量的作用域,是在函数内部和外部的区域 来体现,因此常常与函数有关

5.2 局部变量和全局变量

• 局部变量

  • 定义在函数内部的变量称为局部变量(函数的形参也是局部变量)

  • 函数内部的变量只能在函数内部或者函数内部的函数内部访问 ，函数外部不能访问

  • 局部变量在函数调用时才能够被创建，在函数调用之后会自动销毁

• 全局变量

  • 定义在函数外部，模块内部的变量称为全局变量

  • 全局变量, 所有的函数都可以直接访问(取值,但函数内部不能直接将其赋值改变)

5.3 局部作用域修改全局变量

• 作用

  告诉python 的解释执行器， global 语句声明的一个或多个变量， 这些变量是全局变量

• 语法

  global 变量名1, 变量名2, ....
  

• global 说明

  • 全局变量如果要在函数内部被赋值，则必须经过全局声明 global

  • 默认全局变量在函数内部可以使用，但只能取值，不能赋值

  • 不能先声明为局部变量，再用 global 声明为全局变量，此做法不符合语法规则

• 函数的形参已经是局部变量，不能用 global 声明为全局变量

"""
    变量作用域:LEGB
"""

#全局变量
a = 100
def fun01():
    def fun02():
        a = 10
        print(a)

    fun02()

fun01()

# 在函数内部修改全局变量:global

print(a)

def fun03():
    global a
    a = 1000

fun03()
print(a)

# 外部嵌套作用域
def func01():
    a = 10
    def func02():
        # 内部函数,可以访问外部嵌套变量
        # print(a)
        # 内部函数,如果修改外部嵌套变量,需要使用nonlocal语句声明
        nonlocal a
        a = 20

    func02()
    print(a)

func01()

def fun01(data1,data2):
    data1 = 10
    data2[0] = 200

a = 20
b = [1,2,3]
fun01(a,b)
print(a,b)

5.4 局部作用域修改外部变量

在函数内部 提前用nonlocal声明 函数内部的某个变量为外部的变量

前提：必须是函数嵌套

说明：

（1）变量的查找顺序还是遵从：LEGB顺序

在 Python 中，LEGB 代表四种作用域的查找顺序：Local、Enclosing、Global 和 Built-in。

（2）局部作用域中若要修改外部函数嵌套作用域中的变量需要使用：nonlocal 语句

• 格式：nonlocal 变量名

• 作用：将局部作用域中变量声明为外部函数嵌套作用域中的变量。

LEGB顺序

Local (L):

• 本地作用域，指当前函数内部的变量。

• 当你在函数内部定义变量并尝试访问它时，Python 首先会在函数内部查找这个变量。

Enclosing (E):

• 闭包函数外的函数作用域，指嵌套函数的外部函数中定义的变量。

• 如果在当前函数内部找不到变量，Python 会查找外层（闭包）函数中的变量。

Global (G):

• 全局作用域，指模块级别定义的变量。

• 如果在本地和闭包函数中找不到变量，Python 会查找全局作用域的变量。

Built-in (B):

• 内建作用域，指 Python 预定义的变量、函数等，如 len、sum 等。

• 如果在以上三个作用域中都找不到变量，Python 会查找内建作用域。

nonlocal：内部函数,如果修改外部嵌套变量,需要使用nonlocal语句声明

6. 函数的内存分配

1、将函数的代码存储到代码区，函数体中的代码不执行。

2、调用函数时，在内存中开辟空间（栈帧），存储函数内部定义的变量。

3、函数调用后，栈帧立即被释放。

(1) 不可变类型参数有:

• 数值型(整数，浮点数)

• 布尔值bool

• None 空值

• 字符串str

• 元组tuple

(2) 可变类型参数有:

• 列表 list

• 字典 dict

• 集合 set

(3) 传参说明：

• 不可变类型的数据传参时，函数内部不会改变原数据的值。

• 可变类型的数据传参时，函数内部可以改变原数据。

7. 函数自调用(递归)

• 函数直接或间接的调用自身

说明：

• 递归一定要控制递归的层数，当符合某一条件时要终止递归调用

• 几乎所有的递归都能用while循环来代替

递归的实现方法：

• 先假设此函数已经实现

递归优缺点：

• 优点：

  • 递归可以把问题简单化，让思路更为清晰,代码更简洁

• 缺点：

  • 递归因系统环境影响大，当递归深度太大时，可能会得到不可预知的结果

"""
    递归
    计算阶乘
    非递归思修
    递归思想
"""
def nodigui(n):
    result = 1
    i = 1
    while i<=n:
        result *=i
        i += 1
    return result

print(nodigui(10))

def digui(n):

    # 递归边界，返回条件是什么
    if n == 1:
        return 1

    # 调用自己
    result = n * digui(n-1)
    return  result

print(digui(10))

 二.API复习

del  a 删除变量a
1.字符串 API
str.count(x) 统计字符串x在字符串str中出现的次数
str.split(x) 以x为分隔符将字符串str分割
center（x）将x居中         # center（width，x）
str.join(x) 以x为连接符将str中的每个字符连接起来
str.strip() 执行rstrip()和lstrip()操作，删除字符串两边的空格\t,\r,\n或指定字符。
len(str) 返回字符串的长度
str.replace(old,new，max)将字符串中的某个字符换成新的字符，max为最大次数
str.upper() 将字符串str变成大写
str.lower() 将字符串str变成小写
# str.find（x，beg = 0，end = len(string)）检查x是否在str中,如果包含则返回第一个位置的索引值，否则返回-1
# str.index（x，beg = 0，end = len(string)）同上，只不过不包含会报错
# max（str） min （str）

2.列表API
list.append（x）将x添加到列表list的末尾
list.count(x) 统计某个元素在列表中出现的次数
list.remove（）删除列表的一个元素
list.clear（）清空列表
list.pop(i) 将列表中的第i个元素删除，默认为最后一个
len(list)
list.copy()复制列表
list(seq)将元组转换为列表
# max(list) min(list)
# list.extend(seq)在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
# list.index(obj)从列表中找出某个值第一个匹配项的索引位置
# list.insert(index, obj)将对象插入列表
# list.reverse()反向列表中元素
# list.sort( key=None, reverse=False)对原列表进行排序: x.sort(key=lambda a:abs(a-3), reverse=False)

3.字典API
dict.pop(key)删除字典 key所对应的值，返回被删除的值。
dict.clear()
dict.copy()
# dict.items()以列表返回一个视图对象
# dict.keys()返回一个视图对象
# dict.values()返回一个视图对象
# key in dict如果键在字典dict里返回true，否则返回false
# dict.get(key, default=None)返回指定键的值，如果键不在字典中返回 default 设置的默认值
# dict.setdefault(key, default=None)和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
# dict.update(dict2)把字典dict2的键/值对更新到dict里
# popitem()返回并删除字典中的最后一对键和值。
# dict.fromkeys(seq)创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值

4.集合API
set.add(x)将x添加到集合set中 
set.remove(x)删除集合的一个元素x
set.clear()清空集合
set.copy()
#difference_update()移除集合中的元素，该元素在指定的集合也存在。
#discard()删除集合中指定的元素
# difference() 返回多个集合的差集 
# difference_update()    移除集合中的元素，该元素在指定的集合也存在。              
# intersection()  返回集合的交集                                              
# intersection_update()    返回集合的交集。                                            
# isdisjoint()  判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
# issubset()  判断指定集合是否为该方法参数集合的子集。                
# issuperset() 判断该方法的参数集合是否为指定集合的子集                  
# pop()  随机移除元素                                                                    
# symmetric_difference()   返回两个集合中不重复的元素集合。
# symmetric_difference_update() 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
# union()  返回两个集合的并集         
# update()  给集合添加元素               
# len()   计算集合元素个数    

 三.函数总结

 函数
    定义（创建）
        def 函数名（形参）：
            表达式
        形参
            1.默认参数：形参处直接赋值，实参有传入则覆盖，无则用默认值
            2.命名关键字形参：def 函数名(*或者*args, 命名关键字形参1, 命名关键字形参2, ...)：
            2.*args列表传参 ：可接收不定长的位置参数
            3.**kwargs：可接收不定长的关键字参数    
    调用    
        实参
            1.位置实参：函数名（1,2,3）按顺序
            2.关键字实参：函数名（a = 1，b = 2）
            3.序列实参：可传入序列依次与形参对应 函数名（*序列名）
            4.字典实参：可传入字典依次与形参对应    函数名（**字典名）
    返回值
        return 可有可无，没有时返回None，执行后函数后面语句不执行
    匿名函数
        函数名不可调用 简洁
        lambda 参数: 表达式 :re = lambda x,y: x+y 
        re(1,2)    
    变量 作用域
        全局变量：外面没有函数体，全局生效，不能被内部函数直接修改，内部修改要用global声明后
        局部变量：函数内部生效，函数执行完毕就释放
        查找规则：L(本地)E(嵌套函数)G(全局)B(内置)
        nonlocal：嵌套函数内部改外部变量
    内存分割：
        创建函数是放在代码区，调用时开辟栈帧，函数执行结束后栈帧会释放
        不可变类型（不能直接修改）：数字，字符串，元组，布尔值
        可变类型（可以直接修改，函数内部修改后外部调用时为修改后的）：    列表，集合，字典
    递归调用
        def jiecheng(n):
            if n == 1:
                return 1
            all = n*jiecheng(n-1)
            return all
        print(jiecheng(10))

 

标签：函数,形参,学习,变量,print,日志,字典,def,10.16
From： https://blog.csdn.net/m0_74998557/article/details/142989771