Python

1. 列表list

.1 列表生成

List列表：是Python中使用最频繁的数据类型，其他语言中通常叫做数组。（Python的列表中可以存储不同类型的数据，但是开发中，更多的应用场景是存储相同类型的数据。）如果要取最后一个元素，除了计算索引位置外，还可以用-1做索引，直接获取最后一个元素。-2做索引获取倒数第二个元素，依此类推。

生成多维数组的方法：nums=[[0]*n for i in range(n)] #初始化一个n*n的零阵

这里[]中由一个表达式和一个for循环组成，for循环代表了nums中依次填充的元素个数，每次填充的元素为表达式的返回值，所以这里如果n=3的话可以得到以下数组：[[0,0,0],[0,0,0],[0,0,0]]。如果把[0]*n,更改为[0]*i则会生成数量依次递增的列表：[[0],[0,0],[0,0,0]]。

a = [0] * 9      #一维
#二维     二维数组[3][9]
demo = [[0] * 9 for _ in range(0, 3)]
#三维   三维数组[3][3][9]
demo = [[[0] * 9 for _ in range(0, 3)] for _ in range(0, 3)]

注意：python的变量名与值是通过索引链接起来的，当我们用*给列表增加的时候，python内部并未进行真正的创建新的列表，而是仅仅复制了索引，所以到会导致出现下面这种情况。

dp = [[0]*9]*3
dp[0][0] = 1

dp
"""
[[1, 0, 0, 0, 0, 0, 0, 0, 0],
 [1, 0, 0, 0, 0, 0, 0, 0, 0],
[1, 0, 0, 0, 0, 0, 0, 0, 0]]
"""

.2 常见方法

list.append(obj)	在列表末尾添加新的对象
list.count(obj)	统计某个元素在列表中出现的次数
list.extend(seq)	在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.index(obj)	从列表中找出某个值第一个匹配项的索引位置
list.insert(index, obj)	将对象插入列表
list.pop([index=-1])	移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.remove(obj)	移除列表中某个值的第一个匹配项
list.reverse()	反向列表中元素
list.sort( key=None, reverse=False)	对原列表进行排序
list.clear()	清空列表
list.copy()	复制列表

.3 切片

切片是为了获得序列某个区间的元素序列。切片操作通过使用两个冒号分隔3个数字来实现，

第一个数字表示切片的开始位置，默认为0；
第二个数字表示切片的终止位置（但不包含该位置的元素），默认为列表的长度；
第三个数字为切片的步长，默认为1，当省略步长时，可以同时省略后一个冒号。

lie = [3, 4, 6, 7, 2, 10, 16]
print(lie[:])  # 取全部元素
print(lie[0:])  # 取全部元素
print(lie[:-1])  # 取 除最后一个元素外的所有元素
print(lie[2:5])  # 取序号为2、3、4的元素，不包含最后一个序号的元素
print(lie[::2])  # 从0开始隔一个取一个元素
print(lie[1:5:2])  # 从1开始，每隔一个取一个元素，直到5为止
print(lie[::-1])  # 从右向左取全部成员
print(lie[5:0:-2])  # 从右向左隔一个取一个元素，不包含0

[3, 4, 6, 7, 2, 10, 16]
[3, 4, 6, 7, 2, 10, 16]
[3, 4, 6, 7, 2, 10]
[6, 7, 2]
[3, 6, 2, 16]
[4, 7]
[16, 10, 2, 7, 6, 4, 3]
[10, 7, 4]

lie[:-1]等价于 alist [0: -1:1],-1表示最后一个位置。

Python 列表切片操作_列表切片python-CSDN博客

2. 字符串str

        在Python中，字符串是一种不可变的数据类型，这意味着一旦创建了字符串对象，就不能直接修改其内容。如果对字符串进行操作（如拼接、替换字符等），实际上会创建一个新的字符串对象，而不是直接在原始字符串上进行修改。

这种不可变性的特性有以下几个方面的影响：

• 字符串的赋值：一旦创建了字符串对象，其内容就不能被修改，任何对字符串的赋值操作实际上是创建了一个新的字符串对象，并将其赋给变量。例如：

string = "Hello"
string = string + " world"  # 创建了一个新的字符串对象，并将其赋给变量string

