Python基础

第1章 Python基础知识

一、 Python简介

1、 Python的起源

创始人：吉多范罗苏姆，1989年圣诞节前在社交平台发布

第一个解释器：1991年使用C语言编写，会自带C语言的异常处理和函数

2、python语言的特点

（1）简单

（2）面向对象

（3）开源、免费

3、学习的目的

Python是基础语法，主要是为了写自动化脚本打基础

4、常见的编程语言

C、C++、C#、JAVA、PHP、Python

编程：使用编程命令编写程序

程序：能让机器识别并玩一些任务的命令的集合

程序包含：算法+数据结构

5、Python 语言的版本

Python是一门跨平台的语言，可以在多个平台运行，用于人工智能较多

（1）目前最新版本：Python 3.8

（2）Python 3.X版本进行了语法的改革了，性能降低了（可接受范围内，比python 2.X 降低 10%）

print "hello world!" ---- print("hello world!")
x<>y ---- x!=y

6、Python的安装

install for all user --> C:\Program Files\Python38

注意安装的时候选择添加环境变量到path中，软件会自动把环境变量添加，如果没有勾选，需要手动配置环境变量。

7、Python的编译器（IDLE）

（1）python语言自带有编译器，但是不太好用，通常使用PyCharm进行程序编辑

（2）企业级的 IDLE ---- PyCharm

管理项目，区分颜色，代码跳级，调试等功能

专业版（收费）

社区版（免费）

8、Python的应用

（1）web 类的产品应用：知乎，豆瓣，火狐浏览器中一部分功能

（2）自动化脚本开发

（3）科学计算

（4）游戏的开发：腾讯的部分游戏

9、Pycharm工具介绍

（1）可以同时管理多个工程项目，但是不建议工程项目再创建工程项目；每个项目都是独立的，不能嵌套，

如果嵌套，会引发库文件混乱。

（2）常见的目录和文件： 工程项目

（3）常见索引：directory 、 python package、python file

（1）directory VS python package

directory : 一般文件，用来存放文件的，比如一些好看的图片，文本等等。
python package: python 包，用来编写代码的，会自带一个 _init_.py 文件，不要在该文件中编写代码，需要编码，可以在包下面 new 创建一个新的 python file 文件，注意同一个包下面的python file 文件不能重名

10、PyCharm运行程序

（1）首次执行代码文件：右键 run进行运行

（2）后面执行可以使用右上角的执行按钮+程序列表中选择的对应的程序执行

（3）快捷键执行：ctrl+shift + f10，执行的是当前打开的所在窗口的程序

二、Python的基本语法

（一）模块（modue）

模块是一个Python文件，以 .py 结尾，模块可以让你的Python代码有逻辑的进行组织，即对代码进行分门别类的管理（分层概念：比如创建包，然后再分模块：查看、查询、删除、编辑等等，后期的类的作用也是类似的），好管理，界面整洁，好理解。

（二）变量

1、概念

变量指的是程序执行过程中其值是可以改变的。在程序的编写过程中要定义变量。但是在其它语言中，定义变量之前要先申明变量的数据类型，再赋值

# C语言中定义变量i：
int i ;
i = 10;
# Python直接定义变量
i = 10
i = 1.1     # Python会自动根据数据类型进行赋值

2、定义变量

（1）语法

变量名 = 变量

（2）命名习惯

• 见其名知其意
• 大驼峰：即每个单词首字母都大写，例如：MyName
• 小驼峰：第二个（含）以后的单词首字母大写，例如：myName
• 下划线：my_name

（3）使用变量

num = 100
print(num)
# 将 = 右边的值给到左边的变量，不是相等的意思，Python中的相等符号是 ==

Eg1：把1~4分别赋值给a~d

a,b,c,d = 1,2,3,4 #把1~4分别复制给a~d
print(a,b,c,d) #分别输出a~d

Eg2： 描述x = y = z = 8的意义

x = y = z = 8   #把8复制给z，再把Z赋值给Y，最后赋值给X
print(x,y,z)    #输出x，y，z，可以输出三个值，三个值都是8

# 练习：使用Python 语言实现两个变量的值交换；如：a=10，b=20，输出a，b结果分别为20和10

# 其它语言思路，借助于第三个变量
a = 10
b = 20
c = a       
a = b
b = c
print(a,b)
# Python 语言的思路，变量直接给变量赋值
a = 10
b = 20
a,b = b,a       # 直接进行赋值交换：b赋值给a，a赋值给b
print(a,b)

（三）常量

不变的量，在Python中没有定义常量的方式的，通常是将变量名命名为大写字母表示常量；仅仅是一种表示方式和提示效果，表示这个值不会再变了，本质上还是变量，一个值不再发生变化的变量

A = 3		# 通过大写提示开发人员，这个A的值不能发生变化

（四）注释

1、作用

将程序注释起来，标记起来，就不会再运行了，所以注释也可以用在对代码的解释说明上。

2、分类

（1）单行注释：# 注释内容，快捷键ctrl + /注释掉光标所在行（多行注释直接选中要注释的行，按快捷键即可）

（2）多行注释： 三双引号""" 注释内容 """，或者三单引号''' 注释内容 '''

（五）导入

1、概念

Python中实现了各种函数，自带很多内置函数，如果想要使用这些函数，需要先进行导入

2、语法

# 导入的关键字 导入相应的模块
import  模块名  # 导入整个模块
from ... import # 从某个模块导入其子模块或者函数
import 模块名1,模块名2,模块名3  # 一次导入多个模块
from 模块  import  子模块1,子模块2,函数  # 一次导入多个子模块或函数

3、应用

import random       # 导入随机数模块
num = random.randint(1,100)     # 设置随机数取值范围
print(num)      # 输出随机数

（六）标识符

1、概念

标识符命名规则是Python中定义各种名字的时候的统一规范，具体如下：

2、命名规则

• 由数字、字母、下划线组成
• 不能数字开头
• 不能使用内置关键字
• 严格区分大小写

（七）缩进

1、概念

Python的灵魂，是Python中最有特色的地方（非常重要）

一般是4个空格，一个tab键，会让Python 代码显示的很整齐，默认就是4个空格，还可以进行设置。

2、应用

# python 语言中
a = 6
b = 3
if a>b:
    print(a)    
print(b)

3、程序执行的原则

逐行解释，按照控制条件进行输出，缩进关系会影响属于哪个条件体

a = 6
b = 3
if a>b:
    print(a)		# 这个a得是在a大于b条件下才能输出
print(b)		# 这个b不受到限制，会直接输出

多行语句： Python 中通常是一行写完一条语句；如果语句很长，无法一行写完，可以进行分行编写，需要使用 \ 实现多行编辑

a = 6
b = 3
c = a+\
  b
print(c)    # 输出9

特殊： {}、[]、() 中的多行语句，不需要使用 \ 换行

a = 6
b = 3
c=(a+
  b)
print(c)    # 输出9

第2章 输入和输出

一、输入

1、定义

在Python中，程序接收用户输入的数据的功能即是输入

2、语法

input("输入内容提示信息")

3、特点

• 当程序执行到input，等待用户输入，输入完成后程序才能继续向下执行
• 在Python中，input接受用户输入后，一般储存到变量，方便使用
• 在Python中，input会把接受到的任何用户输入的数据都当做字符串处理

num = input("请输入一个数字：")     # 请输入一个数字：100
print(num,type(num))        # 100 <class 'str'>

二、数据类型的转换

1、定义

在实际使用过程中，可以使用函数对输入的内容进行转换

2、转换数据类型的函数

3、应用实例

（1）整型转换

int(x,base=进制数)
# x：字符串或者数字
# base：进制数，默认是十进制

a = int()
print(a)        # 不传参时，输出结果为0
b = int(3.6)
print(b)        # 3，小数类型直接取整数部分输出
c = int("1010",base=2)
print(c)    # 10，如果是带参数base的话，1010要以字符串的形式进行输入，表示二进制
d = int("12",base=16)
print(d)    # 18，把十六进制数“12”转化为十进制数

（2）进制转换

print(hex(12))      # 0xc
print(oct(12))      # 0o14
print(bin(12))      # 0b1100

（3）获取ASCII码整型数值

print(ord("a"))     # 97
print(ord("b"))     # 98
print(ord("c"))     # 99

三、输出

1、定义

程序输出内容给用户

2、语法

print("引号内写入想要输出的内容")

四、格式化输出

1、%用法

2、format用法

（1）介绍

相对基本格式化输出采用‘%’的方法，format()功能更强大，该函数把字符串当成一个模板，通过传入的参数进行格式化，并且使用大括号‘{}’作为特殊字符代替‘%’

（2）位置匹配方法

• 不带编号，即“{}”
• 带数字编号，可调换顺序，即“{1}”、“{2}”
• 带关键字，即“{a}”、“{tom}”

