python基础day10笔记

最新推荐文章于 2020-11-24 11:45:09 发布
最新推荐文章于 2020-11-24 11:45:09 发布
阅读量1k 收藏 1
点赞数 1
分类专栏： python基础20课时 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42584444/article/details/81057832
版权

2018.7.13

day09回顾:
传参
把数据传递给函数

    传递方式:

  • 位置传参
  • 序列传参
  • 关键字传参
  • 字典关键字传参

  形参:
      把调用函数的实参拿到(接收实参)
      形参的定义方式有四种:

  • 位置形参
  • *元组形参(接收多余的位置传参)
  • 命名关键字形参(强制必须使用关键字传参)
  • ** 字典形参(接收多余的关键字传参)

函数的缺省参数 default argument  
        def fx(a, b=0, c=100):
            pass

全局变量  和 局部变量 

在函数内赋值语句
   变量 = 表达式

day10

globals() / locals()函数:

  • globals() 返回当前全局作用域内变量的字典
  • locals()  返回当前局部作用域内变量的字典

示例见:
 

# globals_locals.py


a = 1
b = 2
c = 3


def fn(c, d):
    e = 300
    # 此处有几个局部变量
    print("locals() 返回:", locals())
    print("------------------------")
    print("globals()返回:", globals())
    print("局部变量c的值是:", c)
    print("全局的变量的c的值是:", globals()['c'])


fn(100, 200)
print('===========================')
print("全局的 globals() 返回: ", globals())

函数变量
  函数名是变量，它在def 语句创建函数时绑定一个函数

示例见:
 

def fa():
    print("hello world")


f1 = fa  # <<<---这里没有括号，f1 变量绑变的是函数
f1()  # 调用 fa绑定的函数
fa()  # 调用 fa绑定的函数
# 此示例示意函数变量的赋值
def f1():
    print("hello")


def f2():
    print("world")


f1, f2 = f2, f1

f1()  # world
f2()  # hello

一个函数 可以作为另一个函数的实参传递
示例1:

def f1():
    print("f1被调用")


def f2():
    print("f2被调用")


def fx(fn):
    print(fn)
    fn()  # 此时这是调用什么呢？


fx(f1)
fx(f2)

示例1:

def goodbye(L):
    for x in L:
        print("再见:", x)


def hello(L):
    for x in L:
        print("你好:", x)


def operator(fn, L):
    fn(L)


operator(hello, ['Tom', 'Jerry', 'Spike'])

#你好：Tom
#你好：Jerry
#你好：Spike

看懂如下代码:

def myinput(fn):
    L=[5,3,1,9,7]
    return fn(L)
print(myinput(max))   #9
print(myinput(min))   #1
print(myinput(sum))   #25
print(myinput(len))   #5

函数可以作为另一个函数的返回值
  示例见:
 

def fx():
    return max


fn = fx()
print(fn([1, 3, 5, 7]))


函数的嵌套定义
  函数嵌套定义是指一个函数里用def语句来创建其它的函数的情况

  示例:

def fn_outter():
    print("fn_outter被调用")
    def fn_inner():
        print("fn_inner被调用")
    fn_inner()
    fn_inner()
    print("fn_outter调用结束")

fn_outter()

#fn_outter被调用
#fn_inner被调用
#fn_inner被调用
#fn_outter调用结束

示例2：

# return_function2.py

def get_op():
    s = input("请输入您要做的操作: ")
    if s == '求最大':
        return max
    elif s == '求最小':
        return min
    elif s == '求和':
        return sum


L = [2, 4, 6, 8, 10]
print(L)
f = get_op()
print(f(L))


练习:
  写一个计算公式的解释执行器
    已知有如下一些函数：
        def myadd(x, y):
            return x + y
        def mysub(x, y):
            return x - y
        def mymul(x, y):
            return x * y
    写一个函数，传入字符串，返回相应的函数
        def get_op(s):
            # 此函数根据字符串来返回相应的函数.
            # 如果传入字符串"加" 则返回myadd函数
            # ....        '乘',则返回mymul函数
            ... 此处自己实现 
    主程序如下:
        while True:
          s = input("请输入计算公式: ")# 10 加 20
          L = s.split()
          a = int(L[0])
          b = int(L[2])
          fn = get_op(L[1])
          print("结果是:", fn(a, b))  # 30

def get_op(s):
    def myadd(x, y):
        return x + y

    def mysub(x, y):
        return x - y

    def mymul(x, y):
        return x * y

    # 此函数根据字符串来返回相应的函数.
    # 如果传入字符串"加" 则返回myadd函数
    # ....        '乘',则返回mymul函数
    if s == '加' or s == '+':
        return myadd
    elif s == '乘' or s == '*':
        return mymul
    elif s == '减' or s == '-':
        return mysub


