python基础-列表

1. 打印图形
2. 高10，宽20，打印口字形

#encoding=utf-8

 

def print_square(height):

    print '*'*height

    for i in range(height/4):

        print '*'+" "*(height-2)+'*'

    print '*'*height

 

print_square(20)

 

 

1. 打印斜线

>>> for i in range(5):

...     print " "*i,"*"

...

 *

  *

   *

    *

2. 查找句子中最长的单词，并输出索引

思路：人去做的话要先找到最长的，然后根据长度找到这个词，再根据词找到索引

方法一：
>>> a="i am a boy"

>>> a.split()

['i', 'am', 'a', 'boy']

>>> "1*2*3".split()

['1*2*3']

>>> "1*2*3".split("*")

['1', '2', '3']

>>> a

'i am a boy'

>>> a=a.split()

>>> a

['i', 'am', 'a', 'boy']

>>> d={}

>>> for word in a:

...     d[len(word)]=word

...

>>> d

{1: 'a', 2: 'am', 3: 'boy'}

>>> max(d.keys())

3

>>> d[3]

'boy'

>>> a.index("boy")

3

 

方法二：

>>> a

['i', 'am', 'a', 'boy']

>>> map(len,a)

[1, 2, 1, 3]

>>> max(map(len,a))

3

>>> map(len,a).index(3)

3

 

1. 列表、元组跟字典

列表跟数组的区别：

数组 int a[10]  int *a[]   数组声明地址对应的内容，必须存定义的类型

列表list[地址，地址，地址]  想存什么存什么，这是个容器

 

   列表：

1. 想存什么都可以

 

1. 创建列表
2. 访问列表：
3. 可正向遍历，可倒着，利用索引直接取

 

1. 利用切片遍历

 

对于切片，后面的数字是开区间

 

1. 更新列表

错误：列表为空时不能直接赋值

 

字典为空时可以直接赋值：

 

 

利用append赋值：

 

 

利用insert插入：

 

利用extend插入：

 

 

1. 列表拆包方法：加一个*

 

 

切片拆包：

 

 

拓展：

元组也能用拆包，加两个*

 

 

1. 删除 

 

 

删除重复值：

方法一：

 

方法二：

 

 

方法三:

Count 函数统计字符出现的次数

 

 

方法四：

利用坐标和切片配合的方式来进行操作

 

 

1. 常用方法汇总

 

 

1. ord 

 

1. pop读取的同时做删除

 

 

1. index 找出元素在列表中的位置

 

 

练习：写一个函数，在字符串中找到某个字母的所有索引位置

算法1：遍历字符串，使用索引做遍历，判断当前字符是否和目标字符相等，如果相等，则将索引位置计入到一个列表中，完成遍历后返回索引位置的结果集

>>> def find_letter_indexs(lista,number):
...     pos_indexs=[]
...     for i in range(len(lista)):
...         if number==lista[i]:
...             pos_indexs.append(i)
...     return pos_indexs
...
>>> print find_letter_indexs([1,1,1,2,2],2)
[3, 4]

算法2：
使用count函数记录一下，字符串中一共有几个目标字符，根据出现的次数，来设定循环次数，找到一个目标字符，就把当前索引的位置+1后设定为开始查找的范围，再进行调用index函数的查找

#encoding=utf-8

def find_letter_indexs(lista,number):
    pos_indexs=[]
    start=0
    for i in range(lista.count(number)):
        index=lista.index(number,start)
        pos_indexs.append(index)
        start=index+1
    return pos_indexs

print find_letter_indexs([1,1,1,2,2],2)

 

Index具备start属性

 

 

 

 

字符串也具备这个功能：

>>> "abc".index("a")

0

>>> "abc".index("b")

1

>>> "abc".find("b")

1

>>> "abc".find("x")

-1

 

1. 软技能：

高手去到一个团队，总是先观察

重视：

人是有惯性的，不容易被改变，总是优先用自己最熟悉的方法去解决问题。

引进新技术，先改变和提高自己。

写简历：功能测试，提现自己跟别人有什么不一样。

        行业经验：同行业的更好找

        质量：漏测少

        流程优化：任何流程，测试和开发流程

      做过什么项目，产生了什么框架，用了什么工具，最后效果怎么样上线的效果怎么样。自己引入了什么工具。积累一些小工具。

      MAT分析内存泄漏 

      Opensource网站，找一些小工具。

1 行业经验
2 质量：漏测少
3 流程优化：任何流程，测试和开发流程：
测试前置、头痛医头脚痛医脚。冒烟、线上故障解决流程
4 测试规范、开发规范、流程规范
5 安全、功能测试框架、bug预防体系、探索式测试、持续集成
自动化、性能（更高）
6 引入了什么工具：fiddler postman webdriver  xenu
sikuli，基于图形的自动化测试。python
findbugs info   
https:

 

 

