Python-while循环+函数

while循环

  • 一个循环语句

  • 表示当某条件成立的时候，就循环

  • 不知道具体循环次数，但能确定循环的成立条件的时候用while循环

  • while语法：

      while 条件表达式：
      语句块

  #另外一种表达方法
  while  条件表达式：
      语句块1
  else：
      语句块2
    # 如果说年利率是6.7%，本利是每年翻滚， 则多少年后本钱会翻倍

benqian = 100000
year = 0
while benqian < 200000:
    benqian = benqian * (1+0.067)
    year += 1 # year = year + 1
    print("第 {0} 年拿了 {1} 块钱".format(year, benqian))




第 1 年拿了 106700.0 块钱
第 2 年拿了 113848.9 块钱
第 3 年拿了 121476.77629999998 块钱
第 4 年拿了 129615.72031209998 块钱
第 5 年拿了 138299.97357301068 块钱
第 6 年拿了 147566.07180240238 块钱
第 7 年拿了 157452.99861316333 块钱
第 8 年拿了 168002.34952024528 块钱
第 9 年拿了 179258.5069381017 块钱
第 10 年拿了 191268.8269029545 块钱
第 11 年拿了 204083.83830545243 块钱
    View Code
    # 如果说年利率是6.7%，本利是每年翻滚， 则多少年后本钱会翻倍
# 如果拿到的钱翻倍，则用print庆祝一下
benqian = 100000
year = 0
while benqian < 200000:
    benqian = benqian * (1+0.067)
    year += 1 # year = year + 1
    print("第 {0} 年拿了 {1} 块钱".format(year, benqian))
else:
    print("大爷的，终于翻倍了，10多年呀")
    print("当年10万可以盖个房子，现在儿子结婚，20万可以给他盖个厨房了")





第 1 年拿了 106700.0 块钱
第 2 年拿了 113848.9 块钱
第 3 年拿了 121476.77629999998 块钱
第 4 年拿了 129615.72031209998 块钱
第 5 年拿了 138299.97357301068 块钱
第 6 年拿了 147566.07180240238 块钱
第 7 年拿了 157452.99861316333 块钱
第 8 年拿了 168002.34952024528 块钱
第 9 年拿了 179258.5069381017 块钱
第 10 年拿了 191268.8269029545 块钱
第 11 年拿了 204083.83830545243 块钱
大爷的，终于翻倍了，10多年呀
当年10万可以盖个房子，现在儿子结婚，20万可以给他盖个厨房了
    View Code

函数

  • 代码的一种组织形式
  • 一个函数一般完成一项特定的功能
  • 函数使用
    • 函数需要先定义
    • 使用函数，俗称调用 
      # 定义一个函数
# 只是定义的话不会执行
# 1. def关键字，后跟一个空格
# 2. 函数名，自己定义，起名需要遵循便令命名规则，约定俗成，大驼峰命名只给类用
# 3. 后面括号和冒号不能省，括号内可以由参数
# 4. 函数内所有代码缩进

def func():
    print("我是一个函数")
    print("我要完成一定功能")
print("我结束了")



我结束了
      View Code
      # 函数的调用
# 直接函数名后面跟括号
func()



我是一个函数
我要完成一定功能
      View Code

函数的参数和返回值

  • 参数： 负责给函数传递一些必要的数据或者信息
    • 形参（形式参数）： 在函数定义的时候用到的参数没有具体值，只是一个占位的符号，成为形参
    • 实参（实际参数）： 在调用函数的时候输入的值
  • 返回值： 函数的执行结果
    • 使用return关键字
    • 如果没有return，默认返回一个None
    • 函数一旦执行return语句，则无条件返回，即结束函数的执行 
      # 参数的定义和使用
# 参数person只是一个符号，代表的是调用的时候的某一个数据
# 调用的时候，会用p的值代替函数中所有的person

def hello(person):
    print("{0}, 你肿么咧".format(person))
    print("Sir, 你不理额额就走咧")
  
p = "明月"
hello(p)



明月, 你肿么咧
Sir, 你不理额额就走咧
      View Code
      # return语句的基本使用
# 函数打完招呼后返回一句话
def hello(person):
    print("{0}, 你肿么咧".format(person))
    print("Sir, 你不理额额就走咧")
    
    return "我已经跟{0}打招呼了，{1}不理我".format(person, person)
  
p = "明月"
rst = hello(p)

print(rst)






明月, 你肿么咧
Sir, 你不理额额就走咧
我已经跟明月打招呼了，明月不理我
      View Code
      # return案例2

