>

tuple应用详解,Python基本语法

- 编辑:www.bifa688.com -

tuple应用详解,Python基本语法

一、高德软件有限公司python试题及答案

  1. Python的两种运行模式:
    • 命令行模式,运行python,然后在命令行中输入python命令
    • 程序脚本, 在命令行中输入 ./hello.py运行
  2. Python是解释形语言,但可以通过工具打包成二进制可执行文件
  3. 指定Python文件的编码方式:#coding:utf-8
  4. 注释符为#,多行注释以'''开始,以'''结束
  5. 变量不需要声明类型,可以自动推导,type()函数可以获得变量类型
  6. 序列(sequence)是一组由顺序的元素的集合,各元素类型可以不同,序列分三种
    • tuple(元组):tuple中的元素不可以变更,用()定义,也可以省略(),字符串是一种特殊元组
    • list:各个元素可以再变更,用[]定义
    • range:表示由数字组成的不可变序列,通常用于循环

python的dict,set,list,tuple应用详解,dicttuple

本文深入剖析了python中dict,set,list,tuple应用及对应示例,有助于读者对其概念及原理的掌握。具体如下:

1.字典(dict)

dict 用 {} 包围
dict.keys(),dict.values(),dict.items()
hash(obj)返回obj的哈希值,如果返回表示可以作为dict的key
del 或 dict.pop可以删除一个item,clear清除所有的内容
sorted(dict)可以把dict排序
dict.get()可以查找没存在的key,dict.[]不可以
dict.setdefault() 检查字典中是否含有某键。 如果字典中这个键存在,你可以取到它的值。 如果所找的键在字典中不存在,你可以给这个键赋默认值并返回此值。
{}.fromkeys()创建一个dict,例如:

{}.fromkeys(('love', 'honor'), True) =>{'love': True, 'honor': True} 

不允许一个键对应多个值
键值必须是哈希的,用hash()测试
一个对象,如果实现_hash()_方法可以作为键值使用

2.集合(set)

集合是一个数学概念,用set()创建

set.add(),set.update.set.remove,添加更新删除,-= 可以做set减法
set.discard 和 set.remove不同在于如果删除的元素不在集合内,discard不报错,remove 报错
< <= 表示 子集,> >=表示超集
| 表示联合 & 表示交集 - 表示差集 ^ 差分集

3.列表(list)

列表是序列对象,可包含任意的Python数据信息,如字符串、数字、列表、元组等。列表的数据是可变的,我们可通过对象方法对列表中的数据进行增加、修改、删除等操作。可以通过list(seq)函数把一个序列类型转换成一个列表。

append(x) 在列表尾部追加单个对象x。使用多个参数会引起异常。
count(x) 返回对象x在列表中出现的次数。
extend(L) 将列表L中的表项添加到列表中。返回None。
Index(x) 返回列表中匹配对象x的第一个列表项的索引。无匹配元素时产生异常。
insert(i,x) 在索引为i的元素前插入对象x。如list.insert(0,x)在第一项前插入对象。返回None。
pop(x) 删除列表中索引为x的表项,并返回该表项的值。若未指定索引,pop返回列表最后一项。
remove(x) 删除列表中匹配对象x的第一个元素。匹配元素时产生异常。返回None。
reverse() 颠倒列表元素的顺序。
sort() 对列表排序,返回none。bisect模块可用于排序列表项的添加和删除。

4.元组(tuple)

tuple=(1,),这是单个元素的元组表示,需加额外的逗号。
tuple=1,2,3,4,这也可以是一个元组,在不使用圆括号而不会导致混淆时,Python允许不使用圆括号的元组。
和列表一样,可对元组进行索引、分片、连接和重复。也可用len()求元组长度。 
元组的索引用tuple[i]的形式,而不是tuple(i)。
和列表类似,使用tuple(seq)可把其它序列类型转换成元组。

