第三章组合数据类型
key关键字传入函数或方法，相当于先将x中的元素“修饰”，再对“修饰”后的元素加以排列得到一个序，最后的结果是x以这个序进行排列。
- 3.4.2 组合类型的复制
  - 浅拷贝
  - 深拷贝
- 实例
  - 生成用户名
    - 小惊喜 m[:1]来代替m[0] 防止产生IndexError
  - 处理统计信息
    - 小惊喜 print 三引号

第三章组合数据类型

3.1 序列类型

3.1.1 元组

元组和字符串类似，是固定的，不能替换或者删改包含的任意项

(1, 2, 3) + (1, 2, 3) #(1, 2, 3, 1, 2, 3)

(1, 2, 3, 4) * 2 #(1, 2, 3, 4, 1, 2, 3, 4)

(1, 2, 3, 4)[:3] #(1, 2, 3)

(1, 2, 3, 1, 1, 3).count(1) #3

(1, 2, 3, 1, 1, 3).index(3) #2

hair = 'black', 'brown', 'blonde', 'red'

hair[2]

hair[-3:]

hair[:2], 'gray', hair[2:] #(('black', 'brown'), 'gray', ('blonde', 'red'))

hair[:2] + ('gray',) + hair[2:] #('black', 'brown', 'gray', 'blonde', 'red')

#请注意上面一元组的写法，别弄错了

things = (1, -7.5, ('pea', (5, 'XyZ'), 'queue'))

things[2][1][1][2]  # 'Z'

3.1.2 命名的元组 (collections.nametuple())

collections 模块提供了 namedtuple() 函数，该函数用于创建自定义的元组数据类型。

import collections

Sale = collections.namedtuple('Sale', 'productid customerid data quantity price')

sales = []

sales.append(Sale(432, 932, '2008-9-14', 3, 7.99))

sales.append(Sale(419, 874, '2008-9-15', 1, 18.49))

total = 0

for sale in sales:

	total += sale.quantity * sale.price

print('Total ${0:.2f}'.format(total)) #Total $42.46

第二个例子：

Aircraft = collections.namedtuple('Aircraft',

								'manufacturer model seating')

Seating = collecttions.namedtuple('Seating', 'minimum maximum')

aircraft = Aircraft('Airbus', 'A320-200', Seating(100, 220))

aircraft.seating.maximum #220

print('{0} {1}'.format(aircraft.manufacturer, aircraft.model))

print('{0.manufacturer} {0.model}'.format(aircraft))

#命名的元组还有几个私有方法，有一个namedtuple._asdict()的方法特别有用

print('{manufacturer} {model}'.format(**aircraft._asdict()))

#Airbus A320-200

3.1.3 列表（查询有关函数点这）

列表方法：

L.append(x)

L.count(x)

L.extend(m) | L += m

L.index(x, start, end)

L.insert(i, x) #在索引i的位置上插入x

a = [1, 2, 3]

a[1:1] = [4] # == a.insert(1, 4)

a # [1, 4, 2, 3]

L.pop() #返回并移除list L最右边的数据项

L.pop(i) # 索引为i的

L.remove(x) #从list中移除最左边出现的数据项x，如果找不到产生ValueError

#a[2:4] = [] | del a[2:4] euqal

L.reverse()

L.sort(...) #排序接受可选的key和reverse参数

first, *rest = [9, 2, -4, 8, 7]

first, *mid, last = 'Charles Philip Arthur George Windsor.'.split()

*directories, executable = '/usr/local/bin/gvim'.split('/')

#(['', 'usr', 'local', 'bin'], 'gvim')

3.1.4 列表内涵

[expression for item in iterable if condition]

[y for y in range(1900, 1940) if (y % 4 == 0 and y % 100 != 0) or (y % 400 == 0)]

#[1904, 1908, 1912, 1916, 1920, 1924, 1928, 1932, 1936]

[s + z + c for s in 'MF' for z in 'SMLX' for c in 'BGW' if not (s == 'F' and z == 'X')]

第二行代码，和一般的for循环似乎不同，条件的判断似乎必须在循环的最后关头才会进行判断，所以其实for循环的顺序发生颠倒也没有什么关系。

3.2 集合类型

只有可哈希运算的对象可以添加到集合中。

为什么需要哈希？

3.2.1 集合(查询有关函数点这)

集合是0个或多个对象引用的无序组合，且排他！

{1, 1, 2, 3, 4, 5} #{1, 2, 3, 4, 5}

空集合只能用set()来创建， '{}' 用来创建空dict

