Python全栈学习_day009知识点

1. 函数的初识
2. 函数的返回值
3. 函数的参数

统计字符串s的总个数(不能用len)

s='fkahfkahofijalkfkadhfkjadhf'
count = 0
for i in s:
    count += 1
print(count)

统计列表lis的总个数(不能用len)

lis = [1, 2, 3, 4, 5, 6, 7, 8, 9]
count = 0
for i in lis:
    count += 1
print(count)

def：关键字；函数名：定义与变量定义一样
def my_len():
    函数体

def my_len(lis):
    count = 0
    for i in lis:
        count += 1
    print(count)
my_len([1, 2, 3, 4, 5, 6, 7, 8, 9])        执行函数：函数名()

函数的优点：减少代码的重复率；增强代码的阅读性

函数到底是什么？函数最主要的目的：封装一个功能

    
s='fkahfkahofijalkfkadhfkjadhf'
print(len(s))

2. 函数的返回值：return

1. 函数中如果遇到return，则直接结束函数
2. 给函数的执行者返回值。  
    - return: None
    - return 单个值: 原封不动的返回
    - return 多个值: 返回一个元组, 所有的值作为元组的每一个元素
工作中，函数中尽量不要出现print()

def func1():
    print(111)
    print(222)
    return
    print(333)
func1()     整体是函数的执行者

def func1():
    '''返回多个值'''
    a = 1
    b = 2
    c = a + b
    d = 'alex'
    e = [1, 2, 3]
    return c, d, e
ret = func1()
print(ret, type(ret))
结果：（返回一个元组）
(3, 'alex', [1, 2, 3]) <class 'tuple'>

    
def my_len(s):
    count = 0
    for i in s:
        count += 1
    return count
print(my_len('fjklashfklah'))

1. 实参
    - 位置参数：必须要遵循按照顺序，一一对应
    - 关键字参数：可以不按照顺序，但是必须一一对应
    - 混合参数：关键字参数一定要在位置参数后面

2. 形参
    - 位置参数：按照顺序，一一对应
    - 默认参数

def my_len(argv):   形参：形式参数
    count = 0
    for i in argv:
        count += 1
    return count
print(my_len('fjklashfklah'))   函数的执行者(实参)：实际的参数

- 实参
位置参数: 必须要遵循按照顺序，一一对应

def func1(x, y):
    print(x, y)
func1(1, 2)

2个函数：
    - 返回两个数的和并且返回
    - 返回两个数的最大值

1.
def my_sum(x, y):
    return x + y
print(my_sum(1, 2))

2.
def my_max(a, b):
    if a > b:
        return a
    else:
        return b
print(my_max(3, 5))

三元运算：只针对于简单的if else这样的结构，才可以使用

ret = x if x > y else y
def my_max(a, b):
    return a if a > b else b
print(my_max(3, 5))

关键字传参: 可以不按照顺序，但是必须一一对应

def func1(x, y):
    return x + y
func1(y = 100, x = 55)

混合传参：关键字参数一定要在位置参数后面

def func1(a, b, n, x, y):
    return x + y

name = 'alex'
func1(100, 200, name, y = 100, x = 55)

形参角度：
    位置参数：按照顺序，一一对应
    默认参数：给其传值，将原来的默认参数覆盖掉；不传值，不报错，使用默认值
        应用场景：不经常改变的参数，但是一直在用

def func1(x, y, z):
    print(x, y, z)
func1(1, 2, 3)

def func1(x, y, z = 666)
    print(x, y, z)
func1(1, 2)
func1(1, 2, 333)

def name_list(n1, s1 = '男'):
    with open('name_list', encoding='utf-8', mode='a') as f1:
        f1.writer('{}|{}\n'.format(n1, s1))
while 1:
    name, sex = input('请输入姓名，性别：以，隔开').strip().replace('，', ',').split(',')
    if name.upper() == 'Q':break
    if sex.strip():
        name_list(name, sex)
    else:
        name_list(name)

默认参数的陷阱(面试题必考)
默认参数若是可变的数据类型，他始终使用的是一个

def func1(x, l1 = []):
    l1.append(x)
    return l1
ret = func1(1)
print(ret, id(ret))
ret1 = func1(100)
print(ret1, id(ret1))

结果：
[1] 2491314105416
[1, 100] 2491314105416