前言

Python 是一种少有的、既简单又功能强大的编程语言，上手难度相对于其他语言较低，但Python 在通用应用程序、自动化插件、网站、网络爬虫、数值分析、科学计算、云计算、大数据和网络编程等领域有着极为广泛的应用，越来越收到人们的欢迎。它有许多的优点诸如：语言简洁，丰富的库（基础代码库），可扩展性强，可嵌入（Python 可以嵌入到 C/C++程序中），开源等。因此学习它很有必要，之后的一段时间，我将通过一些博文来记录我的Python学习之旅，介绍一些python的基础知识。

Python起源简介

Python由荷兰数学和计算机科学研究学会的吉多·范罗苏姆于1990年代初设计，作为一门叫做ABC语言的替代品。 Python提供了高效的高级数据结构，还能简单有效地面向对象编程。Python语法和动态类型，以及解释型语言的本质，使它成为多数平台上写脚本和快速开发应用的编程语言，随着版本的不断更新和语言新功能的添加，逐渐被用于独立的、大型项目的开发。

常量和表达式

像下面这样把一些量通过运算符进行计算的式子成为表达式，计算的结果称之为表达式的返回值。其中 1 , 2 , 3 这种称为字面值常量；a,b称之为变量；+ - * / 这种称为 运算符 或者 操作符

print(1 + 2)
a = 2
b = 3
print(a + b)

什么是变量

变量就是一个用于存储数据的容器，就是一小块内存空间，里面可以装各种数据类型，我们定义一个变量就是开辟一块内存空间用于存储我们的数据。

我们通过定义变量来存储数据，之后就可以通过变量名来使用我们的变量了，如前面的一些计算结果后面要使用，我们就可以通过定义一个变量来解决，之后通过变量名来使用这个中间变量。例如下面求方差的代码，分别通过定义变量avg,total,result来存储计算过程中的平均数，各个数与平均数差的平方，方差

。

# 如以下代码求四个数字的方差
avg = (67.5 + 89.0 + 12.9 + 32.2) / 4
total = (67.5 - avg) ** 2 + (89.0 - avg) ** 2 + (12.9 - avg) ** 2 + (32.2 - avg) ** 2
result = total / 3

变量的语法

变量的定义

定义变量的语法很简单，左边写变量的名称，右边写变量的值，中间通过一个=进行连接，表示将相应的数据放进左边的空间中。左边可以写多个变量名，通过逗号隔开，右边写上你要定义的变量的值，值之间也是通过逗号隔开。
注意：

• 通过使用不同的变量名来区分变量，变量名不要重复
• = 为赋值运算符, 不是要写成比较运算符==
• 变量的命名要遵守一定的命名规则
• 和 C++ / Java 等语言不同, Python 变量的类型不需要显式指定, 而是在赋值的时候确定的，但是也可以指定。

定义变量举例：

a = 5#第一次定义了变量，下面又对变量的值进行了修改
a, b = 3, 4
print(a, b)

变量的命名规则

硬性规则(务必遵守)

• 变量名必须由数字字母下划线构成，不能包括其他特殊符号
• 数字不能开头
• 变量名不能和 “关键字” 重复
• 变量名大小写敏感. num 和 Num 是两个不同的变量名 软性规则(建议遵守)
• 变量名使用有描述性的单词来表示, 尽量表达出变量的作用，见名知意
• 一个变量名可以由多个单词构成, 长一点没关系, 但是含义要清晰.
• 当变量名包含多个单词的时候, 可以使用驼峰命名法，只有一个单词的时候，单词首字母小写，当有多个单词的时候，第一个单词首字母小写，其余单词首字母大写。
  也可以使用蛇形命名法来进行命名，不同的单词之间使用下划线进行连接，具体的命名规范根据公司的要求即可 命名规则举例：

a = 10
a1 = 20
_a = 3
name = '名字'
# 驼峰命名法，下面的变量名会有绿色的波浪线，这是因为我们写的变量名，编译器检测到不是一个常见的命名
personalInfo = 'zhansan'
# 蛇形命名法
personal_info = 'lisi'
# 错误的命名规则
$ = 3
1a = 20
# 和关键字重复
if = 20
#无意义的命名规则
x = 1
y = 2

【tips】

当我们在写python代码的时候经常可能遇到各种来自编译器的提示，如红色的波浪线是语法错误，灰色波浪线不影响代码的执行，是PEP8代码的规范性问题。如果出现就是你的代码写的不规范造成的，绿色波浪线。不影响你的代码的执行。下面就是一个PEP8的提示，表示我们的代码写的不规范，变量名，=,变量值之间应该有空格隔开。其他的不规范行为提示和这一样，遇到的时候具体情况具体解决。规范的代码书写有利于我们阅读，和后期的程序的维护。直接根据提示解决就行。

