Python-封装和解构-set及操作-字典及操作-解析式生成器-内建函数迭代器-学习笔记

序

欠4年前自己的一份笔记，献给今后的自己。

封装和解构

• 封装
  将多个值使用逗号分割，组合在一起
  本质上，返回一个元组，只是省掉了小括号
  python特有语法，被很多语言学习和借鉴

t1 = (1,2) # 定义为元组
t2 = 1,2 # 将1和2封装成元组print(type(t1))   # <class 'tuple'>print(type(t2))   # <class 'tuple'>

举例

a = 4
b = 5
temp = a
a = b
b = temp
等价于
a, b = b, a
上句中，等号右边使用了封装，而左边就使用了解构

解构

• 把线性结构的元素解开，并顺序的赋给其它变量
• 左边接纳的变量数要和右边解开的元素个数一致
• 举例

lst = [3, 5]
first, second = lst
print(first, second)  # 3 5

• 举例

a,b = 1,2
a,b = (1,2)
a,b = [1,2]
a,b = [10,20]
a,b = {10,20}
a,b = {'a':10,'b':20} # 非线性结构也可以解构
a,b = {10,20,30}
a,*b = {10,20,30}
[a,b] = (1,2)
[a,b] = 10,20
(a,b) = {30,40}

Python3的解构

• 使用 *变量名 接收，但不能单独使用
• 被 *变量名 收集后组成一个列表
• 举例

lst = list(range(1, 10, 2))
print(list)     # <class 'list'>head, *mid, tail = lstprint(head, mid, tail)     # 1 [3, 5, 7] 9# *lst2 = lst*body, tail = lstprint(body,tail) #  [1, 3, 5, 7] 9head, *tail = lstprint(head, tail)   # 1 [3, 5, 7, 9]#head, *m1, *m2, tail = lsthead, *mid, tail = "abcdefghijklmn"
print( head ,mid ,tail)  #  a ['b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm'] n
print(type(mid))  #<class 'list'>

丢弃变量

• 这是一个惯例，是一个不成文的约定，不是标准
• 如果不关心一个变量，就可以定义改变量的名字为_
• _是一个合法的标识符，也可以作为一个有效的变量使用，但是定义成下划线就是希望不要被使用，除非你明确的知道这个数据需要使用

举例一

lst = [9,8,7,20]
first, *second = lst
head, *_, tail = lst
print(first)   # 9
print(second)        # [8, 7, 20]print(head)   # 9
print(tail)   # 20#   _是合法的标识符，看到下划线就知道这个变量就是不想被使用print(_)  # [8, 7] 

举例二

lst = [9,8,7,20]
first, *second = lst
_, *_, tail = lst
print(_)                    # [8, 7]
print(tail)             # 20
print(_) # [8, 7]

• 总结
  _ 这个变量本身无任何语义，没有任何可读性，所以不是用来给人使用的 Python中很多库，都使用这个变量，使用十分广泛。请不要在不明确变量作用域的情况下，使用 _ 导致和库中_ 冲突

练习

• lst = list(range(10)) # 这样一个列表，取出第二个、第四个、倒数第二个

lst = list(range(10))
print(lst)
print(lst[2])
print(lst[4])
print(lst[len(lst) - 2 ])

• 从lst = [1,(2,3,4),5]中，提取4出来

lst = list(range(10))
print(lst)          # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(lst[2])       # 2
print(lst[4])       # 4
print(lst[len(lst) - 2 ])               # 8

• 环境变量JAVA_HOME=/usr/bin，返回变量名和路径

key, _ , val = "JAVA_HOME=/usr/bin".partition('=')
print(key)                          # JAVA_HOME
print(val)                          # /usr/bin

• 总结：
  解构，是Python提供的很好的功能，可以方便的提取复杂数据结构的值
  配合 _ 的使用，会更加便利

集set

• 约定
  set 翻译为集合
  collection 翻译为集合类型，是一个大概念
• set
  可变的、无序的、不重复的元素的集合

set定义 初始化

• set() -> new empty set object
• set(iterable) -> new set object

s1 = set()
s2 = set(range(5))
s3 = set(list(range(10)))
s4 = {} # ?
print(s4)                   # {}
s5 = {9,10,11} # set
print(s5)                   # {9, 10, 11}
s6 = {(1,2),3,'a'}
print(s6)                   # {(1, 2), 3, 'a'}
s7 = {[1],(1,),1} # ?
# Traceback (most recent call last):
#   File "/Users/quyixiao/pp/python_lesson/jk/zhushi/test2.py", line 10, in <module>
#     s7 = {[1],(1,),1} # ?
#          ^^^^^^^^^^^^
# TypeError: unhashable type: 'list'
print(s7)

set的元素

• set的元素要求必须可以hash
• 目前学过的不可hash的类型有list、set
• 元素不可以索引
• set可以迭代

s = set()
print(type(s))  # <class 'set'>
s = set(range(10))                           
print(s)                              # {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}     
s = {1, 2, 3}
print(s)                        #{1, 2, 3}                        s = {}
print(s)                            #{}
print(type(s))                      # <class 'dict'>s = set(list(tuple(map(str, range(5)))))print(s)                # {'1', '3', '2', '0', '4'}s1 = set()
s2 = set(range(5))
s3 = set(list(range(5)))
print(s3)               #{0, 1, 2, 3, 4}        print(hash(1))                      # 1print(hash((2, 3, 'aaaa')))  # 可以说是一个线性结构， 7769586874448940022print(hash((2, 3, b'aaaa')))  # 可以说是一个线性结构 ， 7769586874448940022

set增加

• add(elem)
  增加一个元素到set中
  如果元素存在，什么都不做
• update(*others)
  合并其他元素到set集合中来
  参数others必须是可迭代对象
  就地修改

