python3的内置对象及用法示例详解 (python3.7)

17年的时候,业余学习了python和一些深度学习的基础,因为有java的知识基础,所以语法上并没有什么难度,倒是深度学习比较难深入,加上后来一直没有项目推动,所以就搁置了下去,最近公司准备引入阿里的RPA机器人自动化,3.X版本是用python写的,所以这两天晚上就又重新温习了一下python,加强一下记忆和理解,同时也希望能帮助到一些初学的朋友。

python的内置对象有六七十个,一些比较不常用到的我暂时没有整理进来,后续如果有用到,会随时更新。

为了跑测试的时候方便在控制台看结果,所以我将注释都以打印的方式输出了。

print('~~~~ print()方法 , 用于定向输出一个或者多个字符串, sep为间隔符默认空,end为结束符,默认为换行')
print('str')
print('str1', 'str2')
print('str1', 'str2', sep='=', end='||')

print('~~~~ str() 将数字/列表/元组/字段转换成字符串')
print(str(12) + 'end')
print(str([12, 11]) + 'end')
print(str({1: 12, 'a': 12}) + 'end')
print(str((1,)) + 'end')


print('~~~~ float() 将一个字符串或者数字转换成整型')
print(float(12))
print(float('12'))
print(float('12.12'))
# float(1 + 2j) 不可以转型复数

print('''~~~~ int() 将一个字符串或者数字转换成整型
第二个参数可选, 指定返回的数字进制, 使用时, 第一个参数必须为字符''')
print(int('12'))
print(int(12.12))
print(int('10', 8))
print(int('0x16', 16))
# int(1 + 2j) 不可以转型复数
# int('12.12') 不可以转型带小数点的字符串, 需先转成浮点型

print('~~~~ complex() 转换复数,入参为字符串时,参数只能有一个,且不能有空格')
print(complex(3))
print(complex(1, 2))
print(complex('3'))
print(complex('3+2j'))
# print(complex('3 + 2j')) # 错误的写法

print('~~~~ list() 将字符串/元组/字典的键集、值集/set集合  转换为列表')
print(list('abcd')) # 拆成一个一个字符
print(list((13, 'ab', '合'))) # 将元组转成可变的列表
print(list({'key1': 'value1', 'key2': 'value2'}))
print(list({'key1': 'value1', 'key2': 'value2'}.keys()))
print(list({'key1': 'value1', 'key2': 'value2'}.values()))
print(list({'set1', 'set2', 'set3'}))
print(list(['list1', 'list2'])) # 当然也可以传入列表


print('~~~~ tuple() 将字符串/列表/字典的键集、值集/set集合  转换为元组')
print(tuple('abcd'))
print(tuple(['list1', 'list2', 'list3']))
print(tuple({'key1': 'value1', 'key2': 'value2'}))
print(tuple({'key1': 'value1', 'key2': 'value2'}.keys()))
print(tuple({'key1': 'value1', 'key2': 'value2'}.values()))
print(list({'set1', 'set2', 'set3'}))
print(list(('list1', 'list2')))

print('~~~~ set() 将字符串/列表/元组/字典的键集、值集  转换为集合')
print(set('abcd'))
print(set(('list1', 'list2')))
print(set(['list1', 'list2', 'list3']))
print(set({'key1': 'value1', 'key2': 'value2'}))
print(set({'key1': 'value1', 'key2': 'value2'}.keys()))
print(set({'key1': 'value1', 'key2': 'value2'}.values()))
print(set({'set1', 'set2', 'set3'}))

print('~~~~ dict() 用于创建一个字典,入参可以为: 无/多组赋值表达式/两个元素的元组列表/zip函数对象')
print(dict())
print(dict(key1='value1', key2='value2'))
print(dict([('key1', 'value1'), ('key2', 'value2')]))
print(dict(zip(['key1', 'key2', 'key3'], ['value1', 'value2', 'value3'])))

print('''~~~~ bool() 将参数换成布尔型, 0/None/空字符/无参 返回False , 其他都返回True
实际在应用中, 任何数据都可以作为True/Fals条件判断, Python默认会转换为 True和False来判断''')
print(bool(0))
print(bool('0'))
print(bool(1))
print(bool(1.1))
print(bool(1.1))
print(bool(1+1j))
print(bool('1'))
print(bool())
print(bool(None))
print(bool(''))


