Bull's blog
wangyang
2023-09-02
目录

python基础和条件语句

# python基础

# 一.自动化测试

学习代码的几点技巧

1.实践-学过的代码要亲自敲一遍

2.目标导向-学习是不要陷入晦涩的技术

3.定期复盘-记录学习状态，及时调整学习方向

学习路径：

python基础 → 接口自动化→web自动化→APP自动化

# 二.python的简介

认识 Python 1.Python 的开始

1582973610951

Python 的作者，Guido von Rossum（吉多·范罗苏姆），荷兰人。1982 年，Guido 从阿姆斯特丹大学获得了数学和计算机硕士学位。然而，尽管他算得上是一位数学家，但他更加享受计算机带来的乐趣。用他的话说，尽管拥有数学和计算机双料资质，他总趋向于做计算机相关的工作，并热衷于做任何和编程相关的活儿。

在那个时候，Guido 接触并使用过诸如 Pascal [ˈpæskəl]、C、Fortran[ˈfɔ:træn] 等语言。这些语言的基本设计原则是让机器能更快运行。在 80 年代，虽然 IBM 和苹果已经掀起了个人电脑浪潮，但这些个人电脑的配置很低。比如早期的Macintosh(麦金塔电脑)，只有 8MHz 的 CPU 主频和 128KB 的 RAM，一个大的数组就能占满内存。所有的编译器的核心是做优化，以便让程序能够运行。为了增进效率，语言也迫使程序员像计算机一样思考，以便能写出更符合机器口味的程序。在那个时代，程序员恨不得用手榨取计算机每一寸的能力。有人甚至认为 C 语言的指针是在浪费内存。至于动态类型，内存自动管理，面向对象…… 别想了， 那会让你的电脑陷入瘫痪。

这种编程方式让 Guido 感到苦恼。Guido 知道如何用 C 语言写出一个功能，但整个编写过程需要耗费大量的时间，即使他已经准确的知道了如何实现。他的另一个选择是 shell。Bourne Shell(是一个交换式的命令解释器和命令编程语言)

作为 UNIX 系统的解释器已经长期存在。UNIX 的管理员们常常用 shell 去写一些简单的脚本，以进行一些系统维护的工作，比如定期备份、文件系统管理等等。shell 可以像胶水一样，将 UNIX 下的许多功能连接在一起。许多 C 语言下上百行的程序，在 shell 下只用几行就可以完成。然而，shell 的本质是调用命令。它并不是一个真正的语言。比如说，shell 没有数值型的数据类型，加法运算都很复杂。总之，shell 不能全面的调动计算机的功能。

Guido 希望有一种语言，这种语言能够像 C 语言那样，能够全面调用计算机的功能接口，又可以像 shell 那样，可以轻松的编程。ABC 语言让 Guido 看到希望。ABC 是由荷兰的数学和计算机研究所开发的。Guido 在该研究所工作，并参与到ABC 语言的开发。ABC 语言以教学为目的。与当时的大部分语言不同，ABC 语言的目标是“让用户感觉更好”。ABC 语言希望让语言变得容易阅读，容易使用， 容易记忆，容易学习，并以此来激发人们学习编程的兴趣 `` 1582973610951

HOW TO 用于定义一个函数。一个 Python 程序员应该很容易理解这段程序。ABC 语言使用冒号和缩进来表示程序块。行尾没有分号。for 和 if 结构中也没有括号() 。赋值采用的是 PUT，而不是更常见的等号。这些改动让 ABC 程序读起来像一段文字。 尽管已经具备了良好的可读性和易用性，ABC 语言最终没有流行起来。在当时，ABC 语言编译器需要比较高配置的电脑才能运行。而这些电脑的使用者通常精通计算机，他们更多考虑程序的效率，而非它的学习难度。除了硬件上的困难外，ABC 语言的设计也存在一些致命的问题： 可拓展性差。ABC 语言不是模块化语言。如果想在 ABC 语言中增加功能，比如对图形化的支持，就必须改动很多地方。 不能直接进行 IO。ABC 语言不能直接操作文件系统。尽管你可以通过诸如文本流的方式导入数据，但 ABC 无法直接读写文件。输入输出的困难对于计算机语言来说是致命的。你能想像一个打不开车门的跑车么？ 过度革新。ABC 用自然语言的方式来表达程序的意义，比如上面程序中的 HOW TO 。然而对于程序员来说，他们更习惯 用 function 或者 define 来定义一个函数。同样，程序员更习惯用等号来分配变量。尽管 ABC 语言很特别，但学习难度 也很大。 传播困难。ABC 编译器很大，必须被保存在磁带上。当时 Guido 在访问的时候，就必须有一个大磁带来给别人安装 ABC 编译器。 这样，ABC 语言就很难快速传播。 1989 年，为了打发圣诞节假期，Guido 开始写 Python 语言的编译器。Python 这个名字，来自 Guido 所挚爱的电视剧 Monty Python's Flying Circus(飞行马戏团)。他希望这个新的叫做 Python 的语言，能符合他的理想：

创造一种 C 和 shell 之间，功能全面，易学易用，可拓展的语言。Guido 作为一个语言设计爱好者，已经有过设计语言的尝试。这一次，也不过是一次纯粹的hacking(搬运)行为。

1582973610951

2.python的发展

