函数
环境介绍：python cmd控制台和pycharm
python函数的定义
def msg(name):
print("{}在haha".format(name))
def 函数名称([参数列表]):
# 函数体
# return 返回值
函数的参数问题
- 默认值参数
def get_circle_area(r,pi=3.14):
pass
默认值参数要放在普通参数后面
- 可变参数
def show(name,age=18,*args):
pass
args以元组形式保存
- 命名参数
def shows(name,age=18,**kwargs):
pass
kwargs以字典形式保存
匿名函数
早期，python没有匿名函数，但可以借助lambda表达式来使用
def show(fn):
fn()
show(lambda:print("haha"))#无参情况
def show(fn):
print("haha")
show(lambda fn:print(fn))#单个参数参情况
def show(fn):
res = fn(10,20)
print(res)
show(lambda x,y:x + y)#多个参数情况
lambda虽然简化了代码书写，增强了代码维护成本，代码的可读性下降了，提升复杂度
偏函数
将一个函数的某些默认值转换为想要的默认值函数
>>> int("123456",base=10)#以十进制读取，默认也为10，可修改
123456
>>> int("123456",base=8)#以八进制读取
42798
>>> int("123456789",base=8)#格式错误会报错
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 8: '123456789'
>>> from functools import partial
>>> partial(int,base=16) 修改int的默认读取进制为16
functools.partial(<class 'int'>, base=16)
>>> bs16_int = partial(int,base=16)
>>> bs16_int("ABC")
2748
函数递归
函数自身调用自身为递归，必须要有终止条件，否则进入死循环
- 求1-100的和
def get_sum(n):
#没有终止条件
return n + get_sum(n-1)
这样的代码就会报错，python中规定递归默认不能超过1000次
[Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded
设置终止条件
def get_sum(n):
#有终止条件
if n == 1:
return 1
return n + get_sum(n-1)
res = get_sum(100)
print(res)
python函数的调用
msg("wangcai")
函数名称([实参列表])
全局函数
python有接近40个全局函数，全局函数的思维导图在这里
容器
- tuple 元组
- dict 字典
- list 列表
- set 集合
数据类型
- float 将整数和字符串转换成浮点数
- int 将一个字符串或数字转换为整型
- str 将对象转化为适于人阅读的形式
- chr 用一个范围在0～255整数作参数，返回一个对应的字符
转换
- ascii 用ascii码表将其转换为字符串，若非ascii，如UTF-8字符则有\u前缀进行转义
>>> ascii("哈哈")
"'\\u54c8\\u54c8'"
>>> a = ascii(33)
>>> type(a)
<class 'str'>
- bin 返回一个整数 int 或者长整数 long int 的二进制表示，类型为字符串
>>> bin(8)
'0b1000'
>>> a=bin(8)
>>> type(a)
<class 'str'>
>>>
- bool 对值进行布尔运算，None、空字符串、空列表、空元组、空集合、空字典、0等空元素和空数据结构为False，其他为True
>>> bool(None),bool(" "),bool(1),bool([]),bool("")
(False, True, True, False, False)
- oct 将整数转换为8进制
>>> oct(22)
'0o26'
- ord 以一个字符作为参数，返回对应的 ASCII 数值或Unicode 值，若超出范围，则报错
>>> a="a"
>>> ord(a)
97
- hex 将整数转换为16进制
>>> hex(22)
'0x16'
>>> hex(222)
'0xde'
- repr 将对象转化为字符串
>>> a = 1998
>>> b="haha"
>>> b+repr(a)
'haha1998'
>>> b+str(a)
'haha1998'
输入输出
- input 标准输入，返回的是字符串
name = input("输入你的名字:")
print(name)
输入你的名字:翠花
翠花
- print 输出流
print("哈哈")
哈哈
其它
- abs 求数的绝对值，若数为复数，则返回模
>>> abs(-17),abs(3+4j)
(17, 5.0)
- all 可迭代对象所有元素为True则返回True，否则返回False
>>> all([1, 3, " "]), all([1, 3, None])#空格也是一个有效字符
(True, False)
- any 可迭代对象所有元素为False则返回False，否则返回True
>>> any([1, 3,None]), all([None, None])
(True, False)
- bytearray 返回新的二进制数组，拥有列表大多数方法，这个是存放二进制数据，添加数据需要输入整数，参数范围为(0, 256)
a = bytearray("哈哈",encoding="utf-8")
print(a,type(a))
bytearray(b'\xe5\x93\x88\xe5\x93\x88') <class 'bytearray'>
- bytes 返回一个新的bytes对象，范围是0-256区间的整数不可变序列
>>> bytes("翠花", encoding="utf-8")
b'\xe7\xbf\xa0\xe8\x8a\xb1'
- callable 判断对象是否可调用
class CuiHua:
def __call__(self):
print("Hello,翠花")
print(callable(CuiHua))
True
- classmethod 不需要实例化和self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，方法和实例化对象
class A():
bar = 1
@classmethod
def func1(cls):
print('func1')
print(cls.bar)
A.func2()
- compile 将一个字符串编译为字节代码
str = "3 * 4"
a = compile(str,'','eval')
print(eval(a))
结果：12
- complex 返回一个复数，值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数
>>> complex("3+4j"),complex(3,4)
((3+4j), (3+4j))
- delattr 删除对象的一个实例属性
class CuiHua:
def __init__(self, name, age):
self.name = name
self.age = age
Cui = CuiHua("翠花", 18)
print(Cui.name)
# 删除对象中的属性
delattr(Cui, "name")
print(Cui.name)
- dir 不带参数时，返回当前范围内的变量、方法和定义的类型列表;带参数时，返回参数的属性、方法列表
>>> dir()
['A', '__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__']
- divmod 返回整除整数a//b和余数a%b
>>> divmod(15,2)
(7, 1)
- enumerate 返回一个枚举对象，start可以指定枚举计数，默认为0
>>> a = enumerate("哈哈",start=1)
>>> a,type(a)
(<enumerate object at 0x030C2E90>, <class 'enumerate'>)
- eval 运行字符串代码，返回传入字符串的表达式的结果，不改变源码逻辑
>>> eval("1+3*(6+1)*5")
106
- exec 运行字符串代码，改变源码逻辑
>>> sum = 0
>>> exec("sum += 1")
>>> sum
1
- filter 依次取出可迭代对象中元素交给一个函数，取返回True的元素
a = [-1,-2,-3,-4,0,1,2,3,4]
def is_natural(number):
"""判断是否是自然数"""
if isinstance(number, int) and number >= 0:
return True
else:
return False
# 返回filter对象
result = filter(is_natural,a)
print(list(result))
[0, 1, 2, 3, 4]
- format 格式化字符串
age = 18
print("翠花的年龄是{}".format(age))
翠花的年龄是18
- frozenset 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素
>>> a = {1,2,3,4}
>>> b = frozenset(a)
>>> a
{1, 2, 3, 4}
>>> b
frozenset({1, 2, 3, 4})
- globals 以字典类型返回当前位置的全部全局变量
>>> globals()
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>}
- getattr 通过字符串获取对象属性和方法值，一般联合hasattr使用
class CuiHua:
def hello(self):
print("Hello, 翠花")
Cui = CuiHua()
print(getattr(Cui, 'hello', None))
- hasattr 判断对象中是否有对应字符串的属性和方法
class CuiHua:
def hello(self):
print("Hello, 翠花")
Cui = CuiHua()
if hasattr(Cui, "hello"):
getattr(Cui, "hello")()
- setattr 对应函数 getattr()，用于设置属性值，该属性可以不存在
class A():
haha = 1
a = A()
print(getattr(a,'haha'))
setattr(a,'haha',10)
print(a.haha)
结果： 1
10
- hash 返回对象的hash值
>>> hash("222")
-1471210590
- help 获取方法名和方法名下面的注释
>>> help(hash)
Help on built-in function hash in module builtins:
hash(obj, /)
Return the hash value for the given object.
Two objects that compare equal must also have the same hash value, but the
reverse is not necessarily true.
- id 以10进制获取对象内存地址
>>> a = 123
>>> id(a)
2088922112
- isinstance 判断对象是否是某种或多个类型，判断对象是否继承某个类
def is_natural(number):
"""判断是否是自然数"""
if isinstance(number, int) and number >= 0:
return True
else:
return False
- issubclass 判断类是否是某个类的子类，注意：左边为要判断的子类，右边为父类
class Dog:
pass
class JingBa(Dog):
pass
print(issubclass(Dog,JingBa))
print(issubclass(JingBa,Dog))
False
True
- iter 生成迭代器
list = iter([1,2,3,4])
for i in list:
print(i)
结果：
1
2
3
4
- len 获取对象长度
>>> a = [1,2,3,4]
>>> len(a)
4
- locals 以字典类型返回当前位置的全部局部变量
>>> def A(x):
... z=1
... print(locals())
...
>>> A(10)
{'x': 10, 'z': 1}
- map 将可迭代对象依次传入函数，返回可迭代对象
>>> def A(x) :
... return x*x
...
>>> map(A,[1,2,3,4,5])
<map object at 0x006D8C50>
- max 最大值
- min 最小值
- memoryview 返回给定参数的内存查看对象（内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许代码访问）
>>>a = memoryview(bytearray("abcefg", 'utf-8'))
>>> print(a[1])
98
>>> print(a[-1])
103
- next 返回迭代器的下一个项目
list = iter([1,2,3,4])
while True:
x = next(list)
print(x)
if x == 4:
break
结果：
1
2
3
4
- object python的默认类，python3种默认都是新式类，基类都会继承object类
def A(object):
pass
- open 打开一个文件并返回文件对象
f = open("e://a.txt","r")
- pow 返回 x ^ y 或 返回 x ^ y % z的值
>>> pow(2,3)
8
>>> pow(2,3,3)
2
- property 在新式类中返回属性值
class C(object):
def __init__(self):
self._x = None
@property
def x(self):
"""I'm the 'x' property."""
return self._x
- reload 重新载入之前载入的模块
import sys
....
reload(sys)
- range 不可变数据序列，有三个参数开始start, 停止stop,步长step
for i in range(1, 10, 2):
print(i)
1 3 5 7 9
- reversed 用于反向列表
>>> a= [0,1,2,3,4]
>>> a.reverse()
>>> a
[4, 3, 2, 1, 0]
- round 四舍五入保留多少小数位
>>> round(3.141592657,2)
3.14
>>> round(3.141592657,5)
3.14159
- slice 切片操作函数里的参数传递 slice(start,stop,step)
>>> a = slice(0,100,3)
>>> list = [0,1,2,3,4,5,6,7,8,9,10]
>>> list[a]
[0, 3, 6, 9]
- sorted 将可迭代对象进行排序
>>> list = [10,11,22,53,64,5,6,7,8,9,10]
>>> sorted(list)
[5, 6, 7, 8, 9, 10, 10, 11, 22, 53, 64]
- sum 序列求和
>>> sum([1,2,3,4,5])
15
- super 调用父类方法
class Person:
def __init__(self, name, language):
self.name = name
self.language = language
class Richman(Person):
def __init__(self):
super().__init__(name,language)
- type 返回对象是由什么类型构建的
>>> type("haha")
<class 'str'>
>>> type([1,2,3])
<class 'list'>
- vars 获取具有字典属性的对象
def CuiHua():
name = "翠花"
age = 18
print(vars())
CuiHua()
{'name': '翠花', 'age': 18}
- zip 依次取出可迭代对象中元素组成新的元组，返回一个迭代器
a = zip("cuihua", "翠花")
print(a.__next__())
print(a.__next__())
('c', '翠')
('u', '花')
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
