Python零基础入门-03-Python基础语法

Python零基础入门-03-Python基础语法

本节课的知识点：

1，python系列教程的学习方法。

2，熟悉Python的基础语法内容。

1，python系列课程学习方法

由于python属于脚本语言，如果单纯的解释语法没有什么实在的意义，所以我python系列的课程都是以视频讲解为主，至于这里的文章，是给你复习用的。

2. 基础语法

python的基础语法都将以小例子作为驱动来讲解。如果你有其他编程语言的基础，那么直接看文章就会很快上手。

如果你没有编程语言的基础，那就看我的文章+文章配套视频吧。

基础语法的大纲如下：

基础语法主要分为以下的几块内容：

• python中的数据类型与变量定义：每学习一个编程语言都必须知道这个编程语言中的 数据是怎么表示的。但是每一门编程语言的数据表示形式都是差不多的，所以如果你有过一门编程语言的基础，那么对于这一块内容大致扫一眼就会了。

• python中怎么输入输出：输入输出就是最简单的 人与电脑的交互形式，我们输入一个数据，程序帮助我们计算好这个数据然后再输出。想要实现这个功能，那么我们就必须掌握 输入输出的语法格式。

• python的选择结构：有的时候人做事情会有多个选择，比如说当小明考试不及格会挨一顿打，但是考试及格了就不会挨打。
  如果让程序来判断这个事情，程序执行的时候要怎么判断是打不打小明呢？
  这就是相当于有两段代码，一段代码是打小明，另一段代码是不打小明。如何选择其中的一段代码来执行就是选择结构该做的事情了。

• python的循环结构：日常生活中往往会重复执行一件事情，程序也不列外。老师让小明罚抄作业50遍，于是小明就开始循环50抄写作业了。但是用程序怎么完成呢？

• python的函数结构：函数其实就是一块可以完成特定功能的代码段。他的目的是简化代码结构、减少代码的重复。

基础语法就这么多需要讲的，这些东西基本上是每个编程语言都有，所以，主要还是用案例来讲解语法。

2.1 数据类型与变量定义

编程语言中的 数据类型与变量 其实就是要说明白一个事：数据在程序中怎么定义，怎么使用。

2.1.1 变量定义

python中定义数据的时候，不用专门指出这个数据是什么类型的，python会自己识别。

例子

• a = 34 就是定义了一个整数 34，存放在变量a中。
• b = 9.6666 就是定义了一个小数 9.6666，存放在变量b中。

这就可以看出来，python的语法简洁之处了吧。

2.1.2 数据类型

python中常用的数据类型是：数字(整数int，小数float)、字符串(str)，布尔(bool)，列表(list)、元组(tuple)、字典(dict)等。

Tips1：输出函数 print() 的引入。

在python中的输出非常简单，语法是这样的：print( 你想输出的内容 )

# 输出一个数字 36
print(36)


# 输出一个字符串 Hello World!!!
print("Hello World!!!")

Tips2：python中的注释符号。

在python中的注释符号是 ’#‘，处于他后边的代码都将会被忽视掉。

# print("这是一行被注释掉的语句，所以不会执行")
print("这一行没有被注释，他被输出了！！！")

结果如下：可以看得出来注释的语句并没有执行到。

​

2.1.2.1 数字

python中定义数字的时候，想用什么就给他存放在一个变量中就好了，不用指定变量名数据类型。

代码：

# 定义一个整数
a = 36


# 定义一个小数
b = 12.698752

​

分析：

• a = 36 ：直接定义了一个整数 36，存放在变量 a 中。
• b = 12.698752 ：直接定义了一个小数 12.698752，存放在变量 b 中。

操作：

现实生活中数字可以执行什么操作，那就在python中可以执行什么操作。​

a = 66
b = 3
# 加法
op1 = a + b
print(op1)  # 输出：69
# 减法
op2 = a - b
print(op2)  # 输出：63
# 乘法
op3 = a * b
print(op3)  # 输出：198
# 除法
op4 = a / b
print(op4)  # 输出：22.0
# 求余
op5 = a % b
print(op5)  # 输出：0

​

2.1.2.2 布尔

布尔（bool）就是 真/假 两种情况的数据类型。

程序：

# 1、定义出一个 bool 值为假（False）。
b = False


