Python基本语法

 

目录

一、变量

二、运算符

三、分支与循环

四、模块与包

---

一、变量

1. 变量定义

• 在 Python 中，每个变量 在使用前都必须赋值，变量 赋值以后 该变量 才会被创建
• 等号（=）用来给变量赋值
• = 左边是一个变量名
• = 右边是存储在变量中的值

 

变量名 = 值

• 案例1 学生注册

 

# 定义变量---学生学号
studentNo = "9527"

# 定义变量---学生密码
stuentPassword = "123"

# 在程序中，如果要输出变量的内容，需要使用 print 函数
print(studentNo)
print(stuentPassword)

说明#是代码注释，快捷键是Ctrl+/

• 案例2 超市买菜
  需求
  1)柿子的价格是 8.5 元/斤
  2)买了 7.5 斤 柿子
  3)计算付款金额

 

# 定义柿子价格变量
price = 8.5

# 定义购买重量
weight = 7.5

# 计算金额
money = price * weight

print(money)

1. 变量类型
   变量的四要素：

• 变量的名称
• 变量保存的数据
• 变量存储数据的类型
• 变量的内存地址（标识）

2.1. 变量类型的演练

• 需求
  定义变量保存小强的个人信息
  姓名：小强
  年龄：22 岁
  性别：是男生
  身高：1.80 米
  体重：77.0 公斤
• 提问
  在演练中，一共有几种数据类型？
  在 Python 中定义变量时需要指定类型吗？

2.2 变量的类型

• 在 Python 中定义变量是 不需要指定类型（在其他很多高级语言中都需要）
• 数据类型可以分为 数字型 和 非数字型
  数字型
  整型 (int)
  浮点型（float）
  布尔型（bool）
  真 True 非 0 数 —— 非零即真
  假 False 0
  非数字型
  字符串
  列表
  元组
  字典
• 使用 type 函数可以查看一个变量的类型

 

type(name)

2.3 不同类型变量之间的计算

• 数字型变量 之间可以直接计算
  在 Python 中，两个数字型变量是可以直接进行 算数运算的
  如果变量是 bool 型，在计算时
  True 对应的数字是 1
  False 对应的数字是 0
  演练步骤
  1)定义整数 i = 10
  2)定义浮点数 f = 10.5
  3)定义布尔型 b = True

 

i = 10
f = 10.5
b = True

print(i+f+b)
21.5

发生了自动类型转换，全部转换成了浮点数。

• 字符串变量 之间使用 + 拼接字符串
  在 Python 中，字符串之间可以使用 + 拼接生成新的字符串

 

first_name = "三"
last_name = "张"
print(first_name + last_name)

• 字符串变量 可以和 整数 使用 * 重复拼接相同的字符串

 

print("-" * 50)

输出

 

'--------------------------------------------------'

• 数字型变量 和 字符串 之间 不能进行其他计算

 

first_name = "zhang"
x = 10

print( x + first_name)
---------------------------------------------------------------------------
TypeError: unsupported operand type(s) for +: 'int' and 'str'
类型错误：`+` 不支持的操作类型：`int` 和 `str`

解决办法：使用str(x)将x的类型强制转换成字符串类型

 

first_name = "zhang"
x = 10
print(str(x)+first_name)

2.4 变量的输入
所谓 输入，就是 用代码 获取 用户通过 键盘 输入的信息
例如：去银行取钱，在 ATM 上输入密码在 Python 中，如果要获取用户在 键盘 上的输入信息，需要使用到 input 函数

• 在 Python 中可以使用 input 函数从键盘等待用户的输入
• 用户输入的 任何内容 Python 都认为是一个 字符串
• 语法如下

 

字符串变量 = input("提示信息：")

2.5 变量输入演练 —— 超市买苹果
需求

• 收银员输入 苹果的价格，单位：元／斤
  收银员输入 用户购买苹果的重量，单位：斤
  计算并且 输出 付款金额
• 代码

 

# 1. 输入苹果单价
price_str = input("请输入苹果价格：")

# 2. 要求苹果重量
weight_str = input("请输入苹果重量：")

# 3. 计算金额
# 1> 将苹果单价转换成小数
price = float(price_str)

# 2> 将苹果重量转换成小数
weight = float(weight_str)

# 3> 计算付款金额
money = price * weight

print(money)

2.6 变量的格式化输出
使用%

苹果单价 9.00 元／斤，购买了 5.00 斤，需要支付 45.00 元