s = {}
s = set(list(tuple(map(str, range(5)))))
print(s)                        # {'4', '1', '0', '3', '2'}s.add('abc')
print(s)                                         # {'4', 'abc', '1', '0', '3', '2'}
s.add(0)s.update(range(5), range(3, 7))
print(s)            # {0, 1, 2, 3, 4, 5, '4', 6, 'abc', '1', '0', '3', '2'}
s.add('bcd')                
print(s)                                # {0, 1, 2, 3, 4, 5, '4', 6, 'abc', '1', '0', '3', 'bcd', '2'}
s.update('bcd', '123')
print(s)                        # {0, 1, 2, 3, 4, 5, '4', 6, 'abc', '1', '0', 'c', '3', 'b', 'bcd', '2', 'd'}
s.add(-1)
print(s)                        # {0, 1, 2, 3, 4, 5, '4', 6, 'abc', '1', '0', 'c', '3', 'b', 'bcd', '2', -1, 'd'}

set删除

• remove(elem)
  从set中移除一个元素
  元素不存在，抛出KeyError异常。为什么是KeyError？
• discard(elem)
  从set中移除一个元素
  元素不存在，什么都不做
• pop() -> item
  移除并返回任意的元素。为什么是任意元素？
  空集返回KeyError异常
• clear()
  移除所有元素

remove例子

s = {"abc","bcd"}
print(s)                        # {'bcd', 'abc'}s.remove('bcd')                 # {'abc'}print(s)
a = s.pop()
print(a)                    # abc
print(s)                    # set()

discard 例子

s = {"abc","bcd"}
print(s)                        # {'bcd', 'abc'}print(s.discard('xxx'))  # discard(element) 从set移除一个元素，元素不存在，将什么都不做print(s)                # {'abc', 'bcd'}

clear 例子

s = {"abc","bcd"}
print(s)                        # {'bcd', 'abc'}a = s.clear();print(a)                    # None
print(s)                # set()

set修改、查询

• 修改
  要么删除，要么加入新的元素
  为什么没有修改？
• 查询
  非线性结构，无法索引
• 遍历
  可以迭代所有元素
• 成员运算符
  in 和 not in 判断元素是否在set中
  效率呢？

set成员运算符的比较

• list和set的比较
• lst1 = list(range(100))
• lst2 = list(range(1000000))
• -1 in lst1、-1 in lst2 看看效率
• set1 = set(range(100))
• set2 = set(range(1000000))
• -1 in set1、-1 in set2 看看效率

例子1

import datetime
import timeitlst2 = list(range(1000000))start = datetime.datetime.now()
print(-1 in lst2)                   # False
end = datetime.datetime.now()
print(end - start) # 0:00:00.003714start = datetime.datetime.now()
print(-1 in set(range(10000009)))                       # False
end = datetime.datetime.now()
print(end - start) # 0:00:00.216222

例子2

import datetime
import timeitlst2 = list(range(100))start = datetime.datetime.now()
print(-1 in lst2)                   # False
end = datetime.datetime.now()
print(end - start) # 0:00:00.000024start = datetime.datetime.now()
print(-1 in set(range(100)))                       # False
end = datetime.datetime.now()
print(end - start) # 0:00:00.000004

set和线性结构

• 线性结构的查询时间复杂度是O(n)，即随着数据规模的增大而增加耗时
• set、dict等结构，内部使用hash值作为key，时间复杂度可以做到O(1)，查询时间和数据规模无关
• 可hash
  数值型int、float、complex
  布尔型True、False
  字符串string、bytes
  tuple
  None
  以上都是不可变类型，成为可哈希类型，hashable
• set的元素必须是可hash的

集合

• 基本概念
  全集
          所有元素的集合。例如实数集，所有实数组成的集合就是全集
  子集subset和超集superset
          一个集合A所有元素都在另一个集合B内，A是B的子集，B是A的超集
  真子集和真超集
          A是B的子集，且A不等于B，A就是B的真子集，B是A的真超集
  并集：多个集合合并的结果
  交集：多个集合的公共部分
  差集：集合中除去和其他集合公共部分

例子1

• 共同好友
  你的好友A、B、C，他的好友C、B、D，求共同好友
  交集问题：{‘A’, ‘B’, ‘C’}.intersection({‘B’, ‘C’, ‘D’})
• 微信群提醒
  1、XXX与群里其他人都不是微信朋友关系
  2、并集：userid in (A | B | C | …) == False，A、B、C等是微信好友的并集，用户ID不在这个并集中，说明他和任何人都不是朋友

set1 = {'A', 'B', 'C'}
set2 = {'e', 'f', 'D', 'C'}
set3 = set1 & set2
print(set3)                         # {'C'}
if set3 == set():print('xxx 与群里的其他人没有微信朋友关系')
else:print('xxx 与群里的其他的人有朋友关系')

集合运算

• 并集
  将两个集合A和B的所有的元素合并到一起，组成的集合称作集合A与集合B的并集
• union(*others)
  返回和多个集合合并后的新的集合
• | 运算符重载
  等同union
• update(*others)
  和多个集合合并，就地修改
• |=
  等同update

• 交集
  集合A和B，由所有属于A且属于B的元素组成的集合
  intersection(*others)
           返回和多个集合的交集
  &
           等同intersection
  intersection_update(*others)
           获取和多个集合的交集，并就地修改
  &=
          等同intersection_update

• 差集
  集合A和B，由所有属于A且不属于B的元素组成的集合
  difference(*others)
           返回和多个集合的差集
  -
  等同difference
  difference_update(*others)
          获取和多个集合的差集并就地修改
  -=
          等同difference_update

• 对称差集
          集合A和B，由所有不属于A和B的交集元素组成的集合，记作（A-B）（B-A）
  symmetric_differece(other)
          返回和另一个集合的差集
  ^
          等同symmetric_differece
  symmetric_differece_update(other)
          获取和另一个集合的差集并就地修改
  ^=
          等同symmetric_differece_update

例子

• 随机产生2组各10个数字的列表，如下要求：
  每个数字取值范围[10,20]
  统计20个数字中，一共有多少个不同的数字？
  2组比较，不重复的数字有几个？分别是什么？
  2组比较，重复的数字有几个？分别是什么？

