本課主題

  • Set 集合和操作实战
  • 函数介紹和操作实战
  • 参数的深入介绍和操作实战
  • format 函数操作实战
  • lambda 表达式介绍
  • 文件操作函数介紹和操作实战
  • 本周作业

Set 集合和操作实战

Set 是一个无序且不容许重复的序列

创建集合有两种方式:

  1. 第一种是通过直接创建、例如：s = {11,22}

    1.  >>> se = {11,222,11,222}
    2.  >>> print(se)
    3.  {11, 222}
    4.  >>> type(se)
    5.  <class 'set'>

    创建集合 方法一

  2. 第二种是通过转换。从一个可迭代类型的数组、元组转换成集合 Set。例如：s = Set(list) 
    1.  >>> li = [11,22,11,33,11,44,55]
    2.  >>> se = set(li) #把列表转换成集合
    3.  >>> se
    4.  {33, 11, 44, 22, 55}
    5.  >>> type(se)
    6.  <class 'set'>

    创建集合 方法二

    原理：在调用 Set 函数时，它会自动调用 __intit__ 方法，这叫构造方法 ，其实内部会执行一个 For 循环，循环这个"可迭代对象"里的所有元素，一个一个添加到集合里(什么是构造方法会在后期学到面向对象后再分享)

Set 集合的功能

这是Set 集合在 Python3.5.2的源码，我把它贴进来，里面有很多双下划线的方法，现在我都不知道是什么，让我了解后会回来补充一下。现在最主要的是要了解下面这几个集合的功能：我把它归类为添加、更新、找不同、找相同、删除和返回Boolean值六大类。

  1. class set(object):
  2.     """
  3.     set() -> new empty set object
  4.     set(iterable) -> new set object
  5.  
  6.     Build an unordered collection of unique elements.
  7.     """
  8.     def add(self, *args, **kwargs): # real signature unknown
  9.         """
  10.         Add an element to a set.
  11.  
  12.         This has no effect if the element is already present.
  13.         """
  14.         pass
  15.  
  16.     def clear(self, *args, **kwargs): # real signature unknown
  17.         """ Remove all elements from this set. """
  18.         pass
  19.  
  20.     def copy(self, *args, **kwargs): # real signature unknown
  21.         """ Return a shallow copy of a set. """
  22.         pass
  23.  
  24.     def difference(self, *args, **kwargs): # real signature unknown
  25.         """
  26.         Return the difference of two or more sets as a new set.
  27.  
  28.         (i.e. all elements that are in this set but not the others.)
  29.         """
  30.         pass
  31.  
  32.     def difference_update(self, *args, **kwargs): # real signature unknown
  33.         """ Remove all elements of another set from this set. """
  34.         pass
  35.  
  36.     def discard(self, *args, **kwargs): # real signature unknown
  37.         """
  38.         Remove an element from a set if it is a member.
  39.  
  40.         If the element is not a member, do nothing.
  41.         """
  42.         pass
  43.  
  44.     def intersection(self, *args, **kwargs): # real signature unknown
  45.         """
  46.         Return the intersection of two sets as a new set.
  47.  
  48.         (i.e. all elements that are in both sets.)
  49.         """
  50.         pass
  51.  
  52.     def intersection_update(self, *args, **kwargs): # real signature unknown
  53.         """ Update a set with the intersection of itself and another. """
  54.         pass
  55.  
  56.     def isdisjoint(self, *args, **kwargs): # real signature unknown
  57.         """ Return True if two sets have a null intersection. """
  58.         pass
  59.  
  60.     def issubset(self, *args, **kwargs): # real signature unknown
  61.         """ Report whether another set contains this set. """
  62.         pass
  63.  
  64.     def issuperset(self, *args, **kwargs): # real signature unknown
  65.         """ Report whether this set contains another set. """
  66.         pass
  67.  
  68.     def pop(self, *args, **kwargs): # real signature unknown
  69.         """
  70.         Remove and return an arbitrary set element.
  71.         Raises KeyError if the set is empty.
  72.         """
  73.         pass
  74.  
  75.     def remove(self, *args, **kwargs): # real signature unknown
  76.         """
  77.         Remove an element from a set; it must be a member.
  78.  
  79.         If the element is not a member, raise a KeyError.
  80.         """
  81.         pass
  82.  
  83.     __hash__ = None
  84.     def symmetric_difference(self, *args, **kwargs): # real signature unknown
  85.         """
  86.         Return the symmetric difference of two sets as a new set.
  87.  
  88.         (i.e. all elements that are in exactly one of the sets.)
  89.         """
  90.         pass
  91.  
  92.     def symmetric_difference_update(self, *args, **kwargs): # real signature unknown
  93.         """ Update a set with the symmetric difference of itself and another. """
  94.         pass
  95.  
  96.     def union(self, *args, **kwargs): # real signature unknown
  97.         """
  98.         Return the union of sets as a new set.
  99.  
  100.         (i.e. all elements that are in either set.)
  101.         """
  102.         pass
  103.  
  104.     def update(self, *args, **kwargs): # real signature unknown
  105.         """ Update a set with the union of itself and others. """
  106.         pass
  107.  
  108.     def __and__(self, *args, **kwargs): # real signature unknown
  109.         """ Return self&value. """
  110.         pass
  111.  
  112.     def __contains__(self, y): # real signature unknown; restored from __doc__
  113.         """ x.__contains__(y) <==> y in x. """
  114.         pass
  115.  
  116.     def __eq__(self, *args, **kwargs): # real signature unknown
  117.         """ Return self==value. """
  118.         pass
  119.  
  120.     def __getattribute__(self, *args, **kwargs): # real signature unknown
  121.         """ Return getattr(self, name). """
  122.         pass
  123.  
  124.     def __ge__(self, *args, **kwargs): # real signature unknown
  125.         """ Return self>=value. """
  126.         pass
  127.  
  128.     def __gt__(self, *args, **kwargs): # real signature unknown
  129.         """ Return self>value. """
  130.         pass
  131.  
  132.     def __iand__(self, *args, **kwargs): # real signature unknown
  133.         """ Return self&=value. """
  134.         pass
  135.  
  136.     def __init__(self, seq=()): # known special case of set.__init__
  137.         """
  138.         set() -> new empty set object
  139.         set(iterable) -> new set object
  140.  
  141.         Build an unordered collection of unique elements.
  142.         # (copied from class doc)
  143.         """
  144.         pass
  145.  
  146.     def __ior__(self, *args, **kwargs): # real signature unknown
  147.         """ Return self|=value. """
  148.         pass
  149.  
  150.     def __isub__(self, *args, **kwargs): # real signature unknown
  151.         """ Return self-=value. """
  152.         pass
  153.  
  154.     def __iter__(self, *args, **kwargs): # real signature unknown
  155.         """ Implement iter(self). """
  156.         pass
  157.  
  158.     def __ixor__(self, *args, **kwargs): # real signature unknown
  159.         """ Return self^=value. """
  160.         pass
  161.  
  162.     def __len__(self, *args, **kwargs): # real signature unknown
  163.         """ Return len(self). """
  164.         pass
  165.  
  166.     def __le__(self, *args, **kwargs): # real signature unknown
  167.         """ Return self<=value. """
  168.         pass
  169.  
  170.     def __lt__(self, *args, **kwargs): # real signature unknown
  171.         """ Return self<value. """
  172.         pass
  173.  
  174.     @staticmethod # known case of __new__
  175.     def __new__(*args, **kwargs): # real signature unknown
  176.         """ Create and return a new object.  See help(type) for accurate signature. """
  177.         pass
  178.  
  179.     def __ne__(self, *args, **kwargs): # real signature unknown
  180.         """ Return self!=value. """
  181.         pass
  182.  
  183.     def __or__(self, *args, **kwargs): # real signature unknown
  184.         """ Return self|value. """
  185.         pass
  186.  
  187.     def __rand__(self, *args, **kwargs): # real signature unknown
  188.         """ Return value&self. """
  189.         pass
  190.  
  191.     def __reduce__(self, *args, **kwargs): # real signature unknown
  192.         """ Return state information for pickling. """
  193.         pass
  194.  
  195.     def __repr__(self, *args, **kwargs): # real signature unknown
  196.         """ Return repr(self). """
  197.         pass
  198.  
  199.     def __ror__(self, *args, **kwargs): # real signature unknown
  200.         """ Return value|self. """
  201.         pass
  202.  
  203.     def __rsub__(self, *args, **kwargs): # real signature unknown
  204.         """ Return value-self. """
  205.         pass
  206.  
  207.     def __rxor__(self, *args, **kwargs): # real signature unknown
  208.         """ Return value^self. """
  209.         pass
  210.  
  211.     def __sizeof__(self): # real signature unknown; restored from __doc__
  212.         """ S.__sizeof__() -> size of S in memory, in bytes """
  213.         pass
  214.  
  215.     def __sub__(self, *args, **kwargs): # real signature unknown
  216.         """ Return self-value. """
  217.         pass
  218.  
  219.     def __xor__(self, *args, **kwargs): # real signature unknown
  220.         """ Return self^value. """
  221.         pass
  222.  
  223.     __hash__ = None

