自己整理的Python的常用函数

作者: 消失黎明 | 来源:发表于2019-06-02 10:23 被阅读0次

    sys.stdin.readline( )会将标准输入全部获取,而input()不会获取字符串末尾的换行符。

    set 用法

    set() 函数创建一个无序不重复元素集,可进行关系测试,删除重复数据,还可以计算交集、差集、并集等。

    收件人去重,并保持原来的收件人顺序

    mailto = ['cc', 'bbbb', 'afa', 'sss', 'bbbb', 'cc', 'shafa']
    addr_to = list(set(mailto))
    addr_to.sort(key = mailto.index)
    
    随机数
    import random 
    random.randint(1,10)    #no. between 0 and 10
    
    字符串转换为ASCII
    ord(str)
    
    ASCII转换为字符串
    chr(ascii)
    
    十六进制转换为十进制
    while True:
        try:
            string = input()
            print(int(string, 16))
        except:
            break
    

    怎么判断键是否为空

    #生成一个字典
    d = {'name':Tom, 'age':10, 'Tel':110}
    #打印返回值
    print d.has_key('name')
    #结果返回True
    
    遍历字典键值
    for key,value in a.items():
           print(key+':'+value)
    
    检验字符串中某个字符出现的次数
    str.count(sub, start=0, end=len(string))
    --sub 搜索的子字符串
    --start 字符串开始搜索的位置
    --end 字符串中结束搜索的位置
    
    返回一个二进制数
    -- bin() 返回一个整数 int 或者长整数 long int 的二进制表示。
    >>> bin(10)
    '0b1010'
    >>> bin(20)
    '0b10100'
    -- 为了将一个数字转换为八进制数,可以使用oct().
    -- 为了将一个数字转为十六进制数,可以使用hex().
    
    输入字符串分为两个整型变量
    N,m = map(int,raw_input().split())
    
    创建一个二维矩阵的方法
    a = [[0]*(N+1) for _ in range(m+1)]
    dp = [[0 for i in range(N+1)] for j in range(m+1)]
    -- 表示a包含有m+1个子列表,其中每一个子列表都包含有N+1个元素
    
    判断字符串为空
    str=""
    if str.strip()=="":
        print("str is null")
    if not str.strip():
        print("str is null")
    
    如何验证一个字符串是否包含有相同长度超过2的子串
    def fun3(s):
        for i in range((len(s)-3)):
             if s[i:i+3] in s[i+1:]:
                 return False
                 break
        return True
    
    删除字典元素的方法
    • 如果是清空字典中所有元素信息,clear()方法是用来清除字典中的所有数据,因为是原地操作,所以返回None(也可以理解为没有返回值)
    >>> x['name'] = 'lili'
    >>> x['age'] = 20
    >>> x
    {'age': 20, 'name': 'lili'}
    >>> returned_value = x.clear()
    >>> x
    { }
    >>> print returned_value
    None
    
    • 如果是删除指定信息,移除字典数据pop()方法的作用是:删除指定给定键所对应的值,返回这个值并从字典中把它移除。注意字典pop()方法与列表pop()方法作用完全不同。
    >>> x = {'a':1,'b':2}
    >>> x.pop('a')
    1
    >>> x
    {'b': 2}
    
    怎么根据字典的值查找对应的key
    student = {'小萌': '1001', '小智': '1002', '小强': '1003', '小明': '1004'}
    -- 充分利用 keys() 、values()、index() 函数
    >>> list (student.keys()) [list (student.values()).index ('1004')]
    最终得到结果是:'小明'
    
    判断字符串中的所有字符是否为 字母/数字/字母数字的组合
    #用isdigit函数判断是否数字
    print(str_1.isdigit())
    Ture
    print(str_2.isdigit())
    False
    print(str_3.isdigit())
    False
    
    #用isalpha判断是否字母
    print(str_1.isalpha())    
    False
    print(str_2.isalpha())
    Ture    
    print(str_3.isalpha())    
    False
    
    #isalnum判断是否数字和字母的组合
    print(str_1.isalnum())    
    False
    print(str_2.isalnum())
    False
    print(str_1.isalnum())
    
    如何将列表变为带索引的序列

    enumerate()函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中。

    >>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']
    >>> list(enumerate(seasons))
    [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
    >>> list(enumerate(seasons, start=1))       # 小标从 1 开始
    [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
    
    python 怎么对一个数字进行开方
    • 使用math模块
    import math
    math.sqrt(144) # 12
    
    • 使用内置函数pow
    pow(144, 0.5) # 12
    
    • 使用数学表达式
    144**0.5 # 12.0
    
    字符串替换其中某一个字符
    str.replace(c,'haha')
    
    字符串比较
    >>> import operator
    >>> operator.eq('hello', 'name');
    False
    >>> operator.eq('hello', 'hello');
    True
    
    使用正则表达式切分字符串
    import re
    re.split(rex, str)
    -- rex 正则表达式格式
    -- str 要被切分的字符串
    
    python strip()
    a = '*'
    str.strip()  -- 删除字符串左右的*符号
    str.lstrip(a)  -- 表示删除字符串左边的*符号
    str.rstrip(a)  -- 表示删除字符串右边的*符号
    
    向一个列表中的指定位置插入和删除元素
    • 快速创建一个list
    1. split方法
    a_List = str.split('sep')
    
    2. list函数和range函数
    a_List = list(range(10))
    
    • 新增item
    1. concatenation添加
    这种方法添加的是另外一个列表,且两个列表可以组合成为一个新的列表,例如:
    a_List = a_List + [1,0,2]
    
    2. append方法添加。
    该方法在原列表末尾添加一个item,item的类型任意
    a_List.append('hello')      //在原有列表末尾添加一个类型为字符串的item
    a_List.append(['hello'])        //在原有列表末尾添加一个类型为列表的item
    
    3. extend方法添加
    类似于concatenation,只接受列表参数,然后把列表中的item分解,最后添加到原有列表
    a_List.extend('hello')      //在原有列表末尾添加5个字符item,因为它把hello视为列表
    >>> a.extend('hello')
    >>> a
    ['wang', 'h', 'e', 'l', 'l', 'o']
    
    a_List.extend(['hello'])    //在原有列表末尾添加1个item
    
    4.insert方法添加
    insert()方法,可以在原列表中插入item
    a_list.insert(0,'c')   //在原有列表的0位置添加一个字符
    a_list.insert(0.['c'])   //在原有列表的0位置添加一个列表
    
    • 删除元素有三种方法:
    1. remove: 删除单个元素,删除首个符合条件的元素,按值删除
    举例说明:
    >>> str=[1,2,3,4,5,2,6]
    >>> str.remove(2)
    >>> str
    [1, 3, 4, 5, 2, 6]
    
    2. pop:  删除单个或多个元素,按位删除(根据索引删除),同时返回被删除的item值;若不指定索引,默认删除最后一个item
    举例说明:
    >>> str=[0,1,2,3,4,5,6]
    >>> str.pop(1)   #pop删除时会返回被删除的元素
    1
    >>> str
    [0, 2, 3, 4, 5, 6]
    
    3. del:它是根据索引(元素所在位置)或者切片来删除
    举例说明:
    
    del a_List[0]    //删除列表的第一个值
    del a_List[:2]  //删除列表的前两个值
    
    
    • 其他
    检索列表的值,四种方式:in、not in、count、index,后两种方式是列表的方法。
    示例列表:a_list = ['a','b','c','hello']:
    判断值是否在列表中,in操作符:
    'a' in a_list  //判断值a是否在列表中,并返回True或False
    
    判断值是否不在列表,not in操作符:
    'a' not in a_list   //判断a是否不在列表中,并返回True或False
    
    统计指定值在列表中出现的次数,count方法:
    a_list.count('a')  //返回a在列表中的出现的次数
    
    查看指定值在列表中的位置,index方法:
    a_list.index('a')   //返回a在列表中每一次出现的位置,默认搜索整个列表
    a_list.index('a',0,3)  //返回a在指定切片内第一次出现的位置
    
    字符串大小写转换
    str.lower()
    str.upper()
    
    深拷贝和浅拷贝
    # 对于数字和字符串而言,深拷贝,浅拷贝都一样,因为永远指向同一个内存地址
    import copy
    n1 = 123
    n2 = n1
    print(id(n1))
    print(id(n2))
    n2 = copy.copy(n1)
    n2 = copy.deepcopy(n1)
    # 对于字典,元组,列表而言,进行赋值、浅拷贝和深拷贝时,其内存地址的变化是不同的
    1. 赋值。只创建一个变量,且该变量指向原来的内存地址。
    2. 浅拷贝,在内存中只额外创建第一层数据
    3. 深拷贝。在内存中将所有数据重新创建一份
    
    怎么样直接获取整除和求余的结果
    c, d = divmod(m, n)
    -- 其中,c = m//n, d = m%n
    
    什么是python的函数闭包

    在一个内部函数里,对外部作用域(但不是全局作用域)的变量进行引用,那么内部函数和它的环境变量结合在一起,就形成了一个闭包。
    局部作用域可以访问外部作用域,但是不能更改外部作用域中的变量,一旦进行了修改,就会将外部作用域中的变量当成是一个局部变量。
    为了解决这个问题,可以在内部函数中重新声明一个变量,使用关键字nonlocal使得解释器能够从外部作用域查找变量名。

    创建闭包的条件:
    闭包函数中存在执行完毕仍然存在的对象

    newinit的区别
    1. 其中,init主要是用于初始化实例,如果要新添加属性,可以使用。new主要是用于生成实例,当继承一些不可变动的类,比如str,int,等,可以使用new来进行重载。
    2. init是当实例对象创建完成以后被调用的,然后设置实例对象属性的一些初始值,而new则是实例在创建之前被调用,她的作用是创建实例并返回这个实例。
      也就是说,newinit之前被调用,new的返回值将传递给init方法的第一个参数,然后init给这个实例设置一些参数。
    单个下划线 _ 与双下划线__的区别
    • 单下划线
    1. 解释器。 单下划线在交互解释器中最后一次执行语句的返回结果。
    2. 作为名称使用。 单下划线被用作一个被丢弃的名称,例如: n = 42
      for _ in range(n):
      print('hello')
    3. _还可以被用作函数名。这种情况,单下划线经常被用作国际化和本地化字符串翻译查询的函数名。
      以单下划线做前缀的名称指定了这个名称是“私有的”。
    • 双下划线
    1. 任何__spam这种形式(至少以两个下划线做开头,绝大部分都还有一个下划线做结尾)的标识符,都会文本上被替换为_classname__spam,其中classname是当前类名,并带上一个下划线做前缀。
    2. 另一种是魔术变量: spam
    python的自省有哪些

    type()/ dir()/ getattr()/ hasattr()/ isinstance()

    待更新...

    python 怎么调用shell脚本
    test.sh:                                                                                                                                     
    #!/bin/bash
    
    echo "hello world!" 
    exit 3
    
    如果我们需要获得os.system的正确返回值,那使用位移运算可以还原返回值: 
    >>> n = os.system(test.sh) 
    >>> n >> 8 
    >>> 3
    
    os.popen(cmd):
    
    这种调用方式是通过管道的方式来实现,函数返回一个file-like的对象,里面的内容是脚本输出的内容(可简单理解为echo输出的内容)。使用os.popen调用test.sh的情况: 
    >>> file = os.popen(test.sh) 
    >>> file.read() 
    >>> ‘hello world!\n’
    

    相关文章

      网友评论

        本文标题:自己整理的Python的常用函数

        本文链接:https://www.haomeiwen.com/subject/anfztctx.html