花了一晚上时间,终于把Python的基本用法归纳好了!

一、内置函数

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

返回一个复数,实部 + 虚部*1j,或者把字符串或者数字转成复数形式。

参数可以是复数表达式,也可以是字符串。当参数是字符串的时候,数字与操作符之间不能有空格。即comple('1 + 2j')是错误的。

print(complex(1, 2))

print(complex(1 + 2j))

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

# 输出 1+2j

print(complex(1))

# 输出 1+0j

满足:实部 + 虚部*1j 的数被称为复数。

a = 1 + 3j

# 求实部

print(a.real)

# 求虚部

print(a.imag)

# 求共轭

print(a.conjugate())

2. chr(i) 与 ord(i)

chr(i) 是将当前整数 i 转成对应的 ascii 字符,可以是十进制,也可以是十六进制,其中0 <= i <= 0x10ffff (1114111)。其对应的逆操作为 ord(i),i 为 ascii 字符。

下面的函数演示如何求一个可迭代对象的 ascil字符 或者其对应的数值。注意函数 ordplus ,参数 x 中的每一个元素必须是单个字符,如果是列表,形式如下:[‘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 对象。迭代对象必须是序列,迭代器,或者其他支持迭代的对象。enmerate() 函数返回的是迭代器,同样是可迭代对象。每次迭代的元素,都包含元素在序列里的序号(strat 默认值为 0) 和元素对应值。因此,我们可以用 for 循环获取返回值。在学习中有迷茫不知如何学习的朋友小编推荐一个学Python的学习q u n 227  -435-  450可以来了解一起进步一起学习!免费分享视频资料

等价于:

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)

返回数的绝对值。参数可以是整数或者浮点数。如果参数是复数,返回复数的模。Python 中虚数用数值加上字符 j 的形式表示。要注意 j 前面的数值不能省略,比如 1j。

下面是我写的简易版的 abs 函数:


from math import sqrt

def naive_abs(x):

# isinstance 判断参数x是否为整数或浮点数

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

if x < 0:

x = - x

# 判断参数x是否为复数

elif isinstance(x, complex):

# x.real 复数的实部

# x.imag 复数的虚部

real = x.real

imag = x.imag

# 求复数的模

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

else :

return '请输入 int float complex'

return x

print(abs(3+4j))

print(naive_abs(3+4j))

# 输出 5.0

print(abs(-6))

print(naive_abs(-6))

# 输出 6

二、算法与数据结构

1. 二分查找

要想使用二分搜索,首先要确保迭代序列是有序的。对于无序序列,我们首先要进行排序操作。

每次循环缩小一半搜索范围,时间复杂度为 O(logn)。每次循环,比较选取的中间数与需要查找的数字,如果待查数小于中间数,就减少右界至中间数的前一个数;如果待查数大于中间数,就增加左界到中间数后一个数;如果待查数等于中间数,返回中间数的下标,该下标即为待查数在序列中的位置。当左界大于右界时,循环结束,说明序列中并没有待查数。

def binary_search(item, find):

# 有序可迭代对象

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. 快速排序

首先要打乱序列顺序 ,以防算法陷入最坏时间复杂度。快速排序使用“分而治之”的方法。对于一串序列,首先从中选取一个数,凡是小于这个数的值就被放在左边一摞,凡是大于这个数的值就被放在右边一摞。然后,继续对左右两摞进行快速排序。直到进行快速排序的序列长度小于 2 (即序列中只有一个值或者空值)。

# 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. 冒泡排序

冒泡排序(顺序形式),从左向右,两两比较,如果左边元素大于右边,就交换两个元素的位置。其中,每一轮排序,序列中最大的元素浮动到最右面。也就是说,每一轮排序,至少确保有一个元素在正确的位置。这样接下来的循环,就不需要考虑已经排好序的元素了,每次内层循环次数都会减一。其中,如果有一轮循环之后,次序并没有交换,这时我们就可以停止循环,得到我们想要的有序序列了。

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. 选择排序

选择排序,每次选择当前序列的最小值,将其与当前序列的第一个元素交换位置,每迭代一次,当前序列长度减一。迭代结束,即可得到有序序列。

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. 去重序列重复元素

首先新建一个集合 set,对于序列中的元素,如果已经在集合中了,我们就不返回这个值。如果不在集合中,就向集合添加这个元素,并返回这个值。key 是函数名,通过修改 key,我们可以改变重复元素的判断依据。比如对于下面这个序列: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 设置为,基于关键字 ‘a’ 对应值去除重复元素,也就是说集合中添加的元素为关键字 ‘a’ 对应值。输出为:[{'a': 6, 'b': 4}, {'a': 8, 'b': 12}]list(dedupe(a, lambda x: (x['a'],x['b'])))这里,集合添加的是关键字’a’和’b’对应值的元组。

