Python语言精要---上

时间：2021-07-30 15:27:16

下面的记录根据：

麦金尼. 利用Python进行数据分析[M]. 机械工业出版社, 2014.
这本教材的附录部分总结而来

Python语言精要---上
 

Python的设计特点是重视可读性，简洁性以及明确性
Python不推荐多个语句写在一行，不够简洁
Python中真正是万物皆对象，数值，字符串，数据结构，函数，类，模块等都是Python对象
a = [1,2,3]
其实是创建右侧对象的一个应用
b = a
其实不是数据的复制，而是引用的复制，导致现在a和b都是指向这个数据对象的
a.append(4)
之后
b变成了
[1,2,3,4]
所以赋值（assignment）操作也叫做绑定（binding），那么赋值过的变量名也称为绑定变量（bound variable）
所以Python的数据传递默认是按照引用传递的

Python某种程度上虽然随意赋值，但是变量都是有类型的，只是类型信息保存在自己的内部
Python是一种强类型语言
isinstance(a,int)#可以检查一个对象是否是特定类型的实例
instance(a,(int,float))#检查一个对象是否是一个元组中指定的那些

Python中的对象通常都有
属性attribute即存储在对象内部的其他Python对象
方法method与改对象有关的能够访问其内部数据的函数

调用方法除了a.b之外还可以用一些函数
a = 'foo'
print(getattr(a, 'upper'))
b = a.upper()
print(a)
print(b)
输出：
<built-in method upper of str object at 0x0000004448779B58>
foo
FOO

判断对象时候可以迭代
    

  1. def isiterable(obj):
    2. 

  2.     try:
    3. 

  3.         iter(obj)
    4. 

  4.         return True
    5. 

  5.     except TypeError:
    6. 

  6.         return False
    7. 

  7. print(isiterable('a string'))
    8. 

  8. print(isiterable([1,2,3]))
    9. 

  9. print(isiterable(5))
    10.
最后一个不可以，前面的两个都可以
    

  1. #检查对象是不是列表或者数组，要是不是的话，就转换成list
    2. 

  2. x=1,2,3
    3. 

  3. print(x)
    4. 

  4. if not isinstance(x, list) and isiterable(x):
    5. 

  5.     x = list(x)
    6. 

  6. print(x)
    7.
输出：
(1, 2, 3)

[1, 2, 3]


module是包含函数和其变量定义的模块
我们可以用import关键字引入到另一个.py文件中
整体引入就这样写：
import some_module
部分指定引入就这样写：
from some_module inmport f,g,PI
整体/部分引入且指定引入就要这样写：
import some_module as sm
from some_module import PI as pi_const, g as g_function

运算符的比较：
    

  1. a=[1,2,3,4]
    2. 

  2. b = a
    3. 

  3. print(a is b)   #这是创建的引用，是指向同一个对象，所以是True
    4. 

  4. c = list(a)     #会创建新的列，所以a与c不指向相同的列
    5. 

  5. print(a is not c)   
    6. 

  6. print(a ==c)    #但是a与c的内容完全相同
    7. 

  7. a = None
    8. 

  8. print(a is None)#这是True的因为，None的实例只有一个
    9.
上面的四个都是True

急性子：
    

  1. a=b=c=5
    2. 

  2. d=a+b*c
    3. 

  3. print(d)
    4.
Python是一种急性子的严格的语言，几乎在任何时候，计算过程和表达式都是立即求值的
上面的例子中也是先计算b*c然后计算加上a的值
有些Python技术例如迭代器和生成器可以实现延时计算，在执行负荷高的计算时候可以延时计算，先完成代码

可变与不可变对象：
Python对象的大部分是可变的，如列表，字典，数组和大部分自定义的数据类型
可变就是说包含的对象或值是可以被修改的
    

  1. a_list = ['foo',1,[12,34]]
    2. 

  2. a_list[2] = (5,6)
    3. 

  3. print(a_list)       #['foo', 1, (5, 6)]
    4.
其他的字符串和元组是不可变的：
    

  1. a_tuple = (1,2,3,(4,5))
    2. 

  2. a_tuple[1] = 'four'     #TypeError: 'tuple' object does not support item assignment
    3.