a = [1, 9, 7, 5, 6, 7, 8, 8, 2, 6]
b = [1, 9, 0, 5, 6, 4, 8, 3, 2, 3]#
s1 = set(a)
s2 = set(b)
print(s1)               # {1, 2, 5, 6, 7, 8, 9}
print(s2)               # {0, 1, 2, 3, 4, 5, 6, 8, 9}
print(s1.union(s2))  #  {0, 1, 2, 3, 4, 5, 6, 7, 8, 9} , 联合问题 ，两个联合问题
print(s1.symmetric_difference(s2))  # {0, 3, 4, 7}, 没有的  ，不重复的数值
print(s1.intersection(s2))  # {1, 2, 5, 6, 8, 9} ,公共的 重复的数值是

• issubset(other)、<=
  判断当前集合是否是另一个集合的子集
• set1 < set2
  判断set1是否是set2的真子集
• issuperset(other)、>=
  判断当前集合是否是other的超集
• set1 > set2
  判断set1是否是set的真超集
• isdisjoint(other)
  当前集合和另一个集合没有交集
  没有交集，返回True

例子1

s1 = {1, 2, 3}
s2 = {2, 3, 4}
print(s1 > s2)              # False
print(s1 < s2)          # Falseprint(s1 == s2)  # Falses1.add(4)
s2.add(2)print(s1)                   # {1, 2, 3, 4}
print(s2)                   #{2, 3, 4}print(s1.isdisjoint(s2))                # False, isdisjoint 是不是有交集
print(s1 & s2 == set())         #False

集合应用

• 权限判断
  有一个API，要求权限同时具备A、B、C才能访问，用户权限是B、C、D，判断用户是否能够访问该API
          API集合A，权限集合P
          A - P = {} ，A-P为空集，说明P包含A
          A.issubset§ 也行，A是P的子集也行
          A & P = A 也行

A = {'A','B','C'}
P = {'B','C','D'}print(A - P == {})     # False, A-P为空集，说明P包含A
print(A.issubset(P))        # False   A是P的子集也行
print( A & P == A)             #False,  A & P = A 也行

有一个API，要求权限具备A、B、C任意一项就可访问，用户权限是B、C、D，判断用户是否能够访问该API
        API集合A，权限集合P
        A & P != {} 就可以
        A.isdisjoint§ == False 表示有交集

A = {'A','B','C'}P = {'B','C','D'}print(A - P != {})    # True ,A & P != {} 就可以
print(A.isdisjoint(P))  #False

字典dict

• key-value键值对的数据的集合
• 可变的、无序的、key不重复

字典dict定义 初始化

• = dict() 或者 d = {}
• dict(**kwargs) 使用name=value对初始化一个字典
• dict(iterable, **kwarg) 使用可迭代对象和name=value对构造字典，不过可迭代对象的元素必须是一个二元结构
• d = dict(((1,‘a’),(2,‘b’))) 或者 d = dict(([1,‘a’],[2,‘b’]))
• dict(mapping, **kwarg) 使用一个字典构建另一个字典
• d = {‘a’:10, ‘b’:20, ‘c’:None, ‘d’:[1,2,3]}
• 类方法dict.fromkeys(iterable, value)
• d = dict.fromkeys(range(5))
• d = dict.fromkeys(range(5),0)

# key-value 键值对的数据的集合
# 可变的，无序的，key 不重复
# 是不可重复的元素，key 在整个元素中
# dict()d = {}
d = {'a': 10, 'b': 20, 'c': [1, 2, 3, 4]}print(d)                    # {'a': 10, 'b': 20, 'c': [1, 2, 3, 4]}
d = dict(a=1, b=2)              
print(d)                    # {'a': 1, 'b': 2}
e = {'234': '123'}
print(e)                    # {'234': '123'}
print('-----------------------------------------')
d = dict(([1, 'a'], [2, 'b']))
print(d)                    # {1: 'a', 2: 'b'}
d = dict.fromkeys(range(5))             print(d)                    # {0: None, 1: None, 2: None, 3: None, 4: None}

字典元素的访问

• d[key]
  返回key对应的值value
  key不存在抛出KeyError异常
• get(key[, default])
  返回key对应的值value
  key不存在返回缺省值，如果没有设置缺省值就返回None
• setdefault(key[, default])
  返回key对应的值value
  key不存在，添加kv对，value为default，并返回default，如果default没有设置，缺省为None

# 表示是一个引用类型
d = dict.fromkeys(range(5), [1000])print(d)            #{0: [1000], 1: [1000], 2: [1000], 3: [1000], 4: [1000]}
#
print(id(d[0]), id(d[1]))       # 4309072320 4309072320# 用映射来实现一个值# 可以 hash 就可以作为 key
# 元组是不一定可以
# 常见的是可以的# print(id(d[0]),id(d[5])) 只要是 key 那么就必须唯一e = d.get(33)  #  没有返回值,函数是返回的值是，容易出现 key 不存在的情况,print(e) #Nonef = d.setdefault(100, 2)  # 如果不存在的话，则返回默认值，如果存在，则返回之前的默认值
print(f)            # 2 
f = d.setdefault(100, 3)
print(f)  # 2 
# d[key] = value
# 将 key 不存在的话，则直接创建一个值
d[38928] = 2002  # 如果 key 存在，就创建，如果 key 不存在，则
print(d)                            # {0: [1000], 1: [1000], 2: [1000], 3: [1000], 4: [1000], 100: 2, 38928: 2002}       

字典增加和修改

• d[key] = value
  将key对应的值修改为value
  key不存在添加新的kv对
• update([other]) -> None
  使用另一个字典的kv对更新本字典
  key不存在，就添加
  key存在，覆盖已经存在的key对应的值
  就地修改
          d.update(red=1)
          d.update(((‘red’,2),))
          d.update({‘red’:3})

d = {'a': 10, 'b': 20, 'c': [1, 2, 3, 4]}print(d)                # {'a': 10, 'b': 20, 'c': [1, 2, 3, 4]}
# 字典是无序的
d.update(red=1)         
print(d)                # {'a': 10, 'b': 20, 'c': [1, 2, 3, 4], 'red': 1}
d.update((('red', 2),)) 
print(d)                # {'a': 10, 'b': 20, 'c': [1, 2, 3, 4], 'red': 2}
d.update({'red': 3})    
print(d)                #{'a': 10, 'b': 20, 'c': [1, 2, 3, 4], 'red': 3}

