zoukankan      html  css  js  c++  java

  • 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'thisis 
osprcial characters 
'
    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. 1234
    20. thisis 
osprcial characters 

    21. 1234thisis 
osprcial characters
    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("
")
    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("
")
    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('
')
    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("
")
    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("
")
    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)








    万事走心 精益求美
  • 相关阅读:
    python登录qq
    js加解密的算法
    python request模板
    qq查询接口
    python代理池的实现
    mvvm实现
    消息队列
    【Linux常见命令】seq命令
    【Linux常见命令】find命令
    【Linux常见命令】rm命令
  • 原文地址：https://www.cnblogs.com/kongchung/p/5805133.html
Copyright © 2011-2022 走看看