# 2、输出
print(b)  # 输出：False

​

2.1.2.3 字符串

在python中没有字符与字符串的区别，只存在字符串。

并且成对的双引号、成对的单引号都可以定义出字符串，但是需要注意的是，单引号与双引号可以嵌套使用，但是不可以交叉使用。（具体解释往下看例子）

程序：

# 例子1 ：双引号定义字符串。
str1 = "China"
print(str1)  
# 输出：China


# 例子2 ：单引号定义字符串。
str2 = 'Hello'
print(str2)  
# 输出：Hello


# 例子3 ：如何输出具有引号包围的字符串。
str3 = 'I told my friend, "Python is so simply" '
print(str3)  
# 输出：I told my friend, "Python is so simply"

运行结果：

解释：

• 当一种引号（比如：单引号）处于最外层的时候，他所包裹的字符串中不能再含有这种引号。并且她所包裹的字符串中可以出现其他形式的引号（比如：双引号），其他形式的引号会被当作字符串直接输出。

操作：

字符串往往是一个编程语言操作的核心数据类型，所以python为他准备了许多的操作方法。

# 首字母大写转换
orgin1 = "hello world!!!"
print(orgin1.title())  # 输出：Hello World!!!


# 全部转大写
print(orgin1.upper())  # 输出：HELLO WORLD!!!


# 合并字符串
str1 = "hello"
str2 = "world"
op1 = str1 +" "+str2
print(op1)    # 输出：hello world


# 去除空白格
orgin2 = " hello world "
# 去除开头空白格
print(orgin2.lstrip())  # 输出：hello world 
# 去除结尾空白格
print(orgin2.rstrip())  # 输出：hello world
# 去除 开头+结尾 空白格
print(orgin2.strip())  # 输出：hello world

但是以上操作都没啥大用处，基本不咋用，了解即可，后边用到什么在讲什么。

2.1.2.4 列表、元组、字典

在其他编程语言中存在的数组，在python中称作列表（list）。

元组（tuple）是列表的进一步表示，列表的数据可以修改，但是元组的数据不允许修改。

字典（dict）中存放的每个数据都是 key：value 的形式。

• list列表

python中的列表就是数组，只不过他不用指定数组的长度以及数组中每个数据的类型。

列表使用 [ ] 进行定义。

# 1、定义出一个list。
list = ["Hello", 12, 3.6999, True, '中国']


# 2、输出第 1 个元素。
print(list[0])  # 输出：Hello


# 输出第四个元素内容。
print(list[3])  # 输出：True


# 3、修改 list[3] 的数据
list[3] = False
# 4、输出全部内容
print(list)  # 输出：['Hello', 12, 3.6999, False, '中国']

从中可以看出：

1、定义list的时候不用指定list里边的数据个数，并且使用 [ ] 来包裹元素，并且元素各自的数据类型可以不一样。

2、输出的时候 索引坐标还是从0开始。

3、list允许修改里边元素的内容。

4、直接输出列表名字就可以输出 列表中的全部数据（可以看到原来的 True 被修改为 False 了）。

• tuple元组

元组的定义使用与列表差不多，但是列表使用 [ ] 定义，元组需要使用 ( ) 定义。

并且元组中的数据不可以修改。

# 1、定义出一个 tuple。
tuple = ("Hello", 12, 3.6999, True, '中国')


# 2、输出第 1 个元素。
print(tuple[0])  # 输出：Hello


# 输出第四个元素内容。
print(tuple[3])  # 输出：True


# 3、修改 list[3] 的数据
# tuple[3] = False


# 4、输出全部内容
print(tuple)  # 输出：('Hello', 12, 3.6999, True, '中国')

从中可以看出：

1、定义tuple与list基本一样（元素个数可以不指定、元素数据类型可以不同），但是tuple使用 ( ) 来包裹元素。

2、输出的时候 索引坐标还是从0开始。

3、list不允许修改里边元素的内容，当把  3、的注释去掉，程序会报错。

4、直接输出元组名字就可以输出 元组中的全部数据。

• dict字典

字典中存放的数据都是键值对的形式。使用 { } 进行定义。

键值对：他是数据组织的一种方式。

1、平常我们存放数据的时候只会存放数据的本身，也就是只存放数据的 “值“，然后访问这个数据的时候会根据编号访问( 如 list[0] )。