字典删除

• pop(key[, default])
  key存在，移除它，并返回它的value
  key不存在，返回给定的default
  default未设置，key不存在则抛出KeyError异常
• popitem()
  移除并返回一个任意的键值对
  字典为empty，抛出KeyError异常
• clear()
  清空字典

d = {'a': 10, 'b': 20, 'c': [1, 2, 3, 4]}print(d)                # {'a': 10, 'b': 20, 'c': [1, 2, 3, 4]}
# 字典删除
d.pop('a')          # {'b': 20, 'c': [1, 2, 3, 4]}print(d) #
#  如果什么都没有写的话，随机是可以
key,value =d.popitem()
print(key,value)        # c [1, 2, 3, 4]x = d.pop(3289328932,3) # 如果没有这个值 ，返回默认值print(x)        # 3## Traceback (most recent call last):
#  File "/Users/quyixiao/pp/python_lesson/jk/zhushi/test2.py", line 14, in <module>
#    xx = d.pop(3289328932) # 如果这个值没有的话，就会返回错误
#KeyError: 3289328932# y = d.pop(3289328932) # 如果这个值没有的话，就会返回错误# clear
# 清空字典

字典删除

• del语句

a = True
b = [6]
d = {'a': 1, 'b': b, 'c': [1,3,5]}
del a
#  File "/Users/quyixiao/pp/python_lesson/dicttest/dictlianxi.py", line 5
#    print(a)
# IndentationError: unexpected indent
# print(a)del d['c']      # 删除了一个对象[1,3,5]？
print(d)        # {'a': 1, 'b': [6]}del b[0]
print(b)        # []c = b
del c
print(b)        #[]
# Traceback (most recent call last):
#   File "/Users/quyixiao/pp/python_lesson/dicttest/dictlianxi.py", line 19, in <module>
#     print(c)
#           ^
# NameError: name 'c' is not defined
# print(c)print(d)    # {'a': 1, 'b': []}
del b
b = d['b']
print(b)      # []

• del a[‘c’] 看着像删除了一个对象，本质上减少了一个对象的引用，del 实际上删除的是名称，而不是对象

字典遍历

• for … in dict
          遍历key
                  for k in d:
                          print(k)
                  for k in d.keys():
                          print(k)

• for … in dict
          遍历value
                  for k in d:
                          print(d[k])
                  for k in d.keys():
                          print(d.get(k))
                  for v in d.values():
                          print(v)

• for … in dict
          遍历item，即kv对
                  for item in d.items():
                          print(item)
                  for item in d.items():
                          print(item[0], item[1])
                  for k,v in d.items():
                          print(k, v)
                  for k, _ in d.items():
                          print(k)
                  for _ ,v in d.items():
                          print(v)

• 总结
  Python3中，keys、values、items方法返回一个类似一个生成器的可迭代对象，不会把函数的返回结
  果复制到内存中
          Dictionary view对象
          字典的entry的动态的视图，字典变化，视图将反映出这些变化
  Python2中，上面的方法会返回一个新的列表，占据新的内存空间。所以Python2建议使用iterkeys、
          itervalues、iteritems版本，返回一个迭代器，而不是一个copy

字典遍历和移除

• 如何在遍历的时候移除元素
  错误的做法
          d = dict(a=1, b=2, c=‘abc’)
          for k,v in d.items():
                  d.pop(k) # 异常
          while len(d): # 相当于清空，不如直接clear()
                  print(d.popitem())
  正确的做法
          d = dict(a=1, b=2, c=‘abc’)
          keys = []
          for k,v in d.items():
                  if isinstance(v, str):
                          keys.append(k)
          for k in keys:
                  d.pop(k)
          print(d)

d = {1: 3, 2: 4}
for key in d.keys():print(key,end= ' ')     # 1 2
print()# print values 如何打印数值for value in d.values():print(value,end = ' ')  # 3 4print()for item in d.items():print(item,end=' ')     # (1, 3) (2, 4)print()for item in d.items():print(item[0], item[1], end =',')       # 1 3,2 4,print()for k, v in d.items():print(k, v,end ='|')            # 1 3|2 4|print()for k, _in in d.items():print(k, end=',')       # 1,2,print('----------------------------')for _, value in d.items():print(value,end = ',')      # 3,4,print()
# 总结
# python3 中的 keys，value
# 但是这个东西是一个
#
print('=============================================')# 在迭代的过程中是不允许动的
#for k in d:
# print(k)
# d.pop()
# 表示一个个的移除, 当你在迭代的过程中，如果你在 for 循环之后，如果修改字典的长度，那是不允许的while(len(d)):d.popitem()for k in d:print(k)print('+++++++++++++++++++++++++++++++++++++++++++++++++++')d = dict(a = 1 ,b = 2 ,c = 3 ,d = 'str1')lst = []for k in d.keys():print('=============',k)if isinstance(d[k],str):lst.append(k)print(lst)   # ['d']
for k in lst:print(d.pop(k))     # str1# 在迭代的过程中是不能遍历和移除元素
# RuntimeError: dictionary changed size during iteration
#for k in d :
#    d['1000'] = 100# key 的要求和 set 的元素要求一致
# set 的元素可以就是看做 key ,set 可以看做是 dict 的简化版本
# hashcode 可哈希才可以作为 key,可以使用 hash() 测试
# d = {1:0,2.0:3 ,'abc' : None,('hello','word','python'): 'string',b'abc':135},

字典的key

• key的要求和set的元素要求一致
  set的元素可以就是看做key，set可以看做dict的简化版
  hashable 可哈希才可以作为key，可以使用hash()测试

d = {1: 0, 2.0: 3, "abc": None, ('hello', 'world', 'python'): "string", b'abc': '135'}print(d) # {1: 0, 2.0: 3, 'abc': None, ('hello', 'world', 'python'): 'string', b'abc': '135'}

defaultdict

