Python入门到精通

函数（一）

• 函数形参不需要声明类型，也不需要指定函数返回值类型
• 函数不接受参数也要保留一对（）
• 括号后面要有：

函数定义与调用基本语法

例一：斐波那契数列

def fib(n):
    a, b = 1, 1
    while a < n:
          print(a, end=' ')
          a, b = b, a+b
    print()
fib(1000)

例二：递归法进行素因数分解

from random import randint

def factors(num):
    #每次都从2开始查找因数
    for i in range(2, int(num**0.5)+1):
    #找到一个因数
    if num%i == 0:
       facs.append(i)
       #对商继续分解，重复这个过程
       factors(num//i)
       #注意break非常重要
     else:
       #不可分解 自身就是因数
       facs.append(num)

facs = []
n  = randint(2, 10**8)
factors(n)
results = '*'.join(map(str, facs))
if n==eval(result):
    print(n, '= '+result)

传递参数时的序列解包

def demo(a, b, c):
print(a+b+c)

seq = [1, 2, 3]
demo(*seq)

tup = (1, 2, 3)
demo(*tup)

def demo(a, b, c):
print(a, b, c)

dic = {'a':1,'b':2,'c':3}
demo(**dic)

变量作用域

>>> def demo():
global x
x = 3
y = 4
print(x,y)

>>> x = 5
>>> demo()
3 4
>>> x
3
>>> y
NameError: name 'y' is not defined

1.在这段代码中，函数之外有全局变量x，所以函数中的关键字global作用是声明要使用和修改外面已存在的全局变量x。

2.函数中的变量y没有任何声明，默认为局部变量，函数运行结束之后不再存在，所以在函数外访问时代码出错抛出异常。

lambda表达式

>>>f = lambda x, y, z:x+y+z
>>>f(1,2,3)
6
>>>g = lambda x, y=2, z=3: x+y+z
>>>g(1)
6
>>>g(2, z=4, y=5)
11

>>> L = [1,2,3,4,5]
>>>print(list(map(lambda x: x+10, L)))
[11,12,13,14,15]
>>>L
[1,2,3,4,5]

>>>data.sort(key=lambda x: len(str(x)))
>>>data
[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]
>>>data.sort(key=lambda x: len(str(x)), reverse=True)#降序
>>>data
[10,11,12,13,14,15,16,17,18,19,0,1,2,3,4,5,6,7,8,9]

生成器函数设计要点

• 包含yield语句
• 与return语句相似 都用来返回值。区别：返回值之后会暂停或挂起后面代码运行下次通过生成器对象的__next()__()方法、内置函数next（）方法for循环遍历生成器对象元素或其他方式显示“索要”数据时回复执行。
• 生成器具有惰性值的特点，适合大数据处理特点。

 能生成斐波那契数列的生成器函数

>>>def f():
   a, b = 1, 1
   while True:
          yield a
          a, b = b, a+b

>>>a = f()
>>>for i in range(10):
   print(a.__next__(), end=' ')

1.调用生成器函数时返回生成器表达式，并不是一个具体的值。

2.可以使用生成器对象的__next__()方法从前向后逐个返回生成器对象中的每个值，生成器对象使用yield返回一个值，然后暂停代码的执行，再次使用__next__()方法“索要”值时恢复执行。

精彩案例

编写函数，接受字符串参数，返回一个元组，其中第一个元素为 大写字母个数，第二个元素为小写字母个数：

def demo(s):
    result = [0, 0]
    for ch in s:
        if ch.islower():
           result[1] += 1
        elif ch.isupper():
           result[0] += 1
     return tuple(result)

打印杨辉三角：

def yanghui(t):
    print([1])
    line = [1, 1]
    print(line)
    for j in rang(2,t)
        r = []
        for j in range(0, len(line)-1):
             r.append(line[j]+line[j+1]
        line = [1]+r+[1]
        print(line)
yanghui(6)

编写函数，接受一个正偶数为参数，输出两个素数，并且这两个素数之和等于原来的正偶数。如果存在多组符合条件的素数，则全部输出。

def demo(n):
    def IsPrime(p):
        if p == 2:
            return True
        if p%2 == 0:
           return False
        for i in range(3,int(p**0.5)+1, 2):
           if p%i==0:
            return False
       return True

      if isinstance(n, int) and n>0 and n%2==0:
          for i in range(2, n//2+1):
               if IsPrime(i) and Isprime(n-i):
                  print(i,'+', n-i,'=', n)
demo(666)
 

编写函数，计算字符串匹配的准确率。

def Rate(origin, userInput):
    if not (isinstance(origin, str) and isinstance(userInput, str)):
        print('NO')
        return
    right = sum(1 for o, u in zip(origin, userInput) if o==u)
    return round(right/len(origin), 2)

模拟报数游戏：有n个人围成一个圈，顺序编号，从第一个人开始从一到k报数，报道k的人出圈，然后圈子缩小，从下一个人继续游戏，问最后留下的是原来第几号。

from itertools import cycle
 
def demo(lst, k):
    #切片，影响原来的数据
    t_lst = lst[:]
    #游戏一直进行到只剩下最后一个人
    while len(t_lst)：
         #创建cycle对象
         c = cycle(t_lst)
         #从1-k报数
         for i in range(k):
              t = next(c)
         #一个人出局，圈子缩小
         index = t_lst.index(t)
         t_lst = t_lst[index+1:] + t_lst[:index]
     #游戏结束
     return t_lst[0]

lst = list(range(1,11))
print(demo(lst, 3))

while循环

while True:
      print('='*30)
      print(startGame())
      r = input('Do you want to try once more?(y/n)')
      if r == 'n':
         break