Set集合的源码

　　添加: add( ), unions( )

　　更新: difference_update( ), symmeteric_difference_update( ), intersection_update( ), update( )

　　找不同: difference( ), symmeteric_difference( ),

　　找相同: intersection( )

　　删除: discard( ), remove( ), clear( ), pop( )

　　返回Boolean值: isdisjoint( ), issuperset( )

  1. 添加: add()

    1.  >>> se = set() #创建空集合
    2.  >>> se
    3.  set()
    4.  >>> se.add(123) #添加123到集合里
    5.  >>> se
    6.  {123}

    集合功能:添加

  2. 清除所有在集合里的内容: clear()
     
    1.  >>> se = set() #创建一个空集合
    2.  >>> se.add(111)
    3.  >>> se.add(222)
    4.  >>> se.add(333)
    5.  >>> print(se)
    6.  {333, 222, 111}
    7.  >>> se.clear() #清除集合里的所有元素
    8.  >>> se
    9.  set()

    集合功能:删除

  3. 对比两个集合，找其中一方的不同，相当于 database 里的 left outer join: difference()
    1.  >>> s1 = {11,22,33}
    2.  >>> s2 = {22,33,44}
    3.  >>> s3 = s1.difference(s2) # 在s1中存在, s2中不存在
    4.  >>> s1
    5.  {33, 11, 22}
    6.  >>> s3
    7.  {11}
    8.  >>> s3 = s2.difference(s1) #在s2中存在, s1中不存在
    9.  >>> s3
    10.  {44}

    集合功能:找不同

  4. 对比两个集合，取出双方不同的元素: symmetric_difference()
     
    1.  >>> s1 = {11,22,33}
    2.  >>> s2 = {22,33,44}
    3.  >>> s3 = s1.symmetric_difference(s2) #找出双方都不存在的元素
    4.  >>> s1
    5.  {33, 11, 22}
    6.  >>> s3
    7.  {11, 44}

    集合功能:找不同

    更新: 对比两个集合，找其中一方的不同，然后直接把结果更新到原来的集合：difference_update()

    1.  >>> a = {11,22,33}
    2.  >>> b = {22,33,44}
    3.  >>> a.difference_update(b) #对比两个集合，找其中一方的不同，然后直接把结果更新到原来的集合
    4.  >>> a
    5.  {11}

    集合功能:更新

  5. 更新: 对比两个集合，取出双方不同的元素，然后直接把结果更新到原来的集合：symmetric_difference_update()
     
    1.  >>> a = {11,22,33}
    2.  >>> b = {22,33,44}
    3.  >>> a.symmetric_difference_update(b)
    4.  >>> a
    5.  {11, 44}

    集合功能:更新

  6. 刪除指定元素，不存在，不報錯!!：discard()
     
    1.  >>> s1 = {11,22,33}
    2.  >>> s2 = {22,33,44}
    3.  >>> s1.discard(11)
    4.  >>> s1
    5.  {33, 22}

    集合功能:删除

  7. 刪除指定元素，不存在，報錯!!!：remove()
     
    1.  >>> s1 = {11,22,33}
    2.  >>> s2 = {22,33,44}
    3.  >>> s1.remove(11)
    4.  >>> s1
    5.  {33, 22}
    6.  >>> s1.remove(1111)
    7.  Traceback (most recent call last):
    8.    File "<stdin>", line 1, in <module>
    9.  KeyError: 1111

    集合功能:删除

  8. 随机移取某个元素并获取这个元素: pop()
     
    1.  >>> s1 = {11,22,33}
    2.  >>> s2 = {22,33,44}
    3.  >>> ret = s1.pop()
    4.  >>> ret
    5.  33

    集合功能:删除

  9. 对比两个集合，找双方交集部份，相当于 database 里的 inner join: intersection()
     
    1.  >>> s1 = {11,22,33}
    2.  >>> s2 = {22,33,44}
    3.  >>> s3 = s1.intersection(s2) #找s1和s2相同的元素
    4.  >>> s3
    5.  {33, 22}
    6.  >>> s1
    7.  {33, 11, 22}

    集合功能:找相同

  10. 对比两个集合，找双方交集部份，相当于 database 里的 inner join，然后直接把结果更新到原来的集合：intersection_update()
     
    1.  >>> s1 = {11,22,33}
    2.  >>> s2 = {22,33,44}
    3.  >>> s1.intersection_update(s2) #找相同然后直接更新 s1
    4.  >>> s1
    5.  {33, 22}

    集合功能:找相同然后更新

  11. 判断两个集合有没有交集部份，如果有便返回 False ；如果没有，则返回 True: isdisjoint()
     
    1.  >>> s1 = {11,22,33}
    2.  >>> s2 = {22,33,44}
    3.  >>> s1.isdisjoint(s2) #有交集部分
    4.  False
    5.  
    6.  >>> s1 = {11,55,66}
    7.  >>> s2 = {22,33,44}
    8.  >>> s1.isdisjoint(s2) #没有交集部分
    9.  True

    集合功能:返回Boolean值

  12. 判断两个集合有没有父子关系，有是 True, 沒有則 False: issuperset()
     
    1.  >>> s1 = {11,22,33}
    2.  >>> s2 = {22,33,44}
    3.  >>> s1.issuperset(s2) #s1 不是 s2 的父序列
    4.  False
    5.  >>>
    6.  >>> s1 = {11,22,33}
    7.  >>> s2 = {22,33}
    8.  >>> s1.issuperset(s2) #s1 是 s2 的父序列
    9.  True

    集合功能:返回Boolean值

  13. 把两个集合连合然后去掉重覆的就是并集（这功能相当于 database, union 然后拿distinct value)：union()
     
    1.  >>> s1 = {11,22,33}
    2.  >>> s2 = {22,33,44}
    3.  >>> s3 = s1.union(s2)
    4.  >>> s3
    5.  {33, 22, 11, 44}

    集合功能:添加

  14. 批量地把一托集合增加到目标集合，update()接收一个可以被迭代的对象 e.g. List、Tuple、String：update()
     
    1.  >>> s1 = {11,22,33}
    2.  >>> s2 = {22,33,44}
    3.  >>> s1.update({77,88,99})
    4.  >>> s1
    5.  {33, 99, 22, 88, 11, 77}
    6.  >>> s1.update(s2)
    7.  >>> s1
    8.  {33, 99, 22, 88, 11, 44, 77}
    9.  >>>

    集合功能:更新