• collections.defaultdict([default_factory[, …]])
  第一个参数是default_factory，缺省是None，它提供一个初始化函数。当key不存在的时候，会调用这个工厂函数来生成key对应的value
  方法1

import randomd1 = {}
for k in 'abcdef':for i in range(random.randint(1, 5)):if k not in d1.keys():d1[k] = []d1[k].append(i)
print(d1)   # {'a': [0], 'b': [0, 1], 'c': [0, 1, 2, 3, 4], 'd': [0, 1, 2], 'e': [0, 1, 2, 3, 4], 'f': [0, 1, 2, 3, 4]}

方法二：

import random
from collections import defaultdictd1 = defaultdict(list)
for k in 'abcdef':for i in range(random.randint(1, 5)):d1[k].append(i)
print(d1) # defaultdict(<class 'list'>, {'a': [0, 1, 2, 3, 4], 'b': [0, 1, 2, 3], 'c': [0, 1, 2, 3], 'd': [0, 1], 'e': [0, 1, 2], 'f': [0, 1, 2]})

OrderedDict

• collections.OrderedDict([items])
  key并不是按照加入的顺序排列，可以使用OrderedDict记录顺序

• 有序字典可以记录元素插入的顺序，打印的时候也是按照这个顺序输出打印

• 3.6版本的Python的字典就是记录key插入的顺序（IPython不一定有效果）
  应用场景：
          假如使用字典记录了N个产品，这些产品使用ID由小到大加入到字典中
          除了使用字典检索的遍历，有时候需要取出ID，但是希望是按照输入的顺序，因为输入顺序是有序的
          否则还需要重新把遍历到的值排序

from collections import OrderedDict
import randomd = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}
print(d)            # {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}
keys = list(d.keys())
print(keys)     # ['banana', 'apple', 'pear', 'orange']
random.shuffle(keys)        # 打乱列表的元素
print(keys)     # ['pear', 'banana', 'apple', 'orange']od = OrderedDict()
for key in keys:od[key] = d[key]
print(od)       # OrderedDict({'pear': 1, 'banana': 3, 'apple': 4, 'orange': 2})
print(od.keys())        # odict_keys(['pear', 'banana', 'apple', 'orange'])

字典练习

用户输入一个数字,打印每一位数字及其重复的次数

num = input('>>')d = {}for c in num:if not d.get(c):d[c] = 1continued[c] += 1print(d)d = {}for c in num:if c not in d.keys():d[c] = 1else:d[c] += 1print(d)

数字重复统计

随机产生100个整数 , 数字的范围［-1000，1000］ , 升序输出数字及其重复的次数

import randomn = 5nums = [0] * nfor i in range(n):nums[i] = random.randint(-10, 10)print(nums)         # [-5, -4, -4, -2, 2]t = nums.copy()t.sort()print(t)            # [-5, -4, -4, -2, 2]d = {}for x in nums:if x not in d.keys():d[x] = 1else:d[x] += 1print(d)        # {-5: 1, -4: 2, -2: 1, 2: 1}d1 = sorted(d.items())
print(d1)           # [(-5, 1), (-4, 2), (-2, 1), (2, 1)]

字符串重复统计

字符表‘abcdefghijkImnopqrstuvwxyz‘，随机挑选2个字母组成字符串，共挑选10个降序输出这10个字符串及重复的次数

import randomalphabet = 'abcdefghijkImnopqrstuvwxyz'words = []for _ in range(10):# words.append (random.choice(alphabet)+random.choice(alphabet))# words.append（''.join（random.sample（alphabet, 2））） 随机采样words.append(''.join(random.choice(alphabet) for _ in range(2)))  # thatd = {}for x in words:d[x] = d.get(x, 0) + 1print(d)        # {'Io': 1, 'xt': 1, 'II': 1, 'wy': 1, 'ie': 1, 're': 1, 'ke': 1, 'wz': 1, 'gn': 1, 'nq': 1}d1 = sorted(d.items(), reverse=True)print(d1)       # [('xt', 1), ('wz', 1), ('wy', 1), ('re', 1), ('nq', 1), ('ke', 1), ('ie', 1), ('gn', 1), ('Io', 1), ('II', 1)]

返回1-10平方的列表

print([x**2 for x in range(1,11)])  # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

有一个列表Ist =［1，4，9，16，2，5，10，15］，生成一个新列表，要求新列表元素是Ist相邻2项的和

lst = [1,4,9,16,2,5,10,15]print([lst[i]+lst[i+1] for i in range(len(lst)-1)])   # [5, 13, 25, 18, 7, 15, 25]

打印九九乘法表

[print('{}*{}={:<3}{}'.format(j,i,i*j, '\n' if i==j else ''),end="") for i in range( 1,10) for j in range(1,i+1)]输出：
1*1=1  
1*2=2  2*2=4  
1*3=3  2*3=6  3*3=9  
1*4=4  2*4=8  3*4=12 4*4=16 
1*5=5  2*5=10 3*5=15 4*5=20 5*5=25 
1*6=6  2*6=12 3*6=18 4*6=24 5*6=30 6*6=36 
1*7=7  2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 
1*8=8  2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 
1*9=9  2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81 

生成ID

“0001.abadicddws”是ID格式，要求ID格式是以点号分割，左边是4位从1开始的整数，右边是10位随机小写英文字母。请依次生成前100个ID的列表

import random
import string# ['0001.qgndzdidct', '0002.gqhrqdsavq', '0003.rdxbkgbuzq', '0004.nquklydgqu', '0005.uuhhwplmhj', '0006.tcoscaxopz', '0007.xpqagqwwyi', '0008.idqzzlvnza', '0009.clxhkzqpsf']
print(['{:04}.{}'.format(n, ''.join([random.choice(bytes(range(97, 123)).decode()) for _ in range(10)])) for n in range(1, 10)])#['0001.lcihilzmno', '0002.dyqlsjizjz', '0003.yxllmtcicp', '0004.bkzgspsygm', '0005.okbzmdkzln', '0006.ctfkgzbwfg', '0007.vphzodaabj', '0008.enqfyqcahr', '0009.utzoylyden']
print(["{:04}.{}".format(i, "".join([chr(random.randint(97, 122)) for j in range(10)])) for i in range(1, 10)])# ['0001.oolgnryrtw', '0002.ipzdkpvvoo', '0003.sazorbsoak', '0004.iyctigvrhl', '0005.qdlsyrvjju', '0006.fiyompteud', '0007.jqziibnmqv', '0008.cosbiwqcix', '0009.hlpnhpnefj']
print(['{:>04}.{}'.format(i, ''.join(random.choice(string.ascii_lowercase) for _ in range(0, 10))) for i in range(1, 10)])