由于计算机性能的提高，软件的世界也开始随之改变。硬件足以满足许多个人电脑的需要。硬件厂商甚至渴望高需求软件的出现，以带动硬件的更新换代。C++ 和 Java 相继流行。C++和 Java 提供了面向对象的编程范式，以及丰富的对象库。在牺牲了一定的性能的代价下，C++和 Java 大大提高了程序的产量。语言的易用性被提到一个新的高度。我们还记得 ，ABC 失败的一个重要原因是硬件的性能限制。从这方面说，Python 要比 ABC 幸运许多。 另一个悄然发生的改变是Internet。1990 年代还是个人电脑的时代，windows 和 Intel 挟 PC 以令天下， 盛极一时。尽管 Internet 为主体的信息革命尚未到来，但许多程序员以及资深计算机用户已经在频繁使用 Internet 进行交流，比如 使用 email 和 newsgroup(新闻组)。Internet 让信息交流成本大大下降。一种新的软件开发模式开始流行：开源。程序员利用业余时间进行软件开发，并开放源代码。1991 年，Linus（林纳斯·托瓦兹）在 comp.os.minix 新闻组上发布了 Linux 内核源代码，吸引大批 hacker（电脑迷或者黑客）的加入。Linux 和相互合作，最终构成了一个充满活力的开源平台。 硬件性能不是瓶颈，PythonGNU 又容易使用， 所以许多人开始转向 Python。Guido 维护了一个 maillist（邮件列表），Python 用户就通过邮件进行交流。Python 用户来自许多领域，有不同的背景，对 Python 也有不同的需求。Python 相当的开放，又容 易拓展，所以当用户不满足于现有功能，很容易对 Python 进行拓展或改造。随后，这些用户将改动发给 Guido， 并由 Guido 决定是否将新的特征加入到 Python 或者标准库中。如果代码能被纳入 Python 自身或者标准库，这将极大的荣誉。由于 Guido 至高无上的决定权， 他因此被称为“终身的仁慈独裁者”。 Python 被称为“Battery Included”， 是说它以及其标准库的功能强大。这些是整个社区的贡献。Python 的开发者来自不同领域，他们将不同领域的优点带给 Python。比如 Python 标准库中的正则表达是参考 Perl（一种 CGI 脚本语言），而 lambda, map, filter, reduce 等函数参考了 Lisp(因应人工智能而设计的语言)。Python 本身的一些功能以及大部分的标准库来自于社区。Python 的社 区不断扩大，进而拥有了自己的 newsgroup， 网站，以及基金。从 Python 2.0 开始，Python 也从 maillist 的开发方式，转为完全开源的开发方式。社区气氛已经形成，工作被整个社区分担，Python 也获得了更加高速的发展。 到今天，Python 的框架已经确立。Python 语言以对象为核心组织代码，支持多种编程范式，采用动态类型，自动进行内存回收。Python 支持解释运行，并能调用 C 库进行拓展。Python 有强大的标准库。由于标准库的体系已经稳定，所以 Python 的生态系统开始拓展到第三方包。这些包，如Django、web.py、wxPython、numpy、matplotlib、PIL，将 Python 升级成了物种丰富的热带雨林。

2.2. Python 优缺点

2.2.1. 优点

简单————Python 是一种代表简单主义思想的语言。阅读一个良好的 Python 程序就感觉像是在读英语一样，尽管这个英语的要求非常严格！Python 的这种伪代码本质是它最大的优点之一。它使你能够专注于解决问题而不是去搞明白语言本身。

易学————就如同你即将看到的一样，Python 极其容易上手。前面已经提到了，Python 有极其简单的语法。

免费、开源————Python 是 FLOSS（自由/开放源码软件）之一。简单地说， 你可以自由地发布这个软件的拷贝、阅读它的源代码、对它做改动、把它的一部分用于新的自由软件中。FLOSS 是基于一个团体分享知识的概念。这是为什么Python 如此优秀的原因之一——它是由一群希望看到一个更加优秀的 Python 的

人创造并经常改进着的。

高层语言————当你用 Python 语言编写程序的时候，你无需考虑诸如如何管理你的程序使用的内存一类的底层细节。

可移植性————由于它的开源本质，Python 已经被移植在许多平台上（经过改动使它能够工作在不同平台上）。如果你小心地避免使用依赖于系统的特性， 那么你的所有 Python 程序无需修改就可以在下述任何平台上面运行。这些平台包括 Linux、Windows、FreeBSD、Macintosh、Solaris、OS/2、Amiga、AROS、AS/400、BeOS、OS/390、z/OS、Palm OS、QNX、VMS、Psion、Acom RISC OS、VxWorks、PlayStation、Sharp Zaurus、Windows 甚至还有 PocketPC、Symbian 以及 Google 基于 linux 开发的 Android 平台！

解释性————这一点需要一些解释。一个用编译性语言比如 C 或 C++写的程序可以从源文件（即 C 或 C++语言）转换到一个你的计算机使用的语言（二进制代码，即 0 和 1）。这个过程通过编译器和不同的标记、选项完成。当你运行你的程序的时候，连接/转载器软件把你的程序从硬盘复制到内存中并且运行。而Python 语言写的程序不需要编译成二进制代码。你可以直接从源代码运行程序。在计算机内部，Python 解释器把源代码转换成称为字节码的中间形式，然后再把它翻译成计算机使用的机器语言并运行。事实上，由于你不再需要担心如何编译程序，如何确保连接转载正确的库等等，所有这一切使得使用 Python 更加简单。由于你只需要把你的 Python 程序拷贝到另外一台计算机上，它就可以工作了，这也使得你的 Python 程序更加易于移植。

面向对象————Python 既支持面向过程的编程也支持面向对象的编程。在“面向过程”的语言中，程序是由过程或仅仅是可重用代码的函数构建起来的。在“面向对象”的语言中，程序是由数据和功能组合而成的对象构建起来的。与其他主要的语言如 C++和 Java 相比，Python 以一种非常强大又简单的方式实现面向对象编程。

可扩展性————如果你需要你的一段关键代码运行得更快或者希望某些算法不公开，你可以把你的部分程序用 C 或 C++编写，然后在你的 Python 程序中使用它们。

丰富的库————Python 标准库确实很庞大。它可以帮助你处理各种工作，包括正则表达式、文档生成、单元测试、线程、数据库、网页浏览器、CGI、FTP、电子邮件、XML、XML-RPC、HTML、WAV 文件、密码系统、GUI（图形用户界面）、Tk 和其他与系统有关的操作。记住，只要安装了 Python，所有这些功能都是可用的。这被称作 Python 的“功能齐全”理念。除了标准库以外，还有许多其他高质量的库，如 wxPython、Twisted（是用 Python 实现的基于事件驱动的网络引擎框架）和 Python 图像库等等。

