ln函数用Python ln的python

Python3

• Python3基础

• 1、Python3基础
• 2、Python3对象类型及变量

• Python的对象模型

• Python自动内存管理
• Python中的整数类型可以分为：
• 浮点数又称小数
• Python内置支持复数类型
• Python 3.6.x开始支持在数字中间位置使用单个下划线作为分隔来提高数字的可读性，类似于数学上使用逗号作为千位分隔符。
• 字符串

• 字符串合并方式
• 字符串格式化

• %s 字符串的输出格式
• %d 整型输出格式
• %f 浮点型输出格式
• 常用转义字符

• 数字和字符转换
• 原始字符串

• 3、Python运算符和表达式

• Python运算符与功能

• +号的用法
• * 号的用法
• / 号和 // 号用法
• % 号的用法
• 关系运算符
• in的用法
• is的用法
• 位运算 `<<`, `>>`, `&`, `|`, `^`
• 集合的运算`|`, `&`, `^`, `-`
• `and` 和 `or`
• not
• 矩阵相乘
• `Python`的`++`和`--`
• 合法的对象

• rstrip

• 4、常用内置函数

• 内置函数bin()、oct()、hex()
• 内置函数int()
• 内置函数ord()，chr()和str()
• 内置函数max(), min()和sum()

• max()和min()的key值
• sum()

• 内置函数type()和isinstance()

Python3基础

1、Python3基础

1. 查看Python版本

• !python -V

2. help(func)可以查询某函数的使用指南。IDLE中可以按F1获取帮助
3. 使用pip管理第三方包

2、Python3对象类型及变量

Python的对象模型

# Python3 math类的例子
import math
c = math.acos(-1)   # arccos函数
a = math.sin(c) # sin函数
# math.sin(3.1415926)
math.pi # 弧度制的值

1. type(x) 查看x的类型
2. isinstance(3, int) 判断3是不是int类型

Python自动内存管理

1. 在Python中，允许多个变量指向同一个值

• Python采用的是基于值的内存管理方式，如果为不同变量赋值为相同值，这个值在内存中只有一份，多个变量指向同一块内存地址。

2. 赋值语句的执行过程是：首先把等号右侧表达式的值计算出来，然后在内存中寻找一个位置把值存放进去，最后创建变量并指向这个内存地址。Python中的变量并不直接存储值，而是存储了值的内存地址或者引用，这也是变量类型随时可以改变的原因。Python具有自动内存管理功能，对于没有任何变量指向的值，Python自动将其删除。Python会跟踪所有的值，并自动删除不再有变量指向的值。因此，Python程序员一般情况下不需要太多考虑内存管理的问题。尽管如此，显式使用del命令删除不需要的值或显式关闭不再需要访问的资源，仍是一个好的习惯，同时也是一个优秀程序员的基本素养之一。

x = 3
id(x)

y = x
id(y)

# 这两个地址指向同一块内存

x = [1, 1, 1, 1]
id(x[0]) == id(x[1])

# 输出True

Python中的整数类型可以分为：

• 十进制整数如，0、-1、9、123
• 十六进制整数，需要16个数字0、1、2、3、4、5、6、7、8、9、a、b、c、d、e、f来表示整数，必须以0x开头，如0x10、0xfa、0xabcdef
• 八进制整数，只需要8个数字0、1、2、3、4、5、6、7来表示整数，必须以0o开头，如0o35、0o11
• 二进制整数，只需要2个数字0、1来表示整数，必须以0b开头如，0b101、0b100

浮点数又称小数

15.0、0.37、-11.2、1.2e2、314.15e-2

Python内置支持复数类型

c = 3 + 4j

c.real        # 查看复数实部
c.imag        # 查看复数虚部
a.conjugate() # 返回共轭复数

# 虚数支持乘法和除法
a*b
a/b

Python 3.6.x开始支持在数字中间位置使用单个下划线作为分隔来提高数字的可读性，类似于数学上使用逗号作为千位分隔符。

1_000_000
1_2 + 3_4j