解析式生成器

标准库datetime

• datetime模块
  对日期、时间、时间戳的处理
  datetime类
          类方法
          today（）返回本地时区当前时间的datetime对象
           now（tz= None） 返回当前时间的datetime对象，时间到微秒，如果tz为None，返回和today（）一样
          utcnow（） 没有时区的当前时间
          fromtimestamp（timestamp， tz=None） 从一个时间戳返回一个datetime对象口
  datetime对象
          timestamp（）返回一个到微秒的时间戳。
                  时间戳：格林威治时间1970年1月1日0点到现在的秒数

• datetime对象
  构造方法 datetime.datetime(2016, 12, 6, 16, 29, 43, 79043)
  year、month、day、hour、minute、second、microsecond，取datetime对象的年月日时分秒及微秒
  weekday() 返回星期的天，周一0，周日6
  isoweekday() 返回星期的天，周一1，周日7
  date() 返回日期date对象
  time() 返回时间time对象
  replace() 修改并返回新的时间
  isocalendar() 返回一个三元组(年，周数，周的天)

import datetimeprint(type(datetime.datetime.now()))  # <class 'datetime.datetime'>
print(datetime.datetime(2017,10,1))  # 2017-10-01 00:00:00print(datetime.datetime.fromtimestamp(1))    #1970-01-01 08:00:01b = datetime.datetime.now().weekday()  
print(b )  # 3

• 日期格式化
  类方法 strptime(date_string, format) ，返回datetime对象
  对象方法 strftime(format) ，返回字符串
  字符串format函数格式化

import datetime
dt = datetime.datetime.strptime("21/11/06 16:30", "%d/%m/%y %H:%M")
print(dt.strftime("%Y-%m-%d %H:%M:%S"))       # 2006-11-21 16:30:00
print("{0:%Y}/{0:%m}/{0:%d} {0:%H}::{0:%M}::{0:%S}".format(dt))  # 2006/11/21 16::30::00

• timedelta对象
  datetime2 = datetime1 + timedelta
  datetime2 = datetime1 - timedelta
  timedelta = datetime1 - datetime2
  构造方法
          datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0,minutes=0, hours=0, weeks=0)
          year = datetime.timedelta(days=365)
  total_seconds() 返回时间差的总秒数

import datetime
start = datetime.datetime.now()
count = 0
for x in range(2, 200000):flag = Truefor y in range(2, int(x ** 0.5) + 1):if x % y == 0:flag = Falsebreakif flag:count += 1print(count)		# 17984
end = (datetime.datetime.now() - start).total_seconds()
print(end)		# 0.316698

标准库time

• time
  time.sleep(secs) 将调用线程挂起指定的秒数

import datetime
import timestart = datetime.datetime.now()time.sleep(3)end = (datetime.datetime.now() - start).total_seconds()
print(end)  # 3.002462

列表解析

• 举例
  生成一个列表，元素0~9，对每一个元素自增1后求平方返回新列表

• 举例
  生成一个列表，元素0~9，对每一个元素自增1后求平方返回新列表

l1 = list(range(10))
l2 = []
for i in l1:l2.append((i + 1) ** 2)
print(l2)       # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

列表解析式

l1 = list(range(10))
l2 = [(i+1)**2 for i in l1]
print(l2)       # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
print(type(l2))     # <class 'list'>

列表解析List Comprehension

• 语法
  [返回值 for 元素 in 可迭代对象 if 条件]
  使用中括号[]，内部是for循环，if条件语句可选
  返回一个新的列表

• 列表解析式是一种语法糖
  编译器会优化，不会因为简写而影响效率，反而因优化提高了效率
  减少程序员工作量，减少出错
  简化了代码，但可读性增强

• 举例
  获取10以内的偶数，比较执行效率

even = []
for x in range(10):if x % 2 == 0:even.append(x)print(even)     # [0, 2, 4, 6, 8]
even = [x for x in range(10) if x%2==0]
print(even)     # [0, 2, 4, 6, 8]

• 思考
  有这样的赋值语句newlist = [print(i) for i in range(10)]，请问newlist的元素打印出来是什么？

newlist = [print(i , end= ' ') for i in range(10)]       # 0 1 2 3 4 5 6 7 8 9 
print()
print(newlist)      # [None, None, None, None, None, None, None, None, None, None]

获取20以内的偶数，如果数是3的倍数也打印[i for i in range(20) if i%20 elif i%30] 行吗？

• [expr for item in iterable if cond1 if cond2]
• 等价于
  ret = []
  for item in iterable:
          if cond1:
                  if cond2:
                          ret.append(expr)
• 举例
  20以内，既能被2整除又能被3整除的数

print([i for i in range(20) if i%2==0 and i%3==0])  # [0, 6, 12, 18]
print([i for i in range(20) if i%2==0 if i%3==0])   #[0, 6, 12, 18]

• [expr for i in iterable1 for j in iterable2 ]
• 等价于
  ret = []
          for i in iterable1:
                  for j in iterable2:
                          ret.append(expr)
  p 举例