规范的代码————Python 采用强制缩进的方式使得代码具有极佳的可读性。

2.2.2. 缺点

运行速度，有速度要求的话，用 C++改写关键部分吧。

国内市场较小,但时间推移，目前很多国内软件公司，也开始规模使用 Python。

构架选择太多（没有像 C#这样的官方.net 构架，也没有像 ruby 由于历史较短， 构架开发的相对集中。Ruby on Rails 构架开发中小型 web 程序天下无敌）。不过这也从另一个侧面说明，Python 比较优秀，吸引的人才多，项目也多。

3.python是解释型语言

1582973610951

1582973610951

3.1编译型 vs 解释型

编译型

优点：编译器一般会有预编译的过程对代码进行优化。因为编译只做一次，运行时不需要编译，所以编译型语言的程序执行效率高。可以

脱离语言环境独立运行。

缺点：编译之后如果需要修改就需要整个模块重新编译。编译的时候根据对应的运行环境生成机器码，不同的操作系统之间移植就会有问题，需要根据运行的操作系统环境编译不同的可执行文件。 解释型

优点：有良好的平台兼容性，在任何环境中都可以运行，前提是安装了解释器（虚拟机）。灵活，修改代码的时候直接修改就可以，可以快速部署，不用停机维护。 缺点：每次运行的时候都要解释一遍，性能上不如编译型语言。

3.1python解释器

当我们编写 Python 代码时，我们得到的是一个包含 Python 代码的以.py 为扩展名的文本文件。要运行代码，就需要 Python 解释器去执行.py 文件。 由于整个 Python 语言从规范到解释器都是开源的，所以理论上，只要水平够高， 任何人都可以编写 Python 解释器来执行 Python 代码（当然难度很大）。事实上， 确实存在多种 Python 解释器。

CPython：当我们从 Python 官方网站下载并安装好 Python 3.5 后，我们就直接获得了一个官方版本的解释器：CPython。这个解释器是用 C 语言开发的，所以叫 CPython。在命令行下运行 python 就是启动 CPython 解释器。CPython 是使用最广的 Python 解释器。

IPython：IPython 是基于 CPython 之上的一个交互式解释器，也就是说，IPython只是在交互方式上有所增强，但是执行 Python 代码的功能和 CPython 是完全一样的。好比很多国产浏览器虽然外观不同，但内核其实都是调用了 IE。CPython 用>>>作为提示符，而 IPython 用 In [序号]:作为提示符。

PyPy：PyPy 是另一个 Python 解释器，它的目标是执行速度。PyPy 采用 JIT 技术， 对 Python 代码进行动态编译（注意不是解释），所以可以显著提高 Python 代码的执行速度。绝大部分 Python 代码都可以在 PyPy 下运行，但是 PyPy 和 CPython 有一些是不同的，这就导致相同的 Python 代码在两种解释器下执行可能会有不同的结果。如果你的代码要放到 PyPy 下执行，就需要了解 PyPy 和 CPython 的不同点。

Jython：Jython 是运行在 Java 平台上的 Python 解释器，可以直接把 Python 代码编译成 Java 字节码执行。

IronPython：IronPython 和 Jython 类似，只不过 IronPython 是运行在微软.Net 平台上的 Python 解释器，可以直接把 Python 代码编译成.Net 的字节码。

小结：Python 的解释器很多，但使用最广泛的还是CPython。如果要和Java 或.Net平台交互，最好的办法不是用 Jython 或 IronPython，而是通过网络调用来交互，

确保各程序之间的独立性。

# 2.1下载和安装python解释器

# 2.1.1 下载

下载地址： https://www.python.org/downloads/release/python-364/

1582975027305

# 2.1.2安装

双击可执行文件-----【勾选添加环境变量】----【install】,按提示操作即可

1582976247123

1582976261437

备注：可参见我给大家写的软件安装步骤说明

# 三. Pycharm 简介

Pycharm是一种python IDE（集成开发环境），带有一整套可以帮助用户在使用python语言开发时提高效率的工具，内部集成的功能如下：

  • project项目管理
  • 智能提示
  • 语法高亮
  • 代码跳转
  • 调试代码
  • 解释代码（解释器）
  • 框架和库
  • ....

pycharm 分为专业版(professional)和社区版(community),我们的课程主要是以社区版为基准进行操作和讲解

# 3.1 下载和安装Pycharm

下载链接：https://www.jetbrains.com/pycharm/download/#secti

注意：这里选择community（社区版本）下载，专业版本是收费版本，社区版可以满足我们基础编程需要

# 3.2 安装

双击安装包--【运行】--【允许你应用更改设备】：【是】---【next】--【选择安装位置】---【next】--【install】--【finish】

1582976149151

1582976166694

1582976187351

备注：可参见我给大家写的软件安装步骤说明

# 3.2 Project管理

Project管理，即Pycharm的项目管理，主要有新建项目，打开文件 ，关闭项目

# 3.2.1 新建项目

打开pycharm ---【create new project】--选择项目根目录和解释器版本---【create】，即可完成创建一个项目。

1582984456921

1582984606414

# 3.2.2 打开项目

[file]---------[open]---浏览选择目标文件所在的位置，然后选择---[ok]--选择项目的打开方式（在当前窗口打开还是新开起一个窗口）-----[ok]

1582985021086

1582985080849

进行选择是在新窗口打开还是在当前窗口打开

1582985143144

  • open in new window :就是重新打开一个Pycharm界面

  • open in current window：就是在当前页面打开，且覆盖掉当前界面之前的代码文件

  • 小贴士：

    • ​ 如果勾选了open in current window，又同时勾选add to currently opened projects，那么当前pycharm中同时打开原有和目标项目

      1582985512602

    • 如果勾选了open in new window，dd to currently opened projects是灰色的，没有办法勾选。

      1582985742055

# 3.2.3 关闭项目

选中目标项目--【file】--【close project】

1582985845075