while True:
    s = input("请输入计算公式: ")  # 10 加 20
    L = s.split()
    a = int(L[0])
    b = int(L[2])
    fn = get_op(L[1])
    print("结果是:", fn(a, b))  # 30

python 的作用域
  作用域也叫名字空间，是访问变量时查找变量名的范围空间

python的四个作用域:
 

  作用域                       英文解释             英文缩写
局部作用域(函数内)           Local(function)            L
外部嵌套函数作用域           Enclosing function locals  E
函数定义所在模块(文件)作用域  Global(module)             G
Python内建模块的作用域       Builtin(Python)            B

示例见:

v = 100


def f1():
    v = 200
    print("f1.v =", v)

    def f2():
        v = 300
        print('f2.v =', v)
    f2()


f1()
print('v =', v)

#f1.v 200
#f2.v 300
#v= 100

变量名的查找规则
  在变量访问时，先查找本地变量，然后是包裹此函数外部的函数内部的变量，之后是全局变量，最后是内建变量
    即：
      L ----> E ----> G ----> B
    在默认的情况下，变量名赋值会创建或者改变当前作用域的变量


global 语句
  作用:
    1. 告诉解释执行器 global 语句声明的一个或多个变量，这些变量的作用域为模块级的作用域，也称作全局变量
    2. 全局声明(global)将赋值语句操作的变量映射到模块文件内部的作用域

  语法:
    global 变量1, 变量2, ...
  示例见:

v = 100


def fn():
    global v  # 声明v是全局，此时不允许在此作用域存在v
    v = 200  # 想让此语句去修改全局作用域内的变量v
    print('fn内的v =', v)


fn() #fn内的v =200
print("v=", v)  # v = 200  #不加global，v=100

示例2：

# global2.py


# 2. 全局变量在函数内部不经过声明就可以直接访问
#    (变量已经存在并关联一个对象)
def fn():
    n = v
    print(n)


v = 100
fn()

#100

示例3：

# 3. 不能先声明局部变量，再用global声明为全局变量，
# 此做法不附合规则
v = 100

def fn():
    v = 200  # 创建局部变量
    global v  # 此时至少是警告(不建议这样写)
    v = 300
    print(v)

fn()
print('v=', v)

示例4：

# 4. global变量列表里的变量名不能出现在此作用域的形
#     参列表里
v = 100


def fx(v):
    # global v  # 此处会出错 SyntaxError: name 'v' is parameter and global
    print(v)  # 请问打印多少?


fx(200)  #200
print('v=', v)  # v=100


  说明:
    1. 全局变量如果要在函数内部被赋值，则必须经过全局声明（否则会被认为是创建局部变量)
    2. 全局变量在函数内部不经过声明就可以直接访问(变量已经存在并关联一个对象)
    3. 不能先声明局部变量，再用global声明为全局变量，此做法不附合规则
    4. global变量列表里的变量名不能出现在此作用域的形参列表里


练习:
  写一个函数叫hello(name),部分代码如下:
  count = 0
  def hello(name):
      print('你好', name)
      ... 此处代码省略,需要同学们自己填写
      ... 此处代码需要改变全局变量来记录此函数曾经被调用过多少次.
  
  hello('小张')
  hello('小李')
  print('hello 函数被调用', count, '次')  # 2次

count = 0  # 此变量用于记录hello函数调用的次数


def hello(name):
    print('你好', name)
    global count
    count += 1  # count = count + 1


hello('小张')
hello('小李')
print('hello 函数被调用', count, '次')  # 2次

nonlocal 语句
  作用:
    告诉解释执行器，nonlocal声明的变量不是局部变量，也不是全局变量，它是外部嵌套函数内的变量

  语法:
    nonlocal 变量名1, 变量名2, ....
  示例见:

# nonlocal.py


# 此示例示意nonlocal 声明语句的用法
var = 100


def outter():
    var = 200
    print("outter内的var=", var)

    def inner():
        nonlocal var
        var = 300
        print("inner内的var=", var)
    inner()
    print("outter结束时的var=", var)

outter()
print('全局的var=', var)

#outter内的var=200
#inner内的var=300
#outter内的var=300
#全局的var=100
#++++++++++++++++++++++++++++++++++++++++++++++

#把nonlocal var改成global var
#var = 100
#def outter():
#    var = 200
#    print("outter内的var=", var)
#
#    def inner():
#        global var
#        var = 300
#        print("inner内的var=", var)
#    inner()
#    print("outter结束时的var=", var)

