python 继承

一、简介

1、作用

简化代码

2、分类

一个父类可以被多个多个子类继承

一个子类可以继承多个父类—python独有

3、新式类和经典类

python3中,只含义新式类,新式类默认继承Object

python2.7中含义经典类和新式类,新式类需要继承Object

4、方法

类名.__base__查看该类的继承顺序

类.mro(),返回类的调用顺序

class A:
    print('A')


class B(A):
    print('B')


class C(A):
    print('C')


class D(B, C):
    print('D')


print(D.__bases__)      # (<class '__main__.B'>, <class '__main__.C'>)
print(D.mro())      # [<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

二、单继承

1、派生

派生属性:在子类中,创建父类中没有的属性

派生方法:在子类中,创建父类中没有的方法

2、顺序

1)子类对象的调用顺序

子类属性、方法,若没有到父类的属性、方法,若没有到Object,若没有,则报错

2)调用父类

1)通过子类对象调用,若子类有同名方法,会调用子类的方法

2)通过父类名直接调用父类

3)使用super(类名, 已定义的对象名).类方法名

3、用父类的属性、方法

1)父类名.__init__(self, 父类的其它属性)

2)super().__init__(父类的其它属性)

4、super()

super()方法只在python3中存在

在类内部可以不写()内的类名和对象名

super()的本质:不是单纯找父类,而是根据调用者的节点位置的广度优先顺序来的

class Person:
    def __init__(self, name, sex, age):
        self.name = name
        self.sex = sex
        self.age = age

    def introduce(self):
        print('父类方法', self.name)


class Student(Person):
    def __init__(self, name, sex, age, grade):
        Person.__init__(self, name, sex, age)       # 通过父类直接调用__init__方法
        self.grade = grade      # 派生属性

    def gr(self):       # 派生方法
        print(self.grade)


class Worker(Person):
    def __init__(self, name, sex, age, money):
        super(Worker, self).__init__(name, sex, age)    # Worker, self 可以不写
        self.money = money      # 派生属性

    def make(self):     # 派生方法
        print(self.money)


s1 = Student('tom', 'man', 24, 99)
s1.gr()     # 99
print(s1.name)      # tom
s1.introduce()      # 父类方法 tom, 调用父类方法,若子类有同名方法,会调用子类的方法
Person.introduce(s1)    # 调用父类方法
super(Student, s1).introduce()  # 调用父类方法

三、多继承

1、一个子类继承多个父类

2、调用顺序

默认是就近原则

新式类:广度优先

经典类:深度优先

3、新式类

1)钻石继承

class D:
    print('D')


class B(D):
    print('B')
    
    
class C(A):
    print('D')
    
    
class A(B, C):
    print('A')

2)

3)

 

 4、经典类

深度优先,一条路走到黑

 ps:组合和继承怎么抉择?

  组合:什么有什么

  继承:什么是什么

python学习第7天

学习了python基础知识已经七天了,囊括 了很多知识点,今日老师带着我们理了一遍高级游戏的程序逻辑,把我们这几天学习的东西用上了,接下要真正得成为一名码农了,好好纪念一下
首先说一下该游戏的功能,大咖如果觉得有更好的代码精简,可以探讨一下

编写猜年龄游戏,有以下要求:

  1. 可能会有用户会在输入年龄之后不小心输入空格,如18   ,请做处理
  2. 可能会有用户会恶意输入导致程序报错,如逗你玩呀,请做处理
  3. 如果用户3次没有猜对,可以选择继续玩或退出(自定义退出条件)
  4. 如果用户猜对了,可以在以下奖品中选择两件奖品(一次只能选择一件奖品):{0:'布娃娃',1:'变形金刚',2:'奥特曼',3:'<python从入门到放弃>'}
  5. 用户选择奖品后退出程序,用户也可以不选择奖品直接退出程序。
age = 18  # 答案
count = 0  # 游戏次数控制
prize_dict = {
    0:'布娃娃',
    1:'变形金刚',
    2:'奥特曼',
    3:'<Python从入门到放弃>'
}

# 核心代码
while count < 3:
    inp_age = input('请输入你的年龄>>>').strip()  # 与用户交互

    # 判断用户是否骚扰
    if not inp_age.isdigit():
        print('傻逼,你的年龄输错了')
        continue

    inp_age_int = int(inp_age)

    # 核心逻辑,判断年龄
    if inp_age_int == age:
        print('猜对了')
        
        print(prize_dict)  # 打印奖品
        
        # 获取两次奖品
        for i in range(2):
            prize_choice = input('请输入你想要的奖品,如果不想要,则输入"n"退出!!!').strip()  # 与用户交互获取奖品
            
            # 判断是否需要奖品
            if prize_choice != 'n':
                print(f'恭喜你获得奖品: {prize_dict[int(prize_choice)]}')
            else:
                break
       break
       
    elif inp_age_int < age:
        print('猜小了')
    else:
        print('猜大了')
    
    count += 1  # 成功玩一次游戏
    
    if count != 3:
        continue
        
    again_choice = input('是否继续游戏,继续请输入"Y",否则任意键直接退出.').strip() # 交互是否再一次

    # 判断是否继续
    if again_choice == 'Y':
        count = 0

python 0基础起步学习day1

python是强类型语言,字符串和数字连接,他不会自己转化成字符串,因此会报错。   #注释    不要分号结尾

 

缩进是Python的灵魂,缩进有问题导致程序错误

输入dir(__builtins__)可以查看python所有内置函数                  dir(list)#就会返回list列表的所有函数….以此类推哦~~