difference( ) 和 difference_update( ) 的应用：

  • s1 集合和 s2 集合的结果会保持不变，两个方法 difference() 和 symmetric_difference() 都会产生一个新的集合，所以在实际情景中如果需要重用 s1 和 s2 集合的时候，就不要用 differernce_updates() 和 symmetric_difference_update() 了。因为这两个函数会覆盖本來在 s1 里的结果。
  • 如果以后不需要基於 s1 來操作，只需要拿最新结果的话，就可以用 differernce_updates() 和 symmetric_difference_update()，这里的好处是变量声明减少了就可以​​节省内存空间！ ！ ！

案例实战

[更新中...]

函数介紹和操作实战

在还没有学函数之前，我们实现的代码是用很多条件判断（If-then-else）还有表达式的For 循环来实现功能，不免有很多重覆性的代码，其实这个过程叫"面向过程编程”，就是从上到下按照逻辑一点一点去写，如果遇到重覆的功能，最典型的操作就是复制和粘贴（Copy and Paste）

面向过程编程的缺点：

  1. 如果代码量多的话，不断的复制和粘贴，会导致代码缺乏了可阅读性;
  2. 不断使用重覆代码，代码量多，程序员也会很累，会导致代码缺乏了重用性。

**总结：基于以上两点的解决方安案是运用函数式编程！！函数是用来封装某些功能的，它的出现是为了增加代码的重用性，令代码更简洁，而且可以增加其可读性，以后如果要使用的话就直接调用这个函数就行啦！ ！

创建函数的步骤如下：

  1. 用 def 关键字来声明这是一个函数；
  2. 在 def 後面加一個空格，然后寫上一個名字代表函数名稱，以后就可以在内存里调用它;
  3. 名字加上后再加一个括号 ( );
  4. 然后在函数体里写上函数的内容：就是具体需要实现的功能;
  5. 然后加上返回值，如果沒有返回值的話 Python 会有一个默应的返回值 (None) 
    1. >>> def func():
    2. ...     print("")
    3. ...
    4. >>> f1 = func()
    5. 123
    6. >>> print("f1:",f1)
    7. f1: None

    沒有返回值

    有返回值的意思是：函数可以被調用然後賦值到另外一個參數，也就是說一個函数可以像參數一樣被传递。

    1. >>> def func():
    2. ...     return ""
    3. ...
    4. >>> f1 = func()
    5. >>> print("f1:",f1)
    6. f1: 123

    有返回值

  6. 函数可以在括号里面输入参数。

案例实战

以下是一个发邮件的函数，把登录邮件和发邮件这个功能封装在一个叫 sendMail()的函数里，只要一调用这个功能，它就会运行同一样的代码来发送邮件，这就是函数。

  1. def sendMail():
  2.  
  3.     import smtplib
  4.     from email.mime.text import MIMEText
  5.     from email.utils import formataddr
  6.  
  7.     msg = MIMEText("Python Email testing",'plain','utf-8')
  8.     msg['From'] = formataddr(["Janice", "janicecheng.python@gmail.com"])
  9.     msg['To'] = formataddr(["Janice", "janicecheng.python@gmail.com"])
  10.     msg['Subject']='主題'
  11.  
  12.     server = smtplib.SMTP("smtp.gmail.com", 587)
  13.     server.starttls()
  14.     server.login("janicecheng.python@gmail.com","password")
  15.     server.sendmail("janicecheng.python@gmail.com",["janicecheng.python@gmail.com",], msg.as_string())
  16.  
  17.     print("Mail Send Successfully")
  18.     server.quit()
  19.  
  20. sendMail()

邮件发送函数代码

  • def sendMail( ): 这叫声明函数
  • sendMail( ): 这叫执行函数
     
    1.  def sendMail():
    2.  
    3.      import smtplib
    4.      from email.mime.text import MIMEText
    5.      from email.utils import formataddr
    6.  
    7.      msg = MIMEText("Python Email testing",'plain','utf-8')
    8.      msg['From'] = formataddr(["Janice", "janicecheng.python@gmail.com"])
    9.      msg['To'] = formataddr(["Janice", "janicecheng.python@gmail.com"])
    10.      msg['Subject']='主題'
    11.  
    12.      server = smtplib.SMTP("smtp.gmail.com", 587)
    13.      server.starttls()
    14.      server.login("janicecheng.python@gmail.com","password")
    15.      server.sendmail("janicecheng.python@gmail.com",["janicecheng.python@gmail.com",], msg.as_string())
    16.  
    17.      print("Mail Send Successfully")
    18.      server.quit()
    19.  
    20.  sendMail()

    sendMail函数