• 在 Python 中可以使用 print 函数将信息输出到控制台
• 如果希望输出文字信息的同时，一起输出 数据，就需要使用到 格式化操作符
  % 被称为 格式化操作符，专门用于处理字符串中的格式
  包含 % 的字符串，被称为 格式化字符串
• % 和不同的 字符 连用，不同类型的数据 需要使用 不同的格式化字符

1. %s 字符串
2. %d 有符号十进制整数，%06d 表示输出的整数显示位数，不足的地方使用 0 补全
3. %f 浮点数，%.2f 表示小数点后只显示两位
4. %% 输出 %

• 语法格式如下：

 

print("格式化字符串" % 变量1)

print("格式化字符串" % (变量1, 变量2...))

举个栗子
需求

• 定义字符串变量 name，输出 我的名字叫 小明，请多多关照！
• 定义整数变量 student_no，输出 我的学号是 000001
• 定义小数 price、weight、money，输出 苹果单价 9.00 元／斤，购买了 5.00 斤，需要支付 45.00 元
• 定义一个小数 scale，输出 数据比例是 10.00%

 

print("我的名字叫 %s，请多多关照！" % name)
print("我的学号是 %06d" % student_no)
print("苹果单价 %.02f 元／斤，购买 %.02f 斤，需要支付 %.02f 元" % (price, weight, money))
print("数据比例是 %.02f%%" % (scale * 100))

1. 变量命名
   标识符

标识符就是程序员自己命名的 变量名。 名字 需要有 见名知义 的效果，不要随意起名。

• 标示符可以由 字母、下划线 和 数字 组成
• 不能以数字开头
• 不能与关键字重名
  关键字
  关键字 就是在 Python 内部已经使用的标识符
  关键字 具有特殊的功能和含义
  开发者 不允许定义和关键字相同的名字的标示符

 

['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue',
 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 
'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise',
 'return', 'try', 'while', 'with', 'yield']

二、运算符

1)算数运算符

• 是完成基本的算术运算使用的符号，用来处理四则运算

运算符	描述	实例
+	加	10 + 20 = 30
-	减	10 - 20 = -10
*	乘	10 * 20 = 200
/	除	10 / 20 = 0.5
//	取整除	返回除法的整数部分（商） 9 // 2 输出结果 4
%	取余数	返回除法的余数 9 % 2 = 1
**	幂	又称次方、乘方，2 ** 3 = 8

 

>>> a=10
>>> b=5
>>> print(a+b)
15
>>> print(a-b)
5
>>> print(a*b)
50
>>> print(a/b)
2.0
>>> print(a**b)
100000
>>> print(a//b)
2
>>> print(a%b)
0

2)比较（关系）运算符

运算符	描述
==	检查两个操作数的值是否 相等，如果是，则条件成立，返回 True
!=	检查两个操作数的值是否 不相等，如果是，则条件成立，返回 True
>	检查左操作数的值是否 大于 右操作数的值，如果是，则条件成立，返回 True
<	检查左操作数的值是否 小于 右操作数的值，如果是，则条件成立，返回 True
>=	检查左操作数的值是否 大于或等于 右操作数的值，如果是，则条件成立，返回 True
<=	检查左操作数的值是否 小于或等于 右操作数的值，如果是，则条件成立，返回 True

 

>>> a=10
>>> b=20
>>> a==b
False
>>> a!=b
True
>>> a>b
False
>>> a<b
True
>>> a>=b
False
>>> a<=b
True

3)逻辑运算符

运算符	逻辑表达式	描述
and	x and y	只有 x 和 y 的值都为 True，才会返回 True否则只要 x 或者 y 有一个值为 False，就返回 False
or	x or y	只要 x 或者 y 有一个值为 True，就返回 True；只有 x 和 y 的值都为 False，才会返回 False
not	not x	如果 x 为 True，返回 False；如果 x 为 False，返回 True

 

>>> a=True
>>> b=False
>>> a and b
False
>>> a or b
True
>>> not a
False
>>> not -1
False
>>> not 0
True

4)赋值运算符

• 在 Python 中，使用 = 可以给变量赋值
• 在算术运算时，为了简化代码的编写，Python 还提供了一系列的 与 算术运算符 对应的 赋值运算符
• 注意：赋值运算符中间不能使用空格

运算符	描述	实例
=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	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=10
>>> b=20
>>> c=0
>>> c=a+b
>>> print(c)
30
>>> c+=10
>>> print(c)
40
>>> c-=a
>>> print(c)
30
>>> c*=a
>>> print(c)
300
>>> c/=a
>>> print(c)
30.0
>>> c%=a
>>> print(c)
0.0
>>> c=a**5
>>> print(c)
100000
>>> c//=b
>>> print(c)
5000
>>> print(b)
20

