Pyhton的两种执行方式：交互式与脚本文件

l  交互式模式

直接在Windows或者Linux环境下打开Python解释器执行。

优点：快捷，调试方便。

缺点：不能够保存代码。

C:\Users\cc>python3

Python 3.6.2 (v3.6.2:5fd33b5, Jul  8 2017, 04:57:36) [MSC v.1900 64 bit (AMD64)]

 on win32

Type "help", "copyright", "credits" or "license" for more information.

>>> print(‘hello word‘)

hello word

>>> 

l  脚本文件执行

先将执行的内容写成脚本文件，然后使用Pyhton命令+文件全路径执行

优点：能够永久保存代码。

缺点：调试稍微麻烦一点（可以使用IDE工具）。

C:\Users\cc>python3 D:\helloword.tx

hello word

1、 启动解释器。

2、 把文件内容从磁盘中读到内存中去。

3、 解释器读取文件内容，识别内容中的命令后去执行。

Python后缀名和执行原理没有关系，读取内容（在内存里 一行行解释）再执行。

但是最好写成py告诉人们这是一个py程序。

变量就是变化的量。

变量的作用：用来在程序运行期间存储各种需要临时保存不断变化的数据

### 变量名：相当于门牌号，它的作用是代表（或者引用）某个变量值的名字。

变量名 赋值符号 变量值

name=leo

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‘]

驼峰体：

UserName=leo

下划线（推荐）：

user_name=leo

常量：不变的量

USERNAME=leo

Python的常量，只能将变量名都变成大写，但是这只是一个提示作用，还是可以改的

当我们写

name=leo

时，Python解释器做了2件事：

1、 在内存中创建一个“leo”的字符串

2、 在内存中创建一个名为name的变量，并把它指向“leo”的内存地址。

3、 如果在声明一个age=28，那么他们的关系如下图：

如何获取变量指向的内存地址：

>>> ame=‘leo‘

>>> age=16

>>> print(id(name),id(age))

666914558728 1773717648

ID看到的只是ID号，并非真正的内存地址，真正的内存地址无法查看。

两个变量名都分别指向了不同的值和内存地址，如果这个时候我们再声明一个变量

name2=name

理论上我并不是赋值一个字符串，而是把name的值赋给name2，name2此时也应该被指向‘leo‘，name与name2的内存地址也应该一致。

>>> name=‘leo‘

>>> name2=name

#age=16

>>> print(name,id(name),name2,id(name2))

#再把name重新赋值‘pyhton‘name2还会跟着改变么？

>>> name=‘python‘

>>> print(name,id(name),name2,id(name2))

leo 628132844296 leo 628132844296

python 628136510160 leo 628132844296

经过测试由此得出以下结论：

1、 变量赋值给变量，就是将两个变量名赋值给同一个内存地址，获取同一个值。

2、 在执行name=‘python‘时,解释器创建了一个新的值python，并把name重新指向给了‘Python’

3、 此时查看两个变量的内存地址就会发现，name已经重新指向了pyhton的内存地址，而name2还是原来的leo。

它们的关系应该是这样:

l  结论：

当把一个变量A赋值给一个变量B时，解释器只是把变量A所指向的内存地址赋值给了变量B，因此变量A和变量B并没有发生直接的关联！只不过它们都同时指向了同一个内存地址而已，这也就是为什么把变量A再指向一个新地址后，而变量B还保持不变的原因。

Python拥有自动回收垃圾的机制，即回收内存空间。没人用的就是称为垃圾，如我们现在定义:

>>> age=18

>>> age=19

>>> age2=19

>>> print(id(age),age,id(age2),age2)

1773914352 19 1773914352 19

最后打印的应该是值19的内存地址，说明之前18已经和age变量解除了关系，那么它去哪了呢？

实际上18对应的内存地址由于没有人引用了，就会被定期回收，那么上面的过程就是 age解除了与18的关系，与19建立了关联关系。

有没有发现，每次重新运行程序，字符串类型的变量id得到的内存地址都不一样？

Pyhton垃圾回收的特性:

Python不用自己来清除垃圾，会在程序结束的时候自己解除回收，所以每次执行程序都相当于重新创建了变量和内存地址，不用考虑回收垃圾的问题。

总结：

Pyhton拥有垃圾回收机制;

Python会回收引用计数等于0的内存空间。

Python会在程序结束的时候回收垃圾。

定义一个变量会有三个特征：id、type、value

id代表变量引用的内存地址id

type代表数据类型

value代表值

>>> name=‘leo‘

>>> age=28

>>> print(id(name),type(name),name)

>>> print(id(age),type(age),age)

167542887176 <class ‘str‘> leo

