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)