Python

Python教程1

official::Python教程

反编译

text::数据结构与算法

---

〇、基本概念

静态语言 编译 先编译再执行 例：C

脚本语言 解释 边编译边执行 例：python

1 pyCharm

设置中文：File——Setting——Plugins——Chinese (Simplified) Language Pack

# pyCharm中设置代码模板：设置——编辑器——模板——Python Script

#-*- codeing = utf-8 -*-
#@Time: ${DATE} ${TIME}
#@Author: author
#@File: ${NAME}.py
#@Software: ${PRODUCT_NAME}

pyCharm快速添加引号：
    1. ctrl + r
    2. 上方填入(.*?):(.*)，选择正则表达式
    3. 下方填入'$1':'$2'

2 类型

不可变数据类型：Number、String、Tuple。

可变数据类型：List、Dictionary、Set。

可变数据类型在值变化后地址不会改变。不可变数据类型在值变化后会重新开辟空间并修改地址。

3 常见语句

print：使用 参数设置

pass / …的用法

todo：待做。pyCharm中点击下方todo可以看到所有todo。

'''
输出
格式：print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
objects -- 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
sep -- 用来间隔多个对象，默认值是一个空格。
end -- 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
file -- 要写入的文件对象。
flush -- 输出是否被缓存通常决定于 file，但如果 flush 关键字参数为 True，流会被强制刷新。
输出百分号的方法：%%
'''
print(1)

# 输入（结果为字符串）
input()

# 计算eval()中的字符串值（数字，列表，字典，元组皆可）（字符串会被当做变量）
eval('str')

# 释放变量（不可以删集合元素）
del variable[index]

__init__ # 类的初始化数据
__doc__ # 查看函数属性

# match选择
match num:     # switch 
    case 1:    # 自带 break
    case 2:
    case _:    #  default
        
# 函数内赋值（:=）
print( val := function() , val ** 2 )
if (length := len(string)) > 10:
    pass

# 普通的数据处理
input()
print()

4 常用函数

# 判断类型是否相同（可以多重匹配）
isinstance (a,int)
isinstance (a,str)
isinstance (a,(str,int,list)) # 是元组中的一个返回 True

# 除法并取余
quotient , remainder = divmod( dividend , divisor )

# 字符转ASCII码
ord('A')
# ASCII码转字符
chr(65)

5 内存

# python中对于小整数对象有一个小整数对象池，范围在[-5,257)之间。对于在这个范围内的整数，不会新建对象，直接从小整数对象池中取就行。 
lst1 = [2,3]
lst2 = [1,4,5,2]
print(id(lst1[0]) == id(lst2[3])) # 返回True

---

二、字符串

1 普通函数

字符串函数 格式化输出

# 字符串格式化输出
# { [index][ : [ [fill] align] [sign] [#] [width] [.precision] [type] ] }
str.format(args)

# 把s按seq分隔符分割[ num 个]数据存在列表中
s.split(sep,[ num ])

# 从左右去除字符（只要字符在str中就会去除），直到某个s中的字符不在str中便停止
s.strip(["str"])
s.lstrip(["str"]) # 只去左边
s.rstrip(["str"]) # 只去右边

# 把seq按 "" 中的东西组成新字符串
"".join(seq)

# 判断是否是数字
s.isdigit() ：

# 统计字符串在s中出现次数
s.count("str")

# 返回子串出现在s的位置，没找到会报错
s.index("str")

# 旧字符换新，最多max次
s.replace(old, new[, max])

# 字符串获得子串
s = s[::]

2 字符串前的符号

# 后面的字符串会以Unicode格式进行编码，常用于中文
u"str"
# 去掉转义功能
r"str"
# 字符串是 bytes 类型，用于网络传输中
b"str"
# 识别 str 中的格式化输出
f"str"

# 案例
lst= [1,2,3]
print(lst, f'has a length of {len(lst)}.')

---

三、列表与元组

1 列表

普通函数

浅拷贝和深拷贝

# 可变数组
list()

# 拷贝
# 两者id相同。
a = b 

# 一维列表复制不关联，二维依旧关联。
a = b.copy()

# 深拷贝，二维也不关联。
a = b.deepcopy() 

# 删除列表元素
del(lst[index])

