非常传统的题目，计算机语言的三大核心语法要素的一部分：
1. 运算符；
2. 流程控制；
同时建立程序的概念。

主题二：数据运算与流程控制

目标

应用目标
- 阶段实战：利用各种计算、条件控制、循环控制等知识，实现各种图形绘制应用程序；
- 综合实战：
  - 完成股票信息的完整数据查询。
  - 完成完整的信息输入模块。
资费管理系统

字符界面的系统

股票信息查询系统

字符界面的查询系统

技能目标
- 1. 能实现流程复杂的应用模块
- 2. 基本技术应用能力。
  - 能使用运算符；
  - 能根据条件控制流程；
  - 能在开发中使用循环控制程序流程；
  - 能在循环中停止程序的循环流程；
知识点目标
- 1. 掌握运算符语法、功能与应用；
  - 掌握算术运算符号；
  - 掌握条件运算符号；
  - 掌握逻辑运算符号；
  - 掌握位运算符号；
  - 掌握复合运算符号；
  - 掌握其他运算符号；
  - 掌握表达式与运算符号的优先级；
  - 掌握常见数据的运算；
    - 数值运算；
    - 逻辑值运算；
    - 序列值运算；
    - 字符串值运算；
    - 字典值运算；
    - 集合值运算；
  - 掌握调用符号；
  - 掌握函数调用符号；
- 2. 掌握程序流程控制的语法与流程控制过程
  - 掌握条件控制的语法-if；
  - 掌握条件控制的应用-if；
  - 掌握循环控制的语法-while；
  - 掌握循环控制的应用-while；
  - 掌握循环控制的语法-for；
  - 掌握循环控制的应用-for；
  - 掌握循环中断控制语法-continue与break；
  - 了解其他流程控制语法；

运算符语法、功能与应用

掌握好运算符号，从四个方面掌握：

运算符号的使用语法
运算符号的功能（作用）
运算符号参与运算的数据要求（数据类型，数据个数）
运算符号的返回数据类型

特别需要注意的是，在某些运算中，还存在数据类型转换。

算术运算符号

语法
- 算术运算都是二目运算（需要两个数据值参与运算）
- 数据1 运算符数据2
- 说明：运算符在中间，数据在运算符两边（前面的数据成为：被运算数【比如：被加数】，后面成为运算数【比如：加数】），这种运算的表达方式，也称表达式，俗称中继表达式。
算术运算的运算符
- + ：加运算
- - ：减运算
- *：乘运算
- / ：除运算
- //：整除运算
- %：求余运算
- **：幂运算（指数运算，乘方运算）