（3）应用实例

# 不带编号
year = input("输入年：")
month = input("输入月：")
day = input("输入日：")
print("{}年{}月{}日".format(year,month,day))

# 带编号
year = input("输入年：")
month = input("输入月：")
day = input("输入日：")
print("{2}年{0}月{1}日".format(year,month,day))

第3章 Python中的运算符

一、算数运算符

+ 、-、*、/、%（求余数）、**（求幂次方）、//（取整运算）

Eg1：加减乘除运算

a = 1
b,c = 4,5
d = a+b+c
print(d)		# 10
d = d-c
print(d)		# 5

Eg2：除法运算

c = 10
c = c/3
print(c)   # 3.3333333333333335，不会舍弃小数部分

Eg3：取整运算

c = 10
c = c//3
print(c)    # 3，不是四舍五入，就是取整

Eg4：幂次方

e,f = 2,3
c=e**f
print(c)  #计算2的三次方

二、比较运算符

>、<、>=、<=、!=、== （运算结果 true 或者false）

注意：“ <> ”和 “ != ”是等价的；但是在3.0及以上版本中“ <> ”已经不能用了

Eg：数字类型赋值进行比较大小

a,b,c = 4,5,6
d = a>b
print(d)	# False
d = a<b
print(d)	# True
d = a!=b
print(d)	# True

Eg2：比较运算在if语句中的应用

a,b,c = 4,5,6
if a==b:
    print("a等于b")            #如果a等于b，则输出a等于b
else:
    print("a不等于b")          #否则输出a不等于b
if b<=c:
    print("b小于等于c")             #如果b小于等于c，则输出b小于等于c
elif b==c:
    print("b等于c")                 #如果b小于等于c，则输出b小于等于c
else:
    print("b大于c")                 #否则输出b大于c

Eg3：字符串比较大小的运算

d = "a"<"b"
print(d)     # 按照ASCII码表的对应十进制进行比较，输出结果为True
d = "abc"<"ac"
print(d)     # 按照从左向右第一个不相等的字符串进行比较（ASCII码表），输出结果为True
d = "a" +"b"
print(d)    # 字符串相加，实现的是字符拼接，输出结果：ab
d = "bef"+"acd"
print(d)     # 字符串相加，实现的是字符拼接，输出结果：befacd
d = "abc" + 3
print(d)        # 3是int整型，类型不一致不能相加，会报错
d = "abc"*3
print(d)           # 复制字符串3次，输出结果：abcabcabc

三、赋值运算符

= 、+= 、-=、*=、/=、//=、%=、**=

Eg1：单一的 = 为赋值的意思，就是将 = 右边的值赋给左边的变量

a,b =2,3
a +=b       # a = a+b
print(a)    # 输出结果：5
a -=b        # a = a-b
print(a)    # 输出结果：2
a **=b       # a = a的b次方
print(a)    # 输出结果：8
a %=b       # a = a/b 求余数，将余数赋值给a
print(a)    # 输出结果：2

四、逻辑运算符

**and、or、not **

1、and：与 &&

左右两个表达式，如果同时为真，则返回真，只要有一个为假，则返回假；（同真则真，有假则假）

print(2 and 3)	# 3
print(2 and 0)	# 0
print(0 and 3)	# 0
print(0 and 0)	# 0，Python中，0和null认为是假，其余都为真

解释： x and y ：如果x 为真，则返回 y 的结果；如果x 为假，则结束运算，返回x 的结果；

记忆：返回起决定性作用的那个值

2、or ： 或 ||

左右两个表达式，只要有一个为真，则返回真，必须两个都是假，才返回假；（有真则真，同假则假）

print(2 or 3)	# 2
print(2 or 0)	# 2
print(0 or 3)	# 3
print(0 or 0)	# 0

解释：x or y：如果 x为真，运算结束，返回x 的结果；如果 x 为假 ，返回 y 的结果；

记忆：返回起决定性作用的那个值

3、not：非

非真即为假，非假即为真

print(not 1)    # False
print(not 0)    # True

逻辑运算符的优先级：( )> not > and > or **，**除了0 和 null 以外，一切皆为真

注意：返回的一定是决定运算结果的那个值，同真则真就返回第二个真值，有假则假就返回第一个假的值

五、位运算符

与&、或|、异或^、取反~、左移<<、右移>>

1、与 &

同真则真，有假则假（1为真，0为假）

同是1为真，有0则为假

a = 10  # 10的二进制是1010
b = 11  # 11的二进制是1011
c = a & b  # 运算时，按照二进制，从右向左逐位运算，两个相同的位，同为1，运算结果为1；其它情况都是0
print(c)       # 二进制结果为1010，转化为十进制是10

2、或 |

有真则真，同假则假（1为真，0为假）

有1则为真，同0则为假

a =10  # 10的二进制是1010
b =11  # 11的二进制是1011
c = a | b   # 运算时，按照二进制，从右向左逐位运算，两位中有1取1，同0取0
print(c)   # 按照规则得出的二进制是1011，转化为十进制是11

3、亦或 ^

^{(shift+6)：**注意：}符号在Python中表示异或**

真为假，假为真

异或运算：如果a、b两个值不相同，则异或结果为1；如果a、b两个值相同，异或结果为0

e,f = 2,3
c=e^f
print(c)

# 2^3相当于：把2转化为二进制为10，3转化为二进制是11；

# 10异或11结果为：01

# 01转十进制结果为1

4、取反 ~

运算规则非常复杂，直接记口诀： 十进制数加1，然后取反（实际中用的很少，了解）

a = 8
c = ~a  # 8加上1 ，再取反，结果 -9
print(c)

5、左移 <<

向左移动几位，右边就补几个0

b = 11
c = b << 4   # 11的二进制是1011
# 严格意义上的二进制是32位：00000000000000000000000000001011
# 左移4位：表示最左边的4个数被挤掉，然后在右侧补足4个0，保证是32位00000000000000000000000010110000
# 10110000转化为十进制是176
print(c)

6、右移 >>

向右移动几位，就向左边补足几个 0

b = 11
c = b >> 2   # 11的二进制是1011
# 严格意义上的二进制是32位：00000000000000000000000000001011
# 右移2位：表示最右边的2个数被挤掉，然后在左侧补足2个0，保证是32位00000000000000000000000000000010
# 10转化为十进制是2
print(c)

六、成员运算符（Python 特有）

in：在；如果在，则返回true ，否则返回 false

not in：不在；如果不在，则返回 true ,否则返回 false

str1= "hello world!"    # 定义str1
if 'hee' in str1:       # 判断字符串关系
    print("在")
else:
    print("不在")

str1 = "abcdseadsf"
str2 ="a"
r = str2 in str1
print(r)                 # str2在str1里，输出结果为True

str1 = "abcdseadsf"
str2 ="aeeee"
r = str2 in str1
print(r)

list1 =[3,2,4,5,6]
r = 3 in list1
print(r)        # True
r = 3 not in list1
print(r)        # False

七、身份运算符

is：判断两个运算是否引用自同一个对象，是则返回 true，不是则返回 false

is not：判断两个运算是否引自同一个对象，是则返回 False，不是则返回 true

a = 10
b = 10
r = a is b  # 相当于id(a) == id(b)，获取该整形对应的唯一id
print(r)
print(id(a))
print(id(b))

第4章 Python的数据类型

一、数据类型一：数字

所有的数据都可以通过函数 type()去查询出对应的数据类型。

1、整型：int，就是数学中的整数

a = -1
b = 10
print(a,b,type(a),type(b))

结果：class后面显示数据类型

-1 10 <class 'int'> <class 'int'>

2、浮点型：float ，就是数学中的小数-->科学计数法：e 或者 E

num1 = 3.1415926
print(num1,type(num1))

num2 = 3.12e3
num3 = 3.14E3
print(num2,num3,type(num2),type(num3))

3、布尔型：bool，true ,false

num4 = True
num5 = False
print(num4,num5,type(num4),type(num5))

4、复数:complex

◆ 数学中，将 x = a+bi 称为复数，其中 i^2 =-1 ，a 称为实部，b 为虚部

◆ Python中，将 num = real + image

5、数字类型之间可以相互转换

\# 转整型，小数部分直接舍弃

num2 =int("888")
print(num2,type(num2))

888 <class 'int'>	# 字符串"888"转换成整型，再赋值给num2

\# 转浮点型

num33 = 9
print(float(num33))

9.0		#默认小数点后一位

\# 转布尔型 ， 0 转为 false ,其它全部转换为 true

num1 = int("888")
num2 = int("0")
num3 = str("0")
print(bool(num1),bool(num2),bool(num3))

True False True		# 布尔型中，整型0为空即为False，非空即为True

\# 转复数，需要传两个参数，其中第一个参数会变为实部，第二参数为虚部

num1 = int("8")
num2 = int("9")
print(complex(num1,num2))

