30分钟学完Python基础语法

之前学了一些，现在全忘了。有时间所以又重新看了一下，并做以下记录

!> 有一门面向对象语言的基础，30分钟足够看一遍Python的基础了

## 基础语法

```python

# 缩进取代大括号

# 用换行取代分号，也可以使用分号，无所谓

# 输出
print();

# 输入
input();

# 注释
#单行注释
"""
多行注释1
"""
'''
多行注释2
'''

# 申明变量
直接写字母就行与数字、下划线组合即可，不是保留字即可。

# if

if true:
    print("true")
else:
    print("false")
    
# while
i = 0;
while i <= 1:
    #do something
    print("cicle")
    i+=1
    
# for 
languages = ["C", "C++", "Perl", "Python"] 
for x in languages:
    print (x)

# range
range(5)函数返回数字0~4的数组
range(5,9) 函数返回数字5~8的数组
range(0,10,3) 函数返回从数字0开始，递增3，直到最后一个数字小于10的数字数组
range(-10,-100,-30) 函数返回从-10开始，递增-30，直到最后一个数组大于-100的数字数组

# for + range 带索引遍历数组
a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']
for i in range(len(a))
    print(i,a[i])

# while 带索引遍历数组
i = 0;
length = len(a);
while i < a:
    print(i,a[i])
    i+=1
    
# for + enumerate 带索引遍历数组
for i,value in enumerate(a):
    print(i,value)

# 列表list
    # python list 和java list性质很类似，而不是数组，它的大小可变，但是Python列表的元素可以使把不同的数据类型，非常灵活
    
    # 创建新的list
    list1 = []
    list2 = ['bob',1,true] 
    # 增加元素
    list1.append(233)
    list1.insert(0,666) #插入到0位置，原来元素依次后移
    # 删除元素
    list2.pop() #删除末尾的元素
    list2.pop(0)
    # 修改元素 = 直接赋值
    # 访问指定位置元素
    list1[2]
    list1[-1] #表示最后一个元素
    # 切片（返回一个子列表）
    list2[0:2] #表示从索引0到1的元素
    list2[-2:-1] #表示倒数第二个元素
    list2[:3] #表示从0到2
    list2[1:] #表示从1到结尾

# 元组tuple
    # 与list列表区别是，tuple一旦初始化就不能修改。
    # list使用[]方括号，tuple使用()圆括号
    # 定义时候，只有一个元素，需要加一个,，避免歧义
    t = (1,)
    
    
# 字典dict
    # dict 和 java的map很类似。键值对，Python的dict很类似json的语法
    # 定义
    d = {'age':62, 'sex':'male'}
    # 访问值
    d['age']
    # 判断key是否存在
    d.get('name') #默认不存在返回none
    d.get('name',-1) #指定不存在时候返回-1
    'name' in d #不存在时候返回false
    # 删除key
    d.pop('sex')

# 集合set
    # 和java的set性质很类似，也是没有重复元素的集合。
    # 定义
    s = set([1,1,2,2,2,3,3,'sex'])
    # 添加元素
    s.add(4)
    s.add(4) # 重复元素添加操作不会生效
    # 删除元素
    s.remove('sex') #参数是set元素的值，而不是索引

# 函数
    # 定义函数
    def my_function(x):
        print(x);
    # 调用函数

```

## 高级特性

### 列表生成式和生成器

> 列表生成器

一种快速生成一个指定条件的列表的语法。

第一个例子：生成数字0~10的列表，可以使用range(0，11)函数，这个并不是列表生成器，只是引出这个概念。

第二个例子：生成`[1x1, 2x2, 3x3, ..., 10x10]` 这样乘积结果形成的列表，普通写法是一层循环：

```python
l = []
for x in range(1,11):
    l.append(x*x)
    
# 或者下面的循环

i = 1
while i < 11:
    l.append(i*i)
    i+=1
```

**现在使用列表生成式只需要一句代码：**
```python
[x*x for x in range(1,11)]
```

仔细看下上面代码，可以发现，就是把`l.append(x*x)`替换成`x*x`，并写在了for循环前面，而且整体用列表的符号`[]`包裹起来。

