python中point python中points[a, 1]的用法

Part 1 基础知识（1）——基本操作

• 一、Python的基本操作

• 1. Python变量和简单数据类型

• （1）两种数字类型
• （2）列表

• a. 特点：
• b. 列表两种表示方法
• c. 其他
• d. 列表推导式

• （3）字典

• a. 直接创建
• b. 赋值：通过键值对
• c. 其他功能

• （4）集合

• 特点：

• （5）元组
• （7）布尔值

• 2. Python的基本操作

• （1）if条件判断
• （2）for循环

• a. 简介
• b. try-except:对循环中的错误直接报错，而不是直接停止

• （3）while循环

• 3.函数、模块和包、库

• （1）函数：组织好的代码段

• a. 定义函数：
• b. lambda匿名函数

• i. 特点
• ii. 创建lambda函数
• iii.功能

• c. 常见函数

• （2）类class:
• （3）模块module：
• （4）包package：
• （5）库library：

• a.简介
• b.其他常用第三方库

• 二、使用案例

• 1. 白噪音序列作图

一、Python的基本操作

1. Python变量和简单数据类型

（1）两种数字类型

整数型：integer_=1 #整数
浮点数：float_=0.1 #浮点数

（2）列表

a. 特点：

1、有序；因此若元素内容相同，但是序号不同，两个列表也不是相等的
2、可以用list()函数或者方括号[]创建，元素之间用逗号’,‘’分隔；
3、使用索引来访问元素，可切片；
4、可以有重复元素。

b. 列表两种表示方法

a=list()  
b=[]

c. 其他

list_=["one",2,[1,2,3]]   #列表内可以为多种形式的元素
list_[0]  #列表索引，从0开始
list_.append("four")   #在列表中添加“four”  
list_.extend(lst) 	#向list中添加列表lst
list_.count(a) 	#统计list中a的个数
list_.pop(1)  #删除list中索引的元素
list_.remove("one")  #删除list中的元素
list_.clear()   #列表清空
del(list_)  #删除列表
list_[0:3]   #取首不取尾
list_[-3:]  #倒数第三个到最后一个
len(list_)   #查看列表长度
print(a1 + a2)  #列表a1和a2拼接

d. 列表推导式

实现步骤：

语法格式：listname=[expression for variable in subject (if condition)]

1. 先复制X
   [x for x in X]
2. 再对x进行操作
   [x*x for x in X]

// Example 1
#对满足条件的x进行操作
[x*x 
 for x in X 
 if x>5]
// Example 2
words = ['Life', 'is', 'short', 'so', 'we', 'use', 'Python', 'python', 
         'is', 'easy', 'to', 'learn', 'and', 'easy', 'to', 'use']
lower_words = [w.lower() for w in words]
lower_words
wordset = set(lower_words)
[(w,lower_words.count(w)) for w in wordset]
// Example 3 字符操作
rankschool=["清华大学 1","北京大学 2","复旦大学 3","上海交通大学 4"]
school4=[i.split(' ')[0] for i in rankschool]
school4

（3）字典

字典：键-值对;

a. 直接创建

citydata=dict(city=['北京市','上海市','南京市'])   
dict_={"1":"one","2":"two","3":"three"}

b. 赋值：通过键值对

citydata2={}
citydata2["city"]=['北京市','上海市','南京市']

c. 其他功能

len(citydata2)  #查看长度
dict_["1"]="ONE"      #替换各个键  
dict_["1"]=["one","ONE"]  #嵌入列表
dict_["1"]  #字典索引
dict_["5"]="five"  #在字典中添加键值对
dictdata.items() 	 #返回dictdata所有item
	#遍历所有键值对
	for x,y in dictdata.items() :
		print(x,y)
dictdata.keys() 	 #返回dictdata的所有关键词
dictdata.values() 	 #返回dictdata的所有值
dictdata.get(keystr) 	 #获取关键词keystr对应的值
dictdata[keystr] 	 #获取关键词keystr对应的值

（4）集合

特点：

1、无序；
2、可以用set()函数或者方括号{}创建，元素之间用逗号”,”分隔；
3、不可索引，不可切片；
4、不可以有重复元素。

names2 = ['David', 'Mary', 'David', 'Swift', 'David']   #集合是无序的，所以当中也不能重复；集合可以用来去重；可以用set()函数或者方括号{}创建，元素之间用逗号”,”分隔；
#两个集合内的元素内容相同但是顺序不同，两个集合还是一样的
name_set = set(names2)
name_set.add('William')  #setdata.add(ele) 向setdata中加入ele

（5）元组

name_tuple = ('David', 'Mary', 'Henry', 'Swift', 'Lenard')   #元组是圆括号

形似列表，也可拼接、拆包和切片
数据不可更改

// Example 3 元组拼接
d = {'x': 'A', 
     'y': 'B', 
     'z': 'C' }
d.items()
	//1 自己复制d.items()自己
[i for i in d.items()]
	//2 对任何一个元素都要进行字符串的拼接操作