1773914640 <class ‘int‘> 28

变量名没有存储功能，只是删除了变量名与值的绑定关联关系，并不是真的删除值。

>>> name=‘leo‘

>>> del name

>>> print(name)

用户与程序交互的目的：获取用户输入的内容。

### 在python3中的input：无论用输入何种类型，都会存成字符串类型

>>> name=input(‘please input your name: ‘)

>>> print(id(name),type(name),name)

please input your name: leo

522660184336 <class ‘str‘> leo

### 在python2中

### raw_input与python3的input是一样的

>>> name=raw_input(‘please input your name: ‘)

>>> print(id(name),type(name),name)

### python2中input，用户必须输入值，输入的值是什么类型，就存成什么类型

>>> name=input(‘please input your name: ‘)

>>> print(id(name),type(name),name)

### 文件头

Python不支持中文的解决方法，在文件头加入：

#!/usr/bin/env python

# -*- coding: utf-8 -*-  

用来标识：年纪、身份证号、qq号、等级等数字整数类型

定义：age=28 # age=int（28）

>>> age=18

>>> print(type(age))

<class ‘int‘>

用来标识：工资、身高、体重、带有小数的浮点类型数字

定义：height=1.86 # height=float(1.86)

>>> height=1.86

>>> print(type(height))

<class ‘float‘>

在python中，加了引号的字符就是字符串类型，python并没有字符类型

用来标识：姓名、性别、国籍、种族等字符数据

定义：name=‘leo‘ # name=str（leo）

>>> name=‘leo‘

>>> print(type(name))

<class ‘str‘>

### 单引号和双引号没有太大区别，只有在配合使用的时候需要注意，如：

msg="i ‘m leo"

### 多引号的作用，多行字符串必须要用多引号，如：

msg = ‘‘‘

天气预报：

星期一：晴天

星期二：阴天

...

‘‘‘

要求：

l  只能字符串之间拼接

l  字符串之间只能用+或*

### 相加 ，其实就是简单拼接

>>> fname=‘leo‘

>>> lname=‘lex‘

>>> print(fname+lname) leolex

leolex

### 注意1：字符串相加的效率不高

字符串1+字符串2，并不会在字符串1的基础上加字符串2，而是申请一个全新的内存空间存入字符串1和字符串2，相当字符串1与字符串2的空间被复制了一次，

>>> fname=‘leo‘

>>> lname=‘rubin‘

>>> print(fname+‘.‘+lname)

>>> print(fname+‘ ‘+lname)

leo.rubin

leo rubin

### 相乘,x5次输入

>>> print(fname*5)

leoleoleoleoleo

在[]内用用逗号分隔开的多个元素，每个元素可以是任意类型

用于标识：存储多个值的情况，比如一个人的爱好，个人信息等。

定义类型：hobbies=[‘play‘,‘music‘，‘move‘] # hobbies=list（[‘play‘,‘music‘，‘move‘]）

### 取列表元素使用索引下标，从左向右，从0开始；从右向左，从-1开始

hobbies=list([‘play‘,‘read‘,‘music‘,‘movie‘])hobbies=[‘play‘,‘music‘,‘movie‘]

>>> hobbies=[‘play‘,‘read‘,‘music‘,‘movie‘]

>>> print(type(hobbies))

>>> print(hobbies[3])

>>> print(hobbies[0])

>>> print(hobbies[-1])

<class ‘list‘>

movie

play

movie

### 列表中可以嵌套列表，并且可以取值：

>>> info=[110,‘leo‘,28,[‘play‘,‘music‘,‘read‘,‘movie‘]]

>>> print(info[0])

>>> print(info[3][3])

110

movie

### 存放多个学生信息

### 先取第一个学生的所有信息

### 再取第一个学生的第一个爱好

>>> students_info=[[‘leo‘,28,[‘movie‘,‘music‘]],[‘rubin‘,30,[‘play‘,‘read‘]]]

>>> print(students_info[0])

>>> print(students_info[0][2][0])

[‘leo‘, 28, [‘movie‘, ‘music‘]]

movie

### 为什么需要字典？字典的作用是什么

存放一个人的信息：姓名，性别，年龄，很明显是多个值，既然是存多个值，我们完全可以基于刚刚学习的列表去存放，如下

>>> info=[‘leo‘,28,‘movie‘]

定义列表的目的不单单是为了存，还要考虑取值，如果我想取出这个人的年龄，可以用

>>> info[1]

但这是基于我们已经知道在第2个位置存放的是年龄的前提下，我们才知道索引1对应的是年龄

即：

#      name,age,hobbies

info=[‘leo‘,28,‘movie‘]

