Python语言基础

不要光看，要多敲代码，遇到问题解决问题，不要恐惧

第一章 计算机基础知识

计算机是什么

计算机是用来计算的机器，只能根据人类的指令来完成各种操作

计算机的组成

计算机组成：硬件和软件

硬件：键盘，鼠标，显示器，CPU、主板、内存、硬盘，是看得见摸得着的

软件：系统软件（windows,mscOS,Linux)和应用软件(office,QQ)看得见摸不着的，负责控制计算机中的硬件

计算机的使用方式

通过软件对计算机完成各种操作，注意的是软件并不是所有功能都会对用户开放，用户需要调用软件提供的接口（Interface交互界面）来操作计算机

用户界面分为两种：TUI(文本交互界面，例如CMD页面，shell页面)和GUI（图形化交互界面）

windows的命令行

命令行就是文本交互界面，通过命令行可以使用一个一个指令来操作计算机，任何计算机的操作系统都包含命令行

命令行有多个不同名字：命令行，命令行窗口，DOS窗口，命令提示符，CMD窗口，Shell，终端，Terminal

练习：通过搜索引擎来搜下，各个操作系统当中的命令行窗口的样式

1、如何进入到命令行

win键+R出现运行窗口，输入cmd，回车；开始—windows系统管理工具——cmd

2、命令行的结构

-版本以及版权声明（一般没什么用）

Microsoft Windows [版本 10.0.17763.5122]
© 2018 Microsoft Corporation。保留所有权利。

-命令提示符

C:\Users\Administrator>

C: -当前所在磁盘根目录

​ -可通过 d: 来切换盘符（切换到d盘）

\Users\Administrator：-所在磁盘的路径，当前所在的文件夹

​ -cd 切换目录

3、常用dos命令

dir 常看当前目录下所有文件（夹）

cd **进入指定目录

cd .当前目录

cd …回到上一级目录

md 创建一个目录

rd 删除一个目录

del 删除文件

cls 清楚屏幕

命令的语法

命令 【参数】 【选项】

环境变量

环境变量指的是操作系统当中的一些变量。通过修改环境变量，来对计算机进行配置（主要配置路径）

查看环境变量，添加环境变量，修改环境变量，删除环境变量

右键-计算机（此电脑）-属性-高级系统设置-环境变量

path环境变量

path环境变量中保存的是一个一个的路径。当在命令行中输入一个命令（访问一个文件时），系统会先在当前目录下找，若找到了则直接执行或打开，若没有找到，则会依次去path环境变量的路径中去寻找，直到找到为止，若Path环境变量中路径都没找到，则报错不是内部命令或外部命令，故可以将经常使用的文件路径复制到path环江变量中，就可以在任意位置访问文件，path环境变量不区分大小写，记得重启cmd

进制

十进制

0，1，2，3，4，5，6，7，8，9

二进制

所有数据在计算机底层都是以二进制存储，可将内存想象为一个个的小格子,一个小格子存储一个1或一个0，内存的一个小格子就称为1bit(位)

bit是计算机中最小的单位，byte是最小的可操作的单位，8bit=1byte(字节)，1024byte=1kb(千字节)

八进制

0，1，2，3，4，5，6，7

十六进制

0，1，2，3，4，5，6，7，8，9，10，A,B,C,D,E

文本文件和字符集

文本分为：纯文本，富文本

纯文本：只保存单一的文本内容，无法保存内容无关的关系，例如无法设置颜色大小格式

富文本：可以保存文本以外的内容（例如word文档）

开发时，编写程序使用的全是纯文本

纯文本在计算机底层也会转换成二进制保存

将字符转换为二进制码的过程，称为编码

二进制转换为字符的过程，称为解码（参考电报发送接收）

编码和解码所采用的规则，称为字符集

常见的字符集：

ASCII:美国编码，使用7位来对美国常用的字符进行编码，包含128个字符

ISO-8859-1：欧洲编码，使用8位，包含256个字符