• 字符串拼接：当对字符串进行拼接操作时，实际上是创建了一个新的字符串对象，将原始字符串和要拼接的内容连接起来形成新的字符串。原始字符串并没有被修改。例如：

string1 = "Hello"
string2 = " world"
new_string = string1 + string2  # 创建了一个新的字符串对象，将string1和string2连接起来

• 字符串方法的返回值：字符串方法（例如replace、upper、lower等）在执行操作后，会返回一个新的字符串对象作为结果，而不会修改原始字符串。例如：

string = "Hello"
new_string = string.replace("H", "J")  # 创建了一个新的字符串对象，将"H"替换为"J"

• 字符串的哈希值：由于字符串的不可变性，它们的哈希值在创建后是固定的。这使得字符串可以作为字典的键，或者在集合中进行快速查找和比较。

        字符串的不可变性带来了一些好处，例如提高了内存使用效率、保证了字符串对象的安全性和线程安全性等。同时，如果需要频繁地修改字符串内容，可能会导致不必要的字符串对象的创建和内存开销。在这种情况下，可以使用列表等可变数据类型来代替字符串，以提高效率。

比如str，对str进行操作：
>>> a = 'abc'
>>> a.replace('a', 'A')
'Abc'
>>> a
'abc'

最详细并且直观理解Python中的可变数据类型和不可变数据类型_python中什么是可变数据类型?什么是不可变数据类型?-CSDN博客

.1 字符串函数

split()方法
描述：split() 通过指定分隔符对字符串进行切片，如果参数 num 有指定值，则分隔 num+1 个子字符串。
split() 方法语法：str.split(str="", num=string.count(str))
参数：
str -- 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
num -- 分割次数。默认为 -1, 即分隔所有。
返回值：返回分割后的字符串列表。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
str = "Line1-abcdef \nLine2-abc \nLine4-abcd";
print str.split( );       # 以空格为分隔符，包含 \n
print str.split(' ', 1 ); # 以空格为分隔符，分隔成两个
# 以上实例输出结果如下：
#['Line1-abcdef', 'Line2-abc', 'Line4-abcd']
#['Line1-abcdef', '\nLine2-abc \nLine4-abcd']

map() 函数
描述：map() 会根据提供的函数对指定序列做映射。第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
map() 函数语法：map(function, iterable, ...)
参数：function -- 函数；        iterable -- 一个或多个序列
返回值：Python 2.x 返回列表。Python 3.x 返回迭代器。 

Python map() 函数 | 菜鸟教程 (runoob.com)

.2 字符串转换为数字

chr(x )           将一个整数转换为一个字符 ；     str(x )                将对象 x 转换为字符串 
ord(x )           将一个字符转换为它的ASCII值；int(x [,base ])    将x转换为一个整数
tuple(s )        将序列 s 转换为一个元组；         list(s )                将序列 s 转换为一个列表

chr(65)='A'
ord('A')=65
int('2')=2
str(2)='2'

python如何将字符转换为数字？_python字符转数字-CSDN博客

3. 字典dict

        Python3 字典 values() 方法返回一个视图对象。dict.keys()、dict.values() 和 dict.items() 返回的都是视图对象（ view objects），提供了字典实体的动态视图，这就意味着字典改变，视图也会跟着变化。视图对象不是列表，不支持索引，可以使用 list() 来转换为列表。我们不能对视图对象进行任何的修改，因为字典的视图对象都是只读的。

函数或方法	作用
cmp(dict1, dict2)	比较两个字典元素
len(dict)	字典长度
str(dict)	输出字典可打印的字符串表示
type(variable)	输出变量的类型
dict.clear()	删除字典内所有元素
dict.copy()	返回字典的一个复制
dict.fromkeys(seq[, val])	创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
dict.get(key, default=None)	返回指定键的值，如果值不在字典中返回default值
dict.has_key(key)	如果键在字典dict里返回true，否则返回false
dict.items()	返回可遍历的(键, 值) 元组数组
dict.keys()	返回一个字典所有的键
dict.setdefault(key, default=None)	和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
dict.update(dict2)	把字典dict2的键/值对更新到dict里
dict.values()	返回字典中的所有值
pop(key[,default])	删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
popitem()	随机返回并删除字典中的一对键和值。