语法	描述
s.add(x)	将数据项x添加到集合s中——如果s中尚未包含x
s.clear()	移除集合s中的所有数据项
s.copy()	返回集合s的浅拷贝*
s.difference(t) s-t	返回一个新集合，其中包含在s中但不在集合t中的所有数据项*
s.difference_update(t) s -= t	移除每一个在集合t但不在集合s中的项
s.discard(x)	如果数据项x存在于集合s中，就移除该数据项，参见set.remove()
s.intersection(t) s & t	返回一个新集合，其中包含所有同时包含在集合t与s中的数据项*
s.intersection(t) s &= t	使得集合s包含自身与集合t交集
s.isdisjoint(t)	如果集合s与t没有相同的项，就返回True*
s.issubset(t) s<=t	如果集合s与集合t相同，或者是t的子集，就返回True。使用s<t可以测试s是否是t的真子集*
s.issuperset(t) s >= t	如果集合s与集合t相同，或者是t的超集，就返回True。使用s>t可以测试s是否是t的真子集*
s.pop()	返回并移除集合s中一个随即项，如果s为空集，就产生KeyError异常
s.remove(x)	从集合s中移除数据项x，如果s中不包含x，就产生KeyError异常，参见set.discard()
s.symmetric_difference(t) s^t	返回一个新集合，其中包含s与t中的每个数据项，但不包含同时在这俩个集合中的数据项*
s.symmetric_difference_update(t) s ^= t	使得集合s只包含其自身与集合t的对称差
s.union(t) s \| t	返回一个新集合，其中包含集合s中的所有数据项，以及在t中而不在s中的数据项*
s.update(t) s\|= t	将集合t中每个s中不包含的数据项添加到集合s中

* 这一方法及其操作符也可用于frozensets

3.2.2 集合内涵

{expression for item in iterable}

{expression for item in iterable if condition}

html = {x for x in files if x.lower().endswith(('.htm', '.html'))}

固定集合(forzeonset)

如果讲二元运算符应用于集合于固定集合，那么产生结果的数据类型与左边操作数的数据类型一致。

3.3 映射类型

只有可哈希运算的对象才能作为字典的键。

3.3.1 字典 (查询有关函数点这）

dict() | {}

d1 = dict({'id': 1948, 'name': 'Washer', 'size': 3})

d2 = dict(id = 1948, name = 'Washer', size = 3)

d3 = dict([('id', 1948), ('name', 'Washer'), ('size', 3)])

d4 = dict(zip(('id', 'name', 'size'), (1948, 'Washer', 3)))

d5 = {'id': 1948, 'name': 'Washer', 'size': 3}

#{'id': 1948, 'name': 'Washer', 'size': 3}

del d1['id']  #删除'd1'

d1.pop('id')  #删除'd1'

del : del删除的不是数据，而是删除对象与数据之间的绑定，若数据没有被其他对象引用，则进入垃圾收集流程。

语法	描述
d.clear()	从dict d 中移除所有项
d.copy()	返回dict d的浅拷贝
d.fromkeys(s, v)	返回一个dict，该字典的键为序列s中的项，值为None或v
d.get(k)	返回键k相关联的值，如果k不在dict d中就返回None
d.get(k, v)	返回键k相关联的值，如果k不在dict d中就返回v
d.items()	返回dict d 中所有(key, value)对的视图
d.keys()	返回dict d 中所有键的视图
d.pop(k)	返回键k相关联的值，并移除键为k的项，如果k不包含在d中，就产生KeyError异常
d.popitem()	返回并移除dict d 中任意一个(key, value)对，如果d为空就产生KeyError异常
d.setdefault(k, v)	与dict.get()方法一样，不同之处在于，如果k没有包含在dict d中就插入一个键为k的新项，其值为None或v
d.update(a)	将a中每个尚未包含在dict d中的（key, value) 对添加到d，对同时包含在d与a中的每个键，使用a中对应的值替换d中对应的值——a可以是字典，也可以是（key,value)对的一个iterable，或关键字参数
d.values()	返回dict d中所有值的视图

视图是一个只读的iterable对象

特别的是：如果视图引用的字典发生变化，那么视图将反映该变换；键视图与项视图支持一些类似于集合的操作。

& | - ^

d1 = dict(a = 1, b = 2, c = 3)

d2 = dict(x = 1, y = 2, z = 3)

for item in d1.items():

    print(item)

d1['a'] = 7

for item in d1.items():

    print(item)

#('a', 1)

#('b', 2)

#('c', 3)

#('a', 7)

#('b', 2)

#('c', 3)

