CodingLifeDay2:Python:基本数据结构和函数

1，基本数据结构及常用操作

①列表：List = [Elem1,Elem2,Elem3]

"""
列表：
①增：list.append(Elem)----------末尾追加，Elem作为list的一个元素
list.extend(Elem)---------------末尾扩展，Elem的每一个元素逐一append到list中
list.insert(location,Elem)------把Elem插入到list的下标为location的地方
②删：del list[location]---------删除list的下标为location的元素
list.pop()----------------------删除最后一个元素，可以返回这个元素
list.remove(Elem)---------------删除指定内容的元素，重复时只删除第一个
③改：list[location]=Elem--------修改list的下标为location的元素为Elem
④查：if Elem in list:-----------直接使用判断语句判断Elem是否存在于list中
list.index(Elem,loc1,loc2)------如果list下标在[loc1,loc2)的元素里存在Elem，返回Elem的下标，找不到会报错
list.count(Elem)----------------返回list中Elem的个数
len(list)-----------------------返回list中元素的个数
for i,x in enumerate(list)------同时获得list的元素内容和下标，下标i从0开始
⑤排序：list.reverse()-----------列表元素反转
list.sort()---------------------列表升序排序
list.sort(reverse=True)---------列表降序排序
"""

②元组：Tuple = (Elem1,Elem2,Elem3)。元组内容无法被修改。

"""
元组：
创建只有一个元素的元组，要在第一个元素后面加一个逗号。 tuple(Elem,)
①增：tuple=tuple1+tuple2--------新建一个元组，内容为两个元组相连
②删：del tuple------------------删除整个元组，无法再次被访问
"""

③字典：Dict = {key1 : value1, key2 : value2 }

"""
字典：
使用键值对方式存储：key:value。键必须使用不可变类型，键必须是唯一的。
①访问：dict[key]----------------使用键访问值，不存在目标键时会报错
dict.get(key,str)---------------找到了返回key对应的值，没有找到默认返回None，也可设定返回str
②增：dict[newkey]=newvalue------新增键值对newkey:newvalue
③删：del dict[key]--------------删除字典的键为key的键值对
del dict------------------------删除整个字典，无法再次被访问
dict.clear()--------------------清空字典所有元素 
④改：dict[key]=newvalue---------key对应的值被修改为newvalue
⑤查：dict.keys()----------------以列表形式返回所有键
dict.values()-------------------以列表形式返回所有值
dict.items()--------------------以列表形式返回所有键值对，每一个键值对是一个元组
for key,value in dict.items()---for循环形式获得所有键值对
其他操作：len,max,min,dict(转化为字典格式)
"""

④集合：Set = {Elem1,Elem2,Elem3}

"""
集合：
集合是无序的:因此无法用set[location]的方法访问；集合是不重复的：因此相同元素只会存储一个。
①访问：for item in set:---------for循环遍历集合元素
②增：set.add(Elem)--------------新增元素Elem，注意：新增元素并非依次增加到集合末尾。
set.update([Elem1,Elem2])-------新增多个元素
③删：set.remove(Elem)-----------删除指定元素Elem，若Elem不存在，会引发错误
set.discard(Elem)---------------删除指定元素Elem，若Elem不存在，不会引发错误
set.pop()-----------------------删除最后元素，注意：你无法得知删除的是哪一个元素
set.clear()---------------------清空整个集合
del set-------------------------删除集合，无法再次被访问
④合并：set3 = set1.union(set2)---返回一个新集合，其中包含两个集合中的所有项目，重复项将被排除
"""

---

2，函数

"""
函数中调用全局变量：global variable
在一个函数中调用了全局变量并修改其值，再次调用此变量，得到的值是修改后的。
"""

"""
关于函数传参，有以下几个问题值得注意：

①调用函数时可使用关键字传参，这时不必考虑参数的顺序。
def sum(x,y):
    return x+y;
sum(y=5,x=3)

②定义函数时可以默认参数值：
def sum(x,y=3):
    return x+y;
这时调用函数，如果y没有传入值，则使用默认值；如果y有传入值，则使用传入的值。

③定义函数时形参表中若有*，则*后面的参数都必须使用关键字传入：
def sum(x,*,y):
    return x+y;
sum(5,y=7)

④可以在形参表中用*variable的格式接收多个参数的传入。也可以用variable接收函数的多个返回值。
def f(*argvs):
    for i in argvs:
        print(i)
    A, B = argvs
    return A + B, A - B

temp = f(5, 3)
C, D = temp
print(C, D, *temp)
"""

①闭包

"""
当一个函数运行结束后，函数内部所有变量都会被释放。如果希望它的某些变量继续被使用，就可以使用闭包的方法：
在函数内定义一个内部函数，内部函数调用需要继续被使用的变量，外部函数将内部函数作为返回值。
"""

# 下面这个例子使用闭包的方法计算x的y次方：
def OutFunc(y):
    def InFunc(x):
        print(x ** y)

    return InFunc

temp = OutFunc(3)  # 计算一些数的三次方
temp(3)  # 27 : 3 ** 3
temp(5)  # 125 : 5 ** 3

# 如果想要修改调用的局部变量的值，使用nonlocal关键字。
"""
例如在上面的InFunc中加入这两行代码：
nonlocal y
y += 1
可以使得每次调用InFunc时幂次加一，同样的运行结果会是81和3125（分别是3的4次方和5的5次方）
"""

②匿名函数

"""
FunctionName = lambda variable1, variable2: Expression
匿名函数没有return语句，Expression既是对变量的操作，也是函数返回的内容
调用匿名函数，使用FunctionName
"""

# 这是一个实例，用于计算x的y次方
func = lambda x, y: x ** y
print(func(2,5)) #32

③生成器函数

"""
得到生成器有三种方法：
①使用生成器表达式：gen = (expression range)，例如gen = (x*3 for x in range(5))
②函数使用yield返回值。
③yield from语法：yield from object 等价于 for item in object : yield item
输出生成器内容：
①使用next方法:每次返回一个值，返回完最后一个值再次调用会报错:StopIteration
使用方法是:print(next(gen))，print(gen.__next__())
②使用for循环:
for i in gen:
    print(i)
"""

# 1
gen = (x*3 for x in range(5))
# 2
def test_func1():
    a = 1
    yield  a
    a = 2
    yield  a
    a = 3
    yield  a
gen = test_func1()
# 3
list = ["Apple","Pear","Orange"]
def test_func2():
    yield from list
gen = test_func2()

④装饰器

"""
装饰器：在不改变原函数代码的情况下，为其增加一些功能。
在下面的例子中，装饰器通过“装饰前的代码”和“装饰后的代码”为func新增某些功能。
def wrapper(func): # wrapper是装饰器函数，func是被装饰函数
    def inner(variable): # variable是func需要传入的参数
        # 装饰前的代码
        ret = func(variable)  # ret是func返回的结果
        # 装饰后的代码
        return ret

    return inner
调用装饰器函数的方法是在原函数def行的上一行写上@wrapper
调用后执行func的过程实际上是在执行inner函数
"""

# 这是一个实例，装饰器用于打印函数的运行时间
import time

def wrapper(func):
    def inner(variable):
        start_time = time.time()
        ret = func(variable)
        stop_time = time.time()
        print(stop_time - start_time)
        return ret

    return inner

@wrapper
def test_func(num):
    for i in range(num):
        print("Hello,world")
    return num + 1

x = int(input("Input:"))
print(test_func(x))