python入门

python入门(一)

编程语言的分类

机器语言

#直接用计算机能理解的二进制指令编写程序，直接控制硬件
-- 0000,0000,00000000001：加载 暂存区A 存储器地址1

汇编语言

#用英文标签取代二进制指令去编写程序，本质也是在直接控制硬件
 -- MOV 移动 | CMP 比较

高级语言

#用人能理解的表达方式去编写程序，无需考虑硬件的操作细节
-- 编译型：借助编译器来转换，最终用来执行的文件不具备跨平台性
-- 解释型：借助解释器来转换，最终用来执行的文件具备跨平台性

对比

执行效率：机器语言>汇编语言>高级语言（编译型>解释型）
开发效率：机器语言<汇编语言<高级语言（编译型<解释型）
跨平台性：机器语言<汇编语言<高级语言（编译型<解释型）

平台：
应用软件的运行平台=操作系统+硬件
语言优劣：开发效率至关重要

代码执行

1. 编译型：比如说Java代码，直接通过操作系统中的编译器翻译成可执行文件运行

2: 解释型：比如说Python代码，代码肯定是要被重复执行的，如果每次运行都要进行检查语法，转换成可执行文件这一类操作会非常慢，所以python程序运行的时候首先会将代码进行预处理（比如说语法检查）转换成一个中间格式（字节码），字节码文件是一种python的特殊格式的文件，直接就可以被解释器读取执行，每次python程序执行的时候，都是读取字节码文件进行执行

环境变量

'''
1、配置环境变量不是必须的
2、配置环境变量的目的：为终端提供执行环境
'''

python代码执行

'''
1、交互式
	-- 控制台直接编写运行Python代码
	-- 1.打开终端 2.进入python解释器 3.编写代码一回车就执行
	
2、脚本式
	-- 文件编写Python代码，把文件作为脚本交给解释器执行
	-- 1.在文件中编写好代码 2.打开终端 3.用指定版本的解释器命令执行文件(文件的绝对路径)
	
总结：交互式不能永久保存代码，可以实时显示代码

python属于解释性语言，凭解释器解释运行python代码，运行方式是从上至下逐行解释执行
'''

pip

'''
pip: python的应用商城，在商城中下载工具为python拓展功能

pip3 -V：查看版本号
pip3 list: 查看当前python环境下已拓展的功能
pip3 install 功能名称：安装指定的功能
	-- eg：pip3 instal requests
pip3 uninstal 功能名称: 卸载指定的功能
'''

应用程序使用文件的三步骤

'''
1.打开应用程序：使应用程序运行在操作系统上
2.将文件内容加载到内存：应用程序往操作系统发送打开文件的指令
3.应用程序将数据从内存中显示到用户界面：操作系统从内存中取出CPU处理好的数据给道应用程序，然后应用程序将数据直接转化成人能识别的字符显示给人进行浏览
'''

# 如果应用程序是python解释器：cpython
'''
1.启动cpython解释器
2.解释器将文件内容当成文本内容通过操作系统加载到内存
3.解释器解释执行读入内存的代码（存在语法检查）=> 1.正常：执行的结果显示给用户 2.异常：错误信息显示给用户
'''

变量

1. 什么是变量：一个可以动态描述物体状态的量
-- 程序中变量的本质：在程序运行中，值可以发生改变的量
-- python中所有的量在程序运行中都可以发生改变，所有python中没有绝对的常量，因为python没有定于你常量的语法
	
2. 为什么要使用变量：让计算机有记录事务状态的功能，让计算机有记忆的能力
（程序执行的本质就是一系列状态的变化，变是程序执行的直接体现，所以我们需要有一种机制能够反映或者说是保存下来程序执行时状态以及状态的变化。）

3. 定义变量：
	-- 变量名 = 变量值
		-- 变量名：记录状态的名
		-- =：赋值符号
		-- 变量值：记录的状态
		