#outter()
#print('全局的var=', var)

#outter内的var=200
#inner内的var=300
#outter内的var=200
#全局的var=300

示例2：

# nonlocal2.py

# 3. 当有两层或两层以上函数嵌套时，访问nonlocal变量只
# 对最近的一层变量进行操作


v = 100

def f1():
    v = 200

    def f2():
        v = 300

        def f3():
            nonlocal v
            v = 400
            print('fv3.v=', v)
        f3()
        print("f2.v =", v)
    f2()
    print('f1.v=', v)
f1()

#fv3.v=400
#f2.v =400
#f1.v=200

示例3：

# 4. nonlocal语句的变量列表里的变量名，不能出
#     现在此函数的参数列表中
var = 100


def outter():
    var = 200
    print("outter内的var=", var)

    def inner(var):
        nonlocal var  # 此处会出错
        var = 300
        print("inner内的var=", var)
    inner(3)
    print("outter结束时的var=", var)

outter()
print('全局的var=', var)


  说明:
    1. nonlocal 语句只能在被嵌套的函数内部进行使用
    2. 访问nonlocal变量将对外部嵌套函数作用域内的变量进行操作
    3. 当有两层或两层以上函数嵌套时，访问nonlocal变量只对最近的一层变量进行操作
    4. nonlocal语句的变量列表里的变量名，不能出现在此函数的参数列表中

def 语句:
   作用:
     创建函数

lambda 表达式(又称匿名函数)
  作用:
    创建一个匿名函数对象
    同 def 类似,但不提供函数名
  格式:
    lambda : 表达式
  示例见:

def myadd(x, y):
    return x + y

myadd = lambda x, y: x + y

print("20 + 30 = ", myadd(20, 30))  # 50
print("40 + 50 = ", myadd(40, 50))  # 90


  说明:
    1. lambda 只是一个表达式，它用来创建一个函数对象
    2. 当lambda表达式调用时，先执行冒号(:)后的表达式，并返回表达式的结果的引用关系
    3. lambda 表达式创建的函数只能包含一条表达式
    4. lambda 比函数简单且可以随时创建和销毁，有利于减少程序的偶合度

练习:
  1. 写一个lambda 表达式，判断这个数的2次方+1是否能被5整除，如果能被整除返回True, 否则返回False
     例:
        fa = lambda x: .....
        print(fa(2))  # True
        print(fa(4))  # False

fa = lambda x: (x ** 2 + 1) % 5 == 0

print(fa(2))  # True
print(fa(4))  # False

  2. 写一个lambda表达式，求两个变量的最大值
     例如:
        def mymax(x, y):
           ...
        mymax = lambda ...
        print(mymax(100, 200))  # 200

# def mymax(x, y):
#     return x if x > y else y
#     if x > y:
#         return x
#     return y

# mymax = lambda x, y: x if x > y else y
mymax = lambda x, y: max(x, y)
print(mymax(100, 200))  # 200

 

eval() / exec() 函数

  eval(source, globals=None, local=None)  把一个字符串 srouce 当成一个表达式来执行，返回表达式执行的结果

  exec(source, globals=None, locals=None) 把一个字符串source 当成程序来执行

eval示例见:

# eval.py

x = 100
y = 200

a = eval('x + y')
print(a)  # 300

a = eval('x + y', {'x': 1, 'y': 2})
print(a)  # 3

a = eval('x + y',
         {'x': 1, 'y': 2},
         {'x': 10, 'y': 20})
print(a)  # 30

a = eval('x + y',
         {'x': 1, 'y': 2},
         {'x': 10})
print(a)  # 12


 

# eval2.py


while True:
    s = input("请输入表达式: ")
    if not s:
        break
    a = eval(s)
    print(a)

exec 示例见:
 

# exec.py

s = '''print("hello world!")
x = 100
x += 200
print('x=', x)
'''

exec(s)  # 把s当成程序来执行

练习:
  1. 给出一个整数n,写一个函数myfac来计算n!(n的阶乘)
    n! = 1 * 2 * 3 * 4 * ..... * n
    如:
      print(myfac(5))  # 120

def myfac(n):
    m = 1
    for x in range(2, n + 1):
        m *= x
    return m

print(myfac(5))  # 120


  2. 给出一个整数n,写一个函数计算myfn(n):
      1 + 2**2 + 3**3 + .... + n**n的和
    如:
      print(myfn(10)) # ???

# def myfn(n):
#     s = 0
#     for i in range(1, n + 1):
#         s += i ** i
#     return s

def myfn(n):
    return sum(map(lambda i: i ** i,
                   range(1, n + 1)
                   )
               )


