浅析Python模块的引入和调用

大家好,我是IT共享者,人称皮皮。这篇文章我们来浅析Python模块的引入和调用。

一、前言

Python中的模块,有过C语言编程经验的朋友都知道在C语言中如果要引用sqrt函数,必须用语句#include引入math.h这个头文件,否则是无法正常进行调用的。

那么在Python中,如果要引用一些其他的函数,该怎么处理呢?

在Python中有一个概念叫做模块(module),这个和C语言中的头文件以及Java中的包很类似,比如在Python中要调用sqrt函数,必须用import关键字引入math这个模块,下面就来了解一下Python中的模块。

说的通俗点 :模块就好比是工具包,要想使用这个工具包中的工具(就好比函数),就需要导入这个模块。

二、模块引入

1. import

在Python中用关键字import来引入某个模块,比如要引用模块math,就可以在文件最开始的地方用import math来引入。

形如 :

 import module1,mudule2...

当解释器遇到import语句,如果模块在当前的搜索路径就会被导入。

在调用math模块中的函数时,必须这样引用:

  模块名.函数名

为什么必须加上模块名调用呢?

因为可能存在这样一种情况:在多个模块中含有相同名称的函数,此时如果只是通过函数名来调用,解释器无法知道到底要调用哪个函数。所以如果像上述这样引入模块的时候,调用函数必须加上模块名。

   import math


    #这样会报错
    print sqrt(2)


    #这样才能正确输出结果
    print math.sqrt(2)

有时候我们只需要用到模块中的某个函数,只需要引入该函数即可,此时可以用下面方法实现:

   from 模块名 import 函数名1,函数名2....

不仅可以引入函数,还可以引入一些全局变量、类等。

注意:

  1. 这种方式引入的时候,调用函数时只能给出函数名,不能给出模块名,但是当两个模块中含有相同名称函数的时候,后面一次引入会覆盖前一次引入。也就是说假如模块A中有函数function( ),在模块B中也有函数function( ),如果引入A中的function在先、B中的function在后,那么当调用function函数的时候,是去执行模块B中的function函数。

2. 如果想一次性引入math中所有的东西,还可以通过from math import 来实现

2. from…import

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中。

语法如下:

   from modname import name1[, name2[, ... nameN]]

例如,要导入模块fib的fibonacci函数,使用如下语句:

   from fib import fibonacci

注意:

  • 不会把整个fib模块导入到当前的命名空间中,它只会将fib里的fibonacci单个引入。

3. from … import *

把一个模块的所有内容全都导入到当前的命名空间也是可行的,只需使用如下声明:

   from modname import *

注意:

  • 这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。

4 . 定位模块

当你导入一个模块,Python解析器对模块位置的搜索顺序是:

  1. 当前目录
  2. 如果不在当前目录,Python则搜索在shell变量PYTHONPATH下的每个目录。
  3. 如果都找不到,Python会察看默认路径。UNIX下,默认路径一般为/usr/local/lib/python/
  4. 模块搜索路径存储在system模块的sys.path变量中。变量里包含当前目录,PYTHONPATH和由安装过程决定的默认目录。

三、as 的三种用法

1. with…as…

第一种是和with结合使用,主要用于文件的读写操作,省去了关闭文件的麻烦。

写法:

with open("文件路径","读写方式") as 赋值变量:
    #  执行代码块

实例:

#test.py
with open("1.txt") as f:
    print f.read()


#1.txt(两个文件在同一目录下)

运行结果:

 

2. 导入模块起别名

导入模块是对模块进行重命名,也就是给模块起一个别名。示例代码在下方的第三点有演示。

3. except结合使用

第一种:给traceback模块起别名为a

示例代码 :

import traceback as a
try:
    while 1/0 < 0:
        print True

第二种:和except组合使用,将捕获到的异常对象赋值给e。

实例代码 :

except Exception as e:
    print "e=",e
    a.print_exc()

四、总结

本文详细的讲解了Python基础 ( 模块 )的引入,调用 。介绍了常用的三种模块。模块时的需要注意的事项,以及在实际操作中会遇到的问题,提供了解决方案。希望可以帮助你更好的学习Python。

说说Python集合的那些事儿

大家好,我是IT共享者,人称皮皮。今天给大家来捋一捋Python集合。

一、什么是集合?

集合(set)和字典(dict)类似,它是一组 key 的集合,但不存储 value。集合的特性就是:key 不能重复。

二、集合常用操作

1. 创建集合

set 的创建可以使用 {} 也可以使用 set 函数:

s1 = {'a', 'b', 'c', 'a', 'd', 'b'}  # 使用 {}
print(s1)
(['a', 'c', 'b', 'd'])

s2 = set('helloworld')  # 使用 set(),接收一个字符串
print(s2)
set(['e', 'd', 'h', 'l', 'o', 'r', 'w'])
s3 = set(['.mp3', '.mp4', '.rmvb', '.mkv', '.mp3'])  # 使用 set(),接收一个列表
print(s3)
set(['.mp3', '.mkv', '.rmvb', '.mp4'])

说说Python集合的那些事儿

2. 遍历集合

s = {'a', 'b', 'c', 'a', 'd', 'b'}
for e in s:
    print(e)

说说Python集合的那些事儿

3. 添加元素

add() 方法可以将元素添加到 set 中,可以重复添加,但没有效果。

s = {'a', 'b', 'c', 'a', 'd', 'b'}
print(s)
set(['a', 'c', 'b', 'd'])
s.add('e')
print(s)
set(['a', 'c', 'b', 'e', 'd'])
s.add('a')
print(s)
set(['a', 'c', 'b', 'e', 'd'])
s.add(4)
print(s)
set(['a', 'c', 'b', 4, 'd', 'e'])

说说Python集合的那些事儿

4. 删除元素

