Python 数据结构及语法

Python 数据结构及语法

Python 数据结构及其接口方法

列表

1. lst = []
2. lst.sort() # 排序列表
3. lst.reverse() # 反转列表
4. lst.append() # 表尾添加元素
5. lst.pop() # 表尾删除元素
6. lst.extend(lst2) # 合并lst，lst2给lst

列表生成式 (List Comprehensions)

list1 = [1,2,3,4]

list2 = [i for i in list1 if i > 2]
print(list2)

list3 = [i for i in list1 if i%2]
print(list3)

dict1 = {x: x**2 for x in (2,4,6)}
print(dict1)

dict2 = {x : f'item{x **2}' for x in (2,4,6) } # formatted string literals, 以 f 开头，包含的{}表达式在程序运行时会被表达式的值代替。
print(dict2)

set1 = {x for x in 'hello world' if x not in 'abcdefg'}
print(len(set1))

字符串

s = 'abc' # 可以使用单引号和双引号表示字符串
ss = "abc"

str1 = 'hello, world!'
print('字符串长度是: ',len(str1))                       # 字符串长度是:  13
print('单词首字母大写: ',str1.title())                  # 单词首字母大写:  Hello, World!
print('字符串变大写: ',str1.upper())                    # 字符串变大写:  HELLO, WORLD!
print('字符串是不是大写: ',str1.isupper())              # 字符串是不是大写:  False
print('字符串是不是以hello开头: ',str1.startswith('hello')) # 字符串是不是以hello开头:  True
print('字符串是不是以hello结尾: ',str1.endswith('hello'))   # 字符串是不是以hello结尾:  False
print('字符串是不是以感叹号开头: ',str1.startswith('!'))    # 字符串是不是以感叹号开头:  False
print('字符串是不是以感叹号结尾:', str1.endswith('!'))      # 字符串是不是以感叹号结尾: True
str2 = '- abc'
str3 = str1.title() + ' ' + str2.lower()
print(str3)                                                 # Hello, World! - abc

元组

p = 'abcd', 'abcdef', 30, 'ddab@aaa' # p 的类型为 tuple
name, gender, age, email = p

集合

set1 = {1,2,3,3,3,2}
print(set1)                         # {1, 2, 3}
print('Length = ',len(set1))        # Length =  3
set2 = set(range(1,10))
print(set2)                         # {1, 2, 3, 4, 5, 6, 7, 8, 9}
set1.add(4)
set1.add(5)
set2.update([11,12])
print(set1)                         # {1, 2, 3, 4, 5}
print(set2)                         # {1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12}
#移除元素, 如果元素不存在将会引发 KeyError
set2.discard(5)
print(set2)                         # {1, 2, 3, 4, 6, 7, 8, 9, 11, 12}
if 4 in set2:
    set2.remove(4)

print(set2)                         # {1, 2, 3, 6, 7, 8, 9, 11, 12}

for elem in set2:
    print(elem**2,end=' ')          # 1 4 9 36 49 64 81 121 144 1

#将元组转换成集合
set3 = set((1,2,3,3,2,1))
print(set3.pop()) #弹出头部元素     # 1
print(set3)                         # {2, 3}
#交集，并集，差集，对称差运算
print(set1 & set2)                  # {1, 2, 3}
#print(set1.intersection(set2))
print(set1 | set2)                  # {1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12}
#print(set1.union(set2))
print(set1 - set2)                  # {4, 5}
#print(set1.difference(set2))
print(set1 ^ set2)                  # {4, 5, 6, 7, 8, 9, 11, 12}
#print(set1.symmetric_difference(set2))
#判断子集和超集
print(set2 <= set1)                 # False
print(set3 <= set1)                 # True
print(set1 >= set2)                 # False
print(set1 >= set3)                 # True

字典

dict.setdefault

统计字符出现次数使用

s = 'abdfadfeass'
dic = {}
for e in s:
    dic.setdefault(e, 0)
    dic[e] += 1
print(dic)

Collections.defaultdict 类定义

class collections.defaultdict([default_factory[,....]])

Collections.defaultdict

