Python基础（二）

十、生成器

1、创建生成器

方法一：
gen = (x for x in range(5))
print(type(gen))			#<class 'generator'>

调用生成器时需要使用next(generator)方法，每调用一次获取一次生成器的下一个返回值，知道计算到最后一个元素。如果生成器中的元素被调用完，再调用一次则会抛出StopIteration异常。

gen = (x for x in range(5))
print(next(gen))			#0
print(next(gen))			#1
print(next(gen))			#2

方法2：
通过在函数中使用yield创建生成器

def sequence(numb):
    for i in range(numb):
        i = i * 3
        yield i
g = sequence(3)
print(next(g))			#0
print(next(g))			#3

2、send方法

send方法用于传递参数，实现与生成器的交互。send()可以接收一个参数，并将参数传递给接收yield语句返回值的变量。

def sequence(numb):
    for i in range(numb):
        i = i * 3
        temp = yield i
        print(temp)
g = sequence(5)
print(next(g))
print(next(g))
print(g.send("send发送参数"))
print(g.send(None))

close()：该方法用于停止生成器；
throw()：该方法用于在生成器内部（yield语句内）引发一个异常

十一、迭代器

1、可迭代对象

序列：字符串、列表、元组等
非序列：字典、文件
自定义类：用户自定义的类实现了__iter__()或__getitem__()方法的对象

2、创建迭代器

使用iter()创建迭代器：

语法：
iter(iterable)，使用next(iterator)从迭代器iterator中获取一个记录，如果无法获取下一条记录，那么则触发stoptrerator异常

list = [1,2,3,4,5]
it = iter(list)
print(type(it))			#<class 'list_iterator'>
print(next(it))			#1
print(next(it))			#2

十二、函数

1、函数定义

语法：
def 【函数名（参数）】:
	'''【函数说明】'''
	【代码块】
	return 【返回值】

在函数定义中，以return【返回值】结束函数。如果函数中没有return【返回值】，则相当于return None。
函数定义完成，调用函数。直接使用【函数名（参数）】的方法调用，如果没有参数，则参数不用填写。

2、参数

1）、位置参数

位置参数在使用时所有参数都遵循位置一一对应的原则。

def say_hello(name):
    return (name + '您好！')
print(say_hello("AlySam"))			#AlySam您好！

2）、缺省参数

缺省参数是给参数设置缺省值，当调用函数时，该参数可以选择不传递值而使用缺省值，也可以传递值从而不使用缺省值。

语法：
【参数名】=【缺省值】

def say_hello(name,say = 'Hello'):
    return (name + say)
print(say_hello("AlySam"))			#AlySamHello
def say_hello(name,say = 'Hello'):
    return (name + '你好')
print(say_hello("AlySam"))			#AlySam你好

3）、可变参数

如果不知道传入的参数个数，则定义参数时需要将参数设置为可变参数，可变参数需要以元组形式传递。

语法：
*【参数名】

def get_sum(*number):
    sum = 0
    for i in number:
        sum += i
    return sum
print(get_sum(1,3,5,7,9))			#25
print(get_sum(1))					#1

4）、关键字参数

关键字参数以字典形式传递。

语法：
**kw

def tree_info(id,date,**kw):
    return ('id:',id,'date:',date,'ps:',kw)
print(tree_info(1,'2018/06/03'))					#('id:', 1, 'date:', '2018/06/03', 'ps:', {})
print(tree_info(1,'2018/06/03',local="beijing"))	#('id:', 1, 'date:', '2018/06/03', 'ps:', {'local': 'beijing'})

5）、参数组合

在定义函数时可以传递位置参数、缺省参数、可变参数、关键字参数中的一种或者多种参数的组合。

def tree_info(id,date,local = "beijing",*args,**kw):
    return ('id:',id,'date:',date,'local:',local,'args:',args,'ps:',kw)
print(tree_info(1,'2018/06/03'))
print(tree_info(1,'2018/06/03','nanjing'))
print(tree_info(1,'2018/06/03','nanjing','highway','path'))
print(tree_info(1,'2018/06/03','nanjing','highway',kind='pine'))