# 追加
lst.append(x)	# 追加单个元素
lst.extend(lst)	# 追加多个元素

# 删除
lst.pop([index]) # 默认弹出尾部元素，也可以的自定义位置

# 排序（默认升序）
lst.sort(reverse=False)	

# 反转
lst.reverse()

# 统计某个元素的个数
lst.count(val)

# 列表第一列排序（指定列排序）
lst.sort(key=lambda x:x[0])

2 元组

元素不可被修改（列表可以用extend扩展）的列表（只可拼接）：tuple()

括号可以省略。

当元组中只有一个元素时，逗号不可省略。（ tup = (1,) ）

map()

zip()

enumerate()

# 根据提供的函数对指定序列做映射
map()
map(iter,type)
map(list,int)

# 用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表
zip()
zip(iter[,iter...])
zip(a,b)

# 用于将一个可遍历的数据对象（如列表、元组或字符串）组合为一个索引序列。（每个值为一个元组（索引，值））
for idx,num in enumerate(lst):
    print(idx,num)

# 解包（二维列表用：zip(*lst)会获得每一列的值）
* + 可迭代对象
*zip(lst)


# 元组嵌套
# 判断嵌套元组中是否存在某元素值
def is_value_in_nested_tuple(value, nested_tuple):
    for item in nested_tuple:
        if isinstance(item, tuple):  # 如果当前元素是嵌套元组，则递归调用本函数
            if is_value_in_nested_tuple(value, item):
                return True
        elif item == value:  # 如果当前元素与指定值相等，则返回True
            return True
    return False  # 遍历完所有元素都没有找到指定值，则返回False

---

四、字典与集合

1 字典

键值对，dict()

Counter()

# 普通方法
# 返回所有键信息
dic.keys()

# 返回所有值信息
dic.values()

# 返回所有键值对（元组形式）
dic.items()

# 返回值，不存在返回默认
dic.get(key,default)

# 返回值，删除键值对，不存在返回默认
dic.pop(key,default)

# 删除最后一个键值对，返回元组
dic.popitem()

# 清空
dic.clear()

# 浅/深拷贝
dic.copy()/.deepcopy()

# 按字典2的方式更新字典1
dic.update(dicts2)

# 返回key对应的值，key不存在返回default
dic.get(key, default=None)

# in 测试的是键是否在字典中 
key in dicts

# 技巧
# 字典键值互换：
dic2 = {value: key for key, value in dic1.items()}

# 键最大的键（返回最大值的键值）
max( dic ) 
# 值最大的值
max( dic.values() )
# 键最大的值
dic[ max(dic) ]
# 值最大的键
max( dic, key=dic.get)
max( dic,key=lambda x:len(dic[x])) # 列表

# 列表变成字典
lst = [ [ key,value ] , ... ]
dic = dict( lst )

# 将字典中所有键提取出来作为位置参数传递
*dic
# 将字典中所有键值对提取出来作为关键字参数传递
**dic

# 计数器，Counter 中的键为待计数的元素，而 value 值为对应元素出现的次数 count。
# 使用Counter应当 from collections import Counter 

from collections import Counter
#  实例化元素为空的 Counter 对象
a = Counter()

#  从可迭代对象中实例化 Counter 对象
b = Counter('chenkc')

#  从 mapping 中实例化 Counter 对象
c = Counter({'a':1, 'b':2, 'c':3})

#  从关键词参数中实例化 Counter 对象
d = Counter(a = 1, b = 2, c = 3)

# 默认键类型
dic = collections.defaultdict(list)
# 双端队列
collections.deque()

2 集合

数学集合，set()

# 在S中移除，不在不报异常
S.discard(x)

# 在S中移除，不在报KeyError
S.remove(x)
 
# 判断S与T中是否存在相同元素，没有为真
S.isdisjoint(T)

# 交集
res = set1 & set2
res = set1.intersection(set2)

# 并集
res = set1 | set2
res set1.union(set2)

# 差集
res = set1 - set2
res = set1.difference(set2)

# 补集（对称差集）
res = set1 ^ set2
res = set1.symmetric_difference(set2)

# 判断 set1 是否是 set2 的子集
subset_check = set1 in set2
subset_check = set1.issubset(set2)

# 判断 set1 是否是 set2 的超集
superset_check = set2 in set1
superset_check = set1.issuperset(set2)  

