python学习笔记(三)

  内联式css样式,直接写在存活的HTML标签中
CSS样式能够写在哪些地方呢?从CSS
样式代码插入的款式来看基本能够分成以下三种:内联式、嵌入式和外部式三种。
  内联式css样式表便是把css代码直接写在现有的HTML标签中,如下面代码:
    <p style=”color:red”>那里文字是新民主主义革命。</p>
  嵌入式css样式,写在最近的文件中
嵌入式css样式,正是足以把css样式代码写在<style
type=”text/css”></style>标签之间。如上面代码达成把三个<span>标签中的文字设置为革命:
    <style
type=”text/css”>
span{
color:red;
}
</style>
嵌入式css样式必须写在<style></style>之间,并且壹般景观下嵌入式css样式写在<head></head>之间。
  外部式css样式,写在单身的1个文本中
外部式css样式(也可称为外联式)正是把css代码写五个单独的外表文件中,那一个css样式文件以“.css”为扩展名,在<head>内
(不是在<style>标签内)使用<link>标签将css样式文件链接到HTML文件内,如下边代码:
    <link href=”base.css” rel=”stylesheet” type=”text/css”
/>
  注意:
    一、css样式文件名称以有意义的英文字母命名,如 main.css。
    二、rel=”stylesheet” type=”text/css” 是确定地点写法不可修改。
    叁、<link>标签地点一般写在<head>标签之内。

    
叁.生成器只记录当前职分,唯有3个next方法它不了解前面和前边,前边用完了就没了,不能够往回调用。每一遍只保留一个值。

 

伍、软件目录结构正式

      2、能够使用类选拔器词列表方法为七个要素同时设置多少个样式。大家得以为1个元素同时设几个样式,但只好够用类选取器的主意达成,ID采取器是不能的(不可能采取ID 词列表)。

    子选择器
还有一个相比可行的挑3拣4器子选拔器,即当先标志(>),用于选用钦命标签成分的第壹代子成分。如:
      .food>li{border:1px solid
red;}
那行代码会使class名称叫food下的子元素li(水果、蔬菜)参加浅紫蓝实线边框。
    包括(后代)接纳器
包括选拔器,即进入空格,用于采取钦定标签成分下的晚辈成分。如:
      .first
span{color:red;}
这行代码会使第三段文字内容中的“胆小如鼠”字体颜色变为绿色。
    请留心这么些选用器与子选用器的区分,子采用器(child
selector)仅是指它的一贯后代,或然你能够明白为遵守于子成分的率先代子孙。而后人选取器是功能于全部子后代成分。后代选用器通过空格来进展精选,而子选取器是经过“>”举行选拔。
    总括:>效用于成分的第1代子孙,空格功能于成分的具备后代。
    通用采用器
通用选取器是效益最强劲的选取器,它应用三个(*)号钦赐,它的效果是相称html中有着标签成分,如下使用上边代码应用html中自由标签成分字体颜色全部安装为红色:*
{color:red;}
    伪类采取符
更幽默的是伪类选取符,为何叫做伪类选拔符,它同意给html不设有的竹签(标签的某种境况)设置样式,比如说我们给html中三个标签成分的鼠标滑过的意况来设置字体颜色:a:hover{color:red;}
上边一行代码就是为
a 标签鼠标滑过的场所设置字体颜色变红。
    关于伪选取符:
      关于伪类采纳符,到目前甘休,能够相配全部浏鉴器的“伪类接纳符”正是a 标签上行使 :hover 了(其实伪类选取符还有众多,尤其是 css三中,不过因为不可能协作全数浏览器)。其实 :hover
能够置身任意的价签上,比如说
p:hover,可是它们的包容性也是很倒霉的,所以今后相比较常用的也许 a:hover
的结缘。
    分组选取符
当你想为html中多少个标签成分设置同叁个样式时,能够行使分组选用符(,),如下代码为右边代码编辑器中的h壹、span标签同时设置字体颜色为深黄:
      h一,span{color:red;}
