Python教程

python学习

本文主要是介绍python学习,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

python学习

python和C相异之处:

  1. 书写格式(是以缩进形式,没有花括弧,不需要结尾的 ; ):python循环中的循环体或者是if else 语句中的语句是没有花括弧括起来的,而是以 : 代替。python是严格按照缩进形式来表示层级关系,与yaml格式有点类似,这种书写方式可以有效避免if else语句的“悬挂”问题,体会以下两段代码在C和python中的异同:

    第一段:

    temp1 = 3
    if temp1>=2:
        print(">=2")
        if temp1>=5:
            print(">=5")
    else:
        print("10")
    

    输出结果为:

    >=2
    

    第二段

    temp1 = 3
    if temp1>=2:
        print(">=2")
        if temp1>=5:
            print(">=5")
        else:
            print("10")
    

    输出结果为:

    >=2
    10
    

    相异点为:以上两段代码在C中都输出第二段代码的结果,这就是python语言中层级与C中花括弧的区别

    #include<stdio.h>
    int main(){
        int a = 3;
        if(a>2)
            printf("a>2\n");
        if(a>5)
            printf("a>5\n");
        else
            printf("10");
    }
    
  2. 变量的定义:变量之前不需要加类型,直接进行赋值就可以了,但是如果一个变量没有被赋值直接使用的话会报错

    import random
    test = random.randint(1,10)#直接赋值
    
  3. 运算符:比起C,python新加了两个个运算符为 **和//,前一个表示指数幂,后一个表示使两数相除的结果为整形(python规定用/进行相除的结果默认为浮点数),运算优先级为幂运算为最高优先级,其余和C相同。

    逻辑运算符:且用and,而不是&&,或用or,而不是||,非用not而不是!,但是,不等于的表示和C是一样的,都用 !=,表示

    >>> 5**3
    125
    
    >>> 5//3
    1
    
    >>> 5/3
    1.6666666666666667
    
    >>> -5**3#**运算优先级最高
    -125
    
  4. 导包:格式是import + 名称,例如导入随机数

    import random
    
  5. 类型转换:类型之间可以随意转换,非常智能。它的字符型数字也可以直接转为int型

    import random
    test = random.randint(1,10)
    print(test)
    print(type(test))
    temp = str(test)
    print(type(temp))
    temp1 = int(temp)
    print(type(temp1))
    

    输出结果为:

    4
    <class ‘int’>
    <class ‘str’>
    <class ‘int’>

  6. 注释:python的注释是使用 #,而不是//

  7. if else语句:python中多出了一个叫 elif 的条件判断语句,其作用与else if : 条件判断作用相同,目的是使代码更具有易读性

    if temp1==3:
        print("3")
    elif temp1>=5:
        print(">=5")
    
  8. for循环:python中的for循环更加智能和强大,其书写方式为:

    >>> for i in wcc:
    	print(i,end=' ')
    
    	
    l o v e   y o u 
    

    range(): 一般和for循环一起用,指定输出的范围

    range(4):表示从0到4

    >>> list(range(4))
    [0, 1, 2, 3]
    
    1. 传递一个参数的range

      >>> for i in range(2):
      	print(i)
      
      	
      0
      1
      
    2. 传递两个参数的range:第一个参数表示起始位置,第二个参数表示结束位置

      >>> for i in range(2,5):
      	print(i)
      
      	
      2
      3
      4
      
    3. 传递三个参数:第一个参数表示起始位置,第二个参数表示结束位置,第三个参数表示step

      >>> for i in range(2,9,2):
      	print(i)
      
      	
      2
      4
      6
      8
      
  9. 列表:相当于加强版的数组

    1. 普通模式:内部元素可以为整形、字符型、字符串型等

      >>> wcc=['wcc1','wcc2','wcc3','wcc4','wcc5']
      
    2. 混合型:内部元素可以为整形、字符型、字符串型等的混合

      >>> list1 = [1,1.3,'wcc',wcc]
      >>> list1
      [1, 1.3, 'wcc', ['wcc1', 'wcc2', 'wcc3', 'wcc4', 'wcc5']]
      
    3. 用append()方法来给列表添加元素:但是只能有一个参数,append()方法为列表的内置方法

      >>> list1.append('678')
      >>> list1
      [1, 1.3, 'wcc', ['wcc1', 'wcc2', 'wcc3', 'wcc4', 'wcc5'], '678']
      
    4. 用extend()方法来同时添加多个元素,但是extend()方法也是只能有一个参数,但是其参数只能为列表,表示用一个列表扩展另外一个列表

      >>> list1.extend([1,2,3])
      >>> list1
      [1, 1.3, 'wcc', ['wcc1', 'wcc2', 'wcc3', 'wcc4', 'wcc5'], '678', 1, 2, 3]
      
    5. 用insert()方法来将元素添加到指定位置,insert()方法有两个参数,第一个为插入位置(从0开始),第二个为插入内容

      >>> member
      ['wcc0', 'wcc1', 'wcc2', 'wcc3', 'wcc4', 'wcc5']
      >>> member.insert(0,'wcc10')
      >>> member
      ['wcc10', 'wcc0', 'wcc1', 'wcc2', 'wcc3', 'wcc4', 'wcc5']
      
    6. 用remove()方法来删除元素,remove()方法有一个参数,参数为删除内容

      >>> member.remove('wcc10')
      >>> member
      ['wcc0', 'wcc1', 'wcc2', 'wcc3', 'wcc4', 'wcc5']
      
    7. del + 列表名称 :删除整个列表

      del + 列表名称[index]:删除索引位置的元素

      >>> member
      ['wcc0', 'wcc1', 'wcc2', 'wcc3', 'wcc4', 'wcc5', 'wcc10']
      >>> del member[6]
      >>> member
      ['wcc0', 'wcc1', 'wcc2', 'wcc3', 'wcc4', 'wcc5']
      
    8. pop():(无参)删除栈顶元素,并把删除的元素返回

      pop(index):(有参)删除索引位置元素,并把删除的元素返回

      >>> member
      ['wcc0', 'wcc1', 'wcc2', 'wcc3', 'wcc4', 'wcc5']
      >>> member.pop(1)
      'wcc1'
      >>> member
      ['wcc0', 'wcc2', 'wcc3', 'wcc4', 'wcc5']
      >>> 
      
    9. 列表分片:通过 list[start : end]方式来获取多个list内容(从start位置开始,到end-1位置结束),同时,start和end可以有其中一个为空或皆为空。

      1. 若start为空,则是从0开始到end结束。

      2. 若end为空,则是从start开始,到结尾结束。

      3. 若两者都为空,则得到list的拷贝,值得注意的是,这种拷贝所得到的内容是从本体上复制一份到内存,是自己独有的一份,而不是像 = 一样对本体的引用

        >>> member[2:5]
        ['wcc3', 'wcc4', 'wcc5']
        >>> member[:4]
        ['wcc0', 'wcc2', 'wcc3', 'wcc4']
        >>> member[1:]
        ['wcc2', 'wcc3', 'wcc4', 'wcc5']
        >>> member[:]
        ['wcc0', 'wcc2', 'wcc3', 'wcc4', 'wcc5']
        
    10. count():有一个参数,其返回值表示参数在list中出现的次数

      >>> member
      ['wcc0', 'wcc2', 'wcc3', 'wcc4', 'wcc5', 'wcc0']
      >>> member.count('wcc0')
      2
      
    11. reverse():列表原地翻转

      >>> member.reverse()
      >>> member
      ['wcc0', 'wcc5', 'wcc4', 'wcc3', 'wcc2', 'wcc0']
      
    12. sort():列表中的内容自动排序,有一个参数,表示排序方向reverse=False,表示顺序排序。reverse=True,表示逆序排序(False和True的首字母必须都要大写)

      >>> list1 = [1, 10, 4, 7, 2, 8, 6]
      >>> list1
      [1, 10, 4, 7, 2, 8, 6]
      >>> list1.sort()
      >>> list1
      [1, 2, 4, 6, 7, 8, 10]
      >>> list1.sort(reverse=True)
      >>> list1
      [10, 8, 7, 6, 4, 2, 1]
      
  10. 元组:

    首先,注意以下问题:

    >>> 8*(8)
    64
    >>> 8*(8,)
    (8, 8, 8, 8, 8, 8, 8, 8)
    

    因为第3行中的括号被看做是元组,而不是一个数字,所以*就被视为把元组重复8次

    1. 拼接操作符:

      >>> temp = ('wcc0','wcc1','wcc2','wcc3','wcc4')
      >>> temp
      ('wcc0', 'wcc1', 'wcc2', 'wcc3', 'wcc4')
      >>> temp = temp[:2]+('wcc5',)+temp[2:]
      >>> temp
      ('wcc0', 'wcc1', 'wcc5', 'wcc2', 'wcc3', 'wcc4')
      
    2. 格式化:将其转变为想要的格式(有两种书写格式)

      1. >>> "{a} love {b}.{c}".format(a="I",b="wcc",c="com")#自定义参数位置
        'I love wcc.com'
        
      2. >>> "{0} love {1}.{2}".format("I","wcc","com")#默认参数位置
        'I love wcc.com'
        
  11. python中的函数:以def 来开头定义一个函数,调用时根据其参数调用即可,并且python中函数的使用是相当灵活的,对语法要求不是很严格

    >>> def myFirstFunction(a,b):
    	return (a+b)
    
    >>> myFirstFunction(5,6)
    11
    
    1. 函数中用单引号括起来的内容是函数说明文档,不会干扰程序运行

      >>> def mySecondFunction(name):
      	'这是一个文档'
      	#这是一条注释
      	print('这是'+name+'创建的')
      	
      >>> help(mySecondFunction)
      Help on function mySecondFunction in module __main__:
      
      mySecondFunction(name)
          这是一个文档
      
    2. 函数调用时可以采用关键字绑定,使用了关键字绑定后,函数调用时的参数注入就不会根据下标索引了,而是会根据关键字索引,这样可以有效防止参数注入错误

      >>> def myThirdFunction(name,age):
      	print('我的名字是'+name+',今年'+age+'岁')
      
      	
      >>> myThirdFunction(age='29',name='wcc')
      我的名字是wcc,今年29岁
      
    3. 函数的默认参数:当函数调用时可以给定一个默认参数,防止调用时忘记给实参而报错

      >>> def myforthFunction(name='wcc',age='32'):
      	print('我的名字是'+name+',今年'+age+'岁')
      
      	
      >>> myforthFunction()#即使没有给定实参,程序也不会报错,函数会自动调用默认参数
      我的名字是wcc,今年32岁
      >>> myforthFunction('oop','21')
      我的名字是oop,今年21岁
      
    4. 收集参数(可变参数):为了应对程序开发者自己也不知道有多少个参数的情况(原理是py把这些参数全部都用元组打包起来,然后把全部参数放到形参元组里面去)

      >>> def test(*params):#注意,params与*之间不能有间隔
      	print('参数长度:',len(params));
      	print('第一个参数:',params[1]);
      
      	
      >>> test(1,'wcc','a')
      参数长度: 3
      第一个参数: wcc
      
    5. python中不要试图在函数中直接去修改一个全局变量,因为修改全局变量会直接开辟出一个新的同名局部变量,并且奇怪的是当在函数中先打印全局变量再进行修改此变量的时候,会直接报错,具体看下例

      mydef_variable='abc'
      
      def myFunction():
          print('wcc is OK!')
          print(mydef_variable)
          mydef_variable='wccOK'
      
      
      myFunction()
      
      print(mydef_variable)
      
      #输出结果
      wcc is OK!
      Traceback (most recent call last):
        File "F:\python文件\second.py", line 11, in <module>
          myFunction()
        File "F:\python文件\second.py", line 7, in myFunction
          print(mydef_variable)
      UnboundLocalError: local variable 'mydef_variable' referenced before assignment
      
      

      解释:因为python使用了 屏蔽 来保护全局变量,所以使用的是python在函数内部创建的一个新的同名局部变量,而非全局变量,函数内打印的变量即为此局部变量,但是本例中的局部变量使用又在定义之前,所以会造成这个错误。

      正确顺序为:

      mydef_variable='abc'
      
      def myFunction():
          print('wcc is OK!')
          mydef_variable='wccOK'
          print(mydef_variable)
      
      
      myFunction()
      
      print(mydef_variable)
      #输出结果
      wcc is OK!
      wccOK
      abc
      

      如果想在函数中修改全局变量的话,只需要加 global 标识即可。

      mydef_variable='abc'
      
      def myFunction():
          print('wcc is OK!')
          global mydef_variable
          mydef_variable = 'wccOK'
          print(mydef_variable)
      
      
      myFunction()
      
      print(mydef_variable)
      
      #运行结果
      wcc is OK!
      wccOK
      wccOK
      
  12. python支持函数嵌套定义,但不能直接调用被嵌套的函数

    >>> def fun1():
    		print('fun1')
    		def fun2():
    			print('fun2')
    		fun2()
    
    	
    >>> fun1()
    fun1
    fun2
    
  13. python非常非常 灵活,返回值可以是一个函数,可以用一个变量接收这个函数,然后再用此变量进行调用。

    >>> def fun1(x):
    		def fun2(y):
    			return x*y
    		return fun2
    
    >>> fun1(4)
    <function fun1.<locals>.fun2 at 0x000002B538499A60>
    >>> i = fun1(5)
    >>> i(6)
    30
    
  14. python中的lambda表达式:lambda表达式非常精简,很适合python语言的风格

    下面是一般的函数写法

    >>> def fun(x):
    	return 2*x+4
    
    >>> fun(4)
    12
    

    使用了lambda表达式之后的函数写法如下所示:

    >>> g = lambda x:2*x+4 # :前面是参数,后面是返回值
    >>> g(4)
    12
    

    如果是双参数,则如下所示:

    >>> g = lambda x,y:x*y
    >>> g(3,4)
    12
    
  15. python中两个较常用的内置函数filter()和map()

    1. filter()的使用:过滤掉任何非true的内容(第一个参数为空或者是一个函数,第二个参数为一个列表)

      >>> list(filter(lambda x:x%2,range(10)))#在0-9中找出奇数
      [1, 3, 5, 7, 9]
      
    2. map()的使用:对每一个可迭代的值进行给定操作(第一个参数为空或者是一个函数,第二个参数为一个列表)

      >>> list(map(lambda x:x*2,range(10)))#将0-9中的每一个数进行*2操作
      [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
      
  16. 映射关系(键值对):相当于java中的map的键值对

    >>> data1 = {'wcc':'bigBoy','wcc1':'good','ntow':'small'}
    >>> print(data1['wcc1'])
    good
    
  17. 集合:用大括号括起来的没有键值对映射关系的一组数据称为集合,集合内的数据都是无序的,并且集合内的数据都是不重复的,集合会自动将重复的数据去重(只保留一个),并且不支持索引

    >>> num = {1,2,3,4,5,6,7,3,2,1,4,3}
    >>> num
    {1, 2, 3, 4, 5, 6, 7}
    

    还可以用set()将列表变为set型,主要用于去重

    >>> set1 = set([1,2,3,4,5,6,5,4,3])
    >>> set1
    {1, 2, 3, 4, 5, 6}
    

    如果不用set进行去重,用普通代码去重的方法如下:

    >>> num = [1,2,3,4,5,6,7,6,5,3,2]
    >>> temp = []
    >>> for i in num:
    	if i not in temp:
    		temp.append(i)
    
    		
    >>> temp
    [1, 2, 3, 4, 5, 6, 7]
    
    #这种方法是用一个空列表为中转,如果列表中没有此数字,则将其加入进去,若已存在,则不加入
    

    不可变集合:以frozen修饰, frozenset()

    >>> num3 = frozenset([1,2,3,4,6,3,2,4])
    >>> num3
    frozenset({1, 2, 3, 4, 6})
    >>> num3.add(3)
    
  18. 文件操作

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qXtyXHJm-1626230824050)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1618663350943.png)]

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gKMs6zUm-1626230824055)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1618664516388.png)]

    图片所写内容有误,f.readline()是读取一行,读取到空或者是’\n’停止

    ​ f.readlines()是读取多行数据

    读取文件全部内容:调用read()方法时不用加参数即可

    >>> f = open('E:\\pythonTest.txt',encoding='UTF-8')#务必带上encoding
    >>> f.read()
    '这是为了测试python的文件操作而创建的'
    >>> f.close()
    

    读取文件制定字符数以及查看当前文件的书签位置

    >>> f = open('E:\\pythonTest.txt',encoding='UTF-8')
    >>> f.read(4)
    '这是为了'
    >>> f.tell()
    12
    

    可以将字符串直接转化为列表

    >>> list(f)
    ['测试python的文件操作而创建的']
    

    对有多行数据的文件进行读取的时候,可以有以下两种方式:

    1. 将读取出来的数据放到一个列表里,然后对此列表进行迭代,但是当数据较多的时候,非常消耗内存及时间,效率很低

      >>> f.seek(0,0)
      0
      >>> lines = list(f)
      >>> for line in lines:
      	print(line)
      
      	
      这是我添加的内容这是我添加的内容
      
      这是我的python文件操作测试文件
      
    2. 这种方法是直接迭代文件中的内容分,不再将其重新存放到一个列表中,效率很高

      >>> f.seek(0,0)
      0
      >>> for line in f:
      	print(line)
      
      	
      这是我添加的内容这是我添加的内容
      
      这是我的python文件操作测试文件
      

      python中常用的一个函数split():功能是按给定字符分割字符串

      f = open('wccTestPython.txt')
      
      wcc = []
      xy = []
      
      for line in f:
          if line[:6] != '======':
              (role,speaken) = line.split(':',1) #
              if role == 'wcc':
                  wcc.append(speaken)
              if role == 'xy':
                  xy.append(speaken)
      
      print(wcc)
      print(xy)
      #输出结果
      ['wcc is good\n', 'i think so\n']
      ['xy is very good\n', 'wcc:i think that']
      

