python与数据分析基础_数据分析之 Python 基础

基础知识

一、Python3 中有六个标准的数据类型：

Number(数字)

String(字符串)

List(列表)

Tuple(元组)

Set(集合)

Dictionary(字典)

二、Python3 的六个标准数据类型中：

不可变数据(3 个)：Number(数字)、String(字符串)、Tuple(元组)；

可变数据(3 个)：List(列表)、Dictionary(字典)、Set(集合)。

三、四种不同的数值类型

int(有符号整型)：在 64 位系统上，取值范围为 [-2^63 ~ 2^63-1]；

long(长整型，可代表八进制和十六进制)：没有指定位宽，即没有限制长整型数值的大小；

float(浮点型)：带有小数的数字，占 8 个字节(64 bit)，其中 52 位表示底，11 位表示指数，剩下的一位表示符号；

complex(复数)：由实数部分和虚数部分组成，一般形式为 x + yj，其中 x 为实数部分，y 为虚数部分。

四、变量赋值

赋值语句包含一个变量名，一个等号(称为赋值操作符)，以及要存储的值。Python 中的变量不需要声明数据类型，变量的类型是指内存中被赋值对象的类型。

五、变量赋值传递时的引用和拷贝

Python 赋值过程中不明确区分拷贝和引用时，一般对静态变量(不可变数据变量)的传递为拷贝，对动态变量(可变数据变量)的传递为引用。

## Tuple 与 Set

## Tuple 元祖与列表类似，不同之处在于元祖的元素不能修改。可以使用小括号创建元祖，里面的元素可以重复

## Set 是一个无序的不重复元素序列。可以使用大括号创建集合，往里添加的元素将会去重输出，使用 set() 可以转换其他数据类型为集合。

tup1 = ('physics', 'chemistry', 1997, 2000)

tup2 = (1, 2, 3, 3, 4, 5, 6, 7)

print("tup1[0]:", tup1[0])

print("tup2[1:5]:", tup2[1:5])

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}

print(basket)

print(set(tup2))

## 复数

aa = 123-12j

print(aa.real)

print(aa.imag)

## 拷贝(传值)与引用(传址)

dict = {'a': [1, 2, 3, 4, 5], 'b':2}

x = dict['a']

for i in range(5):

x[i] = 0

print(dict)

x = dict['b']

x = x+3

print(dict)

控制流

一、操作符

比较操作符：==，!=，，<=，>=，

布尔操作符：and，or，not

二、控制流语句

控制流语句会根据判断条件是 True 还是 False，来决定后面执行什么。有时候判断条件为某些特定值，如 0，0.0 和 ''(空字符串)等价于 False，其他值等价于 True

if-else

while(只要 while 语句的条件为 True，while 子句的代码就会一遍又一遍地执行)，可结合 break，continue，让执行提前跳出 while 循环子句.

break 是跳出整个循环

continue 是跳出本次循环并重新跳回到循环开始处

## while 循环

name = ''

while name != 'davidac':

print('Please type your name.')

name = input()

print('Thank you!')

while True:

print('Who are you?')

name = input()

if name != 'davidac':

continue

print('Hello, davidac. What is the password?')

password = input()

if password == '123':

break

print('Access granted.')

函数

一、def 语句

def 语句滞后的代码块是函数体，在函数调用时执行，而不是在函数第一次定义时执行。在代码中，函数调用就是函数名后跟上括号，如果需要参数，则把参数写在括号内。

二、返回值和 return 语句

return 语句指定应该返回什么值，可以返回特定值，也可以将返回值作为参数传递给另一个函数调用。

三、None 值

None 是 NoneType 数据类型的唯一值，必须大写首字母 N。对于没有 return 语句的函数定义，Python 都会在末尾加上 return None。如果函数里只有 return 关键字本身，那么就返回 None。

四、关键字参数

大多数参数是由他们在函数调用中的位置来识别的，但关键字参数是由调用时加在它们前面的额关键字来识别的。比如 print('cats', 'dogs', 'mice', sep=',')

五、局部和全局变量

在被调用函数内赋值的变元(参数赋值的变量)和变量，处于该函数的「局部作用域」，称为局部变量，在所有函数之外赋值的变量，属于「全局作用域」，被称为全局变量。

全局作用域的代码不能使用任何局部变量

局部作用域可以访问全局变量

一个函数的局部作用域中的代码不能使用其他局部作用域中的变量

避免局部变量与全局变量或其他局部变量同名

在一个函数中，一个变量要么总是全局变量，要么总是局部变量

六、global 语句

使用 global 语句，可以将函数内的变量修改为全局变量。

七、异常处理

错误可以由 try 和 except 语句来处理，那些可能出错的语句被放在 try 子句中，如果错误发生，程序执行就转到接下来的 except 子句开始处。此处若在 try 子句中的代码导致一个错误，会抛出 except 子句输出的错误信息，并继续往后执行。

列表与字典

一、列表操作

