Python编程入门学习笔记(八)

最新推荐文章于 2024-07-31 14:30:10 发布
最新推荐文章于 2024-07-31 14:30:10 发布
阅读量195 收藏
点赞数
分类专栏： Python 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sonicgyq_gyq/article/details/80728496
版权

Python学习笔记（八）

## Python 第四课

### 课程安排
    1、numpy
    2、pandas
    3、matplotlib

### numpy
    数组和列表，列表可以存储任意类型的数据，而数组只能存储一种类型的数据


```python
import array
```


```python
a = array.array('i',range(10))
```


```python
# 数据类型必须统一
a[1] = 10
```


```python
a
```




    array('i', [0, 10, 2, 3, 4, 5, 6, 7, 8, 9])




```python
import numpy as np
```

### 从原有列表转换为数组


```python
a_list = list(range(10))
b = np.array(a_list)
type(b)
```




    numpy.ndarray



### 生成数组


```python
a = np.zeros(10,dtype = int)
print(type(a))
# 查看数组类型
a.dtype
```

    <class 'numpy.ndarray'>
    




    dtype('int32')




```python
a = np.zeros((4,4),dtype = int)
print(type(a))
# 查看数组类型
print(a.dtype)
a
```

    <class 'numpy.ndarray'>
    int32
    




    array([[0, 0, 0, 0],
           [0, 0, 0, 0],
           [0, 0, 0, 0],
           [0, 0, 0, 0]])




```python
np.ones((4,4),dtype = float)
```




    array([[1., 1., 1., 1.],
           [1., 1., 1., 1.],
           [1., 1., 1., 1.],
           [1., 1., 1., 1.]])




```python
np.full((3,3),3.14)
```




    array([[3.14, 3.14, 3.14],
           [3.14, 3.14, 3.14],
           [3.14, 3.14, 3.14]])




```python
a
```




    array([[0, 0, 0, 0],
           [0, 0, 0, 0],
           [0, 0, 0, 0],
           [0, 0, 0, 0]])




```python
np.zeros_like(a)
```




    array([[0, 0, 0, 0],
           [0, 0, 0, 0],
           [0, 0, 0, 0],
           [0, 0, 0, 0]])




```python
np.ones_like(a)
```




    array([[1, 1, 1, 1],
           [1, 1, 1, 1],
           [1, 1, 1, 1],
           [1, 1, 1, 1]])




```python
np.full_like(a,4.12,dtype = float)
```




    array([[4.12, 4.12, 4.12, 4.12],
           [4.12, 4.12, 4.12, 4.12],
           [4.12, 4.12, 4.12, 4.12],
           [4.12, 4.12, 4.12, 4.12]])



#### random


```python
import random
print(random.randint(5,10))
print(random.random())
```

    6
    0.3174040903523331
    


```python
np.random.random([3,3])
```




    array([[0.34392271, 0.56330278, 0.88974868],
           [0.51721379, 0.21389608, 0.97385049],
           [0.80808061, 0.22847277, 0.83117375]])




```python
# 经常会用到
np.random.randint(0,10,(4,4))
```




    array([[0, 2, 9, 2],
           [6, 1, 4, 5],
           [7, 2, 1, 7],
           [5, 4, 6, 1]])



### 范围取值


```python
list(range(0,10,2))
```




    [0, 2, 4, 6, 8]




```python
np.arange(0,10,2)
```




    array([0, 2, 4, 6, 8])




```python
# 经常用到 从0到3取步长相同的10个数
np.linspace(0,3,10)
```




    array([0.        , 0.33333333, 0.66666667, 1.        , 1.33333333,
           1.66666667, 2.        , 2.33333333, 2.66666667, 3.        ])




```python
# n维单位矩阵
np.eye(5)
```




    array([[1., 0., 0., 0., 0.],
           [0., 1., 0., 0., 0.],
           [0., 0., 1., 0., 0.],
           [0., 0., 0., 1., 0.],
           [0., 0., 0., 0., 1.]])



|Data type|Description|
|:----------:|:----------:|
|bool_|Boolean (True or False) stored as a byte|
|int_|Default integer type (same as C long; normally either int64 or int32)|
|intc|Identical to C int (normally int32 or int64) |
|intp|Integer used for indexing (same as C ssize_t; normally either int32 or int64) |
|int8|Byte (-128 to 127)|
|int16|Integer (-32768 to 32767)|
|int32|Integer (-2147483648 to 2147483647)|
|int64|Integer (-9223372036854775808 to 9223372036854775807) |
|uint8|Unsigned integer (0 to 255)|
|uint16|Unsigned integer (0 to 65535) |
|uint32|Unsigned integer (0 to 4294967295)|
|uint64|Unsigned integer (0 to 18446744073709551615)|
|float_|Shorthand for float64.|
|float16|Half precision float: sign bit, 5 bits exponent, 10 bits mantissa |
|float32|Single precision float: sign bit, 8 bits exponent, 23 bits mantissa|
|float64|Double precision float: sign bit, 11 bits exponent, 52 bits mantissa|
|complex_|Shorthand for complex128. |
|complex64|Complex number, represented by two 32-bit floats|
|complex128|Complex number, represented by two 64-bit floats|