python在数据处理中的应用

python的模块:

  • 一个py文件是一个模块(module),多个模块可组成一个包(package),一个包中必须包含一个

_ init _ _.py文件

  • 模块的导入:

    1. import package.module_name
    2. from package.module_name import name (后面的name可以是函数名或者是变量名)

    总结起来分为三种:

    1. import x
    2. from x import *
    3. from x import a,b,c

在导入包的时候可以用 as 引用其别名

  • import package1.module1_name1 as a1

模块导入机制

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RzEagkoT-1626230824059)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1625814098699.png)]

NumPy:

  1. 一个强大的N维数组对象,ndarray
  2. 广播功能函数
  3. 整合C/C++/Fortran代码的工具
  4. 线性代数,傅里叶变换,随机数生成等功能

NumPy是SciPy、Pandas等数据处理或者科学计算库的基础,是一个强大的python科学计算基础库

  1. ndarray:是一个多维数组对象,由两部分构成

    1. 实际的数据
    2. 描述这些数据的元数据(数据维度,数据类型)(元数据:又称中介数据,中继数据,为描述数据的数据,主要是描述数据属性的信息)
  2. ndarray数组一般要求所有元素类型相同(同质),数组下标从0开始

    1. 创建一维数组:numpy的array()函数,可以将一个列表转化为ndarray数组

      import numpy as np
      list1 = [1,2,3,4]
      x = np.array(list1)
      print(x)
      print(list1)
      print(type(x))
      print(type(list1))
      输出:
      [1 2 3 4]
      [1, 2, 3, 4]
      <class 'numpy.ndarray'>
      <class 'list'>
      
    2. 创建二维数组:和创建一维数组一样,不过只是参数部分用二维数组进行传入

      import numpy as np
      list1 = [[1,2,3],[4,5,6.5]]
      x = np.array(list1)
      print(x)
      print(list1)
      print(type(x))
      print(type(list1))
      输出:
      [[1.  2.  3. ]
       [4.  5.  6.5]]
      [[1, 2, 3], [4, 5, 6.5]]
      <class 'numpy.ndarray'>
      <class 'list'>
      
    3. 条件索引:按条件索引出符合条件的数组元素

      import numpy as np
      list1 = [[1,2,3],[4,5,6]]
      x = np.array(list1)
      c = x[x>2]
      print(c)
      print(type(c))
      输出:
      [3 4 5 6]
      <class 'numpy.ndarray'>
      
    4. 常用函数arange():产生连续的序列数组,用法为 arange([start,]stop[,step]) (注意开口闭口)(python是包头不包尾)

      import numpy as np
      x1 = np.arange(5)
      x2 = np.arange(3,6)
      x3 = np.arange(1,10,2)
      print('x1=',x1)
      print('x2=',x2)
      print('x3=',x3)
      输出:
      x1= [0 1 2 3 4]
      x2= [3 4 5]
      x3= [1 3 5 7 9]
      
    5. 常用函数linspace():产生连续的序列,用法为 linspace(start,stop,num) (从strat开始到stop结束,取出num个相同间隔的数) (第一个数必定是start,最后一个必定是stop)

      import numpy as np
      x1 = np.linspace(2,58,10)
      print(x1)
      输出:
      [ 2.          8.22222222 14.44444444 20.66666667 26.88888889 33.11111111
       39.33333333 45.55555556 51.77777778 58.        ]
      

      arange()和linsapce()是产生坐标轴的两种方式,所以此两种方式非常重要

    6. numpy中的切片、重构,转置

      import numpy as np
      #切片,重构,转置
      a = [[1,2,3],[4,5,6]]
      print(type(a))
      print(a)
      np_array = np.array(a)
      print(type(np_array))
      print(np_array)
      #切片,Python包头不包尾,(逗号前的是为了分割行的,逗号后的是为了分割列的)
      print(np_array[0:2,1:3])
      #重构,前面参数表示行数,后面参数表示列数
      np_array2 = np_array.reshape(1,6)
      print(np_array2)
      #转置
      print(np_array.T)
      输出:
      <class 'list'>
      [[1, 2, 3], [4, 5, 6]]
      <class 'numpy.ndarray'>
      [[1 2 3]
       [4 5 6]]
      
      [[2 3]
       [5 6]]
      
      [[1 2 3 4 5 6]]
      
      [[1 4]
       [2 5]
       [3 6]]
      
      

