python学习

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

python学习

python和C相异之处：

书写格式（是以缩进形式，没有花括弧，不需要结尾的 ; ）：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");
}
```
变量的定义：变量之前不需要加类型，直接进行赋值就可以了，但是如果一个变量没有被赋值直接使用的话会报错
```
import random
test = random.randint(1,10)#直接赋值
```
运算符：比起C，python新加了两个个运算符为 **和//,前一个表示指数幂，后一个表示使两数相除的结果为整形（python规定用/进行相除的结果默认为浮点数）,运算优先级为幂运算为最高优先级，其余和C相同。

逻辑运算符：且用and，而不是&&，或用or，而不是||，非用not而不是!，但是，不等于的表示和C是一样的，都用 !=，表示
```
>>> 5**3
125

>>> 5//3
1

>>> 5/3
1.6666666666666667

>>> -5**3#**运算优先级最高
-125
```
导包：格式是import + 名称，例如导入随机数
```
import random
```
类型转换：类型之间可以随意转换，非常智能。它的字符型数字也可以直接转为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’>
注释：python的注释是使用 #，而不是//
if else语句：python中多出了一个叫 elif 的条件判断语句，其作用与else if : 条件判断作用相同，目的是使代码更具有易读性
```
if temp1==3:
    print("3")
elif temp1>=5:
    print(">=5")
```
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
```
列表：相当于加强版的数组
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]
```

元组：

首先，注意以下问题：

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

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

拼接操作符：

>>> 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')

格式化：将其转变为想要的格式(有两种书写格式)

>>> "{a} love {b}.{c}".format(a="I",b="wcc",c="com")#自定义参数位置
'I love wcc.com'

>>> "{0} love {1}.{2}".format("I","wcc","com")#默认参数位置
'I love wcc.com'

python中的函数：以def 来开头定义一个函数,调用时根据其参数调用即可，并且python中函数的使用是相当灵活的，对语法要求不是很严格

>>> def myFirstFunction(a,b):
	return (a+b)

>>> myFirstFunction(5,6)
11

函数中用单引号括起来的内容是函数说明文档，不会干扰程序运行

>>> def mySecondFunction(name):
	'这是一个文档'
	#这是一条注释
	print('这是'+name+'创建的')
	
>>> help(mySecondFunction)
Help on function mySecondFunction in module __main__:

mySecondFunction(name)
    这是一个文档

函数调用时可以采用关键字绑定，使用了关键字绑定后，函数调用时的参数注入就不会根据下标索引了，而是会根据关键字索引，这样可以有效防止参数注入错误
```
>>> def myThirdFunction(name,age):
	print('我的名字是'+name+',今年'+age+'岁')

	
>>> myThirdFunction(age='29',name='wcc')
我的名字是wcc,今年29岁
```

函数的默认参数：当函数调用时可以给定一个默认参数，防止调用时忘记给实参而报错

>>> def myforthFunction(name='wcc',age='32'):
	print('我的名字是'+name+',今年'+age+'岁')

	
>>> myforthFunction()#即使没有给定实参，程序也不会报错，函数会自动调用默认参数
我的名字是wcc,今年32岁
>>> myforthFunction('oop','21')
我的名字是oop,今年21岁

收集参数(可变参数)：为了应对程序开发者自己也不知道有多少个参数的情况(原理是py把这些参数全部都用元组打包起来，然后把全部参数放到形参元组里面去)
```
>>> def test(*params):#注意，params与*之间不能有间隔
	print('参数长度：',len(params));
	print('第一个参数:',params[1]);

	
>>> test(1,'wcc','a')
参数长度： 3
第一个参数: wcc
```

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

python支持函数嵌套定义,但不能直接调用被嵌套的函数

>>> def fun1():
		print('fun1')
		def fun2():
			print('fun2')
		fun2()

	
>>> fun1()
fun1
fun2

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

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
```
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]
```

映射关系(键值对):相当于java中的map的键值对

>>> data1 = {'wcc':'bigBoy','wcc1':'good','ntow':'small'}
>>> print(data1['wcc1'])
good

集合：用大括号括起来的没有键值对映射关系的一组数据称为集合，集合内的数据都是无序的，并且集合内的数据都是不重复的，集合会自动将重复的数据去重（只保留一个），并且不支持索引

>>> 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)

文件操作

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(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：

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

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

ndarray：是一个多维数组对象，由两部分构成
1. 实际的数据
2. 描述这些数据的元数据（数据维度，数据类型）（元数据：又称中介数据，中继数据，为描述数据的数据，主要是描述数据属性的信息）

ndarray数组一般要求所有元素类型相同（同质），数组下标从0开始

创建一维数组：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'>

创建二维数组：和创建一维数组一样，不过只是参数部分用二维数组进行传入

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'>

条件索引：按条件索引出符合条件的数组元素

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'>

常用函数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]

常用函数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()是产生坐标轴的两种方式，所以此两种方式非常重要

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

figsize = (width,height) :figsize参数可以指定绘图对象的宽度和高度，单位为英寸（用来创建画布）
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）

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'>

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学习的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

python学习

python学习

python和C相异之处：

变量的定义：变量之前不需要加类型，直接进行赋值就可以了，但是如果一个变量没有被赋值直接使用的话会报错

运算符：比起C，python新加了两个个运算符为 **和//,前一个表示指数幂，后一个表示使两数相除的结果为整形（python规定用/进行相除的结果默认为浮点数）,运算优先级为幂运算为最高优先级，其余和C相同。

导包：格式是import + 名称，例如导入随机数

类型转换：类型之间可以随意转换，非常智能。它的字符型数字也可以直接转为int型

注释：python的注释是使用 #，而不是//

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

for循环：python中的for循环更加智能和强大，其书写方式为：

列表：相当于加强版的数组

元组：

python中的函数：以def 来开头定义一个函数,调用时根据其参数调用即可，并且python中函数的使用是相当灵活的，对语法要求不是很严格

python支持函数嵌套定义,但不能直接调用被嵌套的函数

python非常非常 灵活，返回值可以是一个函数，可以用一个变量接收这个函数，然后再用此变量进行调用。

python中的lambda表达式：lambda表达式非常精简，很适合python语言的风格

python中两个较常用的内置函数filter()和map()

映射关系(键值对):相当于java中的map的键值对

集合：用大括号括起来的没有键值对映射关系的一组数据称为集合，集合内的数据都是无序的，并且集合内的数据都是不重复的，集合会自动将重复的数据去重（只保留一个），并且不支持索引

文件操作

python在数据处理中的应用

python的模块:

总结起来分为三种：

模块导入机制

NumPy：

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

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

NumPy Matplotlib：

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

Pandas基础

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

前端开发

后端开发

移动端开发

数据库

服务器运维

人工智能

区块链

游戏开发

网站运营

大数据/云计算

软件工程

软件/开发工具使用

资讯

python非常非常灵活，返回值可以是一个函数，可以用一个变量接收这个函数，然后再用此变量进行调用。

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