Python函數模板

插一哈~

#1.生成一個隨機int類型數
import random
print(random.__file__) #每個模塊都有的一個內置屬性可以查看模塊的完整路徑
rand = random.randint(0,10)
print(rand)
print()
#2.
varstr = "all for %s, all for %s" %("music","kun")
print(varstr)
#3.打印分隔線
print（“-”*50）#50個-

 

#namelist=["w","erf","ef","ewr"]
#print("我",len(namelist),"是")
#a,b=b,a+b //a=b b=a(原值)+b 

 

 

#收集參數 不定長參數 就是當參數自己也不知道要傳多少的時候就形參這么表示就好

def test(*vary):
    print("參數的長度是:",len(vary))
    print("第三個參數是:",vary[2])

test(123,'ccd',[1,2,3,4],'23546')

print()#輸出時空了一格
def test2(*vary,exp):
    print("exp這個參數是:",exp)
    print("收集參數的第二個參數是:",vary[1])

test2(23,"hello",[1,2,3,4],"it's you",exp="EXP")

#為了不搞混自己特定的想傳的參數(exp)麻煩再用收集參數的時候也要加上關鍵字參數哦,關鍵字參數再傳時要放在末尾
#或者搞成默認參數 直接在形參那里規定好exp="EXP",傳參的時候直接EXP就好

print()
def test2(*vary,exp="EXP"):
    print("exp這個參數是:",exp)
    print("收集參數的第二個參數是:",vary[1])

test2(23,"hello",[1,2,3,4],"it's you","EXP")

>>> def hello():
    print("hello world")    
>>> temp = hello()
hello world
>>> temp
>>> print(temp)
None
>>> type(temp)
<class 'NoneType'>
>>> #就算無return語句Python還是會返回東西的函數要么返回return要么返回none
>>> 

 

返回多個值
>>> def back():
    return 1,'one',3.1414

>>> back()
(1, 'one', 3.1414)
>>> 

 

全局變量是可以直接在函數里應用並且輸出的，但是一當你在函數里修改了全局變量，你會發現在函數體外輸出這個變量和在函數里輸出的值是不一樣的，
因為一旦你修改了全局變量，就在會函數里臨時申請一個同名的局部變量，函數里修改，修改的是那個局部變量
(仔細想一哈。。還是沒有變化的，因為pyhon是沒有變量聲明語句的呀所以emm~)
#如果你非想在函數里修改全局變量的值

count = 5
def MyFun():
    global count
    count=10
    print('aaa')

print(count)#輸出5
print()
MyFun()
print(count)#在調用了函數后 輸出10

 

#內嵌函數
def fun1():
    print("這里是fun1函數")
    def fun2():
        print("這里是fun2函數")
    fun2()#!沒這句話fun2不可能輸出的

fun1()
#並且出了fun1的地盤就無法再調用fun2函數了
、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、
#函數 閉包fun2函數就是個閉包 同理不可在fun1外的地盤使用
def fun1(x):
    def fun2(y):
        return x*y
    return fun2 #由於Pyhon萬物皆對象所以這里就這么寫就好

result = fun1(8)(5)#!!!!方式
print(result)
、、、、、、、、、、、、、、、、、、、

 

count = 5
def text():
    count=count+1
    print(count)

text()
#報錯 因為此時你在修改全局變量count就申請了一個新的臨時變量但是直接++並沒有初始值
所以:
def fun1():
    x = 5
    def fun2():
        nonlocal x#!!!為了能用 強硬申請不是局部變量
        x*=x
        return x
    return fun2()#!這里要加()的呀

print(fun1())

 

#在lambda表達式 冒號前面是原函數的參數冒號后面是原函數的返回值
def ds(x):
    return 2*x+1

print(ds(5))
print()
g = lambda x:2*x+2
print(g(5))
##############兩個參數
def add(x,y):
    return x+y
print(add(1,2))

g = lambda x,y:x+y
print(g(1,2))

 

