精华内容
下载资源
问答
  • 1、list.append(obj) 向列表中加入一个对象objfruits = ['apple', 'pear', 'orange']>>> fruits.append('apple')>>> fruits['apple', 'pear', 'orange', 'apple']2、list.count(obj) 返回一个...

    1、list.append(obj) 向列表中加入一个对象obj

    fruits = ['apple', 'pear', 'orange']

    >>> fruits.append('apple')

    >>> fruits

    ['apple', 'pear', 'orange', 'apple']

    2、list.count(obj) 返回一个对象obj在列表中出现的次数

    >>> fruits.count('apple')

    2

    3、list.extend(seq) 把序列seq的内容加入到列表中

    >>> seq = ['banana', 'strawberry']

    >>> fruits.extend(seq)

    >>> fruits

    ['apple', 'pear', 'orange', 'apple', 'banana', 'strawberry']

    4、list.index(obj, i=0, j=len(list))

    返回 list[k] == obj 的 k 值,而且 k 的范围在 i<=k

    >>> fruits.index('orange',0, len(list))

    2

    >>> fruits.index('lemon',0, len(list))

    Traceback (most recent call last):

    File "", line 1, in

    fruits.index('lemon',0, len(list))

    ValueError: 'lemon' is not in list

    5、list.insert(index, obj) 在索引量为 index 的位置插入对象obj

    >>> fruits.insert(3, 'lemon')

    >>> fruits

    ['apple', 'pear', 'orange', 'lemon', 'apple', 'banana', 'strawberry']

    6、list.pop(index=-1) 删除并返回指定位置的对象,默认是最后一个对象

    >>> fruits.pop()

    'strawberry'

    >>> fruits

    ['apple', 'pear', 'orange', 'lemon', 'apple', 'banana']

    7、list.remove(obj) 从列表中删除找到的第一个obj对象。假设不存在则返回一个ValueError错误。

    >>> fruits.remove('apple')

    >>> fruits

    ['pear', 'orange', 'lemon', 'apple', 'banana']

    >>> fruits.remove('strawberry')

    Traceback (most recent call last):

    File "", line 1, in

    fruits.remove('strawberry')

    ValueError: list.remove(x): x not in list

    8、list.reverse() 原地翻转列表

    >>> fruits.reverse()

    >>> fruits

    ['banana', 'apple', 'lemon', 'orange', 'pear']

    9、list.sort(func=None,key=None,

    reverse=False) 以指定的方式排序列表中的成员,假设 func 和 key 參数指定,则依照指定的方式比較各个元素,假设 reverse 标志被置为True,则列表以反序排列。

    >>> fruits.sort()

    >>> fruits

    ['apple', 'banana', 'lemon', 'orange', 'pear']

    >>> fruits.sort(reverse=True)

    >>> fruits

    ['pear', 'orange', 'lemon', 'banana', 'apple']

    版权声明:本文博主原创文章。博客,未经同意不得转载。

    展开全文
  • Python : 3.7.3OS : Ubuntu 18.04.2 LTSIDE : pycharm-community-2019.1.3Conda : 4.7.5typesetting : Markdowncodecoder@ubuntu:~$ source activate py37(py37) coder@ubuntu:~$ ipythonPython 3.7.3 (default, Mar...

    Python : 3.7.3

    OS : Ubuntu 18.04.2 LTS

    IDE : pycharm-community-2019.1.3

    Conda : 4.7.5

    typesetting : Markdown

    code

    coder@ubuntu:~$ source activate py37

    (py37) coder@ubuntu:~$ ipython

    Python 3.7.3 (default, Mar 27 2019, 22:11:17)

    Type 'copyright', 'credits' or 'license' for more information

    IPython 7.5.0 -- An enhanced Interactive Python. Type '?' for help.

    In [1]: # 查询对象的方法列表

    In [2]: dir(object)

    Out[2]:

    ['__class__',

    '__delattr__',

    '__dir__',

    '__doc__',

    '__eq__',

    '__format__',

    '__ge__',

    '__getattribute__',

    '__gt__',

    '__hash__',

    '__init__',

    '__init_subclass__',

    '__le__',

    '__lt__',

    '__ne__',

    '__new__',

    '__reduce__',

    '__reduce_ex__',

    '__repr__',

    '__setattr__',

    '__sizeof__',

    '__str__',

    '__subclasshook__']

    In [3]: dir(list)

    Out[3]:

    ['__add__',

    '__class__',

    '__contains__',

    '__delattr__',

    '__delitem__',

    '__dir__',

    '__doc__',

    '__eq__',

    '__format__',

    '__ge__',

    '__getattribute__',

    '__getitem__',

    '__gt__',

    '__hash__',

    '__iadd__',

    '__imul__',

    '__init__',

    '__init_subclass__',

    '__iter__',

    '__le__',

    '__len__',

    '__lt__',

    '__mul__',

    '__ne__',

    '__new__',

    '__reduce__',

    '__reduce_ex__',

    '__repr__',

    '__reversed__',

    '__rmul__',

    '__setattr__',

    '__setitem__',

    '__sizeof__',

    '__str__',

    '__subclasshook__',

    'append',

    'clear',

    'copy',

    'count',

    'extend',

    'index',

    'insert',

    'pop',

    'remove',

    'reverse',

    'sort']

    In [4]: # 刚开始用Pycharm,它输出的列表在一行上,查看困难。

    ...: # 使用ipython,有自动换行,方便查看。

    In [5]: # 虽然类的方法这么多,可是常用的较少。耐心学习就好。

    In [6]: exit

    (py37) coder@ubuntu:~$ conda deactivate

    coder@ubuntu:~$

    resource

    [文档 - English] docs.python.org/3

    [文档 - 中文] docs.python.org/zh-cn/3

    [规范] www.python.org/dev/peps/pep-0008

    [规范] zh-google-styleguide.readthedocs.io/en/latest/google-python-styleguide/python_language_rules

    [源码] www.python.org/downloads/source

    [ PEP ] www.python.org/dev/peps

    [平台] www.cnblogs.com

    [平台] gitee.com

    Python具有开源、跨平台、解释型、交互式等特性,值得学习。

    Python的设计哲学:优雅,明确,简单。提倡用一种方法,最好是只有一种方法来做一件事。

    代码的书写要遵守规范,这样有助于沟通和理解。

    每种语言都有独特的思想,初学者需要转变思维、踏实践行、坚持积累。

    展开全文
  • Python 集合遍历,推导及 filter/map/reduce 操作 中讲了对集合 filter, map 和 reduce 操作,那还有 ...sort() 是 list 实例方法, sorted() 是一个内置函数Python 中也是只有 list 才有顺序。list.sort()...

    Python 集合的遍历,推导及 filter/map/reduce 操作 中讲了对集合的 filter, map 和 reduce 操作,那还有 sort 排序呢?像 Java 一样,Python  也提供了 sort() 和 sorted() 方法。

    sort() 是 list 的实例方法, sorted() 是一个内置函数。Python 中也是只有 list 才有顺序。

    list.sort() 方法

    查看 Python 3 中的 list.sort() 方法(help(list.sort))

    Help on method_descriptor:

    sort(self, /, *, key=None, reverse=False)

    Stable sort *IN PLACE*.

    Python 的 list.sort() 方法和 Java List.sort() 方法一样的,都是 IN PLACE 排序,没有返回值。实际看下各种排序场景

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    >>>s1=[2,1,5,3,4]

    >>>s1.sort()

    >>>s1

    [1,2,3,4,5]

    >>>s.sort(reverse=True)

    >>>s

    [5,4,3,2,1]

    >>>s2=[('c',2),('a',1),('b',5),('e',3),('d',4)]

    >>>s2.sort()

    >>>s2

    [('a',1),('b',5),('c',2),('d',4),('e',3)]

    >>>s2.sort(key=lambdaitem:item[1])

    >>>s2

    [('a',1),('c',2),('e',3),('d',4),('b',5)]

    >>>s2.sort(key=lambdaitem:item[1],reverse=True)

    >>>s2

    [('b',5),('d',4),('e',3),('c',2),('a',1)]

    list.sort() 能直接对可比较比象进行排序,也就是两个对象间能用 < 号相比较,映射到函数就是 __lt__。数字字符串都能比,从前面看到两个 tuple 也可以比较,

    1

    2

    >>>('c',2)

    False

    如果两个元素之间不能进行比较的话,可以指定 key 参数来取出相关值进行比较,如上面的 key=lambda item: item[1], 取 tuple 的第二个元素进行

    再来看自定义对象的比较

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    >>>classUser:

    ...def__init__(self,name,email):

    ...self.name=name

    ...self.email=email

    ...

    ...defget_name(self):

    ...returnself.name

    ...

    ...def__repr__(self):

    ...returnf'User: name={self.name}, email={self.email}'

    ...

    ...

    ...

    >>>users=[User('cc','hh@g.com'),User('aa','ii@g.com'),User('bb','ee@g.com')]

    >>>users.sort()

    Traceback(mostrecentcalllast):

    File"",line1,in

    users.sort()

    TypeError:'

    >>>users.sort(key=lambdauser:user.get_name())

    >>>users

    [User:name=aa,email=ii@g.com,User:name=bb,email=ee@g.com,User:name=cc,email=hh@g.com]

    >>>users.sort(reverse=True)

    Traceback(mostrecentcalllast):

    File"",line1,in

    users.sort(reverse=True)

    TypeError:'

    users.sort() 不管 reverse 是 False 还是 True,始终是试图用 < 去比较两个对象。由于 User 没有定义 __lt__ 方法,所以不能直接对 User 进行排序,而必须指定 key=lambda user: user.get_name() 依照 get_name() 的返回值进行排序。

    如何让对象是可比较的呢,或者直截说验证一下 Python 是否是调用了 __lt__ 方法来比较函数。接下来动态的给 User 类添加一个  __lt__ 方法,然后变 users.sort() 从不可能到可能

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    >>>deflittle(self,that):

    ...print(f'compare {self}, {that}')

    ...returnself.email

    ...

    >>>setattr(User,'__lt__',little)

    >>>users.sort()

    compareUser:name=cc,email=hh@g.com,User:name=bb,email=ee@g.com

    compareUser:name=aa,email=ii@g.com,User:name=cc,email=hh@g.com

    >>>users

    [User:name=bb,email=ee@g.com,User:name=cc,email=hh@g.com,User:name=aa,email=ii@g.com]

    这时候发现不用指定 key 对 users 也可以排序了,比较时调用了 __lt__ 方法。

    前面提到过只能对 list 进行排序,也就是只有 list 才有 sort() 方法,这也不难理解,set, tuple, dict 是不存在顺序观念的。但有意思的是,在对 set, tuple 转换成 list 后便自动立马有了顺序。

    1

    2

    3

    4

    5

    6

    >>>s={2,1,3}

    >>>list(s)

    [1,2,3]

    >>>t=(2,1,3,2)

    >>>list(t)

    [2,1,3,2]

    这也为接下来要看到的 sorted() 函数作了一个铺垫。前面只有 list 才有 sort() 方法,然而内置的 sorted() 函数除了对 list 进行排序,对 set 和 tuple 也能排序,效果上相当于转换为 list,再对 list 排序,所以最终 sorted() 后得到的都是一个 list。

    内置的 sorted() 函数

    同样,用 help(sorted) 看下它的原型

    Help on built-in function sorted in module builtins:

    sorted(iterable, /, *, key=None, reverse=False)

    Return a new list containing all items from the iterable in ascending order.

    A custom key function can be supplied to customize the sort order, and the

    reverse flag can be set to request the result in descending order.

    之于 list.sort() 方法,我们只需记住 sorted() 的几个不同之处

    它是一个内置函数,所以第一个参数传入待排序的集合

    待排序的集合不受限于 list, 它是 iterable, 根据鸭子类型的规则,只要该类实现了 __iter__() 方法就是 iterable。具体说来就是能使用 for..in.. 进行遍历的都能排序,像 set, tuple, 或 dict.items() 等

    排序不再是 IN PLACE, 也就是它的排序不改变原集合,而是生成一个新的 list 并返回

    其他的排序行为与list.sort() 函数是一致的。

    看下执行效果,对 list, tuple 和  set 进行排序

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    >>>s=[2,1,5,3,4]

    >>>nums=[2,1,5,3,4]

    >>>new_nums=sorted(nums)

    >>>nums

    [2,1,5,3,4]

    >>>new_nums

    [1,2,3,4,5]

    >>>t=(2,1,5,3,4)

    >>>t1=sorted(t)

    >>>t

    (2,1,5,3,4)

    >>>t1

    [1,2,3,4,5]

    >>>type(t1)

    >>>s={2,1,5,3,4}

    >>>s1=sorted(s)

    >>>s

    {1,2,3,4,5}

    >>>s1

    [1,2,3,4,5]

    >>>type(s1)

    不用理会 Python 怎么显示 set 中的内容,因为 set 是不能用索引号访问的。无论是对 tuple 还是 set 排序后得到的结果都是 list,sorted() 对原集合是无副作用的。

    对比一下 Java 的 sort()  与 sorted() 方法

    先看一下 Java 的这两个方法, Java 的 Collections 的类提供了两个 sort 方法

    1

    2

    3

    4

    5

    6

    7

    publicstatic>voidsort(Listlist){

    list.sort(null);

    }

    publicstaticvoidsort(Listlist,Comparator<?superT>c){

    list.sort(c);

    }

    它们接受的参数是 List, 所以也是只针对 List 进行排序,也是 IN PLACE 的, 也是无返回值的。sorted() 出现在 Java 的 Stream

    它得到的结果还是 Stream,因此它也是无副作用的,最后需要 collect(tolist()) 得到一个新的集合。

    关于排序算法

    Python 和 Java 对 List 进行排序的算法都是 Timsort, 摘录一下中文维基百科中的内容

    Timsort 是一种混合稳定的排序算法,源自合并排序和插入排序,旨在较好地处理真实世界中各种各样的数据。它使用了 Peter Mcllroy 的"乐观排序和信息理论上复杂性"中的技术,参见 第四届年度ACM-SIAM离散算法研讨会论文集,第467-474页,1993年。 它由 Tim Peters 在2002年实现,并应用于 Python编程语言。该算法通过查找已经排好序的数据子序列,在此基础上对剩余部分更有效地排序。 该算法通过不断地将特定子序列(称为一个 run )与现有的 run 合并,直到满足某些条件为止来达成的更有效的排序。 从 2.3 版本起,Timsort 一直是 Python 的标准排序算法。 它还被 Java SE7Android platformGNU Octave,谷歌浏览器,Swift

    展开全文
  • 的内置特殊函数列表__init__(self[,args])#类的构造函数__del__(self)#类的析构函数__repr__(self)#与eval()兼容的对象字符串表达式(用于实例重建)__str__(self)#调用st...

    类的内置特殊函数列表

    __init__(self[, args])              #类的构造函数

    __del__(self)                       #类的析构函数

    __repr__(self)                      #与eval()兼容的对象字符串表达式(用于实例重建)

    __str__(self)                       #调用str()执行的函数

    __cmp__(self)                       #比较两个实例,小于为负,等于为0,大于为正

    __hash__(self)                      #hash code

    __nonzero__(self)                   #self为逻辑假,返回0;否则返回1

    __getattr__(self, name)             #使用self.name时调用

    __setattr__(self, name, value)      #使用self.name=value时调用

    __delattr__(self, name)             #调用del self.name时调用

    __call__(self[, args])              #像使用函数一样使用类object(args),即object.__call__(self, args)

    如果对象可通过序列或字典接口访问,则需要实现以下函数

    __len__(self)                       #内置函数len()时调用

    __getitem__(self, key)              #self[key]时调用

    __setitem__(self. key, value)       #self[key] = value时调用

    __delitem__(self, key)              #del self[key]时调用

    __getslice__(self, i, j)            #self[i:j]

    __setslice__(self, i, j, value)     #self[i:j]=value

    __delslice__(self, i, j)            #del self[i:j]

    重载运算符

    __add__(self, other)

    __sub__(self, other)

    __mul__(self, other)

    __div__(self, other)

    __mod__(self, other)

    __divmod__(self, other)

    __pow__(self, other[, modulo])

    __lshift__(self, other)

    __rshift__(self, other)

    __and__(self, other)

    __or__(self, other)

    __xor__(self, other)

    展开全文
  • >>> dir(__builtins__)#Python 内置的函数列表['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', '...
  • Python : 3.7.3OS : Ubuntu 18.04.2 LTSIDE : pycharm-community-2019.1.3Conda : 4.7.5typesetting : Markdowncodecoder@ubuntu:~$ source activate py37(py37) coder@ubuntu:~$ ipythonPython 3.7.3 (default, Mar...
  • Python : 3.7.3OS : Ubuntu 18.04.2 LTSIDE : pycharm-community-2019.1.3Conda : 4.7.5typesetting : Markdowncodecoder@ubuntu:~$ source activate py37(py37) coder@ubuntu:~$ ipythonPython 3.7.3 (default, Mar...
  • 字符串操作:~.lower()———字符串小写显示~.upper()———字符串大写显示~.split(‘ ’)————拆分字符串列表操作:Z=[~:~]: first index is inclusive,and the last ...对列表对象出现次数进行统计z.cou...
  • dir(__builtins__)//查看内置函数(BIF)列表2 [‘ArithmeticError‘, ‘AssertionError‘, ‘AttributeError‘,3 ‘BaseException‘, ‘BlockingIOError‘, ‘BrokenPipeError‘, ‘BufferError‘, ‘BytesWarning...
  • 序列是Python中最基本数据结构。...那么列表有什么内置函数可以使用,怎么使用这些函数。count() 方法用于统计某个元素在列表中出现次数。count()方法语法:list.count(obj)参数:obj:列表中统计...
  • 一、列表list一个队列,一个排列整齐队伍,列表个体称作元素,由若干元素组成的列表,元素可以是任意对象(数字,字符串,对象,列表等)列表内元素有顺序,可以使用索引,线性数据结构,使用[]表示,列表是可...
  • map:处理序列中每个元素,得到结果是一个'列表'(可迭代对象),改'列表'元素个数及位置与原来一样filter:遍历序列中每个元素,判断每个元素得到布尔值,如果是True则留下来text =[{"name" : "wangshe","age...
  • python的内置函数:reversed() 函数返回一个反转的迭代器。reversed(seq)要转换的序列,可以是 tuple, string, list 或 range。range()函数可创建一个整数列表,一般用在 for 循环中。语法:range(start, stop[, ...
  • zip()函数用于将可迭代对象作为参数,将对象中对应元素打包成一个个元组,然后返回由这些元组组成的列表。如果各个迭代器元素个数不一致,则返回列表长度与最短对象相同,利用 * 号操作符,可以将元组解压为...
  • Python的内置函数

    2020-08-18 16:37:06
    前言:本文主要介绍Python的内置函数的一些基本的使用,可能会咕咕咕。 dir(__builtins__)dir(\_\_builtins\_\_)dir(__builtins__) 查看内置列表。 0.help(BIF)0.help(BIF)0.help(BIF) BIF:built in ...
  • 分享给大家供大家参考,具体如下:列表对象提供了sort()方法支持原地排序,而内置函数sorted()不支持原地操作只是返回新的列表,并不对原列表进行任何修改。sorted()方法可以对列表、元组、字典、range对象等进...
  • filter()函数过滤器用于过滤序列,过滤掉不符合条件元素,返回一个迭代器对象,如果要转换为列表,可以使用 list() 来转换。该接收两个参数,第一个为函数,第二个为序列,序列每个元素作为参数传递给函数进行判...
  • list2 比较两个列表的大小,Python会直接从列表的第0个元素进行比较,若相等,则继续下一个比较得到结果是布尔值二、逻辑操作符1 List1 = [123,234]2 list2 = [123,345]3 List1 < list24 True56 List1 and ...
  • map是Python的内置函数, 使用的方式如下;list = map(func, iter)其中, func是函数, iter是可迭代的序列。它的功能是:将一个序列中的每一个元素应用传入的函数, 并返回一个包含所有函数调用结果的一个列表.举一个...
  • 一.python内置函数1.id()返回对象内存地址a = 1print id(a)print id(1)2.int()用于将数据类型转换为整型a = "1"b = 2print int(a) + b3.str()用于将数据类型转换为字符串age = 18name = "zhengying"print name + ...
  • python提供了一个内联... 模块的内置函数: 1、apply():可以调用可变参数列表的函数,把参数存在一个元组或者序列中,apply元组参数必须和sum()的参数一致 #!/usr/bin/python # -*- coding:utf8 -*- def sum(x=1,...
  • sorted作为python的内置全局方法,用于可迭代序列的排序。sorted函数接受3个参数:sorted(iterable,key,reverse)sorted函数有以下特点:1)对列表排序,返回的对象不会改变原列表>>> list =[1,2,3,6,4,5]>...
  • 我试图用一个规范例子来说明如何获取Python中所有内置函数的列表。文档很好,但是我想用一种可证明方法来演示它。在在这里,我本质上是将内置函数定义为默认名称空间成员,这些成员是可用,并且与要在模块中...
  • python内置了一些非常巧妙而且强大的内置函数,对初学者来说,一般不怎么用到,我也是用了一段时间python之后才发现,哇还有这么好的函数,这个函数都是经典的而且经过严格测试的,可以一下子省了你原来很多事情,...
  • (红色字体为重点掌握内置函数)上面便是内置函数列表,按首字母排序,难免看起来混乱无序,不便于记忆;下面把这些函数分成了6大类。由于学习进度原因,此处只写标红四大块(56个方法)~作用域相关:基于字典形式...
  • /usr/bin/python# -*- coding=utf-8 -*-from __future__ import divisiondef count(x,y,operate):result = {"+":x+y,"-":x-y,"*":x*y,"/":x/y}return result.get(operate)print count(2,3,"*")#把列表作为参数传递及...
  • 说明:zip()函数用于将可迭代对象作为参数,将对象中对应元素打包成一个个元组,然后返回由这些元组组成的列表。如果各个迭代器元素个数不一致,则返回列表长度与最短对象相同,利用 * 号操作符,可以将元组...
  • 1、input()输入内容时要将内容用引号引起来:input("...)input("请输入登录名:")name = input("... name)>>>请输入姓名:Binla>>>Hello,Binla2、append()在列表后边追加一个元素3、extend([])在...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,331
精华内容 2,132
关键字:

python的内置函数列表

python 订阅