个人自用python知识点

str字符串常用方法

str_1 = "abcdefgaaaAGJIFJIJaadfn"

# 1. index 返回某个字符第一次出现的下标，若无则报错
print(str_1.index("a"))
# print(str_1.index("p"))     # 报错

# 2. find 返回某个字符第一次出现的下标，若无则返回-1
print(str_1.find("a"))
print(str_1.find("p"))

# 3. count 统计某一个字符出现的次数
print(str_1.count("a"))

# 4. upper 转大写，并不会改变原有的字符串
print(str_1.isupper())
# 判断是否全部转为大写
print(str_1.upper().isupper())

# 5. lower 转小写，并不会改变原有的字符串
print(str_1.lower())
print(str_1.lower().islower())

# 6. capitalize 首字母大写 其余小写，并不会改变原有的字符串
print(str_1.capitalize())

# 7. swapcase 大小写转换,并不会改变原有的字符串
print(str_1.swapcase())

str_2 = "   abcd   "
# 8. strip 删除左右空格,并不会改变原有的字符串
print(str_2.strip())

# 9. lstrip 删除左空白,并不会改变原有的字符串
print(str_2.lstrip())

# 9. rstrip 删除右空白,并不会改变原有的字符串
print(str_2.rstrip())

# 10. join() 用指定符号对字符串进行拼接
#       join后跟字符串，前面才是指定拼接的字符
#       并不会改变原有的字符串
print("+".join(str_1))
print(str_1)

# 11. replace 替换 ,并不会改变原有的字符串
str_3 = "aaa"
print(str_1.replace("abc", str_3))
print(str_1)

# 12. split 切割字符串
#  如果不加split后面不加指定的分割字符如“+”“-”“.”等，默认为空格
str_4 = "a-b-c-d-e"
print(str_4.split("-"))
print(str_4)

# 13. startswith   判断是不是以某一个字符或字符串开头，若是返回True 若不是返回False
print(str_1.startswith("abc"))

# 14. endswith   判断是不是以某一个字符或字符串结尾，若是返回True 若不是返回False
print(str_1.endswith("dfn"))

# 15. isalpha 判断是不是纯字母,单个字符或者一个字符串,若是则返回True 若不是则返回False
print(str_1.isalpha())

# 16. isdigit 判断是不是纯数字,单个字符或者一个字符串,若是则返回True 若不是则返回False
print("123".isdigit())

# 17. isalnum  判断是不是纯数字或者是纯字母,单个字符或者一个字符串,若是则返回True 若不是则返回False
print("adgagag".isalnum())

# 18. center 居中 它有两个参数,第一个是字符串的总长度,第二个是需要填充的字符(若没有指定字符,默认为空格)
str_5 = "tiam"
print(str_5.center(10, "*"))

# 19. ljust 居左 它有两个参数,第一个是字符串的总长度,第二个是需要填充的字符(若没有指定字符,默认为空格)
print(str_5.ljust(10, "*"))

# 20. rjust 居右 它有两个参数,第一个是字符串的总长度,第二个是需要填充的字符(若没有指定字符,默认为空格)
print(str_5.rjust(10, "*"))



# 遍历字符串
# 1. 不关注索引
for i in str_1:
    print(i)

# 2. 关注索引
for i in range(len(str_1)):
    print(str_1[i])

列表常用方法及遍历

# 定义一个空列表
l = list()
print(type(l))    # <class 'list'>

# 定义一个非空列表
l = [1, 85, 4187, 485, 45, 45, 5, 41]
print(l)            # [1, 85, 4187, 485, 45, 45, 5, 41]

# 列表的索引范围是 0（第一个） 到 len -1（最后一个）
print(l[0])             # 1
print(l[len(l) - 1])    # 41

# 列表的索引范围也可以是 -1(最后一个) 到 -len（第一个）
print(l[-1])            # 41
print(l[-len(l)])       # 1

# 列表的常用方法

# 1. index 返回指定元素第一次出现的下标，若没有则报错
print(l.index(45))      # 4
# print(l.index(3))    # 列表中没有3这个元素，会报错

# 2. count 统计某个元素出现的次数
print(l.count(45))      # 2

# 3. append 在末尾添加元素
l.append(1)
print(l)                # [1, 85, 4187, 485, 45, 45, 5, 41, 1]

# 4. insert 在指定位置插入指定元素
# 在下标为2的位置插入66 ，后面的元素后移
l.insert(2, 66)
print(l)                # [1, 85, 66, 4187, 485, 45, 45, 5, 41, 1]