GB2312：国标码

GBK：国标码，中国的编码

Unicode:万国码，包含世界上所有的语言和符号，编写程序时一般用它，有多种实现，UTF-8,UTF-16

最常用的是UTF-8

Sublime Text 3

纯本文编辑器

第二章 Python

计算机语言

计算机语言发展阶段：

**机器语言：**二进制编码来编写程序,执行效率高，编写麻烦

**汇编语言：**使用符号代替机器码，编程程序时，不需要使用二进制，直接编写符号，编写完成后，需要将符号转为机器码（汇编），然后再由计算机执行。将机器码转换为符号的过程，称为反汇编。汇编语言只只适用于某些硬件，兼容性较差

高级语言：C++,Python等

编译型语言和解释型语言

计算机只能识别二进制编码（机器码），任何语言交由计算机执行时必须要先转换为机器码，也就是像print(‘hello’)需要转换为类似10101这样的机器码

根据转化时机的不同，语言分成了两大类：

编译型语言：

C语言，编译型语言，会在代码执行前将代码编译为机器码，然后机器码交由计算机执行。a（源码）—编译—b(编译后的机器码)。相当于饭店点菜等着吃

特点：执行速度快，跨平台性较差

解释型语言：

Python，JS,Java

解释型语言，不会在执行前对代码进行编译，而是在执行的同时一边执行一边编译。a（源码）——解释器——解释执行。相当于去吃火锅，一遍涮一边吃。

特点：执行速度慢，跨平台性比较好

python 的介绍

python是解释型语言

python的用途：

web应用

爬虫程序

科学计算

自动化运维

大数据（数据清洗）

云计算

桌面软件/游戏

人工智能

python开发环境搭建

开发环境搭建就是安装python解释器

python的解释器分类:

CPython(官方)：用c语言编写的python解释器

PyPy:用python语言编写的python解释器

IronPython:用.net编写的Python解释器

Jython:用Java编写的python解释器

步骤：

1.下载安装包

​ -3.x-

​ -2.x-

意思是添加到path环境变量

安装后，打开命令窗口，输入python出现以下内容

python的交互界面

命令行输入的python,所进入的界面就是python的交互界面

命令提示符：>>>

命令提示符后可直接输入python指令，会被解释器立即执行

安装python同时，会自动安装一个python的开发工具IDEL，实际上是一个交互界面，通过IDEL也可以进入到交互模式。不同的是，在IDEL中可以通过TAB键来查看语句的提示且对代码进行保存。

交互模式只能输入一行代码，执行一行，不适用于开发。

第三章 语法入门

概念

1.表达式

表达式就是一个类似于数学公式的东西

比如：10+22 8-0

表达式一般仅仅用了计算一些结果，不会对程序产生实质性影响。如果在交互式模式中输入了一个表达式，解释器会自动将表达式的结果输出

2.语句

在程序中语句一般需要完成某种功能，比如打印信息，获取信息，为变量赋值

比如：print() a=10

语句的执行一般会对程序产生一定的影响，在交互模式中不一定会输出语句的执行结果

若想输出结果，例如a=10,若再输出a,也就是print(a),便可得到10

3.程序

程序由一条条语句和一条条表达式构成。

4.函数（function)

函数就是一种语句，函数专门用来完成特定的功能

函数形如：xxxx()

函数的分类：

内置函数：由python解释器提供的函数，可以在python中直接使用

自定义函数：由程序员自主创建的函数

在开始-python 3.x documentation可以看官方离线手册

函数的两个要素：

参数：（）中的内容就是函数的参数，函数中可以没有参数，也可以有多个参数，多个参数用逗号分开

返回值:是函数的返回结果，不是所有的函数都有返回值

基本语法

1.python严格区分大小写

2.python中每一行都是一条语句，语句以换行符结束

3.每一行语句不要过长（规范建议每行不要超过80个字符）

4.一条语句可以分多行编写，语句后边以\结尾

5.python是严格缩进语言

