【python】基础知识点

service2 = [['abc','def','www'],[1,2,3],['mike','tony','sun']]
print(service2[:][1]) ##第二个元素 [1,2,3]

name_list = ['张三', '李四', '王五', '花蛤', '景浩']
name_list.extend("赵刚")
print(name_list)  # ['张三', '李四', '王五', '花蛤', '景浩', '赵', '刚']

 *args **kwargs

• 你可以在同一个函数中同时使用 *args 和 **kwargs，但 *args 必须位于 **kwargs 之前。

#*args 允许你将不定数量的非关键字参数（位置参数）传递给一个函数。这些#参数在函数内部被打包成一个元组（tuple）
def my_function(*args):
    for arg in args:
        print(arg)

my_function('Hello', 'world', 1, 2, 3)

#**kwargs 允许你将不定数量的关键字参数传递给一个函数。这些参数在函数内部被打包成一个字典（dictionary）。
def my_function(**kwargs):
    for key, value in kwargs.items():
        print(f"{key} = {value}")

my_function(name='Alice', age=30, country='USA')

* 

"""
*  和  ** 如果在函数的定义处使用:
     *  把多余的普通实参打包成元组
     ** 把多余的关键字实参打包成字典
    
* 和 ** 如果在函数的调用处使用:
    *  把元组或者列表，集合(集合顺序不定)，字符串 等容器进行解包
    ** 把字典进行解包
"""

def func(a,b,*,c,d):  # * 命名关键字参数，* 前普通形参， *后 关键字参数
    print(a,b)
    print(c,d)

tup = (1,2)

# 函数的调用处 *号用法
func(*tup,c=3,d=4) # func(1,2,c=3,d=4)
*在调用出放在变量的前面，相当于把该变量解包成对应的实参调用到函数中，如下，将lst中的两个值解包成两个位置实参赋值给a,b
*只能解包赋值给普通(位置实参)，不能解包赋值给关键字实参

闭包

在闭包函数中,内函数使用了外函数的局部变量,该变量会与内函数发生绑定,延长该变量的生命周期,持续到脚本执行结束.

闭包的意义:  闭包可以优先使用外函数中的变量, 并对闭包中的值起到了封装保护的作用. 外部无法访问.

# 定义一个函数工厂，用于生成幂函数
def power_factory(exponent):
    def power(base):
        return base ** exponent
    return power

# 生成平方函数和立方函数
square = power_factory(2)
cube = power_factory(3)

# 使用生成的函数
print(square(4))  # 输出: 16
print(cube(4))    # 输出: 64

迭代器

迭代器：是可以进行迭代的 ，

迭代对象：是不可以进行迭代的，必须使用iter()或者__iter()__转换成迭代器才可以进行迭代

 

# 可迭代对象
res = range(10)
print(dir(res))  # ['__iter__', '__le__'] ,'__iter__' 是可迭代对象

# 可迭代器
a = [1,2,3]
print(dir(iter(a)))  # ['__next__','__iter__']

 全局变量与局部变量

nonloacl：

如果有多层定义同一变量，nonloacl找到最近一层的变量，即不再向上寻找，只修改最近一层的变量

针对可变类型数据也一样，只修改最近层变量的值

不使用nonlocal，当变量是不可变类型，只能修改本层内的变量

不使用nonlocal，当变量是可变类型，可以直接修改各层数据

def outer():
    lst = [1,2,3]
    def inner():
        lst[-1] = 3000
    inner()
    print(lst)
outer()

def outer():
    a = 20
    def inner():
        a=40
        def smaller():
            nonlocal a
            a= 30
            print(f"smaller{a}")
        smaller()
        print(f"inner{a}")
    inner()
    print(f"outer{a}")
outer()

 super()

super 的作用是针对于继承场景，子类继承父类后，需要调用父类的属性或者方法的同时又需要实现自己特有的需求时

class Parent:
    def __init__(self):
        print("Parent __init__")

class Child(Parent):
    def __init__(self):
        super().__init__()  # 调用父类的__init__方法
        print("Child __init__")

# 创建Child类的实例
c = Child()
# 输出:
# Parent __init__
# Child __init__