标量类型：
None 是Python中的null,这个对象只存在一个实例对象
str 字符串
unicode Unicode字符串
float 双精度浮点数
bool True或者False
int 有符号整数，最大值由平台决定
long 任意精度有符号整数，大的int会自动转换为long     
    

  1. cval = 1+2j
    2. 

  2. print(cval*(1-2j)) #(5+0j)
    3. 

    

  1. a = 'first way to define string'
    2. 

  2. b = "second way to define string"
    3. 

  3. c = """
    4. 

  4. thid way to 
    5. 

  5. define a string
    6. 

  6. """
    7. 

  7. print(a)
    8. 

  8. print(b)
    9. 

  9. print(c)
    10. 

  10. '''
    11. 

  11. first way to define string
    12. 

  12. second way to define string
    13. 

    14. 

  14. thid way to 
    15. 

  15. define a string
    16. 

  16. '''
    17.
Python字符串是不可修改的
    

  1. a = "this is an immutable object"
    2. 

  2. print(a[11])
    3. 

  3. #a[10] = "f" #TypeError: 'str' object does not support item assignment
    4. 

  4. b = a.replace('object', "string object")
    5. 

  5. print(b)
    6. 

  6. '''
    7. 

  7. i
    8. 

  8. this is an immutable string object
    9.
字符串的其他操作：
    

  1. a = 5.6
    2. 

  2. s = str(a)
    3. 

  3. print(s)
    4. 

  4. s = 'Python Spark'
    5. 

  5. s_new = list(s)
    6. 

  6. print(s_new)
    7. 

  7. print(s[:3])
    8. 

  8. print(s_new[:3])
    9. 

  9. s1 = '12\\34'
    10. 

  10. print(s1)
    11. 

  11. s2 = r'this\is \no\sprcial characters \n'
    12. 

  12. print(s2)
    13. 

  13. print(s1+s2)
    14. 

  14. '''
    15. 

  15. 5.6
    16. 

  16. ['P', 'y', 't', 'h', 'o', 'n', ' ', 'S', 'p', 'a', 'r', 'k']
    17. 

  17. Pyt
    18. 

  18. ['P', 'y', 't']
    19. 

  19. 12\34
    20. 

  20. this\is \no\sprcial characters \n
    21. 

  21. 12\34this\is \no\sprcial characters \n
    22.
None:
    

  1. def add_and_maybe_multiply(a,b,c=None):
    2. 

  2.     result = a+b
    3. 

  3.     if c is not None:
    4. 

  4.         result = result * c
    5. 

  5.     return result
    6.
这个函数中常见的默认值可以用None去填充
但是None不是一个保留关键字
它只是NoneType的一个实例而已

 时间和日期操作：
    

  1. from datetime import datetime,date,time
    2. 

  2. dt = datetime(2016,8,24,19,22,33)
    3. 

  3. print(dt.year)
    4. 

  4. print(dt.month)
    5. 

  5. print(dt.day)
    6. 

    7. 

  7. print(dt.hour)
    8. 

  8. print(dt.minute)
    9. 

  9. print(dt.second)
    10. 

    11. 

  11. print(dt.date())
    12. 

  12. print(dt.time())
    13. 

    14. 

  14. print(dt.strftime('%m/%d/%Y %H:%M:%S'))
    15. 

    16. 

  16. dt_new = dt.replace(minute = 13, second = 23)
    17. 

  17. print(dt_new)
    18. 

    19. 

  19. dt_sub = dt - dt_new
    20. 

  20. print(dt_sub)
    21. 

  21. print(type(dt_sub))
    22. 

    23. 

  23. dt_recover = dt + dt_sub
    24. 

  24. print(dt_recover)
    25. 

  25. print(type(dt_recover))
    26. 

    27. 

  27. '''
    28. 

  28. 2016
    29. 

  29. 8
    30. 

  30. 24
    31. 

  31. 19
    32. 

  32. 22
    33. 

  33. 33
    34. 

  34. 2016-08-24
    35. 

  35. 19:22:33
    36. 

  36. 08/24/2016 19:22:33
    37. 

  37. 2016-08-24 19:13:23
    38. 

  38. 0:09:10
    39. 

  39. <class 'datetime.timedelta'>
    40. 

  40. 2016-08-24 19:31:43
    41. 

  41. <class 'datetime.datetime'>
    42. 

  42. '''
    43.