输入help(input)等会显示该内置函数的意思

 input() 》if : else : //缩进是python的灵魂,切记、切记

 和C#中字符串@符号一样,python中用r来让字符串默认不区分转义字符

  三引号括起来的字符串可以自动帮我们换行等等,即可打印多行字符串.

 

python也是都是英文符号,中文就会出错,和C#一样

 

条件分支

1.if 条件:

  条件为true执行的操作

else:

  条件为false执行的操作

2.while循环 

3if — elif —else:        #(pythoy中用elif代替elseif)

 

 

 

引入外援

random模块

randint(),会返回一个随机的整数

 其中最上面import random是引入random模块   #和C#的using差不多意思

第二行是调用random模块中的randint函数(1,10) #生成1到10之间的一个随机整数

 类型转换

整型int()

字符串str()

浮点数float()

字节byte()等…

 type()          #返回类型                      type(a)><class ‘int’>

 isinstance()       #返回True和False   isinstance(b,float)>True

 

 

python也支持+=          -=      ( /= 》浮点型) …..这些

**为次幂的意思   2**3》8

//是省略小数点后位数的除法  #4//2》2【整型】    4.2//2》2.0【浮点型】

 

算术运算符的优先级是先乘除再加减,有括号先括号

算书运算符优先级高于比较运算符的优先级

 

逻辑运算符

and/or/not

 

pythoy这都可以

 

 

 

 

 

 

 

 

循环

 1.while

2.for

由此可见print写成print(i,end=’,’).会打印在一行切每个以end中的字符串来分割开,len()计算长度

for 和js中for很像

                                

 

 range()

 经常和for一起用

 

#不包括最后一个参数值

 

和for一起用   切记range(2,9)是不包含9,就是不包含最后一个数字的,只有一个参数,默认从0开始

 break #终止循环

continue #跳过本次循环

                        

 

 

列表:一个打了激素的数组

创建列表

 创建列表》》

向列表添加元素

1.append()  #只能接受一个参数 向列表后插入

2.extend()  #使用一个列表来扩展另一个列表,它只能接受一个参数且为列表    向列表后插入

 》》如果少的话这样写就可以

 

3.insert(列表中的位置索引,插入的元素)

 

 列表获取元素 #通过索引

列表删除元素

1.remove(元素名)     #arr.remove(‘小甲鱼’)只会删除第一个匹配项。   如果没有这个元素名,会报错!

2.del()                     #del arr[1]    del arr#删除整个列表,把列表从内存中剃掉

3.pop()                    #arr.pop()  #删除并返回最后一个元素                arr.pop(1) #删除并返回该索引的元素

 

列表分片(slice)

       拷贝原列表中的一段元素返回一个新列表

 

arrNew=arr[1:]  #从arr列表截取从索引值1开始到最后,返回一个新列表arrNew,对arr无影响

arr[:]                 #得到一个arr列表的拷贝!!!

 

 

列表之间比较是默认从第0个索引开始比较,只要有一个PK赢了,后面就不会比较【就是理解成就是第0个索引之间比较】

 

+   #列表也可以拼接(加号两边对象类型必须是一样的)

*  #list3复制3次并返回新列表

 

in      #检查列表是否有此元素

 in只能检查一层,即我现在检验这个列表,就检验这个列表直接元素有没有我检查的这个元素,即使列表的元素中包含这个元素也不会返回True

 

 列表的小伙伴们

  列表的内置方法

 

 count(元素名) # 检查该元素名在该列表中出现的次数

index  #返回该元素在列表中的位置

  index(元素,起始搜索位置,结束搜索位置)  #只会返回范围内第一个匹配项索引

reverse   #原地翻转

  list3.reverse()

              #func制定算法         key和算法搭配的关键字

sort(reverse=True)    #从大到小

 

 

通过列表分片得到的list3相当于取走了list1的数据,在自己的天地里不受list1的干扰,而list2和list1是引用类型的意思,指向同一块内存地址,因此list1变化,list2也会变化,而list3则不会

由此可见拷贝分片的重要性

拷贝的时候要用分片的方法!!!切记切记!!!!!

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Python学习笔记(一)

之前没有养成习惯,以后学习Python会在这里做好记录。

本节只记录学习过程中的自认为的关键点。

一.安装环境

直接从Python3.0上手,

具体环境配置,参考菜鸟教程,链接: https://www.runoob.com/python3/python3-install.html 。

具体的IDE使用的官网推荐的Pycharm,安装包及安装方式网上随便搜索,照着做就行了。

二.基础语法

