python学习笔记_week肆起名

decorator1

        having
;//对计算结果进行过滤
        select 操作(列),操作(列)….
,分组列 from 表 group by 分组列 having 操作(列) 比较符
值;//正是限制标准  不过是对结果集实行的限制查询,
先分组,在从分组的根底上,进行界定
        select avg(sal),max(sal),deptno
from emp emp group by deptno having
avg(sal)>3000;(平均薪水低于3000的机关号和平均薪金)

那几个能够一向效果于for巡回的对象统称为可迭代对象:Iterable

//子查询 : 分页
    
    //多少个查询运算,只可以是number类型
,重返值也都为int类型
    max :

 内置参数详解
https://docs.python.org/3/library/functions.html?highlight=built#ascii 

    //备份表 :

   二.无法修改被点缀的函数的调用格局

//为用户授权 : 权限

用于系列化的多个模块

    rename 旧表名 to 新表名;

Json模块提供了多个效率:dumps、dump、loads、load

        select 列,列*12 + nvl(列*1二,0)
as sy,  列 from emp order by sy
排序(asc/desc);//查看有些表的一点列,并对少数列实行了算数操作,并给算的结果起各自名称为 sy列 ,然后再给那几个sy列进行排序 asc(从小到大)/desc(从大到小)

 #hash():

     //以多列为正式分组

 1 import json
 2 
 3 def sayhi(name):
 4     print("hello,",name)
 5 info={
 6     "name":"jyh",
 7     "age":24,
 8     #"func":sayhi
 9 }
10 
11 f=open("test.text","w")
12 f.write(json.dumps(info))
13 info["age"]=21
14 f.write(json.dumps(info))
15 f.close()

    //以单列为正式分组

据此,假如列表成分得以遵守某种算法推算出来,那我们是否能够在循环的进程中连连推算出后续的要素呢?那样就不用制造完整的list,从而省去大量的长空。在Python中,那种单方面循环一边盘算的编写制定,称为生成器:generator。

    desc :

要创立三个generator,有很各类主意。第二种形式很简单,只要把1个列表生成式的[]改成(),就创办了三个generator:

    //grant 权限 to c##用户名:

 斐波拉契

//切换当前用户 :

起名 1起名 2

        truncate table 表名;  
 //相当于删除表和多少然后重建表.

举凡可职能于next()函数的目标都以Iterator类别,它们表示3个惰性总结的队列;

zeng :
//增 :
    //成立用户 :
    
        create user c##名字 identified
by 密码 ;
        //命名规则 :
            一名字务必以字母起首,
            2长度无法跨越二20个字符(60字节),
            三不可能采纳oracle的保留字<
            四 只能接纳a-z,A-Z,
0-九,$,#,_,等…

目录社团办公室法

至于怎么样协会一个较好的Python工程目录结构,已经有局地获取了共同的认识的目录结构。在Stackoverflow的以此题材上,能见到我们对Python目录结构的议论。

此处面说的已经很好了,作者也不打算重新造轮子列举种种分裂的艺术,那其间笔者说一下笔者的知道和认知。

比方你的种类名字为foo, 作者相比提出的最方便神速目录结构那样就够用了:

Foo/
|-- bin/
|   |-- foo
|
|-- foo/
|   |-- tests/
|   |   |-- __init__.py
|   |   |-- test_main.py
|   |
|   |-- __init__.py
|   |-- main.py
|
|-- docs/
|   |-- conf.py
|   |-- abc.rst
|
|-- setup.py
|-- requirements.txt
|-- README
#还少一个配置文件目录(conf目录) 。

粗略解释一下:

  1. bin/:
    存放项指标部分可执行文件,当然你能够起名script/等等的也行。
  2. foo/: 存放项目标富有源代码。(壹)
    源代码中的全部模块、包都应该放在此目录。不要置于顶层目录。(二)
    其子目录tests/存放单元测试代码; (三)
    程序的入口最佳命名字为main.py
  3. docs/: 存放1些文书档案。
  4. setup.py: 安装、陈设、打包的本子。
  5. requirements.txt: 存放软件正视的外部Python包列表。
  6. README: 项目表达文件。

除了,有一对方案提交了更进一步多的剧情。比如LICENSE.txt,ChangeLog.txt文件等,小编从不列在此间,因为那几个东西根本是项目开源的时候供给用到。倘使你想写二个开源软件,目录该怎么样组织,能够参见那篇小说

下边,再简单讲一下作者对这么些目录的知晓和村办须求啊。

        connect
用户名/密码@互连网服务器(orcl);

生成器:唯有在调用时才会转移对应的数据。

    // grant 权限 传递
        
        grant 权限 to 用户名 with grant
option;//它也就有给外人权力的权位,不过权力无法跨越她协调(本人)

壹:把3个函数名当抓实参传给此外一个函数(在不修改棉被服装饰函数源代码的场地下为其丰硕效果)

    blob :
       
blob://二进制数据电影,图片,音乐,四G不会停放数据Curry面,文件服务器

requirements.txt

以此文件存在的指标是:

  1. 便利开发者维护软件的包依赖。将付出进度中新增的包添加进那一个列表中,制止在setup.py安装依赖时漏掉软件包。
  2. 有利读者分明项目选拔了怎么样Python包。

