python零基础二

"""
函数参数的分类：
    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())