Python是一种简洁又强力的面向对象的计算机编程语言。简洁指其代码风格,Python的设计哲学是优雅、明确和简单,最好只用一种方法来做一件事,具有更好的可读性。而面向对象指Python在设计时是以对象为核心的,其中的函数、模块、数字、字符串都是对象,有益于增强源代码的复用性。(引用自:https://blog.csdn.net/weixin_40796925/article/details/86247878)Python是解释型脚本语言,这一点与Matlab语言有些类似的特征。该语言的特点可以参考前面放的链接。

以下内容整理自https://www.runoob.com/python3/python3-basic-syntax.html

编码

Python 3 源码文件以 UTF-8 编码,所有字符串都是 unicode 字符串。 当然你也可以为源码文件指定不同的编码:

# -*- coding: cp-1252 -*-

上述定义允许在源文件中使用 Windows-1252 字符集中的字符编码,对应适合语言为保加利亚语、白罗斯语、马其顿语、俄语、塞尔维亚语。

标识符

  • 第一个字符必须是字母表中字母或下划线 _ 。
  • 标识符的其他的部分由字母、数字和下划线组成。
  • 标识符对大小写敏感。

在 Python 3 中,非 ASCII 标识符也是允许的了。

python保留字

保留字即关键字,我们不能把它们用作任何标识符名称。Python 的标准库提供了一个 keyword 模块,可以输出当前版本的所有关键字:

>>> import keyword >>> keyword.kwlist ['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

注释

Python中单行注释以 # 开头,实例如下:

实例(Python 3.0+)

#!/usr/bin/python3 # 第一个注释 print (Hello, Python!) # 第二个注释

执行以上代码,输出结果为:

Hello, Python!

多行注释可以用多个 # 号,还有 ”’ 和 “””:

实例(Python 3.0+)

#!/usr/bin/python3 # 第一个注释 # 第二个注释 ”’ 第三注释 第四注释 ”’ “”” 第五注释 第六注释 “”” print (Hello, Python!)

执行以上代码,输出结果为:

Hello, Python!

行与缩进

python最具特色的就是使用缩进来表示代码块,不需要使用大括号 {} 。

缩进的空格数是可变的,但是同一个代码块的语句必须包含相同的缩进空格数。实例如下:

实例(Python 3.0+)

if True: print (True) else: print (False)

以下代码最后一行语句缩进数的空格数不一致,会导致运行错误:

if True: print ("Answer") print ("True") else: print ("Answer") print ("False") # 缩进不一致,会导致运行错误

以上程序由于缩进不一致,执行后会出现类似以下错误:

 File "test.py", line 6 print ("False") # 缩进不一致,会导致运行错误 ^ IndentationError: unindent does not match any outer indentation level

多行语句

Python 通常是一行写完一条语句,但如果语句很长,我们可以使用反斜杠(\)来实现多行语句,例如:

total = item_one + \ item_two + \ item_three

在 [], {}, 或 () 中的多行语句,不需要使用反斜杠(\),例如:

total = ['item_one', 'item_two', 'item_three', 'item_four', 'item_five']

数字(Number)类型

python中数字有四种类型:整数、布尔型、浮点数和复数。

  • int (整数), 如 1, 只有一种整数类型 int,表示为长整型,没有 python2 中的 Long。
  • bool (布尔), 如 True。
  • float (浮点数), 如 1.23、3E-2
  • complex (复数), 如 1 + 2j、 1.1 + 2.2j

字符串(String)

  • python中单引号和双引号使用完全相同。
  • 使用三引号(”’或”””)可以指定一个多行字符串。
  • 转义符 ‘\’
  • 反斜杠可以用来转义,使用r可以让反斜杠不发生转义。。 如 r”this is a line with \n” 则\n会显示,并不是换行。
  • 按字面意义级联字符串,如”this ” “is ” “string”会被自动转换为this is string。
  • 字符串可以用 + 运算符连接在一起,用 * 运算符重复。
  • Python 中的字符串有两种索引方式,从左往右以 0 开始,从右往左以 -1 开始。
  • Python中的字符串不能改变。
  • Python 没有单独的字符类型,一个字符就是长度为 1 的字符串。
  • 字符串的截取的语法格式如下:变量[头下标:尾下标:步长]
word = '字符串' sentence = "这是一个句子。" paragraph = """这是一个段落, 可以由多行组成"""

实例(Python 3.0+)

#!/usr/bin/python3 str=Runoob print(str) # 输出字符串 print(str[0:-1]) # 输出第一个到倒数第二个的所有字符 print(str[0]) # 输出字符串第一个字符 print(str[2:5]) # 输出从第三个开始到第五个的字符 print(str[2:]) # 输出从第三个开始的后的所有字符 print(str * 2) # 输出字符串两次 print(str + 你好) # 连接字符串 print(——————————) print(hello\nrunoob) # 使用反斜杠(\)+n转义特殊字符 print(rhello\nrunoob) # 在字符串前面添加一个 r,表示原始字符串,不会发生转义

这里的 r 指 raw,即 raw string。

输出结果为:

Runoob Runoo R noo noob RunoobRunoob Runoob你好 ------------------------------ hello runoob hello\nrunoob

空行

函数之间或类的方法之间用空行分隔,表示一段新的代码的开始。类和函数入口之间也用一行空行分隔,以突出函数入口的开始。

空行与代码缩进不同,空行并不是Python语法的一部分。书写时不插入空行,Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码,便于日后代码的维护或重构。

记住:空行也是程序代码的一部分。

等待用户输入

执行下面的程序在按回车键后就会等待用户输入:

实例(Python 3.0+)

#!/usr/bin/python3 input(\n\n按下 enter 键后退出。)

以上代码中 ,”\n\n”在结果输出前会输出两个新的空行。一旦用户按下 enter 键时,程序将退出。

同一行显示多条语句

Python可以在同一行中使用多条语句,语句之间使用分号(;)分割,以下是一个简单的实例:

 

实例(Python 3.0+)

#!/usr/bin/python3 import sys; x = runoob; sys.stdout.write(x + \n)

使用脚本执行以上代码,输出结果为:

runoob

使用交互式命令行执行,输出结果为:

>>> import sys; x = 'runoob'; sys.stdout.write(x + '\n') runoob 7

此处的 7 表示字符数。

多个语句构成代码组

缩进相同的一组语句构成一个代码块,我们称之代码组。

像if、while、def和class这样的复合语句,首行以关键字开始,以冒号( : )结束,该行之后的一行或多行代码构成代码组。

我们将首行及后面的代码组称为一个子句(clause)。

如下实例:

if expression : suite elif expression : suite else : suite

Print 输出

print 默认输出是换行的,如果要实现不换行需要在变量末尾加上 end=””

实例(Python 3.0+)

#!/usr/bin/python3 x=a y=b # 换行输出 print( x ) print( y ) print(———) # 不换行输出 print( x, end= ) print( y, end= ) print()

以上实例执行结果为:

a
b
--------- a b

import 与 from…import

在 python 用 import 或者 from…import 来导入相应的模块。

将整个模块(somemodule)导入,格式为: import somemodule

从某个模块中导入某个函数,格式为: from somemodule import somefunction

从某个模块中导入多个函数,格式为: from somemodule import firstfunc, secondfunc, thirdfunc

将某个模块中的全部函数导入,格式为: from somemodule import *

导入 sys 模块

import sys print(================Python import mode==========================); print (命令行参数为:) for i in sys.argv: print (i) print (\n python 路径为,sys.path)

导入 sys 模块的 argv,path 成员

from sys import argv,path # 导入特定的成员 print(================python from import===================================) print(path:,path) # 因为已经导入path成员,所以此处引用时不需要加sys.path

命令行参数

很多程序可以执行一些操作来查看一些基本信息,Python可以使用-h参数查看各参数帮助信息:

$ python -h usage: python [option] ... [-c cmd | -m mod | file | -] [arg] ... Options and arguments (and corresponding environment variables): -c cmd : program passed in as string (terminates option list) -d : debug output from parser (also PYTHONDEBUG=x) -E : ignore environment variables (such as PYTHONPATH) -h : print this help message and exit [ etc. ]

我们在使用脚本形式执行 Python 时,可以接收命令行输入的参数,具体使用可以参照 Python 3 命令行参数

 

python 中* 和**的作用

先举个 ** 使用的例子:

data = {"a": 1, "b": 2}


def foo(**kwargs):
	print kwargs


foo(a=1, b=2)    
# foo(data)  # 这种调用data的方法会报错
>>>
{'a': 1, 'b': 2}

 可以看出,**代表了给函数传入参数的方式是:a=1形式,即:参数名=参数值,并且不管传入几个值,该函数都会转化为字典处理

 

再举一个*的使用的例子:

data = {"a": 1, "b": 2}


def foo(*kwargs):
	print kwargs


foo(data, "aaa", "bbb")

 可以看出,使用*args可以传入多个参数,并且处理时,按照现将多个值转成一个元组处理

 

Python–re模块的findall等用法

1)正则表达式含义

. # 点可代表一切字符

\ # 起转义作用

[…] # 指代方括号中的任意字符

\d # 指代数字0-9

\D # 指代非数字

\s # 指代一切空格,包括tab制表符、空格、换行等

\S # 指代非空格

\w # 指代大小写字母、数字和下划线

\W # 指代非大小写字母、数字和下划线

* # 匹配前面字符 >=0 次

+ # 匹配前面字符1次及以上

? # 匹配前面字符0次或1次

{m} # 匹配m次

{m,n} # 匹配m到n次

{m,} # 至少匹配m次

 2)结合re模块完成字符串的匹配