# 5. extend 在末尾添加多个元素 若是字符串则会将字符串进行拆分在依次放到列表中
# str = "4554354 d 阿萨"
# l.extend(str)
l1 = [4564, 454, 666]
l.extend(l1)
print(l)                # [1, 85, 66, 4187, 485, 45, 45, 5, 41, 1, 4564, 454, 666]
# 6. reverse  将列表进行逆序
l.reverse()
print(l)                # [666, 454, 4564, 1, 41, 5, 45, 45, 485, 4187, 66, 85, 1]

# 7. sort 排序 当列表中的元素都是int型时才能进行排序
l.sort()
print(l)                # [1, 1, 5, 41, 45, 45, 66, 85, 454, 485, 666, 4187, 4564]
# 进行降序排序
l.sort(reverse=True)
print(l)                # [4564, 4187, 666, 485, 454, 85, 66, 45, 45, 41, 5, 1, 1]

# 8. 列表的最大最小值
print(max(l))           # 4564
print(min(l))           # 1

# 9. pop 删除指定下标的元素，没有指定默认删除最后一个,pop有返回值，返回的是删除的值
xx = l.pop()
print(xx)               # 1
print(l)                # [4564, 4187, 666, 485, 454, 85, 66, 45, 45, 41, 5, 1]
l.pop(2)
print(l)                # [4564, 4187, 485, 454, 85, 66, 45, 45, 41, 5, 1]

# 10. remove 删除指定的值，没有则报错,如有有另一个相同的值，则就删除第一次出现的那个
l.remove(45)            
# l.remove(654354)     # 报错
print(l)				# [4564, 4187, 485, 454, 85, 66, 45, 41, 5, 1]

# 遍历列表
# 1. 不关注索引遍历
for i in l:
    print(i)

# 2. 关注索引遍历
for i in range(len(l)):
    print(l[i])

# 清空列表
l.clear()
print(l)

切片

# 对于切片的认识
l = [1, 2, 48, 4, 54, 123, 165, 465]

# 这行代码的输出与 print(l) 的输出一样
# 第一个冒号代表从头开始(下标)，第二个冒号代表到最后结束，最后的1就是隔几个输出一个也就是步长
# [start（包含） : stop（不包含） : step]
print(l[::1])
# 代表了从下标为1的开始打印，打到下标为2的截至，每1个打印一次
print(l[1:3:1])
# 代表了从下标为6的开始打印，打到下标为2的截至，每2个打印一次(这个是逆序打印)
print(l[6:1:-2])

# 当start > stop  step 为负值才能打印出来
# 当start < stop  step 为正值才能打印出来

# 当 start 和 stop 都为冒号时，切片会根据step进行推导
print(l[::-1])

元组

# 元组是一个不可变数据类型（只能拿数据，遍历数据，不能更改数据）
# 定义一个空元组
t = tuple()
print(type(t))
# 定义一个非空元组
t = (123, 15, 1, 545, 3, 1, 1, "4145")

# 常用的方法
# 1. index 返回某元素第一次出现的索引
print(t.index(1))
# 2. count 统计某个元素出现的次数
print(t.count(1))

# 遍历元组
# 直接遍历
for i in t:
    print(i)

# 通过下标进行遍历
for i in range(len(t)):
    print(t[i])

字典

# 定义一个空字典
d = dict()
print(type(d))
# 定义一个非空字典
d = {
    "name": "张三",
    "sex": "男"
}
print(type(d))

# 为字典添加一个键值对
d["age"] = 18
print(d)

# 字典的常用方法
# 1. 判断某个键是否在字典中
if "name" in d:
    print("这个键在字典中")
else:
    print("这个键不在字典中")
# 2. 获取字典中所有的key,以列表的方式进行返回
print(d.keys())
# 3. 获取字典中所有的value,以列表的方式进行返回
print(d.values())
# 4. 获得所有的键值对,以列表的方式进行返回
print(d.items())
# 拿到某一个key的值 ,直接拿的话,若字典中没有需要的值则会报错
temp = d["name"]
# temp = d["class"]         # 没有对应的key 进行报错
print(temp)
# 5. 用get方法拿值,这种方法若没有对应的key,不会进行报错,   如果没有对应的key,可以在参数写一个默认值
temp = d.get("name", 123)
temp = d.get("class", 123)
print(temp)
# 6. 更新（合并）字典 ****比较重要
d.update(
    {
        "name": "李四",
        "address": "河南省"
    }
)
print(d)

