[开发工具]python 学习笔记

搭建开发环境

必须有一台可以正常使用的计算机，并且它连接了互联网，要是性能不算太差那就更好了，会使用电脑打游戏或者办公，一定要会一些初中的数学知识。

1、所谓的“开发环境”可以理解为，计算机操作系统 + python解释器 + 代码编辑器，当我们拥有了自己的开发环境，就可以写出各式各样程序了。

计算机操作系统（也叫做平台）主要分为Windows、Linux、Mac等，使用那个平台都可以，自己习惯就好。

Python解释器（就是一个软件），作用是将我们编写的python代码翻译成机器能够识别的机器码(人与计算机之间的翻译软件)。根据操作系统的版本情况，选择合适的解释器版本。

代码编辑器就是编写代码的地方，选择一个代码编辑工具，可以使用文本编辑器（记事本），也可以使用IDE编辑器（Pycharm、VScode），那个顺手就使用那个。

2、其实我们需要做的事情，就是在自己的电脑里安装上python解释器软件，仅此而已。

首先查看操作系统的版本信息（这里以windows为例，如果使用别的系统不会装软件，建议切换回windows继续学习）（如果不知道怎么查看，那么建议利用互联网找出答案，并且今后会经常用到搜索引擎）。

进入python官方网站（https://www.python.org），找到下载页面（downloads），选择适用于当前操作系统的python3以上版本的解释器（注意区分32位和64位）（全是英文看不懂怎么办？那就翻译它，并且今后会经常用到翻译工具）。

下载并且安装解释器（windows平台安装软件通常都是一路下一步），注意类似“add Python 3.8 to PATH” 的这种选项一定要勾选上（目的是将python解释器添加到系统的环境变量中，之后就可以通过命令行的方式使用python解释器。如果忘记勾选了，用最简单的方法，重新安装解释器），一路选择默认直到安装完毕。

最后还需要验证一下，启动cmd命令行工具，在对话框中输入python，然后回车，如果看到输出内容的最后有’>>>'提示符，则说明python解释器安装成功并且可以运行了。
注意：如果调用python解释器不成功，则强烈建议利用搜索引擎和翻译工具，逐步找出解决问题的办法（不用理解具体的原因，但是python解释器必须要安装成功），直到看见">>>"。

编写第一个程序

认识一个python的内置方法print()，作用是将括号内的内容打印输出（调试程序的时候经常使用）。

1、编写代码文件

打开笔记本，顶行顶格编辑代码内容，print("hello world")，注意：编辑代码时，请使用纯英文的方式输入各种符号（上例中的括号和引号）；括号和引号要成对出现（单引号和双引号不能交叉使用）；不要随意键入空格（上例代码中只有一个，在hello的后面）。初学阶段最好纯手敲键盘输入代码，不要使用复制粘帖。

保存文件，命名为“one.py”（.py是python代码文件的格式），这样程序的代码内容编辑完毕。

2、运行代码文件

启动cmd命令行工具，cd命令进入文件所在目录（关于cmd命令的用法，建议随用随查）(也可以在one.py文件位置，按住shift+鼠标右键，在此处打开命令窗口)，执行程序时，命令行工具的当前工作路径要与被执行文件所在的路径一致。

输入python one.py，回车执行。结果输出"hello world"，这就算是写好了第一个python程序并且运行了。注意：“python”后面要有一个空格。

注释

好记性不如烂笔头，注释就是代码里的笔记，养成写合理注释的好习惯非常重要。

注释是给代码编辑者看的，计算机执行程序时遇到注释会忽略跳过。

以"#"关键字开头，后面跟着注释的内容。

# 这里是第一个注释，独占一行的用法。
print("hello world")  # 这里是第二个注释，紧随代码尾部的用法。

变量

正如数学知识中经常使用的变量概念，在我们写程序时也会经常用到。变量可以理解为，存储数据的容器，是数据的载体。

变量名由字母、数字、下划线组成，且开头不能是数字。千万不要使用python的保留关键字（像print、def等）、汉语拼音（遭人鄙视）、中文汉字（过于另类了）。

python是动态语言，在定义变量时，不需要定义类型，直接使用等号赋值就好了，赋值即定义，等号右边是什么值，变量就是什么类型。

a = 1
print(a)
print(type(a)) # 使用type()可以查看数据类型

运算符

我们编写的程序代码中会包含着各种各样的运算符，就像写一道数学运算题。

1、赋值运算符=

等号右边的值赋给等号左边的变量，右边有可能是表达式、函数等，最后的结果都会赋值给左边变量。

a = 1
b = 2-1
print(a)
print(b)

2、算数运算符+、-、×、/

和数学上的加减乘除一致（运算优先级、小括号的使用等，同样也遵循）

a = 1 + 2
b = 1 - 2
c = 1 * 2
d = 1 / 2
print(a)
print(b)
print(c)
print(d)

3、关系运算符>、<、>=、<=、==、!=

关系运算产生的结果只有两种结果，要么是True，要么是False，（==判断是否相等，!=判断是否不相等），注意区分=和==的区别。