re.findall(pattern, string, flags=0)

pattern–>正则表达式

string–>需要处理的字符串

flags–>说明匹配模式,如是否大小写re.I

注:findall不同的表现形式: 

  • import re  第一种
  • kk = re.compile( r’\d+’) 
  • kk.findall( ‘one1two2three3four4’) 
  • #[1,2,3,4]  第二种
  • #注意此处findall()的用法,可传两个参数; 
  • kk = re.compile( r’\d+’)
  • re.findall(kk, “one123”) 第三种 kk = “one123” re.findall(r’\d+’, kk)

re.split(pattern, string, maxsplit=0, flags=0)

pattern–>正则表达式

string–>需要处理的字符串

maxsplit–>最大匹配次数。0表示匹配所有次

sub(pattern, repl, string, count=0, flags=0)

pattern–>正则表达式

repl–>新的替换内容

string–>需要处理的字符串

count–>替换次数。0表示匹配替换所有次

flags–>匹配模式

 

在VS2017中编写Python程序

  最近开始了python的学习,在搭建完python环境之后,在选择IDE的时候陷入了困境,首先选择的是PyCharm但是用着还是不习惯,毕竟用VS开发了几年了,突然换软件总感觉有点不适应,就想到了强大的VS能不能写Python程序呢?

  1.Python环境的搭建:

    这里我选择的是Anaconda可以傻瓜式的帮我们将python环境搭建完毕,贴上Anaconda的下载地址:https://www.anaconda.com/download/#download

    选择适合的版本下载即可,我这选择的Python3.6 version 64位的,下载完毕之后就是安装了,Anaconda会帮我们将Python环境搭载完毕的。

  2.VS2017中Python开发的选择:

    如果已经安装过VS2017,直接在找到Visual Studio Installer,运行选择修改,将Python开发和数据科学和分析应用程序 勾选即可

 

    如果是没有安装过VS2017,需要现在VS官网下载最新的VS2017即可,附上微软官方的VS下载链接:

    https://visualstudio.microsoft.com/zh-hans/thank-you-downloading-visual-studio/?sku=Professional&rel=15,后面的步骤与上一步相同。

    安装完毕后,VS2017会自动引入我们前面安装的python环境。

  3.测试环境:

    环境搭建完毕之后就需要测试一下是否搭建成功了,打开VS选择python应用程序;

    可以看到我们安装的Python3.6已经引入了

    接下来点击附加按钮即可:出现了下面的界面那么就表示我们的VS2017已经能成功作为Python的IDE了。

 

Python基本数据类型

一、简介

