每日更新【Python数据分析】语言精要基础回顾

来源：互联网发布：adobe有哪些软件编辑：程序博客网时间：2024/04/29 02:37

Python解释器

基础知识

语言语义

缩进，而不用{ }

建议4个空格作为默认缩进量→这样，编辑器就会将制表符替换为4个空格。

注意例子中的append()方法：list.append(obj)

万物皆对象

注释

函数调用和对象方法调用

http://blog.csdn.net/luckytanggu/article/details/51714757 python的位置参数、默认参数、关键字参数、可变参数区别

变量和按引用传递

a=[1,2,3]

b=a

在某些语言中，赋值过程会使原数据被复制。而在Python中，a、b均指向同一个对象，即原始列表[1,2,3]。

动态引用，强类型

跟许多编译型语言（如Java和C++）相反，Python中的对象引用没有与之关联的类型信息。

属性和方法

Python中的对象通常都既有属性（attribute，即存储在该对象“内部”的其他Python对象）又有方法（method，与该对象有关的能够访问其内部数据的函数）。它们都能通过obj.attribute_name这样的语法访问。

“鸭子”类型

指“对于一只鸟类动物，不用管是不是鸭子，只要看它像不像鸭子就可以了”。一般来说，可能不关心对象类型，只是想知道它到底有没有某些方法或行为（详见书P408）iter()函数：http://www.cnblogs.com/yitouniu/p/5243136.html迭代器和生成器：http://www.jb51.net/article/73939.htm

引入

import as``` / from ```import``` as```

二元运算符和比较运算符

判断两个引用是/否指向同一个对象：is/is not关键字

严格与懒惰

有些Python技术（尤其是用到迭代器和生成器的）可用于实现延迟计算，在数据密集型应用中，处理高负荷计算时派上用场。

可变和不可变的对象

大部分Python对象均可变（mutable），如列表、字典、Numpy数组及大部分用户自定义类型（类），即包含的对象或值可修改——但并不建议修改；而其他的（如字符串和元组等）是不可变的（immutable），即不修改原内存块的数据，即使操作成功了，也只是创建了一个新对象并将其引用赋值给原变量而已。

标量类型

数值类型

字符串

Python字符串是不可变的，要修改字符串就只能创建一个新的；

由于字符串其实是一串字符序列，因此可被当作某种序列类型（如列表、元组等）进行处理。

比如在使用Python进行读取的文件时，总需要在路径中去除掉一些特殊意义的字符进行转义，
在网上搜了一下，在python中除了可以使用‘\’之外，我们也可以使用 r 加在所要处理的字符外面，这样就不用专门的去处理引号之中的特殊字符了。

字符串格式化：%s表示将参数格式化为字符串，%.2f表示一个带有2位小数的数字。%d表示一个整数，

要用实参替换这些格式化形参，需要用到二元运算符%以及由值组成的元组，如：template=‘%.2f %s are worth $%d' template %(4.5560,'Argentine Pesos',1)

布尔值

python numpy中nonzero()的用法 http://www.cnblogs.com/1zhk/articles/4782812.html

类型转换

None

Python字符串处理NoneType的处理 http://www.cnblogs.com/BeDPS/p/3287332.html

日期和时间

python datetime处理时间 http://www.cnblogs.com/lhj588/archive/2012/04/23/2466653.html

strftime方法：将datetime格式→字符串

strptime方法：将字符串→datetime对象

http://www.runoob.com/python/att-time-strftime.html

datetime.timedelta：两个datetime对象的差，用于时间比较（将一个timedelta加到另一个datetime上会产生一个新的datetime）

控制流

if、elif、else

for循环

for value in collection:

#对value做一些处理

注意continue和break关键字的使用；

若集合或迭代器的元素是序列类型（比如元组或列表），还可方便地将这些元素拆散成for语句中的多个变量，如for a,b,c in iterator：

while循环

pass“空操作”语句

可被用于那些没有任何功能的代码块中，常将其作为代码中的占位符

异常处理

try/except块，其中except后可注明是什么类型的错误，如 try: ``` except (ValueError,TypeError):```

三元表达式

true-expr if condition else false-expr

如：x=5 'Non-negative' if x>= else 'Negative' → 'Non-negative'

数据结构和序列

Python中元组，列表，字典的区别 http://m.blog.csdn.net/article/details?id=38384047
Python 标识符与保留字（关键字） http://m.blog.csdn.net/article/details?id=8802948

理解Python的迭代器 http://python.jobbole.com/81916/

元组 tuple

由小甲鱼的学习

元组
与列表相似，但元组不可改变！

创建和访问元组：tuple1=() tuple=(1,)——需加逗号以证明其是元组而不是int型数字
更新和删除元组：重复* 关系> < = >= 成员in /not in 逻辑and/or 拼接元组左右类型需一致，如temp=temp[:2]+('a')+temp[4:]

一维、定长、不可变。

eg：tup=4,5,6 或 tup=(4,5,6),(7,9)

通过调用tuple，任何序列或迭代器都能被转为元组，例：tuple=([1,4,2])——(1,4,2)