而这完全只是一种假设，并没有真正意义上规定第三个位置存放的是年龄，于是我们需要寻求一种，即可以存放多个任意类型的值，又可以硬性规定值的映射关系的类型，比如key=value，这就用到了字典

字典：定义在{}内，用key-value形式表示一个元素，用逗号隔开：

用于标识：存储多个值的情况，每个值都有唯一一个对应的key，可以更为方便高效的取值：

定义：info={‘name‘:‘leo‘,‘age‘:28,‘hobbies‘:‘movie,game‘}

# info=dcit（{‘name‘:‘leo‘,‘age‘:28,‘hobbies‘:‘movie,game‘}）

>>> info={‘name‘:‘leo‘,‘age‘:28,‘hobbies‘:‘movie,game‘}

>>> print(info[‘name‘])

>>> print(info[‘age‘])

>>> print(info[‘hobbies‘])

leo

28

movie,game

info={
    ‘name‘:‘leo‘,
    ‘age‘:‘28‘,
    ‘hobbies‘:[‘play‘,‘movie‘,‘read‘],
    ‘company_info‘:{
        ‘name‘:‘sitech‘,
        ‘type‘:‘IT‘,
        ‘emp_num‘:2000
    }
}

# 取人员基本信息和第三个爱好
print(info[‘name‘],info[‘age‘],info[‘hobbies‘][2])
# 取公司名称
print(info[‘company_info‘][‘name‘])

### 列表里可以放任意类型的元素，可以将人员信息以字典类型模式放入列表中

info=[
    {‘name‘:‘leo‘,‘age‘:28,‘hobbies‘:[‘play‘,‘game‘]},
    {‘name‘:‘rubin‘,‘age‘:30,‘hobbies‘:[‘read‘,‘music‘]},
    {‘name‘:‘lex‘,‘age‘:29,‘hobbies‘:[‘movie‘,‘game‘]},
]

### 取第三个学生的第二个爱好
print(info[2][‘hobbies‘][1])

布尔值：True代表真，False代表假

人脑的主要作用是数据运行与逻辑计算，布尔类型就模拟人的逻辑运算，即判断一个条件成立时，用True标识，不成立则用False标识。

>>> a=5
>>> b=3
>>> print(a > b)
>>> print(a < b)

True

False

可以通过条件结果做不同的事，比如：比较运算或者逻辑运算

#1.可变类型：在id不变的情况下，value可以变，则称为可变类型，如列表，字典

#2. 不可变类型：value一旦改变，id也改变，则称为不可变类型（id变，意味着创建了新的内存空间）

获取用户信息，然后打印成固定格式，比如：

请用户输入名字和年龄，然后打印如下格式：

My name is XXX, I am XXX

格式化输出，需要使用到占位符，常见的占位符有：

%d 整数

%s 字符串

%f 浮点数

### 使用%s字符串占位符

>>> name=input(‘Please input your name: ‘)
>>> age=input(‘Please input your age: ‘)
>>> print(‘My name is %s,I am %s‘ %(name,age))

Please input your name: leo

Please input your age: 28

My name is leo,I am 28

### 如果想要使用%d呢？如果直接使用%d这样是不行的，要注意在接收用户输入的age的类型是str，所以需要转成int类型

print(‘My name is %s,I am %d‘ %(name,age))

name=input(‘Please input your name: ‘)
age=int(input(‘Please input your age: ‘))
print(‘My name is %s,I am %d‘ %(name,age))

练习：用户输入姓名、年龄、工作、爱好 ，然后打印成以下格式

------------ info of Egon -----------

Name  : Egon

Age   : 22

Sex   : male

Job   : Teacher

------------- end -----------------

### 思路：

1、 要求用户输入，需要用到input方法获取用户输入然后分别存在4个对应变量当中

2、 有数字类型，并没有要求你是否要使用int

3、 多行模式，可以使用‘‘‘输出

name=input(‘Please input your name: ‘)
age=input(‘Please input your age: ‘)
sex=input(‘Please input your sex: ‘)
job=input(‘Please input your job: ‘)

print(
‘‘‘
------------ info of Egon -----------
Name : %s
Age  : %s
Sex  : %s
Job  : %s
------------- end -------------------

‘‘‘
%(name,age,sex,job)
)

Please input your name: leo

Please input your age: 29

Please input your sex: male

Please input your job: IT

------------ info of Egon -----------

Name : leo

Age  : 29

Sex  : male

Job  : IT

------------- end -------------------

计算机可以进行的运算有很多种，可不只加减乘除这么简单。

运算按种类可以分成：

l  算数运算

l  比较运算

l  逻辑运算

