Python基础
一、Python概述
1. Python 的起源
- Python 的创始人为吉多·范罗苏姆(Guido van Rossum)
- 1989 年的圣诞节期间,吉多·范罗苏姆为了在阿姆斯特丹打发时间,决心开发一个新的解释程序,作为 ABC 语言的一种继承
- ABC 是由吉多参加设计的一种教学语言,就吉多本人看来,ABC 这种语言非常优美和强大,是专门为非专业程序员设计的。但是 ABC 语言并没有成功,究其原因,吉多认为是非开放造成的。吉多决心在 Python 中避免这一错误,并获取了非常好的效果
- 之所以选中 Python(蟒蛇) 作为程序的名字,是因为他是 BBC 电视剧——蒙提·派森的飞行马戏团(Monty Python’s Flying Circus)的爱好者
- 1991 年,第一个 Python 解释器 诞生,它是用 C 语言实现的,并能够调用 C 语言的库文件
1.1 解释器
-
计算机不能直接理解任何除机器语言以外的语言,所以必须要把程序员所写的程序语言翻译成机器语言,计算机才能执行程序。将其他语言翻译成机器语言的工具,被称为编译器
-
编译器翻译的方式有两种:一个是编译,另外一个是解释。两种方式之间的区别在于翻译时间点的不同。当编译器以解释方式运行的时候,也称之为解释器
-
编译型语言:程序在执行之前需要一个专门的编译过程,把程序编译成为机器语言的文件,运行时不需要重新翻译,直接使用编译的结果就行了。程序执行效率高,依赖编译器,跨平台性差些。如 C、C++
-
解释型语言:解释型语言编写的程序不进行预先编译,以文本方式存储程序代码,会将代码一句一句直接运行。在发布程序时,看起来省了道编译工序,但是在运行程序的时候,必须先解释再运行
-
编译型语言和解释型语言对比
- 速度 —— 编译型语言比解释型语言执行速度快
- 跨平台性 —— 解释型语言比编译型语言跨平台性好
1.2 Python 的设计目标
- 1999 年,吉多·范罗苏姆向 DARPA 提交了一条名为 “Computer Programming for Everybody” 的资金申请,并在后来说明了他对 Python 的目标:
- 一门简单直观的语言并与主要竞争者一样强大
- 开源,以便任何人都可以为它做贡献
- 代码像纯英语那样容易理解
- 适用于短期开发的日常任务
1.3 Python 的设计哲学
- 优雅
- 明确
- 简单
- Python 开发者的哲学是:用一种方法,最好是只有一种方法来做一件事
- 如果面临多种选择,Python 开发者一般会拒绝花俏的语法,而选择明确没有或者很少有歧义的语法
2. Python 的简介
- Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。
- 解释型语言,开发过程没有编译环节
- 交互式语言,可以在Python提示符后面直接互动执行写自己的程序
- 面向对象语言
3. Python 的特点
- Python 是完全面向对象的语言
- 函数、模块、数字、字符串都是对象,在 Python 中一切皆对象
- 完全支持继承、重载、多重继承
- 支持重载运算符,也支持泛型设计
- Python 拥有一个强大的标准库,Python 语言的核心只包含 数字、字符串、列表、字典、文件 等常见类型和函数,而由 Python 标准库提供了 系统管理、网络通信、文本处理、数据库接口、图形系统、XML 处理 等额外的功能
- Python 社区提供了大量的第三方模块,使用方式与标准库类似。它们的功能覆盖 科学计算、人工智能、机器学习、Web 开发、数据库接口、图形系统 多个领域
- 面向对象的思维方式
- 面向对象 是一种 思维方式,也是一门 程序设计技术
- 要解决一个问题前,首先考虑 由谁 来做,怎么做事情是 谁 的职责,最后把事情做好就行!
- 对象 就是 谁
- 要解决复杂的问题,就可以找多个不同的对象,各司其职,共同实现,最终完成需求
4. Python3 的安装
- 为了不带入过多的累赘,Python 3.0在设计的时候没有考虑向下相容。
- 环境安装
- 下载Python环境安装包
- 安装Python环境
- 测试是否安装成功 python3 --version
- 安装Anaconda
- 为了更简单地使用python中丰富的库资源,可以直接安装一个python“全家桶”——Anaconda。
- Anaconda 是一个python的发行版,包括了python和很多常见的软件库, 和一个包管理器conda。常见的科学计算类的库都包含在里面,使得安装比常规python安装要容易。注意,装了Anaconda就不需要再装python了。
- Anaconda不仅可以方便地安装、更新、卸载工具包,而且安装时能自动安装相应的依赖包,同时还能使用不同的虚拟环境隔离不同要求的项目;从而大大简化了工作流程。
5. Python 的优缺点
- 优点
- 简单、易学
- 免费、开源
- 面向对象
- 丰富的库
- 可扩展性
- 如果需要一段关键代码运行得更快或者希望某些算法不公开,可以把这部分程序用 C 或 C++ 编写,然后在 Python 程序中使用它们
- 缺点
- 运行速度
- 国内市场较小
- 中文资料匮乏
二、Python 基本语法
1. 编码
- 默认情况下,python3源文件以UTF-8编码,所有字符串都是unicode字符串。同时可以指定源文件的不同编码
- 文件开头加上
# -*- coding: UTF-8 -*-
# coding=utf-8(等号两边不能有空格) - 允许在源文件中使用utf-8字符集中的字符编码,对应的适合语言为中文等。
2. 标识符
- 第一个字符必须是字母表中的字母或下划线_
- 标识符中的其他部分由字母、数字和下划线组成
- 标识符对大小写敏感
- 在python3中,非ASCII标识符 (如中文字符) 也是允许的
3. 注释
- 单行注释:井号 #
- 多行注释:三个单引号’’’,或者三个双引号"""
4. 行和缩进
- Python的代码块不使用大括号{}来控制类,函数以及其他逻辑判断。python 最具特色的就是用缩进来写模块。
- 缩进的空白数量是可变的,但是所有代码块语句必须包含相同的缩进空白数量,这个必须严格执行。
5. 多行语句
- Python语句中一般以新行作为语句的结束符。但是我们可以使用斜杠( \)将一行的语句分为多行显示
- total = item_one + \
item_two + \
item_three - print(‘aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
aaaaaaaaaaaaaaaaaaaa’)
- total = item_one + \
- 语句中包含 [], {} 或 () 括号就不需要使用多行连接符。
- days = [‘Monday’, ‘Tuesday’, ‘Wednesday’,
‘Thursday’, ‘Friday’]
6. Python空行
- 函数之间或类的方法之间用空行分隔,表示一段新的代码的开始。类和函数入口之间也用一行空行分隔,以突出函数入口的开始。空行与代码缩进不同,空行并不是Python语法的一部分。书写时不插入空行,Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码,便于日后代码的维护或重构。
7. 等待用户输入
- 执行下面的程序在按回车键后就会等待用户输入:
- input("\n\n按下 enter 键后退出。")
8. Print输出
- print 默认输出是换行的,如果要实现不换行需要在变量末尾加上 end=""
9. import 与 from…import
- 在 python 用 import 或者 from…import 来导入相应的模块。
a、将整个模块(somemodule)导入,格式为: import somemodule
b、从某个模块中导入某个函数,格式为: from somemodule import somefunction
c、从某个模块中导入多个函数,格式为: from somemodule import firstfunc, secondfunc, thirdfunc
d、将某个模块中的全部函数导入,格式为: from somemodule import *
10. 算术运算符
- + - * / // % **
11. 程序执行原理
11.1 计算机中的三大件
- 计算机中包含有较多的硬件,但是一个程序要运行,有 三个 核心的硬件,分别是:
- CPU
- 中央处理器,是一块超大规模的集成电路
- 负责 处理数据/计算
- 内存
- 临时 存储数据(断电之后,数据会消失)
- 速度快
- 空间小(单位价格高)
- 硬盘
- 永久 存储数据
- 速度慢
- 空间大(单位价格低)
- CPU
- 计算机中哪一个硬件设备负责执行程序?
- CPU
- 内存 的速度快还是 硬盘 的速度快?
- 内存
- 我们的程序是安装在内存中的,还是安装在硬盘中的?
- 硬盘
- 我买了一个内存条,有 500G 的空间!!!,这句话对吗?
- 不对,内存条通常只有 4G / 8G / 16G / 32G
- 计算机关机之后,内存中的数据都会消失,这句话对吗?
- 正确
11.2 程序执行的原理
- 程序 运行之前,程序是 保存在硬盘 中的
- 当要运行一个程序时
- 操作系统会首先让 CPU 把程序复制到 内存 中
- CPU 执行 内存 中的 程序代码
- 程序要执行,首先要被加载到内存
11.3 Python 程序执行原理
- 操作系统会首先让 CPU 把 Python 解释器 的程序复制到 内存 中
- Python 解释器 根据语法规则,从上向下 让 CPU 翻译 Python 程序中的代码
- CPU 负责执行翻译完成的代码
- 执行以下终端命令可以查看 Python 解释器的大小
# 1. 确认解释器所在位置
$ which python
# 2. 查看 python 文件大小(只是一个软链接)
$ ls -lh /usr/bin/python
# 3. 查看具体文件大小
$ ls -lh /usr/bin/python2.7
# 建立 软链接 的目的,是为了方便使用者不用记住使用的解释器是 哪一个具体版本
11.4 程序的作用
- QQ 在运行之前,是保存在 硬盘 中的
- 运行之后,QQ 程序就会被加载到 内存 中了
- 读取用户输入的 QQ 号码
- 读取用户输入的 QQ 密码
- 将 QQ 号码 和 QQ 密码 发送给腾讯的服务器,等待服务器确认用户信息
- 在 QQ 这个程序将 QQ 号码 和 QQ 密码 发送给服务器之前,需要先存储一下 QQ 号码 和 密码
- QQ 这个程序把 QQ 号码 和 QQ 密码 保存在 内存 中,因为 QQ 程序自己就在内存中
- QQ 这个程序是怎么保存用户的 QQ 号码 和 QQ 密码 的?
- 在内存中为 QQ 号码 和 QQ 密码 各自分配一块空间
- 在 QQ 程序结束之前,这两块空间是由 QQ 程序负责管理的,其他任何程序都不允许使用
- 在 QQ 自己使用完成之前,这两块空间始终都只负责保存 QQ 号码 和 QQ 密码
- 使用一个 别名 标记 QQ 号码 和 QQ 密码 在内存中的位置
- 在内存中为 QQ 号码 和 QQ 密码 各自分配一块空间
- 在程序内部,为 QQ 号码 和 QQ 密码 在内存中分配的空间就叫做 变量
- 程序就是用来处理数据的,而变量就是用来存储数据的
三、基本数据类型
1. 变量赋值
counter = 100 # 整型变量
miles = 1000.0 # 浮点型变量
name = "runoob" # 字符串
print (counter)
print (miles)
print (name)
2. 多变量赋值
# Python允许你同时为多个变量赋值。例如:
a = b = c = 1
# 以上实例,创建一个整型对象,值为 1,从后向前赋值,三个变量被赋予相同的数值。
# 可以为多个对象指定多个变量。例如:
a, b, c = 1, 2, "runoob"
a,b = b,a # 变量的交换
# 以上实例,两个整型对象 1 和 2 的分配给变量 a 和 b,字符串对象 "runoob" 分配给变量 c。
# 注意:
a = 10
b = 20
a,b = b,a+5
print(a,b)
# 结果:a = 20,b=15
3. 标准数据类型
- Number(数字)、String(字符串)、List(列表)、Tuple(元组)、Set(集合)、Dictionary(字典)
- 不可变数据(3 个):Number(数字)、String(字符串)、Tuple(元组)
- 可变数据(3 个):List(列表)、Dictionary(字典)、Set(集合)
4. Number
- int、float、bool、complex(复数)
- 函数
- type(a) # 判断数据类型,不会认为子类是一种父类类型
- isinstance(a,int) # 判断数据是否属于某类型,会认为子类是一种父类类型
- del var1,var2 # 手动GC
- 进制
- 二进制:使用0b开头 例如:0b1010
- 八进制:使用0o开头 例如:0o555
- 十六进制:0x开头 例如:0x52A74(大小写都OK)
- 数学函数
- import math
- 基本数学函数
- abs(x) 返回数字的绝对值,如abs(-10) 返回 10
- ceil(x) 返回数字的上入整数,如math.ceil(4.1) 返回 5
- (x>y)-(x<y) 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
- exp(x) 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
- fabs(x) 返回数字的绝对值,如math.fabs(-10) 返回10.0
- floor(x) 返回数字的下舍整数,如math.floor(4.9)返回 4
- log(x) 如math.log(math.e)返回1.0,math.log(100,10)返回
- log10(x) 返回以10为基数的x的对数,如math.log10(100)返回 2.0
- max(x1, x2,…) 返回给定参数的最大值,参数可以为序列。
- min(x1, x2,…) 返回给定参数的最小值,参数可以为序列。
- modf(x) 返回x的整数部分与小数部分,两部分的数值符号与x相同,整数部分以浮点型表示。
- pow(x, y) x**y 运算后的值。
- round(x [,n]) 返回浮点数x的四舍五入值,如给出n值,则代表舍入到小数点后的位数。
- sqrt(x) 返回数字x的平方根。
- 随机数函数
- choice(seq) 从序列的元素中随机挑选一个元素,比如random.choice(range(10)),
从0到9中随机挑选一个整数。 - randrange ([start,] stop [,step]) 从指定范围内,按指定基数递增的集合中获取一个随机数,基数缺省值为1
- random() 随机生成下一个实数,它在[0,1)范围内。
- seed([x]) 改变随机数生成器的种子seed。如果你不了解其原理,你不必特别去设定seed,Python会帮你选择seed。
- shuffle(lst) 将序列的所有元素随机排序
- uniform(x, y) 随机生成下一个实数,它在[x,y]范围内。
- choice(seq) 从序列的元素中随机挑选一个元素,比如random.choice(range(10)),
- 三角函数
- acos(x) 返回x的反余弦弧度值。
- asin(x) 返回x的反正弦弧度值。
- atan(x) 返回x的反正切弧度值。
- atan2(y, x) 返回给定的 X 及 Y 坐标值的反正切值。
- cos(x) 返回x的弧度的余弦值。
- hypot(x, y) 返回欧几里德范数 sqrt(xx + yy)。
- sin(x) 返回的x弧度的正弦值。
- tan(x) 返回x弧度的正切值。
- degrees(x) 将弧度转换为角度,如degrees(math.pi/2) , 返回90.0
- radians(x) 将角度转换为弧度
- 数学常量
- pi 数学常量 pi(圆周率,一般以π来表示)
- e 数学常量 e,e即自然常数(自然常数)
5. String
-
Python中的字符串用单引号 ’ 或双引号 " 括起来,同时使用反斜杠 \ 转义特殊字符。下标从0开始。
-
加号 + 是字符串的连接符, 星号 * 表示复制当前字符串,紧跟的数字为复制的次数。
-
字符串截取
-
变量[头下标:尾下标:步长)
-6 -5 -4 -3 -2 -1 0 1 2 3 4 5 +---+---+---+---+---+---+ | a | b | c | d | e | f | +---+---+---+---+---+---+
-
-
字符串打印
- Python 使用反斜杠()转义特殊字符,如果你不想让反斜杠发生转义,可以在字符串前面添加一个 r,表示原始字符串
- print(‘Ru\noob’) Runoob
- print(r’Ru\noob’) Ru\noob
-
字符串获取 print(str[0])
-
要点
- 反斜杠可以用来转义,使用r可以让反斜杠不发生转义。
- 字符串可以用+运算符连接在一起,用*运算符重复。
- Python中的字符串有两种索引方式,从左往右以0开始,从右往左以-1开始。
- Python中的字符串不能改变。
- str = ‘abcdef’
- str[0] = ‘s’ # 报错
- Python 没有单独的字符类型,一个字符就是长度为1的字符串。
6. List
- List(列表)是Python 中使用最频繁的数据类型。列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同,它支持数字,字符串甚至可以包含列表(所谓嵌套)。列表是写在方括号[]之间、用逗号分隔开的元素列表。和字符串一样,列表同样可以被索引和截取,列表被截取后返回一个包含所需元素的新列表。
- 定义:
- list = [0,1,2,3,‘c’]
- list[0] # 0
- len(list) # 长度5
- list[0:3] # [0,1,2]
- 要点:
1、List写在方括号之间,元素用逗号隔开。
2、和字符串一样,list可以被索引和切片。
3、List可以使用+操作符进行拼接。
4、List中的元素是可以改变的。
5、不支持与或非运算
7. Tuple
- 元组(tuple)与列表类似,不同之处在于元组的元素不能修改。元组写在小括号 () 里,元素之间用逗号隔开。
- 定义:
- t = (0,1,2,3,‘c’)
- t[0] # 0
- len(list) # 长度5
- t[0:3] # (0,1,2)
- t[0] = 2 # 报错
- 要点
- 与字符串一样,元组的元素不能修改。虽然tuple的元素不可改变,但它可以包含可变的对象,比如list列表。
- list = [0,2,1,3]
- t = (0,1,2,3,list)
- t[0] = 1 # 报错
- t[4][0] = 1
- print(t[4]) # ok
- 元组也可以被索引和切片,方法一样。
- 注意构造包含0或1个元素的元组的特殊语法规则。
- tup1 = () # 空元组
- tup2 = (20,) # 一个元素,需要在元素后添加逗号
- 元组也可以使用 + 或 * 操作符进行拼接。
- 与字符串一样,元组的元素不能修改。虽然tuple的元素不可改变,但它可以包含可变的对象,比如list列表。
8. Set 集合
-
集合(set)是由一个。合的事物或对象称作元素或是成员。基本功能是进行成员关系测试和删除重复元素。
-
可以使用大括号 { } 或者 set() 函数创建集合,注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。
-
创建格式:
parame = {value01,value02,…} 或者 set(value)
s = {‘Tom’, ‘Jim’, ‘Mary’, ‘Tom’, ‘Jack’, ‘Rose’}
print(s) # {‘Mary’, ‘Jack’, ‘Rose’, ‘Tom’, ‘Jim’}s = set('1b1b2b3b2b') # {'2', '3', '1', 'b'} set操作: # set可以进行集合运算 a = set('abracadabra') b = set('alacazam') print(a) >>> {'b', 'a', 'c', 'r', 'd'} print(a - b) # a和b的差集 >>> {'b', 'd', 'r'} print(a | b) # a和b的并集 >>> {'l', 'r', 'a', 'c', 'z', 'm', 'b', 'd'} print(a & b) # a和b的交集 >>> {'a', 'c'} print(a ^ b) # a和b中不同时存在的元素 >>> {'l', 'r', 'z', 'm', 'b', 'd'}
9. Dictionary(字典)
-
字典(dictionary)是Python中另一个非常有用的内置数据类型。
-
列表是有序的对象集合,字典是无序的对象集合。
-
两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取。
-
字典是一种映射类型,字典用"{ }"标识,它是一个无序的键(key) : 值(value)对集合。
-
键(key)必须使用不可变类型。
-
在同一个字典中,键(key)必须是唯一的。
-
字典创建:
(1) d = {“a”:1,“b”:2,“c”:3}
(2) d = dict([(‘Runoob’, 1), (‘Google’, 2), (‘Taobao’, 3)])
(3) d = {x:x**2 for x in (2, 4, 6)} # [2:4,4:16,6:36]
(4) d = dict(Runoob=1, Google=2, Taobao=3)
字典操作:
tinydict = {‘name’: ‘baidu’,‘code’:1, ‘site’: ‘www.baidu.com’}print (dict['name']) # 输出键为 'name' 的值 print (dict['code']) # 输出键为 'code' 的值 print (tinydict) # 输出完整的字典 print (tinydict.keys()) # 输出所有键 dict_keys(['name', 'code', 'site']) print (tinydict.values()) # 输出所有值 dict_values(['baidu', 1, 'www.baidu.com'])
四、变量的基本使用
1. 变量定义
- 在 Python 中,每个变量 在使用前都必须赋值,变量 赋值以后 该变量 才会被创建
- 等号(=)用来给变量赋值
- = 左边是一个变量名
- = 右边是存储在变量中的值
变量名 = 值
# 变量定义之后,后续就可以直接使用了
# 定义 qq 号码变量
qq_number = "1234567"
# 定义 qq 密码变量
qq_password = "123"
# 在程序中,如果要输出变量的内容,需要使用 print 函数
print(qq_number)
print(qq_password)
2. 变量的类型
- 在内存中创建一个变量,会包括:
a. 变量的名称
b. 变量保存的数据
c. 变量存储数据的类型
d. 变量的地址(标示)
2.1 变量的类型
- 在 Python 中定义变量是 不需要指定类型(在其他很多高级语言中都需要)
- 数据类型可以分为 数字型 和 非数字型
- 数字型
- 整型 (int)
- 浮点型(float)
- 布尔型(bool)
- 真 True 非 0 数 —— 非零即真
- 假 False 0
- 复数型 (complex)
- 主要用于科学计算,例如:平面场问题、波动问题、电感电容等问题
- 非数字型
- 字符串
- 列表
- 元组
- 字典
- 使用 type 函数可以查看一个变量的类型
In [1]: type(name)
2.2 不同类型变量之间的计算
2.2.1 数字型变量 之间可以直接计算
- 在 Python 中,两个数字型变量是可以直接进行 算数运算的
- 如果变量是 bool 型,在计算时
- True 对应的数字是 1
- False 对应的数字是 0
2.2.2 字符串变量 之间使用 + 拼接字符串
- 在 Python 中,字符串之间可以使用 + 拼接生成新的字符串
In [1]: first_name = "三"
In [2]: last_name = "张"
In [3]: first_name + last_name
Out[3]: '三张'
2.2.3 字符串变量 可以和 整数 使用 * 重复拼接相同的字符串
In [1]: "-" * 50
Out[1]: '--------------------------------------------------'
2.2.4 数字型变量 和 字符串 之间 不能进行其他计算
In [1]: first_name = "zhang"
In [2]: x = 10
In [3]: x + first_name
---------------------------------------------------------------------------
TypeError: unsupported operand type(s) for +: 'int' and 'str'
类型错误:`+` 不支持的操作类型:`int` 和 `str`
2.3 变量的输入
- 所谓 输入,就是 用代码 获取 用户通过 键盘 输入的信息
- 例如:去银行取钱,在 ATM 上输入密码
- 在 Python 中,如果要获取用户在 键盘 上的输入信息,需要使用到 input 函数
2.3.1 关于函数
- 一个 提前准备好的功能(别人或者自己写的代码),可以直接使用,而 不用关心内部的细节
- 目前已经学习过的函数
函数 | 说明 |
---|---|
print(x) | 将 x 输出到控制台 |
type(x) | 查看 x 的变量类型 |
2.3.2 input 函数实现键盘输入
- 在 Python 中可以使用 input 函数从键盘等待用户的输入
- 用户输入的 任何内容 Python 都认为是一个 字符串
- 语法如下:
字符串变量 = input("提示信息:")
2.3.3 类型转换函数
函数 | 说明 |
---|---|
int(x) | 将 x 转换为一个整数 |
float(x) | 将 x 转换到一个浮点数 |
2.3.4 变量输入演练 —— 超市买苹果增强版
- 需求
- 收银员输入 苹果的价格,单位:元/斤
- 收银员输入 用户购买苹果的重量,单位:斤
- 计算并且 输出 付款金额
- 演练方式 1
# 1. 输入苹果单价
price_str = input("请输入苹果价格:")
# 2. 要求苹果重量
weight_str = input("请输入苹果重量:")
# 3. 计算金额
# 1> 将苹果单价转换成小数
price = float(price_str)
# 2> 将苹果重量转换成小数
weight = float(weight_str)
# 3> 计算付款金额
money = price * weight
print(money)
# 提问
# 1. 演练中,针对 价格 定义了几个变量?
# ○ 两个
# ○ price_str 记录用户输入的价格字符串
# ○ price 记录转换后的价格数值
# 2. 思考 —— 如果开发中,需要用户通过控制台 输入 很多个 数字,针对每一个数字都要定义两个变量,方便吗?
-
演练方式 2 —— 买苹果改进版
- 定义 一个 浮点变量 接收用户输入的同时,就使用 float 函数进行转换
price = float(input("请输入价格:"))
-
改进后的好处:
- 节约空间,只需要为一个变量分配空间
- 起名字方便,不需要为中间变量起名字
-
改进后的“缺点”:
- 初学者需要知道,两个函数能够嵌套使用,稍微有一些难度
2.3.5 变量的格式化输出
- 苹果单价 9.00 元/斤,购买了 5.00 斤,需要支付 45.00 元
- 在 Python 中可以使用 print 函数将信息输出到控制台
- 如果希望输出文字信息的同时,一起输出 数据,就需要使用到 格式化操作符
- % 被称为 格式化操作符,专门用于处理字符串中的格式
- 包含 % 的字符串,被称为 格式化字符串
- % 和不同的 字符 连用,不同类型的数据 需要使用 不同的格式化字符
格式化字符 | 含义 |
---|---|
%s | 字符串 |
%d | 有符号十进制整数,%06d 表示输出的整数显示位数,不足的地方使用 0 补全 |
%f | 浮点数,%.2f 表示小数点后只显示两位 |
%% | 输出 % |
# 语法格式如下:
print("格式化字符串" % 变量1)
print("格式化字符串" % (变量1, 变量2...))
- 格式化输出演练 —— 基本练习
# 需求
# 1. 定义字符串变量 name,输出 我的名字叫 小明,请多多关照!
# 2. 定义整数变量 student_no,输出 我的学号是 000001
# 3. 定义小数 price、weight、money,输出 苹果单价 9.00 元/斤,购买了 5.00 斤,需要支付 45.00 元
# 4. 定义一个小数 scale,输出 数据比例是 10.00%
print("我的名字叫 %s,请多多关照!" % name)
print("我的学号是 %06d" % student_no)
print("苹果单价 %.02f 元/斤,购买 %.02f 斤,需要支付 %.02f 元" % (price, weight, money))
print("数据比例是 %.02f%%" % (scale * 100))
五、变量的命名
1. 标识符和关键字
1.1 标识符
- 标识符就是程序员定义的 变量名、函数名
- 名字 需要有 见名知义 的效果
- 标识符可以由 字母、下划线 和 数字 组成
- 不能以数字开头
- 不能与关键字重名
1.2 关键字
- 关键字 就是在 Python 内部已经使用的标识符
- 关键字 具有特殊的功能和含义
- 开发者 不允许定义和关键字相同的名字的标识符
# 通过以下命令可以查看 Python 中的关键字
In [1]: import keyword
In [2]: print(keyword.kwlist)
# 提示:关键字的学习及使用,会在后面的课程中不断介绍
# import 关键字 可以导入一个 “工具包”
# 在 Python 中不同的工具包,提供有不同的工具
2. 变量的命名规则
- 命名规则 可以被视为一种 惯例,并无绝对与强制
- 目的是为了 增加代码的识别和可读性
- 注意 Python 中的 标识符 是 区分大小写的
- 在定义变量时,为了保证代码格式,= 的左右应该各保留一个空格
- 在 Python 中,如果 变量名 需要由 二个 或 多个单词 组成时,可以按照以下方式命名
a. 每个单词都使用小写字母
b. 单词与单词之间使用 _下划线 连接
○ 例如:first_name、last_name、qq_number、qq_password
- 驼峰命名法
- 当 变量名 是由二个或多个单词组成时,还可以利用驼峰命名法来命名
- 小驼峰式命名法
- 第一个单词以小写字母开始,后续单词的首字母大写
- 例如:firstName、lastName
- 大驼峰式命名法
- 每一个单词的首字母都采用大写字母
- 例如:FirstName、LastName、CamelCase
六、判断(if)语句
1. 逻辑运算
# 练习1: 定义一个整数变量 age,编写代码判断年龄是否正确
age = 100
# 要求人的年龄在 0-120 之间
if age >= 0 and age <= 120:
print("年龄正确")
else:
print("年龄不正确")
# 练习2: 定义两个整数变量 python_score、c_score,编写代码判断成绩
python_score = 50
c_score = 50
# 要求只要有一门成绩 > 60 分就算合格
if python_score > 60 or c_score > 60:
print("考试通过")
else:
print("再接再厉!")
# 练习3: 定义一个布尔型变量 `is_employee`,编写代码判断是否是本公司员工
is_employee = True
# 如果不是提示不允许入内
if not is_employee:
print("非公勿内")
2. if 语句进阶
2.1 elif 演练 —— 女友的节日
- 需求
- 定义 holiday_name 字符串变量记录节日名称
- 如果是 情人节 应该 买玫瑰/看电影
- 如果是 平安夜 应该 买苹果/吃大餐
- 如果是 生日 应该 买蛋糕
- 其他的日子每天都是节日啊……
holiday_name = "平安夜"
if holiday_name == "情人节":
print("买玫瑰")
print("看电影")
elif holiday_name == "平安夜":
print("买苹果")
print("吃大餐")
elif holiday_name == "生日":
print("买蛋糕")
else:
print("每天都是节日啊……")
2.2 if 的嵌套 演练 —— 火车站安检
- 需求
- 定义布尔型变量 has_ticket 表示是否有车票
- 定义整型变量 knife_length 表示刀的长度,单位:厘米
- 首先检查是否有车票,如果有,才允许进行 安检
- 安检时,需要检查刀的长度,判断是否超过 20 厘米
- 如果超过 20 厘米,提示刀的长度,不允许上车
- 如果不超过 20 厘米,安检通过
- 如果没有车票,不允许进门
# 定义布尔型变量 has_ticket 表示是否有车票
has_ticket = True
# 定义整数型变量 knife_length 表示刀的长度,单位:厘米
knife_length = 20
# 首先检查是否有车票,如果有,才允许进行 安检
if has_ticket:
print("有车票,可以开始安检...")
# 安检时,需要检查刀的长度,判断是否超过 20 厘米
# 如果超过 20 厘米,提示刀的长度,不允许上车
if knife_length >= 20:
print("不允许携带 %d 厘米长的刀上车" % knife_length)
# 如果不超过 20 厘米,安检通过
else:
print("安检通过,祝您旅途愉快……")
# 如果没有车票,不允许进门
else:
print("大哥,您要先买票啊")
3. 综合应用 —— 石头剪刀布
3.1 基础代码实现
- 先 假定电脑就只会出石头,完成整体代码功能
# 从控制台输入要出的拳 —— 石头(1)/剪刀(2)/布(3)
player = int(input("请出拳 石头(1)/剪刀(2)/布(3):"))
# 电脑 随机 出拳 - 假定电脑永远出石头
computer = 1
# 比较胜负
# 如果条件判断的内容太长,可以在最外侧的条件增加一对大括号
# 再在每一个条件之间,使用回车,PyCharm 可以自动增加 8 个空格
if ((player == 1 and computer == 2) or
(player == 2 and computer == 3) or
(player == 3 and computer == 1)):
print("噢耶!!!电脑弱爆了!!!")
elif player == computer:
print("心有灵犀,再来一盘!")
else:
print("不行,我要和你决战到天亮!")
3.2 随机数的处理
- 在 Python 中,要使用随机数,首先需要导入 随机数 的 模块 —— “工具包”
import random
- 导入模块后,可以直接在 模块名称 后面敲一个 . 然后按 Tab 键,会提示该模块中包含的所有函数
- random.randint(a, b) ,返回 [a, b] 之间的整数,包含 a 和 b
random.randint(12, 20) # 生成的随机数n: 12 <= n <= 20
random.randint(20, 20) # 结果永远是 20
random.randint(20, 10) # 该语句是错误的,下限必须小于上限
七、运算符
1. 算数运算符
- + - * / // % **
2. 比较(关系)运算符
- == != > < >= <=
3. 逻辑运算符
- and or not
4. 赋值运算符
- = += -= *= /= //= %= **=
5. 运算符的优先级
运算符 | 描述 |
---|---|
** | 幂 (最高优先级) |
* / % // | 乘、除、取余数、取整除 |
+ - | 加法、减法 |
<= < > >= | 比较运算符 |
== != | 等于运算符 |
= %= /= //= -= += *= **= | 赋值运算符 |
not or and | 逻辑运算符 |
八、循环
1. 程序的三大流程
- 在程序开发中,一共有三种流程方式:
- 顺序 —— 从上向下,顺序执行代码
- 分支 —— 根据条件判断,决定执行代码的 分支
- 循环 —— 让 特定代码 重复 执行
2. 循环计算
# 计算 0 ~ 100 之间所有数字的累计求和结果
# 0. 定义最终结果的变量
result = 0
# 1. 定义一个整数的变量记录循环的次数
i = 0
# 2. 开始循环
while i <= 100:
print(i)
# 每一次循环,都让 result 这个变量和 i 这个计数器相加
result += i
# 处理计数器
i += 1
print("0~100之间的数字求和结果 = %d" % result)
# 计算 0 ~ 100 之间 所有 偶数 的累计求和结果
# 0. 最终结果
result = 0
# 1. 计数器
i = 0
# 2. 开始循环
while i <= 100:
# 判断偶数
if i % 2 == 0:
print(i)
result += i
# 处理计数器
i += 1
print("0~100之间偶数求和结果 = %d" % result)
3. break 和 continue
- break 和 continue 是专门在循环中使用的关键字
- break 某一条件满足时,退出循环,不再执行后续重复的代码
- continue 某一条件满足时,不执行后续重复的代码
4. while 循环嵌套
4.1 循环嵌套演练 —— 九九乘法表
# 第 1 步:用嵌套打印小星星
*
**
***
****
*****
# 1. 定义一个计数器变量,从数字1开始,循环会比较方便
row = 1
while row <= 5:
print("*" * row)
row += 1
# 第 2 步:使用循环嵌套打印小星星
# 知识点 对 print 函数的使用做一个增强
● 在默认情况下,print 函数输出内容之后,会自动在内容末尾增加换行
● 如果不希望末尾增加换行,可以在 print 函数输出内容的后面增加 , end=""
● 其中 "" 中间可以指定 print 函数输出内容之后,继续希望显示的内容
● 语法格式如下:
# 向控制台输出内容结束之后,不会换行
print("*", end="")
# 单纯的换行
print("")
row = 1
while row <= 5:
# 假设 python 没有提供字符串 * 操作
# 在循环内部,再增加一个循环,实现每一行的 星星 打印
col = 1
while col <= row:
print("*", end="")
col += 1
# 每一行星号输出完成后,再增加一个换行
print("")
row += 1
4.2 九九乘法表
- 需求 输出 九九乘法表,格式如下:
1 * 1 = 1
1 * 2 = 2 2 * 2 = 4
1 * 3 = 3 2 * 3 = 6 3 * 3 = 9
1 * 4 = 4 2 * 4 = 8 3 * 4 = 12 4 * 4 = 16
1 * 5 = 5 2 * 5 = 10 3 * 5 = 15 4 * 5 = 20 5 * 5 = 25
1 * 6 = 6 2 * 6 = 12 3 * 6 = 18 4 * 6 = 24 5 * 6 = 30 6 * 6 = 36
1 * 7 = 7 2 * 7 = 14 3 * 7 = 21 4 * 7 = 28 5 * 7 = 35 6 * 7 = 42 7 * 7 = 49
1 * 8 = 8 2 * 8 = 16 3 * 8 = 24 4 * 8 = 32 5 * 8 = 40 6 * 8 = 48 7 * 8 = 56 8 * 8 = 64
1 * 9 = 9 2 * 9 = 18 3 * 9 = 27 4 * 9 = 36 5 * 9 = 45 6 * 9 = 54 7 * 9 = 63 8 * 9 = 72 9 * 9 = 81
开发步骤:
1.打印 9 行小星星
*
**
***
****
*****
******
*******
********
*********
2.将每一个 * 替换成对应的行与列相乘
# 定义起始行
row = 1
# 最大打印 9 行
while row <= 9:
# 定义起始列
col = 1
# 最大打印 row 列
while col <= row:
# end = "",表示输出结束后,不换行
# "\t" 可以在控制台输出一个制表符,协助在输出文本时对齐
print("%d * %d = %d" % (col, row, row * col), end="\t")
# 列数 + 1
col += 1
# 一行打印完成的换行
print("")
# 行数 + 1
row += 1
- 字符串中的转义字符
- \t 在控制台输出一个 制表符,协助在输出文本时 垂直方向 保持对齐
- \n 在控制台输出一个 换行符
转义字符 | 描述 |
---|---|
\ | 反斜杠符号 |
’ | 单引号 |
" | 双引号 |
\n | 换行 |
\t | 横向制表符 |
\r | 回车 |