技术标签: python基础知识
长整型(long integers) - 无限大小的整数,整数最后是一个大写或小写的L。Python3 整型是没有限制大小的,可以当作 Long 类型使用,所以 Python3 没有 Python2 的 Long 类型
在32位机器上,整数的位数为32位,取值范围为-231~231-1,即-2147483648~2147483647
在64位系统上,整数的位数为64位,取值范围为-263~263-1,-9223372036854775808~9223372036854775807
var1 = 1
var2 = 10
var3 = 6
del语句删除一些 Number 对象引用
del var1
del var2, var3
跟C语言不同,Python的长整数没有指定位宽,即:Python没有限制长整数数值的大小,但实际上由于机器内存有限,我们使用的长整数数值不可能无限大。
注意,自从Python2.2起,如果整数发生溢出,Python会自动将整数数据转换为长整数,所以如今在长整数数据后面不加字母L也不会导致严重后果了。
199**200
5896784843701866315830202306247774762972638982405042480372238189012365044783448228280875028875684277127088378956152713197320945688565673304729984010537727226637040943165593052367979000124463424161858464934947067680269075228341562695042312463815883441507512003942871781958205145461989665812045325106145074842960481661294209203262577314061569045152694421556602495323466256365196176516277494056642637786305854049111948156579863012416891273717889898672613595960001
浮点数也就是小数,之所以称为浮点数,是因为按照科学记数法表示时,一个浮点数的小数点位置是可变的,比如,1.23x109和12.3x108是完全相等的。浮点数可以用数学写法,如1.23,3.14,-9.01,等等。但是对于很大或很小的浮点数,就必须用科学计数法表示,把10用e替代,1.23x109就是1.23e9,或者12.3e8,0.000012可以写成1.2e-5,等等。
整数和浮点数在计算机内部存储的方式是不同的,整数运算永远是精确的(除法难道也是精确的?是的!),而浮点数运算则可能会有四舍五入的误差。
0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1
0.7999999999999999
复数是指能写成如下形式的数a+bi,这里a和b是实数,i是虚数单位(即-1开根)。在复数a+bi中,a称为复数的实部,b称为复数的虚部,i称为虚数单位。当虚部等于零时,这个复数就是实数;当虚部不等于零时,这个复数称为虚数
#复数由实数部分和虚数部分构成,可以用a + bj,或者complex(a,b)表示, 复数的实部a和虚部b都是浮点型
complex(1,5)
(1+5j)
有理数
数学上,有理数是一个整数a和一个非零整数b的比,例如3/8,通则为a/b,又称作分数。0也是有理数。有理数是整数和分数的集合,整数也可看做是分母为一的分数。有理数的小数部分是有限或为无限循环的数。不是有理数的实数称为无理数,即无理数的小数部分是无限不循环的数。
无理数
无理数,也称为无限不循环小数,不能写作两整数之比。若将它写成小数形式,小数点之后的数字有无限多个,并且不会循环。 常见的无理数有非完全平方数的平方根、圆周率(Pi)和e
实数
实数,是有理数(有限或为无限循环的数)和无理数(无限不循环小数)的总称。
科学记数法
把一个绝对值大于10的实数记为a×10n的形式(1≤|a|<10,n为整数),这种记数法叫做科学记数法。这是一种记数的方法。例如19971400000000=1.99714×10^13。计算器或电脑表达10的的幂是一般是用E或e,也就是1.99714E13=19971400000000
r = bin(10)
print('将整数10转换为二进制字符串:%s'%r)
c = chr(66)
print('整数66对应的ASCII字符:%s'%c)
i = ord("t")
print('字符t转换对应的整数%s'%i)
r= int(12.0)
print("浮点数12.0转换为整数%s"%r)
print("浮点数12.0转换为整数%d"%r)
print("将0xb用十进制数表示%s"%int("0xb",16))
print("将八进制10用十进制数表示%s"%int("10",8))
print("将字符10用十进制数表示%s"%int("10",16))
print("将字符10用十进制数表示%s"%int("10",10))
a = 1.524464444444444444
b = float('%.4f'%a)
print("控制精度,保留4位小数,结果为:%s"%b)
print('字符37.21转换为浮点数:%s'%float('37.21'))
print('整数234转换为浮点数:%s'%float(234))
print('整数234转换为字符:%s'%str(234))
将整数10转换为二进制字符串:0b1010
整数66对应的ASCII字符:B
字符t转换对应的整数116
浮点数12.0转换为整数12
浮点数12.0转换为整数12
将0xb用十进制数表示11
将八进制10用十进制数表示8
将字符10用十进制数表示16
将字符10用十进制数表示10
控制精度,保留4位小数,结果为:1.5245
字符37.21转换为浮点数:37.21
整数234转换为浮点数:234.0
整数234转换为字符:234
print("将整数12转换为十六进制为%s"%hex(2))
print("将整数12转换为八进制为%s"%oct(12))
print("将0xb用十进制数表示%s"%int("82d1",16))
将整数12转换为十六进制为0x2
将整数12转换为八进制为0o14
将0xb用十进制数表示33489
#函数type(),直接给出数的数据类型
print(type(12.0))
print(type(False))
print(type(1000))
<class 'float'>
<class 'bool'>
<class 'int'>
#函数isinstance()需要给出需要判断的数和一个数据类型
print(isinstance('I love u',float))
print(isinstance('I love u',str))
False
True
isinstance 和 type 的区别在于:
class A:
pass
class B(A):
pass
print(isinstance(A(), A))
print(type(A()) == A )
print(isinstance(B(), A))
print(type(B()) == A)
print(type(A()))
print(type(B()))
print(type(A()))
print(type(B()))
True
True
True
False
<class '__main__.A'>
<class '__main__.B'>
<class '__main__.A'>
<class '__main__.B'>
Python 中数学运算常用的函数基本都在 math 模块、cmath 模块中。
Python math 模块提供了许多对浮点数的数学运算函数。
Python cmath 模块包含了一些用于复数运算的函数。
cmath 模块的函数跟 math 模块函数基本一致,区别是 cmath 模块运算的是复数,math 模块运算的是数学运算。
import math
# 查看 math 查看包中的内容:
# dir(math)
函数 | 返回值 ( 描述 ) |
---|---|
abs(x) | 返回数字的绝对值,如abs(-10) 返回 10 |
ceil(x) | 返回数字的上入整数,如math.ceil(4.1) 返回 5 |
cmp(x, y) | 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1(python3中不存在) |
exp(x) | 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045 |
fabs(x) | 返回数字的绝对值,如math.fabs(-10) 返回10.0 |
floor(x) | 返回数字的下舍整数,如math.floor(4.9)返回 4 |
log(x) | 如math.log(math.e)返回1.0,math.log(100,10)返回2.0 |
log10(x) | 返回以10为基数的x的对数,如math.log10(100)返回 2.0 |
max(x1, x2,…) | 返回给定参数的最大值,参数可以为序列。 |
min(x1, x2,…) | 返回给定参数的最小值,参数可以为序列。 |
modf(x) | 返回x的整数部分与小数部分,两部分的数值符号与x相同,整数部分以浮点型表示。 |
pow(x, y) | x**y 运算后的值。 |
round(x [,n]) | 返回浮点数x的四舍五入值,如给出n值,则代表舍入到小数点后的位数。 |
sqrt(x) | 返回数字x的平方根 |
print("abs(-45) : ", abs(-45))
print("abs(100.12) : ", abs(100.12))
print("abs(119) : ", abs(119))
abs(-45) : 45
abs(100.12) : 100.12
abs(119) : 119
import math # This will import math module
print("math.ceil(-45.17) : ", math.ceil(-45.17))
print("math.ceil(100.12) : ", math.ceil(100.12))
print("math.ceil(100.72) : ", math.ceil(100.72))
print("math.ceil(119) : ", math.ceil(119))
print("math.ceil(math.pi) : ", math.ceil(math.pi))
math.ceil(-45.17) : -45
math.ceil(100.12) : 101
math.ceil(100.72) : 101
math.ceil(119) : 119
math.ceil(math.pi) : 4
Python 3.X 的版本中已经没有 cmp 函数,如果你需要实现比较功能,需要引入 operator 模块,适合任何对象,包含的方法有:
#print("cmp(80, 100) : ", cmp(80, 100))
import operator
print(operator.eq('hello', 'name'))
print(operator.lt(80,100))
print(operator.__lt__(80,100))
False
True
True
import math # 导入 math 模块
print ("math.exp(-45.17) : ", math.exp(-45.17))
print ("math.exp(100.12) : ", math.exp(100.12))
print ("math.exp(100.72) : ", math.exp(100.72))
print ("math.exp(math.pi) : ", math.exp(math.pi))
math.exp(-45.17) : 2.4150062132629406e-20
math.exp(100.12) : 3.0308436140742566e+43
math.exp(100.72) : 5.522557130248187e+43
math.exp(math.pi) : 23.140692632779267
fabs() 函数类似于 abs() 函数,但是他有两点区别:
import math
print ("math.fabs(-45.17) : ", math.fabs(-45.17))
print ("math.fabs(100.12) : ", math.fabs(100.12))
print ("math.fabs(100.72) : ", math.fabs(100.72))
print ("math.fabs(math.pi) : ", math.fabs(math.pi))
math.fabs(-45.17) : 45.17
math.fabs(100.12) : 100.12
math.fabs(100.72) : 100.72
math.fabs(math.pi) : 3.141592653589793
import math
print ("math.floor(-45.17) : ", math.floor(-45.17))
print ("math.floor(100.12) : ", math.floor(100.12))
print ("math.floor(100.72) : ", math.floor(100.72))
print ("math.floor(math.pi) : ", math.floor(math.pi))
math.floor(-45.17) : -46
math.floor(100.12) : 100
math.floor(100.72) : 100
math.floor(math.pi) : 3
import math
print ("math.log(100.12) : ", math.log(100.12))
print ("math.log(100.72) : ", math.log(100.72))
print ("math.log(math.pi) : ", math.log(math.pi))
math.exp(math.log(100.12))
math.log(100.12) : 4.6063694665635735
math.log(100.72) : 4.612344389736092
math.log(math.pi) : 1.1447298858494002
100.12
import math
print ("math.log10(100.12) : ", math.log10(100.12))
print ("math.log10(100.72) : ", math.log10(100.72))
print ("math.log10(119) : ", math.log10(119))
print ("math.log10(math.pi) : ", math.log10(math.pi))
math.log10(100.12) : 2.0005208409361854
math.log10(100.72) : 2.003115717099806
math.log10(119) : 2.075546961392531
math.log10(math.pi) : 0.4971498726941338
print ("max(80, 100, 1000) : ", max(80, 100, 1000))
print ("max([80, 100, 1000]) : ", max([80, 100, 1000]))
print ("max(-20, 100, 400) : ", max(-20, 100, 400))
print ("max(-80, -20, -10) : ", max(-80, -20, -10))
print ("max(0, 100, -400) : ", max(0, 100, -400))
max(80, 100, 1000) : 1000
max([80, 100, 1000]) : 1000
max(-20, 100, 400) : 400
max(-80, -20, -10) : -10
max(0, 100, -400) : 100
print ("min(80, 100, 1000) : ", min(80, 100, 1000))
print ("min(-20, 100, 400) : ", min(-20, 100, 400))
print ("min(-80, -20, -10) : ", min(-80, -20, -10))
print ("min(0, 100, -400) : ", min(0, 100, -400))
min(80, 100, 1000) : 80
min(-20, 100, 400) : -20
min(-80, -20, -10) : -80
min(0, 100, -400) : -400
import math
print ("math.modf(100.12) : ", math.modf(100.12))
print ("math.modf(100.72) : ", math.modf(100.72))
print ("math.modf(119) : ", math.modf(119))
print ("math.modf(math.pi) : ", math.modf(math.pi))
math.modf(100.12) : (0.12000000000000455, 100.0)
math.modf(100.72) : (0.7199999999999989, 100.0)
math.modf(119) : (0.0, 119.0)
math.modf(math.pi) : (0.14159265358979312, 3.0)
pow() 通过内置的方法直接调用,内置方法会把参数作为整型,而 math 模块则会把参数转换为 float
import math
print ("math.pow(100, 2) : ", math.pow(100, 2))
print("使用内置,查看输出结果区别")
print ("pow(100, 2) : ", pow(100, 2))
print ("math.pow(100, -2) : ", math.pow(100, -2))
print ("math.pow(2, 4) : ", math.pow(2, 4))
print ("math.pow(3, 0) : ", math.pow(3, 0))
math.pow(100, 2) : 10000.0
使用内置,查看输出结果区别
pow(100, 2) : 10000
math.pow(100, -2) : 0.0001
math.pow(2, 4) : 16.0
math.pow(3, 0) : 1.0
print ("round(70.23456) : ", round(70.23456))
print ("round(56.659,1) : ", round(56.659,1))
print ("round(80.264, 2) : ", round(80.264, 2))
print ("round(100.000056, 3) : ", round(100.000056, 3))
print ("round(-100.000056, 3) : ", round(-100.000056, 3))
round(70.23456) : 70
round(56.659,1) : 56.7
round(80.264, 2) : 80.26
round(100.000056, 3) : 100.0
round(-100.000056, 3) : -100.0
import math
print ("math.sqrt(100) : ", math.sqrt(100))
print ("math.sqrt(7) : ", math.sqrt(7))
print ("math.sqrt(math.pi) : ", math.sqrt(math.pi))
math.sqrt(100) : 10.0
math.sqrt(7) : 2.6457513110645907
math.sqrt(math.pi) : 1.7724538509055159
随机数可以用于数学,游戏,安全等领域中,还经常被嵌入到算法中,用以提高算法效率,并提高程序的安全性
函数 | 描述 |
---|---|
choice(seq) | 从序列的元素中随机挑选一个元素,比如random.choice(range(10)),从0到9中随机挑选一个整数。 |
randrange | ([start,] stop [,step]) 从指定范围内,按指定基数递增的集合中获取一个随机数,基数缺省值为1 |
random() | 生成一个0到1的随机浮点数,0<=n<1.0 |
seed([x]) | 改变随机数生成器的种子seed。如果你不了解其原理,你不必特别去设定seed,Python会帮你选择seed |
shuffle(lst) | 将序列的所有元素随机排序 |
uniform(x, y) | 生成一个指定范围的随机浮点数,它在[x,y]范围内 |
randint(x, y) | 生成一个指定范围内的整数,它在[x,y]范围内 |
sample | 从指定序列中随机获取指定长度的片断 |
import random
print ("从 range(100) 返回一个随机数 : ",random.choice(range(100)))
print ("从列表中 [1, 2, 3, 5, 9]) 返回一个随机元素 : ", random.choice([1, 2, 3, 5, 9]))
print ("从字符串中 'Runoob' 返回一个随机字符 : ", random.choice('Runoob'))
从 range(100) 返回一个随机数 : 28
从列表中 [1, 2, 3, 5, 9]) 返回一个随机元素 : 5
从字符串中 'Runoob' 返回一个随机字符 : n
import random
# 从 1-100 中选取一个奇数
print ("randrange(1,100, 2) : ", random.randrange(1, 100, 2))
# 从 0-99 选取一个随机数
print ("randrange(100) : ", random.randrange(100))
#从[10,12,14,16,...,96,98]序列中获取一个随机数
print("random.randrange(10,100,2):",random.randrange(10,100,2))
randrange(1,100, 2) : 25
randrange(100) : 7
random.randrange(10,100,2): 62
import random
# 第一个随机数
print ("random() : ", random.random())
# 第二个随机数
print ("random() : ", random.random())
# 实现 100-120 随机小数
print((random.random()*20)+100)
random() : 0.1605165979964044
random() : 0.4380019858706685
115.4696868547905
import random
random.seed()
print ("使用默认种子生成随机数:", random.random())
random.seed()
print ("使用默认种子生成随机数:", random.random())
random.seed(10)
print ("使用整数种子生成随机数:", random.random())
random.seed(10)
print ("使用整数种子生成随机数:", random.random())
random.seed(10)
print ("使用整数种子生成随机数:", random.random())
random.seed("hello",2)
print ("使用字符串种子生成随机数:", random.random())
random.seed("hello",2)
print ("使用字符串种子生成随机数:", random.random())
使用默认种子生成随机数: 0.25150521765106926
使用默认种子生成随机数: 0.5832851080848803
使用整数种子生成随机数: 0.5714025946899135
使用整数种子生成随机数: 0.5714025946899135
使用整数种子生成随机数: 0.5714025946899135
使用字符串种子生成随机数: 0.3537754404730722
使用字符串种子生成随机数: 0.3537754404730722
import random
list = [20, 16, 10, 5];
random.shuffle(list)
print ("随机排序列表 : ", list)
random.shuffle(list)
print ("随机排序列表 : ", list)
随机排序列表 : [10, 16, 5, 20]
随机排序列表 : [20, 16, 5, 10]
import random
print ("uniform(5, 10) 的随机浮点数 : ", random.uniform(5, 10))
print ("uniform(7, 14) 的随机浮点数 : ", random.uniform(7, 14))
uniform(5, 10) 的随机浮点数 : 8.32548129941273
uniform(7, 14) 的随机浮点数 : 11.50216637642797
#从指定序列中随机获取指定长度的片断
list2 = [i**2 for i in range(0,10)]
print(random.sample(list2,3))
#sample函数不会修改原有序列
print(list2)
[4, 0, 16]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
函数 | 描述 |
---|---|
acos(x) | 返回x的反余弦弧度值 |
asin(x) | 返回x的反正弦弧度值 |
atan(x) | 返回x的反正切弧度值 |
atan2(y, x) | 返回给定的 X 及 Y 坐标值的反正切值 |
cos(x) | 返回x的弧度的余弦值 |
hypot(x, y) | 返回欧几里德范数 sqrt(xx + yy) |
sin(x) | 返回的x弧度的正弦值 |
tan(x) | 返回x弧度的正切值 |
degrees(x) | 将弧度转换为角度,如degrees(math.pi/2) , 返回90.0 |
radians(x) | 将角度转换为弧度 |
常量 | 描述 |
---|---|
pi | 数学常量 pi(圆周率,一般以π来表示) |
e | 数学常量 e,e即自然常数(自然常数) |
pi
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-33-f84ab820532c> in <module>
----> 1 pi
NameError: name 'pi' is not defined
import math
math.pi
3.141592653589793
import math
math.e
2.718281828459045
文章浏览阅读15次。空化气泡的大小和相应的空化能量可以通过调整完全标度的振幅水平来操纵和数字控制。通过强调超声技术中的更高通量处理和防止样品污染,Epigentek EpiSonic超声仪可以轻松集成到现有的实验室工作流程中,并且特别适合与表观遗传学和下一代应用的兼容性。Epigentek的EpiSonic已成为一种有效的剪切设备,用于在染色质免疫沉淀技术中制备染色质样品,以及用于下一代测序平台的DNA文库制备。该装置的经济性及其多重样品的能力使其成为每个实验室拥有的经济高效的工具,而不仅仅是核心设施。
文章浏览阅读4.2k次,点赞3次,收藏14次。目录点击这里查看所有博文 本系列博客,理论上适用于合宙的Air202、Air268、Air720x、Air720S以及最近发布的Air720U(我还没拿到样机,应该也能支持)。 先不管支不支持,如果你用的是合宙的模块,那都不妨一试,也许会有意外收获。 我使用的是Air720SL模块,如果在其他模块上不能用,那就是底层core固件暂时还没有支持,这里的代码是没有问题的。例程仅供参考!..._合宙获取天气
文章浏览阅读7.7k次,点赞2次,收藏41次。1 关于meshMesh的意思是网状物,以前读书的时候,在自动化领域有传感器自组网,zigbee、蓝牙等无线方式实现各个网络节点消息通信,通过各种算法,保证整个网络中所有节点信息能经过多跳最终传递到目的地,用于数据采集。十多年过去了,在无线路由器领域又把这个mesh概念翻炒了一下,各大品牌都推出了mesh路由器,大多数是3个为一组,实现在面积较大的住宅里,增强wifi覆盖范围,智能在多热点之间切换,提升上网体验。因为节点基本上在3个以内,所以mesh的算法不必太复杂,组网形式比较简单。各厂家都自定义了组_802.11s
文章浏览阅读5.2k次,点赞8次,收藏21次。线程的几种状态_线程状态
文章浏览阅读4.2w次,点赞124次,收藏688次。stack翻译为栈,是STL中实现的一个后进先出的容器。要使用 stack,应先添加头文件include<stack>,并在头文件下面加上“ using namespacestd;"1. stack的定义其定义的写法和其他STL容器相同, typename可以任意基本数据类型或容器:stack<typename> name;2. stack容器内元素的访问..._stack函数用法
文章浏览阅读71次。<li> <a href = "“#”>-</a></li><li>子节点:文本节点(回车),元素节点,文本节点。不同节点树: 节点(各种类型节点)childNodes:返回子节点的所有子节点的集合,包含任何类型、元素节点(元素类型节点):child。node.getAttribute(at...
文章浏览阅读3.4k次。//config的设置是全局的layui.config({ base: '/res/js/' //假设这是你存放拓展模块的根目录}).extend({ //设定模块别名 mymod: 'mymod' //如果 mymod.js 是在根目录,也可以不用设定别名 ,mod1: 'admin/mod1' //相对于上述 base 目录的子目录}); //你也可以忽略 base 设定的根目录,直接在 extend 指定路径(主要:该功能为 layui 2.2.0 新增)layui.exten_layui extend
文章浏览阅读3.2k次,点赞6次,收藏13次。分层思想分层思想分层思想-1分层思想-2分层思想-2OSI七层参考模型物理层和数据链路层物理层数据链路层网络层传输层会话层表示层应用层OSI七层模型的分层结构TCP/IP协议族的组成数据封装过程数据解封装过程PDU设备与层的对应关系各层通信分层思想分层思想-1在现实生活种,我们在喝牛奶时,未必了解他的生产过程,我们所接触的或许只是从超时购买牛奶。分层思想-2平时我们在网络时也未必知道数据的传输过程我们的所考虑的就是可以传就可以,不用管他时怎么传输的分层思想-2将复杂的流程分解为几个功能_5g分层结构
文章浏览阅读191次。在激光雕刻中,单向扫描(Unidirectional Scanning)是一种雕刻技术,其中激光头只在一个方向上移动,而不是来回移动。这种移动方式主要应用于通过激光逐行扫描图像表面的过程。具体而言,单向扫描的过程通常包括以下步骤:横向移动(X轴): 激光头沿X轴方向移动到图像的一侧。纵向移动(Y轴): 激光头沿Y轴方向开始逐行移动,刻蚀图像表面。这一过程是单向的,即在每一行上激光头只在一个方向上移动。返回横向移动: 一旦一行完成,激光头返回到图像的一侧,准备进行下一行的刻蚀。
文章浏览阅读577次。强连通:在有向图G中,如果两个点u和v是互相可达的,即从u出发可以到达v,从v出发也可以到达u,则成u和v是强连通的。强连通分量:如果一个有向图G不是强连通图,那么可以把它分成躲个子图,其中每个子图的内部是强连通的,而且这些子图已经扩展到最大,不能与子图外的任一点强连通,成这样的一个“极大连通”子图是G的一个强连通分量(SCC)。强连通分量的一些性质:(1)一个点必须有出度和入度,才会与其他点强连通。(2)把一个SCC从图中挖掉,不影响其他点的强连通性。_强连通分量
文章浏览阅读3.9k次,点赞5次,收藏18次。在做web开发,要给用户提供一个页面,页面包括静态页面+数据,两者结合起来就是完整的可视化的页面,django的模板系统支持这种功能,首先需要写一个静态页面,然后通过python的模板语法将数据渲染上去。1.创建一个templates目录2.配置。_django templates
文章浏览阅读1.7k次。Ubuntu等Linux系统显卡性能测试软件 Unigine 3DUbuntu Intel显卡驱动安装,请参考:ATI和NVIDIA显卡请在软件和更新中的附加驱动中安装。 这里推荐: 运行后,F9就可评分,已测试显卡有K2000 2GB 900+分,GT330m 1GB 340+ 分,GT620 1GB 340+ 分,四代i5核显340+ 分,还有写博客的小盒子100+ 分。relaybot@re...