其一文件的格式是每一行李包裹括1个包重视的认证,常常是flask>=0.10那种格式,须要是其1格式能被pip识别,那样就能够总结的通过 pip install -r requirements.txt来把全体Python包正视都装好了。具体格式表达: 点这里

 

    //删除3个表的字段 :
(删除2个列/属性)

 

        create table 表名(属性
number(5,0)/*数据类型5个人数,且从未小数*/ , 属性 varchar2(4
byte)/*数据类型,字符型,只可以输入几个人,必须是字节格式*/)

  • ### 装饰器:

//oracle数据类型 :
    
        number : 整型值  插入值的时候
直接 (2贰,3三,四,四五,…就行)
        varchar二 : 字符型 插入值的时候
‘必须用单引号括起来’;
    number :

 1 def fib(max):
 2     n, a, b = 0, 0, 1
 3     while n < max:
 4         #print(b)
 5         yield b
 6         a, b = b, a + b
 7         n = n + 1
 8     return '---done---' #处理异常时返回的值
 9 f = fib(6)
10 while True:
11     try:
12         x = next(f)
13         print('f:', x)
14     except StopIteration as e:
15         print('Generator return value:', e.value)
16         break

//创设用户 :
    
        create user c##名字 identified
by 密码 ;
        //命名规则 :
            一名字务必以字母初叶,
            二长短不能够超越30个字符(60字节),
            三不可能采纳oracle的保存字<
            四 不得不利用a-z,A-Z,
0-九,$,#,_,等…

落实装饰器知识储备:

        revoke 操作名(权限) on 表名 from
用户名;

fibna_

        clob(characterlarge
object);//字符型大目的,最大肆G

decorator4

distinct :
    //单列查询 : (去除重复)

起名 3

        alter table 表名 modify (属性
类型);
            如 : alter table student
modify (sex number(1));

 

    //更改列上的值 :

 1 import pickle
 2 
 3 def sayhi(name):
 4 
 5     print("hello2,",name)
 6 
 7 info={
 8     "name":"jyh",
 9     "age":24,
10     "func":sayhi
11 }
12 
13 f=open("test.text","rb")
14 data=pickle.loads(f.read())
15 print(data["func"]("jyh"))
16 f.close()

cha :
//查 :

setup.py

貌似的话,用setup.py来管理代码的包装、安装、安插难点。产业界规范的写法是用Python流行的包裹工具setuptools来保管那一个业务。那种办法广泛运用于开源项目中。然而那里的核心理想不是用口径的工具来化解那些题材,而是说,一个档次必将要有多个安装配置工具,能高效方便的在1台新机器军长环境装好、代码布置好和将程序运营起来。

以此自家是踩过坑的。

本人刚初叶接触Python写项指标时候,安装环境、布署代码、运转程序那几个历程全是手动实现,境遇过以下难题:

  1. 安装环境时平常忘了最近又添加了2个新的Python包,结果一到线上运维,程序就出错了。
  2. Python包的版本重视难题,有时候大家先后中央银行使的是二个版本的Python包,不过官方的已经是新型的包了,通过手动安装就可能装错了。
  3. 假诺依靠的包很多来说,3个贰个装置那个依赖是很伤脑筋的事务。
  4. 新校友发轫写项目标时候,将先后跑起来万分麻烦,因为或许时时忘了要怎么设置种种正视。

setup.py能够将这么些事情自动化起来,进步成效、减弱失误的可能率。”复杂的事物自动化,能自动化的东西必定要自动化。”是二个尤其好的习惯。

setuptools的文档比较庞大,刚接触的话,恐怕不太好找到切入点。学习技能的法子正是看外人是怎么用的,可以参考一下Python的八个Web框架,flask是如何写的: setup.py

本来,不难点自个儿写个安装脚本(deploy.sh)替代setup.py也未尝不可。

        select * from
dba_users;//前提是 你登6的是sys或system号(用户);

起名 4起名 5

            1 –> update 表名 set
(job,sal,comm)= (select job,sal,comm from emp where ename=’clock’) where
ename
=”scott”;//先查ename为’clock’的(区分轻重缓急写),获取job,sal,comm,对应的值,再把那些值更改(赋值)到
ename为’scott’ 对应的job,sal,comm的列值中

起名 6起名 7

        insert into 新表名(字段名) select
列 from 表名 where 行限定条件(不是颇具数据,年龄段,有个别机构)//
    如 : insert into emp(id) select age
from emp where id = 3三;//把emp表中
id列值为3三,对应的这一个age的值,添加到emp表的id列中

for line in f 也是迭代器的法子去取

        avg();//获取某1列的平均值 
重返值为int类型
            如 :
avg(id);//获取id那一列的平均值

 1 import time
 2 def consumer(name):  #消费者
 3     print("%s 准备吃包子啦!" %name)
 4     while True:
 5        baozi = yield
 6 
 7        print("包子[%s]来了,被[%s]吃了!" %(baozi,name))
 8 
 9 # c=consumer("jyh")
10 # c.__next__()
11 # b1="韭菜馅"
12 # c.send(b1)  #与next区别:不仅调用,还传值
13 # c.__next__()
14 
15 def producer(name):  #生产者
16     c = consumer('A')
17     c2 = consumer('B')
18     c.__next__()
19     c2.__next__()
20     print("老子开始准备做包子啦!")
21     for i in range(10):
22         time.sleep(1)
23         print("做了1个包子,分两半!")
24         c.send(i)
25         c2.send(i)
26 
27 producer("XXX")
28 #协程比线程更小的单位
29 #异步io, Nginx 雏形 。

        select 列限定(就是列) from
