python 精简平台 python简易

最近学习了python入门，做一些必要的笔记，一来是对自己学习的知识的巩固，二来对有同样问题的人有参考作用

---

文章目录

• 一 环境配置
• 二 变量和简单数据类型
• 三 数据类型转化与运算
• 四 列表
• 五 程序控制结构
• 六 字典
• 七 集合
• 八 函数
• 九 类
• 十 异常
• 十一 文件操作
• 十二 测试代码
• 十三 总结

---

本教程内容和 Eric Matthes的<<Python编程从入门到实践>>章节对应。
基于Python3，使用的编译器是Pycharm。

一 环境配置

1、去python官网下载安装文件
2、点击开始安装，一直下一步就可。。。
3、在命令行输入python，如果出现对应的信息，证明安装正确

二 变量和简单数据类型

1、输入和输出

# 输入输出函数

# print函数
print('zhangsan','lisi','wangwu')

# 取消换行
print('firstline',end='')
print('secondline')

# 更换分隔符
print('zhangsan','lisi','wangwu')
print('zhangsan','lisi','wangwu',sep='@')

# input函数
greetone = input('请输入数据: ')
print('您输入的内容是: ',greetone)

# input返回的数据都是str型
greettwo = input('请输入数据: ')
print('内容类型是: ',type(greettwo))

2、字符串

（1）字符串常规操作

# 字符串
name = 'hello world!'

# 指定位置的数据
print(name[1])

# 指定范围的数据
print(name[:2])
print(name[4:7])
print(name[6:])
print(name[:])

# 拼接字符串
first_name = 'LeBron'
last_name = 'James'
new_name = first_name + ' ' + last_name
print(new_name)

# 字符串替换
replace_name = new_name.replace('James','Hardon')
print(replace_name)

（2）字符串进阶操作

# 转义字符串
zy_str01 = 'hello \n world'
zy_str02 = 'hello\000world'
print(zy_str01)
print(zy_str02)

# 取消转义
nozy_str = r'hello \n world'
print(nozy_str)

# 字符串运算
# * 重复
ys_str = 'jr'
print(ys_str * 2)

# in
print('j' in ys_str)

# not in
print('r' not in ys_str)

# 字符串内置函数
nz_str = 'hello World !'
print(len(nz_str))
print(nz_str.lower())
print(nz_str.upper())
print(nz_str.count('l'))
print(nz_str.swapcase())
print(nz_str.index('l'))

3、整型

# 整数四则运算
intone = 5
inttwo = 3
print(intone + inttwo)
print(intone - inttwo)
print(intone * inttwo)
print(intone / inttwo)
print(intone ** inttwo)
print(intone % inttwo)

4、浮点型

# 浮点数四则运算
floatone = 5.2
floattwo = 3.3
print(floatone + floattwo)
print(floatone - floattwo)
print(floatone * floattwo)
print(floatone / floattwo)
print(floatone ** floattwo)
print(floatone % floattwo)

5、布尔型

# 布尔型
a = 2
b = 3
print(a == b)
print(1 == True)
print(0 == False)

特别地，在python中，0==False、1==True。

三 数据类型转化与运算

1 、类型转换

基本类型之间可已进行相互转换，前提是原则上可以相互转换。

# 数据类型转换

# 字符串型强制类型转换
ione = 123
fone = 123.456
bone = True

print(str(ione))
print(str(fone))
print(str(bone))

# 整型强制类型转换
ftwo = 123.456
btwo = True
stwo = "125"

print(int(ftwo))
print(int(btwo))
print(int(stwo))

# 浮点型强制类型转换
ithree = 123
bthree = True
sthree = "12.34"

print(float(ithree))
print(float(bthree))
print(float(sthree))

# 布尔型强制类型转换
ifour = 1
print(1 == True)

结论:

• 整型 浮点型 布尔型都能转为字符串类型
• 将浮点型强转为整型，默认小数点之后全部去掉，不是四舍五入
  布尔类型强制转为整型，默认将True转为1，False转为0
  字符串类型墙砖为整型，字符串必须全部是数字
• 整型强转为浮点型，默认在在后面添加小数点和0
  布尔类型强转为浮点型，默认将True转为1.0，False转为0.0
  字符串类型转为浮点型，必须是 整型.整型的形式
• 整型转为布尔类型，默认1转为True,0转为False
  一般不会出现其他类型转布尔类型，都是在比较或者判断的时候用到

2 、基本运算符-01

# 基本运算符

"""
+ 加 两数相加或者字符串拼接
- 减
* 成
/ 除
% 取余
// 取商的整数
** 幂运算
"""

