Python语言精要---上

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

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.     try:
  3.         iter(obj)
  4.         return True
  5.     except TypeError:
  6.         return False
  7. print(isiterable('a string'))
  8. print(isiterable([1,2,3]))
  9. print(isiterable(5))
最后一个不可以，前面的两个都可以
  1. #检查对象是不是列表或者数组，要是不是的话，就转换成list
  2. x=1,2,3
  3. print(x)
  4. if not isinstance(x, list) and isiterable(x):
  5.     x = list(x)
  6. print(x)
输出：
(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. b = a
  3. print(a is b)   #这是创建的引用，是指向同一个对象，所以是True
  4. c = list(a)     #会创建新的列，所以a与c不指向相同的列
  5. print(a is not c)   
  6. print(a ==c)    #但是a与c的内容完全相同
  7. a = None
  8. print(a is None)#这是True的因为，None的实例只有一个
上面的四个都是True

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

可变与不可变对象：
Python对象的大部分是可变的，如列表，字典，数组和大部分自定义的数据类型
可变就是说包含的对象或值是可以被修改的
  1. a_list = ['foo',1,[12,34]]
  2. a_list[2] = (5,6)
  3. print(a_list)       #['foo', 1, (5, 6)]
其他的字符串和元组是不可变的：
  1. a_tuple = (1,2,3,(4,5))
  2. a_tuple[1] = 'four'     #TypeError: 'tuple' object does not support item assignment

标量类型：
None是Python中的null,这个对象只存在一个实例对象
str字符串
unicodeUnicode字符串
float双精度浮点数
boolTrue或者False
int有符号整数，最大值由平台决定
long任意精度有符号整数，大的int会自动转换为long    
  1. cval = 1+2j
  2. print(cval*(1-2j)) #(5+0j)
  1. a = 'first way to define string'
  2. b = "second way to define string"
  3. c = """
  4. thid way to 
  5. define a string
  6. """
  7. print(a)
  8. print(b)
  9. print(c)
  10. '''
  11. first way to define string
  12. second way to define string
  14. thid way to 
  15. define a string
  16. '''
Python字符串是不可修改的
  1. a = "this is an immutable object"
  2. print(a[11])
  3. #a[10] = "f" #TypeError: 'str' object does not support item assignment
  4. b = a.replace('object', "string object")
  5. print(b)
  6. '''
  7. i
  8. this is an immutable string object
字符串的其他操作：
  1. a = 5.6
  2. s = str(a)
  3. print(s)
  4. s = 'Python Spark'
  5. s_new = list(s)
  6. print(s_new)
  7. print(s[:3])
  8. print(s_new[:3])
  9. s1 = '12\\34'
  10. print(s1)
  11. s2 = r'this\is \no\sprcial characters \n'
  12. print(s2)
  13. print(s1+s2)
  14. '''
  15. 5.6
  16. ['P', 'y', 't', 'h', 'o', 'n', ' ', 'S', 'p', 'a', 'r', 'k']
  17. Pyt
  18. ['P', 'y', 't']
  19. 12\34
  20. this\is \no\sprcial characters \n
  21. 12\34this\is \no\sprcial characters \n
None:
  1. def add_and_maybe_multiply(a,b,c=None):
  2.     result = a+b
  3.     if c is not None:
  4.         result = result * c
  5.     return result
这个函数中常见的默认值可以用None去填充
但是None不是一个保留关键字
它只是NoneType的一个实例而已

 时间和日期操作：
  1. from datetime import datetime,date,time
  2. dt = datetime(2016,8,24,19,22,33)
  3. print(dt.year)
  4. print(dt.month)
  5. print(dt.day)
  7. print(dt.hour)
  8. print(dt.minute)
  9. print(dt.second)
  11. print(dt.date())
  12. print(dt.time())
  14. print(dt.strftime('%m/%d/%Y %H:%M:%S'))
  16. dt_new = dt.replace(minute = 13, second = 23)
  17. print(dt_new)
  19. dt_sub = dt - dt_new
  20. print(dt_sub)
  21. print(type(dt_sub))
  23. dt_recover = dt + dt_sub
  24. print(dt_recover)
  25. print(type(dt_recover))
  27. '''
  28. 2016
  29. 8
  30. 24
  31. 19
  32. 22
  33. 33
  34. 2016-08-24
  35. 19:22:33
  36. 08/24/2016 19:22:33
  37. 2016-08-24 19:13:23
  38. 0:09:10
  39. <class 'datetime.timedelta'>
  40. 2016-08-24 19:31:43
  41. <class 'datetime.datetime'>
  42. '''
控制流：
  1. a = 1; b = 7;
  2. c = 8; d = 4;
  3. if(a <b or c > d):
  4.     print("Made it")
这种and或者or组成的复合条件的求值是从左面到右面的，而且是短路类型的
  1. seq = [1,2,None,4,None,6]
  2. total = 0
  3. for value in seq:
  4.     if value is None:
  5.         continue
  6.     total += value
continue的作用就是在循环中跳出本次迭代
关键字pass代表空操作，可以放在没有任何的功能的地方，站位

异常处理：
  1. f = open(path,'w')
  2. try:
  3.     write_to_file(f)
  4. except (TypeError,ValueError):
  5.     print('Failed')
  6. else:
  7.     print("Successed")
  8. finally:
  9.         f.close()
try去尝试
except加括号表示只处理这些异常，不加的话处理所有的异常
finally:是无论try成功失败都要执行的收尾工作的地方

range：
Python3总range始终返回迭代器
  1. print(range(10))
  2. print(range(0,20,2))
  4. seq = [1,2,3,4]
  5. for i in range(len(seq)):
  6.     print(seq[i])
输出：
range(0, 10)
range(0, 20, 2)
1
2
3
4

三元表达式：
value = true-expr if condition else false-expr
例如：
  1. x = 5
  2. print('Non-negative' if x >=0 else 'negative')

数据结构和序列：
Python的数据结构简单而强大
元组：   tuple
是一种一维的，定长的，不可变的对象和序列
  1. tuple = 4,5,6
  2. print(tuple)
下面创建由元组组成的元组：
  1. nested_tuple = (4,5,6),(7,8)
  2. print(nested_tuple)     #((4, 5, 6), (7, 8))
  3. print(nested_tuple[0])  #(4,5,6)
  4. print(nested_tuple[0][2])#6
  5. tup = tuple + nested_tuple
  6. print(tup)              #(4, 5, 6, (4, 5, 6), (7, 8))
  7. print(tup*2)            #(4, 5, 6, (4, 5, 6), (7, 8), 4, 5, 6, (4, 5, 6), (7, 8))
  8. #这里元素不可变，一旦创建每个槽的元素不能再修改了。上面的加倍其实只是对象的引用加倍，本身不会被复制
元组拆包：
  1. tuple = (1,2,(3,4))
  2. a,b,c = tuple
  3. print(a)
  4. print(c)
  5. d,e,(f,g) = tuple
  6. print(f)
  7. print(g)
  8. '''
  9. 1
  10. (3, 4)
  11. 3
  12. 4
  13. '''
这样给值非常的方便，a,b = b,a其实就完成的值的交换

元组方法：
  1. tuple = (1,2,2,2,2,5,6,7,8)
  2. print(tuple.count(2))
上面的方法计算指定的值在元组中出现的次数，4

列表：    list
列表是可变长度的，内容也是可以修改的
可以通过[]或者是List函数对列表进行定义
  1. a_list = [2,3,5,7,None]
  2. print(a_list)
  3. tuple = ('jason','peggy','thea')
  4. b_list = list(tuple)
  5. print(b_list)
  6. b_list[2] = "cathy"
  7. print(b_list)
  8. '''
  9. [2, 3, 5, 7, None]
  10. ['jason', 'peggy', 'thea']
  11. ['jason', 'peggy', 'cathy']
  12. '''
添加或者移除元素：
  1. b_list.append(a_list)
  2. print(b_list)
  3. b_list.insert(3, 'thea')
  4. print(b_list)
  5. print(b_list.pop(4))
  6. print(b_list)
  7. b_list.append("thea")
  8. print(b_list)
  9. b_list.append("peggy")
  10. print(b_list)
  11. b_list.remove("peggy")  #按照值的移除，移除掉第一个出现的位置
  12. print(b_list)
  13. print('peggy' in b_list)
  14. '''
  15. ['jason', 'peggy', 'cathy', [2, 3, 5, 7, None]]
  16. ['jason', 'peggy', 'cathy', 'thea', [2, 3, 5, 7, None]]
  17. [2, 3, 5, 7, None]
  18. ['jason', 'peggy', 'cathy', 'thea']
  19. ['jason', 'peggy', 'cathy', 'thea', 'thea']
  20. ['jason', 'peggy', 'cathy', 'thea', 'thea', 'peggy']
  21. ['jason', 'cathy', 'thea', 'thea', 'peggy']
  22. True
  23. '''
合并列表：
  1. print(a_list)
  2. print(b_list)
  3. c_list = a_list+b_list
  4. print(c_list)
  5. d_list = c_list.extend([7,8])
  6. print(d_list)   
  7. #extend耗费的资源更小，因为+是创建新的list将原来的拷贝过去，而extend 只是添加到现有列表
  8. everything = []
  9. for chunk in list_of_lists:
  10.     everything.extend(chunk)
  12. everything  =[]
  13. for chunk in list_of_lists:
  14.     everything = everything = chunk
这里我没弄出来，首先这个extend方法不可用
其次这个会把list中的所有的元素变成单个的字符串，可能是我对list_of_lists的设置有问题

排序：
  1. a = [6,3,2,6,7,2,8,9,3,2]
  2. print(a.sort(key=None, reverse=False))
  4. b = ['charles','jason','peggy','thea']
  5. print(b.sort(key=len, reverse=False))
不知道为什么这两个函数的执行结果都是None

二分搜索以及维护有序列表：
内置的bisect模块实现了二分查找以及对有序列表的插入操作
bisect.bisect找出新元素应该被插入到哪个位置才能保证原列表的有序性
bisect.insort将新元素插入到那个位置上去
  1. import bisect
  2. c = [1,2,3,4,5,6,8,9]
  3. print(bisect.bisect(c,7))
  4. bisect.insort(c,7)
  5. print(c)
  6. '''
  7. 6
  8. [1, 2, 3, 4, 5, 6, 7, 8, 9]
  9. '''

切片:
通过切片标记法，可以得到序列类型的子集
  1. seq = [4,6,2,6,889,2,57,2,1,57,223]
  2. print(seq[1:5])
  3. seq[1:2]  =[99,99]
  4. print(seq)
  5. print(seq[:5])
  6. print(seq[3:])
  7. print(seq[-4:])
  8. print(seq[-6:-2])
  10. print(seq[::2])     #每两个取一个
  11. print(seq[::-1])    #反序
  12. '''
  13. [6, 2, 6, 889]
  14. [4, 99, 99, 2, 6, 889, 2, 57, 2, 1, 57, 223]
  15. [4, 99, 99, 2, 6]
  16. [2, 6, 889, 2, 57, 2, 1, 57, 223]
  17. [2, 1, 57, 223]
  18. [2, 57, 2, 1]
  19. [4, 99, 6, 2, 2, 57]
  20. [223, 57, 1, 2, 57, 2, 889, 6, 2, 99, 99, 4]
  21. '''
内置的序列函数：
enumerate
for i,value in enumerate(collection):
    pass
这个函数可以返回序列的（i,value）元组
这个函数还有一个使用方式，可以求取一个序列值映射到其所在的位置的字典
  1. some_list = ['charles','peggy','jason']
  2. mapping = dict((v,i) for i,v in enumerate(some_list))
  3. print(mapping)
  4. print(sorted(zip(mapping.keys(),mapping.values()))) #反转排序
  5. print(sorted(zip(mapping.values(),mapping.keys()))) #反转排序
  6. print(sorted([7,2,4,76,9,3,1]))                     #排序
  7. print(sorted('hello world'))                        #排序
  8. print(sorted(set('hello world')))   #返回唯一元素组成的列表
  9. '''
  10. {'charles': 0, 'jason': 2, 'peggy': 1}
  11. [('charles', 0), ('jason', 2), ('peggy', 1)]
  12. [(0, 'charles'), (1, 'peggy'), (2, 'jason')]
  13. [1, 2, 3, 4, 7, 9, 76]
  14. [' ', 'd', 'e', 'h', 'l', 'l', 'l', 'o', 'o', 'r', 'w']
  15. [' ', 'd', 'e', 'h', 'l', 'o', 'r', 'w']
  16. '''
ZIP：
可以将多个序列中的元素配对，从而产生一个新的元组列表
  1. print("\n")
  2. seq_1 = ['charles','jason','peggy','thea']
  3. seq_2 = ['one','two','three','four']
  4. seq_3 = ['first','second']
  5. print(sorted(zip(seq_1,seq_2)))
  6. print(sorted(zip(seq_1,seq_2,seq_3)))       #按照最短的序列决定
  7. #enumerate和zip结合使用，迭代多个序列
  8. for i, (a,b) in enumerate(zip(seq_1,seq_2)):
  9.     print("%d: %s, %s" % (i,a,b))
  10. #对于已经要压缩好的数据，可以用*解压缩
  11. zipped = zip(seq_1,seq_2)
  12. name, seq = zip(*zipped)
  13. print(name)
  14. print(seq)
  15. #*相当于zip(seq[0],seq[1],...,seq[len(seq)-1])
  17. print(list(reversed(range(10))))
  19. '''
  20. [('charles', 'one'), ('jason', 'two'), ('peggy', 'three'), ('thea', 'four')]
  21. [('charles', 'one', 'first'), ('jason', 'two', 'second')]
  22. 0: charles, one
  23. 1: jason, two
  24. 2: peggy, three
  25. 3: thea, four
  26. ('charles', 'jason', 'peggy', 'thea')
  27. ('one', 'two', 'three', 'four')
  28. [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
  29. '''
字典：
也可以成为是hash map或者关联数组
是一种大小可变的键值对集
其中的key和value都是Python对象
创建字典的方式是{，}
  1. empty_dict = {}
  2. print(empty_dict)
  3. #创建非空字典
  4. d_1 = {'a':'hello world','b':[1,2,3,4]}
  5. print(d_1)
  6. #插入元素
  7. d_1[7] = 'insert an integer'
  8. print(d_1)
  9. print(d_1['b'])#按照key取值
  10. print('b' in d_1)#判断key是否在映射中
  11. #q取出两个列表
  12. print(d_1.keys())
  13. print(d_1.values())
  14. #删除刚才插入的元素
  15. del d_1[7]
  16. print(d_1)
  17. #弹出一个key对应的东西，返回值是弹出的value
  18. ret = d_1.pop('b')
  19. print(ret)
  20. print(d_1)
  21. #刷新字典
  22. d_1.update({'b':'fresh','a':'change that'})
  23. print(d_1)
  24. '''
  25. {}
  26. {'b': [1, 2, 3, 4], 'a': 'hello world'}
  27. {'b': [1, 2, 3, 4], 'a': 'hello world', 7: 'insert an integer'}
  28. [1, 2, 3, 4]
  29. True
  30. dict_keys(['b', 'a', 7])
  31. dict_values([[1, 2, 3, 4], 'hello world', 'insert an integer'])
  32. {'b': [1, 2, 3, 4], 'a': 'hello world'}
  33. [1, 2, 3, 4]
  34. {'a': 'hello world'}
  35. {'b': 'fresh', 'a': 'change that'}
  36. '''
从序列类型创建字典：
其实字典是两个序列中的元素对应的二元的元组集
所以：
  1. mapping  = dict(zip(range(5),reversed(range(5))))
  2. print(mapping)
  3. #{0: 4, 1: 3, 2: 2, 3: 1, 4: 0}
默认值：
  1. print("\n")
  2. #get方法可以类似一个if-else循环
  3. value = mapping.get(1,None)
  4. print(value)
  5. no_value = mapping.get(5,"nothing here")
  6. print(no_value)
  8. names = ['charles','apple','thea','jason']
  9. by_latter = {}
  10. for name in names:
  11.     letter = name[0]
  12.     if letter not in by_latter:
  13.         by_latter[letter] = [name]
  14.     else:
  15.         by_latter[letter].append(name)
  16. print(by_latter)
  17. #上面的这个模块也可以用setdefault代替
  18. by_latter_new = {}
  19. for name in names:
  20.     letter = name[0]
  21.     by_latter_new.setdefault(letter,[]).append(name)
  22. print(by_latter_new)
  23. #collections模块有一个叫做defaultdict的类,可以使得这个过程更加简单
  24. from collections import defaultdict
  25. by_letter_fresh = defaultdict(list)
  26. for name in names:
  27.     by_letter_fresh[name[0]].append(name)
  28. print(by_letter_fresh)
  29. '''
  30. 3
  31. nothing here
  32. {'c': ['charles'], 't': ['thea'], 'j': ['jason'], 'a': ['apple']}
  33. {'c': ['charles'], 't': ['thea'], 'j': ['jason'], 'a': ['apple']}
  34. defaultdict(<class 'list'>, {'c': ['charles'], 't': ['thea'], 'j': ['jason'], 'a': ['apple']})
  35. '''
字典键的有效类型：
字典的值可以是任何的Python对象
但是键必须是不可变的对象
可以使用hash函数，判断这个对象时候是可hash的也就是可以用作字典的键
  1. print('\n')
  2. print(hash('string'))
  3. print(hash((1,2,(3,4))))
  4. #print(hash((1,2,[3,4])))#这里会失败，因为列表是可变的
  5. #要想使用列表做键，最简单的放哪个是就是转换成元组
  6. d = {}
  7. d[tuple([1,2,3])] = 5
  8. print(d)
  9. '''
  10. -5979933153692547881
  11. -2725224101759650258
  12. {(1, 2, 3): 5}
  13. '''


集合：
是唯一元素组成的无序集
可以用Set也可以用{}创建
  1. a_set = set([2,3,4,5,6,8,9,43])
  2. print(a_set)
  4. b_set = {2,3,5,7,89,5,3,1,3,5,6}
  5. print(b_set)
  7. print( a_set | b_set)#并集
  8. print( a_set & b_set)#交集
  9. print( a_set - b_set)#差集
  10. print( a_set ^ b_set)#异或
  12. c_set = {2,3,4}
  13. print(c_set.issubset(a_set))#c是a的子集不是b的子集
  14. print(c_set.issubset(b_set))
  15. print(a_set == b_set)#内容相同就相等
其他的集合操作:
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. print([x.upper() for x in names if len(x) > 4])
集合推导式也是类似：
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. names = ['thea','jason','apple','charles','heater','white']
  3. print([x.upper() for x in names if len(x) > 4])
  5. unique_set = {len(x) for x in names}
  6. print(unique_set)
  7. unique_dict = {val:index for index,val in enumerate(names)}
  8. print(unique_dict)
  9. unique_dict_new = dict((val,idx) for idx,val in enumerate(names))
  10. print(unique_dict_new)
  11. '''
  12. ['JASON', 'APPLE', 'CHARLES', 'HEATER', 'WHITE']
  13. {4, 5, 6, 7}
  14. {'heater': 4, 'white': 5, 'apple': 2, 'thea': 0, 'jason': 1, 'charles': 3}
  15. {'heater': 4, 'white': 5, 'apple': 2, 'thea': 0, 'jason': 1, 'charles': 3}
  16. '''
嵌套列表推导式：
  1. print("\n")
  2. #下面是一个列表的列表
  3. name_name = [
  4.              ['tom','jason','charles','lilei','shown','joe'],
  5.              ['natasha','thea','ana','eva','peggy','heather']
  6.              ]
  7. #想要找到含有两个a的名字放到新的一个列表中
  8. name = [name for names in name_name for name in names if name.count('a')>=2]
  9. print(name)
  10. #为了更清除这种嵌套，下面是一个例子
  11. some_tuples = [(1,2,3),(4,5,6),(7,8,9)]
  12. flattered = [x for tup in some_tuples for x in tup]
  13. print(flattered)
  14. '''
  15. ['natasha', 'ana']
  16. [1, 2, 3, 4, 5, 6, 7, 8, 9]
  17. '''
其实这些推导式都可以换成是循环，循环中的for循环顺序和这些推倒式中的for循环的顺序是一样的。
  1. flat = []
  2. for tup in some_tuples:
  3.     for x in tup:
  4.         flat.append(x)
  5. print(flat)








posted @ 2016-08-25 00:05  kongchung  阅读(591)  评论(0)    收藏  举报