大二上 python 期末复习

类(class)

1. 类的定义

   class nameoftheclass(parent_class):
       statement1
       statement2
       statement3
   

2. init 方法：将对象创建为有初始状态的

   >>> class Complex:
   ...     def __init__(self, realpart, imagpart):
   ...         self.r = realpart
   ...         self.i = imagpart
   ...
   >>> x = Complex(3.0, -4.5)    #创建了一个新的类实例并将该对象赋给局部变量  x
   >>> x.r, x.i
   (3.0, -4.5)
   

3. 继承：

   1. 它将继承父类的所有功能（如变量和方法）

   2. 可以重写新方法

   3. 一个类可以继承自多个类，具有父类的所有变量和方法

      class MyClass(Parentclass1, Parentclass2,...):
          def __init__(self):
              Parentclass1.__init__(self)
              Parentclass2.__init__(self)
              ...
              ...
      

   4. python3自动继承object类（如果为空）

4. 删除对象

   del s

   del 实际上使对象的引用计数减少一，当对象的引用计数变成零的时候，垃圾回收器会删除这个对象

5. 直接使用属性print(std.name)

Collections 模块

import collections

1. Counter 对象:一个有助于 hashable 对象计数的 dict 子类

   1. elements() 的方法，其返回的序列中，依照计数重复元素相同次数，元素顺序是无序的

      >>> c = Counter(a=4, b=2, c=0, d=-2)
      >>> list(c.elements())
      ['b','b','a', 'a', 'a', 'a']
      

   2. most_common() 方法返回最常见的元素及其计数，顺序为最常见到最少

      >>> Counter('abracadabra').most_common(3)
      [('a', 5), ('r', 2), ('b', 2)]
      

   3. defaultdict :内建 dict 类的子类

元组（tuple)

元组的元素不能修改

1. 元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可a = 'Fedora', 'ShiYanLou', 'Kubuntu', 'Pardus' a = (1, 2, 3, 4)
2. 元组封装data = ("shiyanlou", "China", "Python")
3. 元组拆封 name, country, language = data

集合（set）

无序不重复元素

1. 大括号或 set() 函数可以用来创建集合

2. 空集合：使用 set() 而不是 {}，后者用于创建空字典