它一定于上面两行代码:
      h1{color:red;}
span{color:red;}

    实现装饰器的学识储备:

    类和ID采用器的区分:
      相同点:能够利用于任何因素
分化点:
      1、ID选拔器只幸而文书档案中选用3次。与类选用器不一样,在3个HTML文书档案中,ID选用器只好选拔3遍,而且仅一遍。而类采纳器能够应用频繁。


4、Json与pickle数据种类化

第六章 CSS选择器

          图片 1

 

        凡是可效果于
next()函数的对象都以Iterator类型,它们表示一个惰性总结的队列:

  什么是选取器?
每一条css样式表明(定义)由两有个别构成,格局如下:
    选用器{
样式;
}
在{}从前的有个别正是“采取器”,“接纳器”指明了{}中的“样式”的功效对象,也正是“样式”成效于网页中的哪些要素。
    标签选拔器

标签选取器其实就是html代码中的标签。例如下边代码:p{font-size:12px;line-height:1.陆em;}
上边的css样式代码的功用:为p标签设置12px字号,行间距设置1.6em的体制。
    类选拔器
 类选拔器在css样式编码中是最常用到的。
      语法:
        .类选器名称{css样式代码;}
注意:壹、英文圆点起首
                        二、当中类选器名称能够随便起名(但绝不起汉语噢)
      使用办法:
        第2步:使用合适的价签把要修饰的剧情标记起来,如下:<span>胆小如鼠</span>

    打字与印刷结果:

  二种形式的先期级
有的年青人伴问了,如果有一种情况:对于同贰个要素我们还要用了二种艺术设置css样式,那么哪种形式真的有效呢?记住他们的预先级:内联式
> 嵌入式 > 外部式
而是嵌入式>外部式有3个前提:嵌入式css样式的岗位一定在外部式的背后。如右代码编辑器正是那般,<link
href=”style.css” …>代码在<style
type=”text/css”>…</style>代码的前头(实际支付中也是如此写的)。
  其实总结来说,正是–就近原则(离被安装成分越近优先级别越高)。
  但注意上边所计算的优先级是有贰个前提:内联式、嵌入式、外部式样式表中css样式是在的相同权值的境况下。
 

      打印结果:

        第贰步:设置类选器css样式,如下:.stress{color:red;}/*类前边要投入七个英文圆点*/
    ID选取器