python 删除hash_mob64ca12ddcacc的技术博客_51CTO博客

4. 集合set

        set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以在set中，没有重复的key。

set()函数：创建空集合只能使用 ，{}这个是创建空字典用的；
add()函数：用来增加单个数据，不能增加数据序列；
update()函数：在集合中增加数据序列，注意是数据序列，不是单个数据，否则报错；
remove()函数：删除集合中指定的数据，如果数据在集合中则删除，如果不在则报错；
discard()函数：删除集合中指定的数据，如果数据在集合中则删除，如果不在数据也不报错；
clear()函数：清空集合。

s = set()    #创建空集合
s.add(1)    #增加元素s = (1)
s.update((1,2,3,4,5))    #增加集合中的元素s = (1,2,3,4,5)，重复元素只出现一次
s.remove(2)    #删除元素s = (1,3,4,5)
s.clear()     #清空集合

Python创建集合与常见方法【详细】_集合创建的两种方法-CSDN博客

5. 常用的内置函数

.1 list(), tuple(), dict()

这些函数用于创建列表、元组和字典，分别从可迭代对象（如字符串、列表、元组等）中生成新的数据结构。

string = "Hello"
my_list = list(string)
my_tuple = tuple(string)
my_dict = dict(name="Alice", age=30)

.2 max() 和 min()

max()和min()函数分别用于查找可迭代对象中的最大值和最小值。

numbers = [10, 5, 8, 20, 3]
maximum = max(numbers)
minimum = min(numbers)
print("Max:", maximum)
print("Min:", minimum)

.3 sum()

sum()函数用于计算可迭代对象中的所有元素的和。

numbers = [1, 2, 3, 4, 5]
total = sum(numbers)
print("Sum:", total)

.4 sorted()

sorted()函数用于对可迭代对象进行排序，返回一个新的已排序列表。可以指定降序排序。
sorted 语法：sorted(iterable[, cmp[, key[, reverse]]])
参数说明：

• iterable -- 可迭代对象。
• cmp -- 比较的函数（python3中已被彻底移除），这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
• key -- 主要是用来进行比较的元素（python2.4开始提供，之前采用cmp），只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。此函数将在每个元素比较前被调用。
• reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

>>>a = [5,7,6,3,4,1,2]
>>> b = sorted(a)       # 保留原列表
>>> a 
[5, 7, 6, 3, 4, 1, 2]
>>> b
[1, 2, 3, 4, 5, 6, 7]
 
>>> L=[('b',2),('a',1),('c',3),('d',4)]
>>> sorted(L, cmp=lambda x,y:cmp(x[1],y[1]))   # 利用cmp函数
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> sorted(L, key=lambda x:x[1])               # 利用key
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
 
>>> sorted(students, key=lambda s: s[2], reverse=True)       # 按降序
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
>>>

        sort 与 sorted 区别：

1. sort 是应用在 list 上的方法，属于列表的成员方法；sorted 可以对所有可迭代的对象进行排序操作。
2. list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
3. sort使用方法为ls.sort()，而sorted使用方法为sorted(ls)​ 

Python中sort ()与 sorted() 区别_python中sort和sorted-CSDN博客

.5 随机数生成random

random.random() 返回一个介于 0.0 和 1.0 之间的随机小数：

import random

random_number = random.random()
print(random_number)

output:
$ 0.7597072251250637

random.randint(a, b) 用于返回一个介于 a 和 b 之间的整数（包括 a 和 b）。函数返回数字 N ，N 为 a 到 b 之间的数字（a <= N <= b），包含 a 和 b。

random.choice(sequence) 用于从序列中随机选择一个元素。

import random

list1 = [1, 2, 3, 4, 5]
random_element = random.choice(list1)
print(random_element)

random.shuffle(sequence) 用于将序列中的元素进行随机排序。

import random

list1 = [1, 2, 3, 4, 5]
random.shuffle(list1)
print(list1)

output: 
$ [3, 2, 4, 5, 1]

Python 随机数生成 | 菜鸟教程 (runoob.com)

6. 运算符

