引言

都是我手欠非要报什么python的计算机二级，现在好了假期不但要冲C艹，还要学个python，用了几天的时间速成了一下python的基础语法，其实在学会C的基础上，py学起来是非常的快啊。这篇博客呢，建议有一定语言基础的朋友来看。没有接触过编程的朋友可以先看看python相关书籍或视频从0到1学，这里我推荐蟒蛇的python，浅显易懂。那么就开始接下来的正文内容吧。

Python环境配置

想要进行Python开发，就要搭建好Python的环境

需要安装的环境主要是两个部分：

• 运行环境：Python
• 开发环境：Pycharm

安装Python

（1）找到官方网站

认准这个英文标了官方的网站，别的什么中文版官版什么的都别看，是假的，点进去都是收费的

（2）找到下载页面

点入网页后，鼠标放到download上，根据电脑配置点击，例如我的电脑是Windows系统，就点击Windows 

点进去后会进入到这样一个页面里，你可能会注意到版本有非常之多，我们从左边随便点一个版本下就行，具体差异不是很大，注意，右边版本Pre-releases是最新一批版本，不够稳定，所以还是下左边较为稳定的版本，可不要下错了。由于python官网服务器在国外，所以下起来相对会比较慢，耐心等待一下就可以了，我这边其实是在联想的应用商店下的，官网在我这里不知为什么下的非常之慢

（3）安装

下好后咱们打开文件 ，会弹出安装界面。这里注意一点，要把下面的勾勾上，讲Python加入路径中去，避免后续一系列问题。然后点击Install Now

当你看到这样的页面的时候，python解释器就已经下好了

 这时候其实已经可以在控制台敲python的代码了，但是为了更舒适的写python代码，我们还需要安装一个集成开发环境，也就是pycharm。

安装pycharm

（1）找到官方网站

图中第一个就是官网了 

进去后点击中间的download

（2）下载和安装

根据电脑配置下载，注意下社区版（Community），专业版要钱

打开文件点击next

这里文件下载路径根据需求就行

这里勾这两个

后面就没什么要注意的了，一路next就行，看到以下页面就是安装完成了

现在你已经可以点开pycharm开始写python代码咯！

Python中的打印，变量声明和数据类型

数据打印

print(1 + 2 - 3)
print(1 + 2 * 3)
print(1 + 2 / 3)

这里稍微注意一下python中除号（/）是直接将整型转化成了浮点型 

数据类型

这里要说明的是，python中，初始化变量统统都不用事先声明类型了直接将数据用赋值运算符（=）赋给你初始化的变量就行，见下方代码

# 整型
a = 1
print(type(a))
# 浮点型
b = 2.2
print(type(b))
# 字符串类型
c = 'hello'
d = "world"
print(type(c),type(d))
# 布尔类型
e = True
f = False
print(type(e))
print(a)
print(b)
print(c)
print(d)

下面是运行结果 

这里稍微注意一下，type（）是可以直接取到变量类型的内联函数 ，不用包含任何文件，可以直接调用

整型

python中的整型可以自动扩容（自带高精度），意思就是不再像C语言中不同的整型能存的数据大小有一个范围，在python中声明的整型的大小没有上限，可以随意的加减，不用考虑数据溢出的问题了

浮点型

python中的浮点型只存在一种类型，就是C语言中的double类型，看似类型打印的是float实则C中的float在python中已经不复存在

字符串类型

python中单引号和双引号引起来的都是字符串类型，但注意必须是英文字符的单引号和双引号

同时，如果字符串中有单引号，可以用双引号引起；如字符串中有双引号，同样也可以用单引号引起；如都有，可以选择使用三引号，三个'或者三个"都可以

a = "I' am a boy"
b = 'hhh,"hello",hhh'
# 三引号
c = '''hh'hhh"h'hhh'''
print(a)
print(b)
print(c)

下面是运行结果

同时python中字符串支持拼接

a = 'hello'
b = ' world'
c = a + b
print(a + b)
print(c)

 其实感觉这个学了C++的应该会熟悉，STL容器中string类就支持这样的操作

