文章目录

第一章基础
第二章函数
第三章文件操作
第四章面向对象基础
第五章异常
- 1.异常的写法
- 2.⾃定义异常
第六章模块和包
第七章公共操作
第八章练习⾯向对象版学员管理系统

第一章基础

1.注释

注释分为两类：单⾏注释和多⾏注释。

快捷键： ctrl + /

# 注释内容

"""
 第⼀⾏注释
 第⼆⾏注释
"""

'''
 注释1
'''

2.变量

变量就是⼀个存储数据的时候当前数据所在的内存地址的名字⽽已。

变量名 = 值

# 使用变量
my_name = 'TOM'
print(my_name)

# 检测数据类型的⽅法： type()
d = '12345'
print(type(d)) # <class 'str'> -- 字符串
e = [10, 20, 30]
print(type(e)) # <class 'list'> -- 列表

标识符:

由数字、字⺟、下划线组成
不能数字开头
能使⽤内置关键字
严格区分⼤⼩写

1.python基础

3.输入输出

3.1 输入

当程序执⾏到 input ，等待⽤户输⼊，输⼊完成之后才继续向下执⾏。
在Python中， input 接收⽤户输⼊后，⼀般存储到变量，⽅便使⽤。
在Python中， input 会把接收到的任意⽤户输⼊的数据都当做字符串处理。

password = input('请输⼊您的密码：')

print(f'您输⼊的密码是{password}')
# <class 'str'>
print(type(password))

3.2 输出

格式化符号

1.python基础

# 格式化字符串除了%s，还可以写为 f'{表达式}'

age = 18
name = 'TOM'
weight = 75.5
student_id = 1

# 我的名字是TOM
print('我的名字是%s' % name)

# 我的学号是0001
print('我的学号是%4d' % student_id)

# 我的体重是75.50公⽄
print('我的体重是%.2f公⽄' % weight)

# 我的名字是TOM，今年18岁了
print('我的名字是%s，今年%d岁了' % (name, age))

# 我的名字是TOM，明年19岁了
print('我的名字是%s，明年%d岁了' % (name, age + 1))

# 我的名字是TOM，明年19岁了
print(f'我的名字是{name}, 明年{age + 1}岁了')

转义字符

\n ：换⾏。
\t ：制表符，⼀个tab键（4个空格）的距离。

结束符

 print('输出的内容', end="\n")

在Python中，print()，默认⾃带 end=“\n” 这个换⾏结束符，所以导致每两个 print 直接会换⾏
展示，⽤户可以按需求更改结束符。

4.转换数据类型

1.python基础

# 1. 接收⽤户输⼊
num = input('请输⼊您的幸运数字：')
# 2. 打印结果
print(f"您的幸运数字是{num}")
# 3. 检测接收到的⽤户输⼊的数据类型 -- str类型
print(type(num))
# 4. 转换数据类型为整型 -- int类型
print(type(int(num)))

5.运算符

算数运算符

+ - * / %  **  ()
# 混合运算优先级顺序： () ⾼于 ** ⾼于 * / // % ⾼于 + -
# //:整除
# print(9/4) 输出：2.25

赋值运算符

复合赋值运算符

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

⽐较运算符

==  !=  >  <  >=  <=

# 例子
a = 7
b = 5
print(a == b) # False
print(a != b) # True

逻辑运算符

1.python基础

与： and
或：or
⾮：not

a = 1
b = 2
c = 3
print((a < b) and (b < c)) # True
print((a > b) and (b < c)) # False
print((a > b) or (b < c)) # True
print(not (a > b)) # True


a = 0
b = 1
c = 2
# and运算符，只要有⼀个值为0，则结果为0，否则结果为最后⼀个⾮0数字
print(a and b) # 0
print(b and a) # 0
print(a and c) # 0
print(c and a) # 0
print(b and c) # 2
print(c and b) # 1
# or运算符，只有所有值为0结果才为0，否则结果为第⼀个⾮0数字
print(a or b) # 1
print(a or c) # 2
print(b or c) # 1

6 条件语句(if)

if 条件:
 条件成⽴执⾏的代码


if 条件:
 条件成⽴执⾏的代码
else:
 条件不成⽴执⾏的代码

if 条件1:
 条件1成⽴执⾏的代码
elif 条件2:
 条件2成⽴执⾏的代码
else:
 以上条件都不成⽴执⾏的代码

三⽬运算符

条件成⽴执⾏的表达式 if 条件 else 条件不成⽴执⾏的表达式

a = 1
b = 2
c = a if a > b else b
print(c) #2

7. 循环（while、for）

break退出整个循环
continue退出本次循环，继续执⾏下⼀次重复执⾏的代码

while循坏

while 条件:
 条件成⽴重复执⾏的代码1
 条件成⽴重复执⾏的代码2
 .....

//例子
# 循环的计数器
i = 0
while i < 5:
 print('媳妇⼉，我错了')
 i += 1

for循环

for 临时变量 in 序列:
 重复执⾏的代码1
 重复执⾏的代码2
 ......

# 例子
str1 = 'itheima'
for i in str1:
 print(i)

while…else

循环可以和else配合使⽤，else下⽅缩进的代码指的是当循环正常结束之后要执⾏的代码。

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

# 例子
i = 1
while i <= 5:
 	print('媳妇⼉，我错了')
 	i += 1
    #break
    #continue
else:
 print('媳妇原谅我了，真开⼼，哈哈哈哈')

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

因为continue是退出当前⼀次循环，继续下⼀次循环，所以该循环在continue控制下是可以正常结束的，当循环结束后，则执⾏了else缩进的代码。

for…else

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

8.字符串

b = "abcdefg"
print(type(b)) # <class 'str'>

name = "abcdef"
print(name[1]) # b

切⽚

切⽚是指对操作的对象截取其中⼀部分的操作。字符串、列表、元组都⽀持切⽚操作。

序列[开始位置下标:结束位置下标:步⻓]

注意

不包含结束位置下标对应的数据，正负整数均可；
步⻓是选取间隔，正负整数均可，默认步⻓为1。

name = "abcdefg"
print(name[2:5:1]) # cde
print(name[2:5]) # cde
print(name[:5]) # abcde
print(name[1:]) # bcdefg
print(name[:]) # abcdefg
print(name[::2]) # aceg
print(name[:-1]) # abcdef, 负1表示倒数第⼀个数据
print(name[-4:-1]) # def
print(name[::-1]) # gfedcba

常用操作

字符串的常⽤操作⽅法有查找、修改和判断三⼤类。

（1）查找

find()：检测某个⼦串是否包含在这个字符串中
index()：检测某个⼦串是否包含在这个字符串中，
rfind()： 和find()功能相同，但查找⽅向为右侧开始。
rindex()：和index()功能相同，但查找⽅向为右侧开始。
count()：返回某个⼦串在字符串中出现的次数