remove() 方法可以删除集合中的元素, 但是删除不存在的元素,会抛出 KeyError,可改用 discard()

例子:

s = {'a', 'b', 'c', 'a', 'd', 'b'}
print(s)
set(['a', 'c', 'b', 'd'])
s.remove('a')  # 删除元素 'a'
print(s)
set(['c', 'b', 'd'])
s.remove('e')  # 删除不存在的元素,会抛出 KeyError

说说Python集合的那些事儿

s = {'a', 'b', 'c', 'a', 'd', 'b'}
print(s)
set(['a', 'c', 'b', 'd'])
s.remove('a')  # 删除元素 'a'
print(s)
set(['c', 'b', 'd'])
s.discard('e')  # 删除不存在的元素, 不会抛出 KeyError

说说Python集合的那些事儿

三、交集/并集/差集

Python 中的集合也可以看成是数学意义上的无序和无重复元素的集合,因此,我们可以对两个集合作交集、并集等。

看看例子:

s1 = {1, 2, 3, 4, 5, 6}
s2 = {3, 6, 9, 10, 12}
s3 = {2, 3, 4}
print(s1 & s2 ) # 交集
set([3, 6])
print(s1 | s2)  # 并集
set([1, 2, 3, 4, 5, 6, 9, 10, 12])
print(s1 - s2)  # 差集
set([1, 2, 4, 5])
print(s3.issubset(s1))  # s3 是否是 s1 的子集

print(s3.issubset(s2))  # s3 是否是 s2 的子集

print(s1.issuperset(s3))  # s1 是否是 s3 的超集

print(s1.issuperset(s2))  # s1 是否是 s2 的超集

说说Python集合的那些事儿

四、总结

本文主要介绍了Python的另外一种形式(集合),通过讲解集合中如何去创建集合,遍历集合,解释了两种常见的集合操作,添加元素和删除元素。最后通过一个小项目,介绍了集合之间中的三种关系。希望能够帮助大家更好的学习。

浅析装饰器的那些事儿

一、装饰器的简单定义

外层函数返回里层函数的引用,里层函数引用外层函数的变量。

二、装饰器的作用

通俗来讲装饰器的作用就是在不改变已有函数代码前提下,为该函数增加新的功能。

def run():
   print('我会跑')
fun()

现在我想在原有函数的基础上新增一个功能:我会唱歌。这个时候利用装饰器则轻松可以帮我们实现这个功能。

三、实例理解

(1)不传参的装饰器

def outer(fun):
   def inner():
      fun()  //fun是外层函数的变量,在inner里面用
   return inner //inner就是里层函数的引用

(2)传递参数的装饰器:

def func(fun):
   def add(*args,**kwarge):
      return fun(*args,**kwargs)
   return add

现在对于装饰器的基本格式有一定的了解,就可以直接写函数了。下面实现文章开头的 我会唱歌 的功能

def outer(fun):
    def inner(*args, **kwarge):
        print("我会唱歌")
        return fun(*args, **kwarge)
    return inner

四、如何使用装饰器

方法一:使用@符号+装饰器的名字   把它放在想要装饰函数的上一行即可
@outer
def run():
   print('我会跑')
   
run()




方法二:
def run():
    print('我会跑')


run=outer(run)   #就等价于@outer
run()


最终打印结果是:
我会唱歌
我会跑

如果我想知道fun 传递的参数是什么,在装饰器内部可以使用如下方式:

def outer(fun):
    a = 1
    def inner(*args, **kwarge): # args是一个数组,kwargs一个字典
        print(fun.__name__) #打印fun接收的函数的名字
        print("我会唱歌")
        return fun(*args, **kwarge)
    return inner

但是如果我们 print(run.__name__,6666666) 输出的结果是inner,并不是我们想要的run,这里的函数被warpTheFunction替代了。它重写了我们函数的名字和注释文档(docstring)。解决方法如下:

from functools import wraps


def outer(fun):
    @wraps(fun)
    def inner(*args, **kwargs):
        print(fun.__name__,11111111111)
        print("我会唱歌")
        return fun(*args, **kwargs)
    return inner


@outer
def run():
   print('我会跑')
   
 print(run.__name__,6666666)  //输出结果为 run 666666

五、自己实现装饰器

def subuser_keymanage(view_func):
    '''功能是实现用户管理权限的判定'''
    def _wrapper_view(request, *args, **kwargs):
        user = request.user #一个Customer对象,包含了用户名/密码等信息
        customer = user.customer.customer_id #用户的id
        select_status = get_curuser_permission(user=user, customer=customer)#调用函数返回的值有两种0和1
        if not select_status:#如果返回0表示没有权限,返回错误码
            return render_response(request, ErrorCode.FAILED)
        return view_func(request, *args, **kwargs)
    return _wrapper_view
@subuser_keymanage 
def generate_subuser_ak_sk(request):
    params = json.loads(request.body) #获取卡前端传递的参数
    user_id_only = params.get("user_id") #获取用户表示id值
    中间代码就忽略了......
    return render_response(request, ErrorCode.FAILED)

六、装饰器小结

通过装饰器很大程度上可以减少代码的复用,在代码规范中这一点是很重要的。

以上就是装饰器的基本知识,即便没有任何基础,按照作者的思路,套用固定的格式,不需要完全理解,只要按照流程一步一步就能写出高端大气上档次的装饰器了,恭喜你!

前方高能请注意:装饰器传参,三层嵌套函数一般用的比较少,其实也不难,一层一层看,跟上文讲的一样,仅作为知识的拓宽。

import logging
def use_logging(level):
    def decorator(func):
        def wrapper(*args, **kwargs):
            if level == "warn":
                logging.warn("%s is running" % func.__name__)
            elif level == "info":
                logging.info("%s is running" % func.__name__)
            return func(*args)
        return wrapper


    return decorator