这里要注意的是：字符串和数字不可以混合相加，同时字符串直接也不支持减法运算

布尔类型

布尔类型只有真和假，主要用于逻辑判定

• 真（True）
• 假（False）

在JAVA和C/C++中，bool（布尔）类型为true和false，python中的bool类型首字符都是大写的，不要搞混了

如果将bool类型与整型进行加减运算，那么True会被转成1，而False会被转成0，但是这样的操作没有什么实际意义

类型带来的意义

1. 不同类型所占的内存空间不同（单位：字节）                                                                          eg：int：默认4，溢出就扩容；float：固定8；bool：1；str：变长
2. 不同类型对应的操作也是不同的                                                                                                eg：int/float +-/  不能用len()  #计算字符串类型长度的内联函数                                                        str +但不能-*/ 能用len()

动态类型

程序再运行过程中，变量的类型可以改变，见代码

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

以上代码运行的过程中，a的类型一直再改变，但再python中是支持的

在其他语言，例如C/C++，JAVA中，变量都是静态类型，程序运行中，变量的类型是始终不变的

注：一个编程语言，是否为动态类型，只是取决于运行时，类型是否发生改变，不取决于变量定义的时候是否声明类型。 

其实在python中也提供了类型的声明，不多这个类型声明起的作用只是更方便人读代码

a: int = 10
b: float = 1.5
c: str = 'abc'

其他类型

基本类型先介绍到这，还有list（列表），tuple（元组），dict（字典），自定义类型等后面再介绍

python中的报错

• 语法错误：python解释器可以识别
• 逻辑错误：运行对应的代码才能发现

python报错一般会把问题描述的很详细，这对代码错误的排查很有利

这里其实已经可以基本看到python的设计哲学了：

解决一个问题，只提供一种方案~

Python中的注释

前面也有用到，见下面代码

# 我是注释
a = 10  # 我是注释
"""
文档字符串
这是文档字符转
起到的作用和注释一样
"""
print(a)
'''
文档字符串
这是文档字符转
起到的作用和注释一样
'''

emm，想必根据代码和打印结果我们也可以猜出来python注释的用法了

#其实就是C语言中的 //

"""   """和'''   '''其实就是C语言中的 /*   */

Python中的输入输出

输出：print

# 如果要用print打印"a = 20"->字符串和数字混合
a = 20
print(f'a = {a}')

单引号前的 f 作用是格式化字符串，在格式化之后，可以使用{ }往字符串中嵌入变量/表达式

输入：input

num = input('请输入一个整数:')
print(f'你输入的整数为:{num}')
print(type(num))

在这里需要注意的是打印出来num的数据类型是str字符串类型

如果想要用输入的数字进行计算，可以使用强制类型转换 int( )

a = input('输入整数a:')
b = input('输入整数b:')
a = int(a)
b = int(b)
print(a + b)

不但可以强转成整型，python中还提供了：

• str() -> 整数转字符串类型
• float() -> 字符串转浮点数类型

等等

算数运算符

关于运算符先算乘除后算加减之类的我就不赘述了

• + :加号
• - : 减号
• * : 乘号
• / : 除号，无法整除会直接计算乘小数并返回赋值
• ** : 乘方运算，eg：  x**2，这个代表x的平方
• // : 地板除法，等价于C语言中的 / ，eg：7 // 2，结果为3
• % : 和C语言中的%一样，eg：7 % 2，结果为1

这里还要注意关于%（取余）运算的一点

• 在C/C++和JAVA中   -19 % 2 => -1
• 而在python中   -19 % 2 => 1

关系运算符（返回bool类型）

<  <=  >  >=  !=  ==

这个关系运算符和C中的一样

要稍微注意一点的就是，python中的字符串类型可以使用关系运算符，比较规则其实就是字典序，谁在字典序的前面谁就小

如果字符串为中文，针对中文进行字符串大小的比较其实是没有意义的

这里还需注意，针对浮点数，使用 == 是存在风险的，所以比较浮点数一般做差看误差范围

逻辑运算符

• and 并且，等价于C语言的&&
• or 或者，等价于C语言的||
• not 逻辑取反，等价于C语言的！