6.python中使用#表示注释

字面量和变量

字面量

字面量就是一个一个值，比如：1，2，3，4，5，‘hello’

字面量所表示的就是它的字面的值，在程序中可以直接使用字面量

变量

变量（variable)可以用来保存字面量，并且变量中保存的字面量是不定的

a=10

print(a)

一般开发时，都是将字面量保存在变量中，通过变量来引用字面量

python中使用变量，不需要声明，直接为变量赋值即可。a=10

不能使用没有进行过赋值的变量，例如print(b)，否则会报错NameError:name ‘b’ is not defined

python是一个动态类型的语言，可以为便来给你赋任何类型的值，也可以任意修改变量的值

标识符

在python中所有可以自主命名的内容都属于标识符，比如：变量名，函数名，类名。

标识符必须遵循的规范：

1.标识符可以含有字母，数字，下划线，但是不能以数字开头

2.标识符不能是python中的关键字和保留字；也不建议使用python中函数名作为标识符，因为会导致函数被覆盖例如print=123 print(print)

3.命名规范：

下划线命名法：所有字母小写，单词之间使用下划线分割，例如max_length

帕斯卡命名法（大驼峰命名法）：首字母大写，每个单词开头字母大写，其余字母小写，例如MaxLength

如果使用不符合标准的标识符，将会报错SyntaxError:invalid syntax

第四章 数据类型

数值

​ 整型

​ 布尔值

​ 浮点型

​ 复数

字符串

空值

数值

数据类型指的是变量的值的类型，也就是为变量赋哪些值

在python数值分成了三种：整数，浮点数，复数

python中所有整数都是int类型，python中的整数的大小没有限制，可以是一个无限大整数。

如果数字的长度过大，可以使用下划线作为分隔符。a=123_456_789，输出结果不包含下划线

其他进制的整数，只要是数字打印一定是以十进制的形式显示的

十进制的数字不能以0开头

二进制，0b开头，b=0b10 #二进制的10，也就是十进制的2

八进制，0o开头

十六进制，0x开头

可以通过运算符来对数字进行运算，且保证整数运算的准确c=100 c=c+3

浮点数（小数），python中所有的小数都是float类型

对浮点数进行运算时，可能会得到一个不精确的结果

字符串

字符串用来表示一段文本信息，字符串是程序中使用的最多的数据类型

在python中字符串需要使用引号引起来,引号可以是单引号，也可以是双引号，注意不要混着用，相同的引号不能嵌套,不同的可以嵌套，如下s=‘hello’ print(s)

s='子曰：”学而时习之，不亦说乎“'

长字符串需注意，单引号和双引号不能跨行使用,不过，可以使用\实现

s='锄禾日当午，\

汗滴禾下土。\

谁之盘中餐，\

粒粒皆辛苦。'

但是打印出来不是换行的，可使用长字符串

使用三重引号来表示一个长字符串，‘’’ “”"

三重引号可以换行，并且会保留字符串中的格式

s='''锄禾日当午，\

汗滴禾下土。\

谁之盘中餐，\

粒粒皆辛苦。'''

转义字符，可使用\作为转义字符，面对相同引号嵌套使用时，可用\实现

s="子曰：\”学而时习之，不亦说乎\“"

\'表示' \"表示“ \t表示制表符 \n表示换行符 \\表示反斜杠 \uxxx表示Unicode编码

格式化字符串

字符串之间也可以进行加法运算,如果将两个字符串进行相加，则会自动将两个字符串拼接为一个字符

a='abc'+'haha'

print("a="+a)#在python中不常见

字符串不能和其他类型进行加法运算，会出现TypeError:must be str,not int

a=123

print('a = ',a)

print('a = %s ' %a)#结果是a=123

创建字符串时，可以在字符串中指定占位符

%s 在字符串中表示任意字符串

%f表示浮点数占位符

%d表示整数占位符

b = 'hello %s' %'sun'

print(b)

#结果是 hello sun