@use_logging(level="warn")
def foo(name='foo'):
    print("i am %s" % name)


foo()
i am foo
WARNING:root:foo is running

如果在操作过程中有任何问题,记得下面留言,我们看到会第一时间解决问题。

手把手教你用用Python爬取上道网的赞助公司名称

一、前言

上道网是一个手游发行推荐与投融资交易平台。平台聚集手游CP、手游发行、手游渠道、手游外包,投资商以及IP授权商,IP合作、一站式服务。并为之提供合作交易机会。

今天教如何去爬取上道网的赞助公司名称,方便有关人士投资。

二、实现目标

获取对应的公司名称,保存文档。

三、项目准备

软件:PyCharm

需要的库:requests,fake_useragent,time

网址:
http://www.daogame.cn/qudao-p-2.html?s=/qudao-p-{}.html

四、项目分析

如何网页访问?

http://www.daogame.cn/qudao-p-2.html?s=/qudao-p-1.html

http://www.daogame.cn/qudao-p-2.html?s=/qudao-p-2.html

http://www.daogame.cn/qudao-p-2.html?s=/qudao-p-3.html

http://www.daogame.cn/qudao-p-2.html?s=/qudao-p-4.html

点击下一页时,每增加一页p-{}.html自增加1,用{}代替变换的变量,再用for循环遍历这网址,实现多个网址请求。

五、项目实现

1. 定义一个class类继承object,定义init方法继承self,主函数main继承self。导入需要的库、请求地址。

import requests
from lxml import etree
from fake_useragent import UserAgent
import time


class Shangdao(object):
    def __init__(self):
        self.url = "http://www.daogame.cn/qudao-p-2.html?s=/qudao-p-{}.html"  #网站
    def main(self):
        pass


if __name__ == '__main__':
    Siper = Shangdao()
    Siper.main()

2. 随机产生UserAgent,防止反爬。

for i in range(1, 50):
            self.headers = {
                'User-Agent': ua.random,
            }

3. 发送请求 获取响应, 页面回调,方便下次请求。

   def get_page(self, url):
        res = requests.get(url=url, headers=self.headers)
        html = res.content.decode("utf-8")
        return html

4. 获取公司名称,for遍历。

   def page_page(self, html):
        parse_html = etree.HTML(html)
        one = parse_html.xpath('//h2/a/text()')
        for i in one:
            print(i)

5. 写入文档。

           f = open('公司.doc', 'a', encoding='utf-8')  # 以'w'方式打开文件
            f.write(str(i))

6. 调用方法,实现功能。

   def main(self):
        stat = int(input("输 入 开 始 (2开始):"))
        end = int(input("输 入 结 束:"))
        for page in range(stat, end + 1):
            url = self.url.format(page)
            print(url)
            html = self.get_page(url)
            self.page_page(html)
            print("==================第%s页爬取成功!!!!=====================" % page)

项目优化:

1. 设置时间延时。

time.sleep(1.4)

六、效果展示

点击绿色小三角运行输入起始页,终止页( 从0页开始 )。

渠道公司名,结果显示控制台。

保存文档。

七、总结

  1. 不建议抓取太多数据,容易对服务器造成负载,浅尝辄止即可。

  1. 希望通过这个项目,能够帮助了解xpath解析页面的基本流程,字符串是如何拼接,format函数如何运用。

  2. 本文基于Python网络爬虫,利用爬虫库,实现爬取上道网,但是到自己动手实现的时候,总会有各种各样的问题,切勿眼高手低,勤动手,才可以理解的更加深刻。

    看完本文有收获?请转发分享给更多的人

    IT共享之家

    入群请在微信后台回复【入群】

    ——————- End ——————-

    往期精彩文章推荐:

Python解析库lxml与xpath用法总结

本文主要围绕以xpath和lxml库进行展开:

一、xpath 概念、xpath节点、xpath语法、xpath轴、xpath运算符

二、lxml的安装、lxml的使用、lxml案例

一、xpath

1.xpath概念

XPath 是一门在 XML 文档中查找信息的语言。XPath 使用路径表达式在 XML 文档中进行导航 。XPath 包含一个标准函数库 。XPath 是 XSLT 中的主要元素 。XPath 是一个 W3C 标准 。

2.xpath节点

xpath有七种类型的节点:元素、属性、文本、命名空间、处理指令、注释以及文档(根)节点。

节点关系:父、子、兄弟、先辈、后辈。

3.xpath语法

xpath语法在W3c网站上有详细的介绍,这里截取部分知识,供大家学习。

XPath 使用路径表达式在 XML 文档中选取节点。节点是通过沿着路径或者 step 来选取的。下面列出了最有用的路径表达式:

表达式 描述
nodename 选取此节点的所有子节点。
/ 从根节点选取。
// 从匹配选择的当前节点选择文档中的节点,而不考虑它们的位置。
. 选取当前节点。
.. 选取当前节点的父节点。
@ 选取属性。

在下面的表格中,我们已列出了一些路径表达式以及表达式的结果:

路径表达式 结果
bookstore 选取 bookstore 元素的所有子节点。
/bookstore 选取根元素 bookstore。注释:假如路径起始于正斜杠( / ),则此路径始终代表到某元素的绝对路径!
bookstore/book 选取属于 bookstore 的子元素的所有 book 元素。
//book 选取所有 book 子元素,而不管它们在文档中的位置。
bookstore//book 选择属于 bookstore 元素的后代的所有 book 元素,而不管它们位于 bookstore 之下的什么位置。
//@lang 选取名为 lang 的所有属性。

谓语(Predicates)

谓语用来查找某个特定的节点或者包含某个指定的值的节点。

谓语被嵌在方括号中。

在下面的表格中,我们列出了带有谓语的一些路径表达式,以及表达式的结果:

路径表达式 结果
/bookstore/book[1] 选取属于 bookstore 子元素的第一个 book 元素。
/bookstore/book[last()] 选取属于 bookstore 子元素的最后一个 book 元素。
/bookstore/book[last()-1] 选取属于 bookstore 子元素的倒数第二个 book 元素。
/bookstore/book[position()<3] 选取最前面的两个属于 bookstore 元素的子元素的 book 元素。
//title[@lang] 选取所有拥有名为 lang 的属性的 title 元素。
//title[@lang=’eng’] 选取所有 title 元素,且这些元素拥有值为 eng 的 lang 属性。
/bookstore/book[price>35.00] 选取 bookstore 元素的所有 book 元素,且其中的 price 元素的值须大于 35.00。
/bookstore/book[price>35.00]/title 选取 bookstore 元素中的 book 元素的所有 title 元素,且其中的 price 元素的值须大于 35.00。

选取未知节点

XPath 通配符可用来选取未知的 XML 元素。

通配符 描述
* 匹配任何元素节点。
@* 匹配任何属性节点。
node() 匹配任何类型的节点。

在下面的表格中,我们列出了一些路径表达式,以及这些表达式的结果:

路径表达式 结果
/bookstore/* 选取 bookstore 元素的所有子元素。
//* 选取文档中的所有元素。
//title[@*] 选取所有带有属性的 title 元素。

选取若干路径

通过在路径表达式中使用”|”运算符,您可以选取若干个路径。

在下面的表格中,我们列出了一些路径表达式,以及这些表达式的结果:

路径表达式 结果
//book/title | //book/price 选取 book 元素的所有 title 和 price 元素。
//title | //price 选取文档中的所有 title 和 price 元素。
/bookstore/book/title | //price 选取属于 bookstore 元素的 book 元素的所有 title 元素,以及文档中所有的 price 元素。

4.xpath 轴

轴可定义相对于当前节点的节点集。

轴名称 结果
ancestor 选取当前节点的所有先辈(父、祖父等)。
ancestor-or-self 选取当前节点的所有先辈(父、祖父等)以及当前节点本身。
attribute 选取当前节点的所有属性。
child 选取当前节点的所有子元素。
descendant 选取当前节点的所有后代元素(子、孙等)。
descendant-or-self 选取当前节点的所有后代元素(子、孙等)以及当前节点本身。
following 选取文档中当前节点的结束标签之后的所有节点。
namespace 选取当前节点的所有命名空间节点。
parent 选取当前节点的父节点。
preceding 选取文档中当前节点的开始标签之前的所有节点。
preceding-sibling 选取当前节点之前的所有同级节点。
self 选取当前节点。

5.xpath运算符

下面列出了可用在 XPath 表达式中的运算符:

运算符 描述 实例 返回值
| 计算两个节点集 //book | //cd 返回所有拥有 book 和 cd 元素的节点集
+ 加法 6 + 4 10
减法 6 – 4 2
* 乘法 6 * 4 24
div 除法 8 div 4 2
= 等于 price=9.80 如果 price 是 9.80,则返回 true。如果 price 是 9.90,则返回 false。
!= 不等于 price!=9.80 如果 price 是 9.90,则返回 true。如果 price 是 9.80,则返回 false。
< 小于 price<9.80 如果 price 是 9.00,则返回 true。如果 price 是 9.90,则返回 false。
<= 小于或等于 price<=9.80 如果 price 是 9.00,则返回 true。如果 price 是 9.90,则返回 false。
> 大于 price>9.80 如果 price 是 9.90,则返回 true。如果 price 是 9.80,则返回 false。
>= 大于或等于 price>=9.80 如果 price 是 9.90,则返回 true。如果 price 是 9.70,则返回 false。
or price=9.80 or price=9.70 如果 price 是 9.80,则返回 true。如果 price 是 9.50,则返回 false。
and price>9.00 and price<9.90 如果 price 是 9.80,则返回 true。如果 price 是 8.50,则返回 false。
mod 计算除法的余数 5 mod 2 1

好了,xpath的内容就这么多了。接下来我们要介绍一个神器lxml,他的速度很快,曾经一直是我使用beautifulsoup时最钟爱的解析器,没有之一,因为他的速度的确比其他的html.parser 和html5lib快了许多。

二、lxml

1.lxml安装

lxml 是一个xpath格式解析模块,安装很方便,直接pip install lxml 或者easy_install lxml即可。

2.lxml 使用

lxml提供了两种解析网页的方式,一种是你解析自己写的离线网页时,另一种 则是解析线上网页。

导入包:

from lxml import  etree

1.解析离线网页:

html=etree.parse('xx.html',etree.HTMLParser())
aa=html.xpath('//*[@id="s_xmancard_news"]/div/div[2]/div/div[1]/h2/a[1]/@href')
print(aa)

2.解析在线网页:

from lxml import etree
import requests
rep=requests.get('https://www.baidu.com')
html=etree.HTML(rep.text)
aa=html.xpath('//*[@id="s_xmancard_news"]/div/div[2]/div/div[1]/h2/a[1]/@href')
print(aa)

那么我们怎么获取这些标签和标签对应的属性值了,很简单,首先获取标签只需你这样做:


然后我们可以,比方说,你要获取a标签内的文本和它的属性href所对应的值,有两种方法,

1.表达式内获取

aa=html.xpath('//*[@id="s_xmancard_news"]/div/div[2]/div/div[1]/h2/a[1]/text()')


ab=html.xpath('//*[@id="s_xmancard_news"]/div/div[2]/div/div[1]/h2/a[1]/@href')

2.表达式外获取

aa=html.xpath('//*[@id="s_xmancard_news"]/div/div[2]/div/div[1]/h2/a[1]')


aa.text


aa.attrib.get('href')

这样就完成了获取,怎么样,是不是很简单了,哈哈哈。

下面再来lxml的解析规则:

表达式 描述
nodename 选取此节点的所有子节点
/ 从当前节点选取直接子节点
// 从当前节点选取子孙节点
. 选取当前节点
.. 选取当前节点的父节点
@ 选取属性
html = lxml.etree.HTML(text)
#使用text构造一个XPath解析对象,etree模块可以自动修正HTML文本
html = lxml.etree.parse('./ex.html',etree.HTMLParser())
#直接读取文本进行解析
from lxml import etree
result = html.xpath('//*')
#选取所有节点
result = html.xpath('//li')
#获取所有li节点
result = html.xpath('//li/a')
#获取所有li节点的直接a子节点
result = html.xpath('//li//a')
#获取所有li节点的所有a子孙节点
result = html.xpath('//a[@href="link.html"]/../@class')
#获取所有href属性为link.html的a节点的父节点的class属性
result = html.xpath('//li[@class="ni"]')
#获取所有class属性为ni的li节点
result = html.xpath('//li/text()')
#获取所有li节点的文本
result = html.xpath('//li/a/@href')
#获取所有li节点的a节点的href属性
result = html.xpath('//li[contains(@class,"li")]/a/text())
#当li的class属性有多个值时,需用contains函数完成匹配
result = html.xpath('//li[contains(@class,"li") and @name="item"]/a/text()')
#多属性匹配
result = html.xpath('//li[1]/a/text()')
result = html.xpath('//li[last()]/a/text()')
result = html.xpath('//li[position()<3]/a/text()')
result = html.xpath('//li[last()-2]/a/text()')
#按序选择,中括号内为XPath提供的函数
result = html.xpath('//li[1]/ancestor::*')
#获取祖先节点
result = html.xpath('//li[1]/ancestor::div')
result = html.xpath('//li[1]/attribute::*')
#获取属性值
result = html.xpath('//li[1]/child::a[@href="link1.html"]')
#获取直接子节点
result = html.xpath('//li[1]/descendant::span')
#获取所有子孙节点
result = html.xpath('//li[1]/following::*[2]')
#获取当前节点之后的所有节点的第二个
result = html.xpath('//li[1]/following-sibling::*')
#获取后续所有同级节点

3.lxml案例

为了偷懒,小编决定还是采用urllib那篇文章的代码,哈哈哈,机智如我。

好了,今天就讲这么多,大家感兴趣的话可以多多关注哦,精彩不停息!!!!

本文参考文献:

https://www.w3school.com.cn/

看完本文有收获?请转发分享给更多的人

IT共享之家

入群请在微信后台回复【入群】

——————- End ——————-

往期精彩文章推荐:

用Python编程语言来实现阿姆斯特朗数的检查

一、什么是阿姆斯特朗数?

如果一个正整数等于其各个数字的立方和,则称该数为阿姆斯特朗数(亦称为自恋性数)。

一个正整数称为阿姆斯特朗阶数。

例:

abcd... = an + bn + cn + dn + ...

如果是3位的阿姆斯特朗数字,则每个数字的立方和等于该数字本身。
例如:

153 = 1*1*1 + 5*5*5 + 3*3*3  // 153是一个阿姆斯特朗数。

二、案例

1. 检查阿姆斯特朗数(3位数字)

例 :

# 检查该数字是否为阿姆斯壮数字的Python程序

# 接受用户的输入
num = int(input("输入一个数字: "))

# 初始化sum
sum = 0

# 求出每个数字的立方和
temp = num
while temp > 0:
   digit = temp % 10
   sum += digit ** 3
   temp //= 10

# 显示结果
if num == sum:
   print(num,"是阿姆斯特朗数")
else:
   print(num,"不是阿姆斯特朗数")

输出1

输出2

代码解析:

要求用户输入一个数字,然后检查它是否是一个阿姆斯特朗数字,需要计算每个数字的立方和。

因此,将总和初始化为0,并使用模运算符(%)获得每个数字。将数字除以10所得的余数是该数字的最后一位。使用指数运算符获取多维数据集。

最后,将总和与原始数字进行比较,得出结论,如果相等,则是阿姆斯特朗数。

2. 检查是阿姆斯特朗的n位数字

例:

num = 1634

# 将num变量更改为string
# 并计算出长度(位数)
order = len(str(num))

# 初始化 sum
sum = 0

# 求出每个数字的立方和
temp = num
while temp > 0:
    digit = temp % 10
    sum += digit ** order
    temp //= 10

# 显示结果
if num == sum:
    print(num, "是阿姆斯特朗数")
else:
    print(num, "不是阿姆斯特朗数")

运行结果:

注:

读者可以更改源代码中num的值,然后再次运行以对其进行测试。

3. 在整数中查找阿姆斯特朗数

例:

# Python程序在整数中查找阿姆斯特朗数

lower = 100
upper = 2000

for num in range(lower, upper + 1):

    # order 个数
    order = len(str(num))

    # 初始化 sum
    sum = 0

    temp = num
    while temp > 0:
        digit = temp % 10
        sum += digit ** order
        temp //= 10

    if num == sum:
        print(num)

运行结果:

注:

在变量lower中设置了下限100,在变量upper中设置了上限2000。

使用了for循环来从变量lower到upper进行迭代。在迭代中,lower的值增加1,并检查它是否为阿姆斯特朗数。

可以更改范围并通过更改变量lower和upper进行测试。该变量lower应小于upper此程序才能正常运行。

三、总结

本文基于Python基础,介绍了什么是阿姆斯特朗数,以及如何去判断,检查阿姆斯特朗数,检查是阿姆斯特朗的n位数字,在整数中查找阿姆斯特朗数。都通过案例的分析,代码的演示,效果的展示,进行有效的分析。

使用Python语言,能够让读者更好的理解。在实际项目中遇到的问题,难点,提供了有效的解决方案,供读者参考。

代码很简单,希望能够帮读者更好的学习。

想学习更多前端、Python爬虫、大数据等计算机知识,请前往:http://pdcfighting.com/

看完本文有收获?请转发分享给更多的人

IT共享之家

入群请在微信后台回复【入群】

——————- End ——————-

往期精彩文章推荐:

手把手用Python教你如何发现隐藏wifi

手把手教你用Python做个可视化的“剪刀石头布”小游戏

手把手用Python网络爬虫带你爬取全国著名高校附近酒店评论

Python基础数据类型——tuple浅析

Python中tuple的使用

一、什么是元组?

有序列表叫元组:tuple。tuple和list非常类似,但是tuple一旦初始化就不能修改。

二、用法

1. tuple元组的定义

Python的元组与列表类似,不同之处在于元组的元素不能修改。元组使用小括号,列表使用方括号。元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可。示例如下:

tup1 = ('361way', 'com', 1997, 2000)
print(type(tup1))
tup2 = (1, 2, 3, 4, 5)tup3 = "a", "b", "c", "d"
print(type(tup3))
Python基础数据类型——tuple浅析

这里通过tup3可以看出,其并没有用小括号进行包括,但其也是元组。所以需要记住:任意无符号的对象,以逗号隔开,默认为元组 。另外需要特别注意只有一个元素时元组的创建:

tup1 = (111)
print(type(tup1))
tup1 = ("abc")
print(type(tup1))
tup1 = ("abc",)
print(type(tup1))
Python基础数据类型——tuple浅析

元组中只包含一个元素时,需要在元素后面添加逗号,否则就会是int 或 string 等其他数据类型。如果只是创建一个空元组时,则不受逗号的影响:

tup1 = ()
print(type(tup1))
Python基础数据类型——tuple浅析

2. 元组的索引与切片

同字符串、列表类型一样,元组也支持索引与切片 。而且用法也相同,

下面结合示例查看下:

tup1 = ('361way', 'com', 2013, 2014)
print(tup1[0])
print(tup1[4]) #取值超出其索引范围时报错
tup2 = (1, 2, 3, 4, 5, 6, 7)
print(tup2[1:5])

由上面的结果可以看出,取出元组的单个元素数据时,得到的是该数据原来的类型 ; 取出其一段元素值时得到的仍是元组。

Python基础数据类型——tuple浅析

3. 修改元组的值

元组中的元素值是不允许删除的,但可以使用del语句来删除整个元组,如下实例:

tup1 = ('361way', 'com', 2013, 2014)
del tup1[3]  # 删除单个元素,报错
tup1[3] = 'abc'  # 更改一个元素的值,报错
print(tup1[3])
del tup1  # 删除整个元组,正常print(tup1)
Python基础数据类型——tuple浅析

在实际应用中,有时候会遇到需要修改元组的值,那怎么办呢?可以通过一个变通的方法实现。

示例如下:

tup1 = ('361way', 'com', 2013, 2014)
list1 = list(tup1)
print(list1)
list1[3] = 'change'
print(list1)
tup1 = tuple(list1)print(tup1)
Python基础数据类型——tuple浅析

可以将tuple元组的值先通过list转化为列表,再对列表内的值进行修改,修改为再将list转化为tuple 。

不过这里需要注意的是此时的tup1已经非彼tup1,具体可以通过id函数进行查看,发现其内存地址已经发生了变化。

三、总结

本文基于Python基础,主要介绍了Python基础中tuple元组的使用,对于tuple的用法做了详细的讲解,用丰富的案例 ,代码效果图的展示帮助大家更好理解 。

tuple是Python内置的有序集合,一个可变,一个不可变。根据需要来选择使用它们。

最后,希望可以帮助大家更好的学习Python。

想学习更多Python网络爬虫与数据挖掘知识,可前往专业网站:http://pdcfighting.com/

IT共享之家

入群请在微信后台回复【入群】

****看完本文有收获?请转发分享给更多的人****

—————— End ——————

往期精彩文章推荐:

Python基础变量类型——List浅析

Python使用list

一、list

Python内置的一种数据类型是列表:list。list是一种有序的集合,可以随时添加和删除其中的元素。

比如,列出班里所有同学的名字,就可以用一个list表示:

classmates = ['Michael', 'Bob', 'Tracy']
print(classmates)
Python基础变量类型——List浅析

变量classmates就是一个list。

len()函数

1. 获得list元素的个数:

classmates = ['Michael', 'Bob', 'Tracy']
print(len(classmates))

用索引来访问list中每一个位置的元素,记得索引是从0开始的:

classmates = ['Michael', 'Bob', 'Tracy']

print(classmates[0])

print(classmates[1])

print(classmates[2])

print(classmates[3])

当索引超出了范围时,Python会报一个IndexError错误,所以,要确保索引不要越界,记得最后一个元素的索引是len(classmates) – 1。

如果要取最后一个元素,除了计算索引位置外,还可以用-1做索引,直接获取最后一个元素:

print(classmates[-1])
Python基础变量类型——List浅析

以此类推,可以获取倒数第2个、倒数第3个:

classmates = ['Michael', 'Bob', 'Tracy']

print(classmates[-1])

print(classmates[-2])

print(classmates[-3])

print(classmates[-4])
Python基础变量类型——List浅析

当然,倒数第4个就越界了。

2. list是一个可变的有序表,往list中追加元素到末尾:

classmates = ['Michael', 'Bob', 'Tracy']

classmates.append('Adam')

print(classmates)

也可以把元素插入到指定的位置,比如索引号为1的位置:

classmates = ['Michael', 'Bob', 'Tracy']
#替换
classmates.insert(1, 'Jack')

print(classmates)
Python基础变量类型——List浅析

pop()函数

1. 删除list末尾的元素

classmates = ['Michael', 'Bob', 'Tracy']

print(classmates.pop())

print( classmates)
['Michael', 'Jack', 'Bob', 'Tracy']
Python基础变量类型——List浅析

2. 删除指定位置的元素,用pop(i)方法,其中i是索引位置。

classmates.pop(1)

print(classmates)
Python基础变量类型——List浅析

3. 把某个元素替换成别的元素,可以直接赋值给对应的索引位置:

classmates = ['Michael', 'Bob', 'Tracy']

classmates[1] = 'Sarah'

print(classmates)
Python基础变量类型——List浅析

list里面的元素的数据类型也可以不同,比如:

L = ['Apple', 123, True]

list元素也可以是另一个list,比如:

s = ['python', 'java', ['asp', 'php'], 'scheme']
print(len(s))
Python基础变量类型——List浅析

要注意s只有4个元素,其中s[2]又是一个list,如果拆开写就更容易理解了:

p = ['asp', 'php']
s = ['python', 'java', p, 'scheme']

要拿到’php’可以写p[1]或者s[2][1],因此s可以看成是一个二维数组,类似的还有三维、四维……数组,不过很少用到。

如果一个list中一个元素也没有,就是一个空的list,它的长度为0:

L = []
len(L)

二、总结

本文基于Python基础,主要介绍了Python基础中list列表,通过list列表的两个函数 ,对list的语法做了详细的讲解,用丰富的案例 ,代码效果图的展示帮助大家更好理解 。

使用Python编程语言,方便大家更好理解,希望对大家的学习有帮助。

IT共享之家

入群请在微信后台回复【入群】

****看完本文有收获?请转发分享给更多的人****

—————— End ——————

往期精彩文章推荐:

一篇文章教会你使用Python网络爬虫下载酷狗音乐

【一、项目背景】

现在的听歌软件动不动就是各种付费,要下载软件才能听,当你下载了之后,你会惊奇的发现这首歌还收费,这就让一向喜欢白嫖的小编感到很伤心了。于是,小编冥思苦想,终于让我发现了其中的奥秘,一起来看看吧。

【二、项目准备】

1、编辑器:Sublime Text 3

2、软件:360浏览器

【三、项目目标】

下载我们喜欢的音乐。

【四、项目实现】

1、打开酷狗音乐官网

360浏览器打开酷狗音乐官网:

一篇文章教会你使用Python网络爬虫下载酷狗音乐

可以看到十分清爽的画风,这也是我比较喜欢的地方。

2、审查元素,分析请求

打开Network ,分析请求,我们可以看到:

一篇文章教会你使用Python网络爬虫下载酷狗音乐

从上图可以看出,这是请求的参数,所以我们可以使用Requests模块对它发起请求。

3、模拟发起请求

我们从网页中得知它的地址为:

https://www.kugou.com/yy/html/search.html#searchType=song&searchKeyWord=%E4%B8%8D%E8%B0%93%E4%BE%A0

可以看到真正对于我们来说有用的就只有SearchKeyWord参数后的值,前面的搜索类型默认填写即可,所以我们可以这样:

import requests
headers={'accept': '*/*',
'accept-encoding':'gzip, deflate, br',
'accept-language': 'zh-CN,zh;q=0.9',
'cookie': 'kg_mid=ebb2de813317a791bcf7b7d3131880c4; UM_distinctid=1722ba8b22632d-07ac0227c507a7-4e4c0f20-1fa400-1722ba8b2284a1; kg_dfid=0Q0BEI47P4zf0mHYzV0SYbou; kg_dfid_collect=d41d8cd98f00b204e9800998ecf8427e; Hm_lvt_aedee6983d4cfc62f509129360d6bb3d=1590041687,1590280210,1590367138,1590367386; Hm_lpvt_aedee6983d4cfc62f509129360d6bb3d=1590367431',
'referer': 'https://www.kugou.com/yy/html/search.html',
'sec-fetch-mode': 'no-cors',
'sec-fetch-site': 'same-site',
'user-agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.108 Safari/537.36'
}aa=input('请输入歌名:')
data={
'callback': 'jQuery112408716317197794392_1590368232677',
'keyword':aa,
'page': '1',
'pagesize':'30',
'userid':'-1',
'clientver': '',
'platform': 'WebFilter',
'tag': 'em',
'filter': '2',
'iscorrection': '1',
'privilege_filter': '0',
'_': '1590368232679',
}requests.get('https://www.kugou.com/yy/html/search.html',params=data,timeout=4)