同时python中的逻辑运算符也遵循短路求值

and 的左边为False 右边的条件语句就会放弃执行

or 的左边语句为True 右边的条件语句同样也放弃执行

赋值运算符

# python中支持连续初始化赋值
a = b = 20
print(a, b)
# python中支持下面列表式的初始化及赋值
c, d = 10, 20
print(c, d)
# 在python中支持下面的变量交换
c, d = d, c
print(c, d)

 符合赋值

+=  ，-=  ，*=  ，**=  ，%=  ，/=  ，//=

a += b相当于a = a + b

a -= b相当于a = a - b

a *= b相当于a = a * b

...以此类推

a = 10
a /= 2
print(a)

在python中不再支持C语言中的++，--操作 

用+=其实就已经很方便了

其他

python中还有一些运算符

身份运算符（is，is not），成员运算符（in，not in）

位运算符（&，|，~，^，<<，>>）等

顺序语句

从上往下按顺序执行的语句

print('111')
print('222')
print('333')

 

条件语句（分支语句）

在python中，不再使用{ }来框定代码块，而是单纯使用缩进，同一代码块的缩进级数相同

A.

if expression:

        do_somwthing1

        do_something2

next_something

choice = input('输入1:')
if choice == '1':
    print('你输入了1')
    print('这还在if的代码块中')
print('结束')

 

B.

if expression:

        do_something1

else:

        do_something2

choice = input('输入1:')
if choice == '1':
    print('你输入了1')
else:
    print('输入了别的')
print('结束')

 

C.

if expression1:

        do_something1

elif expression2:

        do_something2

else:

        do_something3

choice = input('输入1或2:')
if choice == '1':
    print('你输入了1')
elif choice == '2':
    print('你输入了2')
else:
    print('输入了别的')
print('结束')

 

 注：python中的代码块还支持嵌套，见代码

a = '1'
b = '3'
if a == '1':
    if b == '2':
        print('bbb')
    print('aaa')
print('ccc')

 if else elif while for ……这种跟上代码块的部分，都需要用缩进来表示

下方的两份代码缩进都是有问题的（缩进不一致），都会导致编译报错

a = '1'
if a == '1':
print('bbb')
    print('aaa')

a = '1'
if a == '1':
    print('bbb')
        print('aaa')

多级嵌套时，当前语句属于哪个代码块，完全取决于缩进级别

到这里讲完了条件语句，还要提醒大家一点，python中只提供了if else elif ，而C语言中的switch并未在python中提供

空语句

a = '1'
if a == '1':
    # 什么都不做
else:
    print('aaa')

上面这份代码其实是有问题的，在python可以跟语句块的控制语句之后，默认需要跟上至少一条语句，否则编译器会报错，此时如果需要语句什么都不做，可以使用pass语句，见代码

a = '1'
if a == '1':
    pass
else:
    print('aaa')
print('hello')

此时的代码才是正确的

循环语句

 python中循环语句提供了 while 和 for

 A.while循环

while 条件：

        循环体

# 代码案例
num = 1
while num <= 10:
    print(num)
    num += 1

 B.for循环

for 循环变量 in 可迭代对象

        循环体

# 代码案例
for i in range(1, 11):
    print(i)

这里的range是一个内建函数，起到的作用是得到一个“可迭代对象”，其中包含了一系列的整数

range(beg，end) => [beg，end)，前闭后开区间

下面是代码案例打印结果

range还提供了第三个参数~表示“步长”，其中步长默认为1

如果你想打印2，4，6，8，10，可以像下面这样写

# 代码案例
for i in range(2, 12, 2):
    print(i)

同时步长还能为负，如果你想打印10到1，可以这样写

# 代码案例
for i in range(10, 0, -1):
    print(i)

控制语句break和continue

python中同样还提供了控制语句continue和break，执行到continue回到条件重新开始语句，执行到break直接跳出语句

# 代码案例
for i in range(5, 0, -1):
    if i == 3:
        continue
    print(i)

# 代码案例
for i in range(5, 0, -1):
    if i == 3:
        break
    print(i)

 函数