a = 1
b = 2
print(a > b)
print(a < b)
print(a >= b)
print(a <= b)
print(a == b)
print(a != b)

4、逻辑运算符and、or、not

逻辑运算产生的结果也只有两种结果，要么是True，要么是False，不同的是逻辑运算符的两边（或单边）是需要布尔型数据的。

and：“且"的意思，都真则真，两边都为"真"时结果才是"真”，否则就是"假"。

a = 1 > 0 and 1 > 0
b = 1 > 0 and -1 < 0
c = -1 > 0 and 1 > 0
d = -1 > 0 and -1 > 0
print(a)
print(b)
print(c)
print(d)

or：“或"的意思，有真则真，两边都为"假"时结果才是"假”，否则就是"真"。

a = 1 > 0 or 1 > 0
b = 1 > 0 or -1 < 0
c = -1 > 0 or 1 > 0
d = -1 > 0 or -1 > 0
print(a)
print(b)
print(c)
print(d)

not：“非"的意思，真假取反，not后面是"真”，则结果是"假"，not后面是"假"，则结果是"真"。

a = not 1 > 0
b = not 1 < 0
print(a)
print(b)

数据类型

针对不同的数据，需要定义不同的数据类型，有了数据类型才能进行有针对性的处理操作（分门别类）。

1、Numbers（数字）

就是数学上的数字（int（整型）、float（浮点）、complex（复数））。

a = 1
b = 1.5
print(a, type(a))
print(b, type(b))

2、String（字符串）

以单引号’ '或者双引号" "括起来的任意的文本内容（只要是引号包裹的就是字符串）。

a = "双引号"
b = '单引号'
print(a, type(a))
print(b, type(b))

3、Bool（布尔）

只有两种状态True和False（表达式成立时返回True，表达式不成立时返回False）（也叫做"真"和"假"），可以直接赋值，也可以通过运算得到。

# 注意布尔值首字母要大写的
a = True
b = False
c = 1 > 0
d = 1 > 2
print(a, type(a))
print(b, type(b))
print(c, type(c))
print(d, type(d))

数据结构

1、list列表

一种有序的集合（排队、队列），列表中每个位置都有一个索引值（从0开始计数），并且每个位置可以存放任意数据（列表嵌套也可以，那是多元列表）。有了列表，我们可以有序统一的管理数据（常用的一种数据结构）。

定义列表，使用一对中括号括起来，列表中每个元素使用逗号隔开。

list1 = ["a", "b", "c"]
list2 = ['a', 'name', 1, True]
print(list1)
print(list2)

查看列表长度，使用len()方法，可以获得列表元素的个数。

list1 = ["a", "b", "c"]
list2 = ['a', 'name', 1, True]
print(len(list1))
print(len(list2))

访问列表中的元素，使用索引值实现（当查询的索引超出范围，会报错）。

list1 = ["a", "b", "c"]
list2 = ['a', 'name', 1, True]
# 访问第一个元素，索引从0开始,所以使用[0]
print(list1[0])
# 访问list2的第二个元素
print(list2[1])
# 访问最后一个元素，为了避免超出范围而报错，使用[-1]或者len()-1
print(list1[-1])
print(list2[len(list2)-1])

向列表中追加元素，可以使用append()方法，追加到最后位置。

list1 = ["a", "b", "c"]
list2 = ['a', 'name', 1, True]
list1.append('m')  # 向列表list1中追加元素‘m’
list2.append(11)  # 向列表list2中追加元素11
print(list1)
print(list2)

向列表指定位置插入元素，可以使用使用insert()。

list1 = ["a", "b", "c"]
list2 = ['a', 'name', 1, True]
list1.insert(1, 'm')  # 向索引为1的位置，插入元素‘m'
list2.append(1, 11)  # 向索引为1的位置，插入元素11
print(list1)
print(list2)

删除指定索引位置的元素，可以使用pop()。

list1 = ["a", "b", "c"]
list2 = ['a', 'name', 1, True]
list1.pop(0)  # 删除第一个
list2.pop(-1)  # 删除最后一个
print(list1)
print(list2)

修改（更新）元素，直接使用索引位置赋值。

list1 = ["a", "b", "c"]
list2 = ['a', 'name', 1, True]
list1[0] = 1  # 修改第一个
list2[-1] = False  # 修改最后一个
print(list1)
print(list2)

2、tuple元组

与列表非常相似（把列表的中括号[]改成元括号()，就是元组），但是元组一旦定义时确定了元素，就不能再更改元组内的元素了（初学者完全可以全部使用列表结构，等入门后再使用元组结构）。

list1 = ("a", "b", "c")
print(list1, type(list1))

3、dict字典

字典使用键-值（key-value）存储数据，很像电话本（姓名-号码）的一种数据结构，查找数据速度非常快（也是常用的数据结构）。

列表使用的是索引顺序，字典使用的是键值字符串。列表节省内存空间，但是查询速度慢；字典查询速度快，但是会多占用内存空间。

定义字典，使用一对大括号{}括起来，内部使用逗号隔开，每个元素就是键-值对（key:value）。

dic = {'zhangsan': 95, 'lisi': 75, 'wangwu': 85}
print(dic)

