RemakePython

​
2小时Python基础语法回忆，参考以下文章：

Python3 教程 | 菜鸟教程​

# is 代表引用相同
# = 值相同
# python语法糖 a,b=b,a+b
# 元组初始化只有一个元素 a=(1,)
# 交互模式中 最后被输出的表达式结果被赋值给变量 _,且被当做只读变量
# python中格式化字符串 print("我叫{},今年{}岁".format("小蜜",18))
# list的remove和pop区别
# tuple不允许删除,且元组指向的内存中的内容不可以改变
# id查看内存地址
# python中list即vector dict即hashMap tuple即不可变list set即hashset
# python中set的删除s.pop()为随机删除一个元素
# 元组推导式 a = (x for x in range(1,10))的a返回的是一个生成器,使用 tuple(a)才能将生成器对象转成元组

"""
生成器例子
"""

def countdown(n):
    while n > 0:
        yield n
        n -= 1

# 创建生成器对象
generator = countdown(5)

# 通过迭代生成器获取值
print(next(generator))  # 输出: 5
print(next(generator))  # 输出: 4
print(next(generator))  # 输出: 3

# 使用 for 循环迭代生成器
for value in generator:
    print(value)  # 输出: 2 1



"""
迭代器例子 list=[1,2,3,4] it=iter(list) next(it)
"""

class A:
    def __iter__(self):
        self.a = 1
        return self
    def __next__(self):
        if self.a<=20:
            x = self.a
            self.a += 1
            return x
        else:
            raise StopIteration
myclass=A()
myiter=iter(myclass)
print(next(myiter))
for x in iter(myclass):
    print(x,end=" ")


# python函数中的参数传递方式类似于java? 不可变类型先拷贝一个，可变类型直接传引用地址，对于变量声明同理
# python中传递不定长参数时使用加*的形参，会被收集到一个元组，**的形参，会被收集到一个字典

"""
不定长参数一个*作为tuple 两个**作为dict
"""
def printinfo(arg1, *tuple,**dict):
    "打印任何传入的参数"
    print("输出: ")
    for var in tuple:
        print(var,end=" ")
    print()
    for key in dict:
        print("{}:{}".format(key,dict[key]),end=" ")
    return

printinfo(70, 60, 50,name="小明",age=18)


# 当调用函数的时候，我们也可以进行相反的操作，把元组和字典展开为参数
args = (1, 2, 3, 4)
kwargs = {"a": 3, "b": 4}
all_the_args(*args)  # 等价于 foo(1, 2, 3, 4)
all_the_args(**kwargs)  # 等价于 foo(a=3, b=4)
all_the_args(*args, **kwargs)  # 等价于 foo(1, 2, 3, 4, a=3, b=4)


"""
python装饰器 可以传参也可以不传参，传参深度再加一层，即再多一层闭包
"""
import time
def timer(x):
    def decorator(func):
        def wrapper(*args, **kwargs):
            start_time = time.time()  # 记录函数开始时间
            time.sleep(x)      #睡x秒
            result = func(*args, **kwargs)  # 执行函数并获取返回值
            end_time = time.time()  # 记录函数结束时间
            print('函数 {} 的执行时间为：{:.4f} 秒'.format(func.__name__, end_time - start_time))
            return result
        return wrapper
    return decorator
@timer(3)
def sum(arg1,arg2):
    print("加法:",arg1+arg2)
sum(1,2)

"""
python数据结构:

stack:list模拟
queue:list模拟
HashSet:set
HashMap:map

"""

# zip()组合序列 reversed()反转序列 sorted()排序序列 ，需要再转化为对应集合类型

"""
删除指定路径下的所有文件
"""
import os

def remove_files(path):
    for file_name in os.listdir(path):
        file_path = os.path.join(path, file_name)
        if os.path.isfile(file_path):
            os.remove(file_path)
            print("已删除文件 ", file_path)
        elif os.path.isdir(file_path):
            remove_files(file_path)  # 递归删除子文件夹中的文件
remove_files("C:/example_folder") # 要删除文件的路径


"""
exception处理
"""
try:
    print("123")
except AssertionError as error:
    print(error)
except IOError:
    raise Exception("IOException")
else:
    try:
        with open('file.log') as file:
            read_data = file.read()
    except FileNotFoundError as fnf_error:
        print(fnf_error)
finally:
    print('这句话，无论异常是否发生都会执行。')

"""
自定义异常
"""
class MyError(Exception):
    def __init__(self, value):
        self.value = value

    def __str__(self):
        return repr(self.value)

"""
Python中的类，有私有属性和私有方法，外面无法访问，且类支持多继承
"""

class people:
    # 定义基本属性
    name = ''
    age = 0
    # 定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0

    # 定义构造方法
    def __init__(self, n, a, w):
        self.name = n
        self.age = a
        self.__weight = w

    def speak(self):
        print("%s 说: 我 %d 岁。" % (self.name, self.age))


# 单继承示例
class student(people):
    grade = ''

    def __init__(self, n, a, w, g):
        # 调用父类的构函
        people.__init__(self, n, a, w)
        self.grade = g

    # 覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级" % (self.name, self.age, self.grade))

    def study(self):
        print("%s 正在学习" % (self.name))


