Anaconda安装Python解析器
Anaconda包括Conda、Python以及一大堆安装好的工具包，比如：numpy、pandas等；
Miniconda包括Conda、Python；
conda是一个开源的包、环境管理器，可以用于在同一个机器上安装不同版本的软件包及其依赖，并能够在不同的环境之间切换。
配置环境变量
作用：让系统自动识别解释器
打开开始菜单点击Anaconda Powershell Prompt, 分别输入 conda -V 和 python -V, 能出现版本号, 即为安装成功.
设置或更换Python解析器
Python注释的基本语法
单行和多行
# 单行注释内容
"""
多行注释内容
第一行
第二行
第三行
"""
'''
多行注释内容
第一行
第二行
第三行
'''
Ctrl + /斜杠快捷键
变量
那什么是变量呢？
① 变量是存储数据的容器
② 变量在程序运行过程中是可以发生改变的量
③ 变量存储的数据是临时的
基本语法
变量名称 = 变量的值
注：等号的两边都要保留一个空格，其实Python中建议符号的两边尽量都要保留一个空格
说明：在Python程序中，这个等号和日常生活中的等号不太一样，其有一个专业名词：赋值运算符，其读法：要从右向左读，把变量的值通过 = 赋值给左边的变量。
命名规则
标识符命名规则是Python中定义变量名称时一种命名规范，具体如下：
① 由数字、字母、下划线(_)组成
② 不能数字开头
③ 严格区分⼤小写
④ 不能使⽤内置关键字作为变量名称
help('keywords') #可以打印关键字
Here is a list of the Python keywords. Enter any keyword to get more help.
False class from or
None continue global pass
True def if raise
and del import return
as elif in try
assert else is while
async except lambda with
await finally nonlocal yield
break for not
变量的数据类型
面试题：请手写出Python中的7种数据类型？
答：数值类型、布尔类型、字符串类型、列表类型、元组类型、集合类型、字典类型
问题：如何判断一个变量到底是什么类型？
答：① 使用type(变量名称)方法，返回变量的数据类型 ② isinstance(变量名称,数据类型)，只能返回True或False（真的还是假的）
数值类型
数值类型就是我们日常生活中的数字，数字又分为两种形式：整数 与 小数（带小数点）
整数类型：int类型
小数类型：float类型
案例1：定义一个人的信息，姓名：Tom、年龄18岁
name = 'Tom'
age = 18
print(type(age))
案例2：定义一个超市收银系统，写入一个名称：大白菜，价格：3.5
name = '大白菜'
price = 3.5
print(type(price))
布尔类型
布尔类型是与逻辑相关一种数据类型，只有两个值：True（真）与False（假）
案例1：手工定义一个flag变量，其值为True
flag = True
print(flag)
print(type(flag))
字符串类型
在Python变量定义中，如果其赋值的内容是通过单引号或双引号引起来的内容就是字符串str类型。
msg = '这家伙很懒，什么都没有留下...'
print(type(msg))
其他类型(了解)
# 1、list列表类型
list1 = [10, 20, 30, 40]
print(type(list1))
# 2、tuple元组类型
tuple1 = (10, 20, 30, 40)
print(type(tuple1))
# 3、set集合类型：去重
set1 = {10, 20, 30}
print(type(set1))
# 4、dict字典类型：查询、搜索
dict1 = {'name':'itheima', 'age':18}
print(type(dict1))
Python的输入与输出【掌握】
输出
%格式常见形式如下：
| 格式符号 | 转换 |
|---|---|
| %s | 字符串 |
| %d | 有符号的十进制整数 |
| %f | 浮点数 |
| %c | 字符 |
| %u | 无符号十进制整数 |
| %o | 八进制整数 |
| %x | 十六进制整数（小写ox） |
| %X | 十六进制整数（大写OX） |
| %e | 科学计数法（小写’e’） |
| %E | 科学计数法（大写’E’） |
| %g | %f和%e的简写 |
| %G | %f和%E的简写 |
百分号格式化输出
title = '大白菜'
price = 3.5
# 格式化输出“今天蔬菜特价了，大白菜只要3.5元/斤。"
print("今天蔬菜特价了，%s只要%.2f元/斤。" % (title, price))
format方法格式化输出
name = '孙悟空'
mobile = '18878569090'
print("姓名：{}，联系方式：{}".format(name, mobile))
format方法简写形式格式化输出（推荐）
name = '孙悟空'
mobile = '18878569090'
print(f'姓名：{name}，联系方式：{mobile}')
转义字符
在字符串中，如果出现了\t和\n，其代表的含义就是两个转义字符
\t ：制表符，一个tab键（4个空格）的距离
\n ：换行符
案例：
print('*\t*\t*')
print('hello\nworld')
特别说明：默认情况下，每个print()方法执行完毕后，都会输出一个\n换行符。如果不想让print()方法换行，可以添加一个end参数
print('*', end='')
输入
记住：所有由input()方法获取的数据都是“字符串”类型
name = input('请输入您的姓名：')
age = input('请输入您的年龄：')
print(type(name)) # <class 'str'>
print(type(age)) # <class 'str'>
总结：
① input()可以用于接收由外部设备输入的信息，但是如果用户没有输入任何内容，则input()函数会中止当前代码的继续执行，处于等待状态，直到用户输入结束。
② 所有由input()方法获取的数据都是“字符串”类型
类型转换
| 函数 | 说明 |
|---|---|
| int(x) | 将x转换为一个整数 |
| float(x) | 将x转换为一个浮点数 |
| complex(real [,imag ]) | 创建一个复数，real为实部，imag为虚部 |
| str(x) | 将对象 x 转换为字符串 |
| repr(x) | 将对象 x 转换为表达式字符串 |
| eval(str) | 用来计算在字符串中的有效Python表达式,并返回一个对象 |
| tuple(s) | 将序列 s 转换为一个元组 |
| list(s) | 将序列 s 转换为一个列表 |
| chr(x) | 将一个整数转换为一个Unicode字符 |
| ord(x) | 将一个字符转换为它的ASCII整数值 |
| hex(x) | 将一个整数转换为一个十六进制字符串 |
| oct(x) | 将一个整数转换为一个八进制字符串 |
| bin(x) | 将一个整数转换为一个二进制字符串 |
案例2：多种数据类型转换
# 1、整型转浮点类型 int => float
num1 = 10
print(float(num1))
print(type(float(num1)))
print('-' * 20)
# 2、浮点类型转换为整型 float => int，浮点转整型，其小数点后的数据会丢失！！！
num2 = 18.88
print(int(num2))
print('-' * 20)
# 3、把字符串类型转换为整型或浮点类型
str1 = '20'
str2 = '10.88'
print(type(int(str1)))
print(type(float(str2)))
案例3：eval()方法的使用，把字符串中的数字转换为原数据类型
① 如果一个字符串 * 数字，代表对这个字符串进行复制操作
② 当float浮点类型转换为int整型时，其小数点后面的数据会丢失，一定要记住这个特性。
③ 字符串转数值类型，字符串中的数据必须是有意义的数值
price = input('请输入您购买商品的价格：')
print(eval(price))
print(type(eval(price)))
str1 = ‘10’ 经过eval(str1) 转换为int类型
str2 = ‘10.88’ 经过eval(str1) 转换为float类型
Python运算符【掌握】
算术运算符
所谓的算数运算符就是我们日常生活中的加减乘除等待。
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 加 | 1 + 1 输出结果为 2 |
| - | 减 | 1 - 1 输出结果为 0 |
| * | 乘 | 2 * 2 输出结果为 4 |
| / | 除 | 10 / 2 输出结果为 5 |
| // | 整除 | 9 // 4 输出结果为 2 |
| % | 取余（取模） | 9 % 4 输出结果为 1 |
| ** | 幂指数 | 2 ** 4 输出结果为 16，即2的4次方，2 * 2 * 2 * 2 |
| () | 小括号 | 小括号用来提高运算优先级，即 (1 + 2) * 3 输出结果为 9 |
案例1：了解一下算术运算符
num1 = 10
num2 = 2
# 四则运算 + - * /
print(f'加：{num1 + num2}')
print(f'减：{num1 - num2}')
print(f'乘：{num1 * num2}')
print(f'除：{num1 / num2}')
案例2：和其他编程语言不太相同的几个算术运算符
num1 = 20
num2 = 6
num3 = 5
# 1、整除
print(f'整除：{num1 // num2}')
# 2、求余数
print(f'余数：{num1 % num2}')
# 3、幂指数
print(f'幂指数：{num2 ** 3}')
# 4、圆括号
print(f'优先级：{(num1 + num2) * num3}')
赋值运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 赋值 | 将=右侧的结果赋值给等号左侧的变量 |
案例1：把某个值赋值给某个变量
num = 10
案例2：多个变量同时进行赋值操作
n = 5
f = 10.88
s = 'hello world'
简写为：
n, f, s = 5, 10.88, 'hello world'
print(n)
print(f)
print(s)
案例3：多个变量赋予相同的值
a = 10
b = 10
简写为：
a = b = 10
复合赋值运算符
复合赋值运算符 = 算术运算符 结合 赋值运算符
比较运算符
逻辑运算符
not就是取反，只有一个表达式
not 表达式，如果表达式为True，则not以后就返回False。反之，则返回True。
if选择判断结构【掌握】
if
【案例】
age = 18
if age >= 18:
print('满足18岁要求，可以正常上网')
if…else…
age = int(input('请输入您的年龄：'))
if age >= 18:
print('满足18岁要求，可以正常上网')
else:
print('不满足18岁要求，回家好好学习，天天向上')
if…elif…else多条件判断结构
# 1.获取用户输入的月份
month = int(input("请输入月份 (1-12): "))
# 2.判断季节
if 3 <= month <= 5:
season = "春季"
elif 6 <= month <= 8:
season = "夏季"
elif 9 <= month <= 11:
season = "秋季"
elif month in [1, 2, 12]:
season = "冬季"
else:
season = "无效的月份"
# 3.输出季节
print(f"该月份属于: {season}")
while循环基本语法及其应用
【案例】
# 1. 初始化计数器
i = 0
# 2. 编写循环条件（判断计数器是否达到了100）
while i < 5:
print('Hello World')
# 3. 在循环体内部更新计数器
i += 1
break关键字
场景一：如果吃的过程中，吃完第三个吃饱了，则不需要再吃第4个和第5个苹果，即是吃苹果的动作停止，这里就是break控制循环流程，即终止此循环。
# 初始化计数器
i = 1
# 编写循环条件
while i <= 5:
# 当变量i 4的时候，终止循环
if i 4:
print('我已经吃饱了，实在吃不下了...')
break
# 正在吃第几个苹果
print(f'正在吃第{i}个苹果')
# 更新计数器
i += 1
continue关键字
场景二：如果吃的过程中，吃到第三个吃出一个大虫子…,是不是这个苹果就不吃了，开始吃第四个苹果，这里就是continue控制循环流程，即退出当前一次循环继而执行下一次循环代码。
# 初始化计数器
i = 1
# 编写循环条件
while i <= 5:
# 当变量i 3的时候，中止当前循环，继续下一次循环
if i 3:
# 手工更新计数器(非常重要)
i += 1
print('吃到了一只大虫子，这个苹果不吃了...')
continue
print(f'正在吃第{i}个苹果')
# 更新计数器
i += 1
如果在使用continue的时候，不手工更新计数器会有什么后果呢？
答：会出现死循环
for循环基本语法及其应用
for循环结构主要用于（序列 => 字符串、列表、元组、集合以及字典）类型数据的遍历（循环）操作。
str1 = 'python'
for i in str1:
print(i)
range方法（函数）
Python2 range() 函数返回的是列表，而在Python3中 range() 函数返回的是一个可迭代对象（类型是对象），而不是列表类型， 所以打印的时候不会打印列表。（由于我们还未学习面向对象，为了方便大家理解，你可以简单的将其理解为一个序列结构）
主要作用：用于生成一段连续的内容
基本语法：
range(stop)
range(start, stop[, step])
start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
stop: 计数到 stop 结束，但不包括 stop。例如：range（0，5） 是 [0, 1, 2, 3, 4] 没有 5
step：步长，默认为1。例如：range（0，5） 等价于 range(0, 5, 1)
案例：for循环与range方法，使用for循环，循环5次
for i in range(5):
print(i)
案例: 使用for循环，求1 ~ 100之间所有偶数的和
# 定义一个变量，用于接收1~100之间所有偶数的和
result = 0
# 从1开始循环，循环100次
for i in range(1, 101):
if i % 2 0:
result += i
print(f'1~100之间所有偶数的和为{result}')
for循环中的else结构
for循环中的else结构在循环正常结束后执行，如果循环被break终止，则else结构不会执行。
基本语法：
for 临时变量 in 序列:
循环体
else:
当for循环正常结束后，返回的代码
break关键字对for…else结构的影响
如果循环被break终止，则else结构不会执行。
str1 = 'python'
for i in str1:
if i 'e':
print('遇e不打印')
break
print(i)
else:
print('循环正常结束之后执行的代码')
continue关键字对for…else结构的影响
continue关键词不会影响else结构的执行，else结构仍然会在循环正常结束后执行。
str1 = 'python'
for i in str1:
if i 'e':
print('遇e不打印')
continue
print(i)
else:
print('循环正常结束之后执行的代码')
字符串定义和切片
字符串是 Python 中最常用的数据类型。我们一般使用引号来创建字符串。创建字符串很简单，只要为变量分配一个值即可。
案例1：使用单引号或双引号定义字符串变量
str1 = 'abcdefg'
str2 = "hello world"
print(type(str1)) # <class 'str'>
print(type(str2)) # <class 'str'>
案例2：使用3个引号定义字符串变量
name1 = '''I am Tom, Nice to meet you!'''
print(name1)
print(type(name1))
print('-' * 20)
name2 = """I am Jennify,
Nice to meet you!"""
print(name2)
print(type(name2))
注意：三引号形式的字符串支持换行操作
字符串切片
所谓的切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。
顾头不顾尾：
序列名称[开始位置下标:结束位置下标:步长(步阶)]
numstr = '0123456789'
numstr[0:3:1] # 012 => range方法非常类似，步长：每次前进1步
numstr[0:3:2] # 02 => 每次前进2步
步长可以为负数，正数代表从左向右截取，负数代表从右向左截取
① 不包含结束位置下标对应的数据， 正负整数均可；
② 步长是选取间隔，正负整数均可，正数从左向右，负数从右向左。默认步长为1。
还是有点陌生，没关系，给你举个栗子：
numstr = '0123456789'
如果想对numstr字符串进行切片，如下图所示：
numstr = '0123456789'
# 1、从2到5开始切片，步长为1
print(numstr[2:5:1])
print(numstr[2:5])
# 2、只有结尾的字符串切片：代表从索引为0开始，截取到索引为5的位置（不包含索引为5的数据）
print(numstr[:5])
# 3、只有开头的字符串切片：代表从起始位置开始，已知截取到字符串的结尾
print(numstr[1:])
# 4、获取或拷贝整个字符串
print(numstr[:])
# 5、调整步阶：类似求偶数
print(numstr[::2])
# 6、把步阶设置为负整数：类似字符串翻转
print(numstr[::-1])
# 7、起始位置与结束位置都是负数
print(numstr[-4:-1])
# 8、结束字符为负数，如截取012345678
print(numstr[:-1])
字符串的操作方法（内置）
字符串中的查找方法
所谓字符串查找方法即是查找子串在字符串中的位置或出现的次数。
基本语法：
字符串.find(要查找的字符或者子串)
| 编号 | 函数 | 作用 |
|---|---|---|
| 1 | find() | 检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则返回-1。 |
| 2 | index() | 检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则报异常。 |
☆ find()方法
作用：检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则返回-1。
# 定义一个字符串
str1 = 'hello world hello linux hello python'
# 查找linux子串是否出现在字符串中
print(str1.find('linux'))
# 在str1中查找不存在的子串
print(str1.find('and'))
案例：使用input方法输入任意一个文件名称，求点号的索引下标
filename = input('请输入您要上传文件的名称：')
# 获取点号的索引下标
index = filename.find('.')
print(index)
# 求文件名称
print(filename[:index])
# 求文件后缀
print(filename[index:])
☆ index()方法
index()方法其功能与find()方法完全一致，唯一的区别在于当要查找的子串没有出现在字符串中时，find()方法返回-1，而index()方法则直接报错。
str1 = 'apple, banana, orange'
# 判断apple是否出现在字符串str1中
print(str1.index('apple'))
print(str1.index('pineapple'))
运行结果：
字符串的修改方法
所谓修改字符串，指的就是通过函数（方法）的形式修改字符串中的数据。
| 编号 | 函数 | 作用 |
|---|---|---|
| 1 | replace() | 返回替换后的字符串 |
| 2 | split() | 返回切割后的列表序列 |
| 3 | title() | 所有单词首字母大写 |
☆ replace()方法
基本语法：
字符串.replace(要替换的内容, 替换后的内容, 替换的次数-可以省略)
案例：编写一个字符串，然后把字符串中的linux替换为python
str1 = 'hello linux and hello linux'
# 把字符串中所有linux字符替换为python
print(str1.replace('linux', 'python'))
# 把字符串中的第一个linux进行替换为python
print(str1.replace('linux', 'python', 1))
# 把and字符串替换为&&
print(str1.replace('and', '&&'))
目前在工作中，replace主要用于实现关键字替换或过滤功能。北京 > BJ，论坛关键字过滤
☆ split()方法
作用：对字符串进行切割操作，返回一个list()列表类型的数据
str1 = 'apple-banana-orange'
print(str1.split('-'))
☆ join()方法
作用：和split()方法正好相反，其主要功能是把序列拼接为字符串
字符串.join(数据序列)
案例：把水果列表[‘apple’, ‘banana’, ‘orange’]拼接成’apple-banana-orange’
list1 = ['apple', 'banana', 'orange']
print('-'.join(list1))
列表
列表的作用是一次性存储多个数据，程序员可以对这些数据进行的操作有：增、删、改、查。
查
| 编号 | 函数 | 作用 |
|---|---|---|
| 1 | index() | 指定数据所在位置的下标 |
| 2 | count() | 统计指定数据在当前列表中出现的次数 |
| 3 | in | 判断指定数据在某个列表序列，如果在返回True，否则返回False |
| 4 | not in | 判断指定数据不在某个列表序列，如果不在返回True，否则返回False |
【案例】
# 1、查找某个元素在列表中出现的位置（索引下标）
list1 = ['apple', 'banana', 'pineapple']
print(list1.index('apple')) # 0
# print(list1.index('peach')) # 报错
# 2、count()方法：统计元素在列表中出现的次数
list2 = ['刘备', '关羽', '张飞', '关羽', '赵云']
# 统计一下关羽这个元素在列表中出现的次数
print(list2.count('关羽'))
# 3、in方法和not in方法（黑名单系统）
list3 = ['192.168.1.15', '10.1.1.100', '172.35.46.128']
if '10.1.1.100' in list3:
print('黑名单IP，禁止访问')
else:
print('正常IP，访问站点信息')
增
| 编号 | 函数 | 作用 |
|---|---|---|
| 1 | append(值) | 增加指定数据到列表中,直接在原列表里面追加了指定数据 |
| 2 | extend(列表) | 列表结尾追加数据，如果数据是一个序列，则将这个序列的数据逐一添加到列表 |
| 3 | insert(下标，值) | 指定位置新增数据 |
names = ['孙悟空', '唐僧', '猪八戒']
# 在列表的尾部追加一个元素"沙僧"
names.append('沙僧')
# 打印列表
print(names)
list1 = ['Tom', 'Rose', 'Jack']
# 1、使用extend方法追加元素"Jennify"
# names.extend("Jennify")
# print(names)
# 2、建议：使用extend方法两个列表进行合并
list2 = ['Hack', 'Jennify']
list1.extend(list2)
print(list1)
names = ['薛宝钗', '林黛玉']
# 在薛宝钗和林黛玉之间，插入一个新元素"贾宝玉"
names.insert(1, '贾宝玉')
print(names)
删
| 编号 | 函数 | 作用 |
|---|---|---|
| 1 | del 列表[索引] | 删除列表中的某个元素 |
| 2 | pop() | 删除指定下标的数据(默认为最后一个)，并返回该数据 |
| 3 | remove() | 移除列表中某个数据的第一个匹配项。 |
☆ del删除指定的列表元素
基本语法：
names = ['Tom', 'Rose', 'Jack', 'Jennify']
# 删除Rose
del names[1]
# 打印列表
print(names)
☆ pop()方法
作用：删除指定下标的元素，如果不填写下标，默认删除最后一个。其返回结果：就是删除的这个元素
names = ['貂蝉', '吕布', '董卓']
del_name = names.pop()
# 或
# del_name = names.pop(1)
print(del_name)
print(names)
☆ remove()方法
作用：删除匹配的元素
fruit = ['apple', 'banana', 'pineapple']
fruit.remove('banana')
print(fruit)
改
| 编号 | 函数 | 作用 |
|---|---|---|
| 1 | 列表[索引] = 修改后的值 | 修改列表中的某个元素 |
| 2 | reverse() | 将数据序列进行倒序排列 |
| 3 | sort() | 对列表序列进行排序 |
【案例】
list1 = ['貂蝉', '大乔', '小乔', '八戒']
# 修改列表中的元素
list1[3] = '周瑜'
print(list1)
list2 = [1, 2, 3, 4, 5, 6]
list2.reverse()
print(list2)
list3 = [10, 50, 20, 30, 1]
list3.sort() # 升序(从小到大)
# 或
# list3.sort(reverse=True) # 降序(从大到小)
print(list3)
循环遍历
while循环：
list1 = ['貂蝉', '大乔', '小乔']
# 定义计数器
i = 0
# 编写循环条件
while i < len(list1):
print(list1[i])
# 更新计数器
i += 1
for循环（推荐）：
list1 = ['貂蝉', '大乔', '小乔']
for i in list1:
print(i)
元祖
元组可以存储多个数据且元组内的数据是不能修改的
基本语法：
# 多个数据元组
tuple1 = (10, 20, 30)
# 单个数据元组
tuple2 = (10,)
注意：如果定义的元组只有一个数据，那么这个数据后面也要添加逗号，否则数据类型为唯一的这个数据的数据类型。
和列表的函数类似，由于元组中的数据不允许直接修改，所以其操作方法大部分为查询方法。
| 编号 | 函数 | 作用 |
|---|---|---|
| 1 | 元组[索引] | 根据索引下标查找元素 |
| 2 | index() | 查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列表、字符串的index方法相同 |
| 3 | count() | 统计某个数据在当前元组出现的次数 |
| 4 | len() | 统计元组中数据的个数 |
案例1：访问元组中的某个元素
nums = (10, 20, 30)
print(nums[2])
案例2：查找某个元素在元组中出现的位置，存在则返回索引下标，不存在则直接报错
nums = (10, 20, 30)
print(nums.index(20))
案例3：统计某个元素在元组中出现的次数
nums = (10, 20, 30, 50, 30)
print(nums.count(30))
案例4：len()方法主要就是求数据序列的长度，字符串、列表、元组
nums = (10, 20, 30, 50, 30)
print(len(nums))
字典
定义：
# 有数据字典
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
# 空字典
dict2 = {}
dict3 = dict()
在Python代码中，字典中的key必须使用引号引起来
字典的增操作（重点）
基本语法：
字典名称[key] = value
注：如果key存在则修改这个key对应的值；如果key不存在则新增此键值对。
案例：定义一个空字典，然后添加name、age以及address这样的3个key
# 1、定义一个空字典
person = {}
# 2、向字典中添加数据
person['name'] = '刘备'
person['age'] = 40
person['address'] = '蜀中'
# 3、使用print方法打印person字典
print(person)
注意：列表、字典为可变类型
字典的删操作
① del 字典名称[key]：删除指定元素
# 1、定义一个有数据的字典
person = {'name':'王大锤', 'age':28, 'gender':'male', 'address':'北京市海淀区'}
# 2、删除字典中的某个元素（如gender）
del person['gender']
# 3、打印字典
print(person)
② clear()方法：清空字典中的所有key
# 1、定义一个有数据的字典
person = {'name':'王大锤', 'age':28, 'gender':'male', 'address':'北京市海淀区'}
# 2、使用clear()方法清空字典
person.clear()
# 3、打印字典
print(person)
字典的改操作
基本语法：
字典名称[key] = value
注：如果key存在则修改这个key对应的值；如果key不存在则新增此键值对。
案例：定义一个字典，里面有name、age以及address，修改address这个key的value值
# 1、定义字典
person = {'name':'孙悟空', 'age': 600, 'address':'花果山'}
# 2、修改字典中的数据（address）
person['address'] = '东土大唐'
# 3、打印字典
print(person)
字典的查操作
① 查询方法：使用具体的某个key查询数据，如果未找到，则直接报错。
字典序列[key]
② 字典的相关查询方法
| 编号 | 函数 | 作用 |
|---|---|---|
| 1 | keys() | 以列表返回一个字典所有的键 |
| 2 | values() | 以列表返回字典中的所有值 |
| 3 | items() | 以列表返回可遍历的(键, 值) 元组数据 |
案例1：提取person字典中的所有key
# 1、定义一个字典
person = {'name':'貂蝉', 'age':18, 'mobile':'13765022249'}
# 2、提取字典中的name、age以及mobile属性
print(person.keys())
案例2：提取person字典中的所有value值
# 1、定义一个字典
person = {'name':'貂蝉', 'age':18, 'mobile':'13765022249'}
# 2、提取字典中的貂蝉、18以及13765022249号码
print(person.values())
案例3：使用items()方法提取数据
# 1、定义一个字典
person = {'name':'貂蝉', 'age':18, 'mobile':'13765022249'}
# 2、调用items方法获取数据，dict_items([('name', '貂蝉'), ('age', 18), ('mobile', '13765022249')])
# print(person.items())
# 3、结合for循环对字典中的数据进行遍历
for key, value in person.items():
print(f'{key}：{value}')
集合
集合（set）是一个无序的不重复元素序列。适用于 元素的去重 情况
可以使用一对花括号{}或者set()方法来定义集合，但是如果你定义的集合是一个空集合，则只能使用set()方法。
# 定义一个集合
s1 = {10, 20, 30, 40, 50}
print(s1)
print(type(s1))
# 定义一个集合：集合中存在相同的数据
s2 = {'刘备', '曹操', '孙权', '曹操'}
print(s2)
print(type(s1))
# 定义空集合
s3 = {} #这样定义的是字典
s4 = set()
print(type(s3)) # <class 'dict'>
print(type(s4)) # <class 'set'>
集合的增操作
add()方法：向集合中增加一个元素（单一）
students = set()
students.add('李哲')
students.add('刘毅')
print(students)
集合的删操作
remove()方法：删除集合中的指定数据，如果数据不存在则报错。
# 1、定义一个集合
products = {'萝卜', '白菜', '水蜜桃', '奥利奥', '西红柿', '凤梨'}
# 2、使用remove方法删除白菜这个元素
products.remove('白菜')
print(products)
集合中的查操作
① in ：判断某个元素是否在集合中，如果在，则返回True，否则返回False
② not in ：判断某个元素不在集合中，如果不在，则返回True，否则返回False
# 定义一个set集合
s1 = {'刘帅', '英标', '高源'}
# 判断刘帅是否在s1集合中
if '刘帅' in s1:
print('刘帅在s1集合中')
else:
print('刘帅没有出现在s1集合中')
③ 集合的遍历操作
for i in 集合:
print(i)
推导式
推导式comprehensions（又称解析式），是Python的一种独有特性。推导式是可以从一个数据序列构建另一个新的数据序列（一个有规律的列表或控制一个有规律列表）的结构体。 共有三种推导：列表推导式、集合推导式、字典推导式。
基本语法：
变量名 = [表达式 for 变量 in 列表]
变量名 = [表达式 for 变量 in 列表 if 条件]
变量名 = [表达式 for 变量 in 列表 for 变量 in 列表]
案例：定义0-9之间的列表
list1 = [i for i in range(10)]
print(list1)
案例：生成0-9之间的偶数（i%2 0）序列
list1 = [i for i in range(10) if i % 2 0]
print(list1)
案例：创建列表 => [(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
原生代码：for循环嵌套
list1 = []
# 外层循环
for i in range(1, 3):
# 内层循环
for j in range(0, 3):
tuple1 = (i, j)
list1.append(tuple1)
print(list1)
列表推导式：
list1 = [(i, j) for i in range(1, 3) for j in range(0, 3)]
print(list1)
函数
所谓的函数就是一个被命名的、独立的、完成特定功能的代码段（一段连续的代码），并可能给调用它的程序一个返回值。
#定义函数
def size(num1, num2):
jia = num1 + num2
jian = num1 - num2
cheng = num1 * num2
chu = num1 / num2
return jia, jian, cheng, chu #通过元祖返回多个值
#调用函数
size(20,10)
关键字参数
def user_info(name, age, address):
print(f'我的名字{name}，今年{age}岁了，家里住在{address}')
# 调用函数（使用关键词参数）
user_info(name='Tom', age=23, address='美国纽约')
缺省参数（参数默认值）
def user_info(name, age, gender='男'):
print(f'我的名字{name}，今年{age}岁了，我的性别为{gender}')
user_info('李林', 25)
user_info('振华', 28)
user_info('婉儿', 18, '女')
定义缺省参数时，一定要把其写在参数列表的最后侧
不定长参数
不定长参数也叫可变参数。用于不确定调用的时候会传递多少个参数(不传参也可以)的场景。此时，可用包裹(packing)位置参数，或者包裹关键字参数，来进行参数传递，会显得非常方便。
def user_info(*args):
# print(args) # 元组类型数据，对传递参数有顺序要求
print(f'我的名字{args[0]}，今年{args[1]}岁了，住在{args[2]}')
# 调用函数，传递参数
user_info('Tom', 23, '美国纽约')
def user_info2(**kwargs):
# print(kwargs) # 字典类型数据，对传递参数没有顺序要求，格式要求key = value值
print(f'我的名字{kwargs["name"]}，今年{kwargs["age"]}岁了，住在{kwargs["address"]}')
# 调用函数，传递参数
user_info2(name='Tom', address='美国纽约', age=23)
# Python组包：就是把多个数据组成元组或者字典的过程。
def func(*args, **kwargs):
print(args)
print(kwargs)
# 定义一个元组（也可以是列表）
tuple1 = (10, 20, 30)
# 定义一个字典
dict1 = {'first': 40, 'second': 50, 'third': 60}
# 需求：把元组传递给*args参数，字典传递给**kwargs
# ① 如果想把元组传递给*args，必须在tuple1的前面加一个*号
# ② 如果想把字典传递给**kwargs，必须在dict1的前面加两个**号
func(*tuple1, **dict1)
变量的作用域
在函数内部定义范围就称之为局部作用域，在函数外部（全局）定义范围就是全局作用域
# 全局作用域
def func():
# 局部作用域
在Python中，定义在函数外部的变量就称之为全局变量；定义在函数内部变量就称之为局部变量。
全局变量：在整个程序范围内都可以直接使用
局部变量：在函数的调用过程中，开始定义，函数运行过程中生效，函数执行完毕后，销毁
# 定义在函数外部的变量（全局变量）
num = 10
# 定义一个函数
def func():
# 函数体代码
# 定义在函数内部的变量（局部变量）
num = 100
global关键字的应用场景
不能在局部作用域中对全局变量进行修改,要进行修改，必须使用global关键字。
# 定义全局变量num = 10
num = 10
# 定义一个函数func
def func():
# 尝试在局部作用域中修改全局变量
global num
num = 20
# 调用函数func
func()
# 尝试访问全局变量num
print(num)
global关键字只是针对不可变数据类型的变量进行修改操作（数值、字符串、布尔类型、元组类型），可变类型可以不加global关键字。
可变与非可变数据类型
在大多数编程语言中，值的传递通常可以分为两种形式“值传递与引用（地址）传递”，但是在Python中变量的传递基本上都是引用（地址）传递。
可变和不可变类型的划分依据是: 在不改变地址值的情况下, 元素值是否可以发生改变, 可以 -> 可变类型, 不可以 -> 不可变类型.
可变类型: list(列表), dict(字典), set(集合)
不可变类型: int, float, bool, str, tuple
e = f = g = 1234
print(id(e), id(f), id(g))
# int: 不可变类型
a = 1234
b = 'tom'
print(id(a))
print(id(b))
a = 456
b = 'jerry'
print(id(a))
print(id(b))
# list: 可变类型,
ls = [1, 2, 3, 4]
print(id(ls))
ls.append(5)
ls.append(6)
print(id(ls))
拆包
快速的从容器类型中提取出各个值的过程, 即称之为: 拆包. 拆包应用场景:交换变量值.
把多个值放到容器类型中的过程称之为: 组包.
my_list = [1, 2, 3] # 组包
a, b, c = my_list # 拆包
案例
a, b = (1, 2)
print(a, b) # 1 2
c, d = [3, 4]
print(c, d) # 3 4
e, f = {1, 3}
print(e, f) # 1 3
h, i = {'name': 'tom', 'age': 18}
print(h, i) # name age
lambda表达式
lambda表达式介绍:
概述/作用:
它是用来简化函数写法的.
应用场景:
1. 函数体只有一行代码.
2. 返回值只有1个.
格式:
lambda 形参列表 : 函数体
格式解释:
1. lambda表达式也被称之为: 匿名函数, 即: 没有名字的函数.
2. lambda表达式在 函数体执行完毕后, 会将其结果自动返回.
实际开发真实应用场景:
1. lambda表达式可以作为 函数的实参进行传递, 这样可以根据传入的不同规则, 实现不同的操作.
2. lambda表达式还可以作为 函数对象, 赋值给变量, 该变量 = 函数
案例
# lambda表达式: 带参数的写法.
fun1 = lambda a, b: a + b
result = fun1(10, 20)
print(result)
# lambda表达式: 无参函数写法
fun2 = lambda: print('ok')
fun2()
# lambda表达式: if判断, 即: 获取两个整数最大值.
fun3 = lambda a, b: max(a, b)
print(fun3(10, 20))
案例 sort()函数, 排序问题
students = [
{'name': 'Tom', 'age': 20},
{'name': 'Rose', 'age': 19},
{'name': 'Jack', 'age': 22}
]
students.sort(key=lambda line: line['age'],reverse=False) #按年龄升序
print(students)
文件操作
操作步骤:
1. 打开文件.
open('文件路径', '模式', '码表-可选')
2. 读写操作.
read()
write()
3. 关闭文件.
close()函数
read(n) 一次读取n个字符, 如果不写, 则一次读取所有(字符)
readline() 一次读取一行
readlines() 一次读取所有行, 然后封装到 列表中.
涉及到的常用模式如下:
r 只读, 字符形式.
w 只写, 字符形式.
a 追加, 字符形式.
rb 只读, 字节形式. byte(字节)
wb 只写, 字节形式. byte(字节)
ab 追加, 字节形式. byte(字节)
1).拷贝文本文件, 既可以用 r,w,a, 也可以用 rb, wb, ab, 字符, 字节形式均可.
2).拷贝图片,音频, 视频文件, 只能用 rb, wb, ab, 字节形式.
案例:把数据源文件的内容反转后, 写到目的地文件中.
# 1. 数据源文件
read1 = open(r'test\1.txt','r',encoding='utf-8') #第一个参数前的r表示不转义
# 2. 目的地文件.
write1 = open(r'test\333.txt','w',encoding='utf-8')
# 3. 循环读取; 内容反转
# lines = read1.readlines() #一次读多行
# for line in lines:
# write1.write(line[::-1])
while True:
line = read1.readline() #一次读一行，适合大文件
if len(line) == 0:
break
write1.write(line)
# 4.释放资源.
read1.close()
write1.close()
with open语法糖
语法糖, 省去文件操作时的 close()函数.
with open(r'test\1.txt', 'r', encoding='utf-8') as fr, open(r'test\3.txt', 'w', encoding='utf-8') as fw:
while True:
line = fr.readline()
if len(line) == 0:
break
fw.write(line)
os模块
常用函数如下:
rename() 改名
remove() 删除文件的
mkdir() 创建文件夹
getcwd() 查看当前的工作目录, 即: 相对路径参考的地址.
chdir() 改变工作目录
listdir() 查看当前文件夹下所有的子级(文件, 文件夹), 不包括子级的子级.
rmdir() 删除文件夹的, 细节: 只能删除空文件夹.
shutil.rmtree() 级联删除
# 导包
import os
# 演示 rename() 改名
# os.rename('test/1.txt', 'test/1111.txt')
# 演示 remove() 删除
# os.remove('test/1111.txt')
# 演示 mkdir() makedirs(xx,exist_ok =True) 创建文件夹
# os.mkdir('test/a')
# os.makedirs('test/b/d/e',exist_ok=True)
# 演示 getcwd() 查看当前的工作目录, 即: 相对路径参考的地址.
# print(os.getcwd())
# 演示 chdir() 改变工作目录
# os.chdir('test/b/d/e')
# print(os.getcwd())
# 演示 listdir() 查看当前文件夹下所有的子级(文件, 文件夹), 不包括子级的子级.
#当前文件夹: .
# print(os.listdir('test'))
# 演示 rmdir() 删除文件夹的, 细节: 只能删除空文件夹.
# os.rmdir('test/a')
# 如果要删除 非空目录, 思路1: 递归. 思路2: shutil包的 rmtree函数.
#级联删除（shutil）（文件夹里面包含文件和文件夹）
import shutil
shutil.rmtree('test/b/d')
异常
概述:Python中, 把程序出现的所有的非正常情况, 统称为: 异常. 俗称: Bug
异常的处理方式:
思路1: 不处理.
交由程序默认处理, 则会 将异常信息, 产生原因, 位置打印到控制台上, 并终止程序的执行.
思路2: 捕获异常
手动处理, 采用 try.except 语法来处理, 处理之后, 程序会继续向下执行.
捕获异常语法格式介绍:
try:
可能出问题的代码
except Exception as e:
出问题后的解决方案
else:
如果没有出问题, 即: 没有执行except, 则会执行这里的内容.
finally:
无论是否出问题, 都会执行这里的内容. 一般用于释放资源.
执行流程:
如果出问题, 则执行: except
// \\
try 无论是否有问题, 都会执行: finally
\\ //
如果没有出问题, 则执行 else语句
案例
try:
read1 = open(r'test\2.txt','r',encoding='utf-8')
write1 = open(r'test\1.txt','w',encoding='utf-8')
lines = read1.readlines()
for line in lines:
write1.write(line[::-1])
except Exception as e:
print('异常：',e)
finally:
read1.close()
write1.close()
模块
导入模块的方式:
import 模块名
import 模块名 as 别名
from 模块名 import 功能名
from 模块名 import 功能名 as 别名
from 模块名 import *
案例
# 演示: 思路1: import 模块名
# 导包
#时间工具类
# import time
# print(time.time())
# 演示: 思路2: import 模块名 as 别名
# import time as tm
# print(tm.time())
# 演示: 思路3: from 模块名 import 功能名
# from time import time
# print(time())
# 演示: 思路4: from 模块名 import 功能名 as 别名
# from time import time as tm
# print(tm())
# 演示: 思路5: from 模块名 import *
from time import *
综合案例-学生管理系统
"""
案例: 学生管理系统.
思路:
1. 采用 函数 实现模块化编程.
2. 可以对学生信息进行 增删改查的操作.
3. 学生信息我们用 列表嵌套字典的方式 来实现, 后续可以改为: 文件, 数据库等...
info = [
{'id': '学号', 'name': '姓名', 'tel': '手机号'},
{'id': '学号', 'name': '姓名', 'tel': '手机号'},
{'id': '学号', 'name': '姓名', 'tel': '手机号'}
......
] # 学号具有唯一性, 姓名可以重复.
实现步骤:
0. 定义函数 print_logo(), 打印: 菜单界面.
1. 定义函数 add_student(), 实现: 增加学生信息.
2. 定义函数 del_student(), 实现: 删除学生信息.
3. 定义函数 update_student(), 实现: 修改学生信息.
4. 定义函数 search_one_student(), 实现: 查找(单个)学生信息.
5. 定义函数 search_all_student(), 实现: 查找(所有)学生信息.
6. 定义函数 execute(), 用来实现: 完整的业务逻辑, 根据用户录入的内容, 做对应的操作.
7. 定义函数 main(), 实现: 主函数, 即程序的主入口.
"""
# 1. 定义函数 print_logo(), 打印: 菜单界面.
# def print_logo():
def print_logo():
print('01.添加学生信息')
print('02.删除学生信息')
print('03.修改学生信息')
print('04.查找单个学生信息')
print('05.查找所有学生信息')
# 2. 定义函数 add_student(), 实现: 增加学生信息.
# 2.1 定义全局变量, 用来记录学生信息.
info = [
{'id': 's01', 'name': '熊大', 'tel': '111'},
{'id': 's02', 'name': '熊二', 'tel': '222'},
{'id': 's03', 'name': '光头强', 'tel': '333'}
]
def add_student():
stu_id = input('请输入学生id:')
for i in info:
if i['id'] == stu_id:
print('学生id已存在，请重新输入')
break
else:
name = input('请输入姓名:')
tel = input('请输入手机:')
info.append({'id': stu_id, 'name': name, 'tel': tel})
print('添加学生成功！')
# 3. 定义函数 del_student(), 实现: 删除学生信息.
def del_student():
s_id = input('请输入学号：')
for i in info:
if i['id'] == s_id:
info.remove(i)
break
else:
print('学号不存在')
# 4. 定义函数 update_student(), 实现: 修改学生信息.
def update_student():
s_id = input('请输入学号：')
for i in info:
if i['id'] == s_id:
name = input('请输入姓名:')
tel = input('请输入手机:')
i['name'] = name
i['tel'] = tel
break
else:
print('学号不存在')
# 5. 定义函数 search_one_student(), 实现: 查找(单个)学生信息.
def search_one_student():
s_id = input('请输入学号：')
for i in info:
if i['id'] == s_id:
print(f'学号\t姓名\t手机\t')
print(f'{i["id"]}\t{i["name"]}\t{i["tel"]}')
break
else:
print('暂无数据')
# 6. 定义函数 search_all_student(), 实现: 查找(所有)学生信息.
def search_all_student():
# 6.1 判断是否有学生信息.
if len(info) == 0:
print('暂无学生信息')
else:
print(f'学号\t姓名\t手机\t')
for i in info:
print(f'{i["id"]}\t{i["name"]}\t{i["tel"]}')
# 7. 定义函数 execute(), 用来实现: 完整的业务逻辑, 根据用户录入的内容, 做对应的操作.
def execute():
while True:
print_logo()
menu_id = input('请输入菜单id:')
if menu_id == '01':
add_student()
search_all_student()
elif menu_id == '02':
del_student()
search_all_student()
elif menu_id == '03':
update_student()
search_all_student()
elif menu_id == '04':
search_one_student()
elif menu_id == '05':
search_all_student()
else:
print('请输入正确的菜单')
# 8. 定义函数 main(), 实现: 主函数, 即程序的主入口.
if __name__ == '__main__':
execute()