一、內(nèi)置函數(shù)

1. complex([real[,imag]])

返回一個(gè)復(fù)數(shù)，實(shí)部 + 虛部*1j，或者把字符串或者數(shù)字轉(zhuǎn)成復(fù)數(shù)形式。

參數(shù)可以是復(fù)數(shù)表達(dá)式，也可以是字符串。當(dāng)參數(shù)是字符串的時(shí)候，數(shù)字與操作符之間不能有空格。即comple('1 + 2j')是錯(cuò)誤的。

print(complex(1, 2))

print(complex(1 + 2j))

print(complex('1+2j'))

# 輸出 1+2j

print(complex(1))

# 輸出 1+0j

滿足：實(shí)部 + 虛部*1j 的數(shù)被稱為復(fù)數(shù)。

a = 1 + 3j

# 求實(shí)部

print(a.real)

# 求虛部

print(a.imag)

# 求共軛

print(a.conjugate())

2. chr(i) 與 ord(i)

chr(i) 是將當(dāng)前整數(shù) i 轉(zhuǎn)成對(duì)應(yīng)的 ascii 字符，可以是十進(jìn)制，也可以是十六進(jìn)制，其中0 <= i <= 0x10ffff (1114111)。其對(duì)應(yīng)的逆操作為 ord(i)，i 為 ascii 字符。

下面的函數(shù)演示如何求一個(gè)可迭代對(duì)象的 ascil字符 或者其對(duì)應(yīng)的數(shù)值。注意函數(shù) ordplus ，參數(shù) x 中的每一個(gè)元素必須是單個(gè)字符，如果是列表，形式如下：[‘P’ , ‘y’, ‘t’ , ‘h’, ‘o’ , ‘n’]。

def chrplus(x):

chr_string = ''

for elem in x:

chr_string += chr(elem)

return chr_string

def ordplus(x):

ord_list = []

for elem in x:

ord_list.append(ord(elem))

return ord_list

x = 'Python高效編程'

temp = ordplus(x)

print(temp)

# 輸出：[112, 121, 116, 104, 111, 110,

# 39640, 25928, 32534,31243]

init = chrplus(temp)

print(init)

# 輸出：Python高效編程

3.enumerate(iterable, start=0)

返回 enumerate 對(duì)象。迭代對(duì)象必須是序列，迭代器，或者其他支持迭代的對(duì)象。enmerate() 函數(shù)返回的是迭代器，同樣是可迭代對(duì)象。每次迭代的元素，都包含元素在序列里的序號(hào)(strat 默認(rèn)值為 0) 和元素對(duì)應(yīng)值。因此，我們可以用 for 循環(huán)獲取返回值。

等價(jià)于：

def enumerate(sequence, start=0):

n = start

for elem in sequence:

yield n, elem

n += 1

for i, elem in enumerate(['P', 'y', 't', 'h', 'o', 'n']):

print(i, elem)

4. abs(x)

返回?cái)?shù)的絕對(duì)值。參數(shù)可以是整數(shù)或者浮點(diǎn)數(shù)。如果參數(shù)是復(fù)數(shù)，返回復(fù)數(shù)的模。Python 中虛數(shù)用數(shù)值加上字符 j 的形式表示。要注意 j 前面的數(shù)值不能省略，比如 1j。

下面是我寫的簡(jiǎn)易版的 abs 函數(shù)：

from math import sqrt

def naive_abs(x):

# isinstance 判斷參數(shù)x是否為整數(shù)或浮點(diǎn)數(shù)

if isinstance(x, int) or isinstance(x, float):

if x < 0:

x = - x

# 判斷參數(shù)x是否為復(fù)數(shù)

elif isinstance(x, complex):

# x.real 復(fù)數(shù)的實(shí)部

# x.imag 復(fù)數(shù)的虛部

real = x.real

imag = x.imag

# 求復(fù)數(shù)的模

x = sqrt(real ** 2 + imag ** 2)

else :

return '請(qǐng)輸入 int float complex'

return x

print(abs(3+4j))

print(naive_abs(3+4j))

# 輸出 5.0

print(abs(-6))

print(naive_abs(-6))

# 輸出 6

二、算法與數(shù)據(jù)結(jié)構(gòu)

1. 二分查找

要想使用二分搜索，首先要確保迭代序列是有序的。對(duì)于無序序列，我們首先要進(jìn)行排序操作。

每次循環(huán)縮小一半搜索范圍，時(shí)間復(fù)雜度為 O(logn)。每次循環(huán)，比較選取的中間數(shù)與需要查找的數(shù)字，如果待查數(shù)小于中間數(shù)，就減少右界至中間數(shù)的前一個(gè)數(shù)；如果待查數(shù)大于中間數(shù)，就增加左界到中間數(shù)后一個(gè)數(shù)；如果待查數(shù)等于中間數(shù)，返回中間數(shù)的下標(biāo)，該下標(biāo)即為待查數(shù)在序列中的位置。當(dāng)左界大于右界時(shí)，循環(huán)結(jié)束，說明序列中并沒有待查數(shù)。

def binary_search(item, find):

