|
本文目录
这是我Python数据分析系列文章的第一篇，主要介绍Python基础部分，Python知识面比较广，本文主要是介绍平时使用比较多的知识点，更多的问题，大家可以后台私信我。 基础知识1、第一个Python代码 print('hello world') #Python3中print是一个函数
2、Python不区分大小写，严格缩进。 3、单行注释以#开头，多行注释以''' '''(三引号，可以是单引或者双引)开始结尾。 基本数据类型数据类型是每一种编程语言的必有的知识，Python也有其对应的基本数据类型，本节主要介绍其四种基本类型：整形、浮点型、布尔型。 #赋值操作=，==表示等于 int_value = 520 type(int_value) #<class 'int'> float_value = 19.9 type(float_value) #<class 'float'> boolean_value = True type(boolean_value) #<class 'bool'> 可以通过dir()或者help()查看其对应的属性和方法，比如查看整形： ['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']
其中带双划线的就是整形的可用方法，其他就是整形的属性。 基本数据结构Python基本的数据结构主要包括字符串、列表、元组、字典、集合等 字符串 1、基本方法 string_value = 'python' type(string_value) #<class 'str'> 字符串的内置方法可以通过dir()查询。 ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
str1 = 'hello world'
str1.split() #['hello','world']
str1.find('hello') #0
str1.replace('hello','Hello') #'Hello world'
str1.capitalize() #'Hello world'
'_'.join(str1) #'h_e_l_l_0_ _w_o_r_l_d'
2、切片 str2 = 'python'
s[0:1] #'p'
s[-1] #'n'
s[:-1]:'pytho'
tips:
列表 1、创建列表 l1 = [] l2 = [1,2,3] #中括号，以逗号间隔 type(l1) #<class 'list'> 2、方法 列表是一种Python基本数据结构，是可变类型，支持删减查等操作,相对来说遍历查找效率较低，不过使用方面。 l1.append(2) #列表元素添加
l1.extend([6,7,8,9]) #列表合并，注意与append的区别
l1.remove(2) #列表元素删除
l1.pop(0) #按index删除元素，注意与remove的区别
l1.index(2) #获取元素对应的index
l1.reverse() #列表翻转
l1.insert(0,2) #按照index插入元素
l1.count(2) #元素计数
l1.sort() #列表排序，区别于sorted()
l1.clear() #列表清除
l[0]=10 #列表元素修改
3、切片 与字符串类似，具体操作如下 l = [1,2,3,4,5,6,7,8] l[0] #[1],索引从0开始 l[-1] [8]支持正负缩影，-1表示列表最后一个元素 l[2:4] #[3,4] 注意左闭右开 l[:] #[1,2,3,4,5,6,7,8],相当于浅拷贝，在深浅拷贝知识点会讲到 l[::2] #[1,3,5,7]，step为2 l[::-1] #相当于列表翻转 l l[:3] #[1,2,3,4,5,6,7,8,1,2,3] [0]*5 #列表生成[0,0,0,0,0] 4、遍历 [i for i in range(5)] #[0,1,2,3,4]
元组 Python基本数据结构，不可变类型，不支持删查等操作 t = tuple() #空元组，小括号 t1 = (1,2,[3,4]) #注意嵌套 t1[0] = 0 #TypeError t1[2].remove(3) #(1,2,[4]) 注意列表可以删减操作 1、方法 t1 = (1,2,3,2,4,1)
t1.count(1) #2，计数
t1.index(3) #2，查找元素索引
2、赋值 a,b = (1,2) #a=1,b=2 a,*b1 = (1,2,3,4) #a=1,b=(2,3,4),注意*操作，函数参数有应用 元组创建和遍历优于列表。 字典 用{}包含，以键值对的形式存在，剑指不可重复，可变类型，支持基本操作。 d = {} #空字典，或者d=dict()
d1 = {'name:libai','gender':'男','age':55}
1、方法 #基本方法
cmp(d1, d2) #比较两个字典元素。
len(d1) #计算字典元素个数，即键的总数。
str(d1) #输出字典可打印的字符串表示。
type(d1) #返回输入的变量类型，如果变量是字典就返回字典类型。
# 访问字典中的值
d1['name'] # 查找不到会出错
d1.get('name') # 查找不到，返回None，查找效率更高
#1.get('name','not find') # 查找不到，返回not find
d1.keys() #获取字典所有的键的列表
d1.values() #获取字典所有的值的列表
d1.items() #获取字典的键值对
#字典的修改
d1['key'] = value #key存在即修改，key不存在即新增
d1.setdefault('key',value) #新增键值对,存在会出错
d1.pop('key') #必须要传值，因为字典是无序的
d1.popitem() #随机删除一个
del d1['key'] #删除元素
d1.clear() #清空字典
d1.update(d2) #将d2更新到d1,如果key存在则修改，不存在则添加
#字典的fromkeys方法创建字典，所有元素有一个默认值
{}.fromkeys(['key1', 'key2', 'key3'], 'value')
d1.has_key('key')#判断d1中是否有ke
集合 用大括号表示，或者用set()，集合里面的元素唯一、无序。 s = {} #空集合或者set()
s1 = {1,2,3,4,5}
s1[0] #KeyError,没有切片操作
1、方法 #基本方法 s1.add(5) #向集合中添加元素 s1.remove(5) #从集合中删除元素，当删除的元素不存在时，返回TypeError s1.discard(6) #从集合中删除元素,当删除的元素不存在时不出错 s1.pop() #任意删除一个值，如果集合为空，返回KeyError s1.clear() #清除集合中的值 #对集合进行排序 sorted(s1,reverse=True) list(set(l1)) #删除l1列表中的重复项 #并交补 s1.union(s2) #两个集合取并集 s1|s2 #等价上式 s1.intersection(s2) #两个集合取交集 s1&s2 #等价上式 s1.difference(s2) #两个集合取差集，在s1中，不在s2中 s1-s2 #等价上式 s2.issubset(s1) #判断s2是不是s1的子集 集合不能存储可变对象，也能去判断重复的对象。 基础语句语句可以称之为代码结构，在任何编程语言中都是基础和重点，不同代码编写，我们需要使用不同的语句。本节主要介绍Python语言的条件语句和循环语句。 条件语句 条件语句主要包括三种：
#if语句
if x=520:
print('我爱你！')
#if-else语句
if x=520:
print('我爱你！')
else:
print('我不爱你！')
#if-elif-else 语句
if x=520:
print('我一定爱你！')
elif x=88:
print('我可能爱你！')
else:
print('我不爱你！')
循环语句 循环语句主要包括for循环和white循环 #for循环 for i in range(10): print(i) #在for循环中，有一个常用的内置函数enumerate(),使用它比range()高效 for index，value in enumerate([1,2,3,4,5]): print(index,value) #white循环 n = 0 while n<5: n = 1 print(n) 函数Python内置函数和匿名函数 1、内置函数 函数是是任何一门语言中最主要的部分之一，在介绍Python之前先了解一下，Python内置的一些函数(所谓Python内置函数是指Python里面已经封装好的，不需要人为去编写，可以直接拿来使用的)，下面是一些常用的Python内置函数。 大部分内置函数在Python前面部分已经有所介绍，本节主要介绍三个内置函数map(),filter(),reduce()(注:Python3中reduce不在是一个内置函数)以及和Python匿名函数的使用。 #map
map(str,[1,2,3]) #['1','2','3']
# filter
filter(lambda x:x>2,[1,2,3,4,5]) #[3,4,5]
#reduce,在Python3中需要导入
from functools import reduce
reduce(lambda x,y: x y, range(1,8)) #36
2、匿名函数 用 lambda 关键字来创建一个小的匿名函数。这个函数返回两个参数的和：lambda a, b: a b 。lambda函数可以在需要函数对象的任何地方使用。它们在语法上限于单个表达式。从语义上来说，它们只是正常函数定义的语法糖。与嵌套函数定义一样，lambda函数可以引用包含范围的变量: def make_incrementor(n): #和一个普通函数一样 return lambda x: x n f = make_incrementor(42) f(0) #42 f(1) #43 #在一些如字典的排序中常用到 pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')] pairs.sort(key=lambda pair: pair[1]) pairs #[(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')] Python函数 1、Python函数定义 关键字 def 引入一个函数定义。它必须后跟函数名称和带括号的形式参数列表。构成函数体的语句从下一行开始，并且必须缩进。 #看一个基本的斐波那契函数
def fib2(n): #n是函数参数
result = []
a, b = 0, 1
while a < n:
result.append(a) # see below
a, b = b, a b
return result
fib2(100) #[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
2、函数参数形式 函数定义主要包括四种形式。
（1）必需参数 必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样，不然函数运行会出错。 def get_age(age):
return 'he is {}'.format(age)
get_age(28) #'he is 28'
（2）关键字参数 关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。 def parrot(voltage, state='a stiff', action='voom'):
print('-- This parrot wouldn't', action, end=' ')
print('if you put', voltage, 'volts through it.')
print('-- It's', state, '!')
#接受一个必需的参数（voltage）和两个可选的参数（state, action）。这个函数可以通过下面的任何一种方式调用.
parrot(1000)
parrot(voltage=1000)
parrot(voltage=1000000, action='VOOOOOM')
parrot(action='VOOOOOM', voltage=1000000)
注意：在函数调用中，关键字参数必须跟随在位置参数的后面。传递的所有关键字参数必须与函数接受的其中一个参数匹配（比如 actor 不是函数 parrot 的有效参数），它们的顺序并不重要。这也包括非可选参数， （3）默认参数 调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值。 def printinfo( name, age=35 ):
print ('名字: ', name)
print ('年龄: ', age)
return
#注意默认参数的使用
def add_end(L=[]):
L.append('END')
return L
#连续运行两次，结果不一致
add_end() #['END']
add_end() #['END', 'END']
#注：Python函数在定义的时候，默认参数L的值就被计算出来了，即[]，因为默认参数L也是一个变量，它指向对象[]，每次调用该函数，如果改变了L的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了。
#正确写法
def add_end(L=None):
if L is None:
L = []
L.append('END')
return L
#两次调用结果一致
add_end() #['END']
add_end() #['END']
（4）不定长参数 不定长参数以*或者**的形式存在。
def concat(*args, sep='/'):
return sep.join(args)
#传入一个元组
concat('earth', 'mars', 'venus')
#'earth/mars/venus'
concat('earth', 'mars', 'venus', sep='.')
#'earth.mars.venus'
#包含四种参数类型
def func(a, b, c=0, *args, **kw):
print 'a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw
args = (1, 2, 3, 4)
kw = {'x': 99}
func(*args, **kw)
#a = 1 b = 2 c = 3 args = (4,) kw = {'x': 99}
迭代器和生成器 1、迭代器 迭代器的使用并使得 Python 成为一个统一的整体。 比如使用for 语句时会调用容器对象中的 iter()。 该函数返回一个定义了 __next__() 方法的迭代器对象，该方法将逐一访问容器中的元素。 当元素用尽时，__next__() 将引发 StopIteration 异常来通知终止 for 循环。 你可以使用 next() 内置函数来调用 __next__() 方法: s = 'abc' it = iter(s) it #<iterator object at 0x00A1DB50> >>> next(it) 'a' >>> next(it) 'b' >>> next(it) 'c' >>> next(it) Traceback (most recent call last): File '<stdin>', line 1, in <module> next(it) StopIteration 看过迭代器协议的幕后机制，给你的类添加迭代器行为就很容易了。 定义一个 __iter__() 方法来返回一个带有 __next__() 方法的对象。 如果类已定义了 __next__()，则 __iter__() 可以简单地返回 self: class Reverse:
'''Iterator for looping over a sequence backwards.'''
def __init__(self, data):
self.data = data
self.index = len(data)
def __iter__(self):
return self
def __next__(self):
if self.index == 0:
raise StopIteration
self.index = self.index - 1
return self.data[self.index]
rev = Reverse('spam')
iter(rev)
<__main__.Reverse object at 0x00A1DB50>
for char in rev:
print(char)
m
a
p
2、生成器 Generator 是一个用于创建迭代器的简单而强大的工具。 它们的写法类似标准的函数，但当它们要返回数据时会使用 yield 语句。 每次对生成器调用 next() 时，它会从上次离开位置恢复执行（它会记住上次执行语句时的所有数据值）。 显示如何非常容易地创建生成器的示例如下: def reverse(data):
for index in range(len(data)-1, -1, -1):
yield data[index]
for char in reverse('golf'):
print(char)
f
l
o
g
可以用生成器来完成的操作同样可以用迭代器来完成。 但生成器的写法更为紧凑，因为它会自动创建 __iter__() 和 __next__() 方法。另一个关键特性在于局部变量和执行状态会在每次调用之间自动保存。 这使得该函数相比使用 self.index 和 self.data 这种实例变量的方式更易编写且更为清晰。除了会自动创建方法和保存程序状态，当生成器终结时，它们还会自动引发 StopIteration。 这些特性结合在一起，使得创建迭代器能与编写常规函数一样容易。 类与对象类提供了一种组合数据和功能的方法。创建一个新类意味着创建一个新 类型 的对象，从而允许创建一个该类型的新 实例 。每个类的实例可以拥有保存自己状态的属性。一个类的实例也可以有改变自己状态的（定义在类中的）方法。 类的定义 类定义内的语句通常都是函数定义，但也允许有其他语句。 class ClassName:
<statement-1>
.
.
<statement-N>
类对象 类对象支持两种操作：属性引用和实例化。 属性引用 使用 Python 中所有属性引用所使用的标准语法: obj.name。 有效的属性名称是类对象被创建时存在于类命名空间中的所有名称。 因此，如果类定义是这样的: class MyClass: '''A simple example class''' i = 12345 def f(self): return 'hello world' 那么 MyClass.i 和 MyClass.f 就是有效的属性引用，将分别返回一个整数和一个函数对象。 类属性也可以被赋值，因此可以通过赋值来更改 MyClass.i 的值。 __doc__ 也是一个有效的属性，将返回所属类的文档字符串: 'Asimple example class'。 类的 实例化 是使用函数表示法。 可以相像类对象就是会返回一个新的类实例的不带参数的函数。 举例来说（假设使用上述的类）: x = MyClass()
创建类的新实例 并将此对象分配给局部变量 x。 实例化操作会创建一个空对象。 许多类喜欢创建带有特定初始状态的自定义实例。 因此类定义可能包含一个名为 __init__() 的特殊方法，比如： def __init__(self): self.data = [] 当一个类定义了 __init__() 方法时，类的实例化操作会自动为新创建的类实例发起调用 __init__()。而且__init__() 方法还可以有额外参数以实现更高灵活性。 在这种情况下，提供给类实例化运算符的参数将被传递给 __init__()。 例如: class Complex:
def __init__(self, realpart, imagpart):
self.r = realpart
self.i = imagpart
x = Complex(3.0, -4.5)
x.r, x.i #(3.0, -4.5)
类和实例变量 实例变量用于每个实例的唯一数据，而类变量用于类的所有实例共享的属性和方法: class Dog:
def __init__(self, name):
self.name = name
self.tricks = []
def add_trick(self, trick):
self.tricks.append(trick)
d = Dog('Fido')
e = Dog('Buddy')
d.add_trick('roll over')
e.add_trick('play dead')
d.tricks
#['roll over']
e.tricks
#['play dead'
类的继承 一般情况下子类会继承一些父类的方法，并切可能会对父类的一些方法进行重写。 class DerivedClassName(BaseClassName):
<statement-1>
.
.
<statement-N>
Python有两个内置函数可被用于继承机制：
编程风格从学习python的那一刻起，你就已经准备好了写更长，更复杂的Python代码了，这时候有必要讨论一下代码风格。对于Python，PEP 8 已经成为大多数项目所遵循的风格指南；它促进了一种非常易读且令人赏心悦目的编码风格。每个Python开发人员都应该在某个时候阅读它。以下是为你提取的最重要的几个要点：
总结本文是Python数据分析系列文章的第一篇，简单的介绍一些Python语言特性，下一篇将带来numpy库的使用介绍。 |
|
|
