python快速入门—————附完整示例代码

0 背景

因为项目涉及到做数据分析，因此需要用到python，所以借此机会学习了一些基本的python语法，学习使用的参考书籍为《Head first of python》，该书以实际的小项目为指引，从中穿插各种基本语法，学习起来也不枯燥。 本文正是以参考书籍为大纲，展开的python常用语法总结。

1 基本概念和操作

1.1 概念

• 1，BIF(build in function)：也就是内置函数，不需要任何import模块，例如print函数；

• 2，目标标识符(target identifier)：变量或函数的名称；

• 3，变量不需要声明类型，编译器会自己做类型推导；

• 4，组(suit)：代码块，通过缩进指示分组，例如：

num = [1, 2, 3, 4]
for n in num:
	print(n) # 操作代码

• 5，大小写敏感；
• 6，在命令行中使用ctr/alt + p/n 查看前后指令；
• 7，字节码：文件后缀名为pyc，当你import自己写的模块时，为了防止Python每次运行时都重新解析源代码而生成的（防在__pycache__的子目录中），目的时加快程序运行；
  
• 8，查看模块的位置：

import sys
print(sys.path)

• 9,切片
  格式：[起始偏移量 start:终止偏移量 end[:步长 step]]
  注意：左封右开

name2 = 'qwer'
print(name2[0:2])
# 打印qw

• 10，打印模块中的所有变量和方法:

import  math
print(dir(math))

• 11，返回全局和局部命名空间里的名字

print(locals())
print(globals())

• 12，方法串链(从左到右)

data = ' 12345,789'
print(data.strip().split(',')) 

• 13，函数串链（从右到左）

data = [1, 5, 2, 4]
print(sorted(data))

• 14，工厂函数
  创建某种类型的新数据：

例如：

a = dict() # 创建字典类型数据

1.2 操作

name = ['江雪韩', 'hjx']
print(type(name))  # 查看数据类型
print(len(name))  # 查看长度
if isinstance(name, list): # 判断类型
	print("It's list")
print(id(name)) # 打印id
for i, n in enumerate(name):  # 列出数据和数据下标
    print('i: ' + str(i) + ' n:' + n)	
name2 = 'qwer'
for i in range(len(name2)): # 打印字符串 range(start,stop[,step]) 开始，结束，步长
    print(name2[i])    

2 基本数据结构

2.1 list（列表）

特点：可以存储任何类型的数据

[]

操作：

sch = []
sch.append("中科大") # 追加到列表末尾
sch.extend(["南大", "浙大"]) # 可迭代对象添加列表
sch.insert(1, "复旦") # 在第二个位置添加元素
sch.pop(1) # 在删除第二个元素
shc.remove('浙大') # 移除第一个出现的元素
shc.index('中科大') # 打印元素的位置
shc.count('中科大') # 获得指定元素在列表中出现的次数

2.2 tuple（元祖）

特点：不可改变,可以理解为常量类型的列表

（）

name = ('江雪')

2.3 dict（字典）：

特点：就像map一样，有键和值，一个键可以对应多个值

{}

操作

sch = {1:'南大', 2:'浙大'}
sch.keys() # 取出所有key值
sch.values() # 取出所有values值
#遍历键和值
for key,value in sch.items():
  print(str(key) + ": " + str(value))
# 按键排序
sch = sorted(sch.items(), key=lambda sch: sch[0])  # ,reverse=True 是否降序排列
sch = dict(sch) # 重现转为idct
# 按值排序
sch = sorted(sch.items(), key=lambda x: x[1], reverse=True) # reverse为是否降序排列
sch = dict(sch)

2.4 Set（集合）————字典的特殊形式

特点：只有键的字典，不能重复的且唯一

a = [1,2,3,1]
b = set(a) # 将列表、元组等可迭代对象转成集合

2.5 相互转换

列表转换（字典、元祖、集合）：

a = [5, 3, 2, 4, 2]
b = ['c', 'p', 'j']
c = dict(zip(a, b)) # 转字典
print(type(c), c)
d = tuple(a) # 转元祖
print(type(d), d)
e = set(a) # 转集合
print(type(e), e) # <class 'set'> {2, 3, 4, 5}

