Python 基础

我是王大你是谁
354 阅读14分钟

Python安装

因为是 MAC 自带的 Python ，所以不需要安装，当然如果想安装可以参考官网安装的指南。

Python Releases for Mac OS X :

https://www.python.org/downloads/mac-osx/

使用下面的语句在 MAC 终端可以查看本机上的 Python 版本：

python -V

本节的代码都可以运行在 Anaconda 。

基本数据类型

Python3 中有常见的六种数据类型:

  • Number（数字）
  • String（字符串）
  • List（列表）
  • Tuple（元组）
  • Set（集合）
  • Dictionary（字典）

这六种数据类型可以分成以下两类：

  • 不可变数据：Number、String、Tuple
  • 可变数据：List、Dictionary、Set

Number

Python3 中支持 int、float、bool、complex。

>>> a, b, c, d = 2, 2.5, True, 2+2j
>>> print(type(a), type(b), type(c), type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

此外还可以用 isinstance 来判断数字类型。

>>>a = 10
>>> isinstance(a, int)
True

isinstance 和 type 的区别在于：

  • type() 不会认为子类是一种父类类型。
  • isinstance() 会认为子类是一种父类类型。

具体对比如下：

>>> class Father:
...     pass
... 
>>> class Son(Father):
...     pass
... 
>>> isinstance(Father(), Father)
True
>>> type(Father()) == Father 
True
>>> isinstance(Son(), Father)
True
>>> type(Son()) == Father
False

String

Python中的字符串用单引号 ' 或双引号 " 括起来，同时包含使用反斜杠 \ 转义特殊字符。设字符串长度为 n，索引值以 0 为开始值，一直到 以 n-1 为结束的索引值，反过来，以 -1 为从末尾的开始位置，一直到以 -（n-1） 为结束的索引值。字符串的截取的语法格式如下，不包括尾索引。

变量[头索引:尾索引]

字符串可以用 * 或者 + 进行操作，* 表示复制当前字符串，+ 表示和其他的字符串进行相连。

>>> s = 'wys'
>>> print (s)       	 # 输出字符串
wys
>>> print (s[0:2])	     # 输出第一个和第二个字符
wy
>>> print (s[1])        # 输出第二个字符
y
>>> print(s[-1])		 # 输出倒数第一个字符
s
>>> print (s * 2)       # 输出字符串两次
wyswys
>>> print (s + " haha") # 连接字符串
wys haha

Python 使用反斜杠( \ )转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串。

>>> print('w\nys')
w
ys
>>> print(r'w\nys')
w\nys

再次要强调的是字符串是不可变的数据类型，不要试图去修改，否则会报错。

>>> s = 'wys'
>>> s[0] = 'z'
TypeError                                 Traceback (most recent call last)
<ipython-input-474-83cdae0fbfb2> in <module>()
  	  1 s = 'wys'
----> 2 s[0] = 'z'

TypeError: 'str' object does not support item assignment

List

列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

列表是写在方括号 [] 之间、用逗号分隔开的元素列表。列表的索引和截取方式和 String 相同，这里不再赘述。

列表也可以通过 + 和 * 记性操作，原理和 String 类似，+ 表示连接其他的列表， * 表示重复列表内容，具体举例：

>>> l = [ 'a', 7, 2.2, [2]]
>>> l[0:2]
['a', 7]
>>> l + ['b']
['a', 7, 2.2, [2], 'b']
>>> l * 2
['a', 7, 2.2, [2], 'a', 7, 2.2, [2]]

与字符串不同的是，列表是可以改变元素的。

>>> l[0] = 'b'
>>> l
['b', 7, 2.2, [2]]

列表和字符串截取可以接收第三个参数，参数作用是截取的步长，如下举例：

>>> l[::2]
['a', 2.2]
>>> print(s[::2])
ws
>>> print(s[::-1])   # 使用此截取方式 [::-1] 相当于倒序输出结果
syw
>>> l[::-1]
[[2], 2.2, 7, 'a']

Tuple

元组（ Tuple ）与列表类似，不同之处在于元组的元素不能修改,否则会报错，元组写在小括号 () 里，元素之间用逗号隔开。元组中的元素类型也可以不相同。

Tuple 和 List 的操作基本相同。

>>> t = ( 'a', 6 , 2.2)
>>> print (t)  
('a', 6, 2.2)
>>> t[1:]
(6, 2.2)
>>> t * 2
('a', 6, 2.2, 'a', 6, 2.2)
>>> t + ('b',)		# 如果元组只有一个元素，需要加一个逗号，否则会被识别为字符串 'b'，而不是 ('b')
('a', 6, 2.2, 'b')

Set

集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。基本功能是进行成员关系测试和删除重复元素。

可以使用大括号 { } 或者 set() 函数创建集合，创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

>>> students = {'A', 'B', 'C'}
>>> print(students)
{'C', 'A', 'B'}
>>> students = {'A', 'B', 'C', 'A'}
>>> print(students)
{'C', 'A', 'B'}
>>> a = set('abab')
>>> b = set('acac')
>>> print(a)
>>> print(b)
{'a', 'b'}
{'a', 'c'}
>>> print(a - b)     # a 和 b 的差集
{'b'}
>>> print(a | b)     # a 和 b 的并集
{'a', 'b', 'c'}
>>> print(a & b)     # a 和 b 的交集
{'a'}
>>> print(a ^ b)     # a 和 b 中不同时存在的元素
{'b', 'c'}

Dictionary

列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典是一种映射类型，字典用 { } 标识，它是一个无序的 键 (key) : 值 (value) 的集合。

键 (key) 必须使用不可变类型。并且键 (key) 必须是唯一的。值 (value) 可以相同

>>> d = {}
>>> d['a'] = "wys"
>>> d[0]     = "wys" 
>>> print (d['a'])          	# 输出键为 'one' 的值
wys
>>> print (d[0])            	# 输出键为 2 的值
wys
>>> print (d)          			# 输出完整的字典
{'a': 'wys', 0: 'wys'}
>>> print (keys()) 		 	 	# 输出所有键
dict_keys(['a', 0])
>>> print (d.values()) 			# 输出所有值
dict_values(['wys', 'wys'])

Python 数据类型转换常见函数

函数 介绍
int(x [,base]) 将x转换为一个整数
float(x) 将x转换到一个浮点数
complex(real [,imag]) 创建一个复数
str(x) 将对象 x 转换为字符串
repr(x) 将对象 x 转换为表达式字符串
eval(str) 用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s) 将序列 s 转换为一个元组
list(s) 将序列 s 转换为一个列表
set(s) 转换为可变集合
dict(d) 创建一个字典。d 必须是一个 (key, value)元组序列。
frozenset(s) 转换为不可变集合
chr(x) 将一个整数转换为一个字符
ord(x) 将一个字符转换为它的整数值
hex(x) 将一个整数转换为一个十六进制字符串
oct(x) 将一个整数转换为一个八进制字符串

