一、变量及基本概念

1、变量

# 1、定义变量
user = "root"
password = "123.com"

# 2、打印变量
print(user)
print(password)

注意：print函数()括号内 存在双引号或单引号那就是字符串，并非变量。

案例： 超市买苹果

price = 8.5
weight = 7.5

money = price * weight
print("共%d元" %money)

基于上面举例修改 超市搞活动 只要买苹果就减5元

price = 8.5
weight = 7.5

money = price * weight - 5
print("共%d元" %money)

2、变量类型

变量类型	解释
srt	字符串
int	整数
long	长整数(仅在python2中存在)
bool	布尔(真假)
float	浮点数
tuple	元组
list	列表

3、变量格式化输出

格式化字符	含义
%s	字符串
%d	有符号十进制整数，%06d表示输出整数为6位，不足6为则使用0代替
%f	浮点数，%.2f表示显示小数点后2位
%%	显示%

案例：

1、字符串

name = "张三"
print('%s' %(name))

输出结果如下：

我的名字叫zhangsan

2、整数

studentId = 5
print("我的学号是 %06d" %studentId)

输出结果如下：

我的学号是 000005

3、浮点数

height = 1.8
print("我的身高是 %.2f" %height)

输出结果如下：

我的身高是 1.80

4、输出%号

memory = 25
print("当前内存使用率是 %.2f%%" %memory)

输出结果如下：

当前内存使用率是 25.00%

5、小总结-超时买苹果案例

price = 9
weight = 5
money = price * weight
print('苹果价格 %.2f/斤, 购买了 %.2f斤，需要支付 %.2f元' % (price, weight, money))

输出结果如下：

苹果价格 9.00/斤, 购买了 5.00斤，需要支付 45.00元

4、type()函数

type函数用来查看变量的类型；

variable_str = "zhangsan"
variable_int = 1790
variable_bool = True
variable_float = 17.90

print(type(variable_str))
print(type(variable_int))
print(type(variable_bool))
print(type(variable_float))

输出结果如下：

<class 'str'>
<class 'int'>
<class 'bool'>
<class 'float'>

5、input()函数

用于实现交互式赋值给变量；

user = input('账号:')
passwd = input('密码:')
print('账号为:%s 密码为:%s' %(user, passwd))

输出结果如下：

账号:root
密码:123
账号为:root 密码为:123

6、类型转换函数

函数	解释
int(x)	将x转换为整数
float(x)	将x转换为浮点数

案例：超时买苹果升级版

price = float(input("请输入苹果单价:"))
weight =float(input("请输入苹果重量:"))
money = price * weight
print('苹果价格 %.2f/斤，购买了 %.2f斤，需要支付 %.2f元' % (price, weight, money))

输出结果如下：

请输入苹果单价:10
请输入苹果重量:50
苹果价格 10.00/斤，购买了 50.00斤，需要支付 500.00元

7、注释

1、单行注释

# 这是一个注释
print('test1')

或者

print('test1')  # 这是一个注释

2、多行注释

使用三个"“”“” 引号 表示多行注释

"""
这是一段注释
"""

3、TODO注释

TODO 用来注释 下面代码需要进行的操作

# TODO(作者/邮箱) XXXXXXX

二、Python运算/字符

1、算数运算

运算符	描述	案例
+	加	10 + 10 = 20
-	减	20 - 10 = 10
*	乘	50 * 50 = 2500
/	除	10 / 3 = 3.3333
//	取整除	10 // 3 = 3
%	取余数	10 % 3 = 1
**	幂	2 ** 3 = 8/

在python中*运算还可以用于字符串拼接，计算结果就是字符串重复指定次数的结果；

test = "-" * 50
print(test)

优先级：

• 在python中算数优先级和数学中的运算优先级一致;
• 先乘除后加减;
• 同级运算时 从左到右计算；
• 可以使用 ( ) 调整计算的优先级。

运算符	描述
**	幂（优先级最高）
* / % //	乘、除、取余数、取整数
+ -	加、减

2、比较运算

运算符	描述
==	判断A、B是否相等
!=	判断A、B是否不相等
>	判断A是否大于B
<	判断A是否小于B
>=	判断A是否大于等于B
<=	判断A是否小于等于B

3、逻辑运算

运算符	描述
and	逻辑与
or	逻辑或
not	逻辑非

# 逻辑与： 真真为真 真假为假 假假为假
# 逻辑或： 真真为真 真假为真 假假为假
# 逻辑非： 真的是假的  假的是真的

4、赋值运算符

运算符	描述	实例
=	赋值运算符	c = a + b
+=	加法运算符	i += c 等价于 i = i + c
-=	减法运算符	i -= c 等价于 i = i - c
/=	除法运算符	c /=a 等价于 c = c / a
//=	取整数运算符	c //= b 等价于 c = c // b
%=	取余运算符	c %= a 等价于 c = c % a
**=	幂运算符	c **= b 等价于 c = c ** b

5、转义字符

符号	描述
\	转义字符
\n	换行符
\t	制表符 TAB键
\r	回车

案例：

1、转义字符 \

print("\"hello\"")

输出结果如下：

"hello"

2、换行符 \n

print("hello\nhello")

输出结果如下：

hello
hello

3、制表符 \t

print("hello\thello")
hello	hello

输出结果如下：

print("hello\thello")
hello	hello

4、回车 \r

print("hello\rworld")

输出结果如下：

world

6、成员运算符

运算符	描述
in	判断元素是否存在 返回值是布尔值
not in	判断元素是不否存在 返回值是布尔值

案例：

1、成员运算符 in

listName = ["zhangs", "lisi", "wangwu"]
print("zhangs" in listName)

输出结果如下：

True

2、成员运算符 not in

listName = ["zhangs", "lisi", "wangwu"]
print("zhangs" not in listName)

输出结果如下：

False

三、判断/循环语句

1、if判断语句

基本语法如下：

if 条件1:
    代码块1....
elif 条件2:
    代码块2....
else:
    代码块.....

案例：

1、if判断语句 if...else

age = int(input('你今年多大了?:'))
if age >= 18:
    print('已满18岁,没有防沉迷啦！')
else:
    print('未满18岁,有限制哦！')

输出结果如下：

你今年多大了?:18
已满18岁,没有防沉迷啦！

2、if判断语句 if...elif..else

num = int(input('0-150之间请选择一个整数:'))
if num <= 0:
    print('小于等于0')
elif 0 < num <= 100:
    print('大于0且小于等于100')
elif 100 < num <= 150:
    print('大于100且小于等于150')
else:
    print('无效数字 请0-150选择')

输出结果如下：

0-150之间请选择一个整数:100
大于0且小于等于100

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

day = input('今天是什么日子:')

if day == '情人节':
    print('今天是情人节,不会又是你自己吧？')
elif day == '劳动节':
    print('今天是劳动节,赖床上还没起?')
elif day == '国庆节':
    print('今天是国庆节,天安门看升国旗')
else:
    print('每天都是值得期待的日子呀！')

输出结果如下：

今天是什么日子:情人节
今天是情人节,不会又是你自己吧？

4、if判断语句if嵌套

# 疫情可以回家过年吗？
city = input('请输入现在所在城市:')