还可以更近一步，在for循环后面，写if语句，进一步筛选需要生成的元素：
```python
[x * x for x in range(1, 11) if x % 2 == 0]
# [4, 16, 36, 64, 100]
```

可以说，**列表生成式就是一种语法的简化，没什么新的功能。**

> 生成器

列表生成式是真实返回一个生成好的列表。

但是如果我们需要生成的列表特别大，被逼入100万的成员，但我们只需要打印前几个元素，后面那个多成员所占用的空间就浪费了：

```python
L = [x * x for x in range(1000000)]

print(L[0])
print(L[1])
```

上面写法就是非常浪费，要遭到我们谴责的。可以用下面写法：

```python
g = (x * x for x in range(1000000))

next(g)
next(g)
```

这种写法的返回的并不是一个列表，而是一个生成器`g`。**生成器就好比一个记住规则的工具**，一开始并不会生成任何元素，通过调用`next()`一个个的生成数组元素。

加入我想生成10个元素，我可以**迭代生成器**：
```python
g = (x * x for x in range(10))
for x in g:
    print(x)
```

**上面语法可以创建一个生成器，还可以通过`yield`关键字使一个函数成为生成器**：

```python
def odd():
    print('step 1')
    yield 1
    print('step 2')
    yield(3)
    print('step 3')
    yield(5)
    
g = odd()
next(g) # step 1
next(g) # step 2
next(g) # step 3
next(g) # StopIteration
```

同样可以使用for循环迭代这个生成器：
```python
for x in odd():
    print(x) # 依次返回1 3 5
```

一个函数成为生成器，使用`next`调用函数，遇到`yield`语句会**返回yield申明的值（常量/变量）**。再次调用`next`从上次返回的位置继续，直到遇到下一个`yield`语句。

### 迭代器

首先需要区分两个概念：**迭代器（Iterator）**和**可迭代对象（Iterable）**：
* 可迭代对象：可以使用for遍历，但是不能被next()调用，不断的返回下一个值。
* 迭代器：可以通过调用next(Iterator)，不断返回迭代器内部的值
* 通过`isinstance([变量] , Iterator)`或`isinstance([变量] , Iterable)` 判断变量是否是迭代器或是可迭代对象

* list、dict、str本身不是迭代器，可以通过`iter(Iterable)`返回迭代器对象
* 生成器本身就是迭代器对象。

```python
l = [1, 2, 3, 4, 5]
lIter = iter(l)

next(lIter) # 返回1
```

## 函数式编程

### 装饰器

设计模式里有一个设计模式就是**装饰器模式**，其实很容易理解，就是对函数进行扩展功能。但是又不想通过继承的方式。

用装饰器函数把原函数包裹起来，先执行装饰器的功能，再调用原函数。

所以装饰器的参数**首先**需要原函数func_name，而且装饰器内部还需要定义一个函数`wrapper`，参数是`*args, **kw`，表示任意参数，用来接收调用原函数的参数。

举个例子，定义一个log的装饰器，可以装饰在任何函数上（方式是在需要装饰的函数顶部写`@装饰器名称`），执行原函数，会输出该函数的调用信息：

```python
def log(func):
    def wrapper(*args, **kw):
        print("调用函数%s()"% func.__name__)
        return func(*args, **kw)
    return wrapper

@log    
def now(str):
    print("一个测试函数 + %s" % str)
```

当我们执行`now("哈哈")`，实际上执行的是`log(now("哈哈"))`，然后log函数内部调用`wrapper("哈哈")`，先打印测试时间，再执行了`now("哈哈")`

----

装饰器也可以传值，但是装饰器内部再多一个函数，用来接收需要装饰的函数名：

```python
def log(text):
    def decorator(func):
        def wrapper(*args, **kw):
            print("调用函数%s()时间为，测试文字 %s" % (func.__name__ ,text))
            return func(*args, **kw)
        return wrapper
    return decorator

@log("自定义文字")
def now(str2):
    print("一个测试函数 + %s" % str2)
```