1. 在python中, list, tuple, dict, set有什么区别, 主要应用在什么样的场景?

  1. 一个序列可以作另一个序列的元素,用[]可以访问序列元素,也可以使用范围引用,表达式为[下限:上限:步长],获取的数据索引到上限前一个元素
  2. 列表推导(list comprehension):快速生成表(list)的方法,示例:
    L=[x**2 for x in range(10)],这与生成器表达式类似,只不过用的是中括号
  3. 词典类型的定义dic={key1:value1,key2:value2},key可以使字符串,数字,bool型等,不可变对象都可以做键,创建字典的方法有: 图片 1图片 2

    dict exampledict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
    #{'sape': 4139, 'jack': 4098, 'guido': 4127}
    
    {x: x**2 for x in (2, 4, 6)}
    #{2: 4, 4: 16, 6: 36}
    
    dict(sape=4139, guido=4127, jack=4098)
    #{'sape': 4139, 'jack': 4098, 'guido': 4127}
    

    字典的循环如下,注意循环的key值
    for key in dic:
        print(dic[key])

  4. 字典的常用函数: keys(),values(),items(),clear(),还有一个常用用法是del dic['Tom'],删除key为Tom的元素,del是Python中的关键字,不是函数,用于删除对象
  5. set:不重复元素的集合,可以用大括号或者set()函数创建set,set支持,支持交集,并集,差集等运算,并且也支持列表推导 图片 3图片 4

    set examplebasket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
    print(basket)#返回{'orange', 'banana', 'pear', 'apple'}
    
    #定义空集
    a=set()#注意{}定义的是空词典b={}
    
    a = set('abracadabra')
    b = set('alacazam')
    print(a)#{'a', 'r', 'b', 'c', 'd'}
    print(a-b)#{'r', 'd', 'b'}
    
    #列表推导,注释是大括号
    a = {x for x in 'abracadabra' if x not in 'abc'}
    print(a)#{'r', 'd'}
    
  6. 函数定义的关键字:def, return可以返回多个值,如return a,b,c,相当于return(a,b,c)

    • 函数参数的传递,可以使用关键字传递参数,这样不用遵守位置的对应关系。定义函数时参数可以指定默认值
    • 包裹参数传递:定义函数时在相应的元组或者字典前加*或者**,如
      • func(*arr):arr是一个tuple,调用时,func(1,2,3,4)
      • func(**dic):dic是一个字典,调用时,func(a=1,b=2,c=3)
    • 解包裹:函数定义时未使用包裹参数,调用时传入包裹参数,函数会自动进行拆解,注意调用时,参数值前要加*或者**,对应tuple和字典,如:

      def func(a,b,c): 
            print(a,b,c)
      args = (1,3,4)
      func(*args) 
      
    • 函数也是对象,也可以作为参数传给其他函数

  7. python中一切都是对象,class是对象,实例也是对象,python中所有对象都允许动态添加属性和方法,当类添加新属性后,类的实例同样能访问该属性。当访问一个对象的属性如obj.age时,查找该属性的顺序为:
    • 对象自身的属性(obj.__dict__中)
    • 对象的类属性(obj.__class__.__dict__中)
    • 对象的类的基类,以及基类的基类(obj.__class__.__bases__中的每一个类的__dict__),一直下去
    • 最后未找到属性,会抛出AttributeError异常
  8. Python使用class定义类,类的实例方法第一个参数必须是self,用于引用对象本身,类似于this,类的成员以self.member形式在类中访问,python中没有public,private等关键字,类成员默认都为公开的,类的私有成员命名必须以__开始,在python内部使用name mangling技术将__membername重命名为_class__membername(classname是成员所在的类名),所以使用原有的私有成员名字会提示找不到,但使用_classname__membername仍然可以访问该私有变量,所以python的私有成员不是绝对无法访问的.注意以__开始__结尾的成员是系统保留名字,普通变量不能这样命名
  9. python的类方法包括三种:

    • 实例方法,至少带一个self(其他名也可以)参数,表示实例本身,由类的实例访问,也可以由类直接访问,但第一个参数的含义就变了 图片 5图片 6

      实例方法class A:
          def test(self,age):
              print("hello")
      
      #self='b'
      A.test('b','c')
      a=A()
      #self=a,也可以写为A.test(a,’c’)
      a.test('c')
      
    • 带@classmethod装饰器的方法,至少带一个参数cls,表示类本身可以通过类名访问也可以通过实例访问

    • 带@staticmethod装饰器的方法,可以不带参数,由类或者类的实例访问
  10. python class中的”静态方法”和”静态成员”:在python类作用域中,不带self参数的方法和不使用self访问的成员起到静态成员的作用。对静态成员要注意:
    • 静态成员使用class.member或者instance.member都可以访问(如果没有同名的实例成员,有则访问实例成员). class是类名,instance是类的实例
    • 如果静态成员是值类型,为instance.member赋值相当于新建一个与该静态成员同名的实例成员,不会影响class.Member的值,之后对class.member的改动不会反应到instance.member。如果未对instance.member进行赋值,对class.member的改动会反应到instance.member
    • 如果静态成员是引用类型,则对instance.member的改动会反应到class.member,也会反应到其他同类型实例的member
  11. 继承的语法: class SubClass(ParentClass1,ParentClass2), ParentClass是父类,SubClass是子类