count()：返回某个⼦串在字符串中出现的次数

 字符串序列.count(⼦串, 开始位置下标, 结束位置下标)

mystr = "hello world and itcast and itheima and Python"
print(mystr.count('and')) # 3
print(mystr.count('ands')) # 0
print(mystr.count('and', 0, 20)) # 1

find()：检测某个⼦串是否包含在这个字符串中，如果在返回这个⼦串开始的位置下标，否则则返回-1。

 字符串序列.find(⼦串, 开始位置下标, 结束位置下标)

注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。

mystr = "hello world and itcast and itheima and Python"
print(mystr.find('and')) # 12
print(mystr.find('and', 15, 30)) # 23
print(mystr.find('ands')) # -1

index()：检测某个⼦串是否包含在这个字符串中，如果在返回这个⼦串开始的位置下标，否则则报异常。

字符串序列.index(⼦串, 开始位置下标, 结束位置下标)

注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。

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')) # 报错

（2）修改

replace()：替换
split()：按照指定字符分割字符串。
join()：⽤⼀个字符或⼦串合并字符串，即是将多个字符串合并为⼀个新的字符串。

capitalize()：将字符串第⼀个字符转换成⼤写。
#注意：capitalize()函数转换后，只字符串第⼀个字符⼤写，其他的字符全都⼩写。
title()：将字符串每个单词⾸字⺟转换成⼤写。
lower()：将字符串中⼤写转⼩写。
upper()：将字符串中⼩写转⼤写。

lstrip()：删除字符串左侧空⽩字符。
rstrip()：删除字符串右侧空⽩字符。
strip()：删除字符串两侧空⽩字符。

ljust()：返回⼀个原字符串左对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串
rjust()：返回⼀个原字符串右对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串，语法和ljust()相同。
center()：返回⼀个原字符串居中对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串，语法和ljust()相同。

replace()：替换

字符串序列.replace(旧⼦串, 新⼦串, 替换次数)

# 例子
mystr = "hello world and itcast and itheima and Python"
# 结果：hello world he itcast he itheima he Python
print(mystr.replace('and', 'he'))
# 结果：hello world he itcast he itheima he Python
print(mystr.replace('and', 'he', 10))
# 结果：hello world and itcast and itheima and Python
print(mystr)

split()：按照指定字符分割字符串。‘

字符串序列.split(分割字符, num)
#注意：num表示的是分割字符出现的次数，即将来返回数据个数为num+1个。

#例子
mystr = "hello world and itcast and itheima and Python"
# 结果：['hello world ', ' itcast ', ' itheima ', ' Python']
print(mystr.split('and'))
# 结果：['hello world ', ' itcast ', ' itheima and Python']
print(mystr.split('and', 2))
# 结果：['hello', 'world', 'and', 'itcast', 'and', 'itheima', 'and', 'Python']
print(mystr.split(' '))
# 结果：['hello', 'world', 'and itcast and itheima and Python']
print(mystr.split(' ', 2))

join()：⽤⼀个字符或⼦串合并字符串，即是将多个字符串合并为⼀个新的字符串。

字符或⼦串.join(多字符串组成的序列)

# 例子
list1 = ['chuan', 'zhi', 'bo', 'ke']
t1 = ('aa', 'b', 'cc', 'ddd')
# 结果：chuan_zhi_bo_ke
print('_'.join(list1))
# 结果：aa...b...cc...ddd
print('...'.join(t1))

capitalize()：将字符串第⼀个字符转换成⼤写。
title()：将字符串每个单词⾸字⺟转换成⼤写。
lower()：将字符串中⼤写转⼩写。
upper()：将字符串中⼩写转⼤写。

mystr = "hello world and itcast and itheima and Python"

print(mystr.capitalize())

print(mystr.title())

print(mystr.lower())

print(mystr.upper())

#输出
Hello world and itcast and itheima and python
Hello World And Itcast And Itheima And Python
hello world and itcast and itheima and python
HELLO WORLD AND ITCAST AND ITHEIMA AND PYTHON

（3）判断

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

startswith()：检查字符串是否是以指定⼦串开头，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。

endswith()：：检查字符串是否是以指定⼦串结尾，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。

isalpha()：如果字符串⾄少有⼀个字符并且所有字符都是字⺟则返回 True, 否则返回 False。

isdigit()：如果字符串只包含数字则返回 True 否则返回 False。

isalnum()：如果字符串⾄少有⼀个字符并且所有字符都是字⺟或数字则返 回 True,否则返回False。

sspace()：如果字符串中只包含空⽩，则返回 True，否则返回 False。

startswith()：检查字符串是否是以指定⼦串开头，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。
endswith()：：检查字符串是否是以指定⼦串结尾，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。

字符串序列.startswith(⼦串, 开始位置下标, 结束位置下标)
字符串序列.endswith(⼦串, 开始位置下标, 结束位置下标)

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

isalpha()：如果字符串⾄少有⼀个字符并且所有字符都是字⺟则返回 True, 否则返回 False。
isdigit()：如果字符串只包含数字则返回 True 否则返回 False。

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

9. 列表

# 列表
	name_list = ['Tom', 'Lily', 'Rose']

#列表嵌套    
    name_list = [['⼩明', '⼩红', '⼩绿'], ['Tom', 'Lily', 'Rose'], ['张三', '李四','王五']]
name_list[2][1]


#常⽤操作⽅法
    index()
    len()
    append()
    pop()
    remove()

列表：列表可以⼀次性存储多个数据，且可以为不同数据类型。

列表的作⽤是⼀次性存储多个数据，程序员可以对这些数据进⾏的操作有：增、删、改、查。

查找

index()：返回指定数据所在位置的下标 。
count()：统计指定数据在当前列表中出现的次数。
len()：访问列表⻓度，即列表中数据的个数。

# 
name_list = ['Tom', 'Lily', 'Rose']
print(name_list.index('Lily', 0, 2)) # 1
print(name_list.count('Lily')) # 1
print(len(name_list)) # 3

判断是否存在

in：判断指定数据在某个列表序列，如果在返回True，否则返回False
not in：判断指定数据不在某个列表序列，如果不在返回True，否则返回False

name_list = ['Tom', 'Lily', 'Rose']
# 结果：True
print('Lily' in name_list)
# 结果：False
print('Lilys' in name_list)

# 例子：需求：查找⽤户输⼊的名字是否已经存在。
name_list = ['Tom', 'Lily', 'Rose']
name = input('请输⼊您要搜索的名字：')
if name in name_list:
 	print(f'您输⼊的名字是{name}, 名字已经存在')
else:
 	print(f'您输⼊的名字是{name}, 名字不存在')

增加

append()：列表结尾追加数据。如果append()追加的数据是⼀个序列，则追加整个序列到列表
	列表序列.append(数据),