Python基本数据类型一般分为:数字、字符串、列表、元组、字典、集合这六种基本数据类型

其中数字又包含整型(整型又包括标准整型、长整型(Python2.7及之前版本有))、浮点型、复数类型、布尔型(布尔型就是只有两个值的整型)、这几种数字类型。列表、元组、字符串都是序列。

二、各种数据类型详解

2.1、数字

数字类型是不可更改的对象。对变量改变数字值就是生成/创建新的对象。Python支持多种数字类型:

整型(标准整型和长整型(Python2.7及之前的有这种类型))、布尔型、双精度浮点型、十进制浮点型、复数。

  • 标准整型

    int,标准整型,在大多数32位机器上标准整型取值范围是-2^31到2^31-1,也就是-2147483648~2147483647,如果在64位机器使用64位编译器,那么这个系统的标准整型将是64位。

    Python2.7代码:

    >>> 2**63-1
    9223372036854775807L
    >>> -2**63
    -9223372036854775808L
    >>> 9223372036854775807
    9223372036854775807
    >>> 9223372036854775808
    9223372036854775808L
    >>> -9223372036854775808
    -9223372036854775808
    >>> -9223372036854775809
    -9223372036854775809L
  • 长整型

    long,长整型包含的最大值数字大小由内存决定。长整型及数字末尾加个L(大写小写均可)。Python3中已经取消了标准整型和长整型的区分,都是整型。

    Python2.7代码:

    >>> a = 123L
    >>> type(a)
    <type 'long'>
    >>> a
    123L

    Python3.6代码:

    >>> a = 111111111111111111111111111111
    >>> type(a)
    <class 'int'>
    >>> a
    111111111111111111111111111111
  • 布尔型

    bool,从Python2.3开始Python中添加了布尔类型。布尔类型有两种True和False。对于没有__nozero__方法的对象默认是True。

    对于值为0的数字、空集(空列表、空元组、空字典等)在Python中的布尔类型中都是False。

    >>> bool(1)
    True
    >>> bool('a')
    True
    >>> bool(0)
    False
    >>> bool('')
    False

     

  • 浮点型

    float,每个浮点型占8个字节(64位),完全遵守IEEE754号规范(52M/11E/1S),其中52个位用于表示底,11个位用于表示指数(可表示的范围大约是±10**308.25),剩下的一个位表示符号。这看上去相当完美,然而,实际精度依赖于机器架构和创建Python解释器的编译器。

    浮点型值通常都有一个小数点和一个可选的后缀e(大写或小写,表示科学计数法)。在e和指数之间可以用正(+)或负(-)表示指数的正负(正数的话可以省略符号)。

    以上是Python核心编程的对浮点型(双精度浮点型)的说明。经过Python实测浮点型默认长度是24字节如果超出这个范围会自动

    以下时Python3.6测试过程:

    >>> import sys
    >>> a = 1.1
    >>> sys.getsizeof(a)
    24
    >>> a = 4.4e25
    >>> type(a)
    <class 'float'>
    >>> a = 10**308.25
    >>> a
    1.7782794100389228e+308
    >>> sys.getsizeof(a)
    24
    >>> a = 10**308.25+1
    >>> sys.getsizeof(a)
    24>>> a = float(10)
    >>> a
    10.0
    >>> type(a)
    <class 'float'>
  • 复数类型

    complex,在复数中虚数不能单独存在,它们总是和一个值为0.0的实数部分一起来构成一个复数。
    复数由实数部分和虚数部分构成。
    表示虚数的语法:real+imagj。
    实数部分和虚数部分都是浮点型。
    虚数部分必须有后缀j或J。

    >>> a = 1+1j
    >>> a
    (1+1j)
    >>> type(a)
    <class 'complex'>
    >>> import sys
    >>> sys.getsizeof(a)
    32
    >>> a = complex(2.2)
    >>> a
    (2.2+0j)
    >>> sys.getsizeof(a)
    32

2.2、字符串

字符串(string)是不可变类型,就是说改变一个字符串的元素需要新建一个新的字符串。字符串是由独立的字符组成的,并且这些字符可以通过切片操作顺序地访问。Python里面通过在引号间包含字符的方式创建字符串,单引号和双引号的作用是相同的。
Python用“原始字符串”操作符来创建直接量字符串,所以再做区分就没什么意义了。其他的语言,比如C语言里面用单引号来标示字符,双引号标示字符串,而在Python里面没有字符这个类型。这可能是双引号和单引号在Python里面被视作一样的另一个原因。
Python实际上有三类字符串。通常意义的字符串(str) 和Unicode字符串(unicode) 实际上都是抽象类basestring的子类。这个basestring是不能实例化的。

以下时Python3.6代码:

>>> a = 'abc'
>>> a
'abc'
>>> a = "cba"
>>> a
'cba'
>>> type(a)
<class 'str'>
>>> import sys
>>> sys.getsizeof(a)
52
>>> len(a)
3
>>> a[1]
'b'
>>> del a
>>> a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined

2.3、列表

列表(list)像字符串类型一样,列表类型也是序列式的数据类型。字符串只能由字符组成,而且是不可变的(不能单独改变它的某个值),而列表则是能保留任意数目的Python对象的灵活的容器。
列表不仅可以包含Python的标准类型,而且可以用用户定义的对象作为自己的元素。列表可以包含不同类型的对象,而且要比C或者Python自己的数组类型(包含在array扩展包中)都要灵活,因为数组类型所有的元素只能是一种类型。列表可以执行pop,sort、reverse等操作。列表也可以添加或者减少元素,还可以跟其他的列表结合或者把一个列表分成几个。可以对单独一个元素或者多个元素执行insert、update或remove操作

