Python 3 （含rx、SQLAlchemy、arrt.s、mapper) Chapter_1

Myth丶恋晨 2022-02-17 19:32 79阅读 0赞

**目录**

1. 基础语法

Python3

2. rx模块（表示多个异步流）Reactive Extensions for Python (RxPY)

3. SQLAlchemy

4. arrt.s

5. typing

6. marshmallow

--------------------

## **1. 基础语法** ##

**缩进：**

Python 的代码块不使用大括号 \{\} 来控制类，函数以及其他逻辑判断。python 最具特色的就是用缩进来写模块。

缩进的空白数量是可变的，但是所有代码块语句必须包含相同的缩进空白数量，这个必须严格执行。

**空行：**

函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。

但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。

记住：空行也是程序代码的一部分。

> import sys; x = 'runoob'; sys.stdout.write(x + '\\n')

cmd报错：SyntaxError: Non-ASCII character '\\xe8' in file 的解决方法：

解决方法为只要在文件开头加入 \# -\*- coding: UTF-8 -\*- 或者 \#coding=utf-8 就行了

多变量赋值：

> a = b = c = 1  
> 
> a, b, c = 1, 2, "john"

Python2有五个标准的数据类型：number, string, list（列表）, tuple（元组）, dictionary（字典）

列表中值的切割也可以用到变量 \[头下标:尾下标\] ，就可以截取相应的列表，从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标可以为空表示取到头或尾。

> list = \[ 'runoob', 786 , 2.23, 'john', 70.2 \]
> 
> print list\[2:\] \# 输出从第三个开始至列表末尾的所有元素 \[123, 'john', 123, 'john'\]
> 
> print list\[1:3\] \# 输出第二个至第三个元素 \[786, 2.23\]

元组用 () 标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。

> \# -\*- coding: UTF-8 -\*-
> 
> tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
> 
> print tuple \# 输出完整元组 ('runoob', 786, 2.23, 'john', 70.2)

> Python2.x 里，整数除整数，只能得出整数。如果要得到小数部分，把其中一个数改成浮点数即可。
> 
>     >>> 1/2
>     0
>     >>> 1.0/2
>     0.5
>     >>> 1/float(2)
>     0.5

**为解决乱码问题，打开cmd窗口，在命令行输入 “chcp 65001”即可。**

Python 语言允许在一个循环体里面嵌入另一个循环。

python 并不支持 switch 语句，**所以多个条件判断，只能用 elif 来实现**，如果判断需要多个条件需同时判断时，可以使用 or （或），表示两个条件有一个成立时判断条件成功；使用 and （与）时，表示只有两个条件同时成立的情况下，判断条件才成功。

# coding: UTF-8
    i = 2
    while(i < 10):
       j = 2
       while(j <= (i/j)):
          if not(i%j): break
          j = j + 1
       if (j > i/j) : print i, " 是素数"
       i = i + 1
     
    print "Good bye!"

C:\\doc>python test.py  
2  是素数  
3  是素数  
5  是素数  
7  是素数  
Good bye!

--------------------

### Python3 ###

与Python2不同，Python3有6个标准的数据类型：number, string, list（列表）, tuple（元组）,Set（集合）， dictionary（字典）

**可变数据（3 个）：**List（列表）、Dictionary（字典）、Set（集合）。

标识符第一个字符必须是字母表中字母或下划线 \_ 。

python中数字有四种类型：整数int、布尔型boolean、浮点数float和复数complex。

Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。

字符串的截取的语法格式如下：变量\[头下标:尾下标:步长\]

> 以下两行在事实上等价：
> 
>     sys.stdout.write('hello'+'\n')
>     print 'hello'

像if、while、def和class这样的复合语句，首行以关键字开始，以冒号( : )结束，该行之后的一行或多行代码构成代码组。

我们将首行及后面的代码组称为一个子句(clause)。

print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 **end=""**：

x="a"
    y="b"
    print( x, end=" " )
    print( y, end=" " )
    
    #a b

内置函数type()，isinstance() 可以用来查询所指的对象类型

在 python用 import 或者 from...import 来导入相应的模块。将某个模块中的全部函数导入，格式为： from somemodule import \*

数值的除法运算包括/和//：

>>> 2 / 4  # 除法，得到一个浮点数
    0.5
    >>> 2 // 4 # 除法，向下取整，得到一个整数
    0
    >>> 2**3  #幂，返回2的3次幂

Python 使用反斜杠(\\)转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串：

>>> print('Ru\noob')
    Ru
    oob
    >>> print(r'Ru\noob')
    Ru\noob
    >>>

Python 字符串不能被改变。向一个索引位置赋值，比如word\[0\] = 'm'会导致错误。

> 步长：
> 
> >>> str=\['a','b','c','d','e','f','g','1','a','b','c','d','e','f'\]
> 
> >>> str\[1:12:3\]  
> \['b', 'e', '1', 'c'\]

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。

