函数学习笔记2

习题1：
找到列表中第二大的数，可以用多种方法解决。
思路1：
找到最大的，删除掉，再找最大的

s = [1,2,3,-1,5,-2,4]
max_num = max(s)
s.remove(max_num)
max_num = max(a)
print("第二大的元素是：",max_num)

执行结果：

思路2：
排好序找倒数第二个

s = [1,2,3,-1,5,-2,4]
s.sort()

print("第二大的元素是：",s[-2])

执行结果：

思路3：
遍历，声明两个变量，一个存最大的，一个存第二大的，然后逐一比对。

s = [1,2,3,4,5,-1,-2]
max_num = s[0]
second_max_num = s[0]
for i in s:
    if i>=max_num:
        second_max_num = max_num
        max_num = i

print("第二大的元素是：",second_max_num)

执行结果：

冒泡排序：
s = [-1,1,-2,2,3,-3]
第一步：交换2个元素
交换的方法1：a,b = b,a
交换的方法2：
temp = b
b = a
a = temp
第二步：我要找到这个list中最大的元素，把它放到列表的最后位置
位置0和位置1比，如果大，交换，否则不换
位置1和位置2比，如果大，交换，否则不换
位置2和位置3比，如果大，交换，否则不换
。。。
位置4和位置5比，如果大，交换，否则不换

1、基于坐标遍历，最后一个元素不需要做遍历动作
遍历的反射：
1）把元素逐一取出
2）基于坐标位置逐一取出来，i，i+1

s = [-1,1,-2,2,3,-3]
for i in range(len(s)-1):
    if s[i] > s[i+1]:
        temp = s[i]
        s[i] = s[i+1]
        s[i+1] = temp

print(s)

2、使用if当前元素和后一个元素做比对，如果大了，交换，否则啥也不做
把最后1个元素我不处理了，把之前的所有的数，在做相同的动作，找到第2大元素

s = [-1,1,-2,2,3,-3]
for i in range(len(s)-1-i):
    if s[i] > s[i+1]:
        temp = s[i]
        s[i] = s[i+1]
        s[i+1] = temp

print(s)

把最后2个元素我不处理了，把之前的所有的数，在做相同的动作，找到第3大元素
把最后3个元素我不处理了，把之前的所有的数，在做相同的动作，找到第4大元素
。。。
把最后n-1个元素我不处理了，把之前的所有的数，在做相同的动作，找到第n大元素

s = [-1,1,-2,2,3,-3]
for j in range(len(s)-1):
    for i in range(len(s)-1-j):
        if s[i] > s[i+1]:
            temp = s[i]
            s[i] = s[i+1]
            s[i+1] = temp

print(s)

执行结果：

习题2：
python代码得到2个列表的交集与差集
不许用set
交集思路：遍历list1，判断是否在list2中，在的话，则存入一个列表中。
差集思路：分别遍历list1和2，如果不在对方的list中，则存入一个列表中。

s1 = [1,2,3,9,10]
s2 = [2,3,9,11]
result = []
for i in s1:
    if i in s2:
        result.append(i)

print("交集：",result)

执行结果：

s1 = [1,2,3,9,10]
s2 = [2,3,9,11]
result = []
for i in s1:
    if i not in s2:
        result.append(i)

for i in s2:
    if i not in s1:
        result.append(i)

print("差集：",result)

执行结果：

差集的实现方法2：两个集合的并集减去交集

s1 = [1,2,3,9,10]
s2 = [2,3,9,11]

result1 = []
result2 = []

for i in s1:
    if i in s2:
        result1.append(i)

print("交集",result1)
s1=s1+s2
for i in s1:
    if i not in result1:#不在交集里面的元素就是我想要的
        result2.append(i)

print("差集",result2)

执行结果：

函数：类外面的函数定义叫做函数
方法：类内部定义的函数叫做方法

求一个字符串中的字母个数，需要判断传入参数的类型。
加个要求，必须使用ASCII来判断是否是字母

def count_letter_num(s):
    if not isinstance(s,str):
        return None
    result = 0
    for i in s:
        if ord(i)>=65 and ord(i)<=90\
           or ord(i)>=97 and ord(i)<=122:
            result+=1
    return result

print("包含的字母个数 ",count_letter_num("I am a boy!"))

执行结果：

不可变对象：所有的数字、字符串、元组
可变对象：set dict list 实例
参数传不可变对象的时候，函数内外变量值是独立的
参数传可变对象的时候，函数内外变量值是关联的

在函数内部，使用global变量，会对外部变量有影响。

小练习：
要求有个值result来存结果
1 a，b数字，相加
2 a，b字符串，就当做字符串相加
3 a，b list，就当做list相加
4 不满足条件，则返回None

def add(a,b):
    if isinstance(a,(int,float))and isinstance(b,(int,float)):
        result = 0
    elif isinstance(a,str)and isinstance(b,str):
        result = ""
    elif isinstance(a,list)and isinstance(b,list):
        result = []
    else:
        return None
    result = a+b
    return result

print(add("1","2"))
print(add(1,2))
print(add([1],[2]))
print(add([1],"2"))

正向代理：
客户端和服务器之间的一个服务器或者是软件，负责转发用户的请求到源服务器。
发给不同的公司服务器
在你公司的局域网，某第三方服务器

反向代理：
在被访问服务器的局域网内，你的请求被它收到了之后，会被反向代理服务器解析你的请求url，然后将请求转发给不同的服务器处理。
反向代理+你要访问的服务器是一组，是一个公司开发的。
外人不知道。

使用元组作为函数的参数