print('''str() float() int() complex() list() tuple() set() dict() bool()
都是同类型的内置函数, 作用都是转换数据类型''')
print('-------------------------------')

print('~~~~ 上边有用到zip()函数, zip() 将可迭代的对象打包成元组组成的列表, 参数为*开头表示反向操作')
print(list(zip([1, 2, 3], [4, 5, 6])))
print(list(zip([1, 2, 3], [4, 5, 6, 7, 8])))
zipped = zip([1, 2, 3], [4, 5, 6])
print(list(zip(*zipped)))

print('======下边是与标准数据类型直接相关的函数======')

print('~~~~ len() 返回字符/列表/元组/集合/迭代器 等参数的长度或元素个数')
print(len('abc'))
print(len(['a', 'bb', 42]))
print(len((4, 'g')))
print(len(['a', 'bb', 42, (4, 'g'), ['dd', 'll']]))
print(len({'a', 'cc', 32}))
print(len({'key1': 'value1', 'key2': 'value2'}))
print(len({'key1': 'value1', 'key2': 'value2'}.keys()))
print(len({'key1': 'value1', 'key2': 'value2'}.values()))
print(len({'key1': 'value1', 'key2': 'value2'}.items()))


print('~~~~ abs() 返回数字的绝对值')
print(abs(12))
print(abs(-12.12))

print('~~~~ round() 返回四舍五入值, 第二个参数为保留小数位数,默认为0')
print(round(1.5))
print(round(0.6))
print(round(-3.4))
print(round(1.665, 2))
print(round(2.356, 2))


print('~~~~ hex() 将数字转换为16进制,返回表示十六进制的字符串')
print(hex(1))
print(hex(17))
print(hex(-17))

print('~~~~ min() 返回给定参数(多参数或迭代器)的最小值,入参可以为全数字 或者 全字符')
print(min(10, 3, -12))
print(min(17, 12.11, 33))
print(min('sadfg'))
print(min('1111', '1212', 'a', 'sds'))
print(min(('1111', '1212', 'a', 'sds')))
print(min(['1111', '1212', 'a', 'sds']))
print(min({'a', 'Z', 'a', 'sds'}))
print(min({'a': 'a', 'Z': 'z', 'c': 'sds'}))
print(min({'a': 'a', 'Z': 'z', 'c': 'sds'}.keys()))
print(min({'a': 'a', 'Z': 'z', 'c': 'sds'}.values()))
print(min({'a': 'a', 'Z': 'z', 'c': 'sds'}.items()))

print('~~~~ max() 返回给定参数的最大值,入参可以为全数字 或者 全字符 , 用法同min()')

print('~~~~ sorted() 对可迭代的对象(全数字或者全字符)进行排序并返回, 可以正序 反序 指定表达式排序')
print(sorted('dcads'))
print(sorted([12, -7, 123, 98]))
print(sorted(['a', 'e', '123', 's']))
print(sorted(['a', 'e', '123', 's'], reverse=True)) # 反向
print(sorted([12, -17, 123, 98], key= lambda x: abs(x)))
print(sorted([2, -7, 13, 98], key= lambda x: x*x))
print(sorted({1: 'D', 3: 'F', 2: 'B', 4: 'E', 5: 'A'}))
print(sorted({1: 'D', 3: 'F', 2: 'B', 4: 'E', 5: 'A'}.keys()))
print(sorted({1: 'D', 3: 'F', 2: 'B', 4: 'E', 5: 'A'}.values()))
print(sorted({1: 'D', 3: 'F', 2: 'B', 4: 'E', 5: 'A'}.items()))
# 还可以利用sorted()对字典进行排序
array = [{"age": 20, "name": "a"}, {"age": 25, "name": "b"}, {"age": 10, "name": "c"}]
array = sorted(array, key=lambda x: x["age"])
print(array)


print('~~~~ reversed() 函数返回一个反转的迭代器,只能反转一层, 嵌套的迭代器内层无法反转')
print(list(reversed('adfsdfd')))
print(list(reversed(['ss', 1, 'flower', 123])))
print(list(reversed(['ss', 1, 'flower', [123, 'df', 'ss']])))


print('~~~~ range() 返回一个迭代器, start, stop , step')
print(list(range(0)))
print(list(range(5)))
print(list(range(1, 5)))
print(list(range(1, 5, 2)))


print('~~~~ iter() 用来生成迭代器')
ll = [1, 3, 4]
for i in iter(ll):
    print(i)

