python宇晨_pyhton学习之路(二)---相关的函数

pyhton相关的函数

简介

pyhton相关的函数

1. Python不但能非常灵活地定义函数，而且本身内置了很多有用的函数，可以直接调用。

2. 函数就是最基本的一种代码抽象的方式

计算圆的面积

R=[12.34,9.08,73.1] #多个圆半径

PI=3.1415926535897932 #定义一个常量 圆周率

i=0

def area_of_circle(x):

if x>0:

return( PI * x ** 2)

return 0

while i < len(R):

h=R[i]

s=area_of_circle(h)

print('The area for %.2f is %.3f'%(h,s))

i+=1

定义函数:

1. 在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。

2. 导入一个，文件中定义好的函数：from 文件名(不带后缀) import 函数方法名

3. 空函数： 定义一个什么事也不做的空函数，可以用pass语句

3.1 pass可以用来作为占位符

4. 对参数类型做检查，只允许整数和浮点数类型的参数。数据类型检查可以用内置函数isinstance()实现

5. 返回多个值:如在游戏中经常需要从一个点移动到另一个点，给出坐标、位移和角度，就可以计算出新的坐标

5.1 但其实这只是一种假象，Python函数返回的仍然是单一值，

5.2 原来返回值是一个tuple！但是，在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值，所以，Python的函数返回多值其实就是返回一个tuple，但写起来更方便

def my_abs(x):

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

raise TypeError('bad operand type')

if x >= 0:

return x

else:

return -x

print("调用自定义的函数：",my_abs(100))

def nop(): #空函数

pass

import math #import math语句表示导入math包，并允许后续代码引用math包里的sin、cos等函数

def move(x, y, step, angle=0): #返回多个值

nx = x + step * math.cos(angle)

ny = y - step * math.sin(angle)

return nx, ny

x,y = move(100, 100, 60, math.pi / 6)

print(x,y)

练习示例：请定义一个函数quadratic(a, b, c)，接收3个参数，返回一元二次方程 ax^2+bx+c=0的两个解。

import math

def quadratic(a, b, c):

if not(isinstance(a, (int, float)) and isinstance(b,(int,float)) and isinstance(c,(int,float))):

raise TypeError('bad operand type')

elif a == 0:

return "此方程无解，A不能为0"

else:

x1 = (-b + math.sqrt(b ** 2 - 4 * a * c))/(2 * a) * 代表乘法 ** 代表乘方

x2 = (-b - math.sqrt(b ** 2 - 4 * a * c))/(2 * a)

if x1 == x2 :

return x1

return x1,x2

# 测试:

print('quadratic(2, 3, 1) =', quadratic(2, 3, 1))

print('quadratic(1, 3, -4) =', quadratic(1, 3, -4))

if quadratic(2, 3, 1) != (-0.5, -1.0):

print('测试失败')

elif quadratic(1, 3, -4) != (1.0, -4.0):

print('测试失败')

else:

print('测试成功')

常用函数：

abs()求绝对值

max()求最大值,多个参数

print("求绝对值的参数：",abs(-100))

print("max()求最大值,多个参数：",max(-100,200,150,1,-2))

all() 函数用于判断给定的参数中的所有元素是否都为 TRUE，返回 True/False。元素除了是 0、空、None、False 外都算 True；空元组、空列表返回值为True

print( all( [0.1,1,-1] ) ) # 返回 True

print( all( (None,1) ) ) # 返回 False(其中一个元素为None)

print( all( [0,1,-1] ) ) # 返回 False(其中一个元素为0)

print( all( [" ","a",""] ) ) # 返回 False(第三个元素为空)

any() 函数用于判断给定的参数是否全部为False，是则返回False，如果有一个为True，则返回True。 元素除了是 0、空、False外都算 TRUE。

# 参数全部不为 0、空、FALSE

print(any("-45")) # True

print(any(["-45",None])) # True 有一个none