4. 重点：
-- 堆区开辟空间存放 变量值  
-- 将存放 变量值 空间的地址提供给栈区  
-- 栈区为变量名开辟空间存放提供来的地址

内存回收机制

变量的值是存在内存中，它在内存中有一个内存地址，而变量名则是指向这个内存地址

垃圾回收机制： 引用计数
   age=18 #18的引用计数为1
   x=age #18的引用计数为2
   
   引用计数减少
   del age #18的引用计数减为1
   x = 10 # 一个变量名只能指向一个内存地址，所以这个时候变量名x 指向了值为10的内存地址，这个时候18这个值的引用计数为0，此时python程序会对10这个值进行垃圾回收

变量的三大组成

值：通过 变量名 直接访问就是访问值
地址：通过 id(变量名) 访问的就是变量堆区的地址
类型：通过 type(变量名)  访问的就是变量的类型

比较

==: 只做值比较
is：作地址比较

pycharm

IDE集成开发环境

1. 如果要用编辑器pycharm写python
	-- 创建项目
	-- 创建py文件
	-- 解释执行py文件


2. pycharm需要执行py文件的环境、
	-- 不需要系统的环境变量，需要自己配置找到python解释器

3. pep8规范： python编写代码的格式规范
-- pycharm中可自动设置python代码规范：Code-Reformat Code

4. 快捷键
-- ctrl+D 复制光标所在的这一行的数据到下一行
-- ctrl+?/ctrl+/ 注释单行或者多行
-- ctrl+y 删除一行
-- ctrl+alt+L 格式化pep2格式代码

python入门（二）

变量的命名规范

大前提：变量名应该见名之意

语法规定：
1.只能由 字母 数字 及 _ 组成
2.不能以数字开头
3.避免与系统关键字重名：重名不会报错，但系统的功能就被自定义的功能屏蔽掉了（严重不建议这样来做）
注：以下关键字变为变量名直接回出现错误
['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']
4.以_开头的变量都有特殊含义
5.以__开头与结尾的叫魔法变量：内置变量
6.建议使用_连接语法来声明长变量名：owen_name old_boy_edu
7.支持小驼峰与大驼峰命名规范：owenName | OwenName
8.多个单词的简写建议使用全大写：URL | HTTP | HTML
9.用全大写来标识常量：PI = 3.141592653 | OWEN_SALARY = 88888
命名风格：
     纯小写加下划线(在python中，变量名的命名推荐使用该方式)
        age_of_oldboy=73
     驼峰体
        AgeOfOldboy=73

常量

python中没有严格的常量语法：
	-- 常量：在程序运行过程中，值不能被改变的量
	-- python中所有的量在运行过程中其实都能发生改变，只能自我保障不去改变全大写定义的变量值

python2 和 python 3区别

输出：自带换行
python 2
print(10)
print 10 : py3被遗弃

python 3
print(10)

输入
python 2
info = input('提示信息：')
# 细节
# 1.可以输入一个值，但一定要按照值得表示方式进行输入，10就是数字 'abc'就是字符串
# 2.如果输入的是abc，默认将abc作为变量来解读，如果变量abc未定义就报错

raw_input(): 采用所有输入都以字符串进行存储


python 3
info = input('提示信息：')
# 细节
# 1.所有信息都是直接输入，都会被转换为字符串存储 == raw_input

注释

注释：不会被python解释器解释执行，是提供给开发者阅读代码的提示
单行注释： # 开头的语句
多行注释：出现在文件最上方，用''''''包裹的语句

基本数据类型

为何数据要区分类型

数据类型指的是变量值的类型，变量值之所以区分类型，是因为变量值是用来记录事物的状态的，而事物的状态有不同的种类，对应着，也必须使用不同类型的值去记录他们

有哪些数据类型

1. 数字：包括整型（int）和 浮点型（float）
2. 字符串（str）
3. 列表
4. 字典
5. 布尔值

任何一个数据类型都考虑3个问题

//作用：记录。。。状态
//定义
//使用

整型 int