l  赋值运算

l  身份运算

l  位运算

假设：a=10，b=5

假设：a=10，b=5

假设：a=10，b=5

>>>height=186
>>>height+=1 #height=height+1
>>>print(height)

187

name=‘leo‘
age=28

print(name == ‘leo‘ and age == 28)                 True
print(name == ‘leo‘ and age == 8)                  False

print(name == ‘leo‘ or age == 28)                  True
print(name == ‘lex‘ or age == 8)                   False

print(not(age==28))                                 False
print( not(name == ‘leo‘) and age == 28)           False

#   ==等号比较的是value

#   is比较的是id

x=‘leo0329‘
y=‘leo0329‘
print(id(x))
print(id(y))
print(x==y)
print(x is y)

1069503381776

1069503381776

True

True

条件判断使用if...else

如果条件（在if和冒号之间的表达式）判定为真，那下面的语句块就会被执行，如果位假，语句块就不会被执行。

if （条件）:

    执行

1、如果年级大于30，那么叫“阿姨”

age=int(input("please input your age: "))
if age > 30:
    print("阿姨好")

please input your age: 31

阿姨好

2 如果：女人的年龄>30岁，那么：叫阿姨，否则：叫小姐，否则使用else。

age=int(input("please input your age: "))
if age > 30:
    print("阿姨好")
else:
    print("小姐姐")

please input your age: 28

小姐姐

3 如果：女人的年龄>=18并且<22岁并且身高>170并且体重<100并且是漂亮的，那么：表白，否则：叫阿姨

思考：

首先要先确定有几个变量：age、height、weight、is_pretty

然后条件是 age >= 18 and <22、hetght>170、weight<100、is_pretty=True

age=20
height=171
weight=99
is_pretty=True

if  age >= 18 and age < 22 and height > 170 and weight < 100 and is_pretty == True:
    print("表白")
else:
    print("阿姨好")

age=int(input(‘age>>>: ‘))
is_pretty=str(input(‘is_pretty: ‘))
if  age >= 18 and age < 22 and is_pretty == ‘True‘:
    print("表白成功")
else:
    print("阿姨好")

x = input(‘Please enter a number :‘)
 

#在表白的基础上继续：

#如果表白成功，那么：在一起

#否则：打印 "去你妈的爱情"

age=20
height=171
weight=10000
is_pretty=True
success=True

if  age >= 18 and age < 22 and height > 170 and weight < 100 and is_pretty == True:
    if success == True:
        print("表白成功")
    else:
        print("去你妈的爱情")
else:
    print("阿姨好")

如果：成绩>=90，那么：优秀
       如果成绩>=80且<90,那么：良好
       如果成绩>=70且<80,那么：普通
       其他情况：很差

count=int(input(‘count>>>: ‘))
if count >= 90:
    print(‘优秀‘)
elif count >=80:
    print(‘良好‘)
elif count >=70:
    print(‘普通‘)
else:
    print(‘很差‘)

语法：

if 条件1:

　　　　缩进的代码块

　　elif 条件2:

　　　　缩进的代码块

　　elif 条件3:

　　　　缩进的代码块

　　......

　　else:　　

　　　　缩进的代码块

练习1：用户登录验证

### 请用户输入用户名和密码，如果用户名是leo，密码是123就通过，否则报错用户密码错误。

user_name=input(‘username>>>: ‘)
user_pass=input(‘password>>>: ‘)

if user_name == ‘leo‘ and user_pass == ‘123‘:
    print(‘login success‘)
else:
    print(‘用户名或密码错误‘)

练习2：根据用户输入内容打印其权限

‘‘‘

egon --> 超级管理员

tom  --> 普通管理员

jack,rain --> 业务主管

其他 --> 普通用户

‘‘‘

user_name=input(‘username>>>: ‘)
if user_name == ‘leo‘:
    print(‘您好，超级管理员‘)
elif user_name == ‘tom‘:
    print(‘您好，普通管理员‘)
elif user_name == ‘jack‘ or user_name == ‘rain‘:
    print(‘您好，业务主管‘)
else:
    print(‘普通用户‘)

练习3：根据今天是周几，选择相应输出

# 如果:今天是Monday,那么:上班

# 如果:今天是Tuesday,那么:上班

# 如果:今天是Wednesday,那么:上班

# 如果:今天是Thursday,那么:上班

# 如果:今天是Friday,那么:上班

# 如果:今天是Saturday,那么:出去浪

# 如果:今天是Sunday,那么:出去浪

today=input(‘today>>>: ‘)
if today == ‘Saturday‘ or today == ‘Sunday‘ :
    print(‘出去浪‘)
