print(abs(-5))
print(max(1,2))
print(max(1,2,3,4,5))
print(int('123'))
print(int(12.34))
print(float('12.34'))
print(str(1.23))
print(str(100))
print(bool(1))
print(bool(''))
a = abs #变量a指向abs函数,相当于给函数起了个别名
print(a(-1))
#自定义函数
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(-10))
#from abstest import my_abs 引入其他.py文件中定义的函数直接调用
#空函数,什么也不干
def nop():
pass #pass 可以作为占位符,现在不知道函数的实现,可以通过pass占位,类似于 ;
#my_abs(1,2) TypeError 参数错误
#my_abs('acb')
import math
#坐标 位移 速度
#返回多个参数,实际上返回的只是一个tuple
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)
r = move(100,100,60,math.pi / 6)
print(r)
#Python的函数定义非常简单,但灵活度却非常大。
#除了正常定义的必选参数外,还可以使用默认参数、
#可变参数和关键字参数,使得函数定义出来的接口,
#不但能处理复杂的参数,还可以简化调用者的代码
#默认参数 默认参数在后(调用堆栈)
def my_power(x,n=2):
s = 1
while n>0:
n = n - 1
s = s * x
return s
print(my_power(5))
print(my_power(5,3))
#默认参数必须指向不变对象
def add_end(L=[]):
L.append('END')
return L
print(add_end([1,2,3])) #[1,2,3,'END'] ok
print(add_end(['a','b',3])) #['a','b',3,'END'] ok
print(add_end()) # ['END'] ok
print(add_end()) # ['END','END'] error why
print(add_end()) # ['END','END','END'] error why 错误原因:默认参数指向了变量
def add_end_M(L=None):
if L is None:
L = []
L.append('END')
return L
print(add_end_M()) # ['END'] ok
print(add_end_M()) # ['END'] ok
print(add_end_M()) # ['END'] ok
#可变参数 允许传入0个或任意个参数,这些参数在函数调用时自动组装为一个tuple
def calc(numbers):
sum = 0
for n in numbers:
sum = sum + n*n*n
return sum
print(calc([1,2,3]))
print(calc((1,2,3,4,5)))
#真正的可变参数
def calc_m(*numbers):
sum = 0
for n in numbers:
sum = sum + n*n
return sum
print(calc_m())
print(calc_m(1))
print(calc_m(1,2))
print(calc_m(1,2,3))
print(calc_m(1,2,3,4))
nums = [1,2,3]
print(calc_m(*nums)) # *num 表示把nums这个list的所有元素作为可变参数传进去。
#关键字参数 允许传入0个或任意个含参数名的参数,这些关键字参数在函数内部自动组装为一个dict。
def person(name,age,**kw):
print('name:',name,'age:',age,'other:',kw)
print(person('Michael',30))
aa = person('Bob',30,city='Beijing')
print(aa)
#命名关键字参数
def person(name,age,**kw):
if 'city' in kw:
pass
if 'job' in kw:
pass
print('name:',name,'age:',age,'other:',kw)
person('Jack',24,city='Begin',addr='CHaoyang',zipcode=123456)
#命名关键字参数(需要可变参数,或者*分割) 限制关键字参数的名字 命名关键字参数必须传入参数名
def person(name,age,*,city,job):
print(name,age,city,job)
person('Jack',24,city='Begin',job='Engineer')
#如果函数定义中已经有了一个可变参数,后面跟着的命名关键字参数就不再需要一个特殊分隔符*了:
def person(name,age,*args,city,job):
print(name,age,args,city,job)
person('Jack',24,(1,2,3),city='Begin',job='Engineer')
person('Jack',24,city='Begin',job='Engineer')
#命名关键字参数可以有缺省值
def person(name,age,*,city='beijing',job):
print(name,age,city,job)
person('Jack',24,job='Engineer')
#递归函数
def fact(n):
if n==1:
return 1;
return n*fact(n-1)
print(fact(100))
#尾递归 防止栈溢出
#尾递归调用时,如果做了优化,栈不会增长,因此,无论多少次调用也不会导致栈溢出。
def fact_iter(num,product):
if num == 1:
return product
return fact_iter(num-1,num*product)
def fact(n):
return fact_iter(n,1)
print(fact(100))`这里写代码片`
python基础学习(二)
最新推荐文章于 2022-08-12 10:04:12 发布
本文是Python基础学习的第二部分,详细介绍了Python的数据类型、控制结构和函数使用,帮助初学者掌握Python编程的核心概念。
摘要由CSDN通过智能技术生成