下面是Python3.6代码:

>>> li = [1,'12','abc',['a','123',1]]
>>> li
[1, '12', 'abc', ['a', '123', 1]]
>>> type(li)
<class 'list'>
>>> a = list('abcde')
>>> a
['a', 'b', 'c', 'd', 'e']
>>> a.pop()
'e'
>>> a
['a', 'b', 'c', 'd']
>>> a.reverse()
>>> a
['d', 'c', 'b', 'a']

2.4、元组

元组类型在很多操作上都跟列表一样,许多用在列表上的例子在元组上照样能跑,我们有一节内容专门讲解元组类型。它们的主要不同在于元组是不可变的,或者说是只读的,所以那些用于更新列表的操作,比如用切片操作来更新一部分元素的操作,就不能用于元组类型。

以下是Python3.6代码:

CPython>>> a = ('a','123',['a',123])
>>> a
('a', '123', ['a', 123])
>>> type(a)
<class 'tuple'>
>>> tu = tuple('abcde')
>>> tu
('a', 'b', 'c', 'd', 'e')

2.5、字典

字典是Python语言中唯一的映射类型。映射类型对象里哈希值(键,key) 和指向的对象
(值。value) 是一对多的关系。一个字典对象是可变的,它是一个容器类型,能存储任意个数
的Python对象,其中也包括其他容器类型。字典类型和序列类型容器类(列表、元组) 的区
别是存储和访问数据的方式不同。序列类型只用数字类型的键(从序列的开始起按数值顺序
索引) 。映射类型可以用其他对象类型做键,一般最常见的是用字符串做键。和序列类型的
键不同,映像类型的键直接或间接地和存储的数据值相关联。但因为在映射类型中,我们不
再用“序列化排序”的键,所以映像类型中的数据是无序排列的
映射类型不要求用数字值做索引以从一个容器中
获取对应的数据项。你可以用键直接“映射”到值,这就是为什么叫映射类型(“mapping
type”) 的原因。映射类型通常被称做哈希表,是因为字典对象就是哈希类型的。字典是
Python中最强大的数据类型之一。

字典常见的操作有:字典创建、字典赋值、字典中值的访问、字典更新、字典元素删除等操作。

C>>> d1 = {}
>>> type(d1)
<class 'dict'>
>>> d1['name']='xiaohong'
>>> d1
{'name': 'xiaohong'}
>>> d1['name']
'xiaohong'
>>> del d1['name']
>>> d1
{}Python

2.6、集合

集合最早出现在Python2.3版本中,通过集合模块来创建,并通过ImmutableSet类和Set类进行访问。
集合有两种不同的类型,可变集合(set)和不可变集合(frozenset)。可变集合,你可以添加和删除元素,对不可变集合则不允许这样做。请注意,可变集合不是可哈希的,因此既不能用做字典的键也不能做其他集合中的元素。不可变集合则正好相反,即,他们有哈希值,能被用做字典的键或是作为集合中的一个成员。集合对象是一组无序排列的可哈希的值。
集合支持用in和not in操作符检查成员,由len()内建函数得到集合的基数(大小) ,用for循环迭代集合的成员。但是因为集合本身是无序的,你不可以为集合创建索引或执行切片(slice) 操作,也没有键可用来获取集合中元素的值。

以下时Python3.6代码:

>>> s1 = set('a')
>>> s1
{'a'}
>>> type(s1)
<class 'set'>
>>> 'a' in s1
True
>>> s1.add('cd')
>>> s1
{'cd', 'a'}
>>> s1.remove('a')
>>> s1
{'cd'}
>>> del s1
>>> s1 = set(['abc'])
>>> s1
{'abc'}
>>> s1 = set('abc')
>>> s1
{'c', 'a', 'b'}
>>> s2 = frozenset(s1)
>>> s2
frozenset({'c', 'a', 'b'})
>>> type(s2)
<class 'frozenset'>

Python 和 R 数据分析/挖掘工具互查

写在前面

在此总结一些在数据分析/挖掘中可能用到的功能,方便大家索引或者从一种语言迁移到另一种。当然,这篇博客还会随时更新(不会另起一篇,为了方便大家索引),请大家如果有需要收藏到书签中。

如果大家还知道哪些常用的命令,也可以在评论中回复我。我可以添加进来,方便更多地人更方便的检索。也希望大家可以转载。

如果大家已经熟悉python和R的模块/包载入方式,那下面的表查找起来相对方便。python在下表中以模块.的方式引用,部分模块并非原生模块,请使用

pip install *

安装;同理,为了方便索引,R中也以::表示了函数以及函数所在包的名字,如果不含::表示为R的默认包中就有,如含::,请使用

install.packages("*")

安装。

连接器与io

数据库

类别 Python R
MySQL mysql-connector-python(官方) RMySQL
Oracle cx_Oracle ROracle
Redis redis rredis
MongoDB pymongo RMongo, rmongodb
neo4j py2neo RNeo4j
Cassandra cassandra-driver RJDBC
ODBC pyodbc RODBC
JDBC 未知[Jython Only] RJDBC

IO类

类别 Python R
excel xlsxWriter, pandas.(from/to)_excel, openpyxl openxlsx::read.xlsx(2), xlsx::read.xlsx(2)
csv csv.writer read.csv(2), read.table
json json jsonlite
图片 PIL jpeg, png, tiff, bmp

统计类

描述性统计

