精华内容
下载资源
问答
  • 所谓必经之路,每一条都是不可或缺的。这里也就是给大家指个,等你真正上路了,会发现路上有花有草有风景,有风有雾...5、了解时钟的概念,什么是占空比,抖动和偏斜等,时钟就像FPGA的真气,所有的功力都是真气...

    所谓必经之路,每一条都是不可或缺的。这里也就是给大家指个路,等你真正上路了,会发现路上有花有草有风景,有风有雾还有坑!看似每条只有简单几句,其实都要用心去看资料,去理解,去实践。花花草草的你自己去欣赏,遇到绕不过去的坑,要自己淌一淌,实在淌不过去,你来找我,抽空可以扶你一把。

    废话不多说了,继续往下写:

    5、了解时钟的概念,什么是占空比,抖动和偏斜等,时钟就像FPGA的真气,所有的功力都是真气推动的,这真气如何练就,你要清楚。另外,真气是如何促使发功的,也就是时钟和逻辑之间的关系,要搞清楚。

    找你选择的那款FPGA,有针对这款FPGA所在系列的时钟资源的说明文档,最好细细读一遍,理解时钟在FPGA内部是如何运行的,有哪些时钟资源可以利用。

    6、了解建立保持时间的概念,能用图画出来讲给别人听才算理解。对于FPGA和其他器件之间的接口连接采样的稳定性,建立保持时间是至关重要的。FPGA内部的时序也和这个有关,相同时钟下的逻辑如何处理,跨时钟的逻辑如何处理,都是很关键的。

    7、如果上面你都理解了,找个开发板上最简单的例程跑一跑,就是类似于计数器的点灯实验,看了这么多资料,真气憋了这么久,总要打一拳看看对吧,看板子上的LED灯忽闪忽闪的,你终于知道真气催动的小拳拳是干嘛用的了。

    8、了解简单慢速串行接口的时序和协议,比如SPI、I2C,建议从SPI开始,找个有SPI驱动芯片的FPGA开发板练个手,读写操作来一波。

    哦,对了,你写的代码到底能不能用,功能正不正常,上板调试之前要仿真下的哦,仿真啥的下次再讲...

    展开全文
  • 题意:N个点,M条,每条路的危险度为路上各段中最大危险度。...那不管选择哪个边,对于分别位于两个连通块两点来说,这条边都是必经之路,而这个必经之路是这两点路径危险度中最大,起...

    题意:N个点,M条路,每条路的危险度为路上各段中最大的危险度。多组询问,点s到点t的所有路径中最小的危险度。

    分析:

    1、首先建个最小生成树,则s到t的路径一定是危险度最小的。

    原因:建最小生成树的最后一步,如果有两个相等的边可以选择,然后将两个连通块连在一起。

    那不管选择哪个边,对于分别位于两个连通块的两点来说,这条边都是必经之路,而这个必经之路是这两点路径的危险度中最大的,起决定作用,所以选哪个是一样的。

    2、利用lca,在找s和t最近公共祖先的过程中,不断取两者路径中的最大危险度即可。

    3、d[k][v] 为点v到它向上走2k步所到的顶点的路径中最大的危险度。

    #include<cstdio>
    #include<cstring>
    #include<cstdlib>
    #include<cctype>
    #include<cmath>
    #include<iostream>
    #include<sstream>
    #include<iterator>
    #include<algorithm>
    #include<string>
    #include<vector>
    #include<set>
    #include<map>
    #include<stack>
    #include<deque>
    #include<queue>
    #include<list>
    #define lowbit(x) (x & (-x))
    const double eps = 1e-8;
    inline int dcmp(double a, double b){
        if(fabs(a - b) < eps) return 0;
        return a > b ? 1 : -1;
    }
    typedef long long LL;
    typedef unsigned long long ULL;
    const int INT_INF = 0x3f3f3f3f;
    const int INT_M_INF = 0x7f7f7f7f;
    const LL LL_INF = 0x3f3f3f3f3f3f3f3f;
    const LL LL_M_INF = 0x7f7f7f7f7f7f7f7f;
    const int dr[] = {0, 0, -1, 1, -1, -1, 1, 1};
    const int dc[] = {-1, 1, 0, 0, -1, 1, -1, 1};
    const int MOD = 1e9 + 7;
    const double pi = acos(-1.0);
    const int MAXN = 50000 + 10;
    const int MAXT = 100000 + 10;
    using namespace std;
    struct Node{
        int a, b;
        Node(int aa, int bb):a(aa), b(bb){}
    };
    int N, M;
    int fa[MAXN];
    int d[20][MAXN];
    int depth[MAXN];
    int parent[20][MAXN];
    vector<Node> G[MAXN];
    int Find(int x){
        return fa[x] = (fa[x] == x) ? x : Find(fa[x]);
    }
    struct Edge{
        int x, y, d;
        void read(){
            scanf("%d%d%d", &x, &y, &d);
        }
        bool operator < (const Edge& rhs)const{
            return d < rhs.d;
        }
    }num[MAXT];
    void kruskal(){
        for(int i = 0; i < M; ++i){
            int tmpx = Find(num[i].x);
            int tmpy = Find(num[i].y);
            if(tmpx == tmpy) continue;
            G[num[i].x].push_back(Node(num[i].y, num[i].d));
            G[num[i].y].push_back(Node(num[i].x, num[i].d));
            if(tmpx < tmpy) fa[tmpy] = tmpx;
            else fa[tmpx] = tmpy;
        }
    }
    void dfs(int v, int fa, int deep){
        parent[0][v] = fa;
        depth[v] = deep;
        int len = G[v].size();
        for(int i = 0; i < len; ++i){
            if(G[v][i].a != fa){
                d[0][G[v][i].a] = G[v][i].b;
                dfs(G[v][i].a, v, deep + 1);
            }
        }
    }
    void LCA_init(){
        dfs(1, -1, 0);
        for(int k = 0; k + 1 < 20; ++k){
            for(int v = 1; v <= N; ++v){
                if(parent[k][v] < 0) parent[k + 1][v] = -1;
                else{
                    parent[k + 1][v] = parent[k][parent[k][v]];
                    d[k + 1][v] = max(d[k][v], d[k][parent[k][v]]);
                }
            }
        }
    }
    int lca(int u, int v){
        int ans = 0;
        if(depth[u] > depth[v]) swap(u, v);
        for(int k = 0; k < 20; ++k){
            if(((depth[v] - depth[u]) >> k) & 1){
                ans = max(ans, d[k][v]);
                v = parent[k][v];
            }
        }
        if(u == v) return ans;
        for(int k = 19; k >= 0; --k){
            if(parent[k][u] != parent[k][v]){
                ans = max(ans, d[k][u]);
                ans = max(ans, d[k][v]);
                u = parent[k][u];
                v = parent[k][v];
            }
        }
        ans = max(ans, d[0][u]);
        ans = max(ans, d[0][v]);
        return ans;
    }
    int main(){
        bool flag = true;
        while(scanf("%d%d", &N, &M) == 2){
            memset(parent, -1, sizeof parent);
            memset(d, 0, sizeof d);
            memset(depth, 0, sizeof depth);
            for(int i = 1; i < MAXN; ++i){
                fa[i] = i;
                G[i].clear();
            }
            for(int i = 0; i < M; ++i){
                num[i].read();
            }
            sort(num, num + M);
            kruskal();
            LCA_init();
            int Q;
            scanf("%d", &Q);
            if(flag) flag = false;
            else printf("\n");
            while(Q--){
                int s, t;
                scanf("%d%d", &s, &t);
                printf("%d\n", lca(s, t));
            }
        }
        return 0;
    }
    

      

    转载于:https://www.cnblogs.com/tyty-Somnuspoppy/p/7410927.html

    展开全文
  • 设计模式程序员进阶的必经之路,这也的必经之路,也许大家当初为了面试所需强记过一些设计模式名字,像单例模式,工厂模式,策略模式,观察者模式,代理模式,适配器模式,命令模式等等。我当初就是知其然...

    设计模式是程序员进阶的必经之路,这也是我的必经之路,也许大家当初为了面试所需都强记过一些设计模式的名字,像单例模式,工厂模式,策略模式,观察者模式,代理模式,适配器模式,命令模式等等。我当初就是知其然不知其所以然,现在决定把设计模式都认真学习一遍,没有代码量是不可能成功的,所以在学习过程中,记录下所有代码。见证成长。

    那么先从最简单的工厂模式开始,工厂模式,顾名思义就是生产实例的工厂。也就是在设计层中同一层有过多的相似功能的类,就可以使用工厂类来简化实例。

    举个例子(安卓的代码),很简单的一个计算器程序,很多在校大学生或者玩过代码的初高中生都能编出来。

    对于该需求,先将业务逻辑和界面逻辑分层。界面逻辑在该需求中并不复杂,所以没必要在细分。

    业务逻辑可以继续细分,计算器的逻辑中将可变和不可变的部分进行分层,不可变的共有的放在父类,也就是两个进行计算的参数

    图示:


    public abstract class Operation {
        private double numA;
        private double numB;
    
    
        public double getNumA() {
            return numA;
        }
    
        public void setNumA(double numA) {
            this.numA = numA;
        }
    
        public double getNumB() {
            return numB;
        }
    
        public void setNumB(double numB) {
            this.numB = numB;
        }
    
    
        public double getResultMoney(){
            return 0;
        }
    }
    
    然后就是对计算父类进行继承,这里分层最主要是考虑用户需求的改变,比如再添一个开方,根号的计算,分层有利于提高代码的可扩展性。

    public class OperationAdd extends Operation {
        @Override
        public double getResultMoney() {
            return getNumA()+getNumB();
        }
    }
    计算逻辑分层好了之后,就可以在计算具体实现(加减乘除)这个层加一个工厂类,根据需求提供不同实例,用父类的引用来接受,这样可以进一步简化代码。

    public class OperationFactory {
        public static Operation createOperation(int flag,Context context){
            Operation operation = null;
            switch (flag){
                case 0:
                    operation = new OperationAdd();
                    break;
                case 1:
                    operation = new OperationSub();
                    break;
                case 2:
                    operation = new OperationMul();
                    break;
                case 3:
                    operation = new OperationDiv(context);
                    break;
            }
            return operation;
        }
    }
    具体使用就在自定义的控件了。这里的operation使用多态,提高代码的可复用性。

     case R.id.calwait:
                            numB = Double.parseDouble(textView.getText().toString());
                            stringBuilder.delete(0, stringBuilder.length());
                            Operation operation = OperationFactory.createOperation(flag,context);
                            operation.setNumA(numA);
                            operation.setNumB(numB);
                            double result = operation.getResultMoney();
                            textView.setText(String.valueOf(result));
                            break;
    自定义的计算器控件

    package com.abings.factorymodel.Calcumater;
    
    import android.content.Context;
    import android.util.AttributeSet;
    import android.view.LayoutInflater;
    import android.view.View;
    import android.widget.Button;
    import android.widget.LinearLayout;
    import android.widget.TextView;
    
    import com.abings.factorymodel.Operation.Operation;
    import com.abings.factorymodel.Operation.OperationFactory;
    import com.abings.factorymodel.R;
    
    /**
     * Created by Shuwen on 2016/8/24.
     */
    public class CalcumateView extends LinearLayout {
    
        private TextView textView;
        final StringBuilder stringBuilder = new StringBuilder();
        private Context context;
        private double numA;
        private double numB;
        private Button[]btns = new Button[18];
        //尽可能的使代码简化
        private int[]nums = new int[]{R.id.num0,R.id.num1,R.id.num2,R.id.num3,R.id.num4
                ,R.id.num5,R.id.num6,R.id.num7,R.id.num8,R.id.num9,R.id.caladd,R.id.calsub
                ,R.id.calmul,R.id.caldiv,R.id.calwait,R.id.clearall,R.id.delete,R.id.numdot};
        private int flag = 0;
        public CalcumateView(Context context) {
            this(context,null);
        }
    
        public CalcumateView(Context context, AttributeSet attrs) {
            this(context, attrs, 0);
        }
    
        public CalcumateView(Context context, AttributeSet attrs, int defStyleAttr) {
            super(context, attrs, defStyleAttr);
            this.context = context;
            LayoutInflater.from(context).inflate(R.layout.calculater, this);
            initViews();
            setEvents();
        }
    
        private void setEvents() {
            //数字,加减乘除
            for (int i = 0; i < nums.length; i++) {
                setNumOnclick(btns[i]);
            }
        }
    
        public void setNumOnclick(final Button button){
            button.setOnClickListener(new OnClickListener() {
                @Override
                public void onClick(View v) {
                    switch (v.getId()){
                        case R.id.caladd:
                            numA = Double.parseDouble(textView.getText().toString());
                            stringBuilder.delete(0,stringBuilder.length());
                            flag = 0;
                            textView.setText(stringBuilder);
                            break;
                        case R.id.calsub:
                            numA = Double.parseDouble(textView.getText().toString());
                            stringBuilder.delete(0,stringBuilder.length());
                            flag = 1;
                            textView.setText(stringBuilder);
                            break;
                        case R.id.calmul:
                            numA = Double.parseDouble(textView.getText().toString());
                            stringBuilder.delete(0,stringBuilder.length());
                            flag = 2;
                            textView.setText(stringBuilder);
                            break;
                        case R.id.caldiv:
                            numA = Double.parseDouble(textView.getText().toString());
                            stringBuilder.delete(0,stringBuilder.length());
                            flag = 3;
                            textView.setText(stringBuilder);
                            break;
                        case R.id.calwait:
                            numB = Double.parseDouble(textView.getText().toString());
                            stringBuilder.delete(0, stringBuilder.length());
                            Operation operation = OperationFactory.createOperation(flag,context);
                            operation.setNumA(numA);
                            operation.setNumB(numB);
                            double result = operation.getResultMoney();
                            textView.setText(String.valueOf(result));
                            break;
                        case R.id.clearall:
                            stringBuilder.delete(0, stringBuilder.length());
                            textView.setText(stringBuilder);
                            break;
                        case R.id.delete:
                            int len = stringBuilder.length() - 1 > 0?stringBuilder.length() - 1:0;
                            stringBuilder.delete(len, stringBuilder.length());
                            textView.setText(stringBuilder);
                            break;
                        default:
                            stringBuilder.append(button.getText());
                            textView.setText(stringBuilder);
                            break;
                    }
                }
            });
        }
    
        private void initViews() {
            for (int i = 0;i < nums.length;i++){
                btns[i] = (Button) findViewById(nums[i]);
            }
            textView = (TextView) findViewById(R.id.text);
        }
    
    
    }
    
    这篇博客最主要是介绍工厂模式,好了。工厂模式还是相当简单明了易上手。

    最后附上项目git:(在新的网页打开)

    https://github.com/SingleShu/FactoryModel






    展开全文
  • 我终于学会了使用python操作postgresql

    千次阅读 2020-01-21 15:50:41
    所有的弯路都是必经之路,虽然我已指明前

    一 前言

    这篇文章不仅适合pgsql,更适合mysql,思路都是一致的,如果读者学会使用psycopg2操作pgsql,那么使用PyMySQL 操作mysql也是很简单;本篇文章涵盖内容广泛,提供的操作选择性很多,比如多种数据插入操作,防止sql注入方式,异常处理,sql语句打印处理,显示行号等操作,一篇文章真的收益匪浅;觉得知识追寻者文章不错,随手点赞谢谢。如果看了作者文章有收获,不关注都是耍流氓。

    二 数据库连接

    2.1 安装 psycopg2

    #  pip install psycopg2
    

    2.2 连接数据库

    每条完整的sql执行步骤如下,读者应谨记;

    1. 建立连接获得 connect 对象
    2. 获得游标对象,一个游标对象可以对数据库进行执行操作,非线程安全,多个应用会在同一个连接种创建多个光标;
    3. 书写sql语句
    4. 调用execute()方法执行sql
    5. 抓取数据(可选操作)
    6. 提交事物
    7. 关闭连接
    # -*- coding: utf-8 -*-
    import psycopg2
    # 获得连接
    conn = psycopg2.connect(database="python", user="postgres", password="123456", host="127.0.0.1", port="5432")
    # 获得游标对象
    cursor = conn.cursor()
    # sql语句
    sql = "SELECT VERSION()"
    # 执行语句
    cursor.execute(sql)
    # 获取单条数据.
    data = cursor.fetchone()
    # 打印
    print("database version : %s " % data)
    # 事物提交
    conn.commit()
    # 关闭数据库连接
    conn.close()
    

    输出结果打印出数据库版本说明连接数据库成功:

    database version : PostgreSQL 11.3, compiled by Visual C++ build 1914, 64-bit 
    

    三 创建表

    创建学生表主要有字段id 唯一标识,字段 num 代表学号,字段 name 代表学生姓名;详细的建表默认规则转换见附录

    # -*- coding: utf-8 -*-
    import psycopg2
    # 获得连接
    conn = psycopg2.connect(database="python", user="postgres", password="123456", host="127.0.0.1", port="5432")
    # 获得游标对象,一个游标对象可以对数据库进行执行操作
    cursor = conn.cursor()
    # sql语句 建表
    sql = """CREATE TABLE student (
    id serial4 PRIMARY KEY, 
    num int4,
    name varchar(25));"""
    # 执行语句
    cursor.execute(sql)
    print("student table created successfully")
    # 事物提交
    conn.commit()
    # 关闭数据库连接
    conn.close()
    

    四 插入操作

    4.1 插入数据姿势一

    知识追寻者提供的第一种防止sql注入的插入数据方式(具有占位符的预编译sql),重要程度不言而喻;美中不足是字符串类型必须带上单引号;

    # -*- coding: utf-8 -*-
    import psycopg2
    # 获得连接
    conn = psycopg2.connect(database="python", user="postgres", password="123456", host="127.0.0.1", port="5432")
    # 获得游标对象,一个游标对象可以对数据库进行执行操作
    cursor = conn.cursor()
    # sql语句 建表
    sql ="INSERT INTO student (num, name) \
                        VALUES (%s, '%s')" % \
                        (100, 'zszxz')
    # 执行语句
    cursor.execute(sql)
    print("successfully")
    # 事物提交
    conn.commit()
    # 关闭数据库连接
    conn.close()
    

    4.2 插入数据姿势二(参数分离)

    知识追寻者认为下面参数与sql语句分离插入的姿势更简便帅气,也是防止sql注入问题;强烈推荐;

    # -*- coding: utf-8 -*-
    import psycopg2
    # 获得连接
    conn = psycopg2.connect(database="python", user="postgres", password="123456", host="127.0.0.1", port="5432")
    # 获得游标对象,一个游标对象可以对数据库进行执行操作
    cursor = conn.cursor()
    # sql语句 建表
    sql ="""INSERT INTO student (num, name) VALUES (%s, %s)"""
    params = (101, 'zszxz')
    # 执行语句
    cursor.execute(sql,params)
    print("successfully")
    # 事物提交
    conn.commit()
    # 关闭数据库连接
    conn.close()
    

    4.3 插入数据姿势三(字典)

    第三种姿势也就是是支持字典映射关系插入,使用字典方式的插入数据是根据字典的key进行匹配占位符,强烈推荐;

    # -*- coding: utf-8 -*-
    import psycopg2
    # 获得连接
    conn = psycopg2.connect(database="python", user="postgres", password="123456", host="127.0.0.1", port="5432")
    # 获得游标对象,一个游标对象可以对数据库进行执行操作
    cursor = conn.cursor()
    # sql语句 建表
    sql ="""INSERT INTO student (num, name) VALUES (%(num)s, %(name)s)"""
    params = {'num':102, 'name':'zszxz'}
    # 执行语句
    cursor.execute(sql,params)
    print("successfully")
    # 事物提交
    conn.commit()
    # 关闭数据库连接
    conn.close()
    

    五 查询操作

    5.1 查询一条数据

    使用fetchone()方法可以抓取一条数据, 返回的是元组;

    # -*- coding: utf-8 -*-
    import psycopg2
    # 获得连接
    conn = psycopg2.connect(database="python", user="postgres", password="123456", host="127.0.0.1", port="5432")
    # 获得游标对象,一个游标对象可以对数据库进行执行操作
    cursor = conn.cursor()
    # sql语句 建表
    sql ="""SELECT * FROM student;"""
    # 执行语句
    cursor.execute(sql)
    # 抓取
    row = cursor.fetchone()
    print(row)
    # 事物提交
    conn.commit()
    # 关闭数据库连接
    cursor.close()
    conn.close()
    

    输出结果:

    (1, 100, 'zszxz')
    

    5.2 查询多条数据

    1. 使用fetchmany([size=cursor.arraysize])方法可以抓取多条数据;
    2. 此方法可以多次使用,直到数据库中没有数据,此时会返回空列表;
    3. 如果不传参数,会限制查询条数,一般就是返回第一条;
    # -*- coding: utf-8 -*-
    import psycopg2
    # 获得连接
    conn = psycopg2.connect(database="python", user="postgres", password="123456", host="127.0.0.1", port="5432")
    # 获得游标对象,一个游标对象可以对数据库进行执行操作
    cursor = conn.cursor()
    # sql语句 建表
    sql ="""SELECT * FROM student;"""
    # 执行语句
    cursor.execute(sql)
    # 抓取
    #row = cursor.fetchone()
    rows = cursor.fetchmany(2)
    print(rows)
    # 事物提交
    conn.commit()
    # 关闭数据库连接
    cursor.close()
    conn.close()
    

    输出结果:

    [(1, 100, 'zszxz'), (2, 101, 'zszxz')]
    

    5.3 查询全部数据

    使用 fetchall() 方法会抓取所有数据;

    # -*- coding: utf-8 -*-
    import psycopg2
    # 获得连接
    conn = psycopg2.connect(database="python", user="postgres", password="123456", host="127.0.0.1", port="5432")
    # 获得游标对象,一个游标对象可以对数据库进行执行操作
    cursor = conn.cursor()
    # sql语句 建表
    sql ="""SELECT * FROM student;"""
    # 执行语句
    cursor.execute(sql)
    # 抓取
    rows = cursor.fetchall()
    print(rows)
    # 事物提交
    conn.commit()
    # 关闭数据库连接
    cursor.close()
    conn.close()
    

    输出结果:

    [(1, 100, 'zszxz'), (2, 101, 'zszxz'), (3, 102, 'zszxz')]
    

    5.4 按条件查询

    1. 带参查询读者应该谨记sql 与 参数 分离
    2. 参数的末尾必须加上逗号
    3. 如果知道返回的数据就一条使用fetchone()方法,如果无特殊要求,否则建议使用fetchall()方法
    # -*- coding: utf-8 -*-
    import psycopg2
    # 获得连接
    conn = psycopg2.connect(database="python", user="postgres", password="123456", host="127.0.0.1", port="5432")
    # 获得游标对象,一个游标对象可以对数据库进行执行操作
    cursor = conn.cursor()
    # sql语句 建表
    sql ="""SELECT * FROM student where id = %s;"""
    params = (1,)
    # 执行语句
    cursor.execute(sql,params)
    # 抓取
    rows = cursor.fetchall()
    print(rows)
    # 事物提交
    conn.commit()
    # 关闭数据库连接
    cursor.close()
    conn.close()
    

    输出结果:

    [(1, 100, 'zszxz')]
    

    六 更新操作

    更新操作跟之前的查询,插入类似,参数对应的文章分清楚即可。

    # -*- coding: utf-8 -*-
    import psycopg2
    # 获得连接
    conn = psycopg2.connect(database="python", user="postgres", password="123456", host="127.0.0.1", port="5432")
    # 获得游标对象,一个游标对象可以对数据库进行执行操作
    cursor = conn.cursor()
    # sql语句 建表
    sql ="""update student set name = %s where id = %s  """
    params = ('知识追寻者',3,)
    # 执行语句
    cursor.execute(sql,params)
    # 事物提交
    conn.commit()
    # 关闭数据库连接
    cursor.close()
    conn.close()
    

    七 删除操作

    删除操作很简单,看如下代码,与之前的代码流程没什么区别;

    # -*- coding: utf-8 -*-
    import psycopg2
    # 获得连接
    conn = psycopg2.connect(database="python", user="postgres", password="123456", host="127.0.0.1", port="5432")
    # 获得游标对象,一个游标对象可以对数据库进行执行操作
    cursor = conn.cursor()
    # sql语句 建表
    sql ="""delete from  student where id = %s  """
    params = (3,)
    # 执行语句
    cursor.execute(sql,params)
    # 事物提交
    conn.commit()
    # 关闭数据库连接
    cursor.close()
    conn.close()
    

    八 异常处理

    处理 sql 的异常非常重要,知识追寻者这边使用psycopg2的 Error 进行异常捕获,能捕获到sql执行时期的所有异常;下面代码中表test是库中不存的表,执行sql后会报异常,经过异常捕获后非常美观,不影响程序运行;

    # -*- coding: utf-8 -*-
    import psycopg2
    # 获得连接
    conn = psycopg2.connect(database="python", user="postgres", password="123456", host="127.0.0.1", port="5432")
    # 获得游标对象,一个游标对象可以对数据库进行执行操作
    cursor = conn.cursor()
    # sql语句 建表
    sql ="""select * from test"""
    params = (3,)
    try:
        # 执行语句
        cursor.execute(sql,params)
    except psycopg2.Error as e:
        print(e)
    # 事物提交
    conn.commit()
    # 关闭数据库连接
    cursor.close()
    conn.close()
    

    执行结果

    错误:  关系 "test" 不存在
    LINE 1: select * from test
    

    九 打印sql

    使用cursor.query 可以查看执行的sql语句,方便排查;

    # -*- coding: utf-8 -*-
    import psycopg2
    # 获得连接
    conn = psycopg2.connect(database="python", user="postgres", password="123456", host="127.0.0.1", port="5432")
    # 获得游标对象,一个游标对象可以对数据库进行执行操作
    cursor = conn.cursor()
    # sql语句 建表
    sql ="""select * from student"""
    try:
        # 执行语句
        cursor.execute(sql,)
        que = cursor.query
        print(que)
    except psycopg2.Error as e:
        print(e)
    # 事物提交
    conn.commit()
    # 关闭数据库连接
    cursor.close()
    conn.close()
    

    执行结果:

    b'select * from student'
    

    十 获取总条数

    使用cursor.rowcount 可以获得表中所有行总数;

    # 获得连接
    conn = psycopg2.connect(database="python", user="postgres", password="123456", host="127.0.0.1", port="5432")
    # 获得游标对象,一个游标对象可以对数据库进行执行操作
    cursor = conn.cursor()
    # sql语句 建表
    sql ="""select * from student"""
    # 执行语句
    cursor.execute(sql)
    count = cursor.rowcount
    print(count)
    # 事物提交
    conn.commit()
    # 关闭数据库连接
    conn.close()
    

    输出

    2
    

    十一显示行号

    使用cursor.rownumber 可以显示当前查询sql获得数据的行号,每抓取一次光标的索引就会加1;

    # 获得连接
    conn = psycopg2.connect(database="python", user="postgres", password="123456", host="127.0.0.1", port="5432")
    # 获得游标对象,一个游标对象可以对数据库进行执行操作
    cursor = conn.cursor()
    # sql语句 建表
    sql ="""select * from student """
    # 执行语句
    cursor.execute(sql)
    row_1 = cursor.fetchone()
    print(cursor.rownumber)
    row_2 = cursor.fetchone()
    print(cursor.rownumber)
    # 事物提交
    conn.commit()
    # 关闭数据库连接
    conn.close()
    

    输出结果:

    1
    2
    

    十二 显示执行参数

    使用 mogrify(operation[, parameters]) 能够显示执行语句的参数绑定结果,返回的是字符串形式;

    # 获得连接
    conn = psycopg2.connect(database="python", user="postgres", password="123456", host="127.0.0.1", port="5432")
    # 获得游标对象,一个游标对象可以对数据库进行执行操作
    cursor = conn.cursor()
    # sql语句 建表
    sql ="""INSERT INTO student (num, name) VALUES (%s, %s)"""
    params = (102, '知识追寻者')
    # 执行语句
    result = cursor.mogrify(sql,params)
    print(result.decode('UTF-8'))
    cursor.execute(sql,params)
    # 事物提交
    conn.commit()
    # 关闭数据库连接
    conn.close()
    

    执行结果:

    INSERT INTO student (num, name) VALUES (102, '知识追寻者')
    

    十三 附录

    支持默认的类型转换如下,如果想要使用强制类型转换,详细的可以参照pgsql官网手册;

    Python PostgreSQL
    None NULL
    bool bool
    float realdouble
    intlong smallintintegerbigint
    Decimal numeric
    strunicode varchartext
    buffermemoryviewbytearraybytesBuffer protocol bytea
    date date
    time time,timetz
    datetime timestamp,timestamptz
    timedelta interval
    list ARRAY
    tuple,namedtuple Composite typesIN syntax
    dict hstore
    Range range
    UUID uuid
    Anything json
    ipaddress inet
    展开全文
  • 很多Android入门程序猿来说对于Android自定义View,可能都是比较恐惧,但是这又是高手进阶的必经之路所有准备在自定义View上面花一些功夫,多写一些文章。先总结下自定义View步骤: 1、自定义View属性 ...
  • 论前端开发复杂度

    2016-12-22 22:04:34
    之前读过七哥的《没事别随便思考人生》,比较贴近生活,比一般的鸡汤好喝一些,喝过能从中思考不少。这两天又在看《人生所有经过的路都是必经之路》,里面提到佛法...
  • Web应用开发周期

    千次阅读 2017-06-06 09:35:31
    后来发现,这条几乎是所有Web应用的必经之路。一个Web应用在其生命周期里,要经历搭建开发环境、创建构建系统、编写代码、进行数据分析等,直至最后使用新系统来替换这个遗留系统。如果你一个有经验开发者...
  • 在企业经营管理上对于数据收集与治理越来越重要,主数据治理作为数据治理中重要一环,数据决策分析、深度应用集成重要基础,也企业信息化建设的必经之路,并且这条越早走越好。当下很多企业已经认识到这...
  • 秋招之旅,打个总结

    2020-11-04 12:36:54
    每个人有每个人生活态度,有人选择考研就有人选择找工作,这两项无疑都是每一个即将毕业大学生的必经之路吧,或者还有少数人会去选择考公务员,当然这也是一个不错选择,但是竞争一样很大吧。所谓人生有梦,各自...
  • 我始终坚信: 软件开发中所有的准则都是来源于实践, 而实践也是驾驭软件开发的必经之路.我相信这一点就如我相信:"计算机史上先出现C语言, 再出现C++, 然后才出现Java是一种历史的必然"一样的坚定.“在人生的路上,有...

空空如也

空空如也

1 2
收藏数 22
精华内容 8
关键字:

所有的路都是必经之路