if not city == '天津' or city == '武汉':
    print('%s 不属于高风险区,可以进行购票' % city)
    ticket = input('是否购买去往 %s 的票:' % city)
    if ticket == '是':
        print('购票成功,可以回家啦')
    else:
        print('购票失败')
else:
    print('%s 是高风险区,禁止购票' % city)

输出结果如下：

请输入现在所在城市:北京
北京 不属于高风险区,可以进行购票
是否购买去往 北京 的票:是
购票成功,可以回家啦

5、if判断小总结-石头剪刀布游戏-1

import random
computer = random.randint(1, 3)
player = int(input('请输入你要出的拳 石头(1)/剪刀(2)/布(3):'))
print('我出的是%d 电脑出的是%d' % (player, computer))
if ((player == 1 and computer == 2)
        or (player == 2 and computer == 3)
        or (player == 3 and computer == 1 )):
    print('我赢了 不服不行呀')
elif player == computer:
    print('平局 真是心有灵犀呀')
else:
    print('我不服 大战三百回合')

输出结果如下：

请输入你要出的拳 石头(1)/剪刀(2)/布(3):1
我出的是1 电脑出的是3
我不服 大战三百回合

6、if判断小总结-判断分数程序-2

score = int(input("请输入一个整数:"))

if score >= 60:
    if score >= 80:
        if score == 100:
            print("满分真棒！")
        else:
            print("优秀！")
    else:
        print('及格')
else:
    print('继续加油')

输出结果如下：

请输入一个整数:100
满分真棒！

2、while循环语句

基本语法如下：

while 条件 (计数器 是否达到目的):    # 条件成立执代码块
    代执行码块
    处理条件(计数器 +1)

案例：

1、打印 I love china 5 遍

i = 0
while i < 5:
    print('I love china')
    i += 1

输出结果如下：

I love china
I love china
I love china
I love china
I love china

2、重复循环 计算0-100之间所有数字求和

思路：

• 首先定义整数变量记录循环次数

• 在循环内部，每次循环都用最新的计算结果 更新之前的数据

num = 0
result = 0
while num <= 100:
    result += num
    num += 1
print(result)

输出结果如下：

5050

3、计算1-100之间所有偶数的和

num = 0
result = 0
while num <= 100:
    if num % 2 == 0:
        result += num
    num += 1
print(result)

输出结果如下：

2500

4、计算1-100之间所有基数的和

num = 0
result = 0
while num <= 100:
    if not num % 2 == 0:
        result += num
    num += 1
print(result)

输出结果如下：

2500

5、输出久久乘法表

num1 = 1
while num1 <= 9:
    num2 = 1
    while num2 <= num1:
        print(f"{num1} * {num2} = {num1 * num2}", end='\t')
        num2 += 1
    print('')
    num1 += 1

或者：for循环 乘法表

for i in range(1,10):
    j = 1
    for j in range(1,i+1):
        print("%d * %d = %d" %(i,j,(i*j)),end='\t')
        j += 1
    print('')
    i += 1

输出结果如下：

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

3、for循环语句

基本语法：

for 变量 in 集合:
    循环体代码
else:
    没有通过break 退出循环，循环结束后，会执行的代码

举例：

1、迭代遍历列表

lisi_name = ["雅典娜", "张良", "夏侯惇", "百里玄策", "盾山"]
for i in lisi_name:
    print(i)

输出结果如下：

雅典娜
张良
夏侯惇
百里玄策
盾山

2、遍历字符串

for i in "我爱中国":
    print(i)

输出结果如下：

我
爱
中
国

3、通过索引方式遍历

fruits = ['banana', 'apple', 'mango']
for index in range(len(fruits)):
   print('当前水果 : %s' % fruits[index])

print("Good bye!")

输出结果如下：

当前水果 : banana
当前水果 : apple
当前水果 : mango
Good bye!

4、完整for循环 for...else结构

应用场景

• 在 迭代遍历 嵌套的数据类型时 ，列如一个列表中包含多个字典；
• 需求：判断列表中某个字典是否存在；
  • 如果 存在 则退出循环；
  • 如果不存在 ，在循环体结束后，希望得到一个提示；

students_list = [
    {"name": "张三",
     "age": 20,
     "height": 1.70,
     "weight": 75.0},
    {"name": "李四",
     "age": 22,
     "height": 1.86,
     "weight": 99.0}
]
find_name = input('请输入您要查询的名字:')
for i in students_list:
    if i["name"] == find_name:
        print("找到了 %s 信息如下: %s" % (find_name, i))
        break
else:
    print('没有找到 %s' % find_name)

输出结果如下：

请输入您要查询的名字:张三001
没有找到 张三001

4、for和while循环区别

for 循环：用于遍历一个可迭代对象（如列表、元组、字典、字符串等）中的元素。

while 循环：用于根据条件判断来重复执行代码块，当条件为真时，循环会一直执行下去。

主要区别：

• for 循环适合在已知循环次数或者需要遍历集合内元素的情况下使用，而 while 循环适合在未知循环次数或者需要根据条件来确定是否继续循环的情况下使用。
• for 循环通常比较适合处理已知范围的循环，而 while 循环更适合处理未知范围的循环。
• for 循环的控制结构相对简单，而 while 循环的控制结构较灵活，可以实现更复杂的循环逻辑。

5、break和continue

• break某条件成立 退出整个循环，不在执行后续代码；
• continue 某条件成立 退出当前循环，接着执行后面的代码；
• break和continue只针对 当前所在循环有效。

案例：

1、break

i = 0
while i <= 10:
    if i == 5:
        break
    print(i)
    i += 1
print('over')

输出结果如下：

0
1
2
3
4
over

2、continue

i = 0
while i <= 10:
    if i == 5:
        i += 1
        continue
    print(i)
    i += 1
print('over')

输出结果如下：

0
1
2
3
4
6
7
8
9
10
over

四、函数

1、函数定义式及调用

基本语法：

def 函数名称()：
	代码块

如果调用其他文件中的函数，需要先导入在调用如下：

from function import tab
tab()  //直接调用函数名

或者：

import function # 导入整个函数文件
function.tab()  # 调用: 函数文件.函数

案例：

1、将九九乘法表封装成函数

def tab ():
    row = 1
    while row <= 9:
        col = 1
        while col <= row:
            print('%d * %d = %d ' % (col, row, col * row), end='\t')
            col += 1
        print('')
        row += 1
        
# 使用函数名称调用函数  
tab()

输出结果如下：

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、调用 func文件中的 tab函数

from func import tab
tab()

或者：

import func 
func.tab()

2、函数注释

• 在函数名称下面使用三个引号进行注释：

def tab():
    """
    这里填写注释噢
    """
    row = 1
    while row <= 9:
        col = 1
        while col <= row:
            print("%d * %d = %d" %(col, row, col * row), end='\t')
            col += 1
        print('')
        row += 1

3、函数参数

• 形参：定义函数时后面小括号填写参数为形参；
• 实参：引用函数时后面小括号填写参数为实参；

def sum(num1, num2):
    """对两个变量的求和"""
    print('%d + %d = %d' % (num1, num2, num1 + num2))

sum(100, 200)

4、函数返回值

