python基础篇

迷南。 2022-03-12 12:06 246阅读 0赞

#### python基础篇 ####

**三种推导式**

1.列表推导式

\*\[表达式 for 变量 in 可迭代对象\] 或 \[表达式 for 变量 in 可迭代对象 if 真值表达式\]

\*\[变量1 + 变量2 for 变量1 in 可迭代对象1 if 真值表达式1 for 变量2 in 可迭代对象2 if 真值表达式2\]

2.字典推导式

\*\{键表达式: 值表达式 for 变量 in 可迭代对象 if 真值表达式\}

3.集合推导式

\*\{表达式 for 变量 in 可迭代对象 if 真值表达式\}

**列表创建**

1.L = \[\]

2.L = list()

**字典创建**

1.d = \{\}

2.d = dict()

3.d = dict(iterable) 用可迭代对象初始化一个字典 \#d = dict(\[(‘name’, ‘tarena’), (‘age’, 15)\])

4.dict(\*\*kwargs) 用关键字传参形式生成一个字典 \#d = dict(name=‘tarena’, age=15)

**集合创建**

1.s = set() \#创建空集合

2.s = set(iterable) \#用可迭代对象创建一个新的集合对象

**固定集合 frozenset**

1.固定集合是不可变的,无序的,含有唯一元素的集合

2.固定集合的创建

1.frozenset() \#创建一个空的固定集合对象

2.frozenset(iterable) \#用可迭代对象创建一个固定集合对象

**列表，元组，字典，集合的异同点**

1.列表，元组，字典可以存储任意类型的数据，集合中的元素必须是不可变对象且唯一，其中字典的键只能是不可变对象且唯一，value可以是任何类型

2.列表，字典，集合都是可变对象（可以增删改），元组，字符串，数字都是不可变对象

3.列表，元组都是通过索引获取值，字典通过键获取

4.列表，元组是有序的存储结构，字典和集合是无序的存储结构

5.都是可迭代对象

L = [1,'a',[1,2],('a',2),{ 1,2},{ 1:2}]
    
    t = (1,'a',[1,2,4,5],('a',2),{ 1,2.'a','b'},{ 1:2,'a':'b'})
    
    d = { 'a':'ab',1:2,(1,2):[1,2,3],('a','b'):{ 1:2,'a':'b'}}
    
    s = { 1,2,'a',(1,2,3),(1,2,[2,3,4])} #报错 unhashable type: 'list'
    
    s = { 1,2,(1,2,3),(1,2)}

**python的四个作用域:**  
作用域 英文 英文简写  
局部作用域(函数内) Local L  
外部嵌套函数作用域 Enclosing function local E  
函数定义所在模块作用域 Global G  
python内建模块的作用域 Builtin(Python) B

**高级函数**

map 函数 : map(func, \*iterables) 返回可迭代对象,此可迭代对象用func对可迭代对象iterables中的每个元素作为参数计算后得到结果,再返回.当最短的一个可迭代对象不再提供数据时迭代结束

# map.py
    
    def power2(x):
        # print("power2被调用, x=", x)
        return x ** 2
    
    # 生成一个可迭代对象,此可迭代对象可以生成 1~9的自然数的平方
    for x in map(power2, range(1, 10)):
        print(x)  # 1, 4, 9, 16
    
    # 生成一个可迭代对象,此可迭代对象可以生成 
    # 1**4, 2**3, 3**2, 4**1
    # pow(x, y, z=None)
    
    for x in map(pow, range(1, 5), range(4, 0, -1)):
        print(x)
    
    for x in map(pow, [1, 2, 3, 4],[4, 3, 2, 1],range(5, 100)):
    	print(x)

filter函数 : filter(func, iterable) 返回一个可迭代对象,此可迭代对象将对iterable获取到的数据用函数func进行筛选; func将对iterable中的每个元素进行求值，返回False则丢弃，返回True则保留此数据

# filter.py
    
    # 判断x是否是奇数，如果是奇数返回True,否则...
    def isodd(x):
        return x % 2 == 1
    
    # 生成1~100的奇数
    for x in filter(isodd, range(100)):
        print(x)
    
    # 生成1~100以内的偶数放到列表even中
    even = [x for x in filter(lambda x: x % 2 == 0,range(1, 100)
    )]
    print(even)

sorted 函数 : 将原可迭代对象的数据进行排序，生成排序后的列表

