本文是我在学习期间的笔记,看的书是《python语言及其应用》。
转载请注明出处,谢谢。
本文链接 https://blog.csdn.net/Ming2017123123/article/details/98378499
dir
a = [1 ,2]
print(dir(a))
print(dir(a)[-12:])
动态获取属性 Type.FTE 的值
getattr(Type,‘FTE’)
Type._dict__[‘FTE’]
配合inspect 使用
import inspect
print([i for i in dir(list) if inspect.isbuiltin(getattr(list, i))])
print([i for i in dir(inspect) if inspect.isfunction(getattr(inspect,i))])
print([i for i in dir(inspect) if not callable(getattr(inspect, i))])
print(list.__dict__.keys())
创建整数列表(导致“TypeError: ‘range’ object does not support item assignment”)有时你想要得到一个有序的整数列表, 所以range() 看上去是生成此列表的不错方式。然而,range() 返回的是“range object”,而不是实际的list 值。
a = range(5)
# a = [ i ** 2 for i in a ]
for i in a:
a[i] = a[i] - 5
print(a)
Traceback (most recent call last): File “”, line 4, in TypeError: ‘range’ object does not support item assignment
a = range(0,N)改为a = list(range(0,N))
pip list
使用“/”运算符时,只要有一个操作数是浮点数,那么产生的结果就是浮点数结果
"//"的结果都是整除,如果操作数是浮点数的话,返回一个整除结果转换成浮点数
// x与y之整数商,即:不大于 x 与 y 之商的最大整数
print(20/2)
print(20/3)
print(20.0/3)
print(20/3.0)
print(20.0/3.0)
print(20//3)
print(20.0 // 3)
print(20 // 3.0)
print(20.0 // 3.0)
print(2 * 10)
print(2 ** 10)
print(pow(2,10))
print(pow(3.14,10))
python中的字符数字之间的转换函数 int(x [,base ]) 将x转换为一个整数 long(x [,base ]) 将x转换为一个长整数 float(x ) 将x转换到一个浮点数 complex(real [,imag ]) 创建一个复数 str(x ) 将对象 x 转换为字符串 repr(x ) 将对象 x 转换为表达式字符串 eval(str ) 用来计算在字符串中的有效Python表达式,并返回一个对象 tuple(s ) 将序列 s 转换为一个元组 list(s ) 将序列 s 转换为一个列表 chr(x ) 将一个整数转换为一个字符 unichr(x ) 将一个整数转换为Unicode字符 ord(x ) 将一个字符转换为它的整数值 hex(x ) 将一个整数转换为一个十六进制字符串 oct(x ) 将一个整数转换为一个八进制字符串
chr(65)=‘A’ ord(‘A’)=65
int(‘2’)=2; str(2)=‘2’
原文链接
https://www.cnblogs.com/wuxiangli/p/6046800.html
数字转换为字符
print(type("%d" % 12))
原文连接
https://www.cnblogs.com/zmlctt/p/4234257.html
abs(x)
print(abs(-128))
divmod(a,b)
divmod(42,5)
pow(x,y) pow(x,y,z)
print(pow(2,10))
print(pow(2,10,100))
round(x) round(x,d)
import math
print(math.pi)
print(round(math.pi))
print(round(math.pi,3))
max(x1,x2,…xn) min(x1,x2,…xn)
print(max(1, 2, 3, 4.55, 745, 23987))
print(min(1, 2, 3, 4.55, 745, 23987))
模块属性
模块属性_name__,它的值由Python解释器设定。
如果脚本文件是作为主程序调用,其值就设为_main__,
如果是作为模块被其他文件导入,它的值就是其文件名。
print(__name__)
import numpy
print(numpy.__name__)
每个模块都有自己的私有符号表,所有定义在模块里面的函数把它当做全局符号表使用。
模块可以导入其他的模块。通常将import语句放在模块的开头,被导入的模块名字放在导入它的模块的符号表中。
可以直接从模块中导入名字到符号表,但模块名字不会被导入。
可以把模块中的所有名字全部导入,除了那些以下划线开头的名字符号。不建议使用,不清楚导入了什么符号,有可能覆盖自己定义的东西
模块搜索路径
sys.path的初始值来自于以下地方:
sys.path初始化完成之后可以更改
import sys
for i in sys.path:
print(i)
什么是pyc文件呢?
pyc文件就是Python的字节码文件,Python是一种全平台的解释性语言, 全平台其实就是Python文件在经过解释器解释之后(或者称为编译)生成的pyc文件可以在多个平台下运行,这样同样也可以隐藏源代码。 其实,Python是完全面向对象的语言,Python文件在经过解释器解释后生成字节码对象PyCodeObject,pyc文件可以理解为是PyCodeObject对象的持久化保存方式。
什么时候会生成pyc文件呢?
pyc文件只有在文件被当成模块导入时才会生成。 也就是说,Python解释器认为,只有import进行的模块才需要被重用。 生成pyc文件的好处显而易见,当我们多次运行程序时,不需要重新对该模块进行重新的解释。 主文件一般只需要加载一次不会被其他模块导入,所以一般主文件不会生成pyc文件。
pyc文件的过期时间
在生成pyc文件的同时,写入了一个Long型的变量,用于记录最近修改的时间; 每次载入之前都先检查一下py文件和pyc文件的最后修改日期,如果不一致则会生成一个新的pyc文件
原文连接
https://www.jianshu.com/p/40a42bf1d15d
pydoc
help()
Cython
Shed Skin
Pythran
Numba
PyPy
Python有一套很有用的标准库(standard library)。 标准库会随着Python解释器,一起安装在你的电脑中的。 它是Python的一个组成部分。这些标准库是Python为你准备好的利器,可以让编程事半功倍。
文字处理
数据对象
管理时间和日期
Python运行控制
操作系统
线程与进程
基于socket层的网络应用
比如说将socket赋予给某个端口(port),连接远程端口,以及通过连接传输数据。 也可以利用SocketServer包更方便地建立服务器。
+通过asyncore包实现异步处理,也是改善服务器性能的一个方案。
互联网应用
(URL实际上说明了网络资源所在的位置)进行理解和操作。
原文链接
https://www.cnblogs.com/vamei/archive/2012/07/18/2597212.html#2927936
列表是动态的数组
元组是静态的数组
元组缓存于python运行时环境,每次使用元组时无须访问内核去分配内存
元组用于描述一个不会改变的事物的多个属性,而列表可被用于保存多个互相独立对性的数据集合
列表和元组都支持混合类型
通用代码会比某个特定问题设计的代码慢很多
高效搜索所必须的是*排序算法*和*搜索算法*
def binary_search(needle, haystack):
imin, imax = 0, len(haystack)
while(True):
if imin >= imax:
return -1
midpoint = (imax + imin) // 2
if haystack[midpoint] > needle:
imax = midpoint
elif haystack[midpoint] < needle:
imin = midpoint + 1
else:
return midpoint
a = [2, 4, 34, 563, 23, 12]
a.sort()
num = 23
ind = binary_search(num, a)
print("a = ",a)
print("Search : ", num," in a[", ind,"]")
import bisect
import random
def find_closest(haystack, needle):
i = bisect.bisect_left(haystack, needle)
if i == len(haystack):
return i - 1
elif haystack[i] == needle:
return i
elif i > 0:
j = i - 1
if haystack[i] - needle > needle - haystack[j]:
return j
return i
important_numbers = []
for i in range(10):
new_number = random.randint(0, 1000)
bisect.insort(important_numbers, new_number)
print("important_numbers : ", important_numbers)
closest_index = find_closest(important_numbers, -250)
print("Closest value to -250: ", important_numbers[closest_index]," index : ",closest_index)
closest_index = find_closest(important_numbers, 500)
print("Closest value to 500: ", important_numbers[closest_index]," index : ",closest_index)
closest_index = find_closest(important_numbers, 1000)
print("Closest value to 1000: ", important_numbers[closest_index]," index : ",closest_index)
num = [5, 8, 2, 1, 0, 19]
num[3] = 8 * num[0]
print("numbers = ", num)
print("len(numbers) = ",len(num))
num.append(42)
print("numbers = ", num)
print("len(numbers) = ",len(num))
t = (1, 5, 6, 9)
t[0] = 9
t1 = (1, 2, 4, 6)
t2 = (6, 7, 8, 3)
print("t1 + t2 = ", t1 + t2)
import time
t1 = time.time()
l = [0,1,2,3,4,5,6,7,8,9]
t2 = time.time()
t = (0,1,2,3,4,5,6,7,8,9)
t3 = time.time()
print("list cost : ",t2 - t1," tuple cost : ",t3 - t2)
print("list : ",l," tuple : ",t)
print("times : ", (t2 - t1) / (t3 - t2))
字典和集合十分依赖他们的散列函数
适合用于存储能够被键索引的程序
列表查询电话薄
def find_phonenumber(phonebook, name):
for n,p in phonebook:
if n == name:
return p
return None
phonebook = {("John","555-555-2222"),("Albert Einstein", "212-555-5555")}
print("John's phone number is ",find_phonenumber(phonebook,"John"))
phonebook2 = {"John":"555-555-2222","Albert Einstein":"212-555-5555"}
print("John's phone number is ",phonebook2["John"])
def list_unique_names(phonebook):
unique_names = []
for name, phonenumber in phonebook:
first_name, last_name = name.split(' ', 1)
for unique in unique_names:
if unique == first_name:
break
unique_names.append(first_name)
print("list: unique_names : ",unique_names)
return len(unique_names)
def set_unique_names(phonebook):
unique_names = set()
for name, phonenumber in phonebook:
first_name, last_name = name.split(' ',1)
unique_names.add(first_name)
return len(unique_names)
phonebook = [
("Jhon Doe","555-555-5555"),
("Albert Einstein", "212-555-5555"),
("Jhon Murphey","202-555-5555"),
("Elaine Bodian","301-555-5555")]
print("Number of unique names from set method: ", set_unique_names(phonebook))
print("Number of unique names from list method: ", list_unique_names(phonebook))
def index_sequence(key, mask=0b111, PERTURB_SHIFT = 5):
perturb = hash(key)
i = perturb & mask
yield i
while True:
i = ((i << 2) + i + perturb + 1)
perturb >>= PERTURB_SHIFT
yield i & mask
class City(str):
def __hash__(self):
return ord(self[0])
data = {
City("Rome"): 4,
City("San Francisco"): 3,
City("New York"): 5,
City("Barcelona"): 2
}
删除
改变大小
散列函数和熵
def twoletter_hash(key):
offset = ord('a')
k1, k2 = key
return (ord(k2) - offset) + 26 * (ord(k1) - offset)
import string
import timeit
class BadHash(str):
def __hash__(self):
return 42
class GoodHash(str):
def __hash__(self):
return ord(self[1]) + 26 * ord(self[0]) - 2619
baddict = set()
gooddict = set()
for i in string.ascii_lowercase:
for j in string.ascii_lowercase:
key = i + j
baddict.add(BadHash(key))
gooddict.add(GoodHash(key))
print("baddict : ", len(baddict))
print("gooddict : ", len(gooddict))
# badtime = timeit.repeat(
# "key in baddict",
# setup = "form __main__ import baddict, BadHash; key = BadHash('zz')",
# repeat = 3,
# number = 1000000,
# )
# goodtime = timeit.repeat(
# "key in gooddict",
# setup = "form __main__ import gooddict, GoodHash; key = GoodHash('zz')",
# repeat = 3,
# number = 1000000,
# )
# print("Min look up for baddict: ", min(badtime))
# print("Min look up for gooddict: ", min(goodtime))
字典和命名空间
当python访问一个变量或者函数或模块时,都有一个体系来决定它去那里查找这些对象
命名空间查询
import dis
import math
from math import sin
def test1(x):
return math.sin(x)
def test2(x):
return sin(x)
def test3(x, sin = math.sin):
return sin(x)
print("dis.dis(test1) : ")
dis.dis(test1)
print("dis.dis(test2) : ")
dis.dis(test2)
print("dis.dis(test3) : ")
dis.dis(test3)
循环内命名空间查询的降速效果
import time
from math import sin
def tight_loop_slow(iterations):
result = 0
for i in range(iterations):
result += sin(i)
return result
def tight_loop_fast(iterations):
result = 0
local_sin = sin
for i in range(iterations):
result += local_sin(i)
return result
l = 10000000 # 千万
t1 = time.time()
res1 = tight_loop_fast(l)
t2 = time.time()
res2 = tight_loop_slow(l)
t3 = time.time()
fast_time = t2 - t1
low_time = t3 - t2
print("result : ", res1, "tight_loop_fast: ",t2 - t1)
print("result : ", res2, "tight_loop_slow: ",t3 - t2)
print("times : slow / fast : ", (t3 - t2) / ( t2 - t1))
print("fast : ",round((low_time - fast_time) / low_time * 100,2), "%")