Python-while循環+函數

本文轉載自查看原文 2020-04-10 16:28 1044 python/ Python全棧筆記

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

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 一個小故事，玩轉Python-while循環 python學習——將while循環改成函數 python while循環與for循環 Python循環語句（for..in，while循環和range（）函數） python——for循環與while循環的區別 Python之循環語句（while和for循環） Python之while循環 Python while循環 Python - while 循環 python while循環案例