元祖转换（同上）：

a =(5, 3, 2, 4, 2)
b = ['c', 'p', 'j']
c = dict(zip(a, b)) # 转字典
print(type(c), c)
d = tuple(a) # 转元祖
print(type(d), d)
e = set(a) # 转集合
print(type(e), e) # <class 'set'> {2, 3, 4, 5}

字典转换(元祖、列表、集合)：

dict1 = {1:'a',2:'b',3:'c'}
print(list(dict1.keys()))
print(list(dict1.values()))
print(tuple(dict1.keys()))
print(tuple(dict1.values()))
print(set(dict1.keys()))
print(set(dict1.values()))
print(tuple(dict1.items()))  #生成元祖为单位的元祖
print(list(dict1.items())) #生成元祖为单位的列表
print(set(dict1.items()))   #生成元祖为单位的集合

3 条件、循环

3.1 条件(if)

格式：

if 条件:
	# 组
elif 条件：
	# 组	
else:
	# 组	

注意：使用not可以对条件取反

3.2 循环(while)

格式：

for 目标标识符 in 序列:
	# 组

4 函数（def）

作用：复用需要重复使用的代码
格式：

def 函数名 (参数列表)：
	函数方法

5 异常(try,exception,else,finally)

5.1 捕获处理异常

格式

try:
    # 捕捉异常
    # raise IOError
except IOError as err: # 异常发生时执行
	# 处理异常
    print('The file is not writting' + str(err))
    # 忽律异常
    pass # 空语句或null语句
else:
    print('没有异常发生')
   
finally: # 异常无论是否发生，都会执行
    print('finally')

5.2 抛出异常

raise [Exception [, args [, traceback]]]

语句中 Exception 是异常的类型（例如，NameError）参数标准异常中任一种，args 是自已提供的异常参数。

最后一个参数是可选的（在实践中很少使用），如果存在，是跟踪异常对象。

6 文件、数据管理

6. 1 使用with管理文件读入

不使用with读入语句：

try:
    data = open('/Users/mac/test.txt')
    print(data.readline(), end='')
except IOError as err:
     print('File Error: '+ str(err))
finally:
    if 'data' in locals(): # 如果文件被打开
        data.close()

使用上下文管理器with（不需要手动关闭打开的文件）:

try:
    #上下文管理
    with open('/Users/mac/数据科学/test.txt', 'a+') as data:
        print("It is...", file=data)
except IOError as err:
     print('File Error: '+ str(err))

6.2 打开文件的方法(r,r+,a,a+,w,w+)

默认的打开方式是r

""""
a,a+的方式打开文件，附加方式打开 
a：附加写方式打开，不可读；a+: 附加读写方式打开

w新建只写，w+新建读写，二者都会将文件内容清零，即事先不需要有该文件存在，若已经存在则会覆盖
w方式打开，不能读出;w+可读写

r只读，r+读写，不创建，即需要事先存在一个文件以供读/读写，若不存在文件会报错
"""""

6.3 进行文件写入和读出

例子：

import  sys
def test_print(the_list, f = sys.stdout):
    print(the_list, end='', file=f)

try:
    # 写文件
    with open('/Users/mac/PycharmProjects/hello/test3.txt', 'w') as file:
        test_print([1, 2, '3'], file)
    # 文件读出
    with open('/Users/mac/PycharmProjects/hello/test3.txt', 'r') as file:
        data = file.readline()
        print(data)
except IOError as err:
     print('File Error: '+ str(err))

6.4 使用pickle进行数据存储和读出

要求以二进制方法打开文件:

格式：

import pickle
try:
    # 写文件
    with open('/Users/mac/PycharmProjects/hello/test.pickle', 'wb') as data:
        pickle.dump([1, 2, 'a'], data)
    # 读文件
    with open('/Users/mac/PycharmProjects/hello/test.pickle', 'rb') as data:
        a_list = pickle.load(data)
    print(a_list)
except IOError as err:
     print('File Error: '+ str(err))

6.5 数据库

6.5.1 使用mysql数据库