NumPy Matplotlib:

Matplotlib 是 Python 的绘图库。 它可与 NumPy 一起使用,提供了一种有效的 MatLab 开源替代方案。 它也可以和图形工具包一起使用,如 PyQt 和 wxPython

使用时可直接使用起代码,用自己的数据填充即可,详参 https://matplotlib.org/2.0.2/gallery.html

  1. figsize = (width,height) :figsize参数可以指定绘图对象的宽度和高度,单位为英寸(用来创建画布)
  2. dpi = number (dpi参数指定绘图对象的分辨率,即每英寸多少个像素,缺省值为80)
    • 也可以不创建绘图对象直接调用plot()函数直接绘图
    • 如果需要同时绘制多幅图表,可以给figure传递一个整数参数指定图标的序号
    • 如果所指定序号的绘图对象已经存在的话,将不创建新的对象,而只让它成为当前绘图对象

示例:

import numpy as np
import matplotlib.pyplot as plt
plt.figure(figsize=(8, 4))
# title()一定要放在画布创建之后,否则画布上显示不出来标题内容
plt.title("PyPlot First Example")
x = np.linspace(0, 10, 1000)
y = np.sin(x)
z = np.cos(x**2)
# label:给所绘制的曲线一个名字,此名字在图示legend()中显示
plt.plot(x, y, label="sin(x)", color="red", linewidth=2)
# color:显示曲线的颜色("b--"中的“b”表示以blue颜色显示,显示方式为“--”样式的虚线,这种
# 方式后面不可以再用color字段,并且"b--"不能写在"lable"之前,否则会报错)
# plt.plot(x, z, "b--", label="cos(x^2)")
# 还可以表示为
# plt.plot(x, z, "--", label="cos(x^2)", color="blue")
plt.plot(x, z, "b--", label="cos(x^2)")
# xlabel()和ylabel()设置X/Y轴的文字
plt.xlabel("Time(s)")
plt.ylabel("Volt(v)")
# ylim()设置Y轴的范围
plt.ylim(-1.2, 1.2)
# 为了显示曲线所对应的名称,如去掉legend(),则图示中的曲线名称不显示
plt.legend()
# savefig()函数一定要放在show()函数之前,否则会出现保存的图片没有图像的情况
# savefig()函数可以很容易实现批量的图像输出,图像格式由文件扩展名决定
plt.savefig("C:/Users/Administrator/Desktop/vocation/image/PyPlotExample.png", dpi=300)
# 显示
plt.show()

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QYa4hmPx-1626230824064)(F:\python文件\image\myplot.png)]