python 概念 list,string,tuple 类型不同 以及 数据类型不同

标准答案我是不知道,但是string的元素只能是字符;而list, tuple中的元素几乎可以为任意类型(包括list, tuple, dict等)。  

定义:

  1. _特殊方法(special method):通过特殊的语法实现某些操作,是python实现操作符重载的方式,常用特殊方法有:
    • object.__new__(cls,…):是一个静态方法(特殊方法,不用像声明静态函数那样声明),用于创建一个类对象,创建出的对象会传递给__init__的self参数,函数的其余参数也传递给__init__。函数的参数由构造函数而来。如果子类中重写了__new__函数,实例化对象时会调用子类的__new__,子类的__new__方法可以显示调用基类的__new__,否则不会调用基类的__new__,子类如果没重写__new__则调用基类的__new__.
    • object._init__(self,…):相当于初始化过程。如:human = Human("male"); 参数male先传给__new__再传给__init__()方法,如果父类有__init__函数,子类重写了__init__函数,应当在子类的__init__中调用父类的__init__函数以完成初始化,否则不会自动调用父类的__init__函数,如果子类没有重写__init__函数,实例化子类时则会调用父类的__init__函数
    • object.__del__():析构器,父类中如果有__del__函数,应该在子类的__del__函数中显示调用此函数以确保资源被正常释放
    • object.__call__():定义类型时,如果实现了实例方法__call__,那么实例就是可调用的,如x(5),相当于调用了x.__call__(5).如果是metaclass定义了__call__函数,那么其创建的类就是可调用的,与类实现__call__,则其实例是可调用的是一个道理
    • object__repr__():返回对象的offical representation string, 对于许多类型,将返回值传给eval()函数可以得到一个具有相同值得对象
    • object.__str__():返回对象的informal representation string
    • object.__bytes__():返回对象的byte-string representation
    • class.__subclasses__():返回直接集成该类的子
  2. 特殊属性(special attributes):只读属性,常用特殊属性有:

    • object.__dict__:字典类型,存储对象的属性,不包括只读属性.要注意的是类实例的__dict__中不含其class.__dict__中的值,只包含实例本身的属性和新加的属性。
    • instance.__class__:对象的类型,准确说是创建该instance的类
    • class.__bases__:类的基类的元组,只有类类型才有该属性,实例没有 图片 7图片 8

      __class__ __bases__ example#返回<class 'type'>,因为int 类是由type类创建的对象
      int.__class__
      #返回<class 'object'>,int类的基类是object
      int.__bases__
      
      x="abc"
      #返回<class 'str'>x是由str类创建的对象
      x.__class__
      
    • class.__name__:类名

    • class.__mro__:一个class的tuple,当解析方法时按照tuple中定义类的顺序查找基类中的方法
    • class.__module__:class所属的模块名
  3. python descriptor:如果定义的类(对象)具有__get__,__set__,__delete__方法中的任意一个,这个类(对象)就叫descriptor,作用是拦截属性的访问.descriptor属性会改变普通属性访问时的查找 图片 9图片 10

    descriptor exampleclass Descriptor(object):
        def __init__(self, label):
            self.label = label
     #本例中,instance是f,owner是Foo
        def __get__(self, instance, owner):
            print( '__get__', instance, owner)
            return instance.__dict__.get(self.label)
    
        def __set__(self, instance, value):
            print ('__set__')
    #使用__dict__生成实例属性,可以防止所有的实例都同样的值,因为descriptor是类属性
            instance.__dict__[self.label] = value
    
    class Foo(list):
    #decriptor只能应用与类属性,不能用于实例属性
        x = Descriptor('x')
        y = Descriptor('y')
    
    f = Foo()
    f.x = 5#会调用__set__
    print(f.x)#会调用__get__
    