print( any( ("0","ab","") ) ) # True(注意：第一个参数0加了双引号，表示为一个字符串)

# 参数全部为 0、空、False

print( any( (0,"") ) ) # False

print( any( (0,"",False) ) ) # False

bin()函数返回一个整数int或者长整数long int的 二进制表示。

print( bin(10) ) # 0b1010

print( bin(133) ) # 0b10000101

bool() 函数用于将给定参数转换为布尔类型，如果参数不为空或不为0，返回True；参数为0或没有参数，返回False。

print( bool(10) ) # True

print( bool([0])) # True

print( bool([]) ) # False

print( bool(["123","s",0]) ) # True

print( bool(0) ) # False

print( bool() ) # False

chr()函数用一个范围在range(256)内(即0～255)的整数作参数，返回一个对应的ASCII数值

print( chr(98) ) # 返回：b 把数字98在ascii码中对应的字符打印出来

dict()函数用来将元组/列表转换为字典格式。

print(dict(a='a', b='b', t='t')) # 返回：{'a': 'a', 'b': 'b', 't': 't'}

print(dict( [ ('one',1),('two',2),('three',3) ] ) )

# 可迭代对象方式来构造字典 返回：{'one': 1, 'two': 2, 'three': 3}

print(dict(zip(["1","2","3"],["a","b","c"])))

# 映射函数方式来构造字典 返回：{'1': 'a', '2': 'b', '3': 'c'}

divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(商x，余数y)

print( divmod(5,2) ) # 返回：(2, 1)

print( divmod(5,1) ) # 返回：(5, 0)

print( divmod(5,3) ) # 返回：(1, 2)

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。Python 2.3. 以上版本可用，2.6 添加 start 参数。

seasons = ['Spring', 'Summer', 'Fall', 'Winter']

print(list(enumerate(seasons)))

# 返回：[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]

print(list(enumerate(seasons, start=1)) )

# 下标从 1 开始 返回：[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

11.** eval() 函数用来执行一个字符串表达式，并返回表达式的值**

print(eval('3 * 2')) # 返回：6

x = 7

print(eval('3 + x')) # 返回：10

exec() 执行储存在字符串或文件中的Python语句，相比于eval，exec可以执行更复杂的Python代码

exec("print('Hello World')") # 执行简单的字符串 返回：Hello World

exec("for i in range(5): print('iter time is %d'%i)") # 执行复杂的for循环

# iter time is 0

# iter time is 1

# iter time is 2

# iter time is 3

# iter time is 4

filter()用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，可用list()来转换为列表

res = filter(lambda n:n>5,range(10)) # 过滤掉0-9中不符合n>5的数据

for i in res: # 循环打印符合n>5的数据

print(i)

format()是一种格式化字符串的函数 ，基本语法是通过 {} 和 : 来代替以前的 % 。format 函数可以接受不限个参数，位置可以不按顺序

print( "{}{}".format('a','1') ) #位置映射 返回：a1

print('name:{n},url:{u}'.format(n='alex',u='www.xxxxx.com'))

#返回 ： name:alex,url:www.xxxxx.com

print( "{0[0]},{0[1]}".format(('baidu','com')) ) # 元素访问 按顺序 返回： baidu,com

print( "{0[2]},{0[0]},{0[1]}".format(('baidu','com','www')) ) # 不按顺序 返回：www,baidu,com

float() 函数用于将整数和字符串转换成浮点数。

print(float(1)) #返回： 1.0

print(float(0.1)) #返回： 0.1

print(float('123')) # 返回：123.0

frozenset() 返回一个冻结的集合(一个无序的不重复元素序列)，冻结后集合不能再添加或删除任何元素。

a = frozenset(range(10)) # 先创建一个冻结集合

print(a) # 返回：frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})

del a[0] # 试图删除冻结集合a中的元素，报错 删除已冻结集合的元素 抛异常TypeError: 'frozenset' object doesn't support item deletion