3、匿名函数

语法：
lambda 参数1，参数2，...，参数n：表达式
1、lambda 只能包含一条语句；
2、参数可选，可以为0；
3、不需要return，直接返回表达式；
4、需要被调用才能执行；
5、表达的生成函数一般都比较简单；

lam = lambda x,y:x*y
print(lam(2,3))

4、参数类型

语法：
【参数】：【数据类型】

5、返回值类型

语法：
def 【函数名（参数）】->【数据类型】

十三、类和对象

类是用来描述具有相同属性和方法的对象的集合，对象是类的实例。

1、创建类

使用class创建类，class后为类名并且以冒号结尾。

语法：
class 【类名】（【父类名】）：
	'''【类说明】'''
	【代码块】
【父类名】为所要继承的类，【类说明】一般都是对此类进行说明。

class Animal:
    """这是一个动物类"""
    food = "粮食"
    def __init__(self,name):
        self.name = name
    def eat(self):
        print("%s正在吃%s" % (self.name,Animal.food))

2、创建实例对象

使用类名就可以创建一个类的实例，并且可以通过__init__方法接收参数。

cat = Animal("猫咪")

实例化之后就可以通过（.）来访问对象的属性或者方法。

cat = Animal("猫咪")
cat.eat()
print(cat.food)

实例化之后也可对其属性进行修改。

语法：
添加属性：【实例对象】.【新属性名】=【属性值】
修改属性值：【实例对象】.【属性名】=【新值】
删除属性：del 【实例对象】.【属性名】

3、类的私有化

定义私有变量，在名称前加两个下划线（__）。

class Persion(object):
    def __init__(self):
        self.__name = "persion"
    def __eat(self):
        print("Eating!")
xiaoming = Persion()
xiaoming.__name

Traceback (most recent call last):
  File "E:\Users\PycharmProjects\TimeSheet\AAAA.py", line 288, in <module>
    xiaoming.__name
AttributeError: 'Persion' object has no attribute '__name'

4、类继承

语法：
class 【派生类名】（【继承基类名】）：
		【代码块】
【派生类】会继承【继承基类】的所有属性和方法

class Persion(object):
    def __init__(self):
        pass
    def eat(self):
        print("Eating!")
class Student(Persion):
    pass
xiaoming = Student()
xiaoming.eat()

5、类的重写

类的重写是指在父类中已经有了这个属性或者方法，子类想修改其内容，对本身子类的属性或者方法进行重写。在子类中使用与父类中相同的变量或者方法名，就可以重新定义父类中的属性和方法。

class Persion(object):
    def __init__(self):
        self.name = "persion"
    def eat(self):
        print("Eating!")
class Student(Persion):
    def __init__(self):
        #super用于继承父类中的属性
        super(Student,self).__init__()
        print(self.name)
        #name属性重写
        self.name = "student"
        print(self.name)
    #eat方法重写
    def eat(self):
        print("AlySam")
xiaoming = Student()
xiaoming.eat()

十四、模块

1、模块的分类

标准模块：Python基本库，使用时直接用import导入；
第三方模块：需要使用pip安装，再用import导入；
用户自定义模块：用户自己定义的py文件；

2、模块的导入

语法1：import【模块名】as【别名】
语法2：from【模块名】import【指定部分】
语法3：from【模块名】import *

import sys as ay				#直接导入sys模块
import os,time					#导入os、time模块
from selenium import webdriver	#从selenium导入webdriver模块
from sys import *				#模糊导入

十五、作用域

作用域是指变量的有效范围，Python的作用域是静态的，变量被赋值、创建的位置决定了其被访问的范围，即变量作用域由其所在的位置决定。

L（Local）：局部作用域
E（Enclosing）：嵌套的父级函数局部作用域；
G（Global）：全局作用域
B（Built-in）：内建作用域

十六、异常机制