# 7. 删除键值对，并返回删除键所对应的值
# print(d.pop("address"))

# 8. 删除对后一个键值对
# print(d.popitem())

# 字典的遍历方法
# 1. 通过key进行遍历
for i in d.keys():
    print(d[i])
# 2. 直接获取所有的值，不通过key
for i in d.values():
    print(i)
# 3. 获取所有的键值对进行遍历,可以拿到所有的key和value
for key, value in d.items():
    print(key, value)

# 删除字典
print(d.clear())  # None

集合

# 定义集合  注意和字典机进行区分
# set 无序且不可重复
set0 = set()
set1 = {12, 74, 88}
print(type(set1))

for e in set1:
    print(e)

# add可向set添加一个值
set1.add(6)
print(set1)

# update相当于合并数据
set1.update({1, 12, 3, 6})
print(set1)

# 删除指定值 remove在删除集合中不存在的元素是会报错，但是discard不会,这两个方法都没有返回值
print(set1.remove(12))		# None
print(set1.discard(13))		# None
print(set1)
# 清空集合
set1.clear()
print(set1)		# set()

# set1 = {45, 15, 21, 2, 14}
# set2 = {54, 45, 48, 15, 5}
# # 集合交集的两种写法
# print(set1.intersection(set2))
# print(set1 & set2)
#
# # 集合并集的两种写法
# print(set1.union(set2))
# print(set1 | set2)
#
# # 集合差集的两种写法
# print(set1.difference(set2))
# print(set1 - set2)
#
# print(set2.difference(set1))
# print(set2 - set1)

推导式

# 生成多个数据比较方便
# 列表推导式
l0 = [x for x in range(1, 100) if x > 10]
print(l0, type(l0))

# 元组推导式
s0 = (x for x in range(1, 10))
for i in s0:
    print(i, end=" ")
print(s0, type(s0))

# 字典推导式
d0 = {f"key_{x}": f"value_{x}" for x in range(10)}
print(d0, type(d0))

# 集合推导式
set0 = {f"{x}" for x in range(10)}
print(set0, type(set0))

copy

# 测试拷贝
import copy

# 1. 等号赋值，复制对象的地址。相当与使用的是同一个地址
l = [1, 2, ["A", "B"]]
l1 = l
l[0] = 10
print(l1)
print(id(l), id(l1))


# 2. 浅拷贝copy
# 浅层拷贝是指拷贝一个对象时，只拷贝该对象的引用，并不拷贝对象中的元素。如果原对象中的元素是可变对象（如列表、字典等），则拷贝后的对象与原对象共享这些可变对象。
l = [1, 2, ["A", "B"]]
l1 = l.copy()
l[0] = 10
l[2].append("C")
print(l1)
print(id(l[2]),id(l1[2]))

# 3. 深拷贝 copy.deepcopy
# 深层拷贝是指拷贝一个对象时，不仅拷贝该对象的引用，还会递归拷贝对象中的元素，使得拷贝后的对象与原对象完全独立，互不影响。
l = [1, 2, ["A", "B"]]
l1 = copy.deepcopy(l)
l[0] = 10
l[2].append("C")
print(l1)
print(id(l[2]), id(l1[2]))

# 拷贝°与深拷贝的区别？
'''在Python中，浅拷贝（ShallowCopyQ）与深拷贝（Deep Copy）主要涉及复杂对象（如列表、字典等）的复制方式，这两种复制方式处理对象内部的子对象的方式不同。
	浅拷贝创建一个新对象，其内容是原对象内各元素的引用。如果原对象包含的是不可变对象（如字符串、整数等），这种区别几乎察觉不到。但如果对象包含的是可变对象（如列表、字典等），修改新对象中的可变元素将影响到原对象，因为两者引用的是同一个可变元素。Python标准库中的copy模块提供的copy函数可以用来执行浅拷贝。
	深拷贝不仅复制了原对象，而且递归地复制了对象内的所有可变元素及其包含的所有元素，因此原对象和新对象完全独立。对新对象的任何修改都不会影响原对象，反之亦然。这在处理包含复杂、嵌套对象的情况时非常有用。copy模块提供的deepcopy()函数用于执行深拷贝。'''

装饰器

# 什么是装饰器
# 在不改变函数原有功能（实现）的情况下，对其增加新的功能
# 比如说对原有函数增加一个时间统计类，或者说给原有函数增加一个权限校验的功能

