标签：总结 03 index res func time print def
周总结03
1.文件
1.文件的概念
就是操作系统暴露给用户操作硬盘的快捷方式
# 双击一个文件的底层原理：从硬盘将数据加载到内存
# ctrl+s保存文件的底层原理：把内存中的数据刷到硬盘中进行保存
2.代码打开文件的两种方式
方式1:
f = open(文件路径,读写模式,encoding='utf8')
f.close() # 这个方法不推荐，因为容易忘记写
方式2:
with open(r'a.txt', 'r', encoding='utf8') as f1:#文件路径前面加r防止路径查找混乱
with子代码块 # 这种方法子代码运行结束自动调用close方法关闭资源 可以支持一次性打开多个文件 with open() as f1,open() as f2,open() as f3:
3.文件的读写模式
3.1只读模式:只能读不能写 'r' #read
# 如果文件路径不存在会直接报错；文件路径存在正常读取
with open(r'a.txt', 'r', encoding='utf8') as f:
print(f.read())
3.2只写模式:只能写不能看 'w' #write
# 文件路径不存在自动创建；文件路径存在先清空文件内容再写
with open(r'a.txt', 'w', encoding='utf8') as f:
f.write('赶紧补了，要不然留级呀！\n')
#换行符需要自己添加 而且在后续数据读取比对的时候也一定要注意在不在
3.3只追加模式:文件末尾添加数据 'a' #append
# 文件路径不存在自动创建；文件路径存在:自动在末尾等待追加内容
with open(r'a.txt', 'a', encoding='utf8') as f:
f.write('学习使我快乐')
#不知道写什么具体代码的而且不能空着的时候可以写pass关键字，只是用来补全，本身没有含义
4.文件的操作模式
·文本模式 t; text
默认的模式 我们上面所写的r w a其实全称是 rt wt at
1.只能操作文本文件
2.读写都是以字符为单位
3.需要指定encoding参数 如果不知道则会采用计算机默认的编码
·二进制模式 b; bytes模式
不是默认的模式 需要自己指定 rb wb ab
1.可以操作任意类型的文件
2.读写都是以bytes为单位
3.不需要指定encoding参数 因为它已经是二进制模式了 不需要编码
2.函数
1.函数简介
name_list = ['almira', 'lina', 'judy', 'jeck']
# print(len(name_list))
'''突然len不准用了'''
# count = 0
# for i in name_list:
# count += 1
# print(count)
'''统计列表内数据值个数的代码需要在很多地方使用'''
# 相同的代码需要在不同的位置反复执行
"""
循环
相同的代码在相同的位置反复执行
函数
相同的代码在不同的位置反复执行
ps:相同的代码不是真正一模一样而是可以通过传入的数据不同而做出不同的改变
"""
def my_len():
count = 0
for i in name_list:
count += 1
print(count)
my_len()
"""
函数相当于是工具(具有一定功能)
不用函数
修理工需要修理器件要用锤子 原地打造 每次用完就扔掉 下次用继续原地打造
用函数
修理工提前准备好工具 什么时候想用就直接拿出来使用
"""
2.函数的语法结构
def 函数名(参数):
'''函数注释'''
函数体代码
return 返回值
2.1def
定义函数的关键字
2.2 函数名
命名等同于变量名
2.3 参数
可有可无 主要是在使用函数的时候规定要不要外界传数据进来
2.4 函数注释
类似于工具说明书
2.5 函数体代码
是整个函数的核心 主要取决于程序员的编写
2.6 return
使用函数之后可以返回给使用者的数据 可有可无
3.函数的定义与调用
3.1函数在定义阶段只检测语法 不执行代码
def func():
pass
3.2函数在调用阶段才会执行函数体代码
func()
3.3函数必须先定义后调用
3.4函数定义使用关键字def
函数调用使用函数名加括号
4.函数的分类
4.1空函数
函数体代码为空 使用pass或者...补全的
空函数主要用于项目前期的功能框架搭建
def register():
"""注册功能"""
pass
4.2无参函数
定义函数的时候括号内没有参数
def index():
print('from index function')
4.3有参函数
定义函数的时候括号内写参数 调用函数的时候括号传参数
def func(a):
print(a)
5.函数的返回值
5.1什么是返回值?
调用函数之后返回给调用者的结果
5.2如何获取返回值?
变量名 赋值符号 函数的调用
res = func() # 先执行func函数 然后将返回值赋值给变量res
5.3函数返回值的多种情况?
函数体代码中没有return关键字 默认返回None
函数体代码有return 如果后面没有写任何东西还是返回None
函数体代码有return 后面写什么就返回什么
函数体代码有return并且后面有多个数据值 则自动组织成元组返回
函数体代码遇到return会立刻结束
位置参数
1.位置形参：函数定义阶段，括号内从左往右依次填写的'变量名'
def func1(a, b,):pass # 子代码只有一行且很简单的情况下不需要换行
2.位置实参：函数调用阶段，括号内从左往右依次填写的'数据值'
func1(1, 2)
def func1(a, b):
print(a, b)
# func1(1, 2) # 位置形参的变量名和位置实参数据值一一对应
# func1(1) # 少一个不行，会报错
# func1(1, 2, 3) # d多一个也不行，会报错
# func1(b=1, a=2) # 关键字传参(指名道姓的传参)
# func1(b=2, 1) # 关键字传参一定要在位置传参的后面 报错
# func1(1, b=2) # 可以
# func1(1,a=2) # 同一个形参调用期间不能多次赋值
"""
越简单的越短的越靠前
越复杂的越长的越靠后
同一个形参调用期间不能多次赋值
"""
# name = 'almira'
# pwd = 12345
# func1(name, pwd) # 实参没有固定的定义，可以传数据值也可以传绑定数据值的变量名
# func1(a=name, b=pwd) # 实参没有固定的定义，可以传数据值也可以传绑定数据值的变量名
默认参数
默认参数的本质就是关键字形参(提前已经给了，用户可以不写)
def register(name, age, gender='fmale'):
print(f"""
-----------student information---------
name:{name}
age:{age}
gender:{gender}
-----------------------------------------
""")
# register('almira', 24, 'female')
# register('lina', 22, 'female')
# register('linda', 20, 'female')
register('almira', 24,)
register('lina', 22,)
register('linda', 20,)
可变长形参
# def func1(*a):
# print(a)
# func1() # ()
# func1(1) # (1,)
# func1(1,2) # (1, 2)
# def func2(b, *a):
# print(a, b)
# func2() # 函数至少需要一个参数给到b
# func2(1) # () 1
# func2(1, 2, 3, 4) # (2, 3, 4) 1
"""
*号在形参中
用于接收多余的位置参数 组织成元组赋值给*号后面的变量名
"""
# def func3(**k):
# print(k)
# func3() # {}
# func3(a=1) # {'a': 1}
# func3(a=1, b=2, c=3) # {'a': 1, 'b': 2, 'c': 3}
# def func4(a, **k):
# print(a, k)
# func4() # 函数至少需要一个参数给到a
# func4(a=1) # 1 {}
# func4(a=1, b=2, c=3) # 1 {'b': 2, 'c': 3}
# func4(a=1, b=2, c=3, x='jason', y='kevin') # 1 {'b': 2, 'c': 3, 'x': 'jason', 'y': 'kevin'}
"""
**号在形参中
用于接收多余的关键字参数 组织成字典的形式赋值给**号后面的变量名
"""
# def func5(*a, **k):
# print(a, k)
# func5() # () {}
# func5(1, 2, 3) # (1, 2, 3) {}
# func5(a=1, b=2, c=3) # () {'a': 1, 'b': 2, 'c': 3}
# func5(1, 2, 3, a=1, b=2, c=3) # (1, 2, 3) {'a': 1, 'b': 2, 'c': 3}
# def func5(n, *a, **k):
# print(a, k)
# func5() # 函数至少需要一个参数给到n
# func5(1, 2, 3) # (2, 3) {}
# func5(111,a=1, b=2, c=3) # () {'a': 1, 'b': 2, 'c': 3}
# func5(n=111,a=1, b=2, c=3) # () {'a': 1, 'b': 2, 'c': 3}
# func5(a=1, b=2, c=3, n=111) # () {'a': 1, 'b': 2, 'c': 3}
# func5(1, 2, 3, a=1, b=2, c=3) # (2, 3) {'a': 1, 'b': 2, 'c': 3}
"""
由于*和**在函数的形参中使用频率很高 后面跟的变量名推荐使用
*args
**kwargs
def index(*args,**kwargs):pass
"""
可变长实参
def index(a, b, c):
print(a, b, c)
# l1 = [11, 22, 33]
# index(*l1) # 相当于index(11, 22, 33) ;11 22 33
# t1 = (11, 22, 33)
# index(*t1) # 相当于index(11, 22, 33) ;11 22 33
# st ='bob'
# index(*st) # 相当于index('b', 'o', 'b') ;b o b
# se = {123, 342, 133}
# index(*se) # 相当于index(123 133 342) ；123 133 342集合是无序的，随机拆分
# d1 = {'username':'almira', 'pwd':123, 'gender':'female'}
# index(*d1) # username pwd gender
# *号在实参中相当于for循环，将遍历出来的数据按照位置参数的形式一次性传给函数
# def index(username, pwd, gender):
# print(username, pwd, gender)
# d1 = {'username':'almira', 'pwd':123, 'gender':'female'}
# index(**d1) # index(username='almira', pwd=123, gender='female') ; almira 123 female 只针对字典
# **在实参中将字典打散成关键字参数的形式传给函数
def index(*args, **kwargs):
print(args) # (11, 22, 33, 44)
print(kwargs) # {}
index(*[11, 22, 33, 44]) # index(11, 22, 33, 44)
index(*(11, 22, 33, 44)) # index(11, 22, 33, 44)
名称空间*****
"""
name = 'alimra' 底层原理：
1.首先申请内存空间存储almira
2.给almira绑定一个变量名
3.后续通过变量名找到name就可以访问到almira
"""
名称空间：用来存储变量名与数据值绑定关系的地方(存储变量名的的地方)
1.内置名称空间
# 只要安装了python解释器那内置名称空间就存在
解释器运行自动产生，里面包含了很多名字
ge:len input print...
2.全部名称空间
# 只要运行了py文件就会立刻产生全局名称空间
py文件运行产生，里面存放文件级别的名字
name = 'jason'
if name:
age = 18
while True:
gender = 'male'
def index():
pass
class MyClass(object):
pass
name\age\gender\index\MyClass
3.局部名称空间
# 只要函数调用才会临时产生局部名称空间，一旦运行结束此空间立刻关闭
函数体代码运行产生的
名称空间存期及作用范围(域)
存活周期
内置名称空间
python解释器启动则创建 关闭则销毁
全局名称空间
py文件执行则创建 运行结束则销毁
局部名称空间
函数体代码运行创建 函数体代码结束则销毁(类暂且不考虑)
作用域
内置名称空间
解释器级别的全局有效
全局名称空间
py文件级别的全局有效
局部名称空间
函数体代码内有效
名字查找顺序
涉及到名字的查找 一定要先搞明白自己在哪个空间
1.当我们在局部名称空间中的时候
局部名称空间 >>> 全局名称空间 >>> 内置名称空间
2.当我们在全局名称空间中的时候
全局名称空间 >>> 内置名称空间
ps:其实名字的查找顺序是可以打破的
查找顺序案例
1.相互独立的局部名称空间默认状态不能相互访问的
def func1():
name = 'almira'
print(age)
def func2():
age = 24
print(name)
func1()
func2()
2.局部名称空间嵌套
先从自己的局部名称空间查找 之后由内而外依次查找
函数体代码中名字的查找顺序在函数定义阶段就已经固定死了
x = '加油！'
def func1():
x = 1
def func2():
x = 2
def func3():
x = 3
print(x)
func3()
print(x)
func2()
print(x)
func1()
print(x)
globa 和 nonlocal
money = 666
def index():
global money
money = 123
index()
print(money)
"""
局部名称空间直接修改全局名称空间的数据
"""
def index():
name = 'almira'
def inner():
nonlocal name
name = 'lina'
inner()
print(name)
index()
"""
内层局部名称空间修改外粗局部名称空间的数据
"""
函数名的多种用法
变量名和函数名绑定的都是一块内存地址,
变量名绑定的内存地址里面存放的是数据值
函数名绑定的内存地址里面存放的的一段代码
函数名加括号就会找到该代码并执行
1.可以当作变量名赋值
def index():pass
res = index
res()
2.可以当作函数的参数
def index():
print('from index')
def func(a):
print(a)
a()
func(index)
3.可以地址函数的返回值
def index():
print('from index')
def func():
print('from func')
return index
res = func()
print(res)
res()
def index():
print('from index')
def func():
print('from func')
return func
res = index()
print(res)
res()
4.可以当作容器类型的数据
# 定义容器类型
def register():
print('注册功能')
def login():
print('登陆成功')
def withdraw():
print('提现功能')
def transfer():
print('转账功能')
def shopping():
print('购物功能')
# 定义功能编号与功能的对应关系
func_dict = {
'1': register,
'2': login,
'3': withdraw,
'4': transfer,
'5': shopping
}
while True:
print("""
1.注册功能
2.登录功能
3.提现功能
4.转账功能
5.购物功能
""")
choice = input('>>>:').strip()
if choice in func_dict:
func_name = func_dict.get(choice)
func_name()
else:
print('功能编号不存在')
闭包函数
"""
定义：
1.定义在函数内容
2.用到外部函数名称空间的名字
"""
def index():
name = 'almira'
def inner():
print(name)
闭包函数的实际应用>>>:函数体代码传参
# 方式1：代码里缺什么变量名形参里面就补什么变量名
def register(name,age):
print(f"""
姓名:{name}
年命:{age}
""")
register('almira',24)
# 方式2:闭包函数
def outer(name,age):
# name ='almira'
# age = 24
def register():
print(f"""
姓名:{name}
年龄：{age}
""")
return register
res = outer('almira',18)
res()
res()
res = outer('lina',22)
res()
res()
res()
装饰器简介
1.概念
在不改变装饰器对象原代码和调用方式的情况下给被装饰对象添加新的功能
2.本质
装饰器不是一门新的技术 而是由函数参数、名称空间、函数名多种用法、闭包函数组合到一起的结果
3.口诀
对修改封闭 对扩展开放
4.储备知识
时间相关操作
import time
# print(time.time()) # 时间戳(距离1970-01-01 00:00:00所经历的秒数)
time.sleep(3)
print('睡醒了 干饭')
# count = 0
# 循环之前先获取时间戳
# start_time = time.time()
# while count < 100:
# print('哈哈哈')
# count += 1
# end_time = time.time()
# print('循环消耗的时间:', end_time - start_time)
装饰器推到流程
import time
def index():
time.sleep(3)
print('from index')
def home():
time.sleep(1)
print('from home')
'''1.直接在调用index函数的前后添加代码'''
# start_time = time.time()
# index()
# end_time = time.time()
# print('函数index的执行时间为>>>:', end_time-start_time)
'''2.index调用的地方较多 代码不可能反复拷贝>>>:相同的代码需要在不同的位置反复执行>>>:函数'''
# def get_time():
# start_time = time.time()
# index()
# end_time = time.time()
# print('函数index的执行时间为>>>:', end_time - start_time)
# get_time()
'''3.函数体代码写死了 只能统计index的执行时间 如何才能做到统计更多的函数运行时间 直接传参变换统计的函数'''
# def get_time(xxx):
# start_time = time.time()
# xxx()
# end_time = time.time()
# print('函数的执行时间为>>>:', end_time - start_time)
# get_time(index)
# get_time(home)
'''4.虽然实现了一定的兼容性 但是并不符合装饰器的特征 第一种传参不写 只能考虑闭包'''
# def outer(xxx):
# # xxx = index
# def get_time():
# start_time = time.time()
# xxx()
# end_time = time.time()
# print('函数的执行时间为>>>:', end_time - start_time)
# return get_time
# res = outer(index)
# res()
# res1 = outer(home)
# res1()
'''5.调用方式还是不对 如何变形>>>:变量名赋值绑定 (******)'''
# def outer(xxx):
# def get_time():
# start_time = time.time()
# xxx()
# end_time = time.time()
# print('函数的执行时间为>>>:', end_time - start_time)
# return get_time
# res = outer(index) # 赋值符号的左边是一个变量名 可以随意命名
# res1 = outer(index)
# res2 = outer(index)
# jason = outer(index)
# index = outer(index)
# index()
# home = outer(home)
# home()
'''6.上述装饰器只能装饰无参函数 兼容性太差'''
# def func(a):
# time.sleep(0.1)
# print('from func', a)
#
# def func1(a,b):
# time.sleep(0.2)
# print('from func1', a, b)
#
# def func2():
# time.sleep(0.3)
# print('from func2')
# func(123)
# def outer(xxx):
# def get_time(a, b):
# start_time = time.time()
# xxx(a, b)
# end_time = time.time()
# print('函数的执行时间为>>>:', end_time - start_time)
# return get_time
# func1 = outer(func1)
# func1(1, 2)
# func = outer(func)
# func(1)
# func2 = outer(func2)
# func2()
'''7.被装饰的函数不知道有没有参数以及有几个参数 如何兼容'''
# def func(a):
# time.sleep(0.1)
# print('from func', a)
# def func1(a,b):
# time.sleep(0.2)
# print('from func1', a, b)
# def outer(xxx):
# def get_time(*args, **kwargs): # get_time(1,2,3) args=(1,2,3)
# start_time = time.time()
# xxx(*args, **kwargs) # xxx(*(1,2,3)) xxx(1,2,3)
# end_time = time.time()
# print('函数的执行时间为>>>:', end_time - start_time)
# return get_time
# func = outer(func)
# func(123)
# func1 = outer(func1)
# func1(1, 2)
'''8.如果被装饰的函数有返回值'''
def func(a):
time.sleep(0.1)
print('from func', a)
return 'func'
def func1(a,b):
time.sleep(0.2)
print('from func1', a, b)
return 'func1'
def outer(xxx):
def get_time(*args, **kwargs):
start_time = time.time()
res = xxx(*args, **kwargs)
end_time = time.time()
print('函数的执行时间为>>>:', end_time - start_time)
return res
return get_time
# func = outer(func)
# res = func(123)
# print(res)
func1 = outer(func1)
res = func1(123, 123)
print(res)
装饰器模板
# 必须掌握
def outer(func):
def inner(*args, **kwargs):
res = func(*args, **kwargs)
return res
return inner
# 如何套模板?
def outer(func):
def inner(*args, **kwargs):
username = input('username>>>>:').strip()
password = input('password>>>:').strip()
if username == 'almira' and password == '12345':
res = func(*args, **kwargs)
print('执行被装饰对象之前 可以做的额外操作')
return res
else:
print('执行被装饰对象之后 可以做的额外操作')
return inner
@outer
def func2():
print('登录成功')
# func2 = outer(func2)
func2()
函数装饰器语法糖
def outer(func_name):
def inner(*args, **kwargs):
print('执行被装饰对象之前可以做的额外操作')
res = func_name(*args, **kwargs)
print('执行被装饰对象之后可以做的额外操作')
return res
return inner
"""
语法糖会自动将下面紧挨着的函数名当做第一个参数自动传给@函数调用
"""
@outer # func = outer(func)
def func():
print('from func')
return 'func'
@outer # index = outer(index)
def index():
print('from index')
return 'index'
func()
index()
多层语法糖问题
def outter1(func1):
print('加载了outter1')
def wrapper1(*args,**kwargs):
print('执行了wrapper1')
res1 = func1(*args,**kwargs)
return res1
return wrapper1
def outter2(func2):
print('加载了outter2')
def wrapper2(*args,**kwargs):
print('执行了wrapper2')
res2 = func2(*args,**kwargs)
return res2
return wrapper2
def outter3(func3):
print('加载了outter3')
def wrapper3(*args,**kwargs):
print('执行了func3')
res3 = func3(*args,**kwargs)
return res3
return wrapper3
@outter1
@outter2
@outter3
def index():
print('from index')
index()
"""
多层语法糖 加载顺序由下往上
每次执行之后如果上面还有语法糖 则直接将返回值函数名传给上面的语法糖
如果上面没有语法糖了 则变形 index = outter1(wrapper2)
"""
有参装饰器
# 校验用户是否登录装饰器
def outer(mode):
def login_auth(func_name):
def inner(*args,**kwargs):
usernmae = input('username>>>:').strip()
password = input('password>>>').strip()
if mode == '1':
print('数据直接写死')
elif mode == '2':
print('数据来源于文本文件')
elif mode == '3':
print('数据来源于字典')
elif mode == '4':
print('数据来源于MySQL')
return inner
return login_auth
'''
当装饰器中需要额外的参数时>>>:有参装饰器
'''
"""
函数名加括号执行优先级最高 有参装饰器的情况
先看函数名加括号的执行
然后再是语法糖的操作
"""
@outer('1')
def index():
print('from index')
index()
@outer('2')
def func():
print('from func')
func()
装饰器模板
# 最常用的无参装饰器
def outer(func_name):
def inner(*args,**kwargs):
res = func_name(*args,**kwargs)
return res
return inner
@outer
def index():
pass
# 不常用的有参装饰器
def outer_plus(mode):
def outer(func_name):
def inner(*args,**kwargs):
res = func_name(*args,**kwargs)
return res
return inner
return outer
@outer_plus('MySQL')
def func():
pass
装饰器修复技术
from functools import wraps
def outer(func_name):
@wraps(func_name) # 仅仅是为了让装饰器的效果更加逼真 平时可以不写
def inner(*args,**kwargs):
"""我是inner 我擅长让人蒙蔽"""
res = func_name(*args,**kwargs)
return res
return inner
@outer
def func():
"""我是真正的func 我很强大"""
pass
help(func)
print(func)
func()
递归函数
1.递归函数直接或者间接调用
递归函数直接调用
def index():
print('from index')
index()
index()
递归函数简介调用
def index():
print('from index')
func()
def func():
print('from func')
index()
func()
'''最大递归深度：python解释器添加安全措施'''
count = 0
def index():
global count
count += 1
print(count)
index()
index()
"""官方提供的最大递归深度为1000 测试结果可能会出现996 997 998"""
2.递归函数
2.1直接或者间接调用自己
2.2每次调用必须比上次简单 并且需要一个明确的结束条件
递推：一层层往下
回溯：一层层往下(基于明确的结果)
"""
get_age(5) = get_age(4) + 2
get_age(4) = get_age(3) + 2
get_age(3) = get_age(2) + 2
get_age(2) = get_age(1) + 2
get_age(1) = 18
"""
def get_age(n):
if n == 1:
return 18
return get_age(n-1) + 2
res = get_age(5)
print(res)
算法简介及二分法
1.什么算法?
解决问题的有效方法，不是所有的算法都是高效 也有不合格的算法
2.算法应用场景
推荐算法(抖音视频推送 淘宝商品推送 )
成像算法(AI相关)
几乎涵盖了生活的方方面面
3.算法工程师要求
待遇非常好 但是要求非常高(985+硕士研究生起步，一般高校优秀毕业生)
4.算法部门
不是所有的互联网公司养得起算法部门，只有大型互联网公司有，算法部门类似于药品研发部门
4.二分法是什么?
定义：二分法是算法里面的最简单的算法
要求：待查找的数据集必须有序；待查找的的数据不能在开头或者结尾出现
原理：不断的对数数据集做二分切割
缺陷：针对开头结尾 查找效率很低
5.常见的算法原理以及伪代码
二分法 冒泡 快拍 插入 地推 桶排 数据结构(链表 约瑟夫问题 如何判断链表是否成环)
6.二分法使用案例
# 现在有个需求：查找列表中的某个数
l1 = [21, 76, 84, 91, 122, 132, 231, 334, 665,736, 873, 927, 987, 999]
# 方式1：for 循环 ，次数比较多
# 方式2：二分法 不断地对数据集进行二分切割
# 首先定义我们想要的查找的数据值
target_num = 873
def get_middle(l1, target_num):
# 添加一个结束条件
if len(l1) == 0:
print('很抱歉 没有找到')
return
# 1.获取列表中间的索引值
middle_index = len(l1) // 2
print(middle_index)
# 2.比较目标数据值与中间索引值的大小
if target_num > l1[middle_index]:
# 切片保留列表右边的一半
right_l1 = l1[middle_index +1:]
print(right_l1)
# 针对右边一半的列表继续二分并判断 >>>: 感觉要用递归函数
return get_middle(right_l1, target_num)
elif target_num < l1[middle_index]:
# 切片保留列表左边的一半
left_l1 = l1[:middle_index]
print(left_l1)
# 针对左边一半的列表继续二分并判断 >>>: 感觉要用递归函数
return get_middle(left_l1, target_num)
else:
print('恭喜你找到了')
# get_middle(l1, 873)
# get_middle(l1, 111)
# get_middle(l1, 21)
三元表达式
1.语法结构：
# 数据值1 if 条件 else 数据值2
"""
条件成立立即使用数据值1否则使用数据值2
应用场景：二选一
尽量不要嵌套使用
"""
# 简化步骤：代码简单并且只有一行那么就可以直接在冒号后面编写
# name = 'almira'
# if name == 'almira':print('美女')
# else:print('丑八怪')
# 三元表达式
# res = '美女' if name == 'almira' else '丑八怪'
# print(res)
# res = '美女' if name == 'almira' else '学生' if 1 ==2 else 'hahaha'
# print(res)
is_free = input('电影是否收费>>>:').strip()
rse = '收费' if is_free == 'y' else '免费'
print(res)
各种生成式
1.列表生成式
# 需求：列表中所有人的名字后面加上_SB的后缀
# 方案一：for循环
name_list = ['almira', 'lina', 'rudy', 'judy']
new_list = []
for name in name_list:
data = f'{name}_SB'
new_list.append(data)
print(new_list)
# 方案二：列表生成式
new_list = [name + "_SB" for name in name_list]
print(new_list)
2.字典生成式
s1 = 'beautiful'
for i, j in enumerate(s1, start=100):
print(i,j)
d1 = {i:j for i in enumerate('beautiful')}
print(d1)
3.集合生成式
res = {i for i in 'beautiful'}
print(res)
4.元组生成式>>>生成器*****
res = (i + 'sb' for i in 'baby')
print(res)
for i in res:
print(i)
匿名函数
1.定义：没有名字的函数 需要使用关键字lambda
2.语法结构：
lambda 形参:返回值
3.使用场景
lambda a,b:a+b
匿名函数一般不单独使用需要配合其他函数要求使用
常见内置函数
1.map() 映射
l1 = [1, 2, 3, 4, 5, 6, 5]
def func(a):
return a + 1
res = map(lambda x:x+1, l1)
print(list(res))
2.max()/min() 最大/最小值
l1 = [1, 2, 3, 4, 5, 6, 5]
res = max(l1)
print(res)
d1 = {
'almira':20000,
'lida':2122,
'judy':1212,
}
res = max(d1, key=lambda k:d1.get(k))
print(res)
3.reduce 传多个值 返回一个值
from functools import reduce
l1 = [21, 43, 65, 87, 98, 76, 54]
res = reduce(lambda a, b: a + b, l1)
print(res)
重要内置函数
1.zip() 拉链
zip() # 接受一系列可迭代的对象作为参数,将对象中对应的元素打包成一个个 tuple,然后返回由这些 tuple 组成的 list。 若传入参数的长度不等,则返回 list 的长度和参数中长度最短的对象相同
l1 = [11, 22, 33, 44, 55, 66]
l2 = ['almira', 'judy', 'rudy', 'lina', 'linda', 'lily']
l3 = [1, 2, 3, 4, 5, 6]
res = zip(l1, l2, l3)
print(list(res))
2.filter 过滤
l1 = [11, 22, 33, 44, 55, 66, 77, 88]
res = filter(lambda x: x > 40, l1)
print(list(res))
3.sorted 排序
l1 = [21, 12, 53, 64, 76, 32, 11, 22]
res = sorted(l1)
print(res) # 默认是升序
常见内置函数
1.abs() 绝对值
#取绝对值(absolute绝对)
print(abs(-111))
print(abs(212))
2.all() 所有
#所有的数据值对应的布尔值为True结果才是True 否则返回False
print(all([0, 123, 4]))
print(all([213, 323, True]))
3.any()
#所有的数据值对应的布尔值为有一个为True结果就是是True 否则返回False
print(any([0, None, '', 1]))
print(any([0, None, '']))
4.bin() oct() hex() int()
bin() # 二进制, binary 0 1
oct() # 八进制,Octal 0 1 2 3 4 5 6 7
hex() # 十六进制, HEXadecimal 0~9 a~f
int() # 整型, integer
5.bytes 转换成bytes类型
s1 = 'just do it！u can do it!'
print(s1.encode('utf8'))
print(bytes(s1, 'utf8'))
6.callable()
# 判断名字是否可以加括号调用
name = 'almira'
def index():
print('from index')
print(callable(name)) # True
print(callable(index)) # False
7.chr() ord()
# 基于ASCII码表做数字与字母的转换
# A~Z 65~90 a~z 97~122
print(chr(65)) # A 数字转换为对应的字母
print(ord('A')) # 65 字母转换为对应的序号
8.dir()
# 返回括号内对象能够调用的名字
print(dir('hello'))
9.divmod()
# 元组第一个数据为商 第二个是余数（适用于网站分页）
res = divmod(100, 3)
print(res)
# page_num, more = divmod(9999, 20)
# print(divmod(99, 10)) # (9, 9)
# if more:
# page_num += 1
# print('总页码为:', page_num) # 总页码为: 500
10.enumerate() 枚举
d1 = {i:j for i in enumerate('beautiful')}
print(d1)
11.eval() and exec()
# s1 = 'print("哈哈哈")'
# eval(s1)
# exec(s1)
# s2 = 'for i in range(100):print(i)'
# eval(s2)
eval()能力弱一点 只能识别简单的python代码；
exec()能力强一些 能识别具有逻辑性python代码 能够识别字符串中的python并执行
12.hash() 哈希加密
hash('almira')
res = hash('almira')
print(res) # 5081148859969051842
13.id() input() isinstance()
id()
input()
isinstance()
14.map() max() min()
14.1 map() 映射
l1 = [1, 2, 3, 4, 5, 6, 5]
def func(a):
return a + 1
res = map(lambda x:x+1, l1)
print(list(res))
14.2 max()/min() 最大/最小值
l1 = [1, 2, 3, 4, 5, 6, 5]
res = max(l1)
print(res)
d1 = {
'almira':20000,
'lida':2122,
'judy':1212,
}
res = max(d1, key=lambda k:d1.get(k))
print(res)
15.open()
with open(r'a.txt', 'r', encoding='utf8') as f:
print(f.read())
16.pow()
# 幂指数
pow()函数 Python的内置函数,它计算并返回x的y次方的值。
pow(x, y, z) # 参数 x -- 数值表达式。 y -- 数值表达式。 z -- 数值表达式
17.range()
eg: 编写代码自动生成所有页网址(注意总共多少页)
https://movie.douban.com/top250
""""
https://movie.douban.com/top250
https://movie.douban.com/top250?start=25&filter=
https://movie.douban.com/top250?start=50&filter=
https://movie.douban.com/top250?start=75&filter=
https://movie.douban.com/top250?start=100&filter=
"""
# 先定义网址的模板
base_url = ' https://movie.douban.com/top250?start=%s&filter='
for i in range(1,251):
print(base_url % i)
18.round()四舍五入
print(round(98.5)) # 98
print(round(98.2)) # 98
# 结果不够精确
19.sum求和
print(sum([123, 47, 82, 94, 54, 1, 874])) #列表里面的每一个数连续加
20.zip()
zip
l1 = [11, 22, 33, 44, 55, 66]
l2 = ['almira', 'judy', 'rudy', 'lina', 'linda', 'lily']
l3 = [1, 2, 3, 4, 5, 6]
res = zip(l1, l2, l3)
print(list(res))
可迭代对象
1.定义：数据对象内置有__iter__方法的都称为可迭代对象
"""
内置方法 通过点方法能够调用的方法
__iter__(双下iter)
"""
2.课迭代对象的范围
*不是可迭代对象
int float bool
*是可迭代对象
str list dict tuple set 文件对象
3.可迭代的含义
"""
迭代：更新换代(每次更新都必须依赖上一次的结果)
eg:手机app更新
"""
#可迭代在python中可以理解为是否支持for循环
迭代器对象
1.迭代器对象
是由可迭代对象判断的本质是看是否内置有__iter__和__next__
2.迭代器对象的作用
提供了一种不依赖于索引取值的方式，正因为有迭代器的存在 字典 集合才能被for循环
3.迭代器对象的实操
s1 = 'hello' # 可迭代对象
res = s1.__iter__() # 迭代器对象
print(res.__next__()) # 迭代取值for循环的本质
*一旦__next__取不到值 就会直接报错*
4.迭代器对象注意事项
可迭代对象调用__next__会成为迭代器对象 迭代器对象如果还调用__next__不会有任何变化还是迭代器对象本身
for循环的本质
for 变量名 in 可迭代对象:
循环体代码
"""
1.先将in后面的数据调用__iter__转变成迭代器对象
2.依次让迭代器对象调用__next__取值
3.一旦__next__取不到直接报错 for循环会自动捕获并处理
"""
异常捕获 / 处理
1.异常
异常就是代码运行报错 行业俗语bug 代码运行中一旦遇到异常会直接结束整个程序的运行 我们在编写代码的过程中尽量部门异常
2.异常类型
# 语法错误：
不允许出现，一旦出现立刻改正 否则提桶跑路
# 逻辑错误：
允许出现的，因为这种错误不容易被发现，代码运行之后会报错这时才可以知道具体什么错误
3.异常结构
异常结构(这个一定要学会看，出现报错时可以快速定位错误)
# 错误位置
# 错误类型
# 错误详情
标签：总结,
03,
index,
res,
func,
time,
print,
def
From： https://www.cnblogs.com/almira998/p/16797465.html