5)运算符的优先级

• 以下表格的算数优先级由高到最低顺序排列

运算符	描述
**	幂 (最高优先级)
* / % //	乘、除、取余数、取整除
+ -	加法、减法
<= < > >=	比较运算符
== !=	等于运算符
= %= /= //= -= += = *=	赋值运算符
not or and	逻辑运算符

三、分支与循环

条件语句

Python 条件语句跟其他语言基本一致的，都是通过一条或多条语句的执行结果（ True 或者 False ）来决定执行的代码块。
Python 程序语言指定任何非 0 和非空（None）值为 True，0 或者 None为 False。

• if-语句的基本形式
  Python 中，if 语句的基本形式如下：

 

if 判断条件：
    执行语句……
else：
    执行语句……

Python 语言有着严格的缩进要求，因此这里也需要注意缩进，也不要少写了冒号 : 。

if 语句的判断条件可以用>（大于）、<(小于)、==（等于）、>=（大于等于）、<=（小于等于）来表示其关系。

例如：

 

results=59

if results>=60:
    print ('及格')
else :
    print ('不及格')

输出结果:

 

不及格

上面也说道，非零数值、非空字符串、非空 list 等，判断为True，否则为False。因此也可以这样写：

 

num = 6
if num :
    print('Hello Python')

• if-语句多个判断条件的形式
  有些时候，我们的判断语句不可能只有两个，有些时候需要多个，比如上面的例子中大于 60 的为及格，那我们还要判断大于 90 的为优秀，在 80 到 90 之间的良好呢？

这时候需要用到 if 语句多个判断条件，

用伪代码来表示：

 

if 判断条件1:
    执行语句1……
elif 判断条件2:
    执行语句2……
elif 判断条件3:
    执行语句3……
else:
    执行语句4……

实例:

 

results = 89

if results > 90:
    print('优秀')
elif results > 80:
    print('良好')
elif results > 60:
    print ('及格')
else :
    print ('不及格')

输出结果:

 

良好

• if-语句多个条件同时判断
  Python 不像 Java 有 switch 语句，所以多个条件判断，只能用 elif 来实现，但是有时候需要多个条件需同时判断时，可以使用 or （或），表示两个条件有一个成立时判断条件成功；使用 and （与）时，表示只有两个条件同时成立的情况下，判断条件才成功。

 

java = 86
python = 68

if java > 80 and  python > 80:
    print('优秀')
else :
    print('不优秀')

输出结果：

 

不优秀

注意：if 有多个条件时可使用括号来区分判断的先后顺序，括号中的判断优先执行，此外 and 和 or 的优先级低于 >（大于）、<（小于）等判断符号，即大于和小于在没有括号的情况下会比与或要优先判断。

 

java = 86
python = 68

if (80 <= java < 90) or (80 <= python < 90):
    print('良好')

输出结果：

 

良好

 

循环语句

一般编程语言都有循环语句，循环语句允许我们执行一个语句或语句组多次。
循环语句的一般形式如下：

 

 

Python 提供了 for 循环和 while 循环，当然还有一些控制循环的语句：

循环控制语句	描述
break	在语句块执行过程中终止循环，并且跳出整个循环
continue	在语句块执行过程中终止当前循环，跳出该次循环，执行下一次循环
pass	pass 是空语句，是为了保持程序结构的完整性

• while-循环语句

 

count = 1
sum = 0
while count <= 100:
    sum = sum + count
    count = count + 1
print(sum)

输出结果

 

5050

当然 while 语句时还有另外两个重要的命令 continue，break 来跳过循环，continue 用于跳过该次循环，break 则是用于跳出本层循环
比如，上面的例子是计算 1 到 100 所有整数的和，当我们需要判断 sum 大于 1000 的时候，不在相加时，可以用到 break ，退出整个循环

 

count = 1
sum = 0
while  count <= 100:
    sum = sum + count
    if  sum > 1000:  #当 sum 大于 1000 的时候退出循环
        break
    count = count + 1
print(sum)

输出的结果：

 

1035

有时候，我们只想统计 1 到 100 之间的奇数和，那么也就是说当 count 是偶数，也就是双数的时候，我们需要跳出当次的循环，不想加，这时候可以用到 continue

 

count = 1
sum = 0
while  count <= 100:
    if count % 2 == 0:  # 双数时跳过输出
        count = count + 1
        continue
    sum = sum + count
    count = count + 1
print(sum)

输出的语句：

 

2500