print([(x, y) for x in 'abcde' for y in range(3)]) # [('a', 0), ('a', 1), ('a', 2), ('b', 0), ('b', 1), ('b', 2), ('c', 0), ('c', 1), ('c', 2), ('d', 0), ('d', 1), ('d', 2), ('e', 0), ('e', 1), ('e', 2)]
print([[x, y] for x in 'abcde' for y in range(3)]) # [['a', 0], ['a', 1], ['a', 2], ['b', 0], ['b', 1], ['b', 2], ['c', 0], ['c', 1], ['c', 2], ['d', 0], ['d', 1], ['d', 2], ['e', 0], ['e', 1], ['e', 2]]
print([{x: y} for x in 'abcde' for y in range(3)]) # [{'a': 0}, {'a': 1}, {'a': 2}, {'b': 0}, {'b': 1}, {'b': 2}, {'c': 0}, {'c': 1}, {'c': 2}, {'d': 0}, {'d': 1}, {'d': 2}, {'e': 0}, {'e': 1}, {'e': 2}]

列表解析进阶

• 请问下面3种输出各是什么？为什么

print([(i,j) for i in range(7) if i>4 for j in range(20,25) if j>23])   # [(5, 24), (6, 24)]
print([(i,j) for i in range(7) for j in range(20,25) if i>4 if j>23])   # [(5, 24), (6, 24)]
print([(i,j) for i in range(7) for j in range(20,25) if i>4 and j>23])  # [(5, 24), (6, 24)]

列表解析练习

• 练习（要求使用列表解析式完成）
  返回1-10平方的列表
  有一个列表lst = [1,4,9,16,2,5,10,15]，生成一个新列表，要求新列表元素是lst相邻2项的和
  打印九九乘法表
  “0001.abadicddws” 是ID格式，要求ID格式是以点号分割，左边是4位从1开始的整数，右边是
  10位随机小写英文字母。请依次生成前100个ID的列表

生成器表达式Generator expression

• 语法
  (返回值 for 元素 in 可迭代对象 if 条件)
  列表解析式的中括号换成小括号就行了
  返回一个生成器
• 和列表解析式的区别
  生成器表达式是按需计算（或称惰性求值、延迟计算），需要的时候才计算值
  列表解析式是立即返回值
• 生成器
  可迭代对象
  迭代器

生成器表达式**

• 举例

g = ("{:04}".format(i) for i in range(1, 11))next(g)for x in g:print(x)print('~~~~~~~~~~~~')
for x in g:print(x)输出：
0002
0003
0004
0005
0006
0007
0008
0009
0010
~~~~~~~~~~~~

• 总结
  延迟计算
  返回迭代器，可以迭代
  从前到后走完一遍后，不能回头

g = ["{:04}".format(i) for i in range(1, 11)]for x in g:print(x)print('~~~~~~~~~~~~')
for x in g:print(x)输出：
0001
0002
0003
0004
0005
0006
0007
0008
0009
0010
~~~~~~~~~~~~
0001
0002
0003
0004
0005
0006
0007
0008
0009
0010

• 总结
  立即计算
  返回的不是迭代器，返回可迭代对象列表
  从前到后走完一遍后，可以重新回头迭代

习题

it = (print(“{}”.format(i+1)) for i in range(2))
first = next(it)
second = next(it)
val = first + second
p val的值是什么？
p val = first + second 语句之后能否再次next(it)？

it = (print("{}".format(i+1)) for i in range(2))   # 1 , 2 
first = next(it)
second = next(it)
print(first,second)    # None None
# Traceback (most recent call last):
#   File "/Users/quyixiao/pp/python_lesson/jk/zhushi/test2.py", line 5, in <module>
#     val = first + second
#           ~~~~~~^~~~~~~~
# TypeError: unsupported operand type(s) for +: 'NoneType' and 'NoneType'
val = first + second 

it = (x for x in range(10) if x % 2)
first = next(it)
print(first)    # 1 
second = next(it)
print(second)   # 3 
val = first + second
print(val)     # 4 

p val的值是什么？
p val = first + second 语句之后能否再次next(it)？

生成器表达式

• 和列表解析式的对比
  计算方式
          生成器表达式延迟计算，列表解析式立即计算
  内存占用
          单从返回值本身来说，生成器表达式省内存，列表解析式返回新的列表
          生成器没有数据，内存占用极少，但是使用的时候，虽然一个个返回数据，但是合起来占用的内存也差不多
          列表解析式构造新的列表需要占用内存
• 计算速度
  单看计算时间看，生成器表达式耗时非常短，列表解析式耗时长
  但是生成器本身并没有返回任何值，只返回了一个生成器对象
  列表解析式构造并返回了一个新的列表

集合解析式

• 语法
  {返回值 for 元素 in 可迭代对象 if 条件}
  列表解析式的中括号换成大括号{}就行了
  立即返回一个集合
• 用法

print({(x, x + 1) for x in range(10)})  # {(0, 1), (9, 10), (1, 2), (3, 4), (2, 3), (6, 7), (4, 5), (8, 9), (5, 6), (7, 8)}
# Traceback (most recent call last):
#   File "/Users/quyixiao/pp/python_lesson/jk/zhushi/test2.py", line 3, in <module>
#     print({[x] for x in range(10)}  )
#            ^^^
# TypeError: unhashable type: 'list'
print({[x] for x in range(10)}  )

字典解析式

• 语法
  {返回值 for 元素 in 可迭代对象 if 条件}
  列表解析式的中括号换成大括号{}就行了
  使用key:value形式
  立即返回一个字典
• 用法

print({x: (x, x + 1) for x in range(10)})        # {0: (0, 1), 1: (1, 2), 2: (2, 3), 3: (3, 4), 4: (4, 5), 5: (5, 6), 6: (6, 7), 7: (7, 8), 8: (8, 9), 9: (9, 10)}
print('-'* 30 )
print({x: [x, x + 1] for x in range(10)})       # {0: [0, 1], 1: [1, 2], 2: [2, 3], 3: [3, 4], 4: [4, 5], 5: [5, 6], 6: [6, 7], 7: [7, 8], 8: [8, 9], 9: [9, 10]}
print('*'*30)
print({(x,): [x, x + 1] for x in range(10)})       # {(0,): [0, 1], (1,): [1, 2], (2,): [2, 3], (3,): [3, 4], (4,): [4, 5], (5,): [5, 6], (6,): [6, 7], (7,): [7, 8], (8,): [8, 9], (9,): [9, 10]}
print('/'*30)
# Traceback (most recent call last):
#   File "/Users/quyixiao/pp/python_lesson/jk/zhushi/test2.py", line 7, in <module>
#     print({[x]: [x, x + 1] for x in range(10)}  )
#            ^^^^^^^^^^^^^^^
# TypeError: unhashable type: 'list'
# print({[x]: [x, x + 1] for x in range(10)}  )
print('|' * 30 )
print({chr(0x41 + x): x ** 2 for x in range(10)})        # {'A': 0, 'B': 1, 'C': 4, 'D': 9, 'E': 16, 'F': 25, 'G': 36, 'H': 49, 'I': 64, 'J': 81}
print('~'* 30 )
print({str(x): y for x in range(3) for y in range(4)})  # {'0': 3, '1': 3, '2': 3}