注意：

  1. 当你在声明变量和函数之后，函数体在声明的时倏不会被执行的，它们分别会放在内存里，等待被调用！
  2. 在函数中一旦执行了 return, 函数的执行过程立即终止

返回值的补充说明

下面有一个例子，如果两个函数有相同的名称，然后在同一个程序里执行，运行结果会是多少呢？

以下是程序运行時的顺序：

  1. 第一步：Python 运行程序的时候是从上而下执行的，在 f1 声明函数放在内存的时候，它把1+2 声明后，然后放在内存里
  2. 第二步：当程序运行时碰到第2个 f1函数时，它再次在内存中把1x 2 放在内存中，并且 f1 指向 (1 x 2)
    • Python 有自己的垃圾回收机制，会定时把没有的变量或者函数删除掉。
  3. 第三步：声明一个变量把f1函数的返回值存储在里面
  4. 第四步：当调用 f1函数时，它实际上是运行 a1 * a2
  5. 第五步：然后实际运行 f1函数
  6. 第六步：打印出 ret 变量中的值

所以调用 f1函数时，它其实正在运行 a1 * a2的功能，这就是为什么答案会是 64的原因。

参数的深入介绍和操作实战

  1. 把参数传入然后在函数体里的内码块可以把这个参数当成变量的去使用，这种参数叫形式参数。当我们在调用程序的时候把参数传入然后执行，这种参数叫实际参数。在這個例子中，参数 target_email 叫形式参数;下面执行程序传入的 “Alex” 叫实际参数。
  2. 如果从内存的角度去看这两种参数的话，在调用sendmail( ) 然后传入“alex” 的时候，这个“alex” 的字符串就已经在内存中，这就相当于把“xxoo” 这个形式参数指向内存中的实际参数“alex”; 同样地；对于“eric” 这个实际参数，它在被调用的时候，”eric” 已经在内存中等待着，然后函数本身的形式参数就会指向“ eric ”，然后执行程序，这就是形式参数和实际参数的关系。
  3. 还有就是形式参数和实际参数的位置默认情况下是一一对应的
     
  4. 在Python中也可以定义默认参数，意思是在声明函数的时候，其中一些形式参数已经定义了一些默认值，注意：如果想要定义默认参数，必需把默认参数放在参数列表的最后位置！ ！ ！
     
    1.  #content="This is a testing email" 是默认参数
    2.  def send(receipent,content="This is a testing email"):
    3.      print("Email send to:",receipent,", Content:",content)
    4.      print("Mail sent successfully")
    5.      return True
    6.  
    7.  send("janice@abc-company.com") # 默认 content 用了 "This is a testing email"
    8.  send("janice@abc-company.com", "Company Notice") # content 用了 "Company Notice"
    9.  
    10.  #Results:
    11.  #Email send to: janice@abc-company.com , Content: This is a testing email
    12.  #Mail sent successfully
    13.  #Email send to: janice@abc-company.com , Content: Company Notice
    14.  #Mail sent successfully

    默认参数

  5. 也可以声明指定参数，在调用的时候输入 “”形式参数=实际参数” e.g. content=“alex"，这样就可以在函数被調用時忽略参数顺序。
  6. 对于动态参数有两种类： * 和 ** (分别是一个星号和两个星号)
    * 一个星号: 默认将传入的参数，全部放在一个元组中。 f1(*[11,22,33,44])
    ** 两个星号: 默认将传入的参数，全部放在一个字典中。 f1(**{"k1":"v1","k2":"v2”})

    动态参数 (*) 会返回一个元组，如果函数的形式参数有* 号就有特殊的功能 e.g. def f1(*args)，就是按照顺序接受传入什么的值都会转换到元组里面，并且当做元组的一个元素；如果在传实际参数的时候加一個星 * 号 e.g. f1(*li)，它的特殊的功能是将这个列表里的每一个元素都转化到元组的元素里，其实就相当于在内部​​做了一个 For 循环，把列表里的一个一个添加到元组里(Tuple)。

    1.  def f3(*args):
    2.      print(args) #返回一個元組
    3.  
    4.  li = [11,22,"Janice","dfghjk"]
    5.  name = "Janice"
    6.  
    7.  f3(li)
    8.  f3(*li)
    9.  f3(*"Janice")
    10.  f3(*name)
    11.  
    12.  #Results:
    13.  #([11, 22, 'Janice', 'dfghjk'],)
    14.  #(11, 22, 'Janice', 'dfghjk')
    15.  #('J', 'a', 'n', 'i', 'c', 'e')
    16.  #('J', 'a', 'n', 'i', 'c', 'e')

    动态参数*

    动态参数 (**) 会返回一個字典，如果函数的形式参数有** 号就有特殊的功能 e.g. def f1(**args)，就是传入什么的值都会转换到字典里面，并且当做字典的value；如果在传实际参数的时候加上两个星** 号e.g. f1(**dic)，它的特殊的功能是将这个字典里的每一个key, value 都给转化成字典的key, value，其实就相当于直接赋值到字典里。

    1.  def f4(**args):
    2.      print(args) #返回一個字典
    3.  
    4.  li = [11,22,"Janice","dfghjk"]
    5.  name = "Janice"
    6.  
    7.  f4(n1="Janice")
    8.  f4(n1="Janice", n2=20)
    9.  
    10.  dic = {"k1":"v1","k2":"v2"}
    11.  f4(kk = dic)
    12.  f4(**dic)
    13.  
    14.  #Results
    15.  #{'n1': 'Janice'}
    16.  #{'n1': 'Janice', 'n2': 20}
    17.  #{'kk': {'k1': 'v1', 'k2': 'v2'}}
    18.  #{'k1': 'v1', 'k2': 'v2'}

    动态参数**

  7. 万能参数，def f5(*args, **kwargs) (注意:* 一个星号必须在前面, ** 两个星号必须在后面!)

    1.  def f5(*args, **kwargs):
    2.      print(args)
    3.      print(kwargs)
    4.  
    5.  f5(11,22,33,44,k1="v1",k2="v2")
    6.  
    7.  #Results:
    8.  #(11, 22, 33, 44)
    9.  #{'k2': 'v2', 'k1': 'v1'}

    万能参数*args, **kwargs

  8. 全局变量和局部变量
    没有写到函数体里的变量叫全局变量，它在所有文件中都是可读；在f1函数里写的变量是 f1函数私有的，叫局部变量；变量会先找自己的局部变量，然后才找全局变量，如果你想修改全局变量(重新赋值)，这时需要加入一个global 的关键字+ 它的变量名。如果以后要读一个全局变量的时候，直接打印 e.g. print() 一下就可以啦!

    • 重点一、[列表, 字典, 元组] 如果在函数体里进行修改/新增, 这是在修改全区列表,但列表不容许在函数体里重新赋值。

    • 重点二、如果是全局变量，命名时都需要大写！ ！ ！

  9. 补充：函数的参数在传入的时候，到底是传入引用还是再传入一份列表，現在来分析一下两种结果：

    1. 如果传入的是一份列表，Python 在传入参数的时候是重新赋值的话，打印的时候就不应该出现 999
    2. 如果传入的是一个引用, li 和 a1 便会指向同一个列表
    3. 從运行后的结果可以总结：Python 在传参数的时候，其实是传入一个引用！ ！ ！
       
      1.  def f7(a1):
      2.      a1.append(9999)
      3.  
      4.  li = [11,22,33,44]
      5.  f7(li)
      6.  print(li) 
      7.  
      8.  #Results:
      9.  #[11, 22, 33, 44, 9999]

      运行后结果

实战操作

运用函数写一个简单的猜文字游戏

  1. #!/usr/bin/env python
  2. # -*- coding: utf-8 -*-
  3. # Author: Janice Cheng
  4.  
  5. import os
  6. import random
  7. import sys
  8.  
  9. # make a list of words
  10. words = [
  11.     'apple',
  12.     'banana',
  13.     'orange',
  14.     'coconuts',
  15.     'straweberry',
  16.     'lime',
  17.     'graphefruit',
  18.     'lemon',
  19.     'kumquat',
  20.     'blueberry',
  21.     'melon'
  22. ]
  23.  
  24. def clear():
  25.     if os.name == 'nt':
  26.         os.system('cls')
  27.     else:
  28.         os.system("clear")
  29.  
  30. def draw(bad_guess, good_guess, secret_word):
  31.     clear()
  32.  
  33.     print("Strikes: {}/7".format(bad_guess))
  34.     print('')
  35.  
  36.     for letter in bad_guess:
  37.         print(letter, end=' ')
  38.  
  39.     print('\n\n')
  40.  
  41.     for letter in secret_word:
  42.         if letter in good_guess:
  43.             print(letter, end='')
  44.         else:
  45.             print('_', end='')
  46.  
  47.     print('')
  48.  
  49. def get_guess(bad_guess, good_guess):
  50.     while True:
  51.         guess = input("Guess a letter: ").lower()
  52.  
  53.         if len(guess) != 1:
  54.             print("You can only guess a single letter!")
  55.         elif guess in bad_guess or guess in good_guess:
  56.             print("You've already guess that letter")
  57.         elif not guess.isalpha():
  58.             print("You can only guess letters!")
  59.         else:
  60.             return guess
  61.  
  62. def play(done):
  63.     clear()
  64.     secret_word = random.choice(words)
  65.     bad_guess = []
  66.     good_guess = []
  67.  
  68.     while True:
  69.         draw(bad_guess,good_guess,secret_word)
  70.         guess = get_guess(bad_guess,good_guess)
  71.  
  72.         if guess in secret_word:
  73.             good_guess.append(guess)
  74.             found = True
  75.  
  76.             for letter in secret_word:
  77.                 if letter not in good_guess:
  78.                     found = False
  79.  
  80.             if found:
  81.                 print("You win!")
  82.                 print("The word was {}".format(secret_word))
  83.                 done = True
  84.         else:
  85.             bad_guess.append(guess)
  86.             if len(bad_guess) == 7:
  87.                 draw(bad_guess,good_guess, secret_word)
  88.                 print("You lost!")
  89.                 print("The word was {}".format(secret_word))
  90.                 done = True
  91.  
  92.         if done:
  93.             play_again = input("Play again? y/n ").lower()
  94.             if play_again != 'n':
  95.                 return play(done=False)
  96.             else:
  97.                 sys.exit()
  98.  
  99. def welcome():
  100.     print("Welcome to Letter Guess!!")
  101.     start = input("Press enter/return to start or Q to quit >> ").lower()
  102.     if start == 'q':
  103.         print('Bye!')
  104.         sys.exit()
  105.     else:
  106.         return True
  107.  
  108. if __name__ == "__main__":
  109.  
  110.     done = False
  111.  
  112.     while True:
  113.         clear()
  114.         welcome()
  115.         play(done)

猜文字游戏

format 函数操作实战

  1. ret = '{0} lives in Hong Kong for more than {1} years!!'.format('Janice',20)
  2. ret = '{name} lives in Hong Kong for more than {year} years!!'.format(name='Janice', year=20)
  3. # Janice lives in Hong Kong for more than 20 years!!

这是 Python format 函数的源码，它也是接受一个 *号的参数和 ** 两个星号的参数

  1.     def format(self, *args, **kwargs): # known special case of str.format
  2.         """
  3.         S.format(*args, **kwargs) -> str
  4.  
  5.         Return a formatted version of S, using substitutions from args and kwargs.
  6.         The substitutions are identified by braces ('{' and '}').
  7.         """
  8.         pass
  1. 一个 *星号的函数例子

    1. >>> s = "My name is {} and I am {} years old".format("Janice",20)
    2. >>> s
    3. 'My name is Janice and I am 20 years old'
    4.  
    5. # 在参数里加入*便可以接受列表类型
    6. >>> s = "My name is {} and I am {} years old".format(*["Janice",20])
    7. >>> s
    8. 'My name is Janice and I am 20 years old'
    9.  
    10. # 这里不受列表类型
    11. >>> s = "My name is {} and I am {} years old".format(["Janice",20])
    12. Traceback (most recent call last):
    13.   File "<stdin>", line 1, in <module>
    14. IndexError: tuple index out of range
    15.  
    16. # 在括号里定义{0}和{1}，就不需要在format()函数里重覆定义传递的内容
    17. >>> s = "My name is {0} and {0} and {0} I am {1} years old".format("Janice",20)
    18. >>> s
    19. 'My name is Janice and Janice and Janice I am 20 years old'
    20.  
    21. >>> s = "My name is {} and {} and {} I am {} years old".format("Janice",21)
    22. Traceback (most recent call last):
    23.   File "<stdin>", line 1, in <module>
    24. IndexError: tuple index out of range

    一个*星号的函数

  2. 两个** 星号的函数例子 
    1.  >>> s = "My name is {name} and I am {age} years old".format(name="Janice",age=20)
    2.  >>> s
    3.  
    4.  >>> s = "My name is {name} and I am {age} years old".format(**{"name":"Janice","age":20}) # 在参数里加入**便可以接受字典类型
    5.  >>> s
    6.  'My name is Janice and I am 20 years old'

    两个**星号的函数

实战操作

运用函数式编程来进行登录或注册实战

[更新中...]

lambda 表达式介绍

这是一个简单的函数: f1(a) = a + 100

  1. >>> def f1(a):
  2. ...     return a + 100
  3. ...
  4. >>> ret = f1(10)
  5. >>> print(ret)
  6. 110

普通函数

  1. lambda a: a + 100
  2. # a + 100 是函数体，a 是变量，整句意思是输入参数 a，然后对a进行操作：a + 100

就以上的代码，可以用 lambda 表达式来实现

  1. >>> f2 = lambda a: a + 100 #自动返回
  2. >>> ret2 = f2(10)
  3. >>> print(ret2)
  4. 100

lambda 表达式例子一

  1. >>> add = lambda a1,a2: a1 + a2 #可以传两个参数
  2. >>> add(10,10)
  3. 20

lambda 表达式例子二

lambda 中的 filter 例子

  1. >>> lst = [11,22,33,44]
  2.  
  3. #Option1
  4. >>> def f(x):
  5. ...     return x > 22
  6.  
  7. >>> list(filter(f, lst))
  8. [33, 44]
  9.  
  10. #Option2
  11. >>> list(filter(lambda a: a > 22, lst))
  12. [33, 44]

lambda 表达式例子三

lambda 中的 map 例子

  1. >>> lst1 = [1,3,5,6,9]
  2. >>> lst2 = [2,4,6,8,10]
  3. >>> ret = map(lambda x,y: x+y, lst1, lst2)
  4. >>> list(ret)
  5. [3, 7, 11, 14, 19]

lambda 表达式例子四

大家都应该听过 Spark，在 Spark 里用了很多 lambda 表达式来实现 filter、map、flatMap 和 reduceByKey 的功能，以下是一個 Spark 的 wordcount 例子

  1. wordCounts = textFile.flatMap(lambda line: line.split())\
  2.     .map(lambda word: (word, 1))\
  3.     .reduceByKey(lambda a, b: a+b)

文件操作函数介紹和操作实战

打開文件

  1. ##Operation
  2. output = open(r'C:\spam', 'w') #Create output file ('w' means write)
  3. input = open('data', 'r') #Create input file ('r' means read)
  4. input = open('data') #Same as prior line ('r' is the default)
  5. open('f.txt', encoding='latin-1') #Python 3.X Unicode text files (str strings)
  6. open('f.bin', 'rb') #Python 3.X bytes files (bytes strings)
  7. open('f.bin', 'rb') #Python 2.X bytes files (str strings)
  8. for line in open('data'): #File iterators read line by line

操作文件

  1. ##Method
  2. aString = input.read() #Read entire file into a single string
  3. aString = input.read(N) #Read up to nextNcharacters (or bytes) into a string
  4. aString = input.readline() #Read next line (including\nnewline) into a string
  5. aList = input.readlines() #Read entire file into list of line strings (with \n)
  6. output.write(aString) #Write a string of characters (or bytes) into file
  7. output.writelines(aList) #Write all line strings in a list into file
  8. output.close() #Manual close (done for you when file is collected)
  9. output.flush() #Flush output buffer to disk without closing
  10. anyFile.seek(N) #Change file position to offsetNfor next operation

文件的打开方式不同就会对文件产生不同的影响，打开方式有几种：1) 以字符串类型读写文件; 2) 有加号的方式读写文件; 3) 以二进制(字节)类型读写文件;

  1. # Remember to close the file after every file modification
  2. f = open("readme.txt",'w') #open a file for writing
  3. f.write("this is the first line\n") #write a line to the file
  4. f.write("this is the second line\n") #write one more line to the file
  5. f.close() #close a file
  6.  
  7. f = open("readme.txt",'r') #open a file for reading
  8. f.read() # read the entire content of file at once
  9. f.read(1) # read 1 char from the file
  10. f.seek(1) # 调整指针到第一个位置
  11. f.tell()
  12. f.readable() # 是否是可读文件
  13. f.readlines() # reading all lines as an array
  14. f.readlines() # read only one line
  15. f.close() #close a file
  16.  
  17. f = open("readme.txt",'a') #append data to the original file
  18. f.write("this is the third line\n") #write a line to the file
  19. f.close() #close a file

