Python全栈开发武沛齐day05函数进阶

day05 函数进阶

1.回顾和扩展
1.1 基础语法
• 环境搭建
• 输入输出
• 变量
• 条件语句
• 循环语句 + range
• 字符串格式化
• 注释
• pass

1.2 数据类型
• 整型 int
v1 = 123
py2： int long
py3： int
• 浮点型 float
v1 = 3.14
py2: 5/2=2
py3: 5/2=2.5
res = float(123)
print(res)
• 布尔类型 bool
v1 = True
v2 = False
if 1>2:
pass

if 345:
pass
else:
pass
False: 0 "" [] () {} set() None
True: ...
• 字符串 str
v1 = "root"
– 独有功能（所有的字符串）
v1 = "root"
res = v1.upper()
upper/lower/split/replace/strip/join/startswith/endswith/isdecimal
– 公共功能
索引、切片、for循环、in存在、长度
• 列表 list
v1 = [11,22,33]
v1.append(55)
print(v1) # [11,22,33,55]
– 独有功能（所有列表）
append/insert/clear/reverse/remove...
– 公共功能
索引、切片、for循环、in包含、长度
可以对元素进行修改、删除
# 0123
v1 = "root" -> 不可变，创建后内部元素不允许修改
# 0 1 2
v1 = ["中国","俄罗斯","美国"] -> 可变，...

