标签分类
当前位置:首页 > > Python电子书网盘下载
跟老齐学Python:轻松入门 跟老齐学Python:轻松入门
码小辫

码小辫 提供上传

资源
33
粉丝
49
喜欢
291
评论
2

    跟老齐学Python:轻松入门 PDF 高质量影印版

    Python电子书
    • 发布时间:

    给大家带来的一篇关于Python相关的电子书资源,介绍了关于老齐、Python、入门方面的内容,本书是由电子工业出版社出版,格式为PDF,资源大小46.6 MB,齐伟编写,目前豆瓣、亚马逊、当当、京东等电子书综合评分为:7.2

  • 跟老齐学Python:轻松入门 PDF 下载
  • 下载地址:https://pan.baidu.com/s/1QaowyjCRMLnycEauyXWpsQ
  • 分享码:m896
  • 读者评价

    学习python相当好的一本书,我是看了电子版才决定买了收藏的。

    非常基础,初学Python可以一看,这类书不论买谁的,有一本就足够了

    花了七天读完的,代码都敲了,总的来说,这本书还不错,是用python2.X写的,缺点是技术不够详细,文字略微啰嗦。适合初学者入门,不适合有Python基础的人,或者要学python 3.X的人。

    老齐python是对新手很友好的书,推荐老齐python是对新手很友好的书,推荐本人先看像计算机科学家一样思考Python (第2版),再看老齐的,对比起来觉得后者很友好,很轻松。不能说谁更好,应该要都看,各有亮点,各有长处。前者看完可以引导你写出个程序,有例子参考,有指导引导作用

    编辑推荐

    零基础:专注于入门,层层进阶,帮助读者轻松掌握Python基础知识;

    通俗易懂:轻松幽默,毫无做作、晦涩之感,让编程不枯燥、不乏味;

    深入浅出:指导读者理解Python编程思想,领略Python魅力,授之以渔。

    内容介绍

    Python是一种被广泛用于网站开发、数据处理和机器学习等领域的高级编程语言,同时也是一种学习门槛较低的高级编程语言。本书是Python语言的入门读物,旨在引导初学者能够在轻松的环境中,掌握Python的基础知识,包括基本对象类型、函数、类、模块以及数据存储方式。

    内容节选

    Python实现简单的四则运算计算器

    一、算法

         1、算法的主要思想就是将一个中缀表达式(Infix expression)转换成便于处理的后缀表达式(Postfix expression),然后借助于栈这个简单的数据结构,计算出表达式的结果。

         2、关于如何讲普通的表达式转换成后缀表达式,以及如何处理后缀表达式并计算出结果的具体算法描述不在此叙述了,书上有详细的说明。

    二、简易计算器

    使用说明

    使用该计算器类的简单示例如下:

    # usage
    c = Calculator()
    print('result: {:f}'.formart(c.get_result('1.11+2.22-3.33*4.44/5.55')))
    # output:
    result: 0.666000

    测试案例

    为了对这个计算器进行有效地检验,设计了几组测试案例,测试结果如下:

    Test No.1: (1.11) = 1.110000
    Test No.2: 1.11+2.22-3.33*4.44/5.55 = 0.666000
    Test No.3: 1.11+(2.22-3.33)*4.44/5.55 = 0.222000
    Test No.4: 1.11+(2.22-3.33)*(4.44+5.55)/6.66 = -0.555000
    Test No.5: 1.11*((2.22-3.33)*(4.44+5.55))/(6.66+7.77) = -0.852992
    Test No.6: (1.11+2.22)*(3.33+4.44)/5.55*6.66 = 31.048920
    Test No.7: (1.11-2.22)/(3.33+4.44)/5.55*(6.66+7.77)/(8.88) = -0.041828
    Test No.8: Error: (1.11+2.22)*(3.33+4.44: missing ")", please check your expression
    Test No.9: Error: (1.11+2.22)*3.33/0+(34-45): divisor cannot be zero
    Test No.10: Error: 12+89^7: invalid character: ^

    实现代码

    栈的实现

    栈实际上就是一个被限制操作的表,所有的操作只能在栈的顶端(入栈、出栈等),以下是使用Python代码实现的简单的栈:

    class Stack(object):
      """
      The structure of a Stack.
      The user don't have to know the definition.
      """
      def __init__(self):
        self.__container = list()
      def __is_empty(self):
        """
        Test if the stack is empty or not
        :return: True or False
        """
        return len(self.__container) == 0
      def push(self, element):
        """
        Add a new element to the stack
        :param element: the element you want to add
        :return: None
        """
        self.__container.append(element)
      def top(self):
        """
        Get the top element of the stack
        :return: top element
        """
        if self.__is_empty():
          return None
        return self.__container[-1]
      def pop(self):
        """
        Remove the top element of the stack
        :return: None or the top element of the stack
        """
        return None if self.__is_empty() else self.__container.pop()
      def clear(self):
        """
        We'll make an empty stack
        :return: self
        """
        self.__container.clear()
        return self

    计算器类的实现

    在计算器类中,我们将表达式的合法性验证单独放在一个函数中完成,但是实际上如果需要,也可以直接放在中缀表达式转后缀表达式的函数中实现,这样只需要一次遍历表达式即可同时完成验证和转换工作。但是为了保持结构清晰,还是分开来实现比较好,每个函数尽可能最好一件事情才是比较实在的。

    在该计算器类中,有很多种极端的情况没有被考虑进去,因为那样的话整个实现的代码会更多。不过,可以在后期为整个类继续扩展,添加新的功能也是可以的。目前实现的就是主要框架,包括基本的错误检测和运算,重点时学习运用栈这个看似简单却强大的数据结构解决问题。

    class Calculator(object):
      """
      A simple calculator, just for fun
      """
      def __init__(self):
        self.__exp = ''
      def __validate(self):
        """
        We have to make sure the expression is legal.
        1. We only accept the `()` to specify the priority of a sub-expression. Notes: `[ {` and `] }` will be
        replaced by `(` and `)` respectively.
        2. Valid characters should be `+`, `-`, `*`, `/`, `(`, `)` and numbers(int, float)
        - Invalid expression examples, but we can only handle the 4th case. The implementation will
        be much more sophisticated if we want to handle all the possible cases.:
          1. `a+b-+c`
          2. `a+b+-`
          3. `a+(b+c`
          4. `a+(+b-)`
          5. etc
        :return: True or False
        """
        if not isinstance(self.__exp, str):
          print('Error: {}: expression should be a string'.format(self.__exp))
          return False
        # Save the non-space expression
        val_exp = ''
        s = Stack()
        for x in self.__exp:
          # We should ignore the space characters
          if x == ' ':
            continue
          if self.__is_bracket(x) or self.__is_digit(x) or self.__is_operators(x) \
              or x == '.':
            if x == '(':
              s.push(x)
            elif x == ')':
              s.pop()
            val_exp += x
          else:
            print('Error: {}: invalid character: {}'.format(self.__exp, x))
            return False
        if s.top():
          print('Error: {}: missing ")", please check your expression'.format(self.__exp))
          return False
        self.__exp = val_exp
        return True
      def __convert2postfix_exp(self):
        """
        Convert the infix expression to a postfix expression
        :return: the converted expression
        """
        # highest priority: ()
        # middle: * /
        # lowest: + -
        converted_exp = ''
        stk = Stack()
        for x in self.__exp:
          if self.__is_digit(x) or x == '.':
            converted_exp += x
          elif self.__is_operators(x):
            converted_exp += ' '
            tp = stk.top()
            if tp:
              if tp == '(':
                stk.push(x)
                continue
              x_pri = self.__get_priority(x)
              tp_pri = self.__get_priority(tp)
              if x_pri > tp_pri:
                stk.push(x)
              elif x_pri == tp_pri:
                converted_exp += stk.pop() + ' '
                stk.push(x)
              else:
                while stk.top():
                  if self.__get_priority(stk.top()) != x_pri:
                    converted_exp += stk.pop() + ' '
                  else:
                    break
                stk.push(x)
            else:
              stk.push(x)
          elif self.__is_bracket(x):
            converted_exp += ' '
            if x == '(':
              stk.push(x)
            else:
              while stk.top() and stk.top() != '(':
                converted_exp += stk.pop() + ' '
              stk.pop()
        # pop all the operators
        while stk.top():
          converted_exp += ' ' + stk.pop() + ' '
        return converted_exp
      def __get_result(self, operand_2, operand_1, operator):
        if operator == '+':
          return operand_1 + operand_2
        elif operator == '-':
          return operand_1 - operand_2
        elif operator == '*':
          return operand_1 * operand_2
        elif operator == '/':
          if operand_2 != 0:
            return operand_1 / operand_2
          else:
            print('Error: {}: divisor cannot be zero'.format(self.__exp))
            return None
      def __calc_postfix_exp(self, exp):
        """
        Get the result from a converted postfix expression
        e.g. 6 5 2 3 + 8 * + 3 + *
        :return: result
        """
        assert isinstance(exp, str)
        stk = Stack()
        exp_split = exp.strip().split()
        for x in exp_split:
          if self.__is_operators(x):
            # pop two top numbers in the stack
            r = self.__get_result(stk.pop(), stk.pop(), x)
            if r is None:
              return None
            else:
              stk.push(r)
          else:
            # push the converted number to the stack
            stk.push(float(x))
        return stk.pop()
      def __calc(self):
        """
        Try to get the result of the expression
        :return: None or result
        """
        # Validate
        if self.__validate():
          # Convert, then run the algorithm to get the result
          return self.__calc_postfix_exp(self.__convert2postfix_exp())
        else:
          return None
      def get_result(self, expression):
        """
        Get the result of an expression
        Suppose we have got a valid expression
        :return: None or result
        """
        self.__exp = expression.strip()
        return self.__calc()
      """
      Utilities
      """
      @staticmethod
      def __is_operators(x):
        return x in ['+', '-', '*', '/']
      @staticmethod
      def __is_bracket(x):
        return x in ['(', ')']
      @staticmethod
      def __is_digit(x):
        return x.isdigit()
      @staticmethod
      def __get_priority(op):
        if op in ['+', '-']:
          return 0
        elif op in ['*', '/']:
          return 1

    目录

    • 第0章 预备 1
    • 0.1 关于Python的故事 1
    • 0.1.1 Python的昨天、今天和明天 1
    • 0.1.2 优雅的Python 2
    • 0.1.3 与其他语言比较 3
    • 0.1.4 《Python之禅》 3
    • 0.1.5 感谢Guido van Rossum 4
    • 0.2 从小工到专家 4
    • 0.2.1 Python的版本 5
    • 0.2.2 学习Python是否需要基础 5
    • 0.2.3 从小工到专家 5
    • 0.3 安装Python 7
    • 0.3.1 在Ubuntu系统中安装Python 7
    • 0.3.2 在Windows系统中安装Python 9
    • 0.3.3 在OS X系统中安装Python 10
    • 0.4 开发工具 10
    • 0.4.1 Hello,world 10
    • 0.4.2 集成开发环境 11
    • 0.4.3 Python的IDE 11
    • 第1章 基本对象类型 13
    • 1.1 数和四则运算 13
    • 1.1.1 数 14
    • 1.1.2 变量 16
    • 1.1.3 四则运算 17
    • 1.1.4 大整数 18
    • 1.1.5 浮点数 18
    • 1.2 除法 19
    • 1.2.1 整数除以整数 19
    • 1.2.2 异常的计算 19
    • 1.2.3 引用模块解决除法问题 20
    • 1.2.4 余数 21
    • 1.2.5 四舍五入 22
    • 1.3 常用数学函数和运算优先级 23
    • 1.3.1 使用math 23
    • 1.3.2 运算优先级 25
    • 1.4 一个简单的程序 26
    • 1.4.1 程序 26
    • 1.4.2 Hello,World 27
    • 1.4.3 解一道题目 28
    • 1.4.4 编译 30
    • 1.5 字符串 31
    • 1.5.1 初步认识字符串 31
    • 1.5.2 变量和字符串 33
    • 1.5.3 连接字符串 34
    • 1.5.4 Python转义符 36
    • 1.5.5 键盘输入 36
    • 1.5.6 原始字符串 38
    • 1.5.7 索引和切片 39
    • 1.5.8 字符串基本操作 41
    • 1.5.9 字符串格式化输出 44
    • 1.5.10 常用的字符串方法 47
    • 1.6 字符编码 51
    • 1.6.1 编码 52
    • 1.6.2 计算机中的字符编码 53
    • 1.6.3 Python字符编码 54
    • 1.7 列表 55
    • 1.7.1 定义 55
    • 1.7.2 索引和切片 56
    • 1.7.3 反转 58
    • 1.7.4 操作列表 59
    • 1.7.5 常用的列表函数 61
    • 1.7.6 比较列表和字符串 71
    • 1.7.7 列表和字符串转化 73
    • 1.8 元组 75
    • 1.8.1 定义 75
    • 1.8.2 索引和切片 76
    • 1.8.3 元组的用途 77
    • 1.9 字典 77
    • 1.9.1 创建字典 78
    • 1.9.2 访问字典的值 80
    • 1.9.3 基本操作 80
    • 1.9.4 字符串格式化输出 82
    • 1.9.5 字典的方法 82
    • 1.10 集合 90
    • 1.10.1 创建集合 90
    • 1.10.2 set的方法 92
    • 1.10.3 不变的集合 95
    • 1.10.4 集合运算 96
    • 第2章 语句和文件 100
    • 2.1 运算符 100
    • 2.1.1 算术运算符 100
    • 2.1.2 比较运算符 100
    • 2.1.3 逻辑运算符 102
    • 2.1.4 复杂的布尔表达式 104
    • 2.2 简单语句 105
    • 2.2.1 什么是语句 105
    • 2.2.2 import 105
    • 2.2.3 赋值语句 106
    • 2.3 条件语句 109
    • 2.3.1 if 109
    • 2.3.2 if ... elif ... else 110
    • 2.3.3 三元操作符 112
    • 2.4 for循环语句 112
    • 2.4.1 for循环 112
    • 2.4.2 从例子中理解for循环 113
    • 2.4.3 range(start,stop[, step]) 116
    • 2.4.4 并行迭代 120
    • 2.4.5 enumerate() 123
    • 2.4.6 列表解析 125
    • 2.5 while循环语句 126
    • 2.5.1 做猜数字游戏 127
    • 2.5.2 break和continue 129
    • 2.5.3 while...else 130
    • 2.5.4 for...else 131
    • 2.6 文件 131
    • 2.6.1 读文件 131
    • 2.6.2 创建文件 133
    • 2.6.3 使用with 135
    • 2.6.4 文件的状态 136
    • 2.6.5 read/readline/readlines 137
    • 2.6.6 读很大的文件 138
    • 2.6.7 seek 139
    • 2.7 初识迭代 140
    • 2.7.1 逐个访问 141
    • 2.7.2 文件迭代器 142
    • 第3章 函数 145
    • 3.1 函数的基本概念 145
    • 3.1.1 理解函数 146
    • 3.1.2 定义函数 147
    • 3.1.3 关于命名 150
    • 3.2 深入探究函数 153
    • 3.2.1 返回值 153
    • 3.2.2 函数中的文档 155
    • 3.2.3 函数的属性 156
    • 3.2.4 参数和变量 157
    • 3.2.5 参数收集 159
    • 3.3 函数对象 161
    • 3.3.1 递归 162
    • 3.3.2 传递函数 163
    • 3.3.3 嵌套函数 164
    • 3.3.4 初识装饰器 166
    • 3.3.5 闭包 168
    • 3.4 特殊函数 169
    • 3.4.1 lambda 170
    • 3.4.2 map 171
    • 3.4.3 reduce 173
    • 3.4.4 filter 174
    • 3.4.5 zip()补充 175
    • 3.5 命名空间 176
    • 3.5.1 全局变量和局部变量 176
    • 3.5.2 作用域 177
    • 3.5.3 命名空间 178
    • 第4章 类 181
    • 4.1 类的基本概念 181
    • 4.1.1 术语 181
    • 4.1.2 编写类 184
    • 4.2 编写简单的类 185
    • 4.2.1 创建类 185
    • 4.2.2 实例 187
    • 4.3 属性和数据 188
    • 4.3.1 类属性 188
    • 4.3.2 创建实例 190
    • 4.3.3 实例属性 192
    • 4.3.4 self的作用 194
    • 4.3.5 数据流转 195
    • 4.4 方法 196
    • 4.4.1 绑定方法和非绑定方法 196
    • 4.4.2 类方法和静态方法 198
    • 4.5 继承 201
    • 4.5.1 概念 201
    • 4.5.2 单继承 202
    • 4.5.3 调用覆盖的方法 205
    • 4.5.4 多重继承 206
    • 4.6 多态和封装 208
    • 4.6.1 多态 208
    • 4.6.2 封装和私有化 212
    • 4.7 定制类 214
    • 4.7.1 类和对象类型 214
    • 4.7.2 自定义对象类型 215
    • 4.8 黑魔法 219
    • 4.8.1 优化内存 219
    • 4.8.2 属性拦截 223
    • 4.9 迭代器 226
    • 4.10 生成器 229
    • 4.10.1 定义生成器 230
    • 4.10.2 yield 231
    • 第5章 错误和异常 233
    • 5.1 错误 233
    • 5.2 异常 233
    • 5.3 处理异常 236
    • 5.4 assert 242
    • 第6章 模块 244
    • 6.1 编写模块 244
    • 6.1.1 模块是程序 245
    • 6.1.2 模块的位置 246
    • 6.1.3 __all__在模块中的作用 248
    • 6.1.4 包和库 249
    • 6.2 标准库概述 250
    • 6.2.1 引用的方式 250
    • 6.2.2 深入探究 251
    • 6.2.3 帮助、文档和源码 252
    • 6.3 标准库举例:sys、copy 254
    • 6.3.1 sys 254
    • 6.3.2 copy 257
    • 6.4 标准库举例:OS 257
    • 6.4.1 操作文件:重命名、删除文件 258
    • 6.4.2 操作目录 260
    • 6.4.3 文件和目录属性 262
    • 6.4.4 操作命令 263
    • 6.5 标准库举例:堆 264
    • 6.5.1 基本知识 265
    • 6.5.2 heapq 267
    • 6.5.3 deque 269
    • 6.6 标准库举例:日期和时间 271
    • 6.6.1 calendar 271
    • 6.6.2 time 273
    • 6.6.3 datetime 277
    • 6.7 标准库举例:XML 279
    • 6.7.1 XML 279
    • 6.7.2 遍历查询 280
    • 6.7.3 编辑 283
    • 6.7.4 常用属性和方法总结 285
    • 6.8 标准库举例:JSON 286
    • 6.8.1 基本操作 286
    • 6.8.2 大JSON字符串 287
    • 6.9 第三方库 287
    • 6.9.1 安装第三方库 288
    • 6.9.2 举例:requests库 289
    • 第7章 操作数据 293
    • 7.1 将数据存入文件 293
    • 7.1.1 pickle 293
    • 7.1.2 shelve 294
    • 7.2 操作MySQL数据库 295
    • 7.2.1 概况 295
    • 7.2.2 安装 296
    • 7.2.3 运行 297
    • 7.2.4 安装PyMySQL 297
    • 7.2.5 连接数据库 298
    • 7.2.6 数据库表 300
    • 7.2.7 操作数据库 301
    • 7.3 操作MongoDB 306
    • 7.3.1 安装MongoDB 307
    • 7.3.2 启动 308
    • 7.3.3 安装pymongo 309
    • 7.3.4 连接 309
    • 7.3.5 编辑 310
    • 7.4 操作SQLite 314
    • 7.4.1 建立连接对象 314
    • 7.4.2 建立游标对象 315
    • 跋 318

    上一篇:Python从入门到项目实践  下一篇:教孩子学编程:Python语言版

    展开 +

    收起 -

    Python相关电子书
    学习笔记

    Copyright 2018-2019 xz577.com 码农之家

    版权责任说明