Pandas基础

Pandas是Python的一个数据分析包,是字典形式,给基于numpy创建,让numpy为中心的应用变得更加简单,并且提供大量的能够便捷快速的处理数据的函数和方法

Pandas两个最核心的数据结构就是Series和DataFrame(一个DataFrame中可以包含若干个Series)

  1. Series:是一维数组结构,应用于带有标签的同结构类型数组

    • 通过列表创建,左边是索引号,右边是索引值

      import numpy as np
      import pandas as pd
      arr = np.arange(3,9)
      s = pd.Series(arr)
      print(s)
      print(type(s))
      输出:
      0    3
      1    4
      2    5
      3    6
      4    7
      5    8
      dtype: int32
      <class 'pandas.core.series.Series'>
      
    • 通过字典创建,左边是关键字,右边是值

      import numpy as np
      import pandas as pd
      dic = {'a': 10, 'b': 11, 'c': 12, 'd': 13, 'e': 14, 'f': 15}
      s = pd.Series(dic)
      print(s)
      print(type(s))
      输出:
      a    10
      b    11
      c    12
      d    13
      e    14
      f    15
      dtype: int64
      <class 'pandas.core.series.Series'>
      
  2. DataFrame:是二维数组结构,表格结构,带有标签,大小可变,且可以包含异构的数组

    DataFrame的不同列可以是不同的数据类型,如果以Series数组来创建DataFrame,每个Series将成为一行,而不是一列

    • 通过列表创建(默认的行列索引和列名都是[0,N-1]的形式)(输出结果多了行和列的标签)

      import numpy as np
      import pandas as pd
      arr = np.arange(12).reshape(3, 4)
      df = pd.DataFrame(arr)
      print(df)
      print(type(df))
      输出:
         0  1   2   3
      0  0  1   2   3
      1  4  5   6   7
      2  8  9  10  11
      <class 'pandas.core.frame.DataFrame'>
      
    • 通过字典创建(列的标签是key)

      import numpy as np
      import pandas as pd
      dic = {'a': [1, 2, 3, 4], 'b': [5, 6, 7, 8], 'c': [9, 10, 11, 12], 'd': [13, 14, 15, 16]}
      df = pd.DataFrame(dic)
      print(df)
      print(type(df))
      输出:
         a  b   c   d
      0  1  5   9  13
      1  2  6  10  14
      2  3  7  11  15
      3  4  8  12  16
      
    • 数据的访问:loc():是通过标签访问(包头尾),iloc():表示通过下标访问(包头不包尾)

      • 通过标签(读取一行):

        import numpy as np
        import pandas as pd
        # 从字典构建
        dic = {'a': [1, 2, 3, 4], 'b': [5, 6, 7, 8], 'c': [9, 10, 11, 12], 'd': [13, 14, 15, 16]}
        df = pd.DataFrame(dic)
        # loc:通过行和列的索引来访问数据,df.loc[0]:表示读取第1行的数据
        print(df.loc[0])
        输出:
        a     1
        b     5
        c     9
        d    13
        Name: 0, dtype: int64
        
      • 通过标签(标签切片):

        import numpy as np
        import pandas as pd
         从字典构建
        dic = {'a': [1, 2, 3, 4], 'b': [5, 6, 7, 8], 'c': [9, 10, 11, 12], 'd': [13, 14, 15, 16]}
        df = pd.DataFrame(dic)
        # 第一个逗号前面表示取从哪一行取到哪一行(冒号前后没有数字表示全取),逗号后面表示取哪几列(不是表示范围,没有的不取),df.loc[:, ['a', 'c']]:表示仅读取标签a和b列的所有行数据,要看清是冒号还是逗号
        print(df.loc['1':'3', ['a', 'c']])
        输出:
           a  b
        0  1  5
        1  2  6
        2  3  7
        3  4  8
        
        import numpy as np
        import pandas as pd
        # 从字典构建
        dic = {'a': [1, 2, 3, 4], 'b': [5, 6, 7, 8], 'c': [9, 10, 11, 12], 'd': [13, 14, 15, 16]}
        df = pd.DataFrame(dic)
        # 这个例子和前面的例子不一样之处就在于'a': 'c'和['a', 'c']的区别,前者表示范围,后者表示两个单独的列
        print(df.loc['1':'3', 'a': 'c'])
        

        冒号前后若有省略则省略处表示从头或者尾到未省略处,例如:

        :‘2’ :表示从第0行到第2行

      • 通过下标访问(取某行)

        import numpy as np
        import pandas as pd
        # 从字典构建
        dic = {'a': [1, 2, 3, 4], 'b': [5, 6, 7, 8], 'c': [9, 10, 11, 12], 'd': [13, 14, 15, 16]}
        df = pd.DataFrame(dic)
        # df.iloc[2] 为取第二行的所有数据,相当于 df.iloc[2, :]
        print(df.iloc[2])
        
      • 通过下标访问(下标切片)

        import numpy as np
        import pandas as pd
        # 从字典构建
        dic = {'a': [1, 2, 3, 4], 'b': [5, 6, 7, 8], 'c': [9, 10, 11, 12], 'd': [13, 14, 15, 16]}
        df = pd.DataFrame(dic)
        # 常规切片,包头不包尾
        print(df.iloc[0: 2, 1: 3])
        
      • 标签加引号,从头取到尾,下标不加引号,包头不包尾