、、、、、、、、、、、、、、、、、、
#filter過濾器就是把任何非true的東西過濾掉
list1 = list(filter(None,[0,1,True,False]))#首參數是None或者funcion(自己想篩啥)
print(list1)
#輸出:[1, True]
print()
def odd(x):
    return x%2 #找奇數

temp = range(10)
show=filter(odd,temp) #這里函數只寫函數名就好不用加()
#此時show是一個對象 可以用list表達的
print(list(show)) #輸出[1, 3, 5, 7, 9]

#用lambda 實現
print(list(filter(lambda x:x%2,range(10))))
、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、
#map過濾器 參數仍然是函數和可迭代序列
#序列的每一個元素作為函數的參數運算加工，直到可迭代序列元素加工完畢，返回新序列
print(list(map(lambda x:2*x,range(10))))
#輸出[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

#bif也就是內置函數 Pyhon有兩個自帶的bif iter()和next()
#對一個容器對象用iter就得到其迭代器
#調用next 迭代器就會返回下一個值
#提供迭代方法的容器叫做迭代器:列表元組字符串字典等等(這幾個都是容器對象)

for i in "ilovekk":
    print(i)
print()
directions = {"菜":'c',\
              '徐':'x',\
              '坤':'k'}
for each in directions:
    print("%s -> %s" %(each,directions[each]))
print()
string = "ilove菜菜"
it = iter(string)#it是一個迭代器了(獲得字符串容器的迭代器)
print(next(it))#i
print(next(it))#l
print(next(it))#o
print(next(it))#v
print(next(it))#e
print(next(it))#菜
print(next(it))#菜
print(next(it))#迭代器沒有東西可以返回了 彈出stopiteration
print()
string = 'fishc'
it = iter(string)
while True:
    try:
        each = next(it)
    except StopIteration:
        break
    print(each)

#生成器則是在普通的函數里加個yield語句
#使得python模仿協同程序(函數可以暫停或者掛起並在需要的時候從程序離開的地方繼續或者重新開始)得以實現

>>> def mygun():
    print("生成器被執行")
    yield 1
    yield 2
    #yield語句一加，表明函數為生成器，yield相當於return 只是yield會返回后面的參數，並且暫停在這個位置 下次從下一局開始    
>>> myg = mygun()
>>> next(myg)
生成器被執行
1
>>> next(myg)
2
>>> next(myg)
Traceback (most recent call last):
  File "<pyshell#9>", line 1, in <module>
    next(myg)
StopIteration
>>> 
>>> for i in mygun():
    print(i)    
生成器被執行
1
2
>>> def libs():
    a = 0
    b = 1
    while True:#看起來是個死循環因為一直是true但是這是個生成器隨時可以中斷掛起並且你一次執行到底了下一次在執行函數時肯定可以執行啊就從頭開始唄
        a,b=b,a+b
        yield a

>>> for each in libs():
    if each > 100:
        break;
    else:
        print(each, end=" ")

        
1 1 2 3 5 8 13 21 34 55 89 

#導入模塊
#1. import 模塊名 不用加后綴名.py/調用模塊里的函數時要加上模塊前綴 text.fun()
#2. from 模塊名 import 函數名 函數名就可不用帶括號即使函數有參要傳遞 並且調用時不必加模塊名
#3. from 模塊名 import *通配符  使用時不需要帶模板名 導入里面所有的命名空間/不建議
#4. import 模塊名 as 新名字 自然，調用模板函數的時候要帶上這個新名字來作為前綴 並且駝峰命名法
作用:封裝代碼

 

>因為在導入文件時(文件此時作為模板 文件中任何沒有縮進的代碼都會在主程序里執行，無論你是否用沒用模板)

