python中的关键字---2（函数基础类）
Posted God is a girl
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了python中的关键字---2（函数基础类）相关的知识，希望对你有一定的参考价值。
函数基础
定义函数: def 函数名():
缩进 函数体(代码块)
调用函数: 函数名 + () 小括号
执行顺序: def func(): 1
print(\'这大佬黑\') 3
func()调用 2
函数的返回值:
def func(): 1
print(\'这大佬黑\') 3
return \'今晚不溅不散\'
func()调用 2
返回一个参数的时候是它本身,返回多个就是元组形式显示
当函数体执行到return的时候就结束函数
不写return的时候 默认返回None 写了return不写返回值的时候 返回的也是None
函数的参数:
参数:
形参 : 在函数定义的时候括号里的变量就是咱们的形参
位置参数:
按照实参的位置对应把值赋值给形参中变量
默认参数(关键字参数):
在函数定义的时候,直接给变量赋值
默认参数不传参是否可以???? 可以
默认参数可以传值吗???? 可以 将默认参数的值覆盖
混合参数:
位置参数在默认参数前面
例如:
def f(a,b,c = 8):
pass
实参 : 在函数调用的时候括号里放入的值就是实参
位置参数:
f(1,2,3)
默认参数(关键字参数):
f(a=1,b=2,c=3)
混合参数:
f(1,2,c=3)
传参: 将实参传递给形参的过程
三元运算:
a if a>b else b
结果 条件 结果
结果 如果条件成立使用前面的 否则就使用后边的
函数进阶
1. 函数的参数:
动态:
动态位置参数 *args
动态关键字参数 **kwargs
位置 > 动态位置参数 > 默认(关键字)参数 > 动态关键字参数
2. 名称空间:
局部命名空间
全局命名空间
内置命名空间
加载顺序:
内置 > 全局 > 局部
取值顺序:
局部 > 全局 > 内置
作用域:
全局作用域:
内置 + 全局
局部作用域:
函数局部
# print(globals()) # 查看全局作用域中的变量和函数名
# print(locals()) # 查看局部作用域中的变量和函数名
3. 函数的嵌套:
def f():
print(11)
def f1():
print(22)
def f2():
print(33) **********重要
f2()
f1()
f()
4. 函数的注释:
def func():
# \'\'\'
# 这是打印的函数
# :param a: 没啥用1
# :param b: 没啥用1
# :param c: 没啥用1
# :param d: 没啥用1
# :return: 返回的None
# \'\'\'
# print(a,b,c,d)
5. global|
# print(id(lst))
# def func():
# # a = 15 # 在函数的局部中
# # global se #
# lst[0] = 11
# # print(a) # 使用的是局部
# func()
# print(lst)
# print(id(lst))
# 可变数据类型在函数中可以直接操作,不可变数据类型才需要使用global
# a = 10
# def f():
# a = 1 # a = 2
# def f1():
# # a = 4 # a = 2
# def f2():
# # nonlocal a
# # a = 2
# print(a) # 2
# f2()
# print(a) # 2
# f1()
# print(a) # 2
# f()
# nonlocal 改变最近的父级变量, 如果上级没有能够改变的就继续向上走,直到最外层函数就停止了.
##### 函数: 将一个需求封装后调用,优点:除去重复代码.
闭包
# 闭包: 内部函数使用了外部函数的变量,内部函数就是一个闭包
# def outer():
# a = 1
# b = \'123\'
# c = [1,2,3]
# def inner():
# print(1234)
# print(inner.__closure__) # inner不是一个闭包
# outer()
#
# def outer():
# a = 1
# b = \'123\'
# c = [1,2,3]
# def inner():
# print(a,b,c)
# print(inner.__closure__) # inner是一个闭包
# outer()
# def outer(a):
# def inner():
# print(a)
# print(inner.__closure__) # inner是一个闭包
# def outer(url):
# def inner():
# print(a)
# print(inner.__closure__)
# from urllib import request # 别人写好了python代码的文件
# ret = request.urlopen(\'http://www.cnblogs.com/Eva-J/articles/7213953.html\')
# print(ret.read().decode(\'utf-8\'))
# 访问一个网页
# 会被频繁的访问
# import time
# from urllib import request
# def func2(url):
# ret = request.urlopen(url)
# content = ret.read().decode(\'utf-8\')
# return content
#
# start = time.time()
# for i in range(10):
# func2(\'http://www.cnblogs.com/Eva-J/articles/7213953.html\')
# print(time.time() - start)
#
# from urllib import request # 导入别人写好的python代码,urllib是专门负责访问url的
# def func(url):
# ret = request.urlopen(url) # 利用urlopen函数打开一个url得到结果ret
# content = ret.read().decode(\'utf-8\') #使用ret的read方法得到bytes类型的网页源码,然后转码成str
# def inner():
# return content
# return inner
#
# ret = func(\'http://www.cnblogs.com/Eva-J/articles/7213953.html\')
# # 相当于将url对应的内容存在了url中,每一次调用ret就是获取内容的过程
# for i in range(10):
# ret()
# print(time.time() - start)
# 闭包的应用
# 缓存
# 装饰器
# def func(*args):
# sum_num = 0
# for num in args:
# sum_num += num
# def inner():
# return sum_num
# return inner
#
# inner = func(1,2,3,4)
# inner()
迭代器
# 什么是迭代器?
# l = [1,2,3,4]
# res = l.__iter__()
# print(res)
# list_iterator iterator迭代器
# dir(l)
# print(dir(res))
# res中 但是不在l中的所有方法
# print(set(dir(res))-set(dir(l)))
# {\'__next__\', \'__setstate__\', \'__length_hint__\'}
# 迭代器中特有的方法,l中没有
# print(res.__length_hint__()) # 迭代器中有多少个元素
# for i in res:
# print(i)
# res.__setstate__(2) # 控制迭代器从哪儿开始迭代
# for i in res:
# print(i)
# print(res.__next__()) # 从迭代器中取下一个值
# print(res.__next__())
# print(res.__next__())
# print(res.__next__())
# print(res.__next__())
#
# for循环一个列表的时候必须用的
# __next__取下一个值
#
# 迭代器协议 : 含有__next__和__iter__方法的变量/值都是迭代器
#
# 迭代器的特点:
# 具有next和iter方法
# 通过一个next多次执行就可以获得所有这个容器中的值
# 迭代器中的值只能取一次
# 不取的时候值不出现
#
# for循环取值
# for循环内部的机制就是迭代器取值的机制
# 在for循环执行的过程中 : 先把可迭代的变成一个迭代器,然后再从中一个一个的取值
#
# range生成的就是一个迭代器,创建这个迭代器并不会真的把迭代器中的所有数据一次性生成
# 什么时候生成呢? 只有通过next取值的时候才会生成
# 记住你要多少个值 ,当前该给你什么,并且记住我下一个该给你什么,下一个和当前这个数的关系
#
# f文件句柄
# f记住 当前读到哪个位置了
#
# a = list(range(1000000000))
# print(a)
#
# 迭代器的作用就是节省内存,for循环就是利用了迭代器节省内存的特点来对python当中的变量来进行操作的
生成器
# python语言自带的
# 生成器 : 程序员通过简单的函数就可以实现的
# def func():
# print(\'hello\')
# yield 1
#
# g = func() # 调用"生成器函数"
# print(g) # g generator(生成器)
# 调用就不会执行这个函数,而是返回一个生成器
# print(dir(g)) # g是一个迭代器
# 所有的生成器都是迭代器
#
# a = g.__next__()
# print(a)
#
# def func():
# print(\'hello\')
# yield 1
# print(\'world\')
# yield 2
#
# g = func()
# a = g.__next__()
# print(a)
# b = g.__next__()
# print(b)
# yield关键字的特点: 可以记录当前函数中执行的位置,下一次继续执行
# next和yield是一对搭档 : next开始函数的执行 yield停止函数的执行
生成器函数
int 整数
# float 浮点数
# 1.2
# 2.3333344
# 256.789 = 2.56789*10**2
# 为什么要叫浮点数 : 因为小数点是浮动的
# 浮点数能表示的数学上的数字 : 有理数(有限小数 无限循环小数)
# 浮点数的小数点是不准确的 : 小数的小数位是转换成二进制存储
# a = 1.7265923649689710283508127969
# a = 1.111111111188818181818111624
# print(a)
#
# 转换成字符串存储
# \'1.71264864975975073507505\'
# 如果你创建的变量本身带小数点,那么这个变量的数据类型直接就是浮点数
# 所有的除法(除了//)得到的都是小数
#
# 除法
# python2.x 整数除以整数就会取整(向下取整),有一个数浮点数,就按照浮点数计算
# python3.x 所有的除(除了//)的结果都是小数
# 生成器函数中
# send/__next__ 生成器函数之外用的
# yield/yield from 生成器函数之内用的
#
# next+send == yield
# 如果函数中的yield要接收参数,那么应该使用send传值
# 如果函数中的yield不需要接收参数,那么应该使用next即可
#
# 生成器和迭代器是一样的,内部的值都只能取一次
# 从生成器中取值的方式也和迭代器是一样的:
# for
# next/send
# 数据类型的强制转换(list)
# def gener():
# print(\'草莓味\')
# yield 1
# print(\'香蕉味\')
# yield 2
# print(\'榴莲味\')
# yield 3
#
# g = gener()
# num = g.__next__()
# num = g.__next__()
# num = g.__next__()
# print(num)
# for num in g:
# print(\'*\'* num)
# def gener():
# print(\'草莓味\')
# yield 1
# # smell = yield 1
# # print(smell)
# print(\'可乐味\')
# smell2 = yield 2
# print(smell2)
# yield 3
#
# g = gener()
# print(g.__next__())
# ret = g.send(\'香蕉味\') # g.__next__只不过传了一个值进去
# print(ret)
# ret2 = g.send(\'榴莲味\')
# print(ret2)
列表推导式
# 和循环/列表相关的知识点
# l = [1,2,3,4,5,6]
# # [1,4,9,16,25,36]
# new_l = []
# for i in l:
# new_l.append(i*i)
# print(new_l)
#
# new_l2 = [i*i for i in l]
# print(new_l2)
# l = [1,2,3,4,5,6]
# print([i*i for i in l]) # 列表推导式
# 当已经有了一个列表,从这个列表中的每一个元素都需要做某个操作
# 并且需要将操作的结果放在一个新的列表中
# 适合使用列表推导式
# 新的列表 = [每一个元素要做的操作 for 列表中的每一个元素 in 列表]
# range(2,20) # 把每一个元素整除3的结果放到一个新的列表中
# new_lst = []
# for num in range(2,20):
# new_lst.append(num//3)
# lst = [num//3 for num in range(2,20)]
# print(lst)
# 请计算0-100内能被3整除的所有数字
# new_lst = []
# for i in range(0,101):
# if i%3 == 0:
# new_lst.append(i)
#
#
# new_lst2 = [i for i in range(0,101) if i%3 == 0]
# print(new_lst2)
生成器表达式
# 生成器表达式
# 1.想要一个生成器/迭代器 , 简单的逻辑可以不写函数而是直接用表达式实现
# 2.生成器表达式本身就是一个生成器/迭代器
# 3.惰性运算(列表推导式在执行完的那一刻,已经存在一个列表了) 只能取一次
# 生成器 只有 for next list才开始从生成器中取值 列表推导式
# 4.更加简洁
# 生成器
# def func():
# for i in range(1000001):
# if i%3 == 0:
# yield i
#
# g1 = func()
# g1.__next__()
# g = (i for i in range(0,101) if i%3 == 0)
# print(g.__next__())
# print(g.__next__())
以上是关于python中的关键字---2（函数基础类）的主要内容，如果未能解决你的问题，请参考以下文章