# 有序可迭代對(duì)象

left, right = 0, len(item) - 1

mid = left + (right - left) // 2

while left <= right:

if item[mid] == find:

return mid

elif item[mid] > find:

right = mid - 1

else:

left = mid + 1

mid = left + (right - left) // 2

return None

seq = [1, 4, 7, 9, 13, 17, 18, 21, 34, 45, 65]

binary_search(seq, 13)

# 輸出：4

2. 快速排序

首先要打亂序列順序 ，以防算法陷入最壞時(shí)間復(fù)雜度。快速排序使用“分而治之”的方法。對(duì)于一串序列，首先從中選取一個(gè)數(shù)，凡是小于這個(gè)數(shù)的值就被放在左邊一摞，凡是大于這個(gè)數(shù)的值就被放在右邊一摞。然后，繼續(xù)對(duì)左右兩摞進(jìn)行快速排序。直到進(jìn)行快速排序的序列長(zhǎng)度小于 2 (即序列中只有一個(gè)值或者空值)。

# quicksort

import random

def quicksort(seq):

if len(seq) < 2:

return seq

else:

base = seq[0]

left = [elem for elem in seq[1:] if elem < base]

right = [elem for elem in seq[1:] if elem > base]

return quicksort(left) + [base] + quicksort(right)

seq = [9, 8, 7, 6, 5, 4, 3]

random.shuffle(seq)

# seq：[6, 4, 9, 3, 8, 5, 7]

print(quicksort(seq))

# 輸出：[3, 4, 5, 6, 7, 8, 9]

3. 冒泡排序

冒泡排序(順序形式)，從左向右，兩兩比較，如果左邊元素大于右邊，就交換兩個(gè)元素的位置。其中，每一輪排序，序列中最大的元素浮動(dòng)到最右面。也就是說，每一輪排序，至少確保有一個(gè)元素在正確的位置。這樣接下來的循環(huán)，就不需要考慮已經(jīng)排好序的元素了，每次內(nèi)層循環(huán)次數(shù)都會(huì)減一。其中，如果有一輪循環(huán)之后，次序并沒有交換，這時(shí)我們就可以停止循環(huán)，得到我們想要的有序序列了。

def bouble_sort(sequence):

seq = sequence[:]

length = len(seq) - 1

i = j = 0

flag = 1

while i < length:

j = 0

while j < length - i:

if seq[j] > seq[j + 1]:

seq[j], seq[j + 1] = seq[j + 1], seq[j]

flag = 0

j += 1

if flag:

break

i += 1

return seq

4. 選擇排序

選擇排序，每次選擇當(dāng)前序列的最小值，將其與當(dāng)前序列的第一個(gè)元素交換位置，每迭代一次，當(dāng)前序列長(zhǎng)度減一。迭代結(jié)束，即可得到有序序列。

def find_minimal_index(seq):

min_elem = seq[0]

count = 0

min_elem_index = count

for elem in seq[1:]:

count += 1

if elem < min_elem:

elem, min_elem = min_elem, elem

min_elem_index = count

return min_elem_index

def select_sort(sequence):

# 選擇排序

seq = sequence[:]

length = len(seq)

for i in range(length):

index = find_minimal_index(seq[i:])

seq[index + i], seq[i] = seq[i], seq[index + i]

return seq

5. 去重序列重復(fù)元素

首先新建一個(gè)集合 set，對(duì)于序列中的元素，如果已經(jīng)在集合中了，我們就不返回這個(gè)值。如果不在集合中，就向集合添加這個(gè)元素，并返回這個(gè)值。key 是函數(shù)名，通過修改 key，我們可以改變重復(fù)元素的判斷依據(jù)。比如對(duì)于下面這個(gè)序列：a = [{'a': 6, 'b': 4}, {'a': 6, 'b': 3}, {'a': 6, 'b': 4},{'a': 8, 'b': 12}]list(dedupe(a, lambda x: x['a']))這里我們把 dedupe 設(shè)置為，基于關(guān)鍵字 ‘a(chǎn)’ 對(duì)應(yīng)值去除重復(fù)元素，也就是說集合中添加的元素為關(guān)鍵字 ‘a(chǎn)’ 對(duì)應(yīng)值。輸出為：[{'a': 6, 'b': 4}, {'a': 8, 'b': 12}]list(dedupe(a, lambda x: (x['a'],x['b'])))這里，集合添加的是關(guān)鍵字’a’和’b’對(duì)應(yīng)值的元組。

輸出為：?[{'a': 6, 'b': 4}, {'a': 6, 'b': 3}, {'a': 8, 'b': 12}]

# Python高效編程

def dedupe(sequence, key):

# 依序去除重復(fù)元素

seen = set()

items = sequence[:]

for item in items:

if key:

seq = key(item)

if seq not in seen:

seen.add(seq)

yield item

6. Vector

