函數參數

1.函數參數的傳遞規則，先按位置傳遞參數，再按照關鍵字傳遞參數。

#站在實參的角度上：
#按照位置傳參
#按照關鍵字傳參
#混着用能夠:可是 必須先按照位置傳參，再按照關鍵字傳參數
# 不能給同一個變量傳多個值

#站在形參的角度上
#位置參數：必須傳,且有幾個參數就傳幾個值
#默認參數: 能夠不傳，若是不傳就是用默認的參數，若是傳了就用傳的

 

#只有調用函數的時候
#按照位置傳 ： 直接寫參數的值
#按照關鍵字： 關鍵字 = 值

#定義函數的時候：
#位置參數 ： 直接定義參數
#默認參數，關鍵字參數 ：參數名 = '默認的值'
#動態參數 : 能夠接受任意多個參數
#參數名以前加*，習慣參數名args，
#參數名以前加**，習慣參數名kwargs
#順序：位置參數，*args,默認參數,**kwargs

 

# 動態參數有兩種：能夠接受任意個參數
#*args ： 接收的是按照位置傳參的值，組織成一個元組
#**kwargs： 接受的是按照關鍵字傳參的值，組織成一個字典
#args必須在kwargs以前

def func(b,a):
    
    print(a,b)

func(b=2,a = 1)



def func(a,b):
    print('%s,%s'%(a,b))

func('等等','水電費')    


def func(*args):
    print(args)

func(1,2,[1,2])

def func(**kwargs):
    print(kwargs)

func(a = 1,b =2)    



def func(*args):
    print(args)

li = [1,2]
func(*li)    


def func(**kwargs):
    print(kwargs)

li = {'a':1,'b':2}
func(**li)    

View Code

 

2.這兩天困擾個人一個問題，安裝pycharm沒有選中jre時候顯示沒有安裝JDK,安裝了1.7的JDK後，又顯示could not find main class com/intellij/idea/Main。

後來在網上查找資料發現如下解決方法：

1.應該是是JDK 的版本過低，個人從1.7升級到1.8就解決問題了。

2.官網oracle下載JDK1.8安裝包後，按照正常步驟安裝，而後修改環境變量以下：

(1)新建->變量名"JAVA_HOME"，變量值"C:\Java\jdk1.8.0_05"（即JDK的安裝路徑） 
(2)編輯->變量名"Path"，在原變量值的最後面加上「;%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin」 
(3)新建->變量名「CLASSPATH」,變量值「.;%JAVA_HOME%\lib;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar」

 

詳細狀況可參考個人百度帳號，個人經驗收藏的一篇文章

最後成功了，開心。

 

 3.一些小練習

#列表轉換爲字符串
# li = ['dfd', 'afe', 'd']
# print(''.join(li))
#字符串轉換列表
# s = 'skdlffsf'
# print(s.split('l',1))

#倒着打印100-0
'''
for i in range(100,-1,-1):
    print(i)
'''


# def func(a,b):
#     print('%s,%s' % (a, b))
#
# func(1,2)


s=input('>>>')
li = []
for i in s:
    print(i)
    if  i.isdigit() :
        if int(i) % 2 == 1:
            li.append(i)


print(len(li))

View Code

 

dic={'最終計算結果':None}
dic={}
content = input('請輸入內容：')
s = content.split('+')
sum = 0
for i in s:
   sum += int(i)
dic['最終計算結果'] = sum
print(sum,dic)

4.昨天的2道練習題目

# import os
# with open('ss', mode='r+', encoding='utf-8"') as f, open('ssss', 'w',encoding = 'utf-8') as f1:
#    for i in f:
#      if 'alex' in i:
#         i = i.replace('alex', 'sb')
#      f1.write(i)
#
# os.remove('ss')
# os.rename('ssss','ss')


# apple 10
# tesla 100000 1
# mac 3000 2
# lenovo 30000 3
# chicken 10 3
li = []
with open('aa',mode='a+',encoding='utf-8') as f:
    f.write('apple 10 3\n')
    f.write('tesla 100000 1\n')
    f.write('mac 3000 2\n')
    f.write('lenovo 30000 3\n')
    f.write('chicken 10 3\n')
    f.seek(0)
    for i in f:
       s = i.split()
       dic = {'name':s[0],'price':s[1],'account':s[2]}
       li.append(dic)

print(li)

View Code

 5.函數的參數

# def 深圳():
#     print('歡迎你')
# 深圳()

def func(l = []):
    l.append(1)
    print(l)
func()
func([])
func()

View Code

6.函數的命名空間和做用域

在這裏咱們首先回憶一下python代碼運行的時候遇到函數是怎麼作的。

從python解釋器開始執行以後，就在內存中開闢了一個空間

每當遇到一個變量的時候，就把變量名和值之間的對應關係記錄下來。

可是當遇到函數定義的時候解釋器只是象徵性的將函數名讀入內存，表示知道這個函數的存在了，至於函數內部的變量和邏輯解釋器根本不關心。

等執行到函數調用的時候，python解釋器會再開闢一塊內存來存儲這個函數裏的內容，這個時候，才關注函數裏面有哪些變量，而函數中的變量會存儲在新開闢出來的內存中。函數中的變量只能在函數的內部使用，而且會隨着函數執行完畢，這塊內存中的全部內容也會被清空。

咱們給這個「存放名字與值的關係」的空間起了一個名字——叫作命名空間

代碼在運行伊始，建立的存儲「變量名與值的關係」的空間叫作全局命名空間，在函數的運行中開闢的臨時的空間叫作局部命名空間

 

