python基础篇

最新推荐文章于 2023-10-11 14:28:28 发布

浅吻＠

最新推荐文章于 2023-10-11 14:28:28 发布

阅读量562

点赞数

分类专栏： python3

本文链接：https://blog.csdn.net/weixin_43278089/article/details/88210403

版权

python3 专栏收录该内容

5 篇文章 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

闭包必须满足三个条件:

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

# 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. 定义 : 可通过for循环迭代读取数据供我们使用的对象
2. 本质 : 可迭代对象通过__iter__()方法向我们提供一个迭代器,在迭代一个对象(列表)时,实际上先获取该对象提供的迭代器,然后通过这个迭代器依次获取每个数据
3. __iter__()和__next__()函数作用
  __iter__():获取可迭代对象的迭代器
  __next__():对迭代器不断使用__next__()函数来获取下一条数据,完成后再调用会抛出StopIteration异常
迭代器对象
一个实现了__iter__()方法和__next__()方法的对象
生成器
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)

浅吻＠

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
python基础篇

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 真值表达...
复制链接

扫一扫