2022黑马程序员python基础课程笔记
一、数据容器
1.列表list
mylist = ["itheima", "woshinidie", "hello"]
# 定义空列表
my_list = []
my_list = list()
# 测量长度
# len(list) 统计列表中所有的元素个数(int)
i = len(mylist)
print(f"列表中的元素个数为{i}")
# 查找元素
# list.index(e) 查找元素 方法返回值是e的下标(int)
s = mylist.index("hello")
print(s)
# 插入元素
# list.insert(index,e) 在下标为index的元素之前插入e 方法无返回值(None)
mylist.insert(1, "我是你爹")
print(mylist)
# 追加元素
# list.append(e) 在末尾追加元素e 方法无返回值(None)
mylist.append("World")
print(mylist)
# list.extend(list) 在末尾追加多份元素，可通过追加列表来实现 方法无返回值(None)
mylist.extend(["Fuck", "You", "sbcnm"])
print(mylist)
add_list = ["mlgb", "cnm", "usa"]
mylist.extend(add_list)
print(mylist)
# 删除元素
# list.pop(index) 删除指定下标为index的元素，并返回删除的内容 方法返回值为e(E)
mylist = ["itheima", "woshinidie", "hello"]
pop = mylist.pop(1)
print(pop)
print(mylist)
# del list[index] 关键字del删除
mylist = ["itheima", "woshinidie", "hello"]
del mylist[1]
print(mylist)
# list.remove(e) 删除元素e在列表中的第一个匹配项 方法无返回值(None)
mylist = ["itheima", "woshinidie", "hello", "itheima", "woshinidie"]
mylist.remove("woshinidie")
print(mylist)
# 清空列表
# list.clear() 删除所有元素 方法无返回值(None)
mylist.clear()
print(f"清空后的返回值为{mylist}")
# 统计元素存在数量
# list.count(e) 统计列表中元素e的数量 方法返回值类型为(int)
mylist = ["itheima", "woshinidie", "hello", "itheima", "woshinidie"]
print(mylist)
count = mylist.count("itheima")
print(f"列表中itheima的个数为{count}")
2.元组tuple
- 元组tuple 与 列表list 最大的区别就在于元组不可修改，即元组是一个只读的列表，定义之后再也不可修改；
- 但是，如果元组tuple中有列表元素，则元组内的此列表可以修改。
mytuple = (1,"limengyi",["李梦忆",18,"是个帅哥"])
# 此时，唯独元组内部的列表可以修改
mytuple[2].append("哈哈哈") # 且可以调用列表的方法
- 所以元组的方法比较少，其中与常用的index() count() len()函数或方法与list用法完全相同。
mytuple = (1,"limengyi",True) # 定义之后不可修改，只读
mytuple1 = ("limengyi",) # 当元组内只有一个数据时，最后必须加个‘,’,否则就不是元组
# 定义空元组
my_tuple = ()
my_tuple = tuple()
# 测量长度
# len(tuple) 统计元组中所有的元素个数(int)
i = len(mytuple)
print(f"元组中的元素个数为{i}")
# 查找元素
# tuple.index(e) 查找元素 方法返回值是e的下标(int)
s = mytuple.index("hello")
print(s)
# 统计元素存在数量
# tuple.count(e) 统计元组中元素e的数量 方法返回值类型为(int)
mytuple = ["itheima", "woshinidie", "hello", "itheima", "woshinidie"]
print(mytuple)
count = mytuple.count("itheima")
print(f"元组中itheima的个数为{count}")
3.字符串string
- 字符串也是一个不可修改的量，只能通过创建新的字符串来就收修改后的字符串，原字符串不变
my_str = "itheima and itcast"
# 查找元素
# str.index(e) 查找元素 方法返回值是第一次出现e的位置的下标(int)
s = my_str.index("and")
print(s)
# 替换内容
# str.replace(旧值, 新值) 将str中的每个”旧值“替换成”新值“ 方法返回一个新的字符串(string)
new_str = my_str.replace("it", "程序")
print(new_str)
# 分割字符串
# str.split("分割符") 将字符串str按指定内容(分割符)分割成若干字符串存入新的列表中，原字符串不变(list)
my_list = my_str.split(" ")
print(my_list)
# 删除元素
# str.strip("去除内容") 移除字符串头尾指定的字符（默认为空格或换行符）或字符序列，原字符串不变(string)
my_str = " 12itheima and itcast21 "
# 1.若不传参数，则默认去除字符串首位空格
new_str = my_str.strip()
print(new_str) # >>>12itheima and itcast21
# 2.若传参数，只要头尾包含有指定字符序列中的字符就删除
my_list = "12itheima and itcast21"
new_str = my_list.strip("12") # 此处不仅仅删除了头部"12"字符串，还删除了尾部的字符"1"和"2"
print(new_str) # >>>itheima and itcast
# 统计某元素存在数量
# str.count(e) 统计元组中元素e的数量 方法返回值类型为(int)
my_str = "12itheima and itcast21"
count = my_str.count("it")
print(f"字符串{my_str}中'it'的个数为{count}")
# 统计字符串长度
# len(str) 函数len() 返回(int)
length = len(my_str)
print(length)
4.序列
-
序列是指内容连续、有序、可使用下标索引的一类数据容器。
-
列表、元祖、字符串都是序列
4.1切片
- 从一个序列中，取出一个子序列
# 序列[起始位置下标:截止位置下标:步长] 包头不包尾
list = [0,1,2,3,4,5,6,7]
list[::] # 默认每个位置为[0:末尾:1]
new_list = list[1,5,2] # 表示从第2个元素开始到第6个元素每次跳过1个元素取
print(new_list) # >>>[1, 3]
5.集合set
- 集合无序、不支持下标索引、去重、支持修改元素
my_set = {"itheima", "李梦忆", "大帅哥", "itheima", "李梦忆", "大帅哥", "itheima", "李梦忆", "大帅哥"}
# 定义空集合
my_set_empty = set()
print(my_set_empty) # >>>set()
# 以下所有集合的元素输出顺序都是随机的，不只有所列的一种情况
print(my_set) # >>>{'itheima', '大帅哥', '李梦忆'}
# 添加元素
# set.add(元素)
my_set.add("高大个")
print(my_set) # >>>{'李梦忆', 'itheima', '大帅哥', '高大个'}
# 移除元素
# set.remove(元素)
my_set.remove("itheima")
print(my_set) # >>>{'李梦忆', '大帅哥', '高大个'}
# 随机取出一个元素
# set.pop()
pop = my_set.pop()
print(pop) # >>>大帅哥 # 随机的
print(my_set) # >>>{'高大个', '李梦忆'} # 去除掉随机去除的那个元素
# 清空集合
# set.clear()
my_set.clear()
print(my_set) # >>>set() #变成空集合
# 取差集
# 集合1.difference(集合2) # 得到一个新集合，内含两个集合的差集，原集合不变
my_set1 = {"a", "b", "c", "d", "e"}
my_set2 = {"a", "c", "d"}
difference_set = my_set1.difference(my_set2)
print(difference_set) # >>>{'b', 'e'}
# 集合相减
# 集合1.difference_update(集合2) # 在集合1中去除与集合2共有的元素，集合2不变
my_set1.difference_update(my_set2)
print(my_set1) # >>>{'e', 'b'}
# 取并集
# 集合1.union(集合2) # 得到一个新集合，内含两个集合的并集，即全部元素，原集合不变
my_set3 = {"a", "b", "c", "d", "e"}
my_set4 = {"f", "g", "h"}
union_set = my_set3.union(my_set4)
print(union_set) # >>>{'g', 'e', 'f', 'b', 'a', 'h', 'd', 'c'}
# 获取长度
# len(set)
union_length = len(union_set)
print(union_length) # >>>8
# 遍历
# 由于集合不支持下标索引，所以只支持for循环，不支持while循环
for element in union_set:
print(element, end='')
6.字典dict
- key不允许重复，重复会覆盖原有value的值
- 不可使用下标索引，只能通过key值访问对应的value，所以同样不可使用while循环
- 可通过key值修改对应的value值
# {key: Value, key: Value, key: Value,}
my_dict = {"李梦忆": 98, "张立": 93, "连浩楠": 100}
print(my_dict) # >>>{'李梦忆': 98, '张立': 93, '连浩楠': 100}
# 定义空字典
my_dict_empty1 = {}
my_dict_empty2 = dict()
print(my_dict_empty1) # >>>{}
# 访问value
# dict[key]
score = my_dict["李梦忆"]
print(score) # >>>98
# 取出并删除键值对
# dict.pop(key) # 取出key对应的value并在字典内删除此key的键值对
pop_value = my_dict.pop("张立")
print(pop_value) # >>>93
print(my_dict) # >>>{'李梦忆': 98, '连浩楠': 100}
# 清空字典
# dict.clear()
my_dict.clear()
print(my_dict) # >>>{} #变成空字典
# 获取全部key
# dict.keys() # 取出字典内的全部key，可用于for循环遍历字典
my_dict = {"李梦忆": 98, "张立": 93, "连浩楠": 100}
my_dict_keys = my_dict.keys()
print(my_dict_keys) # >>>dict_keys(['李梦忆', '张立', '连浩楠'])
print(type(my_dict_keys)) # >>>- 字典可嵌套——key不可以为字典，value可以是任意类型
7.数据容器总结
7.1各类数据容器应用场景
- 列表：一批数据，可修改、可重复的存储场景
- 元组：一批数据，不可修改、可重复的存储场景
- 字符串：一串字符串的存储场景集合：一批数据，去重存储场景
- 字典：一批数据，可用Key检索Value的存储场景
7.2容器通用功能总览
二、函数进阶
1.参数种类
def get_message(name, age, gender):
print(f"你的名字是{name}，今年{age}岁了，性别是{gender}")
# 1.位置参数
get_message("limengyi", 19, "男") # >>>你的名字是limengyi，今年19岁了，性别是男
# 2.关键字参数 # 使用关键字传递参数时，可打乱顺序传入
get_message("limengyi", gender="男", age=19) # >>>你的名字是limengyi，今年19岁了，性别是男
# 3.缺省参数(默认参数) # 默认值只能在最后一个或若干个，有默认值的参数不能在无默认值的参数前面，
def get_message(name, age, gender="男"):
print(f"你的名字是{name}，今年{age}岁了，性别是{gender}")
get_message("limengyi", 19) # >>>你的名字是limengyi，今年19岁了，性别是男
get_message("limengyi", gender="女", age=19) # >>>你的名字是limengyi，今年19岁了，性别是女
# 4.不定长参数
# 4.1.位置传递的不定长参数 # args是一个元组容器(tuple)
def get_message(*args):
print(args)
get_message("小明", 18) # >>>('小明', 18)
get_message("小明", 18, "男") # >>>('小明', 18, '男')
# 4.2.关键字传递的不定长参数 # kwargs是一个字典容器(dict) # 调用时：get_message(key = value，key = value)
def get_message(**kwargs):
print(kwargs)
get_message(name="小明", score=98) # >>>{'name': '小明', 'score': 98}
# 5.函数参数
def func_test(func):
result = func(1, 2) # 本质上是计算逻辑不确定，但计算数据确定
print(f"结果为{result}") # >>>结果为3
print(f"参数类型为{type(func)}") # >>>参数类型为2.匿名函数(lambda)
-
使用场景：1.只需一行代码就可以完成的函数
-
2.只需使用一次就再也不用的函数(且只能有一行函数体)
def func_test(func):
result = func(1, 2)
print(f"结果为{result}") # >>>结果为3
print(f"参数类型为{type(func)}") # >>>参数类型为三、文件操作
1.模式
1.1mode类型 说明
- r 以只读⽅式打开⽂件。⽂件的指针将会放在⽂件的开头。这是默认模式。不会创建文件。
- rb 以⼆进制格式打开⼀个⽂件⽤于只读。⽂件指针将会放在⽂件的开头。这是默认模式。
- r+ 打开⼀个⽂件⽤于读写。⽂件指针将会放在⽂件的开头。
- rb+ 以⼆进制格式打开⼀个⽂件⽤于读写。⽂件指针将会放在⽂件的开头。
- w 打开⼀个⽂件只⽤于写⼊。如果该⽂件已存在则打开⽂件，并从开头开始编辑，即原有内容会被删除。如果该⽂件不存 在，创建新⽂件。
- wb 以⼆进制格式打开⼀个⽂件只⽤于写⼊。如果该⽂件已存在则打开⽂件，并从开头开始编辑，即原有内容会被删除。如果该⽂件不存在，创建新⽂件。
- w+ 打开⼀个⽂件⽤于读写。如果该⽂件已存在则打开⽂件，并从开头开始编辑，即原有内容会被删除。如果该⽂件不存在，创 建新⽂件。
- wb+ 以⼆进制格式打开⼀个⽂件⽤于读写。如果该⽂件已存在则打开⽂件，并从开头开始编辑，即原有内容会被删除。如果该⽂件不存在，创建新⽂件。
- a 打开⼀个⽂件⽤于追加。如果该⽂件已存在，⽂件指针将会放在⽂件的结尾。也就是说，新的内容将会被写⼊到已有内容之后。如果该⽂件不存在，创建新⽂件进⾏写⼊。
- ab 以⼆进制格式打开⼀个⽂件⽤于追加。如果该⽂件已存在，⽂件指针将会放在⽂件的结尾。也就是说，新的内容将会被写⼊到已有内容之后。如果该⽂件不存在，创建新⽂件进⾏写⼊。
- a+ 打开⼀个⽂件⽤于读写。如果该⽂件已存在，⽂件指针将会放在⽂件的结尾。⽂件打开时会是追加模式。如果该⽂件不存在，创建新⽂件⽤于读写。
- ab+ 以⼆进制格式打开⼀个⽂件⽤于追加。如果该⽂件已存在，⽂件指针将会放在⽂件的结尾。如果该⽂件不存在，创建新⽂件⽤于读写
2.读
2.1文件的基本操作步骤
打开文件——读写文件——关闭文件
只可以读，不能写入内容
2.2文件的基本操作函数
| 操作 | 功能 |
|---|---|
| 文件对象 = open(file, mode, encoding) | 打开文件获得文件对象 |
| * 文件对象.read(num)——str | 读取指定长度字节，不指定num读取文件全部 |
| * 文件对象.readline()——str | 只读取一行 |
| * 文件对象.readlines()——列表 | 读取全部行，得到列表 |
| * for line in 文件对象——str | for循环文件行，一次循环得到一行数据 |
| 文件对象.close() | 关闭文件对象 |
| with open(file, mode, encoding) as f: | 通过with open语法打开文件，可以自动关闭 |
-
*读取的结尾处会留下标记，下次用任何方式读文件时从标记处开始
-
读取文件后，要用close()进行关闭，否则文件一直被占用
3.写
3.1文件的基本操作步骤
打开文件——写入内存——写入文件（刷新）——关闭文件
只可写，不可读
3.2文件的基本操作函数
| 操作 | 功能 |
|---|---|
| 文件对象 = open(file, mode, encoding) | 打开文件获得文件对象 |
| 文件对象.write(“内容”) | 输入内容，此时是写入内存，没写入文件 |
| 文件对象.flush() | 把堆压在内存里面的内容写入文件 |
| 文件对象.close() | 关闭文件对象，内置flush()方法 |
| with open(file, mode, encoding) as f: | 通过with open语法打开文件，可以自动关闭 |
四、异常处理
1.捕获异常
1.1捕获异常一般形式
# 捕获异常
try:
# 可能发生错误的代码
except: # 捕获所有异常
# 如果出现异常执行的代码
try:
f = open('linux.txt', 'r')
except:
f = open('linux.txt', 'w')
1.2捕获指定异常
# 捕获指定异常
try:
# 可能发生错误的代码
except 异常名 as 存放字符串: # 将异常原因存放在字符串内
# 如果出现异常执行的代码
try:
print(name)
except NameError as e:
print('name变量名称未定义错误')
1.3捕获多种异常
# 捕获多种异常
try:
# 可能发生错误的代码
except (异常名1,异常名2) as 存放字符串: # 将异常原因存放在字符串内
# 如果出现异常执行的代码
try:
print(1/0)
except (NameError, ZeroDivisionError) as e:
print(e)
1.4捕获所有异常
# 捕获所有异常
try:
# 可能发生错误的代码
except Exception as e: # 捕获所有异常
# 如果出现异常执行的代码
try:
print(name)
except Exception as e:
print(e)
1.5else与finally 关键字
# else 与 finally 关键字
try:
f = open('test.txt', 'r')
except Exception as e:
f = open('test.txt', 'w')
else: # 如果没有异常，则执行：
print('没有异常，真开心')
finally: # 不论有无异常，都执行：
f.close()
2.模块的导入方式
import 模块名
from 模块名 import 类、变量、方法等
from 模块名 import *
import 模块名 as 别名
from 模块名 import 功能名 as 别名
3.导入自定义模块
__all__ = ['test_01'] # 1.__all__变量可以控制import *的时候哪些功能可以被导入，默认为全可导入
def test_01(a, b):
print(a + b)
def test_02(a, b):
print(a - b)
if __name__ == '__main__': # 2.表示只有当程序是直接执行的才会进入if内部，如果是被导入的，则if无法进入
test_02(4, 8)
4.自定义包
"""
1. 什么是Python的包？
包就是一个文件夹，里面可以存放许多Python的模块（代码文件），通过包，在逻辑上将一批模块归为一类，方便使用。
2. __init__.py文件的作用？
创建包会默认自动创建的文件，通过这个文件来表示一个文件夹是Python的包，而非普通的文件夹。
里面可以不写任何内容。
3. __all__变量的作用？
同模块中学习到的是一个作用，控制 import * 能够导入的内容，写在__init__.py文件里。
"""
5.安装第三方包
5.1在命令提示符内
- pip install 包名称
- pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名称