零基础掌握Python入门到实战

python基础篇

注：适合萌新学习python并且里面的内容会持续的更新！
说明：并非是最优代码，但程序完全正确！因为此时作者也处在学习阶段！

内置对象类型

内置对象类型：整数、浮点数、字符串、列表、元组、字典、集合。

变量与对象：a=3 a就是变量 ，3就是对象。
一个对象可以与多个变量建立联系。
变量没有类型，对象有类型，并且我们不能单独定义变量。

命名变量：小写字母命名 。例：my_book

实现a与b值的对调：a,b = b,a

运用id可以得到对象的内存地址：
例子：>>>id(3) 与>>>id(3.0)
四则运算：

两个数相除的表示方法：a/b
对两个数求余的表示方法：a%b
对两个数求商的表示方法：a//b
对于求商求余数还有可以用divmod(c,d)方法
例：

>>>divmod(5,2)
得到的结果：(2,1)    ——此处2就表示5除以2的商，1就表示5除以2的余数

关于for循环

例题：创建一个数据集，包含1到10的随机整数，共计100个数，并统计每个数出现的次数。

// 方法1
import random //引入random模块
 lst = []    //定义一个空列表
d = dict() //定义一个空字典
for i in range(100): //循环100次
    n = random.randint(1,10) //每循环一次随机拿到1——10以内的任意一个数
    if n in d :
        d[n] + = 1  //如果这个数作为键在字典里，值加1
    else:
        d[n] = 1 //否则值等于1
print(d)

//方法2
import random 
lst = []
for i in range(100):
    n = random.randint(1,10)
    lst.append(n)
d={}
for n in lst:
    if n in d:
         d[n] + = 1
    else:
         d[n] = 1

常用于for循环的函数

1. range()
2. zip()
3. enumerate( )
4. 列表解析

例题：求100以内能被三整除的数

lst = []
for i in range(100):
    if i % 3 == 0;
    lst.append(i)
print(lst)

用range方法实现两个列表的对应值相加

c = [1，2，3，4，5]
d = [6，7，8，9，1]
r = []
for i in range(len(c))://把列表中的每一个元素所对应的索引拿出来了
     r.append(c[i] + d[i])

用zip方法实现两个列表的对应值相加

 c = [1，2，3，4，5]
 d = [6，7，8，9，1]
r = []
for x,y in zip(c,d):
     r.append(x+y)
print(r)

enumerate()方法：枚举 返回索引值

>>>s = ['one','two','three']
>>>list(enumerate(s))
[(0, 'one'), (1, 'two'), (2, 'three')]//得到索引和值

列表解析
用途：定义一个空列表，向空列表中追加一些符合条件的元素时使用列表解析

用列表解析法求100以内能被三整除的数

>>>[i for i in range(100) if i % 3 == 0]

结果是：[0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 81, 84, 87, 90, 93, 96, 99]

>>>range(0, 100, 3)
>>>list(range(0, 100, 3))

例题 ：字符串s=‘life is short You need python’。统计这个字符串中每个字母出现的次数。

s = 'life is short You need python'
lst = []   //定义一个空列表
d = dict() //定义一个空字典
for i in s: //循环获取s中的每个字母
   if i.isalpha(): //判断循环得到的是否是一个字符，是字符则执行后面的代码块 否则返回false
       if i in d : 
           d[i] + = 1  //'键'放在字典里并且'值'加1
       else:
           d[i] = 1 
print(d)

关于while循环

格式： while[condition]：
statements

a = 0
while a < 3:
    s = input("input your lang:")
    if s == 'python':
        print("your lang is {0}".format(s))
        break  //当代码执行到这里时，会跳出当前循环（此处跳出while 执行print("the end a:",a)）
    else:
        a+=1
        print("a=",a)
print("the end a:",a)

a=11
while a > 0:
    a-=1;
    if a % 2 == 0:
        continue
        print(a)
    else:
        print(a)