• 用法
  print({str(x):y for x in range(3) for y in range(4)}) # {‘0’: 3, ‘1’: 3, ‘2’: 3}
  等价于
  ret = {}
          for x in range(3):
                  for y in range(4):
                          ret[str(x)] = y

总结

• Python2 引入列表解析式
• Python2.4 引入生成器表达式
• Python3 引入集合、字典解析式，并迁移到了2.7
• 一般来说，应该多应用解析式，简短、高效
• 如果一个解析式非常复杂，难以读懂，要考虑拆解成for循环
• 生成器和迭代器是不同的对象，但都是可迭代对象

内建函数

• 标识 id
  返回对象的唯一标识，CPython返回内存地址

• 哈希 hash()
  返回一个对象的哈希值

• 类型 type()
  返回对象的类型

• 类型转换
  float() int() bin() hex() oct() bool() list() tuple() dict() set() complex() bytes() bytearray()

• 输入 input([prompt])
  接收用户输入，返回一个字符串

• 打印 print(*objects, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)
  打印输出，默认使用空格分割、换行结尾，输出到控制台

• 对象长度 len(s)
  返回一个集合类型的元素个数

• isinstance(obj, class_or_tuple)
  判断对象obj是否属于某种类型或者元组中列出的某个类型
  isinstance(True, int)

• issubclass(cls, class_or_tuple)
  判断类型cls是否是某种类型的子类或元组中列出的某个类型的子类
  issubclass(bool, int)

• 绝对值abs(x) x为数值

• 最大值max() 最小值min()
  返回可迭代对象中最大或最小值
  返回多个参数中最大或最小值

• round(x) 四舍六入五取偶，round(-0.5)

• pow(x , y) 等价于 x**y

• range(stop) 从0开始到stop-1的可迭代对象；range(start, stop[, step])从start开始到stop-1结束步长为step的可迭代对象

• divmod(x, y) 等价于 tuple (x//y, x%y)

• sum(iterable[, start]) 对可迭代对象的所有数值元素求和
  sum(range(1,100,2))

• chr(i) 给一个一定范围的整数返回对应的字符
  chr(97) chr(20013)

• ord(c) 返回字符对应的整数
  ord(‘a’) ord(‘中’)

• str() 、repr()、ascii() 后面说

• sorted(iterable[, key][, reverse]) 排序
  返回一个新的列表，默认升序
  reverse是反转
          sorted([1, 3, 5])
          sorted([1, 3, 5], reverse=True)
          sorted({‘c’:1, ‘b’:2, ‘a’:1})

• 翻转 reversed(seq)
  返回一个翻转元素的迭代器
  list(reversed(“13579”))
  { reversed((2, 4)) } # 有几个元素？
  for x in reversed([‘c’,‘b’,‘a’]):
          print(x)
  reversed(sorted({1, 5, 9}))

• 枚举 enumerate(seq, start=0)
  迭代一个序列，返回索引数字和元素构成的二元组
  start表示索引开始的数字，默认是0
  for x in enumerate([2,4,6,8]):
          print(x)
  for x in enumerate(“abcde”):
          print(x,end=" ")

• 迭代器和取元素 iter(iterable)、next(iterator[, default])
  iter将一个可迭代对象封装成一个迭代器
  next对一个迭代器取下一个元素。如果全部元素都取过了，再次next会抛StopIteration异常
  it = iter(range(5))
  next(it)
  it = reversed([1,3,5])
  next(it)

可迭代对象

• 可迭代对象
  能够通过迭代一次次返回不同的元素的对象。
          所谓相同，不是指值是否相同，而是元素在容器中是否是同一个，例如列表中值可以重复的，[‘a’,‘a’]，虽然这个列表有2个元素，值一样，但是两个’a’是不同的元素
  可以迭代，但是未必有序，未必可索引
  可迭代对象有：list、tuple、string、bytes、bytearray、range、set、dict、生成器等
  可以使用成员操作符in、not in，in本质上就是在遍历对象

print(3 in range(10)) # True
print(3 in (x for x in range(10)))      # True
print(3 in {x:y for x,y in zip(range(4),range(4,10))})  # True

迭代器

• 迭代器
  特殊的对象，一定是可迭代对象，具备可迭代对象的特征
  通过iter方法把一个可迭代对象封装成迭代器
  通过next方法，迭代 迭代器对象
  生成器对象，就是迭代器对象

for x in iter(range(10)):print(x)
# 0
# 1
# 2
# 3
# 4
# 5
# 6
# 7
# 8
# 9

g = (x for x in range(10))
print(type(g))       # <class 'generator'>
print(next(g))       # 0
print(next(g))       # 1 

• 拉链函数zip(*iterables)
  p 像拉链一样，把多个可迭代对象合并在一起，返回一个迭代器
  将每次从不同对象中取到的元素合并成一个元组

print(list(zip(range(10),range(10))))  # [(0, 0), (1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6), (7, 7), (8, 8), (9, 9)]
print(list(zip(range(10),range(10),range(5),range(10))))     # [(0, 0, 0, 0), (1, 1, 1, 1), (2, 2, 2, 2), (3, 3, 3, 3), (4, 4, 4, 4)]
print(dict(zip(range(10),range(10)))) # {0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9}
print({str(x):y for x,y in zip(range(10),range(10))})  # {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}

总结

        到这里又告一段落 ， 多偿试，多理解吧。 也是给我自己的。