Python小白学习之路(十六)—【内置函数一】

将68个内置函数按照其功能分为了10类,分别是:

  • 数学运算(7个)
    • abs()    divmod()    max()    min()    pow()    round()    sum()
  • 类型转换(24个)
    • bool()    int()    float()    complex()    str()    bytearray()
    • bytes()   memoryview()   ord()   chr()   bin()   oct()   hex()
    • tuple()   list()   dict()   set()   frozenset(  ) enumerate()
    • range()   iter()   slice()   supper()   object()
  • 序列操作(8个)
    • all()      any()   filter()   map()   next()   reversed()   sorted()   zip()
  • 对象操作(7个)
    • help() dir() id() hash() type() len() ascii() format() vars()
  • 反射操作(8个)
    • _import__() isinstance() issubclass() hasattr() getattr() setattr() delattr() callable()
  • 变量操作(2个)
    • globals() locals()
  • 交互操作(2个)
    • print() input()
  • 文件操作(1个)
    • open()
  • 编译执行(4个)
    • compile() eval() exec() repr()
  • 装饰器(3个)
    • property() classmethod() staticmethod()

一、数学运算类(7个)

abs()

  • Return the absolute value of the argument.取绝对值
print(abs(-1))
#执行结果
1

divmod()

  • divmod(x, y) -> Return the tuple (x//y, x%y).返回商和余数
print(divmod(5, 2))
#执行结果
(2, 1)

max()

  • 返回最大值
  • 处理的对象为可迭代对象
  • (相当于一个for循环取出每一个元素进行比较)
  • 不同类型之间是不能进行比较的
  • 每个元素进行比较时,是从每个元素的第一个位置开始依次比较
  • (如果一个位置分出大小,后面的位置可以不用进行比较便可以得出比较结果)
#用法一:
num_1 = [1,38,2,0,4,7]
print(max(num_1))

#用法二:传入对象为字典,默认比较的是字典的key
age_dic={'age1':14, 'age2':3, 'age3':45, 'age1':18} 
print(max(age_dic)) 
print(max(age_dic.values())) # 比较的是字典的values
#执行结果
age4
45

用法三:
任务:
将给定名单中年龄最大的找出来

people_list = [
{'name':'xhg','age':18},
{'name':'aaa','age':10},
{'name':'bbb','age':30},
{'name':'ccc','age':14},
]
print(max(people_list, key = lambda dic:dic['age']))
#执行结果
{'name': 'bbb', 'age': 30}
'''
#程序分析
#这段代码的理解 max(people_list, key = lambda dic:dic['age'],实际上进行了这样一个操作
ret = []
for item in people_list:
ret.append(item['age'])
print(max(ret))
'''

 

min()

  • 返回可迭代对象的元素中的最小值或者所有参数的最小值
  • 具体用法同max()函数

pow()

  • Equivalent to x**y (with two arguments) or x**y % z (with three arguments)
  • 两个参数,做幂运算
  • 三个参数,先做幂运算,再取余
print(pow(2,3))
#执行结果
8
print(pow(2,3,3))
#执行结果
2

 

round()

  • 对浮点数进行四舍五入求值
  • 第二个参数为可选参数,如果不填默认取整,参数代表保留的位数
print(round(3.1415926))
print(round(3.1415926, 3))
#执行结果
3
3.142

 

sum()

 

  • 对可迭代对象中的每个元素求和
  • 可迭代对象中的元素类型是数值
print(sum([1, 2, 3, 4, 5]))
#执行结果
15

 

二、类型转换(24个)

bool() 

 

  • 根据传入的参数的逻辑值创建一个新的布尔值
  • None ” () {} [] 0 ==>False
  • 其余 ==>True
print(bool(None))
print(bool('xhg'))
#执行结果
False
True

 

int()

 

  • 根据传入的参数创建一个整数
print(int('123')) #将字符串转化为整形
print(int(123.9)) #取整

#执行结果
123
123

 

float()

 

根据传入的参数创建一个新的浮点数

print(float('123.78'))    #将字符串转化为浮点型
print(float(123))    #将整形转换成浮点型

#执行结果
123.78
123.0

 

complex()

 

  • 根据传入参数创建一个新的复数
  • 有两个参数:
  • 第一个参数是实部;第二个参数是虚部
  • 不填参数,默认输出为 0j
  • 只填一个参数 a,则输出 a + 0j
print(complex())
print(complex(1))
print(complex(1, 2))

#执行结果
0j
(1+0j)
(1+2j)

 

str()

 

  • 将目标参数转化为字符串
print(str(123))
print(type(str(123)))
print(str([1, 2, 3, 4, 'xhg']))
print(type(str([1, 2, 3, 4, 'xhg'])))

#执行结果
123
<class 'str'>
[1, 2, 3, 4, 'xhg']
<class 'str'>

 

bytearray()

 

  • 根据传入的参数创建一个新的字节数组
  • 可传入的参数:
    • 字符串(使用指定编码方式编码);bytearray()然后使用str.encode()将字符串转换为字节。
    • 如果它是一个整数,那么数组将具有这个大小,并将用null字节初始化。
    • 如果它是符合缓冲区接口的对象,则将使用对象的只读缓冲区来初始化字节数组。
    • 如果它是可迭代的,那么它必须是range 0 < = x < 256的整数的迭代,它被用作数组的初始内容

 

a = bytearray('小伙郭', encoding = 'utf -8' ) #字符串需要指定编码方式
print(a, len(a))
b = bytearray('小伙郭', encoding = 'gbk' )
print(b, len(b))
c = bytearray([1,2,3,255]) #如果元素大于255,将会报错
print(c, len(c))

#执行结果
bytearray(b'\xe5\xb0\x8f\xe4\xbc\x99\xe9\x83\xad') 9
bytearray(b'\xd0\xa1\xbb\xef\xb9\xf9') 6
bytearray(b'\x01\x02\x03\xff') 4

 

bytes()

  • 根据传入的参数创建一个新的不可变字节数组
  • 具体用法及传入的参数同函数bytearray()

ord()

chr()

  • 返回Unicode字符对应的整数
  • 返回整数所对应的Unicode字符
print(ord('d'))
print(chr(100))
#执行结果
100
d

 

bin()整数–>2进制字符串
oct()整数–>8进制数字符串
hex()整数–>16进制字符串

print(bin(5))
print(oct(10))
print(hex(15))

#执行结果
0b101
0o12
0xf

 

tuple()

 

  • 根据传入的参数创建一个新的元组
  • 传入的参数为空或者是可迭代对象
print(tuple())
print(tuple('123456'))
print(tuple([1, 2, 'a', 'b']))

#执行结果
()
('1', '2', '3', '4', '5', '6')
(1, 2, 'a', 'b')

 

list()

 

  • 根据传入的参数创建一个新的列表
  • 传入的参数为空或者是可迭代对象
print(list())
print(list('123456'))
print(list([1, 2, 'a', 'b']))

#执行结果
[]
['1', '2', '3', '4', '5', '6']
[1, 2, 'a', 'b']

 

dict()

  • 根据传入的参数创建一个新的字典
  • 可以由下列四种方式传入参数:
    • 不传入参数,建立空字典
    • 通过映射函数创建字典
    • 通过键值对来创建字典
    • 通过可迭代对象来创建字典

 

print(dict())
print(dict(zip(['key1', 'key2'],[1, 2])))
print(dict(key1 = 'a', key2 = 'b'))
print(dict([['key1',1], ['key2','b']]))

#执行结果
{}
{'key1': 1, 'key2': 2}
{'key1': 'a', 'key2': 'b'}
{'key1': 1, 'key2': 'b'}

 

set()

 

  • 根据传入的参数创建一个新的集合
  • set() -> new empty set object
  • set(iterable) -> new set object

 

print(set())
print(set('123456'))
print(set([1,2,3,'a','b']))

#执行结果
set()
{'3', '1', '6', '2', '5', '4'}
{1, 2, 3, 'b', 'a'}

 

frozenset()

 

  • 根据传入的参数创建一个新的不可变集合
print(frozenset())
print(frozenset('123456'))

frozenset()
frozenset({'5', '1', '4', '3', '6', '2'})

 

range()

 

  • 根据传入的参数创建一个新的range对象
  • python3里面,需要通过for循环来创建range()每一个元素
  • range(a,b)–>左闭右开
  • range(stop) -> range object
  • range(start, stop[, step]) -> range object
for item in range(5):
print(item)
for item in range(10, 15):
print(item)
for item in range(0, 100, 20):
print(item)

#执行结果
0 1 2 3 4 
10 11 12 13 14
0 20 40 60 80

写在后面:

内置函数总结好多哦

今天眼睛看电脑时间太长了   累

明天继续总结吧

今天也就总结了一半的样子

最近发现之前的知识有些忘记了

需要返回去再看看了

开题报告写的不是很好  今天老师要求重新写

好好加油吧

明天就是周末啦   可以粗去吃好吃的  放松放松

更重要的  双11   买买买