d1 = dict(a = 1, b = 2, c = 3)

d2 = dict(x = 1, y = 2, z = 3)

v = d1.items()

x = d2.items()

for item in v | x:

    print(item)

#('b', 2)

#('y', 2)

#('z', 3)

#('c', 3)

#('x', 1)

#('a', 1)

d = {}.fromkeys('ABCD', 3)   #{'A':3, 'B':3, 'C':3, 'D':4}

s = set('ACX') # {'A', 'C', 'X'}

matches = d.keys() & s # {'A', 'C'}

一个例子（没玩过）

import string

import sys

words = {}

strip = string.whitespace + string.punctuation + string.digits + "\"'"

for filename in sys.argv[1:]: #这个是指在命令行输入的东东

    for line in open(filename):

        for word in line.lower().split():

            word = word.strip(strip)

            if len(word) > 2:

                if words[word] = words.get(word, 0) + 1

for word in sorted(words):

    print("'{0}' occurs {1} times".format(word, words[word]))

文件的读与写

open(filename, encoding = 'utf8') #for reading text

open(filename, 'w', encoding = 'utf8') #for writing text

惯用方法:

for line in open(filename, encoding = 'utf8')：

process(line)

readlines()方法将整个文件读入字符串列表

字典内涵

{keyexpression：valueexpression for key, value in iterable}

{keyexpression：valueexpression for key, value in iterable if condtion}

file_sizes = {name: os.path.getsize(name) for name in os.listdir(".")}

file_sizes = {name: os.path.getsize(name) for name in os.listdir(".")

				if os.path.isfile(name)}

inverted_d = {v: k for k, v in d.items()}#用于反转字典，但是对值有要求

3.3.3 默认字典

解释不清楚

import collections

words = collections.defaultdict(int)

3.3.4 有序字典

d = collections.OrderedDict([('z',-4), ('e', 19), ('k', 7)])

注意，如果括号里面传入的无序的dict，或关键字参数，那么顺序将是任意的(我在没看出来任意来)。

3.4 组合数据类型的迭代与复制

3.4.1 迭代子、迭代操作与函数（查询有关迭代子的函数点这）

