Python基础：函数

最新推荐文章于 2024-05-12 13:47:30 发布

原创最新推荐文章于 2024-05-12 13:47:30 发布 · 1.1k 阅读

CC 4.0 BY-SA版权

#输入两个数，求他们之间所有的质数，把这些质数放在一个列表里，求出他们的和，并输出他们的最大最小值
a=int(input("请输入第一个数"))
b=int(input("请输入第二个数"))
c=[]
while a<b:
    i=2
    while i<a:
        if a%i==0:
            print("%d不是质数"%a)
            break
        i+=1
    else:
        print("%d是质数"%a)
        c.append(a)
    a+=1
print(c)
n=0
sum=0
while n<len(c):
    if n==0:
        max=c[n]
        min=c[n]
    else:
        if max<c[n]:
            max=c[n]
        elif min>c[n]:
            min=c[n]
    sum+=c[n]
    n+=1
print(sum,max,min)

# for j in range(a,b):

#     for i in range(2,j):

#         if j%i==0:

#             print("%d不是质数"%j)

#             break

#     else:

#         print("%d是质数"%j)

#         c.append(j)

# print(c)

# sum=0

# for n in range(len(c)):

#     if n==0:

#         max=c[n]

#         min=c[n]

#     else:

#         if max<c[n]:

#             max=c[n]

#         elif min>c[n]:

#             min=c[n]

#     sum+=c[n]

# print(sum,max,min)

#函数
def dylc():
    print("1楼：化妆品")
    print("2楼：男装")
    print("3楼：女装")
    print("4楼：童装")
    print("5楼：家电")
floor=int(input("请输入楼层"))
if floor==1:
    print("西单%d楼欢迎您"%floor)
    dylc()
    print("您现在在%d楼"%floor)
elif floor==2:
   print("西单%d楼欢迎您"%floor)
    dylc()
    print("您现在在%d楼"%floor)
elif floor==3:
    print("西单%d楼欢迎您"%floor)
    dylc()
    print("您现在在%d楼"%floor)
elif floor==4:
    print("西单%d楼欢迎您"%floor)
    dylc()
    print("您现在在%d楼"%floor)
elif floor==5:
    print("西单%d楼欢迎您"%floor)
    dylc()
    print("您现在在%d楼"%floor)

def dylc():

#     print("1楼：化妆品")

#     print("2楼：男装")

#     print("3楼：女装")

#     print("4楼：童装")

#     print("5楼：家电")

# a=["一","二","三","四","五"]

# floor=int(input("请输入楼层"))

# print("西单%d楼欢迎您"%floor)

# dylc()

# print("您现在在{}楼".format(a[floor-1]))

def sum(a,b):#a,b是形参

    c=a+b

    print("%d+%d=%d"%(a,b,c))

sum(1,2)#1,2是实参

sum(4,5)

def sum(a,b):

    c=a+b

    return c

x=sum(5,6)

print(x)

if x>10:

    print("大于10")

else:

    print("小于10")

def jisuan(a,b):

    c=a+b

    d=a-b

    e=a*b

    f=a/b

    return c,d,e,f

x=jisuan(5,6)

print(x)

a,b,c,d=jisuan(3,4)

print(a,b,c,d)

# 不可变类型参数：整数、字符串、元组。fun（a）内部修改 a的值，只是修改另一个复制的对象，不会影响 a 本身。

# 可变类型：列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响



def hs(a):

    a+=2

b=4

hs(b)

print(b)

print(hs(b))

def hs(a):

    a+=2

    return a

print(hs(b))

def kb(a):

    a.append(3)

b=[]

kb(b)

print(b)

def pt(name,age,sex):#关键字参数

    print("我叫",name)

    print("年龄",age)

    print("性别",sex)

pt(sex="女",name="张三",age=18)

def pt(name,age,sex="男"):#默认参数

    print("我叫",name,end="\t")

    print("年龄",age,end="\t")

    print("性别",sex)

pt("张三",18)

pt("李四",20)

pt("王五",30,sex="男")

pt("小红",19,sex="女")

def pt(*args):#可变参数

    print(args)

    for x in args:

        print(x,end=" ")

    print()

pt(1,2,3)

pt("a","b","c","abc")

def pt(**args):#*args为元组类型，**args为字典类型

    print(args)

    for k,v in args.items():

        print(k,v,end="\t")

    print()

pt(name="张三",age=18,sex="男")

pt(name="李四",age=20,sex="女",address="北京")

def sxh(a,b,sex="nan"):#位置参数必须在默认参数左边

    print(a,b,sex)