from collections import defaultdict
s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
d = defaultdict(list)
for k,v in s:
    d[k].append(v)
print d.items()

• 使用 dict 定义字典，在访问不存在的 key 时会发生 keyerror 这样一个报错。
• 使用 defaultdict 任何未定的 key 都会默认返回一个根据 method_factory 参数不同的默认值，而相同情况下 dict() 会返回KeyError。
• 与使用 dict.setdefault() 相比更简洁更快。

将 default_factory 设置成 int 对于计数非常有用

from collections import defaultdict
s = 'mississippi'
d = defaultdict(int)
for k in s:
    d[k]+=1
print d.items()
#[('i', 4), ('p', 2), ('s', 4), ('m', 1)]

将 default_factory 为 set 使defaultdict构建集合字典非常有用

from collections import defaultdict
s = [('red', 1), ('blue', 2), ('red', 3), ('blue', 4), ('red', 1), ('blue', 4)]
d = defaultdict(set)
for k,v in s:
    d[k].add(v)
print d.items()
#[('blue', set([2, 4])), ('red', set([1, 3]))]

使用 Counter 进行字符统计

from collections import Counter

p = "abc"
print(Counter(p))

# Counter({'a': 1, 'b': 1, 'c': 1})

迭代数据结构

for i in xrange(n): pass # list
for k in dict_obj.iterkeys(): pass # dict keys
for v in dict_obj.itervalues(): pass # dict values
for k,v in dict_obj.iteritems(): pass # dict item
for index, value in enumerate(seq_obj): pass #  seq
for v1, v2 in zip(seq1,seq2): pass # zip obj

Python 语法糖

1. a, b = b, a #交换两个变量
2. [i for i in range(10)] # 快速生成列表
3. newstr = newstr[::-1] # 转置字符串
4. numstr = str(n) # 将数字转换成字符串
5. ''.join(strlst) # 使用''连接strlst里的字符
6. max(arr, key = lambda x : len(str(x))) # 自定义比较函数
7. asc = sorted(arr) # 升序排序
8. desc = sorted(arr, reverse = True) # 降序排序
9. elem = arr[-1] # 取最后一个元素
10. with open('data.txt', 'w') as f : # 文件打开的语法糖，不用考虑关闭文件和异常

Python 语法

生成器

生成器是一种特殊的地带其，使用 yield 语句而不是 return 语句返回结果，yield 语句一次返回一个结果，在每个结果中间，挂起函数的状态，以便下次从它离开的地方继续执行。

def fib():
    prev, curr = 0， 1
    while True:
        yield curr
        curr, prev = prev + curr, curr
f = fib()
for i in range(10): # 调用10次next函数，并打印调用next()之后的结果
    print(next(f)) # 调用next(f)，fib()函数的返回执行到yield语句后返回.

迭代器

Iterator Protocal:

• iter()
• next()
• Exception of StopIteration

iter() 函数有两个参数时，第一个参数必须为可调用对象(callable object)，这种情况下创建的迭代器在调用 next 时将会调用这个可调用对象，并返回它的值直到返回值与 iter 函数的第二个指定参数相等，然后抛出 StopIteration 异常。

使用 iter 可以直接返回 Python 中内建对象的迭代器。

it = iter([1, 2, 3, 4])
for x in it:
    print(x)

装饰器

装饰器可以把与业务逻辑无关的代码抽离出来，让代码保持干净清爽，而且装饰器还能被多个地方重复利用。比如一个爬虫网页的函数，如果该URL曾经被爬过就直接从缓存中获取，否则爬下来之后加入到缓存，防止后续重复爬取。

不使用装饰器模式：

def web_lookup(url, saved={})：
    if url in saved:
        return saved[url]
    page = urllib.urlopen(url).read()
    saved[url] = page
    return page

使用装饰器模式：

#pythonic
import urllib # py2
import urllib.request as urllib # py3

def cache(func):
    saved = {}
    def wrapper(url):
        if url in saved:
            return saved[url]
        else:
            page = func(url)
            saved[url] = page
            return page
    return wrapper

def web_lookup(url): # 业务代码，抽出来。
    return urllib.urlopen(url).read()