---

五、函数

1 变量范围

# global:全局变量，先定义再使用
a = 10
def func():
    global a
    a = 15
func()
print(a) # 输出15

# nonlocal:非局部变量，可以被函数中的函数使用，先定义再使用，外部函数也要有该变量。
def outer():
    x = 10
    def inner():
        nonlocal x
        x = 20
    inner()
    print(x) # 输出20
outer()

2 自定义函数

函数参数：args

字符串方式访问函数

def funcname (paras:types)->types :
    statements
    [return[expression]]


# 函数内部定义函数并在函数内部使用。也可以把内部函数作为返回值返回给外部。（闭包：内部函数使用了外部函数的变量）
def func():
    def new_func():
        pass
    new_func()
   

# 函数参数
# 位置参数（依次赋值）
def test(a,b)
test (1,2)

# 赋值参数（直接赋值）
def test(a,b)
test (b=1,a=2)

# 默认参数（不赋值将使用默认值）
def test (a,b=2)
test (1)
#默认参数注释为 (b:int=2)

# 可变参数
# 一个星号：输入的多个值以元组保存，输入：1,2,3，注意：此时值直接转化成列表为 [( 1,2,3 )]
# 两个星号：输入的多个值以字典保存，输入：a=5,b=6,c=7
def test ( name, *args , **kwargs ):
    pass


# 字符串名访问函数
eval( str )()

# 默认参数案例
def fun(a=(),b=[]):
    a += (1,)
    b.append(1)
    return a,b

fun()
print(fun())
'''
输出：((1,), [1, 1])
Python的默认参数只在函数定义时被赋值一次，而不会每次调用函数时又创建新的引用。
元组不可修改 所以调用了两次函数，第二次元组初始也是空元组，所以只有一个元素。
'''

# 闭包返回函数案例
def fn():
    t = []
    i = 0
    while i < 2:
        t.append(lambda x: print(i*x,end=","))
        i += 1
    return t

for f in fn():
    f(2)
'''
输出：4,4, 因为在for的时候fn中的循环先被执行完了，此时i = 2，然后再调用print函数。
'''

3 yield

yield 的作用就是把一个函数变成一个 generator。

在 for 循环执行时，每次循环都会执行 fab 函数内部的代码，执行到 yield b 时，fab 函数就返回一个迭代值。

# 案例（10以内的阶乘）
def jie(now):
    count = 1
    for i in range(1, now + 1):
        count *= i
        yield i
        yield count
jar = jie(10)
for i in jar :
    print("{}:".format(i), end = "")
    i = jar.__next__()
    print("{}".format(i))

4 匿名函数

lambda parameters : expression

# 按出现次数最多从小到大排序
cnt = Counter(barcodes)
barcodes.sort(key=lambda x: (-cnt[x], x))

5 常用函数

any() all()

# 数学操作
#返回绝对值
abs(num)
# 返回浮点数四舍五入后的值（int()是向下取整）
round(num)
# 返回 dividend/divisor 和 dividend%divisor 的元组
quotient,remainder = divmod( dividend , divisor ) 

# 转化函数
# int()  str->int（字符串数字依照base规则转成十进制）
int(str, base=10)  # str是字符串，base表示进制，默认十进制。

# hex()  int->int（十进制转十六进制）
hex() # 函数用于将10进制整数转换成16进制，以字符串形式表示。返回 '0x....'

# bin()  int->int（十进制转二进制）
bin() # 返回一个整数 int 或者长整数 long int 的二进制表示。返回 '0b....'

# chr()  int->ASCII（整型转ASCII码）
chr() # 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符。

# ord()  ASCII->int（ASCII码转整型）
ord() # 主要用来返回对应字符的 ascii 码

# 用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。
any(iter)
# 用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。
all(iter)

# 保留满足function条件的iter，返回列表
filter(function,iter)
# 按function规则累加，init：初值
reduce(function,iter[,init])

6 装饰器

装饰器

多个装饰器从下往上调用。

定义：在函数调用前先调用闭包的函数，参数传递是传给是闭包的函数。

@cache 装饰器：一种装饰在被执行的函数上，将其执行的结果缓存起来的缓存装饰器。当下次请求的时候，如果请求该函数的传参未变则直接返回缓存起来的结果而不再执行函数。