使用变量

使用变量很简单，直接操作相应的变量名即可，可以直接打印，也可以通过变量名给其他的变量进行赋值

a = 10#第一次，使用=创建了一个变量
b = a#将a的值赋值给了变量b
print(b)

a = 20#第二次是对变量的值进行了修改,不是重新创建了一个变量
print(a)

变量的类型

不同的变量类型就是对不同类型的数据进行了区分。整形变量里面存的就是整数，浮点数类型里面存的是小数，字符串类型里面存的是字符串等等。

整数

a = 10
print(type(a))#type 和 print 类似, 也是 python 内置的函数. 可以使用 type 来查看一个变量的类型.

注意: 和 C++ / Java 等语言不同, Python 的 int 类型变量, 表示的数据范围是没有上限的,它能够根据存储的数据进行动态的扩容， 只要内存足够大, 理论上就可以表示无限大小的数据,因此也不需要其他的数据类型了，如short,long，只要一个int就可以搞定所有的情况。默认占用的内存空间是4个字节。

浮点数(小数)

a = 0.5
print(type(a))

注意: 和 C++ / Java 等语言不同, Python 的小数只有 float 一种类型, 没有 double 类型. 但是实际上Python 的 float 就相当于 C++ / Java 的 double, 表示双精度浮点数，双精度浮点数表示的数据范围，和精确度都比较高，因此在python里面也只需要float这一种数据类型即可表示所有的小数了，默认占用8个字节的空间、

字符串

a = 'hello'
print(type(a))

注意: 因为在python中不区分字符和字符串，一个字符可以看做是长度为1的字符，所以单引号或者双引号或者三引号包裹起来的数据都叫做字符串。字符串是可变长，大小也是没有限制，字符串越长，字符串占用的内存空间就越大。
定义字符串示例：

c = 'hello'
print(type(c))

d = "hello"
print(type(d))

e = '''haha'''
print(type(e))

f = """hehe"""
print(type(f))

通常情况下，字符串里面是不能有和外面一样的引号的，这时会造成语法错，如果字符串内容里面包含了单引号，那么就使用双引号把内容扩起来。如果内容包含了双引号那么就使用单引号把内容扩起来，如果内容里面既包含单引号也包含双引号就使用三双引号把字符串的内容给括起来。情况举例如下：

e = 'My name is "lmm"'
print(type(e))
f = '''My 'name' is "lmm"'''
print(f)

使用len()内置函数求字符串的长度

print(len(d))

在python中也有字符串拼接的操作，使用+号将字符串进行拼接，但是只能是字符串和字符串进行拼接，不能是字符串和数字之间进行拼接或者字符串和其他的数据类型的拼接，否则会出错，这点和java是非常不同的。

a1 = 'hello'
a2 = 'world'
print(a1 + a2)#打印helloworld

拼接出错的代码

a1 = 'hello'
a2 = 'world'
print(a1 + a2)
a3 = 2
print(a1+a2+a3)

布尔

布尔类型是一个特殊的类型, 取值只有两种, True (真) 和 False (假).，经常用于条件判断，默认占用的内存空间大小为一个字节。

a = True
print(type(a))
b = False
print(type(b))

除了上述类型之外, Python 中还有 list, tuple, dict, 自定义类型等，这些类型之后再进行介绍。
数据类型总结：

为什么会有这么多的变量类型呢？经过上面知识的学习，可以总结出一下几点：

• 不同的变量类型对数据进行了不同的分类，相同的数据类型往往具有相同的特性和使用规则
• 类型决定了数据在内存中占据多大空间
• 类型其实约定了能对这个变量做什么样的操作

动态类型的变量

在 Python 中, 一个变量是什么类型, 是可以在 “程序运行” 过程中发生变化的. 这个特性称为
“动态类型”，如下面的代码在程序执行过程中, a 的类型刚开始是 int, 后面变成了 str。

a = 10
print(type(a))
a = 'hello'
print(type(a))

注意：C++/Java 这样的语言则不允许这样的操作. 一个变量定义后类型就是固定的了. 这种特性则称为 “静态类型”
静态类型的语言有优点也有缺点：

• 对于中小型程序, 可以大大的解约代码量(比如写一段代码就可以同时支持多种类型)
• 对于大型程序, 则提高了模块之间的交互成本. (程序猿 A 提供的代码难以被 B 理解，A写的一个模块给B使用，B对于这个模块里面的数据类型不清楚，两者就要进行沟通了)

注释

注释是什么