elif today == ‘Monday‘ or today == ‘Tuesday‘ or today == ‘Wednesday‘ or today == ‘Thursday‘  or today == ‘Friday‘ :
    print(‘上班‘)
else:
    print(‘‘‘您只能输入其中一种：
    Monday
    Tuesday
    Wednesday
    Thursday
    Friday
    Saturday
    Sunday
    ‘‘‘)

### in可以象其他运算符一样在条件语句中使用。

### 可以检查一个值是否在列表中。

today=input(‘today>>>: ‘)
if today in [‘Saturday‘,‘Sunday‘]:
    print(‘出去浪‘)
elif today in [‘Monday‘,‘Tuesday‘,‘Wednesday‘,‘Thursday‘,‘Friday‘] :
    print(‘上班‘)
else:
    print(‘‘‘您只能输入其中一种：
    Monday
    Tuesday
    Wednesday
    Thursday
    Friday
    Saturday
    Sunday
    ‘‘‘)

### 先完成一个猜年龄的小程序，设leo的年级是 28

leo_age = 28
guess = int(input(‘guess>>>: ‘))
if guess > 28:
    print(‘猜大了‘)
elif guess < 28:
    print(‘猜小了‘)
else:
    print(‘猜对了！！！‘)

这样执行只能猜一次，猜中的几率很小，如果想给玩家3次机会呢？总不能复制三次代码执行（其实可以），但是这样太费劲了。

那么就使用循环：循环可以做到不用重写代码又能让程序重复一段代码执行多次。

while 条件:   

    # 循环体

    # 如果条件为真，那么循环体则执行，执行完毕后再次循环，重新判断条件。。。

    # 如果条件为假，那么循环体不执行,循环终止

count=0
while count < 3:
    print(‘loop‘,count)
    count+=1

loop 0

loop 1

loop 2

### 打印0-10

count=0
while count <= 10:
    print(‘loop‘,count)
    count+=1

#打印0-10之间的偶数

#偶数/2余0
#奇数/2余1

count=0
while count <= 10:
    if count%2==0:
        print(count)
    count+=1

#打印0-10之间的奇数

#偶数/2余0
#奇数/2余1

count=0
while count <= 10:
    if count%2==1:
        print(count)
    count+=1

count=0
while True:
    print(count)
    count+=1

name=‘leo‘
password=‘123‘
count=0

while count < 3:
    user_name=input(‘user_name>>>: ‘)
    user_pass=input(‘user_pass>>>: ‘)
    if user_name == name and user_pass == password :
        print("login success")
        break
    else:
        print(‘用户名或者密码错误‘)
        count+=1

语法：

tag=True

　　while tag:

　　　　......

　　　　while tag:

　　　　　　........

　　　　　　while tag:

　　　　　　　　tag=False

#练习，要求如下：

    1 循环验证用户输入的用户名与密码

    2 认证通过后，运行用户重复执行命令

    3 当用户输入命令为quit时，则退出整个程序 

name=‘leo‘
password=‘123‘
count=0
while count < 3:
    user_name=input(‘user_name>>>: ‘)
    user_pass=input(‘user_pass>>>: ‘)
    if user_name == name and user_pass == password :
        print("login success")
        while True :
            cmd=input(‘cmd>>>: ‘)
            if cmd == ‘quit‘:
                print(‘886‘)
                break
            else:
                print(‘run %s‘%cmd)
        break
    else:
        print(‘用户名或者密码错误‘)
        count+=1

方法二：使用tag

name=‘leo‘
password=‘123‘
count=0
tag=True
while tag :
    if count == 3:
        break
    user_name=input(‘user_name>>>: ‘)
    user_pass=input(‘user_pass>>>: ‘)
    if user_name == name and user_pass == password :
        print("login success")
        while tag :
            cmd=input(‘cmd>>>: ‘)
            if cmd == ‘quit‘:
                print(‘886‘)
                tag=False
                continue
            print(‘run %s‘%cmd)
    else:
        print(‘用户名或者密码错误‘)
        count+=1

### break跳出本层循环

count=0
while True:
    if count > 5 :
            break
    print(count)
    count+=1

### continue 跳出本次循环
count=0
while count <= 10:
    if count == 7 :
        count += 1
        continue
    print(count)
    count+=1

#与其它语言else 一般只与if 搭配不同，在Python 中还有个while ...else 语句，while 后面的else 作用是指，当while 循环正常执行完，中间没有被break 中止的话，就会执行else后面的语句

count=0
while count <= 10:
    #if count == 3:
        #break
    print(count)
    count+=1
else:
    print(‘while正常结束了，没有被break打断，才会执行这里的代码‘)