构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

tup1 = ()    # 空元组
    tup2 = (20,) # 一个元素，需要在元素后添加逗号

集合（set）的基本功能是进行成员关系测试和删除重复元素。可以使用大括号 \{ \} 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 \{ \}，因为 \{ \} 是用来创建一个空字典。 字典是无序的对象集合，列表是有序的对象集合

字典格式：tinydict = \{'name': 'runoob','code':1, 'site': 'www.runoob.com'\}

python逻辑运算符：and ,  or , not

python成员运算符：in , not in   \#是否在另一个对象里面

python身份运算符：is , is not   \#是否引用自另一个对象

运算优先级：身份>成员>逻辑

> pip Fatal error in launcher: Unable to create process using解决方案：进入...AppData\\Local\\Programs\\Python\\Python37\\Scripts，删除pip.exe，然后$ `pip3 ``-``V,返回如下信息，可知pip3来自于python3版本。`
> 
> C:\\Users\\86183>pip3 -V  
> pip 19.0.3 from c:\\users\\2223\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\pip (python 3.7)

<table style="margin-left:0px;"> 
 <tbody style="margin-left:0px;"> 
  <tr style="margin-left:0px;"> 
   <td style="margin-left:0px;vertical-align:top;">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; %s</td> 
   <td style="margin-left:0px;vertical-align:top;">&nbsp;格式化字符串</td> 
  </tr> 
  <tr style="margin-left:0px;"> 
   <td style="margin-left:0px;vertical-align:top;">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; %d</td> 
   <td style="margin-left:0px;vertical-align:top;">&nbsp;格式化整数</td> 
  </tr> 
 </tbody> 
</table>

#可以使用 del 语句来删除列表的的元素，如下实例：
    list = ['Google', 'Runoob', 1997, 2000] 
    print ("原始列表 : ", list) 
    del list[2] 
    print ("删除第三个元素 : ", list) 
    
    #原始列表 :  ['Google', 'Runoob', 1997, 2000]
    #删除第三个元素 :  ['Google', 'Runoob', 2000]

关键字end可以用于将结果输出到同一行，或者在输出的末尾添加不同的字符

class Student(object):
        def __init__(self, name, score):
            self.name = name
            self.score = score
    
        def get_grade(self):
            if self.score >= 90:
                return 'A'
            elif self.score >= 60:
                return 'B'
            else:
                return 'C'
    
    lisa = Student('Lisa', 99)
    bart = Student('Bart', 59)
    print(lisa.name, lisa.get_grade())
    print(bart.name, bart.get_grade())
    
    # C:\doc>python test.py
    # Lisa A
    # Bart C

--------------------

一般来说，第三方库都会在Python官方的[pypi.python.org][]网站注册，要安装一个第三方库，必须先知道该库的名称，可以在官网或者pypi上搜索

## **2. rx模块（表示多个异步流）**Reactive Extensions for Python (RxPY) ##

Using Rx, you can represent multiple asynchronous data streams (that come from diverse sources, e.g., stock quote, Tweets, computer events, web service requests, etc.), and subscribe to the event stream using the Observer object. The Observable notifies the subscribed Observer instance whenever an event occurs. You can put various transformations in-between the source Observable and the consuming Observer as well.

