跟老齐学python数据分析笔记_跟老齐学python笔记（1）

第一章 基本的对象类型

1.1 数字

1.1.1 数字

每个对象,在内存中都有着自己的地址,这就是他的身份.

用内建函数id()可以查看每个对象的内存地址,即身份,且用此方法得到的内存地址是只读的,不能修改----id(3.222222) 140612356

type()可以用来查询数据类型,type()得到的结果也是只读的----type(3.0)

1.1.2 变量

对象有类型,变量无类型,变量就只相当于标签. python中变量的特点就是可以四处乱贴标签.他没有类型

1.1.3 简单的四则运算

浮点型 + 整型 = 浮点型

1.1.4 整数溢出问题

参与运算的书或者运算结果超过了计算机中最大的数了,这种问题称之为"整数溢出问题"

在python中无需担心整数溢出,因为它支持无限精度的整数,因为python中的int和long类型可以自动转换, 当超过int类型时会自动转为long类型

1.2 除法

1.2.1 整数与整数相除

整数与整数相除的结果也是整数,并且是直接去掉小数位,并不是四舍五入----7/2 3

1.2.2 浮点数与整数相除

不管是除数还是被除数,只要有一个是浮点数,结果就为浮点数

但是会出现一些情况: 0.1 + 0.2 0.30000000000000004 ,出现这种情况是因为这些十进制的数要转换成为二进制才能被计算机所处理,但是转换为二进制后, 并不能精确地等于十进制中的0.1, 0.1转换成二进制0.0001100110011001100110011001100110011001100110011...

1.2.3 引用模块解决除法问题

引入模块的几种形式:

(1) import modle_name

(2)from modle1_name import modle2_name 其中modle2_name 是modle1_name的子模块或者方法

from __future__ import division 这样不管什么情况,都能得到浮点数了

1.2.4 余数

用%来取得两个数相除的余数

内建函数divmod(a, b) 表示a除以b, 返回的是一个元组(x, y)其中x是商, y是余数. a和b只要有一个是浮点型,则结果全部是 浮点型

1.2.5 四舍五入

round(a, b) a是要四舍五入的数, b是要精确到小数点后几位

1.3 常用数学函数和运算优先级

1.3.1 使用math模块

math.pi 3.141592653589793

dir(module)可以查看任何模块中所包含的工具

dir(math) ['__doc__', '__name__', '__package__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'hypot', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']

help(math.pow), 可以用help(方法名)在交互模式下查询该方法的用途(功能及返回)

math.sqrt(9)-->3 开根号

math.floor(3.9)-->3.0 向下取整

math.fabs(-2)-->2 绝对值

abs(-3)--> 绝对值

math.fmod(5, 3)-->2 取余数

1.3.2 两个函数

1.求绝对值 abs()

2.四舍五入 round(number [, ndigits]) ndigits默认为0, 如: round(1.23)-->1.0

1.4 第一个程序

1.5 字符串

1.5.1 字符串

字符串是由单个字符组成的有限串行,字符串是对象类型,用str来表示.字符串的对象通常用单引号或者双引号包裹起来,其效果是一样的

如何解决'what's your name?'的打印问题

方法一:用双引号包裹单引号-->"what's your name?"

方法二:使用转义符-->'what\'s your name?'

\(反斜杠) 表示转义符

1.5.2 变量和字符串

1.5.3 连接字符串

字符串连接起来用“+”，用“+”连接起来的两者必须是同一类型，int与str相加时python并不会自动将int转换成str

str(a)可以将任意对象转换为字符串对象，Int(a)可以将数字型字符串转换为整型

repr()函数与str()函数都可以将任意类型转换为字符串，但是两者还是有差别的

1.5.4 转义字符

\----(在行尾时)续行符

\n----换行符

\t----横向制表符

1.5.5 原始字符串

r"C:\news"，创建字符串时，在字符串之前加上r，则字符串中的所有符号均表示原始含义

1.5.6 input()与print()

input()输出的时str类型

1.5.7 索引和切片

索引和切片并不是在原字符串上进行修改

索引：

lang = "study"

"study"[0]---->"s"

lang.index(4)---->"y"

lang[1:3]---->"tu"