列表连接和列表复制：+，*

从列表删除值：使用 del 语句将列表中下标处的值删除，其后面的所有值，都将向前移动一个下标。

使用循环和 append() 将元素追加到空列表里

常用的 for 循环：[i for i in range(len(somelist))]

判断一个值是否在列表中：in 和 not in

多重赋值技巧：变量的数目和列表的长度必须严格相等

二、列表方法

index()：判断一个值是否在列表中，就返回它的下标，如果该值不存在，就报 ValueError

append()：将参数添加到列表末尾

insert()：第一个参数是新值的下标，第二个参数是要插入的新值

remove()：将列表中的值，若该值不在列表中，则报 ValueError，若该值在列表中出现多次，只会删除第一个。跟 del 语句相比，如果知道想要删除的值，则使用 remove()

sort()：对数值或字符串的列表进行排序，同样不能写成 spam = spam.sort()。

三、元祖

元祖数据类型几乎与列表数据类型一样，主要区别在于，元祖是不可变的，元祖不让它们的值被修改、添加或删除。如果元祖中只有一个值，可以在括号内该值的后面跟上一个逗号。如 ('hello',)

四、字典方法

keys()：返回字典的键

values()：返回字典的值

items()：返回字典的键-值对(元祖格式)

多重赋值：[k + ', ' + str(v) for k, v in spam.items()]

get()：有两个参数，一是要取的键，二是该键不存在时的备用键，如 str(picnicItem.get('cups', 0))

## 使用列表

catNames = []

while True:

print('Enter the name of cat' + str(len(catNames)) + '(Or enter nothing to stop.):')

name = input()

if name == '':

break

catNames.append(name)

print('The cat names are:')

for name in catNames:

print(' ' + name)

## 常用列表 for 循环(推导式)

catList = [str(i) + '_' + catNames[1] for i in range(len(catNames))]

print(catList)

## 多重赋值

cat = ['fat', 'black', 'loud']

size, color, disposition = cat

## append() 和 insert() 的返回值为 None

cat_spam = catList.append('Akira')

print(cat_spam)

## remove() 和 del

spam = ['cat', 'bat', 'rat', 'cat', 'hat', 'cat']

spam.remove('cat')

del spam[1]

spam

字符串操作

一、isX 字符串方法

isalpha()：如果字串符只包含字幕，并且非空，返回 True

isalnum()：如果字符串只包含数字和字母，并且非空，返回 True

isdecimal()：如果字符串只包含数字字符，并且非空，返回 True

isspace()：如果字符串只包含空格、制表符和换行，并且非空，返回 True

二、字符串连接和分割

join()：是在一个字符串上调用，参数是一个字符串列表，如 ','.join(['cats', 'rats', 'bats'])

split()：针对一个字符串，参数为分割字符，返回一个字符串列表

三、对齐

rjust()/ljust()/center()：第一个参数是一个整数长度，用于对齐字符串，默认为空格

四、删除空白字符

strip()：默认删除字符串头尾的空白字符，若传入字符串作为参数，则在字符串两端删除出现 a、m、p 和大写 S，字符的顺序并不重要，strip('ampS') 与 strip('mapS')，strip('Spam') 效果一样。

## 填充字符

'Hello'.rjust(10, '-')

'Hello'.center(20, '*')

## 删除空白字符

spam = 'SpamSpamBaconSpamEggSpamSpam'

spam.strip('Spma')

文件读写

一、文件路径

os.getcwd()：获取当前工作目录

os.makedirs()：创建新文件夹

os.path.abspath(path)：将相对路径转换为绝对路径的简便方法，返回参数的绝对路径的字符串

os.path.relpath(path, start)：将返回从 start 路径到 path 的相对路径的字符串

os.path.dirname(path)：返回最后一个斜杠之前的所有内容

os.path.basename(path)：返回最后一个斜杠之后的所有内容

str.split(os.path.sep)：返回一个列表，包含该路径的所有部分

os.path.getsize(path)：返回 path 参数中文件的字节数

os.listdir(path)：返回文件名字符串的列表

二、检查路径有效性

os.path.exists(path)：判断所指的文件或文件夹是否存在

os.path.isfile(path)：判断是否文件

os.path.isdir(path)：判断是否目录/文件夹

三、文件读写过程

三个步骤：

调用 open() 函数，返回一个 File 对象。

调用 File 对象的 read() 或 write() 方法

调用 File 对象的 close() 方法，关闭该文件

open() 需要指明读写模式

r(读)，r+(可读可写)，若文件不存在，均会报错不创建。

w(写)，w+(可读可写)，两者都会将文件内容清零，以 w 方式打开，不能读出。

a(追加)，a+(可读可写)

模式

可做操作

若文件不存在

是否覆盖

r

只能读

报错

-

r+

可读可写

报错

是

w

只能写

创建

是

w+

可读可写

创建

是

a

只能写

创建

否，追加写

a+

可读可写

创建

否，追加写