import pymysql
try:
    conn = pymysql.connect(host='127.0.0.1', user='root', passwd='root', db='db_testAnalyzeData', port=9996, charset='utf8') # 连接数据库
    cur = conn.cursor() # 使用游标 
    try: # 执行sql语句
      cur.execute('SELECT  * FROM Customers')
      db.commit() # 提交修改
    except: # 出现错误，则回滚
        db.rollback()
    data = cur.fetchall() #返回多个元祖（多条记录）
    for d in data:
        print("cust_id: " + str(d[0]) + ' cust_name：' + d[2])
    cur.close() # 关闭游标
    conn.close() # 关闭数据库连接
except Exception:
    print('查询失败')

使用通配符：

cur.execute(
            "SELECT quantity,to_big_ratio,is_refund,create_time FROM trans_detail WHERE com_name = %s",
            (commodityName))

6.5.2 使用sqlite数据库

import  sqlite3
connection = sqlite3.connect('data.sqlite')
cursor = connection.cursor()
# 使用通配符
cursor.execute("INSERT INTO school(name, dob) VALUES (?,?)", (name, dob))
cursor.close()
connection.close()

7 类（class）

类的方法（method）：代码（共享）
类的属性（attribute）：数据（不贡献）
类的实例：实例化后的数据对象

7.1 基本类的创建

其中self为指向类的指针

# 类测试
class Athlete:
    # 构造函数
    def __init__(self, a_name, a_age = None, a_grade = dict()):
        self.name = a_name
        self.age = a_age
        self.grades = a_grade
    # 析构函数
    def __del__(self):
        self.name = ''
        self.age = 0
        self.grades = {}
    # 比较
    def __cmp__(self, other):
        if self.age > other.age:
            print('你有点年轻')
        elif self.age < other.age:
            print('你有点成熟')
        else:
            print('刚刚好')
    # 下面两个方法作用相同，都是打印类信息
    def __repr__(self):
        # 在命令端口输入对象名，也可以输出
        return ('Athlete Class：name、age、grades')
    def __str__(self):
        # 只能使用print(对象)
        grade = ''
        for key, value in self.grades.items():
            grade += str(key) + ':' + str(value)
        return (self.name + ' ' + str(self.age) + ' ' + grade)
    # 对字典进行操作
    def  __getitem__(self, key): # 返回字典值
        if key == '田径': return self.grades['田径']
        elif key == '游泳': return self.grades['游泳']
        elif key == '健身': return self.grades['健身']
        else: return 'unknown'
    def __setitem__(self, key, value): # 设置字典值
        self.grades[key] = value
    def __delitem__(self, key): # 删除字典值
        del self.grades[key]
a = Athlete('jiangxuehan', 42, {'田径':98, '游泳':82, '健身':90})
b = Athlete('james', 36, {'田径':90, '游泳':96, '健身':98})
a['田径'] = 92
del a['游泳']
print(a)
a.__cmp__(b)
a.__del__()
print(a)

__repr__和__str__的区别：

7.2 装饰器

7.2.1自带属性

7.2.1.1 property属性

使用了property属性的方法，调用时不需要加()，为的是提供更加友好访问类数据的方式。

class people:
    def __init__(self, name):
        self._name = name
        self._age = 20
    @property # 设置为属性
    def age(self):
        print('@property')
        return self._age
    @age.setter # 设置属性值
    def age(self, value):
        if not isinstance(value, int):
            raise ValueError('年龄非法')
        if value < 0 or value > 120:
            raise ValueError('年龄非法')
        self._age = value
    @age.getter # 返回属性值
    def age(self):
        print('@age.getter')
        return self._age
    @age.deleter # 删除属性值
    def age(self): # 删除后就找不到对象属性
        del self.age

p = people('james')
print(str(p.age))
people.age = 60
print(str(p.age))
del p.age
print(str(p.age)) # 因为属性被删，会报错，AttributeError: age

7.2.1.2 staticmethod和classmethod属性

共同点：

都可以通过不示例化类，就可以直接调用.

区别：

classmethod:由于默认传递了一个类的本身（cls），因此可以调用类中不需要示例化的方法和数据，用于初始化参数等用途。

staticmethod：节省开销。