tup=tuple('string') tup——('s', 't', 'r', 'i', 'n', 'g')

可学习，tuple详解：http://www.jb51.net/article/47986.htm

通过“+”连接元组、元组*整数→连接该元组的副本

注意：对象本身是不会被复制的，这里涉及的只是它们的引用而已。

元组拆包 unpacking——若对元组型变量表达式进行赋值，Python就会尝试将等号右侧的值进行拆包：

例：tup=(4,5,6) a,b,c=tup b——5

嵌套元组也能拆包，例：tup=4,5,(6,7) a,b,(c,d)=tup d——7 可方便地交换变量值，直接：a,b=b,a

元组方法——最有用的是count（对列表也是如此）：

计算指定值出现的次数，例：a=(1,2,2,5) a.count(2)——2

列表 list

由小甲鱼的学习

创建：普通列表/混合列表/空列表
如member("小甲鱼","牡丹","怡静")

向列表添加元素：
member.append()只能一个参数
member.extend()注意其参数是列表，即用一个列表去扩充另一个列表
member.insert()把某元素插到第几个位置，从0计起

交换列表中的元素：
借助temp

删除列表中的元素：
member.remove()
del语句如del member[1]、del member
member.pop() 若无参数，去除最后一个元素并返回

列表分片 Slice（一次性获取多个元素）：
member[1:3]——左包含右不包含，共2个元素
member[:3]、member[1:]——省哪到哪
member[:] 即原列表的拷贝（与直接list1=list2不同-最好不用）

列表常用操作符：
列表可比较大小（即比较其元素）
列表最好不相加≈extend()，但不能“+”单个元素-左右类型不同故不能直接相加→应用append()或insert()
*：列表可“*”以实现复制，也可list *= 3，即复制三次
列表可以套列表，可访问list1[1][1]

列表常用方法：
list.reverse()翻转列表，无参数
list.sort()排序，默认从小到大——从大到小：可先sort排序再reverse翻转呀
sort(func,key,reverse)指定排序的算法，跟算法搭配的关键字（前俩参数是默认的：归并）sort(reverse=True)就从大到小排了

注：
len()列表长度属于对象的方法，用“.”，即列表的内置方法
dir()列出某个类型的所有可用方法，参数可以是类型type或此类型的对象，如dir(list) 或 dir([])

一维，变长，可变，通过[ ]或list函数进行定义。列表和元组语义上差不多，再很多函数中可互换。

可通过下标修改其值，例：f=['1','fg'] f[1]=5——['1', 5]

添加和移除元素：append()方法：list.append(obj)，将元素添加到列表末尾

insert()方法：list.insert(index, obj)，将元素插入到列表的指定位置（注意是index索引，从[0]开始！）

pop()方法，移除并返回指定索引处的元素

remove()方法，按值删除（第一个符合要求的）元素

in关键字判断列表中是否含有某个值：'s' in a_list——True

然而，判断列表中是否含有某个值的操作比字典和集合慢得多，因为Python会对列表中的值线性扫描，而另外两个基于哈希表，瞬间就能完成判断。

合并列表：“+”号或对于一个已定义的列表，用extend()方法来一次性添加多个元素

例：everything=[] for chunk in list_of_lists: everything.extend(chunk)比everything=everything+chunk好很多

排序：调用列表的sort()方法可以实现就地排序（无需创建新对象）如：a.sort() s.sort(key=len)次要排序键，即按len排序

二分搜索及维护有序列表内置的bisect模块实现了二分查找及对有序列表的插入操作：

>>> import bisect （注意位置到底是哪个与索引相区分）
>>> c=[1,2,2,3,4,7]
>>> bisect.bisect(c,8)(c,2)——bisect.bisect可以找出新元素被插入哪个位置才能保持原列表的有序性
3
>>> bisect.insort(c,8)—— bisect.insort将新元素插入到指定位置
>>> c
[1, 2, 2, 2, 3, 4, 7]

切片——选取序列类型的子集（数组、元组、Numpy数组等）的子集，其基本形式由索引运算符（[]）以及传入其中的start:stop构成

注意：如seq[2,5] start包含，stop不包含——即索引[2]、[3]、[4]

start或stop均可省略，此时它们分别默认为序列的起始处和结尾处

负数索引从序列的末尾开始切片，对应位置依次是 -N~ -1

可以在第二个冒号后加上步长step，如每隔一位取一个元素：seq(::2)

使用-1，实现列表或元组的反序

字符串

小甲鱼字符串的方法：http://bbs.fishc.com/forum.php?mod=viewthread&tid=38992&extra=page%3D1%26filter%3Dtypeid%26typeid%3D403

格式化字符串

若有多个参数，以元组的(,)形式隔开
%f 浮点数默认六位，故后面会补0

小甲鱼字符串格式化符号及转义字符：http://bbs.fishc.com/forum.php?mod=viewthread&tid=39140&extra=page%3D1%26filter%3Dtypeid%26typeid%3D403

格式化字符串format方法精彩用法：http://blog.csdn.net/handsomekang/article/details/9183303

