python for循环与函数

循环控制

for循环表达式

for循环通常用来遍历可迭代的对象

注意：

~for...in...属于固定格式  

~iterable表示可迭代对象

~i是变量名（可更改），代表可迭代对象里面的每个元素

while循环九九乘法表

i=1

while i <10:

       j=1

       while j<=i:

              print('*',end="")

              j +=1

i=i+1

print()

for循环九九乘法表

for i in range(1,10):

      for j in range(1,i+1):

             print(f'{j}*{i}={j*i}',end=' ')  #end='\n'

       print()

while和for区别例子：

li = [1, 2, 3, 4]
l = len(li)  # 4
# 设置循环结束条件
num = 0
while num<4:
    print(li[num])
    num +=1
print('-'*100)
for i in li:
    print(i)

函数

函数定义

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

语法格式

def 函数名 （参数1，参数2）

      代码块

函数名（） # 调用函数

~先定义函数，后调用

~如果没有写调用函数，函数里面的代码不会执行

~当执行完函数里面的代码，会再次回到调用函数的位置

函数作用

提高应该模块性与代码复用性

函数参数

可变类型参数与不可变类型参数:

~不可变类型参数在函数体内对变量重新赋值，相当于重新开辟了一块内存保存值

~可变类型参数在函数体内可以改变原有值

位置参数

~位置参数也就是实参与形参顺序一一对应，不论变量名

关键字参数

~以形参=实参形式指定，不论参数位置

默认值参数

~函数定义是已经先定义值，如果不传实参，形参会使用默认值

可变长度参数

1.*args：数据类型为元组

2.**kwargs：需要以键值对的形式传参，打包成字典的数据类型

例子：

#定义函数
def multi_table():
    for i in range(1, 10):
       for j in range(1, i + 1):
        print(f'{j}*{i}={j * i}', end=' ') # end='\n'
       print()
#调用函数
multi_table()

#不可变的参数
def text(a): # a为形参
    a=10 #整数是不可变类型，改变值相当于重新开辟了内存地址
    print(a)

a=1
text(a)
print(a)

#可变参数
def text(a):
    a.extend([1,2])#列表是数据可变类型，改变是，是同一个东西
    print('inner',a,id(a))

a = [1,2,3,4]
text(a)
print('out',a,id(a))

#位置参数
def person(name,age):
    print(f'你的姓名是{name},年龄是{age}')

person('zhangsan',18)#实参与形参位置是一一对应的

#关键字参数
def person(name,age):
    print(f'你的姓名是{name},年龄是{age}')

person(age=18,name='zhangsan')#关键字不受位置影响

#默认值参数
def person(name='zhangsan',age=19):
    print(f'你的姓名是{name},年龄是{age}')

person()#已经定义好了，传与不传没有关系  你的姓名是zhangsan,年龄是19

#*args
def text(*agrs):#接收是会转化为元组数据类型
    print(agrs)

text(1,2,3,4,5)#不传也没事，返回空元组

#**kwargs
dic=dict(name='zhangsan',age=18)
print(dic)

def text(**kwargs):
    print(kwargs)
text(a=1,b=2)#转化为字典类型

# 解包
a,b,c=(1,2,3)
print(a,b,c)

函数返回值

~使用return关键字返回内容

~将内容返回到函数调用处

~函数体中没用return语句时，函数运行结束，则默认返回None，也被称为隐含返回值

例子：

def text(a, b):
    c = a + b  # c 属性函数内部的值
    return c  # 将值返回到函数调用位置


# 拿到c的值，永久保存
num = text(1, 2)
print(num)


#摄氏度
def c_tem():
    c_t = 18
    print(f'摄氏度{c_t}')
    return c_t
#华氏度
def f_tem(c_t):
    f_t = c_t/1.8+32
    print(f'华氏度{f_t}')

c=c_tem()
f=f_tem(c)

def text():
    #局部作用域，作用域范围是函数体内
    a,b,c = (1,2,3)
    return a,b,c

print(text())#(1, 2, 3)

#全局变量

例子1：
a = 100
def text():
    print(a)# 全局的a,如果局部没有，去全局找

def text2():
    a = 200  # 局部的，全局的同时存在，优先使用局部的变量
    print(a) #200
text()
text2()
print(a)

#global
a=100
def text2():
    # global a #可以通过global告诉系统a是全局的
    a=20  #也可以在内部声明局部
    a = a+10 #系统分不清等号后的a是局部的还是全局的
    print(a) #200

#nonlocal
def text():
    b=6
    def text2():
        nonlocal b #父级作用域
        b=7 #只在text2里面有效
    text2()
    print(b)
text()

#bulit--in int float str
#范围：bulit--in>global>enclosing>local
# 优先使用：bulit--in<global<enclosing<local

递归函数

介绍：

函数直接或间接调用函数本身，则该函数称为递归函数

def myfunc(n):
    if n > 1:
        # print(n)
        return n+myfunc(n - 1)
    else:
        return 1

sum = myfunc(3)
print(sum)

内置文件函数

#返回1-10的奇数函数

for循环

for i in range(1,11):
    if i%2 !=0:
        print(i)

#偶数则将改变range（2，11，2）

filter结果为True留下，为False排除

def text(i):
    return i%2==1

print(list(filter(text,range(1,11))))

匿名函数

介绍：

当我们传入函数时，有些时候，不需要重复调用该函数，直接传入匿名函数更为方便，也无序担心函数名冲突，并且还可以将匿名函数赋值给一个变量，再利用变量来调用该函数

def ad(a,b):
    return a+b

print(ad(1,2))

f = lambda a,b:a+b
print(f(1,2))