class A():
    number = 0
    @staticmethod
    def static_test():
        print('static_test')
    @classmethod # 只在类中运行而不在实例中运行的方法
    def classmethod_test(cls): # 参数cls就是类本身
        print('classmethod_test')
        cls.number = 20
        cls.test() # 调用可以不示例化的方法
    def test():
        print('test')
    def print_number(self):
        print(str(self.number))
a = A()
a.print_number()
A.static_test()
A.classmethod_test()
# a.classmethod_test()
a.print_number()

7.2.2 自定义属性

作用：再不修改已有函数的前提下，扩充已有函数。

7.2.2.1 不带返回值、参数

调用的顺序为：run_time—>warp—>foo

import time

def run_time(func):
    def warp():
        start = time.time()
        temp = func()  # 执行函数
        end = time.time()
        print('程序执行时间: ',end - start)
    print('warp')    
    return warp

@run_time
def foo():
    print('hello')

foo()
# 等同与不用装饰器的foo
# foo = run_time(foo)
# foo()

7.2.2.2 带返回值、参数

用例：

import time

def run_time(func):
    def warp(*args, **kwargs):
        print(type(args)) # <class 'tuple'>
        print(type(kwargs)) # <class 'dict'>
        print(args) # foo的参数列表
        # ({'a': 1, 'b': 2, 'c': 3},)
        print(kwargs)
        # {'arg2': '1234', 'arg3': 'hahaha', 'arg4': 'lalalala'}
        start = time.time()
        temp = func(*args, **kwargs)  # 执行函数
        end = time.time()
        print('程序执行时间: ', end - start)
        return temp
    return warp

@run_time
def foo(n, **kwargs):
    temp_num = 2
    return(n['a'] + 1)*temp_num

print(str(foo({'a':1,'b':2,'c':3}, arg2 = '1234', arg3 = 'hahaha', arg4 = 'lalalala')))
# 等同与不用装饰器的foo
# foo = run_time(foo)
# foo()

*args：用于可变长参数；

**kwargs：用于键值参数。

def test_args(*args):
    print(type(args))
    print(args)
def test_kwargs(**kwargs):
    print(type(kwargs))
    print(kwargs)
test_args(1,2,'1231')
test_kwargs(arg1 = 1, arg2 = '12', arg3 = 'asdf')
# 输出：
# <class 'tuple'>
# (1, 2, '1231')
# <class 'dict'>
# {'arg1': 1, 'arg2': '12', 'arg3': 'asdf'}

7.3 继承

class A(list):
    def __init__(self, number):
        list.__init__([]) # 初始化父类
        self.number = number
        
a = A([1,2,3])
a.append(9)
print(a)

8 print使用

格式：

import sys
print(value, sep = '', end='\n', file = sys.stdout)

sep：

用来间隔多个对象，默认值是一个空格。也可以输入特定的值（符号、数字、中文都可）来间隔内容。
end：用来设定以什么结尾，默认值是换行符"\n"。也可以输入其他值来结尾。
file：输出的文件，默认为输出到屏幕。

测试：

a = 'qwer'
b = 2
print(a, b, sep=' | ',end='', file=open('test23.txt','w'))

9 排序

sort和sorted的区别：

sort():原地排序，对原始序列进行改变；

sorted():复制原始序列，对新序列进行排序，并返回，不会修改原始序列。

测试：

a = [1,5,4,2]
print(sorted(a)) # [1, 2, 4, 5]
print(a) # [1, 2, 4, 5]
a.sort()
print(a) # [1, 2, 4, 5]

10 模块

格式：

import 模块名
from 模块 import 函数

示例：

import math
from time import sleep
math.cos(2)
sleep(2) # 不使用包名

其他

Python目前存在的问题

GIL(Global Interpreter Lock，全局解释器锁)【CPython的产物】：多线程并发其实是单线程（伪并行）。只在IO密集型操作时，会得到较好的性能。

GIL解决办法：

• 1，通过多进程的方式绕过GIL；
• 2，使用C/C++来实现这部分代码，并生成对应的so或dll文件，再通过Python的ctypes来调用；
• 3，于IO密集型任务，使用协程（微线程）；
  • ：因为是单线程，不需要多线程的锁机制，省去线程切换的开销；