@property：装饰函数后，该函数会变成属性且变为只读，使用时不用带括号，函数没有参数。

def Do_Add(ad):
    def Add(a,b):
        print("hello")
        c = ad(a,b)
        print("value:%d"%c)
    return Add

# 调用方法1：
def ad(a,b):
    c = a + b
    return c

myfunc = Do_Add(ad)
myfunc(5,6)

# 调用方法2：
@Do_Add
def ad(a,b):
    c = a + b
    return c

ad(1,2)

# 装饰器，获得函数名字
def get_func_name(func):
    def wrapper(*args, **kwargs):
        print(f"Calling function: {func.__name__}")
        result = func(*args, **kwargs)
        return result
    return wrapper

@get_func_name
def add(a, b):
    print(a + b)

add(1, 2)


# 带有参数的装饰器
def log_decorator(log_level='INFO'):
    def decorator(func):
        def wrapper(*args, **kwargs):
            print(f"{log_level}: Entering function {func.__name__}()")
            result = func(*args, **kwargs)
            print("result:",end=" ")
            print(result)
            print(f"{log_level}: Exiting function {func.__name__}()")
            return result
        return wrapper
    return decorator

# 使用装饰器并传递参数
@log_decorator(log_level='INFO')
def multiply(a, b):
    print(1)
    return a * b

# 调用装饰后的函数
multiply(5, 4)

# 函数作为属性且只可读
@property
def name(self):
    return self._name

# 函数作为属性且只可写
@name.setter
def name(self, value):
    self._name = value

---

六、类与对象

1 定义

变量：

• 成员变量：self

• 类变量：方法外定义的变量

类变量可以通过类名加变量名访问，也可以通过对象名加变量名访问。在实例化对象后，若类变量没有修改过值，通过类名加变量名修改类变量值将会同时作用于类和对象。若类变量修改过值，类变量相当于变成了实例变量，通过类名加变量名的方式将不会再修改对象类变量值。后续实例化对象后实例出的类变量值则是实例化最新的变量值。

方法：

• 成员方法：带参self，可以访问类变量和成员变量，可以用对象名访问。
• 普通方法：任意参，可以访问类变量和成员变量，可以用对象名和类名访问。
• 类方法：类方法装饰器@classmethod，参数cls，可以访问类变量，可以用对象名和类名访问。
• 静态方法：静态方法装饰器@staticmethod，无参，不可以访问类变量和成员变量，可以用对象名和类名访问。

# 案例
class MyClass:
    # 类变量
    class_var = "This is a class variable"

    def __init__(self, instance_var):
        # 成员变量
        self.instance_var = instance_var
	# 方法
    def common_method():
        print("This is an common method")
        
    def instance_method(self):
        print("This is an instance method")
        print("Accessing instance variable:", self.instance_var)
        print("Accessing class variable:", self.class_var)

    @classmethod
    def class_method(cls):
        print("This is a class method")
        print("Accessing class variable:", cls.class_var)

    @staticmethod
    def static_method():
        print("This is a static method")
        
        
# 类变量案例
class Base(object):
    count = 0
    def __init__(self):
        pass
    
b1 = Base()
b2 = Base()
# 对象类变量不影响类中类变量
b1.count = b1.count + 200
print(b1.count," ",Base.count," ",b2.count)
# 类变量修改不影响对象的类变量修改过的对象
Base.count = Base.count + 5
print(b1.count," ",Base.count," ",b2.count)
# 对象的类变量修改后通过修改类的类变量的方式将不影响对象的类变量
b2.count = b2.count + 100
print(b1.count," ",Base.count," ",b2.count)

Base.count = Base.count + 50
print(b1.count," ",Base.count," ",b2.count)
# 新实例化的对象是新的类的类变量值
b3 = Base()
print(b1.count," ",Base.count," ",b2.count," ",b3.count)

2 方法参数

对象：self

类：cls的使用

私有参数：__name

# self
class Dog:
    def __init__(self):
        self.age = 6
       
    def my_print(self):
        print(self.age)
        
        
# cls
class MyClass:
    def __init__(self, name):
        self.name = name

    @classmethod
    def create(cls, name):
        obj = cls(name)
        return obj

    def display(self):
        print("Name:", self.name)