extend()：列表结尾追加数据，如果数据是⼀个序列，则将这个序列的数据逐⼀添加到列表。

insert()：指定位置新增数据。

#例子
name_list = ['Tom', 'Lily', 'Rose']
name_list.append('xiaoming')
# 结果：['Tom', 'Lily', 'Rose', 'xiaoming']
print(name_list)

name_list.append(['xiaoming', 'xiaohong'])
# 结果：['Tom', 'Lily', 'Rose', ['xiaoming', 'xiaohong']]
print(name_list)

删除

del:

pop()：删除指定下标的数据(默认为最后⼀个)，并返回该数据。

remove()：移除列表中某个数据的第⼀个匹配项。

clear()：清空列表

del

#语法
del ⽬标

name_list = ['Tom', 'Lily', 'Rose']
# 结果：报错提示：name 'name_list' is not defined
del name_list
del name_list[0]
print(name_list)

pop()：删除指定下标的数据(默认为最后⼀个)，并返回该数据。

# 语法
列表序列.pop(下标)

name_list = ['Tom', 'Lily', 'Rose']
del_name = name_list.pop(1)
# 结果：Lily
print(del_name)
# 结果：['Tom', 'Rose']
print(name_list)

修改:

name_list[0] = 'aaa'   修改指定下标数据

逆置：reverse()

排序：sort()
列表序列.sort( key=None, reverse=False)
注意：reverse表示排序规则，reverse = True 降序， reverse = False 升序（默认）

复制

函数：copy()
name_list = ['Tom', 'Lily', 'Rose']
name_li2 = name_list.copy()
# 结果：['Tom', 'Lily', 'Rose']
print(name_li2

10.元组

#元组
    # 多个数据元组
    t1 = (10, 20, 30)
    # 单个数据元组
    t2 = (10,)

元组：⼀个元组可以存储多个数据，元组内的数据是不能修改的。

11.集合

创建集合使⽤ {} 或 set() ，但是如果要创建空集合只能使⽤ set() ，因为 {} ⽤来创建空字典。

s1 = {10, 20, 30, 40, 50}
print(s1)

s4 = set()

s2 = {10, 30, 20, 10, 30, 40, 30, 50}
print(s2) #{10,30,20,40,50}

特点：

集合可以去掉重复数据；
集合数据是⽆序的，故不⽀持下标

增加数据

add() #s1.add(100)

update(), 追加的数据是序列。

s1 = {10, 20}
# s1.update(100) # 报错
s1.update([100, 200])
s1.update('abc')
print(s1)
# {'a', 100, 200, 10, 'c', 20, 'b'}

删除数据

remove()，删除集合中的指定数据，如果数据不存在则报错。
discard()，删除集合中的指定数据，如果数据不存在也不会报错。
pop()，随机删除集合中的某个数据，并返回这个数据。

#
s1.remove(10)
s1.pop()

查找数据

in：判断数据在集合序列
not in：判断数据不在集合序列

s1 = {10, 20, 30, 40, 50}
print(10 in s1)
print(10 not in s1)

12.字典

字典特点：

符号为⼤括号
数据为键值对形式出现
各个键值对之间⽤逗号隔开

# 有数据字典
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
# 空字典
dict2 = {}
dict3 = dict()

注意：⼀般称冒号前⾯的为键(key)，简称k；冒号后⾯的为值(value)，简称v。

（1）增

写法：字典序列[key] = 值

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
dict1['name'] = 'Rose'
# 结果：{'name': 'Rose', 'age': 20, 'gender': '男'}
print(dict1)

dict1['id'] = 110
# {'name': 'Rose', 'age': 20, 'gender': '男', 'id': 110}
print(dict1)

（2）删

del() / del：删除字典或删除字典中指定键值对。

clear()：清空字典

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

del dict1['gender']
# 结果：{'name': 'Tom', 'age': 20}
print(dict1)

dict1.clear()
print(dict1) # {}

（3）改

写法：字典序列[key] = 值

注意：如果key存在则修改这个key对应的值；如果key不存在则新增此键值对。

（3）查

key值查找

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1['name']) # Tom
print(dict1['id']) # 报错

get()

字典序列.get(key, 默认值)

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.get('name')) # Tom
print(dict1.get('id', 110)) # 110
print(dict1.get('id')) # None

keys() 、values() 、 items()

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.keys()) # dict_keys(['name', 'age', 'gender'])


dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.values()) # dict_values(['Tom', 20, '男'])

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.items()) # dict_items([('name', 'Tom'), ('age', 20), ('gender','男')])

第二章函数

1.函数的基本概念

函数的作⽤：封装代码，⾼效的代码重⽤

函数就是将⼀段具有独⽴功能的代码块 整合到⼀个整体并命名，在需要的位置调⽤这个名称即可完成对应的需求。

函数在开发过程中，可以更⾼效的实现代码重⽤。

# 定义函数
def 函数名(参数):
	 代码1
	 代码2
	 ......
        
#调⽤函数
函数名(参数)

函数的参数：函数调⽤的时候可以传⼊真实数据，增⼤函数的使⽤的灵活性

形参：函数定义时书写的参数(⾮真实数据)
实参：函数调⽤时书写的参数(真实数据)

# 定义函数
def add_num1():
 	result = 1 + 2
 	print(result)
# 调⽤函数
add_num1()

# 定义函数时同时定义了接收⽤户数据的参数a和b，a和b是形参
def add_num2(a, b):
 	result = a + b
 	print(result)
# 调⽤函数时传⼊了真实的数据10 和 20，真实数据为实参
add_num2(10, 20)

函数的返回值
作⽤：函数调⽤后，返回需要的计算结果

# 写法
 return 表达式

#例子
def sum_num(a, b, c):
 	return a + b + c

result = sum_num(1, 2, 3)
print(result) # 6

2.变量、函数的参数

变量作⽤域指的是变量⽣效的范围，主要分为两类：局部变量和全局变量。

缺省参数也叫默认参数。

可变和不可变类型

所谓可变类型与不可变类型是指：数据能够直接进⾏修改，如果能直接修改那么就是可变，否则是不可变.

可变类型：列表、字典、集合
不可变类型：整型、浮点型、字符串、元组

3.递归、lambda 表达式

（1）递归

函数内部⾃⼰调⽤⾃⼰
必须有出⼝

（2）lambda 表达式

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

#语法
lambda 参数列表 ： 表达式

注意

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

def add(a, b):
 	return a + b
result = add(1, 2)
print(result)

# lambda实现
print((lambda a, b: a + b)(1, 2))

lambda的参数形式

# ⽆参数
print((lambda: 100)())

#⼀个参数
print((lambda a: a)('hello world'))

#默认参数
print((lambda a, b, c=100: a + b + c)(10, 20)) #130

#可变参数：**args
print((lambda *args: args)(10, 20, 30))
#是一个元组 (10, 20, 30)