lang[1:]---->表示从索引1(包括)切到末尾

lang[:3]---->表示从索引3(不包括)切到开头

lang[:]---->表示整个字符串

不管是一个字符还是多个字符，通过索引得到字符的过程都叫做切片

如果切片的第二个数字大于字符串的长度，则就算再大也只是切到结尾

c = lang,c和lang指向的是统一字符串(地址相同)

1.5.8 基本操作

所有序列都有如下操作，字符串时序列的子集

len():返回序列长度

"+"：连接两个字符串

"*"：重复字符串

in：判断元素是否在序列中

max()：返回最大值，如果是字母(符)，则比较在ASCII码中的位置

min()：返回最小值，如果是字母(符)，则比较在ASCII码中的位置

cmp(str1, str2)：比较大小(也可以比较整数)，如果str1>str2,则返回1,否则返回-1，相等则返回0，如果遇到两个长字符串，先比较第一位，如果相等则比较第二位，以此类推，知道比较出大小，如果比到位数不够时还没分出大小，则位数多的大

=======================================================

ord()：内建函数，可以返回一个字符的ASCII码的位置(十进制表示)

chr()：内建函数，可以根据输入的整数位置来查询ASCII码中该位置的字符

1.5.9 常用的字符串方法

lang = "work hard"

lang.isalpha()：返回布尔值，判断是否为字符串

lang.split(" ")：根据括号中的分隔符来对字符串进行分割，返回一个列表，并不是在原字符串上进行修改，且如果括号中如果什么都没有，则默认以字符串中的所有分隔符位分割符，对字符串进行分割

"(分割符)".join(lang.split())：是split()方法的反向操作，将列表中的元素进行连接，元素与元素之间用jion()方法的分割符进行连接，返回一个字符串

lang.strip()：去掉字符串左右两边的空格，返回一个新字符串，并不是在原字符串上进行修改

lang.Upper()：转成大写 ---->lang.isupper()

lang.Lower()：转成小写 ---->lang.islower()

lang.Capitalize()：将每个单词的第一个字母转成大写 ---->lang.istitle()

以上转换均不在原字符串上进行修改

1.5.10 字符串的格式化输出

print(" my name is {}, i am {} years old".format("yzp", 18))

1.6 字符编码

1.6.1 编码

编码方案有两套：一套在信息发出者那里，一套在信息接收者那里

1.6.2 计算机中的字符串编码

1.6.3 encode()和decode()

1.7 列表

1.7.1 定义

在python中，用[]表示列表。

在java中，数组中的元素只能是一种类型，要不全是int型，要不全都是str等等。但是在python的列表中，元素可以是任意类型的混合：[int, str, tuple, set, dict]

1.7.2 索引和切片

因为列表也属于序列，所以列表也有切片和索引以及序列的哪些方法，只不过列表中的操作单位是序列

lst = [1, 2, 3]

lst.index(-1)：列表中最后一个元素，列表中有一种排序方式是最右边的是-1，然后向左依次是：-2, -3...

序列的切片，右边的数一定要小于左边的数

1.7.3 反转

lst[: : -1]---->将lst进行反转，返回一个新列表，并不是在原列表上进行修改

list(reversed(lst))---->将列表进行反转，返回一个新列表，并不是在原列表上进行修改

list(reversed("abcd"))---->['d', 'c', 'b', 'a']

1.7.4 对list进行操作

序列中的操作：len()、"+"、"*"、in、max()、min、cmp(str1,str2)

lst1 = [1, 2, 3] lst2 = ['a', 'b', 'c']

lst1.append(a)：是整建制的追加，向lst1的末尾处添加新元素，在原列表上进行修改。相当于 lst[len(lst):] = ['a']

1.7.5 列表的函数

1、append()和extend()

lst1,append("big")---->[1, 2, 3, 'b', 'i', 'g']

lst1.extend("big")---->[1, 2, 3, "big"]

extend()方法是个体化扩编，extend()函数也是将另外的元素增加到一个已知列表中，且元素必须是iterable的，但是字符串并不是iterable的，所以extend()函数是将字符串拆成一个一个的字符，该函数实在原列表上进行操作

hasattr(lst, '__iter__')：判断该类型中是否有'__iter__'函数，即判断该类型是否是可迭代的，返回布尔值