表限定(就是表) where 行限定(正是单排中某二个属性);  
 //数据限定条件区分轻重缓急写,java限定大小写,select什么就输出什么
        一 select id,name from emp where
job = ‘CLE宝马X5K’;//查看
job(列)为’CLE中华VK’的哪壹行(或多行)的id值和name值

  • ###  生成器

       
varchar2:变长,4000字符(8000字节);
        varchar二(20
byte);//规定能写十八个字符 不过只好是byte类型(字节型),不过内容必须是
‘内容’,用单引号括起来

局地作用域和大局作用域的造访顺序(从里往外找)

    //删除行 : 不定条数
    
        delete from 表名 where
行限定标准;
            限定条件 如 :
name那一名列Kay的 全体刨除
        delete from emp where name =
‘Kay’;

起名 8起名 9

    //查看数据Curry面包车型地铁拥有用户 :

fibna_2

    //五个插入 :

起名 10起名 11

    date :

1.函数即“变量”

    //成立表单 :

json_fanxuliehua

where_and_or :
        or : 或者 或
        >,>=,<,<=,= :
大于,大于等于,小于,小于等于,等于;
    select * from 表 where (列
>/*</>/=(大于或等于或低于)*/值 or 列 = 值) and 列 like
‘j%’;//
        如 : select * from emp where
(id>20 or age = 1九)and name like ‘j%’;//查看emp表中
id列的值超出20或age列的值为1九的 并且 name列的值以j初步的具备的行的习性

三.嵌套函数

        select * from 表 where 列
in(值(壹),值(二),值(三)…);//输出某表中 某列的值为 一 仍旧 二 照旧 三的保有的行的品质
        select * from emp id
in(22,4二,6陆);//输出emp表中 id
列的值为2二或4二或6陆的具备的行的属性

Python的for循环本质上正是经过不断调用next()函数完毕的,例如:

    //更改字段(列)的花色大概名字 :

 1 # def foo():
 2 #     print("in the foo")
 3 #     bar()
 4 # foo()
 5 
 6 
 7 
 8 # def foo():
 9 #     print("in the foo")
10 #     bar()
11 # def bar():
12 #     print("in the bar")
13 # foo()
14 
15 def foo():
16     print("in the foo")
17     bar()
18 foo()
19 def bar():
20     print("in the bar")

        % : 相配三个字符 有三个趣味 一能够包容任意位字符
                                    贰得以相配每位上边的即兴字符
        _ : 相称三个字符

 

        select * from 表名 where
列(属性) is not null;//不为空的
        select * from 表名 where
列(属性) is  null;//为空的
       
//查看某列的性质为空(不为空)的享有数据

 1 import json
 2 info={
 3     "name":"jyh",
 4     "age":24
 5 }
 6 
 7 f=open("test.text","r")
 8 data=json.load(f.read())
 9 print(data)
10 f.close()   #可以dump多次,load出错。所以最好dump一次,load一次

       
//给查到的数量,进行从大到小排序(是查到后,在排序,和表内容无妨)
        select * from 表名 order by  列
desc;//某列从大到小排序(只是输出的时候排序而已)

函数和变量都以先定义再调用,在调用在此以前定义好了就OK

       2  select * from 表名 where
限定列 like ‘__k%’;//八个下划线(代表两位) 查看有些表的某个列的值,
值的第7位是k的有着的行的属性

neizhi_

    //设置用户使用的表空间 :
        
        alter user 用户名 default
tablespace users;
        alter user 用户名 temporary
tablespace temp;//最近表空间

 1 import time
 2 def timer(func): #timer(test1)  func=test1()
 3     def deco():
 4         start_time=time.time()
 5         func()  #run test1()
 6         stop_time=time.time()
 7         print('the func run time is %s' % (stop_time - start_time))
 8     return deco
 9 @timer #test1=timer(test1)
10 def test1():
11     time.sleep(3)
12     print('in the test1')
13 test1() #-->run deco

        connect:链接(登陆) 权限
        resource:数据/源 权限 (对数码的
增 删 改 查 )
        unlimited tablespace : 表空间
权限

 1 import time
 2 # def deco(func):
 3 #     start_time=time.time()
 4 #     return func  #返回函数的内存地址
 5 #     stop_time=time.time()
 6 #     print('the func run time is %s' % (stop_time - start_time))
 7 def timer(func): #timer(test1)  func=test1()
 8     def deco(*args,**kwargs):  #加上非固定参数*args,**kwargs才通用
 9         start_time=time.time()
10         func(*args,**kwargs)  #run test1()
11         stop_time=time.time()
12         print('the func run time is %s' % (stop_time - start_time))
13     return deco
14 
15 # def timer():
16 #     def deco():
17 #         pass   #仿照这个格式
18 @timer #test1=timer(test1) =deco
19 def test1():
20     time.sleep(1)
21     print('in the test1')
22 @timer
23 def test2(naem,age):
24     time.sleep(1)
25     print('in the test2')
26 
27 #test1=timer(test1)
28 test1() #-->run deco
29 test2("jyh",24)