one = 23
two = 3
print(one + two)
print("hello" + "world")
print(one - two)
print(one * two)
print(one / two)
print(one % two)
print(one // two)
print(one ** two)

# 赋值运算符

"""
= 赋值
+= 加法赋值 a += b 等同于 a = a+b
-= 减法赋值
*= 乘法赋值
/= 除法赋值
%= 取余赋值
//= 取商的整数赋值
**= 幂赋值运算
"""

onedemo = 13
twodemo = 2
onedemo += twodemo
print(onedemo)
onedemo -= twodemo
print(onedemo)
onedemo *= twodemo
print(onedemo)
onedemo /= twodemo
print(onedemo)
onedemo %= twodemo
print(onedemo)
onedemo //= twodemo
print(onedemo)
onedemo **= twodemo
print(onedemo)

3 、基本运算符-02

# 比较运算符
# 比较运算符的返回值全部为布尔类型

"""
==  值比较
!=
>
<
>=
<=
"""
one = 2
two = 1
print(one == two)
print(one != two)
print(one > two)
print(one < two)
print(one >= two)
print(one <= two)

# 身份运算符

"""
is 表示是否是同一个对象的引用
is noe 表示是否不是同一个对象的引用
"""
listone = [1,2,3]
listtwo = [1,2,3]
print(listone is listtwo)
print(listone is not listtwo)

# 逻辑运算符

"""
and 同真则真
or 有真则真
not 不真则假 不假则真
"""

print(True and True)
print(True or False)
print(not True)

4、运算符优先级

原则:

• 运算级高的先执行，低的后执行
• 相同优先级，从左向右执行
• 四则运算，先乘除后加减

print((1 < 5) or (1 == 3))
print(3 + 2 * (3 == 5) / 2)
print((1 + 2) * (3 == 4 / 5))

优先级由高到低排序:

括号 > 幂 > 正负号 > 乘、除、取余、取商 > 比较运算符 > 赋值运算 > 逻辑运算

四 列表

列表由一系列按特定顺序排列的元素组成。

1、列表的增删改查操作

（1）列表基本操作 – 增

# 列表基本操作 -- 增
animal = ["老鹰","狮子","海豚","大象"]

# append() 在尾部追加单个元素
animal.append("外星人")
print(animal)

# extend() 在尾部追加多个元素
animal.extend(["小虎","老鼠"])
print(animal)


# extend() 在指定位置插入元素
animal.insert(1,"大熊猫")
print(animal)

# '+' 对列表项进行合并
newanimal = ["山羊","鲤鱼"] + ["蚂蚁","喜鹊"]
print(newanimal)

（2）列表基本操作 – 查

# 列表基本操作 -- 查
animal = ["老鹰","狮子","海豚","大象"]

# 根据索引查找元素
print(animal[1])

# 根据值查找索引
print(animal.index("狮子"))
print(animal.index("狮子",2)) # 从下标 2 开始查找

# 判断元素是否在列表中
print("老鼠" in animal)

（3）列表基本操作 – 改

# 列表基本操作 -- 改
animal = ["老鹰","狮子","海豚","大象"]

# 通过索引下标进行修改
animal[1] = "金丝猴"
print(animal)

（4）列表基本操作 – 删

# 列表基本操作 -- 删
animal = ["老鹰","狮子","海豚","大象"]

# 使用 pop() 删除指定下标的列表项， 并返回删除的数据
del_element = animal.pop(1)
print(del_element)
print(animal)

# 使用 remove() 删除指定值的列表项
del_element = "老鹰"
animal.remove(del_element)
print(del_element)
print(animal)

# 使用 del() 删除指定索引范围的列表
del animal[0:2]
print(animal)

# 使用 clear() 将列表清空
animal.clear()
print(animal)

2、切片

切片 就是取列表的一部分。

# 切片 -- 列表的一部分
players = ['yaoming','xuxin','uzi','yangguo','liuxiang']
print(players[0:2])
print(players[:2])
print(players[2:4])
print(players[2:5])
print(players[2:])
print(players[-3:])
print(players[:])

# 复制列表
# 不是 new_players = players
new_players = players[:]
print(new_players)

3、列表排序

本小结介绍一些常见的列表排序算法。

# 列表的排序
bicycles = ['trek','cannondale','redline','speciallized']
print(bicycles)

# 永久排序
bicycles.sort()
print(bicycles)

# 逆序
bicycles.sort(reverse=True)
print(bicycles)

# 临时排序
# 正序
print(sorted(bicycles))
print(bicycles)

# 逆序
print(sorted(bicycles,reverse=True))
print(bicycles)

# 将列表元素翻转
bicycles.reverse()
print(bicycles)

# 按照字符串长度进行排序
bicycles.sort(key = len)
print(bicycles)

# 字符串大写转小写再排序
bicycles.sort(key = str.lower)
print(bicycles)

# 获取列表长度
print(len(bicycles))

4、列表解析

# 列表解析
squares = [value ** 2 for value in range(1,11)]
for square in squares:
    print(square)

''' 
要使用上述的这种语法，首先指定一个描述性的列表名，如squares
然后，指定一个左方括号并定义一个表达式，用于生成你要存储到列表中的值，如value ** 2
接下来，编写一个for循环，用于给表达式提供值
最后，加上右方括号
'''

5、元组

元组是集合内元素不可改变的列表。

# 列表内元素不可变的特殊列表
dimensions = (20,30,25)
print(dimensions)
print(dimensions[0])

# dimensions[1] = 50

# 修改元组变量的值
# 虽然不能修改元组内元素的值，但是可以修改元组变量的值
dimensions = (30,40,80)
print(dimensions)
print(dimensions[0])

五 程序控制结构

1、顺序结构

就是正常的从上到下地执行代码。

num_01 = 12
num_02 = 23
sum_01 = num_01 + num_02
print("两数之和为：",sum_01)

2、if分支结构

# if单分支结构
score = 90
if score >= 90:
    print("获得奖学金")

# if双分支结构
num = 15
if num % 2 == 0:
    print("数字",num,"是偶数")
else:
    print("数字",num,"是奇数")

# elif多分支结构
score = 70
if score >= 90:
    print("奖励笔记本电脑")
elif score >= 80:
    print("奖励python入门教程")
elif score >= 70:
    print("奖励一支钢笔")
else:
    print("参加补考")

# 多测试语句
students = ["zhangsan","lisi","wangwu"]
if "xiaohong" not in students:
    print("不是本校学生")
if "xiaoli" not in students:
    print("不是本校学生")

3、循环结构

（1）for循环

# 循环结构

# for循环
for letter in "python":
    print("当前的字母是：",letter)

# range()函数返回的是一个可迭代的对象，并不是一个列表
print(range(10))
for i in range(10):
    print("i like python!")

# 案例 九九乘法表
for i in range(1,10):
    for j in range(1,i+1):
        print(j,"x",i,"=",j*i," ",end="")
    print()

（2）while循环

# while循环
flag = True
count = 0
while(flag):
    print("我爱python",count+1,"遍!")
    count += 1
    if count >= 10:
        flag = False

（3）跳出循环

import random
# 跳出循环

#  break 跳出循环
count = 0
while True:
    print("我爱python",count+1,"遍!")
    count += 1
    if count >= 10:
        break

# continue 跳出本轮循环，开始下一轮
# 不输出数字5
for i in range(1,10):
    if i == 5:
        continue
    else:
        print(i)

4、循环使用 else 语句

在 python 中，for … else 表示这样的意思：for 中的语句和普通的没有区别，else 中的语句会在循环正常执行完（即 for 不是通过 break 跳出而中断的）的情况下执行，while … else 也是一样。

举例：

for num in range(10,20):  # 迭代 10 到 20 之间的数字
   for i in range(2,num): # 根据因子迭代
      if num%i == 0:      # 确定第一个因子
         j=num/i          # 计算第二个因子
         print '%d 等于 %d * %d' % (num,i,j)
         break            # 跳出当前循环
   else:                  # 循环的 else 部分
      print num, '是一个质数'

5、综合案例

本例子是一个猜数游戏。

import time
import random

# 猜数游戏
print("-------猜数字-------")
time.sleep(1)
print("----游戏开始了----")
for i in range(1,4):
    print(4-i,end=" ")
    time.sleep(1)
print("GO!!")

num = random.randint(0,9)
print("随机数已经出现")

for i in range(3):
    guess = int(input("请输入您猜测的数字："))
    if guess > num:
        print("您猜大了")
    elif guess < num:
        print("您猜小了")
    else:
        print("恭喜您，猜对了")
        print("奖励一个大嘴巴子")
        break

六 字典

字典是可变的序列，可以存储在各种数据类型，用大括号表示；字典中放的是键值对，键值之间用冒号隔开，键值对之间用逗号隔开；通过键访问值的数据结构，字典是python中唯一的映射。

1、创建字典

# 创建字典
dics = {"校长":"张三","书记":"李四"}
print(dics)

# 根据键获取值
print(dics["校长"])

2、字典的增删改查操作

（1）字典基本操作 – 增

# 字典的基本操作 -- 增
dics = {"小明":1234,"小虎":6325,"小龙":7485}
print(dics)

# 通过赋值添加字典元素
dics["阿水"] = 6666
print(dics)

# 通过setdefault()添加字典元素
dics.setdefault("左手",665)
print(dics)

（2）字典基本操作 – 查

# 字典的基本操作 -- 查
dics = {"小明":1234,"小虎":6325,"小龙":7485}
print(dics)

# 通过指定键，查找对应值
# 如果键不存在，报错
print(dics["小明"])
print(dics["小"])

# 通过 get() 函数，查找对应值
# 如果键不存在，返回 None
print(dics.get("小明"))
print(dics.get("小"))

# 判断字典的键是否存在
print("小明" in dics.keys())

# 判断字典的值是否存在
print(1234 in dics.values())

（3）字典基本操作 – 改

# 字典的基本操作 -- 改
dics = {"小明":1234,"小虎":6325,"小龙":7485}
print(dics)

# 通过赋值修改字典元素
dics["小明"] = 6398
print(dics)

# 通过 update() 实现对键值对的更新
up_dic = {"左手":3692,"宁人":6996}
dics.update(up_dic)
print(dics)

（4）字典基本操作 – 删

# 字典的基本操作 -- 改
dics = {"小明":1234,"小虎":6325,"小龙":7485}
print(dics)

# 通过删除值删除键值对
del(dics["小虎"])
print(dics)

# 通过删除键删除键值对
dics.pop("小虎")
print(dics)

# 删除字典中最后一个键值对
dics.popitem()
print(dics)

# 清空所有键值对
dics.clear()
print(dics)

3、遍历字典

# 遍历字典
persion = {"name":"xiaohong","age":18,"height":175}

# 遍历字典中的键值对
for key,value in persion.items():
    print(key,value)

# 遍历字典中的键
for key in persion.keys():
    print(key)

# 遍历字典中的值
for value in persion.values():
    print(value)

4、字典嵌套

# 字典嵌套
# 嵌套多种多样，这里列举常见例子，大家可以举一反三
stu01 = {"tel":18848153347,"age":18,"height":175}
stu02 = {"tel":13448153385,"age":19,"height":178}
stu03 = {"tel":13548153383,"age":19,"height":180}

# 字典和列表的嵌套
students = [stu01,stu02,stu03]
for student in students:
    for key,value in student.items():
        print(key,value)

# 字典和字典的嵌套
students = {"小明":stu01,"小虎":stu02,"小狗":stu03}
for name,info in students.items():
    print(name,":",info)

5、小练习 – 学生信息关系系统

# 小练习 学生信息管理系统
stu1 = {"name":"小张","age":10,"gender":"male","grand":"3(1)"}
stu2 = {"name":"小龙","age":13,"gender":"female","grand":"3(2)"}
stu3 = {"name":"小赵","age":12,"gender":"male","grand":"3(4)"}
stu4 = {"name":"小王","age":11,"gender":"female","grand":"3(6)"}
students = [stu1,stu2,stu3,stu4]

while True:
    print("\n\n---------学生信息管理系统----------")
    print("1.增加学生\n2.删除学生\n3.修改学生\n4.查找学生\n5.退出程序")
    num = int(input("请输入您要操作的编号: "))

    # 添加学生
    if num == 1:
        # 让用户输入信息
        name = input("请输入要添加的学生的姓名:")
        age = int(input("请输入要添加的学生的年龄:"))
        gender = input("请输入要添加的学生的性别:")
        grand = input("请输入要增加的学生的班级")

        # 将学生信息添加到字典
        stu5 = {"name":name,"age":age,"gender":gender,"grand":grand}
        students.append(stu5)

    # 删除学生
    elif num == 2:
        print("1.按照序号删除\n2.全部删除")
        choose = int(input("请选择操作的序号: "))
        if choose == 1:
            stu_num = int(input("请输入要删除的学生的编号: "))
            students.pop(stu_num - 1)
            print("该学生已被删除")
        elif choose == 2:
            yes_no = input("确定要清空所有数据吗? [yes/no]: ")
            if yes_no == "yes":
                students.clear()
                print("数据已清空")
        else:
            print("选择错误!")

    # 修改学生
    elif num == 3:
        print("当前共有",len(students),"个学生")
        stu_num = int(input("请输入要修改的学生的编号: "))
        students.pop(stu_num - 1)
        # 让用户输入信息
        name = input("请输入要添加的学生的姓名:")
        age = int(input("请输入要添加的学生的年龄:"))
        gender = input("请输入要添加的学生的性别:")
        grand = input("请输入要增加的学生的班级")
        # 将学生信息添加到字典中
        stu5 = {"name":name,"age":age,"gender":gender,"grand":grand}
        students.insert(stu_num - 1,stu5)

    # 查看学生
    elif num == 4:
        print("当前共有", len(students), "个学生")
        # 遍历学生信息
        for student in students:
            print("-----------------------")
            for key,value in student.items():
                print(key,value)

    # 退出程序
    elif num == 5:
        yes_no = input("您确定要退出吗？[yes/no] ")
        if yes_no == "yes":
            print("程序已关闭,欢迎下次使用！")
            break

    else:
        print("\n您输入有误，请重新输入!")

七 集合

集合是可变的序列，可以存储各种数据类型，用大括号表示，集合具有无序性和不重复性。

1、创建集合

# 创建空集合
empty_set = set()
print(empty_set)
print(type(empty_set))

# 基于字符串创建集合
str_set = set("我喜欢python我们")
print(str_set)

# 基于元组创建集合
tuple_set = set((12,14,16,18))
print(tuple_set)

# 基于列表创建集合
list_set = set([12,15,18,19])
print(list_set)

# 基于集合创建集合
set_one = {"小狗","小虎","小龙堡"}
print(id(set_one))
print(set_one)
set_two = set(set_one)
print(id(set_two))
print(set_two)

2、集合的基本操作

（1）集合基本操作 – 增

# 集合的增删改查操作  -- 增加
# set_two 为可迭代对象
set_one = {"小红","小绿","小蓝"}

# 通过 update() 添加元素
# set_two = "你好"
set_two = {"i","like"}
set_one.update(set_two)
print(set_one)

# 通过 add() 添加元素
set_one.add("小橙")
print(set_one)

（2）集合基本操作 – 删

# 集合的增删改查操作  -- 删
set_one = {"小红","小绿","小蓝"}

# 通过 pop() 随机删除一个元素
del_element = set_one.pop()
print(del_element)
print(set_one)

# 通过 remove() 删除指定元素, 如果不存在,则报错
set_one.remove("小红")
print(set_one)

# 通过 discard() 删除指定元素, 如果不存在,则do nothing
set_one.discard("小橙")
print(set_one)

# 通过 clear() 清空集合元素
set_one.clear()
print(set_one)

（3）集合基本操作 – 改

# 集合的增删改查操作  -- 改
set_one = {"小红","小绿","小蓝"}

# set集合中的数据没有索引. 也没有办法去定位一个元素. 所以没有办法直接修改.
# 我们可以采用先删除后添加的方式来完成修改操作
set_one.remove("小红")
set_one.add("小橙")
print(set_one)

（4）集合基本操作 – 查

# 集合的增删改查操作  -- 查
set_one = {"小红","小绿","小蓝"}

# for 循环遍历
for element in set_one:
    print(element)

# in 判断是否在集合中
print("小橙" in set_one)

3、集合的基础操作

# 集合的基础运算
s1 = {1, 2, 3, 4}
s2 = {1, 2, 5, 6}

# 交集
sj = s1.intersection(s2)
print(sj)

# 并集
sb = s1.union(s2)
print(sb)

# 差集
sc = s1.difference(s2)
print(sc)

# 对等差分
sd = s1.symmetric_difference(s2)
print(sd)

八 函数

1、函数定义

# 定义函数
def greet_user(username):
    print("Hello,",username)

# 调用函数
greet_user("张三")

"""
说明:
    username 是形参，在定义函数时声明
    "张三" 是实参，在调用函数时传入
"""

2、传递实参

# 位置实参
# 实参和形参按照顺序一一对应
def describle_pet(pet_type,pet_name):
    """显示宠物的信息"""
    print("\nI hava a",pet_type,".")
    print("My",pet_type,"'s name is",pet_name.title(),".")

describle_pet("dog","leyan")

# 关键字实参
# 实参中将名称和值关联起来，无需考虑实参顺序
def describle_pet(pet_type,pet_name):
    """显示宠物的信息"""
    print("\nI hava a",pet_type,".")
    print("My",pet_type,"'s name is",pet_name.title(),".")

describle_pet(pet_name="leyan",pet_type="dog")

# 默认实参
# 使用默认值时，在形参列表中必须先列出来没有默认值的形参，再列出有默认值的形参。
# 因为即使有默认值，python依然将这个实参视为位置实参，放在第一个无法正确识别
def describle_pet(pet_name,pet_type="dog"):
    """显示宠物的信息"""
    print("\nI hava a",pet_type,".")
    print("My",pet_type,"'s name is",pet_name.title(),".")

describle_pet("leyan")

# 传递任意数量的实参
# 任意数量的位置实参
# *toppings 是一个元组
def make_pizza(size,*toppings):
    """概述要制作的披萨"""
    print("\nMaking a",str(size),"-inch pizza with the following toppings:")
    for topping in toppings:
        print("-",topping)

make_pizza(16,"mushrooms","pepperoni")

# 任意数量的关键字实参
def build_profile(first,last,**user_info):
    """创建一个字典看，其中 包含我们知道的有关用户的一切信息"""
    profile = {}
    profile["first_name"] = first
    profile["last_name"] = last
    for key,value in user_info.items():
        profile[key] = value
    return profile

user_profile = build_profile("albert","einstein",age="18",location="princeton")
print(user_profile)

使用哪种调用方式无关紧要，只要函数调用能够你希望的输出就行。

3、函数返回值

# 函数返回值

# 返回简单类型
def get_formatted_name(first_name,last_name):
    full_name = first_name + " " + last_name
    return full_name.title()

musician = get_formatted_name("jimi","hendrix")
print(musician)

# 返回字典
def build_persion(first_name,last_name):
    persion = {"first":first_name,"last":last_name}
    return persion

musician = build_persion("jimi","hendrix")
print(musician)

4、引用模块

（1）被引用的模块 import_demo.py

# 返回两数的最大值
def compare(numone,numtwo):
    if numone >= numtwo:
        return numone
    else:
        return numtwo

# 返回两数的平方的和
def square_sun(numone,numtwo):
    sum = numone ** 2 + numtwo ** 2
    return sum

（2）模块引用

# 导入整个模块
# 通过 模块名.方法名 来调用方法
import import_demo

bigger = import_demo.compare(12,45)
print(bigger)

# 导入特定的函数
# 直接通过函数名调用，注意防止与当前模块的方法名冲突
from import_demo import compare, square_sun

print(compare(12,45))
print(square_sun(1,3))

# 导入模块中所有的方法
# 极不建议使用，容易和当前模块的方法名冲突
from import_demo import *

print(compare(12,45))
print(square_sun(1,3))

# 起别名
# 给模块起别名
import import_demo as ipdemo

bigger = ipdemo.compare(12,45)
print(bigger)

# 给模块的函数起别名
from import_demo import compare as com, square_sun as ss

print(com(12,15))
print(ss(1,3))

5、值传递和引用传递

（1）数据类型的可变和不可变

不可变的数据类型：当该数据类型的对应变量的值发生了改变，那么它对应的内存地址也会发生改变。

可变数据类型：当该数据类型的对应变量的值发生了改变，那么它对应的内存地址不会发生改变。

数据类型	可变/不可变
整型	不可变
字符串	不可变
元组	不可变
列表	可变
集合	可变
字典	可变

（2）值传递和引用传递

# 值传递和引用传递
def change(x,y):
    x = 4
    y[0] = 143

# 值传递
# 不可改变数据类型对象，在函数里进行值修改，源对象不会被修改
one = 12

# 引用传递
# 可变数据类型对象，在函数里进行值修改，源对象也会被修改
two = [42,49,78]

change(one,two)
print(one)
print(two)

6、变量的作用域

作用域: 我们定义的变量所使用的范围。

# 局部变量: 定义在函数中，作用域在函数内部
def print_a():
    a = "hello world"
    print(a)

print_a()

# 全局变量: 定义在函数外，在全局都可以使用
num = 10
def chage_num():
    num = 20
    print(num + 20)

chage_num()
print(num)

# 当内部作用域想要修改外部作用域的变量时，就要用到 global 关键字
num = 10
def chage_num():
    global num
    num = 20
    print(num + 20)

chage_num()
print(num)

7、函数的嵌套和嵌套调用

任意一个函数定义完后，如果没有人通过名字调用它，就永远也不会执行；

对嵌套函数进行封装隐藏，避免代码和功能的重复，已达到灵活性、简洁性的目的。

• 函数的嵌套: 分为内函数和外函数，在函数内部还有函数
• 函数的嵌套调用: 在一个函数中调用了另一个函数

# 函数的嵌套
def funone():
    print("调用了外函数")

    def funtwo():
        print("调用了内函数")

    funtwo()

funone()

# 函数的嵌套调用
def first():
    print("first")

def second():
    print("second")
    first()

second()

8、递归函数

递归函数: 一个函数内部调用他自己 (递归调用的次数过多，会导致栈溢出)：

• 必须有一个明确的结束条件
• 每次进入更深一层递归时，问题规模相比上次都应有所减少
• 相邻两次重复之间有紧密的联系，前一次要为后一次做准备，通常前一次的输出就作为后一次的输入

# 递归函数

# 举例: 求 n! = n * (n-1) * ... * 2 * 1
def fact(n):
    if n == 1:
        return 1
    else:
        return n * fact(n-1)

print(fact(5))

9、匿名函数

# 匿名函数

# 格式  lambda 参数列表: 表达式

"""
优点:
    使程序更加简洁
    省去函数命名烦恼

缺点:
    理解比较难
    函数体知识一个表达式，无法实现比较复杂的功能
"""

# 求两数之和
fun_sum = lambda x,y: x + y
sums = fun_sum(2,3)
print(sums)

10、函数闭包

在一个外函数中定义了一个内函数，内函数里运用了外函数的临时变量，并且外函数的返回值是内函数的引用，这样就构成了一个闭包。

# 函数闭包

x= 23

def outer():
    b= 20
    print(b)
    def inner():
        a = b + x
        print(a)
    return inner

# 返回内部函数
test = outer()

# 调用内部函数
test()

九 类

重点理解：

• 类：实际事物的抽象, 简单理解为模板，需要根据模板创建对象。
• 对象：由类实例化得到的具体的一个事物。
• _init_(self,*others): 构造方法，对对象(属性)进行初始化。
• self：表示当前的对象。

由类得到对象的过程(个人理解)：

• 通过 类名() 得到一个 未初始化的对象(self)
• 自动调用 _init_(self,*others) 通过传参对 self(即当前对象) 进行初始化
• 所有的方法都是用来操作对象的，每个方法中的 self 都是当前对象， 每次调用方法都自动传入 self 就是为了让方法区分不同的对象

1、自定义类

# 定义类
class Student():

    # 类变量
    height = 180

    # 构造方法
    def __init__(self,name,age,gender):
        # 实例变量
        self.name = name
        self.age = age
        self.gender = gender

    # 普通方法
    def say(self,mytext):
        print("I can say:",mytext)

    def change_age(self,age):
        if age > 0:
            self.age = age
        else:
            print("年龄输入错误")
            

# 得到对象
stu_one = Student("小明",18,"male")
stu_one.say("Hello world!")

# 修改属性
# 注意 尽量不要使用 stu_one.age = 18 的方式修改属性值，因为这样做很不安全，比如：stu_one.age = "-1" 这样子也能修改，但是很明显是错的
print(stu_one.age)
stu_one.change_age(36)
print(stu_one.age)

# 类变量 (属于所有对象)
print(stu_one.height)

2、私有属性

# 私有属性
# 尽量不要使用 对象名.属性名 = 属性值 的方式改变属性值
class Card:

    def __init__(self,account,password,balance):
        self.__account = account
        self.__password = password
        self.__balance = balance

    def get_balance(self,account,password):
        if account == self.__account and password == self.__password:
            return self.__balance
        else:
            print("账户或密码错误！")
            return None


mycard = Card("xiaoming","123456",5000)
mybalance = mycard.get_balance("xiaoming","123456")
print(mybalance)

3、类的继承

# 类的继承

"""
一个类继承另一个类时，它将自动获得另一个累的所有属性和方法
子类继承了其父类所有的属性和方法，同时还可以定义自己的属性和方法
在子类中定义一个和父类方法同名的方法，python 将不会考虑父类中的这个方法
"""

# 父类 人类
class Persion:

    def __init__(self,name,age):
        self.name = name
        self.age = age

    def introduce_self(self):
        print("My name is",self.name,"and I am",self.age,"ears old")

    def eat(self):
        print("人总要吃饭")

# 子类 学生类
class Student(Persion):

    def __init__(self,name,age,school):
        super().__init__(name,age)
        # 子类特有的属性
        self.__school = school

    # 重写父类的方法
    def introduce_self(self):
        print("My name is",self.name, "and I am",self.age,"ears old.")
        print("I come from",self.__school,".")

    # 子类特有的方法
    def learn(self):
        print("I love learning")

class Scientist(Persion):

    def invention(self):
        print("袁隆平发明了杂交水稻")


studentone = Student("xiaoming",18,"Tsinghua")
# 调用父类的方法
studentone.eat()
# 调用自己的方法
studentone.learn()
# 调用重写的方法
studentone.introduce_self()

# 如果子类没有指定，默认调用父类的构造方法
scientistone = Scientist("袁隆平",90)
scientistone.invention()

注意：

• python 中私有属性和私有方法都不能被继承，但是可以通过调用继承的父类的公有方法，间接的访问父类的私有方法、属性
• 父类中的构造方法也可以被重写，子类中如果没有指定构造方法，默认使用父类的构造方法

4、抽象类

# 抽象类

"""
抽象类用来制定规则：
    抽象类只能被继承，不能被实例化
    抽象类中有抽象方法，子类继承抽象父类，必须实现(或者重写)父类的抽象方法
"""
import abc
class Animals(metaclass=abc.ABCMeta):

    def __init__(self,name,age):
        self.name = name
        self.age = age

    @abc.abstractmethod
    def eat(self):
        pass

class Dog(Animals):

    def eat(self):
        print(self.name,"can eat food")

mydog = Dog("二哈",6)
mydog.eat()

5、引用自定义类

方式一：

# 引用自定义类
from demo03 import Student

mystudent = Student("小李",15,"Central South University")
mystudent.introduce_self()

方式二：

# 引用自定义类
import demo03

mystudent = demo03.Student("小李",15,"Central South University")
mystudent.learn()

十 异常

定义：

• python 不会处理的行为就是异常
• python 使用被称为异常的特殊对象来管理程序执行期间发生的错误

异常处理的流程：

• 将可能引发异常的代码块放在 try 语句中
• 如果 try 代码块中的代码产生了异常， python 将查找异常对应的 except 代码块，并执行其中的代码
• 如果 try 代码块成功执行， python 将执行 else 代码块中的代码
• 无论异常发生与否，都会执行 finally 中的代码

1、举例（两数相除）

# 例子
print("请输入两个数，将返回两数相除的结果")
numone = int(input("输入一个数: "))
numtwo = int(input("输入另一个数: "))

try:
    answer = numone/numtwo
except ZeroDivisionError:
    print("第二个数不能为 0")
else:
    print("两数相除的结果为:",answer)
finally:
    print("我总能被执行")

2、自定义异常

实际开发中，有时候系统提供的异常类型不能满足开发的需求。这时候你可以通过创建一个新的异常类来拥有自己的异常。异常类继承自 Exception 类，可以直接继承，或者间接继承。

# 自定义异常

class IsNotDigitError(Exception):

    def __init__(self,info):
        self.info = info

    def __str__(self):
        print(self.info,"不是一个数字!")


def error_test():

    try:
        n = input("请输入一个数字: ")
        if not n.isdigit():
            raise IsNotDigitError(n)
    except IsNotDigitError as e:
        e.__str__()
    else:
        print("您输入的数字是:",n)


error_test()

特别地：

• 系统的自带的异常只要触发会自动抛出，比如ZeroDivisionError，但用户自定义的异常需要用户自己决定什么时候抛出
• raise 唯一的一个参数指定了要被抛出的异常,它必须是一个异常的实例或者是异常的类（也就是 Exception 的子类）。
• 大多数的异常的名字都以"Error"结尾，所以实际命名时尽量跟标准的异常命名一样

十一 文件操作

1、文本文件操作

（1）读操作

# 读文本文件

# 完整读取
filename = "poem.txt"
with open(filename,"r",encoding="utf-8") as file_obj:
    contents = file_obj.read()
    print(contents)

# 逐行读取
with open(filename,"r",encoding="utf-8") as file_obj:
    for line in file_obj:
        print(line.rstrip())

（2）写操作

# 写文件

filename = "writefile.txt"

# 清空文件，并写入
with open(filename,"w") as file_obj:
    file_obj.write("世界上只有一种真正的英雄主义，")
    file_obj.write("那就是在认清了生活的真相后，仍然热爱它。\n")

# 在文件末尾追加内容
with open(filename,"a") as file_obj:
    file_obj.write("纵有疾风起\n")
    file_obj.write("人生不言弃")

2、二进制文件操作

以复制图片为例：

# 复制二进制文件

filename = "ebd.jpg"
copyname = "copy.jpg"
content = None

with open(filename,"rb") as file_obj:
    content = file_obj.read()

if content:
    with open(copyname,"wb") as file_obj:
        file_obj.write(content)

3、json文件操作

把用户名存入文件，运行后首先去读取用户名，如果不存在就创建文件并把用户名存入。

# 以 json 格式保存和读取数据
import json

def get_stored_username():
    """如果存储了用户名，就获取它"""
    filename = "username.json"
    try:
        with open(filename,"r") as f_obj:
            username = json.load(f_obj)
    except FileNotFoundError as e:
        return None
    else:
        return username

def get_new_username():
    """提示用户输入用户名"""
    username = input("What is your name: ")
    filename = "username.json"
    with open(filename,"w") as f_obj:
        json.dump(username,f_obj)
    return username

def greet_user():
    """问候用户，并指出其名字"""
    username = get_stored_username()
    if username:
        print("Welcome back,",username,"!")
    else:
        username = get_new_username()
        print("We'll remember you when you come back,",username,"!")

greet_user()

注意文件的路径，有相对路径和绝对路径，要保证文件的路径正确。

十二 测试代码

---

十三 总结

如有错误恳请指正，如有雷同纯属巧合