### 访问数组中的元素


```python
# 嵌套列表的元素访问
var = [[1,2,3],[3,4,5],[5,6,7]]
var[0][0]
```




    1




```python
# 数组中元素的访问
a = np.array(var)
a[-1][0]
```




    5




```python
a
```




    array([[1, 2, 3],
           [3, 4, 5],
           [5, 6, 7]])




```python
# 这两种访问方式是等价的
a[0,0],a[0][0]
```




    (1, 1)




```python
#数组切片
a[:2,:2]
```




    array([[1, 2],
           [3, 4]])




```python
#和上面的方式是不等价的
a[:2][:2]
```




    array([[1, 2, 3],
           [3, 4, 5]])



### 数组属性


```python
a
```




    array([[1, 2, 3],
           [3, 4, 5],
           [5, 6, 7]])




```python
# 维度
print(a.ndim)
# shape
print(a.shape)
# zize
print(a.size)
# dtype
print(a.dtype)
# a.itemsize
print(a.itemsize)
# nbytes
print(a.nbytes)
```

    2
    (3, 3)
    9
    int32
    4
    36
    

### 数组的运算


```python
a = np.array(list(range(10)))
a
```




    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])




```python
print(a + 10)
print(a - 10)
print(a * 10)
```

    [10 11 12 13 14 15 16 17 18 19]
    [-10  -9  -8  -7  -6  -5  -4  -3  -2  -1]
    [ 0 10 20 30 40 50 60 70 80 90]
    


```python
a = np.full((3,3),1.0,dtype = float)
a + 10 #等价于np.add(a, 10)
```




    array([[11., 11., 11.],
           [11., 11., 11.],
           [11., 11., 11.]])



|Oprator|Equivalent ufunc|Description|
|-----|-----|-----|
| + |np.add|Addition(e.g.,1 + 1 = 2)|
| - |np.subtract|Subtraction(e.g.,3 - 2 = 1)|
| - |np.negative|Unary negation(e.g., -2)|
| * |np.multiply|Multiplication(e.g.,2 * 3 = 6)|
| / |np.divide|Division(e.g.,3 / 2 = 1.5)|
| // |np.floor_divide|Floor division(e.g.,3 // 2 = 1)|
| ** |np.power|Exponentiation(e.g.,2 ** 3 = 8)|
| % |np.mod|Modulus/remainder(e.g.,9 % 4 = 1)|


```python
np.add(a, 10)
```




    array([[11., 11., 11.],
           [11., 11., 11.],
           [11., 11., 11.]])




```python
a = np.linspace(0,np.pi, 5)
b = np.sin(a)
print(a)
print(b)
```

    [0.         0.78539816 1.57079633 2.35619449 3.14159265]
    [0.00000000e+00 7.07106781e-01 1.00000000e+00 7.07106781e-01
     1.22464680e-16]
    

### 统计类型


```python
# 求和
print(sum([1,2,3,4,5,6]))
#数组一维求和
a = np.full(10, 2.3)
print(sum(a))
#数组多维求和
a = np.array([[1,2],[3,4]])
print(sum(a))

# np.sum 求和
np.sum(a)
np.sum(a,axis = 1)
np.max(a,axis = 1)
```

    21
    23.000000000000004
    [4 6]
    




    array([2, 4])




```python
n = np.random.rand(1000)
```

#### notebook使用小技巧
    %timeit 代码：此方法来判断程序的执行效率


```python
%timeit sum(n)
```

    171 µs ± 1.42 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
    


```python
%timeit np.sum(n)
```

    6.04 µs ± 41.4 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
    

### 由上代码可以看出np.sum的执行效率高，推荐使用

#### 比较


```python
a = np.array(range(10))
a
```




    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])




```python
a > 3
```




    array([False, False, False, False,  True,  True,  True,  True,  True,
            True])




```python
a != 3
```




    array([ True,  True,  True, False,  True,  True,  True,  True,  True,
            True])




```python
a == a
```




    array([ True,  True,  True,  True,  True,  True,  True,  True,  True,
            True])



|Operator|Equivalent||Operator|Equivalent ufunc|
|---|---|---|---|---|
| == | np.equal || != | np.not_equal |
| < | np.less || <= | np.less_equal |
| > | np.greater || >= | np.greater_eqial |