print(myfn(10))  # 10405071317


  3. 完全数:
     1 + 2 + 3 = 6 (6为完全数)
     1,2,3都为6的因数(因数是能被一个数x整除的整数为y,则y为x的因数)
     1 x 6 = 6
     2 x 3 = 6
     完全数是指除自身以外的所有因数相加之和等于自身的数
     求 4~5个完全数并打印出来
     答案:
       6
       28
       496
       ......

def is_perfect_number(n):
    # 此函数判断n是否是完全数，
    # 如果是则返回True,否则返回False
    L = []  # 此列表用于存放　所有的因数
    for x in range(1, n):
        if n % x == 0:  # 整除了．则说明x为n的因数
            L.append(x)
    return sum(L) == n  # 如果因数之和等于n则返回True


def print_number():  # 此函数用于打印所有的完全数
    i = 1
    while True:
        if is_perfect_number(i):
            print(i)  # 打印这个完全数
        i += 1


print_number()  # 开始计算

4 实现带有界面的学生信息管理系统
  程序启动时先弹出操作菜单:
    +-------------------------+
    | 1)  添加学生信息          |
    | 2)  显示学生信息          |
    | 3)  删除学生信息          |
    | 4)  修改学生成绩          |
    | q)  退出                 |
    +-------------------------+
    请选择: 1
  要求 ：
      每个选择都要有一个函数来实现

def input_student():
    L = []  # 创建一个容器准备放入
    while True:
        name = input('请输入姓名: ')
        if not name:  # 如果名字为空,结束输入操作
            break
        age = int(input("请输入年龄: "))
        score = int(input("请输入成绩: "))
        d = {}  # 每次都会执行{} 来创建新的字典
        d['name'] = name
        d['age'] = age
        d['score'] = score
        L.append(d)
    return L


def output_student(lst):
    # 打印表格
    print("+---------------+----------+----------+")
    print("|     name      |   age    |   score  |")
    print("+---------------+----------+----------+")
    for d in lst:
        n = d['name'].center(15)
        a = str(d['age']).center(10)
        s = str(d['score']).center(10)
        print("|%s|%s|%s|" % (n, a, s))

    print("+---------------+----------+----------+")


def show_menu():
    print('+-------------------------+')
    print('| 1)  添加学生信息        |')
    print('| 2)  显示学生信息        |')
    print('| 3)  删除学生信息        |')
    print('| 4)  修改学生成绩        |')
    print('| q)  退出                |')
    print('+-------------------------+')


def main():
    docs = []  # 用于存放学生信息的空列表
    while True:
        show_menu()
        s = input("请选择: ")
        if s == '1':
            docs += input_student()
        elif s == '2':
            output_student(docs)
        elif s == '3':
            print("开始删除")
        elif s == '4':
            print("开始修改成绩")
        elif s == 'q':
            break

main()

 