#可变参数：**kwargs
print((lambda **kwargs: kwargs)(name='python', age=20))
#{'name': 'python', 'age': 20}

4. ⾼阶函数

把函数作为参数传⼊，这样的函数称为⾼阶函数，⾼阶函数是函数式编程的体现。

内置⾼阶函数

map()

map(func, lst)，将传⼊的函数变量func作⽤到lst变量的每个元素中，并将结果组成新的列表(Python2)/迭代器(Python3)返回。

list1 = [1, 2, 3, 4, 5]
def func(x):
 	return x ** 2

result = map(func, list1)
print(result) # <map object at 0x0000013769653198>
print(list(result)) # [1, 4, 9, 16, 25]

reduce()

reduce(func(x,y)，lst)，其中func必须有两个参数。每次func计算的结果继续和序列的下⼀个元素做累积计算。
注意：reduce()传⼊的参数func必须接受2个参数。

import functools
list1 = [1, 2, 3, 4, 5]
def func(a, b):
 	return a + b

result = functools.reduce(func, list1)
print(result) # 15

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 0x0000017AF9DC3198>
print(list(result)) # [2, 4, 6, 8, 10]

第三章文件操作

总结：⽂件操作的作⽤就是把⼀些内容(数据)存储存放起来，可以让程序下⼀次执⾏的时候直接使⽤，⽽不必重新制作⼀份，省时省⼒。

1.⽂件的基本操作

（1）打开

open(name, mode)

#例子
f = open('test.txt', 'w')
#注意：此时的 f 是 open 函数的⽂件对象。

name：是要打开的⽬标⽂件名的字符串(可以包含⽂件所在的具体路径)。
mode：设置打开⽂件的模式(访问模式)：只读、写⼊、追加等。

1.python基础

（2）⽂件对象⽅法

写

# 语法
对象.write('内容')

# 例子
# 1. 打开⽂件
f = open('test.txt', 'w')
# 2.⽂件写⼊
f.write('hello world')
# 3. 关闭⽂件
f.close()

注意：

w 和 a 模式：如果⽂件不存在则创建该⽂件；如果⽂件存在， w 模式先清空再写⼊， a 模式直接末尾追加。
r 模式：如果⽂件不存在则报错。

读

read()

⽂件对象.read(num)

readlines()

readlines可以按照⾏的⽅式把整个⽂件中的内容进⾏⼀次性读取，并且返回的是⼀个列表，其中每⼀⾏的数据为⼀个元素。

f = open('test.txt')
content = f.readlines()
# ['hello world\n', 'abcdefg\n', 'aaa\n', 'bbb\n', 'ccc']
print(content)
# 关闭⽂件
f.close()

readline()：readline()⼀次读取⼀⾏内容。

f = open('test.txt')
content = f.readline()
print(f'第⼀⾏：{content}')
content = f.readline()
print(f'第⼆⾏：{content}')
# 关闭⽂件
f.close()

seek()
作⽤：⽤来移动⽂件指针。
```
⽂件对象.seek(偏移量, 起始位置)
```
起始位置：
0：⽂件开头
1：当前位置
2：⽂件结尾

（3）打开

⽂件对象.close()

2.⽂件备份

需求：⽤户输⼊当前⽬录下任意⽂件名，程序完成对该⽂件的备份功能(备份⽂件名为xx[备份]后缀，例如：test[备份].txt)。

#1. 接收⽤户输⼊⽬标⽂件名
old_name = input('请输⼊您要备份的⽂件名：')

2. 规划备份⽂件名

# 2.1 提取⽂件后缀点的下标
index = old_name.rfind('.')
# print(index) # 后缀中.的下标
# print(old_name[:index]) # 源⽂件名（⽆后缀）
# 2.2 组织新⽂件名 旧⽂件名 + [备份] + 后缀
new_name = old_name[:index] + '[备份]' + old_name[index:]
# 打印新⽂件名（带后缀）
# print(new_name)

3. 备份⽂件写⼊数据
# 3.1 打开⽂件
old_f = open(old_name, 'rb')
new_f = open(new_name, 'wb')
# 3.2 将源⽂件数据写⼊备份⽂件
while True:
     con = old_f.read(1024)
     if len(con) == 0:
     	break
	 new_f.write(con)
# 3.3 关闭⽂件
old_f.close()
new_f.close()

3.⽂件和⽂件夹的操作

在Python中⽂件和⽂件夹的操作要借助os模块⾥⾯的相关功能，具体步骤如下：

# 1. 导⼊os模块
import os

# 2. 使⽤ os 模块相关功能
os.函数名()

# ⽂件重命名
os.rename(⽬标⽂件名, 新⽂件名)

# 删除⽂件
os.remove(⽬标⽂件名)

# 创建⽂件夹
os.mkdir(⽂件夹名字)

# 删除⽂件夹
os.rmdir(⽂件夹名字)

# 获取当前⽬录
os.getcwd()

# 改变默认⽬录
os.chdir(⽬录)

# 获取⽬录列表
os.listdir(⽬录)

第四章面向对象基础

封装

将属性和⽅法书写到类的⾥⾯的操作即为封装
封装可以为属性和⽅法添加私有权限

继承

⼦类默认继承⽗类的所有属性和⽅法
⼦类可以重写⽗类属性和⽅法

多态

传⼊不同的对象，产⽣不同的结果

1.面向对象重要组成部分

在⾯向对象编程过程中，有两个重要组成部分：类和对象。

⾯向对象就是将编程当成是⼀个事物，对外界来说，事物是直接使⽤的，不⽤去管他内部的情况。⽽编程就是设置事物能够做什么事。

（1）类

特征即是属性，⾏为即是⽅法

class 类名():
	代码
	......

#例子
class Washer():
 	def wash(self):
 	print('我会洗⾐服')

注意：类名要满⾜标识符命名规则，同时遵循⼤驼峰命名习惯。

（2）对象

对象⼜名实例。

# 语法
对象名 = 类名()

#例子
# 创建对象
haier1 = Washer()
# haier对象调⽤实例⽅法
haier1.wash()

2.添加和获取对象属性

类外⾯添加对象属性

对象名.属性名 = 值

类外⾯获取对象属性

对象名.属性名

类⾥⾯获取对象属性

self.属性名


#例子
# 定义类
class Washer():
     def print_info(self):
     # 类⾥⾯获取实例属性
     print(f'haier1洗⾐机的宽度是{self.width}')
     print(f'haier1洗⾐机的⾼度是{self.height}')
    
# 创建对象
haier1 = Washer()
# 添加实例属性
haier1.width = 500
haier1.height = 800

haier1.print_info()

3. 魔法⽅法

在Python中， _ _ xx _ _() 的函数叫做魔法⽅法，指的是具有特殊功能的函数。

（1）_ _ init_ _()

⽅法的作⽤：初始化对象。