1. Reverse：反转，之反转不排序   sort：排序

 

 

1. Sorted函数：

        

 

     Sorted是内置函数，sort是list的函数

     Sorted对新列表进行变换，sort直接对原列表进行变换。

1. sort函数

 

例子： 把list中的元组按里面元素个数去排序

#encoding=utf-8

list1 = [(1,5,3),(1,3,6,3),(1,1,2,4,5,6),(1,9)]

def L(tup) :

    return len(tup)

list1.sort(key = L,reverse = True)  #key赋一个函数值  reverse是升序，降序排

print list1

 

 

变形：

#encoding=utf-8

list1 = [(1,5,3),(1,3,6,3),(1,1,2,4,5,6),(1,9)]

list1.sort(key = len ,reverse = True)

print list1

key可以直接赋值成len

 

 

题目变形：按每个元组中最后一个元素的大小进行排序

#encoding=utf-8

list1 = [(1,5,3),(1,3,6,3),(1,1,2,4,5,6),(1,9)]

def L(tup) :

    return tup[-1]

list1.sort(key = L ,reverse = True)

print list1

 

 

题目变形：按照元组中所有元素的平方数之和进行排序

#encoding=utf-8

list1 = [(1,5,3),(1,3,6,3),(1,1,2,4,5,6),(1,9)]

def L(tup) :

    sum = 0

    for i in tup:

        sum+=i*i

    return sum

list1.sort(key = L ,reverse = True)

print list1

 

 

老师：

list1 = [(1,5,3),(1,3,6,3),(1,1,2,4,5,6),(1,9)]
def L(tup) :
    sum=0
    for i in tup:
        sum+=i**2
    return sum
list1.sort(key = L,reverse = True)
print list1

 

题目变形：求一句话中最长的一个单词的位置

#encoding=utf-8

str="i am a boy"

a=str.split()

def L(tup) :

    return len(tup)

a.sort(key = L ,reverse = True)

print a.index(a[0])

print a[0]

 

 

   练习题：利用绝对值进行比较大小

list1 = [(-1,5,3),(-5,3,6,3),(1,1,2,4,5,6),(2,9),(-2,10)]

def compare(a,b):

    if abs(a)>abs(b):

        return 1

    elif abs(a)==abs(b):

        return 0

    else:

        return -1

def L(tup) :

return tup[0]

list1.sort(cmp=compare,key = L,reverse = False)

print list1

 

练习题：#一个包含多个单词的list，自定义比较函数，函数需要基于字符串的长度做比较，越长的越大。

list1 = ["qi","webd","qwqqqqq"]

def compare(a,b):

    if len(a)>len(b):

        return 1

    elif len(a)==len(b):

        return 0

    else:

        return -1

def L(tup) :

return tup

list1.sort(cmp=compare,reverse = False)

print list1

 

1. 自动生成列表

 

 

1. 列表复制，这是引用的方式

 

 

不想同时改变两个值，可以利用切片

 

 

1. 增删改查遍历的综合操作

练习：图书馆程序：全局变量是list,dict，增加新书、借书、还书，查阅所有的可接书，所有的借出去的。增加个帮助信息。

 

#encoding=utf-8
import sys

help_info=u"""
help:打印图书馆的帮助信息
borrow:借书
lend:还书
add:增加新书
exit:退出系统
catalog:查看当前所有图书信息
"""
def help():
    print help_info

def exit():
    sys.exit(0)

def catalog():
    global books
    if len(books)==0:
        print "no book in library"
        return
    for i in books:
        print i

def add():
    global books
    book_name=raw_input("input your new book name:")
    books.append(book_name)
    print "add %s book successsfully!" %book_name

def borrow():
    global books
    book_name=raw_input("input your book want to borrow:")
    if book_name in books:
        books.remove(book_name)
        print "you have got the book"
    else:
        print "the book to borrow does not exit!"

def lend():
    global books
    book_name=raw_input("input your book want to lend:")
    books.append(book_name)
    print "you have lend the book"


books=[]

command={"help":help,"borrow":borrow,"lend":lend,"add":add,"catalog":catalog,"exit":exit}

while 1:
    user_command=raw_input("input your command:")
    command[user_command]() 

 

1. 序列化

>>> import cPickle as p
>>> a=[1,2,3]
>>> f=open("e:\a.txt",'w')
>>> p.dump(f,a)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: argument must have 'write' attribute
>>> p.dump(a,f)
>>> f.close()

 

>>> f=open("e:\a.txt",'r')
>>> a=p.loads(f)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: loads() argument 1 must be string, not file
>>>
>>>
>>> a=p.load(f)
>>> a
[1, 2, 3]
>>>

 