2、但是键值对的存放形式，要求存放数据值的时候，也要存放这个数据值的索引名字，也就是键。

3，比如：{ ”name“："小明" }，这里边 ”小明“ 就是真实数据值，”name“ 就是 数据值 ”小明“ 的索引，我们访问的时候可以通过 ”name“ 这个索引得到 ”小明“这个数据值。

# 1、定义出一个 dict。
dict = { "name": "小明" ,"age": 23 , "description": "小明是一个好孩子。" }


# 2、输出第 1 个元素。
print(dict['name'])  # 输出：小明


# 输出第四个元素内容。
print(dict['age'])  # 输出：23


# 3、修改 dict['age'] 的数据
dict['age'] = 77


# 4、输出全部内容
print(dict)  # 输出：{'name': '小明', 'age': 77, 'description': '小明是一个好孩子。'}

从中可以看出：

1、定义dict使用 { } 来包裹元素，并且里边定义了三个键值对。

2、输出的时候不再使用索引坐标输出，而是直接使用 “键”名来找到要输出的数据。

3、当然也可以通过 键 索引到数据进行修改。

4、直接输出字典名字就可以输出 字典中的全部数据。

2.1.2.5 数据类型的判断

在python中有一个函数 ​​isinstance(data，type)​​，可以用来判断某个数据是什么数据类型。

函数：isinstance( data，type ) 详解：

功能：用来判断某个数据是不是type类型的。

参数 data：是一个数据 / 变量名。

参数 type：是数据类型（int，float，str，bool，list，tuple，dict等等python数据类型中的一种）。

结果：如果 data 与 type数据类型相同，就会得到 True，否则False。

# a 整数，
a = 23
print( isinstance(a,int) )  # 输出：True


# b 小数
b = 6.399859
print( isinstance(b,float) )  # 输出：True


# c 字符串
c = "China"
print( isinstance(c,str) )  # 输出：True

解释：上述的 a，b，c 分别存放了整数，小数，字符串数据之后，发现变量名a b c 会自动根据数据 自动形成数据类型。

2.2 输入输出

输入输出是最简单的人机交互程序，在上边学过变量定义与数据类型的基础知识之后，我们在这里来完成一个简单的案例。

案例1：用户从键盘中输入名字，然后输出 对这个名字的问好。

案例2：用户从键盘输入两个数字，然后输出两个数字求和的结果。

语法介绍：

输出语法：这个前边介绍过了，就是 print( ) ，然后这里会告诉你一些 怎么在输出数据中加入一些提示性文字。

输入语法：使用的是 input( )，也是非常简答的一个语法。

• 案例1

用户从键盘中输入名字，然后输出 对这个名字的问好。

print("欢迎来到 案例1 。")


name = input("请输入名字：")


print("你好啊 ",name)

运行结果

解释：

1、首先使用 ​​print("欢迎来到 案例1 。")​​ 输出一行提示。

2，​​name = input("请输入名字：")​​  input( ) 括号中的数据就是提示数据，用户输入的内容会存放在 name 变量中。

3 ，​​print("你好啊 ",name)​​ 的作用是输出两个字符串，一个是 "你好啊 "，另一个是 name变量中的内容。

• 案例2

用户从键盘输入两个数字，然后输出两个数字求和的结果。

# 1,
print("欢迎来到 案例2 。")


# 2,
a = input("请输入 a：")  # 输入 12
# 3,
b = input("请输入 b：")  # 输入 23


sum1 = a + b
# 4,
print("字符串相加：", sum1 ) #  输出 ：1223
print( isinstance(sum1,str) )


sum2 = int(a) + int(b)
# 5，
print("数字相加：", sum2 )  # 输出 ：35
print( isinstance(sum2,int) )

运行结果

解释：

1、首先使用 ​​print("欢迎来到 案例2 。")​​ 输出一行提示。

2，​​a = input("请输入 a：")​​  用户输入的内容会存放在 a 变量中。

3,   ​​b = input("请输入 b：")​​  用户输入的内容会存放在 b 变量中。

4 ，​​print("字符串相加：", sum1 )​​ 这里输出的内容为什么会是 “1223”  ？？？