• 返回值 是 函数 完成工作后 ，最后 给调用者的一个结果；
• 在函数中 使用 return关键字可以返回结果；
• 调用函数一方，可以 使用变量 来 接受函数的返回结果；

def sum(num1, num2):
    """对两个变量相加结果"""
    result = num1 + num2
    # 使用return返回值 告诉调用一方计算结果
    # return下方同缩进代码不会被执行
    return result

# 使用变量 接受函数执行返回值
sum_result = sum(10, 20)
print('计算结果：%d' % sum_result)

输出结果如下：

计算结果：30

如果函数没有返回值，默认为None

def sum():
    print("没有返回值的函数!!!")
    return

result = sum()
print(result)

输出结果如下：

没有返回值的函数!!!
None

5、函数嵌套

嵌套函数就是一个函数里面嵌套着另一个函数，执行过程是从上往下的

案例：

定义一个函数 自定义符号 自定义打印次数；

def func1(char, num):
    print(char * num)


func1('*', 50)

接上函数修改 在定义一个函数，使用函数嵌套打印五行

def func1(char, num):
    print(char * num)

def func2(char, num):
    i = 0
    while i < 5:
        func1(char, num)
        i += 1

func2('*', 50)

输出结果如下：

**************************************************
**************************************************
**************************************************
**************************************************
**************************************************

6、局部变量和全局变量

局部变量：

• 局部变量 是在 函数内部定义的变量 ，只能在函数内使用；
• 函数执行完成后，函数内部的局部变量，会被系统回收；
• 不同函数 可以定义相同名字的变量。

全局变量：

• 在函数外部定义 在所有函数内部可以访问到;
• 在函数内部不可以直接修改 全局变量 ;

g_variable = 100

def num1():
    g_variable = 200
    # 在函数中定义局部变量g_variable和全局变量名称相同 但不会影响全局变量的值;
    print('输出全局变量内容 %d' % g_variable)


def num2():
    print('输出全局变量内容 %d' % g_variable)


num1()
num2()

输出结果如下：

输出全局变量内容 200
输出全局变量内容 100

但可以使用global将修改全局变量

g_variable = 100   


def num1():
    global g_variable
    # 使用 global 关键字将可以修改全局变量；
    g_variable = 200
    print('输出全局变量内容 %d' % g_variable)


def num2():
    print('输出全局变量内容 %d' % g_variable)


num1()
num2()
# 输入结果
输出全局变量内容 200
输出全局变量内容 200

输出结果如下：

输出全局变量内容 200
输出全局变量内容 200

五、列表

1、列表定义及引用

• list(列表)，是python中使用最频繁的数据类型，其他语言中通常叫数组;
• 定义列表使用[ ]，数据之间使用逗号隔开；
• 列表的索引是从 0开始的。

案例：定义列表及引用

userList = ["zhangs", "lisi", "wangwu"]
print(userList[0])

输出结果如下：

zhangs

2、列表操作

操作	格式	说明
查看	列表.index(数据, num)	查看指定数据索引位置 ，有重复num指定第几个数据
增加	列表.insert(索引, 数据)	在指定位置插入数据
	列表.append(数据)	在末行追加
	列表.extend(列表2)	将 列表2的数据追加到列表1
修改	列表[索引] = 数据	修改指定索引数据
删除	del 列表[索引]	删除指定索引数据
	列表.remove[数据]	删除指定数据(第一个出现的)
	列表.pop	删除末尾数据
	列表.pop(索引)	删除指定索引数据
	列表.clear	清空列表
统计	len(列表)	统计列表长度
	列表.count(数据)	统计数据出现此时
排序	列表.sort()	升序
	列表.sort(reverse)	降序
	列表.reverse()	逆序

案例：

1、查看

# 查看第二个 "李四" 的索引
name_list = ["张三", "李四", "王五", "李四"]
print(name_list.index("李四", 2))

输出结果如下：

3

2、增加

# insert 指定索引位置插入数据(insert一次只能插入一个值)
name_lisi = ["zhangsan", "lisi", "wangwu"]
name_lisi.insert(3, "maliu")
print(name_lisi)

# append 末尾追加数据(append一次只能插入一个值)
name_lisi = ["zhangsan", "lisi", "wangwu"]
name_lisi.append("maliu")
print(name_lisi)

# extend 列表1和列表2合并数据
name_lisi1 = ["zhangsan", "lisi", "wangwu"]
name_list2 = ["张三", "李四", "王五"]
name_lisi1.extend(name_list2)
print(name_lisi1)

输出结果如下：

['zhangsan', 'lisi', 'wangwu', 'maliu']
['zhangsan', 'lisi', 'wangwu', 'maliu']
['zhangsan', 'lisi', 'wangwu', '张三', '李四', '王五']

3、修改

name_list = ["张三", "李四", "王五"]
name_list[0] = "zhangsan"
print(name_list)

输出结果如下：

['zhangsan', '李四', '王五']

4、删除

# del 删除指定索引数据
name_list = ["张三", "李四", "王五"]
del name_list[0]
print(name_list)

# remove 删除指定数据
name_list = ["张三", "李四", "王五", "李四"]
name_list.remove("李四")
print(name_list)

# pop 删除末尾数据
name_list = ["张三", "李四", "王五", "李四"]
name_list.pop()
print(name_list)

# pop 删除指定索引数据
name_list = ["张三", "李四", "王五", "李四"]
name_list.pop(2)
print(name_list)

# clear 清空列表
name_list = ["张三", "李四", "王五", "李四"]
name_list.clear()
print(name_list)

输出结果如下：

['李四', '王五']
['张三', '王五', '李四']
['张三', '李四', '王五']
['张三', '李四', '李四']
[]

5、统计

# len() 统计列表长度
name_list = ["张三", "李四", "王五", "李四"]
print(len(name_list))

# 统计指定数据在列表中出现的次数
name_list = ["张三", "李四", "王五", "李四"]
print(name_list.count("李四"))

6、排序

# 升序 soft
# 字母A排最前 Z排最后
# 数字1排最前 数字越大排越后
list_name = ["C", "B", "A", "D"]
list_num = [2, 4, 3, 1]
list_num.sort()
list_name.sort()
print(list_name)
print(list_num)

# 降序 sort(reverse)
list_name = ["C", "B", "A", "D"]
list_num = [2, 4, 3, 1]
list_num.sort(reverse=True)
list_name.sort(reverse=True)
print(list_name)
print(list_num)

# 逆序 reverse
list_name = ["C", "B", "A", "D"]
list_num = [2, 4, 3, 1]
list_num.reverse()
list_name.reverse()
print(list_name)
print(list_num)

输出结果如下：

['A', 'B', 'C', 'D']
[1, 2, 3, 4]
['D', 'C', 'B', 'A']
[4, 3, 2, 1]
['D', 'A', 'B', 'C']
[1, 3, 4, 2]

3、循环遍历

• 遍历是指 从头到尾 依次 从 列表 中获取数据；

• 使用for 可以实现迭代遍历，迭代的意思是指重复;

• 列表存储相同类型的数据；

• 通过 迭代遍历 针对列表中每一个元素执行相同的操作。

list_name = ["张三", "李四", "王五", "马六"]
for i in list_name:
    print("我的名字叫 %s " %i)