b = frozenset("happy") # 将字符串转换成一个集合

print(b) # 返回 frozenset({'a', 'h', 'p', 'y'})无序不重复

c = frozenset() # 创建一个空集合

globals() 函数会以字典格式返回当前位置的全部全局变量

print(globals()) # globals 函数返回一个全局变量的字典，包括所有导入的变量

hasattr() 函数用于判断对象是否包含对应的属性。如果对象有该属性返回 True，否则返回 False。

class t: #类 属性名 = 属性值

a = 1

b = 2

c = 3

p = t()

print(hasattr(p,'a')) # True

print(hasattr(p,'b')) # True

print(hasattr(p,'x')) # False

hash() 用于获取一个对象(数字或者字符串等)的哈希值。不能直接应用于 list、set、dictionary。

#注意：在 hash() 对对象使用时，所得的结果不仅和对象的内容有关，还和对象的 id()，也就是内存地址有关。

print(hash(1)) # 1

print(hash(20000)) # 20000

print(hash('123')) # -6436280630278763230

print(hash('ab12')) # 5468785079765213470

print(hash('ab12')) # 5468785079765213470

hex() 函数用于将一个整数转换为十六进制数。返回一个字符串，以0x开头。

print(hex(1)) # 0x1

print(hex(-256)) # -0x100

print(type(hex(-256))) #

id()函数用于获取对象的内存地址。

a = "123" # 字符串

print(id(a)) # 13870392

b = [1,2,3] # 列表

print(id(b)) # 7184328

c = {'num1':1,'num2':2,'num3':3} # 字典

print(id(c)) # 6923656

input() 函数接受一个标准输入数据，返回为 string 类型。这个函数是最最常用的了。在Python3.x中 raw_input() 和 input() 进行了整合，仅保留了input( )函数。

a = '123456'

b = input("username:")

if b == a : # 如果b的输入数据等于a存储的数据，打印”right“

print("right")

else: # 否则打印”wrong“

print("wrong")

int() 函数用于将一个字符串或数字转换为整型。

print(int()) # 不传入参数时，得到结果0

print(int(0.5)) # 去掉小数部分，得到结果0

print(int(3)) # 得到结果3

print(int('0xa',16)) # 十六进制数“0xa”转换成十进制整数，得到结果10

print(int('00010',2)) # 二进制数“00010”转换成十进制整数，得到结果2

isinstance() 函数来判断一个对象是否是一个已知的类型，返回布尔值。类似 type()。

isinstance() 与 type() 区别：

type() 不会认为子类是一种父类类型，不考虑继承关系

isinstance() 会认为子类是一种父类类型，考虑继承关系。

如果要判断两个类型是否相同推荐使用 isinstance()。

a = 2

print(isinstance(a,int)) # True

print(isinstance(a,str)) # False

print(isinstance(a,(str,tuple,dict))) # False

print(isinstance(a,(str,tuple,int))) # 是元组其中的一个则返回True

class A:

pass

class B(A):

pass

print(isinstance(A(),A)) # True

print( type(A()) == A ) # True

print(isinstance(B(),A)) # True

print( type(B()) == A ) # False --type()不考虑继承关系

iter() 函数用来生成迭代器。list、tuple等都是可迭代对象，我们可以通过iter()函数获取这些可迭代对象的迭代器，然后可以对获取到的迭代器不断用next()函数来获取下条数据。iter()函数实际上就是调了可迭代对象的 iter 方法。

注意：当已经迭代完最后一个数据之后，再次调用next()函数会抛出 StopIteration的异常，来告诉我们所有数据都已迭代完成。

it = [1,2,3]

it_list = iter(it)

print(next(it_list)) # 返回：1

print(next(it_list)) # 返回：2

print(next(it_list)) # 返回：3

print(next(it_list)) # StopIteration 集合中元素已经迭代完，提示语

len() 方法返回对象(字符、列表、元组等)长度或元素个数。