文件操作

以字符串类型打开：

  1. Append: "a" - 以追加的方式打开文件，(打开文件后的文件指针会自动移到文件末尾) 如果文件不存在则创建。

    1. f = open("db","a")
    2. f.write("Python")
    3. f.close()
    4.  
    5. #Before: admin|123
    6. #After: admin|123Python

    Append:a

  2. Read: "r" - 以读的方式打开文件，可读取文件信息。 
    1.  >>> f2 = open("db","r")
    2.  >>> data2 = f2.read()
    3.  >>> print(data2)
    4.  Admin|123
    5.  Alex|alex3417
    6.  >>> print(type(data2))
    7.  <class 'str'>

    Read:r

  3. Write: "w" - 以写的方式打开文件，如果文件存在，则清空该文件，再重新写入新内容。 
    1.  >>> import csv
    2.  >>> f2 = open("db","w")
    3.  >>> data = "admin|123"
    4.  >>> f2.write(data)
    5.  9
    6.  >>> f2.close()

    Write:w

  4. Extend: "x" - 如果这个文件存在就报错，如果不存在就创建并写内容 (跟 w 是一样的，只增加多一个条件判断，判断一下当前文件是否已经存在) 
    1.  >>> f2 = open("db","x") #如果文件已经存在，你会报错
    2.  Traceback (most recent call last):
    3.    File "<stdin>", line 1, in <module>
    4.  FileExistsError: [Errno 17] File exists: 'db'
    5.  
    6.  >>> f2 = open("db_test","x")
    7.  >>> data = "admin|123"
    8.  >>> f2.write(data)
    9.  9
    10.  >>> f2.close()

    Extend:x