输出结果如下：

我的名字叫 张三 
我的名字叫 李四 
我的名字叫 王五 
我的名字叫 马六 

六、元组

• tuple(元组)与列表类似，不同之处在于元组中元素不可修改；
• 元组使用()定义；
• 元组索引是从0开始的。

1、元组定义及引用

# 定义元组
info_tuple = ('小明', 18, 1.75)
print(type(info_tuple))

# 引用元组
info_tuple = ('小明', 18, 1.75)
print(info_tuple[0])

# 定义空元组
info_tuple = ()
print(type(info_tuple))

# 定义只有一个元素的元组
info_tuple = ('zhangsan',)
print(info_tuple[0])

输出结果如下：

<class 'tuple'>
小明
<class 'tuple'>
zhangsan

2、元组操作

# 通过元素名称取索引
info_name = ('zhangsan', 'lisi', 'zhangsan', 'wangwu')
print(info_name.index('zhangsan'))

# 统计某个元素出现次数
info_name = ('zhangsan', 'lisi', 'zhangsan', 'wangwu')
print(info_name.count('zhangsan'))

# 统计元组中元素个数
info_name = ('zhangsan', 'lisi', 'zhangsan', 'wangwu')
print(len(info_name))

输出结果如下：

0
2
4

3、元组列表之间切换

函数	解释
tuple()	将列表复制为元组
list()	将元组复制为列表

# 列表切换元组
list_name = ["孙悟空", "猪八戒", "机器吧"]
list_name2 = tuple(list_name)
print(type(list_name))
print(type(list_name2))

# 元组切换列表
tuple_xiaoming = ("小明", 19, 1.75)
tuple_xiaoming2 = list(tuple_xiaoming)
print(type(tuple_xiaoming))
print(type(tuple_xiaoming2))

输出结果如下：

<class 'list'>
<class 'tuple'>
<class 'tuple'>
<class 'list'>

七、字典

• 列表存放有序集合，字典(dictionary)存放无序集合；
• 字典使用 { }定义；
• 字典格采用键值对格式存储数据 即一个键 对应一个值 ；
• **键 **必须是唯一的，值 可以是任何数据类型，但键只能使用 字符串、数字、元组；

1、字典定义及引用

xiaoming = {"name": "小明",
            "age": 20,
            "height": 1.75}
print(xiaoming)

输出结果如下：

{'name': '小明', 'age': 20, 'height': 1.75}

2、字典操作

操作	格式	说明
修改、添加	字典[key] = value	key存在则修改对应内容，不存在则添加内容
添加key添加	字典.setdefault(key，value)	key存在不做操作，不存在则添加key
查看	字典.keys()	打印所有key
	字典.values()	打印所有value
	字典.items()	打印所有键值对
删除	del 字典[“key”]	删除指定key
	字典.pop(‘key’)	删除指定key
	字典.popitem()	随机删除一个key
	字典.clear()	清空字典
合并	字典.update(字典2)	合并字典

案例：

1、增删改操作

xiaoming = {"name": "小明",
            "age": 20,
            "height": 1.75,
            "weight": 120}

# 增加、修改
xiaoming["Size"] = 100
xiaoming["name"] = "小小明"
print(xiaoming)

# 删除
xiaoming.pop("name")

输出结果如下：

{'name': '小小明', 'age': 20, 'height': 1.75, 'weight': 120, 'Size': 100}
{'age': 20, 'height': 1.75, 'weight': 120, 'Size': 100}

2、合并字典

dict1 = {'a': 1, 'b': 2}
dict2 = {'c': 3, 'd': 4}

dict1.update(dict2)
print(dict1)

输出结果如下：

{'a': 1, 'b': 2, 'c': 3, 'd': 4}

3、其他操作

xiaoming = {"name": "小明",
            "age": 20,
            "height": 1.75,
            "weight": 120}
# 统计键值数量
print(len(xiaoming))

# 清空字典
xiaoming.clear()
print(xiaoming)

输出结果如下：

4
{}	

3、循环遍历

此处的 i 变量 相当于 key(键)

xiaoming = {"name": "小明", "age": 20}
for i in xiaoming:
    print("%s : %s" % (i, xiaoming[i]))

输出结果如下：

name : 小明
age : 20

4、列表嵌套字典

//使用 多个键值对 存储 描述一个 物体的相关信息

//将 多个字典放到列表中 再进行循环

class_name = [
    {"姓名": "小明", "年龄": 20, "身高": 175},
    {"姓名": "小红", "年龄": 18, "身高": 165},
    {"姓名": "小刚", "年龄": 21, "身高": 185}
]

for i in class_name:
    print(i)

输出结果如下：

{'姓名': '小明', '年龄': 20, '身高': 175}
{'姓名': '小红', '年龄': 18, '身高': 165}
{'姓名': '小刚', '年龄': 21, '身高': 185}

八、字符串

hello_str = "hello hello"

# 1、统计字符串长度
print(len(hello_str))

# 2、统计某个子字符出现次数
print(hello_str.count('llo'))

# 3、查看索引位置
print(hello_str.index('llo'))

1、字符串判断类型

方法	说明
string.isspace()	判断是否为空 包含制表符
string.isalnum()	判断是否不为空(只包含数字和字母)
string.isalpha()	判断是否不为空(只包含字母)
string.isdigit()	判断是否只包含数字 包含阿拉伯数字、(1)、\u00b2
string.isdecimal()	判断是否只包含数字 包含阿拉伯数字
string.isnumeric()	判断是否只包含数字 包含阿拉伯数字、汉字数字
string.istitle()	判断是否 每个单词的首字母大写

案例：

# 判断 Name_id值 是否只包含 数字 
Name_id = '121201920128230989385'
print(Name_id.isdigit())

# 判断每个单词首字母是否大写
Name_id = 'Name Zhang San'
print(Name_id.istitle())

输出结果如下：

True
True

2、字符串查找替换