這一節(jié)，我們來實(shí)現(xiàn)一個(gè)簡(jiǎn)單的 Vector 類。Vector 類有兩個(gè)屬性，為 x，y 坐標(biāo)，即對(duì)應(yīng)向量的橫縱坐標(biāo)。首先，實(shí)現(xiàn)重載 + 號(hào)的方法def __add__，及實(shí)現(xiàn)兩個(gè)向量的加法。具體做法是：將加號(hào)兩邊的 Vector 對(duì)象的 x, y值相加，得到新的 x, y值并且返回一個(gè)新的向量對(duì)象。__sub__方法實(shí)現(xiàn)了 Vector 對(duì)象的減法，和加法差不多。讓向量對(duì)象的對(duì)應(yīng)屬性相減，并返回新的向量對(duì)象。__ads__方法，使得可以對(duì)實(shí)例進(jìn)行 ads操作(即取橫縱坐標(biāo)的模)。__mul__方法，使得實(shí)例可以通過乘法進(jìn)行伸縮的操作。__repr__與__str__方法使得打印對(duì)象更加美觀。

import math

# Python高效編程

class Vector(object):

def __init__(self, x, y):

self.x = x

self.y = y

def __add__(self, other):

x = self.x + other.x

y = self.y + other.y

return Vector(x, y)

def __sub__(self, other):

x = self.x - other.x

y = self.y - other.y

return Vector(x, y)

def __abs__(self):

return math.sqrt(self.x ** 2 + self.y ** 2)

def __bool__(self):

return bool(self.x or self.y)

def __mul__(self, times):

return Vector(self.x * times, self.y * times)

def __repr__(self):

return 'Vector({}, {})'.format(self.x, self.y)

__str__ = __repr__

def main():

v1 = Vector(3, 5)

v2 = Vector(4, 5)

v3 = v1 + v2

v4 = v3 * 2

v5 = v2 - v1

print(v3)

print(v4)

print(abs(v3))

print(v5)

if __name__ == '__main__':

main()

# 輸出：

# Vector(7, 10)

# Vector(14, 20)

# 12.206555615733702

# Vector(1, 0)

7. 具名元組

具名元組(namedtuple) 是 python 標(biāo)準(zhǔn)庫(kù) collections 中的工廠函數(shù)。它接受兩個(gè)參數(shù)，第一個(gè)參數(shù)表示類的名稱，第二個(gè)參數(shù)是類的字段名。后者可以是可迭代對(duì)象，也可以是空格隔開的字符串。然后，我們通過一串參數(shù)的形式將參數(shù)傳遞到構(gòu)造函數(shù)中。這樣，我們既可以通過字段名訪問元素，也可以用索引訪問元素。

from collections import namedtuple

ToDo = namedtuple('ToDo', 'date content priority')

t = ToDo(12, 'null', 1)

print(t.date)

print(t[1])

# 輸出:

# 12

# null

下面是具名元組的演示程序：我們創(chuàng)建了一個(gè) ToDoList 類，并且支持 + 、索引、切片與顯示等操作。并且通過格式化輸出，美化打印結(jié)果。

from collections import namedtuple

ToDo = namedtuple('ToDo', 'date content priority')

class ToDoList:

def __init__(self):

self.item = []

def add(self, date, content, priority):

self.item.append(ToDo(date, content, priority))

def _modify(self, item):

self.item = item

@property

def _getitem(self):

return self.item

def __getitem__(self, pos):

return self.item[pos]

def __add__(self, other):

item = self._getitem + other._getitem

t = ToDoList()

t._modify(item)

return t

def __repr__(self):

items = self._getitem

text = '{:<5}{:^10}{:^10}'.format('date', 'content', 'priority')

fmt = '{:<5}{:^10}{:^10}'

for item in items:

text += '

'

text += fmt.format(item.date, item.content, item.priority)

return text

__str__ = __repr__

def main():

t1 = ToDoList()

t1.add(12, 'play', 0)

t1.add(8, 'seek', 6)

t2 = ToDoList()

t2.add(4, 'sleep', 2)

t3 = t1 + t2

print(t3)

if __name__ == '__main__':

main()

# 輸出

# date content priority

#12 play 0

#8 seek 6

# 4 sleep 2

三、遞歸

1. 階乘

迭代停止條件：n < 2

# 階乘

# n > 0

def factor(n):

return 1 if n < 2 else n * factor(n-1)

2. 序列和

迭代停止條件：序列為空

# 和

def naive_sum(seq):

if not seq:

return 0

else:

return seq[0] + naive_sum(seq[1:])

3. 求序列長(zhǎng)度

迭代停止條件：序列為空

# 計(jì)數(shù)

def naive_count(seq):

if not seq:

return 0

else:

return 1 + naive_count(seq[1:])

4. 求序列最大值

迭代停止條件：序列為空

# 最大值

count = 1

def naive_max(seq):

global count

global max_num

if count:

max_num = seq[0]

count = 0

if not seq:

count = 1

return max_num

else:

if seq[0] > max_num:

seq[0], max_num = max_num, seq[0]

return naive_max(seq[1:])

以上便是本次的全部?jī)?nèi)容，大家可以親自編程練練手

總結(jié)

以上是生活随笔為你收集整理的python中imag用法_花了一晚上时间，终于把Python的基本用法归纳好了！的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。