3. 实例：

   创建去重+减法+|+&+^

   >>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
   >>> print(basket)                      # 你可以看到重复的元素被去除
   {'orange', 'banana', 'pear', 'apple'}
   >>> 'orange' in basket
   True
   >>> 'crabgrass' in basket
   False
   
   >>> # 演示对两个单词中的字母进行集合操作
   ...
   >>> a = set('abracadabra')
   >>> b = set('alacazam')
   >>> a                                  # a 去重后的字母
   {'a', 'r', 'b', 'c', 'd'}
   >>> a - b                              # a 有而 b 没有的字母
   {'r', 'd', 'b'}
   >>> a | b                              # 存在于 a 或 b 的字母
   {'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
   >>> a & b                              # a 和 b 都有的字母
   {'a', 'c'}
   >>> a ^ b                              # 存在于 a 或 b 但不同时存在的字母
   {'r', 'd', 'b', 'm', 'z', 'l'}
   

   添加和弹出元素：

   >>> a = {'a','e','h','g'}
   >>> a.pop()  # pop 方法随机删除一个元素并打印
   'h'
   >>> a.add('c')
   >>> a
   {'c', 'e', 'g', 'a'}
   

列表(list)

列表允许修改元素

1. a = [ 1, 342, 223, ‘India’, ‘Fedora’]

2. a[:]返回一个拷贝

3. a[0:5] 用数学表达式可以写为 [0,5)

4. a + [36, 49, 64, 81, 100]返回新列表

5. letters[2:5] = ['C', 'D', 'E']赋值

6. 查询'cool' in a

7. 长度len(a)

8. 是否为空if list_name:

9. 函数

   1. a.append(45) 添加元素 45 到列表末尾
   2. a.insert(0, 1)在列表索引 0 位置添加元素 1
   3. a.count(45)返回列表元素中 s 的数量
   4. a.remove(234)在列表中移除任意指定值
   5. a.reverse()反转整个列表
   6. b = [45, 56, 90] a.extend(b) 添加 b 的元素而不是 b 本身
   7. a.sort()排序的前提是列表的元素是可比较的
   8. del a[-1]删除指定位置的列表元素

10. 用作栈和队列

    1. a.pop()弹出末尾
    2. a.pop(0) 弹出列表中第一个元素

11. 列表推导式

    1. squares = list(map(lambda x: x**2, range(10)))

    2. squares = [x**2 for x in range(10)]

    3. >>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
       [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
       

    4. 嵌套>>> a=[1,2,3] >>> z = [x + 1 for x in [x ** 2 for x in a]] >>> z [2, 5, 10]

字典(dict)

键值对：同一个字典内的键互不相同, 且是不可变类型（不能用列表做键）

1. 创建字典

   >>> data = {'kushal':'Fedora', 'kart_':'Debian', 'Jace':'Mac'}
   >>> data
   {'kushal': 'Fedora', 'Jace': 'Mac', 'kart_': 'Debian'}
   >>> data['kart_']
   'Debian'
   

2. 创建新的键值对

   data['parthan'] = 'Ubuntu'
   

   不知道元素是否已经存在dict.setdefault(key, default)

   >>> data = {}
   >>> data.setdefault('names', []).append('Ruby')
   >>> data
   {'names': ['Ruby']}
   >>> data.setdefault('names', []).append('Python')
   >>> data
   {'names': ['Ruby', 'Python']}
   >>> data.setdefault('names', []).append('C')
   >>> data
   {'names': ['Ruby', 'Python', 'C']}
   

   dict = {'runoob': '菜鸟教程', 'google': 'Google 搜索'}
    
   print "Value : %s" %  dict.setdefault('runoob', None)
   print "Value : %s" %  dict.setdefault('Taobao', '淘宝')
   

3. 删除任意指定的键值对

   del data['kushal']
   

4. 查询指定的键是否存在于字典中

   'ShiYanLou' in data
   

5. 从包含键值对的元组中创建字典

   >>> dict((('Indian','Delhi'),('Bangladesh','Dhaka')))
   {'Indian': 'Delhi', 'Bangladesh': 'Dhaka'}
   

6. 遍历一个字典items()

   for x, y in data.items():
        print("{} uses {}".format(x, y))
   

7. 返回指定键的值(不知道键存不存在),get()**

   dict.get(key, default=None) 如果键不在字典中返回默认值 None 或者设置的默认值

   >>> data['foo']
   Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
   KeyError: 'foo'
   >>> data.get('foo', 0)
   0
   

8. 同时获得元素索引值enumerate()

   for i, j in enumerate(['a', 'b', 'c']):
        print(i, j)
   

9. 同时遍历两个序列类型zip()

   zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表

   >>> a = ['Pradeepto', 'Kushal']
   >>> b = ['OpenSUSE', 'Fedora']
   >>> for x, y in zip(a, b):
   ...     print("{} uses {}".format(x, y))
   ...
   Pradeepto uses OpenSUSE
   Kushal uses Fedora
   

字符串

1. 多行字符串 ：三引号

   >>> print("""\
   ... Usage: thingy [OPTIONS]
   ...      -h                        Display this usage message
   ...      -H hostname               Hostname to connect to
   ... """)
   Usage: thingy [OPTIONS]
        -h                        Display this usage message
        -H hostname               Hostname to connect to
   

2. 大小写

   title() 返回字符串的标题版本,即单词首字母大写其余字母小写
   upper() 返回字符串全部大写的版本
   lower() 返回字符串的全部小写版本
   swapcase() 返回字符串大小写交换后的版本
   isalnum() 检查所有字符是否只有字母和数字
   isalpha() 检查字符串之中是否只有字母
   

3. x.split(':') 默认空格分隔，它返回一个包含所有分割后的字符串的列表

4. "-".join("GNU/Linux is great".split()) 连接字符串join()，它需要一个包含字符串元素的列表作为输入，用 "-" 连接它们

5. strip(chars)，用来剥离字符串首尾中指定的字符，默认为空格

   s.strip(“cwsd.”) #删除在字符串左边出现的’c’,‘w’,‘s’,‘d’,’.'字符

   lstrip(chars) 或 rstrip(chars) 只对字符串左或右剥离

6. 字符串格式化:print(“Year {} Rs. {:.2f}”.format(year, value)) + end=" “, sep=” "

   其实是str.format()函数print("{}+to you{:.1f}".format(666,1.2365))

7. 查找

   1. s.find(“for”)，找不到返回-1
   2. s.startswith(“fa”) 开头
   3. s.endswith(“reason”) 结尾

8. 奇技淫巧

   1. z = s[::-1] 倒叙字符串
   2. x="*" * 5 print(x) 打印字符串

模块

1. 你可以由全局变量 __name__ 得到模块的模块名（一个字符串）

    if __name__ == '__main__': 这条语句，它的作用是，只有在当前模块名为 __main__ 的时候（即作为脚本执行的时候）才会执行此 if 块内的语句。换句话说，当此文件以模块的形式导入到其它文件中时，if 块内的语句并不会执行
   

2. import xxx as x

   from xxx import xxx

3. 包

   1. 含有 __init__.py 文件的目录可以用来作为一个包，目录里的所有 .py 文件都是这个包的子模块

   2. 如果 __init__.py 文件内有一个名为 __all__ 的列表，那么只有在列表内列出的名字将会被公开。

      因此如果 mymodule 内的 __init__.py 文件含有以下内容：

      from mymodule.bars import simplebar
      __all__ = [simplebar, ]
      

      那么导入时将只有 simplebar 可用。如果你在 python3 解释器中进行测试，需要确定是在 mymodule 目录同级的目录下执行的 python3，类似下面的操作，否则会出现 ImportError: No module named 'mymodule' 的报错。

   3. os 模块提供了与操作系统相关的功能

      1. getuid() 函数返回当前进程的有效用户 id
      2. getpid() 函数返回当前进程的 id。getppid() 返回父进程的 id。
      3. uname() 函数返回识别操作系统的不同信息，在 Linux 中它返回的详细信息可以从 uname -a 命令得到。uname() 返回的对象是一个元组，（sysname, nodename, release, version, machine）。
      4. getcwd() 函数返回当前工作目录。chdir(path) 则是更改当前目录到 path。

   4. Requests 模块

      使用 get() 方法获取任意一个网页
      
      req = requests.get('https://github.com') 
      
       req.status_code
      

   5. argparse 模块帮你非常容易的编写用户友好的命令行接口

IO

1. days = int(input("Enter days: "))

文件

1. open() 函数：打开文件

   close()函数：关闭文件

   "r"，以只读模式打开，你只能读取文件但不能编辑/删除文件的任何内容
   "w"，以写入模式打开，如果文件存在将会删除里面的所有内容，然后打开这个文件进行写入
   "a"，以追加模式打开，写入到文件中的任何数据将自动添加到末尾
   
   默认的模式为只读模式
   

2. read() 方法一次性读取整个文件

   read(size) 有一个可选的参数 size，用于指定字符串长度

   >>> fobj = open("sample.txt")
   >>> fobj.read()
   'I love Python\nI love shiyanlou\n'
   >>> fobj.close()
   

   readline() 能帮助你每次读取文件的一行

   readlines() 读取所有行到一个列表中

   循环遍历文件对象来读取文件中的每一行:↓

   >>> fobj = open('sample.txt')
   >>> for x in fobj:
   ...     print(x, end = '')
   ...
   I love Python
   I love shiyanlou
   >>> fobj.close()
   
   
   
   for i,line in enumerate(fd):
           spaces += line.count(' ')
           tabs += line.count('\t')
   

3. write()文件写入 fobj.write(‘powerpork\n’)

4. 使用 with 语句

   使用 with 语句处理文件对象，它会在文件用完后会自动关闭，就算发生异常也没关系。它是 try-finally 块的简写：

   >>> with open('sample.txt') as fobj:
   ...     for line in fobj:
   ...         print(line, end = '')
   ...
   I love Python
   I love shiyanlou
   

函数

1. 全局变量 global

2. 默认参数值(没传值的时候默认):::函数重载 的功能大都可以使用默认参数达到

   1. 具有默认值的参数后面不能再有普通参数，比如 f(a,b=90,c) 就是错误的
   2. 默认值只被赋值一次，因此如果默认值是任何可变对象时会有所不同，比如列表、字典或大多数类的实例。例如，下面的函数在后续调用过程中会累积（前面）传给它的参数

   def test(a , b=-99):
        return True
   

   >>> def f(a, data=[]):
   ...     data.append(a)
   ...     return data
   ...
   >>> print(f(1))
   [1]
   >>> print(f(2))
   [1, 2]
   >>> print(f(3))
   [1, 2, 3]
   

   >>> def f(a, data=None):
   ...     if data is None:
   ...         data = []
   ...     data.append(a)
   ...     return data
   ...
   >>> print(f(1))
   [1]
   >>> print(f(2))
   [2]
   

3. 关键字参数

   >>> def func(a, b=5, c=10):
   ...     print('a is', a, 'and b is', b, 'and c is', c)
   ...
   >>> func(12, 24)
   a is 12 and b is 24 and c is 10
   >>> func(12, c = 24)
   a is 12 and b is 5 and c is 24
   >>> func(b=12, c = 24, a = -1)
   a is -1 and b is 12 and c is 24
   

   在上面的例子中你能看见调用函数时使用了变量名，比如 func(12,c = 24)，这样我们将 24 赋给 c 且 b 具有默认值。

4. 文档字符串

   #!/usr/bin/env python3
   import math
   
   def longest_side(a, b):
       """
       Function to find the length of the longest side of a right triangle.
   
       :arg a: Side a of the triangle
       :arg b: Side b of the triangle
   
       :return: Length of the longest side c as float
       """
       return math.sqrt(a*a + b*b)
   
   if __name__ == '__main__':
       print(longest_side.__doc__)
       print(longest_side(4,5))
   

5. 高阶函数：

   1. 使用一个或多个函数作为参数

   2. 返回另一个函数作为输出

   3. map()函数:它接受一个函数和一个序列（迭代器）作为输入，然后对序列（迭代器）的每一个值应用这个函数，返回一个序列（迭代器）

      >>> lst = [1, 2, 3, 4, 5]
      >>> def square(num):
      ...     "返回所给数字的平方."
      ...     return num * num
      ...
      >>> print(list(map(square, lst)))
      [1, 4, 9, 16, 25]
      

异常

1. 首先，执行  try  子句 （在  try  和  except  关键字之间的部分）。
   
   如果没有异常发生，except  子句 在  try  语句执行完毕后就被忽略了。
   
   如果在 try 子句执行过程中发生了异常，那么该子句其余的部分就会被忽略。
   
   如果异常匹配于  except  关键字后面指定的异常类型，就执行对应的 except 子句。然后继续执行  try  语句之后的代码。
   
   如果发生了一个异常，在  except  子句中没有与之匹配的分支，它就会传递到上一级  try  语句中。
   
   如果最终仍找不到对应的处理语句，它就成为一个未处理异常，终止程序运行，显示提示信息。
   

2. >>> def get_number():
   ...     "Returns a float number"
   ...     number = float(input("Enter a float number: "))
   ...     return number
   ...
   >>>
   >>> while True:
   ...     try:
   ...         print(get_number())
   ...     except ValueError:
   ...         print("You entered a wrong value.")
   ...
   Enter a float number: 45.0
   45.0
   Enter a float number: 24,0
   You entered a wrong value.
   Enter a float number: Traceback (most recent call last):
     File "<stdin>", line 3, in <module>
     File "<stdin>", line 3, in get_number
   KeyboardInterrupt
   

3. 一个空的 except 语句能捕获任何异常

4. 使用 raise 语句抛出一个异常

   >>> try:
   ...     raise ValueError("A value error happened.")
   ... except ValueError:
   ...     print("ValueError in our code.")
   ...
   ValueError in our code.
   

5. finally 子句，目的在于定义在任何情况下都一定要执行的功能

   finally 子句用于释放外部资源（文件或网络连接之类的），无论它们的使用过程中是否出错

   不管有没有发生异常，finally 子句 在程序离开 try 后都一定会被执行。当 try 语句中发生了未被 except 捕获的异常（或者它发生在 except 或 else 子句中），在 finally 子句执行完后它会被重新抛出。
   

   >>> try:
   ...     raise KeyboardInterrupt
   ... finally:
   ...     print('Goodbye, world!')
   ...
   Goodbye, world!
   KeyboardInterrupt
   Traceback (most recent call last):
     File "<stdin>", line 2, in ?
   

6. 使用 with 语句

   使用 with 语句处理文件对象，它会在文件用完后会自动关闭，就算发生异常也没关系。它是 try-finally 块的简写：

   >>> with open('sample.txt') as fobj:
   ...     for line in fobj:
   ...         print(line, end = '')
   ...
   I love Python
   I love shiyanlou
   

逻辑运算符

逻辑运算符 and 和 or 也称作短路运算符：它们的参数从左向右解析，一旦结果可以确定就停止。例如，如果 A 和 C 为真而 B 为假，A and B and C 不会解析 C 。作用于一个普通的非逻辑值时，短路运算符的返回值通常是能够最先确定结果的那个操作数。

关系运算可以通过逻辑运算符 and 和 or 组合，比较的结果可以用 not 来取反意。逻辑运算符的优先级又低于关系运算符，在它们之中，not 具有最高的优先级，or 优先级最低，所以 A and not B or C 等于 (A and (notB)) or C。当然，括号也可以用于比较表达式。

>>> 5 and 4   # 首先判断5，肯定为true，那么最终的结果就取决于 and 后面那个的布尔值，4 的布尔值为 true，这样就可以确定整个表达式的值为 true 了，所以返回 4
4
>>> 0 and 4   # 首先判断0，因为 0 的布尔值为 false，那么不管 and 后面那个的布尔值是什么，整个表达式的布尔值都应该为 false 了，这个时候就不需要判断 4 了，直接返回最先确定结果的那个数也就是0
0
>>> False or 3 or 0
3
>>> 2 > 1 and not 3 > 5 or 4
True

虚拟环境

python虚拟环境搭建和包下载

python -m venv venv_name
1.  pip install -r requirements.txt
2.  cd /home/anwen/flask_venv/bin;
3.  source activate
4.  pip list
5.  deactivate
6.  cd ~

测试(waiting)

1. pytest
2. 各类 assert 语句

创建项目(waiting)

创建项目，编写 __init__ 文件
使用 setuptools 模块，编写 setup.py 和 MANIFEST.in 文件
创建源文件的发布版本
项目注册&上传到 PyPI