[i[0]+i[1] for i in d.items()]

（7）布尔值

用于逻辑判断，一般与if结合使用。

x = 4 in [1,2,4]  #True
y = 4 not in [1,2,4]  #False

2. Python的基本操作

（1）if条件判断

condition = False
if condition:
   print('condition为True')
else:
   print('condition为False')

（2）for循环

a. 简介

for循环可以遍历任何可迭代对象，如一个列表或者一个字符串
一般格式：

for <varible> in <sequence>:
	<statements>
else:
	<statements>

// Example 1
b=[1,2,3,4]
for i in b:
	print(i)
    //上述for循环可缩写为
    a=[i for i in b]
// Example 2
for i in range(6):
	print(i)
// Example 3 计算1^2+2^2+……+100^2
result=0
for i in range(1,101):
	result=result+1**2
print(result)

b. try-except:对循环中的错误直接报错，而不是直接停止

// Example 1  10作为被除数，取余数
for i in [10,2,0,4,5]:
	try:
		print(10%i)
	except:
		print("错误"）

（3）while循环

一般格式：
while 判断条件(condition):
执行语句(statements）······

// Example 1  
i=5
while i>=0:  
   //i>=0是终止条件，即未达到终止条件前，继续循环下面的语句
	print(i)
	i=i-1

3.函数、模块和包、库

（1）函数：组织好的代码段

a. 定义函数：

def函数常见参数定义&调用方式

• 位置参数
• 关键词参数
• 默认参数

#位置参数
def hello1(name,address):
    return '大家好！我是{0},来自{1}'.format(name,address) #0对应name,1对应address                                  
hello1('萝卜头','地球')
#关键词参数
def hello2(name,address):
    return '大家好！我是{0},来自{1}'.format(name,address) 
hello2(name='萝卜头',address='地球')   ##直接通过关键词赋值
#默认参数
def hello3(name,address,major='会计学'):    #有默认值的参数需要放在后面
    return '大家好！我是{0},来自{1},专业为{2}'.format(name,address,major) 
hello3('萝卜头','地球')

b. lambda匿名函数

i. 特点

• 匿名函数是指没有声明函数名称的函数。
• lambda函数的行为方式与使用def关键字声明的一般函数相同。
• lambda函数可以接受任意数量的参数，但函数只能包含一个表达式。
• 表达式是lambda函数执行的一段代码，它可以返回任何值，也可以不返回任何值。
• lambda函数可以返回函数对象。

ii. 创建lambda函数

语法： lambda arguments(s): expression

x = lambda a,b,c: a+b*a+c
print(x(1,2,3))    //1,2,3分别对应a,b,c,为各个参数，返回函数值

iii.功能

功能1：赋值

功能2：将lambda函数作为参数传递给其他参数

//Example 1  列出0-20之间不能整除3的数
	//原函数一一定义
def odd(x):
	return x%3
X=range(21)
output=filter(odd,X)   ##filter(函数)为过滤序列，即过滤掉不符合条件的元素
print(list(output))    ##filter函数返回值是一个数组，因此需要用list()函数将其转化为列表
	//用lambda函数直接替换上面的odd函数，作为参数传递给fileter函数
print(list(filter(lambda x:x%3,range(21))))

功能3：返回值

// Example 2  输出a的N次方
def anfunc(n):
	return lambda x:x**n
cube=anfunc(3)   #cube函数为：a的3次方
cube(2)  #将2赋值给x,即求2的3次方

功能4：简化条件语句，将if……else语句缩减为单一的条件表达式

// Example 3  是否可以被3整除
divide3=lambda x:"True" if x%3==0 else "False"
print(divide3(20))
	//等价于下面的
def divide3(n):
	if n%3==0:
		return("True")
	else:
		return("False")
print(divide3(20))

c. 常见函数

函数	功能	例子	运行结果
abs(a)	对a取绝对值	abs(-1)	1
max(lst)、min(lst)	寻找lst中的最大、最小值	max([3, 2, 9])	9
sum(lst)	对lst内所有数字求和（也可元组、字典）	sum([3, 2, 9])	14
sorted(lst， reverse)	对lst排序； 参数reverse为布尔值控制升降序	sorted([3, 2, 9]) sorted([3,2,9], reverse=True)	[2, 3, 9] [9, 3, 2]
range(start, end, step)	生成以步长step，生成从start到end的数列,默认step=1，结果取不到end	list(range(1,5))	[1, 2, 3,4]
int(string)	将字符串数改为整数型	int(‘9’)	9
float(int/str)	将int或str改为浮点型	float(9)、float(‘9’)	9.0
list(iterable)	将可迭代对象为列表。这里的iterable可以为字符串，可以是列表	list(range(1,5)) list(range(1, 10, 2))	[1,2,3,4] [1, 3, 5, 7, 9]
enumerate(lst)	返回带有索引值的序列seq,需要list(seq)处理后才能看到seq	list(enumerate([‘a’, ‘b’, ‘c’]))	[(0,‘a’), (1, ‘b’), (2, ‘c’)]
tuple(lst)	将lst变为tuple	tuple([1,2,3])	(1,2,3)
set(lst)	将lst变为集合	set([1,4,4,4,3])	{1,3,4}
eval（expression)	执行一个字符串表达式 str_expression 是字符串表达式，可以是变量、函数等	eval（‘1+1’)	2
zip(lst1,lst2…)	将lst1,lst2…合并,返回zip对象。需要list处理一下zip对象	list(zip([1,2,3],[4,5,6]))	[(1, 4), (2, 5), (3, 6)]
type(x)	查看X的类型	type(‘2’)	<class ‘str’>
help(x)	查看X的相关信息	help([1, 2])	Help on list object…
map(func, lst)	对lst中的每一个个体都进行func操作,将func运算映射到lst上每个元素	list(map(sum, [[1,1], [1,2]]))	[2, 3]
print(value, end=‘\n’)	打印value	print(‘abc’)	abc
open(file, mode=‘r’, encoding=None)	打开file文件；mode 操作方式们，最常用的是r和a+。r读取， a+是追加写入；encoding是file的文件编码，主要是utf-8和gbk	open(‘data/test.txt’, encoding=‘utf-8’).read() 读取数据 #相对路径 data #绝对路径 C:Users\thunderhit\Desktop\Python数据分析入门\02-Python语法入门\data #以后都要用相对路径	在已有的文件内插入内容 f = open(‘data/test2.txt’, mode=‘a+’, encoding=‘utf-8’) f.write(‘\n还需继续努力’) f.close()