类别 Python R
描述性统计汇总 scipy.stats.descirbe summary
均值 scipy.stats.gmean(几何平均数), scipy.stats.hmean(调和平均数), numpy.mean, numpy.nanmean, pandas.Series.mean mean
中位数 numpy.median, numpy.nanmediam, pandas.Series.median median
众数 scipy.stats.mode, pandas.Series.mode 未知
分位数 numpy.percentile, numpy.nanpercentile, pandas.Series.quantile quantile
经验累积函数(ECDF) statsmodels.tools.ECDF ecdf
标准差 scipy.stats.std, scipy.stats.nanstd, numpy.std, pandas.Series.std sd
方差 numpy.var, pandas.Series.var var
变异系数 scipy.stats.variation 未知
协方差 numpy.cov, pandas.Series.cov cov
(Pearson)相关系数 scipy.stats.pearsonr, numpy.corrcoef, pandas.Series.corr cor
峰度 scipy.stats.kurtosis, pandas.Series.kurt e1071::kurtosis
偏度 scipy.stats.skew, pandas.Series.skew e1071::skewness
直方图 numpy.histogram, numpy.histogram2d, numpy.histogramdd 未知

回归(包括统计和机器学习)

类别 Python R
普通最小二乘法回归(ols) statsmodels.ols, sklearn.linear_model.LinearRegression lm,
广义线性回归(gls) statsmodels.gls nlme::gls, MASS::gls
分位数回归(Quantile Regress) statsmodels.QuantReg quantreg::rq
岭回归 sklearn.linear_model.Ridge MASS::lm.ridge, ridge::linearRidge
LASSO sklearn.linear_model.Lasso lars::lars
最小角回归 sklearn.linear_modle.LassoLars lars::lars
稳健回归 statsmodels.RLM MASS::rlm

假设检验

类别 Python R
t检验 statsmodels.stats.ttest_ind, statsmodels.stats.ttost_ind, statsmodels.stats.ttost.paired; scipy.stats.ttest_1samp, scipy.stats.ttest_ind, scipy.stats.ttest_ind_from_stats, scipy.stats.ttest_rel t.test
ks检验(检验分布) scipy.stats.kstest, scipy.stats.kstest_2samp ks.test
wilcoxon(非参检验,差异检验) scipy.stats.wilcoxon, scipy.stats.mannwhitneyu wilcox.test
Shapiro-Wilk正态性检验 scipy.stats.shapiro shapiro.test
Pearson相关系数检验 scipy.stats.pearsonr cor.test

时间序列

类别 Python R
AR statsmodels.ar_model.AR ar
ARIMA statsmodels.arima_model.arima arima
VAR statsmodels.var_model.var 未知

python还可参见PyFlux.

生存分析

类别 Python R
PH回归 statsmodels.formula.api.phreg 未知

专门分析的模块:
Python: Lifelines

机器学习类

回归

参见统计类

分类器

LDA、QDA

类别 Python R
LDA sklearn.discriminant_analysis.LinearDiscriminantAnalysis MASS::lda
QDA sklearn.discriminant_analysis.QuadraticDiscriminantAnalysis MASS::qda

SVM(支持向量机)

类别 Python R
支持向量分类器(SVC) sklearn.svm.SVC e1071::svm
非支持向量分类器(nonSVC) sklearn.svm.NuSVC 未知
线性支持向量分类器(Lenear SVC) sklearn.svm.LinearSVC 未知

基于临近

类别 Python R
k-临近分类器 sklearn.neighbors.KNeighborsClassifier 未知
半径临近分类器 sklearn.neighbors.RadiusNeighborsClassifier 未知
临近重心分类器(Nearest Centroid Classifier) sklearn.neighbors.NearestCentroid 未知

贝叶斯

类别 Python R
朴素贝叶斯 sklearn.naive_bayes.GaussianNB e1071::naiveBayes
多维贝叶斯(Multinomial Naive Bayes) sklearn.naive_bayes.MultinomialNB 未知
伯努利贝叶斯(Bernoulli Naive Bayes) sklearn.naive_bayes.BernoulliNB 未知

决策树

类别 Python R
决策树分类器 sklearn.tree.DecisionTreeClassifier tree::tree, party::ctree
决策树回归器 sklearn.tree.DecisionTreeRegressor tree::tree, party::tree

Assemble方法

类别 子类别 Python R
Bagging 随机森林分类器 sklearn.ensemble.RandomForestClassifier randomForest::randomForest, party::cforest
Bagging 随机森林回归器 sklearn.ensemble.RandomForestRegressor randomForest::randomForest, party::cforest
Boosting Gradient Boosting xgboost模块 xgboost
Boosting AdaBoost sklearn.ensemble.AdaBoostClassifier adabagfastAdaboostada
Stacking 未知 未知 未知

聚类

类别 Python R
kmeans scipy.cluster.kmeans.kmeans kmeans::kmeans
分层聚类 scipy.cluster.hierarchy.fcluster (stats::)hclust
包聚类(Bagged Cluster) 未知 e1071::bclust
DBSCAN sklearn.cluster.DBSCAN dbscan::dbsan
Birch sklearn.cluster.Birch 未知
K-Medoids聚类 pyclust.KMedoids(可靠性未知) cluster.pam

关联规则

类别 Python R
apriori算法 apriori(可靠性未知,不支持py3), PyFIM(可靠性未知,不可用pip安装) arules::apriori
FP-Growth算法 fp-growth(可靠性未知,不支持py3), PyFIM(可靠性未知,不可用pip安装) 未知

神经网络

类别 Python R
神经网络 neurolab.net, keras.* nnet::nnet, nueralnet::nueralnet
深度学习 keras.* 不可靠包居多以及未知

