第一章 程序设计的基本方法

本章大纲

  1. 程序设计语言

  2. Python语言的概述

  3. Python开发环境配置

  4. 程序的基本编写方法

一、程序设计语言

程序设计语言也叫编程语言。计算机程序按照程序设计语言规则组织起来的一组计算机指令

程序设计语言发展经历了机器语言、汇编语言、高级语言的3个阶段

二、编译和解释

高级语言根据计算机执行机制的不同分为两类:静态语言和脚本语言,静态语言采用编译方式执行,脚本语言采用解释方式执行

编译是将源代码转换成目标代码的过程。源代码是高级语言代码,目标代码是机器语言代码,执行编译的计算机程序称为编译器

解释是将源代码逐句转换成目标代码同时逐句运行目标代码的过程。执行解释的计算机程序称为解释器

编译和解释的区别在于编译是一次性的翻译,一旦程序悲编译,不在需要编译程序或者源代码。解释则在每次程序运行时都需要解释器和源代码

采用编译方式执行的编程语言是静态语言,如C语言、Java等;采用解释方式执行的编程语言是脚本语言,如JavaScript语言、PHP语言等。Python语言是一种被广泛使用的高级通用脚本编程语言,采用解释方式执行,但他的解释器也保留了编译器的部分功能,随着程序运行,解释器也会生成一个完整的目标代码。

三、Python语言的诞生

2008年,Python3.x

四、Python开发环境的配置

手工选择矩形框内的“Add Python 3.5 to PATH”

