python_python爬虫 - CSDN
python 订阅
Python是一种跨平台的计算机程序设计语言。 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。最初被设计用于编写自动化脚本(shell),随着版本的不断更新和语言新功能的添加,越多被用于独立的、大型项目的开发。 展开全文
Python是一种跨平台的计算机程序设计语言。 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。最初被设计用于编写自动化脚本(shell),随着版本的不断更新和语言新功能的添加,越多被用于独立的、大型项目的开发。
信息
缩    写
py
作    者
Guido van Rossum
最新版本
稳定:3x:3.8.3 2x:2.7.18;测试:3.9.0a6 2.x:2.7.18rc1 [1]
最近更新时间
2020年04月28日
别    名
胶水语言
发行时间
1991年
中文名
蟒蛇
经典教材
Head First Python; Automate the Boring Stuff with Python
语言类型
高级语言
荣    誉
2017年度编程语言
外文名
Python
PythonPython简介及应用领域
Python是一种解释型脚本语言,可以应用于以下领域: [2] 
收起全文
  • Python入门视频精讲

    万人学习 2019-12-20 11:53:16
    Python入门视频培训课程以通俗易懂的方式讲解Python核心技术,Python基础,Python入门。适合初学者的教程,让你少走弯路! 课程内容包括:1.Python简介和安装 、2.第一个Python程序、PyCharm的使用 、3.Python基础...
  • 150讲轻松搞定Python网络爬虫

    万人学习 2020-08-20 11:10:11
    【为什么学爬虫?】      ...1、爬虫入手容易,但是深入较难,如何写出高效率的爬虫,如何写出灵活性高可扩展的爬虫都是一项技术活。另外在爬虫过程中,经常容易遇到被反爬虫,比如字体反爬、IP...
  • Python爬虫应用案例视频课程

    千人学习 2019-12-31 13:10:43
    本课程以通俗易懂的方式讲解Python爬虫技术,以案例为导向,手把手的Python爬虫实战教程,让你少走弯路! 课程内容包括:1.爬虫简介,Python爬虫入门、2.基本用法、3.爬虫应用(电影评论数据分析)。教学全程采用...
  • 零基础掌握 Python 入门到实战

    万人学习 2020-08-07 15:32:25
    【为什么学PythonPython 是当今非常热门的语言之一,2020年的 TIOBE 编程语言排行榜中 ,Python名列第一,并且其流行度依然处在上升势头。 在2015年的时候,在网上还经常...
  • Python学习路线

    万次阅读 多人点赞 2020-02-19 17:29:05
    经历长达近一个月的资源筛选过程终于结束,总共1.5T的资源经过:去重、筛选、整理、归档之后一份粗略的Python学习曲线资源已经成型,虽然中间经历了很多坎坷,不过最终还是完成,猪哥也是第一时间与大家分享出来。...

    此视频资源收集于网络,如有侵权请联系删除!!!
    此视频资源仅用作个人学习,请勿用于商业获利,造成后果自负!!!

    经历长达近一个月的资源筛选过程终于结束,总共1.5T百度网盘的资源经过:去重、筛选、整理、归档之后一份粗略的Python学习曲线资源已经成型,虽然中间经历了很多坎坷,不过最终还是完成,猪哥也是第一时间与大家分享出来。
    在这里插入图片描述
    资料主要分为两部分:一、各个学习网站论坛等,二、百度云资料。网站论坛资源更新快,可以与大家互动;而百度云资源主要为视频,方便大家下载和在线观看,两种资源结合使用,学习和查找知识更方便!

    一、网站论坛学习资源

    名称 链接 说明
    实验楼 https://www.shiyanlou.com 提供免费的Linux实验环境
    Py资源中文大全 http://t.cn/Rq0C0ET 各种python包和管理工具
    PEP8 Py编码规范中文版 https://dwz.cn/30uIzs9W 代码规范与基础同样重要
    Py Code Examples https://dwz.cn/dawtruYk 精细到方法级别的代码案例
    Py Module of the Week https://pymotw.com 每篇介绍一个 Py标准库的使用
    菜鸟教程 http://t.cn/RLGeMuW 最经典的一个语言教程网站
    廖雪峰Py教程 https://dwz.cn/drygpxjk 大牛带你简单快速入门
    Py自动化测试博客 https://dwz.cn/raopItkV 一个自动化测试大佬的博客
    Py中文学习大本营 http://www.pythondoc.com 一个不错的Flask学习网站
    刘江的Django https://dwz.cn/udQayyZY 最适合入门的Django教程
    莫烦Py https://morvanzhou.github.io 机器学习方面有着不错的造诣
    吴恩达机器学习 https://dwz.cn/F8Aad3DY 网易云课堂(中/英字幕)
    几个Py练习题 https://dwz.cn/ExJnmwOJ 有几个不错的实用练习题
    CheckiO https://py.checkio.org/ 一个学习Py的有趣网站

    二、学习曲线

    这个学习曲线是我在某马论坛上看到的,觉得不错就推荐给大家,同时也感谢某马的开源免费精神,猪哥也是受益颇多!
    在这里插入图片描述
    在这里插入图片描述

    三、优质资源

    我把这些资源分为了七个不同的阶段,难度是依次递增,其实就是对应上面学习曲线图;

    本资源一共800G,永久保存,并且会持续更新,建议大家转发收藏,方便以后查找学习;
    在这里插入图片描述
    这是猪哥推荐的Python学习曲线,基本上是某马的视频教程,这个学习曲线适合零基础的同学:
    在这里插入图片描述

    四、获取方式

    1. 链接:https://pan.baidu.com/s/18gY3J5t2xZPU6zSDWP09RA 密码:j8wk
    2. 如果链接失效,微信扫描下方二维码,关注猪哥微信公众号,回复:学习曲线 即可获取新链接!
      在这里插入图片描述

    五、猪哥有话说

    昨天看到一则新闻“19岁少年培训被坑而自杀”,当时真的很愤怒!!!这也使得猪哥更加坚定的坚持免费分享的原则,如果你觉得此文章好请分享给你的每一位朋友:也许你一个不经意的善意之举,却是他人人生的一个转折点。

    在这里插入图片描述

    展开全文
  • 玩转Python-Python3基础入门

    千人学习 2020-07-21 20:23:03
    总课时80+,提供源码和相关资料
  • python&pymysql

    2019-05-21 22:29:37
    python基础 1.Python 中的字符串有两种索引方式,从左往右以 0 开始,从右往左以 -1 开始。 Python 没有单独的字符类型,一个字符就是长度为 1 的字符串。 字符串的截取的语法格式如下:变量[头下标:尾下标:...
    一  python基础
    

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

    Python 没有单独的字符类型,一个字符就是长度为 1 的字符串。
    
    字符串的截取的语法格式如下:变量[头下标:尾下标:步长]  尾下标不可取
    
    str= ' chenrui '
    
    print(str[1:-1])      输出 henru
    
    print(str*2)            输出chenruichenrui
    
    print(str+'你好')    连接字符串 输出chenrui你好
    
    1. print 默认输出是换行的,如果要实现不换行需要在变量末尾加上 end=’’:

      print(‘chen’, end=’’)

      print(‘rui’)

    输出chenrui

    不可变数据(3 个):Number(数字)、String(字符串)、Tuple(元组);

    比如str=‘chen’

        str[1]='m'     是错误的,不能重新复制
    

    可变数据(3 个):List(列表)、Dictionary(字典)、Set(集合)。

    4.list列表 可变元素,写在[ ]内

    可以存放不同类型元素,可以切片,分割。与字符串不同的是,列表可以更改元素

    a=[123 , ‘cccc’ , 2.7 , 19 , ‘a’ ]

    (1)切片

    c=a[1:4:2] #c=[‘cccc’ , 19]

    (2)判断元素在不在里面

    123 in a

        True
    
    (3)长度
    

    len(a)

        5
    

    (4) list.append(x) 在列表尾部插入x

    (5) list.insert(x,y) 在list[x]处插入y

    (6) list.count(x) 统计列表中元素x出现次数

    (7)list.remove(x) 移除列表中指定值

    (8)list.reverse() 反转列表

    (9)list.extend(b) 将列表b添加到尾部

    (10)list.sort() 列表由小到大排序

    (11)del list[1] 删除该元素

    (12)栈与队列

    list.pop([index=-1]) pop函数默认弹出最后一个元素 且list也会减少一个元素

    现有列表a[1,2,3,4,5,6]

    要实现栈 就一直用 a.pop() , a.apend(x)

    要实现队列 就一直用 a.pop(0) , a.apend(x)

    (13)列表推导式由包含一个表达式的中括号组成,表达式后面跟随一个 for 子句,之后可以有零或多个 for 或 if 子句。结果是一个列表,由表达式依据其后面的 for 和 if 子句上下文计算而来的结果构成。

       >>> list = [x**2 for x in range(10)]    #  list =  [0, 1, 4, 9, .....81]
    
         x ** 2就是表达式  将表达式后面的语句的计算结果依次带入表达式,生成一个列表
    
        >>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
    
                [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
    
            (x,y)是表达式 
    

    5.tuple 元组 不可变元素 写在()内 用逗号分隔

    a=(123 , ‘chen’ , ‘aa’ )

    a[1: ] # (‘chen’ , ‘aa’)

    a=(123) # type(a)==int

    a=(123,) # type(a) == tuple

    1. set 集合 无序 无重复元素 {}或set()创建

    (1)消除重复

    a = {1,3,4,1,3,2}

    print(a)

        {1,3,4,2}    重复元素被消除
    

    或者用set()函数创建

    a = set(‘chenrui’) # a={‘c’, ‘h’, ‘e’, ‘n’, ‘r’, ‘u’, ‘i’}

    a = set( [‘chen’, ‘rui’, 123,789] ) # a={‘chen’, ‘rui’, 123,789}

    (2)交 并 差 对称差集

    a = set(‘abracadabra’)

    b = set(‘alacazam’)

    a # a 去重后的字母{‘a’, ‘r’, ‘b’, ‘c’, ‘d’}

    a - b # 差 {‘r’, ‘d’, ‘b’}

    a | b # 联合 {‘a’, ‘c’, ‘r’, ‘d’, ‘b’, ‘m’, ‘z’, ‘l’}

    a & b #交{‘a’, ‘c’}

    a ^ b # 对称差集 存在于 a 或 b 但不同时存在的字母{‘r’, ‘d’, ‘b’, ‘m’, ‘z’, ‘l’}

    (3)集合推导式

    a = { x for x in ‘abcdefg’ if x not in ‘abcd’}

    a = {‘e’, ‘f’, ‘g’}

    (4)各种方法

    http://www.runoob.com/python3/python3-set.html

    7.字典 键唯一 但一个键可以有多个值 (通过列表实现)

    a = {‘chen’ : ‘rui’ , ‘asc’:’ asd’, ‘cccc’:‘wqe’}

    a= {‘chen’:[‘asd’, ‘asdqwq’, ‘123’], ‘rui’:‘ee’, ‘man’:‘bbb’}

    (1)用dict()从包含键值对的元组中创建

    a = dict( ( (‘chen’, ‘rui’), (‘asd’, ‘cx’),(‘asdqqq’,‘wqezz’) ) )

    则a = {‘chen’:‘rui’, ‘asd’:‘cx’, ‘asdqqq’:‘wqezz’}

    (2) del删除

    del a[‘chen’]

    (3) 遍历一个字典,使用字典的 items() 方法。

    >>> data
    

    {‘Kushal’: ‘Fedora’, ‘Jace’: ‘Mac’, ‘kart_’: ‘Debian’, ‘parthan’: ‘Ubuntu’}

    for x, y in data.items():

                 print("{} uses {}".format(x, y))
    

    (4)setdefault(key, default) 与 get(key, default)

    a.setdefault(‘name’, 0) #如果a没有’name’这个键,则创建该键,并且值为0. 否则返回name键的值

    a.get(‘name’, 0) #有name键 返回对应的值。否则返回0

    (5)zip() 函数

    zip() 函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的对象,这样做的好处是节约了不少的内存。

    我们可以使用 list() 转换来输出列表。

    如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同,利用 * 号操作符,可以将元组解压为列表。

    a = [1,2,3]

    b = [4,5,6]

    c = [4,5,6,7,8]

    zipped = zip(a,b) # 返回一个对象

    zipped<zip object at 0x103abc288>

    list(zipped) # list() 转换为列表[(1, 4), (2, 5), (3, 6)]

    list(zip(a,c)) # 元素个数与最短的列表一致[(1, 4), (2, 5), (3, 6)]

    list(zip(a,b,c)) # [(1,4,4), (2,5,5), (3,6,6)]

    a1, a2 = zip(zip(a,b)) # 与 zip 相反,zip() 可理解为解压,返回二维矩阵式

    list(a1)

        [1, 2, 3]
    

    list(a2)

        [4, 5, 6]
    

    需要同时遍历两个序列类型,你可以使用 zip() 函数。

    a= [‘Pradeepto’,‘Kushal’]

    b= [‘OpenSUSE’,‘Fedora’]

    for x, y in zip(a, b):

              print("{} uses {}".format(x, y))
    

    输出 Pradeepto uses OpenSUSE

     Kushal uses Fedora
    
    1. *用于赋值

    利用 * 表达式获取单个变量中的多个元素,只要它的解释没有歧义即可。* 获取的值默认为 list

    a, b, *c =0,1,2,3

    a

    0

    b

    1

    c

    [2,3]

    1. str.format() 利用{}和:

    数字格式化

    print( ’ {:7.2f } '.format(3.141595) ) #3.14 后面3个空格 注:小数点也占一位

    print( ’ {this is a {:x>4d}} '.format(10) ') # this is a xx10

    print( ’ {this is a {:x<4d}} '.format(10) ’ ) # this is a 10xx

    可以传入参数

    day,name=12,‘chen’

    print(’ today is {} , my name is {} '.format(day,name) )

    也可以不格式化

    print( ’ x= ’ , x)

    10.逻辑运算符 and or not

    逻辑运算符 and 和 or 也称作短路运算符:它们的参数从左向右解析,一旦结果可以确定就停止。例如,如果 A 和 C 为真而 B 为假,A and B and C 不会解析 C 。作用于一个普通的非逻辑值时,短路运算符的返回值通常是能够最先确定结果的那个操作数。

    5 or 4 返回5

    3 and 0 and 1 返回0

    not 具有最高的优先级,or 优先级最低,所以 A and not B or C 等于 (A and (notB)) or C

    1. if for while

    (1) if

    if :

    pass
    

    elif:

    pass
    

    else:

    (2)for 与 range()与for else

       a=[123 , 'asd' , 456]
    
        for x in a:
    
               print (x)
    

    range(5)产生一个0-4的对象,不是列表

    a = range(5)

    a

        range(5)
    

    b = list(a)

    b

        [0,1,2,3,4]
    

    range(1,5,2)产生一个1-4的数列且步长为2 即1 , 3

        for  x  in  range(len(a)) :
    
                    print(a[x])
    

    在循环后面使用可选的 else 语句。它将会在循环完毕后执行,除非有 break 语句终止了循环。可以用来检测for循环是否正常执行完

    for i in range(0, 5):

                print(i)
    

    else:

            print("Bye bye")       
    

    0

    1

    2

    3

    4

    Bye Bye

    (3)while

     while n<10:
    
               pass
    
        while ...else ...用法与for相同
    

    12.字符串

    (1)str.split(str,num) 返回字符串被分割后的列表

    str --分割依据,默认为空格 num --分割次数

    txt = “Google#Runoob#Taobao#Facebook”

    x = txt.split("#", 1) # 第二个参数为 1,返回两个参数列表 [‘Google’, ‘Runoob#Taobao#Facebook’]

    (2)str.strip(char) 剥离字符串中的指定字符 默认为首尾的空格和换行符

    a = ‘abcdefg…’

    a.strip(‘bcd.’) #剥离字符串中的 ‘b’, ‘c’, ‘d’, '.'字符

    a = ‘aefg’

    (3)str.find(char) 找到第一个匹配的子字符串,没有找到则返回 -1。

    s = “faulty for a reason”

    s.find(“for”)

    7

    s.find(“fora”)

    -1

    (4)%格式化操作符 与c类似 多了括号和%

    name = ‘chen’

    print(‘my name is %s and my age is %d’ % (name,16))

    13.函数

    (1)def函数名(参数):

                    语句1    
    
                    语句2
    

    (2)global 关键字告诉编译器后面的变量是全局的 即使在内部改动也会影响外部的值

    def change():

    global a
    
    a = 90
    
    print(a)
    

    a = 9

    print("Before the function call ", a) #a=9

    print(“inside change function”, end=’ ')

    change() # a=90

    print("After the function call ", a) # a= 90

    如果没有global 函数内的a是局部变量,与外面的a没有关系

    (3)默认参数值

    def f(a , b=-99):

            pass
    

    注:1. 具有默认值的参数后面不能再有普通参数,比如 f(a,b=90,c) 就是错误的

        2. 默认值只被赋值一次,因此如果默认值是任何可变对象时会有所不同,比如列表、字典或大多数类的实例。例如,下面的函数在后续调用过程中会累积(前面)传给它的参数:
    
        deff(a, data=[]):  #默认参数是列表 可变的。
    
                data.append(a)
    
                return data
    
        print(f(1))
    
        [1]
    
       print(f(2))   #此时调用f(), data的默认值为[1]
    
       [1, 2]
    
       print(f(3))
    
       [1, 2, 3]
    

    要避免这个问题,你可以像下面这样:

    def f(a, data=None): #None不是可变对象,所以作为默认值时,data的值不会积累。

                                     #即下次调用f时,data值还是None。设置为data=123也是一样的效果。123是字面量,不                                       #可变,值不会积累
    
        if data is None:      
    
        data = []
    
        data.append(a)
    
        return data
    

    print(f(1)) # [1]

    print(f(2)) # [2]

    (4)关键字参数

    可变参数允许你传入0个或任意个参数,这些可变参数在函数调用时自动组装为一个tuple,而关键字参数允许你传入0个或任意个含参数名的参数,这些关键字参数在函数内部自动组装为一个dict。请看示例:

    def person(name, age, **kw):

    print('name:', name,'age:', age,'other:', kw)
    

    函数person除了必选参数name和age外,还接受关键字参数kw,前面两个**。在调用该函数时,可以只传入必选参数:

    person(‘Michael’,30)

    输出 name:Michaelage:30other:{}

    也可以传入任意个数的关键字参数:

    person(‘Bob’,35, city=‘Beijing’) # key=value 调用时若key,value均为字符串key不能加引号,value要加

    name:Bob age:35 other:{'city':'Beijing'}
    

    person(‘Adam’,45, gender=‘M’, job=‘Engineer’)

    name:Adam age:45 other:{'gender':'M','job':'Engineer'}
    

    关键字参数有什么用?它可以扩展函数的功能。比如,在person函数里,我们保证能接收到name和age这两个参数,但是,如果调用者愿意提供更多的参数,我们也能收到。试想你正在做一个用户注册的功能,除了用户名和年龄是必填项外,其他都是可选项,利用关键字参数来定义这个函数就能满足注册的需求。

    和可变参数类似,也可以先组装出一个dict,然后,把该dict转换为关键字参数传进去:

    extra = {‘city’:‘Beijing’,‘job’:‘Engineer’} #先组装一个dict

    person(‘Jack’,24, city=extra[‘city’], job=extra[‘job’])

        name:Jack age:24 other:{'city':'Beijing','job':'Engineer'}
    

    当然,上面复杂的调用可以用简化的写法:

    extra = {‘city’:‘Beijing’,‘job’:‘Engineer’}

    person(‘Jack’,24, **extra)

        name:Jack age:24 other:{'city':'Beijing','job':'Engineer'}
    

    extra表示把extra这个dict的所有key-value用关键字参数传入到函数的kw参数,kw将获得一个dict,注意kw获得的dict是extra的一份拷贝,对kw的改动不会影响到函数外的extra。

    (5)可变参数(列表参数)

    在Python函数中,还可以定义可变参数。顾名思义,可变参数就是传入的参数个数是可变的,可以是1个、2个到任意个,还可以是0个。
    我们以数学题为例子,给定一组数字a,b,c……,请计算a2 + b2 + c2 + ……。
    要定义出这个函数,我们必须确定输入的参数。由于参数个数不确定,我们首先想到可以把a,b,c……作为一个list或tuple传进来,这样,函数可以定义如下:
    def calc(numbers):
    sum = 0
    for n in numbers:
    sum = sum + n * n
    return sum

    但是调用的时候,需要先组装出一个list或tuple:
    calc([1, 2, 3])
    14
    calc((1, 3, 5, 7))
    84

    如果利用可变参数,调用函数的方式可以简化成这样:
    calc(1, 2, 3)
    14
    calc(1, 3, 5, 7)
    84

    所以,我们把函数的参数改为可变参数:
    def calc(*numbers):
    sum = 0
    for n in numbers:
    sum = sum + n * n
    return sum

    定义可变参数和定义一个list或tuple参数相比,仅仅在参数前面加了一个*号。在函数内部,参数numbers接收到的是一个tuple,因此,函数代码完全不变。但是,调用该函数时,可以传入任意个参数,包括0个参数:
    calc(1, 2)
    5
    calc()
    0

    如果已经有一个list或者tuple,要调用一个可变参数怎么办?可以这样做:
    nums = [1, 2, 3]
    calc(nums[0], nums[1], nums[2])
    14

    这种写法当然是可行的,问题是太繁琐,所以Python允许你在list或tuple前面加一个*号,把list或tuple的元素变成可变参数传进去:
    nums = [1, 2, 3]
    calc(*nums)
    14

    *nums表示把nums这个list的所有元素作为可变参数传进去。这种写法相当有用,而且很常见。

    (7)强制关键字参数

    defdog(name, host, *, age):

        print(name, host, age)
    

    参数中有一个 “*” 号,在该符号之后的所有参数(可一至多个)均被称为强制关键字参数,如果按照位置参数的方式对这些参数传值:

    dog(‘dobi’,‘xuzhoufeng’,2)

        TypeError: dog() takes 2 positional arguments but 3 were given
    

    就会出现 TypeError,正确的传值形式为:

    dog(‘dobi’, ‘xuzhoufeng’, age =2)

        dobi xuzhoufeng 2
    

    也即这里的age 必须使用关键字参数的形式进行传值。

    (8)map函数

    map 是一个在 Python 里非常有用的高阶函数。它接受一个函数和一个序列(迭代器)作为输入,然后对序列(迭代器)的每一个值应用这个函数,返回一个迭代器,不是现成的列表,其包含应用函数后的结果。

    举例:

    lst = [1,2,3,4,5]

    def square(num):

            returnnum * num
    

    print(list(map(square, lst)))

        [1,4,9,16,25]
    

    又:

    list(map(lambda x,y:x+y, [1,2,3,4], [1,2,3,4]))

    结果是 [2,4,6,8]

    (9) enumerate()函数

    用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中。

    list = [‘Spring’, ‘Summer’, ‘Fall’, ‘Winter’]

    for i, x in enumerate(list):

    print(i, x)
    

    输出:

    0 Spring

    1 Summer

    2 Fall

    3 Winter

    14.文件

    (1)open() close()

    r --只读

    r+ --打开一个文件用于读写。文件指针将会放在文件的开头

    w --以写入模式打开,如果文件存在将会删除里面的所有内容,然后打开这个文件进行写入

    w+ --打开一个文件用于读写。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该 文件不存在,创建新文件

    a --以追加模式打开,写入到文件中的任何数据将自动添加到末尾

    a+ --打开一个文件用于读写。如果该文件已存在,文件指针将会放在文件的结尾。文件打开时会是追加模式。如 果该文件不存在,创建新文件用于读写。

    file_object = open(‘filename’[,‘r/w/a’]) #open()返回一个对象,第一个参数为文件名,第二个默认为r。

    file_object.close() #用完一定要关闭

    (2)读取

    file_object.read([size]) #默认读完整个文件 返回的是字符串

    file_object.readline() #读一行

    file_object.readlines() #读所有行 以列表形式保存

    比如 file_object = open(‘sample.txt’)

    file_object.readlines()

    [‘I love Python\n’, ‘I love shiyanlou\n’]

    也可以循环的方式读

    for x in file_object:

    print(x, end='')   
    

    输出 :

    I love Python

    I love shiyanlou

    注:可以把读的结果给一变量 s = file_object.read() print(s)

    for i in file_object : # i 此时是一行一行的字符串

              pass
    

    for i in file_object.read() : # i 此时是一个一个的字符

               pass
    

    (3)write() 写入

    file_object = open(‘test.txt’,‘w’)

    file_object.write(‘this is a test\n’) # 'w’模式下会清空文件再写

    (4) sys模块中的argv sys.argv[]

    用于在命令行模式中获取参数

    假设sample.py 文件用于文件的拷贝

    
    import sys
    
    file1 = open(sys.argv[1])   #sys.argv[1]具体是什么要取决于命令传入的参数
    
    s = file1.read()
    
    file2 = open(sys.argv[2], 'w')
    
    file2.write(s)
    
    

    $ python3 sample.py newfile.py #此处即为命令行命令 第一个参数永远是文件路径及文件名第二个参数是 #sample.py 第三个是newfile.py

    则sys.argv[0] = 文件路径及文件名

    sys.argv[1] = sample.py
    

    sys.argv[2] = newfile.py

    (5)with语句

    with 语句处理文件对象,它会在文件用完后会自动关闭,就算发生异常也没关系。它是 try-finally 块的简写:

    with open(‘sample.txt’) as fobj:

         for line in fobj:
    
             print(line, end ='')
    

    输出:

    I love PythonI

    love shiyanlou

    15.异常 一定要看这篇博客https://www.cnblogs.com/wj-1314/p/8707804.html

    注:博客中没有提到的如下

    (1)try语句执行遇到错误会抛出给except捕获并保存当前pc,若捕获失败,则程序终止。捕获成功,执行该except下的语句,执行完后从原pc继续执行try语句

    异常处理是为了在程序运行发生错误时不让程序终止运行,而是抛出一个自定义的语句来提醒用户发生了错误,

    except用来捕捉程序运行时发生的错误。如果发生的错误没被except捕捉,则程序会直接结束,这样不好。

    while True:
    
        try:
    
            num =int(input('输入一个数:'))
    
            num =5/num
    
            print(num)
    
        except ZeroDivisionError:       
    
            print('输入数字不能为0')
    
    #当用户输入0,自然会产生异常,即ZeroDivisionError,若不用except捕捉,则直接回结束程序,不会给用户第二次输入的机会
    

    (2)else语句

    如果使用这个子句,那么必须放在所有的except子句之后。这个子句将在try子句没有发生任何异常的时候执行。例如:

    for arg in sys.argv[1:]:
    
        try:
    
            f = open(arg, 'r')    
    
        except IOError:
    
            print('cannot open', arg)    
    
        else:
    
            print(arg, 'has', len(f.readlines()), 'lines')        
    
    f.close()
    
    # 使用 else 子句比把所有的语句都放在 try 子句里面要好,这样可以避免一些意想不到的、而except又没有捕获的异常。
    

    (3)Exception是所有 NameError的基类

    
    try :
    
            .....
    
    except Exception:         捕捉Exception时,会捕捉所有的异常 等同于只写except
    
            .....
    

    (4) raise

    try:
    
        raise TypeError('类型错误')    #主动抛出一个TypeError型异常,是Exception的子类
    
    except Exception as e:        #由于是Exception是基类异常,所以会捕获所有try抛出的异常
    
        print(e)          
    
    输出:
    
    '类型错误'
    

    (5)except NameError as e

    e是NameError类的实例,与 except NameError 有区别

    (6)自定义异常类

    
    class MyError(Exception):
    
        def __init__(self,value):
    
            self.value = value
    
        def __str__(self):    #__str__魔法方法 会在实例被要求print()的时候被调用
    
            return self.value
    
    try:
    
        raise MyError('my error')     #self.value = 'my error'
    
    except MyError as e:    # e是MyError类的实例
    
        print(e)     #此处print()调用了e的__str__魔法方法
    

    (7)在真实场景的应用程序中,finally 子句用于释放外部资源(文件或网络连接之类的),无论它们的使用过程中是否出错。

    16.类

    (1)语法

    class nameoftheclass(parent_class):

    statement1    
    
    statement2    
    
    statement3
    

    (2)__init__(self[,v1[,v2…])

    类的实例化操作会自动为新创建的类实例调用 __init__() 方法

    class Complex:

     def__init__(self, realpart, imagpart):
    
           self.r = realpart
    
           self.i = imagpart
    

    x = Complex(3.0, -4.5)

    x.r, x.i

    (3.0, -4.5)

    (3)self

    self代表类的实例,即当前对象的地址,而非类。类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。

    (4) 子类调用父类的方法的两种形式

    如下代码中的???处进行父类方法调用

    class Person:

    def __init__(self, name):
    
            self.name = name
    
    def ps(self):
    
            print('my name is {}'.format(self.name))
    

    class Student(Person):

        def __init__(self,name,age,sex):
    
                ???
    
                self.age = age
    
                self.sex = sex
    
         def ps1(self):
    
                print('my name is {} , my age is {}, my sex is {}'.format(self.name,self.age,self.sex))
    

    第一种是直接法。使用父类名称直接调用,形如 parent_class.parent_attribute(self),对应例程即语句:

                                   Person.__init__(self,name)   #一定要有self 
    
     第二种是通过super函数,形如 super(child_class, child_object).parent_attribute(arg)。第一个参数表示调用父类的起始处,第二个参数表示类实例(一般使用self),父类方法的参数只有self时,参数args不用写。此外,类内部使用时,child_class, child_object也可省略。对应例程:
    

    super(Student,self).__init__(name)

    或者:

    super().__init__(name)

    在类外面也可使用super函数,但是要有child_class, child_object两个参数。

    (5) 装饰器 https://www.zhihu.com/question/26930016
    首先明确 func与func()

    函数只写函数名表示函数对象本身,加上括号表示执行这个函数

    很多时候,你需要对一段代码加上权限认证,加上各种功能;但是又不想,或者不方便破坏原有代码,则可以用装饰器去扩展它。比如play()函数默认播放动画片,现在规定年龄范围内的才能看,可以不用改动play()函数,使用装饰器

    userAge=40
    
    
    
    def canYou(func):
    
            def decorator(*args,**kwargs):
    
                if userAge > 1 and userAge < 10:
    
                    return func(*args,**kwargs)   #func加了括号,说明返回的是对这个函数的执行
    
                print('你的年龄不符合要求,不能看')
    
             return decorator       #返回的是函数对象decorator,相当于一个变量,没有执行这个函数
    
    
    
    @canYou    # @为语法糖  实际为 play = canYou(play),在函数定义后执行。  执行后,play指向了decorator这个对
    
                        #象。此时的play不再是原来的单一功能的函数,而是一个有了年龄判断功能的新函数
    
    def play():
    
        print('开始播放动画片 《喜洋洋和灰太狼》')
    
    
    
    play()
    
    #输出
    
    #你的年龄不符合要求,不能看
    
    #你可以修改上面的 userAge 为9 试试
    
    
    装饰器的执行顺序:装饰器由下到上依次立马执行,之后我们调用的f已经是被装饰器执行了之后的f了,此时是由上到下返回去依次调用wrapper。整个过程有点像先上楼梯(装饰过程),再下楼梯(调用函数)https://segmentfault.com/a/1190000007837364
    def decorator_a(func):
        print 'Get in decorator_a'
        def inner_a(*args, **kwargs):
            print 'Get in inner_a'
            return func(*args, **kwargs)
        return inner_a
    
    def decorator_b(func):
        print 'Get in decorator_b'
        def inner_b(*args, **kwargs):
            print 'Get in inner_b'
            return func(*args, **kwargs)
        return inner_b
    
    @decorator_b
    @decorator_a    #f作为参数传入装饰器a,返回inner_a函数对象给f,同时
    				#装饰器a返回的inner_a作为参数传入装饰器b。返回inner_b给inner_a
    def f(x):
        print 'Get in f'
        return x * 2
    
    f(1)
    #输出
    #Get in decorator_a
    #Get in decorator_b
    #Get in inner_b
    #Get in inner_a
    #Get in f
    
    
    

    整个流程:

    • f(1)执行,装饰器decorator_b启动
    • print ‘Get in decorator_a’ 打印,并且return一个函数inner_a
    • 接着,这个函数inner_a被decorator_b装饰掉,于是
    • print ‘Get in decorator_b’ 打印,再次return一个函数inner_b
    • 因此,绕回来理解整个流程,f(1)调用了inner_b,打印了Get in inner_b
    • 再执行了函数inner_a,打印了Get in inner_a
    • 再执行了f函数,打印了Get in f
    类装饰器

    https://blog.csdn.net/gavin_john/article/details/50923988

    17.模块http://www.runoob.com/python3/python3-module.html

    (1)创建一个module.py文件。再import module即可
    通过module.func()来使用函数。
    或者from module import func,func2,func3再直接调用func()

    (2)__name__属性
    一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行。即在模块中添加

    	if __name__ == '__main__':
    		.....
    

    因为当模块被引入时,模块的__name__属性值不是__main__ 。这样避免了模块被引入时就执行其中的代码

    #!/usr/bin/python3
    #Filename: using_name.py
    
    if __name__ == '__main__':
       print('程序自身在运行')
    else:
       print('我来自另一模块')
    运行输出如下:
    
    $ python using_name.py
    程序自身在运行
    $ python
    import using_name
    我来自另一模块
    

    每个模块都有一个__name__属性,当其值是’__main__'时,表明该模块自身在运行,否则是被引入。

    (3)包

    __init__.py文件内的__all__变量

    18.迭代器,生成器, 闭包

    (1)迭代器

    Iterator:可以被next()函数调用并不断返回下一个值的对象称为迭代器

    生成器是迭代器,即
    isinstance((x*x for i in range(10)), Iterator)返回True

    next()方法只能给迭代器对象用
    Iterable:可以直接作用于for循环的对象统称为可迭代对象

    list , dict , str等是可迭代的,但不是迭代器(使用isinstance([1,2,3] ,Iterable)判断)。因为Python的Iterator对象表示的是一个数据流,Iterator对象可以被next()函数调用并不断返回下一个数据,直到没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序序列,但我们却不能提前知道序列的长度,只能不断通过next()函数实现按需计算下一个数据,所以Iterator的计算是惰性的,只有在需要返回下一个数据时它才会计算。

    Iterator甚至可以表示一个无限大的数据流,例如全体自然数。而使用list是永远不可能存储全体自然数的。

    使用iter()可以将可迭代对象变为迭代器
    isinstance(iter([]), Iterator)返回True

    for循环原理就是利用next()不断取值
    for x in [1,2,3,4,5]:
    	pass
    
    # 相当于如下代码
    
    it = =iter([1,2,3,4,5])
    while True:
    	try:
    		x = next(it)
    	except StopIteration:
    		break
    		
    
    类迭代器

    把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__() 。
    __iter__() 方法返回一个特殊的迭代器对象, 这个迭代器对象实现了 __next__() 方法并通过 StopIteration 异常标识迭代的完成。

    __\next__() 方法(Python 2 里是 next())会返回下一个迭代器对象。
    简而言之,__iter__() 方法返回的是类实例本身(self),__next__()方法则是对功能的具体实现,返回要被打印的变量

    
    
    class Numbers:
    	def __init__(self,low,high):
    		self.low = low
    		self.high = high
    	
    	def __iter__(self):
    		return self
    	
    	def __next__(self):
    		if self.low > self.high:
    			raise StopIteration
    		else:
    			self.low += 1
    			return self.low-1
    
    
    temp = Numbers(1,6)   #此时实例temp就是迭代器对象
    #可以for循环
    '''for i in temp:
    	print(temp)
    '''
    
    #可以用next()
    '''while True:
    	try:
    		print(next(temp))
    	except StopIteration as e:
    		print('迭代结束')
    '''
    
    
    
    

    (2)生成器 generator
    https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/0014317799226173f45ce40636141b6abc8424e12b5fb27000
    生成器不但可以作用于for循环,还可以被next()函数不断调用并返回下一个值,直到最后抛出StopIteration错误表示无法继续返回下一个值了。

    简单的生成器

    (x**2 for i in range(0,10)) 与列表生成时很像 但是圆括号
    通过next(g)调用,调用到头会产生StopIretation异常
    或者用for in调用

    函数形式生成器 yield关键字,generator function

    若func为生成器,则 f = func(*argv, **kw) f为generator对象,不是func执行后的结果
    因为此时func是生成器,不是常规的函数

    (3)闭包

    闭包(Closures)是由另外一个函数返回的函数。我们使用闭包去除重复代码。在下面的例子中我们创建了一个简单的闭包来对数字求和。

     def add_number(num):
         def adder(number):
             #adder 是一个闭包
             return num + number
         return adder
    
     a_10 = add_number(10)
     a_10(21)  # 31
     a_10(34)  # 44
     a_5 = add_number(5)
     a_5(3)   # 8
    
    
    
    19 多线程

    https://www.jb51.net/article/155731.htm

    1. threadname.join()
      在某个线程t中调用另一个线程t2的join方法,相当于会等t2执行完后再执行t。这将阻塞调用线程,直到拥有join()方法的线程的调用终止。
    import threading
    import time
    def fun1():
       print('fun1 start\n')
       time.sleep(1.5)
       print('func1 done\n')
    
    
    def fun2():
       print('fun2 start\n')
       time.sleep(4)
       print('func2 done\n')
    
       
    
    def main():
       t1 = threading.Thread(target=fun1, name='fun1')  # 添加线程,调用threading模块的Thread方法
       t2 = threading.Thread(target=fun2, name='fun2')
       t1.start()
       t2.start()
       t1.join()
       print('main start\n')
       print('main done\n')
    
    
    if __name__ == '__main__' :
       main()
    
    输出
    fun1 start
    fun2 start
    
    
    func1 done
    
    main start
    
    main done
    
    func2 done
    
    1. threading.Thread
      class Thread(group=None, target=None, name=None, args=(), kwargs={})

    group 应当为 None,为将来实现Python Thread类的扩展而保留。

    target 是被 run()方法调用的回调对象. 默认应为None, 意味着没有对象被调用。

    name 为线程名字。默认形式为’Thread-N’的唯一的名字被创建,其中N 是比较小的十进制数。

    args是目标调用参数的tuple,默认为空元组()。

    kwargs是目标调用的参数的关键字dictionary,默认为{}。

    Python连接数据库的步骤

    1)建立数据库连接 (db = pymysql.connect(…))

    2)创建游标对象 (c = db.cursor())

    3)游标方法 (c.execute(sql语句))

    4)提交到数据库 (db.commit())

    5)关闭游标对象 (c.close())

    6)关闭数据库 (db.close())

    connect对象

              1)db=pymysql.connect(参数列表)
    
                    参数列表有:
    
                    1. host : 主机地址,本地地址 localhost
    
                    2. port : 端口号 ,默认为3306
    
                    3. user : 用户名
    
                    4. password : 密码
    
                    5. database : 要连接到的库
    
                    6. charset : 编码方式,推荐使用 utf8
    
              2)数据库连接对象(db)的方法
    
                   1.db.close()    关闭连接
    
                   2.db.commit()    提交到数据库执行
    
                   3.db.rollback()  回滚
    
                   4.db.cursor()    返回游标对象,用于具体执行
    
                   SQL命令
    
              3)游标对象(cur)的方法
    
                   1.cur.execute(SQL命令,[列表])   执行SQL命令
    
                   2.cur.close()            关闭游标对象
    
                   3.cur.fetchone()  获取查询结果集的第一条数据
    
                                     【获取结果为一个元组】
    
                   4.cur.fetchmany(n)  获取查询结果集的第n条数据
    
                      【获取结果为一个元组 如:((记录1),(记录2))】
    
                   5.cur.fetchall()    获取所有记录(结果为元组)
    
                   注意:
    
                   fetchone , fetchmany , fetchall 均获取一条记录少一条记录
    
    展开全文
  • Python使用pymysql小技巧

    1970-01-01 08:00:00
    pymsql是Python中操作MySQL的模块,其使用方法和MySQLdb几乎相同。但目前pymysql支持python3.x而后者不支持3.x版本。
  • python -pymysql的操作

    2019-07-24 14:27:21
    安装 导入模块,生成对象 查看源码,了解传参情况 查看连接对象的属性情况 代码 import pymysql # 获取连接对象 Connection类的对象 conn = pymysql.connect( ... db="python05" ) ...

    安装

    在这里插入图片描述

    安装不成功的情况,

    linux
    Linux中Python3.6.6使用pip3安装第三方库报错pip is configured with locations that require TLS/SSL_综合技术_张晨的个人博客
    http://www.zhangc.cn/?id=94

    windows

    C:\Users\56989\Anaconda3\Scripts
    C:\Users\56989\Anaconda3\Library\bin
    C:\Users\56989\Anaconda3

    导入模块,生成对象

    查看源码,了解传参情况
    在这里插入图片描述

    查看连接对象的属性情况

    代码

    import pymysql
    
    # 获取连接对象 Connection类的对象
    conn = pymysql.connect(
        host="127.0.0.1",
        port=3306,
        user="root",
        passwd="root",
        db="python05"
    )
    
    print(conn)
    print("===",conn.host)
    for k,v in conn.__dict__.items():   # 字典.items()
        print("{}--{}".format(k,v))
    
    
    

    结果

    C:\Users\python_hui\Anaconda3\python.exe G:/1907易学习知识系统/数据库练习/main.py
    <pymysql.connections.Connection object at 0x000001F671F04E10>
    === 127.0.0.1
    _local_infile–False
    ssl–False
    host–127.0.0.1
    port–3306
    user–b’root’
    password–b’root’
    db–b’python05’
    unix_socket–None
    bind_address–None
    connect_timeout–10
    _read_timeout–None
    _write_timeout–None
    charset–utf8mb4
    use_unicode–True
    encoding–utf8
    client_flag–3842573
    cursorclass–<class ‘pymysql.cursors.Cursor’>
    _result–None
    _affected_rows–0
    host_info–socket 127.0.0.1:3306
    autocommit_mode–False
    encoders–{<class ‘bool’>: <function escape_bool at 0x000001F672FB6488>, <class ‘int’>: <function escape_int at 0x000001F672FB6598>, <class ‘float’>: <function escape_float at 0x000001F672FB6620>, <class ‘str’>: <function escape_unicode at 0x000001F672FB6840>, <class ‘tuple’>: <function escape_sequence at 0x000001F672FB6378>, <class ‘list’>: <function escape_sequence at 0x000001F672FB6378>, <class ‘set’>: <function escape_sequence at 0x000001F672FB6378>, <class ‘frozenset’>: <function escape_sequence at 0x000001F672FB6378>, <class ‘dict’>: <function escape_dict at 0x000001F672FB62F0>, <class ‘NoneType’>: <function escape_None at 0x000001F672FB6950>, <class ‘datetime.date’>: <function escape_date at 0x000001F672FB6B70>, <class ‘datetime.datetime’>: <function escape_datetime at 0x000001F672FB6AE8>, <class ‘datetime.timedelta’>: <function escape_timedelta at 0x000001F672FB69D8>, <class ‘datetime.time’>: <function escape_time at 0x000001F672FB6A60>, <class ‘time.struct_time’>: <function escape_struct_time at 0x000001F672FB6BF8>, <class ‘decimal.Decimal’>: <function escape_object at 0x000001F672FB6510>, <class ‘bytes’>: <function escape_bytes at 0x000001F672FB67B8>}
    decoders–{16: <function through at 0x000001F672FC00D0>, 1: <class ‘int’>, 2: <class ‘int’>, 3: <class ‘int’>, 4: <class ‘float’>, 5: <class ‘float’>, 8: <class ‘int’>, 9: <class ‘int’>, 13: <class ‘int’>, 7: <function convert_mysql_timestamp at 0x000001F672FB6F28>, 12: <function convert_datetime at 0x000001F672FB6D08>, 11: <function convert_timedelta at 0x000001F672FB6D90>, 10: <function convert_date at 0x000001F672FB6EA0>, 248: <function convert_set at 0x000001F672FC0048>, 252: <function through at 0x000001F672FC00D0>, 249: <function through at 0x000001F672FC00D0>, 250: <function through at 0x000001F672FC00D0>, 251: <function through at 0x000001F672FC00D0>, 254: <function through at 0x000001F672FC00D0>, 253: <function through at 0x000001F672FC00D0>, 15: <function through at 0x000001F672FC00D0>, 0: <class ‘decimal.Decimal’>, 246: <class ‘decimal.Decimal’>}
    sql_mode–None
    init_command–None
    max_allowed_packet–16777216
    _auth_plugin_map–{}
    _binary_prefix–False
    server_public_key–None
    _connect_attrs–{’_client_name’: ‘pymysql’, ‘_pid’: ‘7400’, ‘_client_version’: ‘0.9.3’}
    _closed–False
    _sock–<socket.socket fd=484, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=(‘127.0.0.1’, 57700), raddr=(‘127.0.0.1’, 3306)>
    _rfile–<_io.BufferedReader name=484>
    _next_seq_id–2
    protocol_version–10
    server_version–8.0.16
    server_thread_id–(26,)
    salt–b’3Rxl+\x01n\x0f\x0ec\x07R8\x0e4X *D1’
    server_capabilities–3288334335
    server_language–255
    server_charset–utf8mb4
    server_status–0
    _auth_plugin_name–caching_sha2_password

    Process finished with exit code 0

    获取游标对象

    游标对象相当于是光标对象

    操作数据表的各种行动。都要通过这个游标对象

    在这里插入图片描述
    可色儿

    游标对象 = 数据库连接对象.cursor( )
    

    写sql语句

    游标对象.execute(strSQL语句)
    

    例子

    cur = conn.cursor()
    
    sql = "insert into stu values (0, '五狗子', 3)"
    # sql = "insert into stu values (0, '{}', 3)".format(name)
    
    cur.execute(sql)
    conn.commit()
    print("数据插入成功")
    

    结果

    在mysql对应的表中,成功可以查到插入的数据
    在这里插入图片描述

    》注意

    当插入语句执行以后, 一定要让

    数据库的连接对象调一下commit()方法, 提交我们的修改操作

    否则,数据是查入不成功的

    关闭对象

    游标对象关闭

    cursor.close()

    连接对象关闭

    conn.close()

    当前阶段的完整代码

    import pymysql
    
    # 获取连接对象 Connection类的对象
    # 连接对象 = 模块名.函数名(参数)
    conn = pymysql.connect(
        host="127.0.0.1",
        port=3306,
        user="root",
        passwd="root",
        db="python05"
    )
    
    # 获取游标对象
    cur = conn.cursor()
    
    # sql语句
    sql = "insert into stu values (0, '八狗子', 3)"
    # sql = "insert into stu values (0, '{}', 3)".format(name)
    
    res = cur.execute(sql)
    print("游标对象的execute返回结果", res)
    conn.commit()
    
    print("数据插入成功")
    
    
    

    注意,需要改一改数据库的相关设置

    查询数据

    res = 游标对象.execute(SQL查询语句)

    res是获取的数据条件,例如获取了8条数据,res就是8

    查询语句执行后,结果会保留在游标对象中

    获取游标对象中的查询结果

    在这里插入图片描述

    获取一条,fetchone()
    
    获取所有,fetchall()
    
    获取多条,fetchmany(条数)
    
    

    光标在结果中移动

    光标的相对移动

    如果位移数值为负值,向上移动,为正值,向下移动。 相对于当前的光标位置的。

    光标对象.scroll(位移数值, mode="relative")
    

    光标的绝对移动

    查询的结果按照索引0开始计数

    光标对象.scroll(位移索引值, mode="absolute")
    

    改变输出的结果

    默认的查询结果是元组

    例如,(3, ‘二狗子’, 3)

    但是我们如果不查数据表, 是不明确这些数据的意义的

    理想的数据是有意义标记的数据,就是字典

    例如, {‘id’: 3, ‘name’: ‘二狗子’, ‘tid’: 3}

    解决办法, 定义游标对象的时候,传递参数,明确游标的类型

    cur = conn.cursor(cursor=pymysql.cursors.DictCursor)
    
    意思是说,连接对象conn它的cursor函数的返回值是字典类型的游标对象DictCursor
    

    设置后,查询后得到的结果就是字典的类型

    展开全文
  • 给大家演示了如何安装以及使用Python中操作mysql的pymysql模块,本文介绍的很详细,对大家学习Python具有一定参考借鉴价值,有需要的朋友们一起来看看吧。
  • Python安装PyMysql客户端

    千次阅读 2017-04-18 19:22:43
    Python貌似有好几个mysql模块,但是比较好用而且容易上手安装的貌似就它了。。。。。 pymysql下载地址: https://pypi.python.org/packages/source/P/PyMySQL3/PyMySQL3-0.5.tar.gz

    Python貌似有好几个mysql模块,但是比较好用而且容易上手安装的貌似就它了。。。。。
    pymysql下载地址:
    https://pypi.python.org/packages/source/P/PyMySQL3/PyMySQL3-0.5.tar.gz
    这里写图片描述

    这里写图片描述

    展开全文
  • Python3 * 和 ** 运算符

    万次阅读 多人点赞 2018-06-05 11:07:40
    Python 中,* 和 ** 具有语法多义性,具体来说是有三类用法。1. 算数运算* 代表乘法** 代表乘方&gt;&gt;&gt; 2 * 5 10 &gt;&gt;&gt; 2 ** 5 322. 函数参数*args 和 **kwargs 主要用于...
  • python语言介绍

    千次阅读 多人点赞 2018-11-15 21:11:02
    Python是一种动态的、面向对象的脚本语言,最初被设计用于编写自动化脚本(shell),随着版本的不断更新和语言新功能的添加,越来越多被用于独立的、大型项目的开发。 发展历程  自从20世纪90年代初Python语言诞生...
  • python安装教程

    万次阅读 多人点赞 2018-06-07 15:44:54
    Python安装教程一、博主自言随着人工智能的快速发展,python语言越来越受大家的欢迎,博主前段时间先自学了一次,这次再次巩固,顺便分享给大家我遇到的坑。帮助大家学习的时候少走弯路。希望会对大家有所帮助,欢迎...
  • python-打印完数

    千次阅读 2019-01-19 21:35:22
    打印完数:一个数如果恰好等于它的因子之和,这个数就称为"完数"。例如 6 = 1+2+3。(10分) 题目内容: 输入一个正整数n(n&lt;1000),输出1到n之间的所有完数(包括n)。...时间限制:500ms内存...
  • Python中输入多行字符串

    千次阅读 2020-03-03 11:49:04
    方法一:使用三引号 >>> str1 = '''Le vent se lève, il faut tenter de vivre.... 起风了,唯有努力生存。 (纵有疾风起,人生不言弃。...'Le vent se lève, il faut tenter de vivre....
  • 最新Python学习路线+千锋Python课程大纲+Python视频教程+Python学习资料下载地址大合集 目前Python已经成为最受欢迎的程序设计语言之一。Python的设计哲学是“优雅”、“明确”、“简单”。 Python的优点(来自...
  • Python数据分析与机器学习实战教程,该课程精心挑选真实的数据集为案例,通过python数据科学库numpy,pandas,matplot结合机器学习库scikit-learn完成一些列的机器学习案例。课程以实战为基础,所有课时都结合代码演示...
  • VSCode配置Python开发环境

    万次阅读 多人点赞 2018-08-10 01:17:44
    之前编写Python更多的是使用pycharm作为编译器进行开发,但是个人感觉用起来比较笨重,而且还收费的,需要进行破解才能使用。后来发现vscode这个软件,觉得很轻便,而且和之前使用的vs2018风格一样。 在这里对...
  • 本课程提供零基础的孩子学习编程,学习Python语言的基本知识,讲课内容通俗易懂,结合大量的实例,让孩子更容易理解编程中的一些概念。 学会本课程后,孩子能看懂一般的Python代码,并能写简单的程序,学会编程...
1 2 3 4 5 ... 20
收藏数 3,177,737
精华内容 1,271,094
关键字:

python