(8+9j)

\# 复数是无法转为整数

二、数据类型二：字符串（重要）

1、认识字符串

字符串是Python中最常用的数据类型，我们一般使用引号来创建字符串

2、定义字符有三种方式

（1）单引号

（2）双引号

（3）三引号

a = 'hello world'
b = "abcdefg"
c = "hello" \
    "你好"
d = '''hello
你好'''
print(type(a))
print(type(b))
print(type(c))
print(type(d))

注意：控制台显示结果为<class 'str'>即数据类型为str(字符串)。

三种定义方式本质上没有任何区别，都是字符串，但是区别在于：

• 单引号，双引号只能引一行，三引号可以引多行
• 单引号，双引号不能引自己，如果字符串中有单引号，必须使用双引号；如果有双引号，必须使用单引号

思考：如何创建一个字符串I'm Tom

a = "I'm Tom"
b = 'I\'m Tom'		# 使用\作为转义符
print(a,type(a))
print(b,type(b))

3、常见到的转义符使用方法

• \n：回车换行

print("abc\ndef")

abc
def

• \b：退格键

print("滚蛋\b")		# 最后一个字符会被删除

• \r：将光标移动到首位，用户后面的内容替换

print("你吃\r屎")		# 光标移动到首位，\r后的内容替换掉\r前的内容

• \t：制表符，tab键，补全4个空格

print("hello\tworld")

\# 取消转义：在转义内容前加r

str1 =r'我是\b狗蛋\n喜欢学\rPython\t哈哈哈' # 方法一：最前面加 r，都是作为普通字符输出
print(str1)
str2='我是\\b狗蛋\\n喜欢学\\rPython\\t哈哈哈' # 方法二：二次转义， '\'作为普通字符输出
print(str2)

4、字符串的输出

（1）普通输出：使用Python的内置函数print()进行输出

str1='今天周五了'
str2='明天可以休息了'
print(str1,str2)		# str1、str2以逗号隔开，是基本输出格式

print(str1,str2*3)		# str3是复制字符串，str1和str2是独立显示，空格间隔；str2*3中间无空格

print(str1+str2*3)     # str1+str*3表示：把字符串1和复制的字符串连接在一起显示

print(str1+str2+str(3))      # 两个字符串连接显示，3是具体数字，使用 str（）转换为字符串拼接在后面

今天周五了 明天可以休息了
今天周五了 明天可以休息了明天可以休息了明天可以休息了
今天周五了明天可以休息了明天可以休息了明天可以休息了
今天周五了明天可以休息了3

（2）字符串的格式化输出：%

格式：[name] [flag] [width] [.] [precision]type

• name：可以为空
• flag：标记限定位

• \+：右对齐，默认

• ：左对齐

• \# ：将数字的进制显示出来
• 0：如果宽度不够，使用0补充

• width：指定的宽度，例如 50
• [.]：小数点
• precision：小数点后面的位数
• type：类型

• c：字符，按照ASCII码转换
• d/i：十进制整数
• o：八进制整数
• x：十六进制
• f：浮点型
• e：科学计数法
• g：根据数字自动转换
• s：字符串
• %：输出%

（3）使用方式

https://www.jb51.net/article/124166.htm

<1> 直接使用占位符

print ('%s+%d' %('abc', 123)) 		# abc+123
print ('%o' %10) 		# 八进制输出，10的八进制是12

print ('%s+%05d' % ('abc', 123)) # abc+00123,为%d指定长度，%05d，如果数字小于5位会在左边补0，大于指定长度时不受此影响
print ('%03X' % 10) 	# 00A，10的十六进制是A
print ('%.3e' % 123456789) 	# 1.235e+08 保留3位小数的科学技术法

<2> 使用format函数

print ('{0}{1}{2}{3}'.format('a', 'b', 'c', 123))       # abc123
print ('{},{},{}'.format('a', 'b', 'c'))        # abc
print ('{2},{1},{0}'.format('a', 'b', 'c'))     # c, b, a
print ('{2},{1},{0}'.format(*'abc'))        # c, b, a
print ('{0}{1}{0}'.format('abra', 'cad'))       # abracadabra

（4）应用实例

\# 进制转换

print(66)		# 输出66为整型
print("66")		# 输出66为字符串
print("%c"%66)    # 输出的是ASCII中66所对应的字符B
print("%d"%66)       # 66默认就是十进制
print("%o"%66)       # 66的八进制是102
print("%x"%66)    # 66的十六进制是42
print("%c\t%d\t%o\t%x"%(66,67,68,69))      # 对应格式输出

\# 整型和浮点型的转换

print(66)
print("%f"%66)    # 浮点型默认输出小数点后6位
print("%f"%3.14)
print("%d"%3.914)      # 取十进制数，直接舍去小数部分 
print("%e"%356345634563)        # 科学计数法输出
print("%g,%g,%g"%(66,3.3456345645746,6.78))     # 根据字符自动转换
print("%.3f"%3.456553)  # 设置小数点为3位，多余的按照四舍五入法则进行取舍
print("%.4f"%3.14)      # 设置小数点为4位，长度不够用0填充

\# 标记限定位之 + - 的设置

print("aabbccddee")
print("%20s"%"aabbccdd")       # +：默认是右对齐，加号可以省略
print("%+20s"%"aabbccdd")      # +：默认是左对齐，20是指宽度
print("%-15s"%"aabbccdd")      # -：默认是左对齐，15是指宽度

\# 标记限定位 # 和 0 ,宽度设置

print("%x"%66)      # 将66以十六进制表示出来
print("%0#20o"%66)  # 将66以八进制表示，并补全长度到20位
print("%0#20x"%66)  # 将66以十六进制表示，并补全长度到20位
print("%0#20d"%66)  # 将66以十进制表示，并补全长度到20位

42
0o000000000000000102
0x000000000000000042
00000000000000000066

5、字符串的访问

（1）索引值访问

在Python中，没有单个字符的数据类型，即使是一个字母也是被当做字符串，假设如果想要获取字符串中某个字母，必须通过索引值来访问。索引值从0开始，按照位置依次递增。（位值）

str1 = "hello world!"
print(str1[6],type(str1))	# 索引值从0开始，空格也占用一个位置
print(str1[12])  	# string index out of range 超出范围，会报错

（2）切片访问：获取字符串中的一部分内容。可以从左向右，也可以从右向左

格式：[start:scan]

• start：从哪一位开始，起始位置，按照索引值来计算
• end：到哪一个位置结束，结束位置，按照索引值计算

• 原则：左闭右开（包含左边，不包含右边，针对的是start，即每次都包含开始的位置）

• scan：步长，每几位取一个，默认1

name = "abcdefg"
print(name[2:5:1]) # cde，从索引值2获取到索引值5，但是不取5，步长为1
print(name[2:5]) # cde，从索引值2获取到索引值5，但是不取5，（默认步长为1）
print(name[:5]) # abcde，从最开始获取到索引值为5，取不到5
print(name[1:]) # bcdefg，从索引值1开始，获取到最后一位
print(name[:]) # abcdefg，访问所有的字符串，步长为默认步长为1
print(name[::2]) # aceg，访问所有的字符串，步长为2
print(name[:-1]) # abcdef, 从首位开始访问，负1表示访问到倒数第1个数据
print(name[-4:-1]) # def，-4的负号表示从倒数第4位开始访问，访问结束到倒数第一位（左开右闭原则）
print(name[::-1]) # 步长为负表示从右向左访问
print(name[4:2:-1]) # 从右向左访问，4取不到

\# 练习：用户输入手机号码，将中间四位要掩码显示出来

phone_num=input("请输入手机号：")
print(phone_num[:3]+"****"+phone_num[7:])      # 字符串相加即为字符串拼接

6、字符串中的内置函数

★ 查找

（1）find

在字符串中找子字符串，如果能找到，则返回第一个匹配的字母的索引值；如果找不到，则返回的是 -1

格式： str1.find(str2,start,end)

• str1：在哪里找，查询的范围
• str2：找什么，找的对象
• start：从哪里开始
• end：到哪里结束，左闭右开原则

str1 = 'hello ,my name is hanmeimei ,nice to meet you ,hanmeimei'
result= str1.find('hanmeimei',0,200)
str_n = str1.find('nc')
print(result)
# 输出的结果为18，意思是：查找的子字符串首位在母字符串中的索引值位置
print(str_n)	# 查找不到该字符串，输出结果为-1（整型）

（2）index

检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置索引值，否则则报异常

格式：str1.index(str2, start,end)

str1：在哪里找，查询的范围

str2：找什么，找的对象

start：从哪里开始

end：到哪里结束，左闭右开原则

mystr = "hello world and itcast and itheima and Python"
print(mystr.index('and')) # 12
print(mystr.index('and', 15, 30)) # 23
print(mystr.index('ands')) # 报错

