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))  # >>><class 'dict_keys'>
# 遍历字典 方式一
for key in my_dict_keys:
    print(f"{key}: {my_dict[key]} ", end='')
    print()
# 遍历字典 方式二 for循环in字典得到的值为key值
for key in my_dict:
    print(f"{key}: {my_dict[key]} ", end='')
    print()

# 获取字典长度
# len(dict)  #获取key的个数
my_dict_length = len(my_dict)
print(my_dict_length)  # >>>3

• 字典可嵌套——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)}")  # >>>参数类型为<class 'function'>
def add(x, y):
    return x+y
func_test(add)  # 传入函数

2.匿名函数(lambda)

• 使用场景：1.只需一行代码就可以完成的函数

• ​ 2.只需使用一次就再也不用的函数(且只能有一行函数体)

def func_test(func):
    result = func(1, 2)
    print(f"结果为{result}")  # >>>结果为3
    print(f"参数类型为{type(func)}")  # >>>参数类型为<class 'function'>


# 匿名函数  <  lambda 参数列表 : 一行代码(函数体)  >
# 一次性函数
func_test(lambda x, y: x + y)  
# >>>结果为3
# >>>参数类型为<class 'function'>

三、文件操作

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 包名称

5.2在PyCharm中安装