python-入门5

1. 容器

1.1 set 集合

'''
set集合介绍:
    概述:
        容器类型的一种, 其元素特点为: 无序, 唯一
    无序解释:
        这里的无序, 并不是排序的意思, 而是: 元素的存的顺序 与 取的顺序不一致, 例如: 存的时候顺序是1, 2, 3, 取的时候顺序是2, 1, 3
    应用场景:
        去重
    set集合定义格式:
        set1 = {值1, 值2, 值3...}
        set2 = set()
'''
# 定义集合
set1 = {10, 2, 'c', 5, 'a', 6, 3, 'b', 10, 5, 'a'}
set2 = set()
set3 = {}  # 这个不是在定义集合, 而是在定义: 字典.

# 打印变量的数据类型
print(type(set1))  # <class 'set'>
print(type(set2))  # <class 'set'>
print(type(set3))  # <class 'dict'>

# 需求: 对列表元素值进行去重
list1 = [10, 20, 30, 20, 10, 30, 50]

# 去重
# 思路1: 定义新列表, 遍历原始列表获取每个元素, 然后判断是否在新列表中, 不存在就添加.
# 代码略, 自己写一下.

# 思路2: list -> set, 会自动去重 -> list
set_tmp = set(list1)
list1 = list(set_tmp)

# 打印去重后的结果.
print(f'list1: {list1}')

1.2 容器 公共运算符

'''
容器类型的公共运算符解释:
    概述:
        5种容器类型  字符串str, 列表list, 元组tuple, 字典dict, 集合set
    公共的运算符:
        +           表示: 合并(拼接), 可以作用于: 字符串, 列表, 元组
        *           表示: 复制, 可以作用于: 字符串, 列表, 元组
        in          表示: 是否在, 返回True or False 可以作用于: 字符串, 列表, 元组, 字典, 集合
        not in      表示: 是否不在, 返回True or False 可以作用于: 字符串, 列表, 元组, 字典, 集合
'''
# +   表示: 合并(拼接), 可以作用于: 字符串, 列表, 元组
print('aa' + 'bb')
print([1, 2, 3] + [4, 5, 6] + ['a', 'b'])
print((1, 2, 3) + ('a', 'b'))

# *   表示: 复制, 可以作用于: 字符串, 列表, 元组
print('-' * 28)
print([1, 2, 3] * 2)
print((1, 2, 3) * 2)

1.3 容器 公共函数

'''
容器类型的公共操作-函数:
    len()                       获取长度
    del 或者 del()               删除
    max()                       获取最大值
    min()                       获取最小值
    range(start, end, step)     生成指定范围内的数据
    enumerate()                 基于可迭代类型(字符串, 列表, 元组等), 生成 下标 + 元素的方式, 即: ['a', 'b', 'c']  => [(0, 'a'), (1, 'b'), (2, 'c')]
'''
# 定义一个数组
list1 = [10, 50, 20, 30, 66, 22]

# len()    获取长度
print(len(list1))

# del 或者 del() 删除
del list1[1]
del (list1[1])
print(f'删除后的list1: {list1}')

# max()  获取最大值
print(f'最大值: {max(list1)}')

# min()  获取最小值
print(f'最大值: {min(list1)}')

# range(start, end, step)     生成指定范围内的数据
print(f'range生成数据: {range(1, 5, 2)}')  # range生成数据: range(1, 5, 2)
print(f'range生成数据: {list(range(1, 5, 2))}')  # range生成数据: [1, 3]

# enumerate()   基于可迭代类型(字符串, 列表, 元组等), 生成 下标 + 元素的方式, 即: ['a', 'b', 'c']  => [(0, 'a'), (1, 'b'), (2, 'c')]
for i in enumerate(list1):
    print(i)  # 格式: (下标, 元素值), 且下标默认从 0 开始.

print('5' * 28)

for i in enumerate(list1, 5):
    print(i)  # 格式: (下标, 元素值), 且下标从 5 开始.

1.4 推导式