print('''~~~~ next()遍历迭代器元素,除了将迭代器转成列表/元组/集合等 , 还可以轮询遍历,
如果传入第二个参数, 那么遍历完成之后会返回该值, 否则抛出StopIteration''')
it = iter([1, 2, 5, 4, 3])
while True:
    try:
        x = next(it)
        print(x)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break

it = iter([1, 2, 5, 4, 3])
while True:
    x = next(it, 'a')
    print(x)
    if x == 'a':
        break


print('''=============''')
print('''列表/元组/集合 以及字典的keys() values() items() 等 都属于
迭代器, 前三者属于标准类型 , 后三者与 range()  reversed() sorted() iter()
等函数返回的迭代器一样, 属于迭代器对象 , 类型是对象 , 转成字符串的话 打印出来是对象而不是列表和元组那样的格式''')
print('''=============''', end='\n\n')

print('=====对象有关的内置函数======')

print('~~~~ id() 获取参数的内存地址')
a = 12
b = 12.12
c = True
d = False
e = 'str'
f = ['l1', 'l2']
print(id(a))
print(id(b))
print(id(c))
print(id(d))
print(id(e))
print(id(f))


print('''~~~~ hash() 返回对象的哈希值(整型), 数值类型返回本身,
      参数不可是列表/集合/字典 , 但是元组和迭代对象是可以的''')
print(hash(12))
print(hash('str'))
print(hash(True))
print(hash(False))
# print(hash(['l1', 'l2']))
print(hash(('l1', 'l2')))
# print(hash({'l1', 'l2'}))
# print(hash({'key1': 'value1', 'key2': 'value2'}))
print(hash(iter(['l1', 'l2'])))


class A:
    pass


print(hash(A()))


print('~~~~ type() 返回数据的类型')
print(type(None))
print(type(13))
print(type(12.12))
print(type(True))
print(type('abc'))
print(type(['abc', 1]))
print(type(('abc',)))
print(type({'set'}))
print(type({'key': 'value'}))

print(type(A()))
print('通过比较可以用来作为判断条件')
''' 由于NoneType只有None一个值,所以可以直接用is 或者 == 来判断, 无法用类似NoneType这样来比较
    因为 NoneType不是一个class '''
a = None
print(a is None)
print(type(13) == int)
print(type(12.12) == float)
print(type(True) == bool)
print(type('abc') == str)
print(type(['abc', 1]) == list)
print(type(('abc',)) == tuple)
print(type({'set'}) == set)
print(type({'key': 'value'}) == dict)
print(type(A()) == A)

print('''~~~~ isinstance() 用来判断对象是否是类的实例 包含子类实例, 第二个参数可以是元组, 
    表示对象实例符合元组中任意一个类,都返回True''')


class B(A):
    pass


class C:
    pass


print(isinstance(A(), A))
print(isinstance(B(), A))
print(isinstance(C(), A))
print(isinstance(C(), (A, C)))


print('~~~~ issubclass(class, classinfo) 判断class是否是classinfo的子类')
print(issubclass(A, A))
print(issubclass(B, A))
print(issubclass(C, A))


print('~~~~ super() 用于在子类中表示父类对象')


class P:
    age = 23

    def __init__(self):
        print('Parent')

    def p_print(self):
        print('i am parent')


class C(P):
    age = 25

    def __init__(self):
        print('Child')

    def c_print(self):
        print('i am child')
        super().p_print()
        print(self.age)
        print(super().age)


C().c_print()

print(''' 可以看到 python的继承机制 , 并不像java那样 , 在子类实例化的时候 , 先实例化父类
    但是在子类中却可以用super()调用父类成员变量以及方法, 更像是将其局部静态化了,也可能是python
    在构建子类的时候, 将父类的属性同时写入到了子类中,但是用vars()方法并没有看到子对象中包含有父类的属性
    这个等到有时间可以具体再探究一下''')


print('''~~~ locals() 返回包含当前位置所有变量和其值的字典''')
print(locals())

print('''~~~~ vars() 返回对象的属性和属性值对应的字典,如果没有参数,
    就打印当前调用位置的属性和属性值 类似 locals()
    如果参数为一个类,则返回类的组成部分''')
print(vars())
print(vars(A))
print(vars(A()))

print('~~~~ input() 接收一个标准输入数据 , 返回字符串')
# inputValue = input()
# print(inputValue)


 

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值