当然,theano模块值得一提,但本质theano包的设计并非在神经网络,所以不归于此类。

概率图模型

python: PyMC3

文本、NLP

基本操作

类别 Python R
tokenize nltk.tokenize(英), jieba.tokenize(中) tau::tokenize
stem nltk.stem RTextTools::wordStem, SnowballC::wordStem
stopwords stop_words.get_stop_words tm::stopwords, qdap::stopwords
中文分词 jieba.cut, smallseg, Yaha, finalseg, genius jiebaR
TFIDF gensim.models.TfidfModel 未知

主题模型

类别 Python R
LDA lda.LDA, gensim.models.ldamodel.LdaModel topicmodels::LDA
LSI gensim.models.lsiModel.LsiModel 未知
RP gensim.models.rpmodel.RpModel 未知
HDP gensim.models.hdpmodel.HdpModel 未知

值得留意的是python的新第三方模块,spaCy

与其他分析/可视化/挖掘/报表工具的交互

 

类别 Python R
weka python-weka-wrapper RWeka
Tableau tableausdk Rserve(实际是R的服务包)

转载于

https://segmentfault.com/a/1190000005041649

python实现读取并显示图片的两种方法

在 python 中除了用 opencv,也可以用 matplotlib 和 PIL 这两个库操作图片。本人偏爱 matpoltlib,因为它的语法更像 matlab。

一、matplotlib

1. 显示图片

?

1 2 3 4 5 6 7 8 9 10 11 import matplotlib.pyplot as plt # plt 用于显示图片 import matplotlib.image as mpimg # mpimg 用于读取图片 import numpy as np   lena = mpimg.imread( 'lena.png' ) # 读取和代码处于同一目录下的 lena.png # 此时 lena 就已经是一个 np.array 了,可以对它进行任意处理 lena.shape #(512, 512, 3)   plt.imshow(lena) # 显示图片 plt.axis( 'off' ) # 不显示坐标轴 plt.show()

2. 显示某个通道

?

1 2 3 4 5 6 7 8 9 10 11 # 显示图片的第一个通道 lena_1 = lena[:,:, 0 ] plt.imshow( 'lena_1' ) plt.show() # 此时会发现显示的是热量图,不是我们预想的灰度图,可以添加 cmap 参数,有如下几种添加方法: plt.imshow( 'lena_1' , cmap = 'Greys_r' ) plt.show()   img = plt.imshow( 'lena_1' ) img.set_cmap( 'gray' ) # 'hot' 是热量图 plt.show()

3. 将 RGB 转为灰度图

matplotlib 中没有合适的函数可以将 RGB 图转换为灰度图,可以根据公式自定义一个:

?

1 2 3 4 5 6 7 8 def rgb2gray(rgb):    return np.dot(rgb[...,: 3 ], [ 0.299 , 0.587 , 0.114 ])   gray = rgb2gray(lena)  # 也可以用 plt.imshow(gray, cmap = plt.get_cmap('gray')) plt.imshow(gray, cmap = 'Greys_r' ) plt.axis( 'off' ) plt.show()

4. 对图像进行放缩

这里要用到 scipy

?

1 2 3 4 5 from scipy import misc lena_new_sz = misc.imresize(lena, 0.5 ) # 第二个参数如果是整数,则为百分比,如果是tuple,则为输出图像的尺寸 plt.imshow(lena_new_sz) plt.axis( 'off' ) plt.show()

5. 保存图像

5.1 保存 matplotlib 画出的图像

该方法适用于保存任何 matplotlib 画出的图像,相当于一个 screencapture。

?

1 2 3 plt.imshow(lena_new_sz) plt.axis( 'off' ) plt.savefig( 'lena_new_sz.png' )

5.2 将 array 保存为图像

?

1 2 from scipy import misc misc.imsave( 'lena_new_sz.png' , lena_new_sz)

5.3 直接保存 array

读取之后还是可以按照前面显示数组的方法对图像进行显示,这种方法完全不会对图像质量造成损失

?

1 2 np.save( 'lena_new_sz' , lena_new_sz) # 会在保存的名字后面自动加上.npy img = np.load( 'lena_new_sz.npy' ) # 读取前面保存的数组

二、PIL

1. 显示图片

?

1 2 3 from PIL import Image im = Image. open ( 'lena.png' ) im.show()

2. 将 PIL Image 图片转换为 numpy 数组

?

1 2 im_array = np.array(im) # 也可以用 np.asarray(im) 区别是 np.array() 是深拷贝,np.asarray() 是浅拷贝

3. 保存 PIL 图片

直接调用 Image 类的 save 方法

?

1 2 3 from PIL import Image I = Image. open ( 'lena.png' ) I.save( 'new_lena.png' )

4. 将 numpy 数组转换为 PIL 图片

这里采用 matplotlib.image 读入图片数组,注意这里读入的数组是 float32 型的,范围是 0-1,而 PIL.Image 数据是 uinit8 型的,范围是0-255,所以要进行转换:

?

1 2 3 4 5 import matplotlib.image as mpimg from PIL import Image lena = mpimg.imread( 'lena.png' ) # 这里读入的数据是 float32 型的,范围是0-1 im = Image.fromarray(np.uinit8(lena * 255 )) im.show()

5. RGB 转换为灰度图

?

1 2 3 4 5 from PIL import Image I = Image. open ( 'lena.png' ) I.show() L = I.convert( 'L' ) L.show()

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持脚本之家。

您可能感兴趣的文章:

 

原文链接:http://www.cnblogs.com/yinxiangnan-charles/p/5928689.html