（3）count

在字符串中统计子字符串出现的次数，如果能找到，则返回统计次数；如果不能找到，则返回0

格式： str1.count(str2,start,end)

• str1：在哪里找，查询的范围
• str2：找什么，找的对象
• start：从哪里开始
• end：到哪里结束，左闭右开原则

str1 = 'hello ,my name is hanmeimei ,nice to meet you,hanmeimei'
result= str1.count('hanmeimei',0,200)
print(result)	# 输出结果为2,不输入范围默认是全部查询

（4）其他查询函数

rfind

和find()功能相同，但查找方向为右侧开始

rindex

和index()功能相同，但查找方向为右侧开始

★★ 修改

（1）replace

替换字符串中原有的子字符串，替换完成后，会生成一个新的字符串

格式： str1.replace(old,new,num)

• str1：在哪个字符串中操作
• old：原来的字符串
• new：需要替换成什么的新字符串
• num：替换的次数

str1 = 'hello ,my name is hanmeimei ,nice to meet you,hanmeimei'
result= str1.replace('hanmeimei','xiaohong',2)
print(result)
# hello ,my name is xiaohong ,nice to meet you,xiaohong

思考

eg1：如果需要删除'hanmeimei':，怎么操作？

str1 = 'hello ,my name is hanmeimei ,nice to meet you,hanmeimei'
result= str1.replace('hanmeimei','',2)
print(result)

eg2：手机号掩码显示，replace 替换

phone_num=input("请输入手机号：")
result= phone_num.replace(phone_num[3:7],"****",1)
print(result)

（2）split

将字符串按照指定的字符串格式进行分隔，分隔成一个列表

格式： str1.split(str2,num)

• str1：在哪个字符串中操作
• str2：指定的字符串，如果不指定，默认使用空格分隔
• num：分隔的次数

str1 = 'hello,my name is liming,nice to meet you,xiaohong'
result= str1.split('l',2)
print(result)
# ['he', '', 'o,my name is liming,nice to meet you,xiaohong']

str1 = 'hello,my name is liming,nice to meet you,xiaohong'
result= str1.split()
print(result)
# 如果不指定，会默认用空格进行分割

（3）join

用一个字符或子串合并字符串，即是将多个字符串合并为一个新的字符串

格式：str1.join[字符串组成的列表]

• str1：要合并的字符串

str1 = '_'
list1 = ['好', '好', '学', '习']
result1 = str1.join(list1)
print(result1)		# 好_好_学_习

str2 = ' '
t1 = ('天', '天', '向', '上')
result2 = str2.join(t1)
print(result2)		# 天 天 向 上

list1 = ['好', '好', '学', '习']
t1 = ('天', '天', '向', '上')
print('_'.join(list1))		# 好_好_学_习
print(' '.join(t1))		# 天 天 向 上

（4）strip

删除字符串中首尾两边指定的字符串

格式：str1.strip(str2)

• str1：在哪个字符串中操作
• str2：指定删除的子字符串，如果不指定，默认使用空格

str1 = '    $$$      hello ,my name is liming!!!!!!!'
result= str1.strip()	# 不指定默认删除字符串开头的空格
print(result)		
result1=str1.strip(" $").strip("!")		# 删除字符串首位的$和空格及尾部的！
print(result1)
result2=str1.strip().strip("!")		# 删除字符串开头的空格和尾部的！
print(result2)

$$$      hello ,my name is liming!!!!!!!
hello ,my name is liming
$$$      hello ,my name is liming

补充：

lstrip()：删除字符串左侧空白字符

rstrip()：删除字符串右侧空白字符

str1 = "    好好学习"
str2 = "天天向上    "
print(str1.lstrip())
print(str1.rstrip())
# 好好学习
#    好好学习

（5）字符串大小写转换

① capitalize()：将字符串第一个字符转换成大写

mystr = "hello world"
print(mystr.capitalize())		# Hello world

注意：capitalize()函数转换后，只字符串第一个字符大写，其他的字符全都小写

② title()：将字符串每个单词首字母转换成大写

mystr = "hello world"
print(mystr.title())		# Hello World

③ lower()：将字符串中大写转小写

str1 = "HELLO WORLD"
print(str1.lower())		# hello world

④ upper()：将字符串中小写转大写

str2 = "hello world"
print(str1.upper())		# HELLO WORLD

（6）字符串填充排布函数

① ljust()

返回一个原字符串左对齐，并使用空格填充至指定长度形成一个新字符串。如果指定的长度小于原字符串的长度则返回原字符串

格式：str.ljust(width[, fillchar])

• width：长度
• fillchar：用来填充的字符串

② rjust()

返回一个原字符串右对齐，并使用空格填充至指定长度形成一个新字符串。如果指定的长度小于字符串的长度则返回原字符串

格式：str.rjust(width[, fillchar])

• width：长度
• fillchar：用来填充的字符串

str1 = "HELLO WORLD"
print(str1.ljust(15,'x'))		# HELLO WORLDxxxx

str2 = "hello world"
print(str1.rjust(15,'+'))		# ++++HELLO WORLD

③ center()

返回一个原字符串居中对齐，并使用指定字符(默认空格)填充至对应长度形成一个新字符串，语法和ljust()相同

i = 0
while i < 4:
    i += 1
    str3 = "* "*i
    print(str3.center(8))

★★★ 判断

所谓判断即是判断真假，返回的结果是布尔型数据类型：True 或 False

（1）startswith()

检查字符串是否是以指定子串开头，是则返回 True，否则返回 False。如果设置开始和结束位置索引，则在指定范围内检查

格式：str1.startswith(str2,start,end)

• str1：在哪个字符串中查询
• str2：查找的字符串
• start：从哪里开始
• end：到哪里结束，左闭右开原则

mystr = "hello world!"
# 结果：True
print(mystr.startswith('hello'))
# 结果False
print(mystr.startswith('hello', 5, 20))

（2）endswith()

检查字符串是否是以指定子串结尾，是则返回 True，否则返回 False。如果设置开始和结束位置索引值，则在指定范围内检查

格式：endswith()

• str1：在哪个字符串中查询
• str2：查找的字符串
• start：从哪里开始
• end：到哪里结束，左闭右开原则

mystr = "hello world!"
print(mystr.endswith('world!'))		# True
print(mystr.endswith('world', 5, 20))	# False

（3）isalpha()

如果字符串至少有一个字符并且所有字符都是字母则返回True，否则返回 False

mystr1 = 'hello'
mystr2 = 'hello12345'
print(mystr1.isalpha())		# True
print(mystr2.isalpha())		# False

（4）isdigit()

如果字符串只包含数字则返回True否则返回False

mystr1 = 'aaa12345'
mystr2 = '12345'
print(mystr1.isdigit())		# True
print(mystr2.isdigit())		# False

（5）isalnum()

如果字符串至少有一个字符并且所有字符都是字母或数字则返回True，否则返回 False

mystr1 = 'aaa12345'
mystr2 = '12345-'
# 结果：True
print(mystr1.isalnum())		# True
# 结果：False
print(mystr2.isalnum())		# False

（6）isspace()

如果字符串中只包含空白，则返回True，否则返回 False

mystr1 = '1 2 3 4 5'
mystr2 = ' '
# 结果：False
print(mystr1.isspace())		# True
# 结果：True
print(mystr2.isspace())		# False

（7）islower（）、isupper（）、istitle()

s = 'abc c'
if s.islower():
    print("全是小写")
c = 'ABCD'
if c.isupper():
    print("全是大写")
v = 'A Big Cat'
if v.istitle():
    print("只有首字母大写且不为空")
vc = 'AcG Big Cat'
if vc.istitle():
    print("首字母大写")

7、字符串的运算

\+：将多个字符进行连接

\*：将字符串进行复制

in：判断子字符串是否在原字符串内

str1 = 'hello world!'
if 'hehe' in str1:
    print("在")
else:
    print("不在")

三、数据类型三：列表

1、列表的概念

列表是一种数据类型，用于存储数据，可以看做是一个容器，所以列表中可以存放多个数据，而且数据之间没有关系，并且数据可以是任意类型

2、定义列表

用中括号[]来定义列表，列表中的每个组成部分叫做元素，元素和元素之间用逗号，间隔

[数据1, 数据2, 数据3, 数据4......]

举例

list1 = []
print(list1,type(list1))
list2 =[3,3.5,223,True,4+5J,'JAVA',[1,2,3]]
print(list2,type(list2))

[] <class 'list'>
[3, 3.5, 223, True, (4+5j), 'JAVA', [1, 2, 3]] <class 'list'>

3、访问列表的元素：

通过索引问值访问，从0开始，按照位置从左依次递增，一个元素一个索引值，索引值不要超出范围

list1 = [1,"*",3.14,True]
print(list1[2])		# 3.14
print(list1[4])		# 左闭右开原则，所以4取不到，超过范围就会报错