在 Python 的 while 循环中，还可以使用 else 语句，while … else 在循环条件为 false 时执行 else 语句块

比如：

 

count = 0
while count < 5:
   print (count)
   count = count + 1
else:
   print (count)

输出的结果：

 

0
1
2
3
4
5

• for-循环语句
  for循环可以遍历任何序列的项目，如一个字符串
  它的流程图基本如下：

   

  

基本的语法格式：

 

for iterating_var in sequence:
   statements(s)

实例：

 

for letter in 'www.neuedu.com':
    print(letter)

输出的结果如下：

 

w
w
w
.
n
e
u
e
d
u
.
c
o
m

range()函数

Python函数range()让你能够轻松地生成一系列的数字。例如，可以像下面这样使用函数range()来打印一系列的数字：

 

    for value in range(1,5):
        print(value)

上述代码好像应该打印数字1~5，但实际上它不会打印数字5：

 

    1
    2
    3
    4

在这个示例中，range()只是打印数字1~4，这是你在编程语言中经常看到的差一行为的结果。函数range()让Python从你指定的第一个值开始数，并在到达你指定的第二个值后停止，因此输出不包含第二个值（这里为5）。

要打印数字1~5，需要使用range(1,6)：

 

    for value in range(1,6):
        print(value)

这样，输出将从1开始，到5结束：

 

    1
    2
    3
    4
    5

• 嵌套循环
  Python 语言允许在一个循环体里面嵌入另一个循环。上面的实例也是使用了嵌套循环的。

具体的语法如下：

for 循环嵌套语法

 

for iterating_var in sequence:
   for iterating_var in sequence:
      statements(s)
   statements(s)

while 循环嵌套语法

 

while expression:
   while expression:
      statement(s)
   statement(s)

除此之外，你也可以在循环体内嵌入其他的循环体，如在 while 循环中可以嵌入 for 循环， 反之，你可以在 for 循环中嵌入 while 循环

有 while … else 语句，当然也有 for … else 语句啦，for 中的语句和普通的没有区别，else 中的语句会在循环正常执行完（即 for 不是通过 break 跳出而中断的）的情况下执行，while … else 也是一样。

 

for num in range(10,20):  # 迭代 10 到 20 之间的数字
   for i in range(2,num): # 根据因子迭代
      if num%i == 0:      # 确定第一个因子
         j=num/i          # 计算第二个因子
         print ('%d 是一个合数' % num)
         break            # 跳出当前循环
   else:                  # 循环的 else 部分
      print ('%d 是一个质数' % num)

输出的结果：

 

10 是一个合数
11 是一个质数
12 是一个合数
13 是一个质数
14 是一个合数
15 是一个合数
16 是一个合数
17 是一个质数
18 是一个合数
19 是一个质数

课上案例

• 打印九九乘法表

 

for i in range(1, 10):
        for j in range(1, i+1):
            print('{}x{}={}\t'.format(i, j, i*j), end='')
        print()

 

1x1=1   
2x1=2   2x2=4   
3x1=3   3x2=6   3x3=9   
4x1=4   4x2=8   4x3=12  4x4=16  
5x1=5   5x2=10  5x3=15  5x4=20  5x5=25  
6x1=6   6x2=12  6x3=18  6x4=24  6x5=30  6x6=36  
7x1=7   7x2=14  7x3=21  7x4=28  7x5=35  7x6=42  7x7=49  
8x1=8   8x2=16  8x3=24  8x4=32  8x5=40  8x6=48  8x7=56  8x8=64  
9x1=9   9x2=18  9x3=27  9x4=36  9x5=45  9x6=54  9x7=63  9x8=72  9x9=81

• 遍历list、set、dict等集合
• l=[1,2,3,4,5,6,7]打印前五个元素

当我们同时需要索引和元素时，还有一种更简洁的方式，那就是通过 Python 内置的函数 enumerate()。用它来遍历集合，不仅返回每个元素，并且还返回其对应的索引，这样一来，上面的例子就可以写成:

 

l = [1, 2, 3, 4, 5, 6, 7]
for index, item in enumerate(l):
    if index < 5:
        print(item)  
              
1
2
3
4
5

条件与循环的复用
前面讲了条件与循环的一些基本操作，接下来，我们重点来看它们的进阶操作，让程序变得更简洁高效。
在阅读代码的时候，你应该常常会发现，有很多将条件与循环并做一行的操作，例如：

 

expression1 if condition else expression2 for item in iterable

将这个表达式分解开来，其实就等同于下面这样的嵌套结构：

 

for item in iterable:
    if condition:
        expression1
    else:
        expression2