Python 中的列表 List 是可以改变的, 元组 Tuple 是不可以改变的, 那什情况下要用到 tuple ?

Tuple 是不可变 list。 一旦创建了一个 tuple 就不能以任何方式改变它。

Tuple 与 list 的相同之处

定义 tuple 与定义 list 的方式相同, 除了整个元素集是用小括号包围的而不是方括号。
Tuple 的元素与 list 一样按定义的次序进行排序。 Tuples 的索引与 list 一样从 0 开始, 所以一个非空 tuple 的第一个元素总是 t[0]。
负数索引与 list 一样从 tuple 的尾部开始计数。
与 list 一样分片 (slice) 也可以使用。注意当分割一个 list 时, 会得到一个新的 list ;当分割一个 tuple 时, 会得到一个新的 tuple。

Tuple 不存在的方法

您不能向 tuple 增加元素。Tuple 没有 append 或 extend 方法。
您不能从 tuple 删除元素。Tuple 没有 remove 或 pop 方法。
您不能在 tuple 中查找元素。Tuple 没有 index 方法。
然而, 您可以使用 in 来查看一个元素是否存在于 tuple 中。

用 Tuple 的好处

Tuple 比 list 操作速度快。如果您定义了一个值的常量集,并且唯一要用它做的是不断地遍历它,请使用 tuple 代替 list。
如果对不需要修改的数据进行 “写保护”,可以使代码更安全。使用 tuple 而不是 list 如同拥有一个隐含的 assert 语句,说明这一数据是常量。如果必须要改变这些值,则需要执行 tuple 到 list 的转换。

Tuple 与 list 的转换
Tuple 可以转换成 list,反之亦然。内置的 tuple 函数接收一个 list,并返回一个有着相同元素的 tuple。而 list 函数接收一个 tuple 返回一个 list。从效果上看,tuple 冻结一个 list,而 list 解冻一个 tuple。

Tuple 的其他应用
一次赋多值
>>> v = ('a', 'b', 'e')
>>> (x, y, z) = v
解释:v 是一个三元素的 tuple, 并且 (x, y, z) 是一个三变量的 tuple。将一个 tuple 赋值给另一个 tuple, 会按顺序将 v 的每个值赋值给每个变量。  

本文深入剖析了python中dict,set,list,tuple应用及对应示例,有助于读者对其概念及原理的掌握。具体如...

list: 链表, 有序的项目, 通过索引进行查找, 使用方括号"[]";

  1. 模块(Module):一个.py文件就是一个模块,模块名必须是小写字母和下划线,使用import关键字引入其他模块,使用模块.对象的方式来访问引入模块中的对象.每个模块中都有一个内置变量__name__,如果是模块自己运行,__name__=’__main__’,如果被其他模块import,则模块的__name__就是等于模块名(不包含扩展名),python中所有加载到内存的模块都放在sys.modules中,import一个模块时会首先查找这个列表。import的模块会被加入当前模块的名字空间,import模块时会执行模块中的代码,import package时则会执行__init__.py中的代码
  2. import的一些用法:
    • import a as b :引入模块a,并重命名为b
    • from a import func1: 从模块a中引入func1对象,之后可以直接使用func1,而不用使用a.func1
    • from a import *:从模块a中引入所有对象,这样可以直接使用a中的对象,而不必用a.对象
    • module或package所在的目录再sys.path中,那么就可以import模块或package
  3. Python会在以下路径搜索它想要的模块:
    • 程序所在的文件夹
    • 标准库的安装路径
    • 操作系统环境变量PYTHONPATH所包含的路径