1. 综合列表（列表推导），列表解析

 

 

>>> [x for x in range(1,10,2)]

[1, 3, 5, 7, 9]

>>> [x**2 for x in range(1,10,2)]

[1, 9, 25, 49, 81]

>>> [i+j for i in range(5) for j in range(10,15)]

[10, 11, 12, 13, 14, 11, 12, 13, 14, 15, 12, 13, 14, 15, 16, 13, 14, 15, 16, 17,

 14, 15, 16, 17, 18]

 

>>> [i for i in range(20) if i%2==0]

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

>>>

 

>>> [m+n for m in 'ABC' for n in "XYZ"]

['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

 

>>> listone=[2,3,4]

>>> listtwo=[2*i for i in listone if i>2]

>>> print listtwo

[6, 8]

 

>>> d={'x':'A','y':'B','z':'C'}

>>> print[k +'='+ v for k,v in d.iteritems()]

['y=B', 'x=A', 'z=C']

 

>>> L=['Hello','World','IBM','Apple']

>>> print [s.lower() for s in L]

['hello', 'world', 'ibm', 'apple']

 

练习：二维矩阵的转置

a=[[1,2],[4,5]]
print [ [j[i] for j in a] for i in range(2)]

执行过程解析：
for i in range(2)--->i:0 --->第一次循环
   for j in a：---第一次：[1,2]
        [1,2][0]--->[1]    
      for j in a：---第2次：[4,5]
        [4,5][0]--->[1,4]  

for i in range(2)--->i:1 --->第二次循环
   for j in a：---第一次：[1,2]
        [1,2][1]--->[2]    
      for j in a：---第2次：[4,5]
        [4,5][1]--->[2,5]

[[1,4] ,[2,5]] 

 

a=[[1,2,3],[4,5,6],[7,8,9],[10,11,12]]

print [ [j[i] for j in a] for i in range(3)]

 

练习：删除二维矩阵的某一列

不打印第三列

a=[[1,2,3],[4,5,6],[7,8,9],[10,11,12]]

print [ [i[j] for j in [0,1]]for i in a]

 

不打印第一列

    a=[[1,2,3],[4,5,6],[7,8,9],[10,11,12]]

print [ [i[j] for j in [0,2]]for i in a]

 

不打印第二列

a=[[1,2,3],[4,5,6],[7,8,9],[10,11,12]]

print [ [i[j] for j in [1,2]]for i in a]

 

 

1. 迭代器 iter()将对象转为迭代器

#encoding=utf-8

li=[5,6,7]

it=iter(li)

print it

print it.next()

print it.next()

print it.next()

print it.next()

 

21．自定义的迭代器

#encoding=utf-8
class MyRange(object):
    def __init__(self, n):
        self.idx = 0
        self.n = n
    
    def __iter__(self):
        return self
    def next(self):
        if self.idx < self.n:
            val = self.idx
            self.idx += 1
            return val
        else:
            raise StopIteration()
myRange = MyRange(3)
for i in myRange:
    print i

 

 

好处：用一次就会生成一次数据。

 

1. 生成器
2. 枚举

好处：生成了对应位置的坐标。

for k,v in enumerate([10,9,8,7]):

print k,v

 

 

1. 深浅拷贝

浅拷贝：与之前的可变元素还有关联—>引用了之前的list地址

浅拷贝与切片复制是一样的。

深拷贝：与之前无任何关联完全对应到具体内容，之前的无论怎么边都不会影响到拷贝之后的。

推荐使用深拷贝

#encoding=utf-8

import copy

a = [1, 2, 3, 4, 5, ['a', 'b']]  # 原始对象

b = a  # 赋值，传对象的引用

c = copy.copy(a)  # 对象拷贝，浅拷贝

d = copy.deepcopy(a)  # 对象拷贝，深拷贝

a.append(6)  # 修改对象a

a[5].append('c')  # 修改对象a中的['a', 'b']数组对象

print 'a = ', a

print 'b = ', b

print 'c = ', c

print 'd = ', d 

 

 

1. 通过list实现堆栈

队列：先进先出

堆栈：后进先出

 

#encoding=utf-8

 

stack = [3, 4, 5]

stack.append(6)

stack.append(7)

print stack

print stack.pop()

print stack

print stack.pop()

print stack.pop()

print stack

 

 

1. 通过list实现队列

#encoding=utf-8

from collections import deque

 

queue = deque(["Eric", "John", "Michael"])

queue.append("Terry")           # Terry arrives

queue.append("Graham")          # Graham arrives

print queue.popleft()                 # The first to arrive now leaves

print queue.popleft()                 # The second to arrive now leaves

print queue                           # Remaining queue in order of arrival