Python解释器有两个重要的工具:

  • IDLE:Python集成开发环境,用来编写和调试Python代码

  • pip:Python第三方库安装工具,用来在当前计算机上安装第三方库

  • 五、Python的最小程序

    使用Python语言编写的Hello程序

      print("Hello World")

    ">>>"是Python语言运行环境的提示符

    六、Python程序的运行方式

    Python程序有两种运行方式:交互式和文件式

    1. 交互式利用Python解释器即时响应用户输入的代码,给出输出结果

    2. 文件式将Python程序写在一个或多个文件中,启动Python解释器批量执行文件中的代码。

      交互式一般用于调试少量代码,文件式是最常用的编程方式

    IDLE中快捷键

  • Ctrl+N:在IDLE交互界面下用来启动IDLE文件式编辑器

  • Atrl+3:在IDLE编辑器内注释选中区域文本

  • Atrl+4:在IDLE编辑器内,解除注释选中区域文本

  • F5:在IDLE编辑器内,执行Python程序

  • 七、IPO程序编写方法

    在程序设计中,每个程序都有统一的运算模式:输入数据、处理数据和输出数据。我们称为IPO程序设计方法

    输入(input):输入是一个程序的开始

    处理(Process):处理是程序对输入数据进行计算产生输出结果的过程

    输出(output):输出是程序展示运算结果的方式

    Python程序的特点

    Python语言是一种被广泛使用的高级通用脚本编程语言,具有很多区别于其他语言的特点

    第二章 Python语言基本语法元素

    本章大纲

    1. 基本语法元素

    2. 基本输入输出

    3. 源程序书写风格

    一、基本的语法元素

    1.缩进

    Python语言采用严格的“缩进”来表明程序的格式框架。缩进指每一行代码开始前的空白区域,用来表示代码之间的包含和层次关系

    1. 1个缩进 = 4个空格

    2. 缩进是Python语言中表明程序框架的唯一手段

    当表达分支、循环、函数、类等程序含义时,在if、while、for、def、class、等保留字所在完整语句后通过英文冒号(:)结尾并在之后进行缩进,表明后续代码与紧邻无缩进语句的所属关系

    缩进错误:当代码执行遇到了“unexpected indent”错误,就表示代码缩进有问题,我们就可以去查看程序的缩进是否正确

    2.注释

    注释是代码中的辅助性文字,会被编译或解释器略去,不被计算机执行,一般用于程序员对代码的说明。Python语言采用#表示一行注释的开始,多行注释需要再每行开始都是用#,或‘’‘或“”“

    Python程序中的非注释语句将按顺序执行,注释语句将被解释器过滤掉,不被执行。注释一般用于在代码中标明作者和版权信息,或解释代码原理及用途,或通过注释单行代码辅助程序调试

    3.续行符

    Python程序是逐行编写的,每行代码长度无限制。续行符由反斜杠(\)符号表达

      
      s = "Whether you come or not,\
      I'll be waiting for you there."
      # 等价于
      s = "Whether you come or not,I'll be waiting for you there."

    注意

  • 续行符后不能存在空格

  • 续行符后必须直接换行

  • 二、语法元素的名称

    1.标识符
  • 由一串字符串组成,字符可以是任意字母、数字、下划线、汉字,不能以数字开头

  • 不能与关键字同名,关键字也被称为“保留字”

  • 2.变量
  • 在运行过程中可以被修改的量被称为变量

  • 变量名必须符合标识符的构成规则

  • 3.常量
  • 一旦赋值就不能改变值的标识符,Python中无法定义常量

  • 4.保留字

    三、数据类型

    1.数据类型概述

    计算机对数据进行运算时需要明确数据的含义和类型

    Python语言支持多种数据类型

    2.数字类型

    表示数字或数值的数据类型称为数字类型,Python提供3种数字类型:整数、浮点数和复数

    3.字符串类型

    计算机程序经常用于处理文本信息,文本信息在程序中使用字符串类型表示。字符串是字符的序列

    用一对双引号 “” 或者一对单引号 ’‘ 括起来。字符串包括两种序列体系:正向递增和反向递减

    四、程序语句元素

    1.表达式
  • 产生或计算新数据值的代码片段称为表达式,一般由数据和操作符等构成

  • 2.赋值语句
  • 对变量进行赋值的一行代码被称为赋值语句

  • 语法格式:<变量> = <表达式>

    3.引用

    通过引用,Python可以使用当前程序之外已有的功能代码,从而提高编程效率

    【引用方式】import <功能库库名>

    引用功能库之后,采用<功能库名称>.<函数名>() 方法去调用具体功能。当然除此之外还有其他方式,后续

    4.其他语句
    1.分支语句
  • 分支语句是控制程序运行的一种语句,他的作用是根据判断条件选择程序执行路径

  • 分支语句包括单分支、二分支和多分支

    单分支语句,使用方式如下:

      
      if <条件>:
          <语句块>

    任何能够产生True和False的语句都可以作为条件,当条件为真时,执行语句块中的内容

    二分支语句,使用方式如下:

      
      if <条件>:
          <语句块1>
      else:
          <语句块2>

    当条件为True时,执行语句块1;当条件为False时,执行语句块2

    2.循环语句

    循环语句是控制程序的一类重要语句,他的作用是根据判断条件确定一段程序是否再次执行一次或者多次。循环包括:遍历循环和条件循环

    条件循环的基本过程

      
      while (<条件>):
          <语句块1>
      <语句块2>

    当条件为True时,执行语句块1,再次判断条件,当条件为False时,退出循环,执行语句块2

    3.input()输入函数
  • 使用方式:<变量> = input(<提示性文字>)

  • 无论用户输入的是字符还是数字,input()函数统一按照字符类型输出

  • 4.eval()
  • 使用方式:<变量> = eval(<字符串>)

  • 去掉字符串最外侧的引号,并按照Python语句方式执行去掉引号后的字符内容

  • 5.print()输入函数
  • 使用方式:

  • 仅输出字符串:print(<待输出字符串>)

  • 仅用于输出一个或多个变量:print(<变量1>,<变量2>,…,<变量n>)

  • 用于混合输出字符串和变量值:print(<输出字符串模版>.format((<变量1>,<变量2>,…,<变量n>)))

  • print()函数输出文本时默认在最后增加一个换行,如若不希望在最后增加换行,或者是想要输出其他内容,可以对print()函数的end参数值进行赋值

  • 第三章 基本数据类型

    第一节 变量

    初始化赋值语句:变量名 = 表达式

    示例:

  • x = 3

  • 变量:通过变量名代表或引用某个值

    = 赋值运算符

    变量赋值过程

      x = 1
      x = x + 10
      ​
      name1 = 'leilei'
      name2 = name1
      ​
      name1 = 'leilei'
      name1 = 'meimei'

    进阶的赋值方法

      # 同时给多个变量赋值同一个内容
      a = b = c = 100
      ​
      # 同时给多个变量赋予不同的内容
      a , b , c = 1 , 2 , 3

    变量名的命名规则

  • 大小写英文、数字和_的结合,且不能用数字开头

  • 系统关键字不能做变量名使用

  • 获取关键字列表:help('keywords')

  • Python中的变量名区分大小写

  • 变量名不能包含空格,但可使用下划线来分隔其中的单词

  • 不要使用Python的内置函数名称做变量名

  • 第二节 初识数据类型

    Python中的基础数据类型

  • 布尔型

  • 数字型

  • 字符串

  • 元组

  • 字典

  • 集合

  • 列表

  • 1.数字型
      a = 1
      print(type(a))
      # <class 'int'>
      b = 2.0
      print(type(b))
      # class <'float'>
    2.字符串
      a = "Hello World"
      print(type(a))
      # <class 'str'>
    3.列表
      a = [1,'two',3.0,'four']
      print(type(a))
      # <class 'list'>
    4.元组
      a = (1,'two',3.0,'four')
      print(type(a))
      # <class 'tuple'>
    5.字典
      
      a = {1:'one',2:'two'}
      print(type(a))
      # <class 'dict'>
    6.集合
      
      a = set([1,2,2,3,2,6,2,1,16,5])
      print(type(a))
      # <class 'set'>

    7.布尔型

      
      a = True
      b = False
      print(type(a))
      print(type(b))
      # <class 'bool'>
      # <class 'bool'>

    第三节 数字型

  • 整数(int)

  • 浮点数(float)

  • 1.整数类型

    整数类型的4种进制表示

    进制种类 引导符号 描述
    二进制 0b或0B 由字符0和1组成,例:0b1010
    八进制 0o或0O 由字符0到7组成,例:0o1010
    十进制 默认情况,例:1010
    十六进制 0x或0X 由字符09,af或A~F组成,例:0x1010
    2.浮点数类型

    一般表示法和科学计数法

    0.1或1e-1

    浮点数计算并不是完全精确的

    不要直接比较两个浮点数是否相等

    一种解决方法:round()进行四舍五入保留一定位数后再判断

      
      round(0.1+0.2 , 5) == round(0.3 , 5)
      # True
    3.数值运算操作符
    操作符 描述符
    x + y 求两数之和
    x – y 求两数之差
    x * y 求两数之积
    x / y 求两数之商,结果为浮点数
    x // y 求两数的整数商
    x % y 两数的余数
    x ** y x的y次幂,即xy
    -x 一个数的负数
    +x 一个数的本身

    基本规则

  • 整数和浮点数混合运算,输出结果为浮点数

  • 整数之间运算,产生结果类型与操作符相关

  • 整数或浮点数与复数运算,输出结果是复数

  • 4.增强操作运算符
    操作符 描述
    x += y 等价于:x = x + y
    x -= y 等价于:x = x – y
    x *= y 等价于:x = x * y
    x /= y 等价于:x = x / y
    x //= y 等价于:x = x // y
    x %= y 等价于:x = x % y
    x**= y 等价于:x = x ** y
    5.数值运算函数
    函数 描述
    abs(x) x的绝对值
    divmod(x,y) (x//y,x%y),输出为二元组形式
    pow(x,y)或pow(x,y,z) x**y或(x**y)%z,幂运算
    round(x)或round(x,d) 对x四舍五入,保留d位小数,无参则返回x的整数,“奇进偶不进”
    max(x1,x2,x3,···,xn) 任意数量的最大值
    min(x1,x2,x3,···,xn) 任意数量的最小值

    第四节 字符串

    1.字符串

    字符串是由字母、数字和特殊字符来组成的序列

    从左到右索引默认0开始的,最大范围是字符串长度少1

    从右到左索引默认-1开始的,最大范围是字符串开头

    创建字符串——使用单引号,双引号或三引号

      
      name = 'leilei'
      number = "12"
      paragraph = '''Hello World
                  Hello'''
    2.字符串长度

    len()函数:返回字符串中的字符长度或者字符数

      
      s1 = 'hello world'
      s2 = 'makerbean'
      print(len(s1))
      print(len(s2))

    isinstance()判断类型

      
      s = 'hello'
      isinstance(s , str)
      # True
    3.转义字符
    转义字符 描述含义
    \b 退格,把光标移到前一列的位置
    \f 换页符
    \n 换行符
    \r 回车
    \t 水平制表符
    \v 垂直制表符
    4.format()方法的基本使用

    字符串使用方式:<模版字符串>.format(<逗号分隔的参数>)

    其中模版字符串是一个由字符串和槽组成的字符串,用来控制字符串和变量的显示效果

      
      "{}那么大,{}想去看看。".format("世界","我")
      # 世界那么大,我想去看看

    语法格式为:

    {<参数序号>:<格式控制标记>}

    5.输出整数和浮点数类型的格式规则

    整数:

  • b:输出整数的二进制方式

  • C:输出整数对应的unicode字符

  • d:输出整数的十进制方式

  • o:输出整数的八进制方式

  • x:输出整数的十六进制方式

  • X:输出整数的大写十六进制方式

  • 浮点数:

  • e:输出浮点数对应的小写字母e的指数形式

  • E:输出浮点数对应的大写字母E的指数形式

  • f:输出浮点数的标准浮点型形式

  • %:输出浮点数的百分比形式

  • 6.字符串类型的操作
    x + y 连接两个字符串
    x * n 或 n * x 复制n次字符x
    x in s
    7.字符串处理函数
    函数 描述
    len(x) 返回字符串x的长度或者是其他组合类型的元素个数
    str(x) 把任意类型转换为字符串形式
    chr(x) 返回Unicode编码对应的单字符
    ord(x) 返回单个字符对应的Unicode编码
    hex(x) 返回整数x对应的十六进制的小写形式
    oct(x) 回整数x对应的八进制的小写形式
    8.字符串处理方法
    方法 描述
    str.lower() 以小写的方式全部返回str的副本
    str.upper() 以大写的方式返回str的副本
    str.split(sep=None) 返回一个列表,以sep作为分隔点,sep默认为空格
    str.count(sub) 返回sub子串出现的次数
    str.replace(old,new) 返回字符串str的副本,所有old子串被替换为new
    str.center(width,fillchar) 字符串居中函数,fillchar参数可选
    str.strip(chars) 从字符串str中去掉在其左侧和右侧chars中列出的字符
    str.join(iter) 将iter变量的每一个元素后面增加一个str字符串
    9.类型转换函数

    int(x):将x转换为整数

    float(x):将x转换为浮点数

    str(x):将x转换为字符串

    第五节 列表

    1.列表结构

    利用中括号表示列表

    列表内的元素用逗号隔开

    注意是英文输入法下的逗号

      
      student1 = ['leilei',18,'class01',201901]
      student2 = ['meimei',19,'class02',201902]
    2.获取列表中的某个元素

    编程语言中通常第一个位置的编号是0

    中括号内数字指定元素位置

      
      grade = [98,99,95,80]
      print(grade[0]) # 98
      print(grade[0] + grade[3])  # 178
    3.修改列表中的某个元素

    找到需要修改的元素编号

    列表名 [编号] = 新值

      
      name = ['leilei','meimei']
      print(name) # ['leilei','meimei']
      name[0] = 'dongdong'
      print(name) # ['dongdong','meimei']
    4.列表的操作函数

    列表类型继承序列类型特点,有一些通用的操作函数

    操作函数 描述
    len(ls) 列表ls的元素个数(长度)
    min(ls) 列表ls中的最小元素(内部数据可比较)
    max(ls) 列表ls中的最大元素(内部数据可比较)
    list(x) 将x转变成列表类型
    5.列表的操作方法

    列表类型存在一些操作方法,使用语法形式是:

    <列表变量>.<方法名称>(<方法参数>)

    方法 描述
    ls.append(x) 在列表ls最后增加一个元素x
    ls.insert(index,x) 在列表ls第index位置增加元素x
    ls.clear() 删除ls中所有元素
    ls.pop(index) 将列表ls中第index项元素取出并删除该元素
    ls.remove(x) 将列表中出现的第一个元素x删除
    ls.reverse() 列表ls中元素反转
    ls.copy() 生成一个新列表,复制ls中所有元素

    可以使用Python保留字del对列表元素或片段进行删除

    del <列表变量>[<索引序号>]

    del <列表变量>[<索引起始>:<索引结束>]

    6.列表的加法与乘法

    加法:两个列表相加合成一个新列表

    乘法:列表循环重复几次形成一个新列表

      
      [1,2] + [3,4]
      # [1,2,3,4]
      [1,2]*3
      # [1,2,1,2,1,2]

    第六节 字典

    1.字典
  • 用花括号表示字典

  • 字典内每一项都有两个元素组成:key和value

  • 各个项用逗号隔开

  •   
      phone_numbers = {'leilei':'1234','meimei':'3456'}
      print(phone_numbers['leilei'])
      # {key:value,key:value}
  • key和value一一对应,同一个键只能有一个对应的值

  • 键的类型是不可变的

  • 2.访问字典里的数据

    利用中括号加要查询的key

      
      grade = {'leilei':'98','meimei':'99'}
      print(grade['leilei'])
    3.更新字典里的元素
      
      grade = {'leilei':'98','meimei':'99'}
      grade['meimei'] = 100   # 更新字典中的键值对
      print(grade)
      grade['dongdong'] = '95'    # 添加一个键值对
      print(grade)
    4.字典的删除操作
      
      grade = {'leilei':'98','meimei':'99','dongdong':'95'}
      print(grade)
      del grade['leilei'] # 删除字典里的某一项
      print(grade)
      grade.clear()   # 删除了字典里的每一项
      print(grade)
      del grade   # 删除了字典本身
      print(grade)
    5.判断字典是否存在某个key

    通过in来判断

      
      d = {'小明':'99','小红':'100'}
      print('小明' in d)
    6.字典的操作函数
    操作函数 描述
    len(d) 字典d的元素个数(长度)
    min(d) 字典d中键的最小值
    max(d) 字典d中键的最大值
    dict() 生成一个空字典
    7.字典的操作方法

    语法形式:<字典变量>.<方法名称>(<方法参数>)

    操作方法 描述
    d.keys() 返回所有的键信息
    d.values() 返回所有的值信息
    d.items() 返回所有的键值对
    d.get(key,default) 键存在则返回相应值,否则返回默认值
    d.pop(key,default) 键存在则返回相应值,同时删除键值对,否则返回默认值
    d.popitem() 随机从字典中取出一个键值对,以元组(key,value)形式返回
    d.clear() 删除所有的键值对

    第七节 数字及字符串进阶

    1.数字型的第三种类型——复数
      
      a = 1 + 3j
      b = 2 + 4j
      c = a + b
      print(c)
      # 3+7j
      d = a * b
      print(d)
      # -10+10j
      type(a)
      # <class 'complex'>

    复数的基本使用方法

    提取实数部分:z.real

    提取虚数部分:z.imag

      
      z = 1 + 2j
      print(z.real)   # 1.0
      print(z.imag)   # 2.0
      type(z.real)    # <class 'float'>
      type(z.imag)    # <class 'float'>
    2.字符串
    1.字符串的切片
      
      name = 'meimei'
      print(name[2:4])    #切2-3,包括左边不包括右边
      print(name[1:5:2])  #2为步长,每2个取一个
      print(name[::-1])   #倒序排列输出
      print(name[::-2])   #倒序步长为2输出

    第一个冒号左侧不写—默认从0开始;第一个冒号右侧不写—默认取到最后

    2.字符串的不可变性

    一个创建出来的字符串是不可以进行二次修改的

    如果想改变某些内容需要新建一个字符串

      
      s = 'Hello Python'
      s1 = 'Hi' + s[5:]
      print(s1)   # 'Hi Python'

    第八节 列表及字典进阶

    1.切片获取列表中连续的几个元素

    与字符串的切片操作一样

      
      numbers = [0,1,2,3,4,5,6,7,8,9]
      print(numbers[2:6]) # 2为从几号开始,起始位置;6为结束为止
      # [2,3,4,5]
      print(numbers[1:5:2])   # 步长为2
      # [1,3]
      print(numbers[::-1])    # 倒序
    2.列表的分片赋值

    一次性为多个元素赋值

      
      name = list('Python')
      print(name)
      #['P', 'y', 't', 'h', 'o', 'n']
      name[2:] = list('abc')
      print(name)
      # ['P', 'y', 'a', 'b', 'c']
      numbers = [1,5]
      numbers[1:1] = [2,3,4]
      print(numbers)
      # [1, 2, 3, 4, 5]
      numbers[1:4] = []
      print(numbers)
      # [1, 5]
    3.用dict函数创建字典

    根据其他序列新建字典

      
      message = [('leilei',98),('meimei',99)]
      d = dict(message)
      print(d)

    根据关键字参数新建字典

      
      d = dict(leilei = 98 ,meimei = 99)
      print(d)

    4.字典与列表的互相嵌套

    由字典构成的列表

      
      student1 = {'name':'leilei','age':18,'grade':98}
      student2 = {'name':'meimei','age':19,'grade':99}
      student3 = {'name':'dongdong','age':18,'grade':95}
      student = [student1,student2,student3]
      print(student)
      # [{'name': 'leilei', 'age': 18, 'grade': 98}, 
      # {'name': 'meimei', 'age': 19, 'grade': 99}, 
      # {'name': 'dongdong', 'age': 18, 'grade': 95}]

    在字典中存储列表

      
      favorite_class = {
          'leilei':['数学','英语'],
          'meimei':['语文'],
          'dongdong':['计算机','物理','数学'],
      }
      print(favorite_class['leilei'])
      # ['数学', '英语']
      print(favorite_class['leilei'][0])
      # 数学

    第九节 元组及集合

    1.列表和元组的对比

    区别:

  • 列表中,元素用方括号[]包裹;在元组中,元素用圆括号()包裹

  • 元组中的元素可以被修改、添加、删除,即列表是可变的数据类型,元组是不可变的数据类型

  • 2.元组可以取值、切片
      b = (2,'leilei',19)
      print(b)
      # (2, 'leilei', 19)
      print(b[2])
      # 19
      print(b[0:2])
      # (2, 'leilei')

    元组内的元素如果是可变结构,任然是有可能被修改的

      l = [1,2,3]
      t = (1,2,l)
      print(t)
      # (1, 2, [1, 2, 3])
      l[0] = 5
      print(t)
      # (1, 2, [5, 2, 3])
    3.创建集合

    直接用花括号创建集合

      
      set1 = {1,2,4,5,8}

    使用set()方法

      
      set1 = set([1,2,4,1,2,8,5,5])
      set2 = set([1,9,3,2,5])
      print(set1)
      # {1, 2, 4, 5, 8}
      print(set2)
      # {1, 2, 3, 5, 9}

    集合内元素不可重复

    4.集合的交集

    交集:求两个集合中都拥有的元素

    用&运算符实现

      set1 = {1,2,4,5,8}
      set2 = {1,2,3,5,9}
      print(set1 & set2)
      # {1, 2, 5}
    5.集合的并集

    并集:求两个集合总共有哪些元素

    用|运算符实现

      set1 = {1,2,4,5,8}
      set2 = {1,2,3,5,9}
      print(set1 | set2)
      # {1, 2, 3, 4, 5, 8, 9}
    6.集合的差集

    差集:set1 和set2 的差集时,会返回在set1中但不在set2中的元素

    用-运算符实现

      set1 = {1,2,4,5,8}
      set2 = {1,2,3,5,9}
      print(set1 - set2)
      # {8, 4}
    7.集合的对称差集

    对称差集:求set1和set2的对称差集时,会返回在set1或在set2中,但不同时存在于两个集合中的元素

    用^运算符实现

      set1 = {1,2,4,5,8}
      set2 = {1,2,3,5,9}
      print(set1 ^ set2)
      # {3, 4, 8, 9}
      set1 = {1,2,4,5,8}
      set2 = {1,2,3,5,9}
      print((set1 | set2) - (set1 & set2))
      # {8, 9, 3, 4}  效果等于对称差集

    作者:辛kai瑞

    物联沃分享整理
    物联沃-IOTWORD物联网 » 计算机二级——Python

    发表回复