'''
推导式介绍:
    概述:
        推导式也叫解析式, 属于Python的一种特有写法, 目的是: 简化代码编写
    分类:
        列表推导式
        集合推导式
        字典推导式
    格式:
        变量名 = [变量名 for ... in ... if 判断条件]
        变量名 = {变量名 for ... in ... if 判断条件}
        变量名 = {变量名1:变量名2 for ... in ... if 判断条件}
'''
# 需求: 创建1个 0 ~ 9的列表
# 方式1: 不使用推导式
list1 = []
for i in range(10):
    list1.append(i)
print(list1)

# 方式2: 列表推导式
list2 = [i for i in range(10)]
print(list2)

# 方式3: 类型转换
list3 = list(range(10))
print(list3)

'''集合和字典推导式详解'''

# 演示 集合推导式.

# 需求1: 生成 0 ~ 9 的偶数 集合.
set1 = {i for i in range(10) if i % 2 == 0}
print(set1)

# 需求2: 创建1个集合, 数据为下方列表的 2次方.
# 目的: 集合元素具有 唯一性, 会自动去重.
list1 = [1, 1, 2]
set2 = {i ** 2 for i in list1}
print(set2)
print('-' * 28)

# 演示 字典推导式, 回顾字典写法: dict1 = {'name':'张三', 'age':23}
# 需求3: 创建1个字典, key是 1 ~ 5的数字, value是该数字的2次方, 例如: {1:2, 2:4, 3:9, 4:16, 5:25}
dict1 = {i: i ** 2 for i in range(1, 6)}
print(dict1)
print('-' * 28)

# 需求4: 把下述的两个列表, 拼接成1个字典.
# 细节: 两个列表的元素个数(长度) 要 一致.
list1 = ['name', 'age', 'gender']
list2 = ['Tom', 20, 'male']

dict2 = {list1[i]: list2[i] for i in range(len(list1))}
print(dict2)

2. 函数

2.1 自定义函数

'''
函数解释:
    概述:
        函数也叫方法, 就是把 一些具有独立功能的代码封装到一起, 使其具有单一功能的代码
        函数: function,  方法: method
    作用:
        1. 模块化编程, 方便我们进行管理.
        2. 提高代码的复用性.
    格式:
        def 函数名(形式参数1, 形式参数2...):
            函数体
            return 具体的返回值
    格式解释:
        def         固定写法, defined, 定义的意思.
        函数名       类似于变量名, 见名知意即可.
        形参列表     表示调用函数, 应该传入什么内容(值)
        函数体       具体的逻辑代码, 就是以前我们写的if, while, for, 容器...
        return      作用1: 结束方法的(类似于break)   作用2: 可以把函数的执行结果进行返回.
    细节:
        1. 函数必须先定义, 然后才能调用.
        2. 定义函数小技巧, 三个明确:
            明确函数名
            明确形参列表
            明确返回值
        3. 调用函数小技巧, 三个步骤
            写 函数名()
            传参, 要什么给什么, 不要就不给.
            接收返回值, 返回什么就接收什么, 不给就不接收.
        4. 如果函数没有明确的返回值, 则return可以省略不写.
        5. 函数必须调用, 才会执行.
'''
def call():
    print('hello world')
call()

2.2 函数 说明文档

'''
函数的 说明文档介绍:
    概述:
        函数的说明文档也叫 文档说明, 就是解释函数的 参数, 作用, 返回值的
    格式:
        在函数内的第一行, 用 三引号的写法来实现即可, 可以是双引号(推荐), 也可以单引号
    如何查看说明文档:
        help(函数名)
        鼠标放到函数上, 点击: ctrl + Q
'''
# 需求: 定义get_sum()函数, 计算两个整数和, 并返回
# 1. 定义函数.
def get_sum(a, b):
    '''
    该函数用于计算两个整数和, 并返回求和结果.
    :param a: 要计算的第1个整数
    :param b: 要计算的第2个整数
    :return: 两个整数的求和结果.
    '''
    return a + b

# 2. 调用函数.
result = get_sum(10, 20)

# 3. 打印结果.
print(f'求和结果为: {result}')

2.3 函数 嵌套

