函数
我们可以把程序中相对独立的功能模块抽取出来这样做的好处一是减少重复代码的编写
二是将来可以重复的使用这些功能模块python中的函数就是代表了这样的功能模块
y = f(x) f 是函数名 x 是自变量 y 是因变量
注意
如果定义的函数名重复了，则后面定义的函数将更新前面定义的函数
A and B 如果A False，B被短路，B不被执行
A or B 如果A True，B被短路，B不被执行
所以A 和 B 位置的不同可能会对执行效率产生明显影响一个文件就是一个模块，千万不要在一个模块中有定义很多功能的函数，尽量保证模块功能的单一性
作用域 - LEGB 尽量减少全局变量的使用
在定义的函数中不能用print(),用了就表面你的函数只能在命令提示行里面执行，不能在窗口中执行(在做项目时坚决执行)
print('%02d ' % val, end='') # 把val格式化成两位输出from combination import * # 导入combination中所有模块 from combination as com # 将combination 重命名为com from math import gcd # 系统将用下面combination中后导入的gcd函数 from combination import is_prime, gcd, lcm, add,is_palindrome # 调用函数时若出现重复，则自动取后调入的函数 # 如果想两个函数同时存在，则不用from导入 # 直接import combination 和 import math # 然后用combination.gcd 和 math.gcd
可变参数的函数
def f(*args):
total = 0
for val in args:
total += val
return total
# 定义了一个可变参数的函数，如果想传入一个列表的每个元素，则在列表名前加上*
mylist = [1, 3, 5, 10, 20]
print(f(*mylist))
作用域
python 搜索一个变量的方式是从局部作用域到嵌套作用域再到全局作用域
local - Enclosed - Global
LEGB
如果想改变搜索范围 可以使用global和 nonloal关键字
在实际编程中一定不要随便使用全局变量
# 在函数外面定义的 a 是一个全局变量
# global variable
a = 100
def foo():
# local variable
# 函数内的局部变量 离开foo函数 a 是无法访问的
a = 200
print(a)
foo()
print(a)
# 在函数外面定义的 a 是一个全局变量
# global variable
a = 100
b = 'good'
def foo():
b = 'hello'
def bar():
b = 'shit'
print(a)
print(b)
bar()
foo()
print(a)
# 在函数外面定义的 a 是一个全局变量
# global variable
a = 100
def foo():
global a
a = 200
b = 'hello'
def bar():
global b
b = 'good'
print(a)
print(b)
bar()
print(b)
foo()
print(a)
# 在函数外面定义的 a 是一个全局变量
# global variable
a = 100
def foo():
global a
a = 200
b = 'hello'
def bar():
nonlocal b
b = 'good'
print(a)
print(b)
bar()
print(b)
foo()
print(a)
各种函数实例
求阶乘
# 定义求阶乘的函数 将求阶乘的功能抽取出来放到函数中
def f(x):
y = 1
for z in range(1, x + 1):
y *= z
return y
if __name__ == '__main__':
m = int(input('m = '))
n = int(input('n = '))
# 当需要计算阶乘的时候不用再写循环而是直接调用已经定义好的函数
# 求C(m,n)
print(f(m) // f(n) // f(m - n))
求阶乘2
# 阶乘
def foo(n):
if n==0:
sun = 1
else:
sun = n * foo(n-1)
return sun
求最大公约数和最小公倍数
# 如果定义的函数名重复了，则后面定义的函数将更新前面定义的函数
from math import sqrt
# 谷歌的文档注释方法
def gcd(x, y):
"""
计算最大公约数
parameters:
x 一个非负整数
y 一个非负整数
Returns:
x, y 的最大公约数
"""
(x, y) =(y, x) if x > y else (x, y)
for factor in range(x, 0, -1):
if x % factor == 0 and y % factor == 0:
return factor
# 文档注释
def lcm(x, y):
"""
计算最小公倍数
:param x:非负整数
:param y:非负整数
:return:最小公倍数
"""
return x * y //gcd(x, y)
短除法求最大公约数
# 最大公约数（短除法）
def bar1(x,y):
if x > y:
return bar1(y, x)
elif y % x == 0:
return x
else:
return bar1(y % x, x)
计算台阶走法
# 有10步台阶，一个小孩每次可以选择一次走1步、2步、3步，问走完这个台阶有几种方法
def bar2(n):
if n < 0:
return 0
elif n == 0:
return 1
else:
return bar2(n - 1) + bar2(n - 2) + bar2(n - 3)
判断素数
# 官方的文档注释方法
def is_prime(num):
"""
判断素数
:param num: 非负整数
:return: 是素数就返回True 否则 返回False
"""
for j in range(2, int(sqrt(num)) + 1):
if num % j == 0:
return False
return True if num != 1 else False
判断一个数是不是回文数
def is_palindrome(num):
"""
判断一个数是不是回文数
:param num: 一个非负整数
:return:是回文数返回True否则返回False
"""
temp = num
total = 0
while temp > 0:
total = total * 10 + temp % 10
temp //= 10
return num == total
拿21根火柴
21跟火柴，人先拿，拿计算机后，最少1根，最多4根，谁拿到最后一根就算输保证计算机获胜
from random import randint
def is_macth():
"""
判断谁拿最后一根火柴
:return: 返回结果
"""
total = 21
while total > 0:
print('总共还有%d根火柴' % total)
while True:
peopel = eval(input('请输入你拿的根数'))
if 0 < peopel <= 4 and peopel <= total:
break
total -= 5
if total > 0:
print('电脑拿走了%d根火柴' % (5 - peopel))
print('你拿走了最后一根，你输了')
判断回文字符串
def is_pa(my_str):
"""
判断回文字符串
:param my_str: 输入的字符串
:return: 是回文字符串返回True，不是返回Fals
"""
temp = ''
my_str1 = my_str
for _ in range(len(my_str)):
temp += my_str1[-1]
my_str1 = my_str1[:-1]
if temp == my_str:
return True
else:
return False
字符串
字节.PNG
字符串常用功能
字符串的所有功能都不直接更改原字符串，而是产生了一个新的字符串赋值给你
help(''.find)
# 不变字符串 相当于str1一直不变，变的是新字符串
str1 = 'hello, world!'
print(len(str1)) # 返回长度
print(str1.capitalize()) # 首字母大写
print(str1.upper()) # 全大写
print(str1)
print(str1.find('or')) # 查找并返回下标
print(str1.find('shit')) #查不到返回-1
print(str1.startswith('He')) # 看是不是He开头
print(str1.startswith('he')) # 看是不是he开头
print(str1.endswith('!')) # 看结尾是不是！
print(str1.center(50, '*')) # 居中 并用*填满50个字符
print(str1.rjust(50, '#')) # 居左 并用#填满50个字符
# print(str1.index('or')) # 查找并返回下标
# print(str1.index('shit')) #查不到直接报错
str2 = 'abc123456'
print(str2[2]) # 取出c
print(str2[2:5]) # 取出 c12 第五个取不到
print(str2[-3:-1]) # 取出 45
print(str2[-1:-3:-1]) # 取出 45
print(str2[:]) # 全取
print(str2[:2]) # 取出ab
print(str2[5:]) # 取出3456
print(str2[::2]) # 隔一个取一个
print(str2[::-1]) # 字符串的倒转
print(str2.isdigit()) # 判断是不是全数字
print(str2.isalpha()) # 判断是不是全字母
print(str2.isalnum()) # 判断只有数字和字母
str3 = ' 644148993@qq.com '
print(str3.rstrip()) # 自动取消右边空格
print(str3.strip()) #自动取消左右两边空格
字符串的实例
制作文字跑马灯效果
# 文字跑马灯效果
def light():
contain = input('请输入跑马灯文字：')
while True:
os.system('cls')
print(contain)
time.sleep(0.5)
contain = contain[1:] + contain[0]
取文件名的后缀名
# 考虑到文件名有 .abc vbg. fig.gei.exe hosts 等情况 还考虑到要不要点：默认不要has_dot=False
def get_suffix(filename, has_dot=False):
"""
获取文件名的后缀名
:param filename: 文件名
:param has_dot: 是否要点（.）
:return: 后缀名
"""
pos = filename.rfind('.')
if 0 < pos < len(filename)-1:
index = pos if has_dot else pos + 1
return filename[index:]
else:
return ''
生成制定长度的随机验证码
def generate_code(code_len=4):
'''
生成由大小字母数字长度确定的随机验证码
:param code_len: 验证码长度
:return: 由大小字母数字组成的验证码
'''
all_char = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
last_pos = len(all_char) - 1
code = ''
for _ in range(code_len):
index = randint(0, last_pos)
code += all_char[index]
return code
统计掷x个色子y次后各个点数出现的次数
# 掷n个色子一次后掷出来的点数
def bar(n):
"""
计算n个色子摇一次的点数和
:param n:色子个数
:return:n个色子摇一次的点数和
"""
return 0 if n <= 0 else randint(1, 6) + bar(n - 1)
# 有了列表（容器）我们可以使用1个变量来保存多个数据
# 更为重要的是我们可以使用循环对列表中保存的数据进行操作
def dot(x, y):
"""
计算x个色子掷y次后每个点数出现的次数
:param x: 色子个数
:param y: 掷色子次数
:return: 利用列表返回每个点数出现的次数
"""
f = [0] * (6 * x - (x - 1))
for _ in range(y):
face = bar(x)
f[face - x] += 1
return f
列表
列表的加法
mylist = [x ** 2 for x in range(1, 10)]
mylist = mylist + [20, 30] # 列表的加法是添加元素
print(mylist)
列表的各种常用方法
# 列表
f = [10, 20, 30, 20, 40, 20, 50]
f1 = ['odlh', 'akdgah', 'idhgjfhgahjghaj', 'ddhgjhhgghh']
# CRUD Create Read Update Delete
'''
f.append() # 追加 加到最后
f.insert() # 插入 需要选择加入的位置（用一定的容错性）
f.clear() # 清空
f.remove() # 移除一个数，如果有多个相同元素，则删除开头那个
del f[6] # 删除50
print(f.index(40, 2, 5)) # 在2-5里面查找40，并返回索引
f.pop(1) # 删除索引为1的元素，默认为删除末尾元素
f.reverse() # 翻转f
enumerate(f) # 枚举 并返回索引
f2 = sorted(f1, key=len, reverse=True) # 对f1按照字符串长度排序，并且为倒序
'''
列表的生成方式
import sys
# 在计算机系统里面：
# 时间和空间是不可调和的矛盾
# 软件和硬件在逻辑上是等效的
def main():
f = list(range(10)) # 用list 构造器构造一个列表 （最不常用）
print(f)
g = [x ** x for x in range(1, 10)]
# 用列表的生成表达式语法创建列表容器 （生成式）
# 用这种语法创建列表之后元素已经准备就绪，所以需要较多的内尺空间
print(g)
h = [x ** 2 for x in range(1, 100)]
print(h)
print(sys.getsizeof(h))
k = (x ** 2 for x in range(1, 100))
# （生成器）--->除了把[]改成（），还可以把定义函数的 return 改成 yield
# 列表生成器 这里得到的不是一个列表 而是一个生成器对象 （生成器）
# 通过生成器可以获取到数据 它不占用额外的空间存储数据
# 每次需要数据的时候就通过生成器取数据 当然这需要花费时间
print(k)
print(sys.getsizeof(k)) #（计算k占用的内尺）
for val in k:
print(val, end='\t')
print()
d = [x + y for x in 'ABCD' for y in '1234']
print(d)
列表相关实例
Fibonacci序列
# fibonacci 序列
# [1, 1, 2, 3, 5, 8, 13, ... ]
a = []
for i in range(20):
if i >=2:
a.append(a[i-1] + a[i-2])
else:
a.append(1)
print(a)
print(a[18]/a[19]) # 黄金分割
print(a[::-1]) # 切片
print(a) # a 被操作后没有改变
a.reverse() # 翻转a
print(a) # a.reverse() 直接把a改变了
# 生成器方法
def fib(n):
a, b = 0, 1
for _ in range(n):
a, b = b, a + b
yield a
for val in fib(20):
print(val)
方法和函数
def main():
f = ['orange', 'apple', 'banna', 'cake']
# python 内置的排序方法默认都是升序（从小到大）
# 如果希望排序成降序（从大到小）可以通过reverse参数来控制
# python 中的函数几乎都是没有副作用的函数
# 调用函数后不会影响传入的参数
f2 = sorted(f, reverse=True) # 函数
print(f)
print(f2)
f.sort(reverse=True) # 方法
print(f)
f.reverse() # 方法
print(f)
f3 = list(reversed(f)) # 函数 reversed(f)返回的是一个反转迭代器，需要加lise才能看到反转的列表
print(f3)
计算最大值最小值和平均数
def my_math():
"""
计算一个列表的最大值最小值和平均数
:return: 计算一个列表的最大值最小值和平均数
"""
scores = [80, 59, 38, 99, 78]
maxscore = minscore = scores[0]
total = 0
for score in scores:
if score > maxscore:
maxscore = score
elif score < minscore:
minscore = score
total += score
print('最小值为%d，最大值为%d，平均值为%.1f' % (minscore, maxscore, total/len(scores)))
按照字符串长度排序
def bar():
"""
按照字符串长度排序
:return: 从长到短排序
"""
o = ['odlh', 'akdgah', 'idhgjfhgahjghaj', 'ddhgjhhgghh']
f2 = sorted(o, key=len, reverse=True)
print(f2)
随机返回几组双色球号码
def random_select():
"""
随机返回一组彩票（双色球）
:return: 返回一组双色球号码
"""
red_balls = list(range(1, 34))
selected_balls = []
for _ in range(6):
index = randrange(len(red_balls))
selected_balls.append(red_balls[index])
del red_balls[index]
selected_balls.sort()
selected_balls.append(randint(1, 16))
return selected_balls
def display(ball):
"""
在蓝色前面加上|，并在一位数前补上0
:param ball: 含一组彩票号码的列表容器
:return: 在蓝色前面加上|，并在一位数前补上0
"""
for index, val in enumerate(ball): # enumerate() 枚举 并返回索引
if index == len(ball) - 1:
print('| ', end='')
print('%02d ' % val, end='')
print()
def cycle():
"""
返回你需要注数的双色球号码
:return: 返回你需要注数的双色球号码
"""
n = int(input('给我摇几注：'))
for _ in range(n):
display(random_select())
求次大
# 求次大
def next_max(all_data):
max_one = max_two = all_data[0]
for value in all_data:
if value > max_one:
max_two = max_one
max_one = value
elif max_two < value < max_one:
max_two = value
return max_two
约瑟夫环问题
# 约瑟夫环问题：有15个基督教徒和15个非基督教徒坐船去旅游，船坏了，要杀掉15个人其他人才能获救
# 他们决定随机从一个人报数，数到9的就被杀死，结果15个基督教徒都活下来了，问他们是怎么站的？
def die():
people = [True] * 30
counter = 0
index = 0
number = 0
while counter < 15:
if people[index]:
number += 1
if number == 9:
people[index] = False
counter += 1
number = 0
index += 1
index %= 30
for person in people:
print('基' if person else '非', end='')
求去除最高分和最低分后的平均数
# 设计一个函数，去掉一个最高分和一个最低分后求平均数
def arv(list):
total = 0
max_value = min_value = list[0]
for select in list:
if select > max_value:
max_value = select
elif select < min_value:
min_value = select
list.remove(min_value)
list.remove(max_value)
for now_value in list:
total += now_value
return total/len(list)
返回最大分数及名字
# 原来有一个列表，装的是一组学生的名字，现在输入对应学生的成绩，找出最高分和最低分和对应的学生名字
def match(list1):
list2 = []
for name in list1:
score = eval(input('请输入%s的成绩：' % name))
list2.append(score)
max_score = max(list2)
min_score = min(list2)
my_max, my_min = list2.index(max_score), list2.index(min_score)
return '%s拥有最高分%d；%s拥有最低分%d' % (list1[my_max], list2[my_max], list1[my_min], list2[my_min], )
python 的坑
# python 的坑 如果静态区有缓存的数字，调用的时候都是引用的静态区的值，不是重新创建的对象
# 在交互式环境中，静态区自动缓存 -5----256
# 在非交互式环境中，静态区自动缓存所有正数
def main2():
a = 123
b = 123
print(id(a))
print(id(b))
print(a is b) # True
a = -123
b = -123
print(id(a))
print(id(b))
print(a is b) # False
内存管理
栈(stack) 堆(heap) 静态区（数据段，只读数据段，代码段）
变量--对象的引用--对象的内存地址 -- 栈
对象--堆--获取更大的存储空间
-
id()函数 和 is运算符 -- 验身份
import sys def main1(): # 栈(stack) 堆(heap) 静态区（数据段，只读数据段，代码段） # 变量--对象的引用--对象的内存地址 -- 栈 # 对象--堆--获取更大的存储空间 # id()函数 和 is运算符 -- 验身份 list1 = [x for x in range(1,10)] # list1 一个对象的地址 list2 = list1 # list1把对象的地址赋值给list2 list2[0] = 1000 # list1 和 list2 是同一个列表容器 print(list1) # [1000, 2, 3, 4, 5, 6, 7, 8, 9] list3 = list1[:] # 只有用切片的方法赋值list3一个新的列表容器 list3[1] = 1000 print(list2) # [1000, 2, 3, 4, 5, 6, 7, 8, 9] print(list3) # [1000, 1000, 3, 4, 5, 6, 7, 8, 9] # 可以查看地址，看是不是同一对象 print(id(list1)) print(id(list2)) print(id(list3)) print(sys.getrefcount(list)) # 得到list引用次数
元组 集合 字典
元组内的单个项目不能重新赋值，且同元素的元组创建时间比列表快很多（%timeit），且同元素的元组占用内存空间比列表少很多(getsizeof(a))
timeit2.PNG
集合部分功能
def main():
list1 = [1, 1, 2, 2, 3, 3]
print(list1)
tuple1 = (1, 1, 2, 2, 3, 3)
print(tuple1)
set1 = {1, 1, 2, 2, 3, 3}
print(set1)
set2 = {1, 3, 5, 7, 9}
set3 = set1.intersection(set2) # 集合的交集 set3 = set1 & set2
print(set3)
set3 = set1.union(set2) # 集合的并集 set3 = set1 | set2
print(set3)
set3 = set1.difference(set2) # 集合的差集 set3 = set1 - set2
print(set3)
set3 = set2.difference(set1)
print(set3)
set3 = set1.symmetric_difference(set2) # 集合的对称差 set3 = set1 ^ set2
for val in set2:
print(val)
# print(set2[0]) # 集合是无须存储的 没有下标 集合也没有重复元素（去重）
print(set2.pop()) # pop() 集合pop出来的值是随机的
if 3 in set2:
set2.remove(3)
print(set2)
print(set2.issubset(set1)) # 子集 set2 <= set1
print(set2.issuperset(set1)) # 超集 set2 >= set1
set4 = {1, 2}
print(set1.issuperset(set4))
集合 列表 元组 相互的转换
def main():
set1 = {'hello', 'good', 'cfx', 'hello'}
print(len(set1)) # 3
x = sorted(set1)
print(type(x)) # <class 'list'>
print(x) # ['cfx', 'good', 'hello']
list1 = list(set1)
print(list1) # ['good', 'hello', 'cfx']
list2 = [1, 2, 3, 1, 2, 4]
set2 = set(list2)
print(set2) # {1, 2, 3, 4}
tuple1 = (1, 1, 2, 3, 4, 4)
list3 = list(tuple1)
print(list3) # [1, 1, 2, 3, 4, 4]
字典的部分功能
def main():
dict1 = {'name': 'cfx', 'age': '24', 'gender': '男'}
print(dict1['name']) # cfx
print(dict1['age']) # 24
print(dict1['gender']) # 男
dict1['name'] = '王大锤'
# dict1 += {'tel': '13594793585'} 这个功能不行
dict1.update(height=172, fav=['吃', '喝'])
print(dict1.pop('age')) # 24
print(dict1.popitem()) # ('fav', ['吃', '喝'])
# del dict1 # del减少对象的引用 断开dict1的引用
del dict1['gender']
print(dict1) # {'name': '王大锤', 'height': 172}
for x in dict1:
print(x, '---->',dict1[x]) # key --value
dict1.setdefault('motto', '成年人的故事太动听')
print(dict1['motto']) # 成年人的故事太动听
del dict1['motoo']
print(dict1['motto']) # 为空
dict1.pop('motto')
元组 字典 集合的实例
二维数列的应用
def main():
names = ['关羽', '张飞', '赵云', '刘备', '孙权']
subjects = ['语文', '数学', 'python']
scores = [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
# scores = [[0, 0, 0] for _ in range(5)]
# scores = [[0] * len(subjects) for _ in range(5)]
# scores = [[0 for __ in range(3)] for _ in range(5)]
'''
# scores1 = [[0] * len(subjects)] * len(names)
# print(id(scores1[0])
# print(id(scores1[1])
# print(id(scores1[2]) # 都是一个地址，后面乘的5 只是引用了地址5次
# print(scores)
'''
for row,name in enumerate(names):
for col,subject in enumerate(subjects):
scores[row][col] = eval(input('请输入%s的%s成绩：' % (names[row], subjects[col])))
print(scores)
输入年月日判断是当年的第几天
def is_leap(year):
"""
判断是不是闰年
:param year: 输入年份
:return: 是闰年返回True，平年返回False
"""
return year % 4 == 0 and year % 100 != 0 or year % 400 == 0
def witch_day(year, month, date):
"""
判断当天是当年的第几天
:param year:输入的年
:param month:输入的月
:param date:输入的日
:return:返回天数
"""
leap = [[31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
[31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
][is_leap(year)]
# is_leap(year) 返回True时自动取1 返回False时自动取0.
total = 0
for index in range(month - 1):
total += leap[index]
return total + date
if __name__ == '__main__':
print(witch_day(2018, 1, 1)) #1
print(witch_day(2016, 3, 1)) # 61
print(witch_day(1980, 11, 28)) # 333
print(witch_day(1981, 12, 31)) # 365
返回杨辉三角（9种方法）
# 1
# 1 1
# 1 2 1
# 1 3 3 1
# 1 4 6 4 1
# 1 5 10 10 5 1
# 1 6 15 20 15 6 1
# 1 7 21 35 35 21 7 1
def pascal1(n):
"""
杨辉三角
:param n: 行数
:return: n行杨辉三角
"""
list1 = [[0 for _ in range(1, p+1)] for p in range(1, n+1)]
if n <= 0:
return None
else:
for i in range(n):
if i == 0:
list1[0][0] = 1
elif i == 1:
list1[1][0] = list1[1][1] = 1
else:
for j in range(i+1):
if j == 0:
list1[i][j] = 1
elif j == i:
list1[i][j] = 1
else:
list1[i][j] = list1[i - 1][j - 1] + list1[i - 1][j]
return list1
def display(n):
for i in range(n):
for j in range(i+1):
print(pascal1(n)[i][j], end='\t')
print()
def pascal2():
list2 = [1]
while True:
yield list2
list2 = [sum(i) for i in zip([0] + list2, list2 + [0] )]
def pascal3():
list2 = [1]
while True:
yield list2
list2 = list(map(lambda x, y: x + y, [0] + list2, list2 + [0]))
def pascal4(n):
list2 = [1]
while True:
yield list2
list2 = [list2[i] + list2[i+1] for i in range(len(list2) - 1)]
list2.insert(0,1)
list2.append(1)
if len(list2) == n:
break
def pascal5(n):
for du in range(1, n+1):
a = [1 for _ in range(du)]
if 2 < du < n + 1:
for x in range(du-2):
a[x+1] = b[x] + b[x+1]
b = a
print(a)
def pascal6(n):
list2 = [1]
i = 0
while i < n:
yield list2
list2.append(0)
list2 = [list2[i-1] + list2[i] for i in range(len(list2))]
i += 1
def pascal7(n):
list = []
for _ in range(n):
for _ in range(len(list) - 1):
list.append(list.pop(0) + list[0])
list.append(1)
print(list)
def pascal8(n):
i, L = 0,[[1]]
while i < n:
yield (L[i])
list3 = [1] + [L[i][x] + L[i][x+1] for x in range(0, len(L[i]) - 1)] +[1]
L.append(list3)
i += 1
def pascal9(n):
for i in range(n):
if i < 2:
list1 =[1] * (1 + i)
else:
list1[1:-1] = [list1[i] + val for i, val in enumerate(list1[1:])]
print(list1)
if __name__ == '__main__':
display(8)
# for val in pascal8(10):
# print(val)
# n = 0
# for t in pascal4():
# print(t)
# n += 1
# if n == 10:
# break
# pascal9(10)
# for val in fib(10):
# print(val)