tuple: 元组, 元组将多样的对象集合到一起, 不能修改, 通过索引进行查找, 使用括号"()";

  1. package:功能相似的模块放在同一个文件夹中,就构成一个package,文件夹中必须包含一个__int__.py的文件(可以为空)以通知Python,该文件夹是一个package,通过:
    import dir.module引用dir文件夹中的module
  2. 用于循环的函数:
    • range:
    • enumerate():可以在每次循环中同时得到下标和元素,for(index,value) in enumerate(arr)
    • zip():用于循环多个等长序列,每次循环从各个序列中分别取一个元素,for(a,b,c)in zip(arr1,arr2,arr3).zip的作用就是从各个序列中依次取出一个元素,合成一个tuple,返回值是一个zip类型对象,可以用list()函数转换为list类型
  3. 生成器(Generator):构建一个用户自定义的循环对象,编写方法与函数类似,只是return改为yield,可以有多个yield,generator遇到yield时会暂停运行返回yield后面的值,再次调用生成器的时候,会从暂停的地方继续运行,返回下一个yield值。生成器示例:
    G=(x for x in range(4)),G就是一个生成器,用__next__()方法访问其中的值
  4. 可迭代对象(iterable):python自带的iterable包括,list,str,tuple,dict ,file,自定义了__iter__()或者__getitem__()类的实例也是,iterable.iter(iterable)就返回这个对象的迭代器
  5. 迭代器(iterator):__iter__方法就返回一个迭代器,迭代器可以使用next方法调用,也就是它实现了__next__方法,将一个class实现为迭代器它必须实现__iter__()和__next__()方法.迭代器只能向前迭代,不能回退,直到抛出StopIteration,不是线程安全的。for关键字是迭代器的语法糖,封装了迭代器的循环操作。python自带的类型tuple,list,set,dict,字符串都支持迭代器
  6. lambda:示例 func=lambda x,y:x y 调用跟普通函数一样,func(3,5)
  7. 异常语法如下,自己抛出式样使用raise关键字

dict: 字典, 字典是一组键(key)和值(value)的组合, 通过键(key)进行查找, 没有顺序, 使用大括号"{}";

     try:
        ... 
    except exception1:
        ... 
    except exception2:
        ... 
    except:
        ... 
    else:
        ... 
    finally:
        ...

如果没有异常,则执行else语句,如果没有对应的异常类型则会向上层抛出异常  

set: 集合,无序, 元素只出现一次, 自动去重, 使用"set([])";

  1. 上下文管理器:用于规定某个对象的使用范围,语法:with ....as...,任何定义了__enter__()和__exit__()方法的对象都可用于上下文管理器

    # with context manager 
    with open("new.txt", "w") as f:  
         print(f.closed)
         f.write("Hello World!") print(f.closed)
    
  2. 对象的Property(attribute的一种):使用内置函数property()来返回一个property,签名如下: property(fget=None, fset=None, fdel=None, doc=None)

    • fget:获取property value的函数,只传递此参数,省略其他参数,将会得到只读property

    • fset:设置property value的函数

    • fdel:删除property的函数

    • doc:property的注释字符 图片 11图片 12

      property exampleclass C:
          def __init__(self):
              self._x = None
      
          def getx(self):
              return self._x
          def setx(self, value):
              self._x = value
          def delx(self):
              del self._x
          x = property(getx, setx, delx, "I'm the 'x' property.")
      
      c=C();
      //调用getx
      a=c.x
      //调用setx
      c.x=9;
      //调用delx
      del c.x
      
  3. 可以把@property当做一个装饰器,如下代码效果同上: 图片 13图片 14

    property exampleclass C:
        def __init__(self):
            self._x = None
    
        @property
        def x(self):
            """I'm the 'x' property."""
            return self._x
    #函数名要与property name相同
        @x.setter
        def x(self, value):
            self._x = value
    
        @x.deleter
        def x(self):
            del self._x
    
  4. 通过自定义object.__getattr__函数,在对象引用的attribute不存在时自动调用该函数,此函数中返回attribute的值或者raise AttributeError exception.注意与obj.__getattribute__函数的区别,后者在每次属性访问时都会先调用,如果属性不存在才会接着调用__getattr__

    图片 15图片 16

    __getattr__ exampleclass Person():
    
        def __init__(self, age):
            self.age = age
        def __getattr__(self, name):
            if name == 'adult':
                if self.age > 18: return True
                else: return False
            else: raise AttributeError(name)
    
    person = Person(20)
    #类中未定义adult attr
    print(person.adult)
    
     
    
  5. 闭包:Python中的闭包是一个包含有环境变量取值的函数对象,环境变量取值被保存在函数对象的__closure__属性中

  6. 装饰器:对一个函数,方法或者类进行加工,可以使用def定义装饰器,被装饰函数或类前要加@装饰器函数,实际上将square_sum传递给decorator,并将decorator返回的新的可调用对象赋给原来的函数名,即square_sum=decor(square_sum) ,square_sum变成了new_F函数

    def decor(F): 
        def new_F(a,b):
            print('decor')   
            return F(a,b)
        return new_F
    
    @decor
    def square_sum(a, b):    
        return a**2   b**2
    
    print(square_sum(2,3))#调用的是new_F函数
    print(square_sum(4,3))
    