# 3.3新建项目

项目根目录或者根目录内部任意位置-----右键------【New】---【python file】---输入文件名字----【OK】

备注：直接写文件名字，会自动加上后缀

1582986270861

输出第一个最简单的python程序：

print("hello world")
1

# 3.4 运行python程序

文件打开状态------空白位置--------右键---Run-----即可调出pycharm的控制台输出程序结果

1582986676681

# 3.5 Pycharm基本设置

【file】-----【setting】/【default Setting】

1582986845182

# 3.5.1 设置pycharm主题

1582987010202

Theme：修改主题

Name：修改主题名字

Size：修改主题字号

# 3.5.2设置解释器

[setting]------[project:项目名字]-----[设置图标]--[Add]---浏览到目标解释器--------[ok]---[ok]

1582987374465

# 3.5.3设置代码文字格式

【Editor】--【Font】

  • Font：修改字体
  • Size：修改字号
  • Line Spacing :修改行间距

# 3.6认识bug

所谓bug就是程序的漏洞或缺陷，简单理解就是程序的错误，需要程序员调节bug

1582988648550

Pycharm控制台会提示错误的行数和错误信息

出现bug

  • 手误：拼写错误
  • 语法不熟练

# 四.注释

# 4.1注释的作用

  • 没有注释的代码

1582989129466

  • 添加注释的代码

1582989349598

通过用自己熟悉的语言，在程序中对某些代码进行标注说明，这就是注释的作用，能够大大增强代码的可读性

# 4.2注释的分类

注释分为两类：单行注释和多行注释

  • 单行注释

只能注释一行内容，语法如下：

#单行注释
1
  • 多行注释

可以注释多行内容，一般用在注释一段代码的情况，语法如下：

'''
	第一行注释
	第二行注释
	第三行注释
	第四行注释
'''
"""
	第一行注释
	第二行注释
	第三行注释
	第四行注释
"""
1
2
3
4
5
6
7
8
9
10
11
12

# 4.3行与缩进

行

物理行是你在编写程序时所 看见 的。逻辑行是Python 看见 的单个语句。Python假定每个 物理行 对应一个 逻辑行 。

逻辑行的例子如print 'Hello World'这样的语句——如果它本身就是一行（就像你在编辑器中看到的那样），那么它也是一个物理行。

默认地，Python希望每行都只使用一个语句，这样使得代码更加易读。

python最具特色的就是使用缩进来表示代码块，不需要使用任何标点

同一个代码块的语句必须包含相同的缩进空格数（4个空格/一个tab表示一个级别）

# -*- coding: utf-8 -*-
import random

x = random.randint(1, 100)
i = 0
while i < 100:
    y = input("请输入数字:")
    print(y)
    y = int(y)
    print(x == y)
    if x == y:
        print("============")
        print("猜中啦！")
        print("============")
        break
    elif y < x:
        print("太小了")
    else:
        print("太大了")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

问题：图片里的图片有几个代码块

ps:不要混合使用制表符和空格来缩进，因为这在跨越不同的平台的时候，无法正常工作

# 多行语句：

Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠()来实现多行语句，例如：

total = item_one + \
        item_two + \
        item_three
1
2
3

在 [], {}, 或 () 中的多行语句，不需要使用反斜杠()，例如：

total = ['item_one', 'item_two', 'item_three',
        'item_four', 'item_five']
1
2

# 五.变量

# 5.1变量的作用

1582990254828

# 1.计算机语言中能储存计算结果的抽象概念。变量可以通过变量名访问

# 2.变量是存储在内存中的值。这就意味着在创建变量时会在内存中开辟一个空间变量的命名

# 一个例子：

举例说明：我们去图书馆读书，怎么能快速锁定到我们要读的书的位置呢？因为管理员提前把图书分类，并按照这个位置进行编号，我们只需要在图书馆中按照这个编号查找指定位置就能找到我们想要的书

这个编号其实就是把书籍存放的位置起了一个名字，方便后期查找和使用

程序中，数据都是临时存储到内存当中，为了更快速的查找和使用这个数据，通常我们把这个数据在内存中存储之后定义一个名字，这个名字就是变量。

# 另一个例子：

num1 的值是100

num2 的值是87

现在要就算两个值相加：

result = num1 + num2 #把 num1 和 num2 这两个变量的数据进行累加，然后放到 result 变量中

变量就是一个存储数据的容器的名字

# 5.2定义变量

变量 = 值
1

使用"="进行赋值

变量名自定义，要满足标识符命名规则

# 5.3标识符(变量命名)

# 5.3.1 标识符命名规则

标识符命名规则是python中定义各种名字的时候使用的统一规范，具体如下：

  • 有数字，字母，下划线组成

  • 数字不能开头

  • 不能使用内置关键字

  • 严格区分大小写

    Flase    None 	True 	and 	or 		as 		assert 		break 	class
continue def 	del 	elif 	else 	except 	finally 	for		nonlocal
form 	 while 	global 	if 		import 	in 		is 			lambda 	yield
not 	 pass 	raise 	return 	try 	with
    1
    2
    3
    4

    ps：使用命令查看关键字

    import keyword

    print(keyword.kwlist)

# 5.3.2 命名习惯

  • 见名知义：一个有意义的名字，尽量做到看一眼就知道是什么意思(提高代码可读性) 比如: 名字 就定义为 name , 定义学生 用 student

    1582993775925

  • 大驼峰，即每个单词首字母都大写，例如：MyName

  • 小驼峰，第二个（含）以后的单词首字母大写，例如：myName

  • 下划线，例如：my_name

# 5.4 认识数据类型

在python里为了应对不同的业务需求，也把数据分为不同的类型

1582993775925

检测数据类型的方式：

  • type(变量)----------返回值直接是类型，经常用这个
  • isinstance(变量，类型)------------返回值是True 或者 False（了解，有的时候面试会问，让写出两个判断类型的）
a = 1
print(type(a))  #---------<class 'int'>

b = 1.1
print(type(b))  #---------<class 'float'>

c = True
print(type(c))  #---------<class 'bool'>

d = (1,3,4)
print(type(d))  #---------<class 'tuple'>

e = [1,3,4]
print(type(e))  #---------<class 'list'>

f = {1,3,3,4}
print(type(f))  #---------<class 'set'>

g = {"name": "夭夭","age":18}
print(type(g))  #---------<class 'dict'>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# 六.输出

作用：程序输出内容给用户

print("hello world")
1

# 6.1格式化输出

所谓的格式化输出就是按照一定的格式输出内容

# 6.1.1格式化符号

说明：列举的是常用的

格式符号 转换
%s 字符串
%d 整数
%f 浮点数

技巧

  • %06d 表示输出的整数显示的位置，如果不足用0补位，超出当前位数则原样输出
  • %.2f 表示小数点后显示的小数位数，遵循四舍五入

# 6.1.2 格式化字符串

格式化三种方式

  • %
  • f"{变量}"
  • {}.format(变量)
age = 30
name = "Bull"
weight= 83.5
student_id = 1

# 我的名字叫
print("我的名字叫%s" % name)

# 我的学号是0001
print("我的学号是%04d" % student_id)

# 我的体重是83.50公斤
print("我的体重是%.1f" % weight)

# 我的名字是，年龄30
print("我的名字是%s,年龄%d" %(name,age))

# 我的名字是，明年就31了
print("我的名字是%s,明年就%d了" %(name,(age+1)))

# 我的名字是，明年就31了
print(f"我的名字是{name},明年就{age+1}")
print("我的名字是{},明年就{}了".format(name,(age+1)))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

f-格式化是python3.6中新增的格式化方法，该方法更简单易读

# 6.1.3 转义字符

  • \n: 换行

  • \t: tab

  • *如何区分正斜杠 与 反斜杠

    image-20201120134646761

# 6.1.4 结束符

想一想，为什么两个print会换行输出？

print('输出的内容', end="\n")
1

在python中，print(), 默认自带end=“\n”这个换行结束符，所以导致每两个print直接会换行展示，用户可以按照需要更改结束符。

# 七.输入

# 7.1 输入的作用

在python中，程序接收用户输入的数据的功能即是输入

# 7.2 输入的语法

input("提示信息")
1

# 7.3 输入的特点

  • 当程序执行到input的时候会停止，等着用户输入，输入完之后程序才会向下执行
  • 在python中，input接受用户的输入之后，一般会存储到变量中，方便使用
  • 在python中，input会把任意用户输入的数据当作字符串处理，即返回的是字符串
password = input("请输入您的密码:")
print(f'您的密码是{password}')
print(type(password))  # <class 'str'>
1
2
3

控制台输出的结果如下：

1582998803132

# 八.数据类型的转换

说明：列举的是常用的

函数 说明
int（x,[,base]） 将x转换为一个整数
float(x) 将x转换为一个浮点数
str(x) 将对象x转换为字符串
tuple(s) 将序列s转换为一个元组
list(s) 将序列s转换为一个列表
eval(str) 用来计算在字符串中的有效的python表达式，并返回一个对象

# 九.运算符

# 9.1 算数运算符

以下假设变量：a = 10, b=20

运算符 描述 实例
+ 加 - 两个对象相加 a+b输出的结果是30
- 减 - 得到负数或是一个数减去另一个数 a-b输出的结果是-10
* 乘 - 两个数相乘或是返回一个被重复若干次的字符串 a*b输出的结果是200
/ 除 b/a输出的结果是2
// 取整除 - 返回商的整数部分（向下取整） >>> 9//2 4 >>> -9//2 -5
% 取模 - 返回除法的余数 b%a输出的结果是0
** 幂 - 返回x的y次幂 a**3输出的结果是1000,即10*10*10
() 小括号 小括号用来提高运算符优先级，即(a+b)*3=90

注意

  • 混合运算优先级顺序：()高于 ** 高于* / // % 高于 + -

# 9.2 赋值运算符

运算符 描述 实例
= 赋值 将=右侧的结果赋值给等号左侧的变量
  • 单个变量赋值
num = 1
print(num)
1
2
  • 多个变量赋值
num1,float1,str1 = 1, 1.2,'hello world'
print(num1,float1,str1)
1
2

结果如下:

1583002385336

  • 多变量赋值同值
a=b=10
print(a)
print(b)
1
2
3

结果如下：

1583002709280

# 9.3 复合赋值运算符

运算符 描述 实例
+= 加法赋值运算符 c+=a 等价于 c =c+a
-= 减法赋值运算发符 c-=a等价于 c=c-a
*= 乘法赋值运算符 c*=a等价于 c=c*a
/= 除法赋值运算符 c/=a 等价于 c = c/a
//= 整除赋值运算符 c //= a 等价于c = c//a
%= 取模赋值运算符 c %=a等价于 c=c%a
**= 取幂赋值运算符 c**= a 等价于c=c**a
a = 100
a += 1
# 输出的结果是101 a+=1 等价于 a = a + 1 即 100+1=101
print(a)

b = 2
b *= 4
# 输出的结果是8 b*=4等价于 b=b*4 即 2*4 = 8
print(b)

c = 10
c += 1+2
#输出的是13，先运算右边的1+2=3，然后 c += 3即c= c +3 10+3=13
print(c)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 9.4比较运算符

比较运算符也叫关系运算符

运算符 描述 实例
== 判断相等。如果两个操作数的结果相等，则条件为真(True),否则条件结果为假(False) 如a=3,b=3,则(a==b)为True
!= 不等于。如果两个操作数的结果不相等，则条件为真(True),否则条件为假(False) 如a=3，b=3，则（a!=b）为False
> 运算符左侧操作数结果是否大于右侧操作数结果，如果大于，则条件为真，否则为假 如a=7，b=3，则（a>b）为True
< 运算符左侧操作数结果是否小于右侧操作数结果，如果小于，则条件为真，否则为假 如a=7,b=3,则（a<b）为False
>= 运算符左侧操作结果是否大于等于右侧操作数结果，如果大于或者等于，则条件为真，否则为假 如果a=7，b=3，则(a>=b)为True
<= 运算符左侧操作结果是否小于等于右侧操作结果，如果小于等于，则条件为真，否则为假 如果a=7，b=3，则(a<=b)为False
a=7
b=3
print(a==b)  # False
print(a!= b) #True
print(a>b)  #True
print(a<b) # False
print(a>=b)  # True
print(a<=b)  # False
1
2
3
4
5
6
7
8
9

