怎么用python解一元高次函數

寫個例子吧，需要安裝numpy數學庫

為隴川等地區用戶提供了全套網頁設計制作服務，及隴川網站建設行業解決方案。主營業務為網站制作、做網站、隴川網站設計，以傳統方式定制建設網站，并提供域名空間備案等一條龍服務，秉承以專業、用心的態度為用戶提供真誠的服務。我們深信只要達到每一位用戶的要求，就會得到認可，從而選擇與我們長期合作。這樣，我們也可以走得更遠！

#!/usr/bin/python

import numpy as np

#求解方程x^2+2x+1=0的根

#方程參數列表抽象成一下形式：

arg=[1， 2， 1]

#求解

np.roots(args)

運行即可求解了，如果沒有實根會給虛根的結果

Python函數和模塊的定義與使用，包括變量的類型及匿名函數用法

函數是組織好，可重復使用的，用來實現相關功能的代碼段

函數提高了代碼的重復利用率和應用的模塊性。

除Python自帶的函數之外，也可以自己創建函數，叫做自定義函數

語法：

函數代碼塊以 def 開頭

參數為 輸入值 ，放于函數名后口號里面，

函數內容以冒號:開始，函數體縮進， return 返回 輸出值

函數調用使用關鍵字參數來確定傳入的參數值，此時，如果多個函數則不需要按照指定順序。

在定義函數時，指定參數默認值。調用時如果不傳入參數，則使用默認值

不定長部分如果沒有指定參數，傳入是一個空元組

加了 兩個星號 ** 的參數會以字典的形式導入

/ 用來指明函數形參必須使用指定位置參數，不能使用關鍵字參數的形式。

3.8版本之后的才能使用

不使用 def 定義函數，沒有函數名

lamdba主體時一個表達式，而不是代碼塊，函數體比def簡單很多

定義在函數內部的為局部變量，僅能在函數內部使用

定義在函數外部的為全局變量，可在全局使用

模塊是將包含所有定義的函數和變量的文件，一般將同類功能的函數組和在一起稱為模塊。

模塊需要導入后，在調用相應函數進行使用

模塊導入的方法：

從模塊中導入一個指定的部分

把一個模塊的所有內容全都導入

eval函數在python中的應用

以python 3.8.5150.0版本為例，python中eval函數作用如下：

1、計算字符串中有效的表達式，并返回結果。

2、將字符串轉成相應的對象（如list、tuple、dict和string之間的轉換）。

3、將利用反引號轉換的字符串再反轉回對象。

參數解析：

expression：這個參數是一個字符串，python會使用globals字典和locals字典作為全局和局部的命名空間，將expression當作一個python表達式進行解析和計算。

globals：這個參數控制的是一個全局的命名空間，也就是我們在計算表達式的時候可以使用全局的命名空間中的函數，如果這個參數被提供了。

并且沒有提供自定義的builtins(python的內建模塊)，那么會將當前環境中的builtins拷貝到提供的globals里，然后進行計算。如果globals沒有被提供，則使用python的全局命名空間。

locals：這個參數控制的是一個局部的命名空間，和globals類似，不過當它和globals中有重復的部分時，locals里的定義會覆蓋掉globals中的，也就是說當globals和locals中有沖突的部分時，locals說了算，它有決定權，以它的為準。如果locals沒有被提供的話，則默認為globals。

如何用Python封裝C語言的字符串處理函數

在C語言中，字符串處理是每天都要面對的問題。我們都知道C語言中其實并沒有一種原生的字符串類型，‘字符串’在C語言里只是一種特殊的以''結尾的字符數組。因此，如何將C語言與更高層次的Python語言在‘字符串’處理這個問題上對接是一個有難度的問題。所幸有swig這種強大的工具。

如何封裝一個函數，它修改參數字符串的內容

假如有這樣一個C語言的函數，

!-- lang: cpp --

void FillZero(char* pc,size_t * piLen)

{

size_t i=0;

while(i++*piLen/2 )

*pc++ = '0';

*pc = 0;

*piLen = i+1;

}