控制流：
    

  1. a = 1; b = 7;
    2. 

  2. c = 8; d = 4;
    3. 

  3. if(a <b or c > d):
    4. 

  4.     print("Made it")
    5.
这种and或者or组成的复合条件的求值是从左面到右面的，而且是短路类型的
    

  1. seq = [1,2,None,4,None,6]
    2. 

  2. total = 0
    3. 

  3. for value in seq:
    4. 

  4.     if value is None:
    5. 

  5.         continue
    6. 

  6.     total += value
    7.
continue的作用就是在循环中跳出本次迭代
关键字pass代表空操作，可以放在没有任何的功能的地方，站位

异常处理：
    

  1. f = open(path,'w')
    2. 

  2. try:
    3. 

  3.     write_to_file(f)
    4. 

  4. except (TypeError,ValueError):
    5. 

  5.     print('Failed')
    6. 

  6. else:
    7. 

  7.     print("Successed")
    8. 

  8. finally:
    9. 

  9.         f.close()
    10.
try去尝试
except加括号表示只处理这些异常，不加的话处理所有的异常
finally:是无论try成功失败都要执行的收尾工作的地方

range：
Python3总range始终返回迭代器
    

  1. print(range(10))
    2. 

  2. print(range(0,20,2))
    3. 

    4. 

  4. seq = [1,2,3,4]
    5. 

  5. for i in range(len(seq)):
    6. 

  6.     print(seq[i])
    7.
输出：
range(0, 10)
range(0, 20, 2)
1
2
3
4

三元表达式：
value = true-expr if condition else false-expr
例如：
    

  1. x = 5
    2. 

  2. print('Non-negative' if x >=0 else 'negative')
    3.

数据结构和序列：
Python的数据结构简单而强大
元组：   tuple
是一种一维的，定长的，不可变的对象和序列
    

  1. tuple = 4,5,6
    2. 

  2. print(tuple)
    3.
下面创建由元组组成的元组：
    

  1. nested_tuple = (4,5,6),(7,8)
    2. 

  2. print(nested_tuple)     #((4, 5, 6), (7, 8))
    3. 

  3. print(nested_tuple[0])  #(4,5,6)
    4. 

  4. print(nested_tuple[0][2])#6
    5. 

  5. tup = tuple + nested_tuple
    6. 

  6. print(tup)              #(4, 5, 6, (4, 5, 6), (7, 8))
    7. 

  7. print(tup*2)            #(4, 5, 6, (4, 5, 6), (7, 8), 4, 5, 6, (4, 5, 6), (7, 8))
    8. 

  8. #这里元素不可变，一旦创建每个槽的元素不能再修改了。上面的加倍其实只是对象的引用加倍，本身不会被复制
    9.
元组拆包：
    

  1. tuple = (1,2,(3,4))
    2. 

  2. a,b,c = tuple
    3. 

  3. print(a)
    4. 

  4. print(c)
    5. 

  5. d,e,(f,g) = tuple
    6. 

  6. print(f)
    7. 

  7. print(g)
    8. 

  8. '''
    9. 

  9. 1
    10. 

  10. (3, 4)
    11. 

  11. 3
    12. 

  12. 4
    13. 

  13. '''
    14.
这样给值非常的方便，a,b = b,a其实就完成的值的交换

元组方法：
    

  1. tuple = (1,2,2,2,2,5,6,7,8)
    2. 

  2. print(tuple.count(2))
    3.
上面的方法计算指定的值在元组中出现的次数，4

列表：    list
列表是可变长度的，内容也是可以修改的
可以通过[]或者是List函数对列表进行定义
    

  1. a_list = [2,3,5,7,None]
    2. 

  2. print(a_list)
    3. 

  3. tuple = ('jason','peggy','thea')
    4. 

  4. b_list = list(tuple)
    5. 

  5. print(b_list)
    6. 

  6. b_list[2] = "cathy"
    7. 

  7. print(b_list)
    8. 

  8. '''
    9. 

  9. [2, 3, 5, 7, None]
    10. 

  10. ['jason', 'peggy', 'thea']
    11. 

  11. ['jason', 'peggy', 'cathy']
    12. 

  12. '''
    13.