而如果没有 else 语句，则需要写成：

 

expression for item in iterable if condition

举个例子，比如我们要绘制 y = 2*|x| + 5 的函数图像，给定集合 x 的数据点，需要计算出 y 的数据集合，那么只用一行代码，就可以很轻松地解决问题了：

 

y = [value * 2 + 5 if value > 0 else -value * 2 + 5 for value in x]

当然，这样的复用并不仅仅局限于一个循环。比如，给定两个列表 x、y，要求返回 x、y 中所有元素对组成的元祖，相等情况除外。那么，你也可以很容易表示出来：

 

[(xx, yy) for xx in x for yy in y if xx != yy]

这样的写法等价于:

 

l = []
for xx in x:
    for yy in y:
        if xx != yy:
            l.append((xx, yy))

随机数的处理

在 Python 中，要使用随机数，首先需要导入 随机数 的 模块 —— “工具包”

 

import random

导入模块后，可以直接在 模块名称 后面敲一个 . ，会提示该模块中包含的所有函数

random.randint(a, b) ，返回 [a, b] 之间的整数，包含 a 和 b

例如：

 

random.randint(12, 20)  # 生成的随机数n: 12 <= n <= 20   
random.randint(20, 20)  # 结果永远是 20   
random.randint(20, 10)  # 该语句是错误的，下限必须小于上限

综合练习---猜数字

计算机要求用户输入数值范围的最小值和最大值。计算机随后“思考”出在这个范围之内的一个随机数，并且重复地要求用户猜测这个数，直到用户猜对了。在用户每次进行猜测之后，计算机都会给出一个提示，并且会在这个过程的最后显示出总的猜测次数。这个程序包含了几种类型的我们学过的 Python 语句，例如，输入语句、输出语句、赋值语句、循环和条件语句。

一个可能的游戏过程如下：

 

Enter the smaller number: 1
Enter the larger number: 20
Enter your guess: 5
Too small
Enter your guess: 9
Too small
Enter your guess: 15
Too small
Enter your guess: 17
Too large
Enter your guess: 16
You've got it in 5 tries!

 

import random

smaller = int(input("Enter the smaller number: "))
larger = int(input("Enter the larger number: "))
myNumber = random.randint(smaller, larger)
count = 0
while True:
    count += 1
    userNumber = int(input("Enter your guess: "))
    if userNumber < myNumber:
        print("Too small")
    elif userNumber > myNumber:
        print("Too large")
    else:
        print("You've got it in", count, "tries!")
        break

四、模块与包

模块的概念

一个.py文件就称为一个模块

导入模块中类或函数的方式：

方式一：import 模块名
使用时：模块名.函数名()

 

import module1
module1.output()

方式二:from 模块名 import 函数名
使用时：函数名()

 

from module1 import output
output()

方式三:from 模块名-import *
使用时：函数名()

 

from module1 import *
output()

方式四:from 模块名 import 函数名 as tt(自定义)
注意原来的函数名将失效
使用时：tt()

 

from module1 import output as tt
tt()

可以在模块当中定义一个变量all，指定导出的函数子集：

使用all的影响: 后面的[]里面写什么函数名，使用from 模块名 import 方式导入时导入什么 all如果没有这个变量将全部导入(all仅限 于from 模块名 import 这种导入方式)

加all示例：

 

__all__=['output']
def output():
    print('hello neuedu')

def output2():
        print('hello output2')

以下代码报错

 

from module1 import *
output2()

包的概念

概念：包就是一个文件夹，里面包含了若干py文件以及一个_init_.py文件。

导入包中函数，以及模块的方式：

方式一：from 包名 import 模块名
使用时：模块名.函数名()

 

from neuedu import module3
module3.output()

方式二：from 包名模块名 import 函数名
使用时：函数名()

 

from neuedu.module3 import output
output()

方式三：import 包名模块名
使用的时候 包名.模块名.函数名()

 

import neuedu.module3
neuedu.module3.output()

方式四：from 包名 import *
前提是：将 init.py 文件中写入all变量(写入方式同模块导入的写入方式) 。 变量当中写入哪个模块则导入哪个模块，不写则什么都不导入 使用时：模块名.函数名() _init_.py

 

__all__ = ['module3']

 

from neuedu import *
module3.output()

方式五：import 包名

前提是：在包里面的init.py 文件里写入 from . import 模块名 init.py里面导入哪个模块 通过本方式就能使用哪个模块

使用时：包名.模块名.函数名() _init_.py

 

from . import module3

 

import neuedu
neuedu.module3.output()