4、列表的基本操作：（增、删、改、查）

（1）增：给列表增加元素

append():在列表的末端追加元素

语法：列表序列.append():

list2 =[[1,2,3],3,3.5,223,True,4+5J,'JAVA',]
list2.append('apple')
print(list2)

insert():在列表指定的位置添加元素，指定的位置按照索引值指定

语法：列表序列.extend():

list2 =[[1,2,3],3,3.5,223,True,4+5J,'JAVA',]
list2.insert(3,'False')   # 'False' 是字符串
print(list2)

extend():可以将两个列表中的元素合并到一个列表中

list1 = [1,2,3,4]
list2 = ['a','b','c']
print(list1+list2) # 列表 + 运算
list1.extend(list2)
print(list1)

# 执行结果：
[1, 2, 3, 4, 'a', 'b', 'c']
[1, 2, 3, 4, 'a', 'b', 'c']

（2）删：删除列表中元素

del: 由Python提供的删除方法，是python的关键字

list1 = [1,2,3,4]
del list1[1]		# 按照索引值进行删除
print(list1)

remove():删除列表中指定的某一个元素，可以通过元素的值或者是列表上的索引值来指定，参数不能为空

# 按照元素的值来删除
list2 = ['a','ab',3,[2,'cd']]
list2.remove([2,'cd'])		# remove后直接跟要删除的内容
print(list2)
# 按照列表的索引值进行删除
list2 = ['a','ab',3,[2,'cd']]
list2.remove(list2[0])		# remove后跟列表的索引值进行删除
print(list2)

['a', 'ab', 3]
['ab', 3, [2, 'cd']]

pop():删除列表中的指定元素，用索引值指定，参数可以为空，为空时删除的是列表最末端的元素

list2 = ['a','ab',3,[2,'cd']]
list2.pop(1)		# pop后只能跟索引值
print(list2)

['a', 3, [2, 'cd']]

clear(): 删除列表中的所有元素，最后变成一个空列表

list3 = ['a','ab',3,[2,'cd']]
list3.clear()
print(list3)

（3）改：修改列表中的元素

原理：通过索引值定位到某一个元素后直接赋值

# 将列表中的True替换成False
list2 =[[1,2,3],3,3.5,223,True,4+5J,'JAVA']
list2[4] = False		
print(list2)

[[1, 2, 3], 3, 3.5, 223, False, (4+5j), 'JAVA']

（4）查：在列表中查询元素in

list2 =[[1,2,3],3,3.5,223,True,4+5J,'JAVA']
if 'java' in list2:
    print("在")
else:
    print("不在")

（5）列表的其他操作

reverse(): 将列表中的所有元素倒序排

list2 =[[1,2,3],3,3.5,223,True,4+5J,'JAVA']
list2.reverse()
print(list2)

['JAVA', (4+5j), True, 223, 3.5, 3, [1, 2, 3]]

sort():将列表中的元素进行排序，默认是从小到大（升序），要求元素必须是同一个数据类型

list2 = [3,1,5,9,11,2,4]
list2.sort()
print(list2)

[1, 2, 3, 4, 5, 9, 11]

思考：将列表中的元素从大往小排序

# 方法1：
list2 = [3,1,5,9,11,2,4]
list2.sort()
list2.reverse()
print(list2) 
# 方法2：
list2 = [3,1,5,9,11,2,4]
list2.sort(reverse=True)    # sort() 函数不加参数默认升序，加 reverse=True 表示降序
print(list2)

max(): 取列表中的最大值，元素类型必须一样

min(): 取列表中的最小值，元素类型一样

len(): 获取元素列表中有多个元素数

list2 = [3,1,5,9,11,2,4]
print(max(list2),min(list2),len(list2))

（6）列表的嵌套

将列表作为一个元素放在列表中，访问元素的时候一定要搞清楚索引值

list2 =[3,5.6,[1,2,3,[1,4,True,7],0.5],3,3.5,223,True,4+5J,'JAVA']
print(list2[6])         # list2 的 true
print(list2[2][3][2])        # 子子列表中 true

四、数据类型四： 元组

1、元组的概念

一种数据类型，用于存储数据，是一种容器；在元组中可以存放多个数据，数据之间没有任何关系，可以是任意数据类型

2、元组和列表的区别

定义方法不一样：元组是不可变数据类型，不可以修改元组的信息

3、定义元组

() 小括号完成定义，空元组： ()

4、访问元组的元素

通过索引值来访问，从0开始，依次递增，不要超出范围

tup1 =()
print(tup1,type(tup1))
tup2 = (3,5.6,[1,2,3,[1,4,True,7],0.5],3,3.5,223,True,4+5J,'JAVA')
print(tup2,type(tup2))
print(tup2[2],type(tup2))

() <class 'tuple'>
(3, 5.6, [1, 2, 3, [1, 4, True, 7], 0.5], 3, 3.5, 223, True, (4+5j), 'JAVA') <class 'tuple'>
[1, 2, 3, [1, 4, True, 7], 0.5] <class 'tuple'>

5、元组的基本操作

（1）增：给元组增加元素，不可以！！！！

但是：如果元组中的元素是可变的数据类型，可以给元组的元素中继续增加元素；比如，元组中的元素是列表

tup2 = (3,5.6,[1,2,3,[1,4,True,7],0.5],3,3.5,223,True,4+5J,'JAVA')
tup2[2].append(True)
print(tup2)		# 在索引值为2的列表中添加元素

（2）删：删除元组中的元素，不可以！！！！

但是，如果元组中的元素是可变的数据类型，可以给元组的元素中删除子元素；比如，元组中的元素是列表

tup2 = (3,5.6,[1,2,3,[1,4,True,7],0.5],3,3.5,223,True,4+5J,'JAVA')
tup2[2].remove(2)
print(tup2)

（3）改：修改元组中的元素，不可以！！！！

但是可以修改元组中可变的元素；比如元素是列表

tup2 = (3,5.6,[1,2,3,[1,4,True,7],0.5],3,3.5,223,True,4+5J,'JAVA')
tup2[2][3][2] = False
print(tup2)

(3, 5.6, [1, 2, 3, [1, 4, False, 7], 0.5], 3, 3.5, 223, True, (4+5j), 'JAVA')

（4）查：跟列表的查询元素的方法一致： in

tup2 = (3,5.6,[1,2,3,[1,4,True,7],0.5],3,3.5,223,True,4+5J,'JAVA')
if 3.5 in tup2:
    print("in")
else:
    print("not in")

6、元组的其他操作

（1）count(): 统计元组中元素出现的次数

tup1 = (3,2,5,7,5)
tup2 = (3,5.6,[1,2,3,[1,4,True,7],0.5],3,3.5,223,True,4+5J,'JAVA')
print(tup1.count(5))		# 2
print(tup2.count('JAVA'))	# 1

（2）sorted()：可以将元组中元素进行排序，元素的数据类型必须一致

由Python提供的方法，需要将元素作为参数传入，排序后的结果为列表，原来的元组保持不变

tup1 = (3,2,5,7,5)
result=sorted(tup1)
print(result,type(result))

（3）max(): 取列表中的最大值，元素类型必须一样

（4）min(): 取列表中的最小值，元素类型一样

（5）len(): 获取元素列表中有多个元素数

7、字符串、列表、元组可以相互转换

（1）字符串使用 str 进行转换

（2）列表使用 list 进行转换

（3）元素使用 tuple 进行转换

\# 元组转换为列表和字符

tup1 = (3,12,-5,7,5)
print(tup1,type(tup1))
list1 = list(tup1)
print(list1,type(list1))
str1 = str(tup1)
print(str1,type(str1))

\# 列表转换为字符和元组

list1 = [[1,2,3],3,3.5,223,True,4+5J,'JAVA',]
str1 = str(list1)
print(str1)
tup1 = tuple(list1)
print(tup1)

\# 字符转换为列表和元组

str1 = "hello,world!"
list1 = list(str1)
print(list1)
tup1 = tuple(str1)
print(tup1)

五、数据类型五： 字典

1、字典概念

字典是一种数据类型，用于存储数据，是一种容器，可以存放多个数据，数据之间没有关系，可以是任意类型数据。

2、和列表的区别

（1）访问列表必须通过索引值来访问，但是字典不是，字典中的数据是无序的

（2）定义字典的方式不一样

3、字典的特点

给每个元素都单独起了名字，名称称为"键"，元素的内容称为"值"，每个元素包含两部分：键&值（键值对）

备注：键不可以重复，而值可以重复

4、定义字典

{} ,大括号，元素之间用 '',''间隔；键和值之间用 : 隔开，定义空字典: {}

dict1 = {}
print(dict1,type(dict1))
dict2={'name':'sunsun','age':35,'ssex':'女'}
print(dict2)

5、访问字典中的元素