添加或者移除元素：
    

  1. b_list.append(a_list)
    2. 

  2. print(b_list)
    3. 

  3. b_list.insert(3, 'thea')
    4. 

  4. print(b_list)
    5. 

  5. print(b_list.pop(4))
    6. 

  6. print(b_list)
    7. 

  7. b_list.append("thea")
    8. 

  8. print(b_list)
    9. 

  9. b_list.append("peggy")
    10. 

  10. print(b_list)
    11. 

  11. b_list.remove("peggy")  #按照值的移除，移除掉第一个出现的位置
    12. 

  12. print(b_list)
    13. 

  13. print('peggy' in b_list)
    14. 

  14. '''
    15. 

  15. ['jason', 'peggy', 'cathy', [2, 3, 5, 7, None]]
    16. 

  16. ['jason', 'peggy', 'cathy', 'thea', [2, 3, 5, 7, None]]
    17. 

  17. [2, 3, 5, 7, None]
    18. 

  18. ['jason', 'peggy', 'cathy', 'thea']
    19. 

  19. ['jason', 'peggy', 'cathy', 'thea', 'thea']
    20. 

  20. ['jason', 'peggy', 'cathy', 'thea', 'thea', 'peggy']
    21. 

  21. ['jason', 'cathy', 'thea', 'thea', 'peggy']
    22. 

  22. True
    23. 

  23. '''
    24.
合并列表：
    

  1. print(a_list)
    2. 

  2. print(b_list)
    3. 

  3. c_list = a_list+b_list
    4. 

  4. print(c_list)
    5. 

  5. d_list = c_list.extend([7,8])
    6. 

  6. print(d_list)   
    7. 

  7. #extend耗费的资源更小，因为+是创建新的list将原来的拷贝过去，而extend 只是添加到现有列表
    8. 

  8. everything = []
    9. 

  9. for chunk in list_of_lists:
    10. 

  10.     everything.extend(chunk)
    11. 

    12. 

  12. everything  =[]
    13. 

  13. for chunk in list_of_lists:
    14. 

  14.     everything = everything = chunk
    15.
这里我没弄出来，首先这个extend方法不可用
其次这个会把list中的所有的元素变成单个的字符串，可能是我对list_of_lists的设置有问题

排序：
    

  1. a = [6,3,2,6,7,2,8,9,3,2]
    2. 

  2. print(a.sort(key=None, reverse=False))
    3. 

    4. 

  4. b = ['charles','jason','peggy','thea']
    5. 

  5. print(b.sort(key=len, reverse=False))
    6.
不知道为什么这两个函数的执行结果都是None

二分搜索以及维护有序列表：
内置的bisect模块实现了二分查找以及对有序列表的插入操作
bisect.bisect找出新元素应该被插入到哪个位置才能保证原列表的有序性
bisect.insort将新元素插入到那个位置上去
    

  1. import bisect
    2. 

  2. c = [1,2,3,4,5,6,8,9]
    3. 

  3. print(bisect.bisect(c,7))
    4. 

  4. bisect.insort(c,7)
    5. 

  5. print(c)
    6. 

  6. '''
    7. 

  7. 6
    8. 

  8. [1, 2, 3, 4, 5, 6, 7, 8, 9]
    9. 

  9. '''
    10.

切片:
通过切片标记法，可以得到序列类型的子集
    

  1. seq = [4,6,2,6,889,2,57,2,1,57,223]
    2. 

  2. print(seq[1:5])
    3. 

  3. seq[1:2]  =[99,99]
    4. 

  4. print(seq)
    5. 

  5. print(seq[:5])
    6. 

  6. print(seq[3:])
    7. 

  7. print(seq[-4:])
    8. 

  8. print(seq[-6:-2])
    9. 

    10. 

  10. print(seq[::2])     #每两个取一个
    11. 

  11. print(seq[::-1])    #反序
    12. 

  12. '''
    13. 

  13. [6, 2, 6, 889]
    14. 

  14. [4, 99, 99, 2, 6, 889, 2, 57, 2, 1, 57, 223]
    15. 

  15. [4, 99, 99, 2, 6]
    16. 

  16. [2, 6, 889, 2, 57, 2, 1, 57, 223]
    17. 

  17. [2, 1, 57, 223]
    18. 

  18. [2, 57, 2, 1]
    19. 

  19. [4, 99, 6, 2, 2, 57]
    20. 

  20. [223, 57, 1, 2, 57, 2, 889, 6, 2, 99, 99, 4]
    21. 

  21. '''
    22.