这样调用`now("哈哈")`，实际上调用了`log("自定义文字")now("哈哈")`，然后执行`decorator(now("哈哈"))`，下面的调用过程和之前一样了。

----

被装饰器修饰的函数，会有一个问题：打印他的函数名称会有问题：

比如`now.__name__`，会输出`wrapper`，我们可以在wrapper的函数，上面写一句：

```python
import functools

def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kw):
        print("调用函数%s()"% func.__name__)
        return func(*args, **kw)
    return wrapper
```

这句注解自动会帮我们`wrapper.__name__ = func.__name__`赋值。

## 面向对象编程

我们用java的类概念来引入Python的面向对象的所有概念：

> 类

```python
class Student(object):

def __init__(self, name, score, sex):
        self.name = name
        self.score = score 
        self.__sex = sex;
    def print_score(self):
        print('%s: %s' % (self.name, self.score))
        
st = Student("hewro",120,"male")

print(st.name)
st.print_sore()

```

从上面代码，我们可以看出：
* 成员变量是在`__init__`中定义，而不是直接申明变量
* 构造函数名称是`__init__`，Python不支持函数重载，自然只能有一个构造函数了。而且第一个参数一定是`self`，生成实例的时候，不需要手动调用该参数。
* 在类的内部使用本身的变量，需要在函数第一个参数添加`self`，很麻烦
* 继承父类的写法不是`extend`，而是`(父类)`
* python 的私有变量定义也没有关键字，只是定义变量名称前面加两个下划线`__`，如`__sex`，就无法直接打印`std.__sex`

> 关于多态

我们知道多态是继承带来的一个很好特性。java、Python都有。但是Python本身变量不需要申明类型，所以多态实现，并不一定需要是定义父类的子类，而只要是该对象也拥有指定的方法即可（即鸭子类型）。

比如我们有一个Animal的父类，还有继承Animal的Dog和Cat 子类

```python
class Animal(object):
    def run(self):
        print('Animal is running...')

class Dog(Animal):
    def run(self):
        print('Dog is running...')
       
class Cat(Animal):
    def run(self):
        print('Cat is running...')
        
class Tortoise(Animal):
    def run(self):
        print('Tortoise is running slowly...')
  
# 这个函数的参数实际上是没有申明类型的   
def run_twice(animal):
    animal.run()
    animal.run() 
```

所以执行`run_twince()`参数可以是`dog`实例，也可以是`Tortoise`的实例，虽然`Tortoise`并不继承于`Animal`。

之前学了一些，现在全忘了。有时间所以又重新看了一下，并做以下记录

有一门面向对象语言的基础，30分钟足够看一遍Python的基础了

基础语法



# 缩进取代大括号

# 用换行取代分号，也可以使用分号，无所谓

# 输出
print();

# 输入
input();

# 注释
#单行注释
"""
多行注释1
"""
'''
多行注释2
'''

# 申明变量
直接写字母就行与数字、下划线组合即可，不是保留字即可。

# if

if true:
    print("true")
else:
    print("false")
    
# while
i = 0;
while i <= 1:
    #do something
    print("cicle")
    i+=1
    
# for 
languages = ["C", "C++", "Perl", "Python"] 
for x in languages:
    print (x)

# range
range(5)函数返回数字0~4的数组
range(5,9) 函数返回数字5~8的数组
range(0,10,3) 函数返回从数字0开始，递增3，直到最后一个数字小于10的数字数组
range(-10,-100,-30) 函数返回从-10开始，递增-30，直到最后一个数组大于-100的数字数组

# for + range 带索引遍历数组
a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']
for i in range(len(a))
    print(i,a[i])

# while 带索引遍历数组
i = 0;
length = len(a);
while i < a:
    print(i,a[i])
    i+=1
    
# for + enumerate 带索引遍历数组
for i,value in enumerate(a):
    print(i,value)