格式 : sorted(iterable, key=None, reverse=False)

# sorted.py
    
    # 此示例示意sorted函数的用法
    L = [5, -2, -4, 0, 3, 1]
    L2 = sorted(L)  # [-4, -2, 0, 1, 3, 5]
    print('L2=', L2)
    L3 = sorted(L, reverse=True)
    print("L3=", L3) # [5, 3, 1, 0, -2, 4]
    
    L4 = sorted(L, key=abs) # [0, 1, -2, 3, -4, 5]
    print(L4)
    
    names = ['Tom', 'Jerry', 'Spike', 'Tyke']
    L5 = sorted(names, key=len)
    print(L5) #['Tom','Tyke','Jerry','Spike'] # 3 4 5 5

**递归、闭包、装饰器**

递归函数调用分为两个阶段:

1. 递推阶段
     从原问题出发,按递归公式递推从未知到已知,最终到达递归终止条件
    2. 回归阶段
     按递归终止条件求出结果,逆向逐步代入递归公式,回归原问题求解

ef myfac(n):
        # 如果n为1则知道 1的阶乘是1,直接返回
        if n == 1:
            return 1
        # 否则,进入递推阶段等待下一个结果后再返回
        return n * myfac(n-1)
    
    print(myfac(5))  # 120

闭包必须满足三个条件:

1.  必须有内嵌函数
2.  内嵌函数必须引用外部函数中的变量
3.  外部函数返回值必须是内嵌函数

# closure2.py
    
    # 用闭包来创建的任意的
    # f(x) = a*x**2 + b*x + c 的函数
    
    def get_fx(a, b, c):
        def fx(x):
            return a*x**2 + b*x + c
        return fx
    
    f123 = get_fx(1, 2, 3)
    print(f123(20))
    print(f123(50))

装饰器：通常在不改变原函数的情况下,改变或添加原函数功能

# mydeco2.py
    
    # 此示例用装饰器改变原来函数的调用流程(业务流程)
    # 银行业务
    
    # 小铭同学
    # 此装饰器用来增加权限验证功能
    def privileged_check(fn):
        def fx(n, x):
            print("正在进行权限验证....")
            fn(n, x)
        return fx
    
    # 此装饰器用来增加短消息提醒功能
    def message_send(fn):
        def fy(n, x):
            fn(n, x)
            print("正在发送短消息给", n, '...')
        return fy
    
    # -------以下是魏老师写的程序------
    @privileged_check
    def save_money(name, x):
        print(name, '存钱', x, '元')
    
    @message_send
    @privileged_check
    def withdraw(name, x):
        print(name, '取钱', x, '元')
    
    # -------以下是小张写的程序------
    save_money('小王', 200)
    save_money('小赵', 400)
    withdraw('小李', 500)

**模块、包开发**

mport 包名 \[as 包别名\]

import 包名.模块名 \[as 模块新名\]

import 包名.子包名.模块名 \[as 模块新名\]  
…  
from 包名 import 模块名 \[as 模块新名\]

from 包名.子包名 import 模块名 \[as 模块新名\]

from 包名.子包名.模块名 import 属性名 \[as 属性新名\]  
…  
from 包名 import \*

from 包名.模块名 import \*

模块的加载路径：

1.搜索内建模块

2.当前工作路径

3.sys.path 提供的路径

包的加载路径:

1.当前工作路径

2.sys.path 提供的路径

**异常、断言**

try语句：

try:  
        可能触发异常的语句  
    except 错误类型1 \[as 变量名1\]:  
        异常处理语句1  
    except 错误类型2 \[as 变量名2\]:  
        异常处理语句2  
    except (错误类型3, 错误类型4)\[as 变量3\]:  
        异常处理语句3  
    except:  
        异常处理语句other  
    else:  
        末发生异常语句  
    finally:  
        最终语句

def div_apple(n):
        print("有%d个苹果,您想分给几个人?" % n)
        s = input("请输入人数: ")
        count = int(s)  #可能触发ValueError错误
        result = n / count #ZeroDivisionError
        print("每个人分了%d个苹果" % result)
    
    try:
        div_apple(10)
        print("分苹果结束")
    except ValueError:
        print("有异常发生具已捕获")
    else:
        print("没有异常发生")
    finally:
        print("我是try语句的finally子句")
        print("我一定会被执行")
    
    print("程序正常结束")