内置的序列函数：
enumerate
for i,value in enumerate(collection):
    pass
这个函数可以返回序列的（i,value）元组
这个函数还有一个使用方式，可以求取一个序列值映射到其所在的位置的字典
    

  1. some_list = ['charles','peggy','jason']
    2. 

  2. mapping = dict((v,i) for i,v in enumerate(some_list))
    3. 

  3. print(mapping)
    4. 

  4. print(sorted(zip(mapping.keys(),mapping.values()))) #反转排序
    5. 

  5. print(sorted(zip(mapping.values(),mapping.keys()))) #反转排序
    6. 

  6. print(sorted([7,2,4,76,9,3,1]))                     #排序
    7. 

  7. print(sorted('hello world'))                        #排序
    8. 

  8. print(sorted(set('hello world')))   #返回唯一元素组成的列表
    9. 

  9. '''
    10. 

  10. {'charles': 0, 'jason': 2, 'peggy': 1}
    11. 

  11. [('charles', 0), ('jason', 2), ('peggy', 1)]
    12. 

  12. [(0, 'charles'), (1, 'peggy'), (2, 'jason')]
    13. 

  13. [1, 2, 3, 4, 7, 9, 76]
    14. 

  14. [' ', 'd', 'e', 'h', 'l', 'l', 'l', 'o', 'o', 'r', 'w']
    15. 

  15. [' ', 'd', 'e', 'h', 'l', 'o', 'r', 'w']
    16. 

  16. '''
    17.
ZIP：
可以将多个序列中的元素配对，从而产生一个新的元组列表
    

  1. print("\n")
    2. 

  2. seq_1 = ['charles','jason','peggy','thea']
    3. 

  3. seq_2 = ['one','two','three','four']
    4. 

  4. seq_3 = ['first','second']
    5. 

  5. print(sorted(zip(seq_1,seq_2)))
    6. 

  6. print(sorted(zip(seq_1,seq_2,seq_3)))       #按照最短的序列决定
    7. 

  7. #enumerate和zip结合使用，迭代多个序列
    8. 

  8. for i, (a,b) in enumerate(zip(seq_1,seq_2)):
    9. 

  9.     print("%d: %s, %s" % (i,a,b))
    10. 

  10. #对于已经要压缩好的数据，可以用*解压缩
    11. 

  11. zipped = zip(seq_1,seq_2)
    12. 

  12. name, seq = zip(*zipped)
    13. 

  13. print(name)
    14. 

  14. print(seq)
    15. 

  15. #*相当于zip(seq[0],seq[1],...,seq[len(seq)-1])
    16. 

    17. 

  17. print(list(reversed(range(10))))
    18. 

    19. 

  19. '''
    20. 

  20. [('charles', 'one'), ('jason', 'two'), ('peggy', 'three'), ('thea', 'four')]
    21. 

  21. [('charles', 'one', 'first'), ('jason', 'two', 'second')]
    22. 

  22. 0: charles, one
    23. 

  23. 1: jason, two
    24. 

  24. 2: peggy, three
    25. 

  25. 3: thea, four
    26. 

  26. ('charles', 'jason', 'peggy', 'thea')
    27. 

  27. ('one', 'two', 'three', 'four')
    28. 

  28. [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
    29. 

  29. '''
    30.