应用场景: 

  1. 装饰器即装饰器类示例

    图片 17图片 18

    decoratordef decorator(func): # 装饰器函数
        print('in decorator')
        def wrapper(*args):
            print('in decorator wrapper')
            wrapper._calls  = 1
            print("calls = %d" % (wrapper._calls))
            func(*args)
        wrapper._calls = 0
        return wrapper
    
    @decorator
    def foo(x, y):
        print("x = %d, y = %d" % (x, y))
    
    foo(1, 2) # foo对象就被赋成了wrapper对象
    """
    in decorator #定义foo时就会输出
    in decorator wrapper
    calls = 1
    x = 1, y = 2
    """
    
    foo(2, 3)
    """
    in decorator wrapper
    calls = 2
    x = 2, y = 3
    """
    #################下面是一个装饰类################################################
    class decorator: #装饰器类
        def __init__(self, func):
            print('in decorator __init__')
            self.func = func
            self.calls = 0
        def __call__(self, *args):
            print('in decorator __call__')
            self.calls  = 1
            print("calls = %d" % (self.calls))
            self.func(*args)
    
    @decorator
    def foo(x, y):
        print("x = %d, y = %d" % (x, y))
    
    foo(1, 2) # foo对象被赋值成了decorator对象
    #执行过程先以foo为参数初始化decorator对象,调用foo(1,2)时则会调用decorator的__call__
    """
    in decorator __init__ #定义foo时输出
    in decorator __call__
    calls = 1
    x = 1, y = 2
    """
    
    foo(2, 3) # 实际是调用decorator对象
    """
    in decorator __call__
    calls = 2
    x = 2, y = 3
    """
    
     
    
  2. 格式化字符串:Python使用一个字符串作模板,模板中有格式符,如print("I am %s,i am %d years old" %('Tom',10)),模板与tuple之间有一个%号分隔,它代表了格式化操作,可以用如下方式对格式进一步的控制:
    %[(name)][flags][width].[precision]typecode

list, 简单的数据集合, 可以使用索引; 

    print("I'm %(name)s. I'm %(age)d year old" % {'name':'Vamei', 'age':99})(使用字典传递真实值)