class Washer():	 
     # 定义初始化功能的函数
     def __init__(self):
         # 添加实例属性
        self.width = 500
        self.height = 800
        
 	 def print_info(self):
         # 类⾥⾯调⽤实例属性
         print(f'洗⾐机的宽度是{self.width}, ⾼度是{self.height}')
        
haier1 = Washer()
haier1.print_info()


#带参数的__init__() __init__() 
class Washer():
     def __init__(self, width, height):
         self.width = width
         self.height = height
     def print_info(self):
         print(f'洗⾐机的宽度是{self.width}')
         print(f'洗⾐机的⾼度是{self.height}')
        
haier1 = Washer(10, 20)
haier1.print_info()

haier2 = Washer(30, 40)
haier2.print_info()

注意：
__init__() ⽅法，在创建⼀个对象时默认被调⽤，不需要⼿动调⽤
__init__(self) 中的self参数，不需要开发者传递，python解释器会⾃动把当前的对象引⽤传递过去。

（2） _ _ str_ _()

当使⽤print输出对象的时候，默认打印对象的内存地址。如果类定义了 str ⽅法，那么就会打印从在这个⽅法中 return 的数据。

class Washer():
     def __init__(self, width, height):
         self.width = width
         self.height = height
     def __str__(self):
     	return '这是海尔洗⾐机的说明书'
    
haier1 = Washer(10, 20)
# 这是海尔洗⾐机的说明书
print(haier1)

（3） _ _ del _ _()

当删除对象时，python解释器也会默认调⽤ del() ⽅法。

class Washer():
    def __init__(self, width, height):
        self.width = width
        self.height = height
    def __del__(self):
        print(f'{self}对象已经被删除')
        
haier1 = Washer(10, 20)
# <__main__.Washer object at 0x0000026118223278>对象已经被删除
del haier1

4. 继承

继承的特点

⼦类默认拥有⽗类的所有属性和⽅法
⼦类重写⽗类同名⽅法和属性
⼦类调⽤⽗类同名⽅法和属性

（1）单继承、多继承、多层继承

多继承意思就是⼀个类同时继承了多个⽗类。

# 1. 师父类，属性和方法
class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


# 为了验证多继承，添加School父类
class School(object):
    def __init__(self):
        self.kongfu = '[黑马煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


# 2. 定义徒弟类，继承师父类 和 学校类
class Prentice(School, Master):
    pass


# 3. 用徒弟类创建对象，调用实例属性和方法
daqiu = Prentice()

print(daqiu.kongfu)

daqiu.make_cake()


# 结论：如果一个类继承多个父类，优先继承第一个父类的同名属性和方法

（2）⼦类重写⽗类同名⽅法和属性

⼦类和⽗类具有同名属性和⽅法，默认使⽤⼦类的同名属性和⽅法。

# 1. 师父类，属性和方法
class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


# 为了验证多继承，添加School父类
class School(object):
    def __init__(self):
        self.kongfu = '[黑马煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


# 2. 定义徒弟类，继承师父类 和 学校类， 添加和父类同名的属性和方法
class Prentice(School, Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果子技术]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


# 3. 用徒弟类创建对象，调用实例属性和方法
daqiu = Prentice()

print(daqiu.kongfu)

daqiu.make_cake()

（3）⼦类调⽤⽗类的同名⽅法和属性

# 1. 师父类，属性和方法
class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


# 为了验证多继承，添加School父类
class School(object):
    def __init__(self):
        self.kongfu = '[黑马煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


# 2. 定义徒弟类，继承师父类 和 学校类， 添加和父类同名的属性和方法
class Prentice(School, Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果子技术]'

    def make_cake(self):
        # 加自己的初始化的原因：如果不加这个自己的初始化，kongfu属性值是上一次调用的init内的kongfu属性值
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')

    # 子类调用父类的同名方法和属性：把父类的同名属性和方法再次封装
    def make_master_cake(self):
        # 父类类名.函数()
        # 再次调用初始化的原因：这里想要调用父类的同名方法和属性，属性在init初始化位置，所以需要再次调用init
        Master.__init__(self)
        Master.make_cake(self)

    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)


# 3. 用徒弟类创建对象，调用实例属性和方法
daqiu = Prentice()
daqiu.make_cake()

daqiu.make_master_cake()

daqiu.make_school_cake()

daqiu.make_cake()


# 输出
运用[独创煎饼果子技术]制作煎饼果子
运用[古法煎饼果子配方]制作煎饼果子
运用[黑马煎饼果子配方]制作煎饼果子
运用[独创煎饼果子技术]制作煎饼果子

（4） super()调⽤⽗类⽅法

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


class School(Master):
    def __init__(self):
        self.kongfu = '[黑马煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')

        # 2.1 super()带参数写法
        # super(School, self).__init__()
        # super(School, self).make_cake()

        # 2.2 无参数的super
        super().__init__()
        super().make_cake()


class Prentice(School):
    def __init__(self):
        self.kongfu = '[独创煎饼果子技术]'

    def make_cake(self):
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')

    # 需求：一次性调用父类School Master的方法
    def make_old_cake(self):
        # 2.2 无参数super
        super().__init__()
        super().make_cake()


daqiu = Prentice()

daqiu.make_old_cake()


运用[黑马煎饼果子配方]制作煎饼果子
运用[古法煎饼果子配方]制作煎饼果子

（3）私有权限

定义私有属性和⽅法

设置私有权限的⽅法：在属性名和⽅法名前⾯加上两个下划线 __。

# 定义私有属性
 self.__money = 2000000

 # 定义私有⽅法
 def __info_print(self):
 print(self.kongfu)
 print(self.__money)

注意：私有属性和私有⽅法只能在类⾥⾯访问和修改。

获取和修改私有属性值

在Python中，⼀般定义函数名 get_xx ⽤来获取私有属性，定义 set_xx ⽤来修改私有属性值。

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


class School(object):
    def __init__(self):
        self.kongfu = '[黑马煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


class Prentice(School, Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果子技术]'
        # 定义私有属性
        self.__money = 2000000

    # 定义函数：获取私有属性值 get_xx
    def get_money(self):
        return self.__money

    # 定义函数：修改私有属性值 set_xx
    def set_money(self):
        self.__money = 500

    # 定义私有方法
    def __info_print(self):
        print('这是私有方法')



class Tusun(Prentice):
    pass


xiaoqiu = Tusun()

print(xiaoqiu.get_money())

xiaoqiu.set_money()

print(xiaoqiu.get_money())

#输出
2000000
500

5.多态

定义：多态是⼀种使⽤对象的⽅式，⼦类重写⽗类⽅法，调⽤不同⼦类对象的相同⽗类⽅法，可以产⽣不同的执⾏结果

# 1. 定义父类，提供公共方法： 警犬 和 人
class Dog(object):
    def work(self):
        pass