因为python接收到数据之后是默认将数据转化为字符串 ”12“  和 ”23“，然后两个 字符串 数据相加的时候相当于是字符串的拼接。所以就形成了 "1223"，而且我还输出了一下 sum1的数据类型，发现sum1就是字符串类型。

5，​​print("数字相加：", sum2 )​​ 这里输出就是 数字12 +数字23 = 35。

在 sum2 中相加的两个字符串  ”12“  和 ”23“ 中使用强制转换的方式，将这两个数字字符串转化为 int 类型的数据了。于是便可以得到正确的数据相加的结果了。

2.3 选择结构

选择结构就是告诉电脑，接下来有很多块代码，你要按照我指定的方式来选择其中一份代码执行。

案例1：根据小明本次考试的成绩是否及格来选择要不要打小明一顿。

当成绩小于60的时候为不及格。

案例2：根据小明的成绩所处的成绩区间，给予相应的奖励。

当成绩大于 90 的时候，奖励三朵小红花。

当成绩处于 80~90 的时候，奖励二朵小红花。

当成绩处于 70~80 的时候，奖励一朵小红花。

当成绩处于 60~70 的时候，奖励零朵小红花。

当成绩小于 60 的时候，奖励一个大嘴巴子。

• 案例1

根据小明本次考试的成绩是否及格来选择要不要打小明一顿。当成绩小于60的时候为不及格。

# 1，
score = input("小明本次的考试成绩是：")
# 2，
score = int(score)
# 3，
if (score < 60):
    print("请收拾小明！！！")
else:
    print("及格了，别打了。")

运行结果：

解释：

1，首先使用输入语法 input 得到小明的考试成绩，并且用变量 score 保存。

2，因为输入语法 input 输入的数据是字符串，因此需要将数字强制转换为 int 类型的。

3，这里的就是 简单选择结构 的语法了，具体结构如下所示：

if (判断条件):
    判断条件 成立之后 执行的语句。
else:
    判断条件 不成立 之后执行的语句。

4，需要注意的是：python中没有大括号了，全部使用 冒号 以及 缩进 来 表示某一段代码所属的层级关系。

• 案例2：

根据小明的成绩所处的成绩区间，给予相应的奖励。

# 1,
score = input("小明本次的考试成绩是：")
score = int(score)


# 2，
if (score > 90):
    print("奖励 3 朵 小红花。")
elif (score > 80):
    print("奖励 2 朵 小红花。")
elif (score > 70):
    print("奖励 1 朵 小红花。")
elif (score > 60):
    print("奖励 0 朵 小红花。")
else:
    print("奖励 大嘴巴子 一个。")

运行结果：

解释：

1，输入成绩，并且将成绩转化为整数。

2，这里就是 复杂选择结构 语法，具体结构如下所示：

if ( 判断条件 1 ):
    判断条件1 成立 之后应该执行的代码。
elif ( 判断条件 2 ):
    判断条件2 成立 之后应该执行的代码。
elif ( 判断条件 3 ):
    判断条件3 成立 之后应该执行的代码。
elif ( 判断条件 4 ):
    判断条件4 成立 之后应该执行的代码。
else:
    以上判断条件都 不成立 之后应该执行的代码。

3，注意：python中将 ​​else if​​​ 合并为 ​​elif​​ 。

2.4 循环结构

循环结构就是让程序重复的执行某一部分代码，类似于人重复的做一件事情。

案例：老师让小明罚抄作业50遍，于是小明就开始循环50抄写作业了。

• 案例 — for循环版本：

案例：老师让小明罚抄作业50遍，于是小明就开始循环50次抄写作业了。

# 1,
num = input("请输入小明罚抄作业的次数：")
num = int(num)


# 2,
for i in range( 1,num+1 ):
    print("小明抄写了：",i," 次作业了")

运行结果：

解释：

1，首先输入罚抄的次数，并且将其转换为整数类型。

2，然后就是 for循环语法 ， 具体语法如下：

for 循环次数的变量 in 控制循环次数:
    循环体

3，range( a , b ) ：是一个函数，它的功能是产生 从 a 到 b-1 的数字。比如：range(1,5) 将会产生 1,2,3,4 四个数字。

4，所以，range(1 , num+1) 就会产生的数字是：1 , 2 , 3 ,... , num。当我们输入 num=4 的时候，就会产生 1，2，3，4。四个数字了。