read()，readline() 与 readlines()

read()：从文件当前位置起读取 size 个字节，若无参数 size，则表示读取至文件结束为止，它范围为字符串对象。

readline()：每次读出文件的一行内容。

readlines()：从文件获得一个字符串列表，列表的每个字符串就是文本的每一行。

write()

对文件对象(可写模式)写入内容，在读取或写入文件后，需要调用 close() 方法，这样在下次读取时才能查看到新写入的内容。

## 路径方法

import os

print(os.getcwd()) ## /Users/davidaclee/OneDrive/Code/python/practice

print(os.path.relpath('/Users/davidaclee/OneDrive/', '.'))

print(os.path.dirname(os.getcwd())) ## /Users/davidaclee/OneDrive/Code/python/practice

print(os.path.basename(os.getcwd())) ## practice

calcFilePath = '/usr/local/hadoop/apache-hive-3.1.1-bin'

calcFilePath.split(os.path.sep)

print(os.path.getsize(calcFilePath))

print(os.listdir(calcFilePath))

totalSize = 0

for filename in os.listdir(calcFilePath):

if os.path.isfile(os.path.join(calcFilePath, filename)) == True:

totalSize = totalSize + os.path.getsize(os.path.join(calcFilePath, filename))

print(totalSize)

调试

一、抛出异常

抛出异常相当于是说：”停止运行这个函数中的代码，将程序执行转到 except 语句“。抛出异常使用 raise 语句，并对 Exception 函数进行调用，传递给 Exception 函数的字符串，作为报错信息。如果没有 try 和 except 语句覆盖抛出异常的 raise 语句，该程序就会崩溃，并显示异常的出错信息。

except Exception as err 如果 try 的子句返回一个 Exception 对象，这条语句就会将它保存在名为 err 的变量中，再使用 str(err) 将它转换成字符串，得到自定的出错信息。

二、断言

断言相当于是说：”我断言这个条件为真，如果不为真，程序中什么地方就有一个缺陷“。条件不成立，程序也不一定报错，但会让程序输出跟预期不一致的结果。所以通过这样快速的失败，能减少为了排查时间。

三、日志

记日志是一种很好的方式，可以理解程序中发生的事，以及事情发生的顺序。Python 的 logging 模块使得你很容易创建自定义的消息记录，并列出你指定的任意变量当时的值。另一方面，确实日志信息表明有一部分代码被跳过，从未执行。

虽然用 print() 也能输出每一个步骤的结果，但调试完成后，需要花很多时间从代码中清楚每条调试结果的 print() 调用，甚至有可能删除一些必要的 print() 调用。日志消息的好处是，可以随心所欲地在程序中加日志，随后只要调用一次 logging.disable(logging.CRITICAL)，就可以禁止日志。

四、日志级别

DEBUG - logging.debug()，最低级别，用于小细节，在诊断问题时才会关心这些消息

INFO - logging.info()，用于记录程序中一般事件的信息，或确认一切工作正常

WARNING - logging.warning()，用于表示可能的问题，它不会阻止程序的工作，但将来可能会

ERROR - logging.error()，用于记录错误，它导致程序失败

CRITICAL - logging.critical()，最高级别，用于表示致命的错误，它导致或将要导致程序完全停止工作

## 抛出异常

def boxPrint(symbol, width, height):

if len(symbol) != 1:

raise Exception('Symbol must be a single character string.')

if width <= 2:

raise Exception('Width must be greater than 2.')

if height <= 2:

raise Exception('Height must be greater than 2.')

print(symbol * width)

for i in range(height - 2):

print(symbol + (' ' * (width -2)) + symbol)

print(symbol * width)

for sym, w, h in (('*', 4, 4), ('0', 20, 5), ('x', 1, 3), ('ZZ', 3, 3)):

try:

boxPrint(sym, w, h)

except Exception as err:

print('An exception happened: ' + str(err))

## 断言

podBayDoorStatus = 'open'

assert podBayDoorStatus == 'open', 'The pod bay doors need to be "open".'

# podBayDoorStatus = "I'm sorry, Dave. I'm afraid I cant't do that."

# assert podBayDoorStatus == 'open', 'The pod bay doors need to be "open".'

## 日志

import logging

logging.basicConfig(level = logging.DEBUG, format = '%(asctime)s - %(levelname)s - %(message)s')

logging.debug('Start of program')

def factorial(n):

logging.debug('Start of factorial(%s)' % (n))

total = 1

for i in range(n + 1):

total *= i

logging.debug('i is '+ str(i) + ', total is ' + str(total))

logging.debug('End of factorial(%s)' % (n))

return total

print(factorial(5))

logging.debug('End of program')

## 禁用日志

import logging

logging.basicConfig(level=logging.INFO, format = '%(asctime)s - %(levelname)s - %(message)s')

# logging.critical('Critical error! Critical error!')

# logging.critical('Critical error! Critical error!')

logging.error('Error! Error!')