字典：
也可以成为是hash map或者关联数组
是一种大小可变的键值对集
其中的key和value都是Python对象
创建字典的方式是{，}
    

  1. empty_dict = {}
    2. 

  2. print(empty_dict)
    3. 

  3. #创建非空字典
    4. 

  4. d_1 = {'a':'hello world','b':[1,2,3,4]}
    5. 

  5. print(d_1)
    6. 

  6. #插入元素
    7. 

  7. d_1[7] = 'insert an integer'
    8. 

  8. print(d_1)
    9. 

  9. print(d_1['b'])#按照key取值
    10. 

  10. print('b' in d_1)#判断key是否在映射中
    11. 

  11. #q取出两个列表
    12. 

  12. print(d_1.keys())
    13. 

  13. print(d_1.values())
    14. 

  14. #删除刚才插入的元素
    15. 

  15. del d_1[7]
    16. 

  16. print(d_1)
    17. 

  17. #弹出一个key对应的东西，返回值是弹出的value
    18. 

  18. ret = d_1.pop('b')
    19. 

  19. print(ret)
    20. 

  20. print(d_1)
    21. 

  21. #刷新字典
    22. 

  22. d_1.update({'b':'fresh','a':'change that'})
    23. 

  23. print(d_1)
    24. 

  24. '''
    25. 

  25. {}
    26. 

  26. {'b': [1, 2, 3, 4], 'a': 'hello world'}
    27. 

  27. {'b': [1, 2, 3, 4], 'a': 'hello world', 7: 'insert an integer'}
    28. 

  28. [1, 2, 3, 4]
    29. 

  29. True
    30. 

  30. dict_keys(['b', 'a', 7])
    31. 

  31. dict_values([[1, 2, 3, 4], 'hello world', 'insert an integer'])
    32. 

  32. {'b': [1, 2, 3, 4], 'a': 'hello world'}
    33. 

  33. [1, 2, 3, 4]
    34. 

  34. {'a': 'hello world'}
    35. 

  35. {'b': 'fresh', 'a': 'change that'}
    36. 

  36. '''
    37.
从序列类型创建字典：
其实字典是两个序列中的元素对应的二元的元组集
所以：
    

  1. mapping  = dict(zip(range(5),reversed(range(5))))
    2. 

  2. print(mapping)
    3. 

  3. #{0: 4, 1: 3, 2: 2, 3: 1, 4: 0}
    4.
默认值：
    

  1. print("\n")
    2. 

  2. #get方法可以类似一个if-else循环
    3. 

  3. value = mapping.get(1,None)
    4. 

  4. print(value)
    5. 

  5. no_value = mapping.get(5,"nothing here")
    6. 

  6. print(no_value)
    7. 

    8. 

  8. names = ['charles','apple','thea','jason']
    9. 

  9. by_latter = {}
    10. 

  10. for name in names:
    11. 

  11.     letter = name[0]
    12. 

  12.     if letter not in by_latter:
    13. 

  13.         by_latter[letter] = [name]
    14. 

  14.     else:
    15. 

  15.         by_latter[letter].append(name)
    16. 

  16. print(by_latter)
    17. 

  17. #上面的这个模块也可以用setdefault代替
    18. 

  18. by_latter_new = {}
    19. 

  19. for name in names:
    20. 

  20.     letter = name[0]
    21. 

  21.     by_latter_new.setdefault(letter,[]).append(name)
    22. 

  22. print(by_latter_new)
    23. 

  23. #collections模块有一个叫做defaultdict的类,可以使得这个过程更加简单
    24. 

  24. from collections import defaultdict
    25. 

  25. by_letter_fresh = defaultdict(list)
    26. 

  26. for name in names:
    27. 

  27.     by_letter_fresh[name[0]].append(name)
    28. 

  28. print(by_letter_fresh)
    29. 

  29. '''
    30. 

  30. 3
    31. 

  31. nothing here
    32. 

  32. {'c': ['charles'], 't': ['thea'], 'j': ['jason'], 'a': ['apple']}
    33. 

  33. {'c': ['charles'], 't': ['thea'], 'j': ['jason'], 'a': ['apple']}
    34. 

  34. defaultdict(<class 'list'>, {'c': ['charles'], 't': ['thea'], 'j': ['jason'], 'a': ['apple']})
    35. 

  35. '''
    36.
字典键的有效类型：
字典的值可以是任何的Python对象
但是键必须是不可变的对象
可以使用hash函数，判断这个对象时候是可hash的也就是可以用作字典的键
    

  1. print('\n')
    2. 

  2. print(hash('string'))
    3. 

  3. print(hash((1,2,(3,4))))
    4. 

  4. #print(hash((1,2,[3,4])))#这里会失败，因为列表是可变的
    5. 

  5. #要想使用列表做键，最简单的放哪个是就是转换成元组
    6. 

  6. d = {}
    7. 

  7. d[tuple([1,2,3])] = 5
    8. 

  8. print(d)
    9. 

  9. '''
    10. 

  10. -5979933153692547881
    11. 

  11. -2725224101759650258
    12. 

  12. {(1, 2, 3): 5}
    13. 

  13. '''
    14.