函数是什么？简单来说就是一段可以重复使用的代码~

1.函数的定义（分配任务）

def 函数名 (形参列表)：

        函数体（记得带一层缩进）

        return 返回值（更具需求判断是否需要）

2.函数的调用（开始完成任务）

返回值 = 函数名（实参列表）

这里实际参数需要和形参个数匹配

# 代码案例
def calcSum(beg, end):
    theSum = 0
    for i in range(beg, end):
        theSum += i
    print(theSum)


# 这里调用函数
calcSum(1, 100)
calcSum(300, 400)

这里注意一点，只定义不调用，函数内代码不会执行

python中要求，函数定义写在前面，调用写在后面

这里大家可能也注意到了，python的函数定义时不用声明返回值类型和形参类型，得益于其变量动态类型的特性，下面看一组代码用来体会一下python代码的简单便捷

#代码案例
def add(x, y):
    return x + y


print(add(10, 20))
print(add(1.5, 2.5))
print(add('hello', ' world'))

python函数的返回值

这里专门放个小标题，就是想讲讲python返回值的特殊性

python中的一个函数，可以返回多个值！！！

# 代码案例
def getpoint():
    x = 10
    y = 20
    z = 30
    return x, y, z


# 使用多元赋值接收
a, b, c = getpoint()
print(a, b, c)
# 如果只想要数值中的一部分，可以使用下划线_占位
_, m, _ = getpoint()
print(m)

变量的作用域

函数内部的变量名，只在函数内部有效

# 代码案例
def getpoint():
    x = 10
    y = 20
    print(x, y)


x, y = 20, 30
print(f'x = {x}')
print(f'y = {y}')
getpoint()
print(f'x = {x}')
print(f'y = {y}')

 在函数内部有和函数外部可以使用同名变量，但它们是不同的变量

在外面的变量，全局变量，在整个程序中都有效

在内部的变量，局部变量，在函数内可用

global关键字

既然内部声明的变量无法影响到外部的变量，那如果有函数有这样的需求时怎么办呢，可以使用global关键字，此时，内部变量的改变就可以影响到外面了

# 代码案例
def getpoint():
    global x
    x = 10


x = 20
print(x)
getpoint()
print(x)

if else while for这些关键字会引入“代码块”，但这不会对变量作用域产生影响。在上述语句代码块内部定义的变量，可以在外部被访问！

只有函数和类会影响作用域

函数递归

简单说，就是一个函数调用自己

eg.写一个函数用于计算n！=> {n*(n-1)*(n-2)....*2*1}

用递归实现的话就是这样的

# 代码案例
def factor(n):
    if n == 1:
        return 1
    return n * factor(n - 1)


print(factor(5))

递归的缺点：

1.可能难以理解

2.递归代码容易出现“栈溢出”

3.递归代码一般能转换成等价的循环代码

递归的优点：

代码简洁，尤其处理“问题本身就是通过递归方式定义的”（eg.二叉树）

参数默认值

# 代码案例
def add(x, y, debug = False):
    if debug:
        print(f'x = {x},y = {y}')
    return x + y


# 这里不传debug默认就会是False
print(add(10, 20))
# 打印一下换行将两块分开
print()
print(add(12, 13, True))

 

这里注意一点：

带有默认值的形参，必须放在形参列表的后面，而不能放在前面/中间！！

关键字参数

想不按照顺序传递参数，这时候可以用关键字参数

# 代码案例
def test(x, y):
    print(f'x = {x}')
    print(f'y = {y}')


# 以这样的形式传参，就可以无视传参顺序了
test(x=10, y=20)
test(y=20, x=10)

最后，位置传参和关键词传参可以混着用，但要求位置参数在前，关键字参数在后

小结

本来想一口气把基础语法讲完的，没想到内容有些多，就准备分两部分讲了，这部分内容还是比较简单的，在python的下部分，我会介绍列表（list），元组（tuple），字典（dict）和关于文件操作的内容，如果本篇博客对你有帮助的话，还请留个关注点个小赞在走啊---♥，后续博主还会产出更多有意思的内容。