花了一晚上时间，终于把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 循环获取返回值。
等价于：
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__方法使得打印对象更加美观。最后，如果你的时间不是很紧张，并且又想快速的python提高，最重要的是不怕吃苦，建议你可以架微♥信：762459510 ，那个真的很不错，很多人进步都很快，需要你不怕吃苦哦！大家可以去添加上看一下~
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:])
以上便是本次的全部内容，大家可以亲自编程练练手
小编整理了一套2021最新的Python学习资料，需要的按以下步骤领取！
1、评论
2、转发
3、关注
**4、需要Python学习资料可以76 年 24 月 59号考试510分 去掉文字加我的伪 ，资料免费赠予大家！（书籍太多，我就随便发一点咯！）**
花了一晚上时间，终于把Python的基本用法归纳好了相关推荐
- 花了一晚上时间，终于把Python的基本用法归纳好了！
一.内置函数 1. complex([real[,imag]]) 返回一个复数,实部 + 虚部*1j,或者把字符串或者数字转成复数形式. 参数可以是复数表达式,也可以是字符串.当参数是字符串的时候,数 ...
- python中imag用法_花了一晚上时间，终于把Python的基本用法归纳好了！
一.内置函数 1. complex([real[,imag]]) 返回一个复数,实部 + 虚部*1j,或者把字符串或者数字转成复数形式. 参数可以是复数表达式,也可以是字符串.当参数是字符串的时候,数 ...
- python flag用法_花了一晚上时间，终于把Python的基本用法归纳好了！
一.内置函数 1. complex([real[,imag]]) 返回一个复数,实部 + 虚部*1j,或者把字符串或者数字转成复数形式. 参数可以是复数表达式,也可以是字符串.当参数是字符串的时候,数 ...
- 获取两个时间之间的间隔_花了两天，终于把 Python 的时间转化给整明白了（超多图解）...
来源:Python编程时光(未经授权不得私自转载) Python 的时间转化,我相信是很多开发者的痛.学得慢,忘得快,一到要用就去百度,效率太低.建议收藏这些文章(但也别忘了点赞呐,求你了),需要的时 ...
- 花了两天，终于把 Python 的 setup.py 给整明白了
作者 | 写代码的明哥 来源 | Python编程时光 头图 | 下载于视觉中国 为什么需要对项目分发打包 平常我们习惯了使用 pip 来安装一些第三方模块,这个安装过程之所以简单,是因为模块开发者为 ...
- python中setup_花了两天，终于把 Python 的 setup.py 给整明白了
给大家推荐本我自己写的电子书<PyCharm中文指南>,把各种 PyCharm 的高效的使用技巧用GIF动态图的形式展示出来.有兴趣的可以看它的在线文档:PyCharm 中文指南 2.0 ...
- 清华教授花一个月把Python所有基本用法归纳好了！末有惊喜
废话不多写,直接开始内容. 一.内置函数 1. complex([real[,imag]]) 返回一个复数,实部 + 虚部*1j,或者把字符串或者数字转成复数形式. 参数可以是复数表达式,也可以是字符 ...
- 花了几天时间，总结了一份Python工程师的职业成长路径图
近几年,Python 的受欢迎程度可谓是扶摇直上,加入 Python 学习大营的人越来越多.不过,随之而来的是,竞争越来越激烈.迷茫的声音也越来越多,我经常看到粉丝在后台留言: Python程序员都有 ...
- 今天花了好长的时间终于把SecureCRT安装成功了 现在分享给大家 安装的步骤, 希望对大家用帮助...
转载地址:https://www.cnblogs.com/lianghe01/p/6618651.html 今天花了好长的时间终于把SecureCRT安装成功了 现在分享给大家 安装的步骤, 希望对大 ...
最新文章
- java 算法笔试题_【干货】经典算法面试题代码实现-Java版
- 在eclipse中使用svn
- 推荐一个不到300k的Gif处理神器 - Gifsicle（免费下载）
- rust怎么不要的墙拆掉_封阳台，栏杆要不要拆掉？栏杆装在玻璃窗里面还是外面...
- Hadoop（5）-Hive
- pandas和spark的区别
- Linux内核0.12完全注释
- JDK可视化工具 | JConsole操作指南，手把手教会你
- Linux内核源代码分析——Linux内核的入口
- [转载] numpy教程：排序、搜索和计数
- RocketMQ消费端消息回退（消费重试）机制源码解析
- 常用算法案例之贪心法（C语言）
- Inter core i7处理器中(x86架构)驱动开发：关于APCI Hardware ID的描述
- 影视APP下载页面html源码
- 关于Ubuntu双击打不开文件夹的解决方案
- 某些特殊悼念日的时候，让个人网页风格变黑灰色
- Python爬取自然风景图片代码
- Java通过axis调用WebService
- python 操作ps脚本_python – 有没有办法以编程方式获得ps输出？
- 继承 inherit