tuple, 把一些数据当做一个整体去使用, 不能修改;

  1. 常用内置函数:

    • dir()用于查询一个类或者对象所有属性,其结果包含类或者对象的__dict__中包含的结果
    • help()用于查询说明文档
    • isinstance(objec,classinfo):返回对象是否是类的实例
    • issubclass(class,classinfo):class类是否是classinfo类的子类
    • repr():调用对象的__repr__,返回offical representation string,与反引号操作符作用相同,输出对python友好,可以作为解释器的输入
    • str():调用对象的__str__,类似于c#的toString()功能,对人友好
    • bytes():调用对象的__bytes_
    • getattr():返回对象的属性值,如果该属性不存在会抛出AttributeError
    • hasattr():判断类或对象是否包含某属性
    • setattr():设置对象的属性值,如果不存在会为对象添加新属性,但不影响类的属性.setattr(x,’name’,’tom’)相当于x.name=’tom’
    • delattr():删除属性,delattr(x,’foobar’) 相当于del x.foobar,不影响类属性
    • iter():返回一个迭代器
    • vars():返回module,class,instance,或者是其他对象(包含__dict__属性)的__dict__属性
    • zip():以多个支持迭代器的对象为参数,返回一个tuples的迭代器,然后可以使用__next__()方法访问每个tuple
    • super():访问基类函数

      class C(B):
          def method(self, arg):
       # This does the same thing as:
       # super(C, self).method(arg),相当于B.method(self,arg),但在多继承情况下super函数能避免相同基类被多次调用
              super().method(arg)
      
    • map(函数对象,list...):功能是将函数对象依次作用于list的每一个元素,每次作用的结果存储在返回的循环对象中,如果函数对象有多个参数,则后面可以有多个list,map函数每次从所有的list中取出一个值,作为函数的参数

    • filter(函数对象,list...):功能是将函数对象作用于多个元素,如果函数对象返回的是True,则返回该次的元素存储在循环对象中

    • reduce(函数对象,list):函数对象只能接受两个参数,可以累进的从list中取值,每一次调用函数对象的返回值与list中后面一个元素作为下次函数对象调用的参数。3.x中需要引入functools包 

  2. 内置函数列表:

dict, 使用键值和值进行关联的数据;

    Built-in Functions    
abs() dict() help() min() setattr()
all() dir() hex() next() slice()
any() divmod() id() object() sorted()
ascii() enumerate() input() oct() staticmethod()
bin() eval() int() open() str()
bool() exec() isinstance() ord() sum()
bytearray() filter() issubclass() pow() super()
bytes() float() iter() print() tuple()
callable() format() len() property() type()
chr() frozenset() list() range() vars()
classmethod() getattr() locals() repr() zip()
compile() globals() map() reversed() __import__()
complex() hasattr() max() round()  
delattr() hash() memoryview() set()  

set, 数据只出现一次, 只关心数据是否出现, 不关心其位置;

mylist = [1, 2, 3, 4, 'Oh']  
mytuple = (1, 2, 'Hello', (4, 5))  
mydict = {'Wang' : 1, 'Hu' : 2, 'Liu' : 4}  
myset = set(['Wang', 'Hu', 'Liu', 4, 'Wang']) 

 


2. 静态函数, 类函数, 成员函数、属性函数的区别?

定义:

静态函数(@staticmethod): 即静态方法,主要处理与这个类的逻辑关联,它是不可以访问实例变量或类变量的。

类函数(@classmethod): 即类方法, 只能访问类变量,不能访问实例变量, 类方法通过@classmethod装饰器实现。

成员函数: 实例的方法, 只能通过实例进行调用,若需通过类名来调用,则应申明为类方法。

属性函数:通过@property把一个方法变成一个静态属性。

具体应用:

日期的方法, 可以通过实例化(__init__)进行数据输出, 传入参数self;

可以通过类的方法(@classmethod)进行数据转换, 传入参数cls;

可以通过静态方法(@staticmethod)进行数据验证;

2.1静态方法举例:

 1 class People(object):
 2     Name="类变量名"
 3     def __init__(self,name):
 4         self.name=name
 5     @staticmethod
 6     def run(self):
 7         print("%s is a staticmethod"%self.name)
 8     @staticmethod
 9     def talk():
10         print("who is talking")
11 p1=People("王文辉")
12 p1.run()
13 # 解决方法:调用时主动传递实例本身给run方法。
14 p1.run(p1)
15 # 解决方法:在run方法中去掉self参数,但这也意味着,在eat中不能通过self.调用实例中的其它变量了
16 p1.talk()

2.2 类方法举例:

1 class Cat(object):
2     name="我是类变量"
3     def __init__(self,name):
4         self.name=name
5     @classmethod
6     def sleep(self):
7         print("%s is a classname"%self.name)
8 c1=Cat("大猫")
9 c1.sleep()

2.3 属性方法举例:

# 属性方法的定义是通过@property把一个方法变成一个静态属性。
class Cat(object):
    def __init__(self,name):
        self.name=name
    @property
    def talk(self):
        print("%s is a property method"%self.name)
c1=Cat("大猫")
# 调用会出现错误,因为talk此时已经变成一个静态属性了,不是方法,不需要括号。
c1.talk()
c1.talk
# 作用:根据需要改变属性的状态,比如获取航班当前的状态,到达,延误还是飞走。

 