不是通过索引值来访问，而是通过键来访问

dict2={'name':'sunsun','age':35,'ssex':'女'}
print(dict2['age'])		# 35

6、字典的基本操作

（1）增：给字典中添加元素，通过 键=值，键要求不能存在

dict2={'name':'sunsun','age':35,'ssex':'女'}
dict2['tel'] = '15391910654'
print(dict2)

（2）删：删除字典中的元素

del：Python提供

dict2={'name':'sunsun','age':35,'ssex':'女'}
print(dict2)
del dict2['age']
print(dict2)

{'name': 'sunsun', 'age': 35, 'ssex': '女'}
{'name': 'sunsun', 'ssex': '女'}

remove：不能使用

pop：通过键名来删除，键不可以为空

dict2={'name':'sunsun','age':35,'sex':'女'}
print(dict2)
dict2.pop('sex')
print(dict2)

{'name': 'sunsun', 'age': 35, 'sex': '女'}
{'name': 'sunsun', 'age': 35}

clear：清空字典元素，空字典

dict2={'name':'sunsun','age':35,'sex':'女'}
print(dict2)
dict2.clear()		# clear后为空
print(dict2)

{'name': 'sunsun', 'age': 35, 'sex': '女'}
{}

（3）改：修改字典中的元素，通过键 = 新值，键必须存在

dict2={'name':'sunsun','age':35,'sex':'女'}
print(dict2)
dict2['tel'] ='19987876654'
print(dict2)

{'name': 'sunsun', 'age': 35, 'sex': '女'}
{'name': 'sunsun', 'age': 35, 'sex': '女', 'tel': '19987876654'}

（4）查：查询字典中的信息： 键 、 值 、 元素

keys()：获取字典中的所有键

values()：获取字典中的所有值

items()：获取字典中的所有元素（键+值）

dict2={'name':'sunsun','age':35,'sex':'女'}
print(dict2.keys())
print(dict2.values())
print(dict2.items())

dict_keys(['name', 'age', 'sex'])
dict_values(['sunsun', 35, '女'])
dict_items([('name', 'sunsun'), ('age', 35), ('sex', '女')])

\# 获取字典中的所有键

dict2={'name':'sunsun','age':35,'sex':'女'}
for i in dict2.keys():
    print(i)
print(dict2.keys())

name
age
sex
dict_keys(['name', 'age', 'sex'])

\# 获取字典中的所有值

dict2={'name':'sunsun','age':35,'sex':'女'}
for j in dict2.values():
    print(j)
print(dict2.keys())

sunsun
35
女
dict_keys(['name', 'age', 'sex'])

\# 获取字典中的所有元素信息，格式化输出

dict2={'name':'sunsun','age':35,'sex':'女'}
for key,val in dict2.items():
    print("字典的键为%s,值为%s"%(key,val))

字典的键为name,值为sunsun
字典的键为age,值为35
字典的键为sex,值为女

7、字符串、列表、字典之间可以相互转换

\# 两个列表转换为字典

list1 =['k1','k2','k3']
list2 =['v1','v2','v3']
print(dict(zip(list1,list2)))