在不少位置,ID接纳器都接近于类选拔符,但也有一部分至关心重视要的区别:
      1、为标签设置id=”ID名称”,而不是class=”类名称”。
      二、ID选取符的前头是井号(#)号,而不是英文圆点(.)。

          图片 2

        第1步:使用class=”类选拔器名称”为标签设置一个类,如下:<span
class=”stress”>胆小如鼠</span>


print(fib(10)) #返回地址
f = fib(10)
print(f.__next__())
print(f.__next__())
print(f.__next__())

第四章 CSS样式基本知识

t = (b,a+b) #t是一个tuple
a = t[0]
b = t[1]

        
把list,dict,str等Iterable变成Iterator能够运用iter()函数:

      图片 3

三、内置方法详解

一、装饰器

一、装饰器

4、杰森与pickle数据连串化

    打印结果:

 

    图片 4

  原则:1.无法改改被点缀函数的源代码

      图片 5

 

def fib(max):
    n,a,b = 0,0,1
    while n < max:
        print(b)
        a,b = b,a+b
        n = n+1
    return 'done'

  打字与印刷结果:

 

a,b = b,a+b

  

    图片 6

__Author__ = 'Redleafage Zhang'

print(all([0,-5,3])) #如果可迭代对象里所有的元素都为真(或者是空值),则返回真
print(any([0,-5.3]))#可迭代数据里任意的数据为真,则为真,如果是空的,则返回假
a=ascii([1,2,'开外挂了']) #把内容转换成字符串
print(type(a),[a])
print(bin(9)) #十进制转二进制
print(bool(1)) #判断真假

a=bytes("abcde",encoding="utf-8")
b = bytearray("abcde",encoding="utf-8")
print(b[0]) #打印ASCII码
b[1] = 100 #不能赋值字符串,只能赋ASCII码形式
# print(a)
# print(a.capitalize(),a) 变大写,不改变原字符串
print(callable([])) #判断是否可调用,能加括号的可调用(比如函数),列表返回False
print(chr(88)) #把数字对应ASCII码字符打印出来
print(ord('a')) #把字符转为ASCII码
code = "for i in range(10):print(i)"
c = compile(code,'','exec')#exec表示可以把字符串之形成代码
exec(c)
code = "1+3/2*6"
#c = compile(code,'','eval') #eval计算数字
#eval(c) #CMD里可运行
eval(code) #CMD里可运行,把字符串变成字典

code = '''
def fib(max):
    n,a,b = 0,0,1
    while n < max:
        #print(b)
        yield b
        a,b = b,a+b
        n = n+1
    return 'done' #此时fib已经是一个生成器,而不是一个函数,因此return是在异常测试时打印出来的东西,而不是函数的返回值

print(fib(10))
f = fib(10)
print(f.__next__())
print(f.__next__())
print(f.__next__())
'''

py_obj = compile(code,"err.log",'exec')
exec(py_obj)
exec(code) #直接用exec也可以,compile没什么用
a = {}
print(dir(a)) #查参数有什么方法可以用

print(divmod(5,2)) #相除并返回商和余数,归为元祖

def sayhi(n): #如果这个函数只使用一次,用def占用空间
    print(n)
    for i in range(n): #此种lambda无法模拟
        print(i)

sayhi(3)

#匿名函数,用完就释放,不占空间
print((lambda n:print(n))(5)) #(5)为传参
calc = lambda n:print(n)
calc(5) #效果同上
calc = lambda  n:3 if n<4 else n
calc(5)

res=filter(lambda n:n>5,range(10))#把大于5的过滤掉,返回迭代器
res = map(lambda n:n*2,range(10))#对传入的每个值按逗号前的方法得出结果 [i*2 for i in range(10)]
for i in res:
    print(i)

res = [lambda i:i*2 for i in range(10)]#效果同上

import functools
res = functools.reduce(lambda x,y:x+y,range(10)) #从1加到9,x+y的值返回x ,y为range(10)的下一个值
print(res)

a = frozenset([1,4,333,212,33,33,12,4]) #不可变集合,不可增删
print(globals()) #返回当前整个程序所有变量的keyvalue的格式,变量名是key,变量名对应的值是value

print(hash('alex')) #把字符变成映射的数字

print(hex(122)) #把数字转成16进制

def test():
    local_var = 333
    print(locals()) #打印当前函数所有的局部变量,以字典的形式
    print(globals()) #打印结果无局部变量
test()
print(globals().get('local_var')) #无法取到函数里的值,global只打印全局变量,不打印局部变量
print(oct(10)) #转八进制
print(pow(3,5)) #3的5次方
round(1.3342,2) #保留两位小数
slice(2,5,None)
d = range(10)
d[slice(2,5)] #相当于d[2:5],没什么用

a = {6:2,8:0,1:4,-5:6,99:11,4:22}
print(sorted(a.items())) #把无序的字典按key排序
print(sorted(a.items(),key = lambda x:x[1])) #把无序的字典按value排序
print(a) #无序

a = [1,2,3,4]
b = ['a','b','c','d']
for i in zip(a,b): #拼两个列表,返回元组
    print(i)


__import__('decorator')  #以后会用到
def foo(): #函数的嵌套,嵌套指在函数内部以def形式定义新函数
    print('in the foo')
    def bar(): #局部变量
        print('in the bar')

    bar()
foo()

def test1(): #这叫函数的调用,不是嵌套。
    test2()
test1()

    

    

        打字与印刷结果:

 

      打印结果:

__Author__ = 'Redleafage Zhang'
import time
def consumer(name):
    print("%s 准备吃包子啦!" %name)
    while True:
       baozi = yield #None,因为是生成器,返回值后不再执行,再次输入__next__()才会继续执行

       print("包子[%s]来了,被[%s]吃了!" %(baozi,name))

c = consumer("ChenRonghua")
c.__next__()

# b1= "韭菜馅"
# c.send(b1) #把b1发送过去,被yield接收到
# c.__next__()

def producer(name):
    c = consumer('A') #这一步只是把c变成生成器,不执行内容,next后才会开始执行
    c2 = consumer('B')
    c.__next__()
    c2.__next__()
    print("老子开始准备做包子啦!")
    for i in range(10):
        time.sleep(1)
        print("做了1个包子,分两半!")
        c.send(i)
        c2.send(i)

producer("alex")

        图片 7

  这么些文件存在的指标是:

 

  列表生成式:

    

      伍.宽广难点求证。

    图片 8

  关于README的内容:

      图片 9

    图片 10

 

    相当于  

 

    generator分外强劲,
若是推算的算法比较复杂,用接近列表生成式的for循环无法落到实处的时候,还足以用函数来贯彻。

 

      3.嵌套函数

    

 

      大家曾经通晓,能够直接成效于for循环的数据类型有以下两种:

        Iterator甚至足以象征2个极端大的数据流,例如全部自然数。而使用
list 是恒久不容许存款和储蓄全体自然数的。(惰性计算:走到这一步再算,没走到就不算)

a=b 
a=1
b=2
a=b
a=2
b=a+b
b=2+2 = 4

    图片 11

        能够被next()函数调用并不停重回下一个值的靶子称为迭代器:Iterator.

         生成器都以Iterator对象,但list,dict,str就算是Iterable,却不是Iterator

    二.调用生成器下3个数额:__next__()

 

      一类是generator,包涵生成器和带yield的generator function.

 

      终极实例:

      

 

  

      写程序时每dump二回,就要loadi
次,不要三次dump很多行,宁可dump成好多少个文件。

      

    注:pickle.dump(info,f) 等同于f.write(pickle,dumps(info)) 

    迭代器

  Pickle:只有python能用,能存放复杂数据(如函数)

    要开创贰个generator,有很各个办法。第3种办法很简短,只要把二个列表生成式的[]改变(),就创办了三个generator

        3个一如既往连串,但大家却不可能超前知道数列的尺寸,只可以不断通过next()函数达成按需总结下三个数据,所以Iterator的计量是惰性的,唯有在需求回到下四个数目时它才会盘算。

__Author__ = 'Redleafage Zhang'

import time

def timmer(func): #装饰器
    def warpper(*args,**kwargs):
        start_time = time.time()
        func()
        stop_time = time.time()
        print('the func run time is %s' %(stop_time-start_time))
    return warpper

@timmer
def test1():
    time.sleep(3) #运行逻辑所花费的时间
    print('in the test1')

test1()

 

    二.福利读者明确项目利用了怎么Python包。

import pickle
def sayhi(name):
    print("hello",name)
info = {
      'name':'alex',
      'age':22,
      'func':sayhi #pickel可以存储函数,而json不行
}
f = open("test.text",''wb")
print(pickle.dumps(info))
f.write(pickle.dumps(info)) #直接以字典格式存入文件
f = open("test.text","rb")
data = pickle.loads(f.read()) #恢复数据
print(data)

      1类是集聚数据类型,如list,tuple,dict,set,str等;

  定义:装饰器本人是函数,(装饰其余函数),正是为别的函数添加附加成效。

  后边多少个因素,那前面绝超越11分之伍要素占用的半空中都白白浪费了。

    比如,著名的斐波这契数列(Fibonacci),除第3个和第三个数外,任意三个数都得以由前四个数相加得到:

        图片 12

      打字与印刷结果:

import json
info = {
      'name':'alex',
      'age':22
 }
f = open('test.text','w')
print(json.dumps(info))
f.write(json.dumps(info)) #直接以字典格式存入文件
f = open('test.text','r')
data = json.loads(f.read()) #恢复数据
print(data['age'])

  哈希:

    注意,赋值语句:

    图片 13

  全数内置方法:

  Json:多语言可用,只好存放简单多少

    一.生成器唯有在调用时才会转移对应的数额

__Author__ = 'Redleafage Zhang'

import time
user,passwd = 'alex','abc123'
def auth(auth_type):
    print("auth func:",auth_type)
    def outer_wrapper(func):
        def wrapper(*args, **kwargs):
            print("wrapper func args:", func)
            if auth_type == 'local':
                username = input("Username:").strip()
                password = input("Password:").strip()

                if user == username and passwd == password:
                    print("\033[32;1mUser has passed authentication\033[0m")
                    res = func(*args, **kwargs)
                    print("---after authentication")
                    return res

                else:
                    exit("\033[31;1mInvalid username or password\033[0m")
            elif auth_type == '1dap':
                print("搞毛线1dap,不会。。。")


        return wrapper
    return outer_wrapper


def index():
    print('welcome to index page')

@auth(auth_type = 'local')
def home():
    print('welcome to home page')
    return 'from home' # 没执行结果,装饰器改变了结果
@auth(auth_type = '1dap')
def bbs():
    print('welcome to bbs page')
index()
print(home()) #wrapper()
bbs()

  注意:从foo调main必要跨目录

 

      打字与印刷结果:

    实例:

      肆.代码目录结构表明,更详细点能够证明软件的基本原理。

  这几个文件的格式是每一行包罗3个包注重的认证。平常是flask >=
0.10那种格式,要求是这么些格式能被pip识别,那样就足以回顾的经过pip install
-r requirements.txt来把富有的python包正视

  三.docs/:存放一些文书档案

        集合数据类型如list,dict,str等是Iterable但不是Iterator,可是能够经过iter()函数得到三个Iterator对象。

 

    

 

    调用生成器:

      匿名函数:

  都设置好了。

    二.高阶函数:

def bar():
    print("in the bar!")
def test1(func):
    print(func)
    func() 可以运行

test1(bar) #打印内存地址,bar只代表标示函数体的门牌号
func = bar
func() #可以运行,传递地址,相当于x=1,y=x

  2.foo/:存放项指标有所源代码。(一)源代码中的全数模块、包都应该放在此目录。不要只置于顶层目录。(二)其子目录test/存放单元测试代码;(贰)程序的入口最佳命名字为main.py

        凡是可用于for循环的对象都以Iterable类型:

    这一个是种种项目都应该有的3个文书,指标是要能简要描述该品种的音讯,让读者非常快理解那几个体系。

    

叁、内置方法详解

      一.软件定位,软件的基本成效。

      贰.高阶函数

    内置函数详解:

      

    如若直白搜索中文集,功效低,假设有500万个数据,则必要循环500万次,把冬日的中文集通过照射转换为数字,并排序,查找的时候用折半搜索的方法找对应的数字,进步成效。python

 

      1.函数即“变量”

  除此而外,有一对方案提交了越多的始末。比如ICENSE.txt,ChangeLog.txt文件等,1般开源的时候会用到。

 

calc = lambda x:x*3 #匿名函数,没有名字的函数
print(calc(3)) #返回9

  装饰器应用详解

    打印结果:

目录:

      图片 14

  循环壹边盘算的体制,称为生成器:generator。

def fib(max):
    n,a,b = 0,0,1
    while n < max:
        #print(b)
        yield b
        a,b = a,a+b
        n += 1
    return 'done'

    它必要表达以下多少个事项:

    也正是说,上边包车型地铁函数和generator仅一步之遥。要把fib函数变成generator,只供给把print(b)改为yield
b就可以了:

  5.requirements.txt:存放软件正视的外部Python包列表

  生成器:

 

        图片 15

      3.不难易行的应用验证。

 

         生成器肯定是迭代器,迭代器不自然是生成器。

    一.有益于开发者维护软件的包依赖。将开发进程中新增的包添加进这一个列表中,防止在setup.py安装重视时漏掉软件包。

 

        
那是因为Python的Iterator对象表示的是1个数据流,Iterator对象能够被next()函数调用并持续重返下贰个多少,直到未有数据时抛出StopIteration错误,可以把这一个数额流看作是

  六.README:项目表达文件

    图片 16

  肆.setup.py:安装、安插、打包的剧本

           2.不能够改改被点缀函数的调用情势

         你大概会问,为何list,dict,str等数据类型不是Iterator?

    斐波这契数列用列表生成式写不出来,不过,用函数把它打字与印刷出来却很不难:

  pickle:

    打印结果:

    所以,若是列表成分得以遵从某种算法推算出来,这大家是或不是能够在循环的进程中连连推算出后续的要素呢?那样就足以不必创造完整的list,从而节省大批量的长空,在python中,那种单方面

5、软件目录结构正式

 

  requirements.txt:

        图片 17

        图片 18

__Author__ = 'Redleafage Zhang'
import time
def timer(func):
    def deco(*args,**kwargs): #是否传递参数都无所谓了
        start_time = time.time()
        func(*args,**kwargs) #run test1
        stop_time = time.time()
        print('the func run time is %s' %(stop_time-start_time))
    return deco

# def timer():
#     def deco():
#         pass

@timer #相当于test1 = timer(test1)
def test1():
    time.sleep(3)
    print('in the test1')
@timer #test2 = timer(test2)= deco test2() = deco()
def test2(name,age):

    print('test2',name,age)

#print(timer(test1)) #打印内存地址
#test1 = timer(test1)
#test1()  #-->deco
test1()
test2('linda',22)

    

    通过列表生成式,我们能够直接创建1个列表。可是,收到内部存款和储蓄器限制,列表容积肯定是零星的。而且,创造一个包涵拾0万个要素的列表,不仅占用相当大的仓库储存空间,借使大家无非要求拜访

 

/Library/Frameworks/Python.framework/Versions/3.6/bin/python3.6 /Users/zhangshu/PycharmProjects/s14/day4/内置方法.py
False
True
<class 'str'> ["[1, 2, '\\u5f00\\u5916\\u6302\\u4e86']"]
0b1001
True
97
False
X
97
0
1
2
3
4
5
6
7
8
9
<generator object fib at 0x10410d200>
1
1
2
<generator object fib at 0x10410d2b0>
1
1
2
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
(2, 1)
3
0
1
2
5
None
5
0
2
4
6
8
10
12
14
16
18
45
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x101eb85c0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/Users/zhangshu/PycharmProjects/s14/day4/内置方法.py', '__cached__': None, '__Author__': 'Redleafage Zhang', 'a': frozenset({1, 33, 4, 12, 333, 212}), 'b': bytearray(b'adcde'), 'code': "\ndef fib(max):\n    n,a,b = 0,0,1\n    while n < max:\n        #print(b)\n        yield b\n        a,b = b,a+b\n        n = n+1\n    return 'done' #此时fib已经是一个生成器,而不是一个函数,因此return是在异常测试时打印出来的东西,而不是函数的返回值\n\nprint(fib(10))\nf = fib(10)\nprint(f.__next__())\nprint(f.__next__())\nprint(f.__next__())\n", 'c': <code object <module> at 0x1040f5a50, file "", line 1>, 'i': 18, 'py_obj': <code object <module> at 0x1040f5b70, file "err.log", line 2>, 'fib': <function fib at 0x104108598>, 'f': <generator object fib at 0x10410d2b0>, 'sayhi': <function sayhi at 0x101e62ea0>, 'calc': <function <lambda> at 0x104108ae8>, 'res': 45, 'functools': <module 'functools' from '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/functools.py'>}
-652459854530933945
0x7a
{'local_var': 333}
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x101eb85c0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/Users/zhangshu/PycharmProjects/s14/day4/内置方法.py', '__cached__': None, '__Author__': 'Redleafage Zhang', 'a': frozenset({1, 33, 4, 12, 333, 212}), 'b': bytearray(b'adcde'), 'code': "\ndef fib(max):\n    n,a,b = 0,0,1\n    while n < max:\n        #print(b)\n        yield b\n        a,b = b,a+b\n        n = n+1\n    return 'done' #此时fib已经是一个生成器,而不是一个函数,因此return是在异常测试时打印出来的东西,而不是函数的返回值\n\nprint(fib(10))\nf = fib(10)\nprint(f.__next__())\nprint(f.__next__())\nprint(f.__next__())\n", 'c': <code object <module> at 0x1040f5a50, file "", line 1>, 'i': 18, 'py_obj': <code object <module> at 0x1040f5b70, file "err.log", line 2>, 'fib': <function fib at 0x104108598>, 'f': <generator object fib at 0x10410d2b0>, 'sayhi': <function sayhi at 0x101e62ea0>, 'calc': <function <lambda> at 0x104108ae8>, 'res': 45, 'functools': <module 'functools' from '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/functools.py'>, 'test': <function test at 0x104108bf8>}
None
0o12
243
[(-5, 6), (1, 4), (4, 22), (6, 2), (8, 0), (99, 11)]
[(8, 0), (6, 2), (1, 4), (-5, 6), (99, 11), (4, 22)]
{6: 2, 8: 0, 1: 4, -5: 6, 99: 11, 4: 22}
(1, 'a')
(2, 'b')
(3, 'c')
(4, 'd')
in the test1
the func run time is 3.002807140350342

Process finished with exit code 0

    一.装饰器之“函数即变量“

 

def bar():
    time.sleep(3)
    print('in the bar')


def test2(func):
    print(func)
    return func

#print(test2(bar)) #两次都打印地址
bar = test2(bar) #覆盖之前的bar函数,相当于test2加上了新功能,函数调用方式没有改变,python解释器有专门的符号可解释此过程,后面讲
bar() # run bar

2、迭代器与生成器

     b.重回值中包罗函数名(不改动函数的调用格局)

 

      二.运行代码的主意:安装环境、运营命令等。

[i*2 for i in range(10)] #生成[0,2,4,6,8,10,12,14,16,18]

    的字典是用哈希的艺术完成的。MD伍也属于哈希

  图片 19

    打字与印刷结果:

 

     a.把七个函数名当作实参传给别的多少个函数(在不改动棉被服装饰函数源代码的景色下为其增加效果)

      能够应用isinstance()判断3个对象是不是是Iterable对象:

  

     实例:

 

  一.bin/: 存放项目标1部分可执行文件,当然你能够起名script/之类的也行。

    仔细观看,能够看到,fib函数实际上是概念了斐波那契数列的推算规则,能够从第2个元素起初,推算出后续任意的成分,那种逻辑其实分外周围generator

 

x=0
def grandpa():
    #x=1
    def dad():
        x=2
        def son():
            x=3
            print(x)
        son()
    dad()
grandpa() #结果返回3

 

      高阶函数+嵌套函数–>装饰器

二、迭代器与生成器

    通过os方法找到主目录,添加给环境变量,再导入其余模块即可。

    1,1,2,3,5,8,13,21,34,……

    而不是一定于

import  time
def bar():
     time.sleep(3)
     print('in the bar')
def test1(func):
     start_time = time.time()

     func() #run bar
     stop_time = time.time()
     print('the func run time is %s' % (stop_time-start_time) )

test1(bar)

    图片 20

    三.嵌套函数

        图片 21

      data = pickle.load(f) 等同于pickle.loads(f.read())

      局地成效域与大局功效域的访问顺序

      那个能够直接效率于for循环的对象统称为可迭代对象:Iterable.

      
 变量名也就是门牌号,存放的剧情约等于房间里的事物(占内部存款和储蓄器空间),函数名也一定于门牌号,函数体(函数的具体内容)在屋子内部。如下图:

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图