这样就实现了模拟请求,我们来验证下:

一篇文章教会你使用Python网络爬虫下载酷狗音乐

可以看出它成功打印出了和我们上面一模一样的地址。

4、获取音乐文件列表

rep=requests.get('https://www.kugou.com/yy/html/search.html',params=data,timeout=5)
print(rep.url)
res=requests.get(rep.url,timeout=4)
print(res.text)

当我们将请求地址填写正确后,我发现竟然内容与预期不相符,但是请求地址对的一批。

我以为是这样的结果:

一篇文章教会你使用Python网络爬虫下载酷狗音乐

实际上的结果:

一篇文章教会你使用Python网络爬虫下载酷狗音乐

可以看到差距很大,而且用Json也根本获取不到,报格式错误,说明不是一个Json,看来这比QQ音乐难度高点。不过我们今天要下载的是音频文件,所以暂时跳过,不管它。

5、下载音频文件

我们在搜索后弹出来的列表中选择原唱曲目,进去听一下:

一篇文章教会你使用Python网络爬虫下载酷狗音乐

我选择第一首,打开是这样,我们开始骚操作,打开Network:

一篇文章教会你使用Python网络爬虫下载酷狗音乐

我们输入后缀Mp3,然后定位到对应的请求,然后打开它的请求结果,可以看到一个Json结果:

一篇文章教会你使用Python网络爬虫下载酷狗音乐

我们将Json结果粘贴到控制台,可以看到里面有一段关于Mp3的结果,不过添加了点干扰符号,我们把它提取出来:

一篇文章教会你使用Python网络爬虫下载酷狗音乐

这样我们就可以把酷狗音乐的歌曲下载下来了。

【五、项目总结】

1、其实,酷狗音乐与QQ音乐不同,酷狗音乐的下载链接更好捕获,你可以直接在它的播放界面捕获到:

一篇文章教会你使用Python网络爬虫下载酷狗音乐

模拟请求这个界面,一切都搞定了。

2、关于QQ音乐的获取,可以参考之前发布的系列文章:

3、需要本文源码的小伙伴,后台回复“酷狗音乐”四个字,即可获取。

IT共享之家

入群请在微信后台回复【入群】

****看完本文有收获?请转发分享给更多的人****

—————— End ——————

往期精彩文章推荐:

一篇文章教会你利用Python网络爬虫获取分类图片

【一、项目背景】

博海拾贝是一支互联网从业者在线教育的团队,扎根于中国教育行业以及互联网行业的创新和眼球中,打造专业体系化的互联网人在线教育平台。精心创作许多精彩的文章,提供了很多有趣的图片。