用while循环做一个小游戏：
制作一个满足如下功能的猜数游戏：
1.计算机随机生成一个100以内的正整数；
2.用户通过键盘输入数字，猜测计算机所生成的随机数。
注意：对用户的输入次数不做限制。

import random
computer_name = random.randint(1,100) #表示从1——100以内随机取一个数
while True:   #表示一直循环，直到遇到结束标志
    user_name = input("请输入你要猜测的数字:")  #获得的是字符串类型
    if not user_name.isdigit():
        print("请输入1——100以内的整数" )
    elif int(user_name) <0 or int(user_name) >= 100:
        print("请输入1——100以内的整数")
    else:
        if int(user_name)==computer_name:
            print("you are win")
            break
        elif int(user_name)<computer_name:
            print("you are smaller")
        else :
            print("you are bigger")

      

函数和装饰器

函数的定义：def wrr(x,y,z)：【def；函数名称；参数列表】
（此处缩进四个空格）do something return object【函数内语句块】
函数结束 返回值 return

例子：

def add(x,y):
    r = x +y 
    return r
c = add(2,3)
print("c的值为：",c)
 结果为：c=5  

参数收集

一个 ‘*’ 的作用

最后的结果是元组类型

def fun(x,*args):
    print("x=",x)
    print("args=",args)
fun(1,2,3,4,5,6)

结果为：
x= 1
args= (2, 3, 4, 5, 6)

二个 ‘*’ 的作用

最后的结果是字典类型

def bar(x,**kwargs):
    print("x=",x)
    print("args=",kwargs)
bar(1,a=2,b=3,c=4)

结果为：
x= 1
args= {'a': 2, 'b': 3, 'c': 4}

参数收集的扩展：

def foo(*args,**kwargs):
    print("x=",args)
    print("args=",kwargs)
foo(1,2,3,a=9,b=7,c=6) 

结果为：
x= (1, 2, 3)
args= {'a': 9, 'b': 7, 'c': 6}

函数的嵌套

例子：

def book(name):
    return "the name of my book is{0}".format(name)
def p_deco(func):   #函数的嵌套
        def wrapper(name):
            return "<p>{0}<p>".format(func(name))
        return wrapper
wrr = p_deco(book)
py_book = wrr(" python 学习")
print(py_book)

结果是：
<p>the name of my book is python 学习<p>

例题:用函数嵌套的方法写一个关于物理公式G=mg的例子

def w(m , g):
    return m * g
def func(g):
    def mm(m):
        return m * g 
    return mm
c = func(10)
G = c(100)
print(G)

装饰器 （@+方法名）

装饰器是一种函数，装饰器本质就是函数的调用。

1.普通装饰器：

#coding:utf-8
def log(func):
    def wrapper(*args,**kwargs):
        print("this is a log")
        return func(*args,**kwargs)
    return wrapper   #返回它的地址

@log #装饰器
def func():
    print("i am a function")
func()

#等价于
log(func)()
#注：log(func)==》wrapper ; log(func)()==》wrapper()

2.带参数的装饰器

#coding:utf-8
def log(leval):#带参数的装饰器
    def decorator(func):
        def wrapper(*args,**kwargs):
            if leval == 'info':
                print("i am info level log")
            elif leval =='error':
                print("i am error level log")
            res=func(*args,**kwargs)
            return res
        return wrapper
    return decorator

@log(leval="error")
def func():
    print("i am a function ")
func()

类装饰器

#coding:utf-8
class Log(object):
    def __init__(self,func):
        self.func = func
    def __call__(self):
        print("i am a log")
        self.func() #调用func方法

@Log    #调用类装饰器的时候，实质上是调用了__call__方法
def func():
    print("i am a function")

func()

def p_deco(func):  #函数的嵌套
        def wrapper(name):
            return "<p>{0}<p>".format(func(name))
        return wrapper