# 列表list
    # python list 和java list性质很类似，而不是数组，它的大小可变，但是Python列表的元素可以使把不同的数据类型，非常灵活
    
    # 创建新的list
    list1 = []
    list2 = ['bob',1,true] 
    # 增加元素
    list1.append(233)
    list1.insert(0,666) #插入到0位置，原来元素依次后移
    # 删除元素
    list2.pop() #删除末尾的元素
    list2.pop(0)
    # 修改元素 = 直接赋值
    # 访问指定位置元素
    list1[2]
    list1[-1] #表示最后一个元素
    # 切片（返回一个子列表）
    list2[0:2] #表示从索引0到1的元素
    list2[-2:-1] #表示倒数第二个元素
    list2[:3] #表示从0到2
    list2[1:] #表示从1到结尾

    
    
# 元组tuple
    # 与list列表区别是，tuple一旦初始化就不能修改。
    # list使用[]方括号，tuple使用()圆括号
    # 定义时候，只有一个元素，需要加一个,，避免歧义
    t = (1,)
    
    
# 字典dict
    # dict 和 java的map很类似。键值对，Python的dict很类似json的语法
    # 定义
    d = {'age':62, 'sex':'male'}
    # 访问值
    d['age']
    # 判断key是否存在
    d.get('name') #默认不存在返回none
    d.get('name',-1) #指定不存在时候返回-1
    'name' in d #不存在时候返回false
    # 删除key
    d.pop('sex')

# 集合set
    # 和java的set性质很类似，也是没有重复元素的集合。
    # 定义
    s = set([1,1,2,2,2,3,3,'sex'])
    # 添加元素
    s.add(4)
    s.add(4) # 重复元素添加操作不会生效
    # 删除元素
    s.remove('sex') #参数是set元素的值，而不是索引

# 函数
    # 定义函数
    def my_function(x):
        print(x);
    # 调用函数

高级特性

列表生成式和生成器

列表生成器

一种快速生成一个指定条件的列表的语法。

第一个例子：生成数字0~10的列表，可以使用range(0，11)函数，这个并不是列表生成器，只是引出这个概念。

第二个例子：生成[1x1, 2x2, 3x3, ..., 10x10] 这样乘积结果形成的列表，普通写法是一层循环：


l = []
for x in range(1,11):
    l.append(x*x)
    
# 或者下面的循环

i = 1
while i < 11:
    l.append(i*i)
    i+=1

现在使用列表生成式只需要一句代码：


[x*x for x in range(1,11)]

仔细看下上面代码，可以发现，就是把l.append(x*x)替换成x*x，并写在了for循环前面，而且整体用列表的符号[]包裹起来。

还可以更近一步，在for循环后面，写if语句，进一步筛选需要生成的元素：


[x * x for x in range(1, 11) if x % 2 == 0]
# [4, 16, 36, 64, 100]

可以说，列表生成式就是一种语法的简化，没什么新的功能。

生成器

列表生成式是真实返回一个生成好的列表。

但是如果我们需要生成的列表特别大，被逼入100万的成员，但我们只需要打印前几个元素，后面那个多成员所占用的空间就浪费了：


L = [x * x for x in range(1000000)]

print(L[0])
print(L[1])

上面写法就是非常浪费，要遭到我们谴责的。可以用下面写法：


g = (x * x for x in range(1000000))

next(g)
next(g)

这种写法的返回的并不是一个列表，而是一个生成器g。生成器就好比一个记住规则的工具，一开始并不会生成任何元素，通过调用next()一个个的生成数组元素。

加入我想生成10个元素，我可以迭代生成器：


g = (x * x for x in range(10))
for x in g:
    print(x)

上面语法可以创建一个生成器，还可以通过yield关键字使一个函数成为生成器：


def odd():
    print('step 1')
    yield 1
    print('step 2')
    yield(3)
    print('step 3')
    yield(5)
    
g = odd()
next(g) # step 1
next(g) # step 2
next(g) # step 3
next(g) # StopIteration

同样可以使用for循环迭代这个生成器：


for x in odd():
    print(x) # 依次返回1 3 5

一个函数成为生成器，使用next调用函数，遇到yield语句会返回yield申明的值（常量/变量）。再次调用next从上次返回的位置继续，直到遇到下一个yield语句。