字符串

• 用单引号、双引号或三引号界定的符号系列称为字符串
• 单引号、双引号、三单引号、三双引号可以互相嵌套，用来表示复杂字符串
• 'abc'、'123'、'中国'、"Python"、'''Tom said, "Let's go'''
• 字符串属于不可变序列
• 空字符串表示为''或 ""
• 三引号'''或"""表示的字符串可以换行，支持排版较为复杂的字符串；三引号还可以在程序中表示较长的注释。

字符串合并方式

a = 'abc' + '123'     #生成新字符串
x = '1234''abcd'
x = x + ',.;'
x = x'efg'    # 错误，不允许

字符串格式化

a = 3.6674
'%7.3f' % a   #%7.3f表示小数点后面精确到3位，总长度7位数，包括小数点，不够左侧补空格
# 结果：'  3.667'

"%d:%c"%(65,65)
# 结果：'65:A'

%s 字符串的输出格式

string = "hello" 
   
# %s打印时结果是hello  
print("string = %s" % string)  # output: string = hello  
   
# %2s意思是字符串长度为2，当原字符串的长度超过2时，按原长度打印，所以%2s的打印结果还是hello  
print("string = %2s" % string)   # output: string = hello  
   
# %7s意思是字符串长度为7，当原字符串的长度小于7时，在原字符串左侧补空格，  
# 所以%7s的打印结果是` hello`
print("string = %7s" % string)   # output: string =` hello`
   
# %-7s意思是字符串长度为7，当原字符串的长度小于7时，在原字符串右侧补空格，  
# 所以%-7s的打印结果是 `hello  `
print("string = %-7s!" % string)   # output: string = `hello  `  
   
# %.2s意思是截取字符串的前2个字符，所以%.2s的打印结果是he  
print("string = %.2s" % string)  # output: string = he  
   
# %.7s意思是截取字符串的前7个字符，当原字符串长度小于7时，即是字符串本身，  
#所以%.7s的打印结果是hello  
print("string = %.7s" % string)  # output: string = hello  
   
# %a.bs这种格式是上面两种格式的综合，首先根据小数点后面的数b截取字符串，  
# 当截取的字符串长度小于a时，还需要在其左侧补空格  
print("string = %7.2s" % string)  # output: string = `   he`  
print("string = %2.7s" % string)  # output: string = `hello`  
print("string = %10.7s" % string) # output: string = `     hello`
   
# 还可以用%*.*s来表示精度，两个*的值分别在后面小括号的前两位数值指定  
print("string = %*.*s" % (7,2,string) )  # output: string =`     he`

%d 整型输出格式

num=14 
   
# %d打印时结果是14  
print("num = %d" % num)      # output: num = 14  
   
# %1d意思是打印结果为1位整数，当整数的位数超过1位时，按整数原值打印，所以%1d的打印结果还是14  
print("num = %1d" % num)      # output: num = 14  
   
# %3d意思是打印结果为3位整数，当整数的位数不够3位时，在整数左侧补空格，所以%3d的打印结果是 14  
print("num = %3d" % num)      # output: num = ` 14`
   
# %-3d意思是打印结果为3位整数，当整数的位数不够3位时，在整数右侧补空格，所以%3d的打印结果是14_  
print("num = %-3d" % num)     # output: num = `14 `
   
# %05d意思是打印结果为5位整数，当整数的位数不够5位时，在整数左侧补0，所以%05d的打印结果是00014  
print("num = %05d" % num)     # output: num = 00014
   
# %.3d小数点后面的3意思是打印结果为3位整数，  
# 当整数的位数不够3位时，在整数左侧补0，所以%.3d的打印结果是014  
print("num = %.3d" % num)     # output: num = 014  
   
# %.0003d小数点后面的0003和3一样，都表示3，意思是打印结果为3位整数，  
# 当整数的位数不够3位时，在整数左侧补0，所以%.3d的打印结果还是014  
print("num = %.0003d" % num)    # output: num = 014  
   
# %5.3d是两种补齐方式的综合，当整数的位数不够3时，先在左侧补0，还是不够5位时，再在左侧补空格，  
# 规则就是补0优先，最终的长度选数值较大的那个，所以%5.3d的打印结果还是 014  
print("num = %5.3d" % num)     # output: num = `  014`
   
# %05.3d是两种补齐方式的综合，当整数的位数不够3时，先在左侧补0，还是不够5位时，  
# 由于是05，再在左侧补0，最终的长度选数值较大的那个，所以%05.3d的打印结果还是00014  
print("num = %05.3d" % num)    # output: num = 00014  
   
# 还可以用%*.*d来表示精度，两个*的值分别在后面小括号的前两位数值指定  
print("num = %*.*d" % (4,3,num)) # output: num = ` 014`

%f 浮点型输出格式

import math  
   
# %a.bf，a表示浮点数的打印长度，b表示浮点数小数点后面的精度  
   
# 只是%f时表示原值，默认是小数点后6位数  
print("PI = %f" % math.pi)       # output: PI = 3.141593  
   
# 只是%9f时，表示打印长度9位数，小数点也占一位，不够左侧补空格  
print("PI = %9f" % math.pi)      # output: PI = ` 3.141593`
   
# 只有.没有后面的数字时，表示去掉小数输出整数，03表示不够3位数左侧补0  
print("PI = %03.f" % math.pi)     # output: PI = 003  
   
# %6.3f表示小数点后面精确到3位，总长度6位数，包括小数点，不够左侧补空格  
print("PI = %6.3f" % math.pi)     # output: PI= ` 3.142`
   
# %-6.3f表示小数点后面精确到3位，总长度6位数，包括小数点，不够右侧补空格  
print("PI = %-6.3f" % math.pi)     # output: PI = `3.142 `
   
# 还可以用%*.*f来表示精度，两个*的值分别在后面小括号的前两位数值指定  
print("PI = %*.*f" % (6,3,math.pi))  # output: PI = ` 3.142`

常用转义字符

数字和字符转换

ord('a')
chr(97)

原始字符串

字符串界定符前面加字母r或R表示原始字符串，其中的特殊字符不进行转义，但字符串的最后一个字符不能是\。原始字符串主要用于正则表达式、文件路径或者URL的场合。

path = r'C:\Windows\notepad.exe' # 原始字符串，任何字符都不转义
print(path)

3、Python运算符和表达式

Python运算符与功能

+号的用法

• +运算符除了用于算术加法以外，还可以用于列表、元组、字符串的连接，但不支持不同类型的对象之间相加或连接。

[1, 2, 3] + [4, 5, 6]          # 连接两个列表

(1, 2, 3) + (4,)                # 连接两个元组

'abcd' + '1234'               # 连接两个字符串

'A' + 1                            # 不支持字符与数字相加，抛出异常

True 当作1，False当作0

* 号的用法

• *运算符不仅可以用于数值乘法，还可以用于列表、字符串、元组等类型，当列表、字符串或元组等类型变量与整数进行*运算时，表示对内容进行重复并返回重复后的新对象。

2.0 * 3                     # 浮点数与整数相乘

(3+4j) * 2                  # 复数与整数相乘(6+8j)

(3+4j) * (3-4j)             # 复数与复数相乘9 - 16 (j ^ 2)

"a" * 10                    # 字符串重复'aaaaaaaaaa'

[1,2,3] * 3                 # 列表重复运行耗时: [1, 2, 3, 1, 2, 3, 1, 2, 3]

(1,2,3) * 3                 # 元组重复(1, 2, 3, 1, 2, 3, 1, 2, 3)

/ 号和 // 号用法

• Python中的除法有两种，/和//分别表示除法和整除运算。

3 / 5       # 0.6

3 // 5      # 0

3.0 // 5    # 0.0

-13 // 10   # -2

% 号的用法

• %运算符除去可以用于字符串格式化之外，还可以对整数和浮点数计算余数。但是由于浮点数的精确度影响，计算结果可能略有误差。

3.1 % 2         # 1.1

6.0 % 2.0       # 0.0

关系运算符

• 关系运算符可以连用，一般用于同类型对象之间值的大小比较，或者测试集合之间的包含关系

1 < 3 < 5                       # 等价于1 < 3 and 3 < 5

'Hello' > 'world'               # 比较字符串大小 字符串的比较是比较ASCII码值

[1, 2, 3] < [1, 2, 4]           # 比较列表大小

'Hello' > 3                     # 字符串和数字不能比较

# 集合的特殊使用，判断是否为子集
{1, 2, 3} < {1, 2, 3, 4}        # 测试是否子集

in的用法

• 成员测试运算符in用于成员测试，即测试一个对象是否为另一个对象的元素。

3 in [1, 2, 3]       # 测试3是否存在于列表[1, 2, 3]中

5 in range(1, 10, 1) # range()是用来生成指定范围数字的内置函数

'abc' in 'abcdefg'   # 子字符串测试

• for 循环中的 in

for i in (3, 5, 7):  # 循环，成员遍历
    print(i, end='\t')

is的用法

• 同一性测试运算符（identitycomparison）is用来测试两个对象是否是同一个，如果是则返回True，否则返回False。如果两个对象是同一个，二者具有相同的内存地址。

3 is 3      # True

x = [300, 300, 300]; x[0] is x[1]       # True

x = [1, 2, 3]
y = [1, 2, 3]       # 上面形式创建的x和y不是同一个列表对象
x is y              # False

位运算 <<, >>, &, |, ^

• 位运算符只能用于整数，其内部执行过程为：首先将整数转换为二进制数，然后右对齐，必要的时候左侧补0，按位进行运算，最后再把计算结果转换为十进制数字返回。

3 << 2    # 把3左移2位(结果：12)

3 & 7     # 位与运算(结果：3)

3 | 8     # 位或运算(结果：11)

3 ^ 5     # 位异或运算(结果：6)

集合的运算|, &, ^, -

• 集合的交集、并集、对称差集等运算借助于位运算符来实现，而差集则使用减号运算符实现（注意，并集运算符不是加号）。

{1, 2, 3} | {3, 4, 5}         # 并集，自动去除重复元素(结果：{1, 2, 3, 4, 5})

{1, 2, 3} & {3, 4, 5}         # 交集(结果：{3})

{1, 2, 3} ^ {3, 4, 5}         # 对称差集(结果：{1, 2, 4, 5})

{1, 2, 3} - {3, 4, 5}         # 差集(结果：{1, 2})

and 和 or

• and和or具有惰性求值特点，只计算必须计算的表达式。

3 > 5 and a > 3     # 注意，此时并没有定义变量a，不用计算后面，不报错

3 > 5 or a > 3      # 3 > 5的值为False，所以需要计算后面表达式，因此报错

3 < 5 or a > 3      # 3 < 5的值为True，不需要计算后面表达式

3 and 5             # 最后一个计算的表达式的值作为整个表达式的值(输出5)

3 and 5 > 2         # 结果：False

not

3 not in [1, 2, 3]   # 逻辑非运算not(False)

3 is not 5           # not的计算结果只能是True或False之一(True)

矩阵相乘

• Python 3.5之后增加了一个新的矩阵相乘运算符@

import numpy             # numpy是用于科学计算的Python扩展库
x = numpy.ones(3)        # ones()函数用于生成全1矩阵
m = numpy.eye(3)*3       # eye()函数用于生成单位矩阵
m[0,2] = 5               # 设置矩阵指定位置上元素的值
m[2, 0] =3
x @ m                    # 矩阵相乘

• 逗号并不是运算符，只是一个普通分隔符。

'a' in 'b', 'a' 等效 'a' in ('b', 'a')

x = 3, 5        # x = (3, 5)

3 == 3, 5       # (True, 5)

x = 3+5, 7      # x = (8, 7)

Python的++和--

• Python不支持++和--运算符，虽然在形式上有时候似乎可以这样用，但实际上是另外的含义。

+(+3) 等效 ++3                # 正在得正，结果为：3
-(-3) 等效 --3                # 负负得正，结果为：3
-(+3) 等效 -+3 等效 +-3 等效 +(-)3 # 一负一正，结果为：-3

合法的对象

• 在Python中，单个任何类型的对象或常数属于合法表达式，使用运算符连接的变量和常量以及函数调用的任意组合也属于合法的表达式。

# 以下代码都合法
a = [1,2,3]
b = [4,5,6]
c = a + b       # c = [1, 2, 3, 4, 5, 6]

d = list(map(str, c))   # d = ['1', '2', '3', '4', '5', '6']

import math
list(map(math.sin, c))

'Hello' + ' ' + 'world'     # 'Hello world'

'welcome ' * 3      # 'welcome ' * 3

('welcome,'*3).rstrip(',')+'!'      # ('welcome,'*3).rstrip(',')+'!'

rstrip

• rstrip() 删除 string 字符串末尾的指定字符（默认为空格）.
• rstrip()方法语法：

str.rstrip([chars])

('welcome,'*3).rstrip(',')+'!'      # 'welcome,welcome,welcome!'

4、常用内置函数

• 内置函数不需要导入任何模块即可使用
• 执行下面的命令可以列出所有内置函数

dir(__builtins__)

• dir()函数可以查看指定模块中包含的所有成员或者指定对象类型所支持的操作。
• help()函数则返回指定模块或函数的说明文档。

内置函数bin()、oct()、hex()

• 内置函数bin()、oct()、hex()用来将整数转换为二进制、八进制和十六进制形式，这三个函数都要求参数必须为整数。

bin(555)                      # 把数字转换为二进制串(结果：'0b1000101011')

oct(555)                      # 转换为八进制串(结果：'0o1053')

hex(555)                      # 转换为十六进制串(结果：'0x22b')

内置函数int()

• 内置函数int()用来把实数转换为整数，或把数字字符串按指定进制转换为十进制数。

int(3.5)		# 3

int(-3.5)		# -3

int('101', 2)	# '101'为2进制数字，转化为十进制输出(结果：5)

int('101', 16)	# '101'为16进制数字，转化为十进制输出(结果：257)

内置函数ord()，chr()和str()

• ord()和chr()是一对功能相反的函数，ord()用来返回单个字符的序数或Unicode码，而chr()则用来返回某序数对应的字符，str()则直接将其任意类型参数转换为字符串。

ord('a')		# 97

chr(65)			# 'A'

chr(ord('A')+1)	# 'B'

str(1)			# '1'

str(1234)		# '1234'

str([1, 2, 3])	# '[1, 2, 3]'

str((1, 2, 3))	# '(1, 2, 3)'

内置函数max(), min()和sum()

• max()、min()、sum()这三个内置函数分别用于计算列表、元组或其他可迭代对象中所有元素最大值、最小值以及所有元素之和，sum()要求元素支持加法运算，max()和min()则要求序列或可迭代对象中的元素之间可比较大小。

import random
a = [random.randint(1,100) for i in range(10)]   # 列表推导式

print(max(a), min(a), sum(a))

sum(a)/len(a)			# 计算平均值

max()和min()的key值

• 内置函数max()和min()的key参数可以用来指定比较规则。

x = ['21', '1234', '9']
max(x, key = len)	# 按照元素的长度比较大小
max(x, key = int)		# 按照转化int之后的大小比较


from random import randrange
x = [[randrange(1,100) for i in range(10)] for j in range(5)]
for item in x:
    print(item)

max(x, key=sum)       #求所有元素之和最大的子列表

sum()

• sum()可以设置初始值求和

sum([1, 2, 3, 4], 5)		# 初始值为5，答案总和为sum([1, 2, 3, 4, 5]) + 5 = 15

内置函数type()和isinstance()

• 内置函数type()和isinstance()可以判断数据类型。