今天来教大家如何使用Python来爬取博海拾贝的图片,分类保存,写入文档。

一篇文章教会你利用Python网络爬虫获取分类图片

【二、项目目标】

创建一个文件夹, 分类保存所有文章图片。下载成功,结果显示控制台。

【三、项目分析】

1、如何找到真正访问的地址,多网页请求?

滑动鼠标,观察网站,右键F12 。鼠标滚轮滑动加载新内容。如图:

一篇文章教会你利用Python网络爬虫获取分类图片

点开随机网页 , 点开Request URL ,观察网址的规律。

一篇文章教会你利用Python网络爬虫获取分类图片
https://bh.sb/page/1/
https://bh.sb/page/2/
https://bh.sb/page/3/
https://bh.sb/page/4/

观察到,每增加一页page/{}/自增加1,用{}代替变换的变量,再用for循环遍历这网址,实现多个网址请求。

2. 反爬处理

1)获取正常的 http请求头,并在requests请求时,设置这些常规的http请求头。

2)使用 fake_useragent ,产生随机的UserAgent进行访问。

【四、涉及的库和网站】

1、网址如下:

https://www.doutula.com/photo/list/?page={}

2、涉及的库:requestslxmlfake_useragenttimeos

3、软件:PyCharm

【五、项目实施】