這個函數的功能是把字符串變成n個0。不過我們更關注函數的形式。這樣的函數，表面上看char* pc是函數的參數，可是實際上它才是函數的返回值和執行的結果。piLen這個參數既是pc的最大長度，也是新的字符串的長度。我們直接用python封裝，看看運行結果。

Type "help", "copyright", "credits" or "license" for more information.

import cchar

s='123456'

cchar.FillZero(s,6)

Traceback (most recent call last):

File "stdin", line 1, in module

TypeError: in method 'FillZero', argument 2 of type 'size_t *'

結果差強人意，不是我們想要得到的結果。函數的第二個參數為size_t* 我們很難用python來表示，而且python中也不存在既是輸入，也是輸出的參數。

swig有一個標準庫，其中有一個cstring.i文件就是用來解決C語言字符串類型的問題。

我們在.i文件中加入這樣幾行

!-- lang: cpp --

%include "cstring.i"

%cstring_output_withsize(char* pc,size_t* pi)

void FillZero(char* pc, size_t* pi);

然后運行看結果

Type "help", "copyright", "credits" or "license" for more information.

import cchar

cchar.FillZero(10)

'00000\x00'

s=cchar.FillZero(10)

print s

00000

我們看函數的變化。首先在python里， FillZero變成了只有一個參數的函數。然后函數的返回值變成了一個字符串。其實cstring_output_size其實是一個宏，通過這個宏的定義改變了函數的形式，直接在Python中得到我們想要的結果。

其實類似cstring_output_size的宏還有好幾個，我列舉一下:

cstring_output_allocate(char *s,free($1));

第一個參數是指向字符串地址的指針，第二個參數為釋放空間的方法。

大家考慮這一下這樣的函數：

void foo(char* s)

{

s = (char*)malloc(10);

memcpy(s,"123456789",9);

}

s這個參數表面上看是輸入，實際上是函數真正的輸出。 函數中真正改變的東西是chars指向的字符串的值。而且char這個類型,

python或者其他腳本語言里應該都沒有對應的類型。那么我們用cstring_output_allocate將這個函數轉換成另外一個形式的python或者其他腳本語言的函數。轉換后的函數其實是這樣的，以python為例str

foo()。

!-- lang: cpp --

%module a

%include "cstring.i"

%{

void foo(char* s);

%}

%cstring_output_allocate(char *s, free(*$1));

void foo(char *s);

在python中的調用：

!-- lang: python --

import a

a.foo()

'123456789'

cstring_output_maxsize(char *path, int maxpath);

第一個參數也是可以改變的字符串首地址，第二個參數為字符串的最大長度。在Python中調用的時候，只有maxpath這個參數，返回字符串。

cstring_output_allocate(char *s, free($1));

第一個參數為指向字符串首地址的指針，第二個參數為釋放指針的方法。這個宏主要是封裝一種直接在函數內部malloc空間的函數。在Python中調用時沒有參數，直接返回字符串。

cstring_output_allocate_size(char *s, int slen, free(*$1));

這個相當于前面兩個函數的組合。在函數內部malloc空間，然后將字符串長度通過slen返回。其實在調用的時候非常簡單，沒有參數，直接返回字符串。

如何處理c++的std::string

std::string是C++標準類庫STL中常見的類。在平時工作中大家肯定是沒少用。在python中如何封裝std::string? swig提供了標準庫

例如函數:

!-- lang: cpp --

string Repeat(const string s)

{

return s+s;

}

只要在swig中加入這樣幾行：

!-- lang: cpp --

%include "std_string.i"

using namespace std;

string Repeat(const string s);

運行結果：

Python 2.6.6 (r266:84292, Dec 27 2010, 00:02:40)

[GCC 4.4.5] on linux2

Type "help", "copyright", "credits" or "license" for more information.

import cchar

cchar.Repeat('123')

'123123'

使用起來很方便，但需要注意的是，假如函數的參數的內容是可以被修改，就不能用這種方式封裝。

例如:

!-- lang: cpp --

void repeat(string s)