{'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}

\# 一个嵌套的列表转为一个字典

list3 =[['k1','k2'],['v1','v2']]
print(dict(list3))

{'k1': 'k2', 'v1': 'v2'}

\# 字典可以转换为列表

dict1 ={'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}
print(list(dict1.keys()))
print(list(dict1.values()))
print(list(dict1.items()))

['k1', 'k2', 'k3']
['v1', 'v2', 'v3']
[('k1', 'v1'), ('k2', 'v2'), ('k3', 'v3')]

六、数据类型六：集合

1、集合的概念

数据类型之一，可以存放数据的容器

2、和列表的区别

集合的元素是一个无序的不重复的序列。

3、定义集合

{} , 但是如果要，定义空集合 set()

set1 =set()
print(set1,type(set1))
set2 = {'java','c','php','python','c#'}
print(set2)

set() <class 'set'>
{'php', 'python', 'java', 'c', 'c#'}

4、访问集合中的元素

不可以访问，因为无序，没有规律

5、集合的基本操作

（1）增：给集合中增加元素

add(): 同一个元素加多了会去重

set2 = {'java','c','php','python','c#'}
set2.add('javascript')
set2.add('javascript')
print(set2)        # 重复添加2次，但是输出显示的是添加一次的内容

{'javascript', 'python', 'c', 'java', 'php', 'c#'}

（2）删：删除集合中的元素

remove():参数为具体的元素信息

clear():删除集合中所有元素

set2 = {'java','c','php','python','c#'}
set2.remove('java')
print(set2)
set2.clear()
print(set2)

{'php', 'c', 'python', 'c#'}
set()

（3）改：修改集合中的元素，删除原来的元素，再添加新的元素（原理），即删除 + 新增

# 集合中的将c修改为c++
set2 = {'java','c','php','python','c#'}
set2.remove('c')		
set2.add('c++')
print(set2)

{'java', 'php', 'c#', 'python', 'c++'}

（4）查：查询集合中的元素，只是查询出有哪些元素，不重复显示

# 判断php是否在集合中
set2 = {'java','c','php','python','c#'}
if 'php' in set2:
    print("在")
else:
    print("不在")

set2 = {'java','c','php','python','c#'}
for i in set2:
    print(i)       # 把集合中的元素都查询出来，放在 i 中，逐一输出

6、集合的其他操作

max(): 取列表中的最大值，元素类型必须一样

min(): 取列表中的最小值，元素类型一样

len()：获取元素列表中有多个元素数

7、集合的运算

&：求交集

|：求并集

- ：求差集

^：不同时存在的元素

set1 =set('abcdefg')
set2 =set('sdfasdf')
print(set1)
print(set2)
print(set1&set2)       # 输出两个集合中相同的元素
print(set1|set2)        # 输出两个集合中所有的元素，重复的只取一个
print(set1-set2)        # 把1集合中和2集合相同的元素去除并输出
print(set1^set2)        # 输出两个集合中不同时存在的元素

{'f', 'b', 'g', 'a', 'd', 'e', 'c'}
{'f', 'a', 'd', 's'}
{'f', 'a', 'd'}
{'f', 'b', 'g', 'a', 'd', 'e', 'c', 's'}
{'e', 'c', 'b', 'g'}
{'b', 'g', 'e', 'c', 's'}

备注：集合没有嵌套集合

第5章 Python流程控制语句

一、基本概念

1、流程控制语句

　　流程控制语句就是按照一定的步骤来实现某些功能的语句

　　python 中主要的流程控制语句：选择语句、条件表达式、循环语句、跳转语句、pass 语句

2、程序结构

（1）顺序结构：按照代码的顺序依次执行

（2）选择结构：根据条件表达式的结果选择执行不同的语句

　　通常使用 if 语句实现

（3）循环结构：在一定条件下反复执行某段程序的流程结构

二、if 语句

1、简单的if语句

语法：如果符合条件，则...

if 条件表达式:
    语句块

# 实例：输入一个比5大的数并输出
number = int(input("请输入number的值："))
if number > 5:
    print("number > 5")

# 执行结果:
# 请输入number的值：6
# number > 5

2、if...else 语句

语法：如果符合条件，则...，否则...

if 条件表达式:
    语句块1
else:
    语句块2

# 实例：输入英语成绩，判断成绩是否合格
score = int(input("请输入你英语成绩："))
if score >= 60:
    print("你的英语成绩合格")
else:
    print("你的英语成绩不合格")

# 执行结果:
# 请输入你英语成绩：56
# 你的英语成绩不合格

3、if...elif...else 语句

语法：如果符合条件，就...，否则，如果满足另一种条件，则...

if 条件表达式1:
    语句块1
elif 条件表达式2:
    语句块2
......
else:    #如果都不满足则执行语句块n
    语句块n

# 实例1：猜数游戏
number = 55
print("猜数字游戏！")
number_in = int(input("你猜的数字是："))
if number_in == number:
    print("你猜对了！")
elif number_in > number:
    print("你猜的数字大了")
else:
    print("你猜的数字小了")

# 执行结果：
# 猜数字游戏！
# 你猜的数字是：56
# 你猜的数字大了

# 实例2：折中算法
# 输入一个最大5位的正整数，判断这是几位数

num = int(input("please enter this number:"))
if num >= 1000:
    if num >= 10000:
        print("该数为5位数")
    else:
        print("该数为4位数")
else:
    if num >= 100:
        print("该数为3位数")
    elif num >= 10:
        print("该数为2位数")
    else:
        print("该数为1位数")

注意1：如果已经定义了一个布尔类型的变量 flag，推荐使用如下判断语句：

if flag:
if not flag:

　　注意2：判断变量是否等于数值时：

# 建议使用：
if 1 == a
# 不建议使用：if a == 1，容易错写为
if a = 1

4、if 语句的嵌套

语法：嵌套语法可以有多种结合，此处列举一列如下

if 条件表达式1:
        if 条件表达式2:
            语句块2
        else:
            语句块3
else:
    语句块1

# 实例：判断是否为酒后驾车
proof = int(input("请输入每100毫升血液的酒精含量："))
if proof < 20:
    print("您还不构成饮酒驾车，可以开车，但请注意安全！")
else:
    if 80 > proof >= 20:
        print("已经达到酒后驾驶标准，请不要开车！")
    else:
        print("您已经达到醉酒驾驶标准，千万不要开车！！！")
        
'''
执行结果：
请输入每100毫升血液的酒精含量：90
您已经达到醉酒驾驶标准，千万不要开车！！！
执行结果2：
为了您和家人的安全，严禁酒后驾车！
请输入每100毫升血液的酒精含量：19
您还不构成饮酒驾车，可以开车，但请注意安全！
'''

三、循环语句

1、while 循环

一直重复，直到条件不满足时停止，语法：

while 条件表达式:
    循环体

# 实例：while循环实现1+2+...+100
sum = 0
n = 0
while n <= 100:
    sum = sum + n
    n  += 1
print("1+2+...+100=",sum)

# 执行结果：
# 1+2+...+100= 5050

2、for 循环

一般重复一定次数，通常用于迭代、枚举或遍历，语法：

for 迭代变量 in 对象:
    循环体

# 实例：for循环实现1+2+...+100
sum = 0					#保存累加结果的变量
for i in range(101):		# range()函数实现数值循环：生成一系列连续整数
    sum += i            # 实现累加
print("1+2+...+100=",sum)

# 执行结果：1+2+...+100= 5050

range() 函数实现数值循环
　　　　主要作用：生成一系列连续整数

　　　　基本语法：range(start,end,stop)

　　　　　　start 指起始值(包括)、end结束值(不包括)、stop
# range()实例：
for i in range(1,10,2):    # 输出1,3,5,7,9（从1开始到10结束，隔2个）
    print(i,end=' ')       # range默认输出到多行，end=' '指以空格分隔

# 执行结果：
1 3 5 7 9

for循环除了可以循环数值，也可以遍历字符串

# 实例：for循环遍历字符串
string = "我可以的"
print(string)
for ch in string:
    print(ch)

'''
执行结果：
我可以的
我
可
以
的
'''

3、循环嵌套

# 语法1
while 条件表达式1:
    while 条件表达式2:
        循环体2
    循环体1

# 语法2
while 条件表达式:
    for 迭代变量 in 对象:
        循环体2
    循环体1

# 语法3
for 迭代变量 in 对象:
    while 条件表达式:
        循环体2
    循环体1

# 语法4,5......

# 实例：使用循环嵌套，输出99乘法表
for i in range(1,10):         # 控制行数
    for j in range(1,i+1):    # 输出与行数相等的列,range不包括结束值，所以i+1
        print(str(j)+"*"+str(i)+"="+str(j*i)+"\t",end='')    #\t：转义字符一个Tab键，end='':在一行输出
    print("")    #转行

'''
执行结果：
1*1=1	
1*2=2	2*2=4	
1*3=3	2*3=6	3*3=9	
1*4=4	2*4=8	3*4=12	4*4=16	
1*5=5	2*5=10	3*5=15	4*5=20	5*5=25	
1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	
1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49	
1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64	
1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81	
'''

4、跳转语句

（1）break 语句

直接跳出循环

# 实例：电影院座位五行七列，你的座位为第二行第三列，请找出你的座位
for row in range(1,5):
    print("当前所在排:",row)
    if row == 2:
        print("这是您座位所在排")
        for column in range(1,8):
            print("当前所在列:",column)
            if column == 3:
                print("这是您的座位")
                break
        break
'''
执行结果：
当前所在排: 1
当前所在排: 2
这是您座位所在排
当前所在列: 1
当前所在列: 2
当前所在列: 3
这是您的座位# 如果不使用break跳转语句跳出循环，会将所有排数都打印一遍
'''

（2）continue 语句

不能跳出整个语句，只能退出本次循环，提前进入下次循环

# 实例：逢七过游戏(叫数游戏：遇到七的倍数和以七结尾的数过)
total = 99    # 假定99次都过
for number in range(1,100):    # 从1循环到99
    if number % 7 == 0:    # 是七的倍数
        continue           # 继续下一次叫数
    else:
        string = str(number)
        if string.endswith('7'):    # 判断是否以七结尾
            continue       # 继续下一次循环
    total -= 1    # 可过次数-1
print("从1到99可以过",total,"次")

# 执行结果：
# 从1到99可以过 22 次

（3）pass 语句

表示空语句，不做任何事情，起占位作用

# 实例：输出1-10之间的偶数，不是偶数的先使用pass空语句占位
for i in range(1,11):
    if i % 2 == 0:
        print(i,end=' ')    #输出1-10之间的偶数，中间使用空格隔开
    else:
        pass    #不是偶数的先占位

# 执行结果：
# 2 4 6 8 10

5、while...else...

循环可以和else配合使用，else下方缩进的代码指的是当循环正常结束之后要执行的代码

while 条件:
    条件成⽴立重复执⾏行行的代码
else:
    循环正常结束之后要执⾏行行的代码

i = 1
result= 0
while i <= 100:
    result += i
    i += 1
    break
else:
    print("累加结果是:",result)
# break终止循环，循环不是正常结束的，所以else后的代码不会只执行，故输出内容为空

i = 1
result= 0
while i <= 100:
    result += i
    i += 1
    continue
else:
    print("累加结果是:",result)
# continue只是停止了一次循环，循环还是可以正常结束，所以else后的代码可以执行

6、for...else...

for 临时变量 in 序列:
    重复执行的代码
    ...
else:
    循环正常结束之后要执⾏的代码

所谓else指的是循环正常结束之后要执行的代码，即如果是break终止循环的情况，else下方缩进 的代码将不执行

str1 = 'abcdefg'
for i in str1:
    if i == 'e':
        print('遇到e不打印')
        break
    print(i)
else:
    print('循环正常结束之后执行的代码')

7、算法入门

（1）打印九九乘法表

for i in range(1, 10):
    for j in range(1, i+1):
        print("{}*{}={}".format(j, i, j*i), end='\t')    #格式化字符串，后续篇幅讲解
    print("")
    
'''
# 执行结果  
1*1=1	
1*2=2	2*2=4	
1*3=3	2*3=6	3*3=9	
1*4=4	2*4=8	3*4=12	4*4=16	
1*5=5	2*5=10	3*5=15	4*5=20	5*5=25	
1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	
1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49	
1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64	
1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81	
'''

（2）打印菱形

# 分析：
   *       #3个空格 + 1个*号
  ***      #2个空格 + 3个*号
 *****     #1个空格 + 5个*号
*******    #0个空格 + 7个*号
 *****     #1个空格 + 5个*号
  ***      #2个空格 + 3个*号
   *       #3个空格 + 1个*号

n = 7    #定义菱形最长行*数
e = n//2
for i in range(-e, e+1):
    print("{}{}".format(abs(i)*" ", (n-(2*abs(i)))*"*"))

（3）打印100以内的斐波那契数列

# 打印100以内的斐波那契数列：1 1 2 3 5......
a1 = 1
a2 = 1
print(a2,end=' ')
print(a1,end=' ')
while True:
    a = a2 + a1
    if a > 100:
        break
        
    else:
        print(a,end=' ')
    a2 = a1
    a1 = a
# 执行结果
1 1 2 3 5 8 13 21 34 55 89

（4）求斐波那契数列的第101项

# 求斐波那契数列的第101项
a1 = 1
a2 = 1
count = 2

while True:
    a = a2 + a1
    if count == 100:
        print(a,end=' ')
        break
    count += 1
    a2 = a1
    a1 = a

# 执行结果：
573147844013817084101

（5）求20以内的所有质数

for i in range(2,20):
    count = 0
    for j in range(1,i):
        if i % j == 0:
            count += 1
    if count == 1:
        print(i,end=' ')

# 执行结果：2 3 5 7 11 13 17 19

第6章 函数

一、函数的定义和作用

1、定义

函数是一块可重用的程序语句，这块语句有个名字，然后可以在需要的时 候使用这个名字反复运行这个语句块

举例：print、input函数等

2、作用

（1）可以被反复调用，提升我们的代码效率以及降低我们代码维护成本

（2）功能的封装，降低学习成本，提升开发速度

二、函数的使用步骤

1、定义函数

def 函数名(参数):
    代码1
    代码2

注意：

• 代码整体缩进在def内
• 函数定义后不会自动执行
• 函数定义完成后，需要使用函数名来调用函数才能执行
• 函数可以无限次调用

2、调用函数

函数名(参数):

Eg：定义一个函数，实现两个数的加法运算

def sum(a,b):
    result = a + b
    print(result)
sum(2,3)

三、函数的参数

1、函数的形参

函数可以接收输入的值，通过在定义函数的时候指定参数来保存这些具体的值，这些参数称为形参

2、函数的实参

而参数中保存的值称为实参，如果需要指定多个形参，参数之间用逗号分隔

注意：

在定义函数过程中如果指定了参数，那么调用函数时一定要给所有的参数传递值，否则会报错

3、默认参数（缺省参数）

如果某一位置形参设置了默认参数，那么该位置之后的所有参数必须设置默认参数

def sum(a,b=10):		# 形参中包含一个默认参数，该参数在函数调用时不需要传入
    result = a + b
    print(result)
sum(2)		# 只传入一个参数就默认是参数a，输出结果为12
sum(2,4)		# 在有默认参数时，若调用是再次传参，则会以传入的参数执行程序，输出结果为6

4、关键参数

在调用函数时，还可以使用另外一种方式给函数传递值，即使用参数的名字（关键字）而不是位置，这被称为关键参数

def sum(a,b=10):
    result = a + b
    print(result)
sum(2,4)		# 位置传参，位置一一对应，不能调整顺序
sum(b=4,a=2)	# 关键字传参，不需要关注参数的顺序

四、函数的返回值

• return语句用来从一个函数返回，即跳出函数，也可以使用return从函数返回一个值，并且这个值可以赋给其他变量
• 如果return语句没有返回值，等价于return None，None表示没有值
• 如果函数中没有明确指定return语句，都在结尾暗含有return None语句
• 函数中可以出现多个return，但有且仅有一个return被执行

# 定义一个判断素数的函数
def sushu(a):
    for i in range(2,a):
        if a%i==0:
            print("%d不是素数"%a)
            return
    else:
        print("%d是素数"%a)
sushu(int(input("输入一个大于1的整数：")))

五、函数的嵌套调用

函数嵌套调用指的，一个函数里面又调用了一个函数

def testB():
    print('---- testB start----')
    print('这里是testB函数执行的代码......')
    print('---- testB end----')
def testA():
    print('---- testA start----')
    testB()
    print('---- testA end----')
testA()

# 执行结果
---- testA start----
---- testB start----
这里是testB函数执行的代码......
---- testB end----
---- testA end----

如果函数A中调用了另外一个函数B，那么先把函数B中的任务都执行完毕之后才会回到上次函数A执行的位置。

# 定义函数：判断三个数的大小关系（嵌套调用）
def max2(x, y):
    if x > y:
        return x
    else:
        return y
def max3(x, y, z):
    res1 = max2(x, y)
    res2 = max2(res1, z)
    return res2
print(max3(11, 199, 2))

六、变量作用域

1、局部变量

局部变量量是定义在函数体内部的变量，即只在函数体内部生效

def num():
    a = 100
    print(a)
num()		# 100
print(a)		# 报错：name 'a' is not defined

2、全局变量

全局变量量，指的是在函数体内、外都能生效的变量。

a = 100 # a被定义为全局变量 def num1(): print(a) num1() # 调用num1函数可以输出a def num2(): print(a) num2() # 调用num2函数也可以输出a print(a) # 不调用函数，也可以直接输出a

七、拆包和交换变量值

1、拆包

（1）拆包元祖

def return_num():
    return 100, 200
num1, num2 = return_num()
print(num1) # 100
print(num2) # 200

（2）拆包字典

dict1 = {'name': 'TOM', 'age': 18}
a, b = dict1
# 对字典进行拆包，取出来的是字典的key
print(a) # name
print(b) # age
print(dict1[a]) # TOM
print(dict1[b]) # 18

2、交换变量值

需求：求a = 10和b = 20，两个交换变量值

方法1：借助第三方变量

a = 10
b =20
# 1. 定义中间变量
c = 0
# 2. 将a的数据存储到c
c = a
# 3. 将b的数据20赋值到a，此时a = 20
a = b
# 4. 将之前c的数据10赋值到b，此时b = 10
b = c
print(a) # 20
print(b) # 10

方法2：多重复值

a, b = 1, 2
a, b = b, a
print(a) # 2
print(b) # 1

八、可变类型和不可变类型

依据：数据能否进行修改，数据可以直接进行修改的是可变类型，反之则是不可变类型

可变类型

• 列表
• 字典
• 集合

不可变类型

• 整型
• 浮点型
• 字符串
• 元祖

# int类型为不可变类型
a = 1
b = a
print(a) #  1
print(b) #  1
a = 2   # 给a重新赋值，但是b的值不会跟着改变
print(b) # 1,说明int类型为不可变类型
print(a)    # 2

# 2. 列表为可变类型
aa = [10, 20]
bb = aa
print(aa)   # [10, 20]
print(bb)   # [10, 20]
aa.append(30)   # 给aa列表追加元素，bb列表会跟着改变
print(bb) # [10, 20, 30], 列表为可变类型
print(aa) # [10, 20, 30]

九、lambda 表达式

1、应用场景

如果一个函数有一个返回值，并且只有一句代码，可以使用lambda简化

示例：计算a + b的值

# 自定义函数
def add(a, b):
    return a + b
result = add(1, 2)
print(result)
# lambda函数实现
print((lambda a, b: a + b)(1, 2))

2、语法

lambda 参数列表 ： 表达式

注意：

• lambda表达式的参数可有可无，函数的参数在lambda表达式中完全适用
• lambda函数能接收任何数量的参数，但只能返回⼀个表达式的值

def fn1():
    return 200
print(fn1)
print(fn1())
# lambda表达式
fn2 = lambda: 100
print(fn2)  # 直接打印lambda函数，输出的是它的内存地址
print(fn2())

3、参数类型

（1）无参数

print((lambda: 100))        # lambda函数可以无参数，但是要用（）占位，否则输出的是内存地址
print((lambda: 100)())      # 100

（2）一个参数

print((lambda a: a)("hello"))      # hello

（3）默认参数

print((lambda a, b, c=100: a + b + c)(10, 20))

（4）可变参数：**args

print((lambda *args: args)(10, 20, 30))		# (10, 20, 30)

（5）可变参数：**kwargs

print((lambda **kwargs: kwargs)(name='python', age=20))		# {'name': 'python', 'age': 20}

4、lambda函数的应用

（1）判断

print((lambda a, b: a if a > b else b)(1000, 500))

（2）列表数据按字典key的值排序

students = [
 {'name': 'TOM', 'age': 20},
 {'name': 'ROSE', 'age': 19},
 {'name': 'Jack', 'age': 22}
]
# 按name值升序排列
students.sort(key=lambda x: x['name'])
print(students)
# 按name值降序排列
students.sort(key=lambda x: x['name'], reverse=True)
print(students)
# 按age值升序排列
students.sort(key=lambda x: x['age'])
print(students)

十、高阶函数

把函数作为参数传入，这样的函数称为高阶函数

1、体验：一个函数完成计算任意两个数字的绝对值之和

在Python中，abs()函数可以完成对数字求绝对值的计算

print(abs(-10)) 	# 10

方法1：

def num_add(a,b):
    return abs(a) + abs(b)
result = num_add(-1,-9)
print(result)       # 10

方法2：

def num_add(a,b,f):
    return f(a) + f(b)
result = num_add(-1,-9,abs)
print(result)       # 10

注意：两种方法相比较，方法2的代码会更加简洁

2、内置高阶函数

（1）max()

map(func, lst)，将传⼊的函数变量func作用到lst变量的每个元素中，并将结果组成新的列表

需求：计算列表list1中每个序列中各个数字的2次方，并以列表类型输出

方法1：利用for循环实现

list1 = [1,2,3,4]
list2 = []
for i in list1:
    i **= 2
    list2.append(i)
print(list2)

方法2：利用内置高阶函数max()实现

list1 = [1, 2, 3, 4, 5]
def func(x):
    return x ** 2
result = map(func, list1)
print(result) 		# 内存地址，<map object at 0x00000118A5E07220>
print(list(result)) 		# [1, 4, 9, 16, 25]

（2）reduce()

reduce(func(x,y)，lst)，其中func必须有两个参数。每次func计算的结果继续和序列的下一个元素做累积计算

需求：计算列表list1中每个序列中各个数字的2次方，并以列表类型输出

import functools
list1 = [1, 2, 3, 4, 5]
def func(a, b):
 return a + b
result = functools.reduce(func, list1)
print(result) # 15

（3）filter()

filter(func, lst)函数用于过滤序列，过滤掉不符合条件的元素，返回一个filter对象，如果要转换为列表，可以使用list() 来转换。

需求：输出自定义列表中的偶数

list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
def func(x):
    return x % 2 == 0
result = filter(func, list1)
print(result)   # <filter object at 0x000002450C565A60>
print(list(result))     # [2, 4, 6, 8, 10]