位置参数：如"{0} love {1].{2}".format("I","FishC","com")
关键字参数:如"{a} love {b].{c}".format(a="I",b="FishC",c="com")

注：同时出现时，位置参数必在关键字参数之前
冒号表示格式化符号的开始

小甲鱼进制转换教程
十进制：0~9，逢十进位
八进制：0~7，用10表示8,11表示9…
十六进制：0~9+A~F，用A表示10，十六进制数A0表示十进制的160（A表示的数字是10,乘以所在位的计数单位16，故160）

序列

可迭代
list() 将一个可迭代对象转为列表
tuple() 将一个可迭代对象转为元组
str() 将obj对象转为字符串
max() 返回序列或参数集合中的最大值
min() 返回序列或参数集合中的最小值
sum(iterable[,start=0]) 返回序列iterable和可选参数start的总和
sorted() 排序

sorted

将任何序列返回为一个新的有序列表

sorted和set结合使用→得到一个由序列中的唯一元素组成的有序列表注：set（集合，其中的元素不能重复）

reversed() 颠倒

reversed

adj. 颠倒的；相反的；（判决等）撤销的 v. 颠倒；翻转

按逆序迭代序列中的元素，如 list(reversed(range(10)))
enumerate() 生成由每个元素的index值和item值组成的元组

enumerate

逐个返回序列的(i,value)元组——例for i,value in enumerate(collection): #用value做一些事情

求取一个将序列值（假定是唯一的）映射到其所在位置的字典——例 some_list=['a','b','c'] m=dict((v,i) for i,v in enumerate(list)) m→{'b':1,'c':2,'a':0}

zip()返回由各参数序列组成的元组，如a=[1,2,3] b=[7,8] 若直接zip(a,b)——<zip object at 0×02EE3C60>表示一个对象，下面将它转为列表 list(zip(a,b))=[(1,7),(2,8)]

zip

将多个序列（列表、元组等）中的元素“配对”，从而产生一个新的元组列表，zip可接受任意数量的序列。

最常见的做法是同时迭代多个序列，还可结合enumurate一起使用。

对于“已压缩的”即zipped序列，可用zip对该序列进行“解压”，即将一组行转为一组列。

>>> a=[('a','9'),('b','8')]
>>> b,c=zip(*a) ——这里的zip(*a)相当于zip(a[0],a[1])
>>> b——('a', 'b')

字典

字典 http://www.jb51.net/article/47990.htm

字典输出无序参考https://www.zhihu.com/question/24306558

创建字典的方式之一：使用{ }并用冒号分隔键和值

del关键字 和 pop方法（删除指定值后返回）可以删除值

keys 和 values方法分别用于获取键和值的迭代器（如dict.keys()）

update方法，将字典合并到另一个字典中去

从序列类型创建字典

将两个序列中的元素两两配对成一个字典 ∵字典本质就是一个二元元组集，可用dict类型函数直接处理二元元组列表：mapping=dict(range(5),reversed(range(5)))

默认值

字典的get和pop方法可以接受一个可供返回的默认值

dict.get(key, default=None)        key：查找的键值，default：键不存在时，设置的默认键值。

words=['apple','bat','bar','atom','book']by_letter={}for word in words:letter=word[0]if letter not in by_letter:by_letter[letter]=[word]else:by_letter[letter].append(word)

>>> by_letter{'a': ['apple', 'atom'], 'b': ['bat', 'bar', 'book']}

字典的setdefault方法可替换上面的if-else块

dict.setdefault(key, default=None)      key：查找的键值，default：键不存在时，设置的默认键值。

内置的collections模块的defaultdict类 （from collections import defaultdict）……

字典键的有效类型

字典值可以是任何Python对象，但键必须是不可变对象，如标量类型（整数、浮点数、字符串）或元组（元组中的所有对象也必须是不可变的）

如果要将列表当作键，最简单的办法是将其转为元组，如下：

>>> d={}
>>> d[tuple([1,2,3])]=5
>>> d
{(1, 2, 3): 5}

集合

集合（set）是由唯一元素组成的无序集，可将其看成只有键而没有值的字典。

集合两种创建方式：set函数或用{}包起来淡定集合字面量——即set([1,2,5])或{1,2,5}

集合支持各种数学运算，如并、交、差以及对称差等，子集/超集等，注：集合相等也用“==”！如{1,2}=={1,2}而不是一个“=”！

列表、集合以及字典的推导式

列表推导式是最受欢迎的Python语言特性之一。它使你能够非常简洁地构造一个新列表：只需一条简洁的表达式，即可对一组元素过滤，并对得到的元素进行转换变形，

基本形式：[expr for val in collection if condition]过滤器条件可以省略，只留下表达式。

集合和字典的推导式跟列表推导式很相似，唯一的区别就是用{ }而不是[ ]

嵌套列表推导式

some_tuples=[(1,2,3),(4,5,6),(7,8,9)]flattened=[x for tup in some_tuples for x in tup]   #注意顺序，与[[x for x in tup] for tup in some_tuples]不同flattened → [1,2,3,4,5,6,7,8,9]