CSDN时光
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
SyntaxError: name ‘x‘ is parameter and global
aiyoufyc001的博客
05-28 8438
def func(x): global x print ('x is', x) x = 2 print ('Changed local x to', x) x = 50 func() print ('x is still', x ) tishSyntaxError: name 'x' is parameter and global
JDK1.8新特性(二): Lambda表达式 (参数列表) -> { } 和函数式接口@FunctionalInterface
人不风流枉少年
05-05 1万+
Lambda表达式 一：简介 JDK的升级的目的有以下几个：增加新的功能、修复bug、性能优化、简化代码等几个方面，Lambda表达式就是属于简化代码，用于简化匿名实现类，提供一种更加简洁的写法。Lambda表达式在Swift语言中称之为代码块,Lambda表达式可以认为是一种特殊的接口，该接口必须只有一个抽象方法。 语法 (参数类型 参数名, 数参数类型 参数名2...) ...
函数嵌套定义
dengchou2870的博客
09-17 2310
目录 局部变量　　全局变量 locals() globals()一个函数可以作为参数传入另一个函数传入一个函数 函数可以作为另一个函数的返回值不加括号绑定函数，　加括号调用函数语句 函数嵌套定义 python四个作用域 局部作用域　　　　　 nonlocal语句 外部嵌套函数作用域 global语句 全局作用域 ...
PYTHON1.day10
weixin_34206899的博客
01-25 123
day09回顾: 函数的参数: 实参(给) 传递方式: 位置传参 序列传参 关键字传参 字典关键字传参 形参(接) 缺省参数(default argument) def fx(a=0, b=2, c=3): ... 形参的定义方...
python基础day01.txt
04-27
python 基础 python3 (CPython) python文件名通常以 .py结尾 # 方法1 $ python3 xxxx.py # 方法2 $ chmod +x xxxx.py # 修改 xxxx.py 第一行 #! /usr/bin/python3 $ ./xxxx.py 交互模式: $ python3 >>> ...
【Python基础学习笔记】Day·1
01-20
python的注释分两种： 1·单行注释：使用 # 号对文本进行注释 例：print(Hello World) #打印字符串Hello World 2·多行注释：使用 ‘’’ ‘’’ 一对三引号对文本进行注释 例：''' Python是一种跨平台的...
Udemy排名第一的Python课程 day6-day10笔记
最新发布
06-02
看b站python学习课程的笔记 内有代码以及截图 pdf笔记
Python学习笔记 day4 基础4
12-21
Python学习笔记——基础4 在Python编程中，掌握基础语法和高级特性是非常重要的。这篇学习笔记将探讨四个关键概念：列表生成式、迭代器与生成器、装饰器以及数据序列化，这些都是Python编程中常用且实用的技术。 1...
python笔记DAY4.docx
10-05
在Python笔记DAY4中，我们重点探讨了函数的基础知识，包括函数的定义、调用、参数类型以及返回值。 首先，函数的定义使用关键字`def`，后跟函数名和圆括号内的参数列表。调用函数时，我们只需提供函数名和所需的...
py3.6中 变量不能同时作为global变量和子函数传递的变量
jzz3933的博客
10-18 7095
最近写一个python程序，用了global变量，但是老报错， Name 'flag' is parameter and global 后来去stackflow上搜索才发现了这个问题，连接如下https://stackoverflow.com/questions/18807749/name-x-is-parameter-and-global-python 最终发现，变量不能同时作为g
global 和 nonlocal 的作用域
ysl的博客
03-11 146
https://blog.csdn.net/youngbit007/article/details/64905070 https://blog.csdn.net/qw_sunny/article/details/80972357
Python中关键字global与nonlocal的区别
热门推荐
每天进步一点点
03-24 5万+
第一，两者的功能不同。global关键字修饰变量后标识该变量是全局变量，对该变量进行修改就是修改全局变量，而nonlocal关键字修饰变量后标识该变量是上一级函数中的局部变量，如果上一级函数中不存在该局部变量，nonlocal位置会发生错误（最上层的函数使用nonlocal修饰变量必定会报错）。 第二，两者使用的范围不同。global关键字可以用在任何地方，包括最上层函数中和嵌套函数中，即使之前未定义该变量，global修饰后也可以直接使用，而nonlocal关键字只能用于嵌套函数中，并且外层函数中定义了
global 和 nonlocal 的区别?
cats_miao---python/java
06-28 1397
global 和 nonlocal 的区别?global 用来声明全局变量。nonlocal 用来声明外层的局部变量, 如下所示:In [14]:# 定义两个全局变量A = 111B = 222​def foo(): # 定义两个局部变量 A = 333 B = 444 def bar(): global A # 使用全局变量 A = 111 ...
global和nonlocal的用法，相同点与区别
山人甲 Python博客
01-04 317
然后  
小甲鱼零基础入门python课后作业_小甲鱼零基础学习Python-课后作业（21）：函数——lambda表达式...
weixin_39769740的博客
11-24 166
测试题：0. 请使用lambda表达式将下边函数转变为匿名函数？1 def fun_A(x, y=3):2 return x *y345 fun_A = lambda x,y=3 : x*y;1. 请将下边的匿名函数转变为普通的屌丝函数？1 lambda x : x if x % 2 elseNone23 deffun_1(x):45 if x % 2:6 returnx;7 else:8 ret...
DW学习－Python基础09（函数与Lambda表达式）
木易是木易啊的博客
07-31 383
目录
python进阶_关于命名空间与作用域
qq_35810838的博客
04-18 165
python进阶_关于命名空间与作用域 写在前面 如非特别说明，下文均基于Python3 命名空间与作用于跟名字的绑定相关性很大，可以结合另一篇介绍Python名字、对象及其绑定的文章。 1 def fun1(): 2 i = 1 3 4 def fun2(): 5 i = 2 同一个模块中的两个函数中，两个同名名字i之间绝没有任...
python用lambda函数实现两个数相乘-Python lambda函数来计算一个数的阶乘
weixin_39803977的博客
11-11 4351
有关于这个功能的两个硬盘部分这是一种混乱。1. lambda a, b: b*a(a, b-1) if b > 0 else 1。2. “B” 这是如下因素1.为1，这不外乎：def f(a, b):if b > 0:b * a(a, b - 1)else:1对于2，本B(lambda b: (lambda a, b: a(a, b))(lambda a, b: b*a(a, b-1) if b ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值