Python 控制语句

Python 的控制语句和大多数的编程语言类似，包括条件控制、循环控制等。

条件控制就是 if-else 语句，举例如下：

>>> age = 18
>>> if age < 0:
>>>     print("你是在逗我吧!")
>>> elif age < 12:
>>>     print("儿童")
>>> elif age < 18:
>>>     print("青少年")
>>> elif age >= 18:
>>>     print("成年人")
成年人

另外条件语句还可以嵌套。 循环语句主要用到 for 和 while，举例如下：

>>> for i in range(0, 10, 3) :
		print(i)
0
3
6
9
>>> count = 0
>>> while count < 2:
>>>     print (count, " 小于 2")
>>>     count = count + 1
>>> else:
>>>     print (count, " 大于或等于 2")
0  小于 2
1  小于 2
2  大于或等于 2

break 可以跳出循环体，如果从 for 或者 while 循环体中 break，任何对应的循环 else 块将不执行。

continue 语句被用来跳过当前循环块中的剩余语句，然后继续进行下一轮循环。

循环语句可以有 else 子句，它在穷尽列表(以for循环)或条件变为 false (以while循环)导致循环终止时被执行,但循环被break终止时不执行。

>>> for n in range(2, 10):
>>>     for x in range(2, n):
>>>         if n % x == 0:
>>>             print(n, '等于', x, '*', n//x)
>>>             break
>>>     else:
>>>         print(n, ' 是质数')

2  是质数
3  是质数
4 等于 2 * 2
5  是质数
6 等于 2 * 3
7  是质数
8 等于 2 * 4
9 等于 3 * 3

pass 语句是空语句，是为了保持程序结构的完整性。pass 不做任何事情，一般用做占位语句。

def func():
    pass

函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。函数能提高应用的模块性，和代码的重复利用率。除了使用许多内建函数，也可以自己创建函数，这被叫做用户自定义函数。

函数的规则一般如下：

* 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
* 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
* 函数内容以冒号起始，并且缩进。
* return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

定义一个函数就是给出函数一个名称，指定了函数里包含的参数，和代码块结构。一般的格式如下：

def 函数名（参数列表）:
    函数体
    
# 计算面积的函数，参数为长和宽
>>> def area(width, height):
>>>     return width * height

定义了函数之后，可以通过另一个函数调用执行，也可以直接执行。

>>> area(2,2)
4

python 函数的参数传递：

不可变类型：如整数、字符串、元组。如 fun(a)，传递的只是a的值，没有影响a对象本身。比如在 fun(a)内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。

>>> def ChangeInt( a ):
>>>     a = 10

>>> b = 2
>>> ChangeInt(b)
>>> print( b ) 
2

可变类型：如列表，字典。如 fun(la)，则是将 la 真正的传过去，修改后 fun 外部的 la 也会受影响，换句话说可变对象在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了。

>>> def changeme( mylist ):
>>>     mylist.append([1,2,3,4])
>>>     print ("函数内取值: ", mylist)
>>>     return
>>> mylist = [10,20,30]
>>> changeme( mylist )
>>> print ("函数外取值: ", mylist)
函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
函数外取值:  [10, 20, 30, [1, 2, 3, 4]]

注意！python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

以下是调用函数时可使用的正式参数类型：

  • 必需参数：必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

  • 关键字参数：关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。

  • 默认参数：调用函数时，如果没有传递参数，则会使用函数定义时的默认参数。

  • 不定长参数：可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。加了两个星号 ** 的参数会以字典的形式导入。

      >>> def printinfo( arg1, *vartuple ):
  >>>     print (arg1)
  >>>     print (vartuple)
  >>> printinfo( 70, 60, 50 )
  70
  (60, 50)
  

  >>> def printinfo( arg1, **vardict ):
  >>>     print (arg1)
  >>>     print (vardict)
  >>> printinfo(1, a=2,b=3)
  1
  {'a': 2, 'b': 3}

如果单独出现星号 * 后的参数必须用关键字传入。

	>>> def f(a,b,*,c):
	        return a+b+c 
	>>> f(1,2,3)   
	Traceback (most recent call last):
	  File "<stdin>", line 1, in <module>
	TypeError: f() takes 2 positional arguments but 3 were given
	>>> f(1,2,c=3) 
	6

python 使用 lambda 来创建匿名函数。所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

  • lambda 只是一个表达式，函数体比 def 简单很多。

  • lambda 的主体是一个表达式，而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。

  • lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。

  • 虽然 lambda 函数看起来只能写一行，却不等同于 C 或 C++ 的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

      >>> f = lambda arg1, arg2: arg1 + arg2
  >>> f(1,2)
  3

文件读写

在磁盘上读写文件的功能都是由操作系统提供的，现代操作系统不允许普通的程序直接操作磁盘，所以，读写文件就是请求操作系统打开一个文件对象（通常称为文件描述符），然后通过操作系统提供的接口从这个文件对象中读取数据（读文件），或者把数据写入这个文件对象（写文件）。

使用如下方法可以读文件的模式打开一个文件对象，如果文件不存在会报错，此种情况需要使用 try... finally 来解决。如果打开成功，可以用相关的方法进行读取内容到内存。

>>> f = open('/Users/wys/test.txt', 'r')
>>> f.read()
'Hello world'

最后一步是调用 close() 方法关闭文件。

>>> f.close()

使用以下方式进行写文件，和读文件类似，但是参数要变成 'w' 或者 'wb' 表示写文本文件或者写二进制文件。

>>> f = open('/Users/wys/test.txt', 'w')
>>> f.write('Hello, world!')
>>> f.close()

可以反复调用 write() 来写入文件，但是务必要调用 f.close() 来关闭文件。当我们写文件时，操作系统往往不会立刻把数据写入磁盘，而是放到内存缓存起来，空闲的时候再慢慢写入。只有调用 close() 方法时，操作系统才保证把没有写入的数据全部写入磁盘。忘记调用 close() 的后果是数据可能只写了一部分到磁盘，剩下的丢失了。用with语句来得保险，因为 Python 引入了 with 语句来自动帮我们调用 close() 方法。

>>> with open('/Users/michael/test.txt', 'w') as f:
>>>     f.write('Hello, world!')

要写入特定编码的文本文件，要给 open() 函数传入 encoding 参数，将字符串自动转换成指定编码。

还有很多的读写函数，请详见官网文档。

Pandas 的安装和使用

本机上的 Pandas 已经安装过了，如果安装直接执行下面的语句

>>> pip install pandas

一般 pandas 结合 numpy 使用，都可以安装到位。

在使用的时候就直接导包就可以了，如下：

>>> import pandas as pd
>>> import numpy as np

Pandas 的 Series 和 DataFrame

可以通过传入一个列表来创建 Series，如下：

>>> s = pd.Series([1, 3, 5, np.nan, 6, 8])
>>> s
0    1.0
1    3.0
2    5.0
3    NaN
4    6.0
5    8.0
dtype: float64

可以通过传入一个 NumPy 数组、一组datetime 索引以及一列标签来创建一个 DataFrame 。

>>> dates = pd.date_range('20130101', periods=6)
>>> df = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=list('ABCD'))
>>> df	


				A			B			C			D