3. a=1, b=2, 不用中间变量交换a和b的值

解答: 三种形式: 直接交换、加法或异或

示例:

a=1
b=2
a,b=b,a
print(a,b)

a=a b
b=a-b
a=a-b
print(a,b)

a=a^b
b=a^b
a=a^b
print(a,b)

 


4. 写一个函数, 输入一个字符串, 返回倒序排列的结果: 如: string_reverse(‘abcdef’), 返回: ‘fedcba’**(请采用多种方法实现, 并对实现方法进行比较)**

解决方法:先转成列表,反转列表后,再转成字符串。

 1 class Solution(object):
 2     def __init__(self,s):
 3         self.s=s
 4     def reverseString(self):
 5         list_string=list(self.s)
 6         list_string.reverse()
 7         str2="".join(list_string)
 8         return str2
 9 
10 str1="hello"
11 c1=Solution(str1)
12 print(""%s""%(c1.reverseString()))

 


5. 请用自己的算法, 按升序合并如下两个list, 并去除重复的元素:

list1 = [2, 3, 8, 4, 9, 5, 6]

list2 = [5, 6, 10, 17, 11, 2]

解答:先转换成集合自动去重,再转换成列表。

list1=[2,7,4,15,10]
list2=[6,1,9,10,7]
list3=list(set(list1 list2))

 


6. 请写出打印结果:

x = [0, 1]

i = 0

i, x[i] = 1, 2

print(x)

打印结果: [0, 2], python可以使用连续赋值, 从左至右.

g = lambda x, y=2, z : x y**z

g(1, z=10) = ?

打印结果: 异常, 形参表末尾才可以有默认参数, z需要提供默认参数.

 


7. 说一下以下代码片段存在的问题

    from amodule import * # amodule is an exist module  

    class dummyclass(object):  
        def __init__(self):  
            self.is_d = True  
            pass  

    class childdummyclass(dummyclass):  
        def __init__(self, isman):  
            self.isman = isman  

        @classmethod  
        def can_speak(self): return True  

        @property  
        def man(self): return self.isman  

    if __name__ == "__main__":  
        object = new childdummyclass(True)  
        print object.can_speak()  
        print object.man()  
        print object.is_d  

解答:

1、警告:object 是python中保留的关键字,不应被重新定义。

2、类方法是类所拥有的方法,传入的参数应为cls,而不是self。

3、错误:Python实例化对象不需要new关键字。

4、错误:@property, 表示属性, 不是方法, 则不需要加括号”()”, 直接调用object.man, 即可。

5、错误: 如果想重写基类的构造方法, 则需要继承基类的构造方法再重写。

6、额外:类名尽量大写。

class Dummyclass(object):
    def __init__(self):
        self.is_d=True
        pass

class ChildDummyclass(Dummyclass):
    def __init__(self,isman):
        super(ChildDummyclass, self).__init__()
        self.isman=isman

    @classmethod
    def can_speak(cls):
        return True
    @property
    def man(self):
        return self.isman

if __name__ == '__main__':
    o=ChildDummyclass(True)
    print(o.can_speak())
    print(o.man)
    print(o.is_d)

 


8. 介绍一下python的异常处理机制和自己开发过程中的体会

解答:**Python的异常处理机制:**

try: 尝试抛出异常;

raise: 引发异常;

except: 处理异常;

finally: 是否发生异常都需要做的事情;

创建新的异常类型, 需要继承Exception类, 可以定义类的属性, 便于处理异常;

# 主动触发异常
try:
    raise Exception("出现错误")
except Exception as e:
    print(e)

# 自定义异常
class wangwenhuiwrong(object):
    def __init__(self,name):
        self.name=name
    def __str__(self):
        return self.message
try:
    raise wangwenhuiwrong("出现错误")
except Exception as e:
    print(e)

开发体会:

异常主要处理读取文件, 也可以使用with的方法读取文件; 还可以用于网络连接, 异常可以包含大量的错误信息, 进行错误处理.

 

本文由必发88手机版发布,转载请注明来源:tuple应用详解,Python基本语法