有+號的打開模式

  1. Append: "a+" - 以读写方式打开文件，并把文件指针移到文件尾。
  2. Read: "r+" - 以读写方式打开文件，可以对文件进行读写操作，Python 在读完整个文件的时候，默认指针位置会在文件的末位​​，所以当 f.write("9999") 的时候，就会在文件最后的位置追加，所以如果用 "r" 打开时，可以配合 seek() 来指定写入的位置 (看下面seek()的例子)。 
    1.  >>> f = open("db","r+", encoding='utf-8')
    2.  >>> data = f.read()
    3.  >>> print(data)
    4.  admin|123
    5.  >>> f.write("")
    6.  11
    7.  >>> f.close()
    8.  
    9.  #Results:
    10.  #Before: admin|123
    11.  #After: admin|1239999

    Read:r+

  3. Write: "w+" - 清除文件内容、然后以读写方式打开文件。可读可写，但會先清空，後再寫。

以二进制(字节)类型打开

  1. Append: "ab" - 如果使用二进制的方式写，必需也得传入字节类型

    1.  >>> f = open("db","ab")
    2.  >>> f.write(bytes("Python", encoding='utf-8'))
    3.  6
    4.  >>> f.close()
    5.  
    6.  #Results:
    7.  #Before: admin|123
    8.  #After: admin|123Python

    Append:ab

    如果使用二进制的方式去写数据，但传入的是一个字符串，这时候程序就会报错！

    1.  >>> f3 = open("db","ab") #如果加b只能写入字节
    2.  >>> f3.write("hello")
    3.  Traceback (most recent call last):
    4.    File "<stdin>", line 1, in <module>
    5.  TypeError: a bytes-like object is required, not 'str'

    Append:ab

  2. Read: "rb" - 只读，在读文件时自己去跟Python 底层的二进制沟通，你读的时候是读二进制，所以写的时候也需要写上二进制(字节)，在硬盘上存储的是二进制格式，Python 在读的时候，默认把底层的二进制字节转转换成字符串，所以打印出来才会是字符串。 
    1.  >>> f1 = open("db","rb")
    2.  >>> data1 = f1.read()
    3.  >>> print(data1)
    4.  b'Admin|123\nAlex|alex3417'
    5.  >>> print(type(data1))
    6.  <class 'bytes'>

    Read:rb

    **注意: encoding 这个参数，它是 Python 在把字节转化成字符串设定的一个编码，Python 会按照这个编码帮我们转换。意思就是说你用什么编码去存储文件(写)的同时，也应该用相同的编码去打开(读)文件。如果把 b 取掉读到的就是字符串类型，所以如果在打开文件的时候出现乱码，很大可能是这个 encoding 出现问题。

    1. f=open("db","r",encoding="GBK")
  3. Write: "wb"