//创立表单 :
    在时下用户下创办表单
    create table 表名字(id number(伍,二),
name varchar贰(20 byte));//成立多少个表单,里面有两列,第三列是id 是数值型
切共有五人数字,并有两位是小数,肆人是整数 ,第一列是name
字符型,能输入十八个字节,必须是字节

实在完全等价于:

        desc
表名;//查看表头(也便是列)
where_and :
    //筛选数据,多选, 查询空值
(前边只好用null 那是三个话语)

 

        grant connect,resource,unlimited
tablespace to c##名字 container=all;//全部权限

满意以下在那之中贰个就是高阶函数

        select 表名 from
dba_tables;//数据库全体表,包罗系统表,前提是
你登陆的是sys或system号(用户);

json_xuliehua2

        update 表名 set
列名=列值改变量(+-*/), 字段二,字段3, where 行限定标准;
            如 :  update 表名 set
列名=’值’ where id=’B000贰'(限定标准,id为B000贰的
都会把后边钦点的天性的值更改);

可怜处理:

    //更改表名字 :
        
        rename 旧表名 to 新表名;

起名 12起名 13

    //查看表头 :

decorator5

        select distinct 列限定 from 表名
where 行限定(z只好单行查询)
    
like :

 

    //删除权限 :

起名 14起名 15

    //切换当前用户 :

 1 import pickle
 2 
 3 def sayhi(name):
 4     print("hello,",name)
 5 info={
 6     "name":"jyh",
 7     "age":24,
 8     "func":sayhi
 9 }
10 
11 f=open("test.text","wb")
12 pickle.dump(info,f) #与f.write(pickle.dumps(info))一样
13 f.close()

order_by :

概念:本质是函数,(装饰别的函数)便是为其余函数添加附加成效

        alter table 表名 add (“名字”
number(3)/*类别,规定内容格式*/);

起名 16起名 17

        sum();//获取某1列的值的总额   
再次回到值为int类型
            如 :
sum(id);//获取id那一列的值的总和

pickle_fanxuliehua2

    in_and :
        >,>=,<,<=,= :
大于,大于等于,小于,小于等于,等于;
        select * from 表 where 列
in(值(1),值(二),值(叁)) and 列 >/</=(大于或低于或等于) 值;
        如 : select * from emp where id
in(2二,3三,4肆) and age >1九;//查看emp表中 id列的值为2二或3叁或4四 还要
age(年龄)列的值 大于19的 全数的行的性质

test2

    //为用户授权 : 权限

大凡可效果于for循环的对象都以Iterable类型;

    //内定查询 :

 1 import time
 2 def bar():
 3     time.sleep(3)
 4     print("in the bar")
 5 def test2(func):
 6     print(func)
 7     return func
 8 
 9 #print(test2(bar))
10 # t=test2(bar)
11 # t() #run bar
12 bar=test2(bar)
13 bar()

    min :

decorator_

    //相称字符查询 : (便是筛选)

 

       
//给查到的数量,举行从小到大排序(是查到后,在排序,和表内容无妨)
        select * from 表 order by 列
asc;//某表的某列输出的时候从小到大排序(只是输出的时候排序)

一类是集聚数据类型,如listtupledictsetstr等;

    //删除用户和表 :
      
        //删除用户
只好用sys用户才能去除,因为唯有sys用户有删除别的用户的权利
        drop user 用户名
cascade;//用户和表1起删除

高阶函数+嵌套函数 =》装饰器

//更改表名字 :

pickle模块提供了八个效益:dumps、dump、loads、load

    asc :

起名 18

    //查看当前用户下全数的表单 :

x=一x一定于门牌号,python解释器中有引用计数,y=x,相当于1所在的房间有多个门牌号,当未有门牌号时,python就会把屋子清空掉。函数的回收机制和变量一样。

       
number(伍,贰);//1共陆个人数字,个中有两位是小数,范围是(-十^3八 ~
10^38);
       
number(5);//便是规定有五人数字,没有小数 私下认可是number(5,0);
    
    char :

起名 19

    //grant 权限 to c##用户名;
        connect:链接(登陆) 权限
        resource:数据/源 权限
        unlimited tablespace : 表空间
权限

  • ### Json & pickle 数据系列化

    avg :

你恐怕会问,为啥listdictstr等数据类型不是Iterator

        conut();//当前列下有多少个值   
再次来到值为int类型
            如 :
conut(id);//获取id那壹列有多少个值
    
    group_by :

起名 20

    varchar2 :

 捕获StopIteration荒谬,再次来到值包涵在StopIterationvalue中。

    //设置用户选用的表空间 :
        
        alter user 用户名 default
tablespace users;
        alter user 用户名 temporary
tablespace temp;//最近表空间

  • #### 迭代器

shan :
//删 :

 

    //查询特定列 :

通过列表生成式,大家能够直接开立八个列表。可是,受到内部存储器限制,列表容积肯定是不难的。而且,创制贰个带有十0万个要素的列表,不仅占用极大的囤积空间,假如大家只是须要拜访后面几个因素,那背后绝半数以上因素占用的长空都白白浪费了。

    //查看数据Curry面包车型客车保有表

贰.高阶函数

       1 select * from 表名 where 限定列
like ”%k%’;//查看有些表中某个列的属性值,包罗k的持有的行的属性

pickle_xuliehua

            1  update 表名 set
(job,sal,comm/*列名*/)= (select job,sal,comm from/*翻开多个列*/ emp
where ename=’clock’/*ename为’clock’*/) where ename
=”scott”/*enamel为’Scott’的*/;//

