Python全棧-第十一課學習筆記

時間 2020-06-05

原文原文鏈接

Python第十一課學習筆記

補充和global nonlocal

補充python
默認參數的陷阱app

# 默認參數的陷阱：
def func(name,sex='男'):
	print(name)
	print(sex)
func('jarvis')

# 陷阱只針對於默認參數是可變的數據類型：
def func(name,alist=[]):
	alist.append(name)
	return alist

ret1 = func('one')
print(ret1,id(ret1))  # ['one']
ret2 = func('two')
print(ret2,id(ret2))  # ['one','two']

# 若是你的默認參數指向的是可變的數據類型，那麼你不管調用多少次這個默認參數，都是同一個。
def func(a, list=[]):
	list.append(a)
	return list
print(func(10,))  	# [10]
print(func(20,[]))  # [20]
print(func(100,))  	# [10,100]

def func(a, list= []):
	list.append(a)
	return list
ret1 = func(10,)  	# ret1 = [10]
ret2 = func(20,[])  # ret2 = [20]
ret3 = func(100,)  	# ret3 = [10,100]
print(ret1)  		# [10,100]  re1和re3使用的同一個列表
print(ret2)  		# [20]
print(ret3)  		# [10,100]

局部做用域的坑函數

count = 1
def func():
	count += 1
	print(count)
func()

# 函數中，若是你定義了一個變量，可是在定義這個變量以前對其引用了，那麼解釋器認爲：語法問題（先引用後定義）
# 你應該在使用以前先定義。
count = 1
def func():
	print(count)
	count = 3
func()

global nonlocal工具

# global
# 在局部做用域聲明一個全局變量。
name = 'jarvis'

def func():
    global name
    name = 'one'
    print(name)
func()
print(name)

# 修改一個全局變量
count = 1
def func():
    global count
    count += 1
    
print(count)   
func()
print(count)

# nonlocal
# 不可以操做全局變量。
count = 1
def func():
    nonlocal count
    count += 1
func()				#報錯
# 局部做用域：內層函數對外層函數的局部變量進行修改。
def wrapper():
    count = 1
    def inner():
        nonlocal count
        count += 1
    print(count)
    inner()
    print(count)
wrapper()

函數名的運用

# 函數名 + ()就能夠執行此函數。
def func():
	print(666)

func()
# 函數名指向的是函數的內存地址。
a = 1
a()
func() 					#報錯

def func():
	print(666)

print(func,type(func))  # <function func at 0x000001BA864E1D08>
func()

# 函數名就是變量
def func():
	print(666)

f = func
f1 = f
f2 = f1

f()
func()
f1()
f2()

def func():
	print('in func')

def func1():
	print('in func1')

func1 = func
func1()

# 函數名能夠做爲容器類數據類型的元素
def func1():
	print('in func1')

def func2():
	print('in func2')

def func3():
	print('in func3')

l1 = [func1,func2,func3]
for i in l1:
	i()

# 函數名能夠做爲函數的參數
def func():
	print('in func')

def func1(x):
	x()  				# func()
	print('in func1')

func1(func)

# 函數名能夠做爲函數的返回值
def func():
    print('in func')

def func1(x): 			# x = func
    print('in func1')
    return x

ret = func1(func)  		# func
ret()  					# func()

新特性：格式化輸出

格式化輸出學習

# %s format
name = 'jarvis'
age = 18
msg = '我叫%s,今年%s' %(name,age)
msg1 = '我叫{},今年{}'.format(name,age)

# 新特性：格式化輸出
name = 'jarvis'
age = 18
msg = f'我叫{name},今年{age}'
print(msg)

# 能夠加表達式
dic = {'name':'jarvis','age': 18}
msg = f'我叫{dic["name"]},今年{dic["age"]}'
print(msg)

count = 7
print(f'最終結果：{count**2}')
name = 'jarvis'
msg = f'個人名字是{name.upper()}'
print(msg)

# 結合函數寫：
def _sum(a,b):
    return a + b

msg = f'最終的結果是：{_sum(10,20)}'
print(msg)
# ! , : { } ;這些標點不能出如今{}這裏面
# 優勢
# 結構更加簡化
# 能夠結合表達式，函數進行使用
# 效率提高不少

迭代器

可迭代對象code
- 字面意思：對象：python中一切皆對象。一個實實在在存在的值，對象。
- 可迭代：更新迭代。重複的，循環的一個過程，更新迭代每次都有新的內容，能夠進行循環更新的一個實實在在的值。
- 專業角度：可迭代對象：內部含有'__iter__'方法的對象，可迭代對象。
- 目前學過的可迭代對象：str list tuple dict set range 文件句柄
獲取對象的全部方法而且以字符串的形式表現：dir()orm

判斷一個對象是不是可迭代對象對象

s1 = 'fjdskl'
l1 = [1,2,3]
print(dir(s1))
print(dir((l1)))
print('__iter__' in dir(s1))
print('__iter__' in dir(range(10)))

可迭代對象小結索引
- 字面意思：能夠進行循環更新的一個實實在在的值。內存
- 專業角度：內部含有'__iter__'方法的對象，可迭代對象。
- 判斷一個對象是否是可迭代對象： '__iter__' in dir(對象)
- str list tuple dict set range
- 優勢：
  - 存儲的數據直接能顯示，比較直觀
  - 擁有的方法比較多，操做方便
- 缺點：
  - 佔用內存
  - 不能直接經過for循環，不能直接取值（索引，key）
迭代器的定義
- 字面意思：更新迭代，器：工具：可更新迭代的工具。
- 專業角度：內部含有'__iter__'方法而且含有'__next__'方法的對象就是迭代器。
- 能夠判斷是不是迭代器：'__iter__' and '__next__' 在不在dir(對象)

判斷一個對象是不是迭代器

with open('文件1',encoding='utf-8',mode='w') as f1:
    print(('__iter__' in dir(f1)) and ('__next__' in dir(f1)))

迭代器的取值

#可迭代對象能夠轉化成迭代器
s1 = 'fjdag'
obj = iter(s1)  	# s1.__iter__()
print(obj)
print(next(obj)) 	# print(obj.__next__())
print(next(obj)) 	# print(obj.__next__())
print(next(obj)) 	# print(obj.__next__())
print(next(obj)) 	# print(obj.__next__())
print(next(obj)) 	# print(obj.__next__())
#多一個就會報錯

l1 = [11,22,33,44,55,66]
obj = iter(l1)
print(next(obj))
print(next(obj))
print(next(obj))
print(next(obj))
print(next(obj))
print(next(obj))

可迭代對象如何轉化成迭代器

iter([1,2,3])

while循環模擬for循環機制

l1 = [11,22,33,44,55,66,77,88,99,1111,1133,15652]
# 將可迭代對象轉化成迭代器。
obj = iter(l1)
while 1:
    try:
        print(next(obj))
    except StopIteration:
        break

小結
- 字面意思：更新迭代，器：工具：可更新迭代的工具。
- 專業角度：內部含有'__iter__'方法而且含有'__next__'方法的對象就是迭代器。
- 優勢：
  - 節省內存
  - 惰性機制，next一次，取一個值
- 缺點：
  - 速度慢
  - 不走回頭路
可迭代對象與迭代器的對比
可迭代對象
- 可迭代對象是一個操做方法比較多，比較直觀，存儲數據相對少（幾百萬個對象，8G內存是能夠承受的）的一個數據集。
- 當你側重於對於數據能夠靈活處理，而且內存空間足夠，將數據集設置爲可迭代對象是明確的選擇。