语法	描述
s + t	返回一个序列，该序列是序列s与t的连接
s * n	返回一个序列，该序列是序列s的n个副本的连接
x in i	如果项x出现在iterable i 中，就返回True，not in 进行的测试则相反
all(i)	如果iterable i 中的每一项都被评估为True，就返回True
any(i)	如果iterable i中的任意项都被评估为True，就返回True
enumerate(i, start)	通常用于for ... in 循环中，提供一个(index, item)元组序列，其中的索引起始值为0或start
len(x)	返回x的“长度”，如果x是组合数据类型，那么返回的是其中数据项数；如果x是一个字符串，那么返回的是其中包含的字符数
max(i,key)	返回iterable i 中的最大的项，如果给定的是key函数，就返回key值最大的项
min(i, key)	...
range(start, stop, step)	返回一个整数迭代子。使用一个参数(stop)时，迭代子的取值范围从0到stop-1;使用参数(start,stop)时，迭代子取值范围从start到stop-1；3个参数全部使用时，迭代范围从start到stop-1，但每俩个值之间间隔step
reversed(i)	返回一个迭代子，该迭代子以反序从迭代子i中返回项#dict 不行有序字典倒是可以
sorted(i, key, reverse)	以排序后顺序从迭代子i返回项，key用于提供DSU（修饰、排序、反修饰）排序，如果reverse为True，则排序以反序进行
sum(i,start)	返回iterable i 中项的和，加上start（默认为0)，i 可以包含字符串
zip(i1, ... ,iN	返回元组的迭代子，使用迭代子i1到iN

x = [-2, 9, 7, -4, 3]

all(x), any(x), len(x), min(x), max(x), sum(x)

#(True, True, 5, -4, 9, 13)

iter() and next()

iter() 将返回一个用于传递给函数的对象的迭代子，如果该对象无法进行迭代，则产生一个TypeError (还有另外一种用法，关于参数和哨点值，另外再说吧（P114）).

next()会依次返回每个相继的数据项，直到没有数据项时产生StopIteration异常。

product = 1

for i in [1, 2, 3, 4]:

	product *= i

print(product)

与下面的是一样的：

product = 1

i = iter([1, 2, 3, 4])

while True:

	try:

		product *= next(i)

	except StopIteration:

		break

print(product)

实例：程序读入一个forename文件与一个surname文件，创建俩个列表，之后创建test-names1.txt并向其中写入100个随机的名称

import random

def get_fornames_and_surnames():

	forenames = []

	surnames = []

	for names, filename in ((fornames, 'data/forenames.txt'),

							(surnames, 'data/surnames.txt')):

		for name in open(filename, encoding='utf8'):

			names.append(name.rstrip()) #删除字符串末尾指定字符（默认为空格）

	return forenames, surnames

forenames, surnames = get_fornames_and_surnames()

fh = open('test-names.txt', 'w', encoding='utf8')

for i in range(100):

	line = "{0} {1}\n".format(random.choice(forenames),

							random.choice(surnames))

	fh.write(line)

fh.close()

zip()

zip()会返回一个迭代子，每个元素是一个元组。

for t in zip(range(4), range(0, 10, 2), range(1, 10, 2)):

	print(t)

#(0, 0, 1)

#(1, 2, 3)

#(2, 4, 5)

#(3, 6, 7)

#注意，即便传入的迭代子长度不一致，依然可以使用，取小。

for i in zip([1, 2], [1, 2, 3]):

    print(i)

#（1, 1)

# (2, 2)

sorted() and reversed()

list(range(6)) #[0, 1, 2, 3, 4, 5]

list(reversed(range(6))) #[5, 4, 3, 2, 1, 0]

x = []

for t in zip(range(-10, 0, 1), range(0, 10, 2), range(1, 10, 2)):

    x += t

x

#[-10, 0, 1, -9, 2, 3, -8, 4, 5, -7, 6, 7, -6, 8, 9]

sorted(x)

#[-10, -9, -8, -7, -6, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

sorted(x, reverse = True)

#[9, 8, 7, 6, 5, 4, 3, 2, 1, 0, -6, -7, -8, -9, -10]

sorted(x, key = abs)

#[0, 1, 2, 3, 4, 5, 6, -6, -7, 7, -8, 8, -9, 9, -10]

key关键字传入函数或方法，相当于先将x中的元素“修饰”，再对“修饰”后的元素加以排列得到一个序，最后的结果是x以这个序进行排列。

x = list(zip((1, 3, 1, 3), ('pram', 'dorie', 'kayak', 'canoe')))

print(x)

print(sorted(x))

def swap(t):

    return t[1], t[0]

print(sorted(x, key=swap))

#[(1, 'pram'), (3, 'dorie'), (1, 'kayak'), (3, 'canoe')]

#[(1, 'kayak'), (1, 'pram'), (3, 'canoe'), (3, 'dorie')]

#[(3, 'canoe'), (3, 'dorie'), (1, 'kayak'), (1, 'pram')]

注意：sorted()只适用于可以进行相互比较的组合类型

sorted([1, '1')]  #TypeError

不过，对于上面这种情况，有一个处理方法: key = int/float，当然这也只是对字符串为“数字”的特殊情形。

3.4.2 组合类型的复制

浅拷贝

a = [1, '2', 3]

b = a

a[1] = 'two'

a, b #([1, 'two', 3], [1, 'two', 3])

a = [1, ['2', 5], 3]

b = a[:]

a[0] = 2

b[1][0] = 'two'

a, b #([2, ['two', 5], 3], [1, ['two', 5], 3])

普通的 a=b，只是使用了对象引用，a, b指向了同一个内存对象

.copy()

dict()

list()

set()

a[:]

这些都会返回一个浅拷贝

深拷贝

a = [1, ['2', 5], 3]

b = copy.deepcopy(a)

a[0] = 2

b[1][0] = 'two'

a, b #([2, ['2', 5], 3], [1, ['two', 5], 3])

实例

生成用户名



import collections

import string

import sys

#在python中全大写的变量一般为常量，这是个约定

ID = 0

FORENAME = 1

MIDDLENAME = 2

SURNAME = 3

#命名元组

User = collections.namedtuple('User', 'username forename middlename surname id')

def Main():

    if len(sys.argv) == 1 or sys.argv[1] in ('-h', '-help'):

        print('useage: {0} file1 [file2 [... fileN]]'.format(

        sys.argv[0]))

        sys.exit()

    usernames = set()

    users = {}

    for filename in sys.argv[1:]:

        for line in open(filename, encoding='utf8'):

            line = line.rstrip()

            if line:

                user = process_line(line, usernames)

                users[(user.username.lower(),

                      user.forename.lower(),

                      user.id)] = user

    print_users(users)

def process_line(line, usernames):

    fields = line.split(':')

    username = generate_username(fields, usernames)

    user = User(username, fields[FORENAME], fields[MIDDLENAME],

               fields[SURNAME], fields[ID])

    return user

def generate_username(fields, usernames):

    username = (fields[FORENAME][0] + fields[MIDDLENAME][:1] +

               fields[SURNAME]).replace('-', '').replace("'", "")

    username = original_name = username[:8].lower()

    count = 1

    while username in usernames:

        username = "{0}{1}".format(original_name, count)

        count += 1

    usernames.add(username)

    return username

def print_users(users):

    namewidth = 32

    usernamewidth = 9

    print("{0:<{nw}} {1:^6} {2:{uw}}".format(

        'Name', 'ID', 'Username', nw = namewidth, uw = usernamewidth))

    print("{0:-<{nw}} {0:-<6} {0:-<{uw}}".format(

        '', nw=namewidth, uw=usernamewidth))

    for key in sorted(users):

        user = users[key]

        inital = ''

        if user.middlename:

            inital = ' ' + user.middlename[0]

        name = "{0.surname}, {0.forename}{1}".format(user, inital)

        print("{0:.<{nw}} {1.id:4} {1.username:{uw}}".format(

            name, user, nw = namewidth, uw = usernamewidth))

if __name__ == '__main__':

	Main()

输入是这样的：

输出是这样的：

小惊喜 m[:1]来代替m[0] 防止产生IndexError

s = ''

s[0] #报错

s[:1]#不会报错s[:k]都不会报错，只是s[:1]在s非空的情况下满足取首项的要求

处理统计信息



import collections

import string

import sys

import math

Statistics = collections.namedtuple('Statistic',

    'mean mode median std_dev')

def main():

    if len(sys.argv) == 1 or sys.argv[1] in {'-h', '-help'}:

        print('usage: {0} file1 [file2 [... fileN]'.format(

            sys.argv[0]))

        sys.exit()

    numbers = []

    frequencies = collections.defaultdict(int)

    for filename in sys.argv[1:]:

        read_data(filename, numbers, frequencies)

    if numbers:

        statistics = calculate_statistics(numbers, frequencies)

        print_results(len(numbers), statistics)

    else:

        print('no numbers found')

def read_data(filename, numbers, frequencies):

    for lino, line in enumerate(open(filename, encoding='utf8'),

                                        start = 1):

        for x in line.split():

            try:

                number = float(x)

                numbers.append(number)

                frequencies[number] += 1

            except ValueError as err:

                print('{filename}:{lino}:skipping {x}:{err}'.format(

                    **locals()))

def calculate_statistics(numbers, frequencies):

    mean = sum(numbers) / len(numbers)

    mode = calculate_mode(frequencies, 3)

    median = calculate_median(numbers)

    std_dev = calculate_std_dev(numbers, mean)

    return Statistics(mean, mode, median, std_dev)

def calculate_mode(frequencies, maximum_modes):

    highest_frequency = max(frequencies.values())

    mode = [number for number, frequency in frequencies.items()

                if frequency == highest_frequency]

    if not (1 <= len(mode) <= maximum_modes):

        mode = None

    else:

        mode.sort()

    return mode

def calculate_median(numbers):

    numbers = sorted(numbers)

    middle = len(numbers) // 2

    median = numbers[middle]

    if len(numbers) %2 == 0:

        median = (median + numbers[middle - 1]) / 2

    return median

def calculate_std_dev(numbers, mean):

    total = 0

    for number in numbers:

        total += (number - mean) **2

    variance = total / (len(numbers) - 1)

    return math.sqrt(variance)

def print_results(count, statistics):

    real = '9.2f'

    if statistics.mode is None:

        modeline = ''

    elif len(statistics.mode) == 1:

        modeline = 'mode     = {0:{fmt}}\n'.format(

            statistics.mode[0], fmt=real)

    else:

        modeline = ("mode    = ["+

                    ",".join(["{0:.2f}".format(m)

                        for m in statistics.mode]) + "]\n")

    print("""\

        count    = {0:6}

        mean     = {mean:{fmt}}

        median   = {median:{fmt}}

        {1}\

        std.dev. = {std_dev:{fmt}}""".format(

            count, modeline, fmt=real, **statistics._asdict()))

if __name__ == '__main__':

    main()

小惊喜 print 三引号

上面的例子中出现了三引号，三引号使得程序以我们所可理解的方式展示文本（大概就是不用加\n之类的）。

print("""

aaaaa

ddddd

""")

aaaaa

ddddd

print("""

aaaaa \

ddddd

""")

aaaaa ddddd

注意这个时候 \ 可以起到把空行转义掉，回到原来的形状。

print("""

aaaaa\n\

ddddd

""")