# 9.5 逻辑运算符

运算符 逻辑表达式 描述 实例
and x and y 布尔"与"：如果x为False，x and y返回False，否则返回y的值 True and False，返回False
or x or y 布尔"或"：如果x是True，它返回True，否则返回y的值 True or False, 返回 True
not not x 布尔"非"：如果x为True，它返回False。如果x为False，它返回True。 not True，返回False，not False，返回True
a = 1
b = 2
c = 3
print((a>b) and (b<c))  # False
print((a<b)and(b<c)) #True
print((a>b) or (b<c))   #True
print(not(a>b))   # True
1
2
3
4
5
6
7

# 十.流程控制

day1-10

程序执行有三种方式：顺序执行，选择执行，循环执行。

# 10.1条件语句

生活中的场景

day1-10

如果我选择吃鱼，就不能迟到熊掌了

场景，月攒钱计划

银行卡余额

如果（if）今天是9日:

​ 发工资

​ 银行卡余额 = 银行卡余额+工资

如果（if）今天是12日:

​ 还房贷

​ 银行卡余额 = 银行卡余额 -月供

如果（if） 车没油了:

​ 加油

​ 银行卡余额 = 银行卡余额 -油费

如果（if）到了下个发薪日：

​ 本月攒钱 = 银行卡余额 - 上月余额

小结：

如果某些条件满足，才能做某件事情，而不满足时不允许做，这就是所谓的判断不仅生活中有，在软件开发中“判断”功能也经常会用到

  • 同学们这个年龄去过网吧吗？
  • 能进去网吧上网必须要做的一件事是什么？
  • 为什么要把身份证给工作人员看？
  • 是不是为了判断是否成年？
  • 是不是如果成年就可以上网，不成年就不可以上网？

# 10.2 if 语句

# 10.2.1语法

if 条件:
    条件成立执行的代码1
    条件成立执行的代码2
    ......
1
2
3
4

# 10.2.2 快速体验

if True:

	print('条件成立执行的代码1')

	print('条件成立执行的代码2')

# 下方的代码没有缩进到if语句块，所以和if条件无关
print('我是无论条件是否成功，都要执行的代码')
1
2
3
4
5
6
7
8

执行结果如下：

1583035861208

# 10.3 实例:上网

需求分析：如果用户年龄大于等于18岁，即成年，输出"已经成年，可以上网"

# 10.3.1 简单版

age = 18
if age >= 18:
    print('已经成年，可以上网')
 
print('系统关闭')
1
2
3
4
5

# 10.3.2 练习

要求：从键盘获取自己的年龄，判断是否大于或者等于 18 岁，如果满足就输出“我已成年，我已经承担法律责任”

  1. 使用 input 从键盘中获取数据，并且存入到一个变量中 2.使用 if 语句，来判断 age>=18 是否成立

# 10.4 if...else..

作用：条件成立执行if下方的代码；条件不成立，执行else下方的代码

思考: 网吧上网的实例，如果成年，允许上网，如果不成年呢？是不是应该回复用户不能上网？

# 10.4.1 语法

if 条件：
	条件成立执行的代码1
    条件成立执行的代码2
    ......
else:
    条件不成立执行的代码1
    条件不成立执行的代码2
    ......
1
2
3
4
5
6
7
8

# 10.4.2 实用版:网吧上网

age = int(input('请输入您的年纪:'))
if age >= 18:
    print(f'您的年龄是{age},已经达到了法令年纪，可以尽情上网')
else:
    print(f'您的年龄是{age},没有达到法定上网年纪，赶紧回家写作业')
print('系统关闭')
1
2
3
4
5
6

注意：如果条件成立执行某些代码，其他情况的代码就不会被执行。

# 10.5多重判断

思考：中国合法工作年龄为18-60，即如果小于18岁为童工，不合法；如果年龄在18-60岁之间为合法工龄；大于60岁则为法定退休年龄

# 10.5.1 语法

if 条件1：
	条件成立执行的代码1
    条件成立执行的代码2
    ....
elif 条件2：
	条件成立执行的代码1
    条件成立执行的代码2
    ....
else:
    以上条件都不成立执行的代码
1
2
3
4
5
6
7
8
9
10

# 10.5.2 实例：工龄判断

age = int(input("请输入您的年龄:"))
if age<18:
    print(f'您的年龄是{age},达不到法定工作年纪，不合法')
elif age>= 18 and age<=60:
    print(f'您的年龄是{age},符合法定工作年龄')
else:
    print(f'您的年龄是{age},符合法定退休年龄')
1
2
3
4
5
6
7

扩展: age>=18 and age<=60 可以化简为 18 =< age <=60

# 10.6 if嵌套

思考: 坐公交：如果有车票，就可以上车，上车之后，如果有空位置就可以坐下，如果没有的话，只能站着。怎么书写程序呢？

# 10.6.1语法

if 条件1：
	条件成立要执行的代码1
    条件成立要执行的代码2
    if 条件2：
    	条件成立要执行的代码1
        条件成立要执行的代码2
1
2
3
4
5
6

注意：条件2的if也是也是出于条件1的缩进关系内部

# 10.6.2 实例:坐公交

# 10.6.2.1 判断是否能上车

'''
1.坐公交，如果有钱，则可以坐上公交车
	2坐上公交之后，如果有座位可以等座位
	 上车后，如果没有座位，则要等座位空下来才能坐
没有钱，没有办法坐车

'''
# money = 1表示有钱，money=0表示没有钱
money = 0
if money == 1:
    print('土豪，请上车')
