python 基础

numpy

视频链接
创建 array

  • np.array([1,2,3,4])
  • np.zeros( (3,2) )
  • np.ones( (2,4) )
  • np.linspace(0,1,5) 第三个数,是个数
  • np.random.rand(2,4)
  • 属性:
    • shape
    • dtype 默认是np.float64
      • np.zeros((4,2,dtype=np.int32))
      • 转化数据类型 a.astype(int)
        python 基础_第1张图片

操作:

  • np.dot(a,b) 点乘
  • np.sqrt(a) 批量计算
  • np.sin(a)
  • np.log(a)
  • np.power(a,2) 指数
  • a*5 a+b (广播机制)
  • a.min()
  • a.max()
  • a.argmin()
  • a.argmax()
  • a.sum( axis=0)
  • a.mean()
  • np.median(a)
  • a.var() # 方差
  • a.std() # 方差
  • 访问元素
    • 高级索引返回的是数组的副本(深拷贝),而切片操作返回的是数组视图(浅拷贝),视图也可说是引用吧
    • 切片索引
      • a[1,2] 、a[1][2]访问第1行第2列的数据,逗号是区分维度的
      • a[0,0:2] 冒号是切片索引,左闭右开
      • a[…,1] 、a[:,1] 三个点代表该维度的所有元素, 这里表示取第1列所有元素
        • a[[1,2],1] 取1,2行的第1列元素
      • a[0:9:2] 第三个是跨度
    • 数组索引 (列表[],np,bool)
      • a[a<3] # boo
# 列表索引
x = np.array([[1,  2],  [3,  4],  [5,  6]])
#[0,1,2]代表行索引;[0,1,0]代表列索引
y = x[[0,1,2],[0,1,0]] 
>>> [1  4  5]
# np 索引
import numpy as np
b = np.array([[ 0, 1, 2],
              [ 3, 4, 5],
              [ 6, 7, 8],
              [ 9,10,11]])
r = np.array([[0,0],[3,3]])    #取两行,
c = np.array([[0,2],[0,2]])    #对应行按索引取两个
# 也可
#r = np.array([[0],[3]])
#c = np.array([[0,2]])
#获取四个角的元素
c = b[r,c]
print(c)
# print(b[[[0,0], [3,3]], [[0,2], [0,2]]]) #一样的
>>> [[ 0  2]
 [ 9 11]]
  • numpy 操作图片
## numpy 融合图片
from PIL import Image
import numpy as np
im = Image.open('test.jpg').resize((400,400))
#im.show()
im_arr = np.array(im)
# print(im_arr.shape)   # (400, 400, 3)   opencv也是,只是3里面的顺序不一样,在tensor里是要把3移到前面的
im2 = np.array(Image.open('test2.jpg').resize((400,400)))
im_blend=im_arr*0.4+im2*0.6
im_blend = im_blend.astype(np.uint8)
Image.fromarray(im_blend).show()


## 图片操作
from PIL import Image
import numpy as np
im = np.array(Image.open('test.jpg').resize((400,400)))
# im 高、宽
im_downsample = im[::3,::3,:]# 图片下采样
Image.fromarray(im_downsample).show()
im_flipped=im[::-1,:,:]  # 图片上下翻转
Image.fromarray(im_flipped).show()
im_croped =im[150:250,150:250,:] # 图片裁剪
Image.fromarray(im_croped).show()

matplotlib