my_obj = MyClass.create("Alice")
my_obj.display()  # 输出: Name: Alice


# python的私有参数强制访问（object._calss__variable）
class NewClass:
    def __init__(self):
        self.__name = "1"

new = NewClass()
print(new._NewClass__name)

3 高级特效

继承的规则：如果有单个父类，则直接继承；如果有多个父类，则按照顺序从左到右依次继承

所有的类默认继承object类，object是python中所有类的基类

super().father_function()调用父类方法

方法重写：子类重写和父类同名同参的方法后，系统在调用时将调用子类重写后的方法

# 继承和重写
# 父类
class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print(f"{self.name} is making a sound.")

# 子类
class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)
        self.breed = breed

    def speak(self):
        print(f"{self.name} is barking.")

# 创建父类对象
animal = Animal("Generic Animal")
animal.speak()  # 输出: Generic Animal is making a sound.

# 创建子类对象
dog = Dog("Buddy", "Labrador")
dog.speak()  # 输出: Buddy is barking.

4 魔法方法

__new__是一个类级别方法（classmethod），它在对象实例化之前被调用。它负责创建并返回实例对象，在实例化过程中是第一个被调用的方法。它的主要作用是控制对象的创建过程，也就是创建一个空类。

__init__是一个实例级别方法（instancemethod），它在对象实例化之后被调用。它用于初始化实例的属性，并在对象创建后进行额外的设置，也就是初始化数据。

对于new和init区别：

• __new__是一个静态方法，而__init__是一个实例方法
• __new__方法会返回一个创建的实例，而__init__什么都不返回
• 只有在__new__返回一个cls的实例时，后面的__init__才能被调用
• 当创建一个新实例时调用__new__，初始化一个实例时用__init__

常用魔术方法

魔术方法名	作用
__new__()	初始化对象
__init__()	初始化对象内容
__del__()	删除对象
__str__()	对象的字符串表示
__repr__()	对象的非正式字符串表示
__len__()	返回对象的长度
__call__()	对象的可调用行为

class MyClass:
    def __new__(cls, *args, **kwargs):
        print("Creating instance using __new__")
        instance = super().__new__(cls)
        return instance

    def __init__(self, value):
        print("Initializing instance using __init__")
        self.value = value

# 创建对象
obj = MyClass(10)

5 重载

类的重载：overload

# 类函数重载
# 类初始化重载
@typing.overload
__init__(): #靠参数注释区分

# 类方法重载
@overload
def func(): #靠参数注释区分
    
    
# 类方法重载
#加减乘除余
__add__
__sub__
__mul__
__div__
__mod__

# 打印或转化 print()、repr()、str()
__repr__、__str__ 
# 索引获取
__getitem__
# 索引赋值
__setitem__
# 删除索引和分片
__delitem__
# key in map
__contains__
# 获得长度
__len__

# 等于/不等于
__eq__、__ne__
# 小于/小于等于
__lt__、__le__
# 大于/大于等于
__gt__、__ge__

# 可迭代（return self.iter.__iter__()，可用 for 依次取出）
__iter__

# 访问类中不存在的属性时触发
__getattr__
# 访问类中属性时触发
__getattribute__

# 向量相加（重载__add__）
class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __add__(self, other):
        if isinstance(other, Vector):
            new_x = self.x + other.x
            new_y = self.y + other.y
            return Vector(new_x, new_y)
        else:
            raise TypeError("Unsupported operand type: {} and {}".format(type(self), type(other)))

    def __str__(self):
        return "({}, {})".format(self.x, self.y)

# 创建两个向量对象
v1 = Vector(1, 2)
v2 = Vector(3, 4)

# 使用+运算符将两个向量相加
result = v1 + v2

# 输出结果
print(result)  # 输出: (4, 6)

6 接口

在python中，若函数中存在：raise NotImplementedError("...")，那么子类必须要继承并重写这个函数。（类似接口、抽象类和抽象方法）

# 利用NotImplementedError进行接口书写
class Father(object):
    # 父类接口
    def f1(self):
        raise NotImplementedError(".f1() must be overridden")
        
class Child(Father):
    # 子类重写
    def f1(self):
        print("Hello World")