注释是一种特殊的代码, 它不会影响到程序的执行, 但是能够起到解释说明的作用,
能够帮助程序猿理解程序代码的执行逻辑。如下面的代码，如果没有注释, 直接阅读, 是不容易 get 到代码的含义是计算方差. 但是通过加了一行注释解释一下, 就让人一目了然了，这样有助于后面代码的维护。

注释的基本语法

行注释：使用#开头的都是一个注释，这个注释一般放在一行代码的上面或者右边，几乎不会写到一行代码的下面和前面，使用ctrl+/选中多行进行行注释

# 这是一个注释
print("haha")# 打印输出

文档注释：使用三引号引起来的称为 “文档字符串”, 也可以视为是一种注释，一般放在一个文件/函数/类的前面用于描述这个文件，函数，类，里面可以包含多行内容

"""
这是文档字符串
这是文档字符串
"""

注释的书写规范

• 内容准确: 注释内容要和代码一致, 匹配, 并在代码修改时及时更新.
• 篇幅合理: 注释既不应该太精简, 也不应该长篇大论.
• 使用中文: 一般中国公司都要求使用中文写注释, 外企另当别论.
• 积极向上: 注释中不要包含负能量(例如 领导 SB 等).

输入输出

和用户交互：

• 用户把信息传递给程序的过程, 称为 “输入”
• 程序把结果展示给用户的过程, 称为 “输出”
• 输入输出的最基本的方法就是控制台. 用户通过控制台输入一些字符串, 程序再通过控 制台打印出一些字符串,比如我windows的cmd窗口，pycharm的运行展示结果的的程序都是一个控制台

通过控制台输出

通过控制台输出：控制台能够输出各种类型的数据，整数，小数，布尔类型的数据等。

print('hello')
a = 10
print(a)
b = True
print(b)

格式化输出

按照一定的格式，在字符串中使用变量，将变量的值进行输出。
通过字符串格式化输出函数.format():

• 可以在任意的 Python版本中使用
• 字符串中需要使用变量的地方,使用{}进行占位
  在format 的括号中按照占位的顺序,将变量写上去

# 我的名字是 xx, 年龄 xx 岁, 性别为 xx.
name = '小明'
age = 18
sex = '男'
print('我的名字是 {}, 年龄 {} 岁, 性别为 {}.'.format(name, age, sex))

试用F-string的方式：

• python 3.6 版本开始可以使用,即大于等于3.6可以使用
• 在字符串前边加上f’’或者F’’
• 字符串中需要使用变量的地方,使用{}进行占位
• 将变量直接写在占位的大括号中

# 我的名字是 xx, 年龄 xx 岁, 性别为 xx.
name = '小明'
age = 18
sex = '男'
print(f'我的名字是 {name}, 年龄 {age} 岁, 性别为 {sex}.')

输入

Python 中使用intput()函数获取到用户的输入，用户输入的内容都被转化为字符串类型，不管你输入什么样的类型。
使用input()输入格式：

• 变量= input(‘给使用者的提示信息,即告诉别人输入什么内容’)
• 代码从上到下执行，当代码执行遇到input 的时候,会暂停代码的执行,等待用户的输入
• 在输入的过程中,如果遇到回车键,表示本次输入结束
• 使用input获取的内容，都是字符串类型,即str

代码示例：

# 需求, 从键盘录入你的姓名
name = input('请输入你的姓名:')
print(type(name), name)  # 打印类型和变量的值，这里是个字符串

转义字符

转义字符就是将两个字符转义成一个特殊的字符，\n是一个回车或者换行。\t是一个水平制表符，例如我们在使用print()函数进行打印的时候，print()函数中有一个end="\n"所以使用print进行打印的时候会换行。
转义字符代码示例：

print('hello world', end=' ')
print('hello\nworld')
print('hello python')
print('hello\tpython')

结果展示：

运算符

算数运算符

像 + - * / % ** //等这种进行算术运算的运算符,称为算术运算符，运算符的执行顺序比较简单，先算乘方，后算乘除，最后算加减，如果有括号先算括号。
+， - * / 运算符，这四个运算符比较简单，表示的含义和我们数学上的加减乘除表示的含义是一样的,只是这个/需要注意，这里的整数除以整数结果为小数，不管可以除尽还是不能除尽结果都是小数，也就是要除尽，和c/java不同，它们整数除以整数结果任然是整数，除不尽时会进行截断，就是保留整数部分，把小数部分丢弃。
代码示例：

print(3 + 2 - 1)
a = 15 / 3
print(type(a))
print(a)
b = 1 / 3
print(type(b))
print(b)
print(a * b)

结果展示：

%求余运算符，就是对结果进行求余数
代码示例：

print(7 % 3)

** 是求乘方. 不光能算整数次方, 还能算小数次方

print(4 ** 2)
print(4 ** 0.5)