视频链接
官网
收集的精美画图

  • 图结构
    python 基础_第2张图片
  1. Axis:指单个数轴
  2. Axes:指坐标系(例如:二维图像由两个数轴(Axis)构成)
  3. Figure:指整个画面(可以包含多个坐标系(Axes))
  4. Artist:画面中所有可以看到的东西(数轴/图示/边框/每条线,都属于 Artist 对象
    Artist的主要元素
    python 基础_第3张图片
    python 基础_第4张图片
    python 基础_第5张图片
    plot 折线marker
    python 基础_第6张图片
  • 画一张图(用plt 直接画
import numpy as np
import matplotlib.pyplot as plt
import matplotlib
### 一些基本设置

# 常用字体 https://blog.csdn.net/lemonbit/article/details/121433603
matplotlib.rcParams['font.family'] = ['SimHei']
matplotlib.rcParams['axes.unicode_minus'] = False   # 步骤二(解决坐标轴负数的负号显示问题)
# 设置图片清晰度(200dpi: 200像素每英寸)
matplotlib.rcParams['figure.dpi'] = 200

# 常用风格 plt.style.available
# https://blog.csdn.net/weixin_45920673/article/details/118438893
# https://matplotlib.org/stable/gallery/style_sheets/style_sheets_reference.html
plt.style.use('fast')


### 初始化数据
seasons = [1,2,3,4]   # 季度
stock1 = [4,8,2,6]    # 股票1每个季度对应的股价
stock2 = [10,12,5,3]  # 股票2每个季度对应的股价

# 转化数据为Numpy数组(可跳过)
seasons = np.array(seasons)
stock1 = np.array(stock1)
stock2 = np.array(stock2)

# 画出两个股价的折现图
plt.plot(seasons, stock1, "ro--", label="股票代码: abc")  # ro--不指定其中一个,就不画出来
plt.plot(seasons, stock2, "b^--", label="股票代码: def")

## 改进
plt.title("折线图")
plt.xlabel("季度")
plt.ylabel("平均股价")
# 添加图例
plt.legend()
# 设置x/y坐标刻度
plt.xticks([1, 2, 3, 4])
plt.yticks(np.arange(2, 13, 1))

# 图的某部分缩进
# plt.xlim(2.5, 4.5)
# plt.ylim(1.5, 6.5)

# 添加网格与辅助线
plt.grid()

# plt.savefig("images/pic1_1.png")
plt.show()
  • 画多张图:使用类似Matlab的语法(也是用plt画)
# matlab 语法
plt.figure(figsize=(9,3)) # 这个是英寸单位
plt.subplot(211)
plt.bar(seasons, stock1, "ro--")

plt.subplot(212)
plt.plot(seasons,stock2,"b^--")
plt.show()
  • 画多张图:使用python 面向对象,基于axes
# 面向对象OOP精确语法
fig,axes = plt.subplots(2,1,figsize=(6,6))
axes[0].bar(seasons, stock1)
axes[1].plot(seasons, stock2,"b^--")
plt.show()



# 画4个
# 面向对象(Object-oriented programming)精确语法
fig, axes = plt.subplots(2, 2, figsize=(6, 6),
                        facecolor="grey",  # 画面背景改为灰色
                        sharex=True, sharey=True)  # 共享xy轴坐标系
axes[0, 0].bar(seasons, stock1)
axes[0, 1].plot(seasons, stock2, "b^--")
ax = axes[1, 0]
ax.plot(seasons, stock2-stock1, "--", color="black")    # 不同的点画在一张图上
ax.scatter(seasons, stock2-stock1, 
           s=[10, 20, 50, 100],
           c=['r', 'b', 'c', 'y'])
ax.set_ylabel("差价(股票1-股票2)")
axes[0, 0].set_title("股票1")
axes[0, 1].set_title("股票2")

# 可以删除最后一个坐标系
axes[1, 1].remove()
axes[0, 0].plot(seasons, stock1, 'r+-')
fig.suptitle("股票分析图")
fig.supylabel("股价")
fig.supxlabel("季度")
# plt.savefig("images/pic2_5.png", facecolor=fig.get_facecolor()) # 注: 保存图片
plt.tight_layout() # 保持内容紧凑
plt.show()

python 基础_第7张图片
python 基础_第8张图片
python 基础_第9张图片

python 基础_第10张图片
python 基础_第11张图片

  • 常用工作流程 参见
    • 查询所有画图整体风格
    • 字体设置,公式编写
    • 包装成函数

pandas

视频链接
代码链接
本地
python 基础_第12张图片

  • 创建表格
    • 字典、csv
  • 行和列,都可以作为Series
    • Series 的属性,name ,values,index
  • 根据索引查找数据
    • 选择一列
      • workout[‘calories’] Series
      • workout[[‘calories’]] DataFrame
      • titanic[[‘Sex’, ‘PassengerId’]]
    • loc 根据索引选取数据
      • workout.loc[‘day1’, :] # 行,列
      • workout.loc[[‘day1’], :] # 保留DataFrame格式
    • iloc 根据位置选取数据,从0开始编号,左闭右开
      • workout.iloc[0, :]
      • workout.iloc[[0], :]
    • .at[]: 访问单独数据
      • workout.at[‘day1’, ‘calories’]
  • 删除一些列的方法,简化:
  • 判空:Series对象.isnull()
  • 设置索引:dataframe对象.set_index(“列名”)
  • 转化时间格式:pd.to_datetime(pd.to_datetime(data_r[“时间”]).dt.strftime(‘%Y/%m’))

文件流

  • 文件对象可迭代,都是读的字符串(str,bytes)
    • var_name = open(filename[mode, [bufsize]])
  • 模式:a 附加,“+“同时支持输入、输出操作,如r+、w+、a+
  • 文件都以二进制存储,但读取会有文本模式和二进制模式,文本模式要指定编码格式,二进制不需要
  • f1.readlines() # 返回整个文件所有行,包括字符串,并生成列表
  • f1.readline() # 返回文件的一行
  • f1.name
  • f1.read(14) # 指定读出14个字节,若不给参数则默认读出所有字节
  • f1.write(‘new line.\n’) # 写进去,注意打开模式
  • f4.writelines(l2) # 列表的每个元素要有‘\n’
with open('./test.txt',mode='wb') as f:
    print('heool',file=f) # a bytes-like object is required, not 'str'
    print(b'hell',file=f)
# 说明只能接收字节(不是字符)类的对象,而不是字符串

#file:  a file-like object (stream); defaults to the current sys.stdout.
#说明标准输出也是文件

print("hello".encode('utf-8'))    #  b'hello'
  • Unicode 是“字符集”,UTF-8 是“编码规则”。
    “字符集”的意思是:为每一个“字符‘”分配一个唯一的 ID(学名为码位 / 码点 / Code Point);“你好世界” :对应unicode_id:Unicode: \u4f60\u597d\u4e16\u754c
    “编码规则”的意思是:将“码位”转换为字节序列的规则(编码/解码 可以理解为 加密/解密 的过程)。
  • 在 Python 中,有 2 种常用的字符串类型,分别为 str 和 bytes 类型,其中 str 用来表示 Unicode 字符,bytes 用来表示二进制数据。str 类型和 bytes 类型之间就需要使用 encode() 和 decode() 方法进行转换。
  • 字符编码问题-链接
  • python 读写多行文件
with open('test.txt','rt') as f:
    for i in f:
        print(i,end='')


with open('test.txt','wt') as f:
    for i in a:
        f.write(i)   # i只能是字符串
        f.write('\n')

with open('test.txt','rt') as f:
    lines = f.readlines()
    for i in lines:  # 读取的i也包含‘\n’
        print(i.strip())

OS 模块

  • 将linux或c语言的一些目录操作封装成文件管理系统
  • 目录相关函数
  • os.mkdir(‘…/day6/dir’) # 创建文件夹
  • os.makedirs():创建多级目录
  • os.rmdir():删除文件目录
  • os.removedirs():删除多级文件目录
  • os.listdir() # 获取当前文件夹下所有文件名
  • os.getcwd() # 获取当前路径,注意linux的系统是/,而win系统是\,使用了转义
  • os.chdir(‘…’) # 相当于cd到其他路径,‘…’表示上一级,‘.’表示当前级
  • os.chdir(‘day6’) # ‘day6’ 是文件夹名字
  • 文件相关函数
    • os.remove() # 删除文件
    • os.rename():重命名
import os  #(包括子目录里面的文件)
for root,dirs, files in os.walk(os.getcwd()):
    print(root)
    print(dirs)
    print(files)
  • 文件路径(os.path)相关函数
    • os.path.dirname(cwd) #文件目录名 就是所处位置的文件夹的路径
    • os.path.basename(cwd) # 文件基名 就是所处位置的文件夹的名字,不是路径
    • os.path.join(dir1, file1)
    • os.path.split() # 返回dirname(), basename()元组
    • 判断查询
      - exists(): 判断指定文件是否存在
      - isdir(): 判断指定的路径是否为目录
      - # if os.path.isfile(filename):

python 注释类型

  • Callable
    可调用类型,常用于注解一个方法。声明时需要按照Callable[[Arg1Type, Arg2Type, …], ReturnType],将参数类型和返回值类型都注解出来

读取图片

def cv_imread(filePath): #读取中文路径的图片
    cv_img=cv2.imdecode(np.fromfile(filePath,dtype=np.uint8),cv2.IMREAD_UNCHANGED)
    #imdecode读取的图像默认会按BGR通道来排列图像矩阵,如果后续需要RGB可以通过如下转换
    #cv_img=cv2.cvtColor(cv_img,cv2.COLOR_BGR2RGB)

  • 实例的初始化可以通过调用类来创建,如:net = my_CNN()
self.__class__.__name__ 
self.__class__ # 实例指向对应的类,__name__ 调用了其他的类属性(类名)


#  __dict__属性:
# 类.__dict__ 查看对象内部所有属性名和属性值组成的字典(包括属性成员和方法成员)
#实例.__dict__ 返回实例的属性,没有类的属性

# dir(实例 or 类)   # 实例和类的属性有不同的地方,比如,实例多了__class__
# 判断是否是Iterable

import collections
if isinstance(e, collections.Iterable):
    # e is iterable
# 判断一个类是否是另一个类的子类
print(issubclass(ChiClass, ParClass))
>>>
True

# 判断一个对象是否是另一个类的实例
print(isinstance(x, ChiClass))
>>>
True

# 判断一个对象是否拥有指定的属性
print(hasattr(x, 'name'))
>>>
True

# 获取一个对象的指定属性,也能删除一个属性delattr()
print(getattr(x, 'name'))
>>>
jackko

# 设置一个对象的指定属性
print(getattr(x, 'name'))
print(setattr(x, 'name', 'anney')) # 没有返回值
print(getattr(x, 'name'))
>>>
jackko
None
anney
  • super()

    • 在子类中找出其父类以便于调用其属性
  • 内的特殊方法

    • __call__()
    • 每一个类的函数都有,函数可调用
    • 也可以 对象名.()

对象

sys.getrefcount(name) # 显示对象的引用次数

type 类型

  • 集合 set
if {}:
>>> false
  • 字符串 str,bytes两种类型
  • 可变与不可变类型:
    • 可变:list 、dict 、set
    • 不可变:如数值、字符串、元组
  • 组合数据类型
    • 序列类型:字符串、列表、元组、集合和字典 ,支持迭代
    • 集合类型:集合set,支持迭代 set(iteration)
    • 映射类型:字典,key-value集合,可变对象

- 所有序列都支持的方法

python 基础_第13张图片

  • 可迭代对象包括:
  • 序列类型:list, str, tuple
  • 非序列类型:dict, file
  • 用户自定义包含__iter__()或__getitem__()方法的类
  • for循环可用于任何可迭代对象:
    • for循环开始时,会通过迭代协议传递给iter()内置函数,从而能够从可迭代对象中获得一个迭代器,返回的对象含有需要的__next__()方法
i1 = l1.__iter__()  # iter(l1) # 等价于
print(i1)  # 返回一个迭代器对象,每次使用循环时,系统自动创建迭代器,来遍历每个元素
print(i1.__next__())
print(i1.__next__())
print(i1.__next__()) # 注意:迭代器不可逆,要想再迭代就要创建新的迭代器
>>>
<list_iterator object at 0x000001449EEA60B8>
1
2
3

字符串

  • s.join(t) 使用s作为分隔符 和并t的字符串
  • s.split([sep [, maxsplit]]) 使用sep作为分隔符对 划分s的字符串
  • s.strip([chrs]) 删掉chrs开头和结尾的空白或字符
  • s.find() 是否包含子串 -1 index 方法报异常
  • s.startswith() ture false
  • s.endswith() ture false
    • 执行拼接

列表

  • 支持在原处修改,不改变id
  • 修改的是引用,而不是对象.(就是不能在去取对象后 对 对象内部修改,不支持 [][], 否则创建新的对象)
  • 增加:append仅添加一个对象、extend将添加的对象的每个元素都一一并入列表中、insert
  • 查找:index count
  • 删除:pop,若不给参数则默认弹出删除最后一个元素,remove,del a[1:4]
  • 逆序:reverse()
  • 排序:sort()
  • 复制:
    • l2 = l1 注意这种是赋值,指向同一对象,并非新建对象
    • l2 = l1[:] 这种复制是生成新的对象
import copy
l2 = copy.deepcopy(l1) 这种也是生成新对象	
  • in 、 not in
  • [i+5 for i in l2]
- print(l2)
l2[1:3] = [] # 把1、2设为空
print(l2)
print(l2[1])
>>>
[1, 32, 3, 'xyz', 5]
[1, 'xyz', 5]
xyz


print(l2)
l2[1:] = ['m',  'n', 'r'] # 1:是指从下标1到最后,包括最后
print(l2)
>>>
[1, 'xyz', 5]
[1, 'm', 'n', 'r']


print(id(l2))
print(l2)
del(l2[1:])
print(l2)
>>>
2507620552392
[1, 'm', 'n', 'r']
[1]

元组

  • 创建:
    • (),记得要加“,” ,否则可能python 不认为它是元组
    • tuple(data)
  • t = ‘x’, ‘y’, ‘z’ 定义元组可以省去括号
  • t1 + t2 会将元素合并,变成新元组
  • t1 * N 把元组重复N遍

字典

  • 定义:
    • { }
    • d3 = dict(name=‘Jackko’, age=24, gender=‘m’) # 定义字典,注意key都是字符串类型或数字类型
  • d1.clear() # 清空字典的元素
  • d1.copy()
  • d2.popitem() # 弹出最后一个(也许是随机弹出)键-值元组
  • d1.update(d2) # 合并字典,若有相同的key,则以参数中的字典为准,覆盖掉旧的
  • zip(‘xyz’, ‘123’) # 将序列一一对应组成元组,返回的是对象,节省内存。需要用list()来查看
zip('xyz', '123') # 将序列一一对应组成元组,返回的是对象,节省内存。需要用list()来查看
print(list((zip('xyz', '123'))))
print(list((zip('xyzm', '123')))) # 只会一一对应,多的不要
print(list((zip('xyz', '1234'))))
>>>
[('x', '1'), ('y', '2'), ('z', '3')]
[('x', '1'), ('y', '2'), ('z', '3')]
[('x', '1'), ('y', '2'), ('z', '3')]

d4 = dict(zip('xyz', '123')) # 构建字典
print(d4)
>>>
{'x': '1', 'y': '2', 'z': '3'}

集合

  • 可变的set()和不可变的frozenset()
  • 不支持:索引、元素获取、切片
  • 创建:
    • set()
    • set([1, 2, 3])
  • s1 & s2 # 交集,返回的是集合
  • s1 | s2 # 求并集
  • s1.update(s3) # 合并
  • s1.add(“Jerry”)

操作符、运算符

  • 比较操作符:<、>、<=、>=、!=、==
  • 成员操作符:in 、not in,用于测试成员关系 、所有序列都支持包括字符串
  • 逻辑运算符:and、 or、 not
  • 三元运算:A = X if Y else Z

is 是判断引用对象的地址是否相同

  • 两个对象比较
    • 值比较:对象中的数据是否相同
    • 身份比较:两个变量名引用的是否为同一对象
    • 类型比较:两个对象的类型是否相同
  • all(s)检查是否所有项为True
  • any(s)若元素都是 0、空、FALSE,则为False,其余都是TRUE
  • 索引
    • 索引运算:[i]
    • 切片运算:[i:j]
    • 扩展切片:[i:j:stride] (切片的结果会生成新的对象)
  • 内置函数
    • min()、max()、len()、dir() 查看自带方法
num1 = 5
num2 = 5
print(num1 == num2) # 但未必证明是同一对象
>>> True
print(num1 is num2) # 这才是同一对象
>>> True
print(type(num1) is type(num2))
>>> True
print(id(num1) == id(num2))
>>> True
print(type(type(num)))  # type也是一个类型
>>> <class 'type'>
print(type(str)) # str ,等以及自定义的class类型,都是type类型,因为没有实例化
>>> <class 'type'>

编码风格

每个模块文件、类、函数开头都可以用" “或”“” “”“写文件描述,可以使用”.doc"来查看

print(str.__doc__) 
  • 模块(py文件)、类或函数的第一条语句是一个字符串的话,该字符串就成为文档字符串
    可以使用__doc__属性引用

  • dir() 打印对象自带方法

  • id() 对象内存地址

  • help (dict.fromkeys)

显式/强制类型转换

  • str() 将非字符型数据转换为字符串 ,用eval(“{ }”) ,即转变成字典类型
  • int():转为整数
  • float():转为浮点数
  • list(s):将字符串s转为列表
  • tuple(s):将字符串s转换为元组 ()
  • set(s):将字符串s转换为集合 { }
  • dict(d):创建字典,其中d必须是(key, value)的元组序列 { }
str2 = "hello world"
l1 = list(str2)
print(l1)
>>> ['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

str3 = str(l1) # 把整个列表当做一个串来用
print(str3)
>>> ['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

print(type(str3))
>>> <class 'str'>

t1 = tuple(str2)
print(t1)
>>> ('h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd')

s1 = set(str2)
print(s1)
>>> {'e', 'h', 'l', 'o', 'd', 'w', 'r', ' '}

l3 = [('a', 1), ('b', 11), ('c', 45)]
d1 = dict(l3)
print(d1)
>>> {'a': 1, 'b': 11, 'c': 45}

num5 = 49
c1 = chr(num5)
print(type(c1))
>>> <class 'str'>

print(c1) # 因为49对应的ASCII码就是1
>>> 1

s1 = '3'
asc1 = ord(s1)
print(asc1)  # 因为ASCII码是3的对应整数是51
>>> 51

num6 = 12
a = hex(num6)
b = bin(num6)
c = oct(num6)
print(a, b, c)
>>> 0xc 0b1100 0o14

函数

  • 匿名函数:lambda args: expression
    • f=(lambda x,y,z=10: x+y+z)
    • f(3,4)
l3 = [ (lambda x: x*2), (lambda y: y*3)]
for i in l3:
    print(i(4)) # 函数调用,注意l3是列表,所以i代表两个lambda表达式
>>>
8
12
  • 闭包:函数里定义函数
def f1(x):
    def f2(y):
        return y ** x
    return f2

print(f1(3))
a1 = f1(3) # 注意,a1是一个函数,x是3
  • 函数参数
    • 位置参数:从左到右,精准匹配

    • 关键字参数:“name=value”

      • 先放所有的位置参数,再放所有的关键字参数
    • 可变参数:

      • 一个*是收集位置参数,返回元组
      • 两个*是收集关键字参数,返回字典类型
        • f10(x=1, y=2, z=9) --> {‘x’: 1, ‘y’: 2, ‘z’: 9}
    • 可变参数解包

# 可变参数解包:在调用函数时使用,刚好和可变参数相反,这是分解参数
l1 = ['Sun', 'Mon', 'Tus']
def f14(x, y, z):
    print(x, y, z)
f14(*l1) # 元素个数需要和函数参数匹配

l2 = ['a', 'b']
d1 = {'k1':1, 'k2':2, 'k3':3}
def f16(x, *y, **z):
    print(x)
    print(y)
    print(z)
f16(m, *l2, **d1)
>>>
3
('a', 'b')
{'k1': 1, 'k2': 2, 'k3': 3}
  • 函数式编程
    • 定义:函数可以接受函数当作输入和输出,由纯函数组成,相互独立,对于相同的输入,总有相同的输出
    • python支持有限的函数式编程功能,如
      • 过滤器 filter(function,iterable) 一一排查,需要bool ,return的对象,需要 list
      • 映射器 map(function,iterable,…) 一一对应,return的对象,需要 list
      • reduce() 做累积操作
  • 使用链接

循环

  • for循环可用于任何可迭代对象:
    • for循环开始时,会通过迭代协议传递给iter()内置函数,从而能够从可迭代对象中获得一个迭代器,返回的对象含有需要的__next__()方法
l1 = [0, 1, 2, 3, 4, 5, 6]
l2 = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]
# 使用zip来将并排元素配成元组,并行遍历
for (k, v) in zip(l1, l2):
for i in l1:
d1 = {0: 'Sun', 1: 'Mon', 2: 'Tue'}
for k, v in d1.items():
[i for i in list1 if i.endswith('.ipynb')]
[(i, j) for i in l1 for j in l2 if j != 1]

生成器

  • 生成器表达式
    序列过长,并且每次只需要获取一个元素时,应当考虑使用生成器表达式而不是列表解析,生成器表达式的语法就是把列表解析的[]换成()
print((i**2 for i in range(1, 11))) # 注意返回的是生成器对象
g1 = (i**2 for i in range(1, 11))
print(g1.__next__())
print(g1.__next__())
print(g1.__next__())
print(g1.__next__())
>>>
<generator object <genexpr> at 0x000001449EE0CCF0>
1
4
9
16

# 生成1到10的平方
for i in (j**2 for j in range(1, 11)):
    print(i)
>>>
1
4
9
16
25
36
49
64
81
100

python 基础_第14张图片

  • range 也是生成器

  • enumerate 枚举生成器

    • for i,value in enumerate(url):
  • 生成器

    • 含有yield的函数
    • 并在下一次执行next() 方法时继续运行
    • 因为yield可以返回,所以不需要写return语句
# 也可以使用含有yield的函数来生成
def gen_num(x):
    i = 1
    while i <= x:
        yield i**2 # 遇到yield就返回其后面的信息
        i += 1

g1 = gen_num(10) # 返回的是生成器对象
print(type(g1))

# print(next(g1)) # 输出一个

for i in g1:
    print(i)
>>>
<class 'generator'>
1
4
9
16
25
36
49
64
81
100

装饰器(decorator)

  • 装饰器本身就是一个函数,用于装饰其他函数
  • 一般接受一个函数对象作为参数,以对其进行增强
  • 使用闭包定义一个装饰器,通过@来引用装饰器
def deco(func):
    def wrapper(x):
        print("please say something:")
        func(x)
        print("No zuo no die.")
    return wrapper

@deco
def show(x):
    print(x)

show("I am from Mars.") # 原来函数只说一句话,现在将其增强为说三句话
>>>
please say something:
I am from Mars.
No zuo no die

模块

  • 一个文件
  • 也是对象
  • 搜索模块文件
import sys    
print(sys.path)  # # 第一个就是程序主目录,当前路径

你可能感兴趣的:(python,开发语言)