# 装饰器是根据闭包进行实现的，那么什么是闭包呢
# 在Python中，闭包（Closure）是一种函数，它能够记住并访问其词法作用域，即使函数在其作用域之外执行。
# 闭包的概念与匿名函数或函数对象紧密相关，但它特指那些能够访问定义在其外部作用域的非全局变量的函数。

# 闭包（三个必要的条件）
# 1. 外部函数嵌套内部函数
# 2. 外部函数将内部函数返回
# 3. 内部函数可以返回外部函数的局部变量

# 这种结构允许内部函数记住外部函数的环境，即使外部函数已经执行完毕。这个特性使得闭包成为实现数据隐藏和封装的强大工具。
# 闭包的使用场景：
# 保持状态：闭包可以记住和继续访问定义它们的函数的局部变量，这对于实现类似于对象的状态保持非常有用。
# 数据封装：通过闭包，可以创建私有变量，这些变量只能通过闭包提供的方法访问，而不是直接访问。
# 回调函数：在事件驱动或异步编程中，闭包允许回调函数访问与事件处理相关的额外数据。


import time

# 一个计算函数运行时间的装饰器
def count_time(f):
    # 计算运行时间装饰器的内部类，要被外部函数返回
    def count():
        # 在内部函数中对原有函数增加计算运行时间的功能
        start = time.time()
        f()
        end = time.time()
        print(f"{f.__name__}运行时间为：{end - start}")
    return count

def req(f):
    def check():
        user = input("请输入用户名：")
        pwd = input("请输入密码：")
        if user == "admin" and pwd == "123":
            f()
        else:
            print("权限不足！")
    return check
@count_time
@req
def login():
    time.sleep(2)
    print("登录成功")


login()

异常处理

# 异常：异常即是一个事件，该事件会在程序执行过程中发生，影响了程序的正常执行。
# try/except/finally语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理。
# 在except后面可以指定异常的类型,可以指定多个，不写默认捕获所有类型
# finally里面的内容在异常发生或者不发生都会执行，不需要也可以不写
try:
    a = 1/0
except ZeroDivisionError as e:
    print(e)
finally:
    print("finally执行了")


# 可以手动抛出异常，使用raise
try:
    raise Exception("出错了，修不好的那种")
except Exception as e:
    print(e)
finally:
    print("修不好是不可能的")

可迭代，迭代器，生成器

from collections.abc import Iterable, Iterator

# 可迭代就是可以进行遍历，其内部实现了__iter__函数，
# 迭代器在可迭代的基础上又实现了__next__函数，可以使用next()取下一个元素
# 手写一个类，实现__iter__和__next__,然后通过next获取每一个元素
# 当next()取到所有元素的，再次调用next()时，会出现IndexError异常

class MyStr:
    def __init__(self, s):
        self.s = s
        self.index = 0

    # iter方法返回的是自身
    def __iter__(self):
        return self

    def __next__(self):
        e = self.s[self.index]
        self.index += 1
        return e

    # def __next__(self):
    #     if self.index >= len(self.s):
    #         raise StopIteration
    #     else:
    #         e = self.s[self.index]
    #         self.index += 1
    #         return e

s0 = MyStr("思绪")

print(isinstance(s0,Iterable), isinstance(s0,Iterator))
# print(next(s0))
# 用for获取所有的元素
# for i in s0:
#     try:
#         print(i)
#     except StopIteration:
#         break
#
# 用while获取到所有的元素，捕获可能发生的异常
while True:
    try:
        print(next(s0))
    except IndexError as e:
        print(e)
        break
        

# 生成器的优点，存储的是生成的算法，极大的省内存空间
# 缺点,只能从前往后依次取数据

l0 = [i for i in range(100)]
print(l0, type(l0))
# 查看占用的字节大小
print(l0.__sizeof__())
print(l0[-1])

# 元组推导式的类型是一个生成器
t0 = (i for i in range(100))
print(t0, type(t0))
# 查看占用的字节大小
print(t0.__sizeof__())
# print(t0[-1])         # 会报错
# print(next(t0))
# for i in t0:
#     print(i, end=' ')
# print()


# 返回值作为了异常的信息，出现异常并打印异常信息时才会显示出来
def gen():
    for i in range(10):
        yield f'思绪{i}'
    return 0

g = gen()
print(g, type(g))
# for e in g:
#     print(e)
while True:
    try:
        print(next(g))
    except StopIteration as e:
        print(e)
        break