sxh(1,2)

def sxh(a,b,d=[]):#默认参数一定要用不可变参数，不然会有逻辑错误

    d.append("x")

    print(d)

sxh(1,2)

sxh(10,20)

#函数的嵌套

def waibu():

    print("1111")

    def neibu():

        print("2222")

    neibu()#在此调用内部函数

waibu()

# 全局变量，局部变量

a=0#全局变量

def hs():

    a=2#局部变量

    print(a)

hs()

print(a)#当全局变量与局部变量同名时：在定义局部变量的子程序内，局部变量起作用，在其他地方全局变量起作用

a=[]

def hs():

    a.append(2)

hs()

print(a)#如果全局变量是可变的数据类型，函数可以对全局变量内部直接进行修改

hs()

print(a)

a=3

def hs():

    a=a+5#会报错，因为此处两个a都是局部变量，第二个a没有赋值，所以无法将a+5赋值给a

hs()

print(a)#函数优先读取局部变量，能读全局变量，无法对全局变量重新赋值操作

a=3

def hs(a):

    a=a+5#此处的两个a都是局部变量

    print(a)

hs(a)

print(a)

a=3

def hs():

    print(a)#此处报错，因为只要函数中出现了局部变量，就全都是局部变量先print（a）时还没有给a赋值，所以print的a是还没有被声明的局部变量

    a=4

hs()

print(a)

a=3

def hs():

    global a#声明此处使用的是全局变量a，可以对其进行修改

    a=5

    print(a)

hs()

print(a)

def waibu():

    a=30

    def neibu():

        nonlocal a#nonlocal关键字使用外层(非全局)变量。

        a=40

    print(a)

    neibu()

    print(a)

waibu()

a=3

def waibu():

    a=30

    def neibu():

        nonlocal a#nonlocal关键字使用外层(非全局)变量。

        a=40

    print(a)

    neibu()

    print(a)

waibu()

#变量的查找顺序  从里向外查找

#作用域局部>外层作用域>当前模块中的全局>python内置作用域；

#LEGB:

# L:LOCAL：局部

# E:ENCLOSE：嵌套（外层）作用域

# G:GLOBAL：全局

# B:BUILT-IN:内置

a=300

b=20

c=1

def waibu():

    b=200

    c=10

    def neibu():

        c=100

        print(c)#局部变量

        print(b)#嵌套作用域（外层作用域）

        print(a)#全局变量

        print(max)#内置作用域

    neibu()

waibu()

#递归:如果一个函数在内部调用自身本身，这个函数就是递归函数。

def jc(n):#阶乘

    if n==1:

        return 1

    else:

        return n*jc(n-1)

print(jc(10))

def fbnq(n):

    if n==1 or n==2:

        return 1

    else:

        return fbnq(n-1)+fbnq(n-2)

for i in range(1,13):

    print("第%d个月的兔子数是"%i,fbnq(i))

# 递归特性:

# 1. 必须有一个明确的结束条件

# 2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少

# 3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，

#    每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

# 匿名函数：用lambda关键词能创建小型匿名函数。这种函数得名于省略了用def声明函数的标准步骤。lambda函数的语法只包含一个语句

x=lambda x:x*2+3

print(x(3))

y=lambda a,b:a*2+b*3

print(y(3,4))

a={"name":"张三","age":18,"addr":"北京"}

x=lambda b:b["age"]

print(x(a))

print(abs(-4))#abs:取绝对值

a=[1,21,-22]

b=max(a,key=abs)#abs在这里是参数不是函数,意思是用键（key）的方式比较a中的最大值，但是a中的每个元素的值不变

print(b)

print(a)

a=[-2,-3,1,9,4]

a.sort(key=abs)#以key的方式对a排序

print(a)

a=[

    {"name":1,"age":15,"address":"上海"},

    {"name":2,"age":25,"address":"北京"},

    {"name":3,"age":35,"address":"河北"},

    {"name":4,"age":45,"address":"山东"}

]

b=max(a,key=lambda x:x["age"])

print(b)

i=10

def a(x):

    print(x*i)#此时函数还没有调用i，所以i不是10而是30



i=20

def b(x):

    print(x*i)



i=30

def c(x):

    print(x*i)



a(3)

b(3)

c(3)

a=[lambda x:x*i for i in range(3)]#不执行lambda x:x*i函数，但是执行for i in range(3)

print(a[0](3))#x=3,i=2,执行a中的函数，此时a中的for语句循环结束，i=2.

print(a[1](3))#x=3,i=2

print(a[2](3))#x=3,i=2