{

s+=s;

}

這樣的函數直接使用 'std_string.i' 就是無效的。遇到這種函數，只能用C語言封裝成 void repeat(chars, int maxsize), 再用swig調用 'cstring_output_withsize' 這個宏再封裝一次了。

用python來解決列表函數多次使用問題？

你的函數是讓原列表每個元素值+1，這里省略了函數，做的仍然是每個元素+1

# 2021-05-11 Luke

s=[1, 2, 3, 4, 5, 5, 6, 1, 4, 5, 5, 7, 1, 5, 3, 8, 3, 5, 9, 1]

num = input("請指定需要循環的次數:")

i = 1

while i = int(num):

new_s = []

for a in s:

a += 1

new_s.append(a)

s = []

s = new_s

用你寫的函數的話這樣也可以

# 2021-05-11 Luke

s=[1, 2, 3, 4, 5, 5, 6, 1, 4, 5, 5, 7, 1, 5, 3, 8, 3, 5, 9, 1]

def tset(s):

s1 = [x+1 for x in s]

return s1

num = input("請指定需要循環的次數:")

i = 1

while i = int(num):

new_s = tset(s)

s = new_s

i += 1

print(s)

i += 1

print(s)

Python常用的正則表達式處理函數詳解

正則表達式是一個特殊的字符序列，用于簡潔表達一組字符串特征，檢查一個字符串是否與某種模式匹配，使用起來十分方便。

在Python中，我們通過調用re庫來使用re模塊：

import re

下面介紹Python常用的正則表達式處理函數。

re.match函數

re.match 函數從字符串的起始位置匹配正則表達式，返回match對象，如果不是起始位置匹配成功的話，match()就返回None。

re.match(pattern, string, flags=0)

pattern：匹配的正則表達式。

string：待匹配的字符串。

flags：標志位，用于控制正則表達式的匹配方式，如：是否區分大小寫，多行匹配等等。具體參數為：

re.I：忽略大小寫。

re.L：表示特殊字符集 \w, \W, \b, \B, \s, \S 依賴于當前環境。

re.M：多行模式。

re.S：即 . ，并且包括換行符在內的任意字符（. 不包括換行符）。

re.U：表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依賴于 Unicode 字符屬性數據庫。

re.X：為了增加可讀性，忽略空格和 # 后面的注釋。

import?re #從起始位置匹配 r1=re.match('abc','abcdefghi') print(r1) #不從起始位置匹配 r2=re.match('def','abcdefghi') print(r2)

運行結果：

其中，span表示匹配成功的整個子串的索引。

使用group(num) 或 groups() 匹配對象函數來獲取匹配表達式。

group(num)：匹配的整個表達式的字符串，group() 可以一次輸入多個組號，這時它將返回一個包含那些組所對應值的元組。

groups()：返回一個包含所有小組字符串的元組，從 1 到 所含的小組號。

import?re s='This?is?a?demo' r1=re.match(r'(.*)?is?(.*)',s) r2=re.match(r'(.*)?is?(.*?)',s) print(r1.group()) print(r1.group(1)) print(r1.group(2)) print(r1.groups()) print() print(r2.group()) print(r2.group(1)) print(r2.group(2)) print(r2.groups())

運行結果：

上述代碼中的(.*)和(.*?)表示正則表達式的貪婪匹配與非貪婪匹配。

re.search函數

re.search函數掃描整個字符串并返回第一個成功的匹配，如果匹配成功則返回match對象，否則返回None。

re.search(pattern, string, flags=0)

pattern：匹配的正則表達式。

string：待匹配的字符串。

flags：標志位，用于控制正則表達式的匹配方式，如：是否區分大小寫，多行匹配等等。

import?re #從起始位置匹配 r1=re.search('abc','abcdefghi') print(r1) #不從起始位置匹配 r2=re.search('def','abcdefghi') print(r2)

運行結果：

使用group(num) 或 groups() 匹配對象函數來獲取匹配表達式。

group(num=0)：匹配的整個表達式的字符串，group() 可以一次輸入多個組號，這時它將返回一個包含那些組所對應值的元組。