def div_deco(func):  #用到了函数的嵌套
    def wrapper(name):
        return "<div>{0}<div>".format(func(name))
    return wrapper

@div_deco  #装饰器
@p_deco    #装饰器
def book(name):  #p_deco(func)装饰了book(name)函数
    return "the name of my book is{0}".format(name)
  #此程序装饰器的功能就是下面注释的两行  
    #whr = p_deco(book)
    #py_book =whr(" python 学习")
py_book=book(" python 学习")
print(py_book)

结果是：
<div><p>the name of my book is python 学习<p><div>

练习

编写一个测试函数执行时间的装饰器函数

注：与时间相关的要引入import time 模块

import time
def timing_func(func):#编写装饰器函数
    def wrapper():
        start = time.time()#记录开始时间
        func()   #执行这个函数
        stop = time.time()#记录结束时间
        return stop-start
    return wrapper
@timing_func  #装饰器
def test_list_append():
    lst=[]
    for i in range(1000000):  #运用for循环取值
        lst.append(i)#把每个数追加到列表中
@timing_func  #装饰器
def test_list_compre():
    [i for i in range(1000000)] #运用列表解析 取值
a=test_list_append()
b=test_list_compre()   
print("运行test_list_append方法所运行的时间",a)
print("运行test_list_compre方法所运行的时间",b)    

执行结果如下：

运行test_list_append方法所运行的时间 0.12466740608215332
运行test_list_compre方法所运行的时间 0.08578181266784668

关于作用域的问题

>>>a=1    #是一个全局变量
>>> def foo()：
        global  a    #声明下面用到的a是一个全局变量
        a = a+1
        print（a）
>>> a=foo()
2

>>>def foo():
       a=1
       def bar():
           nonlocal  a  #代表这个a不是bar函数里面的a
           a=a+1   #第一个a是局部变量a
           print(a)
       bar()
>>> foo()  
2          

特殊函数（常用的三个）

 1. lambda
 2. 　map
 3. filter

1. lambda函数

格式：
lambda +若干个参数：表达式 （参数之间用逗号隔开）

>>>def add(x):
    x+=3
    return x
>>>add(2)
5

用lambda函数实现同样的功能：

>>>r=lambda x: x+3
>>>r(2)
5

2. map函数：
格式：
map(函数，迭代器）
功能：把迭代器中的每一个元素依次取出来后传给函数对象，然后完成函数的计算
要注意的是：返回的是map object类型 若要看返回值的话需要转化一下

>>>r = map(lambda x: x+3,range(10))
>>>list(r)
[3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

3. filter
filter过滤器
格式：
filter(函数，迭代器)

假如用filter函数实现从-5到5之间取出大于0的数

>>>n=range(-5,5)
>>>r=filter(lambda x: x>0,n)
>>>list(r)
[1, 2, 3, 4]

异常处理

主要用到try …except…

while True:
    try:
        a=float(input("please enter first number:"))
        b=float(input("please enter second number:"))
        r=a/b
        print("{0}/{1}={2}".format(a,b,r))
        break
    except ZeroDivisionError:      #异常类型
        print ("Please enter the second number again")
    except ValueError:            #异常类型
        print ("plase enter the number")
    except:
        break
    #也可以组合异常
    # except (ZeroDivisionError,ValueError):   #表示遇到这两个异常中的一个就会执行下面的代码
   #      print ("Please enter the second number again")

网络爬虫
SDK：软件开发工具包。一般都是一些软件工程师为特定的软件包、软件框架、硬件平台、操作系统等建立应用软件时的开发工具的集合。
API：应用程序接口。是一些预先定义的函数，或指软件系统不同组成部分衔接的约定。目的是提供应用程序与开发人员基于某软件或硬件得意访问一组例程的能力，而有无需访问原码，或理解内部工作机制的细节。

安装lxml

lxml作用：主要用于解析要获取到的html代码