b = 'hello %s 你好 %s ' %('Tome','Sun')
print(b)
#结果是 hello Tome 你好 Sun 

`b='hello%3s' %'ab'
print(b)
#hello ab 不够补空格，够了自动补充`

b='hello%3s' %'abcdef'
print(b)
#结果是 helloabcdef

b='hello%3.5s' %'abcdefg'
print(b)
#结果是 helloabcde  【3.5表示最少3个，最多5个】

b='hello%.1s' %'123.456'
print(b)
#结果是 hello1

想限制小数的话，要用%f

b='hello%.2f' %'123.456'
Traceback (most recent call last):
  File "<pyshell#28>", line 1, in <module>
    b='hello%.2f' %'123.456'
TypeError: must be real number, not str
#注意，数字加了''就变成了字符串

b='hello%.2f' %123.456
print(b)
#结果是 hello123.46  保留两位小数，还可四舍五入

b='hello%d'%123.45
print(b)
#结果是 hello123 取整

格式化字符串，可以通过在字符串前添加一个f来创建一个格式化字符串变量

在格式化字符串中可以直接嵌入

a=123

b='呵呵'

c = f 'hello {a} {b} '

print(c)#答案是hello 123 呵呵

a=123
b='啊哈'
print(f'hello{a}{b}')
hello123啊哈

a=123    
print(f'a={a}')

#答案是a=123

练习：创建一个变量保存你的名字，然后通过四种格式化字符串的方式，在命令行中显示，欢迎xxx光临

#创建一个变量保存姓名
name='sun'

#拼串
print('欢迎'+name+'光临')
#结果是 欢迎sun光临

#多个参数
print('欢迎',name,'光临')
#结果是 欢迎 sun 光临

