解构赋值

a, b, c = [1, 2, 3]  # 列表解构 
print(a, b, c) 
a, b, c = (1, 2, 3,)  # 元组解构 
print(a, b, c) 
a, b, c = {1, 2, 3}  # 集合解构 
print(a, b, c) 
a, b, c = range(1, 4)  # 范围解构 
print(a, b, c) 
a, b, c = "hel"  # 字符串解构 
print(a, b, c) 
a, b = {"name": "lisi", "age": 34}  # 字典解构 
print(a, b) 

将可迭代对象依次赋值给左边变量

函数定义

def my_sum(num1, num2): 
    ''' 
    calculate two num sum 
    :param num1: 
    :param num2: 
    :return: 
    ''' 
    return num1 + num2 
 
 
print(my_sum(2, 5))  # 位置对应 
print(my_sum(num2=5, num1=2))  # 参数名称对应 
print(my_sum(3, num2=8))  # 混合 

使用def关键字声明函数，3引号声明函数文档注释，没有return语句会返回None，多个返回值会包装成元组。实参和形参必须一一对应，不能多也不能少。位置对应必须在名称对应之前。

默认参数

def my_sum(num1, num2, num3=0): 
    ''' 
    calculate three num sum 
    :param num1:  
    :param num2:  
    :param num3:  
    :return:  
    ''' 
    return num1 + num2 + num3 
 
 
print(my_sum(6, 5)) 
print(my_sum(6, 5, 2)) 

默认参数在声明函数时定义，传参使用参数值，不传使用默认值。默认参数必须为不可变对象。

可变参数

def my_sum(*nums): 
    sum = 0 
    for num in nums: 
        sum += num 
    return sum 
 
 
print(my_sum(1, 2, 3, 4, 6))  # 可变参数 
print(my_sum(*[1, 2, 3, 4, 5]))  # 解构赋值 

python会将多个参数包装成元组传递给函数。

关键字参数

def person(name, age, **kwargs): 
    return {"name": name, "age": age, **kwargs} 
 
print(person("lisi", 23, city="shanghai", job="java")) 
print(person(**{"name": "lisi", "age": 23, "city": "shanghai", "job": "java"}))  # 解构赋值 
 

python会将多个关键字参数包装成字典传递给函数。

局部变量和全局变量

NAME = "lisi"  # 全局变量 
AGE = 23  # 全局变量 
 
def change_name(): 
    global NAME  # 关联全局变量 
    NAME = "lisi2"  # 修改全局变量 
    AGE = 34  # 局部变量 
    print(NAME, AGE) 
 
change_name() 
 
print(NAME, AGE) 

使用global修改全局变量，先找局部变量，找不到再找全局变量。

NAME = "lisi"  # 全局变量 
 
def change_name(): 
    NAME = "xioaming"  
 
    def change_name2(): 
        nonlocal NAME  #关联上一级作用域变量 
        NAME = "xioali" # 修改 
        print(NAME) 
 
    change_name2() 
    print(NAME) 
 
change_name() 
print(NAME) 

使用nonlocal修改上一级作用域变量

递归函数

def my_sum(*nums): 
    if len(nums) == 0: 
        return 0 
    return my_sum(*nums[0:-1]) + nums[-1] 
 
 
print(my_sum(1, 2, 3, 6)) 
print(my_sum(1)) 
print(my_sum()) 

递归就是直接或间接的调用自己。

闭包

def create_counter(num=0): 
    def inc(): 
        nonlocal num 
        num += 1 
        return num 
 
    return inc 
 
 
counter = create_counter() 
print(counter())  # 1 
print(counter())  # 2 
counter = create_counter(5) 
print(counter())  # 6 
print(counter())  # 7 

python中，只有函数内部或函数内部的子函数才可以读取或修改局部变量，闭包就是可以读取其他函数内部变量的函数，简单理解为函数内部的函数，它是将函数内部和函数外部连接的桥梁。

lambda函数

my_sum = lambda x, y: x + y 
print(my_sum(3, 4)) 

python的lambda函数的函数体只能是表达式，不能是多条语句。