# 2. 定义子类，子类重写父类方法：定义2个类表示不同的警犬
class ArmyDog(Dog):
    def work(self):
        print('追击敌人...')

class DrugDog(Dog):
    def work(self):
        print('追查毒品...')

# 定义人类
class Person(object):
    def work_with_dog(self, dog):
        dog.work()

# 3. 创建对象，调用不同的功能，传入不同的对象，观察执行的结果
ad = ArmyDog()
dd = DrugDog()

daqiu = Person()
daqiu.work_with_dog(ad)
daqiu.work_with_dog(dd)

#
追击敌人...
追查毒品...

6.类属性和实例属性

类属性就是 类对象 所拥有的属性，它被 该类的所有实例对象 所共有。
类属性可以使⽤ 类对象 或 实例对象 访问。

修改类属性

class Dog(object):
 	tooth = 10
    
wangcai = Dog()
xiaohei = Dog()

# 修改类属性
Dog.tooth = 12
print(Dog.tooth) # 12
print(wangcai.tooth) # 12
print(xiaohei.tooth) # 12

# 不能通过对象修改属性，如果这样操作，实则是创建了⼀个实例属性
wangcai.tooth = 20
print(Dog.tooth) # 12
print(wangcai.tooth) # 20
print(xiaohei.tooth) # 12

实例属性

class Dog(object):
 	def __init__(self):
 		self.age = 5
        
 	def info_print(self):
 		print(self.age)
        
wangcai = Dog()
print(wangcai.age) # 5
# print(Dog.age) # 报错：实例属性不能通过类访问
wangcai.info_print() # 5

7.类⽅法和静态⽅法

(1) 类⽅法

类⽅法特点

第⼀个形参是类对象的⽅法
需要⽤装饰器 @classmethod 来标识其为类⽅法，对于类⽅法，第⼀个参数必须是类对象，⼀般以cls 作为第⼀个参数。

当⽅法中 需要使⽤类对象 (如访问私有类属性等)时，定义类⽅法
类⽅法⼀般和类属性配合使⽤

class Dog(object):
	 __tooth = 10
        
     @classmethod
     def get_tooth(cls):
     	return cls.__tooth
    
wangcai = Dog()
result = wangcai.get_tooth()
print(result) # 10

(2) 静态⽅法

静态⽅法特点

需要通过装饰器 @staticmethod 来进⾏修饰，静态⽅法既不需要传递类对象也不需要传递实例对象（形参没有self/cls）。
静态⽅法也能够通过实例对象和类对象去访问。

静态⽅法使⽤场景

当⽅法中 既不需要使⽤实例对象(如实例对象，实例属性)，也不需要使⽤类对象 (如类属性、类⽅法、创建实例等)时，定义静态⽅法
取消不需要的参数传递，有利于减少不必要的内存占⽤和性能消耗

class Dog(object):
     @staticmethod
     def info_print():
    	 print('这是⼀个狗类，⽤于创建狗实例....')
            
            
wangcai = Dog()
# 静态⽅法既可以使⽤对象访问⼜可以使⽤类访问
wangcai.info_print()
Dog.info_print()

第五章异常

1.异常的写法

finally表示的是⽆论是否异常都要执⾏的代码，例如关闭⽂件。

try执行
# 方式一
try:
 可能发⽣错误的代码
except 异常类型:
 如果捕获到该异常类型执⾏的代码

# 方式二
try:
 可能发⽣异常的代码
except:
 如果出现异常执⾏的代码
else:
 没有异常执⾏的代码
finally:
 ⽆论是否异常都要执⾏的代码

例子：

try:
    print(1)
except Exception as result:
    print(result)
else:
     print('我是else，是没有异常的时候执⾏的代码')
        
#输出 
1
我是else，是没有异常的时候执⾏的代码

try:
	f = open('test.txt', 'r')
except Exception as result:
 	f = open('test.txt', 'w')
else:
 	print('没有异常，真开⼼')
finally:
 	f.close()

#except执行，else不执行

2.⾃定义异常

在Python中，抛出⾃定义异常的语法为 raise 异常类对象。

需求：密码⻓度不⾜，则报异常（⽤户输⼊密码，如果输⼊的⻓度不⾜3位，则报错，即抛出⾃定义异常，并捕获该异常）。

# 1. 自定义异常类， 继承Exception， 魔法方法有init和str(设置异常描述信息)
class ShortInputError(Exception):
    def __init__(self, length, min_len):
        # 用户输入的密码长度
        self.length = length
        # 系统要求的最少长度
        self.min_len = min_len

    # 设置异常描述信息
    def __str__(self):
        return f'您输入的密码长度是{self.length}, 密码不能少于{self.min_len}'


def main():
    # 2. 抛出异常: 尝试执行：用户输入密码，如果长度小于3，抛出异常
    try:
        password = input('请输入密码：')
        if len(password) < 3:
            # 抛出异常类创建的对象
            raise ShortInputError(len(password), 3)
    # 3. 捕获该异常
    except Exception as result:
        print(result)
    else:
        print('没有异常，密码输入完成')


main()

第六章模块和包

1. 模块

(1) 导入模块

Python 模块(Module)，是⼀个 Python ⽂件，以 .py 结尾，包含了 Python 对象定义和Python语句。

模块能定义函数，类和变量，模块⾥也能包含可执⾏的代码。

# 方法一：import 模块名; 
#		 import 模块名1, 模块名2...
# 模块名.功能名()
import math
print(math.sqrt(9))


# 方法二： from 模块名 import 功能1, 功能2...; 
# 		 功能调用（不需要书写模块名.功能）
from math import sqrt
print(sqrt(9))


# 方法三：from 模块名 import *; 
#		功能调用（不需要书写模块名.功能）
from math import *
print(sqrt(9))

as定义别名

# 模块定义别名
import 模块名 as 别名

# 功能定义别名
from 模块名 import 功能 as 别名

# 模块别名
import time as tt

tt.sleep(2)
print('hello')

# 功能别名
from time import sleep as sl
sl(2)
print('hello')

(2)制作模块

在Python中，每个Python⽂件都可以作为⼀个模块，模块的名字就是⽂件的名字。也就是说⾃定义模块名必须要符合标识符命名规则。

定义模块
新建⼀个Python⽂件，命名为 my_module1.py ，并定义 testA 函数。

def testA(a, b):
 	print(a + b)

调⽤模块

import my_module1
my_module1.testA(1, 1)

注意事项
如果使⽤ from … import … 或 from … import * 导⼊多个模块的时候，且模块内有同名功能。当调⽤这个同名功能的时候，调⽤到的是后⾯导⼊的模块的功能。

# 模块1代码
def my_test(a, b):
 	print(a + b)
# 模块2代码
def my_test(a, b):
	 print(a - b)
 
# 导⼊模块和调⽤功能代码
from my_module1 import my_test
from my_module2 import my_test
# my_test函数是模块2中的函数
my_test(1, 1) #0