文件操作的功能

  1. seek( ): 主动调整指针的位置，指针跳到指定位置 (永远以字符的方式找位置)

    1.  >>> f = open("db","r+")
    2.  >>> data = f.read(1)
    3.  >>> print(data)
    4.  a
    5.  >>> f.seek(1) #调整指针到第一个位置
    6.  1
    7.  >>> f.write("") #当前指针位置开始向后覆盖，写数据，打开方式有 b 、只能写字节；无b就是写字符
    8.  3
    9.  >>> f.close()
    10.  
    11.  #Results:
    12.  #Before: #admin|123
    13.  #After: #a999n|123

    seek()

  2. tell( ): 获取当前指针的位置（字节），因為一個中文是3個字節，所以當調用read(1)方法之後，再查看當前字節位置，就會返回3 
    1.  >>> f = open("db","r+")
    2.  >>> data = f.read(1)
    3.  >>> print(data)
    4.  金
    5.  >>> print(f.tell())
    6.  3
    7.  
    8.  #db: 金|123

    tell()

  3. read( ): 默认无参数，读全部，如果在打开文件的时候是"rb"，读取的时候会按字节；如果在打开文件的时候是"r"，读取的时候会按字符。 
    1.  >>> f = open("db","rb")
    2.  >>> data = f.read(1)
    3.  >>> print(data)
    4.  b'\xe9'
    5.  >>> f.close()
    6.  >>> f = open("db","r+")
    7.  >>> data = f.read(1)
    8.  >>> print(data)
    9.  金
    10.  >>> f.close()

    read()

  4. write( ): 写数据，如果在打开文件的时候是"rb"，读取的时候会按字节；如果在打开文件的时候是"r"，读取的时候会按字符。
  5. close( ):
  6. fileno( ):
  7. flush( ): 刷新，在文件还没有close()之前，f.write 的数据会存放在内存里而不直接写入文件，如果用了flush()的话，它就会在文件还没有调用close()的状况下强行把数据写入文件中。 
    1.  >>> f = open("db","a")
    2.  >>> f.write("")
    3.  3
    4.  >>>
    5.  >>> input("Please input a number: ") #等待着用户输入
    6.  Please input a number:

    flush()

  8. readable( ): 判断是否可读 
    1.  >>> f2 = open("db_test","w")
    2.  >>> f2.readable()
    3.  False
    4.  >>> f1 = open("db_test","r")
    5.  >>> f1.readable()
    6.  True

    readable()

  9. seekable( ):
  10. readline( ): 只读取一行（读取的过程指针会在移动） 
    1.  db.txt
    2.  admin|123
    3.  janice|janice123
    4.  alex|alex123
    5.  kennith|ken123
    6.  
    7.  >>> f1 = open("db","r")
    8.  >>> f1.readline()
    9.  'admin|123\n'
    10.  >>> f1.readline()
    11.  'janice|janice123\n'
    12.  >>> f1.close()

    readline()

  11. truncate( ):截断数据，只把指针位置后的清空 
    1.  f = open("db","r+",encoding='utf-8')
    2.  f.seek(3)
    3.  f.truncate()
    4.  f.close()
    5.  
    6.  #admin|123
    7.  #adm

    truncate()

  12. for-loop: 
    1.  f = open("db","r+",encoding='utf-8')
    2.  for line in f:
    3.      print(line)
    4.  
    5.  f.close()
    6.  
    7.  #admin|123
    8.  #alex|alex3417
    9.  #kennith|ken3344

    for-loop

關閉文件

  1. close( )

    1. f = close()
  2. with 文件操作 
    1.  with open("db","r+", encoding='utf-8') as f:
    2.      for line in f:
    3.          print(line)
    4.  
    5.  #admin|123
    6.  #alex|alex3417
    7.  #kennith|ken3344

    with f1

  3. with 同時操作兩個文件 
    1.  #從db1文件一个以只读的方法打开，從db2文件一个以只写的方法打开
    2.  #从DB1读一行写一行到DB2
    3.  with open("db1","r", encoding='utf-8') as f1, open("db2","w", encoding='utf-8') as f2:
    4.      for line in f1:
    5.          new_line = line.replace("alex","eric")
    6.          f2.write(new_line)

    with f1, f2

