"""
函数参数的分类：
1.位置参数
2.关键字参数
3.默认参数
4.可变参数
*args
可以给0,1，多个任意类型的实参
**kwargs
可以给0,1，多个键值对类型的实参
函数参数传递的方式：
实参->形参
值？
基本类型
在函数内操作，对源数据没有任何影响
地址？
可变类型
在函数内操作，源数据同样会发生改变
递归函数
直接或者间接调自己
递归本质：
压栈操作
栈的工作原理(弹夹原理：先进后出 FILO)
斐波那契数列
汉诺塔（课下查）
青蛙跳台阶
递归错误：栈溢出错误
命名空间：
分类：
内置
全局
globals()
局部
locals()
加载顺序：
内置 -> 全局 -> 局部
B G L
搜索顺序：
局部 -> 全局 -> 内置
L G B
作用域（LEGB）
L:
局部
当前函数
E:
闭包
嵌套函数的内部函数中
G:
全局
当前文件中的所有函数
B:
内置
所有文件
"""
a = 10
def func1(c = 10):
d = 20
print(locals())
print(a)
def func2():
x = 10
print(x)
def func3():
print(a)
# print(globals())
print(__name__)
print(__file__)
print(a)
print(func1)
func1()
"""
基础稳固
1.封装函数，可以判断一个数字是否为偶数
2.封装函数，可以实现1-n之间所有偶数的打印，每a个一行
3.封装函数，可以找出整型列表中的最大值
4.封装函数，可以找出整型列表中的最大值的索引
5.封装函数，可以找出整型列表中的最小值
6.封装函数，可以找出整型列表中的最小值的索引
7.封装函数，可以求任意多个数字的和,并返回这个和(参数可以使用*args)
能力提升
1.封装函数，可以完成列表的倒序(前后对应位置的元素，位置交换)
2.封装函数，可以判断一个整数是否为质数
3.封装函数，可以打印1-a之间所有的质数,每b个进行一次换行
4.封装函数，可以求出两个数字的最大公约数
"""
# 判断n 是否为偶数
def is_even_number(n):
"""
判断n 是否为偶数
:param n:要判断的数字
:return:bool 如果n为偶数，返回True，否则，返回False
"""
return n % 2 == 0
# help(is_even_number)
# import random
# help(random.randint)
def show_even_numbers(start,n,a=5):
# 用来计数（偶数的个数）
count = 0
for i in range(start,n+1):
if is_even_number(i):
count += 1
print(i,end='\t')
# 当计数器达到指定数量时，执行换行操作
if count == a:
print()
# 计数器清0
count = 0
# show_even_numbers(1,20)
# show_even_numbers(1,100,10)
def get_max_value(list1):# [1,10,2,-4,3]
# 假设列表中的最大值为第一个元素
m = list1[0]
# 有后续的元素逐个比较，来查找实际的最大值
for i in range(1,len(list1)):
if m < list1[i]:
m = list1[i]
return m
# print(get_max_value([1,10,2,3]))
# 查找列表中最大值的索引
def get_max_index(list1):
m = 0
for i in range(1,len(list1)):
if list1[i] > list1[m]:
m = i
return m
print(get_max_index([1,10,2,3,10]))
"""
基础稳固
1.封装函数，可以判断一个数字是否为偶数
2.封装函数，可以实现1-n之间所有偶数的打印，每a个一行
3.封装函数，可以找出整型列表中的最大值
4.封装函数，可以找出整型列表中的最大值的索引
5.封装函数，可以找出整型列表中的最小值
6.封装函数，可以找出整型列表中的最小值的索引
7.封装函数，可以求任意多个数字的和,并返回这个和(参数可以使用*args)
能力提升
1.封装函数，可以完成列表的倒序(前后对应位置的元素，位置交换)
2.封装函数，可以判断一个整数是否为质数
3.封装函数，可以打印1-a之间所有的质数,每b个进行一次换行
4.封装函数，可以求出两个数字的最大公约数
"""
# 判断n 是否为偶数
def is_even_number(n):
"""
判断n 是否为偶数
:param n:要判断的数字
:return:bool 如果n为偶数，返回True，否则，返回False
"""
return n % 2 == 0
# help(is_even_number)
# import random
# help(random.randint)
def show_even_numbers(start,n,a=5):
# 用来计数（偶数的个数）
count = 0
for i in range(start,n+1):
if is_even_number(i):
count += 1
print(i,end='\t')
# 当计数器达到指定数量时，执行换行操作
if count == a:
print()
# 计数器清0
count = 0
# show_even_numbers(1,20)
# show_even_numbers(1,100,10)
def get_max_value(list1):# [1,10,2,-4,3]
# 假设列表中的最大值为第一个元素
m = list1[0]
# 有后续的元素逐个比较，来查找实际的最大值
for i in range(1,len(list1)):
if m < list1[i]:
m = list1[i]
return m
# print(get_max_value([1,10,2,3]))
# 查找列表中最大值的索引
def get_max_index(list1):
m = 0
for i in range(1,len(list1)):
if list1[i] > list1[m]:
m = i
return m
# print(get_max_index([1,10,2,3,10]))
def get_min_value(list1):# [1,10,2,-4,3]
# 假设列表中的最小值为第一个元素
m = list1[0]
# 有后续的元素逐个比较，来查找实际的最小值
for i in range(1,len(list1)):
if m > list1[i]:
m = list1[i]
return m
# print(get_max_value([1,10,2,3]))
# 查找列表中最小值的索引
def get_min_index(list1):
m = 0
for i in range(1,len(list1)):
if list1[i] < list1[m]:
m = i
return m
# print(get_min_value([1,10,2,3]))
# print(get_min_index([1,10,2,3]))
# 7.封装函数，可以求任意多个数字的和,并返回这个和(参数可以使用*args)
def get_sum(*args):
s = 0
for i in args:
if type(i) == int or type(i) == float:
s += i
return s
# sum = get_sum(1,2,3,2.5,-6,9.2,['a','c'])
# print(sum)
# 1.封装函数，可以完成列表的倒序(前后对应位置的元素，位置交换)
def reverse_list(list1): # [1,2,3,4]
count = len(list1) // 2
for i in range(count):
# 待实现： 使用负值完成对应位数的交换
list1[i],list1[len(list1)-1-i] = list1[len(list1)-1-i],list1[i]
# 切片操作，返回一个翻转的新列表
# return list1[::-1]
# list2 = [1,2,3,4]
# print(f'交换前：{list2}')
# v = reverse_list(list2)
# print(f'交换后：{list2}')
# print(v)
# 判断数字n是否为质数
def is_prime_number(n):
for i in range(2,n):
if n % i == 0:
return False
else:
return True
def show_prime_number(a,b):
count = 0
for i in range(1,a+1):
if is_prime_number(i):
print(i,end='\t')
count += 1
if count == b:
print()
count = 0
# show_prime_number(100,5)
# 4.封装函数，可以求出两个数字的最大公约数
def divisor(a,b): # 求a，b的最大公约数
list_a = []
list_b = []
# 1.先找出a的所有约数 []
for i in range(1,a+1):
if a % i == 0:
list_a.append(i)
# 2.找出b的所有约数 []
for i in range(1,b+1):
if b % i == 0:
list_b.append(i)
# 3.取交集
# s1 = set(list_a) & set(list_b)
# list1 = list(s1)
# # 4.返回交集中最大值
# return get_max_value(list1)
return get_max_value(list(set(list_a)&set(list_b)))
# print(divisor(12,122))
"""
全局变量与局部变量
1.定义位置不同：
全局变量定义在函数外
局部变量定义在函数内
2.作用域不同：
全局变量的作用域，所有函数中都可以用
局部变量的作用域，只在当前函数中可以用
3.生命周期不同：
全局变量的生命周期（程序的生命周期），比较长
局部变量的生命周期,(函数被调用时，出生，函数调用结束，局部变量释放)，比较短
4.存储位置不同：
全局变量（不在栈上）
局部变量（存在栈上）
global：
声明一个变量为全局变量
使用场景：
在局部修改全局变量的值，需要使用global声明
在局部如果修改全局变量的值，需要使用global声明(如果全局变量是不可变类型，必须声明，可变类型，可以不声明)
nonlocal:
使用场合：
在嵌套函数的内部函数中使用，会找在它的上一级作用域中查找对应的变量(不是找全局变量，如果找不到，报错)
"""
# 全局变量b
# b = 100
# def func1():
# # a = 10
# # 在函数内，修改b的值
# # b += 1
# # 如果不使用glocal声明，系统默认认为使用局部变量，然而没有，所有会报错
# # 解决方案： 修改变量之前，先声明
# global b
# b = b + 1
# print(f'b = {b}')
#
# func1()
# print(b)
# list1 = []
# def func2():
# # global list1
# list1.append(1)
# print(list1)
# func2()
b = 20
def func_out():
b = 10
def func_in():
nonlocal b
b += 1
print(f'func_in:{b}')
func_in()
func_out()
"""
系统内置函数
在系统内置模块中，已经定义好的函数(不用引入任何模块，直接就能使用)
print()
input()
max()
min()
sum()
系统内置文件 builtins.py
dir(模块名/文件名)
abs()
求绝对值
max(iterable，*[key,default])
max(arg1,arg2,*args,[key])
求最大值
map()
map()函数
有两个参数，第一个参数是一个函数，第二个参数是可迭代的内容。
函数会依次作用在可迭代内容的每一个元素上进行计算，然后返回一个新的可迭 代内容
1.求 lst 中每一个元素的平方值
2.求两个列表对应位置元素的和
[1,2,3] [4,5,6,7]
"""
# import builtins
# # 如何查看系统的内置函数
# v = dir(builtins)
# i = v.index('abs')
# count = len(v[i:])
# print(v[i:])
# print(count)
# print(type(v))
# for s in v:
# print(s)
# 求绝对值
v = abs(-1)
print(v)
# 可以求3个数字之间的最大值
print(max(1,2,3))
# print(max(1)) # TypeError: 'int' object is not iterable
list1 = [1,2,3]
list2 = []
# 封装一个函数，可以求某个数字的平方
def func1(n):
return n ** 2
# for i in list1:
# # v = i ** 2
# # 求i的平方
# # v = int(pow(i,2))
# # list2.append(v)
# v = func1(i)
# list2.append(v)
#
# print(list2)
list3 = map(func1,list1)
# 迭代器可以直接转换为列表
print(list(list3))
def func2(a,b):
return a + b
lst0 = [1,2,3]
lst1 = [4,5,6,7]
# list4 = map(func2,lst0,lst1)
list4 = map(func1,lst0,lst1)
print(list(list4)) #[5,7,9]
"""
需求： [1,2,3],[1,2,3] 第一个列表元组为底数，第二个列表对应位置的元素为指数
filter() 函数
函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成 的新列表(迭代器)
def func2(x):
需求：过滤掉列表所有的奇数，保留偶数
zip(iter1,iter2...)函数
zip 函数接受任意多个可迭代对象作为参数,将对象中对应的元素打包成一个 tuple,
然后返回一个可迭代的 zip 对象.这个可迭代对象可以使用循环的方式列出其元 素
若多个可迭代对象的长度不一致,则所返回的列表与长度最短的可迭代对象相 同
"""
# def func1(a,b):
# return a ** b
# # return pow(a,b)
# list1 = [1,2,3]
# list2 = list1.copy()
# list3 = list(map(func1,list1,list2))
# print(list3)
# list1 = [1,2,3,4,5,6,7,8,9,10]
# list2 = []
# def is_even_number(n):
# return n % 2 == 0
# for i in list1:
# if is_even_number(i):
# list2.append(i)
# print(list2)
#
# list3 = list(filter(is_even_number,list1))
# print(list3)
# list1 = 'abcdef'
# list2 = '123456789'
#
# list3 = list(zip(list1,list2))
# print(list3)
"""
匿名函数：
本质： 函数
定义方式：
lambda 参数：表达式
封装一个求和函数
def get_sum(a,b):
return a + b
使用匿名函数封装：
lambda a,b: a + b
匿名函数的使用场景：
功能简单，可复用性不强的函数，可以做成匿名函数
注意：
不能包含循环、return，可以包含 if...else...
"""
# f = lambda a,b: a + b
# print(type(f))
# v = f(1,2)
# print(v)
# 使用map函数求列表中所有元素的平方
# def func1(x):
# return x ** 2
lst1 = [1,2,3]
# lst2 = list(map(func1,lst1))
# print(lst2)
lst3 = list(map(lambda x:x**2,lst1))
print(lst3)
# 查找最大值 max(iterable,*[key,default])
# lst4 = [1,2,3,0,210,3]
lst5 = [[1001,'Tom',3],[1000,'Rose',18],[1002,'Jerry',16]]
# v = max(lst5)
# v = max(lst5,key=lambda x:x[2])
v = max(lst5,key=lambda x:x[1])
print(v)
"""
# 需求：[{'id':xx,'name':xx,'age':xx},{},{}]
"""
list1 = [{'id':1001,'name':'Tom','age':3},{'id':1000,'name':'Rose','age':18},{'id':1002,'name':'Jack','age':15}]
# # print(max(list1)) #TypeError: '>' not supported between instances of 'dict' and 'dict'
# print(max(list1,key=lambda d:d['id']))
# print(max(list1,key=lambda d:d['age']))
# print([1,2] > [2,3])
# list2 = sorted(list1)TypeError: '<' not supported between instances of 'dict' and 'dict'
# print(list2)
# list3 = sorted(list1,key=lambda d:d['id'],reverse=True)
list3 = sorted(list1,key=lambda d:d.get('age'),reverse=True)
print(list3)
d = {'id':1}
v = d.get('age',1000)
print(v)
"""
字符串
定义:
可以使用单引号、双引号、三引号
拼接
'+'
join
重复
*
求长度：
len(str)
索引
访问：基于索引来访问的
索引范围(同列表)：
[0，len(str)-1]
切片(同列表一样)
"""
# 字符串的定义
s1 = 'abc'
s2 = "abc"
s3 = """abc"""
print(type(s1))
print(type(s2))
print(type(s3))
s4 = s1 + s2
print(s4)
s5 = '_'.join(s1)
print(s5)
print('------'*5)
s6 = s1 * 2
print(s6)
print(f'字符串“{s1}”的长度为:{len(s1)}')
print(f'字符串“{s1}”中的第一个字符为:“{s1[0]}”')
# 索引越界
print(s1[len(s1)]) #IndexError: string index out of range
print(s1[3]) #IndexError: string index out of range
"""
查找
在一个字符串中，查询你想查找的东西
find
rfind
index
rindex
count
拆分
split
partition
rpartition
替换
replace
"""
# print(dir(str))
str1 = 'abc123defabc'
# # index = str1.find('abc')
# # index = str1.rfind('abc')
# index = str1.rfind('ccccc')
# print(index)
# i = str1.index('abc')
# i = str1.rindex('abc')
# i = str1.rindex('cccc')
# print(i)
# count 统计出现次数
# c = str1.count('abc')
# # 如果指定范围，则只获取一次
# c = str1.count('abc',0,5)
# print(c)
# 拆分
str2 = 'a,b,c,d'
v = str2.split(',')
print(v)
path = '123.txt.py'
# 找出文件名，文件后缀 使用切片完成，要求手动实现
# t = path.partition('.')
t = path.rpartition('.')
print(t)
# 替换
words = '你大爷的,你大爷的，你爷爷的'
# new_words = words.replace('爷','*',1)
new_words = words.replace('爷','*')
print(new_words)
"""
面试试题1：
def fun1(s,lst=[])
lst.append(s)
print(lst)
return lst
面试试题2：
求
lambda x: x * i
a = [lambda x: x * i for i in range(3)]
print(a[0](2))
"""
# def func1(s, lst = []):
# def func1(s):
# lst = []
# lst.append(s)
# print(id(lst))
# print(lst)
# return lst
# func1(1)#[1]
# func1(2)#[2] [1,2]
# func1(3)#[3] [1,2,3]
a = [lambda x: x * i for i in range(3)]
# print(a)
lst1 = []
for i in range(3):
# def func(x):
# x * i
# lst1.append(func)
lst1.append(lambda x:x * i)
# print(lst1)
print(i)
print(lst1[0](2))# ? x=? i = ?
print(lst1[1](2))# ?
print(lst1[2](2))# ?
"""
综合业务
注意设计合适的存储结构：
[[],[]]
[{},{}]
自主设计图书管理系统（使用函数）
1.添加图书
请输入id
请输入书名
请输入库存
2.删除图书
1.书名删除
2.一键清空
3.展示所有图书
1.按id自然排序展示
2.按书名自然排序展示
3.按库存自然排序展示
4.查询图书
1.根据图书id查询
2.根据书名查询
3.查询库存量最大的图书
5.修改图书
根据输入的图书名修改库存
6.退出系统
"""
# 存储所有数据
book_list = []
# 展示主菜单
def show_menu():
print('图书管理系统v1.0')
print('1.添加图书')
print('2.删除图书')
print('3.展示图书')
print('4.查询图书')
print('5.修改图书')
print('6.退出系统')
# 展示搜索菜单
def show_menu_search():
print('1.根据id查')
print('2.根据书名查')
print('3.查询最大库存图书')
# 添加图书功能
def add_book():
id = input('请输入图书id:')
name = input('请输入图书名字:')
stock = int(input('请输入图书库存:'))
book_dic = {'id':id,'name':name,'stock':stock}
book_list.append(book_dic)
print('添加成功')
# 查询入口
def search_book():
show_menu_search()
c = input('请选择1-3:')
if c == '1':
book_id = input('请输入要查询的图书id:')
book = get_book_by_id(book_id)
print(book)
elif c == '2':
print('根据书名查')
book_name = input('请输入要查询的图书名字:')
book = get_book_by_name(book_name)
print(book)
elif c == '3':
book = get_most_by_stock()
print(book)
# 根据图书id查
def get_book_by_id(id):
# 返回 id对应的图书
return None
# 根据图书名字查
def get_book_by_name(name):
# 返回name对应的图书
return None
# 获取库存量最大的书
def get_most_by_stock():
# 返回库存量最大的书
return None
while True:
show_menu()
c = input('请选择1-6:')
if c == '1':
pass
elif c == '2':
pass
elif c == '3':
pass
elif c == '4':
search_book()
elif c == '5':
pass
elif c == '6':
pass
else:
print('输入有误')
"""
综合业务
注意设计合适的存储结构：
[{},{}]
自主设计图书管理系统（使用函数）
1.添加图书
请输入id
请输入书名
请输入库存
2.删除图书
1.书名删除
2.一键清空
3.展示所有图书
1.按id自然排序展示
2.按书名自然排序展示
3.按库存自然排序展示
4.查询图书
1.根据图书id查询
2.根据书名查询
3.查询库存量最大的图书
5.修改图书
根据输入的图书名修改库存
6.退出系统
"""
# 存储所有数据
book_list = []
# 展示主菜单
def show_menu():
print('图书管理系统v1.0')
print('1.添加图书')
print('2.删除图书')
print('3.展示图书')
print('4.查询图书')
print('5.修改图书')
print('6.退出系统')
# 展示搜索菜单
def show_menu_search():
print('1.根据id查')
print('2.根据书名查')
print('3.查询最大库存图书')
# 添加图书功能
def add_book():
id = input('请输入图书id:')
name = input('请输入图书名字:')
stock = int(input('请输入图书库存:'))
book_dic = {'id':id,'name':name,'stock':stock}
# 调用查询功能，b为得到的字典信息，如果没有，返回None
b = get_book_by_id(id)
# if b == None:
if not b:
book_list.append(book_dic)
print('添加成功')
else:
# 说明已经包含该图书信息，应该进行库存的更新操作（该函数待封装）
# 新的库存信息应该为: 已经存在的 + 新添加的
b['stock'] = b.get('stock') + stock
print(f'库存已更新，新增{name}{stock}本')
# 查询入口
def search_book():
show_menu_search()
c = input('请选择1-3:')
if c == '1':
book_id = input('请输入要查询的图书id:')
book = get_book_by_id(book_id)
print(book)
elif c == '2':
print('根据书名查')
book_name = input('请输入要查询的图书名字:')
book = get_book_by_name(book_name)
print(book)
elif c == '3':
book = get_most_by_stock()
print(book)
# 根据图书id查
def get_book_by_id(id): #[{},{},{}]
# 返回 id对应的图书
for book_dic in book_list:
if book_dic.get('id') == id:
return book_dic
return None
# 根据图书名字查
def get_book_by_name(name):
# 返回name对应的图书
return None
# 获取库存量最大的书
def get_most_by_stock():
# 返回库存量最大的书
return None
while True:
show_menu()
c = input('请选择1-6:')
if c == '1':
add_book()
elif c == '2':
pass
elif c == '3':
pass
elif c == '4':
search_book()
elif c == '5':
pass
elif c == '6':
pass
else:
print('输入有误')
"""
全局变量与局部变量
不同点：
1.定义位置
2.作用域不同
3.生命周期不同
4.内存中存储位置
在函数中修改全局变量的值 global
如果全局变量是基本类型，需要使用global修饰
如果全局变量是可变类型，可以选择性使用global
nonlocal（在嵌套定义的函数中可能会用）
访问上一层中定义的变量
常用的内置函数：
内置函数的查看：
dir(builtins)
73
max()
min()
abs()
pow(a,b)->float
map(func,iterable...)-> 迭代器
filter(func,iterable)->迭代器
func 要求函数有bool的返回值
zip(iter1,iter2...)
长度取决于iter1，iter2较短的那个
匿名函数
定义：
lambda 参数1，参数2...: 表达式
局限性：
不能存在循环，分支（三元条件表达式除外），return
使用场景：
max(list,key=lambda x:x[0])
sorted(list,key = lambda x:x['id'])
字符串：（不可变类型）
定义：
单引号
双引号
三引号
连接：
+
join
重复：
*
长度：
len(str)
访问：
str[index]
索引范围：
【0,len(str)-1】
切片：
用法同列表
str[start:stop:step]
"""
"""
2.封装函数，判断一个数字是否为水仙花数
水仙花数： 3位数
每一位上数字的3次方之和等于它本身
3.封装函数，打印所有的水仙花数
能力提升题：
1.封装一个函数，可以实现某个字符串的大小写转换，比如：输入'Abc' - > 'aBC'
2.封装一个函数，功能类似join,可以使用一个字符串将另外一个字符串中的每个字符连接在一起
abc _
a_b_c
"""
# 判断数字n是否为水仙花数
def is_narcissistic_number(n):
if 100 <= n < 1000:
a = n // 100
b = n // 10 % 10
c = n % 10
return a**3 + b**3 + c**3 == n
else:
return False
# print(is_narcissistic_number(153))
# print(is_narcissistic_number(154))
# print(is_narcissistic_number(1540))
# 打印所有的水仙花数
def show_all_narcissistic_numbers():
for i in range(100,1000):
if is_narcissistic_number(i):
print(i)
# show_all_narcissistic_numbers()
def swap_case(str1):
# 记录操作后的结果
str2 = ''
for ch in str1:
if 'A' <= ch <= 'Z':
# 如果是大写，转换为小写
ch = chr(ord(ch) + 32)
elif 'a' <= ch <= 'z':
# 如果是小写，转换为大写
ch = chr(ord(ch) - 32)
str2 += ch
return str2
# 2.封装一个函数，功能类似join,可以使用一个字符串将另外一个字符串中的每个字符连接在一起
# print(swap_case('abc1CD'))
# s1 使用什么连接 s2 被连接的字符串
def custom_join(s1,s2):
s3 = ''
for ch in s2:
s3 += ch + s1
return s3[:len(s3)-1]
print(custom_join('_','abc'))
"""
字符串中使用的转义字符：
\n 换行
\t 制表符
\'
\"
r'字符串'：表示元字符串，字符串中的转义字符失效
"""
print('我想在这打印一个单引号\'')
print('我想打印一个斜线\\')
print(r'Hello\nWorld')
print(R'Hello\nWorld')
"""
推导式：
1、列表推导式
变量名=[表达式 for 变量 in 列表]
或者变量名= [表达式 for 变量 in 列表 if 条件]
或者变量名= [表达式 for 变量 in 列表 for in ]
语义：遍历出列表中的内容给变量，表达式根据变量值进行逻辑运算。或者遍历列表中的内容给变量，然后进行判断，符合的值在给表达式。
练习1：快速创建一个包含元素1-10的列表
练习2：快速创建一个包含1-10之间所有偶数的列表
练习3：现在有一列表 lst = [[1,2,3],[4,5,6],[7,8,9]],使用推导式取出 1/4/7 和 1/5/9 元素， 思考如何取出
2、字典推导式
3、集合推导式
"""
import time
# start_time = time.time()
# lst1 = []
# for i in range(1,10000001):
# lst1.append(i)
# # 使用列表推导式实现
# lst2 = [i for i in range(1,10000001)]
# print(lst2)
# end_time = time.time()
# # print(f'使用方法添加元素耗时{end_time-start_time}秒')#3.227184295654297秒
# print(f'使用推导式添加元素耗时{end_time-start_time}秒')#1.802103042602539秒
# 创建1-10中所有偶数的列表
# lst3 = [x for x in range(2,11,2)]
lst3 = [x**2 for x in range(1,11) if x % 2 == 0]
print(lst3)
lst4 = [(x,y) for x in range(1,10) for y in range(1,10)]
print(lst4)
"""
练习3：现在有一列表 lst = [[1,2,3],[4,5,6],[7,8,9]],
使用推导式取出 1/4/7 和 1/5/9 元素，
思考如何取出
字典推导式：
d = {表达式(键值对) for ...}
需求1：
使用字典推导式，创建存储所有大写字母与unicode编码值的 对照字典，例如：{'A':65,'B':66...}
需求2：
将需求1中生成的字典，实现键值翻转
集合推导式：
特点：
不能存在重复元素（去重）
s = {列表推导式的算法}
"""
lst = [[1,2,3],[4,5,6],[7,8,9]]
# lst1 = []
# for i in lst:
# lst1.append(i[0])
# print(lst1)
# lst2 = []
# for i in range(len(lst)):
# lst2.append(lst[i][i])
# print(lst2)
# lst3 = [lst[i][0] for i in range(len(lst))]
# print(lst3)
#
# lst4 = [lst[i][i] for i in range(len(lst))]
# print(lst4)
#
# lst5 = []
# # 传统
# for l in lst:
# for i in l:
# lst5.append(i)
# print(lst5)
#
# # 使用列表推导式
# lst6 = [i for l in lst for i in l]
# print(lst6)
# 字典推导式
# 使用字典推导式，创建存储所有大写字母与unicode编码值的 对照字典，例如：{'A':65,'B':66...}
# 传统方式
# d = {}
# for i in range(65,65+26):
# d[chr(i)] = i
# print(d)
# 推导式
# d = {chr(i):i for i in range(65,65+26)}
# print(d)
#
# d1 = {v:k for k,v in d.items()}
# print(d1)
def fun1(l):
i=''
for h in l:
if 'A'<=h<='Z':
h=chr(ord(h)+32)
i+=h
return i
print(fun1('AVD'))
#
# lst5 = [1,10,2,4,5,3,2,1,10,11,12,100,200,30]
#
# s = {i for i in lst5}
# print(s)
# import random
# s1 = {random.randint(1,6) for x in range(10)}
# print(s1)
"""
format()
str1 = '我叫{}，今年{}岁了'.format('Rose',18)
print(str1)
str1 = '我叫{0}，今年{1}岁了,比我的弟弟大{1}岁'.format('Rose',5)
print(str1)
变形
upper 转大写
lower 转小写
swapcase 大小写互换
title 单词首字母大写
capitalize 首字母大写
判断
startswith
endswith
isdigit
islower
isupper
isalpha
isalnum
"""
name = 'Tom'
age = 18
# str1 = '我叫{},今年{}岁了'.format(name,age)
# str1 = '我叫{},今年{}岁了'.format(age,name)
# str1 = '我叫{1},今年{0}岁了'.format(name,age)
# str1 = '我叫{n},今年{a}岁了'.format(n=name,a=age)
# # str1 = f'我叫{name},今年{age}岁了'
# print(str1)
#
# str2 = '我叫{0}，今年{1}岁了,比我的弟弟大{1}岁'.format('Rose',5)
# print(str2)
# 精度与进制
# str1 = '1/3 = {:.2f}'.format(1 / 3)
# print(str1)
#
# # 进制
# str2 = '10的二进制表示形式为:{:b}'.format(10)
# print(str2)
# str2 = '10的八进制表示形式为:{:o}'.format(10)
# print(str2)
# str2 = '10的十六进制表示形式为:{:x}'.format(10)
# print(str2)
"""
upper 转大写
lower 转小写
swapcase 大小写互换
title 单词首字母大写
capitalize 首字母大写
"""
str1 = 'abcDEF'
# str2 = str1.upper()
# print(str2)
str3 = str1.lower()
print(str3)
# str4 = str1.swapcase()
# print(str4)
# print('---------------')
# str5 = 'hello world'
# str6 = str5.title()
# print(str6)
#
# str7 =str5.capitalize()
# print(str7)
"""
startswith:
以什么开头
endswith
以什么结尾
isdigit
判断字符串是否由纯数字组成
islower
判断字符串是否为纯小写
isupper
判断字符串是否为纯大写
isalpha
判断字符串是否为纯字母，至少得有一个字母
isalnum
判断字符串中是否由字母或者数字组成，至少得有一个
"""
# url = 'https://www.baidu.com'
# print(url.startswith('https://'))
# email = 'xxx@qq.com'
# print(email.endswith('@qq.com'))
# v = input('请输入任意数字')
# if v.isdigit():
# print('由纯数字组成')
# v = int(v)
# else:
# print('有其他内容')
# print(v)
v1 = 'abc122'
# v1 = ''
# print(v1.isalpha())
print(v1.isalnum())
来源：CSDN
作者：return_min
链接：https://blog.csdn.net/return_min/article/details/103585459