(3) _ _ all _ _

如果⼀个模块⽂件中有 all 变量，当使⽤ from xxx import * 导⼊时，只能导⼊这个列表中的元素。

1.python基础

2. 包

包将有联系的模块组织在⼀起，即放到同⼀个⽂件夹下，并且在这个⽂件夹创建⼀个名字为 _ _ init_ _.py ⽂件，那么这个⽂件夹就称之为包。

(1)制作包

[New] — [Python Package] — 输⼊包名 — [OK] — 新建功能模块(有联系的模块)。
注意：新建包后，包内部会⾃动创建 init.py ⽂件，这个⽂件控制着包的导⼊⾏为。

1. 新建包 mypackage
2. 新建包内模块： my_module1 和 my_module2
3. 模块内代码如下

1.python基础

# my_module1
print(1)

def info_print1():
 	print('my_module1')

# my_module2
print(2)

def info_print2():
 	print('my_module2')

(2) 导入包

# ⽅法⼀
import 包名.模块名
包名.模块名.⽬标

import my_package.my_module1
my_package.my_module1.info_print1()

#  __init__.py 
__all__ = ['my_module1']

#⽅法⼆
#注意：必须在 __init__.py ⽂件中添加 __all__ = [] ，控制允许导⼊的模块列表。
from 包名 import *
模块名.⽬标

from my_package import *
my_module1.info_print1()

第七章公共操作

1.运算符

1.python基础

(1) +

# 1. 字符串
str1 = 'aa'
str2 = 'bb'
str3 = str1 + str2
print(str3) # aabb

# 2. 列表
list1 = [1, 2]
list2 = [10, 20]
list3 = list1 + list2
print(list3) # [1, 2, 10, 20]

# 3. 元组
t1 = (1, 2)
t2 = (10, 20)
t3 = t1 + t2
print(t3) # (10, 20, 100, 200)

(2) *

# 1. 字符串
print('-' * 10) # ----------

# 2. 列表
list1 = ['hello']
print(list1 * 4) # ['hello', 'hello', 'hello', 'hello']

# 3. 元组
t1 = ('world',)
print(t1 * 4) # ('world', 'world', 'world', 'world')

(3)in或not in

# 1. 字符串
print('a' in 'abcd') # True
print('a' not in 'abcd') # False

# 2. 列表
list1 = ['a', 'b', 'c', 'd']
print('a' in list1) # True
print('a' not in list1) # False

# 3. 元组
t1 = ('a', 'b', 'c', 'd')
print('aa' in t1) # False
print('aa' not in t1) # True

2.公共⽅法

1.python基础

(1) len()

# 1. 字符串
str1 = 'abcdefg'
print(len(str1)) # 7

# 2. 列表
list1 = [10, 20, 30, 40]
print(len(list1)) # 4

# 3. 元组
t1 = (10, 20, 30, 40, 50)
print(len(t1)) # 5

# 4. 集合
s1 = {10, 20, 30}
print(len(s1)) # 3

# 5. 字典
dict1 = {'name': 'Rose', 'age': 18}
print(len(dict1)) # 2

(2) del()

# 1. 字符串
str1 = 'abcdefg'
del str1
print(str1)

# 2. 列表
list1 = [10, 20, 30, 40]
del(list1[0])
print(list1) # [20, 30, 40]

(3) max()、min()

# 1. 字符串
str1 = 'abcdefg'
print(max(str1)) # g

# 2. 列表
list1 = [10, 20, 30, 40]
print(max(list1)) # 40

# 1. 字符串
str1 = 'abcdefg'
print(min(str1)) # a

# 2. 列表
list1 = [10, 20, 30, 40]
print(min(list1)) # 10

(4) range()

注意：range()⽣成的序列不包含end数字。

# 1 2 3 4 5 6 7 8 9
for i in range(1, 10, 1):
 	print(i)
    
# 1 3 5 7 9
for i in range(1, 10, 2):
 	print(i)
    
# 0 1 2 3 4 5 6 7 8 9
for i in range(10):
 	print(i)

(5) enumerate()

enumerate(可遍历对象, start=0)

注意：start参数⽤来设置遍历数据的下标的起始值，默认为0。

list1 = ['a', 'b', 'c', 'd', 'e']
for i in enumerate(list1):
 	print(i)
# 输出
(0, 'a')
(1, 'b')
(2, 'c')
(3, 'd')
(4, 'e')
     
for index, char in enumerate(list1, start=1):
 	print(f'下标是{index}, 对应的字符是{char}')
  
#输出
下标是1, 对应的字符是a
下标是2, 对应的字符是b
下标是3, 对应的字符是c
下标是4, 对应的字符是d
下标是5, 对应的字符是e

3.容器类型转换

(1) tuple()

作⽤：将某个序列转换成元组

list1 = [10, 20, 30, 40, 50, 20]
s1 = {100, 200, 300, 400, 500}
print(tuple(list1))
print(tuple(s1))

#输出
(10, 20, 30, 40, 50, 20)
(100, 200, 300, 400, 500)

(2) list()

作⽤：将某个序列转换成列表

t1 = ('a', 'b', 'c', 'd', 'e')
s1 = {100, 200, 300, 400, 500}
print(list(t1))
print(list(s1))

(3)set()

作⽤：将某个序列转换成集合

list1 = [10, 20, 30, 40, 50, 20]
t1 = ('a', 'b', 'c', 'd', 'e')
print(set(list1))
print(set(t1))

#输出
{40, 10, 50, 20, 30}
{'e', 'b', 'c', 'a', 'd'}

注意：

集合可以快速完成列表去重
集合不⽀持下标

第八章练习⾯向对象版学员管理系统

使⽤⾯向对象编程思想完成学员管理系统的开发，具体如下：

系统要求：学员数据存储在⽂件中
系统功能：添加学员、删除学员、修改学员信息、查询学员信息、显示所有学员信息、保存学员信息及退出系统等功能。

(1) student.py

需求：

学员信息包含：姓名、性别、⼿机号；
添加 str 魔法⽅法，⽅便查看学员对象信息

class Student(object):
    def __init__(self, name, gender, tel):
        # 姓名、性别、手机号
        self.name = name
        self.gender = gender
        self.tel = tel

    def __str__(self):
        return f'{self.name}, {self.gender}, {self.tel}'


# aa = Student('aa', 'nv', 111)
# print(aa) # aa, nv, 111

(2) managerSystem.py

需求：

存储数据的位置：⽂件(student.data)
加载⽂件数据
修改数据后保存到⽂件
存储数据的形式：列表存储学员对象
系统功能
添加学员
删除学员
修改学员
查询学员信息
显示所有学员信息
保存学员信息

退出系统

1.python基础