extend和append都是在原列表上进行修改，内存还是原来的内存，只是内容增多了

所以列表是可以修改的，这种修改，是在原地址(原内存)中进行修改，原地修改就不会有返回值，所以就不能赋值给某个变量

2、count

list.count(x) Return the number of times x appears in the list

lst.count(x)：返回元素x在列表中出现的次数

3、index

list.index(x) Return the index in the list of the first item whose value is x. It is an error if there is no such item

lst.index(x)：返回列表中第一个元素x的位置，如果该元素不在列表中则会报错

4、insert

list.insert(i, x) Insert an item at a given position. The first argument is the index of the element before which to insert, so a.insert(0, x) inserts at the front of the list, and a.insert(len(a), x) is equivalent to a.append(x).

lst.insert(i ,x)：在i的前面插入元素x，如果i超过了lst的长度，则在末尾添加元素

5、pop()和remove()

Remove the first item from the list whose value is x. It is an error if there is no such item

lst.remove(x)：删除列表中元素x，若列表中没有x会报错

Remove the item at the given position in the list, and return it. If no index is specified, a.pop() removes and returns the last item in the list

lst.pop([i])：取出列表中第i个位置的元素，并在原列表中删除，若没有指定位置，默认取出最后一个元素

这两个方法如果执行成功，则不会有任何反应，因为是原地修改

6、reverse

lst.reveser()：将列表中元素进行翻转，是在原列表上进行修改，所以不会有返回值。

7、sort

sort(...) L.sort(cmp=None, key=None, reverse=False) ‐‐ stable sort IN PLACE; cmp(x, y) ‐> ‐1, 0, 1

lst.sort()是在原列表上进行修改，没有返回值。

lst1 = [1, 2, 3] lst2 = ['ab', 'abcd', 'abc']

lst1.sort()---->[3, 2, 1]

lst1.sort(reverse = True)---->[1, 2, 3]

lst1.sort(key = len)---->['ab', 'abc', 'abcd']

1.8 比较列表和字符串

1.8.1 相同点

两者都属于序列类型，序列类型中的每个元素都可以通过一个编号进行访问，还可以进行切片，序列的方法也是通用的。

1.8.2 不同点

列表可以改变，字符串不可以改变，这里的改变是在原地址对对象进行修改。

1.8.3 多维列表

1.8.4 列表和字符串进行相互转化

str()：转换为字符串形式

list()：转换为列表形式

1.9 元组

1.9.1 定义

元组都是用圆括号括起来的，元素与元素之间用逗号隔开，当元组中只有一个元素时，也要在元素后面加逗号。

元组中的元素是不可改变的，这点跟字符串类似。元组中的元素又可以是任意类型，这点跟列表又类似

1.9.2 索引和切片

元组也属于序列，序列的方法也适用于元组。

可以用list()函数和tuple()函数将对象转换成列表、元组

1.9.3 用途

遍历；对不需要进行修改的数据"写保护"；元组可以在字典中当作key，因为字典中的key是不可变的

1.10 字典

1.10.1 创建字典

创建一个空字典：mydict = {}

字典中，键是唯一的，是不可变对象，值不是唯一的，可以是任意类型的对象，键与值之间用":"，键值对之间用逗号隔开。

mydict["name"] = "yzp"：增加键值对的方法

字典是可以在原地修改的，即他是可变的

mydict = dict(name = "wyy", age = 18 )---->{"name" : "wyy", "age" : 18}

website = {}.fromkeys(("third","forth"),"facebook")---->{'forth': 'facebook', 'third': 'facebook'}

1.10.2 访问字典的值

可以通过键来访问字典的值

1.10.3 基本操作

字典也属于序列，序列的方法适用于字典

1.10.4 字符串格式化输出

1.10.5 相关概念

1、关联数组

2、散列表

1.10.6 字典的函数

copy和deepcopy

ad = {"name":"qiwsir", "lang":"python"}

cd = ad.copy()

用id()函数查询发现cd和ad的地址不同，其中元素的地址也不同，即copy()函数在内存中又开辟出一块新空间

x = {"name":"qiwsir", "lang":["python", "java", "c"]}

y = x.copy()