# 另一个类，多继承之前的准备
class speaker():
    topic = ''
    name = ''

    def __init__(self, n, t):
        self.name = n
        self.topic = t

    def speak(self):
        print("我叫 %s，我是一个演说家，我演讲的主题是 %s" % (self.name, self.topic))


# 多继承
class sample(speaker, student):
    a = ''

    def __init__(self, n, a, w, g, t):
        student.__init__(self, n, a, w, g)
        speaker.__init__(self, n, t)


test = sample("Tim", 25, 80, 4, "Python")
test.speak()  # 方法名同，默认调用的是在括号中参数位置排前父类的方法
test.study()

"""
Python运算符重载
"""
class Vector:
    def __init__(self,a,b):
        self.a=a
        self.b=b
    def __str__(self):
        return f"Vector{self.a},{self.b}"
    def __add__(self,other):
        return Vector(self.a+other.a,self.b+other.b)
v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)

"""
Python中内部作用域想要修改外部作用域的不可变变量(tuple,string,int等) 时需要使用nonlocal或global关键字
也许你会想为什么int也是不可变变量呢？a=1之后再a=2不是可行吗，这是因为a=2实际上是让a重新指向一个新地址，并没有修改1的值

实际上只要修改变量地址时不管是可变还是不可变类型，都需要使用nonlocal和global关键字，对于像是list,我们在执行append时，
没有修改变量地址所以不用加nonlocal，但是如果我们对list进行赋值,list=[123]时，我们修改了变量的地址，所以也要加nonlocal关键字


"""
num = 1
def fun1():
    global num  # 对于全局变量需要使用 global 关键字声明
    num = 123
    print(num)
fun1()
print(num)


def outter():
    temp=1
    def inner():
        nonlocal temp #对于函数内的变量使用nonlocal访问外层地址
        temp+=1


#python的map函数 function->iterable
numbers = [1, 3, 6]
newNumbers = tuple(map(lambda x: x**2 , numbers))
#等价于
(x**2 for x in [1,3,6])

#python中的filter函数 function->iterable
filter(lambda x: x > 5, [3, 4, 5, 6, 7])  # => [6, 7]
#等价于
[x for x in [3,4,5,6,7] if x>5]

#python中的sorted函数 
>>>a = [5,7,6,3,4,1,2]
>>> b = sorted(a)       # 保留原列表
>>> a 
[5, 7, 6, 3, 4, 1, 2]
>>> b
[1, 2, 3, 4, 5, 6, 7]
 
>>> L=[('b',2),('a',1),('c',3),('d',4)]
>>> sorted(L, cmp=lambda x,y:cmp(x[1],y[1]))   # 利用cmp函数
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> sorted(L, key=lambda x:x[1])               # 利用key
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
 
 
>>> students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
>>> sorted(students, key=lambda s: s[2])            # 按年龄排序
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
 
>>> sorted(students, key=lambda s: s[2], reverse=True)       # 按降序
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]


"""
python复杂的排序
"""
from functools import cmp_to_key

def func(stu1, stu2):
    # 年龄相同
    if stu1.age == stu2.age:
        # 体重相同 安装身高逆序
        if stu1.weight == stu2.weight:
            return stu2.height - stu1.height
        else: # 体重不同，逆序排序
            return stu2.weight - stu1.weight
    else: # 年龄不同，则按照年龄排序
        return stu1.age - stu2.age

class Student:
    def __init__(self, age, height, weight):
        self.age = age
        self.height = height
        self.weight = weight
        
s1 = Student(18, 180, 55)
s2 = Student(19, 175, 80)
s3 = Student(17, 162, 70)      

classes = [s1, s2, s3]
classes = sorted(classes, key=cmp_to_key(func))

"""
python PriorityQueue用法

put() 插入元素

get()取队首元素的值并将其弹出.

full() 判断是否为满.

empty() 判断是否为空.


"""
# 定义比较的元素对象
class Task(object):
    def __init__(self, priority, name):
        self.priority = priority
        self.name = name
 
    def __str__(self):
        return "Task(priority={p}, name={n})".format(p=self.priority, n=self.name)
 
 
    def __lt__(self, other):
        """ 定义<比较操作符。"""
        # 从大到小排序
        return self.priority > other.priority
 
 
 
 
tsq = queue.PriorityQueue()
 
# 插入元素
tsq.put_nowait(Task(3, "task1"))  # 自定义的类定义了__lt__, 可以比较大小
tsq.put_nowait(Task(1, "task2"))
tsq.put_nowait(Task(2, "task3"))

# 取队首
print("取队首并弹出")
print(tsq.get())

print("队列长度:")
print(tsq.qsize())
 
print("队列是否为空：")
print(tsq.empty())

"""
可以把Counter类当做一个加强的dict字典，当访问没出现的元素时为0，此外还可以进行不同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)

"""
Python二维数组
"""

test = [[0 for i in range(m)] for j in range(n)]


"""
Python二分查找
bisect.bisect和bisect.bisect_right返回大于x的第一个下标(相当于C++中的upper_bound)，
bisect.bisect_left返回大于等于x的第一个下标(相当于C++中的lower_bound)。
"""

import bisect
a=[1,2,3,4,6]
print(bisect.bisect_left(a,7))
print(bisect.bisect_right(a,4))
print(bisect.bisect_left(a,4))
#output:
#5
#4
#3


>>>