# 利用ABC进行接口书写
from abc import ABC, abstractmethod

# 定义一个接口类
class Shape(ABC):
    # 定义一个抽象方法
    @abstractmethod
    def area(self):
        pass

# 通过继承接口类，创建一个具体的类
class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius * self.radius

# 创建一个抽象类
class Animal(ABC):
    # 定义一个抽象方法
    @abstractmethod
    def make_sound(self):
        pass

# 通过继承抽象类，创建具体的子类
class Dog(Animal):
    def make_sound(self):
        return "汪汪汪"

# 使用具体的类
circle = Circle(5)
print("圆的面积:", circle.area())  # 输出：圆的面积: 78.5

dog = Dog()
print("狗发出的声音:", dog.make_sound())  # 输出：狗发出的声音: 汪汪汪

---

七、存储

1 开关文件

# 打开文件（mode默认只读，encoding编码方式）
myfile = open ( filename [ , mode ] [ , encoding= ] )
# with会在完成工作后自动关闭文件，防止资源占用
with open() as name 

'''
r/w/a：读写追加
b：二进制形式
+：以读/写方式打开
'''
#[, newline=None]：保证不同平台换行符被正确读入

# 关闭文件
myfile.close()
# 缓冲区内容写入文件但不关闭文件
myfile.flush()

2 读写数据

# 读
# 全读，返回字符串，size限定字符或字节数
read( [ size ] )
# 读一行，返回字符串，size限定当前行字符或字节数
readline ( [ size ] )
# 读全行，返回行列表，hint限定行数
readlines ( [ hint ] )
# 检查可读性
readable()

# 写
# 写str进入文件
write( str )
# 写seq_of_str进入文件，seq_of_str为可迭代对象
writelines( seq_of_str )
# 检查可写性
writable()

# 指针
# 获得文件指针位置
tell()
# offset：偏移量，whence：方向（0：从起始位置移动，1：从当前位置移动，2：从结束位置移动，默认0）
seek( offset [ , whence ] )

# 读写对象
#对象写（写一个）
pickle.dump( obj , file )
# 对象读（读一个）
pickle.load( file )

3 os模块和os.path模块

#os.path
# 返回path绝对路径
abspath( path )
# 返回path的目录
dirname( path )
# path存在返回True否则False
exists( path )
# 返回path最后存取时间
getatime( path )
# 返回path最后修改时间
getmtime( path )
# 返回path文件的大小（字节）
getsize( path )
# path是否是绝对路径
isabs( path )
# path是否是一个存在的目录
isdir( path )
# path是否是一个存在的文件
isfile( path )
# 将path分割成目录和文件名二元组返回
split( path )
# 分离文件路径和扩展名
splitext( path )
# 路径拼接
join( str , ... )

# os
# 当前Python脚本工作的路径
os.getcwd()
# 返回指定目录下的所有文件和目录名
os.listdir( path )
# 删除参数file指定的文件
os.remove( file )
# 删除指定目录
os.removedirs( path )
# 重命名
os.rename( old , new )
# 创建单个目录
os.mkdir( path )
# 获得文件属性
os.stat( path )

4 CSV格式读写数据

import csv

5 序列化

序列化：把复杂的数据结构变成一连串的字节

反序列化：把一连串的字节变成复杂的数据结构

# json存取
import json
# 写（获取的数据中有中文，设置ascii存储关闭，否则默认true）
json.dump( data , fp , ensure_ascii=False )
# 读
json.load( fp )
# 字符串变json
res = json.loads( str )

# 类的存取
import pickle

---

八、异常

1 异常流程

# 可能会生成异常的代码段
try:
# 生成异常后的处理（异常名，多个用括号括起）（异常描述存在e中）
except [ ExceptionName ] [ as e ]:
  
except [ ExceptionName ]: 
# 未发生异常时执行的代码段
else:
# 无论是否发生异常都执行的代码段
finally:

2 异常类型