v1[1]
v1[1] = "日本"
del v1[1]
• 元组 tuple
v1 = (11,22,33)
– 独有功能（没有）
– 公共功能
索引、切片、for循环、in包含、长度
• 字典 dict
py3.6之前：字典无序
py3.6之后，字典有序
v1 = {"k1":123,"k2":"456}
– 独有功能
keys/items/values/update
– 公共功能
长度、for循环、in包含、键索引
• 集合 set
- 不可重复 & 查询效率高（哈希）

交并差
if "武沛齐" in ["xxx","xxxxx","李江","张槎"]:
pass
if "武沛齐" in {"xxx","xxxxx","李江","张槎"}:
pass
对列表["xxx","xxxxx","李江","张槎"]去重。
v1 = set(["xxx","xxxxx","李江","张槎"])
res = list(v1)
• None
None
v1 = None
v2 = "123"

数据类型的进阶：推导式，通过一行代码实现某些功能。
num = []
for i in range(10):
num.append(i)
num = [i for i in range(10)]

1.3 函数
1.3.1 内置函数
Python解释器内部帮我们提供好的函数（功能）让我们可以直接使用。
• open函数，文件操作
f = open("xxxx",mode='r')
...
f.close()
参数：
- 路径：相对路径 + 绝对路径
- 模式：r a w
- 编码：utf-8
情景A：文件内容是文字
open("xxxx",mode='r',encoding='utf-8')

情景B：文件是图片、视频、等其他
open("xxxx",mode='rb')
with open("xxxx",mode='r') as f:
data = f.read()
• type函数，查看数据是什么类型？
v1 = 123
v2 = "asdf"

print( type(v1) )
print( type(v2) )
def func(a):
if type(a) == int:
pass
elif type(a) == str:
pass
else:
pass
• range函数，生成一个序列
v1 = range(1,10)
• len函数，算计长度
v1 = len("wupeiqi")
v2 = len([11,22,33,44])

1.3.2 自定义函数
def 函数(参数):
pass

1.定义
def 函数(参数):
pass
def f1(v1,v2):
print(v1 + v2)

2.参数
def f1(v1,v2):
print(v1 + v2)

f1(11,22)

def f2(v1,v2=123):
print(v1 + v2)

f2(11)
f2(11,333)

def f3(*args,**kwargs):
print(v1 + v2)

f2(11)
f2(11,k2=333)
def f1(v1, v2):
print(v1 + v2)

f1(11, 22)

f1(11, v2=22)

f1([11, 22])
f1(**{"v1": 88, "v2": 99})
def f3(args, **kwargs):
print(args, kwargs)

f3(11, 22, 33)
f3(v1=123, v2=999)
f3(11, 22, 88, v1=123, v2=999)
f3([11, 22])
f3(**{"v1": 88, "v2": 99})
f3([11, 22], **{"v1": 88, "v2": 99})

3.返回值
def f3(args, **kwargs):
print(args, kwargs)
return 123
def f3(args, **kwargs):
print(args, kwargs)
# return None

2.函数参数-坑
关于函数默认参数如果设置成了可变类型 + 函数内部对可变类型的元素进行修改。
def f1(v1,v2=123):
pass
不可变：None、int、float、bool、str、tuple
可变：list、dict、set
def f1(v1,v2=123):
print(v1,v2)

f1(1) # 1 123
f1(1,99) # 1 99
f1(2) # 2 123
def f1(v1,v2=[]):
v2.append(v1)
print(v2)

f1(1) # [1]
f1(2,[88,99]) # [88,99,2]
f1(3) # [1,3] 坑
f1(8) # [1,3,8] 坑
注意：函数的默认值不要设置成可变类型。
def f1(v1,v2=None):
if v2 == None:
v2 = []
print(v1,v2)

f1(1)
f1(2)
f1(3)

3.函数参数-引用or值
• 引用，内存地址，同一份数据。【默认】
• 值，新创建一个数据。
def func(v1):
print(v1,id(v1)) #

name = [11,22,33]
print(id(name))
func(name)

def func(v1):
v1.upper()
print(v1)

name = "root"
func(name)
print(name)

root
root

函数传递是，默认不是拷贝一份，而是用的同一个引用。

字符串中执行某个方法，不会对原来的数据进行改变，新生成一个数据改变。

def func(v1):
v1.append(999)
print(v1)

name = [11,22]
func(name)
print(name)

[11,22,999]
[11,22,999]

函数传递是，默认不是拷贝一份，而是用的同一个引用。

列表中执行append方法，会对原来的数据进行修改。

4.函数执行-数据混乱？
def f1(a1,a2):
data = a1 + a1 + 100
print(data)

f1(1,2) f1(10,20)
不用担心数据混乱，不会相互干扰。

5.函数-作用域
• 作用域，一块内存区域，里面存储了一些数据，在这块区域内的人就可以共享区域中的数据。
• 在Python中，执行函数时，就会创建一块作用域。
• 函数默认运行时，会有一个全局作用域。

示例1
name = "中国联通"
salary = 10000
if True:
email = "xxx@unicom.com"

print(name,salary,email)

示例2：
name = "中国联通"
salary = 10000
if True:
email = "xxx@unicom.com"

for i in range(10):
pass

print(name,salary,email,i)

示例3：
name = "中国联通"
salary = 10000
if True:
email = "xxx@unicom.com"

for i in range(10):
pass

def func(a1,a2):
a3 = a1 + a2
print(a3)

func(11,22)
func(100,200)

示例4：内部没有可以往上级找
name = "中国联通"
salary = 10000
if True:
email = "xxx@unicom.com"

for i in range(10):
pass

def func(a1,a2):
a3 = a1 + a2 + salary
print(a3)

func(11,22)

示例5：内部没有可以往上级找
name = "中国联通"
salary = 10000
if True:
email = "xxx@unicom.com"

for i in range(10):
pass

def func(a1,a2):
salary = 100
a3 = a1 + a2 + salary
print(a3)

func(11,22)

print(salary)

示例6：规范

全局变量

NAME = "中国来南通"
SALARY = 10000

def func(a1,a2):
# 局部变量
salary = 100
a3 = a1 + a2 + salary
print(a3)

func(11,22)
print(SALARY)

示例7：

全局变量

NAME = "中国来南通"
SALARY = 10000

def func(a1,a2):
# 局部变量
SALARY = 200
a3 = a1 + a2 + SALARY
print(a3)

func(11,22)
print(SALARY)

233
10000

示例8：

全局变量

NAME = "中国来南通"
SALARY = 10000

def func(a1,a2):
# 局部变量
global SALARY
SALARY = 200
a3 = a1 + a2 + SALARY
print(a3)

func(11,22)
print(SALARY)

233
200
示例9：

全局变量

NAME = "中国来南通"
ROLE = "root"

def func(a1,a2):
# 局部变量
global ROLE
ROLE.upper()
a3 = a1 + a2 + ROLE
print(a3)

func("eric","DBA")
print(ROLE)

"ericDBAroot"
"root"
示例10：

全局变量

NAME = "中国来南通"
ROLE = [11,22]

def func(a1,a2):
# 局部变量
a3 = a1 + a2 + ROLE
print(a3)

func([1,2],[3,4])
print(ROLE)

[1,2,3,4,11,22]
[11,22]

全局变量

NAME = "中国来南通"
ROLE = [11,22]

def func(a1,a2):
# 局部变量
ROLE.append(100)
a3 = a1 + a2 + ROLE
print(a3)

func([1,2],[3,4])
print(ROLE)

[1,2,3,4,11,22,100]
[11,22,100]
一般情况下，global用于进行重新赋值。

全局变量

NAME = "中国来南通"
ROLE = [11,22]

def func(a1,a2):
# 局部变量
global ROLE
ROLE = 999
a3 = a1 + a2 + ROLE
print(a3)

func(1,1)
print(ROLE)

1001
999

6.函数-嵌套
city = "青海"

def func(a1):
a2 = a1 + 100

def f1():
    name = "ROOT"
    print(name)

def f2():
    size = 100
    print(size)

f1()

f2()
print(a2)

func(100)

7.函数-嵌套+返回值
def func(a1):
a2 = a1 + 100 # 101
a3 = 300

def inner(v1,v2) :
    return v1 + v2 + 100

a4 = inner(10,20) # 130

return a3 + a4    # 430

ret = func(1)
print(ret) # 430

def f1():
print(123)

f1()

v2 = f1

v2()

def func(a1):
a2 = a1 + 100

def f1():
    print(123)
a3 = f1
return a3

ret = func(10)
ret()

ret=a3=f1=函数

def func(a1):

def f1():
    return a1 + 100

return f1

v1 = func(10) # f1
v2 = func(20) # f1
v3 = func(30) # f1

7.1 闭包
• 创建多个包裹，每个包裹中放不同的值。
• 后续打开包裹时，取出他里面的不同的值。

7.2 易错点
def func(a1):
def f1():
return a1 + 100

return f1()

v1 = func(10) # 110
v2 = func(20) # 120
v3 = func(30) # 130

def func(a1):
def f1():
return a1 + 100

return f1

v1 = func(10) # 函数
v2 = func(20) # 函数
v3 = func(30) # 函数

8.装饰器
Python中的装饰器本质上就是对闭包的应用：
def func(a1):
def f1():
return a1 + 100

return f1

v1 = func(10) # 函数
v2 = func(20) # 函数
v3 = func(30) # 函数

8.1 第1回合
def send_email(to,subject,content):
...

send_email("wupeiqi@live.com","发工资","本月工资100000")
send_email("zhangkai@live.com","发工资","本月工资100000")
send_email("eric@live.com","发工资","本月工资100000")

接下来，我想要实现一个功能：在发送短信之前做一个操作，例如： print(123)
• 你会这么干
def send_email(to,subject,content):
print(123)
...

send_email("wupeiqi@live.com","发工资","本月工资100000")
send_email("zhangkai@live.com","发工资","本月工资100000")
send_email("eric@live.com","发工资","本月工资100000")
• 我会这么干
def send_email(to, subject, content):
print("发邮件：", to, subject, content)

def outer(func):
def inner(to, subject, content):
print(123)
func(to, subject, content)
return inner

v1 = outer(send_email) # v1是inner函数；闭包：func=send_email函数
v1("wupeiqi@live.com", "发工资", "本月工资100000")
v1("zhangkai@live.com","发工资","本月工资100000")
v1("eric@live.com","发工资","本月工资100000")

绕了一圈，本质上还是发送邮件

# 原来的代码

def send_email(to, subject, content):
print("发邮件：", to, subject, content)

def outer(func):
def inner(to, subject, content):
print(123)
func(to, subject, content)
return inner

send_email是inner函数；闭包：func=send_email函数

send_email = outer(send_email)

原来的代码：调用方法

send_email("wupeiqi@live.com","发工资","本月工资100000")
send_email("zhangkai@live.com","发工资","本月工资100000")
send_email("eric@live.com","发工资","本月工资100000")

优势：没有改变原来的函数定义+函数执行方法，让你的原来的执行前自定义写操作

劣势：代码量增加

注意：自己写功能；接盘。
开放封闭原则：
- 开放：配置开发
- 封闭：逻辑代码

8.2 第2回合
在Python内部支持语法 @函数 + 闭包

接下来，我想要实现一个功能：在发送短信之前做一个操作，例如： print(123)
• 你会这么干
def send_email(to,subject,content):
print(123)
...

send_email("wupeiqi@live.com","发工资","本月工资100000")
send_email("zhangkai@live.com","发工资","本月工资100000")
send_email("eric@live.com","发工资","本月工资100000")
• 我会这么干
def outer(func):
def inner(to, subject, content):
print(123)
func(to, subject, content)
print(666)

return inner

@outer
def send_email(to, subject, content):
print("发邮件：", to, subject, content)

原来的代码：调用方法

send_email("wupeiqi@live.com", "发工资", "本月工资100000")
send_email("zhangkai@live.com", "发工资", "本月工资100000")
send_email("eric@live.com", "发工资", "本月工资100000")

8.3 第3回合
关于参数和返回值
1.参数
def outer(func):
def inner(args, **kwargs):
print(123)
func(args, **kwargs)
print(456)
return inner

@outer # send_email = outer(send_email) inner
def send_email(to, subject, content):
print("发邮件：", to, subject, content)

@outer # send_wechat = outer(send_wechat) inner
def send_wechat(to, content):
print("发送微信", to, content)

原来的代码：调用方法

send_email("wupeiqi@live.com", "发工资", "本月工资100000")
send_email("zhangkai@live.com", "发工资", "本月工资100000")
send_email("eric@live.com", "发工资", "本月工资100000")

send_wechat("eric@live.com", "本月工资100000")
send_wechat("zhangkai@live.com", "本月工资100000")
send_wechat("wupeiqi@live.com", "本月工资100000")

2.返回值
def outer(func):
def inner(args, **kwargs):
print(123)
res = func(args, **kwargs)
return res

return inner

@outer # send_email = outer(send_email) inner
def send_email(to, subject, content):
# print("发邮件：", to, subject, content)
return "成功1"

@outer
def send_wechat(to, content):
# print("发送微信", to, content)
return "成功2"

原来的代码：调用方法

v1 = send_email("wupeiqi@live.com", "发工资", "本月工资100000")
print(v1)

v2 = send_wechat("eric@live.com", "本月工资100000")
print(v2)

8.4 总结
def show():
print(123)

show()

def outer(func):
def inner(args, **kwargs):
res = func(args, **kwargs)
return res
return inner

@outer
def show():
print(123)

show()
def outer(func):
def inner(args, **kwargs):
# 前...
res = func(args, **kwargs)
# 后...
return res
return inner

@outer
def show():
print(123)

show()

装饰器是什么？
• 作用：在不修改原来的函数内部代码的基础上，在执行函数前后进行自定义操作
• 如何实现？
– 创建嵌套函数
def outer(func):
def inner(args, **kwargs):
res = func(args, **kwargs)
return res
return inner
– 应用在被装饰的函数中
@outer
def show():
print(123)

show()
• 是否重要？
– 基础知识，不重要。
– 写项目+面试，非常重要。

案例

有某个函数，我希望你帮我实现对这个函数计算下他得执行时间。

import time

def timer(func):
def inner(args, **kwargs):
start = time.time()
res = func(args, **kwargs)
end = time.time()
print(f"耗时：{end - start}")
return res

return inner

@timer # do_something = outer(do_something)
def do_something():
result = 0
for i in range(1000000):
result = result + i
return result

data = do_something()
print(data)
2. 函数的执行，在内部实现，执行5次，将每次的结果获取到并返回
def counter(func):
def inner(args, **kwargs):
result = []
for i in range(5):
res = func(args, **kwargs)
result.append(res)

    return result

return inner

@counter
def do_something():
result = 0
for i in range(1000000):
result = result + i
return result

data = do_something()
print(data)
3. 通过requests发送网络请求 + 网络异常导致失败（重试）
– 发送网络请求
pip install requests

import requests

res = requests.get('...')
print(res)

– 异常的处理
import requests

try:
res = requests.get('https://www.bilibili.com', timeout=5)
print("成功", res)
except Exception as e:
print("异常", e)
– v1版本
import requests

def download(url):
try:
res = requests.get(url, timeout=5)
if res.status_code == 200:
return "成功"
return "失败"
except Exception as e:
return "异常"

text = input("请输入网址：").strip()

text = "https://www.bilibili.com"

text = "https://www.pythonav.com"

result = download(text)
print(result)
import requests

def download(url):
for i in range(5):
try:
res = requests.get(url, timeout=5)
if res.status_code == 200:
return "成功"
return "失败"
except Exception as e:
print("异常重试")
continue

return "异常"

text = input("请输入网址：").strip()

text = "https://www.bilibili.com"

text = "https://www.pythonav.com"
result = download(text)
print(result)
– v2版本（装饰器）
import requests

def retry(func):
def inner(args, **kwargs):
for i in range(5):
try:
ret = func(args, **kwargs)
return ret
except Exception as e:
continue
return "异常"
return inner

@retry
def download(url):
res = requests.get(url, timeout=5)
if res.status_code == 200:
return "成功"
return "失败"

text = input("请输入网址：").strip()

text = "https://www.bilibili.com"

text = "https://www.pythonav.com"

result = download(text)
print(result)

9.内置函数
https://docs.python.org/zh-cn/3/library/functions.html
Python内部为我们提供的功能。
已经学过有的：len/range/...

9.1 第一组(5个)
• abs，绝对值
v1 = abs(-1)
v2 = abs(1)

print(v1,v2)
• pow，次方
ret = pow(2,5)
print(ret)
• sum，求和
num_list = [11,22,33,44]
ret = sum( num_list )
print(ret)
• divmod，商和余数
v1,v2 = divmod(92,10)
print(v1) # 9
print(v2) # 2
• round，保留小数点后几位
data = round(3.1415,2)
print(data) # 3.14

9.2 第二组（4）

最后一个是False，前面3个都是True
9.3 第三组（3）

案例

10.lambda表达式

109
109
结果都是109

9.内置函数
https://docs.python.org/zh-cn/3/library/functions.html
Python内部为我们提供的功能。
已经学过有的：len/range/...

9.1 第一组 (5)
• abs，绝对值
v1 = abs(-1)
v2 = abs(1)

9.2 第二组（4）
min，最小值
number_list = [11,22,1,0, 19,88]

ret = min(number_list)
print(ret) # 0

max，最大值
number_list = [11,22,1,0, 19,88]

ret = max(number_list)
print(ret) # 88

all，判断内部元素转换成布尔值，是否都是True
data_list = [11,22,-1,99]
ret = all(data_list)
print(ret) # True
应用：判断用户输入是否存在空

user = input("用户名：").strip() # ""
pwd = input("密码：").strip()    # ""

if all([user,pwd]):
    pass
else:
    print("用户名或密码为空")

any，是要存在True(类型转换)，整体就是True
v1 = any([11,22,3])
v2 = any([11,22,0])
v3 = any([11,"",0])
v4 = any([None,"",0])

9.3 第三组（4）
二进制、十六进制、十进制、八进制的转换。

• 二进制和十进制
# 10 -> 2
v1 = bin(48)
print(v1)

2 -> 10

v2 = int("0b1100101",base=2)
print(v2)
• 八进制和十进制
# 10 -> 8
v1 = oct(48)
print(v1)

8 -> 10

v2 = int("0o22324",base=8)
print(v2)
• 十六进制和十进制
# 10 -> 16
v1 = hex(48)
print(v1)

16 -> 10

v2 = int("0x12a23",base=16)
print(v2)

案例
1.IP地址转换
• 关于IP地址 ip = "192.168.11.23"
• 二进制、十六进制、八进制、十进制
utf-8编码十六进制
武 1010010010010100100100101 a718a
中 0110010010010100100100101 a718a
联 0011010010010100100100101 a718a
通 0010110010010100100100101 a718a
• 给你一个IP地址，请将IP地址中的每个十进制数字转成对应二进制
ip = "192.168.11.23"

data_list = ip.split(".") # ["192","168","11","23"]
for item in data_list:
# item=192 168 11 23
item = int(item)
bin_string = bin(item)
bin_string = bin_string[2:]
print(bin_string)
11000000
10101000
1011
10111
• 给你一个IP地址，请将IP地址中的每个十进制数字转成对应二进制，不满8位则补0
ret = "10".rjust(10,"*")
print(ret) # ********10
ip = "192.168.11.23"

data_list = ip.split(".") # ["192","168","11","23"]
for item in data_list:
# item=192 168 11 23
item = int(item)
bin_string = bin(item)
bin_string = bin_string[2:]

bin_8_str = bin_string.rjust(8, "0")
print(bin_8_str)
11000000

10101000
00001011
00010111
• 继续实现：将结果拼接起来 "11000000101010000000101100010111"，再将此二进制的字符串转换成10进制整数。
拼接转换二进制

ret = int("0b110",base=2)
ret = int("110",base=2)

ip = "192.168.11.23"

data_list = ip.split(".") # ["192","168","11","23"]

str_list = []
for item in data_list:
# item=192 168 11 23
item = int(item)
bin_string = bin(item)
bin_string = bin_string[2:]

bin_8_str = bin_string.rjust(8, "0")
# print(bin_8_str)
str_list.append(bin_8_str)

total_bin_str = "".join(str_list)

ret = int(total_bin_str,base=2)
print(ret)

2.字节的处理
• 字符串
name = "中国联通" # unicode
• UTF-8字节
byte_data = name.encode('utf-8') # byte
print(byte_data)
• 获取“中国联通”每个字节的十六进制字符串。
name = "中国联通"
byte_data = name.encode('utf-8') # byte
print(byte_data) # b'\xe4\xb8\xad\xe5\x9b\xbd\xe8\x81\x94\xe9\x80\x9a'
result = []
for item in byte_data:
# 1.转换成十六进制 "0x12"
hex_str = hex(item)
# 2.去除0x
hex_str = hex_str[2:]
# 3.不满2位，则前面补0 a 0a
hex_2_str = hex_str.rjust(2,"0")
result.append(hex_2_str)

4.将所有的十六进制拼接起来字符串的形式

...

print("".join(result))
• 优化v1
name = "中国联通"
byte_data = name.encode('utf-8') # byte
print(byte_data) # b'\xe4\xb8\xad\xe5\x9b\xbd\xe8\x81\x94\xe9\x80\x9a'
result = []
for item in byte_data:
# 1.转换成十六进制 "0x12"
# 2.去除0x
# 3.不满2位，则前面补0 a 0a
result.append(hex(item)[2:].rjust(2, "0"))

4.将所有的十六进制拼接起来字符串的形式

...

print("".join(result))
• 优化v2
name = "中国联通"

result = "".join([hex(item)[2:].rjust(2, "0") for item in name.encode('utf-8')])

print(result)
3.关于md5加密
• 假设你有一个用户注册程序
wupeiqi,123
eric,123
tony,123
• 加密密码md5
wupeiqi,werwerwersdfsdfsdf
eric,werwerwersdfsdfsdf
tony,werwerwersdfsdfsdf
• python的md5加密
import hashlib

obj = hashlib.md5()

obj.update("联通".encode('utf-8'))

encrypt = obj.digest()

encrypt = obj.hexdigest() # 密文
print(encrypt) # 8604270694837d14d85ca6db182c7375
• 实现注册
user = input("用户名：")
pwd = input("密码：")

import hashlib

obj = hashlib.md5()

obj.update(pwd.encode('utf-8'))

encrypt = obj.hexdigest() # 密文

line = f"{user},{encrypt}\n"

with open("db.txt", mode='a', encoding='utf-8') as f:
f.write(line)
import hashlib

def md5(data_string):
obj = hashlib.md5()
obj.update(data_string.encode('utf-8'))
return obj.hexdigest() # 密文

user = input("用户名：")
pwd = input("密码：")
encrypt = md5(pwd)
line = f"{user},{encrypt}\n"

with open("db.txt", mode='a', encoding='utf-8') as f:
f.write(line)

9.4 第四组（2个）
unicode码点
A 0100100001
中 ...
国 ...
• ord，根据文本获取十进制数
v1 = ord("A")
v2 = ord("国")

print(v1, hex(v1), hex(v1)[2:].rjust(4,"0")) # 65 0x41
print(v2, hex(v2), hex(v2)[2:].rjust(4,"0")) # 22269 0x56fd
• chr
ret = chr(22269)
print(ret) # 国

生成随机字母和汉字：
• 字母
import string
import random

ret = random.sample(string.ascii_letters,1)
print(ret)
import random

num = random.randint(65, 90)
ele = chr(num)
print(ele)
• 汉字
import random

num = random.randint(12144, 12229)
ele = chr(num)
print(ele)

9.5 第五组（9）
• int
v1 = int("123")

v1 = int("...",base=2) # 123
v1 = int("...",base=8) # 123
v1 = int("123",base=10) # 123
v1 = int("...",base=16) # 123
• str
• bool
• list
• dict
• tuple
• set
• float
• bytes
v1 = "中国联通" # unicode
v2 = v1.encode('utf-8') # utf-8字节 b"十六进制"

9.6 第六组（10）
• len
• print
• input
• open，文件
• range
py2:
v1 = range(10) # [0,....9] 立即创建
v2 = xrange(10) # 对象不会立即创建
py3:
v1 = list(range(10)) # [0,....9] 立即创建
v2 = range(10) # 对象不会立即创建
• type，查看数据类型
v1 = 123
type(v1) # class
if type(v1) == int:
pass
• id，查看数据内存地址（不要太较真）
- id，表示内存地址

Python内部会缓存和驻留机制
• callable，是否可执行
def func():
pass

data_list = [11,22,33,44,func,func]

for item in data_list:
if callable(item):
item()
else:
print(item)
v1 = 123

print( callable(v1) ) # False
def func():
pass

print( callable(func) ) # True
• enumerate，循环过程中自动生成一列（序号）
goods = ["飞机","坦克","迫击炮"]

for item in goods:
print(item)
goods = ["飞机", "坦克", "迫击炮"]

idx = 1
for item in goods:
print(idx, item)
idx = idx + 1
goods = ["飞机", "坦克", "迫击炮"]

for idx, item in enumerate(goods, 10):
print(idx, item)
• sorted，排序（不会修改原来数据，生成新数据）
num_list = [0, -1, 88, 19, 76, 3, 77]

v1 = sorted(num_list)

print(v1)
num_list = [0, -1, 88, 19, 76, 3, 77]

v1 = sorted(num_list,reverse=True)

print(v1)
name_list = ["alex", "tony", "eric","张三"]
v1 = sorted(name_list)
print(v1)

['alex', 'eric', 'tony']

注意：字符串的排序是按照首个字符的大小进行排序(unicode)..

易错点：

– 数字和字符串是没办法进行比较大小
– 字符串形式的数字
name_list = ["2 进阶", "10 退出","1 入门",]
根据xx进行排序？
name_list = ["2 进阶", "10 退出", "1 入门"]

def func(x):
return int(x.split(" ")[0]) # 2 10 1

ret = sorted(name_list, key=func)
print(ret)

案例
• 展示目录下的所有文件
• 展示
import os

def func(x):
return int(x.split(" ")[0])

name_list = os.listdir(r"E:\EvVideo\day27 大商天狗")

for item in sorted(name_list, key=func):
print(item)

10.lambda表达式
lambda表达式也可以成为匿名函数。
• 创建简单的函数（一行表示+内置return）
def f1(a1):
return a1 + 100

ret = f1(100)
print(ret)
f1 = lambda a1: a1+100

ret = f1(100)
print(ret)
• 匿名函数
def f1():
return 100

def f2():
return 200

func_list = [f1,f2]
func_list = [lambda : 100, lambda : 200]

案例
• 对字符进行切割并获取局部数据，定义函数接收参数，处理获得到的后缀名并返回。
def func(data_str):
return data_str.split(".")[-1]

name = "01 Python基础入门.mp4"
ext = func(name)
print(ext)
func = lambda data_str:data_str.split(".")[-1]

name = "01 Python基础入门.mp4"
ext = func(name)
print(ext)
• 函数放在列表中
data_list = [
lambda data_str:data_str.split(".")[-1],
lambda data_str:data_str.split(".")[-1],
lambda data_str:data_str.split(".")[-1],
]

ext = data_list[0]("01 Python基础入门.mp4")
print(ext) # mp4
• 函数当做参数进行传递
data_list = [
'5 编译器和解释器.mp4',
'9 Python解释器种类.mp4',
'2 课堂笔记的创建.mp4',
'8 Python介绍.mp4',
'7 编程语言的分类.mp4',
'3 常见计算机基本概念.mp4',
'1 今日概要.mp4',
'6 学习编程本质上的三件事.mp4',
'4 编程语言.mp4',
]

ret = sorted(data_list,key=lambda x:int(x.split(" ")[0]) )
print(ret)
import os

name_list = os.listdir(r"E:\EvVideo\day27 大商天狗")

ret = sorted(name_list,key=lambda x:int(x.split(" ")[0]) )
print(ret)

11.推导式+lambda表达式【面试】
• lambda表达式本质是函数 + 未执行则内部代码不会调用
func_list = [lambda :1, lambda :2,lambda :3]

ret = func_list0 # 1
ret = func_list1 # 2
ret = func_list2 # 3
size = 19
func_list = [lambda: 1 + size, lambda: 2 + size, lambda: 3 + size]

ret = func_list1
print(ret) #21

size = 19

func_list = [lambda: 1 + size, lambda: 2 + size, lambda: 3 + size]
size = 20

ret = func_list1
print(ret) # 22

size = 19

func_list = [lambda: 1 + size, lambda: 2 + size, lambda: 3 + size]
ret = func_list1
print(ret) # 21

size = 20

size = 19
func_list = [lambda: 1 + size, lambda: 2 + size, lambda: 3 + size]
ret = func_list[1]()
print(ret)  # 21
size = 20
ret = func_list[1]()

print(ret) # 22
• lambda表达式本质是函数 + 未执行则内部代码不会调用 + 参数
size = 10
func_list = [lambda x: x + 1 + size, lambda x: x + 2 + size, lambda x: x + 3 + size]

ret = func_list0
print(ret)
• lambda表达式本质是函数 + 未执行则内部代码不会调用 + 推导式
func_list = [lambda: 666 for i in range(10)]

ret = func_list0
print(ret)#666

ret = func_list1
print(ret) #666

size = 2

func_list = [lambda: 666 + size for i in range(10)]

ret = func_list0
print(ret)
• 面试题
func_list = [lambda: 100 + i for i in range(10)]

ret = func_list0
print(ret) #109

ret = func_list2
print(ret) #109

函数总结
• 基础：定义、参数、返回值 *****
– 参数：
• 定义：普通参数、默认值、动态参数
• 执行：位置传参、关键字传参
• 坑：默认值是可变类型且在内部会对可变类型元素进行操作。
– 返回值
• 默认返回None
• 遇到return之后，函数就会终止
– 定义
• 传统定义
• 匿名函数
• 内置函数：...*****
• 函数进阶： ***
– 作用域
– 函数嵌套
– 闭包
– 装饰器
– 规范：全局变量用大写、局部变量用小写

预告
基础视频：https://www.bilibili.com/video/BV1m54y1r7zE/
并发编程：https://www.bilibili.com/video/BV1Ev411G7i3/
• 模块，内置功能 + 第三方
• 模块
• 面向对象，【函数+面向对象】
• 数据库
• 前端
• Web框架

posted @ 2024-03-11 22:03 lang333333 阅读(22) 评论(0) 收藏举报

刷新页面返回顶部

fresher20240311

Python全栈开发武沛齐day05函数进阶

f1(11, 22)

f1(11, v2=22)

函数传递是，默认不是拷贝一份，而是用的同一个引用。

字符串中执行某个方法，不会对原来的数据进行改变，新生成一个数据改变。

函数传递是，默认不是拷贝一份，而是用的同一个引用。

列表中执行append方法，会对原来的数据进行修改。

全局变量

全局变量

全局变量

全局变量

全局变量

全局变量

全局变量

ret=a3=f1=函数

绕了一圈，本质上还是发送邮件

send_email是inner函数；闭包：func=send_email函数

原来的代码：调用方法

优势：没有改变原来的函数定义+函数执行方法，让你的原来的执行前自定义写操作

劣势：代码量增加

原来的代码：调用方法

原来的代码：调用方法

原来的代码：调用方法

text = input("请输入网址：").strip()

text = "https://www.pythonav.com"

text = input("请输入网址：").strip()

text = "https://www.bilibili.com"

text = input("请输入网址：").strip()

text = "https://www.pythonav.com"

2 -> 10

8 -> 10

16 -> 10

4.将所有的十六进制拼接起来字符串的形式

...

4.将所有的十六进制拼接起来字符串的形式

...

encrypt = obj.digest()

['alex', 'eric', 'tony']

注意：字符串的排序是按照首个字符的大小进行排序(unicode)..

公告