# break 让当前这个循环立即停止
# continue 停止当前本次循环，继续执行下一次循环
while i <= 10:
if i==4:
i=i+1
continue
print(i)
i=i+1
for 变量 in 可迭代的东西：
print(变量)
for i in range(10):
print(i)
# range(m,n,s): 从m数到n，不包含n,每次的间隔是s
int, float, bool, str, list, tuple, set, dict, bytes
a = "10"
print(type(a)) # <class 'str'>
b = int(a)
print(type(b)) # <class 'int'>
c = bool(b)
print(type(c)) # <class 'bool'> 布尔，数值，非0️⃣都是true，0是false
字符串，非空字符串都是true，空字符串是false
s = ""
print(bool(s)) # False
lst = []
print(bool(lst)) # False 列表，空的是false，非空的都是true
while 1: 无限循环，死循环
content = input("请输入:")
if content:
print("要发的内容是：",content)
else:
break
# 字符串 格式化
s1 = "我叫%s, 我住在%s, 我今年%d岁，我喜欢%s。" % (name, address, age, hobby)
s2 = "我叫{}, 我住在{}, 我今年{}岁，我喜欢{}。".format(name, address, age, hobby)
s3 = f"我叫{name},我住在{address},我今年{age}岁，我喜欢{hobby}。"
# 索引和切片
s = "我叫周杰伦"
print(s[3]) # 杰
print(s[-1]) # 伦 负数 是倒数
print(s[2:4]) # 周杰伦 从索引2位置切片，到4结束，不包含4
# s[start:end] 从start到end进行切片，但是取不到end
s[0:5] 等同于 s[:5]
s[3:] 从3位置取到末尾
s[:] 从开头取到末尾
s[-3:-1] # 周杰伦 只能从左到右切片
s[-1:-3] # 没结果 取不到值
s[::-1] # 负号 表示从右到左 输出：伦杰周叫我
# s[start:end:step] 从start切到end，每step个元素出来一个元素
# 字符串操作一般不会对原字符串产生影响，一般返回一个新的字符串
s = "python"
s1 = s.capitalize()
s 不变，s1变成 Python
s = "I have a dream!"
s1 = s.title()
print(s1) # I Have A Dream!
s.lower() 变成小写
s.upper() 变成大写
# 替换和切割
s.strip() # 去掉两头的空白
replace(old, new) 字符串替换
s="我是张三"
s1=s.replace("张三","周杰伦")
print(s1) # 我是周杰伦
a.replace(" ","") # 去掉所有的空格
a = "python_java_c_js"
lst = a.split("_")
lst => ['pyhton','java','c','js']
ret = a.find("p")
print(ret) # 0 索引值 从0开始，空格也算
# 等同于 a.index("p")
# find() 找不到就返回 -1
# index()找不到 index() 程序就会报错
print("abc" in a) # False
print("abc" not in a) # True
a.startswith("张") # False
a.endswith("张") # False
a.isdigit(): # 判断字符串是否是数字整数
len(a) # 字符串a的长度 length
s="python_java_js"
lst = s.split("_")
lst => ['python', 'java', 'js']
b = "_".join(lst)
b => "python_java_js" # 把列表中的字符串连起来成一个字符串
c = "".join(lst)
c => "pythonjavajs"
# 列表
lst = ["张三", "王五", [1, 2, 3]]
# 列表像字符串一样，也有索引和切片
lst[0] => 张三
lst[1:3] => ['王五', [1, 2, 3]]
lst[::-1] => [[1, 2, 3], '王五', '张三'] # 倒序取结果
lst[4] # 索引超过了就会报错 lst index out of range
lst.append("李四")
lst.append() 追加，直接放在列表最后面
lst.insert(0, "某某") 插入，指定索引位置
lst.extend(["赵六", "张麻子"]) 合并两个列表，批量添加，赵六，张麻子都是添加到lst的最后
ret = lst.pop(3) # 删除 ret 是 索引为三的对象，lst是删除后的剩余
lst.remove("张三") # 删除某个元素
# 修改，直接使用索引修改
lst[2] = "王小二"
# 查询，直接使用索引查询
print(lst[3])
lst=[1,3,6,5]
lst.sort()
print(lst) # [1,3,5,6] 排序，降序
lst.sort(reverse=True)
print(lst) # [6,5,3,1] 升序
# 列表的嵌套
lst = [1, [2, [3, 5], 6], 7]
lst[1][1][1] => 5
lst[2][3][2] = lst[2][3][2].upper() # 只有这样才是变大字符串
for item in lst:
if item.startswitch("张"):
lst.remove(item)
# 会发现，只删除 第一个张绍刚，紧接着后面的张无忌没有删除，因为在删除张绍刚时，
# 后面的张无忌自动往前进了一位，导致张无忌没有被删除
# 要确保都删除了，需要添加一个临时的列表，负责存储要删除的内容
temp = []
for item in lst:
if item.startswith("张"):
temp.append(item)
for item in temp:
lst.remove(item)
# tuple 元组 特点： 不变的列表
t = ("张三", "李四", "王五")
t[1] => 李四
t[1:2] => ("李四", "王五")
t[1] = "赵六" # 报错，因为元组的值无法修改 tuple object does not support item assignment
# 元组如果只有一个元素，相当于单独的变量，小括号是表示优先级，而不是元组的符号
print(("哈哈")) => 哈哈
print(type(("哈哈"))) => <class 'str'>
print(type(("哈哈",))) => <class 'tuple'>
# 如果元组只有一个元素，需要加上个逗号
# 元组中的列表的值是可以改变的，例如人的拔牙
t=[1,2,["拔牙", "美言"])
t[2].append("呵呵哒") # 增加了t[2]的值
# set 集合
# set 集合是无序的
s={1,2,3}
# set 集合里不能放入列表，集合中不能放入不可哈希的值，例如列表
# Python中的set集合进行数据存储的时候，需要对数据进行哈希计算，根据计算的哈希值进行存储
# 列表能增删改查，元组不能改变，所以集合中可以有元组
# 不可变的数据类型：int, str, tuple, bool
# 可变的有：list, dict, set
# set集合中不能嵌套set集合，
s = set() # 创建空集合
t = tuple()
l = list()
s = str()
s = set()
s.add("张三")
s.add("李四")
s.pop() # 因为set集合无序，所以不知道删除的是哪一个值
# 要修改，需要先删除，再添加
s.remove("张三")
s.add("张麻子")
s1 = {1,2,3}
s2 = {2,3,4}
s1 & s2 # 交集
s1 | s2 # 并集
s1.union(s2) # 并集
s1 - s2 # 差集
s1.difference(s2) # 差集
s1.add(1) # 添加后没有两个1，列表中不能添加重复的数据。
# 利用set集合不能添加和包含重复的数据，可以去重
lst = [1,2,3,2,4,1]
lst = list(set(lst))
# 这样列表就去重了
s = {1,2,1,2}
print(s) # {1,2} 集合中不能包含重复的数据
# dict 字典
# 字典是以键值对来存储数据的
# {key:value}
dic = {"jay":"周杰伦","金毛狮王":"谢逊"}
val = dic["jay"] # 周杰伦
# 字典的key必须是可哈希的数据类型 unhashable type:list
# 字典的value可以是任何数据类型
dic = dict()
dic['jay'] = "周杰伦"
# 字典赋值，直接放
# 修改也是直接赋值
dic['jay'] = "昆凌"
dic.setdefault("tom","胡辣汤")
# 设置默认值，如果已经有了该key了，再用就不起作用了
# 删除
dic.pop("jay") # 根据key去删除
del dic['jay'] # 表达式，不常用，不推荐
# 查询
dic['jay'] # 如果key不存在，程序会报错，keyError
dic.get('jay') # 如果key不存在，程序不会报错，直接输出 None
# 绝大多数时候知道key，所以上述两种方法都是常用的
# None 什么都没有
print(type(None)) # <class 'NoneType'> 空类型
s = "" # 空字符串，.后 可以有很多操作，而None啥也操作不了
name = input("请输入姓名：")
val = dic.get(name)
if val is None:
print("我们村没这人")
else:
print(val)
# 使用for循环字典，拿到的就是字典的key
for key in dic:
print(key, dic[key])
dic.keys() # 拿到所有的key，key组成的元组列表 => dict_keys(['key1','key2',...])
lst = list(dic.keys()) # => 转换成列表 ['key1','key2',...]
dic.values() # 拿到所有的value, dict_values(['value1', 'value2',...])
dic.items() # 拿到所有的key和value，dict_items([('key1','value1'),('key2','value2'),...])
# 循环可以拿到key，value的元组，key = item[0],value = item[1]
for item in dic.items():
print(item)
# ('key1','value1')
# ('key2','value2')
# ...
a, b = (1,2) # a=1,b=2 元组或列表都可以执行该操作，叫做 解构，解包
a, b = 1,2 # a=1,b=2
# 上面的可以写成 key, value = item
for key,value int dic.items():
print(key,value)
# 这样就直接输出key和value了
# 字典的嵌套
汪峰 = {"abc":{"bcd":{"name":"哈哈"},"dce":{"name":"呵呵"}}}
# 取值
汪峰['abc']['bcd']['name'] # => 哈哈
# 如果字典里面有列表，使用索引定位 汪峰['abc']['bcd'][1]
# 字典在循环的时候不能改变字典的值
temp = []
for key in dic:
if key.startswith("大"):
temp.append(key)
for t in temp:
dic.pop(t)
# 8bit = 1 byte 8位 = 1个字节
s = "周杰伦"
s1 = s.encode("gbk")
# s1 => b'\xd6\xdc....' s1的长度6个
# b'xxx' bytes类型
s2 = s.encode("utf-8")
# s2 => b'\xe5\x91...' s2的长度9个
# 英文： 8bit 1byte
# 欧洲： 16bit 2byte
# 中文： 24bit 3byte
s3 = s2.decode("gbk") # 解码
# 两个数调换值，不需要temp进行过度
temp = a
a = b
b = temp
# 下面代码仅适用于python
a, b = b, a # 把b的值赋值给a，把a的值赋值给b
# 逻辑运算符 and or not
# 打开文件
open(路径, mode="", encoding="")
f = open("xx.txt", mode="r", encoding="utf-8")
content = f.read()
print(content) # text 文档的具体内容
# r read 读
# w write 写（open的时候先清空）
# a append 追加写
# b 读写的是非文本文件 => bytes
# 文件太大，需要分开读取，一部分一部分的读取
line = f.readline() # 读取第一行
line = f.readline() # 读取第二行
# print()打印，会自带一个换行，而readline()读取txt文档的一行，末尾也有换行，
# 加起来就有两个换行了
line = f.readline().strip() # 去掉了末尾的空白、换行、制表符
content = f.readlines()
print(content) # => ['互联网\n', '风雨都不怕\n', ...] 把换行符也打印出来了，放在列表里面
# 文本读取方式，获取行数
for line in f:
print(line.strip())
# line 就是从文档中获取每一行
# open打开文件，若文件不存在，就创建一个
# w模式下，每一次open就会清空文档内容
f = open("xx.txt", mode="w", encoding="utf-8")
f.write("张三")
f.close()
# 写模式下，每次都需要关闭链接
lst = ['1','2',...]
for item in lst:
f.write(item)
f.write("\n")
f.close()
# with 打开文件，自动关闭链接
with open("xx.txt",mode="r",encoding="utf-8") as f: # f = open()
for line in f:
print(line.strip())
# 只能在with里面操作文档，在外面访问不到，因为已经被自动关闭了
# 读取图片
with open("xx.jpg",mode="rb") as f1, \
open("xx2.jpg",mode="wb") as f2: # 没有encoding，表示非文本文件
for line in f1:
f2.write(line)
f2.write("\n")
import os # 操作系统相关
import time # 和时间相关的模块
time.sleep(3)
os.remove("xx.txt")
os.rename("abc.txt","bcd.txt") # 把 abc.txt 改名为 bcd.txt
# ---------------------------------------------------------
r open for reading
w open for writing
x create a new file and open it for writing
a oepn for writing, appending to the end of the file if it exists
b binary mode
t text mode
+ open a disk file for updating (reading and writing)
U universal newline mode (deprecated)
# ---------------------------------------------------------
# 参数：可以在函数调用的时候，给函数传递信息
# 形参，在函数定义的时候，准备变量接收信息
# 实参，实际在调用的时候传递信息
# 实参， 1，位置参数，按照参数的位置，进行传递参数
# 2，关键字参数，按照参数的名字，进行传递参数
# 3，混合参数，顺序：位置参数在前，关键字参数在后，否则报错
# 必须保证位置参数有值，形参有数据
# 形参，1，默认值参数，默认值参数要放在后面
# 2，位置参数
# 3，动态参数，（*arg）接收所有的位置参数
# （**kwargs）接收所有的关键字参数
def chi(*fool): # * 星号表示位置参数的动态传参，表示多个参数，放在一个元组里
print(food)
def chi(*foor,**kwargs): # ** 两个星号表示关键字参数的动态传参，放在一个字典里
def func(a,b,c="哈哈",*args,**kwargs):
print(a,b,c,args,kwargs)
func(1,2,3,4,5,6,7,8,9,hello=456,haha=567)
# => 1 2 3 (4,5,6,7,8,9) {'hello':456,'haha':567}
# 顺序： 位置 > *args > 默认值 > **kwargs
def func(*args,**kwargs): # 没有限制的接收任何参数，包含位置参数，和关键字参数
print(args,kwargs)
func(1,2,3,4,c=4,a=2) # => (1,2,3,4) {'c':4,'a':2}
lst = ['a','b','c']
# 把列表的元素当成函数参数传递进来
def func(*args):
print(args)
func(*lst) # * 在实参位置，是把列表打散成 位置参数 进行传递
# ** 在实参位置，可以把字典自动转化成 关键字参数 进行传递
# 函数在结束的时候默认返回None
def func():
pass
return None # 不写return，默认返回None
ret = func()
print(ret) # => None
# 内置函数
a=18
bin(a) # 0b10010 2进制
oct(a) # 0o22 8进制
hex(a) # 0x12 16进制
b=0b10010
int(b) # 18 二进制转化成十进制
pow(10,3) # 1000 10的3次方
(10 ** 3) # 1000 等同于 10 的3次方，次幂
lst = [1,3,5,7]
max(lst) # 7
min(lst) # 1
sum(lst) # 16
s = slice(1,4,2) # 从1切到4，间隔2个，等同于[1:4:2]
print("呵呵呵呵呵额呵呵"[s])
# format,ord,chr
a = 18
format(a,"b") # 变成2进制
format(a,"x") # 16进制
format(a,"o") # 8进制
a = 1
format(a,"08b") # 不够8位，由0补充的8位2进制，超过8位则忽略
a = "中" # python 内存中使用的是Unicode
ord(a) # 20013 中 字在Unicode中的码位是20013
chr(20013) # 中 用Unicode的码，输出对应的字
# Unicode的只有65536个字符
for i in range(65536):
print(chr(i)+" ",end="") # 默认print打印会换行，使用end让结尾不换行
# mac 是utf-8 windows 是 gbk
# 列表可变，元组不可变，集合可变，冻结的集合不可变 frozenset
# enumerate, all, any
# 把all当成and来看
all([0,"",'哈哈']) # False
# 把any当成or来看
lst = ["张三","李四"]
for item in enumerate(lst):
print(item)
# (0,'张三')
# (1,'李四')
# enumerate 是可以拿到索引和值
for index, item in enumerate(lst):
print(index,item)
# 0 张三
# 1 李四
# 相当于下面的：
for i in range(len(lst)):
print(i,lst[i])
s = "哈哈"
print(hash(s))
# 哈希值出来是一串数字，想办法转换成内存地址，然后进行存储
# 同一次运行的时候，哈希值是一样的
print(id(s)) # id 直接拿到存储地址
help(s) # 查看字符串str有什么方法
dir(s) # 当前数据能执行哪些操作
# 重要内容：函数
# 函数的嵌套
# 变量的作用域
# 闭包
# 装饰器
# 迭代器
# 生成器
# 推导式
# 匿名函数
# python 内置函数 sorted, filter, map,
def func():
c = 10086
return c
c1 = func()
# c1 就是等于 函数内的c
# 函数的嵌套
def func1():
def func2():
pass
def func():
def inner():
print(123)
print(inner)
return inner # 返回的是一个函数 inner()加括号就执行了
b1 = func()
b1()
# <function func.<locals>.inner at 0x10c78bb90>
# => 123 相当于执行inner()
# b1 等于 inner, 指向同一个地址
def func(an):
an()
def target():
print("target")
func(target) # => target
# global 把全局的变量，引入到函数内
a = 10
def func():
global a
a = 20
# 改变了全局变量a的值
# nonlocal 把外层的变量引入，引入全局变量只能是global
# 外一层有就引入，没有再往外一层找，不包括全局变量，没找到就报错
# 闭包
# 1.让一个变量nonlocal后常驻内存
# 2.避免全局变量被修改，保护全局变量，避免被污染
def func():
a = 10
def inner():
print(a)
return a
return inner
# 内部的inner函数就形成了一个闭包函数
def func():
a = 10
def inner():
nonlocal a
a += 1
return a
return inner
ret = func()
r1 = ret()
r2 = ret()
print(r1,r2) # 11 12
# 装饰器
# 1.函数可以作为参数进行传递
# 2.函数可以作为返回值进行返回
# 3.函数名可以作为变量进行赋值操作
def func1():
print("函数1")
def func2():
print("函数2")
func1 = func2
func1() # => 函数2
def guanjia(game):
def inner():
print("开启外挂")
game()
print("关闭外挂")
return inner
def play_dnf():
print("玩dnf")
def play_lol():
print("玩lol")
@guanjia
def play_wangzhe():
print("玩王者")
play_dnf = guanjia(play_dnf)
play_lol = guanjia(play_lol)
play_dnf()
play_lol()
play_wangzhe()
# 装饰器 @guanjia 本质上是一个闭包，闭包是内层函数对外层函数变量做一个引用
# 作用是，在原有函数不变的情况下，给函数前后增加新功能
# 用途：在用户登录的地方，日志等，不修改原有代码的情况下，前后添加功能
# def wrapper(fn): wrapper 装饰器 fn 目标函数
def wrapper(fn):
def inner():
# 目标函数之前添加代码
fn()
# 目标函数之后添加代码
return inner
def guanjia(game):
def inner(*args,**kwargs): # args 是元组 kwargs 是字典
print("")
game(*args,**kwargs) # 把args元组和kwargs字典打散
print("")
return inner
# 标准的装饰器：
def wrapper(fn):
def inner(*args,**kwargs):
# 目标函数之前添加代码
ret = fn(*args,**kwargs)
# 目标函数之后添加代码
return ret
return inner
@wrapper
def target():
pass
target() # => inner() 并且有返回值 ret
# 装饰器的叠加
@wrapper1
@wrapper2
def target():
print("目标函数")
# => wrapper1 进入
# wrapper2 进入
# 目标函数
# wrapper1 退出
# wrapper2 退出
# 迭代器
for i in "abc": # 必须是可迭代的 iterable
# 获取迭代器的两种方法
# 1.iter() 内置函数可以直接拿到迭代器 iterator
it = iter("字符串")
# 1.1.next() 可以从迭代器中拿出数据
next(it) # => 字
next(it) # => 符
next(it) # => 串
next(it) # 报错，迭代已经停止了，不能再拿了
# 2 __iter__()
it = "字符串".__iter__()
it.__next__() # => 字
next(it) # => 符
# 2.1 __next__() 从迭代器中拿数据，和next()一样，可以相互换用
# 为了防止 从迭代器中拿数据出错，可以用try
while 1:
try:
data = it.__next__()
print(data)
except StopIteration:
break
# str list tuple dict set open()
# 以上都可以使用迭代器，因为它们都是可迭代的
for i in 可迭代：
# 可迭代：iterable
# 迭代器：iterator
# 迭代器：统一了不同数据类型的遍历工作
# 1.迭代器本身也是可以被迭代的
s = "字符串"
it = s.__iter__()
for item in it:
print(item)
# 字
# 符
# 串
# 2.迭代器只能向前，不能反复
# 3.迭代器特别的节省内存，像指针一样，节省内存
# 4.惰性机制，不访问就不会向前，next() __next__() 就下一个
# 生成器
# 生成器的本质就是迭代器
# 创建生成器：1.生成器函数 2.生成器表达式
# 1.生成器函数 关键字：yield
# 把 return 换成 yield ，就变成生成器了
def func():
print(123)
return 999
ret = func()
print(ret) # 999
def func():
print(123)
yield 999
ret = func()
print(ret) # <generator object func at 0x115f2dbd0>
# 2.生成器函数执行的时候，并不会执行函数，得到的是生成器
# yield 只有执行next() __next__() 才返回数据，return是立即返回
print(ret.__next__())
# 123
# 999
# ret.__next__() => 123 返回值需要有个数据来接收
# 函数只有一个yield，只能用一次__next__()
# 只要函数出现yield，函数就是生成器函数，可以分段返回数据
def func():
print(123)
yield(333)
print(456)
yield(666)
ret = func()
print(ret.__next__()) # 123 333
print(ret.__next__()) # 456 666
def order():
lst=[]
for i in range(1000):
lst.append(f"衣服{i}")
if len(lst) == 20:
yield lst
# 下一次拿数据
lst = []
gen = order()
print(gen.__next__())
# 先看推导式，再回过头看生成器表达式
# 推导式：简化代码
# 1.列表推导式 2.集合推导式 3.字典推导式
lst = []
for i in range(10):
lst.append(i)
# 1.列表推导式 ： [数据 for 循环 if 判断]
lst = [i for i in range(10)]
print(lst) # [0,1,2,3,4,5,6,7,8,9]
# 创建一个列表[1,3,5,7,9]
lst = [i for i in range(1,10,2)]
lst = [i ofr i in range(10) if i % 2 ==1]
# 生成50件衣服
lst = [f"衣服{i}" for i in range(50)]
# 将字母变成大写
lst1 = ["allen","tony","andu"]
lst2 = [item.upper() for item in lst1]
# 2.集合推导式： {数据 for 循环 if 判断}
s = {i for i in range(10)}
# 3.字典推导式： {k:v for 循环 if 判断}
# 请将列表修改成字典，索引做为key
lst = ["张三","李四","王五"]
dic = {i:lst[i] for i in range(len(lst))}
# 没有元组推导式，元组是不可变的，所有没有元组推导式
# (数据 for 循环 if 判断) 这个不是元组推导式，它叫生成器表达式
# 生成器表达式
# 语法：(数据 for 循环 if 判断)
gen = (i**2 for i in range(10))
print(gen) # <generator object <genexpr> at 0x102234> 生成器
print(gen.__next__()) # 0
print(gen.__next__()) # 1
print(gen.__next__()) # 4
print(gen.__next__()) # 9
# 生成器本质就是一个迭代器，迭代器是可以被迭代的
for item in gen:
print(item)
# 0 1 4 9 16 25 ...
# 把生成器里面的数据变成列表
lst = list(gen)
print(lst) # [0,1,4,9,16,25,36,49,64,81]
# list() set() 本身是有一个迭代的
s = list("周杰伦")
print(s) # ['周','杰','伦']
# 所以，list() 里面一定有 for 循环，for循环里面有 next()拿数据
# 生成器表达式是一次性的，数据拿光了就没了
# gen里面的数据取过一次，第二次再取就没数据了
gen = (i**2 for i in range(10))
lst1 = list(gen)
lst2 = list(gen)
print("lst1:",lst1)
print("lst2:",lst2)
print("lst1:",lst1)
print("lst2:",lst2)
# lst1: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
# lst2: []
# lst1: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
# lst2: []
# 匿名函数 就是 lambda表达式
def func():
print(123)
return 666
ret = func()
print(ret) # 123 666
# 等同于 lambda表达式
# 变量 = lambda 参数1，参数2，...:返回值
def func(a,b):
return a+b
ret = func(2,3)
fn = lambda a,b:a+b
print(fn) # <function <lambda> at 0x10452ab90>
print(fn(2,3)) # 5
# fn 本质上就是一个匿名函数，也是lambda表达式
# 匿名函数 常与内置函数中的 sorted filter map 等一起使用
# 内置函数：sorted zip filter map，迭代器相关的：range next iter
# zip : python提供的一个功能
lst1 = ["张三","李四","王五"]
lst2 = [22,26,18]
lst3 = ["高","富","帅"]
ret = []
for i in range(len(lst1)):
ret.append((lst1[i],lst2[i],lst3[i]))
print(ret)
# [('张三', 22, '高'), ('李四', 26, '富'), ('王五', 18, '帅')]
# 使用zip来实现
result = zip(lst1,lst2,lst3)
print(result) # <zip object at 0x0000017B3AFBB480>
lst = list(result)
print(lst) # [('张三', 22, '高'), ('李四', 26, '富'), ('王五', 18, '帅')]
print(locals()) # locals() 全局作用域范围内的内容，包括全局变量等
def func():
a = 333
print(locals()) # 此时，locals只包含 a = 333 等局部的变量
# globals() 不管写在哪儿，显示的都是全局的东西
# eval exec compile
# eval : 执行字符串类型的代码，返回最终结果
# exec : 执行字符串类型的代码
# compile : 将一个字符串编译为字节代码
# zip 可以把多个可迭代的内容进行合并
# sorted 排序 (可迭代的内容，key=排序规则或排序函数, reverse=False)
lst = [3,2,4,6,5]
s = sorted(lst,reverse=False)
print(s) # [2, 3, 4, 5, 6]
s = ["张三","李四","王五"]
def func(item):
return len(item)
s1 = sorted(s, key=func)
# 使用lambda改写函数
func = lambda x: len(x)
# 或者直接写在key里
s2 = sorted(s, key=lambda x:len(x))
lst = [
{"id":1, "name":"周润发","age":18, "salary":5000}
]
# 根据年龄排序
s = sorted(lst,key = lambda d:d['age'])
# 根据工资进行排序，从大到小
s = sorted(lst,key = lambda d:d['salary'],reverse=True)
# filter 筛选 (筛选的条件，要筛选的对象)
lst = ["张三","李四","王五"]
# 筛选姓张的名字
f = filter(lambda x:x.startswith("张"),lst)
print(f) # <filter object at 0x107c83910> f 是个生成器
print(list(f)) # ['张三'] 把生成器转换成列表
# 筛选出 不 姓张的出来
f2 = filter(lambda x: not x.startswith("张"),lst)
print(list(f2)) # ['李四', '王五']
# map 映射
lst = [1,2,3,4]
# 使用map计算每一项的平方值
ret = [item*item for item in lst] # 列表推导式
print(ret) # [1, 4, 9, 16]
# 使用map 结果是
ret2 = map(lambda x:x*x,lst)
print(ret2) # <map object at 0x000002BECD12A440>
print(list(ret2)) # [1, 4, 9, 16]
# python 死循环最大数是1000，递归最大深度1000层
import sys
print(sys.getrecursionlimit()) # 1000
# 递归 ： 函数自己调用自己，递归如果没有任何拦截的话，它默认就是一个死循环
浙公网安备 33010602011771号