def hello(person):
    print("{0}, 你肿么咧".format(person))
    return "哈哈，我提前结束了"
    print("Sir, 你不理额额就走咧")
    return "我已经跟{0}打招呼了，{1}不理我".format(person, person)

p = "LiYing"
rst = hello(p)
print(rst)




LiYing, 你肿么咧
哈哈，我提前结束了
      View Code
      # 查找函数帮助文档
# 1. 用help函数
help(print)





Help on built-in function print in module builtins:

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    
    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.
      View Code
      # 九九乘法表
# version 1.0
for row in range(1,10):
    # 打印一行
    for col in range(1, row+1):
        # print函数默认任务打印完毕后换行
        print( row * col, end=" ")
    print("-------------------")




1 -------------------
2 4 -------------------
3 6 9 -------------------
4 8 12 16 -------------------
5 10 15 20 25 -------------------
6 12 18 24 30 36 -------------------
7 14 21 28 35 42 49 -------------------
8 16 24 32 40 48 56 64 -------------------
9 18 27 36 45 54 63 72 81 -------------------
      View Code
      # 定义一个函数，打印一行九九乘法表
def printLine(row):
    for col in range(1, row+1):
        # print函数默认任务打印完毕后换行
        print( row * col, end=" ")
    print("")
  
# 九九乘法表
# version 2.0
for row in range(1,10):
    printLine(row)



1 
2 4 
3 6 9 
4 8 12 16 
5 10 15 20 25 
6 12 18 24 30 36 
7 14 21 28 35 42 49 
8 16 24 32 40 48 56 64 
9 18 27 36 45 54 63 72 81
      View Code

参数详解

　　python的位置参数、默认参数、关键字参数、可变参数区别

 

    • 位置参数
      • 调用函数时根据函数定义的参数位置来传递参数。
#!/usr/bin/env python
# coding=utf-8

def print_hello(name, sex):
    sex_dict = {1: u'先生', 2: u'女士'}
    print 'hello %s %s, welcome to python world!' %(name, sex_dict.get(sex, u'先生'))


# 两个参数的顺序必须一一对应，且少一个参数都不可以
# print_hello('tanggu', 1)
View Code

 

    • 关键字参数

      • 用于函数调用，通过“键-值”形式加以指定。可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求。 
        # 以下是用关键字参数正确调用函数的实例
# print_hello('tanggu', sex=1)
# print_hello(1, name='tanggu')
# print_hello(name='tanggu', sex=1)
# print_hello(sex=1, name='tanggu')

# 以下是错误的调用方式
# print_hello(name='tanggu', 1)
# print_hello(sex=1, 'tanggu')
        View Code

        通过上面的代码，我们可以发现：有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序的

    • 默认参数
      • 用于定义函数，为参数提供默认值，调用函数时可传可不传该默认参数的值（注意：所有位置参数必须出现在默认参数前，包括函数定义和调用） 
        # 正确的默认参数定义方式--> 位置参数在前，默认参数在后
def print_hello(name, sex=1):
    ....

# 错误的定义方式
def print_hello(sex=1, name):
    ....

# 调用时不传sex的值，则使用默认值1
# print_hello('tanggu')

# 调用时传入sex的值，并指定为2
# print_hello('tanggu', 2)
        View Code

    • 可变参数

      • 定义函数时，有时候我们不确定调用的时候会传递多少个参数(不传参也可以)。此时，可用包裹(packing)位置参数，或者包裹关键字参数，来进行参数传递，会显得非常方便。

        • 包裹位置传递

          def func(*args):
    ....


# func()
# func(a)
# func(a, b, c)
          View Code

          我们传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple)，args是元组类型，这就是包裹位置传递。

        • 包裹关键字传递

          def func(**kargs):
    ....

# func(a=1)
# func(a=1, b=2, c=3)
          View Code

          kargs是一个字典(dict)，收集所有关键字参数

    • 解包裹参数

      • *和**，也可以在函数调用的时候使用，称之为解包裹(unpacking)

        • 在传递元组时，让元组的每一个元素对应一个位置参数

          def print_hello(name, sex):
    print name, sex

# args = ('tanggu', '男')
# print_hello(*args)
# tanggu 男
          View Code

        • 在传递词典字典时，让词典的每个键值对作为一个关键字参数传递给函数

          def print_hello(kargs):
    print kargs

# kargs = {'name': 'tanggu', 'sex', u'男'}
# print_hello(**kargs)
# {'name': 'tanggu', 'sex', u'男'}
          View Code

    • 位置参数、默认参数、可变参数的混合使用

      • 基本原则是：先位置参数，默认参数，包裹位置，包裹关键字(定义和调用都应遵循) 
        def func(name, age, sex=1, *args, **kargs):
    print name, age, sex, args, kargs