集合：
是唯一元素组成的无序集
可以用Set也可以用{}创建
    

  1. a_set = set([2,3,4,5,6,8,9,43])
    2. 

  2. print(a_set)
    3. 

    4. 

  4. b_set = {2,3,5,7,89,5,3,1,3,5,6}
    5. 

  5. print(b_set)
    6. 

    7. 

  7. print( a_set | b_set)#并集
    8. 

  8. print( a_set & b_set)#交集
    9. 

  9. print( a_set - b_set)#差集
    10. 

  10. print( a_set ^ b_set)#异或
    11. 

    12. 

  12. c_set = {2,3,4}
    13. 

  13. print(c_set.issubset(a_set))#c是a的子集不是b的子集
    14. 

  14. print(c_set.issubset(b_set))
    15. 

  15. print(a_set == b_set)#内容相同就相等
    16.
其他的集合操作:
a.add(x) 元素x加入到集合a中
a.remove(x) 元素x从集合a中删除
a.union(b) 求合集
a.intersection(b) 求并集
a.difference(b) a-b差集
a.symmetric_difference(b) 异或集合
a.issubset(b) a是b的子集，为True
a.issuperset(b) b是a的子集，为True
a.isdisjoint(b) 没有公共元素，为True

列表，集合以及字典的推导式：

列表推导式是Python受欢迎的语言特性之一
[expr  for  val  in collection  if  condition]
    

  1. names = ['thea','jason','apple','charles','heater','white']
    2. 

  2. print([x.upper() for x in names if len(x) > 4])
    3.
集合推导式也是类似：
set_comp = {expr  for  value  in  condition  if  condition}
字典推导式也是类似：
dict_comp = {key-expr :  value-expr  for  value  in  collection  if  condition}
这几种推倒式都是语法组合一块，但是确实可以使得代码更加容易读懂。
    

  1. print("\n")
    2. 

  2. names = ['thea','jason','apple','charles','heater','white']
    3. 

  3. print([x.upper() for x in names if len(x) > 4])
    4. 

    5. 

  5. unique_set = {len(x) for x in names}
    6. 

  6. print(unique_set)
    7. 

  7. unique_dict = {val:index for index,val in enumerate(names)}
    8. 

  8. print(unique_dict)
    9. 

  9. unique_dict_new = dict((val,idx) for idx,val in enumerate(names))
    10. 

  10. print(unique_dict_new)
    11. 

  11. '''
    12. 

  12. ['JASON', 'APPLE', 'CHARLES', 'HEATER', 'WHITE']
    13. 

  13. {4, 5, 6, 7}
    14. 

  14. {'heater': 4, 'white': 5, 'apple': 2, 'thea': 0, 'jason': 1, 'charles': 3}
    15. 

  15. {'heater': 4, 'white': 5, 'apple': 2, 'thea': 0, 'jason': 1, 'charles': 3}
    16. 

  16. '''
    17.
嵌套列表推导式：
    

  1. print("\n")
    2. 

  2. #下面是一个列表的列表
    3. 

  3. name_name = [
    4. 

  4.              ['tom','jason','charles','lilei','shown','joe'],
    5. 

  5.              ['natasha','thea','ana','eva','peggy','heather']
    6. 

  6.              ]
    7. 

  7. #想要找到含有两个a的名字放到新的一个列表中
    8. 

  8. name = [name for names in name_name for name in names if name.count('a')>=2]
    9. 

  9. print(name)
    10. 

  10. #为了更清除这种嵌套，下面是一个例子
    11. 

  11. some_tuples = [(1,2,3),(4,5,6),(7,8,9)]
    12. 

  12. flattered = [x for tup in some_tuples for x in tup]
    13. 

  13. print(flattered)
    14. 

  14. '''
    15. 

  15. ['natasha', 'ana']
    16. 

  16. [1, 2, 3, 4, 5, 6, 7, 8, 9]
    17. 

  17. '''
    18.
其实这些推导式都可以换成是循环，循环中的for循环顺序和这些推倒式中的for循环的顺序是一样的。
    

  1. flat = []
    2. 

  2. for tup in some_tuples:
    3. 

  3.     for x in tup:
    4. 

  4.         flat.append(x)
    5. 

  5. print(flat)
    6.




相关文章