1. 作用：记录年龄，等级，数量
2. 定义：
age = 18 
3: 使用：数学运算与比较运算
  print(10/3)
  print(10>3)

# py2下：数据过长用long类型存储 | 数据量小的整型用int存储
# py3下：long被遗弃 | 所有整型都用int存储（优化：数据量过大，采用字符串存储处理，如果需要运算，可以直接拿来运算）

浮点型float

1. 作用：记录薪资，身高，体重,可以用来存放小数
2. 定义：
salary = 3.1  
3: 使用：数学运算与比较运算
  print(3.1+2)
  print(4.5>3)

# 可以通过格式化方式来绝对输出格式
# %.6f % salary
-- %f对浮点型数据进行占位
-- .后的数据数字表示小数精度
-- .前的数据是输出的长度，小于等于要输出的数据长度不起作用，超出就采用规定的最大长度
# 注：%015.6f：右对齐，左侧不足拿0填充， %-15.6f: 左对齐输出
salary = 88888.0123456789
print('%015.6f' % salary)

# 了了解
# 可以将格式化的结果进行保存，以便之后再次使用
salary = 88888.0123456789
info = '%015.6f' % salary
print(info)

字符串（str）

1. 作用：记录描述性质的状态
2. 定义：在 单引号/双引号/三引号中包含一些列字符
3: 使用：
  msg='my name is "egon"'
  print(msg)
4. +: 拼接字符串
  x='hello'
  y='world'
  print(x+y)
  print(x+10) # 字符串只能与字符串相加
5. *：复制字符串
  x='hello'
  print(x*10)

6. 案例：
name = input('name: ')
age = input('age: ')
# %s是万能占位符, %是用来连接有占位符的字符串与需要占位的变量，多个变量用()包裹
info = """信息:
name: %s
age: %s""" % (name, age)
print(info)

列表 （list）

原理：比如说命名一个列表 ls = [3, 1, 2]
堆区有四个空间，其中有一块空间其中分成3部分，分别存放元素3，1，2在内存中的地址，这3部分的指针分别指向存放数据3，1，2的三块内存空间，
在栈区也会有一个空间，存放变量名，指针指向存放元素的地址的那块内存，我们在操作列表的时候，通过索引号取元素，就是通过指针的偏移去指向存放元素数据的地址的不同部分                                                                                                                                                                                                                          ，这块空间是指向具体的数据的，我们就取到了元素

1. 作用：按照位置记录多个值(索引对应值，索引从0开始，代表的就是位置)，并且可以取出指定位置的某一个值

2. 定义：变量名 = [多个值，之间用,隔开]
ls = [3, 1, 2]

3. 列表变量名ls访问的是列表整体
print(ls)  # [3, 1, 2]

4. 通过索引(index)来访问具体的值，index从0开始编号： ls[index]
print(ls[0])  # 3

5. ls的嵌套及值的访问
ls = [[1, 2, 3], [4, 5, 6], [7, 8,] [9]]
6. 访问数字9
print(ls[2][2][0])

# 重点：list存放值的方式： eg：[3, 1, 2] => 列表的0号位存放的不是数字3，而是堆区3空间的地址

字典类型（dict）

# 列表能存放多个值，但多个值只能通过index区分，但是index没有语义
# 需找即可以存放多个值，切每个值有一个语义描述 => dict类型
# 定义：{}是用来定义字典的语法，key是用来描述最 终要访问的value值的，key对于开发者来说是已知的
# 访问：通过 dic[key]来访问key描述的值
dic = {'key': 'value'}                                                                                                                                                                                                                                                                                                                                                                

作用：记录多个不同属性的值

定义：在{}内用逗号分开个多个元素，每一个元素都由key:value组成
#{}是用来定义字典的语法，key是用来描述最终要访问的value值的，key对于开发者来说是已知的
# value就是我们存放的值，可以是任意类型，
#一个key唯一对应一个value，key应该对value有描述性的功能，所以key通常是str类型