至于配置文件的施用方法

    as : (起名)

起名 21起名 22

        create table 表名 as select *
from 表名;

decorator5

        drop table
用户名.表名;//删除表

bingxing

        select * from
user_tables;

 1 import time
 2 def bar():
 3     time.sleep(3)
 4     print("in the bar")
 5 def test1(func):
 6     start_time=time.time()
 7     func()  # run bar
 8     stop_time = time.time()
 9     print("the func time is %s"%(stop_time-start_time))
10 
11 test1(bar)

    //查看你能管理的全数用户 :
    
        select * from all_users;

起名 23起名 24

    //删除表的数码

1 def foo():
2     print('in the foo')
3     def bar():  #相当于局部变量,不能在外边调用
4         print('in the bar')
5 
6     bar()
7 foo()

    //删除表 :

起名 25

        select 列一,列二,列三… from 表
where 行限定;(行限定 : 正是某一列上的值 )
        如 :
            select id,name from emp where
sex = ‘男’;//查看性别为’男’的 id和name属性

关于requirements.txt和setup.py

    nvl :
        //!!!!重点 : 借使 某列某行
有个空值 , 那么运算结果必然为空值
        nvl(列,0) : 把某列上的空值
赋值为0
        select 运算列1 +
nvl(运算列2,0)*12 “年工资”,列 from 表;
        select sal(报酬) +
nvl(jiang(奖金列),0) ‘年工钱’ ,name from
emp;//查看emp表中的sal列,和jiang列,和name列 ,
并把sal列的值和jiang列的值相加(有的人奖金为空 ,
正是未有,然后通过nvl(),就把空值赋值为0),然后算出来的结果起名(输出时候的列名)为
年薪酬 ,

  1. 一类同学以为,那种个人风格难点”毫不相关主要”。理由是能让程序work就好,风格难题历来不是题材。
  2. 另1类同学认为,规范化能越来越好的主宰程序结构,让程序有所越来越高的可读性。

        group by
;//以某多少个名列正式,举办分组   分组标准必须是询问条件中的列
        select 操作(列),操作(列)….
,分组列一,分组列二 from 表 group by
分组列壹,分组列二;//以多列为正式举行分组,正是分组列一实行分组(把相同的数额分为壹组,并且
各样组里面不能够有分组列二相同的数据 , 如 : id , name 
种种id分组里面,不可能有一样的name)
        select
min(sal),avg(sal),max(sal),deptno,job from emp group by
deptno,job;

能够接纳isinstance()判断四个对象是不是是Iterable对象:

gai :
//改 :

起名 26起名 27

having :

起名 28

    //往表单里添加三个字段 :
(添加二个列/属性)

 1 import time
 2 def timmer(func):
 3     def warpper(*args,**kwargs):
 4         start_time=time.time()
 5         func()
 6         stop_time=time.time()
 7         print('the func run time is %s'%(stop_time-start_time))
 8     return warpper
 9 
10 @timmer
11 def test1():
12     time.sleep(3)
13     print("in the test1")
14 
15 test1()

    clob :

test1

        min();//获取某一列的相当的小值 
再次回到值为int类型
            如 :
min(id);//获取id那一列的细微值

大家已经知道,能够平素效果于for巡回的数据类型有以下二种:

起名,            connect
用户名/密码@互连网服务器(orcl);

 1 import pickle
 2 
 3 def sayhi(name):
 4 
 5     print("hello2,",name)
 6 
 7 info={
 8     "name":"jyh",
 9     "age":24,
10     "func":sayhi
11 }
12 
13 f=open("test.text","rb")
14 data=pickle.load(f) #与data=pickle.loads(f.read())一样
15 print(data["func"]("jyh"))
16 f.close()

        max();//获取某1列的最大值 
重返值为int类型
            如 :
max(id);//获取id那壹列的最大值

起名 29

    count :

装饰器2

        grant connect,resource,unlimited
tablespace to c##名字 container=all;//全数权力

pickle_xuliehua2

    //枚举查询

起名 30起名 31

    //查看当前登陆用户 :
        
        show user;

留意,在上头的目录结构中,未有将conf.py放在源码目录下,而是放在docs/目录下。

多多品种对布置文件的选拔做法是:

  1. 安插文件写在3个或八个python文件中,比如那里的conf.py。
  2. 项目中哪些模块用到那些布局文件就径直通过import conf那种样式来在代码中使用布置。

那种做法俺不太帮衬:

  1. 那让单元测试变得紧Baba(因为模块内部注重了外部配置)
  2. 一面配置文件作为用户控制造进度序的接口,应当能够由用户自由钦定该文件的门径。
  3. 程序组件可复用性太差,因为那种贯穿全体模块的代码硬编码格局,使得抢先1二分之五模块都依靠conf.py其一文件。

由此,小编觉着配置的施用,越来越好的办法是,

  1. 模块的配备都以足以灵活布署的,不受外部配置文件的影响。
  2. 先后的安插也是能够灵活决定的。

可见佐证那几个怀念的是,用过nginx和mysql的校友都精晓,nginx、mysql那么些程序都得以随便的钦赐用户配置。