5，​​for i in range(1,num+1)​​：i 是循环变量，i 可以取的值是range产生的数据的个数。就是说：range产生几个数，i 就会被赋值几次，于是就会循环几次。

注意：python的for循环与其他编程语言的循环结构不太一样，python的for循环主要要搞明白循环次数怎么产生。

• 案例 — while循环版本：

案例：老师让小明罚抄作业50遍，于是小明就开始循环50抄写作业了。

# 1,
num = input("请输入小明罚抄作业的次数：")
num = int(num)


# 2,
j=1
while j < num+1:
    print("小明抄写了：",j," 次作业了")
    j=j+1

运行结果：

解释：

1，首先输入罚抄的次数，并且将其转换为整数类型。

2，然后就是 while循环语法 ， 具体语法如下：

while 循环控制变量 < 循环控制条件:
    循环体

3，这个语法比较简单，跟其他编程语言类似，主要在于，不使用大括号，改用冒号，并且使用缩进控制代码层级关系。

2.5 函数

函数的作用是将一部分具有某个功能的代码段抽取出来，并且给他起一个名字，以供用户重复使用。

2.5.1 基础语法：

案例1：无参无返回值 类型的函数：打印一个心心。

案例2：有参无返回值 类型的函数：给每一个用户打招呼。

案例3：有参有返回值 类型的函数：计算出三个数中的最大数，并且告诉用户那个最大。

• 案例1：无参无返回值

案例1：打印一个五角星。

# 1,定义出一个 无参无返回值 的打印心心的函数。
def printStar():
    print("      OOOO     OOOO      ")
    print("    OOOOOOO   OOOOOOO    ")
    print("   OOOOOOOOO OOOOOOOOO   ")
    print("    OOOOOOOOOOOOOOOOO    ")
    print("     OOOOOOOOOOOOOOO     ")
    print("      OOOOOOOOOOOO       ")
    print("         OOOOOOO         ")
    print("            O            ")




print("第一次调用函数：")
# 2，调用一次函数。
printStar()


print("第二次调用函数：")
# 3，在调用一次函数。
printStar()

结果：

解释：

1，定义出来的函数名字为 ​​printStar​​​，并且 ​​printStar()​​​的括号内没有参数（无参），然后最后没有返回的 ​​return​​语句（无返回值）。

2，python用换行控制层级关系。

3，调用直接写出函数名字就行了。

• 案例2：有参无返回值

案例2：给每一个用户打招呼。

# 1,定义出函数
def sayHello(name):
    print("你好吖，",name)


# 2，传入数据，调用函数。
sayHello("小明")
# 3，传入数据，调用函数。
sayHello("小花妹妹")

结果

分析

1，定义出函数​​sayHello​​​，并且​​sayHello(name)​​​中的 name 是参数（有参），最后并没有使用​​return​​返回数据（无返回值）。

2，因为​​sayHello​​​函数需要传入数据，所以调用的时候，括号内需要传入数据​​sayHello("小明")​​。

• 案例3：有参有返回值

案例3：计算出三个数中的最大数，并且告诉用户那个最大。

def compare(a,b,c):
    if a >= b :
        if a >= c :
            return a
        else:
            return c
    else:
        if b >= c:
            return b
        else:
            return c




max = compare(3,6,7)


print(max)

结果

解释

2.5.2 特殊之处

经过上边3个案例你就基本知道了函数怎么使用，这里将介绍一下python函数中的特别之处。

• 参数的位置关系

python定义的函数使用的时候可以按照参数名传递参数。

def testPara(theFirst,theSecond):
        print("theFirst: ",theFirst)
        print("theSecond: ", theSecond)




print("第一次调用：")
testPara("111","222")


print("第二次调用：")
testPara(theSecond="222",theFirst="111")

结果：

解释：

1，第一次调用传递参数并没有指定参数名，所以他会按照从左到右的匹配，所以 ​​theFirst="111"​​​，​​theSecond="222"​​。

2，第二次调用传递参数指定了参数名字以及赋值，因此会按照指定的方式赋值，而不是从左到右的匹配了。

• 默认值

python函数定义的时候可以写入默认值，然后有默认值的参数传递的时候可以不传参。

def testPara(theFirst,theSecond="我是默认数据"):
        print("theFirst: ",theFirst)
        print("theSecond: ", theSecond)