方法	说明
string.startswith(‘str’)	判断字符串是否以str开头
string.endswith(‘str’)	判断字符串是否以str结尾
string.find(‘str’)	查看字符串中str索引位置编号 若不存在则返回-1
string.index(‘str’)	查看字符串中str索引位置编号 若不存在则报错
string.replace('old_str, ‘new_str’)	替换old_str字符为new_str

案例：

str = 'Name'
# 查看 'm' 所在索引位置
print(str.find('m'))
print(str.index('m'))

# 将 'Name' 替换为 'name'
print(str.replace('Name', 'name'))

输出结果如下：

2
2
name

3、字符串大小写转换

方法	说明
string.capitalize()	将第一个字符大写
string.title()	将字符串中每个首字母大写
string.lower()	将字符串中 所有大写 转换为 小写
string.upper()	将字符串中 所有小写 转换为 大写
string.swapcase()	将字符串中 所有大小写字符 进行转换

案例：

str = 'L love your'

print(str.lower()) # 转小写
print(str.upper()) # 转大写
print(str.swapcase()) # 相互转化

输出结果如下：

l love your
L LOVE YOUR
l LOVE YOUR

4、字符串文本对齐

方法	说明
string.center(宽度)	居中对齐
string.rjust(宽度)	右对齐
string.ljust(宽度)	左对齐

举例：

poem = ["登鹳雀楼",
        "王之涣",
        "白日依山尽",
        "黄河入海流",
        "欲穷千里目",
        "更上一层楼"]

# 居中对齐
for i in poem:
    print("|%s|" % i.center(10, " "))
print('=' * 50)
# 右对齐
for i in poem:
    print("|%s|" % i.rjust(10))
print('=' * 50)

# 左对齐
for i in poem:
    print("|%s|" % i.ljust(10))
print('=' * 50)

输出结果如下：

|   登鹳雀楼   |
|   王之涣    |
|  白日依山尽   |
|  黄河入海流   |
|  欲穷千里目   |
|  更上一层楼   |
==================================================
|      登鹳雀楼|
|       王之涣|
|     白日依山尽|
|     黄河入海流|
|     欲穷千里目|
|     更上一层楼|
==================================================
|登鹳雀楼      |
|王之涣       |
|白日依山尽     |
|黄河入海流     |
|欲穷千里目     |
|更上一层楼     |
==================================================

5、 字符串去除空白字符

方法	说明
string.strip()	去除空白字符
string.rstrip()	去除右边空白字符
string.lstrip()	去除左边空白字符

举例：

Name = '   zhangsan    '
print(Name.strip())

输出结果如下：

zhangsan

6、字符串拆分和连接

方法	说明
string.split(separator, maxsplit)	字符串切割，存到数组中
separator.join(iterable)	字符串拼接

split()方法的基本语法：

string.split(separator, maxsplit)

• separator（可选）：指定的分隔符，默认为 None（空格字符）。
• maxsplit（可选）：指定分割的最大次数。默认为 -1，即不限制分割次数。

案例：

1、不指定分隔符，默认以空格为分隔符

sentence = "Hello, world! How are you today?"
words = sentence.split()
print(words)

输出结果如下：

['Hello,', 'world!', 'How', 'are', 'you', 'today?']

2、指定分隔符和指定分割次数

sentence = "Hello, world,How,are you today?"
words = sentence.split(",",2)
print(words)

输出结果如下：

['Hello', ' world', 'How,are you today?']

join()方法的基本语法：

separator.join(iterable)

• separator：用于连接字符串的分隔符。
• iterable：一个可迭代对象，包含要连接的字符串元素。

案例：

1、使用|符号连接字符串

words = ['Hello,', 'world!', 'How', 'are', 'you', 'today?']
sentence = '|'.join(words)
print(sentence)

输出结果如下：

Hello,|world!|How|are|you|today?

2、使用空格连接字符串

words = ['Hello,', 'world!', 'How', 'are', 'you', 'today?']
sentence = ' '.join(words)
print(sentence)

输出结果如下：

Hello, world! How are you today?

7、字符串的切片

• 切片 方法适用于 字符串、元组、列表；
• 切片使用索引值 来限定范围 ，从一个大的字符串中切出小的字符串；
• 列表 和 元组 都是有序集合，可以通过索引获取到对方的值。

切片基本语法：

字符串[开始索引:结束索引:步长]

案例：

num_str = "012345679"
# 截取从 2-5 位置 的字符串
print(num_str[2:6])

# 截取从 2-末尾 的字符串
print(num_str[2:])

# 截取从 开始-5位置 的字符串
print(num_str[:6])

# 截取从 索引1开始 每隔一个取一个
print(num_str[1::2])

# 截取字符串末尾两个
print(num_str[-2::])

# 字符串的逆序
print(num_str[::-1])

输出结果如下：

2345
2345679
012345
1357
79
976543210

九、公共方法

1、内置函数

函数	描述	备注
len()	计算容器中元素个数
del()	删除变量
max()	返回容器最大值	字典只针对key作比较
min()	返回容器最小值	字典只针对key作比较

案例：

name_list = ["zhangsan", "lisi", "wangwu", "maliu"]
name_key = "zhangsan"

# 统计个数
print(len(name_list))
print(len(name_key))

# 最大值 & 最小值
print(max(name_key))
print(min(name_key))

# 删除变量
del(name_key)

输出结果如下：

4
8
z
a

2、切片

描述	Python表达式	结果	支持的数据类型
切片	“0123456”[::-2]	6420	字符串、列表、元组

• 切片 使用 索引 值来限定范围，从一个大的字符串中切出 小的字符串
• 列表 和 元组 都是有序集合，都能够通过索引获取到对应的数据
• 字典 是一个 无序集合 ，使用键值对保存数据，没有索引的概念 所以不支持切片

3、常用运算符

运算符	Python表达式	结果	描述	支持的数据类型
+	[1,2] + [3,4]	[1, 2, 3, 4]	合并	字符串、列表、元组
*	“Hi” * 3	HiHiHi	重复	字符串、列表、元组
in	“a” in [“a”, “b”, “c”, “d”]	True	元素是否包含	字符串、列表、元组、字
not in	“a” in [“a”, “b”, “c”, “d”]	False	元素是否不包含	字符串、列表、元组、字典
注意：

• in 针对 字典 的 key 进行判断

• in 和 not in 被称为 成员运算符

十、客户管理系统(综合案例)

1、程序需求解释

• 需求：

  • 1、用户使用数字选择不同的功能；
  • 2、根据功能选择，执行对应的功能；
  • 3、需要记录用户的 姓名、电话、QQ、邮件等信息；
  • 4、查询到指定名片 用户可以选择 修改、删除名片操作。

• 文件解释：

  • customer_main.py：整个逻辑
  • customer_function.py：调用函数

2、程序实现代码

customer_main.py文件代码：

import  customer_function

while True:
    customer_function.showMenu()
    userSelect = input("请输入选择您的指令:")
    if userSelect == "1":
        customer_function.newCustomer()
    elif userSelect == "2":
        customer_function.viewCustomer()
    elif userSelect == "3":
        customer_function.sourceCustomer()
    elif userSelect == "0":
        print("退出系统.....")
        break
    else:
        print("选择操作无效！请重新再次选择")

customer_function.py文件代码：

customerList = [{"Name": "111",
                         "Gender": "111",
                         "Phone": "111",
                         "Wechat": "111",
                         "QQ": "111"}]
# customerList = []
def showMenu():
    print("*" * 50)
    print("欢迎使用【客户管理系统V0.1版本】")
    print("*" * 50)
    print("")
    print("1. 添加客户信息")
    print("2. 查看所有客户信息")
    print("3. 查询客户信息")
    print("")
    print("0. 退出系统")
    print("*" * 50)

def newCustomer():
    print('*' * 50)
    print("功能: 添加客户信息")
    customerName = input("请输入客户姓名:")
    customerGender = input("请输入客户性别:")
    customerPhone = input("请输入客户电话:")
    customerWechat = input("请输入客户微信:")
    customerQQ = input("请输入客户QQ:")
    customerList.append({"Name": customerName,
                         "Gender": customerGender,
                         "Phone": customerPhone,
                         "Wechat": customerWechat,
                         "QQ": customerQQ})
    print('')
    print("添加【%s】客户信息成功!!!!" %(customerName))
def viewCustomer():
    if len(customerList) == 0:
        print("当前没有任何客户信息:")
        return
    print("*" * 50)
    print("功能: 查看所有客户信息")
    for name in ["姓名" ,"性别" ,"电话" ,"微信" ,"QQ"]:
        print(name, end='\t\t\t')
    print('')
    print('=' * 50)
    for i in customerList:
        print("%s\t\t\t%s\t\t\t%s\t\t\t%s\t\t\t%s"
              %(i["Name"] ,i["Gender"],i["Phone"],i["Wechat"],i["QQ"]))

    while True:
        viewCustomerUserSelect = input("0. 退出查看:")
        if viewCustomerUserSelect == "0":
            break
        else:
            print("选择操作无效！请重新再次选择")

def sourceCustomer():
    print("*" * 50)
    print("功能: 查询客户信息")
    sourceCustomerUserSelect = input("请输入要查询的客户名称:")
    for index in customerList:
        if index["Name"] == sourceCustomerUserSelect:
            for name in ["姓名", "性别", "电话", "微信", "QQ"]:
                print(name, end='\t\t\t')
            print('')
            print('=' * 50)
            print("%s\t\t\t%s\t\t\t%s\t\t\t%s\t\t\t%s\n"
            % (index["Name"], index["Gender"], index["Phone"], index["Wechat"], index["QQ"]))
            while True:
                sourceCustomerUserMenu = input("1. 修改客户\t2. 删除客户\t0. 返回上级:")
                if sourceCustomerUserMenu in ["1" ,"2" ,"0"]:
                    if sourceCustomerUserMenu == "1":
                        updateCustomer(index)
                        break
                    elif sourceCustomerUserMenu == "2":
                        removeCustomer(index)
                        break
                    elif sourceCustomerUserMenu == "0":
                        break
                else:
                    print("选择操作无效！请重新再次选择！！！")
        else:
            print("没有查询到【%s】客户信息,请重新选择!!!" %sourceCustomerUserSelect)
def updateCustomer(CustomerName):
    CustomerName["Name"] = nullDispose(CustomerName["Name"],"请输入修改姓名[回车不修改]:")
    CustomerName["Gender"] = nullDispose(CustomerName["Gender"], "请输入修改性别[回车不修改]:")
    CustomerName["Phone"] = nullDispose(CustomerName["Phone"], "请输入修改电话[回车不修改]:")
    CustomerName["Wechat"] = nullDispose(CustomerName["Wechat"], "请输入修改微信[回车不修改]:")
    CustomerName["QQ"] = nullDispose(CustomerName["QQ"], "请输入修改QQ[回车不修改]:")
    print("修改成功!!!!")

def removeCustomer(CustomerName):
    customerList.remove(CustomerName)
    print("【%s】删除成功!!" %(CustomerName["Name"]))

def nullDispose(disposeName,info):

    result = input(info)
    if len(result) > 0:
        return result        # 输入
    else:
        return disposeName  # 未输入

3、程序测试结果

1、运行程序

**************************************************
欢迎使用【客户管理系统V0.1版本】
**************************************************

1. 添加客户信息
2. 查看所有客户信息
3. 查询客户信息

0. 退出系统
**************************************************
请输入选择您的指令:

2、添加客户信息

**************************************************
请输入选择您的指令:1
**************************************************
功能: 添加客户信息
请输入客户姓名:112
请输入客户性别:112
请输入客户电话:112
请输入客户微信:112
请输入客户QQ:112

添加【112】客户信息成功!!!!

3、查看所有客户信息

**************************************************
请输入选择您的指令:2
**************************************************
功能: 查看所有客户信息
姓名			性别			电话			微信			QQ			
==================================================
111			111			111			111			111
112			112			112			112			112
0. 退出查看:

4、修改客户信息

**************************************************
请输入选择您的指令:3
**************************************************
功能: 查询客户信息
请输入要查询的客户名称:111
姓名			性别			电话			微信			QQ			
==================================================
111			111			111			111			111

1. 修改客户	2. 删除客户	0. 返回上级:1
请输入修改姓名[回车不修改]:222
请输入修改性别[回车不修改]:
请输入修改电话[回车不修改]:
请输入修改微信[回车不修改]:
请输入修改QQ[回车不修改]:
修改成功!!!!

5、删除客户

**************************************************
请输入选择您的指令:3
**************************************************
功能: 查询客户信息
请输入要查询的客户名称:222
姓名			性别			电话			微信			QQ			
==================================================
222			111			111			111			111

1. 修改客户	2. 删除客户	0. 返回上级:2
【222】删除成功!!

十一、函数进阶

1、函数多返回值

如果一个函数有多个返回值，需要定义多个变量来接受函数的返回值。

案例：

def t1_func():
    return 1, 2, 3

a, b, c = t1_func() #定义多个变量接受函数的返回值
print(a, b, c)

输出结果如下：

1 2 3

2、缺省参数

• 定义函数时 可以给某个参数 指定一个默认值 具有默认值的参数叫做 缺省参数；
• 函数的缺省参数，将常见的值设置为参数的缺省值，从而简化函数调用；

举例： 定义形参gender缺省参数值为True

def print_info(name, gender=True):
"""
在定义函数时 形参变量使用 赋值变量 赋予默认值
"""
    gender_txet = '男生'

    if not gender: 
        gender_txet = '女生'

    print('%s 是 %s' %(name, gender_txet))
    
# 定义缺省参数后 调用函数时如果 不指定参数 默认值为True
print_info('小明')

输出结果如下：

小明 是 男生

缺省参数注意事项：

函数定义时 带有缺省参数的形参 应该放到最后 如下是错误的定义：

# 错误定义
def test(name, age=16, height):

多个缺省参数的的调用:

def test(name, gender='男', age=26):
    print('%s %s %d' % (name, gender, age))

# 只想要修改age的默认值为36 其他保持默认；
# 可以在调用函数时 使用age=36 这种方法实现效果；
test('小明', age=36)

3、关键字传参

函数调用通过"键=值"形式传递参数，同时也清除了参数的顺序需求。

def t1_func(name ,age):
    print(f"名字: {name}, 年龄: {age}")

t1_func(age="16", name="zhangsan") # 不用考虑参数顺序

输出结果如下：

名字: zhangsan, 年龄: 16

4、多值传参

有时可能需要 一个函数 能够处理的参数 个数 是不确定的 这个需求情况下 就可以使用多值参数；

• Python中 定义多值参数 的 两种方法：
  • 参数名前增加 一个*可以接受元组
  • 参数名前增加 二个*可以接受字典
• 多值参数命名规则 常常使用以下两个名字
  • *args: 存放 元组 的参数；
  • **wkargs：存放 字典 的参数；

def test(num, *args, **wkargs):
    print(num)
    print(args)
    print(wkargs)


test(1, 2, 3, 4, 5, name='小明', age='20')

输出结果如下：

1
(2, 3, 4, 5)
{'name': '小明', 'age': '20'}

案例：将传递的所有数字累加

需求如下：

• 定义一个函数 sum_numbers，可以接受任意多个整数；
• 功能要求：将传递的所有数字累加 并且返回累加结果；

def sum_numbers(*args):
    num = 0
    print(args)

    for i in args:
        num += i

    return num


result = sum_numbers(1, 2, 3)
print(result)

输出结果如下：

(1, 2, 3)
6

5、元组和字典的拆包

• 在调用带有多值参数的函数时，如果希望

  • 将一个 元组变量 直接传给 args
  • 将一个 字典变量 直接传给 kwargs

• 就可以使用 拆包 简化参数的传递，拆包的方式是：

  • 在 元组变量前 增加 一个 *
  • 在 字典变量前 增加 二个*

举例：

def demo(*args, **kwargs):
    print(args)
    print(kwargs)

# 需要将一个元组变量/字典变量传递给函数对应的参数
gl_nums = (1, 2, 3)
gl_xiaoming = {'name': 'xiaoming', 'age': '22'}

# 错误案例
# demo(gl_nums,gl_xiaoming)
# 真确案例 相当于 demo(1, 2, 3, name='xiaoming', age='16') 简化代码量
demo(*gl_nums,**gl_xiaoming)

输出结果如下：

(1, 2, 3)
{'name': 'xiaoming', 'age': '22'}

6、函数的递归

函数调用自身的 编程技巧 称为递归

• 一个函数 内部 调用自己
  • 函数内部可以调用其他函数，当然也可以调用自己
• 代码特点
  • 函数内部的 代码 是相同的 只是针对 参数不同处理的结果不同。
  • 这个非常重要 ，通常被称为递归的出口， 否则 会出现死循环

案例：

1、简单示例

def sum_number(num):
    print(num)
    # 递归出口 当参数满足某个条件时 不在执行函数
    if num == 1:
        return 
    # 调用自己
    sum_number(num - 1)
    
sum_number(3)

输出结果如下：

3
2
1

2、计算1+1+2…+100的和

def sum_numbers(num):
    if num == 1:
        return 1
    temp = sum_numbers(num -1)
    return  num + temp


result = sum_numbers(100)
print(result)

输出结果如下：

5050

7、函数作为参数传递

将函数作为参数传入到另一个函数中

• test_func需要一个函数作为参数传入，这个函数需要接受两个数字进行计算，计算逻辑由这个被传入函数决定。
• compute函数接受两个数字进行计算，compute函数作为参数传递给test_func()函数使用。
• 最终，在test_func函数内部，由传入compute函数，完成了数字计算操作。
• 所以这是一种，计算逻辑的传递，而非数据的传递。

def test_func(compute):
    result = compute(1, 2)
    print(result)

def compute(x, y):
    return x + y

test_func(compute)

输出结果如下：

3

如上代码那样，不仅仅是相加、相减、相除等，任何逻辑都可以自行定义，并作为函数传入。

8、lambda匿名函数

• lambda匿名函数用于临时构建一个函数，只用一次的场景。

• lambda匿名函数中，函数体只能写一行代码。

基本语法如下：

lambda 传入参数: 函数体(一行代码)

案例：

test = lambda x, y: x + y
print(test(2,5))

输出结果如下：

7

十二、文件操作

类型	语法	解释
打开文件	文件对象 = open(name, mode, encoding)	打开文件，获取文件对象
读取文件	文件对象.read(num)	读取指定字节内容，不指定num读取所有
	文件对象.readlines()	读取所有内容，返回一个列表
	文件对象.readline()	读取一行内容，常配合for循环遍历文件内容
关闭文件	文件对象.close()	关闭文件对象
	with open() as f:	通过with open语法打开文件，结束后可以自动关闭文件对象
写入文件	文件对象.write(“内容”)	内容写入到内存中，如果文件存在则情况内容，添加写入内容
写入文件、刷新文件	文件对象.flush()	将内存内容写入到磁盘中
追加内容	定义文件对象时mode模式指定’a’即可	模式指定’a’即追加内容，其他操作和写入文件一致

1、打开文件

打开文件需要使用open()函数，基本语法如下：

open(name, mode, encoding)

• name：打开文件的名字(或者打开文件的路径)
• mode：设置打开文件的模式：只读、写入、追加等。
• encoding：设置编码格式(推荐使用UTF-8)

模式	描述
r	以只读方式打开文件，默认模式
w	以写入方式打开文件，文件不存在，则自动创建
a	打开一个文件用于追加，如果文件存在直接追加，如果文件不存在，则创建新的文件

示例代码：

fw = open("test.txt", 'w', encoding='utf-8')

2、读取文件

1、read()：读取指定字节内容或所有内容

示例代码：

fw = open('测试.txt', 'r', encoding='UTF-8')

print(fw.read(10))  # 只读取10字节内容
print(fw.read())    # 读取所有内容(会接着上面内容继续往下读取内容)

2、readlines()方式：读取所有内容，返回一个列表

示例代码：

fw = open('测试.txt', 'r', encoding='UTF-8')

result = fw.readlines()
print(type(result))

输出结果如下：

<class 'list'>

3、readline：读取一行内容

示例代码：

fw = open('测试.txt', 'r', encoding='UTF-8')

print(f"第一行内容：{fw.readline()}")
print(f"第二行内容：{fw.readline()}")

使用for循环遍历文件内容：

fw = open('测试.txt', 'r', encoding='UTF-8')

for line in fw:
    print(line)

4、with open() 方式关闭文件

示例代码：

with open('测试.txt', 'r', encoding='UTF-8') as f:
    print(f.read())

3、写入文件

1、wirte()：内容写入到内存中，如果文件存在则情况内容，添加写入内容

示例代码：

fw = open("测试.txt", 'w', encoding='UTF-8')
fr = open("测试.txt", 'r', encoding='UTF-8')
fw.write('Qin Ziteng is a handsome boy')
print(fr.read())

问：为什么没有任何返回内容？

答：因为只写入到了内存，没有从内存写入到磁盘中，所以没有输出任何内容，但是程序退出后会也会写入到磁盘中。

2、flush()：刷新文件，将内存内容写入到磁盘中

示例代码：

fw = open("测试.txt", 'w', encoding='UTF-8')
fr = open("测试.txt", 'r', encoding='UTF-8')
fw.write('Qin Ziteng is a handsome boy')
fw.flush()
print(fr.read())

输出结果如下：

Qin Ziteng is a handsome boy

4、追加文件

示例代码：

fw = open("测试.txt", 'w', encoding='UTF-8')  # 定义写入对象
fr = open("测试.txt", 'r', encoding='UTF-8')  # 定义只读对象
fa = open("测试.txt", 'a', encoding='UTF-8')  # 定义追加对象
fw.write('Qin Ziteng is a handsome boy\n')   # 写入一句话
fa.write('Qin Ziteng is a handsome boy ....')  # 追加一句话(不会清空文件原内容)
fw.flush()
fa.flush()
print(fr.read())

输出结果如下：

Qin Ziteng is a handsome boy
Qin Ziteng is a handsome boy ....

5、文件综合案例

需求分析：如下有一份账单buil.txt 文件

• 将内容写入到buil.txt.bak文件作为备份
• 同时将标记测试的数据丢弃掉

周杰轮,2022-01-01,100000,消费,正式
周杰轮,2022-01-02,300000,收入,正式
周杰轮,2022-01-03,100000,消费,测试
林俊节,2022-01-01,300000,收入,正式
林俊节,2022-01-02,100000,消费,测试
林俊节,2022-01-03,100000,消费,正式
林俊节,2022-01-04,100000,消费,测试
林俊节,2022-01-05,500000,收入,正式
张学油,2022-01-01,100000,消费,正式
张学油,2022-01-02,500000,收入,正式
张学油,2022-01-03,900000,收入,测试
王力鸿,2022-01-01,500000,消费,正式
王力鸿,2022-01-02,300000,消费,测试
王力鸿,2022-01-03,950000,收入,正式
刘德滑,2022-01-01,300000,消费,测试
刘德滑,2022-01-02,100000,消费,正式
刘德滑,2022-01-03,300000,消费,正式

实现代码如下：

fr = open("buil.txt", 'r' ,encoding='UTF-8')
fw = open("buil.txt.bak", 'w' ,encoding='UTF-8')

for line in fr:
    line = line.strip()       # 去除空格
    lines = line.split(',')   # 切割 得到数组
    if lines[4] == "正式":
        fw.write(f'{line}\n')
    else:
        continue
fr.close()
fw.close()

十三、异常处理

当检测到一个错误时，Python解释器就无法继续执行了，反而出现一些错误的提示，这就是所谓的 “异常”，也就是我们说的常说的BUG。

1、异常的捕获

捕获异常的作用在于：提前假设某处会出现异常，做好提前准备，当真的出现异常的时候，可以有后续手段。

基本语法：

try:
	可能发生错误的代码段
except:
    如果出现异常执行的代码

案例：

1、捕获所有异常

try:
    fr = open('centos.txt', 'r', encoding='UTF-8')
except:  
    print('打开centos.txt文件失败')

输出结果如下：

打开centos.txt文件失败

捕获所有异常第二种写法，使用Exception 表示所有异常：

try:
    fr = open('centos.txt', 'r', encoding='UTF-8')
except Exception as e:
    print(f'ERROR: {e}')
    print('捕获到异常了')

输出结果如下：

ERROR: [Errno 2] No such file or directory: 'centos.txt'
捕获到异常了

2、捕获指定异常，只捕获 NameError 异常

try:
    print(name)
except NameError as e:    # 只捕获NameError异常
    print(f"ERROR: {e}") 
    name = "zhangsan"    # 捕获到变量未定义,在except里面定义变量
    print(name)

输出结果如下：

ERROR: name 'name' is not defined
zhangsan

3、捕获多个异常，捕获NameError 和 FileNotFoundError 异常

try:
    print(name)
except (Exception, FileNotFoundError) as e:
    print(f'ERROR: {e}')

输出结果如下：

ERROR: name 'name' is not defined

2、try…else 和 finally结构

try…else结构基本语法：

try:
	可能发生错误的代码段
except:
    如果出现异常执行的代码
else:
	如果没有出现异常执行的代码

finally结果基本语法：

try:
	可能发生错误的代码段
except:
    如果出现异常执行的代码
else:
	如果没有出现异常执行的代码
finally:
	无论有没有出现异常都要执行的代码

示例代码：

try:
    fr = open('centos2.txt', 'r', encoding='UTF-8')
except Exception as e:  # 出现异常执行
    print(f'ERROR: {e}')
    fr = open('cento2.txt', 'w', encoding='UTF-8')
else:                   # 没有出现异常执行
    print('没有出现异常')
finally:
    fr.close()          # 无论有没有异常,都要执行关闭文件操作

输出结果如下：

ERROR: [Errno 2] No such file or directory: 'centos2.txt'

3、异常的传递性

异常时具有传递的，示例代码如下：

def func1():
    print('func1函数开始....')
    num = 1 / 0     # 肯定报异常
    print('func01函数结束.....')
    
def func2():
    print('func2函数开始.....')
    func1()
    print('func2函数结束.....')
    
def main():
    try:
        func2()
    except Exception as e:
        print(f'捕获到异常:{e}')

main()

当函数func1中发生异常，并且没有捕获处理这个异常的时候，异常会传递到函数func2，当func2函数也没有捕获到这个异常的时候，main函数会捕捉到这个异常，这就是异常的传递性。

注意：当所有函数都没有捕捉到异常的时候，程序就会报错。

十四、模块

1、导入模块

模块的作用：模块就是一个python文件，里面有类、函数、变量，我们可以拿过来用(导入模块去使用)

基本语法：

[from 模块名] import [模块|类|变量|函数|*] [as 别名]

示例代码：

1、导入time模块

import time
time.sleep(100)  # 使用

2、只导入time模块中的sleep功能

from time import sleep
sleep(100)  # 使用

3、导入time模块所有功能

from time import *
sleep(100) # 使用

4、导入time模块并设置别名

from time import sleep as t1
t1(100)  # 使用

2、自定义模块

自定义模块就是自己创建一个py文件，py文件中写一些自定义的功能，然后通过import导入到其他py中使用这些自定义功能。

如上图所示：在funcs.py文件中自定义了t1_func函数，而在test.py文件中导入了这个函数并使用了。

3、__main__变量

__main__是一个特殊的变量，用于指示当前模块是否正在被直接执行。当一个Python文件被直接执行时，其__name__变量会被设置为"__main__"，这样我们可以通过检查__name__来确定代码是被导入还是直接执行的。

示例代码：

def t1_func(num1, num2):
    sum = num1 + num2
    print(sum)
    return sum

if __name__ == "__main__":  # 表示判断一下是否是其他文件调用，如果是则不执行if下面的代码
    t1_func(100,100)

4、__all__变量

__all__是一个特殊的变量，用于指定一个模块中哪些成员可以被导入。但仅限于使用from module import *语句

示例代码：

__all__ = ['t1_func']   # 表示使用import * 导入所有模块时只能t1_func函数

def t1_func(num1, num2):
    sum = num1 + num2
    print(sum)
    return sum

def t2_func(num1, num2):
    sum = num1 - num2
    print(sum)
    return sum

十五、包

1、包概念及创建包

问：什么是包？

答：包就是一个文件夹，里面可以存放多个Python模块(py文件)，通过包，在逻辑上将一批模块归为一类，方便使用。

在包的文件夹中包含了一个__init__.py 文件，通过这文件来表示此文件夹是一个python包，而非普通的文件夹。

创建流程，以PyCharm演示：

文件 > 新建 > Python软件包 创建完成后该目录中会存在__init__.py 文件。

可以在此文件中定义 __all__ 变量，在控制那些模块可以被导入，仅限于from Package import *方式。

__all__ = ['func_1', 'func_2']

2、导入包

示例代码如下：

1、导入Package包func_1模块

import Package.func_1     
Package.func_1.t1_func()  # 使用

2、使用from方式导入Package包中func_1模块

from Package import func_1
func_1.t1_func() # 使用

3、导入Package包中func_1模块中的t1_func功能

from Package.func_1 import t1_func
t1_func() # 使用

4、导入Package包下所有模块

from Package import *
func_1.t1_func() # 使用

3、安装第三方包

示例代码：

1、正常下载安装requests包

pip install requests

2、使用国内源下载安装requests包

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple requests 

3、添加超时时间，下载一些较大的包时经常使用

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple elasticsearch --timeout 1800

4、查看当前环境已经安装的第三方包

pip list