rx模块学习文档路径：[https://rxpy.readthedocs.io/en/latest/rationale.html][https_rxpy.readthedocs.io_en_latest_rationale.html]

from rx import operators as ops : 从rx模块引出operators包，并用别名ops代替这个包的名字

Observable模式：观察者模式，作用是当一个对象的状态发生变化时，能够自动通知其它关联对象，自动刷新对象状态。定义对象间一种一对多的依赖关系

Observable是被观察者，也就是发出事件的事件（信号）源。一个观察者只有订阅了Observable对象，才能接收Observable发送的事件。**create**：通过指定的方法实现来自定义一个被观察的序列。

*  **订阅**：Observer 通过 Observable 提供的 **subscribe() 方法订阅** Observable。
 *  **发布**：Observable 通过回调 next 方法向 Observer 发布事件。

**Observer**是观察Observable的行为后，对其行为进行响应的实体。

如何生成Observable：自己把observable的动作序列编程实现

**可观察对象(Observable)**是一个惰性推送集合,即:要调用Observable并看到这些值,需要订阅Observable:  
`observable.subscribe({})`

**观察者（Observer）**是一组回调函数的集合,每个回调函数对应一种Observable发送的通知类型:next,error,complete

def pipe(*operators: Callable[[Any], Any]) -> Callable[[Any], Any]:
        """Compose multiple operators left to right.
        Composes zero or more operators into a functional composition. The
        operators are composed to left to right. A composition of zero
        operators gives back the source.
        Examples:
            >>> pipe()(source) == source
            >>> pipe(f)(source) == f(source)
            >>> pipe(f, g)(source) == g(f(source))
            >>> pipe(f, g, h)(source) == h(g(f(source)))
            ...
        Returns:
            The composed observable.
        """

<table> 
 <tbody> 
  <tr> 
   <td><a href="https://github.com/ReactiveX/RxPY/blob/master/docs/operators.rst#id42" rel="nofollow">:func:`filter &lt;rx.operators.filter&gt;`</a></td> 
   <td>emit only those items from an Observable that pass a predicate test</td> 
  </tr> 
  <tr> 
   <td><a href="https://github.com/ReactiveX/RxPY/blob/master/docs/operators.rst#id44" rel="nofollow">:func:`first &lt;rx.operators.first&gt;`</a></td> 
   <td>emit only the first item, or the first item that meets a condition, from an Observable</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td><a href="https://github.com/ReactiveX/RxPY/blob/master/docs/operators.rst#id30" rel="nofollow">:func:`map &lt;rx.operators.map&gt;`</a></td> 
   <td>transform the items emitted by an Observable by applying a function to each item</td> 
  </tr> 
 </tbody> 
</table>

在前端领域，观察者模式被广泛地使用。最常见的例子就是为 DOM 对象添加事件监听，具体示例如下：

>   
> <button id="btn">确认</button>
> 
>  
> 
> function clickHandler(event) \{
> 
>     console.log('用户已点击确认按钮!');
> 
> \}
> 
> document.getElementById("btn").addEventListener('click', clickHandler);
> 
>

上面代码中，我们通过 [addEventListener][] API 监听 button 对象上的点击事件，当用户点击按钮时，会自动执行我们的 `clickHandler` 函数。

## **3. SQLAlchemy ORM** ##

ROM： obeject relational mapper

SQLAlchemy是Python编程语言下的一款ORM框架，该框架建立在数据库API之上，使用关系对象映射进行数据库操作，简言之便是：**将对象转换成SQL，然后使用数据API执行SQL并获取执行结果。**

Column 字段, Integer, String, DateTime 日期, Enum, Table 表, MetaData

## **4. arrt.s (set attributes of target function or class)** ##

>>> import attr
    
    >>> @attr.s
    ... class SomeClass(object):
    ...     a_number = attr.ib(default=42)
    ...     list_of_numbers = attr.ib(factory=list)
    
    >>> sc = SomeClass(1, [1, 2, 3])
    >>> sc
    SomeClass(a_number=1, list_of_numbers=[1, 2, 3])
    
    >>> SomeClass()
    SomeClass(a_number=42, list_of_numbers=[])

# #

## 5. typing  ##

以下这个发送请求的函数，只看这个函数签名，我们就可以知道：

*  `request_data`可以是任何数据
 *  `header`的内容是一个可选的字符串字典
 *  `UserId`是可选的（默认为`None`），或者是符合编码`UserId`的任何数据

def send_request(request_data : Any,
                     headers: Optional[Dict[str, str]],
                     user_id: Optional[UserId] = None,
                     as_json: bool = True):
    ...

Whenever you have a keyword argument with default value `None`, you should use `Optional`\[...\]

To give a field a default value, you can assign to it in the class body:

class Employee(NamedTuple):
        name: str
        id: int = 3
    
    employee = Employee('Guido')
    assert employee.id == 3

## 6. marshmallow  ##

**marshmallow** is an ORM/ODM/framework-agnostic library for converting complex datatypes, such as objects, to and from native Python datatypes.

If *allow\_none* is true, the Python constant `None` will be translated into XML; the default behaviour is for `None` to raise a [`TypeError`][TypeError].

--------------------

创建表 使用mapper关联

from sqlalchemy import Table, MetaData, Column, Integer, String, ForeignKey
    from sqlalchemy.orm import mapper
    
    metadata = MetaData()
    
    user = Table('user', metadata,
                Column('id', Integer, primary_key=True),
                Column('name', String(50)),
                Column('fullname', String(50)),
                Column('password', String(12))
            )
    
    class User(object):
        def __init__(self, name, fullname, password):
            self.name = name
            self.fullname = fullname
            self.password = password
    
    mapper(User, user)  # 类User 和 user关联起来
    # the table metadata is created separately with the Table construct, 
    # then associated with the User class via the mapper() function
    # 如果数据库里有，就不会创建了。

SQLAlchemy的ORM是一个映射函数（Ｍapper），将Python中定义的**类**与数据库中的**表**建立关联，以及类的**实例（instance）**和表的**行（row）**建立关联**。**

查看一个类所对应的数据库表，使用\_\_tablename\_\_属性，例如 User.\_\_tablename\_\_

[pypi.python.org]: https://pypi.python.org/
[https_rxpy.readthedocs.io_en_latest_rationale.html]: https://rxpy.readthedocs.io/en/latest/rationale.html
[addEventListener]: https://developer.mozilla.org/zh-CN/docs/Web/API/EventTarget/addEventListener
[TypeError]: https://docs.python.org/3/library/exceptions.html#TypeError