//是取整除法(也叫地板除). 整数除以整数, 结果还是整数，有一个为小数，结果就是小数，除得的结果只保留整数部分(舍弃小数部分, 并向下取整. 不是四舍五入)

a = 7 // 2
print(a)
print(type(a))
b = 7 // 2.0
print(b)
print(type(b))

关系运算符

像 < <= > >= == != 这一系列的运算符称为 关系运算符, 它们是在比较操作数之间的>关系，如果关系符合, 则表达式返回 True. 如果关系不符合, 则表达式返回 False。

• <= 是 “小于等于”
• “>=” 是 “大于等于”
• == 是 “等于”
• != 是 “不等于”
  整数的比较：

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

浮点数的比较，对于浮点数进行比较相等，不能使用==，因为计算机中不能准确的表示浮点数，因此在计算过程中,就容易出现非常小的误差，这种误差是不能规避的，这种误差是由于浮点数的设计带来的，不仅Python如此，很多编程语言都是这样的。

print(0.1 + 0.2 == 0.3)
print(0.1)
print(0.2)
print(0.1 + 0.2)
print(0.3)

上面代码的运行结果为：

从上面的代码执行结果可以看出，0.1和0.2相加的和并不是等于0.3，而是比0.3大，带有很小的误差，这个误差对程序一般没有多大影响，可以忽略，但==是一丝不差的严格进行比较相等，所以相加的结果和0.3进行比较肯定就是不相等的了。
正确的比较方式: 不再严格比较相等了, 而是判定差值小于允许的误差范围，实际工作中, 误差在所难免, 只要保证误差在合理范围内即可。

a = 0.1 + 0.2
b = 0.3
print(-0.000001 < (a - b) < 0.000001)

逻辑运算符

像 and,or,not 这一系列的运算符称为 逻辑运算符.

• and 并且. 两侧操作数均为 True, 最终结果为 True. 否则为 False. (一假则假)
• or 或者. 两侧操作数均为 False, 最终结果为 False. 否则为 True. (一真则真)
• not 逻辑取反. 操作数本身为 True, 则返回 False. 本身为 False, 则返回 True
  代码示例：

# a < b and b < c 这个操作等价于 a < b < c . 这个设定和大部分编程语言都不相同，写起来非常的方便
a = 10
b = 20
c = 30
print(a < b and b < c)
print(a < b and b > c)
print(a > b or b > c)
print(a < b or b > c)
print(not a < b)
print(not a > b)

短路问题： 和其他编程语言类似, Python 也存在短路求值的规则，规则如下：
对于 and, 如果左侧表达式为 False, 则整体一定为 False, 右侧表达式不再执行
对于 or, 如果左侧表达式为 True, 则整体一定为 True, 右侧表达式不再执行

a = 10
b = 20
c = 30
print(a > b and 10 / 0 == 1)# 这里0作为除数，没有抛出异常，就是没有执行
print(a < b or 10 / 0 == 1)# or左侧的条件为真后右边的条件就在执行了，后面的那个条件就不执行了

执行结果如图：

赋值运算符

= 的使用

• = 表示赋值. 这个我们已经用过很多次了. 注意和 == 区分.
• = 除了基本的用法之外, 还可以同时针对多个变量进行赋值
  代码示例：

# 常规赋值
a = 1
# 多元赋值
b, c = 1, 1
# 链式赋值，先把3的值赋给b,再把b的值赋值给a
a = b = 3

通过赋值运算符交换两个变量的值，代码如下：

# 常规写法
a = 10
b = 20
tmp = a
a = b
b = tmp
# 使用多元赋值, 直接一步到位完成交换，很方便的写法
a, b = b, a
print(a, b)

复合赋值运算符

形如+= -= *= /= %=等的运算符称为复合运算符，这样的运算符不仅Python当中有，主流的编程语言中都有，是对一些操作的简写。如a+=1等价于a=a+1，先和后面的数字进行运算，再进行赋值。
代码示例：

a = 1
a = a * 8  # a=8
print(a)
a *= 6  # a=8*6
print(a)

运算结果：

**【注意】**形如a+=1,这样的代码我们在c/java中也可以写成a++/++a使a的值自增1，但是Python中却不支持这样的操作，因为这样的操作容易混淆，不是特别的方便，a++是先使用a的值再进行自增的，而++a是先自增a的值，再进行使用的。

除了上述之外, Python 中还有一些运算符, 比如 身份运算符 (is, is not), 成员运算符 (in, not in), 位运算符( & | ~ ^ << >>) 等.这里不做介绍。大家可以下来在看看相关书籍了解下，本篇博客要介绍的知识到此就结束了，下篇博客见。(^▽)(^▽)(￣▽￣)~*。