命名空間 有三種

#內置命名空間 —— python解釋器
    # 就是python解釋器一啓動就可使用的名字存儲在內置命名空間中
    # 內置的名字在啓動解釋器的時候被加載進內存裏
#全局命名空間 —— 咱們寫的代碼但不是函數中的代碼
    # 是在程序從上到下被執行的過程當中依次加載進內存的
    # 放置了咱們設置的全部變量名和函數名
#局部命名空間 —— 函數
    # 就是函數內部定義的名字
    # 當調用函數的時候 纔會產生這個名稱空間 隨着函數執行的結束 這個命名空間就又消失了

#在局部:可使用全局、內置命名空間中的名字
#在全局:可使用內置命名空間中的名字，可是不能用局部中使用
#在內置:不能使用局部和全局的名字的

做用域

做用域就是做用範圍，按照生效範圍能夠分爲全局做用域和局部做用域。

全局做用域：包含內置名稱空間、全局名稱空間，在整個文件的任意位置都能被引用、全局有效

局部做用域：局部名稱空間，只能在局部範圍內生效

# def sum(a,b):
#     print(a if a>b else b)
# sum(1,2)

# def input():
#     print(1)
# def func():
#     input = 1
#     print(input)
# func()


# globals和locals方法
# c = 10
# d = 13
# def func():
#     a=12
#     g = 23
#     f = 88
#     b = 13
#     print(locals())
#     # print(globals())
# func()
#print(locals())#globals 永遠打印全局的名字
#print(globals())#locals 輸出什麼 根據locals所在的位置

#global關鍵字
# a = 10
# def func():
#     global a
#     a = 12
#
# print(a)
# func()
# print(a)

# global a
# a = 10
# def func():
#     # a = 12
#     print(a)
#
#
# print(a)
# func()
# print(a)

View Code

7.不經過global 在局部做用域修改全局變量

a = 10
def func():
    a = 20
    return a
a = func()
print(a)

View Code

8.函數的嵌套和做用域鏈

#函數的嵌套調用
# def max2(x,y):
#     m = x if x>y else y
#     return m
# def max4(x,y,z,w):
#     c = max2(x,y)
#     d = max2(z,w)
#     return max(c,d)
# print(max4(1,5,3,4))

#函數的嵌套定義

# def f1():
#     print(1)
#     def f2():
#         print(2)
#     f2()
# f1()
#函數的做用域鏈
# def f1():
#     a = 1
#     def f2():
#         global a#只修改了全局變量，上面的局部變量沒有修改
#         a = 2
#         print(a)
#     f2()
#     print(a)
# f1()
# print(a)

#nonlocal關鍵字和global的區別
#nonlocal 只能用於局部變量 找上層中離當前函數最近一層的局部變量
#聲明瞭nonlocal的內部函數的變量修改會影響到 離當前函數最近一層的局部變量
# 對全局無效
# 對局部 也只是對 最近的 一層 有影響
# a=1
# def f1():
#     a = 1
#     def f2():
#         nonlocal a#只修改了全局變量，上面的局部變量沒有修改
#         a = 2
#         print(a)
#     f2()
#     print(a)
# f1()
# print(a)

View Code

9.函數名的本質

#函數名的本質
#函數名本質上就是函數的內存地址
#1.能夠被引用
# def func():
#     print(1)
# f = func
# print(f)
#2.能夠被看成容器類型的元素
# def f1():
#     print('f1')
# def f2():
#     print(f2)
# def f3():
#     print(f3)
# l = [f1,f2,f3]
# l[0]()
#3.能夠看成函數的參數和返回值
#就當普通變量用

def func():
    print(123)
def wahaha(f):
    f()
    return f           #函數名能夠做爲函數的返回值
qqxing = wahaha(func)   # 函數名能夠做爲函數的參數
qqxing()

View Code

10.閉包

閉包函數：

內部函數包含對外部做用域而非全劇做用域名字的引用，該內部函數稱爲閉包函數
#函數內部定義的函數稱爲內部函數

 

因爲有了做用域的關係，咱們就不能拿到函數內部的變量和函數了。若是咱們就是想拿怎麼辦呢？返回呀！

咱們都知道函數內的變量咱們要想在函數外部用，能夠直接返回這個變量，那麼若是咱們想在函數外部調用函數內部的函數呢？

是否是直接就把這個函數的名字返回就行了？

# name = 'chun'
# def func():
#     name = 'shang'
#     def inner():
#         print(name)
#     # inner()
# func()

# def func():
#     name = 'shang'
#     def inner():
#         print(name)
#     return inner
# f = func()
# f()

#判斷閉包函數的方法__closure__

#輸出的__closure__有cell元素 ：是閉包函數
# def func():
#     name = 'shang'
#     def inner():
#         print(name)
#     print(inner.__closure__)
#     return inner
# f = func()
# f()
#輸出的__closure__爲None ：不是閉包函數
#
name = 'shang'
# def func():
#
#     def inner():
#         print(name)
#     print(inner.__closure__)
#     return inner
# f = func()
# f()
#閉包嵌套
# def wrapper():
#     money = 1000
#     def func():
#         name = 'eva'
#         def inner():
#             print(name,money)
#         return inner
#     return func
#
# f = wrapper()
# i = f()
# i()

#閉包函數獲取網絡應用
from urllib.request import urlopen

def index():
    url = "http://www.xiaohua100.cn/indexhtml"
    def get():
        return urlopen(url).read()
    return get
xiaohua = index()
content = xiaohua()
print(content)

View Code