print("第一次调用：")
testPara("111")


print("第二次调用：")
testPara(theSecond="222",theFirst="111")

结果：

解释：

1，定义的函数 ​​testPara​​ 第二个参数给了默认值。

2，第一次调用只传入一个参数，然后从左到右的匹配，所以第一个参数赋值​​111​​，由于并没有传递第二个参数，所以第二个参数使用默认的数据。

3，第二次调用指定了两个参数的数据，于是第二个参数的默认数据被覆盖掉。

指定默认数据参数必须放在没指定默认数据的参数后边，不然会报错。

• 函数传递list、dict、tuple

其实python中 list、dict、tuple 函数传递非常简单，该怎么用就怎么用，没啥特别的。

def testPara(list,dict,tuple):
    print("传入的数据：")
    print(list)
    print(dict)
    print(tuple)


    list[0] = 999
    tuple["age"] = 99


    return list,tuple




list = ["111",222,True]
dict = ("333",444,False)
tuple = {"name":"小明","age":23}


print("第一次调用：")
newList,newTuple = testPara(list,dict,tuple)


print("返回的数据：")
print(newList)
print(newTuple)

结果：

解释：

1，定义的函数接受三个参数，这三个参数的数据类型未知，你给他传递什么类型他就是什么类型。

2，自定义函数的功能是将传递的参数打印一下，然后修改list与tuple中的数据，然后再将list、tuple返回。（dict不允许修改哦。）

3，用户 ​​newList,newTuple = testPara(list,dict,tuple)​​传递三个参数之后，接收两个参数，因为自定义函数返回两个参数。

4，最后输出一下返回的修改之后的数据。

• 可变参数

python中某个自定义函数不确定自己需要多少个参数，用户传递几个就是几个，这就是可变参数。

def testPara1(para1,*para2):
    print(para1)
    print(para2)


def testPara2(para1,**para2):
    print(para1)
    print(para2)


print("任意个数的参数形成 元组 ：")
testPara1( "111","222","333")


print("任意个数的参数形成 字典 ：")
testPara2( "111",name="小明",age=25 )

结果

解释

1，定义出了函数​​testPara1​​，他接受一个参数para1，还有另一个参数para2，其中para2前边加一个星号的意思是，这个参数是一个可变的参数，它会将para1匹配完之后的所有数据都看作一个整体，形成一个元组。

2，​​testPara1( "111","222","333")​​传入了三个数据，其中第一个数据会被para1匹配到，于是后边的两个数据会被看作一个整体形成元组。

3，定义出了函数​​testPara2​​，他接受一个参数para1，还有另一个参数para2，其中para2前边加两个星号的意思是，这个参数是一个可变的参数，它会将para1匹配完之后的所有数据都看作一个整体，形成一个字典。

4，​​testPara2( "111",name="小明",age=25 )​​传入了三个数据，其中第一个数据会被para1匹配到，于是后边的两个数据会被看作一个整体形成字典。

此处需要注意，因为​​**para2​​  匹配的是字典，所以传递的时候也要写成字典形式哦。（比如：​​name="小明",age=25​​就是字典形式）

• 从不同文件导入函数

python将每一个函数称为模块，所以可以说为从不同文件导入模块（函数）使用。

step1：新建另一个python文件，命名为 ​​testMoudle​​

step2：在 testMoudle.py 文件中写入以下代码。

def myMoudle():
    print("这个函数是 testMoudle.py文件中的 myMoudle方法。")

于是就在 ​​testMoudle.py​​​文件中写入了一个函数 ​​myMoudle​​，这个函数的功能就是打印一句话而已。

step3：调用 ​​testMoudle.py​​​文件中 的  ​​myMoudle​​函数。

1，首先要把 ​​testMoudle.py​​文件引入到 我们要使用这个函数的文件中。

我们准备在 ​​001-demo01-基础语法.py​​​ 文件中使用​​testMoudle.py​​​文件中 的  ​​myMoudle​​​函数。于是使用 ​​import​​​ 关键字引入​​testMoudle.py​​​文件，并且使用 ​​as​​​关键字给这个文件起一个别名 ​​myFunc​​。

2，调用函数的时候使用 ​​别名.函数名​​ 既可调用了。

3，还有其他的引入方式先不讲，先记住这个就够用了。