从而,不应该在代码中一向import conf来利用安顿文件。上边目录结构中的conf.py,是提交的一个配备样例,不是在写死在先后中一贯引用的安顿文件。能够透过给main.py启航参数钦定布置路径的秘诀来让程序读取配置内容。当然,那里的conf.py你能够换个近乎的名字,比如settings.py。也许您也能够选择任何格式的剧情来编排配置文件,比如settings.yaml之类的。

起名 32

atm.py 

起名 33起名 34

 1 #环境变量不能写死,只能写相对路径。我们要把这个程序的绝对路径获取到,动态的加到系统的环境变量里。
 2 # print(__file__) #当前程序的相对路径
 3 import os
 4 # print(os.path.abspath(__file__)) #当前程序的绝对路径
 5 print(os.path.dirname(os.path.abspath(__file__))) #dirname返回目录名不要文件名
 6 print(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 7 BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 8 import sys
 9 sys.path.append(BASE_DIR) #添加环境变量
10 from conf import  settings
11 from core import  main
12 
13 main.login()

atm.py

main.py

起名 35起名 36

1 def login():
2     print("Welcom to my Atm")

main.py

  • ### 作业要求:

仿照完结二个ATM + 购物超级市场先后

  1. 额度 一四千或自定义
  2. 兑现购物超级市场,买东西加入 购物车,调用信用卡接口结账
  3. 能够提现,手续费伍%
  4. 每月2二号出账单,每月拾号为还款日,过期未还,按欠款总额
    相当之5 每一天计息
  5. 援救多账户登录
  6. 帮助账户间转账
  7. 记录每月一般消费流水(账单)
  8. 提供还款接口
  9. ATM记录操作日志 
  10. 提供管理接口,包蕴丰盛账户、用户额度,冻结账户等。。。
  11. 用户认证用装饰器

示范代码https://github.com/triaquae/py3\_training/tree/master/atm 

大约流程图:https://www.processon.com/view/link/589eb841e4b0999184934329
 

 

    //对查看到值进行运算 :
            
            +*-/ : 运算查看的值(查是查
算是算 不是2遍事,并不会转移表单里面包车型客车值,只是改变了出口方式)//不过该列的数据类型必须是数字(number类型)
            select 列+20 ‘年终奖’ , name
from 表名;
            select
列+(加/减/乘/除)20(加减乘除对应的值)
‘年底奖'(给算好的结果(输出时候的列)起个名字) ,name from 表名;
            select sal+20 ‘年初奖’ , name
from emp;//查看emp表中的sal值和name值 ,并且把sal的值都加20
然后起个列名叫年初奖

pickle_fanxuliehua

       
date;//时间格式,values()赋值的时候,可以用那么些改变格式 :
to_date(’20-2-81′,’DD-MON-RR’);

之所以,笔者觉得,保持一个层次明显的目录结构是有不能缺少的。更何况组织一个特出的工程目录,其实是一件很简单的事务。

        group by
;//以某一列为正式,举行分组   分组标准必须是询问条件中的列
        select 操作(列),操作(列)….
,分组列 from 表 group by
分组列;//分组列正是以有个别列为正式分组,去除这一列的重复数据(是把相同数量的行,分为一组)
        select avg(sal),max(sal),deptno
from emp group by deptno;

起名 37

    //模拟中的数据复制 :

而生成器不但能够效率于for循环,还足以被__next__()函数不断调用并赶回下三个值,直到最终抛出StopIteration谬误表示无能为力继续回来下一个值了。

    //往表里面添加行(内容) :
        
        insert into
用户名.表名(属性1,属性2…/*可选的*/)values(值,值…);

 

    sum :

起名 38起名 39

in :

规则:一.不可能改改被点缀的函数的源代码

        insert into 表1(属性1,属性2…)
select * from
表贰;//表一末尾属性个数是稍稍,表2就非得是有点,而且数据类型也非得完全相同 ,
然后把表二里面列的数据类型的值,添加到和表第11中学对应列的数据类型相同的那一列的前面(追加行
)
        1 insert into emp
(id/*自身这么些id是number(5)类型,并且不得不写五个数字*/) select * from
emp二;//表2 里边必须有一个number(五)类型的列,并且也只好写四个数字
        2 insert into emp
(id/*我这个id是number类型*/) select hao from emp二;//hao那么些列
必须和id列的数据类型完全相同,然后把hao那一列的数目,在id哪壹列的末尾,追加

起名 40起名 41

        alter table 表名 drop column
列名;    //强烈提出并非对成熟的系统那样做

断点

   
                           JDBC请看下一篇~

*可以被__next__()函数调用并持续再次回到下一个值的目的称为迭代器:Iterator

        //查询快,但是浪费空间
       
char:定长,3000字符(6000字节),字符串char(伍);//能够安装5可 不过内容必须是
‘内容’,用单引号括起来

  • ### 内置参数

        2 select * from 表 where
列(列限定/表头) < 7800 and 列>2000;//(*就表示输出全部列的个性)
输出 某表中 某列上的值小于7800 且 某列的值大于3000的全部列的品质

聚集数据类型如listdictstr等是Iterable但不是Iterator,但是能够透过iter()函数获得3个Iterator对象。

View Code

decorator3

自笔者是相比较偏向于后世的,因为本人是前一类同学思想行为下的直白受害者。小编早就维护过三个不行倒霉读的品类,其促成的逻辑并不复杂,然则却消耗了本人相当的短的年华去精通它想发挥的情趣。从此笔者个人对于提升项目可读性、可维护性的渴求就很高了。”项目目录结构”其实也是属于”可读性和可维护性”的层面,大家设计贰个层次鲜明的目录结构,正是为着达到以下两点:

 1 import time
 2 user,passwd='alex','abc123'
 3 def auth(auth_type):
 4     print("auth func:",auth_type)
 5     def outer_wrapper(func):
 6         def wrapper(*args, **kwargs):
 7             print("warpper func args:",*args, **kwargs)
 8             if auth_type=="local":
 9                 username = input('Username:').strip()
10                 password = input('Password:').strip()
11                 if user == username and passwd == password:
12                     print("\033[32;1mUser has passed authentication\033[0m")
13                     res = func(*args, **kwargs)  # from home
14                     print("---after authentication")
15                     return res
16                 else:
17                     exit('"\033[32;1mInwalid username or password\033[0m"')
18             elif auth_type=="ldap":
19                 print("ldap,搞毛线!")
20         return wrapper
21     return outer_wrapper
22 
23 def index():
24     print("welcom to index page")
25 @auth(auth_type="local") #home=wrapper()
26 def home():
27     print("welcom to home page")
28     return "from home"
29 @auth(auth_type="ldap")
30 def bbs():
31     print("welcom to bbs page")
32 index()
33 print(home()) #wrapper
34 bbs()

Iterator竟然足以代表二个Infiniti大的数据流,例如全部自然数。而采纳list是永久不容许存款和储蓄全体自然数的。

还可透过yield完成在单线程的动静下降成并发运算的功效。

  1 print(all([1,-5,3])) #True
  2 print(any([0,-5,3])) #True
  3 print(any([])) #False
  4 #ascii()没什么用
  5 print(bin(255)) #0b11111111 把数字十进制转二进制
  6 print(bool(0)) #返回布尔值
  7 
  8 a=bytes("abcd",encoding="utf-8")
  9 print(a.capitalize(),a) #字符串不可以修改,字节更不可以修改,只能生成新的
 10 
 11 #改二进制
 12 b=bytearray("abcd",encoding="utf-8")
 13 print(b[1])
 14 b[1]=50 #ascii码中的50--->2
 15 print(b)
 16 
 17 #可否调用
 18 def func():
 19     pass
 20 print(callable([])) #False
 21 print(callable(func)) #True
 22 
 23 print(chr(98))  #ascii码中的98--->b
 24 print(ord("b")) # b--->ascii码中的98
 25 
 26 #classmethod #类方法,以后讲
 27 
 28 #compile() #基本用不到,底层,把代码进行编译的过程。
 29 code= "for i in range(10):print(i)"
 30 #c=compile(code,'',"exec")
 31 exec(code)
 32 #complex()  复数...
 33 #delattr() 有用,面向对象的时候再讲
 34 print(dict(a=2))#生成字典
 35 
 36 a={}
 37 print(dir(a))#打印字典a的所有"方法"
 38 
 39 print(divmod(5,3)) #--->(1,2) 1是商,2是余数
 40 
 41 # enumerate()
 42 # eval()
 43 # exec
 44 
 45 #匿名函数
 46 def sayhi(n):
 47     print(n)
 48 sayhi(3)
 49 # (lambda  n:print(n))(5)
 50 calc=lambda  n:print(n) #只能写三元运算
 51 calc(5)
 52 print("-----")
 53 
 54 #res=filter(lambda n:n>5,range(10)) #筛选
 55 #res=map(lambda  n:n*2,range(10))
 56 # for i in res:
 57 #     print(i)
 58 import functools
 59 res=functools.reduce(lambda x,y:x+y,range(1,10))
 60 print(res)  #45
 61 
 62 # float
 63 # format()
 64 #a=frozenset([1,4,333,212,33,33,12,4]) #不可变集合,列表
 65 #getattr #面向对象时讲
 66 print(globals()) #返回的是当前整个程序所有变量的key-value格式
 67 print(hash("jyh")) #将对象转化为固定的值,对于算法,很有用,见上图。
 68 #help()
 69 print(hex(23))#把一个数字转化为16进制
 70 # id()、# input()、# int()、# isinstance()、# issubclass()、#iter()、#len()
 71 def test():
 72     local_var=333
 73     print(locals())
 74     print(globals())
 75 test()
 76 print(globals()) #只打印全局变量
 77 print(globals().get("local_var"))
 78 #max(),min(),next(),object  python中世间万物皆为对象,对象有属性,有功能,通过.调用
 79 print(oct(8) ) #转8进制
 80 # open(),ord(),print(),range()
 81 print(pow(2,8)) # 2的8次方
 82 # property #以后讲
 83 #repr() #没什么用
 84 #reversed()
 85 print(round(1.3342,3))#保留小数点后"2"(或其他)位
 86 #setattr 重要,后面讲
 87 #slice 忘记吧
 88 
 89 a={6:2,8:0,1:4,-5:6,99:11,4:22}
 90 print(sorted(a.items())) #默认按key排序 [(-5, 6), (1, 4), (4, 22), (6, 2), (8, 0), (99, 11)]
 91 print(sorted(a.items(),key=lambda x:x[1])) #[(8, 0), (6, 2), (1, 4), (-5, 6), (99, 11), (4, 22)]
 92 #@staticmethod  后面讲
 93 #sum() 求和,super() 后面讲
 94 #vars()#返回对象的所有属性名,用不到
 95 
 96 a=[1,2,3,4,5,6]
 97 b=["a","b","c","d"]
 98 for i in zip(a,b):  #按个数最小的来
 99     print(i)
100 
101 __import__("decorator_")#与import decorator_一样,很有用

listdictstrIterable变成Iterator可以运用iter()函数:

 

  • ### 小结

关于README的内容

以此小编觉得是各样品种都应该有的四个文书,指标是能不难描述该类型的音讯,让读者相当的慢掌握这么些类型。

它须求证实以下多少个事项:

  1. 软件定位,软件的基本作用。
  2. 运作代码的主意: 安装环境、运转命令等。
  3. 总结的施用表明。
  4. 代码目录结构表达,更详细点能够印证软件的基本原理。
  5. 科学普及难点求证。

本人觉着有上述几点是相比较好的三个README。在软件开发初期,由于开发进程中上述内容大概不显然可能产生变化,并不是迟早要在1初步就将装有消息都补全。可是在档次扫尾的时候,是内需写作那样的三个文书档案的。

可以参考Redis源码中Readme的写法,那中间简洁可是清晰的讲述了Redis作用和源码结构。

json_fanxuliehua2

只有一个__next__()方法。 “next()” in python2.x

起名 42起名 43

起名 44起名 45

那是因为Python的Iterator对象表示的是三个数据流,Iterator对象足以被next()函数调用并连发再次回到下一个数量,直到未有数量时抛出StopIteration谬误。能够把那么些数据流看做是3个稳步连串,但我们却无法提前知道连串的长短,只好不停经过next()函数实现按需计算下三个数码,所以Iterator的总括是惰性的,唯有在急需回到下三个数量时它才会总结。

起名 46起名 47

起名 48

  • ### 软件目录结构正式
  1. 可读性高:
    不熟悉那些类其他代码的人,壹眼就能看懂目录结构,知道程序运转脚本是哪位,测试目录在哪儿,配置文件在何地之类。从而丰裕便捷的精通那个类型。
  2. 可维护性高:
    定义好社团规则后,维护者就能很鲜明地领略,新增的哪位文件和代码应该置身怎么样目录之下。这一个利益是,随着年华的延期,代码/配置的范围追加,项目组织不会混杂,照旧能够组织优良。
 1 import pickle
 2 
 3 def sayhi(name):
 4     print("hello,",name)
 5 info={
 6     "name":"jyh",
 7     "age":24,
 8     "func":sayhi
 9 }
10 
11 f=open("test.text","wb")
12 #print(json.dumps(info))
13 f.write(pickle.dumps(info))
14 f.close()

 

 1 import json
 2 info={
 3     "name":"jyh",
 4     "age":24
 5 }
 6 
 7 f=open("test.text","r")
 8 data=json.loads(f.read())  #用load反序列化
 9 print(data["age"])
10 f.close()

生成器都以Iterator对象,但listdictstr虽然是Iterable,却不是Iterator

只记录当前岗位

起名 49起名 50

  • ### 列表生成式

起名 51

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

起名 52起名 53

 1 def fib(max): #10
 2     n, a, b = 0, 0, 1
 3     while n < max:
 4         #print(b)
 5         yield b  #生成器
 6         a, b = b, a + b
 7         n = n + 1
 8     return 'done' #处理异常,返回值
 9 f=fib(10)
10 print(f.__next__())
11 print(f.__next__())
12 print(f.__next__())
13 print(f.__next__())
14 # 注意,赋值语句:
15 # a, b = b, a + b
16 # 相当于:
17 # t = (b, a + b) # t是一个tuple
18 # a = t[0]
19 # b = t[1]
20 # 但不必显式写出临时变量t就可以赋值
21 # 仔细观察,可以看出,fib函数实际上是定义了斐波拉契数列的推算规则,可以从第一个元素开始,推算出后续任意的元素,这种逻辑其实非常类似generator。
22 # 也就是说,上面的函数和generator仅一步之遥。要把fib函数变成generator,只需要把print(b)改为yield b就可以了:
23 
24 print("===start loop===")
25 for i in f:
26     print(i)

起名 54起名 55

“设计项目目录结构”,就和”代码编码风格”一样,属于个人风格难题。对于那种作风上的专业,一直都存在二种态度:

 1 x=0
 2 def grandpa():
 3     # x=1
 4     def dad():
 5         x=2
 6         def son():
 7             x=3
 8             print(x)
 9         son()
10     dad()
11 grandpa()
 1 import json #json用于与java,c等不同语言(简单类型--列表,字典,字符串。函数不行)数据交互,取代xml
 2 #序列化:把内存的数据对象变成字符串存到硬盘上
 3 
 4 def sayhi(name):
 5     print("hello,",name)
 6 info={
 7     "name":"jyh",
 8     "age":24,
 9     "func":sayhi
10 }
11 
12 f=open("test.text","w")
13 #print(json.dumps(info))
14 f.write(json.dumps(info))  #用dumps序列化
15 f.close()

json_xuliehua

起名 56起名 57

2:重返值中包蕴函数名(不改动函数的调用方式)

装饰器1

  • json,用于字符串 和 python数据类型间开始展览转换
  • pickle,用于python特有的类型 和 python的数据类型间开始展览转换

起名 58起名 59

起名 60

起名 61

起名 62

发表评论

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

网站地图xml地图