else:
    print('抱歉，没钱不能上车')
1
2
3
4
5
6
7
8
9
10
11
12
13

# 10.6.2.2 判断是否能坐下

# seat = 1表示有座位，seat = 0表示没有座位
money = 1
seat = 0
if money == 1:
    print('土豪，请上车')
    if seat == 1:
        print('运气爆棚，赶紧坐下休息会')
    else:
        print('哎，没有座位，再等会吧')
else:
    print('抱歉，没钱不能上车')
1
2
3
4
5
6
7
8
9
10
11

# 10.7 应用：猜拳游戏

需求分析：

  • 参与游戏的角色

    • ​ 玩家
      • ​ 手动出拳
    • ​ 电脑
      • ​ 随机出拳

  • 判断输赢

    • ​ 玩家获胜

      玩家 电脑
      石头 剪刀
      剪刀 布
      布 石头

    • 平局

      • ​ 电脑和玩家出的一样

    • 电脑获胜

      玩家 电脑
      石头 布
      剪刀 石头
      布 剪刀
      import random
 # 定义石头=0，剪刀=1，布=2
player = int(input('请输入您要出的石头=0，剪刀=1，布=2:'))
computer = random.randint(0,2)
print(computer)
# 玩家获胜:p0:c1,p1:c2,p2:c0
if (player == 0 and computer == 1) or (player == 1  and computer == 2) or (player == 2 and computer == 0):
    print('玩家获胜')
# 平局
elif player == computer :
    print('平局')
# 电脑获胜
else:
    print('电脑赢了')
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14

    # 10.8循环控制

生活中的循环

1583035861208

每月攒钱：

银行卡余额

每一个月:

    如果（if）今天是9日:

    ​	发工资

    ​	银行卡余额 = 银行卡余额+工资

    如果（if）今天是12日:

    ​	还房贷

    ​	银行卡余额 = 银行卡余额 -月供

    如果（if） 车没油了:

    ​	加油

    ​	银行卡余额 = 银行卡余额 -油费

    如果（if）到了下个发薪日：

    ​	本月攒钱 =  银行卡余额 - 上月余额
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

小结：

需要多次重复执行的代码，可以用循环的方式来完成

使用循环可以提高代码的重复使用率，使得编码更高效

while 条件:
  条件满足时，做的事情 1
  条件满足时，做的事情 2
  条件满足时，做的事情 3
  ...(省略)...
1
2
3
4
5

一个例子：

计算 1~100 的累积和（包含 1 和 100）

#定义一个初始变量
n=1
sum =0
#条件
while n <= 100:
    # 执行的逻辑代码
    sum += n
    # 增量
    n += 1
#输出5050
print(sum)
1
2
3
4
5
6
7
8
9
10
11

注意: 为了验证程序的准确性，可以先改小数值，验证结果正确性后，再改成1-100做累积

练习：计算1-100范围内偶数的和

1583035861208

分析: 1-100之内的偶数，即2+4+6+8+.....（先判断是否满足1-100以内，然后再看是否是偶数）

得到偶数的方法如下：

  • 偶数即是和2取余结果为0的数字，可以加入条件语句判断是否为偶数，为偶数则累加
  • 初始数为0或者2，然后计数器每次加2（控制计数器为偶数）

方法一：条件判断和2取余数则累加

#方法1 判断条件，满足条件判断是否为偶数，是偶数相加
n = 1
sum = 0
while n <= 100:
    if n % 2 == 0:
        sum += n
    n += 1
# 输出2550
print(sum)
1
2
3
4
5
6
7
8
9

方法二：计数器控制

# 方法2 直接让累加量为偶数，然后判断累加量是否在1-100之间，满足条件加和
i = 2
sum = 0
while i <= 100:
    sum += i
    i += 2
# 输出2550
print(sum)
1
2
3
4
5
6
7
8

# 10.9 while嵌套

需求

*****
*****
*****
*****
*****
1
2
3
4
5

代码

分析: 一行输出5个星号，重复打印5行

i = 1
while i <= 5:
	print("*****") 
    i += 1
1
2
3
4
5

打印三角形

三角形

*
**
***
****
*****
1
2
3
4
5

分析：

每一行输出星星的个数和行号是相等的，

每行：重复打印行数个星号，将打印行星号的命令重复执行5次实现打印5行

i = 1
# i用来控制行数
while i <= 5:
    j = 1
    #j用来控制每行显示的*
    while j <=i:
        # print()里面加入end=''结束符，禁止换行
        print('*',end="")
        j += 1
    # print()默认换行
    print()
    i += 1
1
2
3
4
5
6
7
8
9
10
11
12

1583063685893

# break和continue

break 和 continue是循环中满足一定条件退出循环的两种不同方式

# 10.10理解

举例子：一共吃5个苹果，吃完第一个，吃第二个...这里''吃苹果''的动作是不是重复执行？

情况一：如果吃的过程中，吃完第三个就吃饱了，则不需要再吃第四个和第五个了，即是吃苹果的动作停止，这里就是break控制循环流程，即终止此循环

情况二: 如果吃的过程中，吃到第三个苹果吃出来一个大虫子...是不是这个苹果就不吃了，开始吃第四个苹果，这里就是continue控制循环语句，即退出当前一次循环继而执行下一次循环代码。

# 10.10.1 情况一：break

i = 1
while i <=5:
    # 吃到第三个吃饱了
    if i == 3:
        print(f'第{i}个苹果，我吃饱了')
        break
    print(f'第{i}个苹果了')
    i += 1
1
2
3
4
5
6
7
8

执行结果:

1583062308779

# 10.10.2情况二：continue

i = 1
while i <= 5:
    if i == 3:
        print(f'第{i}个苹果，我吃到了虫子，但是我还没有吃饱')
        # 在continue前一定要修改计数器，否则会陷入死循环
        i += 1
        continue
    print(f'吃了第{i}个苹果')
    i += 1
1
2
3
4
5
6
7
8
9