# 熟悉运算符的功能与使用语法
print(20 + 30)
print(40 - 30)
print(10 * 5)
print(17 / 5)
print(18 // 7)
print(25 % 6)
print(8 ** 2)

运算数的数据类型

加减法
- 对整数，小数，逻辑值，复数都可以运算。
- 逻辑值True=1，False=0
- 所有运算的结果与数学知识一致。

# + - 
print(30 + 30)
print(30 + 88.88)
print(30 + True)
print(30 + (30 + 45.8J) )
print(False + True )

60
118.88
31
(60+45.8j)
1

乘除法
- 对整数，小数，逻辑值，复数都可以运算。
- 逻辑值True=1，False=0
- 所有运算的结果与数学知识一致。
- 注意：除法中除数不能为0。

# 乘除
print(30 * 30)
print(30 * 88.88)
print(30 * True)
print(30 * (30 + 45.88888J) )
print(False * True )
print("---------------")
print(30 / 30)
print(30 / 88.88)
print(30 / True)
print(30 / (30 + 45.8J) )
print(False / True )

900
2666.3999999999996
30
(900+1376.6664j)
0
---------------
1.0
0.33753375337533753
30.0
(0.3002361857994957-0.45836057698723004j)
0.0

整除
- 对整数，小数，逻辑值都可以运算，对复数不能运算，因为复数不能取整（floor运算）
- 逻辑值True=1，False=0
- 所有运算的结果与数学知识一致。
- 注意：整除中除数不能为0。

# 整除
print(30 // 30)
print(30 // 88.88)
print(30 // True)
# print((30 + 45J) // 5 )    # TypeError: can't take floor of complex number.
print(False // True )

print(86.8 // 67.8)

乘方
- 对整数，小数，逻辑值，复数都可以运算
- 逻辑值True=1，False=0
- 所有运算的结果与数学知识一致。

# 整除
print(30 ** 2)
print(30 ** 2.5)
print(30 ** True)
print((30 + 45J) ** 3 )    # TypeError: can't take floor of complex number.
print(False ** True )

print(86.8 ** 67.8)
print(2 ** (4.3 + 3J))

900
4929.503017546495
30
(-155250+30375j)
0
2.7017015190288315e+131
(-9.592967312139688+17.20460459222708j)

返回类型
逻辑值作为整数在处理；返回类型的规则

整数 op 整数 -> 整数（op：+ - * // % **）
整数 / 整数 -> 小数 (就算能整除，也是小数)

print(type(16/3))

整数 op 小数 -> 小数
小数 op 小数 -> 小数

print(type(4.5//3.5))
print(type(4//3.0))
print(type(4//3))

整数 op 复数 -> 复数
小数 op 复数 -> 复数

提示：复数有可能虚部为 0

print(23 * (4 + 5J))
print( (4 + 5J) / (4 + 5J))

print( (4 + 5J) * (4 - 5J) )

(92+115j)
(1+0j)
(41+0j)

对序列的运算
- 列表包含三类：元组，列表，字符串
- 有列表支持的算术运算
  - 复制：整数 * 列表： 整数 * 列表 或者 列表 * 整数
  - 连接：列表 + 列表： 列表 + 列表
- 其他的运算符都不支持
- 注意：只有同类型才能连接

print( (1, 2, 3) * 3 )
print( 3 * (1, 2, 3))
print( [1, 2, 3] * 3 )
print( 3 * [1, 2, 3])
print('hello'* 3 )
print( 3 * 'world')

print( [1, 2, 3] + [4, 5, 6])
# print( (1, 2, 3) + [4, 5, 6])    # 不同类型：TypeError: can only concatenate tuple (not "list") to tuple
print( (1, 2, 3) + (1, 2, 3))
print( 'hello' + 'world')
# print( 3 * {1, 2, 3})     # unsupported operand type(s) for *: 'int' and 'set'

(1, 2, 3, 1, 2, 3, 1, 2, 3)
(1, 2, 3, 1, 2, 3, 1, 2, 3)
[1, 2, 3, 1, 2, 3, 1, 2, 3]
[1, 2, 3, 1, 2, 3, 1, 2, 3]
hellohellohello
worldworldworld
[1, 2, 3, 4, 5, 6]
(1, 2, 3, 1, 2, 3)
helloworld

对字典/集合的运算
- 算术运算中的任何运算符，都不支持对字典/集合的运算；

dt = {'name': 'Louis', 'age': 20}
print(dt + dt)   # TypeError: unsupported operand type(s) for +: 'dict' and 'dict'

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

 in ()
      1 dt = {'name': 'Louis', 'age': 20}
----> 2 print(dt + dt)   # TypeError: unsupported operand type(s) for +: 'dict' and 'dict'


TypeError: unsupported operand type(s) for +: 'dict' and 'dict'

关于@运算
- 在Python中提供了一个 @ 运算，我们总是把他归为算术运算，实际这个运算对内置类型都没有实现，但这个运算符提供了Python的发展方向与期望的强项：数值计算。因为这个运算是面向大学线性代数中的运算：内积运算。
- 该运算方式在NumPy提供了实现。

import numpy as np
a = np.array([1,2,3])
b = np.array([4,5,6])
a @ b

关系运算符号；

语法
- 关系运算是二目运算
- 运算数关系运算符运算数
条件运算的运算符
- < ：小于比较运算
- <= ：小于等于比较运算
- > ：大于比较运算
- >= ：大于等于比较运算
- == ：相等比较运算
- != ：不等比较运算
返回的类型
- 返回类型都是逻辑型。

print(45 < 50)
print(45 <= 50)
print(45 > 50)
print(45 >= 50)
print(45 == 50)
print(45 != 50)

True
True
False
False
False
True

运算数的数据类型

整数，小数，逻辑类型
- 数值类型的比较容易理解
- 数值类型包含True。
- 注意：不支持复数的比较（这个符合我们高中的数学知识）

print(True > False)

True

所以类型
- 所有类型都支持： == 与 !=
- 这两个关系运算符，在不同数据类型的实现的含义不同。
  - 对大部分对象而言，指的是两个变量是否是同一个内存空间。
  - 对数值类型而言，指的是内容值是否相等。
  - 对数值类型而言，首先判断类型是否相同，然后再判定值是否相同。（默认实现：地址相等判定）

print((4 + 5J)==complex(4 , 5))
print((4 + 5J)!=(4 + 5J))

True
False

print([1,2,3] == [1, 2, 3])
print([1,2,3] == (1, 2, 3))

True
False

# 类型同，值同，但变量的内存空间不同（地址不同）
a = {1, 2, 3}
b = set([1, 2, 3])
print('0X%X'%id(a), '0X%X'%id(b) )
print(a == b)

0X111655748 0X111E85AC8
True

# 另外一种对象相同，返回的不是逻辑类型，而是逻辑数组。
import numpy as np
a = np.array([1,2,3])
b = np.array([1,2,3])
print(a==b)

[ True  True  True]

# 地址相等
class A:
    pass

oa = A()
ob = A()
print(oa == ob)   # 判定的是地址相等

False

序列类型
- 按照字典排序比较，返回除相等外的第一个元素的比较结果。
- 这种比较基本上没有意义，如果想实现比较，需要自己实现。

print( [6,3,5] <= [6, 2, 5] )
print( [6,2,5] <= [6, 2, 5] )
print( [6,3,5] <= [6, 2, 5,] )
print( [6,2,5] <= [6, 2, 5, 0] )
print('hello' <= 'hEllo')    # 每个字符作为ASCII码比较

False
True
False
True
False

逻辑运算符号；

语法
- 逻辑运算有二目运算，也有一目运算
- 二目运算：运算数 逻辑运算符 运算数
- 一目运算：逻辑运算符 运算数
逻辑运算的运算符
- 二目运算：and or
- 一目运算：not
逻辑运算返回值
- 返回：逻辑类型

print(True and False)
print(True or False)
print(not False)

False
True
True

逻辑运算的数据类型
- 实际上逻辑值是0与1两个整数表示，在Python的逻辑运算中，其他类型会自动转换为逻辑类型后，进行逻辑运算。

整数的逻辑运算
- 所有整数当成逻辑值处理（0：False，非0：True）

print(not -2)
print(not -0)
print(2 and -2)
print(2 or -2)
print(2 and False )
print(2 or False )

False
True
-2
2
False
2

小数的逻辑运算
- 小数与整数一样，也直接作为逻辑值使用（0：False，非0：True）

print(not 2.0 )
print(not 0.0 )
print(2.5 and -0.0)
print(1.8 or -2.3)
print(2.8 and False )
print(2.8 or False )

False
True
-0.0
1.8
False
2.8

字符串的逻辑运算
- 字符串也当成逻辑值处理：（''：False，非''：True）

print(not 'hello')
print(not '')
print('' and 'world')         #第一个为False，返回第一个
print('Hello' and 'world')         #第一个为True，返回第二个
print('hello' or 'world')     
# 为什么不直接返回True或者False。

False
True

world
hello

列表的逻辑运算
- 列表也当成逻辑值处理：（[]，()：False，非[]：True）
- 元组(0)也是当作False处理。这个与元组的语法有关。

print(not [] )
print(not [0] )
print([1, 2, 3] and -0.0)
print(1.8 or [1,2,3])
print(2.8 and [1,2,3] )
print('--------------')
print(not () )
print(not (0) )
print(not (0,2,3))
print((1, 2, 3) and -0.0)
print(1.8 or (1,2,3))
print(2.8 and (1,2,3) )

True
False
-0.0
1.8
[1, 2, 3]
--------------
True
True
False
-0.0
1.8
(1, 2, 3)

字典与集合的逻辑运算
- 字典也当成逻辑值处理：（{}：False，非{}：True）

print(not {})
print(not {0})
print({1, 2, 3} and -0.0)
print(1.8 or {1,2,3})
print(2.8 and {1,2,3} )

True
False
-0.0
1.8
{1, 2, 3}

对象的逻辑运算
对象作为逻辑值使用：对象不存在None表示False，对象存在表示True

class  A:
    pass

a = A()
print(not a)
# 对象默认为True

False

无穷大与非数值，None的逻辑运算
- 无穷大与非数值默认是True（因为非0）
- None当作False使用。

nan = float('NaN')
inf = float('Inf')
n = None
print(not n)
print(not nan)   
print(not inf)

True
False
False

在其他的一些实现中，也可能实现逻辑运算发，其运算规则需要看实现文档。

import numpy as np
na = np.array([1,2,3])
print(na)
print(not na.all())   # 多值，产生歧义：ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()

# ndarray数组对象，不能直接做逻辑值使用，需要做处理。

[1 2 3]
False

位运算符号

位运算符分成两类：
- 位移运算符：对数据的位进行移动，从而改变数据的值。
- 位算术运算符：对数据的位进行且，或，异或，否运算。

位移运算符号

语法：
- 位移运算符是二目运算符
- 语法： 被位移数 位移运算符 位移的位数
位移运算的运算符
- << ：左移
- >> ：右移

print(10<<2)
print(10>>2)
print(10<<1000)

40
2
107150860718626732094842504906000181056140481170553360744375038837035105112493612249319837881569585812759467291755314682518714528569231404359845775746985748039345677748242309854210746050623711418779541821530464749835819412673987675591655439460770629145711964776865421676604298316526243868372056680693760

运算类型
- 位移的位数必须是整数，不支持小数
- 逻辑值可以当成整数处理True当成1，False当成0
- 被位移数也必须是整数
- 因为其他数据位移会破坏数据类型与数据结构。

print(10<

 
 20
4
 
  
  返回类型 
    
    位移返回类型与被位移的整数一样的类型。 
   
  
  
 位算术运算符号 
  
   语法 
    
    位算术运算符，也分成单目运算与二目运算： 
    二目位算术运算：整数 位运算符 整数  
    单目位算术运算：整数 位运算符 
   
  
   位算术运算的运算符 
    
    单目运算： 
      
      ~：每个位取反 
     
  
    二目运算： 
      
      &：每个位做且运算（都是1，为1，否则为0） 
      | ：每个位做或运算（一个为1，为1，否则为0） 
      ^：每个位做异或运算（同为0，不同为1） 
     
  
   
  
  
  
  返回类型： 
    
    返回的也是整数（可以当逻辑值使用） 
   
  
  
 print(10 & 5)
print(10 | 5)
print(10 ^ 5)
print(~ 5)
 
 0
15
15
-6
 
  
  位运算的经典应用 
    
    IP计算：IP地址是4字节整数，一般表示成数点格式：192.168.1.128 
    颜色计算：颜色就是一个像素，在计算机种使用4字节整数表示（这是模拟全真色，还有其他格式），可以通过位运算取出R，G，B，Alpha四个颜色分量。 
   
  
  
 r = 200
g = 100
b = 20
a = 255
print("把三原色+透明度合成一个像素：", r<< 24 | g << 16 | b << 8 | a)
 
 把三原色+透明度合成一个像素： 3362002175
 
 color = 3362002175
print('红色：', color >> 24)
print('绿色：', color >> 16 & 255)
print('蓝色：', color >> 8 & 255)
print('透明：', color & 255)
 
 红色： 200
绿色： 100
蓝色： 20
透明： 255
 
 field1 = 192
field2 = 168
field3 = 1
field4 = 128
print("表示IP地址的整数", field1<< 24 | field2 << 16 | field3 << 8 | field4)
 
 表示IP地址的整数 3232235904
 
 ip = 3232235904
field1 = ip >> 24 & 255
field2 = ip >> 16 & 255
field3 = ip >> 8 & 255
field4 = ip >> 0 & 255
print(F'IP地址数点格式：{field1}.{field2}.{field3}.{field4}')

 
 IP地址数点格式：192.168.1.128
 
 复合运算符号； 
  
  符合运算指的是：=与前面某些运算符号结合的运算符号。有点人成为增值运算； 
  
  
   语法： 
    
     被运算变量 符合运算符 运算数  
   
  
   复合运算的运算符号 
    
    += ：递加 
    -= ：递减 
    *= ：递乘 
    /= ：递除 
    //= ：递整除 
    %= ：递求余 
    **= ：递幂 
    @= ：递内积（Python对内置类型没有实现） 
    &= ：递位且 
    |= ：递位或 
    ^= ：递位异或 
    >>= ：递右移 
    <<= ：递左移 
   
  
  
 - **注意：** 符合运算符号有一个显著的特征：
    - 被运算数必须是变量（因为=有赋值的含义，这个只对变量有效）。对数值无效。
 
  
  复合运算符的运算说明： 
    
    a +=2 效果上等价于 a = a + 2，其他依次类推。 
    性能上复合运算比对等的单一运算要好（运算量要少）。 
   
  
  
 i = 20
i += 20
# 3 += 20    # 错误
 
 其他运算符号； 
 - ()：优先级运算，参数传递等。
- []：下标运算
- .：成员调用运算
- in：列表元素判定运算（使用与序列：tuple，list，string, set）
- is：判定两个变量是否同一个内存
- 值1  if   条件  else   值2：条件表达式运算
- + -除了在二目运算作为加减运算，如果作为一目运算表示取正与负
 
 print(8 * (2 + 3 ))  # 改变优先级
print((1,2,3,4)[1])    # 取列表中的第二个元素
import math
print(math.pi)     # 调用math模块的成员：圆周率
print( 20 in [1 ,2, 3, 20, 4])
print( 20 in {1 ,2, 3, 20, 4})
print( 'name' in {'name':'Louis', 'age':20 })   # 对key判定
print( 20 in {'name':'Louis', 'age':20 })      # 不对value判定
print( 20 is '20')
print( 'ok' if 20>30 else 'not ok' )

a = 20
print(+a)
print(-a)
 
 40
2
3.141592653589793
True
True
True
False
False
not ok
20
-20
 
 表达式与运算符号的优先级； 
  
  运算符可以多个连续使用，形成表达式。 
  
 1 + 3 * 2 / 5**2-10 % 3 == 1 +3 
 
 False
 
  
  表达式因为使用多个运算符，每个运算符存在运算的优先级情况。 
    
    下面是运算优先级 
   
  
  
  
   
    
    运算符说明 
    Python运算符 
    优先级 
    
   
   
    
    'expression,...' 
    字符串转换 
    24 
    
    
    {key:datum,...} 
    字典显示 
    23 
    
    
    [expression,...] 
    列表显示 
    22 
    
    
    (experession,...) 
    绑定或元组显示 
    21 
    
    
    f(arguments...) 
    函数调用 
    20 
    
    
    索引运算符 
    x[index]或x[index:index2[:index3]] 
    18、19 
    
    
    属性访问 
    x.attrbute 
    17 
    
    
    乘方 
    ** 
    16 
    
    
    按位取反 
    ~ 
    15 
    
    
    符号运算符 
    +或- 
    14 
    
    
    乘、除 
    *、/、//、% 
    13 
    
    
    加、减 
    +、- 
    12 
    
    
    位移 
    >>、<< 
    11 
    
    
    按位与 
    & 
    10 
    
    
    按位异或 
    ^ 
    9 
    
    
    按位或 
    | 8 
    
    
    比较运算符 
    ==、!=、>、>=、<、<= 
    7 
    
    
    is运算符 
    is、is not 
    6 
    
    
    in运算符 
    in、not in 
    5 
    
    
    逻辑非 
    not 
    4 
    
    
    逻辑与 
    and 
    3 
    
    
    逻辑或 
    or 
    2 
    
   
  
  
  定制运算优先级 
    
    上面的优先级是Python解释器默认优先级。 
    可以使用（）优先级运算符，改变上述运算的优先级。 
   
  
  
 (1 + 3) * 2 / (5**(2-10 % 3) ) == (1 + 3) 
 
 False
 
 下标运算 
  
  下标运算主要在序列数据类型的运算中使用，用来定位序列中的元素。 
   语法： 
    
    序列数据值[开始位置：结束位置：步长]； 
    其中的位置从0开始。 
    下面是具体的使用方式。 
   
  
  按照位置取列表中的值 
  
 v1 = (1,2,3,4,5,6,7,8)
v2 = [1,2,3,4,5,6,7,8]
v3 = 'abcdefgh'
# 取值
print (v1[1])
print (v2[2])
print (v3[1])
# 修改值
# v1[1]=88   # 元组只取值，不赋值
v2[1]=88
# v3[1]='X'  # 字符串只取值，不赋值
print(v1)
print(v2)
print(v3)
# 释放值
# del v1[1]    # 元组值不能修改
del v2[1]
# del v3[1]     # 字符串值不能修改
print(v2)
 
 2
3
b
(1, 2, 3, 4, 5, 6, 7, 8)
[1, 88, 3, 4, 5, 6, 7, 8]
abcdefgh
[1, 3, 4, 5, 6, 7, 8]
 
  
  取区间的值 
    
    区间使用的是[ ... ) 
   
  
  
 v1 = (1,2,3,4,5,6,7,8)
v2 = [1,2,3,4,5,6,7,8]
v3 = 'abcdefgh'
# 取值
print (v1[1:4])    # 不包含位置4
print (v2[1:4])
print (v3[1:4])
 
 (2, 3, 4)
[2, 3, 4]
bcd
 
  
  指定步长 
  
 v1 = (1,2,3,4,5,6,7,8)
v2 = [1,2,3,4,5,6,7,8]
v3 = 'abcdefgh'
# 取值
print (v1[1:6:2])    # 不包含位置4
print (v2[1:6:2])
print (v3[1:6:2])
v2[1:6:2]= [77,88,99]   #长度要匹配
print(v2)
 
 (2, 4, 6)
[2, 4, 6]
bdf
[1, 77, 3, 88, 5, 99, 7, 8]
 
  
  负值的使用 
    
    其中的开始位置，结束位置，步长都可以取负值，负值表示位置计算从结束位置开始 
   
  
  
 v1 = (1,2,3,4,5,6,7,8)
v2 = [1,2,3,4,5,6,7,8]
v3 = 'abcdefgh'
# 取值
print(v1[-1])

print(v1[-5:-1])    # 从倒数第5个，到倒数第1个
print(v1[-1:-5:-1])   # 从倒数第1个，到倒数第5个。反序。
 
 8
(4, 5, 6, 7)
(8, 7, 6, 5)
 
  
  下标中的默认值 
    
    下标中每一个值可以使用默认值 
   
  
  
 v1 = (1,2,3,4,5,6,7,8)
v2 = [1,2,3,4,5,6,7,8]
v3 = 'abcdefgh'
# 取值
#print(v1[])   # 必须要一个值

print(v1[:])    # 开始位置，默认是0，结束位置默认是-1的下一个。
print(v1[::])   # 步长默认是1。

print(v1[2:])    # 开始位置，默认是0，结束位置默认是-1的下一个。
print(v1[:3:])   # 步长默认是1。


print(v1[::2])   # 步长默认是1。
print(v1[::-1])   # 步长默认是1。
 
 (1, 2, 3, 4, 5, 6, 7, 8)
(1, 2, 3, 4, 5, 6, 7, 8)
(3, 4, 5, 6, 7, 8)
(1, 2, 3)
(1, 3, 5, 7)
(8, 7, 6, 5, 4, 3, 2, 1)
 
 成员调用符号 
  
   运算符. 有两个使用场景 
    
     . 用于包与模块的路径。 
     .用于对象的成员调用。 
   
  
   语法： 
    
    包.包 
    包.模块 
     模块.类或者模块.函数或者模块.变量  
    对象 .成员 
   
  
  
 import math
print(math.pi)
print(math.sin(math.pi/60))
 
 3.141592653589793
0.05233595624294383
 
 from datetime import  *
dt = date.today()
print(dt.year)
print(dt.month)
print(dt.day)
 
 2019
3
6
 
 函数调用符号； 
 - 语法
    返回值变量 =  函数名(参数，参数，参数 ，......)
 
 from math import *
print(sin(3.14159262/6))
 
 0.49999999515173094
 
 程序流程控制的语法与流程控制过程 
  
  程序的执行是按照代码的先后执行的（线性性），需要的时候，可以改变程序执行的流程，我们称为流程控制。 
  常规来说，在语言层面可以控制程序的流程提供两种改变方式： 
    
    执行还是不执行：根据条件选在是否执行，我们称为条件控制 
    反复执行：根据条件反复执行指定的代码。我们称为循环控制 
      
      循环的结束，我们称为中断控制。 
     
  
   
  
  条件控制与循环控制的语法： 
    
    使用是块的方式控制,语法：-块头 + 块体 
    块头：每种类型的块头都不一样。 
    块体：由代码构成，所有代码缩行数相同的代码都是同一个块体。直到缩行数不同，表示当前块结束，另外一个块开始。 
    注意：默认Python程序有一个顶层块，顶层块是不用缩行的。 
   
  
  
 掌握条件控制的语法-if； 
  
  语法一：一个块构成 
    
    条件控制头 ：if 逻辑值 ：  
    说明：条件为真，块得到执行。条件为假，块不会执行。 
   
  
  
 if  True :
    print('被执行---1')
    print('被执行---2')
 
 被执行---1
被执行---2
 
 if False : # 不会被执行
 print('被执行---1')
 print('被执行---2') 
  
  语法二：两个块构成 
  
     if 逻辑值 :
        语句
         ...
    else:
        语句
        ....
 
  
   说明： 
    
    else块不能单独使用，必须与if块一起使用。if块可以不使用else块。 
    当if为假执行else的块，真就执行if的块。 
   
  
  
 if  True :
    print('被执行---1')
    print('被执行---2')
else:
    print('被执行---其他1')
    print('被执行---其他2')
 
 被执行---1
被执行---2
 
 if  False:
    print('被执行---1')
    print('被执行---2')
else:
    print('被执行---其他1')
    print('被执行---其他2')
 
 被执行---其他1
被执行---其他2
 
  
  语法三： 
  
 if 逻辑值:
    语句
     ...
elif 逻辑值:
    语句
    ...
elif 逻辑值:
    语句
    ...
...

 
 a = 80
if a==100:
    print('满分')
elif a >=90:
    print('优秀')
elif a >=80:
    print('良')    
elif a >=70:
    print('中')
elif a >=60:
    print('及格')
elif a<60:
    print('不及格')
 
 良
 
  
  语法四： 
  
 if 逻辑值:
    语句
     ...
elif 逻辑值:
    语句
    ...
elif 逻辑值:
    语句
    ...
else:
    ...

 
 a = 40
if a==100:
    print('满分')
elif a >=90:
    print('优秀')
elif a >=80:
    print('良')    
elif a >=70:
    print('中')
elif a >=60:
    print('及格')
else:
    print('不及格')
 
 不及格
 
 掌握条件控制的应用-if； 
   除了直接使用逻辑值，还可以使用如下形式的逻辑值，会自动转换。 
  
  使用关系运算 
    
    因为关系运算直接返回逻辑值 
   
  
  
 a = input('输入选择 (ok： 接受，其他：不接受) ')
if a == 'ok':
    print('你选择了接受！')
else:
    print('你选择了拒绝！')
 
 输入选择 (ok： 接受，其他：不接受) ok
你选择了接受！
 
  
  直接使用数值，对象作为条件 
    
    这些数值对象可以直接转换为逻辑条件 
   
  
  
 a = input('输入选择 (任何输入： 接受，不输入：不接受) ')
if a :
    print('你选择了接受！')
else:
    print('你选择了拒绝！')
 
 输入选择 (任何输入： 接受，不输入：不接受) 
你选择了拒绝！
 
 a =(1,2,3,4)
if a :
    print('你选择了接受！')
else:
    print('你选择了拒绝！')
 
 你选择了接受！
 
 a = 20
if a :
    print('你选择了接受！')
else:
    print('你选择了拒绝！')
 
 你选择了接受！
 
  
  使用in，is等运算符 
  
 a = input('输入选择 (只能选择1，2，3，4) ')
if type(a) is str:
    print('输入的是str')
else:
    print('输入的是非str')
 
 输入选择 (只能选择1，2，3，4) 1
输入的是str
 
 a = input('输入选择 (只能选择1，2，3，4) ')
if a in ('1' , '2', '3', '4'):
    print('选择正确')
else:
    print('选择不对')
 
 输入选择 (只能选择1，2，3，4) 1
选择正确
 
  
  使用not改变条件 
  
 a = input('输入选择 (只能选择1，2，3，4) ')
print(a)
if a not in ('1' , '2', '3', '4'):
    print('选择不对')
else:
    print('选择正确')
 
 输入选择 (只能选择1，2，3，4) 1
1
选择正确
 
 a = input('输入选择 (只能选择1，2，3，4) ')
print(a)
if not a in ('1' , '2', '3', '4'):
    print('选择不对')
else:
    print('选择正确')
 
 输入选择 (只能选择1，2，3，4) 4
4
选择正确
 
 掌握循环控制的语法-while； 
   while用来对块中代码循环执行。 
  
  语法一： 
  
     while  逻辑值:
        语句
        ...
 
  
   注意： 
    
    逻辑值为True，就执行块，块执行完毕，再重新回到while，继续判定逻辑值是否为True。 
    逻辑值为False，块就不执行。 
     与if的差别在于： 
      
      if执行完块，就继续执行。 
      while执行完块，会回到while处继续判定。 
     
  
   
  
  
 i = 10 
while I:
    print(i)
    
    i -= 1
 
 10
9
8
7
6
5
4
3
2
1
 
  
  语法二： 
  
 
while 逻辑值:
    语句
    ....
else:
    语句
    ....
    
 
  
  当while的条件为False，else会得到执行。 
   说明： 
    
    while支持else，但不支持与elif块配合。 
   
  
  
 i = 10 
while i != 0:
    print(i)
    
    i -= 1
else:
    print('循环没有执行了')
 
 10
9
8
7
6
5
4
3
2
1
循环没有执行了
 
 掌握循环控制的应用-while； 
  
  while中的条件使用其他非逻辑值 
  
 i = 10 
while I:
    print(i)
    
    i -= 1
else:
    print('循环没有执行了')
 
 10
9
8
7
6
5
4
3
2
1
循环没有执行了
 
  
  while中只有一个语句行 
    
    如果一行，可以在while于else后面直接写语句 
    为了在一行上，编写多个语句，可以使用；分隔。 
   
  
  
 i = 10 
while i:print(i);i -= 1
else:print('循环没有执行了')
 
 10
9
8
7
6
5
4
3
2
1
循环没有执行了
 
 # 只有一行才能在while后面直接写，多行不行。
i = 10 
while i:print(i)
    i -= 1
else:print('循环没有执行了')
 
   File "", line 4
    i -= 1
    ^
IndentationError: unexpected indent
 
  
  避免陷入死循环 
    
    需要使用变量来控制while后的条件改变，并有机会得到True的值。 
    一般为了避免while死循环，有如下编程套路 
      
      在while外面定义一个变量，并设置一个初始值 
      在while的逻辑值处，就是用该变量产生。 
      在while内部，根据情况，改变变量，需要退出，就让变量的值改变，以至于使得while逻辑值处的条件得到False的结果。 
     
  
   
  
  
 i = 0
while i <=10 :
    print(i)
    i += 1
 
 0
1
2
3
4
5
6
7
8
9
10
 
 掌握循环控制的语法-for； 
  
  for是专门对列表与字段等可以迭代的数据设计的专用循环语句。 
  
  
  语法一： 
  
 for  标识字  in  序列数据:
    语句
    ......
 
  
   for执行流程说明： 
    
    for语句每次会从序列数据开始位置取一个值，并使用标识字定义各一个标量，把取出的值存入变量，然后执行块中语句。 
    当块语句执行完毕，会回到for位置，并取第二个值放入定义的变量，然后重复执行块中语句； 
    .... 
    直到序列数据中数据都取玩位置，直接跳出块执行。 
   
  
  
 # 循环list
for  d in [1,2,3,4]:
    print(d)
 
 1
2
3
4
 
 # 循环字符串
for  d in 'abcdefg':
    print(d)
 
 a
b
c
d
e
f
g
 
 # 循环元组
for  d in (1,2,3,4):
    print(d)

# 元组的另外表示
for  d in 1,2,3,4:
    print(d)
 
 1
2
3
4
1
2
3
4
 
 # 循环集合
for  d in {1,2,3,4}:
    print(d)
 
 1
2
3
4
 
 # 循环字典
for  d in {'name': 'louis','age':18}:
    print(d)
 
 name
age
 
 # 循环呢字典的值
v = {'name': 'louis','age':18}
for  d in v:
    print(d, v[d], sep=':')
 
 name:louis
age:18
 
  
  for语法二： 
  
 
for 变量 in 序列:
    语句
    ......
else:
    语句
    ......
 
  
   说明： 
    
    当列表循环完毕后，else得到执行。 
   
  
  
 # 循环list
for  d in [1,2,3,4]:
    print(d)
else:
    print('循环结束。')
 
 1
2
3
4
循环结束。
 
 掌握循环控制的应用-for； 
  
  使用range创建序列 
    
    Python提供了一个函数，用来创建序列。 
   
  
  
  | -  range(stop) -> range object
 | -  range(start, stop[, step]) -> range object
 
 # 创建序列范围： [ 0 - 4 )
for v in range(4):
    print(v)
 
 0
1
2
3
 
 # 创建序列范围： [ start - end )
for v in range(1, 5):
    print(v)
 
 1
2
3
4
 
 # 创建序列范围： [ start - end ), step = 2
for v in range(1, 5, 2):
    print(v)
 
 1
3
 
 掌握循环中断控制语法-continue与break； 
   为了结束循环，目前只有等到每次循环结束，重新判定循环条件。Python语言提供了在循环中，可以直接结束循环的语法，使用特殊的语句完成。 
 break与continue的理解与使用 
  
   中断循环的两种方式： 
    
    直接结束循环 
    结束当前次循环后面代码的执行，重新开始循环的条件判别。 
   
  
   循环的中断的语法： 
    
    break ：直接结束循环； 
    continue ：结束当前循环； 
   
  
  注意：中断语句只能用于循环：for与while，不能用于其他块中。 
  
 # break的使用
for  v in range(5):
    print(v)
    break
    print('break后')
 
 0
 
 # continue的使用
for  v in range(5):
    print(v)
    continue
    print('break后')
 
 0
1
2
3
4
 
 在多重循环中使用break与continue 
   Python的中断语句与其他语言有些差异，不提供标签，用来中断到指定位置。
   对于多重循环来说，中断只影响到最近的循环，对外层循环没有影响，需要单独写代码使用中断继续中断。 
 # continue的在多层循环中使用
for y in range(3):
    print('外层:', y)
    for x in range(3):
        print('\t内层:', x)
        continue
        print('\t内层后')
    print('外层后')
        
 
 外层: 0
    内层: 0
    内层: 1
    内层: 2
外层后
外层: 1
    内层: 0
    内层: 1
    内层: 2
外层后
外层: 2
    内层: 0
    内层: 1
    内层: 2
外层后
 
 for y in range(3):
    print('外层:', y)
    for x in range(3):
        print('\t内层:', x)
        break
        print('\t内层后')
    print('外层后')
 
 外层: 0
    内层: 0
外层后
外层: 1
    内层: 0
外层后
外层: 2
    内层: 0
外层后
 
 了解其他流程控制语法； 
  
  其他影响流程执行的方式还有： 
    
     
      
      结束程序： 
      
   
 sys.exit(状态码)
 
    
     
      
      结束函数模块 
      
   
 return 值
 
    
     
      
      对象自动释放 
      
   
 with   ...  :
    语句
    ...
 
    
     
      
      异常发生 
      
   
 try:
    语句
    ......
catch ...: :
    语句
    ....
finally:
    语句
    ......
  
  
 阶段应用实战 
  
  任务描述 
    
    使用循环与条件实现集合图形的输出 
    使用循环与条件实现反复输入，直到满足条件才结束输入。 
    显示系统某个目录下的文件列表 
   
  
  关联知识点： 
    
    变量定义 
    输入语句 
    输出语句 
    类型转换 
    数据运算（算术、比较、逻辑计算等） 
    循环控制 
    条件控制 
    循环中断控制 
    数学思维方式 
   
  
  
 综合应用实战 
  
  实现一个录入模块，提示是否继续录入，根据选择，来决定继续录入，还是退出录入。 
   实现股票历史数据反复查询，并显示多条历史数据。
 
 
    
     
      
       
      
     
    
      查询系统的界面要求 
     
   
  
  
 思考题目 
  
  判定下面语法是否正确 
  
 a = 1
b = 2
a++b
a++++++++b
 
 3

PY01-02:Python数据运算与流程控制

主题二：数据运算与流程控制

目标

运算符语法、功能与应用

算术运算符号

关系运算符号；

逻辑运算符号；

位运算符号

位移运算符号

位算术运算符号

复合运算符号；

其他运算符号；

表达式与运算符号的优先级；

下标运算

成员调用符号

函数调用符号；

程序流程控制的语法与流程控制过程

掌握条件控制的语法-if；

掌握条件控制的应用-if；

掌握循环控制的语法-while；

掌握循环控制的应用-while；

掌握循环控制的语法-for；

掌握循环控制的应用-for；

掌握循环中断控制语法-continue与break；

break与continue的理解与使用

在多重循环中使用break与continue

了解其他流程控制语法；

阶段应用实战

综合应用实战

思考题目

你可能感兴趣的:(PY01-02:Python数据运算与流程控制)

运算符说明	Python运算符	优先级
'expression,...'	字符串转换	24
{key:datum,...}	字典显示	23
[expression,...]	列表显示	22
(experession,...)	绑定或元组显示	21
f(arguments...)	函数调用	20
索引运算符	x[index]或x[index:index2[:index3]]	18、19
属性访问	x.attrbute	17
乘方	**	16
按位取反	~	15
符号运算符	+或-	14
乘、除	*、/、//、%	13
加、减	+、-	12
位移	>>、<<	11
按位与	&	10
按位异或	^	9
按位或	\| 8
比较运算符	==、!=、>、>=、<、<=	7
is运算符	is、is not	6
in运算符	in、not in	5
逻辑非	not	4
逻辑与	and	3
逻辑或	or	2