#占位符
print('欢迎%s光临’%name)
      #SyntaxError: incomplete input
      #注意英文格式
print('欢迎%s光临' %name)
# 结果是 欢迎sun光临

#格式化字符串
print(f'欢迎{name}光临')      
#结果是 欢迎sun光临

字符串的复制

#字符串的复制（将字符串和数字相乘）
a='abc'
# * 在语言中标识乘法
#如果将字符串和数字相乘，则解释器会将字符串重复指定的次数并返回
a=a * 2
print(a)
#结果：abcabc

布尔值和空值

#布尔值（bool）
#布尔值主要用来做逻辑判断
#布尔值一共有两个值，True和False
a=True
b=False
#布尔值实际上也属于整形，True相当于1，False相当于0
print(1+True)
#结果是2

#None(空值）
#None专门用来表示不存在
b=None
print(b)

类型检查

#通过类型检查，可以检查只能值（变量）的类型
a=123 #数值
b='123'#字符串
print('a=',a)
print('b=',b)
#type()用来检查值的类型
#该函数会将检查的结果作为返回值返回,可以通过变量来接收函数的返回值
c=type(123)
d=type('123')
e=type(a)
print(c)
print(d)
print(e)
print(type(b))
# #结果是以下显示
# a= 123
# b= 123
# <class 'int'>
# <class 'str'>
# <class 'int'>
# <class 'str'>

print(type(1))
print(type(1.4))
print(type(True))
print(type('hello'))
print(type(None))
#结果如下
# <class 'int'>
# <class 'float'>
# <class 'bool'>
# <class 'str'>
# <class 'NoneType'>

对象介绍

python是一门面向对象的语言，一切皆对象。

程序运行当中，所有的数据都是存储到内存中然后再运行的。

对象就是内存中专门用来存储指定数据的一块区域，对象实际上就是一个容器，专门用来存储数据

数值、字符串、布尔值，空值都是对象

对象的结构

每个对象中都要保存三种数据

• id(标识)

  id用来标识对象的唯一性，每一个对象都有唯一的Id,相当于人的身份证号。可以通过id()函数来查看对象的id。id是由解析器生成的，在CPython中，id就是对象的内存地址

• type（类型）

  类型用来标识当前对象所属类型，比如int，float，类型决定了对象有哪些功能

  python是一种强类型的语言，对象一旦创建类型便不能修改

  通过type()函数来查看对象的类型

• valude(值)

  值就是对象中存储的具体数据

  对于有些对象值是可以改变的

  对象分成两大类，可变对象，不可变对象

  • 可变对象的值可以改变
  • 不可变对象的值不能改变

变量和对象

对象并没有直接存储到变量中，在python中变量更像是给对象起的一个别名

变量中存储的不是对象的值，而是对象的id（内存地址），当我们使用变量时，实际上就是通过对象id在查找对象

变量中保存的对象（内存地址），只有在为变量重新赋值时才会改变

变量和变量之间时相互独立的，修改一个变量不会影响另一个变量

类型转换

所谓类型转换，是将一个类型的对象转换为其他对象

类型转换不是改变对象本身的类型，而是根据当前对象的值创建一个新的对象

#类型转换四个函数 int() float() str() bool()
#int() 可以用来将其他的对象转换为整型
#规则：布尔值：True -> 1,False -> 0
#     浮点数：直接取整，省略小数点后的内容
#     字符串：合法的整数字符串，直接转换为对应的数字
#            若不是合法的整数字符串，例如a='11.3',则报错ValueError:invalid literal for int() with base 10: '11.3'
#     对于其他不可转换为整型的对象，直接抛出异常 ValueError
# float()和int()基本一致，不同的是它会将对象转换为浮点数
#str()可以将对象转换为字符串，例如下面两句
b=456
print('hello'+str(b))
#结果是hello456
#bool()可以将对象转换为布尔值，任何对象都可以转换为布尔值
#规则： 对于所有表示空性的对象都会转换为False，其余的转换为True
#      表示空性的有：0，None,'',

a=True
print('a = ',a)
print('a的类型是',type(a))
# 结果是 a = True
# a的类型是 <class 'bool'>

a=True
#调用int()来将a转换为整型
#int()函数不会对原来的变量产生影响，他是对象转换为指定的类型并将其作为返回值返回
int(a)
#如果希望修改原来的变量，则需要对变量进行重新赋值
a=int(a)
print('a = ',a)
print('a的类型是',type(a))
# 结果是 a = 1
# a的类型是 <class 'int'>

a=11.6
a=int(a)
print('a = ',a)
print('a的类型是',type(a))
#a = 11
#a的类型是 <class 'int'>

a='11.3'
#a=int(a)
# print('a = ',a)
# print('a的类型是',type(a))
#不合法的整数字符串，会报错

a=None
#a=int(a)
# print('a = ',a)
# print('a的类型是',type(a))
#不可转换为整型的对象，抛出异常

a=False
a=float(a)
print('a = ',a)
print('a的类型是',type(a))
# a =  0.0
# a的类型是 <class 'float'>

a=123
a=str(a)
print('a = ',a)
print('a的类型是',type(a))
# a =  123
# a的类型是 <class 'str'>

a=-12
a=bool(a)
print('a = ',a)
print('a的类型是',type(a))
# a =  True
# a的类型是 <class 'bool'>

a=0
a=bool(a)
print('a = ',a)
print('a的类型是',type(a))
# a =  False
# a的类型是 <class 'bool'>

a=''
a=bool(a)
print('a = ',a)
print('a的类型是',type(a))
# a =  False
# a的类型是 <class 'bool'>

a=None
a=bool(a)
print('a = ',a)
print('a的类型是',type(a))
# a =  False
# a的类型是 <class 'bool'>

第五章 运算符（操作符）

运算符可以对一个值或多个值进行运算或各种操作，比如+，-，= 都属于运算符

运算符的分类：

1. 算术运算符
2. 赋值运算符
3. 比较运算符（关系运算符）
4. 逻辑运算符
5. 条件运算符（三元运算符）

算数运算符

#算术运算符
# + 加法运算符（若是两个字符串之间进行加法运算，则会进行拼串操作）
# - 减法运算符
# * 乘法运算符(如果将字符串和数字相乘，则会对字符串进行复制操作，将字符串重复指定次数）
# / 除法运算符，运算时结果总会返回一个浮点数，注意除数不能为0，否则报错
# // 整除，只会保留计算后的整数位,总会返回一个整数
# ** 幂运算，求一个值的几次幂
# % 取模，求得是余数

a = 10 + 5  # 计算
print('a=',a)
#结果是a= 15

a = 'hello' + '' + 'world' # 拼串
print('a=',a)
#结果是a= helloworld

a = 5 - True
print('a = ',a)
#结果是a=4

a = 10 / 3
print('a = ',a)
#结果是a =  3.3333333333333335
a = 10 // 3
print('a = ',a)
#结果是a = 3

a = 2 ** 2
print('a = ',a)
# 结果是 a = 4
a = 16 ** 0.5 #求16的平方根
print('a = ',a)
# 结果是 a = 4.0

赋值运算符

# 赋值运算符
#  =  可以将等号右侧的值赋值给等号左侧的变量
# +=   a += 5 相当于 a = a + 5
# -=
# *=
# **=
# /=
# //=
# %=
a = 10
a /= 25.0
print('a = ',a) # 在对浮点数做算术运算时，结果也会返回一个浮点数
#结果是 a =  0.4

关系运算符（比较运算符）

#关系运算符
#关系运算符用来比较两个值之间的关系，总会返回一个布尔值
#若关系成立，返回True,否则返回False
# > 比较左侧值是否大于右侧值
# >=
# <
# <=
# ==
# !=
#  相等和不等比较的是对象的值，而不是id
# is 比较两个对象是否是同一个对象，比较的是对象的id
# is not 比较两个对象是否不是同一个对象，比较的也是id

result = 10 > 20  #False
result = 30 > 20  #True
print('result = ',result)

result = 2 > True #True
# result = 2 > '1' TypeError: '>' not supported between instances of 'int' and 'str'
# 0032 > 0031
result = '2' > '1' # True
result = '2' > '11' #True

# 在python中可以对两个字符串进行大于（等于）或小于（等于）的运算
# 当对字符串进行比较时，实际上比较的是字符串的Unicode编码
# 比较两个字符串的Unicode编码时，是逐位比较的，第一位比较出来后就不比较了
# 利用该特性可以对字符串按照字母顺序进行排序，但对中文来说意义不大
# 注意：若不希望比较两个字符串的Unicode编码，则需要将其转换为数字再比较 print(int('2') > int('11'))
result = 'a' > 'b'  #False
result = 'ab' > 'b'  #False
print('result = ',result)

result = 1 == True # True
print('result = ',result)
print(id(1),id(True))
#结果是 result =  True
#2014290772208 140703201418088
result = 1 is True  #False
result = 1 is not True  #True
print('result = ',result)

逻辑运算符

# 逻辑运算符
# 逻辑运算符主要用来做一些逻辑判断
# not 逻辑非
#   not可以对符号右侧的值及逆行非运算
#        对于布尔值，非运算会对其进行取反操作，True变False，False变True
#        对于非布尔值，非运算会先将其转换为布尔值，然后再取反
# and 逻辑与
#    and可以对符号两侧的值进行与运算
#    只有在符号两侧的值都为True时，才会返回True,只要有一个False就返回False
#    与运算是找False的
#    python中的与运算是短路的与，如果第一个值为False,则不再看第二个值
# or 逻辑或
#   or可以对符号两侧的值进行或运算
#   或运算两个值中只要有一个True,就会返回True
#   或运算是找True的
#   python中的或运算是短路的或，如果第一个值为True,则不再看第二个值

#        对于布尔值，非运算会对其进行取反操作，True变False，False变True
a = True
a = not a # 对a进行非运算
print('a = ',a)
#结果是 a =  False

#        对于非布尔值，非运算会先将其转换为布尔值，然后再取反
a = 1
a = '' # a = True
a = not a #结果是 a =  False
print('a =',a)

#and 逻辑与
result = True and True # True
result = True and False #False
result = False and True #False
result = False and False #False
print(result)

#python中的与运算是短路的与，如果第一个值为False,则不再看第二个值
True and print('你猜我出来吗')# 第一个值是True,会看第二个值，所以print会执行
False and print('你猜我出来吗') # 第一个值是False，不输出

result = True or True # True
result = True or False #True
result = False or True #True
result = False or False #False
print(result)

True or print('你猜我出来吗')# 第一个值是True,所以print不会执行
False or print('你猜我出来吗') # 第一个值是False，继续看第二个，所以打印语句执行

#逻辑运算符可以连着使用
result = 1 < 2 < 3  #True  相当于 1 < 2 and 2 < 3
print(result)

result = 10 < 20 > 15 #True 是根据中间数进行比较
print(result)

非布尔值的与或运算

# 非布尔值的与或运算
#   当我们对非布尔值进行与或运算时，python会将其当作布尔值运算，最终会返回原值
# 与运算的规则
#     与运算是找False，如果第一个值是False,就不会看第二个值
#   或运算两个值中只要有一个True,就会返回True

# True and True
result = 1 and 2
print(result)  # 2

# True and False
result = 1 and 0
print(result)  # 0

result = 0 and 1
print(result)  # 0

result = 0 and None
print(result)  # 0

result = 0 or 3
print(result)  #3
result = 3 or 0
print(result)  #3

result = 3 or 2
print(result) # 3

条件运算符

#条件运算符（三元运算符）
#语法： 语句1 if 条件表达式 else 语句2
# 执行流程：
#   条件运算符在执行时，会先对条件表达式进行求值判断
#      如果判断结果为True,则执行语句1，并返回执行结果
#      如果判断结果为False，则执行语句2，并返回执行结果
print('你好') if True else print('hello')  #执行结果是你好
print('你好') if False else print('hello')  #执行结果是hello

运算符的优先级

#运算符的优先级
# 和数学中一样，在python运算中也有优先级，比如先乘除，后加减
# 运算符的优先级可以根据优先级的表格来查询，（官方文档）
#   在表格中位置越靠下的运算符优先级越高，优先级越高的越优先计算
#   如果优先级一样则自左向右计算

# 如果or的优先级高，或者两个运算符的优先级一样高
#   则需要先进行或运算，则运算结果是3
# 如果and的优先级高，则应该先计算与运算
#   则运算结果是1
a = 1 or 2 and 3  # 逻辑运算符低于算术运算符，所以先执行2 and 3 的操作，结果是3，再执行 1 or 3 ,结果为1
print(a)
print(a)

第六章 流程控制语句

if 语句

python代码在执行时是按照自上向下顺序执行的，通过流程空值语句，可以改变程序的执行顺序

流程控制语句分成两大类：条件判断语句和循环语句

# 条件判断语句（if 语句）
# 语法：if 条件表达式 :
#         代码块
# 执行流程： if 语句在执行时，会先对条件表达式进行求值判断
#  如果为True,则执行if后的语句
#  如果为False,则不执行
# 默认情况下，if语句只会控制紧随其后的那条语句，若希望if可以控制多条语句，可在if后跟着一个代码块
#代码块
#   代码块中保存着一组代码，同一个代码块中的代码，要么都执行要么都不执行
#   代码块就是一种代码分组的机制
#   如果要编写代码块，语句就不能跟随在:后边，而是要写在下一行
#   代码块以缩进开始，知道代码恢复到之前的缩进级别时结束
# 缩进有两种方式,一种是使用tab键，一种是使用空格（四个空格）
# python的官方文档中推荐使用空格来缩进
# python代码中使用的缩进方式必须统一

num = 10
if num > 10 : print ('num 比10大')
print('谁也管不了我')
#结果是 谁也管不了我

if True:
    print(123)
    print(345)
print('代码块之外的')
#结果是 123
#3435
#代码块之外的

if False:
    print(123)
    print(345)
print('代码块之外的')
# 结果是代码块之外的

# 可以使用逻辑运算符来连接多个条件
#    若希望所有条件同时满足，则需要使用and
#    若希望只有一个条件满足即可，需使用or
num = 18
if num > 10 and num < 20 :
    print('num 比10 大，num比20小')
if 10 < num > 20:
    print('num 比10 大，num比20小')

input 函数

# input()函数
# 用来获取用户的输入
# input()调用后，程序会立即暂停，等待用户输入
#   用户输入完内容后，点击回车后才会继续向下执行
#   用户输入完成后，其所输入的内容将会以返回值形式返回
#   注意：input()的返回值是一个字符串
#   input()可以设置为一个字符串作为参数，作为提示文字显示
# input()也可以用于暂时阻止程序结束

#练习：在命令行让用户输入一个用户名，获取用户输入，并进行判断
# 如果用户输入的用户名是admin，则显示欢迎管理员光临
# 如果用户输入的是其他的用户名，则什么也不做
name=input('请输入你的用户名，')
if name == 'admin' :
    print('欢迎'+name+'光临')

if-else语句

# if-else 语句
# 语法：
#   if 条件表达式:
#       代码块
#   else :
#       代码块

# 让用户在控制台中输入一个年龄
age = int(input('请输入您的年龄'))
# 如果用户的年龄大于18岁，显示你已经成年了
if age >= 18:
    print('你已经成年了')
else:
    print('你还未成年')

if-elif-else

# if-elif-else 语句
# 语法:
#  if 条件表达式：
#     代码块
#  elif 条件表达式:
#     代码块
#  elif 条件表达式:
#     代码块
#  else:
#     代码块

#注意逻辑关系,不要出现死代码
age = int(input('请输入你的年龄'))
if age >= 60:
    print('可以退休了')
elif age >= 30:
    print('到中年了')
elif age >=18:
    print('成年了')

age = int(input('请输入你的年龄'))
if age >= 18 and age < 30:
    print('成年了')
elif age >= 30 and age < 60 :
    print('到中年了')
elif age >= 60:
    print('可以退休了')

while 语句（循环语句）

# 循环语句
# 循环语句可以使指定的代码块重复指定的次数
# 循环语句分为两种，while循环 ， for 循环
# while循环
# 语法：
#  while 条件表达式：
#    代码块
#  else:
#    代码块
# 执行流程：
#  while语句在执行时，会先对while后得条件表达式进行求值判断，
#     如果判断结果为True,则执行循环体（代码块）
#     循环体执行完毕，继续对条件表达式进行求值判断，以此类推
#     直到判断结果为False，则循环终止，若循环有对应的else，则执行else后的代码块

# 条件表达式恒为true的循环语句，称为死循环
#while True:
#    print('hello')


#创建一个执行十次的循环
#循环的三个表达式
# 初始化表达式，初始化变量
i = 0
#条件表达式，用于设置循环执行条件
while  i < 10:
    #更新表达式，修改初始化变量值
    i += 1
    print(i)

break和continue

# break 可以用来立即退出循环语句（包括else）
# continue 可以跳过当前循环
# break 和 continue 都是只对离他最近的循环起作用
# pass是用来在判断或循环语句中占位的


# 创建一个5次的循环
i = 0
while i < 5 :
    if i == 3:
        break
    print(i)
    i += 1
else:
    print('循环结束')
# 0
# 1
# 2

i= 0
while i < 5:
    i += 1
    if i == 2:
        break
    print(i)
else:
    print('循环结束')
# 1

i= 0
while i < 5:
    i += 1
    if i == 2:
        continue
    print(i)
else:
    print('循环结束')
# 1
# 3
# 4
# 5
# 循环结束

i = 0
if i < 5:
    pass  #若这里不写代码块会报错，可先占位