groups()：返回一個包含所有小組字符串的元組，從 1 到 所含的小組號。

import?re s='This?is?a?demo' r1=re.search(r'(.*)?is?(.*)',s) r2=re.search(r'(.*)?is?(.*?)',s) print(r1.group()) print(r1.group(1)) print(r1.group(2)) print(r1.groups()) print() print(r2.group()) print(r2.group(1)) print(r2.group(2)) print(r2.groups())

運行結果：

從上面不難發現re.match與re.search的區別：re.match只匹配字符串的起始位置，只要起始位置不符合正則表達式就匹配失敗，而re.search是匹配整個字符串，直到找到一個匹配為止。

re.compile 函數

compile 函數用于編譯正則表達式，生成一個正則表達式對象，供 match() 和 search() 這兩個函數使用。

re.compile(pattern[, flags])

pattern：一個字符串形式的正則表達式。

flags：可選，表示匹配模式，比如忽略大小寫，多行模式等。

import?re #匹配數字 r=re.compile(r'\d+')? r1=r.match('This?is?a?demo') r2=r.match('This?is?111?and?That?is?222',0,27) r3=r.match('This?is?111?and?That?is?222',8,27) ? print(r1) print(r2) print(r3)

運行結果：

findall函數

搜索字符串，以列表形式返回正則表達式匹配的所有子串，如果沒有找到匹配的，則返回空列表。

需要注意的是，match 和 search 是匹配一次，而findall 匹配所有。

findall(string[, pos[, endpos]])

string：待匹配的字符串。

pos：可選參數，指定字符串的起始位置，默認為0。

endpos：可選參數，指定字符串的結束位置，默認為字符串的長度。

import?re #匹配數字 r=re.compile(r'\d+')? r1=r.findall('This?is?a?demo') r2=r.findall('This?is?111?and?That?is?222',0,11) r3=r.findall('This?is?111?and?That?is?222',0,27) ? print(r1) print(r2) print(r3)

運行結果：

re.finditer函數

和 findall 類似，在字符串中找到正則表達式所匹配的所有子串，并把它們作為一個迭代器返回。

re.finditer(pattern, string, flags=0)

pattern：匹配的正則表達式。

string：待匹配的字符串。

flags：標志位，用于控制正則表達式的匹配方式，如是否區分大小寫，多行匹配等。

import?re? r=re.finditer(r'\d+','This?is?111?and?That?is?222') for?i?in?r:? ?print?(i.group())

運行結果：

re.split函數

將一個字符串按照正則表達式匹配的子串進行分割后，以列表形式返回。

re.split(pattern, string[, maxsplit=0, flags=0])

pattern：匹配的正則表達式。

string：待匹配的字符串。

maxsplit：分割次數，maxsplit=1分割一次，默認為0，不限次數。

flags：標志位，用于控制正則表達式的匹配方式，如：是否區分大小寫，多行匹配等。

import?re? r1=re.split('\W+','This?is?111?and?That?is?222')? r2=re.split('\W+','This?is?111?and?That?is?222',maxsplit=1)? r3=re.split('\d+','This?is?111?and?That?is?222')? r4=re.split('\d+','This?is?111?and?That?is?222',maxsplit=1)? print(r1) print(r2) print(r3) print(r4)

運行結果：

re.sub函數

re.sub函數用于替換字符串中的匹配項。

re.sub(pattern, repl, string, count=0, flags=0)

pattern：正則中的模式字符串。

repl：替換的字符串，也可為一個函數。

string：要被查找替換的原始字符串。

count：模式匹配后替換的最大次數，默認0表示替換所有的匹配。

import?re? r='This?is?111?and?That?is?222' #?刪除字符串中的數字 r1=re.sub(r'\d+','',r) print(r1) #?刪除非數字的字符串? r2=re.sub(r'\D','',r) print(r2)

運行結果：

到此這篇關于Python常用的正則表達式處理函數詳解的文章就介紹到這了，希望大家以后多多支持！