用id()函数查询发现y和x分别占据着不同的内存地址，但是两个字典中键"lang"的值的地址却是相同的，这是因为python只会储存基本数据类型，像是int、str这些，当对这些进行复制时，python会在内存中重新开一个地址进行储存，但是list,tuple等其他的数据类型，python在对他们进行复制时并不会在内存中重新开辟一个空间进行储存，而是用标签引用原来的对象。

所以copy()被称之为浅拷贝，而deepcopy()被称之为深度拷贝,deepcopy()在使用之前需要引入copy库

x = {"name":"qiwsir", "lang":["python", "java", "c"]}

import copy

y = x.deepcopy()

用id()函数查询发现x和y的地址不同，其中元素的地址也不同(包括列表)。

2、clear()

mydict.clear()：清空一个字典中的所有元素，只留下一个空字典

del mydict：删除字典，即删除该字典的内存空间

3、get和setdefault

get(...) D.get(k[,d]) ‐> D[k] if k in D(return it's value), else d. d defaults to None.

mydict.get(x)：获取键"x"的值，如果没有"x"键，则返回d，d默认为None。

mydict["x"]：也能获取键"x"的值，但是如果字典中没有该键，此方法就会报错

setdefault(...) D.setdefault(k[,d]) ‐> D.get(k,d), also set D[k]=d if k not in D

首先，它要执行D.get(k,d)就跟前面一样了，然后，进一步执行另外一个操作，如果键k不在字典中，就在字典中增加这个键值对。当然，如果有就没有必要执行这一步了。

4、item/iteritems，keys/iterkeys，values/itervalues

>>> dd = {"name":"qiwsir", "lang":"python", "web":"http://www.itdiffer.com"}

>>> dd_kv = dd.items() #显然此方法是有返回值的

>>> dd_kv---->[('lang', 'python'), ('web', 'www.itdiffer.com'), ('name', 'qiwsir')]

=======================================================

>>> dd = {'lang': 'python', 'web': 'www.itdiffer.com', 'name': 'qiwsir'}

>>> dd_iter = dd.iteritems() >>> type(dd_iter)

>>> dd_iter

>>> list(dd_iter) ---->[('lang', 'python'), ('web', 'www.itdiffer.com'), ('name', 'qiwsir')]

这种迭代器类型的数据不能直接输出，必须用list()转换一下，才能看到里面的真面目

5、pop和popitem

pop(...) D.pop(k[,d]) ‐> v, remove specified key and return the corresponding value. If key is not found, d is returned if given, otherwise KeyError is raised

mydict.pop(k)：字典中pop函数的参数不可以省略，这点和列表的pop()函数有区别

dd.pop("name") Traceback (most recent call last): File " ", line 1, in KeyError: 'name'

D.popitem()跟list.pop()有相似之处，不用写参数(list.pop()可以不写参数)，但是，D.popitem()不是删除最后一个，dict没有顺序，也就没有最后和最先了，它是随机删除一个，并将所删除的返回。 如果字典是空的，就要报错了 。返回值是元组类型，且其元素为所删除的键和值。

6、update

mydict1.update(mydict2)：更新字典，没有返回值。将mydict2添加到mydict1中，mydict2不变

7、has_key

mydict.has_key("x")：查看字典中是否含有'x'键。返回布尔值

与"x" in mydict 类似

1.11 集合

能够索引的：list/str 其中元素可重复

可变的：list/dict 其中的元素/键值对可以原地修改

不可变的：str/int/tuple 不可以原地修改

无序序列：set/dict

1.11.1 创建集合

集合中的元素不可重复，无次序

利用set()建立的集合是可变集合，可变集合都是不可哈希的

1.11.2 集合的函数

1、add和update

2、pop、remove、doscard、clear

pop()：随机取出一个元素，并在原集合中删除该元素。若没有会报错

remove(obj)：obj必须是set中的元素，否则会报错

discard(obj)：obj是set中的元素就删除，否则什么都不做

clear()：清除集合中的所有元素

1.11.3 补充知识

数学中的集合

1.11.4 不变的集合

set()创立的集合都是可原地修改的，或者说可变的，也可以说是不可哈希的

1.11.5 集合的运算

交并补