def add(a,b,*arg):
    print(type(arg))
    print(arg)
    for i in arg:
        print(i)

print(add(1,2,3,4,5,6))

小练习：
输入5个字母，声明一个可变参数的函数，给我拼成一个单词。

def word_fun(*arg):
    result = ""
    for i in arg:
        result+=i
    return result

print(word_fun('a','b','c','d','e'))

使用字典作为函数的参数

def add(**kw):
    print(type(kw))
    print(kw)
    for i in kw:
        print(i)
    for j in kw.values():
        print(j)

print(add(a="1",b=2,c=3))

小练习：
使用必填参数、默认参数、可变元组参数、可变字典参数
计算一下单词的长度之和。

def count_letter_num(a,b="abc",*arg,**kw):
    result = 0
    result += len(a)
    result += len(b)
    for i in arg:
        result+=len(i)
    for i in kw.values():
        result+=len(i)
    return result

print(count_letter_num("a","b","c""d","e",x="f",y="g"))#"a"赋值给参数a了，"b"给了参数b，c,d,e给了arg，x,y给kw做key，f,g作为kw的value
print(count_letter_num("a"))
print(count_letter_num("a",c="x"))  

六剑客解决一行代码解决问题：
1 lambda
2 切片
3 map
4 filter
5 reduce
6 推导列表

list(map(str,[1,2,3]))

 list(map(lambda x:x+1,[1,2,3]))

def f(n):
    if n>='a' and n<='z':
        return n

list(filter(f,"AhgtSDFnik"))

from functools import reduce
reduce(lambda x,y:x+y,[1,2,3,4])

第一次计算：x=1,y=2
第二次计算：x=3,y=3
第三次计算：x=6,y=4
6+4=10

递归：（效率不高）
1 在函数中，自己调用自己
2 函数中一定要有结束递归的条件。
建议：使用3次调用，来分析递归调用的过程
累加：1+2+3+4+5

def add(n):
    if n == 1:
        return 1
    return add(n-1)+n    

print(add(3))
print(add(4))
print(add(5))

n设为3
n=3:第一次调用：add(3-1)+3—>add(2)+3 = 3+3=6
第二次调用：add(2-1)+2—>add(1)+2 = 1+2=3
第三次调用：add(1)—>return 1

fib 数列：
1 1 2 3 5 8 13
a1=1
a2=1
sum=a1+a2
a1=a2
a2=sum

非递归的算法：

def fib(n):
    if n <= 0 or not isinstance(n,int):
        return []
    result = []
    a1=1
    a2=1
    if n == 1:
        return result.append(a1)
    if n == 2:
        result.append(a1)
        return result.append(a2)
    result = [1,1]
    for i in range(n-2):
        temp = a1+a2
        result.append(temp)
        a1=a2
        a2=temp
    return result

print(fib(3))
print(fib(4))
print(fib(5))

方法2：

def fib(n):
    result = []
    if n <= 0 or not isinstance(n,int):
        return result
    for i in range(n):
        if i < 2:
            result.append(1)
        else:
            result.append(result[i-1]+result[i-2])
    return result

print(fib(3))
print(fib(4))
print(fib(5))
print(fib(6))

递归的算法：

def fib(n):
    if n == 1 or n == 2:
        return 1
    else:
        return fib(n-1)+fib(n-2)

print(fib(1))
print(fib(2))
print(fib(3))
print(fib(4))
print(fib(5))
print(fib(6))

n3:fib(2)+fib(1)---->1+1
n4:fib(3)+fib(2)---->1
fib(3)->fib(2)—>1+fib(1)---->1=2

练习：
将列表a = [1,2,[3,4,[5,6,7,[8,9,[10,11]]]]]里面的元素放到一个单层列表里面。[1,2,3,4,5,6,7,8,9,10,11]

a = [1,2,[3,4,[5,6,7,[8,9,[10,11]]]]]

def iter_list(l):
    for i in l:
        if isinstance(i,list):
            iter_list(i)
        else:
            print(i,end=" ")

print(iter_list(a))

def iter_list(l,result=[]):
    for i in l:
        if isinstance(i,list):
            iter_list(i,result)
        else:
            #print(i)
            result.append(i)
    return result

a = [1,2,[3,4,[5,6,7,[8,9,[10,11]]]]]
result = []
print(iter_list(a,result))

a = [1,2,[3,4,[5,6,7,[8,9,[10,11]]]]]
iter_list(a)
def iter_list(l,result=[]):
    for i in l:
        if isinstance(i,list):
            iter_list(i,result)
        else:
            #print(i)
            result.append(i)
    return result

a = [1,2,[3,4,[5,6,7,[8,9,[10,11]]]]]
print(iter_list(a))

1、只要不是永远执行自己调用自己，就肯定会在某个时刻递归结束
2、分析2-3次递归调用就可以了
3、递归调用过程的成果，需要使用list来进行保存。

练习：求两个数的最大公约数
方法一：

def greatest_common_division(a,b,c=0,result=[]):
    if c == 0:
        if a<b:
            c=a
        else:
            c=b
    if a%c ==0 and b%c ==0:
        result.append(c)
    else:
        greatest_common_division(a,b,c-1)
    return result[-1]

print(greatest_common_division(10,8))
print(greatest_common_division(10,5))

方法二：更相减损法

def get(small,big):
    if small > big:
        small,big = big,small
    if small == big:
        return small
    return get(small,big-small)

print(get(10,8))
print(get(10,5))

方法三：辗转相除法

def gain(small,big):
    if small > big:
        small,big = big,small
    if small == 0:
        return big
    return gain(small,big % small)

print(gain(10,8))
print(gain(10,5))