异常机制可以使程序在运行过程中顺利执行，即使遇到错误也能很好地处理，提高了程序的健壮性和可用性。

1、try-except

基本语法：
try：
	【代码块】
except Exception as ex：
	【处理异常代码块】	

def func(a,b):
    try:
        return a / b
    except ZeroDivisionError as e:
        return e
print(func(4,2))			#2.0
print(func(2,0))			#division by zero

2、else

结合else使用，else子句会再try子句没有发生任何异常的时候执行，一旦try子句出现异常，else子句将不会执行，else使用需要放在except子句之后。

def func(a,b):
    try:
        print(a / b)
    except:
        print("Error")
    else:
        print("try...except")
func(4,2)
func(4,0)

2.0
try...except
Error

3、finally

finally子句是无论try子句有没有异常都会执行。

def func(a,b):
    try:
        print(a / b)
    except:
        print("Error")
    finally:
        print("try...except")
func(4,2)
func(4,0)

2.0
try...except
Error
try...except

十七、init.py文件

十八、Python实用技巧

1、打印分隔符

使用print中的参数sep进行换行，实现分割线的快速打印。

print('selenium','web','autotest',sep='\n----------\n')
selenium
----------
web
----------
autotest

2、変量変换

a = 1
b = 2
a,b = b,a
print(a,b)

3、列表反转

list = [1,'A',3.25]
reversed_list = list[::-1]
print(reversed_list)

4、链式使用

a = 4
print(4 == a < 6)			#True

5、使用三元操作符进行条件赋值

【表达式为真的返回值】if 【表达式】else【表达式为假的返回值】

def func(y):
    x = -1
    return x if (y > 99) else 1

6、同时迭代两个列表

使用zip函数同时迭代两个列表。

list1 = [1,2,3,4]
list2 = ['A','B','C','D']
for i,j in zip(list1,list2):
    print(str(i) + ':' + j)
1:A
2:B
3:C
4:D

7、从两个相关的序列构建一个字典

list1 = [1,2,3,4]
list2 = ['A','B','C','D']
dict = dict(zip(list1,list2))
print(dict)			#{1: 'A', 2: 'B', 3: 'C', 4: 'D'}

8、初始化列表值

List = [2] * 5
print(List)			#[2, 2, 2, 2, 2]

9、从列表中删除重复项

使用set将列表去重，然后转换成列表。

L = ['A','B','C','D','D','E']
new_L = list(set(L))
print(new_L)			#['A', 'B', 'D', 'E', 'C']

10、enumerate函数

将一个可遍历的数据对象（如列表、元组或字符串）组合为一个索引序列，同时列出索引和值。

enumerate（sequence，[start=0]），start参数为索引起始位置。

seq = ['A', 'B', 'D', 'E', 'C']
for index,item in enumerate(seq):
    print(index,item)			
0 A
1 B
2 D
3 E
4 C
print(list(enumerate(seq,start=1)))			#[(1, 'A'), (2, 'B'), (3, 'D'), (4, 'E'), (5, 'C')]

11、map函数

接收一个函数function和一个列表，并通过把函数function依次作用在列表的每个元素上，得到一个新的列表并返回。

A = list(map(lambda x,y:x*y,[1,3,7],[5,2,6]))
print(A)			#[5, 6, 42]

12、any和all

any（）函数用于判断一个可迭代函数的元素是否全为False。如果是，返回False；否则返回True。False元素中有0、空字符串（‘’）、空列表（[]）、False。

print(any([0,1]))
print(any(['',0,False]))

all（）函数

print(all([3,1]))
print(all(['',0,False]))

13、strip去除空格

str.strip()：去除字符串两边的空格
str.lstrip()：去除字符串左边的空格
str.rstrip()：去除字符串右边的空格

str = "   Hello World "
print(str.strip())			#Hello World
print(str.lstrip())			#Hello World
print(str.rstrip())			#   Hello World

14、获取当前文件的绝对路径

import os
realpath = os.path.split(os.path.realpath(__file__))[0]