>#如果主程序里使用__name__變量 得到的是'__main__' 模板里這樣測試得到的是'__模板名__' 通過 if __name=='__main__'
>#可以判斷出是主程序還是模板 再決定要不要運行或者測試
>>> import sys
>>> sys.path
['E:\\Temp\\TxGameDownload\\Python', 'D:\\Python\\Lib\\idlelib', 'D:\\Python\\python37.zip', 'D:\\Python\\DLLs', 'D:\\Python\\lib', 'D:\\Python', 'C:\\Users\\夢\\AppData\\Roaming\\Python\\Python37\\site-packages', 'D:\\Python\\lib\\site-packages']
>>> 系統的搜索路徑 出來的結果顯示為是一個列表 所以當然可以增加路徑
sys.path.append("E:\\python\\test")導入了此文件夾
導入包： 包名.模塊名

 

os模塊 是對系統進行操作operation system   對文件！目錄！來的 所以你madir("abc") 新建的是名字叫abc的文件夾 就算mkdir("abc.txt") 也是新建文件夾 名字叫abc.txt     

 

'''遞歸
def quicksort(array):
    ''快排''
    less = []
    more = []
    if len(array)<=1:
        return array
    p=array.pop()
    for x in array:
        if x>p:
            more.append(x)
        else:
            less.append(x)

    return quicksort(less)+[p]+quicksort(more)
array1 = [21,32,42,53,34,25,57,54,78,89]
print(quicksort(array1))
'''
'''
def mergesort(list1):
    if len(list1) <=1:
        return list1
    mid = int(len(list1)/2)
    left = mergesort(list1[0:mid])
    right = mergesort(list1[mid:len(list1)])
    return merge(left,right)
def merge(l,r):
    c = []
    i,j=0,0
    while j<len(l) and i<len[r]:
        if l[j] >= r[i]:
            c.append(r[i])
            i = i+1
        else:
            c.append(l[j])
            j = j+1
    for i in (l[j:] if i == len(r) else r[i:]):
        c.append(i)

    return c


list2 = [-4,0,82,3,56,19,-21,1]
print(mergesort(list2))'''

#斐波那契數列F(1)=1，F(2)=1, F(n)=F(n-1)+F(n-2)（n>=3，n∈N*）

 

生成器 yield
#生成器遇到yield人家就是會返回后面跟着的值哈
'''
例子一
def yield_test(n):  
    for i in range(n):  
        yield call(i)  
        print("i=",i)
        print()
    print("Done.")  
  
def call(i):  
    return i*2  
  
for i in yield_test(5):
    print("每一個過程最先執行這里")
    print(i,",")
'''
'''例子二
def fib(n):
    a,b,counter=0,1,0
    while True:
        if(counter>n):
            return
        yield a
        a,b=b,a+b
        counter+=1
f=fib(15)
i=0
while i<15:
    print(next(f))
    i=i+1
'''

 

import time #時間模板
import calendar #日歷模板
import math  #math.pi直接就是圓周率 要引入模板


print(round(2.234,2)) #第一個參數是數字 中間用,分開


#format的格式化 前面是字符串''""均可 變量用{}包裹  再.format(里面是""和,)
#數字是從0開始  如果指定變量名的話前后都要有 變量名不用加''
#print('{},{}和{}'.format('','',''))
print('{}:"{}"!'.format('hello','python'))
print('{0}和{1}'.format("apple","google"))
print('{1}和{0}'.format("apple","google"))
print('{name}網址:{site}'.format(name='baidu',site='baidu.com'))
print('網站{0},{1},和{other}.'.format("baidu.com",'meitu',other="taobao"))
print('PI的值近似為{0:.2f}'.format(math.pi))
print()

tables = {"baidu":1,"meituan":2,"taobao":3}
for name,number in tables.items():
    print('{0:8}------>{1:3d}'.format(name,number))
#解釋print {0:8}8是指輸出寬度默認左靠齊 0則是這個字典的0號-鍵 1則是指對
#3.1的話 3是寬度 1是精度 當寬度小於字符長度時 字符照樣全部輸出
print("常量PI的值近似為:%10.2f" %math.pi) #位數10又靠齊 2是精度
#repr 返回string格式
print(repr('hello python.'))
x=13 * 3.25
s= 'x:'+repr(x)+'||||'
print(s)
print()
ticks=time.time()
print("當前時間戳為:",ticks)
print()

cal = calendar.month(2019,6)
print(cal)