```python
np.all(a>-1)
```




    True




```python
np.any(a>-1)
```




    True



### 变形


```python
a = np.full((2,10),1,dtype = float)
a
```




    array([[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
           [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]])




```python
a.reshape(10,2)
```




    array([[1., 1.],
           [1., 1.],
           [1., 1.],
           [1., 1.],
           [1., 1.],
           [1., 1.],
           [1., 1.],
           [1., 1.],
           [1., 1.],
           [1., 1.]])




```python
a.reshape(4,5)
```




    array([[1., 1., 1., 1., 1.],
           [1., 1., 1., 1., 1.],
           [1., 1., 1., 1., 1.],
           [1., 1., 1., 1., 1.]])



### 排序


```python
m = [
    [1,2,3],
    [34,12,4],
    [32,2,33]
    ]
a = np.array(m)
a
```




    array([[ 1,  2,  3],
           [34, 12,  4],
           [32,  2, 33]])




```python
np.sort(a)
a.sort(axis = 0)
a
```




    array([[ 1,  2,  3],
           [ 2,  4, 32],
           [12, 33, 34]])



### 拼接


```python
a = np.array([1,2,3])
b = np.array([[0,2,4],[1,3,5]])
```


```python
#按行拼接
np.concatenate([b,b,b],axis=0)
```




    array([[0, 2, 4],
           [1, 3, 5],
           [0, 2, 4],
           [1, 3, 5],
           [0, 2, 4],
           [1, 3, 5]])




```python
#按列拼接
np.concatenate([b,b,b],axis=1)
```




    array([[0, 2, 4, 0, 2, 4, 0, 2, 4],
           [1, 3, 5, 1, 3, 5, 1, 3, 5]])

Allen-Gao
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python_Numpy
Enrace的博客
10-09 1251
Python Numpy笔记 numpy.full方法 格式: numpy.full(整数或整数序列,填充值,“dtype数据类型”,主要是行或列) np.full((2,3)) #第一个参数，表示一个二维3列的数组,如果不以坐标形式，则表示为一维数组 np.full(2,np.inf) #第二个参数，表示一维二列的数组，都填充无穷大 np.full((2,2),2,“float”) #第三个参数，指定数据的类型 >>> x = np.full((2,2),2,"float") &gt
python入门教程之八python编程小记——字符串
qq_42832272的博客
05-22 254
width = int(input('Please enter width:')) price_width =10 item_width = width-price_width header_fmt = '{{:{}}}{{:>{}}}'.format(item_width,price_width) fmt = '{{:{}}}{{:>{}.2f}}'.format(item_...
np.full()函数的理解
wzk4869的博客
09-07 5622
np.full()函数的理解
【NumPy】深入解析numpy.full()函数
2402_83361138的博客
04-19 1943
通过灵活使用这个函数，我们可以简化数组初始化的过程，提高编程效率，并为后续的数值计算、数据处理和机器学习等任务提供便利。在大多数情况下，这个参数对普通用户来说可能不太重要，但在某些特定的数值计算或性能优化场景中，选择合适的存储顺序可能会带来一定的性能提升。我坚信知识的力量，希望通过我的分享，能够帮助更多的人掌握这些技术，并在实际项目中发挥作用。函数在大多数情况下都很快，但如果你需要创建非常大的数组，或者需要频繁地创建和销毁数组，那么可能需要考虑性能优化的问题。的权重矩阵，并将其所有元素初始化为 0.01。
定义一个整数类型的数组并存储多个数据,获取数组中的最大值和最小值
oneaka的博客
10-04 2070
定义一个整数类型的数组并存储多个数据,获取数组中的最大值和最小值 package day06作业九月二十三; public class 第七题 { public static void main(String[] args) { // 定义一个整数类型的数组并存储多个数据,获取数组中的最大值和最小值 int[] arr1 = new int[] { 12, 2, 33, 43, 13, 43, 90, 21 }; for (int i = 1; i < arr1.length; i+
Python-趣味编程入门学习笔记.pdf
06-11
Python是一种流行的高级编程语言，尤其适合初学者进行...理解这些基础知识对于Python编程的学习至关重要，它们构成了编写更复杂程序的基础。通过不断地实践和学习，你将逐渐掌握Python的精髓，从而开启你的编程之旅。
黑马python机器学习入门笔记
08-21
笔记可能会从基础开始，介绍Python编程基础，包括变量、数据类型、控制流（如if语句和for循环）、函数以及模块和包的导入。对于机器学习而言，理解数据处理至关重要，因此会涵盖Numpy库的使用，它是Python中用于科学...
python入门之基础语法学习笔记
12-20
Python 是一种广泛使用的高级编程语言，特别适合初学者入门。在学习Python的基础语法时，有几个关键概念需要了解。 首先，关于Python的中文编码问题。...掌握这些基础知识是学习Python编程的第一步。
Python趣味编程入门学习笔记.pdf
09-30
Python趣味编程入门学习笔记.pdf
python入门学习笔记
03-15
"Python入门学习笔记"是一份旨在帮助新手掌握Python编程基础的资料，它涵盖了Python语言的核心概念、基本语法以及常用库的使用。 在Python的世界里，初学者首先要了解的是其基本语法结构，包括变量的声明与赋值、...
numpy_full函数
健身房
01-01 5800
  numpy的full函数用于对数组进行填充。 import numpy as np a = np.full((2, 2), 5) print("a =", a) 执行结果： a = [[5 5] [5 5]]
numpy.full
hongxue8888的博客
03-27 1万+
参考：https://docs.scipy.org/doc/numpy/reference/generated/numpy.full.html import numpy as np a = np.full((2, 2), np.inf) b = np.full((2, 2), 10) print(a) print(b) 输出： [[ inf inf] [ inf inf]] [[...
Python语言程序设计
m0_51945364的博客
11-25 3509
Python基础-1 概述: 1.程序的格式框架： 缩进： 注释： 2.命名与保留字： 变量： 命名： 变量命名方式： 保留字： 3.数据类型： 数字类型 数字类型：整数和浮点数 基本数据类型 >>> x= 10 >>> y = x >>> id(y) 140710369391152 >>> id(y) 14071...
Python numpy.full函数方法的使用
weixin_42098295的博客
05-23 3272
NumPy（Numerical Python的缩写）是一个开源的Python科学计算库。使用NumPy，就可以很自然地使用数组和矩阵。NumPy包含很多实用的数学函数，涵盖线性代数运算、傅里叶变换和随机数生成等功能。本文主要介绍一下NumPy中full方法的使用。 原文地址：Python numpy.full函数方法的使用 ...
Python中矩阵库Numpy基本操作
热门推荐
yqtao的博客
09-29 14万+
NumPy是一个关于矩阵运算的库，熟悉Matlab的都应该清楚，这个库就是让python能够进行矩阵话的操作，而不用去写循环操作。下面对numpy中的操作进行总结。 numpy包含两种基本的数据类型：数组和矩阵。数组>>> from numpy import * >>> a1=array([1,1,1]) #定义一个数组 >>> a2=array([2,2,2]) >>> a1+a2
python numpy np.full(shape, fill_value, dtype=None, order='C')函数 以指定数值填充指定形状的数组
Dontla的博客
11-08 7728
def full(shape, fill_value, dtype=None, order='C'): """ Return a new array of given shape and type, filled with `fill_value`. 返回具有给定形状和类型的新数组，并填充“ fill_value”。 Parameters --------...
Selenium与WebDriver：Errno 8 Exec格式错误的多种解决方案
ip16yun的博客
07-30 376
在使用Selenium和WebDriver进行网页自动化时，可能会遇到各种错误。其中一个常见问题是执行格式错误（Errno 8 Exec format error）。这个错误通常在运行ChromeDriver时出现，错误提示涉及路径中的某个文件。本文将概述这个问题的背景，并提供多种解决方案，包括如何使用代理IP技术进行数据抓取。
python字符串数据容器练习（replace,split,count）
最新发布
2301_79600015的博客
07-31 458
Python字符串是由一系列字符组成的数据类型。在Python中，字符串是不可变的，这意味着一旦创建了一个字符串，就不能修改它的内容。以下是关于Python字符串的一些重要知识点：1. 字符串的基本操作：拼接字符串：使用`+`运算符。重复字符串：使用`*`运算符。索引和切片：使用`[]`和`:`操作符访问字符串中的子串。长度：使用`len()`函数获取字符串长度。转换大小写：使用`upper()`和`lower()`方法。分割和连接：使用`split()`和`join()`方法。
loguru日志模块：简化Python自动化测试的日志管理！
07-29 840
日志是软件开发中的关键组成部分，为开发和测试人员提供了调试和监控应用程序的重要手段。loguru 是一个第三方的 Python 日志库，以其简洁的 API 和自动化的功能脱颖而出。本文将探讨为什么项目中需要日志，loguru 为何受到青睐，以及如何封装和在接口自动化测试项目中使用 loguru，同时结合 Allure 生成丰富的测试报告。
Python编程入门学习笔记
这是一份关于Python编程语言的学习笔记，由作者皮大庆整理。笔记强调了Python作为一门新兴的、免费的、解释型的脚本编程语言，其特性包括面向对象、内置高级数据结构、跨平台支持以及可扩展性。Python的简洁语法使得...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值