print(len('1234')) # 字符串，返回字符长度4

print(len(['1234','asd',1])) # 列表，返回元素个数3

print(len((1,2,3,4,50))) # 元组，返回元素个数5

print(len(12)) # 注意：整数类型不适用，否则报错

#TypeError: object of type 'int' has no len()

#提供了两个列表，对相同位置的列表数据进行相加

a = map(lambda x,y : x+y,[1,2,3,4,5],[2,4,6,8,10])

for i in a:

print(i)

#返回以下数据：

#3

#6

#9

#12s

#15

min()函数返回给定参数的最小值，参数可以为序列。

print("min(10,20,30):" , min(10,20,30) ) #返回：min(10,20,30): 10

print("min(10,-2,3.4):" , min(10,-2,3.4) ) #返回：min(10,-2,3.4): -2

print("min({'b':2,'a':1,'c':0}):" , min({'b':2,'a':1,'c':0}) )

# 字典，默认按key排序 返回 min({'b':2,'a':1,'c':0}): a

next() 返回迭代器的下一个项目。

it = iter([1,2,3,4,5]) # 首先获得Iterator对象:

while True: # 循环:

try:

x = next(it) # 获得下一个值:

print(x)

except StopIteration:

break # 遇到StopIteration就退出循环

oct() 函数将一个整数转换成八进制字符串。

print( oct(10) ) # 0o12

print( oct(255) ) # 0o377

open() 函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。

f = open("test1.txt","w",encoding="utf-8") # 创建一个file

print(f.write("abc"))

f = open("test1.txt","r",encoding="utf-8") # 读取文件数据

print(f.read())

ord()函数是chr()的配对函数，它以一个字符(长度为1的字符串)作为参数，返回对应的ASCII数值，或者Unicode数值，如果所给的 Unicode 字符超出了定义范围，则会引发一个 TypeError 的异常。

把字符 b(长度为1的字符串)作为参数在ascii码中对应的字符打印出来

print( ord('b') ) # 返回：98

print( ord('%') ) # 返回：37

pow()函数返回x的y次方的值。

注意：pow()通过内置的方法直接调用，内置方法会把参数作为整型，而 math 模块则会把参数转换为 float。

#通过内置的方法直接调用

print( pow(2,2) ) # 2的二次方 返回：4

print( pow(2,-2) ) # 2的负二次方 返回 0.5

#导入math模块

import math

print(math.pow(3,2)) # 3的负二次方 返回：9.0

range() 函数可创建一个整数列表，一般用在 for 循环中。语法：range(start, stop[, step])

for i in range(10):

print("依次打印数字:",i) # 依次打印数字0-9

for a in range(0,10,2): # 步长为2

print("步长为2:",a) # 打印0,2,4,6,8

for b in range(10, 0, -2): # 步长为-2

print("步长为-2:",b) # 打印10,8,6,4,2

reduce() 函数会对参数序列中元素进行累积。在Python3 ，reduce()被放置在functools模块里，如果想要使用它，需要先引入functools模块。

import functools #引入functools模块

a = functools.reduce(lambda x,y:x+y,[1,2,3])

print(a) # 6 ， 即从1加到3

b = functools.reduce(lambda x,y:x+y,range(10))

print(b) # 45 ， 即从0加到9

repr() 函数将对象转化为供解释器读取的形式。返回一个对象的 string 格式。

r = repr((1,2,3))

print( r ) # (1, 2, 3)

print( type(r) ) #

dict = repr({'a':1,'b':2,'c':3})

print( dict ) # {'c': 3, 'a': 1, 'b': 2}

print( type(dict) ) #

reversed() 函数返回一个反转的迭代器。 reversed(seq)要转换的序列，可以是 tuple, string, list 或 range。

rev = reversed( [1,2,3,4,5] ) # 列表

print(list(rev)) #返回： [5, 4, 3, 2, 1]