（2）类class:

描述相同的属性和方法的对象的集合，定义该集合中每个对象所共有的属性和方法。对象是类的实例。

（3）模块module：

以.py为后缀的文件，通常包含一些常数和函数。

（4）包package：

将模块、函数放到文件夹下面，通过“包.模块名”制定模块

（5）库library：

a.简介

由诸多函数组成，也可以包括模型和包

语法：import module1 [,module2[,…moduleN]

导入包：
 法1：import numpy as np   //np为简写
 法2：from math import exp as e  //从一个包中导入某部分命名为
 法3：from math import *   //将一个包完整导入

b.其他常用第三方库

第三方扩展库	功能简介
Numpy	支持数组计算，以及相应的高效的处理函数
Pandas	强大、灵活的数据分析和探索工具
Scipy	提供矩阵支持，以及矩阵相关的数组计算模块
Matplotlib	强大的数据可视化工具，作图库
StatsModels	统计建模和计量经济学，包括描述统计、统计模型估计和推断
Scikit-Learn	支持回归、分类、聚类等强大的机器学习库
Keras	深度学习库，用于建立神经网络以及深度学习模型
Gensim	用来做文本主体模型的库，文本挖掘分析

二、使用案例

1. 白噪音序列作图

在任何两个时点的随机变量都不相关，序列中没有任何可以利用的动态规律

import numpyasnp #导入包
from matplotlib import pyplot as plt #导入包
x=np.arange(1,10)  #调用numpy包创建一个数列，如果直接定义x=[1,2,3]，此时数据类型不能用来生成下面的y数列
y=3*x+1   #创建一个数列
plt.title("Matplotlib demo")   #调用pyplot包定义图的标题 
plt.xlabel("x axis caption")   #调用pyplot包定义x轴的标题 
plt.ylabel("y axis caption")   #调用pyplot包定义y轴的标题 
plt.plot(x,y)  #调用pyplot包作图，可以只写plt.plot(y) ，此时x默认为0,1,2,3,4
plt.show()   #让这个图显示出来。在anaconda中可以不需要这个语句也可以显示，但是在一般的python语言中需要。

#--------version1--------
import numpy as np  
import matplotlib pyplot as plt
plt.rcParams['figurefigsize']=(10,6) #控制图形大小
E_values=np.random.randn(100) #调用numpy包模拟100个正态随机变量的值 
plt.plot(evalues)  #调用pyplot包作图,模拟白噪音的震荡图
plt.show()

#--------vers1on2-------- 
ts_length=100  #定义一个100整数变量
e_values = []  #创建一个空的列表
for i in range(ts_length):  #用for循环
	e=np.random.randn()
	e_values.append(e)  #在列表中添加新的元素，即按顺序（1-100）生成100个随机数，依次添加到列表中
plt.plot(e_values) 
plt.show()

#--------version3--------
ts_length = 100
e_values=[]   
i=0  #用while循环生成100个随机值
while i < ts_length:
	e=nprandom.randn() 
	e_values.append(e) 
	i=i+1
plt.plot(e_values) 
plt.show()

#--------version4--------
def white_noise_plot(number):    #将上面的代码改进成函数形式
	ts_length=number   #定义数字的数量
	e_values=[]  
	i=0
	while i<ts_length:
		e=np.random.randn() 
		e_values.append(e) 
		i=i+1
	plt.plot(e_values) 
	plt.show()   #注意缩进一致性
white_noise_plot(100)