pd
# 从字典构建
dic = {‘a’: [1, 2, 3, 4], ‘b’: [5, 6, 7, 8], ‘c’: [9, 10, 11, 12], ‘d’: [13, 14, 15, 16]}
df = pd.DataFrame(dic)
# 这个例子和前面的例子不一样之处就在于’a’: 'c’和[‘a’, ‘c’]的区别,前者表示范围,后者表示两个单独的列
print(df.loc[‘1’:‘3’, ‘a’: ‘c’])
```

   冒号前后若有省略则省略处表示从头或者尾到未省略处,例如:

   **:'2'**  :表示从第0行到第2行

 - 通过下标访问(取某行)

   ```python
   import numpy as np
   import pandas as pd
   # 从字典构建
   dic = {'a': [1, 2, 3, 4], 'b': [5, 6, 7, 8], 'c': [9, 10, 11, 12], 'd': [13, 14, 15, 16]}
   df = pd.DataFrame(dic)
   # df.iloc[2] 为取第二行的所有数据,相当于 df.iloc[2, :]
   print(df.iloc[2])
   ```

 - 通过下标访问(下标切片)

   ```python
   import numpy as np
   import pandas as pd
   # 从字典构建
   dic = {'a': [1, 2, 3, 4], 'b': [5, 6, 7, 8], 'c': [9, 10, 11, 12], 'd': [13, 14, 15, 16]}
   df = pd.DataFrame(dic)
   # 常规切片,包头不包尾
   print(df.iloc[0: 2, 1: 3])
   ```

 - 标签加引号,从头取到尾,下标不加引号,包头不包尾
这篇关于python学习的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!