内置函数

print(abs(-12))  # 求绝对值 
print(min(3, 5, 7, -3, 4))  # 最小值 
print(max(4, 5, 6, 7))  # 最大值 
print(sum([1, 2, 3], 0))  # 求和 
print(pow(3, 2))  # 求幂次方 
print(round(3.4568, 2))  # 四舍五入 
print(divmod(9, 2))  # 求商和余数 
print(int("123"))  # 转为int类型 
print(float("123"))  # 转为float类型 
print(bool("1"))  # 转为bool类型 0或空为False 
print(bin(123))  # 转为2进制字符串 
print(oct(123))  # 转为8进制字符串 
print(hex(123))  # 转为16进制字符串 
print(ord("A"))  # 获取对应的10进制整数 
print(chr(65))  # 获取对应的字符 
print(eval('2**3'))  # 执行python语句 
exec('print(2**3)')  # 执行python语句 
 
f = open("test.txt", "r")  # 打开文件 
print(f.readlines()) 
 
print(str([1, 2, 3]))  # 转为字符串形式 
 
 
class Person(): 
    pass 
 
 
p = Person() 
setattr(p, "len", 4)  # 设置属性值 
print(getattr(p, "len"))  # 获取属性值 
print(hasattr(p, "len"))  # 是否包含属性 
delattr(p, "len")  # 删除属性 
print(all([1, 2, 3, 0]))  # 可迭代对象是否全部为True 
print(any([1, 2, 3, 0]))  # 可迭代对象是否有一个为True 
print(dir())  # 获取当前模块的属性列表 
it = iter([1, 2, 3])  # 获取列表的迭代器对象 
while True: 
    try: 
        print(next(it))  # 获取迭代器的下一个对象，没有抛出异常 
    except StopIteration: 
        break 
sli = slice(0, 2, 1)  # 创建切片对象 
print([1, 2, 3, 4, 5][sli]) 
print(id("lisi"))  # 获取对象的内存地址 
print(sorted([1, 3, 6, 4]))  # 对可迭代对象排序 
print(list(reversed([1, 3, 6, 4])))  # 翻转可迭代对象 
print(ascii([1, 2, 3]))  # 获取对象的字符串表示 
for (i, v) in enumerate(["lisi", "zhangsan"]):  # 获取可迭代对象的索引序列，包含索引和数据 
    print(i, v) 
print(isinstance("", (str, list)))  # 对象是否为类的实例 
print(issubclass(bool, int))  # 是否为父类 
 
 
class Father: 
    def sing(self): 
        print("father sing") 
 
 
class Child(Father): 
    def sing(self): 
        super().sing()  # 调用父类方法 
        print("child sing") 
 
 
print(Child().sing()) 
print(bytearray("lisi", encoding="utf-8"))  # 创建字节数组 
print(bytes("lisi", encoding="utf-8"))  # 创建不可变字节数组 
print(dict(name="lisi", age=23))  # 创建一个字典 
print(tuple([1, 2, 3]))  # 创建元组 
print(list((1, 2, 3,)))  # 创建列表 
print(set([1, 2, 3]))  # 创建集合 
print(frozenset([1, 2, 3]))  # 创建不可变集合 
print(range(5))  # 创建范围对象 
print(list(filter(lambda x: len(x) >= 4, ["java", "go", "python"])))  # 过滤可迭代对象 
print("abc")  # 打印输出函数 
print(callable(Child))  # 是否是可调用的 
print("name:{name},age:{age}".format(name="lisi", age=23))  # 字符串格式化 
print(len("hello"))  # 获取对象长度 
print(type(""))  # 获取对象类型 
print(vars(p))  # 获取对象的属性 
print(hash("abxc"))  # 获取对象的哈希值 
print(list(map(lambda x: x ** 2, [1, 2, 3])))  # 映射 
print(list(zip([1, 2, 3], [4, 5, 6])))  # 将可迭代对象打包成元组 
print(help('str'))  # 查看函数或模块的详细信息 
print(input("please input num: "))  # 接受标准输入