dic={'name':'egon','age':18,'gender':'male'}
print(type(dic))

使用：
print(dic['name'])
print(dic['age'])

people = {
    'name': 'Liuxx',
    'age': 68,
    'gender': '哇塞'
}
# 整体访问
print(people)
# 访问年龄的值，[将key原样拿下来] => ['age']
print(people['age'])


# 案例
# 字典的嵌套
info = {
    'name': 'egon',
    'hobbies': ['play', 'sleep'],
    'company_info': {
        'name': 'Oldboy',
        'type': 'education',
        'emp_num': 40,
    }
}
# 拿到40 | 拿到 'sleep'
res = info['company_info']['emp_num']
print(res)
res = info['hobbies'][1]
print(res)


students=[
    {'name':'alex','age':38,'hobbies':['play','sleep']},
    {'name':'egon','age':18,'hobbies':['read','sleep']},
    {'name':'wupeiqi','age':58,'hobbies':['music','read','sleep']},
]
# 第二个学生的第一个爱好
print(students[1]['hobbies'][0])

布尔类型bool（True、False）

作用：用于判断
（在与if语句连用时，都会将数据类型转换为布尔值，其中0、None、空布尔值为False，其余都为True）
定义：
x=True
y=False
print(type(x))
print(type(y))
print(10 > 11)
print(10 == 10)

使用：
result = False
print(result)

输入输出

1. 接收用户输入
name=input('请输入你的用户名： ') # name='egon'
print(name)


2. 格式化输出
name=input('username>>> ')
age=input('age>>> ')
 
print('my name is '+name+' my age is '+age)  #字符串拼接
print('my name is %s my age is %s' %(name,age)) #格式化输出

3. %d只能接收数字
print('my age is %d' %10)
print('my age is %d' %'aaaa') #出现报错
print('my age is %d' %10.1)

4. %s既能接受字符串也能接受数字
print('my age is %s' %'aaa')
print('my age is %s' %10)
print('my age is %s' %['a',1])


4. 了解
在python3中只有一个input：input会将用户输入的任何内容都存成字符串类型
x=input('>>>>: ') # x='[1,2,3]'
print(x,type(x))

在python2中有两种接收用户输入的机制
raw_input：等同于python3的input
input：要求输入者必须输入的一个明确的数据类型，输入什么类型就存成什么类型

运算符

算数运算符

# 加法
print(10 + 20)
print('abc' + 'def')
print([1, 2, 3] + [4, 5, 6])

# 乘法
print(10 * 2)
print('abc' * 2)
print([1, 2, 3] * 2)

# 除法
print(5 / 2)