rev1 = reversed( "school" ) # 元组

print(tuple(rev1)) #返回参数： ('l', 'o', 'o', 'h', 'c', 's')

rev2 = reversed(range(10)) # range

print(list(rev2)) #返回： [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

round() 方法返回浮点数x的四舍五入值。(除非对精确度没什么要求，否则尽量避开用round()函数)

print( round(4.3)) # 只有一个参数时，默认保留到整数 返回：4

print( round(2.678,2)) # 保留2位小数 返回：2.68

print( round(5/3,3)) # 运算表达式并保留3位小数 返回：1.667

set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

a = set('school')

print(a) # 重复的被删除，得到结果：{'o', 'c', 's', 'l', 'h'}

b = set([1,2,3,4,5])

c = set([2,4,6,8,10])

print(b & c) # 交集，得到结果为{2, 4}

print(b | c) # 并集，得到结果为{1, 2, 3, 4, 5, 6, 8, 10}

print(b - c) # 差集，得到结果为{1, 3, 5}

sorted() 函数对所有可迭代的对象进行排序(默认升序)操作。

print(sorted([1,2,5,30,4,22])) # 对列表进行排序 返回： [1, 2, 4, 5, 22, 30]

dict = {23:42,1:0,98:46,47:-28} # 对字典进行排序

print( sorted(dict) ) # 只对key排序 返回： [1, 23, 47, 98]

print( sorted(dict.items()) )

#默认按key进行排序 return:[(1, 0), (23, 42), (47, -28), (98, 46)]

print( sorted(dict.items(),key=lambda x:x[1]) )

#用匿名函数实现按value进行排序 return:[(47, -28), (1, 0), (23, 42), (98, 46)]

#利用key进行倒序排序

test1 = [1,2,5,30,4,22]

r_list = sorted(test1,key=lambda x:x*-1)

print(r_list) #return: [30, 22, 5, 4, 2, 1]

#要进行反向排序，也可以通过传入第三个参数 reverse=True：

test2 = [1,2,5,30,4,22]

print(sorted(test2,reverse=True)) #return: [30, 22, 5, 4, 2, 1]

str() 函数将对象转化为string格式

a = str((1,2,3))

print(a) # 打印a，得到结果(1, 2, 3)

print(type(a)) # 打印a的类型，得到结果

sum()函数对参数进行求和计算。

print( sum([1,2,3]) ) # 6

print( sum([1,2,3],4) ) # 列表计算总和后再加4，得到结果10

print( sum( (1,2,3),4 ) ) # 元组计算总和后再加4，得到结果10

tuple()函数将列表转换为元组。

注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。

print( tuple([1, 2, 3])) # (1,2,3)

type() 函数如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象。

print(type(1)) #

print(type("123")) #

print(type([123,456])) #

print(type( (123,456) ) ) #

print(type({'a':1,'b':2}) ) #

zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。可以使用 list() 转换来输出列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。利用 * 号操作符，可以将元组解压为列表。*

a = [1,2,3,20]

b = [4,5,6]

c = [7,8,9,10]

for i in zip(a,b): #短集合的下表为主要，输出

print(i)

#返回结果：

#(1, 4)

#(2, 5)

#(3, 6)

print(list(zip(a,b))) # list() 转换为列表 return: [(1, 4), (2, 5), (3, 6)]

print(list(zip(b,c))) # 元素个数与最短的列表一致 return:[(4, 7), (5, 8), (6, 9)]

a1,a2 = zip(*zip(a,b)) # 用zip(*)解压

print(list(a1)) # return:[1, 2, 3]

print(list(a2)) # [4, 5, 6]

import() 函数用于动态加载类和函数。如果一个模块经常变化就可以使用 import() 来动态载入。

调用函数常见BUG：

如果传入的参数数量不对，会报TypeError的错误，参数类型不能被函数所接受，也会报TypeError的错误，并且给出错误信息：str是错误的参数类型