gzip

  1. >>> import gzip
  2. >>> with gzip.open('score.csv.gz','rt') as f:
  3. ...     print(f.read())
  4. ...
  5. chinese,88
  6. english,90
  7. maths,85
  8. computer science,90
  9. chemistry,67
  10. music,88
  11. economics,75

gzip

本周作业

操作 haproxy.conf 文件

  1.  global
  2.          log 127.0.0.1 local2
  3.          daemon
  4.          maxconn 256
  5.          log 127.0.0.1 local2 info
  6.  defaults
  7.          log global
  8.          mode http
  9.          timeout connect 5000ms
  10.          timeout client 50000ms
  11.          timeout server 50000ms
  12.          option  dontlognull
  13.  listen stats :8888
  14.          stats enable
  15.          stats uri       /admin
  16.          stats auth      admin:1234
  17.  frontend oldboy.org
  18.          bind 0.0.0.0:80
  19.          option httplog
  20.          option httpclose
  21.          option  forwardfor
  22.          log global
  23.          acl www hdr_reg(host) -i www.oldboy.org
  24.          use_backend www.oldboy.org if www
  25.  backend www.oldboy.org
  26.          server 100.1.7.9 100.1.7.9 weight 20 maxconn 3000
  27.  backend buy.oldboy.org
  28.          server 100.1.7.90 100.1.7.90 weight 20 maxconn 3000

haproxy.cof

参考资料

金角大王：Python之路,Day3 - Python基础3

银角大王：Python开发【第四篇】：Python基础之函数

第三章：Python基础の函数和文件操作实战的更多相关文章

  1. Python自动化 【第三篇】：Python基础-集合、文件操作、字符编码与转码、函数

    1.        集合 1.1      特性 集合是一个无序的,不重复的数据组合,主要作用如下: 去重,把一个列表变成集合实现自动去重. set可以看成数学意义上的无序和无重复元素的集合,因此,两 ...

  2. python基础3之文件操作、字符编码解码、函数介绍

    内容概要: 一.文件操作 二.字符编码解码 三.函数介绍 一.文件操作 文件操作流程: 打开文件,得到文件句柄并赋值给一个变量 通过句柄对文件进行操作 关闭文件 基本操作: #/usr/bin/env ...

  3. Python基础-week03 集合 , 文件操作 和 函数详解

    一.集合及其运算 1.集合的概念 集合是一个无序的,不重复的数据组合,它的主要作用如下 *去重,把一个列表变成集合,就自动去重了 *关系测试,测试两组数据之前的交集.并集.差集.子集.父级.对称差集, ...

  4. python学习笔记-（七）python基础--集合、文件操作&函数

    本节内容 1.集合操作 2.文件操作 3.字符编码与转码 4.函数操作 1.集合操作 集合是一个无序的.不重复的数据组合: 1.1 常用操作 它的作用是: 1)自动去重:列表变成集合,自动去重: &g ...

  5. Python基础7：文件操作

    [ 文件操作] 1 对文件操作流程 打开文件,得到文件句柄并赋值给一个变量 通过句柄对文件进行操作 关闭文件 现有文件如下: 昨夜寒蛩不住鸣. 惊回千里梦,已三更. 起来独自绕阶行. 人悄悄,帘外月胧 ...

  6. python基础学习笔记——文件操作

    文件操作 初始文件操作 使用Python来读写文件是非常简单的操作,我们使用open()函数来打开一个文件,获取到文件句柄,然后通过文件句柄就可以进行各种各样的操作了 根据打开方式的不同能够执行的操作 ...

  7. Python基础知识(八)----文件操作

    文件操作 一丶文件操作初识 ###f=open('文件名','模式',编码): #open() # 调用操作系统打开文件 #mode #对文件的操作方式 #encoding # 文件的编码格式 存储编 ...

  8. python基础八之文件操作

    python的文件操作 1,打开文件 编码方式要和文件的编码方式相同! #open('路径','打开方式','指定编码方式') f = open(r'E:\pycharm\学习\day8\test', ...

  9. Python基础之 一 文件操作

    文件操作 流程: 1:打开文件,得到文件句柄并赋值给一个变量 2:通过句柄对文件进行操作 3:关闭文件 模式解释 r(读) , w(写) ,a(附加)r+(读写的读), w+(读写的写),a+(读附加 ...

随机推荐

  1. python 序列：字符串、列表、元组

    python 序列:字符串.列表.元组   序列:包含一定顺序排列的对象的一个结构 内建函数:str() list() tuple() 可以使用str(obj)可以把对象obj转换成字符串 list( ...

  2. 微信公众号开发系列-获取微信OpenID

    在微信开发时候在做消息接口交互的时候须要使用带微信加密ID(OpenId),下面讲讲述2中类型方式获取微信OpenID.接收事件推送方式和网页授权获取用户基本信息方式获取. 1.通过接收被动消息方式获 ...

  3. [每天一个Linux小技巧]　强制让内核按单核模式启动

    在启动參数里追加 nosmp nosmp的说明例如以下: nosmp [SMP] Tells an SMP kernel to act as a UP kernel, and disable the ...

  4. POJ 1469（裸二分匹配）

    COURSES Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 18993   Accepted: 7486 Descript ...

  5. Vboxmanage改动uuid报错的解决的方法

    我的环境: Virtualbox 4.3.10 r93012 操作系统:win7 问题:Virtualbox在使用拷贝的虚拟盘时会提示uuid冲突: Because a hard disk with ...

  6. 二、spring Boot构建的Web应用中，基于MySQL数据库的几种数据库连接方式进行介绍

    包括JDBC.JPA.MyBatis.多数据源和事务. 一.JDBC 连接数据库 1.属性配置文件(application.properties) spring.datasource.url=jdbc ...

  7. 使用Myeclipse为数据表创建hibernate实体对象

    hibernate是orm框架的一种,orm即Object Relational Mapping,对象映射关系,其主要作用是将数据库(mysql,mssql,oracle)的对象转换为具体编程语言(如 ...

  8. MyEclipse 2014 破解版下载：我有，需要的给我说一声，给你发过去

    1.破解版的,需要的在下面给我说一声,云盘给你发过去.

  9. IntelliJ IDEA创建java项目

    IntelliJ IDEA创建java项目 进入到IntelliJ IDEA启动界面,点击Create New Project 2.这样就进入到了创建项目页面,这里可以创建好多项目,这里我们以java ...

  10. 【TEGer 在全球架构师峰会】 : 腾讯海外计费系统架构演进

    欢迎大家前往云加社区,获取更多腾讯海量技术实践干货哦~ 作者简介:abllen,2008年加入腾讯,一直专注于腾讯计费平台建设,主导参与了腾讯充值中心.计费开放平台.统一计费米大师等项目,见证了米大师 ...