class StudentManager(object):
    def __init__(self):
        # 存储学员数据 -- 列表
        self.student_list = []

    # 一. 程序入口函数
    def run(self):
        # 1. 加载文件里面的学员数据
        self.load_student()
        while True:
            # 2. 显示功能菜单
            self.show_menu()
            # 3. 用户输入目标功能序号
            menu_num = int(input('请输入您需要的功能序号：'))

            # 4. 根据用户输入的序号执行不同的功能 -- 如果用户输入1，执行添加
            if menu_num == 1:
                # 添加学员
                self.add_student()
            elif menu_num == 2:
                # 删除学员
                self.del_student()
            elif menu_num == 3:
                # 修改学员信息
                self.modify_student()
            elif menu_num == 4:
                # 查询学员信息
                self.search_student()
            elif menu_num == 5:
                # 显示所有学员信息
                self.show_student()
            elif menu_num == 6:
                # 保存学员信息
                self.save_student()
            elif menu_num == 7:
                # 退出系统 -- 退出循环
                break

    # 二. 系统功能函数
    # 2.1 显示功能菜单 -- 打印序号的功能对应关系 -- 静态
    @staticmethod
    def show_menu():
        print('请选择如下功能：')
        print('1:添加学员')
        print('2:删除学员')
        print('3:修改学员信息')
        print('4:查询学员信息')
        print('5:显示所有学员信息')
        print('6:保存学员信息')
        print('7:退出系统')

    # 2.2 添加学员
    def add_student(self):
        # 1. 用户输入姓名、性别、手机号
        name = input('请输入您的姓名：')
        gender = input('请输入您的性别：')
        tel = input('请输入您的手机号：')

        # 2. 创建学员对象 -- 类 ？类在student文件里面  先导入student模块，再创建对象
        student = Student(name, gender, tel)

        # 3. 将该对象添加到学员列表
        self.student_list.append(student)

        print(self.student_list)
        print(student)

    # 2.3 删除学员
    def del_student(self):
        # 1. 用户输入目标学员姓名
        del_name = input('请输入要删除的学员姓名：')

        # 2. 遍历学员列表，如果用户输入的学员存在则删除学员对象，否则提示学员不存在
        for i in self.student_list:
            if del_name == i.name:
                # 删除该学员对象
                self.student_list.remove(i)
                break
        else:
            # 循环正常价结束执行的代码：循环结束都没有删除任何一个对象，所以说明用户输入的目标学员不存在
            print('查无此人！')

        print(self.student_list)

    # 2.4 修改学员信息
    def modify_student(self):
        # 1. 用户输入目标学员姓名
        modify_name = input('请输入要修改的学员姓名：')

        # 2. 遍历列表数据，如果学员存在修改姓名性别手机号，否则提示学员不存在
        for i in self.student_list:
            if modify_name == i.name:
                i.name = input('姓名：')
                i.gender = input('性别：')
                i.tel = input('手机号：')
                print(f'修改学员信息成功，姓名{i.name}, 性别{i.gender}, 手机号{i.tel}')
                break
        else:
            print('查无此人！')

    # 2.5 查询学员信息
    def search_student(self):
        # 1. 用户输入目标学员姓名
        search_name = input('请输入您要搜索的学员姓名：')

        # 2. 遍历列表。如果学员存在打印学员信息，否则提示学员不存在
        for i in self.student_list:
            if search_name == i.name:
                print(f'姓名是{i.name}, 性别是{i.gender}, 手机号是{i.tel}')
                break
        else:
            print('查无此人！')

    # 2.6 显示所有学员信息
    def show_student(self):
        # 1. 打印表头
        print('姓名\t性别\t手机号')

        # 2. 打印学员数据
        for i in self.student_list:
            print(f'{i.name}\t{i.gender}\t{i.tel}')

    # 2.7 保存学员信息
    def save_student(self):
        # 1. 打开文件
        f = open('student.data', 'w')

        # 2. 文件写入数据
        # 2.1 [学员对象] 转换成 [字典]
        new_list = [i.__dict__ for i in self.student_list]

        # 2.2 文件写入 字符串数据
        f.write(str(new_list))

        # 3. 关闭文件
        f.close()

    # 2.8 加载学员信息
    def load_student(self):
        # 1. 打开文件：尝试r打开，如果有异常w
        try:
            f = open('student.data', 'r')
        except:
            f = open('student.data', 'w')
        else:
            # 2. 读取数据：文件读取出的数据是字符串还原列表类型；[{}] 转换 [学员对象]
            data = f.read()  # 字符串
            new_list = eval(data)
            self.student_list = [Student(i['name'], i['gender'], i['tel']) for i in new_list]
        finally:
            # 3. 关闭文件
            f.close()

(3) main.py

# 1. 导入管理系统模块
from managerSystem import *

# 2. 启动管理系统
# 保证是当前文件运行才启动管理系统：if --创建对象并调用run方法
if __name__ == '__main__':
    student_manager = StudentManager()
    student_manager.run()

1.python基础

文章目录

第一章 基础

1.注释

2.变量

3.输入输出

3.1 输入

3.2 输出

4.转换数据类型

5.运算符

6 条件语句(if)

三⽬运算符

7. 循环（while、for）

8.字符串

常用操作

（1）查找

（2）修改

（3）判断

9. 列表

10.元组

11.集合

12.字典

第二章 函数

1.函数的基本概念

2.变量、函数的参数

3.递归、lambda 表达式

4. ⾼阶函数

第三章 文件操作

1.⽂件的基本操作

（1）打开

（2）⽂件对象⽅法

（3）打开

2.⽂件备份

3.⽂件和⽂件夹的操作

第四章 面向对象基础

1.面向对象重要组成部分

（1）类

（2）对象

2.添加和获取对象属性

3. 魔法⽅法

（1）_ _ init_ _()

（2） _ _ str_ _()

（3） _ _ del _ _()

4. 继承

（1）单继承、多继承、多层继承

（2）⼦类重写⽗类同名⽅法和属性

（3）⼦类调⽤⽗类的同名⽅法和属性

（4） super()调⽤⽗类⽅法

（3）私有权限

定义私有属性和⽅法

获取和修改私有属性值

5.多态

6.类属性和实例属性

7.类⽅法和静态⽅法

(1) 类⽅法

(2) 静态⽅法

第五章 异常

1.异常的写法

2.⾃定义异常

第六章 模块和包

1. 模块

(1) 导入模块

(2)制作模块

(3) _ _ all _ _

2. 包

(1)制作包

(2) 导入包

第七章 公共操作

1.运算符

(1) +

(2) *

(3)in或not in

2.公共⽅法

(1) len()

(2) del()

(3) max()、min()

(4) range()

(5) enumerate()

3.容器类型转换

(1) tuple()

第一章基础

第二章函数

第三章文件操作

第四章面向对象基础

第五章异常

第六章模块和包

第七章公共操作

第八章练习⾯向对象版学员管理系统