python涂鸦

【exit】

退出程序   

【%】

占位符：%s 【string】  %f【float】  %d【int】    isdigit：长得像数字

【print不换行】

python 2.X 版本使用逗号分割可以使print不换行    【print "hello",】

python 3.X版本利用end方法可以使print不换行   【print ("hello ",end="")】

 

【】
for x in y （遍历所有的y元素）

【dict字典】

访问dict列表                 d = {
                                            'Adam': 95,
                                            'Lisa': 85,
                                            'Bart': 59
                                             }
                                            for a in d:
                                            print (a,d.get(a))

get（key值） 更新 d['Paul'] = 72

【增】

dict【元素】=***     元素有就修改，没有就添加

dict.setdefault('','')     键存在就不改动，返回相应的值，键不存在，增加新的键值对，并返回相应的值

【删】

del dict（元素） 删除键值对    pop（元素） 删除返回值       popitem()   随机删除一个键值对      clear（） 清空    del dict  删除字典

【查】

dict.key() 键       .value() 值    .Iteme()键值对        in()   查询是否存在值

【改】

dict.update(dict1)   有就更新，没有添加

 

【set列表】

set列表是无序排列的（可以包含前边所有的列表的格式）

set.remove（删除）
set.add（添加）

【len（计算属性的长度）】

 

【list切片】

print L[4:50:5]#从索引4开始，每个5位取一个，取到索引50结束，50索引不包含

 

【索引迭代】

enumerate（集合） dict迭代value【itervalue（）or value（）】

dict迭代key，value【item（）or iteritems（）】

 

【range（）随机数】

range（1,100，2） {1,3,5,7，。。。}

 

【编写函数：def】

【列表生成式for 可以添加筛选条件，可以添加多层嵌套循环】

return [x.upper() for x in L if isinstance(x,str)]

isinstance（）判断是否是字符串 upper（）字母大写

 

【对list进行增删改】

 

append（默认添加到末尾）        insert（index，“”） 添加到那个索引       list.extend(list1)      将两个列表合成一个

remove（“”）  直接删除那个元素      b= pop（1，“””） 删除那个索引值的元素，可以将这个元素取出        del  什么都能删除，包括这个对象     .clear  清空

 

【对list进行查询】

list.count(元素)      查找列表中同一元素的个数

list.index（元素）   查找列表的的元素索引值

【sort】

没有返回值

数字按照从小到大排序，字符按照Ascll排序

【reverse】

list 反序摆列

 

【enumerate】

一个可以添加索引值的方法      enumerate（list,1）  

 

【字符串拼接】

‘’.join（【a，b，c】）