迭代器

首先需要区分两个概念：迭代器（Iterator）和可迭代对象（Iterable）：

可迭代对象：可以使用for遍历，但是不能被next()调用，不断的返回下一个值。
迭代器：可以通过调用next(Iterator)，不断返回迭代器内部的值
通过isinstance([变量] , Iterator)或isinstance([变量] , Iterable) 判断变量是否是迭代器或是可迭代对象
list、dict、str本身不是迭代器，可以通过iter(Iterable)返回迭代器对象
生成器本身就是迭代器对象。


l = [1, 2, 3, 4, 5]
lIter = iter(l)

next(lIter) # 返回1

函数式编程

装饰器

设计模式里有一个设计模式就是装饰器模式，其实很容易理解，就是对函数进行扩展功能。但是又不想通过继承的方式。

用装饰器函数把原函数包裹起来，先执行装饰器的功能，再调用原函数。

所以装饰器的参数首先需要原函数func_name，而且装饰器内部还需要定义一个函数wrapper，参数是*args, **kw，表示任意参数，用来接收调用原函数的参数。

举个例子，定义一个log的装饰器，可以装饰在任何函数上（方式是在需要装饰的函数顶部写@装饰器名称），执行原函数，会输出该函数的调用信息：


def log(func):
    def wrapper(*args, **kw):
        print("调用函数%s()"% func.__name__)
        return func(*args, **kw)
    return wrapper

@log    
def now(str):
    print("一个测试函数 + %s" % str)

当我们执行now("哈哈")，实际上执行的是log(now("哈哈"))，然后log函数内部调用wrapper("哈哈")，先打印测试时间，再执行了now("哈哈")

装饰器也可以传值，但是装饰器内部再多一个函数，用来接收需要装饰的函数名：


def log(text):
    def decorator(func):
        def wrapper(*args, **kw):
            print("调用函数%s()时间为，测试文字 %s" % (func.__name__ ,text))
            return func(*args, **kw)
        return wrapper
    return decorator


@log("自定义文字")
def now(str2):
    print("一个测试函数 + %s" % str2)

这样调用now("哈哈")，实际上调用了log("自定义文字")now("哈哈")，然后执行decorator(now("哈哈"))，下面的调用过程和之前一样了。

被装饰器修饰的函数，会有一个问题：打印他的函数名称会有问题：

比如now.__name__，会输出wrapper，我们可以在wrapper的函数，上面写一句：


import functools

def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kw):
        print("调用函数%s()"% func.__name__)
        return func(*args, **kw)
    return wrapper

这句注解自动会帮我们wrapper.__name__ = func.__name__赋值。

面向对象编程

我们用java的类概念来引入Python的面向对象的所有概念：

类


class Student(object):

    def __init__(self, name, score, sex):
        self.name = name
        self.score = score 
        self.__sex = sex;
    def print_score(self):
        print('%s: %s' % (self.name, self.score))
        
st = Student("hewro",120,"male")

print(st.name)
st.print_sore()

从上面代码，我们可以看出：

成员变量是在__init__中定义，而不是直接申明变量
构造函数名称是__init__，Python不支持函数重载，自然只能有一个构造函数了。而且第一个参数一定是self，生成实例的时候，不需要手动调用该参数。
在类的内部使用本身的变量，需要在函数第一个参数添加self，很麻烦
继承父类的写法不是extend，而是(父类)
python 的私有变量定义也没有关键字，只是定义变量名称前面加两个下划线__，如__sex，就无法直接打印std.__sex

关于多态

比如我们有一个Animal的父类，还有继承Animal的Dog和Cat 子类


class Animal(object):
    def run(self):
        print('Animal is running...')

        
class Dog(Animal):
    def run(self):
        print('Dog is running...')
       
class Cat(Animal):
    def run(self):
        print('Cat is running...')
        
class Tortoise(Animal):
    def run(self):
        print('Tortoise is running slowly...')
  
# 这个函数的参数实际上是没有申明类型的   
def run_twice(animal):
    animal.run()
    animal.run()