'''
函数的嵌套 解释:
    概述:
        函数的嵌套指的是 函数的嵌套调用, 并不是函数的嵌套定义
        例如: 在 func_B 函数中 调用 func_A 这个函数, 就叫: 函数的嵌套调用
    回顾:
        顺序结构: 代码会按照 从上往下, 从左往右, 依次逐行执行
'''
# 定义func_A()函数.
def func_A():
    print('----- func_A start -----')       # 2
    print('我是 funcA函数 ')                 # 3
    print('----- func_A end -----')         # 4

# 定义func_B()函数.
def func_B():
    print('----- func_B start -----')       # 1
    # 3. 在这里调用 funcA()函数.
    func_A()
    print('----- func_B end -----')         # 5

# 在main函数中, 调用 func_B()函数, 观察程序的打印结果.
# main函数是程序的主入口, 所有代码的执行都是从这里开始的.
# main方法可以省略不写(建议写), Python解释器底层执行的时候, 会自动帮我们加.
if __name__ == '__main__':
    func_B()

3. 变量

3.1 变量 作用域

'''
变量的作用域介绍:
    概述:
        变量的作用域指的是 变量的哪里能用, 哪里不能用, 即: 变量的作用区间
    分类:
        局部变量: 定义在函数内 或者 函数形参列表中的 变量
        全局变量: 定义在函数外的变量, 或者用 global 关键字修饰的变量

    面试题:
        局部变量 和 全局变量的区别?
    答案:
        1. 定义位置不同
            局部变量: 定义在函数内 或者 函数形参列表中的 变量
            全局变量: 定义在函数外的变量, 或者用 global 关键字修饰的变量
        2. 在内存中的存储位置不同
            局部变量: 存储在 堆区
            全局变量: 存储在 方法区
        3. 生命周期不同
            局部变量: 随着函数的调用而存在, 随着函数的调用完毕而消失
            全局变量: 随着 .py文件加载而存在, .py文件从内存中移除而消失

    细节:
        使用变量遵循就近原则, 局部位置有就直接使用, 没有就去 全局位置找, 有就使用, 没有就报错
'''
# 局部变量的生命周期
def func1():
    a = 10      # 局部变量
    print(f'a: {a}')
# 调用 func1()函数.
func1()

# print(f'在func1()函数外, 调用变量a: {a}') # 报错, 超出了 局部变量的作用域

# 全局变量的生命周期
b = 100

def func2():
    print(f'func2函数, b: {b}')

def func3():
    print(f'func3函数, b: {b}')

# 调用函数
func2()
func3()

# global关键字.
c = 66

def func4():
    print(f'func4函数, c: {c}')

def func5():
    global c        # global声明的变量, 属于: 全局变量.   不写global, 下述的c是 局部变量.
    c = 200
    print(f'func5函数, c: {c}')   # 使用变量遵循 就近原则.

# 调用函数
func4() # 66
func5() # 200
func4() # 200

3.2 函数传递

'''
关于 函数传递
    1. 函数的返回值可以作为 (另一个函数的)参数进行传递
    2. 函数可以作为 (另一个函数的)参数进行传递
'''
# 1. 函数的返回值可以作为 (另一个函数的)参数进行传递
def fun1():
    return 100      # 返回1个结果 100

def fun2(num):      # 需要1个参数
    print(num)

# 调用fun1()函数, 获取返回值
a = fun1()          # 相当于 a = 100

# 调用fun2()函数
fun2(a)

# 合并版.
fun2(fun1())        # 函数的返回值可以作为 (另一个函数的)参数进行传递

# 2. 函数可以作为 (另一个函数的)参数进行传递.
def get_substract(a, b):
    return a - b

def calculate(a, b, fn):
    '''
    自定义函数, 模拟计算器, 传入什么 函数(对象), 就做什么操作
    :param a: 要操作的第1个整数
    :param b: 要操作的第2个整数
    :param fn: 具体的操作规则
    :return: 计算结果
    '''
    return fn(a, b)

print(calculate(10, 20, get_sum))
print(calculate(10, 20, get_substract))