2013-01-01	-0.993040	1.806758	0.950330	-0.600593
2013-01-02	0.609006	-0.846142	1.010976	-1.785051
2013-01-03	-1.005254	0.524503	0.254739	0.963432
2013-01-04	1.155407	-1.410927	-0.267786	-1.529697
2013-01-05	-0.072459	-0.146467	-0.998918	0.144397
2013-01-06	-0.714030	-0.349822	-0.967966	-0.565888

还可以通过传入一个字典来创造一个 DataFrame，字典中包含的对象能被转换成 Series 系列。

>>> df2 = pd.DataFrame({'A': 1.,
>>>         'B': pd.Timestamp('20130102'),
>>>         'C': pd.Series(1, index=list(range(4)), dtype='float32'),
>>>         'D': np.array([3] * 4, dtype='int32'),
>>>         'E': pd.Categorical(["test", "train", "test", "train"]),
>>>         'F': 'foo'})
     A          B    C  D      E    F
0  1.0 2013-01-02  1.0  3   test  foo
1  1.0 2013-01-02  1.0  3  train  foo
2  1.0 2013-01-02  1.0  3   test  foo
3  1.0 2013-01-02  1.0  3  train  foo

具体的 Pandas 对数据的操作请看官网文档。

对描述性数据分析的 Python 实现

本部分已经用 Python 手工实现过，这里不在赘述，请跳转页面。

本文参考

菜鸟：www.runoob.com/python3/pyt…

每日格言：常常是最终一把钥匙打开了门

请作者喝果粒橙 支付宝

支付宝

微信

微信

avatar
文章
阅读
粉丝