您的位置:新葡亰496net > 奥门新萄京娱乐场 > 新葡亰496net:Python数据结构,学习笔记

新葡亰496net:Python数据结构,学习笔记

发布时间:2019-07-05 12:49编辑:奥门新萄京娱乐场浏览(104)

    • 元组相加

      t1 = (1,2,3) t2 = (4,5,6)

      print(id(t1)) print(id(t2))

      t1 = t2 #即t1=t1 t2,将t1与t2元组相加,t1指向相加之后的新元组,该操作合法,因为元素内容不能修改,但是可以指向新的地址

      print(t1) print(id(t1)) #相加之后的t1指向一个新的地址

    • 变量

    Python 3.6

    1.执行python脚本的两种方式:

    答:1、./run.py.shell直接调用python脚本

    2、python run.py 调用python 解释器来调用python脚本

     

    copy深浅拷贝,copy深浅

     

      我们在很多方法里都看到copy()方法,这是对变量的复制,赋值,下面来看一下实例:

        我们可以让一个变量等于另一个变量可以采用赋值的方式,比如a = b等,让变量a = b变量,还可以通过copy()来实现。下面来看看在各种情况下的关联情况:

        一、字符串和数字的情况

        >>> import copy
      >>> a = 3
      >>> b = a
      >>> c = copy.copy(a)
      >>> d = copy.deepcopy(a)
      >>> b
      3
      >>> c
      3
      >>> d
      3
        >>> print(id(a),id(b),id(c),id(d))
      10914432 10914432 10914432 10914432
        从上面可以看出,我们通过导入模块copy,这个模块专门用于复制,可以看到在数字中,采用赋值、copy()、deepcopy()三种方式,我们发现采用三种方式的方式,都是把地址关联过去,具有相同的地址,说明是采用如下方式进行管理的。实例如下:

        新葡亰496net 1

        从上图可以看出,在数字和字符串中,三种任意方式都是关联到字符串或数字所在的内存,是把内容关联过去,因此无论采用那种方式都是一样的

    。下面来看一看在列表,元组、字符串、字典中的情况。

    二、列表,元组,字典一层复制情况

        列表、字典的情况

        1、在列表中的情况

        import copy
      l = ["alex",11,"sb","tom"]
      d = {"k1":"v1","k2":22,"k3":"alex"}
      t = (11,'ALEX',"sb")

      l1 = l
      l2 = copy.copy(l)
      l3 = copy.deepcopy(l)

      print(id(l),id(l1),id(l2),id(l3))

      #下面来修改一下列表中的元素,看看关联情况编程什么样了,如下:
      l.append("Aoi")
      print(l,l1,l2,l3)
      print(id(l),id(l1),id(l2),id(l3))
        2、在字典中的情况
      d1 = d
      d2 = copy.copy(d)
      d3 = copy.deepcopy(d)
      print(id(d),id(d1),id(d2),id(d3))
      d.__setitem__("tom","Hello")
      print(d,"n",d1,"n",d2,"n",d3)
      print(id(d),id(d1),id(d2),id(d3))

      运行结果如下:

        列表中的运算结果:

        140006457636360 140006457636360 140006457672456 140006457637320
      ['alex', 11, 'sb', 'tom', 'Aoi'] ['alex', 11, 'sb', 'tom', 'Aoi'] ['alex', 11, 'sb', 'tom'] ['alex', 11, 'sb', 'tom']
      140006457636360 140006457636360 140006457672456 140006457637320
      140006482186568 140006482186568 140006457674440 140006457636680
      字典中的运算结果:

        {'k2': 22, 'k3': 'alex', 'tom': 'Hello', 'k1': 'v1'}
      {'k2': 22, 'k3': 'alex', 'tom': 'Hello', 'k1': 'v1'}
       {'k2': 22, 'k1': 'v1', 'k3': 'alex'}
      {'k2': 22, 'k1': 'v1', 'k3': 'alex'}
      140006482186568 140006482186568 140006457674440 140006457636680

        可以看出,在列表中我们通过等号赋值(=)、copy(list)、deepcopy(list)方法打印变量的ip地址,可以看出,等号赋值(=)与原来变量的地址是一样的,因此等号的赋值方式是这样的:

        新葡亰496net 2

        等号赋值无论在关联字典还是列表的过程中,都是指向同一个Python开辟的内存地址,a和b的内存地址永远是一致的,只要a发生了变化,相应的b就发生变化。

        而在字典中copy()和deepcopy()确是下面的形式:

        新葡亰496net 3

     

        为什么我猜测copy()是上面的形式呢,我们来看一段代码:

        import copy
      l = ["alex",11,"sb","tom"]
      d = {"k1":"v1","k2":22,"k3":"alex"}                                   (1)
      t = (11,'ALEX',"sb")

      l1 = l
      l2 = copy.copy(l)
      l3 = copy.deepcopy(l)

      print(id(l),id(l1),id(l2),id(l3))

      #下面来修改一下列表中的元素,看看关联情况编程什么样了,如下:
      l.append("Aoi")
      print(l,l1,l2,l3)
      print(id(l),id(l1),id(l2),id(l3))

      d1 = d
      d2 = copy.copy(d)                                        (2)
      d3 = copy.deepcopy(d)
      print(id(d),id(d1),id(d2),id(d3))                        (3)
      d.__setitem__("tom","Hello")
      print(d,"n",d1,"n",d2,"n",d3)
      print(id(d),id(d1),id(d2),id(d3))                         (4)

      del d["k1"]                                               (5)
      print(d,"n",d1,"n",d2,"n",d3)
      print(id(d),id(d1),id(d2),id(d3))                          (6)

        代码运行如下:

        140353118074376 140353118074376 140353118110472 140353118074760
      ['alex', 11, 'sb', 'tom', 'Aoi'] ['alex', 11, 'sb', 'tom', 'Aoi'] ['alex', 11, 'sb', 'tom'] ['alex', 11, 'sb', 'tom']
      140353118074376 140353118074376 140353118110472 140353118074760
      140353142624584 140353142624584 140353118112456 140353118075272
      {'k1': 'v1', 'tom': 'Hello', 'k2': 22, 'k3': 'alex'}
       {'k1': 'v1', 'tom': 'Hello', 'k2': 22, 'k3': 'alex'}
       {'k1': 'v1', 'k2': 22, 'k3': 'alex'}
       {'k1': 'v1', 'k2': 22, 'k3': 'alex'}
      140353142624584 140353142624584 140353118112456 140353118075272
      {'tom': 'Hello', 'k2': 22, 'k3': 'alex'}
       {'tom': 'Hello', 'k2': 22, 'k3': 'alex'}
       {'k1': 'v1', 'k2': 22, 'k3': 'alex'}
       {'k1': 'v1', 'k2': 22, 'k3': 'alex'}
      140353142624584 140353142624584 140353118112456 140353118075272

        在上面(1)处我们定义了一个字典,在(2)处我们使用copy.copy()产生一个新的变量d2,然后我们打印变量d、d2的id(d)、id(d2),我们可以看出,两者的id()是不一样的,因此可以说明在系统中是存在了两个位置存放d和d2的,而不是一个位置,仅凭这一点还不足以说明,下面来看(5)处,我们删除了字典d中的键-值对"k1",此时如果两者存在关联的话,那么d2中键-值对"k1":"v1"必然也会被删除,事实上并没有,而且我们修改元素的时候,如果它们之间存在指向关系的话,那么copy()也会让d2中的添加一个键-值对"tom":"Hell0"。事实上并没有,所以我断定,无论怎样使用copy()方法都是在内存中新开辟了一个地址,如果只有一层的话,这两个地址之间也是没有关联的。

        如果字典只有一层,那么使用deepcopy()方法也是一样的,图例如下:

        新葡亰496net 4

     

    三、列表,元组,字典多层情况的赋值情况

       上面我们研究了copy()、deepcopy()单层的情况,下面来看看多层的情况,首先定义一个字典n1={"k1":123,"k2":"wupie","k3":[123,"alex"]}

    ,

     

    新葡亰496net 5

         在python中,copy()、deepcopy()的设置挺复杂的,相同元素的id是一样的,但是在删除的时候又不会影响由copy()、deepcopy()产生的变量,

    但是在使用copy()的时候,第二层的元素还是与原来的元素关联在一起,下面来看一个例子:

        import copy

      n1 = {"k1":123,"k2":"wupie","k3":[456,"alex"]}

      #打印k1的ip地址
      n2 = copy.copy(n1)
      n3 = copy.deepcopy(n1)

      print(n1,"n" ,n2,"n",n3)
      print(id(n1),id(n2),id(n3))
      print(id(n1["k1"]),id(n2["k1"]),id(n3["k1"]),"n")

      #打印k2的地址
      print(id(n1["k2"]),id(n2["k2"]),id(n3["k2"]),"n")

      #打印"k3"的ip地址
      print(id(n1["k3"]),id(n2["k3"]),id(n3["k3"]),"n")

      #修改“k1"的值
      n1["k1"] = 888

      #打印修改后的信息
      print(n1,"n" ,n2,"n",n3)
      print(id(n1),id(n2),id(n3))
      print(id(n1["k1"]),id(n2["k1"]),id(n3["k1"]),"n")

      #打印修改后的k2的地址
      print(id(n1["k2"]),id(n2["k2"]),id(n3["k2"]),"n")

      #打印"k3"的ip地址
      print(id(n1["k3"]),id(n2["k3"]),id(n3["k3"]),"n")

      #修改"k3"中的值
      n1["k3"][0] = 666
      print(n1,"n" ,n2,"n",n3)
      print(id(n1),id(n2),id(n3))
      print(id(n1["k1"]),id(n2["k1"]),id(n3["k1"]),"n")

      #打印修改后的k2的地址
      print(id(n1["k2"]),id(n2["k2"]),id(n3["k2"]),"n")

      #打印"k3"的ip地址
      print(id(n1["k3"]),id(n2["k3"]),id(n3["k3"]),"n")

      #删除"k3"的键值对
      del n1["k3"]
      print(n1,"n" ,n2,"n",n3)
      print(id(n1),id(n2),id(n3))print(id(n1["k1"]),id(n2["k1"]),id(n3["k1"]),"n")

      #打印修改后的k2的地址

      print(id(n1["k2"]),id(n2["k2"]),id(n3["k2"]),"n")

      try:#打印"k3"的ip地址

        print(id(n1["k3"]),id(n2["k3"]),id(n3["k3"]),"n")

      except KeyError:

         print(id(n2["k3"]),id(n3["k3"]))id(n2),id(n3))print(id(n1["k1"]),id(n2["k1"]),id(n3["k1"]),"n")#打印修改后的k2的地址print(id(n1["k2"]),id(n2["k2"]),id(n3["k2"]),"n")try:#打印"k3"的ip地址 print(id(n1["k3"]),id(n2["k3"]),id(n3["k3"]),"n")except KeyError: print(id(n2["k3"]),id(n3["k3"]))

        运行结果如下:

        {'k3': [456, 'alex'], 'k1': 123, 'k2': 'wupie'}
       {'k3': [456, 'alex'], 'k1': 123, 'k2': 'wupie'}
      {'k3': [456, 'alex'], 'k1': 123, 'k2': 'wupie'}
      139928164286856 139928139772744 139928139736968
      10918272 10918272 10918272

      139928163731640 139928163731640 139928163731640

      139928139736520 139928139736520 139928139737608           (k3)的ip地址

      {'k3': [456, 'alex'], 'k1': 888, 'k2': 'wupie'}
       {'k3': [456, 'alex'], 'k1': 123, 'k2': 'wupie'}
       {'k3': [456, 'alex'], 'k1': 123, 'k2': 'wupie'}
      139928164286856 139928139772744 139928139736968
      139928164089648 10918272 10918272

      139928163731640 139928163731640 139928163731640

      139928139736520 139928139736520 139928139737608

      {'k3': [666, 'alex'], 'k1': 888, 'k2': 'wupie'}
       {'k3': [666, 'alex'], 'k1': 123, 'k2': 'wupie'}
       {'k3': [456, 'alex'], 'k1': 123, 'k2': 'wupie'}
      139928164286856 139928139772744 139928139736968
      139928164089648 10918272 10918272

      139928163731640 139928163731640 139928163731640

      139928139736520 139928139736520 139928139737608

      {'k1': 888, 'k2': 'wupie'}
       {'k3': [666, 'alex'], 'k1': 123, 'k2': 'wupie'}
       {'k3': [456, 'alex'], 'k1': 123, 'k2': 'wupie'}
      139928164286856 139928139772744 139928139736968
      139928164089648 10918272 10918272

      139928163731640 139928163731640 139928163731640

      139928139736520 139928139737608

        在上面例子中,我们首先定义了一个变量n1,里面嵌套了一层字典,然后使用copy(),deepcopy()生成了新的变量n2,n3并且打印了n1,n2,n3的ip地址,由ip地址可以看出,n1,n2,n3是在内存中有不同的存储位置的,接着我们打印了键-值对“k1”的存储id,结果发现,三者的“k1”存储的id位置是一样的,说明还是用的原来位置的id,这样节省了内存,接着我们看“k3”的ip地址,可以看出,使用copy()得到的ip地址与n1的“k3”的id是一样的,说明是用的一个id,我们修改字典n1中的元素"k3"之后,n2也跟着变化,说明字典n1中的“k3”和字典n2中的“k3”存在某种管理,但是当我们删除字典n1中的“k3”之后,字典n2中的"k3"不受影响,还存在,说明使用copy()生成的变量,第二层关联之间存在着某种关联,但是又不完全依存,第一层之间共用一个地址,节省了内存,但是在原来的字典发生变化的时候又不影响之前的变量,只是对新的变量开辟了一个空间,用来存放位置。

       

     

     

    新葡亰496net 6

     

    新葡亰496net 7

     

        有一个监控模板,包含内存,硬盘,有一批机器,现在是按dic模式运行的,现在要修改其中一部分的及其的硬盘,其他部分不改变。

        import copy
      dic = {
      "cpu":[80,],
      "men":[80,],
      "disk":[80]
      }

      print("before:",dic)
      new_dic = copy.deepcopy(dic)
      new_dic["cpu"][0] = 50

      print(dic,"n",new_dic)

        在上面,我们使用copy模块的deepcopy来进行处理,我们知道,有很多信息,在嵌套中,只有deepcopy()才会生成第二层的信息。

    我们在很多方法里都看到copy()方法,这是对变量的复制,赋值,下面来看一下实例: 我们可以让一个变量等于另一个...

     输出为

    python通过=进行变量赋值,声明变量时不需要声明数据类型

    运算符

    • - * / 四则运算 % 求余 **乘方
    • // 用于整除

    5.python单行注释和多行注释分别是什么?

     答:单行注释用#,多行注释用三引号

    2583036379208
    2583036379280
    (1, 2, 3, 4, 5, 6)
    2583035574600
    
    #-*- coding:utf -8-*-
    #/usr/bin/python3
    
    #在声明变量时不需要声明变量类型
    
    counter = 100        #整型变量  
    
    miles = 1000.0       #浮点型变量
    
    name = "runobb"   #字符串 
    
    #打印变量:print()
    
    print(counter)
    
    print(miles)
    
    print(name)
    
    #查看数据类型:type()
    
    print(type(counter))
    
    print(type(miles))
    
    print(type(name))
    
    #同时为多个变量赋值
    #创建一个整型对象,值为1,三个变量被分配到相同的内存空间
    a = b = c = 1
    #id()查看该变量的内存空间地址
    

    字符串

    • 字符串用单引号或双引号括起来。
    • 三引号(单引号或双引号均可)表示多行字符串,行末加反斜杠表示换行不算在字符串之内。
    • 字符串加上前缀 r 表示原生字符串。
    • 用于连接字符串。
    • * 用于重复字符串。
    • 相邻的字符串字面量会自动连接。
    • 字符串存在片段(slice)语法(使用下标获取子串),但字符串本身不可变。
    • 片段语法中下标 0 指向第一个元素,下标 -1 指向最后一个元素。

      'a' * 3 'aaa' 'b' 'a' 'ba' 'b' "a" 'ba' print(r'C:somename') C:somename print(""" a b c """) a b c "abcde"[1:] 'bcde' "abcde"[:4] 'abcd' "abcde"新葡亰496net:Python数据结构,学习笔记。[:] 'abcde' "abcde"[-3:] 'cde'

    6.声明变量注意事项有哪些?

     答:1.变量名只能是数字、字母、下划线的任意组合

    2.变量名的第一个字符不能为数字

    3.python关键字不能用作变量名

    •  元组相乘

      t1 = (1,2,3) print(id(t1)) t1 = t1 * 3 #运算之后生成新的元组,t1指向所生成的元素新地址 print(t1) #输出(1, 2, 3, 1, 2, 3, 1, 2, 3) print(id(t1)) #t1指向了一个新的地址

    •  双层元组的遍历

      t = ((1,2,3),(6,7,8),("i","love","you")) for i in t:

      print(i)
      

      print(""20)

      for k,v,w in t:

      print(k,"...",v,"...",w)
      

    In [16]: print(id(a))
    1658082080

    列表(Lists)

    • 列表:一种成员的类型相同但个数不限的数据结构。
    • 列表采用中括号加逗号的特殊语法。
    • 连接两个列表。
    • 列表存在片段(slice)语法(使用下标获取子列表),列表片段可变(可以通过赋值被替换)。
    • 片段语法中下标 0 指向第一个元素,下标 -1 指向最后一个元素。

      [1,2,3][1:] [2, 3] [1,2,3][-2:] [2, 3] a = [1,2,3,4] a[2:] = [4,5,6] a [1, 2, 4, 5, 6] a[2:] = [] a [1, 2]

    • append 方法添加元素。

    • extend 方法连接另一个列表。
    • insert 方法插入元素。
    • remove 方法移除指定元素。
    • pop 方法弹出最后面的元素。
    • clear 方法清空列表。
    • index 方法查找指定元素的下标。
    • count 方法返回列表的长度。
    • reverse 方法翻转列表。
    • copy 方法复制列表。

      fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana'] fruits.count('tangerine') 0 fruits.index('banana') 3 fruits.reverse() fruits ['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange'] fruits.sort() fruits ['apple', 'apple', 'banana', 'banana', 'kiwi', 'orange', 'pear']

    • 列表解析(List Comprehensions)

      [x**2 for x in range(10)] [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y] [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

    8.如何查看变量在内存中的地址?

    答:用id(变量名) 即可查看变量在内存中的地址

     

     输出为

    In [17]: print(id(b))
    1658082080

    元组(Tuples)

    • 元组:一种成员数量和次序固定但种类不尽相同的数据结构。
    • 元组采用小括号加逗号的特殊语法。(最外层元组的小括号可省略)
    • 元组是不可变的。
    • 元组存在下标语法。
    • 存在没有任何成员的元组 () 以及只有一个成员的元组 a, (元素后跟一个逗号表示元组)

      t = 123,"123" t[0] 123 t[1] '123' u = t, 456 u ((123, '123'), 456) v = 1, v (1,)

    9.执行python程序时,自动生成的.pyc文件的作用是什么?

    答:pyc是一种二进制文件,是由py文件经过编译后,生成的文件,是一种byte code,py文件变成pyc文件后,加载的速度有所提高,而且pyc是一种跨平台的字节码,是由python的虚拟机来执行的,py文件是可以直接看到源码的,所以就需要编译为pyc后,再发布出去,实现部分源码的隐藏.

    (1, 2, 3)
    (6, 7, 8)
    ('i', 'love', 'you')
    ********************
    1 ... 2 ... 3
    6 ... 7 ... 8
    i ... love ... you
    

    In [18]: print(id(c))
    1658082080

    解构语法

    >>> a,b = [1,2]
    >>> a,b
    (1, 2)
    >>> a,b = (1,2)
    >>> a,b
    (1, 2)
    >>> a,b = b,a
    >>> a,b
    (2, 1)
    

    10.写代码

    •  两个变量交换

      a = (1,2,3) b = (7,8,9) print(a) #输出(1, 2, 3) print(b) #输出(7, 8, 9) print(""20) a,b = b,a #两个元组交换,同样适用于其他各类型变量(比如int,list等等) print(a) #输出(7, 8, 9) print(b) #输出(1, 2, 3)

    • 数值运算

    集合(Sets)

    • 集合:一种不存在重复元素的哈希表数据结构。
    • 集合采用大括号加逗号的特殊语法。
    • 常用操作包括求差集,并集,交集,对称差集。
    • 存在集合的解析表达式。(set comprehensions)

      basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'} basket {'pear', 'orange', 'banana', 'apple'} a = set('abracadabra') b = set('alacazam') a {'c', 'a', 'r', 'd', 'b'} b {'l', 'c', 'a', 'm', 'z'} a - b # 差集 {'b', 'd', 'r'} a | b # 并集 {'m', 'l', 'c', 'a', 'r', 'd', 'b', 'z'} a & b # 交集 {'c', 'a'} a ^ b # 对称差集 {'d', 'b', 'l', 'm', 'z', 'r'} {x for x in 'abracadabra' if x not in 'abc'} {'d', 'r'}

    a.实现用户输入用户名和密码,当用户名为seven且密码为123时,显示登陆成功,否则显示登陆失败.

     

    name=input("请输入用户名:").strip()
    pwd=input("请输入密码:").strip()
    if name=="seven" and pwd=="123":
        print("登陆成功")
    else:
        print("登陆失败")
    

     

     

     

     

    字典(Dictionaries)

    • 字典:一种存放键值对的哈希表数据结构。
    • 字典采用大括号加冒号和逗号的特殊语法。
    • 存在字典的解析表达式。(dictionary comprehensions)

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

    b.实现用户输入用户名和密码,当用户名为seven且密码为123时,显示登陆成功,否则显示登陆失败.失败时允许重复输入3次

    count=0
    while count<3:
        count =1
        name=input("请输入用户名:").strip()
        pwd=input("请输入密码:").strip()
        if name=="seven" and pwd=="123":
          print("登陆成功")
          break
        else:
            print("登陆失败")
            continue
    

     

    >>>5   4  # 加法
    9
    >>> 4.3 - 2 # 减法
    2.3
    >>> 3 * 7  # 乘法
    21
    >>> 2 / 4  # 除法,得到一个浮点数
    0.5
    >>> 2 // 4 # 除法,得到一个整数
    0
    >>> 17 % 3 # 取余 
    2
    >>> 2 ** 5 # 乘方
    32
    

    range 函数

    >>> list(range(5,10))
    [5, 6, 7, 8, 9]
    >>> list(range(0,10,3))
    [0, 3, 6, 9]
    >>> list(range(-10,-100,-30))
    [-10, -40, -70]
    

    c.实现用户输入用户名和密码,当用户名为seven且密码为123时,显示登陆成功,否则显示登陆失败.失败时允许重复输入3次

     

     

    count=0
    while count<3:
        count =1
        name=input("请输入用户名:").strip()
        pwd=input("请输入密码:").strip()
        if name=="seven"or name=="alex" and pwd=="123":
          print("登陆成功")
          break
        else:
            print("登陆失败")
            continue
    

     

    注意:

    语句

    • while 语句
    • for 语句(实质上是 foreach)
    • if ... elif ... else 语句
    • 代码块采用冒号加缩进来表示
    • pass 语句(空语句)
    • break continue 语句
    • 循环 else语句(表示循环正常结束,没有被 break)

      for n in range(2, 10): for x in range(2, n): if n % x == 0: print(n, 'equals', x, '*', n//x) break else: print(n, 'is a prime number')

    2 is a prime number
    3 is a prime number
    4 equals 2 * 2
    5 is a prime number
    6 equals 2 * 3
    7 is a prime number
    8 equals 2 * 4
    9 equals 3 * 3
    

    11.写代码

    1. python可以同时为多个变量赋值如 a , b = 1 , 2
    2. 一个变量可以通过赋值指向不同类型的对象
    3. 数值的除法(/)总是返回一个浮点数,要获取整数使用(//)操作符
    4. 在混合计算时,python会把整型转换为浮点型

    函数

    • 定义函数使用 def。
    • 形参的特殊形式有:带缺省值的形参 arg=value,元组形参 *args,字典形参 **args。
    • 实参的特殊形式有:带关键字的实参 kwarg=value,列表/元组实参 *args,字典实参 **args。

      def f(a, b=2): # 带缺省值的形参 print(a,b)

      f(3) 3 2 f(a=4) # 带关键字的实参 4 2 d = {"a":3,"b":5} f(d) # 字典实参,调用时展开 3 5 def f(k, *args, kws): # 元组形参,字典形参 print(k) for arg in args: print(arg) for kw in kws: print(kw, ":", kws[kw])

    >>> f("a", 1,2,3, c=4,d="abc") # 调用时 1,2,3 打包成元组,c=4,d="abc" 打包成字典
    a
    1
    2
    3
    c : 4
    d : abc
    >>> args = [3,6]
    >>> list(range(*args)) # 列表实参,调用时展开
    [3, 4, 5]
    >>> args = (3,6)
    >>> list(range(*args)) # 元组实参,调用时展开
    [3, 4, 5]
    

    a.使用while循环输出2-3 4-5 6.. 100的和

    count=1
    s=0
    while count<100:
        count =1
        s =(-1)**count*count
    print(s)
    

     

    • 字符串(String)

      1 #-- coding:utf-8 -- 2 #!/usr/bin/python3 3 4 str = "keatiuny" 5 print(str) #打印变量str 6 print(str[0]) #通过下标的方式取得str中对应的value,0:第一个值 -1:最后一个 7 print(str[0:3]) #取得str中第一位到第四位的中间的值(不包含第四位) 8 print(str[0:-1]) #取得str中第一位到最后一位中间的值,不包含最后一位 9 print(str*2) #打印2次 10 print(str "name") #拼接字符串 11 12 #输出结果 13 keatiuny 14 k 15 kea 16 keatiun 17 keatiunykeatiuny 18 keatiunyname

    b.使用for循环和range实现1-2 3-4 5-6... 99的和

    s=0
    for i in range(1,100):
        s =-(-1)**i*i
    print(s)
    

     

     

    注意:

    C.使用while循环输出1,2,3,4,5  7,8,9  11,12

    count=0
    while count<12:
        count =1
        if count==6 or count==10:
            continue
        print(count,end=" ")
    

     

     

    1. 反斜杠可以用来转义,使用r可以让反斜杠不发生转义 例: print(r'Runoob'),输出结果中包含
    2. 字符串可以用 连接在一起,用 * 重复
    3. python中字符串不能改变

    d.使用while循环输出1-100内的所有基数

    count=0
    while count<100:
        count =1
        if count%2!=0:
            print(count)
    

     

    • 列表(list):

    新葡亰496net,e.使用while循环输出1-100内的所有偶数

    count=0
    while count<100:
        count =1
        if count%2==0:
            print(count)
    

     

    11.**分别书写数字5,10,32,7的二进制

    **

    #5=2**2 2**0
    #5对应的二进制为 101
    print(bin(5))
    
    #10=2**3 2**1
    #10对应的二进制为1010
    print(bin(10))
    
    #32=2**5
    #32对应的二进制为100000
    print(bin(32))
    
    #7=2**2 2**1 2**0
    #7对应的二进制 111
    print(bin(7))
    

     

     

    list是python中使用最频繁的数据类型

    14.现在有如下两个变量,请简述n1和n2是什么关系?

    n1=123

    n2=123

    答: n1和n2的id(内存地址) 值 和type都相等

     

    list中元素的类型可以不相同,list支持数字、字符串、嵌套列表

    15.现在有如下两个变量,请简述n1和n2是什么关系?

    n1=123456

    n2=123456

    答:n1和n2的id(内存地址)不等 type不同,值相同,分别指向两个相同的数值123456

    list = ['keatiuny',1,'1.15']            #多个value的可变的集合,是一个可迭代对象
    list2 = ['hello python',456]
    #切片
    print(list)                 #打印整个list
    print(list[0])              #取list中第一个value
    print(list[0:2])            #取list中0:2的值(不包含2)
    print(list[-1])             #取list中最后一个值
    print(list[0:])             #取整个list中的值
    
    #遍历list
    #方法一:for循环
    for value in list:
        print(value)
    #方法二:while 循环:
    i = 0
    while i < len(list):
        print(list[i])
        i  = 1
    #对list的操作(增删改查)
    """
    列表操作包含以下函数:
    1、cmp(list1, list2):比较两个列表的元素 
    2、len(list):列表元素个数 
    3、max(list):返回列表元素最大值 
    4、min(list):返回列表元素最小值 
    5、list(seq):将元组转换为列表 
    列表操作包含以下方法:
    1、list.append(obj):在列表末尾添加新的对象
    2、list.count(obj):统计某个元素在列表中出现的次数
    3、list.extend(seq):在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
    4、list.index(obj):从列表中找出某个值第一个匹配项的索引位置
    5、list.insert(index, obj):将对象插入列表
    6、list.pop(obj=list[-1]):移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
    7、list.remove(obj):移除列表中某个值的第一个匹配项
    8、list.reverse():反向列表中元素
    9、list.sort([func]):对原列表进行排序
    """
    

    16.现在有如下两个变量,请简述n1和n2是什么关系?

     n1=123456

     n2=n1

     

    答:n1和n2的id(内存地址) 值 和type都相等

    • 元组(tuple)

    17.如果有一个变量n=5,请使用int提供的方法,得到该变量最少可以用多少个二进制表示?

    n=5
    print(n.bit_length())

     

    元组同list基本相似,只是元组一旦生成就无法改变,不能修改增删改,可以查

    18.布尔值分别有什么?

    答:布尔值有True和False

    注意:定义当定义的元组中只有一个元素时,需要在元素的后面添加逗号  tup1 = (20,)

    19.阅读代码,写出执行结果:

    a="alex"
    b=a.capitalize()
    print(a)
    print(b)

     

    答:alex  Alex

    20.写代码,有如下代码,按要求实现每个功能:

    name=" aleX"

    __author__ = 'Administrator'
    name=" aleX"
    #a.移除两边对应的空格,并输入移除后的内容
    print(name.strip())
    #b.判断name变量对应的值是否以“al”开头,并输出结果
    print(name.startswith("al"))
    #c.判断name变量对应的值是否以“X”结尾,并输出结果
    print(name.endswith("X"))
    #d.将name变量值中的“l”替换为“p‘并输出结果
    print(name.replace("l","p"))
    #e.将name变量对应的值根据”l“切分,并输出结果
    print(name.split("l"))
    #f.上一题e中分割之后的值是什么类型
    print(type(name.split("l")))
    #g.将name变量对应的值变为大写,并输出值
    print(name.upper())
    #h.将name变量对应的值变为小写,并输出值
    print(name.lower())
    #i请输出name变量对应的值的第二个字符
    print(name[1])
    #j请输出name变量对应的值的前3个字符
    print(name[:3])
    #k请输出name变量对应的值的后2个字符
    print(name[-2:])
    #l 请输出name变量对应的值中”e“所在的索引位置
    print(name.index("e"))
    

     

     

     

    • 字典(dic)
    • 集合(set)

    21.字符串是否可以迭代,如果可以请使用否循环迭代每一个元素。

    答:可以的

    a="abcdefg"
    for i in range(len(a)):
        print(a[i])

    集合(set)是一个无序不重复的元素集合。

    22.写代码,按要求实现功能

    __author__ = 'Administrator'
    li=["alex","erin","rain","aa","bb","cc"]
    #a.计算列表的长度并输出
    print(len(li))
    #b.列表中追加元素”seven“,并输出添加后的列表
    li.append("seven")
    print(li)
    #c.请在列表的第一个位置插入元素”tony“,并输出添加后的列表
    li.insert(0,"Tony")
    print(li)
    #d.请修改列表第二个元素为"kelly",并输出修改后的列表
    li[1]="kelly"
    print(li)
    #e.请删除列表中的”eric“,并输出修改后的列表
    li.remove("erin")
    print(li)
    #f.删除列表的第二个元素,并输出删除的元素和删除后的列表
    aa=li.pop(1)
    print(aa)
    print(li)
    #g请删除列表中的第三个元素,并输出删除后的列表
    li.pop(2)
    print(li)
    #h.请删除列表中的第2-4个元素,比输出删除后的列表
    li.pop(1)
    li.pop(1)
    li.pop(1)
    print(li)
    #i将列表所有元素反转,并输出反转后的列表
    li.reverse()
    print(li)
    #j请使用for in range 输出列表的索引
    for i  in range(len(li)):
        print(i)
    #k请使用enumberate输出列表元素和序号(序号从100开始)
    for i,j in enumerate(li,start=100):
        print(i,j)
    #l请使用for循环输出所有元素
    for i in  li:
        print(i)
    

     

    可以使用{  }或者set( )函数创建集合

    23.写代码,按要求实现功能:

    li=["hello","seven",["moon",["h","kelly"],"all"],123,456]

    __author__ = 'Administrator'
    li=["hello","seven",["moon",["h","kelly"],"all"],123,456]
    #a.请输出kelly
    print(li[2][1][1])
    #b.请使用索引找到”all”元素,并将其修改为“ALL”
    print(li[2][2].upper())
    

     

    )

    • 数据类型转换

    24.写代码,有下面元组.按要求实现功能

     

    __author__ = 'Administrator'
    tu=("alex","eric","rain")
    #a.计算元组长度并输出
    print(len(tu))
    #b.获取元组的第二个元素,并输出
    print(tu[1])
    #c.获取元组的第1-2个元素,并输出
    print(tu[:2])
    #d.请使用for循环输出元组的元素
    for i in tu:
        print(i)
    #e.请使用 for len range 输出元组的索引
    for i in range(len(tu)):
        print(i)
    #f使用enumberate输出元组的元素和序号。序号从10开始
    for i,j in  enumerate(tu,10):
        print(i,j)
    

     

     

    25 有如下元组,按要求实现以下功能

    tu=("alex",[11,22,{"k1":"v1","k2":["age","name"],"k3":(11,22,33)},44])

     

    a.讲述元组的特性:

    答:1、有序的集合,可以存放多个值

    2、通过偏移来取数据

    3、属于不可变的对象,不能在修改内容

    b.元组里的第一个元素”alex”可以不可以修改?

    答:不可以修改

    C.tu中的元素k2对应的值是什么类型,可不可以修改,如果能修改,则向其添加一个元素seven。

    答:k2对应的值是list(列表).可以修改

    tu=("alex",[11,22,{"k1":"v1","k2":["age","name"],"k3":(11,22,33)},44])
    print(tu[1][2]["k2"])
    print(type(tu[1][2]["k2"]))
    tu[1][2]["k2"].append("seven")
    print(tu)
    

     

     

    d.tu中的元素k3对应的值是什么类型,可不可以修改,如果能修改,则向其添加一个元素seven。

    答:k3对应的值类型是元组,不可以修改

     

    26字典

    dic={"k1":"v1","k2":"v2","k3":[11,22,33]}

    __author__ = 'Administrator'
    dic={"k1":"v1","k2":"v2","k3":[11,22,33]}
    #a.请循环输出所有key
    for k in  dic:
        print(k)
    #b.请循环输出所有value
    for v in dic.values():
        print(v)
    #c.请循环输出所有key,value
    for k,v in dic.items():
        print(k,v)
    #d.请在字典中添加一个键值对k4,v4,输出添加后的字典
    dic["k4"]="v4"
    print(dic)
    #e.请修改字典中k1对应的值为alex,输出修改过后的字典
    dic["k1"]="alex"
    print(dic)
    #f.请在k3对应的值中添加一个元素44,输出修改后的字典
    dic["k3"].append(44)
    print(dic)
    #g.请在k3对应的值的第一个位置插入18,输出修改后的字典
    dic["k3"].insert(0,18)
    print(dic)
    

     

     

     

    27 转换

    #1.将字符串s=”alex”,转换成列表
    
    s="alex"
    l=list(s)
    print(l)
    
    #2.将字符串s=”alex”,转换成元组
    
    s="alex"
    t=tuple(s)
    print(t)
    
    
    
    #3.将列表li=[“selx”,”seven”]转换成元组
    
    l=["alex","seven"]
    t=tuple(l)
    print(t)
    
    
    
    #4.将元组tu=(“alex”,”seven”)转换成列表
    
    t=("alex","seven")
    l=list(t)
    print(l)
    
    
    
    #5..将列表li=[“selx”,”seven”]转换成字典且字典的key按照10开始向后递增
    
    
    
    l=["alex","seven"]
    d={}
    for i,j in enumerate(l,start=10):
        d[i]=j
    print(d)
    

     

    28.求1-100所有的和

    s=0
    for i in range(1,101):
         s =i
    print(s)
    

     

    29.元素分类

    有如下集合[11,22,33,44,55,66,77,88,99],将大于66的放在集合的第一个key中,小于66的放在集合的第二个key中

    l=[11,22,33,44,55,66,77,88,99]
    d={"k1":[],"k2":[]}
    for i in l:
        if i>66:
            d["k1"].append(i)
        elif i<66:
            d["k2"].append(i)
    print(d)
    

     

     

     

     

    30.购物车

    功能要求:

       要求用户输入总资产:如2000

       显示商品列表;用户按序号选择商品,加入购物车

       购买,如果商品总金额大于总资产.则提示余额不足,否则购买成功

     

     

    goods=[
    {"name":"电脑","price":1999},
    {"name":"鼠标","price":10},
    {"name":"游艇","price":20},
    {"name":"美女","price":998}
    ]
    good_d={}
    good_l=[]
    tag=True
    flag=True
    while tag:
        allmoney=input("请输入总资产:").strip()
        if allmoney.isdigit():
            for good in  goods:
                print("{}.name:{name} price:{price}".format(goods.index(good) 1,name=good["name"],price=good["price"]))
                good_d[goods.index(good) 1]=[good["name"],good["price"]]
    
            while tag:
                number=int(input("请输入要购买商品的序号:").strip())
                if not number  or number not in good_d:
                    print("输入错误。请重新输入:")
                    continue
                else:
                    flag=True
                    while flag:
                        count=input("请输入要购买商品的件数:").strip()
                        if count.isdigit():
                            allprice=good_d[number][1]*int(count)
                            if allprice<=int(allmoney):
                                good_l.append((good_d[number][0],good_d[number][1],count))
                                allmoney=int(allmoney)- allprice
                                print("你的余额为",allmoney)
                                print(good_l)
                                break
                            else:
                                print("你的余额不足,请重新选择商品")
                                while True:
                                    cmd=input("请输入命令,输入Y表示继续购物,输入N表示退出结账")
                                    if cmd=="Y":
                                        flag=False
                                        break
                                    elif cmd=="N":
                                        flag=False
                                        tag=False
                                        break
    
                                    else:
                                        print("输入命令有误")
                                        continue
    
    
                        else:
                            print("输入有误。请重新输入:")
                            continue
    
    
        else:
            print("总金额必须是数字且不能为空!")
    
     
    

     

     

     

     

    本文由新葡亰496net发布于奥门新萄京娱乐场,转载请注明出处:新葡亰496net:Python数据结构,学习笔记

    关键词: