Python的7个基础知识介绍

函数可变参数

# 可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。
def calc(*number):
    sum = 0
    for x in number:
        sum = sum + x * x
    return sum


# 直接调用
print(calc(5, 5, 5))
# 列表参数调用：*num表示把num这个list的所有元素作为可变参数传进去
num = [1, 2, 3]
print(calc(*num))


# 练习：传入一个或多个参数并计算参数乘积
def product(x, *args):
    if len(args):
        sum = 1
        for m in args:
            sum = sum * m
        return x * sum
    else:
        return x

命名关键字参数

# 调用时命名关键字参数必须传入参数名，关键字参数之间位置不限。如果没有传入参数名，调用将报错
def person(name, age, *, sex, job):
    print('name:%s,age:%d;sex:%s,job:%s' % (name, age, sex, job))


person('sg', 27, job='Engineer', sex='male')


# 如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了
def person2(name, age, *args, sex, job):
    print('name:%s,age:%d;sex:%s,job:%s' % (name, age, sex, job))


person2('sungang', 28, sex='男', job='Python Engineer')


# 命名关键字参数可以设置默认值，如果有默认值，调用时可不传递该参数
def person3(name, age, *, wechat="sg820262236", job):
    print('name:%s,age:%d;wechat:%s,job:%s' % (name, age, wechat, job))


person3('sungang', 27, job='Engineer')
person3('lidysun', 28, wechat='1008611', job='Engineer')

函数关键字参数

# 关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。
def person(name, age, **kw):
    print(name, age, 'other:', kw)


# 直接调用
person('sungang', 27, sex='男', job='Python Engineer')
# sungang 27 other: {'job': 'Python Engineer', 'sex': '男'}

# dist参数调用
# 注意：**otherInfo表示把otherInfo这个dict的所有key-value用关键字参数传入到函数的**kw参数，kw将获得一个dict，kw获得的dict是otherInfo的一份拷贝，对kw的改动不会影响到函数外的otherInfo
otherInfo = {'sex': 'male', 'job': 'Python Engineer'}
person('lidysun', 28, **otherInfo)
# lidysun 28 other: {'job': 'Python Engineer', 'sex': 'male'}

递归函数

# 在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。
# 例如计算阶乘n! = 1 x 2 x 3 x ... x n
def fact(n):
    if n == 1:
        return n
    else:
        return n * fact(n - 1)


print(fact(5))  # 120
# 使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。
print(fact(1000))  # 报错 RecursionError: maximum recursion depth exceeded in comparison

切片

# 字符串切片实例：字符串去首尾空格
def trim(s):
    while s[:1] == ' ':
        s = s[1:]
    while s[-1:] == ' ':
        s = s[:-1]
    return s


print(trim('  sun   gang   ')) 

尾递归函数优化

# 尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。
def fact(num):
    return fact_detail(num, 1)


def fact_detail(num, product):
    if num == 1:
        return product
    else:
        return fact_detail(num - 1, num * product)  # 函数返回的时候，调用自身本身，并且，return语句不能包含表达式


print(fact(5))  # 120

迭代

列表迭代

# 默认迭代字典的key值：
person = {'name': 'sungang', 'age': 27}
for x in person:
    print(x)
# name
# age

# 迭代字典的vaule值
for y in person.values():
    print(y)

字典迭代

# 利用迭代求列表中最小最大值，返回tuple：
def findMinAndMax(L):
    if len(L) == 0:
        return (None, None)
    if (len(L) == 1):
        return (L[0], L[0])

    max = min = L[0]
    for x in L:
        if x >= max:
            max = x
        if x <= min:
            min = x
    return (min, max)