*	乘 - 两个数相乘或是返回一个被重复若干次的字符串	a * b 输出结果 210
/	除 - x 除以 y	b / a 输出结果 2.1
%	取模 - 返回除法的余数	b % a 输出结果 1
**	幂 - 返回x的y次幂	a**b 为10的21次方
//	取整除， - 时往小的方向取整数	>>> 9 // 2 = 4 >>> -9 // 2 = -5

python 的整数除法是向下取整，而不是向零取整。
python2 的除法 "/" 是整数除法， "-3 / 2 = -2" ；python3 的除法 "/" 是浮点除法， "-3 / 2 = -1.5" ；
python3 地板除 "//" 是整数除法， "-3 // 2 = -2" ； C++/Java 的整数除法是向零取整 "-3 / 2 = -1"。

print(10 / 3)         #3.3333333333333335
print(-10 / 3)        #-3.3333333333333335
print(10 // 3)        #3
print(-10 // 3)       #-4
print(int(10 / 3))    #3
print(int(-10 / 3))   #-3

7. lambda函数

        Python 使用 lambda 来创建匿名函数。lambda 函数是一种小型、匿名的、内联函数，它可以具有任意数量的参数，但只能有一个表达式。匿名函数不需要使用 def 关键字定义完整函数。lambda 函数通常用于编写简单的、单行的函数，通常在需要函数作为参数传递的情况下使用，例如在 map()、filter()、reduce() 等函数中。
        lambda 语法格式：lambda arguments: expression
lambda是 Python 的关键字，用于定义 lambda 函数。
arguments 是参数列表，可以包含零个或多个参数，但必须在冒号(:)前指定。
expression 是一个表达式，用于计算并返回函数的结果。

#exampel 1
x = lambda a, b : a * b
print(x(5, 6))    #输出：30

#exampel 2
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
print(squared)  # 输出: [1, 4, 9, 16, 25]

Python 之 lambda 函数完整详解 & 巧妙运用_lambda函数python-CSDN博客

8. Numpy

.1 linspace函数

numpy提供linspace函数(有时也称为np.linspace)是python中创建数值序列工具。与Numpy arange函数类似，生成结构与Numpy 数组类似的均匀分布的数值序列。

numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0, *, device=None)

np.linspace(start = 0, stop = 100, num = 5)

Numpy linspace函数依照定义间隔生成均匀分布的数值。我们使用start和stop参数指定间隔，这里我们设定为0和100，同时指定在范围内生产5个观测值，因此函数生成5个均匀分布的元素。第一个是0，最后一个100，其他三个分布在0和100之间。[0，25，50，75，100]

start：start 参数数值范围的起始点。如果设置为0，则结果的第一个数为0。该参数必须提供。

stop：stop 参数数值范围的终止点。通常其为结果的最后一个值，但如果修改endpoint = False, 则结果中不包括该值(后面示例会说明)。

num (可选)：num 参数控制结果中共有多少个元素。如果num=5，则输出数组个数为5.该参数可选，缺省为50.

endpoint (可选)：endpoint 参数决定终止值(stop参数指定)是否被包含在结果数组中。如果 endpoint = True, 结果中包括终止值，反之不包括。缺省为True。

dtype (可选)：和其他的 NumPy 一样, np.linspace中的dtype 参数决定输出数组的数据类型。如果不指定，python基于其他参数值推断数据类型。如果需要可以显示指定，参数值为NumPy 和 Python支持的任意数据类型。                      

x = numpy.linspace(-15, 15, 10) # 10 points spanning 0..30 mm range
y = numpy.linspace(-15, 15, 10) # 10 points spanning 0..30 mm range
xv, yv = numpy.meshgrid(x, y)

原文链接：https://blog.csdn.net/neweastsun/article/details/99676029

.2 meshgrid函数

meshgrid函数用两个坐标轴上的点在平面上画网格。[X,Y,Z]=meshgrid(x,y,z)生成三维数组，可用来计算三变量的函数和绘制三维立体图。[X,Y]=meshgrid(x)与[X,Y]=meshgrid(x,x)是等同的。

以[X,Y]=meshgrid(x,y)为例，假设x是长度为m的向量，y是长度为n的向量，则最终生成的矩阵X和Y的维度都是 n*m （注意不是m*n）。

参考链接：https://www.cnblogs.com/lemonbit/p/7593898.html