center(50，''） 

 

【endswith() / startswith】   以什么开头/结尾       【find】 查找元素返回索引值     【isdigit】判断是否是数字  【islower/ isupper】  判断是否全大写/ 小写

【strip】 删除左右的空格，换行符      【replace】 替换            【split】  分割符      【expandtabs】 制作表格

【format】 格式化输出 

 

【文件】

【open() 】  打开文件        【read（）】   读取文件    【 write（）】 写入文件      【 tell() 】 获取光标的位置      【seek（）】 移动光标       

【flush】   刷新缓存区，立即写入磁盘          【truncate（）】  数据截断   “w” 没有太大意义  “a”   可按要求截断

 

【*******函数*******】

【默认参数】    默认函数一般放在参数的最后

def  f（name，age=12）

f("Tom")

 

【不定参数（没有命名）】                                         【不定参数（有命令）】

def   f（*args）                                                           def f （**args）

f(1,2,3,4)     　　　　　　　　　　　　　　　　　　f(name=“Tom”，age=12)

运行后会生成一个元组　　　　　　　　　　　　　　运行后会生成一个字典

补充参数：

def a(*args):
    print args
a(*[1,2,3,4])  #####单个添加到元组####

def b(**kwargs):
    print kwargs
b(**{"name":"aa"}) ######键值对方式添加到字典####

 

 

【return】

1 结束某个函数   2返回一个对象    3返回多个对象默认放在一个元组中

【作用域】

built_in(系统)                   global(全局)               enclosing(嵌套)                lical(本地)

count = 10
def out():
    global count    ##申明全局变量
    print count
    count = 5   ##局部不能修改全局的变量
out()

 

【高阶函数】

def f(n):
    return n*n
def foo(a,b,fn):
    return fn(a)+fn(b)  ####fn()就是运行这个f()函数######
print foo(1,2,f)  ######f就是一个函数的内存地址######

def f():
    return 8
def fun():
    return f
ter=fun()     #####只是得到f函数的内存地址######
print ter
print ter()   ####只要加上括号就代表运行这个函数，所以就是运行f()这个函数

 

 【递归函数】

调用自己的函数方法  + 结束条件

阶乘：

def f(n):
    if n==1:
        return 1
    return n*f(n-1)   #####调用自己，结束条件
print f(7)

print reduce(lambda a,b:a*b ,range(1,8))


运行结果：
5040

斐波那契数列：（没大搞懂）

0,1,1,2,3,5,8,13.。。。。。。

def f(n):
    if n<=2:
        return n
    return f(n-1)+f(n-2)

print f(5)


运行结果：
8

 

 【内置函数】

几个重要的内置函数 ：

filter（可以用于筛选【迭代器】）          　　map（可以用于给原来的元素添加）  　　　　reduce（返回的是一个具体的值）　　　　lambda（匿名函数）

#filter
str = ["a","b","c","d","e"]
def func(s):
    #print s
    if s !="a":
        return s
let = filter(func,str)
print list(let)

#map
str = [ 'a', 'b']
def fun2(s):
    return s + "alvin"
ret = map(fun2, str)
print(ret)  # map object的迭代器
print(list(ret))  # ['aalvin', 'balvin', 'calvin', 'dalvin']

#reduce
from functools import reduce
def add1(x, y):
    return x + y
print (reduce(add1, range(1, 101)))  ## 5050 （注：1+2+...+100）
print (reduce(add1, range(1, 101), 20))  ## 5070 （注：1+2+...+100+20）

#lambda
#普通函数
def add(a, b):
    return a + b
print add(2, 3)
# 匿名函数
add = lambda a, b: a + b
print add(2, 3)



运行结果：
['b', 'c', 'd', 'e']
['aalvin', 'balvin']
['aalvin', 'balvin']
5050
5070
5
5

 

【装饰器函数】

闭包定义：1 有内部函数   2 引用外部函数的值     3 return函数名

示:1：

import time
def show_time(f):
    def out(*x,**y):
        start = time.time()
        f(*x,**y)
        end = time.time()
        print "spend time:%s"%(end-start)
    return out
@show_time    # f=show_time(f)
def f(*a,**b):
    sums=0
    for i in a:
        sums+=i
    print sums
    time.sleep(1)
f(1,2,7,4)
    #遵守开放，封闭的原则，在不修改原来的代码的基础上添加要求，调用的时候重新赋值相当于调用原来的函数，  不会影响其他对该函数的调用


运行结果：
14
spend time:1.0

示例2：

import time
def log(flag):
    def show_time(f):            #2.show_time（f，flag）
        def out(*x,**y):
            start = time.time()
            f(*x,**y)
            end = time.time()
            run = end-start
            print "spend time:%s"%(run)
            if flag=="True":
                with open("text","a") as ji:
                    ji.write("\nspend time:%s"%(run))
        return out
    return show_time
@log("True")    # 1.@封装的只能传一个参数，只要满足闭包的定义就能运行，返回值show_time，就相当于@show_time，
def f(*a,**b):    #2，不用@多加一个参数也可以
    sums=0
    for i in a:
        sums+=i
    print sums
    time.sleep(1)
f(1,2,7,4)



运行结果：
14
spend time:1.0

文本内容请自行查看

 

【模块】

【time（时间）】

time.time（）当前时间戳 　　　　time.strftime()   可以自定义格式  【time.time(%Y-%m-%d %X,time.localtime)】 　　　　time.localtime()本地时间

time.ctime()   当地固定时间 （Tm_Year=2018的格式）　　　　time.mktime()   转化为时间戳

【datetime】

datetime.datetime.now（）

【random】

random（）0-1随机数　　　　randint（）整数随机数包含最后一个　　　　choice（）随机选择　　　　shuffle（） 

randrange（）不包含最后一个