执行结果

1583062264334

# 10.11 for 循环

用于遍历循环

for (循环变量类型 循环变量名称；循环条件；更新语句) 循环体

# 10.11.1 语法

for 临时变量 in 序列:
    重复执行的代码1
    重复执行的代码2
    ...
1
2
3
4

# 10.11.2 快速体验

str1 = 'testfan'
for i in str1:
    print(i)
1
2
3

执行结果:

1583072490122

# 10.11.3 break

str1 = 'testfan'
for i in str1:
    if i=="f":
        print('遇到f不打印')
        break
    print(i)
1
2
3
4
5
6

执行结果：

1583072655864

# 10.11.4 continue

str1 = 'testfan'
for i in str1:
    if i == 'f':
        print('遇到f就不打印')
        continue
     print(i)
1
2
3
4
5
6

执行结果：

1583072813903

备注：continue就相当于在符合条件的地方做了个标记，然后循环继续进行。

# 8.2 for...else...

# 8.2.1语法

for 临时变量 in 序列:
    重复执行的代码
    ......
else:
    循环正常结束之后要执行的代码
1
2
3
4
5

所谓else指的就是循环正常结束之后要执行的代码，即如果是break终止循环的情况下，else下方缩进的代码将不会执行

# 8.2.2 实例

str1 = 'testfan'
for i in str1:
    print(i)
else:
    print('循环正常结束之后打印的代码')
1
2
3
4
5

8.2.3退出循环的方式

1.break终止循环

str1 = 'testfan'
for i in str1:
    if i =='f':
        print('遇到f不打印')
        break
    print(i)
else:
    print('循环正常结束之后打印')
1
2
3
4
5
6
7
8

执行结果：

1583075118683

不执行else缩进后面的代码

  1. continue控制循环
str1 = 'testfan'

for i in str1:
	if i =='f':
        print('f不打印，其他需要打印')
        continue
    print(i)
else：
	print('循环正常结束之后执行的代码')
1
2
3
4
5
6
7
8
9

执行结果：

1583075365902

因为continue是退出当前一次循环，继续下一次循环，所以该循环在continue控制下是可以正常结束的，当循环结束之后，则执行else缩进的代码。

# 函数的目的

方法的目的是复用代码

使用函数：

方式1

  import winsound
  winsound.MessageBeep()

 方式2

  print("Hello Python")
1
2
3
4
5
6
7
8

# 函数的执行顺序


glo_num = 10

def test1():
    global glo_num
    glo_num = 200

def test2():
    print(glo_num)


# 调用test1函数修改全局变量
test1()
# 调用test2函数打印全局变量
test2()  # 200
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

函数在调用的时候执行

# 函数的返回值

  • 返回值作为参数传递
def test1():
    return 50
def test2(num):
    print(num)

# 调用test1函数把返回值保存到一个变量中
result = test1()
# 把保存test1函数返回结果的变量传给test2作为参数
test2(result) # 50
1
2
3
4
5
6
7
8
9

思考：如果一个函数想返回两个结果怎么办？可以用两个return去实现吗？

def test1():
    return 1
    return 2
#调用test1()
result = test1()  
print(result)  # 1   函数遇到return就会终止程序
1
2
3
4
5
6

回答: 只执行了第一个return，原因是因为return可以退出当前函数，导致return下方的代码不会执行

思考:如果一个函数要有多个返回值，该如何书写代码？

def return_num():
    return 1,2

result = return_num()
print(result)  # (1,2)
1
2
3
4
5

# 函数的参数

带参数的方法:调用函数的时候根据函数定义的参数位置来传递参数

def user_info(name,age,gender):
    print(f'您的名字是{name},年龄是{age},性别是{gender}')
    

#按照顺序传入参数
user_info('布尔',30,'男')

# 使用参数名传入
user_info('布尔',age=30,gender='男')  #位置参数要放在关键字参数的后面，关键字参数不要求顺序，无所谓
user_info('布尔',gender='男',age=30)
1
2
3
4
5
6
7
8
9
10

注意：传递和定义参数的顺序及个数必须一致

缺省参数:缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值(注意：所有位置参数必须出现在默认参数前，包括函数定义和调用)

def user_info(name,age,gender='女'):
    print(f'您的名字是{name},年龄是{age},性别是{gender}')
# 调用函数，使用默认参数，不传gender
user_info('yaoyao',18)
# 调用函数，更改默认的参数值
user_info('tom',age=23,gender='男')
# 调用函数，关键字参数不区分顺序，只要在位置参数后面就可以
user_info('jack',gender='男',age=25)
1
2
3
4
5
6
7
8

注意：函数调用时，如果为缺省参数传值则修改默认参数值；否则使用这个默认值

# 综合练习

# 需求如下：

以一个月为期限，

一张一卡通乘坐北京轨道交通累计消费满100元后，下一次开始乘车时有8折优惠；

满150元后，下一次开始乘车时有5折优惠；

支出累计达到400元后，就将不再享受打折优惠。

一卡通卡轨道交通支出累计记录每自然月底清零,下自然月重新累计

我的题目：我每天通勤的无折扣票价是12元，一个月上班22天要花多钱？

# 思考如何计算

Day1：12

Day2：12+12 <100

Day3：24+12 <100

编写伪代码：

  新建变量-累计消费金额

  每日消费进行循环相加，总共22次：

  如果累计消费金额>100，累计消费增加12*0.8

  如果累计消费金额>150，累计消费增加12*0.5

  如果累计消费金额>300，累计消费增加12元

  没有上述情况，累计消费增加12元
1
2
3
4
5
6
7
8
9
10
11
12
13

[toc]

#python自动化#自动化入门
上次更新: 2023/09/05, 02:16:11
概述
基础数据类型_改

← 基础数据类型_改→

最近更新
01
aboutforLLM
09-19
02
30.快速实现接口重构测试---deepdiff库使用
09-21
03
概述
09-07
更多文章>
Theme by Vdoing | Copyright © 2018-2025 Evan Xu | MIT License