raise 语句：触发一个错误,让程序进入异常状态

# raise.py
    
    # 此示例示意raise 发送错误通知的用法
    def make_except():
        print("函数开始")
    
        # 发出ZeroDivisionError类型的错误给调用者
        # raise ZeroDivisionError
        # raise ValueError
        e = ValueError("值错误")  #创建一个错误对象
        raise e
    
        print("函数结束")
    
    try:
        make_except()
    except ZeroDivisionError:
        print("接收到make_except发出的错误通知")
    except ValueError as err:
        print("ValueError--->", err)
    
    print("程序正常结束")

assert 语句(断言语句)

语法:  
    assert 真值表达式, 错误数据(通常是字符串)  
作用:  
    当真值表达式为False时,用错误数据创建一个AssertionError类型的错误,并进入异常状态

# assert.py
    
    # 此示例示意assert 语句的用法:
    def get_score():
        s = int(input("请输入学生成绩:(0~100): "))
        assert 0 <= s <= 100, "成绩超出范围"
        # if bool(0 <= s <= 100) == False:
        # raise AssertionError("成绩超出范围")
        return s
    
    try:
        score = get_score()
        print("学生的成绩为:", score)
    except AssertionError as err:
        print("AssertionError类型的错误被触发,且已捕获")
        print("err=", err)

**可迭代对象、迭代器、生成器**

1.  可迭代对象
    
    1.  定义 : 可通过for循环迭代读取数据供我们使用的对象
    2.  本质 : 可迭代对象通过\_\_iter\_\_()方法向我们提供一个迭代器,在迭代一个对象(列表)时,实际上先获取该对象提供的迭代器,然后通过这个迭代器依次获取每个数据
    3.  \_\_iter\_\_()和\_\_next\_\_()函数作用  
        \_\_iter\_\_():获取可迭代对象的迭代器  
        \_\_next\_\_():对迭代器不断使用\_\_next\_\_()函数来获取下一条数据,完成后再调用会抛出StopIteration异常
2.  迭代器对象  
        一个实现了\_\_iter\_\_()方法和\_\_next\_\_()方法的对象
3.  生成器  
        1. 函数中有yield关键字,称为生成器  
        2. yield作用  
            1. 保存当前运行状态,暂停执行,即将生成器挂起  
            2. 将yield关键字后面的表达式的值返回,类似于return

# iterator.py
    
    L = [2, 3, 5, 7]
    it = iter(L)  # 获取迭代器
    while True:
        try:
            x = next(it)
            print(x)
        except StopIteration:
            break

# myinteger.py
    
    # 此示例示意用生成器函数创建生成从0开始到n结束的一系列整数(不包含n)
    def myinteger(n):  # integer(整数)
        i = 0  # 设置初始值为0
        while i < n:
            yield i  # 生成i给next(it) 调用
            i += 1  # 为生成下一个数做准备
    
    for x in myinteger(10000000000000000000):
        print(x)

生成器函数：zip函数、enumerate函数

zip(iter1\[, iter2, …\]) 返回一个zip生成器对象,此对象用于生成元组,元组的数据分别来自于参数中的每个可迭代对象,生成元组的个数由最小的可迭代对象大小决定

enumerate(iterable, start=0) 返回一个enumerate生成器对象,此对象生成类型为(索引,值)的元组,默认索引从零开始,也可以用start指定

# 用生成器函数实现myzip函数
    
    numbers = [10086, 10000, 10010,95588]
    names = ['中国移动','中国电信','中国联通']
    
    # def myzip(*args):
    def myzip(iter1, iter2):
        # 先拿到两个对象的迭代器
        it1 = iter(iter1)
        it2 = iter(iter2)
        while True:
            try:
                a = next(it1)
                b = next(it2)
                yield (a, b)
            except StopIteration:
                return  # 此生成器函数生成结束
    
    for t in myzip(numbers, names):
        print(t)
    
    d = dict(myzip(numbers, names))
    print(d)

**文件**

open(file, mode=‘rt’) 用于打开一个文件,返回此文件流对象,如果打开失败,则会触发OSError错误!

file 是文件路径名的字符串

mode 是打开的模式

#读写操作
    with open("a.txt","rt") as fr:
        with open("b.txt","wt") as fw:
            for line in fr:
                fw.write(line)