# func('tanggu', 25, 2, 'music', 'sport', class=2)
# tanggu 25 1 ('music', 'sport') {'class'=2}
        View Code

        Python中 *args 和 **kwargs 的区别

        先来看个例子：

        def foo(*args, **kwargs):
    print 'args = ', args
    print 'kwargs = ', kwargs
    print '---------------------------------------'

if __name__ == '__main__':
    foo(1,2,3,4)
    foo(a=1,b=2,c=3)
    foo(1,2,3,4, a=1,b=2,c=3)
    foo('a', 1, None, a=1, b='2', c=3)
        View Code

        输出结果如下：

        args =  (1, 2, 3, 4) 
kwargs =  {} 
--------------------------------------- 
args =  () 
kwargs =  {'a': 1, 'c': 3, 'b': 2} 
--------------------------------------- 
args =  (1, 2, 3, 4) 
kwargs =  {'a': 1, 'c': 3, 'b': 2} 
--------------------------------------- 
args =  ('a', 1, None) 
kwargs =  {'a': 1, 'c': 3, 'b': '2'}
        View Code

        可以看到，这两个是Python中的可变参数。*args 表示任何多个无名参数，它是一个tuple；**kwargs 表示关键字参数，它是一个dict。并且同时使用*args和**kwargs时，必须*args参数列要在**kwargs前，像foo(a=1, b='2', c=3, a', 1, None, )这样调用的话，会提示语法错误“SyntaxError: non-keyword arg after keyword arg”。

        知道*args和`**kwarg是什么了吧。还有一个很漂亮的用法，就是创建字典：

        def kw_dict(**kwargs):
        return kwargs
    print kw_dict(a=1,b=2,c=3) == {'a':1, 'b':2, 'c':3}
        View Code

        其实python中就带有dict类，使用dict(a=1,b=2,c=3)即可创建一个字典了。

        *args：

        　　重点在*，后面的args相当于一个变量名，可以自己定义的。它的本质就是将标准调用剩下的值集中转变为元组。

        #*args的运用
def foo (x,*args):
    print(x)
    print(args)

foo(1,2,3,4,5,6,6,'a','b')  #调用函数

输出：
 1----->x
(2, 3, 4, 5, 6, 6, 'a', 'b')----->*args
        View Code
        #从形参的角度
def foo(*args):  # foo(x,y,z)参数个数可以至多个
    print(args)
 
foo(1, 2, 3)  # 没有个数限制
(1, 2, 3)      #输出结果<br>#*args=*(1,2,3)
        View Code
        从实参的角度
def bar(x,y,z):
    print(x)
    print(y)
    print(z)

# bar(*(1,2,3,4)) #会报错只需要3个值，但给定的实参有4个值，不能一一对应
bar(*(1,2,3))   #实参一一对应
1
2
3
        View Code

        *args与位置参数和默认参数混用：（输出元组）

        #*args与位置参数和默认参数混用:*args要放到位置参数后面，默认参数要放最后。
def foo(x,*args,y = 1):
    print(x)
    print(y)
    print(args)
foo(1,2,3,4,5,6,7,8,9,10,y=10000)   #调用函数
1------->x=1
10000-------->y=10000
(2, 3, 4, 5, 6, 7, 8, 9, 10)----->args的值变成元组
        View Code

        **kwargs（输出字典）

        重点在**，后面的kwargs相当于一个变量名，可以自己定义的。它的本质就是将关键字调用剩下的值集中转变为字典。
def foo(x,**kwargs):    #kwargs = {'y':1,'z': 2}
    print(x)
    print(kwargs)
foo(1,y=1,z=2)      #调用函数
# 1-->x的值
# {'y': 1, 'z': 2} #kwargs的值，转为了一个字典
        View Code

        从不同角度看**kwargs：

        def foo(**kwargs):　　#foo(x=1,y=2,z=3)参数个数可以一个至多个
    print(kwargs)

foo(x=1,y=2,z=3)　　#调用函数，没有个数限制
{'x': 1, 'y': 2, 'z': 3}　　----->输出字典
--------------分割线-------------------------
def foo(x,y,z):
    print(x)
    print(y)
    print(z)
# foo(**{'x' : 1,'y' : 2, 'z' : 3,"a":4 })#TypeError: foo() got an unexpected keyword argument 'a',报错原因是函数foo只有3个值(x,y,z)
foo(**{'x' : 1,'y' : 2, 'z' : 3})   #三个值正好匹配
1#输出结果
2
3
        View Code

        **kwargs与位置参数和默认参数混用：

        def foo(x,a = 4,**kwargs):  #混合使用参数
    print(x)
    print(a)
    print(kwargs)

foo(1,y=2,z=3)　　#使用默认参数
1　　#输出
4
{'y': 2, 'z': 3}

 

foo(1,5,y=2,z=3)　　#修改默认参数

1
5
{'y': 2, 'z': 3}
        View Code

        超复杂混合参数混用记：

        从形参角度：

        def foo(x,*args,a=4,**kwargs):　　#使用默认参数时，注意默认参数的位置要在args之后kwargs之前
    print(x)
    print(a)
    print(args)
    print(kwargs)

foo(1,5,6,7,8,y=2,z=3)  #调用函数，不修改默认参数
1   #x的值
4   #a的值
(5, 6, 7, 8)   #*args的值
{'y': 2, 'z': 3}    ##kwargs的值
        View Code
        def foo(x,a=4,*args,**kwargs):　　##注意：当需要修改默认参数时，要调整默认参数的位置，要放在args之前即可，但不可放在开头。
    print(x)
    print(a)
    print(args)
    print(kwargs)

foo(1,9,5,6,7,8,y=2,z=3)    #调用函数，修改默认参数a为9
1   #x的值
9   #被修改后a的值
(5, 6, 7, 8)    #args的值
{'y': 2, 'z': 3}    #kwargs的值
        View Code

        从实参角度：

        def foo(x,*args,a=4,**kwargs):  #使用默认参数时，注意默认参数的位置要在args之后kwargs之前
    print(x)
    print(a)
    print(args)
    print(kwargs)

foo(1,*(5,6,7,8),**{"y":2,"z":3})   #调用函数，不改默认参数
1   #x的值
4   #默认a的值
(5, 6, 7, 8)    #args的值
{'y': 2, 'z': 3}    #kwargs的值
-------------分割线----------------------
def foo(x,a=4,*args,**kwargs):  #注意：当需要修改默认参数时，要调整默认参数的位置，要放在args之前，但不可放在开头
    print(x)
    print(a)
    print(args)
    print(kwargs)

foo(1,9,10,*(5,6,7,8),**{"y":2,"z":3})  #调用函数，修改默认参数a为9
1   #x的值
9   #修改默认参数a后的值
(10, 5, 6, 7, 8)    #args的值
{'y': 2, 'z': 3}    #kwargs的值
        View Code

        小结：

        位置参数：

        调用函数时所传参数的位置必须与定义函数时参数的位置相同

        关键字参数：

        使用关键字参数会指定参数值赋给哪个形参，调用时所传参数的位置可以任意

        *位置参数：可接受任意数量的位置参数(元组)；只能作为最后一个位置参数出现，其后参数均为关键字参数

        **关键字参数：可接受任意数量的关键字参数(字典)；只能作为最后一个参数出现

        默认参数：默认参数的赋值只会在函数定义的时候绑定一次，默认值不会再被修改

参数详解

  • python参考资料： headfirst python -> 零基础入门学习python（小甲鱼),本讲义参考的是流畅的python-->习题-->后期可以考虑腾讯公开免费课

  • 参数分类

    • 普通参数
    • 默认参数
    • 关键字参数
    • 收集参数

  • 普通参数

    • 参见上例
    • 定义的时候直接定义变量名
    • 调用的时候直接把变量或者值放入指定位置
            def 函数名（参数1， 参数2，....):
                函数体

            # 调用
            函数名（value1, value2,.......)

            # 调用的时候，具体值参考的是位置，按位置赋值

  • 默认参数

    • 形参带有默认值

    • 调用的时候，如果没有对相应形参赋值，则使用默认值

            def  func_name(p1=v1, p2=v2..........):
          func_block

      #调用1
      func_name()

      # 调用2
      value1= 100
      value2=200
      func_name(value1,value2)
      # 默认参数示例
# 报名函数，需要知道学生性别
# 学习python的学生基本都是男生，所以，报名的时候如果没有特别指定，我们任务是男生
def reg(name, age, gender="male"):
    if gender == "male":
        print("{0} is {1}, and he is a good student".format(name, age))
    else:
        print("{0} is {1}, and she is a good student".format(name, age))
      View Code
      # 调用默认参数函数案例1

reg("mingyue", 21)

reg("xiaojing", 23, "female")


输出结果如下：
mingyue is 21, and he is a good student
xiaojing is 23, and she is a good student
      View Code

       

posted @ 2020-04-10 16:28  kellen-fang  阅读(1540)  评论(0)  编辑  收藏  举报