异常名	异常含义
Exception	所有异常
BaseExcpettion	所有异常的根异常
GeneratorExit	由生成器.close()方法引发
KeyboardInterrupt	由键盘中断（通常为Ctrl+C) 生成
SystemExit	程序退出/终止
Exception	所有非退出异常的基类
StopIteration	引发后可停止迭代
StandardError	所有内置异常的基类（仅在Python2中使用）
ArithmeticError	算数异常的基类
FloatingPointError	浮点操作失败
ZeorDivisionError	对0进行除或取模操作
AssertionError	由assert语句引发
AttributeError	当属性名称无效时引发
EnviromentError	发生在Python外部的错误
IOError	I/O或文件相关的错误
OSError	操作系统错误
EOFError	到达文件结尾时引发
ImportError	import语句失败
LookupError	索引和键错误
IndexError	超出序列索引的范围
KeyError	字键盘不存在
MemoryError	内存不足
NameError	无法找到局部或全局名称
UnboundLocalError	未绑定的局部变量
ReferenceError	销毁被引用对象后使用的弱引用
RuntimeError	一般运行时错误
NotImplementedError	没有实现的特性
SystaxError	解析错误
IndentationError	缩进错误
TabError	使用不一致的制表符（由-tt选项生成）
SystemError	解释器中的非致命系统错误
TypeError	给操作传递了错误的类型
ValueError	无效类型
UnicodeError	Unicode错误
UnicodeDecondeError	Unicode解码错误
UnicodeEncodeError	Unicode编码错误
UnicodeTranslateError	Unicode转换错误
Warning	警告的基类
DeprecationWarning	关于被弃用的特征的警告
FutureWarning	关于构造将来语义会有改变的警告
OverflowWarning	旧的关于自动提升为长整型(long)的警告
PendingDeprecationWarning	关于特性将会被废弃的警告
RuntimeWarning	可疑的运行时行为(runtime behavior)的警告
SyntaxWarning	可疑的语法的警告
UserWarning	用户代码生成的警告

3 抛出异常

# raise 异常类名[ , 异常描述 ]
# raise 不带参数抛出刚刚抛出的异常
raise [Exception [, args [, traceback]]]

4 断言

# assert（断言）用于判断一个表达式，在表达式条件为 false 的时候触发异常。
assert expression [, arguments]

# 判断系统是否为Linux:
import sys
assert ('linux' in sys.platform), "该代码只能在 Linux 下执行"

# 判断系统是否为 win32:
import sys
assert ('win32' in sys.platform), "win32"

5 自定义异常

class UserDefinedException(Exception):
    def __init__(self, eid, message):
    self.eid = eid
    self.message = message
    
class ExceptionDemo :
    def draw(self, number):
        print("called compute(" + str(number) + ")")
    if number > 500 or number <= 0:
        raise UserDefinedException(101, "number out of bounds")
    else:
        print("normal exit")
myobject = ExceptionDemo()

try:
    myobject.draw(125)
    myobject.draw(900)
except UserDefinedException as e :
    print("Exception caught,id:{},message:{}".format(e.eid, e.message))

---

九、导入包

1 包定义

包中含有模块。（文件夹（包）里有 init.py（初始化文件），hello.py（模块））

模块中含有函数库和类库。（函数和类）

# 单独运行
if __name__ == "main":
    pass
# 作为模块被调用
elif __name__ == "module_name":
    pass

2 pip指令

official::pip安装

official::setuptools安装

镜像源

• 清华：https://pypi.tuna.tsinghua.edu.cn/simple
• 中国科学技术大学 : https://pypi.mirrors.ustc.edu.cn/simple
• 豆瓣：http://pypi.douban.com/simple/
• 阿里云：http://mirrors.aliyun.com/pypi/simple/

pip < command > [ options ]

pip -help：帮助
pip install name：安装包
pip uninstall name：卸载包
pip show name：查看包
pip download name：下载但不安装包
pip list：查看所有安装包

# 使用豆瓣的镜像进行升级
python -m pip install --upgrade pip -i http://pypi.douban.com/simple --trusted-host pypi.douban.com

3 导入包

import 库 [as alias]
from 库 import 函数

# 重命名list为List
from builtins import list as List

4 打包

链接

5 生成可执行文件

链接

pip install PyInstaller

# 普通打包
pyinstaller -F myfile.py
-i ico：装载图标（linux不行）

# 窗口化应用程序作为单文件可执行文件
pyinstaller --onefile --windowed myfile.py

6 标准库

official::大全

6.1 do_cmd