放入数据，使用键值（key）直接赋值的方式（用法很像列表，只是索引改为键值字符串）。

dic = {'zhangsan': 95, 'lisi': 75, 'wangwu': 85}
dic['zhaoliu'] = 60
print(dic)

修改数据，同样也使用键值（key）修改。

dic = {'zhangsan': 95, 'lisi': 75, 'wangwu': 85}
dic['zhangsan'] = 60
print(dic)

删除数据，使用pop()。

dic = {'zhangsan': 95, 'lisi': 75, 'wangwu': 85}
dic.pop('wangwu')
print(dic)

4、set集合

与字典类似，存储的是键（key），但不存储值（value）。集合中不允许存在相同的key，非常适合数据集合间的计算操作（初学者完全可以全部使用字典结构，等入门后再使用集合结构）。

set1 = {"a", "b", "c"}
print(set1, type(set1))

顺序

任何简单或复杂的程序，都可以通过顺序、分支和循环，三种结构组合而成。

我们编写的程序，交由计算机执行时，顺序是从上至下、从左至右，一句一句的执行，这就是最基本的语句结构。

print("开始")
print(1)
print(2)
print(3)
print("结束")

分支

计算机之所以能够代替人工去完成很多的任务，是因为它可以自己做条件判断。

如果下雨，我就打伞;如果晴天，我就不打伞了。

注意：python有特殊的语法格式，利用缩进四个空格格来划分代码块，有缩进的地方就是一个代码块。

if 条件:
    条件成立时，需要执行程序语句
else:
    条件不成立时，需要执行程序语句

当计算机执行到if关键字时，它会去判断后面条件的返回结果，是“真”还是“假”，是“True”还是“Fales”，“成立”还是不“成立”…就是布尔值的状态。如果是“真”，则会执行if下面的代码块，如果是“假”，则执行else下面的代码块。这样计算机就可以根据不同的条件，执行不同的代码了。

a = 1
if a > 0:
    print("a > 0条件成立，执行的代码块")
else:
    print("a > 0条件不成立，执行的代码块")

a = 1
if a < 0:
    print("a < 0条件成立，执行的代码块")
else:
    print("a < 0条件不成立，执行的代码块")

条件控制语句还可以嵌套使用，写出复杂的条件判断（并不推荐写过于复杂的代码）。

a = 1
if a < 0:
    print("a < 0条件成立，执行的代码块")
else:
    print("a < 0条件不成立，执行的代码块")
    if a == 1:
        print("a == 1条件成立，执行的代码块")
    else:
        print("a == 1条件不成立，执行的代码块")

循环

循环语句可以让计算机反复重复的执行任务，很多很多次的运算，离不开循环语句的使用。

1、for

迭代循环（可迭代对象中每个元素都要计算一遍）。

注意：可迭代对象就是可以一个一个的将元素拿出单独处理的数据，比如字符串、列表、字典等（练习做的多了自然就会理解）。

for 变量 in 可迭代对象:
    执行语句

当计算机执行到for关键字的时候，这时就要循环了，第一次循环，将可迭代对象中的第一个元素拿出，赋值给变量，执行一次循环语句；然后第二次循环，将可迭代对象中的第二个元素拿出…直到可迭代对象中最后一个元素。这样可以将所有元素都处理一遍，达到了循环执行任务的目的。

for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
    print(x)

for x in "hello":
    print(x)

2、while

带条件的循环语句（条件为"真"就执行，直到条件为"假"时，停止循环）（初学者稍有难度）。

while "条件":
	"执行语句"

当计算机执行到while关键字的时候，判断条件的返回值，如果返回"真"，则执行接下来的语句块，之后返回来再判断条件的返回值，如果返回还是"真"，则继续执行…直到返回"假"为止（有些像条件控制，一个重点在分支，一个重点在循环）。

a = 10
while a > 0:
   print(a)
   a = a -1

函数

函数是将一批相关代码进行封装（有组织有预谋），可重复使用的，用来实现特定功能的独立代码块。

函数的调用，只需要函数名加上参数就可以得到返回值了，例如使用print()函数，print就是函数名，括号内的内容就是参数，运行后，打印的内容就是这个函数的返回值，这是官方写好的函数，我们自己也可以写自己的函数。

定义一个函数使用def关键字，依次写出函数名、括号、括号中的参数、冒号，然后在缩进的代码块中编写函数体，函数的返回值用return语句返回。

当调用一个函数时，使用函数名加对应的参数，

def "函数名(参数)":
   "函数体内容"
   return "返回值"

#定义函数abc，功能是将传入的变量参数，自身加1后，返回结果。
def abc(x):
	x = x + 1
	return x

a = abc(1)#调用函数abc，传入参数1，返回值赋值给a
b = abc(2)#调用函数abc，传入参数2，返回值赋值给b
print(a)
print(b)

#定义函数abc，功能是将传入的两个变量参数相加，返回结果。
def abc(x,y):
	return x + y

a = abc(1,2)#调用函数abc，传入参数1和2，返回值赋值给a
b = abc(2,3)#调用函数abc，传入参数2和3，返回值赋值给b
print(a)
print(b)