1、我们定义一个class类继承object,然后定义init方法继承self,再定义一个主函数main继承self。导入需要的库和网址,创建保存文件夹。

import requests, os
from lxml import etree
from fake_useragent import UserAgent
import timeclass bnotiank(object):    def __init__(self):
        os.mkdir("图片")  # 在创建文件夹 记住只有第一次运行加上,如果多次运行请注释掉本行。
    def main(self):
          pass
if __name__ == '__main__':
    Siper=bnotiank()
    Siper.main()

2、随机UserAgent ,构造请求头,防止反爬。

ua = UserAgent(verify_ssl=False)
    for i in range(1, 50):
        self.headers = {            'User-Agent': ua.random
        }

3、发送请求 ,获取响应,页面回调,方便下次请求。

'''发送请求  获取响应'''
    def get_page(self, url):
        res = requests.get(url=url, headers=self.headers)        html = res.content.decode("utf-8")
        return html

4、定义parse_page函数,获取二级页面地址,for遍历获取需要的字段。

 def parse_page(self, html):
        parse_html = etree.HTML(html)        image_src_list = parse_html.xpath('//p/a/@href')
        # print(image_src_list)

5、对二级页面发生请求,xpath解析数据,获取大图片链接。

reo = parse_html1.xpath('//div//div[@class="content"]') #父结点
    for j in reo:
        d = j.xpath('.//article[@class="article-content"]//p/img/@src')[0]
        text = parse_html1.xpath('//h1[@class ="article-title"] //a/text()')[0].strip()

6、请求图片地址,写入文档。

 html2 = requests.get(url=d, headers=self.headers).content
    dirname = "./d/" + text + ".jpg" #定义图命名
    with open(dirname, 'wb') as f:
        f.write(html2)        print("%s 【下载成功!!!!】" % text)

7、调用方法,实现功能。

url = self.url.format(page)
print(url)
html = self.get_page(url)
self.parse_page(html)

8、设置延时。(防止ip被封)。

  time.sleep(1) """时间延时"""

【六、效果展示】

1、点击绿色小三角运行输入起始页,终止页。

一篇文章教会你利用Python网络爬虫获取分类图片

2、将下载成功信息显示在控制台。

一篇文章教会你利用Python网络爬虫获取分类图片

3、text 作为图片命名,展示效果如下所示。

一篇文章教会你利用Python网络爬虫获取分类图片

【七、总结】

1、不建议抓取太多数据,容易对服务器造成负载,浅尝辄止即可。

2、本文基于Python网络爬虫,讲述了反爬技巧,利用爬虫库,实现了分类图片的获取,存入文档。

3、希望通过这个项目,能够帮助了解xpath,字符串是如何拼接,format函数如何运用。

4、实现的时候,总会有各种各样的问题,切勿眼高手低,勤动手,才可以理解的更加深刻。

5、需要本文源码的小伙伴,后台回复“博海拾贝”四个字,即可获取。

看完本文有收获?请转发分享给更多的人

IT共享之家

入群请在微信后台回复【入群】

——————- End ——————-

往期精彩文章推荐: