下面的记录根据：

麦金尼. 利用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 字符串
unicode Unicode字符串
float 双精度浮点数
bool True或者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
  13. thid way to
  14. define a string
  15. '''
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)
  6. print(dt.hour)
  7. print(dt.minute)
  8. print(dt.second)
  9. print(dt.date())
  10. print(dt.time())
  11. print(dt.strftime('%m/%d/%Y %H:%M:%S'))
  12. dt_new = dt.replace(minute = 13, second = 23)
  13. print(dt_new)
  14. dt_sub = dt - dt_new
  15. print(dt_sub)
  16. print(type(dt_sub))
  17. dt_recover = dt + dt_sub
  18. print(dt_recover)
  19. print(type(dt_recover))
  20. '''
  21. 2016
  22. 8
  23. 24
  24. 19
  25. 22
  26. 33
  27. 2016-08-24
  28. 19:22:33
  29. 08/24/2016 19:22:33
  30. 2016-08-24 19:13:23
  31. 0:09:10
  32. <class 'datetime.timedelta'>
  33. 2016-08-24 19:31:43
  34. <class 'datetime.datetime'>
  35. '''
控制流：

  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))
  3. seq = [1,2,3,4]
  4. for i in range(len(seq)):
  5. 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)
  11. everything =[]
  12. for chunk in list_of_lists:
  13. 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))
  3. b = ['charles','jason','peggy','thea']
  4. 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])
  9. print(seq[::2]) #每两个取一个
  10. print(seq[::-1]) #反序
  11. '''
  12. [6, 2, 6, 889]
  13. [4, 99, 99, 2, 6, 889, 2, 57, 2, 1, 57, 223]
  14. [4, 99, 99, 2, 6]
  15. [2, 6, 889, 2, 57, 2, 1, 57, 223]
  16. [2, 1, 57, 223]
  17. [2, 57, 2, 1]
  18. [4, 99, 6, 2, 2, 57]
  19. [223, 57, 1, 2, 57, 2, 889, 6, 2, 99, 99, 4]
  20. '''
内置的序列函数：

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])
  16. print(list(reversed(range(10))))
  17. '''
  18. [('charles', 'one'), ('jason', 'two'), ('peggy', 'three'), ('thea', 'four')]
  19. [('charles', 'one', 'first'), ('jason', 'two', 'second')]
  20. 0: charles, one
  21. 1: jason, two
  22. 2: peggy, three
  23. 3: thea, four
  24. ('charles', 'jason', 'peggy', 'thea')
  25. ('one', 'two', 'three', 'four')
  26. [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
  27. '''
字典：

也可以成为是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)
  7. names = ['charles','apple','thea','jason']
  8. by_latter = {}
  9. for name in names:
  10. letter = name[0]
  11. if letter not in by_latter:
  12. by_latter[letter] = [name]
  13. else:
  14. by_latter[letter].append(name)
  15. print(by_latter)
  16. #上面的这个模块也可以用setdefault代替
  17. by_latter_new = {}
  18. for name in names:
  19. letter = name[0]
  20. by_latter_new.setdefault(letter,[]).append(name)
  21. print(by_latter_new)
  22. #collections模块有一个叫做defaultdict的类,可以使得这个过程更加简单
  23. from collections import defaultdict
  24. by_letter_fresh = defaultdict(list)
  25. for name in names:
  26. by_letter_fresh[name[0]].append(name)
  27. print(by_letter_fresh)
  28. '''
  29. 3
  30. nothing here
  31. {'c': ['charles'], 't': ['thea'], 'j': ['jason'], 'a': ['apple']}
  32. {'c': ['charles'], 't': ['thea'], 'j': ['jason'], 'a': ['apple']}
  33. defaultdict(<class 'list'>, {'c': ['charles'], 't': ['thea'], 'j': ['jason'], 'a': ['apple']})
  34. '''
字典键的有效类型：

字典的值可以是任何的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)
  3. b_set = {2,3,5,7,89,5,3,1,3,5,6}
  4. print(b_set)
  5. print( a_set | b_set)#并集
  6. print( a_set & b_set)#交集
  7. print( a_set - b_set)#差集
  8. print( a_set ^ b_set)#异或
  9. c_set = {2,3,4}
  10. print(c_set.issubset(a_set))#c是a的子集不是b的子集
  11. print(c_set.issubset(b_set))
  12. 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])
  4. unique_set = {len(x) for x in names}
  5. print(unique_set)
  6. unique_dict = {val:index for index,val in enumerate(names)}
  7. print(unique_dict)
  8. unique_dict_new = dict((val,idx) for idx,val in enumerate(names))
  9. print(unique_dict_new)
  10. '''
  11. ['JASON', 'APPLE', 'CHARLES', 'HEATER', 'WHITE']
  12. {4, 5, 6, 7}
  13. {'heater': 4, 'white': 5, 'apple': 2, 'thea': 0, 'jason': 1, 'charles': 3}
  14. {'heater': 4, 'white': 5, 'apple': 2, 'thea': 0, 'jason': 1, 'charles': 3}
  15. '''
嵌套列表推导式：

  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)

来自为知笔记(Wiz)

转载于:https://www.cnblogs.com/kongchung/p/5805133.html

Python语言精要---上相关推荐

  1. Python语言快速入门上

    目录 1.前言 2.变量和常量 1)Python对象模型 2)Python变量 二.运算符和表达式 [运算符和表达式] [位运算符] [逻辑运算符] [成员运算符] [身份运算符] [常用内置函数] ...

  2. python语言在命名上是什么敏感的_一文轻松掌握python语言命名规范规则

    和C/C++.Java等语言一样,python在命名上也有一套约定俗成的规则,符合规范的命名可以让程序的可读性大大增加,从而使得代码的逻辑性增强,易于自己和其他协作者在以后的拓展中理解代码的意义,从而 ...

  3. py基础系列(二)：python语言基础（上）

    py 基本数据类型 整型 浮点型 复数型(complex) 逻辑型(布尔型) 字符串 字符串的表示 转义字符 字符串的格式化 变量 关键字和标识符 变量 运算符与表达式 运算符 (1)算数运算符 (2 ...

  4. python能在工程上干嘛-python能干什么？

    Python的五个发展方向如下: 做了JAVA开发十年,也做过大大小小的项目,最近一两年做开发的被一门编程语言,也就是Python给刷屏了,在各个论坛中,关注圈中,Python的关注量一直都是很高,今 ...

  5. android 开发 python_用python语言开发android应用程序(1) - 格物致知的博客空间 - 中国移动开发者社区 - Powered by X-Space...

    对于不熟悉Java语言,又想进入android开发领域的人来说,似乎有两个选择,一个是重新开始学习Java语言,然后开始学习android开发,一个就是到处求方问药:在android上可不使用XXX语 ...

  6. Python语言快速入门（下）

    前言 本图文是本期图文的下篇,可能篇幅较长大概有10000多字,很高兴您能阅读,也感谢您的关注支持!这期下篇主要还是接着上次的内容继续,在上篇中我介绍了关于Python环境的安装.基本数据处理.输入输 ...

  7. python语言type board_菜鸟学Python，双手奉上老司机给上路新手总结的Python实战问题……...

    针对Python这一话题每天后台都会有不少小伙伴提出问题,下面我就将这些问题进行汇整,产出"Python实战问题篇",我认为这些问题非常具有代表性,希望可以帮到大家. 第一类问题: ...

  8. python线上编辑问题_大型线上项目中动态语言诸多问题之二 －－ 以 Python 语言为例...

    第一个问题:Mutable对象被误改 这个是在线上环境出现过的一个BUG 事后说起来很简单,服务端数据(放在dict里面的)被意外修改了,但查证的时候也花了许多时间,伪代码如下: def routin ...

  9. android 使用perl语言,在Android上用python（Perl、Lua、BeanShell等）编程

    原文来自:http://imxingzhi.appspot.com/?p=110001python 偶然间发现了google code上的一个项目--android-scriptingandroid ...

最新文章

  1. java和python哪个好学-Java VS Python 应该先学哪个？
  2. openCV笔记（持续更新）
  3. 常见索引结构—二叉搜索树
  4. 《从0到1学习Flink》—— Flink 写入数据到 ElasticSearch
  5. 对抗焦虑症（恐惧症）研究
  6. C++ 写时拷贝 3
  7. python 行为驱动_什么是行为驱动的Python？
  8. 解决conda activate报错IMPORTANT: You may need to close and restart your shell after running ‘conda init‘
  9. linux的qt5.5,Qt 5.5 正式发布，完全支持 Windows 10
  10. 写不出满分作文怎么办，GPT-3 来帮你
  11. 苹果官网下架 iPhone 8 全系；阿里推出“阿里云会议”；深度操作系统 20 BETA 发布 | 极客头条...
  12. 集群启动/停止方式总结
  13. swift菜鸟入门视频教程-02-基本运算符
  14. 【持久层】Druid简介
  15. 数字图像处理：名词解释
  16. ns手柄pc驱动_功能特点可以打满屏！北通宙斯白金版无线游戏手柄体验
  17. [工具使用]黑暗引擎FOFA
  18. django相关报错知识整理
  19. suger BI 创建任务
  20. 谁是白盒网络市场最大玩家

热门文章

  1. Hibernate搭建成功！（源码）
  2. tidevice安装(MacOS)
  3. mysql 二十条记录_记 MySQL优化 20条
  4. 多线程 python tcp 图片_Python第四周之网络编程TCP （服务器/客户端； 线程下载图片；线程版服务器和客户端（单人、多人）） UDP...
  5. Failed to resolve:com.android.support:appcompat-v7
  6. Wireshark网络分析实例集锦第2章设置Wireshark视图
  7. grub rescue 安装linux,Ubuntu重装启动失败进入修复grub rescue模式
  8. php 生成等比例缩略图,PHP等比例生成缩略图
  9. python安装cv2模块_pythonimportcv2importError：DLLloadfailed：找不到指定模块
  10. python3基本知识_Python3 - 基础知识、基本了解