# 整除
print(5 // 2)

# 求幂
print(5 ** 2)

# 求模（取余）
# 可以对负数进行取余：符号跟着 % 后面那个数
print(5 % 2)

# 深度思考：任意正整数对数字n进行取余，结果为：[0, n-1]

比较运算符

print(10 == 10)  #等于
print(10 != 10)  #不等于
print(10 > 3) #大于
print(10 < 3) #小于
print(10 >= 10) #大于等于
print('egon' == 'egon') 

了解：
x='abcdef'
y='abcz'
print(x > y)

l1=[2,'abc',3]
l2=[2,'3']
print(l2 > l1)

赋值运算符

增量赋值

age = 18
age += 1  # age=age+1
print(age)
age-=1 # age=age-1
print(age)

交叉赋值

x=11
y=22

temp=x
x=y
y=temp
#上述三行代码可以合并为下面这一行
x,y=y,x
print(x,y)

链式赋值

x=10
y=x
z=y

#上述三行代码可以合并为下面这一行
x=y=z=10
print(id(x),id(y),id(z))

解压赋值

l=['a','b','c','d','e']
x=l[0]
y=l[1]
z=l[2]
m=l[3]
n=l[4]

#上述代码可以合并为下面这一行
等号左边的变量名必须与右面所包含的值一一对应（变量名的数量必须和泪飙中值的数量一致，不然就会报错）
x,y,z,m,n=l
print(x,y,z,m,n)

x,y,*_,z=l
print(x,y,z)

l=['a','b','c','d','e']

x,y,x,m,n=l
x='a'
y='b'
x='c'
m='d'
n='e'

print(x,y,x,m,n)

#使用通配符完成解压赋值
# _是合法的变量名，会接受值，但我们认为_代表该解压位不用接收，用_来接收表示
l=['a','b','c','d','e']
x,y,*_=l  #只取列表中前面2个值，分别赋值给x,y
x,y,*_,z=l #只取泪飙中前面2个值以及最后一个值，分别赋值给x,y,z

#字典也能进行解压赋值，但是这个值是key
dic={'k1':1,'k2':2,'k3':3,'k4':4}
a,b,c,d=dic
print(a)
print(b)
print(c)
print(d)

#练习
- 取列表中的前2个数和后面2个数分别赋值给x,y,w,u
l=['a','b','c','d','e']
x, y, *_,w,u,c=l
print(x,y,w,u,c)

- 取列表中的前2个数分别赋值给x,y,取列表中的第三个和第四个数作为列表赋值给w,取最后一个数赋值给u
l = ['a', 'b', 'c', 'd', 'e']
x,y,*w,u=l
print(x,y,z,w)

逻辑运算符

# 逻辑运算符运行结果：不一定是bool类型
# 1. and
#逻辑与，用来连接左右两个条件，在左右两个条件同时为True的情况下，最终结果才为True
# 左右都成立才成立，有不成立的就不成立
print(10 < 3 and 3 == 3)
print(10 > 3 and 3 == 3 and 1 == 1 and 1 > 0)
res = 10 > 5 and 10 > 20
print(res)

res = 0 and 20  # and前为假，整个式子就可以确定为假了，and后就不需要执行(短路)
print(res)

# 2. or
#逻辑或，用来连接左右两个条件，左右两个条件但凡有一个为True，最终结果就为True
# 左右都不成立才不成立，有成立的就成立
print(10 < 3 or 1 == 1)
print(10 < 3 or 1 == 1 or 10 < 11 or 1!= 1 or 'a' != 'a')
res = 10 < 5 or 10 > 20
print(res)

res = 10 or 20  # or前为真，整个式子就可以确定为真了，or后就不需要执行(短路)
print(res)

# 3. not
#成立则不成立，不成立则成立,取反
print(not 10 > 3)
res=(10 > 3 and 'egon' != 'egon') or ((1 < 3 and 4 >= 3) or (not 8 > 3))
print(res)
print(not 10)
print(not 0)

4, 与，或，非的优先级
#and 优先级大于 or
res = 10 or 20 and 0
print(res)

#not 优先级大于and
res = not 0 and 10
print(res)

#优先级排序
not>and>or

身份运算符

==:判断的是值是否相等
is:判断的是id是否相等

值相等，id可以不同
>>> x='info:egon:18:male'
>>> y='info:egon:18:male'
>>> id(x),id(y)
(2924120923496, 2924120923568)
>>> x == y
True
>>> x is y
False

id相同，值一定相同
>>> x=10
>>> x=y
>>> id(x)
2924120923568
>>> id(y)
2924120923568
>>>
>>> x is y
True
>>> x == y
True

python内存优化策略（了解）：

常用的一些数值，在python启动后事先在内存里开辟好空间
pycharm中开辟的空间比python交互式环境更多，所以pycharm启动慢，占用内存多
数字的范围是：-5-256
常用字符串也有在内存中开辟空间存储

x=123213123123123133333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333331
y=123213123123123133333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333331
print(id(x))
print(id(y))

python入门（三）

if判断

python中用缩进来代表代码逻辑，一般缩进四个空格

语法一：
if 条件:
    # 条件成立时执行的子代码块
    代码1
    代码2
    代码3

示例：
#!/usr/bin/env python
sex='female'
age=18
height=170
appearance=8

if sex == 'female' and age>16 and age<20 and appearance:
    print('I want to show love to her')

print('other code 1...')
print('other code 2...')
print('other code 3...')

语法二：
if 条件:
    # 条件成立时执行的子代码块
    代码1
    代码2
    代码3
else:
    # 条件不成立时执行的子代码块
    代码1
    代码2
    代码3
    
    
# 示例：
sex='female'
age=38
is_beautiful=True

if sex == 'female' and age > 16 and age < 20 and is_beautiful:
    print('开始表白。。。')
else:
    print('阿姨好。。。')


print('other code1...')
print('other code2...')
print('other code3...')

语法三：
if 条件1:
    if 条件2:
        代码1
        代码2
        代码3


# 示例：
sex='female'
age=18
is_beautiful=True
is_successful=True
height=1.70


if sex == 'female' and age > 16 and age < 20 and is_beautiful 
        and height > 1.60 and height < 1.80: 
    print('开始表白。。。')
    if is_successful:
        print('在一起。。。')
    else:
        print('什么爱情不爱情的,爱nmlgb的爱情,爱nmlg啊.')
else:
    print('阿姨好。。。')


print('other code1...')
print('other code2...')
print('other code3...')

语法四：
if 条件1:
    代码1
    代码2
    代码3
elif 条件2:
    代码1
    代码2
    代码3
elif 条件3:
    代码1
    代码2
    代码3
.......
else:
    代码1
    代码2
    代码3
    
示例1：
如果成绩 >= 90，那么：优秀

如果成绩 >= 80且 < 90, 那么：良好 

如果成绩 >= 70且 < 80, 那么：普通

其他情况：很差


score = input('please input your score: ')  # score='100'
score = int(score)

if score >= 90:
    print('优秀')
elif score >= 80:
    print('良好')
elif score >= 70:
    print('普通')
else:
    print('很差')
    
    
示例2:
work_day=['Monday','Tuesday','Wednesday','Thursday','Friday']
free_day=['Saturday','Sunday']

today=input('Please input what day is it today ')
today=today.lower()
today=today.title()

if today in work_day:
    print('上班')
elif today in free_day:
    print('休息')
else:
    print('''
    You must enter one of strings as below:
    Monday
    Tuesday
    Wednesday
    Thursday
    Friday
    Saturday
    Sunday
    ''')

while 循环

条件循环

语法：
while 条件:
    代码1
    代码2
    代码3


while True:
    name=input('please input your name: ')
    pwd=input('please input your password: ')

    if name == 'egon' and pwd == '123':
        print('login successful')
    else:
        print('username or password error')

结束while循环的两种方式

• 条件改为False

方式一：条件改为False，
    在条件改为False时不会立即结束掉循环，而是要等到下一次循环判断条件时才会生效
        
    tag=True
    while tag:
        name=input('please input your name: ')
        pwd=input('please input your password: ')
    
        if name == 'egon' and pwd == '123':
            print('login successful')
            tag=False
        else:
            print('username or password error')
    
        print('===>')

• while+break

break后面的代码块无效，不会处理

方式二：while+break
    break一定要放在循环体内，一旦循环体执行到break就会立即结束本层循环
    
    while True:
        name=input('please input your name: ')
        pwd=input('please input your password: ')
    
        if name == 'egon' and pwd == '123':
            print('login successful')
            break
        else:
            print('username or password error')
    
        print('===>>>>>')
        print('===>>>>>')

while+continue:

结束本次循环，直接进入下一次循环

continue后面的代码块无效，不会再执行

# 示例一
count=1
while count < 6: #count=6
    if count == 4:
        count += 1
        continue
        
    print(count)
    count+=1

# 示例二：
while True:
    name=input('please input your name: ')
    pwd=input('please input your password: ')

    if name == 'egon' and pwd == '123':
        print('login successful')
        break
    else:
        print('username or password error')
        # continue # 此处加continue无用
        
# 示例3
#当用户输错三次账号密码结束循环
count=1
while count<=3:
    name = input('please input your name: ')
    pwd = input('please input your password: ')

    if name == 'egon' and pwd == '123':
        print('login successful')
        break
    else:
        print('username or password error')
        count+=1

while + else:

while 条件:
    代码1
    代码2
    代码3
else:
    在循环结束后，并且在循环没有被break打断过的情况下，才会执行else的代码
    
while 条件:
    代码1
    代码2
    代码3
else:
    在循环结束后，并且在循环没有被break打断过的情况下，才会执行else的代码
    
    
tag=True
while tag:
    print(1)
    print(2)
    print(3)
    # tag=False
    break
else:
    print('else的代码') #只有循环没有被break打断才会执行else的代码，比如说设定一个变量tag=True,在循环结束，赋值tag=False,这时候就会执行else的代码

while嵌套循环

while 条件1:
    while 条件2：
        代码1
        代码2
        代码3

#示范一：
while True:
    name=input('please input your name: ')
    pwd=input('please input your password: ')

    if name == 'egon' and pwd == '123':
        print('login successful')
        while True:
            print("""
            0 退出
            1 取款
            2 转账
            3 查询
            """)
            choice=input('请输入您要执行的操作：') #choice='1'
            if choice == '0':
                break
            elif choice == '1':
                print('取款。。。')
            elif choice == '2':
                print('转账。。。')
            elif choice == '3':
                print('查询')
            else:
                print('输入指令错误，请重新输入')
        break
    else:
        print('username or password error')


# 示范二：
tag=True
while tag:
    name=input('please input your name: ')
    pwd=input('please input your password: ')

    if name == 'egon' and pwd == '123':
        print('login successful')
        while tag:
            print("""
            0 退出
            1 取款
            2 转账
            3 查询
            """)
            choice=input('请输入您要执行的操作：') #choice='1'
            if choice == '0':
                tag=False
            elif choice == '1':
                print('取款。。。')
            elif choice == '2':
                print('转账。。。')
            elif choice == '3':
                print('查询')
            else:
                print('输入指令错误，请重新输入')
    else:
        print('username or password error')

For循环

迭代器循环，根据迭代器原理遍历取值

l=['a','b','c','d','e']

i=0
while i < len(l):
    print(l[i])
    i+=1

for x in l: # x='b'
    print(x)

dic={'name':'egon','age':18,'gender':'male'}
for x in dic:
    print(x,dic[x])

for + break

nums=[11,22,33,44,55]
for x in nums:
    if x == 44:
        break
    print(x)

for+ continue

nums=[11,22,33,44,55]
for x in nums:
    if x == 22 or x == 44:
        continue
    print(x)

for+else

names=['egon','kevin1111_dsb','alex_dsb','mac_dsb']

for name in names:
    if name == 'kevin_dsb':
        break
    print(name)
else:
    print('======>')

for+range()

# range的用法 (掐头去尾) ----->将数字生成列表，python2中直接生成列表，python3先封装起来,减少内存占用
- python2
>>> range(1,5)  #不设定步长，默认步长1
[1, 2, 3, 4]
>>> for i in range(1,5):
...     print(i)
...
1
2
3
4
>>> range(1,5,1) #设定步长为1
[1, 2, 3, 4]
>>> range(1,5,2) #设定步长为2
[1, 3]

- python3

>>> range(1,5)
range(1, 5)
>>> for i in range(1,5):
...     print(i)
...
1
2
3
4
>>> range(1,5,1)
range(1, 5)
>>> range(1,5,2)
range(1, 5, 2)

for i in range(5): # 0 1 2 3 4
    print(i)

for嵌套

for i in range(3):
    for j in range(4):
        print(i,j)

while循环练习题

# 1. 使用while循环输出1 2 3 4 5 6     8 9 10
count = 1
while count <= 10:
    if count == 7:
        count+=1  #在count
        continue
    print(count)
    count += 1