输出为: [{'a': 6, 'b': 4}, {'a': 6, 'b': 3}, {'a': 8, 'b': 12}]

# Python高效编程

def dedupe(sequence, key):

# 依序去除重复元素

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

这一节,我们来实现一个简单的 Vector 类。Vector 类有两个属性,为 x,y 坐标,即对应向量的横纵坐标。首先,实现重载 + 号的方法def __add__,及实现两个向量的加法。具体做法是:将加号两边的 Vector 对象的 x, y值相加,得到新的 x, y值并且返回一个新的向量对象。__sub__方法实现了 Vector 对象的减法,和加法差不多。让向量对象的对应属性相减,并返回新的向量对象。__ads__方法,使得可以对实例进行 ads操作(即取横纵坐标的模)。__mul__方法,使得实例可以通过乘法进行伸缩的操作。__repr__与__str__方法使得打印对象更加美观。

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 标准库 collections 中的工厂函数。它接受两个参数,第一个参数表示类的名称,第二个参数是类的字段名。后者可以是可迭代对象,也可以是空格隔开的字符串。然后,我们通过一串参数的形式将参数传递到构造函数中。这样,我们既可以通过字段名访问元素,也可以用索引访问元素。

from collections import namedtuple

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

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

print(t.date)

print(t[1])

# 输出:

# 12

# null

下面是具名元组的演示程序:我们创建了一个 ToDoList 类,并且支持 + 、索引、切片与显示等操作。并且通过格式化输出,美化打印结果。

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. 求序列长度

迭代停止条件:序列为空

# 计数

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:])

以上便是本次的全部内容,大家可以亲自编程练练手

©著作权归作者所有,转载或内容合作请联系作者
  • 序言:七十年代末,一起剥皮案震惊了整个滨河市,随后出现的几起案子,更是在滨河造成了极大的恐慌,老刑警刘岩,带你破解...
    沈念sama阅读 151,511评论 1 330
  • 序言:滨河连续发生了三起死亡事件,死亡现场离奇诡异,居然都是意外死亡,警方通过查阅死者的电脑和手机,发现死者居然都...
    沈念sama阅读 64,495评论 1 273
  • 文/潘晓璐 我一进店门,熙熙楼的掌柜王于贵愁眉苦脸地迎上来,“玉大人,你说我怎么就摊上这事。” “怎么了?”我有些...
    开封第一讲书人阅读 101,595评论 0 225
  • 文/不坏的土叔 我叫张陵,是天一观的道长。 经常有香客问我,道长,这世上最难降的妖魔是什么? 我笑而不...
    开封第一讲书人阅读 42,558评论 0 190
  • 正文 为了忘掉前任,我火速办了婚礼,结果婚礼上,老公的妹妹穿的比我还像新娘。我一直安慰自己,他们只是感情好,可当我...
    茶点故事阅读 50,715评论 3 270
  • 文/花漫 我一把揭开白布。 她就那样静静地躺着,像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上,一...
    开封第一讲书人阅读 39,672评论 1 192
  • 那天,我揣着相机与录音,去河边找鬼。 笑死,一个胖子当着我的面吹牛,可吹牛的内容都是我干的。 我是一名探鬼主播,决...
    沈念sama阅读 31,112评论 2 291
  • 文/苍兰香墨 我猛地睁开眼,长吁一口气:“原来是场噩梦啊……” “哼!你这毒妇竟也来了?” 一声冷哼从身侧响起,我...
    开封第一讲书人阅读 29,837评论 0 181
  • 序言:老挝万荣一对情侣失踪,失踪者是张志新(化名)和其女友刘颖,没想到半个月后,有当地人在树林里发现了一具尸体,经...
    沈念sama阅读 33,417评论 0 228
  • 正文 独居荒郊野岭守林人离奇死亡,尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 29,928评论 2 232
  • 正文 我和宋清朗相恋三年,在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 31,316评论 1 242
  • 序言:一个原本活蹦乱跳的男人离奇死亡,死状恐怖,灵堂内的尸体忽然破棺而出,到底是诈尸还是另有隐情,我是刑警宁泽,带...
    沈念sama阅读 27,773评论 2 234
  • 正文 年R本政府宣布,位于F岛的核电站,受9级特大地震影响,放射性物质发生泄漏。R本人自食恶果不足惜,却给世界环境...
    茶点故事阅读 32,253评论 3 220
  • 文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹,春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 25,827评论 0 8
  • 文/苍兰香墨 我抬头看了看天上的太阳。三九已至,却和暖如春,着一层夹袄步出监牢的瞬间,已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 26,440评论 0 180
  • 我被黑心中介骗来泰国打工, 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留,地道东北人。 一个月前我还...
    沈念sama阅读 34,523评论 2 249
  • 正文 我出身青楼,却偏偏与公主长得像,于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子,可洞房花烛夜当晚...
    茶点故事阅读 34,583评论 2 249

推荐阅读更多精彩内容