# 方法一
import os
cmd = 'ipconfig /all'
res = os.popen(cmd)
output_str = res.buffer.read().decode(encoding='GB2312')
print(output_str)

# 方法二
import subprocess
obj = subprocess.run( 
cmd,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
universal_newlines=True,
timeout=1 )
print( obj.stderr )  # 输出异常信息
print( obj.stdout )  # 程序没有异常，只输出空行

6.2 math

math库

# 排列
math.perm(m,n) == A(m,n)（例：A(5,3) 为 5 * 4 * 3）
# 组合
math.comb(m,n) == C(m,n)
# 求质（最大公约数）
math.gcd(m,n)

6.3 random

random库

# [0 , 1)的小数
random.random()

# [ start , end )的整数
random.randrange( start , end , step )

6.4 datetime

datetime库① datetime库②

import datetime

# 今日的日期
datetime.date.today()
# 使用时间戳创建日期
datetime.date.fromtimestamp(num) 
# 使用公历序数创建的日期
datetime.date.fromordinal(num)

# 时间推移(days,seconds)
datetime.timedelta(days=num)

# 当天日期
now = datetime.datetime.strptime(date, '%Y-%m-%d').date()
# 日期加一
now += datetime.timedelta(1)

6.5 turtle

turtle库

6.6 tkinter GUI

tkinter GUI库

import turtle
t = turtle.Turtle()

# 爬行
forward(n); backward(n) # n：距离
# 转向
left(a);right(a) # a：角度
# 抬笔放笔
penup();pendown()
# 笔属性
pensize(s); pencolor(c)
# 隐藏箭头
hideturtle()
# 结束作图
turtle.done()

6.7 hashlib

# hashlib
import hashlib

# 使用加密函数
hashlib.func()
# func:md5,hash256,...

# 简单使用
obj = hashlib.md5()
# 编码，或者obj.update(b"Hello")
obj.update("Hello".encode("utf-8"))
# 十六进制
print(obj.hexdigest())

# hmac
import hmac
import hashlib

# 密钥，待加密字符串，加密hash函数
mac = hmac.new(b'key',b'hello',hashlib.md5)
# 字符串的ascii码
print(mac.digest()) 
print(mac.hexdigest()) 

6.8 结构化

struct详解

常用 fmt：

• i：int型

function	return	explain
pack(fmt,v1,v2,…)	string	按格式把数据转化成字节流
pack(fmt,buffer,offset,v1,v2,…)	None	写入以offset开始的buffer中
unpack(fmt,v1,v2,…)	tuple	解包
pack_from(fmt,buffer,offset)	tuple	以offset开始解包
calcsize(fmt)	size of fmt	计算fmt占多少字节

# struct
...

# json
...

6.9 Urllib

6.10 itertools

import itertools
# 迭代生成数字，start，step，__next__获得下一个数
itertools.count(start=0,step=1)

7 三方库

库导入

7.1 pygame

导弹追踪

7.2 pymssql

流程：

1. 链接数据库。
2. 新建游标。
3. 执行 sql 操作，用 try，except，无异常数据提交，有异常回滚。
4. 关闭数据库。

# 连接数据库
con = pymsssql.Connect(host,port,user,password,db)
# 创建游标
cursor = con.cursor()
# 执行 sql 语句
cursor.execute('sql')
# 数据提交
con.commit()
# 回滚
con.rollback()
# 关闭
cursor / con.close()

7.3 jieba

jieba库

7.4 cloudwords

cloudwords库

7.5 flask

Flask Web

from flask import Flask

app = Flask(__name__)
# 主网页
@app.route('/')
def index_main():
    return 'Hello World'
# 子网页
@app.route('/bobo')
def index_bobo():
    return 'Hello bobo'
# 404错误
@app.errorhandler(404)
def page_error(error):
    return "page not found"

if __name__ == '__main__':
    app.run()
	# 非局域网访问
	# app.run(debug=True,host='0.0.0.0',port=5000)
    
# 打开外部html（文件必须在templates文件夹下）
@app.route('/')
def index_main():
    return render_template('site.html')

7.6 Django

text::Django

8 生成requirement

生成：pip freeze > requirements.txt

安装：pip install -r requirements.txt

---

十、Python高级

text::PyQt5

---

十一、高级用法

text::PyQt5

text::Python爬虫

text::Python渗透